falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
101359 Commits
32 Branches
703MB
Tree: ee50f72715
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'ee50f72715'
${ noResults }
FFmpeg/libavcodec/ivi.c

1614 lines
66KB
Raw Blame History 

  1. /*

  2.  * common functions for Indeo Video Interactive codecs (Indeo4 and Indeo5)

  3.  *

  4.  * Copyright (c) 2009 Maxim Poliakovski

  5.  *

  6.  * This file is part of FFmpeg.

  7.  *

  8.  * FFmpeg is free software; you can redistribute it and/or

  9.  * modify it under the terms of the GNU Lesser General Public

  10.  * License as published by the Free Software Foundation; either

  11.  * version 2.1 of the License, or (at your option) any later version.

  12.  *

  13.  * FFmpeg is distributed in the hope that it will be useful,

  14.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  15.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

  16.  * Lesser General Public License for more details.

  17.  *

  18.  * You should have received a copy of the GNU Lesser General Public

  19.  * License along with FFmpeg; if not, write to the Free Software

  20.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

  21.  */

  22. 

  23. /**

  24.  * @file

  25.  * This file contains functions and data shared by both Indeo4 and

  26.  * Indeo5 decoders.

  27.  */

  28. 

  29. #include <inttypes.h>

  30. 

  31. #include "libavutil/attributes.h"

  32. #include "libavutil/imgutils.h"

  33. #include "libavutil/thread.h"

  34. 

  35. #define BITSTREAM_READER_LE

  36. #include "avcodec.h"

  37. #include "get_bits.h"

  38. #include "internal.h"

  39. #include "ivi.h"

  40. #include "ivi_dsp.h"

  41. 

  42. /**

  43.  * These are 2x8 predefined Huffman codebooks for coding macroblock/block

  44.  * signals. They are specified using "huffman descriptors" in order to

  45.  * avoid huge static tables. The decoding tables will be generated at

  46.  * startup from these descriptors.

  47.  */

  48. /** static macroblock huffman tables */

  49. static const IVIHuffDesc ivi_mb_huff_desc[8] = {

  50.     {8,  {0, 4, 5, 4, 4, 4, 6, 6}},

  51.     {12, {0, 2, 2, 3, 3, 3, 3, 5, 3, 2, 2, 2}},

  52.     {12, {0, 2, 3, 4, 3, 3, 3, 3, 4, 3, 2, 2}},

  53.     {12, {0, 3, 4, 4, 3, 3, 3, 3, 3, 2, 2, 2}},

  54.     {13, {0, 4, 4, 3, 3, 3, 3, 2, 3, 3, 2, 1, 1}},

  55.     {9,  {0, 4, 4, 4, 4, 3, 3, 3, 2}},

  56.     {10, {0, 4, 4, 4, 4, 3, 3, 2, 2, 2}},

  57.     {12, {0, 4, 4, 4, 3, 3, 2, 3, 2, 2, 2, 2}}

  58. };

  59. 

  60. /** static block huffman tables */

  61. static const IVIHuffDesc ivi_blk_huff_desc[8] = {

  62.     {10, {1, 2, 3, 4, 4, 7, 5, 5, 4, 1}},

  63.     {11, {2, 3, 4, 4, 4, 7, 5, 4, 3, 3, 2}},

  64.     {12, {2, 4, 5, 5, 5, 5, 6, 4, 4, 3, 1, 1}},

  65.     {13, {3, 3, 4, 4, 5, 6, 6, 4, 4, 3, 2, 1, 1}},

  66.     {11, {3, 4, 4, 5, 5, 5, 6, 5, 4, 2, 2}},

  67.     {13, {3, 4, 5, 5, 5, 5, 6, 4, 3, 3, 2, 1, 1}},

  68.     {13, {3, 4, 5, 5, 5, 6, 5, 4, 3, 3, 2, 1, 1}},

  69.     {9,  {3, 4, 4, 5, 5, 5, 6, 5, 5}}

  70. };

  71. 

  72. static VLC ivi_mb_vlc_tabs [8]; ///< static macroblock Huffman tables

  73. static VLC ivi_blk_vlc_tabs[8]; ///< static block Huffman tables

  74. 

  75. typedef void (*ivi_mc_func) (int16_t *buf, const int16_t *ref_buf,

  76.                              ptrdiff_t pitch, int mc_type);

  77. typedef void (*ivi_mc_avg_func) (int16_t *buf, const int16_t *ref_buf1,

  78.                                  const int16_t *ref_buf2,

  79.                                  ptrdiff_t pitch, int mc_type, int mc_type2);

  80. 

  81. static int ivi_mc(const IVIBandDesc *band, ivi_mc_func mc, ivi_mc_avg_func mc_avg,

  82.                   int offs, int mv_x, int mv_y, int mv_x2, int mv_y2,

  83.                   int mc_type, int mc_type2)

  84. {

  85.     int ref_offs = offs + mv_y * band->pitch + mv_x;

  86.     int buf_size = band->pitch * band->aheight;

  87.     int min_size = band->pitch * (band->blk_size - 1) + band->blk_size;

  88.     int ref_size = (mc_type > 1) * band->pitch + (mc_type & 1);

  89. 

  90.     if (mc_type != -1) {

  91.         av_assert0(offs >= 0 && ref_offs >= 0 && band->ref_buf);

  92.         av_assert0(buf_size - min_size >= offs);

  93.         av_assert0(buf_size - min_size - ref_size >= ref_offs);

  94.     }

  95. 

  96.     if (mc_type2 == -1) {

  97.         mc(band->buf + offs, band->ref_buf + ref_offs, band->pitch, mc_type);

  98.     } else {

  99.         int ref_offs2 = offs + mv_y2 * band->pitch + mv_x2;

  100.         int ref_size2 = (mc_type2 > 1) * band->pitch + (mc_type2 & 1);

  101.         if (offs < 0 || ref_offs2 < 0 || !band->b_ref_buf)

  102.             return AVERROR_INVALIDDATA;

  103.         if (buf_size - min_size - ref_size2 < ref_offs2)

  104.             return AVERROR_INVALIDDATA;

  105. 

  106.         if (mc_type == -1)

  107.             mc(band->buf + offs, band->b_ref_buf + ref_offs2,

  108.                band->pitch, mc_type2);

  109.         else

  110.             mc_avg(band->buf + offs, band->ref_buf + ref_offs,

  111.                    band->b_ref_buf + ref_offs2, band->pitch,

  112.                    mc_type, mc_type2);

  113.     }

  114. 

  115.     return 0;

  116. }

  117. 

  118. /*

  119.  *  Generate a huffman codebook from the given descriptor

  120.  *  and convert it into the FFmpeg VLC table.

  121.  *

  122.  *  @param[in]   cb    pointer to codebook descriptor

  123.  *  @param[out]  vlc   where to place the generated VLC table

  124.  *  @param[in]   flag  flag: 1 - for static or 0 for dynamic tables

  125.  *  @return     result code: 0 - OK, -1 = error (invalid codebook descriptor)

  126.  */

  127. static int ivi_create_huff_from_desc(const IVIHuffDesc *cb, VLC *vlc, int flag)

  128. {

  129.     int         pos, i, j, codes_per_row, prefix, not_last_row;

  130.     uint16_t    codewords[256]; /* FIXME: move this temporal storage out? */

  131.     uint8_t     bits[256];

  132. 

  133.     pos = 0; /* current position = 0 */

  134. 

  135.     for (i = 0; i < cb->num_rows; i++) {

  136.         codes_per_row = 1 << cb->xbits[i];

  137.         not_last_row  = (i != cb->num_rows - 1);

  138.         prefix        = ((1 << i) - 1) << (cb->xbits[i] + not_last_row);

  139. 

  140.         for (j = 0; j < codes_per_row; j++) {

  141.             if (pos >= 256) /* Some Indeo5 codebooks can have more than 256 */

  142.                 break;      /* elements, but only 256 codes are allowed! */

  143. 

  144.             bits[pos] = i + cb->xbits[i] + not_last_row;

  145.             if (bits[pos] > IVI_VLC_BITS)

  146.                 return AVERROR_INVALIDDATA; /* invalid descriptor */

  147. 

  148.             codewords[pos] = prefix | j;

  149.             if (!bits[pos])

  150.                 bits[pos] = 1;

  151. 

  152.             pos++;

  153.         }//for j

  154.     }//for i

  155. 

  156.     /* number of codewords = pos */

  157.     return init_vlc(vlc, IVI_VLC_BITS, pos, bits, 1, 1, codewords, 2, 2,

  158.                     (flag ? INIT_VLC_USE_NEW_STATIC : 0) | INIT_VLC_OUTPUT_LE);

  159. }

  160. 

  161. static av_cold void ivi_init_static_vlc(void)

  162. {

  163.     int i;

  164.     static VLC_TYPE table_data[8192 * 16][2];

  165. 

  166.     for (i = 0; i < 8; i++) {

  167.         ivi_mb_vlc_tabs[i].table = table_data + i * 2 * 8192;

  168.         ivi_mb_vlc_tabs[i].table_allocated = 8192;

  169.         ivi_create_huff_from_desc(&ivi_mb_huff_desc[i],

  170.                                   &ivi_mb_vlc_tabs[i], 1);

  171.         ivi_blk_vlc_tabs[i].table = table_data + (i * 2 + 1) * 8192;

  172.         ivi_blk_vlc_tabs[i].table_allocated = 8192;

  173.         ivi_create_huff_from_desc(&ivi_blk_huff_desc[i],

  174.                                   &ivi_blk_vlc_tabs[i], 1);

  175.     }

  176. }

  177. 

  178. av_cold void ff_ivi_init_static_vlc(void)

  179. {

  180.     static AVOnce init_static_once = AV_ONCE_INIT;

  181.     ff_thread_once(&init_static_once, ivi_init_static_vlc);

  182. }

  183. 

  184. /*

  185.  *  Copy huffman codebook descriptors.

  186.  *

  187.  *  @param[out]  dst  ptr to the destination descriptor

  188.  *  @param[in]   src  ptr to the source descriptor

  189.  */

  190. static void ivi_huff_desc_copy(IVIHuffDesc *dst, const IVIHuffDesc *src)

  191. {

  192.     dst->num_rows = src->num_rows;

  193.     memcpy(dst->xbits, src->xbits, src->num_rows);

  194. }

  195. 

  196. /*

  197.  *  Compare two huffman codebook descriptors.

  198.  *

  199.  *  @param[in]  desc1  ptr to the 1st descriptor to compare

  200.  *  @param[in]  desc2  ptr to the 2nd descriptor to compare

  201.  *  @return         comparison result: 0 - equal, 1 - not equal

  202.  */

  203. static int ivi_huff_desc_cmp(const IVIHuffDesc *desc1,

  204.                              const IVIHuffDesc *desc2)

  205. {

  206.     return desc1->num_rows != desc2->num_rows ||

  207.            memcmp(desc1->xbits, desc2->xbits, desc1->num_rows);

  208. }

  209. 

  210. int ff_ivi_dec_huff_desc(GetBitContext *gb, int desc_coded, int which_tab,

  211.                          IVIHuffTab *huff_tab, AVCodecContext *avctx)

  212. {

  213.     int i, result;

  214.     IVIHuffDesc new_huff;

  215. 

  216.     if (!desc_coded) {

  217.         /* select default table */

  218.         huff_tab->tab = (which_tab) ? &ivi_blk_vlc_tabs[7]

  219.                                     : &ivi_mb_vlc_tabs [7];

  220.         return 0;

  221.     }

  222. 

  223.     huff_tab->tab_sel = get_bits(gb, 3);

  224.     if (huff_tab->tab_sel == 7) {

  225.         /* custom huffman table (explicitly encoded) */

  226.         new_huff.num_rows = get_bits(gb, 4);

  227.         if (!new_huff.num_rows) {

  228.             av_log(avctx, AV_LOG_ERROR, "Empty custom Huffman table!\n");

  229.             return AVERROR_INVALIDDATA;

  230.         }

  231. 

  232.         for (i = 0; i < new_huff.num_rows; i++)

  233.             new_huff.xbits[i] = get_bits(gb, 4);

  234. 

  235.         /* Have we got the same custom table? Rebuild if not. */

  236.         if (ivi_huff_desc_cmp(&new_huff, &huff_tab->cust_desc) || !huff_tab->cust_tab.table) {

  237.             ivi_huff_desc_copy(&huff_tab->cust_desc, &new_huff);

  238. 

  239.             if (huff_tab->cust_tab.table)

  240.                 ff_free_vlc(&huff_tab->cust_tab);

  241.             result = ivi_create_huff_from_desc(&huff_tab->cust_desc,

  242.                     &huff_tab->cust_tab, 0);

  243.             if (result) {

  244.                 // reset faulty description

  245.                 huff_tab->cust_desc.num_rows = 0;

  246.                 av_log(avctx, AV_LOG_ERROR,

  247.                        "Error while initializing custom vlc table!\n");

  248.                 return result;

  249.             }

  250.         }

  251.         huff_tab->tab = &huff_tab->cust_tab;

  252.     } else {

  253.         /* select one of predefined tables */

  254.         huff_tab->tab = (which_tab) ? &ivi_blk_vlc_tabs[huff_tab->tab_sel]

  255.             : &ivi_mb_vlc_tabs [huff_tab->tab_sel];

  256.     }

  257. 

  258.     return 0;

  259. }

  260. 

  261. /*

  262.  *  Free planes, bands and macroblocks buffers.

  263.  *

  264.  *  @param[in]  planes  pointer to the array of the plane descriptors

  265.  */

  266. static av_cold void ivi_free_buffers(IVIPlaneDesc *planes)

  267. {

  268.     int p, b, t;

  269. 

  270.     for (p = 0; p < 3; p++) {

  271.         if (planes[p].bands)

  272.         for (b = 0; b < planes[p].num_bands; b++) {

  273.             av_freep(&planes[p].bands[b].bufs[0]);

  274.             av_freep(&planes[p].bands[b].bufs[1]);

  275.             av_freep(&planes[p].bands[b].bufs[2]);

  276.             av_freep(&planes[p].bands[b].bufs[3]);

  277. 

  278.             if (planes[p].bands[b].blk_vlc.cust_tab.table)

  279.                 ff_free_vlc(&planes[p].bands[b].blk_vlc.cust_tab);

  280.             for (t = 0; t < planes[p].bands[b].num_tiles; t++)

  281.                 av_freep(&planes[p].bands[b].tiles[t].mbs);

  282.             av_freep(&planes[p].bands[b].tiles);

  283.         }

  284.         av_freep(&planes[p].bands);

  285.         planes[p].num_bands = 0;

  286.     }

  287. }

  288. 

  289. av_cold int ff_ivi_init_planes(AVCodecContext *avctx, IVIPlaneDesc *planes, const IVIPicConfig *cfg,

  290.                                int is_indeo4)

  291. {

  292.     int p, b;

  293.     uint32_t b_width, b_height, align_fac, width_aligned,

  294.              height_aligned, buf_size;

  295.     IVIBandDesc *band;

  296. 

  297.     ivi_free_buffers(planes);

  298. 

  299.     if (av_image_check_size2(cfg->pic_width, cfg->pic_height, avctx->max_pixels, AV_PIX_FMT_YUV410P, 0, avctx) < 0 ||

  300.         cfg->luma_bands < 1 || cfg->chroma_bands < 1)

  301.         return AVERROR_INVALIDDATA;

  302. 

  303.     /* fill in the descriptor of the luminance plane */

  304.     planes[0].width     = cfg->pic_width;

  305.     planes[0].height    = cfg->pic_height;

  306.     planes[0].num_bands = cfg->luma_bands;

  307. 

  308.     /* fill in the descriptors of the chrominance planes */

  309.     planes[1].width     = planes[2].width     = (cfg->pic_width  + 3) >> 2;

  310.     planes[1].height    = planes[2].height    = (cfg->pic_height + 3) >> 2;

  311.     planes[1].num_bands = planes[2].num_bands = cfg->chroma_bands;

  312. 

  313.     for (p = 0; p < 3; p++) {

  314.         planes[p].bands = av_mallocz_array(planes[p].num_bands, sizeof(IVIBandDesc));

  315.         if (!planes[p].bands)

  316.             return AVERROR(ENOMEM);

  317. 

  318.         /* select band dimensions: if there is only one band then it

  319.          *  has the full size, if there are several bands each of them

  320.          *  has only half size */

  321.         b_width  = planes[p].num_bands == 1 ? planes[p].width

  322.                                             : (planes[p].width  + 1) >> 1;

  323.         b_height = planes[p].num_bands == 1 ? planes[p].height

  324.                                             : (planes[p].height + 1) >> 1;

  325. 

  326.         /* luma   band buffers will be aligned on 16x16 (max macroblock size) */

  327.         /* chroma band buffers will be aligned on   8x8 (max macroblock size) */

  328.         align_fac       = p ? 8 : 16;

  329.         width_aligned   = FFALIGN(b_width , align_fac);

  330.         height_aligned  = FFALIGN(b_height, align_fac);

  331.         buf_size        = width_aligned * height_aligned * sizeof(int16_t);

  332. 

  333.         for (b = 0; b < planes[p].num_bands; b++) {

  334.             band = &planes[p].bands[b]; /* select appropriate plane/band */

  335.             band->plane    = p;

  336.             band->band_num = b;

  337.             band->width    = b_width;

  338.             band->height   = b_height;

  339.             band->pitch    = width_aligned;

  340.             band->aheight  = height_aligned;

  341.             av_assert0(!band->bufs[0] && !band->bufs[1] &&

  342.                        !band->bufs[2] && !band->bufs[3]);

  343.             band->bufsize  = buf_size/2;

  344.             av_assert0(buf_size % 2 == 0);

  345. 

  346.             /* reset custom vlc */

  347.             planes[p].bands[0].blk_vlc.cust_desc.num_rows = 0;

  348.         }

  349.     }

  350. 

  351.     return 0;

  352. }

  353. 

  354. static int ivi_init_tiles(const IVIBandDesc *band, IVITile *ref_tile,

  355.                           int p, int b, int t_height, int t_width)

  356. {

  357.     int x, y;

  358.     IVITile *tile = band->tiles;

  359. 

  360.     for (y = 0; y < band->height; y += t_height) {

  361.         for (x = 0; x < band->width; x += t_width) {

  362.             tile->xpos     = x;

  363.             tile->ypos     = y;

  364.             tile->mb_size  = band->mb_size;

  365.             tile->width    = FFMIN(band->width - x,  t_width);

  366.             tile->height   = FFMIN(band->height - y, t_height);

  367.             tile->is_empty = tile->data_size = 0;

  368.             /* calculate number of macroblocks */

  369.             tile->num_MBs  = IVI_MBs_PER_TILE(tile->width, tile->height,

  370.                                               band->mb_size);

  371. 

  372.             av_freep(&tile->mbs);

  373.             tile->mbs = av_mallocz_array(tile->num_MBs, sizeof(IVIMbInfo));

  374.             if (!tile->mbs)

  375.                 return AVERROR(ENOMEM);

  376. 

  377.             tile->ref_mbs = 0;

  378.             if (p || b) {

  379.                 if (tile->num_MBs != ref_tile->num_MBs) {

  380.                     av_log(NULL, AV_LOG_DEBUG, "ref_tile mismatch\n");

  381.                     return AVERROR_INVALIDDATA;

  382.                 }

  383.                 tile->ref_mbs = ref_tile->mbs;

  384.                 ref_tile++;

  385.             }

  386.             tile++;

  387.         }

  388.     }

  389. 

  390.     return 0;

  391. }

  392. 

  393. av_cold int ff_ivi_init_tiles(IVIPlaneDesc *planes,

  394.                               int tile_width, int tile_height)

  395. {

  396.     int p, b, x_tiles, y_tiles, t_width, t_height, ret;

  397.     IVIBandDesc *band;

  398. 

  399.     for (p = 0; p < 3; p++) {

  400.         t_width  = !p ? tile_width  : (tile_width  + 3) >> 2;

  401.         t_height = !p ? tile_height : (tile_height + 3) >> 2;

  402. 

  403.         if (!p && planes[0].num_bands == 4) {

  404.             if (t_width % 2 || t_height % 2) {

  405.                 avpriv_request_sample(NULL, "Odd tiles");

  406.                 return AVERROR_PATCHWELCOME;

  407.             }

  408.             t_width  >>= 1;

  409.             t_height >>= 1;

  410.         }

  411.         if(t_width<=0 || t_height<=0)

  412.             return AVERROR(EINVAL);

  413. 

  414.         for (b = 0; b < planes[p].num_bands; b++) {

  415.             band = &planes[p].bands[b];

  416. 

  417.             if (band->tiles) {

  418.                 int t;

  419.                 for (t = 0; t < band->num_tiles; t++) {

  420.                     av_freep(&band->tiles[t].mbs);

  421.                 }

  422.             }

  423. 

  424.             x_tiles = IVI_NUM_TILES(band->width, t_width);

  425.             y_tiles = IVI_NUM_TILES(band->height, t_height);

  426.             band->num_tiles = x_tiles * y_tiles;

  427. 

  428.             av_freep(&band->tiles);

  429.             band->tiles = av_mallocz_array(band->num_tiles, sizeof(IVITile));

  430.             if (!band->tiles) {

  431.                 band->num_tiles = 0;

  432.                 return AVERROR(ENOMEM);

  433.             }

  434. 

  435.             /* use the first luma band as reference for motion vectors

  436.              * and quant */

  437.             ret = ivi_init_tiles(band, planes[0].bands[0].tiles,

  438.                                  p, b, t_height, t_width);

  439.             if (ret < 0)

  440.                 return ret;

  441.         }

  442.     }

  443. 

  444.     return 0;

  445. }

  446. 

  447. /*

  448.  *  Decode size of the tile data.

  449.  *  The size is stored as a variable-length field having the following format:

  450.  *  if (tile_data_size < 255) than this field is only one byte long

  451.  *  if (tile_data_size >= 255) than this field four is byte long: 0xFF X1 X2 X3

  452.  *  where X1-X3 is size of the tile data

  453.  *

  454.  *  @param[in,out]  gb  the GetBit context

  455.  *  @return     size of the tile data in bytes

  456.  */

  457. static int ivi_dec_tile_data_size(GetBitContext *gb)

  458. {

  459.     int    len;

  460. 

  461.     len = 0;

  462.     if (get_bits1(gb)) {

  463.         len = get_bits(gb, 8);

  464.         if (len == 255)

  465.             len = get_bits(gb, 24);

  466.     }

  467. 

  468.     /* align the bitstream reader on the byte boundary */

  469.     align_get_bits(gb);

  470. 

  471.     return len;

  472. }

  473. 

  474. static int ivi_dc_transform(const IVIBandDesc *band, int *prev_dc, int buf_offs,

  475.                             int blk_size)

  476. {

  477.     band->dc_transform(prev_dc, band->buf + buf_offs,

  478.                        band->pitch, blk_size);

  479. 

  480.     return 0;

  481. }

  482. 

  483. static int ivi_decode_coded_blocks(GetBitContext *gb, const IVIBandDesc *band,

  484.                                    ivi_mc_func mc, ivi_mc_avg_func mc_avg,

  485.                                    int mv_x, int mv_y,

  486.                                    int mv_x2, int mv_y2,

  487.                                    int *prev_dc, int is_intra,

  488.                                    int mc_type, int mc_type2,

  489.                                    uint32_t quant, int offs,

  490.                                    AVCodecContext *avctx)

  491. {

  492.     const uint16_t *base_tab  = is_intra ? band->intra_base : band->inter_base;

  493.     RVMapDesc *rvmap = band->rv_map;

  494.     uint8_t col_flags[8];

  495.     int32_t trvec[64];

  496.     uint32_t sym = 0, lo, hi, q;

  497.     int pos, run, val;

  498.     int blk_size   = band->blk_size;

  499.     int num_coeffs = blk_size * blk_size;

  500.     int col_mask   = blk_size - 1;

  501.     int scan_pos   = -1;

  502.     int min_size   = band->pitch * (band->transform_size - 1) +

  503.                      band->transform_size;

  504.     int buf_size   = band->pitch * band->aheight - offs;

  505. 

  506.     if (min_size > buf_size)

  507.         return AVERROR_INVALIDDATA;

  508. 

  509.     if (!band->scan) {

  510.         av_log(avctx, AV_LOG_ERROR, "Scan pattern is not set.\n");

  511.         return AVERROR_INVALIDDATA;

  512.     }

  513. 

  514.     /* zero transform vector */

  515.     memset(trvec, 0, num_coeffs * sizeof(trvec[0]));

  516.     /* zero column flags */

  517.     memset(col_flags, 0, sizeof(col_flags));

  518.     while (scan_pos <= num_coeffs) {

  519.         sym = get_vlc2(gb, band->blk_vlc.tab->table,

  520.                        IVI_VLC_BITS, 1);

  521.         if (sym == rvmap->eob_sym)

  522.             break; /* End of block */

  523. 

  524.         /* Escape - run/val explicitly coded using 3 vlc codes */

  525.         if (sym == rvmap->esc_sym) {

  526.             run = get_vlc2(gb, band->blk_vlc.tab->table, IVI_VLC_BITS, 1) + 1;

  527.             lo  = get_vlc2(gb, band->blk_vlc.tab->table, IVI_VLC_BITS, 1);

  528.             hi  = get_vlc2(gb, band->blk_vlc.tab->table, IVI_VLC_BITS, 1);

  529.             /* merge them and convert into signed val */

  530.             val = IVI_TOSIGNED((hi << 6) | lo);

  531.         } else {

  532.             if (sym >= 256U) {

  533.                 av_log(avctx, AV_LOG_ERROR, "Invalid sym encountered: %"PRIu32".\n", sym);

  534.                 return AVERROR_INVALIDDATA;

  535.             }

  536.             run = rvmap->runtab[sym];

  537.             val = rvmap->valtab[sym];

  538.         }

  539. 

  540.         /* de-zigzag and dequantize */

  541.         scan_pos += run;

  542.         if (scan_pos >= num_coeffs || scan_pos < 0)

  543.             break;

  544.         pos = band->scan[scan_pos];

  545. 

  546.         if (!val)

  547.             ff_dlog(avctx, "Val = 0 encountered!\n");

  548. 

  549.         q = (base_tab[pos] * quant) >> 9;

  550.         if (q > 1)

  551.             val = val * q + FFSIGN(val) * (((q ^ 1) - 1) >> 1);

  552.         trvec[pos] = val;

  553.         /* track columns containing non-zero coeffs */

  554.         col_flags[pos & col_mask] |= !!val;

  555.     }

  556. 

  557.     if (scan_pos < 0 || scan_pos >= num_coeffs && sym != rvmap->eob_sym)

  558.         return AVERROR_INVALIDDATA; /* corrupt block data */

  559. 

  560.     /* undoing DC coeff prediction for intra-blocks */

  561.     if (is_intra && band->is_2d_trans) {

  562.         *prev_dc     += trvec[0];

  563.         trvec[0]      = *prev_dc;

  564.         col_flags[0] |= !!*prev_dc;

  565.     }

  566. 

  567.     if(band->transform_size > band->blk_size){

  568.         av_log(NULL, AV_LOG_ERROR, "Too large transform\n");

  569.         return AVERROR_INVALIDDATA;

  570.     }

  571. 

  572.     /* apply inverse transform */

  573.     band->inv_transform(trvec, band->buf + offs,

  574.                         band->pitch, col_flags);

  575. 

  576.     /* apply motion compensation */

  577.     if (!is_intra)

  578.         return ivi_mc(band, mc, mc_avg, offs, mv_x, mv_y, mv_x2, mv_y2,

  579.                       mc_type, mc_type2);

  580. 

  581.     return 0;

  582. }

  583. /*

  584.  *  Decode block data:

  585.  *  extract huffman-coded transform coefficients from the bitstream,

  586.  *  dequantize them, apply inverse transform and motion compensation

  587.  *  in order to reconstruct the picture.

  588.  *

  589.  *  @param[in,out]  gb    the GetBit context

  590.  *  @param[in]      band  pointer to the band descriptor

  591.  *  @param[in]      tile  pointer to the tile descriptor

  592.  *  @return     result code: 0 - OK, -1 = error (corrupted blocks data)

  593.  */

  594. static int ivi_decode_blocks(GetBitContext *gb, const IVIBandDesc *band,

  595.                              IVITile *tile, AVCodecContext *avctx)

  596. {

  597.     int mbn, blk, num_blocks, blk_size, ret, is_intra;

  598.     int mc_type = 0, mc_type2 = -1;

  599.     int mv_x = 0, mv_y = 0, mv_x2 = 0, mv_y2 = 0;

  600.     int32_t prev_dc;

  601.     uint32_t cbp, quant, buf_offs;

  602.     IVIMbInfo *mb;

  603.     ivi_mc_func mc_with_delta_func, mc_no_delta_func;

  604.     ivi_mc_avg_func mc_avg_with_delta_func, mc_avg_no_delta_func;

  605.     const uint8_t *scale_tab;

  606. 

  607.     /* init intra prediction for the DC coefficient */

  608.     prev_dc    = 0;

  609.     blk_size   = band->blk_size;

  610.     /* number of blocks per mb */

  611.     num_blocks = (band->mb_size != blk_size) ? 4 : 1;

  612.     if (blk_size == 8) {

  613.         mc_with_delta_func     = ff_ivi_mc_8x8_delta;

  614.         mc_no_delta_func       = ff_ivi_mc_8x8_no_delta;

  615.         mc_avg_with_delta_func = ff_ivi_mc_avg_8x8_delta;

  616.         mc_avg_no_delta_func   = ff_ivi_mc_avg_8x8_no_delta;

  617.     } else {

  618.         mc_with_delta_func     = ff_ivi_mc_4x4_delta;

  619.         mc_no_delta_func       = ff_ivi_mc_4x4_no_delta;

  620.         mc_avg_with_delta_func = ff_ivi_mc_avg_4x4_delta;

  621.         mc_avg_no_delta_func   = ff_ivi_mc_avg_4x4_no_delta;

  622.     }

  623. 

  624.     for (mbn = 0, mb = tile->mbs; mbn < tile->num_MBs; mb++, mbn++) {

  625.         is_intra = !mb->type;

  626.         cbp      = mb->cbp;

  627.         buf_offs = mb->buf_offs;

  628. 

  629.         quant = band->glob_quant + mb->q_delta;

  630.         if (avctx->codec_id == AV_CODEC_ID_INDEO4)

  631.             quant = av_clip_uintp2(quant, 5);

  632.         else

  633.             quant = av_clip(quant, 0, 23);

  634. 

  635.         scale_tab = is_intra ? band->intra_scale : band->inter_scale;

  636.         if (scale_tab)

  637.             quant = scale_tab[quant];

  638. 

  639.         if (!is_intra) {

  640.             mv_x  = mb->mv_x;

  641.             mv_y  = mb->mv_y;

  642.             mv_x2 = mb->b_mv_x;

  643.             mv_y2 = mb->b_mv_y;

  644.             if (band->is_halfpel) {

  645.                 mc_type  = ((mv_y  & 1) << 1) | (mv_x  & 1);

  646.                 mc_type2 = ((mv_y2 & 1) << 1) | (mv_x2 & 1);

  647.                 mv_x  >>= 1;

  648.                 mv_y  >>= 1;

  649.                 mv_x2 >>= 1;

  650.                 mv_y2 >>= 1; /* convert halfpel vectors into fullpel ones */

  651.             }

  652.             if (mb->type == 2)

  653.                 mc_type = -1;

  654.             if (mb->type != 2 && mb->type != 3)

  655.                 mc_type2 = -1;

  656.             if (mb->type) {

  657.                 int dmv_x, dmv_y, cx, cy;

  658. 

  659.                 dmv_x = mb->mv_x >> band->is_halfpel;

  660.                 dmv_y = mb->mv_y >> band->is_halfpel;

  661.                 cx    = mb->mv_x &  band->is_halfpel;

  662.                 cy    = mb->mv_y &  band->is_halfpel;

  663. 

  664.                 if (mb->xpos + dmv_x < 0 ||

  665.                     mb->xpos + dmv_x + band->mb_size + cx > band->pitch ||

  666.                     mb->ypos + dmv_y < 0 ||

  667.                     mb->ypos + dmv_y + band->mb_size + cy > band->aheight) {

  668.                     return AVERROR_INVALIDDATA;

  669.                 }

  670.             }

  671.             if (mb->type == 2 || mb->type == 3) {

  672.                 int dmv_x, dmv_y, cx, cy;

  673. 

  674.                 dmv_x = mb->b_mv_x >> band->is_halfpel;

  675.                 dmv_y = mb->b_mv_y >> band->is_halfpel;

  676.                 cx    = mb->b_mv_x &  band->is_halfpel;

  677.                 cy    = mb->b_mv_y &  band->is_halfpel;

  678. 

  679.                 if (mb->xpos + dmv_x < 0 ||

  680.                     mb->xpos + dmv_x + band->mb_size + cx > band->pitch ||

  681.                     mb->ypos + dmv_y < 0 ||

  682.                     mb->ypos + dmv_y + band->mb_size + cy > band->aheight) {

  683.                     return AVERROR_INVALIDDATA;

  684.                 }

  685.             }

  686.         }

  687. 

  688.         for (blk = 0; blk < num_blocks; blk++) {

  689.             /* adjust block position in the buffer according to its number */

  690.             if (blk & 1) {

  691.                 buf_offs += blk_size;

  692.             } else if (blk == 2) {

  693.                 buf_offs -= blk_size;

  694.                 buf_offs += blk_size * band->pitch;

  695.             }

  696. 

  697.             if (cbp & 1) { /* block coded ? */

  698.                 ret = ivi_decode_coded_blocks(gb, band, mc_with_delta_func,

  699.                                               mc_avg_with_delta_func,

  700.                                               mv_x, mv_y, mv_x2, mv_y2,

  701.                                               &prev_dc, is_intra,

  702.                                               mc_type, mc_type2, quant,

  703.                                               buf_offs, avctx);

  704.                 if (ret < 0)

  705.                     return ret;

  706.             } else {

  707.                 int buf_size = band->pitch * band->aheight - buf_offs;

  708.                 int min_size = (blk_size - 1) * band->pitch + blk_size;

  709. 

  710.                 if (min_size > buf_size)

  711.                     return AVERROR_INVALIDDATA;

  712.                 /* block not coded */

  713.                 /* for intra blocks apply the dc slant transform */

  714.                 /* for inter - perform the motion compensation without delta */

  715.                 if (is_intra) {

  716.                     ret = ivi_dc_transform(band, &prev_dc, buf_offs, blk_size);

  717.                     if (ret < 0)

  718.                         return ret;

  719.                 } else {

  720.                     ret = ivi_mc(band, mc_no_delta_func, mc_avg_no_delta_func,

  721.                                  buf_offs, mv_x, mv_y, mv_x2, mv_y2,

  722.                                  mc_type, mc_type2);

  723.                     if (ret < 0)

  724.                         return ret;

  725.                 }

  726.             }

  727. 

  728.             cbp >>= 1;

  729.         }// for blk

  730.     }// for mbn

  731. 

  732.     align_get_bits(gb);

  733. 

  734.     return 0;

  735. }

  736. 

  737. /**

  738.  *  Handle empty tiles by performing data copying and motion

  739.  *  compensation respectively.

  740.  *

  741.  *  @param[in]  avctx     ptr to the AVCodecContext

  742.  *  @param[in]  band      pointer to the band descriptor

  743.  *  @param[in]  tile      pointer to the tile descriptor

  744.  *  @param[in]  mv_scale  scaling factor for motion vectors

  745.  */

  746. static int ivi_process_empty_tile(AVCodecContext *avctx, const IVIBandDesc *band,

  747.                                   IVITile *tile, int32_t mv_scale)

  748. {

  749.     int             x, y, need_mc, mbn, blk, num_blocks, mv_x, mv_y, mc_type;

  750.     int             offs, mb_offset, row_offset, ret;

  751.     IVIMbInfo       *mb, *ref_mb;

  752.     const int16_t   *src;

  753.     int16_t         *dst;

  754.     ivi_mc_func     mc_no_delta_func;

  755.     int             clear_first = !band->qdelta_present && !band->plane && !band->band_num;

  756.     int             mb_size     = band->mb_size;

  757.     int             xend        = tile->xpos + tile->width;

  758.     int             is_halfpel  = band->is_halfpel;

  759.     int             pitch       = band->pitch;

  760. 

  761.     if (tile->num_MBs != IVI_MBs_PER_TILE(tile->width, tile->height, mb_size)) {

  762.         av_log(avctx, AV_LOG_ERROR, "Allocated tile size %d mismatches "

  763.                "parameters %d in ivi_process_empty_tile()\n",

  764.                tile->num_MBs, IVI_MBs_PER_TILE(tile->width, tile->height, mb_size));

  765.         return AVERROR_INVALIDDATA;

  766.     }

  767. 

  768.     offs       = tile->ypos * pitch + tile->xpos;

  769.     mb         = tile->mbs;

  770.     ref_mb     = tile->ref_mbs;

  771.     row_offset = mb_size * pitch;

  772.     need_mc    = 0; /* reset the mc tracking flag */

  773. 

  774.     for (y = tile->ypos; y < (tile->ypos + tile->height); y += mb_size) {

  775.         mb_offset = offs;

  776. 

  777.         for (x = tile->xpos; x < xend; x += mb_size) {

  778.             mb->xpos     = x;

  779.             mb->ypos     = y;

  780.             mb->buf_offs = mb_offset;

  781. 

  782.             mb->type = 1; /* set the macroblocks type = INTER */

  783.             mb->cbp  = 0; /* all blocks are empty */

  784. 

  785.             if (clear_first) {

  786.                 mb->q_delta = band->glob_quant;

  787.                 mb->mv_x    = 0;

  788.                 mb->mv_y    = 0;

  789.             }

  790. 

  791.             if (ref_mb) {

  792.                 if (band->inherit_qdelta)

  793.                     mb->q_delta = ref_mb->q_delta;

  794. 

  795.                 if (band->inherit_mv) {

  796.                     /* motion vector inheritance */

  797.                     if (mv_scale) {

  798.                         mb->mv_x = ivi_scale_mv(ref_mb->mv_x, mv_scale);

  799.                         mb->mv_y = ivi_scale_mv(ref_mb->mv_y, mv_scale);

  800.                     } else {

  801.                         mb->mv_x = ref_mb->mv_x;

  802.                         mb->mv_y = ref_mb->mv_y;

  803.                     }

  804.                     need_mc |= mb->mv_x || mb->mv_y; /* tracking non-zero motion vectors */

  805.                     {

  806.                         int dmv_x, dmv_y, cx, cy;

  807. 

  808.                         dmv_x = mb->mv_x >> is_halfpel;

  809.                         dmv_y = mb->mv_y >> is_halfpel;

  810.                         cx    = mb->mv_x &  is_halfpel;

  811.                         cy    = mb->mv_y &  is_halfpel;

  812. 

  813.                         if (   mb->xpos + dmv_x < 0

  814.                             || mb->xpos + dmv_x + mb_size + cx > pitch

  815.                             || mb->ypos + dmv_y < 0

  816.                             || mb->ypos + dmv_y + mb_size + cy > band->aheight) {

  817.                             av_log(avctx, AV_LOG_ERROR, "MV out of bounds\n");

  818.                             return AVERROR_INVALIDDATA;

  819.                         }

  820.                     }

  821.                 }

  822.                 ref_mb++;

  823.             }

  824. 

  825.             mb++;

  826.             mb_offset += mb_size;

  827.         } // for x

  828.         offs += row_offset;

  829.     } // for y

  830. 

  831.     if (band->inherit_mv && need_mc) { /* apply motion compensation if there is at least one non-zero motion vector */

  832.         num_blocks = (mb_size != band->blk_size) ? 4 : 1; /* number of blocks per mb */

  833.         mc_no_delta_func = (band->blk_size == 8) ? ff_ivi_mc_8x8_no_delta

  834.                                                  : ff_ivi_mc_4x4_no_delta;

  835. 

  836.         for (mbn = 0, mb = tile->mbs; mbn < tile->num_MBs; mb++, mbn++) {

  837.             mv_x = mb->mv_x;

  838.             mv_y = mb->mv_y;

  839.             if (!band->is_halfpel) {

  840.                 mc_type = 0; /* we have only fullpel vectors */

  841.             } else {

  842.                 mc_type = ((mv_y & 1) << 1) | (mv_x & 1);

  843.                 mv_x >>= 1;

  844.                 mv_y >>= 1; /* convert halfpel vectors into fullpel ones */

  845.             }

  846. 

  847.             for (blk = 0; blk < num_blocks; blk++) {

  848.                 /* adjust block position in the buffer according with its number */

  849.                 offs = mb->buf_offs + band->blk_size * ((blk & 1) + !!(blk & 2) * pitch);

  850.                 ret = ivi_mc(band, mc_no_delta_func, 0, offs,

  851.                              mv_x, mv_y, 0, 0, mc_type, -1);

  852.                 if (ret < 0)

  853.                     return ret;

  854.             }

  855.         }

  856.     } else {

  857.         /* copy data from the reference tile into the current one */

  858.         src = band->ref_buf + tile->ypos * pitch + tile->xpos;

  859.         dst = band->buf     + tile->ypos * pitch + tile->xpos;

  860.         for (y = 0; y < tile->height; y++) {

  861.             memcpy(dst, src, tile->width*sizeof(band->buf[0]));

  862.             src += pitch;

  863.             dst += pitch;

  864.         }

  865.     }

  866. 

  867.     return 0;

  868. }

  869. 

  870. 

  871. #ifdef DEBUG

  872. static uint16_t ivi_calc_band_checksum(const IVIBandDesc *band)

  873. {

  874.     int         x, y;

  875.     int16_t     *src, checksum;

  876. 

  877.     src = band->buf;

  878.     checksum = 0;

  879. 

  880.     for (y = 0; y < band->height; src += band->pitch, y++)

  881.         for (x = 0; x < band->width; x++)

  882.             checksum += src[x];

  883. 

  884.     return checksum;

  885. }

  886. #endif

  887. 

  888. /*

  889.  *  Convert and output the current plane.

  890.  *  This conversion is done by adding back the bias value of 128

  891.  *  (subtracted in the encoder) and clipping the result.

  892.  *

  893.  *  @param[in]   plane      pointer to the descriptor of the plane being processed

  894.  *  @param[out]  dst        pointer to the buffer receiving converted pixels

  895.  *  @param[in]   dst_pitch  pitch for moving to the next y line

  896.  */

  897. static void ivi_output_plane(IVIPlaneDesc *plane, uint8_t *dst, ptrdiff_t dst_pitch)

  898. {

  899.     int             x, y;

  900.     const int16_t   *src  = plane->bands[0].buf;

  901.     ptrdiff_t       pitch = plane->bands[0].pitch;

  902. 

  903.     if (!src)

  904.         return;

  905. 

  906.     for (y = 0; y < plane->height; y++) {

  907.         int m = 0;

  908.         int w = plane->width;

  909.         for (x = 0; x < w; x++) {

  910.             int t = src[x] + 128;

  911.             dst[x] = t;

  912.             m |= t;

  913.         }

  914.         if (m & ~255)

  915.             for (x = 0; x < w; x++)

  916.                 dst[x] = av_clip_uint8(src[x] + 128);

  917.         src += pitch;

  918.         dst += dst_pitch;

  919.     }

  920. }

  921. 

  922. static void *prepare_buf(IVI45DecContext *ctx, IVIBandDesc *band, int i)

  923. {

  924.     if (ctx->pic_conf.luma_bands <= 1 && i == 2)

  925.         return NULL;

  926.     if (!band->bufs[i])

  927.         band->bufs[i] = av_mallocz(2 * band->bufsize);

  928.     return band->bufs[i];

  929. }

  930. 

  931. /**

  932.  *  Decode an Indeo 4 or 5 band.

  933.  *

  934.  *  @param[in,out]  ctx    ptr to the decoder context

  935.  *  @param[in,out]  band   ptr to the band descriptor

  936.  *  @param[in]      avctx  ptr to the AVCodecContext

  937.  *  @return         result code: 0 = OK, -1 = error

  938.  */

  939. static int decode_band(IVI45DecContext *ctx,

  940.                        IVIBandDesc *band, AVCodecContext *avctx)

  941. {

  942.     int         result, i, t, idx1, idx2, pos;

  943.     IVITile     *tile;

  944. 

  945.     band->buf     = prepare_buf(ctx, band, ctx->dst_buf);

  946.     if (!band->buf) {

  947.         av_log(avctx, AV_LOG_ERROR, "Band buffer points to no data!\n");

  948.         return AVERROR_INVALIDDATA;

  949.     }

  950.     if (ctx->is_indeo4 && ctx->frame_type == IVI4_FRAMETYPE_BIDIR) {

  951.         band->ref_buf   = prepare_buf(ctx, band, ctx->b_ref_buf);

  952.         band->b_ref_buf = prepare_buf(ctx, band, ctx->ref_buf);

  953.         if (!band->b_ref_buf)

  954.             return AVERROR(ENOMEM);

  955.     } else {

  956.         band->ref_buf   = prepare_buf(ctx, band, ctx->ref_buf);

  957.         band->b_ref_buf = 0;

  958.     }

  959.     if (!band->ref_buf)

  960.         return AVERROR(ENOMEM);

  961.     band->data_ptr  = ctx->frame_data + (get_bits_count(&ctx->gb) >> 3);

  962. 

  963.     result = ctx->decode_band_hdr(ctx, band, avctx);

  964.     if (result) {

  965.         av_log(avctx, AV_LOG_ERROR, "Error while decoding band header: %d\n",

  966.                result);

  967.         return result;

  968.     }

  969. 

  970.     if (band->is_empty) {

  971.         av_log(avctx, AV_LOG_ERROR, "Empty band encountered!\n");

  972.         return AVERROR_INVALIDDATA;

  973.     }

  974. 

  975.     band->rv_map = &ctx->rvmap_tabs[band->rvmap_sel];

  976. 

  977.     /* apply corrections to the selected rvmap table if present */

  978.     for (i = 0; i < band->num_corr; i++) {

  979.         idx1 = band->corr[i * 2];

  980.         idx2 = band->corr[i * 2 + 1];

  981.         FFSWAP(uint8_t, band->rv_map->runtab[idx1], band->rv_map->runtab[idx2]);

  982.         FFSWAP(int16_t, band->rv_map->valtab[idx1], band->rv_map->valtab[idx2]);

  983.         if (idx1 == band->rv_map->eob_sym || idx2 == band->rv_map->eob_sym)

  984.             band->rv_map->eob_sym ^= idx1 ^ idx2;

  985.         if (idx1 == band->rv_map->esc_sym || idx2 == band->rv_map->esc_sym)

  986.             band->rv_map->esc_sym ^= idx1 ^ idx2;

  987.     }

  988. 

  989.     pos = get_bits_count(&ctx->gb);

  990. 

  991.     for (t = 0; t < band->num_tiles; t++) {

  992.         tile = &band->tiles[t];

  993. 

  994.         if (tile->mb_size != band->mb_size) {

  995.             av_log(avctx, AV_LOG_ERROR, "MB sizes mismatch: %d vs. %d\n",

  996.                    band->mb_size, tile->mb_size);

  997.             return AVERROR_INVALIDDATA;

  998.         }

  999.         tile->is_empty = get_bits1(&ctx->gb);

  1000.         if (tile->is_empty) {

  1001.             result = ivi_process_empty_tile(avctx, band, tile,

  1002.                                       (ctx->planes[0].bands[0].mb_size >> 3) - (band->mb_size >> 3));

  1003.             if (result < 0)

  1004.                 break;

  1005.             ff_dlog(avctx, "Empty tile encountered!\n");

  1006.         } else {

  1007.             tile->data_size = ivi_dec_tile_data_size(&ctx->gb);

  1008.             if (!tile->data_size) {

  1009.                 av_log(avctx, AV_LOG_ERROR, "Tile data size is zero!\n");

  1010.                 result = AVERROR_INVALIDDATA;

  1011.                 break;

  1012.             }

  1013. 

  1014.             result = ctx->decode_mb_info(ctx, band, tile, avctx);

  1015.             if (result < 0)

  1016.                 break;

  1017. 

  1018.             result = ivi_decode_blocks(&ctx->gb, band, tile, avctx);

  1019.             if (result < 0) {

  1020.                 av_log(avctx, AV_LOG_ERROR,

  1021.                        "Corrupted tile data encountered!\n");

  1022.                 break;

  1023.             }

  1024. 

  1025.             if (((get_bits_count(&ctx->gb) - pos) >> 3) != tile->data_size) {

  1026.                 av_log(avctx, AV_LOG_ERROR,

  1027.                        "Tile data_size mismatch!\n");

  1028.                 result = AVERROR_INVALIDDATA;

  1029.                 break;

  1030.             }

  1031. 

  1032.             pos += tile->data_size << 3; // skip to next tile

  1033.         }

  1034.     }

  1035. 

  1036.     /* restore the selected rvmap table by applying its corrections in

  1037.      * reverse order */

  1038.     for (i = band->num_corr-1; i >= 0; i--) {

  1039.         idx1 = band->corr[i*2];

  1040.         idx2 = band->corr[i*2+1];

  1041.         FFSWAP(uint8_t, band->rv_map->runtab[idx1], band->rv_map->runtab[idx2]);

  1042.         FFSWAP(int16_t, band->rv_map->valtab[idx1], band->rv_map->valtab[idx2]);

  1043.         if (idx1 == band->rv_map->eob_sym || idx2 == band->rv_map->eob_sym)

  1044.             band->rv_map->eob_sym ^= idx1 ^ idx2;

  1045.         if (idx1 == band->rv_map->esc_sym || idx2 == band->rv_map->esc_sym)

  1046.             band->rv_map->esc_sym ^= idx1 ^ idx2;

  1047.     }

  1048. 

  1049. #ifdef DEBUG

  1050.     if (band->checksum_present) {

  1051.         uint16_t chksum = ivi_calc_band_checksum(band);

  1052.         if (chksum != band->checksum) {

  1053.             av_log(avctx, AV_LOG_ERROR,

  1054.                    "Band checksum mismatch! Plane %d, band %d, "

  1055.                    "received: %"PRIx32", calculated: %"PRIx16"\n",

  1056.                    band->plane, band->band_num, band->checksum, chksum);

  1057.         }

  1058.     }

  1059. #endif

  1060. 

  1061.     align_get_bits(&ctx->gb);

  1062. 

  1063.     return result;

  1064. }

  1065. 

  1066. int ff_ivi_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,

  1067.                         AVPacket *avpkt)

  1068. {

  1069.     IVI45DecContext *ctx = avctx->priv_data;

  1070.     const uint8_t   *buf = avpkt->data;

  1071.     AVFrame       *frame = data;

  1072.     int             buf_size = avpkt->size;

  1073.     int             result, p, b;

  1074. 

  1075.     result = init_get_bits8(&ctx->gb, buf, buf_size);

  1076.     if (result < 0)

  1077.         return result;

  1078.     ctx->frame_data = buf;

  1079.     ctx->frame_size = buf_size;

  1080. 

  1081.     result = ctx->decode_pic_hdr(ctx, avctx);

  1082.     if (result) {

  1083.         av_log(avctx, AV_LOG_ERROR,

  1084.                "Error while decoding picture header: %d\n", result);

  1085.         return result;

  1086.     }

  1087.     if (ctx->gop_invalid)

  1088.         return AVERROR_INVALIDDATA;

  1089. 

  1090.     if (ctx->is_indeo4 && ctx->frame_type == IVI4_FRAMETYPE_NULL_LAST) {

  1091.         if (ctx->got_p_frame) {

  1092.             av_frame_move_ref(data, ctx->p_frame);

  1093.             *got_frame = 1;

  1094.             ctx->got_p_frame = 0;

  1095.         } else {

  1096.             *got_frame = 0;

  1097.         }

  1098.         return buf_size;

  1099.     }

  1100. 

  1101.     if (ctx->gop_flags & IVI5_IS_PROTECTED) {

  1102.         avpriv_report_missing_feature(avctx, "Password-protected clip");

  1103.         return AVERROR_PATCHWELCOME;

  1104.     }

  1105. 

  1106.     if (!ctx->planes[0].bands) {

  1107.         av_log(avctx, AV_LOG_ERROR, "Color planes not initialized yet\n");

  1108.         return AVERROR_INVALIDDATA;

  1109.     }

  1110. 

  1111.     ctx->switch_buffers(ctx);

  1112. 

  1113.     if (ctx->is_nonnull_frame(ctx)) {

  1114.         ctx->buf_invalid[ctx->dst_buf] = 1;

  1115.         for (p = 0; p < 3; p++) {

  1116.             for (b = 0; b < ctx->planes[p].num_bands; b++) {

  1117.                 result = decode_band(ctx, &ctx->planes[p].bands[b], avctx);

  1118.                 if (result < 0) {

  1119.                     av_log(avctx, AV_LOG_ERROR,

  1120.                            "Error while decoding band: %d, plane: %d\n", b, p);

  1121.                     return result;

  1122.                 }

  1123.             }

  1124.         }

  1125.         ctx->buf_invalid[ctx->dst_buf] = 0;

  1126.     } else {

  1127.         if (ctx->is_scalable)

  1128.             return AVERROR_INVALIDDATA;

  1129. 

  1130.         for (p = 0; p < 3; p++) {

  1131.             if (!ctx->planes[p].bands[0].buf)

  1132.                 return AVERROR_INVALIDDATA;

  1133.         }

  1134.     }

  1135.     if (ctx->buf_invalid[ctx->dst_buf])

  1136.         return -1;

  1137. 

  1138.     if (!ctx->is_nonnull_frame(ctx))

  1139.         return buf_size;

  1140. 

  1141.     result = ff_set_dimensions(avctx, ctx->planes[0].width, ctx->planes[0].height);

  1142.     if (result < 0)

  1143.         return result;

  1144. 

  1145.     if ((result = ff_get_buffer(avctx, frame, 0)) < 0)

  1146.         return result;

  1147. 

  1148.     if (ctx->is_scalable) {

  1149.         if (ctx->is_indeo4)

  1150.             ff_ivi_recompose_haar(&ctx->planes[0], frame->data[0], frame->linesize[0]);

  1151.         else

  1152.             ff_ivi_recompose53   (&ctx->planes[0], frame->data[0], frame->linesize[0]);

  1153.     } else {

  1154.         ivi_output_plane(&ctx->planes[0], frame->data[0], frame->linesize[0]);

  1155.     }

  1156. 

  1157.     ivi_output_plane(&ctx->planes[2], frame->data[1], frame->linesize[1]);

  1158.     ivi_output_plane(&ctx->planes[1], frame->data[2], frame->linesize[2]);

  1159. 

  1160.     *got_frame = 1;

  1161. 

  1162.     /* If the bidirectional mode is enabled, next I and the following P

  1163.      * frame will be sent together. Unfortunately the approach below seems

  1164.      * to be the only way to handle the B-frames mode.

  1165.      * That's exactly the same Intel decoders do.

  1166.      */

  1167.     if (ctx->is_indeo4 && ctx->frame_type == IVI4_FRAMETYPE_INTRA) {

  1168.         int left;

  1169. 

  1170.             // skip version string

  1171.         while (get_bits(&ctx->gb, 8)) {

  1172.             if (get_bits_left(&ctx->gb) < 8)

  1173.                 return AVERROR_INVALIDDATA;

  1174.         }

  1175.         left = get_bits_count(&ctx->gb) & 0x18;

  1176.         skip_bits_long(&ctx->gb, 64 - left);

  1177.         if (get_bits_left(&ctx->gb) > 18 &&

  1178.             show_bits(&ctx->gb, 21) == 0xBFFF8) { // syncheader + inter type

  1179.             AVPacket pkt;

  1180.             pkt.data = avpkt->data + (get_bits_count(&ctx->gb) >> 3);

  1181.             pkt.size = get_bits_left(&ctx->gb) >> 3;

  1182.             ctx->got_p_frame = 0;

  1183.             av_frame_unref(ctx->p_frame);

  1184.             ff_ivi_decode_frame(avctx, ctx->p_frame, &ctx->got_p_frame, &pkt);

  1185.         }

  1186.     }

  1187. 

  1188.     if (ctx->show_indeo4_info) {

  1189.         if (ctx->is_scalable)

  1190.             av_log(avctx, AV_LOG_DEBUG, "This video uses scalability mode\n");

  1191.         if (ctx->uses_tiling)

  1192.             av_log(avctx, AV_LOG_DEBUG, "This video uses local decoding\n");

  1193.         if (ctx->has_b_frames)

  1194.             av_log(avctx, AV_LOG_DEBUG, "This video contains B-frames\n");

  1195.         if (ctx->has_transp)

  1196.             av_log(avctx, AV_LOG_DEBUG, "Transparency mode is enabled\n");

  1197.         if (ctx->uses_haar)

  1198.             av_log(avctx, AV_LOG_DEBUG, "This video uses Haar transform\n");

  1199.         if (ctx->uses_fullpel)

  1200.             av_log(avctx, AV_LOG_DEBUG, "This video uses fullpel motion vectors\n");

  1201.         ctx->show_indeo4_info = 0;

  1202.     }

  1203. 

  1204.     return buf_size;

  1205. }

  1206. 

  1207. /**

  1208.  *  Close Indeo5 decoder and clean up its context.

  1209.  */

  1210. av_cold int ff_ivi_decode_close(AVCodecContext *avctx)

  1211. {

  1212.     IVI45DecContext *ctx = avctx->priv_data;

  1213. 

  1214.     ivi_free_buffers(&ctx->planes[0]);

  1215. 

  1216.     if (ctx->mb_vlc.cust_tab.table)

  1217.         ff_free_vlc(&ctx->mb_vlc.cust_tab);

  1218. 

  1219.     if (ctx->blk_vlc.cust_tab.table)

  1220.         ff_free_vlc(&ctx->blk_vlc.cust_tab);

  1221. 

  1222.     av_frame_free(&ctx->p_frame);

  1223. 

  1224.     return 0;

  1225. }

  1226. 

  1227. 

  1228. /**

  1229.  *  Scan patterns shared between indeo4 and indeo5

  1230.  */

  1231. const uint8_t ff_ivi_vertical_scan_8x8[64] = {

  1232.     0,  8, 16, 24, 32, 40, 48, 56,

  1233.     1,  9, 17, 25, 33, 41, 49, 57,

  1234.     2, 10, 18, 26, 34, 42, 50, 58,

  1235.     3, 11, 19, 27, 35, 43, 51, 59,

  1236.     4, 12, 20, 28, 36, 44, 52, 60,

  1237.     5, 13, 21, 29, 37, 45, 53, 61,

  1238.     6, 14, 22, 30, 38, 46, 54, 62,

  1239.     7, 15, 23, 31, 39, 47, 55, 63

  1240. };

  1241. 

  1242. const uint8_t ff_ivi_horizontal_scan_8x8[64] = {

  1243.      0,  1,  2,  3,  4,  5,  6,  7,

  1244.      8,  9, 10, 11, 12, 13, 14, 15,

  1245.     16, 17, 18, 19, 20, 21, 22, 23,

  1246.     24, 25, 26, 27, 28, 29, 30, 31,

  1247.     32, 33, 34, 35, 36, 37, 38, 39,

  1248.     40, 41, 42, 43, 44, 45, 46, 47,

  1249.     48, 49, 50, 51, 52, 53, 54, 55,

  1250.     56, 57, 58, 59, 60, 61, 62, 63

  1251. };

  1252. 

  1253. const uint8_t ff_ivi_direct_scan_4x4[16] = {

  1254.     0, 1, 4, 8, 5, 2, 3, 6, 9, 12, 13, 10, 7, 11, 14, 15

  1255. };

  1256. 

  1257. 

  1258. /**

  1259.  *  Run-value (RLE) tables.

  1260.  */

  1261. const RVMapDesc ff_ivi_rvmap_tabs[9] = {

  1262. {   /* MapTab0 */

  1263.     5, /* eob_sym */

  1264.     2, /* esc_sym */

  1265.     /* run table */

  1266.     {1,  1,  0,  1,  1,  0,  1,  1,  2,  2,  1,  1,  1,  1,  3,  3,

  1267.      1,  1,  2,  2,  1,  1,  4,  4,  1,  1,  1,  1,  2,  2,  5,  5,

  1268.      1,  1,  3,  3,  1,  1,  6,  6,  1,  2,  1,  2,  7,  7,  1,  1,

  1269.      8,  8,  1,  1,  4,  2,  1,  4,  2,  1,  3,  3,  1,  1,  1,  9,

  1270.      9,  1,  2,  1,  2,  1,  5,  5,  1,  1, 10, 10,  1,  1,  3,  3,

  1271.      2,  2,  1,  1, 11, 11,  6,  4,  4,  1,  6,  1,  2,  1,  2, 12,

  1272.      8,  1, 12,  7,  8,  7,  1, 16,  1, 16,  1,  3,  3, 13,  1, 13,

  1273.      2,  2,  1, 15,  1,  5, 14, 15,  1,  5, 14,  1, 17,  8, 17,  8,

  1274.      1,  4,  4,  2,  2,  1, 25, 25, 24, 24,  1,  3,  1,  3,  1,  8,

  1275.      6,  7,  6,  1, 18,  8, 18,  1,  7, 23,  2,  2, 23,  1,  1, 21,

  1276.     22,  9,  9, 22, 19,  1, 21,  5, 19,  5,  1, 33, 20, 33, 20,  8,

  1277.      4,  4,  1, 32,  2,  2,  8,  3, 32, 26,  3,  1,  7,  7, 26,  6,

  1278.      1,  6,  1,  1, 16,  1, 10,  1, 10,  2, 16, 29, 28,  2, 29, 28,

  1279.      1, 27,  5,  8,  5, 27,  1,  8,  3,  7,  3, 31, 41, 31,  1, 41,

  1280.      6,  1,  6,  7,  4,  4,  1,  1,  2,  1,  2, 11, 34, 30, 11,  1,

  1281.     30, 15, 15, 34, 36, 40, 36, 40, 35, 35, 37, 37, 39, 39, 38, 38},

  1282. 

  1283.     /* value table */

  1284.     { 1,  -1,   0,   2,  -2,   0,   3,  -3,   1,  -1,   4,  -4,   5,  -5,   1,  -1,

  1285.       6,  -6,   2,  -2,   7,  -7,   1,  -1,   8,  -8,   9,  -9,   3,  -3,   1,  -1,

  1286.      10, -10,   2,  -2,  11, -11,   1,  -1,  12,   4, -12,  -4,   1,  -1,  13, -13,

  1287.       1,  -1,  14, -14,   2,   5,  15,  -2,  -5, -15,  -3,   3,  16, -16,  17,   1,

  1288.      -1, -17,   6,  18,  -6, -18,   2,  -2,  19, -19,   1,  -1,  20, -20,   4,  -4,

  1289.       7,  -7,  21, -21,   1,  -1,   2,   3,  -3,  22,  -2, -22,   8,  23,  -8,   1,

  1290.       2, -23,  -1,   2,  -2,  -2,  24,   1, -24,  -1,  25,   5,  -5,   1, -25,  -1,

  1291.       9,  -9,  26,   1, -26,   3,   1,  -1,  27,  -3,  -1, -27,   1,   3,  -1,  -3,

  1292.      28,  -4,   4,  10, -10, -28,   1,  -1,   1,  -1,  29,   6, -29,  -6,  30,  -4,

  1293.       3,   3,  -3, -30,   1,   4,  -1,  31,  -3,   1,  11, -11,  -1, -31,  32,  -1,

  1294.      -1,   2,  -2,   1,   1, -32,   1,   4,  -1,  -4,  33,  -1,   1,   1,  -1,   5,

  1295.       5,  -5, -33,  -1, -12,  12,  -5,  -7,   1,   1,   7,  34,   4,  -4,  -1,   4,

  1296.     -34,  -4,  35,  36,  -2, -35,  -2, -36,   2,  13,   2,  -1,   1, -13,   1,  -1,

  1297.      37,   1,  -5,   6,   5,  -1,  38,  -6,  -8,   5,   8,  -1,   1,   1, -37,  -1,

  1298.       5,  39,  -5,  -5,   6,  -6, -38, -39, -14,  40,  14,   2,   1,   1,  -2, -40,

  1299.      -1,  -2,   2,  -1,  -1,  -1,   1,   1,   1,  -1,   1,  -1,   1,  -1,   1,  -1}

  1300. },{

  1301.     /* MapTab1 */

  1302.     0,  /* eob_sym */

  1303.     38, /* esc_sym */

  1304.     /* run table */

  1305.     {0,  1,  1,  2,  2,  3,  3,  4,  4,  5,  5,  6,  8,  6,  8,  7,

  1306.      7,  9,  9, 10, 10, 11, 11,  1, 12,  1, 12, 13, 13, 16, 14, 16,

  1307.     14, 15, 15, 17, 17, 18,  0, 18, 19, 20, 21, 19, 22, 21, 20, 22,

  1308.     25, 24,  2, 25, 24, 23, 23,  2, 26, 28, 26, 28, 29, 27, 29, 27,

  1309.     33, 33,  1, 32,  1,  3, 32, 30, 36,  3, 36, 30, 31, 31, 35, 34,

  1310.     37, 41, 34, 35, 37,  4, 41,  4, 49,  8,  8, 49, 40, 38,  5, 38,

  1311.     40, 39,  5, 39, 42, 43, 42,  7, 57,  6, 43, 44,  6, 50,  7, 44,

  1312.     57, 48, 50, 48, 45, 45, 46, 47, 51, 46, 47, 58,  1, 51, 58,  1,

  1313.     52, 59, 53,  9, 52, 55, 55, 59, 53, 56, 54, 56, 54,  9, 64, 64,

  1314.     60, 63, 60, 63, 61, 62, 61, 62,  2, 10,  2, 10, 11,  1, 11, 13,

  1315.     12,  1, 12, 13, 16, 16,  8,  8, 14,  3,  3, 15, 14, 15,  4,  4,

  1316.      1, 17, 17,  5,  1,  7,  7,  5,  6,  1,  2,  2,  6, 22,  1, 25,

  1317.     21, 22,  8, 24,  1, 21, 25, 24,  8, 18, 18, 23,  9, 20, 23, 33,

  1318.     29, 33, 20,  1, 19,  1, 29, 36,  9, 36, 19, 41, 28, 57, 32,  3,

  1319.     28,  3,  1, 27, 49, 49,  1, 32, 26, 26,  2,  4,  4,  7, 57, 41,

  1320.      2,  7, 10,  5, 37, 16, 10, 27,  8,  8, 13, 16, 37, 13,  1,  5},

  1321. 

  1322.     /* value table */

  1323.     {0,   1,  -1,   1,  -1,   1,  -1,   1,  -1,   1,  -1,   1,   1,  -1,  -1,   1,

  1324.     -1,   1,  -1,   1,  -1,   1,  -1,   2,   1,  -2,  -1,   1,  -1,   1,   1,  -1,

  1325.     -1,   1,  -1,   1,  -1,   1,   0,  -1,   1,   1,   1,  -1,   1,  -1,  -1,  -1,

  1326.      1,   1,   2,  -1,  -1,   1,  -1,  -2,   1,   1,  -1,  -1,   1,   1,  -1,  -1,

  1327.      1,  -1,   3,   1,  -3,   2,  -1,   1,   1,  -2,  -1,  -1,  -1,   1,   1,   1,

  1328.      1,   1,  -1,  -1,  -1,   2,  -1,  -2,   1,   2,  -2,  -1,   1,   1,   2,  -1,

  1329.     -1,   1,  -2,  -1,   1,   1,  -1,   2,   1,   2,  -1,   1,  -2,  -1,  -2,  -1,

  1330.     -1,   1,   1,  -1,   1,  -1,   1,   1,   1,  -1,  -1,   1,   4,  -1,  -1,  -4,

  1331.      1,   1,   1,   2,  -1,  -1,   1,  -1,  -1,   1,  -1,  -1,   1,  -2,   1,  -1,

  1332.      1,   1,  -1,  -1,   1,   1,  -1,  -1,   3,   2,  -3,  -2,   2,   5,  -2,   2,

  1333.      2,  -5,  -2,  -2,  -2,   2,  -3,   3,   2,   3,  -3,   2,  -2,  -2,   3,  -3,

  1334.      6,   2,  -2,   3,  -6,   3,  -3,  -3,   3,   7,  -4,   4,  -3,   2,  -7,   2,

  1335.      2,  -2,  -4,   2,   8,  -2,  -2,  -2,   4,   2,  -2,   2,   3,   2,  -2,  -2,

  1336.      2,   2,  -2,  -8,  -2,   9,  -2,   2,  -3,  -2,   2,  -2,   2,   2,   2,   4,

  1337.     -2,  -4,  10,   2,   2,  -2,  -9,  -2,   2,  -2,   5,   4,  -4,   4,  -2,   2,

  1338.     -5,  -4,  -3,   4,   2,  -3,   3,  -2,  -5,   5,   3,   3,  -2,  -3, -10,  -4}

  1339. },{

  1340.     /* MapTab2 */

  1341.     2,  /* eob_sym */

  1342.     11, /* esc_sym */

  1343.     /* run table */

  1344.     {1,  1,  0,  2,  2,  1,  1,  3,  3,  4,  4,  0,  1,  1,  5,  5,

  1345.      2,  2,  6,  6,  7,  7,  1,  8,  1,  8,  3,  3,  9,  9,  1,  2,

  1346.      2,  1,  4, 10,  4, 10, 11, 11,  1,  5, 12, 12,  1,  5, 13, 13,

  1347.      3,  3,  6,  6,  2,  2, 14, 14, 16, 16, 15,  7, 15,  8,  8,  7,

  1348.      1,  1, 17, 17,  4,  4,  1,  1, 18, 18,  2,  2,  5,  5, 25,  3,

  1349.      9,  3, 25,  9, 19, 24, 19, 24,  1, 21, 20,  1, 21, 22, 20, 22,

  1350.     23, 23,  8,  6, 33,  6,  8, 33,  7,  7, 26, 26,  1, 32,  1, 32,

  1351.     28,  4, 28, 10, 29, 27, 27, 10, 41,  4, 29,  2,  2, 41, 36, 31,

  1352.     49, 31, 34, 30, 34, 36, 30, 35,  1, 49, 11,  5, 35, 11,  1,  3,

  1353.      3,  5, 37, 37,  8, 40,  8, 40, 12, 12, 42, 42,  1, 38, 16, 57,

  1354.      1,  6, 16, 39, 38,  6,  7,  7, 13, 13, 39, 43,  2, 43, 57,  2,

  1355.     50,  9, 44,  9, 50,  4, 15, 48, 44,  4,  1, 15, 48, 14, 14,  1,

  1356.     45, 45,  8,  3,  5,  8, 51, 47,  3, 46, 46, 47,  5, 51,  1, 17,

  1357.     17, 58,  1, 58,  2, 52, 52,  2, 53,  7, 59,  6,  6, 56, 53, 55,

  1358.      7, 55,  1, 54, 59, 56, 54, 10,  1, 10,  4, 60,  1, 60,  8,  4,

  1359.      8, 64, 64, 61,  1, 63,  3, 63, 62, 61,  5, 11,  5,  3, 11, 62},

  1360. 

  1361.     /* value table */

  1362.     { 1,  -1,   0,   1,  -1,   2,  -2,   1,  -1,   1,  -1,   0,   3,  -3,   1,  -1,

  1363.       2,  -2,   1,  -1,   1,  -1,   4,   1,  -4,  -1,   2,  -2,   1,  -1,   5,   3,

  1364.      -3,  -5,   2,   1,  -2,  -1,   1,  -1,   6,   2,   1,  -1,  -6,  -2,   1,  -1,

  1365.       3,  -3,   2,  -2,   4,  -4,   1,  -1,   1,  -1,   1,   2,  -1,   2,  -2,  -2,

  1366.       7,  -7,   1,  -1,   3,  -3,   8,  -8,   1,  -1,   5,  -5,   3,  -3,   1,   4,

  1367.       2,  -4,  -1,  -2,   1,   1,  -1,  -1,   9,   1,   1,  -9,  -1,   1,  -1,  -1,

  1368.       1,  -1,   3,  -3,   1,   3,  -3,  -1,   3,  -3,   1,  -1,  10,   1, -10,  -1,

  1369.       1,   4,  -1,   2,   1,  -1,   1,  -2,   1,  -4,  -1,   6,  -6,  -1,   1,   1,

  1370.       1,  -1,   1,   1,  -1,  -1,  -1,   1,  11,  -1,  -2,   4,  -1,   2, -11,   5,

  1371.      -5,  -4,  -1,   1,   4,   1,  -4,  -1,  -2,   2,   1,  -1,  12,   1,  -2,   1,

  1372.     -12,   4,   2,   1,  -1,  -4,   4,  -4,   2,  -2,  -1,   1,   7,  -1,  -1,  -7,

  1373.      -1,  -3,   1,   3,   1,   5,   2,   1,  -1,  -5,  13,  -2,  -1,   2,  -2, -13,

  1374.       1,  -1,   5,   6,   5,  -5,   1,   1,  -6,   1,  -1,  -1,  -5,  -1,  14,   2,

  1375.      -2,   1, -14,  -1,   8,   1,  -1,  -8,   1,   5,   1,   5,  -5,   1,  -1,   1,

  1376.      -5,  -1,  15,   1,  -1,  -1,  -1,   3, -15,  -3,   6,   1,  16,  -1,   6,  -6,

  1377.      -6,   1,  -1,   1, -16,   1,   7,  -1,   1,  -1,  -6,  -3,   6,  -7,   3,  -1}

  1378. },{

  1379.     /* MapTab3 */

  1380.     0,  /* eob_sym */

  1381.     35, /* esc_sym */

  1382.     /* run table */

  1383.     {0,  1,  1,  2,  2,  3,  3,  4,  4,  1,  1,  5,  5,  6,  6,  7,

  1384.      7,  8,  8,  9,  9,  2,  2, 10, 10,  1,  1, 11, 11, 12, 12,  3,

  1385.      3, 13, 13,  0, 14, 14, 16, 15, 16, 15,  4,  4, 17,  1, 17,  1,

  1386.      5,  5, 18, 18,  2,  2,  6,  6,  8, 19,  7,  8,  7, 19, 20, 20,

  1387.     21, 21, 22, 24, 22, 24, 23, 23,  1,  1, 25, 25,  3,  3, 26, 26,

  1388.      9,  9, 27, 27, 28, 28, 33, 29,  4, 33, 29,  1,  4,  1, 32, 32,

  1389.      2,  2, 31, 10, 30, 10, 30, 31, 34, 34,  5,  5, 36, 36, 35, 41,

  1390.     35, 11, 41, 11, 37,  1,  8,  8, 37,  6,  1,  6, 40,  7,  7, 40,

  1391.     12, 38, 12, 39, 39, 38, 49, 13, 49, 13,  3, 42,  3, 42, 16, 16,

  1392.     43, 43, 14, 14,  1,  1, 44, 15, 44, 15,  2,  2, 57, 48, 50, 48,

  1393.     57, 50,  4, 45, 45,  4, 46, 47, 47, 46,  1, 51,  1, 17, 17, 51,

  1394.      8,  9,  9,  5, 58,  8, 58,  5, 52, 52, 55, 56, 53, 56, 55, 59,

  1395.     59, 53, 54,  1,  6, 54,  7,  7,  6,  1,  2,  3,  2,  3, 64, 60,

  1396.     60, 10, 10, 64, 61, 62, 61, 63,  1, 63, 62,  1, 18, 24, 18,  4,

  1397.     25,  4,  8, 21, 21,  1, 24, 22, 25, 22,  8, 11, 19, 11, 23,  1,

  1398.     20, 23, 19, 20,  5, 12,  5,  1, 16,  2, 12, 13,  2, 13,  1, 16},

  1399. 

  1400.     /* value table */

  1401.     { 0,   1,  -1,   1,  -1,   1,  -1,   1,  -1,   2,  -2,   1,  -1,   1,  -1,   1,

  1402.      -1,   1,  -1,   1,  -1,   2,  -2,   1,  -1,   3,  -3,   1,  -1,   1,  -1,   2,

  1403.      -2,   1,  -1,   0,   1,  -1,   1,   1,  -1,  -1,   2,  -2,   1,   4,  -1,  -4,

  1404.       2,  -2,   1,  -1,  -3,   3,   2,  -2,   2,   1,   2,  -2,  -2,  -1,   1,  -1,

  1405.       1,  -1,   1,   1,  -1,  -1,   1,  -1,   5,  -5,   1,  -1,   3,  -3,   1,  -1,

  1406.       2,  -2,   1,  -1,   1,  -1,   1,   1,   3,  -1,  -1,   6,  -3,  -6,  -1,   1,

  1407.       4,  -4,   1,   2,   1,  -2,  -1,  -1,   1,  -1,   3,  -3,   1,  -1,   1,   1,

  1408.      -1,   2,  -1,  -2,   1,   7,  -3,   3,  -1,   3,  -7,  -3,   1,  -3,   3,  -1,

  1409.       2,   1,  -2,   1,  -1,  -1,   1,   2,  -1,  -2,  -4,  -1,   4,   1,   2,  -2,

  1410.       1,  -1,  -2,   2,   8,  -8,  -1,   2,   1,  -2,  -5,   5,   1,  -1,  -1,   1,

  1411.      -1,   1,   4,  -1,   1,  -4,  -1,  -1,   1,   1,   9,   1,  -9,   2,  -2,  -1,

  1412.      -4,   3,  -3,  -4,  -1,   4,   1,   4,   1,  -1,   1,  -1,   1,   1,  -1,   1,

  1413.      -1,  -1,  -1,  10,   4,   1,   4,  -4,  -4, -10,   6,   5,  -6,  -5,   1,  -1,

  1414.       1,   3,  -3,  -1,   1,  -1,  -1,  -1,  11,   1,   1, -11,  -2,  -2,   2,   5,

  1415.      -2,  -5,  -5,   2,  -2,  12,   2,  -2,   2,   2,   5,  -3,  -2,   3,  -2, -12,

  1416.      -2,   2,   2,   2,  -5,   3,   5,  13,  -3,   7,  -3,  -3,  -7,   3, -13,   3}

  1417. },{

  1418.     /* MapTab4 */

  1419.     0,  /* eob_sym */

  1420.     34, /* esc_sym */

  1421.     /* run table */

  1422.     {0,  1,  1,  1,  2,  2,  1,  3,  3,  1,  1,  1,  4,  4,  1,  5,

  1423.      2,  1,  5,  2,  1,  1,  6,  6,  1,  1,  1,  1,  1,  7,  3,  1,

  1424.      2,  3,  0,  1,  2,  7,  1,  1,  1,  8,  1,  1,  8,  1,  1,  1,

  1425.      9,  1,  9,  1,  2,  1,  1,  2,  1,  1, 10,  4,  1, 10,  1,  4,

  1426.      1,  1,  1,  1,  1,  3,  1,  1,  1,  3,  2,  1,  5,  1,  1,  1,

  1427.      2,  5,  1, 11,  1, 11,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,

  1428.      2,  1,  6,  1,  6,  1,  1,  2,  1,  1,  1,  1,  1,  1,  1, 12,

  1429.      3,  1, 12,  1,  1,  1,  2,  1,  1,  3,  1,  1,  1,  1,  1,  1,

  1430.      4,  1,  1,  1,  2,  1,  1,  4,  1,  1,  1,  1,  1,  1,  2,  1,

  1431.      1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  3,  1,  2,  1,  1,  5,

  1432.      1,  1,  1,  1,  1,  7,  1,  7,  1,  1,  2,  3,  1,  1,  1,  1,

  1433.      5,  1,  1,  1,  1,  1,  1,  2, 13,  1,  1,  1,  1,  1,  1,  1,

  1434.      1,  1,  1,  1,  1,  1,  1,  1, 13,  2,  1,  1,  4,  1,  1,  1,

  1435.      3,  1,  6,  1,  1,  1, 14,  1,  1,  1,  1,  1, 14,  6,  1,  1,

  1436.      1,  1, 15,  2,  4,  1,  2,  3, 15,  1,  1,  1,  8,  1,  1,  8,

  1437.      1,  1,  1,  1,  1,  1,  1,  1,  2,  1,  1,  1,  1,  1,  1,  1},

  1438. 

  1439.     /* value table */

  1440.     { 0,   1,  -1,   2,   1,  -1,  -2,   1,  -1,   3,  -3,   4,   1,  -1,  -4,   1,

  1441.       2,   5,  -1,  -2,  -5,   6,   1,  -1,  -6,   7,  -7,   8,  -8,   1,   2,   9,

  1442.       3,  -2,   0,  -9,  -3,  -1,  10, -10,  11,   1, -11,  12,  -1, -12,  13, -13,

  1443.       1,  14,  -1, -14,   4,  15, -15,  -4,  16, -16,   1,   2,  17,  -1, -17,  -2,

  1444.      18, -18,  19, -19,  20,   3, -20,  21, -21,  -3,   5,  22,   2, -22, -23,  23,

  1445.      -5,  -2,  24,   1, -24,  -1,  25, -25,  26, -26, -27,  27,  28,  29, -28, -29,

  1446.       6,  30,   2, -31,  -2, -30,  31,  -6, -32,  32,  33, -33,  34, -35, -34,   1,

  1447.       4, -36,  -1,  35,  37,  36,   7, -37,  38,  -4, -38,  39,  41,  40, -40, -39,

  1448.       3,  42, -43, -41,  -7, -42,  43,  -3,  44, -44,  45, -45,  46,  47,   8, -47,

  1449.     -48, -46,  50, -50,  48,  49,  51, -49,  52, -52,   5, -51,  -8, -53,  53,   3,

  1450.     -56,  56,  55,  54, -54,   2,  60,  -2, -55,  58,   9,  -5,  59,  57, -57, -63,

  1451.      -3, -58, -60, -61,  61, -59, -62,  -9,   1,  64,  62,  69, -64,  63,  65, -67,

  1452.     -68,  66, -65,  68, -66, -69,  67, -70,  -1,  10,  71, -71,   4,  73,  72,  70,

  1453.       6, -76,  -3,  74, -78, -74,   1,  78,  80, -72, -75,  76,  -1,   3, -73,  79,

  1454.      75,  77,   1,  11,  -4, -79, -10,  -6,  -1, -77, -83, -80,   2,  81, -84,  -2,

  1455.      83, -81,  82, -82,  84, -87, -86,  85, -11, -85,  86, -89,  87, -88,  88,  89}

  1456. },{

  1457.     /* MapTab5 */

  1458.     2,  /* eob_sym */

  1459.     33, /* esc_sym */

  1460.     /* run table */

  1461.     {1,  1,  0,  2,  1,  2,  1,  3,  3,  1,  1,  4,  4,  2,  2,  1,

  1462.      1,  5,  5,  6,  1,  6,  1,  7,  7,  3,  3,  2,  8,  2,  8,  1,

  1463.      1,  0,  9,  9,  1,  1, 10,  4, 10,  4, 11, 11,  2,  1,  2,  1,

  1464.     12, 12,  3,  3,  1,  1, 13,  5,  5, 13, 14,  1,  1, 14,  2,  2,

  1465.      6,  6, 15,  1,  1, 15, 16,  4,  7, 16,  4,  7,  1,  1,  3,  3,

  1466.      8,  8,  2,  2,  1,  1, 17, 17,  1,  1, 18, 18,  5,  5,  2,  2,

  1467.      1,  1,  9, 19,  9, 19, 20,  3,  3, 20,  1, 10, 21,  1, 10,  4,

  1468.      4, 21, 22,  6,  6, 22,  1,  1, 23, 24,  2,  2, 23, 24, 11,  1,

  1469.      1, 11,  7, 25,  7,  1,  1, 25,  8,  8,  3, 26,  3,  1, 12,  2,

  1470.      2, 26,  1, 12,  5,  5, 27,  4,  1,  4,  1, 27, 28,  1, 28, 13,

  1471.      1, 13,  2, 29,  2,  1, 32,  6,  1, 30, 14, 29, 14,  6,  3, 31,

  1472.      3,  1, 30,  1, 32, 31, 33,  9, 33,  1,  1,  7,  9,  7,  2,  2,

  1473.      1,  1,  4, 36, 34,  4,  5, 10, 10,  5, 34,  1,  1, 35,  8,  8,

  1474.     36,  3, 35,  1, 15,  3,  2,  1, 16, 15, 16,  2, 37,  1, 37,  1,

  1475.      1,  1,  6,  6, 38,  1, 38, 11,  1, 39, 39, 40, 11,  2, 41,  4,

  1476.     40,  1,  2,  4,  1,  1,  1, 41,  3,  1,  3,  1,  5,  7,  5,  7},

  1477. 

  1478.     /* value table */

  1479.     { 1,  -1,   0,   1,   2,  -1,  -2,   1,  -1,   3,  -3,   1,  -1,   2,  -2,   4,

  1480.      -4,   1,  -1,   1,   5,  -1,  -5,   1,  -1,   2,  -2,   3,   1,  -3,  -1,   6,

  1481.      -6,   0,   1,  -1,   7,  -7,   1,   2,  -1,  -2,   1,  -1,   4,   8,  -4,  -8,

  1482.       1,  -1,   3,  -3,   9,  -9,   1,   2,  -2,  -1,   1,  10, -10,  -1,   5,  -5,

  1483.       2,  -2,   1,  11, -11,  -1,   1,   3,   2,  -1,  -3,  -2,  12, -12,   4,  -4,

  1484.       2,  -2,  -6,   6,  13, -13,   1,  -1,  14, -14,   1,  -1,   3,  -3,   7,  -7,

  1485.      15, -15,   2,   1,  -2,  -1,   1,   5,  -5,  -1, -16,   2,   1,  16,  -2,   4,

  1486.      -4,  -1,   1,   3,  -3,  -1,  17, -17,   1,   1,  -8,   8,  -1,  -1,   2,  18,

  1487.     -18,  -2,   3,   1,  -3,  19, -19,  -1,   3,  -3,   6,   1,  -6,  20,   2,   9,

  1488.      -9,  -1, -20,  -2,   4,  -4,   1,  -5,  21,   5, -21,  -1,   1, -22,  -1,   2,

  1489.      22,  -2,  10,   1, -10,  23,   1,   4, -23,   1,   2,  -1,  -2,  -4,  -7,   1,

  1490.       7, -24,  -1,  24,  -1,  -1,   1,   3,  -1, -25,  25,   4,  -3,  -4,  11, -11,

  1491.      26, -26,   6,   1,   1,  -6,  -5,  -3,   3,   5,  -1, -27,  27,   1,   4,  -4,

  1492.      -1,  -8,  -1,  28,   2,   8, -12, -28,  -2,  -2,   2,  12,  -1,  29,   1, -29,

  1493.      30, -30,   5,  -5,   1, -31,  -1,   3,  31,  -1,   1,   1,  -3, -13,   1,  -7,

  1494.      -1, -32,  13,   7,  32,  33, -33,  -1,  -9, -34,   9,  34,  -6,   5,   6,  -5}

  1495. },{

  1496.     /* MapTab6 */

  1497.     2,  /* eob_sym */

  1498.     13, /* esc_sym */

  1499.     /* run table */

  1500.     {1,  1,  0,  1,  1,  2,  2,  1,  1,  3,  3,  1,  1,  0,  2,  2,

  1501.      4,  1,  4,  1,  1,  1,  5,  5,  1,  1,  6,  6,  2,  2,  1,  1,

  1502.      3,  3,  7,  7,  1,  1,  8,  8,  1,  1,  2,  2,  1,  9,  1,  9,

  1503.      4,  4, 10,  1,  1, 10,  1,  1, 11, 11,  3,  3,  1,  2,  1,  2,

  1504.      1,  1, 12, 12,  5,  5,  1,  1, 13,  1,  1, 13,  2,  2,  1,  1,

  1505.      6,  6,  1,  1,  4, 14,  4, 14,  3,  1,  3,  1,  1,  1, 15,  7,

  1506.     15,  2,  2,  7,  1,  1,  1,  8,  1,  8, 16, 16,  1,  1,  1,  1,

  1507.      2,  1,  1,  2,  1,  1,  3,  5,  5,  3,  4,  1,  1,  4,  1,  1,

  1508.     17, 17,  9,  1,  1,  9,  2,  2,  1,  1, 10, 10,  1,  6,  1,  1,

  1509.      6, 18,  1,  1, 18,  1,  1,  1,  2,  2,  3,  1,  3,  1,  1,  1,

  1510.      4,  1, 19,  1, 19,  7,  1,  1, 20,  1,  4, 20,  1,  7, 11,  2,

  1511.      1, 11, 21,  2,  8,  5,  1,  8,  1,  5, 21,  1,  1,  1, 22,  1,

  1512.      1, 22,  1,  1,  3,  3,  1, 23,  2, 12, 24,  1,  1,  2,  1,  1,

  1513.     12, 23,  1,  1, 24,  1,  1,  1,  4,  1,  1,  1,  2,  1,  6,  6,

  1514.      4,  2,  1,  1,  1,  1,  1,  1,  1, 14, 13,  3,  1, 25,  9, 25,

  1515.     14,  1,  9,  3, 13,  1,  1,  1,  1,  1, 10,  1,  1,  2, 10,  2},

  1516. 

  1517.     /* value table */

  1518.     {-20,  -1,   0,   2,  -2,   1,  -1,   3,  -3,   1,  -1,   4,  -4,   0,   2,  -2,

  1519.        1,   5,  -1,  -5,   6,  -6,   1,  -1,   7,  -7,   1,  -1,   3,  -3,   8,  -8,

  1520.        2,  -2,   1,  -1,   9,  -9,   1,  -1,  10, -10,   4,  -4,  11,   1, -11,  -1,

  1521.        2,  -2,   1,  12, -12,  -1,  13, -13,   1,  -1,   3,  -3,  14,   5, -14,  -5,

  1522.      -15,  15,  -1,   1,   2,  -2,  16, -16,   1,  17, -17,  -1,   6,  -6,  18, -18,

  1523.        2,  -2, -19,  19,  -3,   1,   3,  -1,   4,  20,  -4,   1, -21,  21,   1,   2,

  1524.       -1,  -7,   7,  -2,  22, -22,  23,   2, -23,  -2,   1,  -1, -24,  24, -25,  25,

  1525.       -8, -26,  26,   8, -27,  27,   5,   3,  -3,  -5,  -4,  28, -28,   4,  29, -29,

  1526.        1,  -1,  -2, -30,  30,   2,   9,  -9, -31,  31,   2,  -2, -32,   3,  32, -33,

  1527.       -3,   1,  33, -34,  -1,  34, -35,  35, -10,  10,  -6,  36,   6, -36,  37, -37,

  1528.       -5,  38,   1, -38,  -1,   3,  39, -39,  -1,  40,   5,   1, -40,  -3,   2, -11,

  1529.      -41,  -2,   1,  11,  -3,  -4,  41,   3,  42,   4,  -1, -43, -42,  43,   1, -44,

  1530.       45,  -1,  44, -45,  -7,   7, -46,   1, -12,   2,   1, -47,  46,  12,  47,  48,

  1531.       -2,  -1, -48,  49,  -1, -50, -49,  50,  -6, -51,  51,  52, -13,  53,  -4,   4,

  1532.        6,  13, -53, -52, -54,  55,  54, -55, -56,  -2,   2,  -8,  56,   1,  -3,  -1,

  1533.        2,  58,   3,   8,  -2,  57, -58, -60, -59, -57,  -3,  60,  59, -14,   3,  14}

  1534. },{

  1535.     /* MapTab7 */

  1536.     2,  /* eob_sym */

  1537.     38, /* esc_sym */

  1538.     /* run table */

  1539.     {1,  1,  0,  2,  2,  1,  1,  3,  3,  4,  4,  5,  5,  1,  1,  6,

  1540.      6,  2,  2,  7,  7,  8,  8,  1,  1,  3,  3,  9,  9, 10, 10,  1,

  1541.      1,  2,  2,  4,  4, 11,  0, 11, 12, 12, 13, 13,  1,  1,  5,  5,

  1542.     14, 14, 15, 16, 15, 16,  3,  3,  1,  6,  1,  6,  2,  2,  7,  7,

  1543.      8,  8, 17, 17,  1,  1,  4,  4, 18, 18,  2,  2,  1, 19,  1, 20,

  1544.     19, 20, 21, 21,  3,  3, 22, 22,  5,  5, 24,  1,  1, 23,  9, 23,

  1545.     24,  9,  2,  2, 10,  1,  1, 10,  6,  6, 25,  4,  4, 25,  7,  7,

  1546.     26,  8,  1,  8,  3,  1, 26,  3, 11, 11, 27, 27,  2, 28,  1,  2,

  1547.     28,  1, 12, 12,  5,  5, 29, 13, 13, 29, 32,  1,  1, 33, 31, 30,

  1548.     32,  4, 30, 33,  4, 31,  3, 14,  1,  1,  3, 34, 34,  2,  2, 14,

  1549.      6,  6, 35, 36, 35, 36,  1, 15,  1, 16, 16, 15,  7,  9,  7,  9,

  1550.     37,  8,  8, 37,  1,  1, 39,  2, 38, 39,  2, 40,  5, 38, 40,  5,

  1551.      3,  3,  4,  4, 10, 10,  1,  1,  1,  1, 41,  2, 41,  2,  6,  6,

  1552.      1,  1, 11, 42, 11, 43,  3, 42,  3, 17,  4, 43,  1, 17,  7,  1,

  1553.      8, 44,  4,  7, 44,  5,  8,  2,  5,  1,  2, 48, 45,  1, 12, 45,

  1554.     12, 48, 13, 13,  1,  9,  9, 46,  1, 46, 47, 47, 49, 18, 18, 49},

  1555. 

  1556.     /* value table */

  1557.     { 1,  -1,   0,   1,  -1,   2,  -2,   1,  -1,   1,  -1,   1,  -1,   3,  -3,   1,

  1558.      -1,  -2,   2,   1,  -1,   1,  -1,   4,  -4,  -2,   2,   1,  -1,   1,  -1,   5,

  1559.      -5,  -3,   3,   2,  -2,   1,   0,  -1,   1,  -1,   1,  -1,   6,  -6,   2,  -2,

  1560.       1,  -1,   1,   1,  -1,  -1,  -3,   3,   7,   2,  -7,  -2,  -4,   4,   2,  -2,

  1561.       2,  -2,   1,  -1,   8,  -8,   3,  -3,   1,  -1,  -5,   5,   9,   1,  -9,   1,

  1562.      -1,  -1,   1,  -1,  -4,   4,   1,  -1,   3,  -3,   1, -10,  10,   1,   2,  -1,

  1563.      -1,  -2,   6,  -6,   2,  11, -11,  -2,   3,  -3,   1,  -4,   4,  -1,   3,  -3,

  1564.       1,   3,  12,  -3,  -5, -12,  -1,   5,   2,  -2,   1,  -1,  -7,   1,  13,   7,

  1565.      -1, -13,   2,  -2,   4,  -4,   1,   2,  -2,  -1,   1,  14, -14,   1,   1,   1,

  1566.      -1,  -5,  -1,  -1,   5,  -1,  -6,   2, -15,  15,   6,   1,  -1,  -8,   8,  -2,

  1567.      -4,   4,   1,   1,  -1,  -1,  16,   2, -16,  -2,   2,  -2,   4,   3,  -4,  -3,

  1568.      -1,  -4,   4,   1, -17,  17,  -1,  -9,   1,   1,   9,   1,  -5,  -1,  -1,   5,

  1569.      -7,   7,   6,  -6,   3,  -3,  18, -18,  19, -19,   1, -10,  -1,  10,  -5,   5,

  1570.      20, -20,  -3,   1,   3,   1,   8,  -1,  -8,   2,   7,  -1, -21,  -2,   5,  21,

  1571.       5,  -1,  -7,  -5,   1,  -6,  -5, -11,   6,  22,  11,   1,   1, -22,  -3,  -1,

  1572.       3,  -1,   3,  -3, -23,   4,  -4,   1,  23,  -1,   1,  -1,   1,  -2,   2,  -1}

  1573. },{

  1574.     /* MapTab8 */

  1575.     4,  /* eob_sym */

  1576.     11, /* esc_sym */

  1577.     /* run table */

  1578.     {1,  1,  1,  1,  0,  2,  2,  1,  1,  3,  3,  0,  1,  1,  2,  2,

  1579.      4,  4,  1,  1,  5,  5,  1,  1,  2,  2,  3,  3,  6,  6,  1,  1,

  1580.      7,  7,  8,  1,  8,  2,  2,  1,  4,  4,  1,  3,  1,  3,  9,  9,

  1581.      2,  2,  1,  5,  1,  5, 10, 10,  1,  1, 11, 11,  3,  6,  3,  4,

  1582.      4,  6,  2,  2,  1, 12,  1, 12,  7, 13,  7, 13,  1,  1,  8,  8,

  1583.      2,  2, 14, 14, 16, 15, 16,  5,  5,  1,  3, 15,  1,  3,  4,  4,

  1584.      1,  1, 17, 17,  2,  2,  6,  6,  1, 18,  1, 18, 22, 21, 22, 21,

  1585.     25, 24, 25, 19,  9, 20,  9, 23, 19, 24, 20,  3, 23,  7,  3,  1,

  1586.      1,  7, 28, 26, 29,  5, 28, 26,  5,  8, 29,  4,  8, 27,  2,  2,

  1587.      4, 27,  1,  1, 10, 36, 10, 33, 33, 36, 30,  1, 32, 32,  1, 30,

  1588.      6, 31, 31, 35,  3,  6, 11, 11,  3,  2, 35,  2, 34,  1, 34,  1,

  1589.     37, 37, 12,  7, 12,  5, 41,  5,  4,  7,  1,  8, 13,  4,  1, 41,

  1590.     13, 38,  8, 38,  9,  1, 40, 40,  9,  1, 39,  2,  2, 49, 39, 42,

  1591.      3,  3, 14, 16, 49, 14, 16, 42, 43, 43,  6,  6, 15,  1,  1, 15,

  1592.     44, 44,  1,  1, 50, 48,  4,  5,  4,  7,  5,  2, 10, 10, 48,  7,

  1593.     50, 45,  2,  1, 45,  8,  8,  1, 46, 46,  3, 47, 47,  3,  1,  1},

  1594. 

  1595.     /* value table */

  1596.     { 1,  -1,   2,  -2,   0,   1,  -1,   3,  -3,   1,  -1,   0,   4,  -4,   2,  -2,

  1597.       1,  -1,   5,  -5,   1,  -1,   6,  -6,   3,  -3,   2,  -2,   1,  -1,   7,  -7,

  1598.       1,  -1,   1,   8,  -1,   4,  -4,  -8,   2,  -2,   9,   3,  -9,  -3,   1,  -1,

  1599.       5,  -5,  10,   2, -10,  -2,   1,  -1,  11, -11,   1,  -1,  -4,   2,   4,   3,

  1600.      -3,  -2,   6,  -6,  12,   1, -12,  -1,   2,   1,  -2,  -1,  13, -13,   2,  -2,

  1601.       7,  -7,   1,  -1,   1,   1,  -1,   3,  -3,  14,   5,  -1, -14,  -5,   4,  -4,

  1602.      15, -15,   1,  -1,   8,  -8,  -3,   3,  16,   1, -16,  -1,   1,   1,  -1,  -1,

  1603.       1,   1,  -1,   1,   2,   1,  -2,   1,  -1,  -1,  -1,   6,  -1,   3,  -6,  17,

  1604.     -17,  -3,   1,   1,   1,   4,  -1,  -1,  -4,   3,  -1,   5,  -3,  -1,  -9,   9,

  1605.      -5,   1,  18, -18,   2,   1,  -2,   1,  -1,  -1,   1,  19,  -1,   1, -19,  -1,

  1606.       4,   1,  -1,   1,   7,  -4,  -2,   2,  -7,  10,  -1, -10,   1,  20,  -1, -20,

  1607.       1,  -1,   2,   4,  -2,   5,   1,  -5,   6,  -4,  21,   4,   2,  -6, -21,  -1,

  1608.      -2,   1,  -4,  -1,  -3,  22,  -1,   1,   3, -22,  -1,  11, -11,   1,   1,   1,

  1609.       8,  -8,   2,   2,  -1,  -2,  -2,  -1,   1,  -1,  -5,   5,   2,  23, -23,  -2,

  1610.       1,  -1,  24, -24,  -1,  -1,   7,   6,  -7,   5,  -6,  12,  -3,   3,   1,  -5,

  1611.       1,   1, -12,  25,  -1,  -5,   5, -25,  -1,   1,   9,   1,  -1,  -9,  26, -26}

  1612. }

  1613. };