Merge "Spatializer: set spatializer threads to RT priority 1" (1e7d52ac) · Commits · e / os / android_frameworks_av

media/libaudiohal/impl/EffectHalHidl.cpp

+81 −0

Original line number	Diff line number	Diff line
		@@ -17,11 +17,16 @@
		#define LOG_TAG "EffectHalHidl"
		//#define LOG_NDEBUG 0

		#include <android/hidl/manager/1.0/IServiceManager.h>
		#include <android-base/stringprintf.h>
		#include <common/all-versions/VersionUtils.h>
		#include <cutils/native_handle.h>
		#include <cutils/properties.h>
		#include <hwbinder/IPCThreadState.h>
		#include <media/EffectsFactoryApi.h>
		#include <mediautils/SchedulingPolicyService.h>
		#include <mediautils/TimeCheck.h>
		#include <system/audio_effects/effect_spatializer.h>
		#include <utils/Log.h>

		#include <util/EffectUtils.h>
		@@ -50,6 +55,18 @@ EffectHalHidl::EffectHalHidl(const sp<IEffect>& effect, uint64_t effectId)
		effect_descriptor_t halDescriptor{};
		if (EffectHalHidl::getDescriptor(&halDescriptor) == NO_ERROR) {
		mIsInput = (halDescriptor.flags & EFFECT_FLAG_TYPE_PRE_PROC) == EFFECT_FLAG_TYPE_PRE_PROC;
		const bool isSpatializer =
		memcmp(&halDescriptor.type, FX_IID_SPATIALIZER, sizeof(effect_uuid_t)) == 0;
		if (isSpatializer) {
		constexpr int32_t kRTPriorityMin = 1;
		constexpr int32_t kRTPriorityMax = 3;
		const int32_t priorityBoost = property_get_int32("audio.spatializer.priority", 1);
		if (priorityBoost >= kRTPriorityMin && priorityBoost <= kRTPriorityMax) {
		ALOGD("%s: audio.spatializer.priority %d on effect %lld",
		__func__, priorityBoost, (long long)effectId);
		mHalThreadPriority = priorityBoost;
		}
		}
		}
		}

		@@ -127,6 +144,8 @@ status_t EffectHalHidl::prepareForProcessing() {
		ALOGE_IF(!mEfGroup, "Event flag creation for effects failed");
		return NO_INIT;
		}

		(void)checkHalThreadPriority();
		mStatusMQ = std::move(tempStatusMQ);
		return OK;
		}
		@@ -317,5 +336,67 @@ status_t EffectHalHidl::setConfigImpl(
		return result;
		}

		status_t EffectHalHidl::getHalPid(pid_t *pid) const {
		using ::android::hidl::base::V1_0::DebugInfo;
		using ::android::hidl::manager::V1_0::IServiceManager;
		DebugInfo debugInfo;
		const auto ret = mEffect->getDebugInfo([&] (const auto &info) {
		debugInfo = info;
		});
		if (!ret.isOk()) {
		ALOGW("%s: cannot get effect debug info", __func__);
		return INVALID_OPERATION;
		}
		if (debugInfo.pid != (int)IServiceManager::PidConstant::NO_PID) {
		*pid = debugInfo.pid;
		return NO_ERROR;
		}
		ALOGW("%s: effect debug info does not contain pid", __func__);
		return NAME_NOT_FOUND;
		}

		status_t EffectHalHidl::getHalWorkerTid(pid_t *tid) {
		int32_t reply = -1;
		uint32_t replySize = sizeof(reply);
		const status_t status =
		command('gtid', 0 /* cmdSize /, nullptr / pCmdData */, &replySize, &reply);
		if (status == OK) {
		*tid = (pid_t)reply;
		} else {
		ALOGW("%s: failed with status:%d", __func__, status);
		}
		return status;
		}

		bool EffectHalHidl::requestHalThreadPriority(pid_t threadPid, pid_t threadId) {
		if (mHalThreadPriority == kRTPriorityDisabled) {
		return true;
		}
		const int err = requestPriority(
		threadPid, threadId,
		mHalThreadPriority, false /isForApp/, true /asynchronous/);
		ALOGW_IF(err, "%s: failed to set RT priority %d for pid %d tid %d; error %d",
		__func__, mHalThreadPriority, threadPid, threadId, err);
		// Audio will still work, but may be more susceptible to glitches.
		return err == 0;
		}

		status_t EffectHalHidl::checkHalThreadPriority() {
		if (mHalThreadPriority == kRTPriorityDisabled) return OK;
		if (mHalThreadPriority < kRTPriorityMin
		\|\| mHalThreadPriority > kRTPriorityMax) return BAD_VALUE;

		pid_t halPid, halWorkerTid;
		const status_t status = getHalPid(&halPid) ?: getHalWorkerTid(&halWorkerTid);
		const bool success = status == OK && requestHalThreadPriority(halPid, halWorkerTid);
		ALOGD("%s: effectId %lld RT priority(%d) request %s%s",
		__func__, (long long)mEffectId, mHalThreadPriority,
		success ? "succeeded" : "failed",
		status == OK
		? base::StringPrintf(" for pid:%d tid:%d", halPid, halWorkerTid).c_str()
		: " (pid / tid cannot be read)");
		return success ? OK : status != OK ? status : INVALID_OPERATION /* request failed */;
		}

		} // namespace effect
		} // namespace android

media/libaudiohal/impl/EffectHalHidl.h

+9 −0

Original line number	Diff line number	Diff line
		@@ -78,6 +78,11 @@ class EffectHalHidl : public EffectHalInterface, public EffectConversionHelperHi
		std::unique_ptr<StatusMQ> mStatusMQ;
		EventFlag* mEfGroup;
		bool mIsInput = false;
		static constexpr int32_t kRTPriorityMin = 1;
		static constexpr int32_t kRTPriorityMax = 3;
		static constexpr int kRTPriorityDisabled = 0;
		// Typical RealTime mHalThreadPriority ranges from 1 (low) to 3 (high).
		int mHalThreadPriority = kRTPriorityDisabled;

		// Can not be constructed directly by clients.
		EffectHalHidl(const sp<IEffect>& effect, uint64_t effectId);
		@@ -93,6 +98,10 @@ class EffectHalHidl : public EffectHalInterface, public EffectConversionHelperHi
		uint32_t cmdCode, uint32_t cmdSize, void *pCmdData,
		uint32_t replySize, void pReplyData);
		status_t setProcessBuffers();
		status_t getHalPid(pid_t *pid) const;
		status_t getHalWorkerTid(pid_t *tid);
		bool requestHalThreadPriority(pid_t threadPid, pid_t threadId);
		status_t checkHalThreadPriority();
		};

		} // namespace effect

services/audioflinger/Threads.cpp

+21 −0

Original line number	Diff line number	Diff line
		@@ -7338,6 +7338,27 @@ void AudioFlinger::SpatializerThread::onFirstRef() {
		if (status != INVALID_OPERATION) {
		updateHalSupportedLatencyModes_l();
		}

		// update priority if specified.
		constexpr int32_t kRTPriorityMin = 1;
		constexpr int32_t kRTPriorityMax = 3;
		const int32_t priorityBoost =
		property_get_int32("audio.spatializer.priority", kRTPriorityMin);
		if (priorityBoost >= kRTPriorityMin && priorityBoost <= kRTPriorityMax) {
		const pid_t pid = getpid();
		const pid_t tid = getTid();

		if (tid == -1) {
		// Unusual: PlaybackThread::onFirstRef() should set the threadLoop running.
		ALOGW("%s: audio.spatializer.priority %d ignored, thread not running",
		__func__, priorityBoost);
		} else {
		ALOGD("%s: audio.spatializer.priority %d, allowing real time for pid %d tid %d",
		__func__, priorityBoost, pid, tid);
		sendPrioConfigEvent_l(pid, tid, priorityBoost, false /forApp/);
		stream()->setHalThreadPriority(priorityBoost);
		}
		}
		}

		status_t AudioFlinger::SpatializerThread::createAudioPatch_l(const struct audio_patch *patch,