Merge "Added APIs for audio preprocessing" (6e6e8a6c) · Commits · e / os / android_frameworks_av

include/media/AudioEffect.h

+31 −0

Original line number	Diff line number	Diff line
		@@ -21,6 +21,7 @@
		#include <sys/types.h>

		#include <media/IAudioFlinger.h>
		#include <media/IAudioPolicyService.h>
		#include <media/IEffect.h>
		#include <media/IEffectClient.h>
		#include <hardware/audio_effect.h>
		@@ -110,6 +111,36 @@ public:
		static status_t getEffectDescriptor(effect_uuid_t uuid, effect_descriptor_t descriptor);


		/*
		* Returns a list of descriptors corresponding to the pre processings enabled by default
		* on an AudioRecord with the supplied audio session ID.
		*
		* Parameters:
		* audioSession: audio session ID.
		* descriptors: address where the effect descriptors should be returned.
		* count: as input, the maximum number of descriptor than should be returned
		* as output, the number of descriptor returned if status is NO_ERROR or the actual
		* number of enabled pre processings if status is NO_MEMORY
		*
		* Returned status (from utils/Errors.h) can be:
		* NO_ERROR successful operation.
		* NO_MEMORY the number of descriptor to return is more than the maximum number
		* indicated by count.
		* PERMISSION_DENIED could not get AudioFlinger interface
		* NO_INIT effect library failed to initialize
		* BAD_VALUE invalid audio session or descriptor pointers
		*
		* Returned value
		* *descriptor updated with descriptors of pre processings enabled by default
		* *count number of descriptors returned if returned status is N_ERROR.
		* total number of pre processing enabled by default if returned status is
		* NO_MEMORY. This happens if the count passed as input is less than the number
		* of descriptors to return
		*/
		static status_t queryDefaultPreProcessing(int audioSession,
		effect_descriptor_t *descriptors,
		uint32_t *count);

		/*
		* Events used by callback function (effect_callback_t).
		*/

include/media/IAudioPolicyService.h

+3 −0

Original line number	Diff line number	Diff line
		@@ -85,6 +85,9 @@ public:
		int id) = 0;
		virtual status_t unregisterEffect(int id) = 0;
		virtual bool isStreamActive(int stream, uint32_t inPastMs = 0) const = 0;
		virtual status_t queryDefaultPreProcessing(int audioSession,
		effect_descriptor_t *descriptors,
		uint32_t *count) = 0;
		};

media/libmedia/AudioEffect.cpp

+9 −0

Original line number	Diff line number	Diff line
		@@ -419,6 +419,15 @@ status_t AudioEffect::getEffectDescriptor(effect_uuid_t *uuid, effect_descriptor
		return af->getEffectDescriptor(uuid, descriptor);
		}


		status_t AudioEffect::queryDefaultPreProcessing(int audioSession,
		effect_descriptor_t *descriptors,
		uint32_t *count)
		{
		const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
		if (aps == 0) return PERMISSION_DENIED;
		return aps->queryDefaultPreProcessing(audioSession, descriptors, count);
		}
		// -------------------------------------------------------------------------

		status_t AudioEffect::stringToGuid(const char str, effect_uuid_t guid)

media/libmedia/IAudioPolicyService.cpp

+49 −0

Original line number	Diff line number	Diff line
		@@ -53,6 +53,7 @@ enum {
		UNREGISTER_EFFECT,
		IS_STREAM_ACTIVE,
		GET_DEVICES_FOR_STREAM,
		QUERY_DEFAULT_PRE_PROCESSING
		};

		class BpAudioPolicyService : public BpInterface<IAudioPolicyService>
		@@ -321,6 +322,31 @@ public:
		remote()->transact(IS_STREAM_ACTIVE, data, &reply);
		return reply.readInt32();
		}

		virtual status_t queryDefaultPreProcessing(int audioSession,
		effect_descriptor_t *descriptors,
		uint32_t *count)
		{
		if (descriptors == NULL \|\| count == NULL) {
		return BAD_VALUE;
		}
		Parcel data, reply;
		data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
		data.writeInt32(audioSession);
		data.writeInt32(*count);
		status_t status = remote()->transact(QUERY_DEFAULT_PRE_PROCESSING, data, &reply);
		if (status != NO_ERROR) {
		return status;
		}
		status = static_cast <status_t> (reply.readInt32());
		uint32_t retCount = reply.readInt32();
		if (retCount != 0) {
		uint32_t numDesc = (retCount < count) ? retCount : count;
		reply.read(descriptors, sizeof(effect_descriptor_t) * numDesc);
		}
		*count = retCount;
		return status;
		}
		};

		IMPLEMENT_META_INTERFACE(AudioPolicyService, "android.media.IAudioPolicyService");
		@@ -559,6 +585,29 @@ status_t BnAudioPolicyService::onTransact(
		return NO_ERROR;
		} break;

		case QUERY_DEFAULT_PRE_PROCESSING: {
		CHECK_INTERFACE(IAudioPolicyService, data, reply);
		int audioSession = data.readInt32();
		uint32_t count = data.readInt32();
		uint32_t retCount = count;
		effect_descriptor_t *descriptors =
		(effect_descriptor_t )new char[count sizeof(effect_descriptor_t)];
		status_t status = queryDefaultPreProcessing(audioSession, descriptors, &retCount);
		reply->writeInt32(status);
		if (status != NO_ERROR && status != NO_MEMORY) {
		retCount = 0;
		}
		reply->writeInt32(retCount);
		if (retCount) {
		if (retCount < count) {
		count = retCount;
		}
		reply->write(descriptors, sizeof(effect_descriptor_t) * count);
		}
		delete[] descriptors;
		return status;
		}

		default:
		return BBinder::onTransact(code, data, reply, flags);
		}

services/audioflinger/AudioPolicyService.cpp

+37 −0

Original line number	Diff line number	Diff line
		@@ -497,6 +497,43 @@ bool AudioPolicyService::isStreamActive(int stream, uint32_t inPastMs) const
		return mpAudioPolicy->is_stream_active(mpAudioPolicy, stream, inPastMs);
		}

		status_t AudioPolicyService::queryDefaultPreProcessing(int audioSession,
		effect_descriptor_t *descriptors,
		uint32_t *count)
		{

		if (mpAudioPolicy == NULL) {
		*count = 0;
		return NO_INIT;
		}
		Mutex::Autolock _l(mLock);
		status_t status = NO_ERROR;

		size_t index;
		for (index = 0; index < mInputs.size(); index++) {
		if (mInputs.valueAt(index)->mSessionId == audioSession) {
		break;
		}
		}
		if (index == mInputs.size()) {
		*count = 0;
		return BAD_VALUE;
		}
		Vector< sp<AudioEffect> > effects = mInputs.valueAt(index)->mEffects;

		for (size_t i = 0; i < effects.size(); i++) {
		effect_descriptor_t desc = effects[i]->descriptor();
		if (i < *count) {
		memcpy(descriptors + i, &desc, sizeof(effect_descriptor_t));
		}
		}
		if (effects.size() > *count) {
		status = NO_MEMORY;
		}
		*count = effects.size();
		return status;
		}

		void AudioPolicyService::binderDied(const wp<IBinder>& who) {
		LOGW("binderDied() %p, tid %d, calling tid %d", who.unsafe_get(), gettid(),
		IPCThreadState::self()->getCallingPid());