GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/ivi.c Lines: 415 609 68.1 %
Date: 2019-11-18 18:00:01 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
#include "libavutil/timer.h"
34
35
#define BITSTREAM_READER_LE
36
#include "avcodec.h"
37
#include "get_bits.h"
38
#include "internal.h"
39
#include "mathops.h"
40
#include "ivi.h"
41
#include "ivi_dsp.h"
42
43
/**
44
 * These are 2x8 predefined Huffman codebooks for coding macroblock/block
45
 * signals. They are specified using "huffman descriptors" in order to
46
 * avoid huge static tables. The decoding tables will be generated at
47
 * startup from these descriptors.
48
 */
49
/** static macroblock huffman tables */
50
static const IVIHuffDesc ivi_mb_huff_desc[8] = {
51
    {8,  {0, 4, 5, 4, 4, 4, 6, 6}},
52
    {12, {0, 2, 2, 3, 3, 3, 3, 5, 3, 2, 2, 2}},
53
    {12, {0, 2, 3, 4, 3, 3, 3, 3, 4, 3, 2, 2}},
54
    {12, {0, 3, 4, 4, 3, 3, 3, 3, 3, 2, 2, 2}},
55
    {13, {0, 4, 4, 3, 3, 3, 3, 2, 3, 3, 2, 1, 1}},
56
    {9,  {0, 4, 4, 4, 4, 3, 3, 3, 2}},
57
    {10, {0, 4, 4, 4, 4, 3, 3, 2, 2, 2}},
58
    {12, {0, 4, 4, 4, 3, 3, 2, 3, 2, 2, 2, 2}}
59
};
60
61
/** static block huffman tables */
62
static const IVIHuffDesc ivi_blk_huff_desc[8] = {
63
    {10, {1, 2, 3, 4, 4, 7, 5, 5, 4, 1}},
64
    {11, {2, 3, 4, 4, 4, 7, 5, 4, 3, 3, 2}},
65
    {12, {2, 4, 5, 5, 5, 5, 6, 4, 4, 3, 1, 1}},
66
    {13, {3, 3, 4, 4, 5, 6, 6, 4, 4, 3, 2, 1, 1}},
67
    {11, {3, 4, 4, 5, 5, 5, 6, 5, 4, 2, 2}},
68
    {13, {3, 4, 5, 5, 5, 5, 6, 4, 3, 3, 2, 1, 1}},
69
    {13, {3, 4, 5, 5, 5, 6, 5, 4, 3, 3, 2, 1, 1}},
70
    {9,  {3, 4, 4, 5, 5, 5, 6, 5, 5}}
71
};
72
73
static VLC ivi_mb_vlc_tabs [8]; ///< static macroblock Huffman tables
74
static VLC ivi_blk_vlc_tabs[8]; ///< static block Huffman tables
75
76
typedef void (*ivi_mc_func) (int16_t *buf, const int16_t *ref_buf,
77
                             ptrdiff_t pitch, int mc_type);
78
typedef void (*ivi_mc_avg_func) (int16_t *buf, const int16_t *ref_buf1,
79
                                 const int16_t *ref_buf2,
80
                                 ptrdiff_t pitch, int mc_type, int mc_type2);
81
82
142082
static int ivi_mc(const IVIBandDesc *band, ivi_mc_func mc, ivi_mc_avg_func mc_avg,
83
                  int offs, int mv_x, int mv_y, int mv_x2, int mv_y2,
84
                  int mc_type, int mc_type2)
85
{
86
142082
    int ref_offs = offs + mv_y * band->pitch + mv_x;
87
142082
    int buf_size = band->pitch * band->aheight;
88
142082
    int min_size = band->pitch * (band->blk_size - 1) + band->blk_size;
89
142082
    int ref_size = (mc_type > 1) * band->pitch + (mc_type & 1);
90
91
142082
    if (mc_type != -1) {
92

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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