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