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 #include "libavutil/attributes.h"
30 #include "internal.h"
31 #include "avcodec.h"
32 #include "mpegvideo.h"
33 #include "vc1.h"
34 #include "vc1data.h"
35 #include "wmv2data.h"
36 #include "unary.h"
37 #include "simple_idct.h"
38 
39 /***********************************************************************/
40 /**
41  * @name VC-1 Bitplane decoding
42  * @see 8.7, p56
43  * @{
44  */
45 
46 /** Decode rows by checking if they are skipped
47  * @param plane Buffer to store decoded bits
48  * @param[in] width Width of this buffer
49  * @param[in] height Height of this buffer
50  * @param[in] stride of this buffer
51  */
52 static void decode_rowskip(uint8_t* plane, int width, int height, int stride,
53  GetBitContext *gb)
54 {
55  int x, y;
56 
57  for (y = 0; y < height; y++) {
58  if (!get_bits1(gb)) //rowskip
59  memset(plane, 0, width);
60  else
61  for (x = 0; x < width; x++)
62  plane[x] = get_bits1(gb);
63  plane += stride;
64  }
65 }
66 
67 /** Decode columns by checking if they are skipped
68  * @param plane Buffer to store decoded bits
69  * @param[in] width Width of this buffer
70  * @param[in] height Height of this buffer
71  * @param[in] stride of this buffer
72  * @todo FIXME: Optimize
73  */
74 static void decode_colskip(uint8_t* plane, int width, int height, int stride,
75  GetBitContext *gb)
76 {
77  int x, y;
78 
79  for (x = 0; x < width; x++) {
80  if (!get_bits1(gb)) //colskip
81  for (y = 0; y < height; y++)
82  plane[y*stride] = 0;
83  else
84  for (y = 0; y < height; y++)
85  plane[y*stride] = get_bits1(gb);
86  plane ++;
87  }
88 }
89 
90 /** Decode a bitplane's bits
91  * @param data bitplane where to store the decode bits
92  * @param[out] raw_flag pointer to the flag indicating that this bitplane is not coded explicitly
93  * @param v VC-1 context for bit reading and logging
94  * @return Status
95  * @todo FIXME: Optimize
96  */
97 static int bitplane_decoding(uint8_t* data, int *raw_flag, VC1Context *v)
98 {
99  GetBitContext *gb = &v->s.gb;
100 
101  int imode, x, y, code, offset;
102  uint8_t invert, *planep = data;
103  int width, height, stride;
104 
105  width = v->s.mb_width;
106  height = v->s.mb_height >> v->field_mode;
107  stride = v->s.mb_stride;
108  invert = get_bits1(gb);
110 
111  *raw_flag = 0;
112  switch (imode) {
113  case IMODE_RAW:
114  //Data is actually read in the MB layer (same for all tests == "raw")
115  *raw_flag = 1; //invert ignored
116  return invert;
117  case IMODE_DIFF2:
118  case IMODE_NORM2:
119  if ((height * width) & 1) {
120  *planep++ = get_bits1(gb);
121  y = offset = 1;
122  if (offset == width) {
123  offset = 0;
124  planep += stride - width;
125  }
126  }
127  else
128  y = offset = 0;
129  // decode bitplane as one long line
130  for (; y < height * width; y += 2) {
132  *planep++ = code & 1;
133  offset++;
134  if (offset == width) {
135  offset = 0;
136  planep += stride - width;
137  }
138  *planep++ = code >> 1;
139  offset++;
140  if (offset == width) {
141  offset = 0;
142  planep += stride - width;
143  }
144  }
145  break;
146  case IMODE_DIFF6:
147  case IMODE_NORM6:
148  if (!(height % 3) && (width % 3)) { // use 2x3 decoding
149  for (y = 0; y < height; y += 3) {
150  for (x = width & 1; x < width; x += 2) {
152  if (code < 0) {
153  av_log(v->s.avctx, AV_LOG_DEBUG, "invalid NORM-6 VLC\n");
154  return -1;
155  }
156  planep[x + 0] = (code >> 0) & 1;
157  planep[x + 1] = (code >> 1) & 1;
158  planep[x + 0 + stride] = (code >> 2) & 1;
159  planep[x + 1 + stride] = (code >> 3) & 1;
160  planep[x + 0 + stride * 2] = (code >> 4) & 1;
161  planep[x + 1 + stride * 2] = (code >> 5) & 1;
162  }
163  planep += stride * 3;
164  }
165  if (width & 1)
166  decode_colskip(data, 1, height, stride, &v->s.gb);
167  } else { // 3x2
168  planep += (height & 1) * stride;
169  for (y = height & 1; y < height; y += 2) {
170  for (x = width % 3; x < width; x += 3) {
172  if (code < 0) {
173  av_log(v->s.avctx, AV_LOG_DEBUG, "invalid NORM-6 VLC\n");
174  return -1;
175  }
176  planep[x + 0] = (code >> 0) & 1;
177  planep[x + 1] = (code >> 1) & 1;
178  planep[x + 2] = (code >> 2) & 1;
179  planep[x + 0 + stride] = (code >> 3) & 1;
180  planep[x + 1 + stride] = (code >> 4) & 1;
181  planep[x + 2 + stride] = (code >> 5) & 1;
182  }
183  planep += stride * 2;
184  }
185  x = width % 3;
186  if (x)
187  decode_colskip(data, x, height, stride, &v->s.gb);
188  if (height & 1)
189  decode_rowskip(data + x, width - x, 1, stride, &v->s.gb);
190  }
191  break;
192  case IMODE_ROWSKIP:
193  decode_rowskip(data, width, height, stride, &v->s.gb);
194  break;
195  case IMODE_COLSKIP:
196  decode_colskip(data, width, height, stride, &v->s.gb);
197  break;
198  default:
199  break;
200  }
201 
202  /* Applying diff operator */
203  if (imode == IMODE_DIFF2 || imode == IMODE_DIFF6) {
204  planep = data;
205  planep[0] ^= invert;
206  for (x = 1; x < width; x++)
207  planep[x] ^= planep[x-1];
208  for (y = 1; y < height; y++) {
209  planep += stride;
210  planep[0] ^= planep[-stride];
211  for (x = 1; x < width; x++) {
212  if (planep[x-1] != planep[x-stride]) planep[x] ^= invert;
213  else planep[x] ^= planep[x-1];
214  }
215  }
216  } else if (invert) {
217  planep = data;
218  for (x = 0; x < stride * height; x++)
219  planep[x] = !planep[x]; //FIXME stride
220  }
221  return (imode << 1) + invert;
222 }
223 
224 /** @} */ //Bitplane group
225 
226 /***********************************************************************/
227 /** VOP Dquant decoding
228  * @param v VC-1 Context
229  */
231 {
232  GetBitContext *gb = &v->s.gb;
233  int pqdiff;
234 
235  //variable size
236  if (v->dquant != 2) {
237  v->dquantfrm = get_bits1(gb);
238  if (!v->dquantfrm)
239  return 0;
240 
241  v->dqprofile = get_bits(gb, 2);
242  switch (v->dqprofile) {
245  v->dqsbedge = get_bits(gb, 2);
246  break;
247  case DQPROFILE_ALL_MBS:
248  v->dqbilevel = get_bits1(gb);
249  if (!v->dqbilevel) {
250  v->halfpq = 0;
251  return 0;
252  }
253  default:
254  break; //Forbidden ?
255  }
256  }
257 
258  pqdiff = get_bits(gb, 3);
259  if (pqdiff == 7)
260  v->altpq = get_bits(gb, 5);
261  else
262  v->altpq = v->pq + pqdiff + 1;
263 
264  return 0;
265 }
266 
268 
269 /**
270  * Decode Simple/Main Profiles sequence header
271  * @see Figure 7-8, p16-17
272  * @param avctx Codec context
273  * @param gb GetBit context initialized from Codec context extra_data
274  * @return Status
275  */
277 {
278  av_log(avctx, AV_LOG_DEBUG, "Header: %0X\n", show_bits_long(gb, 32));
279  v->profile = get_bits(gb, 2);
280  if (v->profile == PROFILE_COMPLEX) {
281  av_log(avctx, AV_LOG_WARNING, "WMV3 Complex Profile is not fully supported\n");
282  }
283 
284  if (v->profile == PROFILE_ADVANCED) {
287  return decode_sequence_header_adv(v, gb);
288  } else {
289  v->chromaformat = 1;
292  v->res_y411 = get_bits1(gb);
293  v->res_sprite = get_bits1(gb);
294  if (v->res_y411) {
295  av_log(avctx, AV_LOG_ERROR,
296  "Old interlaced mode is not supported\n");
297  return -1;
298  }
299  }
300 
301  // (fps-2)/4 (->30)
302  v->frmrtq_postproc = get_bits(gb, 3); //common
303  // (bitrate-32kbps)/64kbps
304  v->bitrtq_postproc = get_bits(gb, 5); //common
305  v->s.loop_filter = get_bits1(gb); //common
306  if (v->s.loop_filter == 1 && v->profile == PROFILE_SIMPLE) {
307  av_log(avctx, AV_LOG_ERROR,
308  "LOOPFILTER shall not be enabled in Simple Profile\n");
309  }
311  v->s.loop_filter = 0;
312 
313  v->res_x8 = get_bits1(gb); //reserved
314  v->multires = get_bits1(gb);
315  v->res_fasttx = get_bits1(gb);
316  if (!v->res_fasttx) {
325  }
326 
327  v->fastuvmc = get_bits1(gb); //common
328  if (!v->profile && !v->fastuvmc) {
329  av_log(avctx, AV_LOG_ERROR,
330  "FASTUVMC unavailable in Simple Profile\n");
331  return -1;
332  }
333  v->extended_mv = get_bits1(gb); //common
334  if (!v->profile && v->extended_mv) {
335  av_log(avctx, AV_LOG_ERROR,
336  "Extended MVs unavailable in Simple Profile\n");
337  return -1;
338  }
339  v->dquant = get_bits(gb, 2); //common
340  v->vstransform = get_bits1(gb); //common
341 
342  v->res_transtab = get_bits1(gb);
343  if (v->res_transtab) {
344  av_log(avctx, AV_LOG_ERROR,
345  "1 for reserved RES_TRANSTAB is forbidden\n");
346  return -1;
347  }
348 
349  v->overlap = get_bits1(gb); //common
350 
351  v->resync_marker = get_bits1(gb);
352  v->rangered = get_bits1(gb);
353  if (v->rangered && v->profile == PROFILE_SIMPLE) {
354  av_log(avctx, AV_LOG_INFO,
355  "RANGERED should be set to 0 in Simple Profile\n");
356  }
357 
358  v->s.max_b_frames = avctx->max_b_frames = get_bits(gb, 3); //common
359  v->quantizer_mode = get_bits(gb, 2); //common
360 
361  v->finterpflag = get_bits1(gb); //common
362 
363  if (v->res_sprite) {
364  int w = get_bits(gb, 11);
365  int h = get_bits(gb, 11);
366  int ret = ff_set_dimensions(v->s.avctx, w, h);
367  if (ret < 0) {
368  av_log(avctx, AV_LOG_ERROR, "Failed to set dimensions %d %d\n", w, h);
369  return ret;
370  }
371  skip_bits(gb, 5); //frame rate
372  v->res_x8 = get_bits1(gb);
373  if (get_bits1(gb)) { // something to do with DC VLC selection
374  av_log(avctx, AV_LOG_ERROR, "Unsupported sprite feature\n");
375  return -1;
376  }
377  skip_bits(gb, 3); //slice code
378  v->res_rtm_flag = 0;
379  } else {
380  v->res_rtm_flag = get_bits1(gb); //reserved
381  }
382  if (!v->res_rtm_flag) {
383  av_log(avctx, AV_LOG_ERROR,
384  "Old WMV3 version detected, some frames may be decoded incorrectly\n");
385  //return -1;
386  }
387  //TODO: figure out what they mean (always 0x402F)
388  if (!v->res_fasttx)
389  skip_bits(gb, 16);
390  av_log(avctx, AV_LOG_DEBUG,
391  "Profile %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
392  "LoopFilter=%i, MultiRes=%i, FastUVMC=%i, Extended MV=%i\n"
393  "Rangered=%i, VSTransform=%i, Overlap=%i, SyncMarker=%i\n"
394  "DQuant=%i, Quantizer mode=%i, Max B-frames=%i\n",
396  v->s.loop_filter, v->multires, v->fastuvmc, v->extended_mv,
397  v->rangered, v->vstransform, v->overlap, v->resync_marker,
398  v->dquant, v->quantizer_mode, avctx->max_b_frames);
399  return 0;
400 }
401 
403 {
404  v->res_rtm_flag = 1;
405  v->level = get_bits(gb, 3);
406  if (v->level >= 5) {
407  av_log(v->s.avctx, AV_LOG_ERROR, "Reserved LEVEL %i\n",v->level);
408  }
409  v->chromaformat = get_bits(gb, 2);
410  if (v->chromaformat != 1) {
412  "Only 4:2:0 chroma format supported\n");
413  return -1;
414  }
415 
416  // (fps-2)/4 (->30)
417  v->frmrtq_postproc = get_bits(gb, 3); //common
418  // (bitrate-32kbps)/64kbps
419  v->bitrtq_postproc = get_bits(gb, 5); //common
420  v->postprocflag = get_bits1(gb); //common
421 
422  v->max_coded_width = (get_bits(gb, 12) + 1) << 1;
423  v->max_coded_height = (get_bits(gb, 12) + 1) << 1;
424  v->broadcast = get_bits1(gb);
425  v->interlace = get_bits1(gb);
426  v->tfcntrflag = get_bits1(gb);
427  v->finterpflag = get_bits1(gb);
428  skip_bits1(gb); // reserved
429 
431  "Advanced Profile level %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
432  "LoopFilter=%i, ChromaFormat=%i, Pulldown=%i, Interlace: %i\n"
433  "TFCTRflag=%i, FINTERPflag=%i\n",
436  v->tfcntrflag, v->finterpflag);
437 
438  v->psf = get_bits1(gb);
439  if (v->psf) { //PsF, 6.1.13
440  av_log(v->s.avctx, AV_LOG_ERROR, "Progressive Segmented Frame mode: not supported (yet)\n");
441  return -1;
442  }
443  v->s.max_b_frames = v->s.avctx->max_b_frames = 7;
444  if (get_bits1(gb)) { //Display Info - decoding is not affected by it
445  int w, h, ar = 0;
446  av_log(v->s.avctx, AV_LOG_DEBUG, "Display extended info:\n");
447  w = get_bits(gb, 14) + 1;
448  h = get_bits(gb, 14) + 1;
449  av_log(v->s.avctx, AV_LOG_DEBUG, "Display dimensions: %ix%i\n", w, h);
450  if (get_bits1(gb))
451  ar = get_bits(gb, 4);
452  if (ar && ar < 14) {
454  } else if (ar == 15) {
455  w = get_bits(gb, 8) + 1;
456  h = get_bits(gb, 8) + 1;
457  v->s.avctx->sample_aspect_ratio = (AVRational){w, h};
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 = 0;
633  if (v->finterpflag)
634  v->interpfrm = get_bits1(gb);
635  if (!v->s.avctx->codec)
636  return -1;
637  if (v->s.avctx->codec_id == AV_CODEC_ID_MSS2)
638  v->respic =
639  v->rangered =
640  v->multires = get_bits(gb, 2) == 1;
641  else
642  skip_bits(gb, 2); //framecnt unused
643  v->rangeredfrm = 0;
644  if (v->rangered)
645  v->rangeredfrm = get_bits1(gb);
646  if (get_bits1(gb)) {
648  } else {
649  if (v->s.avctx->max_b_frames && !get_bits1(gb)) {
651  } else
653  }
654 
655  v->bi_type = 0;
656  if (v->s.pict_type == AV_PICTURE_TYPE_B) {
657  if (read_bfraction(v, gb) < 0)
658  return AVERROR_INVALIDDATA;
659  if (v->bfraction == 0) {
661  }
662  }
664  skip_bits(gb, 7); // skip buffer fullness
665 
666  if (v->parse_only)
667  return 0;
668 
669  /* calculate RND */
671  v->rnd = 1;
672  if (v->s.pict_type == AV_PICTURE_TYPE_P)
673  v->rnd ^= 1;
674 
675  /* Quantizer stuff */
676  pqindex = get_bits(gb, 5);
677  if (!pqindex)
678  return -1;
680  v->pq = ff_vc1_pquant_table[0][pqindex];
681  else
682  v->pq = ff_vc1_pquant_table[1][pqindex];
683  v->pqindex = pqindex;
684  if (pqindex < 9)
685  v->halfpq = get_bits1(gb);
686  else
687  v->halfpq = 0;
688  switch (v->quantizer_mode) {
690  v->pquantizer = pqindex < 9;
691  break;
692  case QUANT_NON_UNIFORM:
693  v->pquantizer = 0;
694  break;
696  v->pquantizer = get_bits1(gb);
697  break;
698  default:
699  v->pquantizer = 1;
700  break;
701  }
702  v->dquantfrm = 0;
703  if (v->extended_mv == 1)
704  v->mvrange = get_unary(gb, 0, 3);
705  v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
706  v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
707  v->range_x = 1 << (v->k_x - 1);
708  v->range_y = 1 << (v->k_y - 1);
709  if (v->multires && v->s.pict_type != AV_PICTURE_TYPE_B)
710  v->respic = get_bits(gb, 2);
711 
712  if (v->res_x8 && (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)) {
713  v->x8_type = get_bits1(gb);
714  } else
715  v->x8_type = 0;
716  ff_dlog(v->s.avctx, "%c Frame: QP=[%i]%i (+%i/2) %i\n",
717  (v->s.pict_type == AV_PICTURE_TYPE_P) ? 'P' : ((v->s.pict_type == AV_PICTURE_TYPE_I) ? 'I' : 'B'),
718  pqindex, v->pq, v->halfpq, v->rangeredfrm);
719 
720  if (v->first_pic_header_flag)
721  rotate_luts(v);
722 
723  switch (v->s.pict_type) {
724  case AV_PICTURE_TYPE_P:
725  v->tt_index = (v->pq > 4) + (v->pq > 12);
726 
727  lowquant = (v->pq > 12) ? 0 : 1;
728  v->mv_mode = ff_vc1_mv_pmode_table[lowquant][get_unary(gb, 1, 4)];
729  if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
730  v->mv_mode2 = ff_vc1_mv_pmode_table2[lowquant][get_unary(gb, 1, 3)];
731  v->lumscale = get_bits(gb, 6);
732  v->lumshift = get_bits(gb, 6);
733  v->last_use_ic = 1;
734  /* fill lookup tables for intensity compensation */
735  INIT_LUT(v->lumscale, v->lumshift, v->last_luty[0], v->last_lutuv[0], 1);
736  INIT_LUT(v->lumscale, v->lumshift, v->last_luty[1], v->last_lutuv[1], 1);
737  }
738  v->qs_last = v->s.quarter_sample;
739  if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
743  } else {
746  v->s.mspel = (v->mv_mode != MV_PMODE_1MV_HPEL_BILIN);
747  }
748 
749  if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
750  v->mv_mode2 == MV_PMODE_MIXED_MV) ||
751  v->mv_mode == MV_PMODE_MIXED_MV) {
753  if (status < 0)
754  return -1;
755  av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
756  "Imode: %i, Invert: %i\n", status>>1, status&1);
757  } else {
758  v->mv_type_is_raw = 0;
759  memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
760  }
761  status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
762  if (status < 0)
763  return -1;
764  av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
765  "Imode: %i, Invert: %i\n", status>>1, status&1);
766 
767  /* Hopefully this is correct for P-frames */
768  v->s.mv_table_index = get_bits(gb, 2); //but using ff_vc1_ tables
769  v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
770 
771  if (v->dquant) {
772  av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
774  }
775 
776  if (v->vstransform) {
777  v->ttmbf = get_bits1(gb);
778  if (v->ttmbf) {
779  v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
780  } else
781  v->ttfrm = 0; //FIXME Is that so ?
782  } else {
783  v->ttmbf = 1;
784  v->ttfrm = TT_8X8;
785  }
786  break;
787  case AV_PICTURE_TYPE_B:
788  v->tt_index = (v->pq > 4) + (v->pq > 12);
789 
791  v->qs_last = v->s.quarter_sample;
792  v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
793  v->s.mspel = v->s.quarter_sample;
794 
795  status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
796  if (status < 0)
797  return -1;
798  av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
799  "Imode: %i, Invert: %i\n", status>>1, status&1);
800  status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
801  if (status < 0)
802  return -1;
803  av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
804  "Imode: %i, Invert: %i\n", status>>1, status&1);
805 
806  v->s.mv_table_index = get_bits(gb, 2);
807  v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
808 
809  if (v->dquant) {
810  av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
812  }
813 
814  if (v->vstransform) {
815  v->ttmbf = get_bits1(gb);
816  if (v->ttmbf) {
817  v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
818  } else
819  v->ttfrm = 0;
820  } else {
821  v->ttmbf = 1;
822  v->ttfrm = TT_8X8;
823  }
824  break;
825  }
826 
827  if (!v->x8_type) {
828  /* AC Syntax */
829  v->c_ac_table_index = decode012(gb);
831  v->y_ac_table_index = decode012(gb);
832  }
833  /* DC Syntax */
834  v->s.dc_table_index = get_bits1(gb);
835  }
836 
837  if (v->s.pict_type == AV_PICTURE_TYPE_BI) {
839  v->bi_type = 1;
840  }
841  return 0;
842 }
843 
845 {
846  int pqindex, lowquant;
847  int status;
848  int mbmodetab, imvtab, icbptab, twomvbptab, fourmvbptab; /* useful only for debugging */
849  int field_mode, fcm;
850 
851  v->numref = 0;
852  v->p_frame_skipped = 0;
853  if (v->second_field) {
854  if (v->fcm != ILACE_FIELD || v->field_mode!=1)
855  return -1;
856  if (v->fptype & 4)
858  else
861  if (!v->pic_header_flag)
862  goto parse_common_info;
863  }
864 
865  field_mode = 0;
866  if (v->interlace) {
867  fcm = decode012(gb);
868  if (fcm) {
869  if (fcm == ILACE_FIELD)
870  field_mode = 1;
871  }
872  } else {
873  fcm = PROGRESSIVE;
874  }
875  if (!v->first_pic_header_flag && v->field_mode != field_mode)
876  return AVERROR_INVALIDDATA;
877  v->field_mode = field_mode;
878  v->fcm = fcm;
879 
880  av_assert0( v->s.mb_height == v->s.height + 15 >> 4
881  || v->s.mb_height == FFALIGN(v->s.height + 15 >> 4, 2));
882  if (v->field_mode) {
883  v->s.mb_height = FFALIGN(v->s.height + 15 >> 4, 2);
884  v->fptype = get_bits(gb, 3);
885  if (v->fptype & 4) // B-picture
887  else
889  } else {
890  v->s.mb_height = v->s.height + 15 >> 4;
891  switch (get_unary(gb, 0, 4)) {
892  case 0:
894  break;
895  case 1:
897  break;
898  case 2:
900  break;
901  case 3:
903  break;
904  case 4:
905  v->s.pict_type = AV_PICTURE_TYPE_P; // skipped pic
906  v->p_frame_skipped = 1;
907  break;
908  }
909  }
910  if (v->tfcntrflag)
911  skip_bits(gb, 8);
912  if (v->broadcast) {
913  if (!v->interlace || v->psf) {
914  v->rptfrm = get_bits(gb, 2);
915  } else {
916  v->tff = get_bits1(gb);
917  v->rff = get_bits1(gb);
918  }
919  } else {
920  v->tff = 1;
921  }
922  if (v->panscanflag) {
923  avpriv_report_missing_feature(v->s.avctx, "Pan-scan");
924  //...
925  }
926  if (v->p_frame_skipped) {
927  return 0;
928  }
929  v->rnd = get_bits1(gb);
930  if (v->interlace)
931  v->uvsamp = get_bits1(gb);
933  return 0; //parsing only, vlc tables havnt been allocated
934  if (v->field_mode) {
935  if (!v->refdist_flag)
936  v->refdist = 0;
937  else if ((v->s.pict_type != AV_PICTURE_TYPE_B) && (v->s.pict_type != AV_PICTURE_TYPE_BI)) {
938  v->refdist = get_bits(gb, 2);
939  if (v->refdist == 3)
940  v->refdist += get_unary(gb, 0, 16);
941  }
942  if ((v->s.pict_type == AV_PICTURE_TYPE_B) || (v->s.pict_type == AV_PICTURE_TYPE_BI)) {
943  if (read_bfraction(v, gb) < 0)
944  return AVERROR_INVALIDDATA;
945  v->frfd = (v->bfraction * v->refdist) >> 8;
946  v->brfd = v->refdist - v->frfd - 1;
947  if (v->brfd < 0)
948  v->brfd = 0;
949  }
950  goto parse_common_info;
951  }
952  if (v->fcm == PROGRESSIVE) {
953  if (v->finterpflag)
954  v->interpfrm = get_bits1(gb);
955  if (v->s.pict_type == AV_PICTURE_TYPE_B) {
956  if (read_bfraction(v, gb) < 0)
957  return AVERROR_INVALIDDATA;
958  if (v->bfraction == 0) {
959  v->s.pict_type = AV_PICTURE_TYPE_BI; /* XXX: should not happen here */
960  }
961  }
962  }
963 
964  parse_common_info:
965  if (v->field_mode)
966  v->cur_field_type = !(v->tff ^ v->second_field);
967  pqindex = get_bits(gb, 5);
968  if (!pqindex)
969  return -1;
971  v->pq = ff_vc1_pquant_table[0][pqindex];
972  else
973  v->pq = ff_vc1_pquant_table[1][pqindex];
974  v->pqindex = pqindex;
975  if (pqindex < 9)
976  v->halfpq = get_bits1(gb);
977  else
978  v->halfpq = 0;
979  switch (v->quantizer_mode) {
981  v->pquantizer = pqindex < 9;
982  break;
983  case QUANT_NON_UNIFORM:
984  v->pquantizer = 0;
985  break;
987  v->pquantizer = get_bits1(gb);
988  break;
989  default:
990  v->pquantizer = 1;
991  break;
992  }
993  if (v->postprocflag)
994  v->postproc = get_bits(gb, 2);
995 
996  if (v->parse_only)
997  return 0;
998 
999  if (v->first_pic_header_flag)
1000  rotate_luts(v);
1001 
1002  switch (v->s.pict_type) {
1003  case AV_PICTURE_TYPE_I:
1004  case AV_PICTURE_TYPE_BI:
1005  if (v->fcm == ILACE_FRAME) { //interlace frame picture
1006  status = bitplane_decoding(v->fieldtx_plane, &v->fieldtx_is_raw, v);
1007  if (status < 0)
1008  return -1;
1009  av_log(v->s.avctx, AV_LOG_DEBUG, "FIELDTX plane encoding: "
1010  "Imode: %i, Invert: %i\n", status>>1, status&1);
1011  }
1012  status = bitplane_decoding(v->acpred_plane, &v->acpred_is_raw, v);
1013  if (status < 0)
1014  return -1;
1015  av_log(v->s.avctx, AV_LOG_DEBUG, "ACPRED plane encoding: "
1016  "Imode: %i, Invert: %i\n", status>>1, status&1);
1017  v->condover = CONDOVER_NONE;
1018  if (v->overlap && v->pq <= 8) {
1019  v->condover = decode012(gb);
1020  if (v->condover == CONDOVER_SELECT) {
1021  status = bitplane_decoding(v->over_flags_plane, &v->overflg_is_raw, v);
1022  if (status < 0)
1023  return -1;
1024  av_log(v->s.avctx, AV_LOG_DEBUG, "CONDOVER plane encoding: "
1025  "Imode: %i, Invert: %i\n", status>>1, status&1);
1026  }
1027  }
1028  break;
1029  case AV_PICTURE_TYPE_P:
1030  if (v->field_mode) {
1031  v->numref = get_bits1(gb);
1032  if (!v->numref) {
1033  v->reffield = get_bits1(gb);
1034  v->ref_field_type[0] = v->reffield ^ !v->cur_field_type;
1035  }
1036  }
1037  if (v->extended_mv)
1038  v->mvrange = get_unary(gb, 0, 3);
1039  else
1040  v->mvrange = 0;
1041  if (v->interlace) {
1042  if (v->extended_dmv)
1043  v->dmvrange = get_unary(gb, 0, 3);
1044  else
1045  v->dmvrange = 0;
1046  if (v->fcm == ILACE_FRAME) { // interlaced frame picture
1047  v->fourmvswitch = get_bits1(gb);
1048  v->intcomp = get_bits1(gb);
1049  if (v->intcomp) {
1050  v->lumscale = get_bits(gb, 6);
1051  v->lumshift = get_bits(gb, 6);
1052  INIT_LUT(v->lumscale, v->lumshift, v->last_luty[0], v->last_lutuv[0], 1);
1053  INIT_LUT(v->lumscale, v->lumshift, v->last_luty[1], v->last_lutuv[1], 1);
1054  v->last_use_ic = 1;
1055  }
1056  status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1057  av_log(v->s.avctx, AV_LOG_DEBUG, "SKIPMB plane encoding: "
1058  "Imode: %i, Invert: %i\n", status>>1, status&1);
1059  mbmodetab = get_bits(gb, 2);
1060  if (v->fourmvswitch)
1061  v->mbmode_vlc = &ff_vc1_intfr_4mv_mbmode_vlc[mbmodetab];
1062  else
1063  v->mbmode_vlc = &ff_vc1_intfr_non4mv_mbmode_vlc[mbmodetab];
1064  imvtab = get_bits(gb, 2);
1065  v->imv_vlc = &ff_vc1_1ref_mvdata_vlc[imvtab];
1066  // interlaced p-picture cbpcy range is [1, 63]
1067  icbptab = get_bits(gb, 3);
1068  v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
1069  twomvbptab = get_bits(gb, 2);
1070  v->twomvbp_vlc = &ff_vc1_2mv_block_pattern_vlc[twomvbptab];
1071  if (v->fourmvswitch) {
1072  fourmvbptab = get_bits(gb, 2);
1073  v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
1074  }
1075  }
1076  }
1077  v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1078  v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
1079  v->range_x = 1 << (v->k_x - 1);
1080  v->range_y = 1 << (v->k_y - 1);
1081 
1082  v->tt_index = (v->pq > 4) + (v->pq > 12);
1083  if (v->fcm != ILACE_FRAME) {
1084  int mvmode;
1085  mvmode = get_unary(gb, 1, 4);
1086  lowquant = (v->pq > 12) ? 0 : 1;
1087  v->mv_mode = ff_vc1_mv_pmode_table[lowquant][mvmode];
1088  if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
1089  int mvmode2;
1090  mvmode2 = get_unary(gb, 1, 3);
1091  v->mv_mode2 = ff_vc1_mv_pmode_table2[lowquant][mvmode2];
1092  if (v->field_mode) {
1093  v->intcompfield = decode210(gb) ^ 3;
1094  } else
1095  v->intcompfield = 3;
1096 
1097  v->lumscale2 = v->lumscale = 32;
1098  v->lumshift2 = v->lumshift = 0;
1099  if (v->intcompfield & 1) {
1100  v->lumscale = get_bits(gb, 6);
1101  v->lumshift = get_bits(gb, 6);
1102  }
1103  if ((v->intcompfield & 2) && v->field_mode) {
1104  v->lumscale2 = get_bits(gb, 6);
1105  v->lumshift2 = get_bits(gb, 6);
1106  } else if(!v->field_mode) {
1107  v->lumscale2 = v->lumscale;
1108  v->lumshift2 = v->lumshift;
1109  }
1110  if (v->field_mode && v->second_field) {
1111  if (v->cur_field_type) {
1112  INIT_LUT(v->lumscale , v->lumshift , v->curr_luty[v->cur_field_type^1], v->curr_lutuv[v->cur_field_type^1], 0);
1114  } else {
1117  }
1118  v->next_use_ic = *v->curr_use_ic = 1;
1119  } else {
1120  INIT_LUT(v->lumscale , v->lumshift , v->last_luty[0], v->last_lutuv[0], 1);
1121  INIT_LUT(v->lumscale2, v->lumshift2, v->last_luty[1], v->last_lutuv[1], 1);
1122  }
1123  v->last_use_ic = 1;
1124  }
1125  v->qs_last = v->s.quarter_sample;
1126  if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
1129  v->s.mspel = (v->mv_mode2 != MV_PMODE_1MV_HPEL_BILIN);
1130  } else {
1131  v->s.quarter_sample = (v->mv_mode != MV_PMODE_1MV_HPEL &&
1133  v->s.mspel = (v->mv_mode != MV_PMODE_1MV_HPEL_BILIN);
1134  }
1135  }
1136  if (v->fcm == PROGRESSIVE) { // progressive
1137  if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
1139  || v->mv_mode == MV_PMODE_MIXED_MV) {
1140  status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);
1141  if (status < 0)
1142  return -1;
1143  av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
1144  "Imode: %i, Invert: %i\n", status>>1, status&1);
1145  } else {
1146  v->mv_type_is_raw = 0;
1147  memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
1148  }
1149  status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1150  if (status < 0)
1151  return -1;
1152  av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1153  "Imode: %i, Invert: %i\n", status>>1, status&1);
1154 
1155  /* Hopefully this is correct for P-frames */
1156  v->s.mv_table_index = get_bits(gb, 2); //but using ff_vc1_ tables
1157  v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
1158  } else if (v->fcm == ILACE_FRAME) { // frame interlaced
1159  v->qs_last = v->s.quarter_sample;
1160  v->s.quarter_sample = 1;
1161  v->s.mspel = 1;
1162  } else { // field interlaced
1163  mbmodetab = get_bits(gb, 3);
1164  imvtab = get_bits(gb, 2 + v->numref);
1165  if (!v->numref)
1166  v->imv_vlc = &ff_vc1_1ref_mvdata_vlc[imvtab];
1167  else
1168  v->imv_vlc = &ff_vc1_2ref_mvdata_vlc[imvtab];
1169  icbptab = get_bits(gb, 3);
1170  v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
1171  if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
1173  fourmvbptab = get_bits(gb, 2);
1174  v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
1175  v->mbmode_vlc = &ff_vc1_if_mmv_mbmode_vlc[mbmodetab];
1176  } else {
1177  v->mbmode_vlc = &ff_vc1_if_1mv_mbmode_vlc[mbmodetab];
1178  }
1179  }
1180  if (v->dquant) {
1181  av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1183  }
1184 
1185  if (v->vstransform) {
1186  v->ttmbf = get_bits1(gb);
1187  if (v->ttmbf) {
1188  v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
1189  } else
1190  v->ttfrm = 0; //FIXME Is that so ?
1191  } else {
1192  v->ttmbf = 1;
1193  v->ttfrm = TT_8X8;
1194  }
1195  break;
1196  case AV_PICTURE_TYPE_B:
1197  if (v->fcm == ILACE_FRAME) {
1198  if (read_bfraction(v, gb) < 0)
1199  return AVERROR_INVALIDDATA;
1200  if (v->bfraction == 0) {
1201  return -1;
1202  }
1203  }
1204  if (v->extended_mv)
1205  v->mvrange = get_unary(gb, 0, 3);
1206  else
1207  v->mvrange = 0;
1208  v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1209  v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
1210  v->range_x = 1 << (v->k_x - 1);
1211  v->range_y = 1 << (v->k_y - 1);
1212 
1213  v->tt_index = (v->pq > 4) + (v->pq > 12);
1214 
1215  if (v->field_mode) {
1216  int mvmode;
1217  av_log(v->s.avctx, AV_LOG_DEBUG, "B Fields\n");
1218  if (v->extended_dmv)
1219  v->dmvrange = get_unary(gb, 0, 3);
1220  mvmode = get_unary(gb, 1, 3);
1221  lowquant = (v->pq > 12) ? 0 : 1;
1222  v->mv_mode = ff_vc1_mv_pmode_table2[lowquant][mvmode];
1223  v->qs_last = v->s.quarter_sample;
1226  status = bitplane_decoding(v->forward_mb_plane, &v->fmb_is_raw, v);
1227  if (status < 0)
1228  return -1;
1229  av_log(v->s.avctx, AV_LOG_DEBUG, "MB Forward Type plane encoding: "
1230  "Imode: %i, Invert: %i\n", status>>1, status&1);
1231  mbmodetab = get_bits(gb, 3);
1232  if (v->mv_mode == MV_PMODE_MIXED_MV)
1233  v->mbmode_vlc = &ff_vc1_if_mmv_mbmode_vlc[mbmodetab];
1234  else
1235  v->mbmode_vlc = &ff_vc1_if_1mv_mbmode_vlc[mbmodetab];
1236  imvtab = get_bits(gb, 3);
1237  v->imv_vlc = &ff_vc1_2ref_mvdata_vlc[imvtab];
1238  icbptab = get_bits(gb, 3);
1239  v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
1240  if (v->mv_mode == MV_PMODE_MIXED_MV) {
1241  fourmvbptab = get_bits(gb, 2);
1242  v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
1243  }
1244  v->numref = 1; // interlaced field B pictures are always 2-ref
1245  } else if (v->fcm == ILACE_FRAME) {
1246  if (v->extended_dmv)
1247  v->dmvrange = get_unary(gb, 0, 3);
1248  if (get_bits1(gb)) /* intcomp - present but shall always be 0 */
1249  av_log(v->s.avctx, AV_LOG_WARNING, "Intensity compensation set for B picture\n");
1250  v->intcomp = 0;
1251  v->mv_mode = MV_PMODE_1MV;
1252  v->fourmvswitch = 0;
1253  v->qs_last = v->s.quarter_sample;
1254  v->s.quarter_sample = 1;
1255  v->s.mspel = 1;
1256  status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
1257  if (status < 0)
1258  return -1;
1259  av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
1260  "Imode: %i, Invert: %i\n", status>>1, status&1);
1261  status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1262  if (status < 0)
1263  return -1;
1264  av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1265  "Imode: %i, Invert: %i\n", status>>1, status&1);
1266  mbmodetab = get_bits(gb, 2);
1267  v->mbmode_vlc = &ff_vc1_intfr_non4mv_mbmode_vlc[mbmodetab];
1268  imvtab = get_bits(gb, 2);
1269  v->imv_vlc = &ff_vc1_1ref_mvdata_vlc[imvtab];
1270  // interlaced p/b-picture cbpcy range is [1, 63]
1271  icbptab = get_bits(gb, 3);
1272  v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
1273  twomvbptab = get_bits(gb, 2);
1274  v->twomvbp_vlc = &ff_vc1_2mv_block_pattern_vlc[twomvbptab];
1275  fourmvbptab = get_bits(gb, 2);
1276  v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
1277  } else {
1279  v->qs_last = v->s.quarter_sample;
1280  v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
1281  v->s.mspel = v->s.quarter_sample;
1282  status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
1283  if (status < 0)
1284  return -1;
1285  av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
1286  "Imode: %i, Invert: %i\n", status>>1, status&1);
1287  status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1288  if (status < 0)
1289  return -1;
1290  av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1291  "Imode: %i, Invert: %i\n", status>>1, status&1);
1292  v->s.mv_table_index = get_bits(gb, 2);
1293  v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
1294  }
1295 
1296  if (v->dquant) {
1297  av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1299  }
1300 
1301  if (v->vstransform) {
1302  v->ttmbf = get_bits1(gb);
1303  if (v->ttmbf) {
1304  v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
1305  } else
1306  v->ttfrm = 0;
1307  } else {
1308  v->ttmbf = 1;
1309  v->ttfrm = TT_8X8;
1310  }
1311  break;
1312  }
1313 
1314  if (v->fcm != PROGRESSIVE && !v->s.quarter_sample) {
1315  v->range_x <<= 1;
1316  v->range_y <<= 1;
1317  }
1318 
1319  /* AC Syntax */
1320  v->c_ac_table_index = decode012(gb);
1322  v->y_ac_table_index = decode012(gb);
1323  }
1324  /* DC Syntax */
1325  v->s.dc_table_index = get_bits1(gb);
1327  && v->dquant) {
1328  av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1330  }
1331 
1332  v->bi_type = (v->s.pict_type == AV_PICTURE_TYPE_BI);
1333  if (v->bi_type)
1335 
1336  return 0;
1337 }
1338 
1339 static const uint32_t vc1_ac_tables[AC_MODES][186][2] = {
1340 {
1341 { 0x0001, 2}, { 0x0005, 3}, { 0x000D, 4}, { 0x0012, 5}, { 0x000E, 6}, { 0x0015, 7},
1342 { 0x0013, 8}, { 0x003F, 8}, { 0x004B, 9}, { 0x011F, 9}, { 0x00B8, 10}, { 0x03E3, 10},
1343 { 0x0172, 11}, { 0x024D, 12}, { 0x03DA, 12}, { 0x02DD, 13}, { 0x1F55, 13}, { 0x05B9, 14},
1344 { 0x3EAE, 14}, { 0x0000, 4}, { 0x0010, 5}, { 0x0008, 7}, { 0x0020, 8}, { 0x0029, 9},
1345 { 0x01F4, 9}, { 0x0233, 10}, { 0x01E0, 11}, { 0x012A, 12}, { 0x03DD, 12}, { 0x050A, 13},
1346 { 0x1F29, 13}, { 0x0A42, 14}, { 0x1272, 15}, { 0x1737, 15}, { 0x0003, 5}, { 0x0011, 7},
1347 { 0x00C4, 8}, { 0x004B, 10}, { 0x00B4, 11}, { 0x07D4, 11}, { 0x0345, 12}, { 0x02D7, 13},
1348 { 0x07BF, 13}, { 0x0938, 14}, { 0x0BBB, 14}, { 0x095E, 15}, { 0x0013, 5}, { 0x0078, 7},
1349 { 0x0069, 9}, { 0x0232, 10}, { 0x0461, 11}, { 0x03EC, 12}, { 0x0520, 13}, { 0x1F2A, 13},
1350 { 0x3E50, 14}, { 0x3E51, 14}, { 0x1486, 15}, { 0x000C, 6}, { 0x0024, 9}, { 0x0094, 11},
1351 { 0x08C0, 12}, { 0x0F09, 14}, { 0x1EF0, 15}, { 0x003D, 6}, { 0x0053, 9}, { 0x01A0, 11},
1352 { 0x02D6, 13}, { 0x0F08, 14}, { 0x0013, 7}, { 0x007C, 9}, { 0x07C1, 11}, { 0x04AC, 14},
1353 { 0x001B, 7}, { 0x00A0, 10}, { 0x0344, 12}, { 0x0F79, 14}, { 0x0079, 7}, { 0x03E1, 10},
1354 { 0x02D4, 13}, { 0x2306, 14}, { 0x0021, 8}, { 0x023C, 10}, { 0x0FAE, 12}, { 0x23DE, 14},
1355 { 0x0035, 8}, { 0x0175, 11}, { 0x07B3, 13}, { 0x00C5, 8}, { 0x0174, 11}, { 0x0785, 13},
1356 { 0x0048, 9}, { 0x01A3, 11}, { 0x049E, 13}, { 0x002C, 9}, { 0x00FA, 10}, { 0x07D6, 11},
1357 { 0x0092, 10}, { 0x05CC, 13}, { 0x1EF1, 15}, { 0x00A3, 10}, { 0x03ED, 12}, { 0x093E, 14},
1358 { 0x01E2, 11}, { 0x1273, 15}, { 0x07C4, 11}, { 0x1487, 15}, { 0x0291, 12}, { 0x0293, 12},
1359 { 0x0F8A, 12}, { 0x0509, 13}, { 0x0508, 13}, { 0x078D, 13}, { 0x07BE, 13}, { 0x078C, 13},
1360 { 0x04AE, 14}, { 0x0BBA, 14}, { 0x2307, 14}, { 0x0B9A, 14}, { 0x1736, 15}, { 0x000E, 4},
1361 { 0x0045, 7}, { 0x01F3, 9}, { 0x047A, 11}, { 0x05DC, 13}, { 0x23DF, 14}, { 0x0019, 5},
1362 { 0x0028, 9}, { 0x0176, 11}, { 0x049D, 13}, { 0x23DD, 14}, { 0x0030, 6}, { 0x00A2, 10},
1363 { 0x02EF, 12}, { 0x05B8, 14}, { 0x003F, 6}, { 0x00A5, 10}, { 0x03DB, 12}, { 0x093F, 14},
1364 { 0x0044, 7}, { 0x07CB, 11}, { 0x095F, 15}, { 0x0063, 7}, { 0x03C3, 12}, { 0x0015, 8},
1365 { 0x08F6, 12}, { 0x0017, 8}, { 0x0498, 13}, { 0x002C, 8}, { 0x07B2, 13}, { 0x002F, 8},
1366 { 0x1F54, 13}, { 0x008D, 8}, { 0x07BD, 13}, { 0x008E, 8}, { 0x1182, 13}, { 0x00FB, 8},
1367 { 0x050B, 13}, { 0x002D, 8}, { 0x07C0, 11}, { 0x0079, 9}, { 0x1F5F, 13}, { 0x007A, 9},
1368 { 0x1F56, 13}, { 0x0231, 10}, { 0x03E4, 10}, { 0x01A1, 11}, { 0x0143, 11}, { 0x01F7, 11},
1369 { 0x016F, 12}, { 0x0292, 12}, { 0x02E7, 12}, { 0x016C, 12}, { 0x016D, 12}, { 0x03DC, 12},
1370 { 0x0F8B, 12}, { 0x0499, 13}, { 0x03D8, 12}, { 0x078E, 13}, { 0x02D5, 13}, { 0x1F5E, 13},
1371 { 0x1F2B, 13}, { 0x078F, 13}, { 0x04AD, 14}, { 0x3EAF, 14}, { 0x23DC, 14}, { 0x004A, 9}
1372 },
1373 {
1374 { 0x0000, 3}, { 0x0003, 4}, { 0x000B, 5}, { 0x0014, 6}, { 0x003F, 6}, { 0x005D, 7},
1375 { 0x00A2, 8}, { 0x00AC, 9}, { 0x016E, 9}, { 0x020A, 10}, { 0x02E2, 10}, { 0x0432, 11},
1376 { 0x05C9, 11}, { 0x0827, 12}, { 0x0B54, 12}, { 0x04E6, 13}, { 0x105F, 13}, { 0x172A, 13},
1377 { 0x20B2, 14}, { 0x2D4E, 14}, { 0x39F0, 14}, { 0x4175, 15}, { 0x5A9E, 15}, { 0x0004, 4},
1378 { 0x001E, 5}, { 0x0042, 7}, { 0x00B6, 8}, { 0x0173, 9}, { 0x0395, 10}, { 0x072E, 11},
1379 { 0x0B94, 12}, { 0x16A4, 13}, { 0x20B3, 14}, { 0x2E45, 14}, { 0x0005, 5}, { 0x0040, 7},
1380 { 0x0049, 9}, { 0x028F, 10}, { 0x05CB, 11}, { 0x048A, 13}, { 0x09DD, 14}, { 0x73E2, 15},
1381 { 0x0018, 5}, { 0x0025, 8}, { 0x008A, 10}, { 0x051B, 11}, { 0x0E5F, 12}, { 0x09C9, 14},
1382 { 0x139C, 15}, { 0x0029, 6}, { 0x004F, 9}, { 0x0412, 11}, { 0x048D, 13}, { 0x2E41, 14},
1383 { 0x0038, 6}, { 0x010E, 9}, { 0x05A8, 11}, { 0x105C, 13}, { 0x39F2, 14}, { 0x0058, 7},
1384 { 0x021F, 10}, { 0x0E7E, 12}, { 0x39FF, 14}, { 0x0023, 8}, { 0x02E3, 10}, { 0x04E5, 13},
1385 { 0x2E40, 14}, { 0x00A1, 8}, { 0x05BE, 11}, { 0x09C8, 14}, { 0x0083, 8}, { 0x013A, 11},
1386 { 0x1721, 13}, { 0x0044, 9}, { 0x0276, 12}, { 0x39F6, 14}, { 0x008B, 10}, { 0x04EF, 13},
1387 { 0x5A9B, 15}, { 0x0208, 10}, { 0x1CFE, 13}, { 0x0399, 10}, { 0x1CB4, 13}, { 0x039E, 10},
1388 { 0x39F3, 14}, { 0x05AB, 11}, { 0x73E3, 15}, { 0x0737, 11}, { 0x5A9F, 15}, { 0x082D, 12},
1389 { 0x0E69, 12}, { 0x0E68, 12}, { 0x0433, 11}, { 0x0B7B, 12}, { 0x2DF8, 14}, { 0x2E56, 14},
1390 { 0x2E57, 14}, { 0x39F7, 14}, { 0x51A5, 15}, { 0x0003, 3}, { 0x002A, 6}, { 0x00E4, 8},
1391 { 0x028E, 10}, { 0x0735, 11}, { 0x1058, 13}, { 0x1CFA, 13}, { 0x2DF9, 14}, { 0x4174, 15},
1392 { 0x0009, 4}, { 0x0054, 8}, { 0x0398, 10}, { 0x048B, 13}, { 0x139D, 15}, { 0x000D, 4},
1393 { 0x00AD, 9}, { 0x0826, 12}, { 0x2D4C, 14}, { 0x0011, 5}, { 0x016B, 9}, { 0x0B7F, 12},
1394 { 0x51A4, 15}, { 0x0019, 5}, { 0x021B, 10}, { 0x16FD, 13}, { 0x001D, 5}, { 0x0394, 10},
1395 { 0x28D3, 14}, { 0x002B, 6}, { 0x05BC, 11}, { 0x5A9A, 15}, { 0x002F, 6}, { 0x0247, 12},
1396 { 0x0010, 7}, { 0x0A35, 12}, { 0x003E, 6}, { 0x0B7A, 12}, { 0x0059, 7}, { 0x105E, 13},
1397 { 0x0026, 8}, { 0x09CF, 14}, { 0x0055, 8}, { 0x1CB5, 13}, { 0x0057, 8}, { 0x0E5B, 12},
1398 { 0x00A0, 8}, { 0x1468, 13}, { 0x0170, 9}, { 0x0090, 10}, { 0x01CE, 9}, { 0x021A, 10},
1399 { 0x0218, 10}, { 0x0168, 9}, { 0x021E, 10}, { 0x0244, 12}, { 0x0736, 11}, { 0x0138, 11},
1400 { 0x0519, 11}, { 0x0E5E, 12}, { 0x072C, 11}, { 0x0B55, 12}, { 0x09DC, 14}, { 0x20BB, 14},
1401 { 0x048C, 13}, { 0x1723, 13}, { 0x2E44, 14}, { 0x16A5, 13}, { 0x0518, 11}, { 0x39FE, 14},
1402 { 0x0169, 9}
1403 },
1404 {
1405 { 0x0001, 2}, { 0x0006, 3}, { 0x000F, 4}, { 0x0016, 5}, { 0x0020, 6}, { 0x0018, 7},
1406 { 0x0008, 8}, { 0x009A, 8}, { 0x0056, 9}, { 0x013E, 9}, { 0x00F0, 10}, { 0x03A5, 10},
1407 { 0x0077, 11}, { 0x01EF, 11}, { 0x009A, 12}, { 0x005D, 13}, { 0x0001, 4}, { 0x0011, 5},
1408 { 0x0002, 7}, { 0x000B, 8}, { 0x0012, 9}, { 0x01D6, 9}, { 0x027E, 10}, { 0x0191, 11},
1409 { 0x00EA, 12}, { 0x03DC, 12}, { 0x013B, 13}, { 0x0004, 5}, { 0x0014, 7}, { 0x009E, 8},
1410 { 0x0009, 10}, { 0x01AC, 11}, { 0x01E2, 11}, { 0x03CA, 12}, { 0x005F, 13}, { 0x0017, 5},
1411 { 0x004E, 7}, { 0x005E, 9}, { 0x00F3, 10}, { 0x01AD, 11}, { 0x00EC, 12}, { 0x05F0, 13},
1412 { 0x000E, 6}, { 0x00E1, 8}, { 0x03A4, 10}, { 0x009C, 12}, { 0x013D, 13}, { 0x003B, 6},
1413 { 0x001C, 9}, { 0x0014, 11}, { 0x09BE, 12}, { 0x0006, 7}, { 0x007A, 9}, { 0x0190, 11},
1414 { 0x0137, 13}, { 0x001B, 7}, { 0x0008, 10}, { 0x075C, 11}, { 0x0071, 7}, { 0x00D7, 10},
1415 { 0x09BF, 12}, { 0x0007, 8}, { 0x00AF, 10}, { 0x04CC, 11}, { 0x0034, 8}, { 0x0265, 10},
1416 { 0x009F, 12}, { 0x00E0, 8}, { 0x0016, 11}, { 0x0327, 12}, { 0x0015, 9}, { 0x017D, 11},
1417 { 0x0EBB, 12}, { 0x0014, 9}, { 0x00F6, 10}, { 0x01E4, 11}, { 0x00CB, 10}, { 0x099D, 12},
1418 { 0x00CA, 10}, { 0x02FC, 12}, { 0x017F, 11}, { 0x04CD, 11}, { 0x02FD, 12}, { 0x04FE, 11},
1419 { 0x013A, 13}, { 0x000A, 4}, { 0x0042, 7}, { 0x01D3, 9}, { 0x04DD, 11}, { 0x0012, 5},
1420 { 0x00E8, 8}, { 0x004C, 11}, { 0x0136, 13}, { 0x0039, 6}, { 0x0264, 10}, { 0x0EBA, 12},
1421 { 0x0000, 7}, { 0x00AE, 10}, { 0x099C, 12}, { 0x001F, 7}, { 0x04DE, 11}, { 0x0043, 7},
1422 { 0x04DC, 11}, { 0x0003, 8}, { 0x03CB, 12}, { 0x0006, 8}, { 0x099E, 12}, { 0x002A, 8},
1423 { 0x05F1, 13}, { 0x000F, 8}, { 0x09FE, 12}, { 0x0033, 8}, { 0x09FF, 12}, { 0x0098, 8},
1424 { 0x099F, 12}, { 0x00EA, 8}, { 0x013C, 13}, { 0x002E, 8}, { 0x0192, 11}, { 0x0136, 9},
1425 { 0x006A, 9}, { 0x0015, 11}, { 0x03AF, 10}, { 0x01E3, 11}, { 0x0074, 11}, { 0x00EB, 12},
1426 { 0x02F9, 12}, { 0x005C, 13}, { 0x00ED, 12}, { 0x03DD, 12}, { 0x0326, 12}, { 0x005E, 13},
1427 { 0x0016, 7}
1428 },
1429 {
1430 { 0x0004, 3}, { 0x0014, 5}, { 0x0017, 7}, { 0x007F, 8}, { 0x0154, 9}, { 0x01F2, 10},
1431 { 0x00BF, 11}, { 0x0065, 12}, { 0x0AAA, 12}, { 0x0630, 13}, { 0x1597, 13}, { 0x03B7, 14},
1432 { 0x2B22, 14}, { 0x0BE6, 15}, { 0x000B, 4}, { 0x0037, 7}, { 0x0062, 9}, { 0x0007, 11},
1433 { 0x0166, 12}, { 0x00CE, 13}, { 0x1590, 13}, { 0x05F6, 14}, { 0x0BE7, 15}, { 0x0007, 5},
1434 { 0x006D, 8}, { 0x0003, 11}, { 0x031F, 12}, { 0x05F2, 14}, { 0x0002, 6}, { 0x0061, 9},
1435 { 0x0055, 12}, { 0x01DF, 14}, { 0x001A, 6}, { 0x001E, 10}, { 0x0AC9, 12}, { 0x2B23, 14},
1436 { 0x001E, 6}, { 0x001F, 10}, { 0x0AC3, 12}, { 0x2B2B, 14}, { 0x0006, 7}, { 0x0004, 11},
1437 { 0x02F8, 13}, { 0x0019, 7}, { 0x0006, 11}, { 0x063D, 13}, { 0x0057, 7}, { 0x0182, 11},
1438 { 0x2AA2, 14}, { 0x0004, 8}, { 0x0180, 11}, { 0x059C, 14}, { 0x007D, 8}, { 0x0164, 12},
1439 { 0x076D, 15}, { 0x0002, 9}, { 0x018D, 11}, { 0x1581, 13}, { 0x00AD, 8}, { 0x0060, 12},
1440 { 0x0C67, 14}, { 0x001C, 9}, { 0x00EE, 13}, { 0x0003, 9}, { 0x02CF, 13}, { 0x00D9, 9},
1441 { 0x1580, 13}, { 0x0002, 11}, { 0x0183, 11}, { 0x0057, 12}, { 0x0061, 12}, { 0x0031, 11},
1442 { 0x0066, 12}, { 0x0631, 13}, { 0x0632, 13}, { 0x00AC, 13}, { 0x031D, 12}, { 0x0076, 12},
1443 { 0x003A, 11}, { 0x0165, 12}, { 0x0C66, 14}, { 0x0003, 2}, { 0x0054, 7}, { 0x02AB, 10},
1444 { 0x0016, 13}, { 0x05F7, 14}, { 0x0005, 4}, { 0x00F8, 9}, { 0x0AA9, 12}, { 0x005F, 15},
1445 { 0x0004, 4}, { 0x001C, 10}, { 0x1550, 13}, { 0x0004, 5}, { 0x0077, 11}, { 0x076C, 15},
1446 { 0x000E, 5}, { 0x000A, 12}, { 0x000C, 5}, { 0x0562, 11}, { 0x0004, 6}, { 0x031C, 12},
1447 { 0x0006, 6}, { 0x00C8, 13}, { 0x000D, 6}, { 0x01DA, 13}, { 0x0007, 6}, { 0x00C9, 13},
1448 { 0x0001, 7}, { 0x002E, 14}, { 0x0014, 7}, { 0x1596, 13}, { 0x000A, 7}, { 0x0AC2, 12},
1449 { 0x0016, 7}, { 0x015B, 14}, { 0x0015, 7}, { 0x015A, 14}, { 0x000F, 8}, { 0x005E, 15},
1450 { 0x007E, 8}, { 0x00AB, 8}, { 0x002D, 9}, { 0x00D8, 9}, { 0x000B, 9}, { 0x0014, 10},
1451 { 0x02B3, 10}, { 0x01F3, 10}, { 0x003A, 10}, { 0x0000, 10}, { 0x0058, 10}, { 0x002E, 9},
1452 { 0x005E, 10}, { 0x0563, 11}, { 0x00EC, 12}, { 0x0054, 12}, { 0x0AC1, 12}, { 0x1556, 13},
1453 { 0x02FA, 13}, { 0x0181, 11}, { 0x1557, 13}, { 0x059D, 14}, { 0x2AA3, 14}, { 0x2B2A, 14},
1454 { 0x01DE, 14}, { 0x063C, 13}, { 0x00CF, 13}, { 0x1594, 13}, { 0x000D, 9}
1455 },
1456 {
1457 { 0x0002, 2}, { 0x0006, 3}, { 0x000F, 4}, { 0x000D, 5}, { 0x000C, 5}, { 0x0015, 6},
1458 { 0x0013, 6}, { 0x0012, 6}, { 0x0017, 7}, { 0x001F, 8}, { 0x001E, 8}, { 0x001D, 8},
1459 { 0x0025, 9}, { 0x0024, 9}, { 0x0023, 9}, { 0x0021, 9}, { 0x0021, 10}, { 0x0020, 10},
1460 { 0x000F, 10}, { 0x000E, 10}, { 0x0007, 11}, { 0x0006, 11}, { 0x0020, 11}, { 0x0021, 11},
1461 { 0x0050, 12}, { 0x0051, 12}, { 0x0052, 12}, { 0x000E, 4}, { 0x0014, 6}, { 0x0016, 7},
1462 { 0x001C, 8}, { 0x0020, 9}, { 0x001F, 9}, { 0x000D, 10}, { 0x0022, 11}, { 0x0053, 12},
1463 { 0x0055, 12}, { 0x000B, 5}, { 0x0015, 7}, { 0x001E, 9}, { 0x000C, 10}, { 0x0056, 12},
1464 { 0x0011, 6}, { 0x001B, 8}, { 0x001D, 9}, { 0x000B, 10}, { 0x0010, 6}, { 0x0022, 9},
1465 { 0x000A, 10}, { 0x000D, 6}, { 0x001C, 9}, { 0x0008, 10}, { 0x0012, 7}, { 0x001B, 9},
1466 { 0x0054, 12}, { 0x0014, 7}, { 0x001A, 9}, { 0x0057, 12}, { 0x0019, 8}, { 0x0009, 10},
1467 { 0x0018, 8}, { 0x0023, 11}, { 0x0017, 8}, { 0x0019, 9}, { 0x0018, 9}, { 0x0007, 10},
1468 { 0x0058, 12}, { 0x0007, 4}, { 0x000C, 6}, { 0x0016, 8}, { 0x0017, 9}, { 0x0006, 10},
1469 { 0x0005, 11}, { 0x0004, 11}, { 0x0059, 12}, { 0x000F, 6}, { 0x0016, 9}, { 0x0005, 10},
1470 { 0x000E, 6}, { 0x0004, 10}, { 0x0011, 7}, { 0x0024, 11}, { 0x0010, 7}, { 0x0025, 11},
1471 { 0x0013, 7}, { 0x005A, 12}, { 0x0015, 8}, { 0x005B, 12}, { 0x0014, 8}, { 0x0013, 8},
1472 { 0x001A, 8}, { 0x0015, 9}, { 0x0014, 9}, { 0x0013, 9}, { 0x0012, 9}, { 0x0011, 9},
1473 { 0x0026, 11}, { 0x0027, 11}, { 0x005C, 12}, { 0x005D, 12}, { 0x005E, 12}, { 0x005F, 12},
1474 { 0x0003, 7}
1475 },
1476 {
1477 { 0x0002, 2}, { 0x000F, 4}, { 0x0015, 6}, { 0x0017, 7}, { 0x001F, 8}, { 0x0025, 9},
1478 { 0x0024, 9}, { 0x0021, 10}, { 0x0020, 10}, { 0x0007, 11}, { 0x0006, 11}, { 0x0020, 11},
1479 { 0x0006, 3}, { 0x0014, 6}, { 0x001E, 8}, { 0x000F, 10}, { 0x0021, 11}, { 0x0050, 12},
1480 { 0x000E, 4}, { 0x001D, 8}, { 0x000E, 10}, { 0x0051, 12}, { 0x000D, 5}, { 0x0023, 9},
1481 { 0x000D, 10}, { 0x000C, 5}, { 0x0022, 9}, { 0x0052, 12}, { 0x000B, 5}, { 0x000C, 10},
1482 { 0x0053, 12}, { 0x0013, 6}, { 0x000B, 10}, { 0x0054, 12}, { 0x0012, 6}, { 0x000A, 10},
1483 { 0x0011, 6}, { 0x0009, 10}, { 0x0010, 6}, { 0x0008, 10}, { 0x0016, 7}, { 0x0055, 12},
1484 { 0x0015, 7}, { 0x0014, 7}, { 0x001C, 8}, { 0x001B, 8}, { 0x0021, 9}, { 0x0020, 9},
1485 { 0x001F, 9}, { 0x001E, 9}, { 0x001D, 9}, { 0x001C, 9}, { 0x001B, 9}, { 0x001A, 9},
1486 { 0x0022, 11}, { 0x0023, 11}, { 0x0056, 12}, { 0x0057, 12}, { 0x0007, 4}, { 0x0019, 9},
1487 { 0x0005, 11}, { 0x000F, 6}, { 0x0004, 11}, { 0x000E, 6}, { 0x000D, 6}, { 0x000C, 6},
1488 { 0x0013, 7}, { 0x0012, 7}, { 0x0011, 7}, { 0x0010, 7}, { 0x001A, 8}, { 0x0019, 8},
1489 { 0x0018, 8}, { 0x0017, 8}, { 0x0016, 8}, { 0x0015, 8}, { 0x0014, 8}, { 0x0013, 8},
1490 { 0x0018, 9}, { 0x0017, 9}, { 0x0016, 9}, { 0x0015, 9}, { 0x0014, 9}, { 0x0013, 9},
1491 { 0x0012, 9}, { 0x0011, 9}, { 0x0007, 10}, { 0x0006, 10}, { 0x0005, 10}, { 0x0004, 10},
1492 { 0x0024, 11}, { 0x0025, 11}, { 0x0026, 11}, { 0x0027, 11}, { 0x0058, 12}, { 0x0059, 12},
1493 { 0x005A, 12}, { 0x005B, 12}, { 0x005C, 12}, { 0x005D, 12}, { 0x005E, 12}, { 0x005F, 12},
1494 { 0x0003, 7}
1495 },
1496 {
1497 { 0x0000, 2}, { 0x0003, 3}, { 0x000D, 4}, { 0x0005, 4}, { 0x001C, 5}, { 0x0016, 5},
1498 { 0x003F, 6}, { 0x003A, 6}, { 0x002E, 6}, { 0x0022, 6}, { 0x007B, 7}, { 0x0067, 7},
1499 { 0x005F, 7}, { 0x0047, 7}, { 0x0026, 7}, { 0x00EF, 8}, { 0x00CD, 8}, { 0x00C1, 8},
1500 { 0x00A9, 8}, { 0x004F, 8}, { 0x01F2, 9}, { 0x01DD, 9}, { 0x0199, 9}, { 0x0185, 9},
1501 { 0x015D, 9}, { 0x011B, 9}, { 0x03EF, 10}, { 0x03E1, 10}, { 0x03C8, 10}, { 0x0331, 10},
1502 { 0x0303, 10}, { 0x02F1, 10}, { 0x02A0, 10}, { 0x0233, 10}, { 0x0126, 10}, { 0x07C0, 11},
1503 { 0x076F, 11}, { 0x076C, 11}, { 0x0661, 11}, { 0x0604, 11}, { 0x0572, 11}, { 0x0551, 11},
1504 { 0x046A, 11}, { 0x0274, 11}, { 0x0F27, 12}, { 0x0F24, 12}, { 0x0EDB, 12}, { 0x0C8E, 12},
1505 { 0x0C0B, 12}, { 0x0C0A, 12}, { 0x0AE3, 12}, { 0x08D6, 12}, { 0x0490, 12}, { 0x0495, 12},
1506 { 0x1F19, 13}, { 0x1DB5, 13}, { 0x0009, 4}, { 0x0010, 5}, { 0x0029, 6}, { 0x0062, 7},
1507 { 0x00F3, 8}, { 0x00AD, 8}, { 0x01E5, 9}, { 0x0179, 9}, { 0x009C, 9}, { 0x03B1, 10},
1508 { 0x02AE, 10}, { 0x0127, 10}, { 0x076E, 11}, { 0x0570, 11}, { 0x0275, 11}, { 0x0F25, 12},
1509 { 0x0EC0, 12}, { 0x0AA0, 12}, { 0x08D7, 12}, { 0x1E4C, 13}, { 0x0008, 5}, { 0x0063, 7},
1510 { 0x00AF, 8}, { 0x017B, 9}, { 0x03B3, 10}, { 0x07DD, 11}, { 0x0640, 11}, { 0x0F8D, 12},
1511 { 0x0BC1, 12}, { 0x0491, 12}, { 0x0028, 6}, { 0x00C3, 8}, { 0x0151, 9}, { 0x02A1, 10},
1512 { 0x0573, 11}, { 0x0EC3, 12}, { 0x1F35, 13}, { 0x0065, 7}, { 0x01DA, 9}, { 0x02AF, 10},
1513 { 0x0277, 11}, { 0x08C9, 12}, { 0x1781, 13}, { 0x0025, 7}, { 0x0118, 9}, { 0x0646, 11},
1514 { 0x0AA6, 12}, { 0x1780, 13}, { 0x00C9, 8}, { 0x0321, 10}, { 0x0F9B, 12}, { 0x191E, 13},
1515 { 0x0048, 8}, { 0x07CC, 11}, { 0x0AA1, 12}, { 0x0180, 9}, { 0x0465, 11}, { 0x1905, 13},
1516 { 0x03E2, 10}, { 0x0EC1, 12}, { 0x3C9B, 14}, { 0x02F4, 10}, { 0x08C8, 12}, { 0x07C1, 11},
1517 { 0x0928, 13}, { 0x05E1, 11}, { 0x320D, 14}, { 0x0EC2, 12}, { 0x6418, 15}, { 0x1F34, 13},
1518 { 0x0078, 7}, { 0x0155, 9}, { 0x0552, 11}, { 0x191F, 13}, { 0x00FA, 8}, { 0x07DC, 11},
1519 { 0x1907, 13}, { 0x00AC, 8}, { 0x0249, 11}, { 0x13B1, 14}, { 0x01F6, 9}, { 0x0AE2, 12},
1520 { 0x01DC, 9}, { 0x04ED, 12}, { 0x0184, 9}, { 0x1904, 13}, { 0x0156, 9}, { 0x09D9, 13},
1521 { 0x03E7, 10}, { 0x0929, 13}, { 0x03B2, 10}, { 0x3B68, 14}, { 0x02F5, 10}, { 0x13B0, 14},
1522 { 0x0322, 10}, { 0x3B69, 14}, { 0x0234, 10}, { 0x7935, 15}, { 0x07C7, 11}, { 0xC833, 16},
1523 { 0x0660, 11}, { 0x7934, 15}, { 0x024B, 11}, { 0xC832, 16}, { 0x0AA7, 12}, { 0x1F18, 13},
1524 { 0x007A, 7}
1525 },
1526 {
1527 { 0x0002, 2}, { 0x0000, 3}, { 0x001E, 5}, { 0x0004, 5}, { 0x0012, 6}, { 0x0070, 7},
1528 { 0x001A, 7}, { 0x005F, 8}, { 0x0047, 8}, { 0x01D3, 9}, { 0x00B5, 9}, { 0x0057, 9},
1529 { 0x03B5, 10}, { 0x016D, 10}, { 0x0162, 10}, { 0x07CE, 11}, { 0x0719, 11}, { 0x0691, 11},
1530 { 0x02C6, 11}, { 0x0156, 11}, { 0x0F92, 12}, { 0x0D2E, 12}, { 0x0D20, 12}, { 0x059E, 12},
1531 { 0x0468, 12}, { 0x02A6, 12}, { 0x1DA2, 13}, { 0x1C60, 13}, { 0x1A43, 13}, { 0x0B1D, 13},
1532 { 0x08C0, 13}, { 0x055D, 13}, { 0x0003, 3}, { 0x000A, 5}, { 0x0077, 7}, { 0x00E5, 8},
1533 { 0x01D9, 9}, { 0x03E5, 10}, { 0x0166, 10}, { 0x0694, 11}, { 0x0152, 11}, { 0x059F, 12},
1534 { 0x1F3C, 13}, { 0x1A4B, 13}, { 0x055E, 13}, { 0x000C, 4}, { 0x007D, 7}, { 0x0044, 8},
1535 { 0x03E0, 10}, { 0x0769, 11}, { 0x0E31, 12}, { 0x1F26, 13}, { 0x055C, 13}, { 0x001B, 5},
1536 { 0x00E2, 8}, { 0x03A5, 10}, { 0x02C9, 11}, { 0x1F23, 13}, { 0x3B47, 14}, { 0x0007, 5},
1537 { 0x01D8, 9}, { 0x02D8, 11}, { 0x1F27, 13}, { 0x3494, 14}, { 0x0035, 6}, { 0x03E1, 10},
1538 { 0x059C, 12}, { 0x38C3, 14}, { 0x000C, 6}, { 0x0165, 10}, { 0x1D23, 13}, { 0x1638, 14},
1539 { 0x0068, 7}, { 0x0693, 11}, { 0x3A45, 14}, { 0x0020, 7}, { 0x0F90, 12}, { 0x7CF6, 15},
1540 { 0x00E8, 8}, { 0x058F, 12}, { 0x2CEF, 15}, { 0x0045, 8}, { 0x0B3A, 13}, { 0x01F1, 9},
1541 { 0x3B46, 14}, { 0x01A7, 9}, { 0x1676, 14}, { 0x0056, 9}, { 0x692A, 15}, { 0x038D, 10},
1542 { 0xE309, 16}, { 0x00AA, 10}, { 0x1C611, 17}, { 0x02DF, 11}, { 0xB3B9, 17}, { 0x02C8, 11},
1543 { 0x38C20, 18}, { 0x01B0, 11}, { 0x16390, 18}, { 0x0F9F, 12}, { 0x16771, 18}, { 0x0ED0, 12},
1544 { 0x71843, 19}, { 0x0D2A, 12}, { 0xF9E8C, 20}, { 0x0461, 12}, { 0xF9E8E, 20}, { 0x0B67, 13},
1545 { 0x055F, 13}, { 0x003F, 6}, { 0x006D, 9}, { 0x0E90, 12}, { 0x054E, 13}, { 0x0013, 6},
1546 { 0x0119, 10}, { 0x0B66, 13}, { 0x000B, 6}, { 0x0235, 11}, { 0x7CF5, 15}, { 0x0075, 7},
1547 { 0x0D24, 12}, { 0xF9E9, 16}, { 0x002E, 7}, { 0x1F22, 13}, { 0x0021, 7}, { 0x054F, 13},
1548 { 0x0014, 7}, { 0x3A44, 14}, { 0x00E4, 8}, { 0x7CF7, 15}, { 0x005E, 8}, { 0x7185, 15},
1549 { 0x0037, 8}, { 0x2C73, 15}, { 0x01DB, 9}, { 0x59DD, 16}, { 0x01C7, 9}, { 0x692B, 15},
1550 { 0x01A6, 9}, { 0x58E5, 16}, { 0x00B4, 9}, { 0x1F3D0, 17}, { 0x00B0, 9}, { 0xB1C9, 17},
1551 { 0x03E6, 10}, { 0x16770, 18}, { 0x016E, 10}, { 0x3E7A2, 18}, { 0x011B, 10}, { 0xF9E8D, 20},
1552 { 0x00D9, 10}, { 0xF9E8F, 20}, { 0x00A8, 10}, { 0x2C723, 19}, { 0x0749, 11}, { 0xE3084, 20},
1553 { 0x0696, 11}, { 0x58E45, 20}, { 0x02DE, 11}, { 0xB1C88, 21}, { 0x0231, 11}, { 0x1C610A, 21},
1554 { 0x01B1, 11}, { 0x71842D, 23}, { 0x0D2B, 12}, { 0x38C217, 22}, { 0x0D2F, 12}, { 0x163913, 22},
1555 { 0x05B2, 12}, { 0x163912, 22}, { 0x0469, 12}, { 0x71842C, 23}, { 0x1A42, 13}, { 0x08C1, 13},
1556 { 0x0073, 7}
1557 }
1558 };
1559 
1560 static const uint16_t vlc_offs[] = {
1561  0, 520, 552, 616, 1128, 1160, 1224, 1740, 1772, 1836, 1900, 2436,
1562  2986, 3050, 3610, 4154, 4218, 4746, 5326, 5390, 5902, 6554, 7658, 8342,
1563  9304, 9988, 10630, 11234, 12174, 13006, 13560, 14232, 14786, 15432, 16350, 17522,
1564  20372, 21818, 22330, 22394, 23166, 23678, 23742, 24820, 25332, 25396, 26460, 26980,
1565  27048, 27592, 27600, 27608, 27616, 27624, 28224, 28258, 28290, 28802, 28834, 28866,
1566  29378, 29412, 29444, 29960, 29994, 30026, 30538, 30572, 30604, 31120, 31154, 31186,
1567  31714, 31746, 31778, 32306, 32340, 32372
1568 };
1569 
1570 /**
1571  * Init VC-1 specific tables and VC1Context members
1572  * @param v The VC1Context to initialize
1573  * @return Status
1574  */
1576 {
1577  static int done = 0;
1578  int i = 0;
1579  static VLC_TYPE vlc_table[32372][2];
1580 
1581  v->hrd_rate = v->hrd_buffer = NULL;
1582 
1583  /* VLC tables */
1584  if (!done) {
1586  ff_vc1_bfraction_bits, 1, 1,
1589  ff_vc1_norm2_bits, 1, 1,
1592  ff_vc1_norm6_bits, 1, 1,
1593  ff_vc1_norm6_codes, 2, 2, 556);
1595  ff_vc1_imode_bits, 1, 1,
1597  for (i = 0; i < 3; i++) {
1598  ff_vc1_ttmb_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 0]];
1599  ff_vc1_ttmb_vlc[i].table_allocated = vlc_offs[i * 3 + 1] - vlc_offs[i * 3 + 0];
1601  ff_vc1_ttmb_bits[i], 1, 1,
1603  ff_vc1_ttblk_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 1]];
1604  ff_vc1_ttblk_vlc[i].table_allocated = vlc_offs[i * 3 + 2] - vlc_offs[i * 3 + 1];
1606  ff_vc1_ttblk_bits[i], 1, 1,
1608  ff_vc1_subblkpat_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 2]];
1609  ff_vc1_subblkpat_vlc[i].table_allocated = vlc_offs[i * 3 + 3] - vlc_offs[i * 3 + 2];
1611  ff_vc1_subblkpat_bits[i], 1, 1,
1613  }
1614  for (i = 0; i < 4; i++) {
1615  ff_vc1_4mv_block_pattern_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 9]];
1616  ff_vc1_4mv_block_pattern_vlc[i].table_allocated = vlc_offs[i * 3 + 10] - vlc_offs[i * 3 + 9];
1620  ff_vc1_cbpcy_p_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 10]];
1621  ff_vc1_cbpcy_p_vlc[i].table_allocated = vlc_offs[i * 3 + 11] - vlc_offs[i * 3 + 10];
1623  ff_vc1_cbpcy_p_bits[i], 1, 1,
1625  ff_vc1_mv_diff_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 11]];
1626  ff_vc1_mv_diff_vlc[i].table_allocated = vlc_offs[i * 3 + 12] - vlc_offs[i * 3 + 11];
1628  ff_vc1_mv_diff_bits[i], 1, 1,
1630  }
1631  for (i = 0; i < 8; i++) {
1632  ff_vc1_ac_coeff_table[i].table = &vlc_table[vlc_offs[i * 2 + 21]];
1633  ff_vc1_ac_coeff_table[i].table_allocated = vlc_offs[i * 2 + 22] - vlc_offs[i * 2 + 21];
1635  &vc1_ac_tables[i][0][1], 8, 4,
1636  &vc1_ac_tables[i][0][0], 8, 4, INIT_VLC_USE_NEW_STATIC);
1637  /* initialize interlaced MVDATA tables (2-Ref) */
1638  ff_vc1_2ref_mvdata_vlc[i].table = &vlc_table[vlc_offs[i * 2 + 22]];
1639  ff_vc1_2ref_mvdata_vlc[i].table_allocated = vlc_offs[i * 2 + 23] - vlc_offs[i * 2 + 22];
1641  ff_vc1_2ref_mvdata_bits[i], 1, 1,
1643  }
1644  for (i = 0; i < 4; i++) {
1645  /* initialize 4MV MBMODE VLC tables for interlaced frame P picture */
1646  ff_vc1_intfr_4mv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 37]];
1647  ff_vc1_intfr_4mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 38] - vlc_offs[i * 3 + 37];
1651  /* initialize NON-4MV MBMODE VLC tables for the same */
1652  ff_vc1_intfr_non4mv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 38]];
1653  ff_vc1_intfr_non4mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 39] - vlc_offs[i * 3 + 38];
1657  /* initialize interlaced MVDATA tables (1-Ref) */
1658  ff_vc1_1ref_mvdata_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 39]];
1659  ff_vc1_1ref_mvdata_vlc[i].table_allocated = vlc_offs[i * 3 + 40] - vlc_offs[i * 3 + 39];
1661  ff_vc1_1ref_mvdata_bits[i], 1, 1,
1663  }
1664  for (i = 0; i < 4; i++) {
1665  /* Initialize 2MV Block pattern VLC tables */
1666  ff_vc1_2mv_block_pattern_vlc[i].table = &vlc_table[vlc_offs[i + 49]];
1667  ff_vc1_2mv_block_pattern_vlc[i].table_allocated = vlc_offs[i + 50] - vlc_offs[i + 49];
1671  }
1672  for (i = 0; i < 8; i++) {
1673  /* Initialize interlaced CBPCY VLC tables (Table 124 - Table 131) */
1674  ff_vc1_icbpcy_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 53]];
1675  ff_vc1_icbpcy_vlc[i].table_allocated = vlc_offs[i * 3 + 54] - vlc_offs[i * 3 + 53];
1677  ff_vc1_icbpcy_p_bits[i], 1, 1,
1679  /* Initialize interlaced field picture MBMODE VLC tables */
1680  ff_vc1_if_mmv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 54]];
1681  ff_vc1_if_mmv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 55] - vlc_offs[i * 3 + 54];
1683  ff_vc1_if_mmv_mbmode_bits[i], 1, 1,
1685  ff_vc1_if_1mv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 55]];
1686  ff_vc1_if_1mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 56] - vlc_offs[i * 3 + 55];
1688  ff_vc1_if_1mv_mbmode_bits[i], 1, 1,
1690  }
1691  done = 1;
1692  }
1693 
1694  /* Other defaults */
1695  v->pq = -1;
1696  v->mvrange = 0; /* 7.1.1.18, p80 */
1697 
1698  ff_vc1dsp_init(&v->vc1dsp);
1699 
1700  return 0;
1701 }
int color_prim
8 bits, 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:378
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:1658
AVRational framerate
Definition: avcodec.h:3338
BI type.
Definition: avutil.h:272
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:38
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:185
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:39
const uint8_t ff_wmv2_scantableB[64]
Definition: wmv2data.c:30
const uint8_t ff_vc1_if_1mv_mbmode_codes[8][6]
Definition: vc1data.c:319
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:247
#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:210
#define INIT_VLC_STATIC(vlc, bits, a, b, c, d, e, f, g, static_size)
Definition: vlc.h:57
int max_b_frames
maximum number of B-frames between non-B-frames Note: The output will be delayed by max_b_frames+1 re...
Definition: avcodec.h:1935
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
8 bits, 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:2060
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
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:784
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:97
int frmrtq_postproc
3 bits,
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:230
Macro definitions for various function/variable attributes.
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
8 bits, 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:82
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:1575
void(* vc1_inv_trans_8x8)(int16_t *b)
Definition: vc1dsp.h:37
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:42
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
#define height
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:225
#define ff_dlog(a,...)
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:126
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:276
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 FFALIGN(x, a)
Definition: macros.h:48
#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:592
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:1560
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:74
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:41
#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
#define init_vlc(vlc, nb_bits, nb_codes,bits, bits_wrap, bits_size,codes, codes_wrap, codes_size,flags)
Definition: vlc.h:38
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:40
#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:399
GetBitContext gb
Definition: mpegvideo.h:445
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
const uint8_t ff_wmv2_scantableA[64]
Definition: wmv2data.c:23
uint8_t broken_link
Broken link flag (BROKEN_LINK syntax element)
Definition: vc1.h: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:44
#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:52
int ff_vc1_parse_frame_header_adv(VC1Context *v, GetBitContext *gb)
Definition: vc1.c:844
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:258
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
const int ff_vc1_fps_dr[2]
Definition: vc1data.c:88
int tfcntrflag
TFCNTR present.
Definition: vc1.h:202
#define width
int field_mode
1 for interlaced field pictures
Definition: vc1.h:352
int width
picture width / height.
Definition: avcodec.h:1836
#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:193
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:181
int fourmvswitch
Definition: vc1.h:336
void ff_simple_idct48_add(uint8_t *dest, int line_size, int16_t *block)
Definition: simple_idct.c:200
int ff_vc1_parse_frame_header(VC1Context *v, GetBitContext *gb)
Definition: vc1.c:627
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:535
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:1795
int intcomp
Definition: vc1.h:337
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:560
VLC ff_vc1_bfraction_vlc
Definition: vc1data.c:106
int table_allocated
Definition: vlc.h:29
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:402
int chromaformat
2 bits, 2=4:2:0, only defined
Definition: vc1.h:198
int res_sprite
Simple/Main Profile sequence header.
Definition: vc1.h:183
Libavcodec external API header.
const uint8_t ff_vc1_ttblk_codes[3][8]
Definition: vc1data.c:913
enum AVCodecID codec_id
Definition: avcodec.h:1666
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:615
main external API structure.
Definition: avcodec.h:1649
int height
picture size. must be a multiple of 16
Definition: mpegvideo.h:97
uint8_t range_mapy
Definition: vc1.h:330
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:299
static void skip_bits1(GetBitContext *s)
Definition: get_bits.h:324
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:292
rational number numerator/denominator
Definition: rational.h:43
struct AVFrame * f
Definition: mpegpicture.h:46
const uint16_t ff_vc1_intfr_4mv_mbmode_codes[4][15]
Definition: vc1data.c:267
#define VC1_2MV_BLOCK_PATTERN_VLC_BITS
Definition: vc1data.c:124
int aux_use_ic
Definition: vc1.h: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:570
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
2 bits, 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:112
int pict_type
AV_PICTURE_TYPE_I, AV_PICTURE_TYPE_P, AV_PICTURE_TYPE_B, ...
Definition: mpegvideo.h:209
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:95
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:127
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
#define INIT_VLC_USE_NEW_STATIC
Definition: vlc.h:55
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:268
void ff_simple_idct44_add(uint8_t *dest, int line_size, int16_t *block)
Definition: simple_idct.c:215
int res_fasttx
reserved, always 1
Definition: vc1.h:187
enum AVDiscard skip_loop_filter
Skip loop filtering for selected frames.
Definition: avcodec.h:3250
#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:509
#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:1339
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
static uint8_t tmp[8]
Definition: des.c:38
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:550
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
VLC ff_vc1_1ref_mvdata_vlc[4]
Definition: vc1data.c:139
int bitrtq_postproc
5 bits, quantized framerate-based postprocessing strength
Definition: vc1.h: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, 2 bits (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
#define VLC_TYPE
Definition: vlc.h:24
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:427
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:968
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:430
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:267
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:43
const uint16_t ff_vc1_mv_diff_codes[4][73]
Definition: vc1data.c:937
void ff_simple_idct_8(int16_t *block)
const int16_t ff_vc1_bfraction_lut[23]
Definition: vc1data.c:163
uint8_t altpq
Current/alternate frame quantizer scale.
Definition: vc1.h:238