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

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