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                 return AVERROR(ENOMEM);
 447
 448             /* use the first luma band as reference for motion vectors
 449              * and quant */
 450             ret = ivi_init_tiles(band, planes[0].bands[0].tiles,
 451                                  p, b, t_height, t_width);
 452             if (ret < 0)
 453                 return ret;
 454         }
 455     }
 456
 457     return 0;
 458 }
 459
 460 /*
 461  *  Decode size of the tile data.
 462  *  The size is stored as a variable-length field having the following format:
 463  *  if (tile_data_size < 255) than this field is only one byte long
 464  *  if (tile_data_size >= 255) than this field four is byte long: 0xFF X1 X2 X3
 465  *  where X1-X3 is size of the tile data
 466  *
 467  *  @param[in,out]  gb  the GetBit context
 468  *  @return     size of the tile data in bytes
 469  */
 470 static int ivi_dec_tile_data_size(GetBitContext *gb)
 471 {
 472     int    len;
 473
 474     len = 0;
 475     if (get_bits1(gb)) {
 476         len = get_bits(gb, 8);
 477         if (len == 255)
 478             len = get_bits(gb, 24);
 479     }
 480
 481     /* align the bitstream reader on the byte boundary */
 482     align_get_bits(gb);
 483
 484     return len;
 485 }
 486
 487 static int ivi_dc_transform(const IVIBandDesc *band, int *prev_dc, int buf_offs,
 488                             int blk_size)
 489 {
 490     band->dc_transform(prev_dc, band->buf + buf_offs,
 491                        band->pitch, blk_size);
 492
 493     return 0;
 494 }
 495
 496 static int ivi_decode_coded_blocks(GetBitContext *gb, const IVIBandDesc *band,
 497                                    ivi_mc_func mc, ivi_mc_avg_func mc_avg,
 498                                    int mv_x, int mv_y,
 499                                    int mv_x2, int mv_y2,
 500                                    int *prev_dc, int is_intra,
 501                                    int mc_type, int mc_type2,
 502                                    uint32_t quant, int offs,
 503                                    AVCodecContext *avctx)
 504 {
 505     const uint16_t *base_tab  = is_intra ? band->intra_base : band->inter_base;
 506     RVMapDesc *rvmap = band->rv_map;
 507     uint8_t col_flags[8];
 508     int32_t trvec[64];
 509     uint32_t sym = 0, lo, hi, q;
 510     int pos, run, val;
 511     int blk_size   = band->blk_size;
 512     int num_coeffs = blk_size * blk_size;
 513     int col_mask   = blk_size - 1;
 514     int scan_pos   = -1;
 515     int min_size   = band->pitch * (band->transform_size - 1) +
 516                      band->transform_size;
 517     int buf_size   = band->pitch * band->aheight - offs;
 518
 519     if (min_size > buf_size)
 520         return AVERROR_INVALIDDATA;
 521
 522     if (!band->scan) {
 523         av_log(avctx, AV_LOG_ERROR, "Scan pattern is not set.\n");
 524         return AVERROR_INVALIDDATA;
 525     }
 526
 527     /* zero transform vector */
 528     memset(trvec, 0, num_coeffs * sizeof(trvec[0]));
 529     /* zero column flags */
 530     memset(col_flags, 0, sizeof(col_flags));
 531     while (scan_pos <= num_coeffs) {
 532         sym = get_vlc2(gb, band->blk_vlc.tab->table,
 533                        IVI_VLC_BITS, 1);
 534         if (sym == rvmap->eob_sym)
 535             break; /* End of block */
 536
 537         /* Escape - run/val explicitly coded using 3 vlc codes */
 538         if (sym == rvmap->esc_sym) {
 539             run = get_vlc2(gb, band->blk_vlc.tab->table, IVI_VLC_BITS, 1) + 1;
 540             lo  = get_vlc2(gb, band->blk_vlc.tab->table, IVI_VLC_BITS, 1);
 541             hi  = get_vlc2(gb, band->blk_vlc.tab->table, IVI_VLC_BITS, 1);
 542             /* merge them and convert into signed val */
 543             val = IVI_TOSIGNED((hi << 6) | lo);
 544         } else {
 545             if (sym >= 256U) {
 546                 av_log(avctx, AV_LOG_ERROR, "Invalid sym encountered: %"PRIu32".\n", sym);
 547                 return AVERROR_INVALIDDATA;
 548             }
 549             run = rvmap->runtab[sym];
 550             val = rvmap->valtab[sym];
 551         }
 552
 553         /* de-zigzag and dequantize */
 554         scan_pos += run;
 555         if (scan_pos >= num_coeffs || scan_pos < 0)
 556             break;
 557         pos = band->scan[scan_pos];
 558
 559         if (!val)
 560             ff_dlog(avctx, "Val = 0 encountered!\n");
 561
 562         q = (base_tab[pos] * quant) >> 9;
 563         if (q > 1)
 564             val = val * q + FFSIGN(val) * (((q ^ 1) - 1) >> 1);
 565         trvec[pos] = val;
 566         /* track columns containing non-zero coeffs */
 567         col_flags[pos & col_mask] |= !!val;
 568     }
 569
 570     if (scan_pos < 0 || scan_pos >= num_coeffs && sym != rvmap->eob_sym)
 571         return AVERROR_INVALIDDATA; /* corrupt block data */
 572
 573     /* undoing DC coeff prediction for intra-blocks */
 574     if (is_intra && band->is_2d_trans) {
 575         *prev_dc     += trvec[0];
 576         trvec[0]      = *prev_dc;
 577         col_flags[0] |= !!*prev_dc;
 578     }
 579
 580     if(band->transform_size > band->blk_size){
 581         av_log(NULL, AV_LOG_ERROR, "Too large transform\n");
 582         return AVERROR_INVALIDDATA;
 583     }
 584
 585     /* apply inverse transform */
 586     band->inv_transform(trvec, band->buf + offs,
 587                         band->pitch, col_flags);
 588
 589     /* apply motion compensation */
 590     if (!is_intra)
 591         return ivi_mc(band, mc, mc_avg, offs, mv_x, mv_y, mv_x2, mv_y2,
 592                       mc_type, mc_type2);
 593
 594     return 0;
 595 }
 596 /*
 597  *  Decode block data:
 598  *  extract huffman-coded transform coefficients from the bitstream,
 599  *  dequantize them, apply inverse transform and motion compensation
 600  *  in order to reconstruct the picture.
 601  *
 602  *  @param[in,out]  gb    the GetBit context
 603  *  @param[in]      band  pointer to the band descriptor
 604  *  @param[in]      tile  pointer to the tile descriptor
 605  *  @return     result code: 0 - OK, -1 = error (corrupted blocks data)
 606  */
 607 static int ivi_decode_blocks(GetBitContext *gb, const IVIBandDesc *band,
 608                              IVITile *tile, AVCodecContext *avctx)
 609 {
 610     int mbn, blk, num_blocks, blk_size, ret, is_intra;
 611     int mc_type = 0, mc_type2 = -1;
 612     int mv_x = 0, mv_y = 0, mv_x2 = 0, mv_y2 = 0;
 613     int32_t prev_dc;
 614     uint32_t cbp, quant, buf_offs;
 615     IVIMbInfo *mb;
 616     ivi_mc_func mc_with_delta_func, mc_no_delta_func;
 617     ivi_mc_avg_func mc_avg_with_delta_func, mc_avg_no_delta_func;
 618     const uint8_t *scale_tab;
 619
 620     /* init intra prediction for the DC coefficient */
 621     prev_dc    = 0;
 622     blk_size   = band->blk_size;
 623     /* number of blocks per mb */
 624     num_blocks = (band->mb_size != blk_size) ? 4 : 1;
 625     if (blk_size == 8) {
 626         mc_with_delta_func     = ff_ivi_mc_8x8_delta;
 627         mc_no_delta_func       = ff_ivi_mc_8x8_no_delta;
 628         mc_avg_with_delta_func = ff_ivi_mc_avg_8x8_delta;
 629         mc_avg_no_delta_func   = ff_ivi_mc_avg_8x8_no_delta;
 630     } else {
 631         mc_with_delta_func     = ff_ivi_mc_4x4_delta;
 632         mc_no_delta_func       = ff_ivi_mc_4x4_no_delta;
 633         mc_avg_with_delta_func = ff_ivi_mc_avg_4x4_delta;
 634         mc_avg_no_delta_func   = ff_ivi_mc_avg_4x4_no_delta;
 635     }
 636
 637     for (mbn = 0, mb = tile->mbs; mbn < tile->num_MBs; mb++, mbn++) {
 638         is_intra = !mb->type;
 639         cbp      = mb->cbp;
 640         buf_offs = mb->buf_offs;
 641
 642         quant = band->glob_quant + mb->q_delta;
 643         if (avctx->codec_id == AV_CODEC_ID_INDEO4)
 644             quant = av_clip_uintp2(quant, 5);
 645         else
 646             quant = av_clip(quant, 0, 23);
 647
 648         scale_tab = is_intra ? band->intra_scale : band->inter_scale;
 649         if (scale_tab)
 650             quant = scale_tab[quant];
 651
 652         if (!is_intra) {
 653             mv_x  = mb->mv_x;
 654             mv_y  = mb->mv_y;
 655             mv_x2 = mb->b_mv_x;
 656             mv_y2 = mb->b_mv_y;
 657             if (band->is_halfpel) {
 658                 mc_type  = ((mv_y  & 1) << 1) | (mv_x  & 1);
 659                 mc_type2 = ((mv_y2 & 1) << 1) | (mv_x2 & 1);
 660                 mv_x  >>= 1;
 661                 mv_y  >>= 1;
 662                 mv_x2 >>= 1;
 663                 mv_y2 >>= 1; /* convert halfpel vectors into fullpel ones */
 664             }
 665             if (mb->type == 2)
 666                 mc_type = -1;
 667             if (mb->type != 2 && mb->type != 3)
 668                 mc_type2 = -1;
 669             if (mb->type) {
 670                 int dmv_x, dmv_y, cx, cy;
 671
 672                 dmv_x = mb->mv_x >> band->is_halfpel;
 673                 dmv_y = mb->mv_y >> band->is_halfpel;
 674                 cx    = mb->mv_x &  band->is_halfpel;
 675                 cy    = mb->mv_y &  band->is_halfpel;
 676
 677                 if (mb->xpos + dmv_x < 0 ||
 678                     mb->xpos + dmv_x + band->mb_size + cx > band->pitch ||
 679                     mb->ypos + dmv_y < 0 ||
 680                     mb->ypos + dmv_y + band->mb_size + cy > band->aheight) {
 681                     return AVERROR_INVALIDDATA;
 682                 }
 683             }
 684             if (mb->type == 2 || mb->type == 3) {
 685                 int dmv_x, dmv_y, cx, cy;
 686
 687                 dmv_x = mb->b_mv_x >> band->is_halfpel;
 688                 dmv_y = mb->b_mv_y >> band->is_halfpel;
 689                 cx    = mb->b_mv_x &  band->is_halfpel;
 690                 cy    = mb->b_mv_y &  band->is_halfpel;
 691
 692                 if (mb->xpos + dmv_x < 0 ||
 693                     mb->xpos + dmv_x + band->mb_size + cx > band->pitch ||
 694                     mb->ypos + dmv_y < 0 ||
 695                     mb->ypos + dmv_y + band->mb_size + cy > band->aheight) {
 696                     return AVERROR_INVALIDDATA;
 697                 }
 698             }
 699         }
 700
 701         for (blk = 0; blk < num_blocks; blk++) {
 702             /* adjust block position in the buffer according to its number */
 703             if (blk & 1) {
 704                 buf_offs += blk_size;
 705             } else if (blk == 2) {
 706                 buf_offs -= blk_size;
 707                 buf_offs += blk_size * band->pitch;
 708             }
 709
 710             if (cbp & 1) { /* block coded ? */
 711                 ret = ivi_decode_coded_blocks(gb, band, mc_with_delta_func,
 712                                               mc_avg_with_delta_func,
 713                                               mv_x, mv_y, mv_x2, mv_y2,
 714                                               &prev_dc, is_intra,
 715                                               mc_type, mc_type2, quant,
 716                                               buf_offs, avctx);
 717                 if (ret < 0)
 718                     return ret;
 719             } else {
 720                 int buf_size = band->pitch * band->aheight - buf_offs;
 721                 int min_size = (blk_size - 1) * band->pitch + blk_size;
 722
 723                 if (min_size > buf_size)
 724                     return AVERROR_INVALIDDATA;
 725                 /* block not coded */
 726                 /* for intra blocks apply the dc slant transform */
 727                 /* for inter - perform the motion compensation without delta */
 728                 if (is_intra) {
 729                     ret = ivi_dc_transform(band, &prev_dc, buf_offs, blk_size);
 730                     if (ret < 0)
 731                         return ret;
 732                 } else {
 733                     ret = ivi_mc(band, mc_no_delta_func, mc_avg_no_delta_func,
 734                                  buf_offs, mv_x, mv_y, mv_x2, mv_y2,
 735                                  mc_type, mc_type2);
 736                     if (ret < 0)
 737                         return ret;
 738                 }
 739             }
 740
 741             cbp >>= 1;
 742         }// for blk
 743     }// for mbn
 744
 745     align_get_bits(gb);
 746
 747     return 0;
 748 }
 749
 750 /**
 751  *  Handle empty tiles by performing data copying and motion
 752  *  compensation respectively.
 753  *
 754  *  @param[in]  avctx     ptr to the AVCodecContext
 755  *  @param[in]  band      pointer to the band descriptor
 756  *  @param[in]  tile      pointer to the tile descriptor
 757  *  @param[in]  mv_scale  scaling factor for motion vectors
 758  */
 759 static int ivi_process_empty_tile(AVCodecContext *avctx, const IVIBandDesc *band,
 760                                   IVITile *tile, int32_t mv_scale)
 761 {
 762     int             x, y, need_mc, mbn, blk, num_blocks, mv_x, mv_y, mc_type;
 763     int             offs, mb_offset, row_offset, ret;
 764     IVIMbInfo       *mb, *ref_mb;
 765     const int16_t   *src;
 766     int16_t         *dst;
 767     ivi_mc_func     mc_no_delta_func;
 768     int             clear_first = !band->qdelta_present && !band->plane && !band->band_num;
 769     int             mb_size     = band->mb_size;
 770     int             xend        = tile->xpos + tile->width;
 771     int             is_halfpel  = band->is_halfpel;
 772     int             pitch       = band->pitch;
 773
 774     if (tile->num_MBs != IVI_MBs_PER_TILE(tile->width, tile->height, mb_size)) {
 775         av_log(avctx, AV_LOG_ERROR, "Allocated tile size %d mismatches "
 776                "parameters %d in ivi_process_empty_tile()\n",
 777                tile->num_MBs, IVI_MBs_PER_TILE(tile->width, tile->height, mb_size));
 778         return AVERROR_INVALIDDATA;
 779     }
 780
 781     offs       = tile->ypos * pitch + tile->xpos;
 782     mb         = tile->mbs;
 783     ref_mb     = tile->ref_mbs;
 784     row_offset = mb_size * pitch;
 785     need_mc    = 0; /* reset the mc tracking flag */
 786
 787     for (y = tile->ypos; y < (tile->ypos + tile->height); y += mb_size) {
 788         mb_offset = offs;
 789
 790         for (x = tile->xpos; x < xend; x += mb_size) {
 791             mb->xpos     = x;
 792             mb->ypos     = y;
 793             mb->buf_offs = mb_offset;
 794
 795             mb->type = 1; /* set the macroblocks type = INTER */
 796             mb->cbp  = 0; /* all blocks are empty */
 797
 798             if (clear_first) {
 799                 mb->q_delta = band->glob_quant;
 800                 mb->mv_x    = 0;
 801                 mb->mv_y    = 0;
 802             }
 803
 804             if (ref_mb) {
 805                 if (band->inherit_qdelta)
 806                     mb->q_delta = ref_mb->q_delta;
 807
 808                 if (band->inherit_mv) {
 809                     /* motion vector inheritance */
 810                     if (mv_scale) {
 811                         mb->mv_x = ivi_scale_mv(ref_mb->mv_x, mv_scale);
 812                         mb->mv_y = ivi_scale_mv(ref_mb->mv_y, mv_scale);
 813                     } else {
 814                         mb->mv_x = ref_mb->mv_x;
 815                         mb->mv_y = ref_mb->mv_y;
 816                     }
 817                     need_mc |= mb->mv_x || mb->mv_y; /* tracking non-zero motion vectors */
 818                     {
 819                         int dmv_x, dmv_y, cx, cy;
 820
 821                         dmv_x = mb->mv_x >> is_halfpel;
 822                         dmv_y = mb->mv_y >> is_halfpel;
 823                         cx    = mb->mv_x &  is_halfpel;
 824                         cy    = mb->mv_y &  is_halfpel;
 825
 826                         if (   mb->xpos + dmv_x < 0
 827                             || mb->xpos + dmv_x + mb_size + cx > pitch
 828                             || mb->ypos + dmv_y < 0
 829                             || mb->ypos + dmv_y + mb_size + cy > band->aheight) {
 830                             av_log(avctx, AV_LOG_ERROR, "MV out of bounds\n");
 831                             return AVERROR_INVALIDDATA;
 832                         }
 833                     }
 834                 }
 835                 ref_mb++;
 836             }
 837
 838             mb++;
 839             mb_offset += mb_size;
 840         } // for x
 841         offs += row_offset;
 842     } // for y
 843
 844     if (band->inherit_mv && need_mc) { /* apply motion compensation if there is at least one non-zero motion vector */
 845         num_blocks = (mb_size != band->blk_size) ? 4 : 1; /* number of blocks per mb */
 846         mc_no_delta_func = (band->blk_size == 8) ? ff_ivi_mc_8x8_no_delta
 847                                                  : ff_ivi_mc_4x4_no_delta;
 848
 849         for (mbn = 0, mb = tile->mbs; mbn < tile->num_MBs; mb++, mbn++) {
 850             mv_x = mb->mv_x;
 851             mv_y = mb->mv_y;
 852             if (!band->is_halfpel) {
 853                 mc_type = 0; /* we have only fullpel vectors */
 854             } else {
 855                 mc_type = ((mv_y & 1) << 1) | (mv_x & 1);
 856                 mv_x >>= 1;
 857                 mv_y >>= 1; /* convert halfpel vectors into fullpel ones */
 858             }
 859
 860             for (blk = 0; blk < num_blocks; blk++) {
 861                 /* adjust block position in the buffer according with its number */
 862                 offs = mb->buf_offs + band->blk_size * ((blk & 1) + !!(blk & 2) * pitch);
 863                 ret = ivi_mc(band, mc_no_delta_func, 0, offs,
 864                              mv_x, mv_y, 0, 0, mc_type, -1);
 865                 if (ret < 0)
 866                     return ret;
 867             }
 868         }
 869     } else {
 870         /* copy data from the reference tile into the current one */
 871         src = band->ref_buf + tile->ypos * pitch + tile->xpos;
 872         dst = band->buf     + tile->ypos * pitch + tile->xpos;
 873         for (y = 0; y < tile->height; y++) {
 874             memcpy(dst, src, tile->width*sizeof(band->buf[0]));
 875             src += pitch;
 876             dst += pitch;
 877         }
 878     }
 879
 880     return 0;
 881 }
 882
 883
 884 #ifdef DEBUG
 885 static uint16_t ivi_calc_band_checksum(const IVIBandDesc *band)
 886 {
 887     int         x, y;
 888     int16_t     *src, checksum;
 889
 890     src = band->buf;
 891     checksum = 0;
 892
 893     for (y = 0; y < band->height; src += band->pitch, y++)
 894         for (x = 0; x < band->width; x++)
 895             checksum += src[x];
 896
 897     return checksum;
 898 }
 899 #endif
 900
 901 /*
 902  *  Convert and output the current plane.
 903  *  This conversion is done by adding back the bias value of 128
 904  *  (subtracted in the encoder) and clipping the result.
 905  *
 906  *  @param[in]   plane      pointer to the descriptor of the plane being processed
 907  *  @param[out]  dst        pointer to the buffer receiving converted pixels
 908  *  @param[in]   dst_pitch  pitch for moving to the next y line
 909  */
 910 static void ivi_output_plane(IVIPlaneDesc *plane, uint8_t *dst, ptrdiff_t dst_pitch)
 911 {
 912     int             x, y;
 913     const int16_t   *src  = plane->bands[0].buf;
 914     ptrdiff_t       pitch = plane->bands[0].pitch;
 915
 916     if (!src)
 917         return;
 918
 919     for (y = 0; y < plane->height; y++) {
 920         int m = 0;
 921         int w = plane->width;
 922         for (x = 0; x < w; x++) {
 923             int t = src[x] + 128;
 924             dst[x] = t;
 925             m |= t;
 926         }
 927         if (m & ~255)
 928             for (x = 0; x < w; x++)
 929                 dst[x] = av_clip_uint8(src[x] + 128);
 930         src += pitch;
 931         dst += dst_pitch;
 932     }
 933 }
 934
 935 static void *prepare_buf(IVI45DecContext *ctx, IVIBandDesc *band, int i)
 936 {
 937     if (ctx->pic_conf.luma_bands <= 1 && i == 2)
 938         return NULL;
 939     if (!band->bufs[i])
 940         band->bufs[i] = av_mallocz(2 * band->bufsize);
 941     return band->bufs[i];
 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     = prepare_buf(ctx, band, 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   = prepare_buf(ctx, band, ctx->b_ref_buf);
 965         band->b_ref_buf = prepare_buf(ctx, band, ctx->ref_buf);
 966         if (!band->b_ref_buf)
 967             return AVERROR(ENOMEM);
 968     } else {
 969         band->ref_buf   = prepare_buf(ctx, band, ctx->ref_buf);
 970         band->b_ref_buf = 0;
 971     }
 972     if (!band->ref_buf)
 973         return AVERROR(ENOMEM);
 974     band->data_ptr  = ctx->frame_data + (get_bits_count(&ctx->gb) >> 3);
 975
 976     result = ctx->decode_band_hdr(ctx, band, avctx);
 977     if (result) {
 978         av_log(avctx, AV_LOG_ERROR, "Error while decoding band header: %d\n",
 979                result);
 980         return result;
 981     }
 982
 983     if (band->is_empty) {
 984         av_log(avctx, AV_LOG_ERROR, "Empty band encountered!\n");
 985         return AVERROR_INVALIDDATA;
 986     }
 987
 988     band->rv_map = &ctx->rvmap_tabs[band->rvmap_sel];
 989
 990     /* apply corrections to the selected rvmap table if present */
 991     for (i = 0; i < band->num_corr; i++) {
 992         idx1 = band->corr[i * 2];
 993         idx2 = band->corr[i * 2 + 1];
 994         FFSWAP(uint8_t, band->rv_map->runtab[idx1], band->rv_map->runtab[idx2]);
 995         FFSWAP(int16_t, band->rv_map->valtab[idx1], band->rv_map->valtab[idx2]);
 996         if (idx1 == band->rv_map->eob_sym || idx2 == band->rv_map->eob_sym)
 997             band->rv_map->eob_sym ^= idx1 ^ idx2;
 998         if (idx1 == band->rv_map->esc_sym || idx2 == band->rv_map->esc_sym)
 999             band->rv_map->esc_sym ^= idx1 ^ idx2;
1000     }
1001
1002     pos = get_bits_count(&ctx->gb);
1003
1004     for (t = 0; t < band->num_tiles; t++) {
1005         tile = &band->tiles[t];
1006
1007         if (tile->mb_size != band->mb_size) {
1008             av_log(avctx, AV_LOG_ERROR, "MB sizes mismatch: %d vs. %d\n",
1009                    band->mb_size, tile->mb_size);
1010             return AVERROR_INVALIDDATA;
1011         }
1012         tile->is_empty = get_bits1(&ctx->gb);
1013         if (tile->is_empty) {
1014             result = ivi_process_empty_tile(avctx, band, tile,
1015                                       (ctx->planes[0].bands[0].mb_size >> 3) - (band->mb_size >> 3));
1016             if (result < 0)
1017                 break;
1018             ff_dlog(avctx, "Empty tile encountered!\n");
1019         } else {
1020             tile->data_size = ivi_dec_tile_data_size(&ctx->gb);
1021             if (!tile->data_size) {
1022                 av_log(avctx, AV_LOG_ERROR, "Tile data size is zero!\n");
1023                 result = AVERROR_INVALIDDATA;
1024                 break;
1025             }
1026
1027             result = ctx->decode_mb_info(ctx, band, tile, avctx);
1028             if (result < 0)
1029                 break;
1030
1031             result = ivi_decode_blocks(&ctx->gb, band, tile, avctx);
1032             if (result < 0) {
1033                 av_log(avctx, AV_LOG_ERROR,
1034                        "Corrupted tile data encountered!\n");
1035                 break;
1036             }
1037
1038             if (((get_bits_count(&ctx->gb) - pos) >> 3) != tile->data_size) {
1039                 av_log(avctx, AV_LOG_ERROR,
1040                        "Tile data_size mismatch!\n");
1041                 result = AVERROR_INVALIDDATA;
1042                 break;
1043             }
1044
1045             pos += tile->data_size << 3; // skip to next tile
1046         }
1047     }
1048
1049     /* restore the selected rvmap table by applying its corrections in
1050      * reverse order */
1051     for (i = band->num_corr-1; i >= 0; i--) {
1052         idx1 = band->corr[i*2];
1053         idx2 = band->corr[i*2+1];
1054         FFSWAP(uint8_t, band->rv_map->runtab[idx1], band->rv_map->runtab[idx2]);
1055         FFSWAP(int16_t, band->rv_map->valtab[idx1], band->rv_map->valtab[idx2]);
1056         if (idx1 == band->rv_map->eob_sym || idx2 == band->rv_map->eob_sym)
1057             band->rv_map->eob_sym ^= idx1 ^ idx2;
1058         if (idx1 == band->rv_map->esc_sym || idx2 == band->rv_map->esc_sym)
1059             band->rv_map->esc_sym ^= idx1 ^ idx2;
1060     }
1061
1062 #ifdef DEBUG
1063     if (band->checksum_present) {
1064         uint16_t chksum = ivi_calc_band_checksum(band);
1065         if (chksum != band->checksum) {
1066             av_log(avctx, AV_LOG_ERROR,
1067                    "Band checksum mismatch! Plane %d, band %d, "
1068                    "received: %"PRIx32", calculated: %"PRIx16"\n",
1069                    band->plane, band->band_num, band->checksum, chksum);
1070         }
1071     }
1072 #endif
1073
1074     align_get_bits(&ctx->gb);
1075
1076     return result;
1077 }
1078
1079 int ff_ivi_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
1080                         AVPacket *avpkt)
1081 {
1082     IVI45DecContext *ctx = avctx->priv_data;
1083     const uint8_t   *buf = avpkt->data;
1084     AVFrame       *frame = data;
1085     int             buf_size = avpkt->size;
1086     int             result, p, b;
1087
1088     result = init_get_bits8(&ctx->gb, buf, buf_size);
1089     if (result < 0)
1090         return result;
1091     ctx->frame_data = buf;
1092     ctx->frame_size = buf_size;
1093
1094     result = ctx->decode_pic_hdr(ctx, avctx);
1095     if (result) {
1096         av_log(avctx, AV_LOG_ERROR,
1097                "Error while decoding picture header: %d\n", result);
1098         return result;
1099     }
1100     if (ctx->gop_invalid)
1101         return AVERROR_INVALIDDATA;
1102
1103     if (ctx->is_indeo4 && ctx->frame_type == IVI4_FRAMETYPE_NULL_LAST) {
1104         if (ctx->got_p_frame) {
1105             av_frame_move_ref(data, ctx->p_frame);
1106             *got_frame = 1;
1107             ctx->got_p_frame = 0;
1108         } else {
1109             *got_frame = 0;
1110         }
1111         return buf_size;
1112     }
1113
1114     if (ctx->gop_flags & IVI5_IS_PROTECTED) {
1115         avpriv_report_missing_feature(avctx, "Password-protected clip");
1116         return AVERROR_PATCHWELCOME;
1117     }
1118
1119     if (!ctx->planes[0].bands) {
1120         av_log(avctx, AV_LOG_ERROR, "Color planes not initialized yet\n");
1121         return AVERROR_INVALIDDATA;
1122     }
1123
1124     ctx->switch_buffers(ctx);
1125
1126     if (ctx->is_nonnull_frame(ctx)) {
1127         ctx->buf_invalid[ctx->dst_buf] = 1;
1128         for (p = 0; p < 3; p++) {
1129             for (b = 0; b < ctx->planes[p].num_bands; b++) {
1130                 result = decode_band(ctx, &ctx->planes[p].bands[b], avctx);
1131                 if (result < 0) {
1132                     av_log(avctx, AV_LOG_ERROR,
1133                            "Error while decoding band: %d, plane: %d\n", b, p);
1134                     return result;
1135                 }
1136             }
1137         }
1138         ctx->buf_invalid[ctx->dst_buf] = 0;
1139     } else {
1140         if (ctx->is_scalable)
1141             return AVERROR_INVALIDDATA;
1142
1143         for (p = 0; p < 3; p++) {
1144             if (!ctx->planes[p].bands[0].buf)
1145                 return AVERROR_INVALIDDATA;
1146         }
1147     }
1148     if (ctx->buf_invalid[ctx->dst_buf])
1149         return -1;
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(&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             ctx->got_p_frame = 0;
1196             av_frame_unref(ctx->p_frame);
1197             ff_ivi_decode_frame(avctx, ctx->p_frame, &ctx->got_p_frame, &pkt);
1198         }
1199     }
1200
1201     if (ctx->show_indeo4_info) {
1202         if (ctx->is_scalable)
1203             av_log(avctx, AV_LOG_DEBUG, "This video uses scalability mode\n");
1204         if (ctx->uses_tiling)
1205             av_log(avctx, AV_LOG_DEBUG, "This video uses local decoding\n");
1206         if (ctx->has_b_frames)
1207             av_log(avctx, AV_LOG_DEBUG, "This video contains B-frames\n");
1208         if (ctx->has_transp)
1209             av_log(avctx, AV_LOG_DEBUG, "Transparency mode is enabled\n");
1210         if (ctx->uses_haar)
1211             av_log(avctx, AV_LOG_DEBUG, "This video uses Haar transform\n");
1212         if (ctx->uses_fullpel)
1213             av_log(avctx, AV_LOG_DEBUG, "This video uses fullpel motion vectors\n");
1214         ctx->show_indeo4_info = 0;
1215     }
1216
1217     return buf_size;
1218 }
1219
1220 /**
1221  *  Close Indeo5 decoder and clean up its context.
1222  */
1223 av_cold int ff_ivi_decode_close(AVCodecContext *avctx)
1224 {
1225     IVI45DecContext *ctx = avctx->priv_data;
1226
1227     ivi_free_buffers(&ctx->planes[0]);
1228
1229     if (ctx->mb_vlc.cust_tab.table)
1230         ff_free_vlc(&ctx->mb_vlc.cust_tab);
1231
1232     if (ctx->blk_vlc.cust_tab.table)
1233         ff_free_vlc(&ctx->blk_vlc.cust_tab);
1234
1235     av_frame_free(&ctx->p_frame);
1236
1237     return 0;
1238 }
1239
1240
1241 /**
1242  *  Scan patterns shared between indeo4 and indeo5
1243  */
1244 const uint8_t ff_ivi_vertical_scan_8x8[64] = {
1245     0,  8, 16, 24, 32, 40, 48, 56,
1246     1,  9, 17, 25, 33, 41, 49, 57,
1247     2, 10, 18, 26, 34, 42, 50, 58,
1248     3, 11, 19, 27, 35, 43, 51, 59,
1249     4, 12, 20, 28, 36, 44, 52, 60,
1250     5, 13, 21, 29, 37, 45, 53, 61,
1251     6, 14, 22, 30, 38, 46, 54, 62,
1252     7, 15, 23, 31, 39, 47, 55, 63
1253 };
1254
1255 const uint8_t ff_ivi_horizontal_scan_8x8[64] = {
1256      0,  1,  2,  3,  4,  5,  6,  7,
1257      8,  9, 10, 11, 12, 13, 14, 15,
1258     16, 17, 18, 19, 20, 21, 22, 23,
1259     24, 25, 26, 27, 28, 29, 30, 31,
1260     32, 33, 34, 35, 36, 37, 38, 39,
1261     40, 41, 42, 43, 44, 45, 46, 47,
1262     48, 49, 50, 51, 52, 53, 54, 55,
1263     56, 57, 58, 59, 60, 61, 62, 63
1264 };
1265
1266 const uint8_t ff_ivi_direct_scan_4x4[16] = {
1267     0, 1, 4, 8, 5, 2, 3, 6, 9, 12, 13, 10, 7, 11, 14, 15
1268 };
1269
1270
1271 /**
1272  *  Run-value (RLE) tables.
1273  */
1274 const RVMapDesc ff_ivi_rvmap_tabs[9] = {
1275 {   /* MapTab0 */
1276     5, /* eob_sym */
1277     2, /* esc_sym */
1278     /* run table */
1279     {1,  1,  0,  1,  1,  0,  1,  1,  2,  2,  1,  1,  1,  1,  3,  3,
1280      1,  1,  2,  2,  1,  1,  4,  4,  1,  1,  1,  1,  2,  2,  5,  5,
1281      1,  1,  3,  3,  1,  1,  6,  6,  1,  2,  1,  2,  7,  7,  1,  1,
1282      8,  8,  1,  1,  4,  2,  1,  4,  2,  1,  3,  3,  1,  1,  1,  9,
1283      9,  1,  2,  1,  2,  1,  5,  5,  1,  1, 10, 10,  1,  1,  3,  3,
1284      2,  2,  1,  1, 11, 11,  6,  4,  4,  1,  6,  1,  2,  1,  2, 12,
1285      8,  1, 12,  7,  8,  7,  1, 16,  1, 16,  1,  3,  3, 13,  1, 13,
1286      2,  2,  1, 15,  1,  5, 14, 15,  1,  5, 14,  1, 17,  8, 17,  8,
1287      1,  4,  4,  2,  2,  1, 25, 25, 24, 24,  1,  3,  1,  3,  1,  8,
1288      6,  7,  6,  1, 18,  8, 18,  1,  7, 23,  2,  2, 23,  1,  1, 21,
1289     22,  9,  9, 22, 19,  1, 21,  5, 19,  5,  1, 33, 20, 33, 20,  8,
1290      4,  4,  1, 32,  2,  2,  8,  3, 32, 26,  3,  1,  7,  7, 26,  6,
1291      1,  6,  1,  1, 16,  1, 10,  1, 10,  2, 16, 29, 28,  2, 29, 28,
1292      1, 27,  5,  8,  5, 27,  1,  8,  3,  7,  3, 31, 41, 31,  1, 41,
1293      6,  1,  6,  7,  4,  4,  1,  1,  2,  1,  2, 11, 34, 30, 11,  1,
1294     30, 15, 15, 34, 36, 40, 36, 40, 35, 35, 37, 37, 39, 39, 38, 38},
1295
1296     /* value table */
1297     { 1,  -1,   0,   2,  -2,   0,   3,  -3,   1,  -1,   4,  -4,   5,  -5,   1,  -1,
1298       6,  -6,   2,  -2,   7,  -7,   1,  -1,   8,  -8,   9,  -9,   3,  -3,   1,  -1,
1299      10, -10,   2,  -2,  11, -11,   1,  -1,  12,   4, -12,  -4,   1,  -1,  13, -13,
1300       1,  -1,  14, -14,   2,   5,  15,  -2,  -5, -15,  -3,   3,  16, -16,  17,   1,
1301      -1, -17,   6,  18,  -6, -18,   2,  -2,  19, -19,   1,  -1,  20, -20,   4,  -4,
1302       7,  -7,  21, -21,   1,  -1,   2,   3,  -3,  22,  -2, -22,   8,  23,  -8,   1,
1303       2, -23,  -1,   2,  -2,  -2,  24,   1, -24,  -1,  25,   5,  -5,   1, -25,  -1,
1304       9,  -9,  26,   1, -26,   3,   1,  -1,  27,  -3,  -1, -27,   1,   3,  -1,  -3,
1305      28,  -4,   4,  10, -10, -28,   1,  -1,   1,  -1,  29,   6, -29,  -6,  30,  -4,
1306       3,   3,  -3, -30,   1,   4,  -1,  31,  -3,   1,  11, -11,  -1, -31,  32,  -1,
1307      -1,   2,  -2,   1,   1, -32,   1,   4,  -1,  -4,  33,  -1,   1,   1,  -1,   5,
1308       5,  -5, -33,  -1, -12,  12,  -5,  -7,   1,   1,   7,  34,   4,  -4,  -1,   4,
1309     -34,  -4,  35,  36,  -2, -35,  -2, -36,   2,  13,   2,  -1,   1, -13,   1,  -1,
1310      37,   1,  -5,   6,   5,  -1,  38,  -6,  -8,   5,   8,  -1,   1,   1, -37,  -1,
1311       5,  39,  -5,  -5,   6,  -6, -38, -39, -14,  40,  14,   2,   1,   1,  -2, -40,
1312      -1,  -2,   2,  -1,  -1,  -1,   1,   1,   1,  -1,   1,  -1,   1,  -1,   1,  -1}
1313 },{
1314     /* MapTab1 */
1315     0,  /* eob_sym */
1316     38, /* esc_sym */
1317     /* run table */
1318     {0,  1,  1,  2,  2,  3,  3,  4,  4,  5,  5,  6,  8,  6,  8,  7,
1319      7,  9,  9, 10, 10, 11, 11,  1, 12,  1, 12, 13, 13, 16, 14, 16,
1320     14, 15, 15, 17, 17, 18,  0, 18, 19, 20, 21, 19, 22, 21, 20, 22,
1321     25, 24,  2, 25, 24, 23, 23,  2, 26, 28, 26, 28, 29, 27, 29, 27,
1322     33, 33,  1, 32,  1,  3, 32, 30, 36,  3, 36, 30, 31, 31, 35, 34,
1323     37, 41, 34, 35, 37,  4, 41,  4, 49,  8,  8, 49, 40, 38,  5, 38,
1324     40, 39,  5, 39, 42, 43, 42,  7, 57,  6, 43, 44,  6, 50,  7, 44,
1325     57, 48, 50, 48, 45, 45, 46, 47, 51, 46, 47, 58,  1, 51, 58,  1,
1326     52, 59, 53,  9, 52, 55, 55, 59, 53, 56, 54, 56, 54,  9, 64, 64,
1327     60, 63, 60, 63, 61, 62, 61, 62,  2, 10,  2, 10, 11,  1, 11, 13,
1328     12,  1, 12, 13, 16, 16,  8,  8, 14,  3,  3, 15, 14, 15,  4,  4,
1329      1, 17, 17,  5,  1,  7,  7,  5,  6,  1,  2,  2,  6, 22,  1, 25,
1330     21, 22,  8, 24,  1, 21, 25, 24,  8, 18, 18, 23,  9, 20, 23, 33,
1331     29, 33, 20,  1, 19,  1, 29, 36,  9, 36, 19, 41, 28, 57, 32,  3,
1332     28,  3,  1, 27, 49, 49,  1, 32, 26, 26,  2,  4,  4,  7, 57, 41,
1333      2,  7, 10,  5, 37, 16, 10, 27,  8,  8, 13, 16, 37, 13,  1,  5},
1334
1335     /* value table */
1336     {0,   1,  -1,   1,  -1,   1,  -1,   1,  -1,   1,  -1,   1,   1,  -1,  -1,   1,
1337     -1,   1,  -1,   1,  -1,   1,  -1,   2,   1,  -2,  -1,   1,  -1,   1,   1,  -1,
1338     -1,   1,  -1,   1,  -1,   1,   0,  -1,   1,   1,   1,  -1,   1,  -1,  -1,  -1,
1339      1,   1,   2,  -1,  -1,   1,  -1,  -2,   1,   1,  -1,  -1,   1,   1,  -1,  -1,
1340      1,  -1,   3,   1,  -3,   2,  -1,   1,   1,  -2,  -1,  -1,  -1,   1,   1,   1,
1341      1,   1,  -1,  -1,  -1,   2,  -1,  -2,   1,   2,  -2,  -1,   1,   1,   2,  -1,
1342     -1,   1,  -2,  -1,   1,   1,  -1,   2,   1,   2,  -1,   1,  -2,  -1,  -2,  -1,
1343     -1,   1,   1,  -1,   1,  -1,   1,   1,   1,  -1,  -1,   1,   4,  -1,  -1,  -4,
1344      1,   1,   1,   2,  -1,  -1,   1,  -1,  -1,   1,  -1,  -1,   1,  -2,   1,  -1,
1345      1,   1,  -1,  -1,   1,   1,  -1,  -1,   3,   2,  -3,  -2,   2,   5,  -2,   2,
1346      2,  -5,  -2,  -2,  -2,   2,  -3,   3,   2,   3,  -3,   2,  -2,  -2,   3,  -3,
1347      6,   2,  -2,   3,  -6,   3,  -3,  -3,   3,   7,  -4,   4,  -3,   2,  -7,   2,
1348      2,  -2,  -4,   2,   8,  -2,  -2,  -2,   4,   2,  -2,   2,   3,   2,  -2,  -2,
1349      2,   2,  -2,  -8,  -2,   9,  -2,   2,  -3,  -2,   2,  -2,   2,   2,   2,   4,
1350     -2,  -4,  10,   2,   2,  -2,  -9,  -2,   2,  -2,   5,   4,  -4,   4,  -2,   2,
1351     -5,  -4,  -3,   4,   2,  -3,   3,  -2,  -5,   5,   3,   3,  -2,  -3, -10,  -4}
1352 },{
1353     /* MapTab2 */
1354     2,  /* eob_sym */
1355     11, /* esc_sym */
1356     /* run table */
1357     {1,  1,  0,  2,  2,  1,  1,  3,  3,  4,  4,  0,  1,  1,  5,  5,
1358      2,  2,  6,  6,  7,  7,  1,  8,  1,  8,  3,  3,  9,  9,  1,  2,
1359      2,  1,  4, 10,  4, 10, 11, 11,  1,  5, 12, 12,  1,  5, 13, 13,
1360      3,  3,  6,  6,  2,  2, 14, 14, 16, 16, 15,  7, 15,  8,  8,  7,
1361      1,  1, 17, 17,  4,  4,  1,  1, 18, 18,  2,  2,  5,  5, 25,  3,
1362      9,  3, 25,  9, 19, 24, 19, 24,  1, 21, 20,  1, 21, 22, 20, 22,
1363     23, 23,  8,  6, 33,  6,  8, 33,  7,  7, 26, 26,  1, 32,  1, 32,
1364     28,  4, 28, 10, 29, 27, 27, 10, 41,  4, 29,  2,  2, 41, 36, 31,
1365     49, 31, 34, 30, 34, 36, 30, 35,  1, 49, 11,  5, 35, 11,  1,  3,
1366      3,  5, 37, 37,  8, 40,  8, 40, 12, 12, 42, 42,  1, 38, 16, 57,
1367      1,  6, 16, 39, 38,  6,  7,  7, 13, 13, 39, 43,  2, 43, 57,  2,
1368     50,  9, 44,  9, 50,  4, 15, 48, 44,  4,  1, 15, 48, 14, 14,  1,
1369     45, 45,  8,  3,  5,  8, 51, 47,  3, 46, 46, 47,  5, 51,  1, 17,
1370     17, 58,  1, 58,  2, 52, 52,  2, 53,  7, 59,  6,  6, 56, 53, 55,
1371      7, 55,  1, 54, 59, 56, 54, 10,  1, 10,  4, 60,  1, 60,  8,  4,
1372      8, 64, 64, 61,  1, 63,  3, 63, 62, 61,  5, 11,  5,  3, 11, 62},
1373
1374     /* value table */
1375     { 1,  -1,   0,   1,  -1,   2,  -2,   1,  -1,   1,  -1,   0,   3,  -3,   1,  -1,
1376       2,  -2,   1,  -1,   1,  -1,   4,   1,  -4,  -1,   2,  -2,   1,  -1,   5,   3,
1377      -3,  -5,   2,   1,  -2,  -1,   1,  -1,   6,   2,   1,  -1,  -6,  -2,   1,  -1,
1378       3,  -3,   2,  -2,   4,  -4,   1,  -1,   1,  -1,   1,   2,  -1,   2,  -2,  -2,
1379       7,  -7,   1,  -1,   3,  -3,   8,  -8,   1,  -1,   5,  -5,   3,  -3,   1,   4,
1380       2,  -4,  -1,  -2,   1,   1,  -1,  -1,   9,   1,   1,  -9,  -1,   1,  -1,  -1,
1381       1,  -1,   3,  -3,   1,   3,  -3,  -1,   3,  -3,   1,  -1,  10,   1, -10,  -1,
1382       1,   4,  -1,   2,   1,  -1,   1,  -2,   1,  -4,  -1,   6,  -6,  -1,   1,   1,
1383       1,  -1,   1,   1,  -1,  -1,  -1,   1,  11,  -1,  -2,   4,  -1,   2, -11,   5,
1384      -5,  -4,  -1,   1,   4,   1,  -4,  -1,  -2,   2,   1,  -1,  12,   1,  -2,   1,
1385     -12,   4,   2,   1,  -1,  -4,   4,  -4,   2,  -2,  -1,   1,   7,  -1,  -1,  -7,
1386      -1,  -3,   1,   3,   1,   5,   2,   1,  -1,  -5,  13,  -2,  -1,   2,  -2, -13,
1387       1,  -1,   5,   6,   5,  -5,   1,   1,  -6,   1,  -1,  -1,  -5,  -1,  14,   2,
1388      -2,   1, -14,  -1,   8,   1,  -1,  -8,   1,   5,   1,   5,  -5,   1,  -1,   1,
1389      -5,  -1,  15,   1,  -1,  -1,  -1,   3, -15,  -3,   6,   1,  16,  -1,   6,  -6,
1390      -6,   1,  -1,   1, -16,   1,   7,  -1,   1,  -1,  -6,  -3,   6,  -7,   3,  -1}
1391 },{
1392     /* MapTab3 */
1393     0,  /* eob_sym */
1394     35, /* esc_sym */
1395     /* run table */
1396     {0,  1,  1,  2,  2,  3,  3,  4,  4,  1,  1,  5,  5,  6,  6,  7,
1397      7,  8,  8,  9,  9,  2,  2, 10, 10,  1,  1, 11, 11, 12, 12,  3,
1398      3, 13, 13,  0, 14, 14, 16, 15, 16, 15,  4,  4, 17,  1, 17,  1,
1399      5,  5, 18, 18,  2,  2,  6,  6,  8, 19,  7,  8,  7, 19, 20, 20,
1400     21, 21, 22, 24, 22, 24, 23, 23,  1,  1, 25, 25,  3,  3, 26, 26,
1401      9,  9, 27, 27, 28, 28, 33, 29,  4, 33, 29,  1,  4,  1, 32, 32,
1402      2,  2, 31, 10, 30, 10, 30, 31, 34, 34,  5,  5, 36, 36, 35, 41,
1403     35, 11, 41, 11, 37,  1,  8,  8, 37,  6,  1,  6, 40,  7,  7, 40,
1404     12, 38, 12, 39, 39, 38, 49, 13, 49, 13,  3, 42,  3, 42, 16, 16,
1405     43, 43, 14, 14,  1,  1, 44, 15, 44, 15,  2,  2, 57, 48, 50, 48,
1406     57, 50,  4, 45, 45,  4, 46, 47, 47, 46,  1, 51,  1, 17, 17, 51,
1407      8,  9,  9,  5, 58,  8, 58,  5, 52, 52, 55, 56, 53, 56, 55, 59,
1408     59, 53, 54,  1,  6, 54,  7,  7,  6,  1,  2,  3,  2,  3, 64, 60,
1409     60, 10, 10, 64, 61, 62, 61, 63,  1, 63, 62,  1, 18, 24, 18,  4,
1410     25,  4,  8, 21, 21,  1, 24, 22, 25, 22,  8, 11, 19, 11, 23,  1,
1411     20, 23, 19, 20,  5, 12,  5,  1, 16,  2, 12, 13,  2, 13,  1, 16},
1412
1413     /* value table */
1414     { 0,   1,  -1,   1,  -1,   1,  -1,   1,  -1,   2,  -2,   1,  -1,   1,  -1,   1,
1415      -1,   1,  -1,   1,  -1,   2,  -2,   1,  -1,   3,  -3,   1,  -1,   1,  -1,   2,
1416      -2,   1,  -1,   0,   1,  -1,   1,   1,  -1,  -1,   2,  -2,   1,   4,  -1,  -4,
1417       2,  -2,   1,  -1,  -3,   3,   2,  -2,   2,   1,   2,  -2,  -2,  -1,   1,  -1,
1418       1,  -1,   1,   1,  -1,  -1,   1,  -1,   5,  -5,   1,  -1,   3,  -3,   1,  -1,
1419       2,  -2,   1,  -1,   1,  -1,   1,   1,   3,  -1,  -1,   6,  -3,  -6,  -1,   1,
1420       4,  -4,   1,   2,   1,  -2,  -1,  -1,   1,  -1,   3,  -3,   1,  -1,   1,   1,
1421      -1,   2,  -1,  -2,   1,   7,  -3,   3,  -1,   3,  -7,  -3,   1,  -3,   3,  -1,
1422       2,   1,  -2,   1,  -1,  -1,   1,   2,  -1,  -2,  -4,  -1,   4,   1,   2,  -2,
1423       1,  -1,  -2,   2,   8,  -8,  -1,   2,   1,  -2,  -5,   5,   1,  -1,  -1,   1,
1424      -1,   1,   4,  -1,   1,  -4,  -1,  -1,   1,   1,   9,   1,  -9,   2,  -2,  -1,
1425      -4,   3,  -3,  -4,  -1,   4,   1,   4,   1,  -1,   1,  -1,   1,   1,  -1,   1,
1426      -1,  -1,  -1,  10,   4,   1,   4,  -4,  -4, -10,   6,   5,  -6,  -5,   1,  -1,
1427       1,   3,  -3,  -1,   1,  -1,  -1,  -1,  11,   1,   1, -11,  -2,  -2,   2,   5,
1428      -2,  -5,  -5,   2,  -2,  12,   2,  -2,   2,   2,   5,  -3,  -2,   3,  -2, -12,
1429      -2,   2,   2,   2,  -5,   3,   5,  13,  -3,   7,  -3,  -3,  -7,   3, -13,   3}
1430 },{
1431     /* MapTab4 */
1432     0,  /* eob_sym */
1433     34, /* esc_sym */
1434     /* run table */
1435     {0,  1,  1,  1,  2,  2,  1,  3,  3,  1,  1,  1,  4,  4,  1,  5,
1436      2,  1,  5,  2,  1,  1,  6,  6,  1,  1,  1,  1,  1,  7,  3,  1,
1437      2,  3,  0,  1,  2,  7,  1,  1,  1,  8,  1,  1,  8,  1,  1,  1,
1438      9,  1,  9,  1,  2,  1,  1,  2,  1,  1, 10,  4,  1, 10,  1,  4,
1439      1,  1,  1,  1,  1,  3,  1,  1,  1,  3,  2,  1,  5,  1,  1,  1,
1440      2,  5,  1, 11,  1, 11,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,
1441      2,  1,  6,  1,  6,  1,  1,  2,  1,  1,  1,  1,  1,  1,  1, 12,
1442      3,  1, 12,  1,  1,  1,  2,  1,  1,  3,  1,  1,  1,  1,  1,  1,
1443      4,  1,  1,  1,  2,  1,  1,  4,  1,  1,  1,  1,  1,  1,  2,  1,
1444      1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  3,  1,  2,  1,  1,  5,
1445      1,  1,  1,  1,  1,  7,  1,  7,  1,  1,  2,  3,  1,  1,  1,  1,
1446      5,  1,  1,  1,  1,  1,  1,  2, 13,  1,  1,  1,  1,  1,  1,  1,
1447      1,  1,  1,  1,  1,  1,  1,  1, 13,  2,  1,  1,  4,  1,  1,  1,
1448      3,  1,  6,  1,  1,  1, 14,  1,  1,  1,  1,  1, 14,  6,  1,  1,
1449      1,  1, 15,  2,  4,  1,  2,  3, 15,  1,  1,  1,  8,  1,  1,  8,
1450      1,  1,  1,  1,  1,  1,  1,  1,  2,  1,  1,  1,  1,  1,  1,  1},
1451
1452     /* value table */
1453     { 0,   1,  -1,   2,   1,  -1,  -2,   1,  -1,   3,  -3,   4,   1,  -1,  -4,   1,
1454       2,   5,  -1,  -2,  -5,   6,   1,  -1,  -6,   7,  -7,   8,  -8,   1,   2,   9,
1455       3,  -2,   0,  -9,  -3,  -1,  10, -10,  11,   1, -11,  12,  -1, -12,  13, -13,
1456       1,  14,  -1, -14,   4,  15, -15,  -4,  16, -16,   1,   2,  17,  -1, -17,  -2,
1457      18, -18,  19, -19,  20,   3, -20,  21, -21,  -3,   5,  22,   2, -22, -23,  23,
1458      -5,  -2,  24,   1, -24,  -1,  25, -25,  26, -26, -27,  27,  28,  29, -28, -29,
1459       6,  30,   2, -31,  -2, -30,  31,  -6, -32,  32,  33, -33,  34, -35, -34,   1,
1460       4, -36,  -1,  35,  37,  36,   7, -37,  38,  -4, -38,  39,  41,  40, -40, -39,
1461       3,  42, -43, -41,  -7, -42,  43,  -3,  44, -44,  45, -45,  46,  47,   8, -47,
1462     -48, -46,  50, -50,  48,  49,  51, -49,  52, -52,   5, -51,  -8, -53,  53,   3,
1463     -56,  56,  55,  54, -54,   2,  60,  -2, -55,  58,   9,  -5,  59,  57, -57, -63,
1464      -3, -58, -60, -61,  61, -59, -62,  -9,   1,  64,  62,  69, -64,  63,  65, -67,
1465     -68,  66, -65,  68, -66, -69,  67, -70,  -1,  10,  71, -71,   4,  73,  72,  70,
1466       6, -76,  -3,  74, -78, -74,   1,  78,  80, -72, -75,  76,  -1,   3, -73,  79,
1467      75,  77,   1,  11,  -4, -79, -10,  -6,  -1, -77, -83, -80,   2,  81, -84,  -2,
1468      83, -81,  82, -82,  84, -87, -86,  85, -11, -85,  86, -89,  87, -88,  88,  89}
1469 },{
1470     /* MapTab5 */
1471     2,  /* eob_sym */
1472     33, /* esc_sym */
1473     /* run table */
1474     {1,  1,  0,  2,  1,  2,  1,  3,  3,  1,  1,  4,  4,  2,  2,  1,
1475      1,  5,  5,  6,  1,  6,  1,  7,  7,  3,  3,  2,  8,  2,  8,  1,
1476      1,  0,  9,  9,  1,  1, 10,  4, 10,  4, 11, 11,  2,  1,  2,  1,
1477     12, 12,  3,  3,  1,  1, 13,  5,  5, 13, 14,  1,  1, 14,  2,  2,
1478      6,  6, 15,  1,  1, 15, 16,  4,  7, 16,  4,  7,  1,  1,  3,  3,
1479      8,  8,  2,  2,  1,  1, 17, 17,  1,  1, 18, 18,  5,  5,  2,  2,
1480      1,  1,  9, 19,  9, 19, 20,  3,  3, 20,  1, 10, 21,  1, 10,  4,
1481      4, 21, 22,  6,  6, 22,  1,  1, 23, 24,  2,  2, 23, 24, 11,  1,
1482      1, 11,  7, 25,  7,  1,  1, 25,  8,  8,  3, 26,  3,  1, 12,  2,
1483      2, 26,  1, 12,  5,  5, 27,  4,  1,  4,  1, 27, 28,  1, 28, 13,
1484      1, 13,  2, 29,  2,  1, 32,  6,  1, 30, 14, 29, 14,  6,  3, 31,
1485      3,  1, 30,  1, 32, 31, 33,  9, 33,  1,  1,  7,  9,  7,  2,  2,
1486      1,  1,  4, 36, 34,  4,  5, 10, 10,  5, 34,  1,  1, 35,  8,  8,
1487     36,  3, 35,  1, 15,  3,  2,  1, 16, 15, 16,  2, 37,  1, 37,  1,
1488      1,  1,  6,  6, 38,  1, 38, 11,  1, 39, 39, 40, 11,  2, 41,  4,
1489     40,  1,  2,  4,  1,  1,  1, 41,  3,  1,  3,  1,  5,  7,  5,  7},
1490
1491     /* value table */
1492     { 1,  -1,   0,   1,   2,  -1,  -2,   1,  -1,   3,  -3,   1,  -1,   2,  -2,   4,
1493      -4,   1,  -1,   1,   5,  -1,  -5,   1,  -1,   2,  -2,   3,   1,  -3,  -1,   6,
1494      -6,   0,   1,  -1,   7,  -7,   1,   2,  -1,  -2,   1,  -1,   4,   8,  -4,  -8,
1495       1,  -1,   3,  -3,   9,  -9,   1,   2,  -2,  -1,   1,  10, -10,  -1,   5,  -5,
1496       2,  -2,   1,  11, -11,  -1,   1,   3,   2,  -1,  -3,  -2,  12, -12,   4,  -4,
1497       2,  -2,  -6,   6,  13, -13,   1,  -1,  14, -14,   1,  -1,   3,  -3,   7,  -7,
1498      15, -15,   2,   1,  -2,  -1,   1,   5,  -5,  -1, -16,   2,   1,  16,  -2,   4,
1499      -4,  -1,   1,   3,  -3,  -1,  17, -17,   1,   1,  -8,   8,  -1,  -1,   2,  18,
1500     -18,  -2,   3,   1,  -3,  19, -19,  -1,   3,  -3,   6,   1,  -6,  20,   2,   9,
1501      -9,  -1, -20,  -2,   4,  -4,   1,  -5,  21,   5, -21,  -1,   1, -22,  -1,   2,
1502      22,  -2,  10,   1, -10,  23,   1,   4, -23,   1,   2,  -1,  -2,  -4,  -7,   1,
1503       7, -24,  -1,  24,  -1,  -1,   1,   3,  -1, -25,  25,   4,  -3,  -4,  11, -11,
1504      26, -26,   6,   1,   1,  -6,  -5,  -3,   3,   5,  -1, -27,  27,   1,   4,  -4,
1505      -1,  -8,  -1,  28,   2,   8, -12, -28,  -2,  -2,   2,  12,  -1,  29,   1, -29,
1506      30, -30,   5,  -5,   1, -31,  -1,   3,  31,  -1,   1,   1,  -3, -13,   1,  -7,
1507      -1, -32,  13,   7,  32,  33, -33,  -1,  -9, -34,   9,  34,  -6,   5,   6,  -5}
1508 },{
1509     /* MapTab6 */
1510     2,  /* eob_sym */
1511     13, /* esc_sym */
1512     /* run table */
1513     {1,  1,  0,  1,  1,  2,  2,  1,  1,  3,  3,  1,  1,  0,  2,  2,
1514      4,  1,  4,  1,  1,  1,  5,  5,  1,  1,  6,  6,  2,  2,  1,  1,
1515      3,  3,  7,  7,  1,  1,  8,  8,  1,  1,  2,  2,  1,  9,  1,  9,
1516      4,  4, 10,  1,  1, 10,  1,  1, 11, 11,  3,  3,  1,  2,  1,  2,
1517      1,  1, 12, 12,  5,  5,  1,  1, 13,  1,  1, 13,  2,  2,  1,  1,
1518      6,  6,  1,  1,  4, 14,  4, 14,  3,  1,  3,  1,  1,  1, 15,  7,
1519     15,  2,  2,  7,  1,  1,  1,  8,  1,  8, 16, 16,  1,  1,  1,  1,
1520      2,  1,  1,  2,  1,  1,  3,  5,  5,  3,  4,  1,  1,  4,  1,  1,
1521     17, 17,  9,  1,  1,  9,  2,  2,  1,  1, 10, 10,  1,  6,  1,  1,
1522      6, 18,  1,  1, 18,  1,  1,  1,  2,  2,  3,  1,  3,  1,  1,  1,
1523      4,  1, 19,  1, 19,  7,  1,  1, 20,  1,  4, 20,  1,  7, 11,  2,
1524      1, 11, 21,  2,  8,  5,  1,  8,  1,  5, 21,  1,  1,  1, 22,  1,
1525      1, 22,  1,  1,  3,  3,  1, 23,  2, 12, 24,  1,  1,  2,  1,  1,
1526     12, 23,  1,  1, 24,  1,  1,  1,  4,  1,  1,  1,  2,  1,  6,  6,
1527      4,  2,  1,  1,  1,  1,  1,  1,  1, 14, 13,  3,  1, 25,  9, 25,
1528     14,  1,  9,  3, 13,  1,  1,  1,  1,  1, 10,  1,  1,  2, 10,  2},
1529
1530     /* value table */
1531     {-20,  -1,   0,   2,  -2,   1,  -1,   3,  -3,   1,  -1,   4,  -4,   0,   2,  -2,
1532        1,   5,  -1,  -5,   6,  -6,   1,  -1,   7,  -7,   1,  -1,   3,  -3,   8,  -8,
1533        2,  -2,   1,  -1,   9,  -9,   1,  -1,  10, -10,   4,  -4,  11,   1, -11,  -1,
1534        2,  -2,   1,  12, -12,  -1,  13, -13,   1,  -1,   3,  -3,  14,   5, -14,  -5,
1535      -15,  15,  -1,   1,   2,  -2,  16, -16,   1,  17, -17,  -1,   6,  -6,  18, -18,
1536        2,  -2, -19,  19,  -3,   1,   3,  -1,   4,  20,  -4,   1, -21,  21,   1,   2,
1537       -1,  -7,   7,  -2,  22, -22,  23,   2, -23,  -2,   1,  -1, -24,  24, -25,  25,
1538       -8, -26,  26,   8, -27,  27,   5,   3,  -3,  -5,  -4,  28, -28,   4,  29, -29,
1539        1,  -1,  -2, -30,  30,   2,   9,  -9, -31,  31,   2,  -2, -32,   3,  32, -33,
1540       -3,   1,  33, -34,  -1,  34, -35,  35, -10,  10,  -6,  36,   6, -36,  37, -37,
1541       -5,  38,   1, -38,  -1,   3,  39, -39,  -1,  40,   5,   1, -40,  -3,   2, -11,
1542      -41,  -2,   1,  11,  -3,  -4,  41,   3,  42,   4,  -1, -43, -42,  43,   1, -44,
1543       45,  -1,  44, -45,  -7,   7, -46,   1, -12,   2,   1, -47,  46,  12,  47,  48,
1544       -2,  -1, -48,  49,  -1, -50, -49,  50,  -6, -51,  51,  52, -13,  53,  -4,   4,
1545        6,  13, -53, -52, -54,  55,  54, -55, -56,  -2,   2,  -8,  56,   1,  -3,  -1,
1546        2,  58,   3,   8,  -2,  57, -58, -60, -59, -57,  -3,  60,  59, -14,   3,  14}
1547 },{
1548     /* MapTab7 */
1549     2,  /* eob_sym */
1550     38, /* esc_sym */
1551     /* run table */
1552     {1,  1,  0,  2,  2,  1,  1,  3,  3,  4,  4,  5,  5,  1,  1,  6,
1553      6,  2,  2,  7,  7,  8,  8,  1,  1,  3,  3,  9,  9, 10, 10,  1,
1554      1,  2,  2,  4,  4, 11,  0, 11, 12, 12, 13, 13,  1,  1,  5,  5,
1555     14, 14, 15, 16, 15, 16,  3,  3,  1,  6,  1,  6,  2,  2,  7,  7,
1556      8,  8, 17, 17,  1,  1,  4,  4, 18, 18,  2,  2,  1, 19,  1, 20,
1557     19, 20, 21, 21,  3,  3, 22, 22,  5,  5, 24,  1,  1, 23,  9, 23,
1558     24,  9,  2,  2, 10,  1,  1, 10,  6,  6, 25,  4,  4, 25,  7,  7,
1559     26,  8,  1,  8,  3,  1, 26,  3, 11, 11, 27, 27,  2, 28,  1,  2,
1560     28,  1, 12, 12,  5,  5, 29, 13, 13, 29, 32,  1,  1, 33, 31, 30,
1561     32,  4, 30, 33,  4, 31,  3, 14,  1,  1,  3, 34, 34,  2,  2, 14,
1562      6,  6, 35, 36, 35, 36,  1, 15,  1, 16, 16, 15,  7,  9,  7,  9,
1563     37,  8,  8, 37,  1,  1, 39,  2, 38, 39,  2, 40,  5, 38, 40,  5,
1564      3,  3,  4,  4, 10, 10,  1,  1,  1,  1, 41,  2, 41,  2,  6,  6,
1565      1,  1, 11, 42, 11, 43,  3, 42,  3, 17,  4, 43,  1, 17,  7,  1,
1566      8, 44,  4,  7, 44,  5,  8,  2,  5,  1,  2, 48, 45,  1, 12, 45,
1567     12, 48, 13, 13,  1,  9,  9, 46,  1, 46, 47, 47, 49, 18, 18, 49},
1568
1569     /* value table */
1570     { 1,  -1,   0,   1,  -1,   2,  -2,   1,  -1,   1,  -1,   1,  -1,   3,  -3,   1,
1571      -1,  -2,   2,   1,  -1,   1,  -1,   4,  -4,  -2,   2,   1,  -1,   1,  -1,   5,
1572      -5,  -3,   3,   2,  -2,   1,   0,  -1,   1,  -1,   1,  -1,   6,  -6,   2,  -2,
1573       1,  -1,   1,   1,  -1,  -1,  -3,   3,   7,   2,  -7,  -2,  -4,   4,   2,  -2,
1574       2,  -2,   1,  -1,   8,  -8,   3,  -3,   1,  -1,  -5,   5,   9,   1,  -9,   1,
1575      -1,  -1,   1,  -1,  -4,   4,   1,  -1,   3,  -3,   1, -10,  10,   1,   2,  -1,
1576      -1,  -2,   6,  -6,   2,  11, -11,  -2,   3,  -3,   1,  -4,   4,  -1,   3,  -3,
1577       1,   3,  12,  -3,  -5, -12,  -1,   5,   2,  -2,   1,  -1,  -7,   1,  13,   7,
1578      -1, -13,   2,  -2,   4,  -4,   1,   2,  -2,  -1,   1,  14, -14,   1,   1,   1,
1579      -1,  -5,  -1,  -1,   5,  -1,  -6,   2, -15,  15,   6,   1,  -1,  -8,   8,  -2,
1580      -4,   4,   1,   1,  -1,  -1,  16,   2, -16,  -2,   2,  -2,   4,   3,  -4,  -3,
1581      -1,  -4,   4,   1, -17,  17,  -1,  -9,   1,   1,   9,   1,  -5,  -1,  -1,   5,
1582      -7,   7,   6,  -6,   3,  -3,  18, -18,  19, -19,   1, -10,  -1,  10,  -5,   5,
1583      20, -20,  -3,   1,   3,   1,   8,  -1,  -8,   2,   7,  -1, -21,  -2,   5,  21,
1584       5,  -1,  -7,  -5,   1,  -6,  -5, -11,   6,  22,  11,   1,   1, -22,  -3,  -1,
1585       3,  -1,   3,  -3, -23,   4,  -4,   1,  23,  -1,   1,  -1,   1,  -2,   2,  -1}
1586 },{
1587     /* MapTab8 */
1588     4,  /* eob_sym */
1589     11, /* esc_sym */
1590     /* run table */
1591     {1,  1,  1,  1,  0,  2,  2,  1,  1,  3,  3,  0,  1,  1,  2,  2,
1592      4,  4,  1,  1,  5,  5,  1,  1,  2,  2,  3,  3,  6,  6,  1,  1,
1593      7,  7,  8,  1,  8,  2,  2,  1,  4,  4,  1,  3,  1,  3,  9,  9,
1594      2,  2,  1,  5,  1,  5, 10, 10,  1,  1, 11, 11,  3,  6,  3,  4,
1595      4,  6,  2,  2,  1, 12,  1, 12,  7, 13,  7, 13,  1,  1,  8,  8,
1596      2,  2, 14, 14, 16, 15, 16,  5,  5,  1,  3, 15,  1,  3,  4,  4,
1597      1,  1, 17, 17,  2,  2,  6,  6,  1, 18,  1, 18, 22, 21, 22, 21,
1598     25, 24, 25, 19,  9, 20,  9, 23, 19, 24, 20,  3, 23,  7,  3,  1,
1599      1,  7, 28, 26, 29,  5, 28, 26,  5,  8, 29,  4,  8, 27,  2,  2,
1600      4, 27,  1,  1, 10, 36, 10, 33, 33, 36, 30,  1, 32, 32,  1, 30,
1601      6, 31, 31, 35,  3,  6, 11, 11,  3,  2, 35,  2, 34,  1, 34,  1,
1602     37, 37, 12,  7, 12,  5, 41,  5,  4,  7,  1,  8, 13,  4,  1, 41,
1603     13, 38,  8, 38,  9,  1, 40, 40,  9,  1, 39,  2,  2, 49, 39, 42,
1604      3,  3, 14, 16, 49, 14, 16, 42, 43, 43,  6,  6, 15,  1,  1, 15,
1605     44, 44,  1,  1, 50, 48,  4,  5,  4,  7,  5,  2, 10, 10, 48,  7,
1606     50, 45,  2,  1, 45,  8,  8,  1, 46, 46,  3, 47, 47,  3,  1,  1},
1607
1608     /* value table */
1609     { 1,  -1,   2,  -2,   0,   1,  -1,   3,  -3,   1,  -1,   0,   4,  -4,   2,  -2,
1610       1,  -1,   5,  -5,   1,  -1,   6,  -6,   3,  -3,   2,  -2,   1,  -1,   7,  -7,
1611       1,  -1,   1,   8,  -1,   4,  -4,  -8,   2,  -2,   9,   3,  -9,  -3,   1,  -1,
1612       5,  -5,  10,   2, -10,  -2,   1,  -1,  11, -11,   1,  -1,  -4,   2,   4,   3,
1613      -3,  -2,   6,  -6,  12,   1, -12,  -1,   2,   1,  -2,  -1,  13, -13,   2,  -2,
1614       7,  -7,   1,  -1,   1,   1,  -1,   3,  -3,  14,   5,  -1, -14,  -5,   4,  -4,
1615      15, -15,   1,  -1,   8,  -8,  -3,   3,  16,   1, -16,  -1,   1,   1,  -1,  -1,
1616       1,   1,  -1,   1,   2,   1,  -2,   1,  -1,  -1,  -1,   6,  -1,   3,  -6,  17,
1617     -17,  -3,   1,   1,   1,   4,  -1,  -1,  -4,   3,  -1,   5,  -3,  -1,  -9,   9,
1618      -5,   1,  18, -18,   2,   1,  -2,   1,  -1,  -1,   1,  19,  -1,   1, -19,  -1,
1619       4,   1,  -1,   1,   7,  -4,  -2,   2,  -7,  10,  -1, -10,   1,  20,  -1, -20,
1620       1,  -1,   2,   4,  -2,   5,   1,  -5,   6,  -4,  21,   4,   2,  -6, -21,  -1,
1621      -2,   1,  -4,  -1,  -3,  22,  -1,   1,   3, -22,  -1,  11, -11,   1,   1,   1,
1622       8,  -8,   2,   2,  -1,  -2,  -2,  -1,   1,  -1,  -5,   5,   2,  23, -23,  -2,
1623       1,  -1,  24, -24,  -1,  -1,   7,   6,  -7,   5,  -6,  12,  -3,   3,   1,  -5,
1624       1,   1, -12,  25,  -1,  -5,   5, -25,  -1,   1,   9,   1,  -1,  -9,  26, -26}
1625 }
1626 };