am 6a94d69d: audio policy: implement routing control (671714b8) · Commits · e / os / android_frameworks_av

services/audioflinger/PatchPanel.cpp

+12 −5

Original line number	Diff line number	Diff line
		@@ -179,11 +179,11 @@ status_t AudioFlinger::PatchPanel::createAudioPatch(const struct audio_patch *pa
		ALOGW("createAudioPatch() bad src hw module %d", src_module);
		return BAD_VALUE;
		}
		AudioHwDevice *audioHwDevice = audioflinger->mAudioHwDevs.valueAt(index);
		for (unsigned int i = 0; i < patch->num_sinks; i++) {
		// limit to connections between devices and output streams
		if (patch->sinks[i].type != AUDIO_PORT_TYPE_MIX) {
		ALOGW("createAudioPatch() invalid sink type %d for device source",
		patch->sinks[i].type);
		// reject connection to different sink types
		if (patch->sinks[i].type != patch->sinks[0].type) {
		ALOGW("createAudioPatch() different sink types in same patch not supported");
		return BAD_VALUE;
		}
		// limit to connections between sinks and sources on same HW module
		@@ -192,9 +192,16 @@ status_t AudioFlinger::PatchPanel::createAudioPatch(const struct audio_patch *pa
		"sink on module %d", src_module, patch->sinks[i].ext.mix.hw_module);
		return BAD_VALUE;
		}

		// limit to connections between devices and output streams for HAL before 3.0
		if ((audioHwDevice->version() < AUDIO_DEVICE_API_VERSION_3_0) &&
		(patch->sinks[i].type != AUDIO_PORT_TYPE_MIX)) {
		ALOGW("createAudioPatch() invalid sink type %d for device source",
		patch->sinks[i].type);
		return BAD_VALUE;
		}
		}

		AudioHwDevice *audioHwDevice = audioflinger->mAudioHwDevs.valueAt(index);
		if (audioHwDevice->version() >= AUDIO_DEVICE_API_VERSION_3_0) {
		if (patch->sinks[0].type == AUDIO_PORT_TYPE_MIX) {
		sp<ThreadBase> thread = audioflinger->checkRecordThread_l(

services/audiopolicy/AudioPolicyInterface.h

+18 −0

Original line number	Diff line number	Diff line
		@@ -162,6 +162,24 @@ public:
		virtual status_t dump(int fd) = 0;

		virtual bool isOffloadSupported(const audio_offload_info_t& offloadInfo) = 0;

		virtual status_t listAudioPorts(audio_port_role_t role,
		audio_port_type_t type,
		unsigned int *num_ports,
		struct audio_port *ports,
		unsigned int *generation) = 0;
		virtual status_t getAudioPort(struct audio_port *port) = 0;
		virtual status_t createAudioPatch(const struct audio_patch *patch,
		audio_patch_handle_t *handle,
		uid_t uid) = 0;
		virtual status_t releaseAudioPatch(audio_patch_handle_t handle,
		uid_t uid) = 0;
		virtual status_t listAudioPatches(unsigned int *num_patches,
		struct audio_patch *patches,
		unsigned int *generation) = 0;
		virtual status_t setAudioPortConfig(const struct audio_port_config *config) = 0;
		virtual void clearAudioPatches(uid_t uid) = 0;

		};

services/audiopolicy/AudioPolicyInterfaceImpl.cpp

+48 −19

Original line number	Diff line number	Diff line
		@@ -463,43 +463,72 @@ bool AudioPolicyService::isOffloadSupported(const audio_offload_info_t& info)
		return mAudioPolicyManager->isOffloadSupported(info);
		}

		status_t AudioPolicyService::listAudioPorts(audio_port_role_t role __unused,
		audio_port_type_t type __unused,
		status_t AudioPolicyService::listAudioPorts(audio_port_role_t role,
		audio_port_type_t type,
		unsigned int *num_ports,
		struct audio_port *ports __unused,
		unsigned int *generation __unused)
		struct audio_port *ports,
		unsigned int *generation)
		{
		*num_ports = 0;
		return INVALID_OPERATION;
		Mutex::Autolock _l(mLock);
		if (mAudioPolicyManager == NULL) {
		return NO_INIT;
		}

		return mAudioPolicyManager->listAudioPorts(role, type, num_ports, ports, generation);
		}

		status_t AudioPolicyService::getAudioPort(struct audio_port *port __unused)
		status_t AudioPolicyService::getAudioPort(struct audio_port *port)
		{
		return INVALID_OPERATION;
		Mutex::Autolock _l(mLock);
		if (mAudioPolicyManager == NULL) {
		return NO_INIT;
		}

		status_t AudioPolicyService::createAudioPatch(const struct audio_patch *patch __unused,
		audio_patch_handle_t *handle __unused)
		return mAudioPolicyManager->getAudioPort(port);
		}

		status_t AudioPolicyService::createAudioPatch(const struct audio_patch *patch,
		audio_patch_handle_t *handle)
		{
		return INVALID_OPERATION;
		Mutex::Autolock _l(mLock);
		if (mAudioPolicyManager == NULL) {
		return NO_INIT;
		}
		return mAudioPolicyManager->createAudioPatch(patch, handle,
		IPCThreadState::self()->getCallingUid());
		}

		status_t AudioPolicyService::releaseAudioPatch(audio_patch_handle_t handle __unused)
		status_t AudioPolicyService::releaseAudioPatch(audio_patch_handle_t handle)
		{
		return INVALID_OPERATION;
		Mutex::Autolock _l(mLock);
		if (mAudioPolicyManager == NULL) {
		return NO_INIT;
		}

		return mAudioPolicyManager->releaseAudioPatch(handle,
		IPCThreadState::self()->getCallingUid());
		}

		status_t AudioPolicyService::listAudioPatches(unsigned int *num_patches,
		struct audio_patch *patches __unused,
		unsigned int *generation __unused)
		struct audio_patch *patches,
		unsigned int *generation)
		{
		*num_patches = 0;
		return INVALID_OPERATION;
		Mutex::Autolock _l(mLock);
		if (mAudioPolicyManager == NULL) {
		return NO_INIT;
		}

		status_t AudioPolicyService::setAudioPortConfig(const struct audio_port_config *config __unused)
		return mAudioPolicyManager->listAudioPatches(num_patches, patches, generation);
		}

		status_t AudioPolicyService::setAudioPortConfig(const struct audio_port_config *config)
		{
		return INVALID_OPERATION;
		Mutex::Autolock _l(mLock);
		if (mAudioPolicyManager == NULL) {
		return NO_INIT;
		}

		return mAudioPolicyManager->setAudioPortConfig(config);
		}

		}; // namespace android