LCOV - code coverage report
Current view: top level - libavcodec - ivi.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 408 591 69.0 %
Date: 2017-12-11 04:34:20 Functions: 19 20 95.0 %

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

Generated by: LCOV version 1.13