FFmpeg  2.1.1
vc1.c
Go to the documentation of this file.
1 /*
2  * VC-1 and WMV3 decoder common code
3  * Copyright (c) 2011 Mashiat Sarker Shakkhar
4  * Copyright (c) 2006-2007 Konstantin Shishkov
5  * Partly based on vc9.c (c) 2005 Anonymous, Alex Beregszaszi, Michael Niedermayer
6  *
7  * This file is part of FFmpeg.
8  *
9  * FFmpeg is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Lesser General Public
11  * License as published by the Free Software Foundation; either
12  * version 2.1 of the License, or (at your option) any later version.
13  *
14  * FFmpeg is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17  * Lesser General Public License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public
20  * License along with FFmpeg; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22  */
23 
24 /**
25  * @file
26  * VC-1 and WMV3 decoder common code
27  *
28  */
29 
30 #include "libavutil/attributes.h"
31 #include "internal.h"
32 #include "avcodec.h"
33 #include "mpegvideo.h"
34 #include "vc1.h"
35 #include "vc1data.h"
36 #include "msmpeg4data.h"
37 #include "unary.h"
38 #include "simple_idct.h"
39 
40 #undef NDEBUG
41 #include <assert.h>
42 
43 /***********************************************************************/
44 /**
45  * @name VC-1 Bitplane decoding
46  * @see 8.7, p56
47  * @{
48  */
49 
50 /**
51  * Imode types
52  * @{
53  */
54 enum Imode {
62 };
63 /** @} */ //imode defines
64 
65 /** Decode rows by checking if they are skipped
66  * @param plane Buffer to store decoded bits
67  * @param[in] width Width of this buffer
68  * @param[in] height Height of this buffer
69  * @param[in] stride of this buffer
70  */
71 static void decode_rowskip(uint8_t* plane, int width, int height, int stride,
72  GetBitContext *gb)
73 {
74  int x, y;
75 
76  for (y = 0; y < height; y++) {
77  if (!get_bits1(gb)) //rowskip
78  memset(plane, 0, width);
79  else
80  for (x = 0; x < width; x++)
81  plane[x] = get_bits1(gb);
82  plane += stride;
83  }
84 }
85 
86 /** Decode columns by checking if they are skipped
87  * @param plane Buffer to store decoded bits
88  * @param[in] width Width of this buffer
89  * @param[in] height Height of this buffer
90  * @param[in] stride of this buffer
91  * @todo FIXME: Optimize
92  */
93 static void decode_colskip(uint8_t* plane, int width, int height, int stride,
94  GetBitContext *gb)
95 {
96  int x, y;
97 
98  for (x = 0; x < width; x++) {
99  if (!get_bits1(gb)) //colskip
100  for (y = 0; y < height; y++)
101  plane[y*stride] = 0;
102  else
103  for (y = 0; y < height; y++)
104  plane[y*stride] = get_bits1(gb);
105  plane ++;
106  }
107 }
108 
109 /** Decode a bitplane's bits
110  * @param data bitplane where to store the decode bits
111  * @param[out] raw_flag pointer to the flag indicating that this bitplane is not coded explicitly
112  * @param v VC-1 context for bit reading and logging
113  * @return Status
114  * @todo FIXME: Optimize
115  */
116 static int bitplane_decoding(uint8_t* data, int *raw_flag, VC1Context *v)
117 {
118  GetBitContext *gb = &v->s.gb;
119 
120  int imode, x, y, code, offset;
121  uint8_t invert, *planep = data;
122  int width, height, stride;
123 
124  width = v->s.mb_width;
125  height = v->s.mb_height >> v->field_mode;
126  stride = v->s.mb_stride;
127  invert = get_bits1(gb);
129 
130  *raw_flag = 0;
131  switch (imode) {
132  case IMODE_RAW:
133  //Data is actually read in the MB layer (same for all tests == "raw")
134  *raw_flag = 1; //invert ignored
135  return invert;
136  case IMODE_DIFF2:
137  case IMODE_NORM2:
138  if ((height * width) & 1) {
139  *planep++ = get_bits1(gb);
140  offset = 1;
141  }
142  else
143  offset = 0;
144  // decode bitplane as one long line
145  for (y = offset; y < height * width; y += 2) {
147  *planep++ = code & 1;
148  offset++;
149  if (offset == width) {
150  offset = 0;
151  planep += stride - width;
152  }
153  *planep++ = code >> 1;
154  offset++;
155  if (offset == width) {
156  offset = 0;
157  planep += stride - width;
158  }
159  }
160  break;
161  case IMODE_DIFF6:
162  case IMODE_NORM6:
163  if (!(height % 3) && (width % 3)) { // use 2x3 decoding
164  for (y = 0; y < height; y += 3) {
165  for (x = width & 1; x < width; x += 2) {
167  if (code < 0) {
168  av_log(v->s.avctx, AV_LOG_DEBUG, "invalid NORM-6 VLC\n");
169  return -1;
170  }
171  planep[x + 0] = (code >> 0) & 1;
172  planep[x + 1] = (code >> 1) & 1;
173  planep[x + 0 + stride] = (code >> 2) & 1;
174  planep[x + 1 + stride] = (code >> 3) & 1;
175  planep[x + 0 + stride * 2] = (code >> 4) & 1;
176  planep[x + 1 + stride * 2] = (code >> 5) & 1;
177  }
178  planep += stride * 3;
179  }
180  if (width & 1)
181  decode_colskip(data, 1, height, stride, &v->s.gb);
182  } else { // 3x2
183  planep += (height & 1) * stride;
184  for (y = height & 1; y < height; y += 2) {
185  for (x = width % 3; x < width; x += 3) {
187  if (code < 0) {
188  av_log(v->s.avctx, AV_LOG_DEBUG, "invalid NORM-6 VLC\n");
189  return -1;
190  }
191  planep[x + 0] = (code >> 0) & 1;
192  planep[x + 1] = (code >> 1) & 1;
193  planep[x + 2] = (code >> 2) & 1;
194  planep[x + 0 + stride] = (code >> 3) & 1;
195  planep[x + 1 + stride] = (code >> 4) & 1;
196  planep[x + 2 + stride] = (code >> 5) & 1;
197  }
198  planep += stride * 2;
199  }
200  x = width % 3;
201  if (x)
202  decode_colskip(data, x, height, stride, &v->s.gb);
203  if (height & 1)
204  decode_rowskip(data + x, width - x, 1, stride, &v->s.gb);
205  }
206  break;
207  case IMODE_ROWSKIP:
208  decode_rowskip(data, width, height, stride, &v->s.gb);
209  break;
210  case IMODE_COLSKIP:
211  decode_colskip(data, width, height, stride, &v->s.gb);
212  break;
213  default:
214  break;
215  }
216 
217  /* Applying diff operator */
218  if (imode == IMODE_DIFF2 || imode == IMODE_DIFF6) {
219  planep = data;
220  planep[0] ^= invert;
221  for (x = 1; x < width; x++)
222  planep[x] ^= planep[x-1];
223  for (y = 1; y < height; y++) {
224  planep += stride;
225  planep[0] ^= planep[-stride];
226  for (x = 1; x < width; x++) {
227  if (planep[x-1] != planep[x-stride]) planep[x] ^= invert;
228  else planep[x] ^= planep[x-1];
229  }
230  }
231  } else if (invert) {
232  planep = data;
233  for (x = 0; x < stride * height; x++)
234  planep[x] = !planep[x]; //FIXME stride
235  }
236  return (imode << 1) + invert;
237 }
238 
239 /** @} */ //Bitplane group
240 
241 /***********************************************************************/
242 /** VOP Dquant decoding
243  * @param v VC-1 Context
244  */
246 {
247  GetBitContext *gb = &v->s.gb;
248  int pqdiff;
249 
250  //variable size
251  if (v->dquant == 2) {
252  pqdiff = get_bits(gb, 3);
253  if (pqdiff == 7)
254  v->altpq = get_bits(gb, 5);
255  else
256  v->altpq = v->pq + pqdiff + 1;
257  } else {
258  v->dquantfrm = get_bits1(gb);
259  if (v->dquantfrm) {
260  v->dqprofile = get_bits(gb, 2);
261  switch (v->dqprofile) {
264  v->dqsbedge = get_bits(gb, 2);
265  break;
266  case DQPROFILE_ALL_MBS:
267  v->dqbilevel = get_bits1(gb);
268  if (!v->dqbilevel)
269  v->halfpq = 0;
270  default:
271  break; //Forbidden ?
272  }
273  if (v->dqbilevel || v->dqprofile != DQPROFILE_ALL_MBS) {
274  pqdiff = get_bits(gb, 3);
275  if (pqdiff == 7)
276  v->altpq = get_bits(gb, 5);
277  else
278  v->altpq = v->pq + pqdiff + 1;
279  }
280  }
281  }
282  return 0;
283 }
284 
286 
287 /**
288  * Decode Simple/Main Profiles sequence header
289  * @see Figure 7-8, p16-17
290  * @param avctx Codec context
291  * @param gb GetBit context initialized from Codec context extra_data
292  * @return Status
293  */
295 {
296  av_log(avctx, AV_LOG_DEBUG, "Header: %0X\n", show_bits_long(gb, 32));
297  v->profile = get_bits(gb, 2);
298  if (v->profile == PROFILE_COMPLEX) {
299  av_log(avctx, AV_LOG_WARNING, "WMV3 Complex Profile is not fully supported\n");
300  }
301 
302  if (v->profile == PROFILE_ADVANCED) {
305  return decode_sequence_header_adv(v, gb);
306  } else {
309  v->res_y411 = get_bits1(gb);
310  v->res_sprite = get_bits1(gb);
311  if (v->res_y411) {
312  av_log(avctx, AV_LOG_ERROR,
313  "Old interlaced mode is not supported\n");
314  return -1;
315  }
316  }
317 
318  // (fps-2)/4 (->30)
319  v->frmrtq_postproc = get_bits(gb, 3); //common
320  // (bitrate-32kbps)/64kbps
321  v->bitrtq_postproc = get_bits(gb, 5); //common
322  v->s.loop_filter = get_bits1(gb); //common
323  if (v->s.loop_filter == 1 && v->profile == PROFILE_SIMPLE) {
324  av_log(avctx, AV_LOG_ERROR,
325  "LOOPFILTER shall not be enabled in Simple Profile\n");
326  }
328  v->s.loop_filter = 0;
329 
330  v->res_x8 = get_bits1(gb); //reserved
331  v->multires = get_bits1(gb);
332  v->res_fasttx = get_bits1(gb);
333  if (!v->res_fasttx) {
342  }
343 
344  v->fastuvmc = get_bits1(gb); //common
345  if (!v->profile && !v->fastuvmc) {
346  av_log(avctx, AV_LOG_ERROR,
347  "FASTUVMC unavailable in Simple Profile\n");
348  return -1;
349  }
350  v->extended_mv = get_bits1(gb); //common
351  if (!v->profile && v->extended_mv)
352  {
353  av_log(avctx, AV_LOG_ERROR,
354  "Extended MVs unavailable in Simple Profile\n");
355  return -1;
356  }
357  v->dquant = get_bits(gb, 2); //common
358  v->vstransform = get_bits1(gb); //common
359 
360  v->res_transtab = get_bits1(gb);
361  if (v->res_transtab)
362  {
363  av_log(avctx, AV_LOG_ERROR,
364  "1 for reserved RES_TRANSTAB is forbidden\n");
365  return -1;
366  }
367 
368  v->overlap = get_bits1(gb); //common
369 
370  v->s.resync_marker = get_bits1(gb);
371  v->rangered = get_bits1(gb);
372  if (v->rangered && v->profile == PROFILE_SIMPLE) {
373  av_log(avctx, AV_LOG_INFO,
374  "RANGERED should be set to 0 in Simple Profile\n");
375  }
376 
377  v->s.max_b_frames = avctx->max_b_frames = get_bits(gb, 3); //common
378  v->quantizer_mode = get_bits(gb, 2); //common
379 
380  v->finterpflag = get_bits1(gb); //common
381 
382  if (v->res_sprite) {
383  int w = get_bits(gb, 11);
384  int h = get_bits(gb, 11);
385  avcodec_set_dimensions(v->s.avctx, w, h);
386  skip_bits(gb, 5); //frame rate
387  v->res_x8 = get_bits1(gb);
388  if (get_bits1(gb)) { // something to do with DC VLC selection
389  av_log(avctx, AV_LOG_ERROR, "Unsupported sprite feature\n");
390  return -1;
391  }
392  skip_bits(gb, 3); //slice code
393  v->res_rtm_flag = 0;
394  } else {
395  v->res_rtm_flag = get_bits1(gb); //reserved
396  }
397  if (!v->res_rtm_flag) {
398  av_log(avctx, AV_LOG_ERROR,
399  "Old WMV3 version detected, some frames may be decoded incorrectly\n");
400  //return -1;
401  }
402  //TODO: figure out what they mean (always 0x402F)
403  if (!v->res_fasttx)
404  skip_bits(gb, 16);
405  av_log(avctx, AV_LOG_DEBUG,
406  "Profile %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
407  "LoopFilter=%i, MultiRes=%i, FastUVMC=%i, Extended MV=%i\n"
408  "Rangered=%i, VSTransform=%i, Overlap=%i, SyncMarker=%i\n"
409  "DQuant=%i, Quantizer mode=%i, Max B frames=%i\n",
411  v->s.loop_filter, v->multires, v->fastuvmc, v->extended_mv,
412  v->rangered, v->vstransform, v->overlap, v->s.resync_marker,
413  v->dquant, v->quantizer_mode, avctx->max_b_frames);
414  return 0;
415 }
416 
418 {
419  v->res_rtm_flag = 1;
420  v->level = get_bits(gb, 3);
421  if (v->level >= 5) {
422  av_log(v->s.avctx, AV_LOG_ERROR, "Reserved LEVEL %i\n",v->level);
423  }
424  v->chromaformat = get_bits(gb, 2);
425  if (v->chromaformat != 1) {
427  "Only 4:2:0 chroma format supported\n");
428  return -1;
429  }
430 
431  // (fps-2)/4 (->30)
432  v->frmrtq_postproc = get_bits(gb, 3); //common
433  // (bitrate-32kbps)/64kbps
434  v->bitrtq_postproc = get_bits(gb, 5); //common
435  v->postprocflag = get_bits1(gb); //common
436 
437  v->max_coded_width = (get_bits(gb, 12) + 1) << 1;
438  v->max_coded_height = (get_bits(gb, 12) + 1) << 1;
439  v->broadcast = get_bits1(gb);
440  v->interlace = get_bits1(gb);
441  v->tfcntrflag = get_bits1(gb);
442  v->finterpflag = get_bits1(gb);
443  skip_bits1(gb); // reserved
444 
446  "Advanced Profile level %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
447  "LoopFilter=%i, ChromaFormat=%i, Pulldown=%i, Interlace: %i\n"
448  "TFCTRflag=%i, FINTERPflag=%i\n",
451  v->tfcntrflag, v->finterpflag);
452 
453  v->psf = get_bits1(gb);
454  if (v->psf) { //PsF, 6.1.13
455  av_log(v->s.avctx, AV_LOG_ERROR, "Progressive Segmented Frame mode: not supported (yet)\n");
456  return -1;
457  }
458  v->s.max_b_frames = v->s.avctx->max_b_frames = 7;
459  if (get_bits1(gb)) { //Display Info - decoding is not affected by it
460  int w, h, ar = 0;
461  av_log(v->s.avctx, AV_LOG_DEBUG, "Display extended info:\n");
462  w = get_bits(gb, 14) + 1;
463  h = get_bits(gb, 14) + 1;
464  av_log(v->s.avctx, AV_LOG_DEBUG, "Display dimensions: %ix%i\n", w, h);
465  if (get_bits1(gb))
466  ar = get_bits(gb, 4);
467  if (ar && ar < 14) {
469  } else if (ar == 15) {
470  w = get_bits(gb, 8) + 1;
471  h = get_bits(gb, 8) + 1;
472  v->s.avctx->sample_aspect_ratio = (AVRational){w, h};
473  } else {
476  v->s.avctx->height * w,
477  v->s.avctx->width * h,
478  1 << 30);
479  }
480  av_log(v->s.avctx, AV_LOG_DEBUG, "Aspect: %i:%i\n",
483 
484  if (get_bits1(gb)) { //framerate stuff
485  if (get_bits1(gb)) {
486  v->s.avctx->time_base.num = 32;
487  v->s.avctx->time_base.den = get_bits(gb, 16) + 1;
488  } else {
489  int nr, dr;
490  nr = get_bits(gb, 8);
491  dr = get_bits(gb, 4);
492  if (nr > 0 && nr < 8 && dr > 0 && dr < 3) {
493  v->s.avctx->time_base.num = ff_vc1_fps_dr[dr - 1];
494  v->s.avctx->time_base.den = ff_vc1_fps_nr[nr - 1] * 1000;
495  }
496  }
497  if (v->broadcast) { // Pulldown may be present
498  v->s.avctx->time_base.den *= 2;
499  v->s.avctx->ticks_per_frame = 2;
500  }
501  }
502 
503  if (get_bits1(gb)) {
504  v->s.avctx->color_primaries = get_bits(gb, 8);
505  v->s.avctx->color_trc = get_bits(gb, 8);
506  v->s.avctx->colorspace = get_bits(gb, 8);
508  }
509  }
510 
511  v->hrd_param_flag = get_bits1(gb);
512  if (v->hrd_param_flag) {
513  int i;
514  v->hrd_num_leaky_buckets = get_bits(gb, 5);
515  skip_bits(gb, 4); //bitrate exponent
516  skip_bits(gb, 4); //buffer size exponent
517  for (i = 0; i < v->hrd_num_leaky_buckets; i++) {
518  skip_bits(gb, 16); //hrd_rate[n]
519  skip_bits(gb, 16); //hrd_buffer[n]
520  }
521  }
522  return 0;
523 }
524 
526 {
527  int i;
528  int w,h;
529 
530  av_log(avctx, AV_LOG_DEBUG, "Entry point: %08X\n", show_bits_long(gb, 32));
531  v->broken_link = get_bits1(gb);
532  v->closed_entry = get_bits1(gb);
533  v->panscanflag = get_bits1(gb);
534  v->refdist_flag = get_bits1(gb);
535  v->s.loop_filter = get_bits1(gb);
537  v->s.loop_filter = 0;
538  v->fastuvmc = get_bits1(gb);
539  v->extended_mv = get_bits1(gb);
540  v->dquant = get_bits(gb, 2);
541  v->vstransform = get_bits1(gb);
542  v->overlap = get_bits1(gb);
543  v->quantizer_mode = get_bits(gb, 2);
544 
545  if (v->hrd_param_flag) {
546  for (i = 0; i < v->hrd_num_leaky_buckets; i++) {
547  skip_bits(gb, 8); //hrd_full[n]
548  }
549  }
550 
551  if(get_bits1(gb)){
552  w = (get_bits(gb, 12)+1)<<1;
553  h = (get_bits(gb, 12)+1)<<1;
554  } else {
555  w = v->max_coded_width;
556  h = v->max_coded_height;
557  }
558  avcodec_set_dimensions(avctx, w, h);
559  if (v->extended_mv)
560  v->extended_dmv = get_bits1(gb);
561  if ((v->range_mapy_flag = get_bits1(gb))) {
562  av_log(avctx, AV_LOG_ERROR, "Luma scaling is not supported, expect wrong picture\n");
563  v->range_mapy = get_bits(gb, 3);
564  }
565  if ((v->range_mapuv_flag = get_bits1(gb))) {
566  av_log(avctx, AV_LOG_ERROR, "Chroma scaling is not supported, expect wrong picture\n");
567  v->range_mapuv = get_bits(gb, 3);
568  }
569 
570  av_log(avctx, AV_LOG_DEBUG, "Entry point info:\n"
571  "BrokenLink=%i, ClosedEntry=%i, PanscanFlag=%i\n"
572  "RefDist=%i, Postproc=%i, FastUVMC=%i, ExtMV=%i\n"
573  "DQuant=%i, VSTransform=%i, Overlap=%i, Qmode=%i\n",
576 
577  return 0;
578 }
579 
580 /* fill lookup tables for intensity compensation */
581 #define INIT_LUT(lumscale, lumshift, luty, lutuv, chain) do { \
582  int scale, shift, i; \
583  if (!lumscale) { \
584  scale = -64; \
585  shift = (255 - lumshift * 2) << 6; \
586  if (lumshift > 31) \
587  shift += 128 << 6; \
588  } else { \
589  scale = lumscale + 32; \
590  if (lumshift > 31) \
591  shift = (lumshift - 64) << 6; \
592  else \
593  shift = lumshift << 6; \
594  } \
595  for (i = 0; i < 256; i++) { \
596  int iy = chain ? luty[i] : i; \
597  int iu = chain ? lutuv[i] : i; \
598  luty[i] = av_clip_uint8((scale * iy + shift + 32) >> 6); \
599  lutuv[i] = av_clip_uint8((scale * (iu - 128) + 128*64 + 32) >> 6);\
600  } \
601  } while(0)
602 
603 static void rotate_luts(VC1Context *v)
604 {
605 #define ROTATE(DEF, L, N, C, A) do { \
606  if (v->s.pict_type == AV_PICTURE_TYPE_BI || v->s.pict_type == AV_PICTURE_TYPE_B) { \
607  C = A; \
608  } else { \
609  DEF; \
610  memcpy(&tmp, &L , sizeof(tmp)); \
611  memcpy(&L , &N , sizeof(tmp)); \
612  memcpy(&N , &tmp, sizeof(tmp)); \
613  C = N; \
614  } \
615  } while(0)
616 
617  ROTATE(int tmp, v->last_use_ic, v->next_use_ic, v->curr_use_ic, v->aux_use_ic);
618  ROTATE(uint8_t tmp[2][256], v->last_luty, v->next_luty, v->curr_luty, v->aux_luty);
619  ROTATE(uint8_t tmp[2][256], v->last_lutuv, v->next_lutuv, v->curr_lutuv, v->aux_lutuv);
620 
621  INIT_LUT(32, 0, v->curr_luty[0], v->curr_lutuv[0], 0);
622  INIT_LUT(32, 0, v->curr_luty[1], v->curr_lutuv[1], 0);
623  v->curr_use_ic = 0;
624 }
625 
627 {
628  int pqindex, lowquant, status;
629 
630  if (v->finterpflag)
631  v->interpfrm = get_bits1(gb);
632  if (!v->s.avctx->codec)
633  return -1;
634  if (v->s.avctx->codec_id == AV_CODEC_ID_MSS2)
635  v->respic =
636  v->rangered =
637  v->multires = get_bits(gb, 2) == 1;
638  else
639  skip_bits(gb, 2); //framecnt unused
640  v->rangeredfrm = 0;
641  if (v->rangered)
642  v->rangeredfrm = get_bits1(gb);
643  v->s.pict_type = get_bits1(gb);
644  if (v->s.avctx->max_b_frames) {
645  if (!v->s.pict_type) {
646  if (get_bits1(gb))
648  else
650  } else
652  } else
654 
655  v->bi_type = 0;
656  if (v->s.pict_type == AV_PICTURE_TYPE_B) {
659  if (v->bfraction == 0) {
661  }
662  }
664  skip_bits(gb, 7); // skip buffer fullness
665 
666  if (v->parse_only)
667  return 0;
668 
669  /* calculate RND */
671  v->rnd = 1;
672  if (v->s.pict_type == AV_PICTURE_TYPE_P)
673  v->rnd ^= 1;
674 
675  /* Quantizer stuff */
676  pqindex = get_bits(gb, 5);
677  if (!pqindex)
678  return -1;
680  v->pq = ff_vc1_pquant_table[0][pqindex];
681  else
682  v->pq = ff_vc1_pquant_table[1][pqindex];
683 
684  v->pquantizer = 1;
686  v->pquantizer = pqindex < 9;
688  v->pquantizer = 0;
689  v->pqindex = pqindex;
690  if (pqindex < 9)
691  v->halfpq = get_bits1(gb);
692  else
693  v->halfpq = 0;
695  v->pquantizer = get_bits1(gb);
696  v->dquantfrm = 0;
697  if (v->extended_mv == 1)
698  v->mvrange = get_unary(gb, 0, 3);
699  v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
700  v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
701  v->range_x = 1 << (v->k_x - 1);
702  v->range_y = 1 << (v->k_y - 1);
703  if (v->multires && v->s.pict_type != AV_PICTURE_TYPE_B)
704  v->respic = get_bits(gb, 2);
705 
706  if (v->res_x8 && (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)) {
707  v->x8_type = get_bits1(gb);
708  } else
709  v->x8_type = 0;
710  av_dlog(v->s.avctx, "%c Frame: QP=[%i]%i (+%i/2) %i\n",
711  (v->s.pict_type == AV_PICTURE_TYPE_P) ? 'P' : ((v->s.pict_type == AV_PICTURE_TYPE_I) ? 'I' : 'B'),
712  pqindex, v->pq, v->halfpq, v->rangeredfrm);
713 
714  if (v->first_pic_header_flag)
715  rotate_luts(v);
716 
717  switch (v->s.pict_type) {
718  case AV_PICTURE_TYPE_P:
719  if (v->pq < 5) v->tt_index = 0;
720  else if (v->pq < 13) v->tt_index = 1;
721  else v->tt_index = 2;
722 
723  lowquant = (v->pq > 12) ? 0 : 1;
724  v->mv_mode = ff_vc1_mv_pmode_table[lowquant][get_unary(gb, 1, 4)];
725  if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
726  v->mv_mode2 = ff_vc1_mv_pmode_table2[lowquant][get_unary(gb, 1, 3)];
727  v->lumscale = get_bits(gb, 6);
728  v->lumshift = get_bits(gb, 6);
729  v->last_use_ic = 1;
730  /* fill lookup tables for intensity compensation */
731  INIT_LUT(v->lumscale, v->lumshift, v->last_luty[0], v->last_lutuv[0], 1);
732  INIT_LUT(v->lumscale, v->lumshift, v->last_luty[1], v->last_lutuv[1], 1);
733  }
734  v->qs_last = v->s.quarter_sample;
736  v->s.quarter_sample = 0;
737  else if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
739  v->s.quarter_sample = 0;
740  else
741  v->s.quarter_sample = 1;
742  } else
743  v->s.quarter_sample = 1;
745 
746  if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
747  v->mv_mode2 == MV_PMODE_MIXED_MV) ||
748  v->mv_mode == MV_PMODE_MIXED_MV) {
750  if (status < 0)
751  return -1;
752  av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
753  "Imode: %i, Invert: %i\n", status>>1, status&1);
754  } else {
755  v->mv_type_is_raw = 0;
756  memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
757  }
758  status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
759  if (status < 0)
760  return -1;
761  av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
762  "Imode: %i, Invert: %i\n", status>>1, status&1);
763 
764  /* Hopefully this is correct for P frames */
765  v->s.mv_table_index = get_bits(gb, 2); //but using ff_vc1_ tables
766  v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
767 
768  if (v->dquant) {
769  av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
771  }
772 
773  v->ttfrm = 0; //FIXME Is that so ?
774  if (v->vstransform) {
775  v->ttmbf = get_bits1(gb);
776  if (v->ttmbf) {
777  v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
778  }
779  } else {
780  v->ttmbf = 1;
781  v->ttfrm = TT_8X8;
782  }
783  break;
784  case AV_PICTURE_TYPE_B:
785  if (v->pq < 5) v->tt_index = 0;
786  else if (v->pq < 13) v->tt_index = 1;
787  else v->tt_index = 2;
788 
790  v->qs_last = v->s.quarter_sample;
791  v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
792  v->s.mspel = v->s.quarter_sample;
793 
794  status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
795  if (status < 0)
796  return -1;
797  av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
798  "Imode: %i, Invert: %i\n", status>>1, status&1);
799  status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
800  if (status < 0)
801  return -1;
802  av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
803  "Imode: %i, Invert: %i\n", status>>1, status&1);
804 
805  v->s.mv_table_index = get_bits(gb, 2);
806  v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
807 
808  if (v->dquant) {
809  av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
811  }
812 
813  v->ttfrm = 0;
814  if (v->vstransform) {
815  v->ttmbf = get_bits1(gb);
816  if (v->ttmbf) {
817  v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
818  }
819  } else {
820  v->ttmbf = 1;
821  v->ttfrm = TT_8X8;
822  }
823  break;
824  }
825 
826  if (!v->x8_type) {
827  /* AC Syntax */
828  v->c_ac_table_index = decode012(gb);
830  v->y_ac_table_index = decode012(gb);
831  }
832  /* DC Syntax */
833  v->s.dc_table_index = get_bits1(gb);
834  }
835 
836  if (v->s.pict_type == AV_PICTURE_TYPE_BI) {
838  v->bi_type = 1;
839  }
840  return 0;
841 }
842 
844 {
845  int pqindex, lowquant;
846  int status;
847  int mbmodetab, imvtab, icbptab, twomvbptab, fourmvbptab; /* useful only for debugging */
848  int field_mode, fcm;
849 
850  v->numref=0;
851  v->p_frame_skipped = 0;
852  if (v->second_field) {
853  if(v->fcm!=2 || v->field_mode!=1)
854  return -1;
856  if (v->fptype & 4)
859  if (!v->pic_header_flag)
860  goto parse_common_info;
861  }
862 
863  field_mode = 0;
864  if (v->interlace) {
865  fcm = decode012(gb);
866  if (fcm) {
867  if (fcm == ILACE_FIELD)
868  field_mode = 1;
869  }
870  } else {
871  fcm = PROGRESSIVE;
872  }
873  if (!v->first_pic_header_flag && v->field_mode != field_mode)
874  return AVERROR_INVALIDDATA;
875  v->field_mode = field_mode;
876  v->fcm = fcm;
877 
878  if (v->field_mode) {
879  v->fptype = get_bits(gb, 3);
881  if (v->fptype & 4) // B-picture
883  } else {
884  switch (get_unary(gb, 0, 4)) {
885  case 0:
887  break;
888  case 1:
890  break;
891  case 2:
893  break;
894  case 3:
896  break;
897  case 4:
898  v->s.pict_type = AV_PICTURE_TYPE_P; // skipped pic
899  v->p_frame_skipped = 1;
900  break;
901  }
902  }
903  if (v->tfcntrflag)
904  skip_bits(gb, 8);
905  if (v->broadcast) {
906  if (!v->interlace || v->psf) {
907  v->rptfrm = get_bits(gb, 2);
908  } else {
909  v->tff = get_bits1(gb);
910  v->rff = get_bits1(gb);
911  }
912  } else {
913  v->tff = 1;
914  }
915  if (v->panscanflag) {
916  avpriv_report_missing_feature(v->s.avctx, "Pan-scan");
917  //...
918  }
919  if (v->p_frame_skipped) {
920  return 0;
921  }
922  v->rnd = get_bits1(gb);
923  if (v->interlace)
924  v->uvsamp = get_bits1(gb);
926  return 0; //parsing only, vlc tables havnt been allocated
927  if (v->field_mode) {
928  if (!v->refdist_flag)
929  v->refdist = 0;
930  else if ((v->s.pict_type != AV_PICTURE_TYPE_B) && (v->s.pict_type != AV_PICTURE_TYPE_BI)) {
931  v->refdist = get_bits(gb, 2);
932  if (v->refdist == 3)
933  v->refdist += get_unary(gb, 0, 16);
934  }
935  if ((v->s.pict_type == AV_PICTURE_TYPE_B) || (v->s.pict_type == AV_PICTURE_TYPE_BI)) {
938  v->frfd = (v->bfraction * v->refdist) >> 8;
939  v->brfd = v->refdist - v->frfd - 1;
940  if (v->brfd < 0)
941  v->brfd = 0;
942  }
943  goto parse_common_info;
944  }
945  if (v->fcm == PROGRESSIVE) {
946  if (v->finterpflag)
947  v->interpfrm = get_bits1(gb);
948  if (v->s.pict_type == AV_PICTURE_TYPE_B) {
951  if (v->bfraction == 0) {
952  v->s.pict_type = AV_PICTURE_TYPE_BI; /* XXX: should not happen here */
953  }
954  }
955  }
956 
957  parse_common_info:
958  if (v->field_mode)
959  v->cur_field_type = !(v->tff ^ v->second_field);
960  pqindex = get_bits(gb, 5);
961  if (!pqindex)
962  return -1;
963  v->pqindex = pqindex;
965  v->pq = ff_vc1_pquant_table[0][pqindex];
966  else
967  v->pq = ff_vc1_pquant_table[1][pqindex];
968 
969  v->pquantizer = 1;
971  v->pquantizer = pqindex < 9;
973  v->pquantizer = 0;
974  v->pqindex = pqindex;
975  if (pqindex < 9)
976  v->halfpq = get_bits1(gb);
977  else
978  v->halfpq = 0;
980  v->pquantizer = get_bits1(gb);
981  if (v->postprocflag)
982  v->postproc = get_bits(gb, 2);
983 
984  if (v->parse_only)
985  return 0;
986 
987  if (v->first_pic_header_flag)
988  rotate_luts(v);
989 
990  switch (v->s.pict_type) {
991  case AV_PICTURE_TYPE_I:
992  case AV_PICTURE_TYPE_BI:
993  if (v->fcm == ILACE_FRAME) { //interlace frame picture
994  status = bitplane_decoding(v->fieldtx_plane, &v->fieldtx_is_raw, v);
995  if (status < 0)
996  return -1;
997  av_log(v->s.avctx, AV_LOG_DEBUG, "FIELDTX plane encoding: "
998  "Imode: %i, Invert: %i\n", status>>1, status&1);
999  }
1000  status = bitplane_decoding(v->acpred_plane, &v->acpred_is_raw, v);
1001  if (status < 0)
1002  return -1;
1003  av_log(v->s.avctx, AV_LOG_DEBUG, "ACPRED plane encoding: "
1004  "Imode: %i, Invert: %i\n", status>>1, status&1);
1005  v->condover = CONDOVER_NONE;
1006  if (v->overlap && v->pq <= 8) {
1007  v->condover = decode012(gb);
1008  if (v->condover == CONDOVER_SELECT) {
1009  status = bitplane_decoding(v->over_flags_plane, &v->overflg_is_raw, v);
1010  if (status < 0)
1011  return -1;
1012  av_log(v->s.avctx, AV_LOG_DEBUG, "CONDOVER plane encoding: "
1013  "Imode: %i, Invert: %i\n", status>>1, status&1);
1014  }
1015  }
1016  break;
1017  case AV_PICTURE_TYPE_P:
1018  if (v->field_mode) {
1019  v->numref = get_bits1(gb);
1020  if (!v->numref) {
1021  v->reffield = get_bits1(gb);
1022  v->ref_field_type[0] = v->reffield ^ !v->cur_field_type;
1023  }
1024  }
1025  if (v->extended_mv)
1026  v->mvrange = get_unary(gb, 0, 3);
1027  else
1028  v->mvrange = 0;
1029  if (v->interlace) {
1030  if (v->extended_dmv)
1031  v->dmvrange = get_unary(gb, 0, 3);
1032  else
1033  v->dmvrange = 0;
1034  if (v->fcm == ILACE_FRAME) { // interlaced frame picture
1035  v->fourmvswitch = get_bits1(gb);
1036  v->intcomp = get_bits1(gb);
1037  if (v->intcomp) {
1038  v->lumscale = get_bits(gb, 6);
1039  v->lumshift = get_bits(gb, 6);
1040  INIT_LUT(v->lumscale, v->lumshift, v->last_luty[0], v->last_lutuv[0], 1);
1041  INIT_LUT(v->lumscale, v->lumshift, v->last_luty[1], v->last_lutuv[1], 1);
1042  v->last_use_ic = 1;
1043  }
1044  status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1045  av_log(v->s.avctx, AV_LOG_DEBUG, "SKIPMB plane encoding: "
1046  "Imode: %i, Invert: %i\n", status>>1, status&1);
1047  mbmodetab = get_bits(gb, 2);
1048  if (v->fourmvswitch)
1049  v->mbmode_vlc = &ff_vc1_intfr_4mv_mbmode_vlc[mbmodetab];
1050  else
1051  v->mbmode_vlc = &ff_vc1_intfr_non4mv_mbmode_vlc[mbmodetab];
1052  imvtab = get_bits(gb, 2);
1053  v->imv_vlc = &ff_vc1_1ref_mvdata_vlc[imvtab];
1054  // interlaced p-picture cbpcy range is [1, 63]
1055  icbptab = get_bits(gb, 3);
1056  v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
1057  twomvbptab = get_bits(gb, 2);
1058  v->twomvbp_vlc = &ff_vc1_2mv_block_pattern_vlc[twomvbptab];
1059  if (v->fourmvswitch) {
1060  fourmvbptab = get_bits(gb, 2);
1061  v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
1062  }
1063  }
1064  }
1065  v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1066  v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
1067  v->range_x = 1 << (v->k_x - 1);
1068  v->range_y = 1 << (v->k_y - 1);
1069 
1070  if (v->pq < 5)
1071  v->tt_index = 0;
1072  else if (v->pq < 13)
1073  v->tt_index = 1;
1074  else
1075  v->tt_index = 2;
1076  if (v->fcm != ILACE_FRAME) {
1077  int mvmode;
1078  mvmode = get_unary(gb, 1, 4);
1079  lowquant = (v->pq > 12) ? 0 : 1;
1080  v->mv_mode = ff_vc1_mv_pmode_table[lowquant][mvmode];
1081  if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
1082  int mvmode2;
1083  mvmode2 = get_unary(gb, 1, 3);
1084  v->mv_mode2 = ff_vc1_mv_pmode_table2[lowquant][mvmode2];
1085  if (v->field_mode) {
1086  v->intcompfield = decode210(gb) ^ 3;
1087  } else
1088  v->intcompfield = 3;
1089 
1090  v->lumscale2 = v->lumscale = 32;
1091  v->lumshift2 = v->lumshift = 0;
1092  if (v->intcompfield & 1) {
1093  v->lumscale = get_bits(gb, 6);
1094  v->lumshift = get_bits(gb, 6);
1095  }
1096  if ((v->intcompfield & 2) && v->field_mode) {
1097  v->lumscale2 = get_bits(gb, 6);
1098  v->lumshift2 = get_bits(gb, 6);
1099  } else if(!v->field_mode) {
1100  v->lumscale2 = v->lumscale;
1101  v->lumshift2 = v->lumshift;
1102  }
1103  if (v->field_mode && v->second_field) {
1104  if (v->cur_field_type) {
1105  INIT_LUT(v->lumscale , v->lumshift , v->curr_luty[v->cur_field_type^1], v->curr_lutuv[v->cur_field_type^1], 0);
1107  } else {
1110  }
1111  v->next_use_ic = v->curr_use_ic = 1;
1112  } else {
1113  INIT_LUT(v->lumscale , v->lumshift , v->last_luty[0], v->last_lutuv[0], 1);
1114  INIT_LUT(v->lumscale2, v->lumshift2, v->last_luty[1], v->last_lutuv[1], 1);
1115  }
1116  v->last_use_ic = 1;
1117  }
1118  v->qs_last = v->s.quarter_sample;
1120  v->s.quarter_sample = 0;
1121  else if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
1123  v->s.quarter_sample = 0;
1124  else
1125  v->s.quarter_sample = 1;
1126  } else
1127  v->s.quarter_sample = 1;
1128  v->s.mspel = !(v->mv_mode == MV_PMODE_1MV_HPEL_BILIN
1130  && v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN));
1131  }
1132  if (v->fcm == PROGRESSIVE) { // progressive
1133  if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
1135  || v->mv_mode == MV_PMODE_MIXED_MV) {
1136  status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);
1137  if (status < 0)
1138  return -1;
1139  av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
1140  "Imode: %i, Invert: %i\n", status>>1, status&1);
1141  } else {
1142  v->mv_type_is_raw = 0;
1143  memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
1144  }
1145  status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1146  if (status < 0)
1147  return -1;
1148  av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1149  "Imode: %i, Invert: %i\n", status>>1, status&1);
1150 
1151  /* Hopefully this is correct for P frames */
1152  v->s.mv_table_index = get_bits(gb, 2); //but using ff_vc1_ tables
1153  v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
1154  } else if (v->fcm == ILACE_FRAME) { // frame interlaced
1155  v->qs_last = v->s.quarter_sample;
1156  v->s.quarter_sample = 1;
1157  v->s.mspel = 1;
1158  } else { // field interlaced
1159  mbmodetab = get_bits(gb, 3);
1160  imvtab = get_bits(gb, 2 + v->numref);
1161  if (!v->numref)
1162  v->imv_vlc = &ff_vc1_1ref_mvdata_vlc[imvtab];
1163  else
1164  v->imv_vlc = &ff_vc1_2ref_mvdata_vlc[imvtab];
1165  icbptab = get_bits(gb, 3);
1166  v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
1167  if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
1169  fourmvbptab = get_bits(gb, 2);
1170  v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
1171  v->mbmode_vlc = &ff_vc1_if_mmv_mbmode_vlc[mbmodetab];
1172  } else {
1173  v->mbmode_vlc = &ff_vc1_if_1mv_mbmode_vlc[mbmodetab];
1174  }
1175  }
1176  if (v->dquant) {
1177  av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1179  }
1180 
1181  v->ttfrm = 0; //FIXME Is that so ?
1182  if (v->vstransform) {
1183  v->ttmbf = get_bits1(gb);
1184  if (v->ttmbf) {
1185  v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
1186  }
1187  } else {
1188  v->ttmbf = 1;
1189  v->ttfrm = TT_8X8;
1190  }
1191  break;
1192  case AV_PICTURE_TYPE_B:
1193  if (v->fcm == ILACE_FRAME) {
1196  if (v->bfraction == 0) {
1197  return -1;
1198  }
1199  }
1200  if (v->extended_mv)
1201  v->mvrange = get_unary(gb, 0, 3);
1202  else
1203  v->mvrange = 0;
1204  v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1205  v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
1206  v->range_x = 1 << (v->k_x - 1);
1207  v->range_y = 1 << (v->k_y - 1);
1208 
1209  if (v->pq < 5)
1210  v->tt_index = 0;
1211  else if (v->pq < 13)
1212  v->tt_index = 1;
1213  else
1214  v->tt_index = 2;
1215 
1216  if (v->field_mode) {
1217  int mvmode;
1218  av_log(v->s.avctx, AV_LOG_DEBUG, "B Fields\n");
1219  if (v->extended_dmv)
1220  v->dmvrange = get_unary(gb, 0, 3);
1221  mvmode = get_unary(gb, 1, 3);
1222  lowquant = (v->pq > 12) ? 0 : 1;
1223  v->mv_mode = ff_vc1_mv_pmode_table2[lowquant][mvmode];
1224  v->qs_last = v->s.quarter_sample;
1227  status = bitplane_decoding(v->forward_mb_plane, &v->fmb_is_raw, v);
1228  if (status < 0)
1229  return -1;
1230  av_log(v->s.avctx, AV_LOG_DEBUG, "MB Forward Type plane encoding: "
1231  "Imode: %i, Invert: %i\n", status>>1, status&1);
1232  mbmodetab = get_bits(gb, 3);
1233  if (v->mv_mode == MV_PMODE_MIXED_MV)
1234  v->mbmode_vlc = &ff_vc1_if_mmv_mbmode_vlc[mbmodetab];
1235  else
1236  v->mbmode_vlc = &ff_vc1_if_1mv_mbmode_vlc[mbmodetab];
1237  imvtab = get_bits(gb, 3);
1238  v->imv_vlc = &ff_vc1_2ref_mvdata_vlc[imvtab];
1239  icbptab = get_bits(gb, 3);
1240  v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
1241  if (v->mv_mode == MV_PMODE_MIXED_MV) {
1242  fourmvbptab = get_bits(gb, 2);
1243  v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
1244  }
1245  v->numref = 1; // interlaced field B pictures are always 2-ref
1246  } else if (v->fcm == ILACE_FRAME) {
1247  if (v->extended_dmv)
1248  v->dmvrange = get_unary(gb, 0, 3);
1249  if (get_bits1(gb)) /* intcomp - present but shall always be 0 */
1250  av_log(v->s.avctx, AV_LOG_WARNING, "Intensity compensation set for B picture\n");
1251  v->intcomp = 0;
1252  v->mv_mode = MV_PMODE_1MV;
1253  v->fourmvswitch = 0;
1254  v->qs_last = v->s.quarter_sample;
1255  v->s.quarter_sample = 1;
1256  v->s.mspel = 1;
1257  status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
1258  if (status < 0)
1259  return -1;
1260  av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
1261  "Imode: %i, Invert: %i\n", status>>1, status&1);
1262  status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1263  if (status < 0)
1264  return -1;
1265  av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1266  "Imode: %i, Invert: %i\n", status>>1, status&1);
1267  mbmodetab = get_bits(gb, 2);
1268  v->mbmode_vlc = &ff_vc1_intfr_non4mv_mbmode_vlc[mbmodetab];
1269  imvtab = get_bits(gb, 2);
1270  v->imv_vlc = &ff_vc1_1ref_mvdata_vlc[imvtab];
1271  // interlaced p/b-picture cbpcy range is [1, 63]
1272  icbptab = get_bits(gb, 3);
1273  v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
1274  twomvbptab = get_bits(gb, 2);
1275  v->twomvbp_vlc = &ff_vc1_2mv_block_pattern_vlc[twomvbptab];
1276  fourmvbptab = get_bits(gb, 2);
1277  v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
1278  } else {
1280  v->qs_last = v->s.quarter_sample;
1281  v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
1282  v->s.mspel = v->s.quarter_sample;
1283  status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
1284  if (status < 0)
1285  return -1;
1286  av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
1287  "Imode: %i, Invert: %i\n", status>>1, status&1);
1288  status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1289  if (status < 0)
1290  return -1;
1291  av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1292  "Imode: %i, Invert: %i\n", status>>1, status&1);
1293  v->s.mv_table_index = get_bits(gb, 2);
1294  v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
1295  }
1296 
1297  if (v->dquant) {
1298  av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1300  }
1301 
1302  v->ttfrm = 0;
1303  if (v->vstransform) {
1304  v->ttmbf = get_bits1(gb);
1305  if (v->ttmbf) {
1306  v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
1307  }
1308  } else {
1309  v->ttmbf = 1;
1310  v->ttfrm = TT_8X8;
1311  }
1312  break;
1313  }
1314 
1315  if (v->fcm != PROGRESSIVE && !v->s.quarter_sample) {
1316  v->range_x <<= 1;
1317  v->range_y <<= 1;
1318  }
1319 
1320  /* AC Syntax */
1321  v->c_ac_table_index = decode012(gb);
1323  v->y_ac_table_index = decode012(gb);
1324  }
1325  /* DC Syntax */
1326  v->s.dc_table_index = get_bits1(gb);
1328  && v->dquant) {
1329  av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1331  }
1332 
1333  v->bi_type = 0;
1334  if (v->s.pict_type == AV_PICTURE_TYPE_BI) {
1336  v->bi_type = 1;
1337  }
1338  return 0;
1339 }
1340 
1341 static const uint32_t vc1_ac_tables[AC_MODES][186][2] = {
1342 {
1343 { 0x0001, 2}, { 0x0005, 3}, { 0x000D, 4}, { 0x0012, 5}, { 0x000E, 6}, { 0x0015, 7},
1344 { 0x0013, 8}, { 0x003F, 8}, { 0x004B, 9}, { 0x011F, 9}, { 0x00B8, 10}, { 0x03E3, 10},
1345 { 0x0172, 11}, { 0x024D, 12}, { 0x03DA, 12}, { 0x02DD, 13}, { 0x1F55, 13}, { 0x05B9, 14},
1346 { 0x3EAE, 14}, { 0x0000, 4}, { 0x0010, 5}, { 0x0008, 7}, { 0x0020, 8}, { 0x0029, 9},
1347 { 0x01F4, 9}, { 0x0233, 10}, { 0x01E0, 11}, { 0x012A, 12}, { 0x03DD, 12}, { 0x050A, 13},
1348 { 0x1F29, 13}, { 0x0A42, 14}, { 0x1272, 15}, { 0x1737, 15}, { 0x0003, 5}, { 0x0011, 7},
1349 { 0x00C4, 8}, { 0x004B, 10}, { 0x00B4, 11}, { 0x07D4, 11}, { 0x0345, 12}, { 0x02D7, 13},
1350 { 0x07BF, 13}, { 0x0938, 14}, { 0x0BBB, 14}, { 0x095E, 15}, { 0x0013, 5}, { 0x0078, 7},
1351 { 0x0069, 9}, { 0x0232, 10}, { 0x0461, 11}, { 0x03EC, 12}, { 0x0520, 13}, { 0x1F2A, 13},
1352 { 0x3E50, 14}, { 0x3E51, 14}, { 0x1486, 15}, { 0x000C, 6}, { 0x0024, 9}, { 0x0094, 11},
1353 { 0x08C0, 12}, { 0x0F09, 14}, { 0x1EF0, 15}, { 0x003D, 6}, { 0x0053, 9}, { 0x01A0, 11},
1354 { 0x02D6, 13}, { 0x0F08, 14}, { 0x0013, 7}, { 0x007C, 9}, { 0x07C1, 11}, { 0x04AC, 14},
1355 { 0x001B, 7}, { 0x00A0, 10}, { 0x0344, 12}, { 0x0F79, 14}, { 0x0079, 7}, { 0x03E1, 10},
1356 { 0x02D4, 13}, { 0x2306, 14}, { 0x0021, 8}, { 0x023C, 10}, { 0x0FAE, 12}, { 0x23DE, 14},
1357 { 0x0035, 8}, { 0x0175, 11}, { 0x07B3, 13}, { 0x00C5, 8}, { 0x0174, 11}, { 0x0785, 13},
1358 { 0x0048, 9}, { 0x01A3, 11}, { 0x049E, 13}, { 0x002C, 9}, { 0x00FA, 10}, { 0x07D6, 11},
1359 { 0x0092, 10}, { 0x05CC, 13}, { 0x1EF1, 15}, { 0x00A3, 10}, { 0x03ED, 12}, { 0x093E, 14},
1360 { 0x01E2, 11}, { 0x1273, 15}, { 0x07C4, 11}, { 0x1487, 15}, { 0x0291, 12}, { 0x0293, 12},
1361 { 0x0F8A, 12}, { 0x0509, 13}, { 0x0508, 13}, { 0x078D, 13}, { 0x07BE, 13}, { 0x078C, 13},
1362 { 0x04AE, 14}, { 0x0BBA, 14}, { 0x2307, 14}, { 0x0B9A, 14}, { 0x1736, 15}, { 0x000E, 4},
1363 { 0x0045, 7}, { 0x01F3, 9}, { 0x047A, 11}, { 0x05DC, 13}, { 0x23DF, 14}, { 0x0019, 5},
1364 { 0x0028, 9}, { 0x0176, 11}, { 0x049D, 13}, { 0x23DD, 14}, { 0x0030, 6}, { 0x00A2, 10},
1365 { 0x02EF, 12}, { 0x05B8, 14}, { 0x003F, 6}, { 0x00A5, 10}, { 0x03DB, 12}, { 0x093F, 14},
1366 { 0x0044, 7}, { 0x07CB, 11}, { 0x095F, 15}, { 0x0063, 7}, { 0x03C3, 12}, { 0x0015, 8},
1367 { 0x08F6, 12}, { 0x0017, 8}, { 0x0498, 13}, { 0x002C, 8}, { 0x07B2, 13}, { 0x002F, 8},
1368 { 0x1F54, 13}, { 0x008D, 8}, { 0x07BD, 13}, { 0x008E, 8}, { 0x1182, 13}, { 0x00FB, 8},
1369 { 0x050B, 13}, { 0x002D, 8}, { 0x07C0, 11}, { 0x0079, 9}, { 0x1F5F, 13}, { 0x007A, 9},
1370 { 0x1F56, 13}, { 0x0231, 10}, { 0x03E4, 10}, { 0x01A1, 11}, { 0x0143, 11}, { 0x01F7, 11},
1371 { 0x016F, 12}, { 0x0292, 12}, { 0x02E7, 12}, { 0x016C, 12}, { 0x016D, 12}, { 0x03DC, 12},
1372 { 0x0F8B, 12}, { 0x0499, 13}, { 0x03D8, 12}, { 0x078E, 13}, { 0x02D5, 13}, { 0x1F5E, 13},
1373 { 0x1F2B, 13}, { 0x078F, 13}, { 0x04AD, 14}, { 0x3EAF, 14}, { 0x23DC, 14}, { 0x004A, 9}
1374 },
1375 {
1376 { 0x0000, 3}, { 0x0003, 4}, { 0x000B, 5}, { 0x0014, 6}, { 0x003F, 6}, { 0x005D, 7},
1377 { 0x00A2, 8}, { 0x00AC, 9}, { 0x016E, 9}, { 0x020A, 10}, { 0x02E2, 10}, { 0x0432, 11},
1378 { 0x05C9, 11}, { 0x0827, 12}, { 0x0B54, 12}, { 0x04E6, 13}, { 0x105F, 13}, { 0x172A, 13},
1379 { 0x20B2, 14}, { 0x2D4E, 14}, { 0x39F0, 14}, { 0x4175, 15}, { 0x5A9E, 15}, { 0x0004, 4},
1380 { 0x001E, 5}, { 0x0042, 7}, { 0x00B6, 8}, { 0x0173, 9}, { 0x0395, 10}, { 0x072E, 11},
1381 { 0x0B94, 12}, { 0x16A4, 13}, { 0x20B3, 14}, { 0x2E45, 14}, { 0x0005, 5}, { 0x0040, 7},
1382 { 0x0049, 9}, { 0x028F, 10}, { 0x05CB, 11}, { 0x048A, 13}, { 0x09DD, 14}, { 0x73E2, 15},
1383 { 0x0018, 5}, { 0x0025, 8}, { 0x008A, 10}, { 0x051B, 11}, { 0x0E5F, 12}, { 0x09C9, 14},
1384 { 0x139C, 15}, { 0x0029, 6}, { 0x004F, 9}, { 0x0412, 11}, { 0x048D, 13}, { 0x2E41, 14},
1385 { 0x0038, 6}, { 0x010E, 9}, { 0x05A8, 11}, { 0x105C, 13}, { 0x39F2, 14}, { 0x0058, 7},
1386 { 0x021F, 10}, { 0x0E7E, 12}, { 0x39FF, 14}, { 0x0023, 8}, { 0x02E3, 10}, { 0x04E5, 13},
1387 { 0x2E40, 14}, { 0x00A1, 8}, { 0x05BE, 11}, { 0x09C8, 14}, { 0x0083, 8}, { 0x013A, 11},
1388 { 0x1721, 13}, { 0x0044, 9}, { 0x0276, 12}, { 0x39F6, 14}, { 0x008B, 10}, { 0x04EF, 13},
1389 { 0x5A9B, 15}, { 0x0208, 10}, { 0x1CFE, 13}, { 0x0399, 10}, { 0x1CB4, 13}, { 0x039E, 10},
1390 { 0x39F3, 14}, { 0x05AB, 11}, { 0x73E3, 15}, { 0x0737, 11}, { 0x5A9F, 15}, { 0x082D, 12},
1391 { 0x0E69, 12}, { 0x0E68, 12}, { 0x0433, 11}, { 0x0B7B, 12}, { 0x2DF8, 14}, { 0x2E56, 14},
1392 { 0x2E57, 14}, { 0x39F7, 14}, { 0x51A5, 15}, { 0x0003, 3}, { 0x002A, 6}, { 0x00E4, 8},
1393 { 0x028E, 10}, { 0x0735, 11}, { 0x1058, 13}, { 0x1CFA, 13}, { 0x2DF9, 14}, { 0x4174, 15},
1394 { 0x0009, 4}, { 0x0054, 8}, { 0x0398, 10}, { 0x048B, 13}, { 0x139D, 15}, { 0x000D, 4},
1395 { 0x00AD, 9}, { 0x0826, 12}, { 0x2D4C, 14}, { 0x0011, 5}, { 0x016B, 9}, { 0x0B7F, 12},
1396 { 0x51A4, 15}, { 0x0019, 5}, { 0x021B, 10}, { 0x16FD, 13}, { 0x001D, 5}, { 0x0394, 10},
1397 { 0x28D3, 14}, { 0x002B, 6}, { 0x05BC, 11}, { 0x5A9A, 15}, { 0x002F, 6}, { 0x0247, 12},
1398 { 0x0010, 7}, { 0x0A35, 12}, { 0x003E, 6}, { 0x0B7A, 12}, { 0x0059, 7}, { 0x105E, 13},
1399 { 0x0026, 8}, { 0x09CF, 14}, { 0x0055, 8}, { 0x1CB5, 13}, { 0x0057, 8}, { 0x0E5B, 12},
1400 { 0x00A0, 8}, { 0x1468, 13}, { 0x0170, 9}, { 0x0090, 10}, { 0x01CE, 9}, { 0x021A, 10},
1401 { 0x0218, 10}, { 0x0168, 9}, { 0x021E, 10}, { 0x0244, 12}, { 0x0736, 11}, { 0x0138, 11},
1402 { 0x0519, 11}, { 0x0E5E, 12}, { 0x072C, 11}, { 0x0B55, 12}, { 0x09DC, 14}, { 0x20BB, 14},
1403 { 0x048C, 13}, { 0x1723, 13}, { 0x2E44, 14}, { 0x16A5, 13}, { 0x0518, 11}, { 0x39FE, 14},
1404 { 0x0169, 9}
1405 },
1406 {
1407 { 0x0001, 2}, { 0x0006, 3}, { 0x000F, 4}, { 0x0016, 5}, { 0x0020, 6}, { 0x0018, 7},
1408 { 0x0008, 8}, { 0x009A, 8}, { 0x0056, 9}, { 0x013E, 9}, { 0x00F0, 10}, { 0x03A5, 10},
1409 { 0x0077, 11}, { 0x01EF, 11}, { 0x009A, 12}, { 0x005D, 13}, { 0x0001, 4}, { 0x0011, 5},
1410 { 0x0002, 7}, { 0x000B, 8}, { 0x0012, 9}, { 0x01D6, 9}, { 0x027E, 10}, { 0x0191, 11},
1411 { 0x00EA, 12}, { 0x03DC, 12}, { 0x013B, 13}, { 0x0004, 5}, { 0x0014, 7}, { 0x009E, 8},
1412 { 0x0009, 10}, { 0x01AC, 11}, { 0x01E2, 11}, { 0x03CA, 12}, { 0x005F, 13}, { 0x0017, 5},
1413 { 0x004E, 7}, { 0x005E, 9}, { 0x00F3, 10}, { 0x01AD, 11}, { 0x00EC, 12}, { 0x05F0, 13},
1414 { 0x000E, 6}, { 0x00E1, 8}, { 0x03A4, 10}, { 0x009C, 12}, { 0x013D, 13}, { 0x003B, 6},
1415 { 0x001C, 9}, { 0x0014, 11}, { 0x09BE, 12}, { 0x0006, 7}, { 0x007A, 9}, { 0x0190, 11},
1416 { 0x0137, 13}, { 0x001B, 7}, { 0x0008, 10}, { 0x075C, 11}, { 0x0071, 7}, { 0x00D7, 10},
1417 { 0x09BF, 12}, { 0x0007, 8}, { 0x00AF, 10}, { 0x04CC, 11}, { 0x0034, 8}, { 0x0265, 10},
1418 { 0x009F, 12}, { 0x00E0, 8}, { 0x0016, 11}, { 0x0327, 12}, { 0x0015, 9}, { 0x017D, 11},
1419 { 0x0EBB, 12}, { 0x0014, 9}, { 0x00F6, 10}, { 0x01E4, 11}, { 0x00CB, 10}, { 0x099D, 12},
1420 { 0x00CA, 10}, { 0x02FC, 12}, { 0x017F, 11}, { 0x04CD, 11}, { 0x02FD, 12}, { 0x04FE, 11},
1421 { 0x013A, 13}, { 0x000A, 4}, { 0x0042, 7}, { 0x01D3, 9}, { 0x04DD, 11}, { 0x0012, 5},
1422 { 0x00E8, 8}, { 0x004C, 11}, { 0x0136, 13}, { 0x0039, 6}, { 0x0264, 10}, { 0x0EBA, 12},
1423 { 0x0000, 7}, { 0x00AE, 10}, { 0x099C, 12}, { 0x001F, 7}, { 0x04DE, 11}, { 0x0043, 7},
1424 { 0x04DC, 11}, { 0x0003, 8}, { 0x03CB, 12}, { 0x0006, 8}, { 0x099E, 12}, { 0x002A, 8},
1425 { 0x05F1, 13}, { 0x000F, 8}, { 0x09FE, 12}, { 0x0033, 8}, { 0x09FF, 12}, { 0x0098, 8},
1426 { 0x099F, 12}, { 0x00EA, 8}, { 0x013C, 13}, { 0x002E, 8}, { 0x0192, 11}, { 0x0136, 9},
1427 { 0x006A, 9}, { 0x0015, 11}, { 0x03AF, 10}, { 0x01E3, 11}, { 0x0074, 11}, { 0x00EB, 12},
1428 { 0x02F9, 12}, { 0x005C, 13}, { 0x00ED, 12}, { 0x03DD, 12}, { 0x0326, 12}, { 0x005E, 13},
1429 { 0x0016, 7}
1430 },
1431 {
1432 { 0x0004, 3}, { 0x0014, 5}, { 0x0017, 7}, { 0x007F, 8}, { 0x0154, 9}, { 0x01F2, 10},
1433 { 0x00BF, 11}, { 0x0065, 12}, { 0x0AAA, 12}, { 0x0630, 13}, { 0x1597, 13}, { 0x03B7, 14},
1434 { 0x2B22, 14}, { 0x0BE6, 15}, { 0x000B, 4}, { 0x0037, 7}, { 0x0062, 9}, { 0x0007, 11},
1435 { 0x0166, 12}, { 0x00CE, 13}, { 0x1590, 13}, { 0x05F6, 14}, { 0x0BE7, 15}, { 0x0007, 5},
1436 { 0x006D, 8}, { 0x0003, 11}, { 0x031F, 12}, { 0x05F2, 14}, { 0x0002, 6}, { 0x0061, 9},
1437 { 0x0055, 12}, { 0x01DF, 14}, { 0x001A, 6}, { 0x001E, 10}, { 0x0AC9, 12}, { 0x2B23, 14},
1438 { 0x001E, 6}, { 0x001F, 10}, { 0x0AC3, 12}, { 0x2B2B, 14}, { 0x0006, 7}, { 0x0004, 11},
1439 { 0x02F8, 13}, { 0x0019, 7}, { 0x0006, 11}, { 0x063D, 13}, { 0x0057, 7}, { 0x0182, 11},
1440 { 0x2AA2, 14}, { 0x0004, 8}, { 0x0180, 11}, { 0x059C, 14}, { 0x007D, 8}, { 0x0164, 12},
1441 { 0x076D, 15}, { 0x0002, 9}, { 0x018D, 11}, { 0x1581, 13}, { 0x00AD, 8}, { 0x0060, 12},
1442 { 0x0C67, 14}, { 0x001C, 9}, { 0x00EE, 13}, { 0x0003, 9}, { 0x02CF, 13}, { 0x00D9, 9},
1443 { 0x1580, 13}, { 0x0002, 11}, { 0x0183, 11}, { 0x0057, 12}, { 0x0061, 12}, { 0x0031, 11},
1444 { 0x0066, 12}, { 0x0631, 13}, { 0x0632, 13}, { 0x00AC, 13}, { 0x031D, 12}, { 0x0076, 12},
1445 { 0x003A, 11}, { 0x0165, 12}, { 0x0C66, 14}, { 0x0003, 2}, { 0x0054, 7}, { 0x02AB, 10},
1446 { 0x0016, 13}, { 0x05F7, 14}, { 0x0005, 4}, { 0x00F8, 9}, { 0x0AA9, 12}, { 0x005F, 15},
1447 { 0x0004, 4}, { 0x001C, 10}, { 0x1550, 13}, { 0x0004, 5}, { 0x0077, 11}, { 0x076C, 15},
1448 { 0x000E, 5}, { 0x000A, 12}, { 0x000C, 5}, { 0x0562, 11}, { 0x0004, 6}, { 0x031C, 12},
1449 { 0x0006, 6}, { 0x00C8, 13}, { 0x000D, 6}, { 0x01DA, 13}, { 0x0007, 6}, { 0x00C9, 13},
1450 { 0x0001, 7}, { 0x002E, 14}, { 0x0014, 7}, { 0x1596, 13}, { 0x000A, 7}, { 0x0AC2, 12},
1451 { 0x0016, 7}, { 0x015B, 14}, { 0x0015, 7}, { 0x015A, 14}, { 0x000F, 8}, { 0x005E, 15},
1452 { 0x007E, 8}, { 0x00AB, 8}, { 0x002D, 9}, { 0x00D8, 9}, { 0x000B, 9}, { 0x0014, 10},
1453 { 0x02B3, 10}, { 0x01F3, 10}, { 0x003A, 10}, { 0x0000, 10}, { 0x0058, 10}, { 0x002E, 9},
1454 { 0x005E, 10}, { 0x0563, 11}, { 0x00EC, 12}, { 0x0054, 12}, { 0x0AC1, 12}, { 0x1556, 13},
1455 { 0x02FA, 13}, { 0x0181, 11}, { 0x1557, 13}, { 0x059D, 14}, { 0x2AA3, 14}, { 0x2B2A, 14},
1456 { 0x01DE, 14}, { 0x063C, 13}, { 0x00CF, 13}, { 0x1594, 13}, { 0x000D, 9}
1457 },
1458 {
1459 { 0x0002, 2}, { 0x0006, 3}, { 0x000F, 4}, { 0x000D, 5}, { 0x000C, 5}, { 0x0015, 6},
1460 { 0x0013, 6}, { 0x0012, 6}, { 0x0017, 7}, { 0x001F, 8}, { 0x001E, 8}, { 0x001D, 8},
1461 { 0x0025, 9}, { 0x0024, 9}, { 0x0023, 9}, { 0x0021, 9}, { 0x0021, 10}, { 0x0020, 10},
1462 { 0x000F, 10}, { 0x000E, 10}, { 0x0007, 11}, { 0x0006, 11}, { 0x0020, 11}, { 0x0021, 11},
1463 { 0x0050, 12}, { 0x0051, 12}, { 0x0052, 12}, { 0x000E, 4}, { 0x0014, 6}, { 0x0016, 7},
1464 { 0x001C, 8}, { 0x0020, 9}, { 0x001F, 9}, { 0x000D, 10}, { 0x0022, 11}, { 0x0053, 12},
1465 { 0x0055, 12}, { 0x000B, 5}, { 0x0015, 7}, { 0x001E, 9}, { 0x000C, 10}, { 0x0056, 12},
1466 { 0x0011, 6}, { 0x001B, 8}, { 0x001D, 9}, { 0x000B, 10}, { 0x0010, 6}, { 0x0022, 9},
1467 { 0x000A, 10}, { 0x000D, 6}, { 0x001C, 9}, { 0x0008, 10}, { 0x0012, 7}, { 0x001B, 9},
1468 { 0x0054, 12}, { 0x0014, 7}, { 0x001A, 9}, { 0x0057, 12}, { 0x0019, 8}, { 0x0009, 10},
1469 { 0x0018, 8}, { 0x0023, 11}, { 0x0017, 8}, { 0x0019, 9}, { 0x0018, 9}, { 0x0007, 10},
1470 { 0x0058, 12}, { 0x0007, 4}, { 0x000C, 6}, { 0x0016, 8}, { 0x0017, 9}, { 0x0006, 10},
1471 { 0x0005, 11}, { 0x0004, 11}, { 0x0059, 12}, { 0x000F, 6}, { 0x0016, 9}, { 0x0005, 10},
1472 { 0x000E, 6}, { 0x0004, 10}, { 0x0011, 7}, { 0x0024, 11}, { 0x0010, 7}, { 0x0025, 11},
1473 { 0x0013, 7}, { 0x005A, 12}, { 0x0015, 8}, { 0x005B, 12}, { 0x0014, 8}, { 0x0013, 8},
1474 { 0x001A, 8}, { 0x0015, 9}, { 0x0014, 9}, { 0x0013, 9}, { 0x0012, 9}, { 0x0011, 9},
1475 { 0x0026, 11}, { 0x0027, 11}, { 0x005C, 12}, { 0x005D, 12}, { 0x005E, 12}, { 0x005F, 12},
1476 { 0x0003, 7}
1477 },
1478 {
1479 { 0x0002, 2}, { 0x000F, 4}, { 0x0015, 6}, { 0x0017, 7}, { 0x001F, 8}, { 0x0025, 9},
1480 { 0x0024, 9}, { 0x0021, 10}, { 0x0020, 10}, { 0x0007, 11}, { 0x0006, 11}, { 0x0020, 11},
1481 { 0x0006, 3}, { 0x0014, 6}, { 0x001E, 8}, { 0x000F, 10}, { 0x0021, 11}, { 0x0050, 12},
1482 { 0x000E, 4}, { 0x001D, 8}, { 0x000E, 10}, { 0x0051, 12}, { 0x000D, 5}, { 0x0023, 9},
1483 { 0x000D, 10}, { 0x000C, 5}, { 0x0022, 9}, { 0x0052, 12}, { 0x000B, 5}, { 0x000C, 10},
1484 { 0x0053, 12}, { 0x0013, 6}, { 0x000B, 10}, { 0x0054, 12}, { 0x0012, 6}, { 0x000A, 10},
1485 { 0x0011, 6}, { 0x0009, 10}, { 0x0010, 6}, { 0x0008, 10}, { 0x0016, 7}, { 0x0055, 12},
1486 { 0x0015, 7}, { 0x0014, 7}, { 0x001C, 8}, { 0x001B, 8}, { 0x0021, 9}, { 0x0020, 9},
1487 { 0x001F, 9}, { 0x001E, 9}, { 0x001D, 9}, { 0x001C, 9}, { 0x001B, 9}, { 0x001A, 9},
1488 { 0x0022, 11}, { 0x0023, 11}, { 0x0056, 12}, { 0x0057, 12}, { 0x0007, 4}, { 0x0019, 9},
1489 { 0x0005, 11}, { 0x000F, 6}, { 0x0004, 11}, { 0x000E, 6}, { 0x000D, 6}, { 0x000C, 6},
1490 { 0x0013, 7}, { 0x0012, 7}, { 0x0011, 7}, { 0x0010, 7}, { 0x001A, 8}, { 0x0019, 8},
1491 { 0x0018, 8}, { 0x0017, 8}, { 0x0016, 8}, { 0x0015, 8}, { 0x0014, 8}, { 0x0013, 8},
1492 { 0x0018, 9}, { 0x0017, 9}, { 0x0016, 9}, { 0x0015, 9}, { 0x0014, 9}, { 0x0013, 9},
1493 { 0x0012, 9}, { 0x0011, 9}, { 0x0007, 10}, { 0x0006, 10}, { 0x0005, 10}, { 0x0004, 10},
1494 { 0x0024, 11}, { 0x0025, 11}, { 0x0026, 11}, { 0x0027, 11}, { 0x0058, 12}, { 0x0059, 12},
1495 { 0x005A, 12}, { 0x005B, 12}, { 0x005C, 12}, { 0x005D, 12}, { 0x005E, 12}, { 0x005F, 12},
1496 { 0x0003, 7}
1497 },
1498 {
1499 { 0x0000, 2}, { 0x0003, 3}, { 0x000D, 4}, { 0x0005, 4}, { 0x001C, 5}, { 0x0016, 5},
1500 { 0x003F, 6}, { 0x003A, 6}, { 0x002E, 6}, { 0x0022, 6}, { 0x007B, 7}, { 0x0067, 7},
1501 { 0x005F, 7}, { 0x0047, 7}, { 0x0026, 7}, { 0x00EF, 8}, { 0x00CD, 8}, { 0x00C1, 8},
1502 { 0x00A9, 8}, { 0x004F, 8}, { 0x01F2, 9}, { 0x01DD, 9}, { 0x0199, 9}, { 0x0185, 9},
1503 { 0x015D, 9}, { 0x011B, 9}, { 0x03EF, 10}, { 0x03E1, 10}, { 0x03C8, 10}, { 0x0331, 10},
1504 { 0x0303, 10}, { 0x02F1, 10}, { 0x02A0, 10}, { 0x0233, 10}, { 0x0126, 10}, { 0x07C0, 11},
1505 { 0x076F, 11}, { 0x076C, 11}, { 0x0661, 11}, { 0x0604, 11}, { 0x0572, 11}, { 0x0551, 11},
1506 { 0x046A, 11}, { 0x0274, 11}, { 0x0F27, 12}, { 0x0F24, 12}, { 0x0EDB, 12}, { 0x0C8E, 12},
1507 { 0x0C0B, 12}, { 0x0C0A, 12}, { 0x0AE3, 12}, { 0x08D6, 12}, { 0x0490, 12}, { 0x0495, 12},
1508 { 0x1F19, 13}, { 0x1DB5, 13}, { 0x0009, 4}, { 0x0010, 5}, { 0x0029, 6}, { 0x0062, 7},
1509 { 0x00F3, 8}, { 0x00AD, 8}, { 0x01E5, 9}, { 0x0179, 9}, { 0x009C, 9}, { 0x03B1, 10},
1510 { 0x02AE, 10}, { 0x0127, 10}, { 0x076E, 11}, { 0x0570, 11}, { 0x0275, 11}, { 0x0F25, 12},
1511 { 0x0EC0, 12}, { 0x0AA0, 12}, { 0x08D7, 12}, { 0x1E4C, 13}, { 0x0008, 5}, { 0x0063, 7},
1512 { 0x00AF, 8}, { 0x017B, 9}, { 0x03B3, 10}, { 0x07DD, 11}, { 0x0640, 11}, { 0x0F8D, 12},
1513 { 0x0BC1, 12}, { 0x0491, 12}, { 0x0028, 6}, { 0x00C3, 8}, { 0x0151, 9}, { 0x02A1, 10},
1514 { 0x0573, 11}, { 0x0EC3, 12}, { 0x1F35, 13}, { 0x0065, 7}, { 0x01DA, 9}, { 0x02AF, 10},
1515 { 0x0277, 11}, { 0x08C9, 12}, { 0x1781, 13}, { 0x0025, 7}, { 0x0118, 9}, { 0x0646, 11},
1516 { 0x0AA6, 12}, { 0x1780, 13}, { 0x00C9, 8}, { 0x0321, 10}, { 0x0F9B, 12}, { 0x191E, 13},
1517 { 0x0048, 8}, { 0x07CC, 11}, { 0x0AA1, 12}, { 0x0180, 9}, { 0x0465, 11}, { 0x1905, 13},
1518 { 0x03E2, 10}, { 0x0EC1, 12}, { 0x3C9B, 14}, { 0x02F4, 10}, { 0x08C8, 12}, { 0x07C1, 11},
1519 { 0x0928, 13}, { 0x05E1, 11}, { 0x320D, 14}, { 0x0EC2, 12}, { 0x6418, 15}, { 0x1F34, 13},
1520 { 0x0078, 7}, { 0x0155, 9}, { 0x0552, 11}, { 0x191F, 13}, { 0x00FA, 8}, { 0x07DC, 11},
1521 { 0x1907, 13}, { 0x00AC, 8}, { 0x0249, 11}, { 0x13B1, 14}, { 0x01F6, 9}, { 0x0AE2, 12},
1522 { 0x01DC, 9}, { 0x04ED, 12}, { 0x0184, 9}, { 0x1904, 13}, { 0x0156, 9}, { 0x09D9, 13},
1523 { 0x03E7, 10}, { 0x0929, 13}, { 0x03B2, 10}, { 0x3B68, 14}, { 0x02F5, 10}, { 0x13B0, 14},
1524 { 0x0322, 10}, { 0x3B69, 14}, { 0x0234, 10}, { 0x7935, 15}, { 0x07C7, 11}, { 0xC833, 16},
1525 { 0x0660, 11}, { 0x7934, 15}, { 0x024B, 11}, { 0xC832, 16}, { 0x0AA7, 12}, { 0x1F18, 13},
1526 { 0x007A, 7}
1527 },
1528 {
1529 { 0x0002, 2}, { 0x0000, 3}, { 0x001E, 5}, { 0x0004, 5}, { 0x0012, 6}, { 0x0070, 7},
1530 { 0x001A, 7}, { 0x005F, 8}, { 0x0047, 8}, { 0x01D3, 9}, { 0x00B5, 9}, { 0x0057, 9},
1531 { 0x03B5, 10}, { 0x016D, 10}, { 0x0162, 10}, { 0x07CE, 11}, { 0x0719, 11}, { 0x0691, 11},
1532 { 0x02C6, 11}, { 0x0156, 11}, { 0x0F92, 12}, { 0x0D2E, 12}, { 0x0D20, 12}, { 0x059E, 12},
1533 { 0x0468, 12}, { 0x02A6, 12}, { 0x1DA2, 13}, { 0x1C60, 13}, { 0x1A43, 13}, { 0x0B1D, 13},
1534 { 0x08C0, 13}, { 0x055D, 13}, { 0x0003, 3}, { 0x000A, 5}, { 0x0077, 7}, { 0x00E5, 8},
1535 { 0x01D9, 9}, { 0x03E5, 10}, { 0x0166, 10}, { 0x0694, 11}, { 0x0152, 11}, { 0x059F, 12},
1536 { 0x1F3C, 13}, { 0x1A4B, 13}, { 0x055E, 13}, { 0x000C, 4}, { 0x007D, 7}, { 0x0044, 8},
1537 { 0x03E0, 10}, { 0x0769, 11}, { 0x0E31, 12}, { 0x1F26, 13}, { 0x055C, 13}, { 0x001B, 5},
1538 { 0x00E2, 8}, { 0x03A5, 10}, { 0x02C9, 11}, { 0x1F23, 13}, { 0x3B47, 14}, { 0x0007, 5},
1539 { 0x01D8, 9}, { 0x02D8, 11}, { 0x1F27, 13}, { 0x3494, 14}, { 0x0035, 6}, { 0x03E1, 10},
1540 { 0x059C, 12}, { 0x38C3, 14}, { 0x000C, 6}, { 0x0165, 10}, { 0x1D23, 13}, { 0x1638, 14},
1541 { 0x0068, 7}, { 0x0693, 11}, { 0x3A45, 14}, { 0x0020, 7}, { 0x0F90, 12}, { 0x7CF6, 15},
1542 { 0x00E8, 8}, { 0x058F, 12}, { 0x2CEF, 15}, { 0x0045, 8}, { 0x0B3A, 13}, { 0x01F1, 9},
1543 { 0x3B46, 14}, { 0x01A7, 9}, { 0x1676, 14}, { 0x0056, 9}, { 0x692A, 15}, { 0x038D, 10},
1544 { 0xE309, 16}, { 0x00AA, 10}, { 0x1C611, 17}, { 0x02DF, 11}, { 0xB3B9, 17}, { 0x02C8, 11},
1545 { 0x38C20, 18}, { 0x01B0, 11}, { 0x16390, 18}, { 0x0F9F, 12}, { 0x16771, 18}, { 0x0ED0, 12},
1546 { 0x71843, 19}, { 0x0D2A, 12}, { 0xF9E8C, 20}, { 0x0461, 12}, { 0xF9E8E, 20}, { 0x0B67, 13},
1547 { 0x055F, 13}, { 0x003F, 6}, { 0x006D, 9}, { 0x0E90, 12}, { 0x054E, 13}, { 0x0013, 6},
1548 { 0x0119, 10}, { 0x0B66, 13}, { 0x000B, 6}, { 0x0235, 11}, { 0x7CF5, 15}, { 0x0075, 7},
1549 { 0x0D24, 12}, { 0xF9E9, 16}, { 0x002E, 7}, { 0x1F22, 13}, { 0x0021, 7}, { 0x054F, 13},
1550 { 0x0014, 7}, { 0x3A44, 14}, { 0x00E4, 8}, { 0x7CF7, 15}, { 0x005E, 8}, { 0x7185, 15},
1551 { 0x0037, 8}, { 0x2C73, 15}, { 0x01DB, 9}, { 0x59DD, 16}, { 0x01C7, 9}, { 0x692B, 15},
1552 { 0x01A6, 9}, { 0x58E5, 16}, { 0x00B4, 9}, { 0x1F3D0, 17}, { 0x00B0, 9}, { 0xB1C9, 17},
1553 { 0x03E6, 10}, { 0x16770, 18}, { 0x016E, 10}, { 0x3E7A2, 18}, { 0x011B, 10}, { 0xF9E8D, 20},
1554 { 0x00D9, 10}, { 0xF9E8F, 20}, { 0x00A8, 10}, { 0x2C723, 19}, { 0x0749, 11}, { 0xE3084, 20},
1555 { 0x0696, 11}, { 0x58E45, 20}, { 0x02DE, 11}, { 0xB1C88, 21}, { 0x0231, 11}, { 0x1C610A, 21},
1556 { 0x01B1, 11}, { 0x71842D, 23}, { 0x0D2B, 12}, { 0x38C217, 22}, { 0x0D2F, 12}, { 0x163913, 22},
1557 { 0x05B2, 12}, { 0x163912, 22}, { 0x0469, 12}, { 0x71842C, 23}, { 0x1A42, 13}, { 0x08C1, 13},
1558 { 0x0073, 7}
1559 }
1560 };
1561 
1562 static const uint16_t vlc_offs[] = {
1563  0, 520, 552, 616, 1128, 1160, 1224, 1740, 1772, 1836, 1900, 2436,
1564  2986, 3050, 3610, 4154, 4218, 4746, 5326, 5390, 5902, 6554, 7658, 8342,
1565  9304, 9988, 10630, 11234, 12174, 13006, 13560, 14232, 14786, 15432, 16350, 17522,
1566  20372, 21818, 22330, 22394, 23166, 23678, 23742, 24820, 25332, 25396, 26460, 26980,
1567  27048, 27592, 27600, 27608, 27616, 27624, 28224, 28258, 28290, 28802, 28834, 28866,
1568  29378, 29412, 29444, 29960, 29994, 30026, 30538, 30572, 30604, 31120, 31154, 31186,
1569  31714, 31746, 31778, 32306, 32340, 32372
1570 };
1571 
1572 /**
1573  * Init VC-1 specific tables and VC1Context members
1574  * @param v The VC1Context to initialize
1575  * @return Status
1576  */
1578 {
1579  static int done = 0;
1580  int i = 0;
1581  static VLC_TYPE vlc_table[32372][2];
1582 
1583  v->hrd_rate = v->hrd_buffer = NULL;
1584 
1585  /* VLC tables */
1586  if (!done) {
1588  ff_vc1_bfraction_bits, 1, 1,
1591  ff_vc1_norm2_bits, 1, 1,
1594  ff_vc1_norm6_bits, 1, 1,
1595  ff_vc1_norm6_codes, 2, 2, 556);
1597  ff_vc1_imode_bits, 1, 1,
1599  for (i = 0; i < 3; i++) {
1600  ff_vc1_ttmb_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 0]];
1601  ff_vc1_ttmb_vlc[i].table_allocated = vlc_offs[i * 3 + 1] - vlc_offs[i * 3 + 0];
1603  ff_vc1_ttmb_bits[i], 1, 1,
1605  ff_vc1_ttblk_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 1]];
1606  ff_vc1_ttblk_vlc[i].table_allocated = vlc_offs[i * 3 + 2] - vlc_offs[i * 3 + 1];
1608  ff_vc1_ttblk_bits[i], 1, 1,
1610  ff_vc1_subblkpat_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 2]];
1611  ff_vc1_subblkpat_vlc[i].table_allocated = vlc_offs[i * 3 + 3] - vlc_offs[i * 3 + 2];
1613  ff_vc1_subblkpat_bits[i], 1, 1,
1615  }
1616  for (i = 0; i < 4; i++) {
1617  ff_vc1_4mv_block_pattern_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 9]];
1618  ff_vc1_4mv_block_pattern_vlc[i].table_allocated = vlc_offs[i * 3 + 10] - vlc_offs[i * 3 + 9];
1622  ff_vc1_cbpcy_p_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 10]];
1623  ff_vc1_cbpcy_p_vlc[i].table_allocated = vlc_offs[i * 3 + 11] - vlc_offs[i * 3 + 10];
1625  ff_vc1_cbpcy_p_bits[i], 1, 1,
1627  ff_vc1_mv_diff_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 11]];
1628  ff_vc1_mv_diff_vlc[i].table_allocated = vlc_offs[i * 3 + 12] - vlc_offs[i * 3 + 11];
1630  ff_vc1_mv_diff_bits[i], 1, 1,
1632  }
1633  for (i = 0; i < 8; i++) {
1634  ff_vc1_ac_coeff_table[i].table = &vlc_table[vlc_offs[i * 2 + 21]];
1635  ff_vc1_ac_coeff_table[i].table_allocated = vlc_offs[i * 2 + 22] - vlc_offs[i * 2 + 21];
1637  &vc1_ac_tables[i][0][1], 8, 4,
1638  &vc1_ac_tables[i][0][0], 8, 4, INIT_VLC_USE_NEW_STATIC);
1639  /* initialize interlaced MVDATA tables (2-Ref) */
1640  ff_vc1_2ref_mvdata_vlc[i].table = &vlc_table[vlc_offs[i * 2 + 22]];
1641  ff_vc1_2ref_mvdata_vlc[i].table_allocated = vlc_offs[i * 2 + 23] - vlc_offs[i * 2 + 22];
1643  ff_vc1_2ref_mvdata_bits[i], 1, 1,
1645  }
1646  for (i = 0; i < 4; i++) {
1647  /* initialize 4MV MBMODE VLC tables for interlaced frame P picture */
1648  ff_vc1_intfr_4mv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 37]];
1649  ff_vc1_intfr_4mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 38] - vlc_offs[i * 3 + 37];
1653  /* initialize NON-4MV MBMODE VLC tables for the same */
1654  ff_vc1_intfr_non4mv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 38]];
1655  ff_vc1_intfr_non4mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 39] - vlc_offs[i * 3 + 38];
1659  /* initialize interlaced MVDATA tables (1-Ref) */
1660  ff_vc1_1ref_mvdata_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 39]];
1661  ff_vc1_1ref_mvdata_vlc[i].table_allocated = vlc_offs[i * 3 + 40] - vlc_offs[i * 3 + 39];
1663  ff_vc1_1ref_mvdata_bits[i], 1, 1,
1665  }
1666  for (i = 0; i < 4; i++) {
1667  /* Initialize 2MV Block pattern VLC tables */
1668  ff_vc1_2mv_block_pattern_vlc[i].table = &vlc_table[vlc_offs[i + 49]];
1669  ff_vc1_2mv_block_pattern_vlc[i].table_allocated = vlc_offs[i + 50] - vlc_offs[i + 49];
1673  }
1674  for (i = 0; i < 8; i++) {
1675  /* Initialize interlaced CBPCY VLC tables (Table 124 - Table 131) */
1676  ff_vc1_icbpcy_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 53]];
1677  ff_vc1_icbpcy_vlc[i].table_allocated = vlc_offs[i * 3 + 54] - vlc_offs[i * 3 + 53];
1679  ff_vc1_icbpcy_p_bits[i], 1, 1,
1681  /* Initialize interlaced field picture MBMODE VLC tables */
1682  ff_vc1_if_mmv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 54]];
1683  ff_vc1_if_mmv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 55] - vlc_offs[i * 3 + 54];
1685  ff_vc1_if_mmv_mbmode_bits[i], 1, 1,
1687  ff_vc1_if_1mv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 55]];
1688  ff_vc1_if_1mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 56] - vlc_offs[i * 3 + 55];
1690  ff_vc1_if_1mv_mbmode_bits[i], 1, 1,
1692  }
1693  done = 1;
1694  }
1695 
1696  /* Other defaults */
1697  v->pq = -1;
1698  v->mvrange = 0; /* 7.1.1.18, p80 */
1699 
1700  return 0;
1701 }
static unsigned int show_bits_long(GetBitContext *s, int n)
Show 0-32 bits.
Definition: get_bits.h:378
in the bitstream is reported as 00b
Definition: vc1.h:173
const uint8_t ff_vc1_imode_codes[7]
Definition: vc1data.c:214
const uint8_t ff_vc1_icbpcy_p_bits[8][63]
Definition: vc1data.c:793
#define VC1_TTBLK_VLC_BITS
Definition: vc1data.c:126
float v
const uint8_t ff_vc1_mv_pmode_table[2][5]
MV P mode - the 5th element is only used for mode 1.
Definition: vc1data.c:43
uint8_t bfraction_lut_index
Index for BFRACTION value (see Table 40, reproduced into ff_vc1_bfraction_lut[])
Definition: vc1.h:395
int p_frame_skipped
Definition: vc1.h:386
Imode
Imode types.
Definition: vc1.c:54
const uint8_t ff_vc1_mv_diff_bits[4][73]
Definition: vc1data.c:987
The VC1 Context.
Definition: vc1.h:182
VLC ff_vc1_ttblk_vlc[3]
Definition: vc1data.c:127
#define VC1_ICBPCY_VLC_BITS
Definition: vc1data.c:120
const uint8_t ff_vc1_pquant_table[3][32]
Definition: vc1data.c:89
uint8_t lumscale2
for interlaced field P picture
Definition: vc1.h:344
int k_x
Number of bits for MVs (depends on MV range)
Definition: vc1.h:241
void(* vc1_inv_trans_8x4)(uint8_t *dest, int line_size, int16_t *block)
Definition: vc1dsp.h:40
int reffield
if numref = 0 (1 reference) then reffield decides which
Definition: vc1.h:364
const uint8_t ff_vc1_norm2_codes[4]
Definition: vc1data.c:222
void ff_simple_idct84_add(uint8_t *dest, int line_size, int16_t *block)
Definition: simple_idct.c:180
const uint8_t ff_vc1_2ref_mvdata_bits[8][126]
Definition: vc1data.c:565
void(* vc1_inv_trans_4x8)(uint8_t *dest, int line_size, int16_t *block)
Definition: vc1dsp.h:41
const uint8_t ff_vc1_if_1mv_mbmode_codes[8][6]
Definition: vc1data.c:319
int mv_type_is_raw
mv type mb plane is not coded
Definition: vc1.h:295
Explicitly specified at frame level.
Definition: vc1.h:63
uint8_t dmvrange
Frame decoding info for interlaced picture.
Definition: vc1.h:341
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:255
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: avcodec.h:4153
#define AC_VLC_BITS
Definition: intrax8.c:37
int max_b_frames
maximum number of B-frames between non-B-frames Note: The output will be delayed by max_b_frames+1 re...
Definition: avcodec.h:1397
int tt_index
Index for Transform Type tables (to decode TTMB)
Definition: vc1.h:291
#define VC1_2REF_MVDATA_VLC_BITS
Definition: vc1data.c:140
int extended_mv
Ext MV in P/B (not in Simple)
Definition: vc1.h:229
int broadcast
TFF/RFF present.
Definition: vc1.h:209
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:1848
int num
numerator
Definition: rational.h:44
int next_use_ic
Definition: vc1.h:303
void avcodec_set_dimensions(AVCodecContext *s, int width, int height)
Definition: utils.c:233
const uint8_t ff_vc1_4mv_block_pattern_bits[4][16]
Definition: vc1data.c:250
uint8_t rangeredfrm
Frame decoding info for S/M profiles only.
Definition: vc1.h:308
Definition: vc1.c:55
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel...
Definition: avcodec.h:1517
void av_log(void *avcl, int level, const char *fmt,...) av_printf_format(3
Send the specified message to the log if the level is less than or equal to the current av_log_level...
const uint8_t ff_vc1_cbpcy_p_bits[4][64]
Definition: vc1data.c:682
const int ff_vc1_fps_nr[7]
Definition: vc1data.c:87
int frfd
Definition: vc1.h:373
#define VLC_TYPE
Definition: get_bits.h:61
mpegvideo header.
int intcompfield
which of the two fields to be intensity compensated
Definition: vc1.h:366
VLC * imv_vlc
Definition: vc1.h:347
av_dlog(ac->avr,"%d samples - audio_convert: %s to %s (%s)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt), use_generic?ac->func_descr_generic:ac->func_descr)
uint8_t dqprofile
Definition: vc1.h:252
discard all
Definition: avcodec.h:618
int last_use_ic
Definition: vc1.h:303
int fastuvmc
Rounding of qpel vector to hpel ? (not in Simple)
Definition: vc1.h:228
int stride
Definition: mace.c:144
#define av_cold
Definition: avcodec.h:653
VLC ff_vc1_2ref_mvdata_vlc[8]
Definition: vc1data.c:141
static int bitplane_decoding(uint8_t *data, int *raw_flag, VC1Context *v)
Decode a bitplane&#39;s bits.
Definition: vc1.c:116
int frmrtq_postproc
3bits,
Definition: vc1.h:225
const uint8_t ff_vc1_adv_progressive_4x8_zz[32]
Definition: vc1data.c:1036
static int vop_dquant_decoding(VC1Context *v)
VOP Dquant decoding.
Definition: vc1.c:245
uint8_t rff
Definition: vc1.h:317
Predicted.
Definition: avcodec.h:2305
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avcodec.h:1265
int hrd_param_flag
Presence of Hypothetical Reference Decoder parameters.
Definition: vc1.h:215
uint8_t lumshift2
Definition: vc1.h:345
const uint8_t ff_vc1_1ref_mvdata_bits[4][72]
Definition: vc1data.c:390
int range_x
Definition: vc1.h:243
#define VC1_4MV_BLOCK_PATTERN_VLC_BITS
Definition: vc1data.c:122
uint8_t dqsbedge
Definition: vc1.h:253
const uint8_t ff_vc1_ttmb_bits[3][16]
Definition: vc1data.c:882
int refdist
distance of the current picture from reference
Definition: vc1.h:361
uint8_t * acpred_plane
AC prediction flags bitplane.
Definition: vc1.h:327
int res_transtab
reserved, always 0
Definition: vc1.h:197
VC-1 tables.
int bi_type
Definition: vc1.h:387
const uint8_t ff_vc1_2mv_block_pattern_codes[4][4]
Definition: vc1data.c:258
uint8_t
int first_pic_header_flag
Definition: vc1.h:374
uint16_t * hrd_rate
Definition: vc1.h:332
const uint8_t ff_vc1_2mv_block_pattern_bits[4][4]
Definition: vc1data.c:262
int panscanflag
NUMPANSCANWIN, TOPLEFT{X,Y}, BOTRIGHT{X,Y} present.
Definition: vc1.h:212
av_cold int ff_vc1_init_common(VC1Context *v)
Init VC-1 specific tables and VC1Context members.
Definition: vc1.c:1577
#define INIT_VLC_STATIC(vlc, bits, a, b, c, d, e, f, g, static_size)
Definition: get_bits.h:471
void(* vc1_inv_trans_8x8)(int16_t *b)
Definition: vc1dsp.h:39
const AVRational ff_vc1_pixel_aspect[16]
Definition: vc1data.c:194
static const uint8_t offset[511][2]
Definition: vf_uspp.c:58
VLC ff_vc1_cbpcy_p_vlc[4]
Definition: vc1data.c:119
int interlace
Progressive/interlaced (RPTFTM syntax element)
Definition: vc1.h:210
const uint16_t ff_vc1_icbpcy_p_codes[8][63]
Definition: vc1data.c:710
int y_ac_table_index
Luma index from AC2FRM element.
Definition: vc1.h:261
int second_field
Definition: vc1.h:360
int c_ac_table_index
AC coding set indexes.
Definition: vc1.h:260
const int ff_vc1_ac_sizes[AC_MODES]
Definition: vc1data.c:1133
void(* vc1_inv_trans_8x4_dc)(uint8_t *dest, int line_size, int16_t *block)
Definition: vc1dsp.h:44
int ttfrm
Transform type info present at frame level.
Definition: vc1.h:263
int resync_marker
could this stream contain resync markers
Definition: mpegvideo.h:596
uint8_t aux_luty[2][256]
Definition: vc1.h:300
int16_t bfraction
Relative position % anchors=&gt; how to scale MVs.
Definition: vc1.h:278
const uint8_t ff_vc1_if_mmv_mbmode_bits[8][8]
Definition: vc1data.c:308
int profile
Sequence header data for all Profiles TODO: choose between ints, uint8_ts and monobit flags...
Definition: vc1.h:224
const char data[16]
Definition: mxf.c:68
MSMPEG4 data tables.
int refdist_flag
REFDIST syntax element present in II, IP, PI or PP field picture headers.
Definition: vc1.h:213
uint8_t * forward_mb_plane
bitplane for &quot;forward&quot; MBs
Definition: vc1.h:294
uint8_t last_luty[2][256]
Definition: vc1.h:299
VLC ff_vc1_norm2_vlc
Definition: vc1data.c:110
int mb_height
number of MBs horizontally &amp; vertically
Definition: mpegvideo.h:281
const uint8_t ff_vc1_imode_bits[7]
Definition: vc1data.c:217
int ff_vc1_decode_sequence_header(AVCodecContext *avctx, VC1Context *v, GetBitContext *gb)
Decode Simple/Main Profiles sequence header.
Definition: vc1.c:294
const uint8_t ff_vc1_subblkpat_bits[3][15]
Definition: vc1data.c:930
VLC ff_vc1_4mv_block_pattern_vlc[4]
Definition: vc1data.c:123
int fieldtx_is_raw
Definition: vc1.h:353
Non-uniform quant used for all frames.
Definition: vc1.h:64
uint8_t * over_flags_plane
Overflags bitplane.
Definition: vc1.h:329
uint8_t dqbilevel
Definition: vc1.h:254
int range_y
MV range.
Definition: vc1.h:243
uint8_t last_lutuv[2][256]
lookup tables used for intensity compensation
Definition: vc1.h:299
int psf
Progressive Segmented Frame.
Definition: vc1.h:217
uint8_t ttmbf
Transform type flag.
Definition: vc1.h:264
static void rotate_luts(VC1Context *v)
Definition: vc1.c:603
int k_y
Number of bits for MVs (depends on MV range)
Definition: vc1.h:242
static const uint16_t vlc_offs[]
Definition: vc1.c:1562
Implicitly specified at frame level.
Definition: vc1.h:62
#define ROTATE(DEF, L, N, C, A)
static void decode_colskip(uint8_t *plane, int width, int height, int stride, GetBitContext *gb)
Decode columns by checking if they are skipped.
Definition: vc1.c:93
int dmb_is_raw
direct mb plane is raw
Definition: vc1.h:296
void(* vc1_inv_trans_8x8_dc)(uint8_t *dest, int line_size, int16_t *block)
Definition: vc1dsp.h:43
#define VC1_CBPCY_P_VLC_BITS
Definition: vc1data.c:118
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: avcodec.h:4147
int res_y411
reserved, old interlaced mode
Definition: vc1.h:193
int overlap
overlapped transforms in use
Definition: vc1.h:232
in the bitstream is reported as 11b
Definition: vc1.h:175
int res_x8
reserved
Definition: vc1.h:194
int qs_last
if qpel has been used in the previous (tr.) picture
Definition: vc1.h:371
void(* vc1_inv_trans_4x4)(uint8_t *dest, int line_size, int16_t *block)
Definition: vc1dsp.h:42
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: avcodec.h:4168
struct AVCodec * codec
Definition: avcodec.h:1155
TODO: WMV9 specific.
Definition: vc1.h:54
#define VC1_BFRACTION_VLC_BITS
Definition: vc1data.c:105
VLC ff_vc1_imode_vlc
Definition: vc1data.c:108
VLC * mbmode_vlc
Definition: vc1.h:346
int quarter_sample
1-&gt;qpel, 0-&gt;half pel ME/MC
Definition: mpegvideo.h:584
GetBitContext gb
Definition: mpegvideo.h:654
const int ff_vc1_ttfrm_to_tt[4]
Definition: vc1data.c:40
VLC ff_vc1_norm6_vlc
Definition: vc1data.c:112
Libavcodec external API header.
uint8_t broken_link
Broken link flag (BROKEN_LINK syntax element)
Definition: vc1.h:396
const uint8_t * zz_8x4
Zigzag scan table for TT_8x4 coding mode.
Definition: vc1.h:247
int postprocflag
Per-frame processing suggestion flag present.
Definition: vc1.h:208
int res_rtm_flag
reserved, set to 1
Definition: vc1.h:200
void(* vc1_inv_trans_4x4_dc)(uint8_t *dest, int line_size, int16_t *block)
Definition: vc1dsp.h:46
const uint8_t ff_wmv2_scantableB[64]
Definition: msmpeg4data.c:1994
#define VC1_IF_1MV_MBMODE_VLC_BITS
Definition: vc1data.c:136
static void decode_rowskip(uint8_t *plane, int width, int height, int stride, GetBitContext *gb)
Decode rows by checking if they are skipped.
Definition: vc1.c:71
int ff_vc1_parse_frame_header_adv(VC1Context *v, GetBitContext *gb)
Definition: vc1.c:843
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)
Reduce a fraction.
Definition: rational.c:35
VLC ff_vc1_ttmb_vlc[3]
Definition: vc1data.c:115
const uint16_t ff_vc1_norm6_codes[64]
Definition: vc1data.c:229
int cur_field_type
0: top, 1: bottom
Definition: vc1.h:368
VLC * twomvbp_vlc
Definition: vc1.h:348
const uint8_t * zz_4x8
Zigzag scan table for TT_4x8 coding mode.
Definition: vc1.h:248
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:167
int x8_type
Definition: vc1.h:388
const uint16_t ff_vc1_cbpcy_p_codes[4][64]
Definition: vc1data.c:655
VLC ff_vc1_icbpcy_vlc[8]
Definition: vc1data.c:121
float y
const int ff_vc1_fps_dr[2]
Definition: vc1data.c:88
int tfcntrflag
TFCNTR present.
Definition: vc1.h:211
int field_mode
1 for interlaced field pictures
Definition: vc1.h:358
int width
picture width / height.
Definition: avcodec.h:1314
#define VC1_SUBBLKPAT_VLC_BITS
Definition: vc1data.c:128
uint8_t * mbskip_table
used to avoid copy if macroblock skipped (for black regions for example) and used for b-frame encodin...
Definition: mpegvideo.h:363
uint8_t mv_mode
Frame decoding info for all profiles.
Definition: vc1.h:239
Picture * current_picture_ptr
pointer to the current picture
Definition: mpegvideo.h:351
int fourmvswitch
Definition: vc1.h:342
void ff_simple_idct48_add(uint8_t *dest, int line_size, int16_t *block)
Definition: simple_idct.c:195
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:1827
int ff_vc1_parse_frame_header(VC1Context *v, GetBitContext *gb)
Definition: vc1.c:626
uint8_t lumscale
Luma compensation parameters.
Definition: vc1.h:275
const uint32_t ff_vc1_1ref_mvdata_codes[4][72]
Definition: vc1data.c:343
static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE(*table)[2], int bits, int max_depth)
Parse a vlc code.
Definition: get_bits.h:550
uint8_t range_mapuv_flag
Definition: vc1.h:335
uint8_t closed_entry
Closed entry point flag (CLOSED_ENTRY syntax element)
Definition: vc1.h:397
int ticks_per_frame
For some codecs, the time base is closer to the field rate than the frame rate.
Definition: avcodec.h:1274
int intcomp
Definition: vc1.h:343
#define INIT_VLC_USE_NEW_STATIC
Definition: get_bits.h:469
uint8_t * fieldtx_plane
Definition: vc1.h:352
VLC * cbpcy_vlc
CBPCY VLC table.
Definition: vc1.h:290
const uint8_t ff_vc1_norm6_bits[64]
Definition: vc1data.c:236
static int decode210(GetBitContext *gb)
Definition: get_bits.h:575
VLC ff_vc1_bfraction_vlc
Definition: vc1data.c:106
int table_allocated
Definition: get_bits.h:66
uint8_t aux_lutuv[2][256]
lookup tables used for intensity compensation
Definition: vc1.h:300
int rangered
RANGEREDFRM (range reduction) syntax element present at frame level.
Definition: vc1.h:198
int finterpflag
INTERPFRM present.
Definition: vc1.h:234
static int width
Definition: utils.c:158
#define AV_LOG_INFO
Standard information.
Definition: avcodec.h:4158
#define AC_MODES
Definition: vc1data.h:204
static int decode_sequence_header_adv(VC1Context *v, GetBitContext *gb)
Definition: vc1.c:417
int chromaformat
2bits, 2=4:2:0, only defined
Definition: vc1.h:207
int res_sprite
Simple/Main Profile sequence header.
Definition: vc1.h:192
const uint8_t ff_vc1_ttblk_codes[3][8]
Definition: vc1data.c:913
enum AVCodecID codec_id
Definition: avcodec.h:1157
const uint8_t ff_vc1_4mv_block_pattern_codes[4][16]
Definition: vc1data.c:244
const uint8_t ff_vc1_intfr_non4mv_mbmode_codes[4][9]
Definition: vc1data.c:282
int multires
frame-level RESPIC syntax element present
Definition: vc1.h:195
main external API structure.
Definition: avcodec.h:1146
const uint8_t ff_wmv2_scantableA[64]
Definition: msmpeg4data.c:1987
uint8_t range_mapy
Definition: vc1.h:336
int curr_use_ic
Definition: vc1.h:303
#define init_vlc(vlc, nb_bits, nb_codes,bits, bits_wrap, bits_size,codes, codes_wrap, codes_size,flags)
Definition: get_bits.h:452
int extended_dmv
Additional extended dmv range at P/B frame-level.
Definition: vc1.h:214
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:299
BYTE int const BYTE int int int height
Definition: avisynth_c.h:713
static void skip_bits1(GetBitContext *s)
Definition: get_bits.h:324
int fmb_is_raw
forward mb plane is raw
Definition: vc1.h:297
const uint16_t ff_vc1_ttmb_codes[3][16]
Definition: vc1data.c:852
int fptype
Definition: vc1.h:359
Bi-dir predicted.
Definition: avcodec.h:2306
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:292
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:1841
rational number numerator/denominator
Definition: rational.h:43
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:1834
const uint16_t ff_vc1_intfr_4mv_mbmode_codes[4][15]
Definition: vc1data.c:267
#define VC1_2MV_BLOCK_PATTERN_VLC_BITS
Definition: vc1data.c:124
int aux_use_ic
Definition: vc1.h:303
uint8_t respic
Frame-level flag for resized images.
Definition: vc1.h:280
#define INIT_LUT(lumscale, lumshift, luty, lutuv, chain)
Definition: vc1.c:581
int skip_is_raw
skip mb plane is not coded
Definition: vc1.h:298
VLC ff_vc1_if_mmv_mbmode_vlc[8]
Definition: vc1data.c:135
int quantizer_mode
2bits, quantizer mode used for sequence, see QUANT_*
Definition: vc1.h:233
uint8_t next_lutuv[2][256]
lookup tables used for intensity compensation
Definition: vc1.h:301
int ref_field_type[2]
forward and backward reference field type (top or bottom)
Definition: vc1.h:369
uint8_t * direct_mb_plane
bitplane for &quot;direct&quot; MBs
Definition: vc1.h:293
uint8_t mvrange
Ranges:0 -&gt; [-64n 63.f] x [-32, 31.f]1 -&gt; [-128, 127.f] x [-64, 63.f]2 -&gt; [-512, 511.f] x [-128, 127.f]3 -&gt; [-1024, 1023.f] x [-256, 255.f].
Definition: vc1.h:288
int max_b_frames
max number of b-frames for encoding
Definition: mpegvideo.h:266
int pict_type
AV_PICTURE_TYPE_I, AV_PICTURE_TYPE_P, AV_PICTURE_TYPE_B, ...
Definition: mpegvideo.h:381
int max_coded_width
Definition: vc1.h:227
uint8_t * mv_type_mb_plane
bitplane for mv_type == (4MV)
Definition: vc1.h:292
int vstransform
variable-size [48]x[48] transform type + info
Definition: vc1.h:231
VLC ff_vc1_if_1mv_mbmode_vlc[8]
Definition: vc1data.c:137
int numref
number of past field pictures used as reference
Definition: vc1.h:362
void avpriv_report_missing_feature(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
uint8_t range_mapuv
Definition: vc1.h:337
void ff_simple_idct_add_8(uint8_t *dest, int line_size, int16_t *block)
uint8_t tff
Definition: vc1.h:317
VLC ff_vc1_mv_diff_vlc[4]
Definition: vc1data.c:117
const uint8_t ff_vc1_intfr_4mv_mbmode_bits[4][15]
Definition: vc1data.c:274
MpegEncContext s
Definition: vc1.h:183
const uint8_t ff_vc1_intfr_non4mv_mbmode_bits[4][9]
Definition: vc1data.c:289
in the bitstream is reported as 10b
Definition: vc1.h:174
const uint8_t ff_vc1_bfraction_bits[23]
Definition: vc1data.c:174
struct AVCodecContext * avctx
Definition: mpegvideo.h:247
uint8_t pq
Definition: vc1.h:244
int max_coded_height
Definition: vc1.h:227
const uint8_t ff_vc1_bfraction_codes[23]
Definition: vc1data.c:183
int pqindex
raw pqindex used in coding set selection
Definition: vc1.h:268
#define VC1_1REF_MVDATA_VLC_BITS
Definition: vc1data.c:138
int hrd_num_leaky_buckets
Definition: vc1.h:324
#define VC1_IF_MMV_MBMODE_VLC_BITS
Definition: vc1data.c:134
common internal api header.
int mb_stride
mb_width+1 used for some arrays to allow simple addressing of left &amp; top MBs without sig11 ...
Definition: mpegvideo.h:282
VLC ff_vc1_2mv_block_pattern_vlc[4]
Definition: vc1data.c:125
#define VC1_TTMB_VLC_BITS
Definition: vc1data.c:114
static int get_unary(GetBitContext *gb, int stop, int len)
Get unary code of limited length.
Definition: unary.h:33
#define VC1_IMODE_VLC_BITS
Definition: vc1data.c:107
enum FrameCodingMode fcm
Frame decoding info for Advanced profile.
Definition: vc1.h:314
uint8_t dquantfrm
pquant parameters
Definition: vc1.h:251
uint8_t lumshift
Definition: vc1.h:276
uint8_t next_luty[2][256]
Definition: vc1.h:301
void ff_simple_idct44_add(uint8_t *dest, int line_size, int16_t *block)
Definition: simple_idct.c:210
int res_fasttx
reserved, always 1
Definition: vc1.h:196
enum AVDiscard skip_loop_filter
Skip loop filtering for selected frames.
Definition: avcodec.h:2764
#define VC1_MV_DIFF_VLC_BITS
Definition: vc1data.c:116
int pic_header_flag
Definition: vc1.h:375
int den
denominator
Definition: rational.h:45
#define VC1_NORM2_VLC_BITS
Definition: vc1data.c:109
VLC ff_vc1_ac_coeff_table[8]
Definition: vc1data.c:143
const uint8_t ff_vc1_adv_progressive_8x4_zz[32]
Definition: vc1data.c:1029
uint8_t postproc
Definition: vc1.h:323
uint8_t condover
Definition: vc1.h:331
int ff_vc1_decode_entry_point(AVCodecContext *avctx, VC1Context *v, GetBitContext *gb)
Definition: vc1.c:525
#define VC1_INTFR_4MV_MBMODE_VLC_BITS
Definition: vc1data.c:130
static const uint32_t vc1_ac_tables[AC_MODES][186][2]
Definition: vc1.c:1341
uint8_t uvsamp
Definition: vc1.h:322
uint8_t pquantizer
Uniform (over sequence) quantizer in use.
Definition: vc1.h:289
int rnd
rounding control
Definition: vc1.h:304
#define AVERROR_INVALIDDATA
simple idct header.
const uint8_t ff_vc1_ttblk_bits[3][8]
Definition: vc1data.c:918
int acpred_is_raw
Definition: vc1.h:328
uint8_t rptfrm
Definition: vc1.h:317
uint8_t(* curr_luty)[256]
Definition: vc1.h:302
static int decode012(GetBitContext *gb)
Definition: get_bits.h:565
VLC_TYPE(* table)[2]
code, bits
Definition: get_bits.h:65
VLC ff_vc1_1ref_mvdata_vlc[4]
Definition: vc1data.c:139
int bitrtq_postproc
5bits, quantized framerate-based postprocessing strength
Definition: vc1.h:226
int parse_only
Context is used within parser.
Definition: vc1.h:401
int overflg_is_raw
Definition: vc1.h:330
uint8_t interpfrm
Definition: vc1.h:309
struct AVFrame f
Definition: mpegvideo.h:98
Definition: vc1.h:136
const uint8_t ff_vc1_subblkpat_codes[3][15]
Definition: vc1data.c:925
int level
Advanced Profile.
Definition: vc1.h:206
#define VC1_NORM6_VLC_BITS
Definition: vc1data.c:111
uint8_t range_mapy_flag
Definition: vc1.h:334
int brfd
reference frame distance (forward or backward)
Definition: vc1.h:373
the normal 219*2^(n-8) &quot;MPEG&quot; YUV ranges
Definition: frame.h:48
int dquant
How qscale varies with MBs, 2bits (not in Simple)
Definition: vc1.h:230
uint8_t mv_mode2
Secondary MV coding mode (B frames)
Definition: vc1.h:240
const uint8_t ff_vc1_if_1mv_mbmode_bits[8][6]
Definition: vc1data.c:329
const uint8_t ff_vc1_norm2_bits[4]
Definition: vc1data.c:225
uint16_t * hrd_buffer
Definition: vc1.h:332
int mv_table_index
Definition: mpegvideo.h:636
const uint8_t ff_vc1_if_mmv_mbmode_codes[8][8]
Definition: vc1data.c:298
const uint8_t ff_vc1_mv_pmode_table2[2][4]
Definition: vc1data.c:47
#define VC1_INTFR_NON4MV_MBMODE_VLC_BITS
Definition: vc1data.c:132
VLC * fourmvbp_vlc
Definition: vc1.h:349
VLC ff_vc1_intfr_non4mv_mbmode_vlc[4]
Definition: vc1data.c:133
VLC ff_vc1_intfr_4mv_mbmode_vlc[4]
Definition: vc1data.c:131
int dc_table_index
Definition: mpegvideo.h:639
VLC ff_vc1_subblkpat_vlc[3]
Definition: vc1data.c:129
uint8_t halfpq
Uniform quant over image and qp+.5.
Definition: vc1.h:279
VC1DSPContext vc1dsp
Definition: vc1.h:186
uint8_t((* curr_lutuv)[256]
Definition: vc1.h:302
const uint32_t ff_vc1_2ref_mvdata_codes[8][126]
Definition: vc1data.c:418
void(* vc1_inv_trans_4x8_dc)(uint8_t *dest, int line_size, int16_t *block)
Definition: vc1dsp.h:45
const uint16_t ff_vc1_mv_diff_codes[4][73]
Definition: vc1data.c:937
void ff_simple_idct_8(int16_t *block)
const int16_t ff_vc1_bfraction_lut[23]
Definition: vc1data.c:163
uint8_t altpq
Current/alternate frame quantizer scale.
Definition: vc1.h:244