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 5583392 : 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 5583392 : const int16_t split_len = M / 2;
65 : const int16_t *means;
66 5583392 : const float means_fix2float = 1.f / powf( 2, SNS_MEANS_BITS_4_FRAC );
67 :
68 : /* remove means */
69 5583392 : means = NULL;
70 5583392 : switch ( L_frame )
71 : {
72 884506 : case L_FRAME16k:
73 884506 : means = &sns_1st_means_16k[core - 1][0];
74 884506 : break;
75 2045359 : case L_FRAME25_6k:
76 2045359 : means = &sns_1st_means_25k6[core - 1][0];
77 2045359 : break;
78 2653527 : case L_FRAME32k:
79 2653527 : means = &sns_1st_means_32k[core - 1][0];
80 2653527 : break;
81 0 : default:
82 0 : assert( !"illegal frame length in sns_1st_cod" );
83 : }
84 :
85 94917664 : for ( int16_t i = 0; i < M; ++i )
86 : {
87 89334272 : snsq[i] = sns[i] - means[i] * means_fix2float;
88 : }
89 :
90 5583392 : index = 0;
91 16750176 : 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 11166784 : const float cdbk_fix2float = 1.f / powf( 2, SNS_CDBKS_BITS_4_FRAC );
97 11166784 : const int16_t *const cdbk = &sns_1st_cdbk[split][core - 1][0];
98 :
99 11166784 : j0 = split * split_len;
100 11166784 : j1 = j0 + split_len;
101 :
102 11166784 : cdbk_ptr = cdbk;
103 11166784 : dist_min = 1.0e30f;
104 11166784 : index_split = 0;
105 368503872 : for ( int16_t i = 0; i < 32; ++i )
106 : {
107 : float dist;
108 :
109 357337088 : dist = 0.f;
110 3216033792 : for ( int16_t j = j0; j < j1; ++j )
111 : {
112 : float tmp;
113 :
114 2858696704 : tmp = snsq[j] - ( *cdbk_ptr++ ) * cdbk_fix2float;
115 2858696704 : dist += tmp * tmp;
116 : }
117 :
118 357337088 : if ( dist < dist_min )
119 : {
120 54094338 : dist_min = dist;
121 54094338 : index_split = i;
122 : }
123 : }
124 :
125 : /* set quantized vector */
126 11166784 : cdbk_ptr = &cdbk[index_split * split_len];
127 100501056 : for ( int16_t j = j0; j < j1; ++j )
128 : {
129 89334272 : 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 11166784 : if ( split == 1 )
134 : {
135 5583392 : index_split <<= 5;
136 : }
137 :
138 11166784 : index += index_split;
139 : }
140 :
141 5583392 : return index;
142 : }
143 :
144 :
145 : /*-------------------------------------------------------------------
146 : * sns_2st_cod()
147 : *
148 : *
149 : *-------------------------------------------------------------------*/
150 :
151 : /* r : number of allocated bits */
152 8865453 : 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 8865453 : float scale = 1.0f / 2.5f;
162 :
163 150712701 : for ( i = 0; i < M; i++ )
164 : {
165 141847248 : x[i] = ( sns[i] - snsq[i] ) / scale;
166 : }
167 :
168 : /* quantize */
169 8865453 : AVQ_cod_lpc( x, xq, indx, 2 );
170 :
171 150712701 : for ( i = 0; i < M; i++ )
172 : {
173 141847248 : snsq[i] += scale * (float) xq[i];
174 : }
175 :
176 : /* total number of bits using entropic code to index the quantizer number */
177 8865453 : nbits = 0;
178 :
179 26596359 : for ( i = 0; i < 2; i++ )
180 : {
181 17730906 : nq = indx[i];
182 17730906 : nbits += ( 2 + ( nq * 4 ) ); /* 2 bits to specify Q2,Q3,Q4,ext */
183 :
184 17730906 : if ( nq > 6 )
185 : {
186 15711 : nbits += nq - 3; /* unary code (Q7=1110, ...) */
187 : }
188 17715195 : else if ( nq > 4 )
189 : {
190 744403 : nbits += nq - 4; /* Q5=0, Q6=10 */
191 : }
192 16970792 : else if ( nq == 0 )
193 : {
194 2492337 : nbits += 3; /* Q0=110 */
195 : }
196 : }
197 :
198 8865453 : return ( nbits );
199 : }
200 :
201 :
202 : /*-------------------------------------------------------------------
203 : * sns_avq_cod()
204 : *
205 : * Stereo noise-shaping AVQ encoder for 1 channel
206 : *-------------------------------------------------------------------*/
207 :
208 1140142 : 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 1140142 : index[0] = sns_1st_cod( sns, L_frame, core, sns_q );
224 1140142 : nit = 1 + 2;
225 1140142 : if ( !low_brate_mode )
226 : {
227 1137711 : nbt = sns_2st_cod( sns, sns_q, &index[1] );
228 1137711 : nit += index[1] + index[2];
229 : }
230 : else
231 : {
232 2431 : index[1] = SNS_LOW_BR_MODE;
233 2431 : index[2] = 0;
234 : }
235 :
236 1140142 : index += nit;
237 1140142 : nit = 0;
238 1140142 : *index = 0;
239 :
240 1140142 : if ( core == TCX_10_CORE )
241 : {
242 192148 : index++;
243 :
244 192148 : index[0] = sns_1st_cod( snsmid, L_frame, core, snsmid_q );
245 192148 : nit = 1 + 2;
246 192148 : if ( !low_brate_mode )
247 : {
248 189916 : nbits = sns_2st_cod( snsmid, snsmid_q, &index[1] );
249 189916 : nit += index[1] + index[2];
250 : }
251 : else
252 : {
253 2232 : index[1] = SNS_LOW_BR_MODE;
254 2232 : index[2] = 0;
255 2232 : nbits = 0;
256 : }
257 :
258 :
259 192148 : nbt = 10 + nbits;
260 :
261 192148 : if ( !low_brate_mode )
262 : {
263 3228572 : for ( i = 0; i < M; i++ )
264 : {
265 3038656 : snsmid_q0[i] = sns_q[i];
266 : }
267 189916 : nbits = sns_2st_cod( snsmid, snsmid_q0, indxt );
268 189916 : if ( nbits < nbt )
269 : {
270 129110 : nbt = nbits;
271 129110 : nit = 2 + indxt[0] + indxt[1];
272 129110 : index[-1] = 1;
273 :
274 2194870 : for ( i = 0; i < M; i++ )
275 : {
276 2065760 : snsmid_q[i] = snsmid_q0[i];
277 : }
278 :
279 1096000 : for ( i = 0; i < nit; i++ )
280 : {
281 966890 : index[i] = indxt[i];
282 : }
283 : }
284 : }
285 192148 : index += nit;
286 : }
287 :
288 1140142 : return;
289 : }
290 :
291 :
292 : /*-------------------------------------------------------------------
293 : * sns_avq_cod_stereo()
294 : *
295 : * Stereo noise-shaping AVQ encoder for 2 channels
296 : *-------------------------------------------------------------------*/
297 :
298 3673955 : 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 3673955 : ener_side = 0.f;
313 62457235 : for ( i = 0; i < M; i++ )
314 : {
315 58783280 : side[i] = snsl[i] - snsr[i];
316 58783280 : 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 3673955 : if ( ener_side < 12.f )
333 : {
334 : /* MS coding */
335 3096808 : *indexl++ = 2;
336 3096808 : *indexr++ = 3;
337 :
338 : /* Compute mid */
339 52645736 : for ( i = 0; i < M; i++ )
340 : {
341 49548928 : mid[i] = ( snsl[i] + snsr[i] ) * 0.5f;
342 : }
343 :
344 : /* Quantize mid */
345 3096808 : indexl[0] = sns_1st_cod( mid, L_frame, TCX_20_CORE, mid_q );
346 3096808 : sns_2st_cod( mid, mid_q, &indexl[1] );
347 :
348 : /* Quantize side */
349 3096808 : indexr[0] = -1;
350 52645736 : for ( i = 0; i < M; i++ )
351 : {
352 49548928 : side_q[i] = 0.f;
353 : }
354 3096808 : sns_2st_cod( side, side_q, &indexr[1] );
355 :
356 : /* Detect zero side */
357 3096808 : flag_zero = 1;
358 14109365 : for ( i = 0; i < M; i++ )
359 : {
360 13553442 : if ( side_q[i] != 0 )
361 : {
362 2540885 : flag_zero = 0;
363 2540885 : break;
364 : }
365 : }
366 3096808 : if ( flag_zero )
367 : {
368 555923 : indexr[0] = -2;
369 : }
370 :
371 : /* Go back to LR */
372 52645736 : for ( i = 0; i < M; i++ )
373 : {
374 49548928 : snsl_q[i] = mid_q[i] + side_q[i] * 0.5f;
375 49548928 : snsr_q[i] = mid_q[i] - side_q[i] * 0.5f;
376 : }
377 : }
378 : else
379 : {
380 : /* LR coding */
381 577147 : *indexl++ = 0;
382 577147 : *indexr++ = 1;
383 :
384 : /* Quantize left */
385 577147 : indexl[0] = sns_1st_cod( snsl, L_frame, TCX_20_CORE, snsl_q );
386 577147 : sns_2st_cod( snsl, snsl_q, &indexl[1] );
387 :
388 : /* Quantize right */
389 577147 : indexr[0] = sns_1st_cod( snsr, L_frame, TCX_20_CORE, snsr_q );
390 577147 : sns_2st_cod( snsr, snsr_q, &indexr[1] );
391 : }
392 :
393 3673955 : return;
394 : }
395 :
396 751300 : 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 751300 : nbits = 0;
410 751300 : idxIndices = 0;
411 751300 : set_f( weights, 1.0f, M );
412 :
413 751300 : sns_stereo_mode[0] = SNS_STEREO_MODE_LR;
414 751300 : sns_stereo_mode[1] = SNS_STEREO_MODE_LR;
415 751300 : zero_side_flag[0] = 0;
416 751300 : zero_side_flag[1] = 0;
417 :
418 : /* use snsQ_out as buffer, move input vectors */
419 2253900 : for ( ch = 0; ch < CPE_CHANNELS; ++ch )
420 : {
421 1502600 : nSubframes = ( sts[ch]->core == TCX_20_CORE ) ? 1 : NB_DIV;
422 3045775 : for ( k = 0; k < nSubframes; ++k )
423 : {
424 1543175 : mvr2r( sns_in[ch][k], snsQ_out[ch][k], M );
425 : }
426 : }
427 :
428 : /* stereo mode decision */
429 751300 : if ( sts[0]->core == sts[1]->core )
430 : {
431 746251 : nSubframes = ( sts[0]->core == TCX_20_CORE ) ? 1 : NB_DIV;
432 :
433 1510265 : for ( k = 0; k < nSubframes; ++k )
434 : {
435 : float side[M];
436 : float ener_side;
437 :
438 764014 : v_sub( snsQ_out[0][k], snsQ_out[1][k], side, M );
439 764014 : ener_side = dotp( side, side, M );
440 :
441 764014 : sns_stereo_mode[k] = ener_side < 12.f;
442 764014 : zero_side_flag[k] = ener_side < 1.f;
443 :
444 764014 : if ( sns_stereo_mode[k] == SNS_STEREO_MODE_MS )
445 : {
446 644120 : convertToMS( M, snsQ_out[0][k], snsQ_out[1][k], 0.5f );
447 : }
448 : }
449 : }
450 :
451 : /* run MSVQ */
452 2253900 : for ( ch = 0; ch < CPE_CHANNELS; ++ch )
453 : {
454 1502600 : st = sts[ch];
455 1502600 : nSubframes = ( st->core == TCX_20_CORE ) ? 1 : NB_DIV;
456 :
457 3045775 : for ( k = 0; k < nSubframes; ++k )
458 : {
459 1543175 : const int16_t is_side = ch == 1 && sns_stereo_mode[k] == SNS_STEREO_MODE_MS;
460 1543175 : const float *const *cdbks = ( nSubframes == 1 ) ? ivas_sns_cdbks_tcx20 : ivas_sns_cdbks_tcx10;
461 1543175 : const int16_t *levels = ( nSubframes == 1 ) ? ivas_sns_cdbks_tcx20_levels : ivas_sns_cdbks_tcx10_levels;
462 1543175 : const int16_t *bits = ( nSubframes == 1 ) ? ivas_sns_cdbks_tcx20_bits : ivas_sns_cdbks_tcx10_bits;
463 1543175 : int16_t nStages = ( ( nSubframes == 1 ) ? SNS_MSVQ_NSTAGES_TCX20 : SNS_MSVQ_NSTAGES_TCX10 );
464 1543175 : float *snsQ = snsQ_out[ch][k];
465 1543175 : const float *sns_ptr = snsQ_out[ch][k];
466 :
467 1543175 : if ( is_side )
468 : {
469 644120 : const float *const *side_cdbks = ( st->core == TCX_20_CORE ) ? ivas_sns_cdbks_side_tcx20 : ivas_sns_cdbks_side_tcx10;
470 644120 : const int16_t *side_levels = ( st->core == TCX_20_CORE ) ? ivas_sns_cdbks_side_tcx20_levels : ivas_sns_cdbks_side_tcx10_levels;
471 :
472 644120 : if ( zero_side_flag[k] )
473 : {
474 159682 : set_zero( snsQ, M );
475 159682 : continue;
476 : }
477 :
478 484438 : nStages = SNS_MSVQ_NSTAGES_SIDE;
479 484438 : bits = ( st->core == TCX_20_CORE ) ? ivas_sns_cdbks_side_tcx20_bits : ivas_sns_cdbks_side_tcx10_bits;
480 484438 : msvq_enc( side_cdbks, NULL, NULL, snsQ, side_levels, 3, nStages, weights, M, M, 0, NULL, &indices[idxIndices] );
481 484438 : msvq_dec( side_cdbks, NULL, NULL, nStages, M, M, &indices[idxIndices], 0, NULL, snsQ, NULL );
482 : }
483 : else
484 : {
485 899055 : msvq_enc( cdbks, NULL, NULL, sns_ptr, levels, 3, nStages, weights, M, M, 0, NULL, &indices[idxIndices] );
486 899055 : msvq_dec( cdbks, NULL, NULL, nStages, M, M, &indices[idxIndices], 0, NULL, snsQ, NULL );
487 : }
488 1383493 : idxIndices += nStages;
489 :
490 5899601 : for ( i = 0; i < nStages; ++i )
491 : {
492 4516108 : nbits += bits[i];
493 : }
494 : }
495 : }
496 :
497 : /* get back to L/F representation */
498 751300 : if ( sns_stereo_mode[0] == SNS_STEREO_MODE_MS || sns_stereo_mode[1] == SNS_STEREO_MODE_MS )
499 : {
500 628952 : nSubframes = ( sts[0]->core == TCX_20_CORE ) ? 1 : NB_DIV;
501 1274898 : for ( k = 0; k < nSubframes; ++k )
502 : {
503 645946 : if ( sns_stereo_mode[k] == SNS_STEREO_MODE_MS )
504 : {
505 644120 : convertToMS( M, snsQ_out[0][k], snsQ_out[1][k], 1.f );
506 : }
507 : }
508 : }
509 :
510 751300 : return nbits;
511 : }
|
