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 634 : 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 634 : a1 = 0; /* to avoid compilation warnings */
63 634 : b1 = 0; /* to avoid compilation warnings */
64 634 : move16();
65 634 : move16();
66 :
67 : /* Rate flag */
68 634 : rateFlag = 0;
69 634 : move16();
70 634 : if ( GT_16( nbbits, 400 ) )
71 : {
72 45 : rateFlag = 2 << NBITS_CONTEXT;
73 45 : move16();
74 : }
75 :
76 : /* Init */
77 634 : nt_half = shr( nt, 1 );
78 634 : c[0] = c[1] = 0;
79 634 : move16();
80 634 : move16();
81 :
82 : /* Bits for encoding the number of encoded tuples */
83 634 : nbbits_ntuples = sub( 14, norm_s( negate( nt ) ) ); /* Q0 */
84 :
85 634 : t = 0;
86 634 : move16();
87 634 : bp = nbbits_ntuples; /* Q0 */
88 634 : move16();
89 634 : nbbits_signs = 0;
90 634 : move16();
91 634 : nbbits_lsbs = 0;
92 634 : move16();
93 634 : nbbits_m2 = sub( nbbits, 2 ); /* Q0 */
94 634 : flag_overflow = 0;
95 634 : move16();
96 :
97 634 : IF( hm_cfg ) /* mapped domain */
98 : {
99 54 : numPeakIndicesOrig = hm_cfg->numPeakIndices; /* Q0 */
100 54 : move16();
101 54 : hm_cfg->numPeakIndices = s_min( hm_cfg->numPeakIndices, lastnz ); /* Q0 */
102 54 : move16();
103 54 : numHoleIndices = sub( lastnz, hm_cfg->numPeakIndices ); /* Q0 */
104 :
105 : /* Mark hole indices beyond lastnz as pruned */
106 23944 : FOR( k = numHoleIndices; k < hm_cfg->numHoleIndices; ++k )
107 : {
108 23890 : hm_cfg->holeIndices[k] = add( hm_cfg->holeIndices[k], nt ); /* Q0 */
109 23890 : move16();
110 : }
111 :
112 54 : ii[0] = numPeakIndicesOrig; /* Q0 */
113 54 : move16();
114 54 : ii[1] = 0;
115 54 : move16();
116 :
117 54 : get_next_coeff = get_next_coeff_mapped; /* Q0 */
118 54 : move16();
119 : }
120 : ELSE /* unmapped domain */
121 : {
122 580 : ii[0] = 0;
123 580 : move16();
124 :
125 580 : p1 = p2 = 0;
126 580 : move16();
127 580 : move16();
128 :
129 580 : get_next_coeff = get_next_coeff_unmapped; /* Q0 */
130 580 : move16();
131 :
132 : /* Find last non-zero tuple */
133 : /* ensure termination of while loop by dummy value */
134 580 : a1 = x[0];
135 580 : move16();
136 580 : x[0] = 1;
137 580 : move16();
138 :
139 2281 : WHILE( s_or( x[lastnz - 1], x[lastnz - 2] ) == 0 )
140 : {
141 1701 : lastnz = sub( lastnz, 2 ); /* Q0 */
142 : }
143 580 : x[0] = a1;
144 580 : move16();
145 : }
146 :
147 634 : lsbs_bits2 = ptr + nbbits - 1;
148 :
149 : /*Start Encoding*/
150 634 : ari_start_encoding_14bits_fx( &as );
151 :
152 : /*Main Loop through the 2-tuples*/
153 634 : b1_i = -1;
154 634 : move16();
155 65586 : FOR( k = 0; k < lastnz; k += 2 )
156 : {
157 : /* First coefficient */
158 64952 : a1_i = get_next_coeff( ii, &p1, &idx1, hm_cfg ); /* Q0 */
159 :
160 : /* Second coefficient */
161 64952 : b1_i = get_next_coeff( ii, &p2, &idx2, hm_cfg ); /* Q0 */
162 :
163 64952 : idx = s_min( idx1, idx2 ); /* Q0 */
164 :
165 : /* Get context */
166 64952 : ctx = &c[s_or( p1, p2 )]; /* Q0 */
167 : /* _DIFF_FLOAT_FIX_ float is using t as UWord16 */
168 64952 : t = add( *ctx, rateFlag ); /* Q0 */
169 64952 : if ( GT_16( idx, nt_half ) )
170 : {
171 81 : t = add( t, 1 << NBITS_CONTEXT ); /* Q0 */
172 : }
173 :
174 : /* Init current 2-tuple encoding */
175 64952 : if ( flag_overflow != 0 )
176 : {
177 0 : x[a1_i] = 0;
178 0 : move16();
179 : }
180 64952 : if ( flag_overflow != 0 )
181 : {
182 0 : x[b1_i] = 0;
183 0 : move16();
184 : }
185 :
186 64952 : a1 = abs_s( x[a1_i] ); /* Q0 */
187 64952 : b1 = abs_s( x[b1_i] ); /* Q0 */
188 :
189 64952 : lev1 = -1;
190 64952 : move16();
191 :
192 : /*Copy states*/
193 64952 : ari_copy_states_fx( &as, &as_overflow );
194 64952 : bp_overflow = bp; /* Q0 */
195 64952 : move16();
196 64952 : nbbits_signs_overflow = nbbits_signs; /* Q0 */
197 64952 : move16();
198 64952 : nbbits_lsbs_overflow = nbbits_lsbs; /* Q0 */
199 64952 : move16();
200 :
201 : /*Signs encoding*/
202 64952 : signs[nbbits_signs] = lshr( x[a1_i], 15 ); /* Q0 */
203 64952 : move16();
204 64952 : if ( a1 > 0 )
205 : {
206 17178 : nbbits_signs = add( nbbits_signs, 1 ); /* Q0 */
207 : }
208 64952 : signs[nbbits_signs] = lshr( x[b1_i], 15 ); /* Q0 */
209 64952 : move16();
210 64952 : if ( b1 > 0 )
211 : {
212 16890 : nbbits_signs = add( nbbits_signs, 1 ); /* Q0 */
213 : }
214 :
215 : /* MSBs coding */
216 68798 : WHILE( GE_16( s_max( a1, b1 ), A_THRES ) )
217 : {
218 3846 : tmp = add( t, Tab_esc_nb[lev1 + 1] ); /* Q0 */
219 3846 : assert( tmp >= 0 && tmp < 4096 );
220 3846 : pki = ari_lookup_s17_LC[tmp]; /* Q0 */
221 3846 : move16();
222 3846 : bp = ari_encode_14bits_ext_fx( ptr, bp, &as, VAL_ESC, ari_pk_s17_LC_ext[pki] ); /* Q0 */
223 :
224 3846 : *lsbs_bits2-- = s_and( a1, 1 );
225 3846 : move16();
226 3846 : *lsbs_bits2-- = s_and( b1, 1 );
227 3846 : move16();
228 :
229 : /* LSBs bit counting */
230 3846 : nbbits_lsbs = add( nbbits_lsbs, 2 ); /* Q0 */
231 :
232 3846 : a1 = shr( a1, 1 );
233 3846 : b1 = shr( b1, 1 );
234 :
235 3846 : lev1 = s_min( add( lev1, 1 ), 2 ); /* Q0 */
236 : }
237 :
238 64952 : tmp = add( t, Tab_esc_nb[lev1 + 1] ); /* Q0 */
239 64952 : assert( tmp >= 0 && tmp < 4096 );
240 64952 : pki = ari_lookup_s17_LC[tmp]; /* Q0 */
241 64952 : move16();
242 64952 : 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 64952 : 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 64952 : IF( EQ_16( p1, p2 ) ) /* peak-peak or hole-hole context */
296 : {
297 64699 : if ( lev1 > 0 )
298 899 : t = add( 12, lev1 );
299 64699 : if ( lev1 <= 0 )
300 63800 : t = add( a1, b1 );
301 64699 : if ( lev1 == 0 )
302 1723 : t = add( t, t );
303 :
304 64699 : *ctx = add( shl( s_and( *ctx, 0xf ), 4 ), add( t, 1 ) ); /* Q0 */
305 64699 : move16();
306 : }
307 : ELSE /* mixed context */
308 : {
309 253 : IF( s_and( idx1, 1 ) ) /* update first context */
310 : {
311 123 : c[p1] = update_mixed_context( c[p1], abs_s( x[a1_i] ) ); /* Q0 */
312 123 : move16();
313 : }
314 :
315 253 : IF( s_and( idx2, 1 ) ) /* update second context */
316 : {
317 130 : c[p2] = update_mixed_context( c[p2], abs_s( x[b1_i] ) ); /* Q0 */
318 130 : move16();
319 : }
320 : }
321 : } /*end of the 2-tuples loop*/
322 :
323 : /* End arithmetic coder, overflow management */
324 634 : bp = ari_done_encoding_14bits_fx( ptr, bp, &as ); /* Q0 */
325 :
326 : /* Overflow is detected */
327 634 : 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 634 : value = sub( shr( lastnz, 1 ), 1 ); /* Q0 */
346 634 : push_next_indice( hBstr, value, nbbits_ntuples );
347 :
348 : /* Push arithmetic coded bits */
349 634 : push_next_bits( hBstr, (UWord16 *) &ptr[nbbits_ntuples], sub( bp, nbbits_ntuples ) );
350 :
351 : /* Push sign bits */
352 634 : push_next_bits( hBstr, (UWord16 *) signs, nbbits_signs );
353 634 : bp = add( bp, nbbits_signs ); /* Q0 */
354 :
355 : /*write residual Quantization bits*/
356 634 : tmp = s_min( sub( sub( nbbits, bp ), nbbits_lsbs ), resQMaxBits ); /* Q0 */
357 6744 : FOR( k = 0; k < tmp; k++ )
358 : {
359 6110 : ptr[nbbits - 1 - nbbits_lsbs - k] = x[nt + k]; /* Q0 */
360 6110 : move16();
361 : }
362 : /* Write filler bits */
363 634 : tmp = sub( nbbits, add( bp, nbbits_lsbs ) ); /* Q0 */
364 1738 : FOR( ; k < tmp; ++k )
365 : {
366 1104 : ptr[nbbits - 1 - nbbits_lsbs - k] = 0;
367 1104 : 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 634 : assert( bp + k <= nbbits );
373 :
374 : /* Push the rest of the buffer */
375 634 : push_next_bits( hBstr, (UWord16 *) &ptr[bp], sub( nbbits, bp ) );
376 :
377 634 : return /*(bp+nbbits_lsbs)*/; /*return only for debug plot*/
378 : }
379 : /*-------------------------------------------------------------------*
380 : * find_last_nz_pair()
381 : *
382 : *
383 : *-------------------------------------------------------------------*/
384 4362 : 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 4362 : const Word16 *tmp = NULL;
391 :
392 4362 : if ( hm_cfg )
393 : {
394 1333 : tmp = hm_cfg->indexBuffer; /* Q0 */
395 1333 : move16();
396 : }
397 :
398 4362 : lobs[0] = 4;
399 4362 : move16();
400 4362 : lobs[1] = shr( length, 1 ); /* length/2 */
401 4362 : move16();
402 4362 : lobs[2] = add( lobs[1], shr( length, 2 ) ); /* Q0 */
403 4362 : move16();
404 4362 : lobs[3] = add( lobs[2], shr( length, 3 ) ); /* Q0 */
405 4362 : move16();
406 :
407 4362 : last_nz = 0;
408 4362 : move16();
409 4362 : i = length;
410 4362 : move16();
411 16701 : FOR( stage = 3; stage >= 0; --stage )
412 : {
413 16696 : IF( hm_cfg ) /* mapped kernel */
414 : {
415 313367 : FOR( ; i >= lobs[stage]; i -= 2 )
416 : {
417 308775 : if ( x[tmp[i - 2]] != 0 )
418 : {
419 15621 : last_nz = s_max( last_nz, i ); /* Q0 */
420 : }
421 308775 : if ( x[tmp[i - 1]] != 0 )
422 : {
423 15492 : last_nz = s_max( last_nz, i ); /* Q0 */
424 : }
425 : }
426 : }
427 : ELSE /* unmapped kernel */
428 : {
429 991459 : FOR( ; i >= lobs[stage]; i -= 2 )
430 : {
431 979355 : if ( x[i - 2] != 0 )
432 : {
433 79974 : last_nz = s_max( last_nz, i ); /* Q0 */
434 : }
435 979355 : if ( x[i - 1] != 0 )
436 : {
437 78374 : last_nz = s_max( last_nz, i ); /* Q0 */
438 : }
439 : }
440 : }
441 16696 : IF( last_nz > 0 )
442 : {
443 4357 : BREAK;
444 : }
445 : }
446 :
447 4362 : return s_max( last_nz, 2 );
448 : }
449 : /*-------------------------------------------------------------------*
450 : * ACcontextMapping_encode2_estimate_no_mem_s17_LC_fx()
451 : *
452 : *
453 : *-------------------------------------------------------------------*/
454 4362 : 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 4362 : Word16 numPeakIndicesOrig = 0, numHoleIndices = 0; /* initialize just to avoid compiler warning */
480 4362 : move16();
481 4362 : move16();
482 : get_next_coeff_function get_next_coeff;
483 :
484 :
485 : /* Rate flag */
486 4362 : rateFlag = 0;
487 4362 : move16();
488 4362 : if ( GT_16( target, 400 ) )
489 : {
490 225 : rateFlag = 2 << NBITS_CONTEXT; /* Q0 */
491 225 : move16();
492 : }
493 :
494 : /* proba coded on 14bits -> proba=1 */
495 4362 : proba = L_deposit_l( 16384 ); /* Q0 */
496 :
497 : /* Init */
498 4362 : nt_half = shr( nt, 1 );
499 4362 : stop2 = 0;
500 4362 : move16();
501 4362 : c[0] = c[1] = 0;
502 4362 : move16();
503 4362 : move16();
504 :
505 : /* bits to encode lastnz + 2 bits headroom */
506 4362 : nbits = sub( 2 + 14, norm_s( sub( nt, 1 ) ) ); /* Q0 */
507 4362 : nbits_old = nbits; /* Q0 */
508 4362 : move16();
509 4362 : nbits = sub( nbits, target ); /* Q0 */
510 :
511 : /* Find last non-zero tuple in the mapped domain signal */
512 4362 : lastnz = find_last_nz_pair( x, nt, hm_cfg ); /* Q0 */
513 :
514 : /* At least one tuple is coded */
515 4362 : lastnz2 = 2;
516 4362 : move16();
517 :
518 4362 : IF( hm_cfg ) /* mapped domain */
519 : {
520 1333 : numPeakIndicesOrig = hm_cfg->numPeakIndices; /* Q0 */
521 1333 : move16();
522 1333 : hm_cfg->numPeakIndices = s_min( hm_cfg->numPeakIndices, lastnz ); /* Q0 */
523 1333 : move16();
524 1333 : numHoleIndices = sub( lastnz, hm_cfg->numPeakIndices ); /* Q0 */
525 :
526 : /* Mark hole indices beyond lastnz as pruned */
527 421521 : FOR( k = numHoleIndices; k < hm_cfg->numHoleIndices; ++k )
528 : {
529 420188 : hm_cfg->holeIndices[k] = add( hm_cfg->holeIndices[k], nt ); /* Q0 */
530 420188 : move16();
531 : }
532 :
533 1333 : ii[0] = numPeakIndicesOrig; /* Q0 */
534 1333 : move16();
535 1333 : ii[1] = 0;
536 1333 : move16();
537 :
538 1333 : get_next_coeff = get_next_coeff_mapped; /* Q0 */
539 1333 : move16();
540 : }
541 : ELSE /* unmapped domain */
542 : {
543 3029 : ii[0] = 0;
544 3029 : move16();
545 :
546 3029 : p1 = p2 = 0;
547 3029 : move16();
548 3029 : move16();
549 :
550 3029 : get_next_coeff = get_next_coeff_unmapped; /* Q0 */
551 3029 : move16();
552 : }
553 :
554 : /* Main Loop through the 2-tuples */
555 491124 : FOR( k = 0; k < lastnz; k += 2 )
556 : {
557 : /* First coefficient */
558 487298 : a1_i = get_next_coeff( ii, &p1, &idx1, hm_cfg ); /* Q0 */
559 :
560 : /* Second coefficient */
561 487298 : b1_i = get_next_coeff( ii, &p2, &idx2, hm_cfg ); /* Q0 */
562 :
563 487298 : idx = s_min( idx1, idx2 ); /* Q0 */
564 :
565 : /* Get context */
566 487298 : ctx = &c[s_or( p1, p2 )]; /* Q0 */
567 :
568 487298 : t = add( *ctx, rateFlag ); /* Q0 */
569 487298 : if ( GT_16( idx, nt_half ) )
570 : {
571 18213 : t = add( t, 1 << NBITS_CONTEXT ); /* Q0 */
572 : }
573 :
574 : /* Init current 2-tuple encoding */
575 487298 : a1 = abs_s( x[a1_i] ); /* Q0 */
576 487298 : b1 = abs_s( x[b1_i] ); /* Q0 */
577 :
578 487298 : lev1 = -( 1 << ( NBITS_CONTEXT + NBITS_RATEQ ) );
579 487298 : move16();
580 : /* Signs Bits */
581 487298 : if ( a1 > 0 )
582 : {
583 115475 : nbits = add( nbits, 1 ); /* Q0 */
584 : }
585 :
586 487298 : if ( b1 > 0 )
587 : {
588 113806 : 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 487298 : lookup = (const Word8 *) ( &ari_lookup_s17_LC[t] + ( 1 << ( NBITS_CONTEXT + NBITS_RATEQ ) ) ); /* address calculation not counted */
597 513662 : WHILE( GE_16( s_max( a1, b1 ), A_THRES ) )
598 : {
599 26364 : pki = lookup[lev1];
600 26364 : move16();
601 26364 : 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 26364 : cum_freq_norm_e = norm_s( cum_freq[0] );
605 26364 : cum_freq_norm = shl( cum_freq[0], cum_freq_norm_e );
606 26364 : proba = Mpy_32_16_1( proba, cum_freq_norm );
607 26364 : 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 26364 : nlz = sub( norm_l( proba ), 2 );
611 26364 : proba = L_shl( proba, sub( nlz, 15 ) ); /* cum_freq_norm_e */
612 :
613 26364 : 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 26364 : a1 = shr( a1, 1 );
618 26364 : b1 = shr( b1, 1 );
619 26364 : lev1 = s_min( add( lev1, 1 << ( NBITS_CONTEXT + NBITS_RATEQ ) ), 2 << ( NBITS_CONTEXT + NBITS_RATEQ ) ); /* Q0 */
620 : }
621 :
622 487298 : pki = lookup[lev1]; /* Q0 */
623 487298 : move16();
624 487298 : symbol = add( a1, shl( b1, A_THRES_SHIFT ) ); /* Q0 */
625 487298 : 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 487298 : cum_freq_norm = sub( cum_freq[0], cum_freq[1] );
629 487298 : cum_freq_norm_e = norm_s( cum_freq_norm );
630 487298 : cum_freq_norm = shl( cum_freq_norm, cum_freq_norm_e );
631 487298 : proba = Mpy_32_16_1( proba, cum_freq_norm );
632 487298 : 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 487298 : nlz = sub( norm_l( proba ), 3 );
636 487298 : proba = L_shl( proba, sub( nlz, 14 ) ); /* cum_freq_norm_e */
637 :
638 487298 : 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 487298 : IF( nbits > 0 )
645 : {
646 49833 : stop2 = 1;
647 49833 : move16();
648 :
649 49833 : IF( *stop )
650 : {
651 536 : BREAK;
652 : }
653 : }
654 : ELSE
655 : {
656 437465 : test();
657 437465 : test();
658 437465 : IF( hm_cfg || k == 0 || s_or( x[a1_i], x[b1_i] ) )
659 : {
660 265866 : nbits_old = add( nbits, target ); /* Q0 */
661 265866 : lastnz2 = add( b1_i, 1 ); /* Q0 */
662 : }
663 : }
664 :
665 : /* Update context for next 2-tuple */
666 486762 : IF( EQ_16( p1, p2 ) ) /* peak-peak or hole-hole context */
667 : {
668 461700 : lev1 = shr( lev1, NBITS_CONTEXT + NBITS_RATEQ ); /* Q0 */
669 461700 : if ( lev1 > 0 )
670 5926 : t = add( 12, lev1 );
671 461700 : if ( lev1 <= 0 )
672 455774 : t = add( a1, b1 );
673 461700 : if ( lev1 == 0 )
674 11266 : t = add( t, t );
675 :
676 461700 : *ctx = add( shl( s_and( *ctx, 0xf ), 4 ), add( t, 1 ) ); /* Q0 */
677 461700 : move16();
678 : }
679 : ELSE /* mixed context */
680 : {
681 25062 : IF( s_and( idx1, 1 ) ) /* update first context */
682 : {
683 12455 : c[p1] = update_mixed_context( c[p1], abs_s( x[a1_i] ) ); /* Q0 */
684 12455 : move16();
685 : }
686 :
687 25062 : IF( s_and( idx2, 1 ) ) /* update second context */
688 : {
689 12514 : c[p2] = update_mixed_context( c[p2], abs_s( x[b1_i] ) ); /* Q0 */
690 12514 : move16();
691 : }
692 : }
693 : } /* end of the 2-tuples loop */
694 :
695 4362 : nbits = add( nbits, target ); /* Q0 */
696 :
697 : /* Output */
698 4362 : if ( *stop )
699 : {
700 596 : nbits = nbits_old; /* Q0 */
701 596 : move16();
702 : }
703 :
704 4362 : if ( stop2 )
705 : {
706 2390 : stop2 = nbits; /* Q0 */
707 2390 : move16();
708 : }
709 4362 : *nEncoded = lastnz2; /* Q0 */
710 4362 : move16();
711 4362 : *stop = stop2; /* Q0 */
712 4362 : move16();
713 4362 : if ( lastnz_out )
714 : {
715 4362 : *lastnz_out = lastnz; /* Q0 */
716 4362 : move16();
717 : }
718 :
719 4362 : IF( hm_cfg )
720 : {
721 : /* Restore hole indices beyond lastnz */
722 421521 : FOR( k = numHoleIndices; k < hm_cfg->numHoleIndices; ++k )
723 : {
724 420188 : hm_cfg->holeIndices[k] = sub( hm_cfg->holeIndices[k], nt ); /* Q0 */
725 420188 : move16();
726 : }
727 1333 : hm_cfg->numPeakIndices = numPeakIndicesOrig; /* Q0 */
728 1333 : move16();
729 : }
730 :
731 :
732 4362 : 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 876812 : 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 876812 : a1 = 0; /* to avoid compilation warnings */
767 876812 : b1 = 0; /* to avoid compilation warnings */
768 876812 : move16();
769 876812 : move16();
770 :
771 : /* Init */
772 876812 : nt_half = shr( nt, 1 );
773 :
774 : /* Bits for encoding the number of encoded tuples */
775 876812 : nbbits_ntuples = 0;
776 876812 : k = 1;
777 876812 : move16();
778 876812 : move16();
779 :
780 8666021 : WHILE( LT_16( k, shr( nt, 1 ) ) )
781 : {
782 7789209 : nbbits_ntuples = add( nbbits_ntuples, 1 ); /* Q0 */
783 7789209 : k = shl( k, 1 );
784 : }
785 :
786 876812 : t = 0;
787 876812 : nbbits_signs = 0;
788 876812 : nbbits_lsbs = 0;
789 876812 : move16();
790 876812 : move16();
791 876812 : move16();
792 :
793 876812 : 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 12700 : IF( GT_16( nbbits, 400 ) )
804 : {
805 6027 : rateFlag = 2 << NBITS_CONTEXT;
806 6027 : move16();
807 : }
808 : ELSE
809 : {
810 6673 : rateFlag = 0;
811 6673 : move16();
812 : }
813 :
814 12700 : c[0] = c[1] = 0;
815 12700 : move32();
816 12700 : move32();
817 :
818 : /* mapped domain */
819 12700 : numPeakIndicesOrig = hm_cfg->numPeakIndices; /* Q0 */
820 12700 : hm_cfg->numPeakIndices = s_min( hm_cfg->numPeakIndices, lastnz ); /* Q0 */
821 12700 : numHoleIndices = sub( lastnz, hm_cfg->numPeakIndices ); /* Q0 */
822 12700 : move16();
823 12700 : move16();
824 :
825 : /* Mark hole indices beyond lastnz as pruned */
826 5512055 : FOR( k = numHoleIndices; k < hm_cfg->numHoleIndices; ++k )
827 : {
828 5499355 : hm_cfg->holeIndices[k] = add( hm_cfg->holeIndices[k], nt ); /* Q0 */
829 5499355 : move16();
830 : }
831 :
832 12700 : ii[0] = numPeakIndicesOrig; /* Q0 */
833 12700 : ii[1] = 0;
834 12700 : move16();
835 12700 : move16();
836 :
837 12700 : p1 = p2 = 0; /* to avoid compilation warnings */
838 12700 : move16();
839 12700 : move16();
840 :
841 12700 : lsbs_bits = ptr + sub( nbbits, 1 );
842 :
843 : /*Start Encoding*/
844 : /* Initialize range encoder */
845 12700 : rc_uni_enc_init_fx( &rc_st_enc );
846 :
847 : /*Main Loop through the 2-tuples*/
848 12700 : b1_i = -1;
849 12700 : move16();
850 :
851 2322197 : FOR( k = 0; k < lastnz; k += 2 )
852 : {
853 2309497 : a1_i = get_next_coeff_mapped_ivas_fx( ii, &p1, &idx1, hm_cfg ); /* Q0 */
854 2309497 : b1_i = get_next_coeff_mapped_ivas_fx( ii, &p2, &idx2, hm_cfg ); /* Q0 */
855 :
856 2309497 : idx = s_min( idx1, idx2 ); /* Q0 */
857 :
858 : /* Get context */
859 2309497 : ctx = &c[L_or( p1, p2 )]; /* Q0 */
860 :
861 2309497 : t = (UWord16) L_add( *ctx, rateFlag ); /* Q0 */
862 : // t += ( nt_half >= idx ) ? 0 : ( 1 << NBITS_CONTEXT );
863 2309497 : IF( LT_16( nt_half, idx ) )
864 : {
865 273506 : t = add( t, ( 1 << NBITS_CONTEXT ) );
866 : }
867 :
868 : /* Init current 2-tuple encoding */
869 2309497 : a1 = abs_s( x[a1_i] ); /* Q0 */
870 2309497 : b1 = abs_s( x[b1_i] ); /* Q0 */
871 :
872 2309497 : lev1 = -1;
873 2309497 : move16();
874 :
875 : /*Signs encoding*/
876 2309497 : IF( a1 > 0 )
877 : {
878 : // signs[nbbits_signs++] = ( (uint16_t) x[a1_i] >> ( sizeof( uint16_t ) * 8 - 1 ) );
879 609874 : if ( x[a1_i] >= 0 )
880 : {
881 307120 : signs[nbbits_signs] = 0;
882 307120 : move16();
883 : }
884 609874 : if ( x[a1_i] < 0 )
885 : {
886 302754 : signs[nbbits_signs] = 1;
887 302754 : move16();
888 : }
889 609874 : nbbits_signs = add( nbbits_signs, 1 ); /* Q0 */
890 : }
891 :
892 2309497 : IF( b1 > 0 )
893 : {
894 : // signs[nbbits_signs++] = ( (uint16_t) x[b1_i] >> ( sizeof( uint16_t ) * 8 - 1 ) );
895 604673 : if ( x[b1_i] >= 0 )
896 : {
897 301544 : signs[nbbits_signs] = 0;
898 301544 : move16();
899 : }
900 604673 : if ( x[b1_i] < 0 )
901 : {
902 303129 : signs[nbbits_signs] = 1;
903 303129 : move16();
904 : }
905 604673 : nbbits_signs = add( nbbits_signs, 1 ); /* Q0 */
906 : }
907 :
908 : /* MSBs coding */
909 2615397 : WHILE( GE_16( s_max( a1, b1 ), A_THRES ) )
910 : {
911 305900 : pki = ari_lookup_s17_LC[t + ( ( lev1 + 1 ) << ( NBITS_CONTEXT + NBITS_RATEQ ) )]; /* Q0 */
912 305900 : move16();
913 305900 : 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 305900 : *lsbs_bits-- = s_and( a1, 1 );
916 305900 : *lsbs_bits-- = s_and( b1, 1 );
917 305900 : move16();
918 305900 : move16();
919 :
920 : /* LSBs bit counting */
921 305900 : nbbits_lsbs = add( nbbits_lsbs, 2 ); /* Q0 */
922 :
923 305900 : a1 = shr( a1, 1 );
924 305900 : b1 = shr( b1, 1 );
925 :
926 305900 : lev1 = s_min( add( lev1, 1 ), 2 ); /* Q0 */
927 : }
928 :
929 2309497 : pki = ari_lookup_s17_LC[t + ( ( lev1 + 1 ) << ( NBITS_CONTEXT + NBITS_RATEQ ) )]; /* Q0 */
930 2309497 : move16();
931 2309497 : 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 2309497 : IF( EQ_32( p1, p2 ) )
937 : {
938 : /* peak-peak or hole-hole context */
939 :
940 2099549 : IF( lev1 <= 0 )
941 : {
942 2041707 : t = (UWord16) L_add( 1, L_mult0( add( a1, b1 ), add( lev1, 2 ) ) ); /* Q0 */
943 : }
944 : ELSE
945 : {
946 57842 : t = (UWord16) L_add( 13, lev1 ); /* Q0 */
947 : }
948 :
949 2099549 : *ctx = L_add( L_shl( L_and( *ctx, 0xf ), 4 ), t ); /* Q0 */
950 2099549 : move32();
951 : }
952 : ELSE
953 : {
954 : /* mixed context */
955 :
956 209948 : IF( s_and( idx1, 1 ) )
957 : {
958 : /* update first context */
959 99889 : c[p1] = update_mixed_context_ivas_fx( c[p1], abs_s( x[a1_i] ) ); /* Q0 */
960 99889 : move32();
961 : }
962 :
963 209948 : IF( s_and( idx2, 1 ) )
964 : {
965 : /* update second context */
966 110059 : c[p2] = update_mixed_context_ivas_fx( c[p2], abs_s( x[b1_i] ) ); /* Q0 */
967 110059 : 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 864112 : IF( GT_16( nbbits, 400 ) )
981 : {
982 610109 : rateFlag = 2;
983 610109 : move16();
984 : }
985 : ELSE
986 : {
987 254003 : rateFlag = 0;
988 254003 : move16();
989 : }
990 :
991 864112 : s = 0;
992 864112 : move16();
993 :
994 : /* Find last non-zero tuple */
995 : /* ensure termination of while loop by dummy value */
996 864112 : a1 = x[0];
997 864112 : x[0] = 1; /* ensure first tuple is non-zero */
998 864112 : move16();
999 864112 : move16();
1000 :
1001 7412644 : WHILE( x[lastnz - 1] == 0 && x[lastnz - 2] == 0 )
1002 : {
1003 6548532 : test();
1004 6548532 : lastnz = sub( lastnz, 2 ); /* Q0 */
1005 : }
1006 864112 : x[0] = a1;
1007 864112 : move16();
1008 :
1009 864112 : lsbs_bits = ptr + sub( nbbits, 1 );
1010 :
1011 : /*Start Encoding*/
1012 : /* Initialize range encoder */
1013 864112 : rc_uni_enc_init_fx( &rc_st_enc );
1014 :
1015 : /*Main Loop through the 2-tuples*/
1016 182174899 : FOR( k = 0; k < lastnz; k += 2 )
1017 : {
1018 :
1019 : /* Init current 2-tuple encoding */
1020 181310787 : a1 = abs_s( x[k + 0] ); /* Q0 */
1021 181310787 : b1 = abs_s( x[k + 1] ); /* Q0 */
1022 :
1023 181310787 : lev1 = 0;
1024 181310787 : esc_nb = 0;
1025 181310787 : move16();
1026 181310787 : move16();
1027 :
1028 : /*Signs encoding*/
1029 181310787 : IF( a1 > 0 )
1030 : {
1031 : // signs[nbbits_signs++] = ( (uint16_t) x[k + 0] >> ( sizeof( uint16_t ) * 8 - 1 ) );
1032 73478112 : if ( x[k] >= 0 )
1033 : {
1034 36747982 : signs[nbbits_signs] = 0;
1035 36747982 : move16();
1036 : }
1037 73478112 : if ( x[k] < 0 )
1038 : {
1039 36730130 : signs[nbbits_signs] = 1;
1040 36730130 : move16();
1041 : }
1042 73478112 : nbbits_signs = add( nbbits_signs, 1 ); /* Q0 */
1043 : }
1044 :
1045 181310787 : IF( b1 > 0 )
1046 : {
1047 : // signs[nbbits_signs++] = ( (uint16_t) x[k + 1] >> ( sizeof( uint16_t ) * 8 - 1 ) );
1048 73270214 : if ( x[k + 1] >= 0 )
1049 : {
1050 36544837 : signs[nbbits_signs] = 0;
1051 36544837 : move16();
1052 : }
1053 73270214 : if ( x[k + 1] < 0 )
1054 : {
1055 36725377 : signs[nbbits_signs] = 1;
1056 36725377 : move16();
1057 : }
1058 73270214 : nbbits_signs = add( nbbits_signs, 1 ); /* Q0 */
1059 : }
1060 :
1061 181310787 : rateQ = add( rateFlag, extract_l( GT_16( k, shr( nt, 1 ) ) ) );
1062 :
1063 : /* MSBs coding */
1064 214366861 : WHILE( GE_16( s_max( a1, b1 ), A_THRES ) )
1065 : {
1066 33056074 : pki = ari_lookup_s17_LC[t + ( ( rateQ ) << NBITS_CONTEXT ) + ( esc_nb << ( NBITS_CONTEXT + NBITS_RATEQ ) )];
1067 33056074 : move16();
1068 33056074 : 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 33056074 : *lsbs_bits-- = s_and( a1, 1 );
1071 33056074 : *lsbs_bits-- = s_and( b1, 1 );
1072 33056074 : move16();
1073 33056074 : move16();
1074 :
1075 : /* LSBs bit counting */
1076 33056074 : nbbits_lsbs = add( nbbits_lsbs, 2 ); /* Q0 */
1077 :
1078 33056074 : a1 = shr( a1, 1 );
1079 33056074 : b1 = shr( b1, 1 );
1080 :
1081 33056074 : lev1 = add( lev1, 1 ); /* Q0 */
1082 33056074 : esc_nb = s_min( lev1, 3 ); /* Q0 */
1083 : }
1084 :
1085 181310787 : move16();
1086 :
1087 181310787 : pki = ari_lookup_s17_LC[t + ( ( rateQ ) << NBITS_CONTEXT ) + ( esc_nb << ( NBITS_CONTEXT + NBITS_RATEQ ) )]; /* Q0 */
1088 181310787 : 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 181310787 : IF( LT_16( esc_nb, 2 ) )
1094 : {
1095 173156963 : cp = add( 1, imult1616( add( a1, b1 ), add( esc_nb, 1 ) ) ); /* Q0 */
1096 : }
1097 : ELSE
1098 : {
1099 8153824 : cp = add( 12, esc_nb ); /* Q0 */
1100 : }
1101 :
1102 : /*Shift old 4 bits, replace last 4 bits*/
1103 181310787 : s = (UWord16) ( L_add( L_shl( s, 4 ), cp ) );
1104 181310787 : t = (UWord16) L_and( s, 0xFF );
1105 :
1106 : } /*end of the 2-tuples loop*/
1107 : }
1108 :
1109 : /* Finish range encoder */
1110 876812 : rc_tot_bits = rc_uni_enc_finish_fx( &rc_st_enc ); /* No. of bits consumed by range coder Q0*/
1111 876812 : 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 876812 : value = sub( shr( lastnz, 1 ), 1 ); /* Q0 */
1117 876812 : 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 66089486 : FOR( k = 0; k < ( rc_tot_bits >> 3 ); k++ )
1122 : {
1123 65212674 : push_next_indice( hBstr, rc_st_enc.byte_buffer[k], 8 );
1124 : }
1125 : /* 2) Push remaining bits */
1126 876812 : IF( s_and( rc_tot_bits, 7 ) != 0 )
1127 : {
1128 767571 : 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 876812 : push_next_bits( hBstr, (UWord16 *) signs, nbbits_signs );
1133 876812 : bp = add( bp, nbbits_signs ); /* Q0 */
1134 :
1135 : /*write residual Quantization bits*/
1136 :
1137 4896383 : FOR( k = 0; k < s_min( nbbits - bp - nbbits_lsbs, resQMaxBits ); k++ )
1138 : {
1139 4019571 : ptr[nbbits - 1 - nbbits_lsbs - k] = x[nt + k]; /* Q0 */
1140 4019571 : move16();
1141 : }
1142 : /* Write filler bits */
1143 19683404 : FOR( ; k < nbbits - bp - nbbits_lsbs; ++k )
1144 : {
1145 18806592 : ptr[nbbits - 1 - nbbits_lsbs - k] = 0;
1146 18806592 : move16();
1147 : }
1148 :
1149 : /* Check for debugging */
1150 876812 : assert( bp + k <= nbbits );
1151 :
1152 : /* Push the rest of the buffer */
1153 876812 : push_next_bits( hBstr, (UWord16 *) &ptr[bp], sub( nbbits, bp ) );
1154 :
1155 : /* return (bp+nbbits_lsbs);*/ /*return only for debug plot*/
1156 876812 : return;
1157 : }
1158 :
1159 : /*-------------------------------------------------------------------*
1160 : * find_last_nz_pair_fx()
1161 : *
1162 : *
1163 : *-------------------------------------------------------------------*/
1164 :
1165 399863 : 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 399863 : last_nz = 2;
1174 399863 : move16();
1175 :
1176 399863 : IF( hm_cfg )
1177 : {
1178 : /* mapped kernel */
1179 399863 : tmp = hm_cfg->indexBuffer;
1180 :
1181 68472092 : FOR( i = length; i >= 4; i -= 2 )
1182 : {
1183 68468033 : test();
1184 68468033 : IF( x[tmp[i - 2]] || x[tmp[i - 1]] )
1185 : {
1186 395804 : last_nz = i; /* Q0 */
1187 395804 : move16();
1188 395804 : 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 399863 : 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 3996527 : 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 3996527 : bit_estimate_fx = MAKE_NUMBER_QX( 2, Q23 );
1243 3996527 : move64();
1244 :
1245 3996527 : nbits2_fx = 0;
1246 3996527 : move64();
1247 :
1248 : /* bits to encode lastnz */
1249 3996527 : k = 1;
1250 3996527 : move16();
1251 :
1252 : Word16 round_bit_estimate_fx;
1253 3996527 : Word32 target_Q15 = L_shl( target, Q15 ); // Q15
1254 :
1255 39284155 : WHILE( LT_16( k, nt / 2 ) )
1256 : {
1257 35287628 : bit_estimate_fx = W_add( bit_estimate_fx, MAKE_NUMBER_QX( 1, Q23 ) );
1258 35287628 : k = shl( k, 1 );
1259 : /* check while condition */
1260 : }
1261 :
1262 3996527 : nbits2_fx = bit_estimate_fx;
1263 3996527 : move64();
1264 :
1265 3996527 : IF( hm_cfg )
1266 : {
1267 : Word16 a1_i, b1_i;
1268 : Word16 stop2;
1269 : Word16 total_output_bits;
1270 : Word16 nt_half;
1271 : Word32 c[2], *ctx;
1272 : Word32 p1, p2;
1273 : Word16 ii[2];
1274 : Word16 idx1, idx2, idx;
1275 399863 : Word16 numPeakIndicesOrig = 0, numHoleIndices = 0; /* only to avoid compiler warning */
1276 399863 : move16();
1277 399863 : move16();
1278 :
1279 : /* Rate flag */
1280 399863 : IF( GT_16( target, 400 ) )
1281 : {
1282 248040 : rateFlag = 2 << NBITS_CONTEXT; /* Select context-A for higher bitrates */
1283 248040 : move16();
1284 : }
1285 : ELSE
1286 : {
1287 151823 : rateFlag = 0; /* Select context-B for lower bitrates */
1288 151823 : move16();
1289 : }
1290 :
1291 399863 : nt_half = shr( nt, 1 );
1292 399863 : move16();
1293 399863 : stop2 = 0;
1294 399863 : move16();
1295 399863 : c[0] = c[1] = 0;
1296 399863 : move32();
1297 399863 : move32();
1298 :
1299 : /* Find last non-zero tuple in the mapped domain signal */
1300 399863 : lastnz = find_last_nz_pair_fx( x, nt, hm_cfg );
1301 :
1302 399863 : lastnz2 = 2;
1303 399863 : move16();
1304 :
1305 : /* mapped domain */
1306 399863 : numPeakIndicesOrig = hm_cfg->numPeakIndices; /* Q0 */
1307 399863 : move16();
1308 399863 : hm_cfg->numPeakIndices = s_min( hm_cfg->numPeakIndices, lastnz ); /* Q0 */
1309 399863 : move16();
1310 399863 : numHoleIndices = sub( lastnz, hm_cfg->numPeakIndices ); /* Q0 */
1311 :
1312 : /* Mark hole indices beyond lastnz as pruned */
1313 134658777 : FOR( k = numHoleIndices; k < hm_cfg->numHoleIndices; ++k )
1314 : {
1315 134258914 : hm_cfg->holeIndices[k] = add( hm_cfg->holeIndices[k], nt ); /* Q0 */
1316 134258914 : move16();
1317 : }
1318 :
1319 399863 : ii[0] = numPeakIndicesOrig; /* Q0 */
1320 399863 : move16();
1321 399863 : ii[1] = 0;
1322 399863 : move16();
1323 :
1324 399863 : p1 = p2 = 0; /* to avoid compilation warnings */
1325 399863 : move32();
1326 399863 : move32();
1327 :
1328 : /* Main Loop through the 2-tuples */
1329 83533940 : FOR( k = 0; k < lastnz; k += 2 )
1330 : {
1331 83291083 : a1_i = get_next_coeff_mapped_ivas_fx( ii, &p1, &idx1, hm_cfg ); /* Q0 */
1332 83291083 : b1_i = get_next_coeff_mapped_ivas_fx( ii, &p2, &idx2, hm_cfg ); /* Q0 */
1333 :
1334 83291083 : idx = s_min( idx1, idx2 );
1335 :
1336 : /* Get context */
1337 83291083 : ctx = &c[L_or( p1, p2 )];
1338 :
1339 83291083 : t = (UWord16) L_add( *ctx, rateFlag );
1340 83291083 : if ( LT_16( nt_half, idx ) )
1341 : {
1342 14992648 : t = add( t, ( 1 << NBITS_CONTEXT ) );
1343 : }
1344 :
1345 : /* Init current 2-tuple encoding */
1346 83291083 : a1 = abs_s( x[a1_i] );
1347 83291083 : b1 = abs_s( x[b1_i] );
1348 83291083 : lev1 = -( 1 << ( NBITS_CONTEXT + NBITS_RATEQ ) );
1349 :
1350 83291083 : bit_estimate_fx = W_add( bit_estimate_fx, MAKE_VARIABLE_QX( s_min( a1, 1 ), Q23 ) );
1351 83291083 : bit_estimate_fx = W_add( bit_estimate_fx, MAKE_VARIABLE_QX( s_min( b1, 1 ), Q23 ) );
1352 : /* pre-compute address of ari_pk_s17_LC_ext[0][Val_esc] to avoid doing it multiple times inside the loop */
1353 83291083 : lookup = &ari_lookup_s17_LC[t] + ( 1 << ( NBITS_CONTEXT + NBITS_RATEQ ) );
1354 :
1355 : /* check while condition */
1356 : /* MSBs coding */
1357 92732332 : FOR( ; s_max( a1, b1 ) >= A_THRES; )
1358 : {
1359 9441249 : pki = lookup[lev1]; /* ESC symbol */
1360 :
1361 9441249 : bit_estimate_fx = W_add( bit_estimate_fx, ari_bit_estimate_s17_LC_fx[pki][VAL_ESC] );
1362 9441249 : bit_estimate_fx = W_add( bit_estimate_fx, MAKE_VARIABLE_QX( 2, Q23 ) );
1363 9441249 : a1 = shr( a1, 1 );
1364 9441249 : b1 = shr( b1, 1 );
1365 :
1366 9441249 : lev1 = s_min( add( lev1, ( 1 << ( NBITS_CONTEXT + NBITS_RATEQ ) ) ), 2 << ( NBITS_CONTEXT + NBITS_RATEQ ) );
1367 : }
1368 83291083 : pki = lookup[lev1];
1369 :
1370 83291083 : symbol = add( a1, i_mult( A_THRES, b1 ) ); /* Q0 */
1371 83291083 : bit_estimate_fx = W_add( bit_estimate_fx, ari_bit_estimate_s17_LC_fx[pki][symbol] );
1372 :
1373 83291083 : IF( GT_32( W_shl_sat_l( bit_estimate_fx, -Q8 ), target_Q15 ) ) // Q15
1374 : {
1375 13819189 : stop2 = 1;
1376 13819189 : move16();
1377 :
1378 13819189 : IF( *stop )
1379 : {
1380 157006 : BREAK;
1381 : }
1382 : }
1383 : ELSE
1384 : {
1385 69471894 : lastnz2 = add( b1_i, 1 );
1386 69471894 : nbits2_fx = bit_estimate_fx;
1387 69471894 : move64();
1388 : }
1389 :
1390 : /* Update context for next 2-tuple */
1391 83134077 : IF( EQ_32( p1, p2 ) ) /* peak-peak or hole-hole context */
1392 : {
1393 68304587 : lev1 = shr( lev1, NBITS_CONTEXT + NBITS_RATEQ );
1394 :
1395 68304587 : t = add( 13, lev1 );
1396 68304587 : IF( lev1 <= 0 )
1397 : {
1398 66633044 : t = add( 1, i_mult( add( a1, b1 ), add( lev1, 2 ) ) );
1399 : }
1400 :
1401 68304587 : *ctx = L_add( imult3216( L_and( *ctx, 0xf ), 16 ), t );
1402 68304587 : move32();
1403 : }
1404 : ELSE
1405 : {
1406 : /* mixed context */
1407 :
1408 14829490 : IF( s_and( idx1, 1 ) )
1409 : {
1410 : /* update first context */
1411 7409994 : c[p1] = update_mixed_context_ivas_fx( c[p1], abs_s( x[a1_i] ) ); /* Q0 */
1412 7409994 : move32();
1413 : }
1414 :
1415 14829490 : IF( s_and( idx2, 1 ) )
1416 : {
1417 : /* update second context */
1418 7398810 : c[p2] = update_mixed_context_ivas_fx( c[p2], abs_s( x[b1_i] ) ); /* Q0 */
1419 7398810 : move32();
1420 : }
1421 : }
1422 :
1423 : } /*end of the 2-tuples loop*/
1424 399863 : total_output_bits = round_fx( W_shl_sat_l( bit_estimate_fx, -Q7 ) ); /* Q23 -> Q16 -> Q0 */
1425 399863 : IF( *stop )
1426 : {
1427 168904 : total_output_bits = round_fx( W_shl_sat_l( nbits2_fx, -Q7 ) ); /* Q23 -> Q16 -> Q0 */
1428 : }
1429 :
1430 399863 : if ( stop2 )
1431 : {
1432 326632 : stop2 = total_output_bits; /* Q0 */
1433 326632 : move16();
1434 : }
1435 :
1436 399863 : *nEncoded = lastnz2; /* Q0 */
1437 399863 : move16();
1438 399863 : *stop = stop2; /* If zero, it means no overflow occured during bit-estimation Q0*/
1439 399863 : move16();
1440 399863 : *lastnz_out = lastnz; /* Q0 */
1441 399863 : move16();
1442 :
1443 : /* Restore hole indices beyond lastnz */
1444 134658777 : FOR( k = numHoleIndices; k < hm_cfg->numHoleIndices; ++k )
1445 : {
1446 134258914 : hm_cfg->holeIndices[k] = sub( hm_cfg->holeIndices[k], nt ); /* Q0 */
1447 134258914 : move16();
1448 : }
1449 399863 : hm_cfg->numPeakIndices = numPeakIndicesOrig; /* Q0 */
1450 399863 : move16();
1451 :
1452 399863 : return round_fx( L_add( W_shl_sat_l( nbits2_fx, -Q7 ), ONE_IN_Q14 ) ); /* Q0 */
1453 : }
1454 : ELSE /* if (!hm_cfg) */
1455 : {
1456 : Word16 esc_nb, cp, rateQ;
1457 : UWord16 s;
1458 : Word16 tot_bits2;
1459 3596664 : Word16 overflow_flag = 0;
1460 3596664 : move16();
1461 :
1462 : /* Rate flag */
1463 3596664 : IF( GT_16( target, 400 ) )
1464 : {
1465 2677415 : rateFlag = 2; /* Q0 */
1466 2677415 : move16();
1467 : }
1468 : ELSE
1469 : {
1470 919249 : rateFlag = 0; /* Select context-B for lower bitrates */
1471 919249 : move16();
1472 : }
1473 :
1474 3596664 : t = 0;
1475 3596664 : move16();
1476 3596664 : s = 0;
1477 3596664 : move16();
1478 3596664 : cp = 0;
1479 3596664 : move16();
1480 3596664 : lastnz = 1;
1481 3596664 : move16();
1482 3596664 : lastnz2 = 0;
1483 3596664 : move16();
1484 3596664 : tot_bits2 = 0;
1485 3596664 : move16();
1486 :
1487 : /* Find last non-zero tuple in the mapped domain signal */
1488 616184191 : FOR( lastnz = sub( nt, 2 ); lastnz >= 0; lastnz -= 2 )
1489 : {
1490 616170405 : test();
1491 616170405 : IF( ( x[lastnz] != 0 ) || ( x[lastnz + 1] != 0 ) )
1492 : {
1493 : BREAK;
1494 : }
1495 : }
1496 3596664 : lastnz = add( lastnz, 2 ); /* Q0 */
1497 3596664 : IF( LT_16( lastnz, 2 ) )
1498 : {
1499 13786 : lastnz = 2; /* At least one tuple is coded Q0*/
1500 13786 : move16();
1501 : }
1502 :
1503 3596664 : lastnz2 = 2;
1504 3596664 : move16();
1505 :
1506 : /* Main Loop through the 2-tuples */
1507 789225491 : FOR( k = 0; k < lastnz; k += 2 )
1508 : {
1509 : /* Init current 2-tuple encoding */
1510 785628827 : a1 = abs_s( x[k] ); /* Q0 */
1511 785628827 : b1 = abs_s( x[k + 1] ); /* Q0 */
1512 785628827 : lev1 = 0;
1513 785628827 : move16();
1514 785628827 : esc_nb = 0;
1515 785628827 : move16();
1516 785628827 : rateQ = add( rateFlag, extract_l( GT_16( k, shr( nt, 1 ) ) ) ); /* Q0 */
1517 :
1518 785628827 : bit_estimate_fx = W_add( bit_estimate_fx, MAKE_VARIABLE_QX( s_min( a1, 1 ), Q23 ) );
1519 785628827 : bit_estimate_fx = W_add( bit_estimate_fx, MAKE_VARIABLE_QX( s_min( b1, 1 ), Q23 ) );
1520 :
1521 : /* pre-compute address of ari_pk_s17_LC_ext[0][Val_esc] to avoid doing it multiple times inside the loop */
1522 785628827 : lookup = &ari_lookup_s17_LC[t + shl( rateQ, NBITS_CONTEXT )]; /* Q0 */
1523 :
1524 : /* check while condition */
1525 : /* MSBs coding */
1526 933720047 : FOR( ; s_max( a1, b1 ) >= A_THRES; )
1527 : {
1528 148091220 : pki = lookup[( esc_nb << ( NBITS_CONTEXT + NBITS_RATEQ ) )]; /* Q0 */
1529 :
1530 148091220 : bit_estimate_fx = W_add( bit_estimate_fx, ari_bit_estimate_s17_LC_fx[pki][VAL_ESC] );
1531 148091220 : bit_estimate_fx = W_add( bit_estimate_fx, MAKE_NUMBER_QX( 2, Q23 ) );
1532 :
1533 148091220 : a1 = shr( a1, 1 );
1534 148091220 : b1 = shr( b1, 1 );
1535 :
1536 148091220 : lev1 = add( lev1, 1 );
1537 148091220 : esc_nb = s_min( lev1, 3 );
1538 : }
1539 785628827 : pki = lookup[( esc_nb << ( NBITS_CONTEXT + NBITS_RATEQ ) )]; /* Q0 */
1540 :
1541 785628827 : symbol = add( a1, i_mult( A_THRES, b1 ) ); /* Q0 */
1542 785628827 : bit_estimate_fx = W_add( bit_estimate_fx, ari_bit_estimate_s17_LC_fx[pki][symbol] );
1543 :
1544 : /* Should we truncate? */
1545 785628827 : IF( GT_32( W_shl_sat_l( bit_estimate_fx, -Q8 ), target_Q15 ) ) // Q15
1546 : {
1547 28631113 : overflow_flag = 1;
1548 28631113 : move16();
1549 : }
1550 : ELSE
1551 : {
1552 756997714 : IF( abs_s( x[k] ) || abs_s( x[k + 1] ) ) /* No overflow & non-zero tuple */
1553 : {
1554 452945838 : nbits2_fx = bit_estimate_fx; /* exp(bit_estimate_e) */
1555 452945838 : move64();
1556 :
1557 452945838 : lastnz2 = add( k, 2 );
1558 : }
1559 : }
1560 :
1561 : /* Update context for next 2-tuple */
1562 785628827 : cp = add( 1, i_mult( add( a1, b1 ), add( esc_nb, 1 ) ) ); /* Q0 */
1563 785628827 : if ( GE_16( esc_nb, 2 ) )
1564 : {
1565 36625439 : cp = add( 12, esc_nb ); /* Q0 */
1566 : }
1567 : /*shift old bits and replace last 4 bits*/
1568 785628827 : s = (UWord16) L_add( L_shl( s, 4 ), cp );
1569 785628827 : t = s_and( s, 0xFF );
1570 : } /*end of the 2-tuples loop*/
1571 :
1572 3596664 : tot_bits2 = round_fx( W_shl_sat_l( nbits2_fx, -Q7 ) ); /* Q23 -> Q16 -> Q0 */
1573 3596664 : round_bit_estimate_fx = round_fx( W_shl_sat_l( bit_estimate_fx, -Q7 ) ); /* Q23 -> Q16 -> Q0 */
1574 3596664 : if ( LT_16( lastnz2, lastnz ) ) /* Overflow occured because unable to code all tuples */
1575 : {
1576 1479650 : overflow_flag = 1;
1577 1479650 : move16();
1578 : }
1579 3596664 : if ( EQ_16( mode, -1 ) )
1580 : {
1581 0 : tot_bits2 = round_bit_estimate_fx;
1582 0 : move16();
1583 : }
1584 3596664 : if ( overflow_flag == 0 ) /* No overflow */
1585 : {
1586 2117014 : *stop = 0;
1587 2117014 : move16();
1588 : }
1589 3596664 : IF( overflow_flag != 0 ) /* Overflow */
1590 : {
1591 1479650 : IF( *stop ){
1592 9708 : *stop = tot_bits2; /* Q0 */
1593 9708 : move16();
1594 : }
1595 : ELSE
1596 : {
1597 1469942 : *stop = round_bit_estimate_fx;
1598 1469942 : move16();
1599 : }
1600 : }
1601 :
1602 3596664 : *lastnz_out = lastnz; /* Q0 */
1603 3596664 : move16();
1604 3596664 : *nEncoded = lastnz2; /* Q0 */
1605 3596664 : move16();
1606 : /* Safety mechanism to avoid overflow */
1607 3596664 : test();
1608 3596664 : IF( EQ_16( lastnz2, 2 ) && EQ_16( overflow_flag, 1 ) )
1609 : {
1610 177 : FOR( k = 0; k < lastnz2; k++ )
1611 : {
1612 118 : x[k] = 0;
1613 118 : move16();
1614 : }
1615 : }
1616 :
1617 3596664 : return tot_bits2;
1618 : }
1619 : }
1620 :
1621 :
1622 : /*-------------------------------------------------------------------*
1623 : * RCcontextMapping_encode2_estimate_bandWise_start_fx()
1624 : *
1625 : * Range coder - start bandwise bit-estimation
1626 : *-------------------------------------------------------------------*/
1627 :
1628 568204 : Word16 RCcontextMapping_encode2_estimate_bandWise_start_fx(
1629 : Word16 *x, /* Q0 */
1630 : const Word16 nt, /* Q0 */
1631 : const Word16 target, /* Q0 */
1632 : HANDLE_RC_CONTEXT_MEM hContextMem )
1633 : {
1634 : Word16 i, k;
1635 :
1636 : /* Rate flag */
1637 568204 : IF( GT_16( target, 400 ) )
1638 : {
1639 557772 : hContextMem->rateFlag = 2 << NBITS_CONTEXT;
1640 557772 : move16();
1641 : }
1642 : ELSE
1643 : {
1644 10432 : hContextMem->rateFlag = 0;
1645 10432 : move16();
1646 : }
1647 :
1648 568204 : hContextMem->bit_estimate_fx = MAKE_NUMBER_QX( 2, Q23 );
1649 568204 : move64();
1650 :
1651 :
1652 : /* Init */
1653 568204 : hContextMem->nt_half = shr( nt, 1 );
1654 568204 : move16();
1655 :
1656 : /* bits to encode lastnz */
1657 568204 : k = 1;
1658 568204 : move16();
1659 :
1660 5346172 : WHILE( LT_16( k, hContextMem->nt_half ) )
1661 : {
1662 4777968 : hContextMem->bit_estimate_fx = W_add( hContextMem->bit_estimate_fx, MAKE_NUMBER_QX( 1, Q23 ) );
1663 4777968 : move64();
1664 :
1665 4777968 : k = shl( k, 1 );
1666 : /* check while condition */
1667 : }
1668 :
1669 : /* bits to encode lastnz */
1670 568204 : hContextMem->nbits_old = round_fx( W_extract_l( W_shr( hContextMem->bit_estimate_fx, Q7 ) ) ); /* Q0 */
1671 568204 : move16();
1672 :
1673 568204 : hContextMem->ctx = 0;
1674 568204 : move16();
1675 568204 : hContextMem->lastnz = 2;
1676 568204 : move16();
1677 :
1678 : /* Find last non-zero tuple */
1679 :
1680 8732137 : FOR( i = nt; i >= 4; i -= 2 )
1681 : {
1682 8731490 : test();
1683 8731490 : IF( x[i - 2] != 0 || x[i - 1] != 0 )
1684 : {
1685 567557 : hContextMem->lastnz = i;
1686 567557 : move16();
1687 567557 : BREAK;
1688 : }
1689 : }
1690 :
1691 568204 : return hContextMem->nbits_old;
1692 : }
1693 :
1694 : /*-------------------------------------------------------------------*
1695 : * RCcontextMapping_encode2_estimate_bandWise_fx()
1696 : *
1697 : * Range coder - bandwise bit-estimation
1698 : *-------------------------------------------------------------------*/
1699 :
1700 22598660 : Word16 RCcontextMapping_encode2_estimate_bandWise_fx(
1701 : Word16 *x, /* Q0 */
1702 : const Word16 start_line, /* Q0 */
1703 : const Word16 end_line, /* Q0 */
1704 : HANDLE_RC_CONTEXT_MEM hContextMem )
1705 : {
1706 : Word16 a1, b1, a1_i, b1_i;
1707 : Word16 k, pki, lev1;
1708 : UWord16 t;
1709 22598660 : Word16 bandBits = 0;
1710 22598660 : move16();
1711 : Word16 total_output_bits; /* No. of bits after finalization */
1712 : Word16 symbol;
1713 : const UWord8 *lookup;
1714 : Word16 idx;
1715 : Word16 tmp;
1716 :
1717 : /* Main Loop through the 2-tuples */
1718 : /*hContextMem->nt_half = end_line >> 1;*/
1719 22598660 : Word16 len = s_min( hContextMem->lastnz, end_line );
1720 175830602 : FOR( k = start_line; k < len; k += 2 )
1721 : {
1722 153231942 : a1_i = k; /* Q0 */
1723 153231942 : move16();
1724 153231942 : b1_i = add( k, 1 ); /* Q0 */
1725 :
1726 153231942 : idx = k;
1727 153231942 : move16();
1728 :
1729 : /* Get context */
1730 153231942 : t = add( hContextMem->ctx, hContextMem->rateFlag ); /* Q0 */
1731 :
1732 153231942 : tmp = ( 1 << NBITS_CONTEXT );
1733 153231942 : move16();
1734 153231942 : if ( GE_16( hContextMem->nt_half, idx ) )
1735 : {
1736 80659749 : tmp = 0;
1737 80659749 : move16();
1738 : }
1739 :
1740 153231942 : t = add( t, tmp ); /* Q0 */
1741 :
1742 : /* Init current 2-tuple encoding */
1743 153231942 : a1 = abs_s( x[a1_i] ); /* Q0 */
1744 153231942 : b1 = abs_s( x[b1_i] ); /* Q0 */
1745 153231942 : lev1 = -( 1 << ( NBITS_CONTEXT + NBITS_RATEQ ) ); /* Q0 */
1746 :
1747 : /* Signs Bits */
1748 153231942 : hContextMem->bit_estimate_fx = W_add( hContextMem->bit_estimate_fx, MAKE_VARIABLE_QX( s_min( a1, 1 ), Q23 ) );
1749 153231942 : hContextMem->bit_estimate_fx = W_add( hContextMem->bit_estimate_fx, MAKE_VARIABLE_QX( s_min( b1, 1 ), Q23 ) );
1750 :
1751 153231942 : move32();
1752 153231942 : move32();
1753 :
1754 : /* pre-compute address of ari_pk_s17_LC_ext[0][Val_esc] to avoid doing it multiple times inside the loop */
1755 153231942 : lookup = &ari_lookup_s17_LC[t] + ( 1 << ( NBITS_CONTEXT + NBITS_RATEQ ) );
1756 :
1757 : /* check while condition */
1758 : /* MSBs coding */
1759 184463410 : FOR( ; s_max( a1, b1 ) >= A_THRES; )
1760 : {
1761 31231468 : pki = lookup[lev1]; /* Q0 */
1762 :
1763 31231468 : hContextMem->bit_estimate_fx = W_add( hContextMem->bit_estimate_fx, ari_bit_estimate_s17_LC_fx[pki][VAL_ESC] );
1764 31231468 : hContextMem->bit_estimate_fx = W_add( hContextMem->bit_estimate_fx, MAKE_NUMBER_QX( 2, Q23 ) );
1765 31231468 : move64();
1766 31231468 : move64();
1767 :
1768 :
1769 : // hContextMem->bit_estimate = hContextMem->bit_estimate + ari_bit_estimate_s17_LC[pki][VAL_ESC];
1770 : // hContextMem->bit_estimate += 2; /* Add the 2 LSB bits that were shifted out */
1771 :
1772 31231468 : a1 = shr( a1, 1 );
1773 31231468 : b1 = shr( b1, 1 );
1774 :
1775 31231468 : lev1 = s_min( add( lev1, ( 1 << ( NBITS_CONTEXT + NBITS_RATEQ ) ) ), 2 << ( NBITS_CONTEXT + NBITS_RATEQ ) ); /* Q0 */
1776 : /* check while condition */
1777 : }
1778 :
1779 153231942 : pki = lookup[lev1]; /* Q0 */
1780 :
1781 153231942 : symbol = add( a1, i_mult( A_THRES, b1 ) ); /* MSB symbol Q0*/
1782 153231942 : hContextMem->bit_estimate_fx = W_add( hContextMem->bit_estimate_fx, ari_bit_estimate_s17_LC_fx[pki][symbol] );
1783 :
1784 153231942 : move64();
1785 : // hContextMem->bit_estimate = hContextMem->bit_estimate + ari_bit_estimate_s17_LC[pki][symbol];
1786 :
1787 : /* Update context */
1788 153231942 : lev1 = shr( lev1, NBITS_CONTEXT + NBITS_RATEQ );
1789 :
1790 153231942 : t = add( 1, i_mult( add( a1, b1 ), add( lev1, 2 ) ) ); /* Q0 */
1791 153231942 : if ( lev1 > 0 )
1792 : {
1793 7802317 : t = add( 13, lev1 ); /* Q0 */
1794 : }
1795 153231942 : hContextMem->ctx = add( i_mult( s_and( hContextMem->ctx, 0xf ), 16 ), t ); /* Q0 */
1796 153231942 : move16();
1797 :
1798 : } /*end of the 2-tuples loop*/
1799 22598660 : total_output_bits = round_fx( W_shl_sat_l( hContextMem->bit_estimate_fx, -Q7 ) ); /* Q0 */
1800 : // total_output_bits = (Word16) ( hContextMem->bit_estimate + 0.5f );
1801 :
1802 :
1803 22598660 : bandBits = sub( total_output_bits, hContextMem->nbits_old ); /* Q0 */
1804 22598660 : hContextMem->nbits_old = total_output_bits; /* Q0 */
1805 22598660 : move16();
1806 :
1807 22598660 : return bandBits;
1808 : }
|
