Merge change 7735 (515ae886) · Commits · e / os / platform_frameworks_native

camera/libcameraservice/CameraService.cpp

+1 −8

Original line number	Diff line number	Diff line
		@@ -33,7 +33,6 @@
		#include "CameraService.h"

		#include <cutils/atomic.h>
		#include <cutils/properties.h>

		namespace android {

		@@ -199,13 +198,7 @@ static sp<MediaPlayer> newMediaPlayer(const char *file)
		{
		sp<MediaPlayer> mp = new MediaPlayer();
		if (mp->setDataSource(file) == NO_ERROR) {
		char value[PROPERTY_VALUE_MAX];
		property_get("ro.camera.sound.forced", value, "0");
		if (atoi(value)) {
		mp->setAudioStreamType(AudioSystem::ENFORCED_AUDIBLE);
		} else {
		mp->setAudioStreamType(AudioSystem::SYSTEM);
		}
		mp->prepare();
		} else {
		mp.clear();

include/tts/TtsEngine.h

+2 −2

Original line number	Diff line number	Diff line
		@@ -43,7 +43,7 @@ enum tts_callback_status {
		// @param [inout] void *& - The userdata pointer set in the original
		// synth call
		// @param [in] uint32_t - Track sampling rate in Hz
		// @param [in] audio_format - The AudioSystem::audio_format enum
		// @param [in] uint32_t - The audio format
		// @param [in] int - The number of channels
		// @param [inout] int8_t *& - A buffer of audio data only valid during the
		// execution of the callback
		@@ -54,7 +54,7 @@ enum tts_callback_status {
		// TTS_CALLBACK_CONTINUE to indicate the synthesis must continue if
		// there is more data to produce.
		typedef tts_callback_status (synthDoneCB_t)(void *&, uint32_t,
		AudioSystem::audio_format, int, int8_t *&, size_t&, tts_synth_status);
		uint32_t, int, int8_t *&, size_t&, tts_synth_status);

		class TtsEngine;
		extern "C" TtsEngine* getTtsEngine();

libs/audioflinger/A2dpAudioInterface.cpp

+183 −41

Original line number	Diff line number	Diff line
		@@ -29,25 +29,41 @@ namespace android {

		// ----------------------------------------------------------------------------

		A2dpAudioInterface::A2dpAudioInterface() :
		mOutput(0)
		//AudioHardwareInterface* A2dpAudioInterface::createA2dpInterface()
		//{
		// AudioHardwareInterface* hw = 0;
		//
		// hw = AudioHardwareInterface::create();
		// LOGD("new A2dpAudioInterface(hw: %p)", hw);
		// hw = new A2dpAudioInterface(hw);
		// return hw;
		//}

		A2dpAudioInterface::A2dpAudioInterface(AudioHardwareInterface* hw) :
		mOutput(0), mHardwareInterface(hw), mBluetoothEnabled(true)
		{
		}

		A2dpAudioInterface::~A2dpAudioInterface()
		{
		delete mOutput;
		closeOutputStream((AudioStreamOut *)mOutput);
		delete mHardwareInterface;
		}

		status_t A2dpAudioInterface::initCheck()
		{
		return 0;
		if (mHardwareInterface == 0) return NO_INIT;
		return mHardwareInterface->initCheck();
		}

		AudioStreamOut* A2dpAudioInterface::openOutputStream(
		int format, int channelCount, uint32_t sampleRate, status_t *status)
		uint32_t devices, int format, uint32_t channels, uint32_t sampleRate, status_t status)
		{
		LOGD("A2dpAudioInterface::openOutputStream %d, %d, %d\n", format, channelCount, sampleRate);
		if (!AudioSystem::isA2dpDevice((AudioSystem::audio_devices)devices)) {
		LOGV("A2dpAudioInterface::openOutputStream() open HW device: %x", devices);
		return mHardwareInterface->openOutputStream(devices, format, channels, sampleRate, status);
		}

		status_t err = 0;

		// only one output stream allowed
		@@ -59,8 +75,9 @@ AudioStreamOut* A2dpAudioInterface::openOutputStream(

		// create new output stream
		A2dpAudioStreamOut* out = new A2dpAudioStreamOut();
		if ((err = out->set(format, channelCount, sampleRate)) == NO_ERROR) {
		if ((err = out->set(devices, format, channels, sampleRate)) == NO_ERROR) {
		mOutput = out;
		mOutput->setBluetoothEnabled(mBluetoothEnabled);
		} else {
		delete out;
		}
		@@ -70,60 +87,115 @@ AudioStreamOut* A2dpAudioInterface::openOutputStream(
		return mOutput;
		}

		void A2dpAudioInterface::closeOutputStream(AudioStreamOut* out) {
		if (mOutput == 0 \|\| mOutput != out) {
		LOGW("Attempt to close invalid output stream");
		}
		else {
		delete mOutput;
		mOutput = 0;
		}
		}


		AudioStreamIn* A2dpAudioInterface::openInputStream(
		int inputSource, int format, int channelCount, uint32_t sampleRate,
		status_t *status, AudioSystem::audio_in_acoustics acoustics)
		uint32_t devices, int format, uint32_t channels, uint32_t sampleRate, status_t status,
		AudioSystem::audio_in_acoustics acoustics)
		{
		if (status)
		*status = -1;
		return NULL;
		return mHardwareInterface->openInputStream(devices, format, channels, sampleRate, status, acoustics);
		}

		void A2dpAudioInterface::closeInputStream(AudioStreamIn* in)
		{
		return mHardwareInterface->closeInputStream(in);
		}

		status_t A2dpAudioInterface::setMode(int mode)
		{
		return mHardwareInterface->setMode(mode);
		}

		status_t A2dpAudioInterface::setMicMute(bool state)
		{
		return 0;
		return mHardwareInterface->setMicMute(state);
		}

		status_t A2dpAudioInterface::getMicMute(bool* state)
		{
		return 0;
		return mHardwareInterface->getMicMute(state);
		}

		status_t A2dpAudioInterface::setParameter(const char key, const char value)
		status_t A2dpAudioInterface::setParameters(const String8& keyValuePairs)
		{
		LOGD("setParameter %s,%s\n", key, value);
		AudioParameter param = AudioParameter(keyValuePairs);
		String8 value;
		String8 key;
		status_t status = NO_ERROR;

		if (!key \|\| !value)
		return -EINVAL;
		LOGV("setParameters() %s", keyValuePairs.string());

		if (strcmp(key, "a2dp_sink_address") == 0) {
		return mOutput->setAddress(value);
		key = "bluetooth_enabled";
		if (param.get(key, value) == NO_ERROR) {
		mBluetoothEnabled = (value == "true");
		if (mOutput) {
		mOutput->setBluetoothEnabled(mBluetoothEnabled);
		}
		if (strcmp(key, "bluetooth_enabled") == 0) {
		mOutput->setBluetoothEnabled(strcmp(value, "true") == 0);
		param.remove(key);
		}

		return 0;
		if (param.size()) {
		status_t hwStatus = mHardwareInterface->setParameters(param.toString());
		if (status == NO_ERROR) {
		status = hwStatus;
		}
		}

		status_t A2dpAudioInterface::setVoiceVolume(float v)
		return status;
		}

		String8 A2dpAudioInterface::getParameters(const String8& keys)
		{
		return 0;
		AudioParameter param = AudioParameter(keys);
		AudioParameter a2dpParam = AudioParameter();
		String8 value;
		String8 key;

		key = "bluetooth_enabled";
		if (param.get(key, value) == NO_ERROR) {
		value = mBluetoothEnabled ? "true" : "false";
		a2dpParam.add(key, value);
		param.remove(key);
		}

		status_t A2dpAudioInterface::setMasterVolume(float v)
		String8 keyValuePairs = a2dpParam.toString();

		if (param.size()) {
		keyValuePairs += ";";
		keyValuePairs += mHardwareInterface->getParameters(param.toString());
		}

		LOGV("getParameters() %s", keyValuePairs.string());
		return keyValuePairs;
		}

		size_t A2dpAudioInterface::getInputBufferSize(uint32_t sampleRate, int format, int channelCount)
		{
		return 0;
		return mHardwareInterface->getInputBufferSize(sampleRate, format, channelCount);
		}

		status_t A2dpAudioInterface::doRouting()
		status_t A2dpAudioInterface::setVoiceVolume(float v)
		{
		return 0;
		return mHardwareInterface->setVoiceVolume(v);
		}

		status_t A2dpAudioInterface::setMasterVolume(float v)
		{
		return mHardwareInterface->setMasterVolume(v);
		}

		status_t A2dpAudioInterface::dump(int fd, const Vector<String16>& args)
		{
		return 0;
		return mHardwareInterface->dumpState(fd, args);
		}

		// ----------------------------------------------------------------------------
		@@ -132,7 +204,7 @@ A2dpAudioInterface::A2dpAudioStreamOut::A2dpAudioStreamOut() :
		mFd(-1), mStandby(true), mStartCount(0), mRetryCount(0), mData(NULL),
		// assume BT enabled to start, this is safe because its only the
		// enabled->disabled transition we are worried about
		mBluetoothEnabled(true)
		mBluetoothEnabled(true), mDevice(0)
		{
		// use any address by default
		strcpy(mA2dpAddress, "00:00:00:00:00:00");
		@@ -140,27 +212,43 @@ A2dpAudioInterface::A2dpAudioStreamOut::A2dpAudioStreamOut() :
		}

		status_t A2dpAudioInterface::A2dpAudioStreamOut::set(
		int format, int channels, uint32_t rate)
		uint32_t device, int pFormat, uint32_t pChannels, uint32_t *pRate)
		{
		LOGD("A2dpAudioStreamOut::set %d, %d, %d\n", format, channels, rate);
		int lFormat = pFormat ? *pFormat : 0;
		uint32_t lChannels = pChannels ? *pChannels : 0;
		uint32_t lRate = pRate ? *pRate : 0;

		LOGD("A2dpAudioStreamOut::set %x, %d, %d, %d\n", device, lFormat, lChannels, lRate);

		// fix up defaults
		if (format == 0) format = AudioSystem::PCM_16_BIT;
		if (channels == 0) channels = channelCount();
		if (rate == 0) rate = sampleRate();
		if (lFormat == 0) lFormat = format();
		if (lChannels == 0) lChannels = channels();
		if (lRate == 0) lRate = sampleRate();

		// check values
		if ((format != AudioSystem::PCM_16_BIT) \|\|
		(channels != channelCount()) \|\|
		(rate != sampleRate()))
		if ((lFormat != format()) \|\|
		(lChannels != channels()) \|\|
		(lRate != sampleRate())){
		if (pFormat) *pFormat = format();
		if (pChannels) *pChannels = channels();
		if (pRate) *pRate = sampleRate();
		return BAD_VALUE;
		}

		if (pFormat) *pFormat = lFormat;
		if (pChannels) *pChannels = lChannels;
		if (pRate) *pRate = lRate;

		mDevice = device;
		return NO_ERROR;
		}

		A2dpAudioInterface::A2dpAudioStreamOut::~A2dpAudioStreamOut()
		{
		LOGV("A2dpAudioStreamOut destructor");
		standby();
		close();
		LOGV("A2dpAudioStreamOut destructor returning from close()");
		}

		ssize_t A2dpAudioInterface::A2dpAudioStreamOut::write(const void* buffer, size_t bytes)
		@@ -230,6 +318,59 @@ status_t A2dpAudioInterface::A2dpAudioStreamOut::standby()
		return result;
		}

		status_t A2dpAudioInterface::A2dpAudioStreamOut::setParameters(const String8& keyValuePairs)
		{
		AudioParameter param = AudioParameter(keyValuePairs);
		String8 value;
		String8 key = String8("a2dp_sink_address");
		status_t status = NO_ERROR;
		int device;
		LOGV("A2dpAudioStreamOut::setParameters() %s", keyValuePairs.string());

		if (param.get(key, value) == NO_ERROR) {
		if (value.length() != strlen("00:00:00:00:00:00")) {
		status = BAD_VALUE;
		} else {
		setAddress(value.string());
		}
		param.remove(key);
		}
		key = AudioParameter::keyRouting;
		if (param.getInt(key, device) == NO_ERROR) {
		if (AudioSystem::isA2dpDevice((AudioSystem::audio_devices)device)) {
		mDevice = device;
		status = NO_ERROR;
		} else {
		status = BAD_VALUE;
		}
		param.remove(key);
		}

		if (param.size()) {
		status = BAD_VALUE;
		}
		return status;
		}

		String8 A2dpAudioInterface::A2dpAudioStreamOut::getParameters(const String8& keys)
		{
		AudioParameter param = AudioParameter(keys);
		String8 value;
		String8 key = String8("a2dp_sink_address");

		if (param.get(key, value) == NO_ERROR) {
		value = mA2dpAddress;
		param.add(key, value);
		}
		key = AudioParameter::keyRouting;
		if (param.get(key, value) == NO_ERROR) {
		param.addInt(key, (int)mDevice);
		}

		LOGV("A2dpAudioStreamOut::getParameters() %s", param.toString().string());
		return param.toString();
		}

		status_t A2dpAudioInterface::A2dpAudioStreamOut::setAddress(const char* address)
		{
		Mutex::Autolock lock(mLock);
		@@ -260,12 +401,14 @@ status_t A2dpAudioInterface::A2dpAudioStreamOut::setBluetoothEnabled(bool enable
		status_t A2dpAudioInterface::A2dpAudioStreamOut::close()
		{
		Mutex::Autolock lock(mLock);
		LOGV("A2dpAudioStreamOut::close() calling close_l()");
		return close_l();
		}

		status_t A2dpAudioInterface::A2dpAudioStreamOut::close_l()
		{
		if (mData) {
		LOGV("A2dpAudioStreamOut::close_l() calling a2dp_cleanup(mData)");
		a2dp_cleanup(mData);
		mData = NULL;
		}
		@@ -277,5 +420,4 @@ status_t A2dpAudioInterface::A2dpAudioStreamOut::dump(int fd, const Vector<Strin
		return NO_ERROR;
		}


		}; // namespace android

libs/audioflinger/A2dpAudioInterface.h

+33 −17

Original line number	Diff line number	Diff line
		@@ -32,38 +32,44 @@ class A2dpAudioInterface : public AudioHardwareBase
		class A2dpAudioStreamOut;

		public:
		A2dpAudioInterface();
		A2dpAudioInterface(AudioHardwareInterface* hw);
		virtual ~A2dpAudioInterface();
		virtual status_t initCheck();

		virtual status_t setVoiceVolume(float volume);
		virtual status_t setMasterVolume(float volume);

		virtual status_t setMode(int mode);

		// mic mute
		virtual status_t setMicMute(bool state);
		virtual status_t getMicMute(bool* state);

		// Temporary interface, do not use
		// TODO: Replace with a more generic key:value get/set mechanism
		virtual status_t setParameter(const char key, const char value);
		virtual status_t setParameters(const String8& keyValuePairs);
		virtual String8 getParameters(const String8& keys);

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

		// create I/O streams
		virtual AudioStreamOut* openOutputStream(
		int format=0,
		int channelCount=0,
		uint32_t sampleRate=0,
		uint32_t devices,
		int *format=0,
		uint32_t *channels=0,
		uint32_t *sampleRate=0,
		status_t *status=0);
		virtual void closeOutputStream(AudioStreamOut* out);

		virtual AudioStreamIn* openInputStream(
		int inputSource,
		int format,
		int channelCount,
		uint32_t sampleRate,
		uint32_t devices,
		int *format,
		uint32_t *channels,
		uint32_t *sampleRate,
		status_t *status,
		AudioSystem::audio_in_acoustics acoustics);
		virtual void closeInputStream(AudioStreamIn* in);
		// static AudioHardwareInterface* createA2dpInterface();

		protected:
		virtual status_t doRouting();
		virtual status_t dump(int fd, const Vector<String16>& args);

		private:
		@@ -71,19 +77,22 @@ private:
		public:
		A2dpAudioStreamOut();
		virtual ~A2dpAudioStreamOut();
		status_t set(int format,
		int channelCount,
		uint32_t sampleRate);
		status_t set(uint32_t device,
		int *pFormat,
		uint32_t *pChannels,
		uint32_t *pRate);
		virtual uint32_t sampleRate() const { return 44100; }
		// SBC codec wants a multiple of 512
		virtual size_t bufferSize() const { return 512 * 20; }
		virtual int channelCount() const { return 2; }
		virtual uint32_t channels() const { return AudioSystem::CHANNEL_OUT_STEREO; }
		virtual int format() const { return AudioSystem::PCM_16_BIT; }
		virtual uint32_t latency() const { return ((1000*bufferSize())/frameSize())/sampleRate() + 200; }
		virtual status_t setVolume(float volume) { return INVALID_OPERATION; }
		virtual status_t setVolume(float left, float right) { return INVALID_OPERATION; }
		virtual ssize_t write(const void* buffer, size_t bytes);
		status_t standby();
		virtual status_t dump(int fd, const Vector<String16>& args);
		virtual status_t setParameters(const String8& keyValuePairs);
		virtual String8 getParameters(const String8& keys);

		private:
		friend class A2dpAudioInterface;
		@@ -102,11 +111,18 @@ private:
		void* mData;
		Mutex mLock;
		bool mBluetoothEnabled;
		uint32_t mDevice;
		};

		friend class A2dpAudioStreamOut;

		A2dpAudioStreamOut* mOutput;
		AudioHardwareInterface *mHardwareInterface;
		char mA2dpAddress[20];
		bool mBluetoothEnabled;
		};


		// ----------------------------------------------------------------------------

		}; // namespace android

libs/audioflinger/Android.mk

+59 −5

Original line number	Diff line number	Diff line
		LOCAL_PATH:= $(call my-dir)

		#AUDIO_POLICY_TEST := true
		#ENABLE_AUDIO_DUMP := true

		include $(CLEAR_VARS)


		ifeq ($(AUDIO_POLICY_TEST),true)
		ENABLE_AUDIO_DUMP := true
		endif


		LOCAL_SRC_FILES:= \
		AudioHardwareGeneric.cpp \
		AudioHardwareStub.cpp \
		AudioDumpInterface.cpp \
		AudioHardwareInterface.cpp

		ifeq ($(ENABLE_AUDIO_DUMP),true)
		LOCAL_SRC_FILES += AudioDumpInterface.cpp
		LOCAL_CFLAGS += -DENABLE_AUDIO_DUMP
		endif

		LOCAL_SHARED_LIBRARIES := \
		libcutils \
		libutils \
		@@ -21,8 +34,40 @@ endif

		LOCAL_MODULE:= libaudiointerface

		ifeq ($(BOARD_HAVE_BLUETOOTH),true)
		LOCAL_SRC_FILES += A2dpAudioInterface.cpp
		LOCAL_SHARED_LIBRARIES += liba2dp
		LOCAL_CFLAGS += -DWITH_BLUETOOTH -DWITH_A2DP
		LOCAL_C_INCLUDES += $(call include-path-for, bluez)
		endif

		include $(BUILD_STATIC_LIBRARY)


		include $(CLEAR_VARS)

		LOCAL_SRC_FILES:= \
		AudioPolicyManagerGeneric.cpp

		LOCAL_SHARED_LIBRARIES := \
		libcutils \
		libutils \
		libmedia

		LOCAL_MODULE:= libaudiopolicygeneric

		ifeq ($(BOARD_HAVE_BLUETOOTH),true)
		LOCAL_CFLAGS += -DWITH_A2DP
		endif

		ifeq ($(AUDIO_POLICY_TEST),true)
		LOCAL_CFLAGS += -DAUDIO_POLICY_TEST
		endif

		LOCAL_PRELINK_MODULE := false

		include $(BUILD_SHARED_LIBRARY)

		include $(CLEAR_VARS)

		LOCAL_SRC_FILES:= \
		@@ -30,7 +75,8 @@ LOCAL_SRC_FILES:= \
		AudioMixer.cpp.arm \
		AudioResampler.cpp.arm \
		AudioResamplerSinc.cpp.arm \
		AudioResamplerCubic.cpp.arm
		AudioResamplerCubic.cpp.arm \
		AudioPolicyService.cpp

		LOCAL_SHARED_LIBRARIES := \
		libcutils \
		@@ -41,17 +87,25 @@ LOCAL_SHARED_LIBRARIES := \

		ifeq ($(strip $(BOARD_USES_GENERIC_AUDIO)),true)
		LOCAL_STATIC_LIBRARIES += libaudiointerface
		LOCAL_CFLAGS += -DGENERIC_AUDIO
		else
		LOCAL_SHARED_LIBRARIES += libaudio
		endif

		ifeq ($(TARGET_SIMULATOR),true)
		LOCAL_LDLIBS += -ldl
		else
		LOCAL_SHARED_LIBRARIES += libdl
		endif

		LOCAL_MODULE:= libaudioflinger

		ifeq ($(BOARD_HAVE_BLUETOOTH),true)
		LOCAL_SRC_FILES += A2dpAudioInterface.cpp
		LOCAL_SHARED_LIBRARIES += liba2dp
		LOCAL_CFLAGS += -DWITH_BLUETOOTH -DWITH_A2DP
		LOCAL_C_INCLUDES += $(call include-path-for, bluez)
		endif

		ifeq ($(AUDIO_POLICY_TEST),true)
		LOCAL_CFLAGS += -DAUDIO_POLICY_TEST
		endif

		ifeq ($(TARGET_SIMULATOR),true)