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