audio policy: load audio hw modules. (a4c5a550) · Commits · e / os / android_frameworks_av

include/media/IAudioFlinger.h

+15 −11

Original line number	Original line	Diff line number	Diff line
	@@ -29,6 +29,7 @@
	#include <media/IAudioFlingerClient.h>		#include <media/IAudioFlingerClient.h>
	#include <system/audio.h>		#include <system/audio.h>
	#include <system/audio_policy.h>		#include <system/audio_policy.h>
			#include <hardware/audio_policy.h>
	#include <hardware/audio_effect.h>		#include <hardware/audio_effect.h>
	#include <media/IEffect.h>		#include <media/IEffect.h>
	#include <media/IEffectClient.h>		#include <media/IEffectClient.h>
	@@ -126,10 +127,11 @@ public:
	// retrieve the audio recording buffer size		// retrieve the audio recording buffer size
	virtual size_t getInputBufferSize(uint32_t sampleRate, audio_format_t format, int channelCount) const = 0;		virtual size_t getInputBufferSize(uint32_t sampleRate, audio_format_t format, int channelCount) const = 0;

	virtual audio_io_handle_t openOutput(uint32_t *pDevices,		virtual audio_io_handle_t openOutput(audio_module_handle_t module,
			audio_devices_t *pDevices,
	uint32_t *pSamplingRate,		uint32_t *pSamplingRate,
	audio_format_t *pFormat,		audio_format_t *pFormat,
	uint32_t *pChannels,		audio_channel_mask_t *pChannelMask,
	uint32_t *pLatencyMs,		uint32_t *pLatencyMs,
	audio_policy_output_flags_t flags) = 0;		audio_policy_output_flags_t flags) = 0;
	virtual audio_io_handle_t openDuplicateOutput(audio_io_handle_t output1,		virtual audio_io_handle_t openDuplicateOutput(audio_io_handle_t output1,
	@@ -138,11 +140,11 @@ public:
	virtual status_t suspendOutput(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 status_t restoreOutput(audio_io_handle_t output) = 0;

	virtual audio_io_handle_t openInput(uint32_t *pDevices,		virtual audio_io_handle_t openInput(audio_module_handle_t module,
			audio_devices_t *pDevices,
	uint32_t *pSamplingRate,		uint32_t *pSamplingRate,
	audio_format_t *pFormat,		audio_format_t *pFormat,
	uint32_t *pChannels,		audio_channel_mask_t *pChannelMask) = 0;
	audio_in_acoustics_t acoustics) = 0;
	virtual status_t closeInput(audio_io_handle_t input) = 0;		virtual status_t closeInput(audio_io_handle_t input) = 0;

	virtual status_t setStreamOutput(audio_stream_type_t stream, audio_io_handle_t output) = 0;		virtual status_t setStreamOutput(audio_stream_type_t stream, audio_io_handle_t output) = 0;
	@@ -178,6 +180,8 @@ public:

	virtual status_t moveEffects(int session, audio_io_handle_t srcOutput,		virtual status_t moveEffects(int session, audio_io_handle_t srcOutput,
	audio_io_handle_t dstOutput) = 0;		audio_io_handle_t dstOutput) = 0;

			virtual audio_module_handle_t loadHwModule(const char *name) = 0;
	};		};

media/libmedia/IAudioFlinger.cpp

+62 −43

Original line number	Original line	Diff line number	Diff line
	@@ -69,7 +69,8 @@ enum {
	QUERY_EFFECT,		QUERY_EFFECT,
	GET_EFFECT_DESCRIPTOR,		GET_EFFECT_DESCRIPTOR,
	CREATE_EFFECT,		CREATE_EFFECT,
	MOVE_EFFECTS		MOVE_EFFECTS,
			LOAD_HW_MODULE
	};		};

	class BpAudioFlinger : public BpInterface<IAudioFlinger>		class BpAudioFlinger : public BpInterface<IAudioFlinger>
	@@ -355,38 +356,40 @@ public:
	return reply.readInt32();		return reply.readInt32();
	}		}

	virtual audio_io_handle_t openOutput(uint32_t *pDevices,		virtual audio_io_handle_t openOutput(audio_module_handle_t module,
			audio_devices_t *pDevices,
	uint32_t *pSamplingRate,		uint32_t *pSamplingRate,
	audio_format_t *pFormat,		audio_format_t *pFormat,
	uint32_t *pChannels,		audio_channel_mask_t *pChannelMask,
	uint32_t *pLatencyMs,		uint32_t *pLatencyMs,
	audio_policy_output_flags_t flags)		audio_policy_output_flags_t flags)
	{		{
	Parcel data, reply;		Parcel data, reply;
	uint32_t devices = pDevices ? *pDevices : 0;		audio_devices_t devices = pDevices ? *pDevices : (audio_devices_t)0;
	uint32_t samplingRate = pSamplingRate ? *pSamplingRate : 0;		uint32_t samplingRate = pSamplingRate ? *pSamplingRate : 0;
	audio_format_t format = pFormat ? *pFormat : AUDIO_FORMAT_DEFAULT;		audio_format_t format = pFormat ? *pFormat : AUDIO_FORMAT_DEFAULT;
	uint32_t channels = pChannels ? *pChannels : 0;		audio_channel_mask_t channelMask = pChannelMask ? *pChannelMask : (audio_channel_mask_t)0;
	uint32_t latency = pLatencyMs ? *pLatencyMs : 0;		uint32_t latency = pLatencyMs ? *pLatencyMs : 0;

	data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());		data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
			data.writeInt32(module);
	data.writeInt32(devices);		data.writeInt32(devices);
	data.writeInt32(samplingRate);		data.writeInt32(samplingRate);
	data.writeInt32(format);		data.writeInt32(format);
	data.writeInt32(channels);		data.writeInt32(channelMask);
	data.writeInt32(latency);		data.writeInt32(latency);
	data.writeInt32((int32_t) flags);		data.writeInt32((int32_t) flags);
	remote()->transact(OPEN_OUTPUT, data, &reply);		remote()->transact(OPEN_OUTPUT, data, &reply);
	audio_io_handle_t output = (audio_io_handle_t) reply.readInt32();		audio_io_handle_t output = (audio_io_handle_t) reply.readInt32();
	ALOGV("openOutput() returned output, %d", output);		ALOGV("openOutput() returned output, %d", output);
	devices = reply.readInt32();		devices = (audio_devices_t)reply.readInt32();
	if (pDevices) *pDevices = devices;		if (pDevices) *pDevices = devices;
	samplingRate = reply.readInt32();		samplingRate = reply.readInt32();
	if (pSamplingRate) *pSamplingRate = samplingRate;		if (pSamplingRate) *pSamplingRate = samplingRate;
	format = (audio_format_t) reply.readInt32();		format = (audio_format_t) reply.readInt32();
	if (pFormat) *pFormat = format;		if (pFormat) *pFormat = format;
	channels = reply.readInt32();		channelMask = (audio_channel_mask_t)reply.readInt32();
	if (pChannels) *pChannels = channels;		if (pChannelMask) *pChannelMask = channelMask;
	latency = reply.readInt32();		latency = reply.readInt32();
	if (pLatencyMs) *pLatencyMs = latency;		if (pLatencyMs) *pLatencyMs = latency;
	return output;		return output;
	@@ -430,34 +433,34 @@ public:
	return reply.readInt32();		return reply.readInt32();
	}		}

	virtual audio_io_handle_t openInput(uint32_t *pDevices,		virtual audio_io_handle_t openInput(audio_module_handle_t module,
			audio_devices_t *pDevices,
	uint32_t *pSamplingRate,		uint32_t *pSamplingRate,
	audio_format_t *pFormat,		audio_format_t *pFormat,
	uint32_t *pChannels,		audio_channel_mask_t *pChannelMask)
	audio_in_acoustics_t acoustics)
	{		{
	Parcel data, reply;		Parcel data, reply;
	uint32_t devices = pDevices ? *pDevices : 0;		audio_devices_t devices = pDevices ? *pDevices : (audio_devices_t)0;
	uint32_t samplingRate = pSamplingRate ? *pSamplingRate : 0;		uint32_t samplingRate = pSamplingRate ? *pSamplingRate : 0;
	audio_format_t format = pFormat ? *pFormat : AUDIO_FORMAT_DEFAULT;		audio_format_t format = pFormat ? *pFormat : AUDIO_FORMAT_DEFAULT;
	uint32_t channels = pChannels ? *pChannels : 0;		audio_channel_mask_t channelMask = pChannelMask ? *pChannelMask : (audio_channel_mask_t)0;

	data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());		data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
			data.writeInt32(module);
	data.writeInt32(devices);		data.writeInt32(devices);
	data.writeInt32(samplingRate);		data.writeInt32(samplingRate);
	data.writeInt32(format);		data.writeInt32(format);
	data.writeInt32(channels);		data.writeInt32(channelMask);
	data.writeInt32((int32_t) acoustics);
	remote()->transact(OPEN_INPUT, data, &reply);		remote()->transact(OPEN_INPUT, data, &reply);
	audio_io_handle_t input = (audio_io_handle_t) reply.readInt32();		audio_io_handle_t input = (audio_io_handle_t) reply.readInt32();
	devices = reply.readInt32();		devices = (audio_devices_t)reply.readInt32();
	if (pDevices) *pDevices = devices;		if (pDevices) *pDevices = devices;
	samplingRate = reply.readInt32();		samplingRate = reply.readInt32();
	if (pSamplingRate) *pSamplingRate = samplingRate;		if (pSamplingRate) *pSamplingRate = samplingRate;
	format = (audio_format_t) reply.readInt32();		format = (audio_format_t) reply.readInt32();
	if (pFormat) *pFormat = format;		if (pFormat) *pFormat = format;
	channels = reply.readInt32();		channelMask = (audio_channel_mask_t)reply.readInt32();
	if (pChannels) *pChannels = channels;		if (pChannelMask) *pChannelMask = channelMask;
	return input;		return input;
	}		}

	@@ -668,6 +671,15 @@ public:
	remote()->transact(MOVE_EFFECTS, data, &reply);		remote()->transact(MOVE_EFFECTS, data, &reply);
	return reply.readInt32();		return reply.readInt32();
	}		}

			virtual audio_module_handle_t loadHwModule(const char *name)
			{
			Parcel data, reply;
			data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
			data.writeCString(name);
			remote()->transact(LOAD_HW_MODULE, data, &reply);
			return (audio_module_handle_t) reply.readInt32();
			}
	};		};

	IMPLEMENT_META_INTERFACE(AudioFlinger, "android.media.IAudioFlinger");		IMPLEMENT_META_INTERFACE(AudioFlinger, "android.media.IAudioFlinger");
	@@ -837,16 +849,18 @@ status_t BnAudioFlinger::onTransact(
	} break;		} break;
	case OPEN_OUTPUT: {		case OPEN_OUTPUT: {
	CHECK_INTERFACE(IAudioFlinger, data, reply);		CHECK_INTERFACE(IAudioFlinger, data, reply);
	uint32_t devices = data.readInt32();		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();		uint32_t samplingRate = data.readInt32();
	audio_format_t format = (audio_format_t) data.readInt32();		audio_format_t format = (audio_format_t) data.readInt32();
	uint32_t channels = data.readInt32();		audio_channel_mask_t channelMask = (audio_channel_mask_t)data.readInt32();
	uint32_t latency = data.readInt32();		uint32_t latency = data.readInt32();
	audio_policy_output_flags_t flags = (audio_policy_output_flags_t) data.readInt32();		audio_policy_output_flags_t flags = (audio_policy_output_flags_t) data.readInt32();
	audio_io_handle_t output = openOutput(&devices,		audio_io_handle_t output = openOutput(module,
			&devices,
	&samplingRate,		&samplingRate,
	&format,		&format,
	&channels,		&channelMask,
	&latency,		&latency,
	flags);		flags);
	ALOGV("OPEN_OUTPUT output, %p", output);		ALOGV("OPEN_OUTPUT output, %p", output);
	@@ -854,7 +868,7 @@ status_t BnAudioFlinger::onTransact(
	reply->writeInt32(devices);		reply->writeInt32(devices);
	reply->writeInt32(samplingRate);		reply->writeInt32(samplingRate);
	reply->writeInt32(format);		reply->writeInt32(format);
	reply->writeInt32(channels);		reply->writeInt32(channelMask);
	reply->writeInt32(latency);		reply->writeInt32(latency);
	return NO_ERROR;		return NO_ERROR;
	} break;		} break;
	@@ -882,22 +896,22 @@ status_t BnAudioFlinger::onTransact(
	} break;		} break;
	case OPEN_INPUT: {		case OPEN_INPUT: {
	CHECK_INTERFACE(IAudioFlinger, data, reply);		CHECK_INTERFACE(IAudioFlinger, data, reply);
	uint32_t devices = data.readInt32();		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();		uint32_t samplingRate = data.readInt32();
	audio_format_t format = (audio_format_t) data.readInt32();		audio_format_t format = (audio_format_t) data.readInt32();
	uint32_t channels = data.readInt32();		audio_channel_mask_t channelMask = (audio_channel_mask_t)data.readInt32();
	audio_in_acoustics_t acoustics = (audio_in_acoustics_t) data.readInt32();

	audio_io_handle_t input = openInput(&devices,		audio_io_handle_t input = openInput(module,
			&devices,
	&samplingRate,		&samplingRate,
	&format,		&format,
	&channels,		&channelMask);
	acoustics);
	reply->writeInt32((int32_t) input);		reply->writeInt32((int32_t) input);
	reply->writeInt32(devices);		reply->writeInt32(devices);
	reply->writeInt32(samplingRate);		reply->writeInt32(samplingRate);
	reply->writeInt32(format);		reply->writeInt32(format);
	reply->writeInt32(channels);		reply->writeInt32(channelMask);
	return NO_ERROR;		return NO_ERROR;
	} break;		} break;
	case CLOSE_INPUT: {		case CLOSE_INPUT: {
	@@ -1015,6 +1029,11 @@ status_t BnAudioFlinger::onTransact(
	reply->writeInt32(moveEffects(session, srcOutput, dstOutput));		reply->writeInt32(moveEffects(session, srcOutput, dstOutput));
	return NO_ERROR;		return NO_ERROR;
	} break;		} break;
			case LOAD_HW_MODULE: {
			CHECK_INTERFACE(IAudioFlinger, data, reply);
			reply->writeInt32(loadHwModule(data.readCString()));
			return NO_ERROR;
			} break;
	default:		default:
	return BBinder::onTransact(code, data, reply, flags);		return BBinder::onTransact(code, data, reply, flags);
	}		}

services/audioflinger/AudioFlinger.cpp

+180 −142

File changed.

Preview size limit exceeded, changes collapsed.

services/audioflinger/AudioFlinger.h

+33 −13

Original line number	Original line	Diff line number	Diff line
	@@ -43,6 +43,7 @@

	#include <system/audio.h>		#include <system/audio.h>
	#include <hardware/audio.h>		#include <hardware/audio.h>
			#include <hardware/audio_policy.h>

	#include "AudioBufferProvider.h"		#include "AudioBufferProvider.h"

	@@ -137,10 +138,11 @@ public:

	virtual size_t getInputBufferSize(uint32_t sampleRate, audio_format_t format, int channelCount) const;		virtual size_t getInputBufferSize(uint32_t sampleRate, audio_format_t format, int channelCount) const;

	virtual audio_io_handle_t openOutput(uint32_t *pDevices,		virtual audio_io_handle_t openOutput(audio_module_handle_t module,
			audio_devices_t *pDevices,
	uint32_t *pSamplingRate,		uint32_t *pSamplingRate,
	audio_format_t *pFormat,		audio_format_t *pFormat,
	uint32_t *pChannels,		audio_channel_mask_t *pChannelMask,
	uint32_t *pLatencyMs,		uint32_t *pLatencyMs,
	audio_policy_output_flags_t flags);		audio_policy_output_flags_t flags);

	@@ -153,11 +155,11 @@ public:

	virtual status_t restoreOutput(audio_io_handle_t output);		virtual status_t restoreOutput(audio_io_handle_t output);

	virtual audio_io_handle_t openInput(uint32_t *pDevices,		virtual audio_io_handle_t openInput(audio_module_handle_t module,
			audio_devices_t *pDevices,
	uint32_t *pSamplingRate,		uint32_t *pSamplingRate,
	audio_format_t *pFormat,		audio_format_t *pFormat,
	uint32_t *pChannels,		audio_channel_mask_t *pChannelMask);
	audio_in_acoustics_t acoustics);

	virtual status_t closeInput(audio_io_handle_t input);		virtual status_t closeInput(audio_io_handle_t input);

	@@ -196,6 +198,8 @@ public:
	virtual status_t moveEffects(int sessionId, audio_io_handle_t srcOutput,		virtual status_t moveEffects(int sessionId, audio_io_handle_t srcOutput,
	audio_io_handle_t dstOutput);		audio_io_handle_t dstOutput);

			virtual audio_module_handle_t loadHwModule(const char *name);

	virtual status_t onTransact(		virtual status_t onTransact(
	uint32_t code,		uint32_t code,
	const Parcel& data,		const Parcel& data,
	@@ -256,7 +260,7 @@ private:
	// RefBase		// RefBase
	virtual void onFirstRef();		virtual void onFirstRef();

	audio_hw_device_t* findSuitableHwDev_l(uint32_t devices);		audio_hw_device_t* findSuitableHwDev_l(audio_module_handle_t module, uint32_t devices);
	void purgeStaleEffects_l();		void purgeStaleEffects_l();

	// standby delay for MIXER and DUPLICATING playback threads is read from property		// standby delay for MIXER and DUPLICATING playback threads is read from property
	@@ -1699,15 +1703,30 @@ mutable Mutex mLock; // mutex for process, commands and handl
	MVS_FULL,		MVS_FULL,
	};		};

			class AudioHwDevice {
			public:
			AudioHwDevice(const char moduleName, audio_hw_device_t hwDevice) :
			mModuleName(strdup(moduleName)), mHwDevice(hwDevice){}
			~AudioHwDevice() { free((void *)mModuleName); }

			const char *moduleName() const { return mModuleName; }
			audio_hw_device_t *hwDevice() const { return mHwDevice; }
			private:
			const char * const mModuleName;
			audio_hw_device_t * const mHwDevice;
			};

	mutable Mutex mLock;		mutable Mutex mLock;

	DefaultKeyedVector< pid_t, wp<Client> > mClients; // see ~Client()		DefaultKeyedVector< pid_t, wp<Client> > mClients; // see ~Client()

	mutable Mutex mHardwareLock;		mutable Mutex mHardwareLock;
			// NOTE: If both mLock and mHardwareLock mutexes must be held,
			// always take mLock before mHardwareLock

	// These two fields are immutable after onFirstRef(), so no lock needed to access		// These two fields are immutable after onFirstRef(), so no lock needed to access
	audio_hw_device_t* mPrimaryHardwareDev; // mAudioHwDevs[0] or NULL		audio_hw_device_t* mPrimaryHardwareDev; // mAudioHwDevs[0] or NULL
	Vector<audio_hw_device_t*> mAudioHwDevs;		DefaultKeyedVector<audio_module_handle_t, AudioHwDevice*> mAudioHwDevs;

	// for dump, indicates which hardware operation is currently in progress (but not stream ops)		// for dump, indicates which hardware operation is currently in progress (but not stream ops)
	enum hardware_call_state {		enum hardware_call_state {
	@@ -1757,6 +1776,7 @@ mutable Mutex mLock; // mutex for process, commands and handl
	float masterVolume_l() const;		float masterVolume_l() const;
	float masterVolumeSW_l() const { return mMasterVolumeSW; }		float masterVolumeSW_l() const { return mMasterVolumeSW; }
	bool masterMute_l() const { return mMasterMute; }		bool masterMute_l() const { return mMasterMute; }
			audio_module_handle_t loadHwModule_l(const char *name);

	Vector < sp<SyncEvent> > mPendingSyncEvents; // sync events awaiting for a session		Vector < sp<SyncEvent> > mPendingSyncEvents; // sync events awaiting for a session
	// to be created		// to be created

services/audioflinger/AudioPolicyService.cpp

+66 −14

Original line number	Original line	Diff line number	Diff line
	@@ -1329,11 +1329,25 @@ status_t AudioPolicyService::loadPreProcessorConfig(const char *path)
	/* implementation of the interface to the policy manager */		/* implementation of the interface to the policy manager */
	extern "C" {		extern "C" {


			static audio_module_handle_t aps_load_hw_module(void *service,
			const char *name)
			{
			sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
			if (af == 0) {
			ALOGW("%s: could not get AudioFlinger", __func__);
			return 0;
			}

			return af->loadHwModule(name);
			}

			// deprecated: replaced by aps_open_output_on_module()
	static audio_io_handle_t aps_open_output(void *service,		static audio_io_handle_t aps_open_output(void *service,
	uint32_t *pDevices,		audio_devices_t *pDevices,
	uint32_t *pSamplingRate,		uint32_t *pSamplingRate,
	audio_format_t *pFormat,		audio_format_t *pFormat,
	uint32_t *pChannels,		audio_channel_mask_t *pChannelMask,
	uint32_t *pLatencyMs,		uint32_t *pLatencyMs,
	audio_policy_output_flags_t flags)		audio_policy_output_flags_t flags)
	{		{
	@@ -1343,7 +1357,26 @@ static audio_io_handle_t aps_open_output(void *service,
	return 0;		return 0;
	}		}

	return af->openOutput(pDevices, pSamplingRate, pFormat, pChannels,		return af->openOutput((audio_module_handle_t)0, pDevices, pSamplingRate, pFormat, pChannelMask,
			pLatencyMs, flags);
			}

			static audio_io_handle_t aps_open_output_on_module(void *service,
			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_policy_output_flags_t flags)
			{
			sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
			if (af == 0) {
			ALOGW("%s: could not get AudioFlinger", __func__);
			return 0;
			}
			ALOGW("%s: %d", __func__, module);
			return af->openOutput(module, pDevices, pSamplingRate, pFormat, pChannelMask,
	pLatencyMs, flags);		pLatencyMs, flags);
	}		}

	@@ -1390,11 +1423,12 @@ static int aps_restore_output(void *service, audio_io_handle_t output)
	return af->restoreOutput(output);		return af->restoreOutput(output);
	}		}

			// deprecated: replaced by aps_open_input_on_module()
	static audio_io_handle_t aps_open_input(void *service,		static audio_io_handle_t aps_open_input(void *service,
	uint32_t *pDevices,		audio_devices_t *pDevices,
	uint32_t *pSamplingRate,		uint32_t *pSamplingRate,
	audio_format_t *pFormat,		audio_format_t *pFormat,
	uint32_t *pChannels,		audio_channel_mask_t *pChannelMask,
	audio_in_acoustics_t acoustics)		audio_in_acoustics_t acoustics)
	{		{
	sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();		sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
	@@ -1403,8 +1437,23 @@ static audio_io_handle_t aps_open_input(void *service,
	return 0;		return 0;
	}		}

	return af->openInput(pDevices, pSamplingRate, pFormat, pChannels,		return af->openInput((audio_module_handle_t)0, pDevices, pSamplingRate, pFormat, pChannelMask);
	acoustics);		}

			static audio_io_handle_t aps_open_input_on_module(void *service,
			audio_module_handle_t module,
			audio_devices_t *pDevices,
			uint32_t *pSamplingRate,
			audio_format_t *pFormat,
			audio_channel_mask_t *pChannelMask)
			{
			sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
			if (af == 0) {
			ALOGW("%s: could not get AudioFlinger", __func__);
			return 0;
			}

			return af->openInput(module, pDevices, pSamplingRate, pFormat, pChannelMask);
	}		}

	static int aps_close_input(void *service, audio_io_handle_t input)		static int aps_close_input(void *service, audio_io_handle_t input)
	@@ -1503,6 +1552,9 @@ namespace {
	stop_tone : aps_stop_tone,		stop_tone : aps_stop_tone,
	set_voice_volume : aps_set_voice_volume,		set_voice_volume : aps_set_voice_volume,
	move_effects : aps_move_effects,		move_effects : aps_move_effects,
			load_hw_module : aps_load_hw_module,
			open_output_on_module : aps_open_output_on_module,
			open_input_on_module : aps_open_input_on_module,
	};		};
	}; // namespace <unnamed>		}; // namespace <unnamed>