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

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

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

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

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

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

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

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

2949
        if (idx1 == band->rv_map->eob_sym || idx2 == band->rv_map->eob_sym)
999
            band->rv_map->eob_sym ^= idx1 ^ idx2;
1000

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

2949
        if (idx1 == band->rv_map->eob_sym || idx2 == band->rv_map->eob_sym)
1059
            band->rv_map->eob_sym ^= idx1 ^ idx2;
1060

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

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

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

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