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 646 : 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 646 : Word16 tmp = 0; /* initialize just to avoid compiler warning */
42 646 : 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 646 : r = 0; /* to avoid compilation warnings */
53 646 : move16();
54 646 : esc_nb = 0; /* to avoid compilation warnings */
55 646 : move16();
56 :
57 646 : set16_fx( x, 0, nt );
58 :
59 : /* Rate flag */
60 646 : rateFlag = 0;
61 646 : move16();
62 646 : if ( GT_16( nbbits, 400 ) )
63 : {
64 38 : rateFlag = 2 << NBITS_CONTEXT;
65 38 : move16();
66 : }
67 :
68 : /*Decode number of ntuples*/
69 646 : start_bit_pos = st->next_bit_pos;
70 646 : move16();
71 646 : lsbs_bit_pos = add( start_bit_pos, sub( nbbits, 1 ) );
72 :
73 646 : n = 0;
74 646 : move16();
75 :
76 646 : L = sub( 14, norm_s( negate( nt ) ) );
77 646 : n = add( get_next_indice_fx( st, L ), 1 );
78 :
79 : /* Init */
80 646 : nt_half = shr( nt, 1 );
81 646 : c[0] = c[1] = 0;
82 646 : move16();
83 646 : move16();
84 :
85 646 : t = 0;
86 646 : move16();
87 :
88 646 : lastnz = shl( n, 1 );
89 646 : test();
90 646 : 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 646 : 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 24275 : FOR( k = numHoleIndices; k < hm_cfg->numHoleIndices; ++k )
107 : {
108 24220 : hm_cfg->holeIndices[k] = add( hm_cfg->holeIndices[k], nt );
109 24220 : 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 591 : ii[0] = 0;
125 591 : move16();
126 :
127 591 : p1 = p2 = 0;
128 591 : move16();
129 591 : move16();
130 :
131 591 : get_next_coeff = get_next_coeff_unmapped;
132 : }
133 :
134 : /* Start Decoding */
135 646 : ari_start_decoding_14bits_fx( st, &as );
136 :
137 646 : overflow_bit_pos = st->next_bit_pos;
138 646 : move16();
139 646 : nbbits_m2 = add( nbbits, cbitsnew - 2 );
140 646 : rest_bits_overflow = rest_bits = negate( nbbits_m2 );
141 646 : move16();
142 :
143 : /*Main Loop through the 2-tuples*/
144 66868 : FOR( k = 0; k < lastnz; k += 2 )
145 : {
146 : /* First coefficient */
147 66222 : a1_i = get_next_coeff( ii, &p1, &idx1, hm_cfg );
148 :
149 : /* Second coefficient */
150 66222 : b1_i = get_next_coeff( ii, &p2, &idx2, hm_cfg );
151 :
152 66222 : idx = s_min( idx1, idx2 );
153 :
154 : /* Get context */
155 66222 : ctx = &c[s_or( p1, p2 )];
156 :
157 66222 : t = add( *ctx, rateFlag );
158 66222 : IF( GT_16( idx, nt_half ) )
159 : {
160 81 : t = add( t, 1 << NBITS_CONTEXT );
161 : }
162 :
163 66222 : test();
164 : /* BER detection: Check max value of context t leading to out-of-bound access to ari_lookup_s17_LC[]*/
165 66222 : 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 66222 : La = L_deposit_l( 0 );
173 66222 : Lb = L_deposit_l( 0 );
174 : /* MSBs decoding */
175 :
176 70071 : FOR( lev = 0; lev < 15 && lsbs_bit_pos > 0; lev++ )
177 : {
178 :
179 70071 : esc_nb = s_min( lev, 3 );
180 70071 : tmp = add( t, Tab_esc_nb[esc_nb] );
181 70071 : assert( tmp >= 0 && tmp < 4096 );
182 70071 : pki = ari_lookup_s17_LC[tmp];
183 70071 : move16();
184 70071 : r = ari_decode_14bits_s17_ext_fx( st, &as, ari_pk_s17_LC_ext[pki] );
185 :
186 70071 : IF( LT_16( r, VAL_ESC ) )
187 : {
188 66222 : BREAK;
189 : }
190 :
191 : /*LSBs decoding*/
192 3849 : La = L_mac0( La, pow2tab[lev], get_indice_1_fx( st, lsbs_bit_pos-- ) );
193 3849 : Lb = L_mac0( Lb, pow2tab[lev], get_indice_1_fx( st, lsbs_bit_pos-- ) );
194 : }
195 :
196 66222 : test();
197 66222 : test();
198 66222 : 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 66222 : b1 = shr( r, 2 );
211 66222 : a1 = s_and( r, 0x3 );
212 66222 : a = extract_l( L_mac0( La, pow2tab[lev], a1 ) );
213 66222 : b = extract_l( L_mac0( Lb, pow2tab[lev], b1 ) );
214 :
215 : /*lsbs bits sign bits*/
216 66222 : rest_bits = add( rest_bits, shl( lev, 1 ) );
217 :
218 66222 : if ( a > 0 )
219 : {
220 17223 : rest_bits = add( rest_bits, 1 );
221 : }
222 66222 : if ( b > 0 )
223 : {
224 16940 : rest_bits = add( rest_bits, 1 );
225 : }
226 :
227 : /*Dectect overflow*/
228 66222 : 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 66222 : overflow_bit_pos = st->next_bit_pos;
242 66222 : move16();
243 66222 : rest_bits_overflow = rest_bits;
244 66222 : move16();
245 :
246 : /* Store decoded data */
247 66222 : x[a1_i] = a;
248 66222 : move16();
249 66222 : x[b1_i] = b;
250 66222 : move16();
251 :
252 : /* Update context for next 2-tuple */
253 66222 : IF( EQ_32( p1, p2 ) ) /* peak-peak or hole-hole context */
254 : {
255 65966 : lev = sub( esc_nb, 1 );
256 65966 : IF( lev > 0 )
257 891 : t = add( 12, lev );
258 65966 : IF( lev <= 0 )
259 65075 : t = add( a1, b1 );
260 65966 : IF( lev == 0 )
261 1740 : t = add( t, t );
262 :
263 65966 : *ctx = add( shl( s_and( *ctx, 0xf ), 4 ), add( t, 1 ) );
264 65966 : move16();
265 : }
266 : ELSE /* mixed context */
267 : {
268 256 : IF( s_and( idx1, 1 ) ) /* update first context */
269 : {
270 125 : c[p1] = update_mixed_context( c[p1], a );
271 125 : move16();
272 : }
273 :
274 256 : IF( s_and( idx2, 1 ) ) /* update second context */
275 : {
276 131 : c[p2] = update_mixed_context( c[p2], b );
277 131 : move16();
278 : }
279 : }
280 : }
281 :
282 : /* Total number of decoded AC bits */
283 646 : get_next_indice_tmp_fx( st, -( cbitsnew - 2 ) );
284 :
285 : /*detect overflow*/
286 646 : 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 646 : if ( hm_cfg )
295 : {
296 55 : tmp = nt;
297 55 : move16();
298 : }
299 646 : if ( !hm_cfg )
300 : {
301 591 : tmp = lastnz;
302 591 : move16();
303 : }
304 157310 : FOR( k = 0; k < tmp; k++ )
305 : {
306 156664 : IF( x[k] > 0 )
307 : {
308 34163 : IF( get_next_indice_1_fx( st ) != 0 )
309 : {
310 17119 : x[k] = negate( x[k] );
311 17119 : move16();
312 : }
313 : }
314 : }
315 :
316 : /*Decode Residual Q*/
317 646 : resQBits = s_min( resQMaxBits, sub( add( lsbs_bit_pos, 1 ), st->next_bit_pos ) );
318 7496 : FOR( k = 0; k < resQBits; ++k )
319 : {
320 6850 : x[nt + k] = get_indice_1_fx( st, sub( lsbs_bit_pos, k ) );
321 6850 : move16();
322 : }
323 :
324 : /* Set bitstream pointer to end of buffer */
325 646 : get_next_indice_tmp_fx( st, sub( add( start_bit_pos, nbbits ), st->next_bit_pos ) );
326 :
327 :
328 646 : return resQBits;
329 : }
330 :
331 : /*-------------------------------------------------------------------*
332 : * RCcontextMapping_decode2_no_mem_s17_LCS()
333 : *
334 : * Range decoder
335 : *-------------------------------------------------------------------*/
336 :
337 : /*! r: resQBits */
338 827705 : 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 827705 : set16_fx( x, 0, nt );
362 :
363 : /*Decode number of ntuples*/
364 827705 : start_bit_pos = st->next_bit_pos;
365 827705 : move16();
366 827705 : lsbs_bit_pos = add( start_bit_pos, sub( nbbits, 1 ) );
367 827705 : n = 0;
368 827705 : move16();
369 827705 : k = 1;
370 827705 : move16();
371 827705 : nt_half = shr( nt, 1 );
372 8180985 : WHILE( k < nt_half )
373 : {
374 7353280 : n = add( n, 1 );
375 7353280 : k = shl( k, 1 );
376 : }
377 :
378 827705 : bits_tups = n;
379 827705 : move16();
380 827705 : n = add( get_next_indice_fx( st, n ), 1 );
381 :
382 827705 : t = 0;
383 827705 : move16();
384 827705 : lastnz = shl( n, 1 );
385 :
386 827705 : IF( GT_16( lastnz, nt ) )
387 : {
388 0 : st->BER_detect = 1;
389 0 : move16();
390 0 : return 0;
391 : }
392 :
393 827705 : 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 12064 : IF( GT_16( nbbits, 400 ) )
404 : {
405 5812 : rateFlag = 2 << NBITS_CONTEXT;
406 5812 : move16();
407 : }
408 : ELSE
409 : {
410 6252 : rateFlag = 0;
411 6252 : move16();
412 : }
413 :
414 : /* Init */
415 12064 : c[0] = c[1] = 0;
416 12064 : move16();
417 12064 : move16();
418 : /* mapped domain */
419 12064 : numPeakIndicesOrig = hm_cfg->numPeakIndices;
420 12064 : move16();
421 12064 : hm_cfg->numPeakIndices = s_min( hm_cfg->numPeakIndices, lastnz );
422 12064 : move16();
423 12064 : numHoleIndices = sub( lastnz, hm_cfg->numPeakIndices );
424 :
425 : /* Mark hole indices beyond lastnz as pruned */
426 5181458 : FOR( k = numHoleIndices; k < hm_cfg->numHoleIndices; ++k )
427 : {
428 5169394 : hm_cfg->holeIndices[k] = add( hm_cfg->holeIndices[k], nt );
429 5169394 : move16();
430 : }
431 :
432 12064 : ii[0] = numPeakIndicesOrig;
433 12064 : move16();
434 12064 : ii[1] = 0;
435 12064 : move16();
436 12064 : p1 = p2 = 0; /* to avoid compilation warnings */
437 12064 : move16();
438 12064 : move16();
439 : /* Start Decoding */
440 : /* Initialize range decoder */
441 12064 : 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 12064 : nbbits_m2 = nbbits;
444 12064 : move16();
445 12064 : rest_bits = negate( nbbits_m2 );
446 :
447 : /* Main Loop through the 2-tuples */
448 2264374 : FOR( k = 0; k < lastnz; k += 2 )
449 : {
450 2252310 : a1_i = get_next_coeff_mapped( ii, &p1, &idx1, hm_cfg );
451 2252310 : b1_i = get_next_coeff_mapped( ii, &p2, &idx2, hm_cfg );
452 2252310 : idx = s_min( idx1, idx2 );
453 :
454 : /* Get context */
455 2252310 : ctx = &c[s_or( p1, p2 )];
456 2252310 : t = add( *ctx, rateFlag );
457 2252310 : IF( LT_16( nt_half, idx ) )
458 : {
459 272184 : t = add( t, ( 1 << NBITS_CONTEXT ) );
460 : }
461 :
462 2252310 : esc_nb = 0;
463 2252310 : move16();
464 2252310 : r = 0;
465 2252310 : move16();
466 2252310 : test();
467 : /* BER detection: Check max value of context t leading to out-of-bound access to ari_lookup_s17_LC[]*/
468 2252310 : 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 2252310 : a = b = 0;
476 2252310 : move16();
477 2252310 : move16();
478 : /* MSBs decoding */
479 2555619 : FOR( lev = 0; lev < 15 && lsbs_bit_pos > 0; ++lev )
480 : {
481 2555619 : esc_nb = s_min( lev, 3 );
482 2555619 : pki = ari_lookup_s17_LC[t + Tab_esc_nb[esc_nb]];
483 2555619 : move16();
484 2555619 : 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 2555619 : IF( LT_16( r, VAL_ESC ) ) /* If symbol read corresponds to MSB */
488 : {
489 2252310 : BREAK;
490 : }
491 :
492 : /* LSBs decoding */
493 303309 : a = add( a, shl( get_indice_1_fx( st, lsbs_bit_pos-- ), lev ) );
494 303309 : b = add( b, shl( get_indice_1_fx( st, lsbs_bit_pos-- ), lev ) );
495 : }
496 2252310 : test();
497 2252310 : test();
498 2252310 : 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 2252310 : b1 = shr( r, 2 );
511 2252310 : a1 = s_and( r, 0x3 );
512 2252310 : a = add( a, shl( a1, lev ) );
513 2252310 : b = add( b, shl( b1, lev ) );
514 :
515 : /* Add 2 LSB bits per bit-plane */
516 2252310 : rest_bits = add( rest_bits, shl( lev, 1 ) );
517 : /* Sign bits */
518 2252310 : rest_bits = add( rest_bits, s_min( a, 1 ) );
519 2252310 : rest_bits = add( rest_bits, s_min( b, 1 ) );
520 :
521 : /* Update bitstream pointer */
522 2252310 : st->next_bit_pos = add( start_bit_pos, add( bits_tups, rc_uni_dec_virtual_finish_fx( &rc_st_dec ) ) );
523 2252310 : 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 2252310 : x[a1_i] = a;
532 2252310 : move16();
533 2252310 : x[b1_i] = b;
534 2252310 : move16();
535 : /* Update context for next 2-tuple */
536 2252310 : IF( EQ_32( p1, p2 ) )
537 : {
538 : /* peak-peak or hole-hole context */
539 2044969 : lev = sub( esc_nb, 1 );
540 :
541 2044969 : IF( lev <= 0 )
542 : {
543 1987630 : t = add( 1, imult1616( add( a1, b1 ), add( lev, 2 ) ) );
544 : }
545 : ELSE
546 : {
547 57339 : t = add( 13, lev );
548 : }
549 :
550 2044969 : *ctx = add( shl( s_and( *ctx, 0xf ), 4 ), t );
551 2044969 : move16();
552 : }
553 : ELSE
554 : {
555 : /* mixed context */
556 :
557 207341 : IF( s_and( idx1, 1 ) )
558 : {
559 : /* update first context */
560 98638 : c[p1] = update_mixed_context( c[p1], a );
561 98638 : move16();
562 : }
563 :
564 207341 : IF( s_and( idx2, 1 ) )
565 : {
566 : /* update second context */
567 108703 : c[p2] = update_mixed_context( c[p2], b );
568 108703 : 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 12064 : 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 12064 : n = nt;
586 12064 : move16();
587 : }
588 : ELSE /* if(!hm_cfg) */
589 : {
590 : Word16 c, rateQ;
591 : UWord16 s;
592 :
593 : /* Rate flag */
594 815641 : IF( GT_16( nbbits, 400 ) )
595 : {
596 584992 : rateFlag = 2;
597 584992 : move16();
598 : }
599 : ELSE
600 : {
601 230649 : rateFlag = 0;
602 230649 : move16();
603 : }
604 :
605 : /* Start Decoding */
606 : /* Initialize range decoder */
607 815641 : 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 815641 : nbbits_m2 = nbbits;
610 815641 : move16();
611 815641 : rest_bits = negate( nbbits_m2 );
612 :
613 815641 : t = 0;
614 815641 : move16();
615 815641 : s = 0;
616 815641 : move16();
617 : /* Main Loop through the 2-tuples */
618 174675642 : FOR( k = 0; k < lastnz; k += 2 )
619 : {
620 173860001 : rateQ = add( rateFlag, (Word16) GT_16( k, ( nt_half ) ) );
621 173860001 : test();
622 : /* BER detection: Check max value of context t leading to out-of-bound access to ari_lookup_s17_LC[]*/
623 173860001 : 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 173860001 : a = b = 0;
631 173860001 : move16();
632 173860001 : move16();
633 173860001 : esc_nb = 0;
634 173860001 : move16();
635 173860001 : r = 0;
636 173860001 : move16();
637 : /* MSBs decoding */
638 205508652 : FOR( lev = 0; lev < 15 && lsbs_bit_pos > 0; ++lev )
639 : {
640 205508652 : esc_nb = s_min( lev, 3 );
641 205508652 : pki = ari_lookup_s17_LC[t + ( ( rateQ << NBITS_CONTEXT ) + Tab_esc_nb[esc_nb] )];
642 205508652 : move16();
643 205508652 : 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 205508652 : IF( LT_16( r, VAL_ESC ) ) /* If symbol read corresponds to MSB */
647 : {
648 173860001 : BREAK;
649 : }
650 :
651 : /* LSBs decoding */
652 31648651 : a = add( a, shl( get_indice_1_fx( st, lsbs_bit_pos-- ), lev ) );
653 31648651 : b = add( b, shl( get_indice_1_fx( st, lsbs_bit_pos-- ), lev ) );
654 : }
655 173860001 : test();
656 173860001 : test();
657 173860001 : 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 173860001 : b1 = shr( r, 2 );
670 173860001 : a1 = s_and( r, 0x3 );
671 173860001 : a = add( a, shl( a1, lev ) );
672 173860001 : b = add( b, shl( b1, lev ) );
673 :
674 : /* Add 2 LSB bits per bit-plane */
675 173860001 : rest_bits = add( rest_bits, shl( lev, 1 ) );
676 : /* Sign bits */
677 173860001 : rest_bits = add( rest_bits, s_min( a, 1 ) );
678 173860001 : rest_bits = add( rest_bits, s_min( b, 1 ) );
679 :
680 : /* Update bitstream pointer */
681 173860001 : st->next_bit_pos = add( start_bit_pos, add( bits_tups, rc_uni_dec_virtual_finish_fx( &rc_st_dec ) ) );
682 173860001 : 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 173860001 : x[k + 0] = a;
691 173860001 : move16();
692 173860001 : x[k + 1] = b;
693 173860001 : move16();
694 : /* Update context for next 2-tuple */
695 173860001 : IF( LT_16( esc_nb, 2 ) )
696 : {
697 166047066 : c = add( 1, imult1616( add( a1, b1 ), add( esc_nb, 1 ) ) );
698 : }
699 : ELSE
700 : {
701 7812935 : c = add( 12, esc_nb );
702 : }
703 :
704 173860001 : s = (UWord16) L_shl( s, 4 ); /*Shift old 4 bits*/
705 173860001 : s = (UWord16) L_add( s, c ); /*replace last 4 bits*/
706 173860001 : t = (UWord16) L_and( s, 0xFF );
707 : }
708 :
709 : /* Decode signs */
710 815641 : n = lastnz;
711 815641 : move16();
712 : } /* end of if(hm_cfg) */
713 :
714 358238907 : FOR( k = 0; k < n; k++ )
715 : {
716 357411202 : IF( x[k] > 0 )
717 : {
718 142487403 : x[k] = imult1616( x[k], sub( 1, shl( get_next_indice_1_fx( st ), 1 ) ) );
719 142487403 : move16();
720 : }
721 : }
722 :
723 : /* Decode Residual Q */
724 827705 : resQBits = s_min( resQMaxBits, sub( add( lsbs_bit_pos, 1 ), st->next_bit_pos ) );
725 :
726 4467014 : FOR( k = 0; k < resQBits; ++k )
727 : {
728 3639309 : x[nt + k] = get_indice_1_fx( st, sub( lsbs_bit_pos, k ) );
729 3639309 : move16();
730 : }
731 :
732 : /* Set bitstream pointer to end of buffer */
733 827705 : get_next_indice_tmp_fx( st, sub( add( start_bit_pos, nbbits ), st->next_bit_pos ) );
734 :
735 827705 : return resQBits;
736 : }
|
