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 16912 : 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 16912 : set_s( difidx_org, 0, NB_SFM );
76 16912 : 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 16912 : if ( flag_pack == 0 )
88 : {
89 8457 : if ( is_transient && flag_HQ2 == LOW_RATE_HQ_CORE_TRAN )
90 : {
91 3 : bits = 0;
92 3 : index_max = 0;
93 3 : index_min = 31;
94 99 : for ( i = 0; i < num_sfm; i++ )
95 : {
96 96 : if ( difidx[i] > index_max )
97 : {
98 11 : index_max = difidx[i];
99 : }
100 96 : if ( difidx[i] < index_min )
101 : {
102 4 : index_min = difidx[i];
103 : }
104 : }
105 3 : if ( index_min > 10 && index_max < 22 )
106 : {
107 96 : for ( i = 1; i < num_sfm; i++ )
108 : {
109 93 : j = difidx[i];
110 93 : bits += huffsizn_tran[j];
111 : }
112 : }
113 3 : hcode_l = 0;
114 3 : *LCmode = 0;
115 3 : prevj = difidx[0] + OFFSET_NORM;
116 : /* LC mode 0 = Context based coding */
117 96 : for ( i = 1; i < num_sfm; i++ )
118 : {
119 93 : j = difidx[i];
120 93 : if ( prevj > HTH_NORM )
121 : {
122 : /* above */
123 1 : hcode_l += huffsizn_n[31 - j];
124 : }
125 : else
126 : {
127 92 : if ( prevj < LTH_NORM )
128 : {
129 : /* less */
130 1 : hcode_l += huffsizn_n[j];
131 : }
132 : else
133 : {
134 : /* equal */
135 91 : hcode_l += huffsizn_e[j];
136 : }
137 : }
138 93 : prevj = j;
139 : }
140 3 : if ( hcode_l >= bits && bits != 0 )
141 : {
142 : /* LC mode 1 Transient Huffman Coding */
143 3 : *LCmode = 1;
144 3 : hcode_l = bits;
145 : }
146 : }
147 : else
148 : {
149 : /* Check bits if LC mode == 3 -> Check bits if LC mode == 0 */
150 8454 : hcode_l = 0;
151 8454 : prevj = difidx[0] + OFFSET_NORM;
152 250215 : for ( i = 1; i < num_sfm; i++ )
153 : {
154 241761 : j = difidx[i];
155 241761 : if ( prevj > HTH_NORM )
156 : {
157 : /* above */
158 52305 : hcode_l += huffsizn_n[31 - j];
159 : }
160 : else
161 : {
162 189456 : if ( prevj < LTH_NORM )
163 : {
164 : /* less */
165 32381 : hcode_l += huffsizn_n[j];
166 : }
167 : else
168 : {
169 : /* equal */
170 157075 : hcode_l += huffsizn_e[j];
171 : }
172 : }
173 241761 : prevj = j;
174 : }
175 :
176 8454 : *LCmode = 0;
177 :
178 : /* LR-MDCT core doesn't have coding mode 2 and 3 */
179 8454 : if ( flag_HQ2 == NORMAL_HQ_CORE )
180 : {
181 : /* Check bits if LC mode == 1 -> Check bits if LC mode == 2 */
182 8423 : bits = 0;
183 249533 : for ( i = 1; i < num_sfm; i++ )
184 : {
185 241110 : j = difidx[i];
186 241110 : bits += huffsizn[j];
187 : }
188 :
189 : /*------------------------------------------------------------------------------*
190 : * comparing bit expenses of coding mode 2 with that of the optimal coding mode
191 : *------------------------------------------------------------------------------*/
192 :
193 8423 : if ( hcode_l > bits )
194 : {
195 1139 : *LCmode = 2;
196 1139 : hcode_l = bits;
197 : }
198 : }
199 :
200 : /* Check bits if LC mode == 2 -> Check bits if LC mode == 1 */
201 8454 : bits = 0;
202 8454 : index_max = 0;
203 8454 : index_min = 31;
204 250215 : for ( i = 1; i < num_sfm; i++ )
205 : {
206 241761 : difidx_org[i] = difidx[i];
207 : }
208 :
209 8454 : difidx_flag = 0;
210 241761 : for ( i = 2; i < num_sfm; i++ )
211 : {
212 233307 : if ( difidx_org[i - 1] > 17 )
213 : {
214 46067 : difidx[i] = difidx_org[i] + min( ( difidx_org[i - 1] - 17 ), 3 );
215 46067 : if ( difidx[i] > 31 )
216 : {
217 0 : difidx_flag = 1;
218 0 : break;
219 : }
220 : }
221 :
222 233307 : if ( difidx_org[i - 1] < 13 )
223 : {
224 32291 : difidx[i] = difidx_org[i] + max( ( difidx_org[i - 1] - 13 ), -3 );
225 32291 : if ( difidx[i] < 0 )
226 : {
227 0 : difidx_flag = 1;
228 0 : break;
229 : }
230 : }
231 : }
232 :
233 8454 : index_rad = 0;
234 8454 : if ( difidx_flag != 1 )
235 : {
236 250215 : for ( i = 1; i < num_sfm; i++ )
237 : {
238 241761 : if ( difidx[i] > index_max )
239 : {
240 25180 : index_max = difidx[i];
241 : }
242 :
243 241761 : if ( difidx[i] < index_min )
244 : {
245 26352 : index_min = difidx[i];
246 : }
247 : }
248 :
249 8454 : index_rad = max( ( 15 - index_min ), ( index_max - 15 ) );
250 :
251 8454 : if ( index_rad <= HUFF_THR )
252 : {
253 238179 : for ( i = 1; i < num_sfm; i++ )
254 : {
255 230106 : j = difidx[i];
256 230106 : bits += resize_huffsizn[j];
257 : }
258 :
259 : /*------------------------------------------------------------------*
260 : * comparing bit expenses of coding mode 1 with that of coding mode 0
261 : *------------------------------------------------------------------*/
262 :
263 8073 : if ( hcode_l > bits )
264 : {
265 2396 : hcode_l = bits;
266 2396 : *LCmode = 1;
267 : }
268 : }
269 : }
270 :
271 : /* LR-MDCT core doesn't have coding mode 2 and 3 */
272 8454 : 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 8423 : if ( hcode_l >= numnrmibits )
279 : {
280 127 : hcode_l = numnrmibits;
281 127 : *LCmode = 3;
282 : }
283 : }
284 :
285 8454 : if ( ( *LCmode != 1 && flag_HQ2 == NORMAL_HQ_CORE ) || flag_HQ2 == LOW_RATE_HQ_CORE )
286 : {
287 172444 : for ( i = 2; i < num_sfm; i++ )
288 : {
289 166373 : difidx[i] = difidx_org[i];
290 : }
291 : }
292 : }
293 : }
294 : else
295 : {
296 8455 : if ( flag_HQ2 == LOW_RATE_HQ_CORE_TRAN || flag_HQ2 == LOW_RATE_HQ_CORE )
297 : {
298 32 : push_indice( hBstr, IND_HQ2_DENG_HMODE, *LCmode, BITS_DE_HMODE );
299 32 : push_indice( hBstr, IND_HQ2_DIFF_ENERGY, difidx[0], BITS_DE_FCOMP );
300 : }
301 : else
302 : {
303 8423 : push_indice( hBstr, IND_LC_MODE, *LCmode, 2 );
304 8423 : push_indice( hBstr, IND_YNRM, difidx[0], NORM0_BITS );
305 : }
306 :
307 8455 : if ( is_transient && flag_HQ2 == LOW_RATE_HQ_CORE_TRAN )
308 : {
309 2 : hcode_l = 0;
310 2 : if ( *LCmode == 1 )
311 : {
312 : /* LC mode 0 Transient Huffman Coding */
313 64 : for ( i = 1; i < num_sfm; i++ )
314 : {
315 62 : j = difidx[i];
316 62 : m = huffnorm_tran[j];
317 62 : r = huffsizn_tran[j];
318 62 : v = 0;
319 :
320 : /* Bit reverse */
321 190 : for ( k = 0; k < r; k++ )
322 : {
323 128 : v <<= 1;
324 128 : v |= m & 1;
325 128 : m >>= 1;
326 : }
327 :
328 62 : push_indice( hBstr, IND_HQ2_DIFF_ENERGY, v, r );
329 : }
330 : }
331 : else
332 : {
333 : /* LC mode 1 context based Coding */
334 0 : prevj = difidx[0] + OFFSET_NORM;
335 0 : for ( i = 1; i < num_sfm; i++ )
336 : {
337 0 : j = difidx[i];
338 :
339 0 : if ( prevj > HTH_NORM )
340 : {
341 : /* above */
342 0 : r = huffsizn_n[31 - j];
343 0 : m = huffnorm_n[31 - j];
344 : }
345 : else
346 : {
347 0 : if ( prevj < LTH_NORM )
348 : {
349 : /* less */
350 0 : r = huffsizn_n[j];
351 0 : m = huffnorm_n[j];
352 : }
353 : else
354 : {
355 : /* equal */
356 0 : r = huffsizn_e[j];
357 0 : m = huffnorm_e[j];
358 : }
359 : }
360 0 : push_indice( hBstr, IND_HQ2_DIFF_ENERGY, m, r );
361 0 : prevj = j;
362 : }
363 : }
364 : }
365 : else
366 : {
367 8453 : hcode_l = 0;
368 8453 : if ( *LCmode == 0 )
369 : {
370 : /* LC mode 3 -> LC mode 0 */
371 4915 : prevj = difidx[0] + OFFSET_NORM;
372 146621 : for ( i = 1; i < num_sfm; i++ )
373 : {
374 141706 : j = difidx[i];
375 :
376 141706 : if ( prevj > HTH_NORM )
377 : {
378 : /* above */
379 29984 : r = huffsizn_n[31 - j];
380 29984 : m = huffnorm_n[31 - j];
381 : }
382 : else
383 : {
384 111722 : if ( prevj < LTH_NORM )
385 : {
386 : /* less */
387 18336 : r = huffsizn_n[j];
388 18336 : m = huffnorm_n[j];
389 : }
390 : else
391 : {
392 : /* equal */
393 93386 : r = huffsizn_e[j];
394 93386 : m = huffnorm_e[j];
395 : }
396 : }
397 :
398 141706 : if ( flag_HQ2 == LOW_RATE_HQ_CORE )
399 : {
400 357 : push_indice( hBstr, IND_HQ2_DIFF_ENERGY, m, r );
401 : }
402 : else
403 : {
404 141349 : push_indice( hBstr, IND_YNRM, m, r );
405 : }
406 :
407 141706 : prevj = j;
408 : }
409 : }
410 3538 : else if ( *LCmode == 1 )
411 : {
412 2396 : if ( flag_HQ2 == 1 )
413 : {
414 13 : index_max = 0;
415 13 : index_min = 31;
416 286 : for ( i = 1; i < num_sfm; i++ )
417 : {
418 273 : difidx_org[i] = difidx[i];
419 : }
420 :
421 273 : for ( i = 2; i < num_sfm; i++ )
422 : {
423 260 : if ( difidx_org[i - 1] > 17 )
424 : {
425 55 : difidx[i] = difidx_org[i] + min( ( difidx_org[i - 1] - 17 ), 3 );
426 55 : if ( difidx[i] > 31 )
427 : {
428 0 : difidx_flag = 1;
429 0 : break;
430 : }
431 : }
432 :
433 260 : if ( difidx_org[i - 1] < 13 )
434 : {
435 14 : difidx[i] = difidx_org[i] + max( ( difidx_org[i - 1] - 13 ), -3 );
436 14 : if ( difidx[i] < 0 )
437 : {
438 0 : difidx_flag = 1;
439 0 : break;
440 : }
441 : }
442 : }
443 :
444 13 : if ( difidx_flag != 1 )
445 : {
446 286 : for ( i = 1; i < num_sfm; i++ )
447 : {
448 273 : if ( difidx[i] > index_max )
449 : {
450 23 : index_max = difidx[i];
451 : }
452 :
453 273 : if ( difidx[i] < index_min )
454 : {
455 42 : index_min = difidx[i];
456 : }
457 : }
458 :
459 13 : index_rad = max( ( 15 - index_min ), ( index_max - 15 ) );
460 :
461 13 : if ( index_rad <= HUFF_THR )
462 : {
463 286 : for ( i = 1; i < num_sfm; i++ )
464 : {
465 273 : j = difidx[i];
466 : }
467 : }
468 : }
469 : }
470 :
471 : /* LC mode 2 -> LC mode 1 */
472 71986 : for ( i = 1; i < num_sfm; i++ )
473 : {
474 69590 : j = difidx[i];
475 :
476 69590 : m = resize_huffnorm[j];
477 69590 : r = resize_huffsizn[j];
478 69590 : v = 0;
479 :
480 : /* Bit reverse */
481 293496 : for ( k = 0; k < r; k++ )
482 : {
483 223906 : v <<= 1;
484 223906 : v |= m & 1;
485 223906 : m >>= 1;
486 : }
487 :
488 69590 : if ( flag_HQ2 )
489 : {
490 273 : push_indice( hBstr, IND_HQ2_DIFF_ENERGY, v, r );
491 : }
492 : else
493 : {
494 69317 : push_indice( hBstr, IND_YNRM, v, r );
495 : }
496 : }
497 : }
498 1142 : else if ( *LCmode == 2 )
499 : {
500 : /* LC mode 1 -> LC mode 2 */
501 28665 : for ( i = 1; i < num_sfm; i++ )
502 : {
503 27650 : j = difidx[i];
504 :
505 27650 : m = huffnorm[j];
506 27650 : r = huffsizn[j];
507 :
508 27650 : push_indice( hBstr, IND_YNRM, m, r );
509 : }
510 : }
511 : else
512 : {
513 2921 : for ( i = 1; i < num_sfm; i++ )
514 : {
515 2794 : push_indice( hBstr, IND_YNRM, difidx[i], NORMI_BITS );
516 : }
517 : }
518 : }
519 : }
520 :
521 16912 : return hcode_l;
522 : }
523 :
524 : /*--------------------------------------------------------------------------*
525 : * diff_envelope_coding()
526 : *
527 : * Create differential code of norm indices
528 : *--------------------------------------------------------------------------*/
529 :
530 8423 : 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 8423 : if ( is_transient )
545 : {
546 : /* Reorder quantization indices and quantized norms */
547 562 : reordernorm( ynrm, normqlg2, idxbuf, normbuf, num_env_bands );
548 562 : diffcod( num_env_bands, idxbuf, &difidx[1] );
549 562 : difidx[0] = idxbuf[0];
550 562 : recovernorm( idxbuf, ynrm, normqlg2, num_env_bands );
551 : }
552 : else
553 : {
554 7861 : diffcod( num_env_bands, &ynrm[start_norm], &difidx[1] );
555 7861 : difidx[0] = ynrm[start_norm];
556 :
557 233683 : for ( i = start_norm; i < start_norm + num_env_bands; i++ )
558 : {
559 225822 : normqlg2[i] = dicnlg2[ynrm[i]];
560 : }
561 : }
562 :
563 8423 : return;
564 : }
|
