GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/ivi.c Lines: 415 611 67.9 %
Date: 2020-07-13 04:22:34 Branches: 250 440 56.8 %

Line Branch Exec Source
1
/*
2
 * common functions for Indeo Video Interactive codecs (Indeo4 and Indeo5)
3
 *
4
 * Copyright (c) 2009 Maxim Poliakovski
5
 *
6
 * This file is part of FFmpeg.
7
 *
8
 * FFmpeg is free software; you can redistribute it and/or
9
 * modify it under the terms of the GNU Lesser General Public
10
 * License as published by the Free Software Foundation; either
11
 * version 2.1 of the License, or (at your option) any later version.
12
 *
13
 * FFmpeg is distributed in the hope that it will be useful,
14
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16
 * Lesser General Public License for more details.
17
 *
18
 * You should have received a copy of the GNU Lesser General Public
19
 * License along with FFmpeg; if not, write to the Free Software
20
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21
 */
22
23
/**
24
 * @file
25
 * This file contains functions and data shared by both Indeo4 and
26
 * Indeo5 decoders.
27
 */
28
29
#include <inttypes.h>
30
31
#include "libavutil/attributes.h"
32
#include "libavutil/imgutils.h"
33
34
#define BITSTREAM_READER_LE
35
#include "avcodec.h"
36
#include "get_bits.h"
37
#include "internal.h"
38
#include "mathops.h"
39
#include "ivi.h"
40
#include "ivi_dsp.h"
41
42
/**
43
 * These are 2x8 predefined Huffman codebooks for coding macroblock/block
44
 * signals. They are specified using "huffman descriptors" in order to
45
 * avoid huge static tables. The decoding tables will be generated at
46
 * startup from these descriptors.
47
 */
48
/** static macroblock huffman tables */
49
static const IVIHuffDesc ivi_mb_huff_desc[8] = {
50
    {8,  {0, 4, 5, 4, 4, 4, 6, 6}},
51
    {12, {0, 2, 2, 3, 3, 3, 3, 5, 3, 2, 2, 2}},
52
    {12, {0, 2, 3, 4, 3, 3, 3, 3, 4, 3, 2, 2}},
53
    {12, {0, 3, 4, 4, 3, 3, 3, 3, 3, 2, 2, 2}},
54
    {13, {0, 4, 4, 3, 3, 3, 3, 2, 3, 3, 2, 1, 1}},
55
    {9,  {0, 4, 4, 4, 4, 3, 3, 3, 2}},
56
    {10, {0, 4, 4, 4, 4, 3, 3, 2, 2, 2}},
57
    {12, {0, 4, 4, 4, 3, 3, 2, 3, 2, 2, 2, 2}}
58
};
59
60
/** static block huffman tables */
61
static const IVIHuffDesc ivi_blk_huff_desc[8] = {
62
    {10, {1, 2, 3, 4, 4, 7, 5, 5, 4, 1}},
63
    {11, {2, 3, 4, 4, 4, 7, 5, 4, 3, 3, 2}},
64
    {12, {2, 4, 5, 5, 5, 5, 6, 4, 4, 3, 1, 1}},
65
    {13, {3, 3, 4, 4, 5, 6, 6, 4, 4, 3, 2, 1, 1}},
66
    {11, {3, 4, 4, 5, 5, 5, 6, 5, 4, 2, 2}},
67
    {13, {3, 4, 5, 5, 5, 5, 6, 4, 3, 3, 2, 1, 1}},
68
    {13, {3, 4, 5, 5, 5, 6, 5, 4, 3, 3, 2, 1, 1}},
69
    {9,  {3, 4, 4, 5, 5, 5, 6, 5, 5}}
70
};
71
72
static VLC ivi_mb_vlc_tabs [8]; ///< static macroblock Huffman tables
73
static VLC ivi_blk_vlc_tabs[8]; ///< static block Huffman tables
74
75
typedef void (*ivi_mc_func) (int16_t *buf, const int16_t *ref_buf,
76
                             ptrdiff_t pitch, int mc_type);
77
typedef void (*ivi_mc_avg_func) (int16_t *buf, const int16_t *ref_buf1,
78
                                 const int16_t *ref_buf2,
79
                                 ptrdiff_t pitch, int mc_type, int mc_type2);
80
81
142082
static int ivi_mc(const IVIBandDesc *band, ivi_mc_func mc, ivi_mc_avg_func mc_avg,
82
                  int offs, int mv_x, int mv_y, int mv_x2, int mv_y2,
83
                  int mc_type, int mc_type2)
84
{
85
142082
    int ref_offs = offs + mv_y * band->pitch + mv_x;
86
142082
    int buf_size = band->pitch * band->aheight;
87
142082
    int min_size = band->pitch * (band->blk_size - 1) + band->blk_size;
88
142082
    int ref_size = (mc_type > 1) * band->pitch + (mc_type & 1);
89
90
142082
    if (mc_type != -1) {
91

142082
        av_assert0(offs >= 0 && ref_offs >= 0 && band->ref_buf);
92
142082
        av_assert0(buf_size - min_size >= offs);
93
142082
        av_assert0(buf_size - min_size - ref_size >= ref_offs);
94
    }
95
96
142082
    if (mc_type2 == -1) {
97
142082
        mc(band->buf + offs, band->ref_buf + ref_offs, band->pitch, mc_type);
98
    } else {
99
        int ref_offs2 = offs + mv_y2 * band->pitch + mv_x2;
100
        int ref_size2 = (mc_type2 > 1) * band->pitch + (mc_type2 & 1);
101
        if (offs < 0 || ref_offs2 < 0 || !band->b_ref_buf)
102
            return AVERROR_INVALIDDATA;
103
        if (buf_size - min_size - ref_size2 < ref_offs2)
104
            return AVERROR_INVALIDDATA;
105
106
        if (mc_type == -1)
107
            mc(band->buf + offs, band->b_ref_buf + ref_offs2,
108
               band->pitch, mc_type2);
109
        else
110
            mc_avg(band->buf + offs, band->ref_buf + ref_offs,
111
                   band->b_ref_buf + ref_offs2, band->pitch,
112
                   mc_type, mc_type2);
113
    }
114
115
142082
    return 0;
116
}
117
118
/**
119
 *  Reverse "nbits" bits of the value "val" and return the result
120
 *  in the least significant bits.
121
 */
122
32656
static uint16_t inv_bits(uint16_t val, int nbits)
123
{
124
    uint16_t res;
125
126
32656
    if (nbits <= 8) {
127
5451
        res = ff_reverse[val] >> (8 - nbits);
128
    } else
129
27205
        res = ((ff_reverse[val & 0xFF] << 8) +
130
27205
               (ff_reverse[val >> 8])) >> (16 - nbits);
131
132
32656
    return res;
133
}
134
135
/*
136
 *  Generate a huffman codebook from the given descriptor
137
 *  and convert it into the FFmpeg VLC table.
138
 *
139
 *  @param[in]   cb    pointer to codebook descriptor
140
 *  @param[out]  vlc   where to place the generated VLC table
141
 *  @param[in]   flag  flag: 1 - for static or 0 for dynamic tables
142
 *  @return     result code: 0 - OK, -1 = error (invalid codebook descriptor)
143
 */
144
147
static int ivi_create_huff_from_desc(const IVIHuffDesc *cb, VLC *vlc, int flag)
145
{
146
    int         pos, i, j, codes_per_row, prefix, not_last_row;
147
    uint16_t    codewords[256]; /* FIXME: move this temporal storage out? */
148
    uint8_t     bits[256];
149
150
147
    pos = 0; /* current position = 0 */
151
152
1574
    for (i = 0; i < cb->num_rows; i++) {
153
1427
        codes_per_row = 1 << cb->xbits[i];
154
1427
        not_last_row  = (i != cb->num_rows - 1);
155
1427
        prefix        = ((1 << i) - 1) << (cb->xbits[i] + not_last_row);
156
157
34083
        for (j = 0; j < codes_per_row; j++) {
158
32695
            if (pos >= 256) /* Some Indeo5 codebooks can have more than 256 */
159
39
                break;      /* elements, but only 256 codes are allowed! */
160
161
32656
            bits[pos] = i + cb->xbits[i] + not_last_row;
162
32656
            if (bits[pos] > IVI_VLC_BITS)
163
                return AVERROR_INVALIDDATA; /* invalid descriptor */
164
165
32656
            codewords[pos] = inv_bits((prefix | j), bits[pos]);
166
32656
            if (!bits[pos])
167
                bits[pos] = 1;
168
169
32656
            pos++;
170
        }//for j
171
    }//for i
172
173
    /* number of codewords = pos */
174
147
    return init_vlc(vlc, IVI_VLC_BITS, pos, bits, 1, 1, codewords, 2, 2,
175
                    (flag ? INIT_VLC_USE_NEW_STATIC : 0) | INIT_VLC_LE);
176
}
177
178
4
av_cold void ff_ivi_init_static_vlc(void)
179
{
180
    int i;
181
    static VLC_TYPE table_data[8192 * 16][2];
182
    static int initialized_vlcs = 0;
183
184
4
    if (initialized_vlcs)
185
2
        return;
186
18
    for (i = 0; i < 8; i++) {
187
16
        ivi_mb_vlc_tabs[i].table = table_data + i * 2 * 8192;
188
16
        ivi_mb_vlc_tabs[i].table_allocated = 8192;
189
16
        ivi_create_huff_from_desc(&ivi_mb_huff_desc[i],
190
                                  &ivi_mb_vlc_tabs[i], 1);
191
16
        ivi_blk_vlc_tabs[i].table = table_data + (i * 2 + 1) * 8192;
192
16
        ivi_blk_vlc_tabs[i].table_allocated = 8192;
193
16
        ivi_create_huff_from_desc(&ivi_blk_huff_desc[i],
194
                                  &ivi_blk_vlc_tabs[i], 1);
195
    }
196
2
    initialized_vlcs = 1;
197
}
198
199
/*
200
 *  Copy huffman codebook descriptors.
201
 *
202
 *  @param[out]  dst  ptr to the destination descriptor
203
 *  @param[in]   src  ptr to the source descriptor
204
 */
205
115
static void ivi_huff_desc_copy(IVIHuffDesc *dst, const IVIHuffDesc *src)
206
{
207
115
    dst->num_rows = src->num_rows;
208
115
    memcpy(dst->xbits, src->xbits, src->num_rows);
209
115
}
210
211
/*
212
 *  Compare two huffman codebook descriptors.
213
 *
214
 *  @param[in]  desc1  ptr to the 1st descriptor to compare
215
 *  @param[in]  desc2  ptr to the 2nd descriptor to compare
216
 *  @return         comparison result: 0 - equal, 1 - not equal
217
 */
218
215
static int ivi_huff_desc_cmp(const IVIHuffDesc *desc1,
219
                             const IVIHuffDesc *desc2)
220
{
221
335
    return desc1->num_rows != desc2->num_rows ||
222
120
           memcmp(desc1->xbits, desc2->xbits, desc1->num_rows);
223
}
224
225
1035
int ff_ivi_dec_huff_desc(GetBitContext *gb, int desc_coded, int which_tab,
226
                         IVIHuffTab *huff_tab, AVCodecContext *avctx)
227
{
228
    int i, result;
229
    IVIHuffDesc new_huff;
230
231
1035
    if (!desc_coded) {
232
        /* select default table */
233
101
        huff_tab->tab = (which_tab) ? &ivi_blk_vlc_tabs[7]
234
101
                                    : &ivi_mb_vlc_tabs [7];
235
101
        return 0;
236
    }
237
238
934
    huff_tab->tab_sel = get_bits(gb, 3);
239
934
    if (huff_tab->tab_sel == 7) {
240
        /* custom huffman table (explicitly encoded) */
241
215
        new_huff.num_rows = get_bits(gb, 4);
242
215
        if (!new_huff.num_rows) {
243
            av_log(avctx, AV_LOG_ERROR, "Empty custom Huffman table!\n");
244
            return AVERROR_INVALIDDATA;
245
        }
246
247
2107
        for (i = 0; i < new_huff.num_rows; i++)
248
1892
            new_huff.xbits[i] = get_bits(gb, 4);
249
250
        /* Have we got the same custom table? Rebuild if not. */
251

215
        if (ivi_huff_desc_cmp(&new_huff, &huff_tab->cust_desc) || !huff_tab->cust_tab.table) {
252
115
            ivi_huff_desc_copy(&huff_tab->cust_desc, &new_huff);
253
254
115
            if (huff_tab->cust_tab.table)
255
111
                ff_free_vlc(&huff_tab->cust_tab);
256
115
            result = ivi_create_huff_from_desc(&huff_tab->cust_desc,
257
                    &huff_tab->cust_tab, 0);
258
115
            if (result) {
259
                // reset faulty description
260
                huff_tab->cust_desc.num_rows = 0;
261
                av_log(avctx, AV_LOG_ERROR,
262
                       "Error while initializing custom vlc table!\n");
263
                return result;
264
            }
265
        }
266
215
        huff_tab->tab = &huff_tab->cust_tab;
267
    } else {
268
        /* select one of predefined tables */
269
719
        huff_tab->tab = (which_tab) ? &ivi_blk_vlc_tabs[huff_tab->tab_sel]
270
719
            : &ivi_mb_vlc_tabs [huff_tab->tab_sel];
271
    }
272
273
934
    return 0;
274
}
275
276
/*
277
 *  Free planes, bands and macroblocks buffers.
278
 *
279
 *  @param[in]  planes  pointer to the array of the plane descriptors
280
 */
281
8
static av_cold void ivi_free_buffers(IVIPlaneDesc *planes)
282
{
283
    int p, b, t;
284
285
32
    for (p = 0; p < 3; p++) {
286
24
        if (planes[p].bands)
287
24
        for (b = 0; b < planes[p].num_bands; b++) {
288
12
            av_freep(&planes[p].bands[b].bufs[0]);
289
12
            av_freep(&planes[p].bands[b].bufs[1]);
290
12
            av_freep(&planes[p].bands[b].bufs[2]);
291
12
            av_freep(&planes[p].bands[b].bufs[3]);
292
293
12
            if (planes[p].bands[b].blk_vlc.cust_tab.table)
294
3
                ff_free_vlc(&planes[p].bands[b].blk_vlc.cust_tab);
295
18
            for (t = 0; t < planes[p].bands[b].num_tiles; t++)
296
6
                av_freep(&planes[p].bands[b].tiles[t].mbs);
297
12
            av_freep(&planes[p].bands[b].tiles);
298
        }
299
24
        av_freep(&planes[p].bands);
300
24
        planes[p].num_bands = 0;
301
    }
302
8
}
303
304
4
av_cold int ff_ivi_init_planes(AVCodecContext *avctx, IVIPlaneDesc *planes, const IVIPicConfig *cfg,
305
                               int is_indeo4)
306
{
307
    int p, b;
308
    uint32_t b_width, b_height, align_fac, width_aligned,
309
             height_aligned, buf_size;
310
    IVIBandDesc *band;
311
312
4
    ivi_free_buffers(planes);
313
314
4
    if (av_image_check_size2(cfg->pic_width, cfg->pic_height, avctx->max_pixels, AV_PIX_FMT_YUV410P, 0, avctx) < 0 ||
315

4
        cfg->luma_bands < 1 || cfg->chroma_bands < 1)
316
        return AVERROR_INVALIDDATA;
317
318
    /* fill in the descriptor of the luminance plane */
319
4
    planes[0].width     = cfg->pic_width;
320
4
    planes[0].height    = cfg->pic_height;
321
4
    planes[0].num_bands = cfg->luma_bands;
322
323
    /* fill in the descriptors of the chrominance planes */
324
4
    planes[1].width     = planes[2].width     = (cfg->pic_width  + 3) >> 2;
325
4
    planes[1].height    = planes[2].height    = (cfg->pic_height + 3) >> 2;
326
4
    planes[1].num_bands = planes[2].num_bands = cfg->chroma_bands;
327
328
16
    for (p = 0; p < 3; p++) {
329
12
        planes[p].bands = av_mallocz_array(planes[p].num_bands, sizeof(IVIBandDesc));
330
12
        if (!planes[p].bands)
331
            return AVERROR(ENOMEM);
332
333
        /* select band dimensions: if there is only one band then it
334
         *  has the full size, if there are several bands each of them
335
         *  has only half size */
336
36
        b_width  = planes[p].num_bands == 1 ? planes[p].width
337
12
                                            : (planes[p].width  + 1) >> 1;
338
36
        b_height = planes[p].num_bands == 1 ? planes[p].height
339
12
                                            : (planes[p].height + 1) >> 1;
340
341
        /* luma   band buffers will be aligned on 16x16 (max macroblock size) */
342
        /* chroma band buffers will be aligned on   8x8 (max macroblock size) */
343
12
        align_fac       = p ? 8 : 16;
344
12
        width_aligned   = FFALIGN(b_width , align_fac);
345
12
        height_aligned  = FFALIGN(b_height, align_fac);
346
12
        buf_size        = width_aligned * height_aligned * sizeof(int16_t);
347
348
24
        for (b = 0; b < planes[p].num_bands; b++) {
349
12
            band = &planes[p].bands[b]; /* select appropriate plane/band */
350
12
            band->plane    = p;
351
12
            band->band_num = b;
352
12
            band->width    = b_width;
353
12
            band->height   = b_height;
354
12
            band->pitch    = width_aligned;
355
12
            band->aheight  = height_aligned;
356


12
            av_assert0(!band->bufs[0] && !band->bufs[1] &&
357
                       !band->bufs[2] && !band->bufs[3]);
358
12
            band->bufsize  = buf_size/2;
359
12
            av_assert0(buf_size % 2 == 0);
360
361
            /* reset custom vlc */
362
12
            planes[p].bands[0].blk_vlc.cust_desc.num_rows = 0;
363
        }
364
    }
365
366
4
    return 0;
367
}
368
369
6
static int ivi_init_tiles(const IVIBandDesc *band, IVITile *ref_tile,
370
                          int p, int b, int t_height, int t_width)
371
{
372
    int x, y;
373
6
    IVITile *tile = band->tiles;
374
375
12
    for (y = 0; y < band->height; y += t_height) {
376
12
        for (x = 0; x < band->width; x += t_width) {
377
6
            tile->xpos     = x;
378
6
            tile->ypos     = y;
379
6
            tile->mb_size  = band->mb_size;
380
6
            tile->width    = FFMIN(band->width - x,  t_width);
381
6
            tile->height   = FFMIN(band->height - y, t_height);
382
6
            tile->is_empty = tile->data_size = 0;
383
            /* calculate number of macroblocks */
384
6
            tile->num_MBs  = IVI_MBs_PER_TILE(tile->width, tile->height,
385
                                              band->mb_size);
386
387
6
            av_freep(&tile->mbs);
388
6
            tile->mbs = av_mallocz_array(tile->num_MBs, sizeof(IVIMbInfo));
389
6
            if (!tile->mbs)
390
                return AVERROR(ENOMEM);
391
392
6
            tile->ref_mbs = 0;
393

6
            if (p || b) {
394
4
                if (tile->num_MBs != ref_tile->num_MBs) {
395
                    av_log(NULL, AV_LOG_DEBUG, "ref_tile mismatch\n");
396
                    return AVERROR_INVALIDDATA;
397
                }
398
4
                tile->ref_mbs = ref_tile->mbs;
399
4
                ref_tile++;
400
            }
401
6
            tile++;
402
        }
403
    }
404
405
6
    return 0;
406
}
407
408
2
av_cold int ff_ivi_init_tiles(IVIPlaneDesc *planes,
409
                              int tile_width, int tile_height)
410
{
411
    int p, b, x_tiles, y_tiles, t_width, t_height, ret;
412
    IVIBandDesc *band;
413
414
8
    for (p = 0; p < 3; p++) {
415
6
        t_width  = !p ? tile_width  : (tile_width  + 3) >> 2;
416
6
        t_height = !p ? tile_height : (tile_height + 3) >> 2;
417
418

6
        if (!p && planes[0].num_bands == 4) {
419
            if (t_width % 2 || t_height % 2) {
420
                avpriv_request_sample(NULL, "Odd tiles");
421
                return AVERROR_PATCHWELCOME;
422
            }
423
            t_width  >>= 1;
424
            t_height >>= 1;
425
        }
426

6
        if(t_width<=0 || t_height<=0)
427
            return AVERROR(EINVAL);
428
429
12
        for (b = 0; b < planes[p].num_bands; b++) {
430
6
            band = &planes[p].bands[b];
431
432
6
            if (band->tiles) {
433
                int t;
434
                for (t = 0; t < band->num_tiles; t++) {
435
                    av_freep(&band->tiles[t].mbs);
436
                }
437
            }
438
439
6
            x_tiles = IVI_NUM_TILES(band->width, t_width);
440
6
            y_tiles = IVI_NUM_TILES(band->height, t_height);
441
6
            band->num_tiles = x_tiles * y_tiles;
442
443
6
            av_freep(&band->tiles);
444
6
            band->tiles = av_mallocz_array(band->num_tiles, sizeof(IVITile));
445
6
            if (!band->tiles)
446
                return AVERROR(ENOMEM);
447
448
            /* use the first luma band as reference for motion vectors
449
             * and quant */
450
6
            ret = ivi_init_tiles(band, planes[0].bands[0].tiles,
451
                                 p, b, t_height, t_width);
452
6
            if (ret < 0)
453
                return ret;
454
        }
455
    }
456
457
2
    return 0;
458
}
459
460
/*
461
 *  Decode size of the tile data.
462
 *  The size is stored as a variable-length field having the following format:
463
 *  if (tile_data_size < 255) than this field is only one byte long
464
 *  if (tile_data_size >= 255) than this field four is byte long: 0xFF X1 X2 X3
465
 *  where X1-X3 is size of the tile data
466
 *
467
 *  @param[in,out]  gb  the GetBit context
468
 *  @return     size of the tile data in bytes
469
 */
470
700
static int ivi_dec_tile_data_size(GetBitContext *gb)
471
{
472
    int    len;
473
474
700
    len = 0;
475
700
    if (get_bits1(gb)) {
476
700
        len = get_bits(gb, 8);
477
700
        if (len == 255)
478
447
            len = get_bits(gb, 24);
479
    }
480
481
    /* align the bitstream reader on the byte boundary */
482
700
    align_get_bits(gb);
483
484
700
    return len;
485
}
486
487
67284
static int ivi_dc_transform(const IVIBandDesc *band, int *prev_dc, int buf_offs,
488
                            int blk_size)
489
{
490
67284
    band->dc_transform(prev_dc, band->buf + buf_offs,
491
                       band->pitch, blk_size);
492
493
67284
    return 0;
494
}
495
496
197821
static int ivi_decode_coded_blocks(GetBitContext *gb, const IVIBandDesc *band,
497
                                   ivi_mc_func mc, ivi_mc_avg_func mc_avg,
498
                                   int mv_x, int mv_y,
499
                                   int mv_x2, int mv_y2,
500
                                   int *prev_dc, int is_intra,
501
                                   int mc_type, int mc_type2,
502
                                   uint32_t quant, int offs,
503
                                   AVCodecContext *avctx)
504
{
505
197821
    const uint16_t *base_tab  = is_intra ? band->intra_base : band->inter_base;
506
197821
    RVMapDesc *rvmap = band->rv_map;
507
    uint8_t col_flags[8];
508
    int32_t trvec[64];
509
197821
    uint32_t sym = 0, lo, hi, q;
510
    int pos, run, val;
511
197821
    int blk_size   = band->blk_size;
512
197821
    int num_coeffs = blk_size * blk_size;
513
197821
    int col_mask   = blk_size - 1;
514
197821
    int scan_pos   = -1;
515
197821
    int min_size   = band->pitch * (band->transform_size - 1) +
516
197821
                     band->transform_size;
517
197821
    int buf_size   = band->pitch * band->aheight - offs;
518
519
197821
    if (min_size > buf_size)
520
        return AVERROR_INVALIDDATA;
521
522
197821
    if (!band->scan) {
523
        av_log(avctx, AV_LOG_ERROR, "Scan pattern is not set.\n");
524
        return AVERROR_INVALIDDATA;
525
    }
526
527
    /* zero transform vector */
528
197821
    memset(trvec, 0, num_coeffs * sizeof(trvec[0]));
529
    /* zero column flags */
530
197821
    memset(col_flags, 0, sizeof(col_flags));
531
2016248
    while (scan_pos <= num_coeffs) {
532
2016248
        sym = get_vlc2(gb, band->blk_vlc.tab->table,
533
                       IVI_VLC_BITS, 1);
534
2016248
        if (sym == rvmap->eob_sym)
535
197820
            break; /* End of block */
536
537
        /* Escape - run/val explicitly coded using 3 vlc codes */
538
1818428
        if (sym == rvmap->esc_sym) {
539
14630
            run = get_vlc2(gb, band->blk_vlc.tab->table, IVI_VLC_BITS, 1) + 1;
540
14630
            lo  = get_vlc2(gb, band->blk_vlc.tab->table, IVI_VLC_BITS, 1);
541
14630
            hi  = get_vlc2(gb, band->blk_vlc.tab->table, IVI_VLC_BITS, 1);
542
            /* merge them and convert into signed val */
543
14630
            val = IVI_TOSIGNED((hi << 6) | lo);
544
        } else {
545
1803798
            if (sym >= 256U) {
546
                av_log(avctx, AV_LOG_ERROR, "Invalid sym encountered: %"PRIu32".\n", sym);
547
                return AVERROR_INVALIDDATA;
548
            }
549
1803798
            run = rvmap->runtab[sym];
550
1803798
            val = rvmap->valtab[sym];
551
        }
552
553
        /* de-zigzag and dequantize */
554
1818428
        scan_pos += run;
555

1818428
        if (scan_pos >= num_coeffs || scan_pos < 0)
556
            break;
557
1818427
        pos = band->scan[scan_pos];
558
559
        if (!val)
560
            ff_dlog(avctx, "Val = 0 encountered!\n");
561
562
1818427
        q = (base_tab[pos] * quant) >> 9;
563
1818427
        if (q > 1)
564
98187
            val = val * q + FFSIGN(val) * (((q ^ 1) - 1) >> 1);
565
1818427
        trvec[pos] = val;
566
        /* track columns containing non-zero coeffs */
567
1818427
        col_flags[pos & col_mask] |= !!val;
568
    }
569
570

197821
    if (scan_pos < 0 || scan_pos >= num_coeffs && sym != rvmap->eob_sym)
571
1
        return AVERROR_INVALIDDATA; /* corrupt block data */
572
573
    /* undoing DC coeff prediction for intra-blocks */
574

197820
    if (is_intra && band->is_2d_trans) {
575
115135
        *prev_dc     += trvec[0];
576
115135
        trvec[0]      = *prev_dc;
577
115135
        col_flags[0] |= !!*prev_dc;
578
    }
579
580
197820
    if(band->transform_size > band->blk_size){
581
        av_log(NULL, AV_LOG_ERROR, "Too large transform\n");
582
        return AVERROR_INVALIDDATA;
583
    }
584
585
    /* apply inverse transform */
586
197820
    band->inv_transform(trvec, band->buf + offs,
587
                        band->pitch, col_flags);
588
589
    /* apply motion compensation */
590
197820
    if (!is_intra)
591
82685
        return ivi_mc(band, mc, mc_avg, offs, mv_x, mv_y, mv_x2, mv_y2,
592
                      mc_type, mc_type2);
593
594
115135
    return 0;
595
}
596
/*
597
 *  Decode block data:
598
 *  extract huffman-coded transform coefficients from the bitstream,
599
 *  dequantize them, apply inverse transform and motion compensation
600
 *  in order to reconstruct the picture.
601
 *
602
 *  @param[in,out]  gb    the GetBit context
603
 *  @param[in]      band  pointer to the band descriptor
604
 *  @param[in]      tile  pointer to the tile descriptor
605
 *  @return     result code: 0 - OK, -1 = error (corrupted blocks data)
606
 */
607
700
static int ivi_decode_blocks(GetBitContext *gb, const IVIBandDesc *band,
608
                             IVITile *tile, AVCodecContext *avctx)
609
{
610
    int mbn, blk, num_blocks, blk_size, ret, is_intra;
611
700
    int mc_type = 0, mc_type2 = -1;
612
700
    int mv_x = 0, mv_y = 0, mv_x2 = 0, mv_y2 = 0;
613
    int32_t prev_dc;
614
    uint32_t cbp, quant, buf_offs;
615
    IVIMbInfo *mb;
616
    ivi_mc_func mc_with_delta_func, mc_no_delta_func;
617
    ivi_mc_avg_func mc_avg_with_delta_func, mc_avg_no_delta_func;
618
    const uint8_t *scale_tab;
619
620
    /* init intra prediction for the DC coefficient */
621
700
    prev_dc    = 0;
622
700
    blk_size   = band->blk_size;
623
    /* number of blocks per mb */
624
700
    num_blocks = (band->mb_size != blk_size) ? 4 : 1;
625
700
    if (blk_size == 8) {
626
234
        mc_with_delta_func     = ff_ivi_mc_8x8_delta;
627
234
        mc_no_delta_func       = ff_ivi_mc_8x8_no_delta;
628
234
        mc_avg_with_delta_func = ff_ivi_mc_avg_8x8_delta;
629
234
        mc_avg_no_delta_func   = ff_ivi_mc_avg_8x8_no_delta;
630
    } else {
631
466
        mc_with_delta_func     = ff_ivi_mc_4x4_delta;
632
466
        mc_no_delta_func       = ff_ivi_mc_4x4_no_delta;
633
466
        mc_avg_with_delta_func = ff_ivi_mc_avg_4x4_delta;
634
466
        mc_avg_no_delta_func   = ff_ivi_mc_avg_4x4_no_delta;
635
    }
636
637
162735
    for (mbn = 0, mb = tile->mbs; mbn < tile->num_MBs; mb++, mbn++) {
638
162036
        is_intra = !mb->type;
639
162036
        cbp      = mb->cbp;
640
162036
        buf_offs = mb->buf_offs;
641
642
162036
        quant = band->glob_quant + mb->q_delta;
643
162036
        if (avctx->codec_id == AV_CODEC_ID_INDEO4)
644
90216
            quant = av_clip_uintp2(quant, 5);
645
        else
646
71820
            quant = av_clip(quant, 0, 23);
647
648
162036
        scale_tab = is_intra ? band->intra_scale : band->inter_scale;
649
162036
        if (scale_tab)
650
71820
            quant = scale_tab[quant];
651
652
162036
        if (!is_intra) {
653
70985
            mv_x  = mb->mv_x;
654
70985
            mv_y  = mb->mv_y;
655
70985
            mv_x2 = mb->b_mv_x;
656
70985
            mv_y2 = mb->b_mv_y;
657
70985
            if (band->is_halfpel) {
658
70985
                mc_type  = ((mv_y  & 1) << 1) | (mv_x  & 1);
659
70985
                mc_type2 = ((mv_y2 & 1) << 1) | (mv_x2 & 1);
660
70985
                mv_x  >>= 1;
661
70985
                mv_y  >>= 1;
662
70985
                mv_x2 >>= 1;
663
70985
                mv_y2 >>= 1; /* convert halfpel vectors into fullpel ones */
664
            }
665
70985
            if (mb->type == 2)
666
                mc_type = -1;
667

70985
            if (mb->type != 2 && mb->type != 3)
668
70985
                mc_type2 = -1;
669
70985
            if (mb->type) {
670
                int dmv_x, dmv_y, cx, cy;
671
672
70985
                dmv_x = mb->mv_x >> band->is_halfpel;
673
70985
                dmv_y = mb->mv_y >> band->is_halfpel;
674
70985
                cx    = mb->mv_x &  band->is_halfpel;
675
70985
                cy    = mb->mv_y &  band->is_halfpel;
676
677
70985
                if (mb->xpos + dmv_x < 0 ||
678
70985
                    mb->xpos + dmv_x + band->mb_size + cx > band->pitch ||
679
70985
                    mb->ypos + dmv_y < 0 ||
680
70985
                    mb->ypos + dmv_y + band->mb_size + cy > band->aheight) {
681
                    return AVERROR_INVALIDDATA;
682
                }
683
            }
684

70985
            if (mb->type == 2 || mb->type == 3) {
685
                int dmv_x, dmv_y, cx, cy;
686
687
                dmv_x = mb->b_mv_x >> band->is_halfpel;
688
                dmv_y = mb->b_mv_y >> band->is_halfpel;
689
                cx    = mb->b_mv_x &  band->is_halfpel;
690
                cy    = mb->b_mv_y &  band->is_halfpel;
691
692
                if (mb->xpos + dmv_x < 0 ||
693
                    mb->xpos + dmv_x + band->mb_size + cx > band->pitch ||
694
                    mb->ypos + dmv_y < 0 ||
695
                    mb->ypos + dmv_y + band->mb_size + cy > band->aheight) {
696
                    return AVERROR_INVALIDDATA;
697
                }
698
            }
699
        }
700
701
486537
        for (blk = 0; blk < num_blocks; blk++) {
702
            /* adjust block position in the buffer according to its number */
703
324502
            if (blk & 1) {
704
108311
                buf_offs += blk_size;
705
216191
            } else if (blk == 2) {
706
54155
                buf_offs -= blk_size;
707
54155
                buf_offs += blk_size * band->pitch;
708
            }
709
710
324502
            if (cbp & 1) { /* block coded ? */
711
197821
                ret = ivi_decode_coded_blocks(gb, band, mc_with_delta_func,
712
                                              mc_avg_with_delta_func,
713
                                              mv_x, mv_y, mv_x2, mv_y2,
714
                                              &prev_dc, is_intra,
715
                                              mc_type, mc_type2, quant,
716
                                              buf_offs, avctx);
717
197821
                if (ret < 0)
718
1
                    return ret;
719
            } else {
720
126681
                int buf_size = band->pitch * band->aheight - buf_offs;
721
126681
                int min_size = (blk_size - 1) * band->pitch + blk_size;
722
723
126681
                if (min_size > buf_size)
724
                    return AVERROR_INVALIDDATA;
725
                /* block not coded */
726
                /* for intra blocks apply the dc slant transform */
727
                /* for inter - perform the motion compensation without delta */
728
126681
                if (is_intra) {
729
67284
                    ret = ivi_dc_transform(band, &prev_dc, buf_offs, blk_size);
730
67284
                    if (ret < 0)
731
                        return ret;
732
                } else {
733
59397
                    ret = ivi_mc(band, mc_no_delta_func, mc_avg_no_delta_func,
734
                                 buf_offs, mv_x, mv_y, mv_x2, mv_y2,
735
                                 mc_type, mc_type2);
736
59397
                    if (ret < 0)
737
                        return ret;
738
                }
739
            }
740
741
324501
            cbp >>= 1;
742
        }// for blk
743
    }// for mbn
744
745
699
    align_get_bits(gb);
746
747
699
    return 0;
748
}
749
750
/**
751
 *  Handle empty tiles by performing data copying and motion
752
 *  compensation respectively.
753
 *
754
 *  @param[in]  avctx     ptr to the AVCodecContext
755
 *  @param[in]  band      pointer to the band descriptor
756
 *  @param[in]  tile      pointer to the tile descriptor
757
 *  @param[in]  mv_scale  scaling factor for motion vectors
758
 */
759
static int ivi_process_empty_tile(AVCodecContext *avctx, const IVIBandDesc *band,
760
                                  IVITile *tile, int32_t mv_scale)
761
{
762
    int             x, y, need_mc, mbn, blk, num_blocks, mv_x, mv_y, mc_type;
763
    int             offs, mb_offset, row_offset, ret;
764
    IVIMbInfo       *mb, *ref_mb;
765
    const int16_t   *src;
766
    int16_t         *dst;
767
    ivi_mc_func     mc_no_delta_func;
768
    int             clear_first = !band->qdelta_present && !band->plane && !band->band_num;
769
    int             mb_size     = band->mb_size;
770
    int             xend        = tile->xpos + tile->width;
771
    int             is_halfpel  = band->is_halfpel;
772
    int             pitch       = band->pitch;
773
774
    if (tile->num_MBs != IVI_MBs_PER_TILE(tile->width, tile->height, mb_size)) {
775
        av_log(avctx, AV_LOG_ERROR, "Allocated tile size %d mismatches "
776
               "parameters %d in ivi_process_empty_tile()\n",
777
               tile->num_MBs, IVI_MBs_PER_TILE(tile->width, tile->height, mb_size));
778
        return AVERROR_INVALIDDATA;
779
    }
780
781
    offs       = tile->ypos * pitch + tile->xpos;
782
    mb         = tile->mbs;
783
    ref_mb     = tile->ref_mbs;
784
    row_offset = mb_size * pitch;
785
    need_mc    = 0; /* reset the mc tracking flag */
786
787
    for (y = tile->ypos; y < (tile->ypos + tile->height); y += mb_size) {
788
        mb_offset = offs;
789
790
        for (x = tile->xpos; x < xend; x += mb_size) {
791
            mb->xpos     = x;
792
            mb->ypos     = y;
793
            mb->buf_offs = mb_offset;
794
795
            mb->type = 1; /* set the macroblocks type = INTER */
796
            mb->cbp  = 0; /* all blocks are empty */
797
798
            if (clear_first) {
799
                mb->q_delta = band->glob_quant;
800
                mb->mv_x    = 0;
801
                mb->mv_y    = 0;
802
            }
803
804
            if (ref_mb) {
805
                if (band->inherit_qdelta)
806
                    mb->q_delta = ref_mb->q_delta;
807
808
                if (band->inherit_mv) {
809
                    /* motion vector inheritance */
810
                    if (mv_scale) {
811
                        mb->mv_x = ivi_scale_mv(ref_mb->mv_x, mv_scale);
812
                        mb->mv_y = ivi_scale_mv(ref_mb->mv_y, mv_scale);
813
                    } else {
814
                        mb->mv_x = ref_mb->mv_x;
815
                        mb->mv_y = ref_mb->mv_y;
816
                    }
817
                    need_mc |= mb->mv_x || mb->mv_y; /* tracking non-zero motion vectors */
818
                    {
819
                        int dmv_x, dmv_y, cx, cy;
820
821
                        dmv_x = mb->mv_x >> is_halfpel;
822
                        dmv_y = mb->mv_y >> is_halfpel;
823
                        cx    = mb->mv_x &  is_halfpel;
824
                        cy    = mb->mv_y &  is_halfpel;
825
826
                        if (   mb->xpos + dmv_x < 0
827
                            || mb->xpos + dmv_x + mb_size + cx > pitch
828
                            || mb->ypos + dmv_y < 0
829
                            || mb->ypos + dmv_y + mb_size + cy > band->aheight) {
830
                            av_log(avctx, AV_LOG_ERROR, "MV out of bounds\n");
831
                            return AVERROR_INVALIDDATA;
832
                        }
833
                    }
834
                }
835
                ref_mb++;
836
            }
837
838
            mb++;
839
            mb_offset += mb_size;
840
        } // for x
841
        offs += row_offset;
842
    } // for y
843
844
    if (band->inherit_mv && need_mc) { /* apply motion compensation if there is at least one non-zero motion vector */
845
        num_blocks = (mb_size != band->blk_size) ? 4 : 1; /* number of blocks per mb */
846
        mc_no_delta_func = (band->blk_size == 8) ? ff_ivi_mc_8x8_no_delta
847
                                                 : ff_ivi_mc_4x4_no_delta;
848
849
        for (mbn = 0, mb = tile->mbs; mbn < tile->num_MBs; mb++, mbn++) {
850
            mv_x = mb->mv_x;
851
            mv_y = mb->mv_y;
852
            if (!band->is_halfpel) {
853
                mc_type = 0; /* we have only fullpel vectors */
854
            } else {
855
                mc_type = ((mv_y & 1) << 1) | (mv_x & 1);
856
                mv_x >>= 1;
857
                mv_y >>= 1; /* convert halfpel vectors into fullpel ones */
858
            }
859
860
            for (blk = 0; blk < num_blocks; blk++) {
861
                /* adjust block position in the buffer according with its number */
862
                offs = mb->buf_offs + band->blk_size * ((blk & 1) + !!(blk & 2) * pitch);
863
                ret = ivi_mc(band, mc_no_delta_func, 0, offs,
864
                             mv_x, mv_y, 0, 0, mc_type, -1);
865
                if (ret < 0)
866
                    return ret;
867
            }
868
        }
869
    } else {
870
        /* copy data from the reference tile into the current one */
871
        src = band->ref_buf + tile->ypos * pitch + tile->xpos;
872
        dst = band->buf     + tile->ypos * pitch + tile->xpos;
873
        for (y = 0; y < tile->height; y++) {
874
            memcpy(dst, src, tile->width*sizeof(band->buf[0]));
875
            src += pitch;
876
            dst += pitch;
877
        }
878
    }
879
880
    return 0;
881
}
882
883
884
#ifdef DEBUG
885
static uint16_t ivi_calc_band_checksum(const IVIBandDesc *band)
886
{
887
    int         x, y;
888
    int16_t     *src, checksum;
889
890
    src = band->buf;
891
    checksum = 0;
892
893
    for (y = 0; y < band->height; src += band->pitch, y++)
894
        for (x = 0; x < band->width; x++)
895
            checksum += src[x];
896
897
    return checksum;
898
}
899
#endif
900
901
/*
902
 *  Convert and output the current plane.
903
 *  This conversion is done by adding back the bias value of 128
904
 *  (subtracted in the encoder) and clipping the result.
905
 *
906
 *  @param[in]   plane      pointer to the descriptor of the plane being processed
907
 *  @param[out]  dst        pointer to the buffer receiving converted pixels
908
 *  @param[in]   dst_pitch  pitch for moving to the next y line
909
 */
910
699
static void ivi_output_plane(IVIPlaneDesc *plane, uint8_t *dst, ptrdiff_t dst_pitch)
911
{
912
    int             x, y;
913
699
    const int16_t   *src  = plane->bands[0].buf;
914
699
    ptrdiff_t       pitch = plane->bands[0].pitch;
915
916
699
    if (!src)
917
        return;
918
919
72609
    for (y = 0; y < plane->height; y++) {
920
71910
        int m = 0;
921
71910
        int w = plane->width;
922
15175710
        for (x = 0; x < w; x++) {
923
15103800
            int t = src[x] + 128;
924
15103800
            dst[x] = t;
925
15103800
            m |= t;
926
        }
927
71910
        if (m & ~255)
928
            for (x = 0; x < w; x++)
929
                dst[x] = av_clip_uint8(src[x] + 128);
930
71910
        src += pitch;
931
71910
        dst += dst_pitch;
932
    }
933
}
934
935
1400
static void *prepare_buf(IVI45DecContext *ctx, IVIBandDesc *band, int i)
936
{
937

1400
    if (ctx->pic_conf.luma_bands <= 1 && i == 2)
938
        return NULL;
939
1400
    if (!band->bufs[i])
940
15
        band->bufs[i] = av_mallocz(2 * band->bufsize);
941
1400
    return band->bufs[i];
942
}
943
944
/**
945
 *  Decode an Indeo 4 or 5 band.
946
 *
947
 *  @param[in,out]  ctx    ptr to the decoder context
948
 *  @param[in,out]  band   ptr to the band descriptor
949
 *  @param[in]      avctx  ptr to the AVCodecContext
950
 *  @return         result code: 0 = OK, -1 = error
951
 */
952
700
static int decode_band(IVI45DecContext *ctx,
953
                       IVIBandDesc *band, AVCodecContext *avctx)
954
{
955
    int         result, i, t, idx1, idx2, pos;
956
    IVITile     *tile;
957
958
700
    band->buf     = prepare_buf(ctx, band, ctx->dst_buf);
959
700
    if (!band->buf) {
960
        av_log(avctx, AV_LOG_ERROR, "Band buffer points to no data!\n");
961
        return AVERROR_INVALIDDATA;
962
    }
963

700
    if (ctx->is_indeo4 && ctx->frame_type == IVI4_FRAMETYPE_BIDIR) {
964
        band->ref_buf   = prepare_buf(ctx, band, ctx->b_ref_buf);
965
        band->b_ref_buf = prepare_buf(ctx, band, ctx->ref_buf);
966
        if (!band->b_ref_buf)
967
            return AVERROR(ENOMEM);
968
    } else {
969
700
        band->ref_buf   = prepare_buf(ctx, band, ctx->ref_buf);
970
700
        band->b_ref_buf = 0;
971
    }
972
700
    if (!band->ref_buf)
973
        return AVERROR(ENOMEM);
974
700
    band->data_ptr  = ctx->frame_data + (get_bits_count(&ctx->gb) >> 3);
975
976
700
    result = ctx->decode_band_hdr(ctx, band, avctx);
977
700
    if (result) {
978
        av_log(avctx, AV_LOG_ERROR, "Error while decoding band header: %d\n",
979
               result);
980
        return result;
981
    }
982
983
700
    if (band->is_empty) {
984
        av_log(avctx, AV_LOG_ERROR, "Empty band encountered!\n");
985
        return AVERROR_INVALIDDATA;
986
    }
987
988
700
    band->rv_map = &ctx->rvmap_tabs[band->rvmap_sel];
989
990
    /* apply corrections to the selected rvmap table if present */
991
3649
    for (i = 0; i < band->num_corr; i++) {
992
2949
        idx1 = band->corr[i * 2];
993
2949
        idx2 = band->corr[i * 2 + 1];
994
2949
        FFSWAP(uint8_t, band->rv_map->runtab[idx1], band->rv_map->runtab[idx2]);
995
2949
        FFSWAP(int16_t, band->rv_map->valtab[idx1], band->rv_map->valtab[idx2]);
996

2949
        if (idx1 == band->rv_map->eob_sym || idx2 == band->rv_map->eob_sym)
997
            band->rv_map->eob_sym ^= idx1 ^ idx2;
998

2949
        if (idx1 == band->rv_map->esc_sym || idx2 == band->rv_map->esc_sym)
999
            band->rv_map->esc_sym ^= idx1 ^ idx2;
1000
    }
1001
1002
700
    pos = get_bits_count(&ctx->gb);
1003
1004
1399
    for (t = 0; t < band->num_tiles; t++) {
1005
700
        tile = &band->tiles[t];
1006
1007
700
        if (tile->mb_size != band->mb_size) {
1008
            av_log(avctx, AV_LOG_ERROR, "MB sizes mismatch: %d vs. %d\n",
1009
                   band->mb_size, tile->mb_size);
1010
            return AVERROR_INVALIDDATA;
1011
        }
1012
700
        tile->is_empty = get_bits1(&ctx->gb);
1013
700
        if (tile->is_empty) {
1014
            result = ivi_process_empty_tile(avctx, band, tile,
1015
                                      (ctx->planes[0].bands[0].mb_size >> 3) - (band->mb_size >> 3));
1016
            if (result < 0)
1017
                break;
1018
            ff_dlog(avctx, "Empty tile encountered!\n");
1019
        } else {
1020
700
            tile->data_size = ivi_dec_tile_data_size(&ctx->gb);
1021
700
            if (!tile->data_size) {
1022
                av_log(avctx, AV_LOG_ERROR, "Tile data size is zero!\n");
1023
                result = AVERROR_INVALIDDATA;
1024
                break;
1025
            }
1026
1027
700
            result = ctx->decode_mb_info(ctx, band, tile, avctx);
1028
700
            if (result < 0)
1029
                break;
1030
1031
700
            result = ivi_decode_blocks(&ctx->gb, band, tile, avctx);
1032
700
            if (result < 0) {
1033
1
                av_log(avctx, AV_LOG_ERROR,
1034
                       "Corrupted tile data encountered!\n");
1035
1
                break;
1036
            }
1037
1038
699
            if (((get_bits_count(&ctx->gb) - pos) >> 3) != tile->data_size) {
1039
                av_log(avctx, AV_LOG_ERROR,
1040
                       "Tile data_size mismatch!\n");
1041
                result = AVERROR_INVALIDDATA;
1042
                break;
1043
            }
1044
1045
699
            pos += tile->data_size << 3; // skip to next tile
1046
        }
1047
    }
1048
1049
    /* restore the selected rvmap table by applying its corrections in
1050
     * reverse order */
1051
3649
    for (i = band->num_corr-1; i >= 0; i--) {
1052
2949
        idx1 = band->corr[i*2];
1053
2949
        idx2 = band->corr[i*2+1];
1054
2949
        FFSWAP(uint8_t, band->rv_map->runtab[idx1], band->rv_map->runtab[idx2]);
1055
2949
        FFSWAP(int16_t, band->rv_map->valtab[idx1], band->rv_map->valtab[idx2]);
1056

2949
        if (idx1 == band->rv_map->eob_sym || idx2 == band->rv_map->eob_sym)
1057
            band->rv_map->eob_sym ^= idx1 ^ idx2;
1058

2949
        if (idx1 == band->rv_map->esc_sym || idx2 == band->rv_map->esc_sym)
1059
            band->rv_map->esc_sym ^= idx1 ^ idx2;
1060
    }
1061
1062
#ifdef DEBUG
1063
    if (band->checksum_present) {
1064
        uint16_t chksum = ivi_calc_band_checksum(band);
1065
        if (chksum != band->checksum) {
1066
            av_log(avctx, AV_LOG_ERROR,
1067
                   "Band checksum mismatch! Plane %d, band %d, "
1068
                   "received: %"PRIx32", calculated: %"PRIx16"\n",
1069
                   band->plane, band->band_num, band->checksum, chksum);
1070
        }
1071
    }
1072
#endif
1073
1074
700
    align_get_bits(&ctx->gb);
1075
1076
700
    return result;
1077
}
1078
1079
235
int ff_ivi_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
1080
                        AVPacket *avpkt)
1081
{
1082
235
    IVI45DecContext *ctx = avctx->priv_data;
1083
235
    const uint8_t   *buf = avpkt->data;
1084
235
    AVFrame       *frame = data;
1085
235
    int             buf_size = avpkt->size;
1086
    int             result, p, b;
1087
1088
235
    result = init_get_bits8(&ctx->gb, buf, buf_size);
1089
235
    if (result < 0)
1090
        return result;
1091
235
    ctx->frame_data = buf;
1092
235
    ctx->frame_size = buf_size;
1093
1094
235
    result = ctx->decode_pic_hdr(ctx, avctx);
1095
235
    if (result) {
1096
        av_log(avctx, AV_LOG_ERROR,
1097
               "Error while decoding picture header: %d\n", result);
1098
        return result;
1099
    }
1100
235
    if (ctx->gop_invalid)
1101
        return AVERROR_INVALIDDATA;
1102
1103

235
    if (ctx->is_indeo4 && ctx->frame_type == IVI4_FRAMETYPE_NULL_LAST) {
1104
        if (ctx->got_p_frame) {
1105
            av_frame_move_ref(data, ctx->p_frame);
1106
            *got_frame = 1;
1107
            ctx->got_p_frame = 0;
1108
        } else {
1109
            *got_frame = 0;
1110
        }
1111
        return buf_size;
1112
    }
1113
1114
235
    if (ctx->gop_flags & IVI5_IS_PROTECTED) {
1115
        avpriv_report_missing_feature(avctx, "Password-protected clip");
1116
        return AVERROR_PATCHWELCOME;
1117
    }
1118
1119
235
    if (!ctx->planes[0].bands) {
1120
        av_log(avctx, AV_LOG_ERROR, "Color planes not initialized yet\n");
1121
        return AVERROR_INVALIDDATA;
1122
    }
1123
1124
235
    ctx->switch_buffers(ctx);
1125
1126
235
    if (ctx->is_nonnull_frame(ctx)) {
1127
234
        ctx->buf_invalid[ctx->dst_buf] = 1;
1128
933
        for (p = 0; p < 3; p++) {
1129
1399
            for (b = 0; b < ctx->planes[p].num_bands; b++) {
1130
700
                result = decode_band(ctx, &ctx->planes[p].bands[b], avctx);
1131
700
                if (result < 0) {
1132
1
                    av_log(avctx, AV_LOG_ERROR,
1133
                           "Error while decoding band: %d, plane: %d\n", b, p);
1134
1
                    return result;
1135
                }
1136
            }
1137
        }
1138
233
        ctx->buf_invalid[ctx->dst_buf] = 0;
1139
    } else {
1140
1
        if (ctx->is_scalable)
1141
            return AVERROR_INVALIDDATA;
1142
1143
4
        for (p = 0; p < 3; p++) {
1144
3
            if (!ctx->planes[p].bands[0].buf)
1145
                return AVERROR_INVALIDDATA;
1146
        }
1147
    }
1148
234
    if (ctx->buf_invalid[ctx->dst_buf])
1149
        return -1;
1150
1151
234
    if (!ctx->is_nonnull_frame(ctx))
1152
1
        return buf_size;
1153
1154
233
    result = ff_set_dimensions(avctx, ctx->planes[0].width, ctx->planes[0].height);
1155
233
    if (result < 0)
1156
        return result;
1157
1158
233
    if ((result = ff_get_buffer(avctx, frame, 0)) < 0)
1159
        return result;
1160
1161
233
    if (ctx->is_scalable) {
1162
        if (ctx->is_indeo4)
1163
            ff_ivi_recompose_haar(&ctx->planes[0], frame->data[0], frame->linesize[0]);
1164
        else
1165
            ff_ivi_recompose53   (&ctx->planes[0], frame->data[0], frame->linesize[0]);
1166
    } else {
1167
233
        ivi_output_plane(&ctx->planes[0], frame->data[0], frame->linesize[0]);
1168
    }
1169
1170
233
    ivi_output_plane(&ctx->planes[2], frame->data[1], frame->linesize[1]);
1171
233
    ivi_output_plane(&ctx->planes[1], frame->data[2], frame->linesize[2]);
1172
1173
233
    *got_frame = 1;
1174
1175
    /* If the bidirectional mode is enabled, next I and the following P
1176
     * frame will be sent together. Unfortunately the approach below seems
1177
     * to be the only way to handle the B-frames mode.
1178
     * That's exactly the same Intel decoders do.
1179
     */
1180

233
    if (ctx->is_indeo4 && ctx->frame_type == IVI4_FRAMETYPE_INTRA) {
1181
        int left;
1182
1183
            // skip version string
1184
133
        while (get_bits(&ctx->gb, 8)) {
1185
126
            if (get_bits_left(&ctx->gb) < 8)
1186
                return AVERROR_INVALIDDATA;
1187
        }
1188
7
        left = get_bits_count(&ctx->gb) & 0x18;
1189
7
        skip_bits_long(&ctx->gb, 64 - left);
1190

7
        if (get_bits_left(&ctx->gb) > 18 &&
1191
            show_bits(&ctx->gb, 21) == 0xBFFF8) { // syncheader + inter type
1192
            AVPacket pkt;
1193
            pkt.data = avpkt->data + (get_bits_count(&ctx->gb) >> 3);
1194
            pkt.size = get_bits_left(&ctx->gb) >> 3;
1195
            ctx->got_p_frame = 0;
1196
            av_frame_unref(ctx->p_frame);
1197
            ff_ivi_decode_frame(avctx, ctx->p_frame, &ctx->got_p_frame, &pkt);
1198
        }
1199
    }
1200
1201
233
    if (ctx->show_indeo4_info) {
1202
1
        if (ctx->is_scalable)
1203
            av_log(avctx, AV_LOG_DEBUG, "This video uses scalability mode\n");
1204
1
        if (ctx->uses_tiling)
1205
            av_log(avctx, AV_LOG_DEBUG, "This video uses local decoding\n");
1206
1
        if (ctx->has_b_frames)
1207
            av_log(avctx, AV_LOG_DEBUG, "This video contains B-frames\n");
1208
1
        if (ctx->has_transp)
1209
            av_log(avctx, AV_LOG_DEBUG, "Transparency mode is enabled\n");
1210
1
        if (ctx->uses_haar)
1211
            av_log(avctx, AV_LOG_DEBUG, "This video uses Haar transform\n");
1212
1
        if (ctx->uses_fullpel)
1213
            av_log(avctx, AV_LOG_DEBUG, "This video uses fullpel motion vectors\n");
1214
1
        ctx->show_indeo4_info = 0;
1215
    }
1216
1217
233
    return buf_size;
1218
}
1219
1220
/**
1221
 *  Close Indeo5 decoder and clean up its context.
1222
 */
1223
4
av_cold int ff_ivi_decode_close(AVCodecContext *avctx)
1224
{
1225
4
    IVI45DecContext *ctx = avctx->priv_data;
1226
1227
4
    ivi_free_buffers(&ctx->planes[0]);
1228
1229
4
    if (ctx->mb_vlc.cust_tab.table)
1230
1
        ff_free_vlc(&ctx->mb_vlc.cust_tab);
1231
1232
4
    if (ctx->blk_vlc.cust_tab.table)
1233
        ff_free_vlc(&ctx->blk_vlc.cust_tab);
1234
1235
4
    av_frame_free(&ctx->p_frame);
1236
1237
4
    return 0;
1238
}
1239
1240
1241
/**
1242
 *  Scan patterns shared between indeo4 and indeo5
1243
 */
1244
const uint8_t ff_ivi_vertical_scan_8x8[64] = {
1245
    0,  8, 16, 24, 32, 40, 48, 56,
1246
    1,  9, 17, 25, 33, 41, 49, 57,
1247
    2, 10, 18, 26, 34, 42, 50, 58,
1248
    3, 11, 19, 27, 35, 43, 51, 59,
1249
    4, 12, 20, 28, 36, 44, 52, 60,
1250
    5, 13, 21, 29, 37, 45, 53, 61,
1251
    6, 14, 22, 30, 38, 46, 54, 62,
1252
    7, 15, 23, 31, 39, 47, 55, 63
1253
};
1254
1255
const uint8_t ff_ivi_horizontal_scan_8x8[64] = {
1256
     0,  1,  2,  3,  4,  5,  6,  7,
1257
     8,  9, 10, 11, 12, 13, 14, 15,
1258
    16, 17, 18, 19, 20, 21, 22, 23,
1259
    24, 25, 26, 27, 28, 29, 30, 31,
1260
    32, 33, 34, 35, 36, 37, 38, 39,
1261
    40, 41, 42, 43, 44, 45, 46, 47,
1262
    48, 49, 50, 51, 52, 53, 54, 55,
1263
    56, 57, 58, 59, 60, 61, 62, 63
1264
};
1265
1266
const uint8_t ff_ivi_direct_scan_4x4[16] = {
1267
    0, 1, 4, 8, 5, 2, 3, 6, 9, 12, 13, 10, 7, 11, 14, 15
1268
};
1269
1270
1271
/**
1272
 *  Run-value (RLE) tables.
1273
 */
1274
const RVMapDesc ff_ivi_rvmap_tabs[9] = {
1275
{   /* MapTab0 */
1276
    5, /* eob_sym */
1277
    2, /* esc_sym */
1278
    /* run table */
1279
    {1,  1,  0,  1,  1,  0,  1,  1,  2,  2,  1,  1,  1,  1,  3,  3,
1280
     1,  1,  2,  2,  1,  1,  4,  4,  1,  1,  1,  1,  2,  2,  5,  5,
1281
     1,  1,  3,  3,  1,  1,  6,  6,  1,  2,  1,  2,  7,  7,  1,  1,
1282
     8,  8,  1,  1,  4,  2,  1,  4,  2,  1,  3,  3,  1,  1,  1,  9,
1283
     9,  1,  2,  1,  2,  1,  5,  5,  1,  1, 10, 10,  1,  1,  3,  3,
1284
     2,  2,  1,  1, 11, 11,  6,  4,  4,  1,  6,  1,  2,  1,  2, 12,
1285
     8,  1, 12,  7,  8,  7,  1, 16,  1, 16,  1,  3,  3, 13,  1, 13,
1286
     2,  2,  1, 15,  1,  5, 14, 15,  1,  5, 14,  1, 17,  8, 17,  8,
1287
     1,  4,  4,  2,  2,  1, 25, 25, 24, 24,  1,  3,  1,  3,  1,  8,
1288
     6,  7,  6,  1, 18,  8, 18,  1,  7, 23,  2,  2, 23,  1,  1, 21,
1289
    22,  9,  9, 22, 19,  1, 21,  5, 19,  5,  1, 33, 20, 33, 20,  8,
1290
     4,  4,  1, 32,  2,  2,  8,  3, 32, 26,  3,  1,  7,  7, 26,  6,
1291
     1,  6,  1,  1, 16,  1, 10,  1, 10,  2, 16, 29, 28,  2, 29, 28,
1292
     1, 27,  5,  8,  5, 27,  1,  8,  3,  7,  3, 31, 41, 31,  1, 41,
1293
     6,  1,  6,  7,  4,  4,  1,  1,  2,  1,  2, 11, 34, 30, 11,  1,
1294
    30, 15, 15, 34, 36, 40, 36, 40, 35, 35, 37, 37, 39, 39, 38, 38},
1295
1296
    /* value table */
1297
    { 1,  -1,   0,   2,  -2,   0,   3,  -3,   1,  -1,   4,  -4,   5,  -5,   1,  -1,
1298
      6,  -6,   2,  -2,   7,  -7,   1,  -1,   8,  -8,   9,  -9,   3,  -3,   1,  -1,
1299
     10, -10,   2,  -2,  11, -11,   1,  -1,  12,   4, -12,  -4,   1,  -1,  13, -13,
1300
      1,  -1,  14, -14,   2,   5,  15,  -2,  -5, -15,  -3,   3,  16, -16,  17,   1,
1301
     -1, -17,   6,  18,  -6, -18,   2,  -2,  19, -19,   1,  -1,  20, -20,   4,  -4,
1302
      7,  -7,  21, -21,   1,  -1,   2,   3,  -3,  22,  -2, -22,   8,  23,  -8,   1,
1303
      2, -23,  -1,   2,  -2,  -2,  24,   1, -24,  -1,  25,   5,  -5,   1, -25,  -1,
1304
      9,  -9,  26,   1, -26,   3,   1,  -1,  27,  -3,  -1, -27,   1,   3,  -1,  -3,
1305
     28,  -4,   4,  10, -10, -28,   1,  -1,   1,  -1,  29,   6, -29,  -6,  30,  -4,
1306
      3,   3,  -3, -30,   1,   4,  -1,  31,  -3,   1,  11, -11,  -1, -31,  32,  -1,
1307
     -1,   2,  -2,   1,   1, -32,   1,   4,  -1,  -4,  33,  -1,   1,   1,  -1,   5,
1308
      5,  -5, -33,  -1, -12,  12,  -5,  -7,   1,   1,   7,  34,   4,  -4,  -1,   4,
1309
    -34,  -4,  35,  36,  -2, -35,  -2, -36,   2,  13,   2,  -1,   1, -13,   1,  -1,
1310
     37,   1,  -5,   6,   5,  -1,  38,  -6,  -8,   5,   8,  -1,   1,   1, -37,  -1,
1311
      5,  39,  -5,  -5,   6,  -6, -38, -39, -14,  40,  14,   2,   1,   1,  -2, -40,
1312
     -1,  -2,   2,  -1,  -1,  -1,   1,   1,   1,  -1,   1,  -1,   1,  -1,   1,  -1}
1313
},{
1314
    /* MapTab1 */
1315
    0,  /* eob_sym */
1316
    38, /* esc_sym */
1317
    /* run table */
1318
    {0,  1,  1,  2,  2,  3,  3,  4,  4,  5,  5,  6,  8,  6,  8,  7,
1319
     7,  9,  9, 10, 10, 11, 11,  1, 12,  1, 12, 13, 13, 16, 14, 16,
1320
    14, 15, 15, 17, 17, 18,  0, 18, 19, 20, 21, 19, 22, 21, 20, 22,
1321
    25, 24,  2, 25, 24, 23, 23,  2, 26, 28, 26, 28, 29, 27, 29, 27,
1322
    33, 33,  1, 32,  1,  3, 32, 30, 36,  3, 36, 30, 31, 31, 35, 34,
1323
    37, 41, 34, 35, 37,  4, 41,  4, 49,  8,  8, 49, 40, 38,  5, 38,
1324
    40, 39,  5, 39, 42, 43, 42,  7, 57,  6, 43, 44,  6, 50,  7, 44,
1325
    57, 48, 50, 48, 45, 45, 46, 47, 51, 46, 47, 58,  1, 51, 58,  1,
1326
    52, 59, 53,  9, 52, 55, 55, 59, 53, 56, 54, 56, 54,  9, 64, 64,
1327
    60, 63, 60, 63, 61, 62, 61, 62,  2, 10,  2, 10, 11,  1, 11, 13,
1328
    12,  1, 12, 13, 16, 16,  8,  8, 14,  3,  3, 15, 14, 15,  4,  4,
1329
     1, 17, 17,  5,  1,  7,  7,  5,  6,  1,  2,  2,  6, 22,  1, 25,
1330
    21, 22,  8, 24,  1, 21, 25, 24,  8, 18, 18, 23,  9, 20, 23, 33,
1331
    29, 33, 20,  1, 19,  1, 29, 36,  9, 36, 19, 41, 28, 57, 32,  3,
1332
    28,  3,  1, 27, 49, 49,  1, 32, 26, 26,  2,  4,  4,  7, 57, 41,
1333
     2,  7, 10,  5, 37, 16, 10, 27,  8,  8, 13, 16, 37, 13,  1,  5},
1334
1335
    /* value table */
1336
    {0,   1,  -1,   1,  -1,   1,  -1,   1,  -1,   1,  -1,   1,   1,  -1,  -1,   1,
1337
    -1,   1,  -1,   1,  -1,   1,  -1,   2,   1,  -2,  -1,   1,  -1,   1,   1,  -1,
1338
    -1,   1,  -1,   1,  -1,   1,   0,  -1,   1,   1,   1,  -1,   1,  -1,  -1,  -1,
1339
     1,   1,   2,  -1,  -1,   1,  -1,  -2,   1,   1,  -1,  -1,   1,   1,  -1,  -1,
1340
     1,  -1,   3,   1,  -3,   2,  -1,   1,   1,  -2,  -1,  -1,  -1,   1,   1,   1,
1341
     1,   1,  -1,  -1,  -1,   2,  -1,  -2,   1,   2,  -2,  -1,   1,   1,   2,  -1,
1342
    -1,   1,  -2,  -1,   1,   1,  -1,   2,   1,   2,  -1,   1,  -2,  -1,  -2,  -1,
1343
    -1,   1,   1,  -1,   1,  -1,   1,   1,   1,  -1,  -1,   1,   4,  -1,  -1,  -4,
1344
     1,   1,   1,   2,  -1,  -1,   1,  -1,  -1,   1,  -1,  -1,   1,  -2,   1,  -1,
1345
     1,   1,  -1,  -1,   1,   1,  -1,  -1,   3,   2,  -3,  -2,   2,   5,  -2,   2,
1346
     2,  -5,  -2,  -2,  -2,   2,  -3,   3,   2,   3,  -3,   2,  -2,  -2,   3,  -3,
1347
     6,   2,  -2,   3,  -6,   3,  -3,  -3,   3,   7,  -4,   4,  -3,   2,  -7,   2,
1348
     2,  -2,  -4,   2,   8,  -2,  -2,  -2,   4,   2,  -2,   2,   3,   2,  -2,  -2,
1349
     2,   2,  -2,  -8,  -2,   9,  -2,   2,  -3,  -2,   2,  -2,   2,   2,   2,   4,
1350
    -2,  -4,  10,   2,   2,  -2,  -9,  -2,   2,  -2,   5,   4,  -4,   4,  -2,   2,
1351
    -5,  -4,  -3,   4,   2,  -3,   3,  -2,  -5,   5,   3,   3,  -2,  -3, -10,  -4}
1352
},{
1353
    /* MapTab2 */
1354
    2,  /* eob_sym */
1355
    11, /* esc_sym */
1356
    /* run table */
1357
    {1,  1,  0,  2,  2,  1,  1,  3,  3,  4,  4,  0,  1,  1,  5,  5,
1358
     2,  2,  6,  6,  7,  7,  1,  8,  1,  8,  3,  3,  9,  9,  1,  2,
1359
     2,  1,  4, 10,  4, 10, 11, 11,  1,  5, 12, 12,  1,  5, 13, 13,
1360
     3,  3,  6,  6,  2,  2, 14, 14, 16, 16, 15,  7, 15,  8,  8,  7,
1361
     1,  1, 17, 17,  4,  4,  1,  1, 18, 18,  2,  2,  5,  5, 25,  3,
1362
     9,  3, 25,  9, 19, 24, 19, 24,  1, 21, 20,  1, 21, 22, 20, 22,
1363
    23, 23,  8,  6, 33,  6,  8, 33,  7,  7, 26, 26,  1, 32,  1, 32,
1364
    28,  4, 28, 10, 29, 27, 27, 10, 41,  4, 29,  2,  2, 41, 36, 31,
1365
    49, 31, 34, 30, 34, 36, 30, 35,  1, 49, 11,  5, 35, 11,  1,  3,
1366
     3,  5, 37, 37,  8, 40,  8, 40, 12, 12, 42, 42,  1, 38, 16, 57,
1367
     1,  6, 16, 39, 38,  6,  7,  7, 13, 13, 39, 43,  2, 43, 57,  2,
1368
    50,  9, 44,  9, 50,  4, 15, 48, 44,  4,  1, 15, 48, 14, 14,  1,
1369
    45, 45,  8,  3,  5,  8, 51, 47,  3, 46, 46, 47,  5, 51,  1, 17,
1370
    17, 58,  1, 58,  2, 52, 52,  2, 53,  7, 59,  6,  6, 56, 53, 55,
1371
     7, 55,  1, 54, 59, 56, 54, 10,  1, 10,  4, 60,  1, 60,  8,  4,
1372
     8, 64, 64, 61,  1, 63,  3, 63, 62, 61,  5, 11,  5,  3, 11, 62},
1373
1374
    /* value table */
1375
    { 1,  -1,   0,   1,  -1,   2,  -2,   1,  -1,   1,  -1,   0,   3,  -3,   1,  -1,
1376
      2,  -2,   1,  -1,   1,  -1,   4,   1,  -4,  -1,   2,  -2,   1,  -1,   5,   3,
1377
     -3,  -5,   2,   1,  -2,  -1,   1,  -1,   6,   2,   1,  -1,  -6,  -2,   1,  -1,
1378
      3,  -3,   2,  -2,   4,  -4,   1,  -1,   1,  -1,   1,   2,  -1,   2,  -2,  -2,
1379
      7,  -7,   1,  -1,   3,  -3,   8,  -8,   1,  -1,   5,  -5,   3,  -3,   1,   4,
1380
      2,  -4,  -1,  -2,   1,   1,  -1,  -1,   9,   1,   1,  -9,  -1,   1,  -1,  -1,
1381
      1,  -1,   3,  -3,   1,   3,  -3,  -1,   3,  -3,   1,  -1,  10,   1, -10,  -1,
1382
      1,   4,  -1,   2,   1,  -1,   1,  -2,   1,  -4,  -1,   6,  -6,  -1,   1,   1,
1383
      1,  -1,   1,   1,  -1,  -1,  -1,   1,  11,  -1,  -2,   4,  -1,   2, -11,   5,
1384
     -5,  -4,  -1,   1,   4,   1,  -4,  -1,  -2,   2,   1,  -1,  12,   1,  -2,   1,
1385
    -12,   4,   2,   1,  -1,  -4,   4,  -4,   2,  -2,  -1,   1,   7,  -1,  -1,  -7,
1386
     -1,  -3,   1,   3,   1,   5,   2,   1,  -1,  -5,  13,  -2,  -1,   2,  -2, -13,
1387
      1,  -1,   5,   6,   5,  -5,   1,   1,  -6,   1,  -1,  -1,  -5,  -1,  14,   2,
1388
     -2,   1, -14,  -1,   8,   1,  -1,  -8,   1,   5,   1,   5,  -5,   1,  -1,   1,
1389
     -5,  -1,  15,   1,  -1,  -1,  -1,   3, -15,  -3,   6,   1,  16,  -1,   6,  -6,
1390
     -6,   1,  -1,   1, -16,   1,   7,  -1,   1,  -1,  -6,  -3,   6,  -7,   3,  -1}
1391
},{
1392
    /* MapTab3 */
1393
    0,  /* eob_sym */
1394
    35, /* esc_sym */
1395
    /* run table */
1396
    {0,  1,  1,  2,  2,  3,  3,  4,  4,  1,  1,  5,  5,  6,  6,  7,
1397
     7,  8,  8,  9,  9,  2,  2, 10, 10,  1,  1, 11, 11, 12, 12,  3,
1398
     3, 13, 13,  0, 14, 14, 16, 15, 16, 15,  4,  4, 17,  1, 17,  1,
1399
     5,  5, 18, 18,  2,  2,  6,  6,  8, 19,  7,  8,  7, 19, 20, 20,
1400
    21, 21, 22, 24, 22, 24, 23, 23,  1,  1, 25, 25,  3,  3, 26, 26,
1401
     9,  9, 27, 27, 28, 28, 33, 29,  4, 33, 29,  1,  4,  1, 32, 32,
1402
     2,  2, 31, 10, 30, 10, 30, 31, 34, 34,  5,  5, 36, 36, 35, 41,
1403
    35, 11, 41, 11, 37,  1,  8,  8, 37,  6,  1,  6, 40,  7,  7, 40,
1404
    12, 38, 12, 39, 39, 38, 49, 13, 49, 13,  3, 42,  3, 42, 16, 16,
1405
    43, 43, 14, 14,  1,  1, 44, 15, 44, 15,  2,  2, 57, 48, 50, 48,
1406
    57, 50,  4, 45, 45,  4, 46, 47, 47, 46,  1, 51,  1, 17, 17, 51,
1407
     8,  9,  9,  5, 58,  8, 58,  5, 52, 52, 55, 56, 53, 56, 55, 59,
1408
    59, 53, 54,  1,  6, 54,  7,  7,  6,  1,  2,  3,  2,  3, 64, 60,
1409
    60, 10, 10, 64, 61, 62, 61, 63,  1, 63, 62,  1, 18, 24, 18,  4,
1410
    25,  4,  8, 21, 21,  1, 24, 22, 25, 22,  8, 11, 19, 11, 23,  1,
1411
    20, 23, 19, 20,  5, 12,  5,  1, 16,  2, 12, 13,  2, 13,  1, 16},
1412
1413
    /* value table */
1414
    { 0,   1,  -1,   1,  -1,   1,  -1,   1,  -1,   2,  -2,   1,  -1,   1,  -1,   1,
1415
     -1,   1,  -1,   1,  -1,   2,  -2,   1,  -1,   3,  -3,   1,  -1,   1,  -1,   2,
1416
     -2,   1,  -1,   0,   1,  -1,   1,   1,  -1,  -1,   2,  -2,   1,   4,  -1,  -4,
1417
      2,  -2,   1,  -1,  -3,   3,   2,  -2,   2,   1,   2,  -2,  -2,  -1,   1,  -1,
1418
      1,  -1,   1,   1,  -1,  -1,   1,  -1,   5,  -5,   1,  -1,   3,  -3,   1,  -1,
1419
      2,  -2,   1,  -1,   1,  -1,   1,   1,   3,  -1,  -1,   6,  -3,  -6,  -1,   1,
1420
      4,  -4,   1,   2,   1,  -2,  -1,  -1,   1,  -1,   3,  -3,   1,  -1,   1,   1,
1421
     -1,   2,  -1,  -2,   1,   7,  -3,   3,  -1,   3,  -7,  -3,   1,  -3,   3,  -1,
1422
      2,   1,  -2,   1,  -1,  -1,   1,   2,  -1,  -2,  -4,  -1,   4,   1,   2,  -2,
1423
      1,  -1,  -2,   2,   8,  -8,  -1,   2,   1,  -2,  -5,   5,   1,  -1,  -1,   1,
1424
     -1,   1,   4,  -1,   1,  -4,  -1,  -1,   1,   1,   9,   1,  -9,   2,  -2,  -1,
1425
     -4,   3,  -3,  -4,  -1,   4,   1,   4,   1,  -1,   1,  -1,   1,   1,  -1,   1,
1426
     -1,  -1,  -1,  10,   4,   1,   4,  -4,  -4, -10,   6,   5,  -6,  -5,   1,  -1,
1427
      1,   3,  -3,  -1,   1,  -1,  -1,  -1,  11,   1,   1, -11,  -2,  -2,   2,   5,
1428
     -2,  -5,  -5,   2,  -2,  12,   2,  -2,   2,   2,   5,  -3,  -2,   3,  -2, -12,
1429
     -2,   2,   2,   2,  -5,   3,   5,  13,  -3,   7,  -3,  -3,  -7,   3, -13,   3}
1430
},{
1431
    /* MapTab4 */
1432
    0,  /* eob_sym */
1433
    34, /* esc_sym */
1434
    /* run table */
1435
    {0,  1,  1,  1,  2,  2,  1,  3,  3,  1,  1,  1,  4,  4,  1,  5,
1436
     2,  1,  5,  2,  1,  1,  6,  6,  1,  1,  1,  1,  1,  7,  3,  1,
1437
     2,  3,  0,  1,  2,  7,  1,  1,  1,  8,  1,  1,  8,  1,  1,  1,
1438
     9,  1,  9,  1,  2,  1,  1,  2,  1,  1, 10,  4,  1, 10,  1,  4,
1439
     1,  1,  1,  1,  1,  3,  1,  1,  1,  3,  2,  1,  5,  1,  1,  1,
1440
     2,  5,  1, 11,  1, 11,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,
1441
     2,  1,  6,  1,  6,  1,  1,  2,  1,  1,  1,  1,  1,  1,  1, 12,
1442
     3,  1, 12,  1,  1,  1,  2,  1,  1,  3,  1,  1,  1,  1,  1,  1,
1443
     4,  1,  1,  1,  2,  1,  1,  4,  1,  1,  1,  1,  1,  1,  2,  1,
1444
     1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  3,  1,  2,  1,  1,  5,
1445
     1,  1,  1,  1,  1,  7,  1,  7,  1,  1,  2,  3,  1,  1,  1,  1,
1446
     5,  1,  1,  1,  1,  1,  1,  2, 13,  1,  1,  1,  1,  1,  1,  1,
1447
     1,  1,  1,  1,  1,  1,  1,  1, 13,  2,  1,  1,  4,  1,  1,  1,
1448
     3,  1,  6,  1,  1,  1, 14,  1,  1,  1,  1,  1, 14,  6,  1,  1,
1449
     1,  1, 15,  2,  4,  1,  2,  3, 15,  1,  1,  1,  8,  1,  1,  8,
1450
     1,  1,  1,  1,  1,  1,  1,  1,  2,  1,  1,  1,  1,  1,  1,  1},
1451
1452
    /* value table */
1453
    { 0,   1,  -1,   2,   1,  -1,  -2,   1,  -1,   3,  -3,   4,   1,  -1,  -4,   1,
1454
      2,   5,  -1,  -2,  -5,   6,   1,  -1,  -6,   7,  -7,   8,  -8,   1,   2,   9,
1455
      3,  -2,   0,  -9,  -3,  -1,  10, -10,  11,   1, -11,  12,  -1, -12,  13, -13,
1456
      1,  14,  -1, -14,   4,  15, -15,  -4,  16, -16,   1,   2,  17,  -1, -17,  -2,
1457
     18, -18,  19, -19,  20,   3, -20,  21, -21,  -3,   5,  22,   2, -22, -23,  23,
1458
     -5,  -2,  24,   1, -24,  -1,  25, -25,  26, -26, -27,  27,  28,  29, -28, -29,
1459
      6,  30,   2, -31,  -2, -30,  31,  -6, -32,  32,  33, -33,  34, -35, -34,   1,
1460
      4, -36,  -1,  35,  37,  36,   7, -37,  38,  -4, -38,  39,  41,  40, -40, -39,
1461
      3,  42, -43, -41,  -7, -42,  43,  -3,  44, -44,  45, -45,  46,  47,   8, -47,
1462
    -48, -46,  50, -50,  48,  49,  51, -49,  52, -52,   5, -51,  -8, -53,  53,   3,
1463
    -56,  56,  55,  54, -54,   2,  60,  -2, -55,  58,   9,  -5,  59,  57, -57, -63,
1464
     -3, -58, -60, -61,  61, -59, -62,  -9,   1,  64,  62,  69, -64,  63,  65, -67,
1465
    -68,  66, -65,  68, -66, -69,  67, -70,  -1,  10,  71, -71,   4,  73,  72,  70,
1466
      6, -76,  -3,  74, -78, -74,   1,  78,  80, -72, -75,  76,  -1,   3, -73,  79,
1467
     75,  77,   1,  11,  -4, -79, -10,  -6,  -1, -77, -83, -80,   2,  81, -84,  -2,
1468
     83, -81,  82, -82,  84, -87, -86,  85, -11, -85,  86, -89,  87, -88,  88,  89}
1469
},{
1470
    /* MapTab5 */
1471
    2,  /* eob_sym */
1472
    33, /* esc_sym */
1473
    /* run table */
1474
    {1,  1,  0,  2,  1,  2,  1,  3,  3,  1,  1,  4,  4,  2,  2,  1,
1475
     1,  5,  5,  6,  1,  6,  1,  7,  7,  3,  3,  2,  8,  2,  8,  1,
1476
     1,  0,  9,  9,  1,  1, 10,  4, 10,  4, 11, 11,  2,  1,  2,  1,
1477
    12, 12,  3,  3,  1,  1, 13,  5,  5, 13, 14,  1,  1, 14,  2,  2,
1478
     6,  6, 15,  1,  1, 15, 16,  4,  7, 16,  4,  7,  1,  1,  3,  3,
1479
     8,  8,  2,  2,  1,  1, 17, 17,  1,  1, 18, 18,  5,  5,  2,  2,
1480
     1,  1,  9, 19,  9, 19, 20,  3,  3, 20,  1, 10, 21,  1, 10,  4,
1481
     4, 21, 22,  6,  6, 22,  1,  1, 23, 24,  2,  2, 23, 24, 11,  1,
1482
     1, 11,  7, 25,  7,  1,  1, 25,  8,  8,  3, 26,  3,  1, 12,  2,
1483
     2, 26,  1, 12,  5,  5, 27,  4,  1,  4,  1, 27, 28,  1, 28, 13,
1484
     1, 13,  2, 29,  2,  1, 32,  6,  1, 30, 14, 29, 14,  6,  3, 31,
1485
     3,  1, 30,  1, 32, 31, 33,  9, 33,  1,  1,  7,  9,  7,  2,  2,
1486
     1,  1,  4, 36, 34,  4,  5, 10, 10,  5, 34,  1,  1, 35,  8,  8,
1487
    36,  3, 35,  1, 15,  3,  2,  1, 16, 15, 16,  2, 37,  1, 37,  1,
1488
     1,  1,  6,  6, 38,  1, 38, 11,  1, 39, 39, 40, 11,  2, 41,  4,
1489
    40,  1,  2,  4,  1,  1,  1, 41,  3,  1,  3,  1,  5,  7,  5,  7},
1490
1491
    /* value table */
1492
    { 1,  -1,   0,   1,   2,  -1,  -2,   1,  -1,   3,  -3,   1,  -1,   2,  -2,   4,
1493
     -4,   1,  -1,   1,   5,  -1,  -5,   1,  -1,   2,  -2,   3,   1,  -3,  -1,   6,
1494
     -6,   0,   1,  -1,   7,  -7,   1,   2,  -1,  -2,   1,  -1,   4,   8,  -4,  -8,
1495
      1,  -1,   3,  -3,   9,  -9,   1,   2,  -2,  -1,   1,  10, -10,  -1,   5,  -5,
1496
      2,  -2,   1,  11, -11,  -1,   1,   3,   2,  -1,  -3,  -2,  12, -12,   4,  -4,
1497
      2,  -2,  -6,   6,  13, -13,   1,  -1,  14, -14,   1,  -1,   3,  -3,   7,  -7,
1498
     15, -15,   2,   1,  -2,  -1,   1,   5,  -5,  -1, -16,   2,   1,  16,  -2,   4,
1499
     -4,  -1,   1,   3,  -3,  -1,  17, -17,   1,   1,  -8,   8,  -1,  -1,   2,  18,
1500
    -18,  -2,   3,   1,  -3,  19, -19,  -1,   3,  -3,   6,   1,  -6,  20,   2,   9,
1501
     -9,  -1, -20,  -2,   4,  -4,   1,  -5,  21,   5, -21,  -1,   1, -22,  -1,   2,
1502
     22,  -2,  10,   1, -10,  23,   1,   4, -23,   1,   2,  -1,  -2,  -4,  -7,   1,
1503
      7, -24,  -1,  24,  -1,  -1,   1,   3,  -1, -25,  25,   4,  -3,  -4,  11, -11,
1504
     26, -26,   6,   1,   1,  -6,  -5,  -3,   3,   5,  -1, -27,  27,   1,   4,  -4,
1505
     -1,  -8,  -1,  28,   2,   8, -12, -28,  -2,  -2,   2,  12,  -1,  29,   1, -29,
1506
     30, -30,   5,  -5,   1, -31,  -1,   3,  31,  -1,   1,   1,  -3, -13,   1,  -7,
1507
     -1, -32,  13,   7,  32,  33, -33,  -1,  -9, -34,   9,  34,  -6,   5,   6,  -5}
1508
},{
1509
    /* MapTab6 */
1510
    2,  /* eob_sym */
1511
    13, /* esc_sym */
1512
    /* run table */
1513
    {1,  1,  0,  1,  1,  2,  2,  1,  1,  3,  3,  1,  1,  0,  2,  2,
1514
     4,  1,  4,  1,  1,  1,  5,  5,  1,  1,  6,  6,  2,  2,  1,  1,
1515
     3,  3,  7,  7,  1,  1,  8,  8,  1,  1,  2,  2,  1,  9,  1,  9,
1516
     4,  4, 10,  1,  1, 10,  1,  1, 11, 11,  3,  3,  1,  2,  1,  2,
1517
     1,  1, 12, 12,  5,  5,  1,  1, 13,  1,  1, 13,  2,  2,  1,  1,
1518
     6,  6,  1,  1,  4, 14,  4, 14,  3,  1,  3,  1,  1,  1, 15,  7,
1519
    15,  2,  2,  7,  1,  1,  1,  8,  1,  8, 16, 16,  1,  1,  1,  1,
1520
     2,  1,  1,  2,  1,  1,  3,  5,  5,  3,  4,  1,  1,  4,  1,  1,
1521
    17, 17,  9,  1,  1,  9,  2,  2,  1,  1, 10, 10,  1,  6,  1,  1,
1522
     6, 18,  1,  1, 18,  1,  1,  1,  2,  2,  3,  1,  3,  1,  1,  1,
1523
     4,  1, 19,  1, 19,  7,  1,  1, 20,  1,  4, 20,  1,  7, 11,  2,
1524
     1, 11, 21,  2,  8,  5,  1,  8,  1,  5, 21,  1,  1,  1, 22,  1,
1525
     1, 22,  1,  1,  3,  3,  1, 23,  2, 12, 24,  1,  1,  2,  1,  1,
1526
    12, 23,  1,  1, 24,  1,  1,  1,  4,  1,  1,  1,  2,  1,  6,  6,
1527
     4,  2,  1,  1,  1,  1,  1,  1,  1, 14, 13,  3,  1, 25,  9, 25,
1528
    14,  1,  9,  3, 13,  1,  1,  1,  1,  1, 10,  1,  1,  2, 10,  2},
1529
1530
    /* value table */
1531
    {-20,  -1,   0,   2,  -2,   1,  -1,   3,  -3,   1,  -1,   4,  -4,   0,   2,  -2,
1532
       1,   5,  -1,  -5,   6,  -6,   1,  -1,   7,  -7,   1,  -1,   3,  -3,   8,  -8,
1533
       2,  -2,   1,  -1,   9,  -9,   1,  -1,  10, -10,   4,  -4,  11,   1, -11,  -1,
1534
       2,  -2,   1,  12, -12,  -1,  13, -13,   1,  -1,   3,  -3,  14,   5, -14,  -5,
1535
     -15,  15,  -1,   1,   2,  -2,  16, -16,   1,  17, -17,  -1,   6,  -6,  18, -18,
1536
       2,  -2, -19,  19,  -3,   1,   3,  -1,   4,  20,  -4,   1, -21,  21,   1,   2,
1537
      -1,  -7,   7,  -2,  22, -22,  23,   2, -23,  -2,   1,  -1, -24,  24, -25,  25,
1538
      -8, -26,  26,   8, -27,  27,   5,   3,  -3,  -5,  -4,  28, -28,   4,  29, -29,
1539
       1,  -1,  -2, -30,  30,   2,   9,  -9, -31,  31,   2,  -2, -32,   3,  32, -33,
1540
      -3,   1,  33, -34,  -1,  34, -35,  35, -10,  10,  -6,  36,   6, -36,  37, -37,
1541
      -5,  38,   1, -38,  -1,   3,  39, -39,  -1,  40,   5,   1, -40,  -3,   2, -11,
1542
     -41,  -2,   1,  11,  -3,  -4,  41,   3,  42,   4,  -1, -43, -42,  43,   1, -44,
1543
      45,  -1,  44, -45,  -7,   7, -46,   1, -12,   2,   1, -47,  46,  12,  47,  48,
1544
      -2,  -1, -48,  49,  -1, -50, -49,  50,  -6, -51,  51,  52, -13,  53,  -4,   4,
1545
       6,  13, -53, -52, -54,  55,  54, -55, -56,  -2,   2,  -8,  56,   1,  -3,  -1,
1546
       2,  58,   3,   8,  -2,  57, -58, -60, -59, -57,  -3,  60,  59, -14,   3,  14}
1547
},{
1548
    /* MapTab7 */
1549
    2,  /* eob_sym */
1550
    38, /* esc_sym */
1551
    /* run table */
1552
    {1,  1,  0,  2,  2,  1,  1,  3,  3,  4,  4,  5,  5,  1,  1,  6,
1553
     6,  2,  2,  7,  7,  8,  8,  1,  1,  3,  3,  9,  9, 10, 10,  1,
1554
     1,  2,  2,  4,  4, 11,  0, 11, 12, 12, 13, 13,  1,  1,  5,  5,
1555
    14, 14, 15, 16, 15, 16,  3,  3,  1,  6,  1,  6,  2,  2,  7,  7,
1556
     8,  8, 17, 17,  1,  1,  4,  4, 18, 18,  2,  2,  1, 19,  1, 20,
1557
    19, 20, 21, 21,  3,  3, 22, 22,  5,  5, 24,  1,  1, 23,  9, 23,
1558
    24,  9,  2,  2, 10,  1,  1, 10,  6,  6, 25,  4,  4, 25,  7,  7,
1559
    26,  8,  1,  8,  3,  1, 26,  3, 11, 11, 27, 27,  2, 28,  1,  2,
1560
    28,  1, 12, 12,  5,  5, 29, 13, 13, 29, 32,  1,  1, 33, 31, 30,
1561
    32,  4, 30, 33,  4, 31,  3, 14,  1,  1,  3, 34, 34,  2,  2, 14,
1562
     6,  6, 35, 36, 35, 36,  1, 15,  1, 16, 16, 15,  7,  9,  7,  9,
1563
    37,  8,  8, 37,  1,  1, 39,  2, 38, 39,  2, 40,  5, 38, 40,  5,
1564
     3,  3,  4,  4, 10, 10,  1,  1,  1,  1, 41,  2, 41,  2,  6,  6,
1565
     1,  1, 11, 42, 11, 43,  3, 42,  3, 17,  4, 43,  1, 17,  7,  1,
1566
     8, 44,  4,  7, 44,  5,  8,  2,  5,  1,  2, 48, 45,  1, 12, 45,
1567
    12, 48, 13, 13,  1,  9,  9, 46,  1, 46, 47, 47, 49, 18, 18, 49},
1568
1569
    /* value table */
1570
    { 1,  -1,   0,   1,  -1,   2,  -2,   1,  -1,   1,  -1,   1,  -1,   3,  -3,   1,
1571
     -1,  -2,   2,   1,  -1,   1,  -1,   4,  -4,  -2,   2,   1,  -1,   1,  -1,   5,
1572
     -5,  -3,   3,   2,  -2,   1,   0,  -1,   1,  -1,   1,  -1,   6,  -6,   2,  -2,
1573
      1,  -1,   1,   1,  -1,  -1,  -3,   3,   7,   2,  -7,  -2,  -4,   4,   2,  -2,
1574
      2,  -2,   1,  -1,   8,  -8,   3,  -3,   1,  -1,  -5,   5,   9,   1,  -9,   1,
1575
     -1,  -1,   1,  -1,  -4,   4,   1,  -1,   3,  -3,   1, -10,  10,   1,   2,  -1,
1576
     -1,  -2,   6,  -6,   2,  11, -11,  -2,   3,  -3,   1,  -4,   4,  -1,   3,  -3,
1577
      1,   3,  12,  -3,  -5, -12,  -1,   5,   2,  -2,   1,  -1,  -7,   1,  13,   7,
1578
     -1, -13,   2,  -2,   4,  -4,   1,   2,  -2,  -1,   1,  14, -14,   1,   1,   1,
1579
     -1,  -5,  -1,  -1,   5,  -1,  -6,   2, -15,  15,   6,   1,  -1,  -8,   8,  -2,
1580
     -4,   4,   1,   1,  -1,  -1,  16,   2, -16,  -2,   2,  -2,   4,   3,  -4,  -3,
1581
     -1,  -4,   4,   1, -17,  17,  -1,  -9,   1,   1,   9,   1,  -5,  -1,  -1,   5,
1582
     -7,   7,   6,  -6,   3,  -3,  18, -18,  19, -19,   1, -10,  -1,  10,  -5,   5,
1583
     20, -20,  -3,   1,   3,   1,   8,  -1,  -8,   2,   7,  -1, -21,  -2,   5,  21,
1584
      5,  -1,  -7,  -5,   1,  -6,  -5, -11,   6,  22,  11,   1,   1, -22,  -3,  -1,
1585
      3,  -1,   3,  -3, -23,   4,  -4,   1,  23,  -1,   1,  -1,   1,  -2,   2,  -1}
1586
},{
1587
    /* MapTab8 */
1588
    4,  /* eob_sym */
1589
    11, /* esc_sym */
1590
    /* run table */
1591
    {1,  1,  1,  1,  0,  2,  2,  1,  1,  3,  3,  0,  1,  1,  2,  2,
1592
     4,  4,  1,  1,  5,  5,  1,  1,  2,  2,  3,  3,  6,  6,  1,  1,
1593
     7,  7,  8,  1,  8,  2,  2,  1,  4,  4,  1,  3,  1,  3,  9,  9,
1594
     2,  2,  1,  5,  1,  5, 10, 10,  1,  1, 11, 11,  3,  6,  3,  4,
1595
     4,  6,  2,  2,  1, 12,  1, 12,  7, 13,  7, 13,  1,  1,  8,  8,
1596
     2,  2, 14, 14, 16, 15, 16,  5,  5,  1,  3, 15,  1,  3,  4,  4,
1597
     1,  1, 17, 17,  2,  2,  6,  6,  1, 18,  1, 18, 22, 21, 22, 21,
1598
    25, 24, 25, 19,  9, 20,  9, 23, 19, 24, 20,  3, 23,  7,  3,  1,
1599
     1,  7, 28, 26, 29,  5, 28, 26,  5,  8, 29,  4,  8, 27,  2,  2,
1600
     4, 27,  1,  1, 10, 36, 10, 33, 33, 36, 30,  1, 32, 32,  1, 30,
1601
     6, 31, 31, 35,  3,  6, 11, 11,  3,  2, 35,  2, 34,  1, 34,  1,
1602
    37, 37, 12,  7, 12,  5, 41,  5,  4,  7,  1,  8, 13,  4,  1, 41,
1603
    13, 38,  8, 38,  9,  1, 40, 40,  9,  1, 39,  2,  2, 49, 39, 42,
1604
     3,  3, 14, 16, 49, 14, 16, 42, 43, 43,  6,  6, 15,  1,  1, 15,
1605
    44, 44,  1,  1, 50, 48,  4,  5,  4,  7,  5,  2, 10, 10, 48,  7,
1606
    50, 45,  2,  1, 45,  8,  8,  1, 46, 46,  3, 47, 47,  3,  1,  1},
1607
1608
    /* value table */
1609
    { 1,  -1,   2,  -2,   0,   1,  -1,   3,  -3,   1,  -1,   0,   4,  -4,   2,  -2,
1610
      1,  -1,   5,  -5,   1,  -1,   6,  -6,   3,  -3,   2,  -2,   1,  -1,   7,  -7,
1611
      1,  -1,   1,   8,  -1,   4,  -4,  -8,   2,  -2,   9,   3,  -9,  -3,   1,  -1,
1612
      5,  -5,  10,   2, -10,  -2,   1,  -1,  11, -11,   1,  -1,  -4,   2,   4,   3,
1613
     -3,  -2,   6,  -6,  12,   1, -12,  -1,   2,   1,  -2,  -1,  13, -13,   2,  -2,
1614
      7,  -7,   1,  -1,   1,   1,  -1,   3,  -3,  14,   5,  -1, -14,  -5,   4,  -4,
1615
     15, -15,   1,  -1,   8,  -8,  -3,   3,  16,   1, -16,  -1,   1,   1,  -1,  -1,
1616
      1,   1,  -1,   1,   2,   1,  -2,   1,  -1,  -1,  -1,   6,  -1,   3,  -6,  17,
1617
    -17,  -3,   1,   1,   1,   4,  -1,  -1,  -4,   3,  -1,   5,  -3,  -1,  -9,   9,
1618
     -5,   1,  18, -18,   2,   1,  -2,   1,  -1,  -1,   1,  19,  -1,   1, -19,  -1,
1619
      4,   1,  -1,   1,   7,  -4,  -2,   2,  -7,  10,  -1, -10,   1,  20,  -1, -20,
1620
      1,  -1,   2,   4,  -2,   5,   1,  -5,   6,  -4,  21,   4,   2,  -6, -21,  -1,
1621
     -2,   1,  -4,  -1,  -3,  22,  -1,   1,   3, -22,  -1,  11, -11,   1,   1,   1,
1622
      8,  -8,   2,   2,  -1,  -2,  -2,  -1,   1,  -1,  -5,   5,   2,  23, -23,  -2,
1623
      1,  -1,  24, -24,  -1,  -1,   7,   6,  -7,   5,  -6,  12,  -3,   3,   1,  -5,
1624
      1,   1, -12,  25,  -1,  -5,   5, -25,  -1,   1,   9,   1,  -1,  -9,  26, -26}
1625
}
1626
};