Line data Source code
1 : /******************************************************************************************************
2 :
3 : (C) 2022-2025 IVAS codec Public Collaboration with portions copyright Dolby International AB, Ericsson AB,
4 : Fraunhofer-Gesellschaft zur Foerderung der angewandten Forschung e.V., Huawei Technologies Co. LTD.,
5 : Koninklijke Philips N.V., Nippon Telegraph and Telephone Corporation, Nokia Technologies Oy, Orange,
6 : Panasonic Holdings Corporation, Qualcomm Technologies, Inc., VoiceAge Corporation, and other
7 : contributors to this repository. All Rights Reserved.
8 :
9 : This software is protected by copyright law and by international treaties.
10 : The IVAS codec Public Collaboration consisting of Dolby International AB, Ericsson AB,
11 : Fraunhofer-Gesellschaft zur Foerderung der angewandten Forschung e.V., Huawei Technologies Co. LTD.,
12 : Koninklijke Philips N.V., Nippon Telegraph and Telephone Corporation, Nokia Technologies Oy, Orange,
13 : Panasonic Holdings Corporation, Qualcomm Technologies, Inc., VoiceAge Corporation, and other
14 : contributors to this repository retain full ownership rights in their respective contributions in
15 : the software. This notice grants no license of any kind, including but not limited to patent
16 : license, nor is any license granted by implication, estoppel or otherwise.
17 :
18 : Contributors are required to enter into the IVAS codec Public Collaboration agreement before making
19 : contributions.
20 :
21 : This software is provided "AS IS", without any express or implied warranties. The software is in the
22 : development stage. It is intended exclusively for experts who have experience with such software and
23 : solely for the purpose of inspection. All implied warranties of non-infringement, merchantability
24 : and fitness for a particular purpose are hereby disclaimed and excluded.
25 :
26 : Any dispute, controversy or claim arising under or in relation to providing this software shall be
27 : submitted to and settled by the final, binding jurisdiction of the courts of Munich, Germany in
28 : accordance with the laws of the Federal Republic of Germany excluding its conflict of law rules and
29 : the United Nations Convention on Contracts on the International Sales of Goods.
30 :
31 : *******************************************************************************************************/
32 :
33 : /*====================================================================================
34 : EVS Codec 3GPP TS26.443 Nov 04, 2021. Version 12.14.0 / 13.10.0 / 14.6.0 / 15.4.0 / 16.3.0
35 : ====================================================================================*/
36 :
37 : #include <stdint.h>
38 : #include "options.h"
39 : #include <assert.h>
40 : #include "cnst.h"
41 : #include "rom_com.h"
42 : #include "prot.h"
43 : #include "ivas_prot.h" /* Range coder header file */
44 : #include "ivas_rom_com.h"
45 : #include "ivas_rom_enc.h"
46 : #ifdef DEBUGGING
47 : #include "debug.h"
48 : #endif
49 : #include "wmc_auto.h"
50 :
51 :
52 : /*-------------------------------------------------------------------*
53 : * ACcontextMapping_encode2_no_mem_s17_LC()
54 : *
55 : * Arithmetic encoder
56 : *-------------------------------------------------------------------*/
57 :
58 30068 : void ACcontextMapping_encode2_no_mem_s17_LC(
59 : BSTR_ENC_HANDLE hBstr, /* i/o: bitstream handle */
60 : int16_t *x,
61 : int16_t nt,
62 : int16_t lastnz,
63 : int16_t nbbits,
64 : int16_t resQMaxBits,
65 : CONTEXT_HM_CONFIG *hm_cfg )
66 : {
67 : int16_t ptr[BITBUFSIZE];
68 : Tastat as, as_overflow;
69 : int16_t bp, bp_overflow;
70 : int16_t a1, b1, a1_i, b1_i, k;
71 : uint16_t t;
72 : int16_t pki, lev1;
73 : int16_t rateFlag;
74 : int16_t value;
75 : int16_t nbbits_ntuples, nbbits_lsbs, nbbits_signs, nbbits_signs_overflow, nbbits_lsbs_overflow, flag_overflow;
76 : int16_t *lsbs_bits;
77 : int16_t nt_half;
78 : int32_t c[2], *ctx;
79 : int32_t p1, p2;
80 : int16_t ii[2];
81 : int16_t idx1, idx2, idx;
82 : int16_t numPeakIndicesOrig, numHoleIndices;
83 : uint16_t signs[N_MAX];
84 : int16_t nbbits_m2;
85 :
86 30068 : a1 = 0; /* to avoid compilation warnings */
87 30068 : b1 = 0; /* to avoid compilation warnings */
88 :
89 : /* Rate flag */
90 30068 : if ( nbbits > 400 )
91 : {
92 14839 : rateFlag = 2 << NBITS_CONTEXT;
93 : }
94 : else
95 : {
96 15229 : rateFlag = 0;
97 : }
98 :
99 : /* Init */
100 30068 : nt_half = nt >> 1;
101 30068 : c[0] = c[1] = 0;
102 :
103 : /* Bits for encoding the number of encoded tuples */
104 30068 : nbbits_ntuples = 0;
105 30068 : k = 1;
106 :
107 292112 : while ( k < nt / 2 )
108 : {
109 262044 : nbbits_ntuples++;
110 262044 : k = k << 1;
111 : }
112 :
113 30068 : t = 0;
114 30068 : bp = nbbits_ntuples;
115 30068 : nbbits_signs = 0;
116 30068 : nbbits_lsbs = 0;
117 30068 : nbbits_m2 = nbbits - 2;
118 30068 : flag_overflow = 0;
119 :
120 30068 : if ( hm_cfg )
121 : {
122 : /* mapped domain */
123 3568 : numPeakIndicesOrig = hm_cfg->numPeakIndices;
124 3568 : hm_cfg->numPeakIndices = min( hm_cfg->numPeakIndices, lastnz );
125 3568 : numHoleIndices = lastnz - hm_cfg->numPeakIndices;
126 :
127 : /* Mark hole indices beyond lastnz as pruned */
128 753056 : for ( k = numHoleIndices; k < hm_cfg->numHoleIndices; ++k )
129 : {
130 749488 : hm_cfg->holeIndices[k] = hm_cfg->holeIndices[k] + nt;
131 : }
132 :
133 3568 : ii[0] = numPeakIndicesOrig;
134 3568 : ii[1] = 0;
135 :
136 3568 : p1 = p2 = 0; /* to avoid compilation warnings */
137 : }
138 : else
139 : {
140 : /* unmapped domain */
141 26500 : ii[0] = 0;
142 :
143 26500 : p1 = p2 = 0;
144 :
145 : /* Find last non-zero tuple */
146 : /* ensure termination of while loop by dummy value */
147 26500 : a1 = x[0];
148 26500 : x[0] = 1;
149 :
150 86884 : while ( x[lastnz - 1] == 0 && x[lastnz - 2] == 0 )
151 : {
152 60384 : lastnz -= 2;
153 : }
154 26500 : x[0] = a1;
155 : }
156 :
157 30068 : lsbs_bits = (int16_t *) ptr + nbbits - 1;
158 :
159 : /*Start Encoding*/
160 30068 : ari_start_encoding_14bits( &as );
161 :
162 : /*Main Loop through the 2-tuples*/
163 30068 : b1_i = -1;
164 :
165 4609186 : for ( k = 0; k < lastnz; k += 2 )
166 : {
167 :
168 4579128 : if ( hm_cfg )
169 : {
170 496936 : a1_i = get_next_coeff_mapped( ii, &p1, &idx1, hm_cfg );
171 496936 : b1_i = get_next_coeff_mapped( ii, &p2, &idx2, hm_cfg );
172 : }
173 : else
174 : {
175 4082192 : a1_i = get_next_coeff_unmapped( ii, &idx1 );
176 4082192 : b1_i = get_next_coeff_unmapped( ii, &idx2 );
177 : }
178 :
179 4579128 : idx = min( idx1, idx2 );
180 :
181 : /* Get context */
182 4579128 : ctx = &c[p1 | p2];
183 :
184 4579128 : t = (uint16_t) ( *ctx + rateFlag );
185 4579128 : t += ( nt_half >= idx ) ? 0 : ( 1 << NBITS_CONTEXT );
186 :
187 : /* Init current 2-tuple encoding */
188 :
189 4579128 : if ( flag_overflow != 0 )
190 : {
191 0 : x[a1_i] = 0;
192 0 : x[b1_i] = 0;
193 : }
194 :
195 4579128 : a1 = (int16_t) abs( x[a1_i] );
196 4579128 : b1 = (int16_t) abs( x[b1_i] );
197 :
198 4579128 : lev1 = -1;
199 :
200 : /*Copy states*/
201 4579128 : ari_copy_states( &as, &as_overflow );
202 4579128 : bp_overflow = bp;
203 4579128 : nbbits_signs_overflow = nbbits_signs;
204 4579128 : nbbits_lsbs_overflow = nbbits_lsbs;
205 :
206 : /*Signs encoding*/
207 :
208 4579128 : if ( a1 > 0 )
209 : {
210 2058166 : signs[nbbits_signs++] = ( (uint16_t) x[a1_i] >> ( sizeof( uint16_t ) * 8 - 1 ) );
211 : }
212 :
213 4579128 : if ( b1 > 0 )
214 : {
215 2057464 : signs[nbbits_signs++] = ( (uint16_t) x[b1_i] >> ( sizeof( uint16_t ) * 8 - 1 ) );
216 : }
217 :
218 : /* MSBs coding */
219 5934046 : while ( max( a1, b1 ) >= A_THRES )
220 : {
221 1354918 : pki = ari_lookup_s17_LC[t + ( ( lev1 + 1 ) << ( NBITS_CONTEXT + NBITS_RATEQ ) )];
222 1354918 : bp = ari_encode_14bits_ext( ptr, bp, &as, VAL_ESC, ari_pk_s17_LC_ext[pki] );
223 :
224 1354918 : *lsbs_bits-- = a1 & 1;
225 1354918 : *lsbs_bits-- = b1 & 1;
226 :
227 : /* LSBs bit counting */
228 1354918 : nbbits_lsbs += 2;
229 :
230 1354918 : a1 >>= 1;
231 1354918 : b1 >>= 1;
232 :
233 1354918 : lev1 = min( lev1 + 1, 2 );
234 : }
235 :
236 4579128 : pki = ari_lookup_s17_LC[t + ( ( lev1 + 1 ) << ( NBITS_CONTEXT + NBITS_RATEQ ) )];
237 4579128 : bp = ari_encode_14bits_ext( ptr, bp, &as, a1 + A_THRES * b1, ari_pk_s17_LC_ext[pki] );
238 :
239 :
240 : /* Check bit budget */
241 4579128 : if ( bp + as.bits_to_follow + nbbits_signs + nbbits_lsbs > nbbits_m2 )
242 : {
243 10 : ari_copy_states( &as_overflow, &as );
244 10 : bp = bp_overflow;
245 :
246 10 : if ( !flag_overflow )
247 : {
248 10 : nbbits_signs = nbbits_signs_overflow;
249 10 : nbbits_lsbs = nbbits_lsbs_overflow;
250 :
251 10 : if ( hm_cfg )
252 : {
253 6 : flag_overflow = 1;
254 :
255 : /* Code from now only zeros */
256 6 : x[a1_i] = 0;
257 6 : x[b1_i] = 0;
258 6 : lev1 = -1;
259 :
260 6 : pki = ari_lookup_s17_LC[t];
261 6 : bp = ari_encode_14bits_ext( ptr, bp, &as, 0, ari_pk_s17_LC_ext[pki] );
262 :
263 6 : if ( bp + as.bits_to_follow + nbbits_signs + nbbits_lsbs > nbbits_m2 )
264 : {
265 6 : ari_copy_states( &as_overflow, &as );
266 6 : bp = bp_overflow;
267 6 : break;
268 : }
269 : }
270 : else
271 : {
272 4 : break;
273 : }
274 : }
275 : else
276 : {
277 0 : break;
278 : }
279 : }
280 :
281 : /* Update context for next 2-tuple */
282 4579118 : if ( p1 == p2 )
283 : {
284 : /* peak-peak or hole-hole context */
285 :
286 4518606 : if ( lev1 <= 0 )
287 : {
288 4154648 : t = 1 + ( a1 + b1 ) * ( lev1 + 2 );
289 : }
290 : else
291 : {
292 363958 : t = 13 + lev1;
293 : }
294 :
295 4518606 : *ctx = ( *ctx & 0xf ) * 16 + t;
296 : }
297 : else
298 : {
299 : /* mixed context */
300 :
301 60512 : if ( idx1 & 1 )
302 : {
303 : /* update first context */
304 30374 : c[p1] = update_mixed_context( c[p1], (int16_t) abs( x[a1_i] ) );
305 : }
306 :
307 60512 : if ( idx2 & 1 )
308 : {
309 : /* update second context */
310 30138 : c[p2] = update_mixed_context( c[p2], (int16_t) abs( x[b1_i] ) );
311 : }
312 : }
313 : } /*end of the 2-tuples loop*/
314 :
315 :
316 : /* End arithmetic coder, overflow management */
317 30068 : bp = ari_done_encoding_14bits( ptr, bp, &as );
318 :
319 : /*Overflow is detected*/
320 :
321 30068 : if ( k != lastnz )
322 : {
323 :
324 10 : if ( hm_cfg )
325 : {
326 : /*Fill with zero to be sure that decoder finish at the same position the MSB decoding*/
327 :
328 9 : for ( ; bp < nbbits - ( nbbits_signs + nbbits_lsbs ); )
329 : {
330 3 : ptr[bp++] = 0;
331 : }
332 : }
333 : else
334 : {
335 4 : lastnz = k;
336 : }
337 : }
338 :
339 : /* Push number of encoded tuples */
340 30068 : value = ( lastnz >> 1 ) - 1;
341 30068 : push_next_indice( hBstr, value, nbbits_ntuples );
342 :
343 : /* Push arithmetic coded bits */
344 30068 : push_next_bits( hBstr, (uint16_t *) &ptr[nbbits_ntuples], bp - nbbits_ntuples );
345 :
346 : /* Push sign bits */
347 30068 : push_next_bits( hBstr, (uint16_t *) signs, nbbits_signs );
348 30068 : bp += nbbits_signs;
349 :
350 : /* write residual Quantization bits */
351 201448 : for ( k = 0; k < min( nbbits - bp - nbbits_lsbs, resQMaxBits ); k++ )
352 : {
353 171380 : ptr[nbbits - 1 - nbbits_lsbs - k] = x[nt + k];
354 : }
355 :
356 : /* Write filler bits */
357 269416 : for ( ; k < nbbits - bp - nbbits_lsbs; ++k )
358 : {
359 239348 : ptr[nbbits - 1 - nbbits_lsbs - k] = 0;
360 : }
361 :
362 : /* Check for debugging */
363 30068 : assert( bp + k <= nbbits );
364 :
365 : /* Push the rest of the buffer */
366 30068 : push_next_bits( hBstr, (uint16_t *) &ptr[bp], nbbits - bp );
367 :
368 : #ifdef DEBUGGING
369 : /* return (bp+nbbits_lsbs);*/ /*return only for debug plot*/
370 : #endif
371 30068 : return;
372 : }
373 :
374 : /*-------------------------------------------------------------------*
375 : * find_last_nz_pair()
376 : *
377 : *
378 : *-------------------------------------------------------------------*/
379 :
380 5082625 : static int16_t find_last_nz_pair(
381 : const int16_t x[],
382 : const int16_t length,
383 : const CONTEXT_HM_CONFIG *hm_cfg )
384 : {
385 : int16_t last_nz, i;
386 : const int16_t *tmp;
387 :
388 5082625 : last_nz = 2;
389 :
390 5082625 : if ( hm_cfg )
391 : {
392 : /* mapped kernel */
393 4941831 : tmp = hm_cfg->indexBuffer;
394 :
395 948834954 : for ( i = length; i >= 4; i -= 2 )
396 : {
397 :
398 948276043 : if ( x[tmp[i - 2]] != 0 || x[tmp[i - 1]] != 0 )
399 : {
400 4382920 : last_nz = i;
401 4382920 : break;
402 : }
403 : }
404 : }
405 : else
406 : {
407 : /* unmapped kernel */
408 :
409 20624664 : for ( i = length; i >= 4; i -= 2 )
410 : {
411 :
412 20623744 : if ( x[i - 2] != 0 || x[i - 1] != 0 )
413 : {
414 139874 : last_nz = i;
415 139874 : break;
416 : }
417 : }
418 : }
419 :
420 5082625 : return last_nz;
421 : }
422 :
423 :
424 : /*-------------------------------------------------------------------*
425 : * ACcontextMapping_encode2_estimate_no_mem_s17_LC()
426 : *
427 : *
428 : *-------------------------------------------------------------------*/
429 :
430 196606 : int16_t ACcontextMapping_encode2_estimate_no_mem_s17_LC(
431 : const int16_t *x,
432 : const int16_t nt,
433 : int16_t *lastnz_out,
434 : int16_t *nEncoded,
435 : const int16_t target,
436 : int16_t *stop,
437 : CONTEXT_HM_CONFIG *hm_cfg )
438 : {
439 : int16_t a1, b1, a1_i, b1_i;
440 : int16_t k, pki, lev1;
441 : uint16_t t;
442 : int16_t lastnz, lastnz2;
443 : int16_t rateFlag;
444 : int16_t nbits_old, nbits;
445 : int16_t stop2;
446 : int32_t proba;
447 : int16_t nlz;
448 : const uint16_t *cum_freq;
449 : int16_t symbol;
450 : const uint8_t *lookup;
451 : int16_t nt_half;
452 : int32_t c[2], *ctx;
453 : int32_t p1, p2;
454 : int16_t ii[2];
455 : int16_t idx1, idx2, idx;
456 196606 : int16_t numPeakIndicesOrig = 0, numHoleIndices = 0; /* only to avoid compiler warning */
457 :
458 : /* Rate flag */
459 196606 : if ( target > 400 )
460 : {
461 87352 : rateFlag = 2 << NBITS_CONTEXT;
462 : }
463 : else
464 : {
465 109254 : rateFlag = 0;
466 : }
467 :
468 : /* 2 bits = arithmetic coder initialization interval = 1 bits for rounding last proba + 1 bit?*/
469 196606 : nbits = 2;
470 : /*proba coded on 14bits -> proba=1*/
471 196606 : proba = 16384;
472 :
473 : /* Init */
474 196606 : nt_half = nt >> 1;
475 196606 : stop2 = 0;
476 196606 : c[0] = c[1] = 0;
477 :
478 : /* bits to encode lastnz */
479 196606 : k = 1;
480 :
481 1912141 : while ( k < nt / 2 )
482 : {
483 1715535 : nbits++;
484 1715535 : k = k << 1;
485 : /* check while condition */
486 : }
487 196606 : nbits_old = nbits;
488 :
489 196606 : nbits -= target;
490 :
491 : /* Find last non-zero tuple in the mapped domain signal */
492 196606 : lastnz = find_last_nz_pair( x, nt, hm_cfg );
493 :
494 : /* At least one tuple is coded */
495 196606 : lastnz2 = 2;
496 :
497 196606 : if ( hm_cfg )
498 : {
499 : /* mapped domain */
500 55812 : numPeakIndicesOrig = hm_cfg->numPeakIndices;
501 55812 : hm_cfg->numPeakIndices = min( hm_cfg->numPeakIndices, lastnz );
502 55812 : numHoleIndices = lastnz - hm_cfg->numPeakIndices;
503 :
504 : /* Mark hole indices beyond lastnz as pruned */
505 12692546 : for ( k = numHoleIndices; k < hm_cfg->numHoleIndices; ++k )
506 : {
507 12636734 : hm_cfg->holeIndices[k] = hm_cfg->holeIndices[k] + nt;
508 : }
509 :
510 55812 : ii[0] = numPeakIndicesOrig;
511 55812 : ii[1] = 0;
512 :
513 55812 : p1 = p2 = 0; /* to avoid compilation warnings */
514 : }
515 : else
516 : {
517 : /* unmapped domain */
518 140794 : ii[0] = 0;
519 :
520 140794 : p1 = p2 = 0;
521 : }
522 :
523 : /* Main Loop through the 2-tuples */
524 30155471 : for ( k = 0; k < lastnz; k += 2 )
525 : {
526 29979832 : if ( hm_cfg )
527 : {
528 8477101 : a1_i = get_next_coeff_mapped( ii, &p1, &idx1, hm_cfg );
529 8477101 : b1_i = get_next_coeff_mapped( ii, &p2, &idx2, hm_cfg );
530 : }
531 : else
532 : {
533 21502731 : a1_i = get_next_coeff_unmapped( ii, &idx1 );
534 21502731 : b1_i = get_next_coeff_unmapped( ii, &idx2 );
535 : }
536 :
537 29979832 : idx = min( idx1, idx2 );
538 :
539 : /* Get context */
540 29979832 : ctx = &c[p1 | p2];
541 :
542 29979832 : t = (uint16_t) ( *ctx + rateFlag );
543 29979832 : t += ( nt_half >= idx ) ? 0 : ( 1 << NBITS_CONTEXT );
544 :
545 : /* Init current 2-tuple encoding */
546 29979832 : a1 = (int16_t) abs( x[a1_i] );
547 29979832 : b1 = (int16_t) abs( x[b1_i] );
548 29979832 : lev1 = -( 1 << ( NBITS_CONTEXT + NBITS_RATEQ ) );
549 :
550 : /* Signs Bits */
551 29979832 : nbits += min( a1, 1 );
552 29979832 : nbits += min( b1, 1 );
553 :
554 : /* pre-compute address of ari_pk_s17_LC_ext[0][Val_esc] to avoid doing it multiple times inside the loop */
555 29979832 : lookup = &ari_lookup_s17_LC[t] + ( 1 << ( NBITS_CONTEXT + NBITS_RATEQ ) );
556 :
557 : /* check while condition */
558 : /* MSBs coding */
559 37171162 : while ( max( a1, b1 ) >= A_THRES )
560 : {
561 7191330 : pki = lookup[lev1];
562 7191330 : cum_freq = ari_pk_s17_LC_ext[pki] + VAL_ESC;
563 : /*p1*p2=proba on 28 bits: p=0.5->power(2,27)*/
564 7191330 : proba *= *( cum_freq );
565 : /*Number of leading zero computed in one cycle=norm_l() in BASOP*/
566 7191330 : nlz = 2;
567 16475727 : while ( proba < 134217728 ) /*power(2,27)*/
568 : {
569 9284397 : nlz++;
570 9284397 : proba = proba << 1;
571 : }
572 7191330 : nbits += nlz;
573 : /*addition added as shift not done in norm_l(): real shift = 14-nlz*/
574 7191330 : proba >>= 14; /*proba is rounded down on 14 bits ->automatic over-estimation of bit consumption*/
575 :
576 7191330 : ( a1 ) >>= 1;
577 7191330 : ( b1 ) >>= 1;
578 :
579 7191330 : lev1 = min( lev1 + ( 1 << ( NBITS_CONTEXT + NBITS_RATEQ ) ), 2 << ( NBITS_CONTEXT + NBITS_RATEQ ) );
580 : /* check while condition */
581 : }
582 29979832 : pki = lookup[lev1];
583 29979832 : symbol = a1 + A_THRES * b1;
584 29979832 : cum_freq = ari_pk_s17_LC_ext[pki] + symbol;
585 : /*p1*p2=proba on 28 bits: p=0.5->power(2,27)*/
586 29979832 : proba *= ( cum_freq[0] - cum_freq[1] );
587 : /*Number of leading zero computed in one cycle=norm_l() in BASOP*/
588 29979832 : nlz = 0;
589 106561153 : while ( proba < 134217728 ) /*power(2,27)*/
590 : {
591 76581321 : nlz++;
592 76581321 : proba = proba << 1;
593 : }
594 :
595 29979832 : nbits += nlz;
596 29979832 : proba >>= 14; /*proba is rounded down on 14 bits ->automatic over-estimation of bit consumption*/
597 :
598 : /* Should we truncate? */
599 29979832 : if ( nbits > 0 )
600 : {
601 1683662 : stop2 = 1;
602 :
603 1683662 : if ( *stop )
604 : {
605 20967 : break;
606 : }
607 : }
608 : else
609 : {
610 28296170 : if ( hm_cfg || k == 0 || x[a1_i] || x[b1_i] )
611 : {
612 20341724 : nbits_old = nbits + target;
613 20341724 : lastnz2 = b1_i + 1;
614 : }
615 : }
616 :
617 : /* Update context for next 2-tuple */
618 29958865 : if ( p1 == p2 ) /* peak-peak or hole-hole context */
619 : {
620 28550445 : lev1 >>= NBITS_CONTEXT + NBITS_RATEQ;
621 :
622 28550445 : if ( lev1 <= 0 )
623 : {
624 26671129 : t = 1 + ( a1 + b1 ) * ( lev1 + 2 );
625 : }
626 : else
627 : {
628 1879316 : t = 13 + lev1;
629 : }
630 :
631 28550445 : *ctx = ( *ctx & 0xf ) * 16 + t;
632 : }
633 : else
634 : {
635 : /* mixed context */
636 :
637 1408420 : if ( idx1 & 1 )
638 : {
639 : /* update first context */
640 690617 : c[p1] = update_mixed_context( c[p1], (int16_t) abs( x[a1_i] ) );
641 : }
642 :
643 1408420 : if ( idx2 & 1 )
644 : {
645 : /* update second context */
646 714625 : c[p2] = update_mixed_context( c[p2], (int16_t) abs( x[b1_i] ) );
647 : }
648 : }
649 : } /*end of the 2-tuples loop*/
650 :
651 196606 : nbits += target;
652 :
653 : /* Output */
654 :
655 196606 : if ( *stop )
656 : {
657 23259 : nbits = nbits_old;
658 : }
659 :
660 196606 : if ( stop2 )
661 : {
662 107110 : stop2 = nbits;
663 : }
664 196606 : *nEncoded = lastnz2;
665 196606 : *stop = stop2;
666 196606 : *lastnz_out = lastnz;
667 :
668 196606 : if ( hm_cfg )
669 : {
670 : /* Restore hole indices beyond lastnz */
671 12692546 : for ( k = numHoleIndices; k < hm_cfg->numHoleIndices; ++k )
672 : {
673 12636734 : hm_cfg->holeIndices[k] = hm_cfg->holeIndices[k] - nt;
674 : }
675 55812 : hm_cfg->numPeakIndices = numPeakIndicesOrig;
676 : }
677 :
678 196606 : return nbits_old;
679 : }
680 :
681 :
682 : /* Range Coder Functions */
683 :
684 : /*-------------------------------------------------------------------*
685 : * RCcontextMapping_encode2_no_mem_s17_LCS()
686 : *
687 : * Range encoder
688 : *-------------------------------------------------------------------*/
689 :
690 14519543 : void RCcontextMapping_encode2_no_mem_s17_LCS(
691 : BSTR_ENC_HANDLE hBstr, /* i/o: bitstream handle */
692 : int16_t *x,
693 : const int16_t nt,
694 : int16_t lastnz,
695 : const int16_t nbbits,
696 : const int16_t resQMaxBits,
697 : CONTEXT_HM_CONFIG *hm_cfg )
698 : {
699 : int16_t ptr[BITBUFSIZE];
700 : RangeUniEncState rc_st_enc;
701 : int16_t bp;
702 : int16_t rc_tot_bits; /* No. of bits returned by range coder */
703 : int16_t pki, lev1;
704 : uint16_t t;
705 : int16_t rateFlag;
706 : int16_t value;
707 : int16_t nbbits_ntuples, nbbits_lsbs, nbbits_signs;
708 : int16_t *lsbs_bits;
709 : int16_t nt_half;
710 : int16_t signs[N_MAX];
711 : int16_t a1, b1, k;
712 :
713 14519543 : a1 = 0; /* to avoid compilation warnings */
714 14519543 : b1 = 0; /* to avoid compilation warnings */
715 :
716 : /* Init */
717 14519543 : nt_half = nt >> 1;
718 :
719 : /* Bits for encoding the number of encoded tuples */
720 14519543 : nbbits_ntuples = 0;
721 14519543 : k = 1;
722 142935123 : while ( k < nt / 2 )
723 : {
724 128415580 : nbbits_ntuples++;
725 128415580 : k = k << 1;
726 : }
727 :
728 14519543 : t = 0;
729 14519543 : nbbits_signs = 0;
730 14519543 : nbbits_lsbs = 0;
731 :
732 14519543 : if ( hm_cfg )
733 : {
734 : int16_t a1_i, b1_i;
735 : int32_t c[2], *ctx;
736 : int32_t p1, p2;
737 : int16_t ii[2];
738 : int16_t idx1, idx2, idx;
739 : int16_t numPeakIndicesOrig, numHoleIndices;
740 :
741 : /* Rate flag */
742 155604 : if ( nbbits > 400 )
743 : {
744 61907 : rateFlag = 2 << NBITS_CONTEXT;
745 : }
746 : else
747 : {
748 93697 : rateFlag = 0;
749 : }
750 :
751 155604 : c[0] = c[1] = 0;
752 :
753 : /* mapped domain */
754 155604 : numPeakIndicesOrig = hm_cfg->numPeakIndices;
755 155604 : hm_cfg->numPeakIndices = min( hm_cfg->numPeakIndices, lastnz );
756 155604 : numHoleIndices = lastnz - hm_cfg->numPeakIndices;
757 :
758 : /* Mark hole indices beyond lastnz as pruned */
759 55549420 : for ( k = numHoleIndices; k < hm_cfg->numHoleIndices; ++k )
760 : {
761 55393816 : hm_cfg->holeIndices[k] = hm_cfg->holeIndices[k] + nt;
762 : }
763 :
764 155604 : ii[0] = numPeakIndicesOrig;
765 155604 : ii[1] = 0;
766 :
767 155604 : p1 = p2 = 0; /* to avoid compilation warnings */
768 :
769 155604 : lsbs_bits = ptr + nbbits - 1;
770 :
771 : /*Start Encoding*/
772 : /* Initialize range encoder */
773 155604 : rc_uni_enc_init( &rc_st_enc );
774 :
775 : /*Main Loop through the 2-tuples*/
776 155604 : b1_i = -1;
777 :
778 26166416 : for ( k = 0; k < lastnz; k += 2 )
779 : {
780 26010812 : a1_i = get_next_coeff_mapped( ii, &p1, &idx1, hm_cfg );
781 26010812 : b1_i = get_next_coeff_mapped( ii, &p2, &idx2, hm_cfg );
782 :
783 26010812 : idx = min( idx1, idx2 );
784 :
785 : /* Get context */
786 26010812 : ctx = &c[p1 | p2];
787 :
788 26010812 : t = (uint16_t) ( *ctx + rateFlag );
789 26010812 : t += ( nt_half >= idx ) ? 0 : ( 1 << NBITS_CONTEXT );
790 :
791 : /* Init current 2-tuple encoding */
792 26010812 : a1 = (int16_t) abs( x[a1_i] );
793 26010812 : b1 = (int16_t) abs( x[b1_i] );
794 :
795 26010812 : lev1 = -1;
796 :
797 : /*Signs encoding*/
798 26010812 : if ( a1 > 0 )
799 : {
800 5682990 : signs[nbbits_signs++] = ( (uint16_t) x[a1_i] >> ( sizeof( uint16_t ) * 8 - 1 ) );
801 : }
802 :
803 26010812 : if ( b1 > 0 )
804 : {
805 5653944 : signs[nbbits_signs++] = ( (uint16_t) x[b1_i] >> ( sizeof( uint16_t ) * 8 - 1 ) );
806 : }
807 :
808 : /* MSBs coding */
809 28464107 : while ( max( a1, b1 ) >= A_THRES )
810 : {
811 2453295 : pki = ari_lookup_s17_LC[t + ( ( lev1 + 1 ) << ( NBITS_CONTEXT + NBITS_RATEQ ) )];
812 2453295 : rc_uni_enc_encode_symbol_fastS( &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 */
813 :
814 2453295 : *lsbs_bits-- = a1 & 1;
815 2453295 : *lsbs_bits-- = b1 & 1;
816 :
817 : /* LSBs bit counting */
818 2453295 : nbbits_lsbs += 2;
819 :
820 2453295 : a1 >>= 1;
821 2453295 : b1 >>= 1;
822 :
823 2453295 : lev1 = min( lev1 + 1, 2 );
824 : }
825 :
826 26010812 : pki = ari_lookup_s17_LC[t + ( ( lev1 + 1 ) << ( NBITS_CONTEXT + NBITS_RATEQ ) )];
827 26010812 : rc_uni_enc_encode_symbol_fastS( &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 */
828 :
829 : /*Confirm that there is no overflow, i.e. bit-budget has not exceeded */
830 : #ifdef DEBUGGING
831 : assert( rc_uni_enc_virtual_finish( &rc_st_enc ) <= nbbits - nbbits_signs - nbbits_lsbs - nbbits_ntuples );
832 : #endif
833 :
834 : /* Update context for next 2-tuple */
835 26010812 : if ( p1 == p2 )
836 : {
837 : /* peak-peak or hole-hole context */
838 :
839 23641358 : if ( lev1 <= 0 )
840 : {
841 23191464 : t = 1 + ( a1 + b1 ) * ( lev1 + 2 );
842 : }
843 : else
844 : {
845 449894 : t = 13 + lev1;
846 : }
847 :
848 23641358 : *ctx = ( *ctx & 0xf ) * 16 + t;
849 : }
850 : else
851 : {
852 : /* mixed context */
853 :
854 2369454 : if ( idx1 & 1 )
855 : {
856 : /* update first context */
857 1168625 : c[p1] = update_mixed_context( c[p1], (int16_t) abs( x[a1_i] ) );
858 : }
859 :
860 2369454 : if ( idx2 & 1 )
861 : {
862 : /* update second context */
863 1200829 : c[p2] = update_mixed_context( c[p2], (int16_t) abs( x[b1_i] ) );
864 : }
865 : }
866 :
867 : } /*end of the 2-tuples loop*/
868 : }
869 : else /* if (!hm_cfg) */
870 : {
871 : int16_t cp;
872 : int16_t esc_nb, rateQ;
873 : uint16_t s;
874 :
875 : /* Rate flag */
876 14363939 : if ( nbbits > 400 )
877 : {
878 10066951 : rateFlag = 2;
879 : }
880 : else
881 : {
882 4296988 : rateFlag = 0;
883 : }
884 :
885 14363939 : s = 0;
886 :
887 : /* Find last non-zero tuple */
888 : /* ensure termination of while loop by dummy value */
889 14363939 : a1 = x[0];
890 14363939 : x[0] = 1; /* ensure first tuple is non-zero */
891 :
892 116330655 : while ( x[lastnz - 1] == 0 && x[lastnz - 2] == 0 )
893 : {
894 101966716 : lastnz -= 2;
895 : }
896 14363939 : x[0] = a1;
897 :
898 14363939 : lsbs_bits = ptr + nbbits - 1;
899 :
900 : /*Start Encoding*/
901 : /* Initialize range encoder */
902 14363939 : rc_uni_enc_init( &rc_st_enc );
903 :
904 : /*Main Loop through the 2-tuples*/
905 2987534121 : for ( k = 0; k < lastnz; k += 2 )
906 : {
907 :
908 : /* Init current 2-tuple encoding */
909 2973170182 : a1 = (int16_t) abs( x[k + 0] );
910 2973170182 : b1 = (int16_t) abs( x[k + 1] );
911 :
912 2973170182 : lev1 = 0;
913 2973170182 : esc_nb = 0;
914 :
915 : /*Signs encoding*/
916 2973170182 : if ( a1 > 0 )
917 : {
918 1157586843 : signs[nbbits_signs++] = ( (uint16_t) x[k + 0] >> ( sizeof( uint16_t ) * 8 - 1 ) );
919 : }
920 :
921 2973170182 : if ( b1 > 0 )
922 : {
923 1157934399 : signs[nbbits_signs++] = ( (uint16_t) x[k + 1] >> ( sizeof( uint16_t ) * 8 - 1 ) );
924 : }
925 :
926 2973170182 : rateQ = rateFlag + ( k > ( nt >> 1 ) );
927 :
928 : /* MSBs coding */
929 3587908529 : while ( max( a1, b1 ) >= A_THRES )
930 : {
931 614738347 : pki = ari_lookup_s17_LC[t + ( ( rateQ ) << NBITS_CONTEXT ) + ( esc_nb << ( NBITS_CONTEXT + NBITS_RATEQ ) )];
932 614738347 : rc_uni_enc_encode_symbol_fastS( &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 */
933 :
934 614738347 : *lsbs_bits-- = a1 & 1;
935 614738347 : *lsbs_bits-- = b1 & 1;
936 :
937 : /* LSBs bit counting */
938 614738347 : nbbits_lsbs += 2;
939 :
940 614738347 : a1 >>= 1;
941 614738347 : b1 >>= 1;
942 :
943 614738347 : lev1++;
944 614738347 : esc_nb = min( lev1, 3 );
945 : }
946 :
947 2973170182 : pki = ari_lookup_s17_LC[t + ( ( rateQ ) << NBITS_CONTEXT ) + ( esc_nb << ( NBITS_CONTEXT + NBITS_RATEQ ) )];
948 2973170182 : rc_uni_enc_encode_symbol_fastS( &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 */
949 :
950 : /*Confirm that there is no overflow, i.e. bit-budget has not exceeded */
951 : #ifdef DEBUGGING
952 : assert( rc_uni_enc_virtual_finish( &rc_st_enc ) <= nbbits - nbbits_signs - nbbits_lsbs - nbbits_ntuples );
953 : #endif
954 :
955 : /* Update context for next 2-tuple */
956 2973170182 : if ( esc_nb < 2 )
957 : {
958 2819564818 : cp = 1 + ( ( a1 + b1 ) * ( esc_nb + 1 ) );
959 : }
960 : else
961 : {
962 153605364 : cp = 12 + esc_nb;
963 : }
964 :
965 : /*Shift old 4 bits, replace last 4 bits*/
966 : #ifdef FIX_1464_UBSAN_RC_CONTEXT_MAP
967 2973170182 : s = s & 0x0F;
968 : #endif
969 2973170182 : s = ( s << 4 ) + cp;
970 2973170182 : t = s & 0xFF;
971 :
972 : } /*end of the 2-tuples loop*/
973 : }
974 :
975 : /* Finish range encoder */
976 14519543 : rc_tot_bits = rc_uni_enc_finish( &rc_st_enc ); /* No. of bits consumed by range coder */
977 14519543 : bp = rc_tot_bits + nbbits_ntuples; /* Update bitstream pointer */
978 :
979 : /* Cross-check that there is no overflow */
980 : #ifdef DEBUGGING
981 : assert( k == lastnz );
982 : #endif
983 :
984 : /* Push number of encoded tuples */
985 14519543 : value = ( lastnz >> 1 ) - 1;
986 14519543 : push_next_indice( hBstr, value, nbbits_ntuples );
987 :
988 : /* Push range coded bits from byte_buffer to bitstream */
989 : /* 1) Push all complete bytes, one byte at a time */
990 1044364471 : for ( k = 0; k < ( rc_tot_bits >> 3 ); k++ )
991 : {
992 1029844928 : push_next_indice( hBstr, rc_st_enc.byte_buffer[k], 8 );
993 : }
994 : /* 2) Push remaining bits */
995 14519543 : if ( ( rc_tot_bits & 7 ) != 0 )
996 : {
997 12743146 : push_next_indice( hBstr, rc_st_enc.byte_buffer[k] >> ( 8 - ( rc_tot_bits & 7 ) ), rc_tot_bits & 7 );
998 : }
999 :
1000 : /* Push sign bits */
1001 14519543 : push_next_bits( hBstr, (uint16_t *) signs, nbbits_signs );
1002 14519543 : bp += nbbits_signs;
1003 :
1004 : /*write residual Quantization bits*/
1005 :
1006 120447617 : for ( k = 0; k < min( nbbits - bp - nbbits_lsbs, resQMaxBits ); k++ )
1007 : {
1008 105928074 : ptr[nbbits - 1 - nbbits_lsbs - k] = x[nt + k];
1009 : }
1010 : /* Write filler bits */
1011 797757090 : for ( ; k < nbbits - bp - nbbits_lsbs; ++k )
1012 : {
1013 783237547 : ptr[nbbits - 1 - nbbits_lsbs - k] = 0;
1014 : }
1015 :
1016 : /* Check for debugging */
1017 14519543 : assert( bp + k <= nbbits );
1018 :
1019 : /* Push the rest of the buffer */
1020 14519543 : push_next_bits( hBstr, (uint16_t *) &ptr[bp], nbbits - bp );
1021 :
1022 : /* return (bp+nbbits_lsbs);*/ /*return only for debug plot*/
1023 14519543 : return;
1024 : }
1025 :
1026 : /*-------------------------------------------------------------------*
1027 : * RCcontextMapping_encode2_estimate_no_mem_s17_LCS()
1028 : *
1029 : * Range coder bit-estimation
1030 : *-------------------------------------------------------------------*/
1031 :
1032 64303743 : int16_t RCcontextMapping_encode2_estimate_no_mem_s17_LCS(
1033 : int16_t *x, /* Spectral coefficients */
1034 : const int16_t nt, /* L - size of spectrum (no. of spectral coefficients) */
1035 : int16_t *lastnz_out,
1036 : int16_t *nEncoded, /* No. of spectral coefficients that can be coded without an overflow occuring */
1037 : const int16_t target, /* Target bits */
1038 : int16_t *stop,
1039 : int16_t mode,
1040 : CONTEXT_HM_CONFIG *hm_cfg /* context-based harmonic model configuration */
1041 : )
1042 : {
1043 : /* Common variables */
1044 : int16_t a1, b1;
1045 : int16_t k, pki, lev1;
1046 : uint16_t t;
1047 : int16_t lastnz, lastnz2;
1048 : int16_t rateFlag;
1049 : float bit_estimate;
1050 : int16_t symbol;
1051 : const uint8_t *lookup;
1052 : float nbits2;
1053 :
1054 : /* Initialization */
1055 64303743 : bit_estimate = 2.0f;
1056 64303743 : nbits2 = 0.f;
1057 :
1058 : /* bits to encode lastnz */
1059 64303743 : k = 1;
1060 :
1061 627947812 : while ( k < nt / 2 )
1062 : {
1063 563644069 : bit_estimate++;
1064 563644069 : k = k << 1;
1065 : /* check while condition */
1066 : }
1067 :
1068 64303743 : nbits2 = bit_estimate;
1069 :
1070 64303743 : if ( hm_cfg )
1071 : {
1072 : int16_t a1_i, b1_i;
1073 : int16_t stop2;
1074 : int16_t total_output_bits;
1075 : int16_t nt_half;
1076 : int32_t c[2], *ctx;
1077 : int32_t p1, p2;
1078 : int16_t ii[2];
1079 : int16_t idx1, idx2, idx;
1080 4886019 : int16_t numPeakIndicesOrig = 0, numHoleIndices = 0; /* only to avoid compiler warning */
1081 :
1082 : /* Rate flag */
1083 4886019 : if ( target > 400 )
1084 : {
1085 2637781 : rateFlag = 2 << NBITS_CONTEXT; /* Select context-A for higher bitrates */
1086 : }
1087 : else
1088 : {
1089 2248238 : rateFlag = 0; /* Select context-B for lower bitrates */
1090 : }
1091 :
1092 4886019 : nt_half = nt >> 1;
1093 4886019 : stop2 = 0;
1094 4886019 : c[0] = c[1] = 0;
1095 :
1096 : /* Find last non-zero tuple in the mapped domain signal */
1097 4886019 : lastnz = find_last_nz_pair( x, nt, hm_cfg );
1098 :
1099 4886019 : lastnz2 = 2;
1100 :
1101 : /* mapped domain */
1102 4886019 : numPeakIndicesOrig = hm_cfg->numPeakIndices;
1103 4886019 : hm_cfg->numPeakIndices = min( hm_cfg->numPeakIndices, lastnz );
1104 4886019 : numHoleIndices = lastnz - hm_cfg->numPeakIndices;
1105 :
1106 : /* Mark hole indices beyond lastnz as pruned */
1107 1675598178 : for ( k = numHoleIndices; k < hm_cfg->numHoleIndices; ++k )
1108 : {
1109 1670712159 : hm_cfg->holeIndices[k] = hm_cfg->holeIndices[k] + nt;
1110 : }
1111 :
1112 4886019 : ii[0] = numPeakIndicesOrig;
1113 4886019 : ii[1] = 0;
1114 :
1115 4886019 : p1 = p2 = 0; /* to avoid compilation warnings */
1116 :
1117 : /* Main Loop through the 2-tuples */
1118 858962345 : for ( k = 0; k < lastnz; k += 2 )
1119 : {
1120 855685548 : a1_i = get_next_coeff_mapped( ii, &p1, &idx1, hm_cfg );
1121 855685548 : b1_i = get_next_coeff_mapped( ii, &p2, &idx2, hm_cfg );
1122 :
1123 855685548 : idx = min( idx1, idx2 );
1124 :
1125 : /* Get context */
1126 855685548 : ctx = &c[p1 | p2];
1127 :
1128 855685548 : t = (uint16_t) ( *ctx + rateFlag );
1129 855685548 : t += ( nt_half >= idx ) ? 0 : ( 1 << NBITS_CONTEXT );
1130 :
1131 : /* Init current 2-tuple encoding */
1132 855685548 : a1 = (int16_t) abs( x[a1_i] );
1133 855685548 : b1 = (int16_t) abs( x[b1_i] );
1134 855685548 : lev1 = -( 1 << ( NBITS_CONTEXT + NBITS_RATEQ ) );
1135 :
1136 : /* Signs Bits */
1137 855685548 : bit_estimate += min( a1, 1 );
1138 855685548 : bit_estimate += min( b1, 1 );
1139 :
1140 : /* pre-compute address of ari_pk_s17_LC_ext[0][Val_esc] to avoid doing it multiple times inside the loop */
1141 855685548 : lookup = &ari_lookup_s17_LC[t] + ( 1 << ( NBITS_CONTEXT + NBITS_RATEQ ) );
1142 :
1143 : /* check while condition */
1144 : /* MSBs coding */
1145 950114235 : while ( max( a1, b1 ) >= A_THRES )
1146 : {
1147 94428687 : pki = lookup[lev1]; /* ESC symbol */
1148 :
1149 94428687 : bit_estimate = bit_estimate + ari_bit_estimate_s17_LC[pki][VAL_ESC];
1150 94428687 : bit_estimate += 2; /* Add 2 LSB bits corresponding to the bit-plane */
1151 :
1152 94428687 : ( a1 ) >>= 1;
1153 94428687 : ( b1 ) >>= 1;
1154 :
1155 94428687 : lev1 = min( lev1 + ( 1 << ( NBITS_CONTEXT + NBITS_RATEQ ) ), 2 << ( NBITS_CONTEXT + NBITS_RATEQ ) );
1156 :
1157 : /* check while condition */
1158 : }
1159 :
1160 855685548 : pki = lookup[lev1];
1161 :
1162 855685548 : symbol = a1 + A_THRES * b1;
1163 855685548 : bit_estimate = bit_estimate + ari_bit_estimate_s17_LC[pki][symbol];
1164 :
1165 : /* Should we truncate? */
1166 855685548 : if ( bit_estimate > target )
1167 : {
1168 119250484 : stop2 = 1;
1169 :
1170 119250484 : if ( *stop )
1171 : {
1172 1609222 : break;
1173 : }
1174 : }
1175 : else
1176 : {
1177 736435064 : lastnz2 = b1_i + 1;
1178 736435064 : nbits2 = bit_estimate;
1179 : }
1180 :
1181 : /* Update context for next 2-tuple */
1182 854076326 : if ( p1 == p2 ) /* peak-peak or hole-hole context */
1183 : {
1184 716649184 : lev1 >>= NBITS_CONTEXT + NBITS_RATEQ;
1185 :
1186 716649184 : if ( lev1 <= 0 )
1187 : {
1188 699443792 : t = 1 + ( a1 + b1 ) * ( lev1 + 2 );
1189 : }
1190 : else
1191 : {
1192 17205392 : t = 13 + lev1;
1193 : }
1194 :
1195 716649184 : *ctx = ( *ctx & 0xf ) * 16 + t;
1196 : }
1197 : else
1198 : {
1199 : /* mixed context */
1200 :
1201 137427142 : if ( idx1 & 1 )
1202 : {
1203 : /* update first context */
1204 68427985 : c[p1] = update_mixed_context( c[p1], (int16_t) abs( x[a1_i] ) );
1205 : }
1206 :
1207 137427142 : if ( idx2 & 1 )
1208 : {
1209 : /* update second context */
1210 68737356 : c[p2] = update_mixed_context( c[p2], (int16_t) abs( x[b1_i] ) );
1211 : }
1212 : }
1213 :
1214 : } /*end of the 2-tuples loop*/
1215 :
1216 4886019 : total_output_bits = (int16_t) ( bit_estimate + 0.5f );
1217 4886019 : if ( *stop )
1218 : {
1219 2106247 : total_output_bits = (int16_t) ( nbits2 + 0.5f );
1220 : }
1221 :
1222 4886019 : if ( stop2 )
1223 : {
1224 3221960 : stop2 = total_output_bits;
1225 : }
1226 4886019 : *nEncoded = lastnz2;
1227 4886019 : *stop = stop2; /* If zero, it means no overflow occured during bit-estimation */
1228 4886019 : *lastnz_out = lastnz;
1229 :
1230 : /* Restore hole indices beyond lastnz */
1231 1675598178 : for ( k = numHoleIndices; k < hm_cfg->numHoleIndices; ++k )
1232 : {
1233 1670712159 : hm_cfg->holeIndices[k] = hm_cfg->holeIndices[k] - nt;
1234 : }
1235 4886019 : hm_cfg->numPeakIndices = numPeakIndicesOrig;
1236 :
1237 4886019 : return (int16_t) ( nbits2 + 0.5f );
1238 : }
1239 : else /* if (!hm_cfg) */
1240 : {
1241 : int16_t esc_nb, cp, rateQ;
1242 : uint16_t s;
1243 : int16_t tot_bits2;
1244 59417724 : int16_t overflow_flag = 0;
1245 :
1246 : /* Rate flag */
1247 59417724 : if ( target > 400 )
1248 : {
1249 44248788 : rateFlag = 2;
1250 : }
1251 : else
1252 : {
1253 15168936 : rateFlag = 0; /* Select context-B for lower bitrates */
1254 : }
1255 :
1256 59417724 : t = 0;
1257 59417724 : s = 0;
1258 59417724 : cp = 0;
1259 59417724 : lastnz = 1;
1260 59417724 : lastnz2 = 0;
1261 59417724 : tot_bits2 = 0;
1262 :
1263 : /* Find last non-zero tuple in the mapped domain signal */
1264 9888971471 : for ( lastnz = ( nt - 2 ); lastnz >= 0; lastnz -= 2 )
1265 : {
1266 9887158805 : if ( ( x[lastnz] != 0 ) || ( x[lastnz + 1] != 0 ) )
1267 : {
1268 : break;
1269 : }
1270 : }
1271 59417724 : lastnz += 2;
1272 59417724 : if ( lastnz < 2 )
1273 : {
1274 1812666 : lastnz = 2; /* At least one tuple is coded */
1275 : }
1276 :
1277 59417724 : lastnz2 = 2;
1278 :
1279 : /* Main Loop through the 2-tuples */
1280 12640217283 : for ( k = 0; k < lastnz; k += 2 )
1281 : {
1282 : /* Init current 2-tuple encoding */
1283 12580799559 : a1 = (int16_t) abs( x[k] );
1284 12580799559 : b1 = (int16_t) abs( x[k + 1] );
1285 12580799559 : lev1 = 0;
1286 12580799559 : esc_nb = 0;
1287 12580799559 : rateQ = rateFlag + ( k > ( nt >> 1 ) );
1288 :
1289 : /* Signs Bits */
1290 12580799559 : bit_estimate += min( a1, 1 );
1291 12580799559 : bit_estimate += min( b1, 1 );
1292 :
1293 : /* pre-compute address of ari_pk_s17_LC_ext[0][Val_esc] to avoid doing it multiple times inside the loop */
1294 12580799559 : lookup = &ari_lookup_s17_LC[t + ( rateQ << NBITS_CONTEXT )];
1295 :
1296 : /* check while condition */
1297 : /* MSBs coding */
1298 15317703538 : while ( max( a1, b1 ) >= A_THRES )
1299 : {
1300 2736903979 : pki = lookup[( esc_nb << ( NBITS_CONTEXT + NBITS_RATEQ ) )];
1301 :
1302 2736903979 : bit_estimate = bit_estimate + ari_bit_estimate_s17_LC[pki][VAL_ESC];
1303 2736903979 : bit_estimate += 2; /* Add 2 LSB bits corresponding to the bit-plane */
1304 :
1305 2736903979 : ( a1 ) >>= 1;
1306 2736903979 : ( b1 ) >>= 1;
1307 :
1308 2736903979 : lev1++;
1309 2736903979 : esc_nb = min( lev1, 3 );
1310 :
1311 : /* check while condition */
1312 : }
1313 :
1314 12580799559 : pki = lookup[( esc_nb << ( NBITS_CONTEXT + NBITS_RATEQ ) )];
1315 :
1316 12580799559 : symbol = a1 + A_THRES * b1;
1317 12580799559 : bit_estimate = bit_estimate + ari_bit_estimate_s17_LC[pki][symbol];
1318 :
1319 : /* Should we truncate? */
1320 12580799559 : if ( bit_estimate > target ) /* Overflow occured */
1321 : {
1322 480675286 : overflow_flag = 1;
1323 : }
1324 : else
1325 : {
1326 12100124273 : if ( abs( x[k] ) || abs( x[k + 1] ) ) /* No overflow & non-zero tuple */
1327 : {
1328 7058899891 : nbits2 = bit_estimate;
1329 7058899891 : lastnz2 = k + 2;
1330 : }
1331 : }
1332 :
1333 : /* Update context for next 2-tuple */
1334 12580799559 : if ( esc_nb < 2 )
1335 : {
1336 11895449882 : cp = 1 + ( a1 + b1 ) * ( esc_nb + 1 );
1337 : }
1338 : else
1339 : {
1340 685349677 : cp = 12 + esc_nb;
1341 : }
1342 :
1343 : /*shift old bits and replace last 4 bits*/
1344 : #ifdef FIX_1464_UBSAN_RC_CONTEXT_MAP
1345 12580799559 : s = s & 0x0F;
1346 : #endif
1347 12580799559 : s = ( s << 4 ) + cp;
1348 12580799559 : t = s & 0xFF;
1349 :
1350 : } /*end of the 2-tuples loop*/
1351 :
1352 59417724 : tot_bits2 = (int16_t) ( nbits2 + 0.5f );
1353 59417724 : if ( lastnz2 < lastnz ) /* Overflow occured because unable to code all tuples */
1354 : {
1355 22660560 : overflow_flag = 1;
1356 : }
1357 59417724 : if ( mode == -1 )
1358 : {
1359 0 : tot_bits2 = (int16_t) ( bit_estimate + 0.5f );
1360 : }
1361 59417724 : if ( overflow_flag == 0 ) /* No overflow */
1362 : {
1363 36757164 : *stop = 0;
1364 : }
1365 : else /* Overflow */
1366 : {
1367 22660560 : if ( *stop )
1368 : {
1369 101117 : *stop = tot_bits2;
1370 : }
1371 : else
1372 : {
1373 22559443 : *stop = (int16_t) ( bit_estimate + 0.5f );
1374 : }
1375 : }
1376 :
1377 59417724 : *lastnz_out = lastnz;
1378 59417724 : *nEncoded = lastnz2;
1379 : /* Safety mechanism to avoid overflow */
1380 59417724 : if ( lastnz2 == 2 && overflow_flag == 1 )
1381 : {
1382 125937 : for ( k = 0; k < lastnz2; k++ )
1383 : {
1384 83958 : x[k] = 0;
1385 : }
1386 : }
1387 :
1388 59417724 : return tot_bits2;
1389 : }
1390 : }
1391 :
1392 : /*-------------------------------------------------------------------*
1393 : * RCcontextMapping_encode2_estimate_bandWise_start()
1394 : *
1395 : * Range coder - start bandwise bit-estimation
1396 : *-------------------------------------------------------------------*/
1397 :
1398 11022416 : int16_t RCcontextMapping_encode2_estimate_bandWise_start(
1399 : int16_t *x,
1400 : const int16_t nt,
1401 : const int16_t target,
1402 : HANDLE_RC_CONTEXT_MEM hContextMem )
1403 : {
1404 : int16_t i, k;
1405 :
1406 : /* Rate flag */
1407 11022416 : if ( target > 400 )
1408 : {
1409 10806620 : hContextMem->rateFlag = 2 << NBITS_CONTEXT;
1410 : }
1411 : else
1412 : {
1413 215796 : hContextMem->rateFlag = 0;
1414 : }
1415 :
1416 11022416 : hContextMem->bit_estimate = 2.0f;
1417 :
1418 : /* Init */
1419 11022416 : hContextMem->nt_half = nt >> 1;
1420 :
1421 : /* bits to encode lastnz */
1422 11022416 : k = 1;
1423 :
1424 102725616 : while ( k < hContextMem->nt_half )
1425 : {
1426 91703200 : hContextMem->bit_estimate++;
1427 :
1428 91703200 : k = k << 1;
1429 : /* check while condition */
1430 : }
1431 :
1432 : /* bits to encode lastnz */
1433 11022416 : hContextMem->nbits_old = (int16_t) hContextMem->bit_estimate;
1434 :
1435 11022416 : hContextMem->ctx = 0;
1436 11022416 : hContextMem->lastnz = 2;
1437 :
1438 : /* Find last non-zero tuple */
1439 :
1440 211308040 : for ( i = nt; i >= 4; i -= 2 )
1441 : {
1442 :
1443 211113369 : if ( x[i - 2] != 0 || x[i - 1] != 0 )
1444 : {
1445 10827745 : hContextMem->lastnz = i;
1446 10827745 : break;
1447 : }
1448 : }
1449 :
1450 11022416 : return (int16_t) hContextMem->bit_estimate;
1451 : }
1452 :
1453 : /*-------------------------------------------------------------------*
1454 : * RCcontextMapping_encode2_estimate_bandWise()
1455 : *
1456 : * Range coder - bandwise bit-estimation
1457 : *-------------------------------------------------------------------*/
1458 :
1459 424840780 : int16_t RCcontextMapping_encode2_estimate_bandWise(
1460 : int16_t *x,
1461 : const int16_t start_line,
1462 : const int16_t end_line,
1463 : HANDLE_RC_CONTEXT_MEM hContextMem )
1464 : {
1465 : int16_t a1, b1, a1_i, b1_i;
1466 : int16_t k, pki, lev1;
1467 : uint16_t t;
1468 424840780 : int16_t bandBits = 0;
1469 : int16_t total_output_bits; /* No. of bits after finalization */
1470 : int16_t symbol;
1471 : const uint8_t *lookup;
1472 : int16_t idx;
1473 :
1474 : /* Main Loop through the 2-tuples */
1475 : /*hContextMem->nt_half = end_line >> 1;*/
1476 3191986755 : for ( k = start_line; k < min( hContextMem->lastnz, end_line ); k += 2 )
1477 : {
1478 2767145975 : a1_i = k;
1479 2767145975 : b1_i = k + 1;
1480 :
1481 2767145975 : idx = k;
1482 :
1483 : /* Get context */
1484 2767145975 : t = hContextMem->ctx + hContextMem->rateFlag;
1485 2767145975 : t += ( hContextMem->nt_half >= idx ) ? 0 : ( 1 << NBITS_CONTEXT );
1486 :
1487 : /* Init current 2-tuple encoding */
1488 2767145975 : a1 = (int16_t) abs( x[a1_i] );
1489 2767145975 : b1 = (int16_t) abs( x[b1_i] );
1490 2767145975 : lev1 = -( 1 << ( NBITS_CONTEXT + NBITS_RATEQ ) );
1491 :
1492 : /* Signs Bits */
1493 2767145975 : hContextMem->bit_estimate += min( a1, 1 );
1494 2767145975 : hContextMem->bit_estimate += min( b1, 1 );
1495 :
1496 : /* pre-compute address of ari_pk_s17_LC_ext[0][Val_esc] to avoid doing it multiple times inside the loop */
1497 2767145975 : lookup = &ari_lookup_s17_LC[t] + ( 1 << ( NBITS_CONTEXT + NBITS_RATEQ ) );
1498 :
1499 : /* check while condition */
1500 : /* MSBs coding */
1501 3402874463 : while ( max( a1, b1 ) >= A_THRES )
1502 : {
1503 635728488 : pki = lookup[lev1];
1504 635728488 : hContextMem->bit_estimate = hContextMem->bit_estimate + ari_bit_estimate_s17_LC[pki][VAL_ESC];
1505 635728488 : hContextMem->bit_estimate += 2; /* Add the 2 LSB bits that were shifted out */
1506 :
1507 635728488 : ( a1 ) >>= 1;
1508 635728488 : ( b1 ) >>= 1;
1509 :
1510 635728488 : lev1 = min( lev1 + ( 1 << ( NBITS_CONTEXT + NBITS_RATEQ ) ), 2 << ( NBITS_CONTEXT + NBITS_RATEQ ) );
1511 : /* check while condition */
1512 : }
1513 :
1514 2767145975 : pki = lookup[lev1];
1515 2767145975 : symbol = a1 + A_THRES * b1; /* MSB symbol */
1516 2767145975 : hContextMem->bit_estimate = hContextMem->bit_estimate + ari_bit_estimate_s17_LC[pki][symbol];
1517 :
1518 : /* Update context */
1519 2767145975 : lev1 >>= NBITS_CONTEXT + NBITS_RATEQ;
1520 :
1521 2767145975 : if ( lev1 <= 0 )
1522 : {
1523 2608830485 : t = 1 + ( a1 + b1 ) * ( lev1 + 2 );
1524 : }
1525 : else
1526 : {
1527 158315490 : t = 13 + lev1;
1528 : }
1529 :
1530 2767145975 : hContextMem->ctx = ( hContextMem->ctx & 0xf ) * 16 + t;
1531 :
1532 : } /*end of the 2-tuples loop*/
1533 424840780 : total_output_bits = (int16_t) ( hContextMem->bit_estimate + 0.5f );
1534 :
1535 424840780 : bandBits = total_output_bits - hContextMem->nbits_old;
1536 424840780 : hContextMem->nbits_old = total_output_bits;
1537 :
1538 424840780 : return bandBits;
1539 : }
|
