werunplugged/unplugged-system
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
06ee9615ad
unplugged-system/frameworks/av/services/audiopolicy/custom_extensions/include/AudioPolicyManagerCustomImpl.h

320 lines
19 KiB
C++
Raw Blame History

/*
* Copyright (C) 2019 MediaTek Inc.
*
* 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.
*/
#pragma once
#include <stdint.h>
#include <sys/types.h>
#include <cutils/config_utils.h>
#include <cutils/misc.h>
#include <utils/Timers.h>
#include <utils/Errors.h>
#include <utils/KeyedVector.h>
#include <utils/SortedVector.h>
#include <media/AudioParameter.h>
#include <media/AudioPolicy.h>
#include <media/AudioProfile.h>
#include <media/PatchBuilder.h>
#include "AudioPolicyInterface.h"
#include <AudioPolicyManagerObserver.h>
#include <AudioPolicyConfig.h>
#include <PolicyAudioPort.h>
#include <AudioPatch.h>
#include <DeviceDescriptor.h>
#include <IOProfile.h>
#include <HwModule.h>
#include <AudioInputDescriptor.h>
#include <AudioOutputDescriptor.h>
#include <AudioPolicyMix.h>
#include <EffectDescriptor.h>
#include <SoundTriggerSession.h>
#include "../../managerdefault/EngineLibrary.h"
#include "../../common/managerdefinitions/include/TypeConverter.h"
#include "../../../../../../vendor/mediatek/proprietary/external/audio_utils/common_headers/gain_table/AudioGainTableParam.h" // MTK_AUDIO
#include "../../../../../../vendor/mediatek/proprietary/external/audio_utils/common_headers/gain_table/AudioGainTableParamLegacy.h" // MTK_AUDIO
#include "AudioPolicyVendorControl.h" // MTK_AUDIO
#include "AudioPolicyManagerCustomInterface.h" // MTK_AUDIO
#include "../../../../../../vendor/mediatek/proprietary/external/audio_utils/common_headers/custom_volume/AudioCustomVolume.h" // MTK_AUDIO
namespace android {
// MTK_AUDIO
#define SONIFICATION_AUX_DIGITAL_VOLUME_FACTOR 0.5
#define SONIFICATION_AUX_DIGITAL_VOLUME_FACTOR_DB (-6)
#define AUDIO_HIFI_OUTPUT_SUPPORT_FLAG (AUDIO_OUTPUT_FLAG_DEEP_BUFFER |AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD)
class AudioPolicyManager;
class AudioPolicyManagerCustomImpl : public AudioPolicyManagerCustomInterface {
public:
explicit AudioPolicyManagerCustomImpl();
virtual ~AudioPolicyManagerCustomImpl();
virtual status_t common_set(AudioPolicyManager *audioPolicyManger);
virtual audio_stream_type_t gainTable_getVolumeStream();
virtual int gainTable_getVolumeIndex();
virtual DeviceTypeSet gainTable_getVolumeDevice();
virtual status_t gainTable_setVolumeStream(audio_stream_type_t stream);
virtual status_t gainTable_setVolumeIndex(int index);
virtual status_t gainTable_setVolumeDevice(DeviceTypeSet device);
virtual status_t gainTable_getCustomAudioVolume(void);
virtual float gainTable_getVolumeDbFromComputeVolume(VolumeSource volsrc, int index, DeviceTypeSet device, float volumeDB);
virtual DeviceTypeSet gainTable_getDeviceFromComputeVolume(VolumeSource volumeSource, int index, audio_devices_t device);
virtual float gainTable_getCorrectVolumeDbFromComputeVolume(VolumeSource volumeSource, float volumeDB, DeviceTypeSet device);
virtual DeviceTypeSet gainTable_checkInvalidDeviceFromCheckAndSetVolume(const sp<AudioOutputDescriptor>& outputDesc, DeviceTypeSet device);
virtual status_t gainTable_applyAnalogGainFromCheckAndSetVolume(VolumeSource volumeSource, int index,
const sp<AudioOutputDescriptor>& outputDesc,
DeviceTypeSet device,
int delayMs, bool force);
virtual status_t gainTable_setVolumeFromCheckAndSetVolume(VolumeSource volsrc, int index,
const sp<AudioOutputDescriptor>& outputDesc,
DeviceTypeSet device,
int delayMs, bool force, float volumeDb);
virtual status_t gainTable_routeAndApplyVolumeFromStopSource(const sp<SwAudioOutputDescriptor>& outputDesc, DeviceVector device,
audio_stream_type_t stream, bool force);
virtual bool gainTable_skipAdjustGainFromSetStreamVolumeIndex(audio_devices_t curDevice, audio_devices_t wantDevice);
virtual audio_devices_t gainTable_replaceApplyDeviceFromSetStreamVolumeIndex(audio_devices_t outputDevice, audio_devices_t curDevice);
virtual void gainTable_initXML();
virtual status_t common_setPolicyManagerCustomParameters(int par1, int par2, int par3, int par4);
virtual audio_output_flags_t common_getFlagsForClientDescFromCheckOutputForAttributes(sp<TrackClientDescriptor> clientDesc);
virtual status_t fm_initOutputIdForApp(void);
virtual DeviceVector fm_correctDeviceFromSetDeviceConnectionStateInt(const sp<AudioOutputDescriptor>& outputDesc, DeviceVector device, bool force);
virtual status_t fm_addAudioPatch(audio_patch_handle_t handle, const sp<AudioPatch>& patch);
virtual status_t fm_removeAudioPatch(audio_patch_handle_t handle);
virtual status_t fm_applyGainFromCheckAndSetVolume(VolumeSource volumeSource, int index, const sp<AudioOutputDescriptor>& outputDesc,DeviceTypeSet device,
int delayMs, bool force);
virtual status_t fm_muteStrategyFromCheckOutputForStrategy(const audio_attributes_t &attr, DeviceVector oldDevice, DeviceVector newDevice);
virtual status_t fm_checkSkipVolumeFromCheckOutputForStrategy(const audio_attributes_t &attr, DeviceVector oldDevice, DeviceVector newDevice);
virtual status_t fm_releaseSkipVolumeFromCheckOutputForStrategy(void);
virtual bool fm_checkFirstMusicFromStartSource(const sp<AudioOutputDescriptor>& outputDesc, audio_stream_type_t stream);
virtual uint32_t fm_extendMuteFromCheckDeviceMuteStrategies(const sp<AudioOutputDescriptor>& outputDesc, VolumeSource volumeSource, uint32_t muteDurationMs, uint32_t extendDurationMs);
virtual status_t fm_signalAPProutingFromSetOutputDevice(const sp<SwAudioOutputDescriptor>& outputDesc, bool force);
virtual bool setFMIndirectMode(uint32_t sampleRate);
virtual uint32_t fm_extendSleepFromCheckDeviceMuteStrategies(const sp<AudioOutputDescriptor>& outputDesc, uint32_t muteWaitMs);
virtual status_t usbPhoneCall_closeAllInputsFromSetPhoneState(void);
virtual status_t setCurModeFromSetPhoneState(audio_mode_t state);
virtual status_t gainNvram_remapIndexRangeFromInitStreamVolume(audio_stream_type_t stream,
int *indexMin,
int *indexMax);
virtual status_t gainNvram_remapIndexFromSetStreamVolumeIndex(audio_stream_type_t stream,
int *index,
audio_devices_t device);
virtual status_t gainNvram_remapIndexFromGetStreamVolumeIndex(audio_stream_type_t stream,
int *index,
audio_devices_t device);
virtual status_t lowLatency_updatePrimaryModuleDeviceFromSetPhoneState(audio_mode_t state, DeviceTypeSet rxDevice);
virtual status_t lowLatency_CheckSpeakerProtectionDevice(const sp<IOProfile>& outProfile);
virtual bool lowLatency_skipSelectedDeviceFormSetOutputDevice(const sp<AudioOutputDescriptor>& outputDesc, const DeviceVector &devices);
virtual bool lowLatency_skipOutputCheckFromGetOutputsForDevice(audio_devices_t device, const SwAudioOutputCollection& openOutputs, size_t i);
virtual bool lowLatency_stopToRouteFromStopSource(audio_devices_t newDevice, const sp<AudioOutputDescriptor>& outputDesc);
virtual bool lowLatency_startToRouteFromStartSource(const sp<AudioOutputDescriptor>& outputDesc, bool beFirstActive);
virtual bool lowLatency_isOutputActiveFromStartSource(const sp<AudioOutputDescriptor>& outputDesc);
virtual bool lowLatency_setOutputFirstActiveFromStartSource(const sp<SwAudioOutputDescriptor>& outputDesc, bool beFirstActive, DeviceVector device);
virtual bool lowLatency_checkOutputFirstActiveFromSetOutputDevice(const sp<AudioOutputDescriptor>& outputDesc);
virtual status_t besLoudness_signalDupOutputFromSetOutputDevice(const sp<SwAudioOutputDescriptor>& outputDesc,
const DeviceVector &device,
int delayMs);
virtual status_t offload_invalidateMusicForInCallFromSetPhoneState(audio_mode_t state, int oldState);
virtual bool offload_isInCallFromIsOffloadSupported(void);
virtual bool debug_skipShowLog();
virtual bool debug_showGetOutputForAttr(audio_devices_t device, const audio_config_t *config, audio_output_flags_t flags, audio_stream_type_t stream, audio_io_handle_t output);
virtual bool debug_showGetInputForAttr(AudioPolicyInterface::input_type_t inputType, audio_devices_t device, audio_io_handle_t input);
virtual bool debug_showSetOutputDevice(const sp<SwAudioOutputDescriptor>& outputDesc, const DeviceVector & device, bool force, int delayMs);
virtual status_t hifiAudio_startOutputSamplerate(audio_port_handle_t portId, int samplerate);
virtual status_t hifiAudio_stopOutputSamplerate(audio_port_handle_t portId, int samplerate);
virtual status_t hifiAudio_initSetting(void);
virtual status_t hifiAudio_addOutput(audio_io_handle_t output,
const sp<SwAudioOutputDescriptor>& outputDesc);
virtual status_t hifiAudio_removeOutput(audio_io_handle_t outputHandle);
virtual bool isFMActive(void);
virtual bool hifiAudio_needCheckMuteForPhoneCall(DeviceVector newDevices, DeviceVector oldDevices);
virtual bool hifiAudio_needCheckInvalidateFromCheckOutputForAttributes(DeviceVector newDevices, DeviceVector oldDevices);
virtual bool hifiAudio_invalidateStream(audio_io_handle_t ioHandle, uint32_t samplingRate, DeviceVector newDevices, DeviceVector oldDevices);
virtual int hifiAudio_getCachedHIFIState(void);
virtual bool usbAudio_IsDeepBufferSupportUSBDevice();
virtual status_t BLEPhoneCall_addCurrentVolumeIndexFromsetVolumeIndexForAttributes( int index, audio_devices_t device, IVolumeCurves &volumeCurves);
virtual void hifiAudio_updateSampleRate(uint32_t samplingRate);
virtual bool isMbrainSupport()
{
return mMbrainEnable;
}
virtual bool MBrain_conditionCheck(const audio_stream_type_t stream);
virtual status_t MBrain_LogHook(const int level,
const char* event,
const audio_mode_t mode,
const audio_output_flags_t outflags,
const audio_input_flags_t inflags,
const DeviceTypeSet SinkDevice,
const DeviceTypeSet SourceDevice,
const audio_port_handle_t TrackId,
const audio_stream_type_t stream,
const audio_session_t session,
const uid_t uid);
virtual bool spatializer_checkVirtualizerClient();
virtual bool spatialAudio_getSupportStatus(void);
virtual void spatialAudio_muteStrategyForReleaseOutput(void);
protected:
enum output_samplerate_index
{
OUTPUT_RATE_8_INDEX =0,
OUTPUT_RATE_11_025_INDEX,
OUTPUT_RATE_16_INDEX,
OUTPUT_RATE_22_05_INDEX,
OUTPUT_RATE_32_INDEX,
OUTPUT_RATE_44_1_INDEX,
OUTPUT_RATE_48_INDEX,
OUTPUT_RATE_88_2_INDEX,
OUTPUT_RATE_96_INDEX,
OUTPUT_RATE_176_4_INDEX,
OUTPUT_RATE_192_INDEX,
OUTPUT_NUM_RATE_INDEX
};
enum output_samplerate
{
OUTPUT_RATE_8 = 8000,
OUTPUT_RATE_11_025 = 11025,
OUTPUT_RATE_16 = 16000,
OUTPUT_RATE_22_05 = 22050,
OUTPUT_RATE_32 = 32000,
OUTPUT_RATE_44_1 = 44100,
OUTPUT_RATE_48 = 48000,
OUTPUT_RATE_88_2 = 88200,
OUTPUT_RATE_96 = 96000,
OUTPUT_RATE_176_4 = 176400,
OUTPUT_RATE_192 = 192000,
};
enum output_samplerate_policy
{
SampleRate_Do_nothing =0,
SampleRate_First_Start,
SampleRate_ForceReplace,
};
uint32_t mSampleRateArray[OUTPUT_NUM_RATE_INDEX];
uint32_t mHiFiOutputCurSampleRate;
uint32_t mSampleRate_Policy;
uint32_t mHiFiOutputDefaultSampleRate;
SortedVector<audio_io_handle_t> mHiFiOutputIOHandles;
virtual bool aaudio_conidtionCheck(aaudio_cond_t cond, audio_input_flags_t inflags, audio_output_flags_t outflags, audio_mode_t state);
virtual status_t aaudio_invalidateMMAPStream(void);
virtual status_t aaudio_policyForceReplaceSampleRate(sp<SwAudioOutputDescriptor> desc);
virtual status_t common_muteStrategyFromCheckOutputForStrategy(SortedVector<audio_io_handle_t> dstOutput, const audio_attributes_t &attr, DeviceTypeSet oldDevice, DeviceTypeSet newDevice);
virtual status_t common_extendMuteTimeForUSBFromCheckOutputForStrategy(uint32_t& maxLatency, DeviceVector oldDevice);
virtual status_t common_extendMuteTimeForBLEFromCheckOutputForStrategy(uint32_t& maxLatency, DeviceVector newDevice);
virtual audio_io_handle_t multipleRecord_policySelectInput(sp<IOProfile>& profile,
bool isSoundTrigger,
audio_session_t session,
const audio_config_base_t *config,
audio_input_flags_t flags,
bool forceOpen = false);
virtual status_t swBridgPhoneCall_Control(swbridgephonecall_cmd_t cmd, audio_devices_t type = AUDIO_DEVICE_NONE, uint32_t delayMs = 0);
private:
AudioPolicyManager *mAudioPolicyManager; // For public function
audio_stream_type_t mVolumeStream;
int mVolumeIndex;
DeviceTypeSet mVolumeDevice;
GainTableParam mGainTable;
vndGainEnum mVndGainEnum;
int mGainTableSceneIndex;
int mGainTableSceneCount;
DeviceTypeSet mDeviceOfCheckAndSetVolume;
bool mFMDirectAudioPatchEnable;
bool mSkipFMVolControl;
audio_port_handle_t mFmPortId;
bool mUsbHeadsetConnect;
bool mNeedRemapVoiceVolumeIndex;
AUDIO_CUSTOM_VOLUME_STRUCT mAudioCustVolumeTable;
float linearToLog(int volume);
int logToLinear(float volume);
float linearToLogHifi(int volume);
int hifiIndexToAnalog(int index);
bool setHIFIVolumeMode(uint32_t sampleRate);
bool mHifiVolumeMode;
int mHifiState;
bool mSampleRateForce;
void* mlibMBrainHandle;
status_t checkAndSetGainTableAnalogGain(audio_stream_type_t stream, int index, const sp<AudioOutputDescriptor>& outputDesc,DeviceTypeSet device,
int delayMs, bool force);
audio_stream_type_t selectGainTableActiveStream(audio_stream_type_t requestStream);
float computeGainTableCustomVolume(audio_stream_type_t stream, int index, DeviceTypeSet device);
enum tty_mode_t
{
AUD_TTY_OFF = 0,
AUD_TTY_FULL = 1,
AUD_TTY_VCO = 2,
AUD_TTY_HCO = 4,
AUD_TTY_ERR = -1
};
tty_mode_t mTty_Ctm;
DeviceTypeSet getNewDeviceForTty(DeviceTypeSet device, tty_mode_t tty_mode);
bool isFMDirectMode(const sp<AudioPatch>& patch);
bool isFMDirectActive(void);
int mapVol(float &vol, float unitstep);
int mappingVoiceVol(float &vol, float unitstep);
int getStreamMaxLevels(int stream);
float mapVoltoCustomVol(unsigned char array[], int volmin, int volmax, float &vol ,int stream);
float mapVoiceVoltoCustomVol(unsigned char array[], int volmin, int volmax, float &vol, int vol_stream_type);
float computeCustomVolume(int stream, int index, DeviceTypeSet device);
void loadCustomVolume();
status_t updatePrimaryModuleDevice(DeviceTypeSet rxDevice);
sp<SwAudioOutputDescriptor> mFMOutput; // primary or deepbuf output descriptor
status_t freeGainTable(void);
void dumpmVndGainEnum(void);
status_t allocateGainTable(void);
status_t initmVndGainEnum(void);
status_t copySceneGainTable(unsigned char *temp_buffer);
status_t copyNonSceneGainTable(unsigned char *temp_buffer);
status_t updateCurrentSceneIndexOfGainTable(void);
int getSceneIndexOfGainTable(String8 sceneName);
uint32_t getSampleRateIndex(uint32_t sampleRate);
uint32_t getSampleRateCount();
bool checkFirstActive(void);
bool checkStreamActive(void);
void dumpSampleRateArray(void);
uint32_t getFirstTrackSampleRate();
bool isPrimarySupportSampleRate(uint32_t SampleRate);
bool shouldOutputSetSamplerate(audio_io_handle_t ioHandle);
status_t policyFirstStart(audio_stream_type_t stream , uint32_t sampleRate, audio_io_handle_t ioHandle);
status_t policyRestore(audio_stream_type_t stream);
uint32_t getHifiDeviceSampleRate(audio_io_handle_t ioHandle, uint32_t sampleRate);
status_t policyForceReplace(audio_stream_type_t stream, uint32_t sampleRate, audio_io_handle_t ioHandle, bool forceReplace = false);
status_t sampleRatePolicy(audio_stream_type_t stream, uint32_t sampleRate, audio_io_handle_t ioHandle);
status_t addSampleRateArray(audio_stream_type_t stream __unused,uint32_t sampleRate);
status_t removeSampleRateArray(audio_stream_type_t stream __unused, uint32_t sampleRate);
void initSamplerateArray(uint32_t init_sample_rate);
uint32_t getMaxTrackSampleRate(audio_stream_type_t stream = AUDIO_STREAM_DEFAULT);
audio_io_handle_t getPrimaryFastOutput();
bool isSupportDeepBuffer(void);
bool setHIFIState(int enable);
int getHIFIState(void);
bool isMMAPActive(void);
audio_io_handle_t getVOIPRxOutput(void);
bool mPhoneCallSwBridgeEnable;
void setVolumeParameterToHAL(audio_stream_type_t activeStream, int index, DeviceTypeSet device, int delayMs, bool force);
sp<SwAudioOutputDescriptor> getDeepBufferOutput();
sp<SwAudioOutputDescriptor> getHifiPlaybackOutput();
status_t MBrain_load_mbrain_api();
int (*MBrain_AudioLogHook)(int level, char* str);
bool mMbrainEnable;
};
};
Reference in New Issue View Git Blame Copy Permalink