1873 lines
61 KiB
C++
1873 lines
61 KiB
C++
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <iostream>
|
|
#include <vector>
|
|
#include <errno.h>
|
|
#include <alsa/asoundlib.h>
|
|
#include <math.h>
|
|
#include <signal.h>
|
|
#include <sys/epoll.h>
|
|
#include <sys/inotify.h>
|
|
#include <sys/time.h>
|
|
#include <sys/socket.h>
|
|
#include <sys/un.h>
|
|
#include <getopt.h>
|
|
|
|
#include "eq_log.h"
|
|
#include "Rk_wake_lock.h"
|
|
#include "Rk_socket_app.h"
|
|
|
|
#define EQ_DRC_PROCESS_VERSION "1.29 20210720"
|
|
|
|
#define SOC_IS_RK3308 (0x1)
|
|
#define SOC_IS_RK3326 (0x2)
|
|
|
|
#define ROCKCHIP_SOC SOC_IS_RK3326
|
|
|
|
#define SAMPLE_RATE 48000
|
|
#define CHANNEL 2
|
|
#define REC_DEVICE_NAME "fake_record"
|
|
#define WRITE_DEVICE_NAME "fake_play"
|
|
#define JACK_DEVICE_NAME "fake_jack"
|
|
#define JACK2_DEVICE_NAME "fake_jack2"
|
|
#define READ_FRAME_DEFAULT 1920
|
|
#define PERIOD_SIZE_DEFAULT (READ_FRAME_DEFAULT)
|
|
#define PERIOD_COUNTS_DEFAULT (8)
|
|
#define BUFFER_SIZE_DEFAULT (PERIOD_SIZE_DEFAULT * PERIOD_COUNTS_DEFAULT) /* Keeping a large buffer_size ASAP */
|
|
#define MUTE_TIME_DEFAULT (3) /* seconds */
|
|
//#define ALSA_READ_FORMAT SND_PCM_FORMAT_S32_LE
|
|
#define ALSA_READ_FORMAT SND_PCM_FORMAT_S16_LE
|
|
#define ALSA_WRITE_FORMAT SND_PCM_FORMAT_S16_LE
|
|
|
|
/*
|
|
* Select different alsa pathways based on device type.
|
|
* LINE_OUT: LR-Mix(fake_play)->EqDrcProcess(ladspa)->Speaker(real_playback)
|
|
* HEAD_SET: fake_jack -> Headset(real_playback)
|
|
* BLUETOOTH: device as bluetooth source.
|
|
*/
|
|
#define DEVICE_FLAG_LINE_OUT 0x01
|
|
#define DEVICE_FLAG_ANALOG_HP 0x02
|
|
#define DEVICE_FLAG_DIGITAL_HP 0x03
|
|
#define DEVICE_FLAG_BLUETOOTH 0x04
|
|
#define DEVICE_FLAG_BLUETOOTH_BSA 0x05
|
|
|
|
enum BT_CONNECT_STATE{
|
|
BT_DISCONNECT = 0,
|
|
BT_CONNECT_BLUEZ,
|
|
BT_CONNECT_BSA
|
|
};
|
|
|
|
#define POWER_STATE_PATH "/sys/power/state"
|
|
#define USER_PLAY_STATUS "/dev/snd/pcmC7D0p"
|
|
#define USER_CAPT_STATUS "/dev/snd/pcmC0D0c"
|
|
|
|
/**
|
|
* 0: By default and universal (Recommend)
|
|
* 1: More fast but only used for RK817 or RK809 Codec
|
|
*/
|
|
#define KEEPING_HW_CARD 0
|
|
#if KEEPING_HW_CARD
|
|
#define HW_CARD_PATH_DEFAULT "SPK"
|
|
#endif
|
|
|
|
struct user_play_inotify {
|
|
int fd;
|
|
int watch_desc;
|
|
bool stop;
|
|
};
|
|
|
|
struct user_capt_inotify {
|
|
int fd;
|
|
int watch_desc;
|
|
bool stop;
|
|
};
|
|
|
|
enum {
|
|
USER_PLAY_CLOSED = 0,
|
|
USER_PLAY_CLOSING,
|
|
USER_PLAY_OPENED,
|
|
};
|
|
|
|
enum {
|
|
USER_CAPT_CLOSED = 0,
|
|
USER_CAPT_CLOSING,
|
|
USER_CAPT_OPENED,
|
|
};
|
|
|
|
enum {
|
|
POWER_STATE_RESUME = 0,
|
|
POWER_STATE_SUSPENDING,
|
|
POWER_STATE_SUSPEND,
|
|
};
|
|
|
|
static int g_read_frame = READ_FRAME_DEFAULT;
|
|
static int g_period_size = PERIOD_SIZE_DEFAULT;
|
|
static int g_period_counts = PERIOD_COUNTS_DEFAULT;
|
|
static int g_buffer_size = BUFFER_SIZE_DEFAULT;
|
|
|
|
#if KEEPING_HW_CARD
|
|
static char g_path_name[32];
|
|
volatile static bool g_fast_codec = false;
|
|
#endif
|
|
|
|
static struct user_play_inotify g_upi;
|
|
static struct user_capt_inotify g_uci;
|
|
static char g_bt_mac_addr[17];
|
|
static enum BT_CONNECT_STATE g_bt_is_connect = BT_DISCONNECT;
|
|
static bool g_system_sleep = false;
|
|
static char sock_path[] = "/data/bsa/config/bsa_socket";
|
|
|
|
#if KEEPING_HW_CARD
|
|
static snd_pcm_t *write_handle_bak = NULL;
|
|
#endif
|
|
|
|
volatile static int power_state = POWER_STATE_RESUME;
|
|
volatile static int user_play_state = USER_PLAY_CLOSED;
|
|
volatile static int user_capt_state = USER_CAPT_CLOSED;
|
|
|
|
struct timeval tv_begin, tv_end;
|
|
//gettimeofday(&tv_begin, NULL);
|
|
|
|
extern int set_sw_params(snd_pcm_t *pcm, snd_pcm_uframes_t buffer_size,
|
|
snd_pcm_uframes_t period_size, char **msg);
|
|
|
|
/* epoll for inotify */
|
|
#define EPOLL_SIZE 512
|
|
#define ARRAY_LENGTH 128
|
|
#define NAME_LENGTH 128
|
|
|
|
#define EPOLL_MAX_EVENTS 32
|
|
|
|
struct file_name_fd_desc {
|
|
int fd;
|
|
char name[32];
|
|
char base_name[NAME_LENGTH];
|
|
};
|
|
|
|
static struct epoll_event g_PendingEventItems[EPOLL_MAX_EVENTS];
|
|
|
|
static struct file_name_fd_desc g_file_name_fd_desc[ARRAY_LENGTH];
|
|
static int array_index = 0;
|
|
|
|
static const char *base_dir = "/sys/power";
|
|
|
|
/* hanlding fade-in or fade-out */
|
|
#define FADE_IN 0
|
|
#define FADE_OUT 1
|
|
|
|
#ifndef av_clipd
|
|
# define av_clipd av_clipd_c
|
|
#endif
|
|
|
|
enum CurveType { NONE = -1, TRI, QSIN, ESIN, HSIN, LOG, IPAR, QUA, CUB, SQU, CBR, PAR, EXP, IQSIN, IHSIN, DESE, DESI, LOSI, SINC, ISINC, NB_CURVES };
|
|
|
|
/**
|
|
* Clip a double value into the amin-amax range.
|
|
* @param a value to clip
|
|
* @param amin minimum value of the clip range
|
|
* @param amax maximum value of the clip range
|
|
* @return clipped value
|
|
*/
|
|
static inline const double av_clipd_c(double a, double amin, double amax)
|
|
{
|
|
// eq_info("[EQ] %s - %d enter\n", __func__, __LINE__);
|
|
if (a < amin) return amin;
|
|
else if (a > amax) return amax;
|
|
else return a;
|
|
}
|
|
|
|
static double fade_gain(int curve, int64_t index, int64_t range)
|
|
{
|
|
#define CUBE(a) ((a)*(a)*(a))
|
|
double gain;
|
|
|
|
gain = av_clipd(1.0 * index / range, 0, 1.0);
|
|
|
|
// eq_info("[EQ] %s - %d index=%ld gain=%lf\n", __func__, __LINE__, index, gain);
|
|
|
|
switch (curve) {
|
|
case QSIN:
|
|
gain = sin(gain * M_PI / 2.0);
|
|
break;
|
|
case IQSIN:
|
|
/* 0.6... = 2 / M_PI */
|
|
gain = 0.6366197723675814 * asin(gain);
|
|
break;
|
|
case ESIN:
|
|
gain = 1.0 - cos(M_PI / 4.0 * (CUBE(2.0*gain - 1) + 1));
|
|
break;
|
|
case HSIN:
|
|
gain = (1.0 - cos(gain * M_PI)) / 2.0;
|
|
break;
|
|
case IHSIN:
|
|
/* 0.3... = 1 / M_PI */
|
|
gain = 0.3183098861837907 * acos(1 - 2 * gain);
|
|
break;
|
|
case EXP:
|
|
/* -11.5... = 5*ln(0.1) */
|
|
gain = exp(-11.512925464970227 * (1 - gain));
|
|
break;
|
|
case LOG:
|
|
gain = av_clipd(1 + 0.2 * log10(gain), 0, 1.0);
|
|
break;
|
|
case PAR:
|
|
gain = 1 - sqrt(1 - gain);
|
|
break;
|
|
case IPAR:
|
|
gain = (1 - (1 - gain) * (1 - gain));
|
|
break;
|
|
case QUA:
|
|
gain *= gain;
|
|
break;
|
|
case CUB:
|
|
gain = CUBE(gain);
|
|
break;
|
|
case SQU:
|
|
gain = sqrt(gain);
|
|
break;
|
|
case CBR:
|
|
gain = cbrt(gain);
|
|
break;
|
|
case DESE:
|
|
gain = gain <= 0.5 ? cbrt(2 * gain) / 2: 1 - cbrt(2 * (1 - gain)) / 2;
|
|
break;
|
|
case DESI:
|
|
gain = gain <= 0.5 ? CUBE(2 * gain) / 2: 1 - CUBE(2 * (1 - gain)) / 2;
|
|
break;
|
|
case LOSI: {
|
|
const double a = 1. / (1. - 0.787) - 1;
|
|
double A = 1. / (1.0 + exp(0 -((gain-0.5) * a * 2.0)));
|
|
double B = 1. / (1.0 + exp(a));
|
|
double C = 1. / (1.0 + exp(0-a));
|
|
gain = (A - B) / (C - B);
|
|
}
|
|
break;
|
|
case SINC:
|
|
gain = gain >= 1.0 ? 1.0 : sin(M_PI * (1.0 - gain)) / (M_PI * (1.0 - gain));
|
|
break;
|
|
case ISINC:
|
|
gain = gain <= 0.0 ? 0.0 : 1.0 - sin(M_PI * gain) / (M_PI * gain);
|
|
break;
|
|
case NONE:
|
|
gain = 1.0;
|
|
break;
|
|
}
|
|
|
|
return gain;
|
|
}
|
|
|
|
#define FADE(name, type) \
|
|
static void fade_samples_## name (uint8_t **dst, uint8_t * const *src, \
|
|
int nb_samples, int channels, int dir, \
|
|
int64_t start, int64_t range, int curve) \
|
|
{ \
|
|
type *d = (type *)dst[0]; \
|
|
const type *s = (type *)src[0]; \
|
|
int i, c, k = 0; \
|
|
\
|
|
for (i = 0; i < nb_samples; i++) { \
|
|
double gain = fade_gain(curve, start + i * dir, range); \
|
|
for (c = 0; c < channels; c++, k++) \
|
|
d[k] = s[k] * gain; \
|
|
} \
|
|
}
|
|
|
|
FADE(dbl, double)
|
|
FADE(flt, float)
|
|
FADE(s16, int16_t)
|
|
FADE(s32, int32_t)
|
|
|
|
static int add_to_epoll(int epoll_fd, int fd)
|
|
{
|
|
int result;
|
|
struct epoll_event eventItem;
|
|
|
|
memset(&eventItem, 0, sizeof(eventItem));
|
|
eventItem.events = EPOLLIN;
|
|
eventItem.data.fd = fd;
|
|
result = epoll_ctl(epoll_fd, EPOLL_CTL_ADD, fd, &eventItem);
|
|
|
|
return result;
|
|
}
|
|
|
|
static void remove_from_epoll(int epoll_fd, int fd)
|
|
{
|
|
epoll_ctl(epoll_fd, EPOLL_CTL_DEL, fd, NULL);
|
|
}
|
|
|
|
static int get_name_from_fd(int fd, char **name)
|
|
{
|
|
int i;
|
|
|
|
for(i = 0; i < ARRAY_LENGTH; i++)
|
|
{
|
|
if(fd == g_file_name_fd_desc[i].fd)
|
|
{
|
|
*name = g_file_name_fd_desc[i].name;
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
static int inotify_ctl_info(int inotify_fd, int epoll_fd)
|
|
{
|
|
char event_buf[EPOLL_SIZE];
|
|
int event_pos = 0;
|
|
int event_size;
|
|
struct inotify_event *event;
|
|
int result;
|
|
int tmp_fd;
|
|
int i;
|
|
|
|
memset(event_buf, 0, EPOLL_SIZE);
|
|
result = read(inotify_fd, event_buf, sizeof(event_buf));
|
|
if(result < (int)sizeof(*event)) {
|
|
printf("could not get event!\n");
|
|
return -1;
|
|
}
|
|
|
|
while (result >= (int)sizeof(*event))
|
|
{
|
|
event = (struct inotify_event *)(event_buf + event_pos);
|
|
if (event->len)
|
|
{
|
|
if (event->mask & IN_CREATE)
|
|
{
|
|
sprintf(g_file_name_fd_desc[array_index].name, "%s", event->name);
|
|
sprintf(g_file_name_fd_desc[array_index].base_name, "%s/%s", base_dir, event->name);
|
|
|
|
tmp_fd = open(g_file_name_fd_desc[array_index].base_name, O_RDWR);
|
|
if(-1 == tmp_fd)
|
|
{
|
|
printf("inotify_ctl_info open error!\n");
|
|
return -1;
|
|
}
|
|
add_to_epoll(epoll_fd, tmp_fd);
|
|
|
|
g_file_name_fd_desc[array_index].fd = tmp_fd;
|
|
if(ARRAY_LENGTH == array_index)
|
|
{
|
|
array_index = 0;
|
|
}
|
|
array_index += 1;
|
|
|
|
printf("add file to epoll: %s\n", event->name);
|
|
}
|
|
else if (event->mask & IN_DELETE)
|
|
{
|
|
for(i = 0; i < ARRAY_LENGTH; i++)
|
|
{
|
|
if(!strcmp(g_file_name_fd_desc[i].name, event->name))
|
|
{
|
|
remove_from_epoll(epoll_fd, g_file_name_fd_desc[i].fd);
|
|
|
|
g_file_name_fd_desc[i].fd = 0;
|
|
memset(g_file_name_fd_desc[i].name, 0, sizeof(g_file_name_fd_desc[i].name));
|
|
memset(g_file_name_fd_desc[i].base_name, 0, sizeof(g_file_name_fd_desc[i].base_name));
|
|
|
|
printf("remove file from epoll: %s\n", event->name);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else if (event->mask & IN_MODIFY)
|
|
{
|
|
printf("modify file to epoll: %s and will suspend, power_state: %d\n",
|
|
event->name, power_state);
|
|
|
|
if (power_state == POWER_STATE_RESUME)
|
|
power_state = POWER_STATE_SUSPENDING;
|
|
else
|
|
power_state = POWER_STATE_RESUME;
|
|
}
|
|
}
|
|
|
|
event_size = sizeof(*event) + event->len;
|
|
result -= event_size;
|
|
event_pos += event_size;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void *power_status_listen(void *arg)
|
|
{
|
|
int inotify_fd;
|
|
int epoll_fd;
|
|
int result;
|
|
int i;
|
|
|
|
char readbuf[EPOLL_SIZE];
|
|
int readlen;
|
|
|
|
char *tmp_name;
|
|
|
|
return NULL;
|
|
|
|
eq_info("[EQ] %s enter\n", __func__);
|
|
|
|
epoll_fd = epoll_create(1);
|
|
if(-1 == epoll_fd)
|
|
{
|
|
printf("epoll_create error!\n");
|
|
goto err;
|
|
}
|
|
|
|
inotify_fd = inotify_init();
|
|
|
|
result = inotify_add_watch(inotify_fd, base_dir, IN_MODIFY);
|
|
if(-1 == result)
|
|
{
|
|
printf("inotify_add_watch error!\n");
|
|
goto err;
|
|
}
|
|
|
|
add_to_epoll(epoll_fd, inotify_fd);
|
|
|
|
eq_info("[EQ] %s, %d add_to_epoll\n", __func__, __LINE__);
|
|
|
|
while (1)
|
|
{
|
|
result = epoll_wait(epoll_fd, g_PendingEventItems, EPOLL_MAX_EVENTS, -1);
|
|
if (-1 == result)
|
|
{
|
|
printf("epoll wait error!\n");
|
|
goto err;
|
|
}
|
|
else
|
|
{
|
|
for (i = 0; i < result; i++)
|
|
{
|
|
if (g_PendingEventItems[i].data.fd == inotify_fd)
|
|
{
|
|
if (-1 == inotify_ctl_info(inotify_fd, epoll_fd))
|
|
{
|
|
printf("inotify_ctl_info error!\n");
|
|
goto err;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (!get_name_from_fd(g_PendingEventItems[i].data.fd, &tmp_name))
|
|
{
|
|
readlen = read(g_PendingEventItems[i].data.fd, readbuf, EPOLL_SIZE);
|
|
readbuf[readlen] = '\0';
|
|
printf("read data from %s : %s\n", tmp_name, readbuf);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
err:
|
|
eq_info("[EQ] %s exit\n", __func__);
|
|
return NULL;
|
|
}
|
|
|
|
void alsa_fake_device_record_open(snd_pcm_t** capture_handle,int channels,uint32_t rate)
|
|
{
|
|
snd_pcm_hw_params_t *hw_params;
|
|
snd_pcm_uframes_t periodSize = g_period_size;
|
|
snd_pcm_uframes_t bufferSize = g_buffer_size;
|
|
int dir = 0;
|
|
int err;
|
|
|
|
err = snd_pcm_open(capture_handle, REC_DEVICE_NAME, SND_PCM_STREAM_CAPTURE, 0);
|
|
if (err)
|
|
{
|
|
eq_err("[EQ_RECORD_OPEN] Unable to open capture PCM device\n");
|
|
exit(1);
|
|
}
|
|
eq_debug("[EQ_RECORD_OPEN] snd_pcm_open\n");
|
|
//err = snd_pcm_hw_params_alloca(&hw_params);
|
|
|
|
err = snd_pcm_hw_params_malloc(&hw_params);
|
|
if(err)
|
|
{
|
|
eq_err("[EQ_RECORD_OPEN] cannot allocate hardware parameter structure (%s)\n", snd_strerror(err));
|
|
exit(1);
|
|
}
|
|
eq_debug("[EQ_RECORD_OPEN] snd_pcm_hw_params_malloc\n");
|
|
|
|
err = snd_pcm_hw_params_any(*capture_handle, hw_params);
|
|
if(err)
|
|
{
|
|
eq_err("[EQ_RECORD_OPEN] cannot initialize hardware parameter structure (%s)\n", snd_strerror(err));
|
|
exit(1);
|
|
}
|
|
eq_debug("[EQ_RECORD_OPEN] snd_pcm_hw_params_any!\n");
|
|
|
|
err = snd_pcm_hw_params_set_access(*capture_handle, hw_params, SND_PCM_ACCESS_RW_INTERLEAVED);
|
|
// err = snd_pcm_hw_params_set_access(*capture_handle, hw_params, SND_PCM_ACCESS_MMAP_NONINTERLEAVED);
|
|
if (err)
|
|
{
|
|
eq_err("[EQ_RECORD_OPEN] Error setting interleaved mode\n");
|
|
exit(1);
|
|
}
|
|
eq_debug("[EQ_RECORD_OPEN] snd_pcm_hw_params_set_access!\n");
|
|
|
|
err = snd_pcm_hw_params_set_format(*capture_handle, hw_params, ALSA_READ_FORMAT);
|
|
if (err)
|
|
{
|
|
eq_err("[EQ_RECORD_OPEN] Error setting format: %s\n", snd_strerror(err));
|
|
exit(1);
|
|
}
|
|
eq_debug("[EQ_RECORD_OPEN] snd_pcm_hw_params_set_format\n");
|
|
|
|
err = snd_pcm_hw_params_set_channels(*capture_handle, hw_params, channels);
|
|
if (err)
|
|
{
|
|
eq_debug("[EQ_RECORD_OPEN] channels = %d\n",channels);
|
|
eq_err("[EQ_RECORD_OPEN] Error setting channels: %s\n", snd_strerror(err));
|
|
exit(1);
|
|
}
|
|
eq_debug("[EQ_RECORD_OPEN] channels = %d\n",channels);
|
|
|
|
err = snd_pcm_hw_params_set_buffer_size_near(*capture_handle, hw_params, &bufferSize);
|
|
if (err)
|
|
{
|
|
eq_err("[EQ_RECORD_OPEN] Error setting buffer size (%d): %s\n", bufferSize, snd_strerror(err));
|
|
exit(1);
|
|
}
|
|
eq_debug("[EQ_RECORD_OPEN] bufferSize = %d\n",bufferSize);
|
|
|
|
err = snd_pcm_hw_params_set_period_size_near(*capture_handle, hw_params, &periodSize, 0);
|
|
if (err)
|
|
{
|
|
eq_err("[EQ_RECORD_OPEN] Error setting period time (%d): %s\n", periodSize, snd_strerror(err));
|
|
exit(1);
|
|
}
|
|
eq_debug("[EQ_RECORD_OPEN] periodSize = %d\n",periodSize);
|
|
|
|
err = snd_pcm_hw_params_set_rate_near(*capture_handle, hw_params, &rate, 0/*&dir*/);
|
|
if (err)
|
|
{
|
|
eq_err("[EQ_RECORD_OPEN] Error setting sampling rate (%d): %s\n", rate, snd_strerror(err));
|
|
exit(1);
|
|
}
|
|
eq_debug("[EQ_RECORD_OPEN] Rate = %d\n", rate);
|
|
|
|
/* Write the parameters to the driver */
|
|
err = snd_pcm_hw_params(*capture_handle, hw_params);
|
|
if (err < 0)
|
|
{
|
|
eq_err("[EQ_RECORD_OPEN] Unable to set HW parameters: %s\n", snd_strerror(err));
|
|
exit(1);
|
|
}
|
|
|
|
eq_debug("[EQ_RECORD_OPEN] Open record device done \n");
|
|
//if(set_sw_params(*capture_handle,bufferSize,periodSize,NULL) < 0)
|
|
// exit(1);
|
|
|
|
if(hw_params)
|
|
snd_pcm_hw_params_free(hw_params);
|
|
}
|
|
|
|
int alsa_fake_device_write_open(snd_pcm_t** write_handle, int channels,
|
|
uint32_t write_sampleRate, int device_flag,
|
|
int *socket_fd)
|
|
{
|
|
snd_pcm_hw_params_t *write_params;
|
|
snd_pcm_uframes_t write_periodSize = g_period_size;
|
|
snd_pcm_uframes_t write_bufferSize = g_buffer_size;
|
|
int write_err;
|
|
int write_dir;
|
|
char bluealsa_device[256] = {0};
|
|
|
|
if (device_flag == DEVICE_FLAG_ANALOG_HP) {
|
|
eq_debug("[EQ_WRITE_OPEN] Open PCM: %s\n", JACK_DEVICE_NAME);
|
|
write_err = snd_pcm_open(write_handle, JACK_DEVICE_NAME,
|
|
SND_PCM_STREAM_PLAYBACK, 0);
|
|
} else if (device_flag == DEVICE_FLAG_DIGITAL_HP) {
|
|
eq_debug("[EQ_WRITE_OPEN] Open PCM: %s\n", JACK2_DEVICE_NAME);
|
|
write_err = snd_pcm_open(write_handle, JACK2_DEVICE_NAME,
|
|
SND_PCM_STREAM_PLAYBACK, 0);
|
|
} else if (device_flag == DEVICE_FLAG_BLUETOOTH) {
|
|
sprintf(bluealsa_device, "%s%s", "bluealsa:HCI=hci0,PROFILE=a2dp,DEV=",
|
|
g_bt_mac_addr);
|
|
eq_debug("[EQ_WRITE_OPEN] Open PCM: %s\n", bluealsa_device);
|
|
write_err = snd_pcm_open(write_handle, bluealsa_device,
|
|
SND_PCM_STREAM_PLAYBACK, 0);
|
|
} else if (device_flag == DEVICE_FLAG_BLUETOOTH_BSA) {
|
|
*socket_fd = RK_socket_client_setup(sock_path);
|
|
if (*socket_fd < 0) {
|
|
eq_err("[EQ_WRITE_OPEN] Fail to connect server socket\n");
|
|
return -1;
|
|
} else {
|
|
eq_debug("[EQ_WRITE_OPEN] Socket client connected\n");
|
|
return 0;
|
|
}
|
|
} else {
|
|
eq_debug("[EQ_WRITE_OPEN] Open PCM: %s\n", WRITE_DEVICE_NAME);
|
|
write_err = snd_pcm_open(write_handle, WRITE_DEVICE_NAME,
|
|
SND_PCM_STREAM_PLAYBACK, 0);
|
|
}
|
|
|
|
if (write_err) {
|
|
eq_err("[EQ_WRITE_OPEN] Unable to open playback PCM device: %d\n", write_err);
|
|
return write_err;
|
|
}
|
|
eq_debug("[EQ_WRITE_OPEN] interleaved mode\n");
|
|
|
|
// snd_pcm_hw_params_alloca(&write_params);
|
|
snd_pcm_hw_params_malloc(&write_params);
|
|
eq_debug("[EQ_WRITE_OPEN] snd_pcm_hw_params_alloca\n");
|
|
|
|
snd_pcm_hw_params_any(*write_handle, write_params);
|
|
|
|
write_err = snd_pcm_hw_params_set_access(*write_handle, write_params, SND_PCM_ACCESS_RW_INTERLEAVED);
|
|
//write_err = snd_pcm_hw_params_set_access(*write_handle, write_params, SND_PCM_ACCESS_MMAP_NONINTERLEAVED);
|
|
if (write_err) {
|
|
eq_err("[EQ_WRITE_OPEN] Error setting interleaved mode\n");
|
|
goto failed;
|
|
}
|
|
eq_debug( "[EQ_WRITE_OPEN] interleaved mode\n");
|
|
|
|
write_err = snd_pcm_hw_params_set_format(*write_handle, write_params, ALSA_WRITE_FORMAT);
|
|
if (write_err) {
|
|
eq_err("[EQ_WRITE_OPEN] Error setting format: %s\n", snd_strerror(write_err));
|
|
goto failed;
|
|
}
|
|
eq_debug("[EQ_WRITE_OPEN] format successed\n");
|
|
|
|
write_err = snd_pcm_hw_params_set_channels(*write_handle, write_params, channels);
|
|
if (write_err) {
|
|
eq_err( "[EQ_WRITE_OPEN] Error setting channels: %s\n", snd_strerror(write_err));
|
|
goto failed;
|
|
}
|
|
eq_debug("[EQ_WRITE_OPEN] channels = %d\n", channels);
|
|
|
|
write_err = snd_pcm_hw_params_set_rate_near(*write_handle, write_params, &write_sampleRate, 0/*&write_dir*/);
|
|
if (write_err) {
|
|
eq_err("[EQ_WRITE_OPEN] Error setting sampling rate (%d): %s\n", write_sampleRate, snd_strerror(write_err));
|
|
goto failed;
|
|
}
|
|
eq_debug("[EQ_WRITE_OPEN] setting sampling rate (%d)\n", write_sampleRate);
|
|
|
|
write_err = snd_pcm_hw_params_set_buffer_size_near(*write_handle, write_params, &write_bufferSize);
|
|
if (write_err) {
|
|
eq_err("[EQ_WRITE_OPEN] Error setting buffer size (%ld): %s\n", write_bufferSize, snd_strerror(write_err));
|
|
goto failed;
|
|
}
|
|
eq_debug("[EQ_WRITE_OPEN] write_bufferSize = %d\n", write_bufferSize);
|
|
|
|
write_err = snd_pcm_hw_params_set_period_size_near(*write_handle, write_params, &write_periodSize, 0);
|
|
if (write_err) {
|
|
eq_err("[EQ_WRITE_OPEN] Error setting period time (%ld): %s\n", write_periodSize, snd_strerror(write_err));
|
|
goto failed;
|
|
}
|
|
eq_debug("[EQ_WRITE_OPEN] write_periodSize = %d\n", write_periodSize);
|
|
|
|
#if 0
|
|
snd_pcm_uframes_t write_final_buffer;
|
|
write_err = snd_pcm_hw_params_get_buffer_size(write_params, &write_final_buffer);
|
|
eq_debug(" final buffer size %ld \n" , write_final_buffer);
|
|
|
|
snd_pcm_uframes_t write_final_period;
|
|
write_err = snd_pcm_hw_params_get_period_size(write_params, &write_final_period, &write_dir);
|
|
eq_debug(" final period size %ld \n" , write_final_period);
|
|
#endif
|
|
|
|
{
|
|
int monotonic, can_pause;
|
|
|
|
monotonic = snd_pcm_hw_params_is_monotonic(write_params);
|
|
can_pause = snd_pcm_hw_params_can_pause(write_params);
|
|
|
|
eq_info("[EQ_INFO] monotonic: %d, can_pause: %d\n", monotonic, can_pause);
|
|
}
|
|
|
|
/* Write the parameters to the driver */
|
|
write_err = snd_pcm_hw_params(*write_handle, write_params);
|
|
if (write_err < 0) {
|
|
eq_err("[EQ_WRITE_OPEN] Unable to set HW parameters: %s\n", snd_strerror(write_err));
|
|
goto failed;
|
|
}
|
|
|
|
eq_debug("[EQ_WRITE_OPEN] open write device is successful\n");
|
|
if(set_sw_params(*write_handle, write_bufferSize, write_periodSize, NULL) < 0)
|
|
goto failed;
|
|
|
|
if(write_params)
|
|
snd_pcm_hw_params_free(write_params);
|
|
|
|
#if KEEPING_HW_CARD
|
|
if (device_flag == DEVICE_FLAG_LINE_OUT)
|
|
g_fast_codec = true;
|
|
#endif
|
|
return 0;
|
|
|
|
failed:
|
|
if(write_params)
|
|
snd_pcm_hw_params_free(write_params);
|
|
|
|
snd_pcm_close(*write_handle);
|
|
*write_handle = NULL;
|
|
|
|
return -1;
|
|
}
|
|
|
|
int set_sw_params(snd_pcm_t *pcm, snd_pcm_uframes_t buffer_size,
|
|
snd_pcm_uframes_t period_size, char **msg) {
|
|
|
|
snd_pcm_sw_params_t *params;
|
|
snd_pcm_uframes_t threshold;
|
|
char buf[256];
|
|
int err;
|
|
|
|
//snd_pcm_sw_params_alloca(¶ms);
|
|
snd_pcm_sw_params_malloc(¶ms);
|
|
if ((err = snd_pcm_sw_params_current(pcm, params)) != 0) {
|
|
eq_err("[EQ_SET_SW_PARAMS] Get current params: %s\n", snd_strerror(err));
|
|
goto failed;
|
|
}
|
|
|
|
/* start the transfer when the buffer is full (or almost full) */
|
|
threshold = (buffer_size / period_size) * period_size;
|
|
if ((err = snd_pcm_sw_params_set_start_threshold(pcm, params, threshold)) != 0) {
|
|
eq_err("[EQ_SET_SW_PARAMS] Set start threshold: %s: %lu\n", snd_strerror(err), threshold);
|
|
goto failed;
|
|
}
|
|
|
|
/* 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) {
|
|
eq_err("[EQ_SET_SW_PARAMS] Set avail min: %s: %lu\n", snd_strerror(err), period_size);
|
|
goto failed;
|
|
}
|
|
|
|
if ((err = snd_pcm_sw_params(pcm, params)) != 0) {
|
|
eq_err("[EQ_SET_SW_PARAMS] %s\n", snd_strerror(err));
|
|
goto failed;
|
|
}
|
|
|
|
if(params)
|
|
snd_pcm_sw_params_free(params);
|
|
|
|
return 0;
|
|
|
|
failed:
|
|
if(params)
|
|
snd_pcm_sw_params_free(params);
|
|
|
|
return -1;
|
|
}
|
|
|
|
static int is_mute_frame(short *in,unsigned int size)
|
|
{
|
|
int i;
|
|
int mute_count = 0;
|
|
|
|
if (!size) {
|
|
eq_err("frame size is zero!!!\n");
|
|
return 0;
|
|
}
|
|
for (i = 0; i < size;i ++) {
|
|
if(in[i] != 0)
|
|
return 0;
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
/* Determine whether to enter the energy saving mode according to
|
|
* the value of the environment variable "EQ_LOW_POWERMODE"
|
|
*/
|
|
bool low_power_mode_check()
|
|
{
|
|
char *value = NULL;
|
|
|
|
/* env: "EQ_LOW_POWERMODE=TRUE" or "EQ_LOW_POWERMODE=true" ? */
|
|
value = getenv("EQ_LOW_POWERMODE");
|
|
if (value && (!strcmp("TRUE", value) || !strcmp("true", value)))
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
/* Check device changing. */
|
|
int get_device_flag()
|
|
{
|
|
int fd = 0, ret = 0;
|
|
char buff[512] = {0};
|
|
int device_flag = DEVICE_FLAG_LINE_OUT;
|
|
#if (ROCKCHIP_SOC == SOC_IS_RK3308)
|
|
const char *path = "/sys/devices/platform/ff560000.acodec/rk3308-acodec-dev/dac_output";
|
|
#else /* else is RK3326 */
|
|
const char *path = "/sys/class/switch/h2w/state";
|
|
#endif
|
|
FILE *pp = NULL; /* pipeline */
|
|
char *bt_mac_addr = NULL;
|
|
|
|
if (g_bt_is_connect == BT_CONNECT_BLUEZ)
|
|
return DEVICE_FLAG_BLUETOOTH;
|
|
else if(g_bt_is_connect == BT_CONNECT_BSA)
|
|
return DEVICE_FLAG_BLUETOOTH_BSA;
|
|
|
|
fd = open(path, O_RDONLY);
|
|
if (fd < 0) {
|
|
eq_err("[EQ_DEVICE_FLAG] Open %s failed!\n", path);
|
|
return device_flag;
|
|
}
|
|
|
|
ret = read(fd, buff, sizeof(buff));
|
|
if (ret <= 0) {
|
|
eq_err("[EQ_DEVICE_FLAG] Read %s failed!\n", path);
|
|
close(fd);
|
|
return device_flag;
|
|
}
|
|
|
|
#if (ROCKCHIP_SOC == SOC_IS_RK3308)
|
|
if (strstr(buff, "hp out"))
|
|
device_flag = DEVICE_FLAG_ANALOG_HP;
|
|
#else /* else is RK3326 */
|
|
if (strstr(buff, "1"))
|
|
device_flag = DEVICE_FLAG_ANALOG_HP;
|
|
else if (strstr(buff, "2"))
|
|
device_flag = DEVICE_FLAG_DIGITAL_HP;
|
|
#endif
|
|
|
|
close(fd);
|
|
|
|
return device_flag;
|
|
}
|
|
|
|
/* Get device name frome device_flag */
|
|
const char *get_device_name(int device_flag)
|
|
{
|
|
const char *device_name = NULL;
|
|
|
|
switch (device_flag) {
|
|
case DEVICE_FLAG_BLUETOOTH:
|
|
case DEVICE_FLAG_BLUETOOTH_BSA:
|
|
device_name = "BLUETOOTH";
|
|
break;
|
|
case DEVICE_FLAG_ANALOG_HP:
|
|
device_name = JACK_DEVICE_NAME;
|
|
break;
|
|
case DEVICE_FLAG_DIGITAL_HP:
|
|
device_name = JACK2_DEVICE_NAME;
|
|
break;
|
|
case DEVICE_FLAG_LINE_OUT:
|
|
device_name = WRITE_DEVICE_NAME;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return device_name;
|
|
}
|
|
|
|
static void user_play_inotify_handler(struct inotify_event *event)
|
|
{
|
|
// eq_info("[EQ] %s enter\n", __func__);
|
|
// eq_info("[EQ] event->mask: 0x%08x\n", event->mask);
|
|
// eq_info("[EQ] event->name: %s\n", event->name);
|
|
|
|
switch (event->mask)
|
|
{
|
|
case IN_OPEN:
|
|
user_play_state = USER_PLAY_OPENED;
|
|
eq_info("[EQ] %s USER_PLAY_OPENED\n", __func__);
|
|
break;
|
|
case IN_CLOSE_WRITE:
|
|
user_play_state = USER_PLAY_CLOSING;
|
|
eq_info("[EQ] %s USER_PLAY_CLOSING\n", __func__);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void user_capt_inotify_handler(struct inotify_event *event)
|
|
{
|
|
// eq_info("[EQ] %s enter\n", __func__);
|
|
// eq_info("[EQ] event->mask: 0x%08x\n", event->mask);
|
|
// eq_info("[EQ] event->name: %s\n", event->name);
|
|
|
|
switch (event->mask)
|
|
{
|
|
case IN_OPEN:
|
|
user_capt_state = USER_CAPT_OPENED;
|
|
eq_info("[EQ] %s USER_CAPT_OPENED\n", __func__);
|
|
break;
|
|
case IN_CLOSE_WRITE:
|
|
user_capt_state = USER_CAPT_CLOSING;
|
|
eq_info("[EQ] %s USER_CAPT_CLOSING\n", __func__);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void *user_play_status_listen(void *arg)
|
|
{
|
|
struct user_play_inotify *upi = &g_upi;
|
|
struct inotify_event *event = NULL;
|
|
FILE *fp;
|
|
char *buf;
|
|
|
|
eq_info("[EQ] %s enter\n", __func__);
|
|
|
|
buf = (char *)calloc(1024, 1);
|
|
if (!buf) {
|
|
eq_err("[EQ] %s alloc buf failed!\n", __func__);
|
|
return NULL;
|
|
}
|
|
|
|
upi->stop = 0;
|
|
upi->fd = inotify_init();
|
|
|
|
upi->watch_desc = inotify_add_watch(upi->fd, USER_PLAY_STATUS, IN_OPEN | IN_CLOSE_WRITE);
|
|
while (!upi->stop)
|
|
{
|
|
fd_set fds;
|
|
FD_ZERO(&fds);
|
|
FD_SET(upi->fd, &fds);
|
|
|
|
if (select(upi->fd + 1, &fds, NULL, NULL, NULL) > 0)
|
|
{
|
|
int len, index = 0;
|
|
while (((len = read(upi->fd, buf, 1024)) < 0) && (errno == EINTR));
|
|
while (index < len)
|
|
{
|
|
event = (struct inotify_event *)(buf + index);
|
|
user_play_inotify_handler(event);
|
|
index += sizeof(struct inotify_event) + event->len;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (upi->fd >= 0) {
|
|
inotify_rm_watch(upi->fd, upi->watch_desc);
|
|
close(upi->fd);
|
|
upi->fd = -1;
|
|
}
|
|
|
|
if (buf)
|
|
free(buf);
|
|
|
|
eq_info("[EQ] %s exit\n", __func__);
|
|
|
|
return NULL;
|
|
|
|
err_out:
|
|
if (buf)
|
|
free(buf);
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static void *user_capt_status_listen(void *arg)
|
|
{
|
|
struct user_capt_inotify *uci = &g_uci;
|
|
struct inotify_event *event = NULL;
|
|
FILE *fp;
|
|
char *buf;
|
|
|
|
eq_info("[EQ] %s enter\n", __func__);
|
|
|
|
buf = (char *)calloc(1024, 1);
|
|
if (!buf) {
|
|
eq_err("[EQ] %s alloc buf failed!\n", __func__);
|
|
return NULL;
|
|
}
|
|
|
|
uci->stop = 0;
|
|
uci->fd = inotify_init();
|
|
|
|
uci->watch_desc = inotify_add_watch(uci->fd, USER_CAPT_STATUS, IN_OPEN | IN_CLOSE_WRITE);
|
|
while (!uci->stop)
|
|
{
|
|
fd_set fds;
|
|
FD_ZERO(&fds);
|
|
FD_SET(uci->fd, &fds);
|
|
|
|
if (select(uci->fd + 1, &fds, NULL, NULL, NULL) > 0)
|
|
{
|
|
int len, index = 0;
|
|
while (((len = read(uci->fd, buf, 1024)) < 0) && (errno == EINTR));
|
|
while (index < len)
|
|
{
|
|
event = (struct inotify_event *)(buf + index);
|
|
user_capt_inotify_handler(event);
|
|
index += sizeof(struct inotify_event) + event->len;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (uci->fd >= 0) {
|
|
inotify_rm_watch(uci->fd, uci->watch_desc);
|
|
close(uci->fd);
|
|
uci->fd = -1;
|
|
}
|
|
|
|
if (buf)
|
|
free(buf);
|
|
|
|
eq_info("[EQ] %s exit\n", __func__);
|
|
|
|
return NULL;
|
|
|
|
err_out:
|
|
if (buf)
|
|
free(buf);
|
|
|
|
return NULL;
|
|
}
|
|
|
|
void *a2dp_status_listen(void *arg)
|
|
{
|
|
int ret = 0;
|
|
char buff[100] = {0};
|
|
struct sockaddr_un clientAddr;
|
|
struct sockaddr_un serverAddr;
|
|
int sockfd;
|
|
socklen_t addr_len;
|
|
char *start = NULL;
|
|
snd_pcm_t* audio_bt_handle;
|
|
char bluealsa_device[256] = {0};
|
|
int retry_cnt = 5;
|
|
|
|
sockfd = socket(AF_UNIX, SOCK_DGRAM, 0);
|
|
if (sockfd < 0) {
|
|
eq_err("[EQ_A2DP_LISTEN] Create socket failed!\n");
|
|
return NULL;
|
|
}
|
|
|
|
serverAddr.sun_family = AF_UNIX;
|
|
strcpy(serverAddr.sun_path, "/tmp/a2dp_master_status");
|
|
|
|
system("rm -rf /tmp/a2dp_master_status");
|
|
ret = bind(sockfd, (struct sockaddr *)&serverAddr, sizeof(serverAddr));
|
|
if (ret < 0) {
|
|
eq_err("[EQ_A2DP_LISTEN] Bind Local addr failed!\n");
|
|
return NULL;
|
|
}
|
|
|
|
while(1) {
|
|
addr_len = sizeof(clientAddr);
|
|
memset(buff, 0, sizeof(buff));
|
|
ret = recvfrom(sockfd, buff, sizeof(buff), 0, (struct sockaddr *)&clientAddr, &addr_len);
|
|
if (ret <= 0) {
|
|
eq_err("[EQ_A2DP_LISTEN]: %s\n", strerror(errno));
|
|
break;
|
|
}
|
|
eq_debug("[EQ_A2DP_LISTEN] Received a message(%s)\n", buff);
|
|
|
|
if (strstr(buff, "status:connect:bsa-source")) {
|
|
if (g_bt_is_connect == BT_DISCONNECT) {
|
|
eq_debug("[EQ_A2DP_LISTEN] bsa bluetooth source is connect\n");
|
|
g_bt_is_connect = BT_CONNECT_BSA;
|
|
}
|
|
} else if (strstr(buff, "status:connect")) {
|
|
start = strstr(buff, "address:");
|
|
if (start == NULL) {
|
|
eq_debug("[EQ_A2DP_LISTEN] Received a malformed connect message(%s)\n", buff);
|
|
continue;
|
|
}
|
|
start += strlen("address:");
|
|
if (g_bt_is_connect == BT_DISCONNECT) {
|
|
//sleep(2);
|
|
memcpy(g_bt_mac_addr, start, sizeof(g_bt_mac_addr));
|
|
sprintf(bluealsa_device, "%s%s", "bluealsa:HCI=hci0,PROFILE=a2dp,DEV=",
|
|
g_bt_mac_addr);
|
|
retry_cnt = 5;
|
|
while (retry_cnt--) {
|
|
eq_debug("[EQ_A2DP_LISTEN] try open bluealsa device(%d)\n", retry_cnt + 1);
|
|
ret = snd_pcm_open(&audio_bt_handle, bluealsa_device,
|
|
SND_PCM_STREAM_PLAYBACK, 0);
|
|
if (ret == 0) {
|
|
snd_pcm_close(audio_bt_handle);
|
|
g_bt_is_connect = BT_CONNECT_BLUEZ;
|
|
break;
|
|
}
|
|
usleep(600000); //600ms * 5 = 3s.
|
|
}
|
|
}
|
|
} else if (strstr(buff, "status:disconnect")) {
|
|
g_bt_is_connect = BT_DISCONNECT;
|
|
} else if (strstr(buff, "status:suspend")) {
|
|
g_system_sleep = true;
|
|
} else if (strstr(buff, "status:resume")) {
|
|
g_system_sleep = false;
|
|
} else {
|
|
eq_debug("[EQ_A2DP_LISTEN] Received a malformed message(%s)\n", buff);
|
|
}
|
|
}
|
|
|
|
close(sockfd);
|
|
return NULL;
|
|
}
|
|
|
|
static void sigpipe_handler(int sig)
|
|
{
|
|
eq_info("[EQ] catch the signal number: %d\n", sig);
|
|
}
|
|
|
|
static int signal_handler()
|
|
{
|
|
struct sigaction sa;
|
|
|
|
/* Install signal handler for SIGPIPE */
|
|
memset(&sa, 0, sizeof(sa));
|
|
sa.sa_handler = sigpipe_handler;
|
|
sigemptyset(&sa.sa_mask);
|
|
sa.sa_flags = 0;
|
|
|
|
if (sigaction(SIGPIPE, &sa, NULL) < 0) {
|
|
eq_err("sigaction() failed: %s", strerror(errno));
|
|
return -1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
#if 1
|
|
/* I/O error handler */
|
|
static int eq_drc_xrun(snd_pcm_t *handle, snd_pcm_stream_t stream)
|
|
{
|
|
snd_pcm_status_t *status;
|
|
snd_output_t *log;
|
|
int fatal_errors = 0, monotonic = 1, verbose = 1;
|
|
int res;
|
|
|
|
eq_err("[EQ] %s %d enter\n", __func__, __LINE__);
|
|
|
|
snd_output_stdio_attach(&log, stderr, 0);
|
|
|
|
snd_pcm_status_alloca(&status);
|
|
if ((res = snd_pcm_status(handle, status))<0) {
|
|
eq_err("[EQ] status error: %s\n", snd_strerror(res));
|
|
// prg_exit(EXIT_FAILURE);
|
|
}
|
|
if (snd_pcm_status_get_state(status) == SND_PCM_STATE_XRUN) {
|
|
if (fatal_errors) {
|
|
eq_err("[EQ] fatal %s: %s\n",
|
|
stream == SND_PCM_STREAM_PLAYBACK ? "underrun" : "overrun",
|
|
snd_strerror(res));
|
|
// prg_exit(EXIT_FAILURE);
|
|
}
|
|
if (monotonic) {
|
|
#ifdef HAVE_CLOCK_GETTIME
|
|
struct timespec now, diff, tstamp;
|
|
clock_gettime(CLOCK_MONOTONIC, &now);
|
|
snd_pcm_status_get_trigger_htstamp(status, &tstamp);
|
|
timermsub(&now, &tstamp, &diff);
|
|
fprintf(stderr, "%s!!! (at least %.3f ms long)\n",
|
|
stream == SND_PCM_STREAM_PLAYBACK ? "underrun" : "overrun",
|
|
diff.tv_sec * 1000 + diff.tv_nsec / 1000000.0);
|
|
#else
|
|
fprintf(stderr, "%s !!!\n", "underrun");
|
|
#endif
|
|
} else {
|
|
struct timeval now, diff, tstamp;
|
|
gettimeofday(&now, 0);
|
|
snd_pcm_status_get_trigger_tstamp(status, &tstamp);
|
|
timersub(&now, &tstamp, &diff);
|
|
fprintf(stderr, "%s!!! (at least %.3f ms long)\n",
|
|
stream == SND_PCM_STREAM_PLAYBACK ? "underrun" : "overrun",
|
|
diff.tv_sec * 1000 + diff.tv_usec / 1000.0);
|
|
}
|
|
if (verbose) {
|
|
fprintf(stderr, "Status:\n");
|
|
snd_pcm_status_dump(status, log);
|
|
}
|
|
if ((res = snd_pcm_prepare(handle))<0) {
|
|
eq_err("[EQ] xrun: prepare error: %s\n", snd_strerror(res));
|
|
// prg_exit(EXIT_FAILURE);
|
|
}
|
|
goto out_xrun; /* ok, data should be accepted again */
|
|
} if (snd_pcm_status_get_state(status) == SND_PCM_STATE_DRAINING) {
|
|
if (verbose) {
|
|
fprintf(stderr, "Status(DRAINING):\n");
|
|
snd_pcm_status_dump(status, log);
|
|
}
|
|
if (stream == SND_PCM_STREAM_CAPTURE) {
|
|
fprintf(stderr, "capture stream format change? attempting recover...\n");
|
|
if ((res = snd_pcm_prepare(handle))<0) {
|
|
eq_err("[EQ] xrun(DRAINING): prepare error: %s\n", snd_strerror(res));
|
|
// prg_exit(EXIT_FAILURE);
|
|
}
|
|
goto out_xrun;
|
|
}
|
|
}
|
|
if (verbose) {
|
|
fprintf(stderr, "Status(R/W):\n");
|
|
snd_pcm_status_dump(status, log);
|
|
}
|
|
eq_err("[EQ] read/write error, state = %s\n", snd_pcm_state_name(snd_pcm_status_get_state(status)));
|
|
// prg_exit(EXIT_FAILURE);
|
|
|
|
out_xrun:
|
|
snd_output_close(log);
|
|
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
static void usage(char *command)
|
|
{
|
|
snd_pcm_format_t k;
|
|
printf(
|
|
"Usage: %s [OPTION]...\n"
|
|
"\n"
|
|
"-h, --help help\n"
|
|
"-v --version print current version\n"
|
|
"-s, --seconds close sound card after playback is stopped seconds (default: 3s)\n"
|
|
"-p, --period-size specify the size of the frame period (default: 1920)\n"
|
|
"-n, --period-counts specify the count of the frame periods (default: 8)\n"
|
|
#if KEEPING_HW_CARD
|
|
"-P, --path-name specify the name of playback path for RK817/RK809 codec (default: SPK)\n"
|
|
#endif
|
|
,
|
|
command);
|
|
}
|
|
|
|
static long parse_long(const char *str, int *err)
|
|
{
|
|
long val;
|
|
char *endptr;
|
|
|
|
errno = 0;
|
|
val = strtol(str, &endptr, 0);
|
|
|
|
if (errno != 0 || *endptr != '\0')
|
|
*err = -1;
|
|
else
|
|
*err = 0;
|
|
|
|
return val;
|
|
}
|
|
|
|
static void get_version(char *command)
|
|
{
|
|
printf("%s: version " EQ_DRC_PROCESS_VERSION " by Rockchip\n", command);
|
|
}
|
|
|
|
int main(int argc, char *argv[])
|
|
{
|
|
int err, c;
|
|
snd_pcm_t *capture_handle, *write_handle;
|
|
char *buffer;
|
|
unsigned int sampleRate, channels;
|
|
int mute_frame_thd, mute_frame, skip_frame = 0;
|
|
/* LINE_OUT is the default output device */
|
|
int device_flag, new_flag, last_flag;
|
|
pthread_t a2dp_status_listen_thread;
|
|
pthread_t user_play_status_listen_thread;
|
|
// pthread_t user_capt_status_listen_thread;
|
|
// pthread_t power_status_listen_thread;
|
|
// struct rk_wake_lock* wake_lock;
|
|
bool low_power_mode = low_power_mode_check();
|
|
volatile bool need_close_card = false;
|
|
char *silence_data;
|
|
int socket_fd = -1;
|
|
clock_t startProcTime, endProcTime;
|
|
int mute_time = MUTE_TIME_DEFAULT;
|
|
int option_index;
|
|
|
|
static char *command = argv[0];
|
|
static const char short_options[] = "hvs:p:n:P:";
|
|
static const struct option long_options[] = {
|
|
{"help", 0, 0, 'h'},
|
|
{"version", 0, 0, 'v'},
|
|
{"seconds", 1, 0, 's'},
|
|
{"period-size", 1, 0, 'p'},
|
|
{"period-counts", 1, 0, 'n'},
|
|
#if KEEPING_HW_CARD
|
|
{"path-name", 1, 0, 'P'},
|
|
#endif
|
|
{0, 0, 0, 0}
|
|
};
|
|
|
|
#if KEEPING_HW_CARD
|
|
memset(g_path_name, 0, sizeof(g_path_name));
|
|
strcpy(g_path_name, HW_CARD_PATH_DEFAULT);
|
|
#endif
|
|
|
|
while ((c = getopt_long(argc, argv, short_options, long_options, &option_index)) != -1) {
|
|
switch (c) {
|
|
case 'h':
|
|
usage(command);
|
|
return 0;
|
|
case 'v':
|
|
get_version(command);
|
|
return 0;
|
|
case 's':
|
|
mute_time = parse_long(optarg, &err);
|
|
if (err < 0) {
|
|
eq_err("[EQ] invalid mute_time argument '%s'\n", optarg);
|
|
return -1;
|
|
}
|
|
break;
|
|
case 'p':
|
|
g_period_size = parse_long(optarg, &err);
|
|
if (err < 0) {
|
|
eq_err("[EQ] invalid g_period_size argument '%s'\n", optarg);
|
|
return -1;
|
|
}
|
|
g_read_frame = g_period_size;
|
|
break;
|
|
case 'n':
|
|
g_period_counts = parse_long(optarg, &err);
|
|
if (err < 0) {
|
|
eq_err("[EQ] invalid g_period_counts argument '%s'\n", optarg);
|
|
return -1;
|
|
}
|
|
break;
|
|
#if KEEPING_HW_CARD
|
|
case 'P':
|
|
memset(g_path_name, 0, sizeof(g_path_name));
|
|
strcpy(g_path_name, optarg);
|
|
break;
|
|
#endif
|
|
default:
|
|
eq_err("[EQ] Try `%s --help' for more information.\n", command);
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
if (g_period_size == 0 || g_period_counts == 0) {
|
|
eq_err("[EQ] g_period_size:%d or g_period_size:%d is zero!\n",
|
|
g_period_size, g_period_counts);
|
|
return -1;
|
|
}
|
|
|
|
g_buffer_size = g_period_size * g_period_counts;
|
|
|
|
buffer = (char *)malloc(g_read_frame * g_period_counts * CHANNEL * sizeof(int16_t));
|
|
if (!buffer) {
|
|
eq_err("[EQ] Alloc buffer failed\n");
|
|
return -1;
|
|
}
|
|
|
|
silence_data = (char *)malloc(g_read_frame * sizeof(int16_t) * CHANNEL); /* 2ch 16bit */
|
|
if (!silence_data) {
|
|
eq_err("[EQ] Alloc silence_data failed\n");
|
|
return -1;
|
|
}
|
|
|
|
// wake_lock = RK_wake_lock_new("eq_drc_process");
|
|
|
|
if(signal_handler() < 0) {
|
|
eq_err("[EQ] Install signal_handler for SIGPIPE failed\n");
|
|
return -1;
|
|
}
|
|
|
|
/* Create a thread to listen for Bluetooth connection status. */
|
|
// pthread_create(&power_status_listen_thread, NULL, power_status_listen, NULL);
|
|
pthread_create(&user_play_status_listen_thread, NULL, user_play_status_listen, NULL);
|
|
// pthread_create(&user_capt_status_listen_thread, NULL, user_capt_status_listen, NULL);
|
|
pthread_create(&a2dp_status_listen_thread, NULL, a2dp_status_listen, NULL);
|
|
|
|
repeat:
|
|
capture_handle = NULL;
|
|
write_handle = NULL;
|
|
err = 0;
|
|
memset(buffer, 0, sizeof(buffer));
|
|
memset((char *)silence_data, 0, sizeof(silence_data));
|
|
sampleRate = SAMPLE_RATE;
|
|
channels = CHANNEL;
|
|
mute_frame_thd = (int)(SAMPLE_RATE * mute_time / g_read_frame);
|
|
mute_frame = 0;
|
|
/* LINE_OUT is the default output device */
|
|
device_flag = DEVICE_FLAG_LINE_OUT;
|
|
new_flag = DEVICE_FLAG_LINE_OUT;
|
|
last_flag = DEVICE_FLAG_LINE_OUT;
|
|
|
|
eq_debug("\n==========EQ/DRC process release version %s==============\n", EQ_DRC_PROCESS_VERSION);
|
|
eq_debug("==========KEEPING_HW_CARD: %d===============\n", KEEPING_HW_CARD);
|
|
eq_debug("===== g_read_frame:%d g_period_size:%d g_period_counts:%d g_buffer_size:%d =====\n",
|
|
g_read_frame, g_period_size, g_period_counts, g_buffer_size);
|
|
#if KEEPING_HW_CARD
|
|
eq_debug("===== g_path_name: %s =====\n", g_path_name);
|
|
#endif
|
|
|
|
alsa_fake_device_record_open(&capture_handle, channels, sampleRate);
|
|
|
|
#if KEEPING_HW_CARD
|
|
if (write_handle_bak != NULL) {
|
|
snd_pcm_close(write_handle_bak);
|
|
eq_info("[EQ] resume process and release last write_handle_bak: 0x%x\n", write_handle_bak);
|
|
write_handle_bak = NULL;
|
|
} else {
|
|
eq_info("[EQ] run process first\n");
|
|
}
|
|
#endif
|
|
|
|
device_flag = get_device_flag();
|
|
err = alsa_fake_device_write_open(&write_handle, channels, sampleRate, device_flag, &socket_fd);
|
|
if (err < 0) {
|
|
eq_err("LINE: %d, first open playback device failed, and repeat\n", __LINE__);
|
|
// return -1;
|
|
goto repeat;
|
|
} else {
|
|
eq_info("LINE: %d, open write_handle: 0x%x\n", __LINE__, write_handle);
|
|
}
|
|
|
|
#if KEEPING_HW_CARD
|
|
/* Avoid start with plugged phones and crashed during close sound card. */
|
|
if (device_flag == DEVICE_FLAG_LINE_OUT)
|
|
write_handle_bak = write_handle;
|
|
|
|
eq_info("[EQ] line: %d init write_handle: 0x%x | 0x%x, device_flag: %d | %d\n",
|
|
__LINE__, write_handle, write_handle_bak, device_flag, last_flag);
|
|
#endif
|
|
|
|
// RK_acquire_wake_lock(wake_lock);
|
|
|
|
while (1) {
|
|
// startProcTime = clock();
|
|
err = snd_pcm_readi(capture_handle, buffer, g_read_frame);
|
|
// endProcTime = clock();
|
|
// printf("snd_pcm_readi cost_time: %ld us\n", endProcTime - startProcTime);
|
|
if (err != g_read_frame) {
|
|
if (err == -ESTRPIPE) {
|
|
eq_err("====[EQ] LINE: %d system suspend and resumed\n", __LINE__);
|
|
} else {
|
|
eq_err("====[EQ] LINE: %d read frame error = %d, not %d\n", __LINE__, err, g_read_frame);
|
|
}
|
|
}
|
|
|
|
if (err < 0) {
|
|
if (err == -EPIPE)
|
|
eq_err("[EQ] Overrun occurred: %d\n", err);
|
|
|
|
err = snd_pcm_recover(capture_handle, err, 0);
|
|
// Still an error, need to exit.
|
|
if (err < 0) {
|
|
eq_err("[EQ] Error occured while recording: %s, goto repeat\n", snd_strerror(err));
|
|
// usleep(200 * 1000);
|
|
if (capture_handle)
|
|
snd_pcm_close(capture_handle);
|
|
|
|
goto repeat;
|
|
}
|
|
}
|
|
|
|
if (g_system_sleep)
|
|
mute_frame = mute_frame_thd;
|
|
else if(low_power_mode && is_mute_frame((short *)buffer, channels * g_read_frame))
|
|
mute_frame ++;
|
|
else
|
|
mute_frame = 0;
|
|
|
|
if (device_flag == DEVICE_FLAG_BLUETOOTH_BSA) {
|
|
if ((g_bt_is_connect == BT_DISCONNECT) && (socket_fd >= 0)) {
|
|
eq_debug("[EQ] bsa bt source disconnect, teardown client socket\n");
|
|
RK_socket_client_teardown(socket_fd);
|
|
socket_fd = -1;
|
|
}
|
|
}
|
|
|
|
// eq_info("[EQ] user_play_state=%d\n", user_play_state);
|
|
|
|
if(mute_frame >= mute_frame_thd) {
|
|
// eq_info("[EQ] g_system_sleep=%d, power_state=%d\n", g_system_sleep, power_state);
|
|
//usleep(30*1000);
|
|
/* Reassign to avoid overflow */
|
|
// memset(buffer, 0, sizeof(buffer));
|
|
|
|
mute_frame = mute_frame_thd;
|
|
if (write_handle) {
|
|
#if 1 // fade-out
|
|
int64_t start = 0;
|
|
int fade_type = FADE_OUT;
|
|
int nb_samples = g_read_frame * g_period_counts;
|
|
int buf_bytes = g_read_frame * channels * sizeof(short) * g_period_counts;
|
|
short *fade_buf, *src_buf;
|
|
int curve_type = IQSIN;
|
|
|
|
fade_buf = (short *)calloc(buf_bytes, 1);
|
|
if (!fade_buf) {
|
|
eq_err("[EQ] alloc fade_buf failed\n");
|
|
return -1;
|
|
}
|
|
|
|
src_buf = (short *)calloc(buf_bytes, 1);
|
|
if (!src_buf) {
|
|
eq_err("[EQ] alloc src_buf failed\n");
|
|
return -1;
|
|
}
|
|
|
|
memcpy((void *)(src_buf), (void *)(buffer), buf_bytes);
|
|
|
|
eq_info("[EQ] USER_PLAY_CLOSED and fade out\n");
|
|
|
|
fade_samples_s16((uint8_t **)(&fade_buf), (uint8_t **)(&src_buf),
|
|
nb_samples, channels,
|
|
fade_type ? -1 : 1, start,
|
|
nb_samples, curve_type);
|
|
memcpy((void *)(buffer), (void *)(fade_buf), buf_bytes);
|
|
|
|
if (src_buf)
|
|
free(src_buf);
|
|
if (fade_buf)
|
|
free(fade_buf);
|
|
#endif
|
|
|
|
#if KEEPING_HW_CARD
|
|
if (device_flag == DEVICE_FLAG_LINE_OUT) {
|
|
system("amixer sset 'Playback Path' OFF");
|
|
eq_info("[EQ] disable Playback path and PA\n");
|
|
write_handle = NULL;
|
|
} else {
|
|
snd_pcm_close(write_handle);
|
|
eq_info("[EQ]: %d Close sound card\n", __LINE__);
|
|
write_handle = NULL;
|
|
}
|
|
#else
|
|
snd_pcm_close(write_handle);
|
|
write_handle = NULL;
|
|
#endif
|
|
|
|
// RK_release_wake_lock(wake_lock);
|
|
|
|
if (power_state == POWER_STATE_SUSPENDING) {
|
|
eq_err("[EQ] suspend and close write handle for you right now!\n");
|
|
power_state = POWER_STATE_SUSPEND;
|
|
} else {
|
|
eq_err("[EQ] %d second no playback, close write handle for you now!\n ", mute_time);
|
|
}
|
|
|
|
user_play_state = USER_PLAY_CLOSED;
|
|
}
|
|
|
|
#if KEEPING_HW_CARD
|
|
// if (write_handle == NULL) {
|
|
// snd_pcm_forward(write_handle_bak, g_read_frame);
|
|
// eq_info("[EQ] forward %d frames\n", g_read_frame);
|
|
// }
|
|
#endif
|
|
|
|
continue;
|
|
}
|
|
|
|
last_flag = device_flag;
|
|
new_flag = get_device_flag();
|
|
if (new_flag != device_flag) {
|
|
eq_debug("\n[EQ] Device route changed, from\"%s\" to \"%s\"\n\n",
|
|
get_device_name(device_flag), get_device_name(new_flag));
|
|
device_flag = new_flag;
|
|
#if KEEPING_HW_CARD
|
|
if (device_flag == DEVICE_FLAG_LINE_OUT) {
|
|
if (g_fast_codec == true &&
|
|
last_flag == DEVICE_FLAG_LINE_OUT &&
|
|
last_flag == device_flag) {
|
|
eq_info("[EQ]: %d Do nothing, write_handle: 0x%x | 0x%x\n",
|
|
__LINE__, device_flag, write_handle, write_handle_bak);
|
|
} else {
|
|
eq_info("[EQ]: %d Close card LINE_OUT from %d, write_handle: 0x%x | 0x%x, g_fast_codec:%d\n",
|
|
__LINE__, last_flag, write_handle, write_handle_bak, g_fast_codec);
|
|
|
|
if (write_handle) {
|
|
snd_pcm_close(write_handle);
|
|
eq_info("[EQ]: %d Close sound card\n", __LINE__);
|
|
write_handle = NULL;
|
|
write_handle_bak = NULL;
|
|
g_fast_codec = false;
|
|
}
|
|
}
|
|
} else {
|
|
eq_info("[EQ]: %d Close card, %d, write_handle: 0x%x | 0x%x, g_fast_codec:%d\n",
|
|
__LINE__, device_flag, write_handle, write_handle_bak, g_fast_codec);
|
|
if (write_handle == write_handle_bak) {
|
|
if (write_handle) {
|
|
snd_pcm_close(write_handle);
|
|
eq_info("[EQ]: %d Close sound card\n", __LINE__);
|
|
write_handle = NULL;
|
|
write_handle_bak = NULL;
|
|
g_fast_codec = false;
|
|
}
|
|
} else {
|
|
if (write_handle_bak) {
|
|
snd_pcm_close(write_handle_bak);
|
|
eq_info("[EQ]: %d Close write_handle_bak card\n", __LINE__);
|
|
write_handle_bak = NULL;
|
|
}
|
|
if (write_handle) {
|
|
snd_pcm_close(write_handle);
|
|
eq_info("[EQ]: %d Close write_handle card\n", __LINE__);
|
|
write_handle = NULL;
|
|
}
|
|
g_fast_codec = false;
|
|
}
|
|
}
|
|
#else
|
|
if (write_handle) {
|
|
snd_pcm_close(write_handle);
|
|
write_handle = NULL;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
// eq_info("[EQ] device_flag: %d, %s, write_handle: 0x%x\n",
|
|
// device_flag, get_device_name(device_flag), write_handle);
|
|
|
|
while (write_handle == NULL && socket_fd < 0) {
|
|
// RK_acquire_wake_lock(wake_lock);
|
|
eq_info("[EQ] device_flag: %d, %s, write_handle: 0x%x, socket_fd: %d\n",
|
|
device_flag, get_device_name(device_flag), write_handle, socket_fd);
|
|
#if KEEPING_HW_CARD
|
|
if (device_flag == DEVICE_FLAG_LINE_OUT) {
|
|
if (g_fast_codec == true &&
|
|
last_flag == DEVICE_FLAG_LINE_OUT &&
|
|
write_handle_bak > 0) {
|
|
char cmd_str[64] = { 0 };
|
|
|
|
write_handle = write_handle_bak;
|
|
|
|
sprintf(cmd_str, "amixer sset 'Playback Path' %s", g_path_name);
|
|
system(cmd_str);
|
|
eq_info("[EQ] enable Playback path and PA, write_handle: 0x%x\n", write_handle);
|
|
// snd_pcm_forward(write_handle, g_read_frame);
|
|
// continue;
|
|
} else {
|
|
eq_info("EQ]: %d if switch device_flag: %d | %d and open start, write_handle: 0x%x | 0x%x g_fast_codec: %d\n",
|
|
__LINE__, device_flag, last_flag, write_handle, write_handle_bak, g_fast_codec);
|
|
|
|
err = alsa_fake_device_write_open(&write_handle, channels, sampleRate, device_flag, &socket_fd);
|
|
if (err < 0 || (write_handle == NULL && socket_fd < 0)) {
|
|
eq_err("[EQ] line:%d Route change failed! Using default audio path.\n", __LINE__);
|
|
// last_flag = DEVICE_FLAG_LINE_OUT;
|
|
g_bt_is_connect = BT_DISCONNECT;
|
|
continue;
|
|
} else {
|
|
eq_info("LINE: %d, open write_handle: 0x%x\n", __LINE__, write_handle);
|
|
}
|
|
write_handle_bak = write_handle;
|
|
}
|
|
} else {
|
|
static int overflow = 0;
|
|
|
|
eq_info("EQ]: %d else switch device_flag: %d | %d and open start, write_handle: 0x%x | 0x%x g_fast_codec: %d\n",
|
|
__LINE__, device_flag, last_flag, write_handle, write_handle_bak, g_fast_codec);
|
|
|
|
// if (write_handle_bak) {
|
|
// snd_pcm_close(write_handle_bak);
|
|
// write_handle_bak = NULL;
|
|
// g_fast_codec = false;
|
|
// eq_info("EQ]: %d close g_fast_codec\n", __LINE__);
|
|
// }
|
|
|
|
err = alsa_fake_device_write_open(&write_handle, channels, sampleRate, device_flag, &socket_fd);
|
|
if (err < 0 || (write_handle == NULL && socket_fd < 0)) {
|
|
eq_err("[EQ] line:%d Route change failed!\n", __LINE__);
|
|
// device_flag = DEVICE_FLAG_LINE_OUT;
|
|
|
|
if (device_flag == DEVICE_FLAG_DIGITAL_HP) {
|
|
/* Maybe need to more prepare some time for digital headphone */
|
|
usleep(200 * 1000);
|
|
if (overflow++ >= 12) {
|
|
/* about 3s */
|
|
eq_err("[EQ] line:%d Using default audio path: %d, overflow: %d\n",
|
|
__LINE__, DEVICE_FLAG_LINE_OUT, overflow);
|
|
last_flag = DEVICE_FLAG_DIGITAL_HP;
|
|
device_flag = DEVICE_FLAG_LINE_OUT;
|
|
overflow = 0;
|
|
}
|
|
|
|
// need_close_card = true;
|
|
} else {
|
|
eq_err("[EQ] line:%d device_flag will: %d to %d\n",
|
|
__LINE__, last_flag, DEVICE_FLAG_LINE_OUT);
|
|
if (device_flag == DEVICE_FLAG_BLUETOOTH ||
|
|
device_flag == DEVICE_FLAG_BLUETOOTH_BSA) {
|
|
g_bt_is_connect = BT_DISCONNECT;
|
|
}
|
|
|
|
last_flag = device_flag;
|
|
device_flag = DEVICE_FLAG_LINE_OUT;
|
|
}
|
|
// else if (device_flag == DEVICE_FLAG_ANALOG_HP) {
|
|
// last_flag = DEVICE_FLAG_ANALOG_HP;
|
|
// device_flag = DEVICE_FLAG_LINE_OUT;
|
|
// need_close_card = true;
|
|
// }
|
|
|
|
// g_bt_is_connect = BT_DISCONNECT;
|
|
continue;
|
|
} else {
|
|
eq_err("[EQ] line:%d Clean overflow:%d, write_handle: 0x%x\n", __LINE__, overflow, write_handle);
|
|
overflow = 0;
|
|
}
|
|
|
|
if (write_handle_bak) {
|
|
snd_pcm_close(write_handle_bak);
|
|
write_handle_bak = NULL;
|
|
g_fast_codec = false;
|
|
eq_info("EQ]: %d close g_fast_codec\n", __LINE__);
|
|
}
|
|
}
|
|
#else
|
|
err = alsa_fake_device_write_open(&write_handle, channels, sampleRate, device_flag, &socket_fd);
|
|
if (err < 0 || (write_handle == NULL && socket_fd < 0)) {
|
|
eq_err("[EQ] Route change failed! Using default audio path.\n");
|
|
device_flag = DEVICE_FLAG_LINE_OUT;
|
|
g_bt_is_connect = BT_DISCONNECT;
|
|
}
|
|
#endif
|
|
|
|
skip_frame = 0;
|
|
|
|
// memset(buffer, 0xff, sizeof(buffer));
|
|
|
|
// if (capture_handle)
|
|
// snd_pcm_close(capture_handle);
|
|
// alsa_fake_device_record_open(&capture_handle, channels, sampleRate);
|
|
|
|
if (0 && low_power_mode) {
|
|
int i, num = 4;
|
|
eq_debug("[EQ] feed mute data %d frame\n", num);
|
|
for (i = 0; i < num; i++) {
|
|
if(write_handle != NULL) {
|
|
err = snd_pcm_writei(write_handle, silence_data, g_read_frame);
|
|
if(err != g_read_frame)
|
|
eq_err("====[EQ] %d, write frame error = %d, not %d\n", __LINE__, err, g_read_frame);
|
|
} else if (socket_fd >= 0) {
|
|
err = RK_socket_send(socket_fd, silence_data, g_read_frame * 4); //2ch 16bit
|
|
if(err != (g_read_frame * 4))
|
|
eq_err("====[EQ] %d, write frame error = %d, not %d\n", __LINE__, err, g_read_frame * 4);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if(write_handle != NULL) {
|
|
#if 0
|
|
if (skip_frame > 0) {
|
|
int err;
|
|
err = snd_pcm_writei(write_handle, silence_data, g_read_frame);
|
|
if(err != g_read_frame)
|
|
eq_err("====[EQ] %d, write frame error = %d, not %d\n", __LINE__, err, g_read_frame);
|
|
|
|
eq_err("skip_frame = %d\n", skip_frame);
|
|
skip_frame--;
|
|
continue;
|
|
}
|
|
#endif
|
|
|
|
//usleep(30*1000);
|
|
err = snd_pcm_writei(write_handle, buffer, g_read_frame);
|
|
if(err != g_read_frame) {
|
|
eq_err("====[EQ] %d, write frame error = %d, not %d\n", __LINE__, err, g_read_frame);
|
|
|
|
// if (err > 0) {
|
|
// snd_pcm_sframes_t frames = g_read_frame - err;
|
|
// startProcTime = clock();
|
|
// frames = snd_pcm_forward(write_handle, frames);
|
|
// endProcTime = clock();
|
|
// printf("snd_pcm_forward cost_time: %ld us\n", endProcTime - startProcTime);
|
|
// eq_err("[EQ] snd_pcm_forward frames: %d\n", frames);
|
|
// }
|
|
}
|
|
|
|
if (err < 0) {
|
|
if (err == -EPIPE) {
|
|
eq_err("[EQ] Underrun occurred from write: %d\n", err);
|
|
#if 1
|
|
err = snd_pcm_recover(write_handle, err, 0);
|
|
if (err < 0) {
|
|
eq_err( "[EQ] Error occured while writing: %s\n", snd_strerror(err));
|
|
// usleep(200 * 1000);
|
|
#if KEEPING_HW_CARD
|
|
/* Do nothing */
|
|
#else
|
|
if (write_handle) {
|
|
snd_pcm_close(write_handle);
|
|
write_handle = NULL;
|
|
}
|
|
#endif
|
|
if (device_flag == DEVICE_FLAG_BLUETOOTH)
|
|
g_bt_is_connect = BT_DISCONNECT;
|
|
}
|
|
#else
|
|
eq_drc_xrun(write_handle, SND_PCM_STREAM_PLAYBACK);
|
|
#endif
|
|
}
|
|
#if KEEPING_HW_CARD
|
|
else if (err == -EBADFD) {
|
|
int err;
|
|
|
|
eq_err("====[EQ] %d, EBADFD and re-open sound, device_flag: %d write_handle: 0x%x | 0x%x\n",
|
|
__LINE__, device_flag, write_handle, write_handle_bak);
|
|
|
|
if (write_handle) {
|
|
snd_pcm_close(write_handle);
|
|
write_handle = NULL;
|
|
write_handle_bak = NULL;
|
|
g_fast_codec = false;
|
|
}
|
|
|
|
err = alsa_fake_device_write_open(&write_handle, channels, sampleRate, device_flag, &socket_fd);
|
|
if (err < 0) {
|
|
// eq_err("LINE: %d, open playback device failed, exit eq\n", __LINE__);
|
|
eq_err("LINE: %d, open playback device failed, continue\n", __LINE__);
|
|
// write_handle_bak = write_handle;
|
|
// return -1;
|
|
continue;
|
|
} else {
|
|
eq_info("LINE: %d, open write_handle: 0x%x\n", __LINE__, write_handle);
|
|
}
|
|
|
|
write_handle_bak = write_handle;
|
|
}
|
|
#endif
|
|
}
|
|
}else if (socket_fd >= 0) {
|
|
if (g_bt_is_connect == BT_CONNECT_BSA) {
|
|
err = RK_socket_send(socket_fd, (char *)buffer, g_read_frame * 4);
|
|
if (err != g_read_frame * 4 && -EAGAIN != err)
|
|
eq_err("====[EQ] %d, write frame error = %d, not %d\n", __LINE__, err, g_read_frame * 4);
|
|
|
|
if (err < 0 && -EAGAIN != err) {
|
|
if (socket_fd >= 0) {
|
|
eq_err("[EQ] socket send err: %d, teardown client socket\n", err);
|
|
RK_socket_client_teardown(socket_fd);
|
|
socket_fd = -1;
|
|
}
|
|
|
|
g_bt_is_connect = BT_DISCONNECT;
|
|
}
|
|
} else {
|
|
if(socket_fd >= 0){
|
|
eq_debug("[EQ] bsa bt source disconnect, teardown client socket\n");
|
|
RK_socket_client_teardown(socket_fd);
|
|
socket_fd = -1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
error:
|
|
eq_debug("=== [EQ] Exit eq ===\n");
|
|
|
|
if (silence_data) {
|
|
free(silence_data);
|
|
silence_data = NULL;
|
|
}
|
|
|
|
if (buffer) {
|
|
free(buffer);
|
|
buffer = NULL;
|
|
}
|
|
|
|
g_upi.stop = 1;
|
|
|
|
if (capture_handle)
|
|
snd_pcm_close(capture_handle);
|
|
|
|
if (write_handle)
|
|
snd_pcm_close(write_handle);
|
|
|
|
if (socket_fd >= 0)
|
|
RK_socket_client_teardown(socket_fd);
|
|
|
|
pthread_cancel(a2dp_status_listen_thread);
|
|
pthread_join(a2dp_status_listen_thread, NULL);
|
|
|
|
return 0;
|
|
}
|