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.
4146 Commits
32 Branches
283MB
Tree: 934982c4ac
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '934982c4ac'
${ noResults }
FFmpeg/libavcodec/vc9.c

1724 lines
54KB
Raw Blame History 

  1. /*

  2.  * VC-9 and WMV3 decoder

  3.  * Copyright (c) 2005 Anonymous

  4.  * Copyright (c) 2005 Alex Beregszaszi

  5.  *

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

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

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

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

  10.  *

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

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

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

  14.  * Lesser General Public License for more details.

  15.  *

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

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

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

  19.  *

  20.  */

  21. 

  22. /**

  23.  * @file vc9.c

  24.  * VC-9 and WMV3 decoder

  25.  *

  26.  * TODO: Norm-6 bitplane imode, most AP stuff, optimize, all of MB layer :)

  27.  * TODO: use MPV_ !!

  28.  */

  29. #include "common.h"

  30. #include "dsputil.h"

  31. #include "avcodec.h"

  32. #include "mpegvideo.h"

  33. #include "vc9data.h"

  34. 

  35. /* Some inhibiting stuff */

  36. #define HAS_ADVANCED_PROFILE   1

  37. #define TRACE                  1

  38. 

  39. #if TRACE

  40. #  define INIT_VLC(vlc, nb_bits, nb_codes, bits, bits_wrap, bits_size, \

  41.                    codes, codes_wrap, codes_size, use_static)          \

  42.   if (init_vlc(vlc, nb_bits, nb_codes, bits, bits_wrap, bits_size,     \

  43.                codes, codes_wrap, codes_size, use_static) < 0)         \

  44.   {                                                                    \

  45.     av_log(v->avctx, AV_LOG_ERROR, "Error for " # vlc " (%i)\n", i);   \

  46.     return -1;                                                         \

  47.   }

  48. #else

  49. #  define INIT_VLC(vlc, nb_bits, nb_codes, bits, bits_wrap, bits_size, \

  50.                    codes, codes_wrap, codes_size, use_static)          \

  51.   init_vlc(vlc, nb_bits, nb_codes, bits, bits_wrap, bits_size,         \

  52.            codes, codes_wrap, codes_size, use_static)

  53. #endif

  54. 

  55. #define PROFILE_SIMPLE   0

  56. #define PROFILE_MAIN     1

  57. #define PROFILE_ADVANCED 3

  58. 

  59. #define QUANT_FRAME_IMPLICIT   0

  60. #define QUANT_FRAME_EXPLICIT   1

  61. #define QUANT_NON_UNIFORM      2

  62. #define QUANT_UNIFORM          3

  63. 

  64. /* Where quant can be changed */

  65. #define DQPROFILE_FOUR_EDGES   0

  66. #define DQPROFILE_DOUBLE_EDGES 1

  67. #define DQPROFILE_SINGLE_EDGE  2

  68. #define DQPROFILE_ALL_MBS      3

  69. 

  70. /* Which edge is quantized with ALTPQUANT */

  71. #define DQSINGLE_BEDGE_LEFT   0

  72. #define DQSINGLE_BEDGE_TOP    1

  73. #define DQSINGLE_BEDGE_RIGHT  2

  74. #define DQSINGLE_BEDGE_BOTTOM 3

  75. 

  76. /* Which pair of edges is quantized with ALTPQUANT */

  77. #define DQDOUBLE_BEDGE_TOPLEFT     0

  78. #define DQDOUBLE_BEDGE_TOPRIGHT    1

  79. #define DQDOUBLE_BEDGE_BOTTOMRIGHT 2

  80. #define DQDOUBLE_BEDGE_BOTTOMLEFT  3

  81. 

  82. 

  83. /* Start Codes */

  84. #define SEQ_SC      0x00000010F /* Sequence Start Code */

  85. #define SEQ_EC      0x00000000A /* Sequence End code */

  86. #define SEQ_HDR     /* Sequence Header */

  87. #define ENTRY_SC    0x00000010E /* Entry Point Start Code */

  88. #define ENTRY_HDR /* Entry Point Header */

  89. #define FRM_SC      0x00000010D /* Frame Start Code */

  90. #define FRM_DAT /* Frame Data (includes a Frame Header) */

  91. #define FLD_SC      0x00000010C /* Field Start Code */

  92. #define FLD1_DAT /* Field 1 Data (includes a Frame Header) */

  93. #define FLD2_DAT /* Field 2 Data (includes a Field Header) */

  94. #define SLC_SC      0x00000010B /* Slice Start Code */

  95. #define SLC_HDR /* Slice Header */

  96. #define SLC_DAT /* Slice Data (FrH or FiH possible) */

  97. 

  98. /* MV P modes */

  99. #define MV_PMODE_1MV_HPEL_BILIN   0

  100. #define MV_PMODE_1MV              1

  101. #define MV_PMODE_1MV_HPEL         2

  102. #define MV_PMODE_MIXED_MV         3

  103. #define MV_PMODE_INTENSITY_COMP   4

  104. 

  105. /* MV P mode - the 5th element is only used for mode 1 */

  106. static const uint8_t mv_pmode_table[2][5] = {

  107.   { MV_PMODE_1MV_HPEL_BILIN, MV_PMODE_1MV, MV_PMODE_1MV_HPEL, MV_PMODE_MIXED_MV, MV_PMODE_INTENSITY_COMP },

  108.   { MV_PMODE_1MV, MV_PMODE_MIXED_MV, MV_PMODE_1MV_HPEL, MV_PMODE_1MV_HPEL_BILIN, MV_PMODE_INTENSITY_COMP }

  109. };

  110. 

  111. /* One more frame type */

  112. #define BI_TYPE 7

  113. 

  114. /* FIXME Worse than ugly */

  115. static const int fps_nr[5] = { 24, 25, 30, 50, 60 },

  116.   fps_dr[2] = { 1000, 1001 };

  117. static const uint8_t pquant_table[3][32] = {

  118.   {  /* Implicit quantizer */

  119.      0,  1,  2,  3,  4,  5,  6,  7,  8,  6,  7,  8,  9, 10, 11, 12,

  120.     13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 27, 29, 31

  121.   },

  122.   {  /* Explicit quantizer, pquantizer uniform */

  123.      0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,

  124.     16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31

  125.   },

  126.   {  /* Explicit quantizer, pquantizer non-uniform */

  127.      0,  1,  1,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13,

  128.     14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 29, 31

  129.   }

  130. };

  131. 

  132. // FIXME move this into the context

  133. #define VC9_BFRACTION_VLC_BITS 7

  134. static VLC vc9_bfraction_vlc;

  135. #define VC9_IMODE_VLC_BITS 4

  136. static VLC vc9_imode_vlc;

  137. #define VC9_NORM2_VLC_BITS 3

  138. static VLC vc9_norm2_vlc;

  139. /* Could be optimized, one table only needs 8 bits */

  140. #define VC9_TTMB_VLC_BITS 12

  141. static VLC vc9_ttmb_vlc[3];

  142. #define VC9_MV_DIFF_VLC_BITS 15

  143. static VLC vc9_mv_diff_vlc[4];

  144. #define VC9_CBPCY_I_VLC_BITS 13

  145. static VLC vc9_cbpcy_i_vlc;

  146. #define VC9_CBPCY_P_VLC_BITS 14

  147. static VLC vc9_cbpcy_p_vlc[4];

  148. #define VC9_4MV_BLOCK_PATTERN_VLC_BITS 6

  149. static VLC vc9_4mv_block_pattern_vlc[4];

  150. #define VC9_LUMA_DC_VLC_BITS 26

  151. static VLC vc9_luma_dc_vlc[2];

  152. 

  153. typedef struct VC9Context{

  154.   /* No MpegEnc context, might be good to use it */

  155.   GetBitContext gb;

  156.   AVCodecContext *avctx;

  157. 

  158.   /***************************/

  159.   /* Sequence Header         */

  160.   /***************************/

  161.   /* Simple/Main Profile */

  162.   int res_sm; //reserved, 2b

  163.   int res_x8; //reserved

  164.   int multires; //frame-level RESPIC syntax element present

  165.   int res_fasttx; //always 1

  166.   int res_transtab; //always 0

  167.   int syncmarker; //Sync markers presents

  168.   int rangered; //RANGEREDFRM (range reduction) syntax element present

  169.   int res_rtm_flag; //reserved, set to 1

  170.   int reserved; //duh

  171. 

  172. #if HAS_ADVANCED_PROFILE

  173.   /* Advanced Profile */

  174.   int level; //3

  175.   int chromaformat; //2

  176.   int postprocflag; //frame-based processing use

  177.   int broadcast; //TFF/RFF present

  178.     int interlace; //Progressive/interlaced (RPTFTM syntax element)

  179.   int tfcntrflag; //TFCNTR present

  180.   int panscanflag; //NUMPANSCANWIN, TOPLEFT{X,Y}, BOTRIGHT{X,Y} presents

  181.     int extended_dmv;

  182.   int color_prim; //8

  183.   int transfer_char; //8

  184.   int matrix_coef; //8

  185.   int hrd_param_flag;

  186. #endif

  187. 

  188.   /* All Profiles */

  189.   /* TODO: move all int to flags */

  190.   int profile; //2

  191.   int frmrtq_postproc; //3

  192.   int bitrtq_postproc; //5

  193.     int loopfilter;

  194.     int fastuvmc; //Rounding of qpel vector to hpel ? (not in Simple)

  195.   int extended_mv; //Ext MV in P/B (not in Simple)

  196.   int dquant; //Q varies with MBs, 2bits (not in Simple)

  197.   int vstransform; //variable-size transform46

  198. 

  199.   int overlap; //overlapped transforms in use

  200.   int quantizer_mode; //2, quantizer mode used for sequence, see QUANT_*

  201.   int finterpflag; //INTERPFRM present

  202. 

  203. 

  204.   /*****************************/

  205.   /* Frame decoding            */

  206.   /*****************************/

  207.   /* All profiles */

  208.   uint8_t mv_mode, mv_mode2; /* MV coding mode */

  209.   uint8_t pict_type; /* Picture type, mapped on MPEG types */

  210.   uint8_t pq, altpq; /* Quantizers */

  211.   uint8_t dquantfrm, dqprofile, dqsbedge, dqbilevel; /* pquant parameters */

  212.   int width_mb, height_mb;

  213.   int tile; /* 3x2 if (width_mb%3) else 2x3 */

  214.   int transacfrm2, transacfrm, transacdctab; //1bit elements

  215.   uint8_t ttmbf, ttfrm; /* Transform type */

  216.   uint8_t lumscale, lumshift; /* Luma compensation parameters */

  217.   int16_t bfraction; /* Relative position % anchors=> how to scale MVs */

  218.   uint8_t halfpq; /* Uniform quant over image and qp+.5 */

  219.   uint8_t respic;

  220.   /* Ranges:

  221.    * 0 -> [-64n 63.f] x [-32, 31.f]

  222.    * 1 -> [-128, 127.f] x [-64, 63.f]

  223.    * 2 -> [-512, 511.f] x [-128, 127.f]

  224.    * 3 -> [-1024, 1023.f] x [-256, 255.f]

  225.    */

  226.   uint8_t mvrange;

  227.   uint8_t pquantizer;

  228.   VLC *cbpcy_vlc /* Current CBPCY VLC table */,

  229.     *mv_diff_vlc /* Current MV Diff VLC table */,

  230.     *ttmb_vlc /* Current MB Transform Type VLC table */;

  231.   uint8_t *mv_type_mb_plane; /* bitplane for mv_type == "raw" */

  232.   uint8_t *skip_mb_plane, /* bitplane for skipped MBs */

  233.     *direct_mb_plane; /* bitplane for "direct" MBs */

  234. 

  235.   /* S/M only ? */

  236.   uint8_t rangeredfrm, interpfrm;

  237. 

  238. #if HAS_ADVANCED_PROFILE

  239.   /* Advanced */

  240.   uint8_t fcm; //0->Progressive, 2->Frame-Interlace, 3->Field-Interlace

  241.   uint8_t numpanscanwin;

  242.   uint8_t tfcntr;

  243.   uint8_t rptfrm, tff, rff;

  244.   uint8_t topleftx;

  245.   uint8_t toplefty;

  246.   uint8_t bottomrightx;

  247.   uint8_t bottomrighty;

  248.   uint8_t rndctrl;

  249.   uint8_t uvsamp;

  250.   uint8_t postproc;

  251.   int hrd_num_leaky_buckets;

  252.   uint8_t bit_rate_exponent;

  253.   uint8_t buffer_size_exponent;

  254.   uint8_t *ac_pred_plane;

  255.   uint8_t *over_flags_plane;

  256.   uint16_t *hrd_rate, *hrd_buffer;

  257. #endif

  258. } VC9Context;

  259. 

  260. /* FIXME Slow and ugly */

  261. static int get_prefix(GetBitContext *gb, int stop, int len)

  262. {

  263.   int i = 0, tmp = !stop;

  264. 

  265.   while (i != len && tmp != stop)

  266.   {

  267.     tmp = get_bits(gb, 1);

  268.     i++;

  269.   }

  270.   return i;

  271. }

  272. 

  273. static int init_common(VC9Context *v)

  274. {

  275.     static int done = 0;

  276.     int i;

  277. 

  278.     v->mv_type_mb_plane = v->direct_mb_plane = v->skip_mb_plane = NULL;

  279.     v->pq = -1;

  280. #if HAS_ADVANCED_PROFILE

  281.     v->ac_pred_plane = v->over_flags_plane = NULL;

  282.     v->hrd_rate = v->hrd_buffer = NULL;

  283. #endif

  284.     if(!done)

  285.     {

  286.         done = 1;

  287.         INIT_VLC(&vc9_bfraction_vlc, VC9_BFRACTION_VLC_BITS, 23,

  288.                  vc9_bfraction_bits, 1, 1,

  289.                  vc9_bfraction_codes, 1, 1, 1);

  290.         INIT_VLC(&vc9_norm2_vlc, VC9_NORM2_VLC_BITS, 4,

  291.                  vc9_norm2_bits, 1, 1,

  292.                  vc9_norm2_codes, 1, 1, 1);

  293.         INIT_VLC(&vc9_cbpcy_i_vlc, VC9_CBPCY_I_VLC_BITS, 64,

  294.                  vc9_cbpcy_i_bits, 1, 1,

  295.                  vc9_cbpcy_i_codes, 2, 2, 1);

  296.         INIT_VLC(&vc9_imode_vlc, VC9_IMODE_VLC_BITS, 7,

  297.                  vc9_imode_bits, 1, 1,

  298.                  vc9_imode_codes, 1, 1, 1);

  299.         for(i=0; i<3; i++)

  300.         {

  301.             INIT_VLC(&vc9_4mv_block_pattern_vlc[i], VC9_4MV_BLOCK_PATTERN_VLC_BITS, 16,

  302.                      vc9_4mv_block_pattern_bits[i], 1, 1,

  303.                      vc9_4mv_block_pattern_codes[i], 1, 1, 1);

  304.             INIT_VLC(&vc9_cbpcy_p_vlc[i], VC9_CBPCY_P_VLC_BITS, 64,

  305.                      vc9_cbpcy_p_bits[i], 1, 1,

  306.                      vc9_cbpcy_p_codes[i], 2, 2, 1);

  307.         }

  308.         for (i=0; i<2; i++)

  309.         {

  310.             INIT_VLC(&vc9_mv_diff_vlc[i], VC9_MV_DIFF_VLC_BITS, 73,

  311.                      vc9_mv_diff_bits[i], 1, 1,

  312.                      vc9_mv_diff_codes[i], 2, 2, 1);

  313.             INIT_VLC(&vc9_luma_dc_vlc[i], VC9_LUMA_DC_VLC_BITS, 26,

  314.                      vc9_luma_dc_bits[i], 1, 1,

  315.                      vc9_luma_dc_codes[i], 4, 4, 1);

  316.             INIT_VLC(&vc9_ttmb_vlc[i], VC9_TTMB_VLC_BITS, 16,

  317.                      vc9_ttmb_bits[i], 1, 1,

  318.                      vc9_ttmb_codes[i], 2, 2, 1);

  319.         }

  320.     }

  321. 

  322.     return 0;

  323. }

  324. 

  325. #if HAS_ADVANCED_PROFILE

  326. static int decode_hrd(VC9Context *v, GetBitContext *gb)

  327. {

  328.     int i, num;

  329. 

  330.     num = get_bits(gb, 5);

  331. 

  332.     if (v->hrd_rate || num != v->hrd_num_leaky_buckets)

  333.     {

  334.         av_free(v->hrd_rate);

  335.         v->hrd_rate = NULL;

  336.     }

  337.     if (!v->hrd_rate) v->hrd_rate = av_malloc(num);

  338.     if (!v->hrd_rate) return -1;

  339. 

  340.     if (v->hrd_buffer || num != v->hrd_num_leaky_buckets)

  341.     {

  342.         av_free(v->hrd_buffer);

  343.         v->hrd_buffer = NULL;

  344.     }

  345.     if (!v->hrd_buffer) v->hrd_buffer = av_malloc(num);

  346.     if (!v->hrd_buffer) return -1;

  347. 

  348.     v->hrd_num_leaky_buckets = num;

  349. 

  350.     //exponent in base-2 for rate

  351.     v->bit_rate_exponent = get_bits(gb, 4);

  352.     //exponent in base-2 for buffer_size

  353.     v->buffer_size_exponent = get_bits(gb, 4);

  354. 

  355.     for (i=0; i<num; i++)

  356.     {

  357.         //mantissae, ordered (if not, use a function ?

  358.         v->hrd_rate[i] = get_bits(gb, 16);

  359.         if (i && v->hrd_rate[i-1]>=v->hrd_rate[i])

  360.         {

  361.             av_log(v, AV_LOG_ERROR, "HDR Rates aren't strictly increasing:"

  362.                    "%i vs %i\n", v->hrd_rate[i-1], v->hrd_rate[i]);

  363.             return -1;

  364.         }

  365.         v->hrd_buffer[i] = get_bits(gb, 16);

  366.         if (i && v->hrd_buffer[i-1]<v->hrd_buffer[i])

  367.         {

  368.             av_log(v, AV_LOG_ERROR, "HDR Buffers aren't decreasing:"

  369.                    "%i vs %i\n", v->hrd_buffer[i-1], v->hrd_buffer[i]);

  370.             return -1;

  371.         }

  372.     }

  373.     return 0;

  374. }

  375. 

  376. static int decode_advanced_sequence_header(AVCodecContext *avctx, GetBitContext *gb)

  377. {

  378.     VC9Context *v = avctx->priv_data;

  379.     int nr, dr, aspect_ratio;

  380. 

  381.     v->postprocflag = get_bits(gb, 1);

  382.     v->broadcast = get_bits(gb, 1);

  383.     v->interlace = get_bits(gb, 1);

  384. 

  385.     v->tfcntrflag = get_bits(gb, 1);

  386.     v->finterpflag = get_bits(gb, 1); //common

  387.     v->panscanflag = get_bits(gb, 1);

  388.     v->reserved = get_bits(gb, 1);

  389.     if (v->reserved)

  390.     {

  391.         av_log(avctx, AV_LOG_ERROR, "RESERVED should be 0 (is %i)\n",

  392.                v->reserved);

  393.         return -1;

  394.     }

  395.     if (v->extended_mv)

  396.         v->extended_dmv = get_bits(gb, 1);

  397. 

  398.     if (get_bits(gb, 1) /* pic_size_flag */)

  399.     {

  400.         avctx->coded_width = get_bits(gb, 12);

  401.         avctx->coded_height = get_bits(gb, 12);

  402.         if ( get_bits(gb, 1) /* disp_size_flag */)

  403.         {

  404.             avctx->width = get_bits(gb, 14);

  405.             avctx->height = get_bits(gb, 14);

  406.         }

  407. 

  408.         if ( get_bits(gb, 1) /* aspect_ratio_flag */)

  409.         {

  410.             aspect_ratio = get_bits(gb, 4); //SAR

  411.             if (aspect_ratio == 0x0F) //FF_ASPECT_EXTENDED

  412.             {

  413.                 avctx->sample_aspect_ratio.num = get_bits(gb, 8);

  414.                 avctx->sample_aspect_ratio.den = get_bits(gb, 8);

  415.             }

  416.             else if (aspect_ratio == 0x0E)

  417.             {

  418.                 av_log(avctx, AV_LOG_DEBUG, "Reserved AR found\n");

  419.             }

  420.             else

  421.             {

  422.               avctx->sample_aspect_ratio = vc9_pixel_aspect[aspect_ratio];

  423.             }

  424.         }

  425.     }

  426.     else

  427.     {

  428.         avctx->coded_width = avctx->width;

  429.         avctx->coded_height = avctx->height;

  430.     }

  431. 

  432.     if ( get_bits(gb, 1) /* framerateflag */)

  433.     {

  434.         if ( get_bits(gb, 1) /* framerateind */)

  435.         {

  436.             nr = get_bits(gb, 8);

  437.             dr = get_bits(gb, 4);

  438.             if (nr<1)

  439.             {

  440.                 av_log(avctx, AV_LOG_ERROR, "0 is forbidden for FRAMERATENR\n");

  441.                 return -1;

  442.             }

  443.             if (nr>5)

  444.             {

  445.                 av_log(avctx, AV_LOG_ERROR,

  446.                        "Reserved FRAMERATENR %i not handled\n", nr);

  447.            }

  448.             if (dr<1)

  449.             {

  450.                 av_log(avctx, AV_LOG_ERROR, "0 is forbidden for FRAMERATEDR\n");

  451.            }

  452.             if (dr>2)

  453.             {

  454.                 av_log(avctx, AV_LOG_ERROR,

  455.                        "Reserved FRAMERATEDR %i not handled\n", dr);

  456.             }

  457.             avctx->frame_rate_base = fps_nr[dr];

  458.             avctx->frame_rate = fps_nr[nr];

  459.         }

  460.         else

  461.         {

  462.             nr = get_bits(gb, 16);

  463.             // 0.03125->2048Hz / 0.03125Hz

  464.             avctx->frame_rate = 1000000;

  465.             avctx->frame_rate_base = 31250*(1+nr);

  466.         }

  467.     }

  468. 

  469.     if ( get_bits(gb, 1) /* color_format_flag */)

  470.     {

  471.         //Chromacity coordinates of color primaries

  472.         //like ITU-R BT.709-2, BT.470-2, ...

  473.         v->color_prim = get_bits(gb, 8);

  474.         if (v->color_prim<1)

  475.         {

  476.             av_log(avctx, AV_LOG_ERROR, "0 for COLOR_PRIM is reserved\n");

  477.             return -1;

  478.         }

  479.         if (v->color_prim == 3 || v->color_prim>6)

  480.         {

  481.             av_log(avctx, AV_LOG_DEBUG, "Reserved COLOR_PRIM %i found\n",

  482.                    v->color_prim);

  483.             return -1;

  484.         }

  485. 

  486.         //Opto-electronic transfer characteristics

  487.         v->transfer_char = get_bits(gb, 8);

  488.         if (v->transfer_char == 3 || v->transfer_char>8)

  489.         {

  490.             av_log(avctx, AV_LOG_DEBUG, "Reserved TRANSFERT_CHAR %i found\n",

  491.                    v->color_prim);

  492.             return -1;

  493.         }

  494. 

  495.         //Matrix coefficient for primariev->YCbCr

  496.         v->matrix_coef = get_bits(gb, 8);

  497.         if (v->matrix_coef < 1) return -1; //forbidden

  498.         if ((v->matrix_coef>3 && v->matrix_coef<6) || v->matrix_coef>7)

  499.         {

  500.             av_log(avctx, AV_LOG_DEBUG, "Reserved MATRIX_COEF %i found\n",

  501.                    v->color_prim);

  502.             return -1;

  503.         }

  504.     }

  505. 

  506.     //Hypothetical reference decoder indicator flag

  507.     v->hrd_param_flag = get_bits(gb, 1);

  508.     if (v->hrd_param_flag)

  509.     {

  510.       if (decode_hrd(v, gb) < 0) return -1;

  511.     }

  512. 

  513.     av_log(avctx, AV_LOG_DEBUG, "Advanced profile not supported yet\n");

  514.     return -1;

  515. }

  516. #endif

  517. 

  518. static int decode_sequence_header(AVCodecContext *avctx, GetBitContext *gb)

  519. {

  520.     VC9Context *v = avctx->priv_data;

  521. 

  522.     v->profile = get_bits(gb, 2);

  523.     av_log(avctx, AV_LOG_DEBUG, "Profile: %i\n", v->profile);

  524. 

  525. #if HAS_ADVANCED_PROFILE

  526.     if (v->profile > PROFILE_MAIN)

  527.     {

  528.         v->level = get_bits(gb, 3);

  529.         v->chromaformat = get_bits(gb, 2);

  530.         if (v->chromaformat != 1)

  531.         {

  532.             av_log(avctx, AV_LOG_ERROR,

  533.                    "Only 4:2:0 chroma format supported\n");

  534.             return -1;

  535.         }

  536.     }

  537.     else

  538. #endif

  539.     {

  540.         v->res_sm = get_bits(gb, 2); //reserved

  541.         if (v->res_sm)

  542.         {

  543.             av_log(avctx, AV_LOG_ERROR,

  544.                    "Reserved RES_SM=%i is forbidden\n", v->res_sm);

  545.             //return -1;

  546.         }

  547.     }

  548. 

  549.     // (fps-2)/4 (->30)

  550.     v->frmrtq_postproc = get_bits(gb, 3); //common

  551.     // (bitrate-32kbps)/64kbps

  552.     v->bitrtq_postproc = get_bits(gb, 5); //common

  553.     v->loopfilter = get_bits(gb, 1); //common

  554. 

  555. #if HAS_ADVANCED_PROFILE

  556.     if (v->profile <= PROFILE_MAIN)

  557. #endif

  558.     {

  559.         v->res_x8 = get_bits(gb, 1); //reserved

  560.         if (v->res_x8)

  561.         {

  562.             av_log(avctx, AV_LOG_ERROR,

  563.                    "1 for reserved RES_X8 is forbidden\n");

  564.             return -1;

  565.         }

  566.         v->multires = get_bits(gb, 1);

  567.         v->res_fasttx = get_bits(gb, 1);

  568.         if (!v->res_fasttx)

  569.         {

  570.             av_log(avctx, AV_LOG_ERROR,

  571.                    "0 for reserved RES_FASTTX is forbidden\n");

  572.             //return -1;

  573.         }

  574.     }

  575. 

  576.     v->fastuvmc =  get_bits(gb, 1); //common

  577.     if (!v->profile && !v->fastuvmc)

  578.     {

  579.         av_log(avctx, AV_LOG_ERROR,

  580.                "FASTUVMC unavailable in Simple Profile\n");

  581.         return -1;

  582.     }

  583.     v->extended_mv =  get_bits(gb, 1); //common

  584.     if (!v->profile && v->extended_mv)

  585.     {

  586.         av_log(avctx, AV_LOG_ERROR,

  587.                "Extended MVs unavailable in Simple Profile\n");

  588.         return -1;

  589.     }

  590.     v->dquant =  get_bits(gb, 2); //common

  591.     v->vstransform =  get_bits(gb, 1); //common

  592.     

  593. #if HAS_ADVANCED_PROFILE

  594.     if (v->profile <= PROFILE_MAIN)

  595. #endif

  596.     {

  597.         v->res_transtab = get_bits(gb, 1);

  598.         if (v->res_transtab)

  599.         {

  600.             av_log(avctx, AV_LOG_ERROR,

  601.                    "1 for reserved RES_TRANSTAB is forbidden\n");

  602.             return -1;

  603.         }

  604.     }

  605. 

  606.     v->overlap = get_bits(gb, 1); //common

  607. 

  608. #if HAS_ADVANCED_PROFILE

  609.     if (v->profile <= PROFILE_MAIN)

  610. #endif

  611.     {

  612.         v->syncmarker = get_bits(gb, 1);

  613.         v->rangered = get_bits(gb, 1);

  614.     }

  615. 

  616.     avctx->max_b_frames = get_bits(gb, 3); //common

  617.     v->quantizer_mode = get_bits(gb, 2); //common

  618. 

  619. #if HAS_ADVANCED_PROFILE

  620.     if (v->profile <= PROFILE_MAIN)

  621. #endif

  622.     {

  623.         v->finterpflag = get_bits(gb, 1); //common

  624.         v->res_rtm_flag = get_bits(gb, 1); //reserved

  625.         if (!v->res_rtm_flag)

  626.         {

  627.             av_log(avctx, AV_LOG_ERROR,

  628.                    "0 for reserved RES_RTM_FLAG is forbidden\n");

  629.             //return -1;

  630.         }

  631. #if TRACE

  632.         av_log(avctx, AV_LOG_INFO,

  633.                "Profile %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"

  634.                "LoopFilter=%i, MultiRes=%i, FastUVMV=%i, Extended MV=%i\n"

  635.                "Rangered=%i, VSTransform=%i, Overlap=%i, SyncMarker=%i\n"

  636.                "DQuant=%i, Quantizer mode=%i, Max B frames=%i\n",

  637.                v->profile, v->frmrtq_postproc, v->bitrtq_postproc,

  638.                v->loopfilter, v->multires, v->fastuvmc, v->extended_mv,

  639.                v->rangered, v->vstransform, v->overlap, v->syncmarker,

  640.                v->dquant, v->quantizer_mode, avctx->max_b_frames

  641.                );

  642. #endif

  643.     }

  644. #if HAS_ADVANCED_PROFILE

  645.     else decode_advanced_sequence_header(avctx, gb);

  646. #endif

  647. }

  648. 

  649. 

  650. #if HAS_ADVANCED_PROFILE

  651. /*****************************************************************************/

  652. /* Entry point decoding (Advanced Profile)                                   */

  653. /*****************************************************************************/

  654. static int advanced_entry_point_process(AVCodecContext *avctx, GetBitContext *gb)

  655. {

  656.     VC9Context *v = avctx->priv_data;

  657.     int range_mapy_flag, range_mapuv_flag, i;

  658.     if (v->profile != PROFILE_ADVANCED)

  659.     {

  660.         av_log(avctx, AV_LOG_ERROR,

  661.                "Entry point are only defined in Advanced Profile!\n");

  662.         return -1; //Only for advanced profile!

  663.     }

  664.     if (v->hrd_param_flag)

  665.     {

  666.         //Update buffer fullness

  667.         av_log(avctx, AV_LOG_DEBUG, "Buffer fullness update\n");

  668.         for (i=0; i<v->hrd_num_leaky_buckets; i++)

  669.             skip_bits(gb, 8);

  670.     }

  671.     if ((range_mapy_flag = get_bits(gb, 1)))

  672.     {

  673.         //RANGE_MAPY

  674.         av_log(avctx, AV_LOG_DEBUG, "RANGE_MAPY\n");

  675.         skip_bits(gb, 3);

  676.     }

  677.     if ((range_mapuv_flag = get_bits(gb, 1)))

  678.     {

  679.         //RANGE_MAPUV

  680.         av_log(avctx, AV_LOG_DEBUG, "RANGE_MAPUV\n");

  681.         skip_bits(gb, 3);

  682.     }

  683.     if (v->panscanflag)

  684.     {

  685.         //NUMPANSCANWIN

  686.         v->numpanscanwin = get_bits(gb, 3);

  687.         av_log(avctx, AV_LOG_DEBUG, "NUMPANSCANWIN: %u\n", v->numpanscanwin);

  688.     }

  689.     return 0;

  690. }

  691. #endif

  692. 

  693. /******************************************************************************/

  694. /* Bitplane decoding                                                          */

  695. /******************************************************************************/

  696. #define IMODE_RAW     0

  697. #define IMODE_NORM2   1

  698. #define IMODE_DIFF2   2

  699. #define IMODE_NORM6   3

  700. #define IMODE_DIFF6   4

  701. #define IMODE_ROWSKIP 5

  702. #define IMODE_COLSKIP 6

  703. 

  704. //FIXME optimize

  705. static int bitplane_decoding(uint8_t* plane, int width, int height, VC9Context *v)

  706. {

  707.     int imode, x, y, code;

  708.     uint8_t invert, *planep = plane;

  709. 

  710.     invert = get_bits(&v->gb, 1);

  711.     imode = get_vlc2(&v->gb, vc9_imode_vlc.table, VC9_IMODE_VLC_BITS, 2);

  712.     av_log(v->avctx, AV_LOG_DEBUG, "Bitplane: imode=%i, invert=%i\n",

  713.            imode, invert);

  714. 

  715.     switch (imode)

  716.     {

  717.     case IMODE_RAW:

  718.         for (y=0; y<height; y++)

  719.         {

  720.             for (x=0; x<width; x++)

  721.                 planep[x] = (-get_bits(&v->gb, 1)); //-1=0xFF

  722.             planep += width;

  723.         }

  724.         break;

  725.     case IMODE_DIFF2:

  726.     case IMODE_NORM2:

  727.         if ((height*width) & 1) *(++planep) = get_bits(&v->gb, 1);

  728.         code = get_vlc2(&v->gb, vc9_norm2_vlc.table, VC9_NORM2_VLC_BITS, 2);

  729.         *(++planep) = code&1; //lsb => left

  730.         *(++planep) = code&2; //msb => right - this is a bitplane, so only !0 matters

  731.         break;

  732.     case IMODE_DIFF6:

  733.     case IMODE_NORM6:

  734.         av_log(v->avctx, AV_LOG_ERROR, "Imode using Norm-6 isn't supported\n");

  735.         return -1;

  736.         break;

  737.     case IMODE_ROWSKIP:

  738.         for (y=0; y<height; y++)

  739.         {

  740.             if (get_bits(&v->gb, 1)) //rowskip

  741.               memset(planep, 0, width);

  742.             else for (x=0; x<width; x++) planep[x] = get_bits(&v->gb, 1);

  743.             planep += width;

  744.         }

  745.         break;

  746.     case IMODE_COLSKIP: //Teh ugly

  747.         for (x=0; x<width; x++)

  748.         {

  749.             planep = plane;

  750.             if (get_bits(&v->gb, 1)) //colskip

  751.             {

  752.                 for (y=0; y<height; y++)

  753.                 {

  754.                     planep[x] = 0;

  755.                     planep += width;

  756.                 }

  757.             }

  758.             else

  759.             {

  760.                 for (y=0; y<height; y++)

  761.                 {

  762.                     planep[x] = get_bits(&v->gb, 1);

  763.                     planep += width;

  764.                 }

  765.             }

  766.         }

  767.         break;

  768.     default: break;

  769.     }

  770. 

  771.     /* Applying diff operator */

  772.     if (imode == IMODE_DIFF2 || imode == IMODE_DIFF2)

  773.     {

  774.         /* And what about j=0 !? */

  775.         planep = plane + width;

  776.         memset(plane, invert, width);

  777.         for (y=0; y<height; y++)

  778.         {

  779.             planep[0] = planep[-width];

  780.             for (x=1; x<width; x++)

  781.             {

  782.                 if (planep[x-1] != planep[-width]) planep[x] = invert;

  783.                 else planep[x] = planep[x-1];

  784.             }

  785.             planep += width;

  786.         }

  787.     }

  788.     else if (invert)

  789.     {

  790.         planep = plane;

  791.         for (x=0; x<width*height; x++) planep[x] = !planep[x];

  792.     }

  793.     return 0;

  794. }

  795. 

  796. /*****************************************************************************/

  797. /* VOP Dquant decoding                                                       */

  798. /*****************************************************************************/

  799. static int vop_dquant_decoding(VC9Context *v)

  800. {

  801.     int pqdiff;

  802. 

  803.     //variable size

  804.     if (v->dquant == 2)

  805.     {

  806.         pqdiff = get_bits(&v->gb, 3);

  807.         if (pqdiff == 7) v->altpq = get_bits(&v->gb, 5);

  808.         else v->altpq = v->pq + pqdiff + 1;

  809.     }

  810.     else

  811.     {

  812.         v->dquantfrm = get_bits(&v->gb, 1);

  813.         if ( v->dquantfrm )

  814.         {

  815.             v->dqprofile = get_bits(&v->gb, 2);

  816.             switch (v->dqprofile)

  817.             {

  818.             case DQPROFILE_SINGLE_EDGE:

  819.             case DQPROFILE_DOUBLE_EDGES:

  820.                 v->dqsbedge = get_bits(&v->gb, 2);

  821.                 break;

  822.             case DQPROFILE_ALL_MBS:

  823.                 v->dqbilevel = get_bits(&v->gb, 1);

  824.             default: break; //Forbidden ?

  825.             }

  826.             if (!v->dqbilevel || v->dqprofile != DQPROFILE_ALL_MBS)

  827.             {

  828.                 pqdiff = get_bits(&v->gb, 3);

  829.                 if (pqdiff == 7) v->altpq = get_bits(&v->gb, 5);

  830.                 else v->altpq = v->pq + pqdiff + 1;

  831.             }

  832.         }

  833.     }

  834.     return 0;

  835. }

  836. 

  837. /*****************************************************************************/

  838. /* All Profiles picture header decoding specific functions                   */

  839. /* Only pro/epilog differs between Simple/Main and Advanced => check caller  */

  840. /*****************************************************************************/

  841. static int decode_bi_picture_header(VC9Context *v)

  842. {

  843.     /* Very particular case:

  844.        - for S/M Profiles, decode_b_picture_header reads BF,

  845.          bfraction then determine if this is a BI frame, calling

  846.          this function afterwards

  847.        - for A Profile, PTYPE already tells so and we can go

  848.          directly there

  849.     */

  850.     int pqindex;

  851. 

  852.     /* Read the quantization stuff */

  853.     pqindex = get_bits(&v->gb, 5);

  854.     if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)

  855.         v->pq = pquant_table[0][pqindex];

  856.     else

  857.     {

  858.         v->pq = pquant_table[v->quantizer_mode-1][pqindex];

  859.     }

  860.     if (pqindex < 9) v->halfpq = get_bits(&v->gb, 1);

  861.     if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)

  862.         v->pquantizer = get_bits(&v->gb, 1);

  863. 

  864.     /* Read the MV type/mode */

  865.     if (v->extended_mv == 1)

  866.         v->mvrange = get_prefix(&v->gb, 0, 3);

  867. 

  868.     /* FIXME: what table are used in that case ? */

  869.     v->mv_diff_vlc = &vc9_mv_diff_vlc[0];

  870.     v->cbpcy_vlc = &vc9_cbpcy_i_vlc;

  871. 

  872.     av_log(v->avctx, AV_LOG_DEBUG, "B frame, QP=%i\n", v->pq);

  873.     av_log(v->avctx, AV_LOG_ERROR, "BI_TYPE not supported yet\n");

  874.     /* Epilog should be done in caller */

  875.     return -1;

  876. }

  877. 

  878. static int decode_b_picture_header(VC9Context *v)

  879. {

  880.     int pqindex;

  881. 

  882.     /* Prolog common to all frametypes should be done in caller */

  883.     if (v->profile == PROFILE_SIMPLE)

  884.     {

  885.         av_log(v, AV_LOG_ERROR, "Found a B frame while in Simple Profile!\n");

  886.         return FRAME_SKIPED;

  887.     }

  888. 

  889.     v->bfraction = vc9_bfraction_lut[get_vlc2(&v->gb, vc9_bfraction_vlc.table,

  890.                                               VC9_BFRACTION_VLC_BITS, 2)];

  891.     if (v->bfraction < -1)

  892.     {

  893.         av_log(v, AV_LOG_ERROR, "Invalid BFRaction\n");

  894.         return FRAME_SKIPED;

  895.     }

  896.     else if (!v->bfraction)

  897.     {

  898.         /* We actually have a BI frame */

  899.         return decode_bi_picture_header(v);

  900.     }

  901. 

  902.     /* Read the quantization stuff */

  903.     pqindex = get_bits(&v->gb, 5);

  904.     if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)

  905.         v->pq = pquant_table[0][pqindex];

  906.     else

  907.     {

  908.         v->pq = pquant_table[v->quantizer_mode-1][pqindex];

  909.     }

  910.     if (pqindex < 9) v->halfpq = get_bits(&v->gb, 1);

  911.     if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)

  912.         v->pquantizer = get_bits(&v->gb, 1);

  913. 

  914.     /* Read the MV type/mode */

  915.     if (v->extended_mv == 1)

  916.         v->mvrange = get_prefix(&v->gb, 0, 3);

  917.     v->mv_mode = get_bits(&v->gb, 1);

  918.     if (v->pq < 13)

  919.     {

  920.         if (!v->mv_mode)

  921.         {

  922.             v->mv_mode = get_bits(&v->gb, 2);

  923.             if (v->mv_mode)

  924.                 av_log(v, AV_LOG_ERROR,

  925.                        "mv_mode for lowquant B frame was %i\n", v->mv_mode);

  926.         }

  927.     }

  928.     else

  929.     {

  930.         if (!v->mv_mode)

  931.         {

  932.             if (get_bits(&v->gb, 1))

  933.                 av_log(v, AV_LOG_ERROR,

  934.                        "mv_mode for highquant B frame was %i\n", v->mv_mode);

  935.         }

  936.         v->mv_mode = 1-v->mv_mode; //To match (pq < 13) mapping

  937.     }

  938. 

  939.     if (v->mv_mode == MV_PMODE_MIXED_MV)

  940.     {

  941.         if (bitplane_decoding( v->mv_type_mb_plane, v->width_mb,

  942.                                    v->height_mb, v)<0)

  943.             return -1;

  944.     }

  945. 

  946.     //bitplane

  947.     bitplane_decoding(v->direct_mb_plane, v->width_mb, v->height_mb, v);

  948.     bitplane_decoding(v->skip_mb_plane, v->width_mb, v->height_mb, v);

  949. 

  950.     /* FIXME: what is actually chosen for B frames ? */

  951.     v->mv_diff_vlc = &vc9_mv_diff_vlc[get_bits(&v->gb, 2)];

  952.     v->cbpcy_vlc = &vc9_cbpcy_p_vlc[get_bits(&v->gb, 2)];

  953.     if (v->dquant)

  954.     {

  955.         vop_dquant_decoding(v);

  956.     }

  957. 

  958.     if (v->vstransform)

  959.     {

  960.         v->ttmbf = get_bits(&v->gb, 1);

  961.         if (v->ttmbf)

  962.         {

  963.             v->ttfrm = get_bits(&v->gb, 2);

  964.             av_log(v, AV_LOG_INFO, "Transform used: %ix%i\n",

  965.                    (v->ttfrm & 2) ? 4 : 8, (v->ttfrm & 1) ? 4 : 8);

  966.         }

  967.     }

  968.     /* Epilog should be done in caller */

  969.     return 0;

  970. }

  971. 

  972. static int decode_i_picture_header(VC9Context *v)

  973. {

  974.   int pqindex, status = 0, ac_pred, condover;

  975. 

  976.     /* Prolog common to all frametypes should be done in caller */

  977.     //BF = Buffer Fullness

  978.     if (v->profile <= PROFILE_MAIN && get_bits(&v->gb, 7))

  979.     {

  980.         av_log(v, AV_LOG_DEBUG, "I BufferFullness not 0\n");

  981.     }

  982. 

  983.     /* Quantizer stuff */

  984.     pqindex = get_bits(&v->gb, 5);

  985.     if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)

  986.         v->pq = pquant_table[0][pqindex];

  987.     else

  988.     {

  989.         v->pq = pquant_table[v->quantizer_mode-1][pqindex];

  990.     }

  991.     if (pqindex < 9) v->halfpq = get_bits(&v->gb, 1);

  992.     if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)

  993.         v->pquantizer = get_bits(&v->gb, 1);

  994.     av_log(v->avctx, AV_LOG_DEBUG, "I frame: QP=%i (+%i/2)\n",

  995.            v->pq, v->halfpq);

  996. #if HAS_ADVANCED_PROFILE

  997.     if (v->profile <= PROFILE_MAIN)

  998. #endif

  999.     {

  1000.         if (v->extended_mv) v->mvrange = get_prefix(&v->gb, 0, 3);

  1001.         if (v->multires) v->respic = get_bits(&v->gb, 2);

  1002.     }

  1003. #if HAS_ADVANCED_PROFILE

  1004.     else

  1005.     {

  1006.         ac_pred = get_bits(&v->gb, 1);

  1007.         if (v->postprocflag) v->postproc = get_bits(&v->gb, 1);

  1008.         /* 7.1.1.34 + 8.5.2 */

  1009.         if (v->overlap && v->pq<9)

  1010.         {

  1011.             condover = get_bits(&v->gb, 1);

  1012.             if (condover)

  1013.             {

  1014.                 condover = 2+get_bits(&v->gb, 1);

  1015.                 if (condover == 3)

  1016.                     status = bitplane_decoding(v->over_flags_plane,

  1017.                                                    v->width_mb, v->height_mb, v);

  1018.             }

  1019.         }

  1020.     }

  1021. #endif

  1022. 

  1023.     /* Epilog should be done in caller */

  1024.     return status;

  1025. }

  1026. 

  1027. static int decode_p_picture_header(VC9Context *v)

  1028. {

  1029.     /* INTERFRM, FRMCNT, RANGEREDFRM read in caller */

  1030.     int lowquant, pqindex;

  1031. 

  1032.     pqindex = get_bits(&v->gb, 5);

  1033.     if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)

  1034.         v->pq = pquant_table[0][pqindex];

  1035.     else

  1036.     {

  1037.         v->pq = pquant_table[v->quantizer_mode-1][pqindex];

  1038.     }

  1039.     if (pqindex < 9) v->halfpq = get_bits(&v->gb, 1);

  1040.     if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)

  1041.         v->pquantizer = get_bits(&v->gb, 1);

  1042.     av_log(v->avctx, AV_LOG_DEBUG, "P Frame: QP=%i (+%i/2)\n",

  1043.            v->pq, v->halfpq);

  1044.     if (v->extended_mv == 1) v->mvrange = get_prefix(&v->gb, 0, 3);

  1045. #if HAS_ADVANCED_PROFILE

  1046.     if (v->profile > PROFILE_MAIN)

  1047.     {

  1048.         if (v->postprocflag) v->postproc = get_bits(&v->gb, 1);

  1049.     }

  1050.     else

  1051. #endif

  1052.         if (v->multires) v->respic = get_bits(&v->gb, 2);

  1053.     lowquant = (v->pquantizer>12) ? 0 : 1;

  1054.     v->mv_mode = mv_pmode_table[lowquant][get_prefix(&v->gb, 1, 4)];

  1055.     if (v->mv_mode == MV_PMODE_INTENSITY_COMP)

  1056.     {

  1057.         v->mv_mode2 = mv_pmode_table[lowquant][get_prefix(&v->gb, 1, 3)];

  1058.         v->lumscale = get_bits(&v->gb, 6);

  1059.         v->lumshift = get_bits(&v->gb, 6);

  1060.     }

  1061. 

  1062.     if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&

  1063.          v->mv_mode2 == MV_PMODE_MIXED_MV)

  1064.         || v->mv_mode == MV_PMODE_MIXED_MV)

  1065.     {

  1066.         if (bitplane_decoding(v->mv_type_mb_plane, v->width_mb,

  1067.                                   v->height_mb, v) < 0)

  1068.             return -1;

  1069.     }

  1070. 

  1071.     if (bitplane_decoding(v->skip_mb_plane, v->width_mb,

  1072.                               v->height_mb, v) < 0)

  1073.         return -1;

  1074. 

  1075.     /* Hopefully this is correct for P frames */

  1076.     v->mv_diff_vlc = &vc9_mv_diff_vlc[get_bits(&v->gb, 2)];

  1077.     v->cbpcy_vlc = &vc9_cbpcy_p_vlc[get_bits(&v->gb, 2)];

  1078. 

  1079.     if (v->dquant)

  1080.     {

  1081.         av_log(v->avctx, AV_LOG_INFO, "VOP DQuant info\n");

  1082.         vop_dquant_decoding(v);

  1083.     }

  1084. 

  1085.     if (v->vstransform)

  1086.     {

  1087.         v->ttmbf = get_bits(&v->gb, 1);

  1088.         if (v->ttmbf)

  1089.         {

  1090.             v->ttfrm = get_bits(&v->gb, 2);

  1091.             av_log(v->avctx, AV_LOG_INFO, "Transform used: %ix%i\n",

  1092.                    (v->ttfrm & 2) ? 4 : 8, (v->ttfrm & 1) ? 4 : 8);

  1093.         }

  1094.     }

  1095.     /* Epilog should be done in caller */

  1096.     return 0;

  1097. }

  1098. 

  1099. 

  1100. static int standard_decode_picture_header(VC9Context *v)

  1101. {

  1102.     int status = 0;

  1103. 

  1104.     if (v->finterpflag) v->interpfrm = get_bits(&v->gb, 1);

  1105.     skip_bits(&v->gb, 2); //framecnt unused

  1106.     if (v->rangered) v->rangeredfrm = get_bits(&v->gb, 1);

  1107.     v->pict_type = get_bits(&v->gb, 1);

  1108.     if (v->avctx->max_b_frames && !v->pict_type)

  1109.     {

  1110.         if (get_bits(&v->gb, 1)) v->pict_type = I_TYPE;

  1111.         else v->pict_type = P_TYPE;

  1112.     }

  1113.     else v->pict_type++; //P_TYPE

  1114. 

  1115.     switch (v->pict_type)

  1116.     {

  1117.     case I_TYPE: status = decode_i_picture_header(v); break;

  1118.     case BI_TYPE: status = decode_b_picture_header(v); break;

  1119.     case P_TYPE: status = decode_p_picture_header(v); break;

  1120.     case B_TYPE: status = decode_b_picture_header(v); break;

  1121.     }

  1122. 

  1123.     if (status == FRAME_SKIPED)

  1124.     {

  1125.       av_log(v, AV_LOG_INFO, "Skipping frame...\n");

  1126.       return status;

  1127.     }

  1128. 

  1129.     /* AC/DC Syntax */

  1130.     v->transacfrm = get_bits(&v->gb, 1);

  1131.     if (v->transacfrm) v->transacfrm += get_bits(&v->gb, 1);

  1132.     if (v->pict_type == I_TYPE || v->pict_type == BI_TYPE)

  1133.     {

  1134.         v->transacfrm2 = get_bits(&v->gb, 1);

  1135.         if (v->transacfrm2) v->transacfrm2 += get_bits(&v->gb, 1);

  1136.     }

  1137.     v->transacdctab = get_bits(&v->gb, 1);

  1138.    

  1139.     return 0;

  1140. }

  1141. 

  1142. 

  1143. #if HAS_ADVANCED_PROFILE

  1144. /******************************************************************************/

  1145. /* Advanced Profile picture header decoding specific functions                */

  1146. /******************************************************************************/

  1147. static int advanced_decode_picture_header(VC9Context *v)

  1148. {

  1149.     static const int type_table[4] = { P_TYPE, B_TYPE, I_TYPE, BI_TYPE };

  1150.     int type, i, ret;

  1151. 

  1152.     if (v->interlace)

  1153.     {

  1154.         v->fcm = get_bits(&v->gb, 1);

  1155.         if (v->fcm) v->fcm = 2+get_bits(&v->gb, 1);

  1156.     }

  1157. 

  1158.     type = get_prefix(&v->gb, 0, 4);

  1159.     if (type > 4 || type < 0) return FRAME_SKIPED;

  1160.     v->pict_type = type_table[type];

  1161.     av_log(v->avctx, AV_LOG_INFO, "AP Frame Type: %i\n", v->pict_type);

  1162. 

  1163.     if (v->tfcntrflag) v->tfcntr = get_bits(&v->gb, 8);

  1164.     if (v->broadcast)

  1165.     {

  1166.         if (!v->interlace) v->rptfrm = get_bits(&v->gb, 2);

  1167.         else

  1168.         {

  1169.             v->tff = get_bits(&v->gb, 1);

  1170.             v->rff = get_bits(&v->gb, 1);

  1171.         }

  1172.     }

  1173. 

  1174.     if (v->panscanflag)

  1175.     {

  1176. #if 0

  1177.         for (i=0; i<v->numpanscanwin; i++)

  1178.         {

  1179.             v->topleftx[i] = get_bits(&v->gb, 16);

  1180.             v->toplefty[i] = get_bits(&v->gb, 16);

  1181.             v->bottomrightx[i] = get_bits(&v->gb, 16);

  1182.             v->bottomrighty[i] = get_bits(&v->gb, 16);

  1183.         }

  1184. #else

  1185.         skip_bits(&v->gb, 16*4*v->numpanscanwin);

  1186. #endif

  1187.     }

  1188.     v->rndctrl = get_bits(&v->gb, 1);

  1189.     v->uvsamp = get_bits(&v->gb, 1);

  1190.     if (v->finterpflag == 1) v->interpfrm = get_bits(&v->gb, 1);

  1191. 

  1192.     switch(v->pict_type)

  1193.     {

  1194.     case I_TYPE: if (decode_i_picture_header(v) < 0) return -1;

  1195.     case P_TYPE: if (decode_p_picture_header(v) < 0) return -1;

  1196.     case BI_TYPE:

  1197.     case B_TYPE: if (decode_b_picture_header(v) < 0) return FRAME_SKIPED;

  1198.     default: break;

  1199.     }

  1200. 

  1201.     /* AC/DC Syntax */

  1202.     v->transacfrm = get_bits(&v->gb, 1);

  1203.     if (v->transacfrm) v->transacfrm += get_bits(&v->gb, 1);

  1204.     if (v->pict_type == I_TYPE || v->pict_type == BI_TYPE)

  1205.     {

  1206.         v->transacfrm2 = get_bits(&v->gb, 1);

  1207.         if (v->transacfrm2) v->transacfrm2 += get_bits(&v->gb, 1);

  1208.     }

  1209.     v->transacdctab = get_bits(&v->gb, 1);

  1210.     if (v->pict_type == I_TYPE) vop_dquant_decoding(v);

  1211. 

  1212.     return 0;

  1213. }

  1214. #endif

  1215. 

  1216. /******************************************************************************/

  1217. /* MacroBlock decoding functions                                              */

  1218. /******************************************************************************/

  1219. static int standard_decode_i_mbs(VC9Context *v)

  1220. {

  1221.     int x, y, ac_pred, cbpcy;

  1222. 

  1223.     /* Select ttmb table depending on pq */

  1224.     if (v->pq < 5) v->ttmb_vlc = &vc9_ttmb_vlc[0];

  1225.     else if (v->pq < 13) v->ttmb_vlc = &vc9_ttmb_vlc[1];

  1226.     else v->ttmb_vlc = &vc9_ttmb_vlc[2];

  1227. 

  1228.     for (y=0; y<v->height_mb; y++)

  1229.     {

  1230.         for (x=0; x<v->width_mb; x++)

  1231.         {

  1232.             cbpcy = get_vlc2(&v->gb, vc9_cbpcy_i_vlc.table,

  1233.                              VC9_CBPCY_I_VLC_BITS, 2);

  1234.             ac_pred = get_bits(&v->gb, 1);

  1235.             //Decode blocks from that mb wrt cbpcy

  1236.         }

  1237.     }

  1238.     return 0;

  1239. }

  1240. 

  1241. #define GET_MQUANT()                                           \

  1242.   if (v->dquantfrm)                                            \

  1243.   {                                                            \

  1244.     if (v->dqprofile == DQPROFILE_ALL_MBS)                     \

  1245.     {                                                          \

  1246.       if (v->dqbilevel)                                        \

  1247.       {                                                        \

  1248.         mquant = (get_bits(&v->gb, 1)) ? v->pq : v->altpq;     \

  1249.       }                                                        \

  1250.       else                                                     \

  1251.       {                                                        \

  1252.         mqdiff = get_bits(&v->gb, 3);                          \

  1253.         if (mqdiff != 7) mquant = v->pq + mqdiff;              \

  1254.         else mquant = get_bits(&v->gb, 5);                     \

  1255.       }                                                        \

  1256.     }                                                          \

  1257.   }

  1258. 

  1259. /* MVDATA decoding from 8.3.5.2 */

  1260. #define GET_MVDATA()                                           \

  1261.   index = 1 + get_vlc2(&v->gb, v->mv_diff_vlc->table,          \

  1262.                        VC9_MV_DIFF_VLC_BITS, 2);               \

  1263.   if (index > 36)                                              \

  1264.   {                                                            \

  1265.     mb_has_coeffs = 1;                                         \

  1266.     index -= 37;                                               \

  1267.   }                                                            \

  1268.   else mb_has_coeffs = 0;                                      \

  1269.   mb_is_intra = 0;                                             \

  1270.   if (!index) { dmv_x = dmv_y = 0; }                           \

  1271.   else if (index == 35)                                        \

  1272.   {                                                            \

  1273.     dmv_x = get_bits(&v->gb, k_x);                             \

  1274.     dmv_y = get_bits(&v->gb, k_y);                             \

  1275.     mb_is_intra = 1;                                           \

  1276.   }                                                            \

  1277.   else                                                         \

  1278.   {                                                            \

  1279.     index1 = index%6;                                          \

  1280.     if (hpel_flag && index1 == 5) val = 1;                     \

  1281.     else val = 0;                                              \

  1282.     val = get_bits(&v->gb, size_table[index1] - val);          \

  1283.     sign = 0 - (val&1);                                        \

  1284.     dmv_x = (sign ^ ((val>>1) + offset_table[index1])) - sign; \

  1285.                                                                \

  1286.     index1 = index/6;                                          \

  1287.     if (hpel_flag && index1 == 5) val = 1;                     \

  1288.     else val = 0;                                              \

  1289.     val = get_bits(&v->gb, size_table[index1] - val);          \

  1290.     sign = 0 - (val&1);                                        \

  1291.     dmv_y = (sign ^ ((val>>1) + offset_table[index1])) - sign; \

  1292.   }

  1293. 

  1294. static int decode_p_mbs(VC9Context *v)

  1295. {

  1296.     int x, y, current_mb = 0, i; /* MB/Block Position info */

  1297.     int skip_mb_bit = 0, cbpcy; /* MB/B skip */

  1298.     int hybrid_pred, ac_pred; /* Prediction types */

  1299.     int mb_has_coeffs = 1  /* last_flag */, mb_is_intra;

  1300.     int dmv_x, dmv_y; /* Differential MV components */

  1301.     int mv_mode_bit = 0; /* mv_mode_bit: 1MV=0, 4MV=0 */

  1302.     int mqdiff, mquant; /* MB quantization */

  1303.     int tt_block; /* MB Transform type */

  1304.     static const int size_table[6] = { 0, 2, 3, 4, 5, 8 },

  1305.         offset_table[6] = { 0, 1, 3, 7, 15, 31 };

  1306.     int k_x, k_y; /* Long MV fixed bitlength */

  1307.     int hpel_flag, intra_flag; /* Some MB properties */

  1308.     int index, index1; /* LUT indices */

  1309.     int val, sign;

  1310. 

  1311.     /* Select ttmb table depending on pq */

  1312.     if (v->pq < 5) v->ttmb_vlc = &vc9_ttmb_vlc[0];

  1313.     else if (v->pq < 13) v->ttmb_vlc = &vc9_ttmb_vlc[1];

  1314.     else v->ttmb_vlc = &vc9_ttmb_vlc[2];

  1315. 

  1316.     /* Select proper long MV range */

  1317.     switch (v->mvrange)

  1318.     {

  1319.     case 1: k_x = 10; k_y = 9; break;

  1320.     case 2: k_x = 12; k_y = 10; break;

  1321.     case 3: k_x = 13; k_y = 11; break;

  1322.     default: /*case 0 too */ k_x = 9; k_y = 8; break;

  1323.     }

  1324. 

  1325.     hpel_flag = v->mv_mode & 1; //MV_PMODE is HPEL

  1326.     k_x -= hpel_flag;

  1327.     k_y -= hpel_flag;

  1328. 

  1329.     for (y=0; y<v->height_mb; y++)

  1330.     {

  1331.         for (x=0; x<v->width_mb; x++)

  1332.         {

  1333.             if (v->mv_type_mb_plane[current_mb])

  1334.                 mv_mode_bit = get_bits(&v->gb, 1);

  1335.             if (0) //skipmb is rawmode

  1336.                 skip_mb_bit = get_bits(&v->gb, 1);

  1337.             if (!mv_mode_bit) /* 1MV mode */

  1338.             {

  1339.                 if (!v->skip_mb_plane[current_mb])

  1340.                 {

  1341.                     GET_MVDATA();

  1342. 

  1343.                     /* hybrid mv pred, 8.3.5.3.4 */

  1344.                     if (v->mv_mode == MV_PMODE_1MV ||

  1345.                         v->mv_mode == MV_PMODE_MIXED_MV)

  1346.                         hybrid_pred = get_bits(&v->gb, 1);

  1347.                     if (mb_is_intra && !mb_has_coeffs)

  1348.                     {

  1349.                         GET_MQUANT();

  1350.                         ac_pred = get_bits(&v->gb, 1);

  1351.                     }

  1352.                     else if (mb_has_coeffs)

  1353.                     {

  1354.                         if (mb_is_intra) ac_pred = get_bits(&v->gb, 1);

  1355.                         cbpcy = get_vlc2(&v->gb, v->cbpcy_vlc->table,

  1356.                                          VC9_CBPCY_P_VLC_BITS, 2);

  1357.                         GET_MQUANT();

  1358.                     }

  1359.                     if (!v->ttmbf)

  1360.                         v->ttfrm = get_vlc2(&v->gb, v->ttmb_vlc->table,

  1361.                                             VC9_TTMB_VLC_BITS, 12);

  1362.                     //Decode blocks from that mb wrt cbpcy

  1363.                 }

  1364.                 else //Skipped

  1365.                 {

  1366.                     /* hybrid mv pred, 8.3.5.3.4 */

  1367.                     if (v->mv_mode == MV_PMODE_1MV ||

  1368.                         v->mv_mode == MV_PMODE_MIXED_MV)

  1369.                         hybrid_pred = get_bits(&v->gb, 1);

  1370.                 }

  1371.             } //1MV mode

  1372.             else //4MV mode

  1373.             {

  1374.               if (!v->skip_mb_plane[current_mb] /* unskipped MB */)

  1375.                 {

  1376.                     cbpcy = get_vlc2(&v->gb, v->cbpcy_vlc->table,

  1377.                                      VC9_CBPCY_P_VLC_BITS, 2);

  1378.                     for (i=0; i<4; i++) //For all 4 Y blocks

  1379.                     {

  1380.                         if (cbpcy & (1<<6) /* cbpcy set for this block */)

  1381.                         {

  1382.                             GET_MVDATA();

  1383.                         }

  1384.                         if (v->mv_mode == MV_PMODE_MIXED_MV /* Hybrid pred */)

  1385.                             hybrid_pred = get_bits(&v->gb, 1);

  1386.                         GET_MQUANT();

  1387.                         if (mb_is_intra /* One of the 4 blocks is intra */ &&

  1388.                             index /* non-zero pred for that block */)

  1389.                             ac_pred = get_bits(&v->gb, 1);

  1390.                         if (!v->ttmbf)

  1391.                             tt_block = get_vlc2(&v->gb, v->ttmb_vlc->table,

  1392.                                                 VC9_TTMB_VLC_BITS, 12);

  1393.             

  1394.                         /* TODO: Process blocks wrt cbpcy */

  1395.             

  1396.                         /* Prepare cbpcy for next block */

  1397.                         cbpcy <<= 1;

  1398.                     }

  1399.                 }

  1400.                 else //Skipped MB

  1401.                 {

  1402.                     for (i=0; i<4; i++) //All 4 Y blocks

  1403.                     {

  1404.                         if (v->mv_mode == MV_PMODE_MIXED_MV /* Hybrid pred */)

  1405.                             hybrid_pred = get_bits(&v->gb, 1);

  1406.                         

  1407.                         /* FIXME: do something */

  1408.                     }

  1409.                 }

  1410.             }

  1411.         }

  1412.         current_mb++;

  1413.     }

  1414.     return 0;

  1415. }

  1416. 

  1417. static int decode_b_mbs(VC9Context *v)

  1418. {

  1419.     int x, y, current_mb = 0 , last_mb = v->height_mb*v->width_mb,

  1420.         i /* MB / B postion information */;

  1421.     int direct_b_bit = 0, skip_mb_bit = 0;

  1422.     int ac_pred;

  1423.     int b_mv1 = 0, b_mv2 = 0, b_mv_type = 0;

  1424.     int mquant, mqdiff; /* MB quant stuff */

  1425.     int tt_block; /* Block transform type */

  1426.     

  1427.     for (y=0; y<v->height_mb; y++)

  1428.     {

  1429.         for (x=0; x<v->width_mb; x++)

  1430.         {

  1431.             if (v->direct_mb_plane[current_mb])

  1432.               direct_b_bit = get_bits(&v->gb, 1);

  1433.             if (1 /* Skip mode is raw */)

  1434.             {

  1435.                 /* FIXME getting tired commenting */

  1436. #if 0

  1437.                 skip_mb_bit = get_bits(&v->gb, n); //vlc

  1438. #endif

  1439.             }

  1440.             if (!direct_b_bit)

  1441.             {

  1442.                 if (skip_mb_bit)

  1443.                 {

  1444.                     /* FIXME getting tired commenting */

  1445. #if 0

  1446.                     b_mv_type = get_bits(&v->gb, n); //vlc

  1447. #endif

  1448.                 }

  1449.                 else

  1450.                 { 

  1451.                     /* FIXME getting tired commenting */

  1452. #if 0

  1453.                     b_mv1 = get_bits(&v->gb, n); //VLC

  1454. #endif

  1455.                     if (1 /* b_mv1 isn't intra */)

  1456.                     {

  1457.                         /* FIXME: actually read it */

  1458.                         b_mv_type = 0; //vlc

  1459.                     }

  1460.                 }

  1461.             }

  1462.             if (!skip_mb_bit)

  1463.             {

  1464.                 if (b_mv1 != last_mb)

  1465.                 {

  1466.                     GET_MQUANT();

  1467.                     if (1 /* intra mb */)

  1468.                         ac_pred = get_bits(&v->gb, 1);

  1469.                 }

  1470.                 else

  1471.                 {

  1472.                     if (1 /* forward_mb is interpolate */)

  1473.                     {

  1474.                         /* FIXME: actually read it */

  1475.                         b_mv2 = 0; //vlc

  1476.                     }

  1477.                     if (1 /* b_mv2 isn't the last */)

  1478.                     {

  1479.                         if (1 /* intra_mb */)

  1480.                             ac_pred = get_bits(&v->gb, 1);

  1481.                         GET_MQUANT();

  1482.                     }

  1483.                 }

  1484.             }

  1485.             //End1

  1486.             /* FIXME getting tired, commenting */

  1487. #if 0

  1488.             if (v->ttmbf)

  1489.                 v->ttmb = get_bits(&v->gb, n); //vlc

  1490. #endif

  1491.         }

  1492.         //End2

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

  1494.         {

  1495.             /* FIXME: process the block */

  1496.         }

  1497. 

  1498.         current_mb++;

  1499.     }

  1500.     return 0;

  1501. }

  1502. 

  1503. #if HAS_ADVANCED_PROFILE

  1504. static int advanced_decode_i_mbs(VC9Context *v)

  1505. {

  1506.   int i, x, y, cbpcy, mqdiff, absmq, mquant, ac_pred, condover,

  1507.     current_mb = 0, over_flags_mb = 0;

  1508. 

  1509.     for (y=0; y<v->height_mb; y++)

  1510.     {

  1511.         for (x=0; x<v->width_mb; x++)

  1512.         {

  1513.             if (v->ac_pred_plane[i])

  1514.                 ac_pred = get_bits(&v->gb, 1);

  1515.             if (condover == 3 && v->over_flags_plane)

  1516.                 over_flags_mb = get_bits(&v->gb, 1);

  1517.             GET_MQUANT();

  1518.         }

  1519.         current_mb++;

  1520.     }

  1521.     return 0;

  1522. }

  1523. #endif

  1524. 

  1525. static int vc9_decode_init(AVCodecContext *avctx)

  1526. {

  1527.     VC9Context *v = avctx->priv_data;

  1528.     GetBitContext gb;

  1529. 

  1530.     if (!avctx->extradata_size || !avctx->extradata) return -1;

  1531.     avctx->pix_fmt = PIX_FMT_YUV420P;

  1532.     v->avctx = avctx;

  1533. 

  1534.     if (init_common(v) < 0) return -1;

  1535. 

  1536.     if (avctx->codec_id == CODEC_ID_WMV3)

  1537.     {

  1538.         int count = 0;

  1539. 

  1540. 	// looks like WMV3 has a sequence header stored in the extradata

  1541. 	// advanced sequence header may be before the first frame

  1542. 	// the last byte of the extradata is a version number, 1 for the

  1543. 	// samples we can decode

  1544. 

  1545. 	init_get_bits(&gb, avctx->extradata, avctx->extradata_size);

  1546. 	

  1547. 	decode_sequence_header(avctx, &gb);

  1548. 

  1549. 	count = avctx->extradata_size*8 - get_bits_count(&gb);

  1550. 	if (count>0)

  1551. 	{

  1552.     	    av_log(avctx, AV_LOG_INFO, "Extra data: %i bits left, value: %X\n",

  1553.                count, get_bits(&gb, count));

  1554. 	}

  1555. 	else

  1556. 	{

  1557.     	    av_log(avctx, AV_LOG_INFO, "Read %i bits in overflow\n", -count);

  1558. 	}

  1559.     }

  1560. 

  1561.     /* Done with header parsing */

  1562.     //FIXME I feel like this is wrong

  1563.     v->width_mb = (avctx->coded_width+15)>>4;

  1564.     v->height_mb = (avctx->coded_height+15)>>4;

  1565. 

  1566.     /* Allocate mb bitplanes */

  1567.     v->mv_type_mb_plane = (uint8_t *)av_malloc(v->width_mb*v->height_mb);

  1568.     if (!v->mv_type_mb_plane) return -1;

  1569.     v->skip_mb_plane = (uint8_t *)av_malloc(v->width_mb*v->height_mb);

  1570.     if (!v->skip_mb_plane) return -1;

  1571.     v->direct_mb_plane = (uint8_t *)av_malloc(v->width_mb*v->height_mb);

  1572.     if (!v->direct_mb_plane) return -1;

  1573. 

  1574. #if HAS_ADVANCED_PROFILE

  1575.     if (v->profile > PROFILE_MAIN)

  1576.     {

  1577.         v->over_flags_plane = (uint8_t *)av_malloc(v->width_mb*v->height_mb);

  1578.         if (!v->over_flags_plane) return -1;

  1579.         v->ac_pred_plane = (uint8_t *)av_malloc(v->width_mb*v->height_mb);

  1580.         if (!v->ac_pred_plane) return -1;

  1581.     }

  1582. #endif

  1583. 

  1584.     return 0;

  1585. }

  1586. 

  1587. static int vc9_decode_frame(AVCodecContext *avctx,

  1588.                             void *data, int *data_size,

  1589.                             uint8_t *buf, int buf_size)

  1590. {

  1591.     VC9Context *v = avctx->priv_data;

  1592.     int ret = FRAME_SKIPED, len, start_code;

  1593.     AVFrame *pict = data;

  1594.     uint8_t *tmp_buf;

  1595.     v->avctx = avctx;

  1596. 

  1597.     //buf_size = 0 -> last frame

  1598.     if (!buf_size) return 0;

  1599. 

  1600.     len = avpicture_get_size(avctx->pix_fmt, avctx->width,

  1601.                              avctx->height);

  1602.     tmp_buf = (uint8_t *)av_mallocz(len);

  1603.     avpicture_fill((AVPicture *)pict, tmp_buf, avctx->pix_fmt,

  1604.                    avctx->width, avctx->height);

  1605. 

  1606.     if (avctx->codec_id == CODEC_ID_WMV3)

  1607.     {

  1608. 	init_get_bits(&v->gb, buf, buf_size*8);

  1609. 	av_log(avctx, AV_LOG_INFO, "Frame: %i bits to decode\n", buf_size*8);

  1610.         

  1611. #if HAS_ADVANCED_PROFILE

  1612. 	if (v->profile > PROFILE_MAIN)

  1613. 	{

  1614.     	    if (advanced_decode_picture_header(v) == FRAME_SKIPED) return buf_size;

  1615.     	    switch(v->pict_type)

  1616.     	    {

  1617.     		case I_TYPE: ret = advanced_decode_i_mbs(v); break;

  1618. 	        case P_TYPE: ret = decode_p_mbs(v); break;

  1619.     		case B_TYPE:

  1620.     		case BI_TYPE: ret = decode_b_mbs(v); break;

  1621.     		default: ret = FRAME_SKIPED;

  1622.     	    }

  1623.     	    if (ret == FRAME_SKIPED) return buf_size; //We ignore for now failures

  1624. 	}

  1625. 	else

  1626. #endif

  1627. 	{

  1628.     	    if (standard_decode_picture_header(v) == FRAME_SKIPED) return buf_size;

  1629.     	    switch(v->pict_type)

  1630. 	    {

  1631.     		case I_TYPE: ret = standard_decode_i_mbs(v); break;

  1632.     		case P_TYPE: ret = decode_p_mbs(v); break;

  1633.     		case B_TYPE:

  1634.     		case BI_TYPE: ret = decode_b_mbs(v); break;

  1635.     		default: ret = FRAME_SKIPED;

  1636.     	    }

  1637.     	    if (ret == FRAME_SKIPED) return buf_size;

  1638. 	}

  1639. 

  1640. 	/* Size of the output data = image */

  1641. 	av_log(avctx, AV_LOG_DEBUG, "Consumed %i/%i bits\n",

  1642.            get_bits_count(&v->gb), buf_size*8);

  1643.     }

  1644.     else

  1645.     {

  1646. #if 0

  1647. 	// search for IDU's

  1648. 	// FIXME

  1649. 	uint32_t scp = 0;

  1650. 	int scs = 0, i = 0;

  1651. 

  1652. 	while (i < buf_size)

  1653. 	{

  1654. 	    for (; i < buf_size && scp != 0x000001; i++)

  1655. 		scp = ((scp<<8)|buf[i])&0xffffff;

  1656. 

  1657. 	    if (scp != 0x000001)

  1658. 		break; // eof ?

  1659. 	

  1660. 	    scs = buf[i++];	

  1661. 

  1662. 	    init_get_bits(&v->gb, buf+i, (buf_size-i)*8);

  1663. 	

  1664. 	    switch(scs)

  1665. 	    {

  1666. 		case 0xf:

  1667. 		    decode_sequence_header(avctx, &v->gb);

  1668. 		    break;

  1669. 		// to be finished

  1670. 	    }

  1671. 	    

  1672. 	    i += get_bits_count(&v->gb)*8;

  1673. 	}

  1674. #else

  1675. 	av_abort();

  1676. #endif

  1677.     }

  1678. 

  1679.     *data_size = len;

  1680. 

  1681.     /* Fake consumption of all data */

  1682.     return buf_size; //Number of bytes consumed

  1683. }

  1684. 

  1685. static int vc9_decode_end(AVCodecContext *avctx)

  1686. {

  1687.     VC9Context *v = avctx->priv_data;

  1688. 

  1689. #if HAS_ADVANCED_PROFILE

  1690.     if (v->hrd_rate) av_free(v->hrd_rate);

  1691.     if (v->hrd_buffer) av_free(v->hrd_buffer);

  1692. #endif

  1693.     if (v->mv_type_mb_plane) av_free(v->mv_type_mb_plane);

  1694.     if (v->skip_mb_plane) av_free(v->skip_mb_plane);

  1695.     if (v->direct_mb_plane) av_free(v->direct_mb_plane);

  1696.     return 0;

  1697. }

  1698. 

  1699. AVCodec vc9_decoder = {

  1700.     "vc9",

  1701.     CODEC_TYPE_VIDEO,

  1702.     CODEC_ID_VC9,

  1703.     sizeof(VC9Context),

  1704.     vc9_decode_init,

  1705.     NULL,

  1706.     vc9_decode_end,

  1707.     vc9_decode_frame,

  1708.     CODEC_CAP_DELAY,

  1709.     NULL

  1710. };

  1711. 

  1712. AVCodec wmv3_decoder = {

  1713.     "wmv3",

  1714.     CODEC_TYPE_VIDEO,

  1715.     CODEC_ID_WMV3,

  1716.     sizeof(VC9Context),

  1717.     vc9_decode_init,

  1718.     NULL,

  1719.     vc9_decode_end,

  1720.     vc9_decode_frame,

  1721.     CODEC_CAP_DELAY,

  1722.     NULL

  1723. };