pinebuds/apps/audioplayers/bt_sco_chain_cp.c

232 lines
6.4 KiB
C

/***************************************************************************
*
* Copyright 2015-2019 BES.
* All rights reserved. All unpublished rights reserved.
*
* No part of this work may be used or reproduced in any form or by any
* means, or stored in a database or retrieval system, without prior written
* permission of BES.
*
* Use of this work is governed by a license granted by BES.
* This work contains confidential and proprietary information of
* BES. which is protected by copyright, trade secret,
* trademark and other intellectual property rights.
*
****************************************************************************/
/**
* Usage:
* 1. Enable SCO_CP_ACCEL ?= 1 to enable dual core in sco
* 2. Enable SCO_TRACE_CP_ACCEL ?= 1 to see debug log.
* 3. Change channel number if the algo(run in cp) input is more than one
*channel: sco_cp_init(speech_tx_frame_len, 1);
* 4. The code between SCO_CP_ACCEL_ALGO_START(); and SCO_CP_ACCEL_ALGO_END();
*will run in CP core.
* 5. These algorithms will work in AP. Need to move this algorithms from
*overlay to fast ram.
*
* NOTE:
* 1. spx fft and hw fft will share buffer, so just one core can use these
*fft.
* 2. audio_dump_add_channel_data function can not work correctly in CP core,
*because audio_dump_add_channel_data is possible called after audio_dump_run();
* 3. AP and CP just can use 85%
*
*
*
* TODO:
* 1. FFT, RAM, CODE overlay
**/
#if defined(SCO_CP_ACCEL)
#include "cmsis_os.h"
#include "cp_accel.h"
#include "hal_location.h"
#include "hal_timer.h"
#include "hal_trace.h"
#include "math.h"
#include "norflash_api.h"
#include "speech_cfg.h"
// malloc data from pool in init function
#define FRAME_LEN_MAX (256)
#define CHANNEL_NUM_MAX (2)
enum CP_SCO_STATE_T {
CP_SCO_STATE_NONE = 0,
CP_SCO_STATE_IDLE,
CP_SCO_STATE_WORKING,
};
enum SCO_CP_CMD_T {
SCO_CP_CMD_PRO = 0,
SCO_CP_CMD_OTHER,
SCO_CP_CMD_QTY,
};
static CP_DATA_LOC enum CP_SCO_STATE_T g_cp_state = CP_SCO_STATE_NONE;
// TODO: Use malloc to replace array
// static CP_BSS_LOC char g_cp_heap_buf[1024 * 100];
static CP_BSS_LOC short g_in_pcm_buf[FRAME_LEN_MAX * CHANNEL_NUM_MAX];
static CP_BSS_LOC short g_out_pcm_buf[FRAME_LEN_MAX * CHANNEL_NUM_MAX];
static CP_BSS_LOC short g_in_ref_buf[FRAME_LEN_MAX];
static CP_BSS_LOC int g_pcm_len;
static CP_BSS_LOC int g_frame_len;
static CP_BSS_LOC int g_channel_num;
static int g_require_cnt = 0;
static int g_run_cnt = 0;
int sco_cp_process(short *pcm_buf, short *ref_buf, int *_pcm_len) {
int32_t pcm_len = *_pcm_len;
uint32_t wait_cnt = 0;
ASSERT(g_frame_len * g_channel_num == pcm_len,
"[%s] g_frame_len(%d) * g_channel_num(%d) != pcm_len(%d)", __func__,
g_frame_len, g_channel_num, pcm_len);
// Check CP has new data to get and can get data from buffer
#if defined(SCO_TRACE_CP_ACCEL)
TRACE(4, "[%s] g_require_cnt: %d, status: %d, pcm_len: %d", __func__,
g_require_cnt, g_cp_state, pcm_len);
#endif
while (g_cp_state == CP_SCO_STATE_WORKING) {
hal_sys_timer_delay_us(10);
if (wait_cnt++ > 300000) { // 3s
ASSERT(0, "cp is hung %d", g_cp_state);
}
}
if (g_cp_state == CP_SCO_STATE_IDLE) {
speech_copy_int16(g_in_pcm_buf, pcm_buf, pcm_len);
if (ref_buf) {
speech_copy_int16(g_in_ref_buf, ref_buf, pcm_len / g_channel_num);
}
speech_copy_int16(pcm_buf, g_out_pcm_buf, g_pcm_len);
*_pcm_len = g_pcm_len;
g_pcm_len = pcm_len;
g_require_cnt++;
g_cp_state = CP_SCO_STATE_WORKING;
cp_accel_send_event_mcu2cp(
CP_BUILD_ID(CP_TASK_SCO, CP_EVENT_SCO_PROCESSING));
} else {
// Multi channels to one channel
#if 0
for (int i = 0; i < pcm_len / g_channel_num; i++)
{
pcm_buf[i] = pcm_buf[2*i];
}
*_pcm_len = pcm_len / g_channel_num;
#endif
// Check abs(g_require_cnt - g_run_cnt) > threshold, reset or assert
TRACE(2, "[%s] ERROR: status = %d", __func__, g_cp_state);
}
return 0;
}
extern int sco_cp_algo(short *pcm_buf, short *ref_buf, int *_pcm_len);
CP_TEXT_SRAM_LOC
static unsigned int sco_cp_main(uint8_t event) {
#if defined(SCO_TRACE_CP_ACCEL)
TRACE(2, "[%s] g_run_cnt: %d", __func__, g_run_cnt);
#endif
// LOCK BUFFER
// process pcm
#if 0
// speech_copy_int16(g_out_pcm_buf, g_in_pcm_buf, g_pcm_len);
for (int i = 0; i < g_pcm_len; i++)
{
g_out_pcm_buf[i] = (short)(sinf(2 * 3.1415926 * i / 16 ) * 10000);
}
#else
sco_cp_algo(g_in_pcm_buf, g_in_ref_buf, &g_pcm_len);
speech_copy_int16(g_out_pcm_buf, g_in_pcm_buf, g_pcm_len);
#endif
// set status
g_run_cnt++;
g_cp_state = CP_SCO_STATE_IDLE;
#if defined(SCO_TRACE_CP_ACCEL)
TRACE(1, "[%s] CP_SCO_STATE_IDLE", __func__);
#endif
// UNLOCK BUFFER
return 0;
}
static struct cp_task_desc TASK_DESC_SCO = {CP_ACCEL_STATE_CLOSED, sco_cp_main,
NULL, NULL, NULL};
int sco_cp_init(int frame_len, int channel_num) {
TRACE(3, "[%s] frame_len: %d, channel_num: %d", __func__, frame_len,
channel_num);
ASSERT(frame_len <= FRAME_LEN_MAX, "[%s] frame_len(%d) > FRAME_LEN_MAX",
__func__, frame_len);
ASSERT(channel_num <= CHANNEL_NUM_MAX,
"[%s] channel_num(%d) > CHANNEL_NUM_MAX", __func__, channel_num);
g_require_cnt = 0;
g_run_cnt = 0;
norflash_api_flush_disable(NORFLASH_API_USER_CP,
(uint32_t)cp_accel_init_done);
cp_accel_open(CP_TASK_SCO, &TASK_DESC_SCO);
uint32_t cnt = 0;
while (cp_accel_init_done() == false) {
hal_sys_timer_delay_us(100);
cnt++;
if (cnt % 10 == 0) {
if (cnt == 10 * 200) { // 200ms
ASSERT(0, "[%s] ERROR: Can not init cp!!!", __func__);
} else {
TRACE(1, "[%s] Wait CP init done...%d(ms)", __func__, cnt / 10);
}
}
}
norflash_api_flush_enable(NORFLASH_API_USER_CP);
#if 0
speech_heap_cp_start();
speech_heap_add_block(g_cp_heap_buf, sizeof(g_cp_heap_buf));
speech_heap_cp_end();
#endif
g_frame_len = frame_len;
g_channel_num = channel_num;
g_pcm_len = frame_len; // Initialize output pcm_len
speech_set_int16(g_in_pcm_buf, 0, g_frame_len * g_channel_num);
speech_set_int16(g_out_pcm_buf, 0, g_frame_len * g_channel_num);
speech_set_int16(g_in_ref_buf, 0, g_frame_len);
g_cp_state = CP_SCO_STATE_IDLE;
TRACE(2, "[%s] status = %d", __func__, g_cp_state);
return 0;
}
int sco_cp_deinit(void) {
TRACE(1, "[%s] ...", __func__);
cp_accel_close(CP_TASK_SCO);
g_cp_state = CP_SCO_STATE_NONE;
return 0;
}
#endif