Line data Source code
1 : /******************************************************************************************************
2 :
3 : (C) 2022-2026 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 10979909 : 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 10979909 : if ( !isSBAStereoMode )
72 : {
73 8788958 : nSubframes = ( sts[0]->core == TCX_10_CORE || ( sts[0]->core != sts[1]->core ) ) ? NB_DIV : 1;
74 8788958 : sfbConf = ( sts[0]->core == TCX_20_CORE ) ? &hStereoMdct->stbParamsTCX20 : &hStereoMdct->stbParamsTCX10;
75 8788958 : if ( sts[0]->last_core_from_bs == ACELP_CORE )
76 : {
77 36700 : sfbConf = &hStereoMdct->stbParamsTCX20afterACELP;
78 : }
79 :
80 8788958 : if ( hStereoMdct->use_itd )
81 : {
82 : int16_t I;
83 :
84 486658 : 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 486658 : hStereoMdct->itd = 0.f;
88 486658 : if ( hStereoMdct->itd_mode )
89 : {
90 111951 : /*(*nb_bits) += */ read_itd( st0, &I );
91 111951 : stereo_dft_dequantize_itd( &I, &hStereoMdct->itd, st0->output_Fs );
92 : }
93 : }
94 :
95 17816873 : for ( k = 0; k < nSubframes; k++ )
96 : {
97 9027915 : mdct_stereo_mode = get_next_indice( st0, 1 );
98 9027915 : if ( mdct_stereo_mode )
99 : {
100 8691440 : mdct_stereo_mode = 1 + get_next_indice( st0, 1 );
101 : }
102 9027915 : switch ( mdct_stereo_mode )
103 : {
104 336475 : case 0:
105 336475 : hStereoMdct->mdct_stereo_mode[k] = SMDCT_DUAL_MONO;
106 336475 : break;
107 6077914 : case 1:
108 6077914 : hStereoMdct->mdct_stereo_mode[k] = SMDCT_MS_FULL;
109 6077914 : break;
110 2613526 : case 2:
111 2613526 : hStereoMdct->mdct_stereo_mode[k] = SMDCT_BW_MS;
112 2613526 : break;
113 0 : default:
114 0 : assert( !"Not supported stereo mode\n" );
115 : }
116 :
117 9027915 : if ( !mct_on )
118 : {
119 3083342 : if ( sts[0]->core == sts[1]->core || k == 0 )
120 : {
121 3065938 : hStereoMdct->global_ild[k] = get_next_indice( st0, SMDCT_GLOBAL_ILD_BITS );
122 6028883 : assert( ( hStereoMdct->global_ild[k] > 0 ) && ( hStereoMdct->global_ild[k] < SMDCT_ILD_RANGE ) );
123 : }
124 : else
125 : {
126 17404 : hStereoMdct->global_ild[1] = hStereoMdct->global_ild[0];
127 : }
128 : }
129 :
130 9027915 : set_s( ms_mask[k], ( hStereoMdct->mdct_stereo_mode[k] == SMDCT_MS_FULL ) ? 1 : 0, sfbConf->nBandsStereoCore );
131 :
132 9027915 : if ( hStereoMdct->mdct_stereo_mode[k] == SMDCT_BW_MS )
133 : {
134 108942070 : for ( i = 0; i < sfbConf->nBandsStereoCore; i++ )
135 : {
136 106328544 : ms_mask[k][i] = get_next_indice( st0, 1 );
137 : }
138 : }
139 :
140 9027915 : if ( st0->igf )
141 : {
142 6106516 : mdct_stereo_mode = get_next_indice( st0, 1 );
143 6106516 : if ( mdct_stereo_mode )
144 : {
145 4011655 : mdct_stereo_mode = 1 + get_next_indice( st0, 1 );
146 : }
147 :
148 6106516 : switch ( mdct_stereo_mode )
149 : {
150 2094861 : case 0:
151 2094861 : hStereoMdct->IGFStereoMode[k] = SMDCT_DUAL_MONO;
152 2094861 : break;
153 2784739 : case 1:
154 2784739 : hStereoMdct->IGFStereoMode[k] = SMDCT_MS_FULL;
155 2784739 : break;
156 1226916 : case 2:
157 1226916 : hStereoMdct->IGFStereoMode[k] = SMDCT_BW_MS;
158 1226916 : break;
159 0 : default:
160 0 : assert( !"Not supported stereo mode\n" );
161 : }
162 :
163 6106516 : set_s( &ms_mask[k][sfbConf->nBandsStereoCore], ( hStereoMdct->IGFStereoMode[k] == SMDCT_MS_FULL ) ? 1 : 0, sfbConf->sfbCnt - sfbConf->nBandsStereoCore );
164 :
165 6106516 : if ( hStereoMdct->IGFStereoMode[k] == SMDCT_BW_MS )
166 : {
167 8316670 : for ( i = sfbConf->nBandsStereoCore; i < sfbConf->sfbCnt; i++ )
168 : {
169 7089754 : ms_mask[k][i] = get_next_indice( st0, 1 );
170 : }
171 : }
172 : }
173 : else
174 : {
175 2921399 : hStereoMdct->IGFStereoMode[k] = SMDCT_DUAL_MONO;
176 : }
177 : }
178 : }
179 :
180 10979909 : if ( !mct_on )
181 : {
182 5175882 : hStereoMdct->split_ratio = SMDCT_EQUAL_RATIO_RANGE; /* Equal bits to both channels */
183 5175882 : hStereoMdct->split_ratio = get_next_indice( st0, SMDCT_NBBITS_SPLIT_RATIO );
184 :
185 5175882 : 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 10979909 : 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 8970290 : 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 8970290 : STEREO_MDCT_BAND_PARAMETERS *sfbConf = NULL;
228 : float nrgRatio;
229 :
230 8970290 : nSubframes = 2;
231 8970290 : if ( ( core_l <= TCX_20_CORE && core_r <= TCX_20_CORE ) || tmp_plc_upmix )
232 : {
233 8729896 : nSubframes = 1;
234 : }
235 :
236 18180974 : for ( k = 0; k < nSubframes; k++ )
237 : {
238 9210684 : sfbConf = ( core_l == TCX_20_CORE ) ? &hStereoMdct->stbParamsTCX20 : &hStereoMdct->stbParamsTCX10;
239 :
240 9210684 : if ( last_core_l == ACELP_CORE || last_core_r == ACELP_CORE )
241 : {
242 37082 : sfbConf = &hStereoMdct->stbParamsTCX20afterACELP;
243 : }
244 :
245 9210684 : if ( mdct_stereo_mode[k] == SMDCT_MS_FULL )
246 : {
247 3099546738 : for ( i = 0; i < sfbConf->sfbOffset[sfbConf->nBandsStereoCore]; i++ )
248 : {
249 3093359372 : if ( spec_r_0[k][i] == 0.0f )
250 : {
251 1035807060 : spec_r[k][i] *= NF_RED_FAC;
252 : }
253 : }
254 6187366 : inverseMS( sfbConf->sfbOffset[sfbConf->nBandsStereoCore], spec_l[k], spec_r[k], SQRT2_OVER_2 );
255 : }
256 3023318 : else if ( mdct_stereo_mode[k] == SMDCT_BW_MS )
257 : {
258 111891437 : for ( sfb = 0; sfb < sfbConf->nBandsStereoCore; sfb++ )
259 : {
260 109210775 : if ( ms_mask[k][sfb] )
261 : {
262 941715132 : for ( i = sfbConf->sfbOffset[sfb]; i < sfbConf->sfbOffset[sfb + 1]; i++ )
263 : {
264 873824472 : if ( spec_r_0[k][i] == 0.0f )
265 : {
266 275732780 : spec_r[k][i] *= NF_RED_FAC;
267 : }
268 : }
269 67890660 : 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 9210684 : if ( igf )
281 : {
282 6197001 : if ( hStereoMdct->IGFStereoMode[k] == SMDCT_MS_FULL )
283 : {
284 889311202 : for ( i = sfbConf->sfbOffset[sfbConf->nBandsStereoCore]; i < sfbConf->sfbOffset[sfbConf->sfbCnt]; i++ )
285 : {
286 886491202 : if ( spec_r_0[k][i] == 0.0f )
287 : {
288 256568632 : spec_r[k][i] *= NF_RED_FAC;
289 : }
290 : }
291 2820000 : 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 3377001 : else if ( hStereoMdct->IGFStereoMode[k] == SMDCT_BW_MS )
294 : {
295 8390830 : for ( sfb = sfbConf->nBandsStereoCore; sfb < sfbConf->sfbCnt; sfb++ )
296 : {
297 7154591 : if ( ms_mask[k][sfb] )
298 : {
299 181136593 : for ( i = sfbConf->sfbOffset[sfb]; i < sfbConf->sfbOffset[sfb + 1]; i++ )
300 : {
301 177359088 : if ( spec_r_0[k][i] == 0.0f )
302 : {
303 49882420 : spec_r[k][i] *= NF_RED_FAC;
304 : }
305 : }
306 3777505 : 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 9210684 : if ( !mct_on )
319 : {
320 3266111 : nrgRatio = (float) SMDCT_ILD_RANGE / hStereoMdct->global_ild[k] - 1; /* nrgRatio = nrg[1]/nrg[0] */
321 3266111 : 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 3266111 : if ( hStereoMdct->smooth_ratio > 1.3f )
324 : {
325 666815 : hStereoMdct->reverse_dmx = 1;
326 : }
327 2599296 : else if ( hStereoMdct->smooth_ratio < 0.9f )
328 : {
329 678712 : hStereoMdct->reverse_dmx = 0;
330 : }
331 :
332 3266111 : if ( ( nrgRatio > 1.0f ) && ( k < ( ( core_r == TCX_10_CORE ) ? NB_DIV : 1 ) ) )
333 : {
334 1045475 : v_multc( spec_r[k], nrgRatio, spec_r[k], L_frameTCX_r );
335 : }
336 2220636 : else if ( ( nrgRatio < 1.0f ) && ( k < ( ( core_l == TCX_10_CORE ) ? NB_DIV : 1 ) ) )
337 : {
338 771919 : v_multc( spec_l[k], 1.0f / nrgRatio, spec_l[k], L_frameTCX_l );
339 : }
340 : }
341 : } /* for k */
342 :
343 8970290 : return;
344 : }
345 :
346 :
347 : /*-------------------------------------------------------------------*
348 : * inverseBwMS()
349 : *
350 : * Band-wise M/S stereo processing
351 : *-------------------------------------------------------------------*/
352 :
353 82862977 : 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 5148929723 : for ( j = startLine; j < stopLine; j++ )
365 : {
366 5066066746 : tmpValue = x0[j];
367 5066066746 : x0[j] = ( x0[j] + x1[j] ) * norm_fac;
368 5066066746 : x1[j] = ( tmpValue - x1[j] ) * norm_fac;
369 : }
370 :
371 82862977 : return;
372 : }
373 :
374 :
375 : /*-------------------------------------------------------------------*
376 : * inverseMS()
377 : *
378 : * M/S stereo processing
379 : *-------------------------------------------------------------------*/
380 :
381 11194812 : 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 11194812 : inverseBwMS( 0, L_frame, x0, x1, norm_fac );
389 :
390 11194812 : return;
391 : }
392 :
393 :
394 : /*-------------------------------------------------------------------*
395 : * initMdctStereoDecData()
396 : *
397 : * Initialize MDCT stereo decoder configuration
398 : *-------------------------------------------------------------------*/
399 :
400 18668780 : 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 18668780 : tcx_coded_lines = getNumTcxCodedLines( bwidth );
411 :
412 : /*Initialize sfb parameteres for TCX20 */
413 18668780 : 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 18668780 : 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 18668780 : 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 18668780 : if ( igf )
422 : {
423 : /* calculate the igf start band from the igf start line */
424 10118808 : stereo_mdct_init_igf_start_band( &( hStereoMdct->stbParamsTCX20 ), 1.0f, bwidth, element_brate );
425 10118808 : stereo_mdct_init_igf_start_band( &( hStereoMdct->stbParamsTCX10 ), 0.5f, bwidth, element_brate );
426 10118808 : stereo_mdct_init_igf_start_band( &( hStereoMdct->stbParamsTCX20afterACELP ), 1.25f, bwidth, element_brate );
427 : }
428 : else
429 : {
430 8549972 : hStereoMdct->stbParamsTCX20.sfbIgfStart = -1;
431 8549972 : hStereoMdct->stbParamsTCX10.sfbIgfStart = -1;
432 8549972 : hStereoMdct->stbParamsTCX20afterACELP.sfbIgfStart = -1;
433 8549972 : hStereoMdct->stbParamsTCX10.nBandsStereoCore = hStereoMdct->stbParamsTCX10.sfbCnt;
434 8549972 : hStereoMdct->stbParamsTCX20.nBandsStereoCore = hStereoMdct->stbParamsTCX20.sfbCnt;
435 8549972 : hStereoMdct->stbParamsTCX20afterACELP.nBandsStereoCore = hStereoMdct->stbParamsTCX20afterACELP.sfbCnt;
436 : }
437 :
438 18668780 : return;
439 : }
440 :
441 :
442 : /*-------------------------------------------------------------------*
443 : * initMdctStereoDtxData()
444 : *
445 : * Allocate and initialize structures for MDCT-Stereo DTX operation
446 : *-------------------------------------------------------------------*/
447 :
448 323 : ivas_error initMdctStereoDtxData(
449 : CPE_DEC_HANDLE hCPE /* i/o: CPE handle */
450 : )
451 : {
452 : int16_t ch;
453 : ivas_error error;
454 :
455 323 : error = IVAS_ERR_OK;
456 :
457 969 : for ( ch = 0; ch < CPE_CHANNELS; ch++ )
458 : {
459 646 : DEC_CORE_HANDLE st = hCPE->hCoreCoder[ch];
460 :
461 646 : 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 646 : if ( st->first_CNG == 0 )
474 : {
475 628 : if ( ch == 1 && st->cng_sba_flag )
476 : {
477 202 : st->hFdCngDec->hFdCngCom->seed += 3;
478 : }
479 : }
480 :
481 646 : if ( st->cldfbAna == NULL )
482 : {
483 : /* open analysis for max. sampling rate 48kHz */
484 452 : if ( ( error = openCldfb( &st->cldfbAna, CLDFB_ANALYSIS, 48000, CLDFB_PROTOTYPE_1_25MS ) ) != IVAS_ERR_OK )
485 : {
486 0 : return error;
487 : }
488 : }
489 :
490 646 : if ( st->cldfbBPF == NULL )
491 : {
492 : /* open analysis BPF for max. internal sampling rate 16kHz */
493 452 : 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 323 : return error;
501 : }
502 :
503 : /*-------------------------------------------------------------------*
504 : * synchonize_channels_mdct_sid()
505 : *
506 : * Synchronize channels in SID frame in MDCT stereo
507 : *-------------------------------------------------------------------*/
508 :
509 58841440 : 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 58841440 : st = sts[n];
517 :
518 58841440 : if ( st->element_mode == IVAS_CPE_MDCT && st->total_brate == SID_2k40 )
519 : {
520 12492 : if ( n == 1 )
521 : {
522 : /* synchronize channels */
523 6246 : sts[1]->L_frame = sts[0]->L_frame;
524 6246 : sts[1]->cng_type = sts[0]->cng_type;
525 6246 : sts[1]->bwidth = sts[0]->bwidth;
526 6246 : 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 6246 : 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 6246 : 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 12492 : 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 610 : configureFdCngDec( st->hFdCngDec, st->bwidth, st->element_brate, st->L_frame, st->last_L_frame, st->element_mode );
540 : }
541 : }
542 :
543 58841440 : 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 13830 : 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 13830 : sts[0] = hCPE->hCoreCoder[0];
566 13830 : sts[1] = hCPE->hCoreCoder[1];
567 :
568 : /* synch buffers for inactive frames, but not for transition frames */
569 13830 : if ( hCPE->last_element_brate <= IVAS_SID_5k2 )
570 : {
571 13309 : mvr2r( output[0], output[1], output_frame );
572 13309 : mvr2r( synth[0], synth[1], output_frame );
573 : }
574 :
575 13830 : 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 12602 : for ( int16_t p = 0; p < sts[0]->hFdCngDec->hFdCngCom->npart; p++ )
579 : {
580 12081 : 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 13830 : if ( hCPE->last_element_brate <= IVAS_SID_5k2 )
586 : {
587 13309 : delta = 1;
588 13309 : if ( output_frame == L_FRAME16k )
589 : {
590 4050 : delta = 2;
591 : }
592 9259 : else if ( output_frame == L_FRAME32k )
593 : {
594 4201 : delta = 4;
595 : }
596 5058 : else if ( output_frame == L_FRAME48k )
597 : {
598 5058 : delta = 6;
599 : }
600 :
601 13309 : delay_buf_out_len = delta * HQ_DELAY_COMP;
602 13309 : tcxltp_mem_in_len = NS2SA( sts[0]->output_Fs, TCXLTP_DELAY_NS );
603 :
604 13309 : assert( delay_buf_out_len > tcxltp_mem_in_len );
605 :
606 123813 : for ( i = 0; i < tcxltp_mem_in_len; i++ )
607 : {
608 110504 : sts[0]->hTcxLtpDec->tcxltp_mem_in[i] = INV_SQRT2 * ( sts[0]->hTcxLtpDec->tcxltp_mem_in[i] + sts[1]->hTcxLtpDec->tcxltp_mem_in[i] );
609 110504 : sts[0]->delay_buf_out[i] = INV_SQRT2 * ( sts[0]->delay_buf_out[i] + sts[1]->delay_buf_out[i] );
610 110504 : sts[0]->hHQ_core->old_out[i] = INV_SQRT2 * ( sts[0]->hHQ_core->old_out[i] + sts[1]->hHQ_core->old_out[i] );
611 110504 : 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 455325 : for ( ; i < delay_buf_out_len; i++ )
614 : {
615 442016 : sts[0]->delay_buf_out[i] = INV_SQRT2 * ( sts[0]->delay_buf_out[i] + sts[1]->delay_buf_out[i] );
616 442016 : sts[0]->hHQ_core->old_out[i] = INV_SQRT2 * ( sts[0]->hHQ_core->old_out[i] + sts[1]->hHQ_core->old_out[i] );
617 442016 : 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 8301109 : for ( ; i < output_frame; i++ )
620 : {
621 8287800 : sts[0]->hHQ_core->old_out[i] = INV_SQRT2 * ( sts[0]->hHQ_core->old_out[i] + sts[1]->hHQ_core->old_out[i] );
622 8287800 : 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 13830 : 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 240850 : 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 240850 : step = 1.f;
648 240850 : fade = 1.f;
649 240850 : dmx_len = output_frame;
650 :
651 240850 : if ( hCPE->last_element_brate <= IVAS_SID_5k2 )
652 : {
653 502 : crossfade_len = NS2SA( hCPE->hCoreCoder[0]->output_Fs, IVAS_DEC_DELAY_NS - DELAY_CLDFB_NS );
654 502 : 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 240348 : else if ( hCPE->element_brate <= IVAS_SID_5k2 && hCPE->last_element_brate > IVAS_SID_5k2 )
658 : {
659 521 : crossfade_len = output_frame / 4;
660 521 : step /= -crossfade_len;
661 521 : fade = 0.f;
662 521 : dmx_len = crossfade_len;
663 : }
664 239827 : else if ( hCPE->last_element_mode == IVAS_CPE_DFT && hCPE->last_element_brate <= IVAS_32k )
665 : {
666 585 : crossfade_len = NS2SA( hCPE->hCoreCoder[0]->output_Fs, DELAY_CLDFB_NS );
667 585 : step /= crossfade_len;
668 : }
669 : else
670 : {
671 239242 : crossfade_len = 0;
672 : }
673 :
674 : /* apply crossfade */
675 400670 : for ( i = 0; i < crossfade_len; i++ )
676 : {
677 159820 : output[0][i] = output[0][i] * fade + ( output[0][i] + output[1][i] ) * INV_SQRT2 * ( 1 - fade );
678 159820 : fade -= step;
679 : }
680 :
681 : /* apply passive downmix on all-active-frame part */
682 181220710 : for ( ; i < dmx_len; i++ )
683 : {
684 180979860 : output[0][i] = ( output[0][i] + output[1][i] ) * INV_SQRT_2;
685 : }
686 :
687 240850 : return;
688 : }
|
