Merge "Revert "Add interface to query the mmap support."" (192dcb61) · Commits · e / os / android_frameworks_av

media/audioserver/Android.bp

+1 −1

Original line number	Diff line number	Diff line
		@@ -26,7 +26,6 @@ cc_binary {

		shared_libs: [
		"libaaudioservice",
		"libaudioclient",
		"libaudioflinger",
		"libaudiopolicyservice",
		"libaudioprocessing",
		@@ -42,6 +41,7 @@ cc_binary {
		"libpowermanager",
		"libutils",
		"libvibrator",

		],

		// TODO check if we still need all of these include directories

media/audioserver/main_audioserver.cpp

+4 −24

Original line number	Diff line number	Diff line
		@@ -17,26 +17,20 @@
		#define LOG_TAG "audioserver"
		//#define LOG_NDEBUG 0

		#include <algorithm>

		#include <fcntl.h>
		#include <sys/prctl.h>
		#include <sys/wait.h>
		#include <cutils/properties.h>

		#include <android/media/AudioMMapPolicy.h>
		#include <android/media/AudioMMapPolicyInfo.h>
		#include <android/media/AudioMMapPolicyType.h>
		#include <android/media/IAudioFlingerService.h>
		#include <binder/IPCThreadState.h>
		#include <binder/ProcessState.h>
		#include <binder/IServiceManager.h>
		#include <binder/IInterface.h>
		#include <hidl/HidlTransportSupport.h>
		#include <mediautils/LimitProcessMemory.h>
		#include <utils/Log.h>

		// from include_dirs
		#include "aaudio/AAudioTesting.h" // aaudio_policy_t, AAUDIO_PROP_MMAP_POLICY, AAUDIO_POLICY_*
		#include "AudioFlinger.h"
		#include "AudioPolicyService.h"
		#include "AAudioService.h"
		@@ -152,24 +146,10 @@ int main(int argc __unused, char **argv)
		// AAudioService should only be used in OC-MR1 and later.
		// And only enable the AAudioService if the system MMAP policy explicitly allows it.
		// This prevents a client from misusing AAudioService when it is not supported.
		// If we cannot get audio flinger here, there must be some serious problems. In that case,
		// attempting to call audio flinger on a null pointer could make the process crash
		// and attract attentions.
		sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
		std::vector<media::AudioMMapPolicyInfo> policyInfos;
		status_t status = af->getMmapPolicyInfos(
		media::AudioMMapPolicyType::DEFAULT, &policyInfos);
		// Initialize aaudio service when querying mmap policy succeeds and
		// any of the policy supports MMAP.
		if (status == NO_ERROR \|\|
		std::any_of(policyInfos.begin(), policyInfos.end(), [](const auto& info) {
		return info.mmapPolicy == media::AudioMMapPolicy::AUTO \|\|
		info.mmapPolicy == media::AudioMMapPolicy::ALWAYS;
		})) {
		aaudio_policy_t mmapPolicy = property_get_int32(AAUDIO_PROP_MMAP_POLICY,
		AAUDIO_POLICY_NEVER);
		if (mmapPolicy == AAUDIO_POLICY_AUTO \|\| mmapPolicy == AAUDIO_POLICY_ALWAYS) {
		AAudioService::instantiate();
		} else {
		ALOGD("Do not init aaudio service, status %d, policy info size %zu",
		status, policyInfos.size());
		}

		ProcessState::self()->startThreadPool();

media/libaaudio/src/core/AudioStreamBuilder.cpp

+6 −49

Original line number	Diff line number	Diff line
		@@ -20,14 +20,9 @@

		#include <new>
		#include <stdint.h>
		#include <vector>

		#include <aaudio/AAudio.h>
		#include <aaudio/AAudioTesting.h>
		#include <android/media/AudioMMapPolicy.h>
		#include <android/media/AudioMMapPolicyInfo.h>
		#include <android/media/AudioMMapPolicyType.h>
		#include <media/AudioSystem.h>

		#include "binding/AAudioBinderClient.h"
		#include "client/AudioStreamInternalCapture.h"
		@@ -91,37 +86,6 @@ static aaudio_result_t builder_createStream(aaudio_direction_t direction,
		return result;
		}

		namespace {

		aaudio_policy_t aidl2legacy_aaudio_policy(android::media::AudioMMapPolicy aidl) {
		switch (aidl) {
		case android::media::AudioMMapPolicy::NEVER:
		return AAUDIO_POLICY_NEVER;
		case android::media::AudioMMapPolicy::AUTO:
		return AAUDIO_POLICY_AUTO;
		case android::media::AudioMMapPolicy::ALWAYS:
		return AAUDIO_POLICY_ALWAYS;
		case android::media::AudioMMapPolicy::UNSPECIFIED:
		default:
		return AAUDIO_UNSPECIFIED;
		}
		}

		// The aaudio policy will be ALWAYS, NEVER, UNSPECIFIED only when all policy info are
		// ALWAYS, NEVER or UNSPECIFIED. Otherwise, the aaudio policy will be AUTO.
		aaudio_policy_t getAAudioPolicy(
		const std::vector<android::media::AudioMMapPolicyInfo>& policyInfos) {
		if (policyInfos.empty()) return AAUDIO_POLICY_AUTO;
		for (size_t i = 1; i < policyInfos.size(); ++i) {
		if (policyInfos.at(i).mmapPolicy != policyInfos.at(0).mmapPolicy) {
		return AAUDIO_POLICY_AUTO;
		}
		}
		return aidl2legacy_aaudio_policy(policyInfos.at(0).mmapPolicy);
		}

		} // namespace

		// Try to open using MMAP path if that is allowed.
		// Fall back to Legacy path if MMAP not available.
		// Exact behavior is controlled by MMapPolicy.
		@@ -140,32 +104,25 @@ aaudio_result_t AudioStreamBuilder::build(AudioStream** streamPtr) {
		return result;
		}

		std::vector<android::media::AudioMMapPolicyInfo> policyInfos;
		// The API setting is the highest priority.
		aaudio_policy_t mmapPolicy = AudioGlobal_getMMapPolicy();
		// If not specified then get from a system property.
		if (mmapPolicy == AAUDIO_UNSPECIFIED && android::AudioSystem::getMmapPolicyInfo(
		android::media::AudioMMapPolicyType::DEFAULT, &policyInfos) == NO_ERROR) {
		mmapPolicy = getAAudioPolicy(policyInfos);
		if (mmapPolicy == AAUDIO_UNSPECIFIED) {
		mmapPolicy = AAudioProperty_getMMapPolicy();
		}
		// If still not specified then use the default.
		if (mmapPolicy == AAUDIO_UNSPECIFIED) {
		mmapPolicy = AAUDIO_MMAP_POLICY_DEFAULT;
		}

		policyInfos.clear();
		aaudio_policy_t mmapExclusivePolicy = AAUDIO_UNSPECIFIED;
		if (android::AudioSystem::getMmapPolicyInfo(
		android::media::AudioMMapPolicyType::EXCLUSIVE, &policyInfos) == NO_ERROR) {
		mmapExclusivePolicy = getAAudioPolicy(policyInfos);
		}
		if (mmapExclusivePolicy == AAUDIO_UNSPECIFIED) {
		mmapExclusivePolicy = AAUDIO_MMAP_EXCLUSIVE_POLICY_DEFAULT;
		int32_t mapExclusivePolicy = AAudioProperty_getMMapExclusivePolicy();
		if (mapExclusivePolicy == AAUDIO_UNSPECIFIED) {
		mapExclusivePolicy = AAUDIO_MMAP_EXCLUSIVE_POLICY_DEFAULT;
		}

		aaudio_sharing_mode_t sharingMode = getSharingMode();
		if ((sharingMode == AAUDIO_SHARING_MODE_EXCLUSIVE)
		&& (mmapExclusivePolicy == AAUDIO_POLICY_NEVER)) {
		&& (mapExclusivePolicy == AAUDIO_POLICY_NEVER)) {
		ALOGD("%s() EXCLUSIVE sharing mode not supported. Use SHARED.", __func__);
		sharingMode = AAUDIO_SHARING_MODE_SHARED;
		setSharingMode(sharingMode);

media/libaudioclient/Android.bp

+0 −3

Original line number	Diff line number	Diff line
		@@ -328,9 +328,6 @@ aidl_interface {
		"aidl/android/media/AudioIoConfigEvent.aidl",
		"aidl/android/media/AudioIoDescriptor.aidl",
		"aidl/android/media/AudioIoFlags.aidl",
		"aidl/android/media/AudioMMapPolicy.aidl",
		"aidl/android/media/AudioMMapPolicyInfo.aidl",
		"aidl/android/media/AudioMMapPolicyType.aidl",
		"aidl/android/media/AudioMixLatencyClass.aidl",
		"aidl/android/media/AudioMode.aidl",
		"aidl/android/media/AudioOutputFlags.aidl",

media/libaudioclient/AudioSystem.cpp

+0 −10

Original line number	Diff line number	Diff line
		@@ -2358,16 +2358,6 @@ status_t AudioSystem::setVibratorInfos(
		return af->setVibratorInfos(vibratorInfos);
		}

		status_t AudioSystem::getMmapPolicyInfo(
		media::AudioMMapPolicyType policyType,
		std::vector<media::AudioMMapPolicyInfo> *policyInfos) {
		const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
		if (af == nullptr) {
		return PERMISSION_DENIED;
		}
		return af->getMmapPolicyInfos(policyType, policyInfos);
		}

		// ---------------------------------------------------------------------------

		int AudioSystem::AudioPolicyServiceClient::addAudioPortCallback(