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