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