Files

481 lines
15 KiB
C++
Raw Permalink Normal View History

2026-08-13 11:28:40 +08:00
/*
* Copyright (C) 2017 Amlogic Corporation.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef _DOLBY_MS12_CONFIG_PARAMS_H_
#define _DOLBY_MS12_CONFIG_PARAMS_H_
#include <stdbool.h>
#include <system/audio.h>
#include "dolby_ms12_config_parameter_struct.h"
#include "dolby_ms12_output_mask.h"
#include "dolby_ms12_input_mask.h"
#define DEFAULT_DAP_TUNING_FILE_NAME "/vendor/etc/ms12_tuning.dat"
#ifdef __cplusplus
namespace android
{
#define MS12_INPUT_MAIN 0
#define MS12_INPUT_MAIN2 1
#define MS12_INPUT_SYSTEM 2
#define MS12_INPUT_APP 3
#define MS12_INPUT_UI 4
#define MS12_INPUT_MAX 5
#define MIN_USER_CONTROL_VALUES (-32)
#define MAX_USER_CONTROL_VALUES (32)
#define MAX_MS12_INPUT_CMD_LEN 16
#define MS12_VERSION_24 2
#define MS12_VERSION_28 3
typedef struct ms12InputNameMaskTable_t {
char fileTypeCmd[MAX_MS12_INPUT_CMD_LEN];
int mask;
}
ms12InputTable_t;
class DolbyMS12ConfigParams
{
public:
DolbyMS12ConfigParams();
virtual ~DolbyMS12ConfigParams();
// static DolbyMS12ConfigParams* getInstance();
// static DolbyMS12ConfigParams *getInstance();
virtual void SetAudioStreamOutParams(audio_output_flags_t flags
, audio_format_t input_format
, audio_channel_mask_t channel_mask
, int sample_rate
, int output_format);
virtual int SetInputOutputFileName(char **ConfigParams, int *row_index);
virtual int SetFunctionalSwitches(char **ConfigParams, int *row_index);
virtual int SetPCMSwitches(char **ConfigParams, int *row_index);
virtual int SetDAPDeviceSwitches(char **ConfigParams, int *row_index, int is_runtime);
virtual int SetDAPContentSwitches(char **ConfigParams, int *row_index);
virtual char **GetDolbyMS12ConfigParams(int *argc, Config_Arg_Type_e arg_type);
virtual char **UpdateDolbyMS12RuntimeConfigParams(int *argc, char *cmd);
//init the mConfigParams Array
virtual char **PrepareConfigParams(int max_raw_size, int max_column_size);
//cleanup the mConfigParams Array
virtual void CleanupConfigParams(char **ConfigParams, int max_raw_size);
virtual int GetDolbyConfigOutputConfig(void)
{
return mDolbyMS12OutConfig;
}
virtual int GetDolbyConfigOutputSampleRate(void)
{
return mDolbyMS12OutSampleRate;
}
virtual audio_channel_mask_t GetDolbyConfigOutputChannelMask(void)
{
return mDolbyMS12OutChannelMask[MS12_INPUT_MAIN];
}
//associate flags
virtual void ResetConfigParams(Config_Arg_Type_e arg_type);
virtual int ChannelMask2ChannelConfig(audio_channel_mask_t channel_mask);
virtual int ChannelMask2LFEConfig(audio_channel_mask_t channel_mask);
//*Begin||Add the APT to set the params*//
//Functional Switches
//virtual void setLowComplexityNode(bool flag) { mLowComplexityMode = flag; }//did not use this part!
virtual void setDRCboostVal(int val)
{
mDRCBoost = val;
}
virtual void setDRCcutVal(int val)
{
mDRCCut = val;
}
virtual void setDRCboostStereoVal(int val)
{
mDRCBoostStereo = val;
}
virtual void setDRCcutStereoVal(int val)
{
mDRCCutStereo = val;
}
virtual void setDAPV2InitialisationMode(int val)
{
mDAPInitMode = val; // 0 or 1
}
virtual void setDAPV2InitialisationDAPTuningFile(char* dap_tuning_file_name)
{
if (dap_tuning_file_name != NULL) {
mDAPTuningFile = dap_tuning_file_name;
ALOGI("+%s(): str=%s mDAPTuningFile=%s\n", __FUNCTION__, dap_tuning_file_name, mDAPTuningFile);
} else {
ALOGE("+%s():mDAPTuningFile=%s\n", __FUNCTION__, mDAPTuningFile);
}
}
virtual void setDRCMode(int val)
{
mDRCModesOfDownmixedOutput = val; // 0 or 1
}
virtual void setDAPDRCMode(int val)
{
mDAPDRCMode = val; // 0 or 1
}
virtual void setDownmixModes(int val)
{
mDownmixMode = val; // 0 or 1
}
virtual void setEvaluationMode(int val)
{
mEvaluationMode = val; // 0 or 1
}
virtual void setLFEpresentInSystemSoundsIn(int val)
{
mLFEPresentInSystemSoundIn = val; // 0 or 1
}
virtual void setDownmix71PCMto51OnMultiOutputs(int val)
{
mDonwnmix71PCMto51 = val; //0 or 1
}
virtual void setEncoderChannelModeLockingMode(int val)
{
mLockingChannelModeENC = val; //0 or 1
}
virtual int getEncoderChannelModeLockingMode()
{
return mLockingChannelModeENC; //0 or 1
}
virtual void setRISCprecisionFlag(int val)
{
mRISCPrecisionFlag = val;
}
virtual void setSystemAppAudioMixing(int val)
{
mSystemAPPAudioMixing = val;
//ALOGI("%s() mSystemAPPAudioMixing %d\n", __FUNCTION__, mSystemAPPAudioMixing);
}
virtual int getSystemAppAudioMixing(void)
{
return mSystemAPPAudioMixing;
}
virtual void setSystemSoundMixerGainValuesForAppSoundsInput(MixGain *mixergain)
{
if (mixergain) {
memcpy(&mSysAppsMixGain, mixergain, sizeof(MixGain));
if (mSysAppsMixGain.target < -12288) {
mSysAppsMixGain.target = -12288;
}
ALOGI("%s() set target %d duration %d shape %d", __FUNCTION__, mSysAppsMixGain.target, mSysAppsMixGain.duration, mSysAppsMixGain.shape);
}
}
virtual void setSystemSoundMixerGainValuesForSystemSoundsInput(MixGain *mixergain)
{
if (mixergain) {
memcpy(&mSysSyssMixGain, mixergain, sizeof(MixGain));
if (mSysSyssMixGain.target < -12288) {
mSysSyssMixGain.target = -12288;
}
ALOGI("%s() set target %d duration %d shape %d", __FUNCTION__, mSysSyssMixGain.target, mSysSyssMixGain.duration, mSysSyssMixGain.shape);
}
}
//DDPLUS SWITCHES
#if 0
virtual void setDDPAssociatedSubstreamSelection(int val)
{
mDdplusAssocSubstream = val;
}
#endif
//PCM SWITCHES
virtual void setPCMCompressorProfile(int val)
{
mCompressorProfile = val;
}
//DAP SWITCHES (device specific)
virtual void setDAPGains(int val)
{
mDAPGains = val;
}
virtual void setDAPSurroundDecoderEnable(bool val)
{
mDAPSurDecEnable = val;
}
virtual void setDAPSurroundVirtualizer(DAPSurroundVirtualizer *dapVirtualizerParameters)
{
if (dapVirtualizerParameters) {
memcpy(&DeviceDAPSurroundVirtualizer, dapVirtualizerParameters, sizeof(DeviceDAPSurroundVirtualizer));
}
}
virtual int getDAPSurroundVirtualizer(void)
{
return DeviceDAPSurroundVirtualizer.virtualizer_enable;
}
virtual void setDAPGraphicEQ(DAPGraphicEQ *dapGraphicEQParameters)
{
if (dapGraphicEQParameters) {
memcpy(&DeviceDAPGraphicEQ, dapGraphicEQParameters, sizeof(DeviceDAPGraphicEQ));
}
}
virtual void setDAPBassEnhancer(DAPBassEnhancer *dapBassEnhancerParameters)
{
if (dapBassEnhancerParameters) {
memcpy(&DeviceDAPBassEnhancer, dapBassEnhancerParameters, sizeof(DeviceDAPBassEnhancer));
}
}
virtual void setDAPVirtualBass(DAPVirtualBass *dapVirtualBassParameters)
{
if (dapVirtualBassParameters) {
memcpy(&DeviceDAPVirtualBass, dapVirtualBassParameters, sizeof(DeviceDAPVirtualBass));
}
}
//DAP SWITCHES (content specific)
virtual void setDAPMISteering(DAPMISteering *dapMiSteeringParameters)
{
if (dapMiSteeringParameters) {
memcpy(&ContentDAPMISteering, dapMiSteeringParameters, sizeof(ContentDAPMISteering));
}
}
virtual void setDAPLeveler(DAPLeveler *dapLevelerParameters)
{
if (dapLevelerParameters) {
memcpy(&ContentDAPLeveler, dapLevelerParameters, sizeof(ContentDAPLeveler));
}
}
virtual void setDAPIEQ(DAPIEQ *dapIEQParameters)
{
if (dapIEQParameters) {
memcpy(&ContentDAPIEQ, dapIEQParameters, sizeof(ContentDAPIEQ));
}
}
virtual void setDAPDialogueEnhancer(DAPDialogueEnhancer *dapDialogueEnhancerParameters)
{
if (dapDialogueEnhancerParameters) {
memcpy(&ContentDAPDialogueEnhancer, dapDialogueEnhancerParameters, sizeof(ContentDAPDialogueEnhancer));
}
}
virtual void setAtmosLockFlag(bool flag)
{
mAtmosLock = flag;
ALOGI("%s() set mAtmosLock %d", __FUNCTION__, mAtmosLock);
}
virtual int getAtmosLockFlag(void)
{
return mAtmosLock;
}
/*OTT Processing Graph End*/
virtual void setLegacyDDPOut(bool isLegacyDDPOut)
{
mIsLegacyDDPOut = isLegacyDDPOut;
ALOGI("%s() mIsLegacyDDPOut %d\n", __FUNCTION__, mIsLegacyDDPOut);
}
virtual bool getLegacyDDPOut(void)
{
return mIsLegacyDDPOut;
}
virtual void setHDMIOutoutType(int HdmiOutputType)
{
mHdmiOutputType = HdmiOutputType;
ALOGI("%s() mHdmiOutputType %d\n", __FUNCTION__, mHdmiOutputType);
}
virtual void setDapOnly(int DapOnly)
{
mDapOnly = DapOnly;
ALOGI("%s() mDapOnly %d\n", __FUNCTION__, mDapOnly);
}
virtual void setHalContentProcess(int ContentProcessEnable)
{
mContentProcessEnable = ContentProcessEnable;
ALOGI("%s() mContentProcessEnable %d\n", __FUNCTION__, mContentProcessEnable);
}
virtual void setBitWidth(int bit_width)
{
mOutputBitDepth = bit_width;
ALOGI("%s() mOutputBitDepth %d\n", __FUNCTION__, bit_width);
}
virtual void setTVTuningFlag(bool tv_tuning_flag) {
mTVTuningFlag = tv_tuning_flag;
}
//*End||Add the APT to set the params*//
virtual void setVersion(int version)
{
mVersion = version;
ALOGI("%s() mVersion %d\n", __FUNCTION__, mVersion);
}
protected:
private:
int ms_get_int_array_from_str(char **p_csv_string, int num_el, int *p_vals);
int ms_get_int_from_str(char **p_csv_string, int *p_vals);
// DolbyMS12ConfigParams(const DolbyMS12ConfigParams&);
// DolbyMS12ConfigParams& operator = (const DolbyMS12ConfigParams&);
// static DolbyMS12ConfigParams *gInstance;
// static android::Mutex mLock;
// audio_devices_t mAudioSteamOutDevices;
int mParamNum;
int mRuntimeParamNum;
int mEncParamNum;
//dolby ms12 input
audio_output_flags_t mAudioOutFlags;
audio_format_t mAudioStreamOutFormat;
audio_channel_mask_t mDolbyMS12OutChannelMask[MS12_INPUT_MAX];
//dolby ms12 output
int mDolbyMS12OutConfig;
int mDolbyMS12OutSampleRate;
char **mConfigParams;//[MAX_ARGC][MAX_ARGV_STRING_LEN];
char **mRuntimeConfigParams;//[MAX_ARGC][MAX_ARGV_STRING_LEN];
char **mEncConfigParams;//[MAX_ARGC][MAX_ARGV_STRING_LEN];
// bool mMultiOutputFlag;
//bool mLowComplexityMode = false;
int mDRCBoost;
int mDRCCut;
int mDRCBoostStereo;
int mDRCCutStereo;
int mDAPInitMode;
int mDBGOut;//(default: none)
int mDRCModesOfDownmixedOutput;
int mDAPDRCMode;//for multi-ch and dap output[default is 0]
int mDownmixMode;//Lt/Rt[val=0, default] or Lo/Ro
int mEvaluationMode;//default is 0
int mLFEPresentInSystemSoundIn;//default is 0[means off]
int mDonwnmix71PCMto51;//default 0[means off]
int mLockingChannelModeENC;//0 default, auto; 1 locked as 5.1 channel mode.
int mRISCPrecisionFlag;//0 less&16bits for 16x32;1 high&32bits for 16x32
int mVerbosity;//here choose 0
int mOutputBitDepth;//here choose 16(bit)
int mSystemAPPAudioMixing;//0 off;1 on&default;
MixGain mSysPrimMixGain = {
.target = 0,
.duration = 0,
.shape = 0,
};//System sound mixer gain values for primary input (Input/AD mixer output)
MixGain mSysSyssMixGain = {
.target = 0,
.duration = 0,
.shape = 0,
};//System sound mixer gain values for System Sounds input
MixGain mSysAppsMixGain = {
.target = 0,
.duration = 0,
.shape = 0,
};//System sound mixer gain values for Application Sounds input
//DDPLUS SWITCHES
//PCM SWITCHES
int mCompressorProfile;//[pcm] Compressor profile
//DAP SWITCHES (device specific)
const char *mDAPTuningFile;
int mDAPGains = 0;//postgain (-2080...480, def: 0)
bool mDAPSurDecEnable = true;//DAP surround decoder enable flag (Default 1)
DAPSurroundVirtualizer DeviceDAPSurroundVirtualizer = {
.virtualizer_enable = 0,
.surround_boost = 96,
};
DAPGraphicEQ DeviceDAPGraphicEQ = {
.eq_enable = 0,
.eq_nb_bands = 10,
.eq_band_center = {32, 64, 125, 250, 500, 1000, 2000, 4000, 8000, 16000},
.eq_band_target = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
};
DAPBassEnhancer DeviceDAPBassEnhancer = {
.bass_enable = 0,
.bass_boost = 192,
.bass_cutoff = 200,
.bass_width = 16,
};
DAPVirtualBass DeviceDAPVirtualBass = {
.virtual_bass_mode = 0,
.virtual_bass_low_src_freq = 35,
.virtual_bass_high_src_freq = 160,
.virtual_bass_overall_gain = 0,
.virtual_bass_slope_gain = 0,
.virtual_bass_subgains = { -32, -144, -192},
.virtual_bass_low_mix_freq = 94,
.virtual_bass_high_mix_freq = 469,
};
//DAP SWITCHES (content specific)
DAPMISteering ContentDAPMISteering = {
.mi_enable = 0,
};
DAPLeveler ContentDAPLeveler = {
.leveler_enable = 0,
.leveler_amount = 4,
};
DAPIEQ ContentDAPIEQ = {
.ieq_enable = 0,
.ieq_amount = 10,
.ieq_nb_bands = 10,
.ieq_band_center = {32, 64, 125, 250, 500, 1000, 2000, 4000, 8000, 16000},
.ieq_band_target = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
};
DAPDialogueEnhancer ContentDAPDialogueEnhancer = {
.de_enable = 0,
.de_amount = 0,
};
bool mAtmosLock;
bool mIsLegacyDDPOut;
bool mTVTuningFlag;
bool mFullDAPDisable;
/*
DD/DD+ output is used for
0 = Full HDMI (default)
1 = HDMI ARC
2 = HDMI E-ARC
*/
int mHdmiOutputType;
int mDapOnly;
int mContentProcessEnable;
int mVersion;
int mFlapMaxRenderOutputs;
}; //class DolbyMS12ConfigParams
}//end of namespace android
#endif
#endif //end of _DOLBY_MS12_CONFIG_PARAMS_H_