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 "ivas_cnst.h"
38 : #include "ivas_prot.h"
39 : #include "prot.h"
40 : #include "wmc_auto.h"
41 :
42 :
43 : /*-------------------------------------------------------------------*
44 : * Local function prototypes
45 : *-------------------------------------------------------------------*/
46 :
47 : static void inverseBwMS( const int16_t startLine, const int16_t stopLine, float x0[], float x1[], const float norm_fac );
48 :
49 :
50 : /*-------------------------------------------------------------------*
51 : * parse_stereo_from_bitstream
52 : *
53 : *
54 : *-------------------------------------------------------------------*/
55 :
56 5547214 : void parse_stereo_from_bitstream(
57 : STEREO_MDCT_DEC_DATA_HANDLE hStereoMdct, /* i/o: MDCT stereo decoder structure */
58 : Decoder_State **sts, /* i/o: decoder state structure */
59 : const int16_t mct_on, /* i : flag mct block (1) or stereo (0)*/
60 : const int16_t isSBAStereoMode, /* i : flag core coding for SBA */
61 : Decoder_State *st0, /* i/o: decoder state structure for Bstr*/
62 : int16_t ms_mask[NB_DIV][MAX_SFB] /* o : bandwise MS mask */
63 : )
64 : {
65 : int16_t i, k, nSubframes, mdct_stereo_mode;
66 : STEREO_MDCT_BAND_PARAMETERS *sfbConf;
67 : #ifdef DEBUGGING
68 : int16_t nbits_start = st0->next_bit_pos;
69 : #endif
70 :
71 5547214 : if ( !isSBAStereoMode )
72 : {
73 4071774 : nSubframes = ( sts[0]->core == TCX_10_CORE || ( sts[0]->core != sts[1]->core ) ) ? NB_DIV : 1;
74 4071774 : sfbConf = ( sts[0]->core == TCX_20_CORE ) ? &hStereoMdct->stbParamsTCX20 : &hStereoMdct->stbParamsTCX10;
75 4071774 : if ( sts[0]->last_core_from_bs == ACELP_CORE )
76 : {
77 12280 : sfbConf = &hStereoMdct->stbParamsTCX20afterACELP;
78 : }
79 :
80 4071774 : if ( hStereoMdct->use_itd )
81 : {
82 : int16_t I;
83 :
84 179119 : hStereoMdct->itd_mode = get_next_indice( st0, STEREO_DFT_ITD_MODE_NBITS );
85 : /*(*nb_bits) += STEREO_DFT_ITD_MODE_NBITS;*/ /*ITD mode flag: 1bit*/
86 :
87 179119 : hStereoMdct->itd = 0.f;
88 179119 : if ( hStereoMdct->itd_mode )
89 : {
90 46767 : /*(*nb_bits) += */ read_itd( st0, &I );
91 46767 : stereo_dft_dequantize_itd( &I, &hStereoMdct->itd, st0->output_Fs );
92 : }
93 : }
94 :
95 8259260 : for ( k = 0; k < nSubframes; k++ )
96 : {
97 4187486 : mdct_stereo_mode = get_next_indice( st0, 1 );
98 4187486 : if ( mdct_stereo_mode )
99 : {
100 4069935 : mdct_stereo_mode = 1 + get_next_indice( st0, 1 );
101 : }
102 4187486 : switch ( mdct_stereo_mode )
103 : {
104 117551 : case 0:
105 117551 : hStereoMdct->mdct_stereo_mode[k] = SMDCT_DUAL_MONO;
106 117551 : break;
107 2685305 : case 1:
108 2685305 : hStereoMdct->mdct_stereo_mode[k] = SMDCT_MS_FULL;
109 2685305 : break;
110 1384630 : case 2:
111 1384630 : hStereoMdct->mdct_stereo_mode[k] = SMDCT_BW_MS;
112 1384630 : break;
113 0 : default:
114 0 : assert( !"Not supported stereo mode\n" );
115 : }
116 :
117 4187486 : if ( !mct_on )
118 : {
119 1333376 : if ( sts[0]->core == sts[1]->core || k == 0 )
120 : {
121 1326802 : hStereoMdct->global_ild[k] = get_next_indice( st0, SMDCT_GLOBAL_ILD_BITS );
122 1326802 : assert( ( hStereoMdct->global_ild[k] > 0 ) && ( hStereoMdct->global_ild[k] < SMDCT_ILD_RANGE ) );
123 : }
124 : else
125 : {
126 6574 : hStereoMdct->global_ild[1] = hStereoMdct->global_ild[0];
127 : }
128 : }
129 :
130 4187486 : set_s( ms_mask[k], ( hStereoMdct->mdct_stereo_mode[k] == SMDCT_MS_FULL ) ? 1 : 0, sfbConf->nBandsStereoCore );
131 :
132 4187486 : if ( hStereoMdct->mdct_stereo_mode[k] == SMDCT_BW_MS )
133 : {
134 59268160 : for ( i = 0; i < sfbConf->nBandsStereoCore; i++ )
135 : {
136 57883530 : ms_mask[k][i] = get_next_indice( st0, 1 );
137 : }
138 : }
139 :
140 4187486 : if ( st0->igf )
141 : {
142 2523888 : mdct_stereo_mode = get_next_indice( st0, 1 );
143 2523888 : if ( mdct_stereo_mode )
144 : {
145 1585506 : mdct_stereo_mode = 1 + get_next_indice( st0, 1 );
146 : }
147 :
148 2523888 : switch ( mdct_stereo_mode )
149 : {
150 938382 : case 0:
151 938382 : hStereoMdct->IGFStereoMode[k] = SMDCT_DUAL_MONO;
152 938382 : break;
153 1110106 : case 1:
154 1110106 : hStereoMdct->IGFStereoMode[k] = SMDCT_MS_FULL;
155 1110106 : break;
156 475400 : case 2:
157 475400 : hStereoMdct->IGFStereoMode[k] = SMDCT_BW_MS;
158 475400 : break;
159 0 : default:
160 0 : assert( !"Not supported stereo mode\n" );
161 : }
162 :
163 2523888 : set_s( &ms_mask[k][sfbConf->nBandsStereoCore], ( hStereoMdct->IGFStereoMode[k] == SMDCT_MS_FULL ) ? 1 : 0, sfbConf->sfbCnt - sfbConf->nBandsStereoCore );
164 :
165 2523888 : if ( hStereoMdct->IGFStereoMode[k] == SMDCT_BW_MS )
166 : {
167 3237494 : for ( i = sfbConf->nBandsStereoCore; i < sfbConf->sfbCnt; i++ )
168 : {
169 2762094 : ms_mask[k][i] = get_next_indice( st0, 1 );
170 : }
171 : }
172 : }
173 : else
174 : {
175 1663598 : hStereoMdct->IGFStereoMode[k] = SMDCT_DUAL_MONO;
176 : }
177 : }
178 : }
179 :
180 5547214 : if ( !mct_on )
181 : {
182 2763279 : hStereoMdct->split_ratio = SMDCT_EQUAL_RATIO_RANGE; /* Equal bits to both channels */
183 2763279 : hStereoMdct->split_ratio = get_next_indice( st0, SMDCT_NBBITS_SPLIT_RATIO );
184 :
185 2763279 : assert( hStereoMdct->split_ratio > 0 );
186 : }
187 :
188 : #ifdef DEBUGGING
189 : {
190 : int16_t nBitsStereo = st0->next_bit_pos - nbits_start;
191 :
192 : assert( nBitsStereo <= st0->bits_frame_nominal );
193 : }
194 : #endif
195 :
196 5547214 : return;
197 : }
198 :
199 :
200 : /*-------------------------------------------------------------------*
201 : * stereo_decoder_tcx()
202 : *
203 : * apply stereo processing (inverse MS and global ILD)
204 : *-------------------------------------------------------------------*/
205 :
206 : #define NF_RED_FAC 0.75f
207 :
208 4194280 : void stereo_decoder_tcx(
209 : STEREO_MDCT_DEC_DATA *hStereoMdct, /* i/o: MDCT stereo decoder structure */
210 : int16_t ms_mask[NB_DIV][MAX_SFB], /* i : bandwise MS mask */
211 : float *spec_r_0[NB_DIV], /* i/o: spectrum right channel */
212 : float *spec_l[], /* i/o: spectrum left channel [NB_DIV][N] */
213 : float *spec_r[], /* i/o: spectrum right channel [NB_DIV][N] */
214 : const int16_t mdct_stereo_mode[], /* i : stereo mode (FB/band wise MS, dual mono */
215 : const int16_t core_l, /* i : core for left channel (TCX20/TCX10) */
216 : const int16_t core_r, /* i : core for right channel (TCX20/TCX10) */
217 : const int16_t igf, /* i : flag for IGF activity */
218 : const int16_t L_frameTCX_l, /* i : TCX frame length of left channel */
219 : const int16_t L_frameTCX_r, /* i : TCX frame length of right channel */
220 : const int16_t mct_on, /* i : flag mct block (1) or stereo (0) */
221 : const int16_t last_core_l, /* i : last core for left channel */
222 : const int16_t last_core_r, /* i : last core for right channel */
223 : const int16_t tmp_plc_upmix /* i : indicates temp upmix for PLC decision */
224 : )
225 : {
226 : int16_t i, k, sfb, nSubframes;
227 4194280 : STEREO_MDCT_BAND_PARAMETERS *sfbConf = NULL;
228 : float nrgRatio;
229 :
230 4194280 : nSubframes = 2;
231 4194280 : if ( ( core_l <= TCX_20_CORE && core_r <= TCX_20_CORE ) || tmp_plc_upmix )
232 : {
233 4077854 : nSubframes = 1;
234 : }
235 :
236 8504986 : for ( k = 0; k < nSubframes; k++ )
237 : {
238 4310706 : sfbConf = ( core_l == TCX_20_CORE ) ? &hStereoMdct->stbParamsTCX20 : &hStereoMdct->stbParamsTCX10;
239 :
240 4310706 : if ( last_core_l == ACELP_CORE || last_core_r == ACELP_CORE )
241 : {
242 12447 : sfbConf = &hStereoMdct->stbParamsTCX20afterACELP;
243 : }
244 :
245 4310706 : if ( mdct_stereo_mode[k] == SMDCT_MS_FULL )
246 : {
247 1325311299 : for ( i = 0; i < sfbConf->sfbOffset[sfbConf->nBandsStereoCore]; i++ )
248 : {
249 1322551448 : if ( spec_r_0[k][i] == 0.0f )
250 : {
251 450019333 : spec_r[k][i] *= NF_RED_FAC;
252 : }
253 : }
254 2759851 : inverseMS( sfbConf->sfbOffset[sfbConf->nBandsStereoCore], spec_l[k], spec_r[k], SQRT2_OVER_2 );
255 : }
256 1550855 : else if ( mdct_stereo_mode[k] == SMDCT_BW_MS )
257 : {
258 61423512 : for ( sfb = 0; sfb < sfbConf->nBandsStereoCore; sfb++ )
259 : {
260 59992234 : if ( ms_mask[k][sfb] )
261 : {
262 485864658 : for ( i = sfbConf->sfbOffset[sfb]; i < sfbConf->sfbOffset[sfb + 1]; i++ )
263 : {
264 449150636 : if ( spec_r_0[k][i] == 0.0f )
265 : {
266 123097367 : spec_r[k][i] *= NF_RED_FAC;
267 : }
268 : }
269 36714022 : inverseBwMS( sfbConf->sfbOffset[sfb], sfbConf->sfbOffset[sfb + 1], spec_l[k], spec_r[k], SQRT2_OVER_2 );
270 : }
271 : }
272 : }
273 : #ifdef DEBUGGING
274 : else if ( mdct_stereo_mode[k] != SMDCT_DUAL_MONO )
275 : {
276 : assert( !"Not supported MDCT stereo mode!\n" );
277 : }
278 : #endif
279 :
280 4310706 : if ( igf )
281 : {
282 2577647 : if ( hStereoMdct->IGFStereoMode[k] == SMDCT_MS_FULL )
283 : {
284 348869361 : for ( i = sfbConf->sfbOffset[sfbConf->nBandsStereoCore]; i < sfbConf->sfbOffset[sfbConf->sfbCnt]; i++ )
285 : {
286 347736240 : if ( spec_r_0[k][i] == 0.0f )
287 : {
288 107178717 : spec_r[k][i] *= NF_RED_FAC;
289 : }
290 : }
291 1133121 : inverseMS( sfbConf->sfbOffset[sfbConf->sfbCnt] - sfbConf->sfbOffset[sfbConf->nBandsStereoCore], &spec_l[k][sfbConf->sfbOffset[sfbConf->nBandsStereoCore]], &spec_r[k][sfbConf->sfbOffset[sfbConf->nBandsStereoCore]], SQRT2_OVER_2 );
292 : }
293 1444526 : else if ( hStereoMdct->IGFStereoMode[k] == SMDCT_BW_MS )
294 : {
295 3272472 : for ( sfb = sfbConf->nBandsStereoCore; sfb < sfbConf->sfbCnt; sfb++ )
296 : {
297 2792579 : if ( ms_mask[k][sfb] )
298 : {
299 69257509 : for ( i = sfbConf->sfbOffset[sfb]; i < sfbConf->sfbOffset[sfb + 1]; i++ )
300 : {
301 67793022 : if ( spec_r_0[k][i] == 0.0f )
302 : {
303 18815269 : spec_r[k][i] *= NF_RED_FAC;
304 : }
305 : }
306 1464487 : inverseBwMS( sfbConf->sfbOffset[sfb], sfbConf->sfbOffset[sfb + 1], spec_l[k], spec_r[k], SQRT2_OVER_2 );
307 : }
308 : }
309 : }
310 : #ifdef DEBUGGING
311 : else if ( hStereoMdct->IGFStereoMode[k] != SMDCT_DUAL_MONO )
312 : {
313 : assert( !"Not supported MDCT stereo mode!\n" );
314 : }
315 : #endif
316 : }
317 :
318 4310706 : if ( !mct_on )
319 : {
320 1456596 : nrgRatio = (float) SMDCT_ILD_RANGE / hStereoMdct->global_ild[k] - 1; /* nrgRatio = nrg[1]/nrg[0] */
321 1456596 : hStereoMdct->smooth_ratio = 0.8f * hStereoMdct->smooth_ratio + 0.2f * nrgRatio;
322 : /* set flag to reverse dmx computation in case of right-side panning, only relevant for mono output */
323 1456596 : if ( hStereoMdct->smooth_ratio > 1.3f )
324 : {
325 265666 : hStereoMdct->reverse_dmx = 1;
326 : }
327 1190930 : else if ( hStereoMdct->smooth_ratio < 0.9f )
328 : {
329 266367 : hStereoMdct->reverse_dmx = 0;
330 : }
331 :
332 1456596 : if ( ( nrgRatio > 1.0f ) && ( k < ( ( core_r == TCX_10_CORE ) ? NB_DIV : 1 ) ) )
333 : {
334 492767 : v_multc( spec_r[k], nrgRatio, spec_r[k], L_frameTCX_r );
335 : }
336 963829 : else if ( ( nrgRatio < 1.0f ) && ( k < ( ( core_l == TCX_10_CORE ) ? NB_DIV : 1 ) ) )
337 : {
338 312447 : v_multc( spec_l[k], 1.0f / nrgRatio, spec_l[k], L_frameTCX_l );
339 : }
340 : }
341 : } /* for k */
342 :
343 4194280 : return;
344 : }
345 :
346 :
347 : /*-------------------------------------------------------------------*
348 : * inverseBwMS()
349 : *
350 : * Band-wise M/S stereo processing
351 : *-------------------------------------------------------------------*/
352 :
353 43209515 : static void inverseBwMS(
354 : const int16_t startLine, /* i : start line of sfb */
355 : const int16_t stopLine, /* i : stop line of sfb */
356 : float x0[], /* i/o: mid/left channel coefficients */
357 : float x1[], /* i/o: side/right channel coefficients */
358 : const float norm_fac /* i : normalization factor */
359 : )
360 : {
361 : int16_t j;
362 : float tmpValue;
363 :
364 2248665763 : for ( j = startLine; j < stopLine; j++ )
365 : {
366 2205456248 : tmpValue = x0[j];
367 2205456248 : x0[j] = ( x0[j] + x1[j] ) * norm_fac;
368 2205456248 : x1[j] = ( tmpValue - x1[j] ) * norm_fac;
369 : }
370 :
371 43209515 : return;
372 : }
373 :
374 :
375 : /*-------------------------------------------------------------------*
376 : * inverseMS()
377 : *
378 : * M/S stereo processing
379 : *-------------------------------------------------------------------*/
380 :
381 5031006 : void inverseMS(
382 : const int16_t L_frame, /* i : frame length */
383 : float x0[], /* i/o: mid/left channel coefficients */
384 : float x1[], /* i/o: side/right channel coefficients */
385 : const float norm_fac /* i : normalization factor */
386 : )
387 : {
388 5031006 : inverseBwMS( 0, L_frame, x0, x1, norm_fac );
389 :
390 5031006 : return;
391 : }
392 :
393 :
394 : /*-------------------------------------------------------------------*
395 : * initMdctStereoDecData()
396 : *
397 : * Initialize MDCT stereo decoder configuration
398 : *-------------------------------------------------------------------*/
399 :
400 10921124 : void initMdctStereoDecData(
401 : STEREO_MDCT_DEC_DATA *hStereoMdct, /* i/o: mdct stereo parameters structure */
402 : const int16_t igf, /* i : flag indicating IGF activity */
403 : const H_IGF_GRID igfGrid, /* i : IGF grid configuration */
404 : const int32_t element_brate, /* i : element bitrate */
405 : const int16_t bwidth /* i : audio bandwidth */
406 : )
407 : {
408 : int16_t tcx_coded_lines;
409 :
410 10921124 : tcx_coded_lines = getNumTcxCodedLines( bwidth );
411 :
412 : /*Initialize sfb parameteres for TCX20 */
413 10921124 : stereo_mdct_init_bands( tcx_coded_lines, TCX_20_CORE, element_brate, igf, &igfGrid[IGF_GRID_LB_NORM], &hStereoMdct->stbParamsTCX20.sfbOffset[0], &hStereoMdct->stbParamsTCX20.sfbCnt );
414 :
415 : /*Initialize sfb parameteres for TCX10 */
416 10921124 : stereo_mdct_init_bands( tcx_coded_lines, TCX_10_CORE, element_brate, igf, &igfGrid[IGF_GRID_LB_SHORT], &hStereoMdct->stbParamsTCX10.sfbOffset[0], &hStereoMdct->stbParamsTCX10.sfbCnt );
417 :
418 : /*Initialize sfb parameteres for transition frames */
419 10921124 : stereo_mdct_init_bands( tcx_coded_lines, -1, element_brate, igf, &igfGrid[IGF_GRID_LB_TRAN], &hStereoMdct->stbParamsTCX20afterACELP.sfbOffset[0], &hStereoMdct->stbParamsTCX20afterACELP.sfbCnt );
420 :
421 10921124 : if ( igf )
422 : {
423 : /* calculate the igf start band from the igf start line */
424 4916134 : stereo_mdct_init_igf_start_band( &( hStereoMdct->stbParamsTCX20 ), 1.0f, bwidth, element_brate );
425 4916134 : stereo_mdct_init_igf_start_band( &( hStereoMdct->stbParamsTCX10 ), 0.5f, bwidth, element_brate );
426 4916134 : stereo_mdct_init_igf_start_band( &( hStereoMdct->stbParamsTCX20afterACELP ), 1.25f, bwidth, element_brate );
427 : }
428 : else
429 : {
430 6004990 : hStereoMdct->stbParamsTCX20.sfbIgfStart = -1;
431 6004990 : hStereoMdct->stbParamsTCX10.sfbIgfStart = -1;
432 6004990 : hStereoMdct->stbParamsTCX20afterACELP.sfbIgfStart = -1;
433 6004990 : hStereoMdct->stbParamsTCX10.nBandsStereoCore = hStereoMdct->stbParamsTCX10.sfbCnt;
434 6004990 : hStereoMdct->stbParamsTCX20.nBandsStereoCore = hStereoMdct->stbParamsTCX20.sfbCnt;
435 6004990 : hStereoMdct->stbParamsTCX20afterACELP.nBandsStereoCore = hStereoMdct->stbParamsTCX20afterACELP.sfbCnt;
436 : }
437 :
438 10921124 : return;
439 : }
440 :
441 :
442 : /*-------------------------------------------------------------------*
443 : * initMdctStereoDtxData()
444 : *
445 : * Allocate and initialize structures for MDCT-Stereo DTX operation
446 : *-------------------------------------------------------------------*/
447 :
448 215 : ivas_error initMdctStereoDtxData(
449 : CPE_DEC_HANDLE hCPE /* i/o: CPE handle */
450 : )
451 : {
452 : int16_t ch;
453 : ivas_error error;
454 :
455 215 : error = IVAS_ERR_OK;
456 :
457 645 : for ( ch = 0; ch < CPE_CHANNELS; ch++ )
458 : {
459 430 : DEC_CORE_HANDLE st = hCPE->hCoreCoder[ch];
460 :
461 430 : if ( st->hFdCngDec == NULL )
462 : {
463 : /* Create FD_CNG instance */
464 0 : if ( ( error = createFdCngDec( &st->hFdCngDec ) ) != IVAS_ERR_OK )
465 : {
466 0 : return error;
467 : }
468 :
469 : /* Init FD-CNG */
470 0 : initFdCngDec( st );
471 : }
472 :
473 430 : if ( st->first_CNG == 0 )
474 : {
475 406 : if ( ch == 1 && st->cng_sba_flag )
476 : {
477 134 : st->hFdCngDec->hFdCngCom->seed += 3;
478 : }
479 : }
480 :
481 430 : if ( st->cldfbAna == NULL )
482 : {
483 : /* open analysis for max. sampling rate 48kHz */
484 334 : if ( ( error = openCldfb( &st->cldfbAna, CLDFB_ANALYSIS, 48000, CLDFB_PROTOTYPE_1_25MS ) ) != IVAS_ERR_OK )
485 : {
486 0 : return error;
487 : }
488 : }
489 :
490 430 : if ( st->cldfbBPF == NULL )
491 : {
492 : /* open analysis BPF for max. internal sampling rate 16kHz */
493 334 : if ( ( error = openCldfb( &st->cldfbBPF, CLDFB_ANALYSIS, 16000, CLDFB_PROTOTYPE_1_25MS ) ) != IVAS_ERR_OK )
494 : {
495 0 : return error;
496 : }
497 : }
498 : }
499 :
500 215 : return error;
501 : }
502 :
503 : /*-------------------------------------------------------------------*
504 : * synchonize_channels_mdct_sid()
505 : *
506 : * Synchronize channels in SID frame in MDCT stereo
507 : *-------------------------------------------------------------------*/
508 :
509 32986423 : void synchonize_channels_mdct_sid(
510 : Decoder_State *sts[CPE_CHANNELS], /* i/o: decoder state structure */
511 : const int16_t n /* i : channel number */
512 : )
513 : {
514 : Decoder_State *st;
515 :
516 32986423 : st = sts[n];
517 :
518 32986423 : if ( st->element_mode == IVAS_CPE_MDCT && st->total_brate == SID_2k40 )
519 : {
520 6940 : if ( n == 1 )
521 : {
522 : /* synchronize channels */
523 3470 : sts[1]->L_frame = sts[0]->L_frame;
524 3470 : sts[1]->cng_type = sts[0]->cng_type;
525 3470 : sts[1]->bwidth = sts[0]->bwidth;
526 3470 : sts[0]->hFdCngDec->hFdCngCom->coherence = sts[1]->hFdCngDec->hFdCngCom->coherence; /* coherence is stored in sts[1] - see ivas_decision_matrix_dec() */
527 3470 : sts[0]->hFdCngDec->hFdCngCom->no_side_flag = sts[1]->hFdCngDec->hFdCngCom->no_side_flag;
528 :
529 : /* configure when there is a switching from DFT CNG to MDCT CNG */
530 3470 : if ( sts[0]->first_CNG == 1 && sts[1]->first_CNG == 0 )
531 : {
532 0 : configureFdCngDec( st->hFdCngDec, st->bwidth, st->element_brate, st->L_frame, st->last_L_frame, st->element_mode );
533 : }
534 : }
535 :
536 6940 : if ( sts[0]->first_CNG == 0 )
537 : {
538 : /* configure CNG after reading first side info from SID to get correct values for L_frame and bwidth if first SID is also first valid frame */
539 382 : configureFdCngDec( st->hFdCngDec, st->bwidth, st->element_brate, st->L_frame, st->last_L_frame, st->element_mode );
540 : }
541 : }
542 :
543 32986423 : return;
544 : }
545 :
546 :
547 : /*-------------------------------------------------------------------*
548 : * updateBuffersForDmxMdctStereo()
549 : *
550 : * synch buffers between channels for mono output and
551 : * apply passive downmix to certain buffers to enable smooth transitions
552 : * between active/inactive coding in MDCT-Stereo DTX
553 : *-------------------------------------------------------------------*/
554 :
555 6967 : void updateBuffersForDmxMdctStereo(
556 : CPE_DEC_HANDLE hCPE, /* i/o: CPE handle */
557 : const int16_t output_frame, /* i : output frame length */
558 : float *output[CPE_CHANNELS], /* i/o: decoder output */
559 : float synth[CPE_CHANNELS][L_FRAME48k] /* i/o: decoder synthesis */
560 : )
561 : {
562 : int16_t delay_buf_out_len, tcxltp_mem_in_len, delta, i;
563 : Decoder_State *sts[CPE_CHANNELS];
564 :
565 6967 : sts[0] = hCPE->hCoreCoder[0];
566 6967 : sts[1] = hCPE->hCoreCoder[1];
567 :
568 : /* synch buffers for inactive frames, but not for transition frames */
569 6967 : if ( hCPE->last_element_brate <= IVAS_SID_5k2 )
570 : {
571 6711 : mvr2r( output[0], output[1], output_frame );
572 6711 : mvr2r( synth[0], synth[1], output_frame );
573 : }
574 :
575 6967 : if ( hCPE->element_brate == IVAS_SID_5k2 && hCPE->last_element_brate > IVAS_SID_5k2 )
576 : {
577 : /* in the first SID frame after an active frame, create mid noise shape here, in SID frames that follow inactive frames, it is done directly in the SID decoding since the mid shape is being used in CNG then */
578 6214 : for ( int16_t p = 0; p < sts[0]->hFdCngDec->hFdCngCom->npart; p++ )
579 : {
580 5958 : sts[0]->hFdCngDec->hFdCngCom->sidNoiseEst[p] = 0.5f * ( sts[0]->hFdCngDec->hFdCngCom->sidNoiseEst[p] + sts[1]->hFdCngDec->hFdCngCom->sidNoiseEst[p] );
581 : }
582 : }
583 :
584 : /* for transition of active->inactive frame, apply passive downmix on buffers */
585 6967 : if ( hCPE->last_element_brate <= IVAS_SID_5k2 )
586 : {
587 6711 : delta = 1;
588 6711 : if ( output_frame == L_FRAME16k )
589 : {
590 1930 : delta = 2;
591 : }
592 4781 : else if ( output_frame == L_FRAME32k )
593 : {
594 1997 : delta = 4;
595 : }
596 2784 : else if ( output_frame == L_FRAME48k )
597 : {
598 2784 : delta = 6;
599 : }
600 :
601 6711 : delay_buf_out_len = delta * HQ_DELAY_COMP;
602 6711 : tcxltp_mem_in_len = NS2SA( sts[0]->output_Fs, TCXLTP_DELAY_NS );
603 :
604 6711 : assert( delay_buf_out_len > tcxltp_mem_in_len );
605 :
606 63815 : for ( i = 0; i < tcxltp_mem_in_len; i++ )
607 : {
608 57104 : sts[0]->hTcxLtpDec->tcxltp_mem_in[i] = INV_SQRT2 * ( sts[0]->hTcxLtpDec->tcxltp_mem_in[i] + sts[1]->hTcxLtpDec->tcxltp_mem_in[i] );
609 57104 : sts[0]->delay_buf_out[i] = INV_SQRT2 * ( sts[0]->delay_buf_out[i] + sts[1]->delay_buf_out[i] );
610 57104 : sts[0]->hHQ_core->old_out[i] = INV_SQRT2 * ( sts[0]->hHQ_core->old_out[i] + sts[1]->hHQ_core->old_out[i] );
611 57104 : sts[0]->hTcxLtpDec->tcxltp_mem_out[i] = INV_SQRT2 * ( sts[0]->hTcxLtpDec->tcxltp_mem_out[i] + sts[1]->hTcxLtpDec->tcxltp_mem_out[i] );
612 : }
613 235127 : for ( ; i < delay_buf_out_len; i++ )
614 : {
615 228416 : sts[0]->delay_buf_out[i] = INV_SQRT2 * ( sts[0]->delay_buf_out[i] + sts[1]->delay_buf_out[i] );
616 228416 : sts[0]->hHQ_core->old_out[i] = INV_SQRT2 * ( sts[0]->hHQ_core->old_out[i] + sts[1]->hHQ_core->old_out[i] );
617 228416 : sts[0]->hTcxLtpDec->tcxltp_mem_out[i] = INV_SQRT2 * ( sts[0]->hTcxLtpDec->tcxltp_mem_out[i] + sts[1]->hTcxLtpDec->tcxltp_mem_out[i] );
618 : }
619 4289511 : for ( ; i < output_frame; i++ )
620 : {
621 4282800 : sts[0]->hHQ_core->old_out[i] = INV_SQRT2 * ( sts[0]->hHQ_core->old_out[i] + sts[1]->hHQ_core->old_out[i] );
622 4282800 : sts[0]->hTcxLtpDec->tcxltp_mem_out[i] = INV_SQRT2 * ( sts[0]->hTcxLtpDec->tcxltp_mem_out[i] + sts[1]->hTcxLtpDec->tcxltp_mem_out[i] );
623 : }
624 : }
625 :
626 6967 : return;
627 : }
628 :
629 :
630 : /*-------------------------------------------------------------------*
631 : * applyDmxMdctStereo()
632 : *
633 : * apply passive downmix to certain buffers to enable smooth transitions
634 : * between active/inactive coding in MDCT-Stereo DTX
635 : *-------------------------------------------------------------------*/
636 :
637 110624 : void applyDmxMdctStereo(
638 : const CPE_DEC_HANDLE hCPE, /* i : CPE handle */
639 : float *output[CPE_CHANNELS], /* i/o: core decoder output */
640 : const int16_t output_frame /* i : output frame length */
641 : )
642 : {
643 : int16_t crossfade_len, i;
644 : int16_t dmx_len;
645 : float fade, step;
646 :
647 110624 : step = 1.f;
648 110624 : fade = 1.f;
649 110624 : dmx_len = output_frame;
650 :
651 110624 : if ( hCPE->last_element_brate <= IVAS_SID_5k2 )
652 : {
653 243 : crossfade_len = NS2SA( hCPE->hCoreCoder[0]->output_Fs, IVAS_DEC_DELAY_NS - DELAY_CLDFB_NS );
654 243 : step /= crossfade_len;
655 : }
656 : /* for first inactive CNG frame after active decoding we have to do a fade-OUT FROM the passive DMX */
657 110381 : else if ( hCPE->element_brate <= IVAS_SID_5k2 && hCPE->last_element_brate > IVAS_SID_5k2 )
658 : {
659 256 : crossfade_len = output_frame / 4;
660 256 : step /= -crossfade_len;
661 256 : fade = 0.f;
662 256 : dmx_len = crossfade_len;
663 : }
664 110125 : else if ( hCPE->last_element_mode == IVAS_CPE_DFT && hCPE->last_element_brate <= IVAS_32k )
665 : {
666 236 : crossfade_len = NS2SA( hCPE->hCoreCoder[0]->output_Fs, DELAY_CLDFB_NS );
667 236 : step /= crossfade_len;
668 : }
669 : else
670 : {
671 109889 : crossfade_len = 0;
672 : }
673 :
674 : /* apply crossfade */
675 187488 : for ( i = 0; i < crossfade_len; i++ )
676 : {
677 76864 : output[0][i] = output[0][i] * fade + ( output[0][i] + output[1][i] ) * INV_SQRT2 * ( 1 - fade );
678 76864 : fade -= step;
679 : }
680 :
681 : /* apply passive downmix on all-active-frame part */
682 82050400 : for ( ; i < dmx_len; i++ )
683 : {
684 81939776 : output[0][i] = ( output[0][i] + output[1][i] ) * INV_SQRT_2;
685 : }
686 :
687 110624 : return;
688 : }
|
