git.sesse.net Git - ffmpeg/blob - libavcodec/ivi_common.c

   1 /*
   2  * common functions for Indeo Video Interactive codecs (Indeo4 and Indeo5)
   3  *
   4  * Copyright (c) 2009 Maxim Poliakovski
   5  *
   6  * This file is part of FFmpeg.
   7  *
   8  * FFmpeg is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * FFmpeg is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with FFmpeg; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  21  */
  22
  23 /**
  24  * @file
  25  * This file contains functions and data shared by both Indeo4 and
  26  * Indeo5 decoders.
  27  */
  28
  29 #define BITSTREAM_READER_LE
  30 #include "libavutil/attributes.h"
  31 #include "avcodec.h"
  32 #include "get_bits.h"
  33 #include "internal.h"
  34 #include "mathops.h"
  35 #include "ivi_common.h"
  36 #include "ivi_dsp.h"
  37
  38 extern const IVIHuffDesc ff_ivi_mb_huff_desc[8];  ///< static macroblock huffman tables
  39 extern const IVIHuffDesc ff_ivi_blk_huff_desc[8]; ///< static block huffman tables
  40
  41 static VLC ivi_mb_vlc_tabs [8]; ///< static macroblock Huffman tables
  42 static VLC ivi_blk_vlc_tabs[8]; ///< static block Huffman tables
  43
  44 /**
  45  *  Reverse "nbits" bits of the value "val" and return the result
  46  *  in the least significant bits.
  47  */
  48 static uint16_t inv_bits(uint16_t val, int nbits)
  49 {
  50     uint16_t res;
  51
  52     if (nbits <= 8) {
  53         res = ff_reverse[val] >> (8-nbits);
  54     } else
  55         res = ((ff_reverse[val & 0xFF] << 8) + (ff_reverse[val >> 8])) >> (16-nbits);
  56
  57     return res;
  58 }
  59
  60 /*
  61  *  Generate a huffman codebook from the given descriptor
  62  *  and convert it into the FFmpeg VLC table.
  63  *
  64  *  @param[in]   cb    pointer to codebook descriptor
  65  *  @param[out]  vlc   where to place the generated VLC table
  66  *  @param[in]   flag  flag: 1 - for static or 0 for dynamic tables
  67  *  @return     result code: 0 - OK, -1 = error (invalid codebook descriptor)
  68  */
  69 static int ivi_create_huff_from_desc(const IVIHuffDesc *cb, VLC *vlc, int flag)
  70 {
  71     int         pos, i, j, codes_per_row, prefix, not_last_row;
  72     uint16_t    codewords[256]; /* FIXME: move this temporal storage out? */
  73     uint8_t     bits[256];
  74
  75     pos = 0; /* current position = 0 */
  76
  77     for (i = 0; i < cb->num_rows; i++) {
  78         codes_per_row = 1 << cb->xbits[i];
  79         not_last_row  = (i != cb->num_rows - 1);
  80         prefix        = ((1 << i) - 1) << (cb->xbits[i] + not_last_row);
  81
  82         for (j = 0; j < codes_per_row; j++) {
  83             if (pos >= 256) /* Some Indeo5 codebooks can have more than 256 */
  84                 break;      /* elements, but only 256 codes are allowed! */
  85
  86             bits[pos] = i + cb->xbits[i] + not_last_row;
  87             if (bits[pos] > IVI_VLC_BITS)
  88                 return -1; /* invalid descriptor */
  89
  90             codewords[pos] = inv_bits((prefix | j), bits[pos]);
  91             if (!bits[pos])
  92                 bits[pos] = 1;
  93
  94             pos++;
  95         }//for j
  96     }//for i
  97
  98     /* number of codewords = pos */
  99     return init_vlc(vlc, IVI_VLC_BITS, pos, bits, 1, 1, codewords, 2, 2,
 100                     (flag ? INIT_VLC_USE_NEW_STATIC : 0) | INIT_VLC_LE);
 101 }
 102
 103 void ff_ivi_init_static_vlc(void)
 104 {
 105     int i;
 106     static VLC_TYPE table_data[8192 * 16][2];
 107     static int initialized_vlcs = 0;
 108
 109     if (initialized_vlcs)
 110         return;
 111     for (i = 0; i < 8; i++) {
 112         ivi_mb_vlc_tabs[i].table = table_data + i * 2 * 8192;
 113         ivi_mb_vlc_tabs[i].table_allocated = 8192;
 114         ivi_create_huff_from_desc(&ff_ivi_mb_huff_desc[i],  &ivi_mb_vlc_tabs[i],  1);
 115         ivi_blk_vlc_tabs[i].table = table_data + (i * 2 + 1) * 8192;
 116         ivi_blk_vlc_tabs[i].table_allocated = 8192;
 117         ivi_create_huff_from_desc(&ff_ivi_blk_huff_desc[i], &ivi_blk_vlc_tabs[i], 1);
 118     }
 119     initialized_vlcs = 1;
 120 }
 121
 122 /*
 123  *  Copy huffman codebook descriptors.
 124  *
 125  *  @param[out]  dst  ptr to the destination descriptor
 126  *  @param[in]   src  ptr to the source descriptor
 127  */
 128 static void ivi_huff_desc_copy(IVIHuffDesc *dst, const IVIHuffDesc *src)
 129 {
 130     dst->num_rows = src->num_rows;
 131     memcpy(dst->xbits, src->xbits, src->num_rows);
 132 }
 133
 134 /*
 135  *  Compare two huffman codebook descriptors.
 136  *
 137  *  @param[in]  desc1  ptr to the 1st descriptor to compare
 138  *  @param[in]  desc2  ptr to the 2nd descriptor to compare
 139  *  @return         comparison result: 0 - equal, 1 - not equal
 140  */
 141 static int ivi_huff_desc_cmp(const IVIHuffDesc *desc1, const IVIHuffDesc *desc2)
 142 {
 143     return    desc1->num_rows != desc2->num_rows
 144            || memcmp(desc1->xbits, desc2->xbits, desc1->num_rows);
 145 }
 146
 147 int ff_ivi_dec_huff_desc(GetBitContext *gb, int desc_coded, int which_tab,
 148                          IVIHuffTab *huff_tab, AVCodecContext *avctx)
 149 {
 150     int         i, result;
 151     IVIHuffDesc new_huff;
 152
 153     if (!desc_coded) {
 154         /* select default table */
 155         huff_tab->tab = (which_tab) ? &ivi_blk_vlc_tabs[7]
 156             : &ivi_mb_vlc_tabs [7];
 157     } else {
 158         huff_tab->tab_sel = get_bits(gb, 3);
 159         if (huff_tab->tab_sel == 7) {
 160             /* custom huffman table (explicitly encoded) */
 161             new_huff.num_rows = get_bits(gb, 4);
 162             if (!new_huff.num_rows) {
 163                 av_log(avctx, AV_LOG_ERROR, "Empty custom Huffman table!\n");
 164                 return AVERROR_INVALIDDATA;
 165             }
 166
 167             for (i = 0; i < new_huff.num_rows; i++)
 168                 new_huff.xbits[i] = get_bits(gb, 4);
 169
 170             /* Have we got the same custom table? Rebuild if not. */
 171             if (ivi_huff_desc_cmp(&new_huff, &huff_tab->cust_desc) || !huff_tab->cust_tab.table) {
 172                 ivi_huff_desc_copy(&huff_tab->cust_desc, &new_huff);
 173
 174                 if (huff_tab->cust_tab.table)
 175                     ff_free_vlc(&huff_tab->cust_tab);
 176                 result = ivi_create_huff_from_desc(&huff_tab->cust_desc,
 177                         &huff_tab->cust_tab, 0);
 178                 if (result) {
 179                     huff_tab->cust_desc.num_rows = 0; // reset faulty description
 180                     av_log(avctx, AV_LOG_ERROR,
 181                            "Error while initializing custom vlc table!\n");
 182                     return result;
 183                 }
 184             }
 185             huff_tab->tab = &huff_tab->cust_tab;
 186         } else {
 187             /* select one of predefined tables */
 188             huff_tab->tab = (which_tab) ? &ivi_blk_vlc_tabs[huff_tab->tab_sel]
 189                 : &ivi_mb_vlc_tabs [huff_tab->tab_sel];
 190         }
 191     }
 192
 193     return 0;
 194 }
 195
 196 /*
 197  *  Free planes, bands and macroblocks buffers.
 198  *
 199  *  @param[in]  planes  pointer to the array of the plane descriptors
 200  */
 201 static av_cold void ivi_free_buffers(IVIPlaneDesc *planes)
 202 {
 203     int p, b, t;
 204
 205     for (p = 0; p < 3; p++) {
 206         if (planes[p].bands)
 207         for (b = 0; b < planes[p].num_bands; b++) {
 208             av_freep(&planes[p].bands[b].bufs[0]);
 209             av_freep(&planes[p].bands[b].bufs[1]);
 210             av_freep(&planes[p].bands[b].bufs[2]);
 211
 212             if (planes[p].bands[b].blk_vlc.cust_tab.table)
 213                 ff_free_vlc(&planes[p].bands[b].blk_vlc.cust_tab);
 214             for (t = 0; t < planes[p].bands[b].num_tiles; t++)
 215                 av_freep(&planes[p].bands[b].tiles[t].mbs);
 216             av_freep(&planes[p].bands[b].tiles);
 217         }
 218         av_freep(&planes[p].bands);
 219     }
 220 }
 221
 222 av_cold int ff_ivi_init_planes(IVIPlaneDesc *planes, const IVIPicConfig *cfg)
 223 {
 224     int         p, b;
 225     uint32_t    b_width, b_height, align_fac, width_aligned, height_aligned, buf_size;
 226     IVIBandDesc *band;
 227
 228     ivi_free_buffers(planes);
 229
 230     /* fill in the descriptor of the luminance plane */
 231     planes[0].width     = cfg->pic_width;
 232     planes[0].height    = cfg->pic_height;
 233     planes[0].num_bands = cfg->luma_bands;
 234
 235     /* fill in the descriptors of the chrominance planes */
 236     planes[1].width     = planes[2].width     = (cfg->pic_width  + 3) >> 2;
 237     planes[1].height    = planes[2].height    = (cfg->pic_height + 3) >> 2;
 238     planes[1].num_bands = planes[2].num_bands = cfg->chroma_bands;
 239
 240     for (p = 0; p < 3; p++) {
 241         planes[p].bands = av_mallocz(planes[p].num_bands * sizeof(IVIBandDesc));
 242         if (!planes[p].bands)
 243             return AVERROR(ENOMEM);
 244
 245         /* select band dimensions: if there is only one band then it
 246          *  has the full size, if there are several bands each of them
 247          *  has only half size */
 248         b_width  = planes[p].num_bands == 1 ? planes[p].width  : (planes[p].width  + 1) >> 1;
 249         b_height = planes[p].num_bands == 1 ? planes[p].height : (planes[p].height + 1) >> 1;
 250
 251         /* luma   band buffers will be aligned on 16x16 (max macroblock size) */
 252         /* chroma band buffers will be aligned on   8x8 (max macroblock size) */
 253         align_fac       = p ? 8 : 16;
 254         width_aligned   = FFALIGN(b_width , align_fac);
 255         height_aligned  = FFALIGN(b_height, align_fac);
 256         buf_size        = width_aligned * height_aligned * sizeof(int16_t);
 257
 258         for (b = 0; b < planes[p].num_bands; b++) {
 259             band = &planes[p].bands[b]; /* select appropriate plane/band */
 260             band->plane    = p;
 261             band->band_num = b;
 262             band->width    = b_width;
 263             band->height   = b_height;
 264             band->pitch    = width_aligned;
 265             band->aheight  = height_aligned;
 266             band->bufs[0]  = av_mallocz(buf_size);
 267             band->bufs[1]  = av_mallocz(buf_size);
 268             band->bufsize  = buf_size/2;
 269             if (!band->bufs[0] || !band->bufs[1])
 270                 return AVERROR(ENOMEM);
 271
 272             /* allocate the 3rd band buffer for scalability mode */
 273             if (cfg->luma_bands > 1) {
 274                 band->bufs[2] = av_mallocz(buf_size);
 275                 if (!band->bufs[2])
 276                     return AVERROR(ENOMEM);
 277             }
 278
 279             planes[p].bands[0].blk_vlc.cust_desc.num_rows = 0; /* reset custom vlc */
 280         }
 281     }
 282
 283     return 0;
 284 }
 285
 286 av_cold int ff_ivi_init_tiles(IVIPlaneDesc *planes, int tile_width, int tile_height)
 287 {
 288     int         p, b, x, y, x_tiles, y_tiles, t_width, t_height;
 289     IVIBandDesc *band;
 290     IVITile     *tile, *ref_tile;
 291
 292     for (p = 0; p < 3; p++) {
 293         t_width  = !p ? tile_width  : (tile_width  + 3) >> 2;
 294         t_height = !p ? tile_height : (tile_height + 3) >> 2;
 295
 296         if (!p && planes[0].num_bands == 4) {
 297             t_width  >>= 1;
 298             t_height >>= 1;
 299         }
 300         if(t_width<=0 || t_height<=0)
 301             return AVERROR(EINVAL);
 302
 303         for (b = 0; b < planes[p].num_bands; b++) {
 304             band = &planes[p].bands[b];
 305             x_tiles = IVI_NUM_TILES(band->width, t_width);
 306             y_tiles = IVI_NUM_TILES(band->height, t_height);
 307             band->num_tiles = x_tiles * y_tiles;
 308
 309             av_freep(&band->tiles);
 310             band->tiles = av_mallocz(band->num_tiles * sizeof(IVITile));
 311             if (!band->tiles)
 312                 return AVERROR(ENOMEM);
 313
 314             tile = band->tiles;
 315
 316             /* use the first luma band as reference for motion vectors
 317              * and quant */
 318             ref_tile = planes[0].bands[0].tiles;
 319
 320             for (y = 0; y < band->height; y += t_height) {
 321                 for (x = 0; x < band->width; x += t_width) {
 322                     tile->xpos     = x;
 323                     tile->ypos     = y;
 324                     tile->mb_size  = band->mb_size;
 325                     tile->width    = FFMIN(band->width - x,  t_width);
 326                     tile->height   = FFMIN(band->height - y, t_height);
 327                     tile->is_empty = tile->data_size = 0;
 328                     /* calculate number of macroblocks */
 329                     tile->num_MBs  = IVI_MBs_PER_TILE(tile->width, tile->height,
 330                                                       band->mb_size);
 331
 332                     av_freep(&tile->mbs);
 333                     tile->mbs = av_malloc(tile->num_MBs * sizeof(IVIMbInfo));
 334                     if (!tile->mbs)
 335                         return AVERROR(ENOMEM);
 336
 337                     tile->ref_mbs = 0;
 338                     if (p || b) {
 339                         if (tile->num_MBs <= ref_tile->num_MBs) {
 340                             tile->ref_mbs = ref_tile->mbs;
 341                         }else
 342                             av_log(NULL, AV_LOG_DEBUG, "Cannot use ref_tile, too few mbs\n");
 343                         ref_tile++;
 344                     }
 345
 346                     tile++;
 347                 }
 348             }
 349
 350         }// for b
 351     }// for p
 352
 353     return 0;
 354 }
 355
 356 /*
 357  *  Decode size of the tile data.
 358  *  The size is stored as a variable-length field having the following format:
 359  *  if (tile_data_size < 255) than this field is only one byte long
 360  *  if (tile_data_size >= 255) than this field four is byte long: 0xFF X1 X2 X3
 361  *  where X1-X3 is size of the tile data
 362  *
 363  *  @param[in,out]  gb  the GetBit context
 364  *  @return     size of the tile data in bytes
 365  */
 366 static int ivi_dec_tile_data_size(GetBitContext *gb)
 367 {
 368     int    len;
 369
 370     len = 0;
 371     if (get_bits1(gb)) {
 372         len = get_bits(gb, 8);
 373         if (len == 255)
 374             len = get_bits_long(gb, 24);
 375     }
 376
 377     /* align the bitstream reader on the byte boundary */
 378     align_get_bits(gb);
 379
 380     return len;
 381 }
 382
 383 /*
 384  *  Decode block data:
 385  *  extract huffman-coded transform coefficients from the bitstream,
 386  *  dequantize them, apply inverse transform and motion compensation
 387  *  in order to reconstruct the picture.
 388  *
 389  *  @param[in,out]  gb    the GetBit context
 390  *  @param[in]      band  pointer to the band descriptor
 391  *  @param[in]      tile  pointer to the tile descriptor
 392  *  @return     result code: 0 - OK, -1 = error (corrupted blocks data)
 393  */
 394 static int ivi_decode_blocks(GetBitContext *gb, IVIBandDesc *band, IVITile *tile,
 395                              AVCodecContext *avctx)
 396 {
 397     int         mbn, blk, num_blocks, num_coeffs, blk_size, scan_pos, run, val,
 398                 pos, is_intra, mc_type = 0, av_uninit(mv_x), av_uninit(mv_y), col_mask;
 399     uint8_t     col_flags[8];
 400     int32_t     prev_dc, trvec[64];
 401     uint32_t    cbp, av_uninit(sym), lo, hi, quant, buf_offs, q;
 402     IVIMbInfo   *mb;
 403     RVMapDesc   *rvmap = band->rv_map;
 404     void (*mc_with_delta_func)(int16_t *buf, const int16_t *ref_buf, uint32_t pitch, int mc_type);
 405     void (*mc_no_delta_func)  (int16_t *buf, const int16_t *ref_buf, uint32_t pitch, int mc_type);
 406     const uint16_t  *base_tab;
 407     const uint8_t   *scale_tab;
 408
 409     prev_dc = 0; /* init intra prediction for the DC coefficient */
 410
 411     blk_size   = band->blk_size;
 412     col_mask   = blk_size - 1; /* column mask for tracking non-zero coeffs */
 413     num_blocks = (band->mb_size != blk_size) ? 4 : 1; /* number of blocks per mb */
 414     num_coeffs = blk_size * blk_size;
 415     if (blk_size == 8) {
 416         mc_with_delta_func = ff_ivi_mc_8x8_delta;
 417         mc_no_delta_func   = ff_ivi_mc_8x8_no_delta;
 418     } else {
 419         mc_with_delta_func = ff_ivi_mc_4x4_delta;
 420         mc_no_delta_func   = ff_ivi_mc_4x4_no_delta;
 421     }
 422
 423     for (mbn = 0, mb = tile->mbs; mbn < tile->num_MBs; mb++, mbn++) {
 424         is_intra = !mb->type;
 425         cbp      = mb->cbp;
 426         buf_offs = mb->buf_offs;
 427
 428         quant = av_clip(band->glob_quant + mb->q_delta, 0, 23);
 429
 430         base_tab  = is_intra ? band->intra_base  : band->inter_base;
 431         scale_tab = is_intra ? band->intra_scale : band->inter_scale;
 432         if (scale_tab)
 433             quant = scale_tab[quant];
 434
 435         if (!is_intra) {
 436             mv_x = mb->mv_x;
 437             mv_y = mb->mv_y;
 438             if (band->is_halfpel) {
 439                 mc_type = ((mv_y & 1) << 1) | (mv_x & 1);
 440                 mv_x >>= 1;
 441                 mv_y >>= 1; /* convert halfpel vectors into fullpel ones */
 442             }
 443             if (mb->type) {
 444                 int dmv_x, dmv_y, cx, cy;
 445
 446                 dmv_x = mb->mv_x >> band->is_halfpel;
 447                 dmv_y = mb->mv_y >> band->is_halfpel;
 448                 cx    = mb->mv_x &  band->is_halfpel;
 449                 cy    = mb->mv_y &  band->is_halfpel;
 450
 451                 if (   mb->xpos + dmv_x < 0
 452                     || mb->xpos + dmv_x + band->mb_size + cx > band->pitch
 453                     || mb->ypos + dmv_y < 0
 454                     || mb->ypos + dmv_y + band->mb_size + cy > band->aheight) {
 455                     return AVERROR_INVALIDDATA;
 456                 }
 457             }
 458         }
 459
 460         for (blk = 0; blk < num_blocks; blk++) {
 461             /* adjust block position in the buffer according to its number */
 462             if (blk & 1) {
 463                 buf_offs += blk_size;
 464             } else if (blk == 2) {
 465                 buf_offs -= blk_size;
 466                 buf_offs += blk_size * band->pitch;
 467             }
 468
 469             if (cbp & 1) { /* block coded ? */
 470                 if (!band->scan) {
 471                     av_log(avctx, AV_LOG_ERROR, "Scan pattern is not set.\n");
 472                     return AVERROR_INVALIDDATA;
 473                 }
 474
 475                 scan_pos = -1;
 476                 memset(trvec, 0, num_coeffs*sizeof(trvec[0])); /* zero transform vector */
 477                 memset(col_flags, 0, sizeof(col_flags));      /* zero column flags */
 478
 479                 while (scan_pos <= num_coeffs) {
 480                     sym = get_vlc2(gb, band->blk_vlc.tab->table, IVI_VLC_BITS, 1);
 481                     if (sym == rvmap->eob_sym)
 482                         break; /* End of block */
 483
 484                     if (sym == rvmap->esc_sym) { /* Escape - run/val explicitly coded using 3 vlc codes */
 485                         run = get_vlc2(gb, band->blk_vlc.tab->table, IVI_VLC_BITS, 1) + 1;
 486                         lo  = get_vlc2(gb, band->blk_vlc.tab->table, IVI_VLC_BITS, 1);
 487                         hi  = get_vlc2(gb, band->blk_vlc.tab->table, IVI_VLC_BITS, 1);
 488                         val = IVI_TOSIGNED((hi << 6) | lo); /* merge them and convert into signed val */
 489                     } else {
 490                         if (sym >= 256U) {
 491                             av_log(avctx, AV_LOG_ERROR, "Invalid sym encountered: %d.\n", sym);
 492                             return -1;
 493                         }
 494                         run = rvmap->runtab[sym];
 495                         val = rvmap->valtab[sym];
 496                     }
 497
 498                     /* de-zigzag and dequantize */
 499                     scan_pos += run;
 500                     if (scan_pos >= (unsigned)num_coeffs)
 501                         break;
 502                     pos = band->scan[scan_pos];
 503
 504                     if (!val)
 505                         av_dlog(avctx, "Val = 0 encountered!\n");
 506
 507                     q = (base_tab[pos] * quant) >> 9;
 508                     if (q > 1)
 509                         val = val * q + FFSIGN(val) * (((q ^ 1) - 1) >> 1);
 510                     trvec[pos] = val;
 511                     col_flags[pos & col_mask] |= !!val; /* track columns containing non-zero coeffs */
 512                 }// while
 513
 514                 if (scan_pos >= num_coeffs && sym != rvmap->eob_sym)
 515                     return -1; /* corrupt block data */
 516
 517                 /* undoing DC coeff prediction for intra-blocks */
 518                 if (is_intra && band->is_2d_trans) {
 519                     prev_dc      += trvec[0];
 520                     trvec[0]      = prev_dc;
 521                     col_flags[0] |= !!prev_dc;
 522                 }
 523                 if(band->transform_size > band->blk_size){
 524                     av_log(NULL, AV_LOG_ERROR, "Too large transform\n");
 525                     return AVERROR_INVALIDDATA;
 526                 }
 527                 /* apply inverse transform */
 528                 band->inv_transform(trvec, band->buf + buf_offs,
 529                                     band->pitch, col_flags);
 530
 531                 /* apply motion compensation */
 532                 if (!is_intra)
 533                     mc_with_delta_func(band->buf + buf_offs,
 534                                        band->ref_buf + buf_offs + mv_y * band->pitch + mv_x,
 535                                        band->pitch, mc_type);
 536             } else {
 537                 /* block not coded */
 538                 /* for intra blocks apply the dc slant transform */
 539                 /* for inter - perform the motion compensation without delta */
 540                 if (is_intra) {
 541                     band->dc_transform(&prev_dc, band->buf + buf_offs,
 542                                        band->pitch, blk_size);
 543                 } else
 544                     mc_no_delta_func(band->buf + buf_offs,
 545                                      band->ref_buf + buf_offs + mv_y * band->pitch + mv_x,
 546                                      band->pitch, mc_type);
 547             }
 548
 549             cbp >>= 1;
 550         }// for blk
 551     }// for mbn
 552
 553     align_get_bits(gb);
 554
 555     return 0;
 556 }
 557
 558 /**
 559  *  Handle empty tiles by performing data copying and motion
 560  *  compensation respectively.
 561  *
 562  *  @param[in]  avctx     ptr to the AVCodecContext
 563  *  @param[in]  band      pointer to the band descriptor
 564  *  @param[in]  tile      pointer to the tile descriptor
 565  *  @param[in]  mv_scale  scaling factor for motion vectors
 566  */
 567 static int ivi_process_empty_tile(AVCodecContext *avctx, IVIBandDesc *band,
 568                                   IVITile *tile, int32_t mv_scale)
 569 {
 570     int             x, y, need_mc, mbn, blk, num_blocks, mv_x, mv_y, mc_type;
 571     int             offs, mb_offset, row_offset;
 572     IVIMbInfo       *mb, *ref_mb;
 573     const int16_t   *src;
 574     int16_t         *dst;
 575     void (*mc_no_delta_func)(int16_t *buf, const int16_t *ref_buf, uint32_t pitch,
 576                              int mc_type);
 577
 578     if (tile->num_MBs != IVI_MBs_PER_TILE(tile->width, tile->height, band->mb_size)) {
 579         av_log(avctx, AV_LOG_ERROR, "Allocated tile size %d mismatches "
 580                "parameters %d in ivi_process_empty_tile()\n",
 581                tile->num_MBs, IVI_MBs_PER_TILE(tile->width, tile->height, band->mb_size));
 582         return AVERROR_INVALIDDATA;
 583     }
 584
 585     offs       = tile->ypos * band->pitch + tile->xpos;
 586     mb         = tile->mbs;
 587     ref_mb     = tile->ref_mbs;
 588     row_offset = band->mb_size * band->pitch;
 589     need_mc    = 0; /* reset the mc tracking flag */
 590
 591     for (y = tile->ypos; y < (tile->ypos + tile->height); y += band->mb_size) {
 592         mb_offset = offs;
 593
 594         for (x = tile->xpos; x < (tile->xpos + tile->width); x += band->mb_size) {
 595             mb->xpos     = x;
 596             mb->ypos     = y;
 597             mb->buf_offs = mb_offset;
 598
 599             mb->type = 1; /* set the macroblocks type = INTER */
 600             mb->cbp  = 0; /* all blocks are empty */
 601
 602             if (!band->qdelta_present && !band->plane && !band->band_num) {
 603                 mb->q_delta = band->glob_quant;
 604                 mb->mv_x    = 0;
 605                 mb->mv_y    = 0;
 606             }
 607
 608             if (band->inherit_qdelta && ref_mb)
 609                 mb->q_delta = ref_mb->q_delta;
 610
 611             if (band->inherit_mv && ref_mb) {
 612                 /* motion vector inheritance */
 613                 if (mv_scale) {
 614                     mb->mv_x = ivi_scale_mv(ref_mb->mv_x, mv_scale);
 615                     mb->mv_y = ivi_scale_mv(ref_mb->mv_y, mv_scale);
 616                 } else {
 617                     mb->mv_x = ref_mb->mv_x;
 618                     mb->mv_y = ref_mb->mv_y;
 619                 }
 620                 need_mc |= mb->mv_x || mb->mv_y; /* tracking non-zero motion vectors */
 621                 {
 622                     int dmv_x, dmv_y, cx, cy;
 623
 624                     dmv_x = mb->mv_x >> band->is_halfpel;
 625                     dmv_y = mb->mv_y >> band->is_halfpel;
 626                     cx    = mb->mv_x &  band->is_halfpel;
 627                     cy    = mb->mv_y &  band->is_halfpel;
 628
 629                     if (   mb->xpos + dmv_x < 0
 630                         || mb->xpos + dmv_x + band->mb_size + cx > band->pitch
 631                         || mb->ypos + dmv_y < 0
 632                         || mb->ypos + dmv_y + band->mb_size + cy > band->aheight) {
 633                         av_log(avctx, AV_LOG_ERROR, "MV out of bounds\n");
 634                         return AVERROR_INVALIDDATA;
 635                     }
 636                 }
 637             }
 638
 639             mb++;
 640             if (ref_mb)
 641                 ref_mb++;
 642             mb_offset += band->mb_size;
 643         } // for x
 644         offs += row_offset;
 645     } // for y
 646
 647     if (band->inherit_mv && need_mc) { /* apply motion compensation if there is at least one non-zero motion vector */
 648         num_blocks = (band->mb_size != band->blk_size) ? 4 : 1; /* number of blocks per mb */
 649         mc_no_delta_func = (band->blk_size == 8) ? ff_ivi_mc_8x8_no_delta
 650                                                  : ff_ivi_mc_4x4_no_delta;
 651
 652         for (mbn = 0, mb = tile->mbs; mbn < tile->num_MBs; mb++, mbn++) {
 653             mv_x = mb->mv_x;
 654             mv_y = mb->mv_y;
 655             if (!band->is_halfpel) {
 656                 mc_type = 0; /* we have only fullpel vectors */
 657             } else {
 658                 mc_type = ((mv_y & 1) << 1) | (mv_x & 1);
 659                 mv_x >>= 1;
 660                 mv_y >>= 1; /* convert halfpel vectors into fullpel ones */
 661             }
 662
 663             for (blk = 0; blk < num_blocks; blk++) {
 664                 /* adjust block position in the buffer according with its number */
 665                 offs = mb->buf_offs + band->blk_size * ((blk & 1) + !!(blk & 2) * band->pitch);
 666                 mc_no_delta_func(band->buf + offs,
 667                                  band->ref_buf + offs + mv_y * band->pitch + mv_x,
 668                                  band->pitch, mc_type);
 669             }
 670         }
 671     } else {
 672         /* copy data from the reference tile into the current one */
 673         src = band->ref_buf + tile->ypos * band->pitch + tile->xpos;
 674         dst = band->buf     + tile->ypos * band->pitch + tile->xpos;
 675         for (y = 0; y < tile->height; y++) {
 676             memcpy(dst, src, tile->width*sizeof(band->buf[0]));
 677             src += band->pitch;
 678             dst += band->pitch;
 679         }
 680     }
 681
 682     return 0;
 683 }
 684
 685
 686 #ifdef DEBUG
 687 static uint16_t ivi_calc_band_checksum(IVIBandDesc *band)
 688 {
 689     int         x, y;
 690     int16_t     *src, checksum;
 691
 692     src = band->buf;
 693     checksum = 0;
 694
 695     for (y = 0; y < band->height; src += band->pitch, y++)
 696         for (x = 0; x < band->width; x++)
 697             checksum += src[x];
 698
 699     return checksum;
 700 }
 701 #endif
 702
 703 /*
 704  *  Convert and output the current plane.
 705  *  This conversion is done by adding back the bias value of 128
 706  *  (subtracted in the encoder) and clipping the result.
 707  *
 708  *  @param[in]   plane      pointer to the descriptor of the plane being processed
 709  *  @param[out]  dst        pointer to the buffer receiving converted pixels
 710  *  @param[in]   dst_pitch  pitch for moving to the next y line
 711  */
 712 static void ivi_output_plane(IVIPlaneDesc *plane, uint8_t *dst, int dst_pitch)
 713 {
 714     int             x, y;
 715     const int16_t   *src  = plane->bands[0].buf;
 716     uint32_t        pitch = plane->bands[0].pitch;
 717
 718     if (!src)
 719         return;
 720
 721     for (y = 0; y < plane->height; y++) {
 722         for (x = 0; x < plane->width; x++)
 723             dst[x] = av_clip_uint8(src[x] + 128);
 724         src += pitch;
 725         dst += dst_pitch;
 726     }
 727 }
 728
 729 /**
 730  *  Decode an Indeo 4 or 5 band.
 731  *
 732  *  @param[in,out]  ctx    ptr to the decoder context
 733  *  @param[in,out]  band   ptr to the band descriptor
 734  *  @param[in]      avctx  ptr to the AVCodecContext
 735  *  @return         result code: 0 = OK, -1 = error
 736  */
 737 static int decode_band(IVI45DecContext *ctx,
 738                        IVIBandDesc *band, AVCodecContext *avctx)
 739 {
 740     int         result, i, t, idx1, idx2, pos;
 741     IVITile     *tile;
 742
 743     band->buf     = band->bufs[ctx->dst_buf];
 744     if (!band->buf) {
 745         av_log(avctx, AV_LOG_ERROR, "Band buffer points to no data!\n");
 746         return AVERROR_INVALIDDATA;
 747     }
 748     band->ref_buf = band->bufs[ctx->ref_buf];
 749     band->data_ptr = ctx->frame_data + (get_bits_count(&ctx->gb) >> 3);
 750
 751     result = ctx->decode_band_hdr(ctx, band, avctx);
 752     if (result) {
 753         av_log(avctx, AV_LOG_ERROR, "Error while decoding band header: %d\n",
 754                result);
 755         return result;
 756     }
 757
 758     if (band->is_empty) {
 759         av_log(avctx, AV_LOG_ERROR, "Empty band encountered!\n");
 760         return AVERROR_INVALIDDATA;
 761     }
 762
 763     band->rv_map = &ctx->rvmap_tabs[band->rvmap_sel];
 764
 765     /* apply corrections to the selected rvmap table if present */
 766     for (i = 0; i < band->num_corr; i++) {
 767         idx1 = band->corr[i * 2];
 768         idx2 = band->corr[i * 2 + 1];
 769         FFSWAP(uint8_t, band->rv_map->runtab[idx1], band->rv_map->runtab[idx2]);
 770         FFSWAP(int16_t, band->rv_map->valtab[idx1], band->rv_map->valtab[idx2]);
 771         if (idx1 == band->rv_map->eob_sym || idx2 == band->rv_map->eob_sym)
 772             band->rv_map->eob_sym ^= idx1 ^ idx2;
 773         if (idx1 == band->rv_map->esc_sym || idx2 == band->rv_map->esc_sym)
 774             band->rv_map->esc_sym ^= idx1 ^ idx2;
 775     }
 776
 777     pos = get_bits_count(&ctx->gb);
 778
 779     for (t = 0; t < band->num_tiles; t++) {
 780         tile = &band->tiles[t];
 781
 782         if (tile->mb_size != band->mb_size) {
 783             av_log(avctx, AV_LOG_ERROR, "MB sizes mismatch: %d vs. %d\n",
 784                    band->mb_size, tile->mb_size);
 785             return AVERROR_INVALIDDATA;
 786         }
 787         tile->is_empty = get_bits1(&ctx->gb);
 788         if (tile->is_empty) {
 789             result = ivi_process_empty_tile(avctx, band, tile,
 790                                       (ctx->planes[0].bands[0].mb_size >> 3) - (band->mb_size >> 3));
 791             if (result < 0)
 792                 break;
 793             av_dlog(avctx, "Empty tile encountered!\n");
 794         } else {
 795             tile->data_size = ivi_dec_tile_data_size(&ctx->gb);
 796             if (!tile->data_size) {
 797                 av_log(avctx, AV_LOG_ERROR, "Tile data size is zero!\n");
 798                 result = AVERROR_INVALIDDATA;
 799                 break;
 800             }
 801
 802             result = ctx->decode_mb_info(ctx, band, tile, avctx);
 803             if (result < 0)
 804                 break;
 805
 806             result = ivi_decode_blocks(&ctx->gb, band, tile, avctx);
 807             if (result < 0 || ((get_bits_count(&ctx->gb) - pos) >> 3) != tile->data_size) {
 808                 av_log(avctx, AV_LOG_ERROR, "Corrupted tile data encountered!\n");
 809                 break;
 810             }
 811
 812             pos += tile->data_size << 3; // skip to next tile
 813         }
 814     }
 815
 816     /* restore the selected rvmap table by applying its corrections in reverse order */
 817     for (i = band->num_corr-1; i >= 0; i--) {
 818         idx1 = band->corr[i*2];
 819         idx2 = band->corr[i*2+1];
 820         FFSWAP(uint8_t, band->rv_map->runtab[idx1], band->rv_map->runtab[idx2]);
 821         FFSWAP(int16_t, band->rv_map->valtab[idx1], band->rv_map->valtab[idx2]);
 822         if (idx1 == band->rv_map->eob_sym || idx2 == band->rv_map->eob_sym)
 823             band->rv_map->eob_sym ^= idx1 ^ idx2;
 824         if (idx1 == band->rv_map->esc_sym || idx2 == band->rv_map->esc_sym)
 825             band->rv_map->esc_sym ^= idx1 ^ idx2;
 826     }
 827
 828 #ifdef DEBUG
 829     if (band->checksum_present) {
 830         uint16_t chksum = ivi_calc_band_checksum(band);
 831         if (chksum != band->checksum) {
 832             av_log(avctx, AV_LOG_ERROR,
 833                    "Band checksum mismatch! Plane %d, band %d, received: %x, calculated: %x\n",
 834                    band->plane, band->band_num, band->checksum, chksum);
 835         }
 836     }
 837 #endif
 838
 839     align_get_bits(&ctx->gb);
 840
 841     return result;
 842 }
 843
 844 int ff_ivi_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
 845                         AVPacket *avpkt)
 846 {
 847     IVI45DecContext *ctx = avctx->priv_data;
 848     const uint8_t   *buf = avpkt->data;
 849     int             buf_size = avpkt->size;
 850     int             result, p, b;
 851
 852     init_get_bits(&ctx->gb, buf, buf_size * 8);
 853     ctx->frame_data = buf;
 854     ctx->frame_size = buf_size;
 855
 856     result = ctx->decode_pic_hdr(ctx, avctx);
 857     if (result) {
 858         av_log(avctx, AV_LOG_ERROR,
 859                "Error while decoding picture header: %d\n", result);
 860         return -1;
 861     }
 862     if (ctx->gop_invalid)
 863         return AVERROR_INVALIDDATA;
 864
 865     if (ctx->gop_flags & IVI5_IS_PROTECTED) {
 866         av_log(avctx, AV_LOG_ERROR, "Password-protected clip!\n");
 867         return -1;
 868     }
 869
 870     ctx->switch_buffers(ctx);
 871
 872     //{ START_TIMER;
 873
 874     if (ctx->is_nonnull_frame(ctx)) {
 875         ctx->buf_invalid[ctx->dst_buf] = 1;
 876         for (p = 0; p < 3; p++) {
 877             for (b = 0; b < ctx->planes[p].num_bands; b++) {
 878                 result = decode_band(ctx, &ctx->planes[p].bands[b], avctx);
 879                 if (result) {
 880                     av_log(avctx, AV_LOG_ERROR,
 881                            "Error while decoding band: %d, plane: %d\n", b, p);
 882                     return -1;
 883                 }
 884             }
 885         }
 886         ctx->buf_invalid[ctx->dst_buf] = 0;
 887     }
 888     if (ctx->buf_invalid[ctx->dst_buf])
 889         return -1;
 890
 891     //STOP_TIMER("decode_planes"); }
 892
 893     /* If the bidirectional mode is enabled, next I and the following P frame will */
 894     /* be sent together. Unfortunately the approach below seems to be the only way */
 895     /* to handle the B-frames mode. That's exactly the same Intel decoders do.     */
 896     if (avctx->codec_id == AV_CODEC_ID_INDEO4 && ctx->frame_type == 0/*FRAMETYPE_INTRA*/) {
 897         while (get_bits(&ctx->gb, 8)); // skip version string
 898         skip_bits_long(&ctx->gb, 64);  // skip padding, TODO: implement correct 8-bytes alignment
 899         if (get_bits_left(&ctx->gb) > 18 && show_bits(&ctx->gb, 18) == 0x3FFF8)
 900             av_log(avctx, AV_LOG_ERROR, "Buffer contains IP frames!\n");
 901     }
 902
 903     if (!ctx->is_nonnull_frame(ctx))
 904         return buf_size;
 905
 906     if (ctx->frame.data[0])
 907         avctx->release_buffer(avctx, &ctx->frame);
 908
 909     ctx->frame.reference = 0;
 910     avcodec_set_dimensions(avctx, ctx->planes[0].width, ctx->planes[0].height);
 911     if ((result = ff_get_buffer(avctx, &ctx->frame)) < 0) {
 912         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
 913         return result;
 914     }
 915
 916     if (ctx->is_scalable) {
 917         if (avctx->codec_id == AV_CODEC_ID_INDEO4)
 918             ff_ivi_recompose_haar(&ctx->planes[0], ctx->frame.data[0], ctx->frame.linesize[0]);
 919         else
 920             ff_ivi_recompose53   (&ctx->planes[0], ctx->frame.data[0], ctx->frame.linesize[0]);
 921     } else {
 922         ivi_output_plane(&ctx->planes[0], ctx->frame.data[0], ctx->frame.linesize[0]);
 923     }
 924
 925     ivi_output_plane(&ctx->planes[2], ctx->frame.data[1], ctx->frame.linesize[1]);
 926     ivi_output_plane(&ctx->planes[1], ctx->frame.data[2], ctx->frame.linesize[2]);
 927
 928     *got_frame = 1;
 929     *(AVFrame*)data = ctx->frame;
 930
 931     return buf_size;
 932 }
 933
 934 /**
 935  *  Close Indeo5 decoder and clean up its context.
 936  */
 937 av_cold int ff_ivi_decode_close(AVCodecContext *avctx)
 938 {
 939     IVI45DecContext *ctx = avctx->priv_data;
 940
 941     ivi_free_buffers(&ctx->planes[0]);
 942
 943     if (ctx->mb_vlc.cust_tab.table)
 944         ff_free_vlc(&ctx->mb_vlc.cust_tab);
 945
 946     if (ctx->frame.data[0])
 947         avctx->release_buffer(avctx, &ctx->frame);
 948
 949 #if IVI4_STREAM_ANALYSER
 950     if (avctx->codec_id == AV_CODEC_ID_INDEO4) {
 951     if (ctx->is_scalable)
 952         av_log(avctx, AV_LOG_ERROR, "This video uses scalability mode!\n");
 953     if (ctx->uses_tiling)
 954         av_log(avctx, AV_LOG_ERROR, "This video uses local decoding!\n");
 955     if (ctx->has_b_frames)
 956         av_log(avctx, AV_LOG_ERROR, "This video contains B-frames!\n");
 957     if (ctx->has_transp)
 958         av_log(avctx, AV_LOG_ERROR, "Transparency mode is enabled!\n");
 959     if (ctx->uses_haar)
 960         av_log(avctx, AV_LOG_ERROR, "This video uses Haar transform!\n");
 961     if (ctx->uses_fullpel)
 962         av_log(avctx, AV_LOG_ERROR, "This video uses fullpel motion vectors!\n");
 963     }
 964 #endif
 965
 966     return 0;
 967 }
 968
 969
 970 /**
 971  * These are 2x8 predefined Huffman codebooks for coding macroblock/block
 972  * signals. They are specified using "huffman descriptors" in order to
 973  * avoid huge static tables. The decoding tables will be generated at
 974  * startup from these descriptors.
 975  */
 976 const IVIHuffDesc ff_ivi_mb_huff_desc[8] = {
 977     {8,  {0, 4, 5, 4, 4, 4, 6, 6}},
 978     {12, {0, 2, 2, 3, 3, 3, 3, 5, 3, 2, 2, 2}},
 979     {12, {0, 2, 3, 4, 3, 3, 3, 3, 4, 3, 2, 2}},
 980     {12, {0, 3, 4, 4, 3, 3, 3, 3, 3, 2, 2, 2}},
 981     {13, {0, 4, 4, 3, 3, 3, 3, 2, 3, 3, 2, 1, 1}},
 982     {9,  {0, 4, 4, 4, 4, 3, 3, 3, 2}},
 983     {10, {0, 4, 4, 4, 4, 3, 3, 2, 2, 2}},
 984     {12, {0, 4, 4, 4, 3, 3, 2, 3, 2, 2, 2, 2}}
 985 };
 986
 987 const IVIHuffDesc ff_ivi_blk_huff_desc[8] = {
 988     {10, {1, 2, 3, 4, 4, 7, 5, 5, 4, 1}},
 989     {11, {2, 3, 4, 4, 4, 7, 5, 4, 3, 3, 2}},
 990     {12, {2, 4, 5, 5, 5, 5, 6, 4, 4, 3, 1, 1}},
 991     {13, {3, 3, 4, 4, 5, 6, 6, 4, 4, 3, 2, 1, 1}},
 992     {11, {3, 4, 4, 5, 5, 5, 6, 5, 4, 2, 2}},
 993     {13, {3, 4, 5, 5, 5, 5, 6, 4, 3, 3, 2, 1, 1}},
 994     {13, {3, 4, 5, 5, 5, 6, 5, 4, 3, 3, 2, 1, 1}},
 995     {9,  {3, 4, 4, 5, 5, 5, 6, 5, 5}}
 996 };
 997
 998
 999 /**
1000  *  Scan patterns shared between indeo4 and indeo5
1001  */
1002 const uint8_t ff_ivi_vertical_scan_8x8[64] = {
1003     0,  8, 16, 24, 32, 40, 48, 56,
1004     1,  9, 17, 25, 33, 41, 49, 57,
1005     2, 10, 18, 26, 34, 42, 50, 58,
1006     3, 11, 19, 27, 35, 43, 51, 59,
1007     4, 12, 20, 28, 36, 44, 52, 60,
1008     5, 13, 21, 29, 37, 45, 53, 61,
1009     6, 14, 22, 30, 38, 46, 54, 62,
1010     7, 15, 23, 31, 39, 47, 55, 63
1011 };
1012
1013 const uint8_t ff_ivi_horizontal_scan_8x8[64] = {
1014      0,  1,  2,  3,  4,  5,  6,  7,
1015      8,  9, 10, 11, 12, 13, 14, 15,
1016     16, 17, 18, 19, 20, 21, 22, 23,
1017     24, 25, 26, 27, 28, 29, 30, 31,
1018     32, 33, 34, 35, 36, 37, 38, 39,
1019     40, 41, 42, 43, 44, 45, 46, 47,
1020     48, 49, 50, 51, 52, 53, 54, 55,
1021     56, 57, 58, 59, 60, 61, 62, 63
1022 };
1023
1024 const uint8_t ff_ivi_direct_scan_4x4[16] = {
1025     0, 1, 4, 8, 5, 2, 3, 6, 9, 12, 13, 10, 7, 11, 14, 15
1026 };
1027
1028
1029 /**
1030  *  Run-value (RLE) tables.
1031  */
1032 const RVMapDesc ff_ivi_rvmap_tabs[9] = {
1033 {   /* MapTab0 */
1034     5, /* eob_sym */
1035     2, /* esc_sym */
1036     /* run table */
1037     {1,  1,  0,  1,  1,  0,  1,  1,  2,  2,  1,  1,  1,  1,  3,  3,
1038      1,  1,  2,  2,  1,  1,  4,  4,  1,  1,  1,  1,  2,  2,  5,  5,
1039      1,  1,  3,  3,  1,  1,  6,  6,  1,  2,  1,  2,  7,  7,  1,  1,
1040      8,  8,  1,  1,  4,  2,  1,  4,  2,  1,  3,  3,  1,  1,  1,  9,
1041      9,  1,  2,  1,  2,  1,  5,  5,  1,  1, 10, 10,  1,  1,  3,  3,
1042      2,  2,  1,  1, 11, 11,  6,  4,  4,  1,  6,  1,  2,  1,  2, 12,
1043      8,  1, 12,  7,  8,  7,  1, 16,  1, 16,  1,  3,  3, 13,  1, 13,
1044      2,  2,  1, 15,  1,  5, 14, 15,  1,  5, 14,  1, 17,  8, 17,  8,
1045      1,  4,  4,  2,  2,  1, 25, 25, 24, 24,  1,  3,  1,  3,  1,  8,
1046      6,  7,  6,  1, 18,  8, 18,  1,  7, 23,  2,  2, 23,  1,  1, 21,
1047     22,  9,  9, 22, 19,  1, 21,  5, 19,  5,  1, 33, 20, 33, 20,  8,
1048      4,  4,  1, 32,  2,  2,  8,  3, 32, 26,  3,  1,  7,  7, 26,  6,
1049      1,  6,  1,  1, 16,  1, 10,  1, 10,  2, 16, 29, 28,  2, 29, 28,
1050      1, 27,  5,  8,  5, 27,  1,  8,  3,  7,  3, 31, 41, 31,  1, 41,
1051      6,  1,  6,  7,  4,  4,  1,  1,  2,  1,  2, 11, 34, 30, 11,  1,
1052     30, 15, 15, 34, 36, 40, 36, 40, 35, 35, 37, 37, 39, 39, 38, 38},
1053
1054     /* value table */
1055     { 1,  -1,   0,   2,  -2,   0,   3,  -3,   1,  -1,   4,  -4,   5,  -5,   1,  -1,
1056       6,  -6,   2,  -2,   7,  -7,   1,  -1,   8,  -8,   9,  -9,   3,  -3,   1,  -1,
1057      10, -10,   2,  -2,  11, -11,   1,  -1,  12,   4, -12,  -4,   1,  -1,  13, -13,
1058       1,  -1,  14, -14,   2,   5,  15,  -2,  -5, -15,  -3,   3,  16, -16,  17,   1,
1059      -1, -17,   6,  18,  -6, -18,   2,  -2,  19, -19,   1,  -1,  20, -20,   4,  -4,
1060       7,  -7,  21, -21,   1,  -1,   2,   3,  -3,  22,  -2, -22,   8,  23,  -8,   1,
1061       2, -23,  -1,   2,  -2,  -2,  24,   1, -24,  -1,  25,   5,  -5,   1, -25,  -1,
1062       9,  -9,  26,   1, -26,   3,   1,  -1,  27,  -3,  -1, -27,   1,   3,  -1,  -3,
1063      28,  -4,   4,  10, -10, -28,   1,  -1,   1,  -1,  29,   6, -29,  -6,  30,  -4,
1064       3,   3,  -3, -30,   1,   4,  -1,  31,  -3,   1,  11, -11,  -1, -31,  32,  -1,
1065      -1,   2,  -2,   1,   1, -32,   1,   4,  -1,  -4,  33,  -1,   1,   1,  -1,   5,
1066       5,  -5, -33,  -1, -12,  12,  -5,  -7,   1,   1,   7,  34,   4,  -4,  -1,   4,
1067     -34,  -4,  35,  36,  -2, -35,  -2, -36,   2,  13,   2,  -1,   1, -13,   1,  -1,
1068      37,   1,  -5,   6,   5,  -1,  38,  -6,  -8,   5,   8,  -1,   1,   1, -37,  -1,
1069       5,  39,  -5,  -5,   6,  -6, -38, -39, -14,  40,  14,   2,   1,   1,  -2, -40,
1070      -1,  -2,   2,  -1,  -1,  -1,   1,   1,   1,  -1,   1,  -1,   1,  -1,   1,  -1}
1071 },{
1072     /* MapTab1 */
1073     0,  /* eob_sym */
1074     38, /* esc_sym */
1075     /* run table */
1076     {0,  1,  1,  2,  2,  3,  3,  4,  4,  5,  5,  6,  8,  6,  8,  7,
1077      7,  9,  9, 10, 10, 11, 11,  1, 12,  1, 12, 13, 13, 16, 14, 16,
1078     14, 15, 15, 17, 17, 18,  0, 18, 19, 20, 21, 19, 22, 21, 20, 22,
1079     25, 24,  2, 25, 24, 23, 23,  2, 26, 28, 26, 28, 29, 27, 29, 27,
1080     33, 33,  1, 32,  1,  3, 32, 30, 36,  3, 36, 30, 31, 31, 35, 34,
1081     37, 41, 34, 35, 37,  4, 41,  4, 49,  8,  8, 49, 40, 38,  5, 38,
1082     40, 39,  5, 39, 42, 43, 42,  7, 57,  6, 43, 44,  6, 50,  7, 44,
1083     57, 48, 50, 48, 45, 45, 46, 47, 51, 46, 47, 58,  1, 51, 58,  1,
1084     52, 59, 53,  9, 52, 55, 55, 59, 53, 56, 54, 56, 54,  9, 64, 64,
1085     60, 63, 60, 63, 61, 62, 61, 62,  2, 10,  2, 10, 11,  1, 11, 13,
1086     12,  1, 12, 13, 16, 16,  8,  8, 14,  3,  3, 15, 14, 15,  4,  4,
1087      1, 17, 17,  5,  1,  7,  7,  5,  6,  1,  2,  2,  6, 22,  1, 25,
1088     21, 22,  8, 24,  1, 21, 25, 24,  8, 18, 18, 23,  9, 20, 23, 33,
1089     29, 33, 20,  1, 19,  1, 29, 36,  9, 36, 19, 41, 28, 57, 32,  3,
1090     28,  3,  1, 27, 49, 49,  1, 32, 26, 26,  2,  4,  4,  7, 57, 41,
1091      2,  7, 10,  5, 37, 16, 10, 27,  8,  8, 13, 16, 37, 13,  1,  5},
1092
1093     /* value table */
1094     {0,   1,  -1,   1,  -1,   1,  -1,   1,  -1,   1,  -1,   1,   1,  -1,  -1,   1,
1095     -1,   1,  -1,   1,  -1,   1,  -1,   2,   1,  -2,  -1,   1,  -1,   1,   1,  -1,
1096     -1,   1,  -1,   1,  -1,   1,   0,  -1,   1,   1,   1,  -1,   1,  -1,  -1,  -1,
1097      1,   1,   2,  -1,  -1,   1,  -1,  -2,   1,   1,  -1,  -1,   1,   1,  -1,  -1,
1098      1,  -1,   3,   1,  -3,   2,  -1,   1,   1,  -2,  -1,  -1,  -1,   1,   1,   1,
1099      1,   1,  -1,  -1,  -1,   2,  -1,  -2,   1,   2,  -2,  -1,   1,   1,   2,  -1,
1100     -1,   1,  -2,  -1,   1,   1,  -1,   2,   1,   2,  -1,   1,  -2,  -1,  -2,  -1,
1101     -1,   1,   1,  -1,   1,  -1,   1,   1,   1,  -1,  -1,   1,   4,  -1,  -1,  -4,
1102      1,   1,   1,   2,  -1,  -1,   1,  -1,  -1,   1,  -1,  -1,   1,  -2,   1,  -1,
1103      1,   1,  -1,  -1,   1,   1,  -1,  -1,   3,   2,  -3,  -2,   2,   5,  -2,   2,
1104      2,  -5,  -2,  -2,  -2,   2,  -3,   3,   2,   3,  -3,   2,  -2,  -2,   3,  -3,
1105      6,   2,  -2,   3,  -6,   3,  -3,  -3,   3,   7,  -4,   4,  -3,   2,  -7,   2,
1106      2,  -2,  -4,   2,   8,  -2,  -2,  -2,   4,   2,  -2,   2,   3,   2,  -2,  -2,
1107      2,   2,  -2,  -8,  -2,   9,  -2,   2,  -3,  -2,   2,  -2,   2,   2,   2,   4,
1108     -2,  -4,  10,   2,   2,  -2,  -9,  -2,   2,  -2,   5,   4,  -4,   4,  -2,   2,
1109     -5,  -4,  -3,   4,   2,  -3,   3,  -2,  -5,   5,   3,   3,  -2,  -3, -10,  -4}
1110 },{
1111     /* MapTab2 */
1112     2,  /* eob_sym */
1113     11, /* esc_sym */
1114     /* run table */
1115     {1,  1,  0,  2,  2,  1,  1,  3,  3,  4,  4,  0,  1,  1,  5,  5,
1116      2,  2,  6,  6,  7,  7,  1,  8,  1,  8,  3,  3,  9,  9,  1,  2,
1117      2,  1,  4, 10,  4, 10, 11, 11,  1,  5, 12, 12,  1,  5, 13, 13,
1118      3,  3,  6,  6,  2,  2, 14, 14, 16, 16, 15,  7, 15,  8,  8,  7,
1119      1,  1, 17, 17,  4,  4,  1,  1, 18, 18,  2,  2,  5,  5, 25,  3,
1120      9,  3, 25,  9, 19, 24, 19, 24,  1, 21, 20,  1, 21, 22, 20, 22,
1121     23, 23,  8,  6, 33,  6,  8, 33,  7,  7, 26, 26,  1, 32,  1, 32,
1122     28,  4, 28, 10, 29, 27, 27, 10, 41,  4, 29,  2,  2, 41, 36, 31,
1123     49, 31, 34, 30, 34, 36, 30, 35,  1, 49, 11,  5, 35, 11,  1,  3,
1124      3,  5, 37, 37,  8, 40,  8, 40, 12, 12, 42, 42,  1, 38, 16, 57,
1125      1,  6, 16, 39, 38,  6,  7,  7, 13, 13, 39, 43,  2, 43, 57,  2,
1126     50,  9, 44,  9, 50,  4, 15, 48, 44,  4,  1, 15, 48, 14, 14,  1,
1127     45, 45,  8,  3,  5,  8, 51, 47,  3, 46, 46, 47,  5, 51,  1, 17,
1128     17, 58,  1, 58,  2, 52, 52,  2, 53,  7, 59,  6,  6, 56, 53, 55,
1129      7, 55,  1, 54, 59, 56, 54, 10,  1, 10,  4, 60,  1, 60,  8,  4,
1130      8, 64, 64, 61,  1, 63,  3, 63, 62, 61,  5, 11,  5,  3, 11, 62},
1131
1132     /* value table */
1133     { 1,  -1,   0,   1,  -1,   2,  -2,   1,  -1,   1,  -1,   0,   3,  -3,   1,  -1,
1134       2,  -2,   1,  -1,   1,  -1,   4,   1,  -4,  -1,   2,  -2,   1,  -1,   5,   3,
1135      -3,  -5,   2,   1,  -2,  -1,   1,  -1,   6,   2,   1,  -1,  -6,  -2,   1,  -1,
1136       3,  -3,   2,  -2,   4,  -4,   1,  -1,   1,  -1,   1,   2,  -1,   2,  -2,  -2,
1137       7,  -7,   1,  -1,   3,  -3,   8,  -8,   1,  -1,   5,  -5,   3,  -3,   1,   4,
1138       2,  -4,  -1,  -2,   1,   1,  -1,  -1,   9,   1,   1,  -9,  -1,   1,  -1,  -1,
1139       1,  -1,   3,  -3,   1,   3,  -3,  -1,   3,  -3,   1,  -1,  10,   1, -10,  -1,
1140       1,   4,  -1,   2,   1,  -1,   1,  -2,   1,  -4,  -1,   6,  -6,  -1,   1,   1,
1141       1,  -1,   1,   1,  -1,  -1,  -1,   1,  11,  -1,  -2,   4,  -1,   2, -11,   5,
1142      -5,  -4,  -1,   1,   4,   1,  -4,  -1,  -2,   2,   1,  -1,  12,   1,  -2,   1,
1143     -12,   4,   2,   1,  -1,  -4,   4,  -4,   2,  -2,  -1,   1,   7,  -1,  -1,  -7,
1144      -1,  -3,   1,   3,   1,   5,   2,   1,  -1,  -5,  13,  -2,  -1,   2,  -2, -13,
1145       1,  -1,   5,   6,   5,  -5,   1,   1,  -6,   1,  -1,  -1,  -5,  -1,  14,   2,
1146      -2,   1, -14,  -1,   8,   1,  -1,  -8,   1,   5,   1,   5,  -5,   1,  -1,   1,
1147      -5,  -1,  15,   1,  -1,  -1,  -1,   3, -15,  -3,   6,   1,  16,  -1,   6,  -6,
1148      -6,   1,  -1,   1, -16,   1,   7,  -1,   1,  -1,  -6,  -3,   6,  -7,   3,  -1}
1149 },{
1150     /* MapTab3 */
1151     0,  /* eob_sym */
1152     35, /* esc_sym */
1153     /* run table */
1154     {0,  1,  1,  2,  2,  3,  3,  4,  4,  1,  1,  5,  5,  6,  6,  7,
1155      7,  8,  8,  9,  9,  2,  2, 10, 10,  1,  1, 11, 11, 12, 12,  3,
1156      3, 13, 13,  0, 14, 14, 16, 15, 16, 15,  4,  4, 17,  1, 17,  1,
1157      5,  5, 18, 18,  2,  2,  6,  6,  8, 19,  7,  8,  7, 19, 20, 20,
1158     21, 21, 22, 24, 22, 24, 23, 23,  1,  1, 25, 25,  3,  3, 26, 26,
1159      9,  9, 27, 27, 28, 28, 33, 29,  4, 33, 29,  1,  4,  1, 32, 32,
1160      2,  2, 31, 10, 30, 10, 30, 31, 34, 34,  5,  5, 36, 36, 35, 41,
1161     35, 11, 41, 11, 37,  1,  8,  8, 37,  6,  1,  6, 40,  7,  7, 40,
1162     12, 38, 12, 39, 39, 38, 49, 13, 49, 13,  3, 42,  3, 42, 16, 16,
1163     43, 43, 14, 14,  1,  1, 44, 15, 44, 15,  2,  2, 57, 48, 50, 48,
1164     57, 50,  4, 45, 45,  4, 46, 47, 47, 46,  1, 51,  1, 17, 17, 51,
1165      8,  9,  9,  5, 58,  8, 58,  5, 52, 52, 55, 56, 53, 56, 55, 59,
1166     59, 53, 54,  1,  6, 54,  7,  7,  6,  1,  2,  3,  2,  3, 64, 60,
1167     60, 10, 10, 64, 61, 62, 61, 63,  1, 63, 62,  1, 18, 24, 18,  4,
1168     25,  4,  8, 21, 21,  1, 24, 22, 25, 22,  8, 11, 19, 11, 23,  1,
1169     20, 23, 19, 20,  5, 12,  5,  1, 16,  2, 12, 13,  2, 13,  1, 16},
1170
1171     /* value table */
1172     { 0,   1,  -1,   1,  -1,   1,  -1,   1,  -1,   2,  -2,   1,  -1,   1,  -1,   1,
1173      -1,   1,  -1,   1,  -1,   2,  -2,   1,  -1,   3,  -3,   1,  -1,   1,  -1,   2,
1174      -2,   1,  -1,   0,   1,  -1,   1,   1,  -1,  -1,   2,  -2,   1,   4,  -1,  -4,
1175       2,  -2,   1,  -1,  -3,   3,   2,  -2,   2,   1,   2,  -2,  -2,  -1,   1,  -1,
1176       1,  -1,   1,   1,  -1,  -1,   1,  -1,   5,  -5,   1,  -1,   3,  -3,   1,  -1,
1177       2,  -2,   1,  -1,   1,  -1,   1,   1,   3,  -1,  -1,   6,  -3,  -6,  -1,   1,
1178       4,  -4,   1,   2,   1,  -2,  -1,  -1,   1,  -1,   3,  -3,   1,  -1,   1,   1,
1179      -1,   2,  -1,  -2,   1,   7,  -3,   3,  -1,   3,  -7,  -3,   1,  -3,   3,  -1,
1180       2,   1,  -2,   1,  -1,  -1,   1,   2,  -1,  -2,  -4,  -1,   4,   1,   2,  -2,
1181       1,  -1,  -2,   2,   8,  -8,  -1,   2,   1,  -2,  -5,   5,   1,  -1,  -1,   1,
1182      -1,   1,   4,  -1,   1,  -4,  -1,  -1,   1,   1,   9,   1,  -9,   2,  -2,  -1,
1183      -4,   3,  -3,  -4,  -1,   4,   1,   4,   1,  -1,   1,  -1,   1,   1,  -1,   1,
1184      -1,  -1,  -1,  10,   4,   1,   4,  -4,  -4, -10,   6,   5,  -6,  -5,   1,  -1,
1185       1,   3,  -3,  -1,   1,  -1,  -1,  -1,  11,   1,   1, -11,  -2,  -2,   2,   5,
1186      -2,  -5,  -5,   2,  -2,  12,   2,  -2,   2,   2,   5,  -3,  -2,   3,  -2, -12,
1187      -2,   2,   2,   2,  -5,   3,   5,  13,  -3,   7,  -3,  -3,  -7,   3, -13,   3}
1188 },{
1189     /* MapTab4 */
1190     0,  /* eob_sym */
1191     34, /* esc_sym */
1192     /* run table */
1193     {0,  1,  1,  1,  2,  2,  1,  3,  3,  1,  1,  1,  4,  4,  1,  5,
1194      2,  1,  5,  2,  1,  1,  6,  6,  1,  1,  1,  1,  1,  7,  3,  1,
1195      2,  3,  0,  1,  2,  7,  1,  1,  1,  8,  1,  1,  8,  1,  1,  1,
1196      9,  1,  9,  1,  2,  1,  1,  2,  1,  1, 10,  4,  1, 10,  1,  4,
1197      1,  1,  1,  1,  1,  3,  1,  1,  1,  3,  2,  1,  5,  1,  1,  1,
1198      2,  5,  1, 11,  1, 11,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,
1199      2,  1,  6,  1,  6,  1,  1,  2,  1,  1,  1,  1,  1,  1,  1, 12,
1200      3,  1, 12,  1,  1,  1,  2,  1,  1,  3,  1,  1,  1,  1,  1,  1,
1201      4,  1,  1,  1,  2,  1,  1,  4,  1,  1,  1,  1,  1,  1,  2,  1,
1202      1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  3,  1,  2,  1,  1,  5,
1203      1,  1,  1,  1,  1,  7,  1,  7,  1,  1,  2,  3,  1,  1,  1,  1,
1204      5,  1,  1,  1,  1,  1,  1,  2, 13,  1,  1,  1,  1,  1,  1,  1,
1205      1,  1,  1,  1,  1,  1,  1,  1, 13,  2,  1,  1,  4,  1,  1,  1,
1206      3,  1,  6,  1,  1,  1, 14,  1,  1,  1,  1,  1, 14,  6,  1,  1,
1207      1,  1, 15,  2,  4,  1,  2,  3, 15,  1,  1,  1,  8,  1,  1,  8,
1208      1,  1,  1,  1,  1,  1,  1,  1,  2,  1,  1,  1,  1,  1,  1,  1},
1209
1210     /* value table */
1211     { 0,   1,  -1,   2,   1,  -1,  -2,   1,  -1,   3,  -3,   4,   1,  -1,  -4,   1,
1212       2,   5,  -1,  -2,  -5,   6,   1,  -1,  -6,   7,  -7,   8,  -8,   1,   2,   9,
1213       3,  -2,   0,  -9,  -3,  -1,  10, -10,  11,   1, -11,  12,  -1, -12,  13, -13,
1214       1,  14,  -1, -14,   4,  15, -15,  -4,  16, -16,   1,   2,  17,  -1, -17,  -2,
1215      18, -18,  19, -19,  20,   3, -20,  21, -21,  -3,   5,  22,   2, -22, -23,  23,
1216      -5,  -2,  24,   1, -24,  -1,  25, -25,  26, -26, -27,  27,  28,  29, -28, -29,
1217       6,  30,   2, -31,  -2, -30,  31,  -6, -32,  32,  33, -33,  34, -35, -34,   1,
1218       4, -36,  -1,  35,  37,  36,   7, -37,  38,  -4, -38,  39,  41,  40, -40, -39,
1219       3,  42, -43, -41,  -7, -42,  43,  -3,  44, -44,  45, -45,  46,  47,   8, -47,
1220     -48, -46,  50, -50,  48,  49,  51, -49,  52, -52,   5, -51,  -8, -53,  53,   3,
1221     -56,  56,  55,  54, -54,   2,  60,  -2, -55,  58,   9,  -5,  59,  57, -57, -63,
1222      -3, -58, -60, -61,  61, -59, -62,  -9,   1,  64,  62,  69, -64,  63,  65, -67,
1223     -68,  66, -65,  68, -66, -69,  67, -70,  -1,  10,  71, -71,   4,  73,  72,  70,
1224       6, -76,  -3,  74, -78, -74,   1,  78,  80, -72, -75,  76,  -1,   3, -73,  79,
1225      75,  77,   1,  11,  -4, -79, -10,  -6,  -1, -77, -83, -80,   2,  81, -84,  -2,
1226      83, -81,  82, -82,  84, -87, -86,  85, -11, -85,  86, -89,  87, -88,  88,  89}
1227 },{
1228     /* MapTab5 */
1229     2,  /* eob_sym */
1230     33, /* esc_sym */
1231     /* run table */
1232     {1,  1,  0,  2,  1,  2,  1,  3,  3,  1,  1,  4,  4,  2,  2,  1,
1233      1,  5,  5,  6,  1,  6,  1,  7,  7,  3,  3,  2,  8,  2,  8,  1,
1234      1,  0,  9,  9,  1,  1, 10,  4, 10,  4, 11, 11,  2,  1,  2,  1,
1235     12, 12,  3,  3,  1,  1, 13,  5,  5, 13, 14,  1,  1, 14,  2,  2,
1236      6,  6, 15,  1,  1, 15, 16,  4,  7, 16,  4,  7,  1,  1,  3,  3,
1237      8,  8,  2,  2,  1,  1, 17, 17,  1,  1, 18, 18,  5,  5,  2,  2,
1238      1,  1,  9, 19,  9, 19, 20,  3,  3, 20,  1, 10, 21,  1, 10,  4,
1239      4, 21, 22,  6,  6, 22,  1,  1, 23, 24,  2,  2, 23, 24, 11,  1,
1240      1, 11,  7, 25,  7,  1,  1, 25,  8,  8,  3, 26,  3,  1, 12,  2,
1241      2, 26,  1, 12,  5,  5, 27,  4,  1,  4,  1, 27, 28,  1, 28, 13,
1242      1, 13,  2, 29,  2,  1, 32,  6,  1, 30, 14, 29, 14,  6,  3, 31,
1243      3,  1, 30,  1, 32, 31, 33,  9, 33,  1,  1,  7,  9,  7,  2,  2,
1244      1,  1,  4, 36, 34,  4,  5, 10, 10,  5, 34,  1,  1, 35,  8,  8,
1245     36,  3, 35,  1, 15,  3,  2,  1, 16, 15, 16,  2, 37,  1, 37,  1,
1246      1,  1,  6,  6, 38,  1, 38, 11,  1, 39, 39, 40, 11,  2, 41,  4,
1247     40,  1,  2,  4,  1,  1,  1, 41,  3,  1,  3,  1,  5,  7,  5,  7},
1248
1249     /* value table */
1250     { 1,  -1,   0,   1,   2,  -1,  -2,   1,  -1,   3,  -3,   1,  -1,   2,  -2,   4,
1251      -4,   1,  -1,   1,   5,  -1,  -5,   1,  -1,   2,  -2,   3,   1,  -3,  -1,   6,
1252      -6,   0,   1,  -1,   7,  -7,   1,   2,  -1,  -2,   1,  -1,   4,   8,  -4,  -8,
1253       1,  -1,   3,  -3,   9,  -9,   1,   2,  -2,  -1,   1,  10, -10,  -1,   5,  -5,
1254       2,  -2,   1,  11, -11,  -1,   1,   3,   2,  -1,  -3,  -2,  12, -12,   4,  -4,
1255       2,  -2,  -6,   6,  13, -13,   1,  -1,  14, -14,   1,  -1,   3,  -3,   7,  -7,
1256      15, -15,   2,   1,  -2,  -1,   1,   5,  -5,  -1, -16,   2,   1,  16,  -2,   4,
1257      -4,  -1,   1,   3,  -3,  -1,  17, -17,   1,   1,  -8,   8,  -1,  -1,   2,  18,
1258     -18,  -2,   3,   1,  -3,  19, -19,  -1,   3,  -3,   6,   1,  -6,  20,   2,   9,
1259      -9,  -1, -20,  -2,   4,  -4,   1,  -5,  21,   5, -21,  -1,   1, -22,  -1,   2,
1260      22,  -2,  10,   1, -10,  23,   1,   4, -23,   1,   2,  -1,  -2,  -4,  -7,   1,
1261       7, -24,  -1,  24,  -1,  -1,   1,   3,  -1, -25,  25,   4,  -3,  -4,  11, -11,
1262      26, -26,   6,   1,   1,  -6,  -5,  -3,   3,   5,  -1, -27,  27,   1,   4,  -4,
1263      -1,  -8,  -1,  28,   2,   8, -12, -28,  -2,  -2,   2,  12,  -1,  29,   1, -29,
1264      30, -30,   5,  -5,   1, -31,  -1,   3,  31,  -1,   1,   1,  -3, -13,   1,  -7,
1265      -1, -32,  13,   7,  32,  33, -33,  -1,  -9, -34,   9,  34,  -6,   5,   6,  -5}
1266 },{
1267     /* MapTab6 */
1268     2,  /* eob_sym */
1269     13, /* esc_sym */
1270     /* run table */
1271     {1,  1,  0,  1,  1,  2,  2,  1,  1,  3,  3,  1,  1,  0,  2,  2,
1272      4,  1,  4,  1,  1,  1,  5,  5,  1,  1,  6,  6,  2,  2,  1,  1,
1273      3,  3,  7,  7,  1,  1,  8,  8,  1,  1,  2,  2,  1,  9,  1,  9,
1274      4,  4, 10,  1,  1, 10,  1,  1, 11, 11,  3,  3,  1,  2,  1,  2,
1275      1,  1, 12, 12,  5,  5,  1,  1, 13,  1,  1, 13,  2,  2,  1,  1,
1276      6,  6,  1,  1,  4, 14,  4, 14,  3,  1,  3,  1,  1,  1, 15,  7,
1277     15,  2,  2,  7,  1,  1,  1,  8,  1,  8, 16, 16,  1,  1,  1,  1,
1278      2,  1,  1,  2,  1,  1,  3,  5,  5,  3,  4,  1,  1,  4,  1,  1,
1279     17, 17,  9,  1,  1,  9,  2,  2,  1,  1, 10, 10,  1,  6,  1,  1,
1280      6, 18,  1,  1, 18,  1,  1,  1,  2,  2,  3,  1,  3,  1,  1,  1,
1281      4,  1, 19,  1, 19,  7,  1,  1, 20,  1,  4, 20,  1,  7, 11,  2,
1282      1, 11, 21,  2,  8,  5,  1,  8,  1,  5, 21,  1,  1,  1, 22,  1,
1283      1, 22,  1,  1,  3,  3,  1, 23,  2, 12, 24,  1,  1,  2,  1,  1,
1284     12, 23,  1,  1, 24,  1,  1,  1,  4,  1,  1,  1,  2,  1,  6,  6,
1285      4,  2,  1,  1,  1,  1,  1,  1,  1, 14, 13,  3,  1, 25,  9, 25,
1286     14,  1,  9,  3, 13,  1,  1,  1,  1,  1, 10,  1,  1,  2, 10,  2},
1287
1288     /* value table */
1289     {-20,  -1,   0,   2,  -2,   1,  -1,   3,  -3,   1,  -1,   4,  -4,   0,   2,  -2,
1290        1,   5,  -1,  -5,   6,  -6,   1,  -1,   7,  -7,   1,  -1,   3,  -3,   8,  -8,
1291        2,  -2,   1,  -1,   9,  -9,   1,  -1,  10, -10,   4,  -4,  11,   1, -11,  -1,
1292        2,  -2,   1,  12, -12,  -1,  13, -13,   1,  -1,   3,  -3,  14,   5, -14,  -5,
1293      -15,  15,  -1,   1,   2,  -2,  16, -16,   1,  17, -17,  -1,   6,  -6,  18, -18,
1294        2,  -2, -19,  19,  -3,   1,   3,  -1,   4,  20,  -4,   1, -21,  21,   1,   2,
1295       -1,  -7,   7,  -2,  22, -22,  23,   2, -23,  -2,   1,  -1, -24,  24, -25,  25,
1296       -8, -26,  26,   8, -27,  27,   5,   3,  -3,  -5,  -4,  28, -28,   4,  29, -29,
1297        1,  -1,  -2, -30,  30,   2,   9,  -9, -31,  31,   2,  -2, -32,   3,  32, -33,
1298       -3,   1,  33, -34,  -1,  34, -35,  35, -10,  10,  -6,  36,   6, -36,  37, -37,
1299       -5,  38,   1, -38,  -1,   3,  39, -39,  -1,  40,   5,   1, -40,  -3,   2, -11,
1300      -41,  -2,   1,  11,  -3,  -4,  41,   3,  42,   4,  -1, -43, -42,  43,   1, -44,
1301       45,  -1,  44, -45,  -7,   7, -46,   1, -12,   2,   1, -47,  46,  12,  47,  48,
1302       -2,  -1, -48,  49,  -1, -50, -49,  50,  -6, -51,  51,  52, -13,  53,  -4,   4,
1303        6,  13, -53, -52, -54,  55,  54, -55, -56,  -2,   2,  -8,  56,   1,  -3,  -1,
1304        2,  58,   3,   8,  -2,  57, -58, -60, -59, -57,  -3,  60,  59, -14,   3,  14}
1305 },{
1306     /* MapTab7 */
1307     2,  /* eob_sym */
1308     38, /* esc_sym */
1309     /* run table */
1310     {1,  1,  0,  2,  2,  1,  1,  3,  3,  4,  4,  5,  5,  1,  1,  6,
1311      6,  2,  2,  7,  7,  8,  8,  1,  1,  3,  3,  9,  9, 10, 10,  1,
1312      1,  2,  2,  4,  4, 11,  0, 11, 12, 12, 13, 13,  1,  1,  5,  5,
1313     14, 14, 15, 16, 15, 16,  3,  3,  1,  6,  1,  6,  2,  2,  7,  7,
1314      8,  8, 17, 17,  1,  1,  4,  4, 18, 18,  2,  2,  1, 19,  1, 20,
1315     19, 20, 21, 21,  3,  3, 22, 22,  5,  5, 24,  1,  1, 23,  9, 23,
1316     24,  9,  2,  2, 10,  1,  1, 10,  6,  6, 25,  4,  4, 25,  7,  7,
1317     26,  8,  1,  8,  3,  1, 26,  3, 11, 11, 27, 27,  2, 28,  1,  2,
1318     28,  1, 12, 12,  5,  5, 29, 13, 13, 29, 32,  1,  1, 33, 31, 30,
1319     32,  4, 30, 33,  4, 31,  3, 14,  1,  1,  3, 34, 34,  2,  2, 14,
1320      6,  6, 35, 36, 35, 36,  1, 15,  1, 16, 16, 15,  7,  9,  7,  9,
1321     37,  8,  8, 37,  1,  1, 39,  2, 38, 39,  2, 40,  5, 38, 40,  5,
1322      3,  3,  4,  4, 10, 10,  1,  1,  1,  1, 41,  2, 41,  2,  6,  6,
1323      1,  1, 11, 42, 11, 43,  3, 42,  3, 17,  4, 43,  1, 17,  7,  1,
1324      8, 44,  4,  7, 44,  5,  8,  2,  5,  1,  2, 48, 45,  1, 12, 45,
1325     12, 48, 13, 13,  1,  9,  9, 46,  1, 46, 47, 47, 49, 18, 18, 49},
1326
1327     /* value table */
1328     { 1,  -1,   0,   1,  -1,   2,  -2,   1,  -1,   1,  -1,   1,  -1,   3,  -3,   1,
1329      -1,  -2,   2,   1,  -1,   1,  -1,   4,  -4,  -2,   2,   1,  -1,   1,  -1,   5,
1330      -5,  -3,   3,   2,  -2,   1,   0,  -1,   1,  -1,   1,  -1,   6,  -6,   2,  -2,
1331       1,  -1,   1,   1,  -1,  -1,  -3,   3,   7,   2,  -7,  -2,  -4,   4,   2,  -2,
1332       2,  -2,   1,  -1,   8,  -8,   3,  -3,   1,  -1,  -5,   5,   9,   1,  -9,   1,
1333      -1,  -1,   1,  -1,  -4,   4,   1,  -1,   3,  -3,   1, -10,  10,   1,   2,  -1,
1334      -1,  -2,   6,  -6,   2,  11, -11,  -2,   3,  -3,   1,  -4,   4,  -1,   3,  -3,
1335       1,   3,  12,  -3,  -5, -12,  -1,   5,   2,  -2,   1,  -1,  -7,   1,  13,   7,
1336      -1, -13,   2,  -2,   4,  -4,   1,   2,  -2,  -1,   1,  14, -14,   1,   1,   1,
1337      -1,  -5,  -1,  -1,   5,  -1,  -6,   2, -15,  15,   6,   1,  -1,  -8,   8,  -2,
1338      -4,   4,   1,   1,  -1,  -1,  16,   2, -16,  -2,   2,  -2,   4,   3,  -4,  -3,
1339      -1,  -4,   4,   1, -17,  17,  -1,  -9,   1,   1,   9,   1,  -5,  -1,  -1,   5,
1340      -7,   7,   6,  -6,   3,  -3,  18, -18,  19, -19,   1, -10,  -1,  10,  -5,   5,
1341      20, -20,  -3,   1,   3,   1,   8,  -1,  -8,   2,   7,  -1, -21,  -2,   5,  21,
1342       5,  -1,  -7,  -5,   1,  -6,  -5, -11,   6,  22,  11,   1,   1, -22,  -3,  -1,
1343       3,  -1,   3,  -3, -23,   4,  -4,   1,  23,  -1,   1,  -1,   1,  -2,   2,  -1}
1344 },{
1345     /* MapTab8 */
1346     4,  /* eob_sym */
1347     11, /* esc_sym */
1348     /* run table */
1349     {1,  1,  1,  1,  0,  2,  2,  1,  1,  3,  3,  0,  1,  1,  2,  2,
1350      4,  4,  1,  1,  5,  5,  1,  1,  2,  2,  3,  3,  6,  6,  1,  1,
1351      7,  7,  8,  1,  8,  2,  2,  1,  4,  4,  1,  3,  1,  3,  9,  9,
1352      2,  2,  1,  5,  1,  5, 10, 10,  1,  1, 11, 11,  3,  6,  3,  4,
1353      4,  6,  2,  2,  1, 12,  1, 12,  7, 13,  7, 13,  1,  1,  8,  8,
1354      2,  2, 14, 14, 16, 15, 16,  5,  5,  1,  3, 15,  1,  3,  4,  4,
1355      1,  1, 17, 17,  2,  2,  6,  6,  1, 18,  1, 18, 22, 21, 22, 21,
1356     25, 24, 25, 19,  9, 20,  9, 23, 19, 24, 20,  3, 23,  7,  3,  1,
1357      1,  7, 28, 26, 29,  5, 28, 26,  5,  8, 29,  4,  8, 27,  2,  2,
1358      4, 27,  1,  1, 10, 36, 10, 33, 33, 36, 30,  1, 32, 32,  1, 30,
1359      6, 31, 31, 35,  3,  6, 11, 11,  3,  2, 35,  2, 34,  1, 34,  1,
1360     37, 37, 12,  7, 12,  5, 41,  5,  4,  7,  1,  8, 13,  4,  1, 41,
1361     13, 38,  8, 38,  9,  1, 40, 40,  9,  1, 39,  2,  2, 49, 39, 42,
1362      3,  3, 14, 16, 49, 14, 16, 42, 43, 43,  6,  6, 15,  1,  1, 15,
1363     44, 44,  1,  1, 50, 48,  4,  5,  4,  7,  5,  2, 10, 10, 48,  7,
1364     50, 45,  2,  1, 45,  8,  8,  1, 46, 46,  3, 47, 47,  3,  1,  1},
1365
1366     /* value table */
1367     { 1,  -1,   2,  -2,   0,   1,  -1,   3,  -3,   1,  -1,   0,   4,  -4,   2,  -2,
1368       1,  -1,   5,  -5,   1,  -1,   6,  -6,   3,  -3,   2,  -2,   1,  -1,   7,  -7,
1369       1,  -1,   1,   8,  -1,   4,  -4,  -8,   2,  -2,   9,   3,  -9,  -3,   1,  -1,
1370       5,  -5,  10,   2, -10,  -2,   1,  -1,  11, -11,   1,  -1,  -4,   2,   4,   3,
1371      -3,  -2,   6,  -6,  12,   1, -12,  -1,   2,   1,  -2,  -1,  13, -13,   2,  -2,
1372       7,  -7,   1,  -1,   1,   1,  -1,   3,  -3,  14,   5,  -1, -14,  -5,   4,  -4,
1373      15, -15,   1,  -1,   8,  -8,  -3,   3,  16,   1, -16,  -1,   1,   1,  -1,  -1,
1374       1,   1,  -1,   1,   2,   1,  -2,   1,  -1,  -1,  -1,   6,  -1,   3,  -6,  17,
1375     -17,  -3,   1,   1,   1,   4,  -1,  -1,  -4,   3,  -1,   5,  -3,  -1,  -9,   9,
1376      -5,   1,  18, -18,   2,   1,  -2,   1,  -1,  -1,   1,  19,  -1,   1, -19,  -1,
1377       4,   1,  -1,   1,   7,  -4,  -2,   2,  -7,  10,  -1, -10,   1,  20,  -1, -20,
1378       1,  -1,   2,   4,  -2,   5,   1,  -5,   6,  -4,  21,   4,   2,  -6, -21,  -1,
1379      -2,   1,  -4,  -1,  -3,  22,  -1,   1,   3, -22,  -1,  11, -11,   1,   1,   1,
1380       8,  -8,   2,   2,  -1,  -2,  -2,  -1,   1,  -1,  -5,   5,   2,  23, -23,  -2,
1381       1,  -1,  24, -24,  -1,  -1,   7,   6,  -7,   5,  -6,  12,  -3,   3,   1,  -5,
1382       1,   1, -12,  25,  -1,  -5,   5, -25,  -1,   1,   9,   1,  -1,  -9,  26, -26}
1383 }
1384 };