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