lai/gk-sdk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
master
gk-sdk/sample/common/sample_comm_audio.c
T

2038 lines
55 KiB
C
Raw Permalink Blame History

#include <stdlib.h>
#include <string.h>
#include <pthread.h>
#include "defines.h"
#include "xmedia_sys.h"
#include "xmedia_audio_ai.h"
#include "xmedia_audio_ao.h"
#include "xmedia_audio_adec.h"
#include "xmedia_audio_aenc.h"
#include "xmedia_audio_vqe.h"
#include "xmedia_audio_codec.h"
#include "xmedia_audio_codec_voice.h"
#include "xmedia_audio_codec_mp3.h"
#include "xmedia_audio_codec_aac.h"
#include "xmedia_audio_vqe_enhance_v1.h"
#include "xmedia_audio_vqe_enhance_v2.h"
#include "xmedia_audio_vqe_enhance_v3.h"
#include "xmedia_audio_vqe_detect.h"
#include "sample_comm_audio.h"
#define MAX_AI_CREATE_CHN_CNT 3
typedef struct {
ai_dev dev;
ai_chn chn;
pthread_t data_thd;
xmedia_bool running_flag;
xmedia_bool out_to_aenc;
xmedia_bool out_to_ao;
xmedia_bool out_to_file;
ao_dev dev_ao;
ao_chn chn_ao;
FILE** file;
} comm_ai_ctx;
typedef struct {
ao_dev_attr* attr;
ao_dev dev;
ao_chn chn;
sample_ao_frame* frm_info;
pthread_t data_thd;
xmedia_bool running_flag;
FILE** file;
} comm_ao_ctx;
typedef struct {
ao_dev dev;
ao_chn chn_ao;
adec_chn chn;
pthread_t input_thd;
pthread_t output_thd;
xmedia_bool input_running_flag;
xmedia_bool output_running_flag;
xmedia_bool send_to_ao;
audio_codec_type codec_type;
FILE** input_file;
FILE** output_file;
} comm_adec_ctx;
typedef struct {
ao_chn chn;
audio_channel channels;
audio_sample_rate samplerate;
audio_bit_depth bit_depth;
pthread_t input_thd;
pthread_t output_thd;
xmedia_bool input_running_flag;
xmedia_bool output_running_flag;
audio_codec_type codec_type;
FILE** input_file;
FILE** output_file;
} comm_aenc_ctx;
static comm_ai_ctx g_ai_ctx[3] = {0};
static comm_ao_ctx g_ao_ctx[3] = {0};
static comm_adec_ctx g_adec_ctx[ADEC_MAX_CHN_NUM] = {0};
static comm_aenc_ctx g_aenc_ctx[AENC_MAX_CHN_NUM] = {0};
static xmedia_bool g_share_mode_enable = XMEDIA_FALSE;
static xmedia_s32 regist_vqe_lib(xmedia_u32 mask, xmedia_u32 version, xmedia_bool res_enable)
{
xmedia_s32 ret = XMEDIA_FAILURE;
if (version == AI_VQE_ENHANCE_ATTR_VERSION_1) {
vqe_handle_v1 libv1 = {0};
if (mask & VQE_V1_MASK_HPF) {
libv1.hpf_handle = xmedia_vqe_v1_get_hpf_handle();
}
if (mask & VQE_V1_MASK_AEC) {
libv1.aec_handle = xmedia_vqe_v1_get_aec_handle();
}
if (mask & VQE_V1_MASK_ANR) {
libv1.anr_handle = xmedia_vqe_v1_get_anr_handle();
}
if (mask & VQE_V1_MASK_AGC) {
libv1.agc_handle = xmedia_vqe_v1_get_agc_handle();
}
if (mask & VQE_V1_MASK_VAD) {
libv1.vad_handle = xmedia_vqe_v1_get_vad_handle();
}
if (mask & VQE_V1_MASK_WNS) {
libv1.wns_handle = xmedia_vqe_v1_get_wns_handle();
}
if (mask & VQE_V1_MASK_EQ) {
libv1.eq_handle = xmedia_vqe_v1_get_eq_handle();
}
if (mask & VQE_V1_MASK_DEREVERB) {
libv1.dereverb_handle = xmedia_vqe_v1_get_dereverb_handle();
}
if(res_enable) {
libv1.resampler_handle = xmedia_vqe_v1_get_resampler_handle();
}
ret = xmedia_vqe_register_module(VQE_V1_LIB_MASK, &libv1);
} else if (version == AI_VQE_ENHANCE_ATTR_VERSION_2) {
vqe_handle_v2 libv2 = {0};
if (mask & VQE_V2_MASK_HPF) {
libv2.hpf_handle = xmedia_vqe_v2_get_hpf_handle();
}
if (mask & VQE_V2_MASK_AEC) {
libv2.aec_handle = xmedia_vqe_v2_get_aec_handle();
}
if (mask & VQE_V2_MASK_ANR) {
libv2.anr_handle = xmedia_vqe_v2_get_anr_handle();
}
if (mask & VQE_V2_MASK_AGC) {
libv2.agc_handle = xmedia_vqe_v2_get_agc_handle();
}
if (mask & VQE_V2_MASK_BF) {
libv2.bf_handle = xmedia_vqe_v2_get_bf_handle();
}
if (mask & VQE_V2_MASK_VAD) {
libv2.vad_handle = xmedia_vqe_v2_get_vad_handle();
}
if (mask & VQE_V2_MASK_WNS) {
libv2.wns_handle = xmedia_vqe_v2_get_wns_handle();
}
if (mask & VQE_V2_MASK_EQ) {
libv2.eq_handle = xmedia_vqe_v2_get_eq_handle();
}
if (mask & VQE_V2_MASK_DEREVERB) {
libv2.dereverb_handle = xmedia_vqe_v2_get_dereverb_handle();
}
if(res_enable) {
libv2.resampler_handle = xmedia_vqe_v2_get_resampler_handle();
}
ret = xmedia_vqe_register_module(VQE_V2_LIB_MASK, &libv2);
} else if (version == AI_VQE_ENHANCE_ATTR_VERSION_3) {
vqe_handle_v3 libv3 = {0};
if (mask & VQE_V3_MASK_HPF) {
libv3.hpf_handle = xmedia_vqe_v3_get_hpf_handle();
}
if (mask & VQE_V3_MASK_ANR) {
libv3.anr_handle = xmedia_vqe_v3_get_anr_handle();
}
if (mask & VQE_V3_MASK_AGC) {
libv3.agc_handle = xmedia_vqe_v3_get_agc_handle();
}
if (mask & VQE_V3_MASK_EQ) {
libv3.eq_handle = xmedia_vqe_v3_get_eq_handle();
}
if(res_enable) {
libv3.resampler_handle = xmedia_vqe_v3_get_resampler_handle();
}
ret = xmedia_vqe_register_module(VQE_V3_LIB_MASK, &libv3);
} else if (version == AI_VQE_DETECT_ATTR_VERSION_1) {
vqe_handle_detect libdet = {0};
if (mask & VQE_DETECT_MASK_HPF) {
libdet.hpf_handle = xmedia_vqe_detect_get_hpf_handle();
}
if (mask & VQE_DETECT_MASK_BCD) {
libdet.bcd_handle = xmedia_vqe_detect_get_bcd_handle();
}
if (mask & VQE_DETECT_MASK_VED) {
libdet.ved_handle = xmedia_vqe_detect_get_ved_handle();
}
if (mask & VQE_DETECT_MASK_SSL) {
libdet.ssl_handle = xmedia_vqe_detect_get_ssl_handle();
}
if (mask & VQE_DETECT_MASK_GBD) {
libdet.gbd_handle = xmedia_vqe_detect_get_gbd_handle();
}
ret = xmedia_vqe_register_module(VQE_DETECT_LIB_MASK, &libdet);
}
return ret;
}
static xmedia_s32 get_adec_attr(adec_attr* attr, sample_adec_config* ctx)
{
attr->in_buffer_size = 8096;
attr->out_frame_num = 8;
attr->package_mode = XMEDIA_FALSE;
attr->type = ctx->type;
attr->param = (decoder_param*)malloc(sizeof(decoder_param));
if (attr->param == XMEDIA_NULL) {
return XMEDIA_FAILURE;
}
memset(attr->param, 0, sizeof(decoder_param));
if (ctx->type == CODEC_TYPE_AAC) {
aac_decoder_config* decoder_config = (aac_decoder_config*)malloc(sizeof(aac_decoder_config));
if (decoder_config == XMEDIA_NULL) {
return XMEDIA_FAILURE;
}
memset(decoder_config, 0, sizeof(aac_decoder_config));
aac_dec_get_default_config(decoder_config);
aac_dec_get_default_param(attr->param, decoder_config);
} else if (ctx->type == CODEC_TYPE_MP3) {
mp3_decoder_config* decoder_config = (mp3_decoder_config*)malloc(sizeof(mp3_decoder_config));
if (decoder_config == XMEDIA_NULL) {
return XMEDIA_FAILURE;
}
memset(decoder_config, 0, sizeof(mp3_decoder_config));
mp3_dec_get_default_config(decoder_config);
mp3_dec_get_default_param(attr->param, decoder_config);
} else if (ctx->type == CODEC_TYPE_LPCM) {
voice_dec_get_default_param(attr->param, XMEDIA_NULL);
attr->param->desired_out_samplerate = ctx->sample_rate;
} else {
voice_decoder_config* decoder_config = (voice_decoder_config*)malloc(sizeof(voice_decoder_config));
if (decoder_config == XMEDIA_NULL) {
return XMEDIA_FAILURE;
}
memset(decoder_config, 0, sizeof(voice_decoder_config));
voice_dec_get_default_config(decoder_config);
voice_dec_get_default_param(attr->param, decoder_config);
decoder_config->format = ctx->format;
decoder_config->sample_rate = ctx->sample_rate;
}
return XMEDIA_SUCCESS;
}
static xmedia_s32 release_adec_attr(adec_attr* attr)
{
if (!attr->param) {
return XMEDIA_SUCCESS;
}
if (attr->param->decoder_config) {
free(attr->param->decoder_config);
attr->param->decoder_config = XMEDIA_NULL;
}
free(attr->param);
attr->param = XMEDIA_NULL;
return XMEDIA_SUCCESS;
}
static xmedia_s32 get_recommend_bit_rate(xmedia_u32 sample_rate)
{
xmedia_s32 recommend_rate = 0;
if ((sample_rate == 8000) || (sample_rate == 11025) || (sample_rate == 12000)) {
recommend_rate = 32000;
} else {
recommend_rate = 128000;
}
return recommend_rate;
}
static xmedia_s32 get_aenc_attr(aenc_attr* attr, sample_aenc_config* ctx)
{
attr->in_buffer_size = 8096;
attr->out_frame_num = 8;
attr->type = ctx->type;
attr->param = (encoder_param*)malloc(sizeof(encoder_param));
if (attr->param == XMEDIA_NULL) {
return XMEDIA_FAILURE;
}
memset(attr->param, 0, sizeof(encoder_param));
if (ctx->type == CODEC_TYPE_AAC) {
aac_encoder_config* encoder_config = (aac_encoder_config*)malloc(sizeof(aac_encoder_config));
if (encoder_config == XMEDIA_NULL) {
return XMEDIA_FAILURE;
}
memset(encoder_config, 0, sizeof(aac_encoder_config));
aac_enc_get_default_config(encoder_config);
encoder_config->sample_rate = ctx->sample_rate;
encoder_config->channels = ctx->channels;
encoder_config->bit_width = ctx->bit_depth;
encoder_config->band_width = ctx->sample_rate / 2;
encoder_config->bit_rate = 48000;
aac_enc_get_default_param(attr->param, encoder_config);
} else if (ctx->type == CODEC_TYPE_MP3) {
mp3_encoder_config* encoder_config = (mp3_encoder_config*)malloc(sizeof(mp3_encoder_config));
if (encoder_config == XMEDIA_NULL) {
return XMEDIA_FAILURE;
}
memset(encoder_config, 0, sizeof(mp3_encoder_config));
mp3_enc_get_default_config(encoder_config);
encoder_config->sample_rate = ctx->sample_rate;
encoder_config->channels = ctx->channels;
encoder_config->bit_per_sample = ctx->bit_depth;
encoder_config->bit_rate = get_recommend_bit_rate(ctx->sample_rate);
mp3_enc_get_default_param(attr->param, encoder_config);
} else if (ctx->type == CODEC_TYPE_LPCM) {
voice_encoder_config* encoder_config = (voice_encoder_config*)malloc(sizeof(voice_encoder_config));
if (encoder_config == XMEDIA_NULL) {
return XMEDIA_FAILURE;
}
memset(encoder_config, 0, sizeof(voice_encoder_config));
voice_enc_get_default_config(encoder_config);
voice_enc_get_default_param(attr->param, encoder_config);
attr->param->sample_rate = ctx->sample_rate;
attr->param->channels = ctx->channels;
attr->param->bit_per_sample = ctx->bit_depth;
} else {
voice_encoder_config* encoder_config = (voice_encoder_config*)malloc(sizeof(voice_encoder_config));
if (encoder_config == XMEDIA_NULL) {
return XMEDIA_FAILURE;
}
memset(encoder_config, 0, sizeof(voice_encoder_config));
voice_enc_get_default_config(encoder_config);
encoder_config->format = ctx->format;
voice_enc_get_default_param(attr->param, encoder_config);
}
return XMEDIA_SUCCESS;
}
static xmedia_s32 release_aenc_attr(aenc_attr* attr)
{
if (!attr->param) {
return XMEDIA_SUCCESS;
}
if (attr->param->encoder_config) {
free(attr->param->encoder_config);
attr->param->encoder_config = XMEDIA_NULL;
}
free(attr->param);
attr->param = XMEDIA_NULL;
return XMEDIA_SUCCESS;
}
xmedia_s32 ai_get_default_attr(ai_dev dev, ai_dev_attr* dev_attr)
{
xmedia_s32 ret;
ret = xmedia_ai_get_default_attr(dev, dev_attr);
CHECK_RET(ret, "xmedia_ai_get_default_attr");
return ret;
}
static xmedia_s32 ai_start_dev(sample_ai_config* config)
{
xmedia_s32 ret;
ret = xmedia_ai_set_dev_attr(config->dev, &config->dev_attr);
CHECK_RET(ret, "xmedia_ai_set_dev_attr");
ret = xmedia_ai_enable_dev(config->dev);
CHECK_RET(ret, "xmedia_ai_enable_dev");
return ret;
}
static xmedia_s32 ai_start_chn(sample_ai_config* config)
{
xmedia_s32 i;
xmedia_s32 ret;
xmedia_u32 chn_cnt;
chn_cnt = (config->dev_attr.mode == AUDIO_DEV_WORK_MODE_QUEUE) ? 1 : config->dev_attr.channels;
chn_cnt = (chn_cnt > MAX_AI_CREATE_CHN_CNT) ? MAX_AI_CREATE_CHN_CNT : chn_cnt;
for (i = 0; i < chn_cnt; i++) {
ret = xmedia_ai_create_chn(config->dev, i, &config->chn_attr);
CHECK_RET(ret, "xmedia_ai_create_chn");
if (config->vqe_enable && g_share_mode_enable == XMEDIA_FALSE) {
ret = xmedia_ai_set_ec_source(config->dev, i, config->source, config->ec_chn_id);
CHECK_RET(ret, "xmedia_ai_set_ec_source");
ret = xmedia_ai_set_vqe_attr(config->dev, i, &config->vqe_attr);
CHECK_RET(ret, "xmedia_ai_create_chn");
ret = xmedia_ai_enable_vqe(config->dev, i);
CHECK_RET(ret, "xmedia_ai_enable_vqe");
}
ret = xmedia_ai_enable_chn(config->dev, i);
CHECK_RET(ret, "xmedia_ai_enable_chn");
}
return ret;
}
static xmedia_s32 ai_stop_dev(sample_ai_config* config)
{
xmedia_s32 ret;
ret = xmedia_ai_disable_dev(config->dev);
CHECK_RET(ret, "xmedia_ai_disable_dev");
return ret;
}
static xmedia_s32 ai_stop_chn(sample_ai_config* config)
{
xmedia_s32 i;
xmedia_s32 ret;
xmedia_u32 chn_cnt;
chn_cnt = (config->dev_attr.mode == AUDIO_DEV_WORK_MODE_QUEUE) ? 1 : config->dev_attr.channels;
chn_cnt = (chn_cnt > MAX_AI_CREATE_CHN_CNT) ? MAX_AI_CREATE_CHN_CNT : chn_cnt;
for (i = 0; i < chn_cnt; i++) {
if (config->vqe_enable && g_share_mode_enable == XMEDIA_FALSE) {
ret = xmedia_ai_disable_vqe(config->dev, i);
CHECK_RET(ret, "xmedia_ai_disable_vqe");
}
ret = xmedia_ai_disable_chn(config->dev, i);
CHECK_RET(ret, "xmedia_ai_disable_chn");
ret = xmedia_ai_destroy_chn(config->dev, i);
CHECK_RET(ret, "xmedia_ai_create_chn");
}
return ret;
}
static xmedia_s32 ai_set_volume(sample_ai_config* config, xmedia_s32 volume)
{
xmedia_s32 i;
xmedia_s32 ret;
xmedia_u32 chn_cnt;
chn_cnt = (config->dev_attr.mode == AUDIO_DEV_WORK_MODE_QUEUE) ? 1 : config->dev_attr.channels;
for (i = 0; i < chn_cnt; i++) {
ret = xmedia_ai_set_volume(config->dev, i, volume);
CHECK_RET(ret, "xmedia_ai_set_volume");
}
return ret;
}
static xmedia_s32 ai_get_volume(sample_ai_config* config, xmedia_s32* volume)
{
xmedia_s32 i;
xmedia_s32 ret;
xmedia_u32 chn_cnt;
chn_cnt = (config->dev_attr.mode == AUDIO_DEV_WORK_MODE_QUEUE) ? 1 : config->dev_attr.channels;
for (i = 0; i < chn_cnt; i++) {
ret = xmedia_ai_get_volume(config->dev, i, volume);
CHECK_RET(ret, "xmedia_ai_get_volume");
}
return ret;
}
static xmedia_s32 ai_set_ec_source(sample_ai_config* config)
{
xmedia_s32 i;
xmedia_s32 ret;
xmedia_u32 chn_cnt;
chn_cnt = (config->dev_attr.mode == AUDIO_DEV_WORK_MODE_QUEUE) ? 1 : config->dev_attr.channels;
for (i = 0; i < chn_cnt; i++) {
ret = xmedia_ai_set_ec_source(config->dev, i, config->source, config->ec_chn_id);
CHECK_RET(ret, "xmedia_ai_set_ec_source");
}
return ret;
}
static xmedia_s32 ai_enable_org_frame(sample_ai_config* config, xmedia_bool enable)
{
xmedia_s32 i;
xmedia_s32 ret;
xmedia_u32 chn_cnt;
chn_cnt = (config->dev_attr.mode == AUDIO_DEV_WORK_MODE_QUEUE) ? 1 : config->dev_attr.channels;
for (i = 0; i < chn_cnt; i++) {
if (enable) {
ret = xmedia_ai_enable_origin_frame(config->dev, i);
CHECK_RET(ret, "xmedia_ai_enable_origin_frame");
} else {
ret = xmedia_ai_disable_origin_frame(config->dev, i);
CHECK_RET(ret, "xmedia_ai_disable_origin_frame");
}
}
return ret;
}
static xmedia_s32 ai_enable_ec_frame(sample_ai_config* config, xmedia_bool enable)
{
xmedia_s32 i;
xmedia_s32 ret;
xmedia_u32 chn_cnt;
chn_cnt = (config->dev_attr.mode == AUDIO_DEV_WORK_MODE_QUEUE) ? 1 : config->dev_attr.channels;
for (i = 0; i < chn_cnt; i++) {
if (enable) {
ret = xmedia_ai_enable_ec_frame(config->dev, i);
CHECK_RET(ret, "xmedia_ai_enable_ec_frame");
} else {
ret = xmedia_ai_disable_ec_frame(config->dev, i);
CHECK_RET(ret, "xmedia_ai_disable_ec_frame");
}
}
return ret;
}
static xmedia_void *ai_data_thread(void *arg)
{
xmedia_s32 ret;
xmedia_s32 i;
xmedia_s32 write_size = 0;
xmedia_s32 time_out = 1000;
audio_frame frame;
audio_ext_frame ext_frame;
comm_ai_ctx* ctx = (comm_ai_ctx*)arg;
xmedia_u32 count = 0;
int ffd = -1;
while (ctx->running_flag) {
ret = xmedia_ai_acquire_frame(ctx->dev, ctx->chn, &frame, &ext_frame, time_out);
if (ret != XMEDIA_SUCCESS) {
continue;
}
if (ctx->file && ctx->file[ctx->chn]) {
write_size = ((frame.channels > 1) && (frame.interleaved == XMEDIA_FALSE)) ? (frame.size / frame.channels) : frame.size;
if (frame.bit_depth == AUDIO_BIT_DEPTH_24) {
xmedia_void* write_data;
for (i = 0; i < write_size; i++) {
write_data = frame.data + i;
if (i % 4 == 0) {
continue;
}
fwrite(write_data, 1, 1, ctx->file[ctx->chn]);
}
} else {
fwrite(frame.data, 1, write_size, ctx->file[ctx->chn]);
if ((count % 10) == 0) {
ffd = fileno(ctx->file[ctx->chn]);
if (ffd != -1)
fsync(ffd);
}
}
}
if (ctx->out_to_aenc) {
xmedia_aenc_send_frame(ctx->chn, &frame, -1);
}
if (ctx->out_to_ao) {
xmedia_ao_send_frame(ctx->dev_ao, ctx->chn_ao, &frame, -1);
}
xmedia_ai_release_frame(ctx->dev, ctx->chn, &frame, &ext_frame);
}
return (xmedia_void*)XMEDIA_NULL;
}
static xmedia_s32 ai_create_output_thread_to_aenc(sample_ai_config* config)
{
xmedia_s32 i;
xmedia_s32 ret;
xmedia_u32 chn_cnt;
chn_cnt = (config->dev_attr.mode == AUDIO_DEV_WORK_MODE_QUEUE) ? 1 : config->dev_attr.channels;
chn_cnt = (chn_cnt > MAX_AI_CREATE_CHN_CNT) ? MAX_AI_CREATE_CHN_CNT : chn_cnt;
for (i = 0; i < chn_cnt; i++) {
g_ai_ctx[i].dev = config->dev;
g_ai_ctx[i].chn = i;
g_ai_ctx[i].out_to_aenc = XMEDIA_TRUE;
g_ai_ctx[i].running_flag = XMEDIA_TRUE;
ret = pthread_create(&g_ai_ctx[i].data_thd, 0, ai_data_thread, &g_ai_ctx[i]);
CHECK_RET(ret, "pthread_create");
}
return XMEDIA_SUCCESS;
}
static xmedia_s32 ai_create_output_thread_to_ao(sample_ai_config* config, ao_dev dev, ao_chn chn)
{
xmedia_s32 i;
xmedia_s32 ret;
xmedia_u32 chn_cnt;
chn_cnt = (config->dev_attr.mode == AUDIO_DEV_WORK_MODE_QUEUE) ? 1 : config->dev_attr.channels;
chn_cnt = (chn_cnt > MAX_AI_CREATE_CHN_CNT) ? MAX_AI_CREATE_CHN_CNT : chn_cnt;
for (i = 0; i < chn_cnt; i++) {
g_ai_ctx[i].dev = config->dev;
g_ai_ctx[i].chn = i;
g_ai_ctx[i].out_to_ao = XMEDIA_TRUE;
g_ai_ctx[i].dev_ao = dev;
g_ai_ctx[i].chn_ao = chn;
g_ai_ctx[i].running_flag = XMEDIA_TRUE;
ret = pthread_create(&g_ai_ctx[i].data_thd, 0, ai_data_thread, &g_ai_ctx[i]);
CHECK_RET(ret, "pthread_create");
}
return XMEDIA_SUCCESS;
}
static xmedia_s32 ai_create_output_thread_to_file(sample_ai_config* config, FILE** file)
{
xmedia_s32 i;
xmedia_s32 ret;
xmedia_u32 chn_cnt;
chn_cnt = (config->dev_attr.mode == AUDIO_DEV_WORK_MODE_QUEUE) ? 1 : config->dev_attr.channels;
chn_cnt = (chn_cnt > MAX_AI_CREATE_CHN_CNT) ? MAX_AI_CREATE_CHN_CNT : chn_cnt;
for (i = 0; i < chn_cnt; i++) {
g_ai_ctx[i].chn = i;
g_ai_ctx[i].file = file;
g_ai_ctx[i].running_flag = XMEDIA_TRUE;
g_ai_ctx[i].dev = config->dev;
ret = pthread_create(&g_ai_ctx[i].data_thd, 0, ai_data_thread, &g_ai_ctx[i]);
CHECK_RET(ret, "pthread_create");
}
return XMEDIA_SUCCESS;
}
static xmedia_s32 ai_destroy_output_thread_to_aenc(sample_ai_config* config)
{
xmedia_s32 i;
xmedia_u32 chn_cnt;
chn_cnt = (config->dev_attr.mode == AUDIO_DEV_WORK_MODE_QUEUE) ? 1 : config->dev_attr.channels;
chn_cnt = (chn_cnt > MAX_AI_CREATE_CHN_CNT) ? MAX_AI_CREATE_CHN_CNT : chn_cnt;
for (i = 0; i < chn_cnt; i++) {
if (g_ai_ctx[i].data_thd) {
g_ai_ctx[i].running_flag = XMEDIA_FALSE;
g_ai_ctx[i].out_to_aenc = XMEDIA_FALSE;
pthread_join(g_ai_ctx[i].data_thd, XMEDIA_NULL);
}
}
return XMEDIA_SUCCESS;
}
static xmedia_s32 ai_destroy_output_thread_to_ao(sample_ai_config* config)
{
xmedia_s32 i;
xmedia_u32 chn_cnt;
chn_cnt = (config->dev_attr.mode == AUDIO_DEV_WORK_MODE_QUEUE) ? 1 : config->dev_attr.channels;
chn_cnt = (chn_cnt > MAX_AI_CREATE_CHN_CNT) ? MAX_AI_CREATE_CHN_CNT : chn_cnt;
for (i = 0; i < chn_cnt; i++) {
if (g_ai_ctx[i].data_thd) {
g_ai_ctx[i].running_flag = XMEDIA_FALSE;
g_ai_ctx[i].out_to_ao = XMEDIA_FALSE;
pthread_join(g_ai_ctx[i].data_thd, XMEDIA_NULL);
}
}
return XMEDIA_SUCCESS;
}
static xmedia_s32 ai_destroy_output_thread_to_file(sample_ai_config* config)
{
xmedia_s32 i;
xmedia_u32 chn_cnt;
chn_cnt = (config->dev_attr.mode == AUDIO_DEV_WORK_MODE_QUEUE) ? 1 : config->dev_attr.channels;
chn_cnt = (chn_cnt > MAX_AI_CREATE_CHN_CNT) ? MAX_AI_CREATE_CHN_CNT : chn_cnt;
for (i = 0; i < chn_cnt; i++) {
if (g_ai_ctx[i].data_thd) {
g_ai_ctx[i].running_flag = XMEDIA_FALSE;
pthread_join(g_ai_ctx[i].data_thd, XMEDIA_NULL);
g_ai_ctx[i].file = XMEDIA_NULL;
}
}
return XMEDIA_SUCCESS;
}
xmedia_s32 ao_get_default_attr(ao_dev dev, ao_dev_attr* dev_attr)
{
xmedia_s32 ret;
ret = xmedia_ao_get_default_attr(dev, dev_attr);
CHECK_RET(ret, "xmedia_ao_get_default_attr");
return ret;
}
static xmedia_s32 ao_start_dev(sample_ao_config* config)
{
xmedia_s32 ret;
ret = xmedia_ao_set_dev_attr(config->dev, &config->dev_attr);
CHECK_RET(ret, "xmedia_ao_set_dev_attr");
ret = xmedia_ao_enable_dev(config->dev);
CHECK_RET(ret, "xmedia_ao_set_dev_attr");
return ret;
}
static xmedia_s32 ao_start_chn(sample_ao_config* config)
{
xmedia_s32 i;
xmedia_s32 ret;
xmedia_u32 chn_cnt;
chn_cnt = (config->dev_attr.mode == AUDIO_DEV_WORK_MODE_QUEUE) ? 1 : config->dev_attr.channels;
for (i = 0; i < chn_cnt; i++) {
ret = xmedia_ao_create_chn(config->dev, i);
CHECK_RET(ret, "xmedia_ao_create_chn");
if (config->vqe_enable) {
ret = xmedia_ao_set_vqe_attr(config->dev, i, &config->vqe_attr);
CHECK_RET(ret, "xmedia_ao_set_vqe_attr");
ret = xmedia_ao_enable_vqe(config->dev, i);
CHECK_RET(ret, "xmedia_ao_enable_vqe");
}
if (config->binder_src == MOD_ID_AI || config->binder_src == MOD_ID_ADEC) {
ret = xmedia_ao_bind(config->dev, i, config->binder_src, i);
CHECK_RET(ret, "xmedia_ao_bind");
}
ret = xmedia_ao_enable_chn(config->dev, i);
CHECK_RET(ret, "xmedia_ao_enable_chn");
}
return ret;
}
static xmedia_s32 ao_stop_dev(sample_ao_config* config)
{
xmedia_s32 ret;
ret = xmedia_ao_disable_dev(config->dev);
CHECK_RET(ret, "xmedia_ai_disable_dev");
return ret;
}
static xmedia_s32 ao_stop_chn(sample_ao_config* config)
{
xmedia_s32 i;
xmedia_s32 ret;
xmedia_u32 chn_cnt;
chn_cnt = (config->dev_attr.mode == AUDIO_DEV_WORK_MODE_QUEUE) ? 1 : config->dev_attr.channels;
for (i = 0; i < chn_cnt; i++) {
if (config->vqe_enable) {
ret = xmedia_ao_disable_vqe(config->dev, i);
CHECK_RET(ret, "xmedia_ao_disable_vqe");
}
ret = xmedia_ao_disable_chn(config->dev, i);
CHECK_RET(ret, "xmedia_ao_disable_vqe");
ret = xmedia_ao_destroy_chn(config->dev, i);
CHECK_RET(ret, "xmedia_ao_disable_vqe");
}
return ret;
}
static xmedia_s32 ao_set_volume(sample_ao_config* config, xmedia_s32 volume)
{
xmedia_s32 i;
xmedia_s32 ret;
xmedia_u32 chn_cnt;
chn_cnt = (config->dev_attr.mode == AUDIO_DEV_WORK_MODE_QUEUE) ? 1 : config->dev_attr.channels;
for (i = 0; i < chn_cnt; i++) {
ret = xmedia_ao_set_volume(config->dev, i, volume);
CHECK_RET(ret, "xmedia_ao_set_volume");
}
return ret;
}
static xmedia_s32 ao_get_volume(sample_ao_config* config, xmedia_s32* volume)
{
xmedia_s32 i;
xmedia_s32 ret;
xmedia_u32 chn_cnt;
chn_cnt = (config->dev_attr.mode == AUDIO_DEV_WORK_MODE_QUEUE) ? 1 : config->dev_attr.channels;
for (i = 0; i < chn_cnt; i++) {
ret = xmedia_ao_get_volume(config->dev, i, volume);
CHECK_RET(ret, "xmedia_ao_get_volume");
}
return ret;
}
static xmedia_s32 ao_set_dev_params(sample_ao_config* config, ao_dev_param_cmd cmd, xmedia_void* param)
{
xmedia_s32 ret;
ret = xmedia_ao_set_dev_param(config->dev, cmd, param);
CHECK_RET(ret, "xmedia_ao_set_dev_param");
return ret;
}
static xmedia_void *ao_data_thread(void *arg)
{
xmedia_s32 ret;
xmedia_s32 time_out = -1;
audio_frame frame;
comm_ao_ctx* ctx = (comm_ao_ctx*)arg;
xmedia_s32 send_size;
xmedia_char* send_buffer = XMEDIA_NULL;
frame.bit_depth = ctx->frm_info->frm_bit;
frame.channels = ctx->frm_info->frm_chn;
frame.interleaved = XMEDIA_TRUE;
frame.sample_rate = ctx->frm_info->frm_rate;
frame.timestamp = -1;
send_size = frame.sample_rate * 10 * frame.channels * sizeof(xmedia_s16) / 1000;//10ms
send_buffer = malloc(send_size);
if(send_buffer == XMEDIA_NULL) {
return (xmedia_void*)XMEDIA_NULL;
}
frame.data = (xmedia_void*)send_buffer;
while (ctx->running_flag) {
ret = fread(send_buffer, 1, send_size, ctx->file[ctx->chn]);
if (ret < send_size) {
rewind(ctx->file[ctx->chn]);
}
frame.size = ret;
xmedia_ao_send_frame(ctx->dev, ctx->chn, &frame, time_out);
}
free(send_buffer);
return (xmedia_void*)XMEDIA_NULL;
}
static xmedia_s32 ao_create_input_thread_from_file(sample_ao_config* config, FILE** file)
{
xmedia_s32 i;
xmedia_s32 ret;
xmedia_u32 chn_cnt;
chn_cnt = (config->dev_attr.mode == AUDIO_DEV_WORK_MODE_QUEUE) ? 1 : config->dev_attr.channels;
for (i = 0; i < chn_cnt; i++) {
g_ao_ctx[i].dev = config->dev;
g_ao_ctx[i].chn = i;
g_ao_ctx[i].file = file;
g_ao_ctx[i].attr = &config->dev_attr;
g_ao_ctx[i].frm_info = &config->frame_info;
g_ao_ctx[i].running_flag = XMEDIA_TRUE;
ret = pthread_create(&g_ao_ctx[i].data_thd, 0, ao_data_thread, &g_ao_ctx[i]);
CHECK_RET(ret, "pthread_create");
}
return XMEDIA_SUCCESS;
}
static xmedia_s32 ao_destroy_input_thread_from_file(sample_ao_config* config)
{
xmedia_s32 i;
xmedia_u32 chn_cnt;
chn_cnt = (config->dev_attr.mode == AUDIO_DEV_WORK_MODE_QUEUE) ? 1 : config->dev_attr.channels;
for (i = 0; i < chn_cnt; i++) {
if (g_ao_ctx[i].data_thd) {
g_ao_ctx[i].running_flag = XMEDIA_FALSE;
pthread_join(g_ao_ctx[i].data_thd, XMEDIA_NULL);
g_ao_ctx[i].file[i] = XMEDIA_NULL;
}
}
return XMEDIA_SUCCESS;
}
static xmedia_s32 adec_register_lib(audio_codec_type type)
{
xmedia_s32 ret = XMEDIA_FAILURE;
switch (type) {
case CODEC_TYPE_G711:
ret = xmedia_adec_register(CODEC_MASK_G711, xmedia_g711_dec_get_handle());
break;
case CODEC_TYPE_G726:
ret = xmedia_adec_register(CODEC_MASK_G726, xmedia_g726_dec_get_handle());
break;
case CODEC_TYPE_ADPCM:
ret = xmedia_adec_register(CODEC_MASK_ADPCM, xmedia_adpcm_dec_get_handle());
break;
case CODEC_TYPE_AAC:
ret = xmedia_adec_register(CODEC_MASK_AAC, xmedia_aac_dec_get_handle());
break;
case CODEC_TYPE_MP3:
ret = xmedia_adec_register(CODEC_MASK_MP3, xmedia_mp3_dec_get_handle());
break;
case CODEC_TYPE_LPCM:
ret = xmedia_adec_register(CODEC_MASK_LPCM, xmedia_lpcm_dec_get_handle());
break;
default:
break;
}
return ret;
}
static xmedia_s32 adec_unregister_lib(audio_codec_type type)
{
xmedia_s32 ret = XMEDIA_FAILURE;
switch (type) {
case CODEC_TYPE_G711:
ret = xmedia_adec_unregister(CODEC_MASK_G711);
break;
case CODEC_TYPE_G726:
ret = xmedia_adec_unregister(CODEC_MASK_G726);
break;
case CODEC_TYPE_ADPCM:
ret = xmedia_adec_unregister(CODEC_MASK_ADPCM);
break;
case CODEC_TYPE_AAC:
ret = xmedia_adec_unregister(CODEC_MASK_AAC);
break;
case CODEC_TYPE_MP3:
ret = xmedia_adec_unregister(CODEC_MASK_MP3);
break;
case CODEC_TYPE_LPCM:
ret = xmedia_adec_unregister(CODEC_MASK_LPCM);
break;
default:
break;
}
return ret;
}
static xmedia_s32 adec_start_chn(sample_adec_config* config)
{
xmedia_s32 ret;
adec_attr attr;
ret = get_adec_attr(&attr, config);
CHECK_RET(ret, "get_adec_attr");
ret = xmedia_adec_create_chn(config->chn, (const adec_attr*)&attr);
CHECK_RET(ret, "xmedia_adec_create_chn");
ret = release_adec_attr(&attr);
CHECK_RET(ret, "release_adec_attr");
return ret;
}
static xmedia_s32 adec_stop_chn(sample_adec_config* config)
{
xmedia_s32 ret;
ret = xmedia_adec_destroy_chn(config->chn);
CHECK_RET(ret, "xmedia_adec_destroy_chn");
return ret;
}
static xmedia_void *adec_input_data_thread(void *arg)
{
xmedia_s32 ret = XMEDIA_SUCCESS;
xmedia_s32 time_out = 100;
xmedia_u32 send_cnt = 0;
xmedia_s32 read_size = 0;
xmedia_u32 head_size = 0;
xmedia_bool voice_type = XMEDIA_FALSE;
audio_stream stream;
comm_adec_ctx* ctx = (comm_adec_ctx*)arg;
xmedia_s32 send_size;
xmedia_uchar send_buffer[4096];
send_size = 1024;
//for voice type, we need add 4 bytes head
if ((ctx->codec_type == CODEC_TYPE_G711) || (ctx->codec_type == CODEC_TYPE_G726)) {
voice_type = XMEDIA_TRUE;
head_size = 4;
//send size must be multiples of 80 for voice type
send_size = 320;
}
while (ctx->input_running_flag) {
if (ret == XMEDIA_SUCCESS) {
read_size = fread(send_buffer + head_size, 1, send_size, ctx->input_file[ctx->chn]);
if (read_size <= 0) {
rewind(ctx->input_file[ctx->chn]);
continue;
}
if (voice_type) {
send_buffer[0] = 0x00; //sync byte
send_buffer[1] = 0x01; //sync byte
send_buffer[2] = (xmedia_uchar)((read_size / 2) & 0x00ff); //samples count low bit(0 ~ 7)
send_buffer[3] = (xmedia_uchar)(((read_size / 2) & 0xff00) >> 8); //samples count high bit(8 ~ 15)
}
}
stream.len = read_size + head_size;
stream.index = send_cnt;
stream.data = (xmedia_void*)send_buffer;
stream.timestamp = ((send_cnt == 0) ? 0 : -1);
ret = xmedia_adec_send_stream(ctx->chn, &stream, time_out);
if (ret == XMEDIA_SUCCESS) {
send_cnt++;
}
}
return (xmedia_void*)XMEDIA_NULL;
}
static xmedia_void *adec_output_data_thread(void *arg)
{
xmedia_s32 ret;
xmedia_s32 time_out = 1000;
audio_frame frame;
comm_adec_ctx* ctx = (comm_adec_ctx*)arg;
while (ctx->output_running_flag) {
ret = xmedia_adec_get_frame(ctx->chn, &frame, time_out);
if (ret != XMEDIA_SUCCESS) {
continue;
}
if (ctx->output_file && ctx->output_file[ctx->chn]) {
fwrite(frame.data, 1, frame.size, ctx->output_file[ctx->chn]);
}
if (ctx->send_to_ao) {
xmedia_ao_send_frame(ctx->dev, ctx->chn_ao, &frame, time_out);
}
xmedia_adec_release_frame(ctx->chn, &frame);
}
return (xmedia_void*)XMEDIA_NULL;
}
static xmedia_s32 adec_create_input_thread_from_file(sample_adec_config* config, FILE** file)
{
xmedia_s32 ret;
g_adec_ctx[config->chn].chn = config->chn;
g_adec_ctx[config->chn].input_file = file;
g_adec_ctx[config->chn].input_running_flag = XMEDIA_TRUE;
g_adec_ctx[config->chn].codec_type = config->type;
ret = pthread_create(&g_adec_ctx[config->chn].input_thd, 0, adec_input_data_thread, &g_adec_ctx[config->chn]);
CHECK_RET(ret, "pthread_create");
return XMEDIA_SUCCESS;
}
static xmedia_s32 adec_destroy_input_thread_from_file(sample_adec_config* config)
{
g_adec_ctx[config->chn].input_running_flag = XMEDIA_FALSE;
pthread_join(g_adec_ctx[config->chn].input_thd, XMEDIA_NULL);
g_adec_ctx[config->chn].input_file = XMEDIA_NULL;
return XMEDIA_SUCCESS;
}
static xmedia_s32 adec_create_output_thread_to_ao(sample_adec_config* config, ao_dev dev, ao_chn chn)
{
xmedia_s32 ret;
g_adec_ctx[config->chn].chn = config->chn;
g_adec_ctx[config->chn].dev = dev;
g_adec_ctx[config->chn].chn_ao = chn;
g_adec_ctx[config->chn].send_to_ao = XMEDIA_TRUE;
g_adec_ctx[config->chn].output_running_flag = XMEDIA_TRUE;
ret = pthread_create(&g_adec_ctx[config->chn].output_thd, 0, adec_output_data_thread, &g_adec_ctx[config->chn]);
CHECK_RET(ret, "pthread_create");
return XMEDIA_SUCCESS;
}
static xmedia_s32 adec_destroy_output_thread_to_ao(sample_adec_config* config)
{
g_adec_ctx[config->chn].output_running_flag = XMEDIA_FALSE;
g_adec_ctx[config->chn].send_to_ao = XMEDIA_FALSE;
pthread_join(g_adec_ctx[config->chn].output_thd, XMEDIA_NULL);
return XMEDIA_SUCCESS;
}
static xmedia_s32 adec_create_output_thread_to_file(sample_adec_config* config, FILE** output_file)
{
xmedia_s32 ret;
g_adec_ctx[config->chn].chn = config->chn;
g_adec_ctx[config->chn].output_file = output_file;
g_adec_ctx[config->chn].output_running_flag = XMEDIA_TRUE;
ret = pthread_create(&g_adec_ctx[config->chn].output_thd, 0, adec_output_data_thread, &g_adec_ctx[config->chn]);
CHECK_RET(ret, "pthread_create");
return XMEDIA_SUCCESS;
}
static xmedia_s32 adec_destroy_output_thread_to_file(sample_adec_config* config)
{
g_adec_ctx[config->chn].output_running_flag = XMEDIA_FALSE;
g_adec_ctx[config->chn].send_to_ao = XMEDIA_FALSE;
pthread_join(g_adec_ctx[config->chn].output_thd, XMEDIA_NULL);
g_adec_ctx[config->chn].output_file = XMEDIA_NULL;
return XMEDIA_SUCCESS;
}
static xmedia_s32 aenc_register_lib(audio_codec_type type)
{
xmedia_s32 ret = XMEDIA_FAILURE;
switch (type) {
case CODEC_TYPE_G711:
ret = xmedia_aenc_register(CODEC_MASK_G711, xmedia_g711_enc_get_handle());
break;
case CODEC_TYPE_G726:
ret = xmedia_aenc_register(CODEC_MASK_G726, xmedia_g726_enc_get_handle());
break;
case CODEC_TYPE_ADPCM:
ret = xmedia_aenc_register(CODEC_MASK_ADPCM, xmedia_adpcm_enc_get_handle());
break;
case CODEC_TYPE_AAC:
ret = xmedia_aenc_register(CODEC_MASK_AAC, xmedia_aac_enc_get_handle());
break;
case CODEC_TYPE_MP3:
ret = xmedia_aenc_register(CODEC_MASK_MP3, xmedia_mp3_enc_get_handle());
break;
case CODEC_TYPE_LPCM:
ret = xmedia_aenc_register(CODEC_MASK_LPCM, xmedia_lpcm_enc_get_handle());
break;
default:
break;
}
return ret;
}
static xmedia_s32 aenc_unregister_lib(audio_codec_type type)
{
xmedia_s32 ret = XMEDIA_FAILURE;
switch (type) {
case CODEC_TYPE_G711:
ret = xmedia_aenc_unregister(CODEC_MASK_G711);
break;
case CODEC_TYPE_G726:
ret = xmedia_aenc_unregister(CODEC_MASK_G726);
break;
case CODEC_TYPE_ADPCM:
ret = xmedia_aenc_unregister(CODEC_MASK_ADPCM);
break;
case CODEC_TYPE_AAC:
ret = xmedia_aenc_unregister(CODEC_MASK_AAC);
break;
case CODEC_TYPE_MP3:
ret = xmedia_aenc_unregister(CODEC_MASK_MP3);
break;
case CODEC_TYPE_LPCM:
ret = xmedia_aenc_unregister(CODEC_MASK_LPCM);
break;
default:
break;
}
return ret;
}
static xmedia_s32 aenc_start_chn(sample_aenc_config* config)
{
xmedia_s32 ret;
aenc_attr attr;
ret = get_aenc_attr(&attr, config);
CHECK_RET(ret, "get_aenc_attr");
ret = xmedia_aenc_create_chn(config->chn, (const aenc_attr*)&attr);
CHECK_RET(ret, "xmedia_aenc_create_chn");
if (config->binder_src == MOD_ID_AI) {
ret = xmedia_aenc_bind(config->chn, config->binder_dev, 0);
CHECK_RET(ret, "xmedia_aenc_binder");
}
ret = release_aenc_attr(&attr);
CHECK_RET(ret, "release_aenc_attr");
return ret;
}
static xmedia_s32 aenc_stop_chn(sample_aenc_config* config)
{
xmedia_s32 ret;
if (config->binder_src == MOD_ID_AI) {
ret = xmedia_aenc_unbind(config->chn, config->binder_dev, 0);
CHECK_RET(ret, "xmedia_aenc_binder");
}
ret = xmedia_aenc_destroy_chn(config->chn);
CHECK_RET(ret, "xmedia_aenc_destroy_chn");
return ret;
}
static xmedia_void *aenc_input_data_thread(void *arg)
{
xmedia_s32 ret;
xmedia_s32 time_out = -1;
audio_frame frame;
comm_aenc_ctx* ctx = (comm_aenc_ctx*)arg;
xmedia_s32 send_size;
xmedia_char send_buffer[4096];
frame.bit_depth = ctx->bit_depth;
frame.channels = ctx->channels;
frame.interleaved = XMEDIA_TRUE;
frame.sample_rate = ctx->samplerate;
frame.timestamp = -1;
frame.data = (xmedia_void*)send_buffer;
send_size = ctx->samplerate * frame.channels * sizeof(xmedia_s16) * 10 / 1000;
while (ctx->input_running_flag) {
ret = fread(send_buffer, 1, send_size, ctx->input_file[ctx->chn]);
if (ret < send_size) {
rewind(ctx->input_file[ctx->chn]);
}
frame.size = ret;
xmedia_aenc_send_frame(ctx->chn, &frame, time_out);
}
return (xmedia_void*)XMEDIA_NULL;
}
static xmedia_void *aenc_output_data_thread(void *arg)
{
xmedia_s32 ret;
xmedia_s32 time_out = -1;
xmedia_u32 head_size = 0;
audio_stream stream;
comm_aenc_ctx* ctx = (comm_aenc_ctx*)arg;
//for voice type stream, it contains 4 bytes head, we drop it to get origin stream
if ((ctx->codec_type == CODEC_TYPE_G711) || (ctx->codec_type == CODEC_TYPE_G726)) {
head_size = 4;
}
while (ctx->output_running_flag) {
ret = xmedia_aenc_get_stream(ctx->chn, &stream, time_out);
if (ret != XMEDIA_SUCCESS) {
continue;
}
if (ctx->output_file[ctx->chn]) {
fwrite(stream.data + head_size, 1, stream.len - head_size, ctx->output_file[ctx->chn]);
}
xmedia_aenc_release_stream(ctx->chn, &stream);
}
return (xmedia_void*)XMEDIA_NULL;
}
static xmedia_s32 aenc_create_input_thread_from_file(sample_aenc_config* config, FILE** file)
{
xmedia_s32 ret;
g_aenc_ctx[config->chn].chn = config->chn;
g_aenc_ctx[config->chn].input_file = file;
g_aenc_ctx[config->chn].samplerate = config->sample_rate;
g_aenc_ctx[config->chn].channels = config->channels;
g_aenc_ctx[config->chn].bit_depth = config->bit_depth;
g_aenc_ctx[config->chn].input_running_flag = XMEDIA_TRUE;
ret = pthread_create(&g_aenc_ctx[config->chn].input_thd, 0, aenc_input_data_thread, &g_aenc_ctx[config->chn]);
CHECK_RET(ret, "pthread_create");
return XMEDIA_SUCCESS;
}
static xmedia_s32 aenc_destroy_input_thread_from_file(sample_aenc_config* config)
{
g_aenc_ctx[config->chn].input_running_flag = XMEDIA_FALSE;
pthread_join(g_aenc_ctx[config->chn].input_thd, XMEDIA_NULL);
g_aenc_ctx[config->chn].input_file = XMEDIA_NULL;
return XMEDIA_SUCCESS;
}
static xmedia_s32 aenc_create_output_thread_to_file(sample_aenc_config* config, FILE** file)
{
xmedia_s32 ret;
g_aenc_ctx[config->chn].chn = config->chn;
g_aenc_ctx[config->chn].output_file = file;
g_aenc_ctx[config->chn].output_running_flag = XMEDIA_TRUE;
g_aenc_ctx[config->chn].codec_type = config->type;
ret = pthread_create(&g_aenc_ctx[config->chn].output_thd, 0, aenc_output_data_thread, &g_aenc_ctx[config->chn]);
CHECK_RET(ret, "pthread_create");
return XMEDIA_SUCCESS;
}
static xmedia_s32 aenc_destroy_output_thread_to_file(sample_aenc_config* config)
{
g_aenc_ctx[config->chn].output_running_flag = XMEDIA_FALSE;
pthread_join(g_aenc_ctx[config->chn].output_thd, XMEDIA_NULL);
g_aenc_ctx[config->chn].output_file = XMEDIA_NULL;
return XMEDIA_SUCCESS;
}
static xmedia_s32 comm_audio_init()
{
xmedia_s32 ret;
ret = xmedia_ai_init();
CHECK_RET(ret, "xmedia_ai_init");
ret = xmedia_ao_init();
CHECK_RET(ret, "xmedia_ao_init");
ret = xmedia_adec_init();
CHECK_RET(ret, "xmedia_adec_init");
ret = xmedia_aenc_init();
CHECK_RET(ret, "xmedia_aenc_init");
return ret;
}
static xmedia_s32 comm_audio_exit()
{
xmedia_s32 ret;
ret = xmedia_ai_exit();
CHECK_RET(ret, "xmedia_ai_exit");
ret = xmedia_ao_exit();
CHECK_RET(ret, "xmedia_ao_exit");
ret = xmedia_adec_exit();
CHECK_RET(ret, "xmedia_adec_exit");
ret = xmedia_aenc_exit();
CHECK_RET(ret, "xmedia_aenc_exit");
return ret;
}
xmedia_s32 sample_comm_audio_init()
{
xmedia_s32 ret;
xmedia_sys_config sys_config = {0};
ret = xmedia_sys_init(&sys_config);
CHECK_RET(ret, "xmedia_sys_init");
ret = comm_audio_init();
CHECK_RET(ret, "comm_audio_init");
return ret;
}
xmedia_s32 sample_comm_audio_exit()
{
xmedia_s32 ret;
ret = comm_audio_exit();
CHECK_RET(ret, "comm_audio_exit");
ret = xmedia_sys_exit();
CHECK_RET(ret, "xmedia_sys_exit");
return ret;
}
xmedia_s32 sample_comm_ai_register(xmedia_u32 mask, ai_vqe_attr_version version, xmedia_bool res_enable)
{
xmedia_s32 ret;
ret = regist_vqe_lib(mask, version, res_enable);
CHECK_RET(ret, "regist_vqe_lib");
return ret;
}
xmedia_s32 sample_comm_ai_get_default_attr(ai_dev dev, ai_dev_attr* dev_attr)
{
xmedia_s32 ret;
CHECK_NULL_PTR(dev_attr);
ret = ai_get_default_attr(dev, dev_attr);
CHECK_RET(ret, "ai_get_default_attr");
return ret;
}
xmedia_s32 sample_comm_ai_set_share_mode(xmedia_bool enable)
{
xmedia_s32 ret;
ret = xmedia_ai_set_share_mode(enable);
CHECK_RET(ret, "xmedia_ai_set_share_mode");
g_share_mode_enable = enable;
return XMEDIA_SUCCESS;
}
xmedia_s32 sample_comm_ai_start(sample_ai_config* config)
{
xmedia_s32 ret;
CHECK_NULL_PTR(config);
ret = ai_start_dev(config);
CHECK_RET(ret, "ai_start_dev");
ret = ai_start_chn(config);
CHECK_RET(ret, "ai_start_chn");
return ret;
}
xmedia_s32 sample_comm_ai_stop(sample_ai_config* config)
{
xmedia_s32 ret;
CHECK_NULL_PTR(config);
ret = ai_stop_chn(config);
CHECK_RET(ret, "ai_stop_chn");
ret = ai_stop_dev(config);
CHECK_RET(ret, "ai_stop_dev");
return ret;
}
xmedia_s32 sample_comm_ai_set_volume(sample_ai_config* config, xmedia_s32 volume)
{
xmedia_s32 ret;
CHECK_NULL_PTR(config);
ret = ai_set_volume(config, volume);
CHECK_RET(ret, "ai_set_volume");
return ret;
}
xmedia_s32 sample_comm_ai_get_volume(sample_ai_config* config, xmedia_s32* volume)
{
xmedia_s32 ret;
CHECK_NULL_PTR(config);
CHECK_NULL_PTR(volume);
ret = ai_get_volume(config, volume);
CHECK_RET(ret, "ai_get_volume");
return ret;
}
xmedia_s32 sample_comm_ai_set_dev_param(sample_ai_config* config, ai_dev_param_cmd cmd, xmedia_void* param)
{
xmedia_s32 ret;
CHECK_NULL_PTR(config);
CHECK_NULL_PTR(param);
ret = xmedia_ai_set_dev_param(config->dev, cmd, param);
CHECK_RET(ret, "xmedia_ai_set_dev_param");
return ret;
}
xmedia_s32 sample_comm_ai_set_trackmode(sample_ai_config* config, audio_track_mode trackmode)
{
xmedia_s32 ret;
CHECK_NULL_PTR(config);
ret = xmedia_ai_set_trackmode(config->dev, trackmode);
CHECK_RET(ret, "xmedia_ai_set_trackmode");
return ret;
}
xmedia_s32 sample_comm_ai_get_trackmode(sample_ai_config* config, audio_track_mode* trackmode)
{
xmedia_s32 ret;
CHECK_NULL_PTR(config);
CHECK_NULL_PTR(trackmode);
ret = xmedia_ai_get_trackmode(config->dev, trackmode);
CHECK_RET(ret, "xmedia_ai_get_trackmode");
return ret;
}
xmedia_s32 sample_comm_ai_set_ec_source(sample_ai_config* config)
{
xmedia_s32 ret;
CHECK_NULL_PTR(config);
ret = ai_set_ec_source(config);
CHECK_RET(ret, "ai_set_ec_source");
return ret;
}
xmedia_s32 sample_comm_ai_enable_org_frame(sample_ai_config* config, xmedia_bool enable)
{
xmedia_s32 ret;
CHECK_NULL_PTR(config);
ret = ai_enable_org_frame(config, enable);
CHECK_RET(ret, "ai_enable_org_frame");
return ret;
}
xmedia_s32 sample_comm_ai_enable_ec_frame(sample_ai_config* config, xmedia_bool enable)
{
xmedia_s32 ret;
CHECK_NULL_PTR(config);
ret = ai_enable_ec_frame(config, enable);
CHECK_RET(ret, "ai_enable_ec_frame");
return ret;
}
xmedia_s32 sample_comm_ai_create_output_thread_to_aenc(sample_ai_config* config)
{
xmedia_s32 ret;
CHECK_NULL_PTR(config);
ret = ai_create_output_thread_to_aenc(config);
CHECK_RET(ret, "ai_create_data_thread");
return ret;
}
xmedia_s32 sample_comm_ai_destroy_output_thread_to_aenc(sample_ai_config* config)
{
xmedia_s32 ret;
CHECK_NULL_PTR(config);
ret = ai_destroy_output_thread_to_aenc(config);
CHECK_RET(ret, "ai_create_data_thread");
return ret;
}
xmedia_s32 sample_comm_ai_create_output_thread_to_ao(sample_ai_config* config, ao_dev dev, ao_chn chn)
{
xmedia_s32 ret;
CHECK_NULL_PTR(config);
ret = ai_create_output_thread_to_ao(config, dev, chn);
CHECK_RET(ret, "ai_create_data_thread");
return ret;
}
xmedia_s32 sample_comm_ai_destroy_output_thread_to_ao(sample_ai_config* config)
{
xmedia_s32 ret;
CHECK_NULL_PTR(config);
ret = ai_destroy_output_thread_to_ao(config);
CHECK_RET(ret, "ai_create_data_thread");
return ret;
}
xmedia_s32 sample_comm_ai_create_output_thread_to_file(sample_ai_config* config, FILE** output_file)
{
xmedia_s32 ret;
CHECK_NULL_PTR(config);
ret = ai_create_output_thread_to_file(config, output_file);
CHECK_RET(ret, "ai_create_data_thread");
return ret;
}
xmedia_s32 sample_comm_ai_destroy_output_thread_to_file(sample_ai_config* config)
{
xmedia_s32 ret;
CHECK_NULL_PTR(config);
ret = ai_destroy_output_thread_to_file(config);
CHECK_RET(ret, "ai_create_data_thread");
return ret;
}
xmedia_s32 sample_comm_detect_open(ai_dev dev, ai_vqe_attr* vqe_attr)
{
xmedia_s32 ret;
ret = xmedia_ai_disable_vqe(dev, 0);
CHECK_RET(ret, "xmedia_ai_disable_vqe");
ret = xmedia_ai_set_vqe_attr(dev, 0, vqe_attr);
CHECK_RET(ret, "xmedia_ai_set_vqe_attr");
ret = xmedia_ai_enable_vqe(dev, 0);
CHECK_RET(ret, "xmedia_ai_enable_vqe");
return XMEDIA_SUCCESS;
}
xmedia_s32 sample_comm_ao_register(xmedia_u32 mask, ao_vqe_attr_version version, xmedia_bool res_enable)
{
xmedia_s32 ret;
ret = regist_vqe_lib(mask, version, res_enable);
CHECK_RET(ret, "vqe_register_lib");
return ret;
}
xmedia_s32 sample_comm_ao_get_default_attr(ao_dev dev, ao_dev_attr* dev_attr)
{
xmedia_s32 ret;
CHECK_NULL_PTR(dev_attr);
ret = ao_get_default_attr(dev, dev_attr);
CHECK_RET(ret, "ao_get_default_attr");
return ret;
}
xmedia_s32 sample_comm_ao_start(sample_ao_config* config)
{
xmedia_s32 ret;
CHECK_NULL_PTR(config);
ret = ao_start_dev(config);
CHECK_RET(ret, "ao_start_dev");
ret = ao_start_chn(config);
CHECK_RET(ret, "ao_start_chn");
return ret;
}
xmedia_s32 sample_comm_ao_stop(sample_ao_config* config)
{
xmedia_s32 ret;
CHECK_NULL_PTR(config);
ret = ao_stop_chn(config);
CHECK_RET(ret, "ao_stop_chn");
ret = ao_stop_dev(config);
CHECK_RET(ret, "ao_stop_dev");
return ret;
}
xmedia_s32 sample_comm_ao_set_volume(sample_ao_config* config, xmedia_s32 volume)
{
xmedia_s32 ret;
CHECK_NULL_PTR(config);
ret = ao_set_volume(config, volume);
CHECK_RET(ret, "ao_set_volume");
return ret;
}
xmedia_s32 sample_comm_ao_get_volume(sample_ao_config* config, xmedia_s32* volume)
{
xmedia_s32 ret;
CHECK_NULL_PTR(config);
ret = ao_get_volume(config, volume);
CHECK_RET(ret, "ao_set_volume");
return ret;
}
xmedia_s32 sample_comm_ao_set_dev_param(sample_ao_config* config, ao_dev_param_cmd cmd, xmedia_void* param)
{
xmedia_s32 ret;
CHECK_NULL_PTR(config);
CHECK_NULL_PTR(param);
ret = ao_set_dev_params(config, cmd, param);
CHECK_RET(ret, "ai_set_dev_params");
return ret;
}
xmedia_s32 sample_comm_ao_create_input_thread_from_file(sample_ao_config* config, FILE** input_file)
{
xmedia_s32 ret;
CHECK_NULL_PTR(config);
CHECK_NULL_PTR(input_file);
ret = ao_create_input_thread_from_file(config, input_file);
CHECK_RET(ret, "ao_create_input_thread_from_file");
return ret;
}
xmedia_s32 sample_comm_ao_destroy_input_thread_from_file(sample_ao_config* config)
{
xmedia_s32 ret;
CHECK_NULL_PTR(config);
ret = ao_destroy_input_thread_from_file(config);
CHECK_RET(ret, "ao_destroy_input_thread_from_file");
return ret;
}
xmedia_s32 sample_comm_adec_register(audio_codec_type type)
{
xmedia_s32 ret;
ret = adec_register_lib(type);
CHECK_RET(ret, "adec_register_lib");
return ret;
}
xmedia_s32 sample_comm_adec_unregister(audio_codec_type type)
{
xmedia_s32 ret;
ret = adec_unregister_lib(type);
CHECK_RET(ret, "adec_unregister_lib");
return ret;
}
xmedia_s32 sample_comm_adec_start(sample_adec_config* config)
{
xmedia_s32 ret;
CHECK_NULL_PTR(config);
ret = adec_start_chn(config);
CHECK_RET(ret, "ai_start_chn");
return ret;
}
xmedia_s32 sample_comm_adec_stop(sample_adec_config* config)
{
xmedia_s32 ret;
CHECK_NULL_PTR(config);
ret = adec_stop_chn(config);
CHECK_RET(ret, "adec_stop_chn");
return ret;
}
xmedia_s32 sample_comm_adec_create_input_thread_from_file(sample_adec_config* config, FILE** input_file)
{
xmedia_s32 ret;
CHECK_NULL_PTR(config);
CHECK_NULL_PTR(input_file);
ret = adec_create_input_thread_from_file(config, input_file);
CHECK_RET(ret, "adec_create_input_thread_from_file");
return ret;
}
xmedia_s32 sample_comm_adec_destroy_input_thread_from_file(sample_adec_config* config)
{
xmedia_s32 ret;
CHECK_NULL_PTR(config);
ret = adec_destroy_input_thread_from_file(config);
CHECK_RET(ret, "adec_destroy_input_thread_from_file");
return ret;
}
xmedia_s32 sample_comm_adec_create_output_thread_to_ao(sample_adec_config* config, ao_dev dev, ao_chn chn)
{
xmedia_s32 ret;
CHECK_NULL_PTR(config);
ret = adec_create_output_thread_to_ao(config, dev, chn);
CHECK_RET(ret, "adec_create_output_thread_to_ao");
return ret;
}
xmedia_s32 sample_comm_adec_destroy_output_thread_to_ao(sample_adec_config* config)
{
xmedia_s32 ret;
CHECK_NULL_PTR(config);
ret = adec_destroy_output_thread_to_ao(config);
CHECK_RET(ret, "adec_destroy_output_thread_to_ao");
return ret;
}
xmedia_s32 sample_comm_adec_create_output_thread_to_file(sample_adec_config* config, FILE** output_file)
{
xmedia_s32 ret;
CHECK_NULL_PTR(config);
CHECK_NULL_PTR(output_file);
ret = adec_create_output_thread_to_file(config, output_file);
CHECK_RET(ret, "adec_create_output_thread_to_file");
return ret;
}
xmedia_s32 sample_comm_adec_destroy_output_thread_to_file(sample_adec_config* config)
{
xmedia_s32 ret;
CHECK_NULL_PTR(config);
ret = adec_destroy_output_thread_to_file(config);
CHECK_RET(ret, "adec_destroy_output_thread_to_file");
return ret;
}
xmedia_s32 sample_comm_aenc_register(audio_codec_type type)
{
xmedia_s32 ret;
ret = aenc_register_lib(type);
CHECK_RET(ret, "aenc_register_lib");
return ret;
}
xmedia_s32 sample_comm_aenc_unregister(audio_codec_type type)
{
xmedia_s32 ret;
ret = aenc_unregister_lib(type);
CHECK_RET(ret, "aenc_unregister_lib");
return ret;
}
xmedia_s32 sample_comm_aenc_start(sample_aenc_config* config)
{
xmedia_s32 ret;
CHECK_NULL_PTR(config);
ret = aenc_start_chn(config);
CHECK_RET(ret, "ai_start_chn");
return ret;
}
xmedia_s32 sample_comm_aenc_stop(sample_aenc_config* config)
{
xmedia_s32 ret;
CHECK_NULL_PTR(config);
ret = aenc_stop_chn(config);
CHECK_RET(ret, "adec_stop_chn");
return ret;
}
xmedia_s32 sample_comm_aenc_create_input_thread_from_file(sample_aenc_config* config, FILE** input_file)
{
xmedia_s32 ret;
CHECK_NULL_PTR(config);
ret = aenc_create_input_thread_from_file(config, input_file);
CHECK_RET(ret, "aenc_create_input_thread_from_file");
return ret;
}
xmedia_s32 sample_comm_aenc_destroy_input_thread_from_file(sample_aenc_config* config)
{
xmedia_s32 ret;
CHECK_NULL_PTR(config);
ret = aenc_destroy_input_thread_from_file(config);
CHECK_RET(ret, "aenc_destroy_output_thread_to_file");
return ret;
}
xmedia_s32 sample_comm_aenc_create_output_thread_to_file(sample_aenc_config* config, FILE** output_file)
{
xmedia_s32 ret;
CHECK_NULL_PTR(config);
ret = aenc_create_output_thread_to_file(config, output_file);
CHECK_RET(ret, "aenc_create_output_thread_to_file");
return ret;
}
xmedia_s32 sample_comm_aenc_destroy_output_thread_to_file(sample_aenc_config* config)
{
xmedia_s32 ret;
CHECK_NULL_PTR(config);
ret = aenc_destroy_output_thread_to_file(config);
CHECK_RET(ret, "aenc_destroy_output_thread_to_file");
return ret;
}
xmedia_s32 sample_comm_get_codec_info(xmedia_char* file_name, audio_codec_type* type, voice_format* format)
{
xmedia_s32 ret = XMEDIA_SUCCESS;
CHECK_NULL_PTR(file_name);
CHECK_NULL_PTR(type);
if (strstr(file_name,".adpcm")) {
*type = CODEC_TYPE_ADPCM;
*format = VOICE_FORMAT_ADPCM_DVI4;
} else if (strstr(file_name,".lpcm") || strstr(file_name,".pcm")) {
*type = CODEC_TYPE_LPCM;
} else if (strstr(file_name,".g711a") || strstr(file_name,".alaw")) {
*type = CODEC_TYPE_G711;
*format = VOICE_FORMAT_G711_A;
} else if (strstr(file_name,".g711u") || strstr(file_name,".ulaw")) {
*type = CODEC_TYPE_G711;
*format = VOICE_FORMAT_G711_U;
} else if (strstr(file_name,".g726")) {
*type = CODEC_TYPE_G726;
*format = VOICE_FORMAT_G726_16KBPS;
} else if (strstr(file_name,".aac")) {
*type = CODEC_TYPE_AAC;
} else if (strstr(file_name,".mp3")) {
*type = CODEC_TYPE_MP3;
} else {
printf("invalid file extension\n");
ret = XMEDIA_FAILURE;
}
CHECK_RET(ret, "get_codec_info");
return ret;
}
Reference in New Issue View Git Blame Copy Permalink