ea0ebae0b731edccf515d17a43807acbd96f1415
[libav.git] / libavcodec / vc9.c
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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 *
21 */
22
23 /**
24 * @file vc9.c
25 * VC-9 and WMV3 decoder
26 *
27 * TODO: most AP stuff, optimize, most of MB layer, transform, filtering and motion compensation, etc
28 * TODO: use MPV_ !!
29 */
30 #include "common.h"
31 #include "dsputil.h"
32 #include "avcodec.h"
33 #include "mpegvideo.h"
34 #include "vc9data.h"
35
36 #undef NDEBUG
37 #include <assert.h>
38
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;
44 #define DC_VLC_BITS 9
45 static const uint16_t table_mb_intra[64][2];
46
47 /* Some inhibiting stuff */
48 #define HAS_ADVANCED_PROFILE 0
49 #define TRACE 1
50
51 #if TRACE
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) \
56 { \
57 av_log(v->s.avctx, AV_LOG_ERROR, "Error for " # vlc " (%i)\n", i); \
58 return -1; \
59 }
60 #else
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)
65 #endif
66
67 /** Available Profiles */
68 //@{
69 #define PROFILE_SIMPLE 0
70 #define PROFILE_MAIN 1
71 #define PROFILE_COMPLEX 2 ///< TODO: WMV9 specific
72 #define PROFILE_ADVANCED 3
73 //@}
74
75 /** Sequence quantizer mode */
76 //@{
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
81 //@}
82
83 /** Where quant can be changed */
84 //@{
85 #define DQPROFILE_FOUR_EDGES 0
86 #define DQPROFILE_DOUBLE_EDGES 1
87 #define DQPROFILE_SINGLE_EDGE 2
88 #define DQPROFILE_ALL_MBS 3
89 //@}
90
91 /** @name Where quant can be changed
92 */
93 //@{
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
99 //@}
100
101 /** Which pair of edges is quantized with ALTPQUANT */
102 //@{
103 #define DQDOUBLE_BEDGE_TOPLEFT 0
104 #define DQDOUBLE_BEDGE_TOPRIGHT 1
105 #define DQDOUBLE_BEDGE_BOTTOMRIGHT 2
106 #define DQDOUBLE_BEDGE_BOTTOMLEFT 3
107 //@}
108
109 /** MV modes for P frames */
110 //@{
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
116 //@}
117
118 /** @name MV types for B frames */
119 //@{
120 #define BMV_TYPE_BACKWARD 0
121 #define BMV_TYPE_BACKWARD 0
122 #define BMV_TYPE_FORWARD 1
123 #define BMV_TYPE_INTERPOLATED 3
124 //@}
125
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 }
130 };
131
132 /** One more frame type */
133 #define BI_TYPE 7
134
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
141 },
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
145 },
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
149 }
150 };
151
152 /** @name VC-9 VLC tables and defines
153 * @todo TODO move this into the context
154 */
155 //@{
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];
177 //@}
178
179 /** Bitplane struct
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
184 */
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
191 } BitPlane;
192
193 /** The VC9 Context
194 * @fixme Change size wherever another size is more efficient
195 * Many members are only used for Advanced Profile
196 */
197 typedef struct VC9Context{
198 MpegEncContext s;
199
200 /** Simple/Main Profile sequence header */
201 //@{
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
208 ///< at frame level
209 int res_rtm_flag; ///< reserved, set to 1
210 int reserved; ///< reserved
211 //@}
212
213 #if HAS_ADVANCED_PROFILE
214 /** Advanced Profile */
215 //@{
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
229 //@}
230 #endif
231
232
233 /** Sequence header data for all Profiles
234 * TODO: choose between ints, uint8_ts and monobit flags
235 */
236 //@{
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
247 //@}
248
249 /** Frame decoding info for all profiles */
250 //@{
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 */
257 //@{
258 uint8_t dquantfrm;
259 uint8_t dqprofile;
260 uint8_t dqsbedge;
261 uint8_t dqbilevel;
262 //@}
263 /** AC coding set indexes
264 * @see 8.1.1.10, p(1)10
265 */
266 //@{
267 int c_ac_table_index; ///< Chroma index from ACFRM element
268 int y_ac_table_index; ///< Luma index from AC2FRM element
269 //@}
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 */
275 //@{
276 uint8_t lumscale;
277 uint8_t lumshift;
278 //@}
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
283 /** Ranges:
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]
288 */
289 uint8_t mvrange;
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
297
298 /** Frame decoding info for S/M profiles only */
299 //@{
300 uint8_t rangeredfrm; ///< out_sample = CLIP((in_sample-128)*2+128)
301 uint8_t interpfrm;
302 //@}
303
304 #if HAS_ADVANCED_PROFILE
305 /** Frame decoding info for Advanced profile */
306 //@{
307 uint8_t fcm; ///< 0->Progressive, 2->Frame-Interlace, 3->Field-Interlace
308 uint8_t numpanscanwin;
309 uint8_t tfcntr;
310 uint8_t rptfrm, tff, rff;
311 uint16_t topleftx;
312 uint16_t toplefty;
313 uint16_t bottomrightx;
314 uint16_t bottomrighty;
315 uint8_t uvsamp;
316 uint8_t postproc;
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
322 uint8_t condover;
323 uint16_t *hrd_rate, *hrd_buffer;
324 uint8_t *hrd_fullness;
325 uint8_t range_mapy_flag;
326 uint8_t range_mapuv_flag;
327 uint8_t range_mapy;
328 uint8_t range_mapuv;
329 //@}
330 #endif
331 } VC9Context;
332
333 /**
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
340 */
341 static int get_prefix(GetBitContext *gb, int stop, int len)
342 {
343 #if 1
344 int i = 0, tmp = !stop;
345
346 while (i != len && tmp != stop)
347 {
348 tmp = get_bits(gb, 1);
349 i++;
350 }
351 if (i == len && tmp != stop) return len+1;
352 return i;
353 #else
354 unsigned int buf;
355 int log;
356
357 OPEN_READER(re, gb);
358 UPDATE_CACHE(re, gb);
359 buf=GET_CACHE(re, gb); //Still not sure
360 if (stop) buf = ~buf;
361
362 log= av_log2(-buf); //FIXME: -?
363 if (log < limit){
364 LAST_SKIP_BITS(re, gb, log+1);
365 CLOSE_READER(re, gb);
366 return log;
367 }
368
369 LAST_SKIP_BITS(re, gb, limit);
370 CLOSE_READER(re, gb);
371 return limit;
372 #endif
373 }
374
375 /**
376 * Init VC-9 specific tables and VC9Context members
377 * @param v The VC9Context to initialize
378 * @return Status
379 */
380 static int vc9_init_common(VC9Context *v)
381 {
382 static int done = 0;
383 int i = 0;
384
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;
392 #endif
393
394 /* VLC tables */
395 #if 0 // spec -> actual tables converter
396 for(i=0; i<64; i++){
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");
400 }
401 for(i=0; i<64; i++){
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");
405 }
406 #endif
407 if(!done)
408 {
409 done = 1;
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);
422 for (i=0; i<3; i++)
423 {
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);
433 }
434 for(i=0; i<4; i++)
435 {
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);
445 }
446 }
447
448 /* Other defaults */
449 v->pq = -1;
450 v->mvrange = 0; /* 7.1.1.18, p80 */
451
452 return 0;
453 }
454
455 #if HAS_ADVANCED_PROFILE
456 /**
457 * Decode sequence header's Hypothetic Reference Decoder data
458 * @see 6.2.1, p32
459 * @param v The VC9Context to initialize
460 * @param gb A GetBitContext initialized from AVCodecContext extra_data
461 * @return Status
462 */
463 static int decode_hrd(VC9Context *v, GetBitContext *gb)
464 {
465 int i, num;
466
467 num = 1 + get_bits(gb, 5);
468
469 /*hrd rate*/
470 if (v->hrd_rate || num != v->hrd_num_leaky_buckets)
471 {
472 av_freep(&v->hrd_rate);
473 }
474 if (!v->hrd_rate) v->hrd_rate = av_malloc(num*sizeof(uint16_t));
475 if (!v->hrd_rate) return -1;
476
477 /*hrd buffer*/
478 if (v->hrd_buffer || num != v->hrd_num_leaky_buckets)
479 {
480 av_freep(&v->hrd_buffer);
481 }
482 if (!v->hrd_buffer) v->hrd_buffer = av_malloc(num*sizeof(uint16_t));
483 if (!v->hrd_buffer)
484 {
485 av_freep(&v->hrd_rate);
486 return -1;
487 }
488
489 /*hrd fullness*/
490 if (v->hrd_fullness || num != v->hrd_num_leaky_buckets)
491 {
492 av_freep(&v->hrd_buffer);
493 }
494 if (!v->hrd_fullness) v->hrd_fullness = av_malloc(num*sizeof(uint8_t));
495 if (!v->hrd_fullness)
496 {
497 av_freep(&v->hrd_rate);
498 av_freep(&v->hrd_buffer);
499 return -1;
500 }
501 v->hrd_num_leaky_buckets = num;
502
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);
507
508 for (i=0; i<num; i++)
509 {
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])
513 {
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]);
516 return -1;
517 }
518 v->hrd_buffer[i] = 1 + get_bits(gb, 16);
519 if (i && v->hrd_buffer[i-1]<v->hrd_buffer[i])
520 {
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]);
523 return -1;
524 }
525 }
526 return 0;
527 }
528
529 /**
530 * Decode sequence header for Advanced Profile
531 * @see Table 2, p18
532 * @see 6.1.7, pp21-27
533 * @param v The VC9Context to initialize
534 * @param gb A GetBitContext initialized from AVCodecContext extra_data
535 * @return Status
536 */
537 static int decode_advanced_sequence_header(AVCodecContext *avctx, GetBitContext *gb)
538 {
539 VC9Context *v = avctx->priv_data;
540 int nr, dr, aspect_ratio;
541
542 v->postprocflag = get_bits(gb, 1);
543 v->broadcast = get_bits(gb, 1);
544 v->interlace = get_bits(gb, 1);
545
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);
550 if (v->reserved)
551 {
552 av_log(avctx, AV_LOG_ERROR, "RESERVED should be 0 (is %i)\n",
553 v->reserved);
554 return -1;
555 }
556 if (v->extended_mv)
557 v->extended_dmv = get_bits(gb, 1);
558
559 /* 6.1.7, p21 */
560 if (get_bits(gb, 1) /* pic_size_flag */)
561 {
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 */)
565 {
566 avctx->width = get_bits(gb, 14);
567 avctx->height = get_bits(gb, 14);
568 }
569
570 /* 6.1.7.4, p23 */
571 if ( get_bits(gb, 1) /* aspect_ratio_flag */)
572 {
573 aspect_ratio = get_bits(gb, 4); //SAR
574 if (aspect_ratio == 0x0F) //FF_ASPECT_EXTENDED
575 {
576 avctx->sample_aspect_ratio.num = 1 + get_bits(gb, 8);
577 avctx->sample_aspect_ratio.den = 1 + get_bits(gb, 8);
578 }
579 else if (aspect_ratio == 0x0E)
580 {
581 av_log(avctx, AV_LOG_DEBUG, "Reserved AR found\n");
582 }
583 else
584 {
585 avctx->sample_aspect_ratio = vc9_pixel_aspect[aspect_ratio];
586 }
587 }
588 }
589 else
590 {
591 avctx->coded_width = avctx->width;
592 avctx->coded_height = avctx->height;
593 }
594
595 /* 6.1.8, p23 */
596 if ( get_bits(gb, 1) /* framerateflag */)
597 {
598 if ( !get_bits(gb, 1) /* framerateind */)
599 {
600 nr = get_bits(gb, 8);
601 dr = get_bits(gb, 4);
602 if (nr<1)
603 {
604 av_log(avctx, AV_LOG_ERROR, "0 is forbidden for FRAMERATENR\n");
605 return -1;
606 }
607 if (nr>5)
608 {
609 av_log(avctx, AV_LOG_ERROR,
610 "Reserved FRAMERATENR %i not handled\n", nr);
611 nr = 5; /* overflow protection */
612 }
613 if (dr<1)
614 {
615 av_log(avctx, AV_LOG_ERROR, "0 is forbidden for FRAMERATEDR\n");
616 return -1;
617 }
618 if (dr>2)
619 {
620 av_log(avctx, AV_LOG_ERROR,
621 "Reserved FRAMERATEDR %i not handled\n", dr);
622 dr = 2; /* overflow protection */
623 }
624 avctx->time_base.num = fps_nr[dr - 1];
625 avctx->time_base.den = fps_nr[nr - 1];
626 }
627 else
628 {
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);
633 }
634 }
635
636 /* 6.1.9, p25 */
637 if ( get_bits(gb, 1) /* color_format_flag */)
638 {
639 //Chromacity coordinates of color primaries
640 //like ITU-R BT.709-2, BT.470-2, ...
641 v->color_prim = get_bits(gb, 8);
642 if (v->color_prim<1)
643 {
644 av_log(avctx, AV_LOG_ERROR, "0 for COLOR_PRIM is forbidden\n");
645 return -1;
646 }
647 if (v->color_prim == 3 || v->color_prim>6)
648 {
649 av_log(avctx, AV_LOG_DEBUG, "Reserved COLOR_PRIM %i found\n",
650 v->color_prim);
651 return -1;
652 }
653
654 //Opto-electronic transfer characteristics
655 v->transfer_char = get_bits(gb, 8);
656 if (v->transfer_char < 1)
657 {
658 av_log(avctx, AV_LOG_ERROR, "0 for TRAMSFER_CHAR is forbidden\n");
659 return -1;
660 }
661 if (v->transfer_char == 3 || v->transfer_char>8)
662 {
663 av_log(avctx, AV_LOG_DEBUG, "Reserved TRANSFERT_CHAR %i found\n",
664 v->color_prim);
665 return -1;
666 }
667
668 //Matrix coefficient for primariev->YCbCr
669 v->matrix_coef = get_bits(gb, 8);
670 if (v->matrix_coef < 1)
671 {
672 av_log(avctx, AV_LOG_ERROR, "0 for MATRIX_COEF is forbidden\n");
673 return -1;
674 }
675 if ((v->matrix_coef > 2 && v->matrix_coef < 6) || v->matrix_coef > 7)
676 {
677 av_log(avctx, AV_LOG_DEBUG, "Reserved MATRIX_COEF %i found\n",
678 v->color_prim);
679 return -1;
680 }
681 }
682
683 //Hypothetical reference decoder indicator flag
684 v->hrd_param_flag = get_bits(gb, 1);
685 if (v->hrd_param_flag)
686 {
687 if (decode_hrd(v, gb) < 0) return -1;
688 }
689
690 /*reset scaling ranges, 6.2.2 & 6.2.3, p33*/
691 v->range_mapy_flag = 0;
692 v->range_mapuv_flag = 0;
693
694 av_log(avctx, AV_LOG_DEBUG, "Advanced profile not supported yet\n");
695 return -1;
696 }
697 #endif
698
699 /**
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
704 * @return Status
705 */
706 static int decode_sequence_header(AVCodecContext *avctx, GetBitContext *gb)
707 {
708 VC9Context *v = avctx->priv_data;
709
710 av_log(avctx, AV_LOG_DEBUG, "Header: %0X\n", show_bits(gb, 32));
711 v->profile = get_bits(gb, 2);
712 if (v->profile == 2)
713 {
714 av_log(avctx, AV_LOG_ERROR, "Profile value 2 is forbidden\n");
715 return -1;
716 }
717
718 #if HAS_ADVANCED_PROFILE
719 if (v->profile == PROFILE_ADVANCED)
720 {
721 v->level = get_bits(gb, 3);
722 if(v->level >= 5)
723 {
724 av_log(avctx, AV_LOG_ERROR, "Reserved LEVEL %i\n",v->level);
725 }
726 v->chromaformat = get_bits(gb, 2);
727 if (v->chromaformat != 1)
728 {
729 av_log(avctx, AV_LOG_ERROR,
730 "Only 4:2:0 chroma format supported\n");
731 return -1;
732 }
733 }
734 else
735 #endif
736 {
737 v->res_sm = get_bits(gb, 2); //reserved
738 if (v->res_sm)
739 {
740 av_log(avctx, AV_LOG_ERROR,
741 "Reserved RES_SM=%i is forbidden\n", v->res_sm);
742 return -1;
743 }
744 }
745
746 // (fps-2)/4 (->30)
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)
752 {
753 av_log(avctx, AV_LOG_ERROR,
754 "LOOPFILTER shell not be enabled in simple profile\n");
755 }
756
757 #if HAS_ADVANCED_PROFILE
758 if (v->profile < PROFILE_ADVANCED)
759 #endif
760 {
761 v->res_x8 = get_bits(gb, 1); //reserved
762 if (v->res_x8)
763 {
764 av_log(avctx, AV_LOG_ERROR,
765 "1 for reserved RES_X8 is forbidden\n");
766 //return -1;
767 }
768 v->multires = get_bits(gb, 1);
769 v->res_fasttx = get_bits(gb, 1);
770 if (!v->res_fasttx)
771 {
772 av_log(avctx, AV_LOG_ERROR,
773 "0 for reserved RES_FASTTX is forbidden\n");
774 //return -1;
775 }
776 }
777
778 v->fastuvmc = get_bits(gb, 1); //common
779 if (!v->profile && !v->fastuvmc)
780 {
781 av_log(avctx, AV_LOG_ERROR,
782 "FASTUVMC unavailable in Simple Profile\n");
783 return -1;
784 }
785 v->extended_mv = get_bits(gb, 1); //common
786 if (!v->profile && v->extended_mv)
787 {
788 av_log(avctx, AV_LOG_ERROR,
789 "Extended MVs unavailable in Simple Profile\n");
790 return -1;
791 }
792 v->dquant = get_bits(gb, 2); //common
793 v->vstransform = get_bits(gb, 1); //common
794
795 #if HAS_ADVANCED_PROFILE
796 if (v->profile < PROFILE_ADVANCED)
797 #endif
798 {
799 v->res_transtab = get_bits(gb, 1);
800 if (v->res_transtab)
801 {
802 av_log(avctx, AV_LOG_ERROR,
803 "1 for reserved RES_TRANSTAB is forbidden\n");
804 return -1;
805 }
806 }
807
808 v->overlap = get_bits(gb, 1); //common
809
810 #if HAS_ADVANCED_PROFILE
811 if (v->profile < PROFILE_ADVANCED)
812 #endif
813 {
814 v->s.resync_marker = get_bits(gb, 1);
815 v->rangered = get_bits(gb, 1);
816 if (v->rangered && v->profile == PROFILE_SIMPLE)
817 {
818 av_log(avctx, AV_LOG_DEBUG,
819 "RANGERED should be set to 0 in simple profile\n");
820 }
821 }
822
823 v->s.max_b_frames = avctx->max_b_frames = get_bits(gb, 3); //common
824 v->quantizer_mode = get_bits(gb, 2); //common
825
826 #if HAS_ADVANCED_PROFILE
827 if (v->profile < PROFILE_ADVANCED)
828 #endif
829 {
830 v->finterpflag = get_bits(gb, 1); //common
831 v->res_rtm_flag = get_bits(gb, 1); //reserved
832 if (!v->res_rtm_flag)
833 {
834 av_log(avctx, AV_LOG_ERROR,
835 "0 for reserved RES_RTM_FLAG is forbidden\n");
836 //return -1;
837 }
838 #if TRACE
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
848 );
849 return 0;
850 #endif
851 }
852 #if HAS_ADVANCED_PROFILE
853 else return decode_advanced_sequence_header(avctx, gb);
854 #endif
855 }
856
857
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
862 * @return Status
863 */
864 static int advanced_entry_point_process(AVCodecContext *avctx, GetBitContext *gb)
865 {
866 VC9Context *v = avctx->priv_data;
867 int i;
868 if (v->profile != PROFILE_ADVANCED)
869 {
870 av_log(avctx, AV_LOG_ERROR,
871 "Entry point are only defined in Advanced Profile!\n");
872 return -1; //Only for advanced profile!
873 }
874 if (v->hrd_param_flag)
875 {
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);
881 }
882 if ((v->range_mapy_flag = get_bits(gb, 1)))
883 {
884 //RANGE_MAPY
885 av_log(avctx, AV_LOG_DEBUG, "RANGE_MAPY\n");
886 v->range_mapy = get_bits(gb, 3);
887 }
888 if ((v->range_mapuv_flag = get_bits(gb, 1)))
889 {
890 //RANGE_MAPUV
891 av_log(avctx, AV_LOG_DEBUG, "RANGE_MAPUV\n");
892 v->range_mapuv = get_bits(gb, 3);
893 }
894 if (v->panscanflag)
895 {
896 //NUMPANSCANWIN
897 v->numpanscanwin = get_bits(gb, 3);
898 av_log(avctx, AV_LOG_DEBUG, "NUMPANSCANWIN: %u\n", v->numpanscanwin);
899 }
900 return 0;
901 }
902 #endif
903
904 /***********************************************************************/
905 /**
906 * @defgroup bitplane VC9 Bitplane decoding
907 * @see 8.7, p56
908 * @{
909 */
910
911 /** @addtogroup bitplane
912 * Imode types
913 * @{
914 */
915 #define IMODE_RAW 0
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
923
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
928 * @return Status
929 * @todo TODO: Take into account stride
930 * @todo TODO: Allow use of external buffers ?
931 */
932 int alloc_bitplane(BitPlane *bp, int width, int height)
933 {
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;
938 bp->height = height;
939 return 0;
940 }
941
942 /** Free the bitplane's buffer
943 * @param bp Bitplane which buffer is to free
944 */
945 void free_bitplane(BitPlane *bp)
946 {
947 bp->width = bp->stride = bp->height = 0;
948 if (bp->data) av_freep(&bp->data);
949 }
950
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
956 */
957 static void decode_rowskip(uint8_t* plane, int width, int height, int stride, GetBitContext *gb){
958 int x, y;
959
960 for (y=0; y<height; y++){
961 if (!get_bits(gb, 1)) //rowskip
962 memset(plane, 0, width);
963 else
964 for (x=0; x<width; x++)
965 plane[x] = get_bits(gb, 1);
966 plane += stride;
967 }
968 }
969
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
976 */
977 static void decode_colskip(uint8_t* plane, int width, int height, int stride, GetBitContext *gb){
978 int x, y;
979
980 for (x=0; x<width; x++){
981 if (!get_bits(gb, 1)) //colskip
982 for (y=0; y<height; y++)
983 plane[y*stride] = 0;
984 else
985 for (y=0; y<height; y++)
986 plane[y*stride] = get_bits(gb, 1);
987 plane ++;
988 }
989 }
990
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
994 * @return Status
995 * @fixme FIXME: Optimize
996 * @todo TODO: Decide if a struct is needed
997 */
998 static int bitplane_decoding(BitPlane *bp, VC9Context *v)
999 {
1000 GetBitContext *gb = &v->s.gb;
1001
1002 int imode, x, y, code, use_vertical_tile, tile_w, tile_h, offset;
1003 uint8_t invert, *planep = bp->data;
1004
1005 invert = get_bits(gb, 1);
1006 imode = get_vlc2(gb, vc9_imode_vlc.table, VC9_IMODE_VLC_BITS, 2);
1007
1008 bp->is_raw = 0;
1009 switch (imode)
1010 {
1011 case IMODE_RAW:
1012 //Data is actually read in the MB layer (same for all tests == "raw")
1013 bp->is_raw = 1; //invert ignored
1014 return invert;
1015 case IMODE_DIFF2:
1016 case IMODE_NORM2:
1017 if ((bp->height*bp->width) & 1)
1018 {
1019 *(++planep) = get_bits(gb, 1);
1020 offset = x = 1;
1021 }
1022 else offset = x = 0;
1023
1024 for (y=0; y<bp->height; y++)
1025 {
1026 for(; x<bp->width; x+=2)
1027 {
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
1031 }
1032 planep += bp->stride-bp->width;
1033 if ((bp->width-offset)&1) //Odd number previously processed
1034 {
1035 code = get_vlc2(gb, vc9_norm2_vlc.table, VC9_NORM2_VLC_BITS, 2);
1036 *planep = code&1;
1037 planep += bp->stride-bp->width;
1038 *planep = (code>>1)&1; //msb => right
1039 offset = x = 1;
1040 }
1041 else
1042 {
1043 offset = x = 0;
1044 planep += bp->stride-bp->width;
1045 }
1046 }
1047 break;
1048 case IMODE_DIFF6:
1049 case IMODE_NORM6:
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;
1053
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);
1057 if(code<0){
1058 av_log(v->s.avctx, AV_LOG_DEBUG, "invalid NORM-6 VLC\n");
1059 return -1;
1060 }
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;
1071 }else{
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;
1076 }
1077 }
1078 }
1079
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);
1083
1084 break;
1085 case IMODE_ROWSKIP:
1086 decode_rowskip(bp->data, bp->width, bp->height, bp->stride, &v->s.gb);
1087 break;
1088 case IMODE_COLSKIP:
1089 decode_colskip(bp->data, bp->width, bp->height, bp->stride, &v->s.gb);
1090 break;
1091 default: break;
1092 }
1093
1094 /* Applying diff operator */
1095 if (imode == IMODE_DIFF2 || imode == IMODE_DIFF6)
1096 {
1097 planep = bp->data;
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++)
1102 {
1103 planep += bp->stride;
1104 planep[0] ^= planep[-bp->stride];
1105 for (x=1; x<bp->width; x++)
1106 {
1107 if (planep[x-1] != planep[x-bp->stride]) planep[x] ^= invert;
1108 else planep[x] ^= planep[x-1];
1109 }
1110 }
1111 }
1112 else if (invert)
1113 {
1114 planep = bp->data;
1115 for (x=0; x<bp->width*bp->height; x++) planep[x] = !planep[x]; //FIXME stride
1116 }
1117 return (imode<<1) + invert;
1118 }
1119 /** @} */ //Bitplane group
1120
1121 /***********************************************************************/
1122 /** VOP Dquant decoding
1123 * @param v VC9 Context
1124 */
1125 static int vop_dquant_decoding(VC9Context *v)
1126 {
1127 GetBitContext *gb = &v->s.gb;
1128 int pqdiff;
1129
1130 //variable size
1131 if (v->dquant == 2)
1132 {
1133 pqdiff = get_bits(gb, 3);
1134 if (pqdiff == 7) v->altpq = get_bits(gb, 5);
1135 else v->altpq = v->pq + pqdiff + 1;
1136 }
1137 else
1138 {
1139 v->dquantfrm = get_bits(gb, 1);
1140 if ( v->dquantfrm )
1141 {
1142 v->dqprofile = get_bits(gb, 2);
1143 switch (v->dqprofile)
1144 {
1145 case DQPROFILE_SINGLE_EDGE:
1146 case DQPROFILE_DOUBLE_EDGES:
1147 v->dqsbedge = get_bits(gb, 2);
1148 break;
1149 case DQPROFILE_ALL_MBS:
1150 v->dqbilevel = get_bits(gb, 1);
1151 default: break; //Forbidden ?
1152 }
1153 if (!v->dqbilevel || v->dqprofile != DQPROFILE_ALL_MBS)
1154 {
1155 pqdiff = get_bits(gb, 3);
1156 if (pqdiff == 7) v->altpq = get_bits(gb, 5);
1157 else v->altpq = v->pq + pqdiff + 1;
1158 }
1159 }
1160 }
1161 return 0;
1162 }
1163
1164 /***********************************************************************/
1165 /**
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
1169 * @{
1170 */
1171 /** B and BI frame header decoding, primary part
1172 * @see Tables 11+12, p62-65
1173 * @param v VC9 context
1174 * @return Status
1175 * @warning Also handles BI frames
1176 */
1177 static int decode_b_picture_primary_header(VC9Context *v)
1178 {
1179 GetBitContext *gb = &v->s.gb;
1180 int pqindex;
1181
1182 /* Prolog common to all frametypes should be done in caller */
1183 if (v->profile == PROFILE_SIMPLE)
1184 {
1185 av_log(v->s.avctx, AV_LOG_ERROR, "Found a B frame while in Simple Profile!\n");
1186 return FRAME_SKIPPED;
1187 }
1188 v->bfraction = vc9_bfraction_lut[get_vlc2(gb, vc9_bfraction_vlc.table,
1189 VC9_BFRACTION_VLC_BITS, 2)];
1190 if (v->bfraction < -1)
1191 {
1192 av_log(v->s.avctx, AV_LOG_ERROR, "Invalid BFRaction\n");
1193 return FRAME_SKIPPED;
1194 }
1195 else if (!v->bfraction)
1196 {
1197 /* We actually have a BI frame */
1198 v->s.pict_type = BI_TYPE;
1199 v->buffer_fullness = get_bits(gb, 7);
1200 }
1201
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];
1206 else
1207 {
1208 v->pq = pquant_table[v->quantizer_mode-1][pqindex];
1209 }
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)
1215 {
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);
1219 }
1220 #endif
1221 else
1222 {
1223 if (v->extended_mv == 1)
1224 v->mvrange = get_prefix(gb, 0, 3);
1225 }
1226 /* Read the MV mode */
1227 if (v->s.pict_type != BI_TYPE)
1228 {
1229 v->mv_mode = get_bits(gb, 1);
1230 if (v->pq < 13)
1231 {
1232 if (!v->mv_mode)
1233 {
1234 v->mv_mode = get_bits(gb, 2);
1235 if (v->mv_mode)
1236 av_log(v->s.avctx, AV_LOG_ERROR,
1237 "mv_mode for lowquant B frame was %i\n", v->mv_mode);
1238 }
1239 }
1240 else
1241 {
1242 if (!v->mv_mode)
1243 {
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);
1247 }
1248 v->mv_mode = 1-v->mv_mode; //To match (pq < 13) mapping
1249 }
1250 }
1251
1252 return 0;
1253 }
1254
1255 /** B and BI frame header decoding, secondary part
1256 * @see Tables 11+12, p62-65
1257 * @param v VC9 context
1258 * @return Status
1259 * @warning Also handles BI frames
1260 * @warning To call once all MB arrays are allocated
1261 * @todo Support Advanced Profile headers
1262 */
1263 static int decode_b_picture_secondary_header(VC9Context *v)
1264 {
1265 GetBitContext *gb = &v->s.gb;
1266 int status;
1267
1268 status = bitplane_decoding(&v->skip_mb_plane, v);
1269 if (status < 0) return -1;
1270 #if TRACE
1271 if (v->mv_mode == MV_PMODE_MIXED_MV)
1272 {
1273 status = bitplane_decoding(&v->mv_type_mb_plane, v);
1274 if (status < 0)
1275 return -1;
1276 #if TRACE
1277 av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
1278 "Imode: %i, Invert: %i\n", status>>1, status&1);
1279 #endif
1280 }
1281
1282 //bitplane
1283 status = bitplane_decoding(&v->direct_mb_plane, v);
1284 if (status < 0) return -1;
1285 #if TRACE
1286 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct plane encoding: "
1287 "Imode: %i, Invert: %i\n", status>>1, status&1);
1288 #endif
1289
1290 av_log(v->s.avctx, AV_LOG_DEBUG, "Skip MB plane encoding: "
1291 "Imode: %i, Invert: %i\n", status>>1, status&1);
1292 #endif
1293
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)];
1297
1298 if (v->dquant)
1299 {
1300 vop_dquant_decoding(v);
1301 }
1302
1303 if (v->vstransform)
1304 {
1305 v->ttmbf = get_bits(gb, 1);
1306 if (v->ttmbf)
1307 {
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);
1311 }
1312 }
1313 /* Epilog (AC/DC syntax) should be done in caller */
1314 return 0;
1315 }
1316
1317 /** I frame header decoding, primary part
1318 * @see Tables 5+7, p53-54 and 55-57
1319 * @param v VC9 context
1320 * @return Status
1321 * @todo Support Advanced Profile headers
1322 */
1323 static int decode_i_picture_primary_header(VC9Context *v)
1324 {
1325 GetBitContext *gb = &v->s.gb;
1326 int pqindex;
1327
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))
1331 {
1332 av_log(v->s.avctx, AV_LOG_DEBUG, "I BufferFullness not 0\n");
1333 }
1334
1335 /* Quantizer stuff */
1336 pqindex = get_bits(gb, 5);
1337 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
1338 v->pq = pquant_table[0][pqindex];
1339 else
1340 {
1341 v->pq = pquant_table[v->quantizer_mode-1][pqindex];
1342 }
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",
1347 v->pq, v->halfpq);
1348 return 0;
1349 }
1350
1351 /** I frame header decoding, secondary part
1352 * @param v VC9 context
1353 * @return Status
1354 * @warning Not called in A/S/C profiles, it seems
1355 * @todo Support Advanced Profile headers
1356 */
1357 static int decode_i_picture_secondary_header(VC9Context *v)
1358 {
1359 #if HAS_ADVANCED_PROFILE
1360 int status;
1361 if (v->profile == PROFILE_ADVANCED)
1362 {
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)
1367 {
1368 v->condover = get_bits(&v->s.gb, 1);
1369 if (v->condover)
1370 {
1371 v->condover = 2+get_bits(&v->s.gb, 1);
1372 if (v->condover == 3)
1373 {
1374 status = bitplane_decoding(&v->over_flags_plane, v);
1375 if (status < 0) return -1;
1376 # if TRACE
1377 av_log(v->s.avctx, AV_LOG_DEBUG, "Overflags plane encoding: "
1378 "Imode: %i, Invert: %i\n", status>>1, status&1);
1379 # endif
1380 }
1381 }
1382 }
1383 }
1384 #endif
1385
1386 /* Epilog (AC/DC syntax) should be done in caller */
1387 return 0;
1388 }
1389
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
1394 * @return Status
1395 */
1396 static int decode_p_picture_primary_header(VC9Context *v)
1397 {
1398 /* INTERFRM, FRMCNT, RANGEREDFRM read in caller */
1399 GetBitContext *gb = &v->s.gb;
1400 int lowquant, pqindex;
1401
1402 pqindex = get_bits(gb, 5);
1403 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
1404 v->pq = pquant_table[0][pqindex];
1405 else
1406 {
1407 v->pq = pquant_table[v->quantizer_mode-1][pqindex];
1408 }
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",
1413 v->pq, v->halfpq);
1414 if (v->extended_mv == 1) v->mvrange = get_prefix(gb, 0, 3);
1415 #if HAS_ADVANCED_PROFILE
1416 if (v->profile == PROFILE_ADVANCED)
1417 {
1418 if (v->postprocflag) v->postproc = get_bits(gb, 1);
1419 }
1420 else
1421 #endif
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)
1426 {
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);
1430 }
1431 return 0;
1432 }
1433
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
1438 * @return Status
1439 */
1440 static int decode_p_picture_secondary_header(VC9Context *v)
1441 {
1442 GetBitContext *gb = &v->s.gb;
1443 int status = 0;
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)
1447 {
1448 status = bitplane_decoding(&v->mv_type_mb_plane, v);
1449 if (status < 0) return -1;
1450 #if TRACE
1451 av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
1452 "Imode: %i, Invert: %i\n", status>>1, status&1);
1453 #endif
1454 }
1455
1456 status = bitplane_decoding(&v->skip_mb_plane, v);
1457 if (status < 0) return -1;
1458 #if TRACE
1459 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1460 "Imode: %i, Invert: %i\n", status>>1, status&1);
1461 #endif
1462
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)];
1466
1467 if (v->dquant)
1468 {
1469 av_log(v->s.avctx, AV_LOG_INFO, "VOP DQuant info\n");
1470 vop_dquant_decoding(v);
1471 }
1472
1473 v->ttfrm = 0; //FIXME Is that so ?
1474 if (v->vstransform)
1475 {
1476 v->ttmbf = get_bits(gb, 1);
1477 if (v->ttmbf)
1478 {
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);
1482 }
1483 }
1484 /* Epilog (AC/DC syntax) should be done in caller */
1485 return 0;
1486 }
1487 /** @} */ //End of group all_frm_hdr
1488
1489
1490 /***********************************************************************/
1491 /**
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 =>
1495 * check caller
1496 * @{
1497 */
1498
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"
1504 * @return Status
1505 */
1506 static int standard_decode_picture_primary_header(VC9Context *v)
1507 {
1508 GetBitContext *gb = &v->s.gb;
1509 int status = 0;
1510
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)
1516 {
1517 if (!v->s.pict_type)
1518 {
1519 if (get_bits(gb, 1)) v->s.pict_type = I_TYPE;
1520 else v->s.pict_type = B_TYPE;
1521 }
1522 else v->s.pict_type = P_TYPE;
1523 }
1524 else v->s.pict_type++;
1525
1526 switch (v->s.pict_type)
1527 {
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;
1532 }
1533
1534 if (status == FRAME_SKIPPED)
1535 {
1536 av_log(v->s.avctx, AV_LOG_INFO, "Skipping frame...\n");
1537 return status;
1538 }
1539 return 0;
1540 }
1541
1542 /** Frame header decoding, secondary part
1543 * @param v VC9 context
1544 * @warning To call once all MB arrays are allocated
1545 * @return Status
1546 */
1547 static int standard_decode_picture_secondary_header(VC9Context *v)
1548 {
1549 GetBitContext *gb = &v->s.gb;
1550 int status = 0;
1551
1552 switch (v->s.pict_type)
1553 {
1554 case P_TYPE: status = decode_p_picture_secondary_header(v); break;
1555 case B_TYPE: status = decode_b_picture_secondary_header(v); break;
1556 case BI_TYPE:
1557 case I_TYPE: break; //Nothing needed as it's done in the epilog
1558 }
1559 if (status < 0) return FRAME_SKIPPED;
1560
1561 /* AC Syntax */
1562 v->c_ac_table_index = decode012(gb);
1563 if (v->s.pict_type == I_TYPE || v->s.pict_type == BI_TYPE)
1564 {
1565 v->y_ac_table_index = decode012(gb);
1566 }
1567 /* DC Syntax */
1568 v->s.dc_table_index = decode012(gb);
1569
1570 return 0;
1571 }
1572 /** @} */ //End for group std_frame_hdr
1573
1574 #if HAS_ADVANCED_PROFILE
1575 /***********************************************************************/
1576 /**
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 =>
1580 * check caller
1581 * @{
1582 */
1583 /** Frame header decoding, primary part
1584 * @param v VC9 context
1585 * @return Status
1586 */
1587 static int advanced_decode_picture_primary_header(VC9Context *v)
1588 {
1589 GetBitContext *gb = &v->s.gb;
1590 static const int type_table[4] = { P_TYPE, B_TYPE, I_TYPE, BI_TYPE };
1591 int type;
1592
1593 if (v->interlace)
1594 {
1595 v->fcm = get_bits(gb, 1);
1596 if (v->fcm) v->fcm = 2+get_bits(gb, 1);
1597 }
1598
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);
1603
1604 if (v->tfcntrflag) v->tfcntr = get_bits(gb, 8);
1605 if (v->broadcast)
1606 {
1607 if (!v->interlace) v->rptfrm = get_bits(gb, 2);
1608 else
1609 {
1610 v->tff = get_bits(gb, 1);
1611 v->rff = get_bits(gb, 1);
1612 }
1613 }
1614
1615 if (v->panscanflag)
1616 {
1617 #if 0
1618 for (i=0; i<v->numpanscanwin; i++)
1619 {
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);
1624 }
1625 #else
1626 skip_bits(gb, 16*4*v->numpanscanwin);
1627 #endif
1628 }
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);
1632
1633 switch(v->s.pict_type)
1634 {
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;
1637 case BI_TYPE:
1638 case B_TYPE: if (decode_b_picture_primary_header(v) < 0) return FRAME_SKIPPED;
1639 default: return -1;
1640 }
1641 }
1642
1643 /** Frame header decoding, secondary part
1644 * @param v VC9 context
1645 * @return Status
1646 */
1647 static int advanced_decode_picture_secondary_header(VC9Context *v)
1648 {
1649 GetBitContext *gb = &v->s.gb;
1650 int status = 0;
1651
1652 switch(v->s.pict_type)
1653 {
1654 case P_TYPE: status = decode_p_picture_secondary_header(v); break;
1655 case B_TYPE: status = decode_b_picture_secondary_header(v); break;
1656 case BI_TYPE:
1657 case I_TYPE: status = decode_i_picture_secondary_header(v); break;
1658 }
1659 if (status<0) return FRAME_SKIPPED;
1660
1661 /* AC Syntax */
1662 v->c_ac_table_index = decode012(gb);
1663 if (v->s.pict_type == I_TYPE || v->s.pict_type == BI_TYPE)
1664 {
1665 v->y_ac_table_index = decode012(gb);
1666 }
1667 /* DC Syntax */
1668 v->s.dc_table_index = decode012(gb);
1669
1670 return 0;
1671 }
1672 #endif
1673 /** @} */ //End for adv_frame_hdr
1674
1675 /***********************************************************************/
1676 /**
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
1680 * @{
1681 */
1682
1683 /**
1684 * @def GET_MQUANT
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
1688 */
1689 #define GET_MQUANT() \
1690 if (v->dquantfrm) \
1691 { \
1692 if (v->dqprofile == DQPROFILE_ALL_MBS) \
1693 { \
1694 if (v->dqbilevel) \
1695 { \
1696 mquant = (get_bits(gb, 1)) ? v->pq : v->altpq; \
1697 } \
1698 else \
1699 { \
1700 mqdiff = get_bits(gb, 3); \
1701 if (mqdiff != 7) mquant = v->pq + mqdiff; \
1702 else mquant = get_bits(gb, 5); \
1703 } \
1704 } \
1705 else mquant = v->pq; \
1706 }
1707
1708 /**
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
1715 */
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); \
1719 if (index > 36) \
1720 { \
1721 mb_has_coeffs = 1; \
1722 index -= 37; \
1723 } \
1724 else mb_has_coeffs = 0; \
1725 s->mb_intra = 0; \
1726 if (!index) { _dmv_x = _dmv_y = 0; } \
1727 else if (index == 35) \
1728 { \
1729 _dmv_x = get_bits(gb, v->k_x); \
1730 _dmv_y = get_bits(gb, v->k_y); \
1731 s->mb_intra = 1; \
1732 } \
1733 else \
1734 { \
1735 index1 = index%6; \
1736 if (s->mspel && index1 == 5) val = 1; \
1737 else val = 0; \
1738 val = get_bits(gb, size_table[index1] - val); \
1739 sign = 0 - (val&1); \
1740 _dmv_x = (sign ^ ((val>>1) + offset_table[index1])) - sign; \
1741 \
1742 index1 = index/6; \
1743 if (s->mspel && index1 == 5) val = 1; \
1744 else val = 0; \
1745 val = get_bits(gb, size_table[index1] - val); \
1746 sign = 0 - (val&1); \
1747 _dmv_y = (sign ^ ((val>>1) + offset_table[index1])) - sign; \
1748 }
1749
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
1758 */
1759 static inline int vc9_pred_dc(MpegEncContext *s, int n,
1760 uint16_t **dc_val_ptr, int *dir_ptr)
1761 {
1762 int a, b, c, wrap, pred, scale;
1763 int16_t *dc_val;
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
1769 };
1770
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;
1774
1775 wrap = s->block_wrap[n];
1776 dc_val= s->dc_val[0] + s->block_index[n];
1777
1778 /* B C
1779 * A X
1780 */
1781 a = dc_val[ - 1];
1782 b = dc_val[ - 1 - wrap];
1783 c = dc_val[ - wrap];
1784
1785 /* XXX: Rule B is used only for I and BI frames in S/M/C profile
1786 * with overlap filtering off
1787 */
1788 if ((s->pict_type == I_TYPE || s->pict_type == BI_TYPE) &&
1789 1 /* XXX: overlap filtering off */)
1790 {
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];
1794 }
1795 else
1796 {
1797 /* Set outer values */
1798 if (s->first_slice_line && n!=2) b=c=0;
1799 if (s->mb_x == 0) b=a=0;
1800
1801 /* XXX: Rule A needs to know if blocks are inter or intra :/ */
1802 if (0)
1803 {
1804 /* update predictor */
1805 *dc_val_ptr = &dc_val[0];
1806 dir_ptr = 0;
1807 return a;
1808 }
1809 }
1810
1811 if (abs(a - b) <= abs(b - c)) {
1812 pred = c;
1813 *dir_ptr = 1;
1814 } else {
1815 pred = a;
1816 *dir_ptr = 0;
1817 }
1818
1819 /* update predictor */
1820 *dc_val_ptr = &dc_val[0];
1821 return pred;
1822 }
1823
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
1834 */
1835 int vc9_decode_block(VC9Context *v, DCTELEM block[64], int n, int coded, int mquant)
1836 {
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 */
1842 int run_diff, i;
1843
1844 /* XXX: Guard against dumb values of mquant */
1845 mquant = (mquant < 1) ? 0 : ( (mquant>31) ? 31 : mquant );
1846
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];
1850
1851 if (s->mb_intra)
1852 {
1853 int dcdiff;
1854 uint16_t *dc_val;
1855
1856 /* Get DC differential */
1857 if (n < 4) {
1858 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1859 } else {
1860 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1861 }
1862 if (dcdiff < 0){
1863 av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
1864 return -1;
1865 }
1866 if (dcdiff)
1867 {
1868 if (dcdiff == 119 /* ESC index value */)
1869 {
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);
1874 }
1875 else
1876 {
1877 if (mquant == 1)
1878 dcdiff = (dcdiff<<2) + get_bits(gb, 2) - 3;
1879 else if (mquant == 2)
1880 dcdiff = (dcdiff<<1) + get_bits(gb, 1) - 1;
1881 }
1882 if (get_bits(gb, 1))
1883 dcdiff = -dcdiff;
1884 }
1885
1886 /* Prediction */
1887 dcdiff += vc9_pred_dc(s, n, &dc_val, &dc_pred_dir);
1888 *dc_val = dcdiff;
1889 /* Store the quantized DC coeff, used for prediction */
1890
1891 if (n < 4) {
1892 block[0] = dcdiff * s->y_dc_scale;
1893 } else {
1894 block[0] = dcdiff * s->c_dc_scale;
1895 }
1896 if (block[0] < 0) {
1897 #if TRACE
1898 //av_log(s->avctx, AV_LOG_ERROR, "DC=%i<0\n", dcdiff);
1899 #endif
1900 //return -1;
1901 }
1902 /* Skip ? */
1903 run_diff = 0;
1904 i = 0;
1905 if (!coded) {
1906 goto not_coded;
1907 }
1908 }
1909 else
1910 {
1911 mquant = v->pq;
1912
1913 /* Get TTBLK */
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
1918
1919 /* Get SUBBLKPAT */
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);
1925 }
1926
1927 //TODO AC Decoding
1928 i = 63; //XXX: nothing done yet
1929
1930
1931 not_coded:
1932 if (s->mb_intra) {
1933 mpeg4_pred_ac(s, block, n, dc_pred_dir);
1934 if (s->ac_pred) {
1935 i = 63; /* XXX: not optimal */
1936 }
1937 }
1938 if(i>0) i=63; //FIXME/XXX optimize
1939 s->block_last_index[n] = i;
1940 return 0;
1941 }
1942
1943 /** @} */ //End for group block
1944
1945 /***********************************************************************/
1946 /**
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
1950 * @{
1951 */
1952
1953 static inline int vc9_coded_block_pred(MpegEncContext * s, int n, uint8_t **coded_block_ptr)
1954 {
1955 int xy, wrap, pred, a, b, c;
1956
1957 xy = s->block_index[n];
1958 wrap = s->b8_stride;
1959
1960 /* B C
1961 * A X
1962 */
1963 a = s->coded_block[xy - 1 ];
1964 b = s->coded_block[xy - 1 - wrap];
1965 c = s->coded_block[xy - wrap];
1966
1967 if (b == c) {
1968 pred = a;
1969 } else {
1970 pred = c;
1971 }
1972
1973 /* store value */
1974 *coded_block_ptr = &s->coded_block[xy];
1975
1976 return pred;
1977 }
1978
1979 /** Decode one I-frame MB (in Simple/Main profile)
1980 * @todo TODO: Extend to AP
1981 */
1982 int vc9_decode_i_mb(VC9Context *v, DCTELEM block[6][64])
1983 {
1984 int i, cbp, val;
1985 uint8_t *coded_val;
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 ];
1987
1988 v->s.mb_intra = 1;
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);
1992
1993 for (i=0; i<6; i++)
1994 {
1995 val = ((cbp >> (5 - i)) & 1);
1996 if (i < 4) {
1997 int pred = vc9_coded_block_pred(&v->s, i, &coded_val);
1998 val = val ^ pred;
1999 *coded_val = val;
2000 }
2001 cbp |= val << (5 - i);
2002 if (vc9_decode_block(v, block[i], i, val, v->pq) < 0) //FIXME Should be mquant
2003 {
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);
2006 return -1;
2007 }
2008 }
2009 return 0;
2010 }
2011
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
2015 */
2016 int vc9_decode_p_mb(VC9Context *v, DCTELEM block[6][64])
2017 {
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 */
2026 int status;
2027 uint8_t *coded_val;
2028
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 */
2035
2036 mquant = v->pq; /* Loosy initialization */
2037
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 */
2043 {
2044 if (!v->skip_mb_plane.data[mb_offset])
2045 {
2046 GET_MVDATA(dmv_x, dmv_y);
2047
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)
2054 {
2055 GET_MQUANT();
2056 s->ac_pred = get_bits(gb, 1);
2057 /* XXX: how to handle cbp ? */
2058 cbp = 0;
2059 for (i=0; i<6; i++)
2060 {
2061 s->coded_block[s->block_index[i]] = 0;
2062 vc9_decode_block(v, block[i], i, 0, mquant);
2063 }
2064 return 0;
2065 }
2066 else if (mb_has_coeffs)
2067 {
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);
2070 GET_MQUANT();
2071 }
2072 else
2073 {
2074 mquant = v->pq;
2075 /* XXX: how to handle cbp ? */
2076 /* XXX: how to set values for following predictions ? */
2077 cbp = 0;
2078 }
2079
2080 if (!v->ttmbf)
2081 ttmb = get_vlc2(gb, vc9_ttmb_vlc[v->tt_index].table,
2082 VC9_TTMB_VLC_BITS, 12);
2083
2084 for (i=0; i<6; i++)
2085 {
2086 val = ((cbp >> (5 - i)) & 1);
2087 if (i < 4) {
2088 int pred = vc9_coded_block_pred(&v->s, i, &coded_val);
2089 val = val ^ pred;
2090 *coded_val = val;
2091 }
2092 vc9_decode_block(v, block[i], i, val, mquant); //FIXME
2093 }
2094 }
2095 else //Skipped
2096 {
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);
2101
2102 /* TODO: blah */
2103 return 0;
2104 }
2105 } //1MV mode
2106 else //4MV mode
2107 {
2108 if (!v->skip_mb_plane.data[mb_offset] /* unskipped MB */)
2109 {
2110 /* Get CBPCY */
2111 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC9_CBPCY_P_VLC_BITS, 2);
2112 for (i=0; i<6; i++)
2113 {
2114 val = ((cbp >> (5 - i)) & 1);
2115 if (i < 4) {
2116 int pred = vc9_coded_block_pred(&v->s, i, &coded_val);
2117 val = val ^ pred;
2118 *coded_val = val;
2119 }
2120 if (i<4 && val)
2121 {
2122 GET_MVDATA(dmv_x, dmv_y);
2123 }
2124 if (v->mv_mode == MV_PMODE_MIXED_MV /* Hybrid pred */)
2125 hybrid_pred = get_bits(gb, 1);
2126 GET_MQUANT();
2127
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);
2131 if (!v->ttmbf)
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);
2135 }
2136 return status;
2137 }
2138 else //Skipped MB
2139 {
2140 /* XXX: Skipped => cbp=0 and mquant doesn't matter ? */
2141 for (i=0; i<4; i++)
2142 {
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
2146 }
2147 vc9_decode_block(v, block[4], 4, 0, v->pq); //FIXME
2148 vc9_decode_block(v, block[5], 5, 0, v->pq); //FIXME
2149 /* TODO: blah */
2150 return 0;
2151 }
2152 }
2153
2154 /* Should never happen */
2155 return -1;
2156 }
2157
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
2162 */
2163 int vc9_decode_b_mb(VC9Context *v, DCTELEM block[6][64])
2164 {
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 */
2171
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 */
2178
2179 mb_offset = s->mb_width*s->mb_y + s->mb_x; //FIXME: arrays aren't using stride
2180
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);
2185
2186 if (!v->direct_mb_plane.data[mb_offset])
2187 {
2188 if (v->skip_mb_plane.data[mb_offset])
2189 {
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;
2193 }
2194 else
2195 {
2196 GET_MVDATA(dmv1_x, dmv1_y);
2197 if (!s->mb_intra /* b_mv1 tells not intra */)
2198 {
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;
2202 }
2203 }
2204 }
2205 if (!v->skip_mb_plane.data[mb_offset])
2206 {
2207 if (mb_has_coeffs /* BMV1 == "last" */)
2208 {
2209 GET_MQUANT();
2210 if (s->mb_intra /* intra mb */)
2211 s->ac_pred = get_bits(gb, 1);
2212 }
2213 else
2214 {
2215 /* if bmv1 tells MVs are interpolated */
2216 if (b_mv_type == BMV_TYPE_INTERPOLATED)
2217 {
2218 GET_MVDATA(dmv2_x, dmv2_y);
2219 mquant = v->pq; //FIXME: initialization not necessary ?
2220 }
2221 /* GET_MVDATA has reset some stuff */
2222 if (mb_has_coeffs /* b_mv2 == "last" */)
2223 {
2224 if (s->mb_intra /* intra_mb */)
2225 s->ac_pred = get_bits(gb, 1);
2226 GET_MQUANT();
2227 }
2228 }
2229 }
2230
2231 //End1
2232 if (v->ttmbf)
2233 ttmb = get_vlc2(gb, vc9_ttmb_vlc[v->tt_index].table,
2234 VC9_TTMB_VLC_BITS, 12);
2235
2236 //End2
2237 for (i=0; i<6; i++)
2238 {
2239 vc9_decode_block(v, block[i], i, 0 /*cbp[i]*/, mquant); //FIXME
2240 }
2241 return 0;
2242 }
2243
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)
2247 */
2248 static int standard_decode_mbs(VC9Context *v)
2249 {
2250 MpegEncContext *s = &v->s;
2251
2252 /* Set transform type info depending on pq */
2253 if (v->pq < 5)
2254 {
2255 v->tt_index = 0;
2256 v->ttblk4x4 = 3;
2257 }
2258 else if (v->pq < 13)
2259 {
2260 v->tt_index = 1;
2261 v->ttblk4x4 = 3;
2262 }
2263 else
2264 {
2265 v->tt_index = 2;
2266 v->ttblk4x4 = 2;
2267 }
2268
2269 if (s->pict_type != I_TYPE)
2270 {
2271 /* Select proper long MV range */
2272 switch (v->mvrange)
2273 {
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;
2278 }
2279
2280 s->mspel = v->mv_mode & 1; //MV_PMODE is HPEL
2281 v->k_x -= s->mspel;
2282 v->k_y -= s->mspel;
2283 }
2284
2285 for (s->mb_y=0; s->mb_y<s->mb_height; s->mb_y++)
2286 {
2287 for (s->mb_x=0; s->mb_x<s->mb_width; s->mb_x++)
2288 {
2289 //FIXME Get proper MB DCTELEM
2290 //TODO Move out of the loop
2291 switch (s->pict_type)
2292 {
2293 case I_TYPE: vc9_decode_i_mb(v, s->block); break;
2294 case P_TYPE: vc9_decode_p_mb(v, s->block); break;
2295 case BI_TYPE:
2296 case B_TYPE: vc9_decode_b_mb(v, s->block); break;
2297 }
2298 }
2299 //Add a check for overconsumption ?
2300 }
2301 return 0;
2302 }
2303 /** @} */ //End for group std_mb
2304
2305 #if HAS_ADVANCED_PROFILE
2306 /***********************************************************************/
2307 /**
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
2311 * @{
2312 */
2313 static int advanced_decode_i_mbs(VC9Context *v)
2314 {
2315 MpegEncContext *s = &v->s;
2316 GetBitContext *gb = &v->s.gb;
2317 int mqdiff, mquant, mb_offset = 0, over_flags_mb = 0;
2318
2319 for (s->mb_y=0; s->mb_y<s->mb_height; s->mb_y++)
2320 {
2321 for (s->mb_x=0; s->mb_x<s->mb_width; s->mb_x++)
2322 {
2323 if (v->ac_pred_plane.is_raw)
2324 s->ac_pred = get_bits(gb, 1);
2325 else
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);
2329 GET_MQUANT();
2330
2331 /* TODO: lots */
2332 }
2333 mb_offset++;
2334 }
2335 return 0;
2336 }
2337 /** @} */ //End for group adv_mb
2338 #endif
2339
2340 /** Initialize a VC9/WMV3 decoder
2341 * @todo TODO: Handle VC-9 IDUs (Transport level?)
2342 * @todo TODO: Decypher remaining bits in extra_data
2343 */
2344 static int vc9_decode_init(AVCodecContext *avctx)
2345 {
2346 VC9Context *v = avctx->priv_data;
2347 MpegEncContext *s = &v->s;
2348 GetBitContext gb;
2349
2350 if (!avctx->extradata_size || !avctx->extradata) return -1;
2351 avctx->pix_fmt = PIX_FMT_YUV420P;
2352 v->s.avctx = avctx;
2353
2354 if(ff_h263_decode_init(avctx) < 0)
2355 return -1;
2356 if (vc9_init_common(v) < 0) return -1;
2357
2358 av_log(avctx, AV_LOG_INFO, "This decoder is not supposed to produce picture. Dont report this as a bug!\n");
2359
2360 avctx->coded_width = avctx->width;
2361 avctx->coded_height = avctx->height;
2362 if (avctx->codec_id == CODEC_ID_WMV3)
2363 {
2364 int count = 0;
2365
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
2370
2371 init_get_bits(&gb, avctx->extradata, avctx->extradata_size*8);
2372
2373 if (decode_sequence_header(avctx, &gb) < 0)
2374 return -1;
2375
2376 count = avctx->extradata_size*8 - get_bits_count(&gb);
2377 if (count>0)
2378 {
2379 av_log(avctx, AV_LOG_INFO, "Extra data: %i bits left, value: %X\n",
2380 count, get_bits(&gb, count));
2381 }
2382 else if (count < 0)
2383 {
2384 av_log(avctx, AV_LOG_INFO, "Read %i bits in overflow\n", -count);
2385 }
2386 }
2387 avctx->has_b_frames= !!(avctx->max_b_frames);
2388
2389 s->mb_width = (avctx->coded_width+15)>>4;
2390 s->mb_height = (avctx->coded_height+15)>>4;
2391
2392 /* Allocate mb bitplanes */
2393 if (alloc_bitplane(&v->mv_type_mb_plane, s->mb_width, s->mb_height) < 0)
2394 return -1;
2395 if (alloc_bitplane(&v->mv_type_mb_plane, s->mb_width, s->mb_height) < 0)
2396 return -1;
2397 if (alloc_bitplane(&v->skip_mb_plane, s->mb_width, s->mb_height) < 0)
2398 return -1;
2399 if (alloc_bitplane(&v->direct_mb_plane, s->mb_width, s->mb_height) < 0)
2400 return -1;
2401
2402 /* For predictors */
2403 v->previous_line_cbpcy = (uint8_t *)av_malloc(s->mb_stride*4);
2404 if (!v->previous_line_cbpcy) return -1;
2405
2406 #if HAS_ADVANCED_PROFILE
2407 if (v->profile == PROFILE_ADVANCED)
2408 {
2409 if (alloc_bitplane(&v->over_flags_plane, s->mb_width, s->mb_height) < 0)
2410 return -1;
2411 if (alloc_bitplane(&v->ac_pred_plane, s->mb_width, s->mb_height) < 0)
2412 return -1;
2413 }
2414 #endif
2415
2416 return 0;
2417 }
2418
2419 /** Decode a VC9/WMV3 frame
2420 * @todo TODO: Handle VC-9 IDUs (Transport level?)
2421 * @warning Initial try at using MpegEncContext stuff
2422 */
2423 static int vc9_decode_frame(AVCodecContext *avctx,
2424 void *data, int *data_size,
2425 uint8_t *buf, int buf_size)
2426 {
2427 VC9Context *v = avctx->priv_data;
2428 MpegEncContext *s = &v->s;
2429 int ret = FRAME_SKIPPED, len;
2430 AVFrame *pict = data;
2431 uint8_t *tmp_buf;
2432 v->s.avctx = avctx;
2433
2434 //buf_size = 0 -> last frame
2435 if (!buf_size) return 0;
2436
2437 len = avpicture_get_size(avctx->pix_fmt, avctx->width,
2438 avctx->height);
2439 tmp_buf = (uint8_t *)av_mallocz(len);
2440 avpicture_fill((AVPicture *)pict, tmp_buf, avctx->pix_fmt,
2441 avctx->width, avctx->height);
2442
2443 if (avctx->codec_id == CODEC_ID_VC9)
2444 {
2445 #if 0
2446 // search for IDU's
2447 // FIXME
2448 uint32_t scp = 0;
2449 int scs = 0, i = 0;
2450
2451 while (i < buf_size)
2452 {
2453 for (; i < buf_size && scp != 0x000001; i++)
2454 scp = ((scp<<8)|buf[i])&0xffffff;
2455
2456 if (scp != 0x000001)
2457 break; // eof ?
2458
2459 scs = buf[i++];
2460
2461 init_get_bits(gb, buf+i, (buf_size-i)*8);
2462
2463 switch(scs)
2464 {
2465 case 0x0A: //Sequence End Code
2466 return 0;
2467 case 0x0B: //Slice Start Code
2468 av_log(avctx, AV_LOG_ERROR, "Slice coding not supported\n");
2469 return -1;
2470 case 0x0C: //Field start code
2471 av_log(avctx, AV_LOG_ERROR, "Interlaced coding not supported\n");
2472 return -1;
2473 case 0x0D: //Frame start code
2474 break;
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);
2480 break;
2481 case 0x0F: //Sequence header Start Code
2482 decode_sequence_header(avctx, gb);
2483 break;
2484 default:
2485 av_log(avctx, AV_LOG_ERROR,
2486 "Unsupported IDU suffix %lX\n", scs);
2487 }
2488
2489 i += get_bits_count(gb)*8;
2490 }
2491 #else
2492 av_abort();
2493 #endif
2494 }
2495 else
2496 init_get_bits(&v->s.gb, buf, buf_size*8);
2497
2498 s->flags= avctx->flags;
2499 s->flags2= avctx->flags2;
2500
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;
2507
2508 *data_size = sizeof(AVFrame);
2509 }
2510
2511 return 0;
2512 }
2513
2514 //No IDU - we mimic ff_h263_decode_frame
2515 s->bitstream_buffer_size=0;
2516
2517 if (!s->context_initialized) {
2518 if (MPV_common_init(s) < 0) //we need the idct permutaton for reading a custom matrix
2519 return -1;
2520 }
2521
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)];
2525 }
2526 #if HAS_ADVANCED_PROFILE
2527 if (v->profile == PROFILE_ADVANCED)
2528 ret= advanced_decode_picture_primary_header(v);
2529 else
2530 #endif
2531 ret= standard_decode_picture_primary_header(v);
2532 if (ret == FRAME_SKIPPED) return buf_size;
2533 /* skip if the header was thrashed */
2534 if (ret < 0){
2535 av_log(s->avctx, AV_LOG_ERROR, "header damaged\n");
2536 return -1;
2537 }
2538
2539 //No bug workaround yet, no DCT conformance
2540
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
2544 }
2545 //Not sure about context initialization
2546
2547 // for hurry_up==5
2548 s->current_picture.pict_type= s->pict_type;
2549 s->current_picture.key_frame= s->pict_type == I_TYPE;
2550
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
2560
2561 if(s->next_p_frame_damaged){
2562 if(s->pict_type==B_TYPE)
2563 return buf_size; //FIXME simulating all buffer consumed
2564 else
2565 s->next_p_frame_damaged=0;
2566 }
2567
2568 if(MPV_frame_start(s, avctx) < 0)
2569 return -1;
2570
2571 ff_er_frame_start(s);
2572
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);
2577 else
2578 #endif
2579 ret = standard_decode_picture_secondary_header(v);
2580 if (ret<0) return FRAME_SKIPPED; //FIXME Non fatal for now
2581
2582 //We consider the image coded in only one slice
2583 #if HAS_ADVANCED_PROFILE
2584 if (v->profile == PROFILE_ADVANCED)
2585 {
2586 switch(s->pict_type)
2587 {
2588 case I_TYPE: ret = advanced_decode_i_mbs(v); break;
2589 case P_TYPE: ret = decode_p_mbs(v); break;
2590 case B_TYPE:
2591 case BI_TYPE: ret = decode_b_mbs(v); break;
2592 default: ret = FRAME_SKIPPED;
2593 }
2594 if (ret == FRAME_SKIPPED) return buf_size; //We ignore for now failures
2595 }
2596 else
2597 #endif
2598 {
2599 ret = standard_decode_mbs(v);
2600 if (ret == FRAME_SKIPPED) return buf_size;
2601 }
2602
2603 ff_er_frame_end(s);
2604
2605 MPV_frame_end(s);
2606
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);
2612 } else {
2613 *pict= *(AVFrame*)&s->last_picture;
2614 if(pict)
2615 ff_print_debug_info(s, pict);
2616 }
2617
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;
2621
2622 /* dont output the last pic after seeking */
2623 if(s->last_picture_ptr || s->low_delay)
2624 *data_size = sizeof(AVFrame);
2625
2626 av_log(avctx, AV_LOG_DEBUG, "Consumed %i/%i bits\n",
2627 get_bits_count(&s->gb), buf_size*8);
2628
2629 /* Fake consumption of all data */
2630 *data_size = len;
2631 return buf_size; //Number of bytes consumed
2632 }
2633
2634 /** Close a VC9/WMV3 decoder
2635 * @warning Initial try at using MpegEncContext stuff
2636 */
2637 static int vc9_decode_end(AVCodecContext *avctx)
2638 {
2639 VC9Context *v = avctx->priv_data;
2640
2641 #if HAS_ADVANCED_PROFILE
2642 av_freep(&v->hrd_rate);
2643 av_freep(&v->hrd_buffer);
2644 #endif
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);
2649 return 0;
2650 }
2651
2652 AVCodec vc9_decoder = {
2653 "vc9",
2654 CODEC_TYPE_VIDEO,
2655 CODEC_ID_VC9,
2656 sizeof(VC9Context),
2657 vc9_decode_init,
2658 NULL,
2659 vc9_decode_end,
2660 vc9_decode_frame,
2661 CODEC_CAP_DELAY,
2662 NULL
2663 };
2664
2665 AVCodec wmv3_decoder = {
2666 "wmv3",
2667 CODEC_TYPE_VIDEO,
2668 CODEC_ID_WMV3,
2669 sizeof(VC9Context),
2670 vc9_decode_init,
2671 NULL,
2672 vc9_decode_end,
2673 vc9_decode_frame,
2674 CODEC_CAP_DELAY,
2675 NULL
2676 };