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 : #include <assert.h>
34 : #include <stdint.h>
35 : #include "options.h"
36 : #include <math.h>
37 : #include "cnst.h"
38 : #include "prot.h"
39 : #include "ivas_prot.h"
40 : #include "rom_com.h"
41 : #include "ivas_rom_com.h"
42 : #include "ivas_cnst.h"
43 : #ifdef DEBUGGING
44 : #include "debug.h"
45 : #endif
46 : #include "wmc_auto.h"
47 :
48 :
49 : /*-------------------------------------------------------------------
50 : * sns_1st_cod()
51 : *
52 : *
53 : *-------------------------------------------------------------------*/
54 :
55 : /* r : codebook index */
56 1191349 : static int16_t sns_1st_cod(
57 : const float *sns, /* i : vector to quantize */
58 : const int16_t L_frame,
59 : const int16_t core,
60 : float *snsq /* o : quantized sns */
61 : )
62 : {
63 : int16_t index;
64 1191349 : const int16_t split_len = M / 2;
65 : const int16_t *means;
66 1191349 : const float means_fix2float = 1.f / powf( 2, SNS_MEANS_BITS_4_FRAC );
67 :
68 : /* remove means */
69 1191349 : means = NULL;
70 1191349 : switch ( L_frame )
71 : {
72 101214 : case L_FRAME16k:
73 101214 : means = &sns_1st_means_16k[core - 1][0];
74 101214 : break;
75 396336 : case L_FRAME25_6k:
76 396336 : means = &sns_1st_means_25k6[core - 1][0];
77 396336 : break;
78 693799 : case L_FRAME32k:
79 693799 : means = &sns_1st_means_32k[core - 1][0];
80 693799 : break;
81 0 : default:
82 0 : assert( !"illegal frame length in sns_1st_cod" );
83 : }
84 :
85 20252933 : for ( int16_t i = 0; i < M; ++i )
86 : {
87 19061584 : snsq[i] = sns[i] - means[i] * means_fix2float;
88 : }
89 :
90 1191349 : index = 0;
91 3574047 : for ( int16_t split = 0; split < 2; ++split )
92 : {
93 : const int16_t *cdbk_ptr;
94 : int16_t j0, j1, index_split;
95 : float dist_min;
96 2382698 : const float cdbk_fix2float = 1.f / powf( 2, SNS_CDBKS_BITS_4_FRAC );
97 2382698 : const int16_t *const cdbk = &sns_1st_cdbk[split][core - 1][0];
98 :
99 2382698 : j0 = split * split_len;
100 2382698 : j1 = j0 + split_len;
101 :
102 2382698 : cdbk_ptr = cdbk;
103 2382698 : dist_min = 1.0e30f;
104 2382698 : index_split = 0;
105 78629034 : for ( int16_t i = 0; i < 32; ++i )
106 : {
107 : float dist;
108 :
109 76246336 : dist = 0.f;
110 686217024 : for ( int16_t j = j0; j < j1; ++j )
111 : {
112 : float tmp;
113 :
114 609970688 : tmp = snsq[j] - ( *cdbk_ptr++ ) * cdbk_fix2float;
115 609970688 : dist += tmp * tmp;
116 : }
117 :
118 76246336 : if ( dist < dist_min )
119 : {
120 11503935 : dist_min = dist;
121 11503935 : index_split = i;
122 : }
123 : }
124 :
125 : /* set quantized vector */
126 2382698 : cdbk_ptr = &cdbk[index_split * split_len];
127 21444282 : for ( int16_t j = j0; j < j1; ++j )
128 : {
129 19061584 : snsq[j] = ( *cdbk_ptr++ ) * cdbk_fix2float + means[j] * means_fix2float;
130 : }
131 :
132 : /* for second split shift by five bits to store both indices as one 10 bit value */
133 2382698 : if ( split == 1 )
134 : {
135 1191349 : index_split <<= 5;
136 : }
137 :
138 2382698 : index += index_split;
139 : }
140 :
141 1191349 : return index;
142 : }
143 :
144 :
145 : /*-------------------------------------------------------------------
146 : * sns_2st_cod()
147 : *
148 : *
149 : *-------------------------------------------------------------------*/
150 :
151 : /* r : number of allocated bits */
152 1793958 : static int16_t sns_2st_cod(
153 : const float *sns, /* i : normalized vector to quantize */
154 : float *snsq, /* i/o: i:1st stage o:1st+2nd stage */
155 : int16_t *indx /* o : index[] (4 bits per words) */
156 : )
157 : {
158 : int16_t i, nbits;
159 : float x[M];
160 : int16_t nq, xq[M];
161 1793958 : float scale = 1.0f / 2.5f;
162 :
163 30497286 : for ( i = 0; i < M; i++ )
164 : {
165 28703328 : x[i] = ( sns[i] - snsq[i] ) / scale;
166 : }
167 :
168 : /* quantize */
169 1793958 : AVQ_cod_lpc( x, xq, indx, 2 );
170 :
171 30497286 : for ( i = 0; i < M; i++ )
172 : {
173 28703328 : snsq[i] += scale * (float) xq[i];
174 : }
175 :
176 : /* total number of bits using entropic code to index the quantizer number */
177 1793958 : nbits = 0;
178 :
179 5381874 : for ( i = 0; i < 2; i++ )
180 : {
181 3587916 : nq = indx[i];
182 3587916 : nbits += ( 2 + ( nq * 4 ) ); /* 2 bits to specify Q2,Q3,Q4,ext */
183 :
184 3587916 : if ( nq > 6 )
185 : {
186 90204 : nbits += nq - 3; /* unary code (Q7=1110, ...) */
187 : }
188 3497712 : else if ( nq > 4 )
189 : {
190 187682 : nbits += nq - 4; /* Q5=0, Q6=10 */
191 : }
192 3310030 : else if ( nq == 0 )
193 : {
194 361788 : nbits += 3; /* Q0=110 */
195 : }
196 : }
197 :
198 1793958 : return ( nbits );
199 : }
200 :
201 :
202 : /*-------------------------------------------------------------------
203 : * sns_avq_cod()
204 : *
205 : * Stereo noise-shaping AVQ encoder for 1 channel
206 : *-------------------------------------------------------------------*/
207 :
208 266003 : void sns_avq_cod(
209 : const float *sns, /* i : Input sns vectors */
210 : const float *snsmid, /* i : Input mid-sns vectors */
211 : float *sns_q, /* o : Quantized LFS vectors */
212 : float *snsmid_q, /* o : Quantized mid-LFS vectors */
213 : int16_t *index, /* o : Quantization indices */
214 : const int16_t core, /* i : core */
215 : const int16_t L_frame,
216 : const int16_t low_brate_mode /* i : flag low bit operating mode */
217 : )
218 : {
219 : int16_t i;
220 : float snsmid_q0[M];
221 : int16_t indxt[256], nbits, nbt, nit;
222 :
223 266003 : index[0] = sns_1st_cod( sns, L_frame, core, sns_q );
224 266003 : nit = 1 + 2;
225 266003 : if ( !low_brate_mode )
226 : {
227 265578 : nbt = sns_2st_cod( sns, sns_q, &index[1] );
228 265578 : nit += index[1] + index[2];
229 : }
230 : else
231 : {
232 425 : index[1] = SNS_LOW_BR_MODE;
233 425 : index[2] = 0;
234 : }
235 :
236 266003 : index += nit;
237 266003 : nit = 0;
238 266003 : *index = 0;
239 :
240 266003 : if ( core == TCX_10_CORE )
241 : {
242 58595 : index++;
243 :
244 58595 : index[0] = sns_1st_cod( snsmid, L_frame, core, snsmid_q );
245 58595 : nit = 1 + 2;
246 58595 : if ( !low_brate_mode )
247 : {
248 58219 : nbits = sns_2st_cod( snsmid, snsmid_q, &index[1] );
249 58219 : nit += index[1] + index[2];
250 : }
251 : else
252 : {
253 376 : index[1] = SNS_LOW_BR_MODE;
254 376 : index[2] = 0;
255 376 : nbits = 0;
256 : }
257 :
258 :
259 58595 : nbt = 10 + nbits;
260 :
261 58595 : if ( !low_brate_mode )
262 : {
263 989723 : for ( i = 0; i < M; i++ )
264 : {
265 931504 : snsmid_q0[i] = sns_q[i];
266 : }
267 58219 : nbits = sns_2st_cod( snsmid, snsmid_q0, indxt );
268 58219 : if ( nbits < nbt )
269 : {
270 27528 : nbt = nbits;
271 27528 : nit = 2 + indxt[0] + indxt[1];
272 27528 : index[-1] = 1;
273 :
274 467976 : for ( i = 0; i < M; i++ )
275 : {
276 440448 : snsmid_q[i] = snsmid_q0[i];
277 : }
278 :
279 278411 : for ( i = 0; i < nit; i++ )
280 : {
281 250883 : index[i] = indxt[i];
282 : }
283 : }
284 : }
285 58595 : index += nit;
286 : }
287 :
288 266003 : return;
289 : }
290 :
291 :
292 : /*-------------------------------------------------------------------
293 : * sns_avq_cod_stereo()
294 : *
295 : * Stereo noise-shaping AVQ encoder for 2 channels
296 : *-------------------------------------------------------------------*/
297 :
298 705971 : void sns_avq_cod_stereo(
299 : const float *snsl, /* i : Input sns vector (left channel) */
300 : const float *snsr, /* i : Input sns vector (right channel) */
301 : const int16_t L_frame,
302 : float *snsl_q, /* o : Quantized sns vector (left channel) */
303 : float *snsr_q, /* o : Quantized sns vector (right channel) */
304 : int16_t *indexl, /* o : Quantization indices (left channel) */
305 : int16_t *indexr /* o : Quantization indices (right channel) */
306 : )
307 : {
308 : int16_t i, flag_zero;
309 : float mid[M], side[M], mid_q[M], side_q[M], ener_side;
310 :
311 : /* Compute side */
312 705971 : ener_side = 0.f;
313 12001507 : for ( i = 0; i < M; i++ )
314 : {
315 11295536 : side[i] = snsl[i] - snsr[i];
316 11295536 : ener_side += side[i] * side[i];
317 : }
318 : #ifdef DEBUG_MODE_MDCT
319 : {
320 : float ener_mid = 0;
321 : /* Compute mid */
322 : for ( i = 0; i < M; i++ )
323 : {
324 : mid[i] = ( snsl[i] + snsr[i] ) * 0.5f;
325 : ener_mid += mid[i] * mid[i];
326 : }
327 : dbgwrite( &ener_side, sizeof( float ), 1, 1, "./res/ener_side" );
328 : dbgwrite( &ener_mid, sizeof( float ), 1, 1, "./res/ener_mid" );
329 : }
330 : #endif
331 :
332 705971 : if ( ener_side < 12.f )
333 : {
334 : /* MS coding */
335 545191 : *indexl++ = 2;
336 545191 : *indexr++ = 3;
337 :
338 : /* Compute mid */
339 9268247 : for ( i = 0; i < M; i++ )
340 : {
341 8723056 : mid[i] = ( snsl[i] + snsr[i] ) * 0.5f;
342 : }
343 :
344 : /* Quantize mid */
345 545191 : indexl[0] = sns_1st_cod( mid, L_frame, TCX_20_CORE, mid_q );
346 545191 : sns_2st_cod( mid, mid_q, &indexl[1] );
347 :
348 : /* Quantize side */
349 545191 : indexr[0] = -1;
350 9268247 : for ( i = 0; i < M; i++ )
351 : {
352 8723056 : side_q[i] = 0.f;
353 : }
354 545191 : sns_2st_cod( side, side_q, &indexr[1] );
355 :
356 : /* Detect zero side */
357 545191 : flag_zero = 1;
358 2009332 : for ( i = 0; i < M; i++ )
359 : {
360 1940018 : if ( side_q[i] != 0 )
361 : {
362 475877 : flag_zero = 0;
363 475877 : break;
364 : }
365 : }
366 545191 : if ( flag_zero )
367 : {
368 69314 : indexr[0] = -2;
369 : }
370 :
371 : /* Go back to LR */
372 9268247 : for ( i = 0; i < M; i++ )
373 : {
374 8723056 : snsl_q[i] = mid_q[i] + side_q[i] * 0.5f;
375 8723056 : snsr_q[i] = mid_q[i] - side_q[i] * 0.5f;
376 : }
377 : }
378 : else
379 : {
380 : /* LR coding */
381 160780 : *indexl++ = 0;
382 160780 : *indexr++ = 1;
383 :
384 : /* Quantize left */
385 160780 : indexl[0] = sns_1st_cod( snsl, L_frame, TCX_20_CORE, snsl_q );
386 160780 : sns_2st_cod( snsl, snsl_q, &indexl[1] );
387 :
388 : /* Quantize right */
389 160780 : indexr[0] = sns_1st_cod( snsr, L_frame, TCX_20_CORE, snsr_q );
390 160780 : sns_2st_cod( snsr, snsr_q, &indexr[1] );
391 : }
392 :
393 705971 : return;
394 : }
395 :
396 79086 : int16_t quantize_sns(
397 : float sns_in[CPE_CHANNELS][NB_DIV][M],
398 : float snsQ_out[CPE_CHANNELS][NB_DIV][M],
399 : Encoder_State **sts,
400 : int16_t *indices,
401 : int16_t *zero_side_flag,
402 : int16_t *sns_stereo_mode )
403 : {
404 : int16_t nSubframes, k, ch, i;
405 : int16_t nbits, idxIndices;
406 : Encoder_State *st;
407 : float weights[M];
408 :
409 79086 : nbits = 0;
410 79086 : idxIndices = 0;
411 79086 : set_f( weights, 1.0f, M );
412 :
413 79086 : sns_stereo_mode[0] = SNS_STEREO_MODE_LR;
414 79086 : sns_stereo_mode[1] = SNS_STEREO_MODE_LR;
415 79086 : zero_side_flag[0] = 0;
416 79086 : zero_side_flag[1] = 0;
417 :
418 : /* use snsQ_out as buffer, move input vectors */
419 237258 : for ( ch = 0; ch < CPE_CHANNELS; ++ch )
420 : {
421 158172 : nSubframes = ( sts[ch]->core == TCX_20_CORE ) ? 1 : NB_DIV;
422 321782 : for ( k = 0; k < nSubframes; ++k )
423 : {
424 163610 : mvr2r( sns_in[ch][k], snsQ_out[ch][k], M );
425 : }
426 : }
427 :
428 : /* stereo mode decision */
429 79086 : if ( sts[0]->core == sts[1]->core )
430 : {
431 78682 : nSubframes = ( sts[0]->core == TCX_20_CORE ) ? 1 : NB_DIV;
432 :
433 159881 : for ( k = 0; k < nSubframes; ++k )
434 : {
435 : float side[M];
436 : float ener_side;
437 :
438 81199 : v_sub( snsQ_out[0][k], snsQ_out[1][k], side, M );
439 81199 : ener_side = dotp( side, side, M );
440 :
441 81199 : sns_stereo_mode[k] = ener_side < 12.f;
442 81199 : zero_side_flag[k] = ener_side < 1.f;
443 :
444 81199 : if ( sns_stereo_mode[k] == SNS_STEREO_MODE_MS )
445 : {
446 75427 : convertToMS( M, snsQ_out[0][k], snsQ_out[1][k], 0.5f );
447 : }
448 : }
449 : }
450 :
451 : /* run MSVQ */
452 237258 : for ( ch = 0; ch < CPE_CHANNELS; ++ch )
453 : {
454 158172 : st = sts[ch];
455 158172 : nSubframes = ( st->core == TCX_20_CORE ) ? 1 : NB_DIV;
456 :
457 321782 : for ( k = 0; k < nSubframes; ++k )
458 : {
459 163610 : const int16_t is_side = ch == 1 && sns_stereo_mode[k] == SNS_STEREO_MODE_MS;
460 163610 : const float *const *cdbks = ( nSubframes == 1 ) ? ivas_sns_cdbks_tcx20 : ivas_sns_cdbks_tcx10;
461 163610 : const int16_t *levels = ( nSubframes == 1 ) ? ivas_sns_cdbks_tcx20_levels : ivas_sns_cdbks_tcx10_levels;
462 163610 : const int16_t *bits = ( nSubframes == 1 ) ? ivas_sns_cdbks_tcx20_bits : ivas_sns_cdbks_tcx10_bits;
463 163610 : int16_t nStages = ( ( nSubframes == 1 ) ? SNS_MSVQ_NSTAGES_TCX20 : SNS_MSVQ_NSTAGES_TCX10 );
464 163610 : float *snsQ = snsQ_out[ch][k];
465 163610 : const float *sns_ptr = snsQ_out[ch][k];
466 :
467 163610 : if ( is_side )
468 : {
469 75427 : const float *const *side_cdbks = ( st->core == TCX_20_CORE ) ? ivas_sns_cdbks_side_tcx20 : ivas_sns_cdbks_side_tcx10;
470 75427 : const int16_t *side_levels = ( st->core == TCX_20_CORE ) ? ivas_sns_cdbks_side_tcx20_levels : ivas_sns_cdbks_side_tcx10_levels;
471 :
472 75427 : if ( zero_side_flag[k] )
473 : {
474 21767 : set_zero( snsQ, M );
475 21767 : continue;
476 : }
477 :
478 53660 : nStages = SNS_MSVQ_NSTAGES_SIDE;
479 53660 : bits = ( st->core == TCX_20_CORE ) ? ivas_sns_cdbks_side_tcx20_bits : ivas_sns_cdbks_side_tcx10_bits;
480 53660 : msvq_enc( side_cdbks, NULL, NULL, snsQ, side_levels, 3, nStages, weights, M, M, 0, NULL, &indices[idxIndices] );
481 53660 : msvq_dec( side_cdbks, NULL, NULL, nStages, M, M, &indices[idxIndices], 0, NULL, snsQ, NULL );
482 : }
483 : else
484 : {
485 88183 : msvq_enc( cdbks, NULL, NULL, sns_ptr, levels, 3, nStages, weights, M, M, 0, NULL, &indices[idxIndices] );
486 88183 : msvq_dec( cdbks, NULL, NULL, nStages, M, M, &indices[idxIndices], 0, NULL, snsQ, NULL );
487 : }
488 141843 : idxIndices += nStages;
489 :
490 595393 : for ( i = 0; i < nStages; ++i )
491 : {
492 453550 : nbits += bits[i];
493 : }
494 : }
495 : }
496 :
497 : /* get back to L/F representation */
498 79086 : if ( sns_stereo_mode[0] == SNS_STEREO_MODE_MS || sns_stereo_mode[1] == SNS_STEREO_MODE_MS )
499 : {
500 73515 : nSubframes = ( sts[0]->core == TCX_20_CORE ) ? 1 : NB_DIV;
501 149492 : for ( k = 0; k < nSubframes; ++k )
502 : {
503 75977 : if ( sns_stereo_mode[k] == SNS_STEREO_MODE_MS )
504 : {
505 75427 : convertToMS( M, snsQ_out[0][k], snsQ_out[1][k], 1.f );
506 : }
507 : }
508 : }
509 :
510 79086 : return nbits;
511 : }
|
