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