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