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