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