initial audio HAL implementation for mako (4765c439) · Commits · e / devices / samsung / android_hardware_qcom_audio

alsa_sound/ALSAControl.cpp

0 → 100644

+131 −0

Original line number	Diff line number	Diff line
		/* ALSAControl.cpp
		**
		** Copyright 2008-2009 Wind River Systems
		** Copyright (c) 2011-2012, Code Aurora Forum. All rights reserved.
		**
		** 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 <errno.h>
		#include <stdarg.h>
		#include <sys/stat.h>
		#include <fcntl.h>
		#include <stdlib.h>
		#include <unistd.h>
		#include <dlfcn.h>

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

		#include <cutils/properties.h>
		#include <media/AudioRecord.h>
		#include <hardware_legacy/power.h>

		#include "AudioHardwareALSA.h"

		namespace android_audio_legacy
		{

		ALSAControl::ALSAControl(const char *device)
		{
		LOGD("ALSAControl: ctor device %s", device);
		mHandle = mixer_open(device);
		LOGV("ALSAControl: ctor mixer %p", mHandle);
		}

		ALSAControl::~ALSAControl()
		{
		if (mHandle) mixer_close(mHandle);
		}

		status_t ALSAControl::get(const char *name, unsigned int &value, int index)
		{
		struct mixer_ctl *ctl;

		if (!mHandle) {
		LOGE("Control not initialized");
		return NO_INIT;
		}

		ctl = mixer_get_control(mHandle, name, index);
		if (!ctl)
		return BAD_VALUE;

		mixer_ctl_get(ctl, &value);
		return NO_ERROR;
		}

		status_t ALSAControl::set(const char *name, unsigned int value, int index)
		{
		struct mixer_ctl *ctl;
		int ret = 0;
		LOGD("set:: name %s value %d index %d", name, value, index);
		if (!mHandle) {
		LOGE("Control not initialized");
		return NO_INIT;
		}

		// ToDo: Do we need to send index here? Right now it works with 0
		ctl = mixer_get_control(mHandle, name, 0);
		if(ctl == NULL) {
		LOGE("Could not get the mixer control");
		return BAD_VALUE;
		}
		ret = mixer_ctl_set(ctl, value);
		return (ret < 0) ? BAD_VALUE : NO_ERROR;
		}

		status_t ALSAControl::set(const char name, const char value)
		{
		struct mixer_ctl *ctl;
		int ret = 0;
		LOGD("set:: name %s value %s", name, value);

		if (!mHandle) {
		LOGE("Control not initialized");
		return NO_INIT;
		}

		ctl = mixer_get_control(mHandle, name, 0);
		if(ctl == NULL) {
		LOGE("Could not get the mixer control");
		return BAD_VALUE;
		}
		ret = mixer_ctl_select(ctl, value);
		return (ret < 0) ? BAD_VALUE : NO_ERROR;
		}

		status_t ALSAControl::setext(const char name, int count, char *setValues)
		{
		struct mixer_ctl *ctl;
		int ret = 0;
		LOGD("setext:: name %s count %d", name, count);
		if (!mHandle) {
		LOGE("Control not initialized");
		return NO_INIT;
		}

		// ToDo: Do we need to send index here? Right now it works with 0
		ctl = mixer_get_control(mHandle, name, 0);
		if(ctl == NULL) {
		LOGE("Could not get the mixer control");
		return BAD_VALUE;
		}
		ret = mixer_ctl_set_value(ctl, count, setValues);
		return (ret < 0) ? BAD_VALUE : NO_ERROR;
		}

		}; // namespace android

alsa_sound/ALSAMixer.cpp

0 → 100644

+433 −0

Original line number	Diff line number	Diff line
		/* ALSAMixer.cpp
		**
		** Copyright 2008-2010 Wind River Systems
		**
		** 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 <errno.h>
		#include <stdarg.h>
		#include <sys/stat.h>
		#include <fcntl.h>
		#include <stdlib.h>
		#include <unistd.h>
		#include <dlfcn.h>

		#define LOG_TAG "AudioHardwareALSA"
		#include <utils/Log.h>
		#include <utils/String8.h>

		#include <cutils/properties.h>
		#include <media/AudioRecord.h>
		#include <hardware_legacy/power.h>

		#include "AudioHardwareALSA.h"

		#define SND_MIXER_VOL_RANGE_MIN (0)
		#define SND_MIXER_VOL_RANGE_MAX (100)

		#define ALSA_NAME_MAX 128

		#define ALSA_STRCAT(x,y) \
		if (strlen(x) + strlen(y) < ALSA_NAME_MAX) \
		strcat(x, y);

		namespace android
		{

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

		struct mixer_info_t;

		struct alsa_properties_t
		{
		const AudioSystem::audio_devices device;
		const char *propName;
		const char *propDefault;
		mixer_info_t *mInfo;
		};

		#define ALSA_PROP(dev, name, out, in) \
		{\
		{dev, "alsa.mixer.playback." name, out, NULL},\
		{dev, "alsa.mixer.capture." name, in, NULL}\
		}

		static alsa_properties_t
		mixerMasterProp[SND_PCM_STREAM_LAST+1] =
		ALSA_PROP(AudioSystem::DEVICE_OUT_ALL, "master", "PCM", "Capture");

		static alsa_properties_t
		mixerProp[][SND_PCM_STREAM_LAST+1] = {
		ALSA_PROP(AudioSystem::DEVICE_OUT_EARPIECE, "earpiece", "Earpiece", "Capture"),
		ALSA_PROP(AudioSystem::DEVICE_OUT_SPEAKER, "speaker", "Speaker", ""),
		ALSA_PROP(AudioSystem::DEVICE_OUT_WIRED_HEADSET, "headset", "Headphone", "Capture"),
		ALSA_PROP(AudioSystem::DEVICE_OUT_BLUETOOTH_SCO, "bluetooth.sco", "Bluetooth", "Bluetooth Capture"),
		ALSA_PROP(AudioSystem::DEVICE_OUT_BLUETOOTH_A2DP, "bluetooth.a2dp", "Bluetooth A2DP", "Bluetooth A2DP Capture"),
		ALSA_PROP(static_cast<AudioSystem::audio_devices>(0), "", NULL, NULL)
		};

		struct mixer_info_t
		{
		mixer_info_t() :
		elem(0),
		min(SND_MIXER_VOL_RANGE_MIN),
		max(SND_MIXER_VOL_RANGE_MAX),
		mute(false)
		{
		}

		snd_mixer_elem_t *elem;
		long min;
		long max;
		long volume;
		bool mute;
		char name[ALSA_NAME_MAX];
		};

		static int initMixer (snd_mixer_t *mixer, const char name)
		{
		int err;

		if ((err = snd_mixer_open(mixer, 0)) < 0) {
		LOGE("Unable to open mixer: %s", snd_strerror(err));
		return err;
		}

		if ((err = snd_mixer_attach(*mixer, name)) < 0) {
		LOGW("Unable to attach mixer to device %s: %s",
		name, snd_strerror(err));

		if ((err = snd_mixer_attach(*mixer, "hw:00")) < 0) {
		LOGE("Unable to attach mixer to device default: %s",
		snd_strerror(err));

		snd_mixer_close (*mixer);
		*mixer = NULL;
		return err;
		}
		}

		if ((err = snd_mixer_selem_register(*mixer, NULL, NULL)) < 0) {
		LOGE("Unable to register mixer elements: %s", snd_strerror(err));
		snd_mixer_close (*mixer);
		*mixer = NULL;
		return err;
		}

		// Get the mixer controls from the kernel
		if ((err = snd_mixer_load(*mixer)) < 0) {
		LOGE("Unable to load mixer elements: %s", snd_strerror(err));
		snd_mixer_close (*mixer);
		*mixer = NULL;
		return err;
		}

		return 0;
		}

		typedef int (hasVolume_t)(snd_mixer_elem_t);

		static const hasVolume_t hasVolume[] = {
		snd_mixer_selem_has_playback_volume,
		snd_mixer_selem_has_capture_volume
		};

		typedef int (getVolumeRange_t)(snd_mixer_elem_t, long int, long int);

		static const getVolumeRange_t getVolumeRange[] = {
		snd_mixer_selem_get_playback_volume_range,
		snd_mixer_selem_get_capture_volume_range
		};

		typedef int (setVolume_t)(snd_mixer_elem_t, long int);

		static const setVolume_t setVol[] = {
		snd_mixer_selem_set_playback_volume_all,
		snd_mixer_selem_set_capture_volume_all
		};

		ALSAMixer::ALSAMixer()
		{
		int err;

		initMixer (&mMixer[SND_PCM_STREAM_PLAYBACK], "AndroidOut");
		initMixer (&mMixer[SND_PCM_STREAM_CAPTURE], "AndroidIn");

		snd_mixer_selem_id_t *sid;
		snd_mixer_selem_id_alloca(&sid);

		for (int i = 0; i <= SND_PCM_STREAM_LAST; i++) {

		if (!mMixer[i]) continue;

		mixer_info_t *info = mixerMasterProp[i].mInfo = new mixer_info_t;

		property_get (mixerMasterProp[i].propName,
		info->name,
		mixerMasterProp[i].propDefault);

		for (snd_mixer_elem_t *elem = snd_mixer_first_elem(mMixer[i]);
		elem;
		elem = snd_mixer_elem_next(elem)) {

		if (!snd_mixer_selem_is_active(elem))
		continue;

		snd_mixer_selem_get_id(elem, sid);

		// Find PCM playback volume control element.
		const char *elementName = snd_mixer_selem_id_get_name(sid);

		if (info->elem == NULL &&
		strcmp(elementName, info->name) == 0 &&
		hasVolume[i] (elem)) {

		info->elem = elem;
		getVolumeRange[i] (elem, &info->min, &info->max);
		info->volume = info->max;
		setVol[i] (elem, info->volume);
		if (i == SND_PCM_STREAM_PLAYBACK &&
		snd_mixer_selem_has_playback_switch (elem))
		snd_mixer_selem_set_playback_switch_all (elem, 1);
		break;
		}
		}

		LOGV("Mixer: master '%s' %s.", info->name, info->elem ? "found" : "not found");

		for (int j = 0; mixerProp[j][i].device; j++) {

		mixer_info_t *info = mixerProp[j][i].mInfo = new mixer_info_t;

		property_get (mixerProp[j][i].propName,
		info->name,
		mixerProp[j][i].propDefault);

		for (snd_mixer_elem_t *elem = snd_mixer_first_elem(mMixer[i]);
		elem;
		elem = snd_mixer_elem_next(elem)) {

		if (!snd_mixer_selem_is_active(elem))
		continue;

		snd_mixer_selem_get_id(elem, sid);

		// Find PCM playback volume control element.
		const char *elementName = snd_mixer_selem_id_get_name(sid);

		if (info->elem == NULL &&
		strcmp(elementName, info->name) == 0 &&
		hasVolume[i] (elem)) {

		info->elem = elem;
		getVolumeRange[i] (elem, &info->min, &info->max);
		info->volume = info->max;
		setVol[i] (elem, info->volume);
		if (i == SND_PCM_STREAM_PLAYBACK &&
		snd_mixer_selem_has_playback_switch (elem))
		snd_mixer_selem_set_playback_switch_all (elem, 1);
		break;
		}
		}
		LOGV("Mixer: route '%s' %s.", info->name, info->elem ? "found" : "not found");
		}
		}
		LOGV("mixer initialized.");
		}

		ALSAMixer::~ALSAMixer()
		{
		for (int i = 0; i <= SND_PCM_STREAM_LAST; i++) {
		if (mMixer[i]) snd_mixer_close (mMixer[i]);
		if (mixerMasterProp[i].mInfo) {
		delete mixerMasterProp[i].mInfo;
		mixerMasterProp[i].mInfo = NULL;
		}
		for (int j = 0; mixerProp[j][i].device; j++) {
		if (mixerProp[j][i].mInfo) {
		delete mixerProp[j][i].mInfo;
		mixerProp[j][i].mInfo = NULL;
		}
		}
		}
		LOGV("mixer destroyed.");
		}

		status_t ALSAMixer::setMasterVolume(float volume)
		{
		mixer_info_t *info = mixerMasterProp[SND_PCM_STREAM_PLAYBACK].mInfo;
		if (!info \|\| !info->elem) return INVALID_OPERATION;

		long minVol = info->min;
		long maxVol = info->max;

		// Make sure volume is between bounds.
		long vol = minVol + volume * (maxVol - minVol);
		if (vol > maxVol) vol = maxVol;
		if (vol < minVol) vol = minVol;

		info->volume = vol;
		snd_mixer_selem_set_playback_volume_all (info->elem, vol);

		return NO_ERROR;
		}

		status_t ALSAMixer::setMasterGain(float gain)
		{
		mixer_info_t *info = mixerMasterProp[SND_PCM_STREAM_CAPTURE].mInfo;
		if (!info \|\| !info->elem) return INVALID_OPERATION;

		long minVol = info->min;
		long maxVol = info->max;

		// Make sure volume is between bounds.
		long vol = minVol + gain * (maxVol - minVol);
		if (vol > maxVol) vol = maxVol;
		if (vol < minVol) vol = minVol;

		info->volume = vol;
		snd_mixer_selem_set_capture_volume_all (info->elem, vol);

		return NO_ERROR;
		}

		status_t ALSAMixer::setVolume(uint32_t device, float left, float right)
		{
		for (int j = 0; mixerProp[j][SND_PCM_STREAM_PLAYBACK].device; j++)
		if (mixerProp[j][SND_PCM_STREAM_PLAYBACK].device & device) {

		mixer_info_t *info = mixerProp[j][SND_PCM_STREAM_PLAYBACK].mInfo;
		if (!info \|\| !info->elem) return INVALID_OPERATION;

		long minVol = info->min;
		long maxVol = info->max;

		// Make sure volume is between bounds.
		long vol = minVol + left * (maxVol - minVol);
		if (vol > maxVol) vol = maxVol;
		if (vol < minVol) vol = minVol;

		info->volume = vol;
		snd_mixer_selem_set_playback_volume_all (info->elem, vol);
		}

		return NO_ERROR;
		}

		status_t ALSAMixer::setGain(uint32_t device, float gain)
		{
		for (int j = 0; mixerProp[j][SND_PCM_STREAM_CAPTURE].device; j++)
		if (mixerProp[j][SND_PCM_STREAM_CAPTURE].device & device) {

		mixer_info_t *info = mixerProp[j][SND_PCM_STREAM_CAPTURE].mInfo;
		if (!info \|\| !info->elem) return INVALID_OPERATION;

		long minVol = info->min;
		long maxVol = info->max;

		// Make sure volume is between bounds.
		long vol = minVol + gain * (maxVol - minVol);
		if (vol > maxVol) vol = maxVol;
		if (vol < minVol) vol = minVol;

		info->volume = vol;
		snd_mixer_selem_set_capture_volume_all (info->elem, vol);
		}

		return NO_ERROR;
		}

		status_t ALSAMixer::setCaptureMuteState(uint32_t device, bool state)
		{
		for (int j = 0; mixerProp[j][SND_PCM_STREAM_CAPTURE].device; j++)
		if (mixerProp[j][SND_PCM_STREAM_CAPTURE].device & device) {

		mixer_info_t *info = mixerProp[j][SND_PCM_STREAM_CAPTURE].mInfo;
		if (!info \|\| !info->elem) return INVALID_OPERATION;

		if (snd_mixer_selem_has_capture_switch (info->elem)) {

		int err = snd_mixer_selem_set_capture_switch_all (info->elem, static_cast<int>(!state));
		if (err < 0) {
		LOGE("Unable to %s capture mixer switch %s",
		state ? "enable" : "disable", info->name);
		return INVALID_OPERATION;
		}
		}

		info->mute = state;
		}

		return NO_ERROR;
		}

		status_t ALSAMixer::getCaptureMuteState(uint32_t device, bool *state)
		{
		if (!state) return BAD_VALUE;

		for (int j = 0; mixerProp[j][SND_PCM_STREAM_CAPTURE].device; j++)
		if (mixerProp[j][SND_PCM_STREAM_CAPTURE].device & device) {

		mixer_info_t *info = mixerProp[j][SND_PCM_STREAM_CAPTURE].mInfo;
		if (!info \|\| !info->elem) return INVALID_OPERATION;

		*state = info->mute;
		return NO_ERROR;
		}

		return BAD_VALUE;
		}

		status_t ALSAMixer::setPlaybackMuteState(uint32_t device, bool state)
		{
		for (int j = 0; mixerProp[j][SND_PCM_STREAM_PLAYBACK].device; j++)
		if (mixerProp[j][SND_PCM_STREAM_PLAYBACK].device & device) {

		mixer_info_t *info = mixerProp[j][SND_PCM_STREAM_PLAYBACK].mInfo;
		if (!info \|\| !info->elem) return INVALID_OPERATION;

		if (snd_mixer_selem_has_playback_switch (info->elem)) {

		int err = snd_mixer_selem_set_playback_switch_all (info->elem, static_cast<int>(!state));
		if (err < 0) {
		LOGE("Unable to %s playback mixer switch %s",
		state ? "enable" : "disable", info->name);
		return INVALID_OPERATION;
		}
		}

		info->mute = state;
		}

		return NO_ERROR;
		}

		status_t ALSAMixer::getPlaybackMuteState(uint32_t device, bool *state)
		{
		if (!state) return BAD_VALUE;

		for (int j = 0; mixerProp[j][SND_PCM_STREAM_PLAYBACK].device; j++)
		if (mixerProp[j][SND_PCM_STREAM_PLAYBACK].device & device) {

		mixer_info_t *info = mixerProp[j][SND_PCM_STREAM_PLAYBACK].mInfo;
		if (!info \|\| !info->elem) return INVALID_OPERATION;

		*state = info->mute;
		return NO_ERROR;
		}

		return BAD_VALUE;
		}

		}; // namespace android

alsa_sound/ALSAStreamOps.cpp

0 → 100644

+360 −0

File added.

Preview size limit exceeded, changes collapsed.

alsa_sound/Android.mk

0 → 100644

+123 −0

Original line number	Diff line number	Diff line
		# hardware/libaudio-alsa/Android.mk
		#
		# Copyright 2008 Wind River Systems
		#

		ifeq ($(strip $(BOARD_USES_ALSA_AUDIO)),true)

		LOCAL_PATH := $(call my-dir)

		include $(CLEAR_VARS)

		LOCAL_ARM_MODE := arm
		LOCAL_CFLAGS := -D_POSIX_SOURCE

		LOCAL_SRC_FILES := \
		AudioHardwareALSA.cpp \
		AudioStreamOutALSA.cpp \
		AudioStreamInALSA.cpp \
		ALSAStreamOps.cpp \
		audio_hw_hal.cpp \
		AudioUsbALSA.cpp

		LOCAL_STATIC_LIBRARIES := \
		libmedia_helper \
		libaudiohw_legacy \

		LOCAL_SHARED_LIBRARIES := \
		libcutils \
		libutils \
		libmedia \
		libhardware \
		libc \
		libpower \
		libalsa-intf \
		libcsd-client \
		libsurround_proc

		LOCAL_C_INCLUDES += $(TARGET_OUT_HEADERS)/mm-audio/audio-alsa
		LOCAL_C_INCLUDES += $(TARGET_OUT_HEADERS)/mm-audio/audcal
		LOCAL_C_INCLUDES += $(TARGET_OUT_HEADERS)/mm-audio/audio-acdb-util
		LOCAL_C_INCLUDES += $(TARGET_OUT_HEADERS)/mm-audio/libalsa-intf
		LOCAL_C_INCLUDES += $(TARGET_OUT_HEADERS)/mm-audio/audio-qmi/csd-client
		LOCAL_C_INCLUDES += $(TARGET_OUT_HEADERS)/mm-audio/surround_sound/
		LOCAL_C_INCLUDES += hardware/libhardware/include
		LOCAL_C_INCLUDES += hardware/libhardware_legacy/include
		LOCAL_C_INCLUDES += frameworks/base/include
		LOCAL_C_INCLUDES += system/core/include

		LOCAL_C_INCLUDES += $(TARGET_OUT_INTERMEDIATES)/KERNEL_OBJ/usr/include
		LOCAL_ADDITIONAL_DEPENDENCIES += $(TARGET_OUT_INTERMEDIATES)/KERNEL_OBJ/usr

		LOCAL_MODULE := audio.primary.msm8960
		LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)/hw
		LOCAL_MODULE_TAGS := optional

		include $(BUILD_SHARED_LIBRARY)

		# This is the ALSA audio policy manager

		include $(CLEAR_VARS)

		LOCAL_CFLAGS := -D_POSIX_SOURCE

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

		LOCAL_SRC_FILES := \
		AudioPolicyManagerALSA.cpp \
		audio_policy_hal.cpp

		LOCAL_MODULE := audio_policy.msm8960
		LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)/hw
		LOCAL_MODULE_TAGS := optional

		LOCAL_STATIC_LIBRARIES := \
		libmedia_helper \
		libaudiopolicy_legacy

		LOCAL_SHARED_LIBRARIES := \
		libcutils \
		libutils \
		libmedia

		LOCAL_C_INCLUDES += hardware/libhardware_legacy/audio

		include $(BUILD_SHARED_LIBRARY)


		# This is the ALSA module which behaves closely like the original

		include $(CLEAR_VARS)

		LOCAL_PRELINK_MODULE := false

		LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)/hw

		LOCAL_CFLAGS := -D_POSIX_SOURCE -Wno-multichar

		ifneq ($(ALSA_DEFAULT_SAMPLE_RATE),)
		LOCAL_CFLAGS += -DALSA_DEFAULT_SAMPLE_RATE=$(ALSA_DEFAULT_SAMPLE_RATE)
		endif

		LOCAL_C_INCLUDES := $(TARGET_OUT_INTERMEDIATES)/KERNEL_OBJ/usr/include
		LOCAL_ADDITIONAL_DEPENDENCIES := $(TARGET_OUT_INTERMEDIATES)/KERNEL_OBJ/usr
		LOCAL_C_INCLUDES += $(TARGET_OUT_HEADERS)/mm-audio/libalsa-intf
		LOCAL_C_INCLUDES += $(TARGET_OUT_HEADERS)/mm-audio/audio-qmi/csd-client

		LOCAL_SRC_FILES:= \
		alsa_default.cpp \
		ALSAControl.cpp

		LOCAL_SHARED_LIBRARIES := \
		libcutils \
		liblog \
		libalsa-intf \
		libcsd-client

		LOCAL_MODULE:= alsa.msm8960
		LOCAL_MODULE_TAGS := optional

		include $(BUILD_SHARED_LIBRARY)
		endif

alsa_sound/AudioHardwareALSA.cpp

0 → 100644

+1569 −0

File added.

Preview size limit exceeded, changes collapsed.