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