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