Snap for 9470583 from afc2da8e8b01d95ddd472d9b1a8b6b273a41ff68 to tm-qpr3-release (6e19dc19) · Commits · e / os / android_hardware_interfaces

audio/common/all-versions/default/service/android.hardware.audio.service.rc

+3 −1

Original line number	Diff line number	Diff line
		@@ -3,7 +3,9 @@ service vendor.audio-hal /vendor/bin/hw/android.hardware.audio.service
		user audioserver
		# media gid needed for /dev/fm (radio) and for /data/misc/media (tee)
		group audio camera drmrpc inet media mediadrm net_bt net_bt_admin net_bw_acct wakelock context_hub
		capabilities BLOCK_SUSPEND
		capabilities BLOCK_SUSPEND SYS_NICE
		# setting RLIMIT_RTPRIO allows binder RT priority inheritance
		rlimit rtprio 10 10
		ioprio rt 4
		task_profiles ProcessCapacityHigh HighPerformance
		onrestart restart audioserver

audio/core/all-versions/default/Device.cpp

+3 −0

Original line number	Diff line number	Diff line
		@@ -30,6 +30,7 @@
		#include <algorithm>

		#include <android/log.h>
		#include <hidl/HidlTransportSupport.h>
		#include <mediautils/MemoryLeakTrackUtil.h>
		#include <memunreachable/memunreachable.h>

		@@ -183,6 +184,7 @@ std::tuple<Result, sp<IStreamOut>> Device::openOutputStreamCore(int32_t ioHandle
		if (status == OK) {
		streamOut = new StreamOut(this, halStream);
		++mOpenedStreamsCount;
		android::hardware::setMinSchedulerPolicy(streamOut, SCHED_NORMAL, ANDROID_PRIORITY_AUDIO);
		}
		status_t convertStatus =
		HidlUtils::audioConfigFromHal(halConfig, false /isInput/, suggestedConfig);
		@@ -220,6 +222,7 @@ std::tuple<Result, sp<IStreamIn>> Device::openInputStreamCore(
		if (status == OK) {
		streamIn = new StreamIn(this, halStream);
		++mOpenedStreamsCount;
		android::hardware::setMinSchedulerPolicy(streamIn, SCHED_NORMAL, ANDROID_PRIORITY_AUDIO);
		}
		status_t convertStatus =
		HidlUtils::audioConfigFromHal(halConfig, true /isInput/, suggestedConfig);

audio/core/all-versions/default/DevicesFactory.cpp

+3 −0

Original line number	Diff line number	Diff line
		@@ -23,6 +23,8 @@
		#include <string.h>

		#include <android/log.h>
		#include <hidl/HidlTransportSupport.h>
		#include <system/thread_defs.h>

		namespace android {
		namespace hardware {
		@@ -103,6 +105,7 @@ Return<void> DevicesFactory::openDevice(const char* moduleName, Callback _hidl_c
		int halStatus = loadAudioInterface(moduleName, &halDevice);
		if (halStatus == OK) {
		result = new DeviceShim(halDevice);
		android::hardware::setMinSchedulerPolicy(result, SCHED_NORMAL, ANDROID_PRIORITY_AUDIO);
		retval = Result::OK;
		} else if (halStatus == -EINVAL) {
		retval = Result::NOT_INITIALIZED;

audio/effect/all-versions/default/Effect.cpp

+192 −3

Original line number	Diff line number	Diff line
		@@ -25,8 +25,11 @@
		#define ATRACE_TAG ATRACE_TAG_AUDIO
		#include <HidlUtils.h>
		#include <android/log.h>
		#include <cutils/properties.h>
		#include <media/EffectsFactoryApi.h>
		#include <mediautils/ScopedStatistics.h>
		#include <sys/syscall.h>
		#include <system/audio_effects/effect_spatializer.h>
		#include <util/EffectUtils.h>
		#include <utils/Trace.h>

		@@ -47,6 +50,160 @@ using ::android::hardware::audio::common::COMMON_TYPES_CPP_VERSION::implementati

		namespace {

		/**
		* Some basic scheduling tools.
		*/
		namespace scheduler {

		int getCpu() {
		return sched_getcpu();
		}

		uint64_t getAffinity(pid_t tid) {
		cpu_set_t set;
		CPU_ZERO_S(sizeof(set), &set);

		if (sched_getaffinity(tid, sizeof(set), &set)) {
		ALOGW("%s: for tid:%d returning 0, failed %s", __func__, tid, strerror(errno));
		return 0;
		}
		const int count = CPU_COUNT_S(sizeof(set), &set);
		uint64_t mask = 0;
		for (int i = 0; i < CPU_SETSIZE; ++i) {
		if (CPU_ISSET_S(i, sizeof(set), &set)) {
		mask \|= 1 << i;
		}
		}
		ALOGV("%s: for tid:%d returning cpu count %d mask %llu", __func__, tid, count,
		(unsigned long long)mask);
		return mask;
		}

		status_t setAffinity(pid_t tid, uint64_t mask) {
		cpu_set_t set;
		CPU_ZERO_S(sizeof(set), &set);

		for (uint64_t m = mask; m != 0;) {
		uint64_t tz = __builtin_ctz(m);
		CPU_SET_S(tz, sizeof(set), &set);
		m &= ~(1 << tz);
		}
		if (sched_setaffinity(tid, sizeof(set), &set)) {
		ALOGW("%s: for tid:%d setting cpu mask %llu failed %s", __func__, tid,
		(unsigned long long)mask, strerror(errno));
		return -errno;
		}
		ALOGV("%s: for tid:%d setting cpu mask %llu", __func__, tid, (unsigned long long)mask);
		return OK;
		}

		__unused status_t setPriority(pid_t tid, int policy, int priority) {
		struct sched_param param {
		.sched_priority = priority,
		};
		if (sched_setscheduler(tid, policy, &param) != 0) {
		ALOGW("%s: Cannot set FIFO priority for tid %d to policy %d priority %d %s", __func__, tid,
		policy, priority, strerror(errno));
		return -errno;
		}
		ALOGV("%s: Successfully set priority for tid %d to policy %d priority %d", __func__, tid,
		policy, priority);
		return NO_ERROR;
		}

		status_t setUtilMin(pid_t tid, uint32_t utilMin) {
		// Currently, there is no wrapper in bionic: b/183240349.
		struct {
		uint32_t size;
		uint32_t sched_policy;
		uint64_t sched_flags;
		int32_t sched_nice;
		uint32_t sched_priority;
		uint64_t sched_runtime;
		uint64_t sched_deadline;
		uint64_t sched_period;
		uint32_t sched_util_min;
		uint32_t sched_util_max;
		} attr{
		.size = sizeof(attr),
		.sched_flags = SCHED_FLAG_KEEP_ALL \| SCHED_FLAG_UTIL_CLAMP_MIN,
		.sched_util_min = utilMin,
		};

		if (syscall(__NR_sched_setattr, tid, &attr, 0 /* flags */)) {
		ALOGW("%s: Cannot set sched_util_min for pid %d to %u %s", __func__, tid, utilMin,
		strerror(errno));
		return -errno;
		}
		ALOGV("%s: Successfully set sched_util_min for pid %d to %u", __func__, tid, utilMin);
		return NO_ERROR;
		}

		/*
		Attempts to raise the priority and usage of tid for spatialization.
		Returns OK if everything works.
		*/
		status_t updateSpatializerPriority(pid_t tid) {
		status_t status = OK;

		const int cpu = getCpu();
		ALOGV("%s: current CPU:%d", __func__, cpu);

		const auto currentAffinity = getAffinity(tid);
		ALOGV("%s: current Affinity:%llx", __func__, (unsigned long long)currentAffinity);

		// Set the desired CPU core affinity.
		// Typically this would be done to move the Spatializer effect off of the little cores.
		// The mid cores and large cores typically have more FP/NEON units
		// and will advantageously reduce power and prevent glitches due CPU limitations.
		//
		// Since this is SOC dependent, we do not set the core affinity here but
		// prefer to set the util_clamp_min below.
		//
		constexpr uint64_t kDefaultAffinity = 0;
		const int32_t desiredAffinity =
		property_get_int32("audio.spatializer.effect.affinity", kDefaultAffinity);
		if (desiredAffinity != 0 && (desiredAffinity & ~currentAffinity) == 0) {
		const status_t localStatus = setAffinity(tid, desiredAffinity);
		status = status ? status : localStatus;
		}

		// Set the util_clamp_min.
		// This is beneficial to reduce glitches when starting up, or due to scheduler
		// thread statistics reset (e.g. core migration), which cause the CPU frequency to drop
		// to minimum.
		//
		// Experimentation has found that moving to a mid core over a little core reduces
		// power if the mid core (e.g. A76/78) has more (e.g. 2x) FP/NEON units
		// than the little core (e.g. A55).
		// A possible value is 300.
		//
		constexpr uint32_t kUtilMin = 0;
		const int32_t utilMin = property_get_int32("audio.spatializer.effect.util_clamp_min", kUtilMin);
		if (utilMin > 0 && utilMin <= 1024) {
		const status_t localStatus = setUtilMin(tid, utilMin);
		status = status ? status : localStatus;
		}

		#if 0
		// Provided for local vendor testing but not enabled as audioserver does this for us.
		//
		// Set 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 status_t localStatus = scheduler::setPriority(threadId, SCHED_FIFO, priorityBoost);
		status = status ? status : localStatus;
		}
		#endif

		return status;
		}

		} // namespace scheduler

		#define SCOPED_STATS() \
		::android::mediautils::ScopedStatistics scopedStatistics { \
		std::string("EffectHal::").append(__func__), mEffectHal->mStatistics \
		@@ -83,6 +240,16 @@ class ProcessThread : public Thread {
		};

		bool ProcessThread::threadLoop() {
		// For a spatializer effect, we perform scheduler adjustments to reduce glitches and power.
		{
		effect_descriptor_t halDescriptor{};
		if ((*mEffect)->get_descriptor(mEffect, &halDescriptor) == NO_ERROR &&
		memcmp(&halDescriptor.type, FX_IID_SPATIALIZER, sizeof(effect_uuid_t)) == 0) {
		const status_t status = scheduler::updateSpatializerPriority(gettid());
		ALOGW_IF(status != OK, "Failed to update Spatializer priority");
		}
		}

		// This implementation doesn't return control back to the Thread until it decides to stop,
		// as the Thread uses mutexes, and this can lead to priority inversion.
		while (!std::atomic_load_explicit(mStop, std::memory_order_acquire)) {
		@@ -316,6 +483,11 @@ void Effect::getConfigImpl(int commandCode, const char* commandName, GetConfigCa

		Result Effect::getCurrentConfigImpl(uint32_t featureId, uint32_t configSize,
		GetCurrentConfigSuccessCallback onSuccess) {
		if (configSize > kMaxDataSize - sizeof(uint32_t)) {
		ALOGE("%s: Config size is too big: %" PRIu32, __func__, configSize);
		android_errorWriteLog(0x534e4554, "240266798");
		return Result::INVALID_ARGUMENTS;
		}
		uint32_t halCmd = featureId;
		std::vector<uint32_t> halResult(alignedSizeIn<uint32_t>(sizeof(uint32_t) + configSize), 0);
		uint32_t halResultSize = 0;
		@@ -350,8 +522,12 @@ Result Effect::getParameterImpl(uint32_t paramSize, const void* paramData,

		Result Effect::getSupportedConfigsImpl(uint32_t featureId, uint32_t maxConfigs, uint32_t configSize,
		GetSupportedConfigsSuccessCallback onSuccess) {
		if (maxConfigs != 0 && configSize > (kMaxDataSize - 2 * sizeof(uint32_t)) / maxConfigs) {
		ALOGE("%s: Config size is too big: %" PRIu32, __func__, configSize);
		return Result::INVALID_ARGUMENTS;
		}
		uint32_t halCmd[2] = {featureId, maxConfigs};
		uint32_t halResultSize = 2 * sizeof(uint32_t) + maxConfigs * sizeof(configSize);
		uint32_t halResultSize = 2 * sizeof(uint32_t) + maxConfigs * configSize;
		std::vector<uint8_t> halResult(static_cast<size_t>(halResultSize), 0);
		return sendCommandReturningStatusAndData(
		EFFECT_CMD_GET_FEATURE_SUPPORTED_CONFIGS, "GET_FEATURE_SUPPORTED_CONFIGS", sizeof(halCmd),
		@@ -691,8 +867,21 @@ Return<void> Effect::command(uint32_t commandId, const hidl_vec<uint8_t>& data,

		void* dataPtr = halDataSize > 0 ? &halData[0] : NULL;
		void* resultPtr = halResultSize > 0 ? &halResult[0] : NULL;
		status_t status =
		(*mHandle)->command(mHandle, commandId, halDataSize, dataPtr, &halResultSize, resultPtr);
		status_t status = BAD_VALUE;
		switch (commandId) {
		case 'gtid': // retrieve the tid, used for spatializer priority boost
		if (halDataSize == 0 && resultMaxSize == sizeof(int32_t)) {
		auto ptid = (int32_t*)resultPtr;
		ptid[0] = mProcessThread ? mProcessThread->getTid() : -1;
		status = OK;
		break; // we have handled 'gtid' here.
		}
		[[fallthrough]]; // allow 'gtid' overload (checked halDataSize and resultMaxSize).
		default:
		status = (*mHandle)->command(mHandle, commandId, halDataSize, dataPtr, &halResultSize,
		resultPtr);
		break;
		}
		hidl_vec<uint8_t> result;
		if (status == OK && resultPtr != NULL) {
		result.setToExternal(&halResult[0], halResultSize);

audio/effect/all-versions/default/Effect.h

+3 −0

Original line number	Diff line number	Diff line
		@@ -184,6 +184,9 @@ struct Effect : public IEffect {
		using GetSupportedConfigsSuccessCallback =
		std::function<void(uint32_t supportedConfigs, void* configsData)>;

		// Sets the limit on the maximum size of vendor-provided data structures.
		static constexpr size_t kMaxDataSize = 1 << 20;

		static const char* sContextResultOfCommand;
		static const char* sContextCallToCommand;
		static const char* sContextCallFunction;