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