2 * VC-9 and WMV3 decoder
3 * Copyright (c) 2005 Anonymous
4 * Copyright (c) 2005 Alex Beregszaszi
5 * Copyright (c) 2005 Michael Niedermayer
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.
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.
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
25 * VC-9 and WMV3 decoder
27 * TODO: most AP stuff, optimize, most of MB layer, transform, filtering and motion compensation, etc
33 #include "mpegvideo.h"
39 extern const uint32_t ff_table0_dc_lum[120][2], ff_table1_dc_lum[120][2];
40 extern const uint32_t ff_table0_dc_chroma[120][2], ff_table1_dc_chroma[120][2];
41 extern VLC ff_msmp4_dc_luma_vlc[2], ff_msmp4_dc_chroma_vlc[2];
42 #define MB_INTRA_VLC_BITS 9
43 extern VLC ff_msmp4_mb_i_vlc;
45 static const uint16_t table_mb_intra[64][2];
47 /* Some inhibiting stuff */
48 #define HAS_ADVANCED_PROFILE 0
52 # define INIT_VLC(vlc, nb_bits, nb_codes, bits, bits_wrap, bits_size, \
53 codes, codes_wrap, codes_size, use_static) \
54 if (init_vlc(vlc, nb_bits, nb_codes, bits, bits_wrap, bits_size, \
55 codes, codes_wrap, codes_size, use_static) < 0) \
57 av_log(v->s.avctx, AV_LOG_ERROR, "Error for " # vlc " (%i)\n", i); \
61 # define INIT_VLC(vlc, nb_bits, nb_codes, bits, bits_wrap, bits_size, \
62 codes, codes_wrap, codes_size, use_static) \
63 init_vlc(vlc, nb_bits, nb_codes, bits, bits_wrap, bits_size, \
64 codes, codes_wrap, codes_size, use_static)
67 /** Available Profiles */
69 #define PROFILE_SIMPLE 0
70 #define PROFILE_MAIN 1
71 #define PROFILE_COMPLEX 2 ///< TODO: WMV9 specific
72 #define PROFILE_ADVANCED 3
75 /** Sequence quantizer mode */
77 #define QUANT_FRAME_IMPLICIT 0 ///< Implicitly specified at frame level
78 #define QUANT_FRAME_EXPLICIT 1 ///< Explicitly specified at frame level
79 #define QUANT_NON_UNIFORM 2 ///< Non-uniform quant used for all frames
80 #define QUANT_UNIFORM 3 ///< Uniform quant used for all frames
83 /** Where quant can be changed */
85 #define DQPROFILE_FOUR_EDGES 0
86 #define DQPROFILE_DOUBLE_EDGES 1
87 #define DQPROFILE_SINGLE_EDGE 2
88 #define DQPROFILE_ALL_MBS 3
91 /** @name Where quant can be changed
94 #define DQPROFILE_FOUR_EDGES 0
95 #define DQSINGLE_BEDGE_LEFT 0
96 #define DQSINGLE_BEDGE_TOP 1
97 #define DQSINGLE_BEDGE_RIGHT 2
98 #define DQSINGLE_BEDGE_BOTTOM 3
101 /** Which pair of edges is quantized with ALTPQUANT */
103 #define DQDOUBLE_BEDGE_TOPLEFT 0
104 #define DQDOUBLE_BEDGE_TOPRIGHT 1
105 #define DQDOUBLE_BEDGE_BOTTOMRIGHT 2
106 #define DQDOUBLE_BEDGE_BOTTOMLEFT 3
109 /** MV modes for P frames */
111 #define MV_PMODE_1MV_HPEL_BILIN 0
112 #define MV_PMODE_1MV 1
113 #define MV_PMODE_1MV_HPEL 2
114 #define MV_PMODE_MIXED_MV 3
115 #define MV_PMODE_INTENSITY_COMP 4
118 /** @name MV types for B frames */
120 #define BMV_TYPE_BACKWARD 0
121 #define BMV_TYPE_BACKWARD 0
122 #define BMV_TYPE_FORWARD 1
123 #define BMV_TYPE_INTERPOLATED 3
126 /** MV P mode - the 5th element is only used for mode 1 */
127 static const uint8_t mv_pmode_table[2][5] = {
128 { MV_PMODE_1MV_HPEL_BILIN, MV_PMODE_1MV, MV_PMODE_1MV_HPEL, MV_PMODE_MIXED_MV, MV_PMODE_INTENSITY_COMP },
129 { MV_PMODE_1MV, MV_PMODE_MIXED_MV, MV_PMODE_1MV_HPEL, MV_PMODE_1MV_HPEL_BILIN, MV_PMODE_INTENSITY_COMP }
132 /** One more frame type */
135 static const int fps_nr[5] = { 24, 25, 30, 50, 60 },
136 fps_dr[2] = { 1000, 1001 };
137 static const uint8_t pquant_table[3][32] = {
138 { /* Implicit quantizer */
139 0, 1, 2, 3, 4, 5, 6, 7, 8, 6, 7, 8, 9, 10, 11, 12,
140 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 27, 29, 31
142 { /* Explicit quantizer, pquantizer uniform */
143 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
144 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31
146 { /* Explicit quantizer, pquantizer non-uniform */
147 0, 1, 1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
148 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 29, 31
152 /** @name VC-9 VLC tables and defines
153 * @todo TODO move this into the context
156 #define VC9_BFRACTION_VLC_BITS 7
157 static VLC vc9_bfraction_vlc;
158 #define VC9_IMODE_VLC_BITS 4
159 static VLC vc9_imode_vlc;
160 #define VC9_NORM2_VLC_BITS 3
161 static VLC vc9_norm2_vlc;
162 #define VC9_NORM6_VLC_BITS 9
163 static VLC vc9_norm6_vlc;
164 /* Could be optimized, one table only needs 8 bits */
165 #define VC9_TTMB_VLC_BITS 9 //12
166 static VLC vc9_ttmb_vlc[3];
167 #define VC9_MV_DIFF_VLC_BITS 9 //15
168 static VLC vc9_mv_diff_vlc[4];
169 #define VC9_CBPCY_P_VLC_BITS 9 //14
170 static VLC vc9_cbpcy_p_vlc[4];
171 #define VC9_4MV_BLOCK_PATTERN_VLC_BITS 6
172 static VLC vc9_4mv_block_pattern_vlc[4];
173 #define VC9_TTBLK_VLC_BITS 5
174 static VLC vc9_ttblk_vlc[3];
175 #define VC9_SUBBLKPAT_VLC_BITS 6
176 static VLC vc9_subblkpat_vlc[3];
180 * We mainly need data and is_raw, so this struct could be avoided
181 * to save a level of indirection; feel free to modify
182 * @fixme For now, stride=width
183 * @warning Data are bits, either 1 or 0
185 typedef struct BitPlane {
186 uint8_t *data; ///< Data buffer
187 int width; ///< Width of the buffer
188 int stride; ///< Stride of the buffer
189 int height; ///< Plane height
190 uint8_t is_raw; ///< Bit values must be read at MB level
194 * @fixme Change size wherever another size is more efficient
195 * Many members are only used for Advanced Profile
197 typedef struct VC9Context{
200 /** Simple/Main Profile sequence header */
202 int res_sm; ///< reserved, 2b
203 int res_x8; ///< reserved
204 int multires; ///< frame-level RESPIC syntax element present
205 int res_fasttx; ///< reserved, always 1
206 int res_transtab; ///< reserved, always 0
207 int rangered; ///< RANGEREDFRM (range reduction) syntax element present
209 int res_rtm_flag; ///< reserved, set to 1
210 int reserved; ///< reserved
213 #if HAS_ADVANCED_PROFILE
214 /** Advanced Profile */
216 int level; ///< 3bits, for Advanced/Simple Profile, provided by TS layer
217 int chromaformat; ///< 2bits, 2=4:2:0, only defined
218 int postprocflag; ///< Per-frame processing suggestion flag present
219 int broadcast; ///< TFF/RFF present
220 int interlace; ///< Progressive/interlaced (RPTFTM syntax element)
221 int tfcntrflag; ///< TFCNTR present
222 int panscanflag; ///< NUMPANSCANWIN, TOPLEFT{X,Y}, BOTRIGHT{X,Y} present
223 int extended_dmv; ///< Additional extended dmv range at P/B frame-level
224 int color_prim; ///< 8bits, chroma coordinates of the color primaries
225 int transfer_char; ///< 8bits, Opto-electronic transfer characteristics
226 int matrix_coef; ///< 8bits, Color primaries->YCbCr transform matrix
227 int hrd_param_flag; ///< Presence of Hypothetical Reference
228 ///< Decoder parameters
233 /** Sequence header data for all Profiles
234 * TODO: choose between ints, uint8_ts and monobit flags
237 int profile; ///< 2bits, Profile
238 int frmrtq_postproc; ///< 3bits,
239 int bitrtq_postproc; ///< 5bits, quantized framerate-based postprocessing strength
240 int fastuvmc; ///< Rounding of qpel vector to hpel ? (not in Simple)
241 int extended_mv; ///< Ext MV in P/B (not in Simple)
242 int dquant; ///< How qscale varies with MBs, 2bits (not in Simple)
243 int vstransform; ///< variable-size [48]x[48] transform type + info
244 int overlap; ///< overlapped transforms in use
245 int quantizer_mode; ///< 2bits, quantizer mode used for sequence, see QUANT_*
246 int finterpflag; ///< INTERPFRM present
249 /** Frame decoding info for all profiles */
251 uint8_t mv_mode; ///< MV coding monde
252 uint8_t mv_mode2; ///< Secondary MV coding mode (B frames)
253 int k_x; ///< Number of bits for MVs (depends on MV range)
254 int k_y; ///< Number of bits for MVs (depends on MV range)
255 uint8_t pq, altpq; ///< Current/alternate frame quantizer scale
256 /** pquant parameters */
263 /** AC coding set indexes
264 * @see 8.1.1.10, p(1)10
267 int c_ac_table_index; ///< Chroma index from ACFRM element
268 int y_ac_table_index; ///< Luma index from AC2FRM element
270 int ttfrm; ///< Transform type info present at frame level
271 uint8_t ttmbf; ///< Transform type flag
272 int ttmb; ///< Transform type
273 uint8_t ttblk4x4; ///< Value of ttblk which indicates a 4x4 transform
274 /** Luma compensation parameters */
279 int16_t bfraction; ///< Relative position % anchors=> how to scale MVs
280 uint8_t halfpq; ///< Uniform quant over image and qp+.5
281 uint8_t respic; ///< Frame-level flag for resized images
282 int buffer_fullness; ///< HRD info
284 * -# 0 -> [-64n 63.f] x [-32, 31.f]
285 * -# 1 -> [-128, 127.f] x [-64, 63.f]
286 * -# 2 -> [-512, 511.f] x [-128, 127.f]
287 * -# 3 -> [-1024, 1023.f] x [-256, 255.f]
290 uint8_t pquantizer; ///< Uniform (over sequence) quantizer in use
291 uint8_t *previous_line_cbpcy; ///< To use for predicted CBPCY
292 VLC *cbpcy_vlc; ///< CBPCY VLC table
293 int tt_index; ///< Index for Transform Type tables
294 BitPlane mv_type_mb_plane; ///< bitplane for mv_type == (4MV)
295 BitPlane skip_mb_plane; ///< bitplane for skipped MBs
296 BitPlane direct_mb_plane; ///< bitplane for "direct" MBs
298 /** Frame decoding info for S/M profiles only */
300 uint8_t rangeredfrm; ///< out_sample = CLIP((in_sample-128)*2+128)
304 #if HAS_ADVANCED_PROFILE
305 /** Frame decoding info for Advanced profile */
307 uint8_t fcm; ///< 0->Progressive, 2->Frame-Interlace, 3->Field-Interlace
308 uint8_t numpanscanwin;
310 uint8_t rptfrm, tff, rff;
313 uint16_t bottomrightx;
314 uint16_t bottomrighty;
317 int hrd_num_leaky_buckets;
318 uint8_t bit_rate_exponent;
319 uint8_t buffer_size_exponent;
320 BitPlane ac_pred_plane; ///< AC prediction flags bitplane
321 BitPlane over_flags_plane; ///< Overflags bitplane
323 uint16_t *hrd_rate, *hrd_buffer;
324 uint8_t *hrd_fullness;
325 uint8_t range_mapy_flag;
326 uint8_t range_mapuv_flag;
334 * Get unary code of limited length
335 * @fixme FIXME Slow and ugly
336 * @param gb GetBitContext
337 * @param[in] stop The bitstop value (unary code of 1's or 0's)
338 * @param[in] len Maximum length
339 * @return Unary length/index
341 static int get_prefix(GetBitContext *gb, int stop, int len)
344 int i = 0, tmp = !stop;
346 while (i != len && tmp != stop)
348 tmp = get_bits(gb, 1);
351 if (i == len && tmp != stop) return len+1;
358 UPDATE_CACHE(re, gb);
359 buf=GET_CACHE(re, gb); //Still not sure
360 if (stop) buf = ~buf;
362 log= av_log2(-buf); //FIXME: -?
364 LAST_SKIP_BITS(re, gb, log+1);
365 CLOSE_READER(re, gb);
369 LAST_SKIP_BITS(re, gb, limit);
370 CLOSE_READER(re, gb);
376 * Init VC-9 specific tables and VC9Context members
377 * @param v The VC9Context to initialize
380 static int vc9_init_common(VC9Context *v)
385 /* Set the bit planes */
386 v->mv_type_mb_plane = (struct BitPlane) { NULL, 0, 0, 0 };
387 v->direct_mb_plane = (struct BitPlane) { NULL, 0, 0, 0 };
388 v->skip_mb_plane = (struct BitPlane) { NULL, 0, 0, 0 };
389 #if HAS_ADVANCED_PROFILE
390 v->ac_pred_plane = v->over_flags_plane = (struct BitPlane) { NULL, 0, 0, 0 };
391 v->hrd_rate = v->hrd_buffer = NULL;
395 #if 0 // spec -> actual tables converter
397 int code= (vc9_norm6_spec[i][1] << vc9_norm6_spec[i][4]) + vc9_norm6_spec[i][3];
398 av_log(NULL, AV_LOG_DEBUG, "0x%03X, ", code);
399 if(i%16==15) av_log(NULL, AV_LOG_DEBUG, "\n");
402 int code= vc9_norm6_spec[i][2] + vc9_norm6_spec[i][4];
403 av_log(NULL, AV_LOG_DEBUG, "%2d, ", code);
404 if(i%16==15) av_log(NULL, AV_LOG_DEBUG, "\n");
410 INIT_VLC(&vc9_bfraction_vlc, VC9_BFRACTION_VLC_BITS, 23,
411 vc9_bfraction_bits, 1, 1,
412 vc9_bfraction_codes, 1, 1, 1);
413 INIT_VLC(&vc9_norm2_vlc, VC9_NORM2_VLC_BITS, 4,
414 vc9_norm2_bits, 1, 1,
415 vc9_norm2_codes, 1, 1, 1);
416 INIT_VLC(&vc9_norm6_vlc, VC9_NORM6_VLC_BITS, 64,
417 vc9_norm6_bits, 1, 1,
418 vc9_norm6_codes, 2, 2, 1);
419 INIT_VLC(&vc9_imode_vlc, VC9_IMODE_VLC_BITS, 7,
420 vc9_imode_bits, 1, 1,
421 vc9_imode_codes, 1, 1, 1);
424 INIT_VLC(&vc9_ttmb_vlc[i], VC9_TTMB_VLC_BITS, 16,
425 vc9_ttmb_bits[i], 1, 1,
426 vc9_ttmb_codes[i], 2, 2, 1);
427 INIT_VLC(&vc9_ttblk_vlc[i], VC9_TTBLK_VLC_BITS, 8,
428 vc9_ttblk_bits[i], 1, 1,
429 vc9_ttblk_codes[i], 1, 1, 1);
430 INIT_VLC(&vc9_subblkpat_vlc[i], VC9_SUBBLKPAT_VLC_BITS, 15,
431 vc9_subblkpat_bits[i], 1, 1,
432 vc9_subblkpat_codes[i], 1, 1, 1);
436 INIT_VLC(&vc9_4mv_block_pattern_vlc[i], VC9_4MV_BLOCK_PATTERN_VLC_BITS, 16,
437 vc9_4mv_block_pattern_bits[i], 1, 1,
438 vc9_4mv_block_pattern_codes[i], 1, 1, 1);
439 INIT_VLC(&vc9_cbpcy_p_vlc[i], VC9_CBPCY_P_VLC_BITS, 64,
440 vc9_cbpcy_p_bits[i], 1, 1,
441 vc9_cbpcy_p_codes[i], 2, 2, 1);
442 INIT_VLC(&vc9_mv_diff_vlc[i], VC9_MV_DIFF_VLC_BITS, 73,
443 vc9_mv_diff_bits[i], 1, 1,
444 vc9_mv_diff_codes[i], 2, 2, 1);
450 v->mvrange = 0; /* 7.1.1.18, p80 */
455 #if HAS_ADVANCED_PROFILE
457 * Decode sequence header's Hypothetic Reference Decoder data
459 * @param v The VC9Context to initialize
460 * @param gb A GetBitContext initialized from AVCodecContext extra_data
463 static int decode_hrd(VC9Context *v, GetBitContext *gb)
467 num = 1 + get_bits(gb, 5);
470 if (v->hrd_rate || num != v->hrd_num_leaky_buckets)
472 av_freep(&v->hrd_rate);
474 if (!v->hrd_rate) v->hrd_rate = av_malloc(num*sizeof(uint16_t));
475 if (!v->hrd_rate) return -1;
478 if (v->hrd_buffer || num != v->hrd_num_leaky_buckets)
480 av_freep(&v->hrd_buffer);
482 if (!v->hrd_buffer) v->hrd_buffer = av_malloc(num*sizeof(uint16_t));
485 av_freep(&v->hrd_rate);
490 if (v->hrd_fullness || num != v->hrd_num_leaky_buckets)
492 av_freep(&v->hrd_buffer);
494 if (!v->hrd_fullness) v->hrd_fullness = av_malloc(num*sizeof(uint8_t));
495 if (!v->hrd_fullness)
497 av_freep(&v->hrd_rate);
498 av_freep(&v->hrd_buffer);
501 v->hrd_num_leaky_buckets = num;
503 //exponent in base-2 for rate
504 v->bit_rate_exponent = 6 + get_bits(gb, 4);
505 //exponent in base-2 for buffer_size
506 v->buffer_size_exponent = 4 + get_bits(gb, 4);
508 for (i=0; i<num; i++)
510 //mantissae, ordered (if not, use a function ?
511 v->hrd_rate[i] = 1 + get_bits(gb, 16);
512 if (i && v->hrd_rate[i-1]>=v->hrd_rate[i])
514 av_log(v->s.avctx, AV_LOG_ERROR, "HDR Rates aren't strictly increasing:"
515 "%i vs %i\n", v->hrd_rate[i-1], v->hrd_rate[i]);
518 v->hrd_buffer[i] = 1 + get_bits(gb, 16);
519 if (i && v->hrd_buffer[i-1]<v->hrd_buffer[i])
521 av_log(v->s.avctx, AV_LOG_ERROR, "HDR Buffers aren't decreasing:"
522 "%i vs %i\n", v->hrd_buffer[i-1], v->hrd_buffer[i]);
530 * Decode sequence header for Advanced Profile
532 * @see 6.1.7, pp21-27
533 * @param v The VC9Context to initialize
534 * @param gb A GetBitContext initialized from AVCodecContext extra_data
537 static int decode_advanced_sequence_header(AVCodecContext *avctx, GetBitContext *gb)
539 VC9Context *v = avctx->priv_data;
540 int nr, dr, aspect_ratio;
542 v->postprocflag = get_bits(gb, 1);
543 v->broadcast = get_bits(gb, 1);
544 v->interlace = get_bits(gb, 1);
546 v->tfcntrflag = get_bits(gb, 1);
547 v->finterpflag = get_bits(gb, 1); //common
548 v->panscanflag = get_bits(gb, 1);
549 v->reserved = get_bits(gb, 1);
552 av_log(avctx, AV_LOG_ERROR, "RESERVED should be 0 (is %i)\n",
557 v->extended_dmv = get_bits(gb, 1);
560 if (get_bits(gb, 1) /* pic_size_flag */)
562 avctx->coded_width = get_bits(gb, 12) << 1;
563 avctx->coded_height = get_bits(gb, 12) << 1;
564 if ( get_bits(gb, 1) /* disp_size_flag */)
566 avctx->width = get_bits(gb, 14);
567 avctx->height = get_bits(gb, 14);
571 if ( get_bits(gb, 1) /* aspect_ratio_flag */)
573 aspect_ratio = get_bits(gb, 4); //SAR
574 if (aspect_ratio == 0x0F) //FF_ASPECT_EXTENDED
576 avctx->sample_aspect_ratio.num = 1 + get_bits(gb, 8);
577 avctx->sample_aspect_ratio.den = 1 + get_bits(gb, 8);
579 else if (aspect_ratio == 0x0E)
581 av_log(avctx, AV_LOG_DEBUG, "Reserved AR found\n");
585 avctx->sample_aspect_ratio = vc9_pixel_aspect[aspect_ratio];
591 avctx->coded_width = avctx->width;
592 avctx->coded_height = avctx->height;
596 if ( get_bits(gb, 1) /* framerateflag */)
598 if ( !get_bits(gb, 1) /* framerateind */)
600 nr = get_bits(gb, 8);
601 dr = get_bits(gb, 4);
604 av_log(avctx, AV_LOG_ERROR, "0 is forbidden for FRAMERATENR\n");
609 av_log(avctx, AV_LOG_ERROR,
610 "Reserved FRAMERATENR %i not handled\n", nr);
611 nr = 5; /* overflow protection */
615 av_log(avctx, AV_LOG_ERROR, "0 is forbidden for FRAMERATEDR\n");
620 av_log(avctx, AV_LOG_ERROR,
621 "Reserved FRAMERATEDR %i not handled\n", dr);
622 dr = 2; /* overflow protection */
624 avctx->time_base.num = fps_nr[dr - 1];
625 avctx->time_base.den = fps_nr[nr - 1];
629 nr = get_bits(gb, 16);
630 // 0.03125->2048Hz / 0.03125Hz
631 avctx->time_base.den = 1000000;
632 avctx->time_base.num = 31250*(1+nr);
637 if ( get_bits(gb, 1) /* color_format_flag */)
639 //Chromacity coordinates of color primaries
640 //like ITU-R BT.709-2, BT.470-2, ...
641 v->color_prim = get_bits(gb, 8);
644 av_log(avctx, AV_LOG_ERROR, "0 for COLOR_PRIM is forbidden\n");
647 if (v->color_prim == 3 || v->color_prim>6)
649 av_log(avctx, AV_LOG_DEBUG, "Reserved COLOR_PRIM %i found\n",
654 //Opto-electronic transfer characteristics
655 v->transfer_char = get_bits(gb, 8);
656 if (v->transfer_char < 1)
658 av_log(avctx, AV_LOG_ERROR, "0 for TRAMSFER_CHAR is forbidden\n");
661 if (v->transfer_char == 3 || v->transfer_char>8)
663 av_log(avctx, AV_LOG_DEBUG, "Reserved TRANSFERT_CHAR %i found\n",
668 //Matrix coefficient for primariev->YCbCr
669 v->matrix_coef = get_bits(gb, 8);
670 if (v->matrix_coef < 1)
672 av_log(avctx, AV_LOG_ERROR, "0 for MATRIX_COEF is forbidden\n");
675 if ((v->matrix_coef > 2 && v->matrix_coef < 6) || v->matrix_coef > 7)
677 av_log(avctx, AV_LOG_DEBUG, "Reserved MATRIX_COEF %i found\n",
683 //Hypothetical reference decoder indicator flag
684 v->hrd_param_flag = get_bits(gb, 1);
685 if (v->hrd_param_flag)
687 if (decode_hrd(v, gb) < 0) return -1;
690 /*reset scaling ranges, 6.2.2 & 6.2.3, p33*/
691 v->range_mapy_flag = 0;
692 v->range_mapuv_flag = 0;
694 av_log(avctx, AV_LOG_DEBUG, "Advanced profile not supported yet\n");
700 * Decode Simple/Main Profiles sequence header
701 * @see Figure 7-8, p16-17
702 * @param avctx Codec context
703 * @param gb GetBit context initialized from Codec context extra_data
706 static int decode_sequence_header(AVCodecContext *avctx, GetBitContext *gb)
708 VC9Context *v = avctx->priv_data;
710 av_log(avctx, AV_LOG_DEBUG, "Header: %0X\n", show_bits(gb, 32));
711 v->profile = get_bits(gb, 2);
714 av_log(avctx, AV_LOG_ERROR, "Profile value 2 is forbidden\n");
718 #if HAS_ADVANCED_PROFILE
719 if (v->profile == PROFILE_ADVANCED)
721 v->level = get_bits(gb, 3);
724 av_log(avctx, AV_LOG_ERROR, "Reserved LEVEL %i\n",v->level);
726 v->chromaformat = get_bits(gb, 2);
727 if (v->chromaformat != 1)
729 av_log(avctx, AV_LOG_ERROR,
730 "Only 4:2:0 chroma format supported\n");
737 v->res_sm = get_bits(gb, 2); //reserved
740 av_log(avctx, AV_LOG_ERROR,
741 "Reserved RES_SM=%i is forbidden\n", v->res_sm);
747 v->frmrtq_postproc = get_bits(gb, 3); //common
748 // (bitrate-32kbps)/64kbps
749 v->bitrtq_postproc = get_bits(gb, 5); //common
750 v->s.loop_filter = get_bits(gb, 1); //common
751 if(v->s.loop_filter == 1 && v->profile == PROFILE_SIMPLE)
753 av_log(avctx, AV_LOG_ERROR,
754 "LOOPFILTER shell not be enabled in simple profile\n");
757 #if HAS_ADVANCED_PROFILE
758 if (v->profile < PROFILE_ADVANCED)
761 v->res_x8 = get_bits(gb, 1); //reserved
764 av_log(avctx, AV_LOG_ERROR,
765 "1 for reserved RES_X8 is forbidden\n");
768 v->multires = get_bits(gb, 1);
769 v->res_fasttx = get_bits(gb, 1);
772 av_log(avctx, AV_LOG_ERROR,
773 "0 for reserved RES_FASTTX is forbidden\n");
778 v->fastuvmc = get_bits(gb, 1); //common
779 if (!v->profile && !v->fastuvmc)
781 av_log(avctx, AV_LOG_ERROR,
782 "FASTUVMC unavailable in Simple Profile\n");
785 v->extended_mv = get_bits(gb, 1); //common
786 if (!v->profile && v->extended_mv)
788 av_log(avctx, AV_LOG_ERROR,
789 "Extended MVs unavailable in Simple Profile\n");
792 v->dquant = get_bits(gb, 2); //common
793 v->vstransform = get_bits(gb, 1); //common
795 #if HAS_ADVANCED_PROFILE
796 if (v->profile < PROFILE_ADVANCED)
799 v->res_transtab = get_bits(gb, 1);
802 av_log(avctx, AV_LOG_ERROR,
803 "1 for reserved RES_TRANSTAB is forbidden\n");
808 v->overlap = get_bits(gb, 1); //common
810 #if HAS_ADVANCED_PROFILE
811 if (v->profile < PROFILE_ADVANCED)
814 v->s.resync_marker = get_bits(gb, 1);
815 v->rangered = get_bits(gb, 1);
816 if (v->rangered && v->profile == PROFILE_SIMPLE)
818 av_log(avctx, AV_LOG_DEBUG,
819 "RANGERED should be set to 0 in simple profile\n");
823 v->s.max_b_frames = avctx->max_b_frames = get_bits(gb, 3); //common
824 v->quantizer_mode = get_bits(gb, 2); //common
826 #if HAS_ADVANCED_PROFILE
827 if (v->profile < PROFILE_ADVANCED)
830 v->finterpflag = get_bits(gb, 1); //common
831 v->res_rtm_flag = get_bits(gb, 1); //reserved
832 if (!v->res_rtm_flag)
834 av_log(avctx, AV_LOG_ERROR,
835 "0 for reserved RES_RTM_FLAG is forbidden\n");
839 av_log(avctx, AV_LOG_INFO,
840 "Profile %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
841 "LoopFilter=%i, MultiRes=%i, FastUVMV=%i, Extended MV=%i\n"
842 "Rangered=%i, VSTransform=%i, Overlap=%i, SyncMarker=%i\n"
843 "DQuant=%i, Quantizer mode=%i, Max B frames=%i\n",
844 v->profile, v->frmrtq_postproc, v->bitrtq_postproc,
845 v->s.loop_filter, v->multires, v->fastuvmc, v->extended_mv,
846 v->rangered, v->vstransform, v->overlap, v->s.resync_marker,
847 v->dquant, v->quantizer_mode, avctx->max_b_frames
852 #if HAS_ADVANCED_PROFILE
853 else return decode_advanced_sequence_header(avctx, gb);
858 #if HAS_ADVANCED_PROFILE
859 /** Entry point decoding (Advanced Profile)
860 * @param avctx Codec context
861 * @param gb GetBit context initialized from avctx->extra_data
864 static int advanced_entry_point_process(AVCodecContext *avctx, GetBitContext *gb)
866 VC9Context *v = avctx->priv_data;
868 if (v->profile != PROFILE_ADVANCED)
870 av_log(avctx, AV_LOG_ERROR,
871 "Entry point are only defined in Advanced Profile!\n");
872 return -1; //Only for advanced profile!
874 if (v->hrd_param_flag)
876 //Update buffer fullness
877 av_log(avctx, AV_LOG_DEBUG, "Buffer fullness update\n");
878 assert(v->hrd_num_leaky_buckets > 0);
879 for (i=0; i<v->hrd_num_leaky_buckets; i++)
880 v->hrd_fullness[i] = get_bits(gb, 8);
882 if ((v->range_mapy_flag = get_bits(gb, 1)))
885 av_log(avctx, AV_LOG_DEBUG, "RANGE_MAPY\n");
886 v->range_mapy = get_bits(gb, 3);
888 if ((v->range_mapuv_flag = get_bits(gb, 1)))
891 av_log(avctx, AV_LOG_DEBUG, "RANGE_MAPUV\n");
892 v->range_mapuv = get_bits(gb, 3);
897 v->numpanscanwin = get_bits(gb, 3);
898 av_log(avctx, AV_LOG_DEBUG, "NUMPANSCANWIN: %u\n", v->numpanscanwin);
904 /***********************************************************************/
906 * @defgroup bitplane VC9 Bitplane decoding
911 /** @addtogroup bitplane
916 #define IMODE_NORM2 1
917 #define IMODE_DIFF2 2
918 #define IMODE_NORM6 3
919 #define IMODE_DIFF6 4
920 #define IMODE_ROWSKIP 5
921 #define IMODE_COLSKIP 6
922 /** @} */ //imode defines
924 /** Allocate the buffer from a bitplane, given its dimensions
925 * @param bp Bitplane which buffer is to allocate
926 * @param[in] width Width of the buffer
927 * @param[in] height Height of the buffer
929 * @todo TODO: Take into account stride
930 * @todo TODO: Allow use of external buffers ?
932 int alloc_bitplane(BitPlane *bp, int width, int height)
934 if (!bp || bp->width<0 || bp->height<0) return -1;
935 bp->data = (uint8_t*)av_malloc(width*height);
936 if (!bp->data) return -1;
937 bp->width = bp->stride = width;
942 /** Free the bitplane's buffer
943 * @param bp Bitplane which buffer is to free
945 void free_bitplane(BitPlane *bp)
947 bp->width = bp->stride = bp->height = 0;
948 if (bp->data) av_freep(&bp->data);
951 /** Decode rows by checking if they are skipped
952 * @param plane Buffer to store decoded bits
953 * @param[in] width Width of this buffer
954 * @param[in] height Height of this buffer
955 * @param[in] stride of this buffer
957 static void decode_rowskip(uint8_t* plane, int width, int height, int stride, GetBitContext *gb){
960 for (y=0; y<height; y++){
961 if (!get_bits(gb, 1)) //rowskip
962 memset(plane, 0, width);
964 for (x=0; x<width; x++)
965 plane[x] = get_bits(gb, 1);
970 /** Decode columns by checking if they are skipped
971 * @param plane Buffer to store decoded bits
972 * @param[in] width Width of this buffer
973 * @param[in] height Height of this buffer
974 * @param[in] stride of this buffer
975 * @fixme FIXME: Optimize
977 static void decode_colskip(uint8_t* plane, int width, int height, int stride, GetBitContext *gb){
980 for (x=0; x<width; x++){
981 if (!get_bits(gb, 1)) //colskip
982 for (y=0; y<height; y++)
985 for (y=0; y<height; y++)
986 plane[y*stride] = get_bits(gb, 1);
991 /** Decode a bitplane's bits
992 * @param bp Bitplane where to store the decode bits
993 * @param v VC9 context for bit reading and logging
995 * @fixme FIXME: Optimize
996 * @todo TODO: Decide if a struct is needed
998 static int bitplane_decoding(BitPlane *bp, VC9Context *v)
1000 GetBitContext *gb = &v->s.gb;
1002 int imode, x, y, code, use_vertical_tile, tile_w, tile_h, offset;
1003 uint8_t invert, *planep = bp->data;
1005 invert = get_bits(gb, 1);
1006 imode = get_vlc2(gb, vc9_imode_vlc.table, VC9_IMODE_VLC_BITS, 2);
1012 //Data is actually read in the MB layer (same for all tests == "raw")
1013 bp->is_raw = 1; //invert ignored
1017 if ((bp->height*bp->width) & 1)
1019 *(++planep) = get_bits(gb, 1);
1022 else offset = x = 0;
1024 for (y=0; y<bp->height; y++)
1026 for(; x<bp->width; x+=2)
1028 code = get_vlc2(gb, vc9_norm2_vlc.table, VC9_NORM2_VLC_BITS, 2);
1029 *(++planep) = code&1; //lsb => left
1030 *(++planep) = (code>>1)&1; //msb => right
1032 planep += bp->stride-bp->width;
1033 if ((bp->width-offset)&1) //Odd number previously processed
1035 code = get_vlc2(gb, vc9_norm2_vlc.table, VC9_NORM2_VLC_BITS, 2);
1037 planep += bp->stride-bp->width;
1038 *planep = (code>>1)&1; //msb => right
1044 planep += bp->stride-bp->width;
1050 use_vertical_tile= bp->height%3==0 && bp->width%3!=0;
1051 tile_w= use_vertical_tile ? 2 : 3;
1052 tile_h= use_vertical_tile ? 3 : 2;
1054 for(y= bp->height%tile_h; y< bp->height; y+=tile_h){
1055 for(x= bp->width%tile_w; x< bp->width; x+=tile_w){
1056 code = get_vlc2(gb, vc9_norm6_vlc.table, VC9_NORM6_VLC_BITS, 2);
1058 av_log(v->s.avctx, AV_LOG_DEBUG, "invalid NORM-6 VLC\n");
1061 //FIXME following is a pure guess and probably wrong
1062 //FIXME A bitplane (0 | !0), so could the shifts be avoided ?
1063 planep[x + 0*bp->stride]= (code>>0)&1;
1064 planep[x + 1 + 0*bp->stride]= (code>>1)&1;
1065 //FIXME Does branch prediction help here?
1066 if(use_vertical_tile){
1067 planep[x + 0 + 1*bp->stride]= (code>>2)&1;
1068 planep[x + 1 + 1*bp->stride]= (code>>3)&1;
1069 planep[x + 0 + 2*bp->stride]= (code>>4)&1;
1070 planep[x + 1 + 2*bp->stride]= (code>>5)&1;
1072 planep[x + 2 + 0*bp->stride]= (code>>2)&1;
1073 planep[x + 0 + 1*bp->stride]= (code>>3)&1;
1074 planep[x + 1 + 1*bp->stride]= (code>>4)&1;
1075 planep[x + 2 + 1*bp->stride]= (code>>5)&1;
1080 x= bp->width % tile_w;
1081 decode_colskip(bp->data , x, bp->height , bp->stride, &v->s.gb);
1082 decode_rowskip(bp->data+x, bp->width - x, bp->height % tile_h, bp->stride, &v->s.gb);
1086 decode_rowskip(bp->data, bp->width, bp->height, bp->stride, &v->s.gb);
1089 decode_colskip(bp->data, bp->width, bp->height, bp->stride, &v->s.gb);
1094 /* Applying diff operator */
1095 if (imode == IMODE_DIFF2 || imode == IMODE_DIFF6)
1098 planep[0] ^= invert;
1099 for (x=1; x<bp->width; x++)
1100 planep[x] ^= planep[x-1];
1101 for (y=1; y<bp->height; y++)
1103 planep += bp->stride;
1104 planep[0] ^= planep[-bp->stride];
1105 for (x=1; x<bp->width; x++)
1107 if (planep[x-1] != planep[x-bp->stride]) planep[x] ^= invert;
1108 else planep[x] ^= planep[x-1];
1115 for (x=0; x<bp->width*bp->height; x++) planep[x] = !planep[x]; //FIXME stride
1117 return (imode<<1) + invert;
1119 /** @} */ //Bitplane group
1121 /***********************************************************************/
1122 /** VOP Dquant decoding
1123 * @param v VC9 Context
1125 static int vop_dquant_decoding(VC9Context *v)
1127 GetBitContext *gb = &v->s.gb;
1133 pqdiff = get_bits(gb, 3);
1134 if (pqdiff == 7) v->altpq = get_bits(gb, 5);
1135 else v->altpq = v->pq + pqdiff + 1;
1139 v->dquantfrm = get_bits(gb, 1);
1142 v->dqprofile = get_bits(gb, 2);
1143 switch (v->dqprofile)
1145 case DQPROFILE_SINGLE_EDGE:
1146 case DQPROFILE_DOUBLE_EDGES:
1147 v->dqsbedge = get_bits(gb, 2);
1149 case DQPROFILE_ALL_MBS:
1150 v->dqbilevel = get_bits(gb, 1);
1151 default: break; //Forbidden ?
1153 if (!v->dqbilevel || v->dqprofile != DQPROFILE_ALL_MBS)
1155 pqdiff = get_bits(gb, 3);
1156 if (pqdiff == 7) v->altpq = get_bits(gb, 5);
1157 else v->altpq = v->pq + pqdiff + 1;
1164 /***********************************************************************/
1166 * @defgroup all_frame_hdr All VC9 profiles frame header
1167 * @brief Part of the frame header decoding from all profiles
1168 * @warning Only pro/epilog differs between Simple/Main and Advanced => check caller
1171 /** B and BI frame header decoding, primary part
1172 * @see Tables 11+12, p62-65
1173 * @param v VC9 context
1175 * @warning Also handles BI frames
1177 static int decode_b_picture_primary_header(VC9Context *v)
1179 GetBitContext *gb = &v->s.gb;
1182 /* Prolog common to all frametypes should be done in caller */
1183 if (v->profile == PROFILE_SIMPLE)
1185 av_log(v->s.avctx, AV_LOG_ERROR, "Found a B frame while in Simple Profile!\n");
1186 return FRAME_SKIPPED;
1188 v->bfraction = vc9_bfraction_lut[get_vlc2(gb, vc9_bfraction_vlc.table,
1189 VC9_BFRACTION_VLC_BITS, 2)];
1190 if (v->bfraction < -1)
1192 av_log(v->s.avctx, AV_LOG_ERROR, "Invalid BFRaction\n");
1193 return FRAME_SKIPPED;
1195 else if (!v->bfraction)
1197 /* We actually have a BI frame */
1198 v->s.pict_type = BI_TYPE;
1199 v->buffer_fullness = get_bits(gb, 7);
1202 /* Read the quantization stuff */
1203 pqindex = get_bits(gb, 5);
1204 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
1205 v->pq = pquant_table[0][pqindex];
1208 v->pq = pquant_table[v->quantizer_mode-1][pqindex];
1210 if (pqindex < 9) v->halfpq = get_bits(gb, 1);
1211 if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
1212 v->pquantizer = get_bits(gb, 1);
1213 #if HAS_ADVANCED_PROFILE
1214 if (v->profile == PROFILE_ADVANCED)
1216 if (v->postprocflag) v->postproc = get_bits(gb, 2);
1217 if (v->extended_mv == 1 && v->s.pict_type != BI_TYPE)
1218 v->mvrange = get_prefix(gb, 0, 3);
1223 if (v->extended_mv == 1)
1224 v->mvrange = get_prefix(gb, 0, 3);
1226 /* Read the MV mode */
1227 if (v->s.pict_type != BI_TYPE)
1229 v->mv_mode = get_bits(gb, 1);
1234 v->mv_mode = get_bits(gb, 2);
1236 av_log(v->s.avctx, AV_LOG_ERROR,
1237 "mv_mode for lowquant B frame was %i\n", v->mv_mode);
1244 if (get_bits(gb, 1))
1245 av_log(v->s.avctx, AV_LOG_ERROR,
1246 "mv_mode for highquant B frame was %i\n", v->mv_mode);
1248 v->mv_mode = 1-v->mv_mode; //To match (pq < 13) mapping
1255 /** B and BI frame header decoding, secondary part
1256 * @see Tables 11+12, p62-65
1257 * @param v VC9 context
1259 * @warning Also handles BI frames
1260 * @warning To call once all MB arrays are allocated
1261 * @todo Support Advanced Profile headers
1263 static int decode_b_picture_secondary_header(VC9Context *v)
1265 GetBitContext *gb = &v->s.gb;
1268 status = bitplane_decoding(&v->skip_mb_plane, v);
1269 if (status < 0) return -1;
1271 if (v->mv_mode == MV_PMODE_MIXED_MV)
1273 status = bitplane_decoding(&v->mv_type_mb_plane, v);
1277 av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
1278 "Imode: %i, Invert: %i\n", status>>1, status&1);
1283 status = bitplane_decoding(&v->direct_mb_plane, v);
1284 if (status < 0) return -1;
1286 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct plane encoding: "
1287 "Imode: %i, Invert: %i\n", status>>1, status&1);
1290 av_log(v->s.avctx, AV_LOG_DEBUG, "Skip MB plane encoding: "
1291 "Imode: %i, Invert: %i\n", status>>1, status&1);
1294 /* FIXME: what is actually chosen for B frames ? */
1295 v->s.mv_table_index = get_bits(gb, 2); //but using vc9_ tables
1296 v->cbpcy_vlc = &vc9_cbpcy_p_vlc[get_bits(gb, 2)];
1300 vop_dquant_decoding(v);
1305 v->ttmbf = get_bits(gb, 1);
1308 v->ttfrm = get_bits(gb, 2);
1309 av_log(v->s.avctx, AV_LOG_INFO, "Transform used: %ix%i\n",
1310 (v->ttfrm & 2) ? 4 : 8, (v->ttfrm & 1) ? 4 : 8);
1313 /* Epilog (AC/DC syntax) should be done in caller */
1317 /** I frame header decoding, primary part
1318 * @see Tables 5+7, p53-54 and 55-57
1319 * @param v VC9 context
1321 * @todo Support Advanced Profile headers
1323 static int decode_i_picture_primary_header(VC9Context *v)
1325 GetBitContext *gb = &v->s.gb;
1328 /* Prolog common to all frametypes should be done in caller */
1329 //BF = Buffer Fullness
1330 if (v->profile < PROFILE_ADVANCED && get_bits(gb, 7))
1332 av_log(v->s.avctx, AV_LOG_DEBUG, "I BufferFullness not 0\n");
1335 /* Quantizer stuff */
1336 pqindex = get_bits(gb, 5);
1337 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
1338 v->pq = pquant_table[0][pqindex];
1341 v->pq = pquant_table[v->quantizer_mode-1][pqindex];
1343 if (pqindex < 9) v->halfpq = get_bits(gb, 1);
1344 if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
1345 v->pquantizer = get_bits(gb, 1);
1346 av_log(v->s.avctx, AV_LOG_DEBUG, "I frame: QP=%i (+%i/2)\n",
1351 /** I frame header decoding, secondary part
1352 * @param v VC9 context
1354 * @warning Not called in A/S/C profiles, it seems
1355 * @todo Support Advanced Profile headers
1357 static int decode_i_picture_secondary_header(VC9Context *v)
1359 #if HAS_ADVANCED_PROFILE
1361 if (v->profile == PROFILE_ADVANCED)
1363 v->s.ac_pred = get_bits(&v->s.gb, 1);
1364 if (v->postprocflag) v->postproc = get_bits(&v->s.gb, 1);
1365 /* 7.1.1.34 + 8.5.2 */
1366 if (v->overlap && v->pq<9)
1368 v->condover = get_bits(&v->s.gb, 1);
1371 v->condover = 2+get_bits(&v->s.gb, 1);
1372 if (v->condover == 3)
1374 status = bitplane_decoding(&v->over_flags_plane, v);
1375 if (status < 0) return -1;
1377 av_log(v->s.avctx, AV_LOG_DEBUG, "Overflags plane encoding: "
1378 "Imode: %i, Invert: %i\n", status>>1, status&1);
1386 /* Epilog (AC/DC syntax) should be done in caller */
1390 /** P frame header decoding, primary part
1391 * @see Tables 5+7, p53-54 and 55-57
1392 * @param v VC9 context
1393 * @todo Support Advanced Profile headers
1396 static int decode_p_picture_primary_header(VC9Context *v)
1398 /* INTERFRM, FRMCNT, RANGEREDFRM read in caller */
1399 GetBitContext *gb = &v->s.gb;
1400 int lowquant, pqindex;
1402 pqindex = get_bits(gb, 5);
1403 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
1404 v->pq = pquant_table[0][pqindex];
1407 v->pq = pquant_table[v->quantizer_mode-1][pqindex];
1409 if (pqindex < 9) v->halfpq = get_bits(gb, 1);
1410 if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
1411 v->pquantizer = get_bits(gb, 1);
1412 av_log(v->s.avctx, AV_LOG_DEBUG, "P Frame: QP=%i (+%i/2)\n",
1414 if (v->extended_mv == 1) v->mvrange = get_prefix(gb, 0, 3);
1415 #if HAS_ADVANCED_PROFILE
1416 if (v->profile == PROFILE_ADVANCED)
1418 if (v->postprocflag) v->postproc = get_bits(gb, 1);
1422 if (v->multires) v->respic = get_bits(gb, 2);
1423 lowquant = (v->pquantizer>12) ? 0 : 1;
1424 v->mv_mode = mv_pmode_table[lowquant][get_prefix(gb, 1, 4)];
1425 if (v->mv_mode == MV_PMODE_INTENSITY_COMP)
1427 v->mv_mode2 = mv_pmode_table[lowquant][get_prefix(gb, 1, 3)];
1428 v->lumscale = get_bits(gb, 6);
1429 v->lumshift = get_bits(gb, 6);
1434 /** P frame header decoding, secondary part
1435 * @see Tables 5+7, p53-54 and 55-57
1436 * @param v VC9 context
1437 * @warning To call once all MB arrays are allocated
1440 static int decode_p_picture_secondary_header(VC9Context *v)
1442 GetBitContext *gb = &v->s.gb;
1444 if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
1445 v->mv_mode2 == MV_PMODE_MIXED_MV)
1446 || v->mv_mode == MV_PMODE_MIXED_MV)
1448 status = bitplane_decoding(&v->mv_type_mb_plane, v);
1449 if (status < 0) return -1;
1451 av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
1452 "Imode: %i, Invert: %i\n", status>>1, status&1);
1456 status = bitplane_decoding(&v->skip_mb_plane, v);
1457 if (status < 0) return -1;
1459 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1460 "Imode: %i, Invert: %i\n", status>>1, status&1);
1463 /* Hopefully this is correct for P frames */
1464 v->s.mv_table_index =get_bits(gb, 2); //but using vc9_ tables
1465 v->cbpcy_vlc = &vc9_cbpcy_p_vlc[get_bits(gb, 2)];
1469 av_log(v->s.avctx, AV_LOG_INFO, "VOP DQuant info\n");
1470 vop_dquant_decoding(v);
1473 v->ttfrm = 0; //FIXME Is that so ?
1476 v->ttmbf = get_bits(gb, 1);
1479 v->ttfrm = get_bits(gb, 2);
1480 av_log(v->s.avctx, AV_LOG_INFO, "Transform used: %ix%i\n",
1481 (v->ttfrm & 2) ? 4 : 8, (v->ttfrm & 1) ? 4 : 8);
1484 /* Epilog (AC/DC syntax) should be done in caller */
1487 /** @} */ //End of group all_frm_hdr
1490 /***********************************************************************/
1492 * @defgroup std_frame_hdr VC9 Simple/Main Profiles header decoding
1493 * @brief Part of the frame header decoding belonging to Simple/Main Profiles
1494 * @warning Only pro/epilog differs between Simple/Main and Advanced =>
1499 /** Frame header decoding, first part, in Simple and Main profiles
1500 * @see Tables 5+7, p53-54 and 55-57
1501 * @param v VC9 context
1502 * @todo FIXME: RANGEREDFRM element not read if BI frame from Table6, P54
1503 * However, 7.1.1.8 says "all frame types, for main profiles"
1506 static int standard_decode_picture_primary_header(VC9Context *v)
1508 GetBitContext *gb = &v->s.gb;
1511 if (v->finterpflag) v->interpfrm = get_bits(gb, 1);
1512 skip_bits(gb, 2); //framecnt unused
1513 if (v->rangered) v->rangeredfrm = get_bits(gb, 1);
1514 v->s.pict_type = get_bits(gb, 1);
1515 if (v->s.avctx->max_b_frames)
1517 if (!v->s.pict_type)
1519 if (get_bits(gb, 1)) v->s.pict_type = I_TYPE;
1520 else v->s.pict_type = B_TYPE;
1522 else v->s.pict_type = P_TYPE;
1524 else v->s.pict_type++;
1526 switch (v->s.pict_type)
1528 case I_TYPE: status = decode_i_picture_primary_header(v); break;
1529 case P_TYPE: status = decode_p_picture_primary_header(v); break;
1530 case BI_TYPE: //Same as B
1531 case B_TYPE: status = decode_b_picture_primary_header(v); break;
1534 if (status == FRAME_SKIPPED)
1536 av_log(v->s.avctx, AV_LOG_INFO, "Skipping frame...\n");
1542 /** Frame header decoding, secondary part
1543 * @param v VC9 context
1544 * @warning To call once all MB arrays are allocated
1547 static int standard_decode_picture_secondary_header(VC9Context *v)
1549 GetBitContext *gb = &v->s.gb;
1552 switch (v->s.pict_type)
1554 case P_TYPE: status = decode_p_picture_secondary_header(v); break;
1555 case B_TYPE: status = decode_b_picture_secondary_header(v); break;
1557 case I_TYPE: break; //Nothing needed as it's done in the epilog
1559 if (status < 0) return FRAME_SKIPPED;
1562 v->c_ac_table_index = decode012(gb);
1563 if (v->s.pict_type == I_TYPE || v->s.pict_type == BI_TYPE)
1565 v->y_ac_table_index = decode012(gb);
1568 v->s.dc_table_index = decode012(gb);
1572 /** @} */ //End for group std_frame_hdr
1574 #if HAS_ADVANCED_PROFILE
1575 /***********************************************************************/
1577 * @defgroup adv_frame_hdr VC9 Advanced Profile header decoding
1578 * @brief Part of the frame header decoding belonging to Advanced Profiles
1579 * @warning Only pro/epilog differs between Simple/Main and Advanced =>
1583 /** Frame header decoding, primary part
1584 * @param v VC9 context
1587 static int advanced_decode_picture_primary_header(VC9Context *v)
1589 GetBitContext *gb = &v->s.gb;
1590 static const int type_table[4] = { P_TYPE, B_TYPE, I_TYPE, BI_TYPE };
1595 v->fcm = get_bits(gb, 1);
1596 if (v->fcm) v->fcm = 2+get_bits(gb, 1);
1599 type = get_prefix(gb, 0, 4);
1600 if (type > 4 || type < 0) return FRAME_SKIPPED;
1601 v->s.pict_type = type_table[type];
1602 av_log(v->s.avctx, AV_LOG_INFO, "AP Frame Type: %i\n", v->s.pict_type);
1604 if (v->tfcntrflag) v->tfcntr = get_bits(gb, 8);
1607 if (!v->interlace) v->rptfrm = get_bits(gb, 2);
1610 v->tff = get_bits(gb, 1);
1611 v->rff = get_bits(gb, 1);
1618 for (i=0; i<v->numpanscanwin; i++)
1620 v->topleftx[i] = get_bits(gb, 16);
1621 v->toplefty[i] = get_bits(gb, 16);
1622 v->bottomrightx[i] = get_bits(gb, 16);
1623 v->bottomrighty[i] = get_bits(gb, 16);
1626 skip_bits(gb, 16*4*v->numpanscanwin);
1629 v->s.no_rounding = !get_bits(gb, 1);
1630 v->uvsamp = get_bits(gb, 1);
1631 if (v->finterpflag == 1) v->interpfrm = get_bits(gb, 1);
1633 switch(v->s.pict_type)
1635 case I_TYPE: if (decode_i_picture_primary_header(v) < 0) return -1;
1636 case P_TYPE: if (decode_p_picture_primary_header(v) < 0) return -1;
1638 case B_TYPE: if (decode_b_picture_primary_header(v) < 0) return FRAME_SKIPPED;
1643 /** Frame header decoding, secondary part
1644 * @param v VC9 context
1647 static int advanced_decode_picture_secondary_header(VC9Context *v)
1649 GetBitContext *gb = &v->s.gb;
1652 switch(v->s.pict_type)
1654 case P_TYPE: status = decode_p_picture_secondary_header(v); break;
1655 case B_TYPE: status = decode_b_picture_secondary_header(v); break;
1657 case I_TYPE: status = decode_i_picture_secondary_header(v); break;
1659 if (status<0) return FRAME_SKIPPED;
1662 v->c_ac_table_index = decode012(gb);
1663 if (v->s.pict_type == I_TYPE || v->s.pict_type == BI_TYPE)
1665 v->y_ac_table_index = decode012(gb);
1668 v->s.dc_table_index = decode012(gb);
1673 /** @} */ //End for adv_frame_hdr
1675 /***********************************************************************/
1677 * @defgroup block VC9 Block-level functions
1678 * @see 7.1.4, p91 and 8.1.1.7, p(1)04
1679 * @todo TODO: Integrate to MpegEncContext facilities
1685 * @brief Get macroblock-level quantizer scale
1686 * @warning XXX: qdiff to the frame quant, not previous quant ?
1687 * @fixme XXX: Don't know how to initialize mquant otherwise in last case
1689 #define GET_MQUANT() \
1692 if (v->dqprofile == DQPROFILE_ALL_MBS) \
1696 mquant = (get_bits(gb, 1)) ? v->pq : v->altpq; \
1700 mqdiff = get_bits(gb, 3); \
1701 if (mqdiff != 7) mquant = v->pq + mqdiff; \
1702 else mquant = get_bits(gb, 5); \
1705 else mquant = v->pq; \
1709 * @def GET_MVDATA(_dmv_x, _dmv_y)
1710 * @brief Get MV differentials
1711 * @see MVDATA decoding from 8.3.5.2, p(1)20
1712 * @param _dmv_x Horizontal differential for decoded MV
1713 * @param _dmv_y Vertical differential for decoded MV
1714 * @todo TODO: Use MpegEncContext arrays to store them
1716 #define GET_MVDATA(_dmv_x, _dmv_y) \
1717 index = 1 + get_vlc2(gb, vc9_mv_diff_vlc[s->mv_table_index].table,\
1718 VC9_MV_DIFF_VLC_BITS, 2); \
1721 mb_has_coeffs = 1; \
1724 else mb_has_coeffs = 0; \
1726 if (!index) { _dmv_x = _dmv_y = 0; } \
1727 else if (index == 35) \
1729 _dmv_x = get_bits(gb, v->k_x); \
1730 _dmv_y = get_bits(gb, v->k_y); \
1736 if (s->mspel && index1 == 5) val = 1; \
1738 val = get_bits(gb, size_table[index1] - val); \
1739 sign = 0 - (val&1); \
1740 _dmv_x = (sign ^ ((val>>1) + offset_table[index1])) - sign; \
1743 if (s->mspel && index1 == 5) val = 1; \
1745 val = get_bits(gb, size_table[index1] - val); \
1746 sign = 0 - (val&1); \
1747 _dmv_y = (sign ^ ((val>>1) + offset_table[index1])) - sign; \
1750 /** Get predicted DC value
1751 * prediction dir: left=0, top=1
1752 * @param s MpegEncContext
1753 * @param[in] n block index in the current MB
1754 * @param dc_val_ptr Pointer to DC predictor
1755 * @param dir_ptr Prediction direction for use in AC prediction
1756 * @todo TODO: Actually do it the VC9 way
1757 * @todo TODO: Handle properly edges
1759 static inline int vc9_pred_dc(MpegEncContext *s, int n,
1760 uint16_t **dc_val_ptr, int *dir_ptr)
1762 int a, b, c, wrap, pred, scale;
1764 static const uint16_t dcpred[31] = {
1765 1024, 512, 341, 256, 205, 171, 146, 128,
1766 114, 102, 93, 85, 79, 73, 68, 64,
1767 60, 57, 54, 51, 49, 47, 45, 43,
1768 41, 39, 38, 37, 35, 34, 33
1771 /* find prediction - wmv3_dc_scale always used here in fact */
1772 if (n < 4) scale = s->y_dc_scale;
1773 else scale = s->c_dc_scale;
1775 wrap = s->block_wrap[n];
1776 dc_val= s->dc_val[0] + s->block_index[n];
1782 b = dc_val[ - 1 - wrap];
1783 c = dc_val[ - wrap];
1785 /* XXX: Rule B is used only for I and BI frames in S/M/C profile
1786 * with overlap filtering off
1788 if ((s->pict_type == I_TYPE || s->pict_type == BI_TYPE) &&
1789 1 /* XXX: overlap filtering off */)
1791 /* Set outer values */
1792 if (s->first_slice_line && n!=2) b=c=dcpred[scale];
1793 if (s->mb_x == 0) b=a=dcpred[scale];
1797 /* Set outer values */
1798 if (s->first_slice_line && n!=2) b=c=0;
1799 if (s->mb_x == 0) b=a=0;
1801 /* XXX: Rule A needs to know if blocks are inter or intra :/ */
1804 /* update predictor */
1805 *dc_val_ptr = &dc_val[0];
1811 if (abs(a - b) <= abs(b - c)) {
1819 /* update predictor */
1820 *dc_val_ptr = &dc_val[0];
1824 /** Decode one block, inter or intra
1825 * @param v The VC9 context
1826 * @param block 8x8 DCT block
1827 * @param n Block index in the current MB (<4=>luma)
1828 * @param coded If the block is coded
1829 * @param mquant Quantizer step for the current block
1830 * @see Inter TT: Table 21, p73 + p91-85
1831 * @see Intra TT: Table 20, p72 + p(1)05-(1)07
1832 * @todo TODO: Process the blocks
1833 * @todo TODO: Use M$ MPEG-4 cbp prediction
1835 int vc9_decode_block(VC9Context *v, DCTELEM block[64], int n, int coded, int mquant)
1837 GetBitContext *gb = &v->s.gb;
1838 MpegEncContext *s = &v->s;
1839 int ttblk; /* Transform Type per Block */
1840 int subblkpat; /* Sub-block Transform Type Pattern */
1841 int dc_pred_dir; /* Direction of the DC prediction used */
1844 /* XXX: Guard against dumb values of mquant */
1845 mquant = (mquant < 1) ? 0 : ( (mquant>31) ? 31 : mquant );
1847 /* Set DC scale - y and c use the same */
1848 s->y_dc_scale = s->y_dc_scale_table[mquant];
1849 s->c_dc_scale = s->c_dc_scale_table[mquant];
1856 /* Get DC differential */
1858 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1860 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1863 av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
1868 if (dcdiff == 119 /* ESC index value */)
1870 /* TODO: Optimize */
1871 if (mquant == 1) dcdiff = get_bits(gb, 10);
1872 else if (mquant == 2) dcdiff = get_bits(gb, 9);
1873 else dcdiff = get_bits(gb, 8);
1878 dcdiff = (dcdiff<<2) + get_bits(gb, 2) - 3;
1879 else if (mquant == 2)
1880 dcdiff = (dcdiff<<1) + get_bits(gb, 1) - 1;
1882 if (get_bits(gb, 1))
1887 dcdiff += vc9_pred_dc(s, n, &dc_val, &dc_pred_dir);
1889 /* Store the quantized DC coeff, used for prediction */
1892 block[0] = dcdiff * s->y_dc_scale;
1894 block[0] = dcdiff * s->c_dc_scale;
1898 //av_log(s->avctx, AV_LOG_ERROR, "DC=%i<0\n", dcdiff);
1914 if (v->ttmb < 8) /* per block */
1915 ttblk = get_vlc2(gb, vc9_ttblk_vlc[v->tt_index].table, VC9_TTBLK_VLC_BITS, 2);
1916 else /* Per frame */
1917 ttblk = 0; //FIXME, depends on ttfrm
1920 if (ttblk == v->ttblk4x4) /* 4x4 transform for that qp value */
1921 subblkpat = 1+get_vlc2(gb, vc9_subblkpat_vlc[v->tt_index].table,
1922 VC9_SUBBLKPAT_VLC_BITS, 2);
1923 else /* All others: 8x8, 4x8, 8x4 */
1924 subblkpat = decode012(gb);
1928 i = 63; //XXX: nothing done yet
1933 mpeg4_pred_ac(s, block, n, dc_pred_dir);
1935 i = 63; /* XXX: not optimal */
1938 if(i>0) i=63; //FIXME/XXX optimize
1939 s->block_last_index[n] = i;
1943 /** @} */ //End for group block
1945 /***********************************************************************/
1947 * @defgroup std_mb VC9 Macroblock-level functions in Simple/Main Profiles
1948 * @see 7.1.4, p91 and 8.1.1.7, p(1)04
1949 * @todo TODO: Integrate to MpegEncContext facilities
1953 static inline int vc9_coded_block_pred(MpegEncContext * s, int n, uint8_t **coded_block_ptr)
1955 int xy, wrap, pred, a, b, c;
1957 xy = s->block_index[n];
1958 wrap = s->b8_stride;
1963 a = s->coded_block[xy - 1 ];
1964 b = s->coded_block[xy - 1 - wrap];
1965 c = s->coded_block[xy - wrap];
1974 *coded_block_ptr = &s->coded_block[xy];
1979 /** Decode one I-frame MB (in Simple/Main profile)
1980 * @todo TODO: Extend to AP
1982 int vc9_decode_i_mb(VC9Context *v, DCTELEM block[6][64])
1986 // uint32_t * const mb_type_ptr= &v->s.current_picture.mb_type[ v->s.mb_x + v->s.mb_y*v->s.mb_stride ];
1989 cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
1990 if (cbp < 0) return -1;
1991 v->s.ac_pred = get_bits(&v->s.gb, 1);
1995 val = ((cbp >> (5 - i)) & 1);
1997 int pred = vc9_coded_block_pred(&v->s, i, &coded_val);
2001 cbp |= val << (5 - i);
2002 if (vc9_decode_block(v, block[i], i, val, v->pq) < 0) //FIXME Should be mquant
2004 av_log(v->s.avctx, AV_LOG_ERROR,
2005 "\nerror while decoding block: %d x %d (%d)\n", v->s.mb_x, v->s.mb_y, i);
2012 /** Decode one P-frame MB (in Simple/Main profile)
2013 * @todo TODO: Extend to AP
2014 * @fixme FIXME: DC value for inter blocks not set
2016 int vc9_decode_p_mb(VC9Context *v, DCTELEM block[6][64])
2018 MpegEncContext *s = &v->s;
2019 GetBitContext *gb = &s->gb;
2020 int i, mb_offset = s->mb_x + s->mb_y*s->mb_width; /* XXX: mb_stride */
2021 int cbp; /* cbp decoding stuff */
2022 int hybrid_pred; /* Prediction types */
2023 int mv_mode_bit = 0;
2024 int mqdiff, mquant; /* MB quantization */
2025 int ttmb; /* MB Transform type */
2029 static const int size_table[6] = { 0, 2, 3, 4, 5, 8 },
2030 offset_table[6] = { 0, 1, 3, 7, 15, 31 };
2031 int mb_has_coeffs = 1; /* last_flag */
2032 int dmv_x, dmv_y; /* Differential MV components */
2033 int index, index1; /* LUT indices */
2034 int val, sign; /* temp values */
2036 mquant = v->pq; /* Loosy initialization */
2038 if (v->mv_type_mb_plane.is_raw)
2039 v->mv_type_mb_plane.data[mb_offset] = get_bits(gb, 1);
2040 if (v->skip_mb_plane.is_raw)
2041 v->skip_mb_plane.data[mb_offset] = get_bits(gb, 1);
2042 if (!mv_mode_bit) /* 1MV mode */
2044 if (!v->skip_mb_plane.data[mb_offset])
2046 GET_MVDATA(dmv_x, dmv_y);
2048 /* hybrid mv pred, 8.3.5.3.4 */
2049 if (v->mv_mode == MV_PMODE_1MV ||
2050 v->mv_mode == MV_PMODE_MIXED_MV)
2051 hybrid_pred = get_bits(gb, 1);
2052 /* FIXME Set DC val for inter block ? */
2053 if (s->mb_intra && !mb_has_coeffs)
2056 s->ac_pred = get_bits(gb, 1);
2057 /* XXX: how to handle cbp ? */
2061 s->coded_block[s->block_index[i]] = 0;
2062 vc9_decode_block(v, block[i], i, 0, mquant);
2066 else if (mb_has_coeffs)
2068 if (s->mb_intra) s->ac_pred = get_bits(gb, 1);
2069 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC9_CBPCY_P_VLC_BITS, 2);
2075 /* XXX: how to handle cbp ? */
2076 /* XXX: how to set values for following predictions ? */
2081 ttmb = get_vlc2(gb, vc9_ttmb_vlc[v->tt_index].table,
2082 VC9_TTMB_VLC_BITS, 12);
2086 val = ((cbp >> (5 - i)) & 1);
2088 int pred = vc9_coded_block_pred(&v->s, i, &coded_val);
2092 vc9_decode_block(v, block[i], i, val, mquant); //FIXME
2097 /* hybrid mv pred, 8.3.5.3.4 */
2098 if (v->mv_mode == MV_PMODE_1MV ||
2099 v->mv_mode == MV_PMODE_MIXED_MV)
2100 hybrid_pred = get_bits(gb, 1);
2108 if (!v->skip_mb_plane.data[mb_offset] /* unskipped MB */)
2111 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC9_CBPCY_P_VLC_BITS, 2);
2114 val = ((cbp >> (5 - i)) & 1);
2116 int pred = vc9_coded_block_pred(&v->s, i, &coded_val);
2122 GET_MVDATA(dmv_x, dmv_y);
2124 if (v->mv_mode == MV_PMODE_MIXED_MV /* Hybrid pred */)
2125 hybrid_pred = get_bits(gb, 1);
2128 if (s->mb_intra /* One of the 4 blocks is intra */ &&
2129 index /* non-zero pred for that block */)
2130 s->ac_pred = get_bits(gb, 1);
2132 ttmb = get_vlc2(gb, vc9_ttmb_vlc[v->tt_index].table,
2133 VC9_TTMB_VLC_BITS, 12);
2134 status = vc9_decode_block(v, block[i], i, val, mquant);
2140 /* XXX: Skipped => cbp=0 and mquant doesn't matter ? */
2143 if (v->mv_mode == MV_PMODE_MIXED_MV /* Hybrid pred */)
2144 hybrid_pred = get_bits(gb, 1);
2145 vc9_decode_block(v, block[i], i, 0, v->pq); //FIXME
2147 vc9_decode_block(v, block[4], 4, 0, v->pq); //FIXME
2148 vc9_decode_block(v, block[5], 5, 0, v->pq); //FIXME
2154 /* Should never happen */
2158 /** Decode one B-frame MB (in Simple/Main profile)
2159 * @todo TODO: Extend to AP
2160 * @warning XXX: Used for decoding BI MBs
2161 * @fixme FIXME: DC value for inter blocks not set
2163 int vc9_decode_b_mb(VC9Context *v, DCTELEM block[6][64])
2165 MpegEncContext *s = &v->s;
2166 GetBitContext *gb = &v->s.gb;
2167 int mb_offset, i /* MB / B postion information */;
2168 int b_mv_type = BMV_TYPE_BACKWARD;
2169 int mquant, mqdiff; /* MB quant stuff */
2170 int ttmb; /* MacroBlock transform type */
2172 static const int size_table[6] = { 0, 2, 3, 4, 5, 8 },
2173 offset_table[6] = { 0, 1, 3, 7, 15, 31 };
2174 int mb_has_coeffs = 1; /* last_flag */
2175 int dmv1_x, dmv1_y, dmv2_x, dmv2_y; /* Differential MV components */
2176 int index, index1; /* LUT indices */
2177 int val, sign; /* MVDATA temp values */
2179 mb_offset = s->mb_width*s->mb_y + s->mb_x; //FIXME: arrays aren't using stride
2181 if (v->direct_mb_plane.is_raw)
2182 v->direct_mb_plane.data[mb_offset] = get_bits(gb, 1);
2183 if (v->skip_mb_plane.is_raw)
2184 v->skip_mb_plane.data[mb_offset] = get_bits(gb, 1);
2186 if (!v->direct_mb_plane.data[mb_offset])
2188 if (v->skip_mb_plane.data[mb_offset])
2190 b_mv_type = decode012(gb);
2191 if (v->bfraction > 420 /*1/2*/ &&
2192 b_mv_type < 3) b_mv_type = 1-b_mv_type;
2196 GET_MVDATA(dmv1_x, dmv1_y);
2197 if (!s->mb_intra /* b_mv1 tells not intra */)
2199 b_mv_type = decode012(gb);
2200 if (v->bfraction > 420 /*1/2*/ &&
2201 b_mv_type < 3) b_mv_type = 1-b_mv_type;
2205 if (!v->skip_mb_plane.data[mb_offset])
2207 if (mb_has_coeffs /* BMV1 == "last" */)
2210 if (s->mb_intra /* intra mb */)
2211 s->ac_pred = get_bits(gb, 1);
2215 /* if bmv1 tells MVs are interpolated */
2216 if (b_mv_type == BMV_TYPE_INTERPOLATED)
2218 GET_MVDATA(dmv2_x, dmv2_y);
2219 mquant = v->pq; //FIXME: initialization not necessary ?
2221 /* GET_MVDATA has reset some stuff */
2222 if (mb_has_coeffs /* b_mv2 == "last" */)
2224 if (s->mb_intra /* intra_mb */)
2225 s->ac_pred = get_bits(gb, 1);
2233 ttmb = get_vlc2(gb, vc9_ttmb_vlc[v->tt_index].table,
2234 VC9_TTMB_VLC_BITS, 12);
2239 vc9_decode_block(v, block[i], i, 0 /*cbp[i]*/, mquant); //FIXME
2244 /** Decode all MBs for an I frame in Simple/Main profile
2245 * @todo TODO: Move out of the loop the picture type case?
2246 (branch prediction should help there though)
2248 static int standard_decode_mbs(VC9Context *v)
2250 MpegEncContext *s = &v->s;
2252 /* Set transform type info depending on pq */
2258 else if (v->pq < 13)
2269 if (s->pict_type != I_TYPE)
2271 /* Select proper long MV range */
2274 case 1: v->k_x = 10; v->k_y = 9; break;
2275 case 2: v->k_x = 12; v->k_y = 10; break;
2276 case 3: v->k_x = 13; v->k_y = 11; break;
2277 default: /*case 0 too */ v->k_x = 9; v->k_y = 8; break;
2280 s->mspel = v->mv_mode & 1; //MV_PMODE is HPEL
2285 for (s->mb_y=0; s->mb_y<s->mb_height; s->mb_y++)
2287 for (s->mb_x=0; s->mb_x<s->mb_width; s->mb_x++)
2289 //FIXME Get proper MB DCTELEM
2290 //TODO Move out of the loop
2291 switch (s->pict_type)
2293 case I_TYPE: vc9_decode_i_mb(v, s->block); break;
2294 case P_TYPE: vc9_decode_p_mb(v, s->block); break;
2296 case B_TYPE: vc9_decode_b_mb(v, s->block); break;
2299 //Add a check for overconsumption ?
2303 /** @} */ //End for group std_mb
2305 #if HAS_ADVANCED_PROFILE
2306 /***********************************************************************/
2308 * @defgroup adv_mb VC9 Macroblock-level functions in Advanced Profile
2309 * @todo TODO: Integrate to MpegEncContext facilities
2310 * @todo TODO: Code P, B and BI
2313 static int advanced_decode_i_mbs(VC9Context *v)
2315 MpegEncContext *s = &v->s;
2316 GetBitContext *gb = &v->s.gb;
2317 int mqdiff, mquant, mb_offset = 0, over_flags_mb = 0;
2319 for (s->mb_y=0; s->mb_y<s->mb_height; s->mb_y++)
2321 for (s->mb_x=0; s->mb_x<s->mb_width; s->mb_x++)
2323 if (v->ac_pred_plane.is_raw)
2324 s->ac_pred = get_bits(gb, 1);
2326 s->ac_pred = v->ac_pred_plane.data[mb_offset];
2327 if (v->condover == 3 && v->over_flags_plane.is_raw)
2328 over_flags_mb = get_bits(gb, 1);
2337 /** @} */ //End for group adv_mb
2340 /** Initialize a VC9/WMV3 decoder
2341 * @todo TODO: Handle VC-9 IDUs (Transport level?)
2342 * @todo TODO: Decypher remaining bits in extra_data
2344 static int vc9_decode_init(AVCodecContext *avctx)
2346 VC9Context *v = avctx->priv_data;
2347 MpegEncContext *s = &v->s;
2350 if (!avctx->extradata_size || !avctx->extradata) return -1;
2351 avctx->pix_fmt = PIX_FMT_YUV420P;
2354 if(ff_h263_decode_init(avctx) < 0)
2356 if (vc9_init_common(v) < 0) return -1;
2358 av_log(avctx, AV_LOG_INFO, "This decoder is not supposed to produce picture. Dont report this as a bug!\n");
2360 avctx->coded_width = avctx->width;
2361 avctx->coded_height = avctx->height;
2362 if (avctx->codec_id == CODEC_ID_WMV3)
2366 // looks like WMV3 has a sequence header stored in the extradata
2367 // advanced sequence header may be before the first frame
2368 // the last byte of the extradata is a version number, 1 for the
2369 // samples we can decode
2371 init_get_bits(&gb, avctx->extradata, avctx->extradata_size*8);
2373 if (decode_sequence_header(avctx, &gb) < 0)
2376 count = avctx->extradata_size*8 - get_bits_count(&gb);
2379 av_log(avctx, AV_LOG_INFO, "Extra data: %i bits left, value: %X\n",
2380 count, get_bits(&gb, count));
2384 av_log(avctx, AV_LOG_INFO, "Read %i bits in overflow\n", -count);
2387 avctx->has_b_frames= !!(avctx->max_b_frames);
2389 s->mb_width = (avctx->coded_width+15)>>4;
2390 s->mb_height = (avctx->coded_height+15)>>4;
2392 /* Allocate mb bitplanes */
2393 if (alloc_bitplane(&v->mv_type_mb_plane, s->mb_width, s->mb_height) < 0)
2395 if (alloc_bitplane(&v->mv_type_mb_plane, s->mb_width, s->mb_height) < 0)
2397 if (alloc_bitplane(&v->skip_mb_plane, s->mb_width, s->mb_height) < 0)
2399 if (alloc_bitplane(&v->direct_mb_plane, s->mb_width, s->mb_height) < 0)
2402 /* For predictors */
2403 v->previous_line_cbpcy = (uint8_t *)av_malloc(s->mb_stride*4);
2404 if (!v->previous_line_cbpcy) return -1;
2406 #if HAS_ADVANCED_PROFILE
2407 if (v->profile == PROFILE_ADVANCED)
2409 if (alloc_bitplane(&v->over_flags_plane, s->mb_width, s->mb_height) < 0)
2411 if (alloc_bitplane(&v->ac_pred_plane, s->mb_width, s->mb_height) < 0)
2419 /** Decode a VC9/WMV3 frame
2420 * @todo TODO: Handle VC-9 IDUs (Transport level?)
2421 * @warning Initial try at using MpegEncContext stuff
2423 static int vc9_decode_frame(AVCodecContext *avctx,
2424 void *data, int *data_size,
2425 uint8_t *buf, int buf_size)
2427 VC9Context *v = avctx->priv_data;
2428 MpegEncContext *s = &v->s;
2429 int ret = FRAME_SKIPPED, len;
2430 AVFrame *pict = data;
2434 //buf_size = 0 -> last frame
2435 if (!buf_size) return 0;
2437 len = avpicture_get_size(avctx->pix_fmt, avctx->width,
2439 tmp_buf = (uint8_t *)av_mallocz(len);
2440 avpicture_fill((AVPicture *)pict, tmp_buf, avctx->pix_fmt,
2441 avctx->width, avctx->height);
2443 if (avctx->codec_id == CODEC_ID_VC9)
2451 while (i < buf_size)
2453 for (; i < buf_size && scp != 0x000001; i++)
2454 scp = ((scp<<8)|buf[i])&0xffffff;
2456 if (scp != 0x000001)
2461 init_get_bits(gb, buf+i, (buf_size-i)*8);
2465 case 0x0A: //Sequence End Code
2467 case 0x0B: //Slice Start Code
2468 av_log(avctx, AV_LOG_ERROR, "Slice coding not supported\n");
2470 case 0x0C: //Field start code
2471 av_log(avctx, AV_LOG_ERROR, "Interlaced coding not supported\n");
2473 case 0x0D: //Frame start code
2475 case 0x0E: //Entry point Start Code
2476 if (v->profile < PROFILE_ADVANCED)
2477 av_log(avctx, AV_LOG_ERROR,
2478 "Found an entry point in profile %i\n", v->profile);
2479 advanced_entry_point_process(avctx, gb);
2481 case 0x0F: //Sequence header Start Code
2482 decode_sequence_header(avctx, gb);
2485 av_log(avctx, AV_LOG_ERROR,
2486 "Unsupported IDU suffix %lX\n", scs);
2489 i += get_bits_count(gb)*8;
2496 init_get_bits(&v->s.gb, buf, buf_size*8);
2498 s->flags= avctx->flags;
2499 s->flags2= avctx->flags2;
2501 /* no supplementary picture */
2502 if (buf_size == 0) {
2503 /* special case for last picture */
2504 if (s->low_delay==0 && s->next_picture_ptr) {
2505 *pict= *(AVFrame*)s->next_picture_ptr;
2506 s->next_picture_ptr= NULL;
2508 *data_size = sizeof(AVFrame);
2514 //No IDU - we mimic ff_h263_decode_frame
2515 s->bitstream_buffer_size=0;
2517 if (!s->context_initialized) {
2518 if (MPV_common_init(s) < 0) //we need the idct permutaton for reading a custom matrix
2522 //we need to set current_picture_ptr before reading the header, otherwise we cant store anyting im there
2523 if(s->current_picture_ptr==NULL || s->current_picture_ptr->data[0]){
2524 s->current_picture_ptr= &s->picture[ff_find_unused_picture(s, 0)];
2526 #if HAS_ADVANCED_PROFILE
2527 if (v->profile == PROFILE_ADVANCED)
2528 ret= advanced_decode_picture_primary_header(v);
2531 ret= standard_decode_picture_primary_header(v);
2532 if (ret == FRAME_SKIPPED) return buf_size;
2533 /* skip if the header was thrashed */
2535 av_log(s->avctx, AV_LOG_ERROR, "header damaged\n");
2539 //No bug workaround yet, no DCT conformance
2541 //WMV9 does have resized images
2542 if (v->profile < PROFILE_ADVANCED && v->multires){
2543 //Parse context stuff in here, don't know how appliable it is
2545 //Not sure about context initialization
2548 s->current_picture.pict_type= s->pict_type;
2549 s->current_picture.key_frame= s->pict_type == I_TYPE;
2551 /* skip b frames if we dont have reference frames */
2552 if(s->last_picture_ptr==NULL && (s->pict_type==B_TYPE || s->dropable))
2553 return buf_size; //FIXME simulating all buffer consumed
2554 /* skip b frames if we are in a hurry */
2555 if(avctx->hurry_up && s->pict_type==B_TYPE)
2556 return buf_size; //FIXME simulating all buffer consumed
2557 /* skip everything if we are in a hurry>=5 */
2558 if(avctx->hurry_up>=5)
2559 return buf_size; //FIXME simulating all buffer consumed
2561 if(s->next_p_frame_damaged){
2562 if(s->pict_type==B_TYPE)
2563 return buf_size; //FIXME simulating all buffer consumed
2565 s->next_p_frame_damaged=0;
2568 if(MPV_frame_start(s, avctx) < 0)
2571 ff_er_frame_start(s);
2573 //wmv9 may or may not have skip bits
2574 #if HAS_ADVANCED_PROFILE
2575 if (v->profile == PROFILE_ADVANCED)
2576 ret= advanced_decode_picture_secondary_header(v);
2579 ret = standard_decode_picture_secondary_header(v);
2580 if (ret<0) return FRAME_SKIPPED; //FIXME Non fatal for now
2582 //We consider the image coded in only one slice
2583 #if HAS_ADVANCED_PROFILE
2584 if (v->profile == PROFILE_ADVANCED)
2586 switch(s->pict_type)
2588 case I_TYPE: ret = advanced_decode_i_mbs(v); break;
2589 case P_TYPE: ret = decode_p_mbs(v); break;
2591 case BI_TYPE: ret = decode_b_mbs(v); break;
2592 default: ret = FRAME_SKIPPED;
2594 if (ret == FRAME_SKIPPED) return buf_size; //We ignore for now failures
2599 ret = standard_decode_mbs(v);
2600 if (ret == FRAME_SKIPPED) return buf_size;
2607 assert(s->current_picture.pict_type == s->current_picture_ptr->pict_type);
2608 assert(s->current_picture.pict_type == s->pict_type);
2609 if(s->pict_type==B_TYPE || s->low_delay){
2610 *pict= *(AVFrame*)&s->current_picture;
2611 ff_print_debug_info(s, pict);
2613 *pict= *(AVFrame*)&s->last_picture;
2615 ff_print_debug_info(s, pict);
2618 /* Return the Picture timestamp as the frame number */
2619 /* we substract 1 because it is added on utils.c */
2620 avctx->frame_number = s->picture_number - 1;
2622 /* dont output the last pic after seeking */
2623 if(s->last_picture_ptr || s->low_delay)
2624 *data_size = sizeof(AVFrame);
2626 av_log(avctx, AV_LOG_DEBUG, "Consumed %i/%i bits\n",
2627 get_bits_count(&s->gb), buf_size*8);
2629 /* Fake consumption of all data */
2631 return buf_size; //Number of bytes consumed
2634 /** Close a VC9/WMV3 decoder
2635 * @warning Initial try at using MpegEncContext stuff
2637 static int vc9_decode_end(AVCodecContext *avctx)
2639 VC9Context *v = avctx->priv_data;
2641 #if HAS_ADVANCED_PROFILE
2642 av_freep(&v->hrd_rate);
2643 av_freep(&v->hrd_buffer);
2645 MPV_common_end(&v->s);
2646 free_bitplane(&v->mv_type_mb_plane);
2647 free_bitplane(&v->skip_mb_plane);
2648 free_bitplane(&v->direct_mb_plane);
2652 AVCodec vc9_decoder = {
2665 AVCodec wmv3_decoder = {