upmix working with subframes used in jbm decoder path; fixed number of tc... (a7aa869d) · Commits · IVAS Codec Public Collaboration / IVAS Codec

lib_com/ivas_prot.h

+16 −0

Original line number	Diff line number	Diff line
		@@ -3877,6 +3877,22 @@ void ivas_mc_paramupmix_dec_read_BS(
		int16_t nb_bits / o : number of bits written */
		);

		#ifdef JBM_PARAMUPMIX
		void ivas_mc_paramupmix_dec_digest_tc(
		Decoder_Struct st_ivas, / i/o: IVAS decoder handle */
		const uint8_t nCldfbSlots /* i : number of CLFBS slots in the transport channels */
		);

		void ivas_mc_paramupmix_dec_render(
		Decoder_Struct st_ivas, / i/o: IVAS decoder handle */
		const uint16_t nSamplesAsked, /* i : number of CLDFB slots requested */
		uint16_t nSamplesRendered, / o : number of CLDFB slots rendered */
		uint16_t nSamplesAvailable, / o : number of CLDFB slots still to render */
		float input_f[], / i: core-coder transport channels */
		float output_f[] / i/o: synthesized core-coder transport channels */
		);
		#endif

		void ivas_param_mc_metadata_open(
		const MC_LS_SETUP mc_ls_setup, /* i : MC ls setup */
		const int16_t lfe_index, /* i : channel index of LFE */

lib_dec/ivas_jbm_dec.c

+62 −54

Original line number	Diff line number	Diff line
		@@ -381,8 +381,11 @@ ivas_error ivas_jbm_dec_tc(

		mvr2r( output_lfe_ch, output[LFE_CHANNEL], output_frame );

		//ivas_mc_paramupmix_dec( st_ivas, output );

		/* Rendering */
		if ( st_ivas->renderer_type == RENDERER_MC )
		{
		if ( output_config == AUDIO_CONFIG_MONO \|\| output_config == AUDIO_CONFIG_STEREO )
		{
		/* HP filtering */
		for ( n = 0; n < st_ivas->nchan_transport; n++ )
		{
		@@ -391,55 +394,10 @@ ivas_error ivas_jbm_dec_tc(
		hp20( output[n], output_frame, st_ivas->mem_hp20_out[n], output_Fs );
		}
		}

		if ( st_ivas->transport_config != st_ivas->intern_config && ( st_ivas->intern_config == AUDIO_CONFIG_FOA \|\| st_ivas->intern_config == AUDIO_CONFIG_HOA2 \|\| st_ivas->intern_config == AUDIO_CONFIG_HOA3 ) )
		{
		ivas_mc2sba( st_ivas->hTransSetup, p_output, p_output, output_frame, st_ivas->hIntSetup.ambisonics_order, GAIN_LFE );
		}

		/* Rendering */
		if ( output_config == AUDIO_CONFIG_MONO \|\| output_config == AUDIO_CONFIG_STEREO )
		{
		ivas_ls_setup_conversion( st_ivas, audioCfg2channels( AUDIO_CONFIG_5_1_2 ), output_frame, p_output, p_output );
		}
		#if 0
		/* Rendering */
		if ( st_ivas->renderer_type == RENDERER_BINAURAL_MIXER_CONV \|\| st_ivas->renderer_type == RENDERER_BINAURAL_MIXER_CONV_ROOM )
		{
		if ( ( error = ivas_rend_crendProcess( st_ivas->hCrendWrapper, st_ivas->intern_config, st_ivas->hOutSetup.output_config, st_ivas->hDecoderConfig,
		st_ivas->hCombinedOrientationData,
		&st_ivas->hIntSetup, st_ivas->hEFAPdata, p_output, output_Fs ) ) != IVAS_ERR_OK )
		{
		return error;
		}

		ivas_binaural_add_LFE( st_ivas, output_frame, p_output, p_output );
		}
		else if ( st_ivas->renderer_type == RENDERER_MC )
		{
		if ( ( st_ivas->hDecoderConfig->output_config == AUDIO_CONFIG_MONO ) \|\| ( st_ivas->hDecoderConfig->output_config == AUDIO_CONFIG_STEREO ) )
		{
		ivas_ls_setup_conversion( st_ivas, audioCfg2channels( AUDIO_CONFIG_5_1_2 ), output_frame, p_output, p_output );
		}
		else
		{
		ivas_ls_setup_conversion( st_ivas, MC_PARAMUPMIX_MAX_INPUT_CHANS, output_frame, p_output, p_output );
		}
		}
		else if ( st_ivas->renderer_type == RENDERER_SBA_LINEAR_ENC )
		{
		ivas_mc2sba( st_ivas->hIntSetup, p_output, p_output, output_frame, st_ivas->hOutSetup.ambisonics_order, 0.f );
		}
		else if ( st_ivas->renderer_type == RENDERER_BINAURAL_OBJECTS_TD )
		{
		if ( ( ivas_td_binaural_renderer( st_ivas, p_output, output_frame ) ) != IVAS_ERR_OK )
		{
		return error;
		}

		ivas_binaural_add_LFE( st_ivas, output_frame, p_output, p_output );
		}
		#endif
		}
		#endif
		else if ( st_ivas->mc_mode == MC_MODE_PARAMMC )
		@@ -673,7 +631,7 @@ ivas_error ivas_jbm_dec_feed_tc_to_renderer(
		#ifdef JBM_PARAMUPMIX
		else if ( st_ivas->mc_mode == MC_MODE_PARAMUPMIX )
		{
		ivas_param_upmix_dec_decorr_subframes( st_ivas );
		ivas_mc_paramupmix_dec_digest_tc( st_ivas, (uint8_t) n_render_timeslots );
		}
		#endif
		else if ( st_ivas->mc_mode == MC_MODE_PARAMMC )
		@@ -928,7 +886,51 @@ ivas_error ivas_jbm_dec_render(
		#ifdef JBM_PARAMUPMIX
		else if ( st_ivas->mc_mode == MC_MODE_PARAMUPMIX )
		{
		*nSamplesRendered = min( st_ivas->hTcBuffer->n_samples_available, nSamplesAskedLocal );
		ivas_mc_paramupmix_dec_render( st_ivas, nSamplesAskedLocal, nSamplesRendered, nSamplesAvailableNext, p_tc, p_output );

		/* HP filtering */
		for ( n = 0; n < st_ivas->nchan_transport; n++ )
		{
		if ( n != LFE_CHANNEL )
		{
		hp20( p_output[n], *nSamplesRendered, st_ivas->mem_hp20_out[n], output_Fs );
		}
		}

		if ( st_ivas->transport_config != st_ivas->intern_config && ( st_ivas->intern_config == AUDIO_CONFIG_FOA \|\| st_ivas->intern_config == AUDIO_CONFIG_HOA2 \|\| st_ivas->intern_config == AUDIO_CONFIG_HOA3 ) )
		{
		ivas_mc2sba( st_ivas->hTransSetup, p_output, p_output, *nSamplesRendered, st_ivas->hIntSetup.ambisonics_order, GAIN_LFE );
		}

		/* Rendering */
		if ( st_ivas->renderer_type == RENDERER_BINAURAL_MIXER_CONV \|\| st_ivas->renderer_type == RENDERER_BINAURAL_MIXER_CONV_ROOM )
		{
		if ( ( error = ivas_rend_crendProcessSubframe( st_ivas->hCrendWrapper, st_ivas->intern_config, st_ivas->hOutSetup.output_config, st_ivas->hDecoderConfig,
		st_ivas->hCombinedOrientationData,
		&st_ivas->hIntSetup, st_ivas->hEFAPdata, st_ivas->hTcBuffer, p_output, p_output, *nSamplesRendered, output_Fs ) ) != IVAS_ERR_OK )
		{
		return error;
		}

		ivas_binaural_add_LFE( st_ivas, *nSamplesRendered, p_output, p_output );
		}
		else if ( st_ivas->renderer_type == RENDERER_MC )
		{
		ivas_ls_setup_conversion( st_ivas, MC_PARAMUPMIX_MAX_INPUT_CHANS, *nSamplesRendered, p_output, p_output );
		}
		else if ( st_ivas->renderer_type == RENDERER_SBA_LINEAR_ENC )
		{
		ivas_mc2sba( st_ivas->hIntSetup, p_output, p_output, *nSamplesRendered, st_ivas->hOutSetup.ambisonics_order, 0.f );
		}
		else if ( st_ivas->renderer_type == RENDERER_BINAURAL_OBJECTS_TD )
		{
		if ( ( ivas_td_binaural_renderer( st_ivas, p_output, *nSamplesRendered ) ) != IVAS_ERR_OK )
		{
		return error;
		}

		ivas_binaural_add_LFE( st_ivas, *nSamplesRendered, p_output, p_output );
		}
		}
		#endif
		else if ( st_ivas->mc_mode == MC_MODE_PARAMMC )
		@@ -1489,6 +1491,12 @@ int16_t ivas_jbm_dec_get_num_tc_channels(
		num_tc = st_ivas->hOutSetup.nchan_out_woLFE + st_ivas->hOutSetup.num_lfe;
		}
		}
		#ifdef JBM_PARAMUPMIX
		else if ( st_ivas->mc_mode == MC_MODE_PARAMUPMIX )
		{
		num_tc = MC_PARAMUPMIX_MAX_INPUT_CHANS;
		}
		#endif
		else if ( st_ivas->mc_mode == MC_MODE_MCMASA )
		{
		if ( st_ivas->hOutSetup.separateChannelEnabled )

lib_dec/ivas_mc_paramupmix_dec.c

+291 −6

Original line number	Diff line number	Diff line
		@@ -55,6 +55,14 @@

		static void ps_pred_process( MC_PARAMUPMIX_DEC_HANDLE hMCParamUpmix, float qmf_mod_re[CLDFB_NO_COL_MAX][CLDFB_NO_CHANNELS_MAX], float qmf_mod_im[CLDFB_NO_COL_MAX][CLDFB_NO_CHANNELS_MAX], float qmf_side_re[CLDFB_NO_COL_MAX][CLDFB_NO_CHANNELS_MAX], float qmf_side_im[CLDFB_NO_COL_MAX][CLDFB_NO_CHANNELS_MAX], const int16_t ch );

		#ifdef JBM_PARAMUPMIX
		static void ps_pred_process_sf( MC_PARAMUPMIX_DEC_HANDLE hMCParamUpmix, DECODER_TC_BUFFER_HANDLE hTcBuffer, float qmf_mod_re[JBM_CLDFB_SLOTS_IN_SUBFRAME][CLDFB_NO_CHANNELS_MAX], float qmf_mod_im[JBM_CLDFB_SLOTS_IN_SUBFRAME][CLDFB_NO_CHANNELS_MAX], float qmf_side_re[JBM_CLDFB_SLOTS_IN_SUBFRAME][CLDFB_NO_CHANNELS_MAX], float qmf_side_im[JBM_CLDFB_SLOTS_IN_SUBFRAME][CLDFB_NO_CHANNELS_MAX], float *param_interpol, const int16_t ch );

		static void ivas_mc_paramupmix_dec_sf( Decoder_Struct st_ivas, float output_f[MAX_OUTPUT_CHANNELS] );

		static void ivas_param_upmix_dec_decorr_subframes( Decoder_Struct *st_ivas );
		#endif

		static void paramupmix_td_decorr_process( ivas_td_decorr_state_t hTdDecorr[], float pcm_in[][L_FRAME48k], float *pp_out_pcm, const int16_t output_frame );

		static int huff_read( Decoder_State st, const int16_t ( ht )[2] );
		@@ -292,6 +300,99 @@ void ivas_mc_paramupmix_dec(
		}


		#ifdef JBM_PARAMUPMIX
		void ivas_mc_paramupmix_dec_digest_tc(
		Decoder_Struct st_ivas, / i/o: IVAS decoder handle */
		const uint8_t nCldfbSlots /* i : number of CLFBS slots in the transport channels */
		)
		{
		MC_PARAMUPMIX_DEC_HANDLE hMCParamUpmix;
		hMCParamUpmix = st_ivas->hMCParamUpmix;
		assert( hMCParamUpmix );

		push_wmops( "ivas_mc_paramupmix_dec_digest_tc" );

		ivas_param_upmix_dec_decorr_subframes( st_ivas );

		/* adapt subframes */
		ivas_jbm_dec_td_renderers_adapt_subframes( st_ivas );

		ivas_jbm_dec_get_adapted_linear_interpolator( DEFAULT_JBM_CLDFB_TIMESLOTS, nCldfbSlots, hMCParamUpmix->param_interpolator );

		pop_wmops();
		}


		void ivas_mc_paramupmix_dec_render(
		Decoder_Struct st_ivas, / i/o: IVAS decoder handle */
		const uint16_t nSamplesAsked, /* i : number of CLDFB slots requested */
		uint16_t nSamplesRendered, / o : number of CLDFB slots rendered */
		uint16_t nSamplesAvailable, / o : number of CLDFB slots still to render */
		float input_f[], / i: core-coder transport channels */
		float output_f[] / i/o: synthesized core-coder transport channels */
		)
		{
		int16_t slots_to_render, first_sf, last_sf, subframe_idx;
		uint16_t slot_size, ch;
		float *output_f_local[MAX_OUTPUT_CHANNELS];
		MC_PARAMUPMIX_DEC_HANDLE hMCParamUpmix;
		hMCParamUpmix = st_ivas->hMCParamUpmix;
		assert( hMCParamUpmix );

		push_wmops( "ivas_mc_paramupmix_dec_render" );

		for ( ch = 0; ch < MAX_OUTPUT_CHANNELS; ch++ )
		{
		output_f_local[ch] = output_f[ch];
		}

		slot_size = NS2SA( st_ivas->hDecoderConfig->output_Fs, CLDFB_SLOT_NS );

		/* loop for synthesis, assume we always have to render in multiples of 5ms subframes with spills */
		slots_to_render = min( st_ivas->hTcBuffer->num_slots - st_ivas->hTcBuffer->slots_rendered, nSamplesAsked / slot_size );
		nSamplesRendered = slots_to_render slot_size;
		first_sf = st_ivas->hTcBuffer->subframes_rendered;
		last_sf = first_sf;

		for ( ch = 0; ch < MAX_TRANSPORT_CHANNELS; ch++ )
		{
		mvr2r( input_f[ch], output_f_local[ch], *nSamplesRendered);
		}

		while ( slots_to_render > 0 )
		{
		slots_to_render -= st_ivas->hTcBuffer->subframe_nbslots[last_sf];
		last_sf++;
		}
		#ifdef DEBUGGING
		assert( slots_to_render == 0 );
		#endif

		for ( subframe_idx = first_sf; subframe_idx < last_sf; subframe_idx++ )
		{
		int16_t n_samples_sf = slot_size * st_ivas->hTcBuffer->subframe_nbslots[subframe_idx];

		ivas_mc_paramupmix_dec_sf( st_ivas, output_f_local );
		for ( ch = 0; ch < MAX_OUTPUT_CHANNELS; ch++ )
		{
		output_f_local[ch] += n_samples_sf;
		}
		}

		for ( ch = 0; ch < MC_PARAMUPMIX_COMBINATIONS; ch++ )
		{
		mvr2r( hMCParamUpmix->alphas[ch], hMCParamUpmix->alpha_prev[ch], IVAS_MAX_NUM_BANDS );
		mvr2r( hMCParamUpmix->betas[ch], hMCParamUpmix->beta_prev[ch], IVAS_MAX_NUM_BANDS );
		}

		nSamplesAvailable = ( st_ivas->hTcBuffer->num_slots - st_ivas->hTcBuffer->slots_rendered ) slot_size;

		pop_wmops();
		}
		#endif



		/*-------------------------------------------------------------------------
		* ivas_mc_paramupmix_dec_open()
		*
		@@ -307,10 +408,6 @@ ivas_error ivas_mc_paramupmix_dec_open(
		int16_t nchan_transport;
		uint16_t i;
		ivas_error error;
		#ifdef JBM_PARAMUPMIX
		int16_t num_channels_internal;
		num_channels_internal = MC_PARAMUPMIX_MAX_TRANSPORT_CHANS;
		#endif

		error = IVAS_ERR_OK;

		@@ -385,6 +482,11 @@ ivas_error ivas_mc_paramupmix_dec_open(
		{
		return error;
		}
		if ( ( hMCParamUpmix->param_interpolator = (float ) malloc( MAX_JBM_CLDFB_TIMESLOTS sizeof( float ) ) ) == NULL )
		{
		return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for interpolator\n" ) );
		}
		ivas_jbm_dec_get_adapted_linear_interpolator( DEFAULT_JBM_CLDFB_TIMESLOTS, DEFAULT_JBM_CLDFB_TIMESLOTS, hMCParamUpmix->param_interpolator );
		}
		#endif

		@@ -421,6 +523,12 @@ void ivas_mc_paramupmix_dec_close(
		free( ( *hMCParamUpmix )->pcm_delay[i] );
		}
		}
		#ifdef JBM_PARAMUPMIX
		if ( ( *hMCParamUpmix )->param_interpolator != NULL )
		{
		free( ( *hMCParamUpmix )->param_interpolator );
		}
		#endif
		free( *hMCParamUpmix );

		*hMCParamUpmix = NULL;
		@@ -479,7 +587,7 @@ static void paramupmix_td_decorr_process_jbm(
		return;
		}

		void ivas_param_upmix_dec_decorr_subframes(
		static void ivas_param_upmix_dec_decorr_subframes(
		Decoder_Struct st_ivas / i/o: IVAS decoder handle */
		)
		{
		@@ -487,7 +595,6 @@ void ivas_param_upmix_dec_decorr_subframes(
		int16_t i, ch;
		int32_t output_Fs;
		int16_t output_frame;
		float Pcm_decorr[MC_PARAMUPMIX_COMBINATIONS][L_FRAME48k]; /* decorrelated channels */
		float pPcm_temp[MC_PARAMUPMIX_COMBINATIONS 2]; /* decorrelated and undecorrelated*/
		float *p_tc[MC_PARAMUPMIX_MAX_INPUT_CHANS];

		@@ -584,6 +691,184 @@ static void ps_pred_process(
		return;
		}

		#ifdef JBM_PARAMUPMIX
		static void ps_pred_process_sf(
		MC_PARAMUPMIX_DEC_HANDLE hMCParamUpmix,
		DECODER_TC_BUFFER_HANDLE hTcBuffer,
		float qmf_mod_re[JBM_CLDFB_SLOTS_IN_SUBFRAME][CLDFB_NO_CHANNELS_MAX], /* in/out */
		float qmf_mod_im[JBM_CLDFB_SLOTS_IN_SUBFRAME][CLDFB_NO_CHANNELS_MAX],
		float qmf_side_re[JBM_CLDFB_SLOTS_IN_SUBFRAME][CLDFB_NO_CHANNELS_MAX], /* in/out */
		float qmf_side_im[JBM_CLDFB_SLOTS_IN_SUBFRAME][CLDFB_NO_CHANNELS_MAX],
		float *param_interpol,
		const int16_t ch )
		{
		float vmre, vmim, vsre, vsim;
		int16_t iqmf, ipar, ismp, iismp;
		float alpha_smp, beta_smp;
		float alpha1, alpha2;
		float beta1, beta2;
		float *alpha_prev = hMCParamUpmix->alpha_prev[ch];
		float *beta_prev = hMCParamUpmix->beta_prev[ch];

		const int16_t qmf_to_par_band[] = {
		0, 1, 2, 3, 4, 5, 5, 6, 6, 7,
		7, 7, 8, 8, 8, 8, 9, 9, 9, 9,
		9, 9, 10, 10, 10, 10, 10, 10, 10, 10,
		10, 10, 11, 11, 11, 11, 11, 11, 11, 11,
		11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
		11, 11, 11, 11, 11, 11, 11, 11, 11, 11
		};

		for ( iqmf = 0; iqmf < CLDFB_NO_CHANNELS_MAX; iqmf++ )
		{
		/* For changing no of parameter bands (ipar1 != ipar2), TIGGER_FRAMING assumed */
		ipar = qmf_to_par_band[iqmf];
		alpha1 = alpha_prev;
		beta1 = beta_prev;

		ismp = 0;
		alpha2 = hMCParamUpmix->alphas[ch];
		beta2 = hMCParamUpmix->betas[ch];
		alpha_smp = alpha1[ipar];
		beta_smp = beta1[ipar];

		for ( iismp = 0; iismp < hTcBuffer->subframe_nbslots[hTcBuffer->subframes_rendered]; iismp++ )
		{
		alpha_smp = alpha1[ipar] + ( alpha2[ipar] - alpha1[ipar] ) * param_interpol[iismp];
		beta_smp = beta1[ipar] + ( beta2[ipar] - beta1[ipar] ) * param_interpol[iismp];

		vmre = qmf_mod_re[ismp][iqmf];
		vmim = qmf_mod_im[ismp][iqmf];
		vsre = qmf_side_re[ismp][iqmf];
		vsim = qmf_side_im[ismp][iqmf];

		qmf_side_re[ismp][iqmf] = alpha_smp * vmre + beta_smp * vsre;
		qmf_side_im[ismp][iqmf] = alpha_smp * vmim + beta_smp * vsim;

		ismp++;
		}
		}

		return;
		}


		static void ivas_mc_paramupmix_dec_sf(
		Decoder_Struct st_ivas, / i/o: IVAS decoder handle */
		float output_f[MAX_OUTPUT_CHANNELS] / i/o: synthesized core-coder transport channels */
		)
		{
		int16_t i, ch, slot_idx, k;
		float pPcm_temp[MC_PARAMUPMIX_COMBINATIONS 2]; /* decorrelated and undecorrelated*/
		/CLDFB/
		float Cldfb_RealBuffer[MC_PARAMUPMIX_MAX_TRANSPORT_CHANS][JBM_CLDFB_SLOTS_IN_SUBFRAME][CLDFB_NO_CHANNELS_MAX];
		float Cldfb_ImagBuffer[MC_PARAMUPMIX_MAX_TRANSPORT_CHANS][JBM_CLDFB_SLOTS_IN_SUBFRAME][CLDFB_NO_CHANNELS_MAX];
		int16_t noparamupmix_delay, n_samples_rendered;
		MC_PARAMUPMIX_DEC_HANDLE hMCParamUpmix;
		hMCParamUpmix = st_ivas->hMCParamUpmix;
		assert( hMCParamUpmix );

		push_wmops( "ivas_mc_paramupmix_dec_sf" );

		for ( i = 0; i < MC_PARAMUPMIX_COMBINATIONS; i++ )
		{
		pPcm_temp[2 * i] = output_f[i + 4]; /* un-decorrelated */
		pPcm_temp[2 * i + 1] = output_f[i + 8]; /* decorrelated */
		}

		/* CLDFB Analysis*/
		for ( ch = 0; ch < MC_PARAMUPMIX_COMBINATIONS * 2; ch++ )
		{
		/* slot loop for gathering the input data */
		for ( slot_idx = 0; slot_idx < st_ivas->hTcBuffer->subframe_nbslots[st_ivas->hTcBuffer->subframes_rendered]; slot_idx++ )
		{
		cldfbAnalysis_ts( &( pPcm_temp[ch][hMCParamUpmix->num_freq_bands * slot_idx] ), Cldfb_RealBuffer[ch][slot_idx], Cldfb_ImagBuffer[ch][slot_idx], hMCParamUpmix->num_freq_bands, st_ivas->cldfbAnaDec[ch] );
		}
		}
		for ( ch = 0; ch < MC_PARAMUPMIX_COMBINATIONS; ch++ )
		{
		ps_pred_process_sf( hMCParamUpmix,
		st_ivas->hTcBuffer,
		Cldfb_RealBuffer[2 * ch], /* in/out */
		Cldfb_ImagBuffer[2 * ch],
		Cldfb_RealBuffer[2 * ch + 1], /* in/out decorr */
		Cldfb_ImagBuffer[2 * ch + 1],
		&hMCParamUpmix->param_interpolator[st_ivas->hTcBuffer->slots_rendered],
		ch );

		/-- m, s -> l, r ----------------------------/
		for ( slot_idx = 0; slot_idx < st_ivas->hTcBuffer->subframe_nbslots[st_ivas->hTcBuffer->subframes_rendered]; slot_idx++ )
		{
		for ( k = 0; k < CLDFB_NO_CHANNELS_MAX; k++ )
		{
		float qlre = Cldfb_RealBuffer[2 * ch][slot_idx][k];
		float qlim = Cldfb_ImagBuffer[2 * ch][slot_idx][k];
		float qrre = Cldfb_RealBuffer[2 * ch + 1][slot_idx][k];
		float qrim = Cldfb_ImagBuffer[2 * ch + 1][slot_idx][k];

		Cldfb_RealBuffer[2 * ch][slot_idx][k] = qlre + qrre;
		Cldfb_ImagBuffer[2 * ch][slot_idx][k] = qlim + qrim;
		Cldfb_RealBuffer[2 * ch + 1][slot_idx][k] = qlre - qrre;
		Cldfb_ImagBuffer[2 * ch + 1][slot_idx][k] = qlim - qrim;
		}
		}
		}
		/* boxes = { 0 1 2 3 [4 6] [5 7] [8 10] [9 11] }; */
		pPcm_temp[0] = output_f[4];
		pPcm_temp[1] = output_f[6];
		pPcm_temp[2] = output_f[5];
		pPcm_temp[3] = output_f[7];
		pPcm_temp[4] = output_f[8];
		pPcm_temp[5] = output_f[10];
		pPcm_temp[6] = output_f[9];
		pPcm_temp[7] = output_f[11];

		/* CLDFB synthesis */
		for ( ch = 0; ch < MC_PARAMUPMIX_COMBINATIONS * 2; ch++ )
		{
		for ( slot_idx = 0; slot_idx < st_ivas->hTcBuffer->subframe_nbslots[st_ivas->hTcBuffer->subframes_rendered]; slot_idx++ )
		{
		float ptr_im[1], ptr_re[1];
		ptr_re[0] = Cldfb_RealBuffer[ch][slot_idx];
		ptr_im[0] = Cldfb_ImagBuffer[ch][slot_idx];

		cldfbSynthesis( ptr_re, ptr_im, &( pPcm_temp[ch][hMCParamUpmix->num_freq_bands * slot_idx] ),
		hMCParamUpmix->num_freq_bands, st_ivas->cldfbSynDec[ch] );
		}
		}
		/* adjust delay of other channels */
		noparamupmix_delay = NS2SA( st_ivas->hDecoderConfig->output_Fs, IVAS_FB_DEC_DELAY_NS );
		n_samples_rendered = st_ivas->hTcBuffer->subframe_nbslots[st_ivas->hTcBuffer->subframes_rendered] * hMCParamUpmix->num_freq_bands;
		if (n_samples_rendered > noparamupmix_delay)
		{
		for ( ch = 0; ch < MC_PARAMUPMIX_COMBINATIONS; ch++ )
		{
		float tmp_buf[L_SUBFRAME5MS_48k];
		mvr2r( &output_f[ch][n_samples_rendered - noparamupmix_delay], tmp_buf, noparamupmix_delay );
		mvr2r( output_f[ch], &output_f[ch][noparamupmix_delay], n_samples_rendered - noparamupmix_delay );
		mvr2r( hMCParamUpmix->pcm_delay[ch], output_f[ch], noparamupmix_delay );
		mvr2r( tmp_buf, hMCParamUpmix->pcm_delay[ch], noparamupmix_delay );
		}
		}
		else
		{
		for ( ch = 0; ch < MC_PARAMUPMIX_COMBINATIONS; ch++ )
		{
		float tmp_buf[L_SUBFRAME5MS_48k];
		mvr2r( &output_f[ch][0], tmp_buf, n_samples_rendered );
		mvr2r( hMCParamUpmix->pcm_delay[ch], output_f[ch], n_samples_rendered );
		mvr2r( &hMCParamUpmix->pcm_delay[ch][n_samples_rendered], &hMCParamUpmix->pcm_delay[ch][0], noparamupmix_delay - n_samples_rendered );
		mvr2r( tmp_buf, &hMCParamUpmix->pcm_delay[ch][noparamupmix_delay-n_samples_rendered], n_samples_rendered );
		}
		}

		st_ivas->hTcBuffer->slots_rendered += st_ivas->hTcBuffer->subframe_nbslots[st_ivas->hTcBuffer->subframes_rendered];
		st_ivas->hTcBuffer->subframes_rendered++;

		pop_wmops();
		}
		#endif


		static void paramupmix_td_decorr_process(
		ivas_td_decorr_state_t hTdDecorr[], / i/o: SPAR Covar. decoder handle */

lib_dec/ivas_stat_dec.h

+3 −0

Original line number	Diff line number	Diff line
		@@ -802,6 +802,9 @@ typedef struct ivas_mc_paramupmix_dec_data_structure
		int32_t beta_quant[MC_PARAMUPMIX_COMBINATIONS][IVAS_MAX_NUM_BANDS];
		int16_t first_frame;
		float *pcm_delay[MC_PARAMUPMIX_MAX_TRANSPORT_CHANS];
		#ifdef JBM_PARAMUPMIX
		float *param_interpolator;
		#endif

		} MC_PARAMUPMIX_DEC_DATA, *MC_PARAMUPMIX_DEC_HANDLE;