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 7763298 : 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 7763298 : if ( !isSBAStereoMode )
72 : {
73 6223527 : nSubframes = ( sts[0]->core == TCX_10_CORE || ( sts[0]->core != sts[1]->core ) ) ? NB_DIV : 1;
74 6223527 : sfbConf = ( sts[0]->core == TCX_20_CORE ) ? &hStereoMdct->stbParamsTCX20 : &hStereoMdct->stbParamsTCX10;
75 6223527 : if ( sts[0]->last_core_from_bs == ACELP_CORE )
76 : {
77 28044 : sfbConf = &hStereoMdct->stbParamsTCX20afterACELP;
78 : }
79 :
80 6223527 : if ( hStereoMdct->use_itd )
81 : {
82 : int16_t I;
83 :
84 388233 : 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 388233 : hStereoMdct->itd = 0.f;
88 388233 : if ( hStereoMdct->itd_mode )
89 : {
90 74910 : /*(*nb_bits) += */ read_itd( st0, &I );
91 74910 : stereo_dft_dequantize_itd( &I, &hStereoMdct->itd, st0->output_Fs );
92 : }
93 : }
94 :
95 12608802 : for ( k = 0; k < nSubframes; k++ )
96 : {
97 6385275 : mdct_stereo_mode = get_next_indice( st0, 1 );
98 6385275 : if ( mdct_stereo_mode )
99 : {
100 6094209 : mdct_stereo_mode = 1 + get_next_indice( st0, 1 );
101 : }
102 6385275 : switch ( mdct_stereo_mode )
103 : {
104 291066 : case 0:
105 291066 : hStereoMdct->mdct_stereo_mode[k] = SMDCT_DUAL_MONO;
106 291066 : break;
107 4498419 : case 1:
108 4498419 : hStereoMdct->mdct_stereo_mode[k] = SMDCT_MS_FULL;
109 4498419 : break;
110 1595790 : case 2:
111 1595790 : hStereoMdct->mdct_stereo_mode[k] = SMDCT_BW_MS;
112 1595790 : break;
113 0 : default:
114 0 : assert( !"Not supported stereo mode\n" );
115 : }
116 :
117 6385275 : if ( !mct_on )
118 : {
119 2190309 : if ( sts[0]->core == sts[1]->core || k == 0 )
120 : {
121 2176665 : hStereoMdct->global_ild[k] = get_next_indice( st0, SMDCT_GLOBAL_ILD_BITS );
122 4353330 : assert( ( hStereoMdct->global_ild[k] > 0 ) && ( hStereoMdct->global_ild[k] < SMDCT_ILD_RANGE ) );
123 : }
124 : else
125 : {
126 13644 : hStereoMdct->global_ild[1] = hStereoMdct->global_ild[0];
127 : }
128 : }
129 :
130 6385275 : set_s( ms_mask[k], ( hStereoMdct->mdct_stereo_mode[k] == SMDCT_MS_FULL ) ? 1 : 0, sfbConf->nBandsStereoCore );
131 :
132 6385275 : if ( hStereoMdct->mdct_stereo_mode[k] == SMDCT_BW_MS )
133 : {
134 64127895 : for ( i = 0; i < sfbConf->nBandsStereoCore; i++ )
135 : {
136 62532105 : ms_mask[k][i] = get_next_indice( st0, 1 );
137 : }
138 : }
139 :
140 6385275 : if ( st0->igf )
141 : {
142 4672290 : mdct_stereo_mode = get_next_indice( st0, 1 );
143 4672290 : if ( mdct_stereo_mode )
144 : {
145 3153858 : mdct_stereo_mode = 1 + get_next_indice( st0, 1 );
146 : }
147 :
148 4672290 : switch ( mdct_stereo_mode )
149 : {
150 1518432 : case 0:
151 1518432 : hStereoMdct->IGFStereoMode[k] = SMDCT_DUAL_MONO;
152 1518432 : break;
153 2119587 : case 1:
154 2119587 : hStereoMdct->IGFStereoMode[k] = SMDCT_MS_FULL;
155 2119587 : break;
156 1034271 : case 2:
157 1034271 : hStereoMdct->IGFStereoMode[k] = SMDCT_BW_MS;
158 1034271 : break;
159 0 : default:
160 0 : assert( !"Not supported stereo mode\n" );
161 : }
162 :
163 4672290 : set_s( &ms_mask[k][sfbConf->nBandsStereoCore], ( hStereoMdct->IGFStereoMode[k] == SMDCT_MS_FULL ) ? 1 : 0, sfbConf->sfbCnt - sfbConf->nBandsStereoCore );
164 :
165 4672290 : if ( hStereoMdct->IGFStereoMode[k] == SMDCT_BW_MS )
166 : {
167 6987393 : for ( i = sfbConf->nBandsStereoCore; i < sfbConf->sfbCnt; i++ )
168 : {
169 5953122 : ms_mask[k][i] = get_next_indice( st0, 1 );
170 : }
171 : }
172 : }
173 : else
174 : {
175 1712985 : hStereoMdct->IGFStereoMode[k] = SMDCT_DUAL_MONO;
176 : }
177 : }
178 : }
179 :
180 7763298 : if ( !mct_on )
181 : {
182 3664149 : hStereoMdct->split_ratio = SMDCT_EQUAL_RATIO_RANGE; /* Equal bits to both channels */
183 3664149 : hStereoMdct->split_ratio = get_next_indice( st0, SMDCT_NBBITS_SPLIT_RATIO );
184 :
185 3664149 : 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 7763298 : 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 6290328 : 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 6290328 : STEREO_MDCT_BAND_PARAMETERS *sfbConf = NULL;
228 : float nrgRatio;
229 :
230 6290328 : nSubframes = 2;
231 6290328 : if ( ( core_l <= TCX_20_CORE && core_r <= TCX_20_CORE ) || tmp_plc_upmix )
232 : {
233 6127734 : nSubframes = 1;
234 : }
235 :
236 12743250 : for ( k = 0; k < nSubframes; k++ )
237 : {
238 6452922 : sfbConf = ( core_l == TCX_20_CORE ) ? &hStereoMdct->stbParamsTCX20 : &hStereoMdct->stbParamsTCX10;
239 :
240 6452922 : if ( last_core_l == ACELP_CORE || last_core_r == ACELP_CORE )
241 : {
242 28314 : sfbConf = &hStereoMdct->stbParamsTCX20afterACELP;
243 : }
244 :
245 6452922 : if ( mdct_stereo_mode[k] == SMDCT_MS_FULL )
246 : {
247 2321924847 : for ( i = 0; i < sfbConf->sfbOffset[sfbConf->nBandsStereoCore]; i++ )
248 : {
249 2317385448 : if ( spec_r_0[k][i] == 0.0f )
250 : {
251 749321928 : spec_r[k][i] *= NF_RED_FAC;
252 : }
253 : }
254 4539399 : inverseMS( sfbConf->sfbOffset[sfbConf->nBandsStereoCore], spec_l[k], spec_r[k], SQRT2_OVER_2 );
255 : }
256 1913523 : else if ( mdct_stereo_mode[k] == SMDCT_BW_MS )
257 : {
258 64944723 : for ( sfb = 0; sfb < sfbConf->nBandsStereoCore; sfb++ )
259 : {
260 63327648 : if ( ms_mask[k][sfb] )
261 : {
262 574068699 : for ( i = sfbConf->sfbOffset[sfb]; i < sfbConf->sfbOffset[sfb + 1]; i++ )
263 : {
264 533718000 : if ( spec_r_0[k][i] == 0.0f )
265 : {
266 182773125 : spec_r[k][i] *= NF_RED_FAC;
267 : }
268 : }
269 40350699 : 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 6452922 : if ( igf )
281 : {
282 4712172 : if ( hStereoMdct->IGFStereoMode[k] == SMDCT_MS_FULL )
283 : {
284 675423792 : for ( i = sfbConf->sfbOffset[sfbConf->nBandsStereoCore]; i < sfbConf->sfbOffset[sfbConf->sfbCnt]; i++ )
285 : {
286 673290198 : if ( spec_r_0[k][i] == 0.0f )
287 : {
288 190461141 : spec_r[k][i] *= NF_RED_FAC;
289 : }
290 : }
291 2133594 : 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 2578578 : else if ( hStereoMdct->IGFStereoMode[k] == SMDCT_BW_MS )
294 : {
295 7029561 : for ( sfb = sfbConf->nBandsStereoCore; sfb < sfbConf->sfbCnt; sfb++ )
296 : {
297 5989734 : if ( ms_mask[k][sfb] )
298 : {
299 151152945 : for ( i = sfbConf->sfbOffset[sfb]; i < sfbConf->sfbOffset[sfb + 1]; i++ )
300 : {
301 147994692 : if ( spec_r_0[k][i] == 0.0f )
302 : {
303 41094561 : spec_r[k][i] *= NF_RED_FAC;
304 : }
305 : }
306 3158253 : 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 6452922 : if ( !mct_on )
319 : {
320 2257956 : nrgRatio = (float) SMDCT_ILD_RANGE / hStereoMdct->global_ild[k] - 1; /* nrgRatio = nrg[1]/nrg[0] */
321 2257956 : 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 2257956 : if ( hStereoMdct->smooth_ratio > 1.3f )
324 : {
325 539034 : hStereoMdct->reverse_dmx = 1;
326 : }
327 1718922 : else if ( hStereoMdct->smooth_ratio < 0.9f )
328 : {
329 530988 : hStereoMdct->reverse_dmx = 0;
330 : }
331 :
332 2257956 : if ( ( nrgRatio > 1.0f ) && ( k < ( ( core_r == TCX_10_CORE ) ? NB_DIV : 1 ) ) )
333 : {
334 714177 : v_multc( spec_r[k], nrgRatio, spec_r[k], L_frameTCX_r );
335 : }
336 1543779 : else if ( ( nrgRatio < 1.0f ) && ( k < ( ( core_l == TCX_10_CORE ) ? NB_DIV : 1 ) ) )
337 : {
338 582144 : v_multc( spec_l[k], 1.0f / nrgRatio, spec_l[k], L_frameTCX_l );
339 : }
340 : }
341 : } /* for k */
342 :
343 6290328 : return;
344 : }
345 :
346 :
347 : /*-------------------------------------------------------------------*
348 : * inverseBwMS()
349 : *
350 : * Band-wise M/S stereo processing
351 : *-------------------------------------------------------------------*/
352 :
353 51816756 : 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 3750383898 : for ( j = startLine; j < stopLine; j++ )
365 : {
366 3698567142 : tmpValue = x0[j];
367 3698567142 : x0[j] = ( x0[j] + x1[j] ) * norm_fac;
368 3698567142 : x1[j] = ( tmpValue - x1[j] ) * norm_fac;
369 : }
370 :
371 51816756 : return;
372 : }
373 :
374 :
375 : /*-------------------------------------------------------------------*
376 : * inverseMS()
377 : *
378 : * M/S stereo processing
379 : *-------------------------------------------------------------------*/
380 :
381 8307804 : 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 8307804 : inverseBwMS( 0, L_frame, x0, x1, norm_fac );
389 :
390 8307804 : return;
391 : }
392 :
393 :
394 : /*-------------------------------------------------------------------*
395 : * initMdctStereoDecData()
396 : *
397 : * Initialize MDCT stereo decoder configuration
398 : *-------------------------------------------------------------------*/
399 :
400 12665448 : 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 12665448 : tcx_coded_lines = getNumTcxCodedLines( bwidth );
411 :
412 : /*Initialize sfb parameteres for TCX20 */
413 12665448 : 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 12665448 : 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 12665448 : 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 12665448 : if ( igf )
422 : {
423 : /* calculate the igf start band from the igf start line */
424 7478331 : stereo_mdct_init_igf_start_band( &( hStereoMdct->stbParamsTCX20 ), 1.0f, bwidth, element_brate );
425 7478331 : stereo_mdct_init_igf_start_band( &( hStereoMdct->stbParamsTCX10 ), 0.5f, bwidth, element_brate );
426 7478331 : stereo_mdct_init_igf_start_band( &( hStereoMdct->stbParamsTCX20afterACELP ), 1.25f, bwidth, element_brate );
427 : }
428 : else
429 : {
430 5187117 : hStereoMdct->stbParamsTCX20.sfbIgfStart = -1;
431 5187117 : hStereoMdct->stbParamsTCX10.sfbIgfStart = -1;
432 5187117 : hStereoMdct->stbParamsTCX20afterACELP.sfbIgfStart = -1;
433 5187117 : hStereoMdct->stbParamsTCX10.nBandsStereoCore = hStereoMdct->stbParamsTCX10.sfbCnt;
434 5187117 : hStereoMdct->stbParamsTCX20.nBandsStereoCore = hStereoMdct->stbParamsTCX20.sfbCnt;
435 5187117 : hStereoMdct->stbParamsTCX20afterACELP.nBandsStereoCore = hStereoMdct->stbParamsTCX20afterACELP.sfbCnt;
436 : }
437 :
438 12665448 : 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 39879480 : 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 39879480 : st = sts[n];
517 :
518 39879480 : 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 : #ifdef NONBE_MDCT_ST_DTX_FIX_SUBOPT_SPATIAL_CNG
527 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() */
528 : #else
529 : sts[0]->hFdCngDec->hFdCngCom->coherence = sts[1]->hFdCngDec->hFdCngCom->coherence; /* coherence is stored in sts[1] - see ivas_decision_matrix_dec() */
530 : #endif
531 4080 : sts[0]->hFdCngDec->hFdCngCom->no_side_flag = sts[1]->hFdCngDec->hFdCngCom->no_side_flag;
532 :
533 : /* configure when there is a switching from DFT CNG to MDCT CNG */
534 4080 : if ( sts[0]->first_CNG == 1 && sts[1]->first_CNG == 0 )
535 : {
536 0 : configureFdCngDec( st->hFdCngDec, st->bwidth, st->element_brate, st->L_frame, st->last_L_frame, st->element_mode );
537 : }
538 : }
539 :
540 8160 : if ( sts[0]->first_CNG == 0 )
541 : {
542 : /* 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 */
543 378 : configureFdCngDec( st->hFdCngDec, st->bwidth, st->element_brate, st->L_frame, st->last_L_frame, st->element_mode );
544 : }
545 : }
546 :
547 39879480 : return;
548 : }
549 :
550 :
551 : /*-------------------------------------------------------------------*
552 : * updateBuffersForDmxMdctStereo()
553 : *
554 : * synch buffers between channels for mono output and
555 : * apply passive downmix to certain buffers to enable smooth transitions
556 : * between active/inactive coding in MDCT-Stereo DTX
557 : *-------------------------------------------------------------------*/
558 :
559 8616 : void updateBuffersForDmxMdctStereo(
560 : CPE_DEC_HANDLE hCPE, /* i/o: CPE handle */
561 : const int16_t output_frame, /* i : output frame length */
562 : float *output[CPE_CHANNELS], /* i/o: decoder output */
563 : float synth[CPE_CHANNELS][L_FRAME48k] /* i/o: decoder synthesis */
564 : )
565 : {
566 : int16_t delay_buf_out_len, tcxltp_mem_in_len, delta, i;
567 : Decoder_State *sts[CPE_CHANNELS];
568 :
569 8616 : sts[0] = hCPE->hCoreCoder[0];
570 8616 : sts[1] = hCPE->hCoreCoder[1];
571 :
572 : /* synch buffers for inactive frames, but not for transition frames */
573 8616 : if ( hCPE->last_element_brate <= IVAS_SID_5k2 )
574 : {
575 8277 : mvr2r( output[0], output[1], output_frame );
576 8277 : mvr2r( synth[0], synth[1], output_frame );
577 : }
578 :
579 8616 : if ( hCPE->element_brate == IVAS_SID_5k2 && hCPE->last_element_brate > IVAS_SID_5k2 )
580 : {
581 : /* 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 */
582 8160 : for ( int16_t p = 0; p < sts[0]->hFdCngDec->hFdCngCom->npart; p++ )
583 : {
584 7821 : sts[0]->hFdCngDec->hFdCngCom->sidNoiseEst[p] = 0.5f * ( sts[0]->hFdCngDec->hFdCngCom->sidNoiseEst[p] + sts[1]->hFdCngDec->hFdCngCom->sidNoiseEst[p] );
585 : }
586 : }
587 :
588 : /* for transition of active->inactive frame, apply passive downmix on buffers */
589 8616 : if ( hCPE->last_element_brate <= IVAS_SID_5k2 )
590 : {
591 8277 : delta = 1;
592 8277 : if ( output_frame == L_FRAME16k )
593 : {
594 2658 : delta = 2;
595 : }
596 5619 : else if ( output_frame == L_FRAME32k )
597 : {
598 2769 : delta = 4;
599 : }
600 2850 : else if ( output_frame == L_FRAME48k )
601 : {
602 2850 : delta = 6;
603 : }
604 :
605 8277 : delay_buf_out_len = delta * HQ_DELAY_COMP;
606 8277 : tcxltp_mem_in_len = NS2SA( sts[0]->output_Fs, TCXLTP_DELAY_NS );
607 :
608 8277 : assert( delay_buf_out_len > tcxltp_mem_in_len );
609 :
610 75261 : for ( i = 0; i < tcxltp_mem_in_len; i++ )
611 : {
612 66984 : sts[0]->hTcxLtpDec->tcxltp_mem_in[i] = INV_SQRT2 * ( sts[0]->hTcxLtpDec->tcxltp_mem_in[i] + sts[1]->hTcxLtpDec->tcxltp_mem_in[i] );
613 66984 : sts[0]->delay_buf_out[i] = INV_SQRT2 * ( sts[0]->delay_buf_out[i] + sts[1]->delay_buf_out[i] );
614 66984 : sts[0]->hHQ_core->old_out[i] = INV_SQRT2 * ( sts[0]->hHQ_core->old_out[i] + sts[1]->hHQ_core->old_out[i] );
615 66984 : sts[0]->hTcxLtpDec->tcxltp_mem_out[i] = INV_SQRT2 * ( sts[0]->hTcxLtpDec->tcxltp_mem_out[i] + sts[1]->hTcxLtpDec->tcxltp_mem_out[i] );
616 : }
617 276213 : for ( ; i < delay_buf_out_len; i++ )
618 : {
619 267936 : sts[0]->delay_buf_out[i] = INV_SQRT2 * ( sts[0]->delay_buf_out[i] + sts[1]->delay_buf_out[i] );
620 267936 : sts[0]->hHQ_core->old_out[i] = INV_SQRT2 * ( sts[0]->hHQ_core->old_out[i] + sts[1]->hHQ_core->old_out[i] );
621 267936 : sts[0]->hTcxLtpDec->tcxltp_mem_out[i] = INV_SQRT2 * ( sts[0]->hTcxLtpDec->tcxltp_mem_out[i] + sts[1]->hTcxLtpDec->tcxltp_mem_out[i] );
622 : }
623 5032077 : for ( ; i < output_frame; i++ )
624 : {
625 5023800 : sts[0]->hHQ_core->old_out[i] = INV_SQRT2 * ( sts[0]->hHQ_core->old_out[i] + sts[1]->hHQ_core->old_out[i] );
626 5023800 : sts[0]->hTcxLtpDec->tcxltp_mem_out[i] = INV_SQRT2 * ( sts[0]->hTcxLtpDec->tcxltp_mem_out[i] + sts[1]->hTcxLtpDec->tcxltp_mem_out[i] );
627 : }
628 : }
629 :
630 8616 : return;
631 : }
632 :
633 :
634 : /*-------------------------------------------------------------------*
635 : * applyDmxMdctStereo()
636 : *
637 : * apply passive downmix to certain buffers to enable smooth transitions
638 : * between active/inactive coding in MDCT-Stereo DTX
639 : *-------------------------------------------------------------------*/
640 :
641 186462 : void applyDmxMdctStereo(
642 : const CPE_DEC_HANDLE hCPE, /* i : CPE handle */
643 : float *output[CPE_CHANNELS], /* i/o: core decoder output */
644 : const int16_t output_frame /* i : output frame length */
645 : )
646 : {
647 : int16_t crossfade_len, i;
648 : int16_t dmx_len;
649 : float fade, step;
650 :
651 186462 : step = 1.f;
652 186462 : fade = 1.f;
653 186462 : dmx_len = output_frame;
654 :
655 186462 : if ( hCPE->last_element_brate <= IVAS_SID_5k2 )
656 : {
657 336 : crossfade_len = NS2SA( hCPE->hCoreCoder[0]->output_Fs, IVAS_DEC_DELAY_NS - DELAY_CLDFB_NS );
658 336 : step /= crossfade_len;
659 : }
660 : /* for first inactive CNG frame after active decoding we have to do a fade-OUT FROM the passive DMX */
661 186126 : else if ( hCPE->element_brate <= IVAS_SID_5k2 && hCPE->last_element_brate > IVAS_SID_5k2 )
662 : {
663 339 : crossfade_len = output_frame / 4;
664 339 : step /= -crossfade_len;
665 339 : fade = 0.f;
666 339 : dmx_len = crossfade_len;
667 : }
668 185787 : else if ( hCPE->last_element_mode == IVAS_CPE_DFT && hCPE->last_element_brate <= IVAS_32k )
669 : {
670 501 : crossfade_len = NS2SA( hCPE->hCoreCoder[0]->output_Fs, DELAY_CLDFB_NS );
671 501 : step /= crossfade_len;
672 : }
673 : else
674 : {
675 185286 : crossfade_len = 0;
676 : }
677 :
678 : /* apply crossfade */
679 295530 : for ( i = 0; i < crossfade_len; i++ )
680 : {
681 109068 : output[0][i] = output[0][i] * fade + ( output[0][i] + output[1][i] ) * INV_SQRT2 * ( 1 - fade );
682 109068 : fade -= step;
683 : }
684 :
685 : /* apply passive downmix on all-active-frame part */
686 141852114 : for ( ; i < dmx_len; i++ )
687 : {
688 141665652 : output[0][i] = ( output[0][i] + output[1][i] ) * INV_SQRT_2;
689 : }
690 :
691 186462 : return;
692 : }
|
