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.
6 Commits
32 Branches
325MB
Tree: 85f07f223d
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '85f07f223d'
${ noResults }
FFmpeg/libavcodec/mpeg12.c

1531 lines
47KB
Raw Blame History 

  1. /*

  2.  * MPEG1 encoder / MPEG2 decoder

  3.  * Copyright (c) 2000,2001 Gerard Lantau.

  4.  *

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

  6.  * it under the terms of the GNU General Public License as published by

  7.  * the Free Software Foundation; either version 2 of the License, or

  8.  * (at your option) any later version.

  9.  *

  10.  * This program 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

  13.  * GNU General Public License for more details.

  14.  *

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

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

  17.  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

  18.  */

  19. #include <stdlib.h>

  20. #include <stdio.h>

  21. #include <string.h>

  22. #include "avcodec.h"

  23. #include "dsputil.h"

  24. #include "mpegvideo.h"

  25. 

  26. #include "mpeg12data.h"

  27. 

  28. //#define DEBUG

  29. 

  30. #ifdef DEBUG

  31. #define dprintf(fmt,args...) printf(fmt, ## args)

  32. #else

  33. #define dprintf(fmt,args...)

  34. #endif

  35. 

  36. /* Start codes. */

  37. #define SEQ_END_CODE		0x000001b7

  38. #define SEQ_START_CODE		0x000001b3

  39. #define GOP_START_CODE		0x000001b8

  40. #define PICTURE_START_CODE	0x00000100

  41. #define SLICE_MIN_START_CODE	0x00000101

  42. #define SLICE_MAX_START_CODE	0x000001af

  43. #define EXT_START_CODE		0x000001b5

  44. #define USER_START_CODE		0x000001b2

  45. 

  46. static void mpeg1_encode_block(MpegEncContext *s, 

  47.                          DCTELEM *block, 

  48.                          int component);

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

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

  51. static int mpeg1_decode_block(MpegEncContext *s, 

  52.                               DCTELEM *block, 

  53.                               int n);

  54. static int mpeg2_decode_block_non_intra(MpegEncContext *s, 

  55.                                         DCTELEM *block, 

  56.                                         int n);

  57. static int mpeg2_decode_block_intra(MpegEncContext *s, 

  58.                                     DCTELEM *block, 

  59.                                     int n);

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

  61. 

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

  63. {

  64.     align_put_bits(&s->pb);

  65.     put_bits(&s->pb, 32, header);

  66. }

  67. 

  68. /* put sequence header if needed */

  69. static void mpeg1_encode_sequence_header(MpegEncContext *s)

  70. {

  71.         unsigned int vbv_buffer_size;

  72.         unsigned int fps, n, v;

  73.         UINT64 time_code;

  74.         

  75.         if ((s->picture_number % s->gop_size) == 0) {

  76.             /* mpeg1 header repeated every gop */

  77.             put_header(s, SEQ_START_CODE);

  78.             

  79.             /* search closest frame rate */

  80.             {

  81.                 int i, dmin, d;

  82.                 s->frame_rate_index = 0;

  83.                 dmin = 0x7fffffff;

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

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

  86.                     if (d < dmin) {

  87.                         dmin = d;

  88.                         s->frame_rate_index = i;

  89.                     }

  90.                 }

  91.             }

  92.  

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

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

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

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

  97.             v = s->bit_rate / 400;

  98.             if (v > 0x3ffff)

  99.                 v = 0x3ffff;

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

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

  102.             /* vbv buffer size: slightly greater than an I frame. We add

  103.                some margin just in case */

  104.             vbv_buffer_size = (3 * s->I_frame_bits) / (2 * 8);

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

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

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

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

  109. 

  110.             put_header(s, GOP_START_CODE);

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

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

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

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

  115.             time_code = s->fake_picture_number * FRAME_RATE_BASE;

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

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

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

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

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

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

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

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

  124.         }

  125. 

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

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

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

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

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

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

  132.                 mpeg1_skip_picture(s, s->fake_picture_number - 

  133.                                    s->gop_picture_number); 

  134.                 s->fake_picture_number++;

  135.             }

  136. 

  137.         }

  138.         s->fake_picture_number++;

  139. }

  140. 

  141. 

  142. /* insert a fake P picture */

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

  144. {

  145.     unsigned int mb_incr;

  146. 

  147.     /* mpeg1 picture header */

  148.     put_header(s, PICTURE_START_CODE);

  149.     /* temporal reference */

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

  151.     

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

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

  154.     

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

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

  157.     

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

  159.     

  160.     /* only one slice */

  161.     put_header(s, SLICE_MIN_START_CODE);

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

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

  164.     

  165.     mb_incr = 1;

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

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

  168.     

  169.     /* empty macroblock */

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

  171.     

  172.     /* zero motion x & y */

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

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

  175. 

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

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

  178.     while (mb_incr > 33) {

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

  180.         mb_incr -= 33;

  181.     }

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

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

  184.     

  185.     /* empty macroblock */

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

  187.     

  188.     /* zero motion x & y */

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

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

  191. }

  192. 

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

  194. {

  195.     static int done;

  196. 

  197.     if (!done) {

  198.         done = 1;

  199.         init_rl(&rl_mpeg1);

  200.     }

  201.     mpeg1_encode_sequence_header(s);

  202. 

  203.     /* mpeg1 picture header */

  204.     put_header(s, PICTURE_START_CODE);

  205.     /* temporal reference */

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

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

  208.     

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

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

  211.     

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

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

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

  215.     }

  216.     

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

  218.     

  219.     /* only one slice */

  220.     put_header(s, SLICE_MIN_START_CODE);

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

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

  223. }

  224. 

  225. void mpeg1_encode_mb(MpegEncContext *s,

  226.                      DCTELEM block[6][64],

  227.                      int motion_x, int motion_y)

  228. {

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

  230. 

  231.     mb_x = s->mb_x;

  232.     mb_y = s->mb_y;

  233. 

  234.     /* compute cbp */

  235.     cbp = 0;

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

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

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

  239.     }

  240. 

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

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

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

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

  245.         s->mb_incr++;

  246.     } else {

  247.         /* output mb incr */

  248.         mb_incr = s->mb_incr;

  249. 

  250.         while (mb_incr > 33) {

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

  252.             mb_incr -= 33;

  253.         }

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

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

  256.         

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

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

  259.         } else {

  260.             if (s->mb_intra) {

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

  262.             } else {

  263.                 if (cbp != 0) {

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

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

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

  267.                     } else {

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

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

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

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

  272.                     }

  273.                 } else {

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

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

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

  277.                 }

  278.             }

  279.         }

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

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

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

  283.             }

  284.         }

  285.         s->mb_incr = 1;

  286.     }

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

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

  289. }

  290. 

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

  292. {

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

  294. 

  295.     if (val == 0) {

  296.         /* zero vector */

  297.         code = 0;

  298.         put_bits(&s->pb,

  299.                  mbMotionVectorTable[0][1], 

  300.                  mbMotionVectorTable[0][0]); 

  301.     } else {

  302.         bit_size = s->f_code - 1;

  303.         range = 1 << bit_size;

  304.         /* modulo encoding */

  305.         l = 16 * range;

  306.         m = 2 * l;

  307.         if (val < -l) {

  308.             val += m;

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

  310.             val -= m;

  311.         }

  312. 

  313.         if (val >= 0) {

  314.             val--;

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

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

  317.             sign = 0;

  318.         } else {

  319.             val = -val;

  320.             val--;

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

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

  323.             sign = 1;

  324.         }

  325.         put_bits(&s->pb,

  326.                  mbMotionVectorTable[code][1], 

  327.                  mbMotionVectorTable[code][0]); 

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

  329.         if (bit_size > 0) {

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

  331.         }

  332.     }

  333. }

  334. 

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

  336. {

  337.     int adiff, index;

  338. 

  339.     adiff = abs(diff);

  340.     index = vlc_dc_table[adiff];

  341.     if (component == 0) {

  342.         put_bits(&s->pb, vlc_dc_lum_bits[index], vlc_dc_lum_code[index]);

  343.     } else {

  344.         put_bits(&s->pb, vlc_dc_chroma_bits[index], vlc_dc_chroma_code[index]);

  345.     }

  346.     if (diff > 0) {

  347.         put_bits(&s->pb, index, (diff & ((1 << index) - 1)));

  348.     } else if (diff < 0) {

  349.         put_bits(&s->pb, index, ((diff - 1) & ((1 << index) - 1)));

  350.     }

  351. }

  352. 

  353. static void mpeg1_encode_block(MpegEncContext *s, 

  354.                                DCTELEM *block, 

  355.                                int n)

  356. {

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

  358.     int code, component;

  359.     RLTable *rl = &rl_mpeg1;

  360. 

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

  362. 

  363.     /* DC coef */

  364.     if (s->mb_intra) {

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

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

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

  368.         encode_dc(s, diff, component);

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

  370.         i = 1;

  371.     } else {

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

  373.            it is handled slightly differently */

  374.         level = block[0];

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

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

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

  378.                 i = 1;

  379.         } else {

  380.             i = 0;

  381.             last_non_zero = -1;

  382.             goto next_coef;

  383.         }

  384.     }

  385. 

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

  387.     last_non_zero = i - 1;

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

  389.         j = zigzag_direct[i];

  390.         level = block[j];

  391.     next_coef:

  392. #if 0

  393.         if (level != 0)

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

  395. #endif            

  396.         /* encode using VLC */

  397.         if (level != 0) {

  398.             run = i - last_non_zero - 1;

  399.             sign = 0;

  400.             alevel = level;

  401.             if (alevel < 0) {

  402. 		sign = 1;

  403.                 alevel = -alevel;

  404. 	    }

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

  406.             put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);

  407.             if (code != rl->n) {

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

  409.             } else {

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

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

  412.                 if (alevel < 128) {

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

  414.                 } else {

  415.                     if (level < 0) {

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

  417.                     } else {

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

  419.                     }

  420.                 }

  421.             }

  422.             last_non_zero = i;

  423.         }

  424.     }

  425.     /* end of block */

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

  427. }

  428. 

  429. /******************************************/

  430. /* decoding */

  431. 

  432. static VLC dc_lum_vlc;

  433. static VLC dc_chroma_vlc;

  434. static VLC mv_vlc;

  435. static VLC mbincr_vlc;

  436. static VLC mb_ptype_vlc;

  437. static VLC mb_btype_vlc;

  438. static VLC mb_pat_vlc;

  439. 

  440. void mpeg1_init_vlc(MpegEncContext *s)

  441. {

  442.     static int done = 0;

  443. 

  444.     if (!done) {

  445. 

  446.         init_vlc(&dc_lum_vlc, 9, 12, 

  447.                  vlc_dc_lum_bits, 1, 1,

  448.                  vlc_dc_lum_code, 2, 2);

  449.         init_vlc(&dc_chroma_vlc, 9, 12, 

  450.                  vlc_dc_chroma_bits, 1, 1,

  451.                  vlc_dc_chroma_code, 2, 2);

  452.         init_vlc(&mv_vlc, 9, 17, 

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

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

  455.         init_vlc(&mbincr_vlc, 9, 34, 

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

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

  458.         init_vlc(&mb_pat_vlc, 9, 63, 

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

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

  461.         

  462.         init_vlc(&mb_ptype_vlc, 6, 32, 

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

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

  465.         init_vlc(&mb_btype_vlc, 6, 32, 

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

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

  468.         init_rl(&rl_mpeg1);

  469.         init_rl(&rl_mpeg2);

  470.         /* cannot use generic init because we must add the EOB code */

  471.         init_vlc(&rl_mpeg1.vlc, 9, rl_mpeg1.n + 2, 

  472.                  &rl_mpeg1.table_vlc[0][1], 4, 2,

  473.                  &rl_mpeg1.table_vlc[0][0], 4, 2);

  474.         init_vlc(&rl_mpeg2.vlc, 9, rl_mpeg2.n + 2, 

  475.                  &rl_mpeg2.table_vlc[0][1], 4, 2,

  476.                  &rl_mpeg2.table_vlc[0][0], 4, 2);

  477.     }

  478. }

  479. 

  480. static inline int get_dmv(MpegEncContext *s)

  481. {

  482.     if(get_bits(&s->gb, 1)) 

  483.         return 1 - (get_bits(&s->gb, 1) << 1);

  484.     else

  485.         return 0;

  486. }

  487. 

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

  489. #define MT_FIELD 1

  490. #define MT_FRAME 2

  491. #define MT_16X8  2

  492. #define MT_DMV   3

  493. 

  494. static int mpeg_decode_mb(MpegEncContext *s,

  495.                           DCTELEM block[6][64])

  496. {

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

  498.     

  499.     /* skip mb handling */

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

  501.         /* read again increment */

  502.         s->mb_incr = 1;

  503.         for(;;) {

  504.             code = get_vlc(&s->gb, &mbincr_vlc);

  505.             if (code < 0)

  506.                 return 1; /* error = end of slice */

  507.             if (code >= 33) {

  508.                 if (code == 33) {

  509.                     s->mb_incr += 33;

  510.                 }

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

  512.             } else {

  513.                 s->mb_incr += code;

  514.                 break;

  515.             }

  516.         }

  517.     }

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

  519.         s->mb_x = 0;

  520.         if (s->mb_y >= (s->mb_height - 1))

  521.             return -1;

  522.         s->mb_y++;

  523.     }

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

  525. 

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

  527.         /* skip mb */

  528.         s->mb_intra = 0;

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

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

  531.         s->mv_type = MV_TYPE_16X16;

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

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

  534.             s->mv_dir = MV_DIR_FORWARD;

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

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

  537.         } else {

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

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

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

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

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

  543.         }

  544.         return 0;

  545.     }

  546. 

  547.     switch(s->pict_type) {

  548.     default:

  549.     case I_TYPE:

  550.         if (get_bits(&s->gb, 1) == 0) {

  551.             if (get_bits(&s->gb, 1) == 0)

  552.                 return -1;

  553.             mb_type = MB_QUANT | MB_INTRA;

  554.         } else {

  555.             mb_type = MB_INTRA;

  556.         }

  557.         break;

  558.     case P_TYPE:

  559.         mb_type = get_vlc(&s->gb, &mb_ptype_vlc);

  560.         if (mb_type < 0)

  561.             return -1;

  562.         break;

  563.     case B_TYPE:

  564.         mb_type = get_vlc(&s->gb, &mb_btype_vlc);

  565.         if (mb_type < 0)

  566.             return -1;

  567.         break;

  568.     }

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

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

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

  572.         /* get additionnal motion vector type */

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

  574.             motion_type = MT_FRAME;

  575.         else

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

  577.     }

  578.     /* compute dct type */

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

  580.         !s->frame_pred_frame_dct &&

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

  582.         s->interlaced_dct = get_bits(&s->gb, 1);

  583. #ifdef DEBUG

  584.         if (s->interlaced_dct)

  585.             printf("interlaced_dct\n");

  586. #endif

  587.     } else {

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

  589.     }

  590. 

  591.     if (mb_type & MB_QUANT) {

  592.         if (s->mpeg2) {

  593.             if (s->q_scale_type) {

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

  595.             } else {

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

  597.             }

  598.         } else {

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

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

  601.         }

  602.     }

  603.     if (mb_type & MB_INTRA) {

  604.         if (s->concealment_motion_vectors) {

  605.             /* just parse them */

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

  607.                 get_bits(&s->gb, 1); /* field select */

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

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

  610.         }

  611.         s->mb_intra = 1;

  612.         cbp = 0x3f;

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

  614.     } else {

  615.         s->mb_intra = 0;

  616.         cbp = 0;

  617.     }

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

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

  620.         s->mv_dir = MV_DIR_FORWARD;

  621.         s->mv_type = MV_TYPE_16X16;

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

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

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

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

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

  627.         /* motion vectors */

  628.         s->mv_dir = 0;

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

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

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

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

  633.                 switch(motion_type) {

  634.                 case MT_FRAME: /* or MT_16X8 */

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

  636.                         /* MT_FRAME */

  637.                         s->mv_type = MV_TYPE_16X16;

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

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

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

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

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

  643.                             /* full_pel: only for mpeg1 */

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

  645.                                 val = val << 1;

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

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

  648.                         }

  649.                     } else {

  650.                         /* MT_16X8 */

  651.                         s->mv_type = MV_TYPE_16X8;

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

  653.                             s->field_select[i][j] = get_bits(&s->gb, 1);

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

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

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

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

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

  659.                             }

  660.                         }

  661.                     }

  662.                     break;

  663.                 case MT_FIELD:

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

  665.                         s->mv_type = MV_TYPE_FIELD;

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

  667.                             s->field_select[i][j] = get_bits(&s->gb, 1);

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

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

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

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

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

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

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

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

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

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

  678.                         }

  679.                     } else {

  680.                         s->mv_type = MV_TYPE_16X16;

  681.                         s->field_select[i][0] = get_bits(&s->gb, 1);

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

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

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

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

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

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

  688.                         }

  689.                     }

  690.                     break;

  691.                 case MT_DMV:

  692.                     {

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

  694. 

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

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

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

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

  699.                         dmx = get_dmv(s);

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

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

  702.                         dmy = get_dmv(s);

  703.                         s->mv_type = MV_TYPE_DMV;

  704.                         /* XXX: totally broken */

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

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

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

  708. 

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

  710.                             /* top -> top pred */

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

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

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

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

  715.                             m = 4 - m;

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

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

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

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

  720.                         } else {

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

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

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

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

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

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

  727.                                 /* + 2 * cur_field */;

  728.                         }

  729.                     }

  730.                     break;

  731.                 }

  732.             }

  733.         }

  734.     }

  735. 

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

  737.         get_bits(&s->gb, 1); /* marker */

  738.     }

  739.     

  740.     if (mb_type & MB_PAT) {

  741.         cbp = get_vlc(&s->gb, &mb_pat_vlc);

  742.         if (cbp < 0)

  743.             return -1;

  744.         cbp++;

  745.     }

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

  747. 

  748.     if (s->mpeg2) {

  749.         if (s->mb_intra) {

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

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

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

  753.                         return -1;

  754.                 }

  755.             }

  756.         } else {

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

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

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

  760.                         return -1;

  761.                 }

  762.             }

  763.         }

  764.     } else {

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

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

  767.                 if (mpeg1_decode_block(s, block[i], i) < 0)

  768.                     return -1;

  769.             }

  770.         }

  771.     }

  772.     return 0;

  773. }

  774. 

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

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

  777. {

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

  779. 

  780.     code = get_vlc(&s->gb, &mv_vlc);

  781.     if (code < 0) {

  782.         return 0xffff;

  783.     }

  784.     if (code == 0) {

  785.         return pred;

  786.     }

  787.     sign = get_bits(&s->gb, 1);

  788.     shift = fcode - 1;

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

  790.     if (shift > 0)

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

  792.     val++;

  793.     if (sign)

  794.         val = -val;

  795.     val += pred;

  796.     

  797.     /* modulo decoding */

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

  799.     m = 2 * l;

  800.     if (val < -l) {

  801.         val += m;

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

  803.         val -= m;

  804.     }

  805.     return val;

  806. }

  807. 

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

  809. {

  810.     int code, diff;

  811. 

  812.     if (component == 0) {

  813.         code = get_vlc(&s->gb, &dc_lum_vlc);

  814.     } else {

  815.         code = get_vlc(&s->gb, &dc_chroma_vlc);

  816.     }

  817.     if (code < 0)

  818.         return 0xffff;

  819.     if (code == 0) {

  820.         diff = 0;

  821.     } else {

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

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

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

  825.     }

  826.     return diff;

  827. }

  828. 

  829. static int mpeg1_decode_block(MpegEncContext *s, 

  830.                                DCTELEM *block, 

  831.                                int n)

  832. {

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

  834.     int code, component;

  835.     RLTable *rl = &rl_mpeg1;

  836. 

  837.     if (s->mb_intra) {

  838.         /* DC coef */

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

  840.         diff = decode_dc(s, component);

  841.         if (diff >= 0xffff)

  842.             return -1;

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

  844.         dc += diff;

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

  846.         block[0] = dc;

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

  848.         i = 1;

  849.     } else {

  850.         int bit_cnt, v;

  851.         UINT32 bit_buf;

  852.         UINT8 *buf_ptr;

  853.         i = 0;

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

  855.         SAVE_BITS(&s->gb);

  856.         SHOW_BITS(&s->gb, v, 2);

  857.         if (v & 2) {

  858.             run = 0;

  859.             level = 1 - ((v & 1) << 1);

  860.             FLUSH_BITS(2);

  861.             RESTORE_BITS(&s->gb);

  862.             goto add_coef;

  863.         }

  864.         RESTORE_BITS(&s->gb);

  865.     }

  866. 

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

  868.     for(;;) {

  869.         code = get_vlc(&s->gb, &rl->vlc);

  870.         if (code < 0) {

  871.             return -1;

  872.         }

  873.         if (code == 112) {

  874.             break;

  875.         } else if (code == 111) {

  876.             /* escape */

  877.             run = get_bits(&s->gb, 6);

  878.             level = get_bits(&s->gb, 8);

  879.             level = (level << 24) >> 24;

  880.             if (level == -128) {

  881.                 level = get_bits(&s->gb, 8) - 256;

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

  883.                 level = get_bits(&s->gb, 8);

  884.             }

  885.         } else {

  886.             run = rl->table_run[code];

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

  888.             if (get_bits(&s->gb, 1))

  889.                 level = -level;

  890.         }

  891.         i += run;

  892.         if (i >= 64)

  893.             return -1;

  894.     add_coef:

  895.         dprintf("%d: run=%d level=%d\n", n, run, level);

  896. 	j = zigzag_direct[i];

  897.         block[j] = level;

  898.         i++;

  899.     }

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

  901.     return 0;

  902. }

  903. 

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

  905.    encoding */

  906. static int mpeg2_decode_block_non_intra(MpegEncContext *s, 

  907.                                         DCTELEM *block, 

  908.                                         int n)

  909. {

  910.     int level, i, j, run;

  911.     int code;

  912.     RLTable *rl = &rl_mpeg1;

  913.     const UINT8 *scan_table;

  914.     const UINT16 *matrix;

  915.     int mismatch;

  916. 

  917.     if (s->alternate_scan)

  918.         scan_table = ff_alternate_vertical_scan;

  919.     else

  920.         scan_table = zigzag_direct;

  921.     mismatch = 1;

  922. 

  923.     {

  924.         int bit_cnt, v;

  925.         UINT32 bit_buf;

  926.         UINT8 *buf_ptr;

  927.         i = 0;

  928.         if (n < 4) 

  929.             matrix = s->non_intra_matrix;

  930.         else

  931.             matrix = s->chroma_non_intra_matrix;

  932.             

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

  934.         SAVE_BITS(&s->gb);

  935.         SHOW_BITS(&s->gb, v, 2);

  936.         if (v & 2) {

  937.             run = 0;

  938.             level = 1 - ((v & 1) << 1);

  939.             FLUSH_BITS(2);

  940.             RESTORE_BITS(&s->gb);

  941.             goto add_coef;

  942.         }

  943.         RESTORE_BITS(&s->gb);

  944.     }

  945. 

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

  947.     for(;;) {

  948.         code = get_vlc(&s->gb, &rl->vlc);

  949.         if (code < 0)

  950.             return -1;

  951.         if (code == 112) {

  952.             break;

  953.         } else if (code == 111) {

  954.             /* escape */

  955.             run = get_bits(&s->gb, 6);

  956.             level = get_bits(&s->gb, 12);

  957.             level = (level << 20) >> 20;

  958.         } else {

  959.             run = rl->table_run[code];

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

  961.             if (get_bits(&s->gb, 1))

  962.                 level = -level;

  963.         }

  964.         i += run;

  965.         if (i >= 64)

  966.             return -1;

  967.     add_coef:

  968. 	j = scan_table[i];

  969.         dprintf("%d: run=%d level=%d\n", n, run, level);

  970.         level = ((level * 2 + 1) * s->qscale * matrix[j]) / 32;

  971.         /* XXX: is it really necessary to saturate since the encoder

  972.            knows whats going on ? */

  973.         mismatch ^= level;

  974.         block[j] = level;

  975.         i++;

  976.     }

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

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

  979.     return 0;

  980. }

  981. 

  982. static int mpeg2_decode_block_intra(MpegEncContext *s, 

  983.                                     DCTELEM *block, 

  984.                                     int n)

  985. {

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

  987.     int code, component;

  988.     RLTable *rl;

  989.     const UINT8 *scan_table;

  990.     const UINT16 *matrix;

  991.     int mismatch;

  992. 

  993.     if (s->alternate_scan)

  994.         scan_table = ff_alternate_vertical_scan;

  995.     else

  996.         scan_table = zigzag_direct;

  997.     mismatch = 1;

  998. 

  999.     /* DC coef */

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

  1001.     diff = decode_dc(s, component);

  1002.     if (diff >= 0xffff)

  1003.         return -1;

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

  1005.     dc += diff;

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

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

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

  1009.     i = 1;

  1010.     if (s->intra_vlc_format)

  1011.         rl = &rl_mpeg2;

  1012.     else

  1013.         rl = &rl_mpeg1;

  1014.     if (n < 4) 

  1015.         matrix = s->intra_matrix;

  1016.     else

  1017.         matrix = s->chroma_intra_matrix;

  1018.         

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

  1020.     for(;;) {

  1021.         code = get_vlc(&s->gb, &rl->vlc);

  1022.         if (code < 0)

  1023.             return -1;

  1024.         if (code == 112) {

  1025.             break;

  1026.         } else if (code == 111) {

  1027.             /* escape */

  1028.             run = get_bits(&s->gb, 6);

  1029.             level = get_bits(&s->gb, 12);

  1030.             level = (level << 20) >> 20;

  1031.         } else {

  1032.             run = rl->table_run[code];

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

  1034.             if (get_bits(&s->gb, 1))

  1035.                 level = -level;

  1036.         }

  1037.         i += run;

  1038.         if (i >= 64)

  1039.             return -1;

  1040. 	j = scan_table[i];

  1041.         dprintf("%d: run=%d level=%d\n", n, run, level);

  1042.         level = (level * s->qscale * matrix[j]) / 16;

  1043.         /* XXX: is it really necessary to saturate since the encoder

  1044.            knows whats going on ? */

  1045.         mismatch ^= level;

  1046.         block[j] = level;

  1047.         i++;

  1048.     }

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

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

  1051.     return 0;

  1052. }

  1053. 

  1054. /* compressed picture size */

  1055. #define PICTURE_BUFFER_SIZE 100000

  1056. 

  1057. typedef struct Mpeg1Context {

  1058.     MpegEncContext mpeg_enc_ctx;

  1059.     UINT32 header_state;

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

  1061.     UINT8 buffer[PICTURE_BUFFER_SIZE]; 

  1062.     UINT8 *buf_ptr;

  1063.     int buffer_size;

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

  1065. } Mpeg1Context;

  1066. 

  1067. static int mpeg_decode_init(AVCodecContext *avctx)

  1068. {

  1069.     Mpeg1Context *s = avctx->priv_data;

  1070. 

  1071.     s->header_state = 0xff;

  1072.     s->mpeg_enc_ctx_allocated = 0;

  1073.     s->buffer_size = PICTURE_BUFFER_SIZE;

  1074.     s->start_code = -1;

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

  1076.     s->mpeg_enc_ctx.picture_number = 0;

  1077.     return 0;

  1078. }

  1079. 

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

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

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

  1083.                            UINT32 *header_state)

  1084. {

  1085.     UINT8 *buf_ptr;

  1086.     unsigned int state, v;

  1087.     int val;

  1088. 

  1089.     state = *header_state;

  1090.     buf_ptr = *pbuf_ptr;

  1091.     while (buf_ptr < buf_end) {

  1092.         v = *buf_ptr++;

  1093.         if (state == 0x000001) {

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

  1095.             val = state;

  1096.             goto found;

  1097.         }

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

  1099.     }

  1100.     val = -1;

  1101.  found:

  1102.     *pbuf_ptr = buf_ptr;

  1103.     *header_state = state;

  1104.     return val;

  1105. }

  1106. 

  1107. static int mpeg1_decode_picture(AVCodecContext *avctx, 

  1108.                                 UINT8 *buf, int buf_size)

  1109. {

  1110.     Mpeg1Context *s1 = avctx->priv_data;

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

  1112.     int ref, f_code;

  1113. 

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

  1115. 

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

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

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

  1119.     get_bits(&s->gb, 16);

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

  1121.         s->full_pel[0] = get_bits(&s->gb, 1);

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

  1123.         if (f_code == 0)

  1124.             return -1;

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

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

  1127.     }

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

  1129.         s->full_pel[1] = get_bits(&s->gb, 1);

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

  1131.         if (f_code == 0)

  1132.             return -1;

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

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

  1135.     }

  1136.     s->y_dc_scale = 8;

  1137.     s->c_dc_scale = 8;

  1138.     s->first_slice = 1;

  1139.     return 0;

  1140. }

  1141. 

  1142. static void mpeg_decode_sequence_extension(MpegEncContext *s)

  1143. {

  1144.     int horiz_size_ext, vert_size_ext;

  1145.     int bit_rate_ext, vbv_buf_ext, low_delay;

  1146.     int frame_rate_ext_n, frame_rate_ext_d;

  1147. 

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

  1149.     get_bits(&s->gb, 1); /* progressive_sequence */

  1150.     get_bits(&s->gb, 2); /* chroma_format */

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

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

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

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

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

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

  1157.     get_bits(&s->gb, 1); /* marker */

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

  1159.     low_delay = get_bits(&s->gb, 1);

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

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

  1162.     if (frame_rate_ext_d >= 1)

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

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

  1165.     s->mpeg2 = 1;

  1166. }

  1167. 

  1168. static void mpeg_decode_quant_matrix_extension(MpegEncContext *s)

  1169. {

  1170.     int i, v;

  1171. 

  1172.     if (get_bits(&s->gb, 1)) {

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

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

  1175.             s->intra_matrix[i] = v;

  1176.             s->chroma_intra_matrix[i] = v;

  1177.         }

  1178.     }

  1179.     if (get_bits(&s->gb, 1)) {

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

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

  1182.             s->non_intra_matrix[i] = v;

  1183.             s->chroma_non_intra_matrix[i] = v;

  1184.         }

  1185.     }

  1186.     if (get_bits(&s->gb, 1)) {

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

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

  1189.             s->chroma_intra_matrix[i] = v;

  1190.         }

  1191.     }

  1192.     if (get_bits(&s->gb, 1)) {

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

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

  1195.             s->chroma_non_intra_matrix[i] = v;

  1196.         }

  1197.     }

  1198. }

  1199. 

  1200. static void mpeg_decode_picture_coding_extension(MpegEncContext *s)

  1201. {

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

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

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

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

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

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

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

  1209.     s->top_field_first = get_bits(&s->gb, 1);

  1210.     s->frame_pred_frame_dct = get_bits(&s->gb, 1);

  1211.     s->concealment_motion_vectors = get_bits(&s->gb, 1);

  1212.     s->q_scale_type = get_bits(&s->gb, 1);

  1213.     s->intra_vlc_format = get_bits(&s->gb, 1);

  1214.     s->alternate_scan = get_bits(&s->gb, 1);

  1215.     s->repeat_first_field = get_bits(&s->gb, 1);

  1216.     s->chroma_420_type = get_bits(&s->gb, 1);

  1217.     s->progressive_frame = get_bits(&s->gb, 1);

  1218.     /* composite display not parsed */

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

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

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

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

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

  1224. }

  1225. 

  1226. static void mpeg_decode_extension(AVCodecContext *avctx, 

  1227.                                   UINT8 *buf, int buf_size)

  1228. {

  1229.     Mpeg1Context *s1 = avctx->priv_data;

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

  1231.     int ext_type;

  1232. 

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

  1234.     

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

  1236.     switch(ext_type) {

  1237.     case 0x1:

  1238.         /* sequence ext */

  1239.         mpeg_decode_sequence_extension(s);

  1240.         break;

  1241.     case 0x3:

  1242.         /* quant matrix extension */

  1243.         mpeg_decode_quant_matrix_extension(s);

  1244.         break;

  1245.     case 0x8:

  1246.         /* picture extension */

  1247.         mpeg_decode_picture_coding_extension(s);

  1248.         break;

  1249.     }

  1250. }

  1251. 

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

  1253. static int mpeg_decode_slice(AVCodecContext *avctx, 

  1254.                               AVPicture *pict,

  1255.                               int start_code,

  1256.                               UINT8 *buf, int buf_size)

  1257. {

  1258.     Mpeg1Context *s1 = avctx->priv_data;

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

  1260.     int ret;

  1261.     DCTELEM block[6][64];

  1262. 

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

  1264.     if (start_code >= s->mb_height)

  1265.         return -1;

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

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

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

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

  1270.     s->mb_x = -1;

  1271.     s->mb_y = start_code;

  1272.     s->mb_incr = 0;

  1273. 

  1274.     /* start frame decoding */

  1275.     if (s->first_slice) {

  1276.         s->first_slice = 0;

  1277.         MPV_frame_start(s);

  1278.     }

  1279. 

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

  1281. 

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

  1283.     /* extra slice info */

  1284.     while (get_bits(&s->gb, 1) != 0) {

  1285.         get_bits(&s->gb, 8);

  1286.     }

  1287. 

  1288.     for(;;) {

  1289.         memset(block, 0, sizeof(block));

  1290.         ret = mpeg_decode_mb(s, block);

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

  1292.         if (ret < 0)

  1293.             return -1;

  1294.         if (ret == 1)

  1295.             break;

  1296.         MPV_decode_mb(s, block);

  1297.     }

  1298.     

  1299.     /* end of slice reached */

  1300.     if (s->mb_x == (s->mb_width - 1) &&

  1301.         s->mb_y == (s->mb_height - 1)) {

  1302.         /* end of image */

  1303.         UINT8 **picture;

  1304. 

  1305.         MPV_frame_end(s);

  1306. 

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

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

  1309.             picture = s->current_picture;

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

  1311.         } else {

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

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

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

  1315.                 picture = NULL;

  1316.             } else {

  1317.                 picture = s->last_picture;

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

  1319.             }

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

  1321.             s->picture_number++;

  1322.         }

  1323.         if (picture) {

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

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

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

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

  1328.             pict->linesize[1] = s->linesize / 2;

  1329.             pict->linesize[2] = s->linesize / 2;

  1330.             return 1;

  1331.         } else {

  1332.             return 0;

  1333.         }

  1334.     } else {

  1335.         return 0;

  1336.     }

  1337. }

  1338. 

  1339. static int mpeg1_decode_sequence(AVCodecContext *avctx, 

  1340.                                  UINT8 *buf, int buf_size)

  1341. {

  1342.     Mpeg1Context *s1 = avctx->priv_data;

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

  1344.     int width, height, i, v;

  1345.     

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

  1347. 

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

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

  1350.     get_bits(&s->gb, 4);

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

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

  1353.         return -1;

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

  1355.     if (get_bits(&s->gb, 1) == 0) /* marker */

  1356.         return -1;

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

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

  1359.         return -1;

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

  1361.         height != s->height) {

  1362.         /* start new mpeg1 context decoding */

  1363.         s->out_format = FMT_MPEG1;

  1364.         if (s1->mpeg_enc_ctx_allocated) {

  1365.             MPV_common_end(s);

  1366.         }

  1367.         s->width = width;

  1368.         s->height = height;

  1369.         s->has_b_frames = 1;

  1370.         avctx->width = width;

  1371.         avctx->height = height;

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

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

  1374.         

  1375.         if (MPV_common_init(s) < 0)

  1376.             return -1;

  1377.         mpeg1_init_vlc(s);

  1378.         s1->mpeg_enc_ctx_allocated = 1;

  1379.     }

  1380. 

  1381.     get_bits(&s->gb, 10); /* vbv_buffer_size */

  1382.     get_bits(&s->gb, 1);

  1383. 

  1384.     /* get matrix */

  1385.     if (get_bits(&s->gb, 1)) {

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

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

  1388.             s->intra_matrix[i] = v;

  1389.             s->chroma_intra_matrix[i] = v;

  1390.         }

  1391.     } else {

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

  1393.             v = default_intra_matrix[i];

  1394.             s->intra_matrix[i] = v;

  1395.             s->chroma_intra_matrix[i] = v;

  1396.         }

  1397.     }

  1398.     if (get_bits(&s->gb, 1)) {

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

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

  1401.             s->non_intra_matrix[i] = v;

  1402.             s->chroma_non_intra_matrix[i] = v;

  1403.         }

  1404.     } else {

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

  1406.             v = default_non_intra_matrix[i];

  1407.             s->non_intra_matrix[i] = v;

  1408.             s->chroma_non_intra_matrix[i] = v;

  1409.         }

  1410.     }

  1411. 

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

  1413.     s->progressive_sequence = 1;

  1414.     s->progressive_frame = 1;

  1415.     s->picture_structure = PICT_FRAME;

  1416.     s->frame_pred_frame_dct = 1;

  1417.     s->mpeg2 = 0;

  1418.     return 0;

  1419. }

  1420. 

  1421. /* handle buffering and image synchronisation */

  1422. static int mpeg_decode_frame(AVCodecContext *avctx, 

  1423.                              void *data, int *data_size,

  1424.                              UINT8 *buf, int buf_size)

  1425. {

  1426.     Mpeg1Context *s = avctx->priv_data;

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

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

  1429.     AVPicture *picture = data;

  1430. 

  1431.     dprintf("fill_buffer\n");

  1432. 

  1433.     *data_size = 0;

  1434.     /* special case for last picture */

  1435.     if (buf_size == 0) {

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

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

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

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

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

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

  1442.             picture->linesize[1] = s2->linesize / 2;

  1443.             picture->linesize[2] = s2->linesize / 2;

  1444.             *data_size = sizeof(AVPicture);

  1445.         }

  1446.         return 0;

  1447.     }

  1448. 

  1449.     buf_ptr = buf;

  1450.     buf_end = buf + buf_size;

  1451.     while (buf_ptr < buf_end) {

  1452.         buf_start = buf_ptr;

  1453.         /* find start next code */

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

  1455.         if (code >= 0) {

  1456.             start_code_found = 1;

  1457.         } else {

  1458.             start_code_found = 0;

  1459.         }

  1460.         /* copy to buffer */

  1461.         len = buf_ptr - buf_start;

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

  1463.             /* data too big : flush */

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

  1465.             if (start_code_found)

  1466.                 s->start_code = code;

  1467.         } else {

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

  1469.             s->buf_ptr += len;

  1470.             

  1471.             if (start_code_found) {

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

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

  1474.                 start_code = s->start_code;

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

  1476.                 s->start_code = code;

  1477.                 switch(start_code) {

  1478.                 case SEQ_START_CODE:

  1479.                     mpeg1_decode_sequence(avctx, s->buffer, 

  1480.                                           input_size);

  1481.                     break;

  1482.                             

  1483.                 case PICTURE_START_CODE:

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

  1485.                     mpeg1_decode_picture(avctx, 

  1486.                                          s->buffer, input_size);

  1487.                     break;

  1488.                 case EXT_START_CODE:

  1489.                     mpeg_decode_extension(avctx,

  1490.                                           s->buffer, input_size);

  1491.                     break;

  1492.                 default:

  1493.                     if (start_code >= SLICE_MIN_START_CODE &&

  1494.                         start_code <= SLICE_MAX_START_CODE) {

  1495.                         ret = mpeg_decode_slice(avctx, picture,

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

  1497.                         if (ret == 1) {

  1498.                             /* got a picture: exit */

  1499.                             *data_size = sizeof(AVPicture);

  1500.                             goto the_end;

  1501.                         }

  1502.                     }

  1503.                     break;

  1504.                 }

  1505.             }

  1506.         }

  1507.     }

  1508.  the_end:

  1509.     return buf_ptr - buf;

  1510. }

  1511. 

  1512. static int mpeg_decode_end(AVCodecContext *avctx)

  1513. {

  1514.     Mpeg1Context *s = avctx->priv_data;

  1515. 

  1516.     if (s->mpeg_enc_ctx_allocated)

  1517.         MPV_common_end(&s->mpeg_enc_ctx);

  1518.     return 0;

  1519. }

  1520. 

  1521. AVCodec mpeg_decoder = {

  1522.     "mpegvideo",

  1523.     CODEC_TYPE_VIDEO,

  1524.     CODEC_ID_MPEG1VIDEO,

  1525.     sizeof(Mpeg1Context),

  1526.     mpeg_decode_init,

  1527.     NULL,

  1528.     mpeg_decode_end,

  1529.     mpeg_decode_frame,

  1530. };