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