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