554 lines
16 KiB
C
554 lines
16 KiB
C
/*******************************************************************************************
|
|
# Copyright (c) 2023~2024 Quaming Intelligent Technology Co., Ltd.
|
|
# All Rights Reserved.
|
|
# Confidential and Proprietary - Quaming Intelligent Technology Co., Ltd.
|
|
#*******************************************************************************************/
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <pthread.h>
|
|
#include <signal.h>
|
|
#include <sys/time.h>
|
|
#include <unistd.h>
|
|
#include <fcntl.h>
|
|
#include "common/qua_mm_common.h"
|
|
#include "common/qua_sys_platform.h"
|
|
#include "audio/qua_mm_audio.h"
|
|
|
|
typedef struct _thread_codec_param
|
|
{
|
|
QUA_U32 acw_uDevID;
|
|
QUA_U32 uFrmSize;
|
|
unsigned char* ai_vAddr;
|
|
unsigned long ai_phyAddr;
|
|
unsigned char* ao_vAddr;
|
|
unsigned long ao_phyAddr;
|
|
}thread_codec_param;
|
|
|
|
typedef struct _qua_frame_s
|
|
{
|
|
QUA_U8 *bufVirAddr;
|
|
QUA_U32 u32Len;
|
|
}qua_frame_s;
|
|
|
|
pthread_t g_audio_record_thread = NULL;
|
|
pthread_t g_audio_play_thread = NULL;
|
|
pthread_t g_audio_record_play_thread = NULL;
|
|
pthread_t g_audio_play_file_record_thread = NULL;
|
|
|
|
qua_mm_audio_device_t *g_audio_dev;
|
|
qua_audio_cfg_arg acw_ai_cfg, acw_ao_cfg;
|
|
|
|
char *filename_8k_16bit_stereo = "/data/media/8k_16bit_stereo.pcm";
|
|
|
|
QUA_VOID* audio_record_file_Callback(QUA_VOID* pAtr)
|
|
{
|
|
QUA_U32 uCnt = 0;
|
|
QUA_S32 ret = 0;
|
|
thread_codec_param uparm;
|
|
static qua_frame_s acw_ai_frame;
|
|
FILE * record_fp = NULL;
|
|
|
|
thread_codec_param* p = pAtr;
|
|
QUA_U8 buf[p->uFrmSize];
|
|
memset(buf, 0, p->uFrmSize);
|
|
|
|
memcpy(&uparm, (thread_codec_param*)pAtr, sizeof(thread_codec_param));
|
|
ALOGD("audio_record_file_Callback dev_id:%d,frame_size:%d\n", uparm.acw_uDevID, uparm.uFrmSize);
|
|
|
|
acw_ai_frame.u32Len = uparm.uFrmSize;
|
|
acw_ai_frame.bufVirAddr = buf;
|
|
|
|
record_fp = fopen("/data/media/record.pcm", "wb+");
|
|
if (NULL == record_fp) {
|
|
ALOGD("fopen record_fp is fail!\n");
|
|
goto exit;
|
|
} else {
|
|
ALOGD("record open file succeed!\n");
|
|
}
|
|
|
|
while (1) {
|
|
if (g_audio_record_thread != NULL) {
|
|
ret = g_audio_dev->read_frame(uparm.acw_uDevID, acw_ai_frame.bufVirAddr, acw_ai_frame.u32Len, NULL);
|
|
if (ret != QUA_SUCCESS) {
|
|
ALOGD("%s: Dev:%d, read_frame failed with uCnt %d !\n", __FUNCTION__, uparm.acw_uDevID, uCnt);
|
|
usleep(40 * 1000);
|
|
continue;
|
|
}
|
|
fwrite(acw_ai_frame.bufVirAddr, 1, acw_ai_frame.u32Len, record_fp); /**/
|
|
uCnt++;
|
|
} else {
|
|
ALOGD("audio_record_file_Callback thread exit!\n");
|
|
goto exit;
|
|
}
|
|
}
|
|
|
|
exit:
|
|
g_audio_dev->capture_stop(uparm.acw_uDevID);
|
|
g_audio_dev->exit(uparm.acw_uDevID);
|
|
g_audio_dev->capture_deinit(uparm.acw_uDevID);
|
|
fclose(record_fp);
|
|
pthread_exit(0);
|
|
return NULL;
|
|
|
|
}
|
|
|
|
int audio_record_file(int id)
|
|
{
|
|
QUA_S32 result;
|
|
static thread_codec_param uparm;
|
|
qua_audio_cfg_arg acw_ai_cfg;
|
|
|
|
acw_ai_cfg.enc_type = QUA_PT_LPCM;
|
|
acw_ai_cfg.io_type = QUA_MIC_IN;
|
|
acw_ai_cfg.frame_size = 1280;
|
|
acw_ai_cfg.frame_cnt = 3;
|
|
acw_ai_cfg.channel_bit = QUA_BW_16;
|
|
acw_ai_cfg.rate = QUA_SR_8K;
|
|
|
|
result = g_audio_dev->capture_init(id, &acw_ai_cfg);
|
|
if (result != QUA_SUCCESS) {
|
|
ALOGD("g_audio_dev capture_init failed!\n");
|
|
return QUA_FAILURE;
|
|
}
|
|
g_audio_dev->capture_start(id);
|
|
|
|
if (g_audio_record_thread == NULL) {
|
|
uparm.acw_uDevID = id;
|
|
uparm.uFrmSize = acw_ai_cfg.frame_size;
|
|
|
|
pthread_create(&g_audio_record_thread, 0, audio_record_file_Callback, &uparm);
|
|
ALOGD("%s create thread:acw_dev_id:%d, frame_size:%d\n", __func__, id, acw_ai_cfg.frame_size);
|
|
}
|
|
|
|
pthread_join(g_audio_record_thread, 0);
|
|
g_audio_record_thread = NULL;
|
|
return 0;
|
|
}
|
|
|
|
QUA_VOID* audio_play_file_Callback(QUA_VOID* pAtr)
|
|
{
|
|
QUA_S32 ret = 0;
|
|
thread_codec_param uparm;
|
|
static qua_frame_s acw_ao_frame;
|
|
|
|
FILE * play_fp = NULL;
|
|
|
|
thread_codec_param *p = pAtr;
|
|
QUA_U8 buf[p->uFrmSize];
|
|
memset(buf, 0, p->uFrmSize);
|
|
|
|
memcpy(&uparm, (thread_codec_param*)pAtr, sizeof(thread_codec_param));
|
|
ALOGD("audio_play_file_Callback dev_id:%d, frame_size:%d\n", uparm.acw_uDevID, uparm.uFrmSize);
|
|
|
|
acw_ao_frame.u32Len = uparm.uFrmSize;
|
|
acw_ao_frame.bufVirAddr = buf;
|
|
|
|
play_fp = fopen(filename_8k_16bit_stereo, "rb");
|
|
if (NULL == play_fp) {
|
|
ALOGD("fopen play_fp is fail!\n");
|
|
goto exit;
|
|
} else {
|
|
ALOGD("open file succeed!\n");
|
|
}
|
|
|
|
while (1) {
|
|
if (g_audio_play_thread != NULL) {
|
|
while (fread(acw_ao_frame.bufVirAddr, 1, acw_ao_frame.u32Len, play_fp) != acw_ao_frame.u32Len) {
|
|
fseek(play_fp, 0, SEEK_SET);
|
|
}
|
|
|
|
ret = g_audio_dev->write_frame(uparm.acw_uDevID, acw_ao_frame.bufVirAddr, acw_ao_frame.u32Len);
|
|
if (ret != QUA_SUCCESS) {
|
|
ALOGD("g_audio_dev write_frame is failed!\n");
|
|
goto exit;
|
|
}
|
|
} else {
|
|
ALOGD("audio_play_file_Callback thread exit!\n");
|
|
goto exit;
|
|
}
|
|
}
|
|
|
|
exit:
|
|
g_audio_dev->play_stop(uparm.acw_uDevID);
|
|
g_audio_dev->exit(uparm.acw_uDevID);
|
|
g_audio_dev->play_deinit(uparm.acw_uDevID);
|
|
fclose(play_fp);
|
|
pthread_exit(0);
|
|
return NULL;
|
|
}
|
|
|
|
int audio_play_file(int id)
|
|
{
|
|
QUA_S32 result;
|
|
static thread_codec_param uparm;
|
|
qua_audio_cfg_arg acw_ao_cfg;
|
|
|
|
acw_ao_cfg.enc_type = QUA_PT_LPCM;
|
|
acw_ao_cfg.io_type = QUA_LINE_HPOUT;
|
|
acw_ao_cfg.frame_size = 1280;
|
|
acw_ao_cfg.frame_cnt = 3;
|
|
acw_ao_cfg.channel_bit = QUA_BW_16;
|
|
acw_ao_cfg.rate = QUA_SR_8K;
|
|
result = g_audio_dev->play_init(id, &acw_ao_cfg);
|
|
if (result != QUA_SUCCESS) {
|
|
ALOGD("g_audio_dev play_init failed!\n");
|
|
return QUA_FAILURE;
|
|
}
|
|
g_audio_dev->play_start(id);
|
|
|
|
if (g_audio_play_thread == NULL) {
|
|
uparm.acw_uDevID = id;
|
|
uparm.uFrmSize = acw_ao_cfg.frame_size;
|
|
|
|
pthread_create(&g_audio_play_thread, 0, audio_play_file_Callback, &uparm);
|
|
ALOGD("%s create thread:acw_dev_id:%d, frame_size:%d\n", __func__, id, acw_ao_cfg.frame_size);
|
|
}
|
|
pthread_join(g_audio_play_thread, 0);
|
|
g_audio_play_thread = NULL;
|
|
return 0;
|
|
}
|
|
|
|
QUA_VOID* audio_record_play_Callback(QUA_VOID* pAtr)
|
|
{
|
|
QUA_U32 uCnt = 0;
|
|
QUA_S32 ret = 0;
|
|
thread_codec_param uparm;
|
|
static qua_frame_s acw_ai_frame, acw_ao_frame;
|
|
|
|
thread_codec_param *p = pAtr;
|
|
QUA_U8 buf[p->uFrmSize];
|
|
memset(buf, 0, p->uFrmSize);
|
|
|
|
memcpy(&uparm, (thread_codec_param*)pAtr, sizeof(thread_codec_param));
|
|
ALOGD("audio_record_file_Callback dev_id:%d, frame_size:%d\n", uparm.acw_uDevID, uparm.uFrmSize);
|
|
|
|
acw_ai_frame.u32Len = uparm.uFrmSize;
|
|
acw_ao_frame.u32Len = uparm.uFrmSize;
|
|
acw_ai_frame.bufVirAddr = buf;
|
|
acw_ao_frame.bufVirAddr = buf;
|
|
|
|
while (1) {
|
|
if (g_audio_record_play_thread != NULL) {
|
|
ret = g_audio_dev->read_frame(uparm.acw_uDevID, acw_ai_frame.bufVirAddr, acw_ai_frame.u32Len, NULL);
|
|
if (ret != QUA_SUCCESS) {
|
|
ALOGD("%s: Dev %d,read_frame failed with uCnt %d !\n", __FUNCTION__, uparm.acw_uDevID, uCnt);
|
|
usleep(40 * 1000);
|
|
continue;
|
|
}
|
|
|
|
ret = g_audio_dev->write_frame(uparm.acw_uDevID, acw_ao_frame.bufVirAddr, acw_ao_frame.u32Len);
|
|
if (ret != QUA_SUCCESS) {
|
|
ALOGD("g_audio_dev write_frame is failed!\n");
|
|
goto exit;
|
|
}
|
|
|
|
uCnt++;
|
|
} else {
|
|
ALOGD("audio_record_file_Callback thread exit!\n");
|
|
goto exit;
|
|
}
|
|
}
|
|
|
|
exit:
|
|
g_audio_dev->capture_stop(uparm.acw_uDevID);
|
|
g_audio_dev->play_stop(uparm.acw_uDevID);
|
|
g_audio_dev->exit(uparm.acw_uDevID);
|
|
|
|
g_audio_dev->capture_deinit(uparm.acw_uDevID);
|
|
g_audio_dev->play_deinit(uparm.acw_uDevID);
|
|
|
|
pthread_exit(0);
|
|
return NULL;
|
|
|
|
}
|
|
|
|
int audio_record_play(int id)
|
|
{
|
|
QUA_S32 result;
|
|
static thread_codec_param uparm;
|
|
qua_audio_cfg_arg acw_ai_cfg, acw_ao_cfg;
|
|
|
|
acw_ai_cfg.enc_type = QUA_PT_LPCM;
|
|
acw_ai_cfg.io_type = QUA_MIC_IN;
|
|
acw_ai_cfg.frame_size = 7680;
|
|
acw_ai_cfg.frame_cnt = 3;
|
|
acw_ai_cfg.channel_bit = QUA_BW_16;
|
|
acw_ai_cfg.rate = QUA_SR_48K;
|
|
|
|
result = g_audio_dev->capture_init(id, &acw_ai_cfg);
|
|
if (result != QUA_SUCCESS) {
|
|
ALOGD("g_audio_dev capture_init failed!\n");
|
|
return QUA_FAILURE;
|
|
}
|
|
g_audio_dev->capture_volume(id, QUA_VOLUME_TYPE_ANA, 1);
|
|
g_audio_dev->capture_volume(id, QUA_VOLUME_TYPE_DIG, 0x64);
|
|
g_audio_dev->capture_start(id);
|
|
|
|
acw_ao_cfg.enc_type = QUA_PT_LPCM;
|
|
acw_ao_cfg.io_type = QUA_LINE_HPOUT;
|
|
acw_ao_cfg.frame_size = 7680;
|
|
acw_ao_cfg.frame_cnt = 3;
|
|
acw_ao_cfg.channel_bit = QUA_BW_16;
|
|
acw_ao_cfg.rate = QUA_SR_48K;
|
|
|
|
result = g_audio_dev->play_init(id, &acw_ao_cfg);
|
|
|
|
if (result != QUA_SUCCESS) {
|
|
ALOGD("g_audio_dev play_init failed!\n");
|
|
return QUA_FAILURE;
|
|
}
|
|
g_audio_dev->play_start(id);
|
|
|
|
if (g_audio_record_play_thread == NULL) {
|
|
uparm.acw_uDevID = id;
|
|
uparm.uFrmSize = acw_ai_cfg.frame_size;
|
|
|
|
pthread_create(&g_audio_record_play_thread, 0, audio_record_play_Callback, &uparm);
|
|
ALOGD("%s create thread:acw_dev_id:%d,frame_size:%d\n", __func__, id, acw_ai_cfg.frame_size);
|
|
}
|
|
pthread_join(g_audio_record_play_thread, 0);
|
|
g_audio_record_play_thread = NULL;
|
|
return 0;
|
|
|
|
}
|
|
|
|
QUA_VOID* audio_play_file_record_Callback(QUA_VOID* pAtr)
|
|
{
|
|
QUA_U32 uCnt = 0;
|
|
QUA_S32 ret = 0;
|
|
thread_codec_param uparm;
|
|
static qua_frame_s acw_ai_frame, acw_ao_frame;
|
|
FILE *play_fp = NULL;
|
|
FILE *record_fp = NULL;
|
|
thread_codec_param *p = pAtr;
|
|
QUA_U8 buf[p->uFrmSize];
|
|
memset(buf, 0, p->uFrmSize);
|
|
|
|
memcpy(&uparm, (thread_codec_param*)pAtr, sizeof(thread_codec_param));
|
|
ALOGD("audio_record_play_Callback acw_dev_id:%d, frame_size:%d\n", uparm.acw_uDevID, uparm.uFrmSize);
|
|
|
|
acw_ai_frame.u32Len = uparm.uFrmSize;
|
|
acw_ao_frame.u32Len = uparm.uFrmSize;
|
|
acw_ai_frame.bufVirAddr = buf;
|
|
acw_ao_frame.bufVirAddr = buf;
|
|
|
|
record_fp = fopen("/data/media/play_and_record.pcm", "wb+");
|
|
if (NULL == record_fp) {
|
|
ALOGD("fopen record_fp is fail!\n");
|
|
goto exit;
|
|
} else {
|
|
ALOGD("record open file succeed!\n");
|
|
}
|
|
|
|
play_fp = fopen(filename_8k_16bit_stereo, "rb");
|
|
if (NULL == play_fp) {
|
|
ALOGD("fopen play_fp is fail!\n");
|
|
goto exit;
|
|
} else {
|
|
ALOGD("open file succeed!\n");
|
|
}
|
|
|
|
while (1) {
|
|
if (g_audio_play_file_record_thread != NULL) {
|
|
while (fread(acw_ao_frame.bufVirAddr, 1, acw_ao_frame.u32Len, play_fp) != acw_ao_frame.u32Len) {
|
|
fseek(play_fp, 0, SEEK_SET);
|
|
}
|
|
|
|
ret = g_audio_dev->write_frame(uparm.acw_uDevID, acw_ao_frame.bufVirAddr, acw_ao_frame.u32Len);
|
|
if (ret != QUA_SUCCESS) {
|
|
ALOGD("g_audio_dev write_frame is failed!\n");
|
|
goto exit;
|
|
}
|
|
|
|
ret = g_audio_dev->read_frame(uparm.acw_uDevID, acw_ai_frame.bufVirAddr, acw_ai_frame.u32Len, NULL);
|
|
if (ret != QUA_SUCCESS) {
|
|
ALOGD("%s: Dev %d, read_frame failed with uCnt %d !\n", __FUNCTION__, uparm.acw_uDevID, uCnt);
|
|
usleep(40 * 1000);
|
|
continue;
|
|
}
|
|
fwrite(acw_ai_frame.bufVirAddr, 1, acw_ai_frame.u32Len, record_fp); /**/
|
|
uCnt++;
|
|
} else {
|
|
ALOGD("audio_play_file_record_Callback thread exit!\n");
|
|
goto exit;
|
|
}
|
|
}
|
|
|
|
exit:
|
|
g_audio_dev->capture_stop(uparm.acw_uDevID);
|
|
g_audio_dev->play_stop(uparm.acw_uDevID);
|
|
g_audio_dev->exit(uparm.acw_uDevID);
|
|
g_audio_dev->capture_deinit(uparm.acw_uDevID);
|
|
g_audio_dev->play_deinit(uparm.acw_uDevID);
|
|
|
|
pthread_exit(0);
|
|
return NULL;
|
|
|
|
}
|
|
|
|
int audio_play_file_record(int id_acw)
|
|
{
|
|
QUA_S32 result;
|
|
static thread_codec_param uparm;
|
|
qua_audio_cfg_arg acw_ai_cfg, acw_ao_cfg;
|
|
|
|
acw_ai_cfg.enc_type = QUA_PT_LPCM;
|
|
acw_ai_cfg.io_type = QUA_MIC_IN;
|
|
acw_ai_cfg.frame_size = 1280;
|
|
acw_ai_cfg.frame_cnt = 3;
|
|
acw_ai_cfg.channel_bit = QUA_BW_16;
|
|
acw_ai_cfg.rate = QUA_SR_8K;
|
|
|
|
result = g_audio_dev->capture_init(id_acw, &acw_ai_cfg);
|
|
if (result != QUA_SUCCESS) {
|
|
ALOGD("capture_init failed!\n");
|
|
return QUA_FAILURE;
|
|
}
|
|
g_audio_dev->capture_start(id_acw);
|
|
|
|
acw_ao_cfg.enc_type = QUA_PT_LPCM;
|
|
acw_ao_cfg.io_type = QUA_LINE_HPOUT;
|
|
acw_ao_cfg.frame_size = 1280;
|
|
acw_ao_cfg.frame_cnt = 3;
|
|
acw_ao_cfg.channel_bit = QUA_BW_16;
|
|
acw_ao_cfg.rate = QUA_SR_8K;
|
|
|
|
result = g_audio_dev->play_init(id_acw, &acw_ao_cfg);
|
|
if (result != QUA_SUCCESS) {
|
|
ALOGD("play_init failed!\n");
|
|
return QUA_FAILURE;
|
|
}
|
|
g_audio_dev->play_start(id_acw);
|
|
|
|
if (g_audio_play_file_record_thread == NULL) {
|
|
uparm.acw_uDevID = id_acw;
|
|
uparm.uFrmSize = acw_ai_cfg.frame_size;
|
|
|
|
pthread_create(&g_audio_play_file_record_thread, 0, audio_play_file_record_Callback, &uparm);
|
|
ALOGD("%s create thread:acw_dev_id:%d, frame_size:%d\n", __func__, id_acw, acw_ai_cfg.frame_size);
|
|
}
|
|
pthread_join(g_audio_play_file_record_thread, 0);
|
|
g_audio_play_file_record_thread = NULL;
|
|
return 0;
|
|
}
|
|
|
|
void audio_stop_clr(void)
|
|
{
|
|
g_audio_record_thread = NULL;
|
|
g_audio_play_thread = NULL;
|
|
g_audio_record_play_thread = NULL;
|
|
g_audio_play_file_record_thread = NULL;
|
|
usleep(500 * 1000);
|
|
}
|
|
|
|
QUA_S32 sample_aio_test(QUA_U32 cmd)
|
|
{
|
|
if(cmd != 8)
|
|
audio_stop_clr();
|
|
switch(cmd)
|
|
{
|
|
case 1:
|
|
{
|
|
audio_record_file(QUA_DEV_ACW_STEREO);
|
|
ALOGD("\n\033[31m ######## [AUDIO]START RECORD FILES! ########\033[0m\n");
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
{
|
|
audio_play_file(QUA_DEV_ACW_STEREO);
|
|
ALOGD("\n\033[31m ######## [AUDIO]START PLAY FILES! ########\033[0m\n");
|
|
}
|
|
break;
|
|
|
|
case 3:
|
|
{
|
|
audio_record_play(QUA_DEV_ACW_STEREO);
|
|
ALOGD("\n\033[31m ######## [AUDIO]ACW record and ACW play! ########\033[0m\n");
|
|
}
|
|
break;
|
|
|
|
case 4:
|
|
{
|
|
audio_play_file_record(QUA_DEV_ACW_STEREO);
|
|
ALOGD("\n\033[31m ######## [AUDIO]ACW playfile and ACW record! ########\033[0m\n");
|
|
}
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return QUA_SUCCESS;
|
|
}
|
|
|
|
static void signal_handler(int sig)
|
|
{
|
|
audio_stop_clr();
|
|
(void)sig;
|
|
}
|
|
|
|
static int audio_dev_init(void) {
|
|
qua_mm_device_t *mm_device = NULL;
|
|
QUA_CONST_CHAR *platform = QUA_SYS_MAKE_PLATFORM(QUA_SYS_CHIP_MC331x, QUA_SYS_OS_LINUX);
|
|
const qua_mm_module_t *audio_module = NULL;
|
|
qua_mm_system_t *system = NULL;
|
|
QUA_S32 ret = qua_mm_init(QUA_FALSE, platform, &system);
|
|
if (ret != QUA_SUCCESS || system == NULL) {
|
|
ALOGD("audio_dev_init module init fail");
|
|
return QUA_EINVAL;
|
|
}
|
|
|
|
ret = qua_mm_load_module(QUA_MM_MODULE_AUDIO, &audio_module);
|
|
if (ret != QUA_SUCCESS || audio_module == NULL) {
|
|
ALOGD("audio_dev_init get module fail");
|
|
return QUA_EINVAL;
|
|
}
|
|
|
|
ret = audio_module->open_device(audio_module, QUA_MM_AUDIO_DEV, 0, &mm_device);
|
|
if (ret != QUA_SUCCESS || mm_device == NULL) {
|
|
ALOGD("audio_dev_init open device fail");
|
|
return QUA_EINVAL;
|
|
}
|
|
|
|
g_audio_dev = (qua_mm_audio_device_t *)mm_device;
|
|
return QUA_SUCCESS;
|
|
}
|
|
|
|
static int audio_dev_deinit(void) {
|
|
g_audio_dev->parent.close(&g_audio_dev->parent);
|
|
g_audio_dev = NULL;
|
|
return QUA_SUCCESS;
|
|
}
|
|
|
|
int main(int argc, char * const argv[])
|
|
{
|
|
int cmd = 0;
|
|
int ret = -1;
|
|
|
|
ret = audio_dev_init();
|
|
if (ret != QUA_SUCCESS) {
|
|
printf("audio dev init err\n");
|
|
goto end;
|
|
}
|
|
|
|
if (argc > 1) {
|
|
cmd = atoi(argv[1]);
|
|
} else {
|
|
audio_record_play(QUA_DEV_ACW_STEREO);
|
|
(void)audio_dev_deinit();
|
|
return 0;
|
|
}
|
|
|
|
fcntl(0, F_SETFL, fcntl(0, F_GETFL, 0) | O_NONBLOCK);
|
|
signal(SIGINT, signal_handler);
|
|
signal(SIGTERM, signal_handler);
|
|
signal(SIGABRT, signal_handler);
|
|
|
|
sample_aio_test(cmd);
|
|
(void)audio_dev_deinit();
|
|
end:
|
|
return 0;
|
|
}
|