FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libavcodec/jpeg2000htdec.c
Date: 2023-09-22 12:20:07
Exec Total Coverage
Lines: 410 612 67.0%
Functions: 24 32 75.0%
Branches: 159 276 57.6%
Line Branch Exec Source
1 /*
2 * Copyright (c) 2022 Caleb Etemesi <etemesicaleb@gmail.com>
3 *
4 * This file is part of FFmpeg.
5 *
6 * FFmpeg is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * FFmpeg is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with FFmpeg; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19 */
20
21 /*
22 * Copyright 2019 - 2021, Osamu Watanabe
23 *
24 * Redistribution and use in source and binary forms, with or without modification,
25 * are permitted provided that the following conditions are met:
26 *
27 * 1. Redistributions of source code must retain the above copyright notice, this
28 * list of conditions and the following disclaimer.
29 *
30 * 2. Redistributions in binary form must reproduce the above copyright notice,
31 * this list of conditions and the following disclaimer in the documentation
32 * and/or other materials provided with the distribution.
33 *
34 * 3. Neither the name of the copyright holder nor the names of its contributors
35 * may be used to endorse or promote products derived from this software without
36 * specific prior written permission.
37 *
38 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS “AS IS” AND
39 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
40 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
41 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
42 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
43 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
44 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
45 * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
46 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
47 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
48 */
49
50 #include <stdint.h>
51 #include "libavutil/attributes.h"
52 #include "libavutil/common.h"
53 #include "libavutil/avassert.h"
54 #include "jpeg2000htdec.h"
55 #include "jpeg2000.h"
56 #include "jpeg2000dec.h"
57
58 #define J2K_Q1 0
59 #define J2K_Q2 1
60
61 #define HT_SHIFT_SIGMA 0
62 #define HT_SHIFT_SCAN 4
63 #define HT_SHIFT_REF 3
64 #define HT_SHIFT_REF_IND 2
65
66 /* See Rec. ITU-T T.800, Table 2 */
67 const static uint8_t mel_e[13] = { 0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 4, 5 };
68
69 static const uint16_t dec_cxt_vlc_table1[1024];
70 static const uint16_t dec_cxt_vlc_table0[1024];
71
72 typedef struct StateVars {
73 int32_t pos;
74 uint32_t bits;
75 uint32_t tmp;
76 uint32_t last;
77 uint8_t bits_left;
78 uint64_t bit_buf;
79 } StateVars;
80
81 typedef struct MelDecoderState {
82 uint8_t k;
83 uint8_t run;
84 uint8_t one;
85 } MelDecoderState;
86
87 /**
88 * Given a precomputed c, checks whether n % d == 0. c is precomputed from d
89 * using precompute_c().
90 */
91 av_always_inline
92 15680 static uint32_t is_divisible(uint32_t n, uint64_t c)
93 {
94 15680 return n * c <= c - 1;
95 }
96
97 /**
98 * Precompute the number c used by is_divisible().
99 */
100 av_always_inline
101 10 static uint64_t precompute_c(uint32_t d)
102 {
103 10 return 1 + (0xffffffffffffffffull / d);
104 }
105
106 30 static void jpeg2000_init_zero(StateVars *s)
107 {
108 30 s->bits_left = 0;
109 30 s->bit_buf = 0;
110 30 s->tmp = 0;
111 30 s->bits = 0;
112 30 s->pos = 0;
113 30 s->last = 0;
114 30 }
115
116 10 static void jpeg2000_init_mel(StateVars *s, uint32_t Pcup)
117 {
118 10 jpeg2000_init_zero(s);
119 10 s->pos = Pcup;
120 10 }
121
122 ✗ static void jpeg2000_init_mag_ref(StateVars *s, uint32_t Lref)
123 {
124 ✗ s->pos = Lref - 2;
125 ✗ s->bits = 0;
126 ✗ s->last = 0xFF;
127 ✗ s->tmp = 0;
128 ✗ s->bits_left = 0;
129 ✗ s->bit_buf = 0;
130 ✗ }
131
132 10 static void jpeg2000_init_mel_decoder(MelDecoderState *mel_state)
133 {
134 10 mel_state->k = 0;
135 10 mel_state->run = 0;
136 10 mel_state->one = 0;
137 10 }
138
139 /**
140 * Refill the buffer backwards in little endian while skipping over stuffing
141 * bits. Stuffing bits are those that appear in the position of any byte whose
142 * LSBs are all 1's if the last consumed byte was larger than 0x8F.
143 */
144 6143 static int jpeg2000_bitbuf_refill_backwards(StateVars *buffer, const uint8_t *array)
145 {
146 6143 uint64_t tmp = 0;
147 6143 int32_t position = buffer->pos - 4;
148 6143 uint32_t new_bits = 32;
149
150
2/2
✓ Branch 0 taken 5343 times.
✓ Branch 1 taken 800 times.
 6143 if (buffer->bits_left >= 32)
151 5343 return 0; // enough data, no need to pull in more bits
152
153 /**
154 * Unstuff bits. Load a temporary byte, which precedes the position we
155 * currently at, to ensure that we can also un-stuff if the stuffed bit is
156 * the bottom most bits.
157 */
158
159
2/2
✓ Branch 0 taken 3969 times.
✓ Branch 1 taken 800 times.
 4769 for(int i = FFMAX(0, position + 1); i <= buffer->pos + 1; i++)
160 3969 tmp = 256*tmp + array[i];
161
162
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 800 times.
 800 if ((tmp & 0x7FFF000000) > 0x7F8F000000) {
163 ✗ tmp &= 0x7FFFFFFFFF;
164 ✗ new_bits--;
165 }
166
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 800 times.
 800 if ((tmp & 0x007FFF0000) > 0x007F8F0000) {
167 ✗ tmp = (tmp & 0x007FFFFFFF) + ((tmp & 0xFF00000000) >> 1);
168 ✗ new_bits--;
169 }
170
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 797 times.
 800 if ((tmp & 0x00007FFF00) > 0x00007F8F00) {
171 3 tmp = (tmp & 0x00007FFFFF) + ((tmp & 0xFFFF000000) >> 1);
172 3 new_bits--;
173 }
174
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 797 times.
 800 if ((tmp & 0x0000007FFF) > 0x0000007F8F) {
175 3 tmp = (tmp & 0x0000007FFF) + ((tmp & 0xFFFFFF0000) >> 1);
176 3 new_bits--;
177 }
178
179 800 tmp >>= 8; // Remove temporary byte loaded
180
181 /* Add bits to the MSB of the bit buffer */
182 800 buffer->bit_buf |= tmp << buffer->bits_left;
183 800 buffer->bits_left += new_bits;
184 800 buffer->pos = FFMAX(0, position);
185 800 return 0;
186 }
187
188 /**
189 * Refill the bit-buffer reading new bits going forward
190 * in the stream while skipping over stuffed bits.
191 */
192 1191 static void jpeg2000_bitbuf_refill_forward(StateVars *buffer, const uint8_t *array,
193 uint32_t length)
194 {
195
2/2
✓ Branch 0 taken 4762 times.
✓ Branch 1 taken 1191 times.
 5953 while (buffer->bits_left < 32) {
196 4762 buffer->tmp = 0xFF;
197
2/2
✓ Branch 0 taken 5 times.
✓ Branch 1 taken 4757 times.
 4762 buffer->bits = (buffer->last == 0xFF) ? 7 : 8;
198
2/2
✓ Branch 0 taken 4748 times.
✓ Branch 1 taken 14 times.
 4762 if (buffer->pos <= length) {
199 4748 buffer->tmp = array[buffer->pos];
200 4748 buffer->pos += 1;
201 4748 buffer->last = buffer->tmp;
202 }
203 4762 buffer->bit_buf |= ((uint64_t) buffer->tmp) << buffer->bits_left;
204 4762 buffer->bits_left += buffer->bits;
205 }
206 1191 }
207
208 /**
209 * Drops bits from lower bits in the bit buffer. buf contains the bit buffers.
210 * nbits is the number of bits to remove.
211 */
212 av_always_inline
213 18441 static void jpeg2000_bitbuf_drop_bits_lsb(StateVars *buf, uint8_t nbits)
214 {
215 av_assert2(buf->bits_left >= nbits); // cannot read more bits than available
216 18441 buf->bit_buf >>= nbits;
217 18441 buf->bits_left -= nbits;
218 18441 }
219
220 /**
221 * Get bits from the bit buffer reading them from the least significant bits
222 * moving to the most significant bits. In case there are fewer bits, refill
223 * from buf moving backwards.
224 */
225 av_always_inline
226 1548 static uint64_t jpeg2000_bitbuf_get_bits_lsb(StateVars *bit_stream, uint8_t nbits,
227 const uint8_t *buf)
228 {
229 uint64_t bits;
230 1548 uint64_t mask = (1ull << nbits) - 1;
231
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1548 times.
 1548 if (bit_stream->bits_left < nbits)
232 ✗ jpeg2000_bitbuf_refill_backwards(bit_stream, buf);
233 1548 bits = bit_stream->bit_buf & mask;
234 1548 jpeg2000_bitbuf_drop_bits_lsb(bit_stream, nbits);
235 1548 return bits;
236 }
237
238 /**
239 * Get bits from the bit buffer reading them from the least significant bits
240 * moving to the most significant bits. In case there are fewer bits, refill from
241 * buf moving forward.
242 */
243 av_always_inline
244 10869 static uint64_t jpeg2000_bitbuf_get_bits_lsb_forward(StateVars *bit_stream,
245 uint8_t nbits, const uint8_t *buf,
246 uint32_t length)
247 {
248 uint64_t bits;
249 10869 uint64_t mask = (1ull << nbits) - 1;
250
251
2/2
✓ Branch 0 taken 1181 times.
✓ Branch 1 taken 9688 times.
 10869 if (bit_stream->bits_left <= nbits)
252 1181 jpeg2000_bitbuf_refill_forward(bit_stream, buf, length);
253 10869 bits = bit_stream->bit_buf & mask;
254 10869 jpeg2000_bitbuf_drop_bits_lsb(bit_stream, nbits);
255 10869 return bits;
256 }
257
258 /**
259 * Look ahead bit buffer without discarding bits.
260 */
261 av_always_inline
262 1929 static uint64_t jpeg2000_bitbuf_peek_bits_lsb(StateVars *stream, uint8_t nbits)
263 {
264 1929 uint64_t mask = (1ull << nbits) - 1;
265 1929 return stream->bit_buf & mask;
266 }
267
268 10 static void jpeg2000_init_vlc(StateVars *s, uint32_t Lcup, uint32_t Pcup,
269 const uint8_t *Dcup)
270 {
271 10 s->bits_left = 0;
272 10 s->bit_buf = 0;
273 10 s->pos = Lcup - 2 - Pcup;
274 10 s->last = Dcup[Lcup - 2];
275 10 s->tmp = (s->last) >> 4;
276
2/2
✓ Branch 0 taken 8 times.
✓ Branch 1 taken 2 times.
 10 s->bits = ((s->tmp & 7) < 7) ? 4 : 3;
277
278 10 jpeg2000_bitbuf_refill_backwards(s, Dcup + Pcup);
279 10 jpeg2000_bitbuf_drop_bits_lsb(s, 4);
280 10 }
281
282 /**
283 * Decode prefix codes for VLC segment. See Rec. ITU-T T.814, 7.3.5.
284 */
285 av_always_inline
286 4085 static int jpeg2000_decode_ctx_vlc(const Jpeg2000DecoderContext *s,
287 StateVars *vlc_stream, const uint16_t *table,
288 const uint8_t *Dcup, uint8_t *sig_pat,
289 uint8_t *res_off, uint8_t *emb_pat_k,
290 uint8_t *emb_pat_1, uint8_t pos,
291 uint32_t Pcup, uint16_t context)
292 {
293 uint32_t value;
294 uint8_t len;
295 uint64_t index;
296 uint64_t code_word;
297
298 4085 jpeg2000_bitbuf_refill_backwards(vlc_stream, Dcup + Pcup);
299
300 4085 code_word = vlc_stream->bit_buf & 0x7f;
301 4085 index = code_word + (context << 7);
302
303
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4085 times.
 4085 av_assert0(index < 1024); // The CxtVLC table has 1024 entries.
304
305 4085 value = table[index];
306
307 4085 len = (value & 0x000F) >> 1;
308
309 4085 res_off[pos] = (uint8_t) (value & 1);
310 4085 sig_pat[pos] = (uint8_t) ((value & 0x00F0) >> 4);
311 4085 emb_pat_k[pos] = (uint8_t) ((value & 0x0F00) >> 8);
312 4085 emb_pat_1[pos] = (uint8_t) ((value & 0xF000) >> 12);
313
314 4085 jpeg2000_bitbuf_drop_bits_lsb(vlc_stream, len);
315 4085 return 0;
316 }
317
318 /**
319 * Decode variable length u-vlc prefix. See decodeUPrefix procedure at Rec.
320 * ITU-T T.814, 7.3.6.
321 */
322 av_always_inline
323 1548 static uint8_t vlc_decode_u_prefix(StateVars *vlc_stream, const uint8_t *refill_array)
324 {
325 static const uint8_t return_value[8] = { 5, 1, 2, 1, 3, 1, 2, 1 };
326 static const uint8_t drop_bits[8] = { 3, 1, 2, 1, 3, 1, 2, 1 };
327
328 uint8_t bits;
329
330
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1548 times.
 1548 if (vlc_stream->bits_left < 3)
331 ✗ jpeg2000_bitbuf_refill_backwards(vlc_stream, refill_array);
332
333 1548 bits = jpeg2000_bitbuf_peek_bits_lsb(vlc_stream, 3);
334
335 1548 jpeg2000_bitbuf_drop_bits_lsb(vlc_stream, drop_bits[bits]);
336 1548 return return_value[bits];
337 }
338
339 /**
340 * Decode variable length u-vlc suffix. See decodeUSuffix procedure at Rec.
341 * ITU-T T.814, 7.3.6.
342 */
343 av_always_inline
344 1548 static uint8_t vlc_decode_u_suffix(StateVars *vlc_stream, uint8_t suffix,
345 const uint8_t *refill_array)
346 {
347 static const int mask[] = { 1, 31 };
348 static const int drop_bits[] = { 1, 5 };
349
350 uint8_t bits;
351 1548 int cond = suffix != 3;
352
2/2
✓ Branch 0 taken 1167 times.
✓ Branch 1 taken 381 times.
 1548 if (suffix < 3)
353 1167 return 0;
354
355
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 381 times.
 381 if (vlc_stream->bits_left < 5)
356 ✗ jpeg2000_bitbuf_refill_backwards(vlc_stream, refill_array);
357
358 381 bits = jpeg2000_bitbuf_peek_bits_lsb(vlc_stream, 5);
359
360 381 jpeg2000_bitbuf_drop_bits_lsb(vlc_stream, drop_bits[cond]);
361 381 return bits & mask[cond];
362 }
363
364 /**
365 * Decode u-vlc extension values. See decodeUExtension procedure at Rec. ITU-T
366 * T.814, 7.3.6.
367 */
368 av_always_inline
369 1548 static uint8_t vlc_decode_u_extension(StateVars *vlc_stream, uint8_t suffix,
370 const uint8_t *refill_array)
371 {
372
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1548 times.
 1548 return jpeg2000_bitbuf_get_bits_lsb(vlc_stream, 4 * (suffix >= 28), refill_array);
373 }
374
375 /**
376 * Magnitude and Sign decode procedures. See decodeMagSgnValue procedure at Rec.
377 * ITU-T T.814, 7.3.8.
378 */
379 av_always_inline
380 16384 static int32_t jpeg2000_decode_mag_sgn(StateVars *mag_sgn_stream, int32_t m_n,
381 int32_t i_n, const uint8_t *buf, uint32_t length)
382 {
383 16384 int32_t val = 0;
384
2/2
✓ Branch 0 taken 10869 times.
✓ Branch 1 taken 5515 times.
 16384 if (m_n > 0) {
385 10869 val = jpeg2000_bitbuf_get_bits_lsb_forward(mag_sgn_stream,m_n,buf,length);
386 10869 val += (i_n << m_n);
387 }
388 16384 return val;
389 }
390
391 av_always_inline
392 4096 static void recover_mag_sgn(StateVars *mag_sgn, uint8_t pos, uint16_t q, int32_t m_n[2],
393 int32_t known_1[2], const uint8_t emb_pat_1[2],
394 int32_t v[2][4], int32_t m[2][4], uint8_t *E,
395 uint32_t *mu_n, const uint8_t *Dcup, uint32_t Pcup,
396 uint32_t pLSB)
397 {
398
2/2
✓ Branch 0 taken 16384 times.
✓ Branch 1 taken 4096 times.
 20480 for (int i = 0; i < 4; i++) {
399 16384 int32_t n = 4 * q + i;
400 16384 m_n[pos] = m[pos][i];
401 16384 known_1[pos] = (emb_pat_1[pos] >> i) & 1;
402 16384 v[pos][i] = jpeg2000_decode_mag_sgn(mag_sgn, m_n[pos], known_1[pos], Dcup, Pcup);
403
404
2/2
✓ Branch 0 taken 10869 times.
✓ Branch 1 taken 5515 times.
 16384 if (m_n[pos] != 0) {
405 10869 E[n] = 32 - ff_clz(v[pos][i] | 1);
406 10869 mu_n[n] = (v[pos][i] >> 1) + 1;
407 10869 mu_n[n] <<= pLSB;
408 10869 mu_n[n] |= ((uint32_t) (v[pos][i] & 1)) << 31; // sign bit.
409 }
410 }
411 4096 }
412
413 109 static int jpeg2000_import_bit(StateVars *stream, const uint8_t *array, uint32_t length)
414 {
415 109 int cond = stream->pos <= length;
416 109 int pos = FFMIN(stream->pos, length);
417
2/2
✓ Branch 0 taken 19 times.
✓ Branch 1 taken 90 times.
 109 if (stream->bits == 0) {
418
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 19 times.
 19 stream->bits = (stream->tmp == 0xFF) ? 7 : 8;
419 19 stream->pos += cond;
420
1/2
✓ Branch 0 taken 19 times.
✗ Branch 1 not taken.
 19 stream->tmp = cond ? array[pos] : 0xFF;
421 }
422 109 stream->bits -= 1;
423 109 return (stream->tmp >> stream->bits) & 1;
424 }
425
426 ✗ static int jpeg2000_peek_bit(StateVars *stream, const uint8_t *array, uint32_t length)
427 {
428 ✗ if (stream->bits == 0) {
429 ✗ int cond = stream->pos <= length;
430 ✗ int pos = FFMIN(stream->pos, length);
431 ✗ stream->bits = (stream->tmp == 0xFF) ? 7 : 8;
432 ✗ stream->pos += cond;
433 ✗ stream->tmp = cond ? array[pos] : 0xFF;
434 }
435 ✗ return (stream->tmp >> stream->bits) & 1;
436 }
437
438 109 static int jpeg2000_decode_mel_sym(MelDecoderState *mel_state,
439 StateVars *mel_stream,
440 const uint8_t *Dcup,
441 uint32_t Lcup)
442 {
443
444
2/4
✓ Branch 0 taken 109 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 109 times.
✗ Branch 3 not taken.
 109 if (mel_state->run == 0 && mel_state->one == 0) {
445 uint8_t eval;
446 uint8_t bit;
447
448 109 eval = mel_e[mel_state->k];
449 109 bit = jpeg2000_import_bit(mel_stream, Dcup, Lcup);
450
2/2
✓ Branch 0 taken 13 times.
✓ Branch 1 taken 96 times.
 109 if (bit == 1) {
451 13 mel_state->run = 1 << eval;
452 13 mel_state->k = FFMIN(12, mel_state->k + 1);
453 } else {
454 96 mel_state->run = 0;
455
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 96 times.
 96 while (eval > 0) {
456 ✗ bit = jpeg2000_import_bit(mel_stream, Dcup, Lcup);
457 ✗ mel_state->run = (2 * (mel_state->run)) + bit;
458 ✗ eval -= 1;
459 }
460
2/2
✓ Branch 0 taken 12 times.
✓ Branch 1 taken 84 times.
 96 mel_state->k = FFMAX(0, mel_state->k - 1);
461 96 mel_state->one = 1;
462 }
463 }
464
2/2
✓ Branch 0 taken 13 times.
✓ Branch 1 taken 96 times.
 109 if (mel_state->run > 0) {
465 13 mel_state->run -= 1;
466 13 return 0;
467 } else {
468 96 mel_state->one = 0;
469 96 return 1;
470 }
471 }
472
473 /**
474 * Magref decoding procedures.
475 */
476 av_always_inline
477 ✗ static int jpeg2000_import_magref_bit(StateVars *stream, const uint8_t *array,
478 uint32_t length)
479 {
480 ✗ return jpeg2000_bitbuf_get_bits_lsb(stream, 1, array);
481 }
482
483 /**
484 * Signal EMB decode.
485 */
486 4096 static int jpeg2000_decode_sig_emb(const Jpeg2000DecoderContext *s, MelDecoderState *mel_state,
487 StateVars *mel_stream, StateVars *vlc_stream,
488 const uint16_t *vlc_table, const uint8_t *Dcup,
489 uint8_t *sig_pat, uint8_t *res_off, uint8_t *emb_pat_k,
490 uint8_t *emb_pat_1, uint8_t pos, uint16_t context,
491 uint32_t Lcup, uint32_t Pcup)
492 {
493
2/2
✓ Branch 0 taken 103 times.
✓ Branch 1 taken 3993 times.
 4096 if (context == 0) {
494 uint8_t sym;
495 103 sym = jpeg2000_decode_mel_sym(mel_state, mel_stream, Dcup, Lcup);
496
2/2
✓ Branch 0 taken 11 times.
✓ Branch 1 taken 92 times.
 103 if (sym == 0) {
497 11 sig_pat[pos] = 0;
498 11 res_off[pos] = 0;
499 11 emb_pat_k[pos] = 0;
500 11 emb_pat_1[pos] = 0;
501 11 return 0;
502 }
503 }
504 4085 return jpeg2000_decode_ctx_vlc(s, vlc_stream, vlc_table, Dcup, sig_pat,
505 res_off, emb_pat_k, emb_pat_1, pos, Pcup,
506 context);
507 }
508
509 av_always_inline
510 ✗ static int jpeg2000_get_state(int x1, int x2, int width, int shift_by,
511 const uint8_t *block_states)
512 {
513 ✗ return (block_states[(x1 + 1) * (width + 2) + (x2 + 1)] >> shift_by) & 1;
514 }
515
516 av_always_inline
517 16384 static void jpeg2000_modify_state(int x1, int x2, int width,
518 int value, uint8_t *block_states)
519 {
520 16384 block_states[(x1 + 1) * (width + 2) + (x2 + 1)] |= value;
521 16384 }
522
523 av_always_inline
524 10 static int jpeg2000_decode_ht_cleanup_segment(const Jpeg2000DecoderContext *s,
525 Jpeg2000Cblk *cblk, Jpeg2000T1Context *t1,
526 MelDecoderState *mel_state,
527 StateVars *mel_stream, StateVars *vlc_stream,
528 StateVars *mag_sgn_stream, const uint8_t *Dcup,
529 uint32_t Lcup, uint32_t Pcup, uint8_t pLSB,
530 int width, int height, int32_t *sample_buf,
531 uint8_t *block_states)
532 {
533 10 uint16_t q = 0; // Represents current quad position
534 uint16_t q1, q2;
535 uint16_t context1, context2;
536 10 uint16_t context = 0;
537
538 10 uint8_t sig_pat[2] = { 0 }; // significance pattern
539 10 uint8_t res_off[2] = { 0 }; // residual offset
540 10 uint8_t emb_pat_k[2] = { 0 }; // exponent Max Bound pattern K
541 10 uint8_t emb_pat_1[2] = { 0 }; // exponent Max Bound pattern 1
542 10 uint8_t gamma[2] = { 0 };
543
544 10 uint8_t E_n[2] = { 0 };
545 10 uint8_t E_ne[2] = { 0 };
546 10 uint8_t E_nw[2] = { 0 };
547 10 uint8_t E_nf[2] = { 0 };
548
549 10 uint8_t max_e[2] = { 0 };
550 10 uint8_t u_pfx[2] = { 0 };
551 10 uint8_t u_sfx[2] = { 0 };
552 10 uint8_t u_ext[2] = { 0 };
553
554 10 int32_t u[2] = { 0 };
555 10 int32_t U[2] = { 0 }; // exponent bound
556 10 int32_t m_n[2] = { 0 };
557 10 int32_t known_1[2] = { 0 };
558
559 10 int32_t m[2][4] = { 0 };
560 10 int32_t v[2][4] = { 0 };
561
562 10 uint8_t kappa[2] = { 1, 1 };
563
564 10 int ret = 0;
565
566 int sp;
567
568 uint64_t c;
569
570 uint8_t *sigma;
571 uint32_t *mu;
572
573 10 const uint8_t *vlc_buf = Dcup + Pcup;
574
575 /* convert to raster-scan */
576 10 const uint16_t is_border_x = width % 2;
577 10 const uint16_t is_border_y = height % 2;
578
579 10 const uint16_t quad_width = ff_jpeg2000_ceildivpow2(width, 1);
580 10 const uint16_t quad_height = ff_jpeg2000_ceildivpow2(height, 1);
581
582 10 size_t buf_size = 4 * quad_width * quad_height;
583
584 10 uint8_t *sigma_n = av_calloc(buf_size, sizeof(uint8_t));
585 10 uint8_t *E = av_calloc(buf_size, sizeof(uint8_t));
586 10 uint32_t *mu_n = av_calloc(buf_size, sizeof(uint32_t));
587
588
3/6
✓ Branch 0 taken 10 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 10 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 10 times.
 10 if (!sigma_n || !E || !mu_n) {
589 ✗ ret = AVERROR(ENOMEM);
590 ✗ goto free;
591 }
592
593 10 sigma = sigma_n;
594 10 mu = mu_n;
595
596
2/2
✓ Branch 0 taken 88 times.
✓ Branch 1 taken 10 times.
 98 while (q < quad_width - 1) {
597 88 q1 = q;
598 88 q2 = q1 + 1;
599
600
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 88 times.
 88 if ((ret = jpeg2000_decode_sig_emb(s, mel_state, mel_stream, vlc_stream,
601 dec_cxt_vlc_table0, Dcup, sig_pat, res_off,
602 emb_pat_k, emb_pat_1, J2K_Q1, context, Lcup,
603 Pcup)) < 0)
604 ✗ goto free;
605
606
2/2
✓ Branch 0 taken 352 times.
✓ Branch 1 taken 88 times.
 440 for (int i = 0; i < 4; i++)
607 352 sigma_n[4 * q1 + i] = (sig_pat[J2K_Q1] >> i) & 1;
608
609 /* calculate context */
610 88 context = sigma_n[4 * q1]; // f
611 88 context |= sigma_n[4 * q1 + 1]; // sf
612 88 context += sigma_n[4 * q1 + 2] << 1; // w << 1
613 88 context += sigma_n[4 * q1 + 3] << 2;
614
615
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 88 times.
 88 if ((ret = jpeg2000_decode_sig_emb(s, mel_state, mel_stream, vlc_stream,
616 dec_cxt_vlc_table0, Dcup, sig_pat, res_off,
617 emb_pat_k, emb_pat_1, J2K_Q2, context, Lcup,
618 Pcup)) < 0)
619 ✗ goto free;
620
621
2/2
✓ Branch 0 taken 352 times.
✓ Branch 1 taken 88 times.
 440 for (int i = 0; i < 4; i++)
622 352 sigma_n[4 * q2 + i] = (sig_pat[J2K_Q2] >> i) & 1;
623
624 /* calculate context for the next quad */
625 88 context = sigma_n[4 * q2]; // f
626 88 context |= sigma_n[4 * q2 + 1]; // sf
627 88 context += sigma_n[4 * q2 + 2] << 1; // w << 1
628 88 context += sigma_n[4 * q2 + 3] << 2; // sw << 2
629
630 88 u[0] = 0;
631 88 u[1] = 0;
632
633 88 jpeg2000_bitbuf_refill_backwards(vlc_stream, vlc_buf);
634
635
4/4
✓ Branch 0 taken 16 times.
✓ Branch 1 taken 72 times.
✓ Branch 2 taken 6 times.
✓ Branch 3 taken 10 times.
 88 if (res_off[J2K_Q1] == 1 && res_off[J2K_Q2] == 1) {
636
637
2/2
✓ Branch 1 taken 4 times.
✓ Branch 2 taken 2 times.
 12 if (jpeg2000_decode_mel_sym(mel_state, mel_stream, Dcup, Lcup) == 1) {
638
639 4 u_pfx[J2K_Q1] = vlc_decode_u_prefix(vlc_stream, vlc_buf);
640 4 u_pfx[J2K_Q2] = vlc_decode_u_prefix(vlc_stream, vlc_buf);
641
642 4 u_sfx[J2K_Q1] = vlc_decode_u_suffix(vlc_stream, u_pfx[J2K_Q1], vlc_buf);
643 4 u_sfx[J2K_Q2] = vlc_decode_u_suffix(vlc_stream, u_pfx[J2K_Q2], vlc_buf);
644
645 4 u_ext[J2K_Q1] = vlc_decode_u_extension(vlc_stream, u_sfx[J2K_Q1], vlc_buf);
646 4 u_ext[J2K_Q2] = vlc_decode_u_extension(vlc_stream, u_sfx[J2K_Q2], vlc_buf);
647
648 4 u[J2K_Q1] = 2 + u_pfx[J2K_Q1] + u_sfx[J2K_Q1] + (u_ext[J2K_Q1] * 4);
649 4 u[J2K_Q2] = 2 + u_pfx[J2K_Q2] + u_sfx[J2K_Q2] + (u_ext[J2K_Q2] * 4);
650
651 } else {
652 2 u_pfx[J2K_Q1] = vlc_decode_u_prefix(vlc_stream, vlc_buf);
653
654
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 if (u_pfx[J2K_Q1] > 2) {
655 ✗ u[J2K_Q2] = jpeg2000_bitbuf_get_bits_lsb(vlc_stream, 1, vlc_buf) + 1;
656 ✗ u_sfx[J2K_Q1] = vlc_decode_u_suffix(vlc_stream, u_pfx[J2K_Q1], vlc_buf);
657 ✗ u_ext[J2K_Q1] = vlc_decode_u_extension(vlc_stream, u_sfx[J2K_Q1], vlc_buf);
658 } else {
659 2 u_pfx[J2K_Q2] = vlc_decode_u_prefix(vlc_stream, vlc_buf);
660 2 u_sfx[J2K_Q1] = vlc_decode_u_suffix(vlc_stream, u_pfx[J2K_Q1], vlc_buf);
661 2 u_sfx[J2K_Q2] = vlc_decode_u_suffix(vlc_stream, u_pfx[J2K_Q2], vlc_buf);
662 2 u_ext[J2K_Q1] = vlc_decode_u_extension(vlc_stream, u_sfx[J2K_Q1], vlc_buf);
663 2 u_ext[J2K_Q2] = vlc_decode_u_extension(vlc_stream, u_sfx[J2K_Q2], vlc_buf);
664 2 u[J2K_Q2] = u_pfx[J2K_Q2] + u_sfx[J2K_Q2] + (u_ext[J2K_Q2] * 4);
665 }
666 /* See Rec. ITU-T T.814, 7.3.6(3) */
667 2 u[J2K_Q1] = u_pfx[J2K_Q1] + u_sfx[J2K_Q1] + (u_ext[J2K_Q1] * 4);
668 }
669
670
4/4
✓ Branch 0 taken 72 times.
✓ Branch 1 taken 10 times.
✓ Branch 2 taken 21 times.
✓ Branch 3 taken 51 times.
 82 } else if (res_off[J2K_Q1] == 1 || res_off[J2K_Q2] == 1) {
671 31 uint8_t pos = res_off[J2K_Q1] == 1 ? 0 : 1;
672 31 u_pfx[pos] = vlc_decode_u_prefix(vlc_stream, vlc_buf);
673 31 u_sfx[pos] = vlc_decode_u_suffix(vlc_stream, u_pfx[pos], vlc_buf);
674 31 u_ext[pos] = vlc_decode_u_extension(vlc_stream, u_sfx[pos], vlc_buf);
675 31 u[pos] = u_pfx[pos] + u_sfx[pos] + (u_ext[pos] * 4);
676 }
677 88 U[J2K_Q1] = kappa[J2K_Q1] + u[J2K_Q1];
678 88 U[J2K_Q2] = kappa[J2K_Q2] + u[J2K_Q2];
679
680
2/2
✓ Branch 0 taken 352 times.
✓ Branch 1 taken 88 times.
 440 for (int i = 0; i < 4; i++) {
681 352 m[J2K_Q1][i] = sigma_n[4 * q1 + i] * U[J2K_Q1] - ((emb_pat_k[J2K_Q1] >> i) & 1);
682 352 m[J2K_Q2][i] = sigma_n[4 * q2 + i] * U[J2K_Q2] - ((emb_pat_k[J2K_Q2] >> i) & 1);
683 }
684
685 88 recover_mag_sgn(mag_sgn_stream, J2K_Q1, q1, m_n, known_1, emb_pat_1, v, m,
686 E, mu_n, Dcup, Pcup, pLSB);
687
688 88 recover_mag_sgn(mag_sgn_stream, J2K_Q2, q2, m_n, known_1, emb_pat_1, v, m,
689 E, mu_n, Dcup, Pcup, pLSB);
690
691 88 q += 2; // Move to the next quad pair
692 }
693
694
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 10 times.
 10 if (quad_width % 2 == 1) {
695 ✗ q1 = q;
696
697 ✗ if ((ret = jpeg2000_decode_sig_emb(s, mel_state, mel_stream, vlc_stream,
698 dec_cxt_vlc_table0, Dcup, sig_pat, res_off,
699 emb_pat_k, emb_pat_1, J2K_Q1, context, Lcup,
700 Pcup)) < 0)
701 ✗ goto free;
702
703 ✗ for (int i = 0; i < 4; i++)
704 ✗ sigma_n[4 * q1 + i] = (sig_pat[J2K_Q1] >> i) & 1;
705
706 ✗ u[J2K_Q1] = 0;
707
708 ✗ if (res_off[J2K_Q1] == 1) {
709 ✗ u_pfx[J2K_Q1] = vlc_decode_u_prefix(vlc_stream, vlc_buf);
710 ✗ u_sfx[J2K_Q1] = vlc_decode_u_suffix(vlc_stream, u_pfx[J2K_Q1], vlc_buf);
711 ✗ u_ext[J2K_Q1] = vlc_decode_u_extension(vlc_stream, u_sfx[J2K_Q1], vlc_buf);
712 ✗ u[J2K_Q1] = u_pfx[J2K_Q1] + u_sfx[J2K_Q1] + (u_ext[J2K_Q1] * 4);
713 }
714
715 ✗ U[J2K_Q1] = kappa[J2K_Q1] + u[J2K_Q1];
716
717 ✗ for (int i = 0; i < 4; i++)
718 ✗ m[J2K_Q1][i] = sigma_n[4 * q1 + i] * U[J2K_Q1] - ((emb_pat_k[J2K_Q1] >> i) & 1);
719
720 ✗ recover_mag_sgn(mag_sgn_stream, J2K_Q1, q1, m_n, known_1, emb_pat_1, v, m,
721 E, mu_n, Dcup, Pcup, pLSB);
722
723 ✗ q++; // move to next quad pair
724 }
725
726 /**
727 * Initial line pair end. As an optimization, we can replace modulo
728 * operations with checking if a number is divisible , since that's the only
729 * thing we need. This is paired with is_divisible. Credits to Daniel Lemire
730 * blog post [1].
731 *
732 * [1]
733 * https://lemire.me/blog/2019/02/08/faster-remainders-when-the-divisor-is-a-constant-beating-compilers-and-libdivide/
734 *
735 * It's UB on zero, but the spec doesn't allow a quad being zero, so we
736 * error out early in case that's the case.
737 */
738 10 c = precompute_c(quad_width);
739
740
2/2
✓ Branch 0 taken 166 times.
✓ Branch 1 taken 10 times.
 176 for (int row = 1; row < quad_height; row++) {
741
3/4
✓ Branch 0 taken 1960 times.
✓ Branch 1 taken 166 times.
✓ Branch 2 taken 1960 times.
✗ Branch 3 not taken.
 2126 while ((q - (row * quad_width)) < quad_width - 1 && q < (quad_height * quad_width)) {
742 1960 q1 = q;
743 1960 q2 = q + 1;
744 1960 context1 = sigma_n[4 * (q1 - quad_width) + 1];
745 1960 context1 += sigma_n[4 * (q1 - quad_width) + 3] << 2; // ne
746
747
2/2
✓ Branch 1 taken 1794 times.
✓ Branch 2 taken 166 times.
 1960 if (!is_divisible(q1, c)) {
748 1794 context1 |= sigma_n[4 * (q1 - quad_width) - 1]; // nw
749 1794 context1 += (sigma_n[4 * q1 - 1] | sigma_n[4 * q1 - 2]) << 1; // sw | q
750 }
751
1/2
✓ Branch 1 taken 1960 times.
✗ Branch 2 not taken.
 1960 if (!is_divisible(q1 + 1, c))
752 1960 context1 |= sigma_n[4 * (q1 - quad_width) + 5] << 2;
753
754
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1960 times.
 1960 if ((ret = jpeg2000_decode_sig_emb(s, mel_state, mel_stream, vlc_stream,
755 dec_cxt_vlc_table1, Dcup, sig_pat, res_off,
756 emb_pat_k, emb_pat_1, J2K_Q1, context1, Lcup,
757 Pcup))
758 < 0)
759 ✗ goto free;
760
761
2/2
✓ Branch 0 taken 7840 times.
✓ Branch 1 taken 1960 times.
 9800 for (int i = 0; i < 4; i++)
762 7840 sigma_n[4 * q1 + i] = (sig_pat[J2K_Q1] >> i) & 1;
763
764 1960 context2 = sigma_n[4 * (q2 - quad_width) + 1];
765 1960 context2 += sigma_n[4 * (q2 - quad_width) + 3] << 2;
766
767
1/2
✓ Branch 1 taken 1960 times.
✗ Branch 2 not taken.
 1960 if (!is_divisible(q2, c)) {
768 1960 context2 |= sigma_n[4 * (q2 - quad_width) - 1];
769 1960 context2 += (sigma_n[4 * q2 - 1] | sigma_n[4 * q2 - 2]) << 1;
770 }
771
2/2
✓ Branch 1 taken 1794 times.
✓ Branch 2 taken 166 times.
 1960 if (!is_divisible(q2 + 1, c))
772 1794 context2 |= sigma_n[4 * (q2 - quad_width) + 5] << 2;
773
774
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1960 times.
 1960 if ((ret = jpeg2000_decode_sig_emb(s, mel_state, mel_stream, vlc_stream,
775 dec_cxt_vlc_table1, Dcup, sig_pat, res_off,
776 emb_pat_k, emb_pat_1, J2K_Q2, context2, Lcup,
777 Pcup))
778 < 0)
779 ✗ goto free;
780
781
2/2
✓ Branch 0 taken 7840 times.
✓ Branch 1 taken 1960 times.
 9800 for (int i = 0; i < 4; i++)
782 7840 sigma_n[4 * q2 + i] = (sig_pat[J2K_Q2] >> i) & 1;
783
784 1960 u[J2K_Q1] = 0;
785 1960 u[J2K_Q2] = 0;
786
787 1960 jpeg2000_bitbuf_refill_backwards(vlc_stream, vlc_buf);
788
789
4/4
✓ Branch 0 taken 743 times.
✓ Branch 1 taken 1217 times.
✓ Branch 2 taken 461 times.
✓ Branch 3 taken 282 times.
 1960 if (res_off[J2K_Q1] == 1 && res_off[J2K_Q2] == 1) {
790 461 u_pfx[J2K_Q1] = vlc_decode_u_prefix(vlc_stream, vlc_buf);
791 461 u_pfx[J2K_Q2] = vlc_decode_u_prefix(vlc_stream, vlc_buf);
792
793 461 u_sfx[J2K_Q1] = vlc_decode_u_suffix(vlc_stream, u_pfx[J2K_Q1], vlc_buf);
794 461 u_sfx[J2K_Q2] = vlc_decode_u_suffix(vlc_stream, u_pfx[J2K_Q2], vlc_buf);
795
796 461 u_ext[J2K_Q1] = vlc_decode_u_extension(vlc_stream, u_sfx[J2K_Q1], vlc_buf);
797 461 u_ext[J2K_Q2] = vlc_decode_u_extension(vlc_stream, u_sfx[J2K_Q2], vlc_buf);
798
799 461 u[J2K_Q1] = u_pfx[J2K_Q1] + u_sfx[J2K_Q1] + (u_ext[J2K_Q1] << 2);
800 461 u[J2K_Q2] = u_pfx[J2K_Q2] + u_sfx[J2K_Q2] + (u_ext[J2K_Q2] << 2);
801
802
4/4
✓ Branch 0 taken 1217 times.
✓ Branch 1 taken 282 times.
✓ Branch 2 taken 301 times.
✓ Branch 3 taken 916 times.
 1499 } else if (res_off[J2K_Q1] == 1 || res_off[J2K_Q2] == 1) {
803 583 uint8_t pos = res_off[J2K_Q1] == 1 ? 0 : 1;
804
805 583 u_pfx[pos] = vlc_decode_u_prefix(vlc_stream, vlc_buf);
806 583 u_sfx[pos] = vlc_decode_u_suffix(vlc_stream, u_pfx[pos], vlc_buf);
807 583 u_ext[pos] = vlc_decode_u_extension(vlc_stream, u_sfx[pos], vlc_buf);
808
809 583 u[pos] = u_pfx[pos] + u_sfx[pos] + (u_ext[pos] << 2);
810 }
811 1960 sp = sig_pat[J2K_Q1];
812
813 1960 gamma[J2K_Q1] = 1;
814
815
10/10
✓ Branch 0 taken 1859 times.
✓ Branch 1 taken 101 times.
✓ Branch 2 taken 1788 times.
✓ Branch 3 taken 71 times.
✓ Branch 4 taken 1713 times.
✓ Branch 5 taken 75 times.
✓ Branch 6 taken 1631 times.
✓ Branch 7 taken 82 times.
✓ Branch 8 taken 72 times.
✓ Branch 9 taken 1559 times.
 1960 if (sp == 0 || sp == 1 || sp == 2 || sp == 4 || sp == 8)
816 401 gamma[J2K_Q1] = 0;
817
818 1960 sp = sig_pat[J2K_Q2];
819
820 1960 gamma[J2K_Q2] = 1;
821
822
10/10
✓ Branch 0 taken 1861 times.
✓ Branch 1 taken 99 times.
✓ Branch 2 taken 1782 times.
✓ Branch 3 taken 79 times.
✓ Branch 4 taken 1707 times.
✓ Branch 5 taken 75 times.
✓ Branch 6 taken 1630 times.
✓ Branch 7 taken 77 times.
✓ Branch 8 taken 79 times.
✓ Branch 9 taken 1551 times.
 1960 if (sp == 0 || sp == 1 || sp == 2 || sp == 4 || sp == 8)
823 409 gamma[J2K_Q2] = 0;
824
825 1960 E_n[J2K_Q1] = E[4 * (q1 - quad_width) + 1];
826 1960 E_n[J2K_Q2] = E[4 * (q2 - quad_width) + 1];
827
828 1960 E_ne[J2K_Q1] = E[4 * (q1 - quad_width) + 3];
829 1960 E_ne[J2K_Q2] = E[4 * (q2 - quad_width) + 3];
830
831
2/2
✓ Branch 1 taken 1950 times.
✓ Branch 2 taken 10 times.
 1960 E_nw[J2K_Q1] = (!is_divisible(q1, c)) * E[FFMAX((4 * (q1 - quad_width) - 1), 0)];
832
1/2
✓ Branch 1 taken 1960 times.
✗ Branch 2 not taken.
 1960 E_nw[J2K_Q2] = (!is_divisible(q2, c)) * E[FFMAX((4 * (q2 - quad_width) - 1), 0)];
833
834 1960 E_nf[J2K_Q1] = (!is_divisible(q1 + 1, c)) * E[4 * (q1 - quad_width) + 5];
835 1960 E_nf[J2K_Q2] = (!is_divisible(q2 + 1, c)) * E[4 * (q2 - quad_width) + 5];
836
837 1960 max_e[J2K_Q1] = FFMAX(E_nw[J2K_Q1], FFMAX3(E_n[J2K_Q1], E_ne[J2K_Q1], E_nf[J2K_Q1]));
838 1960 max_e[J2K_Q2] = FFMAX(E_nw[J2K_Q2], FFMAX3(E_n[J2K_Q2], E_ne[J2K_Q2], E_nf[J2K_Q2]));
839
840 1960 kappa[J2K_Q1] = FFMAX(1, gamma[J2K_Q1] * (max_e[J2K_Q1] - 1));
841 1960 kappa[J2K_Q2] = FFMAX(1, gamma[J2K_Q2] * (max_e[J2K_Q2] - 1));
842
843 1960 U[J2K_Q1] = kappa[J2K_Q1] + u[J2K_Q1];
844 1960 U[J2K_Q2] = kappa[J2K_Q2] + u[J2K_Q2];
845
846
2/2
✓ Branch 0 taken 7840 times.
✓ Branch 1 taken 1960 times.
 9800 for (int i = 0; i < 4; i++) {
847 7840 m[J2K_Q1][i] = sigma_n[4 * q1 + i] * U[J2K_Q1] - ((emb_pat_k[J2K_Q1] >> i) & 1);
848 7840 m[J2K_Q2][i] = sigma_n[4 * q2 + i] * U[J2K_Q2] - ((emb_pat_k[J2K_Q2] >> i) & 1);
849 }
850 1960 recover_mag_sgn(mag_sgn_stream, J2K_Q1, q1, m_n, known_1, emb_pat_1, v, m,
851 E, mu_n, Dcup, Pcup, pLSB);
852
853 1960 recover_mag_sgn(mag_sgn_stream, J2K_Q2, q2, m_n, known_1, emb_pat_1, v, m,
854 E, mu_n, Dcup, Pcup, pLSB);
855
856 1960 q += 2; // Move to the next quad pair
857 }
858
859
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 166 times.
 166 if (quad_width % 2 == 1) {
860 ✗ q1 = q;
861
862 /* calculate context for current quad */
863 ✗ context1 = sigma_n[4 * (q1 - quad_width) + 1];
864 ✗ context1 += (sigma_n[4 * (q1 - quad_width) + 3] << 2);
865
866 ✗ if (!is_divisible(q1, c)) {
867 ✗ context1 |= sigma_n[4 * (q1 - quad_width) - 1];
868 ✗ context1 += (sigma_n[4 * q1 - 1] | sigma_n[4 * q1 - 2]) << 1;
869 }
870 ✗ if (!is_divisible(q1 + 1, c))
871 ✗ context1 |= sigma_n[4 * (q1 - quad_width) + 5] << 2;
872
873 ✗ if ((ret = jpeg2000_decode_sig_emb(s, mel_state, mel_stream, vlc_stream,
874 dec_cxt_vlc_table1, Dcup, sig_pat, res_off,
875 emb_pat_k, emb_pat_1, J2K_Q1, context1, Lcup,
876 Pcup)) < 0)
877 ✗ goto free;
878
879 ✗ for (int i = 0; i < 4; i++)
880 ✗ sigma_n[4 * q1 + i] = (sig_pat[J2K_Q1] >> i) & 1;
881
882 ✗ u[J2K_Q1] = 0;
883
884 /* Recover mag_sgn value */
885 ✗ if (res_off[J2K_Q1] == 1) {
886 ✗ u_pfx[J2K_Q1] = vlc_decode_u_prefix(vlc_stream, vlc_buf);
887 ✗ u_sfx[J2K_Q1] = vlc_decode_u_suffix(vlc_stream, u_pfx[J2K_Q1], vlc_buf);
888 ✗ u_ext[J2K_Q1] = vlc_decode_u_extension(vlc_stream, u_sfx[J2K_Q1], vlc_buf);
889
890 ✗ u[J2K_Q1] = u_pfx[J2K_Q1] + u_sfx[J2K_Q1] + (u_ext[J2K_Q1] << 2);
891 }
892
893 ✗ sp = sig_pat[J2K_Q1];
894
895 ✗ gamma[J2K_Q1] = 1;
896
897 ✗ if (sp == 0 || sp == 1 || sp == 2 || sp == 4 || sp == 8)
898 ✗ gamma[J2K_Q1] = 0;
899
900 ✗ E_n[J2K_Q1] = E[4 * (q1 - quad_width) + 1];
901
902 ✗ E_ne[J2K_Q1] = E[4 * (q1 - quad_width) + 3];
903
904 ✗ E_nw[J2K_Q1] = (!is_divisible(q1, c)) * E[FFMAX((4 * (q1 - quad_width) - 1), 0)];
905
906 ✗ E_nf[J2K_Q1] = (!is_divisible(q1 + 1, c)) * E[4 * (q1 - quad_width) + 5];
907
908 ✗ max_e[J2K_Q1] = FFMAX(E_nw[J2K_Q1], FFMAX3(E_n[J2K_Q1], E_ne[J2K_Q1], E_nf[J2K_Q1]));
909
910 ✗ kappa[J2K_Q1] = FFMAX(1, gamma[J2K_Q1] * (max_e[J2K_Q1] - 1));
911
912 ✗ U[J2K_Q1] = kappa[J2K_Q1] + u[J2K_Q1];
913
914 ✗ for (int i = 0; i < 4; i++)
915 ✗ m[J2K_Q1][i] = sigma_n[4 * q1 + i] * U[J2K_Q1] - ((emb_pat_k[J2K_Q1] >> i) & 1);
916
917 ✗ recover_mag_sgn(mag_sgn_stream, J2K_Q1, q1, m_n, known_1, emb_pat_1, v, m,
918 E, mu_n, Dcup, Pcup, pLSB);
919 ✗ q += 1;
920 }
921 }
922
923 // convert to raster-scan
924
2/2
✓ Branch 0 taken 176 times.
✓ Branch 1 taken 10 times.
 186 for (int y = 0; y < quad_height; y++) {
925
2/2
✓ Branch 0 taken 4096 times.
✓ Branch 1 taken 176 times.
 4272 for (int x = 0; x < quad_width; x++) {
926 int j1, j2;
927 int x1, x2 , x3;
928
929 4096 j1 = 2 * y;
930 4096 j2 = 2 * x;
931
932 4096 sample_buf[j2 + (j1 * width)] = (int32_t)*mu;
933 4096 jpeg2000_modify_state(j1, j2, width, *sigma, block_states);
934 4096 sigma += 1;
935 4096 mu += 1;
936
937
3/4
✓ Branch 0 taken 176 times.
✓ Branch 1 taken 3920 times.
✓ Branch 2 taken 176 times.
✗ Branch 3 not taken.
 4096 x1 = y != quad_height - 1 || is_border_y == 0;
938 4096 sample_buf[j2 + ((j1 + 1) * width)] = ((int32_t)*mu) * x1;
939 4096 jpeg2000_modify_state(j1 + 1, j2, width, (*sigma) * x1, block_states);
940 4096 sigma += 1;
941 4096 mu += 1;
942
943
3/4
✓ Branch 0 taken 176 times.
✓ Branch 1 taken 3920 times.
✓ Branch 2 taken 176 times.
✗ Branch 3 not taken.
 4096 x2 = x != quad_width - 1 || is_border_x == 0;
944 4096 sample_buf[(j2 + 1) + (j1 * width)] = ((int32_t)*mu) * x2;
945 4096 jpeg2000_modify_state(j1, j2 + 1, width, (*sigma) * x2, block_states);
946 4096 sigma += 1;
947 4096 mu += 1;
948
949 4096 x3 = x1 | x2;
950 4096 sample_buf[(j2 + 1) + (j1 + 1) * width] = ((int32_t)*mu) * x3;
951 4096 jpeg2000_modify_state(j1 + 1, j2 + 1, width, (*sigma) * x3, block_states);
952 4096 sigma += 1;
953 4096 mu += 1;
954 }
955 }
956 10 ret = 1;
957 10 free:
958 10 av_freep(&sigma_n);
959 10 av_freep(&E);
960 10 av_freep(&mu_n);
961 10 return ret;
962 }
963
964 ✗ static void jpeg2000_calc_mbr(uint8_t *mbr, const uint16_t i, const uint16_t j,
965 const uint32_t mbr_info, uint8_t causal_cond,
966 uint8_t *block_states, int width)
967 {
968 ✗ int local_mbr = 0;
969
970 ✗ local_mbr |= jpeg2000_get_state(i - 1, j - 1, width, HT_SHIFT_SIGMA, block_states);
971 ✗ local_mbr |= jpeg2000_get_state(i - 1, j + 0, width, HT_SHIFT_SIGMA, block_states);
972 ✗ local_mbr |= jpeg2000_get_state(i - 1, j + 1, width, HT_SHIFT_SIGMA, block_states);
973
974 ✗ local_mbr |= jpeg2000_get_state(i + 0, j - 1, width, HT_SHIFT_SIGMA, block_states);
975 ✗ local_mbr |= jpeg2000_get_state(i + 0, j + 1, width, HT_SHIFT_SIGMA, block_states);
976
977 ✗ local_mbr |= jpeg2000_get_state(i + 1, j - 1, width, HT_SHIFT_SIGMA, block_states) * causal_cond;
978 ✗ local_mbr |= jpeg2000_get_state(i + 1, j + 0, width, HT_SHIFT_SIGMA, block_states) * causal_cond;
979 ✗ local_mbr |= jpeg2000_get_state(i + 1, j + 1, width, HT_SHIFT_SIGMA, block_states) * causal_cond;
980
981 ✗ local_mbr |= jpeg2000_get_state(i - 1, j - 1, width, HT_SHIFT_REF, block_states) *
982 ✗ jpeg2000_get_state(i - 1, j - 1, width, HT_SHIFT_SCAN, block_states);
983 ✗ local_mbr |= jpeg2000_get_state(i - 1, j + 0, width, HT_SHIFT_REF, block_states) *
984 ✗ jpeg2000_get_state(i - 1, j - 1, width, HT_SHIFT_SCAN, block_states);
985 ✗ local_mbr |= jpeg2000_get_state(i - 1, j + 1, width, HT_SHIFT_REF, block_states) *
986 ✗ jpeg2000_get_state(i - 1, j + 1, width, HT_SHIFT_SCAN, block_states);
987
988 ✗ local_mbr |= jpeg2000_get_state(i + 0, j - 1, width, HT_SHIFT_REF, block_states) *
989 ✗ jpeg2000_get_state(i + 0, j - 1, width, HT_SHIFT_SCAN, block_states);
990 ✗ local_mbr |= jpeg2000_get_state(i + 0, j + 1, width, HT_SHIFT_REF, block_states) *
991 ✗ jpeg2000_get_state(i + 0, j + 1, width, HT_SHIFT_SCAN, block_states);
992
993 ✗ local_mbr |= jpeg2000_get_state(i + 1, j - 1, width, HT_SHIFT_REF, block_states) *
994 ✗ jpeg2000_get_state(i + 1, j - 1, width, HT_SHIFT_SCAN, block_states) * causal_cond;
995 ✗ local_mbr |= jpeg2000_get_state(i + 1, j + 0, width, HT_SHIFT_REF, block_states) *
996 ✗ jpeg2000_get_state(i + 1, j + 0, width, HT_SHIFT_SCAN, block_states) * causal_cond;
997 ✗ local_mbr |= jpeg2000_get_state(i + 1, j + 1, width, HT_SHIFT_REF, block_states) *
998 ✗ jpeg2000_get_state(i + 1, j + 1, width, HT_SHIFT_SCAN, block_states) * causal_cond;
999
1000 ✗ *mbr |= local_mbr;
1001 ✗ }
1002
1003 ✗ static void jpeg2000_process_stripes_block(StateVars *sig_prop, int i_s, int j_s,
1004 int width, int height, int stride, int pLSB,
1005 int32_t *sample_buf, uint8_t *block_states,
1006 uint8_t *magref_segment, uint32_t magref_length)
1007 {
1008 ✗ for (int j = j_s; j < j_s + width; j++) {
1009 ✗ uint32_t mbr_info = 0;
1010 ✗ for (int i = i_s; i < i_s + height; i++) {
1011 int modify_state, cond;
1012 uint8_t bit;
1013 ✗ uint8_t causal_cond = i != (i_s + height - 1);
1014 ✗ int32_t *sp = &sample_buf[j + (i * (stride - 2))];
1015 ✗ uint8_t mbr = 0;
1016
1017 ✗ if (jpeg2000_get_state(i, j, stride - 2, HT_SHIFT_SIGMA, block_states) == 0)
1018 ✗ jpeg2000_calc_mbr(&mbr, i, j, mbr_info & 0x1EF, causal_cond, block_states, stride - 2);
1019 ✗ mbr_info >>= 3;
1020 ✗ cond = mbr != 0;
1021 ✗ bit = jpeg2000_peek_bit(sig_prop, magref_segment, magref_length);
1022 ✗ *sp |= (bit * cond) << pLSB;
1023 ✗ sig_prop->bits -= cond;
1024 ✗ modify_state = (((1 << HT_SHIFT_REF_IND) | (1 << HT_SHIFT_REF)) * cond) | 1 << HT_SHIFT_SCAN;
1025 ✗ jpeg2000_modify_state(i, j, stride - 2, modify_state, block_states);
1026 }
1027 }
1028 ✗ }
1029
1030 /**
1031 * See procedure decodeSigPropMag at Rec. ITU-T T.814, 7.4.
1032 */
1033 av_noinline
1034 ✗ static void jpeg2000_decode_sigprop_segment(Jpeg2000Cblk *cblk, uint16_t width,
1035 uint16_t height, uint8_t *magref_segment,
1036 uint32_t magref_length, uint8_t pLSB,
1037 int32_t *sample_buf, uint8_t *block_states)
1038 {
1039 StateVars sp_dec;
1040
1041 ✗ const uint16_t num_v_stripe = height / 4;
1042 ✗ const uint16_t num_h_stripe = width / 4;
1043 ✗ int b_width = 4;
1044 ✗ int b_height = 4;
1045 ✗ int stride = width + 2;
1046
1047 int last_width;
1048 ✗ uint16_t i = 0, j = 0;
1049
1050 ✗ jpeg2000_init_zero(&sp_dec);
1051
1052 ✗ for (int n1 = 0; n1 < num_v_stripe; n1++) {
1053 ✗ j = 0;
1054 ✗ for (int n2 = 0; n2 < num_h_stripe; n2++) {
1055 ✗ jpeg2000_process_stripes_block(&sp_dec, i, j, b_width, b_height, stride,
1056 pLSB, sample_buf, block_states, magref_segment,
1057 magref_length);
1058 ✗ j += 4;
1059 }
1060 ✗ last_width = width % 4;
1061 ✗ if (last_width)
1062 ✗ jpeg2000_process_stripes_block(&sp_dec, i, j, last_width, b_height, stride,
1063 pLSB, sample_buf, block_states, magref_segment,
1064 magref_length);
1065 ✗ i += 4;
1066 }
1067
1068 /* Decode remaining height stripes */
1069 ✗ b_height = height % 4;
1070 ✗ j = 0;
1071 ✗ for (int n2 = 0; n2 < num_h_stripe; n2++) {
1072 ✗ jpeg2000_process_stripes_block(&sp_dec, i, j, b_width, b_height, stride,
1073 pLSB, sample_buf, block_states, magref_segment,
1074 magref_length);
1075 ✗ j += 4;
1076 }
1077 ✗ last_width = width % 4;
1078 ✗ if (last_width)
1079 ✗ jpeg2000_process_stripes_block(&sp_dec, i, j, last_width, b_height, stride,
1080 pLSB, sample_buf, block_states, magref_segment,
1081 magref_length);
1082 ✗ }
1083
1084 /**
1085 * See procedure decodeSigPropMag at Rec. ITU-T T.814, 7.5.
1086 */
1087 static int
1088 ✗ jpeg2000_decode_magref_segment( uint16_t width, uint16_t block_height,
1089 uint8_t *magref_segment,uint32_t magref_length,
1090 uint8_t pLSB, int32_t *sample_buf, uint8_t *block_states)
1091 {
1092
1093 ✗ StateVars mag_ref = { 0 };
1094 ✗ const uint16_t num_v_stripe = block_height / 4;
1095 ✗ uint16_t height = 4;
1096 ✗ uint16_t i_start = 0;
1097 int32_t *sp;
1098
1099 ✗ jpeg2000_init_mag_ref(&mag_ref, magref_length);
1100
1101 ✗ for (int n1 = 0; n1 < num_v_stripe; n1++) {
1102 ✗ for (int j = 0; j < width; j++) {
1103 ✗ for (int i = i_start; i < i_start + height; i++) {
1104 /**
1105 * We move column wise, going from one quad to another. See
1106 * Rec. ITU-T T.814, Figure 7.
1107 */
1108 ✗ sp = &sample_buf[j + i * width];
1109 ✗ if (jpeg2000_get_state(i, j, width, HT_SHIFT_SIGMA, block_states) != 0) {
1110 ✗ jpeg2000_modify_state(i, j, width, 1 << HT_SHIFT_REF_IND, block_states);
1111 ✗ *sp |= jpeg2000_import_magref_bit(&mag_ref, magref_segment, magref_length) << pLSB;
1112 }
1113 }
1114 }
1115 ✗ i_start += 4;
1116 }
1117 ✗ height = block_height % 4;
1118 ✗ for (int j = 0; j < width; j++) {
1119 ✗ for (int i = i_start; i < i_start + height; i++) {
1120 ✗ sp = &sample_buf[j + i * width];
1121 ✗ if (jpeg2000_get_state(i, j, width, HT_SHIFT_SIGMA, block_states) != 0) {
1122 ✗ jpeg2000_modify_state(i, j, width, 1 << HT_SHIFT_REF_IND, block_states);
1123 ✗ *sp |= jpeg2000_import_magref_bit(&mag_ref, magref_segment, magref_length) << pLSB;
1124 }
1125 }
1126 }
1127 ✗ return 1;
1128 }
1129
1130
1131 int
1132 10 ff_jpeg2000_decode_htj2k(const Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *codsty, Jpeg2000T1Context *t1, Jpeg2000Cblk *cblk,
1133 int width, int height, int magp, uint8_t roi_shift)
1134 {
1135 10 uint8_t p0 = 0; // Number of placeholder passes
1136 uint32_t Lcup; // Length of HT cleanup segment
1137 uint32_t Lref; // Length of Refinement segment
1138 uint32_t Scup; // HT cleanup segment suffix length
1139 uint32_t Pcup; // HT cleanup segment prefix length
1140
1141 uint8_t S_blk; // Number of skipped magnitude bitplanes
1142 uint8_t pLSB;
1143
1144 uint8_t *Dcup; // Byte of an HT cleanup segment
1145 uint8_t *Dref; // Byte of an HT refinement segment
1146
1147 int z_blk; // Number of ht coding pass
1148
1149 uint8_t empty_passes;
1150
1151 StateVars mag_sgn; // Magnitude and Sign
1152 StateVars mel; // Adaptive run-length coding
1153 StateVars vlc; // Variable Length coding
1154 StateVars sig_prop; // Significance propagation
1155
1156 MelDecoderState mel_state;
1157
1158 int ret;
1159
1160 /* Temporary buffers */
1161 10 int32_t *sample_buf = NULL;
1162 10 uint8_t *block_states = NULL;
1163
1164 int32_t n, val; // Post-processing
1165
1166 10 int32_t M_b = magp;
1167
1168 /* codeblock size as constrained by Rec. ITU-T T.800, Table A.18 */
1169
2/4
✓ Branch 0 taken 10 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 10 times.
 10 av_assert0(width <= 1024U && height <= 1024U);
1170
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 10 times.
 10 av_assert0(width * height <= 4096);
1171
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 10 times.
 10 av_assert0(width * height > 0);
1172
1173 10 memset(t1->data, 0, t1->stride * height * sizeof(*t1->data));
1174 10 memset(t1->flags, 0, t1->stride * (height + 2) * sizeof(*t1->flags));
1175
1176
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 10 times.
 10 if (cblk->npasses == 0)
1177 ✗ return 0;
1178
1179
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 10 times.
 10 if (cblk->npasses > 3)
1180 ✗ p0 = 0;
1181
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 10 times.
 10 else if (cblk->length == 0)
1182 ✗ p0 = 1;
1183
1184 10 empty_passes = p0 * 3;
1185 10 z_blk = cblk->npasses - empty_passes;
1186
1187
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 10 times.
 10 if (z_blk <= 0)
1188 ✗ return 0; // No passes within this set, continue
1189
1190 10 Lcup = cblk->pass_lengths[0];
1191 10 Lref = cblk->pass_lengths[1];
1192
1193
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 10 times.
 10 if (Lcup < 2) {
1194 ✗ av_log(s->avctx, AV_LOG_ERROR,
1195 "Cleanup pass length must be at least 2 bytes in length\n");
1196 ✗ return AVERROR_INVALIDDATA;
1197 }
1198 10 Dcup = cblk->data;
1199 10 Dref = cblk->data + Lcup; // Dref comes after the refinement segment
1200 10 S_blk = p0 + cblk->zbp;
1201 10 pLSB = 30 - S_blk;
1202
1203 10 Scup = (Dcup[Lcup - 1] << 4) + (Dcup[Lcup - 2] & 0x0F);
1204
1205
3/6
✓ Branch 0 taken 10 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 10 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 10 times.
 10 if (Scup < 2 || Scup > Lcup || Scup > 4079) {
1206 ✗ av_log(s->avctx, AV_LOG_ERROR, "Cleanup pass suffix length is invalid %d\n",
1207 Scup);
1208 ✗ ret = AVERROR_INVALIDDATA;
1209 ✗ goto free;
1210 }
1211 10 Pcup = Lcup - Scup;
1212
1213 /* modDcup shall be done before the creation of vlc instance. */
1214 10 Dcup[Lcup - 1] = 0xFF;
1215 10 Dcup[Lcup - 2] |= 0x0F;
1216
1217 /* Magnitude and refinement */
1218 10 jpeg2000_init_zero(&mag_sgn);
1219 10 jpeg2000_bitbuf_refill_forward(&mag_sgn, Dcup, Pcup);
1220
1221 /* Significance propagation */
1222 10 jpeg2000_init_zero(&sig_prop);
1223
1224 /* Adaptive run length */
1225 10 jpeg2000_init_mel(&mel, Pcup);
1226
1227 /* Variable Length coding */
1228 10 jpeg2000_init_vlc(&vlc, Lcup, Pcup, Dcup);
1229
1230 10 jpeg2000_init_mel_decoder(&mel_state);
1231
1232 10 sample_buf = av_calloc((width + 4) * (height + 4), sizeof(int32_t));
1233 10 block_states = av_calloc((width + 4) * (height + 4), sizeof(uint8_t));
1234
1235
2/4
✓ Branch 0 taken 10 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 10 times.
 10 if (!sample_buf || !block_states) {
1236 ✗ ret = AVERROR(ENOMEM);
1237 ✗ goto free;
1238 }
1239
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 10 times.
 10 if ((ret = jpeg2000_decode_ht_cleanup_segment(s, cblk, t1, &mel_state, &mel, &vlc,
1240 &mag_sgn, Dcup, Lcup, Pcup, pLSB, width,
1241 height, sample_buf, block_states)) < 0)
1242 ✗ goto free;
1243
1244
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 10 times.
 10 if (cblk->npasses > 1)
1245 ✗ jpeg2000_decode_sigprop_segment(cblk, width, height, Dref, Lref,
1246 ✗ pLSB - 1, sample_buf, block_states);
1247
1248
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 10 times.
 10 if (cblk->npasses > 2) {
1249
1250 ✗ if (Lref < 2){
1251 ✗ av_log(s->avctx,AV_LOG_ERROR,"Invalid magnitude refinement length\n");
1252 ✗ ret = AVERROR_INVALIDDATA;
1253 ✗ goto free;
1254 }
1255 ✗ if ((ret = jpeg2000_decode_magref_segment(width, height, Dref, Lref,
1256 ✗ pLSB - 1, sample_buf, block_states)) < 0)
1257 ✗ goto free;
1258 }
1259
1260 10 pLSB = 31 - M_b;
1261
1262 /* Reconstruct the sample values */
1263
2/2
✓ Branch 0 taken 352 times.
✓ Branch 1 taken 10 times.
 362 for (int y = 0; y < height; y++) {
1264
2/2
✓ Branch 0 taken 16384 times.
✓ Branch 1 taken 352 times.
 16736 for (int x = 0; x < width; x++) {
1265 16384 n = x + (y * t1->stride);
1266 16384 val = sample_buf[x + (y * width)];
1267 /* Convert sign-magnitude to two's complement. */
1268
2/2
✓ Branch 0 taken 4032 times.
✓ Branch 1 taken 12352 times.
 16384 val = val >> 31 ? 0x80000000 - val : val;
1269 16384 val >>= (pLSB - 1);
1270 16384 t1->data[n] = val;
1271 }
1272 }
1273 10 free:
1274 10 av_freep(&sample_buf);
1275 10 av_freep(&block_states);
1276 10 return ret;
1277 }
1278
1279 /**
1280 * CtxVLC tables (see Rec. ITU-T T.800, Annex C) as found at
1281 * https://github.com/osamu620/OpenHTJ2K (author: Osamu Watanabe)
1282 */
1283 static const uint16_t dec_cxt_vlc_table1[1024] = {
1284 0x0016, 0x006A, 0x0046, 0x00DD, 0x0086, 0x888B, 0x0026, 0x444D, 0x0016, 0x00AA, 0x0046, 0x88AD, 0x0086,
1285 0x003A, 0x0026, 0x00DE, 0x0016, 0x00CA, 0x0046, 0x009D, 0x0086, 0x005A, 0x0026, 0x222D, 0x0016, 0x009A,
1286 0x0046, 0x007D, 0x0086, 0x01FD, 0x0026, 0x007E, 0x0016, 0x006A, 0x0046, 0x88CD, 0x0086, 0x888B, 0x0026,
1287 0x111D, 0x0016, 0x00AA, 0x0046, 0x005D, 0x0086, 0x003A, 0x0026, 0x00EE, 0x0016, 0x00CA, 0x0046, 0x00BD,
1288 0x0086, 0x005A, 0x0026, 0x11FF, 0x0016, 0x009A, 0x0046, 0x003D, 0x0086, 0x04ED, 0x0026, 0x2AAF, 0x0016,
1289 0x006A, 0x0046, 0x00DD, 0x0086, 0x888B, 0x0026, 0x444D, 0x0016, 0x00AA, 0x0046, 0x88AD, 0x0086, 0x003A,
1290 0x0026, 0x44EF, 0x0016, 0x00CA, 0x0046, 0x009D, 0x0086, 0x005A, 0x0026, 0x222D, 0x0016, 0x009A, 0x0046,
1291 0x007D, 0x0086, 0x01FD, 0x0026, 0x00BE, 0x0016, 0x006A, 0x0046, 0x88CD, 0x0086, 0x888B, 0x0026, 0x111D,
1292 0x0016, 0x00AA, 0x0046, 0x005D, 0x0086, 0x003A, 0x0026, 0x4CCF, 0x0016, 0x00CA, 0x0046, 0x00BD, 0x0086,
1293 0x005A, 0x0026, 0x00FE, 0x0016, 0x009A, 0x0046, 0x003D, 0x0086, 0x04ED, 0x0026, 0x006F, 0x0002, 0x0088,
1294 0x0002, 0x005C, 0x0002, 0x0018, 0x0002, 0x00DE, 0x0002, 0x0028, 0x0002, 0x009C, 0x0002, 0x004A, 0x0002,
1295 0x007E, 0x0002, 0x0088, 0x0002, 0x00CC, 0x0002, 0x0018, 0x0002, 0x888F, 0x0002, 0x0028, 0x0002, 0x00FE,
1296 0x0002, 0x003A, 0x0002, 0x222F, 0x0002, 0x0088, 0x0002, 0x04FD, 0x0002, 0x0018, 0x0002, 0x00BE, 0x0002,
1297 0x0028, 0x0002, 0x00BF, 0x0002, 0x004A, 0x0002, 0x006E, 0x0002, 0x0088, 0x0002, 0x00AC, 0x0002, 0x0018,
1298 0x0002, 0x444F, 0x0002, 0x0028, 0x0002, 0x00EE, 0x0002, 0x003A, 0x0002, 0x113F, 0x0002, 0x0088, 0x0002,
1299 0x005C, 0x0002, 0x0018, 0x0002, 0x00CF, 0x0002, 0x0028, 0x0002, 0x009C, 0x0002, 0x004A, 0x0002, 0x006F,
1300 0x0002, 0x0088, 0x0002, 0x00CC, 0x0002, 0x0018, 0x0002, 0x009F, 0x0002, 0x0028, 0x0002, 0x00EF, 0x0002,
1301 0x003A, 0x0002, 0x233F, 0x0002, 0x0088, 0x0002, 0x04FD, 0x0002, 0x0018, 0x0002, 0x00AF, 0x0002, 0x0028,
1302 0x0002, 0x44FF, 0x0002, 0x004A, 0x0002, 0x005F, 0x0002, 0x0088, 0x0002, 0x00AC, 0x0002, 0x0018, 0x0002,
1303 0x007F, 0x0002, 0x0028, 0x0002, 0x00DF, 0x0002, 0x003A, 0x0002, 0x111F, 0x0002, 0x0028, 0x0002, 0x005C,
1304 0x0002, 0x008A, 0x0002, 0x00BF, 0x0002, 0x0018, 0x0002, 0x00FE, 0x0002, 0x00CC, 0x0002, 0x007E, 0x0002,
1305 0x0028, 0x0002, 0x8FFF, 0x0002, 0x004A, 0x0002, 0x007F, 0x0002, 0x0018, 0x0002, 0x00DF, 0x0002, 0x00AC,
1306 0x0002, 0x133F, 0x0002, 0x0028, 0x0002, 0x222D, 0x0002, 0x008A, 0x0002, 0x00BE, 0x0002, 0x0018, 0x0002,
1307 0x44EF, 0x0002, 0x2AAD, 0x0002, 0x006E, 0x0002, 0x0028, 0x0002, 0x15FF, 0x0002, 0x004A, 0x0002, 0x009E,
1308 0x0002, 0x0018, 0x0002, 0x00CF, 0x0002, 0x003C, 0x0002, 0x223F, 0x0002, 0x0028, 0x0002, 0x005C, 0x0002,
1309 0x008A, 0x0002, 0x2BBF, 0x0002, 0x0018, 0x0002, 0x04EF, 0x0002, 0x00CC, 0x0002, 0x006F, 0x0002, 0x0028,
1310 0x0002, 0x27FF, 0x0002, 0x004A, 0x0002, 0x009F, 0x0002, 0x0018, 0x0002, 0x00DE, 0x0002, 0x00AC, 0x0002,
1311 0x444F, 0x0002, 0x0028, 0x0002, 0x222D, 0x0002, 0x008A, 0x0002, 0x8AAF, 0x0002, 0x0018, 0x0002, 0x00EE,
1312 0x0002, 0x2AAD, 0x0002, 0x005F, 0x0002, 0x0028, 0x0002, 0x44FF, 0x0002, 0x004A, 0x0002, 0x888F, 0x0002,
1313 0x0018, 0x0002, 0xAAAF, 0x0002, 0x003C, 0x0002, 0x111F, 0x0004, 0x8FFD, 0x0028, 0x005C, 0x0004, 0x00BC,
1314 0x008A, 0x66FF, 0x0004, 0x00CD, 0x0018, 0x111D, 0x0004, 0x009C, 0x003A, 0x8AAF, 0x0004, 0x00FC, 0x0028,
1315 0x133D, 0x0004, 0x00AC, 0x004A, 0x3BBF, 0x0004, 0x2BBD, 0x0018, 0x5FFF, 0x0004, 0x006C, 0x157D, 0x455F,
1316 0x0004, 0x2FFD, 0x0028, 0x222D, 0x0004, 0x22AD, 0x008A, 0x44EF, 0x0004, 0x00CC, 0x0018, 0x4FFF, 0x0004,
1317 0x007C, 0x003A, 0x447F, 0x0004, 0x04DD, 0x0028, 0x233D, 0x0004, 0x009D, 0x004A, 0x00DE, 0x0004, 0x88BD,
1318 0x0018, 0xAFFF, 0x0004, 0x115D, 0x1FFD, 0x444F, 0x0004, 0x8FFD, 0x0028, 0x005C, 0x0004, 0x00BC, 0x008A,
1319 0x8CEF, 0x0004, 0x00CD, 0x0018, 0x111D, 0x0004, 0x009C, 0x003A, 0x888F, 0x0004, 0x00FC, 0x0028, 0x133D,
1320 0x0004, 0x00AC, 0x004A, 0x44DF, 0x0004, 0x2BBD, 0x0018, 0x8AFF, 0x0004, 0x006C, 0x157D, 0x006F, 0x0004,
1321 0x2FFD, 0x0028, 0x222D, 0x0004, 0x22AD, 0x008A, 0x00EE, 0x0004, 0x00CC, 0x0018, 0x2EEF, 0x0004, 0x007C,
1322 0x003A, 0x277F, 0x0004, 0x04DD, 0x0028, 0x233D, 0x0004, 0x009D, 0x004A, 0x1BBF, 0x0004, 0x88BD, 0x0018,
1323 0x37FF, 0x0004, 0x115D, 0x1FFD, 0x333F, 0x0002, 0x0088, 0x0002, 0x02ED, 0x0002, 0x00CA, 0x0002, 0x4CCF,
1324 0x0002, 0x0048, 0x0002, 0x23FF, 0x0002, 0x001A, 0x0002, 0x888F, 0x0002, 0x0088, 0x0002, 0x006C, 0x0002,
1325 0x002A, 0x0002, 0x00AF, 0x0002, 0x0048, 0x0002, 0x22EF, 0x0002, 0x00AC, 0x0002, 0x005F, 0x0002, 0x0088,
1326 0x0002, 0x444D, 0x0002, 0x00CA, 0x0002, 0xCCCF, 0x0002, 0x0048, 0x0002, 0x00FE, 0x0002, 0x001A, 0x0002,
1327 0x006F, 0x0002, 0x0088, 0x0002, 0x005C, 0x0002, 0x002A, 0x0002, 0x009F, 0x0002, 0x0048, 0x0002, 0x00DF,
1328 0x0002, 0x03FD, 0x0002, 0x222F, 0x0002, 0x0088, 0x0002, 0x02ED, 0x0002, 0x00CA, 0x0002, 0x8CCF, 0x0002,
1329 0x0048, 0x0002, 0x11FF, 0x0002, 0x001A, 0x0002, 0x007E, 0x0002, 0x0088, 0x0002, 0x006C, 0x0002, 0x002A,
1330 0x0002, 0x007F, 0x0002, 0x0048, 0x0002, 0x00EE, 0x0002, 0x00AC, 0x0002, 0x003E, 0x0002, 0x0088, 0x0002,
1331 0x444D, 0x0002, 0x00CA, 0x0002, 0x00BE, 0x0002, 0x0048, 0x0002, 0x00BF, 0x0002, 0x001A, 0x0002, 0x003F,
1332 0x0002, 0x0088, 0x0002, 0x005C, 0x0002, 0x002A, 0x0002, 0x009E, 0x0002, 0x0048, 0x0002, 0x00DE, 0x0002,
1333 0x03FD, 0x0002, 0x111F, 0x0004, 0x8AED, 0x0048, 0x888D, 0x0004, 0x00DC, 0x00CA, 0x3FFF, 0x0004, 0xCFFD,
1334 0x002A, 0x003D, 0x0004, 0x00BC, 0x005A, 0x8DDF, 0x0004, 0x8FFD, 0x0048, 0x006C, 0x0004, 0x027D, 0x008A,
1335 0x99FF, 0x0004, 0x00EC, 0x00FA, 0x003C, 0x0004, 0x00AC, 0x001A, 0x009F, 0x0004, 0x2FFD, 0x0048, 0x007C,
1336 0x0004, 0x44CD, 0x00CA, 0x67FF, 0x0004, 0x1FFD, 0x002A, 0x444D, 0x0004, 0x00AD, 0x005A, 0x8CCF, 0x0004,
1337 0x4FFD, 0x0048, 0x445D, 0x0004, 0x01BD, 0x008A, 0x4EEF, 0x0004, 0x45DD, 0x00FA, 0x111D, 0x0004, 0x009C,
1338 0x001A, 0x222F, 0x0004, 0x8AED, 0x0048, 0x888D, 0x0004, 0x00DC, 0x00CA, 0xAFFF, 0x0004, 0xCFFD, 0x002A,
1339 0x003D, 0x0004, 0x00BC, 0x005A, 0x11BF, 0x0004, 0x8FFD, 0x0048, 0x006C, 0x0004, 0x027D, 0x008A, 0x22EF,
1340 0x0004, 0x00EC, 0x00FA, 0x003C, 0x0004, 0x00AC, 0x001A, 0x227F, 0x0004, 0x2FFD, 0x0048, 0x007C, 0x0004,
1341 0x44CD, 0x00CA, 0x5DFF, 0x0004, 0x1FFD, 0x002A, 0x444D, 0x0004, 0x00AD, 0x005A, 0x006F, 0x0004, 0x4FFD,
1342 0x0048, 0x445D, 0x0004, 0x01BD, 0x008A, 0x11DF, 0x0004, 0x45DD, 0x00FA, 0x111D, 0x0004, 0x009C, 0x001A,
1343 0x155F, 0x0006, 0x00FC, 0x0018, 0x111D, 0x0048, 0x888D, 0x00AA, 0x4DDF, 0x0006, 0x2AAD, 0x005A, 0x67FF,
1344 0x0028, 0x223D, 0x00BC, 0xAAAF, 0x0006, 0x00EC, 0x0018, 0x5FFF, 0x0048, 0x006C, 0x008A, 0xCCCF, 0x0006,
1345 0x009D, 0x00CA, 0x44EF, 0x0028, 0x003C, 0x8FFD, 0x137F, 0x0006, 0x8EED, 0x0018, 0x1FFF, 0x0048, 0x007C,
1346 0x00AA, 0x4CCF, 0x0006, 0x227D, 0x005A, 0x1DDF, 0x0028, 0x444D, 0x4FFD, 0x155F, 0x0006, 0x00DC, 0x0018,
1347 0x2EEF, 0x0048, 0x445D, 0x008A, 0x22BF, 0x0006, 0x009C, 0x00CA, 0x8CDF, 0x0028, 0x222D, 0x2FFD, 0x226F,
1348 0x0006, 0x00FC, 0x0018, 0x111D, 0x0048, 0x888D, 0x00AA, 0x1BBF, 0x0006, 0x2AAD, 0x005A, 0x33FF, 0x0028,
1349 0x223D, 0x00BC, 0x8AAF, 0x0006, 0x00EC, 0x0018, 0x9BFF, 0x0048, 0x006C, 0x008A, 0x8ABF, 0x0006, 0x009D,
1350 0x00CA, 0x4EEF, 0x0028, 0x003C, 0x8FFD, 0x466F, 0x0006, 0x8EED, 0x0018, 0xCFFF, 0x0048, 0x007C, 0x00AA,
1351 0x8CCF, 0x0006, 0x227D, 0x005A, 0xAEEF, 0x0028, 0x444D, 0x4FFD, 0x477F, 0x0006, 0x00DC, 0x0018, 0xAFFF,
1352 0x0048, 0x445D, 0x008A, 0x2BBF, 0x0006, 0x009C, 0x00CA, 0x44DF, 0x0028, 0x222D, 0x2FFD, 0x133F, 0x00F6,
1353 0xAFFD, 0x1FFB, 0x003C, 0x0008, 0x23BD, 0x007A, 0x11DF, 0x00F6, 0x45DD, 0x2FFB, 0x4EEF, 0x00DA, 0x177D,
1354 0xCFFD, 0x377F, 0x00F6, 0x3FFD, 0x8FFB, 0x111D, 0x0008, 0x009C, 0x005A, 0x1BBF, 0x00F6, 0x00CD, 0x00BA,
1355 0x8DDF, 0x4FFB, 0x006C, 0x9BFD, 0x455F, 0x00F6, 0x67FD, 0x1FFB, 0x002C, 0x0008, 0x00AC, 0x007A, 0x009F,
1356 0x00F6, 0x00AD, 0x2FFB, 0x7FFF, 0x00DA, 0x004C, 0x5FFD, 0x477F, 0x00F6, 0x00EC, 0x8FFB, 0x001C, 0x0008,
1357 0x008C, 0x005A, 0x888F, 0x00F6, 0x00CC, 0x00BA, 0x2EEF, 0x4FFB, 0x115D, 0x8AED, 0x113F, 0x00F6, 0xAFFD,
1358 0x1FFB, 0x003C, 0x0008, 0x23BD, 0x007A, 0x1DDF, 0x00F6, 0x45DD, 0x2FFB, 0xBFFF, 0x00DA, 0x177D, 0xCFFD,
1359 0x447F, 0x00F6, 0x3FFD, 0x8FFB, 0x111D, 0x0008, 0x009C, 0x005A, 0x277F, 0x00F6, 0x00CD, 0x00BA, 0x22EF,
1360 0x4FFB, 0x006C, 0x9BFD, 0x444F, 0x00F6, 0x67FD, 0x1FFB, 0x002C, 0x0008, 0x00AC, 0x007A, 0x11BF, 0x00F6,
1361 0x00AD, 0x2FFB, 0xFFFF, 0x00DA, 0x004C, 0x5FFD, 0x233F, 0x00F6, 0x00EC, 0x8FFB, 0x001C, 0x0008, 0x008C,
1362 0x005A, 0x006F, 0x00F6, 0x00CC, 0x00BA, 0x8BBF, 0x4FFB, 0x115D, 0x8AED, 0x222F};
1363
1364 static const uint16_t dec_cxt_vlc_table0[1024] = {
1365 0x0026, 0x00AA, 0x0046, 0x006C, 0x0086, 0x8AED, 0x0018, 0x8DDF, 0x0026, 0x01BD, 0x0046, 0x5FFF, 0x0086,
1366 0x027D, 0x005A, 0x155F, 0x0026, 0x003A, 0x0046, 0x444D, 0x0086, 0x4CCD, 0x0018, 0xCCCF, 0x0026, 0x2EFD,
1367 0x0046, 0x99FF, 0x0086, 0x009C, 0x00CA, 0x133F, 0x0026, 0x00AA, 0x0046, 0x445D, 0x0086, 0x8CCD, 0x0018,
1368 0x11DF, 0x0026, 0x4FFD, 0x0046, 0xCFFF, 0x0086, 0x009D, 0x005A, 0x007E, 0x0026, 0x003A, 0x0046, 0x1FFF,
1369 0x0086, 0x88AD, 0x0018, 0x00BE, 0x0026, 0x8FFD, 0x0046, 0x4EEF, 0x0086, 0x888D, 0x00CA, 0x111F, 0x0026,
1370 0x00AA, 0x0046, 0x006C, 0x0086, 0x8AED, 0x0018, 0x45DF, 0x0026, 0x01BD, 0x0046, 0x22EF, 0x0086, 0x027D,
1371 0x005A, 0x227F, 0x0026, 0x003A, 0x0046, 0x444D, 0x0086, 0x4CCD, 0x0018, 0x11BF, 0x0026, 0x2EFD, 0x0046,
1372 0x00FE, 0x0086, 0x009C, 0x00CA, 0x223F, 0x0026, 0x00AA, 0x0046, 0x445D, 0x0086, 0x8CCD, 0x0018, 0x00DE,
1373 0x0026, 0x4FFD, 0x0046, 0xABFF, 0x0086, 0x009D, 0x005A, 0x006F, 0x0026, 0x003A, 0x0046, 0x6EFF, 0x0086,
1374 0x88AD, 0x0018, 0x2AAF, 0x0026, 0x8FFD, 0x0046, 0x00EE, 0x0086, 0x888D, 0x00CA, 0x222F, 0x0004, 0x00CA,
1375 0x0088, 0x027D, 0x0004, 0x4CCD, 0x0028, 0x00FE, 0x0004, 0x2AFD, 0x0048, 0x005C, 0x0004, 0x009D, 0x0018,
1376 0x00DE, 0x0004, 0x01BD, 0x0088, 0x006C, 0x0004, 0x88AD, 0x0028, 0x11DF, 0x0004, 0x8AED, 0x0048, 0x003C,
1377 0x0004, 0x888D, 0x0018, 0x111F, 0x0004, 0x00CA, 0x0088, 0x006D, 0x0004, 0x88CD, 0x0028, 0x88FF, 0x0004,
1378 0x8BFD, 0x0048, 0x444D, 0x0004, 0x009C, 0x0018, 0x00BE, 0x0004, 0x4EFD, 0x0088, 0x445D, 0x0004, 0x00AC,
1379 0x0028, 0x00EE, 0x0004, 0x45DD, 0x0048, 0x222D, 0x0004, 0x003D, 0x0018, 0x007E, 0x0004, 0x00CA, 0x0088,
1380 0x027D, 0x0004, 0x4CCD, 0x0028, 0x1FFF, 0x0004, 0x2AFD, 0x0048, 0x005C, 0x0004, 0x009D, 0x0018, 0x11BF,
1381 0x0004, 0x01BD, 0x0088, 0x006C, 0x0004, 0x88AD, 0x0028, 0x22EF, 0x0004, 0x8AED, 0x0048, 0x003C, 0x0004,
1382 0x888D, 0x0018, 0x227F, 0x0004, 0x00CA, 0x0088, 0x006D, 0x0004, 0x88CD, 0x0028, 0x4EEF, 0x0004, 0x8BFD,
1383 0x0048, 0x444D, 0x0004, 0x009C, 0x0018, 0x2AAF, 0x0004, 0x4EFD, 0x0088, 0x445D, 0x0004, 0x00AC, 0x0028,
1384 0x8DDF, 0x0004, 0x45DD, 0x0048, 0x222D, 0x0004, 0x003D, 0x0018, 0x155F, 0x0004, 0x005A, 0x0088, 0x006C,
1385 0x0004, 0x88DD, 0x0028, 0x23FF, 0x0004, 0x11FD, 0x0048, 0x444D, 0x0004, 0x00AD, 0x0018, 0x00BE, 0x0004,
1386 0x137D, 0x0088, 0x155D, 0x0004, 0x00CC, 0x0028, 0x00DE, 0x0004, 0x02ED, 0x0048, 0x111D, 0x0004, 0x009D,
1387 0x0018, 0x007E, 0x0004, 0x005A, 0x0088, 0x455D, 0x0004, 0x44CD, 0x0028, 0x00EE, 0x0004, 0x1FFD, 0x0048,
1388 0x003C, 0x0004, 0x00AC, 0x0018, 0x555F, 0x0004, 0x47FD, 0x0088, 0x113D, 0x0004, 0x02BD, 0x0028, 0x477F,
1389 0x0004, 0x4CDD, 0x0048, 0x8FFF, 0x0004, 0x009C, 0x0018, 0x222F, 0x0004, 0x005A, 0x0088, 0x006C, 0x0004,
1390 0x88DD, 0x0028, 0x00FE, 0x0004, 0x11FD, 0x0048, 0x444D, 0x0004, 0x00AD, 0x0018, 0x888F, 0x0004, 0x137D,
1391 0x0088, 0x155D, 0x0004, 0x00CC, 0x0028, 0x8CCF, 0x0004, 0x02ED, 0x0048, 0x111D, 0x0004, 0x009D, 0x0018,
1392 0x006F, 0x0004, 0x005A, 0x0088, 0x455D, 0x0004, 0x44CD, 0x0028, 0x1DDF, 0x0004, 0x1FFD, 0x0048, 0x003C,
1393 0x0004, 0x00AC, 0x0018, 0x227F, 0x0004, 0x47FD, 0x0088, 0x113D, 0x0004, 0x02BD, 0x0028, 0x22BF, 0x0004,
1394 0x4CDD, 0x0048, 0x22EF, 0x0004, 0x009C, 0x0018, 0x233F, 0x0006, 0x4DDD, 0x4FFB, 0xCFFF, 0x0018, 0x113D,
1395 0x005A, 0x888F, 0x0006, 0x23BD, 0x008A, 0x00EE, 0x002A, 0x155D, 0xAAFD, 0x277F, 0x0006, 0x44CD, 0x8FFB,
1396 0x44EF, 0x0018, 0x467D, 0x004A, 0x2AAF, 0x0006, 0x00AC, 0x555B, 0x99DF, 0x1FFB, 0x003C, 0x5FFD, 0x266F,
1397 0x0006, 0x1DDD, 0x4FFB, 0x6EFF, 0x0018, 0x177D, 0x005A, 0x1BBF, 0x0006, 0x88AD, 0x008A, 0x5DDF, 0x002A,
1398 0x444D, 0x2FFD, 0x667F, 0x0006, 0x00CC, 0x8FFB, 0x2EEF, 0x0018, 0x455D, 0x004A, 0x119F, 0x0006, 0x009C,
1399 0x555B, 0x8CCF, 0x1FFB, 0x111D, 0x8CED, 0x006E, 0x0006, 0x4DDD, 0x4FFB, 0x3FFF, 0x0018, 0x113D, 0x005A,
1400 0x11BF, 0x0006, 0x23BD, 0x008A, 0x8DDF, 0x002A, 0x155D, 0xAAFD, 0x222F, 0x0006, 0x44CD, 0x8FFB, 0x00FE,
1401 0x0018, 0x467D, 0x004A, 0x899F, 0x0006, 0x00AC, 0x555B, 0x00DE, 0x1FFB, 0x003C, 0x5FFD, 0x446F, 0x0006,
1402 0x1DDD, 0x4FFB, 0x9BFF, 0x0018, 0x177D, 0x005A, 0x00BE, 0x0006, 0x88AD, 0x008A, 0xCDDF, 0x002A, 0x444D,
1403 0x2FFD, 0x007E, 0x0006, 0x00CC, 0x8FFB, 0x4EEF, 0x0018, 0x455D, 0x004A, 0x377F, 0x0006, 0x009C, 0x555B,
1404 0x8BBF, 0x1FFB, 0x111D, 0x8CED, 0x233F, 0x0004, 0x00AA, 0x0088, 0x047D, 0x0004, 0x01DD, 0x0028, 0x11DF,
1405 0x0004, 0x27FD, 0x0048, 0x005C, 0x0004, 0x8AAD, 0x0018, 0x2BBF, 0x0004, 0x009C, 0x0088, 0x006C, 0x0004,
1406 0x00CC, 0x0028, 0x00EE, 0x0004, 0x8CED, 0x0048, 0x222D, 0x0004, 0x888D, 0x0018, 0x007E, 0x0004, 0x00AA,
1407 0x0088, 0x006D, 0x0004, 0x88CD, 0x0028, 0x00FE, 0x0004, 0x19FD, 0x0048, 0x003C, 0x0004, 0x2AAD, 0x0018,
1408 0xAAAF, 0x0004, 0x8BFD, 0x0088, 0x005D, 0x0004, 0x00BD, 0x0028, 0x4CCF, 0x0004, 0x44ED, 0x0048, 0x4FFF,
1409 0x0004, 0x223D, 0x0018, 0x111F, 0x0004, 0x00AA, 0x0088, 0x047D, 0x0004, 0x01DD, 0x0028, 0x99FF, 0x0004,
1410 0x27FD, 0x0048, 0x005C, 0x0004, 0x8AAD, 0x0018, 0x00BE, 0x0004, 0x009C, 0x0088, 0x006C, 0x0004, 0x00CC,
1411 0x0028, 0x00DE, 0x0004, 0x8CED, 0x0048, 0x222D, 0x0004, 0x888D, 0x0018, 0x444F, 0x0004, 0x00AA, 0x0088,
1412 0x006D, 0x0004, 0x88CD, 0x0028, 0x2EEF, 0x0004, 0x19FD, 0x0048, 0x003C, 0x0004, 0x2AAD, 0x0018, 0x447F,
1413 0x0004, 0x8BFD, 0x0088, 0x005D, 0x0004, 0x00BD, 0x0028, 0x009F, 0x0004, 0x44ED, 0x0048, 0x67FF, 0x0004,
1414 0x223D, 0x0018, 0x133F, 0x0006, 0x00CC, 0x008A, 0x9DFF, 0x2FFB, 0x467D, 0x1FFD, 0x99BF, 0x0006, 0x2AAD,
1415 0x002A, 0x66EF, 0x4FFB, 0x005C, 0x2EED, 0x377F, 0x0006, 0x89BD, 0x004A, 0x00FE, 0x8FFB, 0x006C, 0x67FD,
1416 0x889F, 0x0006, 0x888D, 0x001A, 0x5DDF, 0x00AA, 0x222D, 0x89DD, 0x444F, 0x0006, 0x2BBD, 0x008A, 0xCFFF,
1417 0x2FFB, 0x226D, 0x009C, 0x00BE, 0x0006, 0xAAAD, 0x002A, 0x1DDF, 0x4FFB, 0x003C, 0x4DDD, 0x466F, 0x0006,
1418 0x8AAD, 0x004A, 0xAEEF, 0x8FFB, 0x445D, 0x8EED, 0x177F, 0x0006, 0x233D, 0x001A, 0x4CCF, 0x00AA, 0xAFFF,
1419 0x88CD, 0x133F, 0x0006, 0x00CC, 0x008A, 0x77FF, 0x2FFB, 0x467D, 0x1FFD, 0x3BBF, 0x0006, 0x2AAD, 0x002A,
1420 0x00EE, 0x4FFB, 0x005C, 0x2EED, 0x007E, 0x0006, 0x89BD, 0x004A, 0x4EEF, 0x8FFB, 0x006C, 0x67FD, 0x667F,
1421 0x0006, 0x888D, 0x001A, 0x00DE, 0x00AA, 0x222D, 0x89DD, 0x333F, 0x0006, 0x2BBD, 0x008A, 0x57FF, 0x2FFB,
1422 0x226D, 0x009C, 0x199F, 0x0006, 0xAAAD, 0x002A, 0x99DF, 0x4FFB, 0x003C, 0x4DDD, 0x155F, 0x0006, 0x8AAD,
1423 0x004A, 0xCEEF, 0x8FFB, 0x445D, 0x8EED, 0x277F, 0x0006, 0x233D, 0x001A, 0x1BBF, 0x00AA, 0x3FFF, 0x88CD,
1424 0x111F, 0x0006, 0x45DD, 0x2FFB, 0x111D, 0x0018, 0x467D, 0x8FFD, 0xCCCF, 0x0006, 0x19BD, 0x004A, 0x22EF,
1425 0x002A, 0x222D, 0x3FFD, 0x888F, 0x0006, 0x00CC, 0x008A, 0x00FE, 0x0018, 0x115D, 0xCFFD, 0x8AAF, 0x0006,
1426 0x00AC, 0x003A, 0x8CDF, 0x1FFB, 0x133D, 0x66FD, 0x466F, 0x0006, 0x8CCD, 0x2FFB, 0x5FFF, 0x0018, 0x006C,
1427 0x4FFD, 0xABBF, 0x0006, 0x22AD, 0x004A, 0x00EE, 0x002A, 0x233D, 0xAEFD, 0x377F, 0x0006, 0x2BBD, 0x008A,
1428 0x55DF, 0x0018, 0x005C, 0x177D, 0x119F, 0x0006, 0x009C, 0x003A, 0x4CCF, 0x1FFB, 0x333D, 0x8EED, 0x444F,
1429 0x0006, 0x45DD, 0x2FFB, 0x111D, 0x0018, 0x467D, 0x8FFD, 0x99BF, 0x0006, 0x19BD, 0x004A, 0x2EEF, 0x002A,
1430 0x222D, 0x3FFD, 0x667F, 0x0006, 0x00CC, 0x008A, 0x4EEF, 0x0018, 0x115D, 0xCFFD, 0x899F, 0x0006, 0x00AC,
1431 0x003A, 0x00DE, 0x1FFB, 0x133D, 0x66FD, 0x226F, 0x0006, 0x8CCD, 0x2FFB, 0x9BFF, 0x0018, 0x006C, 0x4FFD,
1432 0x00BE, 0x0006, 0x22AD, 0x004A, 0x1DDF, 0x002A, 0x233D, 0xAEFD, 0x007E, 0x0006, 0x2BBD, 0x008A, 0xCEEF,
1433 0x0018, 0x005C, 0x177D, 0x277F, 0x0006, 0x009C, 0x003A, 0x8BBF, 0x1FFB, 0x333D, 0x8EED, 0x455F, 0x1FF9,
1434 0x1DDD, 0xAFFB, 0x00DE, 0x8FF9, 0x001C, 0xFFFB, 0x477F, 0x4FF9, 0x177D, 0x3FFB, 0x3BBF, 0x2FF9, 0xAEEF,
1435 0x8EED, 0x444F, 0x1FF9, 0x22AD, 0x000A, 0x8BBF, 0x8FF9, 0x00FE, 0xCFFD, 0x007E, 0x4FF9, 0x115D, 0x5FFB,
1436 0x577F, 0x2FF9, 0x8DDF, 0x2EED, 0x333F, 0x1FF9, 0x2BBD, 0xAFFB, 0x88CF, 0x8FF9, 0xBFFF, 0xFFFB, 0x377F,
1437 0x4FF9, 0x006D, 0x3FFB, 0x00BE, 0x2FF9, 0x66EF, 0x9FFD, 0x133F, 0x1FF9, 0x009D, 0x000A, 0xABBF, 0x8FF9,
1438 0xDFFF, 0x6FFD, 0x006E, 0x4FF9, 0x002C, 0x5FFB, 0x888F, 0x2FF9, 0xCDDF, 0x4DDD, 0x222F, 0x1FF9, 0x1DDD,
1439 0xAFFB, 0x4CCF, 0x8FF9, 0x001C, 0xFFFB, 0x277F, 0x4FF9, 0x177D, 0x3FFB, 0x99BF, 0x2FF9, 0xCEEF, 0x8EED,
1440 0x004E, 0x1FF9, 0x22AD, 0x000A, 0x00AE, 0x8FF9, 0x7FFF, 0xCFFD, 0x005E, 0x4FF9, 0x115D, 0x5FFB, 0x009E,
1441 0x2FF9, 0x5DDF, 0x2EED, 0x003E, 0x1FF9, 0x2BBD, 0xAFFB, 0x00CE, 0x8FF9, 0xEFFF, 0xFFFB, 0x667F, 0x4FF9,
1442 0x006D, 0x3FFB, 0x8AAF, 0x2FF9, 0x00EE, 0x9FFD, 0x233F, 0x1FF9, 0x009D, 0x000A, 0x1BBF, 0x8FF9, 0x4EEF,
1443 0x6FFD, 0x455F, 0x4FF9, 0x002C, 0x5FFB, 0x008E, 0x2FF9, 0x99DF, 0x4DDD, 0x111F};
1444