#include <stdio.h>
|
#include <stdlib.h>
|
#include <pthread.h>
|
#include <unistd.h>
|
|
#include <alsa/asoundlib.h>
|
#include <sys/time.h>
|
#include <sys/socket.h>
|
#include <sys/un.h>
|
|
#include "../a2dp_source/a2dp_masterctrl.h"
|
#include "rfcomm_msg.h"
|
#include "slog.h"
|
|
typedef struct {
|
int sockfd;
|
pthread_t tid;
|
RK_BT_HFP_CALLBACK cb;
|
} rfcomm_handler_t;
|
|
typedef struct {
|
const char *no_calls_active; //No calls (held or active)
|
const char *call_present_active; //Call is present (active or held)
|
const char *no_call_progress; //No call setup in progress
|
const char *incoming_call_progress; //Incoming call setup in progress
|
const char *outgoing_call_dialing; //Outgoing call setup in dialing state
|
const char *outgoing_call_alerting; //Outgoing call setup in alerting state
|
} rfcomm_ciev_status_t;
|
|
typedef struct {
|
bool is_call_present_active;
|
bool is_outgoing_call;
|
bool is_send_audio_open;
|
bool is_incoming_call;
|
int dev_platform;
|
} rfcomm_control_t;
|
|
static rfcomm_control_t g_rfcomm_control = {
|
false,
|
false,
|
false,
|
false,
|
DEV_PLATFORM_UNKNOWN,
|
};
|
|
static rfcomm_handler_t g_rfcomm_handler = {
|
-1, 0, NULL,
|
};
|
|
void rfcomm_hfp_send_event(RK_BT_HFP_EVENT event, void *data)
|
{
|
char address[18];
|
|
if (!g_rfcomm_handler.cb)
|
return;
|
|
memset(address, 0, 18);
|
bt_get_default_dev_addr(address, 18);
|
|
g_rfcomm_handler.cb(address, event, data);
|
}
|
|
static void send_audio_open_evt(int time_ms)
|
{
|
if(!g_rfcomm_control.is_send_audio_open) {
|
if(time_ms)
|
usleep(time_ms * 1000);
|
|
rfcomm_hfp_send_event(RK_BT_HFP_AUDIO_OPEN_EVT, NULL);
|
g_rfcomm_control.is_send_audio_open = true;
|
}
|
}
|
|
static void send_audio_close_evt(int time_ms)
|
{
|
if(g_rfcomm_control.is_send_audio_open) {
|
if(time_ms)
|
usleep(time_ms * 1000);
|
|
rfcomm_hfp_send_event(RK_BT_HFP_AUDIO_CLOSE_EVT, NULL);
|
g_rfcomm_control.is_send_audio_open = false;
|
}
|
}
|
|
static void config_ciev_msg(rfcomm_ciev_status_t *rfcomm_ciev_status)
|
{
|
if(rfcomm_ciev_status == NULL)
|
return;
|
|
g_rfcomm_control.dev_platform = get_current_dev_platform();
|
|
if(g_rfcomm_control.dev_platform == DEV_PLATFORM_IOS) {
|
rfcomm_ciev_status->no_calls_active = "2,0";
|
rfcomm_ciev_status->call_present_active = "2,1";
|
rfcomm_ciev_status->no_call_progress = "3,0";
|
rfcomm_ciev_status->incoming_call_progress = "3,1";
|
rfcomm_ciev_status->outgoing_call_dialing = "3,2";
|
rfcomm_ciev_status->outgoing_call_alerting = "3,3";
|
} else {
|
rfcomm_ciev_status->no_calls_active = "1,0";
|
rfcomm_ciev_status->call_present_active = "1,1";
|
rfcomm_ciev_status->no_call_progress = "2,0";
|
rfcomm_ciev_status->incoming_call_progress = "2,1";
|
rfcomm_ciev_status->outgoing_call_dialing = "2,2";
|
rfcomm_ciev_status->outgoing_call_alerting = "2,3";
|
}
|
}
|
|
static void process_ciev_msg(char *msg, rfcomm_ciev_status_t rfcomm_ciev_status)
|
{
|
if(strstr(msg, rfcomm_ciev_status.no_calls_active)) {
|
rfcomm_hfp_send_event(RK_BT_HFP_HANGUP_EVT, NULL);
|
send_audio_close_evt(1000);
|
} else if (strstr(msg, rfcomm_ciev_status.outgoing_call_dialing)) {
|
g_rfcomm_control.is_outgoing_call = true;
|
} else if (strstr(msg, rfcomm_ciev_status.outgoing_call_alerting)) {
|
if(g_rfcomm_control.is_outgoing_call) {
|
send_audio_open_evt(0);
|
g_rfcomm_control.is_outgoing_call = false;
|
}
|
} else if (strstr(msg, rfcomm_ciev_status.call_present_active)){
|
g_rfcomm_control.is_call_present_active = true;
|
rfcomm_hfp_send_event(RK_BT_HFP_PICKUP_EVT, NULL);
|
} else if (strstr(msg, rfcomm_ciev_status.no_call_progress)) {
|
if(!g_rfcomm_control.is_call_present_active) {
|
rfcomm_hfp_send_event(RK_BT_HFP_HANGUP_EVT, NULL);
|
send_audio_close_evt(1000);
|
} else {
|
if(g_rfcomm_control.dev_platform == DEV_PLATFORM_UNKNOWN)
|
send_audio_open_evt(500);
|
g_rfcomm_control.is_call_present_active = false;
|
}
|
} else if (strstr(msg, rfcomm_ciev_status.incoming_call_progress)) {
|
g_rfcomm_control.is_incoming_call = true; //for apple ios
|
}
|
}
|
|
static void process_bcs_msg(char *msg)
|
{
|
unsigned short codec_type = 0;
|
|
if(strstr(msg, "1"))
|
codec_type = BT_SCO_CODEC_CVSD;
|
else if(strstr(msg, "2"))
|
codec_type = BT_SCO_CODEC_MSBC;
|
|
rfcomm_hfp_send_event(RK_BT_HFP_BCS_EVT, &codec_type);
|
|
if(g_rfcomm_control.dev_platform == DEV_PLATFORM_IOS && g_rfcomm_control.is_incoming_call) {
|
send_audio_open_evt(500);
|
g_rfcomm_control.is_incoming_call = false;
|
}
|
}
|
|
static void *thread_get_ba_msg(void *arg)
|
{
|
int ret = 0;
|
char buff[100] = {0};
|
struct sockaddr_un clientAddr;
|
struct sockaddr_un serverAddr;
|
socklen_t addr_len;
|
rfcomm_ciev_status_t rfcomm_ciev_status;
|
|
g_rfcomm_handler.sockfd = socket(AF_UNIX, SOCK_DGRAM, 0);
|
if (g_rfcomm_handler.sockfd < 0) {
|
pr_info("Create socket failed!\n");
|
return NULL;
|
}
|
|
serverAddr.sun_family = AF_UNIX;
|
strcpy(serverAddr.sun_path, "/tmp/rk_deviceio_rfcomm_status");
|
|
system("rm -rf /tmp/rk_deviceio_rfcomm_status");
|
ret = bind(g_rfcomm_handler.sockfd, (struct sockaddr *)&serverAddr, sizeof(serverAddr));
|
if (ret < 0) {
|
pr_err("Bind Local addr failed!\n");
|
return NULL;
|
}
|
|
while(1) {
|
memset(buff, 0, sizeof(buff));
|
ret = recvfrom(g_rfcomm_handler.sockfd, buff, sizeof(buff), 0, (struct sockaddr *)&clientAddr, &addr_len);
|
if (ret <= 0) {
|
if (ret == 0)
|
pr_info("###### FUCN:%s. socket closed!\n", __func__);
|
break;
|
}
|
pr_info("###### FUCN:%s. Received a malformed message(%s)\n", __func__, buff);
|
|
if (strstr(buff, "rfcomm status:hfp_hf_ring;")) {
|
rfcomm_hfp_send_event(RK_BT_HFP_RING_EVT, NULL);
|
} else if (strstr(buff, "rfcomm status:hfp_slc_connected;")) {
|
memset(&rfcomm_ciev_status, 0, sizeof(rfcomm_ciev_status_t));
|
memset(&g_rfcomm_control, 0, sizeof(rfcomm_control_t));
|
config_ciev_msg(&rfcomm_ciev_status);
|
rfcomm_hfp_send_event(RK_BT_HFP_CONNECT_EVT, NULL);
|
} else if (strstr(buff, "rfcomm status:hfp_slc_disconnected;")) {
|
rfcomm_hfp_send_event(RK_BT_HFP_DISCONNECT_EVT, NULL);
|
} else if (strstr(buff, "rfcomm status:hfp_hf_connected;")) {
|
//send_audio_open_evt(0);
|
} else if(strstr(buff, "rfcomm status:") && strstr(buff, "+CIEV")) {
|
process_ciev_msg(buff, rfcomm_ciev_status);
|
} else if(strstr(buff, "rfcomm status:") && strstr(buff, "+BCS")) {
|
process_bcs_msg(buff);
|
} else {
|
pr_info("FUCN:%s. Received a malformed message(%s)\n", __func__, buff);
|
}
|
}
|
|
pr_info("###### FUCN:%s exit!\n", __func__);
|
return NULL;
|
}
|
|
int rfcomm_listen_ba_msg_start()
|
{
|
pthread_t tid;
|
|
/* Create a thread to listen for Bluezalsa hfp-hf status. */
|
if(!g_rfcomm_handler.tid) {
|
if(pthread_create(&g_rfcomm_handler.tid, NULL, thread_get_ba_msg, NULL)) {
|
pr_err("Create rfcomm listen pthread failed\n");
|
return -1;
|
}
|
|
pthread_setname_np(g_rfcomm_handler.tid, "rfcomm_listen");
|
}
|
|
return 0;
|
}
|
|
int rfcomm_listen_ba_msg_stop()
|
{
|
pr_debug("%s enter\n", __func__);
|
if (g_rfcomm_handler.sockfd >= 0) {
|
shutdown(g_rfcomm_handler.sockfd, SHUT_RDWR);
|
g_rfcomm_handler.sockfd = -1;
|
}
|
|
if(g_rfcomm_handler.tid) {
|
pthread_join(g_rfcomm_handler.tid, NULL);
|
g_rfcomm_handler.tid = 0;
|
}
|
|
pr_debug("%s exit\n", __func__);
|
return 0;
|
}
|
|
void rfcomm_hfp_hf_regist_cb(RK_BT_HFP_CALLBACK cb)
|
{
|
g_rfcomm_handler.cb = cb;
|
}
|
|
/***********************************************************
|
* Audio path config api
|
***********************************************************/
|
|
static int g_audio_path_valid_flag = 0;
|
static snd_pcm_t *local_play_pcm, *local_record_pcm;
|
static snd_pcm_t *bt_play_pcm, *bt_record_pcm;
|
pthread_t g_playback_tid = 0, g_capture_tid = 0;
|
|
typedef struct _setup_pcm_param {
|
unsigned char channel;
|
unsigned int samplerate;
|
unsigned int buffer_time;
|
unsigned int period_time;
|
snd_pcm_uframes_t start_threshold;
|
snd_pcm_format_t format;
|
} setup_pcm_param;
|
|
static int set_hw_params(snd_pcm_t *pcm, setup_pcm_param *param, char **msg)
|
{
|
const snd_pcm_access_t access = SND_PCM_ACCESS_RW_INTERLEAVED;
|
snd_pcm_format_t format;
|
snd_pcm_hw_params_t *params;
|
int channels, rate;
|
unsigned int *buffer_time;
|
unsigned int *period_time;
|
char buf[256];
|
int dir;
|
int err;
|
|
channels = param->channel;
|
rate = param->samplerate;
|
buffer_time = &(param->buffer_time);
|
period_time = &(param->period_time);
|
format = param->format;
|
|
snd_pcm_hw_params_alloca(¶ms);
|
|
if ((err = snd_pcm_hw_params_any(pcm, params)) != 0) {
|
snprintf(buf, sizeof(buf), "Set all possible ranges: %s", snd_strerror(err));
|
goto fail;
|
}
|
if ((err = snd_pcm_hw_params_set_access(pcm, params, access)) != 0) {
|
snprintf(buf, sizeof(buf), "Set assess type: %s: %s", snd_strerror(err), snd_pcm_access_name(access));
|
goto fail;
|
}
|
if ((err = snd_pcm_hw_params_set_format(pcm, params, format)) != 0) {
|
snprintf(buf, sizeof(buf), "Set format: %s: %s", snd_strerror(err), snd_pcm_format_name(format));
|
goto fail;
|
}
|
if ((err = snd_pcm_hw_params_set_channels(pcm, params, channels)) != 0) {
|
snprintf(buf, sizeof(buf), "Set channels: %s: %d", snd_strerror(err), channels);
|
goto fail;
|
}
|
if ((err = snd_pcm_hw_params_set_rate(pcm, params, rate, 0)) != 0) {
|
snprintf(buf, sizeof(buf), "Set sampling rate: %s: %d", snd_strerror(err), rate);
|
goto fail;
|
}
|
if ((err = snd_pcm_hw_params_set_buffer_time_near(pcm, params, buffer_time, &dir)) != 0) {
|
snprintf(buf, sizeof(buf), "Set buffer time: %s: %u", snd_strerror(err), *buffer_time);
|
goto fail;
|
}
|
if ((err = snd_pcm_hw_params_set_period_time_near(pcm, params, period_time, &dir)) != 0) {
|
snprintf(buf, sizeof(buf), "Set period time: %s: %u", snd_strerror(err), *period_time);
|
goto fail;
|
}
|
if ((err = snd_pcm_hw_params(pcm, params)) != 0) {
|
snprintf(buf, sizeof(buf), "%s", snd_strerror(err));
|
goto fail;
|
}
|
|
return 0;
|
|
fail:
|
if (msg != NULL)
|
*msg = strdup(buf);
|
return err;
|
}
|
|
static int set_sw_params(snd_pcm_t *pcm, snd_pcm_uframes_t buffer_size,
|
snd_pcm_uframes_t period_size, snd_pcm_uframes_t start_threshold, char **msg)
|
{
|
snd_pcm_sw_params_t *params;
|
snd_pcm_uframes_t threshold;
|
char buf[256];
|
int err;
|
|
snd_pcm_sw_params_alloca(¶ms);
|
|
if ((err = snd_pcm_sw_params_current(pcm, params)) != 0) {
|
snprintf(buf, sizeof(buf), "Get current params: %s", snd_strerror(err));
|
goto fail;
|
}
|
|
/* start the transfer when the buffer is full (or almost full) */
|
if (start_threshold == 0)
|
threshold = (buffer_size / period_size) * period_size;
|
else
|
threshold = start_threshold;
|
if ((err = snd_pcm_sw_params_set_start_threshold(pcm, params, threshold)) != 0) {
|
snprintf(buf, sizeof(buf), "Set start threshold: %s: %lu", snd_strerror(err), threshold);
|
goto fail;
|
}
|
|
/* allow the transfer when at least period_size samples can be processed */
|
if ((err = snd_pcm_sw_params_set_avail_min(pcm, params, period_size)) != 0) {
|
snprintf(buf, sizeof(buf), "Set avail min: %s: %lu", snd_strerror(err), period_size);
|
goto fail;
|
}
|
|
if ((err = snd_pcm_sw_params(pcm, params)) != 0) {
|
snprintf(buf, sizeof(buf), "%s", snd_strerror(err));
|
goto fail;
|
}
|
|
return 0;
|
|
fail:
|
if (msg != NULL)
|
*msg = strdup(buf);
|
return err;
|
}
|
|
static int setup_pcm_handle(char *name, snd_pcm_t *pcm, setup_pcm_param *param)
|
{
|
char *msg = NULL;
|
int err = 0;
|
snd_pcm_uframes_t buffer_size, period_size;
|
|
if ((err = set_hw_params(pcm, param, &msg)) != 0) {
|
pr_info("Couldn't set %s HW parameters: %s", name, msg);
|
goto dofail;
|
}
|
|
if ((err = snd_pcm_get_params(pcm, &buffer_size, &period_size)) != 0) {
|
pr_info("Couldn't get %s PCM parameters: %s", name, snd_strerror(err));
|
goto dofail;
|
}
|
|
pr_info("Used configuration for %s:\n"
|
" PCM buffer time: %u us (%zu bytes)\n"
|
" PCM period time: %u us (%zu bytes)\n"
|
" Sampling rate: %u Hz\n"
|
" Channels: %u\n"
|
" StartThreshold: %lu\n",
|
name,
|
param->buffer_time, snd_pcm_frames_to_bytes(pcm, buffer_size),
|
param->period_time, snd_pcm_frames_to_bytes(pcm, period_size),
|
param->samplerate, param->channel, param->start_threshold);
|
|
if ((err = set_sw_params(pcm, buffer_size, period_size, param->start_threshold, &msg)) != 0) {
|
pr_info("Couldn't set SW parameters: %s", msg);
|
goto dofail;
|
}
|
|
if ((err = snd_pcm_prepare(pcm)) != 0) {
|
pr_info("Couldn't prepare PCM: %s", snd_strerror(err));
|
goto dofail;
|
}
|
|
return 0;
|
|
dofail:
|
if (msg)
|
free(msg);
|
return -1;
|
}
|
|
static void *thread_record_start(void *arg)
|
{
|
snd_pcm_uframes_t buffer_size = 0, period_size = 0;
|
int period_bytes = 0;
|
char *buffer = NULL;
|
int ret = 0;
|
|
snd_pcm_get_params(bt_play_pcm, &buffer_size, &period_size);
|
period_bytes = snd_pcm_frames_to_bytes(bt_play_pcm, buffer_size);
|
buffer = (char *)malloc(period_bytes);
|
if (!buffer) {
|
pr_info("ERROR:%s no space left!\n", __func__);
|
return NULL;
|
}
|
memset(buffer, 0, period_size);
|
|
pr_info("#%s start... period_bytes = %d\n", __func__, period_bytes);
|
|
while (g_audio_path_valid_flag) {
|
memset(buffer, 0, period_bytes);
|
ret = snd_pcm_readi(local_record_pcm, buffer , period_size);
|
if (ret < 0) {
|
if (ret == -EPIPE) {
|
pr_info( "Xrun occurred: LocalCaputure\n");
|
snd_pcm_prepare(local_record_pcm);
|
} else {
|
pr_info("ERROR: %s read frame error=%d\n", __func__, ret);
|
return NULL;
|
}
|
}
|
|
ret = snd_pcm_writei(bt_play_pcm, buffer, period_size);
|
if (ret < 0) {
|
if (ret == -EPIPE) {
|
pr_info( "Xrun occurred: BtPlayback\n");
|
snd_pcm_prepare(bt_play_pcm);
|
} else {
|
pr_info("ERROR: %s write frame error=%d\n", __func__, ret);
|
return NULL;
|
}
|
}
|
}
|
|
pr_info("#%s end... \n", __func__);
|
|
snd_pcm_close(local_record_pcm);
|
snd_pcm_close(bt_play_pcm);
|
local_record_pcm = NULL;
|
bt_play_pcm = NULL;
|
free(buffer);
|
|
return NULL;
|
}
|
|
static void *thread_playback_start(void *arg)
|
{
|
snd_pcm_uframes_t buffer_size = 0, period_size = 0;
|
int period_bytes = 0;
|
char *buffer = NULL;
|
int ret = 0;
|
|
snd_pcm_get_params(local_play_pcm, &buffer_size, &period_size);
|
period_bytes = snd_pcm_frames_to_bytes(local_play_pcm, buffer_size);
|
buffer = (char *)malloc(period_bytes);
|
if (!buffer) {
|
pr_info("ERROR:%s no space left!\n", __func__);
|
return NULL;
|
}
|
memset(buffer, 0, period_size);
|
|
pr_info("#%s start... period_bytes = %d\n", __func__, period_bytes);
|
|
while (g_audio_path_valid_flag) {
|
memset(buffer, 0, period_bytes);
|
ret = snd_pcm_readi(bt_record_pcm, buffer , period_size);
|
if (ret < 0) {
|
if (ret == -EPIPE) {
|
pr_info( "Xrun occurred: BtCaputure\n");
|
snd_pcm_prepare(bt_record_pcm);
|
} else {
|
pr_info("ERROR: %s read frame error=%d\n", __func__, ret);
|
return NULL;
|
}
|
}
|
|
ret = snd_pcm_writei(local_play_pcm, buffer, period_size);
|
if (ret < 0) {
|
if (ret == -EPIPE) {
|
pr_info( "Xrun occurred: LocalPlayback\n");
|
snd_pcm_prepare(local_play_pcm);
|
} else {
|
pr_info("ERROR: %s write frame error=%d\n", __func__, ret);
|
return NULL;
|
}
|
}
|
}
|
|
pr_info("#%s end...\n", __func__);
|
|
snd_pcm_close(local_play_pcm);
|
snd_pcm_close(bt_record_pcm);
|
local_play_pcm = NULL;
|
bt_record_pcm = NULL;
|
free(buffer);
|
|
return NULL;
|
}
|
|
int rfcomm_hfp_open_audio_path()
|
{
|
int err;
|
setup_pcm_param pcm_param;
|
|
if (g_audio_path_valid_flag) {
|
pr_info("WARNING: Hfp audio path has already be opened!\n");
|
return 0;
|
}
|
|
/* Open and setup LocalPlayback audio handle */
|
if ((err = snd_pcm_open(&local_play_pcm, "default", SND_PCM_STREAM_PLAYBACK, 0)) != 0) {
|
pr_info("Couldn't open local playback PCM: %s", snd_strerror(err));
|
goto fail;
|
}
|
pcm_param.channel = 2;
|
pcm_param.samplerate = 8000;
|
pcm_param.buffer_time = 100000;
|
pcm_param.period_time = 20000;
|
pcm_param.format = SND_PCM_FORMAT_S16_LE;
|
pcm_param.start_threshold = 0; //default
|
if ((err = setup_pcm_handle("LocalPlayback", local_play_pcm, &pcm_param)) != 0) {
|
pr_info("Set up Local Playback audio path failed!\n");
|
goto fail;
|
}
|
|
/* Open and setup LocalCaputure audio handle */
|
if ((err = snd_pcm_open(&local_record_pcm, "2mic_loopback", SND_PCM_STREAM_CAPTURE, 0)) != 0) {
|
pr_info("Couldn't open local capture PCM: %s", snd_strerror(err));
|
goto fail;
|
}
|
pcm_param.channel = 2;
|
pcm_param.samplerate = 8000;
|
pcm_param.buffer_time = 400000;
|
pcm_param.period_time = 20000;
|
pcm_param.format = SND_PCM_FORMAT_S16_LE;
|
pcm_param.start_threshold = 1;
|
if ((err = setup_pcm_handle("LocalCaputure", local_record_pcm, &pcm_param)) != 0) {
|
pr_info("Set up Local Caputure audio path failed!\n");
|
goto fail;
|
}
|
|
/* Open and setup BtPlayback audio handle */
|
if ((err = snd_pcm_open(&bt_play_pcm, "hw:1,0", SND_PCM_STREAM_PLAYBACK, 0)) != 0) {
|
pr_info("Couldn't open bt playback PCM: %s", snd_strerror(err));
|
goto fail;
|
}
|
pcm_param.channel = 2;
|
pcm_param.samplerate = 8000;
|
pcm_param.buffer_time = 100000;
|
pcm_param.period_time = 20000;
|
pcm_param.format = SND_PCM_FORMAT_S16_LE;
|
pcm_param.start_threshold = 0;
|
if ((err = setup_pcm_handle("BtPlayback", bt_play_pcm, &pcm_param)) != 0) {
|
pr_info("Set up Bt Playback audio path failed!\n");
|
goto fail;
|
}
|
|
/* Open and setup BtCaputure audio handle */
|
if ((err = snd_pcm_open(&bt_record_pcm, "hw:1,0", SND_PCM_STREAM_CAPTURE, 0)) != 0) {
|
pr_info("Couldn't open bt capture PCM: %s", snd_strerror(err));
|
goto fail;
|
}
|
pcm_param.channel = 2;
|
pcm_param.samplerate = 8000;
|
pcm_param.buffer_time = 400000;
|
pcm_param.period_time = 20000;
|
pcm_param.format = SND_PCM_FORMAT_S16_LE;
|
pcm_param.start_threshold = 1;
|
if ((err = setup_pcm_handle("BtCaputure", bt_record_pcm, &pcm_param)) != 0) {
|
pr_info("Set up Bt Caputure audio path failed!\n");
|
goto fail;
|
}
|
|
g_audio_path_valid_flag = 1;
|
/* Create a thread to listen for Bluezalsa hfp-hf status. */
|
pthread_create(&g_playback_tid, NULL, thread_playback_start, NULL);
|
/* Create a thread to listen for Bluezalsa hfp-hf status. */
|
pthread_create(&g_capture_tid, NULL, thread_record_start, NULL);
|
|
return 0;
|
|
fail:
|
if (local_play_pcm)
|
snd_pcm_close(local_play_pcm);
|
if (local_record_pcm)
|
snd_pcm_close(local_record_pcm);
|
if (bt_play_pcm)
|
snd_pcm_close(bt_play_pcm);
|
if (bt_record_pcm)
|
snd_pcm_close(bt_record_pcm);
|
|
local_play_pcm = NULL;
|
local_record_pcm = NULL;
|
bt_play_pcm = NULL;
|
bt_record_pcm = NULL;
|
|
g_audio_path_valid_flag = 0;
|
|
return -1;
|
}
|
|
int rfcomm_hfp_close_audio_path()
|
{
|
void *status;
|
|
pr_info("#%s is called! flag=%d\n", __func__, g_audio_path_valid_flag);
|
|
if (g_audio_path_valid_flag) {
|
g_audio_path_valid_flag = 0;
|
pthread_join(g_playback_tid, &status);
|
pthread_join(g_capture_tid, &status);
|
}
|
|
return 0;
|
}
|
