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 : #ifdef DEBUGGING
40 : #include "debug.h"
41 : #endif
42 : #include "prot.h"
43 : #include "rom_com.h"
44 : #include "rom_enc.h"
45 : #include "wmc_auto.h"
46 :
47 : /*--------------------------------------------------------------------------------------*
48 : * encode_envelope_indices()
49 : *
50 : * Encode envelope indices
51 : *--------------------------------------------------------------------------------------*/
52 :
53 : /*! r: Number of bits if flag_pack=0,0 if flag_pack=1 */
54 168986 : int16_t encode_envelope_indices(
55 : BSTR_ENC_HANDLE hBstr, /* i/o: encoder bitstream handle */
56 : const int16_t num_sfm, /* i : Number of subbands */
57 : const int16_t numnrmibits, /* i : Bitrate of fall-back coding mode */
58 : int16_t *difidx, /* i/o: Diff indices/encoded diff indices */
59 : int16_t *LCmode, /* o : Coding mode if flag_pack=0, i : if flag_pack=1 */
60 : const int16_t flag_pack, /* i : indicator of packing or estimating bits */
61 : const int16_t flag_HQ2, /* i : indicator of HQ2 core */
62 : const int16_t is_transient /* i : transient flag */
63 : )
64 : {
65 : int16_t bits;
66 : int16_t prevj;
67 : int16_t hcode_l;
68 : int16_t i, j;
69 : int16_t difidx_flag;
70 : int16_t index_max, index_min, index_rad;
71 : int16_t difidx_org[NB_SFM]; /* length of this buffer is max(BANDS_MAX,NB_SFM) */
72 : int16_t m, r;
73 : int16_t v, k;
74 :
75 168986 : set_s( difidx_org, 0, NB_SFM );
76 168986 : difidx_flag = 0;
77 :
78 : /*------------------------------------------------------------------*
79 : * Check Huffman encoding for QNorm indices
80 : *------------------------------------------------------------------*/
81 :
82 : /* LC mode index is changed to synchronize LR-MDCT signaling */
83 : /* LC mode 0 = Context based coding */
84 : /* LC mode 1 = resized huffman coding */
85 : /* LC mode 2 = normal Huffman Coding */
86 : /* LC mode 3 = bit packing */
87 168986 : if ( flag_pack == 0 )
88 : {
89 84723 : if ( is_transient && flag_HQ2 == LOW_RATE_HQ_CORE_TRAN )
90 : {
91 106 : bits = 0;
92 106 : index_max = 0;
93 106 : index_min = 31;
94 2854 : for ( i = 0; i < num_sfm; i++ )
95 : {
96 2748 : if ( difidx[i] > index_max )
97 : {
98 395 : index_max = difidx[i];
99 : }
100 2748 : if ( difidx[i] < index_min )
101 : {
102 168 : index_min = difidx[i];
103 : }
104 : }
105 106 : if ( index_min > 10 && index_max < 22 )
106 : {
107 2352 : for ( i = 1; i < num_sfm; i++ )
108 : {
109 2265 : j = difidx[i];
110 2265 : bits += huffsizn_tran[j];
111 : }
112 : }
113 106 : hcode_l = 0;
114 106 : *LCmode = 0;
115 106 : prevj = difidx[0] + OFFSET_NORM;
116 : /* LC mode 0 = Context based coding */
117 2748 : for ( i = 1; i < num_sfm; i++ )
118 : {
119 2642 : j = difidx[i];
120 2642 : if ( prevj > HTH_NORM )
121 : {
122 : /* above */
123 66 : hcode_l += huffsizn_n[31 - j];
124 : }
125 : else
126 : {
127 2576 : if ( prevj < LTH_NORM )
128 : {
129 : /* less */
130 74 : hcode_l += huffsizn_n[j];
131 : }
132 : else
133 : {
134 : /* equal */
135 2502 : hcode_l += huffsizn_e[j];
136 : }
137 : }
138 2642 : prevj = j;
139 : }
140 106 : if ( hcode_l >= bits && bits != 0 )
141 : {
142 : /* LC mode 1 Transient Huffman Coding */
143 82 : *LCmode = 1;
144 82 : hcode_l = bits;
145 : }
146 : }
147 : else
148 : {
149 : /* Check bits if LC mode == 3 -> Check bits if LC mode == 0 */
150 84617 : hcode_l = 0;
151 84617 : prevj = difidx[0] + OFFSET_NORM;
152 2463933 : for ( i = 1; i < num_sfm; i++ )
153 : {
154 2379316 : j = difidx[i];
155 2379316 : if ( prevj > HTH_NORM )
156 : {
157 : /* above */
158 449851 : hcode_l += huffsizn_n[31 - j];
159 : }
160 : else
161 : {
162 1929465 : if ( prevj < LTH_NORM )
163 : {
164 : /* less */
165 282439 : hcode_l += huffsizn_n[j];
166 : }
167 : else
168 : {
169 : /* equal */
170 1647026 : hcode_l += huffsizn_e[j];
171 : }
172 : }
173 2379316 : prevj = j;
174 : }
175 :
176 84617 : *LCmode = 0;
177 :
178 : /* LR-MDCT core doesn't have coding mode 2 and 3 */
179 84617 : if ( flag_HQ2 == NORMAL_HQ_CORE )
180 : {
181 : /* Check bits if LC mode == 1 -> Check bits if LC mode == 2 */
182 82747 : bits = 0;
183 2425514 : for ( i = 1; i < num_sfm; i++ )
184 : {
185 2342767 : j = difidx[i];
186 2342767 : bits += huffsizn[j];
187 : }
188 :
189 : /*------------------------------------------------------------------------------*
190 : * comparing bit expenses of coding mode 2 with that of the optimal coding mode
191 : *------------------------------------------------------------------------------*/
192 :
193 82747 : if ( hcode_l > bits )
194 : {
195 12147 : *LCmode = 2;
196 12147 : hcode_l = bits;
197 : }
198 : }
199 :
200 : /* Check bits if LC mode == 2 -> Check bits if LC mode == 1 */
201 84617 : bits = 0;
202 84617 : index_max = 0;
203 84617 : index_min = 31;
204 2463933 : for ( i = 1; i < num_sfm; i++ )
205 : {
206 2379316 : difidx_org[i] = difidx[i];
207 : }
208 :
209 84617 : difidx_flag = 0;
210 2359895 : for ( i = 2; i < num_sfm; i++ )
211 : {
212 2276314 : if ( difidx_org[i - 1] > 17 )
213 : {
214 385084 : difidx[i] = difidx_org[i] + min( ( difidx_org[i - 1] - 17 ), 3 );
215 385084 : if ( difidx[i] > 31 )
216 : {
217 113 : difidx_flag = 1;
218 113 : break;
219 : }
220 : }
221 :
222 2276201 : if ( difidx_org[i - 1] < 13 )
223 : {
224 277790 : difidx[i] = difidx_org[i] + max( ( difidx_org[i - 1] - 13 ), -3 );
225 277790 : if ( difidx[i] < 0 )
226 : {
227 923 : difidx_flag = 1;
228 923 : break;
229 : }
230 : }
231 : }
232 :
233 84617 : index_rad = 0;
234 84617 : if ( difidx_flag != 1 )
235 : {
236 2429061 : for ( i = 1; i < num_sfm; i++ )
237 : {
238 2345480 : if ( difidx[i] > index_max )
239 : {
240 231448 : index_max = difidx[i];
241 : }
242 :
243 2345480 : if ( difidx[i] < index_min )
244 : {
245 280214 : index_min = difidx[i];
246 : }
247 : }
248 :
249 83581 : index_rad = max( ( 15 - index_min ), ( index_max - 15 ) );
250 :
251 83581 : if ( index_rad <= HUFF_THR )
252 : {
253 1925273 : for ( i = 1; i < num_sfm; i++ )
254 : {
255 1856188 : j = difidx[i];
256 1856188 : bits += resize_huffsizn[j];
257 : }
258 :
259 : /*------------------------------------------------------------------*
260 : * comparing bit expenses of coding mode 1 with that of coding mode 0
261 : *------------------------------------------------------------------*/
262 :
263 69085 : if ( hcode_l > bits )
264 : {
265 21500 : hcode_l = bits;
266 21500 : *LCmode = 1;
267 : }
268 : }
269 : }
270 :
271 : /* LR-MDCT core doesn't have coding mode 2 and 3 */
272 84617 : if ( flag_HQ2 == NORMAL_HQ_CORE )
273 : {
274 : /*------------------------------------------------------------------------------*
275 : * comparing bit expenses of coding mode 3 with that of the optimal coding mode
276 : *------------------------------------------------------------------------------*/
277 :
278 82747 : if ( hcode_l >= numnrmibits )
279 : {
280 2614 : hcode_l = numnrmibits;
281 2614 : *LCmode = 3;
282 : }
283 : }
284 :
285 84617 : if ( ( *LCmode != 1 && flag_HQ2 == NORMAL_HQ_CORE ) || flag_HQ2 == LOW_RATE_HQ_CORE )
286 : {
287 1795713 : for ( i = 2; i < num_sfm; i++ )
288 : {
289 1731529 : difidx[i] = difidx_org[i];
290 : }
291 : }
292 : }
293 : }
294 : else
295 : {
296 84263 : if ( flag_HQ2 == LOW_RATE_HQ_CORE_TRAN || flag_HQ2 == LOW_RATE_HQ_CORE )
297 : {
298 1516 : push_indice( hBstr, IND_HQ2_DENG_HMODE, *LCmode, BITS_DE_HMODE );
299 1516 : push_indice( hBstr, IND_HQ2_DIFF_ENERGY, difidx[0], BITS_DE_FCOMP );
300 : }
301 : else
302 : {
303 82747 : push_indice( hBstr, IND_LC_MODE, *LCmode, 2 );
304 82747 : push_indice( hBstr, IND_YNRM, difidx[0], NORM0_BITS );
305 : }
306 :
307 84263 : if ( is_transient && flag_HQ2 == LOW_RATE_HQ_CORE_TRAN )
308 : {
309 87 : hcode_l = 0;
310 87 : if ( *LCmode == 1 )
311 : {
312 : /* LC mode 0 Transient Huffman Coding */
313 1772 : for ( i = 1; i < num_sfm; i++ )
314 : {
315 1706 : j = difidx[i];
316 1706 : m = huffnorm_tran[j];
317 1706 : r = huffsizn_tran[j];
318 1706 : v = 0;
319 :
320 : /* Bit reverse */
321 5676 : for ( k = 0; k < r; k++ )
322 : {
323 3970 : v <<= 1;
324 3970 : v |= m & 1;
325 3970 : m >>= 1;
326 : }
327 :
328 1706 : push_indice( hBstr, IND_HQ2_DIFF_ENERGY, v, r );
329 : }
330 : }
331 : else
332 : {
333 : /* LC mode 1 context based Coding */
334 21 : prevj = difidx[0] + OFFSET_NORM;
335 412 : for ( i = 1; i < num_sfm; i++ )
336 : {
337 391 : j = difidx[i];
338 :
339 391 : if ( prevj > HTH_NORM )
340 : {
341 : /* above */
342 29 : r = huffsizn_n[31 - j];
343 29 : m = huffnorm_n[31 - j];
344 : }
345 : else
346 : {
347 362 : if ( prevj < LTH_NORM )
348 : {
349 : /* less */
350 33 : r = huffsizn_n[j];
351 33 : m = huffnorm_n[j];
352 : }
353 : else
354 : {
355 : /* equal */
356 329 : r = huffsizn_e[j];
357 329 : m = huffnorm_e[j];
358 : }
359 : }
360 391 : push_indice( hBstr, IND_HQ2_DIFF_ENERGY, m, r );
361 391 : prevj = j;
362 : }
363 : }
364 : }
365 : else
366 : {
367 84176 : hcode_l = 0;
368 84176 : if ( *LCmode == 0 )
369 : {
370 : /* LC mode 3 -> LC mode 0 */
371 50359 : prevj = difidx[0] + OFFSET_NORM;
372 1520375 : for ( i = 1; i < num_sfm; i++ )
373 : {
374 1470016 : j = difidx[i];
375 :
376 1470016 : if ( prevj > HTH_NORM )
377 : {
378 : /* above */
379 252162 : r = huffsizn_n[31 - j];
380 252162 : m = huffnorm_n[31 - j];
381 : }
382 : else
383 : {
384 1217854 : if ( prevj < LTH_NORM )
385 : {
386 : /* less */
387 152838 : r = huffsizn_n[j];
388 152838 : m = huffnorm_n[j];
389 : }
390 : else
391 : {
392 : /* equal */
393 1065016 : r = huffsizn_e[j];
394 1065016 : m = huffnorm_e[j];
395 : }
396 : }
397 :
398 1470016 : if ( flag_HQ2 == LOW_RATE_HQ_CORE )
399 : {
400 11986 : push_indice( hBstr, IND_HQ2_DIFF_ENERGY, m, r );
401 : }
402 : else
403 : {
404 1458030 : push_indice( hBstr, IND_YNRM, m, r );
405 : }
406 :
407 1470016 : prevj = j;
408 : }
409 : }
410 33817 : else if ( *LCmode == 1 )
411 : {
412 21253 : if ( flag_HQ2 == 1 )
413 : {
414 820 : index_max = 0;
415 820 : index_min = 31;
416 16377 : for ( i = 1; i < num_sfm; i++ )
417 : {
418 15557 : difidx_org[i] = difidx[i];
419 : }
420 :
421 15557 : for ( i = 2; i < num_sfm; i++ )
422 : {
423 14737 : if ( difidx_org[i - 1] > 17 )
424 : {
425 1701 : difidx[i] = difidx_org[i] + min( ( difidx_org[i - 1] - 17 ), 3 );
426 1701 : if ( difidx[i] > 31 )
427 : {
428 0 : difidx_flag = 1;
429 0 : break;
430 : }
431 : }
432 :
433 14737 : if ( difidx_org[i - 1] < 13 )
434 : {
435 540 : difidx[i] = difidx_org[i] + max( ( difidx_org[i - 1] - 13 ), -3 );
436 540 : if ( difidx[i] < 0 )
437 : {
438 0 : difidx_flag = 1;
439 0 : break;
440 : }
441 : }
442 : }
443 :
444 820 : if ( difidx_flag != 1 )
445 : {
446 16377 : for ( i = 1; i < num_sfm; i++ )
447 : {
448 15557 : if ( difidx[i] > index_max )
449 : {
450 1911 : index_max = difidx[i];
451 : }
452 :
453 15557 : if ( difidx[i] < index_min )
454 : {
455 2232 : index_min = difidx[i];
456 : }
457 : }
458 :
459 820 : index_rad = max( ( 15 - index_min ), ( index_max - 15 ) );
460 :
461 820 : if ( index_rad <= HUFF_THR )
462 : {
463 16377 : for ( i = 1; i < num_sfm; i++ )
464 : {
465 15557 : j = difidx[i];
466 : }
467 : }
468 : }
469 : }
470 :
471 : /* LC mode 2 -> LC mode 1 */
472 620413 : for ( i = 1; i < num_sfm; i++ )
473 : {
474 599160 : j = difidx[i];
475 :
476 599160 : m = resize_huffnorm[j];
477 599160 : r = resize_huffsizn[j];
478 599160 : v = 0;
479 :
480 : /* Bit reverse */
481 2477961 : for ( k = 0; k < r; k++ )
482 : {
483 1878801 : v <<= 1;
484 1878801 : v |= m & 1;
485 1878801 : m >>= 1;
486 : }
487 :
488 599160 : if ( flag_HQ2 )
489 : {
490 15557 : push_indice( hBstr, IND_HQ2_DIFF_ENERGY, v, r );
491 : }
492 : else
493 : {
494 583603 : push_indice( hBstr, IND_YNRM, v, r );
495 : }
496 : }
497 : }
498 12564 : else if ( *LCmode == 2 )
499 : {
500 : /* LC mode 1 -> LC mode 2 */
501 255408 : for ( i = 1; i < num_sfm; i++ )
502 : {
503 245458 : j = difidx[i];
504 :
505 245458 : m = huffnorm[j];
506 245458 : r = huffsizn[j];
507 :
508 245458 : push_indice( hBstr, IND_YNRM, m, r );
509 : }
510 : }
511 : else
512 : {
513 58290 : for ( i = 1; i < num_sfm; i++ )
514 : {
515 55676 : push_indice( hBstr, IND_YNRM, difidx[i], NORMI_BITS );
516 : }
517 : }
518 : }
519 : }
520 :
521 168986 : return hcode_l;
522 : }
523 :
524 : /*--------------------------------------------------------------------------*
525 : * diff_envelope_coding()
526 : *
527 : * Create differential code of norm indices
528 : *--------------------------------------------------------------------------*/
529 :
530 82747 : void diff_envelope_coding(
531 : const int16_t is_transient, /* i : transient indicator */
532 : const int16_t num_env_bands, /* i : number of envelope bands to code */
533 : const int16_t start_norm, /* i : start of envelope coding */
534 : int16_t *ynrm, /* i/o: quantization indices for norms */
535 : int16_t *normqlg2, /* i/o: quantized norms */
536 : int16_t *difidx /* o : differential code */
537 : )
538 : {
539 : int16_t i;
540 : int16_t idxbuf[NB_SFM];
541 : int16_t normbuf[NB_SFM];
542 :
543 : /* Differential coding for indices of quantized norms */
544 82747 : if ( is_transient )
545 : {
546 : /* Reorder quantization indices and quantized norms */
547 3614 : reordernorm( ynrm, normqlg2, idxbuf, normbuf, num_env_bands );
548 3614 : diffcod( num_env_bands, idxbuf, &difidx[1] );
549 3614 : difidx[0] = idxbuf[0];
550 3614 : recovernorm( idxbuf, ynrm, normqlg2, num_env_bands );
551 : }
552 : else
553 : {
554 79133 : diffcod( num_env_bands, &ynrm[start_norm], &difidx[1] );
555 79133 : difidx[0] = ynrm[start_norm];
556 :
557 2362436 : for ( i = start_norm; i < start_norm + num_env_bands; i++ )
558 : {
559 2283303 : normqlg2[i] = dicnlg2[ynrm[i]];
560 : }
561 : }
562 :
563 82747 : return;
564 : }
|
