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