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