Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

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