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