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 514683 : 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 514683 : if ( !isSBAStereoMode )
72 : {
73 400614 : nSubframes = ( sts[0]->core == TCX_10_CORE || ( sts[0]->core != sts[1]->core ) ) ? NB_DIV : 1;
74 400614 : sfbConf = ( sts[0]->core == TCX_20_CORE ) ? &hStereoMdct->stbParamsTCX20 : &hStereoMdct->stbParamsTCX10;
75 400614 : if ( sts[0]->last_core_from_bs == ACELP_CORE )
76 : {
77 1905 : sfbConf = &hStereoMdct->stbParamsTCX20afterACELP;
78 : }
79 :
80 400614 : if ( hStereoMdct->use_itd )
81 : {
82 : int16_t I;
83 :
84 34356 : 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 34356 : hStereoMdct->itd = 0.f;
88 34356 : if ( hStereoMdct->itd_mode )
89 : {
90 10305 : /*(*nb_bits) += */ read_itd( st0, &I );
91 10305 : stereo_dft_dequantize_itd( &I, &hStereoMdct->itd, st0->output_Fs );
92 : }
93 : }
94 :
95 811326 : for ( k = 0; k < nSubframes; k++ )
96 : {
97 410712 : mdct_stereo_mode = get_next_indice( st0, 1 );
98 410712 : if ( mdct_stereo_mode )
99 : {
100 399576 : mdct_stereo_mode = 1 + get_next_indice( st0, 1 );
101 : }
102 410712 : switch ( mdct_stereo_mode )
103 : {
104 11136 : case 0:
105 11136 : hStereoMdct->mdct_stereo_mode[k] = SMDCT_DUAL_MONO;
106 11136 : break;
107 247776 : case 1:
108 247776 : hStereoMdct->mdct_stereo_mode[k] = SMDCT_MS_FULL;
109 247776 : break;
110 151800 : case 2:
111 151800 : hStereoMdct->mdct_stereo_mode[k] = SMDCT_BW_MS;
112 151800 : break;
113 0 : default:
114 0 : assert( !"Not supported stereo mode\n" );
115 : }
116 :
117 410712 : if ( !mct_on )
118 : {
119 130233 : if ( sts[0]->core == sts[1]->core || k == 0 )
120 : {
121 129453 : hStereoMdct->global_ild[k] = get_next_indice( st0, SMDCT_GLOBAL_ILD_BITS );
122 129453 : assert( ( hStereoMdct->global_ild[k] > 0 ) && ( hStereoMdct->global_ild[k] < SMDCT_ILD_RANGE ) );
123 : }
124 : else
125 : {
126 780 : hStereoMdct->global_ild[1] = hStereoMdct->global_ild[0];
127 : }
128 : }
129 :
130 410712 : set_s( ms_mask[k], ( hStereoMdct->mdct_stereo_mode[k] == SMDCT_MS_FULL ) ? 1 : 0, sfbConf->nBandsStereoCore );
131 :
132 410712 : if ( hStereoMdct->mdct_stereo_mode[k] == SMDCT_BW_MS )
133 : {
134 6311316 : for ( i = 0; i < sfbConf->nBandsStereoCore; i++ )
135 : {
136 6159516 : ms_mask[k][i] = get_next_indice( st0, 1 );
137 : }
138 : }
139 :
140 410712 : if ( st0->igf )
141 : {
142 274353 : mdct_stereo_mode = get_next_indice( st0, 1 );
143 274353 : if ( mdct_stereo_mode )
144 : {
145 163284 : mdct_stereo_mode = 1 + get_next_indice( st0, 1 );
146 : }
147 :
148 274353 : switch ( mdct_stereo_mode )
149 : {
150 111069 : case 0:
151 111069 : hStereoMdct->IGFStereoMode[k] = SMDCT_DUAL_MONO;
152 111069 : break;
153 120765 : case 1:
154 120765 : hStereoMdct->IGFStereoMode[k] = SMDCT_MS_FULL;
155 120765 : break;
156 42519 : case 2:
157 42519 : hStereoMdct->IGFStereoMode[k] = SMDCT_BW_MS;
158 42519 : break;
159 0 : default:
160 0 : assert( !"Not supported stereo mode\n" );
161 : }
162 :
163 274353 : set_s( &ms_mask[k][sfbConf->nBandsStereoCore], ( hStereoMdct->IGFStereoMode[k] == SMDCT_MS_FULL ) ? 1 : 0, sfbConf->sfbCnt - sfbConf->nBandsStereoCore );
164 :
165 274353 : if ( hStereoMdct->IGFStereoMode[k] == SMDCT_BW_MS )
166 : {
167 268530 : for ( i = sfbConf->nBandsStereoCore; i < sfbConf->sfbCnt; i++ )
168 : {
169 226011 : ms_mask[k][i] = get_next_indice( st0, 1 );
170 : }
171 : }
172 : }
173 : else
174 : {
175 136359 : hStereoMdct->IGFStereoMode[k] = SMDCT_DUAL_MONO;
176 : }
177 : }
178 : }
179 :
180 514683 : if ( !mct_on )
181 : {
182 240156 : hStereoMdct->split_ratio = SMDCT_EQUAL_RATIO_RANGE; /* Equal bits to both channels */
183 240156 : hStereoMdct->split_ratio = get_next_indice( st0, SMDCT_NBBITS_SPLIT_RATIO );
184 :
185 240156 : 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 514683 : 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 404541 : 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 404541 : STEREO_MDCT_BAND_PARAMETERS *sfbConf = NULL;
228 : float nrgRatio;
229 :
230 404541 : nSubframes = 2;
231 404541 : if ( ( core_l <= TCX_20_CORE && core_r <= TCX_20_CORE ) || tmp_plc_upmix )
232 : {
233 394389 : nSubframes = 1;
234 : }
235 :
236 819234 : for ( k = 0; k < nSubframes; k++ )
237 : {
238 414693 : sfbConf = ( core_l == TCX_20_CORE ) ? &hStereoMdct->stbParamsTCX20 : &hStereoMdct->stbParamsTCX10;
239 :
240 414693 : if ( last_core_l == ACELP_CORE || last_core_r == ACELP_CORE )
241 : {
242 1950 : sfbConf = &hStereoMdct->stbParamsTCX20afterACELP;
243 : }
244 :
245 414693 : if ( mdct_stereo_mode[k] == SMDCT_MS_FULL )
246 : {
247 136515432 : for ( i = 0; i < sfbConf->sfbOffset[sfbConf->nBandsStereoCore]; i++ )
248 : {
249 136265424 : if ( spec_r_0[k][i] == 0.0f )
250 : {
251 37586586 : spec_r[k][i] *= NF_RED_FAC;
252 : }
253 : }
254 250008 : inverseMS( sfbConf->sfbOffset[sfbConf->nBandsStereoCore], spec_l[k], spec_r[k], SQRT2_OVER_2 );
255 : }
256 164685 : else if ( mdct_stereo_mode[k] == SMDCT_BW_MS )
257 : {
258 6370920 : for ( sfb = 0; sfb < sfbConf->nBandsStereoCore; sfb++ )
259 : {
260 6217587 : if ( ms_mask[k][sfb] )
261 : {
262 53901393 : for ( i = sfbConf->sfbOffset[sfb]; i < sfbConf->sfbOffset[sfb + 1]; i++ )
263 : {
264 50139252 : if ( spec_r_0[k][i] == 0.0f )
265 : {
266 13920909 : spec_r[k][i] *= NF_RED_FAC;
267 : }
268 : }
269 3762141 : 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 414693 : if ( igf )
281 : {
282 276330 : if ( hStereoMdct->IGFStereoMode[k] == SMDCT_MS_FULL )
283 : {
284 36835335 : for ( i = sfbConf->sfbOffset[sfbConf->nBandsStereoCore]; i < sfbConf->sfbOffset[sfbConf->sfbCnt]; i++ )
285 : {
286 36714102 : if ( spec_r_0[k][i] == 0.0f )
287 : {
288 11419020 : spec_r[k][i] *= NF_RED_FAC;
289 : }
290 : }
291 121233 : 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 155097 : else if ( hStereoMdct->IGFStereoMode[k] == SMDCT_BW_MS )
294 : {
295 270174 : for ( sfb = sfbConf->nBandsStereoCore; sfb < sfbConf->sfbCnt; sfb++ )
296 : {
297 227436 : if ( ms_mask[k][sfb] )
298 : {
299 5987883 : for ( i = sfbConf->sfbOffset[sfb]; i < sfbConf->sfbOffset[sfb + 1]; i++ )
300 : {
301 5867610 : if ( spec_r_0[k][i] == 0.0f )
302 : {
303 2055699 : spec_r[k][i] *= NF_RED_FAC;
304 : }
305 : }
306 120273 : 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 414693 : if ( !mct_on )
319 : {
320 134214 : nrgRatio = (float) SMDCT_ILD_RANGE / hStereoMdct->global_ild[k] - 1; /* nrgRatio = nrg[1]/nrg[0] */
321 134214 : 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 134214 : if ( hStereoMdct->smooth_ratio > 1.3f )
324 : {
325 49797 : hStereoMdct->reverse_dmx = 1;
326 : }
327 84417 : else if ( hStereoMdct->smooth_ratio < 0.9f )
328 : {
329 24813 : hStereoMdct->reverse_dmx = 0;
330 : }
331 :
332 134214 : if ( ( nrgRatio > 1.0f ) && ( k < ( ( core_r == TCX_10_CORE ) ? NB_DIV : 1 ) ) )
333 : {
334 65103 : v_multc( spec_r[k], nrgRatio, spec_r[k], L_frameTCX_r );
335 : }
336 69111 : else if ( ( nrgRatio < 1.0f ) && ( k < ( ( core_l == TCX_10_CORE ) ? NB_DIV : 1 ) ) )
337 : {
338 28983 : v_multc( spec_l[k], 1.0f / nrgRatio, spec_l[k], L_frameTCX_l );
339 : }
340 : }
341 : } /* for k */
342 :
343 404541 : return;
344 : }
345 :
346 :
347 : /*-------------------------------------------------------------------*
348 : * inverseBwMS()
349 : *
350 : * Band-wise M/S stereo processing
351 : *-------------------------------------------------------------------*/
352 :
353 4386999 : 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 235515066 : for ( j = startLine; j < stopLine; j++ )
365 : {
366 231128067 : tmpValue = x0[j];
367 231128067 : x0[j] = ( x0[j] + x1[j] ) * norm_fac;
368 231128067 : x1[j] = ( tmpValue - x1[j] ) * norm_fac;
369 : }
370 :
371 4386999 : return;
372 : }
373 :
374 :
375 : /*-------------------------------------------------------------------*
376 : * inverseMS()
377 : *
378 : * M/S stereo processing
379 : *-------------------------------------------------------------------*/
380 :
381 504585 : 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 504585 : inverseBwMS( 0, L_frame, x0, x1, norm_fac );
389 :
390 504585 : return;
391 : }
392 :
393 :
394 : /*-------------------------------------------------------------------*
395 : * initMdctStereoDecData()
396 : *
397 : * Initialize MDCT stereo decoder configuration
398 : *-------------------------------------------------------------------*/
399 :
400 893454 : 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 893454 : tcx_coded_lines = getNumTcxCodedLines( bwidth );
411 :
412 : /*Initialize sfb parameteres for TCX20 */
413 893454 : 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 893454 : 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 893454 : 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 893454 : if ( igf )
422 : {
423 : /* calculate the igf start band from the igf start line */
424 503115 : stereo_mdct_init_igf_start_band( &( hStereoMdct->stbParamsTCX20 ), 1.0f, bwidth, element_brate );
425 503115 : stereo_mdct_init_igf_start_band( &( hStereoMdct->stbParamsTCX10 ), 0.5f, bwidth, element_brate );
426 503115 : stereo_mdct_init_igf_start_band( &( hStereoMdct->stbParamsTCX20afterACELP ), 1.25f, bwidth, element_brate );
427 : }
428 : else
429 : {
430 390339 : hStereoMdct->stbParamsTCX20.sfbIgfStart = -1;
431 390339 : hStereoMdct->stbParamsTCX10.sfbIgfStart = -1;
432 390339 : hStereoMdct->stbParamsTCX20afterACELP.sfbIgfStart = -1;
433 390339 : hStereoMdct->stbParamsTCX10.nBandsStereoCore = hStereoMdct->stbParamsTCX10.sfbCnt;
434 390339 : hStereoMdct->stbParamsTCX20.nBandsStereoCore = hStereoMdct->stbParamsTCX20.sfbCnt;
435 390339 : hStereoMdct->stbParamsTCX20afterACELP.nBandsStereoCore = hStereoMdct->stbParamsTCX20afterACELP.sfbCnt;
436 : }
437 :
438 893454 : return;
439 : }
440 :
441 :
442 : /*-------------------------------------------------------------------*
443 : * initMdctStereoDtxData()
444 : *
445 : * Allocate and initialize structures for MDCT-Stereo DTX operation
446 : *-------------------------------------------------------------------*/
447 :
448 108 : ivas_error initMdctStereoDtxData(
449 : CPE_DEC_HANDLE hCPE /* i/o: CPE handle */
450 : )
451 : {
452 : int16_t ch;
453 : ivas_error error;
454 :
455 108 : error = IVAS_ERR_OK;
456 :
457 324 : for ( ch = 0; ch < CPE_CHANNELS; ch++ )
458 : {
459 216 : DEC_CORE_HANDLE st = hCPE->hCoreCoder[ch];
460 :
461 216 : 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 216 : if ( st->first_CNG == 0 )
474 : {
475 198 : if ( ch == 1 && st->cng_sba_flag )
476 : {
477 54 : st->hFdCngDec->hFdCngCom->seed += 3;
478 : }
479 : }
480 :
481 216 : if ( st->cldfbAna == NULL )
482 : {
483 : /* open analysis for max. sampling rate 48kHz */
484 174 : if ( ( error = openCldfb( &st->cldfbAna, CLDFB_ANALYSIS, 48000, CLDFB_PROTOTYPE_1_25MS ) ) != IVAS_ERR_OK )
485 : {
486 0 : return error;
487 : }
488 : }
489 :
490 216 : if ( st->cldfbBPF == NULL )
491 : {
492 : /* open analysis BPF for max. internal sampling rate 16kHz */
493 174 : 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 108 : return error;
501 : }
502 :
503 : /*-------------------------------------------------------------------*
504 : * synchonize_channels_mdct_sid()
505 : *
506 : * Synchronize channels in SID frame in MDCT stereo
507 : *-------------------------------------------------------------------*/
508 :
509 3335415 : 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 3335415 : st = sts[n];
517 :
518 3335415 : if ( st->element_mode == IVAS_CPE_MDCT && st->total_brate == SID_2k40 )
519 : {
520 3408 : if ( n == 1 )
521 : {
522 : /* synchronize channels */
523 1704 : sts[1]->L_frame = sts[0]->L_frame;
524 1704 : sts[1]->cng_type = sts[0]->cng_type;
525 1704 : sts[1]->bwidth = sts[0]->bwidth;
526 1704 : sts[0]->hFdCngDec->hFdCngCom->coherence = sts[1]->hFdCngDec->hFdCngCom->coherence; /* coherence is stored in sts[1] - see ivas_decision_matrix_dec() */
527 1704 : 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 1704 : 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 3408 : 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 180 : configureFdCngDec( st->hFdCngDec, st->bwidth, st->element_brate, st->L_frame, st->last_L_frame, st->element_mode );
540 : }
541 : }
542 :
543 3335415 : 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 3357 : 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 3357 : sts[0] = hCPE->hCoreCoder[0];
566 3357 : sts[1] = hCPE->hCoreCoder[1];
567 :
568 : /* synch buffers for inactive frames, but not for transition frames */
569 3357 : if ( hCPE->last_element_brate <= IVAS_SID_5k2 )
570 : {
571 3240 : mvr2r( output[0], output[1], output_frame );
572 3240 : mvr2r( synth[0], synth[1], output_frame );
573 : }
574 :
575 3357 : 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 2844 : for ( int16_t p = 0; p < sts[0]->hFdCngDec->hFdCngCom->npart; p++ )
579 : {
580 2727 : 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 3357 : if ( hCPE->last_element_brate <= IVAS_SID_5k2 )
586 : {
587 3240 : delta = 1;
588 3240 : if ( output_frame == L_FRAME16k )
589 : {
590 1044 : delta = 2;
591 : }
592 2196 : else if ( output_frame == L_FRAME32k )
593 : {
594 1074 : delta = 4;
595 : }
596 1122 : else if ( output_frame == L_FRAME48k )
597 : {
598 1122 : delta = 6;
599 : }
600 :
601 3240 : delay_buf_out_len = delta * HQ_DELAY_COMP;
602 3240 : tcxltp_mem_in_len = NS2SA( sts[0]->output_Fs, TCXLTP_DELAY_NS );
603 :
604 3240 : assert( delay_buf_out_len > tcxltp_mem_in_len );
605 :
606 29472 : for ( i = 0; i < tcxltp_mem_in_len; i++ )
607 : {
608 26232 : sts[0]->hTcxLtpDec->tcxltp_mem_in[i] = INV_SQRT2 * ( sts[0]->hTcxLtpDec->tcxltp_mem_in[i] + sts[1]->hTcxLtpDec->tcxltp_mem_in[i] );
609 26232 : sts[0]->delay_buf_out[i] = INV_SQRT2 * ( sts[0]->delay_buf_out[i] + sts[1]->delay_buf_out[i] );
610 26232 : sts[0]->hHQ_core->old_out[i] = INV_SQRT2 * ( sts[0]->hHQ_core->old_out[i] + sts[1]->hHQ_core->old_out[i] );
611 26232 : 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 108168 : for ( ; i < delay_buf_out_len; i++ )
614 : {
615 104928 : sts[0]->delay_buf_out[i] = INV_SQRT2 * ( sts[0]->delay_buf_out[i] + sts[1]->delay_buf_out[i] );
616 104928 : sts[0]->hHQ_core->old_out[i] = INV_SQRT2 * ( sts[0]->hHQ_core->old_out[i] + sts[1]->hHQ_core->old_out[i] );
617 104928 : 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 1970640 : for ( ; i < output_frame; i++ )
620 : {
621 1967400 : sts[0]->hHQ_core->old_out[i] = INV_SQRT2 * ( sts[0]->hHQ_core->old_out[i] + sts[1]->hHQ_core->old_out[i] );
622 1967400 : 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 3357 : 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 17754 : 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 17754 : step = 1.f;
648 17754 : fade = 1.f;
649 17754 : dmx_len = output_frame;
650 :
651 17754 : if ( hCPE->last_element_brate <= IVAS_SID_5k2 )
652 : {
653 105 : crossfade_len = NS2SA( hCPE->hCoreCoder[0]->output_Fs, IVAS_DEC_DELAY_NS - DELAY_CLDFB_NS );
654 105 : 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 17649 : else if ( hCPE->element_brate <= IVAS_SID_5k2 && hCPE->last_element_brate > IVAS_SID_5k2 )
658 : {
659 117 : crossfade_len = output_frame / 4;
660 117 : step /= -crossfade_len;
661 117 : fade = 0.f;
662 117 : dmx_len = crossfade_len;
663 : }
664 17532 : else if ( hCPE->last_element_mode == IVAS_CPE_DFT && hCPE->last_element_brate <= IVAS_32k )
665 : {
666 45 : crossfade_len = NS2SA( hCPE->hCoreCoder[0]->output_Fs, DELAY_CLDFB_NS );
667 45 : step /= crossfade_len;
668 : }
669 : else
670 : {
671 17487 : crossfade_len = 0;
672 : }
673 :
674 : /* apply crossfade */
675 48486 : for ( i = 0; i < crossfade_len; i++ )
676 : {
677 30732 : output[0][i] = output[0][i] * fade + ( output[0][i] + output[1][i] ) * INV_SQRT2 * ( 1 - fade );
678 30732 : fade -= step;
679 : }
680 :
681 : /* apply passive downmix on all-active-frame part */
682 13806702 : for ( ; i < dmx_len; i++ )
683 : {
684 13788948 : output[0][i] = ( output[0][i] + output[1][i] ) * INV_SQRT_2;
685 : }
686 :
687 17754 : return;
688 : }
|
