Line data Source code
1 : /*====================================================================================
2 : EVS Codec 3GPP TS26.452 Aug 12, 2021. Version 16.3.0
3 : ====================================================================================*/
4 :
5 : #include <stdint.h>
6 : #include <assert.h>
7 : #include "options.h"
8 : #include "rom_com.h"
9 : #include "rom_dec.h"
10 : #include "basop_util.h"
11 : #include "cnst.h"
12 : #include "prot_fx.h"
13 : #include "ivas_prot_fx.h"
14 :
15 : #include "ivas_rom_com.h"
16 : /*-------------------------------------------------------------------*
17 : * ACcontextMapping_decode2_no_mem_s17_LC()
18 : *
19 : * Arithmetic decoder
20 : *-------------------------------------------------------------------*/
21 :
22 638 : Word16 ACcontextMapping_decode2_no_mem_s17_LC(
23 : Decoder_State *st, /* i/o: decoder state */
24 : Word16 *x, /* o: decoded spectrum Q0*/
25 : Word16 nt, /* i: size of spectrum */
26 : Word16 nbbits, /* i: bit budget */
27 : Word16 resQMaxBits, /* i: residual coding maximum bits*/
28 : CONTEXT_HM_CONFIG *hm_cfg /* i: context-based harmonic model configuration */
29 : )
30 : {
31 : Tastat as;
32 : Word16 start_bit_pos, lsbs_bit_pos, overflow_bit_pos;
33 : Word16 a, b, a1, b1, a1_i, b1_i, k, L;
34 : UWord16 t;
35 : Word16 lev, pki, esc_nb;
36 : Word16 rateFlag;
37 : Word16 lastnz, n;
38 : UWord16 r;
39 : Word16 resQBits;
40 : Word16 rest_bits, rest_bits_overflow;
41 638 : Word16 tmp = 0; /* initialize just to avoid compiler warning */
42 638 : move16();
43 : Word16 nt_half;
44 : Word16 c[2], *ctx;
45 : Word16 p1, p2;
46 : Word16 ii[2], idx1, idx2, idx;
47 : Word16 numPeakIndicesOrig, numHoleIndices;
48 : get_next_coeff_function get_next_coeff;
49 : Word16 nbbits_m2;
50 : Word32 La, Lb;
51 :
52 638 : r = 0; /* to avoid compilation warnings */
53 638 : move16();
54 638 : esc_nb = 0; /* to avoid compilation warnings */
55 638 : move16();
56 :
57 638 : set16_fx( x, 0, nt );
58 :
59 : /* Rate flag */
60 638 : rateFlag = 0;
61 638 : move16();
62 638 : if ( GT_16( nbbits, 400 ) )
63 : {
64 42 : rateFlag = 2 << NBITS_CONTEXT;
65 42 : move16();
66 : }
67 :
68 : /*Decode number of ntuples*/
69 638 : start_bit_pos = st->next_bit_pos;
70 638 : move16();
71 638 : lsbs_bit_pos = add( start_bit_pos, sub( nbbits, 1 ) );
72 :
73 638 : n = 0;
74 638 : move16();
75 :
76 638 : L = sub( 14, norm_s( negate( nt ) ) );
77 638 : n = add( get_next_indice_fx( st, L ), 1 );
78 :
79 : /* Init */
80 638 : nt_half = shr( nt, 1 );
81 638 : c[0] = c[1] = 0;
82 638 : move16();
83 638 : move16();
84 :
85 638 : t = 0;
86 638 : move16();
87 :
88 638 : lastnz = shl( n, 1 );
89 638 : test();
90 638 : IF( GT_16( lastnz, nt ) || st->BER_detect )
91 : {
92 0 : st->BER_detect = 1;
93 0 : move16();
94 0 : return 0;
95 : }
96 :
97 638 : IF( hm_cfg ) /* mapped domain */
98 : {
99 55 : numPeakIndicesOrig = hm_cfg->numPeakIndices;
100 55 : move16();
101 55 : hm_cfg->numPeakIndices = s_min( hm_cfg->numPeakIndices, lastnz );
102 55 : move16();
103 55 : numHoleIndices = sub( lastnz, hm_cfg->numPeakIndices );
104 :
105 : /* Mark hole indices beyond lastnz as pruned */
106 24287 : FOR( k = numHoleIndices; k < hm_cfg->numHoleIndices; ++k )
107 : {
108 24232 : hm_cfg->holeIndices[k] = add( hm_cfg->holeIndices[k], nt );
109 24232 : move16();
110 : }
111 :
112 55 : ii[0] = numPeakIndicesOrig;
113 55 : move16();
114 55 : ii[1] = 0;
115 55 : move16();
116 55 : p1 = p2 = 0; /* to avoid compilation warnings */
117 55 : move16();
118 55 : move16();
119 :
120 55 : get_next_coeff = get_next_coeff_mapped;
121 : }
122 : ELSE /* unmapped domain */
123 : {
124 583 : ii[0] = 0;
125 583 : move16();
126 :
127 583 : p1 = p2 = 0;
128 583 : move16();
129 583 : move16();
130 :
131 583 : get_next_coeff = get_next_coeff_unmapped;
132 : }
133 :
134 : /* Start Decoding */
135 638 : ari_start_decoding_14bits_fx( st, &as );
136 :
137 638 : overflow_bit_pos = st->next_bit_pos;
138 638 : move16();
139 638 : nbbits_m2 = add( nbbits, cbitsnew - 2 );
140 638 : rest_bits_overflow = rest_bits = negate( nbbits_m2 );
141 638 : move16();
142 :
143 : /*Main Loop through the 2-tuples*/
144 66168 : FOR( k = 0; k < lastnz; k += 2 )
145 : {
146 : /* First coefficient */
147 65530 : a1_i = get_next_coeff( ii, &p1, &idx1, hm_cfg );
148 :
149 : /* Second coefficient */
150 65530 : b1_i = get_next_coeff( ii, &p2, &idx2, hm_cfg );
151 :
152 65530 : idx = s_min( idx1, idx2 );
153 :
154 : /* Get context */
155 65530 : ctx = &c[s_or( p1, p2 )];
156 :
157 65530 : t = add( *ctx, rateFlag );
158 65530 : IF( GT_16( idx, nt_half ) )
159 : {
160 81 : t = add( t, 1 << NBITS_CONTEXT );
161 : }
162 :
163 65530 : test();
164 : /* BER detection: Check max value of context t leading to out-of-bound access to ari_lookup_s17_LC[]*/
165 65530 : IF( GE_16( t, ( 1 << ( NBITS_CONTEXT + NBITS_RATEQ ) ) ) || lsbs_bit_pos <= 0 )
166 : {
167 0 : st->BER_detect = 1;
168 0 : move16();
169 0 : return 0;
170 : }
171 :
172 65530 : La = L_deposit_l( 0 );
173 65530 : Lb = L_deposit_l( 0 );
174 : /* MSBs decoding */
175 :
176 69328 : FOR( lev = 0; lev < 15 && lsbs_bit_pos > 0; lev++ )
177 : {
178 :
179 69328 : esc_nb = s_min( lev, 3 );
180 69328 : tmp = add( t, Tab_esc_nb[esc_nb] );
181 69328 : assert( tmp >= 0 && tmp < 4096 );
182 69328 : pki = ari_lookup_s17_LC[tmp];
183 69328 : move16();
184 69328 : r = ari_decode_14bits_s17_ext_fx( st, &as, ari_pk_s17_LC_ext[pki] );
185 :
186 69328 : IF( LT_16( r, VAL_ESC ) )
187 : {
188 65530 : BREAK;
189 : }
190 :
191 : /*LSBs decoding*/
192 3798 : La = L_mac0( La, pow2tab[lev], get_indice_1_fx( st, lsbs_bit_pos-- ) );
193 3798 : Lb = L_mac0( Lb, pow2tab[lev], get_indice_1_fx( st, lsbs_bit_pos-- ) );
194 : }
195 :
196 65530 : test();
197 65530 : test();
198 65530 : IF( ( ( LT_16( lsbs_bit_pos, -1 ) && GE_16( r, VAL_ESC ) ) ) || ( GT_16( lev, 14 ) ) )
199 : {
200 0 : x[a1_i] = 0;
201 0 : move16();
202 0 : x[b1_i] = 0;
203 0 : move16();
204 0 : st->BER_detect = 1;
205 0 : move16();
206 0 : return 0;
207 : }
208 :
209 : /*MSBs contributions*/
210 65530 : b1 = shr( r, 2 );
211 65530 : a1 = s_and( r, 0x3 );
212 65530 : a = extract_l( L_mac0( La, pow2tab[lev], a1 ) );
213 65530 : b = extract_l( L_mac0( Lb, pow2tab[lev], b1 ) );
214 :
215 : /*lsbs bits sign bits*/
216 65530 : rest_bits = add( rest_bits, shl( lev, 1 ) );
217 :
218 65530 : if ( a > 0 )
219 : {
220 17155 : rest_bits = add( rest_bits, 1 );
221 : }
222 65530 : if ( b > 0 )
223 : {
224 16983 : rest_bits = add( rest_bits, 1 );
225 : }
226 :
227 : /*Dectect overflow*/
228 65530 : IF( add( sub( st->next_bit_pos, start_bit_pos ), rest_bits ) > 0 )
229 : {
230 : /* Roll back bitstream position to overflow_bit_pos */
231 0 : get_next_indice_tmp_fx( st, sub( overflow_bit_pos, st->next_bit_pos ) );
232 0 : rest_bits = rest_bits_overflow;
233 0 : move16();
234 0 : x[a1_i] = 0;
235 0 : move16();
236 0 : x[b1_i] = 0;
237 0 : move16();
238 0 : BREAK;
239 : }
240 :
241 65530 : overflow_bit_pos = st->next_bit_pos;
242 65530 : move16();
243 65530 : rest_bits_overflow = rest_bits;
244 65530 : move16();
245 :
246 : /* Store decoded data */
247 65530 : x[a1_i] = a;
248 65530 : move16();
249 65530 : x[b1_i] = b;
250 65530 : move16();
251 :
252 : /* Update context for next 2-tuple */
253 65530 : IF( EQ_32( p1, p2 ) ) /* peak-peak or hole-hole context */
254 : {
255 65280 : lev = sub( esc_nb, 1 );
256 65280 : IF( lev > 0 )
257 884 : t = add( 12, lev );
258 65280 : IF( lev <= 0 )
259 64396 : t = add( a1, b1 );
260 65280 : IF( lev == 0 )
261 1706 : t = add( t, t );
262 :
263 65280 : *ctx = add( shl( s_and( *ctx, 0xf ), 4 ), add( t, 1 ) );
264 65280 : move16();
265 : }
266 : ELSE /* mixed context */
267 : {
268 250 : IF( s_and( idx1, 1 ) ) /* update first context */
269 : {
270 122 : c[p1] = update_mixed_context( c[p1], a );
271 122 : move16();
272 : }
273 :
274 250 : IF( s_and( idx2, 1 ) ) /* update second context */
275 : {
276 128 : c[p2] = update_mixed_context( c[p2], b );
277 128 : move16();
278 : }
279 : }
280 : }
281 :
282 : /* Total number of decoded AC bits */
283 638 : get_next_indice_tmp_fx( st, -( cbitsnew - 2 ) );
284 :
285 : /*detect overflow*/
286 638 : IF( NE_16( k, lastnz ) )
287 : {
288 0 : rest_bits = add( rest_bits, nbbits_m2 );
289 : /* Set bitstream position to (start_bit_pos+nbbits-rest_bits) */
290 0 : get_next_indice_tmp_fx( st, sub( ( sub( add( start_bit_pos, nbbits ), rest_bits ) ), st->next_bit_pos ) );
291 : }
292 :
293 : /*Decode signs*/
294 638 : if ( hm_cfg )
295 : {
296 55 : tmp = nt;
297 55 : move16();
298 : }
299 638 : if ( !hm_cfg )
300 : {
301 583 : tmp = lastnz;
302 583 : move16();
303 : }
304 155930 : FOR( k = 0; k < tmp; k++ )
305 : {
306 155292 : IF( x[k] > 0 )
307 : {
308 34138 : IF( get_next_indice_1_fx( st ) != 0 )
309 : {
310 17088 : x[k] = negate( x[k] );
311 17088 : move16();
312 : }
313 : }
314 : }
315 :
316 : /*Decode Residual Q*/
317 638 : resQBits = s_min( resQMaxBits, sub( add( lsbs_bit_pos, 1 ), st->next_bit_pos ) );
318 7295 : FOR( k = 0; k < resQBits; ++k )
319 : {
320 6657 : x[nt + k] = get_indice_1_fx( st, sub( lsbs_bit_pos, k ) );
321 6657 : move16();
322 : }
323 :
324 : /* Set bitstream pointer to end of buffer */
325 638 : get_next_indice_tmp_fx( st, sub( add( start_bit_pos, nbbits ), st->next_bit_pos ) );
326 :
327 :
328 638 : return resQBits;
329 : }
330 :
331 : /*-------------------------------------------------------------------*
332 : * RCcontextMapping_decode2_no_mem_s17_LCS()
333 : *
334 : * Range decoder
335 : *-------------------------------------------------------------------*/
336 :
337 : /*! r: resQBits */
338 773840 : Word16 RCcontextMapping_decode2_no_mem_s17_LCS_fx(
339 : Decoder_State *st, /* i/o: decoder state */
340 : Word16 *x, /* o : decoded spectrum Q0*/
341 : const Word16 nt, /* i : size of spectrum */
342 : const Word16 nbbits, /* i : bit budget */
343 : const Word16 resQMaxBits, /* i : residual coding maximum bits */
344 : CONTEXT_HM_CONFIG *hm_cfg /* i : context-based harmonic model configuration*/
345 : )
346 : {
347 : RangeUniDecState rc_st_dec; /* State of the range decoder */
348 : Word16 start_bit_pos, lsbs_bit_pos;
349 : Word16 a, b, a1, b1, k;
350 : UWord16 t;
351 : Word16 lev, pki, esc_nb;
352 : Word16 rateFlag;
353 : Word16 lastnz, n;
354 : UWord16 r;
355 : Word16 resQBits;
356 : Word16 rest_bits;
357 : Word16 nt_half;
358 : Word16 nbbits_m2;
359 : Word16 bits_tups; /* No. of bits for coding the no. of tuples */
360 :
361 773840 : set16_fx( x, 0, nt );
362 :
363 : /*Decode number of ntuples*/
364 773840 : start_bit_pos = st->next_bit_pos;
365 773840 : move16();
366 773840 : lsbs_bit_pos = add( start_bit_pos, sub( nbbits, 1 ) );
367 773840 : n = 0;
368 773840 : move16();
369 773840 : k = 1;
370 773840 : move16();
371 773840 : nt_half = shr( nt, 1 );
372 7652086 : WHILE( k < nt_half )
373 : {
374 6878246 : n = add( n, 1 );
375 6878246 : k = shl( k, 1 );
376 : }
377 :
378 773840 : bits_tups = n;
379 773840 : move16();
380 773840 : n = add( get_next_indice_fx( st, n ), 1 );
381 :
382 773840 : t = 0;
383 773840 : move16();
384 773840 : lastnz = shl( n, 1 );
385 :
386 773840 : IF( GT_16( lastnz, nt ) )
387 : {
388 0 : st->BER_detect = 1;
389 0 : move16();
390 0 : return 0;
391 : }
392 :
393 773840 : IF( hm_cfg )
394 : {
395 : Word16 a1_i, b1_i;
396 : Word16 c[2], *ctx;
397 : Word16 p1, p2;
398 : Word16 ii[2];
399 : Word16 idx1, idx2, idx;
400 : Word16 numPeakIndicesOrig, numHoleIndices;
401 :
402 : /* Rate flag */
403 11959 : IF( GT_16( nbbits, 400 ) )
404 : {
405 5776 : rateFlag = 2 << NBITS_CONTEXT;
406 5776 : move16();
407 : }
408 : ELSE
409 : {
410 6183 : rateFlag = 0;
411 6183 : move16();
412 : }
413 :
414 : /* Init */
415 11959 : c[0] = c[1] = 0;
416 11959 : move16();
417 11959 : move16();
418 : /* mapped domain */
419 11959 : numPeakIndicesOrig = hm_cfg->numPeakIndices;
420 11959 : move16();
421 11959 : hm_cfg->numPeakIndices = s_min( hm_cfg->numPeakIndices, lastnz );
422 11959 : move16();
423 11959 : numHoleIndices = sub( lastnz, hm_cfg->numPeakIndices );
424 :
425 : /* Mark hole indices beyond lastnz as pruned */
426 5144729 : FOR( k = numHoleIndices; k < hm_cfg->numHoleIndices; ++k )
427 : {
428 5132770 : hm_cfg->holeIndices[k] = add( hm_cfg->holeIndices[k], nt );
429 5132770 : move16();
430 : }
431 :
432 11959 : ii[0] = numPeakIndicesOrig;
433 11959 : move16();
434 11959 : ii[1] = 0;
435 11959 : move16();
436 11959 : p1 = p2 = 0; /* to avoid compilation warnings */
437 11959 : move16();
438 11959 : move16();
439 : /* Start Decoding */
440 : /* Initialize range decoder */
441 11959 : rc_uni_dec_init_fx( &rc_st_dec, &st->bit_stream[st->next_bit_pos], nbbits ); /* (nbbits + 30) entries are read by the decoder */
442 :
443 11959 : nbbits_m2 = nbbits;
444 11959 : move16();
445 11959 : rest_bits = negate( nbbits_m2 );
446 :
447 : /* Main Loop through the 2-tuples */
448 2249141 : FOR( k = 0; k < lastnz; k += 2 )
449 : {
450 2237182 : a1_i = get_next_coeff_mapped( ii, &p1, &idx1, hm_cfg );
451 2237182 : b1_i = get_next_coeff_mapped( ii, &p2, &idx2, hm_cfg );
452 2237182 : idx = s_min( idx1, idx2 );
453 :
454 : /* Get context */
455 2237182 : ctx = &c[s_or( p1, p2 )];
456 2237182 : t = add( *ctx, rateFlag );
457 2237182 : IF( LT_16( nt_half, idx ) )
458 : {
459 270556 : t = add( t, ( 1 << NBITS_CONTEXT ) );
460 : }
461 :
462 2237182 : esc_nb = 0;
463 2237182 : move16();
464 2237182 : r = 0;
465 2237182 : move16();
466 2237182 : test();
467 : /* BER detection: Check max value of context t leading to out-of-bound access to ari_lookup_s17_LC[]*/
468 2237182 : IF( ( GE_16( t, ( 1 << ( NBITS_CONTEXT + NBITS_RATEQ ) ) ) ) || ( lsbs_bit_pos <= 0 ) )
469 : {
470 0 : st->BER_detect = 1;
471 0 : move16();
472 0 : return 0;
473 : }
474 :
475 2237182 : a = b = 0;
476 2237182 : move16();
477 2237182 : move16();
478 : /* MSBs decoding */
479 2539486 : FOR( lev = 0; lev < 15 && lsbs_bit_pos > 0; ++lev )
480 : {
481 2539486 : esc_nb = s_min( lev, 3 );
482 2539486 : pki = ari_lookup_s17_LC[t + Tab_esc_nb[esc_nb]];
483 2539486 : move16();
484 2539486 : r = rc_uni_dec_read_symbol_fastS_fx( &rc_st_dec, cum_freq_ari_pk_s17_LC_ext[pki], sym_freq_ari_pk_s17_LC_ext[pki], 17, 14 ); /*Alphabet size = 17 (2^4 = 16 MSB symbols + 1 ESC symbol) */
485 : /* r is the symbol read, the possible values are {0,1,....alphabet_size - 1} */
486 :
487 2539486 : IF( LT_16( r, VAL_ESC ) ) /* If symbol read corresponds to MSB */
488 : {
489 2237182 : BREAK;
490 : }
491 :
492 : /* LSBs decoding */
493 302304 : a = add( a, shl( get_indice_1_fx( st, lsbs_bit_pos-- ), lev ) );
494 302304 : b = add( b, shl( get_indice_1_fx( st, lsbs_bit_pos-- ), lev ) );
495 : }
496 2237182 : test();
497 2237182 : test();
498 2237182 : IF( ( LT_16( lsbs_bit_pos, -1 ) && GE_16( r, VAL_ESC ) ) || GT_16( lev, 14 ) )
499 : {
500 0 : x[a1_i] = 0;
501 0 : move16();
502 0 : x[b1_i] = 0;
503 0 : move16();
504 0 : st->BER_detect = 1;
505 0 : move16();
506 0 : return 0;
507 : }
508 :
509 : /* MSBs contributions */
510 2237182 : b1 = shr( r, 2 );
511 2237182 : a1 = s_and( r, 0x3 );
512 2237182 : a = add( a, shl( a1, lev ) );
513 2237182 : b = add( b, shl( b1, lev ) );
514 :
515 : /* Add 2 LSB bits per bit-plane */
516 2237182 : rest_bits = add( rest_bits, shl( lev, 1 ) );
517 : /* Sign bits */
518 2237182 : rest_bits = add( rest_bits, s_min( a, 1 ) );
519 2237182 : rest_bits = add( rest_bits, s_min( b, 1 ) );
520 :
521 : /* Update bitstream pointer */
522 2237182 : st->next_bit_pos = add( start_bit_pos, add( bits_tups, rc_uni_dec_virtual_finish_fx( &rc_st_dec ) ) );
523 2237182 : move16();
524 :
525 : /* Confirm that there is no overflow */
526 : #ifdef DEBUGGING
527 : assert( st->next_bit_pos - start_bit_pos + rest_bits <= 0 );
528 : #endif
529 :
530 : /* Store decoded data */
531 2237182 : x[a1_i] = a;
532 2237182 : move16();
533 2237182 : x[b1_i] = b;
534 2237182 : move16();
535 : /* Update context for next 2-tuple */
536 2237182 : IF( EQ_32( p1, p2 ) )
537 : {
538 : /* peak-peak or hole-hole context */
539 2031403 : lev = sub( esc_nb, 1 );
540 :
541 2031403 : IF( lev <= 0 )
542 : {
543 1974235 : t = add( 1, imult1616( add( a1, b1 ), add( lev, 2 ) ) );
544 : }
545 : ELSE
546 : {
547 57168 : t = add( 13, lev );
548 : }
549 :
550 2031403 : *ctx = add( shl( s_and( *ctx, 0xf ), 4 ), t );
551 2031403 : move16();
552 : }
553 : ELSE
554 : {
555 : /* mixed context */
556 :
557 205779 : IF( s_and( idx1, 1 ) )
558 : {
559 : /* update first context */
560 97838 : c[p1] = update_mixed_context( c[p1], a );
561 97838 : move16();
562 : }
563 :
564 205779 : IF( s_and( idx2, 1 ) )
565 : {
566 : /* update second context */
567 107941 : c[p2] = update_mixed_context( c[p2], b );
568 107941 : move16();
569 : }
570 : }
571 : }
572 :
573 : /* We don't need to finish because virtual_finish() already does the same */
574 : /*st->next_bit_pos = rc_uni_dec_finish(&rc_st_dec);*/
575 :
576 : /* Check for bitstream errors */
577 11959 : assert( rc_st_dec.bit_error_detected == 0 );
578 :
579 : /* Cross-check: No overflow */
580 : #ifdef DEBUGGING
581 : assert( k == lastnz );
582 : #endif
583 :
584 : /* Decode signs */
585 11959 : n = nt;
586 11959 : move16();
587 : }
588 : ELSE /* if(!hm_cfg) */
589 : {
590 : Word16 c, rateQ;
591 : UWord16 s;
592 :
593 : /* Rate flag */
594 761881 : IF( GT_16( nbbits, 400 ) )
595 : {
596 557633 : rateFlag = 2;
597 557633 : move16();
598 : }
599 : ELSE
600 : {
601 204248 : rateFlag = 0;
602 204248 : move16();
603 : }
604 :
605 : /* Start Decoding */
606 : /* Initialize range decoder */
607 761881 : rc_uni_dec_init_fx( &rc_st_dec, &st->bit_stream[st->next_bit_pos], nbbits ); /* (nbbits + 30) entries are read by the decoder */
608 :
609 761881 : nbbits_m2 = nbbits;
610 761881 : move16();
611 761881 : rest_bits = negate( nbbits_m2 );
612 :
613 761881 : t = 0;
614 761881 : move16();
615 761881 : s = 0;
616 761881 : move16();
617 : /* Main Loop through the 2-tuples */
618 164788266 : FOR( k = 0; k < lastnz; k += 2 )
619 : {
620 164026385 : rateQ = add( rateFlag, (Word16) GT_16( k, ( nt_half ) ) );
621 164026385 : test();
622 : /* BER detection: Check max value of context t leading to out-of-bound access to ari_lookup_s17_LC[]*/
623 164026385 : IF( ( GE_16( t, ( 1 << ( NBITS_CONTEXT ) ) ) ) || ( lsbs_bit_pos <= 0 ) )
624 : {
625 0 : st->BER_detect = 1;
626 0 : move16();
627 0 : return 0;
628 : }
629 :
630 164026385 : a = b = 0;
631 164026385 : move16();
632 164026385 : move16();
633 164026385 : esc_nb = 0;
634 164026385 : move16();
635 164026385 : r = 0;
636 164026385 : move16();
637 : /* MSBs decoding */
638 194156732 : FOR( lev = 0; lev < 15 && lsbs_bit_pos > 0; ++lev )
639 : {
640 194156732 : esc_nb = s_min( lev, 3 );
641 194156732 : pki = ari_lookup_s17_LC[t + ( ( rateQ << NBITS_CONTEXT ) + Tab_esc_nb[esc_nb] )];
642 194156732 : move16();
643 194156732 : r = rc_uni_dec_read_symbol_fastS_fx( &rc_st_dec, cum_freq_ari_pk_s17_LC_ext[pki], sym_freq_ari_pk_s17_LC_ext[pki], 17, 14 ); /*Alphabet size = 17 (2^4 = 16 MSB symbols + 1 ESC symbol) */
644 : /* r is the symbol read, the possible values are {0,1,....alphabet_size - 1} */
645 :
646 194156732 : IF( LT_16( r, VAL_ESC ) ) /* If symbol read corresponds to MSB */
647 : {
648 164026385 : BREAK;
649 : }
650 :
651 : /* LSBs decoding */
652 30130347 : a = add( a, shl( get_indice_1_fx( st, lsbs_bit_pos-- ), lev ) );
653 30130347 : b = add( b, shl( get_indice_1_fx( st, lsbs_bit_pos-- ), lev ) );
654 : }
655 164026385 : test();
656 164026385 : test();
657 164026385 : IF( ( LT_16( lsbs_bit_pos, -1 ) && GE_16( r, VAL_ESC ) ) || GT_16( lev, 14 ) )
658 : {
659 0 : x[k + 0] = 0;
660 0 : move16();
661 0 : x[k + 1] = 0;
662 0 : move16();
663 0 : st->BER_detect = 1;
664 0 : move16();
665 0 : return 0;
666 : }
667 :
668 : /* MSBs contributions */
669 164026385 : b1 = shr( r, 2 );
670 164026385 : a1 = s_and( r, 0x3 );
671 164026385 : a = add( a, shl( a1, lev ) );
672 164026385 : b = add( b, shl( b1, lev ) );
673 :
674 : /* Add 2 LSB bits per bit-plane */
675 164026385 : rest_bits = add( rest_bits, shl( lev, 1 ) );
676 : /* Sign bits */
677 164026385 : rest_bits = add( rest_bits, s_min( a, 1 ) );
678 164026385 : rest_bits = add( rest_bits, s_min( b, 1 ) );
679 :
680 : /* Update bitstream pointer */
681 164026385 : st->next_bit_pos = add( start_bit_pos, add( bits_tups, rc_uni_dec_virtual_finish_fx( &rc_st_dec ) ) );
682 164026385 : move16();
683 :
684 : /* Confirm that there is no overflow */
685 : #ifdef DEBUGGING
686 : assert( st->next_bit_pos - start_bit_pos + rest_bits <= 0 );
687 : #endif
688 :
689 : /* Store decoded data */
690 164026385 : x[k + 0] = a;
691 164026385 : move16();
692 164026385 : x[k + 1] = b;
693 164026385 : move16();
694 : /* Update context for next 2-tuple */
695 164026385 : IF( LT_16( esc_nb, 2 ) )
696 : {
697 156569002 : c = add( 1, imult1616( add( a1, b1 ), add( esc_nb, 1 ) ) );
698 : }
699 : ELSE
700 : {
701 7457383 : c = add( 12, esc_nb );
702 : }
703 :
704 164026385 : s = (UWord16) L_shl( s, 4 ); /*Shift old 4 bits*/
705 164026385 : s = (UWord16) L_add( s, c ); /*replace last 4 bits*/
706 164026385 : t = (UWord16) L_and( s, 0xFF );
707 : }
708 :
709 : /* Decode signs */
710 761881 : n = lastnz;
711 761881 : move16();
712 : } /* end of if(hm_cfg) */
713 :
714 338450930 : FOR( k = 0; k < n; k++ )
715 : {
716 337677090 : IF( x[k] > 0 )
717 : {
718 135505349 : x[k] = imult1616( x[k], sub( 1, shl( get_next_indice_1_fx( st ), 1 ) ) );
719 135505349 : move16();
720 : }
721 : }
722 :
723 : /* Decode Residual Q */
724 773840 : resQBits = s_min( resQMaxBits, sub( add( lsbs_bit_pos, 1 ), st->next_bit_pos ) );
725 :
726 4282970 : FOR( k = 0; k < resQBits; ++k )
727 : {
728 3509130 : x[nt + k] = get_indice_1_fx( st, sub( lsbs_bit_pos, k ) );
729 3509130 : move16();
730 : }
731 :
732 : /* Set bitstream pointer to end of buffer */
733 773840 : get_next_indice_tmp_fx( st, sub( add( start_bit_pos, nbbits ), st->next_bit_pos ) );
734 :
735 773840 : return resQBits;
736 : }
|
