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