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