libavcodec/ivi_common.c
Go to the documentation of this file.
00001 /*
00002  * common functions for Indeo Video Interactive codecs (Indeo4 and Indeo5)
00003  *
00004  * Copyright (c) 2009 Maxim Poliakovski
00005  *
00006  * This file is part of Libav.
00007  *
00008  * Libav is free software; you can redistribute it and/or
00009  * modify it under the terms of the GNU Lesser General Public
00010  * License as published by the Free Software Foundation; either
00011  * version 2.1 of the License, or (at your option) any later version.
00012  *
00013  * Libav is distributed in the hope that it will be useful,
00014  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00015  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00016  * Lesser General Public License for more details.
00017  *
00018  * You should have received a copy of the GNU Lesser General Public
00019  * License along with Libav; if not, write to the Free Software
00020  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
00021  */
00022 
00029 #define BITSTREAM_READER_LE
00030 #include "avcodec.h"
00031 #include "internal.h"
00032 #include "get_bits.h"
00033 #include "ivi_common.h"
00034 #include "libavutil/common.h"
00035 #include "libavutil/imgutils.h"
00036 #include "ivi_dsp.h"
00037 
00038 extern const IVIHuffDesc ff_ivi_mb_huff_desc[8];  
00039 extern const IVIHuffDesc ff_ivi_blk_huff_desc[8]; 
00040 
00041 VLC ff_ivi_mb_vlc_tabs [8];
00042 VLC ff_ivi_blk_vlc_tabs[8];
00043 
00044 typedef void (*ivi_mc_func) (int16_t *buf, const int16_t *ref_buf,
00045                              uint32_t pitch, int mc_type);
00046 
00047 static int ivi_mc(IVIBandDesc *band, ivi_mc_func mc,
00048                   int offs, int mv_x, int mv_y, int mc_type)
00049 {
00050     int ref_offs = offs + mv_y * band->pitch + mv_x;
00051     int buf_size = band->pitch * band->aheight;
00052     int min_size = band->pitch * (band->blk_size - 1) + band->blk_size;
00053     int ref_size = (mc_type > 1) * band->pitch + (mc_type & 1);
00054 
00055     if (offs < 0 || ref_offs < 0 || !band->ref_buf)
00056         return AVERROR_INVALIDDATA;
00057     if (buf_size - min_size < offs)
00058         return AVERROR_INVALIDDATA;
00059     if (buf_size - min_size - ref_size < ref_offs)
00060         return AVERROR_INVALIDDATA;
00061 
00062     mc(band->buf + offs, band->ref_buf + ref_offs, band->pitch, mc_type);
00063 
00064     return 0;
00065 }
00066 
00071 static uint16_t inv_bits(uint16_t val, int nbits)
00072 {
00073     uint16_t res;
00074 
00075     if (nbits <= 8) {
00076         res = av_reverse[val] >> (8 - nbits);
00077     } else
00078         res = ((av_reverse[val & 0xFF] << 8) +
00079                (av_reverse[val >> 8])) >> (16 - nbits);
00080 
00081     return res;
00082 }
00083 
00084 int ff_ivi_create_huff_from_desc(const IVIHuffDesc *cb, VLC *vlc, int flag)
00085 {
00086     int         pos, i, j, codes_per_row, prefix, not_last_row;
00087     uint16_t    codewords[256]; /* FIXME: move this temporal storage out? */
00088     uint8_t     bits[256];
00089 
00090     pos = 0; /* current position = 0 */
00091 
00092     for (i = 0; i < cb->num_rows; i++) {
00093         codes_per_row = 1 << cb->xbits[i];
00094         not_last_row  = (i != cb->num_rows - 1);
00095         prefix        = ((1 << i) - 1) << (cb->xbits[i] + not_last_row);
00096 
00097         for (j = 0; j < codes_per_row; j++) {
00098             if (pos >= 256) /* Some Indeo5 codebooks can have more than 256 */
00099                 break;      /* elements, but only 256 codes are allowed! */
00100 
00101             bits[pos] = i + cb->xbits[i] + not_last_row;
00102             if (bits[pos] > IVI_VLC_BITS)
00103                 return AVERROR_INVALIDDATA; /* invalid descriptor */
00104 
00105             codewords[pos] = inv_bits((prefix | j), bits[pos]);
00106             if (!bits[pos])
00107                 bits[pos] = 1;
00108 
00109             pos++;
00110         }//for j
00111     }//for i
00112 
00113     /* number of codewords = pos */
00114     return init_vlc(vlc, IVI_VLC_BITS, pos, bits, 1, 1, codewords, 2, 2,
00115                     (flag ? INIT_VLC_USE_NEW_STATIC : 0) | INIT_VLC_LE);
00116 }
00117 
00118 void ff_ivi_init_static_vlc(void)
00119 {
00120     int i;
00121     static VLC_TYPE table_data[8192 * 16][2];
00122     static int initialized_vlcs = 0;
00123 
00124     if (initialized_vlcs)
00125         return;
00126     for (i = 0; i < 8; i++) {
00127         ff_ivi_mb_vlc_tabs[i].table = table_data + i * 2 * 8192;
00128         ff_ivi_mb_vlc_tabs[i].table_allocated = 8192;
00129         ff_ivi_create_huff_from_desc(&ff_ivi_mb_huff_desc[i],
00130                                      &ff_ivi_mb_vlc_tabs[i],  1);
00131         ff_ivi_blk_vlc_tabs[i].table = table_data + (i * 2 + 1) * 8192;
00132         ff_ivi_blk_vlc_tabs[i].table_allocated = 8192;
00133         ff_ivi_create_huff_from_desc(&ff_ivi_blk_huff_desc[i],
00134                                      &ff_ivi_blk_vlc_tabs[i], 1);
00135     }
00136     initialized_vlcs = 1;
00137 }
00138 
00139 int ff_ivi_dec_huff_desc(GetBitContext *gb, int desc_coded, int which_tab,
00140                          IVIHuffTab *huff_tab, AVCodecContext *avctx)
00141 {
00142     int i, result;
00143     IVIHuffDesc new_huff;
00144 
00145     if (!desc_coded) {
00146         /* select default table */
00147         huff_tab->tab = (which_tab) ? &ff_ivi_blk_vlc_tabs[7]
00148                                     : &ff_ivi_mb_vlc_tabs [7];
00149         return 0;
00150     }
00151 
00152     huff_tab->tab_sel = get_bits(gb, 3);
00153     if (huff_tab->tab_sel == 7) {
00154         /* custom huffman table (explicitly encoded) */
00155         new_huff.num_rows = get_bits(gb, 4);
00156         if (!new_huff.num_rows) {
00157             av_log(avctx, AV_LOG_ERROR, "Empty custom Huffman table!\n");
00158             return AVERROR_INVALIDDATA;
00159         }
00160 
00161         for (i = 0; i < new_huff.num_rows; i++)
00162             new_huff.xbits[i] = get_bits(gb, 4);
00163 
00164         /* Have we got the same custom table? Rebuild if not. */
00165         if (ff_ivi_huff_desc_cmp(&new_huff, &huff_tab->cust_desc)) {
00166             ff_ivi_huff_desc_copy(&huff_tab->cust_desc, &new_huff);
00167 
00168             if (huff_tab->cust_tab.table)
00169                 ff_free_vlc(&huff_tab->cust_tab);
00170             result = ff_ivi_create_huff_from_desc(&huff_tab->cust_desc,
00171                     &huff_tab->cust_tab, 0);
00172             if (result) {
00173                 huff_tab->cust_desc.num_rows = 0; // reset faulty description
00174                 av_log(avctx, AV_LOG_ERROR,
00175                        "Error while initializing custom vlc table!\n");
00176                 return result;
00177             }
00178         }
00179         huff_tab->tab = &huff_tab->cust_tab;
00180     } else {
00181         /* select one of predefined tables */
00182         huff_tab->tab = (which_tab) ? &ff_ivi_blk_vlc_tabs[huff_tab->tab_sel]
00183                                     : &ff_ivi_mb_vlc_tabs [huff_tab->tab_sel];
00184     }
00185 
00186     return 0;
00187 }
00188 
00189 int ff_ivi_huff_desc_cmp(const IVIHuffDesc *desc1, const IVIHuffDesc *desc2)
00190 {
00191     return    desc1->num_rows != desc2->num_rows
00192            || memcmp(desc1->xbits, desc2->xbits, desc1->num_rows);
00193 }
00194 
00195 void ff_ivi_huff_desc_copy(IVIHuffDesc *dst, const IVIHuffDesc *src)
00196 {
00197     dst->num_rows = src->num_rows;
00198     memcpy(dst->xbits, src->xbits, src->num_rows);
00199 }
00200 
00201 int av_cold ff_ivi_init_planes(IVIPlaneDesc *planes, const IVIPicConfig *cfg)
00202 {
00203     int p, b;
00204     uint32_t b_width, b_height, align_fac, width_aligned,
00205              height_aligned, buf_size;
00206     IVIBandDesc *band;
00207 
00208     ff_ivi_free_buffers(planes);
00209 
00210     if (av_image_check_size(cfg->pic_width, cfg->pic_height, 0, NULL) < 0 ||
00211         cfg->luma_bands < 1 || cfg->chroma_bands < 1)
00212         return AVERROR_INVALIDDATA;
00213 
00214     /* fill in the descriptor of the luminance plane */
00215     planes[0].width     = cfg->pic_width;
00216     planes[0].height    = cfg->pic_height;
00217     planes[0].num_bands = cfg->luma_bands;
00218 
00219     /* fill in the descriptors of the chrominance planes */
00220     planes[1].width     = planes[2].width     = (cfg->pic_width  + 3) >> 2;
00221     planes[1].height    = planes[2].height    = (cfg->pic_height + 3) >> 2;
00222     planes[1].num_bands = planes[2].num_bands = cfg->chroma_bands;
00223 
00224     for (p = 0; p < 3; p++) {
00225         planes[p].bands = av_mallocz(planes[p].num_bands * sizeof(IVIBandDesc));
00226         if (!planes[p].bands)
00227             return AVERROR(ENOMEM);
00228 
00229         /* select band dimensions: if there is only one band then it
00230          *  has the full size, if there are several bands each of them
00231          *  has only half size */
00232         b_width  = planes[p].num_bands == 1 ? planes[p].width
00233                                             : (planes[p].width  + 1) >> 1;
00234         b_height = planes[p].num_bands == 1 ? planes[p].height
00235                                             : (planes[p].height + 1) >> 1;
00236 
00237         /* luma   band buffers will be aligned on 16x16 (max macroblock size) */
00238         /* chroma band buffers will be aligned on   8x8 (max macroblock size) */
00239         align_fac       = p ? 8 : 16;
00240         width_aligned   = FFALIGN(b_width , align_fac);
00241         height_aligned  = FFALIGN(b_height, align_fac);
00242         buf_size        = width_aligned * height_aligned * sizeof(int16_t);
00243 
00244         for (b = 0; b < planes[p].num_bands; b++) {
00245             band = &planes[p].bands[b]; /* select appropriate plane/band */
00246             band->plane    = p;
00247             band->band_num = b;
00248             band->width    = b_width;
00249             band->height   = b_height;
00250             band->pitch    = width_aligned;
00251             band->aheight  = height_aligned;
00252             band->bufs[0]  = av_mallocz(buf_size);
00253             band->bufs[1]  = av_mallocz(buf_size);
00254             if (!band->bufs[0] || !band->bufs[1])
00255                 return AVERROR(ENOMEM);
00256 
00257             /* allocate the 3rd band buffer for scalability mode */
00258             if (cfg->luma_bands > 1) {
00259                 band->bufs[2] = av_mallocz(buf_size);
00260                 if (!band->bufs[2])
00261                     return AVERROR(ENOMEM);
00262             }
00263             /* reset custom vlc */
00264             planes[p].bands[0].blk_vlc.cust_desc.num_rows = 0;
00265         }
00266     }
00267 
00268     return 0;
00269 }
00270 
00271 void av_cold ff_ivi_free_buffers(IVIPlaneDesc *planes)
00272 {
00273     int p, b, t;
00274 
00275     for (p = 0; p < 3; p++) {
00276         for (b = 0; b < planes[p].num_bands; b++) {
00277             av_freep(&planes[p].bands[b].bufs[0]);
00278             av_freep(&planes[p].bands[b].bufs[1]);
00279             av_freep(&planes[p].bands[b].bufs[2]);
00280 
00281             if (planes[p].bands[b].blk_vlc.cust_tab.table)
00282                 ff_free_vlc(&planes[p].bands[b].blk_vlc.cust_tab);
00283             for (t = 0; t < planes[p].bands[b].num_tiles; t++)
00284                 av_freep(&planes[p].bands[b].tiles[t].mbs);
00285             av_freep(&planes[p].bands[b].tiles);
00286         }
00287         av_freep(&planes[p].bands);
00288         planes[p].num_bands = 0;
00289     }
00290 }
00291 
00292 static int ivi_init_tiles(IVIBandDesc *band, IVITile *ref_tile,
00293                           int p, int b, int t_height, int t_width)
00294 {
00295     int x, y;
00296     IVITile *tile = band->tiles;
00297 
00298     for (y = 0; y < band->height; y += t_height) {
00299         for (x = 0; x < band->width; x += t_width) {
00300             tile->xpos     = x;
00301             tile->ypos     = y;
00302             tile->mb_size  = band->mb_size;
00303             tile->width    = FFMIN(band->width - x,  t_width);
00304             tile->height   = FFMIN(band->height - y, t_height);
00305             tile->is_empty = tile->data_size = 0;
00306             /* calculate number of macroblocks */
00307             tile->num_MBs  = IVI_MBs_PER_TILE(tile->width, tile->height,
00308                                               band->mb_size);
00309 
00310             av_freep(&tile->mbs);
00311             tile->mbs = av_malloc(tile->num_MBs * sizeof(IVIMbInfo));
00312             if (!tile->mbs)
00313                 return AVERROR(ENOMEM);
00314 
00315             tile->ref_mbs = 0;
00316             if (p || b) {
00317                 if (tile->num_MBs != ref_tile->num_MBs)
00318                     return AVERROR_INVALIDDATA;
00319                 tile->ref_mbs = ref_tile->mbs;
00320                 ref_tile++;
00321             }
00322             tile++;
00323         }
00324     }
00325 
00326     return 0;
00327 }
00328 
00329 int av_cold ff_ivi_init_tiles(IVIPlaneDesc *planes, int tile_width, int tile_height)
00330 {
00331     int         p, b, x_tiles, y_tiles, t_width, t_height, ret;
00332     IVIBandDesc *band;
00333 
00334     for (p = 0; p < 3; p++) {
00335         t_width  = !p ? tile_width  : (tile_width  + 3) >> 2;
00336         t_height = !p ? tile_height : (tile_height + 3) >> 2;
00337 
00338         if (!p && planes[0].num_bands == 4) {
00339             t_width  >>= 1;
00340             t_height >>= 1;
00341         }
00342 
00343         for (b = 0; b < planes[p].num_bands; b++) {
00344             band = &planes[p].bands[b];
00345             x_tiles = IVI_NUM_TILES(band->width, t_width);
00346             y_tiles = IVI_NUM_TILES(band->height, t_height);
00347             band->num_tiles = x_tiles * y_tiles;
00348 
00349             av_freep(&band->tiles);
00350             band->tiles = av_mallocz(band->num_tiles * sizeof(IVITile));
00351             if (!band->tiles)
00352                 return AVERROR(ENOMEM);
00353 
00354             /* use the first luma band as reference for motion vectors
00355              * and quant */
00356             ret = ivi_init_tiles(band, planes[0].bands[0].tiles,
00357                                  p, b, t_height, t_width);
00358             if (ret < 0)
00359                 return ret;
00360         }
00361     }
00362 
00363     return 0;
00364 }
00365 
00366 int ff_ivi_dec_tile_data_size(GetBitContext *gb)
00367 {
00368     int    len;
00369 
00370     len = 0;
00371     if (get_bits1(gb)) {
00372         len = get_bits(gb, 8);
00373         if (len == 255)
00374             len = get_bits_long(gb, 24);
00375     }
00376 
00377     /* align the bitstream reader on the byte boundary */
00378     align_get_bits(gb);
00379 
00380     return len;
00381 }
00382 
00383 static int ivi_dc_transform(IVIBandDesc *band, int *prev_dc, int buf_offs,
00384                             int blk_size)
00385 {
00386     int buf_size = band->pitch * band->aheight - buf_offs;
00387     int min_size = (blk_size - 1) * band->pitch + blk_size;
00388 
00389     if (!band->dc_transform)
00390         return 0;
00391 
00392 
00393     if (min_size > buf_size)
00394         return AVERROR_INVALIDDATA;
00395 
00396     band->dc_transform(prev_dc, band->buf + buf_offs,
00397                        band->pitch, blk_size);
00398 
00399     return 0;
00400 }
00401 
00402 static int ivi_decode_coded_blocks(GetBitContext *gb, IVIBandDesc *band,
00403                                    ivi_mc_func mc, int mv_x, int mv_y,
00404                                    int *prev_dc, int is_intra, int mc_type,
00405                                    uint32_t quant, int offs)
00406 {
00407     const uint16_t *base_tab  = is_intra ? band->intra_base : band->inter_base;
00408     RVMapDesc *rvmap = band->rv_map;
00409     uint8_t col_flags[8];
00410     int32_t trvec[64];
00411     uint32_t sym = 0, lo, hi, q;
00412     int pos, run, val;
00413     int blk_size   = band->blk_size;
00414     int num_coeffs = blk_size * blk_size;
00415     int col_mask   = blk_size - 1;
00416     int scan_pos   = -1;
00417     int min_size   = band->pitch * (band->transform_size - 1) +
00418                      band->transform_size;
00419     int buf_size   = band->pitch * band->aheight - offs;
00420 
00421     if (min_size > buf_size)
00422         return AVERROR_INVALIDDATA;
00423 
00424     if (!band->scan)
00425         return AVERROR_INVALIDDATA;
00426 
00427     /* zero transform vector */
00428     memset(trvec, 0, num_coeffs * sizeof(trvec[0]));
00429     /* zero column flags */
00430     memset(col_flags, 0, sizeof(col_flags));
00431     while (scan_pos <= num_coeffs) {
00432         sym = get_vlc2(gb, band->blk_vlc.tab->table,
00433                        IVI_VLC_BITS, 1);
00434         if (sym == rvmap->eob_sym)
00435             break; /* End of block */
00436 
00437         /* Escape - run/val explicitly coded using 3 vlc codes */
00438         if (sym == rvmap->esc_sym) {
00439             run = get_vlc2(gb, band->blk_vlc.tab->table, IVI_VLC_BITS, 1) + 1;
00440             lo  = get_vlc2(gb, band->blk_vlc.tab->table, IVI_VLC_BITS, 1);
00441             hi  = get_vlc2(gb, band->blk_vlc.tab->table, IVI_VLC_BITS, 1);
00442             /* merge them and convert into signed val */
00443             val = IVI_TOSIGNED((hi << 6) | lo);
00444         } else {
00445             if (sym >= 256U)
00446                 return AVERROR_INVALIDDATA;
00447 
00448             run = rvmap->runtab[sym];
00449             val = rvmap->valtab[sym];
00450         }
00451 
00452         /* de-zigzag and dequantize */
00453         scan_pos += run;
00454         if (scan_pos >= num_coeffs || scan_pos < 0)
00455             break;
00456         pos = band->scan[scan_pos];
00457 
00458         q = (base_tab[pos] * quant) >> 9;
00459         if (q > 1)
00460             val = val * q + FFSIGN(val) * (((q ^ 1) - 1) >> 1);
00461         trvec[pos] = val;
00462         /* track columns containing non-zero coeffs */
00463         col_flags[pos & col_mask] |= !!val;
00464     }
00465 
00466     if (scan_pos < 0 || scan_pos >= num_coeffs && sym != rvmap->eob_sym)
00467         return AVERROR_INVALIDDATA; /* corrupt block data */
00468 
00469     /* undoing DC coeff prediction for intra-blocks */
00470     if (is_intra && band->is_2d_trans) {
00471         *prev_dc     += trvec[0];
00472         trvec[0]      = *prev_dc;
00473         col_flags[0] |= !!*prev_dc;
00474     }
00475 
00476     /* apply inverse transform */
00477     band->inv_transform(trvec, band->buf + offs,
00478                         band->pitch, col_flags);
00479 
00480     /* apply motion compensation */
00481     if (!is_intra)
00482         return ivi_mc(band, mc, offs, mv_x, mv_y, mc_type);
00483 
00484     return 0;
00485 }
00486 
00487 int ff_ivi_decode_blocks(GetBitContext *gb, IVIBandDesc *band, IVITile *tile)
00488 {
00489     int mbn, blk, num_blocks, blk_size, ret, is_intra, mc_type = 0;
00490     int mv_x = 0, mv_y = 0;
00491     int32_t prev_dc;
00492     uint32_t cbp, quant, buf_offs;
00493     IVIMbInfo *mb;
00494     ivi_mc_func mc_with_delta_func, mc_no_delta_func;
00495     const uint8_t *scale_tab;
00496 
00497     /* init intra prediction for the DC coefficient */
00498     prev_dc = 0;
00499     blk_size   = band->blk_size;
00500     /* number of blocks per mb */
00501     num_blocks = (band->mb_size != blk_size) ? 4 : 1;
00502     if (blk_size == 8) {
00503         mc_with_delta_func = ff_ivi_mc_8x8_delta;
00504         mc_no_delta_func   = ff_ivi_mc_8x8_no_delta;
00505     } else {
00506         mc_with_delta_func = ff_ivi_mc_4x4_delta;
00507         mc_no_delta_func   = ff_ivi_mc_4x4_no_delta;
00508     }
00509 
00510     for (mbn = 0, mb = tile->mbs; mbn < tile->num_MBs; mb++, mbn++) {
00511         is_intra = !mb->type;
00512         cbp      = mb->cbp;
00513         buf_offs = mb->buf_offs;
00514 
00515         quant = av_clip(band->glob_quant + mb->q_delta, 0, 23);
00516 
00517         scale_tab = is_intra ? band->intra_scale : band->inter_scale;
00518         if (scale_tab)
00519             quant = scale_tab[quant];
00520 
00521         if (!is_intra) {
00522             mv_x = mb->mv_x;
00523             mv_y = mb->mv_y;
00524             if (!band->is_halfpel) {
00525                 mc_type = 0; /* we have only fullpel vectors */
00526             } else {
00527                 mc_type = ((mv_y & 1) << 1) | (mv_x & 1);
00528                 mv_x >>= 1;
00529                 mv_y >>= 1; /* convert halfpel vectors into fullpel ones */
00530             }
00531             if (mb->type) {
00532                 int dmv_x, dmv_y, cx, cy;
00533 
00534                 dmv_x = mb->mv_x >> band->is_halfpel;
00535                 dmv_y = mb->mv_y >> band->is_halfpel;
00536                 cx    = mb->mv_x &  band->is_halfpel;
00537                 cy    = mb->mv_y &  band->is_halfpel;
00538 
00539                 if (mb->xpos + dmv_x < 0 ||
00540                     mb->xpos + dmv_x + band->mb_size + cx > band->pitch ||
00541                     mb->ypos + dmv_y < 0 ||
00542                     mb->ypos + dmv_y + band->mb_size + cy > band->aheight) {
00543                     return AVERROR_INVALIDDATA;
00544                 }
00545             }
00546         }
00547 
00548         for (blk = 0; blk < num_blocks; blk++) {
00549             /* adjust block position in the buffer according to its number */
00550             if (blk & 1) {
00551                 buf_offs += blk_size;
00552             } else if (blk == 2) {
00553                 buf_offs -= blk_size;
00554                 buf_offs += blk_size * band->pitch;
00555             }
00556 
00557             if (cbp & 1) { /* block coded ? */
00558                 ret = ivi_decode_coded_blocks(gb, band, mc_with_delta_func,
00559                                               mv_x, mv_y, &prev_dc, is_intra,
00560                                               mc_type, quant, buf_offs);
00561                 if (ret < 0)
00562                     return ret;
00563             } else {
00564                 /* block not coded */
00565                 /* for intra blocks apply the dc slant transform */
00566                 /* for inter - perform the motion compensation without delta */
00567                 if (is_intra) {
00568                     ret = ivi_dc_transform(band, &prev_dc, buf_offs, blk_size);
00569                     if (ret < 0)
00570                         return ret;
00571                 } else {
00572                     ret = ivi_mc(band, mc_no_delta_func, buf_offs,
00573                                  mv_x, mv_y, mc_type);
00574                     if (ret < 0)
00575                         return ret;
00576                 }
00577             }
00578 
00579             cbp >>= 1;
00580         }// for blk
00581     }// for mbn
00582 
00583     align_get_bits(gb);
00584 
00585     return 0;
00586 }
00587 
00597 static int ivi_process_empty_tile(AVCodecContext *avctx, IVIBandDesc *band,
00598                                   IVITile *tile, int32_t mv_scale)
00599 {
00600     int             x, y, need_mc, mbn, blk, num_blocks, mv_x, mv_y, mc_type;
00601     int             offs, mb_offset, row_offset, ret;
00602     IVIMbInfo       *mb, *ref_mb;
00603     const int16_t   *src;
00604     int16_t         *dst;
00605     ivi_mc_func     mc_no_delta_func;
00606 
00607     if (tile->num_MBs != IVI_MBs_PER_TILE(tile->width, tile->height, band->mb_size)) {
00608         av_log(avctx, AV_LOG_ERROR, "Allocated tile size %d mismatches "
00609                "parameters %d in ivi_process_empty_tile()\n",
00610                tile->num_MBs, IVI_MBs_PER_TILE(tile->width, tile->height, band->mb_size));
00611         return AVERROR_INVALIDDATA;
00612     }
00613 
00614     offs       = tile->ypos * band->pitch + tile->xpos;
00615     mb         = tile->mbs;
00616     ref_mb     = tile->ref_mbs;
00617     row_offset = band->mb_size * band->pitch;
00618     need_mc    = 0; /* reset the mc tracking flag */
00619 
00620     for (y = tile->ypos; y < (tile->ypos + tile->height); y += band->mb_size) {
00621         mb_offset = offs;
00622 
00623         for (x = tile->xpos; x < (tile->xpos + tile->width); x += band->mb_size) {
00624             mb->xpos     = x;
00625             mb->ypos     = y;
00626             mb->buf_offs = mb_offset;
00627 
00628             mb->type = 1; /* set the macroblocks type = INTER */
00629             mb->cbp  = 0; /* all blocks are empty */
00630 
00631             if (!band->qdelta_present && !band->plane && !band->band_num) {
00632                 mb->q_delta = band->glob_quant;
00633                 mb->mv_x    = 0;
00634                 mb->mv_y    = 0;
00635             }
00636 
00637             if (band->inherit_qdelta && ref_mb)
00638                 mb->q_delta = ref_mb->q_delta;
00639 
00640             if (band->inherit_mv && ref_mb) {
00641                 /* motion vector inheritance */
00642                 if (mv_scale) {
00643                     mb->mv_x = ivi_scale_mv(ref_mb->mv_x, mv_scale);
00644                     mb->mv_y = ivi_scale_mv(ref_mb->mv_y, mv_scale);
00645                 } else {
00646                     mb->mv_x = ref_mb->mv_x;
00647                     mb->mv_y = ref_mb->mv_y;
00648                 }
00649                 need_mc |= mb->mv_x || mb->mv_y; /* tracking non-zero motion vectors */
00650             }
00651 
00652             mb++;
00653             if (ref_mb)
00654                 ref_mb++;
00655             mb_offset += band->mb_size;
00656         } // for x
00657         offs += row_offset;
00658     } // for y
00659 
00660     if (band->inherit_mv && need_mc) { /* apply motion compensation if there is at least one non-zero motion vector */
00661         num_blocks = (band->mb_size != band->blk_size) ? 4 : 1; /* number of blocks per mb */
00662         mc_no_delta_func = (band->blk_size == 8) ? ff_ivi_mc_8x8_no_delta
00663                                                  : ff_ivi_mc_4x4_no_delta;
00664 
00665         for (mbn = 0, mb = tile->mbs; mbn < tile->num_MBs; mb++, mbn++) {
00666             mv_x = mb->mv_x;
00667             mv_y = mb->mv_y;
00668             if (!band->is_halfpel) {
00669                 mc_type = 0; /* we have only fullpel vectors */
00670             } else {
00671                 mc_type = ((mv_y & 1) << 1) | (mv_x & 1);
00672                 mv_x >>= 1;
00673                 mv_y >>= 1; /* convert halfpel vectors into fullpel ones */
00674             }
00675 
00676             for (blk = 0; blk < num_blocks; blk++) {
00677                 /* adjust block position in the buffer according with its number */
00678                 offs = mb->buf_offs + band->blk_size * ((blk & 1) + !!(blk & 2) * band->pitch);
00679                 ret = ivi_mc(band, mc_no_delta_func, offs,
00680                              mv_x, mv_y, mc_type);
00681                 if (ret < 0)
00682                     return ret;
00683             }
00684         }
00685     } else {
00686         /* copy data from the reference tile into the current one */
00687         src = band->ref_buf + tile->ypos * band->pitch + tile->xpos;
00688         dst = band->buf     + tile->ypos * band->pitch + tile->xpos;
00689         for (y = 0; y < tile->height; y++) {
00690             memcpy(dst, src, tile->width*sizeof(band->buf[0]));
00691             src += band->pitch;
00692             dst += band->pitch;
00693         }
00694     }
00695 
00696     return 0;
00697 }
00698 
00699 
00700 #ifdef DEBUG
00701 uint16_t ivi_calc_band_checksum (IVIBandDesc *band)
00702 {
00703     int         x, y;
00704     int16_t     *src, checksum;
00705 
00706     src = band->buf;
00707     checksum = 0;
00708 
00709     for (y = 0; y < band->height; src += band->pitch, y++)
00710         for (x = 0; x < band->width; x++)
00711             checksum += src[x];
00712 
00713     return checksum;
00714 }
00715 
00716 int ivi_check_band (IVIBandDesc *band, const uint8_t *ref, int pitch)
00717 {
00718     int         x, y, result;
00719     uint8_t     t1, t2;
00720     int16_t    *src;
00721 
00722     src = band->buf;
00723     result = 0;
00724 
00725     for (y = 0; y < band->height; src += band->pitch, y++) {
00726         for (x = 0; x < band->width; x++) {
00727             t1 = av_clip(src[x] + 128, 0, 255);
00728             t2 = ref[x];
00729             if (t1 != t2) {
00730                 av_log(NULL, AV_LOG_ERROR, "Data mismatch: row %d, column %d\n",
00731                        y / band->blk_size, x / band->blk_size);
00732                 result = -1;
00733             }
00734         }
00735         ref += pitch;
00736     }
00737 
00738     return result;
00739 }
00740 #endif
00741 
00742 void ff_ivi_output_plane(IVIPlaneDesc *plane, uint8_t *dst, int dst_pitch)
00743 {
00744     int             x, y;
00745     const int16_t   *src  = plane->bands[0].buf;
00746     uint32_t        pitch = plane->bands[0].pitch;
00747 
00748     if (!src)
00749         return;
00750 
00751     for (y = 0; y < plane->height; y++) {
00752         for (x = 0; x < plane->width; x++)
00753             dst[x] = av_clip_uint8(src[x] + 128);
00754         src += pitch;
00755         dst += dst_pitch;
00756     }
00757 }
00758 
00767 static int decode_band(IVI45DecContext *ctx, int plane_num,
00768                        IVIBandDesc *band, AVCodecContext *avctx)
00769 {
00770     int         result, i, t, idx1, idx2, pos;
00771     IVITile     *tile;
00772 
00773     band->buf     = band->bufs[ctx->dst_buf];
00774     band->ref_buf = band->bufs[ctx->ref_buf];
00775     band->data_ptr = ctx->frame_data + (get_bits_count(&ctx->gb) >> 3);
00776 
00777     result = ctx->decode_band_hdr(ctx, band, avctx);
00778     if (result) {
00779         av_log(avctx, AV_LOG_ERROR, "Error while decoding band header: %d\n",
00780                result);
00781         return result;
00782     }
00783 
00784     if (band->is_empty) {
00785         av_log(avctx, AV_LOG_ERROR, "Empty band encountered!\n");
00786         return AVERROR_INVALIDDATA;
00787     }
00788 
00789     band->rv_map = &ctx->rvmap_tabs[band->rvmap_sel];
00790 
00791     /* apply corrections to the selected rvmap table if present */
00792     for (i = 0; i < band->num_corr; i++) {
00793         idx1 = band->corr[i * 2];
00794         idx2 = band->corr[i * 2 + 1];
00795         FFSWAP(uint8_t, band->rv_map->runtab[idx1], band->rv_map->runtab[idx2]);
00796         FFSWAP(int16_t, band->rv_map->valtab[idx1], band->rv_map->valtab[idx2]);
00797     }
00798 
00799     pos = get_bits_count(&ctx->gb);
00800 
00801     for (t = 0; t < band->num_tiles; t++) {
00802         tile = &band->tiles[t];
00803 
00804         if (tile->mb_size != band->mb_size) {
00805             av_log(avctx, AV_LOG_ERROR, "MB sizes mismatch: %d vs. %d\n",
00806                    band->mb_size, tile->mb_size);
00807             return AVERROR_INVALIDDATA;
00808         }
00809         tile->is_empty = get_bits1(&ctx->gb);
00810         if (tile->is_empty) {
00811             result = ivi_process_empty_tile(avctx, band, tile,
00812                                       (ctx->planes[0].bands[0].mb_size >> 3) - (band->mb_size >> 3));
00813             if (result < 0)
00814                 break;
00815             av_dlog(avctx, "Empty tile encountered!\n");
00816         } else {
00817             tile->data_size = ff_ivi_dec_tile_data_size(&ctx->gb);
00818             if (!tile->data_size) {
00819                 av_log(avctx, AV_LOG_ERROR, "Tile data size is zero!\n");
00820                 return AVERROR_INVALIDDATA;
00821             }
00822 
00823             result = ctx->decode_mb_info(ctx, band, tile, avctx);
00824             if (result < 0)
00825                 break;
00826 
00827             result = ff_ivi_decode_blocks(&ctx->gb, band, tile);
00828             if (result < 0) {
00829                 av_log(avctx, AV_LOG_ERROR,
00830                        "Corrupted tile data encountered!\n");
00831                 break;
00832             }
00833 
00834             if (((get_bits_count(&ctx->gb) - pos) >> 3) != tile->data_size) {
00835                 av_log(avctx, AV_LOG_ERROR,
00836                        "Tile data_size mismatch!\n");
00837                 result = AVERROR_INVALIDDATA;
00838                 break;
00839             }
00840 
00841             pos += tile->data_size << 3; // skip to next tile
00842         }
00843     }
00844 
00845     /* restore the selected rvmap table by applying its corrections in
00846      * reverse order */
00847     for (i = band->num_corr-1; i >= 0; i--) {
00848         idx1 = band->corr[i*2];
00849         idx2 = band->corr[i*2+1];
00850         FFSWAP(uint8_t, band->rv_map->runtab[idx1], band->rv_map->runtab[idx2]);
00851         FFSWAP(int16_t, band->rv_map->valtab[idx1], band->rv_map->valtab[idx2]);
00852     }
00853 
00854 #ifdef DEBUG
00855     if (band->checksum_present) {
00856         uint16_t chksum = ivi_calc_band_checksum(band);
00857         if (chksum != band->checksum) {
00858             av_log(avctx, AV_LOG_ERROR,
00859                    "Band checksum mismatch! Plane %d, band %d, "
00860                    "received: %x, calculated: %x\n",
00861                    band->plane, band->band_num, band->checksum, chksum);
00862         }
00863     }
00864 #endif
00865 
00866     align_get_bits(&ctx->gb);
00867 
00868     return result;
00869 }
00870 
00871 int ff_ivi_decode_frame(AVCodecContext *avctx, void *data, int *data_size,
00872                         AVPacket *avpkt)
00873 {
00874     IVI45DecContext *ctx = avctx->priv_data;
00875     const uint8_t   *buf = avpkt->data;
00876     int             buf_size = avpkt->size;
00877     int             result, p, b;
00878 
00879     init_get_bits(&ctx->gb, buf, buf_size * 8);
00880     ctx->frame_data = buf;
00881     ctx->frame_size = buf_size;
00882 
00883     result = ctx->decode_pic_hdr(ctx, avctx);
00884     if (result) {
00885         av_log(avctx, AV_LOG_ERROR,
00886                "Error while decoding picture header: %d\n", result);
00887         return result;
00888     }
00889     if (ctx->gop_invalid)
00890         return AVERROR_INVALIDDATA;
00891 
00892     if (ctx->gop_flags & IVI5_IS_PROTECTED) {
00893         av_log(avctx, AV_LOG_ERROR, "Password-protected clip!\n");
00894         return AVERROR_PATCHWELCOME;
00895     }
00896 
00897     if (!ctx->planes[0].bands) {
00898         av_log(avctx, AV_LOG_ERROR, "Color planes not initialized yet\n");
00899         return AVERROR_INVALIDDATA;
00900     }
00901 
00902     ctx->switch_buffers(ctx);
00903 
00904     //{ START_TIMER;
00905 
00906     if (ctx->is_nonnull_frame(ctx)) {
00907         for (p = 0; p < 3; p++) {
00908             for (b = 0; b < ctx->planes[p].num_bands; b++) {
00909                 result = decode_band(ctx, p, &ctx->planes[p].bands[b], avctx);
00910                 if (result < 0) {
00911                     av_log(avctx, AV_LOG_ERROR,
00912                            "Error while decoding band: %d, plane: %d\n", b, p);
00913                     return result;
00914                 }
00915             }
00916         }
00917     } else {
00918         if (ctx->is_scalable)
00919             return AVERROR_INVALIDDATA;
00920 
00921         for (p = 0; p < 3; p++) {
00922             if (!ctx->planes[p].bands[0].buf)
00923                 return AVERROR_INVALIDDATA;
00924         }
00925     }
00926 
00927     //STOP_TIMER("decode_planes"); }
00928 
00929     /* If the bidirectional mode is enabled, next I and the following P frame will */
00930     /* be sent together. Unfortunately the approach below seems to be the only way */
00931     /* to handle the B-frames mode. That's exactly the same Intel decoders do.     */
00932     if (avctx->codec_id == CODEC_ID_INDEO4 &&
00933         ctx->frame_type == 0/*FRAMETYPE_INTRA*/) {
00934         while (get_bits(&ctx->gb, 8)); // skip version string
00935         skip_bits_long(&ctx->gb, 64);  // skip padding, TODO: implement correct 8-bytes alignment
00936         if (get_bits_left(&ctx->gb) > 18 && show_bits(&ctx->gb, 18) == 0x3FFF8)
00937             av_log(avctx, AV_LOG_ERROR, "Buffer contains IP frames!\n");
00938     }
00939 
00940     if (ctx->frame.data[0])
00941         avctx->release_buffer(avctx, &ctx->frame);
00942 
00943     ctx->frame.reference = 0;
00944     avcodec_set_dimensions(avctx, ctx->planes[0].width, ctx->planes[0].height);
00945     if ((result = ff_get_buffer(avctx, &ctx->frame)) < 0) {
00946         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
00947         return result;
00948     }
00949 
00950     if (ctx->is_scalable) {
00951         if (avctx->codec_id == CODEC_ID_INDEO4)
00952             ff_ivi_recompose_haar(&ctx->planes[0], ctx->frame.data[0], ctx->frame.linesize[0], 4);
00953         else
00954             ff_ivi_recompose53   (&ctx->planes[0], ctx->frame.data[0], ctx->frame.linesize[0], 4);
00955     } else {
00956         ff_ivi_output_plane(&ctx->planes[0], ctx->frame.data[0], ctx->frame.linesize[0]);
00957     }
00958 
00959     ff_ivi_output_plane(&ctx->planes[2], ctx->frame.data[1], ctx->frame.linesize[1]);
00960     ff_ivi_output_plane(&ctx->planes[1], ctx->frame.data[2], ctx->frame.linesize[2]);
00961 
00962     *data_size = sizeof(AVFrame);
00963     *(AVFrame*)data = ctx->frame;
00964 
00965     return buf_size;
00966 }
00967 
00971 av_cold int ff_ivi_decode_close(AVCodecContext *avctx)
00972 {
00973     IVI45DecContext *ctx = avctx->priv_data;
00974 
00975     ff_ivi_free_buffers(&ctx->planes[0]);
00976 
00977     if (ctx->mb_vlc.cust_tab.table)
00978         ff_free_vlc(&ctx->mb_vlc.cust_tab);
00979 
00980     if (ctx->frame.data[0])
00981         avctx->release_buffer(avctx, &ctx->frame);
00982 
00983 #if IVI4_STREAM_ANALYSER
00984     if (avctx->codec_id == CODEC_ID_INDEO4) {
00985     if (ctx->is_scalable)
00986         av_log(avctx, AV_LOG_ERROR, "This video uses scalability mode!\n");
00987     if (ctx->uses_tiling)
00988         av_log(avctx, AV_LOG_ERROR, "This video uses local decoding!\n");
00989     if (ctx->has_b_frames)
00990         av_log(avctx, AV_LOG_ERROR, "This video contains B-frames!\n");
00991     if (ctx->has_transp)
00992         av_log(avctx, AV_LOG_ERROR, "Transparency mode is enabled!\n");
00993     if (ctx->uses_haar)
00994         av_log(avctx, AV_LOG_ERROR, "This video uses Haar transform!\n");
00995     if (ctx->uses_fullpel)
00996         av_log(avctx, AV_LOG_ERROR, "This video uses fullpel motion vectors!\n");
00997     }
00998 #endif
00999 
01000     return 0;
01001 }
01002 
01003 
01010 const IVIHuffDesc ff_ivi_mb_huff_desc[8] = {
01011     {8,  {0, 4, 5, 4, 4, 4, 6, 6}},
01012     {12, {0, 2, 2, 3, 3, 3, 3, 5, 3, 2, 2, 2}},
01013     {12, {0, 2, 3, 4, 3, 3, 3, 3, 4, 3, 2, 2}},
01014     {12, {0, 3, 4, 4, 3, 3, 3, 3, 3, 2, 2, 2}},
01015     {13, {0, 4, 4, 3, 3, 3, 3, 2, 3, 3, 2, 1, 1}},
01016     {9,  {0, 4, 4, 4, 4, 3, 3, 3, 2}},
01017     {10, {0, 4, 4, 4, 4, 3, 3, 2, 2, 2}},
01018     {12, {0, 4, 4, 4, 3, 3, 2, 3, 2, 2, 2, 2}}
01019 };
01020 
01021 const IVIHuffDesc ff_ivi_blk_huff_desc[8] = {
01022     {10, {1, 2, 3, 4, 4, 7, 5, 5, 4, 1}},
01023     {11, {2, 3, 4, 4, 4, 7, 5, 4, 3, 3, 2}},
01024     {12, {2, 4, 5, 5, 5, 5, 6, 4, 4, 3, 1, 1}},
01025     {13, {3, 3, 4, 4, 5, 6, 6, 4, 4, 3, 2, 1, 1}},
01026     {11, {3, 4, 4, 5, 5, 5, 6, 5, 4, 2, 2}},
01027     {13, {3, 4, 5, 5, 5, 5, 6, 4, 3, 3, 2, 1, 1}},
01028     {13, {3, 4, 5, 5, 5, 6, 5, 4, 3, 3, 2, 1, 1}},
01029     {9,  {3, 4, 4, 5, 5, 5, 6, 5, 5}}
01030 };
01031 
01032 
01036 const uint8_t ff_ivi_vertical_scan_8x8[64] = {
01037     0,  8, 16, 24, 32, 40, 48, 56,
01038     1,  9, 17, 25, 33, 41, 49, 57,
01039     2, 10, 18, 26, 34, 42, 50, 58,
01040     3, 11, 19, 27, 35, 43, 51, 59,
01041     4, 12, 20, 28, 36, 44, 52, 60,
01042     5, 13, 21, 29, 37, 45, 53, 61,
01043     6, 14, 22, 30, 38, 46, 54, 62,
01044     7, 15, 23, 31, 39, 47, 55, 63
01045 };
01046 
01047 const uint8_t ff_ivi_horizontal_scan_8x8[64] = {
01048      0,  1,  2,  3,  4,  5,  6,  7,
01049      8,  9, 10, 11, 12, 13, 14, 15,
01050     16, 17, 18, 19, 20, 21, 22, 23,
01051     24, 25, 26, 27, 28, 29, 30, 31,
01052     32, 33, 34, 35, 36, 37, 38, 39,
01053     40, 41, 42, 43, 44, 45, 46, 47,
01054     48, 49, 50, 51, 52, 53, 54, 55,
01055     56, 57, 58, 59, 60, 61, 62, 63
01056 };
01057 
01058 const uint8_t ff_ivi_direct_scan_4x4[16] = {
01059     0, 1, 4, 8, 5, 2, 3, 6, 9, 12, 13, 10, 7, 11, 14, 15
01060 };
01061 
01062 
01066 const RVMapDesc ff_ivi_rvmap_tabs[9] = {
01067 {   /* MapTab0 */
01068     5, /* eob_sym */
01069     2, /* esc_sym */
01070     /* run table */
01071     {1,  1,  0,  1,  1,  0,  1,  1,  2,  2,  1,  1,  1,  1,  3,  3,
01072      1,  1,  2,  2,  1,  1,  4,  4,  1,  1,  1,  1,  2,  2,  5,  5,
01073      1,  1,  3,  3,  1,  1,  6,  6,  1,  2,  1,  2,  7,  7,  1,  1,
01074      8,  8,  1,  1,  4,  2,  1,  4,  2,  1,  3,  3,  1,  1,  1,  9,
01075      9,  1,  2,  1,  2,  1,  5,  5,  1,  1, 10, 10,  1,  1,  3,  3,
01076      2,  2,  1,  1, 11, 11,  6,  4,  4,  1,  6,  1,  2,  1,  2, 12,
01077      8,  1, 12,  7,  8,  7,  1, 16,  1, 16,  1,  3,  3, 13,  1, 13,
01078      2,  2,  1, 15,  1,  5, 14, 15,  1,  5, 14,  1, 17,  8, 17,  8,
01079      1,  4,  4,  2,  2,  1, 25, 25, 24, 24,  1,  3,  1,  3,  1,  8,
01080      6,  7,  6,  1, 18,  8, 18,  1,  7, 23,  2,  2, 23,  1,  1, 21,
01081     22,  9,  9, 22, 19,  1, 21,  5, 19,  5,  1, 33, 20, 33, 20,  8,
01082      4,  4,  1, 32,  2,  2,  8,  3, 32, 26,  3,  1,  7,  7, 26,  6,
01083      1,  6,  1,  1, 16,  1, 10,  1, 10,  2, 16, 29, 28,  2, 29, 28,
01084      1, 27,  5,  8,  5, 27,  1,  8,  3,  7,  3, 31, 41, 31,  1, 41,
01085      6,  1,  6,  7,  4,  4,  1,  1,  2,  1,  2, 11, 34, 30, 11,  1,
01086     30, 15, 15, 34, 36, 40, 36, 40, 35, 35, 37, 37, 39, 39, 38, 38},
01087 
01088     /* value table */
01089     { 1,  -1,   0,   2,  -2,   0,   3,  -3,   1,  -1,   4,  -4,   5,  -5,   1,  -1,
01090       6,  -6,   2,  -2,   7,  -7,   1,  -1,   8,  -8,   9,  -9,   3,  -3,   1,  -1,
01091      10, -10,   2,  -2,  11, -11,   1,  -1,  12,   4, -12,  -4,   1,  -1,  13, -13,
01092       1,  -1,  14, -14,   2,   5,  15,  -2,  -5, -15,  -3,   3,  16, -16,  17,   1,
01093      -1, -17,   6,  18,  -6, -18,   2,  -2,  19, -19,   1,  -1,  20, -20,   4,  -4,
01094       7,  -7,  21, -21,   1,  -1,   2,   3,  -3,  22,  -2, -22,   8,  23,  -8,   1,
01095       2, -23,  -1,   2,  -2,  -2,  24,   1, -24,  -1,  25,   5,  -5,   1, -25,  -1,
01096       9,  -9,  26,   1, -26,   3,   1,  -1,  27,  -3,  -1, -27,   1,   3,  -1,  -3,
01097      28,  -4,   4,  10, -10, -28,   1,  -1,   1,  -1,  29,   6, -29,  -6,  30,  -4,
01098       3,   3,  -3, -30,   1,   4,  -1,  31,  -3,   1,  11, -11,  -1, -31,  32,  -1,
01099      -1,   2,  -2,   1,   1, -32,   1,   4,  -1,  -4,  33,  -1,   1,   1,  -1,   5,
01100       5,  -5, -33,  -1, -12,  12,  -5,  -7,   1,   1,   7,  34,   4,  -4,  -1,   4,
01101     -34,  -4,  35,  36,  -2, -35,  -2, -36,   2,  13,   2,  -1,   1, -13,   1,  -1,
01102      37,   1,  -5,   6,   5,  -1,  38,  -6,  -8,   5,   8,  -1,   1,   1, -37,  -1,
01103       5,  39,  -5,  -5,   6,  -6, -38, -39, -14,  40,  14,   2,   1,   1,  -2, -40,
01104      -1,  -2,   2,  -1,  -1,  -1,   1,   1,   1,  -1,   1,  -1,   1,  -1,   1,  -1}
01105 },{
01106     /* MapTab1 */
01107     0,  /* eob_sym */
01108     38, /* esc_sym */
01109     /* run table */
01110     {0,  1,  1,  2,  2,  3,  3,  4,  4,  5,  5,  6,  8,  6,  8,  7,
01111      7,  9,  9, 10, 10, 11, 11,  1, 12,  1, 12, 13, 13, 16, 14, 16,
01112     14, 15, 15, 17, 17, 18,  0, 18, 19, 20, 21, 19, 22, 21, 20, 22,
01113     25, 24,  2, 25, 24, 23, 23,  2, 26, 28, 26, 28, 29, 27, 29, 27,
01114     33, 33,  1, 32,  1,  3, 32, 30, 36,  3, 36, 30, 31, 31, 35, 34,
01115     37, 41, 34, 35, 37,  4, 41,  4, 49,  8,  8, 49, 40, 38,  5, 38,
01116     40, 39,  5, 39, 42, 43, 42,  7, 57,  6, 43, 44,  6, 50,  7, 44,
01117     57, 48, 50, 48, 45, 45, 46, 47, 51, 46, 47, 58,  1, 51, 58,  1,
01118     52, 59, 53,  9, 52, 55, 55, 59, 53, 56, 54, 56, 54,  9, 64, 64,
01119     60, 63, 60, 63, 61, 62, 61, 62,  2, 10,  2, 10, 11,  1, 11, 13,
01120     12,  1, 12, 13, 16, 16,  8,  8, 14,  3,  3, 15, 14, 15,  4,  4,
01121      1, 17, 17,  5,  1,  7,  7,  5,  6,  1,  2,  2,  6, 22,  1, 25,
01122     21, 22,  8, 24,  1, 21, 25, 24,  8, 18, 18, 23,  9, 20, 23, 33,
01123     29, 33, 20,  1, 19,  1, 29, 36,  9, 36, 19, 41, 28, 57, 32,  3,
01124     28,  3,  1, 27, 49, 49,  1, 32, 26, 26,  2,  4,  4,  7, 57, 41,
01125      2,  7, 10,  5, 37, 16, 10, 27,  8,  8, 13, 16, 37, 13,  1,  5},
01126 
01127     /* value table */
01128     {0,   1,  -1,   1,  -1,   1,  -1,   1,  -1,   1,  -1,   1,   1,  -1,  -1,   1,
01129     -1,   1,  -1,   1,  -1,   1,  -1,   2,   1,  -2,  -1,   1,  -1,   1,   1,  -1,
01130     -1,   1,  -1,   1,  -1,   1,   0,  -1,   1,   1,   1,  -1,   1,  -1,  -1,  -1,
01131      1,   1,   2,  -1,  -1,   1,  -1,  -2,   1,   1,  -1,  -1,   1,   1,  -1,  -1,
01132      1,  -1,   3,   1,  -3,   2,  -1,   1,   1,  -2,  -1,  -1,  -1,   1,   1,   1,
01133      1,   1,  -1,  -1,  -1,   2,  -1,  -2,   1,   2,  -2,  -1,   1,   1,   2,  -1,
01134     -1,   1,  -2,  -1,   1,   1,  -1,   2,   1,   2,  -1,   1,  -2,  -1,  -2,  -1,
01135     -1,   1,   1,  -1,   1,  -1,   1,   1,   1,  -1,  -1,   1,   4,  -1,  -1,  -4,
01136      1,   1,   1,   2,  -1,  -1,   1,  -1,  -1,   1,  -1,  -1,   1,  -2,   1,  -1,
01137      1,   1,  -1,  -1,   1,   1,  -1,  -1,   3,   2,  -3,  -2,   2,   5,  -2,   2,
01138      2,  -5,  -2,  -2,  -2,   2,  -3,   3,   2,   3,  -3,   2,  -2,  -2,   3,  -3,
01139      6,   2,  -2,   3,  -6,   3,  -3,  -3,   3,   7,  -4,   4,  -3,   2,  -7,   2,
01140      2,  -2,  -4,   2,   8,  -2,  -2,  -2,   4,   2,  -2,   2,   3,   2,  -2,  -2,
01141      2,   2,  -2,  -8,  -2,   9,  -2,   2,  -3,  -2,   2,  -2,   2,   2,   2,   4,
01142     -2,  -4,  10,   2,   2,  -2,  -9,  -2,   2,  -2,   5,   4,  -4,   4,  -2,   2,
01143     -5,  -4,  -3,   4,   2,  -3,   3,  -2,  -5,   5,   3,   3,  -2,  -3, -10,  -4}
01144 },{
01145     /* MapTab2 */
01146     2,  /* eob_sym */
01147     11, /* esc_sym */
01148     /* run table */
01149     {1,  1,  0,  2,  2,  1,  1,  3,  3,  4,  4,  0,  1,  1,  5,  5,
01150      2,  2,  6,  6,  7,  7,  1,  8,  1,  8,  3,  3,  9,  9,  1,  2,
01151      2,  1,  4, 10,  4, 10, 11, 11,  1,  5, 12, 12,  1,  5, 13, 13,
01152      3,  3,  6,  6,  2,  2, 14, 14, 16, 16, 15,  7, 15,  8,  8,  7,
01153      1,  1, 17, 17,  4,  4,  1,  1, 18, 18,  2,  2,  5,  5, 25,  3,
01154      9,  3, 25,  9, 19, 24, 19, 24,  1, 21, 20,  1, 21, 22, 20, 22,
01155     23, 23,  8,  6, 33,  6,  8, 33,  7,  7, 26, 26,  1, 32,  1, 32,
01156     28,  4, 28, 10, 29, 27, 27, 10, 41,  4, 29,  2,  2, 41, 36, 31,
01157     49, 31, 34, 30, 34, 36, 30, 35,  1, 49, 11,  5, 35, 11,  1,  3,
01158      3,  5, 37, 37,  8, 40,  8, 40, 12, 12, 42, 42,  1, 38, 16, 57,
01159      1,  6, 16, 39, 38,  6,  7,  7, 13, 13, 39, 43,  2, 43, 57,  2,
01160     50,  9, 44,  9, 50,  4, 15, 48, 44,  4,  1, 15, 48, 14, 14,  1,
01161     45, 45,  8,  3,  5,  8, 51, 47,  3, 46, 46, 47,  5, 51,  1, 17,
01162     17, 58,  1, 58,  2, 52, 52,  2, 53,  7, 59,  6,  6, 56, 53, 55,
01163      7, 55,  1, 54, 59, 56, 54, 10,  1, 10,  4, 60,  1, 60,  8,  4,
01164      8, 64, 64, 61,  1, 63,  3, 63, 62, 61,  5, 11,  5,  3, 11, 62},
01165 
01166     /* value table */
01167     { 1,  -1,   0,   1,  -1,   2,  -2,   1,  -1,   1,  -1,   0,   3,  -3,   1,  -1,
01168       2,  -2,   1,  -1,   1,  -1,   4,   1,  -4,  -1,   2,  -2,   1,  -1,   5,   3,
01169      -3,  -5,   2,   1,  -2,  -1,   1,  -1,   6,   2,   1,  -1,  -6,  -2,   1,  -1,
01170       3,  -3,   2,  -2,   4,  -4,   1,  -1,   1,  -1,   1,   2,  -1,   2,  -2,  -2,
01171       7,  -7,   1,  -1,   3,  -3,   8,  -8,   1,  -1,   5,  -5,   3,  -3,   1,   4,
01172       2,  -4,  -1,  -2,   1,   1,  -1,  -1,   9,   1,   1,  -9,  -1,   1,  -1,  -1,
01173       1,  -1,   3,  -3,   1,   3,  -3,  -1,   3,  -3,   1,  -1,  10,   1, -10,  -1,
01174       1,   4,  -1,   2,   1,  -1,   1,  -2,   1,  -4,  -1,   6,  -6,  -1,   1,   1,
01175       1,  -1,   1,   1,  -1,  -1,  -1,   1,  11,  -1,  -2,   4,  -1,   2, -11,   5,
01176      -5,  -4,  -1,   1,   4,   1,  -4,  -1,  -2,   2,   1,  -1,  12,   1,  -2,   1,
01177     -12,   4,   2,   1,  -1,  -4,   4,  -4,   2,  -2,  -1,   1,   7,  -1,  -1,  -7,
01178      -1,  -3,   1,   3,   1,   5,   2,   1,  -1,  -5,  13,  -2,  -1,   2,  -2, -13,
01179       1,  -1,   5,   6,   5,  -5,   1,   1,  -6,   1,  -1,  -1,  -5,  -1,  14,   2,
01180      -2,   1, -14,  -1,   8,   1,  -1,  -8,   1,   5,   1,   5,  -5,   1,  -1,   1,
01181      -5,  -1,  15,   1,  -1,  -1,  -1,   3, -15,  -3,   6,   1,  16,  -1,   6,  -6,
01182      -6,   1,  -1,   1, -16,   1,   7,  -1,   1,  -1,  -6,  -3,   6,  -7,   3,  -1}
01183 },{
01184     /* MapTab3 */
01185     0,  /* eob_sym */
01186     35, /* esc_sym */
01187     /* run table */
01188     {0,  1,  1,  2,  2,  3,  3,  4,  4,  1,  1,  5,  5,  6,  6,  7,
01189      7,  8,  8,  9,  9,  2,  2, 10, 10,  1,  1, 11, 11, 12, 12,  3,
01190      3, 13, 13,  0, 14, 14, 16, 15, 16, 15,  4,  4, 17,  1, 17,  1,
01191      5,  5, 18, 18,  2,  2,  6,  6,  8, 19,  7,  8,  7, 19, 20, 20,
01192     21, 21, 22, 24, 22, 24, 23, 23,  1,  1, 25, 25,  3,  3, 26, 26,
01193      9,  9, 27, 27, 28, 28, 33, 29,  4, 33, 29,  1,  4,  1, 32, 32,
01194      2,  2, 31, 10, 30, 10, 30, 31, 34, 34,  5,  5, 36, 36, 35, 41,
01195     35, 11, 41, 11, 37,  1,  8,  8, 37,  6,  1,  6, 40,  7,  7, 40,
01196     12, 38, 12, 39, 39, 38, 49, 13, 49, 13,  3, 42,  3, 42, 16, 16,
01197     43, 43, 14, 14,  1,  1, 44, 15, 44, 15,  2,  2, 57, 48, 50, 48,
01198     57, 50,  4, 45, 45,  4, 46, 47, 47, 46,  1, 51,  1, 17, 17, 51,
01199      8,  9,  9,  5, 58,  8, 58,  5, 52, 52, 55, 56, 53, 56, 55, 59,
01200     59, 53, 54,  1,  6, 54,  7,  7,  6,  1,  2,  3,  2,  3, 64, 60,
01201     60, 10, 10, 64, 61, 62, 61, 63,  1, 63, 62,  1, 18, 24, 18,  4,
01202     25,  4,  8, 21, 21,  1, 24, 22, 25, 22,  8, 11, 19, 11, 23,  1,
01203     20, 23, 19, 20,  5, 12,  5,  1, 16,  2, 12, 13,  2, 13,  1, 16},
01204 
01205     /* value table */
01206     { 0,   1,  -1,   1,  -1,   1,  -1,   1,  -1,   2,  -2,   1,  -1,   1,  -1,   1,
01207      -1,   1,  -1,   1,  -1,   2,  -2,   1,  -1,   3,  -3,   1,  -1,   1,  -1,   2,
01208      -2,   1,  -1,   0,   1,  -1,   1,   1,  -1,  -1,   2,  -2,   1,   4,  -1,  -4,
01209       2,  -2,   1,  -1,  -3,   3,   2,  -2,   2,   1,   2,  -2,  -2,  -1,   1,  -1,
01210       1,  -1,   1,   1,  -1,  -1,   1,  -1,   5,  -5,   1,  -1,   3,  -3,   1,  -1,
01211       2,  -2,   1,  -1,   1,  -1,   1,   1,   3,  -1,  -1,   6,  -3,  -6,  -1,   1,
01212       4,  -4,   1,   2,   1,  -2,  -1,  -1,   1,  -1,   3,  -3,   1,  -1,   1,   1,
01213      -1,   2,  -1,  -2,   1,   7,  -3,   3,  -1,   3,  -7,  -3,   1,  -3,   3,  -1,
01214       2,   1,  -2,   1,  -1,  -1,   1,   2,  -1,  -2,  -4,  -1,   4,   1,   2,  -2,
01215       1,  -1,  -2,   2,   8,  -8,  -1,   2,   1,  -2,  -5,   5,   1,  -1,  -1,   1,
01216      -1,   1,   4,  -1,   1,  -4,  -1,  -1,   1,   1,   9,   1,  -9,   2,  -2,  -1,
01217      -4,   3,  -3,  -4,  -1,   4,   1,   4,   1,  -1,   1,  -1,   1,   1,  -1,   1,
01218      -1,  -1,  -1,  10,   4,   1,   4,  -4,  -4, -10,   6,   5,  -6,  -5,   1,  -1,
01219       1,   3,  -3,  -1,   1,  -1,  -1,  -1,  11,   1,   1, -11,  -2,  -2,   2,   5,
01220      -2,  -5,  -5,   2,  -2,  12,   2,  -2,   2,   2,   5,  -3,  -2,   3,  -2, -12,
01221      -2,   2,   2,   2,  -5,   3,   5,  13,  -3,   7,  -3,  -3,  -7,   3, -13,   3}
01222 },{
01223     /* MapTab4 */
01224     0,  /* eob_sym */
01225     34, /* esc_sym */
01226     /* run table */
01227     {0,  1,  1,  1,  2,  2,  1,  3,  3,  1,  1,  1,  4,  4,  1,  5,
01228      2,  1,  5,  2,  1,  1,  6,  6,  1,  1,  1,  1,  1,  7,  3,  1,
01229      2,  3,  0,  1,  2,  7,  1,  1,  1,  8,  1,  1,  8,  1,  1,  1,
01230      9,  1,  9,  1,  2,  1,  1,  2,  1,  1, 10,  4,  1, 10,  1,  4,
01231      1,  1,  1,  1,  1,  3,  1,  1,  1,  3,  2,  1,  5,  1,  1,  1,
01232      2,  5,  1, 11,  1, 11,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,
01233      2,  1,  6,  1,  6,  1,  1,  2,  1,  1,  1,  1,  1,  1,  1, 12,
01234      3,  1, 12,  1,  1,  1,  2,  1,  1,  3,  1,  1,  1,  1,  1,  1,
01235      4,  1,  1,  1,  2,  1,  1,  4,  1,  1,  1,  1,  1,  1,  2,  1,
01236      1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  3,  1,  2,  1,  1,  5,
01237      1,  1,  1,  1,  1,  7,  1,  7,  1,  1,  2,  3,  1,  1,  1,  1,
01238      5,  1,  1,  1,  1,  1,  1,  2, 13,  1,  1,  1,  1,  1,  1,  1,
01239      1,  1,  1,  1,  1,  1,  1,  1, 13,  2,  1,  1,  4,  1,  1,  1,
01240      3,  1,  6,  1,  1,  1, 14,  1,  1,  1,  1,  1, 14,  6,  1,  1,
01241      1,  1, 15,  2,  4,  1,  2,  3, 15,  1,  1,  1,  8,  1,  1,  8,
01242      1,  1,  1,  1,  1,  1,  1,  1,  2,  1,  1,  1,  1,  1,  1,  1},
01243 
01244     /* value table */
01245     { 0,   1,  -1,   2,   1,  -1,  -2,   1,  -1,   3,  -3,   4,   1,  -1,  -4,   1,
01246       2,   5,  -1,  -2,  -5,   6,   1,  -1,  -6,   7,  -7,   8,  -8,   1,   2,   9,
01247       3,  -2,   0,  -9,  -3,  -1,  10, -10,  11,   1, -11,  12,  -1, -12,  13, -13,
01248       1,  14,  -1, -14,   4,  15, -15,  -4,  16, -16,   1,   2,  17,  -1, -17,  -2,
01249      18, -18,  19, -19,  20,   3, -20,  21, -21,  -3,   5,  22,   2, -22, -23,  23,
01250      -5,  -2,  24,   1, -24,  -1,  25, -25,  26, -26, -27,  27,  28,  29, -28, -29,
01251       6,  30,   2, -31,  -2, -30,  31,  -6, -32,  32,  33, -33,  34, -35, -34,   1,
01252       4, -36,  -1,  35,  37,  36,   7, -37,  38,  -4, -38,  39,  41,  40, -40, -39,
01253       3,  42, -43, -41,  -7, -42,  43,  -3,  44, -44,  45, -45,  46,  47,   8, -47,
01254     -48, -46,  50, -50,  48,  49,  51, -49,  52, -52,   5, -51,  -8, -53,  53,   3,
01255     -56,  56,  55,  54, -54,   2,  60,  -2, -55,  58,   9,  -5,  59,  57, -57, -63,
01256      -3, -58, -60, -61,  61, -59, -62,  -9,   1,  64,  62,  69, -64,  63,  65, -67,
01257     -68,  66, -65,  68, -66, -69,  67, -70,  -1,  10,  71, -71,   4,  73,  72,  70,
01258       6, -76,  -3,  74, -78, -74,   1,  78,  80, -72, -75,  76,  -1,   3, -73,  79,
01259      75,  77,   1,  11,  -4, -79, -10,  -6,  -1, -77, -83, -80,   2,  81, -84,  -2,
01260      83, -81,  82, -82,  84, -87, -86,  85, -11, -85,  86, -89,  87, -88,  88,  89}
01261 },{
01262     /* MapTab5 */
01263     2,  /* eob_sym */
01264     33, /* esc_sym */
01265     /* run table */
01266     {1,  1,  0,  2,  1,  2,  1,  3,  3,  1,  1,  4,  4,  2,  2,  1,
01267      1,  5,  5,  6,  1,  6,  1,  7,  7,  3,  3,  2,  8,  2,  8,  1,
01268      1,  0,  9,  9,  1,  1, 10,  4, 10,  4, 11, 11,  2,  1,  2,  1,
01269     12, 12,  3,  3,  1,  1, 13,  5,  5, 13, 14,  1,  1, 14,  2,  2,
01270      6,  6, 15,  1,  1, 15, 16,  4,  7, 16,  4,  7,  1,  1,  3,  3,
01271      8,  8,  2,  2,  1,  1, 17, 17,  1,  1, 18, 18,  5,  5,  2,  2,
01272      1,  1,  9, 19,  9, 19, 20,  3,  3, 20,  1, 10, 21,  1, 10,  4,
01273      4, 21, 22,  6,  6, 22,  1,  1, 23, 24,  2,  2, 23, 24, 11,  1,
01274      1, 11,  7, 25,  7,  1,  1, 25,  8,  8,  3, 26,  3,  1, 12,  2,
01275      2, 26,  1, 12,  5,  5, 27,  4,  1,  4,  1, 27, 28,  1, 28, 13,
01276      1, 13,  2, 29,  2,  1, 32,  6,  1, 30, 14, 29, 14,  6,  3, 31,
01277      3,  1, 30,  1, 32, 31, 33,  9, 33,  1,  1,  7,  9,  7,  2,  2,
01278      1,  1,  4, 36, 34,  4,  5, 10, 10,  5, 34,  1,  1, 35,  8,  8,
01279     36,  3, 35,  1, 15,  3,  2,  1, 16, 15, 16,  2, 37,  1, 37,  1,
01280      1,  1,  6,  6, 38,  1, 38, 11,  1, 39, 39, 40, 11,  2, 41,  4,
01281     40,  1,  2,  4,  1,  1,  1, 41,  3,  1,  3,  1,  5,  7,  5,  7},
01282 
01283     /* value table */
01284     { 1,  -1,   0,   1,   2,  -1,  -2,   1,  -1,   3,  -3,   1,  -1,   2,  -2,   4,
01285      -4,   1,  -1,   1,   5,  -1,  -5,   1,  -1,   2,  -2,   3,   1,  -3,  -1,   6,
01286      -6,   0,   1,  -1,   7,  -7,   1,   2,  -1,  -2,   1,  -1,   4,   8,  -4,  -8,
01287       1,  -1,   3,  -3,   9,  -9,   1,   2,  -2,  -1,   1,  10, -10,  -1,   5,  -5,
01288       2,  -2,   1,  11, -11,  -1,   1,   3,   2,  -1,  -3,  -2,  12, -12,   4,  -4,
01289       2,  -2,  -6,   6,  13, -13,   1,  -1,  14, -14,   1,  -1,   3,  -3,   7,  -7,
01290      15, -15,   2,   1,  -2,  -1,   1,   5,  -5,  -1, -16,   2,   1,  16,  -2,   4,
01291      -4,  -1,   1,   3,  -3,  -1,  17, -17,   1,   1,  -8,   8,  -1,  -1,   2,  18,
01292     -18,  -2,   3,   1,  -3,  19, -19,  -1,   3,  -3,   6,   1,  -6,  20,   2,   9,
01293      -9,  -1, -20,  -2,   4,  -4,   1,  -5,  21,   5, -21,  -1,   1, -22,  -1,   2,
01294      22,  -2,  10,   1, -10,  23,   1,   4, -23,   1,   2,  -1,  -2,  -4,  -7,   1,
01295       7, -24,  -1,  24,  -1,  -1,   1,   3,  -1, -25,  25,   4,  -3,  -4,  11, -11,
01296      26, -26,   6,   1,   1,  -6,  -5,  -3,   3,   5,  -1, -27,  27,   1,   4,  -4,
01297      -1,  -8,  -1,  28,   2,   8, -12, -28,  -2,  -2,   2,  12,  -1,  29,   1, -29,
01298      30, -30,   5,  -5,   1, -31,  -1,   3,  31,  -1,   1,   1,  -3, -13,   1,  -7,
01299      -1, -32,  13,   7,  32,  33, -33,  -1,  -9, -34,   9,  34,  -6,   5,   6,  -5}
01300 },{
01301     /* MapTab6 */
01302     2,  /* eob_sym */
01303     13, /* esc_sym */
01304     /* run table */
01305     {1,  1,  0,  1,  1,  2,  2,  1,  1,  3,  3,  1,  1,  0,  2,  2,
01306      4,  1,  4,  1,  1,  1,  5,  5,  1,  1,  6,  6,  2,  2,  1,  1,
01307      3,  3,  7,  7,  1,  1,  8,  8,  1,  1,  2,  2,  1,  9,  1,  9,
01308      4,  4, 10,  1,  1, 10,  1,  1, 11, 11,  3,  3,  1,  2,  1,  2,
01309      1,  1, 12, 12,  5,  5,  1,  1, 13,  1,  1, 13,  2,  2,  1,  1,
01310      6,  6,  1,  1,  4, 14,  4, 14,  3,  1,  3,  1,  1,  1, 15,  7,
01311     15,  2,  2,  7,  1,  1,  1,  8,  1,  8, 16, 16,  1,  1,  1,  1,
01312      2,  1,  1,  2,  1,  1,  3,  5,  5,  3,  4,  1,  1,  4,  1,  1,
01313     17, 17,  9,  1,  1,  9,  2,  2,  1,  1, 10, 10,  1,  6,  1,  1,
01314      6, 18,  1,  1, 18,  1,  1,  1,  2,  2,  3,  1,  3,  1,  1,  1,
01315      4,  1, 19,  1, 19,  7,  1,  1, 20,  1,  4, 20,  1,  7, 11,  2,
01316      1, 11, 21,  2,  8,  5,  1,  8,  1,  5, 21,  1,  1,  1, 22,  1,
01317      1, 22,  1,  1,  3,  3,  1, 23,  2, 12, 24,  1,  1,  2,  1,  1,
01318     12, 23,  1,  1, 24,  1,  1,  1,  4,  1,  1,  1,  2,  1,  6,  6,
01319      4,  2,  1,  1,  1,  1,  1,  1,  1, 14, 13,  3,  1, 25,  9, 25,
01320     14,  1,  9,  3, 13,  1,  1,  1,  1,  1, 10,  1,  1,  2, 10,  2},
01321 
01322     /* value table */
01323     {-20,  -1,   0,   2,  -2,   1,  -1,   3,  -3,   1,  -1,   4,  -4,   0,   2,  -2,
01324        1,   5,  -1,  -5,   6,  -6,   1,  -1,   7,  -7,   1,  -1,   3,  -3,   8,  -8,
01325        2,  -2,   1,  -1,   9,  -9,   1,  -1,  10, -10,   4,  -4,  11,   1, -11,  -1,
01326        2,  -2,   1,  12, -12,  -1,  13, -13,   1,  -1,   3,  -3,  14,   5, -14,  -5,
01327      -15,  15,  -1,   1,   2,  -2,  16, -16,   1,  17, -17,  -1,   6,  -6,  18, -18,
01328        2,  -2, -19,  19,  -3,   1,   3,  -1,   4,  20,  -4,   1, -21,  21,   1,   2,
01329       -1,  -7,   7,  -2,  22, -22,  23,   2, -23,  -2,   1,  -1, -24,  24, -25,  25,
01330       -8, -26,  26,   8, -27,  27,   5,   3,  -3,  -5,  -4,  28, -28,   4,  29, -29,
01331        1,  -1,  -2, -30,  30,   2,   9,  -9, -31,  31,   2,  -2, -32,   3,  32, -33,
01332       -3,   1,  33, -34,  -1,  34, -35,  35, -10,  10,  -6,  36,   6, -36,  37, -37,
01333       -5,  38,   1, -38,  -1,   3,  39, -39,  -1,  40,   5,   1, -40,  -3,   2, -11,
01334      -41,  -2,   1,  11,  -3,  -4,  41,   3,  42,   4,  -1, -43, -42,  43,   1, -44,
01335       45,  -1,  44, -45,  -7,   7, -46,   1, -12,   2,   1, -47,  46,  12,  47,  48,
01336       -2,  -1, -48,  49,  -1, -50, -49,  50,  -6, -51,  51,  52, -13,  53,  -4,   4,
01337        6,  13, -53, -52, -54,  55,  54, -55, -56,  -2,   2,  -8,  56,   1,  -3,  -1,
01338        2,  58,   3,   8,  -2,  57, -58, -60, -59, -57,  -3,  60,  59, -14,   3,  14}
01339 },{
01340     /* MapTab7 */
01341     2,  /* eob_sym */
01342     38, /* esc_sym */
01343     /* run table */
01344     {1,  1,  0,  2,  2,  1,  1,  3,  3,  4,  4,  5,  5,  1,  1,  6,
01345      6,  2,  2,  7,  7,  8,  8,  1,  1,  3,  3,  9,  9, 10, 10,  1,
01346      1,  2,  2,  4,  4, 11,  0, 11, 12, 12, 13, 13,  1,  1,  5,  5,
01347     14, 14, 15, 16, 15, 16,  3,  3,  1,  6,  1,  6,  2,  2,  7,  7,
01348      8,  8, 17, 17,  1,  1,  4,  4, 18, 18,  2,  2,  1, 19,  1, 20,
01349     19, 20, 21, 21,  3,  3, 22, 22,  5,  5, 24,  1,  1, 23,  9, 23,
01350     24,  9,  2,  2, 10,  1,  1, 10,  6,  6, 25,  4,  4, 25,  7,  7,
01351     26,  8,  1,  8,  3,  1, 26,  3, 11, 11, 27, 27,  2, 28,  1,  2,
01352     28,  1, 12, 12,  5,  5, 29, 13, 13, 29, 32,  1,  1, 33, 31, 30,
01353     32,  4, 30, 33,  4, 31,  3, 14,  1,  1,  3, 34, 34,  2,  2, 14,
01354      6,  6, 35, 36, 35, 36,  1, 15,  1, 16, 16, 15,  7,  9,  7,  9,
01355     37,  8,  8, 37,  1,  1, 39,  2, 38, 39,  2, 40,  5, 38, 40,  5,
01356      3,  3,  4,  4, 10, 10,  1,  1,  1,  1, 41,  2, 41,  2,  6,  6,
01357      1,  1, 11, 42, 11, 43,  3, 42,  3, 17,  4, 43,  1, 17,  7,  1,
01358      8, 44,  4,  7, 44,  5,  8,  2,  5,  1,  2, 48, 45,  1, 12, 45,
01359     12, 48, 13, 13,  1,  9,  9, 46,  1, 46, 47, 47, 49, 18, 18, 49},
01360 
01361     /* value table */
01362     { 1,  -1,   0,   1,  -1,   2,  -2,   1,  -1,   1,  -1,   1,  -1,   3,  -3,   1,
01363      -1,  -2,   2,   1,  -1,   1,  -1,   4,  -4,  -2,   2,   1,  -1,   1,  -1,   5,
01364      -5,  -3,   3,   2,  -2,   1,   0,  -1,   1,  -1,   1,  -1,   6,  -6,   2,  -2,
01365       1,  -1,   1,   1,  -1,  -1,  -3,   3,   7,   2,  -7,  -2,  -4,   4,   2,  -2,
01366       2,  -2,   1,  -1,   8,  -8,   3,  -3,   1,  -1,  -5,   5,   9,   1,  -9,   1,
01367      -1,  -1,   1,  -1,  -4,   4,   1,  -1,   3,  -3,   1, -10,  10,   1,   2,  -1,
01368      -1,  -2,   6,  -6,   2,  11, -11,  -2,   3,  -3,   1,  -4,   4,  -1,   3,  -3,
01369       1,   3,  12,  -3,  -5, -12,  -1,   5,   2,  -2,   1,  -1,  -7,   1,  13,   7,
01370      -1, -13,   2,  -2,   4,  -4,   1,   2,  -2,  -1,   1,  14, -14,   1,   1,   1,
01371      -1,  -5,  -1,  -1,   5,  -1,  -6,   2, -15,  15,   6,   1,  -1,  -8,   8,  -2,
01372      -4,   4,   1,   1,  -1,  -1,  16,   2, -16,  -2,   2,  -2,   4,   3,  -4,  -3,
01373      -1,  -4,   4,   1, -17,  17,  -1,  -9,   1,   1,   9,   1,  -5,  -1,  -1,   5,
01374      -7,   7,   6,  -6,   3,  -3,  18, -18,  19, -19,   1, -10,  -1,  10,  -5,   5,
01375      20, -20,  -3,   1,   3,   1,   8,  -1,  -8,   2,   7,  -1, -21,  -2,   5,  21,
01376       5,  -1,  -7,  -5,   1,  -6,  -5, -11,   6,  22,  11,   1,   1, -22,  -3,  -1,
01377       3,  -1,   3,  -3, -23,   4,  -4,   1,  23,  -1,   1,  -1,   1,  -2,   2,  -1}
01378 },{
01379     /* MapTab8 */
01380     4,  /* eob_sym */
01381     11, /* esc_sym */
01382     /* run table */
01383     {1,  1,  1,  1,  0,  2,  2,  1,  1,  3,  3,  0,  1,  1,  2,  2,
01384      4,  4,  1,  1,  5,  5,  1,  1,  2,  2,  3,  3,  6,  6,  1,  1,
01385      7,  7,  8,  1,  8,  2,  2,  1,  4,  4,  1,  3,  1,  3,  9,  9,
01386      2,  2,  1,  5,  1,  5, 10, 10,  1,  1, 11, 11,  3,  6,  3,  4,
01387      4,  6,  2,  2,  1, 12,  1, 12,  7, 13,  7, 13,  1,  1,  8,  8,
01388      2,  2, 14, 14, 16, 15, 16,  5,  5,  1,  3, 15,  1,  3,  4,  4,
01389      1,  1, 17, 17,  2,  2,  6,  6,  1, 18,  1, 18, 22, 21, 22, 21,
01390     25, 24, 25, 19,  9, 20,  9, 23, 19, 24, 20,  3, 23,  7,  3,  1,
01391      1,  7, 28, 26, 29,  5, 28, 26,  5,  8, 29,  4,  8, 27,  2,  2,
01392      4, 27,  1,  1, 10, 36, 10, 33, 33, 36, 30,  1, 32, 32,  1, 30,
01393      6, 31, 31, 35,  3,  6, 11, 11,  3,  2, 35,  2, 34,  1, 34,  1,
01394     37, 37, 12,  7, 12,  5, 41,  5,  4,  7,  1,  8, 13,  4,  1, 41,
01395     13, 38,  8, 38,  9,  1, 40, 40,  9,  1, 39,  2,  2, 49, 39, 42,
01396      3,  3, 14, 16, 49, 14, 16, 42, 43, 43,  6,  6, 15,  1,  1, 15,
01397     44, 44,  1,  1, 50, 48,  4,  5,  4,  7,  5,  2, 10, 10, 48,  7,
01398     50, 45,  2,  1, 45,  8,  8,  1, 46, 46,  3, 47, 47,  3,  1,  1},
01399 
01400     /* value table */
01401     { 1,  -1,   2,  -2,   0,   1,  -1,   3,  -3,   1,  -1,   0,   4,  -4,   2,  -2,
01402       1,  -1,   5,  -5,   1,  -1,   6,  -6,   3,  -3,   2,  -2,   1,  -1,   7,  -7,
01403       1,  -1,   1,   8,  -1,   4,  -4,  -8,   2,  -2,   9,   3,  -9,  -3,   1,  -1,
01404       5,  -5,  10,   2, -10,  -2,   1,  -1,  11, -11,   1,  -1,  -4,   2,   4,   3,
01405      -3,  -2,   6,  -6,  12,   1, -12,  -1,   2,   1,  -2,  -1,  13, -13,   2,  -2,
01406       7,  -7,   1,  -1,   1,   1,  -1,   3,  -3,  14,   5,  -1, -14,  -5,   4,  -4,
01407      15, -15,   1,  -1,   8,  -8,  -3,   3,  16,   1, -16,  -1,   1,   1,  -1,  -1,
01408       1,   1,  -1,   1,   2,   1,  -2,   1,  -1,  -1,  -1,   6,  -1,   3,  -6,  17,
01409     -17,  -3,   1,   1,   1,   4,  -1,  -1,  -4,   3,  -1,   5,  -3,  -1,  -9,   9,
01410      -5,   1,  18, -18,   2,   1,  -2,   1,  -1,  -1,   1,  19,  -1,   1, -19,  -1,
01411       4,   1,  -1,   1,   7,  -4,  -2,   2,  -7,  10,  -1, -10,   1,  20,  -1, -20,
01412       1,  -1,   2,   4,  -2,   5,   1,  -5,   6,  -4,  21,   4,   2,  -6, -21,  -1,
01413      -2,   1,  -4,  -1,  -3,  22,  -1,   1,   3, -22,  -1,  11, -11,   1,   1,   1,
01414       8,  -8,   2,   2,  -1,  -2,  -2,  -1,   1,  -1,  -5,   5,   2,  23, -23,  -2,
01415       1,  -1,  24, -24,  -1,  -1,   7,   6,  -7,   5,  -6,  12,  -3,   3,   1,  -5,
01416       1,   1, -12,  25,  -1,  -5,   5, -25,  -1,   1,   9,   1,  -1,  -9,  26, -26}
01417 }
01418 };