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