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 513111 : 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 513111 : if ( !isSBAStereoMode )
72 : {
73 399042 : nSubframes = ( sts[0]->core == TCX_10_CORE || ( sts[0]->core != sts[1]->core ) ) ? NB_DIV : 1;
74 399042 : sfbConf = ( sts[0]->core == TCX_20_CORE ) ? &hStereoMdct->stbParamsTCX20 : &hStereoMdct->stbParamsTCX10;
75 399042 : if ( sts[0]->last_core_from_bs == ACELP_CORE )
76 : {
77 1905 : sfbConf = &hStereoMdct->stbParamsTCX20afterACELP;
78 : }
79 :
80 399042 : 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 808164 : for ( k = 0; k < nSubframes; k++ )
96 : {
97 409122 : mdct_stereo_mode = get_next_indice( st0, 1 );
98 409122 : if ( mdct_stereo_mode )
99 : {
100 397986 : mdct_stereo_mode = 1 + get_next_indice( st0, 1 );
101 : }
102 409122 : switch ( mdct_stereo_mode )
103 : {
104 11136 : case 0:
105 11136 : hStereoMdct->mdct_stereo_mode[k] = SMDCT_DUAL_MONO;
106 11136 : break;
107 247452 : case 1:
108 247452 : hStereoMdct->mdct_stereo_mode[k] = SMDCT_MS_FULL;
109 247452 : break;
110 150534 : case 2:
111 150534 : hStereoMdct->mdct_stereo_mode[k] = SMDCT_BW_MS;
112 150534 : break;
113 0 : default:
114 0 : assert( !"Not supported stereo mode\n" );
115 : }
116 :
117 409122 : 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 409122 : set_s( ms_mask[k], ( hStereoMdct->mdct_stereo_mode[k] == SMDCT_MS_FULL ) ? 1 : 0, sfbConf->nBandsStereoCore );
131 :
132 409122 : if ( hStereoMdct->mdct_stereo_mode[k] == SMDCT_BW_MS )
133 : {
134 6262158 : for ( i = 0; i < sfbConf->nBandsStereoCore; i++ )
135 : {
136 6111624 : ms_mask[k][i] = get_next_indice( st0, 1 );
137 : }
138 : }
139 :
140 409122 : if ( st0->igf )
141 : {
142 272763 : mdct_stereo_mode = get_next_indice( st0, 1 );
143 272763 : if ( mdct_stereo_mode )
144 : {
145 163014 : mdct_stereo_mode = 1 + get_next_indice( st0, 1 );
146 : }
147 :
148 272763 : switch ( mdct_stereo_mode )
149 : {
150 109749 : case 0:
151 109749 : hStereoMdct->IGFStereoMode[k] = SMDCT_DUAL_MONO;
152 109749 : break;
153 120672 : case 1:
154 120672 : hStereoMdct->IGFStereoMode[k] = SMDCT_MS_FULL;
155 120672 : break;
156 42342 : case 2:
157 42342 : hStereoMdct->IGFStereoMode[k] = SMDCT_BW_MS;
158 42342 : break;
159 0 : default:
160 0 : assert( !"Not supported stereo mode\n" );
161 : }
162 :
163 272763 : set_s( &ms_mask[k][sfbConf->nBandsStereoCore], ( hStereoMdct->IGFStereoMode[k] == SMDCT_MS_FULL ) ? 1 : 0, sfbConf->sfbCnt - sfbConf->nBandsStereoCore );
164 :
165 272763 : if ( hStereoMdct->IGFStereoMode[k] == SMDCT_BW_MS )
166 : {
167 267468 : for ( i = sfbConf->nBandsStereoCore; i < sfbConf->sfbCnt; i++ )
168 : {
169 225126 : 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 513111 : 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 513111 : 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 402969 : 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 402969 : STEREO_MDCT_BAND_PARAMETERS *sfbConf = NULL;
228 : float nrgRatio;
229 :
230 402969 : nSubframes = 2;
231 402969 : if ( ( core_l <= TCX_20_CORE && core_r <= TCX_20_CORE ) || tmp_plc_upmix )
232 : {
233 392835 : nSubframes = 1;
234 : }
235 :
236 816072 : for ( k = 0; k < nSubframes; k++ )
237 : {
238 413103 : sfbConf = ( core_l == TCX_20_CORE ) ? &hStereoMdct->stbParamsTCX20 : &hStereoMdct->stbParamsTCX10;
239 :
240 413103 : if ( last_core_l == ACELP_CORE || last_core_r == ACELP_CORE )
241 : {
242 1950 : sfbConf = &hStereoMdct->stbParamsTCX20afterACELP;
243 : }
244 :
245 413103 : if ( mdct_stereo_mode[k] == SMDCT_MS_FULL )
246 : {
247 136353828 : for ( i = 0; i < sfbConf->sfbOffset[sfbConf->nBandsStereoCore]; i++ )
248 : {
249 136104144 : if ( spec_r_0[k][i] == 0.0f )
250 : {
251 37575150 : spec_r[k][i] *= NF_RED_FAC;
252 : }
253 : }
254 249684 : inverseMS( sfbConf->sfbOffset[sfbConf->nBandsStereoCore], spec_l[k], spec_r[k], SQRT2_OVER_2 );
255 : }
256 163419 : else if ( mdct_stereo_mode[k] == SMDCT_BW_MS )
257 : {
258 6321762 : for ( sfb = 0; sfb < sfbConf->nBandsStereoCore; sfb++ )
259 : {
260 6169695 : if ( ms_mask[k][sfb] )
261 : {
262 53513463 : for ( i = sfbConf->sfbOffset[sfb]; i < sfbConf->sfbOffset[sfb + 1]; i++ )
263 : {
264 49779738 : if ( spec_r_0[k][i] == 0.0f )
265 : {
266 13892502 : spec_r[k][i] *= NF_RED_FAC;
267 : }
268 : }
269 3733725 : 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 413103 : if ( igf )
281 : {
282 274740 : if ( hStereoMdct->IGFStereoMode[k] == SMDCT_MS_FULL )
283 : {
284 36809754 : for ( i = sfbConf->sfbOffset[sfbConf->nBandsStereoCore]; i < sfbConf->sfbOffset[sfbConf->sfbCnt]; i++ )
285 : {
286 36688614 : if ( spec_r_0[k][i] == 0.0f )
287 : {
288 11418693 : spec_r[k][i] *= NF_RED_FAC;
289 : }
290 : }
291 121140 : 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 153600 : else if ( hStereoMdct->IGFStereoMode[k] == SMDCT_BW_MS )
294 : {
295 269112 : for ( sfb = sfbConf->nBandsStereoCore; sfb < sfbConf->sfbCnt; sfb++ )
296 : {
297 226551 : if ( ms_mask[k][sfb] )
298 : {
299 5968803 : for ( i = sfbConf->sfbOffset[sfb]; i < sfbConf->sfbOffset[sfb + 1]; i++ )
300 : {
301 5848950 : if ( spec_r_0[k][i] == 0.0f )
302 : {
303 2055699 : spec_r[k][i] *= NF_RED_FAC;
304 : }
305 : }
306 119853 : 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 413103 : 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 402969 : return;
344 : }
345 :
346 :
347 : /*-------------------------------------------------------------------*
348 : * inverseBwMS()
349 : *
350 : * Band-wise M/S stereo processing
351 : *-------------------------------------------------------------------*/
352 :
353 4357746 : 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 234920871 : for ( j = startLine; j < stopLine; j++ )
365 : {
366 230563125 : tmpValue = x0[j];
367 230563125 : x0[j] = ( x0[j] + x1[j] ) * norm_fac;
368 230563125 : x1[j] = ( tmpValue - x1[j] ) * norm_fac;
369 : }
370 :
371 4357746 : return;
372 : }
373 :
374 :
375 : /*-------------------------------------------------------------------*
376 : * inverseMS()
377 : *
378 : * M/S stereo processing
379 : *-------------------------------------------------------------------*/
380 :
381 504168 : 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 504168 : inverseBwMS( 0, L_frame, x0, x1, norm_fac );
389 :
390 504168 : return;
391 : }
392 :
393 :
394 : /*-------------------------------------------------------------------*
395 : * initMdctStereoDecData()
396 : *
397 : * Initialize MDCT stereo decoder configuration
398 : *-------------------------------------------------------------------*/
399 :
400 890451 : 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 890451 : tcx_coded_lines = getNumTcxCodedLines( bwidth );
411 :
412 : /*Initialize sfb parameteres for TCX20 */
413 890451 : 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 890451 : 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 890451 : 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 890451 : if ( igf )
422 : {
423 : /* calculate the igf start band from the igf start line */
424 500115 : stereo_mdct_init_igf_start_band( &( hStereoMdct->stbParamsTCX20 ), 1.0f, bwidth, element_brate );
425 500115 : stereo_mdct_init_igf_start_band( &( hStereoMdct->stbParamsTCX10 ), 0.5f, bwidth, element_brate );
426 500115 : stereo_mdct_init_igf_start_band( &( hStereoMdct->stbParamsTCX20afterACELP ), 1.25f, bwidth, element_brate );
427 : }
428 : else
429 : {
430 390336 : hStereoMdct->stbParamsTCX20.sfbIgfStart = -1;
431 390336 : hStereoMdct->stbParamsTCX10.sfbIgfStart = -1;
432 390336 : hStereoMdct->stbParamsTCX20afterACELP.sfbIgfStart = -1;
433 390336 : hStereoMdct->stbParamsTCX10.nBandsStereoCore = hStereoMdct->stbParamsTCX10.sfbCnt;
434 390336 : hStereoMdct->stbParamsTCX20.nBandsStereoCore = hStereoMdct->stbParamsTCX20.sfbCnt;
435 390336 : hStereoMdct->stbParamsTCX20afterACELP.nBandsStereoCore = hStereoMdct->stbParamsTCX20afterACELP.sfbCnt;
436 : }
437 :
438 890451 : 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 3323415 : 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 3323415 : st = sts[n];
517 :
518 3323415 : 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 3323415 : 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 : }
|
