gugelfrei
/
android_frameworks_av
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

libeffects: Added multichannel support for volume balance

Browse Source 
Test: local native test (lvmtest)
Bug: 120941390
Change-Id: If982e03a57fb3a1e03d67f531c615bc016e7f3a5
gugelfrei
Saketh Sathuvalli 5 years ago committed by Andy Hung
parent 06709c6db6
commit 7b66e3b61a
13 changed files with 411 additions and 32 deletions
Show Stats Download Patch File Download Diff File

3
media/libeffects/lvm/lib/Android.bp
Unescape View File

@ -132,6 +132,9 @@ cc_library_static {
shared_libs: [
"liblog",
],
header_libs: [
"libhardware_headers"
],
cflags: [
"-fvisibility=hidden",
"-DBUILD_FLOAT",

1
media/libeffects/lvm/lib/Bundle/lib/LVM.h
Unescape View File

@ -298,6 +298,7 @@ typedef struct
LVM_PSA_DecaySpeed_en PSA_PeakDecayRate; /* Peak value decay rate*/
#ifdef SUPPORT_MC
LVM_INT32 NrChannels;
LVM_INT32 ChMask;
#endif
} LVM_ControlParams_t;

2
media/libeffects/lvm/lib/Bundle/src/LVM_Control.c
Unescape View File

@ -93,6 +93,7 @@ LVM_ReturnStatus_en LVM_SetControlParameters(LVM_Handle_t hInstance,
#ifdef SUPPORT_MC
pInstance->Params.NrChannels = pParams->NrChannels;
pInstance->Params.ChMask = pParams->ChMask;
#endif
/*
* Cinema Sound parameters
@ -584,6 +585,7 @@ LVM_ReturnStatus_en LVM_ApplyNewSettings(LVM_Handle_t hInstance)
#ifdef SUPPORT_MC
pInstance->NrChannels = LocalParams.NrChannels;
pInstance->ChMask = LocalParams.ChMask;
#endif
/* Clear all internal data if format change*/

1
media/libeffects/lvm/lib/Bundle/src/LVM_Private.h
Unescape View File

@ -291,6 +291,7 @@ typedef struct
#ifdef SUPPORT_MC
LVM_INT16 NrChannels;
LVM_INT32 ChMask;
#endif
} LVM_Instance_t;

32
media/libeffects/lvm/lib/Bundle/src/LVM_Process.c
Unescape View File

@ -21,6 +21,7 @@
/* Includes */
/* */
/****************************************************************************************/
#include <system/audio.h>
#include "LVM_Private.h"
#include "VectorArithmetic.h"
@ -67,6 +68,7 @@ LVM_ReturnStatus_en LVM_Process(LVM_Handle_t hInstance,
LVM_ReturnStatus_en Status;
#ifdef SUPPORT_MC
LVM_INT32 NrChannels = pInstance->NrChannels;
LVM_INT32 ChMask = pInstance->ChMask;
#define NrFrames SampleCount // alias for clarity
#endif
@ -119,6 +121,7 @@ LVM_ReturnStatus_en LVM_Process(LVM_Handle_t hInstance,
#ifdef SUPPORT_MC
/* Update the local variable NrChannels from pInstance->NrChannels value */
NrChannels = pInstance->NrChannels;
ChMask = pInstance->ChMask;
#endif
if(Status != LVM_SUCCESS)
@ -140,6 +143,7 @@ LVM_ReturnStatus_en LVM_Process(LVM_Handle_t hInstance,
pToProcess = pOutData;
#ifdef SUPPORT_MC
NrChannels = 2;
ChMask = AUDIO_CHANNEL_OUT_STEREO;
#endif
}
@ -254,18 +258,24 @@ LVM_ReturnStatus_en LVM_Process(LVM_Handle_t hInstance,
}
#ifdef SUPPORT_MC
/* TODO - Multichannel support to be added */
if (NrChannels == 2)
/*
* Volume balance
*/
LVC_MixSoft_1St_MC_float_SAT(&pInstance->VC_BalanceMix,
pProcessed,
pProcessed,
NrFrames,
NrChannels,
ChMask);
#else
/*
* Volume balance
*/
LVC_MixSoft_1St_2i_D16C31_SAT(&pInstance->VC_BalanceMix,
pProcessed,
pProcessed,
SampleCount);
#endif
{
/*
* Volume balance
*/
LVC_MixSoft_1St_2i_D16C31_SAT(&pInstance->VC_BalanceMix,
pProcessed,
pProcessed,
SampleCount);
}
/*
* Perform Parametric Spectum Analysis

25
media/libeffects/lvm/lib/Common/src/LVC_Core_MixHard_1St_2i_D16C31_SAT.c
Unescape View File

@ -59,6 +59,31 @@ void LVC_Core_MixHard_1St_2i_D16C31_SAT( LVMixer3_FLOAT_st *ptrInstance1,
}
#ifdef SUPPORT_MC
void LVC_Core_MixHard_1St_MC_float_SAT (Mix_Private_FLOAT_st **ptrInstance,
const LVM_FLOAT *src,
LVM_FLOAT *dst,
LVM_INT16 NrFrames,
LVM_INT16 NrChannels)
{
LVM_FLOAT Temp;
LVM_INT16 ii, jj;
for (ii = NrFrames; ii != 0; ii--)
{
for (jj = 0; jj < NrChannels; jj++)
{
Mix_Private_FLOAT_st *pInstance1 = (Mix_Private_FLOAT_st *)(ptrInstance[jj]);
Temp = ((LVM_FLOAT)*(src++) * (LVM_FLOAT)pInstance1->Current);
if (Temp > 1.0f)
*dst++ = 1.0f;
else if (Temp < -1.0f)
*dst++ = -1.0f;
else
*dst++ = (LVM_FLOAT)Temp;
}
}
}
#endif
#else
void LVC_Core_MixHard_1St_2i_D16C31_SAT( LVMixer3_st *ptrInstance1,
LVMixer3_st *ptrInstance2,

45
media/libeffects/lvm/lib/Common/src/LVC_Core_MixSoft_1St_2i_D16C31_WRA.c
Unescape View File

@ -146,6 +146,51 @@ void LVC_Core_MixSoft_1St_2i_D16C31_WRA( LVMixer3_FLOAT_st *ptrInstance1,
pInstanceR->Current = CurrentR;
}
#ifdef SUPPORT_MC
void LVC_Core_MixSoft_1St_MC_float_WRA (Mix_Private_FLOAT_st **ptrInstance,
const LVM_FLOAT *src,
LVM_FLOAT *dst,
LVM_INT16 NrFrames,
LVM_INT16 NrChannels)
{
LVM_INT32 ii, ch;
LVM_FLOAT Temp =0.0f;
LVM_FLOAT tempCurrent[NrChannels];
for (ch = 0; ch < NrChannels; ch++)
{
tempCurrent[ch] = ptrInstance[ch]->Current;
}
for (ii = NrFrames; ii > 0; ii--)
{
for (ch = 0; ch < NrChannels; ch++)
{
Mix_Private_FLOAT_st *pInstance = ptrInstance[ch];
const LVM_FLOAT Delta = pInstance->Delta;
LVM_FLOAT Current = tempCurrent[ch];
const LVM_FLOAT Target = pInstance->Target;
if (Current < Target)
{
ADD2_SAT_FLOAT(Current, Delta, Temp);
Current = Temp;
if (Current > Target)
Current = Target;
}
else
{
Current -= Delta;
if (Current < Target)
Current = Target;
}
*dst++ = *src++ * Current;
tempCurrent[ch] = Current;
}
}
for (ch = 0; ch < NrChannels; ch++)
{
ptrInstance[ch]->Current = tempCurrent[ch];
}
}
#endif
#else
void LVC_Core_MixSoft_1St_2i_D16C31_WRA( LVMixer3_st *ptrInstance1,
LVMixer3_st *ptrInstance2,

199
media/libeffects/lvm/lib/Common/src/LVC_MixSoft_1St_2i_D16C31_SAT.c
Unescape View File

@ -19,6 +19,8 @@
INCLUDE FILES
***********************************************************************************/
#include <system/audio.h>
#include "LVC_Mixer_Private.h"
#include "VectorArithmetic.h"
#include "ScalarArithmetic.h"
@ -30,10 +32,207 @@
#define TRUE 1
#define FALSE 0
#define ARRAY_SIZE(a) ((sizeof(a)) / (sizeof(*(a))))
/**********************************************************************************
FUNCTION LVC_MixSoft_1St_2i_D16C31_SAT
***********************************************************************************/
#ifdef BUILD_FLOAT
#ifdef SUPPORT_MC
/* This threshold is used to decide on the processing to be applied on
* front center and back center channels
*/
#define LVM_VOL_BAL_THR (0.000016f)
void LVC_MixSoft_1St_MC_float_SAT (LVMixer3_2St_FLOAT_st *ptrInstance,
const LVM_FLOAT *src,
LVM_FLOAT *dst,
LVM_INT16 NrFrames,
LVM_INT32 NrChannels,
LVM_INT32 ChMask)
{
char HardMixing = TRUE;
LVM_FLOAT TargetGain;
Mix_Private_FLOAT_st Target_lfe = {LVM_MAXFLOAT, LVM_MAXFLOAT, LVM_MAXFLOAT};
Mix_Private_FLOAT_st Target_ctr = {LVM_MAXFLOAT, LVM_MAXFLOAT, LVM_MAXFLOAT};
Mix_Private_FLOAT_st *pInstance1 = \
(Mix_Private_FLOAT_st *)(ptrInstance->MixerStream[0].PrivateParams);
Mix_Private_FLOAT_st *pInstance2 = \
(Mix_Private_FLOAT_st *)(ptrInstance->MixerStream[1].PrivateParams);
Mix_Private_FLOAT_st *pMixPrivInst[4] = {pInstance1, pInstance2, &Target_ctr, &Target_lfe};
Mix_Private_FLOAT_st *pInstance[NrChannels];
if (audio_channel_mask_get_representation(ChMask)
== AUDIO_CHANNEL_REPRESENTATION_INDEX)
{
for (int i = 0; i < 2; i++)
{
pInstance[i] = pMixPrivInst[i];
}
for (int i = 2; i < NrChannels; i++)
{
pInstance[i] = pMixPrivInst[2];
}
}
else
{
// TODO: Combine with system/media/audio_utils/Balance.cpp
// Constants in system/media/audio/include/system/audio-base.h
// 'mixInstIdx' is used to map the appropriate mixer instance for each channel.
const int mixInstIdx[] = {
0, // AUDIO_CHANNEL_OUT_FRONT_LEFT = 0x1u,
1, // AUDIO_CHANNEL_OUT_FRONT_RIGHT = 0x2u,
2, // AUDIO_CHANNEL_OUT_FRONT_CENTER = 0x4u,
3, // AUDIO_CHANNEL_OUT_LOW_FREQUENCY = 0x8u,
0, // AUDIO_CHANNEL_OUT_BACK_LEFT = 0x10u,
1, // AUDIO_CHANNEL_OUT_BACK_RIGHT = 0x20u,
0, // AUDIO_CHANNEL_OUT_FRONT_LEFT_OF_CENTER = 0x40u,
1, // AUDIO_CHANNEL_OUT_FRONT_RIGHT_OF_CENTER = 0x80u,
2, // AUDIO_CHANNEL_OUT_BACK_CENTER = 0x100u,
0, // AUDIO_CHANNEL_OUT_SIDE_LEFT = 0x200u,
1, // AUDIO_CHANNEL_OUT_SIDE_RIGHT = 0x400u,
2, // AUDIO_CHANNEL_OUT_TOP_CENTER = 0x800u,
0, // AUDIO_CHANNEL_OUT_TOP_FRONT_LEFT = 0x1000u,
2, // AUDIO_CHANNEL_OUT_TOP_FRONT_CENTER = 0x2000u,
1, // AUDIO_CHANNEL_OUT_TOP_FRONT_RIGHT = 0x4000u,
0, // AUDIO_CHANNEL_OUT_TOP_BACK_LEFT = 0x8000u,
2, // AUDIO_CHANNEL_OUT_TOP_BACK_CENTER = 0x10000u,
1, // AUDIO_CHANNEL_OUT_TOP_BACK_RIGHT = 0x20000u,
0, // AUDIO_CHANNEL_OUT_TOP_SIDE_LEFT = 0x40000u,
1, // AUDIO_CHANNEL_OUT_TOP_SIDE_RIGHT = 0x80000u
};
if (pInstance1->Target <= LVM_VOL_BAL_THR ||
pInstance2->Target <= LVM_VOL_BAL_THR)
{
Target_ctr.Target = 0.0f;
Target_ctr.Current = 0.0f;
Target_ctr.Delta = 0.0f;
}
const unsigned int idxArrSize = ARRAY_SIZE(mixInstIdx);
for (unsigned int i = 0, channel = ChMask; channel !=0 ; ++i)
{
const unsigned int idx = __builtin_ctz(channel);
if (idx < idxArrSize)
{
pInstance[i] = pMixPrivInst[mixInstIdx[idx]];
}
else
{
pInstance[i] = pMixPrivInst[2];
}
channel &= ~(1 << idx);
}
}
if (NrFrames <= 0) return;
/******************************************************************************
SOFT MIXING
*******************************************************************************/
if ((pInstance1->Current != pInstance1->Target) ||
(pInstance2->Current != pInstance2->Target))
{
// TODO: combine similar checks below.
if (pInstance1->Delta == LVM_MAXFLOAT
|| Abs_Float(pInstance1->Current - pInstance1->Target) < pInstance1->Delta)
{
/* Difference is not significant anymore. Make them equal. */
pInstance1->Current = pInstance1->Target;
TargetGain = pInstance1->Target;
LVC_Mixer_SetTarget(&(ptrInstance->MixerStream[0]), TargetGain);
}
else
{
/* Soft mixing has to be applied */
HardMixing = FALSE;
}
if (HardMixing == TRUE)
{
if (pInstance2->Delta == LVM_MAXFLOAT
|| Abs_Float(pInstance2->Current - pInstance2->Target) < pInstance2->Delta)
{
/* Difference is not significant anymore. Make them equal. */
pInstance2->Current = pInstance2->Target;
TargetGain = pInstance2->Target;
LVC_Mixer_SetTarget(&(ptrInstance->MixerStream[1]), TargetGain);
}
else
{
/* Soft mixing has to be applied */
HardMixing = FALSE;
}
}
if (HardMixing == FALSE)
{
LVC_Core_MixSoft_1St_MC_float_WRA (&pInstance[0],
src, dst, NrFrames, NrChannels);
}
}
/******************************************************************************
HARD MIXING
*******************************************************************************/
if (HardMixing == TRUE)
{
if ((pInstance1->Target == LVM_MAXFLOAT) && (pInstance2->Target == LVM_MAXFLOAT))
{
if (src != dst)
{
Copy_Float(src, dst, NrFrames*NrChannels);
}
}
else
{
LVC_Core_MixHard_1St_MC_float_SAT(&(pInstance[0]),
src, dst, NrFrames, NrChannels);
}
}
/******************************************************************************
CALL BACK
*******************************************************************************/
if (ptrInstance->MixerStream[0].CallbackSet)
{
if (Abs_Float(pInstance1->Current - pInstance1->Target) < pInstance1->Delta)
{
pInstance1->Current = pInstance1->Target; /* Difference is not significant anymore. \
Make them equal. */
TargetGain = pInstance1->Target;
LVC_Mixer_SetTarget(&ptrInstance->MixerStream[0], TargetGain);
ptrInstance->MixerStream[0].CallbackSet = FALSE;
if (ptrInstance->MixerStream[0].pCallBack != 0)
{
(*ptrInstance->MixerStream[0].pCallBack) (\
ptrInstance->MixerStream[0].pCallbackHandle,
ptrInstance->MixerStream[0].pGeneralPurpose,
ptrInstance->MixerStream[0].CallbackParam);
}
}
}
if (ptrInstance->MixerStream[1].CallbackSet)
{
if (Abs_Float(pInstance2->Current - pInstance2->Target) < pInstance2->Delta)
{
pInstance2->Current = pInstance2->Target; /* Difference is not significant anymore.
Make them equal. */
TargetGain = pInstance2->Target;
LVC_Mixer_SetTarget(&ptrInstance->MixerStream[1], TargetGain);
ptrInstance->MixerStream[1].CallbackSet = FALSE;
if (ptrInstance->MixerStream[1].pCallBack != 0)
{
(*ptrInstance->MixerStream[1].pCallBack) (\
ptrInstance->MixerStream[1].pCallbackHandle,
ptrInstance->MixerStream[1].pGeneralPurpose,
ptrInstance->MixerStream[1].CallbackParam);
}
}
}
}
#endif
void LVC_MixSoft_1St_2i_D16C31_SAT( LVMixer3_2St_FLOAT_st *ptrInstance,
const LVM_FLOAT *src,
LVM_FLOAT *dst,

8
media/libeffects/lvm/lib/Common/src/LVC_Mixer.h
Unescape View File

@ -224,6 +224,14 @@ void LVC_MixSoft_2St_D16C31_SAT( LVMixer3_2St_st *pInstance,
/* Gain values should not be more that 1.0 */
/**********************************************************************************/
#ifdef BUILD_FLOAT
#ifdef SUPPORT_MC
void LVC_MixSoft_1St_MC_float_SAT(LVMixer3_2St_FLOAT_st *pInstance,
const LVM_FLOAT *src,
LVM_FLOAT *dst, /* dst can be equal to src */
LVM_INT16 NrFrames,
LVM_INT32 NrChannels,
LVM_INT32 ChMask);
#endif
void LVC_MixSoft_1St_2i_D16C31_SAT(LVMixer3_2St_FLOAT_st *pInstance,
const LVM_FLOAT *src,
LVM_FLOAT *dst, /* dst can be equal to src */

14
media/libeffects/lvm/lib/Common/src/LVC_Mixer_Private.h
Unescape View File

@ -116,6 +116,13 @@ void LVC_Core_MixHard_2St_D16C31_SAT( LVMixer3_st *pInstance1,
/* Gain values should not be more that 1.0 */
/**********************************************************************************/
#ifdef BUILD_FLOAT
#ifdef SUPPORT_MC
void LVC_Core_MixSoft_1St_MC_float_WRA(Mix_Private_FLOAT_st **ptrInstance,
const LVM_FLOAT *src,
LVM_FLOAT *dst,
LVM_INT16 NrFrames,
LVM_INT16 NrChannels);
#endif
void LVC_Core_MixSoft_1St_2i_D16C31_WRA( LVMixer3_FLOAT_st *ptrInstance1,
LVMixer3_FLOAT_st *ptrInstance2,
const LVM_FLOAT *src,
@ -136,6 +143,13 @@ void LVC_Core_MixSoft_1St_2i_D16C31_WRA( LVMixer3_st *ptrInstance1,
/* Gain values should not be more that 1.0 */
/**********************************************************************************/
#ifdef BUILD_FLOAT
#ifdef SUPPORT_MC
void LVC_Core_MixHard_1St_MC_float_SAT(Mix_Private_FLOAT_st **ptrInstance,
const LVM_FLOAT *src,
LVM_FLOAT *dst,
LVM_INT16 NrFrames,
LVM_INT16 NrChannels);
#endif
void LVC_Core_MixHard_1St_2i_D16C31_SAT( LVMixer3_FLOAT_st *ptrInstance1,
LVMixer3_FLOAT_st *ptrInstance2,
const LVM_FLOAT *src,

20
media/libeffects/lvm/tests/build_and_run_all_unit_tests.sh
Unescape View File

@ -36,6 +36,10 @@ flags_arr=(
"-csE -tE"
"-csE -eqE" "-tE -eqE"
"-csE -tE -bE -M -eqE"
"-tE -eqE -vcBal:96 -M"
"-tE -eqE -vcBal:-96 -M"
"-tE -eqE -vcBal:0 -M"
"-tE -eqE -bE -vcBal:30 -M"
)
fs_arr=(
@ -60,22 +64,22 @@ for flags in "${flags_arr[@]}"
do
for fs in ${fs_arr[*]}
do
for ch in {1..8}
for chMask in {0..22}
do
adb shell $testdir/lvmtest -i:$testdir/sinesweepraw.raw \
-o:$testdir/sinesweep_$((ch))_$((fs)).raw -ch:$ch -fs:$fs $flags
-o:$testdir/sinesweep_$((chMask))_$((fs)).raw -chMask:$chMask -fs:$fs $flags
# two channel files should be identical to higher channel
# computation (first 2 channels).
# Do not compare cases where -bE is in flags (due to mono computation)
if [[ $flags != *"-bE"* ]] && [ "$ch" -gt 2 ]
if [[ $flags != *"-bE"* ]] && [[ "$chMask" -gt 1 ]]
then
adb shell cmp $testdir/sinesweep_2_$((fs)).raw \
$testdir/sinesweep_$((ch))_$((fs)).raw
elif [[ $flags == *"-bE"* ]] && [ "$ch" -gt 2 ]
adb shell cmp $testdir/sinesweep_1_$((fs)).raw \
$testdir/sinesweep_$((chMask))_$((fs)).raw
elif [[ $flags == *"-bE"* ]] && [[ "$chMask" -gt 1 ]]
then
adb shell $testdir/snr $testdir/sinesweep_2_$((fs)).raw \
$testdir/sinesweep_$((ch))_$((fs)).raw -thr:90.308998
adb shell $testdir/snr $testdir/sinesweep_1_$((fs)).raw \
$testdir/sinesweep_$((chMask))_$((fs)).raw -thr:90.308998
fi
done

92
media/libeffects/lvm/tests/lvmtest.cpp
Unescape View File

@ -24,6 +24,7 @@
#include <audio_utils/channels.h>
#include <audio_utils/primitives.h>
#include <log/log.h>
#include <system/audio.h>
#include "EffectBundle.h"
#include "LVM_Private.h"
@ -76,6 +77,8 @@
struct lvmConfigParams_t {
int samplingFreq = 44100;
int nrChannels = 2;
int chMask = AUDIO_CHANNEL_OUT_STEREO;
int vcBal = 0;
int fChannels = 2;
bool monoMode = false;
int bassEffectLevel = 0;
@ -87,9 +90,36 @@ struct lvmConfigParams_t {
LVM_Mode_en csEnable = LVM_MODE_OFF;
};
constexpr audio_channel_mask_t lvmConfigChMask[] = {
AUDIO_CHANNEL_OUT_MONO,
AUDIO_CHANNEL_OUT_STEREO,
AUDIO_CHANNEL_OUT_2POINT1,
AUDIO_CHANNEL_OUT_2POINT0POINT2,
AUDIO_CHANNEL_OUT_QUAD,
AUDIO_CHANNEL_OUT_QUAD_BACK,
AUDIO_CHANNEL_OUT_QUAD_SIDE,
AUDIO_CHANNEL_OUT_SURROUND,
(1 << 4) - 1,
AUDIO_CHANNEL_OUT_2POINT1POINT2,
AUDIO_CHANNEL_OUT_3POINT0POINT2,
AUDIO_CHANNEL_OUT_PENTA,
(1 << 5) - 1,
AUDIO_CHANNEL_OUT_3POINT1POINT2,
AUDIO_CHANNEL_OUT_5POINT1,
AUDIO_CHANNEL_OUT_5POINT1_BACK,
AUDIO_CHANNEL_OUT_5POINT1_SIDE,
(1 << 6) - 1,
AUDIO_CHANNEL_OUT_6POINT1,
(1 << 7) - 1,
AUDIO_CHANNEL_OUT_5POINT1POINT2,
AUDIO_CHANNEL_OUT_7POINT1,
(1 << 8) - 1,
};
void printUsage() {
printf("\nUsage: ");
printf("\n <exceutable> -i:<input_file> -o:<out_file> [options]\n");
printf("\n <executable> -i:<input_file> -o:<out_file> [options]\n");
printf("\nwhere, \n <inputfile> is the input file name");
printf("\n on which LVM effects are applied");
printf("\n <outputfile> processed output file");
@ -98,7 +128,34 @@ void printUsage() {
printf("\n -help (or) -h");
printf("\n Prints this usage information");
printf("\n");
printf("\n -ch:<process_channels> (1 through 8)\n\n");
printf("\n -chMask:<channel_mask>\n");
printf("\n 0 - AUDIO_CHANNEL_OUT_MONO");
printf("\n 1 - AUDIO_CHANNEL_OUT_STEREO");
printf("\n 2 - AUDIO_CHANNEL_OUT_2POINT1");
printf("\n 3 - AUDIO_CHANNEL_OUT_2POINT0POINT2");
printf("\n 4 - AUDIO_CHANNEL_OUT_QUAD");
printf("\n 5 - AUDIO_CHANNEL_OUT_QUAD_BACK");
printf("\n 6 - AUDIO_CHANNEL_OUT_QUAD_SIDE");
printf("\n 7 - AUDIO_CHANNEL_OUT_SURROUND");
printf("\n 8 - canonical channel index mask for 4 ch: (1 << 4) - 1");
printf("\n 9 - AUDIO_CHANNEL_OUT_2POINT1POINT2");
printf("\n 10 - AUDIO_CHANNEL_OUT_3POINT0POINT2");
printf("\n 11 - AUDIO_CHANNEL_OUT_PENTA");
printf("\n 12 - canonical channel index mask for 5 ch: (1 << 5) - 1");
printf("\n 13 - AUDIO_CHANNEL_OUT_3POINT1POINT2");
printf("\n 14 - AUDIO_CHANNEL_OUT_5POINT1");
printf("\n 15 - AUDIO_CHANNEL_OUT_5POINT1_BACK");
printf("\n 16 - AUDIO_CHANNEL_OUT_5POINT1_SIDE");
printf("\n 17 - canonical channel index mask for 6 ch: (1 << 6) - 1");
printf("\n 18 - AUDIO_CHANNEL_OUT_6POINT1");
printf("\n 19 - canonical channel index mask for 7 ch: (1 << 7) - 1");
printf("\n 20 - AUDIO_CHANNEL_OUT_5POINT1POINT2");
printf("\n 21 - AUDIO_CHANNEL_OUT_7POINT1");
printf("\n 22 - canonical channel index mask for 8 ch: (1 << 8) - 1");
printf("\n default 0");
printf("\n -vcBal:<Left Right Balance control in dB [-96 to 96 dB]>");
printf("\n -ve values reduce Right channel while +ve value reduces Left channel");
printf("\n default 0");
printf("\n -fch:<file_channels> (1 through 8)\n\n");
printf("\n -M");
printf("\n Mono mode (force all input audio channels to be identical)");
@ -298,6 +355,7 @@ int LvmBundle_init(struct EffectContext *pContext, LVM_ControlParams_t *params)
params->OperatingMode = LVM_MODE_ON;
params->SampleRate = LVM_FS_44100;
params->SourceFormat = LVM_STEREO;
params->ChMask = AUDIO_CHANNEL_OUT_STEREO;
params->SpeakerType = LVM_HEADPHONES;
pContext->pBundledContext->SampleRate = LVM_FS_44100;
@ -452,13 +510,13 @@ int lvmControl(struct EffectContext *pContext,
params->OperatingMode = LVM_MODE_ON;
params->SpeakerType = LVM_HEADPHONES;
const int nrChannels = plvmConfigParams->nrChannels;
params->NrChannels = nrChannels;
if (nrChannels == 1) {
params->ChMask = plvmConfigParams->chMask;
params->NrChannels = plvmConfigParams->nrChannels;
if (params->NrChannels == 1) {
params->SourceFormat = LVM_MONO;
} else if (nrChannels == 2) {
} else if (params->NrChannels == 2) {
params->SourceFormat = LVM_STEREO;
} else if (nrChannels > 2 && nrChannels <= 8) { // FCC_2 FCC_8
} else if (params->NrChannels > 2 && params->NrChannels <= 8) { // FCC_2 FCC_8
params->SourceFormat = LVM_MULTICHANNEL;
} else {
return -EINVAL;
@ -531,7 +589,7 @@ int lvmControl(struct EffectContext *pContext,
/* Volume Control parameters */
params->VC_EffectLevel = 0;
params->VC_Balance = 0;
params->VC_Balance = plvmConfigParams->vcBal;
/* Treble Enhancement parameters */
params->TE_OperatingMode = plvmConfigParams->trebleEnable;
@ -667,13 +725,21 @@ int main(int argc, const char *argv[]) {
return -1;
}
lvmConfigParams.samplingFreq = samplingFreq;
} else if (!strncmp(argv[i], "-ch:", 4)) {
const int nrChannels = atoi(argv[i] + 4);
if (nrChannels > 8 || nrChannels < 1) {
printf("Error: Unsupported number of channels : %d\n", nrChannels);
} else if (!strncmp(argv[i], "-chMask:", 8)) {
const int chMaskConfigIdx = atoi(argv[i] + 8);
if (chMaskConfigIdx < 0 || (size_t)chMaskConfigIdx >= std::size(lvmConfigChMask)) {
ALOGE("\nError: Unsupported Channel Mask : %d\n", chMaskConfigIdx);
return -1;
}
lvmConfigParams.nrChannels = nrChannels;
const audio_channel_mask_t chMask = lvmConfigChMask[chMaskConfigIdx];
lvmConfigParams.chMask = chMask;
lvmConfigParams.nrChannels = audio_channel_count_from_out_mask(chMask);
} else if (!strncmp(argv[i], "-vcBal:", 7)) {
const int vcBalance = atoi(argv[i] + 7);
if (vcBalance > 96 || vcBalance < -96) {
ALOGE("\nError: Unsupported volume balance value: %d\n", vcBalance);
}
lvmConfigParams.vcBal = vcBalance;
} else if (!strncmp(argv[i], "-fch:", 5)) {
const int fChannels = atoi(argv[i] + 5);
if (fChannels > 8 || fChannels < 1) {

1
media/libeffects/lvm/wrapper/Bundle/EffectBundle.cpp
Unescape View File

@ -1315,6 +1315,7 @@ int Effect_setConfig(EffectContext *pContext, effect_config_t *pConfig){
#ifdef SUPPORT_MC
ActiveParams.NrChannels = NrChannels;
ActiveParams.ChMask = pConfig->inputCfg.channels;
#endif
LvmStatus = LVM_SetControlParameters(pContext->pBundledContext->hInstance, &ActiveParams);

Write Preview
Loading…
Cancel
Save