dereference
/
android_hardware_qcom_audio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
android_hardware_qcom_audio/hal/audio_extn/usb.c

726 lines
24 KiB
C
Raw Blame History

/*
* Copyright (c) 2013, The Linux Foundation. All rights reserved.
* Not a Contribution.
*
* Copyright (C) 2013 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.
*/
#define LOG_TAG "audio_hw_usb"
#define LOG_NDEBUG 0
#define LOG_NDDEBUG 0
#include <errno.h>
#include <pthread.h>
#include <stdlib.h>
#include <cutils/log.h>
#include <cutils/str_parms.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <system/audio.h>
#include <tinyalsa/asoundlib.h>
#ifdef USB_HEADSET_ENABLED
#define USB_LOW_LATENCY_OUTPUT_PERIOD_SIZE 512
#define USB_LOW_LATENCY_OUTPUT_PERIOD_COUNT 8
#define USB_DEFAULT_OUTPUT_SAMPLING_RATE 48000
#define USB_PROXY_DEFAULT_SAMPLING_RATE 48000
#define USB_PROXY_OPEN_RETRY_COUNT 100
#define USB_PROXY_OPEN_WAIT_TIME 20
#define USB_PROXY_PERIOD_SIZE 3072
#define USB_PROXY_RATE_8000 8000
#define USB_PROXY_RATE_16000 16000
#define USB_PROXY_RATE_48000 48000
#define USB_PERIOD_SIZE 2048
#define USB_BUFF_SIZE 2048
#define AFE_PROXY_PERIOD_COUNT 32
#define AFE_PROXY_PLAYBACK_DEVICE 8
#define AFE_PROXY_CAPTURE_DEVICE 7
struct usb_module {
uint32_t usb_card;
uint32_t proxy_card;
uint32_t usb_device_id;
uint32_t proxy_device_id;
int32_t channels_playback;
int32_t sample_rate_playback;
int32_t channels_record;
int32_t sample_rate_record;
bool is_playback_running;
bool is_record_running;
pthread_t usb_playback_thr;
pthread_t usb_record_thr;
pthread_mutex_t usb_playback_lock;
pthread_mutex_t usb_record_lock;
struct pcm *proxy_pcm_playback_handle;
struct pcm *usb_pcm_playback_handle;
struct pcm *proxy_pcm_record_handle;
struct pcm *usb_pcm_record_handle;
struct audio_device *adev;
};
static struct usb_module *usbmod = NULL;
static pthread_once_t alloc_usbmod_once_ctl = PTHREAD_ONCE_INIT;
struct pcm_config pcm_config_usbmod = {
.channels = 2,
.rate = USB_DEFAULT_OUTPUT_SAMPLING_RATE,
.period_size = USB_LOW_LATENCY_OUTPUT_PERIOD_SIZE,
.period_count = USB_LOW_LATENCY_OUTPUT_PERIOD_COUNT,
.format = PCM_FORMAT_S16_LE,
.start_threshold = USB_LOW_LATENCY_OUTPUT_PERIOD_SIZE / 4,
.stop_threshold = INT_MAX,
.avail_min = USB_LOW_LATENCY_OUTPUT_PERIOD_SIZE / 4,
};
static void usb_alloc()
{
usbmod = calloc(1, sizeof(struct usb_module));
}
// Some USB audio accessories have a really low default volume set. Look for a suitable
// volume control and set the volume to default volume level.
static void initPlaybackVolume() {
ALOGD("initPlaybackVolume");
struct mixer *usbMixer = mixer_open(1);
if (usbMixer) {
struct mixer_ctl *ctl = NULL;
unsigned int usbPlaybackVolume;
unsigned int i;
unsigned int num_ctls = mixer_get_num_ctls(usbMixer);
// Look for the first control named ".*Playback Volume" that isn't for a microphone
for (i = 0; i < num_ctls; i++) {
ctl = mixer_get_ctl(usbMixer, i);
if (strstr((const char *)mixer_ctl_get_name(ctl), "Playback Volume") &&
!strstr((const char *)mixer_ctl_get_name(ctl), "Mic")) {
break;
}
}
if (ctl != NULL) {
ALOGD("Found a volume control for USB: %s", mixer_ctl_get_name(ctl) );
usbPlaybackVolume = mixer_ctl_get_value(ctl, 0);
ALOGD("Value got from mixer_ctl_get is:%u", usbPlaybackVolume);
if (mixer_ctl_set_value(ctl,0,usbPlaybackVolume) < 0) {
ALOGE("Failed to set volume; default volume might be used");
}
} else {
ALOGE("No playback volume control found; default volume will be used");
}
mixer_close(usbMixer);
} else {
ALOGE("Failed to open mixer for card 1");
}
}
static int usb_get_numof_rates(char *rates_str)
{
int i, size = 0;
char *next_sr_string, *temp_ptr;
next_sr_string = strtok_r(rates_str, " ,", &temp_ptr);
if (next_sr_string == NULL) {
ALOGE("%s: get_numof_rates: could not find rates string", __func__);
return (int)NULL;
}
for (i = 1; next_sr_string != NULL; i++) {
size ++;
next_sr_string = strtok_r(NULL, " ,.-", &temp_ptr);
}
return size;
}
static int usb_get_capability(char *type, int32_t *channels,
int32_t *sample_rate)
{
ALOGD("%s: for %s", __func__, type);
long unsigned file_size;
FILE *fp;
char *buffer;
int32_t err = 1;
int32_t size = 0;
int32_t fd, i, channels_playback;
char *read_buf, *str_start, *channel_start, *rates_str, *rates_str_for_val,
*rates_str_start, *next_sr_str, *test, *next_sr_string, *temp_ptr;
struct stat st;
int *rates_supported;
char path[128];
memset(&st, 0x0, sizeof(struct stat));
*sample_rate = 0;
snprintf(path, sizeof(path), "/proc/asound/card%u/stream0",
usbmod->usb_card);
fd = open(path, O_RDONLY);
if (fd <0) {
ALOGE("%s: error failed to open config file %s error: %d\n",
__func__, path, errno);
close(fd);
return -EINVAL;
}
if (fstat(fd, &st) < 0) {
ALOGE("%s: error failed to stat %s error %d\n",
__func__, path, errno);
close(fd);
return -EINVAL;
}
file_size = st.st_size;
read_buf = (char *)calloc(1, USB_BUFF_SIZE + 1);
err = read(fd, read_buf, USB_BUFF_SIZE);
str_start = strstr(read_buf, type);
if (str_start == NULL) {
ALOGE("%s: error %s section not found in usb config file",
__func__, type);
close(fd);
free(read_buf);
return -EINVAL;
}
channel_start = strstr(str_start, "Channels:");
if (channel_start == NULL) {
ALOGE("%s: error could not find Channels information", __func__);
close(fd);
free(read_buf);
return -EINVAL;
}
channel_start = strstr(channel_start, " ");
if (channel_start == NULL) {
ALOGE("%s: error channel section not found in usb config file",
__func__);
close(fd);
free(read_buf);
return -EINVAL;
}
channels_playback = atoi(channel_start);
if (channels_playback == 1) {
*channels = 1;
} else {
*channels = 2;
}
ALOGD("%s: channels supported by device: %d", __func__, *channels);
rates_str_start = strstr(str_start, "Rates:");
if (rates_str_start == NULL) {
ALOGE("%s: error cant find rates information", __func__);
close(fd);
free(read_buf);
return -EINVAL;
}
rates_str_start = strstr(rates_str_start, " ");
if (rates_str_start == NULL) {
ALOGE("%s: error channel section not found in usb config file",
__func__);
close(fd);
free(read_buf);
return -EINVAL;
}
char *target = strchr(rates_str_start, '\n');
if (target == NULL) {
ALOGE("%s: error end of line not found", __func__);
close(fd);
free(read_buf);
return -EINVAL;
}
size = target - rates_str_start;
if ((rates_str = (char *)malloc(size + 1)) == NULL) {
ALOGE("%s: error unable to allocate memory to hold sample rate strings",
__func__);
close(fd);
free(read_buf);
return -ENOMEM;
}
if ((rates_str_for_val = (char *)malloc(size + 1)) == NULL) {
ALOGE("%s: error unable to allocate memory to hold sample rate string",
__func__);
close(fd);
free(rates_str);
free(read_buf);
return -ENOMEM;
}
memcpy(rates_str, rates_str_start, size);
memcpy(rates_str_for_val, rates_str_start, size);
rates_str[size] = '\0';
rates_str_for_val[size] = '\0';
size = usb_get_numof_rates(rates_str);
if (!size) {
ALOGE("%s: error could not get rate size, returning", __func__);
close(fd);
free(rates_str_for_val);
free(rates_str);
free(read_buf);
return -EINVAL;
}
rates_supported = (int *)malloc(sizeof(int) * size);
next_sr_string = strtok_r(rates_str_for_val, " ,", &temp_ptr);
if (next_sr_string == NULL) {
ALOGE("%s: error could not get first rate val", __func__);
close(fd);
free(rates_str_for_val);
free(rates_str);
free(rates_supported);
free(read_buf);
return -EINVAL;
}
rates_supported[0] = atoi(next_sr_string);
ALOGD("%s: rates_supported[0] for playback: %d",
__func__, rates_supported[0]);
for (i = 1; i<size; i++) {
next_sr_string = strtok_r(NULL, " ,.-", &temp_ptr);
rates_supported[i] = atoi(next_sr_string);
ALOGD("rates_supported[%d] for playback: %d",i, rates_supported[i]);
}
for (i = 0; i<size; i++) {
if ((rates_supported[i] > *sample_rate) &&
(rates_supported[i] <= 48000)) {
/* Sample Rate should be one of the proxy supported rates only
This is because proxy port is used to read from/write to DSP */
if ((rates_supported[i] == USB_PROXY_RATE_8000) ||
(rates_supported[i] == USB_PROXY_RATE_16000) ||
(rates_supported[i] == USB_PROXY_RATE_48000)) {
*sample_rate = rates_supported[i];
}
}
}
ALOGD("%s: sample_rate: %d", __func__, *sample_rate);
close(fd);
free(rates_str_for_val);
free(rates_str);
free(rates_supported);
free(read_buf);
return 0;
}
static int32_t usb_playback_entry(void *adev)
{
unsigned char usbbuf[USB_PROXY_PERIOD_SIZE] = {0};
int32_t ret, bytes, proxy_open_retry_count;
ALOGD("%s: entry", __func__);
/* update audio device pointer */
usbmod->adev = (struct audio_device*)adev;
proxy_open_retry_count = USB_PROXY_OPEN_RETRY_COUNT;
/* get capabilities */
pthread_mutex_lock(&usbmod->usb_playback_lock);
ret = usb_get_capability((char *)"Playback:",
&usbmod->channels_playback, &usbmod->sample_rate_playback);
if (ret) {
ALOGE("%s: could not get playback capabilities from usb device",
__func__);
pthread_mutex_unlock(&usbmod->usb_playback_lock);
return -EINVAL;
}
/* update config for usb
1 pcm frame(sample)= 4 bytes since two channels*/
pcm_config_usbmod.period_size = USB_PERIOD_SIZE/4;
pcm_config_usbmod.channels = usbmod->channels_playback;
pcm_config_usbmod.rate = usbmod->sample_rate_playback;
ALOGV("%s: usb device %u:period %u:channels %u:sample", __func__,
pcm_config_usbmod.period_size, pcm_config_usbmod.channels,
pcm_config_usbmod.rate);
usbmod->usb_pcm_playback_handle = pcm_open(usbmod->usb_card, \
usbmod->usb_device_id, PCM_OUT |
PCM_MMAP | PCM_NOIRQ , &pcm_config_usbmod);
if ((usbmod->usb_pcm_playback_handle \
&& !pcm_is_ready(usbmod->usb_pcm_playback_handle))
|| (!usbmod->is_playback_running)) {
ALOGE("%s: failed: %s", __func__,
pcm_get_error(usbmod->usb_pcm_playback_handle));
pcm_close(usbmod->usb_pcm_playback_handle);
usbmod->usb_pcm_playback_handle = NULL;
pthread_mutex_unlock(&usbmod->usb_playback_lock);
return -ENOMEM;
}
ALOGD("%s: USB configured for playback", __func__);
/* update config for proxy*/
pcm_config_usbmod.period_size = USB_PROXY_PERIOD_SIZE/3;
pcm_config_usbmod.rate = usbmod->sample_rate_playback;
pcm_config_usbmod.channels = usbmod->channels_playback;
pcm_config_usbmod.period_count = AFE_PROXY_PERIOD_COUNT;
usbmod->proxy_device_id = AFE_PROXY_PLAYBACK_DEVICE;
ALOGD("%s: proxy device %u:period %u:channels %u:sample", __func__,
pcm_config_usbmod.period_size, pcm_config_usbmod.channels,
pcm_config_usbmod.rate);
while(proxy_open_retry_count){
usbmod->proxy_pcm_playback_handle = pcm_open(usbmod->proxy_card,
usbmod->proxy_device_id, PCM_IN |
PCM_MMAP | PCM_NOIRQ, &pcm_config_usbmod);
if(usbmod->proxy_pcm_playback_handle
&& !pcm_is_ready(usbmod->proxy_pcm_playback_handle)){
pcm_close(usbmod->proxy_pcm_playback_handle);
usbmod->proxy_pcm_playback_handle = NULL;
proxy_open_retry_count--;
usleep(USB_PROXY_OPEN_WAIT_TIME * 1000);
ALOGE("%s: pcm_open for proxy failed retrying = %d",
__func__, proxy_open_retry_count);
}
else{
break;
}
}
if ((usbmod->proxy_pcm_playback_handle
&& !pcm_is_ready(usbmod->proxy_pcm_playback_handle))
|| (!usbmod->is_playback_running)) {
ALOGE("%s: failed: %s", __func__,
pcm_get_error(usbmod->proxy_pcm_playback_handle));
pcm_close(usbmod->proxy_pcm_playback_handle);
usbmod->proxy_pcm_playback_handle = NULL;
pthread_mutex_unlock(&usbmod->usb_playback_lock);
return -ENOMEM;
}
ALOGD("%s: PROXY configured for playback", __func__);
pthread_mutex_unlock(&usbmod->usb_playback_lock);
ALOGD("Init USB volume");
initPlaybackVolume();
/* main loop to read from proxy and write to usb */
while (usbmod->is_playback_running) {
/* read data from proxy */
ret = pcm_mmap_read(usbmod->proxy_pcm_playback_handle,
(void *)usbbuf, USB_PROXY_PERIOD_SIZE);
/* Write to usb */
ret = pcm_mmap_write(usbmod->usb_pcm_playback_handle,
(void *)usbbuf, USB_PROXY_PERIOD_SIZE);
if(!usbmod->is_playback_running)
break;
memset(usbbuf, 0, USB_PROXY_PERIOD_SIZE);
} /* main loop end */
ALOGD("%s: exiting USB playback thread",__func__);
return 0;
}
static void* usb_playback_launcher(void *adev)
{
int32_t ret;
usbmod->is_playback_running = true;
ret = usb_playback_entry(adev);
if (ret) {
ALOGE("%s: failed with err:%d", __func__, ret);
usbmod->is_playback_running = false;
}
return NULL;
}
static int32_t usb_record_entry(void *adev)
{
unsigned char usbbuf[USB_PROXY_PERIOD_SIZE] = {0};
int32_t ret, bytes, proxy_open_retry_count;
ALOGD("%s: entry", __func__);
/* update audio device pointer */
usbmod->adev = (struct audio_device*)adev;
proxy_open_retry_count = USB_PROXY_OPEN_RETRY_COUNT;
/* get capabilities */
pthread_mutex_lock(&usbmod->usb_record_lock);
ret = usb_get_capability((char *)"Capture:",
&usbmod->channels_record, &usbmod->sample_rate_record);
if (ret) {
ALOGE("%s: could not get capture capabilities from usb device",
__func__);
pthread_mutex_unlock(&usbmod->usb_record_lock);
return -EINVAL;
}
/* update config for usb
1 pcm frame(sample)= 4 bytes since two channels*/
pcm_config_usbmod.period_size = USB_PERIOD_SIZE/4;
pcm_config_usbmod.channels = usbmod->channels_record;
pcm_config_usbmod.rate = usbmod->sample_rate_record;
ALOGV("%s: usb device %u:period %u:channels %u:sample", __func__,
pcm_config_usbmod.period_size, pcm_config_usbmod.channels,
pcm_config_usbmod.rate);
usbmod->usb_pcm_record_handle = pcm_open(usbmod->usb_card, \
usbmod->usb_device_id, PCM_IN |
PCM_MMAP | PCM_NOIRQ , &pcm_config_usbmod);
if ((usbmod->usb_pcm_record_handle \
&& !pcm_is_ready(usbmod->usb_pcm_record_handle))
|| (!usbmod->is_record_running)) {
ALOGE("%s: failed: %s", __func__,
pcm_get_error(usbmod->usb_pcm_record_handle));
pcm_close(usbmod->usb_pcm_record_handle);
usbmod->usb_pcm_record_handle = NULL;
pthread_mutex_unlock(&usbmod->usb_record_lock);
return -ENOMEM;
}
ALOGD("%s: USB configured for capture", __func__);
/* update config for proxy*/
pcm_config_usbmod.period_size = USB_PROXY_PERIOD_SIZE/4;
pcm_config_usbmod.rate = usbmod->sample_rate_record;
pcm_config_usbmod.channels = usbmod->channels_record;
pcm_config_usbmod.period_count = AFE_PROXY_PERIOD_COUNT * 2;
usbmod->proxy_device_id = AFE_PROXY_CAPTURE_DEVICE;
ALOGV("%s: proxy device %u:period %u:channels %u:sample", __func__,
pcm_config_usbmod.period_size, pcm_config_usbmod.channels,
pcm_config_usbmod.rate);
while(proxy_open_retry_count){
usbmod->proxy_pcm_record_handle = pcm_open(usbmod->proxy_card,
usbmod->proxy_device_id, PCM_OUT |
PCM_MMAP | PCM_NOIRQ, &pcm_config_usbmod);
if(usbmod->proxy_pcm_record_handle
&& !pcm_is_ready(usbmod->proxy_pcm_record_handle)){
pcm_close(usbmod->proxy_pcm_record_handle);
usbmod->proxy_pcm_record_handle = NULL;
proxy_open_retry_count--;
usleep(USB_PROXY_OPEN_WAIT_TIME * 1000);
ALOGE("%s: pcm_open for proxy(recording) failed retrying = %d",
__func__, proxy_open_retry_count);
}
else{
break;
}
}
if ((usbmod->proxy_pcm_record_handle
&& !pcm_is_ready(usbmod->proxy_pcm_record_handle))
|| (!usbmod->is_record_running)) {
ALOGE("%s: failed: %s", __func__,
pcm_get_error(usbmod->proxy_pcm_record_handle));
pcm_close(usbmod->proxy_pcm_record_handle);
usbmod->proxy_pcm_record_handle = NULL;
pthread_mutex_unlock(&usbmod->usb_record_lock);
return -ENOMEM;
}
ALOGD("%s: PROXY configured for capture", __func__);
pthread_mutex_unlock(&usbmod->usb_record_lock);
/* main loop to read from usb and write to proxy */
while (usbmod->is_record_running) {
/* read data from usb */
ret = pcm_mmap_read(usbmod->usb_pcm_record_handle,
(void *)usbbuf, USB_PROXY_PERIOD_SIZE);
/* Write to proxy */
ret = pcm_mmap_write(usbmod->proxy_pcm_record_handle,
(void *)usbbuf, USB_PROXY_PERIOD_SIZE);
if(!usbmod->is_record_running)
break;
memset(usbbuf, 0, USB_PROXY_PERIOD_SIZE);
} /* main loop end */
ALOGD("%s: exiting USB capture thread",__func__);
return 0;
}
static void* usb_capture_launcher(void *adev)
{
int32_t ret;
usbmod->is_record_running = true;
ret = usb_record_entry(adev);
if (ret) {
ALOGE("%s: failed with err:%d", __func__, ret);
usbmod->is_record_running = false;
}
return NULL;
}
void audio_extn_usb_init(void *adev)
{
pthread_once(&alloc_usbmod_once_ctl, usb_alloc);
usbmod->is_playback_running = false;
usbmod->is_record_running = false;
usbmod->usb_pcm_playback_handle = NULL;
usbmod->proxy_pcm_playback_handle = NULL;
usbmod->usb_pcm_record_handle = NULL;
usbmod->proxy_pcm_record_handle = NULL;
usbmod->usb_card = 1;
usbmod->usb_device_id = 0;
usbmod->proxy_card = 0;
usbmod->proxy_device_id = AFE_PROXY_PLAYBACK_DEVICE;
usbmod->adev = (struct audio_device*)adev;
pthread_mutex_init(&usbmod->usb_playback_lock,
(const pthread_mutexattr_t *) NULL);
pthread_mutex_init(&usbmod->usb_record_lock,
(const pthread_mutexattr_t *) NULL);
}
void audio_extn_usb_deinit()
{
if (NULL != usbmod){
free(usbmod);
usbmod = NULL;
}
}
void audio_extn_usb_set_proxy_sound_card(uint32_t sndcard_idx)
{
/* Proxy port and USB headset are related to two different sound cards */
if (sndcard_idx == usbmod->usb_card) {
usbmod->usb_card = usbmod->proxy_card;
}
usbmod->proxy_card = sndcard_idx;
}
void audio_extn_usb_start_playback(void *adev)
{
int32_t ret;
if (NULL == usbmod){
ALOGE("%s: USB device object is NULL", __func__);
return;
}
if (usbmod->is_playback_running){
ALOGE("%s: USB playback thread already running", __func__);
return;
}
ALOGD("%s: creating USB playback thread", __func__);
ret = pthread_create(&usbmod->usb_playback_thr, NULL,
usb_playback_launcher, (void*)adev);
if (ret)
ALOGE("%s: failed to create USB playback thread with err:%d",
__func__, ret);
}
void audio_extn_usb_stop_playback()
{
int32_t ret;
ALOGD("%s: entry", __func__);
usbmod->is_playback_running = false;
if (NULL != usbmod->proxy_pcm_playback_handle)
pcm_stop(usbmod->proxy_pcm_playback_handle);
if (NULL != usbmod->usb_pcm_playback_handle)
pcm_stop(usbmod->usb_pcm_playback_handle);
if(usbmod->usb_playback_thr) {
ret = pthread_join(usbmod->usb_playback_thr,NULL);
ALOGE("%s: return for pthread_join = %d", __func__, ret);
usbmod->usb_playback_thr = (pthread_t)NULL;
}
pthread_mutex_lock(&usbmod->usb_playback_lock);
if (NULL != usbmod->usb_pcm_playback_handle){
pcm_close(usbmod->usb_pcm_playback_handle);
usbmod->usb_pcm_playback_handle = NULL;
}
if (NULL != usbmod->proxy_pcm_playback_handle){
pcm_close(usbmod->proxy_pcm_playback_handle);
usbmod->proxy_pcm_playback_handle = NULL;
}
pthread_mutex_unlock(&usbmod->usb_playback_lock);
ALOGD("%s: exiting",__func__);
}
void audio_extn_usb_start_capture(void *adev)
{
int32_t ret;
if (NULL == usbmod){
ALOGE("%s: USB device object is NULL", __func__);
return;
}
if (usbmod->is_record_running){
ALOGE("%s: USB capture thread already running", __func__);
return;
}
ALOGD("%s: creating USB capture thread", __func__);
ret = pthread_create(&usbmod->usb_record_thr, NULL,
usb_capture_launcher, (void*)adev);
if (ret)
ALOGE("%s: failed to create USB capture thread with err:%d",
__func__, ret);
}
void audio_extn_usb_stop_capture()
{
int32_t ret;
ALOGD("%s: entry", __func__);
usbmod->is_record_running = false;
if (NULL != usbmod->proxy_pcm_record_handle)
pcm_stop(usbmod->proxy_pcm_record_handle);
if (NULL != usbmod->usb_pcm_record_handle)
pcm_stop(usbmod->usb_pcm_record_handle);
if(usbmod->usb_record_thr) {
ret = pthread_join(usbmod->usb_record_thr,NULL);
ALOGE("%s: return for pthread_join = %d", __func__, ret);
usbmod->usb_record_thr = (pthread_t)NULL;
}
pthread_mutex_lock(&usbmod->usb_record_lock);
if (NULL != usbmod->usb_pcm_record_handle){
pcm_close(usbmod->usb_pcm_record_handle);
usbmod->usb_pcm_record_handle = NULL;
}
if (NULL != usbmod->proxy_pcm_record_handle){
pcm_close(usbmod->proxy_pcm_record_handle);
usbmod->proxy_pcm_record_handle = NULL;
}
pthread_mutex_unlock(&usbmod->usb_record_lock);
ALOGD("%s: exiting",__func__);
}
bool audio_extn_usb_is_proxy_inuse()
{
if( usbmod->is_record_running || usbmod->is_playback_running)
return true;
else
return false;
}
#endif /*USB_HEADSET_ENABLED end*/
Reference in New Issue View Git Blame Copy Permalink