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