FFmpeg  4.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  if (get_bits_left(gb) < 5)
676  return AVERROR_INVALIDDATA;
677  /* Quantizer stuff */
678  pqindex = get_bits(gb, 5);
679  if (!pqindex)
680  return -1;
682  v->pq = ff_vc1_pquant_table[0][pqindex];
683  else
684  v->pq = ff_vc1_pquant_table[1][pqindex];
685  v->pqindex = pqindex;
686  if (pqindex < 9)
687  v->halfpq = get_bits1(gb);
688  else
689  v->halfpq = 0;
690  switch (v->quantizer_mode) {
692  v->pquantizer = pqindex < 9;
693  break;
694  case QUANT_NON_UNIFORM:
695  v->pquantizer = 0;
696  break;
698  v->pquantizer = get_bits1(gb);
699  break;
700  default:
701  v->pquantizer = 1;
702  break;
703  }
704  v->dquantfrm = 0;
705  if (v->extended_mv == 1)
706  v->mvrange = get_unary(gb, 0, 3);
707  v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
708  v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
709  v->range_x = 1 << (v->k_x - 1);
710  v->range_y = 1 << (v->k_y - 1);
711  if (v->multires && v->s.pict_type != AV_PICTURE_TYPE_B)
712  v->respic = get_bits(gb, 2);
713 
714  if (v->res_x8 && (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)) {
715  v->x8_type = get_bits1(gb);
716  } else
717  v->x8_type = 0;
718  ff_dlog(v->s.avctx, "%c Frame: QP=[%i]%i (+%i/2) %i\n",
719  (v->s.pict_type == AV_PICTURE_TYPE_P) ? 'P' : ((v->s.pict_type == AV_PICTURE_TYPE_I) ? 'I' : 'B'),
720  pqindex, v->pq, v->halfpq, v->rangeredfrm);
721 
722  if (v->first_pic_header_flag)
723  rotate_luts(v);
724 
725  switch (v->s.pict_type) {
726  case AV_PICTURE_TYPE_P:
727  v->tt_index = (v->pq > 4) + (v->pq > 12);
728 
729  lowquant = (v->pq > 12) ? 0 : 1;
730  v->mv_mode = ff_vc1_mv_pmode_table[lowquant][get_unary(gb, 1, 4)];
731  if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
732  v->mv_mode2 = ff_vc1_mv_pmode_table2[lowquant][get_unary(gb, 1, 3)];
733  v->lumscale = get_bits(gb, 6);
734  v->lumshift = get_bits(gb, 6);
735  v->last_use_ic = 1;
736  /* fill lookup tables for intensity compensation */
737  INIT_LUT(v->lumscale, v->lumshift, v->last_luty[0], v->last_lutuv[0], 1);
738  INIT_LUT(v->lumscale, v->lumshift, v->last_luty[1], v->last_lutuv[1], 1);
739  }
740  v->qs_last = v->s.quarter_sample;
741  if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
745  } else {
748  v->s.mspel = (v->mv_mode != MV_PMODE_1MV_HPEL_BILIN);
749  }
750 
751  if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
752  v->mv_mode2 == MV_PMODE_MIXED_MV) ||
753  v->mv_mode == MV_PMODE_MIXED_MV) {
755  if (status < 0)
756  return -1;
757  av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
758  "Imode: %i, Invert: %i\n", status>>1, status&1);
759  } else {
760  v->mv_type_is_raw = 0;
761  memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
762  }
763  status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
764  if (status < 0)
765  return -1;
766  av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
767  "Imode: %i, Invert: %i\n", status>>1, status&1);
768 
769  if (get_bits_left(gb) < 4)
770  return AVERROR_INVALIDDATA;
771 
772  /* Hopefully this is correct for P-frames */
773  v->s.mv_table_index = get_bits(gb, 2); //but using ff_vc1_ tables
774  v->cbptab = get_bits(gb, 2);
776 
777  if (v->dquant) {
778  av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
780  }
781 
782  if (v->vstransform) {
783  v->ttmbf = get_bits1(gb);
784  if (v->ttmbf) {
785  v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
786  } else
787  v->ttfrm = 0; //FIXME Is that so ?
788  } else {
789  v->ttmbf = 1;
790  v->ttfrm = TT_8X8;
791  }
792  break;
793  case AV_PICTURE_TYPE_B:
794  v->tt_index = (v->pq > 4) + (v->pq > 12);
795 
797  v->qs_last = v->s.quarter_sample;
798  v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
799  v->s.mspel = v->s.quarter_sample;
800 
801  status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
802  if (status < 0)
803  return -1;
804  av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
805  "Imode: %i, Invert: %i\n", status>>1, status&1);
806  status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
807  if (status < 0)
808  return -1;
809  av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
810  "Imode: %i, Invert: %i\n", status>>1, status&1);
811 
812  v->s.mv_table_index = get_bits(gb, 2);
813  v->cbptab = get_bits(gb, 2);
815 
816  if (v->dquant) {
817  av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
819  }
820 
821  if (v->vstransform) {
822  v->ttmbf = get_bits1(gb);
823  if (v->ttmbf) {
824  v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
825  } else
826  v->ttfrm = 0;
827  } else {
828  v->ttmbf = 1;
829  v->ttfrm = TT_8X8;
830  }
831  break;
832  }
833 
834  if (!v->x8_type) {
835  /* AC Syntax */
836  v->c_ac_table_index = decode012(gb);
838  v->y_ac_table_index = decode012(gb);
839  }
840  /* DC Syntax */
841  v->s.dc_table_index = get_bits1(gb);
842  }
843 
844  if (v->s.pict_type == AV_PICTURE_TYPE_BI) {
846  v->bi_type = 1;
847  }
848  return 0;
849 }
850 
852 {
853  int pqindex, lowquant;
854  int status;
855  int field_mode, fcm;
856 
857  v->numref = 0;
858  v->p_frame_skipped = 0;
859  if (v->second_field) {
860  if (v->fcm != ILACE_FIELD || v->field_mode!=1)
861  return -1;
862  if (v->fptype & 4)
864  else
867  if (!v->pic_header_flag)
868  goto parse_common_info;
869  }
870 
871  field_mode = 0;
872  if (v->interlace) {
873  fcm = decode012(gb);
874  if (fcm) {
875  if (fcm == ILACE_FIELD)
876  field_mode = 1;
877  }
878  } else {
879  fcm = PROGRESSIVE;
880  }
881  if (!v->first_pic_header_flag && v->field_mode != field_mode)
882  return AVERROR_INVALIDDATA;
883  v->field_mode = field_mode;
884  v->fcm = fcm;
885 
886  av_assert0( v->s.mb_height == v->s.height + 15 >> 4
887  || v->s.mb_height == FFALIGN(v->s.height + 15 >> 4, 2));
888  if (v->field_mode) {
889  v->s.mb_height = FFALIGN(v->s.height + 15 >> 4, 2);
890  v->fptype = get_bits(gb, 3);
891  if (v->fptype & 4) // B-picture
893  else
895  } else {
896  v->s.mb_height = v->s.height + 15 >> 4;
897  switch (get_unary(gb, 0, 4)) {
898  case 0:
900  break;
901  case 1:
903  break;
904  case 2:
906  break;
907  case 3:
909  break;
910  case 4:
911  v->s.pict_type = AV_PICTURE_TYPE_P; // skipped pic
912  v->p_frame_skipped = 1;
913  break;
914  }
915  }
916  if (v->tfcntrflag)
917  skip_bits(gb, 8);
918  if (v->broadcast) {
919  if (!v->interlace || v->psf) {
920  v->rptfrm = get_bits(gb, 2);
921  } else {
922  v->tff = get_bits1(gb);
923  v->rff = get_bits1(gb);
924  }
925  } else {
926  v->tff = 1;
927  }
928  if (v->panscanflag) {
929  avpriv_report_missing_feature(v->s.avctx, "Pan-scan");
930  //...
931  }
932  if (v->p_frame_skipped) {
933  return 0;
934  }
935  v->rnd = get_bits1(gb);
936  if (v->interlace)
937  v->uvsamp = get_bits1(gb);
939  return 0; //parsing only, vlc tables havnt been allocated
940  if (v->field_mode) {
941  if (!v->refdist_flag)
942  v->refdist = 0;
943  else if ((v->s.pict_type != AV_PICTURE_TYPE_B) && (v->s.pict_type != AV_PICTURE_TYPE_BI)) {
944  v->refdist = get_bits(gb, 2);
945  if (v->refdist == 3)
946  v->refdist += get_unary(gb, 0, 14);
947  if (v->refdist > 16)
948  return AVERROR_INVALIDDATA;
949  }
950  if ((v->s.pict_type == AV_PICTURE_TYPE_B) || (v->s.pict_type == AV_PICTURE_TYPE_BI)) {
951  if (read_bfraction(v, gb) < 0)
952  return AVERROR_INVALIDDATA;
953  v->frfd = (v->bfraction * v->refdist) >> 8;
954  v->brfd = v->refdist - v->frfd - 1;
955  if (v->brfd < 0)
956  v->brfd = 0;
957  }
958  goto parse_common_info;
959  }
960  if (v->fcm == PROGRESSIVE) {
961  if (v->finterpflag)
962  v->interpfrm = get_bits1(gb);
963  if (v->s.pict_type == AV_PICTURE_TYPE_B) {
964  if (read_bfraction(v, gb) < 0)
965  return AVERROR_INVALIDDATA;
966  if (v->bfraction == 0) {
967  v->s.pict_type = AV_PICTURE_TYPE_BI; /* XXX: should not happen here */
968  }
969  }
970  }
971 
972  parse_common_info:
973  if (v->field_mode)
974  v->cur_field_type = !(v->tff ^ v->second_field);
975  pqindex = get_bits(gb, 5);
976  if (!pqindex)
977  return -1;
979  v->pq = ff_vc1_pquant_table[0][pqindex];
980  else
981  v->pq = ff_vc1_pquant_table[1][pqindex];
982  v->pqindex = pqindex;
983  if (pqindex < 9)
984  v->halfpq = get_bits1(gb);
985  else
986  v->halfpq = 0;
987  switch (v->quantizer_mode) {
989  v->pquantizer = pqindex < 9;
990  break;
991  case QUANT_NON_UNIFORM:
992  v->pquantizer = 0;
993  break;
995  v->pquantizer = get_bits1(gb);
996  break;
997  default:
998  v->pquantizer = 1;
999  break;
1000  }
1001  v->dquantfrm = 0;
1002  if (v->postprocflag)
1003  v->postproc = get_bits(gb, 2);
1004 
1005  if (v->parse_only)
1006  return 0;
1007 
1008  if (v->first_pic_header_flag)
1009  rotate_luts(v);
1010 
1011  switch (v->s.pict_type) {
1012  case AV_PICTURE_TYPE_I:
1013  case AV_PICTURE_TYPE_BI:
1014  if (v->fcm == ILACE_FRAME) { //interlace frame picture
1015  status = bitplane_decoding(v->fieldtx_plane, &v->fieldtx_is_raw, v);
1016  if (status < 0)
1017  return -1;
1018  av_log(v->s.avctx, AV_LOG_DEBUG, "FIELDTX plane encoding: "
1019  "Imode: %i, Invert: %i\n", status>>1, status&1);
1020  } else
1021  v->fieldtx_is_raw = 0;
1022  status = bitplane_decoding(v->acpred_plane, &v->acpred_is_raw, v);
1023  if (status < 0)
1024  return -1;
1025  av_log(v->s.avctx, AV_LOG_DEBUG, "ACPRED plane encoding: "
1026  "Imode: %i, Invert: %i\n", status>>1, status&1);
1027  v->condover = CONDOVER_NONE;
1028  if (v->overlap && v->pq <= 8) {
1029  v->condover = decode012(gb);
1030  if (v->condover == CONDOVER_SELECT) {
1031  status = bitplane_decoding(v->over_flags_plane, &v->overflg_is_raw, v);
1032  if (status < 0)
1033  return -1;
1034  av_log(v->s.avctx, AV_LOG_DEBUG, "CONDOVER plane encoding: "
1035  "Imode: %i, Invert: %i\n", status>>1, status&1);
1036  }
1037  }
1038  break;
1039  case AV_PICTURE_TYPE_P:
1040  if (v->field_mode) {
1041  v->numref = get_bits1(gb);
1042  if (!v->numref) {
1043  v->reffield = get_bits1(gb);
1044  v->ref_field_type[0] = v->reffield ^ !v->cur_field_type;
1045  }
1046  }
1047  if (v->extended_mv)
1048  v->mvrange = get_unary(gb, 0, 3);
1049  else
1050  v->mvrange = 0;
1051  if (v->interlace) {
1052  if (v->extended_dmv)
1053  v->dmvrange = get_unary(gb, 0, 3);
1054  else
1055  v->dmvrange = 0;
1056  if (v->fcm == ILACE_FRAME) { // interlaced frame picture
1057  v->fourmvswitch = get_bits1(gb);
1058  v->intcomp = get_bits1(gb);
1059  if (v->intcomp) {
1060  v->lumscale = get_bits(gb, 6);
1061  v->lumshift = get_bits(gb, 6);
1062  INIT_LUT(v->lumscale, v->lumshift, v->last_luty[0], v->last_lutuv[0], 1);
1063  INIT_LUT(v->lumscale, v->lumshift, v->last_luty[1], v->last_lutuv[1], 1);
1064  v->last_use_ic = 1;
1065  }
1066  status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1067  if (status < 0)
1068  return -1;
1069  av_log(v->s.avctx, AV_LOG_DEBUG, "SKIPMB plane encoding: "
1070  "Imode: %i, Invert: %i\n", status>>1, status&1);
1071  v->mbmodetab = get_bits(gb, 2);
1072  if (v->fourmvswitch)
1074  else
1076  v->imvtab = get_bits(gb, 2);
1078  // interlaced p-picture cbpcy range is [1, 63]
1079  v->icbptab = get_bits(gb, 3);
1081  v->twomvbptab = get_bits(gb, 2);
1083  if (v->fourmvswitch) {
1084  v->fourmvbptab = get_bits(gb, 2);
1086  }
1087  }
1088  }
1089  v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1090  v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
1091  v->range_x = 1 << (v->k_x - 1);
1092  v->range_y = 1 << (v->k_y - 1);
1093 
1094  v->tt_index = (v->pq > 4) + (v->pq > 12);
1095  if (v->fcm != ILACE_FRAME) {
1096  int mvmode;
1097  mvmode = get_unary(gb, 1, 4);
1098  lowquant = (v->pq > 12) ? 0 : 1;
1099  v->mv_mode = ff_vc1_mv_pmode_table[lowquant][mvmode];
1100  if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
1101  int mvmode2;
1102  mvmode2 = get_unary(gb, 1, 3);
1103  v->mv_mode2 = ff_vc1_mv_pmode_table2[lowquant][mvmode2];
1104  if (v->field_mode) {
1105  v->intcompfield = decode210(gb) ^ 3;
1106  } else
1107  v->intcompfield = 3;
1108 
1109  v->lumscale2 = v->lumscale = 32;
1110  v->lumshift2 = v->lumshift = 0;
1111  if (v->intcompfield & 1) {
1112  v->lumscale = get_bits(gb, 6);
1113  v->lumshift = get_bits(gb, 6);
1114  }
1115  if ((v->intcompfield & 2) && v->field_mode) {
1116  v->lumscale2 = get_bits(gb, 6);
1117  v->lumshift2 = get_bits(gb, 6);
1118  } else if(!v->field_mode) {
1119  v->lumscale2 = v->lumscale;
1120  v->lumshift2 = v->lumshift;
1121  }
1122  if (v->field_mode && v->second_field) {
1123  if (v->cur_field_type) {
1124  INIT_LUT(v->lumscale , v->lumshift , v->curr_luty[v->cur_field_type^1], v->curr_lutuv[v->cur_field_type^1], 0);
1126  } else {
1129  }
1130  v->next_use_ic = *v->curr_use_ic = 1;
1131  } else {
1132  INIT_LUT(v->lumscale , v->lumshift , v->last_luty[0], v->last_lutuv[0], 1);
1133  INIT_LUT(v->lumscale2, v->lumshift2, v->last_luty[1], v->last_lutuv[1], 1);
1134  }
1135  v->last_use_ic = 1;
1136  }
1137  v->qs_last = v->s.quarter_sample;
1138  if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
1141  v->s.mspel = (v->mv_mode2 != MV_PMODE_1MV_HPEL_BILIN);
1142  } else {
1143  v->s.quarter_sample = (v->mv_mode != MV_PMODE_1MV_HPEL &&
1145  v->s.mspel = (v->mv_mode != MV_PMODE_1MV_HPEL_BILIN);
1146  }
1147  }
1148  if (v->fcm == PROGRESSIVE) { // progressive
1149  if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
1151  || v->mv_mode == MV_PMODE_MIXED_MV) {
1152  status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);
1153  if (status < 0)
1154  return -1;
1155  av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
1156  "Imode: %i, Invert: %i\n", status>>1, status&1);
1157  } else {
1158  v->mv_type_is_raw = 0;
1159  memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
1160  }
1161  status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1162  if (status < 0)
1163  return -1;
1164  av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1165  "Imode: %i, Invert: %i\n", status>>1, status&1);
1166 
1167  /* Hopefully this is correct for P-frames */
1168  v->s.mv_table_index = get_bits(gb, 2); //but using ff_vc1_ tables
1169  v->cbptab = get_bits(gb, 2);
1171  } else if (v->fcm == ILACE_FRAME) { // frame interlaced
1172  v->qs_last = v->s.quarter_sample;
1173  v->s.quarter_sample = 1;
1174  v->s.mspel = 1;
1175  } else { // field interlaced
1176  v->mbmodetab = get_bits(gb, 3);
1177  v->imvtab = get_bits(gb, 2 + v->numref);
1178  if (!v->numref)
1180  else
1182  v->icbptab = get_bits(gb, 3);
1184  if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
1186  v->fourmvbptab = get_bits(gb, 2);
1189  } else {
1191  }
1192  }
1193  if (v->dquant) {
1194  av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1196  }
1197 
1198  if (v->vstransform) {
1199  v->ttmbf = get_bits1(gb);
1200  if (v->ttmbf) {
1201  v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
1202  } else
1203  v->ttfrm = 0; //FIXME Is that so ?
1204  } else {
1205  v->ttmbf = 1;
1206  v->ttfrm = TT_8X8;
1207  }
1208  break;
1209  case AV_PICTURE_TYPE_B:
1210  if (v->fcm == ILACE_FRAME) {
1211  if (read_bfraction(v, gb) < 0)
1212  return AVERROR_INVALIDDATA;
1213  if (v->bfraction == 0) {
1214  return -1;
1215  }
1216  }
1217  if (v->extended_mv)
1218  v->mvrange = get_unary(gb, 0, 3);
1219  else
1220  v->mvrange = 0;
1221  v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1222  v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
1223  v->range_x = 1 << (v->k_x - 1);
1224  v->range_y = 1 << (v->k_y - 1);
1225 
1226  v->tt_index = (v->pq > 4) + (v->pq > 12);
1227 
1228  if (v->field_mode) {
1229  int mvmode;
1230  av_log(v->s.avctx, AV_LOG_DEBUG, "B Fields\n");
1231  if (v->extended_dmv)
1232  v->dmvrange = get_unary(gb, 0, 3);
1233  mvmode = get_unary(gb, 1, 3);
1234  lowquant = (v->pq > 12) ? 0 : 1;
1235  v->mv_mode = ff_vc1_mv_pmode_table2[lowquant][mvmode];
1236  v->qs_last = v->s.quarter_sample;
1238  v->s.mspel = (v->mv_mode != MV_PMODE_1MV_HPEL_BILIN);
1239  status = bitplane_decoding(v->forward_mb_plane, &v->fmb_is_raw, v);
1240  if (status < 0)
1241  return -1;
1242  av_log(v->s.avctx, AV_LOG_DEBUG, "MB Forward Type plane encoding: "
1243  "Imode: %i, Invert: %i\n", status>>1, status&1);
1244  v->mbmodetab = get_bits(gb, 3);
1245  if (v->mv_mode == MV_PMODE_MIXED_MV)
1247  else
1249  v->imvtab = get_bits(gb, 3);
1251  v->icbptab = get_bits(gb, 3);
1253  if (v->mv_mode == MV_PMODE_MIXED_MV) {
1254  v->fourmvbptab = get_bits(gb, 2);
1256  }
1257  v->numref = 1; // interlaced field B pictures are always 2-ref
1258  } else if (v->fcm == ILACE_FRAME) {
1259  if (v->extended_dmv)
1260  v->dmvrange = get_unary(gb, 0, 3);
1261  if (get_bits1(gb)) /* intcomp - present but shall always be 0 */
1262  av_log(v->s.avctx, AV_LOG_WARNING, "Intensity compensation set for B picture\n");
1263  v->intcomp = 0;
1264  v->mv_mode = MV_PMODE_1MV;
1265  v->fourmvswitch = 0;
1266  v->qs_last = v->s.quarter_sample;
1267  v->s.quarter_sample = 1;
1268  v->s.mspel = 1;
1269  status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
1270  if (status < 0)
1271  return -1;
1272  av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
1273  "Imode: %i, Invert: %i\n", status>>1, status&1);
1274  status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1275  if (status < 0)
1276  return -1;
1277  av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1278  "Imode: %i, Invert: %i\n", status>>1, status&1);
1279  v->mbmodetab = get_bits(gb, 2);
1281  v->imvtab = get_bits(gb, 2);
1283  // interlaced p/b-picture cbpcy range is [1, 63]
1284  v->icbptab = get_bits(gb, 3);
1286  v->twomvbptab = get_bits(gb, 2);
1288  v->fourmvbptab = get_bits(gb, 2);
1290  } else {
1292  v->qs_last = v->s.quarter_sample;
1293  v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
1294  v->s.mspel = v->s.quarter_sample;
1295  status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
1296  if (status < 0)
1297  return -1;
1298  av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
1299  "Imode: %i, Invert: %i\n", status>>1, status&1);
1300  status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1301  if (status < 0)
1302  return -1;
1303  av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1304  "Imode: %i, Invert: %i\n", status>>1, status&1);
1305  v->s.mv_table_index = get_bits(gb, 2);
1306  v->cbptab = get_bits(gb, 2);
1308  }
1309 
1310  if (v->dquant) {
1311  av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1313  }
1314 
1315  if (v->vstransform) {
1316  v->ttmbf = get_bits1(gb);
1317  if (v->ttmbf) {
1318  v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
1319  } else
1320  v->ttfrm = 0;
1321  } else {
1322  v->ttmbf = 1;
1323  v->ttfrm = TT_8X8;
1324  }
1325  break;
1326  }
1327 
1328 
1329  /* AC Syntax */
1330  v->c_ac_table_index = decode012(gb);
1332  v->y_ac_table_index = decode012(gb);
1333  }
1334  else if (v->fcm != PROGRESSIVE && !v->s.quarter_sample) {
1335  v->range_x <<= 1;
1336  v->range_y <<= 1;
1337  }
1338 
1339  /* DC Syntax */
1340  v->s.dc_table_index = get_bits1(gb);
1342  && v->dquant) {
1343  av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1345  }
1346 
1347  v->bi_type = (v->s.pict_type == AV_PICTURE_TYPE_BI);
1348  if (v->bi_type)
1350 
1351  return 0;
1352 }
1353 
1354 static const uint32_t vc1_ac_tables[AC_MODES][186][2] = {
1355 {
1356 { 0x0001, 2}, { 0x0005, 3}, { 0x000D, 4}, { 0x0012, 5}, { 0x000E, 6}, { 0x0015, 7},
1357 { 0x0013, 8}, { 0x003F, 8}, { 0x004B, 9}, { 0x011F, 9}, { 0x00B8, 10}, { 0x03E3, 10},
1358 { 0x0172, 11}, { 0x024D, 12}, { 0x03DA, 12}, { 0x02DD, 13}, { 0x1F55, 13}, { 0x05B9, 14},
1359 { 0x3EAE, 14}, { 0x0000, 4}, { 0x0010, 5}, { 0x0008, 7}, { 0x0020, 8}, { 0x0029, 9},
1360 { 0x01F4, 9}, { 0x0233, 10}, { 0x01E0, 11}, { 0x012A, 12}, { 0x03DD, 12}, { 0x050A, 13},
1361 { 0x1F29, 13}, { 0x0A42, 14}, { 0x1272, 15}, { 0x1737, 15}, { 0x0003, 5}, { 0x0011, 7},
1362 { 0x00C4, 8}, { 0x004B, 10}, { 0x00B4, 11}, { 0x07D4, 11}, { 0x0345, 12}, { 0x02D7, 13},
1363 { 0x07BF, 13}, { 0x0938, 14}, { 0x0BBB, 14}, { 0x095E, 15}, { 0x0013, 5}, { 0x0078, 7},
1364 { 0x0069, 9}, { 0x0232, 10}, { 0x0461, 11}, { 0x03EC, 12}, { 0x0520, 13}, { 0x1F2A, 13},
1365 { 0x3E50, 14}, { 0x3E51, 14}, { 0x1486, 15}, { 0x000C, 6}, { 0x0024, 9}, { 0x0094, 11},
1366 { 0x08C0, 12}, { 0x0F09, 14}, { 0x1EF0, 15}, { 0x003D, 6}, { 0x0053, 9}, { 0x01A0, 11},
1367 { 0x02D6, 13}, { 0x0F08, 14}, { 0x0013, 7}, { 0x007C, 9}, { 0x07C1, 11}, { 0x04AC, 14},
1368 { 0x001B, 7}, { 0x00A0, 10}, { 0x0344, 12}, { 0x0F79, 14}, { 0x0079, 7}, { 0x03E1, 10},
1369 { 0x02D4, 13}, { 0x2306, 14}, { 0x0021, 8}, { 0x023C, 10}, { 0x0FAE, 12}, { 0x23DE, 14},
1370 { 0x0035, 8}, { 0x0175, 11}, { 0x07B3, 13}, { 0x00C5, 8}, { 0x0174, 11}, { 0x0785, 13},
1371 { 0x0048, 9}, { 0x01A3, 11}, { 0x049E, 13}, { 0x002C, 9}, { 0x00FA, 10}, { 0x07D6, 11},
1372 { 0x0092, 10}, { 0x05CC, 13}, { 0x1EF1, 15}, { 0x00A3, 10}, { 0x03ED, 12}, { 0x093E, 14},
1373 { 0x01E2, 11}, { 0x1273, 15}, { 0x07C4, 11}, { 0x1487, 15}, { 0x0291, 12}, { 0x0293, 12},
1374 { 0x0F8A, 12}, { 0x0509, 13}, { 0x0508, 13}, { 0x078D, 13}, { 0x07BE, 13}, { 0x078C, 13},
1375 { 0x04AE, 14}, { 0x0BBA, 14}, { 0x2307, 14}, { 0x0B9A, 14}, { 0x1736, 15}, { 0x000E, 4},
1376 { 0x0045, 7}, { 0x01F3, 9}, { 0x047A, 11}, { 0x05DC, 13}, { 0x23DF, 14}, { 0x0019, 5},
1377 { 0x0028, 9}, { 0x0176, 11}, { 0x049D, 13}, { 0x23DD, 14}, { 0x0030, 6}, { 0x00A2, 10},
1378 { 0x02EF, 12}, { 0x05B8, 14}, { 0x003F, 6}, { 0x00A5, 10}, { 0x03DB, 12}, { 0x093F, 14},
1379 { 0x0044, 7}, { 0x07CB, 11}, { 0x095F, 15}, { 0x0063, 7}, { 0x03C3, 12}, { 0x0015, 8},
1380 { 0x08F6, 12}, { 0x0017, 8}, { 0x0498, 13}, { 0x002C, 8}, { 0x07B2, 13}, { 0x002F, 8},
1381 { 0x1F54, 13}, { 0x008D, 8}, { 0x07BD, 13}, { 0x008E, 8}, { 0x1182, 13}, { 0x00FB, 8},
1382 { 0x050B, 13}, { 0x002D, 8}, { 0x07C0, 11}, { 0x0079, 9}, { 0x1F5F, 13}, { 0x007A, 9},
1383 { 0x1F56, 13}, { 0x0231, 10}, { 0x03E4, 10}, { 0x01A1, 11}, { 0x0143, 11}, { 0x01F7, 11},
1384 { 0x016F, 12}, { 0x0292, 12}, { 0x02E7, 12}, { 0x016C, 12}, { 0x016D, 12}, { 0x03DC, 12},
1385 { 0x0F8B, 12}, { 0x0499, 13}, { 0x03D8, 12}, { 0x078E, 13}, { 0x02D5, 13}, { 0x1F5E, 13},
1386 { 0x1F2B, 13}, { 0x078F, 13}, { 0x04AD, 14}, { 0x3EAF, 14}, { 0x23DC, 14}, { 0x004A, 9}
1387 },
1388 {
1389 { 0x0000, 3}, { 0x0003, 4}, { 0x000B, 5}, { 0x0014, 6}, { 0x003F, 6}, { 0x005D, 7},
1390 { 0x00A2, 8}, { 0x00AC, 9}, { 0x016E, 9}, { 0x020A, 10}, { 0x02E2, 10}, { 0x0432, 11},
1391 { 0x05C9, 11}, { 0x0827, 12}, { 0x0B54, 12}, { 0x04E6, 13}, { 0x105F, 13}, { 0x172A, 13},
1392 { 0x20B2, 14}, { 0x2D4E, 14}, { 0x39F0, 14}, { 0x4175, 15}, { 0x5A9E, 15}, { 0x0004, 4},
1393 { 0x001E, 5}, { 0x0042, 7}, { 0x00B6, 8}, { 0x0173, 9}, { 0x0395, 10}, { 0x072E, 11},
1394 { 0x0B94, 12}, { 0x16A4, 13}, { 0x20B3, 14}, { 0x2E45, 14}, { 0x0005, 5}, { 0x0040, 7},
1395 { 0x0049, 9}, { 0x028F, 10}, { 0x05CB, 11}, { 0x048A, 13}, { 0x09DD, 14}, { 0x73E2, 15},
1396 { 0x0018, 5}, { 0x0025, 8}, { 0x008A, 10}, { 0x051B, 11}, { 0x0E5F, 12}, { 0x09C9, 14},
1397 { 0x139C, 15}, { 0x0029, 6}, { 0x004F, 9}, { 0x0412, 11}, { 0x048D, 13}, { 0x2E41, 14},
1398 { 0x0038, 6}, { 0x010E, 9}, { 0x05A8, 11}, { 0x105C, 13}, { 0x39F2, 14}, { 0x0058, 7},
1399 { 0x021F, 10}, { 0x0E7E, 12}, { 0x39FF, 14}, { 0x0023, 8}, { 0x02E3, 10}, { 0x04E5, 13},
1400 { 0x2E40, 14}, { 0x00A1, 8}, { 0x05BE, 11}, { 0x09C8, 14}, { 0x0083, 8}, { 0x013A, 11},
1401 { 0x1721, 13}, { 0x0044, 9}, { 0x0276, 12}, { 0x39F6, 14}, { 0x008B, 10}, { 0x04EF, 13},
1402 { 0x5A9B, 15}, { 0x0208, 10}, { 0x1CFE, 13}, { 0x0399, 10}, { 0x1CB4, 13}, { 0x039E, 10},
1403 { 0x39F3, 14}, { 0x05AB, 11}, { 0x73E3, 15}, { 0x0737, 11}, { 0x5A9F, 15}, { 0x082D, 12},
1404 { 0x0E69, 12}, { 0x0E68, 12}, { 0x0433, 11}, { 0x0B7B, 12}, { 0x2DF8, 14}, { 0x2E56, 14},
1405 { 0x2E57, 14}, { 0x39F7, 14}, { 0x51A5, 15}, { 0x0003, 3}, { 0x002A, 6}, { 0x00E4, 8},
1406 { 0x028E, 10}, { 0x0735, 11}, { 0x1058, 13}, { 0x1CFA, 13}, { 0x2DF9, 14}, { 0x4174, 15},
1407 { 0x0009, 4}, { 0x0054, 8}, { 0x0398, 10}, { 0x048B, 13}, { 0x139D, 15}, { 0x000D, 4},
1408 { 0x00AD, 9}, { 0x0826, 12}, { 0x2D4C, 14}, { 0x0011, 5}, { 0x016B, 9}, { 0x0B7F, 12},
1409 { 0x51A4, 15}, { 0x0019, 5}, { 0x021B, 10}, { 0x16FD, 13}, { 0x001D, 5}, { 0x0394, 10},
1410 { 0x28D3, 14}, { 0x002B, 6}, { 0x05BC, 11}, { 0x5A9A, 15}, { 0x002F, 6}, { 0x0247, 12},
1411 { 0x0010, 7}, { 0x0A35, 12}, { 0x003E, 6}, { 0x0B7A, 12}, { 0x0059, 7}, { 0x105E, 13},
1412 { 0x0026, 8}, { 0x09CF, 14}, { 0x0055, 8}, { 0x1CB5, 13}, { 0x0057, 8}, { 0x0E5B, 12},
1413 { 0x00A0, 8}, { 0x1468, 13}, { 0x0170, 9}, { 0x0090, 10}, { 0x01CE, 9}, { 0x021A, 10},
1414 { 0x0218, 10}, { 0x0168, 9}, { 0x021E, 10}, { 0x0244, 12}, { 0x0736, 11}, { 0x0138, 11},
1415 { 0x0519, 11}, { 0x0E5E, 12}, { 0x072C, 11}, { 0x0B55, 12}, { 0x09DC, 14}, { 0x20BB, 14},
1416 { 0x048C, 13}, { 0x1723, 13}, { 0x2E44, 14}, { 0x16A5, 13}, { 0x0518, 11}, { 0x39FE, 14},
1417 { 0x0169, 9}
1418 },
1419 {
1420 { 0x0001, 2}, { 0x0006, 3}, { 0x000F, 4}, { 0x0016, 5}, { 0x0020, 6}, { 0x0018, 7},
1421 { 0x0008, 8}, { 0x009A, 8}, { 0x0056, 9}, { 0x013E, 9}, { 0x00F0, 10}, { 0x03A5, 10},
1422 { 0x0077, 11}, { 0x01EF, 11}, { 0x009A, 12}, { 0x005D, 13}, { 0x0001, 4}, { 0x0011, 5},
1423 { 0x0002, 7}, { 0x000B, 8}, { 0x0012, 9}, { 0x01D6, 9}, { 0x027E, 10}, { 0x0191, 11},
1424 { 0x00EA, 12}, { 0x03DC, 12}, { 0x013B, 13}, { 0x0004, 5}, { 0x0014, 7}, { 0x009E, 8},
1425 { 0x0009, 10}, { 0x01AC, 11}, { 0x01E2, 11}, { 0x03CA, 12}, { 0x005F, 13}, { 0x0017, 5},
1426 { 0x004E, 7}, { 0x005E, 9}, { 0x00F3, 10}, { 0x01AD, 11}, { 0x00EC, 12}, { 0x05F0, 13},
1427 { 0x000E, 6}, { 0x00E1, 8}, { 0x03A4, 10}, { 0x009C, 12}, { 0x013D, 13}, { 0x003B, 6},
1428 { 0x001C, 9}, { 0x0014, 11}, { 0x09BE, 12}, { 0x0006, 7}, { 0x007A, 9}, { 0x0190, 11},
1429 { 0x0137, 13}, { 0x001B, 7}, { 0x0008, 10}, { 0x075C, 11}, { 0x0071, 7}, { 0x00D7, 10},
1430 { 0x09BF, 12}, { 0x0007, 8}, { 0x00AF, 10}, { 0x04CC, 11}, { 0x0034, 8}, { 0x0265, 10},
1431 { 0x009F, 12}, { 0x00E0, 8}, { 0x0016, 11}, { 0x0327, 12}, { 0x0015, 9}, { 0x017D, 11},
1432 { 0x0EBB, 12}, { 0x0014, 9}, { 0x00F6, 10}, { 0x01E4, 11}, { 0x00CB, 10}, { 0x099D, 12},
1433 { 0x00CA, 10}, { 0x02FC, 12}, { 0x017F, 11}, { 0x04CD, 11}, { 0x02FD, 12}, { 0x04FE, 11},
1434 { 0x013A, 13}, { 0x000A, 4}, { 0x0042, 7}, { 0x01D3, 9}, { 0x04DD, 11}, { 0x0012, 5},
1435 { 0x00E8, 8}, { 0x004C, 11}, { 0x0136, 13}, { 0x0039, 6}, { 0x0264, 10}, { 0x0EBA, 12},
1436 { 0x0000, 7}, { 0x00AE, 10}, { 0x099C, 12}, { 0x001F, 7}, { 0x04DE, 11}, { 0x0043, 7},
1437 { 0x04DC, 11}, { 0x0003, 8}, { 0x03CB, 12}, { 0x0006, 8}, { 0x099E, 12}, { 0x002A, 8},
1438 { 0x05F1, 13}, { 0x000F, 8}, { 0x09FE, 12}, { 0x0033, 8}, { 0x09FF, 12}, { 0x0098, 8},
1439 { 0x099F, 12}, { 0x00EA, 8}, { 0x013C, 13}, { 0x002E, 8}, { 0x0192, 11}, { 0x0136, 9},
1440 { 0x006A, 9}, { 0x0015, 11}, { 0x03AF, 10}, { 0x01E3, 11}, { 0x0074, 11}, { 0x00EB, 12},
1441 { 0x02F9, 12}, { 0x005C, 13}, { 0x00ED, 12}, { 0x03DD, 12}, { 0x0326, 12}, { 0x005E, 13},
1442 { 0x0016, 7}
1443 },
1444 {
1445 { 0x0004, 3}, { 0x0014, 5}, { 0x0017, 7}, { 0x007F, 8}, { 0x0154, 9}, { 0x01F2, 10},
1446 { 0x00BF, 11}, { 0x0065, 12}, { 0x0AAA, 12}, { 0x0630, 13}, { 0x1597, 13}, { 0x03B7, 14},
1447 { 0x2B22, 14}, { 0x0BE6, 15}, { 0x000B, 4}, { 0x0037, 7}, { 0x0062, 9}, { 0x0007, 11},
1448 { 0x0166, 12}, { 0x00CE, 13}, { 0x1590, 13}, { 0x05F6, 14}, { 0x0BE7, 15}, { 0x0007, 5},
1449 { 0x006D, 8}, { 0x0003, 11}, { 0x031F, 12}, { 0x05F2, 14}, { 0x0002, 6}, { 0x0061, 9},
1450 { 0x0055, 12}, { 0x01DF, 14}, { 0x001A, 6}, { 0x001E, 10}, { 0x0AC9, 12}, { 0x2B23, 14},
1451 { 0x001E, 6}, { 0x001F, 10}, { 0x0AC3, 12}, { 0x2B2B, 14}, { 0x0006, 7}, { 0x0004, 11},
1452 { 0x02F8, 13}, { 0x0019, 7}, { 0x0006, 11}, { 0x063D, 13}, { 0x0057, 7}, { 0x0182, 11},
1453 { 0x2AA2, 14}, { 0x0004, 8}, { 0x0180, 11}, { 0x059C, 14}, { 0x007D, 8}, { 0x0164, 12},
1454 { 0x076D, 15}, { 0x0002, 9}, { 0x018D, 11}, { 0x1581, 13}, { 0x00AD, 8}, { 0x0060, 12},
1455 { 0x0C67, 14}, { 0x001C, 9}, { 0x00EE, 13}, { 0x0003, 9}, { 0x02CF, 13}, { 0x00D9, 9},
1456 { 0x1580, 13}, { 0x0002, 11}, { 0x0183, 11}, { 0x0057, 12}, { 0x0061, 12}, { 0x0031, 11},
1457 { 0x0066, 12}, { 0x0631, 13}, { 0x0632, 13}, { 0x00AC, 13}, { 0x031D, 12}, { 0x0076, 12},
1458 { 0x003A, 11}, { 0x0165, 12}, { 0x0C66, 14}, { 0x0003, 2}, { 0x0054, 7}, { 0x02AB, 10},
1459 { 0x0016, 13}, { 0x05F7, 14}, { 0x0005, 4}, { 0x00F8, 9}, { 0x0AA9, 12}, { 0x005F, 15},
1460 { 0x0004, 4}, { 0x001C, 10}, { 0x1550, 13}, { 0x0004, 5}, { 0x0077, 11}, { 0x076C, 15},
1461 { 0x000E, 5}, { 0x000A, 12}, { 0x000C, 5}, { 0x0562, 11}, { 0x0004, 6}, { 0x031C, 12},
1462 { 0x0006, 6}, { 0x00C8, 13}, { 0x000D, 6}, { 0x01DA, 13}, { 0x0007, 6}, { 0x00C9, 13},
1463 { 0x0001, 7}, { 0x002E, 14}, { 0x0014, 7}, { 0x1596, 13}, { 0x000A, 7}, { 0x0AC2, 12},
1464 { 0x0016, 7}, { 0x015B, 14}, { 0x0015, 7}, { 0x015A, 14}, { 0x000F, 8}, { 0x005E, 15},
1465 { 0x007E, 8}, { 0x00AB, 8}, { 0x002D, 9}, { 0x00D8, 9}, { 0x000B, 9}, { 0x0014, 10},
1466 { 0x02B3, 10}, { 0x01F3, 10}, { 0x003A, 10}, { 0x0000, 10}, { 0x0058, 10}, { 0x002E, 9},
1467 { 0x005E, 10}, { 0x0563, 11}, { 0x00EC, 12}, { 0x0054, 12}, { 0x0AC1, 12}, { 0x1556, 13},
1468 { 0x02FA, 13}, { 0x0181, 11}, { 0x1557, 13}, { 0x059D, 14}, { 0x2AA3, 14}, { 0x2B2A, 14},
1469 { 0x01DE, 14}, { 0x063C, 13}, { 0x00CF, 13}, { 0x1594, 13}, { 0x000D, 9}
1470 },
1471 {
1472 { 0x0002, 2}, { 0x0006, 3}, { 0x000F, 4}, { 0x000D, 5}, { 0x000C, 5}, { 0x0015, 6},
1473 { 0x0013, 6}, { 0x0012, 6}, { 0x0017, 7}, { 0x001F, 8}, { 0x001E, 8}, { 0x001D, 8},
1474 { 0x0025, 9}, { 0x0024, 9}, { 0x0023, 9}, { 0x0021, 9}, { 0x0021, 10}, { 0x0020, 10},
1475 { 0x000F, 10}, { 0x000E, 10}, { 0x0007, 11}, { 0x0006, 11}, { 0x0020, 11}, { 0x0021, 11},
1476 { 0x0050, 12}, { 0x0051, 12}, { 0x0052, 12}, { 0x000E, 4}, { 0x0014, 6}, { 0x0016, 7},
1477 { 0x001C, 8}, { 0x0020, 9}, { 0x001F, 9}, { 0x000D, 10}, { 0x0022, 11}, { 0x0053, 12},
1478 { 0x0055, 12}, { 0x000B, 5}, { 0x0015, 7}, { 0x001E, 9}, { 0x000C, 10}, { 0x0056, 12},
1479 { 0x0011, 6}, { 0x001B, 8}, { 0x001D, 9}, { 0x000B, 10}, { 0x0010, 6}, { 0x0022, 9},
1480 { 0x000A, 10}, { 0x000D, 6}, { 0x001C, 9}, { 0x0008, 10}, { 0x0012, 7}, { 0x001B, 9},
1481 { 0x0054, 12}, { 0x0014, 7}, { 0x001A, 9}, { 0x0057, 12}, { 0x0019, 8}, { 0x0009, 10},
1482 { 0x0018, 8}, { 0x0023, 11}, { 0x0017, 8}, { 0x0019, 9}, { 0x0018, 9}, { 0x0007, 10},
1483 { 0x0058, 12}, { 0x0007, 4}, { 0x000C, 6}, { 0x0016, 8}, { 0x0017, 9}, { 0x0006, 10},
1484 { 0x0005, 11}, { 0x0004, 11}, { 0x0059, 12}, { 0x000F, 6}, { 0x0016, 9}, { 0x0005, 10},
1485 { 0x000E, 6}, { 0x0004, 10}, { 0x0011, 7}, { 0x0024, 11}, { 0x0010, 7}, { 0x0025, 11},
1486 { 0x0013, 7}, { 0x005A, 12}, { 0x0015, 8}, { 0x005B, 12}, { 0x0014, 8}, { 0x0013, 8},
1487 { 0x001A, 8}, { 0x0015, 9}, { 0x0014, 9}, { 0x0013, 9}, { 0x0012, 9}, { 0x0011, 9},
1488 { 0x0026, 11}, { 0x0027, 11}, { 0x005C, 12}, { 0x005D, 12}, { 0x005E, 12}, { 0x005F, 12},
1489 { 0x0003, 7}
1490 },
1491 {
1492 { 0x0002, 2}, { 0x000F, 4}, { 0x0015, 6}, { 0x0017, 7}, { 0x001F, 8}, { 0x0025, 9},
1493 { 0x0024, 9}, { 0x0021, 10}, { 0x0020, 10}, { 0x0007, 11}, { 0x0006, 11}, { 0x0020, 11},
1494 { 0x0006, 3}, { 0x0014, 6}, { 0x001E, 8}, { 0x000F, 10}, { 0x0021, 11}, { 0x0050, 12},
1495 { 0x000E, 4}, { 0x001D, 8}, { 0x000E, 10}, { 0x0051, 12}, { 0x000D, 5}, { 0x0023, 9},
1496 { 0x000D, 10}, { 0x000C, 5}, { 0x0022, 9}, { 0x0052, 12}, { 0x000B, 5}, { 0x000C, 10},
1497 { 0x0053, 12}, { 0x0013, 6}, { 0x000B, 10}, { 0x0054, 12}, { 0x0012, 6}, { 0x000A, 10},
1498 { 0x0011, 6}, { 0x0009, 10}, { 0x0010, 6}, { 0x0008, 10}, { 0x0016, 7}, { 0x0055, 12},
1499 { 0x0015, 7}, { 0x0014, 7}, { 0x001C, 8}, { 0x001B, 8}, { 0x0021, 9}, { 0x0020, 9},
1500 { 0x001F, 9}, { 0x001E, 9}, { 0x001D, 9}, { 0x001C, 9}, { 0x001B, 9}, { 0x001A, 9},
1501 { 0x0022, 11}, { 0x0023, 11}, { 0x0056, 12}, { 0x0057, 12}, { 0x0007, 4}, { 0x0019, 9},
1502 { 0x0005, 11}, { 0x000F, 6}, { 0x0004, 11}, { 0x000E, 6}, { 0x000D, 6}, { 0x000C, 6},
1503 { 0x0013, 7}, { 0x0012, 7}, { 0x0011, 7}, { 0x0010, 7}, { 0x001A, 8}, { 0x0019, 8},
1504 { 0x0018, 8}, { 0x0017, 8}, { 0x0016, 8}, { 0x0015, 8}, { 0x0014, 8}, { 0x0013, 8},
1505 { 0x0018, 9}, { 0x0017, 9}, { 0x0016, 9}, { 0x0015, 9}, { 0x0014, 9}, { 0x0013, 9},
1506 { 0x0012, 9}, { 0x0011, 9}, { 0x0007, 10}, { 0x0006, 10}, { 0x0005, 10}, { 0x0004, 10},
1507 { 0x0024, 11}, { 0x0025, 11}, { 0x0026, 11}, { 0x0027, 11}, { 0x0058, 12}, { 0x0059, 12},
1508 { 0x005A, 12}, { 0x005B, 12}, { 0x005C, 12}, { 0x005D, 12}, { 0x005E, 12}, { 0x005F, 12},
1509 { 0x0003, 7}
1510 },
1511 {
1512 { 0x0000, 2}, { 0x0003, 3}, { 0x000D, 4}, { 0x0005, 4}, { 0x001C, 5}, { 0x0016, 5},
1513 { 0x003F, 6}, { 0x003A, 6}, { 0x002E, 6}, { 0x0022, 6}, { 0x007B, 7}, { 0x0067, 7},
1514 { 0x005F, 7}, { 0x0047, 7}, { 0x0026, 7}, { 0x00EF, 8}, { 0x00CD, 8}, { 0x00C1, 8},
1515 { 0x00A9, 8}, { 0x004F, 8}, { 0x01F2, 9}, { 0x01DD, 9}, { 0x0199, 9}, { 0x0185, 9},
1516 { 0x015D, 9}, { 0x011B, 9}, { 0x03EF, 10}, { 0x03E1, 10}, { 0x03C8, 10}, { 0x0331, 10},
1517 { 0x0303, 10}, { 0x02F1, 10}, { 0x02A0, 10}, { 0x0233, 10}, { 0x0126, 10}, { 0x07C0, 11},
1518 { 0x076F, 11}, { 0x076C, 11}, { 0x0661, 11}, { 0x0604, 11}, { 0x0572, 11}, { 0x0551, 11},
1519 { 0x046A, 11}, { 0x0274, 11}, { 0x0F27, 12}, { 0x0F24, 12}, { 0x0EDB, 12}, { 0x0C8E, 12},
1520 { 0x0C0B, 12}, { 0x0C0A, 12}, { 0x0AE3, 12}, { 0x08D6, 12}, { 0x0490, 12}, { 0x0495, 12},
1521 { 0x1F19, 13}, { 0x1DB5, 13}, { 0x0009, 4}, { 0x0010, 5}, { 0x0029, 6}, { 0x0062, 7},
1522 { 0x00F3, 8}, { 0x00AD, 8}, { 0x01E5, 9}, { 0x0179, 9}, { 0x009C, 9}, { 0x03B1, 10},
1523 { 0x02AE, 10}, { 0x0127, 10}, { 0x076E, 11}, { 0x0570, 11}, { 0x0275, 11}, { 0x0F25, 12},
1524 { 0x0EC0, 12}, { 0x0AA0, 12}, { 0x08D7, 12}, { 0x1E4C, 13}, { 0x0008, 5}, { 0x0063, 7},
1525 { 0x00AF, 8}, { 0x017B, 9}, { 0x03B3, 10}, { 0x07DD, 11}, { 0x0640, 11}, { 0x0F8D, 12},
1526 { 0x0BC1, 12}, { 0x0491, 12}, { 0x0028, 6}, { 0x00C3, 8}, { 0x0151, 9}, { 0x02A1, 10},
1527 { 0x0573, 11}, { 0x0EC3, 12}, { 0x1F35, 13}, { 0x0065, 7}, { 0x01DA, 9}, { 0x02AF, 10},
1528 { 0x0277, 11}, { 0x08C9, 12}, { 0x1781, 13}, { 0x0025, 7}, { 0x0118, 9}, { 0x0646, 11},
1529 { 0x0AA6, 12}, { 0x1780, 13}, { 0x00C9, 8}, { 0x0321, 10}, { 0x0F9B, 12}, { 0x191E, 13},
1530 { 0x0048, 8}, { 0x07CC, 11}, { 0x0AA1, 12}, { 0x0180, 9}, { 0x0465, 11}, { 0x1905, 13},
1531 { 0x03E2, 10}, { 0x0EC1, 12}, { 0x3C9B, 14}, { 0x02F4, 10}, { 0x08C8, 12}, { 0x07C1, 11},
1532 { 0x0928, 13}, { 0x05E1, 11}, { 0x320D, 14}, { 0x0EC2, 12}, { 0x6418, 15}, { 0x1F34, 13},
1533 { 0x0078, 7}, { 0x0155, 9}, { 0x0552, 11}, { 0x191F, 13}, { 0x00FA, 8}, { 0x07DC, 11},
1534 { 0x1907, 13}, { 0x00AC, 8}, { 0x0249, 11}, { 0x13B1, 14}, { 0x01F6, 9}, { 0x0AE2, 12},
1535 { 0x01DC, 9}, { 0x04ED, 12}, { 0x0184, 9}, { 0x1904, 13}, { 0x0156, 9}, { 0x09D9, 13},
1536 { 0x03E7, 10}, { 0x0929, 13}, { 0x03B2, 10}, { 0x3B68, 14}, { 0x02F5, 10}, { 0x13B0, 14},
1537 { 0x0322, 10}, { 0x3B69, 14}, { 0x0234, 10}, { 0x7935, 15}, { 0x07C7, 11}, { 0xC833, 16},
1538 { 0x0660, 11}, { 0x7934, 15}, { 0x024B, 11}, { 0xC832, 16}, { 0x0AA7, 12}, { 0x1F18, 13},
1539 { 0x007A, 7}
1540 },
1541 {
1542 { 0x0002, 2}, { 0x0000, 3}, { 0x001E, 5}, { 0x0004, 5}, { 0x0012, 6}, { 0x0070, 7},
1543 { 0x001A, 7}, { 0x005F, 8}, { 0x0047, 8}, { 0x01D3, 9}, { 0x00B5, 9}, { 0x0057, 9},
1544 { 0x03B5, 10}, { 0x016D, 10}, { 0x0162, 10}, { 0x07CE, 11}, { 0x0719, 11}, { 0x0691, 11},
1545 { 0x02C6, 11}, { 0x0156, 11}, { 0x0F92, 12}, { 0x0D2E, 12}, { 0x0D20, 12}, { 0x059E, 12},
1546 { 0x0468, 12}, { 0x02A6, 12}, { 0x1DA2, 13}, { 0x1C60, 13}, { 0x1A43, 13}, { 0x0B1D, 13},
1547 { 0x08C0, 13}, { 0x055D, 13}, { 0x0003, 3}, { 0x000A, 5}, { 0x0077, 7}, { 0x00E5, 8},
1548 { 0x01D9, 9}, { 0x03E5, 10}, { 0x0166, 10}, { 0x0694, 11}, { 0x0152, 11}, { 0x059F, 12},
1549 { 0x1F3C, 13}, { 0x1A4B, 13}, { 0x055E, 13}, { 0x000C, 4}, { 0x007D, 7}, { 0x0044, 8},
1550 { 0x03E0, 10}, { 0x0769, 11}, { 0x0E31, 12}, { 0x1F26, 13}, { 0x055C, 13}, { 0x001B, 5},
1551 { 0x00E2, 8}, { 0x03A5, 10}, { 0x02C9, 11}, { 0x1F23, 13}, { 0x3B47, 14}, { 0x0007, 5},
1552 { 0x01D8, 9}, { 0x02D8, 11}, { 0x1F27, 13}, { 0x3494, 14}, { 0x0035, 6}, { 0x03E1, 10},
1553 { 0x059C, 12}, { 0x38C3, 14}, { 0x000C, 6}, { 0x0165, 10}, { 0x1D23, 13}, { 0x1638, 14},
1554 { 0x0068, 7}, { 0x0693, 11}, { 0x3A45, 14}, { 0x0020, 7}, { 0x0F90, 12}, { 0x7CF6, 15},
1555 { 0x00E8, 8}, { 0x058F, 12}, { 0x2CEF, 15}, { 0x0045, 8}, { 0x0B3A, 13}, { 0x01F1, 9},
1556 { 0x3B46, 14}, { 0x01A7, 9}, { 0x1676, 14}, { 0x0056, 9}, { 0x692A, 15}, { 0x038D, 10},
1557 { 0xE309, 16}, { 0x00AA, 10}, { 0x1C611, 17}, { 0x02DF, 11}, { 0xB3B9, 17}, { 0x02C8, 11},
1558 { 0x38C20, 18}, { 0x01B0, 11}, { 0x16390, 18}, { 0x0F9F, 12}, { 0x16771, 18}, { 0x0ED0, 12},
1559 { 0x71843, 19}, { 0x0D2A, 12}, { 0xF9E8C, 20}, { 0x0461, 12}, { 0xF9E8E, 20}, { 0x0B67, 13},
1560 { 0x055F, 13}, { 0x003F, 6}, { 0x006D, 9}, { 0x0E90, 12}, { 0x054E, 13}, { 0x0013, 6},
1561 { 0x0119, 10}, { 0x0B66, 13}, { 0x000B, 6}, { 0x0235, 11}, { 0x7CF5, 15}, { 0x0075, 7},
1562 { 0x0D24, 12}, { 0xF9E9, 16}, { 0x002E, 7}, { 0x1F22, 13}, { 0x0021, 7}, { 0x054F, 13},
1563 { 0x0014, 7}, { 0x3A44, 14}, { 0x00E4, 8}, { 0x7CF7, 15}, { 0x005E, 8}, { 0x7185, 15},
1564 { 0x0037, 8}, { 0x2C73, 15}, { 0x01DB, 9}, { 0x59DD, 16}, { 0x01C7, 9}, { 0x692B, 15},
1565 { 0x01A6, 9}, { 0x58E5, 16}, { 0x00B4, 9}, { 0x1F3D0, 17}, { 0x00B0, 9}, { 0xB1C9, 17},
1566 { 0x03E6, 10}, { 0x16770, 18}, { 0x016E, 10}, { 0x3E7A2, 18}, { 0x011B, 10}, { 0xF9E8D, 20},
1567 { 0x00D9, 10}, { 0xF9E8F, 20}, { 0x00A8, 10}, { 0x2C723, 19}, { 0x0749, 11}, { 0xE3084, 20},
1568 { 0x0696, 11}, { 0x58E45, 20}, { 0x02DE, 11}, { 0xB1C88, 21}, { 0x0231, 11}, { 0x1C610A, 21},
1569 { 0x01B1, 11}, { 0x71842D, 23}, { 0x0D2B, 12}, { 0x38C217, 22}, { 0x0D2F, 12}, { 0x163913, 22},
1570 { 0x05B2, 12}, { 0x163912, 22}, { 0x0469, 12}, { 0x71842C, 23}, { 0x1A42, 13}, { 0x08C1, 13},
1571 { 0x0073, 7}
1572 }
1573 };
1574 
1575 static const uint16_t vlc_offs[] = {
1576  0, 520, 552, 616, 1128, 1160, 1224, 1740, 1772, 1836, 1900, 2436,
1577  2986, 3050, 3610, 4154, 4218, 4746, 5326, 5390, 5902, 6554, 7658, 8342,
1578  9304, 9988, 10630, 11234, 12174, 13006, 13560, 14232, 14786, 15432, 16350, 17522,
1579  20372, 21818, 22330, 22394, 23166, 23678, 23742, 24820, 25332, 25396, 26460, 26980,
1580  27048, 27592, 27600, 27608, 27616, 27624, 28224, 28258, 28290, 28802, 28834, 28866,
1581  29378, 29412, 29444, 29960, 29994, 30026, 30538, 30572, 30604, 31120, 31154, 31186,
1582  31714, 31746, 31778, 32306, 32340, 32372
1583 };
1584 
1585 static av_cold void vc1_init_static(void)
1586 {
1587  int i = 0;
1588  static VLC_TYPE vlc_table[32372][2];
1589 
1591  ff_vc1_bfraction_bits, 1, 1,
1594  ff_vc1_norm2_bits, 1, 1,
1597  ff_vc1_norm6_bits, 1, 1,
1598  ff_vc1_norm6_codes, 2, 2, 556);
1600  ff_vc1_imode_bits, 1, 1,
1602  for (i = 0; i < 3; i++) {
1603  ff_vc1_ttmb_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 0]];
1604  ff_vc1_ttmb_vlc[i].table_allocated = vlc_offs[i * 3 + 1] - vlc_offs[i * 3 + 0];
1606  ff_vc1_ttmb_bits[i], 1, 1,
1608  ff_vc1_ttblk_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 1]];
1609  ff_vc1_ttblk_vlc[i].table_allocated = vlc_offs[i * 3 + 2] - vlc_offs[i * 3 + 1];
1611  ff_vc1_ttblk_bits[i], 1, 1,
1613  ff_vc1_subblkpat_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 2]];
1614  ff_vc1_subblkpat_vlc[i].table_allocated = vlc_offs[i * 3 + 3] - vlc_offs[i * 3 + 2];
1616  ff_vc1_subblkpat_bits[i], 1, 1,
1618  }
1619  for (i = 0; i < 4; i++) {
1620  ff_vc1_4mv_block_pattern_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 9]];
1625  ff_vc1_cbpcy_p_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 10]];
1626  ff_vc1_cbpcy_p_vlc[i].table_allocated = vlc_offs[i * 3 + 11] - vlc_offs[i * 3 + 10];
1628  ff_vc1_cbpcy_p_bits[i], 1, 1,
1630  ff_vc1_mv_diff_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 11]];
1631  ff_vc1_mv_diff_vlc[i].table_allocated = vlc_offs[i * 3 + 12] - vlc_offs[i * 3 + 11];
1633  ff_vc1_mv_diff_bits[i], 1, 1,
1635  }
1636  for (i = 0; i < 8; i++) {
1637  ff_vc1_ac_coeff_table[i].table = &vlc_table[vlc_offs[i * 2 + 21]];
1638  ff_vc1_ac_coeff_table[i].table_allocated = vlc_offs[i * 2 + 22] - vlc_offs[i * 2 + 21];
1640  &vc1_ac_tables[i][0][1], 8, 4,
1641  &vc1_ac_tables[i][0][0], 8, 4, INIT_VLC_USE_NEW_STATIC);
1642  /* initialize interlaced MVDATA tables (2-Ref) */
1643  ff_vc1_2ref_mvdata_vlc[i].table = &vlc_table[vlc_offs[i * 2 + 22]];
1644  ff_vc1_2ref_mvdata_vlc[i].table_allocated = vlc_offs[i * 2 + 23] - vlc_offs[i * 2 + 22];
1646  ff_vc1_2ref_mvdata_bits[i], 1, 1,
1648  }
1649  for (i = 0; i < 4; i++) {
1650  /* initialize 4MV MBMODE VLC tables for interlaced frame P picture */
1651  ff_vc1_intfr_4mv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 37]];
1656  /* initialize NON-4MV MBMODE VLC tables for the same */
1657  ff_vc1_intfr_non4mv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 38]];
1662  /* initialize interlaced MVDATA tables (1-Ref) */
1663  ff_vc1_1ref_mvdata_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 39]];
1664  ff_vc1_1ref_mvdata_vlc[i].table_allocated = vlc_offs[i * 3 + 40] - vlc_offs[i * 3 + 39];
1666  ff_vc1_1ref_mvdata_bits[i], 1, 1,
1668  }
1669  for (i = 0; i < 4; i++) {
1670  /* Initialize 2MV Block pattern VLC tables */
1671  ff_vc1_2mv_block_pattern_vlc[i].table = &vlc_table[vlc_offs[i + 49]];
1676  }
1677  for (i = 0; i < 8; i++) {
1678  /* Initialize interlaced CBPCY VLC tables (Table 124 - Table 131) */
1679  ff_vc1_icbpcy_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 53]];
1680  ff_vc1_icbpcy_vlc[i].table_allocated = vlc_offs[i * 3 + 54] - vlc_offs[i * 3 + 53];
1682  ff_vc1_icbpcy_p_bits[i], 1, 1,
1684  /* Initialize interlaced field picture MBMODE VLC tables */
1685  ff_vc1_if_mmv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 54]];
1686  ff_vc1_if_mmv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 55] - vlc_offs[i * 3 + 54];
1690  ff_vc1_if_1mv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 55]];
1691  ff_vc1_if_1mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 56] - vlc_offs[i * 3 + 55];
1695  }
1696 }
1697 
1698 /**
1699  * Init VC-1 specific tables and VC1Context members
1700  * @param v The VC1Context to initialize
1701  * @return Status
1702  */
1704 {
1705  static AVOnce init_static_once = AV_ONCE_INIT;
1706 
1707  v->hrd_rate = v->hrd_buffer = NULL;
1708 
1709  /* defaults */
1710  v->pq = -1;
1711  v->mvrange = 0; /* 7.1.1.18, p80 */
1712 
1713  ff_vc1dsp_init(&v->vc1dsp);
1714 
1715  /* VLC tables */
1716  ff_thread_once(&init_static_once, vc1_init_static);
1717 
1718  return 0;
1719 }
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 int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:849
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:1575
av_cold int ff_vc1_init_common(VC1Context *v)
Init VC-1 specific tables and VC1Context members.
Definition: vc1.c:1703
static av_cold void vc1_init_static(void)
Definition: vc1.c:1585
int ff_vc1_parse_frame_header_adv(VC1Context *v, GetBitContext *gb)
Definition: vc1.c:851
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:1354
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