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