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