开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 查看源码
frame.c
资源名称：vlc-0.8.1.tar.gz　[点击查看]
上传用户：riyaled888
上传日期：2009-03-27
资源大小：7338k
文件大小：42k
源码类别：

多媒体

开发平台：

MultiPlatform

frame.c：源码内容
  1. /*****************************************************************************
  2.  * frame.c: MPEG2 video transrating module
  3.  *****************************************************************************
  4.  * Copyright (C) 2003-2004 VideoLAN
  5.  * Copyright (C) 2003 Antoine Missout <antoine.missout@metakine.com>
  6.  * Copyright (C) 2000-2003 Michel Lespinasse <walken@zoy.org>
  7.  * Copyright (C) 1999-2000 Aaron Holtzman <aholtzma@ess.engr.uvic.ca>
  8.  * $Id: frame.c 9038 2004-10-22 13:44:24Z massiot $
  9.  *
  10.  * Authors: Christophe Massiot <massiot@via.ecp.fr>
  11.  *          Laurent Aimar <fenrir@via.ecp.fr>
  12.  *          Antoine Missout <antoine.missout@metakine.com>
  13.  *          Michel Lespinasse <walken@zoy.org>
  14.  *          Aaron Holtzman <aholtzma@ess.engr.uvic.ca>
  15.  *
  16.  * This program is free software; you can redistribute it and/or modify
  17.  * it under the terms of the GNU General Public License as published by
  18.  * the Free Software Foundation; either version 2 of the License, or
  19.  * (at your option) any later version.
  20.  *
  21.  * This program is distributed in the hope that it will be useful,
  22.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  23.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  24.  * GNU General Public License for more details.
  25.  *
  26.  * You should have received a copy of the GNU General Public License
  27.  * along with this program; if not, write to the Free Software
  28.  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  29.  *****************************************************************************/
  31. /*****************************************************************************
  32.  * Preamble
  33.  *****************************************************************************/
  34. #include <stdio.h>
  35. #include <stdlib.h>
  36. #define NDEBUG 1
  37. #include <assert.h>
  38. #include <math.h>
  40. #include <vlc/vlc.h>
  41. #include <vlc/sout.h>
  42. #include <vlc/input.h>
  44. #include "transrate.h"
  46. /****************************************************************************
  47.  * transrater, code from M2VRequantizer http://www.metakine.com/
  48.  ****************************************************************************/
  50. // useful constants
  51. enum
  52. {
  53.     I_TYPE = 1,
  54.     P_TYPE = 2,
  55.     B_TYPE = 3
  56. };
  59. /////---- begin ext mpeg code
  61. #include "putvlc.h"
  63. #include "getvlc.h"
  65. static const int non_linear_quantizer_scale [] =
  66. {
  67.      0,  1,  2,  3,  4,  5,   6,   7,
  68.      8, 10, 12, 14, 16, 18,  20,  22,
  69.     24, 28, 32, 36, 40, 44,  48,  52,
  70.     56, 64, 72, 80, 88, 96, 104, 112
  71. };
  73. static inline int get_macroblock_modes( transrate_t *tr )
  74. {
  75.     bs_transrate_t *bs = &tr->bs;
  77.     int macroblock_modes;
  78.     const MBtab * tab;
  80.     switch( tr->picture_coding_type )
  81.     {
  82.         case I_TYPE:
  84.             tab = MB_I + UBITS (bs->i_bit_in_cache, 1);
  85.             bs_flush( bs, tab->len );
  86.             macroblock_modes = tab->modes;
  88.             if ((!(tr->frame_pred_frame_dct)) && (tr->picture_structure == FRAME_PICTURE))
  89.             {
  90.                 macroblock_modes |= UBITS (bs->i_bit_in_cache, 1) * DCT_TYPE_INTERLACED;
  91.                 bs_flush( bs, 1 );
  92.             }
  94.             return macroblock_modes;
  96.         case P_TYPE:
  98.             tab = MB_P + UBITS (bs->i_bit_in_cache, 5);
  99.             bs_flush( bs, tab->len );
  100.             macroblock_modes = tab->modes;
  102.             if (tr->picture_structure != FRAME_PICTURE)
  103.             {
  104.                 if (macroblock_modes & MACROBLOCK_MOTION_FORWARD)
  105.                 {
  106.                     macroblock_modes |= UBITS (bs->i_bit_in_cache, 2) * MOTION_TYPE_BASE;
  107.                     bs_flush( bs, 2 );
  108.                 }
  109.                 return macroblock_modes;
  110.             }
  111.             else if (tr->frame_pred_frame_dct)
  112.             {
  113.                 if (macroblock_modes & MACROBLOCK_MOTION_FORWARD)
  114.                     macroblock_modes |= MC_FRAME;
  115.                 return macroblock_modes;
  116.             }
  117.             else
  118.             {
  119.                 if (macroblock_modes & MACROBLOCK_MOTION_FORWARD)
  120.                 {
  121.                     macroblock_modes |= UBITS (bs->i_bit_in_cache, 2) * MOTION_TYPE_BASE;
  122.                     bs_flush( bs, 2 );
  123.                 }
  124.                 if (macroblock_modes & (MACROBLOCK_INTRA | MACROBLOCK_PATTERN))
  125.                 {
  126.                     macroblock_modes |= UBITS (bs->i_bit_in_cache, 1) * DCT_TYPE_INTERLACED;
  127.                     bs_flush( bs, 1 );
  128.                 }
  129.                 return macroblock_modes;
  130.             }
  132.         case B_TYPE:
  134.             tab = MB_B + UBITS (bs->i_bit_in_cache, 6);
  135.             bs_flush( bs, tab->len );
  136.             macroblock_modes = tab->modes;
  138.             if( tr->picture_structure != FRAME_PICTURE)
  139.             {
  140.                 if (! (macroblock_modes & MACROBLOCK_INTRA))
  141.                 {
  142.                     macroblock_modes |= UBITS (bs->i_bit_in_cache, 2) * MOTION_TYPE_BASE;
  143.                     bs_flush( bs, 2 );
  144.                 }
  145.                 return macroblock_modes;
  146.             }
  147.             else if (tr->frame_pred_frame_dct)
  148.             {
  149.                 /* if (! (macroblock_modes & MACROBLOCK_INTRA)) */
  150.                 macroblock_modes |= MC_FRAME;
  151.                 return macroblock_modes;
  152.             }
  153.             else
  154.             {
  155.                 if (macroblock_modes & MACROBLOCK_INTRA) goto intra;
  156.                 macroblock_modes |= UBITS (bs->i_bit_in_cache, 2) * MOTION_TYPE_BASE;
  157.                 bs_flush( bs, 2 );
  158.                 if (macroblock_modes & (MACROBLOCK_INTRA | MACROBLOCK_PATTERN))
  159.                 {
  160.                     intra:
  161.                     macroblock_modes |= UBITS (bs->i_bit_in_cache, 1) * DCT_TYPE_INTERLACED;
  162.                     bs_flush( bs, 1 );
  163.                 }
  164.                 return macroblock_modes;
  165.             }
  167.         default:
  168.             return 0;
  169.     }
  171. }
  173. static inline int get_quantizer_scale( transrate_t *tr )
  174. {
  175.     bs_transrate_t *bs = &tr->bs;
  177.     int quantizer_scale_code;
  179.     quantizer_scale_code = UBITS (bs->i_bit_in_cache, 5);
  180.     bs_flush( bs, 5 );
  182.     if( tr->q_scale_type )
  183.         return non_linear_quantizer_scale[quantizer_scale_code];
  184.     else
  185.         return quantizer_scale_code << 1;
  186. }
  188. static inline int get_motion_delta( bs_transrate_t *bs, const int f_code )
  189. {
  190.     int delta;
  191.     int sign;
  192.     const MVtab * tab;
  194.     if (bs->i_bit_in_cache & 0x80000000)
  195.     {
  196.         bs_copy( bs, 1 );
  197.         return 0;
  198.     }
  199.     else if (bs->i_bit_in_cache >= 0x0c000000)
  200.     {
  202.         tab = MV_4 + UBITS (bs->i_bit_in_cache, 4);
  203.         delta = (tab->delta << f_code) + 1;
  204.         bs_copy( bs, tab->len);
  206.         sign = SBITS (bs->i_bit_in_cache, 1);
  207.         bs_copy( bs, 1 );
  209.         if (f_code)
  210.         {
  211.             delta += UBITS (bs->i_bit_in_cache, f_code);
  212.             bs_copy( bs, f_code);
  213.         }
  215.         return (delta ^ sign) - sign;
  216.     }
  217.     else
  218.     {
  220.         tab = MV_10 + UBITS (bs->i_bit_in_cache, 10);
  221.         delta = (tab->delta << f_code) + 1;
  222.         bs_copy( bs, tab->len);
  224.         sign = SBITS (bs->i_bit_in_cache, 1);
  225.         bs_copy( bs, 1);
  227.         if (f_code)
  228.         {
  229.             delta += UBITS (bs->i_bit_in_cache, f_code);
  230.             bs_copy( bs, f_code);
  231.         }
  233.         return (delta ^ sign) - sign;
  234.     }
  235. }
  238. static inline int get_dmv( bs_transrate_t *bs )
  239. {
  240.     const DMVtab * tab;
  242.     tab = DMV_2 + UBITS (bs->i_bit_in_cache, 2);
  243.     bs_copy( bs, tab->len);
  244.     return tab->dmv;
  245. }
  247. static inline int get_coded_block_pattern( bs_transrate_t *bs )
  248. {
  249.     const CBPtab * tab;
  251.     if (bs->i_bit_in_cache >= 0x20000000)
  252.     {
  253.         tab = CBP_7 + (UBITS (bs->i_bit_in_cache, 7) - 16);
  254.         bs_flush( bs, tab->len );
  255.         return tab->cbp;
  256.     }
  257.     else
  258.     {
  259.         tab = CBP_9 + UBITS (bs->i_bit_in_cache, 9);
  260.         bs_flush( bs, tab->len );
  261.         return tab->cbp;
  262.     }
  263. }
  265. static inline int get_luma_dc_dct_diff( bs_transrate_t *bs, uint32_t *bits, uint8_t *len )
  266. {
  267.     const DCtab * tab;
  268.     int size;
  269.     int dc_diff;
  271.     if (bs->i_bit_in_cache < 0xf8000000)
  272.     {
  273.         tab = DC_lum_5 + UBITS (bs->i_bit_in_cache, 5);
  274.         size = tab->size;
  275.         if (size)
  276.         {
  277.             *bits = bs_read( bs, tab->len );
  278.             *len = tab->len;
  279.             //dc_diff = UBITS (bs->i_bit_in_cache, size) - UBITS (SBITS (~bs->i_bit_in_cache, 1), size);
  280.             dc_diff = UBITS (bs->i_bit_in_cache, size);
  281.             if (!(dc_diff >> (size - 1))) dc_diff = (dc_diff + 1) - (1 << size);
  282.             *bits <<= size;
  283.             *bits |= bs_read( bs, size );
  284.             *len += size;
  285.             return dc_diff;
  286.         }
  287.         else
  288.         {
  289.             *bits = bs_read( bs, 3 );
  290.             *len = 3;
  291.             return 0;
  292.         }
  293.     }
  294.     else
  295.     {
  296.         tab = DC_long + (UBITS (bs->i_bit_in_cache, 9) - 0x1e0);
  297.         size = tab->size;
  298.         *bits = bs_read( bs, tab->len );
  299.         *len = tab->len;
  300.         //dc_diff = UBITS (bs->i_bit_in_cache, size) - UBITS (SBITS (~bs->i_bit_in_cache, 1), size);
  301.         dc_diff = UBITS (bs->i_bit_in_cache, size);
  302.         if (!(dc_diff >> (size - 1))) dc_diff = (dc_diff + 1) - (1 << size);
  303.         *bits <<= size;
  304.         *bits |= bs_read( bs, size );
  305.         *len += size;
  306.         return dc_diff;
  307.     }
  308. }
  310. static inline int get_chroma_dc_dct_diff( bs_transrate_t *bs, uint32_t *bits, uint8_t *len )
  311. {
  312.     const DCtab * tab;
  313.     int size;
  314.     int dc_diff;
  316.     if (bs->i_bit_in_cache < 0xf8000000)
  317.     {
  318.         tab = DC_chrom_5 + UBITS (bs->i_bit_in_cache, 5);
  319.         size = tab->size;
  320.         if (size)
  321.         {
  322.             *bits = bs_read( bs, tab->len );
  323.             *len = tab->len;
  324.             //dc_diff = UBITS (bs->i_bit_in_cache, size) - UBITS (SBITS (~bs->i_bit_in_cache, 1), size);
  325.             dc_diff = UBITS (bs->i_bit_in_cache, size);
  326.             if (!(dc_diff >> (size - 1))) dc_diff = (dc_diff + 1) - (1 << size);
  327.             *bits <<= size;
  328.             *bits |= bs_read( bs, size );
  329.             *len += size;
  330.             return dc_diff;
  331.         }
  332.         else
  333.         {
  334.             *bits = bs_read( bs, 2 );
  335.             *len = 2;
  336.             return 0;
  337.         }
  338.     }
  339.     else
  340.     {
  341.         tab = DC_long + (UBITS (bs->i_bit_in_cache, 10) - 0x3e0);
  342.         size = tab->size;
  343.         *bits = bs_read( bs, tab->len + 1 );
  344.         *len = tab->len + 1;
  345.         //dc_diff = UBITS (bs->i_bit_in_cache, size) - UBITS (SBITS (~bs->i_bit_in_cache, 1), size);
  346.         dc_diff = UBITS (bs->i_bit_in_cache, size);
  347.         if (!(dc_diff >> (size - 1))) dc_diff = (dc_diff + 1) - (1 << size);
  348.         *bits <<= size;
  349.         *bits |= bs_read( bs, size );
  350.         *len += size;
  351.         return dc_diff;
  352.     }
  353. }
  355. static void motion_fr_frame( bs_transrate_t *bs, unsigned int f_code[2] )
  356. {
  357.     get_motion_delta( bs, f_code[0] );
  358.     get_motion_delta( bs, f_code[1] );
  359. }
  361. static void motion_fr_field( bs_transrate_t *bs, unsigned int f_code[2] )
  362. {
  363.     bs_copy( bs, 1);
  365.     get_motion_delta( bs, f_code[0]);
  366.     get_motion_delta( bs, f_code[1]);
  368.     bs_copy( bs, 1);
  370.     get_motion_delta( bs, f_code[0]);
  371.     get_motion_delta( bs, f_code[1]);
  372. }
  374. static void motion_fr_dmv( bs_transrate_t *bs, unsigned int f_code[2] )
  375. {
  376.     get_motion_delta( bs, f_code[0]);
  377.     get_dmv( bs );
  379.     get_motion_delta( bs, f_code[1]);
  380.     get_dmv( bs );
  381. }
  383. static void motion_fi_field( bs_transrate_t *bs, unsigned int f_code[2] )
  384. {
  385.     bs_copy( bs, 1);
  387.     get_motion_delta( bs, f_code[0]);
  388.     get_motion_delta( bs, f_code[1]);
  389. }
  391. static void motion_fi_16x8( bs_transrate_t *bs, unsigned int f_code[2] )
  392. {
  393.     bs_copy( bs, 1);
  395.     get_motion_delta( bs, f_code[0]);
  396.     get_motion_delta( bs, f_code[1]);
  398.     bs_copy( bs, 1);
  400.     get_motion_delta( bs, f_code[0]);
  401.     get_motion_delta( bs, f_code[1]);
  402. }
  404. static void motion_fi_dmv( bs_transrate_t *bs, unsigned int f_code[2] )
  405. {
  406.     get_motion_delta( bs, f_code[0]);
  407.     get_dmv( bs );
  409.     get_motion_delta( bs, f_code[1]);
  410.     get_dmv( bs );
  411. }
  414. #define MOTION_CALL(routine,direction)                      
  415. do {                                                        
  416.     if ((direction) & MACROBLOCK_MOTION_FORWARD)            
  417.         routine( bs, tr->f_code[0]);                        
  418.     if ((direction) & MACROBLOCK_MOTION_BACKWARD)           
  419.         routine( bs, tr->f_code[1]);                        
  420. } while (0)
  422. #define NEXT_MACROBLOCK                                         
  423. do {                                                            
  424.     tr->h_offset += 16;                                         
  425.     if( tr->h_offset == tr->horizontal_size_value)              
  426.     {                                                           
  427.         tr->v_offset += 16;                                         
  428.         if (tr->v_offset > (tr->vertical_size_value - 16)) return;      
  429.         tr->h_offset = 0;                                       
  430.     }                                                           
  431. } while (0)
  433. static void putmbdata( transrate_t *tr, int macroblock_modes )
  434. {
  435.     bs_transrate_t *bs = &tr->bs;
  437.     bs_write( bs,
  438.               mbtypetab[tr->picture_coding_type-1][macroblock_modes&0x1F].code,
  439.               mbtypetab[tr->picture_coding_type-1][macroblock_modes&0x1F].len);
  441.     switch ( tr->picture_coding_type )
  442.     {
  443.         case I_TYPE:
  444.             if ((! (tr->frame_pred_frame_dct)) && (tr->picture_structure == FRAME_PICTURE))
  445.                 bs_write( bs, macroblock_modes & DCT_TYPE_INTERLACED ? 1 : 0, 1);
  446.             break;
  448.         case P_TYPE:
  449.             if (tr->picture_structure != FRAME_PICTURE)
  450.             {
  451.                 if (macroblock_modes & MACROBLOCK_MOTION_FORWARD)
  452.                     bs_write( bs, (macroblock_modes & MOTION_TYPE_MASK) / MOTION_TYPE_BASE, 2);
  453.                 break;
  454.             }
  455.             else if (tr->frame_pred_frame_dct) break;
  456.             else
  457.             {
  458.                 if (macroblock_modes & MACROBLOCK_MOTION_FORWARD)
  459.                     bs_write( bs, (macroblock_modes & MOTION_TYPE_MASK) / MOTION_TYPE_BASE, 2);
  460.                 if (macroblock_modes & (MACROBLOCK_INTRA | MACROBLOCK_PATTERN))
  461.                     bs_write( bs, macroblock_modes & DCT_TYPE_INTERLACED ? 1 : 0, 1);
  462.                 break;
  463.             }
  465.         case B_TYPE:
  466.             if (tr->picture_structure != FRAME_PICTURE)
  467.             {
  468.                 if (! (macroblock_modes & MACROBLOCK_INTRA))
  469.                     bs_write( bs, (macroblock_modes & MOTION_TYPE_MASK) / MOTION_TYPE_BASE, 2);
  470.                 break;
  471.             }
  472.             else if (tr->frame_pred_frame_dct) break;
  473.             else
  474.             {
  475.                 if (macroblock_modes & MACROBLOCK_INTRA) goto intra;
  476.                 bs_write( bs, (macroblock_modes & MOTION_TYPE_MASK) / MOTION_TYPE_BASE, 2);
  477.                 if (macroblock_modes & (MACROBLOCK_INTRA | MACROBLOCK_PATTERN))
  478.                 {
  479.                     intra:
  480.                     bs_write( bs, macroblock_modes & DCT_TYPE_INTERLACED ? 1 : 0, 1);
  481.                 }
  482.                 break;
  483.             }
  484.     }
  485. }
  487. static const uint8_t map_non_linear_mquant[113] =
  488. {
  489.     0,1,2,3,4,5,6,7,8,8,9,9,10,10,11,11,12,12,13,13,14,14,15,15,16,16,
  490.     16,17,17,17,18,18,18,18,19,19,19,19,20,20,20,20,21,21,21,21,22,22,
  491.     22,22,23,23,23,23,24,24,24,24,24,24,24,25,25,25,25,25,25,25,26,26,
  492.     26,26,26,26,26,26,27,27,27,27,27,27,27,27,28,28,28,28,28,28,28,29,
  493.     29,29,29,29,29,29,29,29,29,30,30,30,30,30,30,30,31,31,31,31,31
  494. };
  495. static inline void put_quantiser( transrate_t *tr )
  496. {
  497.     bs_transrate_t *bs = &tr->bs;
  499.     bs_write( bs, tr->q_scale_type ? map_non_linear_mquant[tr->new_quantizer_scale] : tr->new_quantizer_scale >> 1, 5 );
  500.     tr->last_coded_scale = tr->new_quantizer_scale;
  501. }
  503. /* generate variable length code for macroblock_address_increment (6.3.16) */
  504. static inline void putaddrinc( transrate_t *tr, int addrinc )
  505. {
  506.     bs_transrate_t *bs = &tr->bs;
  508.     while ( addrinc >= 33 )
  509.     {
  510.         bs_write( bs, 0x08, 11 ); /* macroblock_escape */
  511.         addrinc -= 33;
  512.     }
  514.     bs_write( bs, addrinctab[addrinc].code, addrinctab[addrinc].len );
  515. }
  517. static int slice_init( transrate_t *tr,  int code )
  518. {
  519.     bs_transrate_t *bs = &tr->bs;
  520.     int offset;
  521.     const MBAtab * mba;
  523.     tr->v_offset = (code - 1) * 16;
  525.     tr->quantizer_scale = get_quantizer_scale( tr );
  526.     if ( tr->new_quantizer_scale < tr->quantizer_scale )
  527.         tr->new_quantizer_scale = scale_quant( tr, tr->qrate );
  529.     /*LOGF("************************nstart of slice %i in %s picture. ori quant: %i new quant: %in", code,
  530.         (picture_coding_type == I_TYPE ? "I_TYPE" : (picture_coding_type == P_TYPE ? "P_TYPE" : "B_TYPE")),
  531.         quantizer_scale, new_quantizer_scale);*/
  533.     /* ignore intra_slice and all the extra data */
  534.     while (bs->i_bit_in_cache & 0x80000000)
  535.     {
  536.         bs_flush( bs, 9 );
  537.     }
  539.     /* decode initial macroblock address increment */
  540.     offset = 0;
  541.     for( ;; )
  542.     {
  543.         if (bs->i_bit_in_cache >= 0x08000000)
  544.         {
  545.             mba = MBA_5 + (UBITS (bs->i_bit_in_cache, 6) - 2);
  546.             break;
  547.         }
  548.         else if (bs->i_bit_in_cache >= 0x01800000)
  549.         {
  550.             mba = MBA_11 + (UBITS (bs->i_bit_in_cache, 12) - 24);
  551.             break;
  552.         }
  553.         else if( UBITS (bs->i_bit_in_cache, 12 ) == 8 )
  554.         {
  555.             /* macroblock_escape */
  556.             offset += 33;
  557.             bs_flush(bs, 11);
  558.         }
  559.         else
  560.         {
  561.             return -1;
  562.         }
  563.     }
  565.     bs_flush(bs, mba->len + 1);
  566.     tr->h_offset = (offset + mba->mba) << 4;
  568.     while( tr->h_offset - (int)tr->horizontal_size_value >= 0)
  569.     {
  570.         tr->h_offset -= tr->horizontal_size_value;
  571.         tr->v_offset += 16;
  572.     }
  574.     if( tr->v_offset > tr->vertical_size_value - 16 )
  575.     {
  576.         return -1;
  577.     }
  578.     return (offset + mba->mba);
  579. }
  581. static void mpeg2_slice( transrate_t *tr, const int code )
  582. {
  583.     bs_transrate_t *bs = &tr->bs;
  584.     int mba_inc;
  585.     int first_in_slice = 1;
  587.     if( (mba_inc = slice_init( tr, code )) < 0 )
  588.     {
  589.         return;
  590.     }
  592.     for( ;; )
  593.     {
  594.         const MBAtab * mba;
  595.         int macroblock_modes;
  596.         int mba_local;
  597.         int i;
  599.         while (unlikely(bs->i_bit_in < 24)) bs_refill( bs );
  601.         macroblock_modes = get_macroblock_modes( tr );
  602.         if (macroblock_modes & MACROBLOCK_QUANT)
  603.             tr->quantizer_scale = get_quantizer_scale( tr );
  604.         if (tr->new_quantizer_scale < tr->quantizer_scale)
  605.             tr->new_quantizer_scale = scale_quant( tr, tr->qrate );
  607.         //LOGF("blk %i : ", h_offset >> 4);
  609.         if (macroblock_modes & MACROBLOCK_INTRA)
  610.         {
  611.             RunLevel block[6][65]; // terminated by level = 0, so we need 64+1
  612.             RunLevel new_block[6][65]; // terminated by level = 0, so we need 64+1
  613.             uint32_t dc[6];
  614.             uint8_t  dc_len[6];
  616.             // begin saving data
  617.             int batb;
  618.             uint8_t   p_n_ow[32], *p_n_w,
  619.                     *p_o_ow = bs->p_ow, *p_o_w = bs->p_w;
  620.             uint32_t  i_n_bit_out, i_n_bit_out_cache,
  621.                     i_o_bit_out  = bs->i_bit_out, i_o_bit_out_cache = bs->i_bit_out_cache;
  623.             bs->i_bit_out_cache = 0; bs->i_bit_out = BITS_IN_BUF;
  624.             bs->p_ow = bs->p_w = p_n_ow;
  626.             //LOG("intra "); if (macroblock_modes & MACROBLOCK_QUANT) LOGF("got new quant: %i ", quantizer_scale);
  628.             if (tr->concealment_motion_vectors)
  629.             {
  630.                 if (tr->picture_structure != FRAME_PICTURE)
  631.                 {
  632.                     bs_copy(bs, 1); /* remove field_select */
  633.                 }
  634.                 /* like motion_frame, but parsing without actual motion compensation */
  635.                 get_motion_delta(bs, tr->f_code[0][0]);
  636.                 get_motion_delta(bs, tr->f_code[0][1]);
  638.                 bs_copy(bs, 1); /* remove marker_bit */
  639.             }
  641.             assert(bs->p_w - bs->p_ow < 32);
  643.             p_n_w = bs->p_w;
  644.             i_n_bit_out = bs->i_bit_out;
  645.             i_n_bit_out_cache = bs->i_bit_out_cache;
  646.             assert(bs->p_ow == p_n_ow);
  648.             bs->i_bit_out = i_o_bit_out ;
  649.             bs->i_bit_out_cache = i_o_bit_out_cache;
  650.             bs->p_ow = p_o_ow;
  651.             bs->p_w = p_o_w;
  652.             // end saving data
  654.             if( tr->intra_vlc_format )
  655.             {
  656.                 /* Luma */
  657.                 for ( i = 0; i < 4; i++ )
  658.                 {
  659.                     get_luma_dc_dct_diff( bs, dc + i, dc_len + i );
  660.                     get_intra_block_B15( tr, block[i] );
  661.                     if (tr->b_error) return;
  662.                 }
  663.                 /* Chroma */
  664.                 for ( ; i < 6; i++ )
  665.                 {
  666.                     get_chroma_dc_dct_diff( bs, dc + i, dc_len + i );
  667.                     get_intra_block_B15( tr, block[i] );
  668.                     if (tr->b_error) return;
  669.                 }
  670.             }
  671.             else
  672.             {
  673.                 /* Luma */
  674.                 for ( i = 0; i < 4; i++ )
  675.                 {
  676.                     get_luma_dc_dct_diff( bs, dc + i, dc_len + i );
  677.                     get_intra_block_B14( tr, block[i] );
  678.                     if (tr->b_error) return;
  679.                 }
  680.                 /* Chroma */
  681.                 for ( ; i < 6; i++ )
  682.                 {
  683.                     get_chroma_dc_dct_diff( bs, dc + i, dc_len + i );
  684.                     get_intra_block_B14( tr, block[i] );
  685.                     if (tr->b_error) return;
  686.                 }
  687.             }
  689.             transrate_mb( tr, block, new_block, 0x3f, 1 );
  691.             if (tr->last_coded_scale == tr->new_quantizer_scale)
  692.                 macroblock_modes &= ~MACROBLOCK_QUANT;
  694.             if ( first_in_slice )
  695.             {
  696.                 put_quantiser( tr );
  697.                 bs_write( bs, 0, 1 );
  698.                 macroblock_modes &= ~MACROBLOCK_QUANT;
  699.             }
  700.             putaddrinc( tr, mba_inc );
  701.             mba_inc = 0;
  702.             putmbdata( tr, macroblock_modes );
  703.             if( macroblock_modes & MACROBLOCK_QUANT )
  704.             {
  705.                 put_quantiser( tr );
  706.             }
  708.             // put saved motion data...
  709.             for (batb = 0; batb < (p_n_w - p_n_ow); batb++)
  710.             {
  711.                 bs_write( bs, p_n_ow[batb], 8 );
  712.             }
  713.             bs_write( bs, i_n_bit_out_cache, BITS_IN_BUF - i_n_bit_out );
  714.             // end saved motion data...
  716.             for ( i = 0; i < 6; i++ )
  717.             {
  718.                 bs_write( bs, *(dc + i), *(dc_len + i) );
  719.                 putintrablk( bs, new_block[i], tr->intra_vlc_format );
  720.             }
  721.     
  722.         }
  723.         else
  724.         {
  725.             RunLevel block[6][65]; // terminated by level = 0, so we need 64+1
  726.             RunLevel new_block[6][65]; // terminated by level = 0, so we need 64+1
  727.             int new_coded_block_pattern = 0;
  728.             int cbp = 0;
  730.             // begin saving data
  731.             int batb;
  732.             uint8_t   p_n_ow[32], *p_n_w,
  733.                     *p_o_ow = bs->p_ow, *p_o_w = bs->p_w;
  734.             uint32_t  i_n_bit_out, i_n_bit_out_cache,
  735.                     i_o_bit_out  = bs->i_bit_out, i_o_bit_out_cache = bs->i_bit_out_cache;
  737.             bs->i_bit_out_cache = 0; bs->i_bit_out = BITS_IN_BUF;
  738.             bs->p_ow = bs->p_w = p_n_ow;
  740.             if (tr->picture_structure == FRAME_PICTURE)
  741.                 switch (macroblock_modes & MOTION_TYPE_MASK)
  742.                 {
  743.                     case MC_FRAME: MOTION_CALL (motion_fr_frame, macroblock_modes); break;
  744.                     case MC_FIELD: MOTION_CALL (motion_fr_field, macroblock_modes); break;
  745.                     case MC_DMV: MOTION_CALL (motion_fr_dmv, MACROBLOCK_MOTION_FORWARD); break;
  746.                 }
  747.             else
  748.                 switch (macroblock_modes & MOTION_TYPE_MASK)
  749.                 {
  750.                     case MC_FIELD: MOTION_CALL (motion_fi_field, macroblock_modes); break;
  751.                     case MC_16X8: MOTION_CALL (motion_fi_16x8, macroblock_modes); break;
  752.                     case MC_DMV: MOTION_CALL (motion_fi_dmv, MACROBLOCK_MOTION_FORWARD); break;
  753.                 }
  755.             //LOG("non intra "); if (macroblock_modes & MACROBLOCK_QUANT) LOGF("got new quant: %i ", quantizer_scale);
  757.             if (macroblock_modes & MACROBLOCK_PATTERN)
  758.             {
  759.                 int last_in_slice;
  761.                 cbp = get_coded_block_pattern( bs );
  763.                 for ( i = 0; i < 6; i++ )
  764.                 {
  765.                     if ( cbp & (1 << (5 - i)) )
  766.                     {
  767.                         get_non_intra_block( tr, block[i] );
  768.                         if (tr->b_error) return;
  769.                     }
  770.                 }
  771.                 last_in_slice = !UBITS( bs->i_bit_in_cache, 11 );
  773.                 new_coded_block_pattern = transrate_mb( tr, block, new_block,
  774.                                                         cbp, 0 );
  776.                 if ( !new_coded_block_pattern &&
  777.                         !(macroblock_modes
  778.                             & (MACROBLOCK_MOTION_FORWARD
  779.                                 | MACROBLOCK_MOTION_BACKWARD))
  780.                         && (first_in_slice || last_in_slice) )
  781.                 {
  782.                     /* First mb in slice, just code a 0-mv mb.
  783.                      * This is wrong for last in slice, but it only shows
  784.                      * a few artefacts. */
  785.                     macroblock_modes |= MACROBLOCK_MOTION_FORWARD;
  786.                     if (tr->picture_structure == FRAME_PICTURE)
  787.                     {
  788.                         macroblock_modes |= MC_FRAME;
  789.                         bs_write( bs, 0x3, 2 ); /* motion vectors */
  790.                     }
  791.                     else
  792.                     {
  793.                         macroblock_modes |= MC_FIELD;
  794.                         bs_write( bs,
  795.                              (tr->picture_structure == BOTTOM_FIELD ? 1 : 0),
  796.                              1); /* motion field select */
  797.                         bs_write( bs, 0x3, 2 ); /* motion vectors */
  798.                     }
  799.                 }
  801.                 if ( !new_coded_block_pattern )
  802.                 {
  803.                     macroblock_modes &= ~MACROBLOCK_PATTERN;
  804.                     macroblock_modes &= ~MACROBLOCK_QUANT;
  805.                 }
  806.                 else
  807.                 {
  808.                     if ( tr->last_coded_scale == tr->new_quantizer_scale )
  809.                     {
  810.                         macroblock_modes &= ~MACROBLOCK_QUANT;
  811.                     }
  812.                     else
  813.                     {
  814.                         macroblock_modes |= MACROBLOCK_QUANT;
  815.                     }
  816.                 }
  817.             }
  819.             assert(bs->p_w - bs->p_ow < 32);
  821.             p_n_w = bs->p_w;
  822.             i_n_bit_out = bs->i_bit_out;
  823.             i_n_bit_out_cache = bs->i_bit_out_cache;
  824.             assert(bs->p_ow == p_n_ow);
  826.             bs->i_bit_out = i_o_bit_out ;
  827.             bs->i_bit_out_cache = i_o_bit_out_cache;
  828.             bs->p_ow = p_o_ow;
  829.             bs->p_w = p_o_w;
  830.             // end saving data
  832.             if ( macroblock_modes &
  833.                     (MACROBLOCK_MOTION_FORWARD | MACROBLOCK_MOTION_BACKWARD
  834.                       | MACROBLOCK_PATTERN) )
  835.             {
  836.                 if ( first_in_slice )
  837.                 {
  838.                     put_quantiser( tr );
  839.                     bs_write( bs, 0, 1 );
  840.                     macroblock_modes &= ~MACROBLOCK_QUANT;
  841.                 }
  842.                 putaddrinc( tr, mba_inc );
  843.                 mba_inc = 0;
  844.                 putmbdata( tr, macroblock_modes );
  845.                 if ( macroblock_modes & MACROBLOCK_QUANT )
  846.                 {
  847.                     put_quantiser( tr );
  848.                 }
  850.                 // put saved motion data...
  851.                 for (batb = 0; batb < (p_n_w - p_n_ow); batb++)
  852.                 {
  853.                     bs_write( bs, p_n_ow[batb], 8 );
  854.                 }
  855.                 bs_write( bs, i_n_bit_out_cache, BITS_IN_BUF - i_n_bit_out);
  856.                 // end saved motion data...
  858.                 if (macroblock_modes & MACROBLOCK_PATTERN)
  859.                 {
  860.                     /* Write CBP */
  861.                     bs_write( bs, cbptable[new_coded_block_pattern].code,
  862.                               cbptable[new_coded_block_pattern].len );
  864.                     for ( i = 0; i < 6; i++ )
  865.                     {
  866.                         if ( new_coded_block_pattern & (1 << (5 - i)) )
  867.                         {
  868.                             putnonintrablk( bs, new_block[i] );
  869.                         }
  870.                     }
  871.                 }
  872.             }
  873.             else
  874.             {
  875.                 /* skipped macroblock */
  876.                 mba_inc++;
  877.             }
  878.         }
  880.         if (bs->p_c > bs->p_r || bs->p_w > bs->p_rw)
  881.         {
  882.             tr->b_error = 1;
  883.             return;
  884.         }
  885.         //LOGF("nto: %i c: %i n: %in", quantizer_scale, last_coded_scale, new_quantizer_scale);
  887.         NEXT_MACROBLOCK;
  889.         first_in_slice = 0;
  890.         mba_local = 0;
  891.         for ( ; ; )
  892.         {
  893.             if ( bs->i_bit_in_cache >= 0x10000000 )
  894.             {
  895.                 mba = MBA_5 + (UBITS (bs->i_bit_in_cache, 5) - 2);
  896.                 break;
  897.             }
  898.             else if ( bs->i_bit_in_cache >= 0x03000000 )
  899.             {
  900.                 mba = MBA_11 + (UBITS (bs->i_bit_in_cache, 11) - 24);
  901.                 break;
  902.             }
  903.             else if ( UBITS( bs->i_bit_in_cache, 11 ) == 8 )
  904.             {
  905.                 /* macroblock_escape */
  906.                 mba_inc += 33;
  907.                 mba_local += 33;
  908.                 bs_flush(bs, 11);
  909.             }
  910.             else
  911.             {
  912.                 /* EOS or error */
  913.                 return;
  914.             }
  915.         }
  916.         bs_flush(bs, mba->len);
  917.         mba_inc += mba->mba;
  918.         mba_local += mba->mba;
  920.         while( mba_local-- )
  921.         {
  922.             NEXT_MACROBLOCK;
  923.         }
  924.     }
  925. }
  927. static const uint8_t mpeg2_scan_norm[64] ATTR_ALIGN(16) = {
  928.     /* Zig-Zag scan pattern */
  929.      0,  1,  8, 16,  9,  2,  3, 10, 17, 24, 32, 25, 18, 11,  4,  5,
  930.     12, 19, 26, 33, 40, 48, 41, 34, 27, 20, 13,  6,  7, 14, 21, 28,
  931.     35, 42, 49, 56, 57, 50, 43, 36, 29, 22, 15, 23, 30, 37, 44, 51,
  932.     58, 59, 52, 45, 38, 31, 39, 46, 53, 60, 61, 54, 47, 55, 62, 63
  933. };
  935. static const uint8_t mpeg2_scan_alt[64] ATTR_ALIGN(16) = {
  936.     /* Alternate scan pattern */
  937.      0, 8,  16, 24,  1,  9,  2, 10, 17, 25, 32, 40, 48, 56, 57, 49,
  938.     41, 33, 26, 18,  3, 11,  4, 12, 19, 27, 34, 42, 50, 58, 35, 43,
  939.     51, 59, 20, 28,  5, 13,  6, 14, 21, 29, 36, 44, 52, 60, 37, 45,
  940.     53, 61, 22, 30,  7, 15, 23, 31, 38, 46, 54, 62, 39, 47, 55, 63
  941. };
  943. static const int16_t default_intra_matrix[64] = {
  944.         8, 16, 19, 22, 26, 27, 29, 34,
  945.         16, 16, 22, 24, 27, 29, 34, 37,
  946.         19, 22, 26, 27, 29, 34, 34, 38,
  947.         22, 22, 26, 27, 29, 34, 37, 40,
  948.         22, 26, 27, 29, 32, 35, 40, 48,
  949.         26, 27, 29, 32, 35, 40, 48, 58,
  950.         26, 27, 29, 34, 38, 46, 56, 69,
  951.         27, 29, 35, 38, 46, 56, 69, 83
  952. };
  954. static int mpeg2_header_sequence( transrate_t * tr )
  955. {
  956.     bs_transrate_t *bs = &tr->bs;
  957.     int has_intra = 0, has_non_intra = 0;
  958.     int i;
  960.     i = (bs->p_c[0] << 16) | (bs->p_c[1] << 8) | bs->p_c[2];
  961.     tr->horizontal_size_value = i >> 12;
  962.     tr->vertical_size_value = i & 0xfff;
  963.     tr->horizontal_size_value = (tr->horizontal_size_value + 15) & ~15;
  964.     tr->vertical_size_value = (tr->vertical_size_value + 15) & ~15;
  965.     if ( !tr->horizontal_size_value || !tr->vertical_size_value )
  966.     {
  967.         return -1;
  968.     }
  970.     if ( tr->mpeg4_matrix )
  971.     {
  972.         if (bs->p_c[7] & 2)
  973.         {
  974.             has_intra = 1;
  975.             for (i = 0; i < 64; i++)
  976.                 tr->intra_quantizer_matrix[mpeg2_scan_norm[i]] =
  977.                 (bs->p_c[i+7] << 7) | (bs->p_c[i+8] >> 1);
  978.         }
  979.         else
  980.         {
  981.             for (i = 0; i < 64; i++)
  982.                 tr->intra_quantizer_matrix[mpeg2_scan_norm[i]] =
  983.                 default_intra_matrix[i];
  984.         }
  986.         if (bs->p_c[7+64] & 1)
  987.         {
  988.             has_non_intra = 1;
  989.             for (i = 0; i < 64; i++)
  990.                 tr->non_intra_quantizer_matrix[mpeg2_scan_norm[i]] =
  991.                 bs->p_c[i+8+64];
  992.         }
  993.         else
  994.         {
  995.             for (i = 0; i < 64; i++)
  996.                 tr->non_intra_quantizer_matrix[i] = 16;
  997.         }
  998.     }
  1000.     /* Write quantization matrices */
  1001.     memcpy( bs->p_w, bs->p_c, 8 );
  1002.     bs->p_c += 8;
  1004.     if ( tr->mpeg4_matrix )
  1005.     {
  1006.         memset( &bs->p_w[8], 0, 128 );
  1007.         bs->p_w[7] |= 2;
  1008.         bs->p_w[7] &= ~1;
  1009.         for (i = 0; i < 64; i++)
  1010.         {
  1011.             bs->p_w[i+7] |= mpeg4_default_intra_matrix[mpeg2_scan_norm[i]] >> 7;
  1012.             bs->p_w[i+8] |= mpeg4_default_intra_matrix[mpeg2_scan_norm[i]] << 1;
  1013.         }
  1015.         bs->p_w[7+64] |= 1;
  1016.         for (i = 0; i < 64; i++)
  1017.         {
  1018.             bs->p_w[i+8+64] |= mpeg4_default_intra_matrix[mpeg2_scan_norm[i]];
  1019.         }
  1020.         bs->p_w += 8 + 128;
  1021.         bs->p_c += (has_intra + has_non_intra) * 64;
  1022.     }
  1023.     else
  1024.     {
  1025.         bs->p_w += 8;
  1026.     }
  1028.     tr->scan = mpeg2_scan_norm;
  1030.     return 0;
  1031. }
  1033. /////---- end ext mpeg code
  1035. static int do_next_start_code( transrate_t *tr )
  1036. {
  1037.     bs_transrate_t *bs = &tr->bs;
  1038.     uint8_t ID;
  1040.     // get start code
  1041.     ID = bs->p_c[0];
  1043.     /* Copy one byte */
  1044.     *bs->p_w++ = *bs->p_c++;
  1046.     if (ID == 0x00) // pic header
  1047.     {
  1048.         tr->picture_coding_type = (bs->p_c[1] >> 3) & 0x7;
  1049.         bs->p_c[1] |= 0x7; bs->p_c[2] = 0xFF; bs->p_c[3] |= 0xF8; // vbv_delay is now 0xFFFF
  1051.         memcpy(bs->p_w, bs->p_c, 4);
  1052.         bs->p_c += 4;
  1053.         bs->p_w += 4;
  1054.     }
  1055.     else if (ID == 0xB3) // seq header
  1056.     {
  1057.         mpeg2_header_sequence(tr);
  1058.     }
  1059.     else if (ID == 0xB5) // extension
  1060.     {
  1061.         if ((bs->p_c[0] >> 4) == 0x8) // pic coding ext
  1062.         {
  1063.             tr->f_code[0][0] = (bs->p_c[0] & 0xF) - 1;
  1064.             tr->f_code[0][1] = (bs->p_c[1] >> 4) - 1;
  1065.             tr->f_code[1][0] = (bs->p_c[1] & 0xF) - 1;
  1066.             tr->f_code[1][1] = (bs->p_c[2] >> 4) - 1;
  1068.             /* tr->intra_dc_precision = (bs->p_c[2] >> 2) & 0x3; */
  1069.             tr->picture_structure = bs->p_c[2] & 0x3;
  1070.             tr->frame_pred_frame_dct = (bs->p_c[3] >> 6) & 0x1;
  1071.             tr->concealment_motion_vectors = (bs->p_c[3] >> 5) & 0x1;
  1072.             tr->q_scale_type = (bs->p_c[3] >> 4) & 0x1;
  1073.             tr->intra_vlc_format = (bs->p_c[3] >> 3) & 0x1;
  1074.             if ( (bs->p_c[3] >> 2) & 0x1 )
  1075.                 tr->scan = mpeg2_scan_alt;
  1077.             memcpy(bs->p_w, bs->p_c, 5);
  1078.             bs->p_c += 5;
  1079.             bs->p_w += 5;
  1080.         }
  1081.         else
  1082.         {
  1083.             *bs->p_w++ = *bs->p_c++;
  1084.         }
  1085.     }
  1086.     else if (ID == 0xB8) // gop header
  1087.     {
  1088.         memcpy(bs->p_w, bs->p_c, 4);
  1089.         bs->p_c += 4;
  1090.         bs->p_w += 4;
  1091.     }
  1092.     else if ((ID >= 0x01) && (ID <= 0xAF)) // slice
  1093.     {
  1094.         uint8_t *outTemp = bs->p_w, *inTemp = bs->p_c;
  1096.         if( tr->qrate != 1.0 )
  1097.         {
  1098.             if( !tr->horizontal_size_value || !tr->vertical_size_value )
  1099.             {
  1100.                 return -1;
  1101.             }
  1103.             // init bit buffer
  1104.             bs->i_bit_in_cache = 0; bs->i_bit_in = 0;
  1105.             bs->i_bit_out_cache = 0; bs->i_bit_out = BITS_IN_BUF;
  1107.             // get 32 bits
  1108.             bs_refill( bs );
  1109.             bs_refill( bs );
  1110.             bs_refill( bs );
  1111.             bs_refill( bs );
  1113.             // begin bit level recoding
  1114.             mpeg2_slice(tr, ID);
  1115.             if (tr->b_error) return -1;
  1117.             bs_flush_read( bs );
  1118.             bs_flush_write( bs );
  1119.             // end bit level recoding
  1121.             /* Basic sanity checks --Meuuh */
  1122.             if (bs->p_c > bs->p_r || bs->p_w > bs->p_rw)
  1123.             {
  1124.                 return -1;
  1125.             }
  1127.             /*LOGF("type: %s code: %02i in : %6i out : %6i diff : %6i fact: %2.2fn",
  1128.             (picture_coding_type == I_TYPE ? "I_TYPE" : (picture_coding_type == P_TYPE ? "P_TYPE" : "B_TYPE")),
  1129.             ID,  bs->p_c - inTemp, bs->p_w - outTemp, (bs->p_w - outTemp) - (bs->p_c - inTemp), (float)(bs->p_c - inTemp) / (float)(bs->p_w - outTemp));*/
  1131.             if (bs->p_w - outTemp > bs->p_c - inTemp) // yes that might happen, rarely
  1132.             {
  1134.                 /*LOGF("*** slice bigger than before !! (type: %s code: %i in : %i out : %i diff : %i)n",
  1135.                 (picture_coding_type == I_TYPE ? "I_TYPE" : (picture_coding_type == P_TYPE ? "P_TYPE" : "B_TYPE")),
  1136.                 ID, bs->p_c - inTemp, bs->p_w - outTemp, (bs->p_w - outTemp) - (bs->p_c - inTemp));*/
  1138.                 if ( !tr->mpeg4_matrix )
  1139.                 {
  1140.                     // in this case, we'll just use the original slice !
  1141.                     memcpy(outTemp, inTemp, bs->p_c - inTemp);
  1142.                     bs->p_w = outTemp + (bs->p_c - inTemp);
  1144.                     // adjust bs->i_byte_out
  1145.                     bs->i_byte_out -= (bs->p_w - outTemp) - (bs->p_c - inTemp);
  1146.                 }
  1147.                 else
  1148.                 {
  1149.                     fprintf(stderr, "bad choice for mpeg4-matrix...n");
  1150.                 }
  1151.             }
  1152.         }
  1153.     }
  1154.     return 0;
  1155. }
  1157. int process_frame( sout_stream_t *p_stream, sout_stream_id_t *id,
  1158.                    block_t *in, block_t **out, int i_handicap )
  1159. {
  1160.     transrate_t *tr = &id->tr;
  1161.     bs_transrate_t *bs = &tr->bs;
  1163.     block_t       *p_out;
  1165.     double        f_drift, f_fact;
  1166.     int           i_drift;
  1168.     p_out = block_New( p_stream, in->i_buffer * 3 );
  1170.     p_out->i_length = in->i_length;
  1171.     p_out->i_dts    = in->i_dts;
  1172.     p_out->i_pts    = in->i_pts;
  1173.     p_out->i_flags  = in->i_flags;
  1175.     bs->p_rw = bs->p_ow = bs->p_w = p_out->p_buffer;
  1176.     bs->p_c = bs->p_r = in->p_buffer;
  1177.     bs->p_r += in->i_buffer + 4;
  1178.     bs->p_rw += in->i_buffer * 2;
  1179.     *(in->p_buffer + in->i_buffer) = 0;
  1180.     *(in->p_buffer + in->i_buffer + 1) = 0;
  1181.     *(in->p_buffer + in->i_buffer + 2) = 1;
  1182.     *(in->p_buffer + in->i_buffer + 3) = 0;
  1184.     /* Calculate how late we are */
  1185.     bs->i_byte_in = in->i_buffer;
  1186.     bs->i_byte_out  = 0;
  1188.     i_drift = tr->i_current_output + tr->i_remaining_input
  1189.                 - tr->i_wanted_output;
  1190.     f_drift = (double)i_drift / tr->i_wanted_output;
  1191.     f_fact = (double)(tr->i_wanted_output - tr->i_current_output)
  1192.                     / tr->i_remaining_input;
  1194.     if ( in->i_flags & BLOCK_FLAG_TYPE_I )
  1195.     {
  1196.         /* This is the last picture of the GOP ; only transrate if we're
  1197.          * very late. */
  1198.         if ( 0 && f_drift > 0.085 )
  1199.         {
  1200.             tr->i_minimum_error = (f_drift - 0.085) * 50.0 * 50.0;
  1201.             tr->i_admissible_error = (f_drift - 0.085) * 50.0 * 75.0;
  1202.             tr->qrate = 1.0 + (f_drift - 0.085) * 50.0;
  1203.             msg_Warn( p_stream, "transrating I %d/%d",
  1204.                       tr->i_minimum_error, tr->i_admissible_error );
  1205.         }
  1206.         else
  1207.         {
  1208.             tr->i_minimum_error = 0;
  1209.             tr->i_admissible_error = 0;
  1210.             tr->qrate = 1.0;
  1211.         }
  1212.     }
  1213.     else if ( in->i_flags & BLOCK_FLAG_TYPE_P )
  1214.     {
  1215.         if ( f_fact < 0.8 )
  1216.         {
  1217.             tr->i_minimum_error = (0.8 - f_fact) * 3000.0 + i_handicap;
  1218.             tr->i_admissible_error = (0.8 - f_fact) * 3500.0 + i_handicap;
  1219.             tr->qrate = 1.0 + (0.8 - f_fact) * 70.0;
  1220.         }
  1221.         else
  1222.         {
  1223.             tr->i_minimum_error = 0;
  1224.             tr->i_admissible_error = 0;
  1225.             tr->qrate = 1.0;
  1226.         }
  1227.     }
  1228.     else
  1229.     {
  1230.         if ( f_fact < 1.2 )
  1231.         {
  1232.             tr->i_minimum_error = (1.2 - f_fact) * 1750.0 + i_handicap;
  1233.             tr->i_admissible_error = (1.2 - f_fact) * 2250.0 + i_handicap;
  1234.             tr->qrate = 1.0 + (1.2 - f_fact) * 45.0;
  1235.         }
  1236.         else
  1237.         {
  1238.             tr->i_minimum_error = 0;
  1239.             tr->i_admissible_error = 0;
  1240.             tr->qrate = 1.0;
  1241.         }
  1242.     }
  1244.     tr->new_quantizer_scale = 0;
  1245.     tr->b_error = 0;
  1247.     for ( ; ; )
  1248.     {
  1249.         uint8_t *p_end = &in->p_buffer[in->i_buffer];
  1251.         /* Search next start code */
  1252.         for( ;; )
  1253.         {
  1254.             if( bs->p_c < p_end - 3 && bs->p_c[0] == 0 && bs->p_c[1] == 0 && bs->p_c[2] == 1 )
  1255.             {
  1256.                 /* Next start code */
  1257.                 break;
  1258.             }
  1259.             else if( bs->p_c < p_end - 6 &&
  1260.                      bs->p_c[0] == 0 && bs->p_c[1] == 0 && bs->p_c[2] == 0 &&
  1261.                      bs->p_c[3] == 0 && bs->p_c[4] == 0 && bs->p_c[5] == 0 )
  1262.             {
  1263.                 /* remove stuffing (looking for 6 0x00 bytes) */
  1264.                 bs->p_c++;
  1265.             }
  1266.             else
  1267.             {
  1268.                 /* Copy */
  1269.                 *bs->p_w++ = *bs->p_c++;
  1270.             }
  1272.             if( bs->p_c >= p_end )
  1273.             {
  1274.                 break;
  1275.             }
  1276.         }
  1278.         if( bs->p_c >= p_end )
  1279.         {
  1280.             break;
  1281.         }
  1283.         /* Copy the start code */
  1284.         memcpy( bs->p_w, bs->p_c, 3 );
  1285.         bs->p_c += 3;
  1286.         bs->p_w += 3;
  1288.         if ( do_next_start_code( tr ) )
  1289.         {
  1290.             /* Error */
  1291.             msg_Err( p_stream, "error in do_next_start_code()" );
  1292.             block_Release( p_out );
  1293.             tr->i_remaining_input -= in->i_buffer;
  1294.             tr->i_current_output += in->i_buffer;
  1295.             return -1;
  1296.         }
  1297.     }
  1299.     bs->i_byte_out += bs->p_w - bs->p_ow;
  1300.     p_out->i_buffer = bs->p_w - bs->p_ow;
  1302. #if 0
  1303.     if ( in->i_flags & BLOCK_FLAG_TYPE_P && f_fact < 0.8 )
  1304.     {
  1305.         double f_ratio = (in->i_buffer - p_out->i_buffer) / in->i_buffer;
  1306.         if ( f_ratio < (0.8 - f_fact) * 0.1 && i_handicap < 200 )
  1307.         {
  1308.             block_Release( p_out );
  1309.             return process_frame( p_stream, id, in, out, i_handicap + 50 );
  1310.         }
  1311.     }
  1313.     if ( in->i_flags & BLOCK_FLAG_TYPE_B && f_fact < 1.1 )
  1314.     {
  1315.         double f_ratio = (double)(in->i_buffer - p_out->i_buffer)
  1316.                             / in->i_buffer;
  1317.         if ( f_ratio < (1.1 - f_fact) * 0.1 && i_handicap < 400 )
  1318.         {
  1319. #ifdef DEBUG_TRANSRATER
  1320.             msg_Dbg( p_stream, "%d: %d -> %d big (f: %f d: %f)",
  1321.                      tr->picture_coding_type, in->i_buffer, p_out->i_buffer,
  1322.                      f_fact, f_drift);
  1323. #endif
  1324.             block_Release( p_out );
  1325.             return process_frame( p_stream, id, in, out, i_handicap + 100 );
  1326.         }
  1327.     }
  1328. #endif
  1330. #if 0
  1331.     {
  1332.         int toto;
  1333.         for ( toto = 0; toto < p_out->i_buffer; toto++ )
  1334.             if (in->p_buffer[toto] != p_out->p_buffer[toto])
  1335.                 msg_Dbg(p_stream, "toto %d %x %x", toto, in->p_buffer[toto], p_out->p_buffer[toto]);
  1336.     }
  1337. #endif
  1339.     block_ChainAppend( out, p_out );
  1340.     tr->i_remaining_input -= in->i_buffer;
  1341.     tr->i_current_output += p_out->i_buffer;
  1343. #ifdef DEBUG_TRANSRATER
  1344.     msg_Dbg( p_stream, "%d: %d -> %d (%d/%d)",
  1345.              tr->picture_coding_type, in->i_buffer, p_out->i_buffer,
  1346.              tr->i_minimum_error, tr->i_admissible_error );
  1347. #endif
  1349.     return 0;
  1350. }