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