git.sesse.net Git - ffmpeg/blob - libavcodec/ivi.c

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