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 371252 : 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 371252 : if ( !isSBAStereoMode )
72 : {
73 316399 : nSubframes = ( sts[0]->core == TCX_10_CORE || ( sts[0]->core != sts[1]->core ) ) ? NB_DIV : 1;
74 316399 : sfbConf = ( sts[0]->core == TCX_20_CORE ) ? &hStereoMdct->stbParamsTCX20 : &hStereoMdct->stbParamsTCX10;
75 316399 : if ( sts[0]->last_core_from_bs == ACELP_CORE )
76 : {
77 670 : sfbConf = &hStereoMdct->stbParamsTCX20afterACELP;
78 : }
79 :
80 316399 : if ( hStereoMdct->use_itd )
81 : {
82 : int16_t I;
83 :
84 11662 : 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 11662 : hStereoMdct->itd = 0.f;
88 11662 : if ( hStereoMdct->itd_mode )
89 : {
90 3531 : /*(*nb_bits) += */ read_itd( st0, &I );
91 3531 : stereo_dft_dequantize_itd( &I, &hStereoMdct->itd, st0->output_Fs );
92 : }
93 : }
94 :
95 638980 : for ( k = 0; k < nSubframes; k++ )
96 : {
97 322581 : mdct_stereo_mode = get_next_indice( st0, 1 );
98 322581 : if ( mdct_stereo_mode )
99 : {
100 318590 : mdct_stereo_mode = 1 + get_next_indice( st0, 1 );
101 : }
102 322581 : switch ( mdct_stereo_mode )
103 : {
104 3991 : case 0:
105 3991 : hStereoMdct->mdct_stereo_mode[k] = SMDCT_DUAL_MONO;
106 3991 : break;
107 211974 : case 1:
108 211974 : hStereoMdct->mdct_stereo_mode[k] = SMDCT_MS_FULL;
109 211974 : break;
110 106616 : case 2:
111 106616 : hStereoMdct->mdct_stereo_mode[k] = SMDCT_BW_MS;
112 106616 : break;
113 0 : default:
114 0 : assert( !"Not supported stereo mode\n" );
115 : }
116 :
117 322581 : if ( !mct_on )
118 : {
119 70411 : if ( sts[0]->core == sts[1]->core || k == 0 )
120 : {
121 70072 : hStereoMdct->global_ild[k] = get_next_indice( st0, SMDCT_GLOBAL_ILD_BITS );
122 70072 : assert( ( hStereoMdct->global_ild[k] > 0 ) && ( hStereoMdct->global_ild[k] < SMDCT_ILD_RANGE ) );
123 : }
124 : else
125 : {
126 339 : hStereoMdct->global_ild[1] = hStereoMdct->global_ild[0];
127 : }
128 : }
129 :
130 322581 : set_s( ms_mask[k], ( hStereoMdct->mdct_stereo_mode[k] == SMDCT_MS_FULL ) ? 1 : 0, sfbConf->nBandsStereoCore );
131 :
132 322581 : if ( hStereoMdct->mdct_stereo_mode[k] == SMDCT_BW_MS )
133 : {
134 4425940 : for ( i = 0; i < sfbConf->nBandsStereoCore; i++ )
135 : {
136 4319324 : ms_mask[k][i] = get_next_indice( st0, 1 );
137 : }
138 : }
139 :
140 322581 : if ( st0->igf )
141 : {
142 233058 : mdct_stereo_mode = get_next_indice( st0, 1 );
143 233058 : if ( mdct_stereo_mode )
144 : {
145 162353 : mdct_stereo_mode = 1 + get_next_indice( st0, 1 );
146 : }
147 :
148 233058 : switch ( mdct_stereo_mode )
149 : {
150 70705 : case 0:
151 70705 : hStereoMdct->IGFStereoMode[k] = SMDCT_DUAL_MONO;
152 70705 : break;
153 124447 : case 1:
154 124447 : hStereoMdct->IGFStereoMode[k] = SMDCT_MS_FULL;
155 124447 : break;
156 37906 : case 2:
157 37906 : hStereoMdct->IGFStereoMode[k] = SMDCT_BW_MS;
158 37906 : break;
159 0 : default:
160 0 : assert( !"Not supported stereo mode\n" );
161 : }
162 :
163 233058 : set_s( &ms_mask[k][sfbConf->nBandsStereoCore], ( hStereoMdct->IGFStereoMode[k] == SMDCT_MS_FULL ) ? 1 : 0, sfbConf->sfbCnt - sfbConf->nBandsStereoCore );
164 :
165 233058 : if ( hStereoMdct->IGFStereoMode[k] == SMDCT_BW_MS )
166 : {
167 251092 : for ( i = sfbConf->nBandsStereoCore; i < sfbConf->sfbCnt; i++ )
168 : {
169 213186 : ms_mask[k][i] = get_next_indice( st0, 1 );
170 : }
171 : }
172 : }
173 : else
174 : {
175 89523 : hStereoMdct->IGFStereoMode[k] = SMDCT_DUAL_MONO;
176 : }
177 : }
178 : }
179 :
180 371252 : if ( !mct_on )
181 : {
182 123336 : hStereoMdct->split_ratio = SMDCT_EQUAL_RATIO_RANGE; /* Equal bits to both channels */
183 123336 : hStereoMdct->split_ratio = get_next_indice( st0, SMDCT_NBBITS_SPLIT_RATIO );
184 :
185 123336 : 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 371252 : 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 319202 : 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 319202 : STEREO_MDCT_BAND_PARAMETERS *sfbConf = NULL;
228 : float nrgRatio;
229 :
230 319202 : nSubframes = 2;
231 319202 : if ( ( core_l <= TCX_20_CORE && core_r <= TCX_20_CORE ) || tmp_plc_upmix )
232 : {
233 313002 : nSubframes = 1;
234 : }
235 :
236 644604 : for ( k = 0; k < nSubframes; k++ )
237 : {
238 325402 : sfbConf = ( core_l == TCX_20_CORE ) ? &hStereoMdct->stbParamsTCX20 : &hStereoMdct->stbParamsTCX10;
239 :
240 325402 : if ( last_core_l == ACELP_CORE || last_core_r == ACELP_CORE )
241 : {
242 685 : sfbConf = &hStereoMdct->stbParamsTCX20afterACELP;
243 : }
244 :
245 325402 : if ( mdct_stereo_mode[k] == SMDCT_MS_FULL )
246 : {
247 116476083 : for ( i = 0; i < sfbConf->sfbOffset[sfbConf->nBandsStereoCore]; i++ )
248 : {
249 116262508 : if ( spec_r_0[k][i] == 0.0f )
250 : {
251 28587511 : spec_r[k][i] *= NF_RED_FAC;
252 : }
253 : }
254 213575 : inverseMS( sfbConf->sfbOffset[sfbConf->nBandsStereoCore], spec_l[k], spec_r[k], SQRT2_OVER_2 );
255 : }
256 111827 : else if ( mdct_stereo_mode[k] == SMDCT_BW_MS )
257 : {
258 4471556 : for ( sfb = 0; sfb < sfbConf->nBandsStereoCore; sfb++ )
259 : {
260 4363792 : if ( ms_mask[k][sfb] )
261 : {
262 40255940 : for ( i = sfbConf->sfbOffset[sfb]; i < sfbConf->sfbOffset[sfb + 1]; i++ )
263 : {
264 37622536 : if ( spec_r_0[k][i] == 0.0f )
265 : {
266 9258320 : spec_r[k][i] *= NF_RED_FAC;
267 : }
268 : }
269 2633404 : 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 325402 : if ( igf )
281 : {
282 234600 : if ( hStereoMdct->IGFStereoMode[k] == SMDCT_MS_FULL )
283 : {
284 41209254 : for ( i = sfbConf->sfbOffset[sfbConf->nBandsStereoCore]; i < sfbConf->sfbOffset[sfbConf->sfbCnt]; i++ )
285 : {
286 41084362 : if ( spec_r_0[k][i] == 0.0f )
287 : {
288 6295286 : spec_r[k][i] *= NF_RED_FAC;
289 : }
290 : }
291 124892 : 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 109708 : else if ( hStereoMdct->IGFStereoMode[k] == SMDCT_BW_MS )
294 : {
295 252490 : for ( sfb = sfbConf->nBandsStereoCore; sfb < sfbConf->sfbCnt; sfb++ )
296 : {
297 214426 : if ( ms_mask[k][sfb] )
298 : {
299 6014973 : for ( i = sfbConf->sfbOffset[sfb]; i < sfbConf->sfbOffset[sfb + 1]; i++ )
300 : {
301 5899426 : if ( spec_r_0[k][i] == 0.0f )
302 : {
303 1132441 : spec_r[k][i] *= NF_RED_FAC;
304 : }
305 : }
306 115547 : 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 325402 : if ( !mct_on )
319 : {
320 73232 : nrgRatio = (float) SMDCT_ILD_RANGE / hStereoMdct->global_ild[k] - 1; /* nrgRatio = nrg[1]/nrg[0] */
321 73232 : 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 73232 : if ( hStereoMdct->smooth_ratio > 1.3f )
324 : {
325 17347 : hStereoMdct->reverse_dmx = 1;
326 : }
327 55885 : else if ( hStereoMdct->smooth_ratio < 0.9f )
328 : {
329 18493 : hStereoMdct->reverse_dmx = 0;
330 : }
331 :
332 73232 : if ( ( nrgRatio > 1.0f ) && ( k < ( ( core_r == TCX_10_CORE ) ? NB_DIV : 1 ) ) )
333 : {
334 24386 : v_multc( spec_r[k], nrgRatio, spec_r[k], L_frameTCX_r );
335 : }
336 48846 : else if ( ( nrgRatio < 1.0f ) && ( k < ( ( core_l == TCX_10_CORE ) ? NB_DIV : 1 ) ) )
337 : {
338 19450 : v_multc( spec_l[k], 1.0f / nrgRatio, spec_l[k], L_frameTCX_l );
339 : }
340 : }
341 : } /* for k */
342 :
343 319202 : return;
344 : }
345 :
346 :
347 : /*-------------------------------------------------------------------*
348 : * inverseBwMS()
349 : *
350 : * Band-wise M/S stereo processing
351 : *-------------------------------------------------------------------*/
352 :
353 3142332 : 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 204892480 : for ( j = startLine; j < stopLine; j++ )
365 : {
366 201750148 : tmpValue = x0[j];
367 201750148 : x0[j] = ( x0[j] + x1[j] ) * norm_fac;
368 201750148 : x1[j] = ( tmpValue - x1[j] ) * norm_fac;
369 : }
370 :
371 3142332 : return;
372 : }
373 :
374 :
375 : /*-------------------------------------------------------------------*
376 : * inverseMS()
377 : *
378 : * M/S stereo processing
379 : *-------------------------------------------------------------------*/
380 :
381 393381 : 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 393381 : inverseBwMS( 0, L_frame, x0, x1, norm_fac );
389 :
390 393381 : return;
391 : }
392 :
393 :
394 : /*-------------------------------------------------------------------*
395 : * initMdctStereoDecData()
396 : *
397 : * Initialize MDCT stereo decoder configuration
398 : *-------------------------------------------------------------------*/
399 :
400 635035 : 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 635035 : tcx_coded_lines = getNumTcxCodedLines( bwidth );
411 :
412 : /*Initialize sfb parameteres for TCX20 */
413 635035 : 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 635035 : 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 635035 : 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 635035 : if ( igf )
422 : {
423 : /* calculate the igf start band from the igf start line */
424 383056 : stereo_mdct_init_igf_start_band( &( hStereoMdct->stbParamsTCX20 ), 1.0f, bwidth, element_brate );
425 383056 : stereo_mdct_init_igf_start_band( &( hStereoMdct->stbParamsTCX10 ), 0.5f, bwidth, element_brate );
426 383056 : stereo_mdct_init_igf_start_band( &( hStereoMdct->stbParamsTCX20afterACELP ), 1.25f, bwidth, element_brate );
427 : }
428 : else
429 : {
430 251979 : hStereoMdct->stbParamsTCX20.sfbIgfStart = -1;
431 251979 : hStereoMdct->stbParamsTCX10.sfbIgfStart = -1;
432 251979 : hStereoMdct->stbParamsTCX20afterACELP.sfbIgfStart = -1;
433 251979 : hStereoMdct->stbParamsTCX10.nBandsStereoCore = hStereoMdct->stbParamsTCX10.sfbCnt;
434 251979 : hStereoMdct->stbParamsTCX20.nBandsStereoCore = hStereoMdct->stbParamsTCX20.sfbCnt;
435 251979 : hStereoMdct->stbParamsTCX20afterACELP.nBandsStereoCore = hStereoMdct->stbParamsTCX20afterACELP.sfbCnt;
436 : }
437 :
438 635035 : return;
439 : }
440 :
441 :
442 : /*-------------------------------------------------------------------*
443 : * initMdctStereoDtxData()
444 : *
445 : * Allocate and initialize structures for MDCT-Stereo DTX operation
446 : *-------------------------------------------------------------------*/
447 :
448 36 : ivas_error initMdctStereoDtxData(
449 : CPE_DEC_HANDLE hCPE /* i/o: CPE handle */
450 : )
451 : {
452 : int16_t ch;
453 : ivas_error error;
454 :
455 36 : error = IVAS_ERR_OK;
456 :
457 108 : for ( ch = 0; ch < CPE_CHANNELS; ch++ )
458 : {
459 72 : DEC_CORE_HANDLE st = hCPE->hCoreCoder[ch];
460 :
461 72 : 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 72 : if ( st->first_CNG == 0 )
474 : {
475 66 : if ( ch == 1 && st->cng_sba_flag )
476 : {
477 18 : st->hFdCngDec->hFdCngCom->seed += 3;
478 : }
479 : }
480 :
481 72 : if ( st->cldfbAna == NULL )
482 : {
483 : /* open analysis for max. sampling rate 48kHz */
484 58 : if ( ( error = openCldfb( &st->cldfbAna, CLDFB_ANALYSIS, 48000, CLDFB_PROTOTYPE_1_25MS ) ) != IVAS_ERR_OK )
485 : {
486 0 : return error;
487 : }
488 : }
489 :
490 72 : if ( st->cldfbBPF == NULL )
491 : {
492 : /* open analysis BPF for max. internal sampling rate 16kHz */
493 58 : 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 36 : return error;
501 : }
502 :
503 : /*-------------------------------------------------------------------*
504 : * synchonize_channels_mdct_sid()
505 : *
506 : * Synchronize channels in SID frame in MDCT stereo
507 : *-------------------------------------------------------------------*/
508 :
509 2024287 : 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 2024287 : st = sts[n];
517 :
518 2024287 : if ( st->element_mode == IVAS_CPE_MDCT && st->total_brate == SID_2k40 )
519 : {
520 1136 : if ( n == 1 )
521 : {
522 : /* synchronize channels */
523 568 : sts[1]->L_frame = sts[0]->L_frame;
524 568 : sts[1]->cng_type = sts[0]->cng_type;
525 568 : sts[1]->bwidth = sts[0]->bwidth;
526 : #ifdef NONBE_MDCT_ST_DTX_FIX_SUBOPT_SPATIAL_CNG
527 568 : 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 568 : 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 568 : 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 1136 : 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 60 : configureFdCngDec( st->hFdCngDec, st->bwidth, st->element_brate, st->L_frame, st->last_L_frame, st->element_mode );
544 : }
545 : }
546 :
547 2024287 : 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 1119 : 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 1119 : sts[0] = hCPE->hCoreCoder[0];
570 1119 : sts[1] = hCPE->hCoreCoder[1];
571 :
572 : /* synch buffers for inactive frames, but not for transition frames */
573 1119 : if ( hCPE->last_element_brate <= IVAS_SID_5k2 )
574 : {
575 1080 : mvr2r( output[0], output[1], output_frame );
576 1080 : mvr2r( synth[0], synth[1], output_frame );
577 : }
578 :
579 1119 : 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 948 : for ( int16_t p = 0; p < sts[0]->hFdCngDec->hFdCngCom->npart; p++ )
583 : {
584 909 : 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 1119 : if ( hCPE->last_element_brate <= IVAS_SID_5k2 )
590 : {
591 1080 : delta = 1;
592 1080 : if ( output_frame == L_FRAME16k )
593 : {
594 348 : delta = 2;
595 : }
596 732 : else if ( output_frame == L_FRAME32k )
597 : {
598 358 : delta = 4;
599 : }
600 374 : else if ( output_frame == L_FRAME48k )
601 : {
602 374 : delta = 6;
603 : }
604 :
605 1080 : delay_buf_out_len = delta * HQ_DELAY_COMP;
606 1080 : tcxltp_mem_in_len = NS2SA( sts[0]->output_Fs, TCXLTP_DELAY_NS );
607 :
608 1080 : assert( delay_buf_out_len > tcxltp_mem_in_len );
609 :
610 9824 : for ( i = 0; i < tcxltp_mem_in_len; i++ )
611 : {
612 8744 : sts[0]->hTcxLtpDec->tcxltp_mem_in[i] = INV_SQRT2 * ( sts[0]->hTcxLtpDec->tcxltp_mem_in[i] + sts[1]->hTcxLtpDec->tcxltp_mem_in[i] );
613 8744 : sts[0]->delay_buf_out[i] = INV_SQRT2 * ( sts[0]->delay_buf_out[i] + sts[1]->delay_buf_out[i] );
614 8744 : sts[0]->hHQ_core->old_out[i] = INV_SQRT2 * ( sts[0]->hHQ_core->old_out[i] + sts[1]->hHQ_core->old_out[i] );
615 8744 : 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 36056 : for ( ; i < delay_buf_out_len; i++ )
618 : {
619 34976 : sts[0]->delay_buf_out[i] = INV_SQRT2 * ( sts[0]->delay_buf_out[i] + sts[1]->delay_buf_out[i] );
620 34976 : sts[0]->hHQ_core->old_out[i] = INV_SQRT2 * ( sts[0]->hHQ_core->old_out[i] + sts[1]->hHQ_core->old_out[i] );
621 34976 : 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 656880 : for ( ; i < output_frame; i++ )
624 : {
625 655800 : sts[0]->hHQ_core->old_out[i] = INV_SQRT2 * ( sts[0]->hHQ_core->old_out[i] + sts[1]->hHQ_core->old_out[i] );
626 655800 : 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 1119 : 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 5918 : 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 5918 : step = 1.f;
652 5918 : fade = 1.f;
653 5918 : dmx_len = output_frame;
654 :
655 5918 : if ( hCPE->last_element_brate <= IVAS_SID_5k2 )
656 : {
657 35 : crossfade_len = NS2SA( hCPE->hCoreCoder[0]->output_Fs, IVAS_DEC_DELAY_NS - DELAY_CLDFB_NS );
658 35 : 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 5883 : else if ( hCPE->element_brate <= IVAS_SID_5k2 && hCPE->last_element_brate > IVAS_SID_5k2 )
662 : {
663 39 : crossfade_len = output_frame / 4;
664 39 : step /= -crossfade_len;
665 39 : fade = 0.f;
666 39 : dmx_len = crossfade_len;
667 : }
668 5844 : else if ( hCPE->last_element_mode == IVAS_CPE_DFT && hCPE->last_element_brate <= IVAS_32k )
669 : {
670 15 : crossfade_len = NS2SA( hCPE->hCoreCoder[0]->output_Fs, DELAY_CLDFB_NS );
671 15 : step /= crossfade_len;
672 : }
673 : else
674 : {
675 5829 : crossfade_len = 0;
676 : }
677 :
678 : /* apply crossfade */
679 16162 : for ( i = 0; i < crossfade_len; i++ )
680 : {
681 10244 : output[0][i] = output[0][i] * fade + ( output[0][i] + output[1][i] ) * INV_SQRT2 * ( 1 - fade );
682 10244 : fade -= step;
683 : }
684 :
685 : /* apply passive downmix on all-active-frame part */
686 4602234 : for ( ; i < dmx_len; i++ )
687 : {
688 4596316 : output[0][i] = ( output[0][i] + output[1][i] ) * INV_SQRT_2;
689 : }
690 :
691 5918 : return;
692 : }
|
