AudioFlinger: update openInput() and openOutput() (cf2c0210) · Commits · e / os / android_frameworks_av

include/media/IAudioFlinger.h

+14 −14

Original line number	Diff line number	Diff line
		@@ -145,25 +145,25 @@ public:
		virtual size_t getInputBufferSize(uint32_t sampleRate, audio_format_t format,
		audio_channel_mask_t channelMask) const = 0;

		virtual audio_io_handle_t openOutput(audio_module_handle_t module,
		audio_devices_t *pDevices,
		uint32_t *pSamplingRate,
		audio_format_t *pFormat,
		audio_channel_mask_t *pChannelMask,
		uint32_t *pLatencyMs,
		audio_output_flags_t flags,
		const audio_offload_info_t *offloadInfo = NULL) = 0;
		virtual status_t openOutput(audio_module_handle_t module,
		audio_io_handle_t *output,
		audio_config_t *config,
		audio_devices_t *devices,
		const String8& address,
		uint32_t *latencyMs,
		audio_output_flags_t flags) = 0;
		virtual audio_io_handle_t openDuplicateOutput(audio_io_handle_t output1,
		audio_io_handle_t output2) = 0;
		virtual status_t closeOutput(audio_io_handle_t output) = 0;
		virtual status_t suspendOutput(audio_io_handle_t output) = 0;
		virtual status_t restoreOutput(audio_io_handle_t output) = 0;

		virtual audio_io_handle_t openInput(audio_module_handle_t module,
		audio_devices_t *pDevices,
		uint32_t *pSamplingRate,
		audio_format_t *pFormat,
		audio_channel_mask_t *pChannelMask,
		virtual status_t openInput(audio_module_handle_t module,
		audio_io_handle_t *input,
		audio_config_t *config,
		audio_devices_t *device,
		const String8& address,
		audio_source_t source,
		audio_input_flags_t flags) = 0;
		virtual status_t closeInput(audio_io_handle_t input) = 0;

media/libmedia/IAudioFlinger.cpp

+82 −119

Original line number	Diff line number	Diff line
		@@ -434,61 +434,40 @@ public:
		return reply.readInt64();
		}

		virtual audio_io_handle_t openOutput(audio_module_handle_t module,
		audio_devices_t *pDevices,
		uint32_t *pSamplingRate,
		audio_format_t *pFormat,
		audio_channel_mask_t *pChannelMask,
		uint32_t *pLatencyMs,
		audio_output_flags_t flags,
		const audio_offload_info_t *offloadInfo)
		virtual status_t openOutput(audio_module_handle_t module,
		audio_io_handle_t *output,
		audio_config_t *config,
		audio_devices_t *devices,
		const String8& address,
		uint32_t *latencyMs,
		audio_output_flags_t flags)
		{
		if (output == NULL \|\| config == NULL \|\| devices == NULL \|\| latencyMs == NULL) {
		return BAD_VALUE;
		}
		Parcel data, reply;
		audio_devices_t devices = pDevices != NULL ? *pDevices : AUDIO_DEVICE_NONE;
		uint32_t samplingRate = pSamplingRate != NULL ? *pSamplingRate : 0;
		audio_format_t format = pFormat != NULL ? *pFormat : AUDIO_FORMAT_DEFAULT;
		audio_channel_mask_t channelMask = pChannelMask != NULL ?
		*pChannelMask : (audio_channel_mask_t)0;
		uint32_t latency = pLatencyMs != NULL ? *pLatencyMs : 0;
		data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
		data.writeInt32(module);
		data.writeInt32(devices);
		data.writeInt32(samplingRate);
		data.writeInt32(format);
		data.writeInt32(channelMask);
		data.writeInt32(latency);
		data.write(config, sizeof(audio_config_t));
		data.writeInt32(*devices);
		data.writeString8(address);
		data.writeInt32((int32_t) flags);
		// hasOffloadInfo
		if (offloadInfo == NULL) {
		data.writeInt32(0);
		} else {
		data.writeInt32(1);
		data.write(offloadInfo, sizeof(audio_offload_info_t));
		}
		remote()->transact(OPEN_OUTPUT, data, &reply);
		audio_io_handle_t output = (audio_io_handle_t) reply.readInt32();
		ALOGV("openOutput() returned output, %d", output);
		devices = (audio_devices_t)reply.readInt32();
		if (pDevices != NULL) {
		*pDevices = devices;
		}
		samplingRate = reply.readInt32();
		if (pSamplingRate != NULL) {
		*pSamplingRate = samplingRate;
		}
		format = (audio_format_t) reply.readInt32();
		if (pFormat != NULL) {
		*pFormat = format;
		}
		channelMask = (audio_channel_mask_t)reply.readInt32();
		if (pChannelMask != NULL) {
		*pChannelMask = channelMask;
		status_t status = remote()->transact(OPEN_OUTPUT, data, &reply);
		if (status != NO_ERROR) {
		*output = AUDIO_IO_HANDLE_NONE;
		return status;
		}
		latency = reply.readInt32();
		if (pLatencyMs != NULL) {
		*pLatencyMs = latency;
		status = (status_t)reply.readInt32();
		if (status != NO_ERROR) {
		*output = AUDIO_IO_HANDLE_NONE;
		return status;
		}
		return output;
		*output = (audio_io_handle_t)reply.readInt32();
		ALOGV("openOutput() returned output, %d", *output);
		reply.read(config, sizeof(audio_config_t));
		*devices = (audio_devices_t)reply.readInt32();
		*latencyMs = reply.readInt32();
		return NO_ERROR;
		}

		virtual audio_io_handle_t openDuplicateOutput(audio_io_handle_t output1,
		@@ -529,46 +508,40 @@ public:
		return reply.readInt32();
		}

		virtual audio_io_handle_t openInput(audio_module_handle_t module,
		audio_devices_t *pDevices,
		uint32_t *pSamplingRate,
		audio_format_t *pFormat,
		audio_channel_mask_t *pChannelMask,
		virtual status_t openInput(audio_module_handle_t module,
		audio_io_handle_t *input,
		audio_config_t *config,
		audio_devices_t *device,
		const String8& address,
		audio_source_t source,
		audio_input_flags_t flags)
		{
		if (input == NULL \|\| config == NULL \|\| device == NULL) {
		return BAD_VALUE;
		}
		Parcel data, reply;
		audio_devices_t devices = pDevices != NULL ? *pDevices : AUDIO_DEVICE_NONE;
		uint32_t samplingRate = pSamplingRate != NULL ? *pSamplingRate : 0;
		audio_format_t format = pFormat != NULL ? *pFormat : AUDIO_FORMAT_DEFAULT;
		audio_channel_mask_t channelMask = pChannelMask != NULL ?
		*pChannelMask : (audio_channel_mask_t)0;

		data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
		data.writeInt32(module);
		data.writeInt32(devices);
		data.writeInt32(samplingRate);
		data.writeInt32(format);
		data.writeInt32(channelMask);
		data.writeInt32(*input);
		data.write(config, sizeof(audio_config_t));
		data.writeInt32(*device);
		data.writeString8(address);
		data.writeInt32(source);
		data.writeInt32(flags);
		remote()->transact(OPEN_INPUT, data, &reply);
		audio_io_handle_t input = (audio_io_handle_t) reply.readInt32();
		devices = (audio_devices_t)reply.readInt32();
		if (pDevices != NULL) {
		*pDevices = devices;
		}
		samplingRate = reply.readInt32();
		if (pSamplingRate != NULL) {
		*pSamplingRate = samplingRate;
		}
		format = (audio_format_t) reply.readInt32();
		if (pFormat != NULL) {
		*pFormat = format;
		status_t status = remote()->transact(OPEN_INPUT, data, &reply);
		if (status != NO_ERROR) {
		*input = AUDIO_IO_HANDLE_NONE;
		return status;
		}
		channelMask = (audio_channel_mask_t)reply.readInt32();
		if (pChannelMask != NULL) {
		*pChannelMask = channelMask;
		status = (status_t)reply.readInt32();
		if (status != NO_ERROR) {
		*input = AUDIO_IO_HANDLE_NONE;
		return status;
		}
		return input;
		*input = (audio_io_handle_t)reply.readInt32();
		reply.read(config, sizeof(audio_config_t));
		*device = (audio_devices_t)reply.readInt32();
		return NO_ERROR;
		}

		virtual status_t closeInput(int input)
		@@ -1103,32 +1076,23 @@ status_t BnAudioFlinger::onTransact(
		case OPEN_OUTPUT: {
		CHECK_INTERFACE(IAudioFlinger, data, reply);
		audio_module_handle_t module = (audio_module_handle_t)data.readInt32();
		audio_config_t config;
		data.read(&config, sizeof(audio_config_t));
		audio_devices_t devices = (audio_devices_t)data.readInt32();
		uint32_t samplingRate = data.readInt32();
		audio_format_t format = (audio_format_t) data.readInt32();
		audio_channel_mask_t channelMask = (audio_channel_mask_t)data.readInt32();
		uint32_t latency = data.readInt32();
		String8 address(data.readString8());
		audio_output_flags_t flags = (audio_output_flags_t) data.readInt32();
		bool hasOffloadInfo = data.readInt32() != 0;
		audio_offload_info_t offloadInfo;
		if (hasOffloadInfo) {
		data.read(&offloadInfo, sizeof(audio_offload_info_t));
		}
		audio_io_handle_t output = openOutput(module,
		&devices,
		&samplingRate,
		&format,
		&channelMask,
		&latency,
		flags,
		hasOffloadInfo ? &offloadInfo : NULL);
		uint32_t latencyMs;
		audio_io_handle_t output;
		status_t status = openOutput(module, &output, &config,
		&devices, address, &latencyMs, flags);
		ALOGV("OPEN_OUTPUT output, %d", output);
		reply->writeInt32((int32_t)status);
		if (status == NO_ERROR) {
		reply->writeInt32((int32_t)output);
		reply->write(&config, sizeof(audio_config_t));
		reply->writeInt32(devices);
		reply->writeInt32(samplingRate);
		reply->writeInt32(format);
		reply->writeInt32(channelMask);
		reply->writeInt32(latency);
		reply->writeInt32(latencyMs);
		}
		return NO_ERROR;
		} break;
		case OPEN_DUPLICATE_OUTPUT: {
		@@ -1156,23 +1120,22 @@ status_t BnAudioFlinger::onTransact(
		case OPEN_INPUT: {
		CHECK_INTERFACE(IAudioFlinger, data, reply);
		audio_module_handle_t module = (audio_module_handle_t)data.readInt32();
		audio_devices_t devices = (audio_devices_t)data.readInt32();
		uint32_t samplingRate = data.readInt32();
		audio_format_t format = (audio_format_t) data.readInt32();
		audio_channel_mask_t channelMask = (audio_channel_mask_t)data.readInt32();
		audio_io_handle_t input = (audio_io_handle_t)data.readInt32();
		audio_config_t config;
		data.read(&config, sizeof(audio_config_t));
		audio_devices_t device = (audio_devices_t)data.readInt32();
		String8 address(data.readString8());
		audio_source_t source = (audio_source_t)data.readInt32();
		audio_input_flags_t flags = (audio_input_flags_t) data.readInt32();

		audio_io_handle_t input = openInput(module,
		&devices,
		&samplingRate,
		&format,
		&channelMask,
		flags);
		status_t status = openInput(module, &input, &config,
		&device, address, source, flags);
		reply->writeInt32((int32_t) status);
		if (status == NO_ERROR) {
		reply->writeInt32((int32_t) input);
		reply->writeInt32(devices);
		reply->writeInt32(samplingRate);
		reply->writeInt32(format);
		reply->writeInt32(channelMask);
		reply->write(&config, sizeof(audio_config_t));
		reply->writeInt32(device);
		}
		return NO_ERROR;
		} break;
		case CLOSE_INPUT: {

services/audioflinger/AudioFlinger.cpp

+85 −117

File changed.

Preview size limit exceeded, changes collapsed.

services/audioflinger/AudioFlinger.h

+22 −17

Original line number	Diff line number	Diff line
		@@ -158,14 +158,13 @@ public:
		virtual size_t getInputBufferSize(uint32_t sampleRate, audio_format_t format,
		audio_channel_mask_t channelMask) const;

		virtual audio_io_handle_t openOutput(audio_module_handle_t module,
		audio_devices_t *pDevices,
		uint32_t *pSamplingRate,
		audio_format_t *pFormat,
		audio_channel_mask_t *pChannelMask,
		uint32_t *pLatencyMs,
		audio_output_flags_t flags,
		const audio_offload_info_t *offloadInfo);
		virtual status_t openOutput(audio_module_handle_t module,
		audio_io_handle_t *output,
		audio_config_t *config,
		audio_devices_t *devices,
		const String8& address,
		uint32_t *latencyMs,
		audio_output_flags_t flags);

		virtual audio_io_handle_t openDuplicateOutput(audio_io_handle_t output1,
		audio_io_handle_t output2);
		@@ -176,11 +175,12 @@ public:

		virtual status_t restoreOutput(audio_io_handle_t output);

		virtual audio_io_handle_t openInput(audio_module_handle_t module,
		audio_devices_t *pDevices,
		uint32_t *pSamplingRate,
		audio_format_t *pFormat,
		audio_channel_mask_t *pChannelMask,
		virtual status_t openInput(audio_module_handle_t module,
		audio_io_handle_t *input,
		audio_config_t *config,
		audio_devices_t *device,
		const String8& address,
		audio_source_t source,
		audio_input_flags_t flags);

		virtual status_t closeInput(audio_io_handle_t input);
		@@ -515,12 +515,17 @@ private:
		MixerThread *checkMixerThread_l(audio_io_handle_t output) const;
		RecordThread *checkRecordThread_l(audio_io_handle_t input) const;
		sp<RecordThread> openInput_l(audio_module_handle_t module,
		audio_io_handle_t *input,
		audio_config_t *config,
		audio_devices_t device,
		struct audio_config *config,
		const String8& address,
		audio_source_t source,
		audio_input_flags_t flags);
		sp<PlaybackThread> openOutput_l(audio_module_handle_t module,
		audio_devices_t device,
		struct audio_config *config,
		audio_io_handle_t *output,
		audio_config_t *config,
		audio_devices_t devices,
		const String8& address,
		audio_output_flags_t flags);

		void closeOutputFinish(sp<PlaybackThread> thread);

services/audioflinger/PatchPanel.cpp

+41 −17

Original line number	Diff line number	Diff line
		@@ -231,14 +231,16 @@ status_t AudioFlinger::PatchPanel::createAudioPatch(const struct audio_patch *pa
		goto exit;
		}
		} else {
		struct audio_config config;
		config.sample_rate = 0;
		config.channel_mask = AUDIO_CHANNEL_NONE;
		config.format = AUDIO_FORMAT_DEFAULT;
		audio_config_t config = AUDIO_CONFIG_INITIALIZER;
		audio_devices_t device = patch->sinks[0].ext.device.type;
		String8 address = String8(patch->sinks[0].ext.device.address);
		audio_io_handle_t output = AUDIO_IO_HANDLE_NONE;
		newPatch->mPlaybackThread = audioflinger->openOutput_l(
		patch->sinks[0].ext.device.hw_module,
		patch->sinks[0].ext.device.type,
		&output,
		&config,
		device,
		address,
		AUDIO_OUTPUT_FLAG_NONE);
		ALOGV("audioflinger->openOutput_l() returned %p",
		newPatch->mPlaybackThread.get());
		@@ -249,14 +251,19 @@ status_t AudioFlinger::PatchPanel::createAudioPatch(const struct audio_patch *pa
		}
		uint32_t channelCount = newPatch->mPlaybackThread->channelCount();
		audio_devices_t device = patch->sources[0].ext.device.type;
		struct audio_config config;
		String8 address = String8(patch->sources[0].ext.device.address);
		audio_config_t config = AUDIO_CONFIG_INITIALIZER;
		audio_channel_mask_t inChannelMask = audio_channel_in_mask_from_count(channelCount);
		config.sample_rate = newPatch->mPlaybackThread->sampleRate();
		config.channel_mask = inChannelMask;
		config.format = newPatch->mPlaybackThread->format();
		audio_io_handle_t input = AUDIO_IO_HANDLE_NONE;
		newPatch->mRecordThread = audioflinger->openInput_l(src_module,
		device,
		&input,
		&config,
		device,
		address,
		AUDIO_SOURCE_MIC,
		AUDIO_INPUT_FLAG_NONE);
		ALOGV("audioflinger->openInput_l() returned %p inChannelMask %08x",
		newPatch->mRecordThread.get(), inChannelMask);
		@@ -298,12 +305,20 @@ status_t AudioFlinger::PatchPanel::createAudioPatch(const struct audio_patch *pa
		status = BAD_VALUE;
		goto exit;
		}
		AudioParameter param;
		param.addInt(String8(AudioParameter::keyRouting),
		char *address;
		if (strcmp(patch->sources[0].ext.device.address, "") != 0) {
		address = audio_device_address_to_parameter(
		patch->sources[0].ext.device.type,
		patch->sources[0].ext.device.address);
		} else {
		address = (char *)calloc(1, 1);
		}
		AudioParameter param = AudioParameter(String8(address));
		free(address);
		param.addInt(String8(AUDIO_PARAMETER_STREAM_ROUTING),
		(int)patch->sources[0].ext.device.type);
		param.addInt(String8(AudioParameter::keyInputSource),
		param.addInt(String8(AUDIO_PARAMETER_STREAM_INPUT_SOURCE),
		(int)patch->sinks[0].ext.mix.usecase.source);

		ALOGV("createAudioPatch() AUDIO_PORT_TYPE_DEVICE setParameters %s",
		param.toString().string());
		status = thread->setParameters(param.toString());
		@@ -348,8 +363,17 @@ status_t AudioFlinger::PatchPanel::createAudioPatch(const struct audio_patch *pa
		for (unsigned int i = 0; i < patch->num_sinks; i++) {
		type \|= patch->sinks[i].ext.device.type;
		}
		AudioParameter param;
		param.addInt(String8(AudioParameter::keyRouting), (int)type);
		char *address;
		if (strcmp(patch->sinks[0].ext.device.address, "") != 0) {
		address = audio_device_address_to_parameter(
		patch->sinks[0].ext.device.type,
		patch->sinks[0].ext.device.address);
		} else {
		address = (char *)calloc(1, 1);
		}
		AudioParameter param = AudioParameter(String8(address));
		free(address);
		param.addInt(String8(AUDIO_PARAMETER_STREAM_ROUTING), (int)type);
		status = thread->setParameters(param.toString());
		}

		@@ -578,7 +602,7 @@ status_t AudioFlinger::PatchPanel::releaseAudioPatch(audio_patch_handle_t handle
		break;
		}
		AudioParameter param;
		param.addInt(String8(AudioParameter::keyRouting), 0);
		param.addInt(String8(AUDIO_PARAMETER_STREAM_ROUTING), 0);
		ALOGV("releaseAudioPatch() AUDIO_PORT_TYPE_DEVICE setParameters %s",
		param.toString().string());
		status = thread->setParameters(param.toString());
		@@ -605,7 +629,7 @@ status_t AudioFlinger::PatchPanel::releaseAudioPatch(audio_patch_handle_t handle
		status = thread->sendReleaseAudioPatchConfigEvent(mPatches[index]->mHalHandle);
		} else {
		AudioParameter param;
		param.addInt(String8(AudioParameter::keyRouting), (int)0);
		param.addInt(String8(AUDIO_PARAMETER_STREAM_ROUTING), 0);
		status = thread->setParameters(param.toString());
		}
		} break;