home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / wvis0626.zip / warpvision_20020626.zip / libavcodec / mpeg12.c < prev    next >
C/C++ Source or Header  |  2002-06-24  |  56KB  |  1,726 lines
  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. /* Start codes. */
  27. #define SEQ_END_CODE        0x000001b7
  28. #define SEQ_START_CODE        0x000001b3
  29. #define GOP_START_CODE        0x000001b8
  30. #define PICTURE_START_CODE    0x00000100
  31. #define SLICE_MIN_START_CODE    0x00000101
  32. #define SLICE_MAX_START_CODE    0x000001af
  33. #define EXT_START_CODE        0x000001b5
  34. #define USER_START_CODE        0x000001b2
  35.  
  36. static void mpeg1_encode_block(MpegEncContext *s, 
  37.                          DCTELEM *block, 
  38.                          int component);
  39. static void mpeg1_encode_motion(MpegEncContext *s, int val);
  40. static void mpeg1_skip_picture(MpegEncContext *s, int pict_num);
  41. static int mpeg1_decode_block(MpegEncContext *s, 
  42.                               DCTELEM *block, 
  43.                               int n);
  44. static int mpeg2_decode_block_non_intra(MpegEncContext *s, 
  45.                                         DCTELEM *block, 
  46.                                         int n);
  47. static int mpeg2_decode_block_intra(MpegEncContext *s, 
  48.                                     DCTELEM *block, 
  49.                                     int n);
  50. static int mpeg_decode_motion(MpegEncContext *s, int fcode, int pred);
  51.  
  52. static UINT16 mv_penalty[MAX_FCODE+1][MAX_MV*2+1];
  53. static UINT8 fcode_tab[MAX_MV*2+1];
  54.  
  55. static void put_header(MpegEncContext *s, int header)
  56. {
  57.     align_put_bits(&s->pb);
  58.     put_bits(&s->pb, 16, header>>16);
  59.     put_bits(&s->pb, 16, header&0xFFFF);
  60. }
  61.  
  62. /* put sequence header if needed */
  63. static void mpeg1_encode_sequence_header(MpegEncContext *s)
  64. {
  65.         unsigned int vbv_buffer_size;
  66.         unsigned int fps, v;
  67.         int n;
  68.         UINT64 time_code;
  69.         
  70.         if (s->picture_in_gop_number == 0) {
  71.             /* mpeg1 header repeated every gop */
  72.             put_header(s, SEQ_START_CODE);
  73.             
  74.             /* search closest frame rate */
  75.             {
  76.                 int i, dmin, d;
  77.                 s->frame_rate_index = 0;
  78.                 dmin = 0x7fffffff;
  79.                 for(i=1;i<9;i++) {
  80.                     d = abs(s->frame_rate - frame_rate_tab[i]);
  81.                     if (d < dmin) {
  82.                         dmin = d;
  83.                         s->frame_rate_index = i;
  84.                     }
  85.                 }
  86.             }
  87.  
  88.             put_bits(&s->pb, 12, s->width);
  89.             put_bits(&s->pb, 12, s->height);
  90.             put_bits(&s->pb, 4, 1); /* 1/1 aspect ratio */
  91.             put_bits(&s->pb, 4, s->frame_rate_index);
  92.             v = s->bit_rate / 400;
  93.             if (v > 0x3ffff)
  94.                 v = 0x3ffff;
  95.             put_bits(&s->pb, 18, v);
  96.             put_bits(&s->pb, 1, 1); /* marker */
  97.             /* vbv buffer size: slightly greater than an I frame. We add
  98.                some margin just in case */
  99.             vbv_buffer_size = (3 * s->I_frame_bits) / (2 * 8);
  100.             put_bits(&s->pb, 10, (vbv_buffer_size + 16383) / 16384); 
  101.             put_bits(&s->pb, 1, 1); /* constrained parameter flag */
  102.             put_bits(&s->pb, 1, 0); /* no custom intra matrix */
  103.             put_bits(&s->pb, 1, 0); /* no custom non intra matrix */
  104.  
  105.             put_header(s, GOP_START_CODE);
  106.             put_bits(&s->pb, 1, 0); /* do drop frame */
  107.             /* time code : we must convert from the real frame rate to a
  108.                fake mpeg frame rate in case of low frame rate */
  109.             fps = frame_rate_tab[s->frame_rate_index];
  110.             time_code = (INT64)s->fake_picture_number * FRAME_RATE_BASE;
  111.             s->gop_picture_number = s->fake_picture_number;
  112.             put_bits(&s->pb, 5, (UINT32)((time_code / (fps * 3600)) % 24));
  113.             put_bits(&s->pb, 6, (UINT32)((time_code / (fps * 60)) % 60));
  114.             put_bits(&s->pb, 1, 1);
  115.             put_bits(&s->pb, 6, (UINT32)((time_code / fps) % 60));
  116.             put_bits(&s->pb, 6, (UINT32)((time_code % fps) / FRAME_RATE_BASE));
  117.             put_bits(&s->pb, 1, 1); /* closed gop */
  118.             put_bits(&s->pb, 1, 0); /* broken link */
  119.         }
  120.  
  121.         if (s->frame_rate < (24 * FRAME_RATE_BASE) && s->picture_number > 0) {
  122.             /* insert empty P pictures to slow down to the desired
  123.                frame rate. Each fake pictures takes about 20 bytes */
  124.             fps = frame_rate_tab[s->frame_rate_index];
  125.             n = (((INT64)s->picture_number * fps) / s->frame_rate) - 1;
  126.             while (s->fake_picture_number < n) {
  127.                 mpeg1_skip_picture(s, s->fake_picture_number - 
  128.                                    s->gop_picture_number); 
  129.                 s->fake_picture_number++;
  130.             }
  131.  
  132.         }
  133. }
  134.  
  135.  
  136. /* insert a fake P picture */
  137. static void mpeg1_skip_picture(MpegEncContext *s, int pict_num)
  138. {
  139.     unsigned int mb_incr;
  140.  
  141.     /* mpeg1 picture header */
  142.     put_header(s, PICTURE_START_CODE);
  143.     /* temporal reference */
  144.     put_bits(&s->pb, 10, pict_num & 0x3ff); 
  145.     
  146.     put_bits(&s->pb, 3, P_TYPE);
  147.     put_bits(&s->pb, 16, 0xffff); /* non constant bit rate */
  148.     
  149.     put_bits(&s->pb, 1, 1); /* integer coordinates */
  150.     put_bits(&s->pb, 3, 1); /* forward_f_code */
  151.     
  152.     put_bits(&s->pb, 1, 0); /* extra bit picture */
  153.     
  154.     /* only one slice */
  155.     put_header(s, SLICE_MIN_START_CODE);
  156.     put_bits(&s->pb, 5, 1); /* quantizer scale */
  157.     put_bits(&s->pb, 1, 0); /* slice extra information */
  158.     
  159.     mb_incr = 1;
  160.     put_bits(&s->pb, mbAddrIncrTable[mb_incr - 1][1], 
  161.              mbAddrIncrTable[mb_incr - 1][0]);
  162.     
  163.     /* empty macroblock */
  164.     put_bits(&s->pb, 3, 1); /* motion only */
  165.     
  166.     /* zero motion x & y */
  167.     put_bits(&s->pb, 1, 1); 
  168.     put_bits(&s->pb, 1, 1); 
  169.  
  170.     /* output a number of empty slice */
  171.     mb_incr = s->mb_width * s->mb_height - 1;
  172.     while (mb_incr > 33) {
  173.         put_bits(&s->pb, 11, 0x008);
  174.         mb_incr -= 33;
  175.     }
  176.     put_bits(&s->pb, mbAddrIncrTable[mb_incr - 1][1], 
  177.              mbAddrIncrTable[mb_incr - 1][0]);
  178.     
  179.     /* empty macroblock */
  180.     put_bits(&s->pb, 3, 1); /* motion only */
  181.     
  182.     /* zero motion x & y */
  183.     put_bits(&s->pb, 1, 1); 
  184.     put_bits(&s->pb, 1, 1); 
  185. }
  186.  
  187. static void common_init(MpegEncContext *s)
  188. {
  189.     s->y_dc_scale_table=
  190.     s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
  191. }
  192.  
  193. void mpeg1_encode_picture_header(MpegEncContext *s, int picture_number)
  194. {
  195.     mpeg1_encode_sequence_header(s);
  196.  
  197.     /* mpeg1 picture header */
  198.     put_header(s, PICTURE_START_CODE);
  199.     /* temporal reference */
  200.     put_bits(&s->pb, 10, (s->fake_picture_number - 
  201.                           s->gop_picture_number) & 0x3ff); 
  202.     s->fake_picture_number++;
  203.     
  204.     put_bits(&s->pb, 3, s->pict_type);
  205.     put_bits(&s->pb, 16, 0xffff); /* non constant bit rate */
  206.     
  207.     if (s->pict_type == P_TYPE) {
  208.         put_bits(&s->pb, 1, 0); /* half pel coordinates */
  209.         put_bits(&s->pb, 3, s->f_code); /* forward_f_code */
  210.     }
  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, s->qscale); /* quantizer scale */
  217.     put_bits(&s->pb, 1, 0); /* slice extra information */
  218. }
  219.  
  220. void mpeg1_encode_mb(MpegEncContext *s,
  221.                      DCTELEM block[6][64],
  222.                      int motion_x, int motion_y)
  223. {
  224.     int mb_incr, i, cbp, mb_x, mb_y;
  225.  
  226.     mb_x = s->mb_x;
  227.     mb_y = s->mb_y;
  228.  
  229.     /* compute cbp */
  230.     cbp = 0;
  231.     for(i=0;i<6;i++) {
  232.         if (s->block_last_index[i] >= 0)
  233.             cbp |= 1 << (5 - i);
  234.     }
  235.  
  236.     /* skip macroblock, except if first or last macroblock of a slice */
  237.     if ((cbp | motion_x | motion_y) == 0 &&
  238.         (!((mb_x | mb_y) == 0 ||
  239.            (mb_x == s->mb_width - 1 && mb_y == s->mb_height - 1)))) {
  240.         s->mb_incr++;
  241.     } else {
  242.         /* output mb incr */
  243.         mb_incr = s->mb_incr;
  244.  
  245.         while (mb_incr > 33) {
  246.             put_bits(&s->pb, 11, 0x008);
  247.             mb_incr -= 33;
  248.         }
  249.         put_bits(&s->pb, mbAddrIncrTable[mb_incr - 1][1], 
  250.                  mbAddrIncrTable[mb_incr - 1][0]);
  251.         
  252.         if (s->pict_type == I_TYPE) {
  253.             put_bits(&s->pb, 1, 1); /* macroblock_type : macroblock_quant = 0 */
  254.         } else {
  255.             if (s->mb_intra) {
  256.                 put_bits(&s->pb, 5, 0x03);
  257.             } else {
  258.                 if (cbp != 0) {
  259.                     if (motion_x == 0 && motion_y == 0) {
  260.                         put_bits(&s->pb, 2, 1); /* macroblock_pattern only */
  261.                         put_bits(&s->pb, mbPatTable[cbp - 1][1], mbPatTable[cbp - 1][0]);
  262.                     } else {
  263.                         put_bits(&s->pb, 1, 1); /* motion + cbp */
  264.                         mpeg1_encode_motion(s, motion_x - s->last_mv[0][0][0]); 
  265.                         mpeg1_encode_motion(s, motion_y - s->last_mv[0][0][1]); 
  266.                         put_bits(&s->pb, mbPatTable[cbp - 1][1], mbPatTable[cbp - 1][0]);
  267.                     }
  268.                 } else {
  269.                     put_bits(&s->pb, 3, 1); /* motion only */
  270.                     mpeg1_encode_motion(s, motion_x - s->last_mv[0][0][0]); 
  271.                     mpeg1_encode_motion(s, motion_y - s->last_mv[0][0][1]); 
  272.                 }
  273.             }
  274.         }
  275.         for(i=0;i<6;i++) {
  276.             if (cbp & (1 << (5 - i))) {
  277.                 mpeg1_encode_block(s, block[i], i);
  278.             }
  279.         }
  280.         s->mb_incr = 1;
  281.     }
  282.     s->last_mv[0][0][0] = motion_x;
  283.     s->last_mv[0][0][1] = motion_y;
  284. }
  285.  
  286. static void mpeg1_encode_motion(MpegEncContext *s, int val)
  287. {
  288.     int code, bit_size, l, m, bits, range, sign;
  289.  
  290.     if (val == 0) {
  291.         /* zero vector */
  292.         code = 0;
  293.         put_bits(&s->pb,
  294.                  mbMotionVectorTable[0][1], 
  295.                  mbMotionVectorTable[0][0]); 
  296.     } else {
  297.         bit_size = s->f_code - 1;
  298.         range = 1 << bit_size;
  299.         /* modulo encoding */
  300.         l = 16 * range;
  301.         m = 2 * l;
  302.         if (val < -l) {
  303.             val += m;
  304.         } else if (val >= l) {
  305.             val -= m;
  306.         }
  307.  
  308.         if (val >= 0) {
  309.             val--;
  310.             code = (val >> bit_size) + 1;
  311.             bits = val & (range - 1);
  312.             sign = 0;
  313.         } else {
  314.             val = -val;
  315.             val--;
  316.             code = (val >> bit_size) + 1;
  317.             bits = val & (range - 1);
  318.             sign = 1;
  319.         }
  320.         put_bits(&s->pb,
  321.                  mbMotionVectorTable[code][1], 
  322.                  mbMotionVectorTable[code][0]); 
  323.         put_bits(&s->pb, 1, sign);
  324.         if (bit_size > 0) {
  325.             put_bits(&s->pb, bit_size, bits);
  326.         }
  327.     }
  328. }
  329.  
  330. void ff_mpeg1_encode_init(MpegEncContext *s)
  331. {
  332.     static int done=0;
  333.  
  334.     common_init(s);
  335.  
  336.     if(!done){
  337.         int f_code;
  338.         int mv;
  339.     int i;
  340.  
  341.         done=1;
  342.         init_rl(&rl_mpeg1);
  343.     
  344.     for(i=0; i<64; i++)
  345.     {
  346.         mpeg1_max_level[0][i]= rl_mpeg1.max_level[0][i];
  347.         mpeg1_index_run[0][i]= rl_mpeg1.index_run[0][i];
  348.     }
  349.  
  350.     /* build unified dc encoding tables */
  351.     for(i=-255; i<256; i++)
  352.     {
  353.         int adiff, index;
  354.         int bits, code;
  355.         int diff=i;
  356.  
  357.         adiff = ABS(diff);
  358.         if(diff<0) diff--;
  359.         index = vlc_dc_table[adiff];
  360.  
  361.         bits= vlc_dc_lum_bits[index] + index;
  362.         code= (vlc_dc_lum_code[index]<<index) + (diff & ((1 << index) - 1));
  363.         mpeg1_lum_dc_uni[i+255]= bits + (code<<8);
  364.         
  365.         bits= vlc_dc_chroma_bits[index] + index;
  366.         code= (vlc_dc_chroma_code[index]<<index) + (diff & ((1 << index) - 1));
  367.         mpeg1_chr_dc_uni[i+255]= bits + (code<<8);
  368.     }
  369.  
  370.         for(f_code=1; f_code<=MAX_FCODE; f_code++){
  371.             for(mv=-MAX_MV; mv<=MAX_MV; mv++){
  372.                 int len;
  373.  
  374.                 if(mv==0) len= mbMotionVectorTable[0][1];
  375.                 else{
  376.                     int val, bit_size, range, code;
  377.  
  378.                     bit_size = s->f_code - 1;
  379.                     range = 1 << bit_size;
  380.  
  381.                     val=mv;
  382.                     if (val < 0) 
  383.                         val = -val;
  384.                     val--;
  385.                     code = (val >> bit_size) + 1;
  386.                     if(code<17){
  387.                         len= mbMotionVectorTable[code][1] + 1 + bit_size;
  388.                     }else{
  389.                         len= mbMotionVectorTable[16][1] + 2 + bit_size;
  390.                     }
  391.                 }
  392.  
  393.                 mv_penalty[f_code][mv+MAX_MV]= len;
  394.             }
  395.         }
  396.         
  397.  
  398.         for(f_code=MAX_FCODE; f_code>0; f_code--){
  399.             for(mv=-(8<<f_code); mv<(8<<f_code); mv++){
  400.                 fcode_tab[mv+MAX_MV]= f_code;
  401.             }
  402.         }
  403.     }
  404.     s->mv_penalty= mv_penalty;
  405.     s->fcode_tab= fcode_tab;
  406.     s->min_qcoeff=-255;
  407.     s->max_qcoeff= 255;
  408.     s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x
  409.     s->inter_quant_bias= 0;
  410. }
  411.  
  412. static inline void encode_dc(MpegEncContext *s, int diff, int component)
  413. {
  414.     if (component == 0) {
  415.         put_bits(
  416.         &s->pb, 
  417.         mpeg1_lum_dc_uni[diff+255]&0xFF,
  418.         mpeg1_lum_dc_uni[diff+255]>>8);
  419.     } else {
  420.         put_bits(
  421.             &s->pb, 
  422.         mpeg1_chr_dc_uni[diff+255]&0xFF,
  423.         mpeg1_chr_dc_uni[diff+255]>>8);
  424.     }
  425. }
  426.  
  427. static void mpeg1_encode_block(MpegEncContext *s, 
  428.                                DCTELEM *block, 
  429.                                int n)
  430. {
  431.     int alevel, level, last_non_zero, dc, diff, i, j, run, last_index, sign;
  432.     int code, component;
  433. //    RLTable *rl = &rl_mpeg1;
  434.  
  435.     last_index = s->block_last_index[n];
  436.  
  437.     /* DC coef */
  438.     if (s->mb_intra) {
  439.         component = (n <= 3 ? 0 : n - 4 + 1);
  440.         dc = block[0]; /* overflow is impossible */
  441.         diff = dc - s->last_dc[component];
  442.         encode_dc(s, diff, component);
  443.         s->last_dc[component] = dc;
  444.         i = 1;
  445.     } else {
  446.         /* encode the first coefficient : needs to be done here because
  447.            it is handled slightly differently */
  448.         level = block[0];
  449.         if (abs(level) == 1) {
  450.                 code = ((UINT32)level >> 31); /* the sign bit */
  451.                 put_bits(&s->pb, 2, code | 0x02);
  452.                 i = 1;
  453.         } else {
  454.             i = 0;
  455.             last_non_zero = -1;
  456.             goto next_coef;
  457.         }
  458.     }
  459.  
  460.     /* now quantify & encode AC coefs */
  461.     last_non_zero = i - 1;
  462.  
  463.     for(;i<=last_index;i++) {
  464.         j = zigzag_direct[i];
  465.         level = block[j];
  466.     next_coef:
  467. #if 0
  468.         if (level != 0)
  469.             dprintf("level[%d]=%d\n", i, level);
  470. #endif            
  471.         /* encode using VLC */
  472.         if (level != 0) {
  473.             run = i - last_non_zero - 1;
  474. #if defined ARCH_X86 && !defined OS2
  475.             asm volatile(
  476.         "movl %2, %1        \n\t"
  477.         "movl %1, %0        \n\t"
  478.         "addl %1, %1        \n\t"
  479.         "sbbl %1, %1        \n\t"
  480.         "xorl %1, %0        \n\t"
  481.         "subl %1, %0        \n\t"
  482.         "andl $1, %1        \n\t"
  483.         : "=&r" (alevel), "=&r" (sign)
  484.         : "g" (level)
  485.         );
  486. #else
  487.             sign = 0;
  488.             alevel = level;
  489.             if (alevel < 0) {
  490.         sign = 1;
  491.                 alevel = -alevel;
  492.         }
  493. #endif
  494. //            code = get_rl_index(rl, 0, run, alevel);
  495.             if (alevel > mpeg1_max_level[0][run])
  496.                 code= 111; /*rl->n*/
  497.             else
  498.                 code= mpeg1_index_run[0][run] + alevel - 1;
  499.  
  500.             if (code < 111 /* rl->n */) {
  501.             /* store the vlc & sign at once */
  502.                 put_bits(&s->pb, mpeg1_vlc[code][1]+1, (mpeg1_vlc[code][0]<<1) + sign);
  503.             } else {
  504.         /* escape seems to be pretty rare <5% so i dont optimize it */
  505.                 put_bits(&s->pb, mpeg1_vlc[111/*rl->n*/][1], mpeg1_vlc[111/*rl->n*/][0]);
  506.                 /* escape: only clip in this case */
  507.                 put_bits(&s->pb, 6, run);
  508.                 if (alevel < 128) {
  509.                     put_bits(&s->pb, 8, level & 0xff);
  510.                 } else {
  511.                     if (level < 0) {
  512.                         put_bits(&s->pb, 16, 0x8001 + level + 255);
  513.                     } else {
  514.                         put_bits(&s->pb, 16, level & 0xffff);
  515.                     }
  516.                 }
  517.             }
  518.             last_non_zero = i;
  519.         }
  520.     }
  521.     /* end of block */
  522.     put_bits(&s->pb, 2, 0x2);
  523. }
  524.  
  525. /******************************************/
  526. /* decoding */
  527.  
  528. static VLC dc_lum_vlc;
  529. static VLC dc_chroma_vlc;
  530. static VLC mv_vlc;
  531. static VLC mbincr_vlc;
  532. static VLC mb_ptype_vlc;
  533. static VLC mb_btype_vlc;
  534. static VLC mb_pat_vlc;
  535.  
  536. void mpeg1_init_vlc(MpegEncContext *s)
  537. {
  538.     static int done = 0;
  539.  
  540.     if (!done) {
  541.         done = 1;
  542.  
  543.         init_vlc(&dc_lum_vlc, 9, 12, 
  544.                  vlc_dc_lum_bits, 1, 1,
  545.                  vlc_dc_lum_code, 2, 2);
  546.         init_vlc(&dc_chroma_vlc, 9, 12, 
  547.                  vlc_dc_chroma_bits, 1, 1,
  548.                  vlc_dc_chroma_code, 2, 2);
  549.         init_vlc(&mv_vlc, 9, 17, 
  550.                  &mbMotionVectorTable[0][1], 2, 1,
  551.                  &mbMotionVectorTable[0][0], 2, 1);
  552.         init_vlc(&mbincr_vlc, 9, 35, 
  553.                  &mbAddrIncrTable[0][1], 2, 1,
  554.                  &mbAddrIncrTable[0][0], 2, 1);
  555.         init_vlc(&mb_pat_vlc, 9, 63, 
  556.                  &mbPatTable[0][1], 2, 1,
  557.                  &mbPatTable[0][0], 2, 1);
  558.         
  559.         init_vlc(&mb_ptype_vlc, 6, 32, 
  560.                  &table_mb_ptype[0][1], 2, 1,
  561.                  &table_mb_ptype[0][0], 2, 1);
  562.         init_vlc(&mb_btype_vlc, 6, 32, 
  563.                  &table_mb_btype[0][1], 2, 1,
  564.                  &table_mb_btype[0][0], 2, 1);
  565.         init_rl(&rl_mpeg1);
  566.         init_rl(&rl_mpeg2);
  567.         /* cannot use generic init because we must add the EOB code */
  568.         init_vlc(&rl_mpeg1.vlc, 9, rl_mpeg1.n + 2, 
  569.                  &rl_mpeg1.table_vlc[0][1], 4, 2,
  570.                  &rl_mpeg1.table_vlc[0][0], 4, 2);
  571.         init_vlc(&rl_mpeg2.vlc, 9, rl_mpeg2.n + 2, 
  572.                  &rl_mpeg2.table_vlc[0][1], 4, 2,
  573.                  &rl_mpeg2.table_vlc[0][0], 4, 2);
  574.     }
  575. }
  576.  
  577. static inline int get_dmv(MpegEncContext *s)
  578. {
  579.     if(get_bits1(&s->gb)) 
  580.         return 1 - (get_bits1(&s->gb) << 1);
  581.     else
  582.         return 0;
  583. }
  584.  
  585. static inline int get_qscale(MpegEncContext *s)
  586. {
  587.     int qscale;
  588.     if (s->mpeg2) {
  589.         if (s->q_scale_type) {
  590.             qscale = non_linear_qscale[get_bits(&s->gb, 5)];
  591.         } else {
  592.             qscale = get_bits(&s->gb, 5) << 1;
  593.         }
  594.     } else {
  595.         /* for mpeg1, we use the generic unquant code */
  596.         qscale = get_bits(&s->gb, 5);
  597.     }
  598.     return qscale;
  599. }
  600.  
  601. /* motion type (for mpeg2) */
  602. #define MT_FIELD 1
  603. #define MT_FRAME 2
  604. #define MT_16X8  2
  605. #define MT_DMV   3
  606.  
  607. static int mpeg_decode_mb(MpegEncContext *s,
  608.                           DCTELEM block[6][64])
  609. {
  610.     int i, j, k, cbp, val, code, mb_type, motion_type;
  611.     
  612.     /* skip mb handling */
  613.     if (s->mb_incr == 0) {
  614.         /* read again increment */
  615.         s->mb_incr = 1;
  616.         for(;;) {
  617.             code = get_vlc(&s->gb, &mbincr_vlc);
  618.             if (code < 0)
  619.                 return 1; /* error = end of slice */
  620.             if (code >= 33) {
  621.                 if (code == 33) {
  622.                     s->mb_incr += 33;
  623.                 }
  624.                 /* otherwise, stuffing, nothing to do */
  625.             } else {
  626.                 s->mb_incr += code;
  627.                 break;
  628.             }
  629.         }
  630.     }
  631.     if (++s->mb_x >= s->mb_width) {
  632.         s->mb_x = 0;
  633.         if (s->mb_y >= (s->mb_height - 1))
  634.             return -1;
  635.         s->mb_y++;
  636.     }
  637.     dprintf("decode_mb: x=%d y=%d\n", s->mb_x, s->mb_y);
  638.  
  639.     if (--s->mb_incr != 0) {
  640.         /* skip mb */
  641.         s->mb_intra = 0;
  642.         for(i=0;i<6;i++)
  643.             s->block_last_index[i] = -1;
  644.         s->mv_type = MV_TYPE_16X16;
  645.         if (s->pict_type == P_TYPE) {
  646.             /* if P type, zero motion vector is implied */
  647.             s->mv_dir = MV_DIR_FORWARD;
  648.             s->mv[0][0][0] = s->mv[0][0][1] = 0;
  649.             s->last_mv[0][0][0] = s->last_mv[0][0][1] = 0;
  650.             s->last_mv[0][1][0] = s->last_mv[0][1][1] = 0;
  651.         } else {
  652.             /* if B type, reuse previous vectors and directions */
  653.             s->mv[0][0][0] = s->last_mv[0][0][0];
  654.             s->mv[0][0][1] = s->last_mv[0][0][1];
  655.             s->mv[1][0][0] = s->last_mv[1][0][0];
  656.             s->mv[1][0][1] = s->last_mv[1][0][1];
  657.         }
  658.         s->mb_skiped = 1;
  659.         return 0;
  660.     }
  661.  
  662.     switch(s->pict_type) {
  663.     default:
  664.     case I_TYPE:
  665.         if (get_bits1(&s->gb) == 0) {
  666.             if (get_bits1(&s->gb) == 0)
  667.                 return -1;
  668.             mb_type = MB_QUANT | MB_INTRA;
  669.         } else {
  670.             mb_type = MB_INTRA;
  671.         }
  672.         break;
  673.     case P_TYPE:
  674.         mb_type = get_vlc(&s->gb, &mb_ptype_vlc);
  675.         if (mb_type < 0)
  676.             return -1;
  677.         break;
  678.     case B_TYPE:
  679.         mb_type = get_vlc(&s->gb, &mb_btype_vlc);
  680.         if (mb_type < 0)
  681.             return -1;
  682.         break;
  683.     }
  684.     dprintf("mb_type=%x\n", mb_type);
  685.     motion_type = 0; /* avoid warning */
  686.     if (mb_type & (MB_FOR|MB_BACK)) {
  687.         /* get additionnal motion vector type */
  688.         if (s->picture_structure == PICT_FRAME && s->frame_pred_frame_dct) 
  689.             motion_type = MT_FRAME;
  690.         else
  691.             motion_type = get_bits(&s->gb, 2);
  692.     }
  693.     /* compute dct type */
  694.     if (s->picture_structure == PICT_FRAME && 
  695.         !s->frame_pred_frame_dct &&
  696.         (mb_type & (MB_PAT | MB_INTRA))) {
  697.         s->interlaced_dct = get_bits1(&s->gb);
  698. #ifdef DEBUG
  699.         if (s->interlaced_dct)
  700.             printf("interlaced_dct\n");
  701. #endif
  702.     } else {
  703.         s->interlaced_dct = 0; /* frame based */
  704.     }
  705.  
  706.     if (mb_type & MB_QUANT) {
  707.         s->qscale = get_qscale(s);
  708.     }
  709.     if (mb_type & MB_INTRA) {
  710.         if (s->concealment_motion_vectors) {
  711.             /* just parse them */
  712.             if (s->picture_structure != PICT_FRAME) 
  713.                 skip_bits1(&s->gb); /* field select */
  714.             mpeg_decode_motion(s, s->mpeg_f_code[0][0], 0);
  715.             mpeg_decode_motion(s, s->mpeg_f_code[0][1], 0);
  716.         }
  717.         s->mb_intra = 1;
  718.         cbp = 0x3f;
  719.         memset(s->last_mv, 0, sizeof(s->last_mv)); /* reset mv prediction */
  720.     } else {
  721.         s->mb_intra = 0;
  722.         cbp = 0;
  723.     }
  724.     /* special case of implicit zero motion vector */
  725.     if (s->pict_type == P_TYPE && !(mb_type & MB_FOR)) {
  726.         s->mv_dir = MV_DIR_FORWARD;
  727.         s->mv_type = MV_TYPE_16X16;
  728.         s->last_mv[0][0][0] = 0;
  729.         s->last_mv[0][0][1] = 0;
  730.         s->last_mv[0][1][0] = 0;
  731.         s->last_mv[0][1][1] = 0;
  732.         s->mv[0][0][0] = 0;
  733.         s->mv[0][0][1] = 0;
  734.     } else if (mb_type & (MB_FOR | MB_BACK)) {
  735.         /* motion vectors */
  736.         s->mv_dir = 0;
  737.         for(i=0;i<2;i++) {
  738.             if (mb_type & (MB_FOR >> i)) {
  739.                 s->mv_dir |= (MV_DIR_FORWARD >> i);
  740.                 dprintf("motion_type=%d\n", motion_type);
  741.                 switch(motion_type) {
  742.                 case MT_FRAME: /* or MT_16X8 */
  743.                     if (s->picture_structure == PICT_FRAME) {
  744.                         /* MT_FRAME */
  745.                         s->mv_type = MV_TYPE_16X16;
  746.                         for(k=0;k<2;k++) {
  747.                             val = mpeg_decode_motion(s, s->mpeg_f_code[i][k], 
  748.                                                      s->last_mv[i][0][k]);
  749.                             s->last_mv[i][0][k] = val;
  750.                             s->last_mv[i][1][k] = val;
  751.                             /* full_pel: only for mpeg1 */
  752.                             if (s->full_pel[i])
  753.                                 val = val << 1;
  754.                             s->mv[i][0][k] = val;
  755.                             dprintf("mv%d: %d\n", k, val);
  756.                         }
  757.                     } else {
  758.                         /* MT_16X8 */
  759.                         s->mv_type = MV_TYPE_16X8;
  760.                         for(j=0;j<2;j++) {
  761.                             s->field_select[i][j] = get_bits1(&s->gb);
  762.                             for(k=0;k<2;k++) {
  763.                                 val = mpeg_decode_motion(s, s->mpeg_f_code[i][k],
  764.                                                          s->last_mv[i][j][k]);
  765.                                 s->last_mv[i][j][k] = val;
  766.                                 s->mv[i][j][k] = val;
  767.                             }
  768.                         }
  769.                     }
  770.                     break;
  771.                 case MT_FIELD:
  772.                     if (s->picture_structure == PICT_FRAME) {
  773.                         s->mv_type = MV_TYPE_FIELD;
  774.                         for(j=0;j<2;j++) {
  775.                             s->field_select[i][j] = get_bits1(&s->gb);
  776.                             val = mpeg_decode_motion(s, s->mpeg_f_code[i][0],
  777.                                                      s->last_mv[i][j][0]);
  778.                             s->last_mv[i][j][0] = val;
  779.                             s->mv[i][j][0] = val;
  780.                             dprintf("fmx=%d\n", val);
  781.                             val = mpeg_decode_motion(s, s->mpeg_f_code[i][1],
  782.                                                      s->last_mv[i][j][1] >> 1);
  783.                             s->last_mv[i][j][1] = val << 1;
  784.                             s->mv[i][j][1] = val;
  785.                             dprintf("fmy=%d\n", val);
  786.                         }
  787.                     } else {
  788.                         s->mv_type = MV_TYPE_16X16;
  789.                         s->field_select[i][0] = get_bits1(&s->gb);
  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.                             s->mv[i][0][k] = val;
  796.                         }
  797.                     }
  798.                     break;
  799.                 case MT_DMV:
  800.                     {
  801.                         int dmx, dmy, mx, my, m;
  802.  
  803.                         mx = mpeg_decode_motion(s, s->mpeg_f_code[i][0], 
  804.                                                 s->last_mv[i][0][0]);
  805.                         s->last_mv[i][0][0] = mx;
  806.                         s->last_mv[i][1][0] = mx;
  807.                         dmx = get_dmv(s);
  808.                         my = mpeg_decode_motion(s, s->mpeg_f_code[i][1], 
  809.                                                 s->last_mv[i][0][1] >> 1);
  810.                         dmy = get_dmv(s);
  811.                         s->mv_type = MV_TYPE_DMV;
  812.                         /* XXX: totally broken */
  813.                         if (s->picture_structure == PICT_FRAME) {
  814.                             s->last_mv[i][0][1] = my << 1;
  815.                             s->last_mv[i][1][1] = my << 1;
  816.  
  817.                             m = s->top_field_first ? 1 : 3;
  818.                             /* top -> top pred */
  819.                             s->mv[i][0][0] = mx; 
  820.                             s->mv[i][0][1] = my << 1;
  821.                             s->mv[i][1][0] = ((mx * m + (mx > 0)) >> 1) + dmx;
  822.                             s->mv[i][1][1] = ((my * m + (my > 0)) >> 1) + dmy - 1;
  823.                             m = 4 - m;
  824.                             s->mv[i][2][0] = mx;
  825.                             s->mv[i][2][1] = my << 1;
  826.                             s->mv[i][3][0] = ((mx * m + (mx > 0)) >> 1) + dmx;
  827.                             s->mv[i][3][1] = ((my * m + (my > 0)) >> 1) + dmy + 1;
  828.                         } else {
  829.                             s->last_mv[i][0][1] = my;
  830.                             s->last_mv[i][1][1] = my;
  831.                             s->mv[i][0][0] = mx;
  832.                             s->mv[i][0][1] = my;
  833.                             s->mv[i][1][0] = ((mx + (mx > 0)) >> 1) + dmx;
  834.                             s->mv[i][1][1] = ((my + (my > 0)) >> 1) + dmy - 1 
  835.                                 /* + 2 * cur_field */;
  836.                         }
  837.                     }
  838.                     break;
  839.                 }
  840.             }
  841.         }
  842.     }
  843.  
  844.     if ((mb_type & MB_INTRA) && s->concealment_motion_vectors) {
  845.         skip_bits1(&s->gb); /* marker */
  846.     }
  847.     
  848.     if (mb_type & MB_PAT) {
  849.         cbp = get_vlc(&s->gb, &mb_pat_vlc);
  850.         if (cbp < 0)
  851.             return -1;
  852.         cbp++;
  853.     }
  854.     dprintf("cbp=%x\n", cbp);
  855.  
  856.     if (s->mpeg2) {
  857.         if (s->mb_intra) {
  858.             for(i=0;i<6;i++) {
  859.                 if (cbp & (1 << (5 - i))) {
  860.                     if (mpeg2_decode_block_intra(s, block[i], i) < 0)
  861.                         return -1;
  862.                 } else {
  863.                     s->block_last_index[i] = -1;
  864.                 }
  865.             }
  866.         } else {
  867.             for(i=0;i<6;i++) {
  868.                 if (cbp & (1 << (5 - i))) {
  869.                     if (mpeg2_decode_block_non_intra(s, block[i], i) < 0)
  870.                         return -1;
  871.                 } else {
  872.                     s->block_last_index[i] = -1;
  873.                 }
  874.             }
  875.         }
  876.     } else {
  877.         for(i=0;i<6;i++) {
  878.             if (cbp & (1 << (5 - i))) {
  879.                 if (mpeg1_decode_block(s, block[i], i) < 0)
  880.                     return -1;
  881.             } else {
  882.                 s->block_last_index[i] = -1;
  883.             }
  884.         }
  885.     }
  886.     return 0;
  887. }
  888.  
  889. /* as h263, but only 17 codes */
  890. static int mpeg_decode_motion(MpegEncContext *s, int fcode, int pred)
  891. {
  892.     int code, sign, val, m, l, shift;
  893.  
  894.     code = get_vlc(&s->gb, &mv_vlc);
  895.     if (code < 0) {
  896.         return 0xffff;
  897.     }
  898.     if (code == 0) {
  899.         return pred;
  900.     }
  901.     sign = get_bits1(&s->gb);
  902.     shift = fcode - 1;
  903.     val = (code - 1) << shift;
  904.     if (shift > 0)
  905.         val |= get_bits(&s->gb, shift);
  906.     val++;
  907.     if (sign)
  908.         val = -val;
  909.     val += pred;
  910.     
  911.     /* modulo decoding */
  912.     l = (1 << shift) * 16;
  913.     m = 2 * l;
  914.     if (val < -l) {
  915.         val += m;
  916.     } else if (val >= l) {
  917.         val -= m;
  918.     }
  919.     return val;
  920. }
  921.  
  922. static inline int decode_dc(MpegEncContext *s, int component)
  923. {
  924.     int code, diff;
  925.  
  926.     if (component == 0) {
  927.         code = get_vlc(&s->gb, &dc_lum_vlc);
  928.     } else {
  929.         code = get_vlc(&s->gb, &dc_chroma_vlc);
  930.     }
  931.     if (code < 0)
  932.         return 0xffff;
  933.     if (code == 0) {
  934.         diff = 0;
  935.     } else {
  936.         diff = get_bits(&s->gb, code);
  937.         if ((diff & (1 << (code - 1))) == 0) 
  938.             diff = (-1 << code) | (diff + 1);
  939.     }
  940.     return diff;
  941. }
  942.  
  943. static int mpeg1_decode_block(MpegEncContext *s, 
  944.                                DCTELEM *block, 
  945.                                int n)
  946. {
  947.     int level, dc, diff, i, j, run;
  948.     int code, component;
  949.     RLTable *rl = &rl_mpeg1;
  950.  
  951.     if (s->mb_intra) {
  952.         /* DC coef */
  953.         component = (n <= 3 ? 0 : n - 4 + 1);
  954.         diff = decode_dc(s, component);
  955.         if (diff >= 0xffff)
  956.             return -1;
  957.         dc = s->last_dc[component];
  958.         dc += diff;
  959.         s->last_dc[component] = dc;
  960.         block[0] = dc;
  961.         dprintf("dc=%d diff=%d\n", dc, diff);
  962.         i = 1;
  963.     } else {
  964.         int bit_cnt, v;
  965.         UINT32 bit_buf;
  966.         UINT8 *buf_ptr;
  967.         i = 0;
  968.         /* special case for the first coef. no need to add a second vlc table */
  969.         SAVE_BITS(&s->gb);
  970.         SHOW_BITS(&s->gb, v, 2);
  971.         if (v & 2) {
  972.             run = 0;
  973.             level = 1 - ((v & 1) << 1);
  974.             FLUSH_BITS(2);
  975.             RESTORE_BITS(&s->gb);
  976.             goto add_coef;
  977.         }
  978.         RESTORE_BITS(&s->gb);
  979.     }
  980.  
  981.     /* now quantify & encode AC coefs */
  982.     for(;;) {
  983.         code = get_vlc(&s->gb, &rl->vlc);
  984.         if (code < 0) {
  985.             return -1;
  986.         }
  987.         if (code == 112) {
  988.             break;
  989.         } else if (code == 111) {
  990.             /* escape */
  991.             run = get_bits(&s->gb, 6);
  992.             level = get_bits(&s->gb, 8);
  993.             level = (level << 24) >> 24;
  994.             if (level == -128) {
  995.                 level = get_bits(&s->gb, 8) - 256;
  996.             } else if (level == 0) {
  997.                 level = get_bits(&s->gb, 8);
  998.             }
  999.         } else {
  1000.             run = rl->table_run[code];
  1001.             level = rl->table_level[code];
  1002.             if (get_bits1(&s->gb))
  1003.                 level = -level;
  1004.         }
  1005.         i += run;
  1006.         if (i >= 64)
  1007.             return -1;
  1008.     add_coef:
  1009.         dprintf("%d: run=%d level=%d\n", n, run, level);
  1010.     j = zigzag_direct[i];
  1011.         block[j] = level;
  1012.         i++;
  1013.     }
  1014.     s->block_last_index[n] = i-1;
  1015.     return 0;
  1016. }
  1017.  
  1018. /* Also does unquantization here, since I will never support mpeg2
  1019.    encoding */
  1020. static int mpeg2_decode_block_non_intra(MpegEncContext *s, 
  1021.                                         DCTELEM *block, 
  1022.                                         int n)
  1023. {
  1024.     int level, i, j, run;
  1025.     int code;
  1026.     RLTable *rl = &rl_mpeg1;
  1027.     const UINT8 *scan_table;
  1028.     const UINT16 *matrix;
  1029.     int mismatch;
  1030.  
  1031.     if (s->alternate_scan)
  1032.         scan_table = ff_alternate_vertical_scan;
  1033.     else
  1034.         scan_table = zigzag_direct;
  1035.     mismatch = 1;
  1036.  
  1037.     {
  1038.         int bit_cnt, v;
  1039.         UINT32 bit_buf;
  1040.         UINT8 *buf_ptr;
  1041.         i = 0;
  1042.         if (n < 4) 
  1043.             matrix = s->inter_matrix;
  1044.         else
  1045.             matrix = s->chroma_inter_matrix;
  1046.             
  1047.         /* special case for the first coef. no need to add a second vlc table */
  1048.         SAVE_BITS(&s->gb);
  1049.         SHOW_BITS(&s->gb, v, 2);
  1050.         if (v & 2) {
  1051.             run = 0;
  1052.             level = 1 - ((v & 1) << 1);
  1053.             FLUSH_BITS(2);
  1054.             RESTORE_BITS(&s->gb);
  1055.             goto add_coef;
  1056.         }
  1057.         RESTORE_BITS(&s->gb);
  1058.     }
  1059.  
  1060.     /* now quantify & encode AC coefs */
  1061.     for(;;) {
  1062.         code = get_vlc(&s->gb, &rl->vlc);
  1063.         if (code < 0)
  1064.             return -1;
  1065.         if (code == 112) {
  1066.             break;
  1067.         } else if (code == 111) {
  1068.             /* escape */
  1069.             run = get_bits(&s->gb, 6);
  1070.             level = get_bits(&s->gb, 12);
  1071.             level = (level << 20) >> 20;
  1072.         } else {
  1073.             run = rl->table_run[code];
  1074.             level = rl->table_level[code];
  1075.             if (get_bits1(&s->gb))
  1076.                 level = -level;
  1077.         }
  1078.         i += run;
  1079.         if (i >= 64)
  1080.             return -1;
  1081.     add_coef:
  1082.     j = scan_table[i];
  1083.         dprintf("%d: run=%d level=%d\n", n, run, level);
  1084.         /* XXX: optimize */
  1085.         if (level > 0) {
  1086.             level = ((level * 2 + 1) * s->qscale * matrix[j]) >> 5;
  1087.         } else {
  1088.             level = ((-level * 2 + 1) * s->qscale * matrix[j]) >> 5;
  1089.             level = -level;
  1090.         }
  1091.         /* XXX: is it really necessary to saturate since the encoder
  1092.            knows whats going on ? */
  1093.         mismatch ^= level;
  1094.         block[j] = level;
  1095.         i++;
  1096.     }
  1097.     block[63] ^= (mismatch & 1);
  1098.     s->block_last_index[n] = i;
  1099.     return 0;
  1100. }
  1101.  
  1102. static int mpeg2_decode_block_intra(MpegEncContext *s, 
  1103.                                     DCTELEM *block, 
  1104.                                     int n)
  1105. {
  1106.     int level, dc, diff, i, j, run;
  1107.     int code, component;
  1108.     RLTable *rl;
  1109.     const UINT8 *scan_table;
  1110.     const UINT16 *matrix;
  1111.     int mismatch;
  1112.  
  1113.     if (s->alternate_scan)
  1114.         scan_table = ff_alternate_vertical_scan;
  1115.     else
  1116.         scan_table = zigzag_direct;
  1117.  
  1118.     /* DC coef */
  1119.     component = (n <= 3 ? 0 : n - 4 + 1);
  1120.     diff = decode_dc(s, component);
  1121.     if (diff >= 0xffff)
  1122.         return -1;
  1123.     dc = s->last_dc[component];
  1124.     dc += diff;
  1125.     s->last_dc[component] = dc;
  1126.     block[0] = dc << (3 - s->intra_dc_precision);
  1127.     dprintf("dc=%d\n", block[0]);
  1128.     mismatch = block[0] ^ 1;
  1129.     i = 1;
  1130.     if (s->intra_vlc_format)
  1131.         rl = &rl_mpeg2;
  1132.     else
  1133.         rl = &rl_mpeg1;
  1134.     if (n < 4) 
  1135.         matrix = s->intra_matrix;
  1136.     else
  1137.         matrix = s->chroma_intra_matrix;
  1138.  
  1139.     /* now quantify & encode AC coefs */
  1140.     for(;;) {
  1141.         code = get_vlc(&s->gb, &rl->vlc);
  1142.         if (code < 0)
  1143.             return -1;
  1144.         if (code == 112) {
  1145.             break;
  1146.         } else if (code == 111) {
  1147.             /* escape */
  1148.             run = get_bits(&s->gb, 6);
  1149.             level = get_bits(&s->gb, 12);
  1150.             level = (level << 20) >> 20;
  1151.         } else {
  1152.             run = rl->table_run[code];
  1153.             level = rl->table_level[code];
  1154.             if (get_bits1(&s->gb))
  1155.                 level = -level;
  1156.         }
  1157.         i += run;
  1158.         if (i >= 64)
  1159.             return -1;
  1160.     j = scan_table[i];
  1161.         dprintf("%d: run=%d level=%d\n", n, run, level);
  1162.         level = (level * s->qscale * matrix[j]) / 16;
  1163.         /* XXX: is it really necessary to saturate since the encoder
  1164.            knows whats going on ? */
  1165.         mismatch ^= level;
  1166.         block[j] = level;
  1167.         i++;
  1168.     }
  1169.     block[63] ^= (mismatch & 1);
  1170.     s->block_last_index[n] = i;
  1171.     return 0;
  1172. }
  1173.  
  1174. /* compressed picture size */
  1175. #define PICTURE_BUFFER_SIZE 100000
  1176.  
  1177. typedef struct Mpeg1Context {
  1178.     MpegEncContext mpeg_enc_ctx;
  1179.     UINT32 header_state;
  1180.     int start_code; /* current start code */
  1181.     UINT8 buffer[PICTURE_BUFFER_SIZE]; 
  1182.     UINT8 *buf_ptr;
  1183.     int buffer_size;
  1184.     int mpeg_enc_ctx_allocated; /* true if decoding context allocated */
  1185.     int repeat_field; /* true if we must repeat the field */
  1186. } Mpeg1Context;
  1187.  
  1188. static int mpeg_decode_init(AVCodecContext *avctx)
  1189. {
  1190.     Mpeg1Context *s = avctx->priv_data;
  1191.     
  1192.     common_init(&s->mpeg_enc_ctx);
  1193.  
  1194.     s->header_state = 0xff;
  1195.     s->mpeg_enc_ctx_allocated = 0;
  1196.     s->buffer_size = PICTURE_BUFFER_SIZE;
  1197.     s->start_code = -1;
  1198.     s->buf_ptr = s->buffer;
  1199.     s->mpeg_enc_ctx.picture_number = 0;
  1200.     s->repeat_field = 0;
  1201.     s->mpeg_enc_ctx.codec_id= avctx->codec->id;
  1202.     avctx->mbskip_table= s->mpeg_enc_ctx.mbskip_table;
  1203.     s->mpeg_enc_ctx.flags= avctx->flags;
  1204.     return 0;
  1205. }
  1206.  
  1207. /* return the 8 bit start code value and update the search
  1208.    state. Return -1 if no start code found */
  1209. static int find_start_code(UINT8 **pbuf_ptr, UINT8 *buf_end, 
  1210.                            UINT32 *header_state)
  1211. {
  1212.     UINT8 *buf_ptr;
  1213.     unsigned int state, v;
  1214.     int val;
  1215.  
  1216.     state = *header_state;
  1217.     buf_ptr = *pbuf_ptr;
  1218.     while (buf_ptr < buf_end) {
  1219.         v = *buf_ptr++;
  1220.         if (state == 0x000001) {
  1221.             state = ((state << 8) | v) & 0xffffff;
  1222.             val = state;
  1223.             goto found;
  1224.         }
  1225.         state = ((state << 8) | v) & 0xffffff;
  1226.     }
  1227.     val = -1;
  1228.  found:
  1229.     *pbuf_ptr = buf_ptr;
  1230.     *header_state = state;
  1231.     return val;
  1232. }
  1233.  
  1234. static int mpeg1_decode_picture(AVCodecContext *avctx, 
  1235.                                 UINT8 *buf, int buf_size)
  1236. {
  1237.     Mpeg1Context *s1 = avctx->priv_data;
  1238.     MpegEncContext *s = &s1->mpeg_enc_ctx;
  1239.     int ref, f_code;
  1240.  
  1241.     init_get_bits(&s->gb, buf, buf_size);
  1242.  
  1243.     ref = get_bits(&s->gb, 10); /* temporal ref */
  1244.     s->pict_type = get_bits(&s->gb, 3);
  1245.     dprintf("pict_type=%d number=%d\n", s->pict_type, s->picture_number);
  1246.     skip_bits(&s->gb, 16);
  1247.     if (s->pict_type == P_TYPE || s->pict_type == B_TYPE) {
  1248.         s->full_pel[0] = get_bits1(&s->gb);
  1249.         f_code = get_bits(&s->gb, 3);
  1250.         if (f_code == 0)
  1251.             return -1;
  1252.         s->mpeg_f_code[0][0] = f_code;
  1253.         s->mpeg_f_code[0][1] = f_code;
  1254.     }
  1255.     if (s->pict_type == B_TYPE) {
  1256.         s->full_pel[1] = get_bits1(&s->gb);
  1257.         f_code = get_bits(&s->gb, 3);
  1258.         if (f_code == 0)
  1259.             return -1;
  1260.         s->mpeg_f_code[1][0] = f_code;
  1261.         s->mpeg_f_code[1][1] = f_code;
  1262.     }
  1263.     s->y_dc_scale = 8;
  1264.     s->c_dc_scale = 8;
  1265.     s->first_slice = 1;
  1266.     return 0;
  1267. }
  1268.  
  1269. static void mpeg_decode_sequence_extension(MpegEncContext *s)
  1270. {
  1271.     int horiz_size_ext, vert_size_ext;
  1272.     int bit_rate_ext, vbv_buf_ext, low_delay;
  1273.     int frame_rate_ext_n, frame_rate_ext_d;
  1274.  
  1275.     skip_bits(&s->gb, 8); /* profil and level */
  1276.     s->progressive_sequence = get_bits1(&s->gb); /* progressive_sequence */
  1277.     skip_bits(&s->gb, 2); /* chroma_format */
  1278.     horiz_size_ext = get_bits(&s->gb, 2);
  1279.     vert_size_ext = get_bits(&s->gb, 2);
  1280.     s->width |= (horiz_size_ext << 12);
  1281.     s->height |= (vert_size_ext << 12);
  1282.     bit_rate_ext = get_bits(&s->gb, 12);  /* XXX: handle it */
  1283.     s->bit_rate = ((s->bit_rate / 400) | (bit_rate_ext << 12)) * 400;
  1284.     skip_bits1(&s->gb); /* marker */
  1285.     vbv_buf_ext = get_bits(&s->gb, 8);
  1286.     low_delay = get_bits1(&s->gb);
  1287.     frame_rate_ext_n = get_bits(&s->gb, 2);
  1288.     frame_rate_ext_d = get_bits(&s->gb, 5);
  1289.     if (frame_rate_ext_d >= 1)
  1290.         s->frame_rate = (s->frame_rate * frame_rate_ext_n) / frame_rate_ext_d;
  1291.     dprintf("sequence extension\n");
  1292.     s->mpeg2 = 1;
  1293.     s->avctx->sub_id = 2; /* indicates mpeg2 found */
  1294. }
  1295.  
  1296. static void mpeg_decode_quant_matrix_extension(MpegEncContext *s)
  1297. {
  1298.     int i, v, j;
  1299.  
  1300.     dprintf("matrix extension\n");
  1301.  
  1302.     if (get_bits1(&s->gb)) {
  1303.         for(i=0;i<64;i++) {
  1304.             v = get_bits(&s->gb, 8);
  1305.             j = zigzag_direct[i];
  1306.             s->intra_matrix[j] = v;
  1307.             s->chroma_intra_matrix[j] = v;
  1308.         }
  1309.     }
  1310.     if (get_bits1(&s->gb)) {
  1311.         for(i=0;i<64;i++) {
  1312.             v = get_bits(&s->gb, 8);
  1313.             j = zigzag_direct[i];
  1314.             s->inter_matrix[j] = v;
  1315.             s->chroma_inter_matrix[j] = v;
  1316.         }
  1317.     }
  1318.     if (get_bits1(&s->gb)) {
  1319.         for(i=0;i<64;i++) {
  1320.             v = get_bits(&s->gb, 8);
  1321.             j = zigzag_direct[i];
  1322.             s->chroma_intra_matrix[j] = v;
  1323.         }
  1324.     }
  1325.     if (get_bits1(&s->gb)) {
  1326.         for(i=0;i<64;i++) {
  1327.             v = get_bits(&s->gb, 8);
  1328.             j = zigzag_direct[i];
  1329.             s->chroma_inter_matrix[j] = v;
  1330.         }
  1331.     }
  1332. }
  1333.  
  1334. static void mpeg_decode_picture_coding_extension(MpegEncContext *s)
  1335. {
  1336.     s->full_pel[0] = s->full_pel[1] = 0;
  1337.     s->mpeg_f_code[0][0] = get_bits(&s->gb, 4);
  1338.     s->mpeg_f_code[0][1] = get_bits(&s->gb, 4);
  1339.     s->mpeg_f_code[1][0] = get_bits(&s->gb, 4);
  1340.     s->mpeg_f_code[1][1] = get_bits(&s->gb, 4);
  1341.     s->intra_dc_precision = get_bits(&s->gb, 2);
  1342.     s->picture_structure = get_bits(&s->gb, 2);
  1343.     s->top_field_first = get_bits1(&s->gb);
  1344.     s->frame_pred_frame_dct = get_bits1(&s->gb);
  1345.     s->concealment_motion_vectors = get_bits1(&s->gb);
  1346.     s->q_scale_type = get_bits1(&s->gb);
  1347.     s->intra_vlc_format = get_bits1(&s->gb);
  1348.     s->alternate_scan = get_bits1(&s->gb);
  1349.     s->repeat_first_field = get_bits1(&s->gb);
  1350.     s->chroma_420_type = get_bits1(&s->gb);
  1351.     s->progressive_frame = get_bits1(&s->gb);
  1352.     /* composite display not parsed */
  1353.     dprintf("intra_dc_precision=%d\n", s->intra_dc_precision);
  1354.     dprintf("picture_structure=%d\n", s->picture_structure);
  1355.     dprintf("top field first=%d\n", s->top_field_first);
  1356.     dprintf("repeat first field=%d\n", s->repeat_first_field);
  1357.     dprintf("conceal=%d\n", s->concealment_motion_vectors);
  1358.     dprintf("intra_vlc_format=%d\n", s->intra_vlc_format);
  1359.     dprintf("alternate_scan=%d\n", s->alternate_scan);
  1360.     dprintf("frame_pred_frame_dct=%d\n", s->frame_pred_frame_dct);
  1361.     dprintf("progressive_frame=%d\n", s->progressive_frame);
  1362. }
  1363.  
  1364. static void mpeg_decode_extension(AVCodecContext *avctx, 
  1365.                                   UINT8 *buf, int buf_size)
  1366. {
  1367.     Mpeg1Context *s1 = avctx->priv_data;
  1368.     MpegEncContext *s = &s1->mpeg_enc_ctx;
  1369.     int ext_type;
  1370.  
  1371.     init_get_bits(&s->gb, buf, buf_size);
  1372.     
  1373.     ext_type = get_bits(&s->gb, 4);
  1374.     switch(ext_type) {
  1375.     case 0x1:
  1376.         /* sequence ext */
  1377.         mpeg_decode_sequence_extension(s);
  1378.         break;
  1379.     case 0x3:
  1380.         /* quant matrix extension */
  1381.         mpeg_decode_quant_matrix_extension(s);
  1382.         break;
  1383.     case 0x8:
  1384.         /* picture extension */
  1385.         mpeg_decode_picture_coding_extension(s);
  1386.         break;
  1387.     }
  1388. }
  1389.  
  1390. /* return 1 if end of frame */
  1391. static int mpeg_decode_slice(AVCodecContext *avctx, 
  1392.                               AVPicture *pict,
  1393.                               int start_code,
  1394.                               UINT8 *buf, int buf_size)
  1395. {
  1396.     Mpeg1Context *s1 = avctx->priv_data;
  1397.     MpegEncContext *s = &s1->mpeg_enc_ctx;
  1398.     int ret;
  1399.  
  1400.     start_code = (start_code - 1) & 0xff;
  1401.     if (start_code >= s->mb_height)
  1402.         return -1;
  1403.     s->last_dc[0] = 1 << (7 + s->intra_dc_precision);
  1404.     s->last_dc[1] = s->last_dc[0];
  1405.     s->last_dc[2] = s->last_dc[0];
  1406.     memset(s->last_mv, 0, sizeof(s->last_mv));
  1407.     s->mb_x = -1;
  1408.     s->mb_y = start_code;
  1409.     s->mb_incr = 0;
  1410.     /* start frame decoding */
  1411.     if (s->first_slice) {
  1412.         s->first_slice = 0;
  1413.         MPV_frame_start(s);
  1414.     }
  1415.  
  1416.     init_get_bits(&s->gb, buf, buf_size);
  1417.  
  1418.     s->qscale = get_qscale(s);
  1419.     /* extra slice info */
  1420.     while (get_bits1(&s->gb) != 0) {
  1421.         skip_bits(&s->gb, 8);
  1422.     }
  1423.  
  1424.     for(;;) {
  1425.         clear_blocks(s->block[0]);
  1426.         emms_c();
  1427.         ret = mpeg_decode_mb(s, s->block);
  1428.         dprintf("ret=%d\n", ret);
  1429.         if (ret < 0)
  1430.             return -1;
  1431.         if (ret == 1)
  1432.             break;
  1433.         MPV_decode_mb(s, s->block);
  1434.     }
  1435.     emms_c();
  1436.  
  1437.     /* end of slice reached */
  1438.     if (s->mb_x == (s->mb_width - 1) &&
  1439.         s->mb_y == (s->mb_height - 1)) {
  1440.         /* end of image */
  1441.         UINT8 **picture;
  1442.  
  1443.         MPV_frame_end(s);
  1444.  
  1445.         /* XXX: incorrect reported qscale for mpeg2 */
  1446.         if (s->pict_type == B_TYPE) {
  1447.             picture = s->current_picture;
  1448.             avctx->quality = s->qscale;
  1449.         } else {
  1450.             /* latency of 1 frame for I and P frames */
  1451.             /* XXX: use another variable than picture_number */
  1452.             if (s->picture_number == 0) {
  1453.                 picture = NULL;
  1454.             } else {
  1455.                 picture = s->last_picture;
  1456.                 avctx->quality = s->last_qscale;
  1457.             }
  1458.             s->last_qscale = s->qscale;
  1459.             s->picture_number++;
  1460.         }
  1461.         if (picture) {
  1462.             pict->data[0] = picture[0];
  1463.             pict->data[1] = picture[1];
  1464.             pict->data[2] = picture[2];
  1465.             pict->linesize[0] = s->linesize;
  1466.             pict->linesize[1] = s->linesize / 2;
  1467.             pict->linesize[2] = s->linesize / 2;
  1468.             return 1;
  1469.         } else {
  1470.             return 0;
  1471.         }
  1472.     } else {
  1473.         return 0;
  1474.     }
  1475. }
  1476.  
  1477. static int mpeg1_decode_sequence(AVCodecContext *avctx, 
  1478.                                  UINT8 *buf, int buf_size)
  1479. {
  1480.     Mpeg1Context *s1 = avctx->priv_data;
  1481.     MpegEncContext *s = &s1->mpeg_enc_ctx;
  1482.     int width, height, i, v, j;
  1483.  
  1484.     init_get_bits(&s->gb, buf, buf_size);
  1485.  
  1486.     width = get_bits(&s->gb, 12);
  1487.     height = get_bits(&s->gb, 12);
  1488.     skip_bits(&s->gb, 4);
  1489.     s->frame_rate_index = get_bits(&s->gb, 4);
  1490.     if (s->frame_rate_index == 0)
  1491.         return -1;
  1492.     s->bit_rate = get_bits(&s->gb, 18) * 400;
  1493.     if (get_bits1(&s->gb) == 0) /* marker */
  1494.         return -1;
  1495.     if (width <= 0 || height <= 0 ||
  1496.         (width % 2) != 0 || (height % 2) != 0)
  1497.         return -1;
  1498.     if (width != s->width ||
  1499.         height != s->height) {
  1500.         /* start new mpeg1 context decoding */
  1501.         s->out_format = FMT_MPEG1;
  1502.         if (s1->mpeg_enc_ctx_allocated) {
  1503.             MPV_common_end(s);
  1504.         }
  1505.         s->width = width;
  1506.         s->height = height;
  1507.         s->has_b_frames = 1;
  1508.         s->avctx = avctx;
  1509.         avctx->width = width;
  1510.         avctx->height = height;
  1511.         if (s->frame_rate_index >= 9) {
  1512.             /* at least give a valid frame rate (some old mpeg1 have this) */
  1513.             avctx->frame_rate = 25 * FRAME_RATE_BASE;
  1514.         } else {
  1515.             avctx->frame_rate = frame_rate_tab[s->frame_rate_index];
  1516.         }
  1517.         s->frame_rate = avctx->frame_rate;
  1518.         avctx->bit_rate = s->bit_rate;
  1519.         
  1520.         if (MPV_common_init(s) < 0)
  1521.             return -1;
  1522.         mpeg1_init_vlc(s);
  1523.         s1->mpeg_enc_ctx_allocated = 1;
  1524.     }
  1525.  
  1526.     skip_bits(&s->gb, 10); /* vbv_buffer_size */
  1527.     skip_bits(&s->gb, 1);
  1528.  
  1529.     /* get matrix */
  1530.     if (get_bits1(&s->gb)) {
  1531.         for(i=0;i<64;i++) {
  1532.             v = get_bits(&s->gb, 8);
  1533.             j = zigzag_direct[i];
  1534.             s->intra_matrix[j] = v;
  1535.             s->chroma_intra_matrix[j] = v;
  1536.         }
  1537. #ifdef DEBUG
  1538.         dprintf("intra matrix present\n");
  1539.         for(i=0;i<64;i++)
  1540.             dprintf(" %d", s->intra_matrix[zigzag_direct[i]]);
  1541.         printf("\n");
  1542. #endif
  1543.     } else {
  1544.         for(i=0;i<64;i++) {
  1545.             v = default_intra_matrix[i];
  1546.             s->intra_matrix[i] = v;
  1547.             s->chroma_intra_matrix[i] = v;
  1548.         }
  1549.     }
  1550.     if (get_bits1(&s->gb)) {
  1551.         for(i=0;i<64;i++) {
  1552.             v = get_bits(&s->gb, 8);
  1553.             j = zigzag_direct[i];
  1554.             s->inter_matrix[j] = v;
  1555.             s->chroma_inter_matrix[j] = v;
  1556.         }
  1557. #ifdef DEBUG
  1558.         dprintf("non intra matrix present\n");
  1559.         for(i=0;i<64;i++)
  1560.             dprintf(" %d", s->inter_matrix[zigzag_direct[i]]);
  1561.         printf("\n");
  1562. #endif
  1563.     } else {
  1564.         for(i=0;i<64;i++) {
  1565.             v = default_non_intra_matrix[i];
  1566.             s->inter_matrix[i] = v;
  1567.             s->chroma_inter_matrix[i] = v;
  1568.         }
  1569.     }
  1570.  
  1571.     /* we set mpeg2 parameters so that it emulates mpeg1 */
  1572.     s->progressive_sequence = 1;
  1573.     s->progressive_frame = 1;
  1574.     s->picture_structure = PICT_FRAME;
  1575.     s->frame_pred_frame_dct = 1;
  1576.     s->mpeg2 = 0;
  1577.     avctx->sub_id = 1; /* indicates mpeg1 */
  1578.     return 0;
  1579. }
  1580.  
  1581. /* handle buffering and image synchronisation */
  1582. static int mpeg_decode_frame(AVCodecContext *avctx, 
  1583.                              void *data, int *data_size,
  1584.                              UINT8 *buf, int buf_size)
  1585. {
  1586.     Mpeg1Context *s = avctx->priv_data;
  1587.     UINT8 *buf_end, *buf_ptr, *buf_start;
  1588.     int len, start_code_found, ret, code, start_code, input_size;
  1589.     AVPicture *picture = data;
  1590.     MpegEncContext *s2 = &s->mpeg_enc_ctx;
  1591.             
  1592.     dprintf("fill_buffer\n");
  1593.  
  1594.     *data_size = 0;
  1595.  
  1596.     /* special case for last picture */
  1597.     if (buf_size == 0) {
  1598.         if (s2->picture_number > 0) {
  1599.             picture->data[0] = s2->next_picture[0];
  1600.             picture->data[1] = s2->next_picture[1];
  1601.             picture->data[2] = s2->next_picture[2];
  1602.             picture->linesize[0] = s2->linesize;
  1603.             picture->linesize[1] = s2->linesize / 2;
  1604.             picture->linesize[2] = s2->linesize / 2;
  1605.             *data_size = sizeof(AVPicture);
  1606.         }
  1607.         return 0;
  1608.     }
  1609.  
  1610.     buf_ptr = buf;
  1611.     buf_end = buf + buf_size;
  1612.  
  1613. #if 0    
  1614.     if (s->repeat_field % 2 == 1) { 
  1615.         s->repeat_field++;
  1616.         //fprintf(stderr,"\nRepeating last frame: %d -> %d! pict: %d %d", avctx->frame_number-1, avctx->frame_number,
  1617.         //        s2->picture_number, s->repeat_field);
  1618.         if (avctx->flags & CODEC_FLAG_REPEAT_FIELD) {
  1619.             *data_size = sizeof(AVPicture);
  1620.             goto the_end;
  1621.         }
  1622.     }
  1623. #endif
  1624.     while (buf_ptr < buf_end) {
  1625.         buf_start = buf_ptr;
  1626.         /* find start next code */
  1627.         code = find_start_code(&buf_ptr, buf_end, &s->header_state);
  1628.         if (code >= 0) {
  1629.             start_code_found = 1;
  1630.         } else {
  1631.             start_code_found = 0;
  1632.         }
  1633.         /* copy to buffer */
  1634.         len = buf_ptr - buf_start;
  1635.         if (len + (s->buf_ptr - s->buffer) > s->buffer_size) {
  1636.             /* data too big : flush */
  1637.             s->buf_ptr = s->buffer;
  1638.             if (start_code_found)
  1639.                 s->start_code = code;
  1640.         } else {
  1641.             memcpy(s->buf_ptr, buf_start, len);
  1642.             s->buf_ptr += len;
  1643.             
  1644.             if (start_code_found) {
  1645.                 /* prepare data for next start code */
  1646.                 input_size = s->buf_ptr - s->buffer;
  1647.                 start_code = s->start_code;
  1648.                 s->buf_ptr = s->buffer;
  1649.                 s->start_code = code;
  1650.                 switch(start_code) {
  1651.                 case SEQ_START_CODE:
  1652.                     mpeg1_decode_sequence(avctx, s->buffer, 
  1653.                                           input_size);
  1654.                     break;
  1655.                             
  1656.                 case PICTURE_START_CODE:
  1657.                     /* we have a complete image : we try to decompress it */
  1658.                     mpeg1_decode_picture(avctx, 
  1659.                                          s->buffer, input_size);
  1660.                     break;
  1661.                 case EXT_START_CODE:
  1662.                     mpeg_decode_extension(avctx,
  1663.                                           s->buffer, input_size);
  1664.                     break;
  1665.                 default:
  1666.                     if (start_code >= SLICE_MIN_START_CODE &&
  1667.                         start_code <= SLICE_MAX_START_CODE) {
  1668.                         ret = mpeg_decode_slice(avctx, picture,
  1669.                                                 start_code, s->buffer, input_size);
  1670.                         if (ret == 1) {
  1671.                             /* got a picture: exit */
  1672.                             /* first check if we must repeat the frame */
  1673.                             avctx->repeat_pict = 0;
  1674. #if 0
  1675.                             if (s2->progressive_frame && s2->repeat_first_field) {
  1676.                                 //fprintf(stderr,"\nRepeat this frame: %d! pict: %d",avctx->frame_number,s2->picture_number);
  1677.                                 //s2->repeat_first_field = 0;
  1678.                                 //s2->progressive_frame = 0;
  1679.                                 if (++s->repeat_field > 2)
  1680.                                     s->repeat_field = 0;
  1681.                                 avctx->repeat_pict = 1;
  1682.                             }
  1683. #endif                      
  1684.                             if (s2->repeat_first_field) {
  1685.                                 if (s2->progressive_sequence) {
  1686.                                     if (s2->top_field_first)
  1687.                                         avctx->repeat_pict = 4;
  1688.                                     else
  1689.                                         avctx->repeat_pict = 2;
  1690.                                 } else if (s2->progressive_frame) {
  1691.                                     avctx->repeat_pict = 1;
  1692.                                 }
  1693.                             }         
  1694.                             *data_size = sizeof(AVPicture);
  1695.                             goto the_end;
  1696.                         }
  1697.                     }
  1698.                     break;
  1699.                 }
  1700.             }
  1701.         }
  1702.     }
  1703.  the_end:
  1704.     return buf_ptr - buf;
  1705. }
  1706.  
  1707. static int mpeg_decode_end(AVCodecContext *avctx)
  1708. {
  1709.     Mpeg1Context *s = avctx->priv_data;
  1710.  
  1711.     if (s->mpeg_enc_ctx_allocated)
  1712.         MPV_common_end(&s->mpeg_enc_ctx);
  1713.     return 0;
  1714. }
  1715.  
  1716. AVCodec mpeg_decoder = {
  1717.     "mpegvideo",
  1718.     CODEC_TYPE_VIDEO,
  1719.     CODEC_ID_MPEG1VIDEO,
  1720.     sizeof(Mpeg1Context),
  1721.     mpeg_decode_init,
  1722.     NULL,
  1723.     mpeg_decode_end,
  1724.     mpeg_decode_frame,
  1725. };
  1726.