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