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