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