589 lines
16 KiB
C
589 lines
16 KiB
C
|
||
#include "asm/includes.h"
|
||
#include "media/includes.h"
|
||
#include "system/includes.h"
|
||
#include "encode/encode_write.h"
|
||
#include "asm/audio_src.h"
|
||
#include "audio_enc.h"
|
||
#include "app_main.h"
|
||
#include "app_action.h"
|
||
#include "clock_cfg.h"
|
||
#include "dev_manager.h"
|
||
#include "btstack/btstack_task.h"
|
||
#include "btstack/avctp_user.h"
|
||
|
||
#if TCFG_ENC_WRITE_FILE_ENABLE
|
||
|
||
#define PCM_ENC2FILE_PCM_LEN (3 * 1024)
|
||
#define PCM_ENC2FILE_FILE_LEN (8 * 1024)
|
||
|
||
#define PCM_ENC2FILE_PCM_LEN_OVERLAY (2 * 1024)
|
||
#define PCM_ENC2FILE_FILE_LEN_OVERLAY (3 * 1024)
|
||
|
||
#define WAV_FILE_HEAD_LEN 90
|
||
|
||
#define PCM2FILE_ENC_BUF_COUNT 1
|
||
|
||
//wav录音头部信息定时更新时间设置， 单位ms
|
||
#define UPDATA_WAV_HEAD_TIME (5000)
|
||
|
||
|
||
extern struct audio_encoder_task *encode_task;
|
||
|
||
struct pcm2file_enc_hdl {
|
||
struct audio_encoder encoder;
|
||
s16 output_frame[1152 / 2]; //align 4Bytes
|
||
|
||
int pcm_frame[64]; //align 4Bytes
|
||
u8 file_head_frame[128];
|
||
u8 file_head_len;
|
||
/* u8 pcm_buf[PCM_ENC2FILE_PCM_LEN]; */
|
||
u8 *pcm_buf;
|
||
cbuffer_t pcm_cbuf;
|
||
|
||
int out_file_frame[512 / 4];
|
||
/* u8 out_file_buf[PCM_ENC2FILE_FILE_LEN]; */
|
||
u8 *out_file_buf;
|
||
cbuffer_t out_file_cbuf;
|
||
|
||
void *whdl;
|
||
OS_SEM sem_wfile;
|
||
OS_MUTEX mutex;
|
||
|
||
volatile u32 status : 2;
|
||
volatile u32 enc_err : 1;
|
||
volatile u32 encoding : 1;
|
||
volatile u32 write_head_busy : 1;
|
||
volatile u32 input_busy : 1;
|
||
|
||
u32 lost;
|
||
|
||
#if PCM2FILE_ENC_BUF_COUNT
|
||
u16 pcm_buf_max;
|
||
u16 out_file_max;
|
||
#endif
|
||
|
||
u32 head_update_tick;
|
||
|
||
};
|
||
|
||
|
||
static volatile u8 pcm2file_used_overlay = 0;
|
||
|
||
#if (RECORDER_MIX_EN)
|
||
struct pcm2file_enc_hdl pcm2file_enc_overlay_handle sec(.enc_file_mem);
|
||
u8 pcm_buf_overlay[PCM_ENC2FILE_PCM_LEN_OVERLAY] sec(.enc_file_mem);
|
||
u8 out_file_buf_overlay[PCM_ENC2FILE_FILE_LEN_OVERLAY] sec(.enc_file_mem);
|
||
#endif/*RECORDER_MIX_EN*/
|
||
|
||
static void pcm2file_enc_suspend(struct pcm2file_enc_hdl *enc)
|
||
{
|
||
audio_encoder_suspend(&enc->encoder, 0);
|
||
}
|
||
|
||
|
||
static void pcm2file_enc_resume(struct pcm2file_enc_hdl *enc)
|
||
{
|
||
audio_encoder_resume(&enc->encoder);
|
||
}
|
||
|
||
static void pcm2file_wfile_resume(struct pcm2file_enc_hdl *enc)
|
||
{
|
||
os_sem_set(&enc->sem_wfile, 0);
|
||
os_sem_post(&enc->sem_wfile);
|
||
enc_write_file_resume(enc->whdl);
|
||
}
|
||
|
||
void enc_change_status(void *hdl)
|
||
{
|
||
struct pcm2file_enc_hdl *pcm2file = hdl;
|
||
if (pcm2file->status == 1) {
|
||
pcm2file->status = 2;
|
||
} else if (pcm2file->status == 2) {
|
||
pcm2file->status = 1;
|
||
}
|
||
}
|
||
|
||
// 写pcm数据
|
||
int pcm2file_enc_write_pcm(void *priv, s16 *data, int len)
|
||
{
|
||
struct pcm2file_enc_hdl *enc = (struct pcm2file_enc_hdl *)priv;
|
||
if (!enc || enc->enc_err || enc->status == 0) {
|
||
return 0;
|
||
}
|
||
u16 wlen = 0;
|
||
enc->input_busy = 1;
|
||
if (enc->status == 1) {
|
||
wlen = cbuf_write(&enc->pcm_cbuf, data, len);
|
||
if (!wlen) {
|
||
enc->lost++;
|
||
putchar('~');
|
||
} else {
|
||
/* putchar('G');//__G__ */
|
||
}
|
||
#if PCM2FILE_ENC_BUF_COUNT
|
||
if (enc->pcm_buf_max < enc->pcm_cbuf.data_len) {
|
||
enc->pcm_buf_max = enc->pcm_cbuf.data_len;
|
||
}
|
||
#endif
|
||
/* printf("wl:%d ", wlen); */
|
||
// 激活录音编码器
|
||
if (cbuf_get_data_size(&enc->pcm_cbuf) >= 128) {
|
||
pcm2file_enc_resume(enc);
|
||
}
|
||
} else if (enc->status == 2) {
|
||
// 挂起录音编码器
|
||
pcm2file_enc_suspend(enc);
|
||
}
|
||
enc->input_busy = 0;
|
||
return wlen;
|
||
}
|
||
|
||
// 编码器获取数据
|
||
static int pcm2file_enc_pcm_get(struct audio_encoder *encoder, s16 **frame, u16 frame_len)
|
||
{
|
||
int rlen = 0;
|
||
int dlen = 0;
|
||
if (encoder == NULL) {
|
||
r_printf("encoder NULL");
|
||
}
|
||
struct pcm2file_enc_hdl *enc = container_of(encoder, struct pcm2file_enc_hdl, encoder);
|
||
|
||
if (enc == NULL) {
|
||
r_printf("enc NULL");
|
||
}
|
||
|
||
/* printf("l:%d", frame_len); */
|
||
|
||
if (!enc->status) {
|
||
return 0;
|
||
}
|
||
if (enc->enc_err) {
|
||
return 0;
|
||
}
|
||
|
||
dlen = cbuf_get_data_len(&enc->pcm_cbuf);
|
||
if (dlen < frame_len) {
|
||
/* putchar('T');//__T__ */
|
||
return 0;
|
||
}
|
||
|
||
rlen = cbuf_read(&enc->pcm_cbuf, enc->pcm_frame, frame_len);
|
||
|
||
*frame = enc->pcm_frame;
|
||
|
||
return rlen;
|
||
}
|
||
|
||
static void pcm2file_enc_pcm_put(struct audio_encoder *encoder, s16 *frame)
|
||
{
|
||
}
|
||
|
||
static const struct audio_enc_input pcm2file_enc_input = {
|
||
.fget = pcm2file_enc_pcm_get,
|
||
.fput = pcm2file_enc_pcm_put,
|
||
};
|
||
|
||
static int pcm2file_enc_probe_handler(struct audio_encoder *encoder)
|
||
{
|
||
return 0;
|
||
}
|
||
// 编码器输出
|
||
static int pcm2file_enc_output_handler(struct audio_encoder *encoder, u8 *frame, int len)
|
||
{
|
||
struct pcm2file_enc_hdl *enc = container_of(encoder, struct pcm2file_enc_hdl, encoder);
|
||
|
||
int wlen = cbuf_write(&enc->out_file_cbuf, frame, len);
|
||
#if PCM2FILE_ENC_BUF_COUNT
|
||
if (enc->out_file_max < enc->out_file_cbuf.data_len) {
|
||
enc->out_file_max = enc->out_file_cbuf.data_len;
|
||
}
|
||
#endif
|
||
if (cbuf_get_data_len(&enc->out_file_cbuf) >= (512 * 2)) {
|
||
pcm2file_wfile_resume(enc);
|
||
}
|
||
/* if (wlen != len) { */
|
||
/* printf("X"); */
|
||
/* } */
|
||
/* if (!enc->status) { */
|
||
/* return 0; */
|
||
/* } */
|
||
if (enc->enc_err) {
|
||
return 0;
|
||
}
|
||
|
||
return wlen;
|
||
}
|
||
|
||
static void pcm2file_enc_get_head_info(struct audio_encoder *encoder)
|
||
{
|
||
struct pcm2file_enc_hdl *pcm2file = container_of(encoder, struct pcm2file_enc_hdl, encoder);
|
||
u16 len = 0;
|
||
u8 *ptr = (u8 *)audio_encoder_ioctrl(&pcm2file->encoder, 2, AUDIO_ENCODER_IOCTRL_CMD_GET_HEAD_INFO, &len);
|
||
/* printf("%s, ptr = %x, len = %d\n", __FUNCTION__, ptr, len); */
|
||
if (ptr) {
|
||
if (len > sizeof(pcm2file->file_head_frame)) {
|
||
printf("file_head_frame buf not enough\n");
|
||
return;
|
||
}
|
||
memcpy(pcm2file->file_head_frame, ptr, len);
|
||
/* put_buf(pcm2file->file_head_frame, len); */
|
||
pcm2file->file_head_len = len;
|
||
}
|
||
}
|
||
|
||
static int pcm2file_enc_close_handler(struct audio_encoder *encoder)
|
||
{
|
||
//做一些编码关闭前的操作， 例如：adpcm写头操作
|
||
pcm2file_enc_get_head_info(encoder);//写编码头部信息
|
||
return 0;
|
||
}
|
||
|
||
const static struct audio_enc_handler pcm2file_enc_handler = {
|
||
.enc_probe = pcm2file_enc_probe_handler,
|
||
.enc_output = pcm2file_enc_output_handler,
|
||
.enc_close = pcm2file_enc_close_handler,
|
||
};
|
||
|
||
static int enc_wfile_set_head(void *hdl, char **head)
|
||
{
|
||
struct pcm2file_enc_hdl *enc = hdl;
|
||
/* struct enc_write_test *tst = hdl; */
|
||
*head = enc->file_head_frame;
|
||
return enc->file_head_len;
|
||
}
|
||
|
||
|
||
static void updata_wav_head_info(struct audio_encoder *encoder, void *priv)
|
||
{
|
||
int len;
|
||
char *head;
|
||
int cur_write_pos;
|
||
struct audio_fmt *enc_fmt;
|
||
struct pcm2file_enc_hdl *enc = (struct pcm2file_enc_hdl *)priv;
|
||
|
||
/* extern int audio_encoder_get_fmt(struct audio_encoder * enc, struct audio_fmt **fmt); */
|
||
audio_encoder_get_fmt(encoder, &enc_fmt);
|
||
if ((enc_fmt->coding_type != AUDIO_CODING_WAV)
|
||
&& (enc_fmt->coding_type != AUDIO_CODING_G726)
|
||
) {
|
||
return;
|
||
}
|
||
|
||
cur_write_pos = fpos(get_wfil_file(enc->whdl));
|
||
pcm2file_enc_get_head_info(encoder);
|
||
len = enc_wfile_set_head(get_wfil_head_hdl(enc->whdl), &head);
|
||
if (len) {
|
||
fseek(get_wfil_file(enc->whdl), 0, SEEK_SET);
|
||
fwrite(get_wfil_file(enc->whdl), head, len);
|
||
}
|
||
fseek(get_wfil_file(enc->whdl), cur_write_pos, SEEK_SET);
|
||
//printf("update head!!\n");
|
||
}
|
||
|
||
static void pcm2file_enc_w_evt(void *hdl, int evt, int parm)
|
||
{
|
||
struct pcm2file_enc_hdl *enc = hdl;
|
||
printf("evt: %d ", evt);
|
||
if (evt == ENC_WRITE_FILE_EVT_WRITE_ERR) {
|
||
enc->enc_err = 1;
|
||
pcm2file_wfile_resume(enc);
|
||
pcm2file_enc_resume(enc);
|
||
audio_encoder_stop(&enc->encoder);
|
||
} else if (evt == ENC_WRITE_FILE_EVT_FILE_CLOSE) {
|
||
printf("sclust: %d ", parm);
|
||
}
|
||
}
|
||
|
||
static int pcm2file_enc_w_get(void *hdl, s16 **frame, u16 frame_len)
|
||
{
|
||
int rlen;
|
||
struct pcm2file_enc_hdl *enc = hdl;
|
||
os_sem_set(&enc->sem_wfile, 0);
|
||
/* printf("r:%d", frame_len); */
|
||
do {
|
||
rlen = cbuf_read(&enc->out_file_cbuf, enc->out_file_frame, frame_len);
|
||
if (rlen == frame_len) {
|
||
break;
|
||
}
|
||
|
||
if (!enc->status) {
|
||
rlen = cbuf_get_data_len(&enc->out_file_cbuf);
|
||
rlen = cbuf_read(&enc->out_file_cbuf, enc->out_file_frame, rlen);
|
||
break;
|
||
}
|
||
|
||
if (enc->enc_err) {
|
||
return 0;
|
||
}
|
||
if (cbuf_get_data_size(&enc->pcm_cbuf) >= 128) {
|
||
pcm2file_enc_resume(enc);
|
||
}
|
||
os_sem_pend(&enc->sem_wfile, 2);
|
||
} while (1);
|
||
|
||
*frame = enc->out_file_frame;
|
||
return rlen;
|
||
}
|
||
static void pcm2file_enc_w_put(void *hdl, s16 *frame)
|
||
{
|
||
#if TCFG_NOR_FS_ENABLE || FLASH_INSIDE_REC_ENABLE
|
||
return ;
|
||
#endif
|
||
|
||
struct pcm2file_enc_hdl *enc = (struct pcm2file_enc_hdl *)hdl;
|
||
u32 cur_sys_time = timer_get_ms();
|
||
os_mutex_pend(&enc->mutex, 0);
|
||
if (enc->status == 0) {
|
||
os_mutex_post(&enc->mutex);
|
||
return ;
|
||
}
|
||
if (cur_sys_time - enc->head_update_tick >= UPDATA_WAV_HEAD_TIME) {
|
||
updata_wav_head_info(&(enc->encoder), enc);
|
||
enc->head_update_tick = cur_sys_time;
|
||
}
|
||
os_mutex_post(&enc->mutex);
|
||
}
|
||
|
||
const struct audio_enc_write_input pcm2file_enc_w_input = {
|
||
.get = pcm2file_enc_w_get,
|
||
.put = pcm2file_enc_w_put,
|
||
};
|
||
|
||
|
||
|
||
|
||
|
||
void pcm2file_enc_write_file_set_limit(void *hdl, u32 cut_size, u32 limit_size)
|
||
{
|
||
struct pcm2file_enc_hdl *pcm2file = hdl;
|
||
enc_write_file_set_limit(pcm2file->whdl, cut_size, limit_size);
|
||
}
|
||
|
||
void pcm2file_enc_set_evt_handler(void *hdl, void (*handler)(struct audio_encoder *, int, int *), u32 maigc)
|
||
{
|
||
struct pcm2file_enc_hdl *pcm2file = hdl;
|
||
audio_encoder_set_event_handler(&pcm2file->encoder, handler, maigc);
|
||
}
|
||
|
||
void pcm2file_enc_start(void *hdl)
|
||
{
|
||
struct pcm2file_enc_hdl *pcm2file = hdl;
|
||
|
||
pcm2file->status = 1;
|
||
|
||
audio_encoder_start(&pcm2file->encoder);
|
||
|
||
enc_write_file_start(pcm2file->whdl);
|
||
|
||
//记录录音启动时的tick， 后面定时更新头部信息用到
|
||
pcm2file->head_update_tick = timer_get_ms();
|
||
}
|
||
|
||
int pcm2file_enc_get_time(void *hdl)
|
||
{
|
||
struct pcm2file_enc_hdl *pcm2file = hdl;
|
||
if (!pcm2file) {
|
||
return 0;
|
||
}
|
||
os_mutex_pend(&pcm2file->mutex, 0);
|
||
if (pcm2file->status == 0) {
|
||
os_mutex_post(&pcm2file->mutex);
|
||
return 0;
|
||
}
|
||
int ret = audio_encoder_ioctrl(&pcm2file->encoder, 1, AUDIO_ENCODER_IOCTRL_CMD_GET_TIME);
|
||
os_mutex_post(&pcm2file->mutex);
|
||
return ret;
|
||
}
|
||
void *pcm2file_enc_open(struct audio_fmt *pfmt, char *logo, char *folder, char *filename)
|
||
{
|
||
int err;
|
||
struct pcm2file_enc_hdl *pcm2file = NULL;
|
||
char *temp_filename = NULL;
|
||
u32 out_file_buf_size = 0;
|
||
u32 pcm_buf_size = 0;
|
||
|
||
if (pfmt->coding_type != AUDIO_CODING_MP3 && pfmt->coding_type != AUDIO_CODING_WAV && pfmt->coding_type != AUDIO_CODING_G726) {
|
||
return NULL;
|
||
}
|
||
|
||
///创建录音编码线程
|
||
audio_encoder_task_open();
|
||
|
||
#if (RECORDER_MIX_EN)
|
||
if (BT_CALL_HANGUP != get_call_status()) {
|
||
printf("[%s], used overlay!!\n", __FUNCTION__);
|
||
pcm2file_used_overlay = 1;
|
||
pcm2file = &pcm2file_enc_overlay_handle;
|
||
memset(&pcm2file_enc_overlay_handle, 0, sizeof(struct pcm2file_enc_hdl));
|
||
pcm2file->pcm_buf = pcm_buf_overlay;
|
||
pcm2file->out_file_buf = out_file_buf_overlay;
|
||
pcm_buf_size = PCM_ENC2FILE_PCM_LEN_OVERLAY;
|
||
out_file_buf_size = PCM_ENC2FILE_FILE_LEN_OVERLAY;
|
||
memset(pcm2file->pcm_buf, 0, PCM_ENC2FILE_PCM_LEN_OVERLAY);
|
||
memset(pcm2file->out_file_buf, 0, PCM_ENC2FILE_FILE_LEN_OVERLAY);
|
||
} else
|
||
#endif/*RECORDER_MIX_EN*/
|
||
{
|
||
printf("[%s], used malloc!!\n", __FUNCTION__);
|
||
pcm2file_used_overlay = 0;
|
||
pcm2file = zalloc(sizeof(struct pcm2file_enc_hdl));
|
||
if (!pcm2file) {
|
||
goto __out;
|
||
}
|
||
pcm_buf_size = PCM_ENC2FILE_PCM_LEN;
|
||
out_file_buf_size = PCM_ENC2FILE_FILE_LEN;
|
||
pcm2file->pcm_buf = zalloc(pcm_buf_size);
|
||
if (pcm2file->pcm_buf == NULL) {
|
||
goto __out;
|
||
}
|
||
pcm2file->out_file_buf = zalloc(out_file_buf_size);
|
||
if (pcm2file->out_file_buf == NULL) {
|
||
goto __out;
|
||
}
|
||
|
||
}
|
||
|
||
os_sem_create(&pcm2file->sem_wfile, 0);
|
||
os_mutex_create(&pcm2file->mutex);
|
||
cbuf_init(&pcm2file->out_file_cbuf, pcm2file->out_file_buf, out_file_buf_size);
|
||
|
||
temp_filename = zalloc(strlen(filename) + 5);
|
||
if (temp_filename == NULL) {
|
||
goto __out;
|
||
}
|
||
if (pfmt->coding_type == AUDIO_CODING_MP3) {
|
||
strcat(temp_filename, filename);
|
||
strcat(temp_filename, ".mp3");
|
||
} else if (pfmt->coding_type == AUDIO_CODING_WAV || pfmt->coding_type == AUDIO_CODING_G726) {
|
||
strcat(temp_filename, filename);
|
||
strcat(temp_filename, ".wav");
|
||
}
|
||
pcm2file->whdl = enc_write_file_open(logo, folder, temp_filename);
|
||
free(temp_filename);
|
||
if (!pcm2file->whdl) {
|
||
goto __out;
|
||
}
|
||
|
||
enc_write_file_set_evt_handler(pcm2file->whdl, pcm2file_enc_w_evt, pcm2file);
|
||
enc_write_file_set_input(pcm2file->whdl, &pcm2file_enc_w_input, pcm2file, sizeof(pcm2file->out_file_frame));
|
||
if ((pfmt->coding_type == AUDIO_CODING_WAV) || (pfmt->coding_type == AUDIO_CODING_G726)) {
|
||
pcm2file->file_head_len = WAV_FILE_HEAD_LEN;
|
||
enc_write_file_set_head_handler(pcm2file->whdl, enc_wfile_set_head, pcm2file);
|
||
}
|
||
if (pfmt->coding_type == AUDIO_CODING_MP3) {
|
||
if ((pfmt->sample_rate < 16000) && (pfmt->bit_rate > 64)) {
|
||
pfmt->bit_rate = 64;
|
||
}
|
||
}
|
||
cbuf_init(&pcm2file->pcm_cbuf, pcm2file->pcm_buf, pcm_buf_size);
|
||
audio_encoder_open(&pcm2file->encoder, &pcm2file_enc_input, encode_task);
|
||
audio_encoder_set_handler(&pcm2file->encoder, &pcm2file_enc_handler);
|
||
audio_encoder_set_fmt(&pcm2file->encoder, pfmt);
|
||
audio_encoder_set_output_buffs(&pcm2file->encoder, pcm2file->output_frame,
|
||
sizeof(pcm2file->output_frame), 1);
|
||
|
||
pcm2file->input_busy = 0;
|
||
|
||
return pcm2file;
|
||
__out:
|
||
if (pcm2file_used_overlay == 0) {
|
||
if (pcm2file->pcm_buf) {
|
||
free(pcm2file->pcm_buf);
|
||
}
|
||
if (pcm2file->out_file_buf) {
|
||
free(pcm2file->out_file_buf);
|
||
}
|
||
if (pcm2file) {
|
||
free(pcm2file);
|
||
}
|
||
}
|
||
return NULL;
|
||
}
|
||
|
||
|
||
void pcm2file_enc_close(void **hdl)
|
||
{
|
||
struct pcm2file_enc_hdl *pcm2file = *hdl;
|
||
if (!pcm2file) {
|
||
return;
|
||
}
|
||
os_mutex_pend(&pcm2file->mutex, 0);
|
||
pcm2file->status = 0;
|
||
os_mutex_post(&pcm2file->mutex);
|
||
while (pcm2file->input_busy) {
|
||
os_time_dly(1);
|
||
}
|
||
|
||
audio_encoder_close(&pcm2file->encoder);
|
||
enc_write_file_stop(pcm2file->whdl, 1000);
|
||
enc_write_file_close(pcm2file->whdl);
|
||
|
||
printf("pcm2file_enc_close, lost:%d ", pcm2file->lost);
|
||
|
||
if (pcm2file_used_overlay == 0) {
|
||
#if PCM2FILE_ENC_BUF_COUNT
|
||
printf("pcm_buf_max:%d,%d/100; out_file_max:%d,%d/100 ",
|
||
pcm2file->pcm_buf_max, pcm2file->pcm_buf_max * 100 / PCM_ENC2FILE_PCM_LEN,
|
||
pcm2file->out_file_max, pcm2file->out_file_max * 100 / PCM_ENC2FILE_FILE_LEN
|
||
);
|
||
#endif
|
||
printf("[%s], used malloc, need free!!\n", __FUNCTION__);
|
||
if (pcm2file->pcm_buf) {
|
||
free(pcm2file->pcm_buf);
|
||
}
|
||
if (pcm2file->out_file_buf) {
|
||
free(pcm2file->out_file_buf);
|
||
}
|
||
OS_ENTER_CRITICAL();
|
||
free(pcm2file);
|
||
*hdl = NULL;
|
||
OS_EXIT_CRITICAL();
|
||
} else {
|
||
#if PCM2FILE_ENC_BUF_COUNT
|
||
printf("pcm_buf_max:%d,%d/100; out_file_max:%d,%d/100 ",
|
||
pcm2file->pcm_buf_max, pcm2file->pcm_buf_max * 100 / PCM_ENC2FILE_PCM_LEN_OVERLAY,
|
||
pcm2file->out_file_max, pcm2file->out_file_max * 100 / PCM_ENC2FILE_FILE_LEN_OVERLAY
|
||
);
|
||
#endif
|
||
printf("[%s], used overlay, noneed free!!\n", __FUNCTION__);
|
||
}
|
||
|
||
audio_encoder_task_close();
|
||
/* if (encode_task) { */
|
||
/* audio_encoder_task_del(encode_task); */
|
||
/* free(encode_task); */
|
||
/* encode_task = NULL; */
|
||
/* } */
|
||
}
|
||
|
||
int pcm2file_enc_is_work(void *hdl)
|
||
{
|
||
struct pcm2file_enc_hdl *enc = hdl;
|
||
if (!enc || !enc->status || enc->enc_err) {
|
||
return false;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
int get_pcm2file_enc_file_len(void *hdl)
|
||
{
|
||
struct pcm2file_enc_hdl *pcm2file = hdl;
|
||
return get_enc_file_len(pcm2file->whdl);
|
||
}
|
||
|
||
struct audio_encoder *get_pcm2file_encoder_hdl(void *hdl)
|
||
{
|
||
struct pcm2file_enc_hdl *enc = hdl;
|
||
return &(enc->encoder);
|
||
}
|
||
|
||
|
||
#endif
|
||
|
||
|
||
|
||
|
||
|
||
|