Merge branch 'FhG/rend_cfg_lfe' into 'main' (ea0efc47) · Commits · IVAS Codec Public Collaboration / IVAS Codec

apps/renderer.c

+255 −0

Original line number	Diff line number	Diff line
		@@ -132,6 +132,14 @@ typedef struct
		bool quietModeEnabled;
		bool sceneDescriptionInput;
		float inputGainGlobal; /* Linear gain (not in dB) */
		#ifdef REND_CFG_LFE
		bool lfePanningEnabled;
		float lfeConfigGain; /* Linear gain (not in dB) */
		float lfeConfigAzimuth;
		float lfeConfigElevation;
		bool lfeCustomRoutingEnabled;
		char inLfePanningMatrixFile[RENDERER_MAX_CLI_ARG_LENGTH];
		#endif
		} CmdlnArgs;

		typedef enum
		@@ -146,7 +154,12 @@ typedef enum
		CmdLnOptionId_renderConfigFile,
		CmdLnOptionId_noDiegeticPan,
		CmdLnOptionId_orientationTracking,
		#ifdef REND_CFG_LFE
		CmdlnOptionId_lfePosition,
		CmdlnOptionId_lfeMatrix,
		#else
		CmdLnOptionId_customLfeRouting,
		#endif
		CmdLnOptionId_noDelayCmp,
		CmdLnOptionId_quietModeEnabled,
		CmdLnOptionId_inputMetadata,
		@@ -222,13 +235,26 @@ static const CmdLnParser_Option cliOptions[] = {
		.description = "Head orientation tracking type: 'ref' or 'avg' (only for BINAURAL and BINAURAL_ROOM) (todo: check implementation)",
		},
		{
		#ifdef REND_CFG_LFE
		.id = CmdlnOptionId_lfePosition,
		.match = "lfe_position",
		.matchShort = "lp",
		.description = "Output LFE position. Comma-delimited triplet of [gain, azimuth, elevation] where gain is linear (like --gain, -g) and azimuth, elevation are in degrees.\nIf specified, overrides the default behavior which attempts to map input to output LFE channel(s)",
		#else
		/* TODO(sgi): Replace with more configurable input, e.g. ask for a list of triplets: (gain, azimuth, elevation) to place LFE signal */
		/* rename to "lfeHandling" */
		.id = CmdLnOptionId_customLfeRouting,
		.match = "neverDropLfe",
		.matchShort = "ndl",
		.description = "[flag] If set, renderer tries to render LFE into other channels in an optimal way when rendering to configs w/o LFE",
		#endif
		},
		#ifdef REND_CFG_LFE
		{ .id = CmdlnOptionId_lfeMatrix,
		.match = "lfe_matrix",
		.matchShort = "lm",
		.description = "LFE panning matrix. File (CSV table) containing a matrix of dimensions [ num_input_lfe x num_output_channels ] with elements specifying linear routing gain (like --gain, -g). \nIf specified, overrides the output LFE position option and the default behavior which attempts to map input to output LFE channel(s)" },
		#endif
		{
		.id = CmdLnOptionId_noDelayCmp,
		.match = "no_delay_cmp",
		@@ -334,6 +360,12 @@ static void parseMetadata(
		IsmPositionProvider *positionProvider,
		MasaFileReader **masaReaders );

		#ifdef REND_CFG_LFE
		static ivas_error parseLfePanMtxFile(
		const char *lfeRoutingMatrixFilePath,
		IVAS_REND_LfePanMtx *lfePanMtx );
		#endif

		static void convert_backslash( char *str );

		static void remove_cr( char *str );
		@@ -550,6 +582,9 @@ int main(
		convert_backslash( args.inputFilePath );
		convert_backslash( args.outputFilePath );
		convert_backslash( args.headRotationFilePath );
		#ifdef REND_CFG_LFE
		convert_backslash( args.inLfePanningMatrixFile );
		#endif

		if ( !isEmptyString( args.headRotationFilePath ) )
		{
		@@ -656,6 +691,21 @@ int main(
		}
		}

		#ifdef REND_CFG_LFE
		IVAS_REND_LfePanMtx lfePanMatrix;

		/* parse input LFE panning matrix */
		if ( args.lfeCustomRoutingEnabled && !isEmptyString( args.inLfePanningMatrixFile ) )
		{
		/* TODO tmu: how should we handle this on CLI for multiple MC inputs? */
		if ( ( error = parseLfePanMtxFile( args.inLfePanningMatrixFile, &lfePanMatrix ) ) != IVAS_ERR_OK )
		{
		fprintf( stderr, "Error: %s\n", ivas_error_to_string( error ) );
		exit( -1 );
		}
		}
		#endif

		for ( i = 0; i < args.inConfig.numMultiChannelBuses; ++i )
		{
		if ( ( error = IVAS_REND_AddInput( hIvasRend, args.inConfig.multiChannelBuses[i].audioConfig, &mcIds[i] ) ) != IVAS_ERR_OK )
		@@ -679,7 +729,34 @@ int main(
		}
		}

		#ifdef REND_CFG_LFE
		/* set panning matrix for input LFE */
		if ( args.lfeCustomRoutingEnabled )
		{
		if ( args.lfePanningEnabled )
		{
		fprintf( stdout, "Warning LFE position specified as well as panning matrix! Ignoring position and using gains from panning matrix\n" );
		args.lfePanningEnabled = false;
		}

		if ( ( error = IVAS_REND_SetInputLfeMtx( hIvasRend, mcIds[i], (const IVAS_REND_LfePanMtx *) &lfePanMatrix ) ) != IVAS_ERR_OK )
		{
		fprintf( stderr, "Error: %s\n", ivas_error_to_string( error ) );
		exit( -1 );
		}
		}
		/* set panning gains for input LFE */
		else if ( args.lfePanningEnabled )
		{
		if ( ( error = IVAS_REND_SetInputLfePos( hIvasRend, mcIds[i], args.lfeConfigGain, args.lfeConfigAzimuth, args.lfeConfigElevation ) ) != IVAS_ERR_OK )
		{
		fprintf( stderr, "Error: %s\n", ivas_error_to_string( error ) );
		exit( -1 );
		}
		}
		#else
		/* TODO(sgi): Test custom LFE routing here */
		#endif
		}

		for ( i = 0; i < args.inConfig.numAudioObjects; ++i )
		@@ -1206,12 +1283,18 @@ static bool parseOutConfig(
		return true;
		}

		#ifdef REND_CFG_LFE
		static bool parseDiegeticPan(
		#else
		static int8_t parseDiegeticPan(
		#endif
		char *value,
		float *noDiegeticPan )
		{
		#ifndef REND_CFG_LFE
		int8_t success;
		success = 1;
		#endif
		to_upper( value );

		if ( ( strcmp( value, "CENTER" ) == 0 ) \|\| ( strchr( value, 'C' ) != NULL ) )
		@@ -1233,18 +1316,32 @@ static int8_t parseDiegeticPan(
		if ( noDiegeticPan > 1.0f \|\| noDiegeticPan < -1.0f )
		{
		fprintf( stderr, "Error: Incorrect value for panning option argument specified!\n\n" );
		#ifdef REND_CFG_LFE
		return false;
		#else
		success = 0;
		#endif
		}
		}
		#ifdef REND_CFG_LFE
		return false;
		#else
		return success ? 0 : -1;
		#endif
		}

		#ifdef REND_CFG_LFE
		static bool parseOrientationTracking(
		#else
		static int8_t parseOrientationTracking(
		#endif
		char *value,
		int8_t *tracking_type )
		{
		#ifndef REND_CFG_LFE
		int8_t success;
		success = 1;
		#endif

		to_upper( value );

		@@ -1259,10 +1356,18 @@ static int8_t parseOrientationTracking(
		else
		{
		fprintf( stderr, "Error: Invalid orientation tracking type %s \n\n", value );
		#ifdef REND_CFG_LFE
		return false;
		#else
		success = 0;
		#endif
		}

		#ifdef REND_CFG_LFE
		return true;
		#else
		return success ? 0 : -1;
		#endif
		}

		static IVAS_REND_AudioConfig parseAudioConfig(
		@@ -1357,6 +1462,54 @@ static IVAS_REND_AudioConfig parseAudioConfig(
		return IVAS_REND_AUDIO_CONFIG_UNKNOWN;
		}

		#ifdef REND_CFG_LFE
		static bool parseLfePositionConfig(
		const char *value,
		float *lfeGain,
		float *lfeAzimuth,
		float *lfeElevation )
		{
		uint8_t nvalues;
		const char *tok;
		float values[3];
		char config_string[RENDERER_MAX_METADATA_LINE_LENGTH];

		strncpy( config_string, value, RENDERER_MAX_METADATA_LINE_LENGTH );
		nvalues = 0;

		for ( tok = strtok( config_string, "," ); tok && *tok; tok = strtok( NULL, ",\n" ) )
		{
		while ( *tok == ' ' )
		{
		tok++;
		}

		if ( *tok == '\0' )
		{
		continue;
		}
		values[nvalues] = (float) atof( tok );
		nvalues++;

		/* ignore any additionally specified values */
		if ( nvalues == 3 )
		{
		break;
		}
		}

		if ( nvalues != 3 )
		{
		return false;
		}

		*lfeGain = values[0];
		*lfeAzimuth = values[1];
		*lfeElevation = values[2];
		return true;
		}
		#endif

		#ifndef FIX_293_EXT_RENDERER_CLI
		static const CmdLnParser_Option *findOptionById(
		const int32_t id )
		@@ -1456,6 +1609,15 @@ static CmdlnArgs defaultArgs(
		args.sceneDescriptionInput = false;
		args.inputGainGlobal = 1.0f;

		#ifdef REND_CFG_LFE
		args.lfePanningEnabled = false;
		args.lfeConfigGain = 1.0f;
		args.lfeConfigAzimuth = 0;
		args.lfeConfigElevation = 0;

		args.lfeCustomRoutingEnabled = false;
		clearString( args.inLfePanningMatrixFile );
		#endif
		return args;
		}

		@@ -1526,7 +1688,11 @@ static void parseOption(
		break;
		case CmdLnOptionId_noDiegeticPan:
		assert( numOptionValues == 1 );
		#ifdef REND_CFG_LFE
		if ( !parseDiegeticPan( optionValues[0], &args->noDiegeticPan ) )
		#else
		if ( parseDiegeticPan( optionValues[0], &args->noDiegeticPan ) != 0 )
		#endif
		{
		fprintf( stderr, "Unknown option for diegetic panning: %s\n", optionValues[0] );
		exit( -1 );
		@@ -1534,15 +1700,38 @@ static void parseOption(
		break;
		case CmdLnOptionId_orientationTracking:
		assert( numOptionValues == 1 );
		#ifdef REND_CFG_LFE
		if ( !parseOrientationTracking( optionValues[0], &args->orientationTracking ) )
		#else
		if ( parseOrientationTracking( optionValues[0], &args->orientationTracking ) != 0 )
		#endif
		{
		fprintf( stderr, "Unknown option for orientation tracking: %s\n", optionValues[0] );
		exit( -1 );
		}
		break;
		#ifdef REND_CFG_LFE
		case CmdlnOptionId_lfePosition:
		assert( numOptionValues == 1 );
		if ( !parseLfePositionConfig( optionValues[0], &args->lfeConfigGain, &args->lfeConfigAzimuth, &args->lfeConfigElevation ) )
		{
		fprintf( stderr, "Unknown or invalid option for LFE position: %s\n", optionValues[0] );
		exit( -1 );
		}
		args->lfePanningEnabled = true;
		break;
		#else
		case CmdLnOptionId_customLfeRouting:
		assert( 0 && "Not yet implemented in CLI" );
		#endif
		break;
		#ifdef REND_CFG_LFE
		case CmdlnOptionId_lfeMatrix:
		assert( numOptionValues == 1 );
		strncpy( args->inLfePanningMatrixFile, optionValues[0], RENDERER_MAX_CLI_ARG_LENGTH - 1 );
		args->lfeCustomRoutingEnabled = true;
		break;
		#endif
		case CmdLnOptionId_noDelayCmp:
		assert( numOptionValues == 0 );
		args->delayCompensationEnabled = false;
		@@ -2325,6 +2514,72 @@ static void printSupportedAudioConfigs()
		return;
		}

		#ifdef REND_CFG_LFE
		static ivas_error parseLfePanMtxFile(
		const char *lfeRoutingMatrixFilePath,
		IVAS_REND_LfePanMtx *lfePanMtx )
		{
		int16_t lfe_in, ch_out;
		const char *tok;
		char line[200]; /* > (10 chars * IVAS_MAX_OUTPUT_CHANNELS) i.e. "-999, " */
		FILE *mtxFile;

		if ( strlen( lfeRoutingMatrixFilePath ) < 1 )
		{
		return IVAS_ERR_FAILED_FILE_OPEN;
		}

		mtxFile = fopen( lfeRoutingMatrixFilePath, "r" );

		if ( !mtxFile )
		{
		return IVAS_ERR_FAILED_FILE_OPEN;
		}

		/* set default panning matrix to all zeros
		any subsequent issue in file reading will gracefully exit the function */
		for ( lfe_in = 0; lfe_in < IVAS_MAX_INPUT_LFE_CHANNELS; lfe_in++ )
		{
		set_zero( ( *lfePanMtx )[lfe_in], IVAS_MAX_OUTPUT_CHANNELS );
		}

		for ( lfe_in = 0, ch_out = 0; lfe_in < IVAS_MAX_INPUT_LFE_CHANNELS; lfe_in++ )
		{
		/* if EOF or a blank line is encountered, simply return */
		if ( ( fgets( line, 200, mtxFile ) == NULL ) && ( strcmp( line, "\n" ) == 0 ) && ( strcmp( line, "\r\n" ) == 0 ) )
		{
		fclose( mtxFile );
		return IVAS_ERR_OK;
		}

		for ( tok = strtok( line, "," ); tok && *tok; tok = strtok( NULL, ",\n" ) )
		{
		while ( *tok == ' ' )
		{
		tok++;
		}

		if ( *tok == '\0' )
		{
		continue;
		}
		if ( ch_out > IVAS_MAX_OUTPUT_CHANNELS )
		{
		break;
		}
		else
		{
		( *lfePanMtx )[lfe_in][ch_out] = (float) atof( tok );
		ch_out++;
		}
		}
		}

		fclose( mtxFile );
		return IVAS_ERR_OK;
		}
		#endif

		// VE2AT: possibly move these functions to cmdln_parser.c ?
		static void convert_backslash(
		char *str )

lib_com/options.h

+1 −0

Original line number	Diff line number	Diff line
		@@ -148,6 +148,7 @@
		#define FIX_I59_DELAY_ROUNDING /* Issue 59: rounding in sample domain instead of nanosec for IVAS_ENC_GetDelay() and IVAS_DEC_GetDelay() */
		#define FIX_FIX_I59 /* Issue 59: small fix concerning LFE delay rounding */
		#define FIX_245_RANGE_CODER_VOIP_MSAN /* Issue 245: fix use-of-uninitialized-value in range coder in VoIP mode */
		#define REND_CFG_LFE /* Issue 110: Configurable LFE handling for external renderer */
		#define FIX_235 /* Issue 235: Deallocation of HR filter memory separately for lib_rend (ROM) and lib_util (from file) */
		#define ENV_STAB_FIX /* Contribution 23: HQ envelope stability memory fix */
		#define STABILIZE_GIPD /* FhG: Contribution 22: gIPD stabilization */

lib_rend/lib_rend.c

+222 −20

Original line number	Diff line number	Diff line
		@@ -115,6 +115,18 @@ typedef struct
		rotation_matrix rot_mat_prev;
		} input_ism;

		#ifdef REND_CFG_LFE
		typedef struct
		{
		int16_t numLfeChannels;
		bool pan_lfe;
		float lfeInputGain;
		float lfeOutputAzimuth;
		float lfeOutputElevation;
		IVAS_REND_LfePanMtx lfePanMtx;
		} lfe_routing;
		#endif

		typedef struct
		{
		input_base base;
		@@ -128,7 +140,11 @@ typedef struct
		TDREND_WRAPPER tdRendWrapper;
		CREND_WRAPPER crendWrapper;
		rotation_gains rot_gains_prev;
		#ifdef REND_CFG_LFE
		lfe_routing lfeRouting;
		#else
		IVAS_REND_LfeRouting lfeRouting;
		#endif
		} input_mc;

		typedef struct
		@@ -606,6 +622,26 @@ static ivas_error getAmbisonicsOrder(
		return IVAS_ERR_OK;
		}

		static int32_t getNumLfeChannels(
		input_mc *inputMc )
		{
		switch ( inputMc->base.inConfig )
		{
		case IVAS_REND_AUDIO_CONFIG_5_1:
		case IVAS_REND_AUDIO_CONFIG_7_1:
		case IVAS_REND_AUDIO_CONFIG_5_1_2:
		case IVAS_REND_AUDIO_CONFIG_5_1_4:
		case IVAS_REND_AUDIO_CONFIG_7_1_4:
		return 1;
		case IVAS_REND_AUDIO_CONFIG_LS_CUSTOM:
		return inputMc->customLsInput.num_lfe;
		default:
		break;
		}

		return 0;
		}

		static ivas_error getNumNonLfeChannelsInSpeakerLayout(
		IVAS_REND_AudioConfig config,
		int16_t *numNonLfeChannels )
		@@ -1343,6 +1379,97 @@ static bool configsAreEqual(
		return configA == configB;
		}

		#ifdef REND_CFG_LFE
		static ivas_error updateLfePanGainsForMcOut(
		input_mc *inputMc,
		const IVAS_REND_AudioConfig outConfig )
		{
		int16_t i, numLfeIn, numOutChannels;
		ivas_error error;
		error = IVAS_ERR_OK;

		/* If panning is not required, simply return */
		if ( !inputMc->lfeRouting.pan_lfe )
		{
		return error;
		}

		numLfeIn = getNumLfeChannels( inputMc );

		if ( outConfig == IVAS_REND_AUDIO_CONFIG_LS_CUSTOM )
		{
		numOutChannels = inputMc->base.ctx.pCustomLsOut->num_spk + inputMc->base.ctx.pCustomLsOut->num_lfe;
		}
		else
		{
		if ( ( error = getAudioConfigNumChannels( outConfig, &numOutChannels ) ) != IVAS_ERR_OK )
		{
		return error;
		}
		}

		for ( i = 0; i < numLfeIn; i++ )
		{
		/* panning gains */
		if ( ( error = getEfapGains( *inputMc->base.ctx.pEfapOutWrapper,
		inputMc->lfeRouting.lfeOutputAzimuth,
		inputMc->lfeRouting.lfeOutputElevation,
		inputMc->lfeRouting.lfePanMtx[i] ) ) != IVAS_ERR_OK )
		{
		return error;
		}

		/* linear input gain */
		v_multc( inputMc->lfeRouting.lfePanMtx[i],
		inputMc->lfeRouting.lfeInputGain,
		inputMc->lfeRouting.lfePanMtx[i],
		numOutChannels );
		}

		return error;
		}

		static ivas_error updateLfePanGainsForAmbiOut(
		input_mc *inputMc,
		const IVAS_REND_AudioConfig outConfig )
		{
		int16_t i;
		int16_t numLfeIn, outAmbiOrder;
		ivas_error error;
		error = IVAS_ERR_OK;

		/* If panning is not required, simply return */
		if ( !inputMc->lfeRouting.pan_lfe )
		{
		return error;
		}

		if ( ( error = getAmbisonicsOrder( outConfig, &outAmbiOrder ) ) != IVAS_ERR_OK )
		{
		return error;
		}

		numLfeIn = getNumLfeChannels( inputMc );

		for ( i = 0; i < numLfeIn; i++ )
		{
		/* panning gains */
		ivas_dirac_dec_get_response( inputMc->lfeRouting.lfeOutputAzimuth,
		inputMc->lfeRouting.lfeOutputElevation,
		inputMc->lfeRouting.lfePanMtx[i],
		outAmbiOrder );

		/* linear input gain */
		v_multc( inputMc->lfeRouting.lfePanMtx[i],
		inputMc->lfeRouting.lfeInputGain,
		inputMc->lfeRouting.lfePanMtx[i],
		IVAS_MAX_OUTPUT_CHANNELS );
		}

		return error;
		}
		#endif

		static ivas_error updateMcPanGainsForMcOut(
		input_mc *inputMc,
		const IVAS_REND_AudioConfig outConfig )
		@@ -1384,6 +1511,17 @@ static ivas_error updateMcPanGainsForMcOut(
		error = initMcPanGainsWithConversionMapping( inputMc, outConfig );
		}

		#ifdef REND_CFG_LFE
		/* check for errors from above block */
		if ( error != IVAS_ERR_OK )
		{
		return error;
		}

		/* update LFE panning */
		error = updateLfePanGainsForMcOut( inputMc, outConfig );
		#endif

		return error;
		}

		@@ -1446,6 +1584,14 @@ static ivas_error updateMcPanGainsForAmbiOut(
		}
		}

		#ifdef REND_CFG_LFE
		/* update LFE panning */
		if ( ( error = updateLfePanGainsForAmbiOut( inputMc, outConfig ) ) != IVAS_ERR_OK )
		{
		return error;
		}
		#endif

		return IVAS_ERR_OK;
		}

		@@ -1495,13 +1641,13 @@ static ivas_error updateMcPanGains(
		{
		for ( i = 0; i < inputMc->customLsInput.num_lfe; ++i )
		{
		mvr2r( inputMc->lfeRouting.lfeOutputGains[i], inputMc->panGains[inputMc->customLsInput.lfe_idx[i]], IVAS_MAX_OUTPUT_CHANNELS );
		mvr2r( inputMc->lfeRouting.lfePanMtx[i], inputMc->panGains[inputMc->customLsInput.lfe_idx[i]], IVAS_MAX_OUTPUT_CHANNELS );
		}
		}
		else
		{
		/* For code simplicity, always copy LFE gains. If config has no LFE, gains will be zero anyway. */
		mvr2r( inputMc->lfeRouting.lfeOutputGains[0], inputMc->panGains[LFE_CHANNEL], IVAS_MAX_OUTPUT_CHANNELS );
		mvr2r( inputMc->lfeRouting.lfePanMtx[0], inputMc->panGains[LFE_CHANNEL], IVAS_MAX_OUTPUT_CHANNELS );
		}

		return IVAS_ERR_OK;
		@@ -1578,22 +1724,35 @@ static ivas_error initMcBinauralRendering(
		return error;
		}

		#ifdef REND_CFG_LFE
		static lfe_routing defaultLfeRouting(
		#else
		static IVAS_REND_LfeRouting defaultLfeRouting(
		#endif
		IVAS_REND_AudioConfig inConfig,
		LSSETUP_CUSTOM_STRUCT customLsIn,
		IVAS_REND_AudioConfig outConfig,
		LSSETUP_CUSTOM_STRUCT customLsOut )
		{
		int32_t i;
		#ifdef REND_CFG_LFE
		lfe_routing routing;
		#else
		IVAS_REND_LfeRouting routing;
		#endif

		/* Set all output gains to zero, then route each input LFE consecutively to the next available output LFE. */

		for ( i = 0; i < IVAS_MAX_INPUT_LFE_CHANNELS; ++i )
		{
		set_zero( routing.lfeOutputGains[i], IVAS_MAX_OUTPUT_CHANNELS );
		set_zero( routing.lfePanMtx[i], IVAS_MAX_OUTPUT_CHANNELS );
		}

		#ifdef REND_CFG_LFE
		routing.pan_lfe = false;
		routing.lfeInputGain = 1.0f;
		#endif

		switch ( inConfig )
		{
		case IVAS_REND_AUDIO_CONFIG_5_1:
		@@ -1617,12 +1776,12 @@ static IVAS_REND_LfeRouting defaultLfeRouting(
		case IVAS_REND_AUDIO_CONFIG_5_1_4:
		case IVAS_REND_AUDIO_CONFIG_7_1:
		case IVAS_REND_AUDIO_CONFIG_7_1_4:
		routing.lfeOutputGains[0][LFE_CHANNEL] = 1.0f;
		routing.lfePanMtx[0][LFE_CHANNEL] = 1.0f;
		break;
		case IVAS_REND_AUDIO_CONFIG_LS_CUSTOM:
		for ( i = 0; i < routing.numLfeChannels && i < customLsOut.num_lfe; ++i )
		{
		routing.lfeOutputGains[i][customLsOut.lfe_idx[i]] = 1.0f;
		routing.lfePanMtx[i][customLsOut.lfe_idx[i]] = 1.0f;
		}
		break;
		default:
		@@ -2888,30 +3047,66 @@ ivas_error IVAS_REND_SetInputGain(
		return IVAS_ERR_OK;
		}

		static int32_t getNumLfeChannels(
		input_mc *inputMc )
		#ifdef REND_CFG_LFE
		ivas_error IVAS_REND_SetInputLfeMtx(
		IVAS_REND_HANDLE hIvasRend,
		const IVAS_REND_InputId inputId,
		const IVAS_REND_LfePanMtx *lfePanMtx )
		{
		switch ( inputMc->base.inConfig )
		int16_t i;
		input_base *pInputBase;
		input_mc *pInputMc;
		ivas_error error;

		/-----------------------------------------------------------------
		* Validate function arguments
		-----------------------------------------------------------------/

		if ( hIvasRend == NULL )
		{
		case IVAS_REND_AUDIO_CONFIG_5_1:
		case IVAS_REND_AUDIO_CONFIG_7_1:
		case IVAS_REND_AUDIO_CONFIG_5_1_2:
		case IVAS_REND_AUDIO_CONFIG_5_1_4:
		case IVAS_REND_AUDIO_CONFIG_7_1_4:
		return 1;
		case IVAS_REND_AUDIO_CONFIG_LS_CUSTOM:
		return inputMc->customLsInput.num_lfe;
		default:
		break;
		return IVAS_ERR_UNEXPECTED_NULL_POINTER;
		}
		if ( ( error = getInputById( hIvasRend, inputId, (void **) &pInputBase ) ) != IVAS_ERR_OK )
		{
		return error;
		}
		if ( getAudioConfigType( pInputBase->inConfig ) != IVAS_REND_AUDIO_CONFIG_TYPE_CHANNEL_BASED )
		{
		/* Custom LFE panning matrix only makes sense with channel-based input */
		return IVAS_ERR_INVALID_INPUT_FORMAT;
		}
		pInputMc = (input_mc *) pInputBase;

		return 0;
		/* copy LFE panning matrix */
		for ( i = 0; i < IVAS_MAX_INPUT_LFE_CHANNELS; i++ )
		{
		mvr2r( ( *lfePanMtx )[i], pInputMc->lfeRouting.lfePanMtx[i], IVAS_MAX_OUTPUT_CHANNELS );
		}

		if ( ( error = updateMcPanGains( pInputMc, hIvasRend->outputConfig ) ) != IVAS_ERR_OK )
		{
		return error;
		}

		return IVAS_ERR_OK;
		}
		#endif

		#ifdef REND_CFG_LFE
		ivas_error IVAS_REND_SetInputLfePos(
		#else
		ivas_error IVAS_REND_SetInputLfeRouting(
		#endif
		IVAS_REND_HANDLE hIvasRend,
		const IVAS_REND_InputId inputId,
		const IVAS_REND_LfeRouting lfeRouting )
		#ifdef REND_CFG_LFE
		const float inputGain,
		const float outputAzimuth,
		const float outputElevation
		#else
		const IVAS_REND_LfeRouting lfeRouting
		#endif
		)
		{
		input_base *pInputBase;
		input_mc *pInputMc;
		@@ -2936,12 +3131,19 @@ ivas_error IVAS_REND_SetInputLfeRouting(
		}
		pInputMc = (input_mc *) pInputBase;

		#ifdef REND_CFG_LFE
		pInputMc->lfeRouting.pan_lfe = true;
		pInputMc->lfeRouting.lfeInputGain = inputGain;
		pInputMc->lfeRouting.lfeOutputAzimuth = outputAzimuth;
		pInputMc->lfeRouting.lfeOutputElevation = outputElevation;
		#else
		if ( getNumLfeChannels( pInputMc ) != lfeRouting.numLfeChannels )
		{
		return IVAS_ERR_WRONG_NUM_CHANNELS;
		}

		pInputMc->lfeRouting = lfeRouting;
		#endif
		if ( ( error = updateMcPanGains( pInputMc, hIvasRend->outputConfig ) ) != IVAS_ERR_OK )
		{
		return error;

lib_rend/lib_rend.h

+24 −0

Original line number	Diff line number	Diff line
		@@ -49,6 +49,10 @@

		#define RENDERER_HEAD_POSITIONS_PER_FRAME 4

		#ifdef REND_CFG_LFE
		typedef float IVAS_REND_LfePanMtx[IVAS_MAX_INPUT_LFE_CHANNELS][IVAS_MAX_OUTPUT_CHANNELS];
		#endif

		typedef struct
		{
		int16_t numSamplesPerChannel;
		@@ -133,11 +137,13 @@ typedef enum

		typedef uint16_t IVAS_REND_InputId;

		#ifndef REND_CFG_LFE
		typedef struct
		{
		int16_t numLfeChannels;
		float lfeOutputGains[IVAS_MAX_INPUT_LFE_CHANNELS][IVAS_MAX_OUTPUT_CHANNELS];
		} IVAS_REND_LfeRouting;
		#endif

		/* clang-format off */
		/----------------------------------------------------------------------------------
		@@ -191,10 +197,28 @@ ivas_error IVAS_REND_SetInputGain(
		const float gain /* i : linear gain (not in dB) */
		);

		#ifdef REND_CFG_LFE
		ivas_error IVAS_REND_SetInputLfeMtx(
		IVAS_REND_HANDLE hIvasRend, /* i/o: Renderer handle */
		const IVAS_REND_InputId inputId, /* i : ID of the input */
		const IVAS_REND_LfePanMtx lfePanMtx / i : LFE panning matrix */
		);
		#endif

		#ifdef REND_CFG_LFE
		ivas_error IVAS_REND_SetInputLfePos(
		#else
		ivas_error IVAS_REND_SetInputLfeRouting(
		#endif
		IVAS_REND_HANDLE hIvasRend, /* i/o: Renderer handle */
		const IVAS_REND_InputId inputId, /* i : ID of the input */
		#ifdef REND_CFG_LFE
		const float inputGain, /* i : Input gain to be applied to the LFE channel(s) */
		const float outputAzimuth, /* i : Output azimuth position */
		const float outputElevation /* i : Output elevation position */
		#else
		const IVAS_REND_LfeRouting lfeRouting /* i : custom LFE routing struct */
		#endif
		);

		ivas_error IVAS_REND_RemoveInput(