Merge "TimeCheck: Track audio Hidl hwbinder calls" into tm-dev (44c327c7) · Commits · e / os / android_frameworks_av

media/libaudiohal/impl/ConversionHelperHidl.cpp

+3 −3

Original line number	Diff line number	Diff line
		@@ -99,8 +99,8 @@ void ConversionHelperHidl::parametersToHal(
		values->setTo(params.toString());
		}

		ConversionHelperHidl::ConversionHelperHidl(const char* className)
		: mClassName(className) {
		ConversionHelperHidl::ConversionHelperHidl(std::string_view className)
		: mClassName(className.begin(), className.end()) {
		}

		// static
		@@ -125,7 +125,7 @@ status_t ConversionHelperHidl::analyzeResult(const Result& result) {
		}

		void ConversionHelperHidl::emitError(const char* funcName, const char* description) {
		ALOGE("%s %p %s: %s (from rpc)", mClassName, this, funcName, description);
		ALOGE("%s %p %s: %s (from rpc)", mClassName.c_str(), this, funcName, description);
		}

		} // namespace android

media/libaudiohal/impl/ConversionHelperHidl.h

+6 −2

Original line number	Diff line number	Diff line
		@@ -40,7 +40,7 @@ class ConversionHelperHidl {
		static void parametersToHal(const hidl_vec<ParameterValue>& parameters, String8 *values);
		static void argsFromHal(const Vector<String16>& args, hidl_vec<hidl_string> *hidlArgs);

		ConversionHelperHidl(const char* className);
		ConversionHelperHidl(std::string_view className);

		template<typename R, typename T>
		status_t processReturn(const char* funcName, const Return<R>& ret, T *retval) {
		@@ -76,8 +76,12 @@ class ConversionHelperHidl {
		return ret.isOk() ? analyzeResult(retval) : FAILED_TRANSACTION;
		}

		const std::string& getClassName() const {
		return mClassName;
		}

		private:
		const char* mClassName;
		const std::string mClassName;

		static status_t analyzeResult(const CoreResult& result);

media/libaudiohal/impl/DeviceHalHidl.cpp

+32 −2

Original line number	Diff line number	Diff line
		@@ -23,6 +23,7 @@
		#include <cutils/properties.h>
		#include <hwbinder/IPCThreadState.h>
		#include <media/AudioContainers.h>
		#include <mediautils/TimeCheck.h>
		#include <utils/Log.h>

		#include PATH(android/hardware/audio/FILE_VERSION/IPrimaryDevice.h)
		@@ -45,13 +46,16 @@ namespace android {
		using namespace ::android::hardware::audio::common::COMMON_TYPES_CPP_VERSION;
		using namespace ::android::hardware::audio::CORE_TYPES_CPP_VERSION;

		#define TIME_CHECK() auto timeCheck = \
		mediautils::makeTimeCheckStatsForClassMethod(getClassName(), __func__)

		DeviceHalHidl::DeviceHalHidl(const sp<::android::hardware::audio::CPP_VERSION::IDevice>& device)
		: ConversionHelperHidl("Device"), mDevice(device) {
		: ConversionHelperHidl("DeviceHalHidl"), mDevice(device) {
		}

		DeviceHalHidl::DeviceHalHidl(
		const sp<::android::hardware::audio::CPP_VERSION::IPrimaryDevice>& device)
		: ConversionHelperHidl("Device"),
		: ConversionHelperHidl("DeviceHalHidl"),
		#if MAJOR_VERSION <= 6 \|\| (MAJOR_VERSION == 7 && MINOR_VERSION == 0)
		mDevice(device),
		#endif
		@@ -84,22 +88,26 @@ status_t DeviceHalHidl::getSupportedDevices(uint32_t*) {
		}

		status_t DeviceHalHidl::initCheck() {
		TIME_CHECK();
		if (mDevice == 0) return NO_INIT;
		return processReturn("initCheck", mDevice->initCheck());
		}

		status_t DeviceHalHidl::setVoiceVolume(float volume) {
		TIME_CHECK();
		if (mDevice == 0) return NO_INIT;
		if (mPrimaryDevice == 0) return INVALID_OPERATION;
		return processReturn("setVoiceVolume", mPrimaryDevice->setVoiceVolume(volume));
		}

		status_t DeviceHalHidl::setMasterVolume(float volume) {
		TIME_CHECK();
		if (mDevice == 0) return NO_INIT;
		return processReturn("setMasterVolume", mDevice->setMasterVolume(volume));
		}

		status_t DeviceHalHidl::getMasterVolume(float *volume) {
		TIME_CHECK();
		if (mDevice == 0) return NO_INIT;
		Result retval;
		Return<void> ret = mDevice->getMasterVolume(
		@@ -113,17 +121,20 @@ status_t DeviceHalHidl::getMasterVolume(float *volume) {
		}

		status_t DeviceHalHidl::setMode(audio_mode_t mode) {
		TIME_CHECK();
		if (mDevice == 0) return NO_INIT;
		if (mPrimaryDevice == 0) return INVALID_OPERATION;
		return processReturn("setMode", mPrimaryDevice->setMode(AudioMode(mode)));
		}

		status_t DeviceHalHidl::setMicMute(bool state) {
		TIME_CHECK();
		if (mDevice == 0) return NO_INIT;
		return processReturn("setMicMute", mDevice->setMicMute(state));
		}

		status_t DeviceHalHidl::getMicMute(bool *state) {
		TIME_CHECK();
		if (mDevice == 0) return NO_INIT;
		Result retval;
		Return<void> ret = mDevice->getMicMute(
		@@ -137,11 +148,13 @@ status_t DeviceHalHidl::getMicMute(bool *state) {
		}

		status_t DeviceHalHidl::setMasterMute(bool state) {
		TIME_CHECK();
		if (mDevice == 0) return NO_INIT;
		return processReturn("setMasterMute", mDevice->setMasterMute(state));
		}

		status_t DeviceHalHidl::getMasterMute(bool *state) {
		TIME_CHECK();
		if (mDevice == 0) return NO_INIT;
		Result retval;
		Return<void> ret = mDevice->getMasterMute(
		@@ -155,6 +168,7 @@ status_t DeviceHalHidl::getMasterMute(bool *state) {
		}

		status_t DeviceHalHidl::setParameters(const String8& kvPairs) {
		TIME_CHECK();
		if (mDevice == 0) return NO_INIT;
		hidl_vec<ParameterValue> hidlParams;
		status_t status = parametersFromHal(kvPairs, &hidlParams);
		@@ -165,6 +179,7 @@ status_t DeviceHalHidl::setParameters(const String8& kvPairs) {
		}

		status_t DeviceHalHidl::getParameters(const String8& keys, String8 *values) {
		TIME_CHECK();
		values->clear();
		if (mDevice == 0) return NO_INIT;
		hidl_vec<hidl_string> hidlKeys;
		@@ -185,6 +200,7 @@ status_t DeviceHalHidl::getParameters(const String8& keys, String8 *values) {

		status_t DeviceHalHidl::getInputBufferSize(
		const struct audio_config config, size_t size) {
		TIME_CHECK();
		if (mDevice == 0) return NO_INIT;
		AudioConfig hidlConfig;
		HidlUtils::audioConfigFromHal(config, true /isInput*/, &hidlConfig);
		@@ -207,6 +223,7 @@ status_t DeviceHalHidl::openOutputStream(
		struct audio_config *config,
		const char *address,
		sp<StreamOutHalInterface> *outStream) {
		TIME_CHECK();
		if (mDevice == 0) return NO_INIT;
		DeviceAddress hidlDevice;
		if (status_t status = CoreUtils::deviceAddressFromHal(deviceType, address, &hidlDevice);
		@@ -263,6 +280,7 @@ status_t DeviceHalHidl::openInputStream(
		audio_devices_t outputDevice,
		const char *outputDeviceAddress,
		sp<StreamInHalInterface> *inStream) {
		TIME_CHECK();
		if (mDevice == 0) return NO_INIT;
		DeviceAddress hidlDevice;
		if (status_t status = CoreUtils::deviceAddressFromHal(devices, address, &hidlDevice);
		@@ -326,6 +344,7 @@ status_t DeviceHalHidl::openInputStream(
		}

		status_t DeviceHalHidl::supportsAudioPatches(bool *supportsPatches) {
		TIME_CHECK();
		if (mDevice == 0) return NO_INIT;
		return processReturn("supportsAudioPatches", mDevice->supportsAudioPatches(), supportsPatches);
		}
		@@ -336,6 +355,7 @@ status_t DeviceHalHidl::createAudioPatch(
		unsigned int num_sinks,
		const struct audio_port_config *sinks,
		audio_patch_handle_t *patch) {
		TIME_CHECK();
		if (mDevice == 0) return NO_INIT;
		if (patch == nullptr) return BAD_VALUE;

		@@ -381,6 +401,7 @@ status_t DeviceHalHidl::createAudioPatch(
		}

		status_t DeviceHalHidl::releaseAudioPatch(audio_patch_handle_t patch) {
		TIME_CHECK();
		if (mDevice == 0) return NO_INIT;
		return processReturn("releaseAudioPatch", mDevice->releaseAudioPatch(patch));
		}
		@@ -403,10 +424,12 @@ status_t DeviceHalHidl::getAudioPortImpl(HalPort *port) {
		}

		status_t DeviceHalHidl::getAudioPort(struct audio_port *port) {
		TIME_CHECK();
		return getAudioPortImpl(port);
		}

		status_t DeviceHalHidl::getAudioPort(struct audio_port_v7 *port) {
		TIME_CHECK();
		#if MAJOR_VERSION >= 7
		return getAudioPortImpl(port);
		#else
		@@ -427,6 +450,7 @@ status_t DeviceHalHidl::getAudioPort(struct audio_port_v7 *port) {
		}

		status_t DeviceHalHidl::setAudioPortConfig(const struct audio_port_config *config) {
		TIME_CHECK();
		if (mDevice == 0) return NO_INIT;
		AudioPortConfig hidlConfig;
		HidlUtils::audioPortConfigFromHal(*config, &hidlConfig);
		@@ -441,6 +465,7 @@ status_t DeviceHalHidl::getMicrophones(
		}
		#elif MAJOR_VERSION >= 4
		status_t DeviceHalHidl::getMicrophones(std::vector<media::MicrophoneInfo> *microphonesInfo) {
		TIME_CHECK();
		if (mDevice == 0) return NO_INIT;
		Result retval;
		Return<void> ret = mDevice->getMicrophones(
		@@ -461,6 +486,7 @@ status_t DeviceHalHidl::getMicrophones(std::vector<media::MicrophoneInfo> *micro
		#if MAJOR_VERSION >= 6
		status_t DeviceHalHidl::addDeviceEffect(
		audio_port_handle_t device, sp<EffectHalInterface> effect) {
		TIME_CHECK();
		if (mDevice == 0) return NO_INIT;
		return processReturn("addDeviceEffect", mDevice->addDeviceEffect(
		static_cast<AudioPortHandle>(device), effect->effectId()));
		@@ -475,6 +501,7 @@ status_t DeviceHalHidl::addDeviceEffect(
		#if MAJOR_VERSION >= 6
		status_t DeviceHalHidl::removeDeviceEffect(
		audio_port_handle_t device, sp<EffectHalInterface> effect) {
		TIME_CHECK();
		if (mDevice == 0) return NO_INIT;
		return processReturn("removeDeviceEffect", mDevice->removeDeviceEffect(
		static_cast<AudioPortHandle>(device), effect->effectId()));
		@@ -487,6 +514,7 @@ status_t DeviceHalHidl::removeDeviceEffect(
		#endif

		status_t DeviceHalHidl::setConnectedState(const struct audio_port_v7 *port, bool connected) {
		TIME_CHECK();
		if (mDevice == 0) return NO_INIT;
		#if MAJOR_VERSION == 7 && MINOR_VERSION == 1
		if (supportsSetConnectedState7_1) {
		@@ -513,6 +541,7 @@ status_t DeviceHalHidl::setConnectedState(const struct audio_port_v7 *port, bool
		}

		error::Result<audio_hw_sync_t> DeviceHalHidl::getHwAvSync() {
		TIME_CHECK();
		if (mDevice == 0) return NO_INIT;
		audio_hw_sync_t value;
		Result result;
		@@ -525,6 +554,7 @@ error::Result<audio_hw_sync_t> DeviceHalHidl::getHwAvSync() {
		}

		status_t DeviceHalHidl::dump(int fd, const Vector<String16>& args) {
		TIME_CHECK();
		if (mDevice == 0) return NO_INIT;
		native_handle_t* hidlHandle = native_handle_create(1, 0);
		hidlHandle->data[0] = fd;

media/libaudiohal/impl/StreamHalHidl.cpp

+61 −5

Original line number	Diff line number	Diff line
		@@ -22,6 +22,7 @@
		#include <media/AudioParameter.h>
		#include <mediautils/memory.h>
		#include <mediautils/SchedulingPolicyService.h>
		#include <mediautils/TimeCheck.h>
		#include <utils/Log.h>

		#include PATH(android/hardware/audio/CORE_TYPES_FILE_VERSION/IStreamOutCallback.h)
		@@ -45,8 +46,11 @@ using ReadCommand = ::android::hardware::audio::CORE_TYPES_CPP_VERSION::IStreamI
		using namespace ::android::hardware::audio::common::COMMON_TYPES_CPP_VERSION;
		using namespace ::android::hardware::audio::CORE_TYPES_CPP_VERSION;

		StreamHalHidl::StreamHalHidl(IStream *stream)
		: ConversionHelperHidl("Stream"),
		#define TIME_CHECK() auto TimeCheck = \
		mediautils::makeTimeCheckStatsForClassMethod(getClassName(), __func__)

		StreamHalHidl::StreamHalHidl(std::string_view className, IStream *stream)
		: ConversionHelperHidl(className),
		mStream(stream),
		mHalThreadPriority(HAL_THREAD_PRIORITY_DEFAULT),
		mCachedBufferSize(0){
		@@ -67,6 +71,7 @@ StreamHalHidl::~StreamHalHidl() {
		}

		status_t StreamHalHidl::getBufferSize(size_t *size) {
		TIME_CHECK();
		if (!mStream) return NO_INIT;
		status_t status = processReturn("getBufferSize", mStream->getBufferSize(), size);
		if (status == OK) {
		@@ -76,6 +81,7 @@ status_t StreamHalHidl::getBufferSize(size_t *size) {
		}

		status_t StreamHalHidl::getAudioProperties(audio_config_base_t *configBase) {
		TIME_CHECK();
		*configBase = AUDIO_CONFIG_BASE_INITIALIZER;
		if (!mStream) return NO_INIT;
		#if MAJOR_VERSION <= 6
		@@ -105,6 +111,7 @@ status_t StreamHalHidl::getAudioProperties(audio_config_base_t *configBase) {
		}

		status_t StreamHalHidl::setParameters(const String8& kvPairs) {
		TIME_CHECK();
		if (!mStream) return NO_INIT;
		hidl_vec<ParameterValue> hidlParams;
		status_t status = parametersFromHal(kvPairs, &hidlParams);
		@@ -114,6 +121,7 @@ status_t StreamHalHidl::setParameters(const String8& kvPairs) {
		}

		status_t StreamHalHidl::getParameters(const String8& keys, String8 *values) {
		TIME_CHECK();
		values->clear();
		if (!mStream) return NO_INIT;
		hidl_vec<hidl_string> hidlKeys;
		@@ -134,21 +142,25 @@ status_t StreamHalHidl::getParameters(const String8& keys, String8 *values) {
		}

		status_t StreamHalHidl::addEffect(sp<EffectHalInterface> effect) {
		TIME_CHECK();
		if (!mStream) return NO_INIT;
		return processReturn("addEffect", mStream->addEffect(effect->effectId()));
		}

		status_t StreamHalHidl::removeEffect(sp<EffectHalInterface> effect) {
		TIME_CHECK();
		if (!mStream) return NO_INIT;
		return processReturn("removeEffect", mStream->removeEffect(effect->effectId()));
		}

		status_t StreamHalHidl::standby() {
		TIME_CHECK();
		if (!mStream) return NO_INIT;
		return processReturn("standby", mStream->standby());
		}

		status_t StreamHalHidl::dump(int fd, const Vector<String16>& args) {
		TIME_CHECK();
		if (!mStream) return NO_INIT;
		native_handle_t* hidlHandle = native_handle_create(1, 0);
		hidlHandle->data[0] = fd;
		@@ -173,17 +185,20 @@ status_t StreamHalHidl::dump(int fd, const Vector<String16>& args) {
		}

		status_t StreamHalHidl::start() {
		TIME_CHECK();
		if (!mStream) return NO_INIT;
		return processReturn("start", mStream->start());
		}

		status_t StreamHalHidl::stop() {
		TIME_CHECK();
		if (!mStream) return NO_INIT;
		return processReturn("stop", mStream->stop());
		}

		status_t StreamHalHidl::createMmapBuffer(int32_t minSizeFrames,
		struct audio_mmap_buffer_info *info) {
		TIME_CHECK();
		Result retval;
		Return<void> ret = mStream->createMmapBuffer(
		minSizeFrames,
		@@ -216,6 +231,7 @@ status_t StreamHalHidl::createMmapBuffer(int32_t minSizeFrames,
		}

		status_t StreamHalHidl::getMmapPosition(struct audio_mmap_position *position) {
		TIME_CHECK();
		Result retval;
		Return<void> ret = mStream->getMmapPosition(
		[&](Result r, const MmapPosition& hidlPosition) {
		@@ -244,7 +260,7 @@ status_t StreamHalHidl::getCachedBufferSize(size_t *size) {
		status_t StreamHalHidl::getHalPid(pid_t *pid) {
		using ::android::hidl::base::V1_0::DebugInfo;
		using ::android::hidl::manager::V1_0::IServiceManager;

		TIME_CHECK();
		DebugInfo debugInfo;
		auto ret = mStream->getDebugInfo([&] (const auto &info) {
		debugInfo = info;
		@@ -275,6 +291,7 @@ bool StreamHalHidl::requestHalThreadPriority(pid_t threadPid, pid_t threadId) {
		status_t StreamHalHidl::legacyCreateAudioPatch(const struct audio_port_config& port,
		std::optional<audio_source_t> source,
		audio_devices_t type) {
		TIME_CHECK();
		LOG_ALWAYS_FATAL_IF(port.type != AUDIO_PORT_TYPE_DEVICE, "port type must be device");
		unique_malloced_ptr<char> address;
		if (strcmp(port.ext.device.address, "") != 0) {
		@@ -293,6 +310,7 @@ status_t StreamHalHidl::legacyCreateAudioPatch(const struct audio_port_config& p
		}

		status_t StreamHalHidl::legacyReleaseAudioPatch() {
		TIME_CHECK();
		AudioParameter param;
		param.addInt(String8(AudioParameter::keyRouting), 0);
		return setParameters(param.toString());
		@@ -352,7 +370,8 @@ struct StreamOutCallback : public IStreamOutCallback {

		StreamOutHalHidl::StreamOutHalHidl(
		const sp<::android::hardware::audio::CPP_VERSION::IStreamOut>& stream)
		: StreamHalHidl(stream.get()), mStream(stream), mWriterClient(0), mEfGroup(nullptr) {
		: StreamHalHidl("StreamOutHalHidl", stream.get())
		, mStream(stream), mWriterClient(0), mEfGroup(nullptr) {
		}

		StreamOutHalHidl::~StreamOutHalHidl() {
		@@ -376,11 +395,13 @@ StreamOutHalHidl::~StreamOutHalHidl() {
		}

		status_t StreamOutHalHidl::getFrameSize(size_t *size) {
		TIME_CHECK();
		if (mStream == 0) return NO_INIT;
		return processReturn("getFrameSize", mStream->getFrameSize(), size);
		}

		status_t StreamOutHalHidl::getLatency(uint32_t *latency) {
		TIME_CHECK();
		if (mStream == 0) return NO_INIT;
		if (mWriterClient == gettid() && mCommandMQ) {
		return callWriterThread(
		@@ -394,12 +415,14 @@ status_t StreamOutHalHidl::getLatency(uint32_t *latency) {
		}

		status_t StreamOutHalHidl::setVolume(float left, float right) {
		TIME_CHECK();
		if (mStream == 0) return NO_INIT;
		return processReturn("setVolume", mStream->setVolume(left, right));
		}

		#if MAJOR_VERSION == 2
		status_t StreamOutHalHidl::selectPresentation(int presentationId, int programId) {
		TIME_CHECK();
		if (mStream == 0) return NO_INIT;
		std::vector<ParameterValue> parameters;
		String8 halParameters;
		@@ -410,6 +433,7 @@ status_t StreamOutHalHidl::selectPresentation(int presentationId, int programId)
		}
		#elif MAJOR_VERSION >= 4
		status_t StreamOutHalHidl::selectPresentation(int presentationId, int programId) {
		TIME_CHECK();
		if (mStream == 0) return NO_INIT;
		return processReturn("selectPresentation",
		mStream->selectPresentation(presentationId, programId));
		@@ -417,6 +441,7 @@ status_t StreamOutHalHidl::selectPresentation(int presentationId, int programId)
		#endif

		status_t StreamOutHalHidl::write(const void buffer, size_t bytes, size_t written) {
		TIME_CHECK();
		if (mStream == 0) return NO_INIT;
		*written = 0;

		@@ -562,6 +587,7 @@ status_t StreamOutHalHidl::prepareForWriting(size_t bufferSize) {
		}

		status_t StreamOutHalHidl::getRenderPosition(uint32_t *dspFrames) {
		TIME_CHECK();
		if (mStream == 0) return NO_INIT;
		Result retval;
		Return<void> ret = mStream->getRenderPosition(
		@@ -575,6 +601,7 @@ status_t StreamOutHalHidl::getRenderPosition(uint32_t *dspFrames) {
		}

		status_t StreamOutHalHidl::getNextWriteTimestamp(int64_t *timestamp) {
		TIME_CHECK();
		if (mStream == 0) return NO_INIT;
		Result retval;
		Return<void> ret = mStream->getNextWriteTimestamp(
		@@ -588,6 +615,7 @@ status_t StreamOutHalHidl::getNextWriteTimestamp(int64_t *timestamp) {
		}

		status_t StreamOutHalHidl::setCallback(wp<StreamOutHalInterfaceCallback> callback) {
		TIME_CHECK();
		if (mStream == 0) return NO_INIT;
		status_t status = processReturn(
		"setCallback", mStream->setCallback(new StreamOutCallback(this)));
		@@ -598,6 +626,7 @@ status_t StreamOutHalHidl::setCallback(wp<StreamOutHalInterfaceCallback> callbac
		}

		status_t StreamOutHalHidl::supportsPauseAndResume(bool supportsPause, bool supportsResume) {
		TIME_CHECK();
		if (mStream == 0) return NO_INIT;
		Return<void> ret = mStream->supportsPauseAndResume(
		[&](bool p, bool r) {
		@@ -608,32 +637,38 @@ status_t StreamOutHalHidl::supportsPauseAndResume(bool supportsPause, bool sup
		}

		status_t StreamOutHalHidl::pause() {
		TIME_CHECK();
		if (mStream == 0) return NO_INIT;
		return processReturn("pause", mStream->pause());
		}

		status_t StreamOutHalHidl::resume() {
		TIME_CHECK();
		if (mStream == 0) return NO_INIT;
		return processReturn("pause", mStream->resume());
		}

		status_t StreamOutHalHidl::supportsDrain(bool *supportsDrain) {
		TIME_CHECK();
		if (mStream == 0) return NO_INIT;
		return processReturn("supportsDrain", mStream->supportsDrain(), supportsDrain);
		}

		status_t StreamOutHalHidl::drain(bool earlyNotify) {
		TIME_CHECK();
		if (mStream == 0) return NO_INIT;
		return processReturn(
		"drain", mStream->drain(earlyNotify ? AudioDrain::EARLY_NOTIFY : AudioDrain::ALL));
		}

		status_t StreamOutHalHidl::flush() {
		TIME_CHECK();
		if (mStream == 0) return NO_INIT;
		return processReturn("pause", mStream->flush());
		}

		status_t StreamOutHalHidl::getPresentationPosition(uint64_t frames, struct timespec timestamp) {
		TIME_CHECK();
		if (mStream == 0) return NO_INIT;
		if (mWriterClient == gettid() && mCommandMQ) {
		return callWriterThread(
		@@ -667,6 +702,7 @@ status_t StreamOutHalHidl::updateSourceMetadata(
		#elif MAJOR_VERSION >= 4
		status_t StreamOutHalHidl::updateSourceMetadata(
		const StreamOutHalInterface::SourceMetadata& sourceMetadata) {
		TIME_CHECK();
		#if MAJOR_VERSION == 4
		::android::hardware::audio::CORE_TYPES_CPP_VERSION::SourceMetadata hidlMetadata;
		#else
		@@ -717,6 +753,7 @@ status_t StreamOutHalHidl::setEventCallback(
		#else

		status_t StreamOutHalHidl::getDualMonoMode(audio_dual_mono_mode_t* mode) {
		TIME_CHECK();
		if (mStream == 0) return NO_INIT;
		Result retval;
		Return<void> ret = mStream->getDualMonoMode(
		@@ -730,12 +767,14 @@ status_t StreamOutHalHidl::getDualMonoMode(audio_dual_mono_mode_t* mode) {
		}

		status_t StreamOutHalHidl::setDualMonoMode(audio_dual_mono_mode_t mode) {
		TIME_CHECK();
		if (mStream == 0) return NO_INIT;
		return processReturn(
		"setDualMonoMode", mStream->setDualMonoMode(static_cast<DualMonoMode>(mode)));
		}

		status_t StreamOutHalHidl::getAudioDescriptionMixLevel(float* leveldB) {
		TIME_CHECK();
		if (mStream == 0) return NO_INIT;
		Result retval;
		Return<void> ret = mStream->getAudioDescriptionMixLevel(
		@@ -749,12 +788,14 @@ status_t StreamOutHalHidl::getAudioDescriptionMixLevel(float* leveldB) {
		}

		status_t StreamOutHalHidl::setAudioDescriptionMixLevel(float leveldB) {
		TIME_CHECK();
		if (mStream == 0) return NO_INIT;
		return processReturn(
		"setAudioDescriptionMixLevel", mStream->setAudioDescriptionMixLevel(leveldB));
		}

		status_t StreamOutHalHidl::getPlaybackRateParameters(audio_playback_rate_t* playbackRate) {
		TIME_CHECK();
		if (mStream == 0) return NO_INIT;
		Result retval;
		Return<void> ret = mStream->getPlaybackRateParameters(
		@@ -775,6 +816,7 @@ status_t StreamOutHalHidl::getPlaybackRateParameters(audio_playback_rate_t* play
		}

		status_t StreamOutHalHidl::setPlaybackRateParameters(const audio_playback_rate_t& playbackRate) {
		TIME_CHECK();
		if (mStream == 0) return NO_INIT;
		return processReturn(
		"setPlaybackRateParameters", mStream->setPlaybackRateParameters(
		@@ -809,6 +851,7 @@ struct StreamOutEventCallback : public IStreamOutEventCallback {

		status_t StreamOutHalHidl::setEventCallback(
		const sp<StreamOutHalInterfaceEventCallback>& callback) {
		TIME_CHECK();
		if (mStream == nullptr) return NO_INIT;
		mEventCallback = callback;
		status_t status = processReturn(
		@@ -823,12 +866,14 @@ status_t StreamOutHalHidl::setEventCallback(
		using hardware::audio::V7_1::LatencyMode;

		status_t StreamOutHalHidl::setLatencyMode(audio_latency_mode_t mode) {
		TIME_CHECK();
		if (mStream == 0) return NO_INIT;
		return processReturn(
		"setLatencyMode", mStream->setLatencyMode(static_cast<LatencyMode>(mode)));
		};

		status_t StreamOutHalHidl::getRecommendedLatencyModes(std::vector<audio_latency_mode_t> *modes) {
		TIME_CHECK();
		if (!mStream) return NO_INIT;
		Result retval;
		Return<void> ret = mStream->getRecommendedLatencyModes(
		@@ -869,6 +914,7 @@ struct StreamOutLatencyModeCallback : public IStreamOutLatencyModeCallback {

		status_t StreamOutHalHidl::setLatencyModeCallback(
		const sp<StreamOutHalInterfaceLatencyModeCallback>& callback) {
		TIME_CHECK();

		if (mStream == nullptr) return NO_INIT;
		mLatencyModeCallback = callback;
		@@ -940,7 +986,8 @@ status_t StreamOutHalHidl::exit() {

		StreamInHalHidl::StreamInHalHidl(
		const sp<::android::hardware::audio::CORE_TYPES_CPP_VERSION::IStreamIn>& stream)
		: StreamHalHidl(stream.get()), mStream(stream), mReaderClient(0), mEfGroup(nullptr) {
		: StreamHalHidl("StreamInHalHidl", stream.get())
		, mStream(stream), mReaderClient(0), mEfGroup(nullptr) {
		}

		StreamInHalHidl::~StreamInHalHidl() {
		@@ -953,16 +1000,19 @@ StreamInHalHidl::~StreamInHalHidl() {
		}

		status_t StreamInHalHidl::getFrameSize(size_t *size) {
		TIME_CHECK();
		if (mStream == 0) return NO_INIT;
		return processReturn("getFrameSize", mStream->getFrameSize(), size);
		}

		status_t StreamInHalHidl::setGain(float gain) {
		TIME_CHECK();
		if (mStream == 0) return NO_INIT;
		return processReturn("setGain", mStream->setGain(gain));
		}

		status_t StreamInHalHidl::read(void buffer, size_t bytes, size_t read) {
		TIME_CHECK();
		if (mStream == 0) return NO_INIT;
		*read = 0;

		@@ -1090,11 +1140,13 @@ status_t StreamInHalHidl::prepareForReading(size_t bufferSize) {
		}

		status_t StreamInHalHidl::getInputFramesLost(uint32_t *framesLost) {
		TIME_CHECK();
		if (mStream == 0) return NO_INIT;
		return processReturn("getInputFramesLost", mStream->getInputFramesLost(), framesLost);
		}

		status_t StreamInHalHidl::getCapturePosition(int64_t frames, int64_t time) {
		TIME_CHECK();
		if (mStream == 0) return NO_INIT;
		if (mReaderClient == gettid() && mCommandMQ) {
		ReadParameters params;
		@@ -1134,6 +1186,7 @@ status_t StreamInHalHidl::updateSinkMetadata(
		#elif MAJOR_VERSION >= 4
		status_t StreamInHalHidl::getActiveMicrophones(
		std::vector<media::MicrophoneInfo> *microphonesInfo) {
		TIME_CHECK();
		if (!mStream) return NO_INIT;
		Result retval;
		Return<void> ret = mStream->getActiveMicrophones(
		@@ -1152,6 +1205,7 @@ status_t StreamInHalHidl::getActiveMicrophones(

		status_t StreamInHalHidl::updateSinkMetadata(const
		StreamInHalInterface::SinkMetadata& sinkMetadata) {
		TIME_CHECK();
		#if MAJOR_VERSION == 4
		::android::hardware::audio::CORE_TYPES_CPP_VERSION::SinkMetadata hidlMetadata;
		#else
		@@ -1179,12 +1233,14 @@ status_t StreamInHalHidl::setPreferredMicrophoneFieldDimension(float zoom __unus
		}
		#else
		status_t StreamInHalHidl::setPreferredMicrophoneDirection(audio_microphone_direction_t direction) {
		TIME_CHECK();
		if (!mStream) return NO_INIT;
		return processReturn("setPreferredMicrophoneDirection",
		mStream->setMicrophoneDirection(static_cast<MicrophoneDirection>(direction)));
		}

		status_t StreamInHalHidl::setPreferredMicrophoneFieldDimension(float zoom) {
		TIME_CHECK();
		if (!mStream) return NO_INIT;
		return processReturn("setPreferredMicrophoneFieldDimension",
		mStream->setMicrophoneFieldDimension(zoom));

media/libaudiohal/impl/StreamHalHidl.h

+1 −1

Original line number	Diff line number	Diff line
		@@ -97,7 +97,7 @@ class StreamHalHidl : public virtual StreamHalInterface, public ConversionHelper

		protected:
		// Subclasses can not be constructed directly by clients.
		explicit StreamHalHidl(IStream *stream);
		StreamHalHidl(std::string_view className, IStream *stream);

		~StreamHalHidl() override;