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 "internal.h"
31 #include "dsputil.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 {
307  v->zz_8x4 = wmv2_scantableA;
308  v->zz_4x8 = wmv2_scantableB;
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->s.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 // "0 for reserved RES_RTM_FLAG is forbidden\n");
399  av_log(avctx, AV_LOG_ERROR,
400  "Old WMV3 version detected, some frames may be decoded incorrectly\n");
401  //return -1;
402  }
403  //TODO: figure out what they mean (always 0x402F)
404  if (!v->res_fasttx)
405  skip_bits(gb, 16);
406  av_log(avctx, AV_LOG_DEBUG,
407  "Profile %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
408  "LoopFilter=%i, MultiRes=%i, FastUVMC=%i, Extended MV=%i\n"
409  "Rangered=%i, VSTransform=%i, Overlap=%i, SyncMarker=%i\n"
410  "DQuant=%i, Quantizer mode=%i, Max B frames=%i\n",
412  v->s.loop_filter, v->multires, v->fastuvmc, v->extended_mv,
413  v->rangered, v->vstransform, v->overlap, v->s.resync_marker,
414  v->dquant, v->quantizer_mode, avctx->max_b_frames);
415  return 0;
416 }
417 
419 {
420  v->res_rtm_flag = 1;
421  v->level = get_bits(gb, 3);
422  if (v->level >= 5) {
423  av_log(v->s.avctx, AV_LOG_ERROR, "Reserved LEVEL %i\n",v->level);
424  }
425  v->chromaformat = get_bits(gb, 2);
426  if (v->chromaformat != 1) {
428  "Only 4:2:0 chroma format supported\n");
429  return -1;
430  }
431 
432  // (fps-2)/4 (->30)
433  v->frmrtq_postproc = get_bits(gb, 3); //common
434  // (bitrate-32kbps)/64kbps
435  v->bitrtq_postproc = get_bits(gb, 5); //common
436  v->postprocflag = get_bits1(gb); //common
437 
438  v->s.avctx->coded_width = (get_bits(gb, 12) + 1) << 1;
439  v->s.avctx->coded_height = (get_bits(gb, 12) + 1) << 1;
440  v->s.avctx->width = v->s.avctx->coded_width;
441  v->s.avctx->height = v->s.avctx->coded_height;
442  v->broadcast = get_bits1(gb);
443  v->interlace = get_bits1(gb);
444  v->tfcntrflag = get_bits1(gb);
445  v->finterpflag = get_bits1(gb);
446  skip_bits1(gb); // reserved
447 
449  "Advanced Profile level %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
450  "LoopFilter=%i, ChromaFormat=%i, Pulldown=%i, Interlace: %i\n"
451  "TFCTRflag=%i, FINTERPflag=%i\n",
454  v->tfcntrflag, v->finterpflag);
455 
456  v->psf = get_bits1(gb);
457  if (v->psf) { //PsF, 6.1.13
458  av_log(v->s.avctx, AV_LOG_ERROR, "Progressive Segmented Frame mode: not supported (yet)\n");
459  return -1;
460  }
461  v->s.max_b_frames = v->s.avctx->max_b_frames = 7;
462  if (get_bits1(gb)) { //Display Info - decoding is not affected by it
463  int w, h, ar = 0;
464  av_log(v->s.avctx, AV_LOG_DEBUG, "Display extended info:\n");
465  w = get_bits(gb, 14) + 1;
466  h = get_bits(gb, 14) + 1;
467  av_log(v->s.avctx, AV_LOG_DEBUG, "Display dimensions: %ix%i\n", w, h);
468  if (get_bits1(gb))
469  ar = get_bits(gb, 4);
470  if (ar && ar < 14) {
472  } else if (ar == 15) {
473  w = get_bits(gb, 8) + 1;
474  h = get_bits(gb, 8) + 1;
475  v->s.avctx->sample_aspect_ratio = (AVRational){w, h};
476  } else {
479  v->s.avctx->height * w,
480  v->s.avctx->width * h,
481  1 << 30);
482  }
483  av_log(v->s.avctx, AV_LOG_DEBUG, "Aspect: %i:%i\n",
486 
487  if (get_bits1(gb)) { //framerate stuff
488  if (get_bits1(gb)) {
489  v->s.avctx->time_base.num = 32;
490  v->s.avctx->time_base.den = get_bits(gb, 16) + 1;
491  } else {
492  int nr, dr;
493  nr = get_bits(gb, 8);
494  dr = get_bits(gb, 4);
495  if (nr > 0 && nr < 8 && dr > 0 && dr < 3) {
496  v->s.avctx->time_base.num = ff_vc1_fps_dr[dr - 1];
497  v->s.avctx->time_base.den = ff_vc1_fps_nr[nr - 1] * 1000;
498  }
499  }
500  if (v->broadcast) { // Pulldown may be present
501  v->s.avctx->time_base.den *= 2;
502  v->s.avctx->ticks_per_frame = 2;
503  }
504  }
505 
506  if (get_bits1(gb)) {
507  v->color_prim = get_bits(gb, 8);
508  v->transfer_char = get_bits(gb, 8);
509  v->matrix_coef = get_bits(gb, 8);
510  }
511  }
512 
513  v->hrd_param_flag = get_bits1(gb);
514  if (v->hrd_param_flag) {
515  int i;
516  v->hrd_num_leaky_buckets = get_bits(gb, 5);
517  skip_bits(gb, 4); //bitrate exponent
518  skip_bits(gb, 4); //buffer size exponent
519  for (i = 0; i < v->hrd_num_leaky_buckets; i++) {
520  skip_bits(gb, 16); //hrd_rate[n]
521  skip_bits(gb, 16); //hrd_buffer[n]
522  }
523  }
524  return 0;
525 }
526 
528 {
529  int i;
530 
531  av_log(avctx, AV_LOG_DEBUG, "Entry point: %08X\n", show_bits_long(gb, 32));
532  v->broken_link = get_bits1(gb);
533  v->closed_entry = get_bits1(gb);
534  v->panscanflag = get_bits1(gb);
535  v->refdist_flag = get_bits1(gb);
536  v->s.loop_filter = get_bits1(gb);
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  avctx->width = avctx->coded_width = (get_bits(gb, 12) + 1) << 1;
552  avctx->height = avctx->coded_height = (get_bits(gb, 12) + 1) << 1;
553  }
554  if (v->extended_mv)
555  v->extended_dmv = get_bits1(gb);
556  if ((v->range_mapy_flag = get_bits1(gb))) {
557  av_log(avctx, AV_LOG_ERROR, "Luma scaling is not supported, expect wrong picture\n");
558  v->range_mapy = get_bits(gb, 3);
559  }
560  if ((v->range_mapuv_flag = get_bits1(gb))) {
561  av_log(avctx, AV_LOG_ERROR, "Chroma scaling is not supported, expect wrong picture\n");
562  v->range_mapuv = get_bits(gb, 3);
563  }
564 
565  av_log(avctx, AV_LOG_DEBUG, "Entry point info:\n"
566  "BrokenLink=%i, ClosedEntry=%i, PanscanFlag=%i\n"
567  "RefDist=%i, Postproc=%i, FastUVMC=%i, ExtMV=%i\n"
568  "DQuant=%i, VSTransform=%i, Overlap=%i, Qmode=%i\n",
571 
572  return 0;
573 }
574 
576 {
577  int pqindex, lowquant, status;
578 
579  if (v->finterpflag)
580  v->interpfrm = get_bits1(gb);
581  skip_bits(gb, 2); //framecnt unused
582  v->rangeredfrm = 0;
583  if (v->rangered)
584  v->rangeredfrm = get_bits1(gb);
585  v->s.pict_type = get_bits1(gb);
586  if (v->s.avctx->max_b_frames) {
587  if (!v->s.pict_type) {
588  if (get_bits1(gb))
590  else
592  } else
594  } else
596 
597  v->bi_type = 0;
598  if (v->s.pict_type == AV_PICTURE_TYPE_B) {
601  if (v->bfraction == 0) {
603  }
604  }
606  skip_bits(gb, 7); // skip buffer fullness
607 
608  if (v->parse_only)
609  return 0;
610 
611  /* calculate RND */
613  v->rnd = 1;
614  if (v->s.pict_type == AV_PICTURE_TYPE_P)
615  v->rnd ^= 1;
616 
617  /* Quantizer stuff */
618  pqindex = get_bits(gb, 5);
619  if (!pqindex)
620  return -1;
622  v->pq = ff_vc1_pquant_table[0][pqindex];
623  else
624  v->pq = ff_vc1_pquant_table[1][pqindex];
625 
626  v->pquantizer = 1;
628  v->pquantizer = pqindex < 9;
630  v->pquantizer = 0;
631  v->pqindex = pqindex;
632  if (pqindex < 9)
633  v->halfpq = get_bits1(gb);
634  else
635  v->halfpq = 0;
637  v->pquantizer = get_bits1(gb);
638  v->dquantfrm = 0;
639  if (v->extended_mv == 1)
640  v->mvrange = get_unary(gb, 0, 3);
641  v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
642  v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
643  v->range_x = 1 << (v->k_x - 1);
644  v->range_y = 1 << (v->k_y - 1);
645  if (v->multires && v->s.pict_type != AV_PICTURE_TYPE_B)
646  v->respic = get_bits(gb, 2);
647 
648  if (v->res_x8 && (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)) {
649  v->x8_type = get_bits1(gb);
650  } else
651  v->x8_type = 0;
652 //av_log(v->s.avctx, AV_LOG_INFO, "%c Frame: QP=[%i]%i (+%i/2) %i\n",
653 // (v->s.pict_type == AV_PICTURE_TYPE_P) ? 'P' : ((v->s.pict_type == AV_PICTURE_TYPE_I) ? 'I' : 'B'), pqindex, v->pq, v->halfpq, v->rangeredfrm);
654 
656  v->use_ic = 0;
657 
658  switch (v->s.pict_type) {
659  case AV_PICTURE_TYPE_P:
660  if (v->pq < 5) v->tt_index = 0;
661  else if (v->pq < 13) v->tt_index = 1;
662  else v->tt_index = 2;
663 
664  lowquant = (v->pq > 12) ? 0 : 1;
665  v->mv_mode = ff_vc1_mv_pmode_table[lowquant][get_unary(gb, 1, 4)];
666  if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
667  int scale, shift, i;
668  v->mv_mode2 = ff_vc1_mv_pmode_table2[lowquant][get_unary(gb, 1, 3)];
669  v->lumscale = get_bits(gb, 6);
670  v->lumshift = get_bits(gb, 6);
671  v->use_ic = 1;
672  /* fill lookup tables for intensity compensation */
673  if (!v->lumscale) {
674  scale = -64;
675  shift = (255 - v->lumshift * 2) << 6;
676  if (v->lumshift > 31)
677  shift += 128 << 6;
678  } else {
679  scale = v->lumscale + 32;
680  if (v->lumshift > 31)
681  shift = (v->lumshift - 64) << 6;
682  else
683  shift = v->lumshift << 6;
684  }
685  for (i = 0; i < 256; i++) {
686  v->luty[i] = av_clip_uint8((scale * i + shift + 32) >> 6);
687  v->lutuv[i] = av_clip_uint8((scale * (i - 128) + 128*64 + 32) >> 6);
688  }
689  }
690  v->qs_last = v->s.quarter_sample;
692  v->s.quarter_sample = 0;
693  else if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
695  v->s.quarter_sample = 0;
696  else
697  v->s.quarter_sample = 1;
698  } else
699  v->s.quarter_sample = 1;
701 
702  if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
703  v->mv_mode2 == MV_PMODE_MIXED_MV) ||
704  v->mv_mode == MV_PMODE_MIXED_MV) {
706  if (status < 0)
707  return -1;
708  av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
709  "Imode: %i, Invert: %i\n", status>>1, status&1);
710  } else {
711  v->mv_type_is_raw = 0;
712  memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
713  }
714  status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
715  if (status < 0)
716  return -1;
717  av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
718  "Imode: %i, Invert: %i\n", status>>1, status&1);
719 
720  /* Hopefully this is correct for P frames */
721  v->s.mv_table_index = get_bits(gb, 2); //but using ff_vc1_ tables
722  v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
723 
724  if (v->dquant) {
725  av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
727  }
728 
729  v->ttfrm = 0; //FIXME Is that so ?
730  if (v->vstransform) {
731  v->ttmbf = get_bits1(gb);
732  if (v->ttmbf) {
733  v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
734  }
735  } else {
736  v->ttmbf = 1;
737  v->ttfrm = TT_8X8;
738  }
739  break;
740  case AV_PICTURE_TYPE_B:
741  if (v->pq < 5) v->tt_index = 0;
742  else if (v->pq < 13) v->tt_index = 1;
743  else v->tt_index = 2;
744 
746  v->qs_last = v->s.quarter_sample;
747  v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
748  v->s.mspel = v->s.quarter_sample;
749 
750  status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
751  if (status < 0)
752  return -1;
753  av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
754  "Imode: %i, Invert: %i\n", status>>1, status&1);
755  status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
756  if (status < 0)
757  return -1;
758  av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
759  "Imode: %i, Invert: %i\n", status>>1, status&1);
760 
761  v->s.mv_table_index = get_bits(gb, 2);
762  v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
763 
764  if (v->dquant) {
765  av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
767  }
768 
769  v->ttfrm = 0;
770  if (v->vstransform) {
771  v->ttmbf = get_bits1(gb);
772  if (v->ttmbf) {
773  v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
774  }
775  } else {
776  v->ttmbf = 1;
777  v->ttfrm = TT_8X8;
778  }
779  break;
780  }
781 
782  if (!v->x8_type) {
783  /* AC Syntax */
784  v->c_ac_table_index = decode012(gb);
786  v->y_ac_table_index = decode012(gb);
787  }
788  /* DC Syntax */
789  v->s.dc_table_index = get_bits1(gb);
790  }
791 
792  if (v->s.pict_type == AV_PICTURE_TYPE_BI) {
794  v->bi_type = 1;
795  }
796  return 0;
797 }
798 
799 /* fill lookup tables for intensity compensation */
800 #define INIT_LUT(lumscale, lumshift, luty, lutuv) \
801  if (!lumscale) { \
802  scale = -64; \
803  shift = (255 - lumshift * 2) << 6; \
804  if (lumshift > 31) \
805  shift += 128 << 6; \
806  } else { \
807  scale = lumscale + 32; \
808  if (lumshift > 31) \
809  shift = (lumshift - 64) << 6; \
810  else \
811  shift = lumshift << 6; \
812  } \
813  for (i = 0; i < 256; i++) { \
814  luty[i] = av_clip_uint8((scale * i + shift + 32) >> 6); \
815  lutuv[i] = av_clip_uint8((scale * (i - 128) + 128*64 + 32) >> 6); \
816  }
817 
819 {
820  int pqindex, lowquant;
821  int status;
822  int mbmodetab, imvtab, icbptab, twomvbptab, fourmvbptab; /* useful only for debugging */
823  int scale, shift, i; /* for initializing LUT for intensity compensation */
824 
825  v->numref = 0;
826  v->p_frame_skipped = 0;
827  if (v->second_field) {
829  if (v->fptype & 4)
832  if (!v->pic_header_flag)
833  goto parse_common_info;
834  }
835 
836  v->field_mode = 0;
837  if (v->interlace) {
838  v->fcm = decode012(gb);
839  if (v->fcm) {
840  if (v->fcm == ILACE_FIELD)
841  v->field_mode = 1;
842  if (!v->warn_interlaced++)
844  "Interlaced frames/fields support is incomplete\n");
845  }
846  } else {
847  v->fcm = PROGRESSIVE;
848  }
849 
850  if (v->field_mode) {
851  v->fptype = get_bits(gb, 3);
853  if (v->fptype & 4) // B-picture
855  } else {
856  switch (get_unary(gb, 0, 4)) {
857  case 0:
859  break;
860  case 1:
862  break;
863  case 2:
865  break;
866  case 3:
868  break;
869  case 4:
870  v->s.pict_type = AV_PICTURE_TYPE_P; // skipped pic
871  v->p_frame_skipped = 1;
872  break;
873  }
874  }
875  if (v->tfcntrflag)
876  skip_bits(gb, 8);
877  if (v->broadcast) {
878  if (!v->interlace || v->psf) {
879  v->rptfrm = get_bits(gb, 2);
880  } else {
881  v->tff = get_bits1(gb);
882  v->rff = get_bits1(gb);
883  }
884  }
885  if (v->panscanflag) {
886  av_log_missing_feature(v->s.avctx, "Pan-scan", 0);
887  //...
888  }
889  if (v->p_frame_skipped) {
890  return 0;
891  }
892  v->rnd = get_bits1(gb);
893  if (v->interlace)
894  v->uvsamp = get_bits1(gb);
895  if (v->field_mode) {
896  if (!v->refdist_flag)
897  v->refdist = 0;
898  else {
899  if ((v->s.pict_type != AV_PICTURE_TYPE_B)
900  && (v->s.pict_type != AV_PICTURE_TYPE_BI)) {
901  v->refdist = get_bits(gb, 2);
902  if (v->refdist == 3)
903  v->refdist += get_unary(gb, 0, 16);
904  } else {
907  v->frfd = (v->bfraction * v->refdist) >> 8;
908  v->brfd = v->refdist - v->frfd - 1;
909  if (v->brfd < 0)
910  v->brfd = 0;
911  }
912  }
913  goto parse_common_info;
914  }
915  if (v->finterpflag)
916  v->interpfrm = get_bits1(gb);
917  if (v->s.pict_type == AV_PICTURE_TYPE_B) {
920  if (v->bfraction == 0) {
921  v->s.pict_type = AV_PICTURE_TYPE_BI; /* XXX: should not happen here */
922  }
923  }
924 
925  parse_common_info:
926  if (v->field_mode)
927  v->cur_field_type = !(v->tff ^ v->second_field);
928  pqindex = get_bits(gb, 5);
929  if (!pqindex)
930  return -1;
931  v->pqindex = pqindex;
933  v->pq = ff_vc1_pquant_table[0][pqindex];
934  else
935  v->pq = ff_vc1_pquant_table[1][pqindex];
936 
937  v->pquantizer = 1;
939  v->pquantizer = pqindex < 9;
941  v->pquantizer = 0;
942  v->pqindex = pqindex;
943  if (pqindex < 9)
944  v->halfpq = get_bits1(gb);
945  else
946  v->halfpq = 0;
948  v->pquantizer = get_bits1(gb);
949  if (v->postprocflag)
950  v->postproc = get_bits(gb, 2);
951 
953  v->use_ic = 0;
954 
955  if (v->parse_only)
956  return 0;
957 
958  switch (v->s.pict_type) {
959  case AV_PICTURE_TYPE_I:
960  case AV_PICTURE_TYPE_BI:
961  if (v->fcm == ILACE_FRAME) { //interlace frame picture
962  status = bitplane_decoding(v->fieldtx_plane, &v->fieldtx_is_raw, v);
963  if (status < 0)
964  return -1;
965  av_log(v->s.avctx, AV_LOG_DEBUG, "FIELDTX plane encoding: "
966  "Imode: %i, Invert: %i\n", status>>1, status&1);
967  }
968  status = bitplane_decoding(v->acpred_plane, &v->acpred_is_raw, v);
969  if (status < 0)
970  return -1;
971  av_log(v->s.avctx, AV_LOG_DEBUG, "ACPRED plane encoding: "
972  "Imode: %i, Invert: %i\n", status>>1, status&1);
973  v->condover = CONDOVER_NONE;
974  if (v->overlap && v->pq <= 8) {
975  v->condover = decode012(gb);
976  if (v->condover == CONDOVER_SELECT) {
978  if (status < 0)
979  return -1;
980  av_log(v->s.avctx, AV_LOG_DEBUG, "CONDOVER plane encoding: "
981  "Imode: %i, Invert: %i\n", status>>1, status&1);
982  }
983  }
984  break;
985  case AV_PICTURE_TYPE_P:
986  if (v->field_mode) {
987  v->numref = get_bits1(gb);
988  if (!v->numref) {
989  v->reffield = get_bits1(gb);
990  v->ref_field_type[0] = v->reffield ^ !v->cur_field_type;
991  }
992  }
993  if (v->extended_mv)
994  v->mvrange = get_unary(gb, 0, 3);
995  else
996  v->mvrange = 0;
997  if (v->interlace) {
998  if (v->extended_dmv)
999  v->dmvrange = get_unary(gb, 0, 3);
1000  else
1001  v->dmvrange = 0;
1002  if (v->fcm == ILACE_FRAME) { // interlaced frame picture
1003  v->fourmvswitch = get_bits1(gb);
1004  v->intcomp = get_bits1(gb);
1005  if (v->intcomp) {
1006  v->lumscale = get_bits(gb, 6);
1007  v->lumshift = get_bits(gb, 6);
1008  INIT_LUT(v->lumscale, v->lumshift, v->luty, v->lutuv);
1009  }
1010  status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1011  av_log(v->s.avctx, AV_LOG_DEBUG, "SKIPMB plane encoding: "
1012  "Imode: %i, Invert: %i\n", status>>1, status&1);
1013  mbmodetab = get_bits(gb, 2);
1014  if (v->fourmvswitch)
1015  v->mbmode_vlc = &ff_vc1_intfr_4mv_mbmode_vlc[mbmodetab];
1016  else
1017  v->mbmode_vlc = &ff_vc1_intfr_non4mv_mbmode_vlc[mbmodetab];
1018  imvtab = get_bits(gb, 2);
1019  v->imv_vlc = &ff_vc1_1ref_mvdata_vlc[imvtab];
1020  // interlaced p-picture cbpcy range is [1, 63]
1021  icbptab = get_bits(gb, 3);
1022  v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
1023  twomvbptab = get_bits(gb, 2);
1024  v->twomvbp_vlc = &ff_vc1_2mv_block_pattern_vlc[twomvbptab];
1025  if (v->fourmvswitch) {
1026  fourmvbptab = get_bits(gb, 2);
1027  v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
1028  }
1029  }
1030  }
1031  v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1032  v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
1033  v->range_x = 1 << (v->k_x - 1);
1034  v->range_y = 1 << (v->k_y - 1);
1035 
1036  if (v->pq < 5)
1037  v->tt_index = 0;
1038  else if (v->pq < 13)
1039  v->tt_index = 1;
1040  else
1041  v->tt_index = 2;
1042  if (v->fcm != ILACE_FRAME) {
1043  int mvmode;
1044  mvmode = get_unary(gb, 1, 4);
1045  lowquant = (v->pq > 12) ? 0 : 1;
1046  v->mv_mode = ff_vc1_mv_pmode_table[lowquant][mvmode];
1047  if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
1048  int mvmode2;
1049  mvmode2 = get_unary(gb, 1, 3);
1050  v->mv_mode2 = ff_vc1_mv_pmode_table2[lowquant][mvmode2];
1051  if (v->field_mode)
1052  v->intcompfield = decode210(gb);
1053  v->lumscale = get_bits(gb, 6);
1054  v->lumshift = get_bits(gb, 6);
1055  INIT_LUT(v->lumscale, v->lumshift, v->luty, v->lutuv);
1056  if ((v->field_mode) && !v->intcompfield) {
1057  v->lumscale2 = get_bits(gb, 6);
1058  v->lumshift2 = get_bits(gb, 6);
1059  INIT_LUT(v->lumscale2, v->lumshift2, v->luty2, v->lutuv2);
1060  }
1061  v->use_ic = 1;
1062  }
1063  v->qs_last = v->s.quarter_sample;
1065  v->s.quarter_sample = 0;
1066  else if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
1068  v->s.quarter_sample = 0;
1069  else
1070  v->s.quarter_sample = 1;
1071  } else
1072  v->s.quarter_sample = 1;
1073  v->s.mspel = !(v->mv_mode == MV_PMODE_1MV_HPEL_BILIN
1075  && v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN));
1076  }
1077  if (v->fcm == PROGRESSIVE) { // progressive
1078  if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
1080  || v->mv_mode == MV_PMODE_MIXED_MV) {
1081  status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);
1082  if (status < 0)
1083  return -1;
1084  av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
1085  "Imode: %i, Invert: %i\n", status>>1, status&1);
1086  } else {
1087  v->mv_type_is_raw = 0;
1088  memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
1089  }
1090  status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1091  if (status < 0)
1092  return -1;
1093  av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1094  "Imode: %i, Invert: %i\n", status>>1, status&1);
1095 
1096  /* Hopefully this is correct for P frames */
1097  v->s.mv_table_index = get_bits(gb, 2); //but using ff_vc1_ tables
1098  v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
1099  } else if (v->fcm == ILACE_FRAME) { // frame interlaced
1100  v->qs_last = v->s.quarter_sample;
1101  v->s.quarter_sample = 1;
1102  v->s.mspel = 1;
1103  } else { // field interlaced
1104  mbmodetab = get_bits(gb, 3);
1105  imvtab = get_bits(gb, 2 + v->numref);
1106  if (!v->numref)
1107  v->imv_vlc = &ff_vc1_1ref_mvdata_vlc[imvtab];
1108  else
1109  v->imv_vlc = &ff_vc1_2ref_mvdata_vlc[imvtab];
1110  icbptab = get_bits(gb, 3);
1111  v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
1112  if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
1114  fourmvbptab = get_bits(gb, 2);
1115  v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
1116  v->mbmode_vlc = &ff_vc1_if_mmv_mbmode_vlc[mbmodetab];
1117  } else {
1118  v->mbmode_vlc = &ff_vc1_if_1mv_mbmode_vlc[mbmodetab];
1119  }
1120  }
1121  if (v->dquant) {
1122  av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1124  }
1125 
1126  v->ttfrm = 0; //FIXME Is that so ?
1127  if (v->vstransform) {
1128  v->ttmbf = get_bits1(gb);
1129  if (v->ttmbf) {
1130  v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
1131  }
1132  } else {
1133  v->ttmbf = 1;
1134  v->ttfrm = TT_8X8;
1135  }
1136  break;
1137  case AV_PICTURE_TYPE_B:
1138  // TODO: implement interlaced frame B picture decoding
1139  if (v->fcm == ILACE_FRAME)
1140  return -1;
1141  if (v->extended_mv)
1142  v->mvrange = get_unary(gb, 0, 3);
1143  else
1144  v->mvrange = 0;
1145  v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1146  v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
1147  v->range_x = 1 << (v->k_x - 1);
1148  v->range_y = 1 << (v->k_y - 1);
1149 
1150  if (v->pq < 5)
1151  v->tt_index = 0;
1152  else if (v->pq < 13)
1153  v->tt_index = 1;
1154  else
1155  v->tt_index = 2;
1156 
1157  if (v->field_mode) {
1158  int mvmode;
1159  if (v->extended_dmv)
1160  v->dmvrange = get_unary(gb, 0, 3);
1161  mvmode = get_unary(gb, 1, 3);
1162  lowquant = (v->pq > 12) ? 0 : 1;
1163  v->mv_mode = ff_vc1_mv_pmode_table2[lowquant][mvmode];
1164  v->qs_last = v->s.quarter_sample;
1167  status = bitplane_decoding(v->forward_mb_plane, &v->fmb_is_raw, v);
1168  if (status < 0)
1169  return -1;
1170  av_log(v->s.avctx, AV_LOG_DEBUG, "MB Forward Type plane encoding: "
1171  "Imode: %i, Invert: %i\n", status>>1, status&1);
1172  mbmodetab = get_bits(gb, 3);
1173  if (v->mv_mode == MV_PMODE_MIXED_MV)
1174  v->mbmode_vlc = &ff_vc1_if_mmv_mbmode_vlc[mbmodetab];
1175  else
1176  v->mbmode_vlc = &ff_vc1_if_1mv_mbmode_vlc[mbmodetab];
1177  imvtab = get_bits(gb, 3);
1178  v->imv_vlc = &ff_vc1_2ref_mvdata_vlc[imvtab];
1179  icbptab = get_bits(gb, 3);
1180  v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
1181  if (v->mv_mode == MV_PMODE_MIXED_MV) {
1182  fourmvbptab = get_bits(gb, 2);
1183  v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
1184  }
1185  v->numref = 1; // interlaced field B pictures are always 2-ref
1186  } else {
1188  v->qs_last = v->s.quarter_sample;
1189  v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
1190  v->s.mspel = v->s.quarter_sample;
1191  status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
1192  if (status < 0)
1193  return -1;
1194  av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
1195  "Imode: %i, Invert: %i\n", status>>1, status&1);
1196  status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1197  if (status < 0)
1198  return -1;
1199  av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1200  "Imode: %i, Invert: %i\n", status>>1, status&1);
1201  v->s.mv_table_index = get_bits(gb, 2);
1202  v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
1203  }
1204 
1205  if (v->dquant) {
1206  av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1208  }
1209 
1210  v->ttfrm = 0;
1211  if (v->vstransform) {
1212  v->ttmbf = get_bits1(gb);
1213  if (v->ttmbf) {
1214  v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
1215  }
1216  } else {
1217  v->ttmbf = 1;
1218  v->ttfrm = TT_8X8;
1219  }
1220  break;
1221  }
1222 
1223  /* AC Syntax */
1224  v->c_ac_table_index = decode012(gb);
1226  v->y_ac_table_index = decode012(gb);
1227  }
1228  /* DC Syntax */
1229  v->s.dc_table_index = get_bits1(gb);
1231  && v->dquant) {
1232  av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1234  }
1235 
1236  v->bi_type = 0;
1237  if (v->s.pict_type == AV_PICTURE_TYPE_BI) {
1239  v->bi_type = 1;
1240  }
1241  return 0;
1242 }
1243 
1244 static const uint32_t vc1_ac_tables[AC_MODES][186][2] = {
1245 {
1246 { 0x0001, 2}, { 0x0005, 3}, { 0x000D, 4}, { 0x0012, 5}, { 0x000E, 6}, { 0x0015, 7},
1247 { 0x0013, 8}, { 0x003F, 8}, { 0x004B, 9}, { 0x011F, 9}, { 0x00B8, 10}, { 0x03E3, 10},
1248 { 0x0172, 11}, { 0x024D, 12}, { 0x03DA, 12}, { 0x02DD, 13}, { 0x1F55, 13}, { 0x05B9, 14},
1249 { 0x3EAE, 14}, { 0x0000, 4}, { 0x0010, 5}, { 0x0008, 7}, { 0x0020, 8}, { 0x0029, 9},
1250 { 0x01F4, 9}, { 0x0233, 10}, { 0x01E0, 11}, { 0x012A, 12}, { 0x03DD, 12}, { 0x050A, 13},
1251 { 0x1F29, 13}, { 0x0A42, 14}, { 0x1272, 15}, { 0x1737, 15}, { 0x0003, 5}, { 0x0011, 7},
1252 { 0x00C4, 8}, { 0x004B, 10}, { 0x00B4, 11}, { 0x07D4, 11}, { 0x0345, 12}, { 0x02D7, 13},
1253 { 0x07BF, 13}, { 0x0938, 14}, { 0x0BBB, 14}, { 0x095E, 15}, { 0x0013, 5}, { 0x0078, 7},
1254 { 0x0069, 9}, { 0x0232, 10}, { 0x0461, 11}, { 0x03EC, 12}, { 0x0520, 13}, { 0x1F2A, 13},
1255 { 0x3E50, 14}, { 0x3E51, 14}, { 0x1486, 15}, { 0x000C, 6}, { 0x0024, 9}, { 0x0094, 11},
1256 { 0x08C0, 12}, { 0x0F09, 14}, { 0x1EF0, 15}, { 0x003D, 6}, { 0x0053, 9}, { 0x01A0, 11},
1257 { 0x02D6, 13}, { 0x0F08, 14}, { 0x0013, 7}, { 0x007C, 9}, { 0x07C1, 11}, { 0x04AC, 14},
1258 { 0x001B, 7}, { 0x00A0, 10}, { 0x0344, 12}, { 0x0F79, 14}, { 0x0079, 7}, { 0x03E1, 10},
1259 { 0x02D4, 13}, { 0x2306, 14}, { 0x0021, 8}, { 0x023C, 10}, { 0x0FAE, 12}, { 0x23DE, 14},
1260 { 0x0035, 8}, { 0x0175, 11}, { 0x07B3, 13}, { 0x00C5, 8}, { 0x0174, 11}, { 0x0785, 13},
1261 { 0x0048, 9}, { 0x01A3, 11}, { 0x049E, 13}, { 0x002C, 9}, { 0x00FA, 10}, { 0x07D6, 11},
1262 { 0x0092, 10}, { 0x05CC, 13}, { 0x1EF1, 15}, { 0x00A3, 10}, { 0x03ED, 12}, { 0x093E, 14},
1263 { 0x01E2, 11}, { 0x1273, 15}, { 0x07C4, 11}, { 0x1487, 15}, { 0x0291, 12}, { 0x0293, 12},
1264 { 0x0F8A, 12}, { 0x0509, 13}, { 0x0508, 13}, { 0x078D, 13}, { 0x07BE, 13}, { 0x078C, 13},
1265 { 0x04AE, 14}, { 0x0BBA, 14}, { 0x2307, 14}, { 0x0B9A, 14}, { 0x1736, 15}, { 0x000E, 4},
1266 { 0x0045, 7}, { 0x01F3, 9}, { 0x047A, 11}, { 0x05DC, 13}, { 0x23DF, 14}, { 0x0019, 5},
1267 { 0x0028, 9}, { 0x0176, 11}, { 0x049D, 13}, { 0x23DD, 14}, { 0x0030, 6}, { 0x00A2, 10},
1268 { 0x02EF, 12}, { 0x05B8, 14}, { 0x003F, 6}, { 0x00A5, 10}, { 0x03DB, 12}, { 0x093F, 14},
1269 { 0x0044, 7}, { 0x07CB, 11}, { 0x095F, 15}, { 0x0063, 7}, { 0x03C3, 12}, { 0x0015, 8},
1270 { 0x08F6, 12}, { 0x0017, 8}, { 0x0498, 13}, { 0x002C, 8}, { 0x07B2, 13}, { 0x002F, 8},
1271 { 0x1F54, 13}, { 0x008D, 8}, { 0x07BD, 13}, { 0x008E, 8}, { 0x1182, 13}, { 0x00FB, 8},
1272 { 0x050B, 13}, { 0x002D, 8}, { 0x07C0, 11}, { 0x0079, 9}, { 0x1F5F, 13}, { 0x007A, 9},
1273 { 0x1F56, 13}, { 0x0231, 10}, { 0x03E4, 10}, { 0x01A1, 11}, { 0x0143, 11}, { 0x01F7, 11},
1274 { 0x016F, 12}, { 0x0292, 12}, { 0x02E7, 12}, { 0x016C, 12}, { 0x016D, 12}, { 0x03DC, 12},
1275 { 0x0F8B, 12}, { 0x0499, 13}, { 0x03D8, 12}, { 0x078E, 13}, { 0x02D5, 13}, { 0x1F5E, 13},
1276 { 0x1F2B, 13}, { 0x078F, 13}, { 0x04AD, 14}, { 0x3EAF, 14}, { 0x23DC, 14}, { 0x004A, 9}
1277 },
1278 {
1279 { 0x0000, 3}, { 0x0003, 4}, { 0x000B, 5}, { 0x0014, 6}, { 0x003F, 6}, { 0x005D, 7},
1280 { 0x00A2, 8}, { 0x00AC, 9}, { 0x016E, 9}, { 0x020A, 10}, { 0x02E2, 10}, { 0x0432, 11},
1281 { 0x05C9, 11}, { 0x0827, 12}, { 0x0B54, 12}, { 0x04E6, 13}, { 0x105F, 13}, { 0x172A, 13},
1282 { 0x20B2, 14}, { 0x2D4E, 14}, { 0x39F0, 14}, { 0x4175, 15}, { 0x5A9E, 15}, { 0x0004, 4},
1283 { 0x001E, 5}, { 0x0042, 7}, { 0x00B6, 8}, { 0x0173, 9}, { 0x0395, 10}, { 0x072E, 11},
1284 { 0x0B94, 12}, { 0x16A4, 13}, { 0x20B3, 14}, { 0x2E45, 14}, { 0x0005, 5}, { 0x0040, 7},
1285 { 0x0049, 9}, { 0x028F, 10}, { 0x05CB, 11}, { 0x048A, 13}, { 0x09DD, 14}, { 0x73E2, 15},
1286 { 0x0018, 5}, { 0x0025, 8}, { 0x008A, 10}, { 0x051B, 11}, { 0x0E5F, 12}, { 0x09C9, 14},
1287 { 0x139C, 15}, { 0x0029, 6}, { 0x004F, 9}, { 0x0412, 11}, { 0x048D, 13}, { 0x2E41, 14},
1288 { 0x0038, 6}, { 0x010E, 9}, { 0x05A8, 11}, { 0x105C, 13}, { 0x39F2, 14}, { 0x0058, 7},
1289 { 0x021F, 10}, { 0x0E7E, 12}, { 0x39FF, 14}, { 0x0023, 8}, { 0x02E3, 10}, { 0x04E5, 13},
1290 { 0x2E40, 14}, { 0x00A1, 8}, { 0x05BE, 11}, { 0x09C8, 14}, { 0x0083, 8}, { 0x013A, 11},
1291 { 0x1721, 13}, { 0x0044, 9}, { 0x0276, 12}, { 0x39F6, 14}, { 0x008B, 10}, { 0x04EF, 13},
1292 { 0x5A9B, 15}, { 0x0208, 10}, { 0x1CFE, 13}, { 0x0399, 10}, { 0x1CB4, 13}, { 0x039E, 10},
1293 { 0x39F3, 14}, { 0x05AB, 11}, { 0x73E3, 15}, { 0x0737, 11}, { 0x5A9F, 15}, { 0x082D, 12},
1294 { 0x0E69, 12}, { 0x0E68, 12}, { 0x0433, 11}, { 0x0B7B, 12}, { 0x2DF8, 14}, { 0x2E56, 14},
1295 { 0x2E57, 14}, { 0x39F7, 14}, { 0x51A5, 15}, { 0x0003, 3}, { 0x002A, 6}, { 0x00E4, 8},
1296 { 0x028E, 10}, { 0x0735, 11}, { 0x1058, 13}, { 0x1CFA, 13}, { 0x2DF9, 14}, { 0x4174, 15},
1297 { 0x0009, 4}, { 0x0054, 8}, { 0x0398, 10}, { 0x048B, 13}, { 0x139D, 15}, { 0x000D, 4},
1298 { 0x00AD, 9}, { 0x0826, 12}, { 0x2D4C, 14}, { 0x0011, 5}, { 0x016B, 9}, { 0x0B7F, 12},
1299 { 0x51A4, 15}, { 0x0019, 5}, { 0x021B, 10}, { 0x16FD, 13}, { 0x001D, 5}, { 0x0394, 10},
1300 { 0x28D3, 14}, { 0x002B, 6}, { 0x05BC, 11}, { 0x5A9A, 15}, { 0x002F, 6}, { 0x0247, 12},
1301 { 0x0010, 7}, { 0x0A35, 12}, { 0x003E, 6}, { 0x0B7A, 12}, { 0x0059, 7}, { 0x105E, 13},
1302 { 0x0026, 8}, { 0x09CF, 14}, { 0x0055, 8}, { 0x1CB5, 13}, { 0x0057, 8}, { 0x0E5B, 12},
1303 { 0x00A0, 8}, { 0x1468, 13}, { 0x0170, 9}, { 0x0090, 10}, { 0x01CE, 9}, { 0x021A, 10},
1304 { 0x0218, 10}, { 0x0168, 9}, { 0x021E, 10}, { 0x0244, 12}, { 0x0736, 11}, { 0x0138, 11},
1305 { 0x0519, 11}, { 0x0E5E, 12}, { 0x072C, 11}, { 0x0B55, 12}, { 0x09DC, 14}, { 0x20BB, 14},
1306 { 0x048C, 13}, { 0x1723, 13}, { 0x2E44, 14}, { 0x16A5, 13}, { 0x0518, 11}, { 0x39FE, 14},
1307 { 0x0169, 9}
1308 },
1309 {
1310 { 0x0001, 2}, { 0x0006, 3}, { 0x000F, 4}, { 0x0016, 5}, { 0x0020, 6}, { 0x0018, 7},
1311 { 0x0008, 8}, { 0x009A, 8}, { 0x0056, 9}, { 0x013E, 9}, { 0x00F0, 10}, { 0x03A5, 10},
1312 { 0x0077, 11}, { 0x01EF, 11}, { 0x009A, 12}, { 0x005D, 13}, { 0x0001, 4}, { 0x0011, 5},
1313 { 0x0002, 7}, { 0x000B, 8}, { 0x0012, 9}, { 0x01D6, 9}, { 0x027E, 10}, { 0x0191, 11},
1314 { 0x00EA, 12}, { 0x03DC, 12}, { 0x013B, 13}, { 0x0004, 5}, { 0x0014, 7}, { 0x009E, 8},
1315 { 0x0009, 10}, { 0x01AC, 11}, { 0x01E2, 11}, { 0x03CA, 12}, { 0x005F, 13}, { 0x0017, 5},
1316 { 0x004E, 7}, { 0x005E, 9}, { 0x00F3, 10}, { 0x01AD, 11}, { 0x00EC, 12}, { 0x05F0, 13},
1317 { 0x000E, 6}, { 0x00E1, 8}, { 0x03A4, 10}, { 0x009C, 12}, { 0x013D, 13}, { 0x003B, 6},
1318 { 0x001C, 9}, { 0x0014, 11}, { 0x09BE, 12}, { 0x0006, 7}, { 0x007A, 9}, { 0x0190, 11},
1319 { 0x0137, 13}, { 0x001B, 7}, { 0x0008, 10}, { 0x075C, 11}, { 0x0071, 7}, { 0x00D7, 10},
1320 { 0x09BF, 12}, { 0x0007, 8}, { 0x00AF, 10}, { 0x04CC, 11}, { 0x0034, 8}, { 0x0265, 10},
1321 { 0x009F, 12}, { 0x00E0, 8}, { 0x0016, 11}, { 0x0327, 12}, { 0x0015, 9}, { 0x017D, 11},
1322 { 0x0EBB, 12}, { 0x0014, 9}, { 0x00F6, 10}, { 0x01E4, 11}, { 0x00CB, 10}, { 0x099D, 12},
1323 { 0x00CA, 10}, { 0x02FC, 12}, { 0x017F, 11}, { 0x04CD, 11}, { 0x02FD, 12}, { 0x04FE, 11},
1324 { 0x013A, 13}, { 0x000A, 4}, { 0x0042, 7}, { 0x01D3, 9}, { 0x04DD, 11}, { 0x0012, 5},
1325 { 0x00E8, 8}, { 0x004C, 11}, { 0x0136, 13}, { 0x0039, 6}, { 0x0264, 10}, { 0x0EBA, 12},
1326 { 0x0000, 7}, { 0x00AE, 10}, { 0x099C, 12}, { 0x001F, 7}, { 0x04DE, 11}, { 0x0043, 7},
1327 { 0x04DC, 11}, { 0x0003, 8}, { 0x03CB, 12}, { 0x0006, 8}, { 0x099E, 12}, { 0x002A, 8},
1328 { 0x05F1, 13}, { 0x000F, 8}, { 0x09FE, 12}, { 0x0033, 8}, { 0x09FF, 12}, { 0x0098, 8},
1329 { 0x099F, 12}, { 0x00EA, 8}, { 0x013C, 13}, { 0x002E, 8}, { 0x0192, 11}, { 0x0136, 9},
1330 { 0x006A, 9}, { 0x0015, 11}, { 0x03AF, 10}, { 0x01E3, 11}, { 0x0074, 11}, { 0x00EB, 12},
1331 { 0x02F9, 12}, { 0x005C, 13}, { 0x00ED, 12}, { 0x03DD, 12}, { 0x0326, 12}, { 0x005E, 13},
1332 { 0x0016, 7}
1333 },
1334 {
1335 { 0x0004, 3}, { 0x0014, 5}, { 0x0017, 7}, { 0x007F, 8}, { 0x0154, 9}, { 0x01F2, 10},
1336 { 0x00BF, 11}, { 0x0065, 12}, { 0x0AAA, 12}, { 0x0630, 13}, { 0x1597, 13}, { 0x03B7, 14},
1337 { 0x2B22, 14}, { 0x0BE6, 15}, { 0x000B, 4}, { 0x0037, 7}, { 0x0062, 9}, { 0x0007, 11},
1338 { 0x0166, 12}, { 0x00CE, 13}, { 0x1590, 13}, { 0x05F6, 14}, { 0x0BE7, 15}, { 0x0007, 5},
1339 { 0x006D, 8}, { 0x0003, 11}, { 0x031F, 12}, { 0x05F2, 14}, { 0x0002, 6}, { 0x0061, 9},
1340 { 0x0055, 12}, { 0x01DF, 14}, { 0x001A, 6}, { 0x001E, 10}, { 0x0AC9, 12}, { 0x2B23, 14},
1341 { 0x001E, 6}, { 0x001F, 10}, { 0x0AC3, 12}, { 0x2B2B, 14}, { 0x0006, 7}, { 0x0004, 11},
1342 { 0x02F8, 13}, { 0x0019, 7}, { 0x0006, 11}, { 0x063D, 13}, { 0x0057, 7}, { 0x0182, 11},
1343 { 0x2AA2, 14}, { 0x0004, 8}, { 0x0180, 11}, { 0x059C, 14}, { 0x007D, 8}, { 0x0164, 12},
1344 { 0x076D, 15}, { 0x0002, 9}, { 0x018D, 11}, { 0x1581, 13}, { 0x00AD, 8}, { 0x0060, 12},
1345 { 0x0C67, 14}, { 0x001C, 9}, { 0x00EE, 13}, { 0x0003, 9}, { 0x02CF, 13}, { 0x00D9, 9},
1346 { 0x1580, 13}, { 0x0002, 11}, { 0x0183, 11}, { 0x0057, 12}, { 0x0061, 12}, { 0x0031, 11},
1347 { 0x0066, 12}, { 0x0631, 13}, { 0x0632, 13}, { 0x00AC, 13}, { 0x031D, 12}, { 0x0076, 12},
1348 { 0x003A, 11}, { 0x0165, 12}, { 0x0C66, 14}, { 0x0003, 2}, { 0x0054, 7}, { 0x02AB, 10},
1349 { 0x0016, 13}, { 0x05F7, 14}, { 0x0005, 4}, { 0x00F8, 9}, { 0x0AA9, 12}, { 0x005F, 15},
1350 { 0x0004, 4}, { 0x001C, 10}, { 0x1550, 13}, { 0x0004, 5}, { 0x0077, 11}, { 0x076C, 15},
1351 { 0x000E, 5}, { 0x000A, 12}, { 0x000C, 5}, { 0x0562, 11}, { 0x0004, 6}, { 0x031C, 12},
1352 { 0x0006, 6}, { 0x00C8, 13}, { 0x000D, 6}, { 0x01DA, 13}, { 0x0007, 6}, { 0x00C9, 13},
1353 { 0x0001, 7}, { 0x002E, 14}, { 0x0014, 7}, { 0x1596, 13}, { 0x000A, 7}, { 0x0AC2, 12},
1354 { 0x0016, 7}, { 0x015B, 14}, { 0x0015, 7}, { 0x015A, 14}, { 0x000F, 8}, { 0x005E, 15},
1355 { 0x007E, 8}, { 0x00AB, 8}, { 0x002D, 9}, { 0x00D8, 9}, { 0x000B, 9}, { 0x0014, 10},
1356 { 0x02B3, 10}, { 0x01F3, 10}, { 0x003A, 10}, { 0x0000, 10}, { 0x0058, 10}, { 0x002E, 9},
1357 { 0x005E, 10}, { 0x0563, 11}, { 0x00EC, 12}, { 0x0054, 12}, { 0x0AC1, 12}, { 0x1556, 13},
1358 { 0x02FA, 13}, { 0x0181, 11}, { 0x1557, 13}, { 0x059D, 14}, { 0x2AA3, 14}, { 0x2B2A, 14},
1359 { 0x01DE, 14}, { 0x063C, 13}, { 0x00CF, 13}, { 0x1594, 13}, { 0x000D, 9}
1360 },
1361 {
1362 { 0x0002, 2}, { 0x0006, 3}, { 0x000F, 4}, { 0x000D, 5}, { 0x000C, 5}, { 0x0015, 6},
1363 { 0x0013, 6}, { 0x0012, 6}, { 0x0017, 7}, { 0x001F, 8}, { 0x001E, 8}, { 0x001D, 8},
1364 { 0x0025, 9}, { 0x0024, 9}, { 0x0023, 9}, { 0x0021, 9}, { 0x0021, 10}, { 0x0020, 10},
1365 { 0x000F, 10}, { 0x000E, 10}, { 0x0007, 11}, { 0x0006, 11}, { 0x0020, 11}, { 0x0021, 11},
1366 { 0x0050, 12}, { 0x0051, 12}, { 0x0052, 12}, { 0x000E, 4}, { 0x0014, 6}, { 0x0016, 7},
1367 { 0x001C, 8}, { 0x0020, 9}, { 0x001F, 9}, { 0x000D, 10}, { 0x0022, 11}, { 0x0053, 12},
1368 { 0x0055, 12}, { 0x000B, 5}, { 0x0015, 7}, { 0x001E, 9}, { 0x000C, 10}, { 0x0056, 12},
1369 { 0x0011, 6}, { 0x001B, 8}, { 0x001D, 9}, { 0x000B, 10}, { 0x0010, 6}, { 0x0022, 9},
1370 { 0x000A, 10}, { 0x000D, 6}, { 0x001C, 9}, { 0x0008, 10}, { 0x0012, 7}, { 0x001B, 9},
1371 { 0x0054, 12}, { 0x0014, 7}, { 0x001A, 9}, { 0x0057, 12}, { 0x0019, 8}, { 0x0009, 10},
1372 { 0x0018, 8}, { 0x0023, 11}, { 0x0017, 8}, { 0x0019, 9}, { 0x0018, 9}, { 0x0007, 10},
1373 { 0x0058, 12}, { 0x0007, 4}, { 0x000C, 6}, { 0x0016, 8}, { 0x0017, 9}, { 0x0006, 10},
1374 { 0x0005, 11}, { 0x0004, 11}, { 0x0059, 12}, { 0x000F, 6}, { 0x0016, 9}, { 0x0005, 10},
1375 { 0x000E, 6}, { 0x0004, 10}, { 0x0011, 7}, { 0x0024, 11}, { 0x0010, 7}, { 0x0025, 11},
1376 { 0x0013, 7}, { 0x005A, 12}, { 0x0015, 8}, { 0x005B, 12}, { 0x0014, 8}, { 0x0013, 8},
1377 { 0x001A, 8}, { 0x0015, 9}, { 0x0014, 9}, { 0x0013, 9}, { 0x0012, 9}, { 0x0011, 9},
1378 { 0x0026, 11}, { 0x0027, 11}, { 0x005C, 12}, { 0x005D, 12}, { 0x005E, 12}, { 0x005F, 12},
1379 { 0x0003, 7}
1380 },
1381 {
1382 { 0x0002, 2}, { 0x000F, 4}, { 0x0015, 6}, { 0x0017, 7}, { 0x001F, 8}, { 0x0025, 9},
1383 { 0x0024, 9}, { 0x0021, 10}, { 0x0020, 10}, { 0x0007, 11}, { 0x0006, 11}, { 0x0020, 11},
1384 { 0x0006, 3}, { 0x0014, 6}, { 0x001E, 8}, { 0x000F, 10}, { 0x0021, 11}, { 0x0050, 12},
1385 { 0x000E, 4}, { 0x001D, 8}, { 0x000E, 10}, { 0x0051, 12}, { 0x000D, 5}, { 0x0023, 9},
1386 { 0x000D, 10}, { 0x000C, 5}, { 0x0022, 9}, { 0x0052, 12}, { 0x000B, 5}, { 0x000C, 10},
1387 { 0x0053, 12}, { 0x0013, 6}, { 0x000B, 10}, { 0x0054, 12}, { 0x0012, 6}, { 0x000A, 10},
1388 { 0x0011, 6}, { 0x0009, 10}, { 0x0010, 6}, { 0x0008, 10}, { 0x0016, 7}, { 0x0055, 12},
1389 { 0x0015, 7}, { 0x0014, 7}, { 0x001C, 8}, { 0x001B, 8}, { 0x0021, 9}, { 0x0020, 9},
1390 { 0x001F, 9}, { 0x001E, 9}, { 0x001D, 9}, { 0x001C, 9}, { 0x001B, 9}, { 0x001A, 9},
1391 { 0x0022, 11}, { 0x0023, 11}, { 0x0056, 12}, { 0x0057, 12}, { 0x0007, 4}, { 0x0019, 9},
1392 { 0x0005, 11}, { 0x000F, 6}, { 0x0004, 11}, { 0x000E, 6}, { 0x000D, 6}, { 0x000C, 6},
1393 { 0x0013, 7}, { 0x0012, 7}, { 0x0011, 7}, { 0x0010, 7}, { 0x001A, 8}, { 0x0019, 8},
1394 { 0x0018, 8}, { 0x0017, 8}, { 0x0016, 8}, { 0x0015, 8}, { 0x0014, 8}, { 0x0013, 8},
1395 { 0x0018, 9}, { 0x0017, 9}, { 0x0016, 9}, { 0x0015, 9}, { 0x0014, 9}, { 0x0013, 9},
1396 { 0x0012, 9}, { 0x0011, 9}, { 0x0007, 10}, { 0x0006, 10}, { 0x0005, 10}, { 0x0004, 10},
1397 { 0x0024, 11}, { 0x0025, 11}, { 0x0026, 11}, { 0x0027, 11}, { 0x0058, 12}, { 0x0059, 12},
1398 { 0x005A, 12}, { 0x005B, 12}, { 0x005C, 12}, { 0x005D, 12}, { 0x005E, 12}, { 0x005F, 12},
1399 { 0x0003, 7}
1400 },
1401 {
1402 { 0x0000, 2}, { 0x0003, 3}, { 0x000D, 4}, { 0x0005, 4}, { 0x001C, 5}, { 0x0016, 5},
1403 { 0x003F, 6}, { 0x003A, 6}, { 0x002E, 6}, { 0x0022, 6}, { 0x007B, 7}, { 0x0067, 7},
1404 { 0x005F, 7}, { 0x0047, 7}, { 0x0026, 7}, { 0x00EF, 8}, { 0x00CD, 8}, { 0x00C1, 8},
1405 { 0x00A9, 8}, { 0x004F, 8}, { 0x01F2, 9}, { 0x01DD, 9}, { 0x0199, 9}, { 0x0185, 9},
1406 { 0x015D, 9}, { 0x011B, 9}, { 0x03EF, 10}, { 0x03E1, 10}, { 0x03C8, 10}, { 0x0331, 10},
1407 { 0x0303, 10}, { 0x02F1, 10}, { 0x02A0, 10}, { 0x0233, 10}, { 0x0126, 10}, { 0x07C0, 11},
1408 { 0x076F, 11}, { 0x076C, 11}, { 0x0661, 11}, { 0x0604, 11}, { 0x0572, 11}, { 0x0551, 11},
1409 { 0x046A, 11}, { 0x0274, 11}, { 0x0F27, 12}, { 0x0F24, 12}, { 0x0EDB, 12}, { 0x0C8E, 12},
1410 { 0x0C0B, 12}, { 0x0C0A, 12}, { 0x0AE3, 12}, { 0x08D6, 12}, { 0x0490, 12}, { 0x0495, 12},
1411 { 0x1F19, 13}, { 0x1DB5, 13}, { 0x0009, 4}, { 0x0010, 5}, { 0x0029, 6}, { 0x0062, 7},
1412 { 0x00F3, 8}, { 0x00AD, 8}, { 0x01E5, 9}, { 0x0179, 9}, { 0x009C, 9}, { 0x03B1, 10},
1413 { 0x02AE, 10}, { 0x0127, 10}, { 0x076E, 11}, { 0x0570, 11}, { 0x0275, 11}, { 0x0F25, 12},
1414 { 0x0EC0, 12}, { 0x0AA0, 12}, { 0x08D7, 12}, { 0x1E4C, 13}, { 0x0008, 5}, { 0x0063, 7},
1415 { 0x00AF, 8}, { 0x017B, 9}, { 0x03B3, 10}, { 0x07DD, 11}, { 0x0640, 11}, { 0x0F8D, 12},
1416 { 0x0BC1, 12}, { 0x0491, 12}, { 0x0028, 6}, { 0x00C3, 8}, { 0x0151, 9}, { 0x02A1, 10},
1417 { 0x0573, 11}, { 0x0EC3, 12}, { 0x1F35, 13}, { 0x0065, 7}, { 0x01DA, 9}, { 0x02AF, 10},
1418 { 0x0277, 11}, { 0x08C9, 12}, { 0x1781, 13}, { 0x0025, 7}, { 0x0118, 9}, { 0x0646, 11},
1419 { 0x0AA6, 12}, { 0x1780, 13}, { 0x00C9, 8}, { 0x0321, 10}, { 0x0F9B, 12}, { 0x191E, 13},
1420 { 0x0048, 8}, { 0x07CC, 11}, { 0x0AA1, 12}, { 0x0180, 9}, { 0x0465, 11}, { 0x1905, 13},
1421 { 0x03E2, 10}, { 0x0EC1, 12}, { 0x3C9B, 14}, { 0x02F4, 10}, { 0x08C8, 12}, { 0x07C1, 11},
1422 { 0x0928, 13}, { 0x05E1, 11}, { 0x320D, 14}, { 0x0EC2, 12}, { 0x6418, 15}, { 0x1F34, 13},
1423 { 0x0078, 7}, { 0x0155, 9}, { 0x0552, 11}, { 0x191F, 13}, { 0x00FA, 8}, { 0x07DC, 11},
1424 { 0x1907, 13}, { 0x00AC, 8}, { 0x0249, 11}, { 0x13B1, 14}, { 0x01F6, 9}, { 0x0AE2, 12},
1425 { 0x01DC, 9}, { 0x04ED, 12}, { 0x0184, 9}, { 0x1904, 13}, { 0x0156, 9}, { 0x09D9, 13},
1426 { 0x03E7, 10}, { 0x0929, 13}, { 0x03B2, 10}, { 0x3B68, 14}, { 0x02F5, 10}, { 0x13B0, 14},
1427 { 0x0322, 10}, { 0x3B69, 14}, { 0x0234, 10}, { 0x7935, 15}, { 0x07C7, 11}, { 0xC833, 16},
1428 { 0x0660, 11}, { 0x7934, 15}, { 0x024B, 11}, { 0xC832, 16}, { 0x0AA7, 12}, { 0x1F18, 13},
1429 { 0x007A, 7}
1430 },
1431 {
1432 { 0x0002, 2}, { 0x0000, 3}, { 0x001E, 5}, { 0x0004, 5}, { 0x0012, 6}, { 0x0070, 7},
1433 { 0x001A, 7}, { 0x005F, 8}, { 0x0047, 8}, { 0x01D3, 9}, { 0x00B5, 9}, { 0x0057, 9},
1434 { 0x03B5, 10}, { 0x016D, 10}, { 0x0162, 10}, { 0x07CE, 11}, { 0x0719, 11}, { 0x0691, 11},
1435 { 0x02C6, 11}, { 0x0156, 11}, { 0x0F92, 12}, { 0x0D2E, 12}, { 0x0D20, 12}, { 0x059E, 12},
1436 { 0x0468, 12}, { 0x02A6, 12}, { 0x1DA2, 13}, { 0x1C60, 13}, { 0x1A43, 13}, { 0x0B1D, 13},
1437 { 0x08C0, 13}, { 0x055D, 13}, { 0x0003, 3}, { 0x000A, 5}, { 0x0077, 7}, { 0x00E5, 8},
1438 { 0x01D9, 9}, { 0x03E5, 10}, { 0x0166, 10}, { 0x0694, 11}, { 0x0152, 11}, { 0x059F, 12},
1439 { 0x1F3C, 13}, { 0x1A4B, 13}, { 0x055E, 13}, { 0x000C, 4}, { 0x007D, 7}, { 0x0044, 8},
1440 { 0x03E0, 10}, { 0x0769, 11}, { 0x0E31, 12}, { 0x1F26, 13}, { 0x055C, 13}, { 0x001B, 5},
1441 { 0x00E2, 8}, { 0x03A5, 10}, { 0x02C9, 11}, { 0x1F23, 13}, { 0x3B47, 14}, { 0x0007, 5},
1442 { 0x01D8, 9}, { 0x02D8, 11}, { 0x1F27, 13}, { 0x3494, 14}, { 0x0035, 6}, { 0x03E1, 10},
1443 { 0x059C, 12}, { 0x38C3, 14}, { 0x000C, 6}, { 0x0165, 10}, { 0x1D23, 13}, { 0x1638, 14},
1444 { 0x0068, 7}, { 0x0693, 11}, { 0x3A45, 14}, { 0x0020, 7}, { 0x0F90, 12}, { 0x7CF6, 15},
1445 { 0x00E8, 8}, { 0x058F, 12}, { 0x2CEF, 15}, { 0x0045, 8}, { 0x0B3A, 13}, { 0x01F1, 9},
1446 { 0x3B46, 14}, { 0x01A7, 9}, { 0x1676, 14}, { 0x0056, 9}, { 0x692A, 15}, { 0x038D, 10},
1447 { 0xE309, 16}, { 0x00AA, 10}, { 0x1C611, 17}, { 0x02DF, 11}, { 0xB3B9, 17}, { 0x02C8, 11},
1448 { 0x38C20, 18}, { 0x01B0, 11}, { 0x16390, 18}, { 0x0F9F, 12}, { 0x16771, 18}, { 0x0ED0, 12},
1449 { 0x71843, 19}, { 0x0D2A, 12}, { 0xF9E8C, 20}, { 0x0461, 12}, { 0xF9E8E, 20}, { 0x0B67, 13},
1450 { 0x055F, 13}, { 0x003F, 6}, { 0x006D, 9}, { 0x0E90, 12}, { 0x054E, 13}, { 0x0013, 6},
1451 { 0x0119, 10}, { 0x0B66, 13}, { 0x000B, 6}, { 0x0235, 11}, { 0x7CF5, 15}, { 0x0075, 7},
1452 { 0x0D24, 12}, { 0xF9E9, 16}, { 0x002E, 7}, { 0x1F22, 13}, { 0x0021, 7}, { 0x054F, 13},
1453 { 0x0014, 7}, { 0x3A44, 14}, { 0x00E4, 8}, { 0x7CF7, 15}, { 0x005E, 8}, { 0x7185, 15},
1454 { 0x0037, 8}, { 0x2C73, 15}, { 0x01DB, 9}, { 0x59DD, 16}, { 0x01C7, 9}, { 0x692B, 15},
1455 { 0x01A6, 9}, { 0x58E5, 16}, { 0x00B4, 9}, { 0x1F3D0, 17}, { 0x00B0, 9}, { 0xB1C9, 17},
1456 { 0x03E6, 10}, { 0x16770, 18}, { 0x016E, 10}, { 0x3E7A2, 18}, { 0x011B, 10}, { 0xF9E8D, 20},
1457 { 0x00D9, 10}, { 0xF9E8F, 20}, { 0x00A8, 10}, { 0x2C723, 19}, { 0x0749, 11}, { 0xE3084, 20},
1458 { 0x0696, 11}, { 0x58E45, 20}, { 0x02DE, 11}, { 0xB1C88, 21}, { 0x0231, 11}, { 0x1C610A, 21},
1459 { 0x01B1, 11}, { 0x71842D, 23}, { 0x0D2B, 12}, { 0x38C217, 22}, { 0x0D2F, 12}, { 0x163913, 22},
1460 { 0x05B2, 12}, { 0x163912, 22}, { 0x0469, 12}, { 0x71842C, 23}, { 0x1A42, 13}, { 0x08C1, 13},
1461 { 0x0073, 7}
1462 }
1463 };
1464 
1465 static const uint16_t vlc_offs[] = {
1466  0, 520, 552, 616, 1128, 1160, 1224, 1740, 1772, 1836, 1900, 2436,
1467  2986, 3050, 3610, 4154, 4218, 4746, 5326, 5390, 5902, 6554, 7658, 8342,
1468  9304, 9988, 10630, 11234, 12174, 13006, 13560, 14232, 14786, 15432, 16350, 17522,
1469  20372, 21818, 22330, 22394, 23166, 23678, 23742, 24820, 25332, 25396, 26460, 26980,
1470  27048, 27592, 27600, 27608, 27616, 27624, 28224, 28258, 28290, 28802, 28834, 28866,
1471  29378, 29412, 29444, 29960, 29994, 30026, 30538, 30572, 30604, 31120, 31154, 31186,
1472  31714, 31746, 31778, 32306, 32340, 32372
1473 };
1474 
1481 {
1482  static int done = 0;
1483  int i = 0;
1484  static VLC_TYPE vlc_table[32372][2];
1485 
1486  v->hrd_rate = v->hrd_buffer = NULL;
1487 
1488  /* VLC tables */
1489  if (!done) {
1491  ff_vc1_bfraction_bits, 1, 1,
1494  ff_vc1_norm2_bits, 1, 1,
1497  ff_vc1_norm6_bits, 1, 1,
1498  ff_vc1_norm6_codes, 2, 2, 556);
1500  ff_vc1_imode_bits, 1, 1,
1502  for (i = 0; i < 3; i++) {
1503  ff_vc1_ttmb_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 0]];
1504  ff_vc1_ttmb_vlc[i].table_allocated = vlc_offs[i * 3 + 1] - vlc_offs[i * 3 + 0];
1506  ff_vc1_ttmb_bits[i], 1, 1,
1508  ff_vc1_ttblk_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 1]];
1509  ff_vc1_ttblk_vlc[i].table_allocated = vlc_offs[i * 3 + 2] - vlc_offs[i * 3 + 1];
1511  ff_vc1_ttblk_bits[i], 1, 1,
1513  ff_vc1_subblkpat_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 2]];
1514  ff_vc1_subblkpat_vlc[i].table_allocated = vlc_offs[i * 3 + 3] - vlc_offs[i * 3 + 2];
1516  ff_vc1_subblkpat_bits[i], 1, 1,
1518  }
1519  for (i = 0; i < 4; i++) {
1520  ff_vc1_4mv_block_pattern_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 9]];
1521  ff_vc1_4mv_block_pattern_vlc[i].table_allocated = vlc_offs[i * 3 + 10] - vlc_offs[i * 3 + 9];
1525  ff_vc1_cbpcy_p_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 10]];
1526  ff_vc1_cbpcy_p_vlc[i].table_allocated = vlc_offs[i * 3 + 11] - vlc_offs[i * 3 + 10];
1528  ff_vc1_cbpcy_p_bits[i], 1, 1,
1530  ff_vc1_mv_diff_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 11]];
1531  ff_vc1_mv_diff_vlc[i].table_allocated = vlc_offs[i * 3 + 12] - vlc_offs[i * 3 + 11];
1533  ff_vc1_mv_diff_bits[i], 1, 1,
1535  }
1536  for (i = 0; i < 8; i++) {
1537  ff_vc1_ac_coeff_table[i].table = &vlc_table[vlc_offs[i * 2 + 21]];
1538  ff_vc1_ac_coeff_table[i].table_allocated = vlc_offs[i * 2 + 22] - vlc_offs[i * 2 + 21];
1540  &vc1_ac_tables[i][0][1], 8, 4,
1541  &vc1_ac_tables[i][0][0], 8, 4, INIT_VLC_USE_NEW_STATIC);
1542  /* initialize interlaced MVDATA tables (2-Ref) */
1543  ff_vc1_2ref_mvdata_vlc[i].table = &vlc_table[vlc_offs[i * 2 + 22]];
1544  ff_vc1_2ref_mvdata_vlc[i].table_allocated = vlc_offs[i * 2 + 23] - vlc_offs[i * 2 + 22];
1546  ff_vc1_2ref_mvdata_bits[i], 1, 1,
1548  }
1549  for (i = 0; i < 4; i++) {
1550  /* initialize 4MV MBMODE VLC tables for interlaced frame P picture */
1551  ff_vc1_intfr_4mv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 37]];
1552  ff_vc1_intfr_4mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 38] - vlc_offs[i * 3 + 37];
1556  /* initialize NON-4MV MBMODE VLC tables for the same */
1557  ff_vc1_intfr_non4mv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 38]];
1558  ff_vc1_intfr_non4mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 39] - vlc_offs[i * 3 + 38];
1562  /* initialize interlaced MVDATA tables (1-Ref) */
1563  ff_vc1_1ref_mvdata_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 39]];
1564  ff_vc1_1ref_mvdata_vlc[i].table_allocated = vlc_offs[i * 3 + 40] - vlc_offs[i * 3 + 39];
1566  ff_vc1_1ref_mvdata_bits[i], 1, 1,
1568  }
1569  for (i = 0; i < 4; i++) {
1570  /* Initialize 2MV Block pattern VLC tables */
1571  ff_vc1_2mv_block_pattern_vlc[i].table = &vlc_table[vlc_offs[i + 49]];
1572  ff_vc1_2mv_block_pattern_vlc[i].table_allocated = vlc_offs[i + 50] - vlc_offs[i + 49];
1576  }
1577  for (i = 0; i < 8; i++) {
1578  /* Initialize interlaced CBPCY VLC tables (Table 124 - Table 131) */
1579  ff_vc1_icbpcy_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 53]];
1580  ff_vc1_icbpcy_vlc[i].table_allocated = vlc_offs[i * 3 + 54] - vlc_offs[i * 3 + 53];
1582  ff_vc1_icbpcy_p_bits[i], 1, 1,
1584  /* Initialize interlaced field picture MBMODE VLC tables */
1585  ff_vc1_if_mmv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 54]];
1586  ff_vc1_if_mmv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 55] - vlc_offs[i * 3 + 54];
1588  ff_vc1_if_mmv_mbmode_bits[i], 1, 1,
1590  ff_vc1_if_1mv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 55]];
1591  ff_vc1_if_1mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 56] - vlc_offs[i * 3 + 55];
1593  ff_vc1_if_1mv_mbmode_bits[i], 1, 1,
1595  }
1596  done = 1;
1597  }
1598 
1599  /* Other defaults */
1600  v->pq = -1;
1601  v->mvrange = 0; /* 7.1.1.18, p80 */
1602 
1603  return 0;
1604 }
int color_prim
8bits, chroma coordinates of the color primaries
Definition: vc1.h:213
static unsigned int show_bits_long(GetBitContext *s, int n)
Show 0-32 bits.
Definition: get_bits.h:327
in the bitstream is reported as 00b
Definition: vc1.h:172
const uint8_t ff_vc1_imode_codes[7]
Definition: vc1data.c:214
int vc1_decode_entry_point(AVCodecContext *avctx, VC1Context *v, GetBitContext *gb)
Definition: vc1.c:527
const uint8_t ff_vc1_icbpcy_p_bits[8][63]
Definition: vc1data.c:793
int use_ic
use intensity compensation in B-frames
Definition: vc1.h:300
#define VC1_TTBLK_VLC_BITS
Definition: vc1data.c:126
BI type.
Definition: avutil.h:302
const uint8_t ff_vc1_mv_pmode_table[2][5]
MV P mode - the 5th element is only used for mode 1.
Definition: vc1data.c:43
uint8_t bfraction_lut_index
Index for BFRACTION value (see Table 40, reproduced into ff_vc1_bfraction_lut[])
Definition: vc1.h:393
int p_frame_skipped
Definition: vc1.h:384
Imode
Imode types.
Definition: vc1.c:54
const uint8_t ff_vc1_mv_diff_bits[4][73]
Definition: vc1data.c:987
uint8_t luty[256]
Definition: vc1.h:299
The VC1 Context.
Definition: vc1.h:181
int vc1_parse_frame_header_adv(VC1Context *v, GetBitContext *gb)
Definition: vc1.c:818
VLC ff_vc1_ttblk_vlc[3]
Definition: vc1data.c:127
#define VC1_ICBPCY_VLC_BITS
Definition: vc1data.c:120
void(* vc1_inv_trans_4x8)(uint8_t *dest, int line_size, DCTELEM *block)
Definition: vc1dsp.h:37
const uint8_t ff_vc1_pquant_table[3][32]
Definition: vc1data.c:89
uint8_t lumscale2
for interlaced field P picture
Definition: vc1.h:341
int k_x
Number of bits for MVs (depends on MV range)
Definition: vc1.h:241
int reffield
if numref = 0 (1 reference) then reffield decides which
Definition: vc1.h:363
const uint8_t ff_vc1_norm2_codes[4]
Definition: vc1data.c:222
const uint8_t ff_vc1_2ref_mvdata_bits[8][126]
Definition: vc1data.c:565
const uint8_t ff_vc1_if_1mv_mbmode_codes[8][6]
Definition: vc1data.c:319
int coded_width
Bitstream width / height, may be different from width/height if lowres enabled.
Definition: avcodec.h:2543
int mv_type_is_raw
mv type mb plane is not coded
Definition: vc1.h:295
const int8_t ff_vc1_adv_progressive_8x4_zz[32]
Definition: vc1data.c:1029
Explicitly specified at frame level.
Definition: vc1.h:62
uint8_t dmvrange
Frame decoding info for interlaced picture.
Definition: vc1.h:338
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:237
#define AC_VLC_BITS
Definition: intrax8.c:34
void ff_simple_idct_8(DCTELEM *block)
int max_b_frames
maximum number of B-frames between non-B-frames Note: The output will be delayed by max_b_frames+1 re...
Definition: avcodec.h:1512
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:117
int tt_index
Index for Transform Type tables (to decode TTMB)
Definition: vc1.h:291
#define VC1_2REF_MVDATA_VLC_BITS
Definition: vc1data.c:140
int extended_mv
Ext MV in P/B (not in Simple)
Definition: vc1.h:229
int broadcast
TFF/RFF present.
Definition: vc1.h:207
int num
numerator
Definition: rational.h:44
int transfer_char
8bits, Opto-electronic transfer characteristics
Definition: vc1.h:214
const uint8_t ff_vc1_4mv_block_pattern_bits[4][16]
Definition: vc1data.c:250
uint8_t rangeredfrm
Frame decoding info for S/M profiles only.
Definition: vc1.h:305
int width
Definition: rotozoom.c:164
Definition: vc1.c:55
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel...
Definition: avcodec.h:1993
const uint8_t ff_vc1_cbpcy_p_bits[4][64]
Definition: vc1data.c:682
const int ff_vc1_fps_nr[7]
Definition: vc1data.c:87
uint8_t luty2[256]
Definition: vc1.h:343
int frfd
Definition: vc1.h:372
#define VLC_TYPE
Definition: get_bits.h:61
mpegvideo header.
int intcompfield
which of the two fields to be intensity compensated
Definition: vc1.h:365
VLC * imv_vlc
Definition: vc1.h:345
uint8_t dqprofile
Definition: vc1.h:252
int fastuvmc
Rounding of qpel vector to hpel ? (not in Simple)
Definition: vc1.h:228
int stride
Definition: mace.c:143
VLC ff_vc1_2ref_mvdata_vlc[8]
Definition: vc1data.c:141
static int bitplane_decoding(uint8_t *data, int *raw_flag, VC1Context *v)
Decode a bitplane's bits.
Definition: vc1.c:116
int frmrtq_postproc
3bits,
Definition: vc1.h:226
#define v(n)
Definition: regs.h:34
static int vop_dquant_decoding(VC1Context *v)
VOP Dquant decoding.
Definition: vc1.c:245
uint8_t rff
Definition: vc1.h:314
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avcodec.h:1398
int hrd_param_flag
Presence of Hypothetical Reference Decoder parameters.
Definition: vc1.h:216
uint8_t lumshift2
Definition: vc1.h:342
const uint8_t ff_vc1_1ref_mvdata_bits[4][72]
Definition: vc1data.c:390
int range_x
Definition: vc1.h:243
#define VC1_4MV_BLOCK_PATTERN_VLC_BITS
Definition: vc1data.c:122
uint8_t dqsbedge
Definition: vc1.h:253
const uint8_t ff_vc1_ttmb_bits[3][16]
Definition: vc1data.c:882
int refdist
distance of the current picture from reference
Definition: vc1.h:360
uint8_t * acpred_plane
AC prediction flags bitplane.
Definition: vc1.h:324
int res_transtab
reserved, always 0
Definition: vc1.h:195
VC-1 tables.
int bi_type
Definition: vc1.h:385
int matrix_coef
8bits, Color primaries->YCbCr transform matrix
Definition: vc1.h:215
const uint8_t ff_vc1_2mv_block_pattern_codes[4][4]
Definition: vc1data.c:258
uint16_t * hrd_rate
Definition: vc1.h:329
const uint8_t ff_vc1_2mv_block_pattern_bits[4][4]
Definition: vc1data.c:262
int panscanflag
NUMPANSCANWIN, TOPLEFT{X,Y}, BOTRIGHT{X,Y} present.
Definition: vc1.h:210
#define INIT_VLC_STATIC(vlc, bits, a, b, c, d, e, f, g, static_size)
Definition: get_bits.h:402
void(* vc1_inv_trans_8x4_dc)(uint8_t *dest, int line_size, DCTELEM *block)
Definition: vc1dsp.h:40
const AVRational ff_vc1_pixel_aspect[16]
Definition: vc1data.c:194
VLC ff_vc1_cbpcy_p_vlc[4]
Definition: vc1data.c:119
void(* vc1_inv_trans_4x8_dc)(uint8_t *dest, int line_size, DCTELEM *block)
Definition: vc1dsp.h:41
int interlace
Progressive/interlaced (RPTFTM syntax element)
Definition: vc1.h:208
const uint16_t ff_vc1_icbpcy_p_codes[8][63]
Definition: vc1data.c:710
int y_ac_table_index
Luma index from AC2FRM element.
Definition: vc1.h:261
int second_field
Definition: vc1.h:359
void(* vc1_inv_trans_8x8)(DCTELEM *b)
Definition: vc1dsp.h:35
int c_ac_table_index
AC coding set indexes.
Definition: vc1.h:260
const int ff_vc1_ac_sizes[AC_MODES]
Definition: vc1data.c:1133
int ttfrm
Transform type info present at frame level.
Definition: vc1.h:263
int resync_marker
could this stream contain resync markers
Definition: mpegvideo.h:546
uint8_t lutuv[256]
lookup tables used for intensity compensation
Definition: vc1.h:299
uint8_t lutuv2[256]
Definition: vc1.h:343
int16_t bfraction
Relative position % anchors=> how to scale MVs.
Definition: vc1.h:278
const uint8_t ff_vc1_if_mmv_mbmode_bits[8][8]
Definition: vc1data.c:308
int profile
Sequence header data for all Profiles TODO: choose between ints, uint8_ts and monobit flags...
Definition: vc1.h:225
const char data[16]
Definition: mxf.c:60
void ff_simple_idct_add_8(uint8_t *dest, int line_size, DCTELEM *block)
MSMPEG4 data tables.
int refdist_flag
REFDIST syntax element present in II, IP, PI or PP field picture headers.
Definition: vc1.h:211
void(* vc1_inv_trans_8x8_dc)(uint8_t *dest, int line_size, DCTELEM *block)
Definition: vc1dsp.h:39
uint8_t * forward_mb_plane
bitplane for "forward" MBs
Definition: vc1.h:294
VLC ff_vc1_norm2_vlc
Definition: vc1data.c:110
int mb_height
number of MBs horizontally & vertically
Definition: mpegvideo.h:237
const uint8_t ff_vc1_imode_bits[7]
Definition: vc1data.c:217
const uint8_t ff_vc1_subblkpat_bits[3][15]
Definition: vc1data.c:930
VLC ff_vc1_4mv_block_pattern_vlc[4]
Definition: vc1data.c:123
int fieldtx_is_raw
Definition: vc1.h:351
Non-uniform quant used for all frames.
Definition: vc1.h:63
uint8_t * over_flags_plane
Overflags bitplane.
Definition: vc1.h:326
uint8_t dqbilevel
Definition: vc1.h:254
int range_y
MV range.
Definition: vc1.h:243
int psf
Progressive Segmented Frame.
Definition: vc1.h:218
uint8_t ttmbf
Transform type flag.
Definition: vc1.h:264
int k_y
Number of bits for MVs (depends on MV range)
Definition: vc1.h:242
static const uint16_t vlc_offs[]
Definition: vc1.c:1465
const int8_t ff_vc1_adv_progressive_4x8_zz[32]
Definition: vc1data.c:1036
Implicitly specified at frame level.
Definition: vc1.h:61
static void decode_colskip(uint8_t *plane, int width, int height, int stride, GetBitContext *gb)
Decode columns by checking if they are skipped.
Definition: vc1.c:93
int dmb_is_raw
direct mb plane is raw
Definition: vc1.h:296
discard all
Definition: avcodec.h:530
#define VC1_CBPCY_P_VLC_BITS
Definition: vc1data.c:118
int res_y411
reserved, old interlaced mode
Definition: vc1.h:191
int overlap
overlapped transforms in use
Definition: vc1.h:232
in the bitstream is reported as 11b
Definition: vc1.h:174
int res_x8
reserved
Definition: vc1.h:192
int qs_last
if qpel has been used in the previous (tr.) picture
Definition: vc1.h:370
void(* vc1_inv_trans_4x4_dc)(uint8_t *dest, int line_size, DCTELEM *block)
Definition: vc1dsp.h:42
TODO: WMV9 specific.
Definition: vc1.h:53
#define VC1_BFRACTION_VLC_BITS
Definition: vc1data.c:105
VLC ff_vc1_imode_vlc
Definition: vc1data.c:108
VLC * mbmode_vlc
Definition: vc1.h:344
int vc1_parse_frame_header(VC1Context *v, GetBitContext *gb)
Definition: vc1.c:575
void av_log(void *avcl, int level, const char *fmt,...)
Definition: log.c:140
int quarter_sample
1->qpel, 0->half pel ME/MC
Definition: mpegvideo.h:534
GetBitContext gb
Definition: mpegvideo.h:603
const int ff_vc1_ttfrm_to_tt[4]
Definition: vc1data.c:40
VLC ff_vc1_norm6_vlc
Definition: vc1data.c:112
uint8_t broken_link
Broken link flag (BROKEN_LINK syntax element)
Definition: vc1.h:394
const uint8_t * zz_8x4
Zigzag scan table for TT_8x4 coding mode.
Definition: vc1.h:247
int postprocflag
Per-frame processing suggestion flag present.
Definition: vc1.h:206
int res_rtm_flag
reserved, set to 1
Definition: vc1.h:198
#define VC1_IF_1MV_MBMODE_VLC_BITS
Definition: vc1data.c:136
static void decode_rowskip(uint8_t *plane, int width, int height, int stride, GetBitContext *gb)
Decode rows by checking if they are skipped.
Definition: vc1.c:71
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)
Reduce a fraction.
Definition: rational.c:36
VLC ff_vc1_ttmb_vlc[3]
Definition: vc1data.c:115
const uint16_t ff_vc1_norm6_codes[64]
Definition: vc1data.c:229
int cur_field_type
0: top, 1: bottom
Definition: vc1.h:367
struct AVRational AVRational
rational number numerator/denominator
VLC * twomvbp_vlc
Definition: vc1.h:346
const uint8_t * zz_4x8
Zigzag scan table for TT_4x8 coding mode.
Definition: vc1.h:248
enum AVPictureType pict_type
Picture type of the frame, see ?_TYPE below.
Definition: avcodec.h:1029
int x8_type
Definition: vc1.h:386
const uint16_t ff_vc1_cbpcy_p_codes[4][64]
Definition: vc1data.c:655
VLC ff_vc1_icbpcy_vlc[8]
Definition: vc1data.c:121
const int ff_vc1_fps_dr[2]
Definition: vc1data.c:88
int tfcntrflag
TFCNTR present.
Definition: vc1.h:209
int field_mode
1 for interlaced field pictures
Definition: vc1.h:357
int width
picture width / height.
Definition: avcodec.h:1408
#define VC1_SUBBLKPAT_VLC_BITS
Definition: vc1data.c:128
uint8_t * mbskip_table
used to avoid copy if macroblock skipped (for black regions for example) and used for b-frame encodin...
Definition: mpegvideo.h:314
void ff_simple_idct84_add(uint8_t *dest, int line_size, DCTELEM *block)
Definition: simple_idct.c:177
uint8_t mv_mode
Frame decoding info for all profiles.
Definition: vc1.h:239
Picture * current_picture_ptr
pointer to the current picture
Definition: mpegvideo.h:299
int fourmvswitch
Definition: vc1.h:339
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
Definition: get_bits.h:251
uint8_t lumscale
Luma compensation parameters.
Definition: vc1.h:275
const uint32_t ff_vc1_1ref_mvdata_codes[4][72]
Definition: vc1data.c:343
static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE(*table)[2], int bits, int max_depth)
Parse a vlc code.
Definition: get_bits.h:481
uint8_t range_mapuv_flag
Definition: vc1.h:332
uint8_t closed_entry
Closed entry point flag (CLOSED_ENTRY syntax element)
Definition: vc1.h:395
int ticks_per_frame
For some codecs, the time base is closer to the field rate than the frame rate.
Definition: avcodec.h:2907
int intcomp
Definition: vc1.h:340
#define INIT_VLC_USE_NEW_STATIC
Definition: get_bits.h:399
uint8_t * fieldtx_plane
Definition: vc1.h:350
VLC * cbpcy_vlc
CBPCY VLC table.
Definition: vc1.h:290
const uint8_t ff_vc1_norm6_bits[64]
Definition: vc1data.c:236
static int decode210(GetBitContext *gb)
Definition: get_bits.h:505
int warn_interlaced
Definition: vc1.h:399
VLC ff_vc1_bfraction_vlc
Definition: vc1data.c:106
int table_allocated
Definition: get_bits.h:66
int rangered
RANGEREDFRM (range reduction) syntax element present at frame level.
Definition: vc1.h:196
int finterpflag
INTERPFRM present.
Definition: vc1.h:234
NULL
Definition: eval.c:50
#define AC_MODES
Definition: vc1data.h:204
static int decode_sequence_header_adv(VC1Context *v, GetBitContext *gb)
Definition: vc1.c:418
int chromaformat
2bits, 2=4:2:0, only defined
Definition: vc1.h:205
int res_sprite
Simple/Main Profile sequence header.
Definition: vc1.h:190
external API header
const uint8_t ff_vc1_ttblk_codes[3][8]
Definition: vc1data.c:913
const uint8_t ff_vc1_4mv_block_pattern_codes[4][16]
Definition: vc1data.c:244
const uint8_t ff_vc1_intfr_non4mv_mbmode_codes[4][9]
Definition: vc1data.c:282
int multires
frame-level RESPIC syntax element present
Definition: vc1.h:193
int ff_vc1_init_common(VC1Context *v)
Init VC-1 specific tables and VC1Context members.
Definition: vc1.c:1480
main external API structure.
Definition: avcodec.h:1329
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:111
uint8_t range_mapy
Definition: vc1.h:333
#define init_vlc(vlc, nb_bits, nb_codes,bits, bits_wrap, bits_size,codes, codes_wrap, codes_size,flags)
Definition: get_bits.h:384
int extended_dmv
Additional extended dmv range at P/B frame-level.
Definition: vc1.h:212
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:268
static void skip_bits1(GetBitContext *s)
Definition: get_bits.h:293
int fmb_is_raw
forward mb plane is raw
Definition: vc1.h:297
void(* vc1_inv_trans_4x4)(uint8_t *dest, int line_size, DCTELEM *block)
Definition: vc1dsp.h:38
int coded_height
Definition: avcodec.h:2543
const uint16_t ff_vc1_ttmb_codes[3][16]
Definition: vc1data.c:852
int fptype
Definition: vc1.h:358
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:260
const uint16_t ff_vc1_intfr_4mv_mbmode_codes[4][15]
Definition: vc1data.c:267
#define VC1_2MV_BLOCK_PATTERN_VLC_BITS
Definition: vc1data.c:124
const uint8_t wmv2_scantableA[64]
Definition: msmpeg4data.c:1989
uint8_t respic
Frame-level flag for resized images.
Definition: vc1.h:280
int skip_is_raw
skip mb plane is not coded
Definition: vc1.h:298
VLC ff_vc1_if_mmv_mbmode_vlc[8]
Definition: vc1data.c:135
#define INIT_LUT(lumscale, lumshift, luty, lutuv)
Definition: vc1.c:800
int quantizer_mode
2bits, quantizer mode used for sequence, see QUANT_*
Definition: vc1.h:233
int ref_field_type[2]
forward and backward reference field type (top or bottom)
Definition: vc1.h:368
uint8_t * direct_mb_plane
bitplane for "direct" MBs
Definition: vc1.h:293
int vc1_decode_sequence_header(AVCodecContext *avctx, VC1Context *v, GetBitContext *gb)
Decode Simple/Main Profiles sequence header.
Definition: vc1.c:294
uint8_t mvrange
Ranges:0 -> [-64n 63.f] x [-32, 31.f]1 -> [-128, 127.f] x [-64, 63.f]2 -> [-512, 511.f] x [-128, 127.f]3 -> [-1024, 1023.f] x [-256, 255.f].
Definition: vc1.h:288
int max_b_frames
max number of b-frames for encoding
Definition: mpegvideo.h:222
int pict_type
AV_PICTURE_TYPE_I, AV_PICTURE_TYPE_P, AV_PICTURE_TYPE_B, ...
Definition: mpegvideo.h:331
uint8_t * mv_type_mb_plane
bitplane for mv_type == (4MV)
Definition: vc1.h:292
int vstransform
variable-size [48]x[48] transform type + info
Definition: vc1.h:231
VLC ff_vc1_if_1mv_mbmode_vlc[8]
Definition: vc1data.c:137
int numref
number of past field pictures used as reference
Definition: vc1.h:361
uint8_t range_mapuv
Definition: vc1.h:334
static const uint16_t scale[4]
uint8_t tff
Definition: vc1.h:314
VLC ff_vc1_mv_diff_vlc[4]
Definition: vc1data.c:117
const uint8_t ff_vc1_intfr_4mv_mbmode_bits[4][15]
Definition: vc1data.c:274
MpegEncContext s
Definition: vc1.h:182
const uint8_t ff_vc1_intfr_non4mv_mbmode_bits[4][9]
Definition: vc1data.c:289
int height
Definition: gxfenc.c:73
in the bitstream is reported as 10b
Definition: vc1.h:173
const uint8_t ff_vc1_bfraction_bits[23]
Definition: vc1data.c:174
struct AVCodecContext * avctx
Definition: mpegvideo.h:203
uint8_t pq
Definition: vc1.h:244
const uint8_t ff_vc1_bfraction_codes[23]
Definition: vc1data.c:183
int pqindex
raw pqindex used in coding set selection
Definition: vc1.h:268
#define VC1_1REF_MVDATA_VLC_BITS
Definition: vc1data.c:138
int hrd_num_leaky_buckets
Definition: vc1.h:321
#define VC1_IF_MMV_MBMODE_VLC_BITS
Definition: vc1data.c:134
common internal api header.
int mb_stride
mb_width+1 used for some arrays to allow simple addressing of left & top MBs without sig11 ...
Definition: mpegvideo.h:238
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:125
VLC ff_vc1_2mv_block_pattern_vlc[4]
Definition: vc1data.c:125
#define VC1_TTMB_VLC_BITS
Definition: vc1data.c:114
static int get_unary(GetBitContext *gb, int stop, int len)
Get unary code of limited length.
Definition: unary.h:33
#define VC1_IMODE_VLC_BITS
Definition: vc1data.c:107
enum FrameCodingMode fcm
Frame decoding info for Advanced profile.
Definition: vc1.h:311
uint8_t dquantfrm
pquant parameters
Definition: vc1.h:251
uint8_t lumshift
Definition: vc1.h:276
Bi-dir predicted.
Definition: avutil.h:298
int res_fasttx
reserved, always 1
Definition: vc1.h:194
enum AVDiscard skip_loop_filter
Definition: avcodec.h:2607
#define VC1_MV_DIFF_VLC_BITS
Definition: vc1data.c:116
int pic_header_flag
Definition: vc1.h:373
int den
denominator
Definition: rational.h:45
#define VC1_NORM2_VLC_BITS
Definition: vc1data.c:109
VLC ff_vc1_ac_coeff_table[8]
Definition: vc1data.c:143
DSP utils.
uint8_t postproc
Definition: vc1.h:320
uint8_t condover
Definition: vc1.h:328
#define VC1_INTFR_4MV_MBMODE_VLC_BITS
Definition: vc1data.c:130
static const uint32_t vc1_ac_tables[AC_MODES][186][2]
Definition: vc1.c:1244
uint8_t uvsamp
Definition: vc1.h:319
uint8_t pquantizer
Uniform (over sequence) quantizer in use.
Definition: vc1.h:289
int rnd
rounding control
Definition: vc1.h:301
simple idct header.
const uint8_t ff_vc1_ttblk_bits[3][8]
Definition: vc1data.c:918
int acpred_is_raw
Definition: vc1.h:325
uint8_t rptfrm
Definition: vc1.h:314
static int decode012(GetBitContext *gb)
Definition: get_bits.h:495
VLC_TYPE(* table)[2]
code, bits
Definition: get_bits.h:65
VLC ff_vc1_1ref_mvdata_vlc[4]
Definition: vc1data.c:139
int bitrtq_postproc
5bits, quantized framerate-based postprocessing strength
Definition: vc1.h:227
int parse_only
Context is used within parser.
Definition: vc1.h:397
int overflg_is_raw
Definition: vc1.h:327
uint8_t interpfrm
Definition: vc1.h:306
struct AVFrame f
Definition: mpegvideo.h:86
void ff_simple_idct44_add(uint8_t *dest, int line_size, DCTELEM *block)
Definition: simple_idct.c:207
Definition: vc1.h:135
const uint8_t ff_vc1_subblkpat_codes[3][15]
Definition: vc1data.c:925
int level
Advanced Profile.
Definition: vc1.h:204
#define VC1_NORM6_VLC_BITS
Definition: vc1data.c:111
#define AV_LOG_INFO
Definition: log.h:119
uint8_t range_mapy_flag
Definition: vc1.h:331
int brfd
reference frame distance (forward or backward)
Definition: vc1.h:372
int dquant
How qscale varies with MBs, 2bits (not in Simple)
Definition: vc1.h:230
uint8_t mv_mode2
Secondary MV coding mode (B frames)
Definition: vc1.h:240
const uint8_t ff_vc1_if_1mv_mbmode_bits[8][6]
Definition: vc1data.c:329
const uint8_t ff_vc1_norm2_bits[4]
Definition: vc1data.c:225
uint16_t * hrd_buffer
Definition: vc1.h:329
int mv_table_index
Definition: mpegvideo.h:585
void av_log_missing_feature(void *avc, const char *feature, int want_sample)
Log a generic warning message about a missing feature.
Definition: utils.c:1714
const uint8_t ff_vc1_if_mmv_mbmode_codes[8][8]
Definition: vc1data.c:298
const uint8_t ff_vc1_mv_pmode_table2[2][4]
Definition: vc1data.c:47
void ff_simple_idct48_add(uint8_t *dest, int line_size, DCTELEM *block)
Definition: simple_idct.c:192
#define VC1_INTFR_NON4MV_MBMODE_VLC_BITS
Definition: vc1data.c:132
void(* vc1_inv_trans_8x4)(uint8_t *dest, int line_size, DCTELEM *block)
Definition: vc1dsp.h:36
VLC * fourmvbp_vlc
Definition: vc1.h:347
VLC ff_vc1_intfr_non4mv_mbmode_vlc[4]
Definition: vc1data.c:133
VLC ff_vc1_intfr_4mv_mbmode_vlc[4]
Definition: vc1data.c:131
const uint8_t wmv2_scantableB[64]
Definition: msmpeg4data.c:1996
int dc_table_index
Definition: mpegvideo.h:588
VLC ff_vc1_subblkpat_vlc[3]
Definition: vc1data.c:129
uint8_t halfpq
Uniform quant over image and qp+.5.
Definition: vc1.h:279
VC1DSPContext vc1dsp
Definition: vc1.h:184
Predicted.
Definition: avutil.h:297
const uint32_t ff_vc1_2ref_mvdata_codes[8][126]
Definition: vc1data.c:418
const uint16_t ff_vc1_mv_diff_codes[4][73]
Definition: vc1data.c:937
const int16_t ff_vc1_bfraction_lut[23]
Definition: vc1data.c:163
uint8_t altpq
Current/alternate frame quantizer scale.
Definition: vc1.h:244