am e1715a46: audio policy: add audio port gain control (481c8837) · Commits · e / os / android_frameworks_av

services/audioflinger/PatchPanel.cpp

+28 −3

Original line number	Original line	Diff line number	Diff line
	@@ -404,13 +404,38 @@ status_t AudioFlinger::PatchPanel::listAudioPatches(unsigned int *num_patches __
	}		}

	/* Set audio port configuration */		/* Set audio port configuration */
	status_t AudioFlinger::PatchPanel::setAudioPortConfig(		status_t AudioFlinger::PatchPanel::setAudioPortConfig(const struct audio_port_config *config)
	const struct audio_port_config *config __unused)
	{		{
	ALOGV("setAudioPortConfig");		ALOGV("setAudioPortConfig");
	return NO_ERROR;		status_t status = NO_ERROR;

			sp<AudioFlinger> audioflinger = mAudioFlinger.promote();
			if (audioflinger == 0) {
			return NO_INIT;
			}

			audio_module_handle_t module;
			if (config->type == AUDIO_PORT_TYPE_DEVICE) {
			module = config->ext.device.hw_module;
			} else {
			module = config->ext.mix.hw_module;
			}

			ssize_t index = audioflinger->mAudioHwDevs.indexOfKey(module);
			if (index < 0) {
			ALOGW("setAudioPortConfig() bad hw module %d", module);
			return BAD_VALUE;
	}		}

			AudioHwDevice *audioHwDevice = audioflinger->mAudioHwDevs.valueAt(index);
			if (audioHwDevice->version() >= AUDIO_DEVICE_API_VERSION_3_0) {
			audio_hw_device_t *hwDevice = audioHwDevice->hwDevice();
			return hwDevice->set_audio_port_config(hwDevice, config);
			} else {
			return INVALID_OPERATION;
			}
			return NO_ERROR;
			}


	}; // namespace android		}; // namespace android

services/audiopolicy/AudioPolicyClientImpl.cpp

+7 −0

Original line number	Original line	Diff line number	Diff line
	@@ -195,6 +195,13 @@ status_t AudioPolicyService::AudioPolicyClient::releaseAudioPatch(audio_patch_ha
	return mAudioPolicyService->clientReleaseAudioPatch(handle, delayMs);		return mAudioPolicyService->clientReleaseAudioPatch(handle, delayMs);
	}		}

			status_t AudioPolicyService::AudioPolicyClient::setAudioPortConfig(
			const struct audio_port_config *config,
			int delayMs)
			{
			return mAudioPolicyService->clientSetAudioPortConfig(config, delayMs);
			}

	void AudioPolicyService::AudioPolicyClient::onAudioPortListUpdate()		void AudioPolicyService::AudioPolicyClient::onAudioPortListUpdate()
	{		{
	mAudioPolicyService->onAudioPortListUpdate();		mAudioPolicyService->onAudioPortListUpdate();

services/audiopolicy/AudioPolicyInterface.h

+3 −0

Original line number	Original line	Diff line number	Diff line
	@@ -273,6 +273,9 @@ public:
	virtual status_t releaseAudioPatch(audio_patch_handle_t handle,		virtual status_t releaseAudioPatch(audio_patch_handle_t handle,
	int delayMs) = 0;		int delayMs) = 0;

			/* Set audio port configuration */
			virtual status_t setAudioPortConfig(const struct audio_port_config *config, int delayMs) = 0;

	virtual void onAudioPortListUpdate() = 0;		virtual void onAudioPortListUpdate() = 0;

	virtual void onAudioPatchListUpdate() = 0;		virtual void onAudioPatchListUpdate() = 0;

services/audiopolicy/AudioPolicyManager.cpp

+94 −3

Original line number	Original line	Diff line number	Diff line
	@@ -2019,9 +2019,93 @@ status_t AudioPolicyManager::listAudioPatches(unsigned int *num_patches,
	return NO_ERROR;		return NO_ERROR;
	}		}

	status_t AudioPolicyManager::setAudioPortConfig(const struct audio_port_config *config __unused)		status_t AudioPolicyManager::setAudioPortConfig(const struct audio_port_config *config)
	{		{
	return NO_ERROR;		ALOGV("setAudioPortConfig()");

			if (config == NULL) {
			return BAD_VALUE;
			}
			ALOGV("setAudioPortConfig() on port handle %d", config->id);
			// Only support gain configuration for now
			if (config->config_mask != AUDIO_PORT_CONFIG_GAIN \|\| config->gain.index < 0) {
			return BAD_VALUE;
			}

			sp<AudioPort> portDesc;
			struct audio_port_config portConfig;
			if (config->type == AUDIO_PORT_TYPE_MIX) {
			if (config->role == AUDIO_PORT_ROLE_SOURCE) {
			AudioOutputDescriptor *outputDesc = getOutputFromId(config->id);
			if (outputDesc == NULL) {
			return BAD_VALUE;
			}
			portDesc = outputDesc->mProfile;
			outputDesc->toAudioPortConfig(&portConfig);
			} else if (config->role == AUDIO_PORT_ROLE_SINK) {
			AudioInputDescriptor *inputDesc = getInputFromId(config->id);
			if (inputDesc == NULL) {
			return BAD_VALUE;
			}
			portDesc = inputDesc->mProfile;
			inputDesc->toAudioPortConfig(&portConfig);
			} else {
			return BAD_VALUE;
			}
			} else if (config->type == AUDIO_PORT_TYPE_DEVICE) {
			sp<DeviceDescriptor> deviceDesc;
			if (config->role == AUDIO_PORT_ROLE_SOURCE) {
			deviceDesc = mAvailableInputDevices.getDeviceFromId(config->id);
			} else if (config->role == AUDIO_PORT_ROLE_SINK) {
			deviceDesc = mAvailableOutputDevices.getDeviceFromId(config->id);
			} else {
			return BAD_VALUE;
			}
			if (deviceDesc == NULL) {
			return BAD_VALUE;
			}
			portDesc = deviceDesc;
			deviceDesc->toAudioPortConfig(&portConfig);
			} else {
			return BAD_VALUE;
			}

			if ((size_t)config->gain.index >= portDesc->mGains.size()) {
			return INVALID_OPERATION;
			}
			const struct audio_gain *gain = &portDesc->mGains[config->gain.index]->mGain;
			if ((config->gain.mode & ~gain->mode) != 0) {
			return BAD_VALUE;
			}
			if ((config->gain.mode & AUDIO_GAIN_MODE_JOINT) == AUDIO_GAIN_MODE_JOINT) {
			if ((config->gain.values[0] < gain->min_value) \|\|
			(config->gain.values[0] > gain->max_value)) {
			return BAD_VALUE;
			}
			} else {
			if ((config->gain.channel_mask & ~gain->channel_mask) != 0) {
			return BAD_VALUE;
			}
			size_t numValues = popcount(config->gain.channel_mask);
			for (size_t i = 0; i < numValues; i++) {
			if ((config->gain.values[i] < gain->min_value) \|\|
			(config->gain.values[i] > gain->max_value)) {
			return BAD_VALUE;
			}
			}
			}
			if ((config->gain.mode & AUDIO_GAIN_MODE_RAMP) == AUDIO_GAIN_MODE_RAMP) {
			if ((config->gain.ramp_duration_ms < gain->min_ramp_ms) \|\|
			(config->gain.ramp_duration_ms > gain->max_ramp_ms)) {
			return BAD_VALUE;
			}
			}

			portConfig.gain = config->gain;

			status_t status = mpClientInterface->setAudioPortConfig(&portConfig, 0);

			return status;
	}		}

	void AudioPolicyManager::clearAudioPatches(uid_t uid)		void AudioPolicyManager::clearAudioPatches(uid_t uid)
	@@ -4860,7 +4944,13 @@ void AudioPolicyManager::AudioPort::toAudioPort(struct audio_port *port) const
	port->formats[i] = mFormats[i];		port->formats[i] = mFormats[i];
	}		}
	port->num_formats = i;		port->num_formats = i;
	port->num_gains = 0;
			ALOGV("AudioPort::toAudioPort() num gains %d", mGains.size());

			for (i = 0; i < mGains.size() && i < AUDIO_PORT_MAX_GAINS; i++) {
			port->gains[i] = mGains[i]->mGain;
			}
			port->num_gains = i;
	}		}


	@@ -5416,6 +5506,7 @@ void AudioPolicyManager::DeviceDescriptor::toAudioPortConfig(

	void AudioPolicyManager::DeviceDescriptor::toAudioPort(struct audio_port *port) const		void AudioPolicyManager::DeviceDescriptor::toAudioPort(struct audio_port *port) const
	{		{
			ALOGV("DeviceVector::toAudioPort() handle %d type %x", mId, mDeviceType);
	AudioPort::toAudioPort(port);		AudioPort::toAudioPort(port);
	port->id = mId;		port->id = mId;
	toAudioPortConfig(&port->active_config);		toAudioPortConfig(&port->active_config);

services/audiopolicy/AudioPolicyService.cpp

+29 −0

Original line number	Original line	Diff line number	Diff line
	@@ -226,6 +226,12 @@ void AudioPolicyService::doOnAudioPatchListUpdate()
	}		}
	}		}

			status_t AudioPolicyService::clientSetAudioPortConfig(const struct audio_port_config *config,
			int delayMs)
			{
			return mAudioCommandThread->setAudioPortConfigCommand(config, delayMs);
			}

	AudioPolicyService::NotificationClient::NotificationClient(const sp<AudioPolicyService>& service,		AudioPolicyService::NotificationClient::NotificationClient(const sp<AudioPolicyService>& service,
	const sp<IAudioPolicyServiceClient>& client,		const sp<IAudioPolicyServiceClient>& client,
	uid_t uid)		uid_t uid)
	@@ -506,6 +512,16 @@ bool AudioPolicyService::AudioCommandThread::threadLoop()
	svc->doOnAudioPatchListUpdate();		svc->doOnAudioPatchListUpdate();
	mLock.lock();		mLock.lock();
	}break;		}break;
			case SET_AUDIOPORT_CONFIG: {
			SetAudioPortConfigData data = (SetAudioPortConfigData )command->mParam.get();
			ALOGV("AudioCommandThread() processing set port config");
			sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
			if (af == 0) {
			command->mStatus = PERMISSION_DENIED;
			} else {
			command->mStatus = af->setAudioPortConfig(&data->mConfig);
			}
			} break;
	default:		default:
	ALOGW("AudioCommandThread() unknown command %d", command->mCommand);		ALOGW("AudioCommandThread() unknown command %d", command->mCommand);
	}		}
	@@ -716,6 +732,19 @@ void AudioPolicyService::AudioCommandThread::updateAudioPatchListCommand()
	sendCommand(command);		sendCommand(command);
	}		}

			status_t AudioPolicyService::AudioCommandThread::setAudioPortConfigCommand(
			const struct audio_port_config *config, int delayMs)
			{
			sp<AudioCommand> command = new AudioCommand();
			command->mCommand = SET_AUDIOPORT_CONFIG;
			SetAudioPortConfigData *data = new SetAudioPortConfigData();
			data->mConfig = *config;
			command->mParam = data;
			command->mWaitStatus = true;
			ALOGV("AudioCommandThread() adding set port config delay %d", delayMs);
			return sendCommand(command, delayMs);
			}

	status_t AudioPolicyService::AudioCommandThread::sendCommand(sp<AudioCommand>& command, int delayMs)		status_t AudioPolicyService::AudioCommandThread::sendCommand(sp<AudioCommand>& command, int delayMs)
	{		{
	{		{