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 7792383 : 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 7792383 : if ( !isSBAStereoMode )
72 : {
73 6252612 : nSubframes = ( sts[0]->core == TCX_10_CORE || ( sts[0]->core != sts[1]->core ) ) ? NB_DIV : 1;
74 6252612 : sfbConf = ( sts[0]->core == TCX_20_CORE ) ? &hStereoMdct->stbParamsTCX20 : &hStereoMdct->stbParamsTCX10;
75 6252612 : if ( sts[0]->last_core_from_bs == ACELP_CORE )
76 : {
77 28053 : sfbConf = &hStereoMdct->stbParamsTCX20afterACELP;
78 : }
79 :
80 6252612 : if ( hStereoMdct->use_itd )
81 : {
82 : int16_t I;
83 :
84 417318 : 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 417318 : hStereoMdct->itd = 0.f;
88 417318 : if ( hStereoMdct->itd_mode )
89 : {
90 80817 : /*(*nb_bits) += */ read_itd( st0, &I );
91 80817 : stereo_dft_dequantize_itd( &I, &hStereoMdct->itd, st0->output_Fs );
92 : }
93 : }
94 :
95 12667593 : for ( k = 0; k < nSubframes; k++ )
96 : {
97 6414981 : mdct_stereo_mode = get_next_indice( st0, 1 );
98 6414981 : if ( mdct_stereo_mode )
99 : {
100 6121566 : mdct_stereo_mode = 1 + get_next_indice( st0, 1 );
101 : }
102 6414981 : switch ( mdct_stereo_mode )
103 : {
104 293415 : case 0:
105 293415 : hStereoMdct->mdct_stereo_mode[k] = SMDCT_DUAL_MONO;
106 293415 : break;
107 4514037 : case 1:
108 4514037 : hStereoMdct->mdct_stereo_mode[k] = SMDCT_MS_FULL;
109 4514037 : break;
110 1607529 : case 2:
111 1607529 : hStereoMdct->mdct_stereo_mode[k] = SMDCT_BW_MS;
112 1607529 : break;
113 0 : default:
114 0 : assert( !"Not supported stereo mode\n" );
115 : }
116 :
117 6414981 : if ( !mct_on )
118 : {
119 2220015 : if ( sts[0]->core == sts[1]->core || k == 0 )
120 : {
121 2206239 : hStereoMdct->global_ild[k] = get_next_indice( st0, SMDCT_GLOBAL_ILD_BITS );
122 4412478 : assert( ( hStereoMdct->global_ild[k] > 0 ) && ( hStereoMdct->global_ild[k] < SMDCT_ILD_RANGE ) );
123 : }
124 : else
125 : {
126 13776 : hStereoMdct->global_ild[1] = hStereoMdct->global_ild[0];
127 : }
128 : }
129 :
130 6414981 : set_s( ms_mask[k], ( hStereoMdct->mdct_stereo_mode[k] == SMDCT_MS_FULL ) ? 1 : 0, sfbConf->nBandsStereoCore );
131 :
132 6414981 : if ( hStereoMdct->mdct_stereo_mode[k] == SMDCT_BW_MS )
133 : {
134 64521318 : for ( i = 0; i < sfbConf->nBandsStereoCore; i++ )
135 : {
136 62913789 : ms_mask[k][i] = get_next_indice( st0, 1 );
137 : }
138 : }
139 :
140 6414981 : if ( st0->igf )
141 : {
142 4700559 : mdct_stereo_mode = get_next_indice( st0, 1 );
143 4700559 : if ( mdct_stereo_mode )
144 : {
145 3167142 : mdct_stereo_mode = 1 + get_next_indice( st0, 1 );
146 : }
147 :
148 4700559 : switch ( mdct_stereo_mode )
149 : {
150 1533417 : case 0:
151 1533417 : hStereoMdct->IGFStereoMode[k] = SMDCT_DUAL_MONO;
152 1533417 : break;
153 2127072 : case 1:
154 2127072 : hStereoMdct->IGFStereoMode[k] = SMDCT_MS_FULL;
155 2127072 : break;
156 1040070 : case 2:
157 1040070 : hStereoMdct->IGFStereoMode[k] = SMDCT_BW_MS;
158 1040070 : break;
159 0 : default:
160 0 : assert( !"Not supported stereo mode\n" );
161 : }
162 :
163 4700559 : set_s( &ms_mask[k][sfbConf->nBandsStereoCore], ( hStereoMdct->IGFStereoMode[k] == SMDCT_MS_FULL ) ? 1 : 0, sfbConf->sfbCnt - sfbConf->nBandsStereoCore );
164 :
165 4700559 : if ( hStereoMdct->IGFStereoMode[k] == SMDCT_BW_MS )
166 : {
167 7045353 : for ( i = sfbConf->nBandsStereoCore; i < sfbConf->sfbCnt; i++ )
168 : {
169 6005283 : ms_mask[k][i] = get_next_indice( st0, 1 );
170 : }
171 : }
172 : }
173 : else
174 : {
175 1714422 : hStereoMdct->IGFStereoMode[k] = SMDCT_DUAL_MONO;
176 : }
177 : }
178 : }
179 :
180 7792383 : if ( !mct_on )
181 : {
182 3693234 : hStereoMdct->split_ratio = SMDCT_EQUAL_RATIO_RANGE; /* Equal bits to both channels */
183 3693234 : hStereoMdct->split_ratio = get_next_indice( st0, SMDCT_NBBITS_SPLIT_RATIO );
184 :
185 3693234 : 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 7792383 : 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 6322608 : 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 6322608 : STEREO_MDCT_BAND_PARAMETERS *sfbConf = NULL;
228 : float nrgRatio;
229 :
230 6322608 : nSubframes = 2;
231 6322608 : if ( ( core_l <= TCX_20_CORE && core_r <= TCX_20_CORE ) || tmp_plc_upmix )
232 : {
233 6159360 : nSubframes = 1;
234 : }
235 :
236 12808464 : for ( k = 0; k < nSubframes; k++ )
237 : {
238 6485856 : sfbConf = ( core_l == TCX_20_CORE ) ? &hStereoMdct->stbParamsTCX20 : &hStereoMdct->stbParamsTCX10;
239 :
240 6485856 : if ( last_core_l == ACELP_CORE || last_core_r == ACELP_CORE )
241 : {
242 28323 : sfbConf = &hStereoMdct->stbParamsTCX20afterACELP;
243 : }
244 :
245 6485856 : if ( mdct_stereo_mode[k] == SMDCT_MS_FULL )
246 : {
247 2328702198 : for ( i = 0; i < sfbConf->sfbOffset[sfbConf->nBandsStereoCore]; i++ )
248 : {
249 2324145432 : if ( spec_r_0[k][i] == 0.0f )
250 : {
251 754999110 : spec_r[k][i] *= NF_RED_FAC;
252 : }
253 : }
254 4556766 : inverseMS( sfbConf->sfbOffset[sfbConf->nBandsStereoCore], spec_l[k], spec_r[k], SQRT2_OVER_2 );
255 : }
256 1929090 : else if ( mdct_stereo_mode[k] == SMDCT_BW_MS )
257 : {
258 65383305 : for ( sfb = 0; sfb < sfbConf->nBandsStereoCore; sfb++ )
259 : {
260 63753144 : if ( ms_mask[k][sfb] )
261 : {
262 577352415 : for ( i = sfbConf->sfbOffset[sfb]; i < sfbConf->sfbOffset[sfb + 1]; i++ )
263 : {
264 536741580 : if ( spec_r_0[k][i] == 0.0f )
265 : {
266 185207418 : spec_r[k][i] *= NF_RED_FAC;
267 : }
268 : }
269 40610835 : 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 6485856 : if ( igf )
281 : {
282 4743483 : if ( hStereoMdct->IGFStereoMode[k] == SMDCT_MS_FULL )
283 : {
284 678670068 : for ( i = sfbConf->sfbOffset[sfbConf->nBandsStereoCore]; i < sfbConf->sfbOffset[sfbConf->sfbCnt]; i++ )
285 : {
286 676528242 : if ( spec_r_0[k][i] == 0.0f )
287 : {
288 193699155 : spec_r[k][i] *= NF_RED_FAC;
289 : }
290 : }
291 2141826 : 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 2601657 : else if ( hStereoMdct->IGFStereoMode[k] == SMDCT_BW_MS )
294 : {
295 7095351 : for ( sfb = sfbConf->nBandsStereoCore; sfb < sfbConf->sfbCnt; sfb++ )
296 : {
297 6048942 : if ( ms_mask[k][sfb] )
298 : {
299 152397897 : for ( i = sfbConf->sfbOffset[sfb]; i < sfbConf->sfbOffset[sfb + 1]; i++ )
300 : {
301 149209980 : if ( spec_r_0[k][i] == 0.0f )
302 : {
303 42309849 : spec_r[k][i] *= NF_RED_FAC;
304 : }
305 : }
306 3187917 : 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 6485856 : if ( !mct_on )
319 : {
320 2290890 : nrgRatio = (float) SMDCT_ILD_RANGE / hStereoMdct->global_ild[k] - 1; /* nrgRatio = nrg[1]/nrg[0] */
321 2290890 : 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 2290890 : if ( hStereoMdct->smooth_ratio > 1.3f )
324 : {
325 548082 : hStereoMdct->reverse_dmx = 1;
326 : }
327 1742808 : else if ( hStereoMdct->smooth_ratio < 0.9f )
328 : {
329 541380 : hStereoMdct->reverse_dmx = 0;
330 : }
331 :
332 2290890 : if ( ( nrgRatio > 1.0f ) && ( k < ( ( core_r == TCX_10_CORE ) ? NB_DIV : 1 ) ) )
333 : {
334 725637 : v_multc( spec_r[k], nrgRatio, spec_r[k], L_frameTCX_r );
335 : }
336 1565253 : else if ( ( nrgRatio < 1.0f ) && ( k < ( ( core_l == TCX_10_CORE ) ? NB_DIV : 1 ) ) )
337 : {
338 592821 : v_multc( spec_l[k], 1.0f / nrgRatio, spec_l[k], L_frameTCX_l );
339 : }
340 : }
341 : } /* for k */
342 :
343 6322608 : return;
344 : }
345 :
346 :
347 : /*-------------------------------------------------------------------*
348 : * inverseBwMS()
349 : *
350 : * Band-wise M/S stereo processing
351 : *-------------------------------------------------------------------*/
352 :
353 52158279 : 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 3765380301 : for ( j = startLine; j < stopLine; j++ )
365 : {
366 3713222022 : tmpValue = x0[j];
367 3713222022 : x0[j] = ( x0[j] + x1[j] ) * norm_fac;
368 3713222022 : x1[j] = ( tmpValue - x1[j] ) * norm_fac;
369 : }
370 :
371 52158279 : return;
372 : }
373 :
374 :
375 : /*-------------------------------------------------------------------*
376 : * inverseMS()
377 : *
378 : * M/S stereo processing
379 : *-------------------------------------------------------------------*/
380 :
381 8359527 : 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 8359527 : inverseBwMS( 0, L_frame, x0, x1, norm_fac );
389 :
390 8359527 : return;
391 : }
392 :
393 :
394 : /*-------------------------------------------------------------------*
395 : * initMdctStereoDecData()
396 : *
397 : * Initialize MDCT stereo decoder configuration
398 : *-------------------------------------------------------------------*/
399 :
400 12696447 : 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 12696447 : tcx_coded_lines = getNumTcxCodedLines( bwidth );
411 :
412 : /*Initialize sfb parameteres for TCX20 */
413 12696447 : 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 12696447 : 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 12696447 : 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 12696447 : if ( igf )
422 : {
423 : /* calculate the igf start band from the igf start line */
424 7507767 : stereo_mdct_init_igf_start_band( &( hStereoMdct->stbParamsTCX20 ), 1.0f, bwidth, element_brate );
425 7507767 : stereo_mdct_init_igf_start_band( &( hStereoMdct->stbParamsTCX10 ), 0.5f, bwidth, element_brate );
426 7507767 : stereo_mdct_init_igf_start_band( &( hStereoMdct->stbParamsTCX20afterACELP ), 1.25f, bwidth, element_brate );
427 : }
428 : else
429 : {
430 5188680 : hStereoMdct->stbParamsTCX20.sfbIgfStart = -1;
431 5188680 : hStereoMdct->stbParamsTCX10.sfbIgfStart = -1;
432 5188680 : hStereoMdct->stbParamsTCX20afterACELP.sfbIgfStart = -1;
433 5188680 : hStereoMdct->stbParamsTCX10.nBandsStereoCore = hStereoMdct->stbParamsTCX10.sfbCnt;
434 5188680 : hStereoMdct->stbParamsTCX20.nBandsStereoCore = hStereoMdct->stbParamsTCX20.sfbCnt;
435 5188680 : hStereoMdct->stbParamsTCX20afterACELP.nBandsStereoCore = hStereoMdct->stbParamsTCX20afterACELP.sfbCnt;
436 : }
437 :
438 12696447 : return;
439 : }
440 :
441 :
442 : /*-------------------------------------------------------------------*
443 : * initMdctStereoDtxData()
444 : *
445 : * Allocate and initialize structures for MDCT-Stereo DTX operation
446 : *-------------------------------------------------------------------*/
447 :
448 207 : ivas_error initMdctStereoDtxData(
449 : CPE_DEC_HANDLE hCPE /* i/o: CPE handle */
450 : )
451 : {
452 : int16_t ch;
453 : ivas_error error;
454 :
455 207 : error = IVAS_ERR_OK;
456 :
457 621 : for ( ch = 0; ch < CPE_CHANNELS; ch++ )
458 : {
459 414 : DEC_CORE_HANDLE st = hCPE->hCoreCoder[ch];
460 :
461 414 : 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 414 : if ( st->first_CNG == 0 )
474 : {
475 396 : if ( ch == 1 && st->cng_sba_flag )
476 : {
477 138 : st->hFdCngDec->hFdCngCom->seed += 3;
478 : }
479 : }
480 :
481 414 : if ( st->cldfbAna == NULL )
482 : {
483 : /* open analysis for max. sampling rate 48kHz */
484 252 : if ( ( error = openCldfb( &st->cldfbAna, CLDFB_ANALYSIS, 48000, CLDFB_PROTOTYPE_1_25MS ) ) != IVAS_ERR_OK )
485 : {
486 0 : return error;
487 : }
488 : }
489 :
490 414 : if ( st->cldfbBPF == NULL )
491 : {
492 : /* open analysis BPF for max. internal sampling rate 16kHz */
493 252 : 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 207 : return error;
501 : }
502 :
503 : /*-------------------------------------------------------------------*
504 : * synchonize_channels_mdct_sid()
505 : *
506 : * Synchronize channels in SID frame in MDCT stereo
507 : *-------------------------------------------------------------------*/
508 :
509 39937680 : 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 39937680 : st = sts[n];
517 :
518 39937680 : if ( st->element_mode == IVAS_CPE_MDCT && st->total_brate == SID_2k40 )
519 : {
520 8160 : if ( n == 1 )
521 : {
522 : /* synchronize channels */
523 4080 : sts[1]->L_frame = sts[0]->L_frame;
524 4080 : sts[1]->cng_type = sts[0]->cng_type;
525 4080 : sts[1]->bwidth = sts[0]->bwidth;
526 4080 : sts[0]->hFdCngDec->hFdCngCom->coherence[0] = sts[1]->hFdCngDec->hFdCngCom->coherence[0]; /* coherence is stored in sts[1] - see ivas_decision_matrix_dec() and FdCngDecodeMDCTStereoSID() */
527 4080 : 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 4080 : 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 8160 : 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 378 : configureFdCngDec( st->hFdCngDec, st->bwidth, st->element_brate, st->L_frame, st->last_L_frame, st->element_mode );
540 : }
541 : }
542 :
543 39937680 : 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 8616 : 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 8616 : sts[0] = hCPE->hCoreCoder[0];
566 8616 : sts[1] = hCPE->hCoreCoder[1];
567 :
568 : /* synch buffers for inactive frames, but not for transition frames */
569 8616 : if ( hCPE->last_element_brate <= IVAS_SID_5k2 )
570 : {
571 8277 : mvr2r( output[0], output[1], output_frame );
572 8277 : mvr2r( synth[0], synth[1], output_frame );
573 : }
574 :
575 8616 : 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 8160 : for ( int16_t p = 0; p < sts[0]->hFdCngDec->hFdCngCom->npart; p++ )
579 : {
580 7821 : 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 8616 : if ( hCPE->last_element_brate <= IVAS_SID_5k2 )
586 : {
587 8277 : delta = 1;
588 8277 : if ( output_frame == L_FRAME16k )
589 : {
590 2658 : delta = 2;
591 : }
592 5619 : else if ( output_frame == L_FRAME32k )
593 : {
594 2769 : delta = 4;
595 : }
596 2850 : else if ( output_frame == L_FRAME48k )
597 : {
598 2850 : delta = 6;
599 : }
600 :
601 8277 : delay_buf_out_len = delta * HQ_DELAY_COMP;
602 8277 : tcxltp_mem_in_len = NS2SA( sts[0]->output_Fs, TCXLTP_DELAY_NS );
603 :
604 8277 : assert( delay_buf_out_len > tcxltp_mem_in_len );
605 :
606 75261 : for ( i = 0; i < tcxltp_mem_in_len; i++ )
607 : {
608 66984 : sts[0]->hTcxLtpDec->tcxltp_mem_in[i] = INV_SQRT2 * ( sts[0]->hTcxLtpDec->tcxltp_mem_in[i] + sts[1]->hTcxLtpDec->tcxltp_mem_in[i] );
609 66984 : sts[0]->delay_buf_out[i] = INV_SQRT2 * ( sts[0]->delay_buf_out[i] + sts[1]->delay_buf_out[i] );
610 66984 : sts[0]->hHQ_core->old_out[i] = INV_SQRT2 * ( sts[0]->hHQ_core->old_out[i] + sts[1]->hHQ_core->old_out[i] );
611 66984 : 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 276213 : for ( ; i < delay_buf_out_len; i++ )
614 : {
615 267936 : sts[0]->delay_buf_out[i] = INV_SQRT2 * ( sts[0]->delay_buf_out[i] + sts[1]->delay_buf_out[i] );
616 267936 : sts[0]->hHQ_core->old_out[i] = INV_SQRT2 * ( sts[0]->hHQ_core->old_out[i] + sts[1]->hHQ_core->old_out[i] );
617 267936 : 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 5032077 : for ( ; i < output_frame; i++ )
620 : {
621 5023800 : sts[0]->hHQ_core->old_out[i] = INV_SQRT2 * ( sts[0]->hHQ_core->old_out[i] + sts[1]->hHQ_core->old_out[i] );
622 5023800 : 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 8616 : 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 186462 : 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 186462 : step = 1.f;
648 186462 : fade = 1.f;
649 186462 : dmx_len = output_frame;
650 :
651 186462 : if ( hCPE->last_element_brate <= IVAS_SID_5k2 )
652 : {
653 336 : crossfade_len = NS2SA( hCPE->hCoreCoder[0]->output_Fs, IVAS_DEC_DELAY_NS - DELAY_CLDFB_NS );
654 336 : 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 186126 : else if ( hCPE->element_brate <= IVAS_SID_5k2 && hCPE->last_element_brate > IVAS_SID_5k2 )
658 : {
659 339 : crossfade_len = output_frame / 4;
660 339 : step /= -crossfade_len;
661 339 : fade = 0.f;
662 339 : dmx_len = crossfade_len;
663 : }
664 185787 : else if ( hCPE->last_element_mode == IVAS_CPE_DFT && hCPE->last_element_brate <= IVAS_32k )
665 : {
666 501 : crossfade_len = NS2SA( hCPE->hCoreCoder[0]->output_Fs, DELAY_CLDFB_NS );
667 501 : step /= crossfade_len;
668 : }
669 : else
670 : {
671 185286 : crossfade_len = 0;
672 : }
673 :
674 : /* apply crossfade */
675 295530 : for ( i = 0; i < crossfade_len; i++ )
676 : {
677 109068 : output[0][i] = output[0][i] * fade + ( output[0][i] + output[1][i] ) * INV_SQRT2 * ( 1 - fade );
678 109068 : fade -= step;
679 : }
680 :
681 : /* apply passive downmix on all-active-frame part */
682 141852114 : for ( ; i < dmx_len; i++ )
683 : {
684 141665652 : output[0][i] = ( output[0][i] + output[1][i] ) * INV_SQRT_2;
685 : }
686 :
687 186462 : return;
688 : }
|
