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

2004 lines
64KB
Raw Blame History 

  1. /*

  2.  * VC-9 and WMV3 decoder

  3.  * Copyright (c) 2005 Anonymous

  4.  * Copyright (c) 2005 Alex Beregszaszi

  5.  * Copyright (c) 2005 Michael Niedermayer

  6.  *

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

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

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

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

  11.  *

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

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

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

  15.  * Lesser General Public License for more details.

  16.  *

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

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

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

  20.  *

  21.  */

  22. 

  23. /**

  24.  * @file vc9.c

  25.  * VC-9 and WMV3 decoder

  26.  *

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

  28.  * TODO: use MPV_ !!

  29.  * TODO: export decode012 in bitstream.h ?

  30.  */

  31. #include "common.h"

  32. #include "dsputil.h"

  33. #include "avcodec.h"

  34. #include "mpegvideo.h"

  35. #include "vc9data.h"

  36. 

  37. /* Some inhibiting stuff */

  38. #define HAS_ADVANCED_PROFILE   1

  39. #define TRACE                  1

  40. 

  41. #if TRACE

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

  43.                    codes, codes_wrap, codes_size, use_static)          \

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

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

  46.   {                                                                    \

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

  48.     return -1;                                                         \

  49.   }

  50. #else

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

  52.                    codes, codes_wrap, codes_size, use_static)          \

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

  54.            codes, codes_wrap, codes_size, use_static)

  55. #endif

  56. 

  57. #define PROFILE_SIMPLE   0

  58. #define PROFILE_MAIN     1

  59. #define PROFILE_ADVANCED 3

  60. 

  61. #define QUANT_FRAME_IMPLICIT   0

  62. #define QUANT_FRAME_EXPLICIT   1

  63. #define QUANT_NON_UNIFORM      2

  64. #define QUANT_UNIFORM          3

  65. 

  66. /* Where quant can be changed */

  67. #define DQPROFILE_FOUR_EDGES   0

  68. #define DQPROFILE_DOUBLE_EDGES 1

  69. #define DQPROFILE_SINGLE_EDGE  2

  70. #define DQPROFILE_ALL_MBS      3

  71. 

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

  73. #define DQSINGLE_BEDGE_LEFT   0

  74. #define DQSINGLE_BEDGE_TOP    1

  75. #define DQSINGLE_BEDGE_RIGHT  2

  76. #define DQSINGLE_BEDGE_BOTTOM 3

  77. 

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

  79. #define DQDOUBLE_BEDGE_TOPLEFT     0

  80. #define DQDOUBLE_BEDGE_TOPRIGHT    1

  81. #define DQDOUBLE_BEDGE_BOTTOMRIGHT 2

  82. #define DQDOUBLE_BEDGE_BOTTOMLEFT  3

  83. 

  84. /* MV P modes */

  85. #define MV_PMODE_1MV_HPEL_BILIN   0

  86. #define MV_PMODE_1MV              1

  87. #define MV_PMODE_1MV_HPEL         2

  88. #define MV_PMODE_MIXED_MV         3

  89. #define MV_PMODE_INTENSITY_COMP   4

  90. 

  91. #define BMV_TYPE_BACKWARD          0

  92. #define BMV_TYPE_FORWARD           1

  93. #define BMV_TYPE_INTERPOLATED      3

  94. 

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

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

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

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

  99. };

  100. 

  101. /* One more frame type */

  102. #define BI_TYPE 7

  103. 

  104. /* FIXME Worse than ugly */

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

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

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

  108.   {  /* Implicit quantizer */

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

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

  111.   },

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

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

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

  115.   },

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

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

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

  119.   }

  120. };

  121. 

  122. // FIXME move this into the context

  123. #define VC9_BFRACTION_VLC_BITS 7

  124. static VLC vc9_bfraction_vlc;

  125. #define VC9_IMODE_VLC_BITS 4

  126. static VLC vc9_imode_vlc;

  127. #define VC9_NORM2_VLC_BITS 3

  128. static VLC vc9_norm2_vlc;

  129. #define VC9_NORM6_VLC_BITS 9

  130. static VLC vc9_norm6_vlc;

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

  132. #define VC9_TTMB_VLC_BITS 9 //12

  133. static VLC vc9_ttmb_vlc[3];

  134. #define VC9_MV_DIFF_VLC_BITS 9 //15

  135. static VLC vc9_mv_diff_vlc[4];

  136. #define VC9_CBPCY_I_VLC_BITS 9 //13

  137. static VLC vc9_cbpcy_i_vlc;

  138. #define VC9_CBPCY_P_VLC_BITS 9 //14

  139. static VLC vc9_cbpcy_p_vlc[4];

  140. #define VC9_4MV_BLOCK_PATTERN_VLC_BITS 6

  141. static VLC vc9_4mv_block_pattern_vlc[4];

  142. #define VC9_LUMA_DC_VLC_BITS 9

  143. static VLC vc9_luma_dc_vlc[2];

  144. #define VC9_CHROMA_DC_VLC_BITS 9

  145. static VLC vc9_chroma_dc_vlc[2];

  146. 

  147. //We mainly need data and is_raw, so this struct could be avoided

  148. //to save a level of indirection; feel free to modify

  149. typedef struct BitPlane {

  150.     uint8_t *data;

  151.     int width, stride;

  152.     int height;

  153.     uint8_t is_raw;

  154. } BitPlane;

  155. 

  156. typedef struct VC9Context{

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

  158.   GetBitContext gb;

  159.   AVCodecContext *avctx;

  160. 

  161.   /***************************/

  162.   /* Sequence Header         */

  163.   /***************************/

  164.   /* Simple/Main Profile */

  165.   int res_sm; //reserved, 2b

  166.   int res_x8; //reserved

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

  168.   int res_fasttx; //always 1

  169.   int res_transtab; //always 0

  170.   int syncmarker; //Sync markers presents

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

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

  173.   int reserved; //duh

  174. 

  175. #if HAS_ADVANCED_PROFILE

  176.   /* Advanced Profile */

  177.   int level; //3

  178.   int chromaformat; //2

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

  180.   int broadcast; //TFF/RFF present

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

  182.   int tfcntrflag; //TFCNTR present

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

  184.     int extended_dmv;

  185.   int color_prim; //8

  186.   int transfer_char; //8

  187.   int matrix_coef; //8

  188.   int hrd_param_flag;

  189. #endif

  190. 

  191.   /* All Profiles */

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

  193.   int profile; //2

  194.   int frmrtq_postproc; //3

  195.   int bitrtq_postproc; //5

  196.     int loopfilter;

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

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

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

  200.   int vstransform; //variable-size transform46

  201. 

  202.   int overlap; //overlapped transforms in use

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

  204.   int finterpflag; //INTERPFRM present

  205. 

  206. 

  207.   /*****************************/

  208.   /* Frame decoding            */

  209.   /*****************************/

  210.   /* All profiles */

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

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

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

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

  215.   int width_mb, height_mb;

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

  217.   VLC *luma_ac_vlc, *chroma_ac_vlc,

  218.     *luma_dc_vlc, *chroma_dc_vlc; /* transac/dcfrm bits are indexes */

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

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

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

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

  223.   uint8_t respic;

  224.   /* Ranges:

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

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

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

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

  229.    */

  230.   uint8_t mvrange;

  231.   uint8_t pquantizer;

  232.   uint8_t *previous_line_cbpcy; /* To use for predicted CBPCY */

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

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

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

  236.   BitPlane mv_type_mb_plane; /* bitplane for mv_type == (4MV) */

  237.   BitPlane skip_mb_plane, /* bitplane for skipped MBs */

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

  239. 

  240.   /* S/M only ? */

  241.   uint8_t rangeredfrm; /* out_sample = CLIP((in_sample-128)*2+128) */

  242.   uint8_t interpfrm;

  243. 

  244. #if HAS_ADVANCED_PROFILE

  245.   /* Advanced */

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

  247.   uint8_t numpanscanwin;

  248.   uint8_t tfcntr;

  249.   uint8_t rptfrm, tff, rff;

  250.   uint8_t topleftx;

  251.   uint8_t toplefty;

  252.   uint8_t bottomrightx;

  253.   uint8_t bottomrighty;

  254.   uint8_t rndctrl;

  255.   uint8_t uvsamp;

  256.   uint8_t postproc;

  257.   int hrd_num_leaky_buckets;

  258.   uint8_t bit_rate_exponent;

  259.   uint8_t buffer_size_exponent;

  260.   BitPlane ac_pred_plane; //AC prediction flags bitplane

  261.   BitPlane over_flags_plane; //Overflags bitplane

  262.   uint8_t condover;

  263.   uint16_t *hrd_rate, *hrd_buffer;

  264.   VLC *luma_ac2_vlc, *chroma_ac2_vlc;

  265. #endif

  266. } VC9Context;

  267. 

  268. /* FIXME Slow and ugly */

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

  270. {

  271. #if 1

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

  273. 

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

  275.   {

  276.     tmp = get_bits(gb, 1);

  277.     i++;

  278.   }

  279.   return i;

  280. #else

  281.   unsigned int buf;

  282.   int log;

  283. 

  284.   OPEN_READER(re, gb);

  285.   UPDATE_CACHE(re, gb);

  286.   buf=GET_CACHE(re, gb); //Still not sure

  287.   if (stop) buf = ~buf;

  288.   

  289.   log= av_log2(-buf); //FIXME: -?

  290.   if (log < limit){

  291.     LAST_SKIP_BITS(re, gb, log+1);

  292.     CLOSE_READER(re, gb);

  293.     return log;

  294.   }

  295.   

  296.   LAST_SKIP_BITS(re, gb, limit);

  297.   CLOSE_READER(re, gb);

  298.   return limit;

  299. #endif

  300. }

  301. 

  302. static int init_common(VC9Context *v)

  303. {

  304.     static int done = 0;

  305.     int i;

  306. 

  307.     /* Set the bit planes */

  308.     /* FIXME memset better ? (16bytes) */

  309.     v->mv_type_mb_plane = (struct BitPlane) { NULL, 0, 0, 0 };

  310.     v->direct_mb_plane = (struct BitPlane) { NULL, 0, 0, 0 };

  311.     v->skip_mb_plane = (struct BitPlane) { NULL, 0, 0, 0 };

  312. #if HAS_ADVANCED_PROFILE

  313.     v->ac_pred_plane = v->over_flags_plane = (struct BitPlane) { NULL, 0, 0, 0 };

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

  315. #endif

  316. 

  317.     /* VLC tables */

  318. #if 0 // spec -> actual tables converter

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

  320.         int code= (vc9_norm6_spec[i][1] << vc9_norm6_spec[i][4]) + vc9_norm6_spec[i][3];

  321.         av_log(NULL, AV_LOG_DEBUG, "0x%03X, ", code);

  322.         if(i%16==15) av_log(NULL, AV_LOG_DEBUG, "\n");

  323.     }

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

  325.         int code= vc9_norm6_spec[i][2] + vc9_norm6_spec[i][4];

  326.         av_log(NULL, AV_LOG_DEBUG, "%2d, ", code);

  327.         if(i%16==15) av_log(NULL, AV_LOG_DEBUG, "\n");

  328.     }

  329. #endif

  330.     if(!done)

  331.     {

  332.         done = 1;

  333.         INIT_VLC(&vc9_bfraction_vlc, VC9_BFRACTION_VLC_BITS, 23,

  334.                  vc9_bfraction_bits, 1, 1,

  335.                  vc9_bfraction_codes, 1, 1, 1);

  336.         INIT_VLC(&vc9_norm2_vlc, VC9_NORM2_VLC_BITS, 4,

  337.                  vc9_norm2_bits, 1, 1,

  338.                  vc9_norm2_codes, 1, 1, 1);

  339.         INIT_VLC(&vc9_norm6_vlc, VC9_NORM6_VLC_BITS, 64,

  340.                  vc9_norm6_bits, 1, 1,

  341.                  vc9_norm6_codes, 2, 2, 1);

  342.         INIT_VLC(&vc9_cbpcy_i_vlc, VC9_CBPCY_I_VLC_BITS, 64,

  343.                  vc9_cbpcy_i_bits, 1, 1,

  344.                  vc9_cbpcy_i_codes, 2, 2, 1);

  345.         INIT_VLC(&vc9_imode_vlc, VC9_IMODE_VLC_BITS, 7,

  346.                  vc9_imode_bits, 1, 1,

  347.                  vc9_imode_codes, 1, 1, 1);

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

  349.         {

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

  351.                      vc9_luma_dc_bits[i], 1, 1,

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

  353.             INIT_VLC(&vc9_chroma_dc_vlc[i], VC9_CHROMA_DC_VLC_BITS, 26,

  354.                      vc9_chroma_dc_bits[i], 1, 1,

  355.                      vc9_chroma_dc_codes[i], 4, 4, 1);

  356.         }

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

  358.         {

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

  360.                      vc9_ttmb_bits[i], 1, 1,

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

  362.         }

  363.         for(i=0; i<4; i++)

  364.         {

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

  366.                      vc9_4mv_block_pattern_bits[i], 1, 1,

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

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

  369.                      vc9_cbpcy_p_bits[i], 1, 1,

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

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

  372.                      vc9_mv_diff_bits[i], 1, 1,

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

  374.         }

  375.     }

  376. 

  377.     /* Other defaults */

  378.     v->pq = -1;

  379.     v->mvrange = 0; /* 7.1.1.18, p80 */

  380. 

  381.     return 0;

  382. }

  383. 

  384. #if HAS_ADVANCED_PROFILE

  385. /* 6.2.1, p32 */

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

  387. {

  388.     int i, num;

  389. 

  390.     num = get_bits(gb, 5);

  391. 

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

  393.     {

  394.         av_freep(&v->hrd_rate);

  395.     }

  396.     if (!v->hrd_rate) v->hrd_rate = av_malloc(num*sizeof(uint16_t));

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

  398. 

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

  400.     {

  401.         av_freep(&v->hrd_buffer);

  402.     }

  403.     if (!v->hrd_buffer) v->hrd_buffer = av_malloc(num*sizeof(uint16_t));

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

  405. 

  406.     v->hrd_num_leaky_buckets = num;

  407. 

  408.     //exponent in base-2 for rate

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

  410.     //exponent in base-2 for buffer_size

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

  412. 

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

  414.     {

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

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

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

  418.         {

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

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

  421.             return -1;

  422.         }

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

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

  425.         {

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

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

  428.             return -1;

  429.         }

  430.     }

  431.     return 0;

  432. }

  433. 

  434. /* Table 2, p18 */

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

  436. {

  437.     VC9Context *v = avctx->priv_data;

  438.     int nr, dr, aspect_ratio;

  439. 

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

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

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

  443. 

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

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

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

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

  448.     if (v->reserved)

  449.     {

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

  451.                v->reserved);

  452.         return -1;

  453.     }

  454.     if (v->extended_mv)

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

  456. 

  457.     /* 6.1.7, p21 */

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

  459.     {

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

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

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

  463.         {

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

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

  466.         }

  467. 

  468.         /* 6.1.7.4, p22 */

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

  470.         {

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

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

  473.             {

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

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

  476.             }

  477.             else if (aspect_ratio == 0x0E)

  478.             {

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

  480.             }

  481.             else

  482.             {

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

  484.             }

  485.         }

  486.     }

  487.     else

  488.     {

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

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

  491.     }

  492. 

  493.     /* 6.1.8, p23 */

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

  495.     {

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

  497.         {

  498.             nr = get_bits(gb, 8);

  499.             dr = get_bits(gb, 4);

  500.             if (nr<1)

  501.             {

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

  503.                 return -1;

  504.             }

  505.             if (nr>5)

  506.             {

  507.                 av_log(avctx, AV_LOG_ERROR,

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

  509.            }

  510.             if (dr<1)

  511.             {

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

  513.            }

  514.             if (dr>2)

  515.             {

  516.                 av_log(avctx, AV_LOG_ERROR,

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

  518.             }

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

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

  521.         }

  522.         else

  523.         {

  524.             nr = get_bits(gb, 16);

  525.             // 0.03125->2048Hz / 0.03125Hz

  526.             avctx->frame_rate = 1000000;

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

  528.         }

  529.     }

  530. 

  531.     /* 6.1.9, p25 */

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

  533.     {

  534.         //Chromacity coordinates of color primaries

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

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

  537.         if (v->color_prim<1)

  538.         {

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

  540.             return -1;

  541.         }

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

  543.         {

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

  545.                    v->color_prim);

  546.             return -1;

  547.         }

  548. 

  549.         //Opto-electronic transfer characteristics

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

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

  552.         {

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

  554.                    v->color_prim);

  555.             return -1;

  556.         }

  557. 

  558.         //Matrix coefficient for primariev->YCbCr

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

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

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

  562.         {

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

  564.                    v->color_prim);

  565.             return -1;

  566.         }

  567.     }

  568. 

  569.     //Hypothetical reference decoder indicator flag

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

  571.     if (v->hrd_param_flag)

  572.     {

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

  574.     }

  575. 

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

  577.     return -1;

  578. }

  579. #endif

  580. 

  581. /* Figure 7-8, p16-17 */

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

  583. {

  584.     VC9Context *v = avctx->priv_data;

  585. 

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

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

  588. 

  589. #if HAS_ADVANCED_PROFILE

  590.     if (v->profile > PROFILE_MAIN)

  591.     {

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

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

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

  595.         {

  596.             av_log(avctx, AV_LOG_ERROR,

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

  598.             return -1;

  599.         }

  600.     }

  601.     else

  602. #endif

  603.     {

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

  605.         if (v->res_sm)

  606.         {

  607.             av_log(avctx, AV_LOG_ERROR,

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

  609.             //return -1;

  610.         }

  611.     }

  612. 

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

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

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

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

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

  618. 

  619. #if HAS_ADVANCED_PROFILE

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

  621. #endif

  622.     {

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

  624.         if (v->res_x8)

  625.         {

  626.             av_log(avctx, AV_LOG_ERROR,

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

  628.             return -1;

  629.         }

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

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

  632.         if (!v->res_fasttx)

  633.         {

  634.             av_log(avctx, AV_LOG_ERROR,

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

  636.             //return -1;

  637.         }

  638.     }

  639. 

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

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

  642.     {

  643.         av_log(avctx, AV_LOG_ERROR,

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

  645.         return -1;

  646.     }

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

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

  649.     {

  650.         av_log(avctx, AV_LOG_ERROR,

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

  652.         return -1;

  653.     }

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

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

  656.     

  657. #if HAS_ADVANCED_PROFILE

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

  659. #endif

  660.     {

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

  662.         if (v->res_transtab)

  663.         {

  664.             av_log(avctx, AV_LOG_ERROR,

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

  666.             return -1;

  667.         }

  668.     }

  669. 

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

  671. 

  672. #if HAS_ADVANCED_PROFILE

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

  674. #endif

  675.     {

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

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

  678.     }

  679. 

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

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

  682. 

  683. #if HAS_ADVANCED_PROFILE

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

  685. #endif

  686.     {

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

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

  689.         if (!v->res_rtm_flag)

  690.         {

  691.             av_log(avctx, AV_LOG_ERROR,

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

  693.             //return -1;

  694.         }

  695. #if TRACE

  696.         av_log(avctx, AV_LOG_INFO,

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

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

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

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

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

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

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

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

  705.                );

  706.         return 0;

  707. #endif

  708.     }

  709. #if HAS_ADVANCED_PROFILE

  710.     else return decode_advanced_sequence_header(avctx, gb);

  711. #endif

  712. }

  713. 

  714. 

  715. #if HAS_ADVANCED_PROFILE

  716. /*****************************************************************************/

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

  718. /*****************************************************************************/

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

  720. {

  721.     VC9Context *v = avctx->priv_data;

  722.     int range_mapy_flag, range_mapuv_flag, i;

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

  724.     {

  725.         av_log(avctx, AV_LOG_ERROR,

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

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

  728.     }

  729.     if (v->hrd_param_flag)

  730.     {

  731.         //Update buffer fullness

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

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

  734.             skip_bits(gb, 8);

  735.     }

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

  737.     {

  738.         //RANGE_MAPY

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

  740.         skip_bits(gb, 3);

  741.     }

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

  743.     {

  744.         //RANGE_MAPUV

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

  746.         skip_bits(gb, 3);

  747.     }

  748.     if (v->panscanflag)

  749.     {

  750.         //NUMPANSCANWIN

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

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

  753.     }

  754.     return 0;

  755. }

  756. #endif

  757. 

  758. /******************************************************************************/

  759. /* Bitplane decoding: 8.7, p56                                                */

  760. /******************************************************************************/

  761. #define IMODE_RAW     0

  762. #define IMODE_NORM2   1

  763. #define IMODE_DIFF2   2

  764. #define IMODE_NORM6   3

  765. #define IMODE_DIFF6   4

  766. #define IMODE_ROWSKIP 5

  767. #define IMODE_COLSKIP 6

  768. int alloc_bitplane(BitPlane *bp, int width, int height)

  769. {

  770.     if (!bp || bp->width<0 || bp->height<0) return -1;

  771.     bp->data = (uint8_t*)av_malloc(width*height);

  772.     if (!bp->data) return -1;

  773.     bp->width = bp->stride = width; //FIXME Needed for aligned data ?

  774.     bp->height = height;

  775.     return 0;

  776. }

  777. 

  778. static void decode_rowskip(uint8_t* plane, int width, int height, int stride, VC9Context *v){

  779.     int x, y;

  780. 

  781.     for (y=0; y<height; y++){

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

  783.             memset(plane, 0, width);

  784.         else

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

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

  787.         plane += stride;

  788.     }

  789. }

  790. 

  791. //FIXME optimize

  792. static void decode_colskip(uint8_t* plane, int width, int height, int stride, VC9Context *v){

  793.     int x, y;

  794. 

  795.     for (x=0; x<width; x++){

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

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

  798.                 plane[y*stride] = 0;

  799.         else

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

  801.                 plane[y*stride] = get_bits(&v->gb, 1);

  802.         plane ++;

  803.     }

  804. }

  805. 

  806. //FIXME optimize

  807. //FIXME is this supposed to set elements to 0/FF or 0/1? 0/x!=0, not used for

  808. //      prediction

  809. //FIXME Use BitPlane struct or return if table is raw (no bits read here but

  810. //      later on)

  811. static int bitplane_decoding(BitPlane *bp, VC9Context *v)

  812. {

  813.     int imode, x, y, code, use_vertical_tile, tile_w, tile_h;

  814.     uint8_t invert, *planep = bp->data;

  815. 

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

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

  818. 

  819.     bp->is_raw = 0;

  820.     switch (imode)

  821.     {

  822.     case IMODE_RAW:

  823.         //Data is actually read in the MB layer (same for all tests == "raw")

  824.         bp->is_raw = 1; //invert ignored

  825.         return invert;

  826.     case IMODE_DIFF2:

  827.     case IMODE_NORM2:

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

  829.         for(x=0; x<(bp->height*bp->width)>>1; x++){

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

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

  832.             *(++planep) = code&2; //msb => right - bitplane => only !0 matters

  833.             //FIXME width->stride

  834.         }

  835.         break;

  836.     case IMODE_DIFF6:

  837.     case IMODE_NORM6:

  838.         use_vertical_tile=  bp->height%3==0 &&  bp->width%3!=0;

  839.         tile_w= use_vertical_tile ? 2 : 3;

  840.         tile_h= use_vertical_tile ? 3 : 2;

  841. 

  842.         for(y=  bp->height%tile_h; y< bp->height; y+=tile_h){

  843.             for(x=  bp->width%tile_w; x< bp->width; x+=tile_w){

  844.                 code = get_vlc2(&v->gb, vc9_norm6_vlc.table, VC9_NORM6_VLC_BITS, 2);

  845.                 if(code<0){

  846.                     av_log(v->avctx, AV_LOG_DEBUG, "inavlid NORM-6 VLC\n");

  847.                     return -1;

  848.                 }

  849.                 //FIXME following is a pure guess and probably wrong

  850.                 //FIXME A bitplane (0 | !0), so could the shifts be avoided ?

  851.                 planep[x     + 0*bp->stride]= (code>>0)&1;

  852.                 planep[x + 1 + 0*bp->stride]= (code>>1)&1;

  853.                 if(use_vertical_tile){

  854.                     planep[x + 0 + 1*bp->stride]= (code>>2)&1;

  855.                     planep[x + 1 + 1*bp->stride]= (code>>3)&1;

  856.                     planep[x + 0 + 2*bp->stride]= (code>>4)&1;

  857.                     planep[x + 1 + 2*bp->stride]= (code>>5)&1;

  858.                 }else{

  859.                     planep[x + 2 + 0*bp->stride]= (code>>2)&1;

  860.                     planep[x + 0 + 1*bp->stride]= (code>>3)&1;

  861.                     planep[x + 1 + 1*bp->stride]= (code>>4)&1;

  862.                     planep[x + 2 + 1*bp->stride]= (code>>5)&1;

  863.                 }

  864.             }

  865.         }

  866. 

  867.         x=  bp->width % tile_w;

  868.         decode_colskip(bp->data  ,             x, bp->height         , bp->stride, v);

  869.         decode_rowskip(bp->data+x, bp->width - x, bp->height % tile_h, bp->stride, v);

  870. 

  871.         break;

  872.     case IMODE_ROWSKIP:

  873.         decode_rowskip(bp->data, bp->width, bp->height, bp->stride, v);

  874.         break;

  875.     case IMODE_COLSKIP: //Teh ugly

  876.         decode_colskip(bp->data, bp->width, bp->height, bp->stride, v);

  877.         break;

  878.     default: break;

  879.     }

  880. 

  881.     /* Applying diff operator */

  882.     if (imode == IMODE_DIFF2 || imode == IMODE_DIFF6)

  883.     {

  884.         planep = bp->data;

  885.         planep[0] ^= invert;

  886.         for (x=1; x<bp->width; x++)

  887.             planep[x] ^= planep[x-1];

  888.         for (y=1; y<bp->height; y++)

  889.         {

  890.             planep += bp->stride;

  891.             planep[0] ^= planep[-bp->stride];

  892.             for (x=1; x<bp->width; x++)

  893.             {

  894.                 if (planep[x-1] != planep[x-bp->stride]) planep[x] ^= invert;

  895.                 else                                     planep[x] ^= planep[x-1];

  896.             }

  897.         }

  898.     }

  899.     else if (invert)

  900.     {

  901.         planep = bp->data;

  902.         for (x=0; x<bp->width*bp->height; x++) planep[x] = !planep[x]; //FIXME stride

  903.     }

  904.     return (imode<<1) + invert;

  905. }

  906. 

  907. /*****************************************************************************/

  908. /* VOP Dquant decoding                                                       */

  909. /*****************************************************************************/

  910. static int vop_dquant_decoding(VC9Context *v)

  911. {

  912.     int pqdiff;

  913. 

  914.     //variable size

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

  916.     {

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

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

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

  920.     }

  921.     else

  922.     {

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

  924.         if ( v->dquantfrm )

  925.         {

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

  927.             switch (v->dqprofile)

  928.             {

  929.             case DQPROFILE_SINGLE_EDGE:

  930.             case DQPROFILE_DOUBLE_EDGES:

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

  932.                 break;

  933.             case DQPROFILE_ALL_MBS:

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

  935.             default: break; //Forbidden ?

  936.             }

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

  938.             {

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

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

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

  942.             }

  943.         }

  944.     }

  945.     return 0;

  946. }

  947. 

  948. /*****************************************************************************/

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

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

  951. /*****************************************************************************/

  952. static int decode_bi_picture_header(VC9Context *v)

  953. {

  954.     /* Very particular case:

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

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

  957.          this function afterwards

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

  959.          directly there

  960.     */

  961.     int pqindex;

  962. 

  963.     /* Read the quantization stuff */

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

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

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

  967.     else

  968.     {

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

  970.     }

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

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

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

  974. 

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

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

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

  978. 

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

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

  981.     v->cbpcy_vlc = &vc9_cbpcy_i_vlc;

  982. 

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

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

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

  986.     return -1;

  987. }

  988. 

  989. /* Tables 11+12, p62-65 */

  990. static int decode_b_picture_header(VC9Context *v)

  991. {

  992.   int pqindex, status;

  993. 

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

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

  996.     {

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

  998.         return FRAME_SKIPED;

  999.     }

  1000. 

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

  1002.                                               VC9_BFRACTION_VLC_BITS, 2)];

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

  1004.     {

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

  1006.         return FRAME_SKIPED;

  1007.     }

  1008.     else if (!v->bfraction)

  1009.     {

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

  1011.         return decode_bi_picture_header(v);

  1012.     }

  1013. 

  1014.     /* Read the quantization stuff */

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

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

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

  1018.     else

  1019.     {

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

  1021.     }

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

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

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

  1025. 

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

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

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

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

  1030.     if (v->pq < 13)

  1031.     {

  1032.         if (!v->mv_mode)

  1033.         {

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

  1035.             if (v->mv_mode)

  1036.                 av_log(v, AV_LOG_ERROR,

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

  1038.         }

  1039.     }

  1040.     else

  1041.     {

  1042.         if (!v->mv_mode)

  1043.         {

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

  1045.                 av_log(v, AV_LOG_ERROR,

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

  1047.         }

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

  1049.     }

  1050. 

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

  1052.     {

  1053.         status = bitplane_decoding(&v->mv_type_mb_plane, v);

  1054.         if (status < 0)

  1055.             return -1;

  1056. #if TRACE

  1057.         av_log(v->avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "

  1058.                "Imode: %i, Invert: %i\n", status>>1, status&1);

  1059. #endif

  1060.     }

  1061. 

  1062.     //bitplane

  1063.     status = bitplane_decoding(&v->direct_mb_plane, v);

  1064.     if (status < 0) return -1;

  1065. #if TRACE

  1066.     av_log(v->avctx, AV_LOG_DEBUG, "MB Direct plane encoding: "

  1067.            "Imode: %i, Invert: %i\n", status>>1, status&1);

  1068. #endif

  1069. 

  1070.     bitplane_decoding(&v->skip_mb_plane, v);

  1071.     if (status < 0) return -1;

  1072. #if TRACE

  1073.     av_log(v->avctx, AV_LOG_DEBUG, "Skip MB plane encoding: "

  1074.            "Imode: %i, Invert: %i\n", status>>1, status&1);

  1075. #endif

  1076. 

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

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

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

  1080.     if (v->dquant)

  1081.     {

  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, 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. /* Tables 5+7, p53-54 and 55-57 */

  1100. static int decode_i_picture_header(VC9Context *v)

  1101. {

  1102.   int pqindex, status = 0, ac_pred;

  1103. 

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

  1105.     //BF = Buffer Fullness

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

  1107.     {

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

  1109.     }

  1110. 

  1111.     /* Quantizer stuff */

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

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

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

  1115.     else

  1116.     {

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

  1118.     }

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

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

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

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

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

  1124. #if HAS_ADVANCED_PROFILE

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

  1126. #endif

  1127.     {

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

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

  1130.     }

  1131. #if HAS_ADVANCED_PROFILE

  1132.     else

  1133.     {

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

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

  1136.         /* 7.1.1.34 + 8.5.2 */

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

  1138.         {

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

  1140.             if (v->condover)

  1141.             {

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

  1143.                 if (v->condover == 3)

  1144.                 {

  1145.                     status = bitplane_decoding(&v->over_flags_plane, v);

  1146.                     if (status < 0) return -1;

  1147. #if TRACE

  1148.                     av_log(v->avctx, AV_LOG_DEBUG, "Overflags plane encoding: "

  1149.                            "Imode: %i, Invert: %i\n", status>>1, status&1);

  1150. #endif

  1151.                 }

  1152.             }

  1153.         }

  1154.     }

  1155. #endif

  1156. 

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

  1158.     return status;

  1159. }

  1160. 

  1161. /* Table 9, p58-60 */

  1162. static int decode_p_picture_header(VC9Context *v)

  1163. {

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

  1165.     int lowquant, pqindex, status = 0;

  1166. 

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

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

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

  1170.     else

  1171.     {

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

  1173.     }

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

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

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

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

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

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

  1180. #if HAS_ADVANCED_PROFILE

  1181.     if (v->profile > PROFILE_MAIN)

  1182.     {

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

  1184.     }

  1185.     else

  1186. #endif

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

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

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

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

  1191.     {

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

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

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

  1195.     }

  1196. 

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

  1198.          v->mv_mode2 == MV_PMODE_MIXED_MV)

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

  1200.     {

  1201.         status = bitplane_decoding(&v->mv_type_mb_plane, v);

  1202.         if (status < 0) return -1;

  1203. #if TRACE

  1204.         av_log(v->avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "

  1205.                "Imode: %i, Invert: %i\n", status>>1, status&1);

  1206. #endif

  1207.     }

  1208. 

  1209.     status = bitplane_decoding(&v->skip_mb_plane, v);

  1210.     if (status < 0) return -1;

  1211. #if TRACE

  1212.     av_log(v->avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "

  1213.            "Imode: %i, Invert: %i\n", status>>1, status&1);

  1214. #endif

  1215. 

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

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

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

  1219. 

  1220.     if (v->dquant)

  1221.     {

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

  1223.         vop_dquant_decoding(v);

  1224.     }

  1225. 

  1226.     if (v->vstransform)

  1227.     {

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

  1229.         if (v->ttmbf)

  1230.         {

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

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

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

  1234.         }

  1235.     }

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

  1237.     return 0;

  1238. }

  1239. 

  1240. 

  1241. static int standard_decode_picture_header(VC9Context *v)

  1242. {

  1243.     int status = 0, index;

  1244. 

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

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

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

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

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

  1250.     {

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

  1252.         else v->pict_type = P_TYPE;

  1253.     }

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

  1255. 

  1256.     switch (v->pict_type)

  1257.     {

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

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

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

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

  1262.     }

  1263. 

  1264.     if (status == FRAME_SKIPED)

  1265.     {

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

  1267.       return status;

  1268.     }

  1269. 

  1270.     /* AC Syntax */

  1271.     index = decode012(&v->gb);

  1272.     v->luma_ac_vlc = NULL + index; //FIXME Add AC table

  1273.     v->chroma_ac_vlc = NULL +  index;

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

  1275.     {

  1276.         index = decode012(&v->gb);

  1277.         v->luma_ac2_vlc = NULL + index; //FIXME Add AC2 table

  1278.         v->chroma_ac2_vlc = NULL + index;

  1279.     }

  1280.     /* DC Syntax */

  1281.     index = decode012(&v->gb);

  1282.     v->luma_dc_vlc = vc9_luma_dc_vlc + index;

  1283.     v->chroma_dc_vlc = vc9_chroma_dc_vlc + index;

  1284.    

  1285.     return 0;

  1286. }

  1287. 

  1288. 

  1289. #if HAS_ADVANCED_PROFILE

  1290. /******************************************************************************/

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

  1292. /******************************************************************************/

  1293. static int advanced_decode_picture_header(VC9Context *v)

  1294. {

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

  1296.     int type, i, index;

  1297. 

  1298.     if (v->interlace)

  1299.     {

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

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

  1302.     }

  1303. 

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

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

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

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

  1308. 

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

  1310.     if (v->broadcast)

  1311.     {

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

  1313.         else

  1314.         {

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

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

  1317.         }

  1318.     }

  1319. 

  1320.     if (v->panscanflag)

  1321.     {

  1322. #if 0

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

  1324.         {

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

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

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

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

  1329.         }

  1330. #else

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

  1332. #endif

  1333.     }

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

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

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

  1337. 

  1338.     switch(v->pict_type)

  1339.     {

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

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

  1342.     case BI_TYPE:

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

  1344.     default: break;

  1345.     }

  1346. 

  1347.     /* AC Syntax */

  1348.     index = decode012(&v->gb);

  1349.     v->luma_ac_vlc = NULL + index; //FIXME

  1350.     v->chroma_ac_vlc = NULL +  index; //FIXME

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

  1352.     {

  1353.         index = decode012(&v->gb); //FIXME

  1354.         v->luma_ac2_vlc = NULL + index;

  1355.         v->chroma_ac2_vlc = NULL + index;

  1356.     }

  1357.     /* DC Syntax */

  1358.     index = decode012(&v->gb);

  1359.     v->luma_dc_vlc = vc9_luma_dc_vlc + index;

  1360.     v->chroma_dc_vlc = vc9_chroma_dc_vlc + index;

  1361. 

  1362.     return 0;

  1363. }

  1364. #endif

  1365. 

  1366. /******************************************************************************/

  1367. /* Block decoding functions                                                   */

  1368. /******************************************************************************/

  1369. /* 7.1.4, p91 and 8.1.1.7, p(1)04 */

  1370. /* FIXME proper integration (unusable and lots of parameters to send */

  1371. int decode_luma_intra_block(VC9Context *v, int mquant)

  1372. {

  1373.     int dcdiff;

  1374. 

  1375.     dcdiff = get_vlc2(&v->gb, v->luma_dc_vlc->table,

  1376.                       VC9_LUMA_DC_VLC_BITS, 2);

  1377.     if (dcdiff)

  1378.     {

  1379.         if (dcdiff == 119 /* ESC index value */)

  1380.         {

  1381.             /* TODO: Optimize */

  1382.             if (mquant == 1) dcdiff = get_bits(&v->gb, 10);

  1383.             else if (mquant == 2) dcdiff = get_bits(&v->gb, 9);

  1384.             else dcdiff = get_bits(&v->gb, 8);

  1385.         }

  1386.         else

  1387.         {

  1388.             if (mquant == 1)

  1389.                 dcdiff = (dcdiff<<2) + get_bits(&v->gb, 2) - 3;

  1390.             else if (mquant == 2)

  1391.                 dcdiff = (dcdiff<<1) + get_bits(&v->gb, 1) - 1;

  1392.         }

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

  1394.             dcdiff = -dcdiff;

  1395.     }

  1396.     /* FIXME: 8.1.1.15, p(1)13, coeff scaling for Adv Profile */

  1397. 

  1398.     return 0;

  1399. }

  1400. 

  1401. /******************************************************************************/

  1402. /* MacroBlock decoding functions                                              */

  1403. /******************************************************************************/

  1404. /* 8.1.1.5, p(1)02-(1)03 */

  1405. /* We only need to store 3 flags, but math with 4 is easier */

  1406. #define GET_CBPCY(table, bits)                                      \

  1407.     predicted_cbpcy = get_vlc2(&v->gb, table, bits, 2);             \

  1408.     cbpcy[0] = (p_cbpcy[-1] == p_cbpcy[2])                          \

  1409.          ? previous_cbpcy[1] : p_cbpcy[+2];                         \

  1410.     cbpcy[0] ^= ((predicted_cbpcy>>5)&0x01);                        \

  1411.     cbpcy[1] = (p_cbpcy[2] == p_cbpcy[3]) ? cbpcy[0] : p_cbpcy[3];  \

  1412.     cbpcy[1] ^= ((predicted_cbpcy>>4)&0x01);                        \

  1413.     cbpcy[2] = (previous_cbpcy[1] == cbpcy[0])                      \

  1414.          ? previous_cbpcy[3] : cbpcy[0];                            \

  1415.     cbpcy[2] ^= ((predicted_cbpcy>>3)&0x01);                        \

  1416.     cbpcy[3] = (cbpcy[1] == cbpcy[0]) ? cbpcy[2] : cbpcy[1];        \

  1417.     cbpcy[3] ^= ((predicted_cbpcy>>2)&0x01);

  1418.      

  1419. /* 8.1, p100 */

  1420. static int standard_decode_i_mbs(VC9Context *v)

  1421. {

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

  1423.     int ac_pred;

  1424.     /* FIXME: better to use a pointer than using (x<<4) */

  1425.     uint8_t cbpcy[4], previous_cbpcy[4], predicted_cbpcy,

  1426.         *p_cbpcy /* Pointer to skip some math */;

  1427. 

  1428.     /* Reset CBPCY predictors */

  1429.     memset(v->previous_line_cbpcy, 0, (v->width_mb+1)<<2);

  1430. 

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

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

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

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

  1435. 

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

  1437.     {

  1438.         /* Init CBPCY for line */

  1439.         *((uint32_t*)previous_cbpcy) = 0x00000000;

  1440.         p_cbpcy = v->previous_line_cbpcy+4;

  1441. 

  1442.         for (x=0; x<v->width_mb; x++, p_cbpcy += 4)

  1443.         {

  1444.             /* Get CBPCY */

  1445.             GET_CBPCY(vc9_cbpcy_i_vlc.table, VC9_CBPCY_I_VLC_BITS);

  1446. 

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

  1448. 

  1449.             /* TODO: Decode blocks from that mb wrt cbpcy */

  1450. 

  1451.             /* Update for next block */

  1452.             *((uint32_t*)p_cbpcy) = *((uint32_t*)previous_cbpcy);

  1453.             *((uint32_t*)previous_cbpcy) = *((uint32_t*)cbpcy);

  1454.             current_mb++;

  1455.         }

  1456.     }

  1457.     return 0;

  1458. }

  1459. 

  1460. #define GET_MQUANT()                                           \

  1461.   if (v->dquantfrm)                                            \

  1462.   {                                                            \

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

  1464.     {                                                          \

  1465.       if (v->dqbilevel)                                        \

  1466.       {                                                        \

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

  1468.       }                                                        \

  1469.       else                                                     \

  1470.       {                                                        \

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

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

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

  1474.       }                                                        \

  1475.     }                                                          \

  1476.   }

  1477. 

  1478. /* MVDATA decoding from 8.3.5.2, p(1)20 */

  1479. #define GET_MVDATA(_dmv_x, _dmv_y)                                  \

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

  1481.                        VC9_MV_DIFF_VLC_BITS, 2);                    \

  1482.   if (index > 36)                                                   \

  1483.   {                                                                 \

  1484.     mb_has_coeffs = 1;                                              \

  1485.     index -= 37;                                                    \

  1486.   }                                                                 \

  1487.   else mb_has_coeffs = 0;                                           \

  1488.   mb_is_intra = 0;                                                  \

  1489.   if (!index) { _dmv_x = _dmv_y = 0; }                              \

  1490.   else if (index == 35)                                             \

  1491.   {                                                                 \

  1492.     _dmv_x = get_bits(&v->gb, k_x);                                 \

  1493.     _dmv_y = get_bits(&v->gb, k_y);                                 \

  1494.     mb_is_intra = 1;                                                \

  1495.   }                                                                 \

  1496.   else                                                              \

  1497.   {                                                                 \

  1498.     index1 = index%6;                                               \

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

  1500.     else                          val = 0;                          \

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

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

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

  1504.                                                                     \

  1505.     index1 = index/6;                                               \

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

  1507.     else                          val = 0;                          \

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

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

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

  1511.   }

  1512. 

  1513. /* 8.1, p(1)15 */

  1514. static int decode_p_mbs(VC9Context *v)

  1515. {

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

  1517.     uint8_t cbpcy[4], previous_cbpcy[4], predicted_cbpcy,

  1518.         *p_cbpcy /* Pointer to skip some math */;

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

  1520.     int mv_mode_bit = 0; 

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

  1522.     int ttmb; /* MB Transform type */

  1523. 

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

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

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

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

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

  1529.     int hpel_flag; /* Some MB properties */

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

  1531.     int val, sign; /* MVDATA temp values */

  1532. 

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

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

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

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

  1537. 

  1538.     /* Select proper long MV range */

  1539.     switch (v->mvrange)

  1540.     {

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

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

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

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

  1545.     }

  1546. 

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

  1548.     k_x -= hpel_flag;

  1549.     k_y -= hpel_flag;

  1550. 

  1551.     /* Reset CBPCY predictors */

  1552.     memset(v->previous_line_cbpcy, 0, (v->width_mb+1)<<2);

  1553. 

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

  1555.     {

  1556.         /* Init CBPCY for line */

  1557.         *((uint32_t*)previous_cbpcy) = 0x00000000;

  1558.         p_cbpcy = v->previous_line_cbpcy+4;

  1559. 

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

  1561.         {

  1562.             if (v->mv_type_mb_plane.is_raw)

  1563.                 v->mv_type_mb_plane.data[current_mb] = get_bits(&v->gb, 1);

  1564.             if (v->skip_mb_plane.is_raw)

  1565.                 v->skip_mb_plane.data[current_mb] = get_bits(&v->gb, 1);

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

  1567.             {

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

  1569.                 {

  1570.                     GET_MVDATA(dmv_x, dmv_y);

  1571. 

  1572.                     /* hybrid mv pred, 8.3.5.3.4 */

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

  1574.                         v->mv_mode == MV_PMODE_MIXED_MV)

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

  1576.                     if (mb_is_intra && !mb_has_coeffs)

  1577.                     {

  1578.                         GET_MQUANT();

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

  1580.                     }

  1581.                     else if (mb_has_coeffs)

  1582.                     {

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

  1584.                         GET_CBPCY(v->cbpcy_vlc->table, VC9_CBPCY_P_VLC_BITS);

  1585.                         GET_MQUANT();

  1586.                     }

  1587.                     if (!v->ttmbf)

  1588.                         ttmb = get_vlc2(&v->gb, v->ttmb_vlc->table,

  1589.                                             VC9_TTMB_VLC_BITS, 12);

  1590.                     /* TODO: decode blocks from that mb wrt cbpcy */

  1591.                 }

  1592.                 else //Skipped

  1593.                 {

  1594.                     /* hybrid mv pred, 8.3.5.3.4 */

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

  1596.                         v->mv_mode == MV_PMODE_MIXED_MV)

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

  1598.                 }

  1599.             } //1MV mode

  1600.             else //4MV mode

  1601.             {

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

  1603.                 {

  1604.                     /* Get CBPCY */

  1605.                     GET_CBPCY(v->cbpcy_vlc->table, VC9_CBPCY_P_VLC_BITS);

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

  1607.                     {

  1608.                         if (cbpcy[i] /* cbpcy set for this block */)

  1609.                         {

  1610.                             GET_MVDATA(dmv_x, dmv_y);

  1611.                         }

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

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

  1614.                         GET_MQUANT();

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

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

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

  1618.                         if (!v->ttmbf)

  1619.                             ttmb = get_vlc2(&v->gb, v->ttmb_vlc->table,

  1620.                                             VC9_TTMB_VLC_BITS, 12);

  1621.             

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

  1623.             

  1624.                     }

  1625.                 }

  1626.                 else //Skipped MB

  1627.                 {

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

  1629.                     {

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

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

  1632.                         

  1633.                         /* TODO: do something */

  1634.                     }

  1635.                 }

  1636.             }

  1637. 

  1638.             /* Update for next block */

  1639. #if TRACE > 2

  1640.             av_log(v->avctx, AV_LOG_DEBUG, "Block %4i: p_cbpcy=%i%i%i%i, previous_cbpcy=%i%i%i%i,"

  1641.                    " cbpcy=%i%i%i%i\n", current_mb,

  1642.                    p_cbpcy[0], p_cbpcy[1], p_cbpcy[2], p_cbpcy[3],

  1643.                    previous_cbpcy[0], previous_cbpcy[1], previous_cbpcy[2], previous_cbpcy[3],

  1644.                    cbpcy[0], cbpcy[1], cbpcy[2], cbpcy[3]);

  1645. #endif

  1646.             *((uint32_t*)p_cbpcy) = *((uint32_t*)previous_cbpcy);

  1647.             *((uint32_t*)previous_cbpcy) = *((uint32_t*)cbpcy);

  1648.             current_mb++;

  1649.         }

  1650.     }

  1651.     return 0;

  1652. }

  1653. 

  1654. static int decode_b_mbs(VC9Context *v)

  1655. {

  1656.     int x, y, current_mb = 0, i /* MB / B postion information */;

  1657.     int ac_pred;

  1658.     int b_mv_type = BMV_TYPE_BACKWARD;

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

  1660.     int ttmb; /* MacroBlock transform type */

  1661.     

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

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

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

  1665.     int dmv1_x, dmv1_y, dmv2_x, dmv2_y; /* Differential MV components */

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

  1667.     int hpel_flag; /* Some MB properties */

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

  1669.     int val, sign; /* MVDATA temp values */

  1670.     

  1671.     /* Select proper long MV range */

  1672.     switch (v->mvrange)

  1673.     {

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

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

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

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

  1678.     }

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

  1680.     k_x -= hpel_flag;

  1681.     k_y -= hpel_flag;

  1682. 

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

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

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

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

  1687. 

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

  1689.     {

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

  1691.         {

  1692.             if (v->direct_mb_plane.is_raw)

  1693.                 v->direct_mb_plane.data[current_mb] = get_bits(&v->gb, 1);

  1694.             if (v->skip_mb_plane.is_raw)

  1695.                 v->skip_mb_plane.data[current_mb] = get_bits(&v->gb, 1);

  1696.             

  1697.             if (!v->direct_mb_plane.data[current_mb])

  1698.             {

  1699.                 if (v->skip_mb_plane.data[current_mb])

  1700.                 {

  1701.                     b_mv_type = decode012(&v->gb);

  1702.                     if (v->bfraction > 420 /*1/2*/ &&

  1703.                         b_mv_type < 3) b_mv_type = 1-b_mv_type;

  1704.                 }

  1705.                 else

  1706.                 { 

  1707.                     /* FIXME getting tired commenting */

  1708.                     GET_MVDATA(dmv1_x, dmv1_y);

  1709.                     if (!mb_is_intra /* b_mv1 tells not intra */)

  1710.                     {

  1711.                         /* FIXME: actually read it */

  1712.                         b_mv_type = decode012(&v->gb);

  1713.                         if (v->bfraction > 420 /*1/2*/ &&

  1714.                             b_mv_type < 3) b_mv_type = 1-b_mv_type;

  1715.                     }

  1716.                 }

  1717.             }

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

  1719.             {

  1720.                 if (mb_has_coeffs /* BMV1 == "last" */)

  1721.                 {

  1722.                     GET_MQUANT();

  1723.                     if (mb_is_intra /* intra mb */)

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

  1725.                 }

  1726.                 else

  1727.                 {

  1728.                     /* if bmv1 tells MVs are interpolated */

  1729.                     if (b_mv_type == BMV_TYPE_INTERPOLATED)

  1730.                     {

  1731.                         GET_MVDATA(dmv2_x, dmv2_y);

  1732.                     }

  1733.                     /* GET_MVDATA has reset some stuff */

  1734.                     if (mb_has_coeffs /* b_mv2 == "last" */)

  1735.                     {

  1736.                         if (mb_is_intra /* intra_mb */)

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

  1738.                         GET_MQUANT();

  1739.                     }

  1740.                 }

  1741.             }

  1742.             //End1

  1743.             if (v->ttmbf)

  1744.                 ttmb = get_vlc2(&v->gb, v->ttmb_vlc->table,

  1745.                                    VC9_TTMB_VLC_BITS, 12);

  1746. 

  1747.             //End2

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

  1749.             {

  1750.                 /* FIXME: process the block */

  1751.             }

  1752. 

  1753.             current_mb++;

  1754.         }

  1755.     }

  1756.     return 0;

  1757. }

  1758. 

  1759. #if HAS_ADVANCED_PROFILE

  1760. static int advanced_decode_i_mbs(VC9Context *v)

  1761. {

  1762.     int x, y, mqdiff, mquant, ac_pred, current_mb = 0, over_flags_mb = 0;

  1763. 

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

  1765.     {

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

  1767.         {

  1768.             if (v->ac_pred_plane.data[current_mb])

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

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

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

  1772.             GET_MQUANT();

  1773. 

  1774.             /* TODO: lots */

  1775.         }

  1776.         current_mb++;

  1777.     }

  1778.     return 0;

  1779. }

  1780. #endif

  1781. 

  1782. static int vc9_decode_init(AVCodecContext *avctx)

  1783. {

  1784.     VC9Context *v = avctx->priv_data;

  1785.     GetBitContext gb;

  1786. 

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

  1788.     avctx->pix_fmt = PIX_FMT_YUV420P;

  1789.     v->avctx = avctx;

  1790. 

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

  1792. 

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

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

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

  1796.     {

  1797.         int count = 0;

  1798. 

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

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

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

  1802. 	// samples we can decode

  1803. 

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

  1805. 	

  1806. 	decode_sequence_header(avctx, &gb);

  1807. 

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

  1809. 	if (count>0)

  1810. 	{

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

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

  1813. 	}

  1814. 	else

  1815. 	{

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

  1817. 	}

  1818.     }

  1819. 

  1820.     /* Done with header parsing */

  1821.     //FIXME I feel like this is wrong

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

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

  1824. 

  1825.     /* Allocate mb bitplanes */

  1826.     if (alloc_bitplane(&v->mv_type_mb_plane, v->width_mb, v->height_mb) < 0)

  1827.         return -1;

  1828.     if (alloc_bitplane(&v->mv_type_mb_plane, v->width_mb, v->height_mb) < 0)

  1829.         return -1;

  1830.     if (alloc_bitplane(&v->skip_mb_plane, v->width_mb, v->height_mb) < 0)

  1831.         return -1;

  1832.     if (alloc_bitplane(&v->direct_mb_plane, v->width_mb, v->height_mb) < 0)

  1833.         return -1;

  1834. 

  1835.     /* For predictors */

  1836.     v->previous_line_cbpcy = (uint8_t *)av_malloc((v->width_mb+1)*4);

  1837.     if (!v->previous_line_cbpcy) return -1;

  1838. 

  1839. #if HAS_ADVANCED_PROFILE

  1840.     if (v->profile > PROFILE_MAIN)

  1841.     {

  1842.         if (alloc_bitplane(&v->over_flags_plane, v->width_mb, v->height_mb) < 0)

  1843.             return -1;

  1844.         if (alloc_bitplane(&v->ac_pred_plane, v->width_mb, v->height_mb) < 0)

  1845.             return -1;

  1846.     }

  1847. #endif

  1848. 

  1849.     return 0;

  1850. }

  1851. 

  1852. static int vc9_decode_frame(AVCodecContext *avctx,

  1853.                             void *data, int *data_size,

  1854.                             uint8_t *buf, int buf_size)

  1855. {

  1856.     VC9Context *v = avctx->priv_data;

  1857.     int ret = FRAME_SKIPED, len, start_code;

  1858.     AVFrame *pict = data;

  1859.     uint8_t *tmp_buf;

  1860.     v->avctx = avctx;

  1861. 

  1862.     //buf_size = 0 -> last frame

  1863.     if (!buf_size) return 0;

  1864. 

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

  1866.                              avctx->height);

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

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

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

  1870. 

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

  1872.     {

  1873.         //No IDU

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

  1875.         

  1876. #if HAS_ADVANCED_PROFILE

  1877. 	if (v->profile > PROFILE_MAIN)

  1878. 	{

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

  1880.     	    switch(v->pict_type)

  1881.     	    {

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

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

  1884.     		case B_TYPE:

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

  1886.     		default: ret = FRAME_SKIPED;

  1887.     	    }

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

  1889. 	}

  1890. 	else

  1891. #endif

  1892. 	{

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

  1894.     	    switch(v->pict_type)

  1895. 	    {

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

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

  1898.     		case B_TYPE:

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

  1900.     		default: ret = FRAME_SKIPED;

  1901.     	    }

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

  1903. 	}

  1904.     }

  1905.     else

  1906.     {

  1907. #if 0

  1908. 	// search for IDU's

  1909. 	// FIXME

  1910. 	uint32_t scp = 0;

  1911. 	int scs = 0, i = 0;

  1912. 

  1913. 	while (i < buf_size)

  1914. 	{

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

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

  1917. 

  1918. 	    if (scp != 0x000001)

  1919. 		break; // eof ?

  1920. 	

  1921. 	    scs = buf[i++];	

  1922. 

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

  1924. 	

  1925. 	    switch(scs)

  1926. 	    {

  1927.             case 0x0A: //Sequence End Code

  1928.                 return 0;

  1929.             case 0x0B: //Slice Start Code

  1930.                 av_log(avctx, AV_LOG_ERROR, "Slice coding not supported\n");

  1931.                 return -1;

  1932.             case 0x0C: //Field start code

  1933.                 av_log(avctx, AV_LOG_ERROR, "Interlaced coding not supported\n");

  1934.                 return -1;

  1935.             case 0x0D: //Frame start code

  1936.                 break;

  1937.             case 0x0E: //Entry point Start Code

  1938.                 if (v->profile <= MAIN_PROFILE)

  1939.                     av_log(avctx, AV_LOG_ERROR,

  1940.                            "Found an entry point in profile %i\n", v->profile);

  1941.                 advanced_entry_point_process(avctx, &v->gb);

  1942.                 break;

  1943.             case 0x0F: //Sequence header Start Code

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

  1945.                 break;

  1946.             default:

  1947.                 av_log(avctx, AV_LOG_ERROR,

  1948.                        "Unsupported IDU suffix %lX\n", scs);

  1949.             }

  1950. 	    

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

  1952. 	}

  1953. #else

  1954. 	av_abort();

  1955. #endif

  1956.     }

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

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

  1959. 

  1960.     /* Fake consumption of all data */

  1961.     *data_size = len;

  1962.     return buf_size; //Number of bytes consumed

  1963. }

  1964. 

  1965. static int vc9_decode_end(AVCodecContext *avctx)

  1966. {

  1967.     VC9Context *v = avctx->priv_data;

  1968. 

  1969. #if HAS_ADVANCED_PROFILE

  1970.     av_freep(&v->hrd_rate);

  1971.     av_freep(&v->hrd_buffer);

  1972. #endif

  1973.     av_freep(&v->mv_type_mb_plane);

  1974.     av_freep(&v->skip_mb_plane);

  1975.     av_freep(&v->direct_mb_plane);

  1976.     return 0;

  1977. }

  1978. 

  1979. AVCodec vc9_decoder = {

  1980.     "vc9",

  1981.     CODEC_TYPE_VIDEO,

  1982.     CODEC_ID_VC9,

  1983.     sizeof(VC9Context),

  1984.     vc9_decode_init,

  1985.     NULL,

  1986.     vc9_decode_end,

  1987.     vc9_decode_frame,

  1988.     CODEC_CAP_DELAY,

  1989.     NULL

  1990. };

  1991. 

  1992. AVCodec wmv3_decoder = {

  1993.     "wmv3",

  1994.     CODEC_TYPE_VIDEO,

  1995.     CODEC_ID_WMV3,

  1996.     sizeof(VC9Context),

  1997.     vc9_decode_init,

  1998.     NULL,

  1999.     vc9_decode_end,

  2000.     vc9_decode_frame,

  2001.     CODEC_CAP_DELAY,

  2002.     NULL

  2003. };