GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/ivi.c Lines: 410 607 67.5 %
Date: 2021-04-18 10:33:33 Branches: 246 436 56.4 %

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
#include "libavutil/thread.h"
34
35
#define BITSTREAM_READER_LE
36
#include "avcodec.h"
37
#include "get_bits.h"
38
#include "internal.h"
39
#include "ivi.h"
40
#include "ivi_dsp.h"
41
42
/**
43
 * These are 2x8 predefined Huffman codebooks for coding macroblock/block
44
 * signals. They are specified using "huffman descriptors" in order to
45
 * avoid huge static tables. The decoding tables will be generated at
46
 * startup from these descriptors.
47
 */
48
/** static macroblock huffman tables */
49
static const IVIHuffDesc ivi_mb_huff_desc[8] = {
50
    {8,  {0, 4, 5, 4, 4, 4, 6, 6}},
51
    {12, {0, 2, 2, 3, 3, 3, 3, 5, 3, 2, 2, 2}},
52
    {12, {0, 2, 3, 4, 3, 3, 3, 3, 4, 3, 2, 2}},
53
    {12, {0, 3, 4, 4, 3, 3, 3, 3, 3, 2, 2, 2}},
54
    {13, {0, 4, 4, 3, 3, 3, 3, 2, 3, 3, 2, 1, 1}},
55
    {9,  {0, 4, 4, 4, 4, 3, 3, 3, 2}},
56
    {10, {0, 4, 4, 4, 4, 3, 3, 2, 2, 2}},
57
    {12, {0, 4, 4, 4, 3, 3, 2, 3, 2, 2, 2, 2}}
58
};
59
60
/** static block huffman tables */
61
static const IVIHuffDesc ivi_blk_huff_desc[8] = {
62
    {10, {1, 2, 3, 4, 4, 7, 5, 5, 4, 1}},
63
    {11, {2, 3, 4, 4, 4, 7, 5, 4, 3, 3, 2}},
64
    {12, {2, 4, 5, 5, 5, 5, 6, 4, 4, 3, 1, 1}},
65
    {13, {3, 3, 4, 4, 5, 6, 6, 4, 4, 3, 2, 1, 1}},
66
    {11, {3, 4, 4, 5, 5, 5, 6, 5, 4, 2, 2}},
67
    {13, {3, 4, 5, 5, 5, 5, 6, 4, 3, 3, 2, 1, 1}},
68
    {13, {3, 4, 5, 5, 5, 6, 5, 4, 3, 3, 2, 1, 1}},
69
    {9,  {3, 4, 4, 5, 5, 5, 6, 5, 5}}
70
};
71
72
static VLC ivi_mb_vlc_tabs [8]; ///< static macroblock Huffman tables
73
static VLC ivi_blk_vlc_tabs[8]; ///< static block Huffman tables
74
75
typedef void (*ivi_mc_func) (int16_t *buf, const int16_t *ref_buf,
76
                             ptrdiff_t pitch, int mc_type);
77
typedef void (*ivi_mc_avg_func) (int16_t *buf, const int16_t *ref_buf1,
78
                                 const int16_t *ref_buf2,
79
                                 ptrdiff_t pitch, int mc_type, int mc_type2);
80
81
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
 *  Generate a huffman codebook from the given descriptor
120
 *  and convert it into the FFmpeg VLC table.
121
 *
122
 *  @param[in]   cb    pointer to codebook descriptor
123
 *  @param[out]  vlc   where to place the generated VLC table
124
 *  @param[in]   flag  flag: 1 - for static or 0 for dynamic tables
125
 *  @return     result code: 0 - OK, -1 = error (invalid codebook descriptor)
126
 */
127
147
static int ivi_create_huff_from_desc(const IVIHuffDesc *cb, VLC *vlc, int flag)
128
{
129
    int         pos, i, j, codes_per_row, prefix, not_last_row;
130
    uint16_t    codewords[256]; /* FIXME: move this temporal storage out? */
131
    uint8_t     bits[256];
132
133
147
    pos = 0; /* current position = 0 */
134
135
1574
    for (i = 0; i < cb->num_rows; i++) {
136
1427
        codes_per_row = 1 << cb->xbits[i];
137
1427
        not_last_row  = (i != cb->num_rows - 1);
138
1427
        prefix        = ((1 << i) - 1) << (cb->xbits[i] + not_last_row);
139
140
34083
        for (j = 0; j < codes_per_row; j++) {
141
32695
            if (pos >= 256) /* Some Indeo5 codebooks can have more than 256 */
142
39
                break;      /* elements, but only 256 codes are allowed! */
143
144
32656
            bits[pos] = i + cb->xbits[i] + not_last_row;
145
32656
            if (bits[pos] > IVI_VLC_BITS)
146
                return AVERROR_INVALIDDATA; /* invalid descriptor */
147
148
32656
            codewords[pos] = prefix | j;
149
32656
            if (!bits[pos])
150
                bits[pos] = 1;
151
152
32656
            pos++;
153
        }//for j
154
    }//for i
155
156
    /* number of codewords = pos */
157
147
    return init_vlc(vlc, IVI_VLC_BITS, pos, bits, 1, 1, codewords, 2, 2,
158
                    (flag ? INIT_VLC_USE_NEW_STATIC : 0) | INIT_VLC_OUTPUT_LE);
159
}
160
161
2
static av_cold void ivi_init_static_vlc(void)
162
{
163
    int i;
164
    static VLC_TYPE table_data[8192 * 16][2];
165
166
18
    for (i = 0; i < 8; i++) {
167
16
        ivi_mb_vlc_tabs[i].table = table_data + i * 2 * 8192;
168
16
        ivi_mb_vlc_tabs[i].table_allocated = 8192;
169
16
        ivi_create_huff_from_desc(&ivi_mb_huff_desc[i],
170
                                  &ivi_mb_vlc_tabs[i], 1);
171
16
        ivi_blk_vlc_tabs[i].table = table_data + (i * 2 + 1) * 8192;
172
16
        ivi_blk_vlc_tabs[i].table_allocated = 8192;
173
16
        ivi_create_huff_from_desc(&ivi_blk_huff_desc[i],
174
                                  &ivi_blk_vlc_tabs[i], 1);
175
    }
176
2
}
177
178
4
av_cold void ff_ivi_init_static_vlc(void)
179
{
180
    static AVOnce init_static_once = AV_ONCE_INIT;
181
4
    ff_thread_once(&init_static_once, ivi_init_static_vlc);
182
4
}
183
184
/*
185
 *  Copy huffman codebook descriptors.
186
 *
187
 *  @param[out]  dst  ptr to the destination descriptor
188
 *  @param[in]   src  ptr to the source descriptor
189
 */
190
115
static void ivi_huff_desc_copy(IVIHuffDesc *dst, const IVIHuffDesc *src)
191
{
192
115
    dst->num_rows = src->num_rows;
193
115
    memcpy(dst->xbits, src->xbits, src->num_rows);
194
115
}
195
196
/*
197
 *  Compare two huffman codebook descriptors.
198
 *
199
 *  @param[in]  desc1  ptr to the 1st descriptor to compare
200
 *  @param[in]  desc2  ptr to the 2nd descriptor to compare
201
 *  @return         comparison result: 0 - equal, 1 - not equal
202
 */
203
215
static int ivi_huff_desc_cmp(const IVIHuffDesc *desc1,
204
                             const IVIHuffDesc *desc2)
205
{
206
335
    return desc1->num_rows != desc2->num_rows ||
207
120
           memcmp(desc1->xbits, desc2->xbits, desc1->num_rows);
208
}
209
210
1035
int ff_ivi_dec_huff_desc(GetBitContext *gb, int desc_coded, int which_tab,
211
                         IVIHuffTab *huff_tab, AVCodecContext *avctx)
212
{
213
    int i, result;
214
    IVIHuffDesc new_huff;
215
216
1035
    if (!desc_coded) {
217
        /* select default table */
218
101
        huff_tab->tab = (which_tab) ? &ivi_blk_vlc_tabs[7]
219
101
                                    : &ivi_mb_vlc_tabs [7];
220
101
        return 0;
221
    }
222
223
934
    huff_tab->tab_sel = get_bits(gb, 3);
224
934
    if (huff_tab->tab_sel == 7) {
225
        /* custom huffman table (explicitly encoded) */
226
215
        new_huff.num_rows = get_bits(gb, 4);
227
215
        if (!new_huff.num_rows) {
228
            av_log(avctx, AV_LOG_ERROR, "Empty custom Huffman table!\n");
229
            return AVERROR_INVALIDDATA;
230
        }
231
232
2107
        for (i = 0; i < new_huff.num_rows; i++)
233
1892
            new_huff.xbits[i] = get_bits(gb, 4);
234
235
        /* Have we got the same custom table? Rebuild if not. */
236

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

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


12
            av_assert0(!band->bufs[0] && !band->bufs[1] &&
342
                       !band->bufs[2] && !band->bufs[3]);
343
12
            band->bufsize  = buf_size/2;
344
12
            av_assert0(buf_size % 2 == 0);
345
346
            /* reset custom vlc */
347
12
            planes[p].bands[0].blk_vlc.cust_desc.num_rows = 0;
348
        }
349
    }
350
351
4
    return 0;
352
}
353
354
6
static int ivi_init_tiles(const IVIBandDesc *band, IVITile *ref_tile,
355
                          int p, int b, int t_height, int t_width)
356
{
357
    int x, y;
358
6
    IVITile *tile = band->tiles;
359
360
12
    for (y = 0; y < band->height; y += t_height) {
361
12
        for (x = 0; x < band->width; x += t_width) {
362
6
            tile->xpos     = x;
363
6
            tile->ypos     = y;
364
6
            tile->mb_size  = band->mb_size;
365
6
            tile->width    = FFMIN(band->width - x,  t_width);
366
6
            tile->height   = FFMIN(band->height - y, t_height);
367
6
            tile->is_empty = tile->data_size = 0;
368
            /* calculate number of macroblocks */
369
6
            tile->num_MBs  = IVI_MBs_PER_TILE(tile->width, tile->height,
370
                                              band->mb_size);
371
372
6
            av_freep(&tile->mbs);
373
6
            tile->mbs = av_mallocz_array(tile->num_MBs, sizeof(IVIMbInfo));
374
6
            if (!tile->mbs)
375
                return AVERROR(ENOMEM);
376
377
6
            tile->ref_mbs = 0;
378

6
            if (p || b) {
379
4
                if (tile->num_MBs != ref_tile->num_MBs) {
380
                    av_log(NULL, AV_LOG_DEBUG, "ref_tile mismatch\n");
381
                    return AVERROR_INVALIDDATA;
382
                }
383
4
                tile->ref_mbs = ref_tile->mbs;
384
4
                ref_tile++;
385
            }
386
6
            tile++;
387
        }
388
    }
389
390
6
    return 0;
391
}
392
393
2
av_cold int ff_ivi_init_tiles(IVIPlaneDesc *planes,
394
                              int tile_width, int tile_height)
395
{
396
    int p, b, x_tiles, y_tiles, t_width, t_height, ret;
397
    IVIBandDesc *band;
398
399
8
    for (p = 0; p < 3; p++) {
400
6
        t_width  = !p ? tile_width  : (tile_width  + 3) >> 2;
401
6
        t_height = !p ? tile_height : (tile_height + 3) >> 2;
402
403

6
        if (!p && planes[0].num_bands == 4) {
404
            if (t_width % 2 || t_height % 2) {
405
                avpriv_request_sample(NULL, "Odd tiles");
406
                return AVERROR_PATCHWELCOME;
407
            }
408
            t_width  >>= 1;
409
            t_height >>= 1;
410
        }
411

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

1818428
        if (scan_pos >= num_coeffs || scan_pos < 0)
543
            break;
544
1818427
        pos = band->scan[scan_pos];
545
546
        if (!val)
547
            ff_dlog(avctx, "Val = 0 encountered!\n");
548
549
1818427
        q = (base_tab[pos] * quant) >> 9;
550
1818427
        if (q > 1)
551
98187
            val = val * q + FFSIGN(val) * (((q ^ 1) - 1) >> 1);
552
1818427
        trvec[pos] = val;
553
        /* track columns containing non-zero coeffs */
554
1818427
        col_flags[pos & col_mask] |= !!val;
555
    }
556
557

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

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

70985
            if (mb->type != 2 && mb->type != 3)
655
70985
                mc_type2 = -1;
656
70985
            if (mb->type) {
657
                int dmv_x, dmv_y, cx, cy;
658
659
70985
                dmv_x = mb->mv_x >> band->is_halfpel;
660
70985
                dmv_y = mb->mv_y >> band->is_halfpel;
661
70985
                cx    = mb->mv_x &  band->is_halfpel;
662
70985
                cy    = mb->mv_y &  band->is_halfpel;
663
664
70985
                if (mb->xpos + dmv_x < 0 ||
665
70985
                    mb->xpos + dmv_x + band->mb_size + cx > band->pitch ||
666
70985
                    mb->ypos + dmv_y < 0 ||
667
70985
                    mb->ypos + dmv_y + band->mb_size + cy > band->aheight) {
668
                    return AVERROR_INVALIDDATA;
669
                }
670
            }
671

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

1400
    if (ctx->pic_conf.luma_bands <= 1 && i == 2)
925
        return NULL;
926
1400
    if (!band->bufs[i])
927
15
        band->bufs[i] = av_mallocz(2 * band->bufsize);
928
1400
    return band->bufs[i];
929
}
930
931
/**
932
 *  Decode an Indeo 4 or 5 band.
933
 *
934
 *  @param[in,out]  ctx    ptr to the decoder context
935
 *  @param[in,out]  band   ptr to the band descriptor
936
 *  @param[in]      avctx  ptr to the AVCodecContext
937
 *  @return         result code: 0 = OK, -1 = error
938
 */
939
700
static int decode_band(IVI45DecContext *ctx,
940
                       IVIBandDesc *band, AVCodecContext *avctx)
941
{
942
    int         result, i, t, idx1, idx2, pos;
943
    IVITile     *tile;
944
945
700
    band->buf     = prepare_buf(ctx, band, ctx->dst_buf);
946
700
    if (!band->buf) {
947
        av_log(avctx, AV_LOG_ERROR, "Band buffer points to no data!\n");
948
        return AVERROR_INVALIDDATA;
949
    }
950

700
    if (ctx->is_indeo4 && ctx->frame_type == IVI4_FRAMETYPE_BIDIR) {
951
        band->ref_buf   = prepare_buf(ctx, band, ctx->b_ref_buf);
952
        band->b_ref_buf = prepare_buf(ctx, band, ctx->ref_buf);
953
        if (!band->b_ref_buf)
954
            return AVERROR(ENOMEM);
955
    } else {
956
700
        band->ref_buf   = prepare_buf(ctx, band, ctx->ref_buf);
957
700
        band->b_ref_buf = 0;
958
    }
959
700
    if (!band->ref_buf)
960
        return AVERROR(ENOMEM);
961
700
    band->data_ptr  = ctx->frame_data + (get_bits_count(&ctx->gb) >> 3);
962
963
700
    result = ctx->decode_band_hdr(ctx, band, avctx);
964
700
    if (result) {
965
        av_log(avctx, AV_LOG_ERROR, "Error while decoding band header: %d\n",
966
               result);
967
        return result;
968
    }
969
970
700
    if (band->is_empty) {
971
        av_log(avctx, AV_LOG_ERROR, "Empty band encountered!\n");
972
        return AVERROR_INVALIDDATA;
973
    }
974
975
700
    band->rv_map = &ctx->rvmap_tabs[band->rvmap_sel];
976
977
    /* apply corrections to the selected rvmap table if present */
978
3649
    for (i = 0; i < band->num_corr; i++) {
979
2949
        idx1 = band->corr[i * 2];
980
2949
        idx2 = band->corr[i * 2 + 1];
981
2949
        FFSWAP(uint8_t, band->rv_map->runtab[idx1], band->rv_map->runtab[idx2]);
982
2949
        FFSWAP(int16_t, band->rv_map->valtab[idx1], band->rv_map->valtab[idx2]);
983

2949
        if (idx1 == band->rv_map->eob_sym || idx2 == band->rv_map->eob_sym)
984
            band->rv_map->eob_sym ^= idx1 ^ idx2;
985

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

2949
        if (idx1 == band->rv_map->eob_sym || idx2 == band->rv_map->eob_sym)
1044
            band->rv_map->eob_sym ^= idx1 ^ idx2;
1045

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

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

233
    if (ctx->is_indeo4 && ctx->frame_type == IVI4_FRAMETYPE_INTRA) {
1168
        int left;
1169
1170
            // skip version string
1171
133
        while (get_bits(&ctx->gb, 8)) {
1172
126
            if (get_bits_left(&ctx->gb) < 8)
1173
                return AVERROR_INVALIDDATA;
1174
        }
1175
7
        left = get_bits_count(&ctx->gb) & 0x18;
1176
7
        skip_bits_long(&ctx->gb, 64 - left);
1177

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