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 {
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  "Old WMV3 version detected, some frames may be decoded incorrectly\n");
399  //return -1;
400  }
401  //TODO: figure out what they mean (always 0x402F)
402  if (!v->res_fasttx)
403  skip_bits(gb, 16);
404  av_log(avctx, AV_LOG_DEBUG,
405  "Profile %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
406  "LoopFilter=%i, MultiRes=%i, FastUVMC=%i, Extended MV=%i\n"
407  "Rangered=%i, VSTransform=%i, Overlap=%i, SyncMarker=%i\n"
408  "DQuant=%i, Quantizer mode=%i, Max B frames=%i\n",
410  v->s.loop_filter, v->multires, v->fastuvmc, v->extended_mv,
411  v->rangered, v->vstransform, v->overlap, v->s.resync_marker,
412  v->dquant, v->quantizer_mode, avctx->max_b_frames);
413  return 0;
414 }
415 
417 {
418  v->res_rtm_flag = 1;
419  v->level = get_bits(gb, 3);
420  if (v->level >= 5) {
421  av_log(v->s.avctx, AV_LOG_ERROR, "Reserved LEVEL %i\n",v->level);
422  }
423  v->chromaformat = get_bits(gb, 2);
424  if (v->chromaformat != 1) {
426  "Only 4:2:0 chroma format supported\n");
427  return -1;
428  }
429 
430  // (fps-2)/4 (->30)
431  v->frmrtq_postproc = get_bits(gb, 3); //common
432  // (bitrate-32kbps)/64kbps
433  v->bitrtq_postproc = get_bits(gb, 5); //common
434  v->postprocflag = get_bits1(gb); //common
435 
436  v->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 
574 {
575  int pqindex, lowquant, status;
576 
577  if (v->finterpflag)
578  v->interpfrm = get_bits1(gb);
579  if (v->s.avctx->codec_id == AV_CODEC_ID_MSS2)
580  v->respic =
581  v->rangered =
582  v->multires = get_bits(gb, 2) == 1;
583  else
584  skip_bits(gb, 2); //framecnt unused
585  v->rangeredfrm = 0;
586  if (v->rangered)
587  v->rangeredfrm = get_bits1(gb);
588  v->s.pict_type = get_bits1(gb);
589  if (v->s.avctx->max_b_frames) {
590  if (!v->s.pict_type) {
591  if (get_bits1(gb))
593  else
595  } else
597  } else
599 
600  v->bi_type = 0;
601  if (v->s.pict_type == AV_PICTURE_TYPE_B) {
604  if (v->bfraction == 0) {
606  }
607  }
609  skip_bits(gb, 7); // skip buffer fullness
610 
611  if (v->parse_only)
612  return 0;
613 
614  /* calculate RND */
616  v->rnd = 1;
617  if (v->s.pict_type == AV_PICTURE_TYPE_P)
618  v->rnd ^= 1;
619 
620  /* Quantizer stuff */
621  pqindex = get_bits(gb, 5);
622  if (!pqindex)
623  return -1;
625  v->pq = ff_vc1_pquant_table[0][pqindex];
626  else
627  v->pq = ff_vc1_pquant_table[1][pqindex];
628 
629  v->pquantizer = 1;
631  v->pquantizer = pqindex < 9;
633  v->pquantizer = 0;
634  v->pqindex = pqindex;
635  if (pqindex < 9)
636  v->halfpq = get_bits1(gb);
637  else
638  v->halfpq = 0;
640  v->pquantizer = get_bits1(gb);
641  v->dquantfrm = 0;
642  if (v->extended_mv == 1)
643  v->mvrange = get_unary(gb, 0, 3);
644  v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
645  v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
646  v->range_x = 1 << (v->k_x - 1);
647  v->range_y = 1 << (v->k_y - 1);
648  if (v->multires && v->s.pict_type != AV_PICTURE_TYPE_B)
649  v->respic = get_bits(gb, 2);
650 
651  if (v->res_x8 && (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)) {
652  v->x8_type = get_bits1(gb);
653  } else
654  v->x8_type = 0;
655  av_dlog(v->s.avctx, "%c Frame: QP=[%i]%i (+%i/2) %i\n",
656  (v->s.pict_type == AV_PICTURE_TYPE_P) ? 'P' : ((v->s.pict_type == AV_PICTURE_TYPE_I) ? 'I' : 'B'),
657  pqindex, v->pq, v->halfpq, v->rangeredfrm);
658 
660  v->use_ic = 0;
661 
662  switch (v->s.pict_type) {
663  case AV_PICTURE_TYPE_P:
664  if (v->pq < 5) v->tt_index = 0;
665  else if (v->pq < 13) v->tt_index = 1;
666  else v->tt_index = 2;
667 
668  lowquant = (v->pq > 12) ? 0 : 1;
669  v->mv_mode = ff_vc1_mv_pmode_table[lowquant][get_unary(gb, 1, 4)];
670  if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
671  int scale, shift, i;
672  v->mv_mode2 = ff_vc1_mv_pmode_table2[lowquant][get_unary(gb, 1, 3)];
673  v->lumscale = get_bits(gb, 6);
674  v->lumshift = get_bits(gb, 6);
675  v->use_ic = 1;
676  /* fill lookup tables for intensity compensation */
677  if (!v->lumscale) {
678  scale = -64;
679  shift = (255 - v->lumshift * 2) << 6;
680  if (v->lumshift > 31)
681  shift += 128 << 6;
682  } else {
683  scale = v->lumscale + 32;
684  if (v->lumshift > 31)
685  shift = (v->lumshift - 64) << 6;
686  else
687  shift = v->lumshift << 6;
688  }
689  for (i = 0; i < 256; i++) {
690  v->luty[i] = av_clip_uint8((scale * i + shift + 32) >> 6);
691  v->lutuv[i] = av_clip_uint8((scale * (i - 128) + 128*64 + 32) >> 6);
692  }
693  }
694  v->qs_last = v->s.quarter_sample;
696  v->s.quarter_sample = 0;
697  else if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
699  v->s.quarter_sample = 0;
700  else
701  v->s.quarter_sample = 1;
702  } else
703  v->s.quarter_sample = 1;
705 
706  if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
707  v->mv_mode2 == MV_PMODE_MIXED_MV) ||
708  v->mv_mode == MV_PMODE_MIXED_MV) {
710  if (status < 0)
711  return -1;
712  av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
713  "Imode: %i, Invert: %i\n", status>>1, status&1);
714  } else {
715  v->mv_type_is_raw = 0;
716  memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
717  }
718  status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
719  if (status < 0)
720  return -1;
721  av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
722  "Imode: %i, Invert: %i\n", status>>1, status&1);
723 
724  /* Hopefully this is correct for P frames */
725  v->s.mv_table_index = get_bits(gb, 2); //but using ff_vc1_ tables
726  v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
727 
728  if (v->dquant) {
729  av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
731  }
732 
733  v->ttfrm = 0; //FIXME Is that so ?
734  if (v->vstransform) {
735  v->ttmbf = get_bits1(gb);
736  if (v->ttmbf) {
737  v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
738  }
739  } else {
740  v->ttmbf = 1;
741  v->ttfrm = TT_8X8;
742  }
743  break;
744  case AV_PICTURE_TYPE_B:
745  if (v->pq < 5) v->tt_index = 0;
746  else if (v->pq < 13) v->tt_index = 1;
747  else v->tt_index = 2;
748 
750  v->qs_last = v->s.quarter_sample;
751  v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
752  v->s.mspel = v->s.quarter_sample;
753 
754  status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
755  if (status < 0)
756  return -1;
757  av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
758  "Imode: %i, Invert: %i\n", status>>1, status&1);
759  status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
760  if (status < 0)
761  return -1;
762  av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
763  "Imode: %i, Invert: %i\n", status>>1, status&1);
764 
765  v->s.mv_table_index = get_bits(gb, 2);
766  v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
767 
768  if (v->dquant) {
769  av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
771  }
772 
773  v->ttfrm = 0;
774  if (v->vstransform) {
775  v->ttmbf = get_bits1(gb);
776  if (v->ttmbf) {
777  v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
778  }
779  } else {
780  v->ttmbf = 1;
781  v->ttfrm = TT_8X8;
782  }
783  break;
784  }
785 
786  if (!v->x8_type) {
787  /* AC Syntax */
788  v->c_ac_table_index = decode012(gb);
790  v->y_ac_table_index = decode012(gb);
791  }
792  /* DC Syntax */
793  v->s.dc_table_index = get_bits1(gb);
794  }
795 
796  if (v->s.pict_type == AV_PICTURE_TYPE_BI) {
798  v->bi_type = 1;
799  }
800  return 0;
801 }
802 
803 /* fill lookup tables for intensity compensation */
804 #define INIT_LUT(lumscale, lumshift, luty, lutuv) \
805  if (!lumscale) { \
806  scale = -64; \
807  shift = (255 - lumshift * 2) << 6; \
808  if (lumshift > 31) \
809  shift += 128 << 6; \
810  } else { \
811  scale = lumscale + 32; \
812  if (lumshift > 31) \
813  shift = (lumshift - 64) << 6; \
814  else \
815  shift = lumshift << 6; \
816  } \
817  for (i = 0; i < 256; i++) { \
818  luty[i] = av_clip_uint8((scale * i + shift + 32) >> 6); \
819  lutuv[i] = av_clip_uint8((scale * (i - 128) + 128*64 + 32) >> 6); \
820  }
821 
823 {
824  int pqindex, lowquant;
825  int status;
826  int mbmodetab, imvtab, icbptab, twomvbptab, fourmvbptab; /* useful only for debugging */
827  int scale, shift, i; /* for initializing LUT for intensity compensation */
828 
829  v->p_frame_skipped = 0;
830  if (v->second_field) {
832  if (v->fptype & 4)
835  if (!v->pic_header_flag)
836  goto parse_common_info;
837  }
838 
839  v->field_mode = 0;
840  if (v->interlace) {
841  v->fcm = decode012(gb);
842  if (v->fcm) {
843  if (v->fcm == ILACE_FIELD)
844  v->field_mode = 1;
845  if (!v->warn_interlaced++)
847  "Interlaced frames/fields support is incomplete\n");
848  }
849  } else {
850  v->fcm = PROGRESSIVE;
851  }
852 
853  if (v->field_mode) {
854  v->fptype = get_bits(gb, 3);
856  if (v->fptype & 4) // B-picture
858  } else {
859  switch (get_unary(gb, 0, 4)) {
860  case 0:
862  break;
863  case 1:
865  break;
866  case 2:
868  break;
869  case 3:
871  break;
872  case 4:
873  v->s.pict_type = AV_PICTURE_TYPE_P; // skipped pic
874  v->p_frame_skipped = 1;
875  break;
876  }
877  }
878  if (v->tfcntrflag)
879  skip_bits(gb, 8);
880  if (v->broadcast) {
881  if (!v->interlace || v->psf) {
882  v->rptfrm = get_bits(gb, 2);
883  } else {
884  v->tff = get_bits1(gb);
885  v->rff = get_bits1(gb);
886  }
887  }
888  if (v->panscanflag) {
889  av_log_missing_feature(v->s.avctx, "Pan-scan", 0);
890  //...
891  }
892  if (v->p_frame_skipped) {
893  return 0;
894  }
895  v->rnd = get_bits1(gb);
896  if (v->interlace)
897  v->uvsamp = get_bits1(gb);
898  if (v->field_mode) {
899  if (!v->refdist_flag)
900  v->refdist = 0;
901  else if ((v->s.pict_type != AV_PICTURE_TYPE_B) && (v->s.pict_type != AV_PICTURE_TYPE_BI)) {
902  v->refdist = get_bits(gb, 2);
903  if (v->refdist == 3)
904  v->refdist += get_unary(gb, 0, 16);
905  }
906  if ((v->s.pict_type == AV_PICTURE_TYPE_B) || (v->s.pict_type == AV_PICTURE_TYPE_BI)) {
909  v->frfd = (v->bfraction * v->refdist) >> 8;
910  v->brfd = v->refdist - v->frfd - 1;
911  if (v->brfd < 0)
912  v->brfd = 0;
913  }
914  goto parse_common_info;
915  }
916  if (v->fcm == PROGRESSIVE) {
917  if (v->finterpflag)
918  v->interpfrm = get_bits1(gb);
919  if (v->s.pict_type == AV_PICTURE_TYPE_B) {
922  if (v->bfraction == 0) {
923  v->s.pict_type = AV_PICTURE_TYPE_BI; /* XXX: should not happen here */
924  }
925  }
926  }
927 
928  parse_common_info:
929  if (v->field_mode)
930  v->cur_field_type = !(v->tff ^ v->second_field);
931  pqindex = get_bits(gb, 5);
932  if (!pqindex)
933  return -1;
934  v->pqindex = pqindex;
936  v->pq = ff_vc1_pquant_table[0][pqindex];
937  else
938  v->pq = ff_vc1_pquant_table[1][pqindex];
939 
940  v->pquantizer = 1;
942  v->pquantizer = pqindex < 9;
944  v->pquantizer = 0;
945  v->pqindex = pqindex;
946  if (pqindex < 9)
947  v->halfpq = get_bits1(gb);
948  else
949  v->halfpq = 0;
951  v->pquantizer = get_bits1(gb);
952  if (v->postprocflag)
953  v->postproc = get_bits(gb, 2);
954 
956  v->use_ic = 0;
957 
958  if (v->parse_only)
959  return 0;
960 
961  switch (v->s.pict_type) {
962  case AV_PICTURE_TYPE_I:
963  case AV_PICTURE_TYPE_BI:
964  if (v->fcm == ILACE_FRAME) { //interlace frame picture
965  status = bitplane_decoding(v->fieldtx_plane, &v->fieldtx_is_raw, v);
966  if (status < 0)
967  return -1;
968  av_log(v->s.avctx, AV_LOG_DEBUG, "FIELDTX plane encoding: "
969  "Imode: %i, Invert: %i\n", status>>1, status&1);
970  }
971  status = bitplane_decoding(v->acpred_plane, &v->acpred_is_raw, v);
972  if (status < 0)
973  return -1;
974  av_log(v->s.avctx, AV_LOG_DEBUG, "ACPRED plane encoding: "
975  "Imode: %i, Invert: %i\n", status>>1, status&1);
976  v->condover = CONDOVER_NONE;
977  if (v->overlap && v->pq <= 8) {
978  v->condover = decode012(gb);
979  if (v->condover == CONDOVER_SELECT) {
981  if (status < 0)
982  return -1;
983  av_log(v->s.avctx, AV_LOG_DEBUG, "CONDOVER plane encoding: "
984  "Imode: %i, Invert: %i\n", status>>1, status&1);
985  }
986  }
987  break;
988  case AV_PICTURE_TYPE_P:
989  if (v->field_mode) {
990  v->numref = get_bits1(gb);
991  if (!v->numref) {
992  v->reffield = get_bits1(gb);
993  v->ref_field_type[0] = v->reffield ^ !v->cur_field_type;
994  }
995  }
996  if (v->extended_mv)
997  v->mvrange = get_unary(gb, 0, 3);
998  else
999  v->mvrange = 0;
1000  if (v->interlace) {
1001  if (v->extended_dmv)
1002  v->dmvrange = get_unary(gb, 0, 3);
1003  else
1004  v->dmvrange = 0;
1005  if (v->fcm == ILACE_FRAME) { // interlaced frame picture
1006  v->fourmvswitch = get_bits1(gb);
1007  v->intcomp = get_bits1(gb);
1008  if (v->intcomp) {
1009  v->lumscale = get_bits(gb, 6);
1010  v->lumshift = get_bits(gb, 6);
1011  INIT_LUT(v->lumscale, v->lumshift, v->luty, v->lutuv);
1012  }
1013  status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1014  av_log(v->s.avctx, AV_LOG_DEBUG, "SKIPMB plane encoding: "
1015  "Imode: %i, Invert: %i\n", status>>1, status&1);
1016  mbmodetab = get_bits(gb, 2);
1017  if (v->fourmvswitch)
1018  v->mbmode_vlc = &ff_vc1_intfr_4mv_mbmode_vlc[mbmodetab];
1019  else
1020  v->mbmode_vlc = &ff_vc1_intfr_non4mv_mbmode_vlc[mbmodetab];
1021  imvtab = get_bits(gb, 2);
1022  v->imv_vlc = &ff_vc1_1ref_mvdata_vlc[imvtab];
1023  // interlaced p-picture cbpcy range is [1, 63]
1024  icbptab = get_bits(gb, 3);
1025  v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
1026  twomvbptab = get_bits(gb, 2);
1027  v->twomvbp_vlc = &ff_vc1_2mv_block_pattern_vlc[twomvbptab];
1028  if (v->fourmvswitch) {
1029  fourmvbptab = get_bits(gb, 2);
1030  v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
1031  }
1032  }
1033  }
1034  v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1035  v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
1036  v->range_x = 1 << (v->k_x - 1);
1037  v->range_y = 1 << (v->k_y - 1);
1038 
1039  if (v->pq < 5)
1040  v->tt_index = 0;
1041  else if (v->pq < 13)
1042  v->tt_index = 1;
1043  else
1044  v->tt_index = 2;
1045  if (v->fcm != ILACE_FRAME) {
1046  int mvmode;
1047  mvmode = get_unary(gb, 1, 4);
1048  lowquant = (v->pq > 12) ? 0 : 1;
1049  v->mv_mode = ff_vc1_mv_pmode_table[lowquant][mvmode];
1050  if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
1051  int mvmode2;
1052  mvmode2 = get_unary(gb, 1, 3);
1053  v->mv_mode2 = ff_vc1_mv_pmode_table2[lowquant][mvmode2];
1054  if (v->field_mode)
1055  v->intcompfield = decode210(gb);
1056  v->lumscale = get_bits(gb, 6);
1057  v->lumshift = get_bits(gb, 6);
1058  INIT_LUT(v->lumscale, v->lumshift, v->luty, v->lutuv);
1059  if ((v->field_mode) && !v->intcompfield) {
1060  v->lumscale2 = get_bits(gb, 6);
1061  v->lumshift2 = get_bits(gb, 6);
1062  INIT_LUT(v->lumscale2, v->lumshift2, v->luty2, v->lutuv2);
1063  }
1064  v->use_ic = 1;
1065  }
1066  v->qs_last = v->s.quarter_sample;
1068  v->s.quarter_sample = 0;
1069  else if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
1071  v->s.quarter_sample = 0;
1072  else
1073  v->s.quarter_sample = 1;
1074  } else
1075  v->s.quarter_sample = 1;
1076  v->s.mspel = !(v->mv_mode == MV_PMODE_1MV_HPEL_BILIN
1078  && v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN));
1079  }
1080  if (v->fcm == PROGRESSIVE) { // progressive
1081  if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
1083  || v->mv_mode == MV_PMODE_MIXED_MV) {
1084  status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);
1085  if (status < 0)
1086  return -1;
1087  av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
1088  "Imode: %i, Invert: %i\n", status>>1, status&1);
1089  } else {
1090  v->mv_type_is_raw = 0;
1091  memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
1092  }
1093  status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1094  if (status < 0)
1095  return -1;
1096  av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1097  "Imode: %i, Invert: %i\n", status>>1, status&1);
1098 
1099  /* Hopefully this is correct for P frames */
1100  v->s.mv_table_index = get_bits(gb, 2); //but using ff_vc1_ tables
1101  v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
1102  } else if (v->fcm == ILACE_FRAME) { // frame interlaced
1103  v->qs_last = v->s.quarter_sample;
1104  v->s.quarter_sample = 1;
1105  v->s.mspel = 1;
1106  } else { // field interlaced
1107  mbmodetab = get_bits(gb, 3);
1108  imvtab = get_bits(gb, 2 + v->numref);
1109  if (!v->numref)
1110  v->imv_vlc = &ff_vc1_1ref_mvdata_vlc[imvtab];
1111  else
1112  v->imv_vlc = &ff_vc1_2ref_mvdata_vlc[imvtab];
1113  icbptab = get_bits(gb, 3);
1114  v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
1115  if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
1117  fourmvbptab = get_bits(gb, 2);
1118  v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
1119  v->mbmode_vlc = &ff_vc1_if_mmv_mbmode_vlc[mbmodetab];
1120  } else {
1121  v->mbmode_vlc = &ff_vc1_if_1mv_mbmode_vlc[mbmodetab];
1122  }
1123  }
1124  if (v->dquant) {
1125  av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1127  }
1128 
1129  v->ttfrm = 0; //FIXME Is that so ?
1130  if (v->vstransform) {
1131  v->ttmbf = get_bits1(gb);
1132  if (v->ttmbf) {
1133  v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
1134  }
1135  } else {
1136  v->ttmbf = 1;
1137  v->ttfrm = TT_8X8;
1138  }
1139  break;
1140  case AV_PICTURE_TYPE_B:
1141  // TODO: implement interlaced frame B picture decoding
1142  if (v->fcm == ILACE_FRAME)
1143  return -1;
1144  if (v->extended_mv)
1145  v->mvrange = get_unary(gb, 0, 3);
1146  else
1147  v->mvrange = 0;
1148  v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1149  v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
1150  v->range_x = 1 << (v->k_x - 1);
1151  v->range_y = 1 << (v->k_y - 1);
1152 
1153  if (v->pq < 5)
1154  v->tt_index = 0;
1155  else if (v->pq < 13)
1156  v->tt_index = 1;
1157  else
1158  v->tt_index = 2;
1159 
1160  if (v->field_mode) {
1161  int mvmode;
1162  if (v->extended_dmv)
1163  v->dmvrange = get_unary(gb, 0, 3);
1164  mvmode = get_unary(gb, 1, 3);
1165  lowquant = (v->pq > 12) ? 0 : 1;
1166  v->mv_mode = ff_vc1_mv_pmode_table2[lowquant][mvmode];
1167  v->qs_last = v->s.quarter_sample;
1170  status = bitplane_decoding(v->forward_mb_plane, &v->fmb_is_raw, v);
1171  if (status < 0)
1172  return -1;
1173  av_log(v->s.avctx, AV_LOG_DEBUG, "MB Forward Type plane encoding: "
1174  "Imode: %i, Invert: %i\n", status>>1, status&1);
1175  mbmodetab = get_bits(gb, 3);
1176  if (v->mv_mode == MV_PMODE_MIXED_MV)
1177  v->mbmode_vlc = &ff_vc1_if_mmv_mbmode_vlc[mbmodetab];
1178  else
1179  v->mbmode_vlc = &ff_vc1_if_1mv_mbmode_vlc[mbmodetab];
1180  imvtab = get_bits(gb, 3);
1181  v->imv_vlc = &ff_vc1_2ref_mvdata_vlc[imvtab];
1182  icbptab = get_bits(gb, 3);
1183  v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
1184  if (v->mv_mode == MV_PMODE_MIXED_MV) {
1185  fourmvbptab = get_bits(gb, 2);
1186  v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
1187  }
1188  v->numref = 1; // interlaced field B pictures are always 2-ref
1189  } else {
1191  v->qs_last = v->s.quarter_sample;
1192  v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
1193  v->s.mspel = v->s.quarter_sample;
1194  status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
1195  if (status < 0)
1196  return -1;
1197  av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
1198  "Imode: %i, Invert: %i\n", status>>1, status&1);
1199  status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1200  if (status < 0)
1201  return -1;
1202  av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1203  "Imode: %i, Invert: %i\n", status>>1, status&1);
1204  v->s.mv_table_index = get_bits(gb, 2);
1205  v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
1206  }
1207 
1208  if (v->dquant) {
1209  av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1211  }
1212 
1213  v->ttfrm = 0;
1214  if (v->vstransform) {
1215  v->ttmbf = get_bits1(gb);
1216  if (v->ttmbf) {
1217  v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
1218  }
1219  } else {
1220  v->ttmbf = 1;
1221  v->ttfrm = TT_8X8;
1222  }
1223  break;
1224  }
1225 
1226  if (v->fcm != PROGRESSIVE && !v->s.quarter_sample) {
1227  v->range_x <<= 1;
1228  v->range_y <<= 1;
1229  }
1230 
1231  /* AC Syntax */
1232  v->c_ac_table_index = decode012(gb);
1234  v->y_ac_table_index = decode012(gb);
1235  }
1236  /* DC Syntax */
1237  v->s.dc_table_index = get_bits1(gb);
1239  && v->dquant) {
1240  av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1242  }
1243 
1244  v->bi_type = 0;
1245  if (v->s.pict_type == AV_PICTURE_TYPE_BI) {
1247  v->bi_type = 1;
1248  }
1249  return 0;
1250 }
1251 
1252 static const uint32_t vc1_ac_tables[AC_MODES][186][2] = {
1253 {
1254 { 0x0001, 2}, { 0x0005, 3}, { 0x000D, 4}, { 0x0012, 5}, { 0x000E, 6}, { 0x0015, 7},
1255 { 0x0013, 8}, { 0x003F, 8}, { 0x004B, 9}, { 0x011F, 9}, { 0x00B8, 10}, { 0x03E3, 10},
1256 { 0x0172, 11}, { 0x024D, 12}, { 0x03DA, 12}, { 0x02DD, 13}, { 0x1F55, 13}, { 0x05B9, 14},
1257 { 0x3EAE, 14}, { 0x0000, 4}, { 0x0010, 5}, { 0x0008, 7}, { 0x0020, 8}, { 0x0029, 9},
1258 { 0x01F4, 9}, { 0x0233, 10}, { 0x01E0, 11}, { 0x012A, 12}, { 0x03DD, 12}, { 0x050A, 13},
1259 { 0x1F29, 13}, { 0x0A42, 14}, { 0x1272, 15}, { 0x1737, 15}, { 0x0003, 5}, { 0x0011, 7},
1260 { 0x00C4, 8}, { 0x004B, 10}, { 0x00B4, 11}, { 0x07D4, 11}, { 0x0345, 12}, { 0x02D7, 13},
1261 { 0x07BF, 13}, { 0x0938, 14}, { 0x0BBB, 14}, { 0x095E, 15}, { 0x0013, 5}, { 0x0078, 7},
1262 { 0x0069, 9}, { 0x0232, 10}, { 0x0461, 11}, { 0x03EC, 12}, { 0x0520, 13}, { 0x1F2A, 13},
1263 { 0x3E50, 14}, { 0x3E51, 14}, { 0x1486, 15}, { 0x000C, 6}, { 0x0024, 9}, { 0x0094, 11},
1264 { 0x08C0, 12}, { 0x0F09, 14}, { 0x1EF0, 15}, { 0x003D, 6}, { 0x0053, 9}, { 0x01A0, 11},
1265 { 0x02D6, 13}, { 0x0F08, 14}, { 0x0013, 7}, { 0x007C, 9}, { 0x07C1, 11}, { 0x04AC, 14},
1266 { 0x001B, 7}, { 0x00A0, 10}, { 0x0344, 12}, { 0x0F79, 14}, { 0x0079, 7}, { 0x03E1, 10},
1267 { 0x02D4, 13}, { 0x2306, 14}, { 0x0021, 8}, { 0x023C, 10}, { 0x0FAE, 12}, { 0x23DE, 14},
1268 { 0x0035, 8}, { 0x0175, 11}, { 0x07B3, 13}, { 0x00C5, 8}, { 0x0174, 11}, { 0x0785, 13},
1269 { 0x0048, 9}, { 0x01A3, 11}, { 0x049E, 13}, { 0x002C, 9}, { 0x00FA, 10}, { 0x07D6, 11},
1270 { 0x0092, 10}, { 0x05CC, 13}, { 0x1EF1, 15}, { 0x00A3, 10}, { 0x03ED, 12}, { 0x093E, 14},
1271 { 0x01E2, 11}, { 0x1273, 15}, { 0x07C4, 11}, { 0x1487, 15}, { 0x0291, 12}, { 0x0293, 12},
1272 { 0x0F8A, 12}, { 0x0509, 13}, { 0x0508, 13}, { 0x078D, 13}, { 0x07BE, 13}, { 0x078C, 13},
1273 { 0x04AE, 14}, { 0x0BBA, 14}, { 0x2307, 14}, { 0x0B9A, 14}, { 0x1736, 15}, { 0x000E, 4},
1274 { 0x0045, 7}, { 0x01F3, 9}, { 0x047A, 11}, { 0x05DC, 13}, { 0x23DF, 14}, { 0x0019, 5},
1275 { 0x0028, 9}, { 0x0176, 11}, { 0x049D, 13}, { 0x23DD, 14}, { 0x0030, 6}, { 0x00A2, 10},
1276 { 0x02EF, 12}, { 0x05B8, 14}, { 0x003F, 6}, { 0x00A5, 10}, { 0x03DB, 12}, { 0x093F, 14},
1277 { 0x0044, 7}, { 0x07CB, 11}, { 0x095F, 15}, { 0x0063, 7}, { 0x03C3, 12}, { 0x0015, 8},
1278 { 0x08F6, 12}, { 0x0017, 8}, { 0x0498, 13}, { 0x002C, 8}, { 0x07B2, 13}, { 0x002F, 8},
1279 { 0x1F54, 13}, { 0x008D, 8}, { 0x07BD, 13}, { 0x008E, 8}, { 0x1182, 13}, { 0x00FB, 8},
1280 { 0x050B, 13}, { 0x002D, 8}, { 0x07C0, 11}, { 0x0079, 9}, { 0x1F5F, 13}, { 0x007A, 9},
1281 { 0x1F56, 13}, { 0x0231, 10}, { 0x03E4, 10}, { 0x01A1, 11}, { 0x0143, 11}, { 0x01F7, 11},
1282 { 0x016F, 12}, { 0x0292, 12}, { 0x02E7, 12}, { 0x016C, 12}, { 0x016D, 12}, { 0x03DC, 12},
1283 { 0x0F8B, 12}, { 0x0499, 13}, { 0x03D8, 12}, { 0x078E, 13}, { 0x02D5, 13}, { 0x1F5E, 13},
1284 { 0x1F2B, 13}, { 0x078F, 13}, { 0x04AD, 14}, { 0x3EAF, 14}, { 0x23DC, 14}, { 0x004A, 9}
1285 },
1286 {
1287 { 0x0000, 3}, { 0x0003, 4}, { 0x000B, 5}, { 0x0014, 6}, { 0x003F, 6}, { 0x005D, 7},
1288 { 0x00A2, 8}, { 0x00AC, 9}, { 0x016E, 9}, { 0x020A, 10}, { 0x02E2, 10}, { 0x0432, 11},
1289 { 0x05C9, 11}, { 0x0827, 12}, { 0x0B54, 12}, { 0x04E6, 13}, { 0x105F, 13}, { 0x172A, 13},
1290 { 0x20B2, 14}, { 0x2D4E, 14}, { 0x39F0, 14}, { 0x4175, 15}, { 0x5A9E, 15}, { 0x0004, 4},
1291 { 0x001E, 5}, { 0x0042, 7}, { 0x00B6, 8}, { 0x0173, 9}, { 0x0395, 10}, { 0x072E, 11},
1292 { 0x0B94, 12}, { 0x16A4, 13}, { 0x20B3, 14}, { 0x2E45, 14}, { 0x0005, 5}, { 0x0040, 7},
1293 { 0x0049, 9}, { 0x028F, 10}, { 0x05CB, 11}, { 0x048A, 13}, { 0x09DD, 14}, { 0x73E2, 15},
1294 { 0x0018, 5}, { 0x0025, 8}, { 0x008A, 10}, { 0x051B, 11}, { 0x0E5F, 12}, { 0x09C9, 14},
1295 { 0x139C, 15}, { 0x0029, 6}, { 0x004F, 9}, { 0x0412, 11}, { 0x048D, 13}, { 0x2E41, 14},
1296 { 0x0038, 6}, { 0x010E, 9}, { 0x05A8, 11}, { 0x105C, 13}, { 0x39F2, 14}, { 0x0058, 7},
1297 { 0x021F, 10}, { 0x0E7E, 12}, { 0x39FF, 14}, { 0x0023, 8}, { 0x02E3, 10}, { 0x04E5, 13},
1298 { 0x2E40, 14}, { 0x00A1, 8}, { 0x05BE, 11}, { 0x09C8, 14}, { 0x0083, 8}, { 0x013A, 11},
1299 { 0x1721, 13}, { 0x0044, 9}, { 0x0276, 12}, { 0x39F6, 14}, { 0x008B, 10}, { 0x04EF, 13},
1300 { 0x5A9B, 15}, { 0x0208, 10}, { 0x1CFE, 13}, { 0x0399, 10}, { 0x1CB4, 13}, { 0x039E, 10},
1301 { 0x39F3, 14}, { 0x05AB, 11}, { 0x73E3, 15}, { 0x0737, 11}, { 0x5A9F, 15}, { 0x082D, 12},
1302 { 0x0E69, 12}, { 0x0E68, 12}, { 0x0433, 11}, { 0x0B7B, 12}, { 0x2DF8, 14}, { 0x2E56, 14},
1303 { 0x2E57, 14}, { 0x39F7, 14}, { 0x51A5, 15}, { 0x0003, 3}, { 0x002A, 6}, { 0x00E4, 8},
1304 { 0x028E, 10}, { 0x0735, 11}, { 0x1058, 13}, { 0x1CFA, 13}, { 0x2DF9, 14}, { 0x4174, 15},
1305 { 0x0009, 4}, { 0x0054, 8}, { 0x0398, 10}, { 0x048B, 13}, { 0x139D, 15}, { 0x000D, 4},
1306 { 0x00AD, 9}, { 0x0826, 12}, { 0x2D4C, 14}, { 0x0011, 5}, { 0x016B, 9}, { 0x0B7F, 12},
1307 { 0x51A4, 15}, { 0x0019, 5}, { 0x021B, 10}, { 0x16FD, 13}, { 0x001D, 5}, { 0x0394, 10},
1308 { 0x28D3, 14}, { 0x002B, 6}, { 0x05BC, 11}, { 0x5A9A, 15}, { 0x002F, 6}, { 0x0247, 12},
1309 { 0x0010, 7}, { 0x0A35, 12}, { 0x003E, 6}, { 0x0B7A, 12}, { 0x0059, 7}, { 0x105E, 13},
1310 { 0x0026, 8}, { 0x09CF, 14}, { 0x0055, 8}, { 0x1CB5, 13}, { 0x0057, 8}, { 0x0E5B, 12},
1311 { 0x00A0, 8}, { 0x1468, 13}, { 0x0170, 9}, { 0x0090, 10}, { 0x01CE, 9}, { 0x021A, 10},
1312 { 0x0218, 10}, { 0x0168, 9}, { 0x021E, 10}, { 0x0244, 12}, { 0x0736, 11}, { 0x0138, 11},
1313 { 0x0519, 11}, { 0x0E5E, 12}, { 0x072C, 11}, { 0x0B55, 12}, { 0x09DC, 14}, { 0x20BB, 14},
1314 { 0x048C, 13}, { 0x1723, 13}, { 0x2E44, 14}, { 0x16A5, 13}, { 0x0518, 11}, { 0x39FE, 14},
1315 { 0x0169, 9}
1316 },
1317 {
1318 { 0x0001, 2}, { 0x0006, 3}, { 0x000F, 4}, { 0x0016, 5}, { 0x0020, 6}, { 0x0018, 7},
1319 { 0x0008, 8}, { 0x009A, 8}, { 0x0056, 9}, { 0x013E, 9}, { 0x00F0, 10}, { 0x03A5, 10},
1320 { 0x0077, 11}, { 0x01EF, 11}, { 0x009A, 12}, { 0x005D, 13}, { 0x0001, 4}, { 0x0011, 5},
1321 { 0x0002, 7}, { 0x000B, 8}, { 0x0012, 9}, { 0x01D6, 9}, { 0x027E, 10}, { 0x0191, 11},
1322 { 0x00EA, 12}, { 0x03DC, 12}, { 0x013B, 13}, { 0x0004, 5}, { 0x0014, 7}, { 0x009E, 8},
1323 { 0x0009, 10}, { 0x01AC, 11}, { 0x01E2, 11}, { 0x03CA, 12}, { 0x005F, 13}, { 0x0017, 5},
1324 { 0x004E, 7}, { 0x005E, 9}, { 0x00F3, 10}, { 0x01AD, 11}, { 0x00EC, 12}, { 0x05F0, 13},
1325 { 0x000E, 6}, { 0x00E1, 8}, { 0x03A4, 10}, { 0x009C, 12}, { 0x013D, 13}, { 0x003B, 6},
1326 { 0x001C, 9}, { 0x0014, 11}, { 0x09BE, 12}, { 0x0006, 7}, { 0x007A, 9}, { 0x0190, 11},
1327 { 0x0137, 13}, { 0x001B, 7}, { 0x0008, 10}, { 0x075C, 11}, { 0x0071, 7}, { 0x00D7, 10},
1328 { 0x09BF, 12}, { 0x0007, 8}, { 0x00AF, 10}, { 0x04CC, 11}, { 0x0034, 8}, { 0x0265, 10},
1329 { 0x009F, 12}, { 0x00E0, 8}, { 0x0016, 11}, { 0x0327, 12}, { 0x0015, 9}, { 0x017D, 11},
1330 { 0x0EBB, 12}, { 0x0014, 9}, { 0x00F6, 10}, { 0x01E4, 11}, { 0x00CB, 10}, { 0x099D, 12},
1331 { 0x00CA, 10}, { 0x02FC, 12}, { 0x017F, 11}, { 0x04CD, 11}, { 0x02FD, 12}, { 0x04FE, 11},
1332 { 0x013A, 13}, { 0x000A, 4}, { 0x0042, 7}, { 0x01D3, 9}, { 0x04DD, 11}, { 0x0012, 5},
1333 { 0x00E8, 8}, { 0x004C, 11}, { 0x0136, 13}, { 0x0039, 6}, { 0x0264, 10}, { 0x0EBA, 12},
1334 { 0x0000, 7}, { 0x00AE, 10}, { 0x099C, 12}, { 0x001F, 7}, { 0x04DE, 11}, { 0x0043, 7},
1335 { 0x04DC, 11}, { 0x0003, 8}, { 0x03CB, 12}, { 0x0006, 8}, { 0x099E, 12}, { 0x002A, 8},
1336 { 0x05F1, 13}, { 0x000F, 8}, { 0x09FE, 12}, { 0x0033, 8}, { 0x09FF, 12}, { 0x0098, 8},
1337 { 0x099F, 12}, { 0x00EA, 8}, { 0x013C, 13}, { 0x002E, 8}, { 0x0192, 11}, { 0x0136, 9},
1338 { 0x006A, 9}, { 0x0015, 11}, { 0x03AF, 10}, { 0x01E3, 11}, { 0x0074, 11}, { 0x00EB, 12},
1339 { 0x02F9, 12}, { 0x005C, 13}, { 0x00ED, 12}, { 0x03DD, 12}, { 0x0326, 12}, { 0x005E, 13},
1340 { 0x0016, 7}
1341 },
1342 {
1343 { 0x0004, 3}, { 0x0014, 5}, { 0x0017, 7}, { 0x007F, 8}, { 0x0154, 9}, { 0x01F2, 10},
1344 { 0x00BF, 11}, { 0x0065, 12}, { 0x0AAA, 12}, { 0x0630, 13}, { 0x1597, 13}, { 0x03B7, 14},
1345 { 0x2B22, 14}, { 0x0BE6, 15}, { 0x000B, 4}, { 0x0037, 7}, { 0x0062, 9}, { 0x0007, 11},
1346 { 0x0166, 12}, { 0x00CE, 13}, { 0x1590, 13}, { 0x05F6, 14}, { 0x0BE7, 15}, { 0x0007, 5},
1347 { 0x006D, 8}, { 0x0003, 11}, { 0x031F, 12}, { 0x05F2, 14}, { 0x0002, 6}, { 0x0061, 9},
1348 { 0x0055, 12}, { 0x01DF, 14}, { 0x001A, 6}, { 0x001E, 10}, { 0x0AC9, 12}, { 0x2B23, 14},
1349 { 0x001E, 6}, { 0x001F, 10}, { 0x0AC3, 12}, { 0x2B2B, 14}, { 0x0006, 7}, { 0x0004, 11},
1350 { 0x02F8, 13}, { 0x0019, 7}, { 0x0006, 11}, { 0x063D, 13}, { 0x0057, 7}, { 0x0182, 11},
1351 { 0x2AA2, 14}, { 0x0004, 8}, { 0x0180, 11}, { 0x059C, 14}, { 0x007D, 8}, { 0x0164, 12},
1352 { 0x076D, 15}, { 0x0002, 9}, { 0x018D, 11}, { 0x1581, 13}, { 0x00AD, 8}, { 0x0060, 12},
1353 { 0x0C67, 14}, { 0x001C, 9}, { 0x00EE, 13}, { 0x0003, 9}, { 0x02CF, 13}, { 0x00D9, 9},
1354 { 0x1580, 13}, { 0x0002, 11}, { 0x0183, 11}, { 0x0057, 12}, { 0x0061, 12}, { 0x0031, 11},
1355 { 0x0066, 12}, { 0x0631, 13}, { 0x0632, 13}, { 0x00AC, 13}, { 0x031D, 12}, { 0x0076, 12},
1356 { 0x003A, 11}, { 0x0165, 12}, { 0x0C66, 14}, { 0x0003, 2}, { 0x0054, 7}, { 0x02AB, 10},
1357 { 0x0016, 13}, { 0x05F7, 14}, { 0x0005, 4}, { 0x00F8, 9}, { 0x0AA9, 12}, { 0x005F, 15},
1358 { 0x0004, 4}, { 0x001C, 10}, { 0x1550, 13}, { 0x0004, 5}, { 0x0077, 11}, { 0x076C, 15},
1359 { 0x000E, 5}, { 0x000A, 12}, { 0x000C, 5}, { 0x0562, 11}, { 0x0004, 6}, { 0x031C, 12},
1360 { 0x0006, 6}, { 0x00C8, 13}, { 0x000D, 6}, { 0x01DA, 13}, { 0x0007, 6}, { 0x00C9, 13},
1361 { 0x0001, 7}, { 0x002E, 14}, { 0x0014, 7}, { 0x1596, 13}, { 0x000A, 7}, { 0x0AC2, 12},
1362 { 0x0016, 7}, { 0x015B, 14}, { 0x0015, 7}, { 0x015A, 14}, { 0x000F, 8}, { 0x005E, 15},
1363 { 0x007E, 8}, { 0x00AB, 8}, { 0x002D, 9}, { 0x00D8, 9}, { 0x000B, 9}, { 0x0014, 10},
1364 { 0x02B3, 10}, { 0x01F3, 10}, { 0x003A, 10}, { 0x0000, 10}, { 0x0058, 10}, { 0x002E, 9},
1365 { 0x005E, 10}, { 0x0563, 11}, { 0x00EC, 12}, { 0x0054, 12}, { 0x0AC1, 12}, { 0x1556, 13},
1366 { 0x02FA, 13}, { 0x0181, 11}, { 0x1557, 13}, { 0x059D, 14}, { 0x2AA3, 14}, { 0x2B2A, 14},
1367 { 0x01DE, 14}, { 0x063C, 13}, { 0x00CF, 13}, { 0x1594, 13}, { 0x000D, 9}
1368 },
1369 {
1370 { 0x0002, 2}, { 0x0006, 3}, { 0x000F, 4}, { 0x000D, 5}, { 0x000C, 5}, { 0x0015, 6},
1371 { 0x0013, 6}, { 0x0012, 6}, { 0x0017, 7}, { 0x001F, 8}, { 0x001E, 8}, { 0x001D, 8},
1372 { 0x0025, 9}, { 0x0024, 9}, { 0x0023, 9}, { 0x0021, 9}, { 0x0021, 10}, { 0x0020, 10},
1373 { 0x000F, 10}, { 0x000E, 10}, { 0x0007, 11}, { 0x0006, 11}, { 0x0020, 11}, { 0x0021, 11},
1374 { 0x0050, 12}, { 0x0051, 12}, { 0x0052, 12}, { 0x000E, 4}, { 0x0014, 6}, { 0x0016, 7},
1375 { 0x001C, 8}, { 0x0020, 9}, { 0x001F, 9}, { 0x000D, 10}, { 0x0022, 11}, { 0x0053, 12},
1376 { 0x0055, 12}, { 0x000B, 5}, { 0x0015, 7}, { 0x001E, 9}, { 0x000C, 10}, { 0x0056, 12},
1377 { 0x0011, 6}, { 0x001B, 8}, { 0x001D, 9}, { 0x000B, 10}, { 0x0010, 6}, { 0x0022, 9},
1378 { 0x000A, 10}, { 0x000D, 6}, { 0x001C, 9}, { 0x0008, 10}, { 0x0012, 7}, { 0x001B, 9},
1379 { 0x0054, 12}, { 0x0014, 7}, { 0x001A, 9}, { 0x0057, 12}, { 0x0019, 8}, { 0x0009, 10},
1380 { 0x0018, 8}, { 0x0023, 11}, { 0x0017, 8}, { 0x0019, 9}, { 0x0018, 9}, { 0x0007, 10},
1381 { 0x0058, 12}, { 0x0007, 4}, { 0x000C, 6}, { 0x0016, 8}, { 0x0017, 9}, { 0x0006, 10},
1382 { 0x0005, 11}, { 0x0004, 11}, { 0x0059, 12}, { 0x000F, 6}, { 0x0016, 9}, { 0x0005, 10},
1383 { 0x000E, 6}, { 0x0004, 10}, { 0x0011, 7}, { 0x0024, 11}, { 0x0010, 7}, { 0x0025, 11},
1384 { 0x0013, 7}, { 0x005A, 12}, { 0x0015, 8}, { 0x005B, 12}, { 0x0014, 8}, { 0x0013, 8},
1385 { 0x001A, 8}, { 0x0015, 9}, { 0x0014, 9}, { 0x0013, 9}, { 0x0012, 9}, { 0x0011, 9},
1386 { 0x0026, 11}, { 0x0027, 11}, { 0x005C, 12}, { 0x005D, 12}, { 0x005E, 12}, { 0x005F, 12},
1387 { 0x0003, 7}
1388 },
1389 {
1390 { 0x0002, 2}, { 0x000F, 4}, { 0x0015, 6}, { 0x0017, 7}, { 0x001F, 8}, { 0x0025, 9},
1391 { 0x0024, 9}, { 0x0021, 10}, { 0x0020, 10}, { 0x0007, 11}, { 0x0006, 11}, { 0x0020, 11},
1392 { 0x0006, 3}, { 0x0014, 6}, { 0x001E, 8}, { 0x000F, 10}, { 0x0021, 11}, { 0x0050, 12},
1393 { 0x000E, 4}, { 0x001D, 8}, { 0x000E, 10}, { 0x0051, 12}, { 0x000D, 5}, { 0x0023, 9},
1394 { 0x000D, 10}, { 0x000C, 5}, { 0x0022, 9}, { 0x0052, 12}, { 0x000B, 5}, { 0x000C, 10},
1395 { 0x0053, 12}, { 0x0013, 6}, { 0x000B, 10}, { 0x0054, 12}, { 0x0012, 6}, { 0x000A, 10},
1396 { 0x0011, 6}, { 0x0009, 10}, { 0x0010, 6}, { 0x0008, 10}, { 0x0016, 7}, { 0x0055, 12},
1397 { 0x0015, 7}, { 0x0014, 7}, { 0x001C, 8}, { 0x001B, 8}, { 0x0021, 9}, { 0x0020, 9},
1398 { 0x001F, 9}, { 0x001E, 9}, { 0x001D, 9}, { 0x001C, 9}, { 0x001B, 9}, { 0x001A, 9},
1399 { 0x0022, 11}, { 0x0023, 11}, { 0x0056, 12}, { 0x0057, 12}, { 0x0007, 4}, { 0x0019, 9},
1400 { 0x0005, 11}, { 0x000F, 6}, { 0x0004, 11}, { 0x000E, 6}, { 0x000D, 6}, { 0x000C, 6},
1401 { 0x0013, 7}, { 0x0012, 7}, { 0x0011, 7}, { 0x0010, 7}, { 0x001A, 8}, { 0x0019, 8},
1402 { 0x0018, 8}, { 0x0017, 8}, { 0x0016, 8}, { 0x0015, 8}, { 0x0014, 8}, { 0x0013, 8},
1403 { 0x0018, 9}, { 0x0017, 9}, { 0x0016, 9}, { 0x0015, 9}, { 0x0014, 9}, { 0x0013, 9},
1404 { 0x0012, 9}, { 0x0011, 9}, { 0x0007, 10}, { 0x0006, 10}, { 0x0005, 10}, { 0x0004, 10},
1405 { 0x0024, 11}, { 0x0025, 11}, { 0x0026, 11}, { 0x0027, 11}, { 0x0058, 12}, { 0x0059, 12},
1406 { 0x005A, 12}, { 0x005B, 12}, { 0x005C, 12}, { 0x005D, 12}, { 0x005E, 12}, { 0x005F, 12},
1407 { 0x0003, 7}
1408 },
1409 {
1410 { 0x0000, 2}, { 0x0003, 3}, { 0x000D, 4}, { 0x0005, 4}, { 0x001C, 5}, { 0x0016, 5},
1411 { 0x003F, 6}, { 0x003A, 6}, { 0x002E, 6}, { 0x0022, 6}, { 0x007B, 7}, { 0x0067, 7},
1412 { 0x005F, 7}, { 0x0047, 7}, { 0x0026, 7}, { 0x00EF, 8}, { 0x00CD, 8}, { 0x00C1, 8},
1413 { 0x00A9, 8}, { 0x004F, 8}, { 0x01F2, 9}, { 0x01DD, 9}, { 0x0199, 9}, { 0x0185, 9},
1414 { 0x015D, 9}, { 0x011B, 9}, { 0x03EF, 10}, { 0x03E1, 10}, { 0x03C8, 10}, { 0x0331, 10},
1415 { 0x0303, 10}, { 0x02F1, 10}, { 0x02A0, 10}, { 0x0233, 10}, { 0x0126, 10}, { 0x07C0, 11},
1416 { 0x076F, 11}, { 0x076C, 11}, { 0x0661, 11}, { 0x0604, 11}, { 0x0572, 11}, { 0x0551, 11},
1417 { 0x046A, 11}, { 0x0274, 11}, { 0x0F27, 12}, { 0x0F24, 12}, { 0x0EDB, 12}, { 0x0C8E, 12},
1418 { 0x0C0B, 12}, { 0x0C0A, 12}, { 0x0AE3, 12}, { 0x08D6, 12}, { 0x0490, 12}, { 0x0495, 12},
1419 { 0x1F19, 13}, { 0x1DB5, 13}, { 0x0009, 4}, { 0x0010, 5}, { 0x0029, 6}, { 0x0062, 7},
1420 { 0x00F3, 8}, { 0x00AD, 8}, { 0x01E5, 9}, { 0x0179, 9}, { 0x009C, 9}, { 0x03B1, 10},
1421 { 0x02AE, 10}, { 0x0127, 10}, { 0x076E, 11}, { 0x0570, 11}, { 0x0275, 11}, { 0x0F25, 12},
1422 { 0x0EC0, 12}, { 0x0AA0, 12}, { 0x08D7, 12}, { 0x1E4C, 13}, { 0x0008, 5}, { 0x0063, 7},
1423 { 0x00AF, 8}, { 0x017B, 9}, { 0x03B3, 10}, { 0x07DD, 11}, { 0x0640, 11}, { 0x0F8D, 12},
1424 { 0x0BC1, 12}, { 0x0491, 12}, { 0x0028, 6}, { 0x00C3, 8}, { 0x0151, 9}, { 0x02A1, 10},
1425 { 0x0573, 11}, { 0x0EC3, 12}, { 0x1F35, 13}, { 0x0065, 7}, { 0x01DA, 9}, { 0x02AF, 10},
1426 { 0x0277, 11}, { 0x08C9, 12}, { 0x1781, 13}, { 0x0025, 7}, { 0x0118, 9}, { 0x0646, 11},
1427 { 0x0AA6, 12}, { 0x1780, 13}, { 0x00C9, 8}, { 0x0321, 10}, { 0x0F9B, 12}, { 0x191E, 13},
1428 { 0x0048, 8}, { 0x07CC, 11}, { 0x0AA1, 12}, { 0x0180, 9}, { 0x0465, 11}, { 0x1905, 13},
1429 { 0x03E2, 10}, { 0x0EC1, 12}, { 0x3C9B, 14}, { 0x02F4, 10}, { 0x08C8, 12}, { 0x07C1, 11},
1430 { 0x0928, 13}, { 0x05E1, 11}, { 0x320D, 14}, { 0x0EC2, 12}, { 0x6418, 15}, { 0x1F34, 13},
1431 { 0x0078, 7}, { 0x0155, 9}, { 0x0552, 11}, { 0x191F, 13}, { 0x00FA, 8}, { 0x07DC, 11},
1432 { 0x1907, 13}, { 0x00AC, 8}, { 0x0249, 11}, { 0x13B1, 14}, { 0x01F6, 9}, { 0x0AE2, 12},
1433 { 0x01DC, 9}, { 0x04ED, 12}, { 0x0184, 9}, { 0x1904, 13}, { 0x0156, 9}, { 0x09D9, 13},
1434 { 0x03E7, 10}, { 0x0929, 13}, { 0x03B2, 10}, { 0x3B68, 14}, { 0x02F5, 10}, { 0x13B0, 14},
1435 { 0x0322, 10}, { 0x3B69, 14}, { 0x0234, 10}, { 0x7935, 15}, { 0x07C7, 11}, { 0xC833, 16},
1436 { 0x0660, 11}, { 0x7934, 15}, { 0x024B, 11}, { 0xC832, 16}, { 0x0AA7, 12}, { 0x1F18, 13},
1437 { 0x007A, 7}
1438 },
1439 {
1440 { 0x0002, 2}, { 0x0000, 3}, { 0x001E, 5}, { 0x0004, 5}, { 0x0012, 6}, { 0x0070, 7},
1441 { 0x001A, 7}, { 0x005F, 8}, { 0x0047, 8}, { 0x01D3, 9}, { 0x00B5, 9}, { 0x0057, 9},
1442 { 0x03B5, 10}, { 0x016D, 10}, { 0x0162, 10}, { 0x07CE, 11}, { 0x0719, 11}, { 0x0691, 11},
1443 { 0x02C6, 11}, { 0x0156, 11}, { 0x0F92, 12}, { 0x0D2E, 12}, { 0x0D20, 12}, { 0x059E, 12},
1444 { 0x0468, 12}, { 0x02A6, 12}, { 0x1DA2, 13}, { 0x1C60, 13}, { 0x1A43, 13}, { 0x0B1D, 13},
1445 { 0x08C0, 13}, { 0x055D, 13}, { 0x0003, 3}, { 0x000A, 5}, { 0x0077, 7}, { 0x00E5, 8},
1446 { 0x01D9, 9}, { 0x03E5, 10}, { 0x0166, 10}, { 0x0694, 11}, { 0x0152, 11}, { 0x059F, 12},
1447 { 0x1F3C, 13}, { 0x1A4B, 13}, { 0x055E, 13}, { 0x000C, 4}, { 0x007D, 7}, { 0x0044, 8},
1448 { 0x03E0, 10}, { 0x0769, 11}, { 0x0E31, 12}, { 0x1F26, 13}, { 0x055C, 13}, { 0x001B, 5},
1449 { 0x00E2, 8}, { 0x03A5, 10}, { 0x02C9, 11}, { 0x1F23, 13}, { 0x3B47, 14}, { 0x0007, 5},
1450 { 0x01D8, 9}, { 0x02D8, 11}, { 0x1F27, 13}, { 0x3494, 14}, { 0x0035, 6}, { 0x03E1, 10},
1451 { 0x059C, 12}, { 0x38C3, 14}, { 0x000C, 6}, { 0x0165, 10}, { 0x1D23, 13}, { 0x1638, 14},
1452 { 0x0068, 7}, { 0x0693, 11}, { 0x3A45, 14}, { 0x0020, 7}, { 0x0F90, 12}, { 0x7CF6, 15},
1453 { 0x00E8, 8}, { 0x058F, 12}, { 0x2CEF, 15}, { 0x0045, 8}, { 0x0B3A, 13}, { 0x01F1, 9},
1454 { 0x3B46, 14}, { 0x01A7, 9}, { 0x1676, 14}, { 0x0056, 9}, { 0x692A, 15}, { 0x038D, 10},
1455 { 0xE309, 16}, { 0x00AA, 10}, { 0x1C611, 17}, { 0x02DF, 11}, { 0xB3B9, 17}, { 0x02C8, 11},
1456 { 0x38C20, 18}, { 0x01B0, 11}, { 0x16390, 18}, { 0x0F9F, 12}, { 0x16771, 18}, { 0x0ED0, 12},
1457 { 0x71843, 19}, { 0x0D2A, 12}, { 0xF9E8C, 20}, { 0x0461, 12}, { 0xF9E8E, 20}, { 0x0B67, 13},
1458 { 0x055F, 13}, { 0x003F, 6}, { 0x006D, 9}, { 0x0E90, 12}, { 0x054E, 13}, { 0x0013, 6},
1459 { 0x0119, 10}, { 0x0B66, 13}, { 0x000B, 6}, { 0x0235, 11}, { 0x7CF5, 15}, { 0x0075, 7},
1460 { 0x0D24, 12}, { 0xF9E9, 16}, { 0x002E, 7}, { 0x1F22, 13}, { 0x0021, 7}, { 0x054F, 13},
1461 { 0x0014, 7}, { 0x3A44, 14}, { 0x00E4, 8}, { 0x7CF7, 15}, { 0x005E, 8}, { 0x7185, 15},
1462 { 0x0037, 8}, { 0x2C73, 15}, { 0x01DB, 9}, { 0x59DD, 16}, { 0x01C7, 9}, { 0x692B, 15},
1463 { 0x01A6, 9}, { 0x58E5, 16}, { 0x00B4, 9}, { 0x1F3D0, 17}, { 0x00B0, 9}, { 0xB1C9, 17},
1464 { 0x03E6, 10}, { 0x16770, 18}, { 0x016E, 10}, { 0x3E7A2, 18}, { 0x011B, 10}, { 0xF9E8D, 20},
1465 { 0x00D9, 10}, { 0xF9E8F, 20}, { 0x00A8, 10}, { 0x2C723, 19}, { 0x0749, 11}, { 0xE3084, 20},
1466 { 0x0696, 11}, { 0x58E45, 20}, { 0x02DE, 11}, { 0xB1C88, 21}, { 0x0231, 11}, { 0x1C610A, 21},
1467 { 0x01B1, 11}, { 0x71842D, 23}, { 0x0D2B, 12}, { 0x38C217, 22}, { 0x0D2F, 12}, { 0x163913, 22},
1468 { 0x05B2, 12}, { 0x163912, 22}, { 0x0469, 12}, { 0x71842C, 23}, { 0x1A42, 13}, { 0x08C1, 13},
1469 { 0x0073, 7}
1470 }
1471 };
1472 
1473 static const uint16_t vlc_offs[] = {
1474  0, 520, 552, 616, 1128, 1160, 1224, 1740, 1772, 1836, 1900, 2436,
1475  2986, 3050, 3610, 4154, 4218, 4746, 5326, 5390, 5902, 6554, 7658, 8342,
1476  9304, 9988, 10630, 11234, 12174, 13006, 13560, 14232, 14786, 15432, 16350, 17522,
1477  20372, 21818, 22330, 22394, 23166, 23678, 23742, 24820, 25332, 25396, 26460, 26980,
1478  27048, 27592, 27600, 27608, 27616, 27624, 28224, 28258, 28290, 28802, 28834, 28866,
1479  29378, 29412, 29444, 29960, 29994, 30026, 30538, 30572, 30604, 31120, 31154, 31186,
1480  31714, 31746, 31778, 32306, 32340, 32372
1481 };
1482 
1489 {
1490  static int done = 0;
1491  int i = 0;
1492  static VLC_TYPE vlc_table[32372][2];
1493 
1494  v->hrd_rate = v->hrd_buffer = NULL;
1495 
1496  /* VLC tables */
1497  if (!done) {
1499  ff_vc1_bfraction_bits, 1, 1,
1502  ff_vc1_norm2_bits, 1, 1,
1505  ff_vc1_norm6_bits, 1, 1,
1506  ff_vc1_norm6_codes, 2, 2, 556);
1508  ff_vc1_imode_bits, 1, 1,
1510  for (i = 0; i < 3; i++) {
1511  ff_vc1_ttmb_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 0]];
1512  ff_vc1_ttmb_vlc[i].table_allocated = vlc_offs[i * 3 + 1] - vlc_offs[i * 3 + 0];
1514  ff_vc1_ttmb_bits[i], 1, 1,
1516  ff_vc1_ttblk_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 1]];
1517  ff_vc1_ttblk_vlc[i].table_allocated = vlc_offs[i * 3 + 2] - vlc_offs[i * 3 + 1];
1519  ff_vc1_ttblk_bits[i], 1, 1,
1521  ff_vc1_subblkpat_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 2]];
1522  ff_vc1_subblkpat_vlc[i].table_allocated = vlc_offs[i * 3 + 3] - vlc_offs[i * 3 + 2];
1524  ff_vc1_subblkpat_bits[i], 1, 1,
1526  }
1527  for (i = 0; i < 4; i++) {
1528  ff_vc1_4mv_block_pattern_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 9]];
1529  ff_vc1_4mv_block_pattern_vlc[i].table_allocated = vlc_offs[i * 3 + 10] - vlc_offs[i * 3 + 9];
1533  ff_vc1_cbpcy_p_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 10]];
1534  ff_vc1_cbpcy_p_vlc[i].table_allocated = vlc_offs[i * 3 + 11] - vlc_offs[i * 3 + 10];
1536  ff_vc1_cbpcy_p_bits[i], 1, 1,
1538  ff_vc1_mv_diff_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 11]];
1539  ff_vc1_mv_diff_vlc[i].table_allocated = vlc_offs[i * 3 + 12] - vlc_offs[i * 3 + 11];
1541  ff_vc1_mv_diff_bits[i], 1, 1,
1543  }
1544  for (i = 0; i < 8; i++) {
1545  ff_vc1_ac_coeff_table[i].table = &vlc_table[vlc_offs[i * 2 + 21]];
1546  ff_vc1_ac_coeff_table[i].table_allocated = vlc_offs[i * 2 + 22] - vlc_offs[i * 2 + 21];
1548  &vc1_ac_tables[i][0][1], 8, 4,
1549  &vc1_ac_tables[i][0][0], 8, 4, INIT_VLC_USE_NEW_STATIC);
1550  /* initialize interlaced MVDATA tables (2-Ref) */
1551  ff_vc1_2ref_mvdata_vlc[i].table = &vlc_table[vlc_offs[i * 2 + 22]];
1552  ff_vc1_2ref_mvdata_vlc[i].table_allocated = vlc_offs[i * 2 + 23] - vlc_offs[i * 2 + 22];
1554  ff_vc1_2ref_mvdata_bits[i], 1, 1,
1556  }
1557  for (i = 0; i < 4; i++) {
1558  /* initialize 4MV MBMODE VLC tables for interlaced frame P picture */
1559  ff_vc1_intfr_4mv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 37]];
1560  ff_vc1_intfr_4mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 38] - vlc_offs[i * 3 + 37];
1564  /* initialize NON-4MV MBMODE VLC tables for the same */
1565  ff_vc1_intfr_non4mv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 38]];
1566  ff_vc1_intfr_non4mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 39] - vlc_offs[i * 3 + 38];
1570  /* initialize interlaced MVDATA tables (1-Ref) */
1571  ff_vc1_1ref_mvdata_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 39]];
1572  ff_vc1_1ref_mvdata_vlc[i].table_allocated = vlc_offs[i * 3 + 40] - vlc_offs[i * 3 + 39];
1574  ff_vc1_1ref_mvdata_bits[i], 1, 1,
1576  }
1577  for (i = 0; i < 4; i++) {
1578  /* Initialize 2MV Block pattern VLC tables */
1579  ff_vc1_2mv_block_pattern_vlc[i].table = &vlc_table[vlc_offs[i + 49]];
1580  ff_vc1_2mv_block_pattern_vlc[i].table_allocated = vlc_offs[i + 50] - vlc_offs[i + 49];
1584  }
1585  for (i = 0; i < 8; i++) {
1586  /* Initialize interlaced CBPCY VLC tables (Table 124 - Table 131) */
1587  ff_vc1_icbpcy_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 53]];
1588  ff_vc1_icbpcy_vlc[i].table_allocated = vlc_offs[i * 3 + 54] - vlc_offs[i * 3 + 53];
1590  ff_vc1_icbpcy_p_bits[i], 1, 1,
1592  /* Initialize interlaced field picture MBMODE VLC tables */
1593  ff_vc1_if_mmv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 54]];
1594  ff_vc1_if_mmv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 55] - vlc_offs[i * 3 + 54];
1596  ff_vc1_if_mmv_mbmode_bits[i], 1, 1,
1598  ff_vc1_if_1mv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 55]];
1599  ff_vc1_if_1mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 56] - vlc_offs[i * 3 + 55];
1601  ff_vc1_if_1mv_mbmode_bits[i], 1, 1,
1603  }
1604  done = 1;
1605  }
1606 
1607  /* Other defaults */
1608  v->pq = -1;
1609  v->mvrange = 0; /* 7.1.1.18, p80 */
1610 
1611  return 0;
1612 }