falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1207 Commits
32 Branches
369MB
Tree: f20dca4020
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'f20dca4020'
${ noResults }
FFmpeg/libavcodec/mpeg12.c

1961 lines
63KB
Raw Blame History 

  1. /*

  2.  * MPEG1 encoder / MPEG2 decoder

  3.  * Copyright (c) 2000,2001 Fabrice Bellard.

  4.  *

  5.  * This library is free software; you can redistribute it and/or

  6.  * modify it under the terms of the GNU Lesser General Public

  7.  * License as published by the Free Software Foundation; either

  8.  * version 2 of the License, or (at your option) any later version.

  9.  *

  10.  * This library is distributed in the hope that it will be useful,

  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

  13.  * Lesser General Public License for more details.

  14.  *

  15.  * You should have received a copy of the GNU Lesser General Public

  16.  * License along with this library; if not, write to the Free Software

  17.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

  18.  */

  19. //#define DEBUG

  20. #include "avcodec.h"

  21. #include "dsputil.h"

  22. #include "mpegvideo.h"

  23. 

  24. #include "mpeg12data.h"

  25. 

  26. #if 1

  27. #define PRINT_QP(a, b) {}

  28. #else

  29. #define PRINT_QP(a, b) printf(a, b)

  30. #endif

  31. 

  32. /* Start codes. */

  33. #define SEQ_END_CODE		0x000001b7

  34. #define SEQ_START_CODE		0x000001b3

  35. #define GOP_START_CODE		0x000001b8

  36. #define PICTURE_START_CODE	0x00000100

  37. #define SLICE_MIN_START_CODE	0x00000101

  38. #define SLICE_MAX_START_CODE	0x000001af

  39. #define EXT_START_CODE		0x000001b5

  40. #define USER_START_CODE		0x000001b2

  41. 

  42. #define DC_VLC_BITS 9

  43. #define MV_VLC_BITS 9

  44. #define MBINCR_VLC_BITS 9

  45. #define MB_PAT_VLC_BITS 9

  46. #define MB_PTYPE_VLC_BITS 6

  47. #define MB_BTYPE_VLC_BITS 6

  48. #define TEX_VLC_BITS 9

  49. 

  50. static void mpeg1_encode_block(MpegEncContext *s, 

  51.                          DCTELEM *block, 

  52.                          int component);

  53. static void mpeg1_encode_motion(MpegEncContext *s, int val);

  54. static void mpeg1_skip_picture(MpegEncContext *s, int pict_num);

  55. static inline int mpeg1_decode_block_inter(MpegEncContext *s, 

  56.                               DCTELEM *block, 

  57.                               int n);

  58. static inline int mpeg1_decode_block_intra(MpegEncContext *s, 

  59.                               DCTELEM *block, 

  60.                               int n);

  61. static inline int mpeg2_decode_block_non_intra(MpegEncContext *s, 

  62.                                         DCTELEM *block, 

  63.                                         int n);

  64. static inline int mpeg2_decode_block_intra(MpegEncContext *s, 

  65.                                     DCTELEM *block, 

  66.                                     int n);

  67. static int mpeg_decode_motion(MpegEncContext *s, int fcode, int pred);

  68. 

  69. static UINT16 mv_penalty[MAX_FCODE+1][MAX_MV*2+1];

  70. static UINT8 fcode_tab[MAX_MV*2+1];

  71. 

  72. static void init_2d_vlc_rl(RLTable *rl)

  73. {

  74.     int i;

  75.     

  76.     init_vlc(&rl->vlc, TEX_VLC_BITS, rl->n + 2, 

  77.              &rl->table_vlc[0][1], 4, 2,

  78.              &rl->table_vlc[0][0], 4, 2);

  79. 

  80.     

  81.     rl->rl_vlc[0]= av_malloc(rl->vlc.table_size*sizeof(RL_VLC_ELEM));

  82.     for(i=0; i<rl->vlc.table_size; i++){

  83.         int code= rl->vlc.table[i][0];

  84.         int len = rl->vlc.table[i][1];

  85.         int level, run;

  86.     

  87.         if(len==0){ // illegal code

  88.             run= 65;

  89.             level= MAX_LEVEL;

  90.         }else if(len<0){ //more bits needed

  91.             run= 0;

  92.             level= code;

  93.         }else{

  94.             if(code==rl->n){ //esc

  95.                 run= 65;

  96.                 level= 0;

  97.             }else if(code==rl->n+1){ //eob

  98.                 run= 0;

  99.                 level= 127;

  100.             }else{

  101.                 run=   rl->table_run  [code] + 1;

  102.                 level= rl->table_level[code];

  103.             }

  104.         }

  105.         rl->rl_vlc[0][i].len= len;

  106.         rl->rl_vlc[0][i].level= level;

  107.         rl->rl_vlc[0][i].run= run;

  108.     }

  109. }

  110. 

  111. 

  112. static void put_header(MpegEncContext *s, int header)

  113. {

  114.     align_put_bits(&s->pb);

  115.     put_bits(&s->pb, 16, header>>16);

  116.     put_bits(&s->pb, 16, header&0xFFFF);

  117. }

  118. 

  119. /* put sequence header if needed */

  120. static void mpeg1_encode_sequence_header(MpegEncContext *s)

  121. {

  122.         unsigned int vbv_buffer_size;

  123.         unsigned int fps, v;

  124.         int n;

  125.         UINT64 time_code;

  126.         

  127.         if (s->picture_in_gop_number == 0) {

  128.             /* mpeg1 header repeated every gop */

  129.             put_header(s, SEQ_START_CODE);

  130.             

  131.             /* search closest frame rate */

  132.             {

  133.                 int i, dmin, d;

  134.                 s->frame_rate_index = 0;

  135.                 dmin = 0x7fffffff;

  136.                 for(i=1;i<9;i++) {

  137.                     d = abs(s->frame_rate - frame_rate_tab[i]);

  138.                     if (d < dmin) {

  139.                         dmin = d;

  140.                         s->frame_rate_index = i;

  141.                     }

  142.                 }

  143.             }

  144.  

  145.             put_bits(&s->pb, 12, s->width);

  146.             put_bits(&s->pb, 12, s->height);

  147.             put_bits(&s->pb, 4, 1); /* 1/1 aspect ratio */

  148.             put_bits(&s->pb, 4, s->frame_rate_index);

  149.             v = s->bit_rate / 400;

  150.             if (v > 0x3ffff)

  151.                 v = 0x3ffff;

  152.             put_bits(&s->pb, 18, v);

  153.             put_bits(&s->pb, 1, 1); /* marker */

  154. 

  155.             if(s->avctx->rc_buffer_size)

  156.                 vbv_buffer_size = s->avctx->rc_buffer_size;

  157.             else

  158.                 /* VBV calculation: Scaled so that a VCD has the proper VBV size of 40 kilobytes */

  159.                 vbv_buffer_size = (( 20 * s->bit_rate) / (1151929 / 2)) * 8 * 1024;	 

  160.             put_bits(&s->pb, 10, (vbv_buffer_size + 16383) / 16384); 

  161.             put_bits(&s->pb, 1, 1); /* constrained parameter flag */

  162.             put_bits(&s->pb, 1, 0); /* no custom intra matrix */

  163.             put_bits(&s->pb, 1, 0); /* no custom non intra matrix */

  164. 

  165.             put_header(s, GOP_START_CODE);

  166.             put_bits(&s->pb, 1, 0); /* do drop frame */

  167.             /* time code : we must convert from the real frame rate to a

  168.                fake mpeg frame rate in case of low frame rate */

  169.             fps = frame_rate_tab[s->frame_rate_index];

  170.             time_code = (INT64)s->fake_picture_number * FRAME_RATE_BASE;

  171.             s->gop_picture_number = s->fake_picture_number;

  172.             put_bits(&s->pb, 5, (UINT32)((time_code / (fps * 3600)) % 24));

  173.             put_bits(&s->pb, 6, (UINT32)((time_code / (fps * 60)) % 60));

  174.             put_bits(&s->pb, 1, 1);

  175.             put_bits(&s->pb, 6, (UINT32)((time_code / fps) % 60));

  176.             put_bits(&s->pb, 6, (UINT32)((time_code % fps) / FRAME_RATE_BASE));

  177.             put_bits(&s->pb, 1, 1); /* closed gop */

  178.             put_bits(&s->pb, 1, 0); /* broken link */

  179.         }

  180. 

  181.         if (s->frame_rate < (24 * FRAME_RATE_BASE) && s->picture_number > 0) {

  182.             /* insert empty P pictures to slow down to the desired

  183.                frame rate. Each fake pictures takes about 20 bytes */

  184.             fps = frame_rate_tab[s->frame_rate_index];

  185.             n = (((INT64)s->picture_number * fps) / s->frame_rate) - 1;

  186.             while (s->fake_picture_number < n) {

  187.                 mpeg1_skip_picture(s, s->fake_picture_number - 

  188.                                    s->gop_picture_number); 

  189.                 s->fake_picture_number++;

  190.             }

  191. 

  192.         }

  193. }

  194. 

  195. 

  196. /* insert a fake P picture */

  197. static void mpeg1_skip_picture(MpegEncContext *s, int pict_num)

  198. {

  199.     unsigned int mb_incr;

  200. 

  201.     /* mpeg1 picture header */

  202.     put_header(s, PICTURE_START_CODE);

  203.     /* temporal reference */

  204.     put_bits(&s->pb, 10, pict_num & 0x3ff); 

  205.     

  206.     put_bits(&s->pb, 3, P_TYPE);

  207.     put_bits(&s->pb, 16, 0xffff); /* non constant bit rate */

  208.     

  209.     put_bits(&s->pb, 1, 1); /* integer coordinates */

  210.     put_bits(&s->pb, 3, 1); /* forward_f_code */

  211.     

  212.     put_bits(&s->pb, 1, 0); /* extra bit picture */

  213.     

  214.     /* only one slice */

  215.     put_header(s, SLICE_MIN_START_CODE);

  216.     put_bits(&s->pb, 5, 1); /* quantizer scale */

  217.     put_bits(&s->pb, 1, 0); /* slice extra information */

  218.     

  219.     mb_incr = 1;

  220.     put_bits(&s->pb, mbAddrIncrTable[mb_incr - 1][1], 

  221.              mbAddrIncrTable[mb_incr - 1][0]);

  222.     

  223.     /* empty macroblock */

  224.     put_bits(&s->pb, 3, 1); /* motion only */

  225.     

  226.     /* zero motion x & y */

  227.     put_bits(&s->pb, 1, 1); 

  228.     put_bits(&s->pb, 1, 1); 

  229. 

  230.     /* output a number of empty slice */

  231.     mb_incr = s->mb_width * s->mb_height - 1;

  232.     while (mb_incr > 33) {

  233.         put_bits(&s->pb, 11, 0x008);

  234.         mb_incr -= 33;

  235.     }

  236.     put_bits(&s->pb, mbAddrIncrTable[mb_incr - 1][1], 

  237.              mbAddrIncrTable[mb_incr - 1][0]);

  238.     

  239.     /* empty macroblock */

  240.     put_bits(&s->pb, 3, 1); /* motion only */

  241.     

  242.     /* zero motion x & y */

  243.     put_bits(&s->pb, 1, 1); 

  244.     put_bits(&s->pb, 1, 1); 

  245. }

  246. 

  247. static void common_init(MpegEncContext *s)

  248. {

  249.     s->y_dc_scale_table=

  250.     s->c_dc_scale_table= ff_mpeg1_dc_scale_table;

  251. }

  252. 

  253. void mpeg1_encode_picture_header(MpegEncContext *s, int picture_number)

  254. {

  255.     mpeg1_encode_sequence_header(s);

  256. 

  257.     /* mpeg1 picture header */

  258.     put_header(s, PICTURE_START_CODE);

  259.     /* temporal reference */

  260.     put_bits(&s->pb, 10, (s->fake_picture_number - 

  261.                           s->gop_picture_number) & 0x3ff); 

  262.     s->fake_picture_number++;

  263.     

  264.     put_bits(&s->pb, 3, s->pict_type);

  265.     put_bits(&s->pb, 16, 0xffff); /* non constant bit rate */

  266.     

  267.     if (s->pict_type == P_TYPE) {

  268.         put_bits(&s->pb, 1, 0); /* half pel coordinates */

  269.         put_bits(&s->pb, 3, s->f_code); /* forward_f_code */

  270.     }

  271.     

  272.     put_bits(&s->pb, 1, 0); /* extra bit picture */

  273.     

  274.     /* only one slice */

  275.     put_header(s, SLICE_MIN_START_CODE);

  276.     put_bits(&s->pb, 5, s->qscale); /* quantizer scale */

  277.     put_bits(&s->pb, 1, 0); /* slice extra information */

  278. }

  279. 

  280. void mpeg1_encode_mb(MpegEncContext *s,

  281.                      DCTELEM block[6][64],

  282.                      int motion_x, int motion_y)

  283. {

  284.     int mb_incr, i, cbp, mb_x, mb_y;

  285. 

  286.     mb_x = s->mb_x;

  287.     mb_y = s->mb_y;

  288. 

  289.     /* compute cbp */

  290.     cbp = 0;

  291.     for(i=0;i<6;i++) {

  292.         if (s->block_last_index[i] >= 0)

  293.             cbp |= 1 << (5 - i);

  294.     }

  295. 

  296.     /* skip macroblock, except if first or last macroblock of a slice */

  297.     if ((cbp | motion_x | motion_y) == 0 &&

  298.         (!((mb_x | mb_y) == 0 ||

  299.            (mb_x == s->mb_width - 1 && mb_y == s->mb_height - 1)))) {

  300.         s->mb_incr++;

  301.         s->qscale -= s->dquant;

  302.     } else {

  303.         /* output mb incr */

  304.         mb_incr = s->mb_incr;

  305. 

  306.         while (mb_incr > 33) {

  307.             put_bits(&s->pb, 11, 0x008);

  308.             mb_incr -= 33;

  309.         }

  310.         put_bits(&s->pb, mbAddrIncrTable[mb_incr - 1][1], 

  311.                  mbAddrIncrTable[mb_incr - 1][0]);

  312.         

  313.         if (s->pict_type == I_TYPE) {

  314.             if(s->dquant && cbp){

  315.                 put_bits(&s->pb, 2, 1); /* macroblock_type : macroblock_quant = 1 */

  316.                 put_bits(&s->pb, 5, s->qscale);

  317.             }else{

  318.                 put_bits(&s->pb, 1, 1); /* macroblock_type : macroblock_quant = 0 */

  319.                 s->qscale -= s->dquant;

  320.             }

  321.         } else {

  322.             if (s->mb_intra) {

  323.                 if(s->dquant && cbp){

  324.                     put_bits(&s->pb, 6, 0x01);

  325.                     put_bits(&s->pb, 5, s->qscale);

  326.                 }else{

  327.                     put_bits(&s->pb, 5, 0x03);

  328.                     s->qscale -= s->dquant;

  329.                 }

  330.             } else {

  331.                 if (cbp != 0) {

  332.                     if (motion_x == 0 && motion_y == 0) {

  333.                         if(s->dquant){

  334.                             put_bits(&s->pb, 5, 1); /* macroblock_pattern & quant */

  335.                             put_bits(&s->pb, 5, s->qscale);

  336.                         }else{

  337.                             put_bits(&s->pb, 2, 1); /* macroblock_pattern only */

  338.                         }

  339.                         put_bits(&s->pb, mbPatTable[cbp - 1][1], mbPatTable[cbp - 1][0]);

  340.                     } else {

  341.                         if(s->dquant){

  342.                             put_bits(&s->pb, 5, 2); /* motion + cbp */

  343.                             put_bits(&s->pb, 5, s->qscale);

  344.                         }else{

  345.                             put_bits(&s->pb, 1, 1); /* motion + cbp */

  346.                         }

  347.                         mpeg1_encode_motion(s, motion_x - s->last_mv[0][0][0]); 

  348.                         mpeg1_encode_motion(s, motion_y - s->last_mv[0][0][1]); 

  349.                         put_bits(&s->pb, mbPatTable[cbp - 1][1], mbPatTable[cbp - 1][0]);

  350.                     }

  351.                 } else {

  352.                     put_bits(&s->pb, 3, 1); /* motion only */

  353.                     mpeg1_encode_motion(s, motion_x - s->last_mv[0][0][0]); 

  354.                     mpeg1_encode_motion(s, motion_y - s->last_mv[0][0][1]); 

  355.                     s->qscale -= s->dquant;

  356.                 }

  357.             }

  358.         }

  359.         for(i=0;i<6;i++) {

  360.             if (cbp & (1 << (5 - i))) {

  361.                 mpeg1_encode_block(s, block[i], i);

  362.             }

  363.         }

  364.         s->mb_incr = 1;

  365.     }

  366.     s->last_mv[0][0][0] = motion_x;

  367.     s->last_mv[0][0][1] = motion_y;

  368. }

  369. 

  370. static void mpeg1_encode_motion(MpegEncContext *s, int val)

  371. {

  372.     int code, bit_size, l, m, bits, range, sign;

  373. 

  374.     if (val == 0) {

  375.         /* zero vector */

  376.         code = 0;

  377.         put_bits(&s->pb,

  378.                  mbMotionVectorTable[0][1], 

  379.                  mbMotionVectorTable[0][0]); 

  380.     } else {

  381.         bit_size = s->f_code - 1;

  382.         range = 1 << bit_size;

  383.         /* modulo encoding */

  384.         l = 16 * range;

  385.         m = 2 * l;

  386.         if (val < -l) {

  387.             val += m;

  388.         } else if (val >= l) {

  389.             val -= m;

  390.         }

  391. 

  392.         if (val >= 0) {

  393.             val--;

  394.             code = (val >> bit_size) + 1;

  395.             bits = val & (range - 1);

  396.             sign = 0;

  397.         } else {

  398.             val = -val;

  399.             val--;

  400.             code = (val >> bit_size) + 1;

  401.             bits = val & (range - 1);

  402.             sign = 1;

  403.         }

  404.         put_bits(&s->pb,

  405.                  mbMotionVectorTable[code][1], 

  406.                  mbMotionVectorTable[code][0]); 

  407.         put_bits(&s->pb, 1, sign);

  408.         if (bit_size > 0) {

  409.             put_bits(&s->pb, bit_size, bits);

  410.         }

  411.     }

  412. }

  413. 

  414. void ff_mpeg1_encode_init(MpegEncContext *s)

  415. {

  416.     static int done=0;

  417. 

  418.     common_init(s);

  419. 

  420.     if(!done){

  421.         int f_code;

  422.         int mv;

  423. 	int i;

  424. 

  425.         done=1;

  426.         init_rl(&rl_mpeg1);

  427. 	

  428. 	for(i=0; i<64; i++)

  429. 	{

  430. 		mpeg1_max_level[0][i]= rl_mpeg1.max_level[0][i];

  431. 		mpeg1_index_run[0][i]= rl_mpeg1.index_run[0][i];

  432. 	}

  433. 

  434. 	/* build unified dc encoding tables */

  435. 	for(i=-255; i<256; i++)

  436. 	{

  437. 		int adiff, index;

  438. 		int bits, code;

  439. 		int diff=i;

  440. 

  441. 		adiff = ABS(diff);

  442. 		if(diff<0) diff--;

  443. 		index = vlc_dc_table[adiff];

  444. 

  445. 		bits= vlc_dc_lum_bits[index] + index;

  446. 		code= (vlc_dc_lum_code[index]<<index) + (diff & ((1 << index) - 1));

  447. 		mpeg1_lum_dc_uni[i+255]= bits + (code<<8);

  448. 		

  449. 		bits= vlc_dc_chroma_bits[index] + index;

  450. 		code= (vlc_dc_chroma_code[index]<<index) + (diff & ((1 << index) - 1));

  451. 		mpeg1_chr_dc_uni[i+255]= bits + (code<<8);

  452. 	}

  453. 

  454.         for(f_code=1; f_code<=MAX_FCODE; f_code++){

  455.             for(mv=-MAX_MV; mv<=MAX_MV; mv++){

  456.                 int len;

  457. 

  458.                 if(mv==0) len= mbMotionVectorTable[0][1];

  459.                 else{

  460.                     int val, bit_size, range, code;

  461. 

  462.                     bit_size = s->f_code - 1;

  463.                     range = 1 << bit_size;

  464. 

  465.                     val=mv;

  466.                     if (val < 0) 

  467.                         val = -val;

  468.                     val--;

  469.                     code = (val >> bit_size) + 1;

  470.                     if(code<17){

  471.                         len= mbMotionVectorTable[code][1] + 1 + bit_size;

  472.                     }else{

  473.                         len= mbMotionVectorTable[16][1] + 2 + bit_size;

  474.                     }

  475.                 }

  476. 

  477.                 mv_penalty[f_code][mv+MAX_MV]= len;

  478.             }

  479.         }

  480.         

  481. 

  482.         for(f_code=MAX_FCODE; f_code>0; f_code--){

  483.             for(mv=-(8<<f_code); mv<(8<<f_code); mv++){

  484.                 fcode_tab[mv+MAX_MV]= f_code;

  485.             }

  486.         }

  487.     }

  488.     s->mv_penalty= mv_penalty;

  489.     s->fcode_tab= fcode_tab;

  490.     s->min_qcoeff=-255;

  491.     s->max_qcoeff= 255;

  492.     s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x

  493.     s->inter_quant_bias= 0;

  494. }

  495. 

  496. static inline void encode_dc(MpegEncContext *s, int diff, int component)

  497. {

  498.     if (component == 0) {

  499.         put_bits(

  500. 	    &s->pb, 

  501. 	    mpeg1_lum_dc_uni[diff+255]&0xFF,

  502. 	    mpeg1_lum_dc_uni[diff+255]>>8);

  503.     } else {

  504.         put_bits(

  505.             &s->pb, 

  506. 	    mpeg1_chr_dc_uni[diff+255]&0xFF,

  507. 	    mpeg1_chr_dc_uni[diff+255]>>8);

  508.     }

  509. }

  510. 

  511. static void mpeg1_encode_block(MpegEncContext *s, 

  512.                                DCTELEM *block, 

  513.                                int n)

  514. {

  515.     int alevel, level, last_non_zero, dc, diff, i, j, run, last_index, sign;

  516.     int code, component;

  517. //    RLTable *rl = &rl_mpeg1;

  518. 

  519.     last_index = s->block_last_index[n];

  520. 

  521.     /* DC coef */

  522.     if (s->mb_intra) {

  523.         component = (n <= 3 ? 0 : n - 4 + 1);

  524.         dc = block[0]; /* overflow is impossible */

  525.         diff = dc - s->last_dc[component];

  526.         encode_dc(s, diff, component);

  527.         s->last_dc[component] = dc;

  528.         i = 1;

  529.     } else {

  530.         /* encode the first coefficient : needs to be done here because

  531.            it is handled slightly differently */

  532.         level = block[0];

  533.         if (abs(level) == 1) {

  534.                 code = ((UINT32)level >> 31); /* the sign bit */

  535.                 put_bits(&s->pb, 2, code | 0x02);

  536.                 i = 1;

  537.         } else {

  538.             i = 0;

  539.             last_non_zero = -1;

  540.             goto next_coef;

  541.         }

  542.     }

  543. 

  544.     /* now quantify & encode AC coefs */

  545.     last_non_zero = i - 1;

  546. 

  547.     for(;i<=last_index;i++) {

  548.         j = s->intra_scantable.permutated[i];

  549.         level = block[j];

  550.     next_coef:

  551. #if 0

  552.         if (level != 0)

  553.             dprintf("level[%d]=%d\n", i, level);

  554. #endif            

  555.         /* encode using VLC */

  556.         if (level != 0) {

  557.             run = i - last_non_zero - 1;

  558.             

  559.             alevel= level;

  560.             MASK_ABS(sign, alevel)

  561.             sign&=1;

  562. 

  563. //            code = get_rl_index(rl, 0, run, alevel);

  564.             if (alevel > mpeg1_max_level[0][run])

  565.                 code= 111; /*rl->n*/

  566.             else

  567.                 code= mpeg1_index_run[0][run] + alevel - 1;

  568. 

  569.             if (code < 111 /* rl->n */) {

  570. 	    	/* store the vlc & sign at once */

  571.                 put_bits(&s->pb, mpeg1_vlc[code][1]+1, (mpeg1_vlc[code][0]<<1) + sign);

  572.             } else {

  573. 		/* escape seems to be pretty rare <5% so i dont optimize it */

  574.                 put_bits(&s->pb, mpeg1_vlc[111/*rl->n*/][1], mpeg1_vlc[111/*rl->n*/][0]);

  575.                 /* escape: only clip in this case */

  576.                 put_bits(&s->pb, 6, run);

  577.                 if (alevel < 128) {

  578.                     put_bits(&s->pb, 8, level & 0xff);

  579.                 } else {

  580.                     if (level < 0) {

  581.                         put_bits(&s->pb, 16, 0x8001 + level + 255);

  582.                     } else {

  583.                         put_bits(&s->pb, 16, level & 0xffff);

  584.                     }

  585.                 }

  586.             }

  587.             last_non_zero = i;

  588.         }

  589.     }

  590.     /* end of block */

  591.     put_bits(&s->pb, 2, 0x2);

  592. }

  593. 

  594. /******************************************/

  595. /* decoding */

  596. 

  597. static VLC dc_lum_vlc;

  598. static VLC dc_chroma_vlc;

  599. static VLC mv_vlc;

  600. static VLC mbincr_vlc;

  601. static VLC mb_ptype_vlc;

  602. static VLC mb_btype_vlc;

  603. static VLC mb_pat_vlc;

  604. 

  605. static void init_vlcs(MpegEncContext *s)

  606. {

  607.     static int done = 0;

  608. 

  609.     if (!done) {

  610.         done = 1;

  611. 

  612.         init_vlc(&dc_lum_vlc, DC_VLC_BITS, 12, 

  613.                  vlc_dc_lum_bits, 1, 1,

  614.                  vlc_dc_lum_code, 2, 2);

  615.         init_vlc(&dc_chroma_vlc,  DC_VLC_BITS, 12, 

  616.                  vlc_dc_chroma_bits, 1, 1,

  617.                  vlc_dc_chroma_code, 2, 2);

  618.         init_vlc(&mv_vlc, MV_VLC_BITS, 17, 

  619.                  &mbMotionVectorTable[0][1], 2, 1,

  620.                  &mbMotionVectorTable[0][0], 2, 1);

  621.         init_vlc(&mbincr_vlc, MBINCR_VLC_BITS, 35, 

  622.                  &mbAddrIncrTable[0][1], 2, 1,

  623.                  &mbAddrIncrTable[0][0], 2, 1);

  624.         init_vlc(&mb_pat_vlc, MB_PAT_VLC_BITS, 63, 

  625.                  &mbPatTable[0][1], 2, 1,

  626.                  &mbPatTable[0][0], 2, 1);

  627.         

  628.         init_vlc(&mb_ptype_vlc, MB_PTYPE_VLC_BITS, 32, 

  629.                  &table_mb_ptype[0][1], 2, 1,

  630.                  &table_mb_ptype[0][0], 2, 1);

  631.         init_vlc(&mb_btype_vlc, MB_BTYPE_VLC_BITS, 32, 

  632.                  &table_mb_btype[0][1], 2, 1,

  633.                  &table_mb_btype[0][0], 2, 1);

  634.         init_rl(&rl_mpeg1);

  635.         init_rl(&rl_mpeg2);

  636. 

  637.         init_2d_vlc_rl(&rl_mpeg1);

  638.         init_2d_vlc_rl(&rl_mpeg2);

  639.     }

  640. }

  641. 

  642. static inline int get_dmv(MpegEncContext *s)

  643. {

  644.     if(get_bits1(&s->gb)) 

  645.         return 1 - (get_bits1(&s->gb) << 1);

  646.     else

  647.         return 0;

  648. }

  649. 

  650. static inline int get_qscale(MpegEncContext *s)

  651. {

  652.     int qscale;

  653.     if (s->mpeg2) {

  654.         if (s->q_scale_type) {

  655.             qscale = non_linear_qscale[get_bits(&s->gb, 5)];

  656.         } else {

  657.             qscale = get_bits(&s->gb, 5) << 1;

  658.         }

  659.     } else {

  660.         /* for mpeg1, we use the generic unquant code */

  661.         qscale = get_bits(&s->gb, 5);

  662.     }

  663.     return qscale;

  664. }

  665. 

  666. /* motion type (for mpeg2) */

  667. #define MT_FIELD 1

  668. #define MT_FRAME 2

  669. #define MT_16X8  2

  670. #define MT_DMV   3

  671. 

  672. static int mpeg_decode_mb(MpegEncContext *s,

  673.                           DCTELEM block[6][64])

  674. {

  675.     int i, j, k, cbp, val, code, mb_type, motion_type;

  676.     

  677.     dprintf("decode_mb: x=%d y=%d\n", s->mb_x, s->mb_y);

  678. 

  679.     if (--s->mb_incr != 0) {

  680.         /* skip mb */

  681.         s->mb_intra = 0;

  682.         for(i=0;i<6;i++)

  683.             s->block_last_index[i] = -1;

  684.         s->mv_type = MV_TYPE_16X16;

  685.         if (s->pict_type == P_TYPE) {

  686.             /* if P type, zero motion vector is implied */

  687.             s->mv_dir = MV_DIR_FORWARD;

  688.             s->mv[0][0][0] = s->mv[0][0][1] = 0;

  689.             s->last_mv[0][0][0] = s->last_mv[0][0][1] = 0;

  690.             s->last_mv[0][1][0] = s->last_mv[0][1][1] = 0;

  691.         } else {

  692.             /* if B type, reuse previous vectors and directions */

  693.             s->mv[0][0][0] = s->last_mv[0][0][0];

  694.             s->mv[0][0][1] = s->last_mv[0][0][1];

  695.             s->mv[1][0][0] = s->last_mv[1][0][0];

  696.             s->mv[1][0][1] = s->last_mv[1][0][1];

  697.         }

  698.         s->mb_skiped = 1;

  699.         return 0;

  700.     }

  701. 

  702.     switch(s->pict_type) {

  703.     default:

  704.     case I_TYPE:

  705.         if (get_bits1(&s->gb) == 0) {

  706.             if (get_bits1(&s->gb) == 0)

  707.                 return -1;

  708.             mb_type = MB_QUANT | MB_INTRA;

  709.         } else {

  710.             mb_type = MB_INTRA;

  711.         }

  712.         break;

  713.     case P_TYPE:

  714.         mb_type = get_vlc2(&s->gb, mb_ptype_vlc.table, MB_PTYPE_VLC_BITS, 1);

  715.         if (mb_type < 0){

  716.             fprintf(stderr, "invalid mb type in P Frame at %d %d\n", s->mb_x, s->mb_y);

  717.             return -1;

  718.         }

  719.         break;

  720.     case B_TYPE:

  721.         mb_type = get_vlc2(&s->gb, mb_btype_vlc.table, MB_BTYPE_VLC_BITS, 1);

  722.         if (mb_type < 0){

  723.             fprintf(stderr, "invalid mb type in B Frame at %d %d\n", s->mb_x, s->mb_y);

  724.             return -1;

  725.         }

  726.         break;

  727.     }

  728.     dprintf("mb_type=%x\n", mb_type);

  729.     motion_type = 0; /* avoid warning */

  730.     if (mb_type & (MB_FOR|MB_BACK)) {

  731.         /* get additionnal motion vector type */

  732.         if (s->picture_structure == PICT_FRAME && s->frame_pred_frame_dct) 

  733.             motion_type = MT_FRAME;

  734.         else

  735.             motion_type = get_bits(&s->gb, 2);

  736.     }

  737.     /* compute dct type */

  738.     if (s->picture_structure == PICT_FRAME && 

  739.         !s->frame_pred_frame_dct &&

  740.         (mb_type & (MB_PAT | MB_INTRA))) {

  741.         s->interlaced_dct = get_bits1(&s->gb);

  742. #ifdef DEBUG

  743.         if (s->interlaced_dct)

  744.             printf("interlaced_dct\n");

  745. #endif

  746.     } else {

  747.         s->interlaced_dct = 0; /* frame based */

  748.     }

  749. 

  750.     if (mb_type & MB_QUANT) {

  751.         s->qscale = get_qscale(s);

  752.     }

  753.     if (mb_type & MB_INTRA) {

  754.         if (s->concealment_motion_vectors) {

  755.             /* just parse them */

  756.             if (s->picture_structure != PICT_FRAME) 

  757.                 skip_bits1(&s->gb); /* field select */

  758.             mpeg_decode_motion(s, s->mpeg_f_code[0][0], 0);

  759.             mpeg_decode_motion(s, s->mpeg_f_code[0][1], 0);

  760.         }

  761.         s->mb_intra = 1;

  762.         cbp = 0x3f;

  763.         memset(s->last_mv, 0, sizeof(s->last_mv)); /* reset mv prediction */

  764.     } else {

  765.         s->mb_intra = 0;

  766.         cbp = 0;

  767.     }

  768.     /* special case of implicit zero motion vector */

  769.     if (s->pict_type == P_TYPE && !(mb_type & MB_FOR)) {

  770.         s->mv_dir = MV_DIR_FORWARD;

  771.         s->mv_type = MV_TYPE_16X16;

  772.         s->last_mv[0][0][0] = 0;

  773.         s->last_mv[0][0][1] = 0;

  774.         s->last_mv[0][1][0] = 0;

  775.         s->last_mv[0][1][1] = 0;

  776.         s->mv[0][0][0] = 0;

  777.         s->mv[0][0][1] = 0;

  778.     } else if (mb_type & (MB_FOR | MB_BACK)) {

  779.         /* motion vectors */

  780.         s->mv_dir = 0;

  781.         for(i=0;i<2;i++) {

  782.             if (mb_type & (MB_FOR >> i)) {

  783.                 s->mv_dir |= (MV_DIR_FORWARD >> i);

  784.                 dprintf("motion_type=%d\n", motion_type);

  785.                 switch(motion_type) {

  786.                 case MT_FRAME: /* or MT_16X8 */

  787.                     if (s->picture_structure == PICT_FRAME) {

  788.                         /* MT_FRAME */

  789.                         s->mv_type = MV_TYPE_16X16;

  790.                         for(k=0;k<2;k++) {

  791.                             val = mpeg_decode_motion(s, s->mpeg_f_code[i][k], 

  792.                                                      s->last_mv[i][0][k]);

  793.                             s->last_mv[i][0][k] = val;

  794.                             s->last_mv[i][1][k] = val;

  795.                             /* full_pel: only for mpeg1 */

  796.                             if (s->full_pel[i])

  797.                                 val = val << 1;

  798.                             s->mv[i][0][k] = val;

  799.                             dprintf("mv%d: %d\n", k, val);

  800.                         }

  801.                     } else {

  802.                         /* MT_16X8 */

  803.                         s->mv_type = MV_TYPE_16X8;

  804.                         for(j=0;j<2;j++) {

  805.                             s->field_select[i][j] = get_bits1(&s->gb);

  806.                             for(k=0;k<2;k++) {

  807.                                 val = mpeg_decode_motion(s, s->mpeg_f_code[i][k],

  808.                                                          s->last_mv[i][j][k]);

  809.                                 s->last_mv[i][j][k] = val;

  810.                                 s->mv[i][j][k] = val;

  811.                             }

  812.                         }

  813.                     }

  814.                     break;

  815.                 case MT_FIELD:

  816.                     if (s->picture_structure == PICT_FRAME) {

  817.                         s->mv_type = MV_TYPE_FIELD;

  818.                         for(j=0;j<2;j++) {

  819.                             s->field_select[i][j] = get_bits1(&s->gb);

  820.                             val = mpeg_decode_motion(s, s->mpeg_f_code[i][0],

  821.                                                      s->last_mv[i][j][0]);

  822.                             s->last_mv[i][j][0] = val;

  823.                             s->mv[i][j][0] = val;

  824.                             dprintf("fmx=%d\n", val);

  825.                             val = mpeg_decode_motion(s, s->mpeg_f_code[i][1],

  826.                                                      s->last_mv[i][j][1] >> 1);

  827.                             s->last_mv[i][j][1] = val << 1;

  828.                             s->mv[i][j][1] = val;

  829.                             dprintf("fmy=%d\n", val);

  830.                         }

  831.                     } else {

  832.                         s->mv_type = MV_TYPE_16X16;

  833.                         s->field_select[i][0] = get_bits1(&s->gb);

  834.                         for(k=0;k<2;k++) {

  835.                             val = mpeg_decode_motion(s, s->mpeg_f_code[i][k],

  836.                                                      s->last_mv[i][0][k]);

  837.                             s->last_mv[i][0][k] = val;

  838.                             s->last_mv[i][1][k] = val;

  839.                             s->mv[i][0][k] = val;

  840.                         }

  841.                     }

  842.                     break;

  843.                 case MT_DMV:

  844.                     {

  845.                         int dmx, dmy, mx, my, m;

  846. 

  847.                         mx = mpeg_decode_motion(s, s->mpeg_f_code[i][0], 

  848.                                                 s->last_mv[i][0][0]);

  849.                         s->last_mv[i][0][0] = mx;

  850.                         s->last_mv[i][1][0] = mx;

  851.                         dmx = get_dmv(s);

  852.                         my = mpeg_decode_motion(s, s->mpeg_f_code[i][1], 

  853.                                                 s->last_mv[i][0][1] >> 1);

  854.                         dmy = get_dmv(s);

  855.                         s->mv_type = MV_TYPE_DMV;

  856.                         /* XXX: totally broken */

  857.                         if (s->picture_structure == PICT_FRAME) {

  858.                             s->last_mv[i][0][1] = my << 1;

  859.                             s->last_mv[i][1][1] = my << 1;

  860. 

  861.                             m = s->top_field_first ? 1 : 3;

  862.                             /* top -> top pred */

  863.                             s->mv[i][0][0] = mx; 

  864.                             s->mv[i][0][1] = my << 1;

  865.                             s->mv[i][1][0] = ((mx * m + (mx > 0)) >> 1) + dmx;

  866.                             s->mv[i][1][1] = ((my * m + (my > 0)) >> 1) + dmy - 1;

  867.                             m = 4 - m;

  868.                             s->mv[i][2][0] = mx;

  869.                             s->mv[i][2][1] = my << 1;

  870.                             s->mv[i][3][0] = ((mx * m + (mx > 0)) >> 1) + dmx;

  871.                             s->mv[i][3][1] = ((my * m + (my > 0)) >> 1) + dmy + 1;

  872.                         } else {

  873.                             s->last_mv[i][0][1] = my;

  874.                             s->last_mv[i][1][1] = my;

  875.                             s->mv[i][0][0] = mx;

  876.                             s->mv[i][0][1] = my;

  877.                             s->mv[i][1][0] = ((mx + (mx > 0)) >> 1) + dmx;

  878.                             s->mv[i][1][1] = ((my + (my > 0)) >> 1) + dmy - 1 

  879.                                 /* + 2 * cur_field */;

  880.                         }

  881.                     }

  882.                     break;

  883.                 }

  884.             }

  885.         }

  886.     }

  887. 

  888.     if ((mb_type & MB_INTRA) && s->concealment_motion_vectors) {

  889.         skip_bits1(&s->gb); /* marker */

  890.     }

  891.     

  892.     if (mb_type & MB_PAT) {

  893.         cbp = get_vlc2(&s->gb, mb_pat_vlc.table, MB_PAT_VLC_BITS, 1);

  894.         if (cbp < 0){

  895.             fprintf(stderr, "invalid cbp at %d %d\n", s->mb_x, s->mb_y);

  896.             return -1;

  897.         }

  898.         cbp++;

  899.     }

  900.     dprintf("cbp=%x\n", cbp);

  901. 

  902.     if (s->mpeg2) {

  903.         if (s->mb_intra) {

  904.             for(i=0;i<6;i++) {

  905.                 if (mpeg2_decode_block_intra(s, block[i], i) < 0)

  906.                     return -1;

  907.             }

  908.         } else {

  909.             for(i=0;i<6;i++) {

  910.                 if (cbp & 32) {

  911.                     if (mpeg2_decode_block_non_intra(s, block[i], i) < 0)

  912.                         return -1;

  913.                 } else {

  914.                     s->block_last_index[i] = -1;

  915.                 }

  916.                 cbp+=cbp;

  917.             }

  918.         }

  919.     } else {

  920.         if (s->mb_intra) {

  921.             for(i=0;i<6;i++) {

  922.                 if (mpeg1_decode_block_intra(s, block[i], i) < 0)

  923.                     return -1;

  924.             }

  925.         }else{

  926.             for(i=0;i<6;i++) {

  927.                 if (cbp & 32) {

  928.                     if (mpeg1_decode_block_inter(s, block[i], i) < 0)

  929.                         return -1;

  930.                 } else {

  931.                     s->block_last_index[i] = -1;

  932.                 }

  933.                 cbp+=cbp;

  934.             }

  935.         }

  936.     }

  937.     return 0;

  938. }

  939. 

  940. /* as h263, but only 17 codes */

  941. static int mpeg_decode_motion(MpegEncContext *s, int fcode, int pred)

  942. {

  943.     int code, sign, val, m, l, shift;

  944. 

  945.     code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);

  946.     if (code < 0) {

  947.         return 0xffff;

  948.     }

  949.     if (code == 0) {

  950.         return pred;

  951.     }

  952.     sign = get_bits1(&s->gb);

  953.     shift = fcode - 1;

  954.     val = (code - 1) << shift;

  955.     if (shift > 0)

  956.         val |= get_bits(&s->gb, shift);

  957.     val++;

  958.     if (sign)

  959.         val = -val;

  960.     val += pred;

  961.     

  962.     /* modulo decoding */

  963.     l = (1 << shift) * 16;

  964.     m = 2 * l;

  965.     if (val < -l) {

  966.         val += m;

  967.     } else if (val >= l) {

  968.         val -= m;

  969.     }

  970.     return val;

  971. }

  972. 

  973. static inline int decode_dc(MpegEncContext *s, int component)

  974. {

  975.     int code, diff;

  976. 

  977.     if (component == 0) {

  978.         code = get_vlc2(&s->gb, dc_lum_vlc.table, DC_VLC_BITS, 2);

  979.     } else {

  980.         code = get_vlc2(&s->gb, dc_chroma_vlc.table, DC_VLC_BITS, 2);

  981.     }

  982.     if (code < 0){

  983.         fprintf(stderr, "invalid dc code at %d %d\n", s->mb_x, s->mb_y);

  984.         return 0xffff;

  985.     }

  986.     if (code == 0) {

  987.         diff = 0;

  988.     } else {

  989.         diff = get_bits(&s->gb, code);

  990.         if ((diff & (1 << (code - 1))) == 0) 

  991.             diff = (-1 << code) | (diff + 1);

  992.     }

  993.     return diff;

  994. }

  995. 

  996. static inline int mpeg1_decode_block_intra(MpegEncContext *s, 

  997.                                DCTELEM *block, 

  998.                                int n)

  999. {

  1000.     int level, dc, diff, i, j, run;

  1001.     int component;

  1002.     RLTable *rl = &rl_mpeg1;

  1003.     UINT8 * const scantable= s->intra_scantable.permutated;

  1004.     const UINT16 *quant_matrix= s->intra_matrix;

  1005.     const int qscale= s->qscale;

  1006. 

  1007.     /* DC coef */

  1008.     component = (n <= 3 ? 0 : n - 4 + 1);

  1009.     diff = decode_dc(s, component);

  1010.     if (diff >= 0xffff)

  1011.         return -1;

  1012.     dc = s->last_dc[component];

  1013.     dc += diff;

  1014.     s->last_dc[component] = dc;

  1015.     block[0] = dc<<3;

  1016.     dprintf("dc=%d diff=%d\n", dc, diff);

  1017.     i = 0;

  1018.     {

  1019.         OPEN_READER(re, &s->gb);    

  1020.         /* now quantify & encode AC coefs */

  1021.         for(;;) {

  1022.             UPDATE_CACHE(re, &s->gb);

  1023.             GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2);

  1024.             

  1025.             if(level == 127){

  1026.                 break;

  1027.             } else if(level != 0) {

  1028.                 i += run;

  1029.                 j = scantable[i];

  1030.                 level= (level*qscale*quant_matrix[j])>>3;

  1031.                 level= (level-1)|1;

  1032.                 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);

  1033.                 LAST_SKIP_BITS(re, &s->gb, 1);

  1034.             } else {

  1035.                 /* escape */

  1036.                 run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);

  1037.                 UPDATE_CACHE(re, &s->gb);

  1038.                 level = SHOW_SBITS(re, &s->gb, 8); SKIP_BITS(re, &s->gb, 8);

  1039.                 if (level == -128) {

  1040.                     level = SHOW_UBITS(re, &s->gb, 8) - 256; LAST_SKIP_BITS(re, &s->gb, 8);

  1041.                 } else if (level == 0) {

  1042.                     level = SHOW_UBITS(re, &s->gb, 8)      ; LAST_SKIP_BITS(re, &s->gb, 8);

  1043.                 }

  1044.                 i += run;

  1045.                 j = scantable[i];

  1046.                 if(level<0){

  1047.                     level= -level;

  1048.                     level= (level*qscale*quant_matrix[j])>>3;

  1049.                     level= (level-1)|1;

  1050.                     level= -level;

  1051.                 }else{

  1052.                     level= (level*qscale*quant_matrix[j])>>3;

  1053.                     level= (level-1)|1;

  1054.                 }

  1055.             }

  1056.             if (i > 63){

  1057.                 fprintf(stderr, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);

  1058.                 return -1;

  1059.             }

  1060. 

  1061.             block[j] = level;

  1062.         }

  1063.         CLOSE_READER(re, &s->gb);

  1064.     }

  1065.     s->block_last_index[n] = i;

  1066.    return 0;

  1067. }

  1068. 

  1069. static inline int mpeg1_decode_block_inter(MpegEncContext *s, 

  1070.                                DCTELEM *block, 

  1071.                                int n)

  1072. {

  1073.     int level, i, j, run;

  1074.     RLTable *rl = &rl_mpeg1;

  1075.     UINT8 * const scantable= s->intra_scantable.permutated;

  1076.     const UINT16 *quant_matrix= s->inter_matrix;

  1077.     const int qscale= s->qscale;

  1078. 

  1079.     {

  1080.         int v;

  1081.         OPEN_READER(re, &s->gb);

  1082.         i = -1;

  1083.         /* special case for the first coef. no need to add a second vlc table */

  1084.         UPDATE_CACHE(re, &s->gb);

  1085.         v= SHOW_UBITS(re, &s->gb, 2);

  1086.         if (v & 2) {

  1087.             LAST_SKIP_BITS(re, &s->gb, 2);

  1088.             level= (3*qscale*quant_matrix[0])>>4;

  1089.             level= (level-1)|1;

  1090.             if(v&1)

  1091.                 level= -level;

  1092.             block[0] = level;

  1093.             i++;

  1094.         }

  1095. 

  1096.         /* now quantify & encode AC coefs */

  1097.         for(;;) {

  1098.             UPDATE_CACHE(re, &s->gb);

  1099.             GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2);

  1100.             

  1101.             if(level == 127){

  1102.                 break;

  1103.             } else if(level != 0) {

  1104.                 i += run;

  1105.                 j = scantable[i];

  1106.                 level= ((level*2+1)*qscale*quant_matrix[j])>>4;

  1107.                 level= (level-1)|1;

  1108.                 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);

  1109.                 LAST_SKIP_BITS(re, &s->gb, 1);

  1110.             } else {

  1111.                 /* escape */

  1112.                 run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);

  1113.                 UPDATE_CACHE(re, &s->gb);

  1114.                 level = SHOW_SBITS(re, &s->gb, 8); SKIP_BITS(re, &s->gb, 8);

  1115.                 if (level == -128) {

  1116.                     level = SHOW_UBITS(re, &s->gb, 8) - 256; LAST_SKIP_BITS(re, &s->gb, 8);

  1117.                 } else if (level == 0) {

  1118.                     level = SHOW_UBITS(re, &s->gb, 8)      ; LAST_SKIP_BITS(re, &s->gb, 8);

  1119.                 }

  1120.                 i += run;

  1121.                 j = scantable[i];

  1122.                 if(level<0){

  1123.                     level= -level;

  1124.                     level= ((level*2+1)*qscale*quant_matrix[j])>>4;

  1125.                     level= (level-1)|1;

  1126.                     level= -level;

  1127.                 }else{

  1128.                     level= ((level*2+1)*qscale*quant_matrix[j])>>4;

  1129.                     level= (level-1)|1;

  1130.                 }

  1131.             }

  1132.             if (i > 63){

  1133.                 fprintf(stderr, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);

  1134.                 return -1;

  1135.             }

  1136. 

  1137.             block[j] = level;

  1138.         }

  1139.         CLOSE_READER(re, &s->gb);

  1140.     }

  1141.     s->block_last_index[n] = i;

  1142.     return 0;

  1143. }

  1144. 

  1145. /* Also does unquantization here, since I will never support mpeg2

  1146.    encoding */

  1147. static inline int mpeg2_decode_block_non_intra(MpegEncContext *s, 

  1148.                                DCTELEM *block, 

  1149.                                int n)

  1150. {

  1151.     int level, i, j, run;

  1152.     RLTable *rl = &rl_mpeg1;

  1153.     UINT8 * const scantable= s->intra_scantable.permutated;

  1154.     const UINT16 *quant_matrix;

  1155.     const int qscale= s->qscale;

  1156.     int mismatch;

  1157. 

  1158.     mismatch = 1;

  1159. 

  1160.     {

  1161.         int v;

  1162.         OPEN_READER(re, &s->gb);

  1163.         i = -1;

  1164.         if (n < 4)

  1165.             quant_matrix = s->inter_matrix;

  1166.         else

  1167.             quant_matrix = s->chroma_inter_matrix;

  1168. 

  1169.         /* special case for the first coef. no need to add a second vlc table */

  1170.         UPDATE_CACHE(re, &s->gb);

  1171.         v= SHOW_UBITS(re, &s->gb, 2);

  1172.         if (v & 2) {

  1173.             LAST_SKIP_BITS(re, &s->gb, 2);

  1174.             level= (3*qscale*quant_matrix[0])>>5;

  1175.             if(v&1)

  1176.                 level= -level;

  1177.             block[0] = level;

  1178.             mismatch ^= level;

  1179.             i++;

  1180.         }

  1181. 

  1182.         /* now quantify & encode AC coefs */

  1183.         for(;;) {

  1184.             UPDATE_CACHE(re, &s->gb);

  1185.             GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2);

  1186.             

  1187.             if(level == 127){

  1188.                 break;

  1189.             } else if(level != 0) {

  1190.                 i += run;

  1191.                 j = scantable[i];

  1192.                 level= ((level*2+1)*qscale*quant_matrix[j])>>5;

  1193.                 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);

  1194.                 LAST_SKIP_BITS(re, &s->gb, 1);

  1195.             } else {

  1196.                 /* escape */

  1197.                 run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);

  1198.                 UPDATE_CACHE(re, &s->gb);

  1199.                 level = SHOW_SBITS(re, &s->gb, 12); SKIP_BITS(re, &s->gb, 12);

  1200. 

  1201.                 i += run;

  1202.                 j = scantable[i];

  1203.                 if(level<0){

  1204.                     level= ((-level*2+1)*qscale*quant_matrix[j])>>5;

  1205.                     level= -level;

  1206.                 }else{

  1207.                     level= ((level*2+1)*qscale*quant_matrix[j])>>5;

  1208.                 }

  1209.             }

  1210.             if (i > 63){

  1211.                 fprintf(stderr, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);

  1212.                 return -1;

  1213.             }

  1214.             

  1215.             mismatch ^= level;

  1216.             block[j] = level;

  1217.         }

  1218.         CLOSE_READER(re, &s->gb);

  1219.     }

  1220.     block[63] ^= (mismatch & 1);

  1221.     

  1222.     s->block_last_index[n] = i;

  1223.     return 0;

  1224. }

  1225. 

  1226. static inline int mpeg2_decode_block_intra(MpegEncContext *s, 

  1227.                                DCTELEM *block, 

  1228.                                int n)

  1229. {

  1230.     int level, dc, diff, i, j, run;

  1231.     int component;

  1232.     RLTable *rl;

  1233.     UINT8 * const scantable= s->intra_scantable.permutated;

  1234.     const UINT16 *quant_matrix;

  1235.     const int qscale= s->qscale;

  1236.     int mismatch;

  1237. 

  1238.     /* DC coef */

  1239.     if (n < 4){

  1240.         quant_matrix = s->intra_matrix;

  1241.         component = 0; 

  1242.     }else{

  1243.         quant_matrix = s->chroma_intra_matrix;

  1244.         component = n - 3;

  1245.     }

  1246.     diff = decode_dc(s, component);

  1247.     if (diff >= 0xffff)

  1248.         return -1;

  1249.     dc = s->last_dc[component];

  1250.     dc += diff;

  1251.     s->last_dc[component] = dc;

  1252.     block[0] = dc << (3 - s->intra_dc_precision);

  1253.     dprintf("dc=%d\n", block[0]);

  1254.     mismatch = block[0] ^ 1;

  1255.     i = 0;

  1256.     if (s->intra_vlc_format)

  1257.         rl = &rl_mpeg2;

  1258.     else

  1259.         rl = &rl_mpeg1;

  1260. 

  1261.     {

  1262.         OPEN_READER(re, &s->gb);    

  1263.         /* now quantify & encode AC coefs */

  1264.         for(;;) {

  1265.             UPDATE_CACHE(re, &s->gb);

  1266.             GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2);

  1267.             

  1268.             if(level == 127){

  1269.                 break;

  1270.             } else if(level != 0) {

  1271.                 i += run;

  1272.                 j = scantable[i];

  1273.                 level= (level*qscale*quant_matrix[j])>>4;

  1274.                 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);

  1275.                 LAST_SKIP_BITS(re, &s->gb, 1);

  1276.             } else {

  1277.                 /* escape */

  1278.                 run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);

  1279.                 UPDATE_CACHE(re, &s->gb);

  1280.                 level = SHOW_SBITS(re, &s->gb, 12); SKIP_BITS(re, &s->gb, 12);

  1281.                 i += run;

  1282.                 j = scantable[i];

  1283.                 if(level<0){

  1284.                     level= (-level*qscale*quant_matrix[j])>>4;

  1285.                     level= -level;

  1286.                 }else{

  1287.                     level= (level*qscale*quant_matrix[j])>>4;

  1288.                 }

  1289.             }

  1290.             if (i > 63){

  1291.                 fprintf(stderr, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);

  1292.                 return -1;

  1293.             }

  1294.             

  1295.             mismatch^= level;

  1296.             block[j] = level;

  1297.         }

  1298.         CLOSE_READER(re, &s->gb);

  1299.     }

  1300.     block[63]^= mismatch&1;

  1301.     

  1302.     s->block_last_index[n] = i;

  1303.     return 0;

  1304. }

  1305. 

  1306. /* compressed picture size */

  1307. #define PICTURE_BUFFER_SIZE 100000

  1308. 

  1309. typedef struct Mpeg1Context {

  1310.     MpegEncContext mpeg_enc_ctx;

  1311.     UINT32 header_state;

  1312.     int start_code; /* current start code */

  1313.     UINT8 buffer[PICTURE_BUFFER_SIZE]; 

  1314.     UINT8 *buf_ptr;

  1315.     int buffer_size;

  1316.     int mpeg_enc_ctx_allocated; /* true if decoding context allocated */

  1317.     int repeat_field; /* true if we must repeat the field */

  1318. } Mpeg1Context;

  1319. 

  1320. static int mpeg_decode_init(AVCodecContext *avctx)

  1321. {

  1322.     Mpeg1Context *s = avctx->priv_data;

  1323.     

  1324.     s->mpeg_enc_ctx.flags= avctx->flags;

  1325.     common_init(&s->mpeg_enc_ctx);

  1326.     init_vlcs(&s->mpeg_enc_ctx);

  1327. 

  1328.     s->header_state = 0xff;

  1329.     s->mpeg_enc_ctx_allocated = 0;

  1330.     s->buffer_size = PICTURE_BUFFER_SIZE;

  1331.     s->start_code = -1;

  1332.     s->buf_ptr = s->buffer;

  1333.     s->mpeg_enc_ctx.picture_number = 0;

  1334.     s->repeat_field = 0;

  1335.     s->mpeg_enc_ctx.codec_id= avctx->codec->id;

  1336.     avctx->mbskip_table= s->mpeg_enc_ctx.mbskip_table;

  1337.     return 0;

  1338. }

  1339. 

  1340. /* return the 8 bit start code value and update the search

  1341.    state. Return -1 if no start code found */

  1342. static int find_start_code(UINT8 **pbuf_ptr, UINT8 *buf_end, 

  1343.                            UINT32 *header_state)

  1344. {

  1345.     UINT8 *buf_ptr;

  1346.     unsigned int state, v;

  1347.     int val;

  1348. 

  1349.     state = *header_state;

  1350.     buf_ptr = *pbuf_ptr;

  1351.     while (buf_ptr < buf_end) {

  1352.         v = *buf_ptr++;

  1353.         if (state == 0x000001) {

  1354.             state = ((state << 8) | v) & 0xffffff;

  1355.             val = state;

  1356.             goto found;

  1357.         }

  1358.         state = ((state << 8) | v) & 0xffffff;

  1359.     }

  1360.     val = -1;

  1361.  found:

  1362.     *pbuf_ptr = buf_ptr;

  1363.     *header_state = state;

  1364.     return val;

  1365. }

  1366. 

  1367. static int mpeg1_decode_picture(AVCodecContext *avctx, 

  1368.                                 UINT8 *buf, int buf_size)

  1369. {

  1370.     Mpeg1Context *s1 = avctx->priv_data;

  1371.     MpegEncContext *s = &s1->mpeg_enc_ctx;

  1372.     int ref, f_code;

  1373. 

  1374.     init_get_bits(&s->gb, buf, buf_size);

  1375. 

  1376.     ref = get_bits(&s->gb, 10); /* temporal ref */

  1377.     s->pict_type = get_bits(&s->gb, 3);

  1378.     dprintf("pict_type=%d number=%d\n", s->pict_type, s->picture_number);

  1379.     skip_bits(&s->gb, 16);

  1380.     if (s->pict_type == P_TYPE || s->pict_type == B_TYPE) {

  1381.         s->full_pel[0] = get_bits1(&s->gb);

  1382.         f_code = get_bits(&s->gb, 3);

  1383.         if (f_code == 0)

  1384.             return -1;

  1385.         s->mpeg_f_code[0][0] = f_code;

  1386.         s->mpeg_f_code[0][1] = f_code;

  1387.     }

  1388.     if (s->pict_type == B_TYPE) {

  1389.         s->full_pel[1] = get_bits1(&s->gb);

  1390.         f_code = get_bits(&s->gb, 3);

  1391.         if (f_code == 0)

  1392.             return -1;

  1393.         s->mpeg_f_code[1][0] = f_code;

  1394.         s->mpeg_f_code[1][1] = f_code;

  1395.     }

  1396.     s->y_dc_scale = 8;

  1397.     s->c_dc_scale = 8;

  1398.     s->first_slice = 1;

  1399.     return 0;

  1400. }

  1401. 

  1402. static void mpeg_decode_sequence_extension(MpegEncContext *s)

  1403. {

  1404.     int horiz_size_ext, vert_size_ext;

  1405.     int bit_rate_ext, vbv_buf_ext, low_delay;

  1406.     int frame_rate_ext_n, frame_rate_ext_d;

  1407. 

  1408.     skip_bits(&s->gb, 8); /* profil and level */

  1409.     s->progressive_sequence = get_bits1(&s->gb); /* progressive_sequence */

  1410.     skip_bits(&s->gb, 2); /* chroma_format */

  1411.     horiz_size_ext = get_bits(&s->gb, 2);

  1412.     vert_size_ext = get_bits(&s->gb, 2);

  1413.     s->width |= (horiz_size_ext << 12);

  1414.     s->height |= (vert_size_ext << 12);

  1415.     bit_rate_ext = get_bits(&s->gb, 12);  /* XXX: handle it */

  1416.     s->bit_rate = ((s->bit_rate / 400) | (bit_rate_ext << 12)) * 400;

  1417.     skip_bits1(&s->gb); /* marker */

  1418.     vbv_buf_ext = get_bits(&s->gb, 8);

  1419.     low_delay = get_bits1(&s->gb);

  1420.     frame_rate_ext_n = get_bits(&s->gb, 2);

  1421.     frame_rate_ext_d = get_bits(&s->gb, 5);

  1422.     if (frame_rate_ext_d >= 1)

  1423.         s->frame_rate = (s->frame_rate * frame_rate_ext_n) / frame_rate_ext_d;

  1424.     dprintf("sequence extension\n");

  1425.     s->mpeg2 = 1;

  1426.     s->avctx->sub_id = 2; /* indicates mpeg2 found */

  1427. }

  1428. 

  1429. static void mpeg_decode_quant_matrix_extension(MpegEncContext *s)

  1430. {

  1431.     int i, v, j;

  1432. 

  1433.     dprintf("matrix extension\n");

  1434. 

  1435.     if (get_bits1(&s->gb)) {

  1436.         for(i=0;i<64;i++) {

  1437.             v = get_bits(&s->gb, 8);

  1438.             j= s->idct_permutation[ ff_zigzag_direct[i] ];

  1439.             s->intra_matrix[j] = v;

  1440.             s->chroma_intra_matrix[j] = v;

  1441.         }

  1442.     }

  1443.     if (get_bits1(&s->gb)) {

  1444.         for(i=0;i<64;i++) {

  1445.             v = get_bits(&s->gb, 8);

  1446.             j= s->idct_permutation[ ff_zigzag_direct[i] ];

  1447.             s->inter_matrix[j] = v;

  1448.             s->chroma_inter_matrix[j] = v;

  1449.         }

  1450.     }

  1451.     if (get_bits1(&s->gb)) {

  1452.         for(i=0;i<64;i++) {

  1453.             v = get_bits(&s->gb, 8);

  1454.             j= s->idct_permutation[ ff_zigzag_direct[i] ];

  1455.             s->chroma_intra_matrix[j] = v;

  1456.         }

  1457.     }

  1458.     if (get_bits1(&s->gb)) {

  1459.         for(i=0;i<64;i++) {

  1460.             v = get_bits(&s->gb, 8);

  1461.             j= s->idct_permutation[ ff_zigzag_direct[i] ];

  1462.             s->chroma_inter_matrix[j] = v;

  1463.         }

  1464.     }

  1465. }

  1466. 

  1467. static void mpeg_decode_picture_coding_extension(MpegEncContext *s)

  1468. {

  1469.     s->full_pel[0] = s->full_pel[1] = 0;

  1470.     s->mpeg_f_code[0][0] = get_bits(&s->gb, 4);

  1471.     s->mpeg_f_code[0][1] = get_bits(&s->gb, 4);

  1472.     s->mpeg_f_code[1][0] = get_bits(&s->gb, 4);

  1473.     s->mpeg_f_code[1][1] = get_bits(&s->gb, 4);

  1474.     s->intra_dc_precision = get_bits(&s->gb, 2);

  1475.     s->picture_structure = get_bits(&s->gb, 2);

  1476.     s->top_field_first = get_bits1(&s->gb);

  1477.     s->frame_pred_frame_dct = get_bits1(&s->gb);

  1478.     s->concealment_motion_vectors = get_bits1(&s->gb);

  1479.     s->q_scale_type = get_bits1(&s->gb);

  1480.     s->intra_vlc_format = get_bits1(&s->gb);

  1481.     s->alternate_scan = get_bits1(&s->gb);

  1482.     s->repeat_first_field = get_bits1(&s->gb);

  1483.     s->chroma_420_type = get_bits1(&s->gb);

  1484.     s->progressive_frame = get_bits1(&s->gb);

  1485.     

  1486.     if(s->alternate_scan){

  1487.         ff_init_scantable(s, &s->inter_scantable  , ff_alternate_vertical_scan);

  1488.         ff_init_scantable(s, &s->intra_scantable  , ff_alternate_vertical_scan);

  1489.         ff_init_scantable(s, &s->intra_h_scantable, ff_alternate_vertical_scan);

  1490.         ff_init_scantable(s, &s->intra_v_scantable, ff_alternate_vertical_scan);

  1491.     }else{

  1492.         ff_init_scantable(s, &s->inter_scantable  , ff_zigzag_direct);

  1493.         ff_init_scantable(s, &s->intra_scantable  , ff_zigzag_direct);

  1494.         ff_init_scantable(s, &s->intra_h_scantable, ff_alternate_horizontal_scan);

  1495.         ff_init_scantable(s, &s->intra_v_scantable, ff_alternate_vertical_scan);

  1496.     }

  1497.     

  1498.     /* composite display not parsed */

  1499.     dprintf("intra_dc_precision=%d\n", s->intra_dc_precision);

  1500.     dprintf("picture_structure=%d\n", s->picture_structure);

  1501.     dprintf("top field first=%d\n", s->top_field_first);

  1502.     dprintf("repeat first field=%d\n", s->repeat_first_field);

  1503.     dprintf("conceal=%d\n", s->concealment_motion_vectors);

  1504.     dprintf("intra_vlc_format=%d\n", s->intra_vlc_format);

  1505.     dprintf("alternate_scan=%d\n", s->alternate_scan);

  1506.     dprintf("frame_pred_frame_dct=%d\n", s->frame_pred_frame_dct);

  1507.     dprintf("progressive_frame=%d\n", s->progressive_frame);

  1508. }

  1509. 

  1510. static void mpeg_decode_extension(AVCodecContext *avctx, 

  1511.                                   UINT8 *buf, int buf_size)

  1512. {

  1513.     Mpeg1Context *s1 = avctx->priv_data;

  1514.     MpegEncContext *s = &s1->mpeg_enc_ctx;

  1515.     int ext_type;

  1516. 

  1517.     init_get_bits(&s->gb, buf, buf_size);

  1518.     

  1519.     ext_type = get_bits(&s->gb, 4);

  1520.     switch(ext_type) {

  1521.     case 0x1:

  1522.         /* sequence ext */

  1523.         mpeg_decode_sequence_extension(s);

  1524.         break;

  1525.     case 0x3:

  1526.         /* quant matrix extension */

  1527.         mpeg_decode_quant_matrix_extension(s);

  1528.         break;

  1529.     case 0x8:

  1530.         /* picture extension */

  1531.         mpeg_decode_picture_coding_extension(s);

  1532.         break;

  1533.     }

  1534. }

  1535. 

  1536. /* return 1 if end of frame */

  1537. static int mpeg_decode_slice(AVCodecContext *avctx, 

  1538.                               AVPicture *pict,

  1539.                               int start_code,

  1540.                               UINT8 *buf, int buf_size)

  1541. {

  1542.     Mpeg1Context *s1 = avctx->priv_data;

  1543.     MpegEncContext *s = &s1->mpeg_enc_ctx;

  1544.     int ret;

  1545. 

  1546.     start_code = (start_code - 1) & 0xff;

  1547.     if (start_code >= s->mb_height){

  1548.         fprintf(stderr, "slice below image (%d >= %d)\n", start_code, s->mb_height);

  1549.         return -1;

  1550.     }

  1551.     s->last_dc[0] = 1 << (7 + s->intra_dc_precision);

  1552.     s->last_dc[1] = s->last_dc[0];

  1553.     s->last_dc[2] = s->last_dc[0];

  1554.     memset(s->last_mv, 0, sizeof(s->last_mv));

  1555.     /* start frame decoding */

  1556.     if (s->first_slice) {

  1557.         s->first_slice = 0;

  1558.         MPV_frame_start(s, avctx);

  1559.     }

  1560. 

  1561.     init_get_bits(&s->gb, buf, buf_size);

  1562. 

  1563.     s->qscale = get_qscale(s);

  1564.     /* extra slice info */

  1565.     while (get_bits1(&s->gb) != 0) {

  1566.         skip_bits(&s->gb, 8);

  1567.     }

  1568. 

  1569.     s->mb_x=0;

  1570.     for(;;) {

  1571.         int code = get_vlc2(&s->gb, mbincr_vlc.table, MBINCR_VLC_BITS, 2);

  1572.         if (code < 0)

  1573.             return -1; /* error = end of slice, but empty slice is bad or?*/

  1574.         if (code >= 33) {

  1575.             if (code == 33) {

  1576.                 s->mb_x += 33;

  1577.             }

  1578.             /* otherwise, stuffing, nothing to do */

  1579.         } else {

  1580.             s->mb_x += code;

  1581.             break;

  1582.         }

  1583.     }

  1584.     s->mb_y = start_code;

  1585.     s->mb_incr= 1;

  1586. 

  1587.     for(;;) {

  1588.         clear_blocks(s->block[0]);

  1589.         emms_c();

  1590.         

  1591.         ret = mpeg_decode_mb(s, s->block);

  1592.         dprintf("ret=%d\n", ret);

  1593.         if (ret < 0)

  1594.             return -1;

  1595.     

  1596.         MPV_decode_mb(s, s->block);

  1597. 

  1598.         if (++s->mb_x >= s->mb_width) {

  1599.             if (    avctx->draw_horiz_band 

  1600.                 && (s->num_available_buffers>=1 || (!s->has_b_frames)) ) {

  1601.                 UINT8 *src_ptr[3];

  1602.                 int y, h, offset;

  1603.                 y = s->mb_y * 16;

  1604.                 h = s->height - y;

  1605.                 if (h > 16)

  1606.                     h = 16;

  1607.                 if(s->pict_type==B_TYPE)

  1608.                     offset = 0;

  1609.                 else

  1610.                     offset = y * s->linesize;

  1611.                 if(s->pict_type==B_TYPE || (!s->has_b_frames)){

  1612.                     src_ptr[0] = s->current_picture[0] + offset;

  1613.                     src_ptr[1] = s->current_picture[1] + (offset >> 2);

  1614.                     src_ptr[2] = s->current_picture[2] + (offset >> 2);

  1615.                 } else {

  1616.                     src_ptr[0] = s->last_picture[0] + offset;

  1617.                     src_ptr[1] = s->last_picture[1] + (offset >> 2);

  1618.                     src_ptr[2] = s->last_picture[2] + (offset >> 2);

  1619.                 }

  1620.                 avctx->draw_horiz_band(avctx, src_ptr, s->linesize,

  1621.                                    y, s->width, h);

  1622.             }

  1623. 

  1624.             s->mb_x = 0;

  1625.             s->mb_y++;

  1626.             PRINT_QP("%s", "\n");

  1627.         }

  1628.         PRINT_QP("%2d", s->qscale);

  1629. 

  1630.         /* skip mb handling */

  1631.         if (s->mb_incr == 0) {

  1632.             /* read again increment */

  1633.             s->mb_incr = 1;

  1634.             for(;;) {

  1635.                 int code = get_vlc2(&s->gb, mbincr_vlc.table, MBINCR_VLC_BITS, 2);

  1636.                 if (code < 0)

  1637.                     goto eos; /* error = end of slice */

  1638.                 if (code >= 33) {

  1639.                     if (code == 33) {

  1640.                         s->mb_incr += 33;

  1641.                     }

  1642.                     /* otherwise, stuffing, nothing to do */

  1643.                 } else {

  1644.                     s->mb_incr += code;

  1645.                     break;

  1646.                 }

  1647.             }

  1648.         }

  1649.         if(s->mb_y >= s->mb_height){

  1650.             fprintf(stderr, "slice too long\n");

  1651.             return -1;

  1652.         }

  1653.     }

  1654. eos: //end of slice

  1655.     

  1656.     emms_c();

  1657. 

  1658.     /* end of slice reached */

  1659.     if (/*s->mb_x == 0 &&*/

  1660.         s->mb_y == s->mb_height) {

  1661.         /* end of image */

  1662.         UINT8 **picture;

  1663. 

  1664.         MPV_frame_end(s);

  1665. 

  1666.         /* XXX: incorrect reported qscale for mpeg2 */

  1667.         if (s->pict_type == B_TYPE) {

  1668.             picture = s->current_picture;

  1669.             avctx->quality = s->qscale;

  1670.         } else {

  1671.             /* latency of 1 frame for I and P frames */

  1672.             /* XXX: use another variable than picture_number */

  1673.             if (s->picture_number == 0) {

  1674.                 picture = NULL;

  1675.             } else {

  1676.                 picture = s->last_picture;

  1677.                 avctx->quality = s->last_qscale;

  1678.             }

  1679.             s->last_qscale = s->qscale;

  1680.             s->picture_number++;

  1681.         }

  1682.         if (picture) {

  1683.             pict->data[0] = picture[0];

  1684.             pict->data[1] = picture[1];

  1685.             pict->data[2] = picture[2];

  1686.             pict->linesize[0] = s->linesize;

  1687.             pict->linesize[1] = s->uvlinesize;

  1688.             pict->linesize[2] = s->uvlinesize;

  1689.             return 1;

  1690.         } else {

  1691.             return 0;

  1692.         }

  1693.     } else {

  1694.         return 0;

  1695.     }

  1696. }

  1697. 

  1698. static int mpeg1_decode_sequence(AVCodecContext *avctx, 

  1699.                                  UINT8 *buf, int buf_size)

  1700. {

  1701.     Mpeg1Context *s1 = avctx->priv_data;

  1702.     MpegEncContext *s = &s1->mpeg_enc_ctx;

  1703.     int width, height, i, v, j;

  1704. 

  1705.     init_get_bits(&s->gb, buf, buf_size);

  1706. 

  1707.     width = get_bits(&s->gb, 12);

  1708.     height = get_bits(&s->gb, 12);

  1709.     skip_bits(&s->gb, 4);

  1710.     s->frame_rate_index = get_bits(&s->gb, 4);

  1711.     if (s->frame_rate_index == 0)

  1712.         return -1;

  1713.     s->bit_rate = get_bits(&s->gb, 18) * 400;

  1714.     if (get_bits1(&s->gb) == 0) /* marker */

  1715.         return -1;

  1716.     if (width <= 0 || height <= 0 ||

  1717.         (width % 2) != 0 || (height % 2) != 0)

  1718.         return -1;

  1719.     if (width != s->width ||

  1720.         height != s->height) {

  1721.         /* start new mpeg1 context decoding */

  1722.         s->out_format = FMT_MPEG1;

  1723.         if (s1->mpeg_enc_ctx_allocated) {

  1724.             MPV_common_end(s);

  1725.         }

  1726.         s->width = width;

  1727.         s->height = height;

  1728.         avctx->has_b_frames= s->has_b_frames = 1;

  1729.         s->avctx = avctx;

  1730.         avctx->width = width;

  1731.         avctx->height = height;

  1732.         if (s->frame_rate_index >= 9) {

  1733.             /* at least give a valid frame rate (some old mpeg1 have this) */

  1734.             avctx->frame_rate = 25 * FRAME_RATE_BASE;

  1735.         } else {

  1736.             avctx->frame_rate = frame_rate_tab[s->frame_rate_index];

  1737.         }

  1738.         s->frame_rate = avctx->frame_rate;

  1739.         avctx->bit_rate = s->bit_rate;

  1740.         

  1741.         if (MPV_common_init(s) < 0)

  1742.             return -1;

  1743.         s1->mpeg_enc_ctx_allocated = 1;

  1744.     }

  1745. 

  1746.     skip_bits(&s->gb, 10); /* vbv_buffer_size */

  1747.     skip_bits(&s->gb, 1);

  1748. 

  1749.     /* get matrix */

  1750.     if (get_bits1(&s->gb)) {

  1751.         for(i=0;i<64;i++) {

  1752.             v = get_bits(&s->gb, 8);

  1753.             j = s->intra_scantable.permutated[i];

  1754.             s->intra_matrix[j] = v;

  1755.             s->chroma_intra_matrix[j] = v;

  1756.         }

  1757. #ifdef DEBUG

  1758.         dprintf("intra matrix present\n");

  1759.         for(i=0;i<64;i++)

  1760.             dprintf(" %d", s->intra_matrix[s->intra_scantable.permutated[i]]);

  1761.         printf("\n");

  1762. #endif

  1763.     } else {

  1764.         for(i=0;i<64;i++) {

  1765.             int j= s->idct_permutation[i];

  1766.             v = ff_mpeg1_default_intra_matrix[i];

  1767.             s->intra_matrix[j] = v;

  1768.             s->chroma_intra_matrix[j] = v;

  1769.         }

  1770.     }

  1771.     if (get_bits1(&s->gb)) {

  1772.         for(i=0;i<64;i++) {

  1773.             v = get_bits(&s->gb, 8);

  1774.             j = s->intra_scantable.permutated[i];

  1775.             s->inter_matrix[j] = v;

  1776.             s->chroma_inter_matrix[j] = v;

  1777.         }

  1778. #ifdef DEBUG

  1779.         dprintf("non intra matrix present\n");

  1780.         for(i=0;i<64;i++)

  1781.             dprintf(" %d", s->inter_matrix[s->intra_scantable.permutated[i]]);

  1782.         printf("\n");

  1783. #endif

  1784.     } else {

  1785.         for(i=0;i<64;i++) {

  1786.             int j= s->idct_permutation[i];

  1787.             v = ff_mpeg1_default_non_intra_matrix[i];

  1788.             s->inter_matrix[j] = v;

  1789.             s->chroma_inter_matrix[j] = v;

  1790.         }

  1791.     }

  1792. 

  1793.     /* we set mpeg2 parameters so that it emulates mpeg1 */

  1794.     s->progressive_sequence = 1;

  1795.     s->progressive_frame = 1;

  1796.     s->picture_structure = PICT_FRAME;

  1797.     s->frame_pred_frame_dct = 1;

  1798.     s->mpeg2 = 0;

  1799.     avctx->sub_id = 1; /* indicates mpeg1 */

  1800.     return 0;

  1801. }

  1802. 

  1803. /* handle buffering and image synchronisation */

  1804. static int mpeg_decode_frame(AVCodecContext *avctx, 

  1805.                              void *data, int *data_size,

  1806.                              UINT8 *buf, int buf_size)

  1807. {

  1808.     Mpeg1Context *s = avctx->priv_data;

  1809.     UINT8 *buf_end, *buf_ptr, *buf_start;

  1810.     int len, start_code_found, ret, code, start_code, input_size;

  1811.     AVPicture *picture = data;

  1812.     MpegEncContext *s2 = &s->mpeg_enc_ctx;

  1813.             

  1814.     dprintf("fill_buffer\n");

  1815. 

  1816.     *data_size = 0;

  1817. 

  1818.     /* special case for last picture */

  1819.     if (buf_size == 0) {

  1820.         if (s2->picture_number > 0) {

  1821.             picture->data[0] = s2->next_picture[0];

  1822.             picture->data[1] = s2->next_picture[1];

  1823.             picture->data[2] = s2->next_picture[2];

  1824.             picture->linesize[0] = s2->linesize;

  1825.             picture->linesize[1] = s2->uvlinesize;

  1826.             picture->linesize[2] = s2->uvlinesize;

  1827.             *data_size = sizeof(AVPicture);

  1828.         }

  1829.         return 0;

  1830.     }

  1831. 

  1832.     buf_ptr = buf;

  1833.     buf_end = buf + buf_size;

  1834. 

  1835. #if 0    

  1836.     if (s->repeat_field % 2 == 1) { 

  1837.         s->repeat_field++;

  1838.         //fprintf(stderr,"\nRepeating last frame: %d -> %d! pict: %d %d", avctx->frame_number-1, avctx->frame_number,

  1839.         //        s2->picture_number, s->repeat_field);

  1840.         if (avctx->flags & CODEC_FLAG_REPEAT_FIELD) {

  1841.             *data_size = sizeof(AVPicture);

  1842.             goto the_end;

  1843.         }

  1844.     }

  1845. #endif

  1846.     while (buf_ptr < buf_end) {

  1847.         buf_start = buf_ptr;

  1848.         /* find start next code */

  1849.         code = find_start_code(&buf_ptr, buf_end, &s->header_state);

  1850.         if (code >= 0) {

  1851.             start_code_found = 1;

  1852.         } else {

  1853.             start_code_found = 0;

  1854.         }

  1855.         /* copy to buffer */

  1856.         len = buf_ptr - buf_start;

  1857.         if (len + (s->buf_ptr - s->buffer) > s->buffer_size) {

  1858.             /* data too big : flush */

  1859.             s->buf_ptr = s->buffer;

  1860.             if (start_code_found)

  1861.                 s->start_code = code;

  1862.         } else {

  1863.             memcpy(s->buf_ptr, buf_start, len);

  1864.             s->buf_ptr += len;

  1865.             if(   (s2->flags&CODEC_FLAG_NOT_TRUNCATED) && (!start_code_found) 

  1866.                && s->buf_ptr+4<s->buffer+s->buffer_size){

  1867.                 start_code_found= 1;

  1868.                 code= 0x1FF;

  1869.                 s->header_state=0xFF;

  1870.                 s->buf_ptr[0]=0;

  1871.                 s->buf_ptr[1]=0;

  1872.                 s->buf_ptr[2]=1;

  1873.                 s->buf_ptr[3]=0xFF;

  1874.                 s->buf_ptr+=4;

  1875.             }

  1876.             if (start_code_found) {

  1877.                 /* prepare data for next start code */

  1878.                 input_size = s->buf_ptr - s->buffer;

  1879.                 start_code = s->start_code;

  1880.                 s->buf_ptr = s->buffer;

  1881.                 s->start_code = code;

  1882.                 switch(start_code) {

  1883.                 case SEQ_START_CODE:

  1884.                     mpeg1_decode_sequence(avctx, s->buffer, 

  1885.                                           input_size);

  1886.                     break;

  1887.                             

  1888.                 case PICTURE_START_CODE:

  1889.                     /* we have a complete image : we try to decompress it */

  1890.                     mpeg1_decode_picture(avctx, 

  1891.                                          s->buffer, input_size);

  1892.                     break;

  1893.                 case EXT_START_CODE:

  1894.                     mpeg_decode_extension(avctx,

  1895.                                           s->buffer, input_size);

  1896.                     break;

  1897.                 default:

  1898.                     if (start_code >= SLICE_MIN_START_CODE &&

  1899.                         start_code <= SLICE_MAX_START_CODE) {

  1900.                         ret = mpeg_decode_slice(avctx, picture,

  1901.                                                 start_code, s->buffer, input_size);

  1902.                         if (ret == 1) {

  1903.                             /* got a picture: exit */

  1904.                             /* first check if we must repeat the frame */

  1905.                             avctx->repeat_pict = 0;

  1906. #if 0

  1907.                             if (s2->progressive_frame && s2->repeat_first_field) {

  1908.                                 //fprintf(stderr,"\nRepeat this frame: %d! pict: %d",avctx->frame_number,s2->picture_number);

  1909.                                 //s2->repeat_first_field = 0;

  1910.                                 //s2->progressive_frame = 0;

  1911.                                 if (++s->repeat_field > 2)

  1912.                                     s->repeat_field = 0;

  1913.                                 avctx->repeat_pict = 1;

  1914.                             }

  1915. #endif                      

  1916.                             if (s2->repeat_first_field) {

  1917.                                 if (s2->progressive_sequence) {

  1918.                                     if (s2->top_field_first)

  1919.                                         avctx->repeat_pict = 4;

  1920.                                     else

  1921.                                         avctx->repeat_pict = 2;

  1922.                                 } else if (s2->progressive_frame) {

  1923.                                     avctx->repeat_pict = 1;

  1924.                                 }

  1925.                             }         

  1926.                             *data_size = sizeof(AVPicture);

  1927.                             goto the_end;

  1928.                         }else if(ret==-1){

  1929.                             printf("Error while decoding slice\n");

  1930.                         }

  1931.                     }

  1932.                     break;

  1933.                 }

  1934.             }

  1935.         }

  1936.     }

  1937.  the_end:

  1938.     return buf_ptr - buf;

  1939. }

  1940. 

  1941. static int mpeg_decode_end(AVCodecContext *avctx)

  1942. {

  1943.     Mpeg1Context *s = avctx->priv_data;

  1944. 

  1945.     if (s->mpeg_enc_ctx_allocated)

  1946.         MPV_common_end(&s->mpeg_enc_ctx);

  1947.     return 0;

  1948. }

  1949. 

  1950. AVCodec mpeg_decoder = {

  1951.     "mpegvideo",

  1952.     CODEC_TYPE_VIDEO,

  1953.     CODEC_ID_MPEG1VIDEO,

  1954.     sizeof(Mpeg1Context),

  1955.     mpeg_decode_init,

  1956.     NULL,

  1957.     mpeg_decode_end,

  1958.     mpeg_decode_frame,

  1959.     CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,

  1960. };