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 : #define IVAS_CONTEXT_MAPPING
332 : #ifdef IVAS_CONTEXT_MAPPING
333 :
334 : /*-------------------------------------------------------------------*
335 : * RCcontextMapping_decode2_no_mem_s17_LCS()
336 : *
337 : * Range decoder
338 : *-------------------------------------------------------------------*/
339 :
340 : /*! r: resQBits */
341 773840 : Word16 RCcontextMapping_decode2_no_mem_s17_LCS_fx(
342 : Decoder_State *st, /* i/o: decoder state */
343 : Word16 *x, /* o : decoded spectrum Q0*/
344 : const Word16 nt, /* i : size of spectrum */
345 : const Word16 nbbits, /* i : bit budget */
346 : const Word16 resQMaxBits, /* i : residual coding maximum bits */
347 : CONTEXT_HM_CONFIG *hm_cfg /* i : context-based harmonic model configuration*/
348 : )
349 : {
350 : RangeUniDecState rc_st_dec; /* State of the range decoder */
351 : Word16 start_bit_pos, lsbs_bit_pos;
352 : Word16 a, b, a1, b1, k;
353 : UWord16 t;
354 : Word16 lev, pki, esc_nb;
355 : Word16 rateFlag;
356 : Word16 lastnz, n;
357 : UWord16 r;
358 : Word16 resQBits;
359 : Word16 rest_bits;
360 : Word16 nt_half;
361 : Word16 nbbits_m2;
362 : Word16 bits_tups; /* No. of bits for coding the no. of tuples */
363 :
364 773840 : set16_fx( x, 0, nt );
365 :
366 : /*Decode number of ntuples*/
367 773840 : start_bit_pos = st->next_bit_pos;
368 773840 : move16();
369 773840 : lsbs_bit_pos = add( start_bit_pos, sub( nbbits, 1 ) );
370 773840 : n = 0;
371 773840 : move16();
372 773840 : k = 1;
373 773840 : move16();
374 773840 : nt_half = shr( nt, 1 );
375 7652086 : WHILE( k < nt_half )
376 : {
377 6878246 : n = add( n, 1 );
378 6878246 : k = shl( k, 1 );
379 : }
380 :
381 773840 : bits_tups = n;
382 773840 : move16();
383 773840 : n = add( get_next_indice_fx( st, n ), 1 );
384 :
385 773840 : t = 0;
386 773840 : move16();
387 773840 : lastnz = shl( n, 1 );
388 :
389 773840 : IF( GT_16( lastnz, nt ) )
390 : {
391 0 : st->BER_detect = 1;
392 0 : move16();
393 0 : return 0;
394 : }
395 :
396 773840 : IF( hm_cfg )
397 : {
398 : Word16 a1_i, b1_i;
399 : Word16 c[2], *ctx;
400 : Word16 p1, p2;
401 : Word16 ii[2];
402 : Word16 idx1, idx2, idx;
403 : Word16 numPeakIndicesOrig, numHoleIndices;
404 :
405 : /* Rate flag */
406 11959 : IF( GT_16( nbbits, 400 ) )
407 : {
408 5776 : rateFlag = 2 << NBITS_CONTEXT;
409 5776 : move16();
410 : }
411 : ELSE
412 : {
413 6183 : rateFlag = 0;
414 6183 : move16();
415 : }
416 :
417 : /* Init */
418 11959 : c[0] = c[1] = 0;
419 11959 : move16();
420 11959 : move16();
421 : /* mapped domain */
422 11959 : numPeakIndicesOrig = hm_cfg->numPeakIndices;
423 11959 : move16();
424 11959 : hm_cfg->numPeakIndices = s_min( hm_cfg->numPeakIndices, lastnz );
425 11959 : move16();
426 11959 : numHoleIndices = sub( lastnz, hm_cfg->numPeakIndices );
427 :
428 : /* Mark hole indices beyond lastnz as pruned */
429 5144729 : FOR( k = numHoleIndices; k < hm_cfg->numHoleIndices; ++k )
430 : {
431 5132770 : hm_cfg->holeIndices[k] = add( hm_cfg->holeIndices[k], nt );
432 5132770 : move16();
433 : }
434 :
435 11959 : ii[0] = numPeakIndicesOrig;
436 11959 : move16();
437 11959 : ii[1] = 0;
438 11959 : move16();
439 11959 : p1 = p2 = 0; /* to avoid compilation warnings */
440 11959 : move16();
441 11959 : move16();
442 : /* Start Decoding */
443 : /* Initialize range decoder */
444 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 */
445 :
446 11959 : nbbits_m2 = nbbits;
447 11959 : move16();
448 11959 : rest_bits = negate( nbbits_m2 );
449 :
450 : /* Main Loop through the 2-tuples */
451 2249141 : FOR( k = 0; k < lastnz; k += 2 )
452 : {
453 2237182 : a1_i = get_next_coeff_mapped( ii, &p1, &idx1, hm_cfg );
454 2237182 : b1_i = get_next_coeff_mapped( ii, &p2, &idx2, hm_cfg );
455 2237182 : idx = s_min( idx1, idx2 );
456 :
457 : /* Get context */
458 2237182 : ctx = &c[s_or( p1, p2 )];
459 2237182 : t = add( *ctx, rateFlag );
460 2237182 : IF( LT_16( nt_half, idx ) )
461 : {
462 270556 : t = add( t, ( 1 << NBITS_CONTEXT ) );
463 : }
464 :
465 2237182 : esc_nb = 0;
466 2237182 : move16();
467 2237182 : r = 0;
468 2237182 : move16();
469 2237182 : test();
470 : /* BER detection: Check max value of context t leading to out-of-bound access to ari_lookup_s17_LC[]*/
471 2237182 : IF( ( GE_16( t, ( 1 << ( NBITS_CONTEXT + NBITS_RATEQ ) ) ) ) || ( lsbs_bit_pos <= 0 ) )
472 : {
473 0 : st->BER_detect = 1;
474 0 : move16();
475 0 : return 0;
476 : }
477 :
478 2237182 : a = b = 0;
479 2237182 : move16();
480 2237182 : move16();
481 : /* MSBs decoding */
482 2539486 : FOR( lev = 0; lev < 15 && lsbs_bit_pos > 0; ++lev )
483 : {
484 2539486 : esc_nb = s_min( lev, 3 );
485 2539486 : pki = ari_lookup_s17_LC[t + Tab_esc_nb[esc_nb]];
486 2539486 : move16();
487 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) */
488 : /* r is the symbol read, the possible values are {0,1,....alphabet_size - 1} */
489 :
490 2539486 : IF( LT_16( r, VAL_ESC ) ) /* If symbol read corresponds to MSB */
491 : {
492 2237182 : BREAK;
493 : }
494 :
495 : /* LSBs decoding */
496 302304 : a = add( a, shl( get_indice_1_fx( st, lsbs_bit_pos-- ), lev ) );
497 302304 : b = add( b, shl( get_indice_1_fx( st, lsbs_bit_pos-- ), lev ) );
498 : }
499 2237182 : test();
500 2237182 : test();
501 2237182 : IF( ( LT_16( lsbs_bit_pos, -1 ) && GE_16( r, VAL_ESC ) ) || GT_16( lev, 14 ) )
502 : {
503 0 : x[a1_i] = 0;
504 0 : move16();
505 0 : x[b1_i] = 0;
506 0 : move16();
507 0 : st->BER_detect = 1;
508 0 : move16();
509 0 : return 0;
510 : }
511 :
512 : /* MSBs contributions */
513 2237182 : b1 = shr( r, 2 );
514 2237182 : a1 = s_and( r, 0x3 );
515 2237182 : a = add( a, shl( a1, lev ) );
516 2237182 : b = add( b, shl( b1, lev ) );
517 :
518 : /* Add 2 LSB bits per bit-plane */
519 2237182 : rest_bits = add( rest_bits, shl( lev, 1 ) );
520 : /* Sign bits */
521 2237182 : rest_bits = add( rest_bits, s_min( a, 1 ) );
522 2237182 : rest_bits = add( rest_bits, s_min( b, 1 ) );
523 :
524 : /* Update bitstream pointer */
525 2237182 : st->next_bit_pos = add( start_bit_pos, add( bits_tups, rc_uni_dec_virtual_finish_fx( &rc_st_dec ) ) );
526 2237182 : move16();
527 :
528 : /* Confirm that there is no overflow */
529 : #ifdef DEBUGGING
530 : assert( st->next_bit_pos - start_bit_pos + rest_bits <= 0 );
531 : #endif
532 :
533 : /* Store decoded data */
534 2237182 : x[a1_i] = a;
535 2237182 : move16();
536 2237182 : x[b1_i] = b;
537 2237182 : move16();
538 : /* Update context for next 2-tuple */
539 2237182 : IF( EQ_32( p1, p2 ) )
540 : {
541 : /* peak-peak or hole-hole context */
542 2031403 : lev = sub( esc_nb, 1 );
543 :
544 2031403 : IF( lev <= 0 )
545 : {
546 1974235 : t = add( 1, imult1616( add( a1, b1 ), add( lev, 2 ) ) );
547 : }
548 : ELSE
549 : {
550 57168 : t = add( 13, lev );
551 : }
552 :
553 2031403 : *ctx = add( shl( s_and( *ctx, 0xf ), 4 ), t );
554 2031403 : move16();
555 : }
556 : ELSE
557 : {
558 : /* mixed context */
559 :
560 205779 : IF( s_and( idx1, 1 ) )
561 : {
562 : /* update first context */
563 97838 : c[p1] = update_mixed_context( c[p1], a );
564 97838 : move16();
565 : }
566 :
567 205779 : IF( s_and( idx2, 1 ) )
568 : {
569 : /* update second context */
570 107941 : c[p2] = update_mixed_context( c[p2], b );
571 107941 : move16();
572 : }
573 : }
574 : }
575 :
576 : /* We don't need to finish because virtual_finish() already does the same */
577 : /*st->next_bit_pos = rc_uni_dec_finish(&rc_st_dec);*/
578 :
579 : /* Check for bitstream errors */
580 11959 : assert( rc_st_dec.bit_error_detected == 0 );
581 :
582 : /* Cross-check: No overflow */
583 : #ifdef DEBUGGING
584 : assert( k == lastnz );
585 : #endif
586 :
587 : /* Decode signs */
588 11959 : n = nt;
589 11959 : move16();
590 : }
591 : ELSE /* if(!hm_cfg) */
592 : {
593 : Word16 c, rateQ;
594 : UWord16 s;
595 :
596 : /* Rate flag */
597 761881 : IF( GT_16( nbbits, 400 ) )
598 : {
599 557633 : rateFlag = 2;
600 557633 : move16();
601 : }
602 : ELSE
603 : {
604 204248 : rateFlag = 0;
605 204248 : move16();
606 : }
607 :
608 : /* Start Decoding */
609 : /* Initialize range decoder */
610 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 */
611 :
612 761881 : nbbits_m2 = nbbits;
613 761881 : move16();
614 761881 : rest_bits = negate( nbbits_m2 );
615 :
616 761881 : t = 0;
617 761881 : move16();
618 761881 : s = 0;
619 761881 : move16();
620 : /* Main Loop through the 2-tuples */
621 164788266 : FOR( k = 0; k < lastnz; k += 2 )
622 : {
623 164026385 : rateQ = add( rateFlag, (Word16) GT_16( k, ( nt_half ) ) );
624 164026385 : test();
625 : /* BER detection: Check max value of context t leading to out-of-bound access to ari_lookup_s17_LC[]*/
626 164026385 : IF( ( GE_16( t, ( 1 << ( NBITS_CONTEXT ) ) ) ) || ( lsbs_bit_pos <= 0 ) )
627 : {
628 0 : st->BER_detect = 1;
629 0 : move16();
630 0 : return 0;
631 : }
632 :
633 164026385 : a = b = 0;
634 164026385 : move16();
635 164026385 : move16();
636 164026385 : esc_nb = 0;
637 164026385 : move16();
638 164026385 : r = 0;
639 164026385 : move16();
640 : /* MSBs decoding */
641 194156732 : FOR( lev = 0; lev < 15 && lsbs_bit_pos > 0; ++lev )
642 : {
643 194156732 : esc_nb = s_min( lev, 3 );
644 194156732 : pki = ari_lookup_s17_LC[t + ( ( rateQ << NBITS_CONTEXT ) + Tab_esc_nb[esc_nb] )];
645 194156732 : move16();
646 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) */
647 : /* r is the symbol read, the possible values are {0,1,....alphabet_size - 1} */
648 :
649 194156732 : IF( LT_16( r, VAL_ESC ) ) /* If symbol read corresponds to MSB */
650 : {
651 164026385 : BREAK;
652 : }
653 :
654 : /* LSBs decoding */
655 30130347 : a = add( a, shl( get_indice_1_fx( st, lsbs_bit_pos-- ), lev ) );
656 30130347 : b = add( b, shl( get_indice_1_fx( st, lsbs_bit_pos-- ), lev ) );
657 : }
658 164026385 : test();
659 164026385 : test();
660 164026385 : IF( ( LT_16( lsbs_bit_pos, -1 ) && GE_16( r, VAL_ESC ) ) || GT_16( lev, 14 ) )
661 : {
662 0 : x[k + 0] = 0;
663 0 : move16();
664 0 : x[k + 1] = 0;
665 0 : move16();
666 0 : st->BER_detect = 1;
667 0 : move16();
668 0 : return 0;
669 : }
670 :
671 : /* MSBs contributions */
672 164026385 : b1 = shr( r, 2 );
673 164026385 : a1 = s_and( r, 0x3 );
674 164026385 : a = add( a, shl( a1, lev ) );
675 164026385 : b = add( b, shl( b1, lev ) );
676 :
677 : /* Add 2 LSB bits per bit-plane */
678 164026385 : rest_bits = add( rest_bits, shl( lev, 1 ) );
679 : /* Sign bits */
680 164026385 : rest_bits = add( rest_bits, s_min( a, 1 ) );
681 164026385 : rest_bits = add( rest_bits, s_min( b, 1 ) );
682 :
683 : /* Update bitstream pointer */
684 164026385 : st->next_bit_pos = add( start_bit_pos, add( bits_tups, rc_uni_dec_virtual_finish_fx( &rc_st_dec ) ) );
685 164026385 : move16();
686 :
687 : /* Confirm that there is no overflow */
688 : #ifdef DEBUGGING
689 : assert( st->next_bit_pos - start_bit_pos + rest_bits <= 0 );
690 : #endif
691 :
692 : /* Store decoded data */
693 164026385 : x[k + 0] = a;
694 164026385 : move16();
695 164026385 : x[k + 1] = b;
696 164026385 : move16();
697 : /* Update context for next 2-tuple */
698 164026385 : IF( LT_16( esc_nb, 2 ) )
699 : {
700 156569002 : c = add( 1, imult1616( add( a1, b1 ), add( esc_nb, 1 ) ) );
701 : }
702 : ELSE
703 : {
704 7457383 : c = add( 12, esc_nb );
705 : }
706 :
707 164026385 : s = (UWord16) L_shl( s, 4 ); /*Shift old 4 bits*/
708 164026385 : s = (UWord16) L_add( s, c ); /*replace last 4 bits*/
709 164026385 : t = (UWord16) L_and( s, 0xFF );
710 : }
711 :
712 : /* Decode signs */
713 761881 : n = lastnz;
714 761881 : move16();
715 : } /* end of if(hm_cfg) */
716 :
717 338450930 : FOR( k = 0; k < n; k++ )
718 : {
719 337677090 : IF( x[k] > 0 )
720 : {
721 135505349 : x[k] = imult1616( x[k], sub( 1, shl( get_next_indice_1_fx( st ), 1 ) ) );
722 135505349 : move16();
723 : }
724 : }
725 :
726 : /* Decode Residual Q */
727 773840 : resQBits = s_min( resQMaxBits, sub( add( lsbs_bit_pos, 1 ), st->next_bit_pos ) );
728 :
729 4282970 : FOR( k = 0; k < resQBits; ++k )
730 : {
731 3509130 : x[nt + k] = get_indice_1_fx( st, sub( lsbs_bit_pos, k ) );
732 3509130 : move16();
733 : }
734 :
735 : /* Set bitstream pointer to end of buffer */
736 773840 : get_next_indice_tmp_fx( st, sub( add( start_bit_pos, nbbits ), st->next_bit_pos ) );
737 :
738 773840 : return resQBits;
739 : }
740 :
741 : #endif
742 : #undef IVAS_CONTEXT_MAPPING
|
