huxi
284 lines
8.0 KiB
C
284 lines
8.0 KiB
C
#ifdef SUPPORT_MS_EXTENSIONS
|
|
#pragma bss_seg(".plc_node.data.bss")
|
|
#pragma data_seg(".plc_node.data")
|
|
#pragma const_seg(".plc_node.text.const")
|
|
#pragma code_seg(".plc_node.text")
|
|
#endif
|
|
#include "jlstream.h"
|
|
#include "audio_plc.h"
|
|
#include "tech_lib/LFaudio_plc_api.h"
|
|
#include "app_config.h"
|
|
#include "effects/effects_adj.h"
|
|
#include "media/audio_splicing.h"
|
|
|
|
#if TCFG_PLC_NODE_ENABLE
|
|
|
|
enum audio_plc_type {
|
|
AUD_PLC_BYPASS = 0, //不做任何处理，但是仍然会有缓存;
|
|
AUD_PLC_NORMAL, //仅修复
|
|
AUD_PLC_WITH_FADE //修复的同时做淡入淡出的处理
|
|
};
|
|
|
|
extern int tws_api_get_low_latency_state();
|
|
struct plc_node_hdl {
|
|
u8 start;
|
|
u8 channel_num;
|
|
enum stream_scene scene; //当前场景
|
|
struct music_plc *plc;
|
|
void *esco_plc;
|
|
char *out_buf;
|
|
u16 out_buf_len;
|
|
struct stream_node *node; //节点句柄
|
|
struct node_port_data_wide data_wide;
|
|
u8 Qval;//数据的饱和位宽
|
|
};
|
|
struct music_plc {
|
|
LFaudio_PLC_API *plc_ops;
|
|
void *plc_mem;
|
|
af_DataType datatype;
|
|
};
|
|
|
|
struct music_plc *music_plc_open(struct plc_node_hdl *hdl, u32 sr, u8 ch_num)
|
|
{
|
|
|
|
struct music_plc *plc = zalloc(sizeof(struct music_plc));
|
|
if (plc) {
|
|
plc->datatype.IndataBit = hdl->data_wide.iport_data_wide;
|
|
plc->datatype.OutdataBit = hdl->data_wide.oport_data_wide;
|
|
plc->datatype.IndataInc = (ch_num == 2) ? 2 : 1;
|
|
plc->datatype.OutdataInc = (ch_num == 2) ? 2 : 1;
|
|
plc->plc_ops = get_lfaudioPLC_api();
|
|
int plc_mem_size = plc->plc_ops->need_buf(ch_num, &plc->datatype); // 3660bytes，请衡量是否使用该空间换取PLC处理
|
|
plc->plc_mem = malloc(plc_mem_size);
|
|
if (!plc->plc_mem) {
|
|
plc->plc_ops = NULL;
|
|
free(plc);
|
|
return NULL;
|
|
}
|
|
#if TCFG_USER_TWS_ENABLE
|
|
u8 mode = tws_api_get_low_latency_state() ? 4 : 0;
|
|
#else
|
|
u8 mode = 0;
|
|
#endif
|
|
plc->plc_ops->open(plc->plc_mem, ch_num, sr, mode, &plc->datatype); //4是延时最低 16个点
|
|
}
|
|
return plc;
|
|
}
|
|
|
|
|
|
void music_plc_run(struct music_plc *plc, s16 *data, u16 len, u8 repair)
|
|
{
|
|
if (plc && plc->plc_ops) {
|
|
u16 point_offset = plc->datatype.IndataBit ? 2 : 1;
|
|
u16 plc_type = repair ? AUD_PLC_WITH_FADE : AUD_PLC_BYPASS;
|
|
plc->plc_ops->run(plc->plc_mem, data, data, len >> point_offset, plc_type);
|
|
}
|
|
}
|
|
|
|
void music_plc_set_bit_wide(struct music_plc *plc, struct node_port_data_wide data_wide)
|
|
{
|
|
//TODO
|
|
}
|
|
void music_plc_close(struct music_plc *plc)
|
|
{
|
|
if (plc) {
|
|
if (plc->plc_mem) {
|
|
free(plc->plc_mem);
|
|
plc->plc_mem = NULL;
|
|
}
|
|
free(plc);
|
|
}
|
|
}
|
|
/*
|
|
*通话plc只支持单声道
|
|
* */
|
|
void *esco_plc_open(struct plc_node_hdl *hdl, u32 sr, u8 ch_num)
|
|
{
|
|
hdl->channel_num = ch_num;
|
|
af_DataType dataTypeobj = {0};
|
|
dataTypeobj.IndataBit = hdl->data_wide.iport_data_wide;
|
|
dataTypeobj.OutdataBit = hdl->data_wide.oport_data_wide;
|
|
dataTypeobj.IndataInc = 1;
|
|
dataTypeobj.OutdataInc = 1;
|
|
dataTypeobj.Qval = hdl->node->oport->fmt.Qval;
|
|
void *esco_plc = audio_plc_open(sr, 1, &dataTypeobj);
|
|
return esco_plc;
|
|
}
|
|
|
|
void esco_plc_run(struct plc_node_hdl *hdl, s16 *data, u16 len, u8 repair_flag)
|
|
{
|
|
if (!hdl->esco_plc) {
|
|
return;
|
|
}
|
|
u8 ch_num = hdl->channel_num;
|
|
u8 bit_wide = hdl->data_wide.oport_data_wide;
|
|
if (ch_num == 2) {
|
|
if (hdl->out_buf_len < len / 2) {
|
|
if (hdl->out_buf) {
|
|
free(hdl->out_buf);
|
|
hdl->out_buf = NULL;
|
|
}
|
|
}
|
|
if (!hdl->out_buf) {
|
|
hdl->out_buf = malloc(len / 2);
|
|
hdl->out_buf_len = len / 2;
|
|
}
|
|
if (hdl->out_buf) {
|
|
if (bit_wide) {
|
|
if (config_media_24bit_enable) {
|
|
pcm_dual_to_single_32bit(hdl->out_buf, data, len);
|
|
audio_plc_run(hdl->esco_plc, (s16 *)hdl->out_buf, len / 2, repair_flag);
|
|
pcm_single_to_dual_32bit(data, hdl->out_buf, len / 2);
|
|
}
|
|
} else {
|
|
pcm_dual_to_single(hdl->out_buf, data, len);
|
|
audio_plc_run(hdl->esco_plc, (s16 *)hdl->out_buf, len / 2, repair_flag);
|
|
pcm_single_to_dual(data, hdl->out_buf, len / 2);
|
|
}
|
|
}
|
|
} else {
|
|
audio_plc_run(hdl->esco_plc, (s16 *)data, len, repair_flag);
|
|
}
|
|
}
|
|
|
|
void esco_plc_close(void *esco_plc)
|
|
{
|
|
if (!esco_plc) {
|
|
return;
|
|
}
|
|
|
|
audio_plc_close(esco_plc);
|
|
}
|
|
|
|
static void plc_handle_frame(struct stream_iport *iport, struct stream_note *note)
|
|
{
|
|
struct stream_frame *frame;
|
|
struct stream_node *node = iport->node;
|
|
struct plc_node_hdl *hdl = (struct plc_node_hdl *)iport->private_data;
|
|
u8 repair_flag = 0;
|
|
while (1) {
|
|
frame = jlstream_pull_frame(iport, note);
|
|
if (!frame) {
|
|
break;
|
|
}
|
|
if ((frame->flags & (FRAME_FLAG_FILL_PACKET & ~FRAME_FLAG_FLUSH_OUT)) == (FRAME_FLAG_FILL_PACKET & ~FRAME_FLAG_FLUSH_OUT)) {
|
|
repair_flag = 1;
|
|
//putchar('Q');
|
|
}
|
|
if (hdl->scene == STREAM_SCENE_A2DP) {
|
|
music_plc_run(hdl->plc, (s16 *)frame->data, frame->len, repair_flag);
|
|
} else {
|
|
esco_plc_run(hdl, (s16 *)frame->data, frame->len, repair_flag);
|
|
}
|
|
repair_flag = 0;
|
|
if (node->oport) {
|
|
jlstream_push_frame(node->oport, frame);
|
|
} else {
|
|
jlstream_free_frame(frame);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*节点预处理-在ioctl之前*/
|
|
static int plc_adapter_bind(struct stream_node *node, u16 uuid)
|
|
{
|
|
struct plc_node_hdl *hdl = malloc(sizeof(*hdl));
|
|
memset(hdl, 0, sizeof(*hdl));
|
|
hdl->node = node;
|
|
node->private_data = hdl;
|
|
return 0;
|
|
}
|
|
|
|
/*打开改节点输入接口*/
|
|
static void plc_ioc_open_iport(struct stream_iport *iport)
|
|
{
|
|
iport->handle_frame = plc_handle_frame;
|
|
iport->private_data = iport->node->private_data;
|
|
}
|
|
|
|
/*节点参数协商*/
|
|
static int plc_ioc_negotiate(struct stream_iport *iport)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
/*节点start函数*/
|
|
static void plc_ioc_start(struct plc_node_hdl *hdl, u32 sr, u8 ch_num)
|
|
{
|
|
|
|
hdl->data_wide.iport_data_wide = hdl->node->iport->prev->fmt.bit_wide;
|
|
hdl->data_wide.oport_data_wide = hdl->node->oport->fmt.bit_wide;
|
|
log_d("%s bit_wide, %d %d %d\n", __FUNCTION__, hdl->data_wide.iport_data_wide, hdl->data_wide.oport_data_wide, hdl->node->oport->fmt.Qval);
|
|
if (hdl->scene == STREAM_SCENE_A2DP) {
|
|
hdl->plc = music_plc_open(hdl, sr, ch_num);
|
|
} else {
|
|
hdl->esco_plc = esco_plc_open(hdl, sr, ch_num);
|
|
}
|
|
}
|
|
|
|
/*节点stop函数*/
|
|
static void plc_ioc_stop(struct plc_node_hdl *hdl)
|
|
{
|
|
if (hdl->scene == STREAM_SCENE_A2DP) {
|
|
if (hdl->plc) {
|
|
music_plc_close(hdl->plc);
|
|
hdl->plc = NULL;
|
|
}
|
|
} else {
|
|
if (hdl->esco_plc) {
|
|
esco_plc_close(hdl->esco_plc);
|
|
hdl->esco_plc = NULL;
|
|
}
|
|
if (hdl->out_buf) {
|
|
free(hdl->out_buf);
|
|
hdl->out_buf = NULL;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*节点ioctl函数*/
|
|
static int plc_adapter_ioctl(struct stream_iport *iport, int cmd, int arg)
|
|
{
|
|
int ret = 0;
|
|
struct plc_node_hdl *hdl = (struct plc_node_hdl *)iport->private_data;
|
|
|
|
switch (cmd) {
|
|
case NODE_IOC_OPEN_IPORT:
|
|
plc_ioc_open_iport(iport);
|
|
break;
|
|
case NODE_IOC_SET_SCENE:
|
|
hdl->scene = (enum stream_scene)arg;
|
|
break;
|
|
|
|
case NODE_IOC_NEGOTIATE:
|
|
*(int *)arg |= plc_ioc_negotiate(iport);
|
|
break;
|
|
case NODE_IOC_START:
|
|
plc_ioc_start(hdl, iport->prev->fmt.sample_rate, AUDIO_CH_NUM(iport->prev->fmt.channel_mode));
|
|
break;
|
|
case NODE_IOC_SUSPEND:
|
|
case NODE_IOC_STOP:
|
|
plc_ioc_stop(hdl);
|
|
break;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/*节点用完释放函数*/
|
|
static void plc_adapter_release(struct stream_node *node)
|
|
{
|
|
free(node->private_data);
|
|
}
|
|
|
|
/*节点adapter 注意需要在sdk_used_list声明，否则会被优化*/
|
|
REGISTER_STREAM_NODE_ADAPTER(plc_node_adapter) = {
|
|
.name = "plc",
|
|
.uuid = NODE_UUID_PLC,
|
|
.bind = plc_adapter_bind,
|
|
.ioctl = plc_adapter_ioctl,
|
|
.release = plc_adapter_release,
|
|
};
|
|
|
|
#endif
|
|
|