lmx/99_7018_lmx
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

first

Browse Source
This commit is contained in:
lmx
2025-10-29 13:10:02 +08:00
commit 49a07fa419
2284 changed files with 642060 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

89
apps/common/music/breakpoint.c Normal file
View File

@ -0,0 +1,89 @@
#include "breakpoint.h"
#include "app_config.h"
#include "vm.h"
#include "system/syscfg_id.h"
#if (defined(TCFG_DEC_APE_ENABLE) && (TCFG_DEC_APE_ENABLE))
#define BREAKPOINT_DATA_LEN (2036 + 4)
#elif (defined(TCFG_DEC_FLAC_ENABLE) && (TCFG_DEC_FLAC_ENABLE))
#define BREAKPOINT_DATA_LEN 688
#elif (TCFG_DEC_M4A_ENABLE || TCFG_DEC_ALAC_ENABLE)
#define BREAKPOINT_DATA_LEN 536
#endif
#ifdef CONFIG_CPU_BR18
#ifndef BREAKPOINT_DATA_LEN
#define BREAKPOINT_DATA_LEN 80
#endif
#else
#ifndef BREAKPOINT_DATA_LEN
#define BREAKPOINT_DATA_LEN 32
#endif
#endif
#define BREAKPOINT_VAILD_SIZE(p) ((p)->dbp.len + ((u32)(p)->dbp.data - (u32)(p)))
struct __breakpoint *breakpoint_handle_creat(void)
{
struct __breakpoint *bp = (struct __breakpoint *)zalloc(sizeof(struct __breakpoint) + BREAKPOINT_DATA_LEN);
bp->dbp.data_len = BREAKPOINT_DATA_LEN;
return bp;
}
void breakpoint_handle_destroy(struct __breakpoint **bp)
{
if (bp && *bp) {
free(*bp);
*bp = NULL;
}
}
bool breakpoint_vm_read(struct __breakpoint *bp, char *logo)
{
if (bp == NULL || logo == NULL) {
return false;
}
u16 vm_id;
if (!strcmp(logo, "sd0")) {
vm_id = CFG_SD0_BREAKPOINT0;
} else if (!strcmp(logo, "sd1")) {
vm_id = CFG_SD1_BREAKPOINT0;
} else if (!strcmp(logo, "udisk0")) {
vm_id = CFG_USB_BREAKPOINT0;
} else {
return false;
}
int rlen = vm_api_read_mult(vm_id, vm_id + 10, bp, sizeof(struct __breakpoint) + BREAKPOINT_DATA_LEN);
if (rlen == 0) {
memset(bp, 0, sizeof(struct __breakpoint) + BREAKPOINT_DATA_LEN);
bp->dbp.data_len = BREAKPOINT_DATA_LEN;
return false;
} else {
}
return true;
}
void breakpoint_vm_write(struct __breakpoint *bp, char *logo)
{
if (bp == NULL || logo == NULL) {
return ;
}
u16 vm_id;
if (!strcmp(logo, "sd0")) {
vm_id = CFG_SD0_BREAKPOINT0;
} else if (!strcmp(logo, "sd1")) {
vm_id = CFG_SD1_BREAKPOINT0;
} else if (!strcmp(logo, "udisk0")) {
vm_id = CFG_USB_BREAKPOINT0;
} else {
return ;
}
printf("%s %s ok\n", logo, __FUNCTION__);
vm_api_write_mult(vm_id, vm_id + 10, bp, BREAKPOINT_VAILD_SIZE(bp), 2);
}

14
apps/common/music/breakpoint.h Normal file
View File

@ -0,0 +1,14 @@
#ifndef __BREAKPOINT_H__
#define __BREAKPOINT_H__
#include "system/includes.h"
#include "media/audio_decoder.h"
#include "music/music_player.h"
struct __breakpoint *breakpoint_handle_creat(void);
void breakpoint_handle_destroy(struct __breakpoint **bp);
bool breakpoint_vm_read(struct __breakpoint *bp, char *logo);
void breakpoint_vm_write(struct __breakpoint *bp, char *logo);
#endif//__BREAKPOINT_H__

184
apps/common/music/music_decrypt.c Normal file
View File

@ -0,0 +1,184 @@
#include "system/app_core.h"
#include "system/includes.h"
#include "app_config.h"
#include "music/music_decrypt.h"
#include "system/fs/fs.h"
#if (TCFG_DEC_DECRYPT_ENABLE)
#define LOG_TAG_CONST APP_MUSIC
#define LOG_TAG "[APP_MUSIC_CIPHER]"
#define LOG_ERROR_ENABLE
#define LOG_DEBUG_ENABLE
#define LOG_INFO_ENABLE
/* #define LOG_DUMP_ENABLE */
#define LOG_CLI_ENABLE
#include "debug.h"
/*----------------------------------------------------------------------------*/
/**@brief 解密读使能开关
@param u8 ctl
@return 无
@note void cipher_ctl(u8 ctl)
*/
/*----------------------------------------------------------------------------*/
static void cipher_ctl(CIPHER *pcipher, u8 ctl)
{
pcipher->cipher_enable = ctl;
}
/*----------------------------------------------------------------------------*/
/**@brief 解密读文件数据的回调函数，用于底层的物理读
@param void* buf, u32 lba
@return 无
@note void cryptanalysis_buff(void* buf, u32 faddr, u32 len)
*/
/*----------------------------------------------------------------------------*/
#define ALIN_SIZE 4
void cryptanalysis_buff(CIPHER *pcipher, void *buf, u32 faddr, u32 len)
{
u32 i;
u8 j;
u8 head_rem;//
u8 tail_rem;//
u32 len_ali;
u8 *buf_1b_ali;
u8 *cipher_code;
cipher_code = (u8 *)&pcipher->cipher_code;
if (!pcipher->cipher_enable) {
return;
}
/* log_info("----faddr = %d \n",faddr); */
/* put_buf(buf,len); */
/* log_info("buf_addr = %d \n", buf); */
head_rem = ALIN_SIZE - (faddr % ALIN_SIZE);
if (head_rem == ALIN_SIZE) {
head_rem = 0;
}
if (head_rem > len) {
head_rem = len;
}
if (len - head_rem) {
tail_rem = (faddr + len) % ALIN_SIZE;
} else {
tail_rem = 0;
}
/* log_info("head_rem = %d tail_rem = %d \n", head_rem, tail_rem); */
/* log_info("deal_head_buf\n"); */
buf_1b_ali = buf;
j = 3;
for (i = head_rem; i > 0; i--) {
buf_1b_ali[i - 1] ^= cipher_code[j--];
/* log_info("i = %d \n", i - 1); */
/* log_info("buf_1b_ali[i] = %x \n", buf_1b_ali[i - 1]); */
}
/* log_info("\n\n-----------TEST_HEAD-----------------"); */
/* put_buf(buf_1b_ali, head_rem); */
/* log_info("deal_main_buf\n"); */
buf_1b_ali = buf;
buf_1b_ali = (u8 *)(buf_1b_ali + head_rem);
len_ali = len - head_rem - tail_rem;
/* log_info("len_ali = %d \n", len_ali); */
/* log_info("buf_1b_ali = %d \n", buf_1b_ali); */
for (i = 0; i < (len_ali / 4); i++) {
buf_1b_ali[0 + i * 4] ^= cipher_code[0];
buf_1b_ali[1 + i * 4] ^= cipher_code[1];
buf_1b_ali[2 + i * 4] ^= cipher_code[2];
buf_1b_ali[3 + i * 4] ^= cipher_code[3];
}
/* log_info("\n\n-----------TEST_MAIN-----------------"); */
/* put_buf(buf_1b_ali, len_ali); */
/* log_info("deal_tail_buf\n"); */
buf_1b_ali = buf;
buf_1b_ali += len - tail_rem;
j = 0;
for (i = 0 ; i < tail_rem; i++) {
buf_1b_ali[i] ^= cipher_code[j++];
}
/* log_info("\n\n-----------TEST_TAIL-----------------"); */
/* put_buf(buf_1b_ali, tail_rem); */
/* log_info("\n\n-----------TEST-----------------"); */
/* put_buf(buf,len); */
}
/*----------------------------------------------------------------------------*/
/**@brief 解密判断
@param void *file：当前解码文件的句柄
@return 无
@note void cipher_check_decode_file(void *file)
*/
/*----------------------------------------------------------------------------*/
void cipher_check_decode_file(CIPHER *pcipher, void *file)
{
int rlen;
u8 name[128];
memset(name, 0, sizeof(name));
rlen = fget_name(file, name, sizeof(name));
/* log_info("rlen:%d \n", rlen); */
/* put_buf(name, sizeof(name)); */
u8 *ext_name = strrchr(name, '.');
if (ext_name == NULL) {
// 可能是83结构文件名
int name_len = strlen(name);
if (name_len > 3) {
rlen = name_len - 4;
goto __check_ext;
}
}
while (rlen--) {
if ((name[rlen] >= 'a') && (name[rlen] <= 'z')) {
name[rlen] = name[rlen] - 'a' + 'A';
}
if (name[rlen] != '.') {
continue;
}
__check_ext:
/* log_info("file exname : %s \n", &name[rlen+1]); */
/* log_info("rlen:%d \n", rlen); */
/* put_buf(name, sizeof(name)); */
if (((name[rlen + 1] == 'S') && (name[rlen + 2] == 'M') && (name[rlen + 3] == 'P')) // assci
|| ((name[rlen + 2] == 'S') && (name[rlen + 4] == 'M') && (name[rlen + 6] == 'P')) // unicode
) {
log_info("\n----It's a SMP FILE---\n");
cipher_ctl(pcipher, 1);
}
return;
}
cipher_ctl(pcipher, 0);
}
/*----------------------------------------------------------------------------*/
/**@brief 解密读初始化
@param 无
@return 无
@note void cipher_init(u32 key)
*/
/*----------------------------------------------------------------------------*/
void cipher_init(CIPHER *pcipher, u32 key)
{
pcipher->cipher_code = key;
cipher_ctl(pcipher, 0);
}
/*----------------------------------------------------------------------------*/
/**@brief 解密读初关闭
@param 无
@return 无
@note void cipher_close(void)
*/
/*----------------------------------------------------------------------------*/
void cipher_close(CIPHER *pcipher)
{
cipher_ctl(pcipher, 0);
}
#endif

19
apps/common/music/music_decrypt.h Normal file
View File

@ -0,0 +1,19 @@
#ifndef __MUSIC_DECRYPT_H__
#define __MUSIC_DECRYPT_H__
#include "typedef.h"
typedef struct _CIPHER {
u32 cipher_code; ///>解密key
u8 cipher_enable; ///>解密读使能
} CIPHER;
void cryptanalysis_buff(CIPHER *pcipher, void *buf, u32 faddr, u32 len);
void cipher_check_decode_file(CIPHER *pcipher, void *file);
void cipher_init(CIPHER *pcipher, u32 key);
void cipher_close(CIPHER *pcipher);
#endif //__MUSIC_DECRYPT_H__

310
apps/common/music/music_id3.c Normal file
View File

@ -0,0 +1,310 @@
#include "system/app_core.h"
#include "system/includes.h"
#include "app_config.h"
#include "music/music_id3.h"
#include "system/fs/fs.h"
#if ((TCFG_DEC_ID3_V1_ENABLE) || (TCFG_DEC_ID3_V2_ENABLE))
#define LOG_TAG_CONST APP_MUSIC
#define LOG_TAG "[APP_MUSIC_ID3]"
#define LOG_ERROR_ENABLE
#define LOG_DEBUG_ENABLE
#define LOG_INFO_ENABLE
/* #define LOG_DUMP_ENABLE */
#define LOG_CLI_ENABLE
#include "debug.h"
#define ID3_ANALYSIS_EN 1 // ID3解析
struct id3_v1_hdl {
char header[3]; // TAG
char title[30]; // 标题
char artist[30]; // 作者
char album[30]; // 专辑
char year[4]; // 出品年代
char comment[30]; // 备注
char genre; // 类型
};
struct id3_v2_hdl {
char header[3]; // ID3
char ver; // 版本号
char revision; // 副版本号
char flag; // 标志
u8 size[4]; // 标签大小，不包括标签头的10个字节
};
struct id3_v2_frame {
char frameID[4]; // 帧标识
u8 size[4]; // 帧大小，不包括帧头10个字节，不小于1
char flags[2]; // 标志
};
u8 tpe1_data[512];
u32 tpe1_data_len;
#define ID3_SIZEOF_ALIN(var,al) ((((var)+(al)-1)/(al))*(al))
#define ID3_V1_HEADER_SIZE (128) // sizeof(struct id3_v1_hdl)
#define ID3_V2_HEADER_SIZE (10) // sizeof(struct id3_v2_hdl)
#define ID3_V2_HEADER_SIZE_MAX (1024 * 2)
#define ID3_V2_FRAME_SIZE (10) // sizeof(struct id3_v2_frame)
static u8 id3_v1_match(u8 *buf)
{
if (buf[0] == 'T' && buf[1] == 'A' && buf[2] == 'G') {
return true;
} else {
return false;
}
}
static u8 id3_v2_match(u8 *buf)
{
//put_buf(buf, 16);
if ((buf[0] == 'I')
&& (buf[1] == 'D')
&& (buf[2] == '3')
&& (buf[3] != 0xff)
&& (buf[4] != 0xff)
&& ((buf[6] & 0x80) == 0)
&& ((buf[7] & 0x80) == 0)
&& ((buf[8] & 0x80) == 0)
&& ((buf[9] & 0x80) == 0)) {
return true;
} else {
return false;
}
}
static u32 id3v2_get_tag_len(u8 *buf)
{
u32 len = (((u32)buf[6] & 0x7f) << 21) +
(((u32)buf[7] & 0x7f) << 14) +
(((u32)buf[8] & 0x7f) << 7) +
(buf[9] & 0x7f) +
ID3_V2_HEADER_SIZE;
if (buf[5] & 0x10) {
len += ID3_V2_HEADER_SIZE;
}
log_info("----id3v2_len%d---\n", len);
return len;
}
#if ID3_ANALYSIS_EN
static void id3_v1_analysis(MP3_ID3_OBJ *obj)
{
struct id3_v1_hdl *hdl = (struct id3_v1_hdl *)obj->id3_buf;
/* log_info("header:%s \n", hdl->header); */
log_info("title:%s \n", hdl->title);
log_info("artist:%s \n", hdl->artist);
log_info("album:%s \n", hdl->album);
log_info("year:%s \n", hdl->year);
log_info("comment:%s \n", hdl->comment);
log_info("genre:%d \n", hdl->genre);
}
static const u8 ID3_V2_FRAME_ID[][4] = {
"TIT2", // 标题
"TPE1", // 作者
"TALB", // 专辑
"TYER", // 年代
"TCON", // 类型
"COMM", // 备注
};
static void id3_v2_analysis(void *file, void *buf)
{
#define FRAME_DAT_MAX 512
u8 *frame_dat = malloc(FRAME_DAT_MAX);
u8 frame_hdl[ID3_V2_FRAME_SIZE];
u32 frame_len;
struct id3_v2_hdl *hdl = (struct id3_v2_hdl *)buf;
/* log_info("header:%s \n", hdl->header); */
if (!frame_dat) {
return ;
}
u32 addr = ID3_V2_HEADER_SIZE;
u32 addr_end = id3v2_get_tag_len(buf) + ID3_V2_HEADER_SIZE;
log_info("frame total len:0x%x ", addr_end);
memset(tpe1_data, 0, sizeof(tpe1_data));
while (addr < addr_end) {
fseek(file, addr, SEEK_SET);
fread(file, frame_hdl, ID3_V2_FRAME_SIZE);
int idx;
struct id3_v2_frame *frame = (struct id3_v2_frame *)frame_hdl;
frame_len = (((u32)frame->size[0]) << 24) + (((u32)frame->size[1]) << 16) + (((u32)frame->size[2]) << 8) + (u32)frame->size[3];
log_info_hexdump(frame, ID3_V2_FRAME_SIZE);
log_info("frame ID:%s ", frame->frameID);
log_info("frame len:0x%x ", frame_len);
log_info("addr :0x%x ", addr);
if (!frame_len) {
break;
}
if (frame_len <= FRAME_DAT_MAX) {
memset(frame_dat, 0, FRAME_DAT_MAX);
fread(file, frame_dat, frame_len);
}
for (idx = 0; idx < sizeof(ID3_V2_FRAME_ID) / 4; idx++) {
if (!memcmp(frame->frameID, ID3_V2_FRAME_ID[idx], 4)) {
log_info("find frameID \n");
break;
}
}
if (frame_len <= FRAME_DAT_MAX) {
log_info("frame dat:%s, \n", frame_dat);
log_info_hexdump(frame_dat, frame_len);
}
if (!memcmp(frame->frameID, "TPE1", 4)) {
frame_dat++;
sprintf(tpe1_data, "%s", frame_dat);
tpe1_data_len = frame_len;
log_info_hexdump(tpe1_data, tpe1_data_len - 1);
frame_dat--;
}
addr += ID3_V2_FRAME_SIZE + frame_len;
}
free(frame_dat);
}
#endif
void id3_obj_post(MP3_ID3_OBJ **obj)
{
if (obj == NULL || (*obj) == NULL) {
return ;
}
free(*obj);
*obj = NULL;
}
MP3_ID3_OBJ *id3_v1_obj_get(void *file)
{
if (file == NULL) {
return NULL;
}
MP3_ID3_OBJ *obj = NULL;
u8 *need_buf = NULL;
u32 need_buf_size;
u32 cur_fptr = fpos(file);
u32 file_len = flen(file);
need_buf_size = ID3_SIZEOF_ALIN(sizeof(MP3_ID3_OBJ), 4)
+ ID3_SIZEOF_ALIN(ID3_V1_HEADER_SIZE, 4);
need_buf = (u8 *)zalloc(need_buf_size);
if (need_buf == NULL) {
log_error("malloc err !!\n");
return NULL;
}
obj = (MP3_ID3_OBJ *)need_buf;
obj->id3_buf = (u8 *)(need_buf + ID3_SIZEOF_ALIN(sizeof(MP3_ID3_OBJ), 4));
obj->id3_len = ID3_V1_HEADER_SIZE;
fseek(file, (file_len - ID3_V1_HEADER_SIZE), SEEK_SET);
fread(file, obj->id3_buf, ID3_V1_HEADER_SIZE);
if (id3_v1_match(obj->id3_buf) == true) {
log_info("find id3 v1 !!\n");
put_buf(obj->id3_buf, obj->id3_len);
} else {
goto __id3_v1_err;
}
#if ID3_ANALYSIS_EN
id3_v1_analysis(obj);
#else
fseek(file, cur_fptr, SEEK_SET);
return obj;
#endif
__id3_v1_err:
fseek(file, cur_fptr, SEEK_SET);
if (need_buf) {
free(need_buf);
}
return NULL;
}
MP3_ID3_OBJ *id3_v2_obj_get(void *file)
{
if (file == NULL) {
return NULL;
}
MP3_ID3_OBJ *obj = NULL;
u8 *need_buf = NULL;
u32 need_buf_size;
u8 tmp_buf[ID3_V2_HEADER_SIZE];
u32 cur_fptr = fpos(file);
fseek(file, 0, SEEK_SET);
fread(file, tmp_buf, ID3_V2_HEADER_SIZE);
if (id3_v2_match(tmp_buf) == true) {
log_info("find id3 v2 !!\n");
#if ID3_ANALYSIS_EN
id3_v2_analysis(file, (MP3_ID3_OBJ *)tmp_buf);
#else
u32 tag_len = id3v2_get_tag_len(tmp_buf);
if (tag_len > (ID3_V2_HEADER_SIZE_MAX)) {
log_error("id3 v2 info is too big!!\n", tag_len);
goto __id3_v2_err;
}
need_buf_size = ID3_SIZEOF_ALIN(sizeof(MP3_ID3_OBJ), 4)
+ ID3_SIZEOF_ALIN(tag_len, 4);
need_buf = (u8 *)zalloc(need_buf_size);
if (need_buf == NULL) {
log_error("no space for id3 v2 %d\n", tag_len);
goto __id3_v2_err;
}
obj = (MP3_ID3_OBJ *)need_buf;
obj->id3_buf = (u8 *)(need_buf + ID3_SIZEOF_ALIN(sizeof(MP3_ID3_OBJ), 4));
obj->id3_len = tag_len;
fseek(file, 0, SEEK_SET);
fread(file, obj->id3_buf, obj->id3_len);
log_info("id3_v2 size = %d\n", obj->id3_len);
put_buf(obj->id3_buf, obj->id3_len);
#endif
} else {
goto __id3_v2_err;
}
fseek(file, cur_fptr, SEEK_SET);
return obj;
__id3_v2_err:
fseek(file, cur_fptr, SEEK_SET);
if (need_buf) {
free(need_buf);
}
return NULL;
}
#endif

15
apps/common/music/music_id3.h Normal file
View File

@ -0,0 +1,15 @@
#ifndef __MUSIC_ID3_H__
#define __MUSIC_ID3_H__
#include "typedef.h"
typedef struct __MP3_ID3_OBJ {
u8 *id3_buf;
u32 id3_len;
} MP3_ID3_OBJ;
void id3_obj_post(MP3_ID3_OBJ **obj);
MP3_ID3_OBJ *id3_v1_obj_get(void *file);
MP3_ID3_OBJ *id3_v2_obj_get(void *file);
#endif// __MUSIC_ID3_H__

1576
apps/common/music/music_player.c Normal file
View File

File diff suppressed because it is too large Load Diff

154
apps/common/music/music_player.h Normal file
View File

@ -0,0 +1,154 @@
#ifndef __MUSIC_PLAYER_H__
#define __MUSIC_PLAYER_H__
#include "system/app_core.h"
#include "system/includes.h"
#include "server/server_core.h"
#include "media/audio_decoder.h"
#include "dev_manager/dev_manager.h"
#include "file_operate/file_manager.h"
#include "audio_dec/audio_dec_file.h"
///解码错误码表
enum {
MUSIC_PLAYER_ERR_NULL = 0x0, ///没有错误， 不需要做任何
MUSIC_PLAYER_SUCC = 0x1, ///播放成功， 可以做相关显示、断点记忆等处理
MUSIC_PLAYER_ERR_PARM, ///参数错误
MUSIC_PLAYER_ERR_POINT, ///参数指针错误
MUSIC_PLAYER_ERR_NO_RAM, ///没有ram空间错误
MUSIC_PLAYER_ERR_DECODE_FAIL, ///解码器启动失败错误
MUSIC_PLAYER_ERR_DEV_NOFOUND, ///没有找到指定设备
MUSIC_PLAYER_ERR_DEV_OFFLINE, ///设备不在线错误
MUSIC_PLAYER_ERR_DEV_READ, ///设备读错误
MUSIC_PLAYER_ERR_FSCAN, ///设备扫描失败
MUSIC_PLAYER_ERR_FILE_NOFOUND, ///没有找到文件
MUSIC_PLAYER_ERR_RECORD_DEV, ///录音文件夹操作错误
MUSIC_PLAYER_ERR_FILE_READ, ///文件读错误
};
///断点信息结构体
struct __breakpoint {
///文件信息
u32 fsize;
u32 sclust;
///解码信息
struct audio_dec_breakpoint dbp;
};
///回调接口结构体
struct __player_cb {
///解码成功回调
void (*start)(void *priv, int parm);
///解码结束回调
void (*end)(void *priv, int parm);
///解码错误回调
void (*err)(void *priv, int parm);
};
///参数设置结构体
struct __player_parm {
const struct __player_cb *cb;
///其他扩展
const struct __scan_callback *scan_cb;//扫盘打断回调
};
//music_player创建接口
bool music_player_creat(void *priv, struct __player_parm *parm);
//music_player释放接口
void music_player_destroy(void);
//music_player播放结束处理
int music_player_end_deal(int parm);
//music_player播放器解码错误处理
int music_player_decode_err_deal(int event);
//music_player解码器启动接口
int music_player_decode_start(FILE *file, struct audio_dec_breakpoint *dbp);
//music_player获取当前播放设备断点信息
bool music_player_get_playing_breakpoint(struct __breakpoint *bp, u8 flag);
//music_player获取当前播放设备文件总数
u16 music_player_get_file_total(void);
//music_player获取当前播放文件序号
u16 music_player_get_file_cur(void);
//music_player获取当前播放文件所在文件夹的文件总数
u16 music_player_get_fileindir_number(void);
//music_player获取当前播放文件所在文件夹
u16 music_player_get_dir_cur(void);
//music_player获取文件夹总数
u16 music_player_get_dir_total(void);
//music_player获取当前文件句柄
FILE *music_player_get_file_hdl(void);
//music_player获取当前文件簇号
u32 music_player_get_file_sclust(void);
//music_player获取当前文件长度
u32 music_player_get_file_len(void);
//music_player获取现在的使用设备
char *music_player_get_dev_cur(void);
//music_player获取当前播放对应的music设备
char *music_player_get_cur_music_dev(void);
//music_player获取当前播放设备下一个设备
char *music_player_get_dev_next(u8 auto_next);
//music_player获取当前播放设备上一个设备
char *music_player_get_dev_prev(void);
//music_player获取当前播放状态
int music_player_get_play_status(void);
//music_player获取当前播放歌曲时间
int music_player_get_dec_cur_time(void);
//music_player获取当前播放歌曲总时间
int music_player_get_dec_total_time(void);
//music_player获取当前播放循环模式
u8 music_player_get_repeat_mode(void);
//music_player获取当前录音区分播放状态
bool music_player_get_record_play_status(void);
//music_player从设备列表里面往前或往后找设备，并且过滤掉指定字符串的设备
char *music_player_get_dev_flit(char *flit, u8 direct);
//music_player播放/暂停
int music_player_pp(void);
//music_player快进
void music_player_ff(int step);
//music_player快退
void music_player_fr(int step);
//music_player设置播放循环模式
int music_player_set_repeat_mode(u8 mode);
//music_player切换循环模式
int music_player_change_repeat_mode(void);
//music_player解码停止
void music_player_stop(u8 fsn_release);
//music_player删除当前播放文件,并播放下一曲
int music_player_delete_playing_file(void);
//music_player播放上一曲
int music_player_play_prev(void);
//music_player播放下一曲
int music_player_play_next(void);
//music_player播放第一曲
int music_player_play_first_file(char *logo);
//music_player播放最后一曲
int music_player_play_last_file(char *logo);
//music_player自动播放下一曲
int music_player_play_auto_next(void);
//music_player上一个文件夹
int music_player_play_folder_prev(void);
//music_player下一个文件夹
int music_player_play_folder_next(void);
//music_player上一个设备
int music_player_play_devcie_prev(struct __breakpoint *bp);
//music_player下一个设备
int music_player_play_devcie_next(struct __breakpoint *bp);
//music_player断点播放指定设备
int music_player_play_by_breakpoint(char *logo, struct __breakpoint *pb);
//music_player序号播放指定设备
int music_player_play_by_number(char *logo, u32 number);
//music_player簇号播放指定设备
int music_player_play_by_sclust(char *logo, u32 sclust);
//music_player路径播放指定设备
int music_player_play_by_path(char *logo, const char *path);
//music_player录音区分切换播放
int music_player_play_record_folder(char *logo, struct __breakpoint *bp);
//music_player扫盘
int music_player_scan_disk();
//获取当前设备的物理设备
const char *music_player_get_phy_dev(int *len);
//歌词分析
int music_player_lrc_analy_start();
//music_player获取当前vfscan句柄
struct vfscan *music_player_get_vfscan_hdl(void);
#endif//__MUSIC_PLAYER_H__