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 "basop_util.h"
9 : #include "cnst.h"
10 : #include "prot_fx.h"
11 : #include "ivas_prot_fx.h"
12 : #include "rom_com.h"
13 : #include "ivas_rom_com.h"
14 : #include "ivas_rom_enc.h"
15 : #include "prot_fx_enc.h"
16 :
17 : #define MAKE_NUMBER_QX( number, QX ) ( ( number ) << ( QX ) ) /* evaulated at compile time */
18 : #define MAKE_VARIABLE_QX( variable, QX ) W_shl( W_deposit32_l( L_deposit_l( ( variable ) ) ), ( QX ) ) /* evaluated at run time */
19 :
20 : /*-------------------------------------------------------------------*
21 : * ACcontextMapping_encode2_no_mem_s17_LC_fx()
22 : *
23 : * Arithmetic encoder
24 : *-------------------------------------------------------------------*/
25 : /**
26 : * \brief Arithmetic encoder
27 : * \param[i] x
28 : * \param[o] ntuples amount of encoded tuple (2 lines per tuple)
29 : * \param[i] nt
30 : * \param[i] nbbits
31 : * \param[i] resQMaxBits
32 : * \return none
33 : */
34 662 : void ACcontextMapping_encode2_no_mem_s17_LC_fx(
35 : BSTR_ENC_HANDLE hBstr, /* i/o: bitstream handle */
36 : Word16 *x, /* Q0 */
37 : Word16 nt, /* Q0 */
38 : Word16 lastnz, /* Q0 */
39 : Word16 nbbits, /* Q0 */
40 : Word16 resQMaxBits, /* Q0 */
41 : CONTEXT_HM_CONFIG *hm_cfg )
42 : {
43 : Word16 ptr[BITBUFSIZE];
44 : TastatEnc as, as_overflow;
45 : Word16 bp, bp_overflow;
46 : Word16 a1, b1, a1_i, b1_i, k;
47 : Word16 t, pki, lev1;
48 : Word16 rateFlag;
49 : Word16 value;
50 : Word16 nbbits_ntuples, nbbits_lsbs, nbbits_signs, nbbits_signs_overflow, nbbits_lsbs_overflow, flag_overflow;
51 : Word16 *lsbs_bits2;
52 : Word16 tmp;
53 : Word16 nt_half;
54 : Word16 c[2], *ctx;
55 : Word16 p1, p2;
56 : Word16 ii[2], idx1, idx2, idx;
57 : Word16 numPeakIndicesOrig, numHoleIndices;
58 : get_next_coeff_function get_next_coeff;
59 : Word16 signs[N_MAX];
60 : Word16 nbbits_m2;
61 :
62 662 : a1 = 0; /* to avoid compilation warnings */
63 662 : b1 = 0; /* to avoid compilation warnings */
64 662 : move16();
65 662 : move16();
66 :
67 : /* Rate flag */
68 662 : rateFlag = 0;
69 662 : move16();
70 662 : if ( GT_16( nbbits, 400 ) )
71 : {
72 45 : rateFlag = 2 << NBITS_CONTEXT;
73 45 : move16();
74 : }
75 :
76 : /* Init */
77 662 : nt_half = shr( nt, 1 );
78 662 : c[0] = c[1] = 0;
79 662 : move16();
80 662 : move16();
81 :
82 : /* Bits for encoding the number of encoded tuples */
83 662 : nbbits_ntuples = sub( 14, norm_s( negate( nt ) ) ); /* Q0 */
84 :
85 662 : t = 0;
86 662 : move16();
87 662 : bp = nbbits_ntuples; /* Q0 */
88 662 : move16();
89 662 : nbbits_signs = 0;
90 662 : move16();
91 662 : nbbits_lsbs = 0;
92 662 : move16();
93 662 : nbbits_m2 = sub( nbbits, 2 ); /* Q0 */
94 662 : flag_overflow = 0;
95 662 : move16();
96 :
97 662 : IF( hm_cfg ) /* mapped domain */
98 : {
99 55 : numPeakIndicesOrig = hm_cfg->numPeakIndices; /* Q0 */
100 55 : move16();
101 55 : hm_cfg->numPeakIndices = s_min( hm_cfg->numPeakIndices, lastnz ); /* Q0 */
102 55 : move16();
103 55 : numHoleIndices = sub( lastnz, hm_cfg->numPeakIndices ); /* Q0 */
104 :
105 : /* Mark hole indices beyond lastnz as pruned */
106 23851 : FOR( k = numHoleIndices; k < hm_cfg->numHoleIndices; ++k )
107 : {
108 23796 : hm_cfg->holeIndices[k] = add( hm_cfg->holeIndices[k], nt ); /* Q0 */
109 23796 : move16();
110 : }
111 :
112 55 : ii[0] = numPeakIndicesOrig; /* Q0 */
113 55 : move16();
114 55 : ii[1] = 0;
115 55 : move16();
116 :
117 55 : get_next_coeff = get_next_coeff_mapped; /* Q0 */
118 55 : move16();
119 : }
120 : ELSE /* unmapped domain */
121 : {
122 607 : ii[0] = 0;
123 607 : move16();
124 :
125 607 : p1 = p2 = 0;
126 607 : move16();
127 607 : move16();
128 :
129 607 : get_next_coeff = get_next_coeff_unmapped; /* Q0 */
130 607 : move16();
131 :
132 : /* Find last non-zero tuple */
133 : /* ensure termination of while loop by dummy value */
134 607 : a1 = x[0];
135 607 : move16();
136 607 : x[0] = 1;
137 607 : move16();
138 :
139 2506 : WHILE( s_or( x[lastnz - 1], x[lastnz - 2] ) == 0 )
140 : {
141 1899 : lastnz = sub( lastnz, 2 ); /* Q0 */
142 : }
143 607 : x[0] = a1;
144 607 : move16();
145 : }
146 :
147 662 : lsbs_bits2 = ptr + nbbits - 1;
148 :
149 : /*Start Encoding*/
150 662 : ari_start_encoding_14bits_fx( &as );
151 :
152 : /*Main Loop through the 2-tuples*/
153 662 : b1_i = -1;
154 662 : move16();
155 69423 : FOR( k = 0; k < lastnz; k += 2 )
156 : {
157 : /* First coefficient */
158 68761 : a1_i = get_next_coeff( ii, &p1, &idx1, hm_cfg ); /* Q0 */
159 :
160 : /* Second coefficient */
161 68761 : b1_i = get_next_coeff( ii, &p2, &idx2, hm_cfg ); /* Q0 */
162 :
163 68761 : idx = s_min( idx1, idx2 ); /* Q0 */
164 :
165 : /* Get context */
166 68761 : ctx = &c[s_or( p1, p2 )]; /* Q0 */
167 : /* _DIFF_FLOAT_FIX_ float is using t as UWord16 */
168 68761 : t = add( *ctx, rateFlag ); /* Q0 */
169 68761 : if ( GT_16( idx, nt_half ) )
170 : {
171 225 : t = add( t, 1 << NBITS_CONTEXT ); /* Q0 */
172 : }
173 :
174 : /* Init current 2-tuple encoding */
175 68761 : if ( flag_overflow != 0 )
176 : {
177 0 : x[a1_i] = 0;
178 0 : move16();
179 : }
180 68761 : if ( flag_overflow != 0 )
181 : {
182 0 : x[b1_i] = 0;
183 0 : move16();
184 : }
185 :
186 68761 : a1 = abs_s( x[a1_i] ); /* Q0 */
187 68761 : b1 = abs_s( x[b1_i] ); /* Q0 */
188 :
189 68761 : lev1 = -1;
190 68761 : move16();
191 :
192 : /*Copy states*/
193 68761 : ari_copy_states_fx( &as, &as_overflow );
194 68761 : bp_overflow = bp; /* Q0 */
195 68761 : move16();
196 68761 : nbbits_signs_overflow = nbbits_signs; /* Q0 */
197 68761 : move16();
198 68761 : nbbits_lsbs_overflow = nbbits_lsbs; /* Q0 */
199 68761 : move16();
200 :
201 : /*Signs encoding*/
202 68761 : signs[nbbits_signs] = lshr( x[a1_i], 15 ); /* Q0 */
203 68761 : move16();
204 68761 : if ( a1 > 0 )
205 : {
206 18205 : nbbits_signs = add( nbbits_signs, 1 ); /* Q0 */
207 : }
208 68761 : signs[nbbits_signs] = lshr( x[b1_i], 15 ); /* Q0 */
209 68761 : move16();
210 68761 : if ( b1 > 0 )
211 : {
212 17937 : nbbits_signs = add( nbbits_signs, 1 ); /* Q0 */
213 : }
214 :
215 : /* MSBs coding */
216 72801 : WHILE( GE_16( s_max( a1, b1 ), A_THRES ) )
217 : {
218 4040 : tmp = add( t, Tab_esc_nb[lev1 + 1] ); /* Q0 */
219 4040 : assert( tmp >= 0 && tmp < 4096 );
220 4040 : pki = ari_lookup_s17_LC[tmp]; /* Q0 */
221 4040 : move16();
222 4040 : bp = ari_encode_14bits_ext_fx( ptr, bp, &as, VAL_ESC, ari_pk_s17_LC_ext[pki] ); /* Q0 */
223 :
224 4040 : *lsbs_bits2-- = s_and( a1, 1 );
225 4040 : move16();
226 4040 : *lsbs_bits2-- = s_and( b1, 1 );
227 4040 : move16();
228 :
229 : /* LSBs bit counting */
230 4040 : nbbits_lsbs = add( nbbits_lsbs, 2 ); /* Q0 */
231 :
232 4040 : a1 = shr( a1, 1 );
233 4040 : b1 = shr( b1, 1 );
234 :
235 4040 : lev1 = s_min( add( lev1, 1 ), 2 ); /* Q0 */
236 : }
237 :
238 68761 : tmp = add( t, Tab_esc_nb[lev1 + 1] ); /* Q0 */
239 68761 : assert( tmp >= 0 && tmp < 4096 );
240 68761 : pki = ari_lookup_s17_LC[tmp]; /* Q0 */
241 68761 : move16();
242 68761 : bp = ari_encode_14bits_ext_fx( ptr, bp, &as, add( a1, shl( b1, A_THRES_SHIFT ) ), ari_pk_s17_LC_ext[pki] ); /* Q0 */
243 :
244 : /* Check bit budget */
245 68761 : IF( GT_16( add( add( add( bp, extract_l( as.value ) ), nbbits_signs ), nbbits_lsbs ), nbbits_m2 ) )
246 : {
247 0 : ari_copy_states_fx( &as_overflow, &as );
248 0 : bp = bp_overflow; /* Q0 */
249 0 : move16();
250 :
251 0 : IF( flag_overflow == 0 )
252 : {
253 0 : nbbits_signs = nbbits_signs_overflow; /* Q0 */
254 0 : move16();
255 0 : nbbits_lsbs = nbbits_lsbs_overflow; /* Q0 */
256 0 : move16();
257 0 : IF( hm_cfg )
258 : {
259 0 : flag_overflow = 1;
260 0 : move16();
261 :
262 : /* Code from now only zeros */
263 0 : x[a1_i] = 0;
264 0 : move16();
265 0 : x[b1_i] = 0;
266 0 : move16();
267 0 : lev1 = -1;
268 0 : move16();
269 :
270 0 : assert( t >= 0 && t < 4096 );
271 0 : pki = ari_lookup_s17_LC[t]; /* Q0 */
272 0 : move16();
273 0 : bp = ari_encode_14bits_ext_fx( ptr, bp, &as, 0, ari_pk_s17_LC_ext[pki] ); /* Q0 */
274 :
275 0 : IF( GT_16( add( add( add( bp, extract_l( as.value ) ), nbbits_signs ), nbbits_lsbs ), nbbits_m2 ) )
276 : {
277 0 : ari_copy_states_fx( &as_overflow, &as );
278 0 : bp = bp_overflow; /* Q0 */
279 0 : move16();
280 0 : BREAK;
281 : }
282 : }
283 : ELSE
284 : {
285 0 : BREAK;
286 : }
287 : }
288 : ELSE
289 : {
290 0 : BREAK;
291 : }
292 : }
293 :
294 : /* Update context for next 2-tuple */
295 68761 : IF( EQ_16( p1, p2 ) ) /* peak-peak or hole-hole context */
296 : {
297 68486 : if ( lev1 > 0 )
298 935 : t = add( 12, lev1 );
299 68486 : if ( lev1 <= 0 )
300 67551 : t = add( a1, b1 );
301 68486 : if ( lev1 == 0 )
302 1823 : t = add( t, t );
303 :
304 68486 : *ctx = add( shl( s_and( *ctx, 0xf ), 4 ), add( t, 1 ) ); /* Q0 */
305 68486 : move16();
306 : }
307 : ELSE /* mixed context */
308 : {
309 275 : IF( s_and( idx1, 1 ) ) /* update first context */
310 : {
311 134 : c[p1] = update_mixed_context( c[p1], abs_s( x[a1_i] ) ); /* Q0 */
312 134 : move16();
313 : }
314 :
315 275 : IF( s_and( idx2, 1 ) ) /* update second context */
316 : {
317 141 : c[p2] = update_mixed_context( c[p2], abs_s( x[b1_i] ) ); /* Q0 */
318 141 : move16();
319 : }
320 : }
321 : } /*end of the 2-tuples loop*/
322 :
323 : /* End arithmetic coder, overflow management */
324 662 : bp = ari_done_encoding_14bits_fx( ptr, bp, &as ); /* Q0 */
325 :
326 : /* Overflow is detected */
327 662 : IF( NE_16( k, lastnz ) )
328 : {
329 0 : IF( hm_cfg )
330 : {
331 : /* Fill with zero to be sure that the decoder finishes the MSB decoding at the same position */
332 0 : tmp = sub( nbbits, add( nbbits_signs, nbbits_lsbs ) ); /* Q0 */
333 0 : set16_fx( &ptr[bp], 0, sub( tmp, bp ) );
334 0 : bp = tmp;
335 0 : move16();
336 : }
337 0 : if ( !hm_cfg )
338 : {
339 0 : lastnz = k; /* Q0 */
340 0 : move16();
341 : }
342 : }
343 :
344 : /* Push number of encoded tuples */
345 662 : value = sub( shr( lastnz, 1 ), 1 ); /* Q0 */
346 662 : push_next_indice( hBstr, value, nbbits_ntuples );
347 :
348 : /* Push arithmetic coded bits */
349 662 : push_next_bits( hBstr, (UWord16 *) &ptr[nbbits_ntuples], sub( bp, nbbits_ntuples ) );
350 :
351 : /* Push sign bits */
352 662 : push_next_bits( hBstr, (UWord16 *) signs, nbbits_signs );
353 662 : bp = add( bp, nbbits_signs ); /* Q0 */
354 :
355 : /*write residual Quantization bits*/
356 662 : tmp = s_min( sub( sub( nbbits, bp ), nbbits_lsbs ), resQMaxBits ); /* Q0 */
357 7303 : FOR( k = 0; k < tmp; k++ )
358 : {
359 6641 : ptr[nbbits - 1 - nbbits_lsbs - k] = x[nt + k]; /* Q0 */
360 6641 : move16();
361 : }
362 : /* Write filler bits */
363 662 : tmp = sub( nbbits, add( bp, nbbits_lsbs ) ); /* Q0 */
364 1921 : FOR( ; k < tmp; ++k )
365 : {
366 1259 : ptr[nbbits - 1 - nbbits_lsbs - k] = 0;
367 1259 : move16();
368 : }
369 : /* fprintf(stderr, "Budget: %d Fill bits: %d ResQ Bits: %d\n",(int) (nbbits),(int) (nbbits-bp-nbbits_lsbs),(int)i);*/
370 :
371 : /* Check for debugging */
372 662 : assert( bp + k <= nbbits );
373 :
374 : /* Push the rest of the buffer */
375 662 : push_next_bits( hBstr, (UWord16 *) &ptr[bp], sub( nbbits, bp ) );
376 :
377 662 : return /*(bp+nbbits_lsbs)*/; /*return only for debug plot*/
378 : }
379 : /*-------------------------------------------------------------------*
380 : * find_last_nz_pair()
381 : *
382 : *
383 : *-------------------------------------------------------------------*/
384 4556 : static Word16 find_last_nz_pair(
385 : const Word16 x[], /* Q0 */
386 : Word16 length,
387 : const CONTEXT_HM_CONFIG *hm_cfg )
388 : {
389 : Word16 last_nz, i, stage, lobs[4];
390 4556 : const Word16 *tmp = NULL;
391 :
392 4556 : if ( hm_cfg )
393 : {
394 1405 : tmp = hm_cfg->indexBuffer; /* Q0 */
395 1405 : move16();
396 : }
397 :
398 4556 : lobs[0] = 4;
399 4556 : move16();
400 4556 : lobs[1] = shr( length, 1 ); /* length/2 */
401 4556 : move16();
402 4556 : lobs[2] = add( lobs[1], shr( length, 2 ) ); /* Q0 */
403 4556 : move16();
404 4556 : lobs[3] = add( lobs[2], shr( length, 3 ) ); /* Q0 */
405 4556 : move16();
406 :
407 4556 : last_nz = 0;
408 4556 : move16();
409 4556 : i = length;
410 4556 : move16();
411 17404 : FOR( stage = 3; stage >= 0; --stage )
412 : {
413 17399 : IF( hm_cfg ) /* mapped kernel */
414 : {
415 328187 : FOR( ; i >= lobs[stage]; i -= 2 )
416 : {
417 323363 : if ( x[tmp[i - 2]] != 0 )
418 : {
419 16662 : last_nz = s_max( last_nz, i ); /* Q0 */
420 : }
421 323363 : if ( x[tmp[i - 1]] != 0 )
422 : {
423 16416 : last_nz = s_max( last_nz, i ); /* Q0 */
424 : }
425 : }
426 : }
427 : ELSE /* unmapped kernel */
428 : {
429 1028952 : FOR( ; i >= lobs[stage]; i -= 2 )
430 : {
431 1016377 : if ( x[i - 2] != 0 )
432 : {
433 84098 : last_nz = s_max( last_nz, i ); /* Q0 */
434 : }
435 1016377 : if ( x[i - 1] != 0 )
436 : {
437 82662 : last_nz = s_max( last_nz, i ); /* Q0 */
438 : }
439 : }
440 : }
441 17399 : IF( last_nz > 0 )
442 : {
443 4551 : BREAK;
444 : }
445 : }
446 :
447 4556 : return s_max( last_nz, 2 );
448 : }
449 : /*-------------------------------------------------------------------*
450 : * ACcontextMapping_encode2_estimate_no_mem_s17_LC_fx()
451 : *
452 : *
453 : *-------------------------------------------------------------------*/
454 4556 : Word16 ACcontextMapping_encode2_estimate_no_mem_s17_LC_fx(
455 : const Word16 *x, /* Q0 */
456 : Word16 nt, /* Q0 */
457 : Word16 *lastnz_out, /* Q0 */
458 : Word16 *nEncoded, /* Q0 */
459 : Word16 target, /* Q0 */
460 : Word16 *stop, /* Q0 */
461 : CONTEXT_HM_CONFIG *hm_cfg )
462 : {
463 : Word16 a1, b1, a1_i, b1_i;
464 : Word16 k, t, pki, lev1;
465 : Word16 lastnz, lastnz2;
466 : Word16 rateFlag;
467 : Word16 nbits_old, nbits;
468 : Word16 stop2;
469 : Word16 cum_freq_norm, cum_freq_norm_e;
470 : Word32 proba;
471 : Word16 nlz;
472 : const UWord16 *cum_freq;
473 : Word16 symbol;
474 : const Word8 *lookup;
475 : Word16 nt_half;
476 : Word16 c[2], *ctx;
477 : Word16 p1, p2;
478 : Word16 ii[2], idx1, idx2, idx;
479 4556 : Word16 numPeakIndicesOrig = 0, numHoleIndices = 0; /* initialize just to avoid compiler warning */
480 4556 : move16();
481 4556 : move16();
482 : get_next_coeff_function get_next_coeff;
483 :
484 :
485 : /* Rate flag */
486 4556 : rateFlag = 0;
487 4556 : move16();
488 4556 : if ( GT_16( target, 400 ) )
489 : {
490 226 : rateFlag = 2 << NBITS_CONTEXT; /* Q0 */
491 226 : move16();
492 : }
493 :
494 : /* proba coded on 14bits -> proba=1 */
495 4556 : proba = L_deposit_l( 16384 ); /* Q0 */
496 :
497 : /* Init */
498 4556 : nt_half = shr( nt, 1 );
499 4556 : stop2 = 0;
500 4556 : move16();
501 4556 : c[0] = c[1] = 0;
502 4556 : move16();
503 4556 : move16();
504 :
505 : /* bits to encode lastnz + 2 bits headroom */
506 4556 : nbits = sub( 2 + 14, norm_s( sub( nt, 1 ) ) ); /* Q0 */
507 4556 : nbits_old = nbits; /* Q0 */
508 4556 : move16();
509 4556 : nbits = sub( nbits, target ); /* Q0 */
510 :
511 : /* Find last non-zero tuple in the mapped domain signal */
512 4556 : lastnz = find_last_nz_pair( x, nt, hm_cfg ); /* Q0 */
513 :
514 : /* At least one tuple is coded */
515 4556 : lastnz2 = 2;
516 4556 : move16();
517 :
518 4556 : IF( hm_cfg ) /* mapped domain */
519 : {
520 1405 : numPeakIndicesOrig = hm_cfg->numPeakIndices; /* Q0 */
521 1405 : move16();
522 1405 : hm_cfg->numPeakIndices = s_min( hm_cfg->numPeakIndices, lastnz ); /* Q0 */
523 1405 : move16();
524 1405 : numHoleIndices = sub( lastnz, hm_cfg->numPeakIndices ); /* Q0 */
525 :
526 : /* Mark hole indices beyond lastnz as pruned */
527 442385 : FOR( k = numHoleIndices; k < hm_cfg->numHoleIndices; ++k )
528 : {
529 440980 : hm_cfg->holeIndices[k] = add( hm_cfg->holeIndices[k], nt ); /* Q0 */
530 440980 : move16();
531 : }
532 :
533 1405 : ii[0] = numPeakIndicesOrig; /* Q0 */
534 1405 : move16();
535 1405 : ii[1] = 0;
536 1405 : move16();
537 :
538 1405 : get_next_coeff = get_next_coeff_mapped; /* Q0 */
539 1405 : move16();
540 : }
541 : ELSE /* unmapped domain */
542 : {
543 3151 : ii[0] = 0;
544 3151 : move16();
545 :
546 3151 : p1 = p2 = 0;
547 3151 : move16();
548 3151 : move16();
549 :
550 3151 : get_next_coeff = get_next_coeff_unmapped; /* Q0 */
551 3151 : move16();
552 : }
553 :
554 : /* Main Loop through the 2-tuples */
555 518369 : FOR( k = 0; k < lastnz; k += 2 )
556 : {
557 : /* First coefficient */
558 514372 : a1_i = get_next_coeff( ii, &p1, &idx1, hm_cfg ); /* Q0 */
559 :
560 : /* Second coefficient */
561 514372 : b1_i = get_next_coeff( ii, &p2, &idx2, hm_cfg ); /* Q0 */
562 :
563 514372 : idx = s_min( idx1, idx2 ); /* Q0 */
564 :
565 : /* Get context */
566 514372 : ctx = &c[s_or( p1, p2 )]; /* Q0 */
567 :
568 514372 : t = add( *ctx, rateFlag ); /* Q0 */
569 514372 : if ( GT_16( idx, nt_half ) )
570 : {
571 20324 : t = add( t, 1 << NBITS_CONTEXT ); /* Q0 */
572 : }
573 :
574 : /* Init current 2-tuple encoding */
575 514372 : a1 = abs_s( x[a1_i] ); /* Q0 */
576 514372 : b1 = abs_s( x[b1_i] ); /* Q0 */
577 :
578 514372 : lev1 = -( 1 << ( NBITS_CONTEXT + NBITS_RATEQ ) );
579 514372 : move16();
580 : /* Signs Bits */
581 514372 : if ( a1 > 0 )
582 : {
583 122462 : nbits = add( nbits, 1 ); /* Q0 */
584 : }
585 :
586 514372 : if ( b1 > 0 )
587 : {
588 121014 : nbits = add( nbits, 1 ); /* Q0 */
589 : }
590 :
591 : /* pre-compute address of ari_pk_s17_LC_ext[0][Val_esc] to avoid doing it multiple times inside the loop */
592 :
593 : /* check while condition */
594 :
595 : /* MSBs coding */
596 514372 : lookup = (const Word8 *) ( &ari_lookup_s17_LC[t] + ( 1 << ( NBITS_CONTEXT + NBITS_RATEQ ) ) ); /* address calculation not counted */
597 542161 : WHILE( GE_16( s_max( a1, b1 ), A_THRES ) )
598 : {
599 27789 : pki = lookup[lev1];
600 27789 : move16();
601 27789 : cum_freq = ari_pk_s17_LC_ext[pki] + VAL_ESC; /* address calculation not counted */
602 : /*p1*p2=proba on 28 bits: p=0.5->power(2,27)*/
603 :
604 27789 : cum_freq_norm_e = norm_s( cum_freq[0] );
605 27789 : cum_freq_norm = shl( cum_freq[0], cum_freq_norm_e );
606 27789 : proba = Mpy_32_16_1( proba, cum_freq_norm );
607 27789 : proba = L_shl( proba, sub( 14, cum_freq_norm_e ) ); /* Q14 + cum_freq_norm_e */
608 :
609 : /*Number of leading zero computed in one cycle=norm_l() in BASOP*/
610 27789 : nlz = sub( norm_l( proba ), 2 );
611 27789 : proba = L_shl( proba, sub( nlz, 15 ) ); /* cum_freq_norm_e */
612 :
613 27789 : nbits = add( nbits, nlz ); /* Q0 */
614 : /*addition added as shift not done in norm_l(): real shift = 14-nlz*/
615 : /*proba is rounded down on 14 bits ->automatic over-estimation of bit consumption*/
616 :
617 27789 : a1 = shr( a1, 1 );
618 27789 : b1 = shr( b1, 1 );
619 27789 : lev1 = s_min( add( lev1, 1 << ( NBITS_CONTEXT + NBITS_RATEQ ) ), 2 << ( NBITS_CONTEXT + NBITS_RATEQ ) ); /* Q0 */
620 : }
621 :
622 514372 : pki = lookup[lev1]; /* Q0 */
623 514372 : move16();
624 514372 : symbol = add( a1, shl( b1, A_THRES_SHIFT ) ); /* Q0 */
625 514372 : cum_freq = ari_pk_s17_LC_ext[pki] + symbol; /* address calculation not counted */
626 : /*p1*p2=proba on 28 bits: p=0.5->power(2,27)*/
627 :
628 514372 : cum_freq_norm = sub( cum_freq[0], cum_freq[1] );
629 514372 : cum_freq_norm_e = norm_s( cum_freq_norm );
630 514372 : cum_freq_norm = shl( cum_freq_norm, cum_freq_norm_e );
631 514372 : proba = Mpy_32_16_1( proba, cum_freq_norm );
632 514372 : proba = L_shl( proba, sub( 15, cum_freq_norm_e ) ); /* Q15 + cum_freq_norm_e */
633 :
634 : /*Number of leading zero computed in one cycle=norm_l() in BASOP*/
635 514372 : nlz = sub( norm_l( proba ), 3 );
636 514372 : proba = L_shl( proba, sub( nlz, 14 ) ); /* cum_freq_norm_e */
637 :
638 514372 : nbits = add( nbits, nlz ); /* Q0 */
639 : /*addition added as shift not done in norm_l(): real shift = 14-nlz*/
640 : /*proba is rounded down on 14 bits ->automatic over-estimation of bit consumption*/
641 :
642 : /* Should we truncate? */
643 :
644 514372 : IF( nbits > 0 )
645 : {
646 50755 : stop2 = 1;
647 50755 : move16();
648 :
649 50755 : IF( *stop )
650 : {
651 559 : BREAK;
652 : }
653 : }
654 : ELSE
655 : {
656 463617 : test();
657 463617 : test();
658 463617 : IF( hm_cfg || k == 0 || s_or( x[a1_i], x[b1_i] ) )
659 : {
660 282810 : nbits_old = add( nbits, target ); /* Q0 */
661 282810 : lastnz2 = add( b1_i, 1 ); /* Q0 */
662 : }
663 : }
664 :
665 : /* Update context for next 2-tuple */
666 513813 : IF( EQ_16( p1, p2 ) ) /* peak-peak or hole-hole context */
667 : {
668 487407 : lev1 = shr( lev1, NBITS_CONTEXT + NBITS_RATEQ ); /* Q0 */
669 487407 : if ( lev1 > 0 )
670 6213 : t = add( 12, lev1 );
671 487407 : if ( lev1 <= 0 )
672 481194 : t = add( a1, b1 );
673 487407 : if ( lev1 == 0 )
674 11908 : t = add( t, t );
675 :
676 487407 : *ctx = add( shl( s_and( *ctx, 0xf ), 4 ), add( t, 1 ) ); /* Q0 */
677 487407 : move16();
678 : }
679 : ELSE /* mixed context */
680 : {
681 26406 : IF( s_and( idx1, 1 ) ) /* update first context */
682 : {
683 13093 : c[p1] = update_mixed_context( c[p1], abs_s( x[a1_i] ) ); /* Q0 */
684 13093 : move16();
685 : }
686 :
687 26406 : IF( s_and( idx2, 1 ) ) /* update second context */
688 : {
689 13223 : c[p2] = update_mixed_context( c[p2], abs_s( x[b1_i] ) ); /* Q0 */
690 13223 : move16();
691 : }
692 : }
693 : } /* end of the 2-tuples loop */
694 :
695 4556 : nbits = add( nbits, target ); /* Q0 */
696 :
697 : /* Output */
698 4556 : if ( *stop )
699 : {
700 623 : nbits = nbits_old; /* Q0 */
701 623 : move16();
702 : }
703 :
704 4556 : if ( stop2 )
705 : {
706 2485 : stop2 = nbits; /* Q0 */
707 2485 : move16();
708 : }
709 4556 : *nEncoded = lastnz2; /* Q0 */
710 4556 : move16();
711 4556 : *stop = stop2; /* Q0 */
712 4556 : move16();
713 4556 : if ( lastnz_out )
714 : {
715 4556 : *lastnz_out = lastnz; /* Q0 */
716 4556 : move16();
717 : }
718 :
719 4556 : IF( hm_cfg )
720 : {
721 : /* Restore hole indices beyond lastnz */
722 442385 : FOR( k = numHoleIndices; k < hm_cfg->numHoleIndices; ++k )
723 : {
724 440980 : hm_cfg->holeIndices[k] = sub( hm_cfg->holeIndices[k], nt ); /* Q0 */
725 440980 : move16();
726 : }
727 1405 : hm_cfg->numPeakIndices = numPeakIndicesOrig; /* Q0 */
728 1405 : move16();
729 : }
730 :
731 :
732 4556 : return nbits_old;
733 : }
734 :
735 : /* Range Coder Functions */
736 :
737 : /*-------------------------------------------------------------------*
738 : * RCcontextMapping_encode2_no_mem_s17_LCS()
739 : *
740 : * Range encoder
741 : *-------------------------------------------------------------------*/
742 :
743 843946 : void RCcontextMapping_encode2_no_mem_s17_LCS_fx(
744 : BSTR_ENC_HANDLE hBstr, /* i/o: bitstream handle */
745 : Word16 *x, /* Q0 */
746 : const Word16 nt, /* Q0 */
747 : Word16 lastnz, /* Q0 */
748 : const Word16 nbbits, /* Q0 */
749 : const Word16 resQMaxBits, /* Q0 */
750 : CONTEXT_HM_CONFIG *hm_cfg )
751 : {
752 : Word16 ptr[BITBUFSIZE];
753 : RangeUniEncState rc_st_enc;
754 : Word16 bp;
755 : Word16 rc_tot_bits; /* No. of bits returned by range coder */
756 : Word16 pki, lev1;
757 : UWord16 t;
758 : Word16 rateFlag;
759 : Word16 value;
760 : Word16 nbbits_ntuples, nbbits_lsbs, nbbits_signs;
761 : Word16 *lsbs_bits;
762 : Word16 nt_half;
763 : Word16 signs[N_MAX];
764 : Word16 a1, b1, k;
765 :
766 843946 : a1 = 0; /* to avoid compilation warnings */
767 843946 : b1 = 0; /* to avoid compilation warnings */
768 843946 : move16();
769 843946 : move16();
770 :
771 : /* Init */
772 843946 : nt_half = shr( nt, 1 );
773 :
774 : /* Bits for encoding the number of encoded tuples */
775 843946 : nbbits_ntuples = 0;
776 843946 : k = 1;
777 843946 : move16();
778 843946 : move16();
779 :
780 8347234 : WHILE( LT_16( k, shr( nt, 1 ) ) )
781 : {
782 7503288 : nbbits_ntuples = add( nbbits_ntuples, 1 ); /* Q0 */
783 7503288 : k = shl( k, 1 );
784 : }
785 :
786 843946 : t = 0;
787 843946 : nbbits_signs = 0;
788 843946 : nbbits_lsbs = 0;
789 843946 : move16();
790 843946 : move16();
791 843946 : move16();
792 :
793 843946 : IF( hm_cfg )
794 : {
795 : Word16 a1_i, b1_i;
796 : Word32 c[2], *ctx;
797 : Word32 p1, p2;
798 : Word16 ii[2];
799 : Word16 idx1, idx2, idx;
800 : Word16 numPeakIndicesOrig, numHoleIndices;
801 :
802 : /* Rate flag */
803 12616 : IF( GT_16( nbbits, 400 ) )
804 : {
805 5974 : rateFlag = 2 << NBITS_CONTEXT;
806 5974 : move16();
807 : }
808 : ELSE
809 : {
810 6642 : rateFlag = 0;
811 6642 : move16();
812 : }
813 :
814 12616 : c[0] = c[1] = 0;
815 12616 : move32();
816 12616 : move32();
817 :
818 : /* mapped domain */
819 12616 : numPeakIndicesOrig = hm_cfg->numPeakIndices; /* Q0 */
820 12616 : hm_cfg->numPeakIndices = s_min( hm_cfg->numPeakIndices, lastnz ); /* Q0 */
821 12616 : numHoleIndices = sub( lastnz, hm_cfg->numPeakIndices ); /* Q0 */
822 12616 : move16();
823 12616 : move16();
824 :
825 : /* Mark hole indices beyond lastnz as pruned */
826 5498221 : FOR( k = numHoleIndices; k < hm_cfg->numHoleIndices; ++k )
827 : {
828 5485605 : hm_cfg->holeIndices[k] = add( hm_cfg->holeIndices[k], nt ); /* Q0 */
829 5485605 : move16();
830 : }
831 :
832 12616 : ii[0] = numPeakIndicesOrig; /* Q0 */
833 12616 : ii[1] = 0;
834 12616 : move16();
835 12616 : move16();
836 :
837 12616 : p1 = p2 = 0; /* to avoid compilation warnings */
838 12616 : move16();
839 12616 : move16();
840 :
841 12616 : lsbs_bits = ptr + sub( nbbits, 1 );
842 :
843 : /*Start Encoding*/
844 : /* Initialize range encoder */
845 12616 : rc_uni_enc_init_fx( &rc_st_enc );
846 :
847 : /*Main Loop through the 2-tuples*/
848 12616 : b1_i = -1;
849 12616 : move16();
850 :
851 2313290 : FOR( k = 0; k < lastnz; k += 2 )
852 : {
853 2300674 : a1_i = get_next_coeff_mapped_ivas_fx( ii, &p1, &idx1, hm_cfg ); /* Q0 */
854 2300674 : b1_i = get_next_coeff_mapped_ivas_fx( ii, &p2, &idx2, hm_cfg ); /* Q0 */
855 :
856 2300674 : idx = s_min( idx1, idx2 ); /* Q0 */
857 :
858 : /* Get context */
859 2300674 : ctx = &c[L_or( p1, p2 )]; /* Q0 */
860 :
861 2300674 : t = (UWord16) L_add( *ctx, rateFlag ); /* Q0 */
862 : // t += ( nt_half >= idx ) ? 0 : ( 1 << NBITS_CONTEXT );
863 2300674 : IF( LT_16( nt_half, idx ) )
864 : {
865 271359 : t = add( t, ( 1 << NBITS_CONTEXT ) );
866 : }
867 :
868 : /* Init current 2-tuple encoding */
869 2300674 : a1 = abs_s( x[a1_i] ); /* Q0 */
870 2300674 : b1 = abs_s( x[b1_i] ); /* Q0 */
871 :
872 2300674 : lev1 = -1;
873 2300674 : move16();
874 :
875 : /*Signs encoding*/
876 2300674 : IF( a1 > 0 )
877 : {
878 : // signs[nbbits_signs++] = ( (uint16_t) x[a1_i] >> ( sizeof( uint16_t ) * 8 - 1 ) );
879 606101 : if ( x[a1_i] >= 0 )
880 : {
881 305118 : signs[nbbits_signs] = 0;
882 305118 : move16();
883 : }
884 606101 : if ( x[a1_i] < 0 )
885 : {
886 300983 : signs[nbbits_signs] = 1;
887 300983 : move16();
888 : }
889 606101 : nbbits_signs = add( nbbits_signs, 1 ); /* Q0 */
890 : }
891 :
892 2300674 : IF( b1 > 0 )
893 : {
894 : // signs[nbbits_signs++] = ( (uint16_t) x[b1_i] >> ( sizeof( uint16_t ) * 8 - 1 ) );
895 600928 : if ( x[b1_i] >= 0 )
896 : {
897 299672 : signs[nbbits_signs] = 0;
898 299672 : move16();
899 : }
900 600928 : if ( x[b1_i] < 0 )
901 : {
902 301256 : signs[nbbits_signs] = 1;
903 301256 : move16();
904 : }
905 600928 : nbbits_signs = add( nbbits_signs, 1 ); /* Q0 */
906 : }
907 :
908 : /* MSBs coding */
909 2604913 : WHILE( GE_16( s_max( a1, b1 ), A_THRES ) )
910 : {
911 304239 : pki = ari_lookup_s17_LC[t + ( ( lev1 + 1 ) << ( NBITS_CONTEXT + NBITS_RATEQ ) )]; /* Q0 */
912 304239 : move16();
913 304239 : rc_uni_enc_encode_symbol_fastS_fx( &rc_st_enc, VAL_ESC, cum_freq_ari_pk_s17_LC_ext[pki], sym_freq_ari_pk_s17_LC_ext[pki], 14 ); /* Encode ESC symbol */
914 :
915 304239 : *lsbs_bits-- = s_and( a1, 1 );
916 304239 : *lsbs_bits-- = s_and( b1, 1 );
917 304239 : move16();
918 304239 : move16();
919 :
920 : /* LSBs bit counting */
921 304239 : nbbits_lsbs = add( nbbits_lsbs, 2 ); /* Q0 */
922 :
923 304239 : a1 = shr( a1, 1 );
924 304239 : b1 = shr( b1, 1 );
925 :
926 304239 : lev1 = s_min( add( lev1, 1 ), 2 ); /* Q0 */
927 : }
928 :
929 2300674 : pki = ari_lookup_s17_LC[t + ( ( lev1 + 1 ) << ( NBITS_CONTEXT + NBITS_RATEQ ) )]; /* Q0 */
930 2300674 : move16();
931 2300674 : rc_uni_enc_encode_symbol_fastS_fx( &rc_st_enc, a1 + A_THRES * b1, cum_freq_ari_pk_s17_LC_ext[pki], sym_freq_ari_pk_s17_LC_ext[pki], 14 ); /* Encode MSB symbol */
932 :
933 : /*Confirm that there is no overflow, i.e. bit-budget has not exceeded */
934 :
935 : /* Update context for next 2-tuple */
936 2300674 : IF( EQ_32( p1, p2 ) )
937 : {
938 : /* peak-peak or hole-hole context */
939 :
940 2091994 : IF( lev1 <= 0 )
941 : {
942 2034498 : t = (UWord16) L_add( 1, L_mult0( add( a1, b1 ), add( lev1, 2 ) ) ); /* Q0 */
943 : }
944 : ELSE
945 : {
946 57496 : t = (UWord16) L_add( 13, lev1 ); /* Q0 */
947 : }
948 :
949 2091994 : *ctx = L_add( L_shl( L_and( *ctx, 0xf ), 4 ), t ); /* Q0 */
950 2091994 : move32();
951 : }
952 : ELSE
953 : {
954 : /* mixed context */
955 :
956 208680 : IF( s_and( idx1, 1 ) )
957 : {
958 : /* update first context */
959 99294 : c[p1] = update_mixed_context_ivas_fx( c[p1], abs_s( x[a1_i] ) ); /* Q0 */
960 99294 : move32();
961 : }
962 :
963 208680 : IF( s_and( idx2, 1 ) )
964 : {
965 : /* update second context */
966 109386 : c[p2] = update_mixed_context_ivas_fx( c[p2], abs_s( x[b1_i] ) ); /* Q0 */
967 109386 : move32();
968 : }
969 : }
970 :
971 : } /*end of the 2-tuples loop*/
972 : }
973 : ELSE /* if (!hm_cfg) */
974 : {
975 : Word16 cp;
976 : Word16 esc_nb, rateQ;
977 : UWord16 s;
978 :
979 : /* Rate flag */
980 831330 : IF( GT_16( nbbits, 400 ) )
981 : {
982 605220 : rateFlag = 2;
983 605220 : move16();
984 : }
985 : ELSE
986 : {
987 226110 : rateFlag = 0;
988 226110 : move16();
989 : }
990 :
991 831330 : s = 0;
992 831330 : move16();
993 :
994 : /* Find last non-zero tuple */
995 : /* ensure termination of while loop by dummy value */
996 831330 : a1 = x[0];
997 831330 : x[0] = 1; /* ensure first tuple is non-zero */
998 831330 : move16();
999 831330 : move16();
1000 :
1001 7062795 : WHILE( x[lastnz - 1] == 0 && x[lastnz - 2] == 0 )
1002 : {
1003 6231465 : test();
1004 6231465 : lastnz = sub( lastnz, 2 ); /* Q0 */
1005 : }
1006 831330 : x[0] = a1;
1007 831330 : move16();
1008 :
1009 831330 : lsbs_bits = ptr + sub( nbbits, 1 );
1010 :
1011 : /*Start Encoding*/
1012 : /* Initialize range encoder */
1013 831330 : rc_uni_enc_init_fx( &rc_st_enc );
1014 :
1015 : /*Main Loop through the 2-tuples*/
1016 179097293 : FOR( k = 0; k < lastnz; k += 2 )
1017 : {
1018 :
1019 : /* Init current 2-tuple encoding */
1020 178265963 : a1 = abs_s( x[k + 0] ); /* Q0 */
1021 178265963 : b1 = abs_s( x[k + 1] ); /* Q0 */
1022 :
1023 178265963 : lev1 = 0;
1024 178265963 : esc_nb = 0;
1025 178265963 : move16();
1026 178265963 : move16();
1027 :
1028 : /*Signs encoding*/
1029 178265963 : IF( a1 > 0 )
1030 : {
1031 : // signs[nbbits_signs++] = ( (uint16_t) x[k + 0] >> ( sizeof( uint16_t ) * 8 - 1 ) );
1032 73167238 : if ( x[k] >= 0 )
1033 : {
1034 36594092 : signs[nbbits_signs] = 0;
1035 36594092 : move16();
1036 : }
1037 73167238 : if ( x[k] < 0 )
1038 : {
1039 36573146 : signs[nbbits_signs] = 1;
1040 36573146 : move16();
1041 : }
1042 73167238 : nbbits_signs = add( nbbits_signs, 1 ); /* Q0 */
1043 : }
1044 :
1045 178265963 : IF( b1 > 0 )
1046 : {
1047 : // signs[nbbits_signs++] = ( (uint16_t) x[k + 1] >> ( sizeof( uint16_t ) * 8 - 1 ) );
1048 72968950 : if ( x[k + 1] >= 0 )
1049 : {
1050 36398478 : signs[nbbits_signs] = 0;
1051 36398478 : move16();
1052 : }
1053 72968950 : if ( x[k + 1] < 0 )
1054 : {
1055 36570472 : signs[nbbits_signs] = 1;
1056 36570472 : move16();
1057 : }
1058 72968950 : nbbits_signs = add( nbbits_signs, 1 ); /* Q0 */
1059 : }
1060 :
1061 178265963 : rateQ = add( rateFlag, extract_l( GT_16( k, shr( nt, 1 ) ) ) );
1062 :
1063 : /* MSBs coding */
1064 211582892 : WHILE( GE_16( s_max( a1, b1 ), A_THRES ) )
1065 : {
1066 33316929 : pki = ari_lookup_s17_LC[t + ( ( rateQ ) << NBITS_CONTEXT ) + ( esc_nb << ( NBITS_CONTEXT + NBITS_RATEQ ) )];
1067 33316929 : move16();
1068 33316929 : rc_uni_enc_encode_symbol_fastS_fx( &rc_st_enc, VAL_ESC, cum_freq_ari_pk_s17_LC_ext[pki], sym_freq_ari_pk_s17_LC_ext[pki], 14 ); /* Encode ESC symbol */
1069 :
1070 33316929 : *lsbs_bits-- = s_and( a1, 1 );
1071 33316929 : *lsbs_bits-- = s_and( b1, 1 );
1072 33316929 : move16();
1073 33316929 : move16();
1074 :
1075 : /* LSBs bit counting */
1076 33316929 : nbbits_lsbs = add( nbbits_lsbs, 2 ); /* Q0 */
1077 :
1078 33316929 : a1 = shr( a1, 1 );
1079 33316929 : b1 = shr( b1, 1 );
1080 :
1081 33316929 : lev1 = add( lev1, 1 ); /* Q0 */
1082 33316929 : esc_nb = s_min( lev1, 3 ); /* Q0 */
1083 : }
1084 :
1085 178265963 : move16();
1086 :
1087 178265963 : pki = ari_lookup_s17_LC[t + ( ( rateQ ) << NBITS_CONTEXT ) + ( esc_nb << ( NBITS_CONTEXT + NBITS_RATEQ ) )]; /* Q0 */
1088 178265963 : rc_uni_enc_encode_symbol_fastS_fx( &rc_st_enc, a1 + A_THRES * b1, cum_freq_ari_pk_s17_LC_ext[pki], sym_freq_ari_pk_s17_LC_ext[pki], 14 ); /* Encode MSB symbol */
1089 :
1090 : /*Confirm that there is no overflow, i.e. bit-budget has not exceeded */
1091 :
1092 : /* Update context for next 2-tuple */
1093 178265963 : IF( LT_16( esc_nb, 2 ) )
1094 : {
1095 170015012 : cp = add( 1, imult1616( add( a1, b1 ), add( esc_nb, 1 ) ) ); /* Q0 */
1096 : }
1097 : ELSE
1098 : {
1099 8250951 : cp = add( 12, esc_nb ); /* Q0 */
1100 : }
1101 :
1102 : /*Shift old 4 bits, replace last 4 bits*/
1103 178265963 : s = (UWord16) ( L_add( L_shl( s, 4 ), cp ) );
1104 178265963 : t = (UWord16) L_and( s, 0xFF );
1105 :
1106 : } /*end of the 2-tuples loop*/
1107 : }
1108 :
1109 : /* Finish range encoder */
1110 843946 : rc_tot_bits = rc_uni_enc_finish_fx( &rc_st_enc ); /* No. of bits consumed by range coder Q0*/
1111 843946 : bp = add( rc_tot_bits, nbbits_ntuples ); /* Update bitstream pointer Q0*/
1112 :
1113 : /* Cross-check that there is no overflow */
1114 :
1115 : /* Push number of encoded tuples */
1116 843946 : value = sub( shr( lastnz, 1 ), 1 ); /* Q0 */
1117 843946 : push_next_indice( hBstr, value, nbbits_ntuples );
1118 :
1119 : /* Push range coded bits from byte_buffer to bitstream */
1120 : /* 1) Push all complete bytes, one byte at a time */
1121 65568536 : FOR( k = 0; k < ( rc_tot_bits >> 3 ); k++ )
1122 : {
1123 64724590 : push_next_indice( hBstr, rc_st_enc.byte_buffer[k], 8 );
1124 : }
1125 : /* 2) Push remaining bits */
1126 843946 : IF( s_and( rc_tot_bits, 7 ) != 0 )
1127 : {
1128 738728 : push_next_indice( hBstr, shr( rc_st_enc.byte_buffer[k], sub( 8, s_and( rc_tot_bits, 7 ) ) ), s_and( rc_tot_bits, 7 ) );
1129 : }
1130 :
1131 : /* Push sign bits */
1132 843946 : push_next_bits( hBstr, (UWord16 *) signs, nbbits_signs );
1133 843946 : bp = add( bp, nbbits_signs ); /* Q0 */
1134 :
1135 : /*write residual Quantization bits*/
1136 :
1137 4580174 : FOR( k = 0; k < s_min( nbbits - bp - nbbits_lsbs, resQMaxBits ); k++ )
1138 : {
1139 3736228 : ptr[nbbits - 1 - nbbits_lsbs - k] = x[nt + k]; /* Q0 */
1140 3736228 : move16();
1141 : }
1142 : /* Write filler bits */
1143 18878234 : FOR( ; k < nbbits - bp - nbbits_lsbs; ++k )
1144 : {
1145 18034288 : ptr[nbbits - 1 - nbbits_lsbs - k] = 0;
1146 18034288 : move16();
1147 : }
1148 :
1149 : /* Check for debugging */
1150 843946 : assert( bp + k <= nbbits );
1151 :
1152 : /* Push the rest of the buffer */
1153 843946 : push_next_bits( hBstr, (UWord16 *) &ptr[bp], sub( nbbits, bp ) );
1154 :
1155 : /* return (bp+nbbits_lsbs);*/ /*return only for debug plot*/
1156 843946 : return;
1157 : }
1158 :
1159 : /*-------------------------------------------------------------------*
1160 : * find_last_nz_pair_fx()
1161 : *
1162 : *
1163 : *-------------------------------------------------------------------*/
1164 :
1165 398329 : static Word16 find_last_nz_pair_fx(
1166 : const Word16 x[], /* Q0 */
1167 : const Word16 length,
1168 : const CONTEXT_HM_CONFIG *hm_cfg )
1169 : {
1170 : Word16 last_nz, i;
1171 : const Word16 *tmp;
1172 :
1173 398329 : last_nz = 2;
1174 398329 : move16();
1175 :
1176 398329 : IF( hm_cfg )
1177 : {
1178 : /* mapped kernel */
1179 398329 : tmp = hm_cfg->indexBuffer;
1180 :
1181 68418594 : FOR( i = length; i >= 4; i -= 2 )
1182 : {
1183 68414542 : test();
1184 68414542 : IF( x[tmp[i - 2]] || x[tmp[i - 1]] )
1185 : {
1186 394277 : last_nz = i; /* Q0 */
1187 394277 : move16();
1188 394277 : BREAK;
1189 : }
1190 : }
1191 : }
1192 : ELSE
1193 : {
1194 : /* unmapped kernel */
1195 :
1196 0 : FOR( i = length; i >= 4; i -= 2 )
1197 : {
1198 0 : test();
1199 0 : IF( x[i - 2] || x[i - 1] )
1200 : {
1201 0 : last_nz = i; /* Q0 */
1202 0 : move16();
1203 0 : BREAK;
1204 : }
1205 : }
1206 : }
1207 :
1208 398329 : return last_nz;
1209 : }
1210 :
1211 :
1212 : /*-------------------------------------------------------------------*
1213 : * RCcontextMapping_encode2_estimate_no_mem_s17_LCS_fx()
1214 : *
1215 : * Range coder bit-estimation
1216 : *-------------------------------------------------------------------*/
1217 :
1218 3882556 : Word16 RCcontextMapping_encode2_estimate_no_mem_s17_LCS_fx(
1219 : Word16 *x, /* Spectral coefficients Q0*/
1220 : const Word16 nt, /* L - size of spectrum (no. of spectral coefficients) Q0*/
1221 : Word16 *lastnz_out, /* Q0 */
1222 : Word16 *nEncoded, /* No. of spectral coefficients that can be coded without an overflow occuring Q0*/
1223 : const Word16 target, /* Target bits Q0*/
1224 : Word16 *stop, /* Q0 */
1225 : Word16 mode, /* Q0 */
1226 : CONTEXT_HM_CONFIG *hm_cfg /* context-based harmonic model configuration */
1227 : )
1228 : {
1229 : /* Common variables */
1230 : Word16 a1, b1;
1231 : Word16 k, pki, lev1;
1232 : UWord16 t;
1233 : Word16 lastnz, lastnz2;
1234 : Word16 rateFlag;
1235 : Word64 bit_estimate_fx; /* Q23 */
1236 :
1237 : Word16 symbol;
1238 : const UWord8 *lookup;
1239 : Word64 nbits2_fx;
1240 :
1241 : /* Initialization */
1242 3882556 : bit_estimate_fx = MAKE_NUMBER_QX( 2, Q23 );
1243 3882556 : move64();
1244 :
1245 3882556 : nbits2_fx = 0;
1246 3882556 : move64();
1247 :
1248 : /* bits to encode lastnz */
1249 3882556 : k = 1;
1250 3882556 : move16();
1251 :
1252 38189922 : WHILE( LT_16( k, nt / 2 ) )
1253 : {
1254 34307366 : bit_estimate_fx = W_add( bit_estimate_fx, MAKE_NUMBER_QX( 1, Q23 ) );
1255 34307366 : k = shl( k, 1 );
1256 : /* check while condition */
1257 : }
1258 :
1259 3882556 : nbits2_fx = bit_estimate_fx;
1260 3882556 : move64();
1261 :
1262 3882556 : IF( hm_cfg )
1263 : {
1264 : Word16 a1_i, b1_i;
1265 : Word16 stop2;
1266 : Word16 total_output_bits;
1267 : Word16 nt_half;
1268 : Word32 c[2], *ctx;
1269 : Word32 p1, p2;
1270 : Word16 ii[2];
1271 : Word16 idx1, idx2, idx;
1272 398329 : Word16 numPeakIndicesOrig = 0, numHoleIndices = 0; /* only to avoid compiler warning */
1273 398329 : move16();
1274 398329 : move16();
1275 :
1276 : /* Rate flag */
1277 398329 : IF( GT_16( target, 400 ) )
1278 : {
1279 246855 : rateFlag = 2 << NBITS_CONTEXT; /* Select context-A for higher bitrates */
1280 246855 : move16();
1281 : }
1282 : ELSE
1283 : {
1284 151474 : rateFlag = 0; /* Select context-B for lower bitrates */
1285 151474 : move16();
1286 : }
1287 :
1288 398329 : nt_half = shr( nt, 1 );
1289 398329 : move16();
1290 398329 : stop2 = 0;
1291 398329 : move16();
1292 398329 : c[0] = c[1] = 0;
1293 398329 : move32();
1294 398329 : move32();
1295 :
1296 : /* Find last non-zero tuple in the mapped domain signal */
1297 398329 : lastnz = find_last_nz_pair_fx( x, nt, hm_cfg );
1298 :
1299 398329 : lastnz2 = 2;
1300 398329 : move16();
1301 :
1302 : /* mapped domain */
1303 398329 : numPeakIndicesOrig = hm_cfg->numPeakIndices; /* Q0 */
1304 398329 : move16();
1305 398329 : hm_cfg->numPeakIndices = s_min( hm_cfg->numPeakIndices, lastnz ); /* Q0 */
1306 398329 : move16();
1307 398329 : numHoleIndices = sub( lastnz, hm_cfg->numPeakIndices ); /* Q0 */
1308 :
1309 : /* Mark hole indices beyond lastnz as pruned */
1310 134554865 : FOR( k = numHoleIndices; k < hm_cfg->numHoleIndices; ++k )
1311 : {
1312 134156536 : hm_cfg->holeIndices[k] = add( hm_cfg->holeIndices[k], nt ); /* Q0 */
1313 134156536 : move16();
1314 : }
1315 :
1316 398329 : ii[0] = numPeakIndicesOrig; /* Q0 */
1317 398329 : move16();
1318 398329 : ii[1] = 0;
1319 398329 : move16();
1320 :
1321 398329 : p1 = p2 = 0; /* to avoid compilation warnings */
1322 398329 : move32();
1323 398329 : move32();
1324 :
1325 : /* Main Loop through the 2-tuples */
1326 83376431 : FOR( k = 0; k < lastnz; k += 2 )
1327 : {
1328 83135076 : a1_i = get_next_coeff_mapped_ivas_fx( ii, &p1, &idx1, hm_cfg ); /* Q0 */
1329 83135076 : b1_i = get_next_coeff_mapped_ivas_fx( ii, &p2, &idx2, hm_cfg ); /* Q0 */
1330 :
1331 83135076 : idx = s_min( idx1, idx2 );
1332 :
1333 : /* Get context */
1334 83135076 : ctx = &c[L_or( p1, p2 )];
1335 :
1336 83135076 : t = (UWord16) L_add( *ctx, rateFlag );
1337 83135076 : IF( LT_16( nt_half, idx ) )
1338 : {
1339 14962580 : t = add( t, ( 1 << NBITS_CONTEXT ) );
1340 : }
1341 :
1342 : /* Init current 2-tuple encoding */
1343 83135076 : a1 = abs_s( x[a1_i] );
1344 83135076 : b1 = abs_s( x[b1_i] );
1345 83135076 : lev1 = -( 1 << ( NBITS_CONTEXT + NBITS_RATEQ ) );
1346 :
1347 83135076 : bit_estimate_fx = W_add( bit_estimate_fx, MAKE_VARIABLE_QX( s_min( a1, 1 ), Q23 ) );
1348 83135076 : bit_estimate_fx = W_add( bit_estimate_fx, MAKE_VARIABLE_QX( s_min( b1, 1 ), Q23 ) );
1349 : /* pre-compute address of ari_pk_s17_LC_ext[0][Val_esc] to avoid doing it multiple times inside the loop */
1350 83135076 : lookup = &ari_lookup_s17_LC[t] + ( 1 << ( NBITS_CONTEXT + NBITS_RATEQ ) );
1351 :
1352 : /* check while condition */
1353 : /* MSBs coding */
1354 92561096 : WHILE( GE_16( s_max( a1, b1 ), A_THRES ) )
1355 : {
1356 9426020 : pki = lookup[lev1]; /* ESC symbol */
1357 :
1358 9426020 : bit_estimate_fx = W_add( bit_estimate_fx, ari_bit_estimate_s17_LC_fx[pki][VAL_ESC] );
1359 9426020 : bit_estimate_fx = W_add( bit_estimate_fx, MAKE_VARIABLE_QX( 2, Q23 ) );
1360 9426020 : a1 = shr( a1, 1 );
1361 9426020 : b1 = shr( b1, 1 );
1362 :
1363 9426020 : lev1 = s_min( add( lev1, ( 1 << ( NBITS_CONTEXT + NBITS_RATEQ ) ) ), 2 << ( NBITS_CONTEXT + NBITS_RATEQ ) );
1364 :
1365 : /* check while condition */
1366 : }
1367 :
1368 83135076 : pki = lookup[lev1];
1369 :
1370 83135076 : symbol = add( a1, i_mult( A_THRES, b1 ) ); /* Q0 */
1371 83135076 : bit_estimate_fx = W_add( bit_estimate_fx, ari_bit_estimate_s17_LC_fx[pki][symbol] );
1372 :
1373 : /* Should we truncate? */
1374 83135076 : IF( GT_32( W_extract_l( W_shr( bit_estimate_fx, Q8 ) ), L_shl( target, Q15 ) ) )
1375 : {
1376 13812633 : stop2 = 1;
1377 13812633 : move16();
1378 :
1379 13812633 : IF( *stop )
1380 : {
1381 156974 : BREAK;
1382 : }
1383 : }
1384 : ELSE
1385 : {
1386 69322443 : lastnz2 = add( b1_i, 1 );
1387 69322443 : nbits2_fx = bit_estimate_fx;
1388 69322443 : move64();
1389 : }
1390 :
1391 : /* Update context for next 2-tuple */
1392 82978102 : IF( EQ_32( p1, p2 ) ) /* peak-peak or hole-hole context */
1393 : {
1394 68173522 : lev1 = shr( lev1, NBITS_CONTEXT + NBITS_RATEQ );
1395 :
1396 68173522 : IF( lev1 <= 0 )
1397 : {
1398 66505577 : t = add( 1, i_mult( add( a1, b1 ), add( lev1, 2 ) ) );
1399 : }
1400 : ELSE
1401 : {
1402 1667945 : t = add( 13, lev1 );
1403 : }
1404 :
1405 68173522 : *ctx = L_add( imult3216( L_and( *ctx, 0xf ), 16 ), t );
1406 68173522 : move32();
1407 : }
1408 : ELSE
1409 : {
1410 : /* mixed context */
1411 :
1412 14804580 : IF( s_and( idx1, 1 ) )
1413 : {
1414 : /* update first context */
1415 7398051 : c[p1] = update_mixed_context_ivas_fx( c[p1], abs_s( x[a1_i] ) ); /* Q0 */
1416 7398051 : move32();
1417 : }
1418 :
1419 14804580 : IF( s_and( idx2, 1 ) )
1420 : {
1421 : /* update second context */
1422 7385730 : c[p2] = update_mixed_context_ivas_fx( c[p2], abs_s( x[b1_i] ) ); /* Q0 */
1423 7385730 : move32();
1424 : }
1425 : }
1426 :
1427 : } /*end of the 2-tuples loop*/
1428 :
1429 398329 : total_output_bits = round_fx( W_extract_l( W_shr( bit_estimate_fx, Q7 ) ) ); /* Q23 -> Q16 -> Q0 */
1430 :
1431 398329 : IF( *stop )
1432 : {
1433 168212 : total_output_bits = round_fx( W_extract_l( W_shr( nbits2_fx, Q7 ) ) ); /* Q23 -> Q16 -> Q0 */
1434 : }
1435 :
1436 398329 : IF( stop2 )
1437 : {
1438 326485 : stop2 = total_output_bits; /* Q0 */
1439 326485 : move16();
1440 : }
1441 :
1442 398329 : *nEncoded = lastnz2; /* Q0 */
1443 398329 : move16();
1444 398329 : *stop = stop2; /* If zero, it means no overflow occured during bit-estimation Q0*/
1445 398329 : move16();
1446 398329 : *lastnz_out = lastnz; /* Q0 */
1447 398329 : move16();
1448 :
1449 : /* Restore hole indices beyond lastnz */
1450 134554865 : FOR( k = numHoleIndices; k < hm_cfg->numHoleIndices; ++k )
1451 : {
1452 134156536 : hm_cfg->holeIndices[k] = sub( hm_cfg->holeIndices[k], nt ); /* Q0 */
1453 134156536 : move16();
1454 : }
1455 398329 : hm_cfg->numPeakIndices = numPeakIndicesOrig; /* Q0 */
1456 398329 : move16();
1457 :
1458 :
1459 398329 : return round_fx( L_add( W_extract_l( W_shr( nbits2_fx, Q7 ) ), ONE_IN_Q14 ) ); /* Q0 */
1460 : }
1461 : ELSE /* if (!hm_cfg) */
1462 : {
1463 : Word16 esc_nb, cp, rateQ;
1464 : UWord16 s;
1465 : Word16 tot_bits2;
1466 3484227 : Word16 overflow_flag = 0;
1467 3484227 : move16();
1468 :
1469 : /* Rate flag */
1470 3484227 : IF( GT_16( target, 400 ) )
1471 : {
1472 2649272 : rateFlag = 2; /* Q0 */
1473 2649272 : move16();
1474 : }
1475 : ELSE
1476 : {
1477 834955 : rateFlag = 0; /* Select context-B for lower bitrates */
1478 834955 : move16();
1479 : }
1480 :
1481 3484227 : t = 0;
1482 3484227 : move16();
1483 3484227 : s = 0;
1484 3484227 : move16();
1485 3484227 : cp = 0;
1486 3484227 : move16();
1487 3484227 : lastnz = 1;
1488 3484227 : move16();
1489 3484227 : lastnz2 = 0;
1490 3484227 : move16();
1491 3484227 : tot_bits2 = 0;
1492 3484227 : move16();
1493 :
1494 : /* Find last non-zero tuple in the mapped domain signal */
1495 590765655 : FOR( lastnz = sub( nt, 2 ); lastnz >= 0; lastnz -= 2 )
1496 : {
1497 590751972 : test();
1498 590751972 : IF( ( x[lastnz] != 0 ) || ( x[lastnz + 1] != 0 ) )
1499 : {
1500 : BREAK;
1501 : }
1502 : }
1503 3484227 : lastnz = add( lastnz, 2 ); /* Q0 */
1504 3484227 : IF( LT_16( lastnz, 2 ) )
1505 : {
1506 13683 : lastnz = 2; /* At least one tuple is coded Q0*/
1507 13683 : move16();
1508 : }
1509 :
1510 3484227 : lastnz2 = 2;
1511 3484227 : move16();
1512 :
1513 : /* Main Loop through the 2-tuples */
1514 776760954 : FOR( k = 0; k < lastnz; k += 2 )
1515 : {
1516 : /* Init current 2-tuple encoding */
1517 773276727 : a1 = abs_s( x[k] ); /* Q0 */
1518 773276727 : b1 = abs_s( x[k + 1] ); /* Q0 */
1519 773276727 : lev1 = 0;
1520 773276727 : move16();
1521 773276727 : esc_nb = 0;
1522 773276727 : move16();
1523 773276727 : rateQ = add( rateFlag, extract_l( GT_16( k, shr( nt, 1 ) ) ) ); /* Q0 */
1524 :
1525 773276727 : bit_estimate_fx = W_add( bit_estimate_fx, MAKE_VARIABLE_QX( s_min( a1, 1 ), Q23 ) );
1526 773276727 : bit_estimate_fx = W_add( bit_estimate_fx, MAKE_VARIABLE_QX( s_min( b1, 1 ), Q23 ) );
1527 :
1528 : /* pre-compute address of ari_pk_s17_LC_ext[0][Val_esc] to avoid doing it multiple times inside the loop */
1529 773276727 : lookup = &ari_lookup_s17_LC[t + shl( rateQ, NBITS_CONTEXT )]; /* Q0 */
1530 :
1531 : /* check while condition */
1532 : /* MSBs coding */
1533 922150719 : WHILE( GE_16( s_max( a1, b1 ), A_THRES ) )
1534 : {
1535 148873992 : pki = lookup[( esc_nb << ( NBITS_CONTEXT + NBITS_RATEQ ) )]; /* Q0 */
1536 148873992 : move16();
1537 :
1538 148873992 : bit_estimate_fx = W_add( bit_estimate_fx, ari_bit_estimate_s17_LC_fx[pki][VAL_ESC] );
1539 148873992 : bit_estimate_fx = W_add( bit_estimate_fx, MAKE_NUMBER_QX( 2, Q23 ) );
1540 :
1541 148873992 : a1 = shr( a1, 1 );
1542 148873992 : b1 = shr( b1, 1 );
1543 :
1544 148873992 : lev1 = add( lev1, 1 );
1545 148873992 : esc_nb = s_min( lev1, 3 );
1546 :
1547 : /* check while condition */
1548 : }
1549 :
1550 773276727 : pki = lookup[( esc_nb << ( NBITS_CONTEXT + NBITS_RATEQ ) )]; /* Q0 */
1551 773276727 : move16();
1552 :
1553 773276727 : symbol = add( a1, i_mult( A_THRES, b1 ) ); /* Q0 */
1554 773276727 : bit_estimate_fx = W_add( bit_estimate_fx, ari_bit_estimate_s17_LC_fx[pki][symbol] );
1555 :
1556 : /* Should we truncate? */
1557 773276727 : IF( GT_32( W_extract_l( W_shr( bit_estimate_fx, Q8 ) ), L_shl( target, Q15 ) ) )
1558 : {
1559 26964873 : overflow_flag = 1;
1560 26964873 : move16();
1561 : }
1562 : ELSE
1563 : {
1564 746311854 : IF( abs_s( x[k] ) || abs_s( x[k + 1] ) ) /* No overflow & non-zero tuple */
1565 : {
1566 450502578 : nbits2_fx = bit_estimate_fx; /* exp(bit_estimate_e) */
1567 450502578 : move64();
1568 :
1569 450502578 : lastnz2 = add( k, 2 );
1570 : }
1571 : }
1572 :
1573 : /* Update context for next 2-tuple */
1574 773276727 : IF( LT_16( esc_nb, 2 ) )
1575 : {
1576 736354944 : cp = add( 1, i_mult( add( a1, b1 ), add( esc_nb, 1 ) ) ); /* Q0 */
1577 : }
1578 : ELSE
1579 : {
1580 36921783 : cp = add( 12, esc_nb ); /* Q0 */
1581 : }
1582 : /*shift old bits and replace last 4 bits*/
1583 773276727 : s = (UWord16) L_add( L_shl( s, 4 ), cp );
1584 773276727 : t = s_and( s, 0xFF );
1585 :
1586 : } /*end of the 2-tuples loop*/
1587 :
1588 3484227 : tot_bits2 = round_fx( W_extract_l( W_shr( nbits2_fx, Q7 ) ) ); /* Q23 -> Q16 -> Q0 */
1589 3484227 : IF( LT_16( lastnz2, lastnz ) ) /* Overflow occured because unable to code all tuples */
1590 : {
1591 1430556 : overflow_flag = 1;
1592 1430556 : move16();
1593 : }
1594 3484227 : IF( EQ_16( mode, -1 ) )
1595 : {
1596 0 : tot_bits2 = round_fx( W_extract_l( W_shr( bit_estimate_fx, Q7 ) ) ); /* Q23 -> Q16 -> Q0 */
1597 : }
1598 3484227 : IF( overflow_flag == 0 ) /* No overflow */
1599 : {
1600 2053671 : *stop = 0;
1601 2053671 : move16();
1602 : }
1603 : ELSE /* Overflow */
1604 : {
1605 1430556 : IF( *stop ){
1606 9724 : *stop = tot_bits2; /* Q0 */
1607 9724 : move16();
1608 : }
1609 : ELSE
1610 : {
1611 1420832 : *stop = round_fx( W_extract_l( W_shr( bit_estimate_fx, Q7 ) ) ); /* Q23 -> Q16 -> Q0 */
1612 1420832 : move16();
1613 : }
1614 : }
1615 :
1616 3484227 : *lastnz_out = lastnz; /* Q0 */
1617 3484227 : move16();
1618 3484227 : *nEncoded = lastnz2; /* Q0 */
1619 3484227 : move16();
1620 : /* Safety mechanism to avoid overflow */
1621 3484227 : test();
1622 3484227 : IF( EQ_16( lastnz2, 2 ) && EQ_16( overflow_flag, 1 ) )
1623 : {
1624 156 : FOR( k = 0; k < lastnz2; k++ )
1625 : {
1626 104 : x[k] = 0;
1627 104 : move16();
1628 : }
1629 : }
1630 :
1631 3484227 : return tot_bits2;
1632 : }
1633 : }
1634 :
1635 :
1636 : /*-------------------------------------------------------------------*
1637 : * RCcontextMapping_encode2_estimate_bandWise_start_fx()
1638 : *
1639 : * Range coder - start bandwise bit-estimation
1640 : *-------------------------------------------------------------------*/
1641 :
1642 553108 : Word16 RCcontextMapping_encode2_estimate_bandWise_start_fx(
1643 : Word16 *x, /* Q0 */
1644 : const Word16 nt, /* Q0 */
1645 : const Word16 target, /* Q0 */
1646 : HANDLE_RC_CONTEXT_MEM hContextMem )
1647 : {
1648 : Word16 i, k;
1649 :
1650 : /* Rate flag */
1651 553108 : IF( GT_16( target, 400 ) )
1652 : {
1653 543724 : hContextMem->rateFlag = 2 << NBITS_CONTEXT;
1654 543724 : move16();
1655 : }
1656 : ELSE
1657 : {
1658 9384 : hContextMem->rateFlag = 0;
1659 9384 : move16();
1660 : }
1661 :
1662 553108 : hContextMem->bit_estimate_fx = MAKE_NUMBER_QX( 2, Q23 );
1663 553108 : move64();
1664 :
1665 :
1666 : /* Init */
1667 553108 : hContextMem->nt_half = shr( nt, 1 );
1668 553108 : move16();
1669 :
1670 : /* bits to encode lastnz */
1671 553108 : k = 1;
1672 553108 : move16();
1673 :
1674 5208096 : WHILE( LT_16( k, hContextMem->nt_half ) )
1675 : {
1676 4654988 : hContextMem->bit_estimate_fx = W_add( hContextMem->bit_estimate_fx, MAKE_NUMBER_QX( 1, Q23 ) );
1677 4654988 : move64();
1678 :
1679 4654988 : k = shl( k, 1 );
1680 : /* check while condition */
1681 : }
1682 :
1683 : /* bits to encode lastnz */
1684 553108 : hContextMem->nbits_old = round_fx( W_extract_l( W_shr( hContextMem->bit_estimate_fx, Q7 ) ) ); /* Q0 */
1685 553108 : move16();
1686 :
1687 553108 : hContextMem->ctx = 0;
1688 553108 : move16();
1689 553108 : hContextMem->lastnz = 2;
1690 553108 : move16();
1691 :
1692 : /* Find last non-zero tuple */
1693 :
1694 8153101 : FOR( i = nt; i >= 4; i -= 2 )
1695 : {
1696 8152455 : test();
1697 8152455 : IF( x[i - 2] != 0 || x[i - 1] != 0 )
1698 : {
1699 552462 : hContextMem->lastnz = i;
1700 552462 : move16();
1701 552462 : BREAK;
1702 : }
1703 : }
1704 :
1705 553108 : return hContextMem->nbits_old;
1706 : }
1707 :
1708 : /*-------------------------------------------------------------------*
1709 : * RCcontextMapping_encode2_estimate_bandWise_fx()
1710 : *
1711 : * Range coder - bandwise bit-estimation
1712 : *-------------------------------------------------------------------*/
1713 :
1714 21952188 : Word16 RCcontextMapping_encode2_estimate_bandWise_fx(
1715 : Word16 *x, /* Q0 */
1716 : const Word16 start_line, /* Q0 */
1717 : const Word16 end_line, /* Q0 */
1718 : HANDLE_RC_CONTEXT_MEM hContextMem )
1719 : {
1720 : Word16 a1, b1, a1_i, b1_i;
1721 : Word16 k, pki, lev1;
1722 : UWord16 t;
1723 21952188 : Word16 bandBits = 0;
1724 21952188 : move16();
1725 : Word16 total_output_bits; /* No. of bits after finalization */
1726 : Word16 symbol;
1727 : const UWord8 *lookup;
1728 : Word16 idx;
1729 : Word16 tmp;
1730 :
1731 : /* Main Loop through the 2-tuples */
1732 : /*hContextMem->nt_half = end_line >> 1;*/
1733 21952188 : Word16 len = s_min( hContextMem->lastnz, end_line );
1734 172294910 : FOR( k = start_line; k < len; k += 2 )
1735 : {
1736 150342722 : a1_i = k; /* Q0 */
1737 150342722 : move16();
1738 150342722 : b1_i = add( k, 1 ); /* Q0 */
1739 :
1740 150342722 : idx = k;
1741 150342722 : move16();
1742 :
1743 : /* Get context */
1744 150342722 : t = add( hContextMem->ctx, hContextMem->rateFlag ); /* Q0 */
1745 :
1746 150342722 : IF( GE_16( hContextMem->nt_half, idx ) )
1747 : {
1748 78950593 : tmp = 0;
1749 : }
1750 : ELSE
1751 : {
1752 71392129 : tmp = ( 1 << NBITS_CONTEXT );
1753 : }
1754 :
1755 150342722 : t = add( t, tmp ); /* Q0 */
1756 :
1757 : /* Init current 2-tuple encoding */
1758 150342722 : a1 = abs_s( x[a1_i] ); /* Q0 */
1759 150342722 : b1 = abs_s( x[b1_i] ); /* Q0 */
1760 150342722 : lev1 = -( 1 << ( NBITS_CONTEXT + NBITS_RATEQ ) ); /* Q0 */
1761 :
1762 : /* Signs Bits */
1763 150342722 : hContextMem->bit_estimate_fx = W_add( hContextMem->bit_estimate_fx, MAKE_VARIABLE_QX( s_min( a1, 1 ), Q23 ) );
1764 150342722 : hContextMem->bit_estimate_fx = W_add( hContextMem->bit_estimate_fx, MAKE_VARIABLE_QX( s_min( b1, 1 ), Q23 ) );
1765 :
1766 150342722 : move32();
1767 150342722 : move32();
1768 :
1769 : /* pre-compute address of ari_pk_s17_LC_ext[0][Val_esc] to avoid doing it multiple times inside the loop */
1770 150342722 : lookup = &ari_lookup_s17_LC[t] + ( 1 << ( NBITS_CONTEXT + NBITS_RATEQ ) );
1771 :
1772 : /* check while condition */
1773 : /* MSBs coding */
1774 181566998 : WHILE( GE_16( s_max( a1, b1 ), A_THRES ) )
1775 : {
1776 31224276 : pki = lookup[lev1]; /* Q0 */
1777 31224276 : move16();
1778 :
1779 31224276 : hContextMem->bit_estimate_fx = W_add( hContextMem->bit_estimate_fx, ari_bit_estimate_s17_LC_fx[pki][VAL_ESC] );
1780 31224276 : hContextMem->bit_estimate_fx = W_add( hContextMem->bit_estimate_fx, MAKE_NUMBER_QX( 2, Q23 ) );
1781 31224276 : move32();
1782 31224276 : move32();
1783 :
1784 :
1785 : // hContextMem->bit_estimate = hContextMem->bit_estimate + ari_bit_estimate_s17_LC[pki][VAL_ESC];
1786 : // hContextMem->bit_estimate += 2; /* Add the 2 LSB bits that were shifted out */
1787 :
1788 31224276 : a1 = shr( a1, 1 );
1789 31224276 : b1 = shr( b1, 1 );
1790 :
1791 31224276 : lev1 = s_min( add( lev1, ( 1 << ( NBITS_CONTEXT + NBITS_RATEQ ) ) ), 2 << ( NBITS_CONTEXT + NBITS_RATEQ ) ); /* Q0 */
1792 : /* check while condition */
1793 : }
1794 :
1795 150342722 : pki = lookup[lev1]; /* Q0 */
1796 150342722 : move16();
1797 150342722 : symbol = add( a1, i_mult( A_THRES, b1 ) ); /* MSB symbol Q0*/
1798 150342722 : hContextMem->bit_estimate_fx = W_add( hContextMem->bit_estimate_fx, ari_bit_estimate_s17_LC_fx[pki][symbol] );
1799 :
1800 150342722 : move32();
1801 : // hContextMem->bit_estimate = hContextMem->bit_estimate + ari_bit_estimate_s17_LC[pki][symbol];
1802 :
1803 : /* Update context */
1804 150342722 : lev1 = shr( lev1, NBITS_CONTEXT + NBITS_RATEQ );
1805 :
1806 150342722 : IF( lev1 <= 0 )
1807 : {
1808 142535034 : t = add( 1, i_mult( add( a1, b1 ), add( lev1, 2 ) ) ); /* Q0 */
1809 : }
1810 : ELSE
1811 : {
1812 7807688 : t = add( 13, lev1 ); /* Q0 */
1813 : }
1814 :
1815 150342722 : hContextMem->ctx = add( i_mult( s_and( hContextMem->ctx, 0xf ), 16 ), t ); /* Q0 */
1816 150342722 : move16();
1817 :
1818 : } /*end of the 2-tuples loop*/
1819 21952188 : total_output_bits = round_fx( W_extract_l( W_shr( hContextMem->bit_estimate_fx, Q7 ) ) ); /* Q0 */
1820 : // total_output_bits = (Word16) ( hContextMem->bit_estimate + 0.5f );
1821 :
1822 :
1823 21952188 : bandBits = sub( total_output_bits, hContextMem->nbits_old ); /* Q0 */
1824 21952188 : hContextMem->nbits_old = total_output_bits; /* Q0 */
1825 21952188 : move16();
1826 :
1827 21952188 : return bandBits;
1828 : }
1829 :
1830 :
1831 : #ifdef IVAS_CODE_RANGE_CODER
1832 :
1833 : /*-------------------------------------------------------------------*
1834 : * RCcontextMapping_encode2_estimate_no_mem_s17_LCS()
1835 : *
1836 : * Range coder bit-estimation
1837 : *-------------------------------------------------------------------*/
1838 :
1839 : int16_t RCcontextMapping_encode2_estimate_no_mem_s17_LCS(
1840 : int16_t *x, /* Spectral coefficients */
1841 : const int16_t nt, /* L - size of spectrum (no. of spectral coefficients) */
1842 : int16_t *lastnz_out,
1843 : int16_t *nEncoded, /* No. of spectral coefficients that can be coded without an overflow occuring */
1844 : const int16_t target, /* Target bits */
1845 : int16_t *stop,
1846 : int16_t mode,
1847 : CONTEXT_HM_CONFIG *hm_cfg /* context-based harmonic model configuration */
1848 : )
1849 : {
1850 : /* Common variables */
1851 : int16_t a1, b1;
1852 : int16_t k, pki, lev1;
1853 : uint16_t t;
1854 : int16_t lastnz, lastnz2;
1855 : int16_t rateFlag;
1856 : float bit_estimate;
1857 : int16_t symbol;
1858 : const uint8_t *lookup;
1859 : float nbits2;
1860 :
1861 : /* Initialization */
1862 : bit_estimate = 2.0f;
1863 : nbits2 = 0.f;
1864 :
1865 : /* bits to encode lastnz */
1866 : k = 1;
1867 :
1868 : while ( k < nt / 2 )
1869 : {
1870 : bit_estimate++;
1871 : k = k << 1;
1872 : /* check while condition */
1873 : }
1874 :
1875 : nbits2 = bit_estimate;
1876 :
1877 : if ( hm_cfg )
1878 : {
1879 : int16_t a1_i, b1_i;
1880 : int16_t stop2;
1881 : int16_t total_output_bits;
1882 : int16_t nt_half;
1883 : int32_t c[2], *ctx;
1884 : int32_t p1, p2;
1885 : int16_t ii[2];
1886 : int16_t idx1, idx2, idx;
1887 : int16_t numPeakIndicesOrig = 0, numHoleIndices = 0; /* only to avoid compiler warning */
1888 :
1889 : /* Rate flag */
1890 : if ( target > 400 )
1891 : {
1892 : rateFlag = 2 << NBITS_CONTEXT; /* Select context-A for higher bitrates */
1893 : }
1894 : else
1895 : {
1896 : rateFlag = 0; /* Select context-B for lower bitrates */
1897 : }
1898 :
1899 : nt_half = nt >> 1;
1900 : stop2 = 0;
1901 : c[0] = c[1] = 0;
1902 :
1903 : /* Find last non-zero tuple in the mapped domain signal */
1904 : lastnz = find_last_nz_pair( x, nt, hm_cfg );
1905 :
1906 : lastnz2 = 2;
1907 :
1908 : /* mapped domain */
1909 : numPeakIndicesOrig = hm_cfg->numPeakIndices;
1910 : hm_cfg->numPeakIndices = min( hm_cfg->numPeakIndices, lastnz );
1911 : numHoleIndices = lastnz - hm_cfg->numPeakIndices;
1912 :
1913 : /* Mark hole indices beyond lastnz as pruned */
1914 : for ( k = numHoleIndices; k < hm_cfg->numHoleIndices; ++k )
1915 : {
1916 : hm_cfg->holeIndices[k] = hm_cfg->holeIndices[k] + nt;
1917 : }
1918 :
1919 : ii[0] = numPeakIndicesOrig;
1920 : ii[1] = 0;
1921 :
1922 : p1 = p2 = 0; /* to avoid compilation warnings */
1923 :
1924 : /* Main Loop through the 2-tuples */
1925 : for ( k = 0; k < lastnz; k += 2 )
1926 : {
1927 : a1_i = get_next_coeff_mapped( ii, &p1, &idx1, hm_cfg );
1928 : b1_i = get_next_coeff_mapped( ii, &p2, &idx2, hm_cfg );
1929 :
1930 : idx = min( idx1, idx2 );
1931 :
1932 : /* Get context */
1933 : ctx = &c[p1 | p2];
1934 :
1935 : t = (uint16_t) ( *ctx + rateFlag );
1936 : t += ( nt_half >= idx ) ? 0 : ( 1 << NBITS_CONTEXT );
1937 :
1938 : /* Init current 2-tuple encoding */
1939 : a1 = (int16_t) abs( x[a1_i] );
1940 : b1 = (int16_t) abs( x[b1_i] );
1941 : lev1 = -( 1 << ( NBITS_CONTEXT + NBITS_RATEQ ) );
1942 :
1943 : /* Signs Bits */
1944 : bit_estimate += min( a1, 1 );
1945 : bit_estimate += min( b1, 1 );
1946 :
1947 : /* pre-compute address of ari_pk_s17_LC_ext[0][Val_esc] to avoid doing it multiple times inside the loop */
1948 : lookup = &ari_lookup_s17_LC[t] + ( 1 << ( NBITS_CONTEXT + NBITS_RATEQ ) );
1949 :
1950 : /* check while condition */
1951 : /* MSBs coding */
1952 : while ( max( a1, b1 ) >= A_THRES )
1953 : {
1954 : pki = lookup[lev1]; /* ESC symbol */
1955 :
1956 : bit_estimate = bit_estimate + ari_bit_estimate_s17_LC[pki][VAL_ESC];
1957 : bit_estimate += 2; /* Add 2 LSB bits corresponding to the bit-plane */
1958 :
1959 : ( a1 ) >>= 1;
1960 : ( b1 ) >>= 1;
1961 :
1962 : lev1 = min( lev1 + ( 1 << ( NBITS_CONTEXT + NBITS_RATEQ ) ), 2 << ( NBITS_CONTEXT + NBITS_RATEQ ) );
1963 :
1964 : /* check while condition */
1965 : }
1966 :
1967 : pki = lookup[lev1];
1968 :
1969 : symbol = a1 + A_THRES * b1;
1970 : bit_estimate = bit_estimate + ari_bit_estimate_s17_LC[pki][symbol];
1971 :
1972 : /* Should we truncate? */
1973 : if ( bit_estimate > target )
1974 : {
1975 : stop2 = 1;
1976 :
1977 : if ( *stop )
1978 : {
1979 : break;
1980 : }
1981 : }
1982 : else
1983 : {
1984 : lastnz2 = b1_i + 1;
1985 : nbits2 = bit_estimate;
1986 : }
1987 :
1988 : /* Update context for next 2-tuple */
1989 : if ( p1 == p2 ) /* peak-peak or hole-hole context */
1990 : {
1991 : lev1 >>= NBITS_CONTEXT + NBITS_RATEQ;
1992 :
1993 : if ( lev1 <= 0 )
1994 : {
1995 : t = 1 + ( a1 + b1 ) * ( lev1 + 2 );
1996 : }
1997 : else
1998 : {
1999 : t = 13 + lev1;
2000 : }
2001 :
2002 : *ctx = ( *ctx & 0xf ) * 16 + t;
2003 : }
2004 : else
2005 : {
2006 : /* mixed context */
2007 :
2008 : if ( idx1 & 1 )
2009 : {
2010 : /* update first context */
2011 : c[p1] = update_mixed_context( c[p1], (int16_t) abs( x[a1_i] ) );
2012 : }
2013 :
2014 : if ( idx2 & 1 )
2015 : {
2016 : /* update second context */
2017 : c[p2] = update_mixed_context( c[p2], (int16_t) abs( x[b1_i] ) );
2018 : }
2019 : }
2020 :
2021 : } /*end of the 2-tuples loop*/
2022 :
2023 : total_output_bits = (int16_t) ( bit_estimate + 0.5f );
2024 : if ( *stop )
2025 : {
2026 : total_output_bits = (int16_t) ( nbits2 + 0.5f );
2027 : }
2028 :
2029 : if ( stop2 )
2030 : {
2031 : stop2 = total_output_bits;
2032 : }
2033 : *nEncoded = lastnz2;
2034 : *stop = stop2; /* If zero, it means no overflow occured during bit-estimation */
2035 : *lastnz_out = lastnz;
2036 :
2037 : /* Restore hole indices beyond lastnz */
2038 : for ( k = numHoleIndices; k < hm_cfg->numHoleIndices; ++k )
2039 : {
2040 : hm_cfg->holeIndices[k] = hm_cfg->holeIndices[k] - nt;
2041 : }
2042 : hm_cfg->numPeakIndices = numPeakIndicesOrig;
2043 :
2044 : return (int16_t) ( nbits2 + 0.5f );
2045 : }
2046 : else /* if (!hm_cfg) */
2047 : {
2048 : int16_t esc_nb, cp, rateQ;
2049 : uint16_t s;
2050 : int16_t tot_bits2;
2051 : int16_t overflow_flag = 0;
2052 :
2053 : /* Rate flag */
2054 : if ( target > 400 )
2055 : {
2056 : rateFlag = 2;
2057 : }
2058 : else
2059 : {
2060 : rateFlag = 0; /* Select context-B for lower bitrates */
2061 : }
2062 :
2063 : t = 0;
2064 : s = 0;
2065 : cp = 0;
2066 : lastnz = 1;
2067 : lastnz2 = 0;
2068 : tot_bits2 = 0;
2069 :
2070 : /* Find last non-zero tuple in the mapped domain signal */
2071 : for ( lastnz = ( nt - 2 ); lastnz >= 0; lastnz -= 2 )
2072 : {
2073 : if ( ( x[lastnz] != 0 ) || ( x[lastnz + 1] != 0 ) )
2074 : {
2075 : break;
2076 : }
2077 : }
2078 : lastnz += 2;
2079 : if ( lastnz < 2 )
2080 : {
2081 : lastnz = 2; /* At least one tuple is coded */
2082 : }
2083 :
2084 : lastnz2 = 2;
2085 :
2086 : /* Main Loop through the 2-tuples */
2087 : for ( k = 0; k < lastnz; k += 2 )
2088 : {
2089 : /* Init current 2-tuple encoding */
2090 : a1 = (int16_t) abs( x[k] );
2091 : b1 = (int16_t) abs( x[k + 1] );
2092 : lev1 = 0;
2093 : esc_nb = 0;
2094 : rateQ = rateFlag + ( k > ( nt >> 1 ) );
2095 :
2096 : /* Signs Bits */
2097 : bit_estimate += min( a1, 1 );
2098 : bit_estimate += min( b1, 1 );
2099 :
2100 : /* pre-compute address of ari_pk_s17_LC_ext[0][Val_esc] to avoid doing it multiple times inside the loop */
2101 : lookup = &ari_lookup_s17_LC[t + ( rateQ << NBITS_CONTEXT )];
2102 :
2103 : /* check while condition */
2104 : /* MSBs coding */
2105 : while ( max( a1, b1 ) >= A_THRES )
2106 : {
2107 : pki = lookup[( esc_nb << ( NBITS_CONTEXT + NBITS_RATEQ ) )];
2108 :
2109 : bit_estimate = bit_estimate + ari_bit_estimate_s17_LC[pki][VAL_ESC];
2110 : bit_estimate += 2; /* Add 2 LSB bits corresponding to the bit-plane */
2111 :
2112 : ( a1 ) >>= 1;
2113 : ( b1 ) >>= 1;
2114 :
2115 : lev1++;
2116 : esc_nb = min( lev1, 3 );
2117 :
2118 : /* check while condition */
2119 : }
2120 :
2121 : pki = lookup[( esc_nb << ( NBITS_CONTEXT + NBITS_RATEQ ) )];
2122 :
2123 : symbol = a1 + A_THRES * b1;
2124 : bit_estimate = bit_estimate + ari_bit_estimate_s17_LC[pki][symbol];
2125 :
2126 : /* Should we truncate? */
2127 : if ( bit_estimate > target ) /* Overflow occured */
2128 : {
2129 : overflow_flag = 1;
2130 : }
2131 : else
2132 : {
2133 : if ( abs( x[k] ) || abs( x[k + 1] ) ) /* No overflow & non-zero tuple */
2134 : {
2135 : nbits2 = bit_estimate;
2136 : lastnz2 = k + 2;
2137 : }
2138 : }
2139 :
2140 : /* Update context for next 2-tuple */
2141 : if ( esc_nb < 2 )
2142 : {
2143 : cp = 1 + ( a1 + b1 ) * ( esc_nb + 1 );
2144 : }
2145 : else
2146 : {
2147 : cp = 12 + esc_nb;
2148 : }
2149 : /*shift old bits and replace last 4 bits*/
2150 : s = ( s << 4 ) + cp;
2151 : t = s & 0xFF;
2152 :
2153 : } /*end of the 2-tuples loop*/
2154 :
2155 : tot_bits2 = (int16_t) ( nbits2 + 0.5f );
2156 : if ( lastnz2 < lastnz ) /* Overflow occured because unable to code all tuples */
2157 : {
2158 : overflow_flag = 1;
2159 : }
2160 : if ( mode == -1 )
2161 : {
2162 : tot_bits2 = (int16_t) ( bit_estimate + 0.5f );
2163 : }
2164 : if ( overflow_flag == 0 ) /* No overflow */
2165 : {
2166 : *stop = 0;
2167 : }
2168 : else /* Overflow */
2169 : {
2170 : if ( *stop )
2171 : {
2172 : *stop = tot_bits2;
2173 : }
2174 : else
2175 : {
2176 : *stop = (int16_t) ( bit_estimate + 0.5f );
2177 : }
2178 : }
2179 :
2180 : *lastnz_out = lastnz;
2181 : *nEncoded = lastnz2;
2182 : /* Safety mechanism to avoid overflow */
2183 : if ( lastnz2 == 2 && overflow_flag == 1 )
2184 : {
2185 : for ( k = 0; k < lastnz2; k++ )
2186 : {
2187 : x[k] = 0;
2188 : }
2189 : }
2190 :
2191 : return tot_bits2;
2192 : }
2193 : }
2194 :
2195 : /*-------------------------------------------------------------------*
2196 : * RCcontextMapping_encode2_estimate_bandWise_start()
2197 : *
2198 : * Range coder - start bandwise bit-estimation
2199 : *-------------------------------------------------------------------*/
2200 :
2201 : int16_t RCcontextMapping_encode2_estimate_bandWise_start(
2202 : int16_t *x,
2203 : const int16_t nt,
2204 : const int16_t target,
2205 : HANDLE_RC_CONTEXT_MEM hContextMem )
2206 : {
2207 : int16_t i, k;
2208 :
2209 : /* Rate flag */
2210 : if ( target > 400 )
2211 : {
2212 : hContextMem->rateFlag = 2 << NBITS_CONTEXT;
2213 : }
2214 : else
2215 : {
2216 : hContextMem->rateFlag = 0;
2217 : }
2218 :
2219 : hContextMem->bit_estimate = 2.0f;
2220 :
2221 : /* Init */
2222 : hContextMem->nt_half = nt >> 1;
2223 :
2224 : /* bits to encode lastnz */
2225 : k = 1;
2226 :
2227 : while ( k < hContextMem->nt_half )
2228 : {
2229 : hContextMem->bit_estimate++;
2230 :
2231 : k = k << 1;
2232 : /* check while condition */
2233 : }
2234 :
2235 : /* bits to encode lastnz */
2236 : hContextMem->nbits_old = (int16_t) hContextMem->bit_estimate;
2237 :
2238 : hContextMem->ctx = 0;
2239 : hContextMem->lastnz = 2;
2240 :
2241 : /* Find last non-zero tuple */
2242 :
2243 : for ( i = nt; i >= 4; i -= 2 )
2244 : {
2245 :
2246 : if ( x[i - 2] != 0 || x[i - 1] != 0 )
2247 : {
2248 : hContextMem->lastnz = i;
2249 : break;
2250 : }
2251 : }
2252 :
2253 : return (int16_t) hContextMem->bit_estimate;
2254 : }
2255 :
2256 : /*-------------------------------------------------------------------*
2257 : * RCcontextMapping_encode2_estimate_bandWise()
2258 : *
2259 : * Range coder - bandwise bit-estimation
2260 : *-------------------------------------------------------------------*/
2261 :
2262 : int16_t RCcontextMapping_encode2_estimate_bandWise(
2263 : int16_t *x,
2264 : const int16_t start_line,
2265 : const int16_t end_line,
2266 : HANDLE_RC_CONTEXT_MEM hContextMem )
2267 : {
2268 : int16_t a1, b1, a1_i, b1_i;
2269 : int16_t k, pki, lev1;
2270 : uint16_t t;
2271 : int16_t bandBits = 0;
2272 : int16_t total_output_bits; /* No. of bits after finalization */
2273 : int16_t symbol;
2274 : const uint8_t *lookup;
2275 : int16_t idx;
2276 :
2277 : /* Main Loop through the 2-tuples */
2278 : /*hContextMem->nt_half = end_line >> 1;*/
2279 : for ( k = start_line; k < min( hContextMem->lastnz, end_line ); k += 2 )
2280 : {
2281 : a1_i = k;
2282 : b1_i = k + 1;
2283 :
2284 : idx = k;
2285 :
2286 : /* Get context */
2287 : t = hContextMem->ctx + hContextMem->rateFlag;
2288 : t += ( hContextMem->nt_half >= idx ) ? 0 : ( 1 << NBITS_CONTEXT );
2289 :
2290 : /* Init current 2-tuple encoding */
2291 : a1 = (int16_t) abs( x[a1_i] );
2292 : b1 = (int16_t) abs( x[b1_i] );
2293 : lev1 = -( 1 << ( NBITS_CONTEXT + NBITS_RATEQ ) );
2294 :
2295 : /* Signs Bits */
2296 : hContextMem->bit_estimate += min( a1, 1 );
2297 : hContextMem->bit_estimate += min( b1, 1 );
2298 :
2299 : /* pre-compute address of ari_pk_s17_LC_ext[0][Val_esc] to avoid doing it multiple times inside the loop */
2300 : lookup = &ari_lookup_s17_LC[t] + ( 1 << ( NBITS_CONTEXT + NBITS_RATEQ ) );
2301 :
2302 : /* check while condition */
2303 : /* MSBs coding */
2304 : while ( max( a1, b1 ) >= A_THRES )
2305 : {
2306 : pki = lookup[lev1];
2307 : hContextMem->bit_estimate = hContextMem->bit_estimate + ari_bit_estimate_s17_LC[pki][VAL_ESC];
2308 : hContextMem->bit_estimate += 2; /* Add the 2 LSB bits that were shifted out */
2309 :
2310 : ( a1 ) >>= 1;
2311 : ( b1 ) >>= 1;
2312 :
2313 : lev1 = min( lev1 + ( 1 << ( NBITS_CONTEXT + NBITS_RATEQ ) ), 2 << ( NBITS_CONTEXT + NBITS_RATEQ ) );
2314 : /* check while condition */
2315 : }
2316 :
2317 : pki = lookup[lev1];
2318 : symbol = a1 + A_THRES * b1; /* MSB symbol */
2319 : hContextMem->bit_estimate = hContextMem->bit_estimate + ari_bit_estimate_s17_LC[pki][symbol];
2320 :
2321 : /* Update context */
2322 : lev1 >>= NBITS_CONTEXT + NBITS_RATEQ;
2323 :
2324 : if ( lev1 <= 0 )
2325 : {
2326 : t = 1 + ( a1 + b1 ) * ( lev1 + 2 );
2327 : }
2328 : else
2329 : {
2330 : t = 13 + lev1;
2331 : }
2332 :
2333 : hContextMem->ctx = ( hContextMem->ctx & 0xf ) * 16 + t;
2334 :
2335 : } /*end of the 2-tuples loop*/
2336 : total_output_bits = (int16_t) ( hContextMem->bit_estimate + 0.5f );
2337 :
2338 : bandBits = total_output_bits - hContextMem->nbits_old;
2339 : hContextMem->nbits_old = total_output_bits;
2340 :
2341 : return bandBits;
2342 : }
2343 :
2344 : #endif
|
