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