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 static void rotate_luts(VC1Context *v)
604 {
605 #define ROTATE(DEF, L, N, C, A) do { \
606  if (v->s.pict_type == AV_PICTURE_TYPE_BI || v->s.pict_type == AV_PICTURE_TYPE_B) { \
607  C = A; \
608  } else { \
609  DEF; \
610  memcpy(&tmp, &L , sizeof(tmp)); \
611  memcpy(&L , &N , sizeof(tmp)); \
612  memcpy(&N , &tmp, sizeof(tmp)); \
613  C = N; \
614  } \
615  } while(0)
616 
617  ROTATE(int tmp, v->last_use_ic, v->next_use_ic, v->curr_use_ic, v->aux_use_ic);
618  ROTATE(uint8_t tmp[2][256], v->last_luty, v->next_luty, v->curr_luty, v->aux_luty);
619  ROTATE(uint8_t tmp[2][256], v->last_lutuv, v->next_lutuv, v->curr_lutuv, v->aux_lutuv);
620 
621  INIT_LUT(32, 0, v->curr_luty[0], v->curr_lutuv[0], 0);
622  INIT_LUT(32, 0, v->curr_luty[1], v->curr_lutuv[1], 0);
623  v->curr_use_ic = 0;
624  if (v->curr_luty == v->next_luty) {
625  // If we just initialized next_lut, clear next_use_ic to match.
626  v->next_use_ic = 0;
627  }
628 }
629 
630 int ff_vc1_parse_frame_header(VC1Context *v, GetBitContext* gb)
631 {
632  int pqindex, lowquant, status;
633 
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  v->bfraction_lut_index = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
662  v->bfraction = ff_vc1_bfraction_lut[v->bfraction_lut_index];
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  if (v->field_mode) {
883  v->fptype = get_bits(gb, 3);
884  v->s.pict_type = (v->fptype & 2) ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I;
885  if (v->fptype & 4) // B-picture
886  v->s.pict_type = (v->fptype & 2) ? AV_PICTURE_TYPE_BI : AV_PICTURE_TYPE_B;
887  } else {
888  switch (get_unary(gb, 0, 4)) {
889  case 0:
890  v->s.pict_type = AV_PICTURE_TYPE_P;
891  break;
892  case 1:
893  v->s.pict_type = AV_PICTURE_TYPE_B;
894  break;
895  case 2:
896  v->s.pict_type = AV_PICTURE_TYPE_I;
897  break;
898  case 3:
899  v->s.pict_type = AV_PICTURE_TYPE_BI;
900  break;
901  case 4:
902  v->s.pict_type = AV_PICTURE_TYPE_P; // skipped pic
903  v->p_frame_skipped = 1;
904  break;
905  }
906  }
907  if (v->tfcntrflag)
908  skip_bits(gb, 8);
909  if (v->broadcast) {
910  if (!v->interlace || v->psf) {
911  v->rptfrm = get_bits(gb, 2);
912  } else {
913  v->tff = get_bits1(gb);
914  v->rff = get_bits1(gb);
915  }
916  } else {
917  v->tff = 1;
918  }
919  if (v->panscanflag) {
920  avpriv_report_missing_feature(v->s.avctx, "Pan-scan");
921  //...
922  }
923  if (v->p_frame_skipped) {
924  return 0;
925  }
926  v->rnd = get_bits1(gb);
927  if (v->interlace)
928  v->uvsamp = get_bits1(gb);
929  if(!ff_vc1_bfraction_vlc.table)
930  return 0; //parsing only, vlc tables havnt been allocated
931  if (v->field_mode) {
932  if (!v->refdist_flag)
933  v->refdist = 0;
934  else if ((v->s.pict_type != AV_PICTURE_TYPE_B) && (v->s.pict_type != AV_PICTURE_TYPE_BI)) {
935  v->refdist = get_bits(gb, 2);
936  if (v->refdist == 3)
937  v->refdist += get_unary(gb, 0, 16);
938  }
939  if ((v->s.pict_type == AV_PICTURE_TYPE_B) || (v->s.pict_type == AV_PICTURE_TYPE_BI)) {
940  v->bfraction_lut_index = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
941  v->bfraction = ff_vc1_bfraction_lut[v->bfraction_lut_index];
942  v->frfd = (v->bfraction * v->refdist) >> 8;
943  v->brfd = v->refdist - v->frfd - 1;
944  if (v->brfd < 0)
945  v->brfd = 0;
946  }
947  goto parse_common_info;
948  }
949  if (v->fcm == PROGRESSIVE) {
950  if (v->finterpflag)
951  v->interpfrm = get_bits1(gb);
952  if (v->s.pict_type == AV_PICTURE_TYPE_B) {
953  v->bfraction_lut_index = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
954  v->bfraction = ff_vc1_bfraction_lut[v->bfraction_lut_index];
955  if (v->bfraction == 0) {
956  v->s.pict_type = AV_PICTURE_TYPE_BI; /* XXX: should not happen here */
957  }
958  }
959  }
960 
961  parse_common_info:
962  if (v->field_mode)
963  v->cur_field_type = !(v->tff ^ v->second_field);
964  pqindex = get_bits(gb, 5);
965  if (!pqindex)
966  return -1;
967  v->pqindex = pqindex;
968  if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
969  v->pq = ff_vc1_pquant_table[0][pqindex];
970  else
971  v->pq = ff_vc1_pquant_table[1][pqindex];
972 
973  v->pquantizer = 1;
974  if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
975  v->pquantizer = pqindex < 9;
976  if (v->quantizer_mode == QUANT_NON_UNIFORM)
977  v->pquantizer = 0;
978  v->pqindex = pqindex;
979  if (pqindex < 9)
980  v->halfpq = get_bits1(gb);
981  else
982  v->halfpq = 0;
983  if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
984  v->pquantizer = get_bits1(gb);
985  if (v->postprocflag)
986  v->postproc = get_bits(gb, 2);
987 
988  if (v->parse_only)
989  return 0;
990 
991  if (v->first_pic_header_flag)
992  rotate_luts(v);
993 
994  switch (v->s.pict_type) {
995  case AV_PICTURE_TYPE_I:
996  case AV_PICTURE_TYPE_BI:
997  if (v->fcm == ILACE_FRAME) { //interlace frame picture
998  status = bitplane_decoding(v->fieldtx_plane, &v->fieldtx_is_raw, v);
999  if (status < 0)
1000  return -1;
1001  av_log(v->s.avctx, AV_LOG_DEBUG, "FIELDTX plane encoding: "
1002  "Imode: %i, Invert: %i\n", status>>1, status&1);
1003  }
1004  status = bitplane_decoding(v->acpred_plane, &v->acpred_is_raw, v);
1005  if (status < 0)
1006  return -1;
1007  av_log(v->s.avctx, AV_LOG_DEBUG, "ACPRED plane encoding: "
1008  "Imode: %i, Invert: %i\n", status>>1, status&1);
1009  v->condover = CONDOVER_NONE;
1010  if (v->overlap && v->pq <= 8) {
1011  v->condover = decode012(gb);
1012  if (v->condover == CONDOVER_SELECT) {
1013  status = bitplane_decoding(v->over_flags_plane, &v->overflg_is_raw, v);
1014  if (status < 0)
1015  return -1;
1016  av_log(v->s.avctx, AV_LOG_DEBUG, "CONDOVER plane encoding: "
1017  "Imode: %i, Invert: %i\n", status>>1, status&1);
1018  }
1019  }
1020  break;
1021  case AV_PICTURE_TYPE_P:
1022  if (v->field_mode) {
1023  v->numref = get_bits1(gb);
1024  if (!v->numref) {
1025  v->reffield = get_bits1(gb);
1026  v->ref_field_type[0] = v->reffield ^ !v->cur_field_type;
1027  }
1028  }
1029  if (v->extended_mv)
1030  v->mvrange = get_unary(gb, 0, 3);
1031  else
1032  v->mvrange = 0;
1033  if (v->interlace) {
1034  if (v->extended_dmv)
1035  v->dmvrange = get_unary(gb, 0, 3);
1036  else
1037  v->dmvrange = 0;
1038  if (v->fcm == ILACE_FRAME) { // interlaced frame picture
1039  v->fourmvswitch = get_bits1(gb);
1040  v->intcomp = get_bits1(gb);
1041  if (v->intcomp) {
1042  v->lumscale = get_bits(gb, 6);
1043  v->lumshift = get_bits(gb, 6);
1044  INIT_LUT(v->lumscale, v->lumshift, v->last_luty[0], v->last_lutuv[0], 1);
1045  INIT_LUT(v->lumscale, v->lumshift, v->last_luty[1], v->last_lutuv[1], 1);
1046  v->last_use_ic = 1;
1047  }
1048  status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1049  av_log(v->s.avctx, AV_LOG_DEBUG, "SKIPMB plane encoding: "
1050  "Imode: %i, Invert: %i\n", status>>1, status&1);
1051  mbmodetab = get_bits(gb, 2);
1052  if (v->fourmvswitch)
1053  v->mbmode_vlc = &ff_vc1_intfr_4mv_mbmode_vlc[mbmodetab];
1054  else
1055  v->mbmode_vlc = &ff_vc1_intfr_non4mv_mbmode_vlc[mbmodetab];
1056  imvtab = get_bits(gb, 2);
1057  v->imv_vlc = &ff_vc1_1ref_mvdata_vlc[imvtab];
1058  // interlaced p-picture cbpcy range is [1, 63]
1059  icbptab = get_bits(gb, 3);
1060  v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
1061  twomvbptab = get_bits(gb, 2);
1062  v->twomvbp_vlc = &ff_vc1_2mv_block_pattern_vlc[twomvbptab];
1063  if (v->fourmvswitch) {
1064  fourmvbptab = get_bits(gb, 2);
1065  v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
1066  }
1067  }
1068  }
1069  v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1070  v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
1071  v->range_x = 1 << (v->k_x - 1);
1072  v->range_y = 1 << (v->k_y - 1);
1073 
1074  if (v->pq < 5)
1075  v->tt_index = 0;
1076  else if (v->pq < 13)
1077  v->tt_index = 1;
1078  else
1079  v->tt_index = 2;
1080  if (v->fcm != ILACE_FRAME) {
1081  int mvmode;
1082  mvmode = get_unary(gb, 1, 4);
1083  lowquant = (v->pq > 12) ? 0 : 1;
1084  v->mv_mode = ff_vc1_mv_pmode_table[lowquant][mvmode];
1085  if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
1086  int mvmode2;
1087  mvmode2 = get_unary(gb, 1, 3);
1088  v->mv_mode2 = ff_vc1_mv_pmode_table2[lowquant][mvmode2];
1089  if (v->field_mode) {
1090  v->intcompfield = decode210(gb) ^ 3;
1091  } else
1092  v->intcompfield = 3;
1093 
1094  v->lumscale2 = v->lumscale = 32;
1095  v->lumshift2 = v->lumshift = 0;
1096  if (v->intcompfield & 1) {
1097  v->lumscale = get_bits(gb, 6);
1098  v->lumshift = get_bits(gb, 6);
1099  }
1100  if ((v->intcompfield & 2) && v->field_mode) {
1101  v->lumscale2 = get_bits(gb, 6);
1102  v->lumshift2 = get_bits(gb, 6);
1103  } else if(!v->field_mode) {
1104  v->lumscale2 = v->lumscale;
1105  v->lumshift2 = v->lumshift;
1106  }
1107  if (v->field_mode && v->second_field) {
1108  if (v->cur_field_type) {
1109  INIT_LUT(v->lumscale , v->lumshift , v->curr_luty[v->cur_field_type^1], v->curr_lutuv[v->cur_field_type^1], 0);
1110  INIT_LUT(v->lumscale2, v->lumshift2, v->last_luty[v->cur_field_type ], v->last_lutuv[v->cur_field_type ], 1);
1111  } else {
1112  INIT_LUT(v->lumscale2, v->lumshift2, v->curr_luty[v->cur_field_type^1], v->curr_lutuv[v->cur_field_type^1], 0);
1113  INIT_LUT(v->lumscale , v->lumshift , v->last_luty[v->cur_field_type ], v->last_lutuv[v->cur_field_type ], 1);
1114  }
1115  v->next_use_ic = v->curr_use_ic = 1;
1116  } else {
1117  INIT_LUT(v->lumscale , v->lumshift , v->last_luty[0], v->last_lutuv[0], 1);
1118  INIT_LUT(v->lumscale2, v->lumshift2, v->last_luty[1], v->last_lutuv[1], 1);
1119  }
1120  v->last_use_ic = 1;
1121  }
1122  v->qs_last = v->s.quarter_sample;
1123  if (v->mv_mode == MV_PMODE_1MV_HPEL || v->mv_mode == MV_PMODE_1MV_HPEL_BILIN)
1124  v->s.quarter_sample = 0;
1125  else if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
1126  if (v->mv_mode2 == MV_PMODE_1MV_HPEL || v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN)
1127  v->s.quarter_sample = 0;
1128  else
1129  v->s.quarter_sample = 1;
1130  } else
1131  v->s.quarter_sample = 1;
1132  v->s.mspel = !(v->mv_mode == MV_PMODE_1MV_HPEL_BILIN
1133  || (v->mv_mode == MV_PMODE_INTENSITY_COMP
1134  && v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN));
1135  }
1136  if (v->fcm == PROGRESSIVE) { // progressive
1137  if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
1138  v->mv_mode2 == MV_PMODE_MIXED_MV)
1139  || v->mv_mode == MV_PMODE_MIXED_MV) {
1140  status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);
1141  if (status < 0)
1142  return -1;
1143  av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
1144  "Imode: %i, Invert: %i\n", status>>1, status&1);
1145  } else {
1146  v->mv_type_is_raw = 0;
1147  memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
1148  }
1149  status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1150  if (status < 0)
1151  return -1;
1152  av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1153  "Imode: %i, Invert: %i\n", status>>1, status&1);
1154 
1155  /* Hopefully this is correct for P frames */
1156  v->s.mv_table_index = get_bits(gb, 2); //but using ff_vc1_ tables
1157  v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
1158  } else if (v->fcm == ILACE_FRAME) { // frame interlaced
1159  v->qs_last = v->s.quarter_sample;
1160  v->s.quarter_sample = 1;
1161  v->s.mspel = 1;
1162  } else { // field interlaced
1163  mbmodetab = get_bits(gb, 3);
1164  imvtab = get_bits(gb, 2 + v->numref);
1165  if (!v->numref)
1166  v->imv_vlc = &ff_vc1_1ref_mvdata_vlc[imvtab];
1167  else
1168  v->imv_vlc = &ff_vc1_2ref_mvdata_vlc[imvtab];
1169  icbptab = get_bits(gb, 3);
1170  v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
1171  if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
1172  v->mv_mode2 == MV_PMODE_MIXED_MV) || v->mv_mode == MV_PMODE_MIXED_MV) {
1173  fourmvbptab = get_bits(gb, 2);
1174  v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
1175  v->mbmode_vlc = &ff_vc1_if_mmv_mbmode_vlc[mbmodetab];
1176  } else {
1177  v->mbmode_vlc = &ff_vc1_if_1mv_mbmode_vlc[mbmodetab];
1178  }
1179  }
1180  if (v->dquant) {
1181  av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1182  vop_dquant_decoding(v);
1183  }
1184 
1185  v->ttfrm = 0; //FIXME Is that so ?
1186  if (v->vstransform) {
1187  v->ttmbf = get_bits1(gb);
1188  if (v->ttmbf) {
1189  v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
1190  }
1191  } else {
1192  v->ttmbf = 1;
1193  v->ttfrm = TT_8X8;
1194  }
1195  break;
1196  case AV_PICTURE_TYPE_B:
1197  if (v->fcm == ILACE_FRAME) {
1198  v->bfraction_lut_index = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
1199  v->bfraction = ff_vc1_bfraction_lut[v->bfraction_lut_index];
1200  if (v->bfraction == 0) {
1201  return -1;
1202  }
1203  }
1204  if (v->extended_mv)
1205  v->mvrange = get_unary(gb, 0, 3);
1206  else
1207  v->mvrange = 0;
1208  v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1209  v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
1210  v->range_x = 1 << (v->k_x - 1);
1211  v->range_y = 1 << (v->k_y - 1);
1212 
1213  if (v->pq < 5)
1214  v->tt_index = 0;
1215  else if (v->pq < 13)
1216  v->tt_index = 1;
1217  else
1218  v->tt_index = 2;
1219 
1220  if (v->field_mode) {
1221  int mvmode;
1222  av_log(v->s.avctx, AV_LOG_DEBUG, "B Fields\n");
1223  if (v->extended_dmv)
1224  v->dmvrange = get_unary(gb, 0, 3);
1225  mvmode = get_unary(gb, 1, 3);
1226  lowquant = (v->pq > 12) ? 0 : 1;
1227  v->mv_mode = ff_vc1_mv_pmode_table2[lowquant][mvmode];
1228  v->qs_last = v->s.quarter_sample;
1229  v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV || v->mv_mode == MV_PMODE_MIXED_MV);
1230  v->s.mspel = !(v->mv_mode == MV_PMODE_1MV_HPEL_BILIN || v->mv_mode == MV_PMODE_1MV_HPEL);
1231  status = bitplane_decoding(v->forward_mb_plane, &v->fmb_is_raw, v);
1232  if (status < 0)
1233  return -1;
1234  av_log(v->s.avctx, AV_LOG_DEBUG, "MB Forward Type plane encoding: "
1235  "Imode: %i, Invert: %i\n", status>>1, status&1);
1236  mbmodetab = get_bits(gb, 3);
1237  if (v->mv_mode == MV_PMODE_MIXED_MV)
1238  v->mbmode_vlc = &ff_vc1_if_mmv_mbmode_vlc[mbmodetab];
1239  else
1240  v->mbmode_vlc = &ff_vc1_if_1mv_mbmode_vlc[mbmodetab];
1241  imvtab = get_bits(gb, 3);
1242  v->imv_vlc = &ff_vc1_2ref_mvdata_vlc[imvtab];
1243  icbptab = get_bits(gb, 3);
1244  v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
1245  if (v->mv_mode == MV_PMODE_MIXED_MV) {
1246  fourmvbptab = get_bits(gb, 2);
1247  v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
1248  }
1249  v->numref = 1; // interlaced field B pictures are always 2-ref
1250  } else if (v->fcm == ILACE_FRAME) {
1251  if (v->extended_dmv)
1252  v->dmvrange = get_unary(gb, 0, 3);
1253  if (get_bits1(gb)) /* intcomp - present but shall always be 0 */
1254  av_log(v->s.avctx, AV_LOG_WARNING, "Intensity compensation set for B picture\n");
1255  v->intcomp = 0;
1256  v->mv_mode = MV_PMODE_1MV;
1257  v->fourmvswitch = 0;
1258  v->qs_last = v->s.quarter_sample;
1259  v->s.quarter_sample = 1;
1260  v->s.mspel = 1;
1261  status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
1262  if (status < 0)
1263  return -1;
1264  av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
1265  "Imode: %i, Invert: %i\n", status>>1, status&1);
1266  status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1267  if (status < 0)
1268  return -1;
1269  av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1270  "Imode: %i, Invert: %i\n", status>>1, status&1);
1271  mbmodetab = get_bits(gb, 2);
1272  v->mbmode_vlc = &ff_vc1_intfr_non4mv_mbmode_vlc[mbmodetab];
1273  imvtab = get_bits(gb, 2);
1274  v->imv_vlc = &ff_vc1_1ref_mvdata_vlc[imvtab];
1275  // interlaced p/b-picture cbpcy range is [1, 63]
1276  icbptab = get_bits(gb, 3);
1277  v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
1278  twomvbptab = get_bits(gb, 2);
1279  v->twomvbp_vlc = &ff_vc1_2mv_block_pattern_vlc[twomvbptab];
1280  fourmvbptab = get_bits(gb, 2);
1281  v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
1282  } else {
1283  v->mv_mode = get_bits1(gb) ? MV_PMODE_1MV : MV_PMODE_1MV_HPEL_BILIN;
1284  v->qs_last = v->s.quarter_sample;
1285  v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
1286  v->s.mspel = v->s.quarter_sample;
1287  status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
1288  if (status < 0)
1289  return -1;
1290  av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
1291  "Imode: %i, Invert: %i\n", status>>1, status&1);
1292  status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1293  if (status < 0)
1294  return -1;
1295  av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1296  "Imode: %i, Invert: %i\n", status>>1, status&1);
1297  v->s.mv_table_index = get_bits(gb, 2);
1298  v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
1299  }
1300 
1301  if (v->dquant) {
1302  av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1303  vop_dquant_decoding(v);
1304  }
1305 
1306  v->ttfrm = 0;
1307  if (v->vstransform) {
1308  v->ttmbf = get_bits1(gb);
1309  if (v->ttmbf) {
1310  v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
1311  }
1312  } else {
1313  v->ttmbf = 1;
1314  v->ttfrm = TT_8X8;
1315  }
1316  break;
1317  }
1318 
1319  if (v->fcm != PROGRESSIVE && !v->s.quarter_sample) {
1320  v->range_x <<= 1;
1321  v->range_y <<= 1;
1322  }
1323 
1324  /* AC Syntax */
1325  v->c_ac_table_index = decode012(gb);
1326  if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI) {
1327  v->y_ac_table_index = decode012(gb);
1328  }
1329  /* DC Syntax */
1330  v->s.dc_table_index = get_bits1(gb);
1331  if ((v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)
1332  && v->dquant) {
1333  av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1334  vop_dquant_decoding(v);
1335  }
1336 
1337  v->bi_type = 0;
1338  if (v->s.pict_type == AV_PICTURE_TYPE_BI) {
1339  v->s.pict_type = AV_PICTURE_TYPE_B;
1340  v->bi_type = 1;
1341  }
1342  return 0;
1343 }
1344 
1345 static const uint32_t vc1_ac_tables[AC_MODES][186][2] = {
1346 {
1347 { 0x0001, 2}, { 0x0005, 3}, { 0x000D, 4}, { 0x0012, 5}, { 0x000E, 6}, { 0x0015, 7},
1348 { 0x0013, 8}, { 0x003F, 8}, { 0x004B, 9}, { 0x011F, 9}, { 0x00B8, 10}, { 0x03E3, 10},
1349 { 0x0172, 11}, { 0x024D, 12}, { 0x03DA, 12}, { 0x02DD, 13}, { 0x1F55, 13}, { 0x05B9, 14},
1350 { 0x3EAE, 14}, { 0x0000, 4}, { 0x0010, 5}, { 0x0008, 7}, { 0x0020, 8}, { 0x0029, 9},
1351 { 0x01F4, 9}, { 0x0233, 10}, { 0x01E0, 11}, { 0x012A, 12}, { 0x03DD, 12}, { 0x050A, 13},
1352 { 0x1F29, 13}, { 0x0A42, 14}, { 0x1272, 15}, { 0x1737, 15}, { 0x0003, 5}, { 0x0011, 7},
1353 { 0x00C4, 8}, { 0x004B, 10}, { 0x00B4, 11}, { 0x07D4, 11}, { 0x0345, 12}, { 0x02D7, 13},
1354 { 0x07BF, 13}, { 0x0938, 14}, { 0x0BBB, 14}, { 0x095E, 15}, { 0x0013, 5}, { 0x0078, 7},
1355 { 0x0069, 9}, { 0x0232, 10}, { 0x0461, 11}, { 0x03EC, 12}, { 0x0520, 13}, { 0x1F2A, 13},
1356 { 0x3E50, 14}, { 0x3E51, 14}, { 0x1486, 15}, { 0x000C, 6}, { 0x0024, 9}, { 0x0094, 11},
1357 { 0x08C0, 12}, { 0x0F09, 14}, { 0x1EF0, 15}, { 0x003D, 6}, { 0x0053, 9}, { 0x01A0, 11},
1358 { 0x02D6, 13}, { 0x0F08, 14}, { 0x0013, 7}, { 0x007C, 9}, { 0x07C1, 11}, { 0x04AC, 14},
1359 { 0x001B, 7}, { 0x00A0, 10}, { 0x0344, 12}, { 0x0F79, 14}, { 0x0079, 7}, { 0x03E1, 10},
1360 { 0x02D4, 13}, { 0x2306, 14}, { 0x0021, 8}, { 0x023C, 10}, { 0x0FAE, 12}, { 0x23DE, 14},
1361 { 0x0035, 8}, { 0x0175, 11}, { 0x07B3, 13}, { 0x00C5, 8}, { 0x0174, 11}, { 0x0785, 13},
1362 { 0x0048, 9}, { 0x01A3, 11}, { 0x049E, 13}, { 0x002C, 9}, { 0x00FA, 10}, { 0x07D6, 11},
1363 { 0x0092, 10}, { 0x05CC, 13}, { 0x1EF1, 15}, { 0x00A3, 10}, { 0x03ED, 12}, { 0x093E, 14},
1364 { 0x01E2, 11}, { 0x1273, 15}, { 0x07C4, 11}, { 0x1487, 15}, { 0x0291, 12}, { 0x0293, 12},
1365 { 0x0F8A, 12}, { 0x0509, 13}, { 0x0508, 13}, { 0x078D, 13}, { 0x07BE, 13}, { 0x078C, 13},
1366 { 0x04AE, 14}, { 0x0BBA, 14}, { 0x2307, 14}, { 0x0B9A, 14}, { 0x1736, 15}, { 0x000E, 4},
1367 { 0x0045, 7}, { 0x01F3, 9}, { 0x047A, 11}, { 0x05DC, 13}, { 0x23DF, 14}, { 0x0019, 5},
1368 { 0x0028, 9}, { 0x0176, 11}, { 0x049D, 13}, { 0x23DD, 14}, { 0x0030, 6}, { 0x00A2, 10},
1369 { 0x02EF, 12}, { 0x05B8, 14}, { 0x003F, 6}, { 0x00A5, 10}, { 0x03DB, 12}, { 0x093F, 14},
1370 { 0x0044, 7}, { 0x07CB, 11}, { 0x095F, 15}, { 0x0063, 7}, { 0x03C3, 12}, { 0x0015, 8},
1371 { 0x08F6, 12}, { 0x0017, 8}, { 0x0498, 13}, { 0x002C, 8}, { 0x07B2, 13}, { 0x002F, 8},
1372 { 0x1F54, 13}, { 0x008D, 8}, { 0x07BD, 13}, { 0x008E, 8}, { 0x1182, 13}, { 0x00FB, 8},
1373 { 0x050B, 13}, { 0x002D, 8}, { 0x07C0, 11}, { 0x0079, 9}, { 0x1F5F, 13}, { 0x007A, 9},
1374 { 0x1F56, 13}, { 0x0231, 10}, { 0x03E4, 10}, { 0x01A1, 11}, { 0x0143, 11}, { 0x01F7, 11},
1375 { 0x016F, 12}, { 0x0292, 12}, { 0x02E7, 12}, { 0x016C, 12}, { 0x016D, 12}, { 0x03DC, 12},
1376 { 0x0F8B, 12}, { 0x0499, 13}, { 0x03D8, 12}, { 0x078E, 13}, { 0x02D5, 13}, { 0x1F5E, 13},
1377 { 0x1F2B, 13}, { 0x078F, 13}, { 0x04AD, 14}, { 0x3EAF, 14}, { 0x23DC, 14}, { 0x004A, 9}
1378 },
1379 {
1380 { 0x0000, 3}, { 0x0003, 4}, { 0x000B, 5}, { 0x0014, 6}, { 0x003F, 6}, { 0x005D, 7},
1381 { 0x00A2, 8}, { 0x00AC, 9}, { 0x016E, 9}, { 0x020A, 10}, { 0x02E2, 10}, { 0x0432, 11},
1382 { 0x05C9, 11}, { 0x0827, 12}, { 0x0B54, 12}, { 0x04E6, 13}, { 0x105F, 13}, { 0x172A, 13},
1383 { 0x20B2, 14}, { 0x2D4E, 14}, { 0x39F0, 14}, { 0x4175, 15}, { 0x5A9E, 15}, { 0x0004, 4},
1384 { 0x001E, 5}, { 0x0042, 7}, { 0x00B6, 8}, { 0x0173, 9}, { 0x0395, 10}, { 0x072E, 11},
1385 { 0x0B94, 12}, { 0x16A4, 13}, { 0x20B3, 14}, { 0x2E45, 14}, { 0x0005, 5}, { 0x0040, 7},
1386 { 0x0049, 9}, { 0x028F, 10}, { 0x05CB, 11}, { 0x048A, 13}, { 0x09DD, 14}, { 0x73E2, 15},
1387 { 0x0018, 5}, { 0x0025, 8}, { 0x008A, 10}, { 0x051B, 11}, { 0x0E5F, 12}, { 0x09C9, 14},
1388 { 0x139C, 15}, { 0x0029, 6}, { 0x004F, 9}, { 0x0412, 11}, { 0x048D, 13}, { 0x2E41, 14},
1389 { 0x0038, 6}, { 0x010E, 9}, { 0x05A8, 11}, { 0x105C, 13}, { 0x39F2, 14}, { 0x0058, 7},
1390 { 0x021F, 10}, { 0x0E7E, 12}, { 0x39FF, 14}, { 0x0023, 8}, { 0x02E3, 10}, { 0x04E5, 13},
1391 { 0x2E40, 14}, { 0x00A1, 8}, { 0x05BE, 11}, { 0x09C8, 14}, { 0x0083, 8}, { 0x013A, 11},
1392 { 0x1721, 13}, { 0x0044, 9}, { 0x0276, 12}, { 0x39F6, 14}, { 0x008B, 10}, { 0x04EF, 13},
1393 { 0x5A9B, 15}, { 0x0208, 10}, { 0x1CFE, 13}, { 0x0399, 10}, { 0x1CB4, 13}, { 0x039E, 10},
1394 { 0x39F3, 14}, { 0x05AB, 11}, { 0x73E3, 15}, { 0x0737, 11}, { 0x5A9F, 15}, { 0x082D, 12},
1395 { 0x0E69, 12}, { 0x0E68, 12}, { 0x0433, 11}, { 0x0B7B, 12}, { 0x2DF8, 14}, { 0x2E56, 14},
1396 { 0x2E57, 14}, { 0x39F7, 14}, { 0x51A5, 15}, { 0x0003, 3}, { 0x002A, 6}, { 0x00E4, 8},
1397 { 0x028E, 10}, { 0x0735, 11}, { 0x1058, 13}, { 0x1CFA, 13}, { 0x2DF9, 14}, { 0x4174, 15},
1398 { 0x0009, 4}, { 0x0054, 8}, { 0x0398, 10}, { 0x048B, 13}, { 0x139D, 15}, { 0x000D, 4},
1399 { 0x00AD, 9}, { 0x0826, 12}, { 0x2D4C, 14}, { 0x0011, 5}, { 0x016B, 9}, { 0x0B7F, 12},
1400 { 0x51A4, 15}, { 0x0019, 5}, { 0x021B, 10}, { 0x16FD, 13}, { 0x001D, 5}, { 0x0394, 10},
1401 { 0x28D3, 14}, { 0x002B, 6}, { 0x05BC, 11}, { 0x5A9A, 15}, { 0x002F, 6}, { 0x0247, 12},
1402 { 0x0010, 7}, { 0x0A35, 12}, { 0x003E, 6}, { 0x0B7A, 12}, { 0x0059, 7}, { 0x105E, 13},
1403 { 0x0026, 8}, { 0x09CF, 14}, { 0x0055, 8}, { 0x1CB5, 13}, { 0x0057, 8}, { 0x0E5B, 12},
1404 { 0x00A0, 8}, { 0x1468, 13}, { 0x0170, 9}, { 0x0090, 10}, { 0x01CE, 9}, { 0x021A, 10},
1405 { 0x0218, 10}, { 0x0168, 9}, { 0x021E, 10}, { 0x0244, 12}, { 0x0736, 11}, { 0x0138, 11},
1406 { 0x0519, 11}, { 0x0E5E, 12}, { 0x072C, 11}, { 0x0B55, 12}, { 0x09DC, 14}, { 0x20BB, 14},
1407 { 0x048C, 13}, { 0x1723, 13}, { 0x2E44, 14}, { 0x16A5, 13}, { 0x0518, 11}, { 0x39FE, 14},
1408 { 0x0169, 9}
1409 },
1410 {
1411 { 0x0001, 2}, { 0x0006, 3}, { 0x000F, 4}, { 0x0016, 5}, { 0x0020, 6}, { 0x0018, 7},
1412 { 0x0008, 8}, { 0x009A, 8}, { 0x0056, 9}, { 0x013E, 9}, { 0x00F0, 10}, { 0x03A5, 10},
1413 { 0x0077, 11}, { 0x01EF, 11}, { 0x009A, 12}, { 0x005D, 13}, { 0x0001, 4}, { 0x0011, 5},
1414 { 0x0002, 7}, { 0x000B, 8}, { 0x0012, 9}, { 0x01D6, 9}, { 0x027E, 10}, { 0x0191, 11},
1415 { 0x00EA, 12}, { 0x03DC, 12}, { 0x013B, 13}, { 0x0004, 5}, { 0x0014, 7}, { 0x009E, 8},
1416 { 0x0009, 10}, { 0x01AC, 11}, { 0x01E2, 11}, { 0x03CA, 12}, { 0x005F, 13}, { 0x0017, 5},
1417 { 0x004E, 7}, { 0x005E, 9}, { 0x00F3, 10}, { 0x01AD, 11}, { 0x00EC, 12}, { 0x05F0, 13},
1418 { 0x000E, 6}, { 0x00E1, 8}, { 0x03A4, 10}, { 0x009C, 12}, { 0x013D, 13}, { 0x003B, 6},
1419 { 0x001C, 9}, { 0x0014, 11}, { 0x09BE, 12}, { 0x0006, 7}, { 0x007A, 9}, { 0x0190, 11},
1420 { 0x0137, 13}, { 0x001B, 7}, { 0x0008, 10}, { 0x075C, 11}, { 0x0071, 7}, { 0x00D7, 10},
1421 { 0x09BF, 12}, { 0x0007, 8}, { 0x00AF, 10}, { 0x04CC, 11}, { 0x0034, 8}, { 0x0265, 10},
1422 { 0x009F, 12}, { 0x00E0, 8}, { 0x0016, 11}, { 0x0327, 12}, { 0x0015, 9}, { 0x017D, 11},
1423 { 0x0EBB, 12}, { 0x0014, 9}, { 0x00F6, 10}, { 0x01E4, 11}, { 0x00CB, 10}, { 0x099D, 12},
1424 { 0x00CA, 10}, { 0x02FC, 12}, { 0x017F, 11}, { 0x04CD, 11}, { 0x02FD, 12}, { 0x04FE, 11},
1425 { 0x013A, 13}, { 0x000A, 4}, { 0x0042, 7}, { 0x01D3, 9}, { 0x04DD, 11}, { 0x0012, 5},
1426 { 0x00E8, 8}, { 0x004C, 11}, { 0x0136, 13}, { 0x0039, 6}, { 0x0264, 10}, { 0x0EBA, 12},
1427 { 0x0000, 7}, { 0x00AE, 10}, { 0x099C, 12}, { 0x001F, 7}, { 0x04DE, 11}, { 0x0043, 7},
1428 { 0x04DC, 11}, { 0x0003, 8}, { 0x03CB, 12}, { 0x0006, 8}, { 0x099E, 12}, { 0x002A, 8},
1429 { 0x05F1, 13}, { 0x000F, 8}, { 0x09FE, 12}, { 0x0033, 8}, { 0x09FF, 12}, { 0x0098, 8},
1430 { 0x099F, 12}, { 0x00EA, 8}, { 0x013C, 13}, { 0x002E, 8}, { 0x0192, 11}, { 0x0136, 9},
1431 { 0x006A, 9}, { 0x0015, 11}, { 0x03AF, 10}, { 0x01E3, 11}, { 0x0074, 11}, { 0x00EB, 12},
1432 { 0x02F9, 12}, { 0x005C, 13}, { 0x00ED, 12}, { 0x03DD, 12}, { 0x0326, 12}, { 0x005E, 13},
1433 { 0x0016, 7}
1434 },
1435 {
1436 { 0x0004, 3}, { 0x0014, 5}, { 0x0017, 7}, { 0x007F, 8}, { 0x0154, 9}, { 0x01F2, 10},
1437 { 0x00BF, 11}, { 0x0065, 12}, { 0x0AAA, 12}, { 0x0630, 13}, { 0x1597, 13}, { 0x03B7, 14},
1438 { 0x2B22, 14}, { 0x0BE6, 15}, { 0x000B, 4}, { 0x0037, 7}, { 0x0062, 9}, { 0x0007, 11},
1439 { 0x0166, 12}, { 0x00CE, 13}, { 0x1590, 13}, { 0x05F6, 14}, { 0x0BE7, 15}, { 0x0007, 5},
1440 { 0x006D, 8}, { 0x0003, 11}, { 0x031F, 12}, { 0x05F2, 14}, { 0x0002, 6}, { 0x0061, 9},
1441 { 0x0055, 12}, { 0x01DF, 14}, { 0x001A, 6}, { 0x001E, 10}, { 0x0AC9, 12}, { 0x2B23, 14},
1442 { 0x001E, 6}, { 0x001F, 10}, { 0x0AC3, 12}, { 0x2B2B, 14}, { 0x0006, 7}, { 0x0004, 11},
1443 { 0x02F8, 13}, { 0x0019, 7}, { 0x0006, 11}, { 0x063D, 13}, { 0x0057, 7}, { 0x0182, 11},
1444 { 0x2AA2, 14}, { 0x0004, 8}, { 0x0180, 11}, { 0x059C, 14}, { 0x007D, 8}, { 0x0164, 12},
1445 { 0x076D, 15}, { 0x0002, 9}, { 0x018D, 11}, { 0x1581, 13}, { 0x00AD, 8}, { 0x0060, 12},
1446 { 0x0C67, 14}, { 0x001C, 9}, { 0x00EE, 13}, { 0x0003, 9}, { 0x02CF, 13}, { 0x00D9, 9},
1447 { 0x1580, 13}, { 0x0002, 11}, { 0x0183, 11}, { 0x0057, 12}, { 0x0061, 12}, { 0x0031, 11},
1448 { 0x0066, 12}, { 0x0631, 13}, { 0x0632, 13}, { 0x00AC, 13}, { 0x031D, 12}, { 0x0076, 12},
1449 { 0x003A, 11}, { 0x0165, 12}, { 0x0C66, 14}, { 0x0003, 2}, { 0x0054, 7}, { 0x02AB, 10},
1450 { 0x0016, 13}, { 0x05F7, 14}, { 0x0005, 4}, { 0x00F8, 9}, { 0x0AA9, 12}, { 0x005F, 15},
1451 { 0x0004, 4}, { 0x001C, 10}, { 0x1550, 13}, { 0x0004, 5}, { 0x0077, 11}, { 0x076C, 15},
1452 { 0x000E, 5}, { 0x000A, 12}, { 0x000C, 5}, { 0x0562, 11}, { 0x0004, 6}, { 0x031C, 12},
1453 { 0x0006, 6}, { 0x00C8, 13}, { 0x000D, 6}, { 0x01DA, 13}, { 0x0007, 6}, { 0x00C9, 13},
1454 { 0x0001, 7}, { 0x002E, 14}, { 0x0014, 7}, { 0x1596, 13}, { 0x000A, 7}, { 0x0AC2, 12},
1455 { 0x0016, 7}, { 0x015B, 14}, { 0x0015, 7}, { 0x015A, 14}, { 0x000F, 8}, { 0x005E, 15},
1456 { 0x007E, 8}, { 0x00AB, 8}, { 0x002D, 9}, { 0x00D8, 9}, { 0x000B, 9}, { 0x0014, 10},
1457 { 0x02B3, 10}, { 0x01F3, 10}, { 0x003A, 10}, { 0x0000, 10}, { 0x0058, 10}, { 0x002E, 9},
1458 { 0x005E, 10}, { 0x0563, 11}, { 0x00EC, 12}, { 0x0054, 12}, { 0x0AC1, 12}, { 0x1556, 13},
1459 { 0x02FA, 13}, { 0x0181, 11}, { 0x1557, 13}, { 0x059D, 14}, { 0x2AA3, 14}, { 0x2B2A, 14},
1460 { 0x01DE, 14}, { 0x063C, 13}, { 0x00CF, 13}, { 0x1594, 13}, { 0x000D, 9}
1461 },
1462 {
1463 { 0x0002, 2}, { 0x0006, 3}, { 0x000F, 4}, { 0x000D, 5}, { 0x000C, 5}, { 0x0015, 6},
1464 { 0x0013, 6}, { 0x0012, 6}, { 0x0017, 7}, { 0x001F, 8}, { 0x001E, 8}, { 0x001D, 8},
1465 { 0x0025, 9}, { 0x0024, 9}, { 0x0023, 9}, { 0x0021, 9}, { 0x0021, 10}, { 0x0020, 10},
1466 { 0x000F, 10}, { 0x000E, 10}, { 0x0007, 11}, { 0x0006, 11}, { 0x0020, 11}, { 0x0021, 11},
1467 { 0x0050, 12}, { 0x0051, 12}, { 0x0052, 12}, { 0x000E, 4}, { 0x0014, 6}, { 0x0016, 7},
1468 { 0x001C, 8}, { 0x0020, 9}, { 0x001F, 9}, { 0x000D, 10}, { 0x0022, 11}, { 0x0053, 12},
1469 { 0x0055, 12}, { 0x000B, 5}, { 0x0015, 7}, { 0x001E, 9}, { 0x000C, 10}, { 0x0056, 12},
1470 { 0x0011, 6}, { 0x001B, 8}, { 0x001D, 9}, { 0x000B, 10}, { 0x0010, 6}, { 0x0022, 9},
1471 { 0x000A, 10}, { 0x000D, 6}, { 0x001C, 9}, { 0x0008, 10}, { 0x0012, 7}, { 0x001B, 9},
1472 { 0x0054, 12}, { 0x0014, 7}, { 0x001A, 9}, { 0x0057, 12}, { 0x0019, 8}, { 0x0009, 10},
1473 { 0x0018, 8}, { 0x0023, 11}, { 0x0017, 8}, { 0x0019, 9}, { 0x0018, 9}, { 0x0007, 10},
1474 { 0x0058, 12}, { 0x0007, 4}, { 0x000C, 6}, { 0x0016, 8}, { 0x0017, 9}, { 0x0006, 10},
1475 { 0x0005, 11}, { 0x0004, 11}, { 0x0059, 12}, { 0x000F, 6}, { 0x0016, 9}, { 0x0005, 10},
1476 { 0x000E, 6}, { 0x0004, 10}, { 0x0011, 7}, { 0x0024, 11}, { 0x0010, 7}, { 0x0025, 11},
1477 { 0x0013, 7}, { 0x005A, 12}, { 0x0015, 8}, { 0x005B, 12}, { 0x0014, 8}, { 0x0013, 8},
1478 { 0x001A, 8}, { 0x0015, 9}, { 0x0014, 9}, { 0x0013, 9}, { 0x0012, 9}, { 0x0011, 9},
1479 { 0x0026, 11}, { 0x0027, 11}, { 0x005C, 12}, { 0x005D, 12}, { 0x005E, 12}, { 0x005F, 12},
1480 { 0x0003, 7}
1481 },
1482 {
1483 { 0x0002, 2}, { 0x000F, 4}, { 0x0015, 6}, { 0x0017, 7}, { 0x001F, 8}, { 0x0025, 9},
1484 { 0x0024, 9}, { 0x0021, 10}, { 0x0020, 10}, { 0x0007, 11}, { 0x0006, 11}, { 0x0020, 11},
1485 { 0x0006, 3}, { 0x0014, 6}, { 0x001E, 8}, { 0x000F, 10}, { 0x0021, 11}, { 0x0050, 12},
1486 { 0x000E, 4}, { 0x001D, 8}, { 0x000E, 10}, { 0x0051, 12}, { 0x000D, 5}, { 0x0023, 9},
1487 { 0x000D, 10}, { 0x000C, 5}, { 0x0022, 9}, { 0x0052, 12}, { 0x000B, 5}, { 0x000C, 10},
1488 { 0x0053, 12}, { 0x0013, 6}, { 0x000B, 10}, { 0x0054, 12}, { 0x0012, 6}, { 0x000A, 10},
1489 { 0x0011, 6}, { 0x0009, 10}, { 0x0010, 6}, { 0x0008, 10}, { 0x0016, 7}, { 0x0055, 12},
1490 { 0x0015, 7}, { 0x0014, 7}, { 0x001C, 8}, { 0x001B, 8}, { 0x0021, 9}, { 0x0020, 9},
1491 { 0x001F, 9}, { 0x001E, 9}, { 0x001D, 9}, { 0x001C, 9}, { 0x001B, 9}, { 0x001A, 9},
1492 { 0x0022, 11}, { 0x0023, 11}, { 0x0056, 12}, { 0x0057, 12}, { 0x0007, 4}, { 0x0019, 9},
1493 { 0x0005, 11}, { 0x000F, 6}, { 0x0004, 11}, { 0x000E, 6}, { 0x000D, 6}, { 0x000C, 6},
1494 { 0x0013, 7}, { 0x0012, 7}, { 0x0011, 7}, { 0x0010, 7}, { 0x001A, 8}, { 0x0019, 8},
1495 { 0x0018, 8}, { 0x0017, 8}, { 0x0016, 8}, { 0x0015, 8}, { 0x0014, 8}, { 0x0013, 8},
1496 { 0x0018, 9}, { 0x0017, 9}, { 0x0016, 9}, { 0x0015, 9}, { 0x0014, 9}, { 0x0013, 9},
1497 { 0x0012, 9}, { 0x0011, 9}, { 0x0007, 10}, { 0x0006, 10}, { 0x0005, 10}, { 0x0004, 10},
1498 { 0x0024, 11}, { 0x0025, 11}, { 0x0026, 11}, { 0x0027, 11}, { 0x0058, 12}, { 0x0059, 12},
1499 { 0x005A, 12}, { 0x005B, 12}, { 0x005C, 12}, { 0x005D, 12}, { 0x005E, 12}, { 0x005F, 12},
1500 { 0x0003, 7}
1501 },
1502 {
1503 { 0x0000, 2}, { 0x0003, 3}, { 0x000D, 4}, { 0x0005, 4}, { 0x001C, 5}, { 0x0016, 5},
1504 { 0x003F, 6}, { 0x003A, 6}, { 0x002E, 6}, { 0x0022, 6}, { 0x007B, 7}, { 0x0067, 7},
1505 { 0x005F, 7}, { 0x0047, 7}, { 0x0026, 7}, { 0x00EF, 8}, { 0x00CD, 8}, { 0x00C1, 8},
1506 { 0x00A9, 8}, { 0x004F, 8}, { 0x01F2, 9}, { 0x01DD, 9}, { 0x0199, 9}, { 0x0185, 9},
1507 { 0x015D, 9}, { 0x011B, 9}, { 0x03EF, 10}, { 0x03E1, 10}, { 0x03C8, 10}, { 0x0331, 10},
1508 { 0x0303, 10}, { 0x02F1, 10}, { 0x02A0, 10}, { 0x0233, 10}, { 0x0126, 10}, { 0x07C0, 11},
1509 { 0x076F, 11}, { 0x076C, 11}, { 0x0661, 11}, { 0x0604, 11}, { 0x0572, 11}, { 0x0551, 11},
1510 { 0x046A, 11}, { 0x0274, 11}, { 0x0F27, 12}, { 0x0F24, 12}, { 0x0EDB, 12}, { 0x0C8E, 12},
1511 { 0x0C0B, 12}, { 0x0C0A, 12}, { 0x0AE3, 12}, { 0x08D6, 12}, { 0x0490, 12}, { 0x0495, 12},
1512 { 0x1F19, 13}, { 0x1DB5, 13}, { 0x0009, 4}, { 0x0010, 5}, { 0x0029, 6}, { 0x0062, 7},
1513 { 0x00F3, 8}, { 0x00AD, 8}, { 0x01E5, 9}, { 0x0179, 9}, { 0x009C, 9}, { 0x03B1, 10},
1514 { 0x02AE, 10}, { 0x0127, 10}, { 0x076E, 11}, { 0x0570, 11}, { 0x0275, 11}, { 0x0F25, 12},
1515 { 0x0EC0, 12}, { 0x0AA0, 12}, { 0x08D7, 12}, { 0x1E4C, 13}, { 0x0008, 5}, { 0x0063, 7},
1516 { 0x00AF, 8}, { 0x017B, 9}, { 0x03B3, 10}, { 0x07DD, 11}, { 0x0640, 11}, { 0x0F8D, 12},
1517 { 0x0BC1, 12}, { 0x0491, 12}, { 0x0028, 6}, { 0x00C3, 8}, { 0x0151, 9}, { 0x02A1, 10},
1518 { 0x0573, 11}, { 0x0EC3, 12}, { 0x1F35, 13}, { 0x0065, 7}, { 0x01DA, 9}, { 0x02AF, 10},
1519 { 0x0277, 11}, { 0x08C9, 12}, { 0x1781, 13}, { 0x0025, 7}, { 0x0118, 9}, { 0x0646, 11},
1520 { 0x0AA6, 12}, { 0x1780, 13}, { 0x00C9, 8}, { 0x0321, 10}, { 0x0F9B, 12}, { 0x191E, 13},
1521 { 0x0048, 8}, { 0x07CC, 11}, { 0x0AA1, 12}, { 0x0180, 9}, { 0x0465, 11}, { 0x1905, 13},
1522 { 0x03E2, 10}, { 0x0EC1, 12}, { 0x3C9B, 14}, { 0x02F4, 10}, { 0x08C8, 12}, { 0x07C1, 11},
1523 { 0x0928, 13}, { 0x05E1, 11}, { 0x320D, 14}, { 0x0EC2, 12}, { 0x6418, 15}, { 0x1F34, 13},
1524 { 0x0078, 7}, { 0x0155, 9}, { 0x0552, 11}, { 0x191F, 13}, { 0x00FA, 8}, { 0x07DC, 11},
1525 { 0x1907, 13}, { 0x00AC, 8}, { 0x0249, 11}, { 0x13B1, 14}, { 0x01F6, 9}, { 0x0AE2, 12},
1526 { 0x01DC, 9}, { 0x04ED, 12}, { 0x0184, 9}, { 0x1904, 13}, { 0x0156, 9}, { 0x09D9, 13},
1527 { 0x03E7, 10}, { 0x0929, 13}, { 0x03B2, 10}, { 0x3B68, 14}, { 0x02F5, 10}, { 0x13B0, 14},
1528 { 0x0322, 10}, { 0x3B69, 14}, { 0x0234, 10}, { 0x7935, 15}, { 0x07C7, 11}, { 0xC833, 16},
1529 { 0x0660, 11}, { 0x7934, 15}, { 0x024B, 11}, { 0xC832, 16}, { 0x0AA7, 12}, { 0x1F18, 13},
1530 { 0x007A, 7}
1531 },
1532 {
1533 { 0x0002, 2}, { 0x0000, 3}, { 0x001E, 5}, { 0x0004, 5}, { 0x0012, 6}, { 0x0070, 7},
1534 { 0x001A, 7}, { 0x005F, 8}, { 0x0047, 8}, { 0x01D3, 9}, { 0x00B5, 9}, { 0x0057, 9},
1535 { 0x03B5, 10}, { 0x016D, 10}, { 0x0162, 10}, { 0x07CE, 11}, { 0x0719, 11}, { 0x0691, 11},
1536 { 0x02C6, 11}, { 0x0156, 11}, { 0x0F92, 12}, { 0x0D2E, 12}, { 0x0D20, 12}, { 0x059E, 12},
1537 { 0x0468, 12}, { 0x02A6, 12}, { 0x1DA2, 13}, { 0x1C60, 13}, { 0x1A43, 13}, { 0x0B1D, 13},
1538 { 0x08C0, 13}, { 0x055D, 13}, { 0x0003, 3}, { 0x000A, 5}, { 0x0077, 7}, { 0x00E5, 8},
1539 { 0x01D9, 9}, { 0x03E5, 10}, { 0x0166, 10}, { 0x0694, 11}, { 0x0152, 11}, { 0x059F, 12},
1540 { 0x1F3C, 13}, { 0x1A4B, 13}, { 0x055E, 13}, { 0x000C, 4}, { 0x007D, 7}, { 0x0044, 8},
1541 { 0x03E0, 10}, { 0x0769, 11}, { 0x0E31, 12}, { 0x1F26, 13}, { 0x055C, 13}, { 0x001B, 5},
1542 { 0x00E2, 8}, { 0x03A5, 10}, { 0x02C9, 11}, { 0x1F23, 13}, { 0x3B47, 14}, { 0x0007, 5},
1543 { 0x01D8, 9}, { 0x02D8, 11}, { 0x1F27, 13}, { 0x3494, 14}, { 0x0035, 6}, { 0x03E1, 10},
1544 { 0x059C, 12}, { 0x38C3, 14}, { 0x000C, 6}, { 0x0165, 10}, { 0x1D23, 13}, { 0x1638, 14},
1545 { 0x0068, 7}, { 0x0693, 11}, { 0x3A45, 14}, { 0x0020, 7}, { 0x0F90, 12}, { 0x7CF6, 15},
1546 { 0x00E8, 8}, { 0x058F, 12}, { 0x2CEF, 15}, { 0x0045, 8}, { 0x0B3A, 13}, { 0x01F1, 9},
1547 { 0x3B46, 14}, { 0x01A7, 9}, { 0x1676, 14}, { 0x0056, 9}, { 0x692A, 15}, { 0x038D, 10},
1548 { 0xE309, 16}, { 0x00AA, 10}, { 0x1C611, 17}, { 0x02DF, 11}, { 0xB3B9, 17}, { 0x02C8, 11},
1549 { 0x38C20, 18}, { 0x01B0, 11}, { 0x16390, 18}, { 0x0F9F, 12}, { 0x16771, 18}, { 0x0ED0, 12},
1550 { 0x71843, 19}, { 0x0D2A, 12}, { 0xF9E8C, 20}, { 0x0461, 12}, { 0xF9E8E, 20}, { 0x0B67, 13},
1551 { 0x055F, 13}, { 0x003F, 6}, { 0x006D, 9}, { 0x0E90, 12}, { 0x054E, 13}, { 0x0013, 6},
1552 { 0x0119, 10}, { 0x0B66, 13}, { 0x000B, 6}, { 0x0235, 11}, { 0x7CF5, 15}, { 0x0075, 7},
1553 { 0x0D24, 12}, { 0xF9E9, 16}, { 0x002E, 7}, { 0x1F22, 13}, { 0x0021, 7}, { 0x054F, 13},
1554 { 0x0014, 7}, { 0x3A44, 14}, { 0x00E4, 8}, { 0x7CF7, 15}, { 0x005E, 8}, { 0x7185, 15},
1555 { 0x0037, 8}, { 0x2C73, 15}, { 0x01DB, 9}, { 0x59DD, 16}, { 0x01C7, 9}, { 0x692B, 15},
1556 { 0x01A6, 9}, { 0x58E5, 16}, { 0x00B4, 9}, { 0x1F3D0, 17}, { 0x00B0, 9}, { 0xB1C9, 17},
1557 { 0x03E6, 10}, { 0x16770, 18}, { 0x016E, 10}, { 0x3E7A2, 18}, { 0x011B, 10}, { 0xF9E8D, 20},
1558 { 0x00D9, 10}, { 0xF9E8F, 20}, { 0x00A8, 10}, { 0x2C723, 19}, { 0x0749, 11}, { 0xE3084, 20},
1559 { 0x0696, 11}, { 0x58E45, 20}, { 0x02DE, 11}, { 0xB1C88, 21}, { 0x0231, 11}, { 0x1C610A, 21},
1560 { 0x01B1, 11}, { 0x71842D, 23}, { 0x0D2B, 12}, { 0x38C217, 22}, { 0x0D2F, 12}, { 0x163913, 22},
1561 { 0x05B2, 12}, { 0x163912, 22}, { 0x0469, 12}, { 0x71842C, 23}, { 0x1A42, 13}, { 0x08C1, 13},
1562 { 0x0073, 7}
1563 }
1564 };
1565 
1566 static const uint16_t vlc_offs[] = {
1567  0, 520, 552, 616, 1128, 1160, 1224, 1740, 1772, 1836, 1900, 2436,
1568  2986, 3050, 3610, 4154, 4218, 4746, 5326, 5390, 5902, 6554, 7658, 8342,
1569  9304, 9988, 10630, 11234, 12174, 13006, 13560, 14232, 14786, 15432, 16350, 17522,
1570  20372, 21818, 22330, 22394, 23166, 23678, 23742, 24820, 25332, 25396, 26460, 26980,
1571  27048, 27592, 27600, 27608, 27616, 27624, 28224, 28258, 28290, 28802, 28834, 28866,
1572  29378, 29412, 29444, 29960, 29994, 30026, 30538, 30572, 30604, 31120, 31154, 31186,
1573  31714, 31746, 31778, 32306, 32340, 32372
1574 };
1575 
1576 /**
1577  * Init VC-1 specific tables and VC1Context members
1578  * @param v The VC1Context to initialize
1579  * @return Status
1580  */
1581 av_cold int ff_vc1_init_common(VC1Context *v)
1582 {
1583  static int done = 0;
1584  int i = 0;
1585  static VLC_TYPE vlc_table[32372][2];
1586 
1587  v->hrd_rate = v->hrd_buffer = NULL;
1588 
1589  /* VLC tables */
1590  if (!done) {
1591  INIT_VLC_STATIC(&ff_vc1_bfraction_vlc, VC1_BFRACTION_VLC_BITS, 23,
1592  ff_vc1_bfraction_bits, 1, 1,
1593  ff_vc1_bfraction_codes, 1, 1, 1 << VC1_BFRACTION_VLC_BITS);
1594  INIT_VLC_STATIC(&ff_vc1_norm2_vlc, VC1_NORM2_VLC_BITS, 4,
1595  ff_vc1_norm2_bits, 1, 1,
1596  ff_vc1_norm2_codes, 1, 1, 1 << VC1_NORM2_VLC_BITS);
1597  INIT_VLC_STATIC(&ff_vc1_norm6_vlc, VC1_NORM6_VLC_BITS, 64,
1598  ff_vc1_norm6_bits, 1, 1,
1599  ff_vc1_norm6_codes, 2, 2, 556);
1600  INIT_VLC_STATIC(&ff_vc1_imode_vlc, VC1_IMODE_VLC_BITS, 7,
1601  ff_vc1_imode_bits, 1, 1,
1602  ff_vc1_imode_codes, 1, 1, 1 << VC1_IMODE_VLC_BITS);
1603  for (i = 0; i < 3; i++) {
1604  ff_vc1_ttmb_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 0]];
1605  ff_vc1_ttmb_vlc[i].table_allocated = vlc_offs[i * 3 + 1] - vlc_offs[i * 3 + 0];
1606  init_vlc(&ff_vc1_ttmb_vlc[i], VC1_TTMB_VLC_BITS, 16,
1607  ff_vc1_ttmb_bits[i], 1, 1,
1608  ff_vc1_ttmb_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1609  ff_vc1_ttblk_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 1]];
1610  ff_vc1_ttblk_vlc[i].table_allocated = vlc_offs[i * 3 + 2] - vlc_offs[i * 3 + 1];
1611  init_vlc(&ff_vc1_ttblk_vlc[i], VC1_TTBLK_VLC_BITS, 8,
1612  ff_vc1_ttblk_bits[i], 1, 1,
1613  ff_vc1_ttblk_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1614  ff_vc1_subblkpat_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 2]];
1615  ff_vc1_subblkpat_vlc[i].table_allocated = vlc_offs[i * 3 + 3] - vlc_offs[i * 3 + 2];
1616  init_vlc(&ff_vc1_subblkpat_vlc[i], VC1_SUBBLKPAT_VLC_BITS, 15,
1617  ff_vc1_subblkpat_bits[i], 1, 1,
1618  ff_vc1_subblkpat_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1619  }
1620  for (i = 0; i < 4; i++) {
1621  ff_vc1_4mv_block_pattern_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 9]];
1622  ff_vc1_4mv_block_pattern_vlc[i].table_allocated = vlc_offs[i * 3 + 10] - vlc_offs[i * 3 + 9];
1623  init_vlc(&ff_vc1_4mv_block_pattern_vlc[i], VC1_4MV_BLOCK_PATTERN_VLC_BITS, 16,
1624  ff_vc1_4mv_block_pattern_bits[i], 1, 1,
1625  ff_vc1_4mv_block_pattern_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1626  ff_vc1_cbpcy_p_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 10]];
1627  ff_vc1_cbpcy_p_vlc[i].table_allocated = vlc_offs[i * 3 + 11] - vlc_offs[i * 3 + 10];
1628  init_vlc(&ff_vc1_cbpcy_p_vlc[i], VC1_CBPCY_P_VLC_BITS, 64,
1629  ff_vc1_cbpcy_p_bits[i], 1, 1,
1630  ff_vc1_cbpcy_p_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1631  ff_vc1_mv_diff_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 11]];
1632  ff_vc1_mv_diff_vlc[i].table_allocated = vlc_offs[i * 3 + 12] - vlc_offs[i * 3 + 11];
1633  init_vlc(&ff_vc1_mv_diff_vlc[i], VC1_MV_DIFF_VLC_BITS, 73,
1634  ff_vc1_mv_diff_bits[i], 1, 1,
1635  ff_vc1_mv_diff_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1636  }
1637  for (i = 0; i < 8; i++) {
1638  ff_vc1_ac_coeff_table[i].table = &vlc_table[vlc_offs[i * 2 + 21]];
1639  ff_vc1_ac_coeff_table[i].table_allocated = vlc_offs[i * 2 + 22] - vlc_offs[i * 2 + 21];
1640  init_vlc(&ff_vc1_ac_coeff_table[i], AC_VLC_BITS, ff_vc1_ac_sizes[i],
1641  &vc1_ac_tables[i][0][1], 8, 4,
1642  &vc1_ac_tables[i][0][0], 8, 4, INIT_VLC_USE_NEW_STATIC);
1643  /* initialize interlaced MVDATA tables (2-Ref) */
1644  ff_vc1_2ref_mvdata_vlc[i].table = &vlc_table[vlc_offs[i * 2 + 22]];
1645  ff_vc1_2ref_mvdata_vlc[i].table_allocated = vlc_offs[i * 2 + 23] - vlc_offs[i * 2 + 22];
1646  init_vlc(&ff_vc1_2ref_mvdata_vlc[i], VC1_2REF_MVDATA_VLC_BITS, 126,
1647  ff_vc1_2ref_mvdata_bits[i], 1, 1,
1648  ff_vc1_2ref_mvdata_codes[i], 4, 4, INIT_VLC_USE_NEW_STATIC);
1649  }
1650  for (i = 0; i < 4; i++) {
1651  /* initialize 4MV MBMODE VLC tables for interlaced frame P picture */
1652  ff_vc1_intfr_4mv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 37]];
1653  ff_vc1_intfr_4mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 38] - vlc_offs[i * 3 + 37];
1654  init_vlc(&ff_vc1_intfr_4mv_mbmode_vlc[i], VC1_INTFR_4MV_MBMODE_VLC_BITS, 15,
1655  ff_vc1_intfr_4mv_mbmode_bits[i], 1, 1,
1656  ff_vc1_intfr_4mv_mbmode_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1657  /* initialize NON-4MV MBMODE VLC tables for the same */
1658  ff_vc1_intfr_non4mv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 38]];
1659  ff_vc1_intfr_non4mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 39] - vlc_offs[i * 3 + 38];
1660  init_vlc(&ff_vc1_intfr_non4mv_mbmode_vlc[i], VC1_INTFR_NON4MV_MBMODE_VLC_BITS, 9,
1661  ff_vc1_intfr_non4mv_mbmode_bits[i], 1, 1,
1662  ff_vc1_intfr_non4mv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1663  /* initialize interlaced MVDATA tables (1-Ref) */
1664  ff_vc1_1ref_mvdata_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 39]];
1665  ff_vc1_1ref_mvdata_vlc[i].table_allocated = vlc_offs[i * 3 + 40] - vlc_offs[i * 3 + 39];
1666  init_vlc(&ff_vc1_1ref_mvdata_vlc[i], VC1_1REF_MVDATA_VLC_BITS, 72,
1667  ff_vc1_1ref_mvdata_bits[i], 1, 1,
1668  ff_vc1_1ref_mvdata_codes[i], 4, 4, INIT_VLC_USE_NEW_STATIC);
1669  }
1670  for (i = 0; i < 4; i++) {
1671  /* Initialize 2MV Block pattern VLC tables */
1672  ff_vc1_2mv_block_pattern_vlc[i].table = &vlc_table[vlc_offs[i + 49]];
1673  ff_vc1_2mv_block_pattern_vlc[i].table_allocated = vlc_offs[i + 50] - vlc_offs[i + 49];
1674  init_vlc(&ff_vc1_2mv_block_pattern_vlc[i], VC1_2MV_BLOCK_PATTERN_VLC_BITS, 4,
1675  ff_vc1_2mv_block_pattern_bits[i], 1, 1,
1676  ff_vc1_2mv_block_pattern_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1677  }
1678  for (i = 0; i < 8; i++) {
1679  /* Initialize interlaced CBPCY VLC tables (Table 124 - Table 131) */
1680  ff_vc1_icbpcy_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 53]];
1681  ff_vc1_icbpcy_vlc[i].table_allocated = vlc_offs[i * 3 + 54] - vlc_offs[i * 3 + 53];
1682  init_vlc(&ff_vc1_icbpcy_vlc[i], VC1_ICBPCY_VLC_BITS, 63,
1683  ff_vc1_icbpcy_p_bits[i], 1, 1,
1684  ff_vc1_icbpcy_p_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1685  /* Initialize interlaced field picture MBMODE VLC tables */
1686  ff_vc1_if_mmv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 54]];
1687  ff_vc1_if_mmv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 55] - vlc_offs[i * 3 + 54];
1688  init_vlc(&ff_vc1_if_mmv_mbmode_vlc[i], VC1_IF_MMV_MBMODE_VLC_BITS, 8,
1689  ff_vc1_if_mmv_mbmode_bits[i], 1, 1,
1690  ff_vc1_if_mmv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1691  ff_vc1_if_1mv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 55]];
1692  ff_vc1_if_1mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 56] - vlc_offs[i * 3 + 55];
1693  init_vlc(&ff_vc1_if_1mv_mbmode_vlc[i], VC1_IF_1MV_MBMODE_VLC_BITS, 6,
1694  ff_vc1_if_1mv_mbmode_bits[i], 1, 1,
1695  ff_vc1_if_1mv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1696  }
1697  done = 1;
1698  }
1699 
1700  /* Other defaults */
1701  v->pq = -1;
1702  v->mvrange = 0; /* 7.1.1.18, p80 */
1703 
1704  return 0;
1705 }
Generated on Sat Jan 25 2014 19:51:56 for FFmpeg by   doxygen 1.8.2