860 lines
23 KiB
C
Executable File
860 lines
23 KiB
C
Executable File
// Copyright 2020-2021 Beken
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
#include "cli.h"
|
|
|
|
#include <os/os.h>
|
|
#include <os/mem.h>
|
|
#include <os/str.h>
|
|
#include <stdio.h>
|
|
#include <driver/aud_dac_types.h>
|
|
#include <driver/aud_dac.h>
|
|
#include <driver/dma.h>
|
|
#include "sys_driver.h"
|
|
//#include "aud_driver.h"
|
|
#include "mp3_demo_types.h"
|
|
#include <driver/audio_ring_buff.h>
|
|
#include <modules/mp3dec.h>
|
|
#include "ff.h"
|
|
#include "diskio.h"
|
|
#if CONFIG_AUD_INTF
|
|
#include "aud_intf.h"
|
|
#include "aud_intf_types.h"
|
|
#endif
|
|
|
|
#define TU_QITEM_COUNT (60)
|
|
#define PCM_SIZE_MAX (MAX_NSAMP * MAX_NCHAN * MAX_NGRAN)
|
|
|
|
static beken_thread_t audio_mp3_play_thread_hdl = NULL;
|
|
static beken_queue_t audio_mp3_play_msg_que = NULL;
|
|
|
|
HMP3Decoder hMP3Decoder;
|
|
MP3FrameInfo mp3FrameInfo;
|
|
unsigned char *readBuf;
|
|
short *pcmBuf;
|
|
int bytesLeft = 0;
|
|
int g_mp3_decode_status = 0;
|
|
int g_mp3_decode_complete_status = 0;
|
|
int g_mp3_play_is_running = 0;
|
|
short *output;
|
|
|
|
FIL mp3file;
|
|
FIL pcmfile;
|
|
uint32 uiTemp = 0;
|
|
uint32 br = 0;
|
|
static char *g_mp3_name;
|
|
static char mp3_file_name[50];
|
|
int offset = 0;
|
|
unsigned char *g_readptr;
|
|
|
|
static dma_id_t mp3_dac_dma_id = DMA_ID_MAX;
|
|
static int32_t *mp3_play_ring_buff = NULL;
|
|
static RingBufferContext mp3_play_rb;
|
|
#if CONFIG_AUD_INTF
|
|
static bool mp3_file_is_empty = false;
|
|
#endif
|
|
|
|
static bk_err_t audio_send_msg(audio_mp3_play_msg_t msg)
|
|
{
|
|
bk_err_t ret = BK_OK;
|
|
|
|
if (audio_mp3_play_msg_que) {
|
|
ret = rtos_push_to_queue(&audio_mp3_play_msg_que, &msg, BEKEN_NO_WAIT);
|
|
if (ret != kNoErr) {
|
|
os_printf("audio_send_msg failed\r\n");
|
|
return kGeneralErr;
|
|
}
|
|
return ret;
|
|
}
|
|
return kNoResourcesErr;
|
|
}
|
|
|
|
static bk_err_t bk_audio_mp3_play_dac_config(void)
|
|
{
|
|
bk_err_t ret = BK_OK;
|
|
aud_dac_config_t dac_config = DEFAULT_AUD_DAC_CONFIG();
|
|
|
|
dac_config.dac_chl = AUD_DAC_CHL_LR;
|
|
/* init audio driver and config dac */
|
|
ret = bk_aud_dac_init(&dac_config);
|
|
if (ret != BK_OK) {
|
|
os_printf("init audio dac fail \r\n");
|
|
goto aud_dac_exit;
|
|
}
|
|
|
|
return BK_OK;
|
|
|
|
aud_dac_exit:
|
|
os_printf("audio dac config fail \r\n");
|
|
bk_aud_dac_deinit();
|
|
return BK_FAIL;
|
|
|
|
}
|
|
|
|
static void audio_mp3_play_dma_finish_isr(void)
|
|
{
|
|
bk_err_t ret = BK_OK;
|
|
audio_mp3_play_msg_t msg;
|
|
|
|
msg.op = AUDIO_MP3_PLAY_START;
|
|
ret = audio_send_msg(msg);
|
|
if (ret != kNoErr) {
|
|
os_printf("mp3 play send msg: %d fails \r\n", msg.op);
|
|
}
|
|
|
|
}
|
|
|
|
static bk_err_t bk_audio_mp3_play_dma_config(dma_id_t dma_id, int32_t *ring_buff_addr, uint32_t ring_buff_size, uint32_t transfer_len)
|
|
{
|
|
bk_err_t ret = BK_OK;
|
|
dma_config_t dma_config;
|
|
uint32_t dac_port_addr;
|
|
|
|
dma_config.mode = DMA_WORK_MODE_REPEAT;
|
|
dma_config.chan_prio = 1;
|
|
dma_config.src.dev = DMA_DEV_DTCM;
|
|
dma_config.src.width = DMA_DATA_WIDTH_32BITS;
|
|
dma_config.dst.dev = DMA_DEV_AUDIO;
|
|
dma_config.dst.width = DMA_DATA_WIDTH_32BITS;
|
|
|
|
/* get dac fifo address */
|
|
if (bk_aud_dac_get_fifo_addr(&dac_port_addr) != BK_OK) {
|
|
os_printf("get dac fifo address failed\r\n");
|
|
return BK_FAIL;
|
|
} else {
|
|
dma_config.dst.addr_inc_en = DMA_ADDR_INC_ENABLE;
|
|
dma_config.dst.addr_loop_en = DMA_ADDR_LOOP_ENABLE;
|
|
dma_config.dst.start_addr = dac_port_addr;
|
|
dma_config.dst.end_addr = dac_port_addr + 4;
|
|
}
|
|
dma_config.src.addr_inc_en = DMA_ADDR_INC_ENABLE;
|
|
dma_config.src.addr_loop_en = DMA_ADDR_LOOP_ENABLE;
|
|
dma_config.src.start_addr = (uint32_t)ring_buff_addr;
|
|
dma_config.src.end_addr = (uint32_t)(ring_buff_addr) + ring_buff_size;
|
|
|
|
/* init dma channel */
|
|
ret = bk_dma_init(dma_id, &dma_config);
|
|
if (ret != BK_OK) {
|
|
os_printf("audio dac dma channel init fail \r\n");
|
|
return BK_FAIL;
|
|
}
|
|
|
|
/* set dma transfer length */
|
|
bk_dma_set_transfer_len(dma_id, transfer_len);
|
|
|
|
//register isr
|
|
bk_dma_register_isr(dma_id, NULL, (void *)audio_mp3_play_dma_finish_isr);
|
|
bk_dma_enable_finish_interrupt(dma_id);
|
|
|
|
return BK_OK;
|
|
|
|
}
|
|
|
|
void bk_audio_mp3_play_decode_init(void)
|
|
{
|
|
readBuf = os_malloc(MAINBUF_SIZE);
|
|
if (readBuf == NULL) {
|
|
os_printf("readBuf malloc failed!\r\n");
|
|
return;
|
|
}
|
|
|
|
pcmBuf = os_malloc(PCM_SIZE_MAX * 2);
|
|
if (pcmBuf == NULL) {
|
|
os_printf("pcmBuf malloc failed!\r\n");
|
|
return;
|
|
}
|
|
|
|
hMP3Decoder = MP3InitDecoder();
|
|
if (hMP3Decoder == 0) {
|
|
os_free(readBuf);
|
|
os_free(pcmBuf);
|
|
os_printf("MP3Decoder init failed!\r\n");
|
|
return;
|
|
}
|
|
|
|
}
|
|
|
|
static void bk_audio_mp3_play_decode_start(DISK_NUMBER disk_id, char *mp3_name, unsigned char **mp3_readptr)
|
|
{
|
|
bk_err_t ret = BK_OK;
|
|
int offset = 0;
|
|
char tag_header[10];
|
|
int tag_size = 0;
|
|
unsigned char *readptr = *mp3_readptr;
|
|
audio_mp3_play_msg_t msg;
|
|
|
|
FRESULT fr;
|
|
|
|
if (!g_mp3_decode_status) {
|
|
/*open file to read mp3 data */
|
|
os_memset(mp3_file_name, 0, sizeof(mp3_file_name)/sizeof(mp3_file_name[0]));
|
|
sprintf(mp3_file_name, "%d:/%s", disk_id, mp3_name);
|
|
fr = f_open(&mp3file, mp3_file_name, FA_OPEN_EXISTING | FA_READ);
|
|
if (fr != FR_OK) {
|
|
os_printf("open %s failed!\r\n", mp3_file_name);
|
|
return;
|
|
}
|
|
|
|
fr = f_read(&mp3file, (void *)tag_header, 10, &uiTemp);
|
|
if (fr != FR_OK) {
|
|
os_printf("read %s failed!\r\n", mp3_file_name);
|
|
return;
|
|
}
|
|
|
|
if (os_memcmp(tag_header, "ID3", 3) == 0) {
|
|
tag_size = ((tag_header[6] & 0x7F) << 21) | ((tag_header[7] & 0x7F) << 14) | ((tag_header[8] & 0x7F) << 7) | (tag_header[9] & 0x7F);
|
|
// os_printf("tag_size = %d\r\n", tag_size);
|
|
f_lseek(&mp3file, tag_size + 10);
|
|
} else {
|
|
os_printf("tag_header not found!\r\n");
|
|
f_lseek(&mp3file, 0);
|
|
}
|
|
|
|
g_mp3_decode_status = 1;
|
|
}
|
|
|
|
/* start mp3 decode */
|
|
if (bytesLeft < MAINBUF_SIZE) {
|
|
os_memmove(readBuf, readptr, bytesLeft);
|
|
// os_printf("mp3file bytesLeft = %d!\r\n", bytesLeft);
|
|
fr = f_read(&mp3file, (void *)(readBuf + bytesLeft), MAINBUF_SIZE - bytesLeft, &br);
|
|
if (fr != FR_OK) {
|
|
os_printf("read %s failed!\r\n", mp3_file_name);
|
|
return;
|
|
}
|
|
|
|
if ((br == 0) && (bytesLeft == 0)) {
|
|
os_printf("uiTemp = 0 and bytesLeft = 0!\r\n");
|
|
msg.op = AUDIO_MP3_PLAY_EXIT;
|
|
ret = audio_send_msg(msg);
|
|
if (ret != kNoErr) {
|
|
os_printf("mp3 play send msg: %d fails \r\n", msg.op);
|
|
}
|
|
return;
|
|
}
|
|
|
|
bytesLeft = bytesLeft + br;
|
|
readptr = readBuf;
|
|
}
|
|
|
|
offset = MP3FindSyncWord(readptr, bytesLeft);
|
|
// os_printf("MP3FindSyncWord offset = %d!\r\n", offset);
|
|
|
|
if (offset < 0) {
|
|
os_printf("MP3FindSyncWord not find!\r\n");
|
|
bytesLeft = 0;
|
|
msg.op = AUDIO_MP3_PLAY_EXIT;
|
|
ret = audio_send_msg(msg);
|
|
if (ret != kNoErr) {
|
|
os_printf("mp3 play send msg: %d fails \r\n", msg.op);
|
|
}
|
|
} else {
|
|
readptr += offset;
|
|
bytesLeft -= offset;
|
|
|
|
ret = MP3Decode(hMP3Decoder, &readptr, &bytesLeft, pcmBuf, 0);
|
|
if (ret != ERR_MP3_NONE) {
|
|
os_printf("MP3Decode failed, err is %d", ret);
|
|
return;
|
|
}
|
|
|
|
MP3GetLastFrameInfo(hMP3Decoder, &mp3FrameInfo);
|
|
// os_printf("Bitrate: %d kb/s, Samprate: %d\r\n", (mp3FrameInfo.bitrate) / 1000, mp3FrameInfo.samprate);
|
|
// os_printf("Channel: %d, Version: %d, Layer: %d\r\n", mp3FrameInfo.nChans, mp3FrameInfo.version, mp3FrameInfo.layer);
|
|
// os_printf("OutputSamps: %d\r\n", mp3FrameInfo.outputSamps);
|
|
*mp3_readptr = readptr;
|
|
}
|
|
|
|
}
|
|
|
|
static void audio_mp3_play_main(void)
|
|
{
|
|
bk_err_t ret = BK_OK;
|
|
unsigned char *readptr;
|
|
uint32_t size = 0;
|
|
|
|
ret = bk_audio_mp3_play_dac_config();
|
|
if (ret != BK_OK) {
|
|
os_printf("audio dac init failed!\r\n");
|
|
return;
|
|
}
|
|
|
|
ret = bk_dma_driver_init();
|
|
if (ret != BK_OK) {
|
|
os_printf("dma driver init failed!\r\n");
|
|
return;
|
|
}
|
|
|
|
/* allocate free DMA channel */
|
|
mp3_dac_dma_id = bk_dma_alloc(DMA_DEV_AUDIO);
|
|
if ((mp3_dac_dma_id < DMA_ID_0) || (mp3_dac_dma_id >= DMA_ID_MAX)) {
|
|
os_printf("mp3 dma malloc failed!\r\n");
|
|
return;
|
|
}
|
|
// os_printf("mp3_dac_dma_id: %d \r\n", mp3_dac_dma_id);
|
|
|
|
/* start mp3 init and decode */
|
|
bk_audio_mp3_play_decode_init();
|
|
readptr = readBuf;
|
|
bk_audio_mp3_play_decode_start(DISK_NUMBER_SDIO_SD, g_mp3_name, &readptr);
|
|
|
|
|
|
mp3_play_ring_buff = os_malloc(PCM_SIZE_MAX * 5);
|
|
if (mp3_play_ring_buff == NULL) {
|
|
os_printf("mp3 play ring buffer malloc failed!\r\n");
|
|
return;
|
|
}
|
|
|
|
ret = bk_audio_mp3_play_dma_config(mp3_dac_dma_id, mp3_play_ring_buff, PCM_SIZE_MAX * 5, mp3FrameInfo.outputSamps * 2);
|
|
if (ret != BK_OK) {
|
|
os_printf("audio mp3 play dma config failed!\r\n");
|
|
return;
|
|
}
|
|
|
|
ring_buffer_init(&mp3_play_rb, (uint8_t*)mp3_play_ring_buff, PCM_SIZE_MAX * 5, mp3_dac_dma_id, RB_DMA_TYPE_READ);
|
|
|
|
bk_aud_dac_set_samp_rate(mp3FrameInfo.samprate);
|
|
|
|
size = ring_buffer_write(&mp3_play_rb, (uint8_t *)pcmBuf, mp3FrameInfo.outputSamps * 2);
|
|
// os_printf("ring buffer write size = %d!\r\n", size);
|
|
|
|
bk_audio_mp3_play_decode_start(DISK_NUMBER_SDIO_SD, g_mp3_name, &readptr);
|
|
size = ring_buffer_write(&mp3_play_rb, (uint8_t *)pcmBuf, mp3FrameInfo.outputSamps * 2);
|
|
// os_printf("ring buffer write size = %d!\r\n", size);
|
|
|
|
bk_aud_dac_start();
|
|
bk_dma_start(mp3_dac_dma_id);
|
|
bk_aud_dac_start();
|
|
|
|
while(1) {
|
|
audio_mp3_play_msg_t msg;
|
|
ret = rtos_pop_from_queue(&audio_mp3_play_msg_que, &msg, BEKEN_WAIT_FOREVER);
|
|
if (kNoErr == ret) {
|
|
switch (msg.op) {
|
|
case AUDIO_MP3_PLAY_PREV:
|
|
break;
|
|
|
|
case AUDIO_MP3_PLAY_NEXT:
|
|
break;
|
|
|
|
case AUDIO_MP3_PLAY_START:
|
|
size = ring_buffer_get_free_size(&mp3_play_rb);
|
|
// os_printf("speaker_rb: free_size=%d \r\n", size);
|
|
if (g_mp3_decode_complete_status == 1) {
|
|
if (size > PCM_SIZE_MAX * 5 - mp3FrameInfo.outputSamps * 2) {
|
|
goto audio_mp3_play_exit;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (size > PCM_SIZE_MAX) {
|
|
bk_audio_mp3_play_decode_start(DISK_NUMBER_SDIO_SD, g_mp3_name, &readptr);
|
|
size = ring_buffer_write(&mp3_play_rb, (uint8_t *)pcmBuf, mp3FrameInfo.outputSamps * 2);
|
|
// os_printf("ring buffer write size = %d!\r\n", size);
|
|
}
|
|
break;
|
|
|
|
case AUDIO_MP3_PLAY_STOP:
|
|
break;
|
|
|
|
case AUDIO_MP3_PLAY_EXIT:
|
|
g_mp3_decode_complete_status = 1;
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
// rtos_delay_milliseconds(10);
|
|
}
|
|
|
|
audio_mp3_play_exit:
|
|
bytesLeft = 0;
|
|
f_close(&mp3file);
|
|
g_mp3_play_is_running = 0;
|
|
g_mp3_decode_status = 0;
|
|
g_mp3_decode_complete_status = 0;
|
|
|
|
MP3FreeDecoder(hMP3Decoder);
|
|
os_free(readBuf);
|
|
os_free(pcmBuf);
|
|
|
|
bk_aud_dac_stop();
|
|
bk_aud_dac_deinit();
|
|
|
|
bk_dma_stop(mp3_dac_dma_id);
|
|
bk_dma_deinit(mp3_dac_dma_id);
|
|
bk_dma_free(DMA_DEV_AUDIO, mp3_dac_dma_id);
|
|
|
|
/* free audio ring buffer */
|
|
ring_buffer_clear(&mp3_play_rb);
|
|
os_free(mp3_play_ring_buff);
|
|
|
|
/* delete msg queue */
|
|
ret = rtos_deinit_queue(&audio_mp3_play_msg_que);
|
|
if (ret != kNoErr) {
|
|
os_printf("delete message queue failed!\r\n");
|
|
}
|
|
audio_mp3_play_msg_que = NULL;
|
|
os_printf("delete message queue completed!\r\n");
|
|
|
|
audio_mp3_play_thread_hdl = NULL;
|
|
ret = rtos_delete_thread(NULL);
|
|
if (ret != kNoErr) {
|
|
os_printf("delete task failed!\r\n");
|
|
}
|
|
|
|
}
|
|
|
|
bk_err_t bk_audio_mp3_play_init(void)
|
|
{
|
|
bk_err_t ret = BK_OK;
|
|
|
|
g_mp3_play_is_running = 1;
|
|
|
|
ret = rtos_init_queue(&audio_mp3_play_msg_que,
|
|
"audio_mp3_play_queue",
|
|
sizeof(audio_mp3_play_msg_t),
|
|
TU_QITEM_COUNT);
|
|
if (ret != kNoErr) {
|
|
os_printf("create audio mp3 play message queue failed!\r\n");
|
|
return BK_FAIL;
|
|
}
|
|
|
|
ret = rtos_create_thread(&audio_mp3_play_thread_hdl,
|
|
BEKEN_DEFAULT_WORKER_PRIORITY,
|
|
"audio_mp3_play",
|
|
(beken_thread_function_t)audio_mp3_play_main,
|
|
4096,
|
|
NULL);
|
|
if (ret != kNoErr) {
|
|
os_printf("create audio mp3 play task fail!\r\n");
|
|
rtos_deinit_queue(&audio_mp3_play_msg_que);
|
|
audio_mp3_play_msg_que = NULL;
|
|
audio_mp3_play_thread_hdl = NULL;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
bk_err_t bk_audio_mp3_play_deinit(void)
|
|
{
|
|
bk_err_t ret = BK_OK;
|
|
|
|
audio_mp3_play_msg_t msg;
|
|
|
|
msg.op = AUDIO_MP3_PLAY_EXIT;
|
|
ret = audio_send_msg(msg);
|
|
if (ret != kNoErr) {
|
|
os_printf("send msg: %d fails \r\n", msg.op);
|
|
return BK_FAIL;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
void cli_mp3_play_test_cmd(char *pcWriteBuffer, int xWriteBufferLen, int argc, char **argv)
|
|
{
|
|
bk_err_t ret = BK_OK;
|
|
|
|
if (argc != 3) {
|
|
os_printf("aud_cp0_audio_mp3_play_test {start|stop} xx.mp3 \r\n");
|
|
return;
|
|
}
|
|
|
|
if (os_strcmp(argv[1], "start") == 0) {
|
|
os_printf("start audio mp3 play test!\r\n");
|
|
|
|
g_mp3_name = argv[2];
|
|
|
|
if (!g_mp3_play_is_running) {
|
|
/* init audio mp3 play task */
|
|
ret = bk_audio_mp3_play_init();
|
|
if (ret != BK_OK) {
|
|
os_printf("init audio mp3 play task fail!\r\n");
|
|
return;
|
|
}
|
|
} else {
|
|
os_printf("mp3 play task is running, please input stop command firstly!\r\n");
|
|
return;
|
|
}
|
|
|
|
} else if (os_strcmp(argv[1], "stop") == 0) {
|
|
os_printf("stop audio mp3 play test!\r\n");
|
|
|
|
ret = bk_audio_mp3_play_deinit();
|
|
if (ret != BK_OK) {
|
|
os_printf("init audio mp3 play task fail!\r\n");
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
static void bk_audio_mp3_decode(void)
|
|
{
|
|
bk_err_t ret = BK_OK;
|
|
|
|
FRESULT fr;
|
|
uint32 uiTemp = 0;
|
|
uint32 uiTemp2 = 0;
|
|
int offset = 0;
|
|
unsigned char *readptr = readBuf;
|
|
|
|
while(1) {
|
|
if (bytesLeft < MAINBUF_SIZE) {
|
|
os_memmove(readBuf, readptr, bytesLeft);
|
|
os_printf("mp3file bytesLeft = %d!\r\n", bytesLeft);
|
|
fr = f_read(&mp3file, (void *)(readBuf + bytesLeft), MAINBUF_SIZE - bytesLeft, &uiTemp);
|
|
if (fr != FR_OK) {
|
|
os_printf("read %s failed!\r\n", mp3_file_name);
|
|
return;
|
|
}
|
|
|
|
if ((uiTemp == 0) && (bytesLeft == 0)) {
|
|
os_printf("uiTemp = 0 and bytesLeft = 0\r\n");
|
|
return;
|
|
}
|
|
|
|
bytesLeft = bytesLeft + uiTemp;
|
|
readptr = readBuf;
|
|
}
|
|
|
|
offset = MP3FindSyncWord(readptr, bytesLeft);
|
|
os_printf("MP3FindSyncWord offset = %d!\r\n", offset);
|
|
|
|
if (offset < 0) {
|
|
os_printf("MP3FindSyncWord not find!\r\n");
|
|
bytesLeft = 0;
|
|
} else {
|
|
readptr += offset;
|
|
bytesLeft -= offset;
|
|
|
|
ret = MP3Decode(hMP3Decoder, &readptr, &bytesLeft, output, 0);
|
|
if (ret != ERR_MP3_NONE) {
|
|
os_printf("MP3Decode failed, code is %d", ret);
|
|
return;
|
|
}
|
|
|
|
fr = f_write(&pcmfile, (void *)output, mp3FrameInfo.outputSamps * 2, &uiTemp2);
|
|
if (fr != FR_OK) {
|
|
os_printf("write pcm file failed.\r\n");
|
|
return;
|
|
}
|
|
|
|
MP3GetLastFrameInfo(hMP3Decoder, &mp3FrameInfo);
|
|
os_printf("Bitrate: %d kb/s, Samprate: %d\r\n", (mp3FrameInfo.bitrate) / 1000, mp3FrameInfo.samprate);
|
|
os_printf("Channel: %d, Version: %d, Layer: %d\r\n", mp3FrameInfo.nChans, mp3FrameInfo.version, mp3FrameInfo.layer);
|
|
os_printf("OutputSamps: %d\r\n", mp3FrameInfo.outputSamps);
|
|
}
|
|
}
|
|
}
|
|
|
|
void cli_mp3_decode_test_cmd(char *pcWriteBuffer, int xWriteBufferLen, int argc, char **argv)
|
|
{
|
|
FRESULT fr;
|
|
static char pcm_file_name[50];
|
|
uint32 uiTemp = 0;
|
|
char tag_header[10];
|
|
int tag_size = 0;
|
|
|
|
readBuf = os_malloc(MAINBUF_SIZE);
|
|
if (readBuf == NULL) {
|
|
os_printf("readBuf malloc failed\r\n");
|
|
return;
|
|
}
|
|
|
|
output = os_malloc(PCM_SIZE_MAX * 2);
|
|
if (output == NULL) {
|
|
os_free(readBuf);
|
|
os_printf("outBuf malloc failed");
|
|
return;
|
|
}
|
|
|
|
if (argc != 4) {
|
|
os_printf("mp3_decode_test {start|stop} xx.mp3 xx.pcm \r\n");
|
|
return;
|
|
}
|
|
|
|
if (os_strcmp(argv[1], "start") == 0) {
|
|
os_printf("start audio mp3 decode test!\r\n");
|
|
|
|
hMP3Decoder = MP3InitDecoder();
|
|
if (hMP3Decoder == 0) {
|
|
os_free(readBuf);
|
|
os_free(output);
|
|
os_printf("hMP3Decoder malloc failed!\r\n");
|
|
return;
|
|
}
|
|
|
|
os_printf("MP3InitDecoder init successful!\r\n");
|
|
|
|
/*open file to read mp3 data */
|
|
sprintf(mp3_file_name, "%d:/%s", DISK_NUMBER_SDIO_SD, argv[2]);
|
|
fr = f_open(&mp3file, mp3_file_name, FA_OPEN_EXISTING | FA_READ);
|
|
if (fr != FR_OK) {
|
|
MP3FreeDecoder(hMP3Decoder);
|
|
os_free(readBuf);
|
|
os_free(output);
|
|
os_printf("open %s failed!\r\n", mp3_file_name);
|
|
return;
|
|
}
|
|
os_printf("mp3 file open successfully!\r\n");
|
|
|
|
sprintf(pcm_file_name, "%d:/%s", DISK_NUMBER_SDIO_SD, argv[3]);
|
|
fr = f_open(&pcmfile, pcm_file_name, FA_CREATE_ALWAYS | FA_WRITE);
|
|
if (fr != FR_OK) {
|
|
os_printf("open %s failed!\r\n", pcm_file_name);
|
|
return;
|
|
}
|
|
os_printf("pcm file open successfully!\r\n");
|
|
|
|
fr = f_read(&mp3file, (void *)tag_header, 10, &uiTemp);
|
|
if (fr != FR_OK) {
|
|
os_printf("read %s failed!\r\n", mp3_file_name);
|
|
return;
|
|
}
|
|
os_printf("mp3file read successfully!\r\n");
|
|
|
|
if (os_memcmp(tag_header, "ID3", 3) == 0) {
|
|
tag_size = ((tag_header[6] & 0x7F) << 21) | ((tag_header[7] & 0x7F) << 14) | ((tag_header[8] & 0x7F) << 7) | (tag_header[9] & 0x7F);
|
|
os_printf("tag_size = %d\r\n", tag_size);
|
|
f_lseek(&mp3file, tag_size + 10);
|
|
os_printf("tag_header has found!\r\n");
|
|
} else {
|
|
os_printf("tag_header not found!\r\n");
|
|
f_lseek(&mp3file, 0);
|
|
}
|
|
|
|
bk_audio_mp3_decode();
|
|
|
|
fr = f_close(&pcmfile);
|
|
if (fr != FR_OK) {
|
|
os_printf("close %s fail!\r\n", pcm_file_name);
|
|
return;
|
|
}
|
|
|
|
os_printf("start audio mp3 play test successful!\r\n");
|
|
} else if (os_strcmp(argv[1], "stop") == 0) {
|
|
MP3FreeDecoder(hMP3Decoder);
|
|
os_free(readBuf);
|
|
os_free(output);
|
|
|
|
/* close mp3 file */
|
|
fr = f_close(&mp3file);
|
|
if (fr != FR_OK) {
|
|
os_printf("close %s fail!\r\n", mp3_file_name);
|
|
return;
|
|
}
|
|
|
|
os_printf("stop audio mp3 play test successful!\r\n");
|
|
} else {
|
|
os_printf("mp3_decode_test {start|stop} xx.mp3 xx.pcm \r\n");
|
|
return;
|
|
}
|
|
|
|
}
|
|
|
|
#if CONFIG_AUD_INTF
|
|
static bk_err_t mp3_decode_handler(unsigned int size)
|
|
{
|
|
bk_err_t ret = BK_OK;
|
|
|
|
FRESULT fr;
|
|
uint32 uiTemp = 0;
|
|
|
|
if (mp3_file_is_empty) {
|
|
os_printf("==========================================================\r\n");
|
|
os_printf("%s playback is over, please input the stop command!\r\n", mp3_file_name);
|
|
os_printf("==========================================================\r\n");
|
|
return BK_FAIL;
|
|
}
|
|
|
|
if (bytesLeft < MAINBUF_SIZE) {
|
|
os_memmove(readBuf, g_readptr, bytesLeft);
|
|
fr = f_read(&mp3file, (void *)(readBuf + bytesLeft), MAINBUF_SIZE - bytesLeft, &uiTemp);
|
|
if (fr != FR_OK) {
|
|
os_printf("read %s failed!\r\n", mp3_file_name);
|
|
return fr;
|
|
}
|
|
|
|
if ((uiTemp == 0) && (bytesLeft == 0)) {
|
|
os_printf("uiTemp = 0 and bytesLeft = 0\r\n");
|
|
mp3_file_is_empty = true;
|
|
os_printf("the %s is empty \r\n", mp3_file_name);
|
|
return ret;
|
|
}
|
|
|
|
bytesLeft = bytesLeft + uiTemp;
|
|
g_readptr = readBuf;
|
|
}
|
|
|
|
offset = MP3FindSyncWord(g_readptr, bytesLeft);
|
|
|
|
if (offset < 0) {
|
|
os_printf("MP3FindSyncWord not find!\r\n");
|
|
bytesLeft = 0;
|
|
} else {
|
|
g_readptr += offset;
|
|
bytesLeft -= offset;
|
|
|
|
ret = MP3Decode(hMP3Decoder, &g_readptr, &bytesLeft, pcmBuf, 0);
|
|
if (ret != ERR_MP3_NONE) {
|
|
os_printf("MP3Decode failed, code is %d", ret);
|
|
return ret;
|
|
}
|
|
|
|
MP3GetLastFrameInfo(hMP3Decoder, &mp3FrameInfo);
|
|
// os_printf("Bitrate: %d kb/s, Samprate: %d\r\n", (mp3FrameInfo.bitrate) / 1000, mp3FrameInfo.samprate);
|
|
// os_printf("Channel: %d, Version: %d, Layer: %d\r\n", mp3FrameInfo.nChans, mp3FrameInfo.version, mp3FrameInfo.layer);
|
|
// os_printf("OutputSamps: %d\r\n", mp3FrameInfo.outputSamps);
|
|
|
|
/* write a frame speaker data to speaker_ring_buff */
|
|
ret = bk_aud_intf_write_spk_data((uint8_t*)pcmBuf, mp3FrameInfo.outputSamps * 2);
|
|
if (ret != BK_OK) {
|
|
os_printf("write spk data fail \r\n");
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
void cli_aud_intf_mp3_play_test_cmd(char *pcWriteBuffer, int xWriteBufferLen, int argc, char **argv)
|
|
{
|
|
bk_err_t ret = BK_ERR_AUD_INTF_OK;
|
|
FRESULT fr;
|
|
|
|
aud_intf_drv_setup_t aud_intf_drv_setup = DEFAULT_AUD_INTF_DRV_SETUP_CONFIG();
|
|
aud_intf_spk_setup_t aud_intf_spk_setup = DEFAULT_AUD_INTF_SPK_SETUP_CONFIG();
|
|
aud_intf_work_mode_t aud_work_mode = AUD_INTF_WORK_MODE_NULL;
|
|
|
|
if (argc != 3) {
|
|
os_printf("aud_intf_mp3_play_test {start|stop} xx.mp3\r\n");
|
|
return;
|
|
}
|
|
|
|
if (os_strcmp(argv[1], "start") == 0) {
|
|
bk_audio_mp3_play_decode_init();
|
|
os_printf("audio mp3 play decode init completely!\r\n");
|
|
|
|
/*open file to read mp3 data */
|
|
os_memset(mp3_file_name, 0, sizeof(mp3_file_name)/sizeof(mp3_file_name[0]));
|
|
sprintf(mp3_file_name, "%d:/%s", DISK_NUMBER_SDIO_SD, argv[2]);
|
|
fr = f_open(&mp3file, mp3_file_name, FA_OPEN_EXISTING | FA_READ);
|
|
if (fr != FR_OK) {
|
|
MP3FreeDecoder(hMP3Decoder);
|
|
os_free(readBuf);
|
|
os_free(output);
|
|
os_printf("open %s failed!\r\n", mp3_file_name);
|
|
return;
|
|
}
|
|
os_printf("mp3 file open successfully!\r\n");
|
|
|
|
//aud_intf_drv_setup.work_mode = AUD_INTF_WORK_MODE_NULL;
|
|
//aud_intf_drv_setup.task_config.priority = 3;
|
|
aud_intf_drv_setup.aud_intf_rx_spk_data = mp3_decode_handler;
|
|
//aud_intf_drv_setup.aud_intf_tx_mic_data = NULL;
|
|
ret = bk_aud_intf_drv_init(&aud_intf_drv_setup);
|
|
if (ret != BK_ERR_AUD_INTF_OK) {
|
|
os_printf("bk_aud_intf_drv_init fail, ret:%d \r\n", ret);
|
|
} else {
|
|
os_printf("bk_aud_intf_drv_init complete \r\n");
|
|
}
|
|
|
|
aud_work_mode = AUD_INTF_WORK_MODE_GENERAL;
|
|
ret = bk_aud_intf_set_mode(aud_work_mode);
|
|
if (ret != BK_ERR_AUD_INTF_OK) {
|
|
os_printf("bk_aud_intf_set_mode fail, ret:%d \r\n", ret);
|
|
} else {
|
|
os_printf("bk_aud_intf_set_mode complete \r\n");
|
|
}
|
|
|
|
g_readptr = readBuf;
|
|
mp3_decode_handler(mp3FrameInfo.outputSamps * 2);
|
|
|
|
aud_intf_spk_setup.spk_chl = AUD_INTF_SPK_CHL_DUAL;
|
|
aud_intf_spk_setup.samp_rate = mp3FrameInfo.samprate;
|
|
aud_intf_spk_setup.frame_size = mp3FrameInfo.outputSamps * 2;
|
|
//aud_intf_spk_setup.spk_gain = 0x2d;
|
|
aud_intf_spk_setup.work_mode = AUD_DAC_WORK_MODE_DIFFEN;
|
|
//aud_intf_spk_setup.spk_type = AUD_INTF_SPK_TYPE_BOARD;
|
|
ret = bk_aud_intf_spk_init(&aud_intf_spk_setup);
|
|
if (ret != BK_ERR_AUD_INTF_OK) {
|
|
os_printf("bk_aud_intf_spk_init fail, ret:%d \r\n", ret);
|
|
} else {
|
|
os_printf("bk_aud_intf_spk_init complete \r\n");
|
|
}
|
|
|
|
ret = bk_aud_intf_spk_start();
|
|
if (ret != BK_ERR_AUD_INTF_OK) {
|
|
os_printf("bk_aud_intf_spk_start fail, ret:%d \r\n", ret);
|
|
} else {
|
|
os_printf("bk_aud_intf_spk_start complete \r\n");
|
|
}
|
|
|
|
}else if (os_strcmp(argv[1], "stop") == 0) {
|
|
ret = bk_aud_intf_spk_stop();
|
|
if (ret != BK_ERR_AUD_INTF_OK) {
|
|
os_printf("bk_aud_intf_spk_stop fail, ret:%d \r\n", ret);
|
|
} else {
|
|
os_printf("bk_aud_intf_spk_stop complete \r\n");
|
|
}
|
|
|
|
ret = bk_aud_intf_spk_deinit();
|
|
if (ret != BK_ERR_AUD_INTF_OK) {
|
|
os_printf("bk_aud_intf_spk_deinit fail, ret:%d \r\n", ret);
|
|
} else {
|
|
os_printf("bk_aud_intf_spk_deinit complete \r\n");
|
|
}
|
|
|
|
ret = bk_aud_intf_drv_deinit();
|
|
if (ret != BK_ERR_AUD_INTF_OK) {
|
|
os_printf("bk_aud_intf_drv_deinit fail, ret:%d \r\n", ret);
|
|
} else {
|
|
os_printf("bk_aud_intf_drv_deinit complete \r\n");
|
|
}
|
|
|
|
bytesLeft = 0;
|
|
mp3_file_is_empty = false;
|
|
|
|
fr = f_close(&mp3file);
|
|
if (fr != FR_OK) {
|
|
os_printf("close %s fail!\r\n", mp3_file_name);
|
|
return;
|
|
}
|
|
|
|
MP3FreeDecoder(hMP3Decoder);
|
|
os_free(readBuf);
|
|
os_free(pcmBuf);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
#define MP3_CMD_CNT (sizeof(s_mp3_commands) / sizeof(struct cli_command))
|
|
static const struct cli_command s_mp3_commands[] = {
|
|
{"mp3_decode_test", "mp3_decode_test {start|stop} xx.mp3 xx.pcm", cli_mp3_decode_test_cmd},
|
|
{"mp3_play_test", "mp3_play_test {start|stop} xx.mp3", cli_mp3_play_test_cmd},
|
|
#if CONFIG_AUD_INTF
|
|
{"aud_intf_mp3_play_test", "aud_intf_mp3_play_test {start|stop} xx.mp3", cli_aud_intf_mp3_play_test_cmd},
|
|
#endif
|
|
};
|
|
|
|
int cli_mp3_init(void)
|
|
{
|
|
return cli_register_commands(s_mp3_commands, MP3_CMD_CNT);
|
|
}
|
|
|