move native services under services/ (ccaa4142) · Commits · e / os / android_frameworks_av

media/mediaserver/Android.mk

+2 −2

Original line number	Diff line number	Diff line
		@@ -14,8 +14,8 @@ LOCAL_SHARED_LIBRARIES := \
		base := $(LOCAL_PATH)/../..

		LOCAL_C_INCLUDES := \
		$(base)/libs/audioflinger \
		$(base)/camera/libcameraservice \
		$(base)/services/audioflinger \
		$(base)/services/camera/libcameraservice \
		$(base)/media/libmediaplayerservice

		LOCAL_MODULE:= mediaserver

services/audioflinger/A2dpAudioInterface.cpp

0 → 100644

+466 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2008 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		#include <math.h>

		//#define LOG_NDEBUG 0
		#define LOG_TAG "A2dpAudioInterface"
		#include <utils/Log.h>
		#include <utils/String8.h>

		#include "A2dpAudioInterface.h"
		#include "audio/liba2dp.h"


		namespace android {

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

		//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), mSuspended(false)
		{
		}

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

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

		AudioStreamOut* A2dpAudioInterface::openOutputStream(
		uint32_t devices, int format, uint32_t channels, uint32_t sampleRate, status_t status)
		{
		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
		if (mOutput) {
		if (status)
		*status = -1;
		return NULL;
		}

		// create new output stream
		A2dpAudioStreamOut* out = new A2dpAudioStreamOut();
		if ((err = out->set(devices, format, channels, sampleRate)) == NO_ERROR) {
		mOutput = out;
		mOutput->setBluetoothEnabled(mBluetoothEnabled);
		mOutput->setSuspended(mSuspended);
		} else {
		delete out;
		}

		if (status)
		*status = err;
		return mOutput;
		}

		void A2dpAudioInterface::closeOutputStream(AudioStreamOut* out) {
		if (mOutput == 0 \|\| mOutput != out) {
		mHardwareInterface->closeOutputStream(out);
		}
		else {
		delete mOutput;
		mOutput = 0;
		}
		}


		AudioStreamIn* A2dpAudioInterface::openInputStream(
		uint32_t devices, int format, uint32_t channels, uint32_t sampleRate, status_t status,
		AudioSystem::audio_in_acoustics acoustics)
		{
		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 mHardwareInterface->setMicMute(state);
		}

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

		status_t A2dpAudioInterface::setParameters(const String8& keyValuePairs)
		{
		AudioParameter param = AudioParameter(keyValuePairs);
		String8 value;
		String8 key;
		status_t status = NO_ERROR;

		LOGV("setParameters() %s", keyValuePairs.string());

		key = "bluetooth_enabled";
		if (param.get(key, value) == NO_ERROR) {
		mBluetoothEnabled = (value == "true");
		if (mOutput) {
		mOutput->setBluetoothEnabled(mBluetoothEnabled);
		}
		param.remove(key);
		}
		key = String8("A2dpSuspended");
		if (param.get(key, value) == NO_ERROR) {
		mSuspended = (value == "true");
		if (mOutput) {
		mOutput->setSuspended(mSuspended);
		}
		param.remove(key);
		}

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

		return status;
		}

		String8 A2dpAudioInterface::getParameters(const String8& keys)
		{
		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);
		}
		key = "A2dpSuspended";
		if (param.get(key, value) == NO_ERROR) {
		value = mSuspended ? "true" : "false";
		a2dpParam.add(key, value);
		param.remove(key);
		}

		String8 keyValuePairs = a2dpParam.toString();

		if (param.size()) {
		if (keyValuePairs != "") {
		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 mHardwareInterface->getInputBufferSize(sampleRate, format, channelCount);
		}

		status_t A2dpAudioInterface::setVoiceVolume(float v)
		{
		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 mHardwareInterface->dumpState(fd, args);
		}

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

		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), mDevice(0), mClosing(false), mSuspended(false)
		{
		// use any address by default
		strcpy(mA2dpAddress, "00:00:00:00:00:00");
		init();
		}

		status_t A2dpAudioInterface::A2dpAudioStreamOut::set(
		uint32_t device, int pFormat, uint32_t pChannels, uint32_t *pRate)
		{
		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 (lFormat == 0) lFormat = format();
		if (lChannels == 0) lChannels = channels();
		if (lRate == 0) lRate = sampleRate();

		// check values
		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)
		{
		Mutex::Autolock lock(mLock);

		size_t remaining = bytes;
		status_t status = -1;

		if (!mBluetoothEnabled \|\| mClosing \|\| mSuspended) {
		LOGV("A2dpAudioStreamOut::write(), but bluetooth disabled \
		mBluetoothEnabled %d, mClosing %d, mSuspended %d",
		mBluetoothEnabled, mClosing, mSuspended);
		goto Error;
		}

		status = init();
		if (status < 0)
		goto Error;

		while (remaining > 0) {
		status = a2dp_write(mData, buffer, remaining);
		if (status <= 0) {
		LOGE("a2dp_write failed err: %d\n", status);
		goto Error;
		}
		remaining -= status;
		buffer = ((char *)buffer) + status;
		}

		mStandby = false;

		return bytes;

		Error:
		// Simulate audio output timing in case of error
		usleep(((bytes * 1000 )/ frameSize() / sampleRate()) * 1000);

		return status;
		}

		status_t A2dpAudioInterface::A2dpAudioStreamOut::init()
		{
		if (!mData) {
		status_t status = a2dp_init(44100, 2, &mData);
		if (status < 0) {
		LOGE("a2dp_init failed err: %d\n", status);
		mData = NULL;
		return status;
		}
		a2dp_set_sink(mData, mA2dpAddress);
		}

		return 0;
		}

		status_t A2dpAudioInterface::A2dpAudioStreamOut::standby()
		{
		int result = 0;

		if (mClosing) {
		LOGV("Ignore standby, closing");
		return result;
		}

		Mutex::Autolock lock(mLock);

		if (!mStandby) {
		result = a2dp_stop(mData);
		if (result == 0)
		mStandby = true;
		}

		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 = String8("closing");
		if (param.get(key, value) == NO_ERROR) {
		mClosing = (value == "true");
		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);

		if (strlen(address) != strlen("00:00:00:00:00:00"))
		return -EINVAL;

		strcpy(mA2dpAddress, address);
		if (mData)
		a2dp_set_sink(mData, mA2dpAddress);

		return NO_ERROR;
		}

		status_t A2dpAudioInterface::A2dpAudioStreamOut::setBluetoothEnabled(bool enabled)
		{
		LOGD("setBluetoothEnabled %d", enabled);

		Mutex::Autolock lock(mLock);

		mBluetoothEnabled = enabled;
		if (!enabled) {
		return close_l();
		}
		return NO_ERROR;
		}

		status_t A2dpAudioInterface::A2dpAudioStreamOut::setSuspended(bool onOff)
		{
		LOGV("setSuspended %d", onOff);
		mSuspended = onOff;
		standby();
		return NO_ERROR;
		}

		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;
		}
		return NO_ERROR;
		}

		status_t A2dpAudioInterface::A2dpAudioStreamOut::dump(int fd, const Vector<String16>& args)
		{
		return NO_ERROR;
		}

		status_t A2dpAudioInterface::A2dpAudioStreamOut::getRenderPosition(uint32_t *driverFrames)
		{
		//TODO: enable when supported by driver
		return INVALID_OPERATION;
		}

		}; // namespace android

services/audioflinger/A2dpAudioInterface.h

0 → 100644

+135 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2008 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		#ifndef A2DP_AUDIO_HARDWARE_H
		#define A2DP_AUDIO_HARDWARE_H

		#include <stdint.h>
		#include <sys/types.h>

		#include <utils/threads.h>

		#include <hardware_legacy/AudioHardwareBase.h>


		namespace android {

		class A2dpAudioInterface : public AudioHardwareBase
		{
		class A2dpAudioStreamOut;

		public:
		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);

		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(
		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(
		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 dump(int fd, const Vector<String16>& args);

		private:
		class A2dpAudioStreamOut : public AudioStreamOut {
		public:
		A2dpAudioStreamOut();
		virtual ~A2dpAudioStreamOut();
		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 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 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);
		virtual status_t getRenderPosition(uint32_t *dspFrames);

		private:
		friend class A2dpAudioInterface;
		status_t init();
		status_t close();
		status_t close_l();
		status_t setAddress(const char* address);
		status_t setBluetoothEnabled(bool enabled);
		status_t setSuspended(bool onOff);

		private:
		int mFd;
		bool mStandby;
		int mStartCount;
		int mRetryCount;
		char mA2dpAddress[20];
		void* mData;
		Mutex mLock;
		bool mBluetoothEnabled;
		uint32_t mDevice;
		bool mClosing;
		bool mSuspended;
		};

		friend class A2dpAudioStreamOut;

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


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

		}; // namespace android

		#endif // A2DP_AUDIO_HARDWARE_H

services/audioflinger/Android.mk

0 → 100644

+130 −0

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 \
		AudioHardwareInterface.cpp

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

		LOCAL_SHARED_LIBRARIES := \
		libcutils \
		libutils \
		libbinder \
		libmedia \
		libhardware_legacy

		ifeq ($(strip $(BOARD_USES_GENERIC_AUDIO)),true)
		LOCAL_CFLAGS += -DGENERIC_AUDIO
		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:= \
		AudioPolicyManagerBase.cpp

		LOCAL_SHARED_LIBRARIES := \
		libcutils \
		libutils \
		libmedia

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

		LOCAL_MODULE:= libaudiopolicybase

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

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

		include $(BUILD_STATIC_LIBRARY)

		include $(CLEAR_VARS)

		LOCAL_SRC_FILES:= \
		AudioFlinger.cpp \
		AudioMixer.cpp.arm \
		AudioResampler.cpp.arm \
		AudioResamplerSinc.cpp.arm \
		AudioResamplerCubic.cpp.arm \
		AudioPolicyService.cpp

		LOCAL_SHARED_LIBRARIES := \
		libcutils \
		libutils \
		libbinder \
		libmedia \
		libhardware_legacy

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

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

		LOCAL_MODULE:= libaudioflinger

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

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

		ifeq ($(TARGET_SIMULATOR),true)
		ifeq ($(HOST_OS),linux)
		LOCAL_LDLIBS += -lrt -lpthread
		endif
		endif

		ifeq ($(BOARD_USE_LVMX),true)
		LOCAL_CFLAGS += -DLVMX
		LOCAL_C_INCLUDES += vendor/nxp
		LOCAL_STATIC_LIBRARIES += liblifevibes
		LOCAL_SHARED_LIBRARIES += liblvmxservice
		# LOCAL_SHARED_LIBRARIES += liblvmxipc
		endif

		include $(BUILD_SHARED_LIBRARY)

services/audioflinger/AudioBufferProvider.h

0 → 100644

+49 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2007 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		#ifndef ANDROID_AUDIO_BUFFER_PROVIDER_H
		#define ANDROID_AUDIO_BUFFER_PROVIDER_H

		#include <stdint.h>
		#include <sys/types.h>
		#include <utils/Errors.h>

		namespace android {
		// ----------------------------------------------------------------------------

		class AudioBufferProvider
		{
		public:

		struct Buffer {
		union {
		void* raw;
		short* i16;
		int8_t* i8;
		};
		size_t frameCount;
		};

		virtual ~AudioBufferProvider() {}

		virtual status_t getNextBuffer(Buffer* buffer) = 0;
		virtual void releaseBuffer(Buffer* buffer) = 0;
		};

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

		#endif // ANDROID_AUDIO_BUFFER_PROVIDER_H