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 637 : 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 637 : a1 = 0; /* to avoid compilation warnings */
63 637 : b1 = 0; /* to avoid compilation warnings */
64 637 : move16();
65 637 : move16();
66 :
67 : /* Rate flag */
68 637 : rateFlag = 0;
69 637 : move16();
70 637 : if ( GT_16( nbbits, 400 ) )
71 : {
72 42 : rateFlag = 2 << NBITS_CONTEXT;
73 42 : move16();
74 : }
75 :
76 : /* Init */
77 637 : nt_half = shr( nt, 1 );
78 637 : c[0] = c[1] = 0;
79 637 : move16();
80 637 : move16();
81 :
82 : /* Bits for encoding the number of encoded tuples */
83 637 : nbbits_ntuples = sub( 14, norm_s( negate( nt ) ) ); /* Q0 */
84 :
85 637 : t = 0;
86 637 : move16();
87 637 : bp = nbbits_ntuples; /* Q0 */
88 637 : move16();
89 637 : nbbits_signs = 0;
90 637 : move16();
91 637 : nbbits_lsbs = 0;
92 637 : move16();
93 637 : nbbits_m2 = sub( nbbits, 2 ); /* Q0 */
94 637 : flag_overflow = 0;
95 637 : move16();
96 :
97 637 : IF( hm_cfg ) /* mapped domain */
98 : {
99 50 : numPeakIndicesOrig = hm_cfg->numPeakIndices; /* Q0 */
100 50 : move16();
101 50 : hm_cfg->numPeakIndices = s_min( hm_cfg->numPeakIndices, lastnz ); /* Q0 */
102 50 : move16();
103 50 : numHoleIndices = sub( lastnz, hm_cfg->numPeakIndices ); /* Q0 */
104 :
105 : /* Mark hole indices beyond lastnz as pruned */
106 22052 : FOR( k = numHoleIndices; k < hm_cfg->numHoleIndices; ++k )
107 : {
108 22002 : hm_cfg->holeIndices[k] = add( hm_cfg->holeIndices[k], nt ); /* Q0 */
109 22002 : move16();
110 : }
111 :
112 50 : ii[0] = numPeakIndicesOrig; /* Q0 */
113 50 : move16();
114 50 : ii[1] = 0;
115 50 : move16();
116 :
117 50 : get_next_coeff = get_next_coeff_mapped; /* Q0 */
118 50 : move16();
119 : }
120 : ELSE /* unmapped domain */
121 : {
122 587 : ii[0] = 0;
123 587 : move16();
124 :
125 587 : p1 = p2 = 0;
126 587 : move16();
127 587 : move16();
128 :
129 587 : get_next_coeff = get_next_coeff_unmapped; /* Q0 */
130 587 : move16();
131 :
132 : /* Find last non-zero tuple */
133 : /* ensure termination of while loop by dummy value */
134 587 : a1 = x[0];
135 587 : move16();
136 587 : x[0] = 1;
137 587 : move16();
138 :
139 2406 : WHILE( s_or( x[lastnz - 1], x[lastnz - 2] ) == 0 )
140 : {
141 1819 : lastnz = sub( lastnz, 2 ); /* Q0 */
142 : }
143 587 : x[0] = a1;
144 587 : move16();
145 : }
146 :
147 637 : lsbs_bits2 = ptr + nbbits - 1;
148 :
149 : /*Start Encoding*/
150 637 : ari_start_encoding_14bits_fx( &as );
151 :
152 : /*Main Loop through the 2-tuples*/
153 637 : b1_i = -1;
154 637 : move16();
155 66143 : FOR( k = 0; k < lastnz; k += 2 )
156 : {
157 : /* First coefficient */
158 65506 : a1_i = get_next_coeff( ii, &p1, &idx1, hm_cfg ); /* Q0 */
159 :
160 : /* Second coefficient */
161 65506 : b1_i = get_next_coeff( ii, &p2, &idx2, hm_cfg ); /* Q0 */
162 :
163 65506 : idx = s_min( idx1, idx2 ); /* Q0 */
164 :
165 : /* Get context */
166 65506 : ctx = &c[s_or( p1, p2 )]; /* Q0 */
167 : /* _DIFF_FLOAT_FIX_ float is using t as UWord16 */
168 65506 : t = add( *ctx, rateFlag ); /* Q0 */
169 65506 : 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 65506 : if ( flag_overflow != 0 )
176 : {
177 0 : x[a1_i] = 0;
178 0 : move16();
179 : }
180 65506 : if ( flag_overflow != 0 )
181 : {
182 0 : x[b1_i] = 0;
183 0 : move16();
184 : }
185 :
186 65506 : a1 = abs_s( x[a1_i] ); /* Q0 */
187 65506 : b1 = abs_s( x[b1_i] ); /* Q0 */
188 :
189 65506 : lev1 = -1;
190 65506 : move16();
191 :
192 : /*Copy states*/
193 65506 : ari_copy_states_fx( &as, &as_overflow );
194 65506 : bp_overflow = bp; /* Q0 */
195 65506 : move16();
196 65506 : nbbits_signs_overflow = nbbits_signs; /* Q0 */
197 65506 : move16();
198 65506 : nbbits_lsbs_overflow = nbbits_lsbs; /* Q0 */
199 65506 : move16();
200 :
201 : /*Signs encoding*/
202 65506 : signs[nbbits_signs] = lshr( x[a1_i], 15 ); /* Q0 */
203 65506 : move16();
204 65506 : if ( a1 > 0 )
205 : {
206 17248 : nbbits_signs = add( nbbits_signs, 1 ); /* Q0 */
207 : }
208 65506 : signs[nbbits_signs] = lshr( x[b1_i], 15 ); /* Q0 */
209 65506 : move16();
210 65506 : if ( b1 > 0 )
211 : {
212 17047 : nbbits_signs = add( nbbits_signs, 1 ); /* Q0 */
213 : }
214 :
215 : /* MSBs coding */
216 69365 : WHILE( GE_16( s_max( a1, b1 ), A_THRES ) )
217 : {
218 3859 : tmp = add( t, Tab_esc_nb[lev1 + 1] ); /* Q0 */
219 3859 : assert( tmp >= 0 && tmp < 4096 );
220 3859 : pki = ari_lookup_s17_LC[tmp]; /* Q0 */
221 3859 : move16();
222 3859 : bp = ari_encode_14bits_ext_fx( ptr, bp, &as, VAL_ESC, ari_pk_s17_LC_ext[pki] ); /* Q0 */
223 :
224 3859 : *lsbs_bits2-- = s_and( a1, 1 );
225 3859 : move16();
226 3859 : *lsbs_bits2-- = s_and( b1, 1 );
227 3859 : move16();
228 :
229 : /* LSBs bit counting */
230 3859 : nbbits_lsbs = add( nbbits_lsbs, 2 ); /* Q0 */
231 :
232 3859 : a1 = shr( a1, 1 );
233 3859 : b1 = shr( b1, 1 );
234 :
235 3859 : lev1 = s_min( add( lev1, 1 ), 2 ); /* Q0 */
236 : }
237 :
238 65506 : tmp = add( t, Tab_esc_nb[lev1 + 1] ); /* Q0 */
239 65506 : assert( tmp >= 0 && tmp < 4096 );
240 65506 : pki = ari_lookup_s17_LC[tmp]; /* Q0 */
241 65506 : move16();
242 65506 : 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 65506 : 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 65506 : IF( EQ_16( p1, p2 ) ) /* peak-peak or hole-hole context */
296 : {
297 65273 : if ( lev1 > 0 )
298 897 : t = add( 12, lev1 );
299 65273 : if ( lev1 <= 0 )
300 64376 : t = add( a1, b1 );
301 65273 : if ( lev1 == 0 )
302 1730 : t = add( t, t );
303 :
304 65273 : *ctx = add( shl( s_and( *ctx, 0xf ), 4 ), add( t, 1 ) ); /* Q0 */
305 65273 : move16();
306 : }
307 : ELSE /* mixed context */
308 : {
309 233 : IF( s_and( idx1, 1 ) ) /* update first context */
310 : {
311 113 : c[p1] = update_mixed_context( c[p1], abs_s( x[a1_i] ) ); /* Q0 */
312 113 : move16();
313 : }
314 :
315 233 : IF( s_and( idx2, 1 ) ) /* update second context */
316 : {
317 120 : c[p2] = update_mixed_context( c[p2], abs_s( x[b1_i] ) ); /* Q0 */
318 120 : move16();
319 : }
320 : }
321 : } /*end of the 2-tuples loop*/
322 :
323 : /* End arithmetic coder, overflow management */
324 637 : bp = ari_done_encoding_14bits_fx( ptr, bp, &as ); /* Q0 */
325 :
326 : /* Overflow is detected */
327 637 : 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 637 : value = sub( shr( lastnz, 1 ), 1 ); /* Q0 */
346 637 : push_next_indice( hBstr, value, nbbits_ntuples );
347 :
348 : /* Push arithmetic coded bits */
349 637 : push_next_bits( hBstr, (UWord16 *) &ptr[nbbits_ntuples], sub( bp, nbbits_ntuples ) );
350 :
351 : /* Push sign bits */
352 637 : push_next_bits( hBstr, (UWord16 *) signs, nbbits_signs );
353 637 : bp = add( bp, nbbits_signs ); /* Q0 */
354 :
355 : /*write residual Quantization bits*/
356 637 : tmp = s_min( sub( sub( nbbits, bp ), nbbits_lsbs ), resQMaxBits ); /* Q0 */
357 6980 : FOR( k = 0; k < tmp; k++ )
358 : {
359 6343 : ptr[nbbits - 1 - nbbits_lsbs - k] = x[nt + k]; /* Q0 */
360 6343 : move16();
361 : }
362 : /* Write filler bits */
363 637 : tmp = sub( nbbits, add( bp, nbbits_lsbs ) ); /* Q0 */
364 1826 : FOR( ; k < tmp; ++k )
365 : {
366 1189 : ptr[nbbits - 1 - nbbits_lsbs - k] = 0;
367 1189 : 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 637 : assert( bp + k <= nbbits );
373 :
374 : /* Push the rest of the buffer */
375 637 : push_next_bits( hBstr, (UWord16 *) &ptr[bp], sub( nbbits, bp ) );
376 :
377 637 : return /*(bp+nbbits_lsbs)*/; /*return only for debug plot*/
378 : }
379 : /*-------------------------------------------------------------------*
380 : * find_last_nz_pair()
381 : *
382 : *
383 : *-------------------------------------------------------------------*/
384 4391 : 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 4391 : const Word16 *tmp = NULL;
391 :
392 4391 : if ( hm_cfg )
393 : {
394 1341 : tmp = hm_cfg->indexBuffer; /* Q0 */
395 1341 : move16();
396 : }
397 :
398 4391 : lobs[0] = 4;
399 4391 : move16();
400 4391 : lobs[1] = shr( length, 1 ); /* length/2 */
401 4391 : move16();
402 4391 : lobs[2] = add( lobs[1], shr( length, 2 ) ); /* Q0 */
403 4391 : move16();
404 4391 : lobs[3] = add( lobs[2], shr( length, 3 ) ); /* Q0 */
405 4391 : move16();
406 :
407 4391 : last_nz = 0;
408 4391 : move16();
409 4391 : i = length;
410 4391 : move16();
411 16814 : FOR( stage = 3; stage >= 0; --stage )
412 : {
413 16809 : IF( hm_cfg ) /* mapped kernel */
414 : {
415 315552 : FOR( ; i >= lobs[stage]; i -= 2 )
416 : {
417 310931 : if ( x[tmp[i - 2]] != 0 )
418 : {
419 15544 : last_nz = s_max( last_nz, i ); /* Q0 */
420 : }
421 310931 : if ( x[tmp[i - 1]] != 0 )
422 : {
423 15451 : last_nz = s_max( last_nz, i ); /* Q0 */
424 : }
425 : }
426 : }
427 : ELSE /* unmapped kernel */
428 : {
429 996642 : FOR( ; i >= lobs[stage]; i -= 2 )
430 : {
431 984454 : if ( x[i - 2] != 0 )
432 : {
433 80366 : last_nz = s_max( last_nz, i ); /* Q0 */
434 : }
435 984454 : if ( x[i - 1] != 0 )
436 : {
437 79058 : last_nz = s_max( last_nz, i ); /* Q0 */
438 : }
439 : }
440 : }
441 16809 : IF( last_nz > 0 )
442 : {
443 4386 : BREAK;
444 : }
445 : }
446 :
447 4391 : return s_max( last_nz, 2 );
448 : }
449 : /*-------------------------------------------------------------------*
450 : * ACcontextMapping_encode2_estimate_no_mem_s17_LC_fx()
451 : *
452 : *
453 : *-------------------------------------------------------------------*/
454 4391 : 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 4391 : Word16 numPeakIndicesOrig = 0, numHoleIndices = 0; /* initialize just to avoid compiler warning */
480 4391 : move16();
481 4391 : move16();
482 : get_next_coeff_function get_next_coeff;
483 :
484 :
485 : /* Rate flag */
486 4391 : rateFlag = 0;
487 4391 : move16();
488 4391 : if ( GT_16( target, 400 ) )
489 : {
490 210 : rateFlag = 2 << NBITS_CONTEXT; /* Q0 */
491 210 : move16();
492 : }
493 :
494 : /* proba coded on 14bits -> proba=1 */
495 4391 : proba = L_deposit_l( 16384 ); /* Q0 */
496 :
497 : /* Init */
498 4391 : nt_half = shr( nt, 1 );
499 4391 : stop2 = 0;
500 4391 : move16();
501 4391 : c[0] = c[1] = 0;
502 4391 : move16();
503 4391 : move16();
504 :
505 : /* bits to encode lastnz + 2 bits headroom */
506 4391 : nbits = sub( 2 + 14, norm_s( sub( nt, 1 ) ) ); /* Q0 */
507 4391 : nbits_old = nbits; /* Q0 */
508 4391 : move16();
509 4391 : nbits = sub( nbits, target ); /* Q0 */
510 :
511 : /* Find last non-zero tuple in the mapped domain signal */
512 4391 : lastnz = find_last_nz_pair( x, nt, hm_cfg ); /* Q0 */
513 :
514 : /* At least one tuple is coded */
515 4391 : lastnz2 = 2;
516 4391 : move16();
517 :
518 4391 : IF( hm_cfg ) /* mapped domain */
519 : {
520 1341 : numPeakIndicesOrig = hm_cfg->numPeakIndices; /* Q0 */
521 1341 : move16();
522 1341 : hm_cfg->numPeakIndices = s_min( hm_cfg->numPeakIndices, lastnz ); /* Q0 */
523 1341 : move16();
524 1341 : numHoleIndices = sub( lastnz, hm_cfg->numPeakIndices ); /* Q0 */
525 :
526 : /* Mark hole indices beyond lastnz as pruned */
527 424829 : FOR( k = numHoleIndices; k < hm_cfg->numHoleIndices; ++k )
528 : {
529 423488 : hm_cfg->holeIndices[k] = add( hm_cfg->holeIndices[k], nt ); /* Q0 */
530 423488 : move16();
531 : }
532 :
533 1341 : ii[0] = numPeakIndicesOrig; /* Q0 */
534 1341 : move16();
535 1341 : ii[1] = 0;
536 1341 : move16();
537 :
538 1341 : get_next_coeff = get_next_coeff_mapped; /* Q0 */
539 1341 : move16();
540 : }
541 : ELSE /* unmapped domain */
542 : {
543 3050 : ii[0] = 0;
544 3050 : move16();
545 :
546 3050 : p1 = p2 = 0;
547 3050 : move16();
548 3050 : move16();
549 :
550 3050 : get_next_coeff = get_next_coeff_unmapped; /* Q0 */
551 3050 : move16();
552 : }
553 :
554 : /* Main Loop through the 2-tuples */
555 494598 : FOR( k = 0; k < lastnz; k += 2 )
556 : {
557 : /* First coefficient */
558 490750 : a1_i = get_next_coeff( ii, &p1, &idx1, hm_cfg ); /* Q0 */
559 :
560 : /* Second coefficient */
561 490750 : b1_i = get_next_coeff( ii, &p2, &idx2, hm_cfg ); /* Q0 */
562 :
563 490750 : idx = s_min( idx1, idx2 ); /* Q0 */
564 :
565 : /* Get context */
566 490750 : ctx = &c[s_or( p1, p2 )]; /* Q0 */
567 :
568 490750 : t = add( *ctx, rateFlag ); /* Q0 */
569 490750 : if ( GT_16( idx, nt_half ) )
570 : {
571 18133 : t = add( t, 1 << NBITS_CONTEXT ); /* Q0 */
572 : }
573 :
574 : /* Init current 2-tuple encoding */
575 490750 : a1 = abs_s( x[a1_i] ); /* Q0 */
576 490750 : b1 = abs_s( x[b1_i] ); /* Q0 */
577 :
578 490750 : lev1 = -( 1 << ( NBITS_CONTEXT + NBITS_RATEQ ) );
579 490750 : move16();
580 : /* Signs Bits */
581 490750 : if ( a1 > 0 )
582 : {
583 116211 : nbits = add( nbits, 1 ); /* Q0 */
584 : }
585 :
586 490750 : if ( b1 > 0 )
587 : {
588 114949 : 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 490750 : lookup = (const Word8 *) ( &ari_lookup_s17_LC[t] + ( 1 << ( NBITS_CONTEXT + NBITS_RATEQ ) ) ); /* address calculation not counted */
597 517228 : WHILE( GE_16( s_max( a1, b1 ), A_THRES ) )
598 : {
599 26478 : pki = lookup[lev1];
600 26478 : move16();
601 26478 : 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 26478 : cum_freq_norm_e = norm_s( cum_freq[0] );
605 26478 : cum_freq_norm = shl( cum_freq[0], cum_freq_norm_e );
606 26478 : proba = Mpy_32_16_1( proba, cum_freq_norm );
607 26478 : 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 26478 : nlz = sub( norm_l( proba ), 2 );
611 26478 : proba = L_shl( proba, sub( nlz, 15 ) ); /* cum_freq_norm_e */
612 :
613 26478 : 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 26478 : a1 = shr( a1, 1 );
618 26478 : b1 = shr( b1, 1 );
619 26478 : lev1 = s_min( add( lev1, 1 << ( NBITS_CONTEXT + NBITS_RATEQ ) ), 2 << ( NBITS_CONTEXT + NBITS_RATEQ ) ); /* Q0 */
620 : }
621 :
622 490750 : pki = lookup[lev1]; /* Q0 */
623 490750 : move16();
624 490750 : symbol = add( a1, shl( b1, A_THRES_SHIFT ) ); /* Q0 */
625 490750 : 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 490750 : cum_freq_norm = sub( cum_freq[0], cum_freq[1] );
629 490750 : cum_freq_norm_e = norm_s( cum_freq_norm );
630 490750 : cum_freq_norm = shl( cum_freq_norm, cum_freq_norm_e );
631 490750 : proba = Mpy_32_16_1( proba, cum_freq_norm );
632 490750 : 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 490750 : nlz = sub( norm_l( proba ), 3 );
636 490750 : proba = L_shl( proba, sub( nlz, 14 ) ); /* cum_freq_norm_e */
637 :
638 490750 : 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 490750 : IF( nbits > 0 )
645 : {
646 48552 : stop2 = 1;
647 48552 : move16();
648 :
649 48552 : IF( *stop )
650 : {
651 543 : BREAK;
652 : }
653 : }
654 : ELSE
655 : {
656 442198 : test();
657 442198 : test();
658 442198 : IF( hm_cfg || k == 0 || s_or( x[a1_i], x[b1_i] ) )
659 : {
660 268360 : nbits_old = add( nbits, target ); /* Q0 */
661 268360 : lastnz2 = add( b1_i, 1 ); /* Q0 */
662 : }
663 : }
664 :
665 : /* Update context for next 2-tuple */
666 490207 : IF( EQ_16( p1, p2 ) ) /* peak-peak or hole-hole context */
667 : {
668 465073 : lev1 = shr( lev1, NBITS_CONTEXT + NBITS_RATEQ ); /* Q0 */
669 465073 : if ( lev1 > 0 )
670 5925 : t = add( 12, lev1 );
671 465073 : if ( lev1 <= 0 )
672 459148 : t = add( a1, b1 );
673 465073 : if ( lev1 == 0 )
674 11313 : t = add( t, t );
675 :
676 465073 : *ctx = add( shl( s_and( *ctx, 0xf ), 4 ), add( t, 1 ) ); /* Q0 */
677 465073 : move16();
678 : }
679 : ELSE /* mixed context */
680 : {
681 25134 : IF( s_and( idx1, 1 ) ) /* update first context */
682 : {
683 12452 : c[p1] = update_mixed_context( c[p1], abs_s( x[a1_i] ) ); /* Q0 */
684 12452 : move16();
685 : }
686 :
687 25134 : IF( s_and( idx2, 1 ) ) /* update second context */
688 : {
689 12589 : c[p2] = update_mixed_context( c[p2], abs_s( x[b1_i] ) ); /* Q0 */
690 12589 : move16();
691 : }
692 : }
693 : } /* end of the 2-tuples loop */
694 :
695 4391 : nbits = add( nbits, target ); /* Q0 */
696 :
697 : /* Output */
698 4391 : if ( *stop )
699 : {
700 603 : nbits = nbits_old; /* Q0 */
701 603 : move16();
702 : }
703 :
704 4391 : if ( stop2 )
705 : {
706 2421 : stop2 = nbits; /* Q0 */
707 2421 : move16();
708 : }
709 4391 : *nEncoded = lastnz2; /* Q0 */
710 4391 : move16();
711 4391 : *stop = stop2; /* Q0 */
712 4391 : move16();
713 4391 : if ( lastnz_out )
714 : {
715 4391 : *lastnz_out = lastnz; /* Q0 */
716 4391 : move16();
717 : }
718 :
719 4391 : IF( hm_cfg )
720 : {
721 : /* Restore hole indices beyond lastnz */
722 424829 : FOR( k = numHoleIndices; k < hm_cfg->numHoleIndices; ++k )
723 : {
724 423488 : hm_cfg->holeIndices[k] = sub( hm_cfg->holeIndices[k], nt ); /* Q0 */
725 423488 : move16();
726 : }
727 1341 : hm_cfg->numPeakIndices = numPeakIndicesOrig; /* Q0 */
728 1341 : move16();
729 : }
730 :
731 :
732 4391 : 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 845374 : 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 845374 : a1 = 0; /* to avoid compilation warnings */
767 845374 : b1 = 0; /* to avoid compilation warnings */
768 845374 : move16();
769 845374 : move16();
770 :
771 : /* Init */
772 845374 : nt_half = shr( nt, 1 );
773 :
774 : /* Bits for encoding the number of encoded tuples */
775 845374 : nbbits_ntuples = 0;
776 845374 : k = 1;
777 845374 : move16();
778 845374 : move16();
779 :
780 8360632 : WHILE( LT_16( k, shr( nt, 1 ) ) )
781 : {
782 7515258 : nbbits_ntuples = add( nbbits_ntuples, 1 ); /* Q0 */
783 7515258 : k = shl( k, 1 );
784 : }
785 :
786 845374 : t = 0;
787 845374 : nbbits_signs = 0;
788 845374 : nbbits_lsbs = 0;
789 845374 : move16();
790 845374 : move16();
791 845374 : move16();
792 :
793 845374 : 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 12641 : IF( GT_16( nbbits, 400 ) )
804 : {
805 6011 : rateFlag = 2 << NBITS_CONTEXT;
806 6011 : move16();
807 : }
808 : ELSE
809 : {
810 6630 : rateFlag = 0;
811 6630 : move16();
812 : }
813 :
814 12641 : c[0] = c[1] = 0;
815 12641 : move32();
816 12641 : move32();
817 :
818 : /* mapped domain */
819 12641 : numPeakIndicesOrig = hm_cfg->numPeakIndices; /* Q0 */
820 12641 : hm_cfg->numPeakIndices = s_min( hm_cfg->numPeakIndices, lastnz ); /* Q0 */
821 12641 : numHoleIndices = sub( lastnz, hm_cfg->numPeakIndices ); /* Q0 */
822 12641 : move16();
823 12641 : move16();
824 :
825 : /* Mark hole indices beyond lastnz as pruned */
826 5498704 : FOR( k = numHoleIndices; k < hm_cfg->numHoleIndices; ++k )
827 : {
828 5486063 : hm_cfg->holeIndices[k] = add( hm_cfg->holeIndices[k], nt ); /* Q0 */
829 5486063 : move16();
830 : }
831 :
832 12641 : ii[0] = numPeakIndicesOrig; /* Q0 */
833 12641 : ii[1] = 0;
834 12641 : move16();
835 12641 : move16();
836 :
837 12641 : p1 = p2 = 0; /* to avoid compilation warnings */
838 12641 : move16();
839 12641 : move16();
840 :
841 12641 : lsbs_bits = ptr + sub( nbbits, 1 );
842 :
843 : /*Start Encoding*/
844 : /* Initialize range encoder */
845 12641 : rc_uni_enc_init_fx( &rc_st_enc );
846 :
847 : /*Main Loop through the 2-tuples*/
848 12641 : b1_i = -1;
849 12641 : move16();
850 :
851 2315486 : FOR( k = 0; k < lastnz; k += 2 )
852 : {
853 2302845 : a1_i = get_next_coeff_mapped_ivas_fx( ii, &p1, &idx1, hm_cfg ); /* Q0 */
854 2302845 : b1_i = get_next_coeff_mapped_ivas_fx( ii, &p2, &idx2, hm_cfg ); /* Q0 */
855 :
856 2302845 : idx = s_min( idx1, idx2 ); /* Q0 */
857 :
858 : /* Get context */
859 2302845 : ctx = &c[L_or( p1, p2 )]; /* Q0 */
860 :
861 2302845 : t = (UWord16) L_add( *ctx, rateFlag ); /* Q0 */
862 : // t += ( nt_half >= idx ) ? 0 : ( 1 << NBITS_CONTEXT );
863 2302845 : IF( LT_16( nt_half, idx ) )
864 : {
865 271836 : t = add( t, ( 1 << NBITS_CONTEXT ) );
866 : }
867 :
868 : /* Init current 2-tuple encoding */
869 2302845 : a1 = abs_s( x[a1_i] ); /* Q0 */
870 2302845 : b1 = abs_s( x[b1_i] ); /* Q0 */
871 :
872 2302845 : lev1 = -1;
873 2302845 : move16();
874 :
875 : /*Signs encoding*/
876 2302845 : IF( a1 > 0 )
877 : {
878 : // signs[nbbits_signs++] = ( (uint16_t) x[a1_i] >> ( sizeof( uint16_t ) * 8 - 1 ) );
879 608484 : if ( x[a1_i] >= 0 )
880 : {
881 306474 : signs[nbbits_signs] = 0;
882 306474 : move16();
883 : }
884 608484 : if ( x[a1_i] < 0 )
885 : {
886 302010 : signs[nbbits_signs] = 1;
887 302010 : move16();
888 : }
889 608484 : nbbits_signs = add( nbbits_signs, 1 ); /* Q0 */
890 : }
891 :
892 2302845 : IF( b1 > 0 )
893 : {
894 : // signs[nbbits_signs++] = ( (uint16_t) x[b1_i] >> ( sizeof( uint16_t ) * 8 - 1 ) );
895 603305 : if ( x[b1_i] >= 0 )
896 : {
897 300920 : signs[nbbits_signs] = 0;
898 300920 : move16();
899 : }
900 603305 : if ( x[b1_i] < 0 )
901 : {
902 302385 : signs[nbbits_signs] = 1;
903 302385 : move16();
904 : }
905 603305 : nbbits_signs = add( nbbits_signs, 1 ); /* Q0 */
906 : }
907 :
908 : /* MSBs coding */
909 2608450 : WHILE( GE_16( s_max( a1, b1 ), A_THRES ) )
910 : {
911 305605 : pki = ari_lookup_s17_LC[t + ( ( lev1 + 1 ) << ( NBITS_CONTEXT + NBITS_RATEQ ) )]; /* Q0 */
912 305605 : move16();
913 305605 : 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 305605 : *lsbs_bits-- = s_and( a1, 1 );
916 305605 : *lsbs_bits-- = s_and( b1, 1 );
917 305605 : move16();
918 305605 : move16();
919 :
920 : /* LSBs bit counting */
921 305605 : nbbits_lsbs = add( nbbits_lsbs, 2 ); /* Q0 */
922 :
923 305605 : a1 = shr( a1, 1 );
924 305605 : b1 = shr( b1, 1 );
925 :
926 305605 : lev1 = s_min( add( lev1, 1 ), 2 ); /* Q0 */
927 : }
928 :
929 2302845 : pki = ari_lookup_s17_LC[t + ( ( lev1 + 1 ) << ( NBITS_CONTEXT + NBITS_RATEQ ) )]; /* Q0 */
930 2302845 : move16();
931 2302845 : 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 2302845 : IF( EQ_32( p1, p2 ) )
937 : {
938 : /* peak-peak or hole-hole context */
939 :
940 2093837 : IF( lev1 <= 0 )
941 : {
942 2036054 : t = (UWord16) L_add( 1, L_mult0( add( a1, b1 ), add( lev1, 2 ) ) ); /* Q0 */
943 : }
944 : ELSE
945 : {
946 57783 : t = (UWord16) L_add( 13, lev1 ); /* Q0 */
947 : }
948 :
949 2093837 : *ctx = L_add( L_shl( L_and( *ctx, 0xf ), 4 ), t ); /* Q0 */
950 2093837 : move32();
951 : }
952 : ELSE
953 : {
954 : /* mixed context */
955 :
956 209008 : IF( s_and( idx1, 1 ) )
957 : {
958 : /* update first context */
959 99419 : c[p1] = update_mixed_context_ivas_fx( c[p1], abs_s( x[a1_i] ) ); /* Q0 */
960 99419 : move32();
961 : }
962 :
963 209008 : IF( s_and( idx2, 1 ) )
964 : {
965 : /* update second context */
966 109589 : c[p2] = update_mixed_context_ivas_fx( c[p2], abs_s( x[b1_i] ) ); /* Q0 */
967 109589 : 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 832733 : IF( GT_16( nbbits, 400 ) )
981 : {
982 606037 : rateFlag = 2;
983 606037 : move16();
984 : }
985 : ELSE
986 : {
987 226696 : rateFlag = 0;
988 226696 : move16();
989 : }
990 :
991 832733 : s = 0;
992 832733 : move16();
993 :
994 : /* Find last non-zero tuple */
995 : /* ensure termination of while loop by dummy value */
996 832733 : a1 = x[0];
997 832733 : x[0] = 1; /* ensure first tuple is non-zero */
998 832733 : move16();
999 832733 : move16();
1000 :
1001 7088470 : WHILE( x[lastnz - 1] == 0 && x[lastnz - 2] == 0 )
1002 : {
1003 6255737 : test();
1004 6255737 : lastnz = sub( lastnz, 2 ); /* Q0 */
1005 : }
1006 832733 : x[0] = a1;
1007 832733 : move16();
1008 :
1009 832733 : lsbs_bits = ptr + sub( nbbits, 1 );
1010 :
1011 : /*Start Encoding*/
1012 : /* Initialize range encoder */
1013 832733 : rc_uni_enc_init_fx( &rc_st_enc );
1014 :
1015 : /*Main Loop through the 2-tuples*/
1016 179096897 : FOR( k = 0; k < lastnz; k += 2 )
1017 : {
1018 :
1019 : /* Init current 2-tuple encoding */
1020 178264164 : a1 = abs_s( x[k + 0] ); /* Q0 */
1021 178264164 : b1 = abs_s( x[k + 1] ); /* Q0 */
1022 :
1023 178264164 : lev1 = 0;
1024 178264164 : esc_nb = 0;
1025 178264164 : move16();
1026 178264164 : move16();
1027 :
1028 : /*Signs encoding*/
1029 178264164 : IF( a1 > 0 )
1030 : {
1031 : // signs[nbbits_signs++] = ( (uint16_t) x[k + 0] >> ( sizeof( uint16_t ) * 8 - 1 ) );
1032 73139521 : if ( x[k] >= 0 )
1033 : {
1034 36579103 : signs[nbbits_signs] = 0;
1035 36579103 : move16();
1036 : }
1037 73139521 : if ( x[k] < 0 )
1038 : {
1039 36560418 : signs[nbbits_signs] = 1;
1040 36560418 : move16();
1041 : }
1042 73139521 : nbbits_signs = add( nbbits_signs, 1 ); /* Q0 */
1043 : }
1044 :
1045 178264164 : IF( b1 > 0 )
1046 : {
1047 : // signs[nbbits_signs++] = ( (uint16_t) x[k + 1] >> ( sizeof( uint16_t ) * 8 - 1 ) );
1048 72938725 : if ( x[k + 1] >= 0 )
1049 : {
1050 36380879 : signs[nbbits_signs] = 0;
1051 36380879 : move16();
1052 : }
1053 72938725 : if ( x[k + 1] < 0 )
1054 : {
1055 36557846 : signs[nbbits_signs] = 1;
1056 36557846 : move16();
1057 : }
1058 72938725 : nbbits_signs = add( nbbits_signs, 1 ); /* Q0 */
1059 : }
1060 :
1061 178264164 : rateQ = add( rateFlag, extract_l( GT_16( k, shr( nt, 1 ) ) ) );
1062 :
1063 : /* MSBs coding */
1064 211591082 : WHILE( GE_16( s_max( a1, b1 ), A_THRES ) )
1065 : {
1066 33326918 : pki = ari_lookup_s17_LC[t + ( ( rateQ ) << NBITS_CONTEXT ) + ( esc_nb << ( NBITS_CONTEXT + NBITS_RATEQ ) )];
1067 33326918 : move16();
1068 33326918 : 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 33326918 : *lsbs_bits-- = s_and( a1, 1 );
1071 33326918 : *lsbs_bits-- = s_and( b1, 1 );
1072 33326918 : move16();
1073 33326918 : move16();
1074 :
1075 : /* LSBs bit counting */
1076 33326918 : nbbits_lsbs = add( nbbits_lsbs, 2 ); /* Q0 */
1077 :
1078 33326918 : a1 = shr( a1, 1 );
1079 33326918 : b1 = shr( b1, 1 );
1080 :
1081 33326918 : lev1 = add( lev1, 1 ); /* Q0 */
1082 33326918 : esc_nb = s_min( lev1, 3 ); /* Q0 */
1083 : }
1084 :
1085 178264164 : move16();
1086 :
1087 178264164 : pki = ari_lookup_s17_LC[t + ( ( rateQ ) << NBITS_CONTEXT ) + ( esc_nb << ( NBITS_CONTEXT + NBITS_RATEQ ) )]; /* Q0 */
1088 178264164 : 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 178264164 : IF( LT_16( esc_nb, 2 ) )
1094 : {
1095 170010890 : cp = add( 1, imult1616( add( a1, b1 ), add( esc_nb, 1 ) ) ); /* Q0 */
1096 : }
1097 : ELSE
1098 : {
1099 8253274 : cp = add( 12, esc_nb ); /* Q0 */
1100 : }
1101 :
1102 : /*Shift old 4 bits, replace last 4 bits*/
1103 178264164 : s = (UWord16) ( L_add( L_shl( s, 4 ), cp ) );
1104 178264164 : t = (UWord16) L_and( s, 0xFF );
1105 :
1106 : } /*end of the 2-tuples loop*/
1107 : }
1108 :
1109 : /* Finish range encoder */
1110 845374 : rc_tot_bits = rc_uni_enc_finish_fx( &rc_st_enc ); /* No. of bits consumed by range coder Q0*/
1111 845374 : 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 845374 : value = sub( shr( lastnz, 1 ), 1 ); /* Q0 */
1117 845374 : 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 65563541 : FOR( k = 0; k < ( rc_tot_bits >> 3 ); k++ )
1122 : {
1123 64718167 : push_next_indice( hBstr, rc_st_enc.byte_buffer[k], 8 );
1124 : }
1125 : /* 2) Push remaining bits */
1126 845374 : IF( s_and( rc_tot_bits, 7 ) != 0 )
1127 : {
1128 739704 : 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 845374 : push_next_bits( hBstr, (UWord16 *) signs, nbbits_signs );
1133 845374 : bp = add( bp, nbbits_signs ); /* Q0 */
1134 :
1135 : /*write residual Quantization bits*/
1136 :
1137 4827528 : FOR( k = 0; k < s_min( nbbits - bp - nbbits_lsbs, resQMaxBits ); k++ )
1138 : {
1139 3982154 : ptr[nbbits - 1 - nbbits_lsbs - k] = x[nt + k]; /* Q0 */
1140 3982154 : move16();
1141 : }
1142 : /* Write filler bits */
1143 19324956 : FOR( ; k < nbbits - bp - nbbits_lsbs; ++k )
1144 : {
1145 18479582 : ptr[nbbits - 1 - nbbits_lsbs - k] = 0;
1146 18479582 : move16();
1147 : }
1148 :
1149 : /* Check for debugging */
1150 845374 : assert( bp + k <= nbbits );
1151 :
1152 : /* Push the rest of the buffer */
1153 845374 : push_next_bits( hBstr, (UWord16 *) &ptr[bp], sub( nbbits, bp ) );
1154 :
1155 : /* return (bp+nbbits_lsbs);*/ /*return only for debug plot*/
1156 845374 : return;
1157 : }
1158 :
1159 : /*-------------------------------------------------------------------*
1160 : * find_last_nz_pair_fx()
1161 : *
1162 : *
1163 : *-------------------------------------------------------------------*/
1164 :
1165 399500 : 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 399500 : last_nz = 2;
1174 399500 : move16();
1175 :
1176 399500 : IF( hm_cfg )
1177 : {
1178 : /* mapped kernel */
1179 399500 : tmp = hm_cfg->indexBuffer;
1180 :
1181 68456486 : FOR( i = length; i >= 4; i -= 2 )
1182 : {
1183 68452427 : test();
1184 68452427 : IF( x[tmp[i - 2]] || x[tmp[i - 1]] )
1185 : {
1186 395441 : last_nz = i; /* Q0 */
1187 395441 : move16();
1188 395441 : 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 399500 : 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 3886480 : 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 3886480 : bit_estimate_fx = MAKE_NUMBER_QX( 2, Q23 );
1243 3886480 : move64();
1244 :
1245 3886480 : nbits2_fx = 0;
1246 3886480 : move64();
1247 :
1248 : /* bits to encode lastnz */
1249 3886480 : k = 1;
1250 3886480 : move16();
1251 :
1252 : #ifdef OPT_SBA_ENC_V2_BE
1253 : Word16 round_bit_estimate_fx;
1254 3886480 : Word32 target_Q15 = L_shl( target, Q15 ); // Q15
1255 : #endif
1256 :
1257 38224049 : WHILE( LT_16( k, nt / 2 ) )
1258 : {
1259 34337569 : bit_estimate_fx = W_add( bit_estimate_fx, MAKE_NUMBER_QX( 1, Q23 ) );
1260 34337569 : k = shl( k, 1 );
1261 : /* check while condition */
1262 : }
1263 :
1264 3886480 : nbits2_fx = bit_estimate_fx;
1265 3886480 : move64();
1266 :
1267 3886480 : IF( hm_cfg )
1268 : {
1269 : Word16 a1_i, b1_i;
1270 : Word16 stop2;
1271 : Word16 total_output_bits;
1272 : Word16 nt_half;
1273 : Word32 c[2], *ctx;
1274 : Word32 p1, p2;
1275 : Word16 ii[2];
1276 : Word16 idx1, idx2, idx;
1277 399500 : Word16 numPeakIndicesOrig = 0, numHoleIndices = 0; /* only to avoid compiler warning */
1278 399500 : move16();
1279 399500 : move16();
1280 :
1281 : /* Rate flag */
1282 399500 : IF( GT_16( target, 400 ) )
1283 : {
1284 247846 : rateFlag = 2 << NBITS_CONTEXT; /* Select context-A for higher bitrates */
1285 247846 : move16();
1286 : }
1287 : ELSE
1288 : {
1289 151654 : rateFlag = 0; /* Select context-B for lower bitrates */
1290 151654 : move16();
1291 : }
1292 :
1293 399500 : nt_half = shr( nt, 1 );
1294 399500 : move16();
1295 399500 : stop2 = 0;
1296 399500 : move16();
1297 399500 : c[0] = c[1] = 0;
1298 399500 : move32();
1299 399500 : move32();
1300 :
1301 : /* Find last non-zero tuple in the mapped domain signal */
1302 399500 : lastnz = find_last_nz_pair_fx( x, nt, hm_cfg );
1303 :
1304 399500 : lastnz2 = 2;
1305 399500 : move16();
1306 :
1307 : /* mapped domain */
1308 399500 : numPeakIndicesOrig = hm_cfg->numPeakIndices; /* Q0 */
1309 399500 : move16();
1310 399500 : hm_cfg->numPeakIndices = s_min( hm_cfg->numPeakIndices, lastnz ); /* Q0 */
1311 399500 : move16();
1312 399500 : numHoleIndices = sub( lastnz, hm_cfg->numPeakIndices ); /* Q0 */
1313 :
1314 : /* Mark hole indices beyond lastnz as pruned */
1315 134628308 : FOR( k = numHoleIndices; k < hm_cfg->numHoleIndices; ++k )
1316 : {
1317 134228808 : hm_cfg->holeIndices[k] = add( hm_cfg->holeIndices[k], nt ); /* Q0 */
1318 134228808 : move16();
1319 : }
1320 :
1321 399500 : ii[0] = numPeakIndicesOrig; /* Q0 */
1322 399500 : move16();
1323 399500 : ii[1] = 0;
1324 399500 : move16();
1325 :
1326 399500 : p1 = p2 = 0; /* to avoid compilation warnings */
1327 399500 : move32();
1328 399500 : move32();
1329 :
1330 : /* Main Loop through the 2-tuples */
1331 83478106 : FOR( k = 0; k < lastnz; k += 2 )
1332 : {
1333 83235547 : a1_i = get_next_coeff_mapped_ivas_fx( ii, &p1, &idx1, hm_cfg ); /* Q0 */
1334 83235547 : b1_i = get_next_coeff_mapped_ivas_fx( ii, &p2, &idx2, hm_cfg ); /* Q0 */
1335 :
1336 83235547 : idx = s_min( idx1, idx2 );
1337 :
1338 : /* Get context */
1339 83235547 : ctx = &c[L_or( p1, p2 )];
1340 :
1341 83235547 : t = (UWord16) L_add( *ctx, rateFlag );
1342 83235547 : if ( LT_16( nt_half, idx ) )
1343 : {
1344 14975120 : t = add( t, ( 1 << NBITS_CONTEXT ) );
1345 : }
1346 :
1347 : /* Init current 2-tuple encoding */
1348 83235547 : a1 = abs_s( x[a1_i] );
1349 83235547 : b1 = abs_s( x[b1_i] );
1350 83235547 : lev1 = -( 1 << ( NBITS_CONTEXT + NBITS_RATEQ ) );
1351 :
1352 83235547 : bit_estimate_fx = W_add( bit_estimate_fx, MAKE_VARIABLE_QX( s_min( a1, 1 ), Q23 ) );
1353 83235547 : bit_estimate_fx = W_add( bit_estimate_fx, MAKE_VARIABLE_QX( s_min( b1, 1 ), Q23 ) );
1354 : /* pre-compute address of ari_pk_s17_LC_ext[0][Val_esc] to avoid doing it multiple times inside the loop */
1355 83235547 : lookup = &ari_lookup_s17_LC[t] + ( 1 << ( NBITS_CONTEXT + NBITS_RATEQ ) );
1356 :
1357 : /* check while condition */
1358 : /* MSBs coding */
1359 : #ifdef OPT_SBA_ENC_V2_BE
1360 92672716 : FOR( ; s_max( a1, b1 ) >= A_THRES; )
1361 : {
1362 9437169 : pki = lookup[lev1]; /* ESC symbol */
1363 :
1364 9437169 : bit_estimate_fx = W_add( bit_estimate_fx, ari_bit_estimate_s17_LC_fx[pki][VAL_ESC] );
1365 9437169 : bit_estimate_fx = W_add( bit_estimate_fx, MAKE_VARIABLE_QX( 2, Q23 ) );
1366 9437169 : a1 = shr( a1, 1 );
1367 9437169 : b1 = shr( b1, 1 );
1368 :
1369 9437169 : lev1 = s_min( add( lev1, ( 1 << ( NBITS_CONTEXT + NBITS_RATEQ ) ) ), 2 << ( NBITS_CONTEXT + NBITS_RATEQ ) );
1370 : }
1371 : #else
1372 : WHILE( GE_16( s_max( a1, b1 ), A_THRES ) )
1373 : {
1374 : pki = lookup[lev1]; /* ESC symbol */
1375 :
1376 : bit_estimate_fx = W_add( bit_estimate_fx, ari_bit_estimate_s17_LC_fx[pki][VAL_ESC] );
1377 : bit_estimate_fx = W_add( bit_estimate_fx, MAKE_VARIABLE_QX( 2, Q23 ) );
1378 : a1 = shr( a1, 1 );
1379 : b1 = shr( b1, 1 );
1380 :
1381 : lev1 = s_min( add( lev1, ( 1 << ( NBITS_CONTEXT + NBITS_RATEQ ) ) ), 2 << ( NBITS_CONTEXT + NBITS_RATEQ ) );
1382 :
1383 : /* check while condition */
1384 : }
1385 : #endif
1386 83235547 : pki = lookup[lev1];
1387 :
1388 83235547 : symbol = add( a1, i_mult( A_THRES, b1 ) ); /* Q0 */
1389 83235547 : bit_estimate_fx = W_add( bit_estimate_fx, ari_bit_estimate_s17_LC_fx[pki][symbol] );
1390 :
1391 : #ifdef OPT_SBA_ENC_V2_BE
1392 83235547 : IF( GT_32( W_shl_sat_l( bit_estimate_fx, -Q8 ), target_Q15 ) ) // Q15
1393 : #else
1394 : /* Should we truncate? */
1395 : IF( GT_32( W_extract_l( W_shr( bit_estimate_fx, Q8 ) ), L_shl( target, Q15 ) ) )
1396 : #endif
1397 : {
1398 13807937 : stop2 = 1;
1399 13807937 : move16();
1400 :
1401 13807937 : IF( *stop )
1402 : {
1403 156941 : BREAK;
1404 : }
1405 : }
1406 : ELSE
1407 : {
1408 69427610 : lastnz2 = add( b1_i, 1 );
1409 69427610 : nbits2_fx = bit_estimate_fx;
1410 69427610 : move64();
1411 : }
1412 :
1413 : /* Update context for next 2-tuple */
1414 83078606 : IF( EQ_32( p1, p2 ) ) /* peak-peak or hole-hole context */
1415 : {
1416 68262259 : lev1 = shr( lev1, NBITS_CONTEXT + NBITS_RATEQ );
1417 :
1418 : #ifdef OPT_SBA_ENC_V2_BE
1419 68262259 : t = add( 13, lev1 );
1420 68262259 : IF( lev1 <= 0 )
1421 : {
1422 66591359 : t = add( 1, i_mult( add( a1, b1 ), add( lev1, 2 ) ) );
1423 : }
1424 : #else
1425 : IF( lev1 <= 0 )
1426 : {
1427 : t = add( 1, i_mult( add( a1, b1 ), add( lev1, 2 ) ) );
1428 : }
1429 : ELSE
1430 : {
1431 : t = add( 13, lev1 );
1432 : }
1433 : #endif
1434 :
1435 68262259 : *ctx = L_add( imult3216( L_and( *ctx, 0xf ), 16 ), t );
1436 68262259 : move32();
1437 : }
1438 : ELSE
1439 : {
1440 : /* mixed context */
1441 :
1442 14816347 : IF( s_and( idx1, 1 ) )
1443 : {
1444 : /* update first context */
1445 7403798 : c[p1] = update_mixed_context_ivas_fx( c[p1], abs_s( x[a1_i] ) ); /* Q0 */
1446 7403798 : move32();
1447 : }
1448 :
1449 14816347 : IF( s_and( idx2, 1 ) )
1450 : {
1451 : /* update second context */
1452 7391844 : c[p2] = update_mixed_context_ivas_fx( c[p2], abs_s( x[b1_i] ) ); /* Q0 */
1453 7391844 : move32();
1454 : }
1455 : }
1456 :
1457 : } /*end of the 2-tuples loop*/
1458 : #ifdef OPT_SBA_ENC_V2_BE
1459 399500 : total_output_bits = round_fx( W_shl_sat_l( bit_estimate_fx, -Q7 ) ); /* Q23 -> Q16 -> Q0 */
1460 : #else
1461 : total_output_bits = round_fx( W_extract_l( W_shr( bit_estimate_fx, Q7 ) ) ); /* Q23 -> Q16 -> Q0 */
1462 : #endif
1463 399500 : IF( *stop )
1464 : {
1465 : #ifdef OPT_SBA_ENC_V2_BE
1466 168835 : total_output_bits = round_fx( W_shl_sat_l( nbits2_fx, -Q7 ) ); /* Q23 -> Q16 -> Q0 */
1467 : #else
1468 : total_output_bits = round_fx( W_extract_l( W_shr( nbits2_fx, Q7 ) ) ); /* Q23 -> Q16 -> Q0 */
1469 : #endif
1470 : }
1471 :
1472 399500 : if ( stop2 )
1473 : {
1474 326338 : stop2 = total_output_bits; /* Q0 */
1475 326338 : move16();
1476 : }
1477 :
1478 399500 : *nEncoded = lastnz2; /* Q0 */
1479 399500 : move16();
1480 399500 : *stop = stop2; /* If zero, it means no overflow occured during bit-estimation Q0*/
1481 399500 : move16();
1482 399500 : *lastnz_out = lastnz; /* Q0 */
1483 399500 : move16();
1484 :
1485 : /* Restore hole indices beyond lastnz */
1486 134628308 : FOR( k = numHoleIndices; k < hm_cfg->numHoleIndices; ++k )
1487 : {
1488 134228808 : hm_cfg->holeIndices[k] = sub( hm_cfg->holeIndices[k], nt ); /* Q0 */
1489 134228808 : move16();
1490 : }
1491 399500 : hm_cfg->numPeakIndices = numPeakIndicesOrig; /* Q0 */
1492 399500 : move16();
1493 :
1494 : #ifdef OPT_SBA_ENC_V2_BE
1495 399500 : return round_fx( L_add( W_shl_sat_l( nbits2_fx, -Q7 ), ONE_IN_Q14 ) ); /* Q0 */
1496 : #else
1497 : return round_fx( L_add( W_extract_l( W_shr( nbits2_fx, Q7 ) ), ONE_IN_Q14 ) ); /* Q0 */
1498 : #endif
1499 : }
1500 : ELSE /* if (!hm_cfg) */
1501 : {
1502 : Word16 esc_nb, cp, rateQ;
1503 : UWord16 s;
1504 : Word16 tot_bits2;
1505 3486980 : Word16 overflow_flag = 0;
1506 3486980 : move16();
1507 :
1508 : /* Rate flag */
1509 3486980 : IF( GT_16( target, 400 ) )
1510 : {
1511 2650867 : rateFlag = 2; /* Q0 */
1512 2650867 : move16();
1513 : }
1514 : ELSE
1515 : {
1516 836113 : rateFlag = 0; /* Select context-B for lower bitrates */
1517 836113 : move16();
1518 : }
1519 :
1520 3486980 : t = 0;
1521 3486980 : move16();
1522 3486980 : s = 0;
1523 3486980 : move16();
1524 3486980 : cp = 0;
1525 3486980 : move16();
1526 3486980 : lastnz = 1;
1527 3486980 : move16();
1528 3486980 : lastnz2 = 0;
1529 3486980 : move16();
1530 3486980 : tot_bits2 = 0;
1531 3486980 : move16();
1532 :
1533 : /* Find last non-zero tuple in the mapped domain signal */
1534 590286159 : FOR( lastnz = sub( nt, 2 ); lastnz >= 0; lastnz -= 2 )
1535 : {
1536 590272471 : test();
1537 590272471 : IF( ( x[lastnz] != 0 ) || ( x[lastnz + 1] != 0 ) )
1538 : {
1539 : BREAK;
1540 : }
1541 : }
1542 3486980 : lastnz = add( lastnz, 2 ); /* Q0 */
1543 3486980 : IF( LT_16( lastnz, 2 ) )
1544 : {
1545 13688 : lastnz = 2; /* At least one tuple is coded Q0*/
1546 13688 : move16();
1547 : }
1548 :
1549 3486980 : lastnz2 = 2;
1550 3486980 : move16();
1551 :
1552 : /* Main Loop through the 2-tuples */
1553 776407841 : FOR( k = 0; k < lastnz; k += 2 )
1554 : {
1555 : /* Init current 2-tuple encoding */
1556 772920861 : a1 = abs_s( x[k] ); /* Q0 */
1557 772920861 : b1 = abs_s( x[k + 1] ); /* Q0 */
1558 772920861 : lev1 = 0;
1559 772920861 : move16();
1560 772920861 : esc_nb = 0;
1561 772920861 : move16();
1562 772920861 : rateQ = add( rateFlag, extract_l( GT_16( k, shr( nt, 1 ) ) ) ); /* Q0 */
1563 :
1564 772920861 : bit_estimate_fx = W_add( bit_estimate_fx, MAKE_VARIABLE_QX( s_min( a1, 1 ), Q23 ) );
1565 772920861 : bit_estimate_fx = W_add( bit_estimate_fx, MAKE_VARIABLE_QX( s_min( b1, 1 ), Q23 ) );
1566 :
1567 : /* pre-compute address of ari_pk_s17_LC_ext[0][Val_esc] to avoid doing it multiple times inside the loop */
1568 772920861 : lookup = &ari_lookup_s17_LC[t + shl( rateQ, NBITS_CONTEXT )]; /* Q0 */
1569 :
1570 : /* check while condition */
1571 : /* MSBs coding */
1572 : #ifdef OPT_SBA_ENC_V2_BE
1573 921819652 : FOR( ; s_max( a1, b1 ) >= A_THRES; )
1574 : {
1575 148898791 : pki = lookup[( esc_nb << ( NBITS_CONTEXT + NBITS_RATEQ ) )]; /* Q0 */
1576 :
1577 148898791 : bit_estimate_fx = W_add( bit_estimate_fx, ari_bit_estimate_s17_LC_fx[pki][VAL_ESC] );
1578 148898791 : bit_estimate_fx = W_add( bit_estimate_fx, MAKE_NUMBER_QX( 2, Q23 ) );
1579 :
1580 148898791 : a1 = shr( a1, 1 );
1581 148898791 : b1 = shr( b1, 1 );
1582 :
1583 148898791 : lev1 = add( lev1, 1 );
1584 148898791 : esc_nb = s_min( lev1, 3 );
1585 : }
1586 : #else
1587 : WHILE( GE_16( s_max( a1, b1 ), A_THRES ) )
1588 : {
1589 : pki = lookup[( esc_nb << ( NBITS_CONTEXT + NBITS_RATEQ ) )]; /* Q0 */
1590 : move16();
1591 :
1592 : bit_estimate_fx = W_add( bit_estimate_fx, ari_bit_estimate_s17_LC_fx[pki][VAL_ESC] );
1593 : bit_estimate_fx = W_add( bit_estimate_fx, MAKE_NUMBER_QX( 2, Q23 ) );
1594 :
1595 : a1 = shr( a1, 1 );
1596 : b1 = shr( b1, 1 );
1597 :
1598 : lev1 = add( lev1, 1 );
1599 : esc_nb = s_min( lev1, 3 );
1600 :
1601 : /* check while condition */
1602 : }
1603 : #endif
1604 772920861 : pki = lookup[( esc_nb << ( NBITS_CONTEXT + NBITS_RATEQ ) )]; /* Q0 */
1605 :
1606 772920861 : symbol = add( a1, i_mult( A_THRES, b1 ) ); /* Q0 */
1607 772920861 : bit_estimate_fx = W_add( bit_estimate_fx, ari_bit_estimate_s17_LC_fx[pki][symbol] );
1608 :
1609 : /* Should we truncate? */
1610 : #ifdef OPT_SBA_ENC_V2_BE
1611 772920861 : IF( GT_32( W_shl_sat_l( bit_estimate_fx, -Q8 ), target_Q15 ) ) // Q15
1612 : #else
1613 : IF( GT_32( W_extract_l( W_shr( bit_estimate_fx, Q8 ) ), L_shl( target, Q15 ) ) )
1614 : #endif
1615 : {
1616 26958122 : overflow_flag = 1;
1617 26958122 : move16();
1618 : }
1619 : ELSE
1620 : {
1621 745962739 : IF( abs_s( x[k] ) || abs_s( x[k + 1] ) ) /* No overflow & non-zero tuple */
1622 : {
1623 450180323 : nbits2_fx = bit_estimate_fx; /* exp(bit_estimate_e) */
1624 450180323 : move64();
1625 :
1626 450180323 : lastnz2 = add( k, 2 );
1627 : }
1628 : }
1629 :
1630 : #ifdef OPT_SBA_ENC_V2_BE
1631 : /* Update context for next 2-tuple */
1632 772920861 : cp = add( 1, i_mult( add( a1, b1 ), add( esc_nb, 1 ) ) ); /* Q0 */
1633 772920861 : if ( GE_16( esc_nb, 2 ) )
1634 : {
1635 36927925 : cp = add( 12, esc_nb ); /* Q0 */
1636 : }
1637 : #else
1638 : /* Update context for next 2-tuple */
1639 : IF( LT_16( esc_nb, 2 ) )
1640 : {
1641 : cp = add( 1, i_mult( add( a1, b1 ), add( esc_nb, 1 ) ) ); /* Q0 */
1642 : }
1643 : ELSE
1644 : {
1645 : cp = add( 12, esc_nb ); /* Q0 */
1646 : }
1647 : #endif
1648 : /*shift old bits and replace last 4 bits*/
1649 772920861 : s = (UWord16) L_add( L_shl( s, 4 ), cp );
1650 772920861 : t = s_and( s, 0xFF );
1651 : } /*end of the 2-tuples loop*/
1652 :
1653 : #ifdef OPT_SBA_ENC_V2_BE
1654 3486980 : tot_bits2 = round_fx( W_shl_sat_l( nbits2_fx, -Q7 ) ); /* Q23 -> Q16 -> Q0 */
1655 3486980 : round_bit_estimate_fx = round_fx( W_shl_sat_l( bit_estimate_fx, -Q7 ) ); /* Q23 -> Q16 -> Q0 */
1656 : #else
1657 : tot_bits2 = round_fx( W_extract_l( W_shr( nbits2_fx, Q7 ) ) ); /* Q23 -> Q16 -> Q0 */
1658 : #endif
1659 3486980 : if ( LT_16( lastnz2, lastnz ) ) /* Overflow occured because unable to code all tuples */
1660 : {
1661 1430012 : overflow_flag = 1;
1662 1430012 : move16();
1663 : }
1664 : #ifdef OPT_SBA_ENC_V2_BE
1665 3486980 : if ( EQ_16( mode, -1 ) )
1666 : {
1667 0 : tot_bits2 = round_bit_estimate_fx;
1668 0 : move16();
1669 : }
1670 : #else
1671 : IF( EQ_16( mode, -1 ) )
1672 : {
1673 : tot_bits2 = round_fx( W_shl_sat_l( bit_estimate_fx, -Q7 ) ); /* Q23 -> Q16 -> Q0 */
1674 : }
1675 : #endif
1676 : #ifdef OPT_SBA_ENC_V2_BE
1677 3486980 : if ( overflow_flag == 0 ) /* No overflow */
1678 : {
1679 2056968 : *stop = 0;
1680 2056968 : move16();
1681 : }
1682 3486980 : IF( overflow_flag != 0 ) /* Overflow */
1683 : {
1684 1430012 : IF( *stop )
1685 : {
1686 9686 : *stop = tot_bits2; /* Q0 */
1687 9686 : move16();
1688 : }
1689 : ELSE
1690 : {
1691 1420326 : *stop = round_bit_estimate_fx;
1692 1420326 : move16();
1693 : }
1694 : }
1695 : #else
1696 : IF( overflow_flag == 0 ) /* No overflow */
1697 : {
1698 : *stop = 0;
1699 : move16();
1700 : }
1701 : ELSE /* Overflow */
1702 : {
1703 : IF( *stop )
1704 : {
1705 : *stop = tot_bits2; /* Q0 */
1706 : move16();
1707 : }
1708 : ELSE
1709 : {
1710 : *stop = round_fx( W_extract_l( W_shr( bit_estimate_fx, Q7 ) ) ); /* Q23 -> Q16 -> Q0 */
1711 : move16();
1712 : }
1713 : }
1714 : #endif
1715 :
1716 3486980 : *lastnz_out = lastnz; /* Q0 */
1717 3486980 : move16();
1718 3486980 : *nEncoded = lastnz2; /* Q0 */
1719 3486980 : move16();
1720 : /* Safety mechanism to avoid overflow */
1721 3486980 : test();
1722 3486980 : IF( EQ_16( lastnz2, 2 ) && EQ_16( overflow_flag, 1 ) )
1723 : {
1724 174 : FOR( k = 0; k < lastnz2; k++ )
1725 : {
1726 116 : x[k] = 0;
1727 116 : move16();
1728 : }
1729 : }
1730 :
1731 3486980 : return tot_bits2;
1732 : }
1733 : }
1734 :
1735 :
1736 : /*-------------------------------------------------------------------*
1737 : * RCcontextMapping_encode2_estimate_bandWise_start_fx()
1738 : *
1739 : * Range coder - start bandwise bit-estimation
1740 : *-------------------------------------------------------------------*/
1741 :
1742 552892 : Word16 RCcontextMapping_encode2_estimate_bandWise_start_fx(
1743 : Word16 *x, /* Q0 */
1744 : const Word16 nt, /* Q0 */
1745 : const Word16 target, /* Q0 */
1746 : HANDLE_RC_CONTEXT_MEM hContextMem )
1747 : {
1748 : Word16 i, k;
1749 :
1750 : /* Rate flag */
1751 552892 : IF( GT_16( target, 400 ) )
1752 : {
1753 543524 : hContextMem->rateFlag = 2 << NBITS_CONTEXT;
1754 543524 : move16();
1755 : }
1756 : ELSE
1757 : {
1758 9368 : hContextMem->rateFlag = 0;
1759 9368 : move16();
1760 : }
1761 :
1762 552892 : hContextMem->bit_estimate_fx = MAKE_NUMBER_QX( 2, Q23 );
1763 552892 : move64();
1764 :
1765 :
1766 : /* Init */
1767 552892 : hContextMem->nt_half = shr( nt, 1 );
1768 552892 : move16();
1769 :
1770 : /* bits to encode lastnz */
1771 552892 : k = 1;
1772 552892 : move16();
1773 :
1774 5206056 : WHILE( LT_16( k, hContextMem->nt_half ) )
1775 : {
1776 4653164 : hContextMem->bit_estimate_fx = W_add( hContextMem->bit_estimate_fx, MAKE_NUMBER_QX( 1, Q23 ) );
1777 4653164 : move64();
1778 :
1779 4653164 : k = shl( k, 1 );
1780 : /* check while condition */
1781 : }
1782 :
1783 : /* bits to encode lastnz */
1784 552892 : hContextMem->nbits_old = round_fx( W_extract_l( W_shr( hContextMem->bit_estimate_fx, Q7 ) ) ); /* Q0 */
1785 552892 : move16();
1786 :
1787 552892 : hContextMem->ctx = 0;
1788 552892 : move16();
1789 552892 : hContextMem->lastnz = 2;
1790 552892 : move16();
1791 :
1792 : /* Find last non-zero tuple */
1793 :
1794 8218850 : FOR( i = nt; i >= 4; i -= 2 )
1795 : {
1796 8218203 : test();
1797 8218203 : IF( x[i - 2] != 0 || x[i - 1] != 0 )
1798 : {
1799 552245 : hContextMem->lastnz = i;
1800 552245 : move16();
1801 552245 : BREAK;
1802 : }
1803 : }
1804 :
1805 552892 : return hContextMem->nbits_old;
1806 : }
1807 :
1808 : /*-------------------------------------------------------------------*
1809 : * RCcontextMapping_encode2_estimate_bandWise_fx()
1810 : *
1811 : * Range coder - bandwise bit-estimation
1812 : *-------------------------------------------------------------------*/
1813 :
1814 21943852 : Word16 RCcontextMapping_encode2_estimate_bandWise_fx(
1815 : Word16 *x, /* Q0 */
1816 : const Word16 start_line, /* Q0 */
1817 : const Word16 end_line, /* Q0 */
1818 : HANDLE_RC_CONTEXT_MEM hContextMem )
1819 : {
1820 : Word16 a1, b1, a1_i, b1_i;
1821 : Word16 k, pki, lev1;
1822 : UWord16 t;
1823 21943852 : Word16 bandBits = 0;
1824 21943852 : move16();
1825 : Word16 total_output_bits; /* No. of bits after finalization */
1826 : Word16 symbol;
1827 : const UWord8 *lookup;
1828 : Word16 idx;
1829 : Word16 tmp;
1830 :
1831 : /* Main Loop through the 2-tuples */
1832 : /*hContextMem->nt_half = end_line >> 1;*/
1833 21943852 : Word16 len = s_min( hContextMem->lastnz, end_line );
1834 172154708 : FOR( k = start_line; k < len; k += 2 )
1835 : {
1836 150210856 : a1_i = k; /* Q0 */
1837 150210856 : move16();
1838 150210856 : b1_i = add( k, 1 ); /* Q0 */
1839 :
1840 150210856 : idx = k;
1841 150210856 : move16();
1842 :
1843 : /* Get context */
1844 150210856 : t = add( hContextMem->ctx, hContextMem->rateFlag ); /* Q0 */
1845 :
1846 : #ifdef OPT_SBA_ENC_V2_BE
1847 150210856 : tmp = ( 1 << NBITS_CONTEXT );
1848 150210856 : move16();
1849 150210856 : if ( GE_16( hContextMem->nt_half, idx ) )
1850 : {
1851 78897473 : tmp = 0;
1852 78897473 : move16();
1853 : }
1854 : #else
1855 : IF( GE_16( hContextMem->nt_half, idx ) )
1856 : {
1857 : tmp = 0;
1858 : }
1859 : ELSE
1860 : {
1861 : tmp = ( 1 << NBITS_CONTEXT );
1862 : }
1863 : #endif
1864 :
1865 150210856 : t = add( t, tmp ); /* Q0 */
1866 :
1867 : /* Init current 2-tuple encoding */
1868 150210856 : a1 = abs_s( x[a1_i] ); /* Q0 */
1869 150210856 : b1 = abs_s( x[b1_i] ); /* Q0 */
1870 150210856 : lev1 = -( 1 << ( NBITS_CONTEXT + NBITS_RATEQ ) ); /* Q0 */
1871 :
1872 : /* Signs Bits */
1873 150210856 : hContextMem->bit_estimate_fx = W_add( hContextMem->bit_estimate_fx, MAKE_VARIABLE_QX( s_min( a1, 1 ), Q23 ) );
1874 150210856 : hContextMem->bit_estimate_fx = W_add( hContextMem->bit_estimate_fx, MAKE_VARIABLE_QX( s_min( b1, 1 ), Q23 ) );
1875 :
1876 150210856 : move32();
1877 150210856 : move32();
1878 :
1879 : /* pre-compute address of ari_pk_s17_LC_ext[0][Val_esc] to avoid doing it multiple times inside the loop */
1880 150210856 : lookup = &ari_lookup_s17_LC[t] + ( 1 << ( NBITS_CONTEXT + NBITS_RATEQ ) );
1881 :
1882 : /* check while condition */
1883 : /* MSBs coding */
1884 : #ifdef OPT_SBA_ENC_V2_BE
1885 181416096 : FOR( ; s_max( a1, b1 ) >= A_THRES; )
1886 : #else
1887 : WHILE( GE_16( s_max( a1, b1 ), A_THRES ) )
1888 : #endif
1889 : {
1890 31205240 : pki = lookup[lev1]; /* Q0 */
1891 :
1892 31205240 : hContextMem->bit_estimate_fx = W_add( hContextMem->bit_estimate_fx, ari_bit_estimate_s17_LC_fx[pki][VAL_ESC] );
1893 31205240 : hContextMem->bit_estimate_fx = W_add( hContextMem->bit_estimate_fx, MAKE_NUMBER_QX( 2, Q23 ) );
1894 31205240 : move64();
1895 31205240 : move64();
1896 :
1897 :
1898 : // hContextMem->bit_estimate = hContextMem->bit_estimate + ari_bit_estimate_s17_LC[pki][VAL_ESC];
1899 : // hContextMem->bit_estimate += 2; /* Add the 2 LSB bits that were shifted out */
1900 :
1901 31205240 : a1 = shr( a1, 1 );
1902 31205240 : b1 = shr( b1, 1 );
1903 :
1904 31205240 : lev1 = s_min( add( lev1, ( 1 << ( NBITS_CONTEXT + NBITS_RATEQ ) ) ), 2 << ( NBITS_CONTEXT + NBITS_RATEQ ) ); /* Q0 */
1905 : /* check while condition */
1906 : }
1907 :
1908 150210856 : pki = lookup[lev1]; /* Q0 */
1909 :
1910 150210856 : symbol = add( a1, i_mult( A_THRES, b1 ) ); /* MSB symbol Q0*/
1911 150210856 : hContextMem->bit_estimate_fx = W_add( hContextMem->bit_estimate_fx, ari_bit_estimate_s17_LC_fx[pki][symbol] );
1912 :
1913 150210856 : move64();
1914 : // hContextMem->bit_estimate = hContextMem->bit_estimate + ari_bit_estimate_s17_LC[pki][symbol];
1915 :
1916 : /* Update context */
1917 150210856 : lev1 = shr( lev1, NBITS_CONTEXT + NBITS_RATEQ );
1918 :
1919 : #ifdef OPT_SBA_ENC_V2_BE
1920 150210856 : t = add( 1, i_mult( add( a1, b1 ), add( lev1, 2 ) ) ); /* Q0 */
1921 150210856 : if ( lev1 > 0 )
1922 : {
1923 7801807 : t = add( 13, lev1 ); /* Q0 */
1924 : }
1925 : #else
1926 : IF( lev1 <= 0 )
1927 : {
1928 : t = add( 1, i_mult( add( a1, b1 ), add( lev1, 2 ) ) ); /* Q0 */
1929 : }
1930 : ELSE
1931 : {
1932 : t = add( 13, lev1 ); /* Q0 */
1933 : }
1934 : #endif
1935 150210856 : hContextMem->ctx = add( i_mult( s_and( hContextMem->ctx, 0xf ), 16 ), t ); /* Q0 */
1936 150210856 : move16();
1937 :
1938 : } /*end of the 2-tuples loop*/
1939 : #ifdef OPT_SBA_ENC_V2_BE
1940 21943852 : total_output_bits = round_fx( W_shl_sat_l( hContextMem->bit_estimate_fx, -Q7 ) ); /* Q0 */
1941 : #else
1942 : total_output_bits = round_fx( W_extract_l( W_shr( hContextMem->bit_estimate_fx, Q7 ) ) ); /* Q0 */
1943 : #endif
1944 : // total_output_bits = (Word16) ( hContextMem->bit_estimate + 0.5f );
1945 :
1946 :
1947 21943852 : bandBits = sub( total_output_bits, hContextMem->nbits_old ); /* Q0 */
1948 21943852 : hContextMem->nbits_old = total_output_bits; /* Q0 */
1949 21943852 : move16();
1950 :
1951 21943852 : return bandBits;
1952 : }
|
