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