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