815 lines
24 KiB
C
815 lines
24 KiB
C
#include "led_lyric.h"
|
||
#include "res/resfile.h"
|
||
#include "font/font_all.h"
|
||
#include "system/timer.h"
|
||
#include "board_config.h"
|
||
#include "os/os_api.h"
|
||
#include "ui/ui_style.h"
|
||
#include "system/includes.h"
|
||
#include "fm/fm_manage.h"
|
||
#include "uart_update.h"
|
||
#include "lyrics_api.h"
|
||
|
||
#if LED_LYRICS_ENABLE
|
||
|
||
typedef struct {
|
||
u8 *pixelbuf;
|
||
u8 width;
|
||
u8 height;
|
||
u8 offsetx;
|
||
u16 nbytes;
|
||
} FONT_CHAR_INFO;
|
||
|
||
typedef struct {
|
||
u8 scroll_speed;
|
||
u8 center_offset;
|
||
u16 scroll_offset;
|
||
LRC_FONT_ROTATE rotate;
|
||
LRC_FONT_FLIP flip;
|
||
} FONT_LYRICS_INFO;
|
||
|
||
typedef struct {
|
||
u8 *str;
|
||
u16 len;
|
||
u16 offset;
|
||
u16 sum_width;
|
||
FONT_LYRICS_INFO lyrics_info;
|
||
} LYRICS_UPDATE_INFO;
|
||
|
||
struct lrc_font_header {
|
||
u8 magic[4];
|
||
u32 version;
|
||
u32 timestamp;
|
||
u8 fontsize;
|
||
u8 bitdepth;
|
||
u8 reserved[18];
|
||
};
|
||
|
||
typedef struct {
|
||
u32 width : 6;
|
||
u32 height : 7;
|
||
s32 top : 8;
|
||
u32 size : 11;
|
||
s32 left : 7;
|
||
u32 addr : 25;
|
||
} __attribute__((packed, aligned(1))) LRC_UnicInfo;
|
||
|
||
|
||
#define Font_NumPages 1024
|
||
#define Font_PageSize (0x10000 / Font_NumPages)
|
||
|
||
#define Code_Size 7
|
||
#define Colon_Size 3
|
||
typedef struct {
|
||
u16 charIndex;
|
||
u8 codesMask[Font_PageSize / 8];
|
||
} LRC_Font_PageEntry_t;
|
||
|
||
#define IMAGE_BUF_SIZE ((LED_WIDTH * LED_HEIGHT + 7) / 8)
|
||
static u8 *image_buf = NULL; //整屏点阵缓存buffer
|
||
static u8 *image_buf_out = NULL;
|
||
static u8 lrc_check_online_flag = 1;
|
||
static u8 lrc_sleep_flag = 0;
|
||
|
||
static struct lrc_font_header header = {0};
|
||
static struct font_info f_info;
|
||
static FONT_CHAR_INFO char_info;
|
||
|
||
static u16 font_lyrics_scroll_timer_id = 0;
|
||
static LYRICS_UPDATE_INFO lrc_update_info;
|
||
|
||
static OS_MUTEX mutex;
|
||
static OS_MUTEX show_mutex;
|
||
|
||
static struct lrc_show_status lrc_status = {
|
||
|
||
.lrc_rotate = 0,
|
||
.lrc_flip = 0,
|
||
.lrc_scroll_speed = 100,
|
||
|
||
.lrc_show_status_update_flag = 0,
|
||
.lrc_record_len = 0,
|
||
.lrc_record_str = NULL,
|
||
};
|
||
|
||
void lyrics_show_status_set(u16 scroll_speed, u8 rotate, u8 flip)
|
||
{
|
||
lrc_status.lrc_scroll_speed = scroll_speed;
|
||
lrc_status.lrc_rotate = rotate;
|
||
lrc_status.lrc_flip = flip;
|
||
lrc_status.lrc_show_status_update_flag = 1;
|
||
lyrics_update_font(lrc_status.lrc_record_str, lrc_status.lrc_record_len, NULL);
|
||
}
|
||
|
||
static bool LRC_InitFont_Unicode(struct font_info *info)
|
||
{
|
||
info->pixel.file.fd = fopen(info->pixel.file.name, "r");
|
||
if (!info->pixel.file.fd) {
|
||
info->sta |= FT_ERROR_NOPIXFILE;
|
||
printf("unicode file not open!");
|
||
return FALSE;
|
||
}
|
||
|
||
fseek(info->pixel.file.fd, 0, SEEK_SET);
|
||
fread(info->pixel.file.fd, &header, sizeof(struct lrc_font_header));
|
||
printf("magic : %s\n", header.magic);
|
||
printf("version : 0x%x\n", header.version);
|
||
printf("timestamp : %d\n", header.timestamp);
|
||
printf("fontsize : %d\n", header.fontsize);
|
||
printf("bitdepth : %d\n", header.bitdepth);
|
||
|
||
if (memcmp(header.magic, "unic", 4)) {
|
||
info->sta |= FT_ERROR_NOPIXFILE;
|
||
printf("unicode magic not paired!");
|
||
return FALSE;
|
||
}
|
||
info->pixel.size = header.fontsize;
|
||
|
||
if (header.bitdepth == 0) {
|
||
info->pixel.nbytes = (info->pixel.size * info->pixel.size + 7) / 8;
|
||
} else if (header.bitdepth == 1) {
|
||
info->pixel.nbytes = (info->pixel.size * info->pixel.size * 2 + 7) / 8;
|
||
} else if (header.bitdepth == 2) {
|
||
info->pixel.nbytes = (info->pixel.size * info->pixel.size * 4 + 7) / 8;
|
||
} else { // header.bitdepth == 8
|
||
info->pixel.nbytes = info->pixel.size * info->pixel.size;
|
||
}
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
|
||
/* 获取字符索引 */
|
||
static int LRC_Font_GetCharIndex(struct font_info *info, u16 unicode)
|
||
{
|
||
LRC_Font_PageEntry_t pageEntry;
|
||
|
||
u16 m = unicode / Font_PageSize;
|
||
u16 n = unicode % Font_PageSize;
|
||
u16 i, j;
|
||
|
||
fseek(info->pixel.file.fd, sizeof(struct lrc_font_header) + m * sizeof(LRC_Font_PageEntry_t), SEEK_SET);
|
||
fread(info->pixel.file.fd, &pageEntry, sizeof(LRC_Font_PageEntry_t));
|
||
if (!(pageEntry.codesMask[n / 8] & (1 << (n % 8)))) {
|
||
return -1;
|
||
}
|
||
|
||
for (i = j = 0; i < n; i++) {
|
||
if (pageEntry.codesMask[i / 8] & (1 << (i % 8))) {
|
||
j++;
|
||
}
|
||
}
|
||
i = pageEntry.charIndex + j;
|
||
return i;
|
||
}
|
||
|
||
|
||
/* 获取字符宽度 */
|
||
static int LRC_Font_GetCharWidth(struct font_info *info, u16 unicode)
|
||
{
|
||
int charIndex;
|
||
u16 nbytes;
|
||
|
||
if ((charIndex = LRC_Font_GetCharIndex(info, unicode)) < 0) {
|
||
printf("unicode : 0x%x, charIndex = %d, char index not exist!\n", unicode, charIndex);
|
||
return 0;
|
||
}
|
||
|
||
LRC_UnicInfo codeinfo = {0};
|
||
|
||
u32 file_offset = 0;
|
||
fseek(info->pixel.file.fd, sizeof(struct lrc_font_header) + Font_NumPages * \
|
||
sizeof(LRC_Font_PageEntry_t) + charIndex * sizeof(LRC_UnicInfo), SEEK_SET);
|
||
fread(info->pixel.file.fd, &codeinfo, sizeof(LRC_UnicInfo));
|
||
|
||
if (unicode == 0x20) {
|
||
codeinfo.width = info->pixel.size / 3;
|
||
codeinfo.height = info->pixel.size / 3;
|
||
}
|
||
|
||
if (unicode == 0x10) {
|
||
codeinfo.width = Code_Size;
|
||
codeinfo.height = Code_Size;
|
||
memset(info->pixel.pixelbuf, 0, (codeinfo.width * codeinfo.height + 7) / 8);
|
||
}
|
||
|
||
if (unicode == 0x11) {
|
||
codeinfo.width = Colon_Size;
|
||
codeinfo.height = Colon_Size;
|
||
memset(info->pixel.pixelbuf, 0, (codeinfo.width * codeinfo.height + 7) / 8);
|
||
}
|
||
u8 width = codeinfo.width;
|
||
char_info.width = codeinfo.width;
|
||
char_info.height = codeinfo.height;
|
||
|
||
return width;
|
||
}
|
||
|
||
/* 获取字符位图数据 */
|
||
static int LRC_Font_GetCharBits(struct font_info *info, u16 unicode)
|
||
{
|
||
int charIndex;
|
||
u16 nbytes, width;
|
||
|
||
if ((charIndex = LRC_Font_GetCharIndex(info, unicode)) < 0) {
|
||
printf("unicode : 0x%x, charIndex = %d, char index not exist!\n", unicode, charIndex);
|
||
return 0;
|
||
}
|
||
LRC_UnicInfo codeinfo = {0};
|
||
|
||
fseek(info->pixel.file.fd, sizeof(struct lrc_font_header) + Font_NumPages * \
|
||
sizeof(LRC_Font_PageEntry_t) + charIndex * sizeof(LRC_UnicInfo), SEEK_SET);
|
||
fread(info->pixel.file.fd, &codeinfo, sizeof(LRC_UnicInfo));
|
||
const u8 bit[] = {1, 2, 4, 8};
|
||
nbytes = (codeinfo.width * codeinfo.height * bit[header.bitdepth] + 7) / 8;
|
||
if (info->pixel.pixelbuf != NULL) {
|
||
if (nbytes > info->pixel.nbytes) {
|
||
puts("error:pixelbuf overlay!\n");
|
||
printf("info.width = %d, info->ascpixel.size = %d, nbytes = %d\n", width, info->pixel.size, nbytes);
|
||
free(info->pixel.pixelbuf);
|
||
info->pixel.pixelbuf = (u8 *)malloc(nbytes);
|
||
info->pixel.nbytes = nbytes;
|
||
|
||
char_info.pixelbuf = info->pixel.pixelbuf;
|
||
char_info.nbytes = info->pixel.nbytes;
|
||
}
|
||
|
||
fseek(info->pixel.file.fd, codeinfo.addr, SEEK_SET);
|
||
fread(info->pixel.file.fd, info->pixel.pixelbuf, nbytes);
|
||
}
|
||
|
||
if (unicode == 0x20) {
|
||
codeinfo.width = info->pixel.size / 3;
|
||
codeinfo.height = info->pixel.size / 3;
|
||
}
|
||
|
||
if (unicode == 0x10) {
|
||
codeinfo.width = Code_Size;
|
||
codeinfo.height = Code_Size;
|
||
memset(info->pixel.pixelbuf, 0, (codeinfo.width * codeinfo.height + 7) / 8);
|
||
}
|
||
|
||
if (unicode == 0x11) {
|
||
codeinfo.width = Colon_Size;
|
||
codeinfo.height = Colon_Size;
|
||
memset(info->pixel.pixelbuf, 0, (codeinfo.width * codeinfo.height + 7) / 8);
|
||
}
|
||
width = codeinfo.width;
|
||
char_info.width = codeinfo.width;
|
||
char_info.height = codeinfo.height;
|
||
char_info.pixelbuf = info->pixel.pixelbuf;
|
||
|
||
return width;
|
||
}
|
||
|
||
bool lyrics_font_init(char *file_name)
|
||
{
|
||
bool ret;
|
||
if (f_info.pixel.file.fd == NULL) {
|
||
f_info.pixel.file.name = file_name;
|
||
f_info.bigendian = 0;
|
||
ret = LRC_InitFont_Unicode(&f_info);
|
||
if (ret == FALSE) {
|
||
return FALSE;
|
||
}
|
||
f_info.pixel.pixelbuf = (u8 *)malloc(f_info.pixel.nbytes);
|
||
char_info.pixelbuf = f_info.pixel.pixelbuf;
|
||
char_info.nbytes = f_info.pixel.nbytes;
|
||
image_buf = (u8 *)malloc(IMAGE_BUF_SIZE);
|
||
image_buf_out = (u8 *)malloc(IMAGE_BUF_SIZE);
|
||
os_mutex_create(&mutex);
|
||
os_mutex_create(&show_mutex);
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
void lyrics_font_release()
|
||
{
|
||
if (f_info.pixel.file.fd) {
|
||
fclose(f_info.pixel.file.fd);
|
||
f_info.pixel.file.fd = NULL;
|
||
}
|
||
if (f_info.pixel.pixelbuf) {
|
||
free(f_info.pixel.pixelbuf);
|
||
f_info.pixel.pixelbuf = NULL;
|
||
}
|
||
if (font_lyrics_scroll_timer_id) {
|
||
sys_timer_del(font_lyrics_scroll_timer_id);
|
||
font_lyrics_scroll_timer_id = 0;
|
||
}
|
||
if (lrc_update_info.str) {
|
||
free(lrc_update_info.str);
|
||
lrc_update_info.str = NULL;
|
||
}
|
||
if (image_buf) {
|
||
free(image_buf);
|
||
image_buf = NULL;
|
||
}
|
||
if (image_buf_out) {
|
||
free(image_buf_out);
|
||
image_buf_out = NULL;
|
||
}
|
||
}
|
||
|
||
static void Font_CharBit_to_Image(FONT_CHAR_INFO *info, u8 *image, u8 x, u8 y)
|
||
{
|
||
u8 image_width = LED_WIDTH;
|
||
u8 char_width = info->width;
|
||
u8 char_height = info->height;
|
||
u8 *char_buf = info->pixelbuf;
|
||
u8 char_byte_idx, char_bit_idx;
|
||
u8 image_byte_idx, image_bit_idx;
|
||
u8 inc_ofs = info->offsetx;
|
||
for (u16 i = 0; i < char_height; i++) {
|
||
for (u16 j = 0; j < char_width; j++) {
|
||
if (x + j >= LED_WIDTH) {
|
||
break;
|
||
}
|
||
if (j + inc_ofs >= char_width) {
|
||
break;
|
||
}
|
||
char_byte_idx = (i * char_width + j + inc_ofs) / 8;
|
||
char_bit_idx = (i * char_width + j + inc_ofs) % 8;
|
||
image_byte_idx = ((i + y) * image_width + j + x) / 8;
|
||
image_bit_idx = ((i + y) * image_width + j + x) % 8;
|
||
image[image_byte_idx] |= (((char_buf[char_byte_idx] >> (7 - char_bit_idx)) & 0x1) << (7 - image_bit_idx));
|
||
}
|
||
}
|
||
}
|
||
|
||
static void Font_Char_Rotate_90Reverse(FONT_CHAR_INFO *info)
|
||
{
|
||
u8 *in = info->pixelbuf;
|
||
u8 *out = image_buf_out;
|
||
u8 in_byte_idx, in_bit_idx;
|
||
u8 out_byte_idx, out_bit_idx;
|
||
u8 char_width = info->width;
|
||
u8 char_height = info->height;
|
||
memset(image_buf_out, 0, IMAGE_BUF_SIZE);
|
||
for (u16 h = 0; h < char_height; h++) {
|
||
for (u16 w = 0; w < char_width; w++) {
|
||
in_byte_idx = (h * char_width + w) / 8;
|
||
in_bit_idx = (h * char_width + w) % 8;
|
||
out_byte_idx = ((char_width - 1 - w) * char_height + h) / 8;
|
||
out_bit_idx = ((char_width - 1 - w) * char_height + h) % 8;
|
||
out[out_byte_idx] |= (((in[in_byte_idx] >> (7 - in_bit_idx)) & 0x1) << (7 - out_bit_idx));
|
||
}
|
||
}
|
||
u8 tmp = info->width;
|
||
info->width = info->height;
|
||
info->height = tmp;
|
||
memcpy(info->pixelbuf, image_buf_out, info->nbytes);
|
||
}
|
||
|
||
static void Font_Image_Rotate_180()
|
||
{
|
||
u8 *in = image_buf;
|
||
u8 *out = image_buf_out;
|
||
u8 in_byte_idx, in_bit_idx;
|
||
u8 out_byte_idx, out_bit_idx;
|
||
memset(image_buf_out, 0, IMAGE_BUF_SIZE);
|
||
for (u16 h = 0; h < LED_HEIGHT; h++) {
|
||
for (u16 w = 0; w < LED_WIDTH; w++) {
|
||
in_byte_idx = (h * LED_WIDTH + w) / 8;
|
||
in_bit_idx = (h * LED_WIDTH + w) % 8;
|
||
out_byte_idx = (LED_WIDTH * LED_HEIGHT / 8) - 1 - in_byte_idx;
|
||
out_bit_idx = (7 - in_bit_idx);
|
||
out[out_byte_idx] |= (((in[in_byte_idx] >> (7 - in_bit_idx)) & 0x1) << (7 - out_bit_idx));
|
||
}
|
||
}
|
||
}
|
||
|
||
static void Font_Image_Mirror_Horizontal_Flip(u8 *image)
|
||
{
|
||
u8 *in, *out;
|
||
if (image == image_buf) {
|
||
in = image_buf;
|
||
out = image_buf_out;
|
||
} else {
|
||
in = image_buf_out;
|
||
out = image_buf;
|
||
}
|
||
memset(out, 0, IMAGE_BUF_SIZE);
|
||
u8 in_byte_idx, in_bit_idx;
|
||
u8 out_byte_idx, out_bit_idx;
|
||
u16 in_bit, out_bit;
|
||
for (u16 h = 0; h < LED_HEIGHT; h++) {
|
||
for (u16 w = 0; w < LED_WIDTH; w++) {
|
||
in_bit = h * LED_WIDTH + w;
|
||
out_bit = h * LED_WIDTH + (LED_WIDTH - 1 - w);
|
||
in_byte_idx = in_bit / 8;
|
||
in_bit_idx = in_bit % 8;
|
||
out_byte_idx = out_bit / 8;
|
||
out_bit_idx = out_bit % 8;
|
||
out[out_byte_idx] |= (((in[in_byte_idx] >> (7 - in_bit_idx)) & 0x1) << (7 - out_bit_idx));
|
||
}
|
||
}
|
||
memcpy(in, out, IMAGE_BUF_SIZE);
|
||
}
|
||
|
||
static void Font_Image_Mirror_Vertical_Flip(u8 *image)
|
||
{
|
||
u8 *in, *out;
|
||
if (image == image_buf) {
|
||
in = image_buf;
|
||
out = image_buf_out;
|
||
} else {
|
||
in = image_buf_out;
|
||
out = image_buf;
|
||
}
|
||
memset(out, 0, IMAGE_BUF_SIZE);
|
||
u8 in_byte_idx, in_bit_idx;
|
||
u8 out_byte_idx, out_bit_idx;
|
||
u16 in_bit, out_bit;
|
||
for (u16 h = 0; h < LED_HEIGHT; h++) {
|
||
for (u16 w = 0; w < LED_WIDTH; w++) {
|
||
in_bit = h * LED_WIDTH + w;
|
||
out_bit = (LED_HEIGHT - 1 - h) * LED_WIDTH + w;
|
||
in_byte_idx = in_bit / 8;
|
||
in_bit_idx = in_bit % 8;
|
||
out_byte_idx = out_bit / 8;
|
||
out_bit_idx = out_bit % 8;
|
||
out[out_byte_idx] |= (((in[in_byte_idx] >> (7 - in_bit_idx)) & 0x1) << (7 - out_bit_idx));
|
||
}
|
||
}
|
||
memcpy(in, out, IMAGE_BUF_SIZE);
|
||
}
|
||
|
||
static u16 Font_GetStringWidth(u8 *utf8_buf, u16 len, FONT_LYRICS_INFO *lyrics_info)
|
||
{
|
||
u16 unicode, width;
|
||
u16 utf8_len = len;
|
||
u16 *utf16_buf = zalloc(utf8_len * 2);
|
||
u16 utf16_len = font_utf8toutf16(&f_info, utf8_buf, utf8_len, utf16_buf);
|
||
u16 unic_num = utf16_len / 2;
|
||
u16 sum_width = 0;
|
||
|
||
for (u16 n = 0; n < unic_num; n++) {
|
||
unicode = utf16_buf[n];
|
||
width = LRC_Font_GetCharWidth(&f_info, unicode);
|
||
if (width == 0) {
|
||
continue;
|
||
}
|
||
if (lyrics_info->rotate == LRC_FONT_ROTATE_90 || lyrics_info->rotate == LRC_FONT_ROTATE_270) {
|
||
width = char_info.height;
|
||
}
|
||
sum_width += width;
|
||
}
|
||
free(utf16_buf);
|
||
return sum_width;
|
||
}
|
||
|
||
void lrc_buf_push(u8 *buf, u16 size)
|
||
{
|
||
u8 *uartbuf = malloc(size + 1);
|
||
#if UI_LED_LRC_DECODE_FONT
|
||
uartbuf[0] = CMD_UART_UI_PIXEL_MATRIX;
|
||
#else
|
||
uartbuf[0] = CMD_UART_UI_STRING;
|
||
#endif
|
||
memcpy(uartbuf + 1, buf, size);
|
||
#if MUTIL_CPU_UART_UPDATE_ENABLE
|
||
if (!lrc_sleep_flag) {
|
||
uart_update_tx_packet(0, uartbuf, 0, size + 1, 0);
|
||
}
|
||
#endif
|
||
free(uartbuf);
|
||
}
|
||
|
||
void lrc_show_slepp_push(void)
|
||
{
|
||
u8 buf[1];
|
||
buf[0] = CMD_UART_SLEEP;
|
||
#if MUTIL_CPU_UART_UPDATE_ENABLE
|
||
if (!lrc_sleep_flag) {
|
||
uart_update_tx_packet(0, buf, 0, sizeof(buf), 1);
|
||
}
|
||
#endif
|
||
lrc_sleep_flag = 1;
|
||
}
|
||
|
||
void lrc_wake_up_push(void)
|
||
{
|
||
u8 buf[1];
|
||
buf[0] = 0XFF;
|
||
#if MUTIL_CPU_UART_UPDATE_ENABLE
|
||
uart_update_tx_packet(0, buf, 0, sizeof(buf), 1);
|
||
#endif
|
||
lrc_sleep_flag = 0;
|
||
}
|
||
|
||
#if (AD10X_WITHOUT_FLASH && LED_LYRICS_SH50_CHECK_ONLINE)
|
||
|
||
static u8 lrc_dev_check_online()
|
||
{
|
||
u8 ret = 0;
|
||
u8 packet = CMD_UART_CHECK_ONLINE;
|
||
|
||
#if MUTIL_CPU_UART_UPDATE_ENABLE
|
||
|
||
lrc_check_online_flag = 1;
|
||
if (!lrc_sleep_flag) {
|
||
ret = uart_update_tx_packet(CMD_UART_CHECK_ONLINE, &packet, 0, 1, 1);
|
||
}
|
||
|
||
#endif
|
||
|
||
if (ret != 0) {
|
||
if (!lrc_sleep_flag) {
|
||
ret = uart_update_tx_packet(CMD_UART_CHECK_ONLINE, &packet, 0, 1, 1);
|
||
}
|
||
if (ret != 0) {
|
||
lrc_check_online_flag = 0;
|
||
sh50_isp_up_code();
|
||
}
|
||
}
|
||
return ret;
|
||
}
|
||
|
||
static u16 online_timer_id = 0;
|
||
|
||
void lrc_check_online_timer_init()
|
||
{
|
||
if (online_timer_id == 0) {
|
||
online_timer_id = sys_timer_add(NULL, lrc_dev_check_online, 3000);
|
||
}
|
||
}
|
||
|
||
void lrc_check_online_timer_release()
|
||
{
|
||
if (online_timer_id) {
|
||
sys_timer_del(online_timer_id);
|
||
online_timer_id = 0;
|
||
}
|
||
}
|
||
|
||
#endif
|
||
|
||
void lrc_show_mode_push(LRC_SHOW_INFO *show_info)
|
||
{
|
||
u8 buf[5];
|
||
u8 rotate, flip, speed, brightness;
|
||
if (show_info) {
|
||
rotate = show_info->rotate;
|
||
flip = show_info->flip;
|
||
speed = show_info->scroll_speed / 50;
|
||
brightness = show_info->brightness;
|
||
} else {
|
||
rotate = 0;
|
||
flip = 0;
|
||
speed = 3;
|
||
brightness = 0;
|
||
}
|
||
buf[0] = CMD_UART_UI_CMD;
|
||
buf[1] = rotate;
|
||
buf[2] = flip;
|
||
buf[3] = speed;
|
||
buf[4] = brightness;
|
||
#if MUTIL_CPU_UART_UPDATE_ENABLE
|
||
if (!lrc_sleep_flag) {
|
||
uart_update_tx_packet(0, buf, 0, sizeof(buf), 1);
|
||
}
|
||
#endif
|
||
}
|
||
|
||
static void Font_GetStringBits(u8 *utf8_buf, u16 len, FONT_LYRICS_INFO *lyrics_info)
|
||
{
|
||
u8 curr_x = lyrics_info->center_offset;
|
||
u8 offset_y = 0;
|
||
u16 unicode, width;
|
||
u16 rec_scr_ofs = 0;
|
||
u8 curr_char_offset = 0;
|
||
u8 *font_ptr = image_buf;
|
||
u16 sum_char_offset = lyrics_info->scroll_offset;
|
||
memset(image_buf, 0, IMAGE_BUF_SIZE);
|
||
u16 utf8_len = len;
|
||
u16 *utf16_buf = zalloc(utf8_len * 2);
|
||
u16 utf16_len = font_utf8toutf16(&f_info, utf8_buf, utf8_len, utf16_buf);
|
||
u16 unic_num = utf16_len / 2;
|
||
|
||
for (u16 n = 0; n < unic_num; n++) {
|
||
unicode = utf16_buf[n];
|
||
width = LRC_Font_GetCharBits(&f_info, unicode);
|
||
if (width == 0) {
|
||
continue;
|
||
}
|
||
if (lyrics_info->rotate == LRC_FONT_ROTATE_0 || lyrics_info->rotate == LRC_FONT_ROTATE_180) {
|
||
curr_char_offset = width;
|
||
} else {
|
||
curr_char_offset = char_info.height;
|
||
}
|
||
rec_scr_ofs += curr_char_offset;
|
||
if (rec_scr_ofs < sum_char_offset) {
|
||
continue;
|
||
}
|
||
if (curr_x == 0) {
|
||
char_info.offsetx = sum_char_offset + curr_char_offset - rec_scr_ofs;
|
||
} else {
|
||
char_info.offsetx = 0;
|
||
}
|
||
if (curr_x > LED_WIDTH) {
|
||
break;
|
||
}
|
||
if (lyrics_info->rotate == LRC_FONT_ROTATE_90 || lyrics_info->rotate == LRC_FONT_ROTATE_270) {
|
||
Font_Char_Rotate_90Reverse(&char_info);
|
||
}
|
||
offset_y = (f_info.pixel.size - char_info.height) / 2;
|
||
Font_CharBit_to_Image(&char_info, image_buf, curr_x, offset_y);
|
||
curr_x += (char_info.width - char_info.offsetx);
|
||
}
|
||
if (lyrics_info->rotate == LRC_FONT_ROTATE_180 || lyrics_info->rotate == LRC_FONT_ROTATE_270) {
|
||
Font_Image_Rotate_180();
|
||
font_ptr = image_buf_out;
|
||
}
|
||
if (lyrics_info->flip == LRC_FONT_HORIZONTAL_FLIP) {
|
||
Font_Image_Mirror_Horizontal_Flip(font_ptr);
|
||
}
|
||
if (lyrics_info->flip == LRC_FONT_VERTICAL_FLIP) {
|
||
Font_Image_Mirror_Vertical_Flip(font_ptr);
|
||
}
|
||
|
||
lrc_buf_push(font_ptr, IMAGE_BUF_SIZE);
|
||
|
||
free(utf16_buf);
|
||
}
|
||
|
||
void lyrics_scroll_timer_del()
|
||
{
|
||
if (font_lyrics_scroll_timer_id) {
|
||
sys_timer_del(font_lyrics_scroll_timer_id);
|
||
font_lyrics_scroll_timer_id = 0;
|
||
}
|
||
}
|
||
|
||
static u8 lyrics_scroll_flag = 1;
|
||
|
||
static void lyrics_scroll_font(void *ptr)
|
||
{
|
||
os_mutex_pend(&show_mutex, 0);
|
||
LYRICS_UPDATE_INFO *info = (LYRICS_UPDATE_INFO *)ptr;
|
||
if (info->lyrics_info.scroll_offset > info->sum_width - LED_WIDTH + 3) {
|
||
info->lyrics_info.scroll_offset = 0;
|
||
/* 不从头滚动 */
|
||
if (info->sum_width > LED_WIDTH) {
|
||
lyrics_scroll_timer_del();
|
||
os_mutex_post(&show_mutex);
|
||
return;
|
||
}
|
||
/* 不从头滚动 */
|
||
}
|
||
Font_GetStringBits((u8 *)(info->str), info->len, &(info->lyrics_info));
|
||
if (info->sum_width > LED_WIDTH && lyrics_scroll_flag) {
|
||
info->lyrics_info.scroll_offset++;
|
||
}
|
||
os_mutex_post(&show_mutex);
|
||
}
|
||
|
||
void lyrics_scroll_control(u8 flag)
|
||
{
|
||
lyrics_scroll_flag = flag;
|
||
}
|
||
|
||
void lyrics_update_font(u8 *str, u16 len, LRC_SHOW_INFO *show_info)
|
||
{
|
||
#if UI_LED_LRC_DECODE_FONT
|
||
if (f_info.pixel.file.fd == NULL) {
|
||
printf("err, font file not open\n");
|
||
return;
|
||
}
|
||
#endif
|
||
u16 str_curr_crc;
|
||
static u16 str_last_crc = 0;
|
||
str_curr_crc = CRC16(str, len);
|
||
if (str_last_crc == str_curr_crc && lrc_status.lrc_show_status_update_flag == 0 && lrc_check_online_flag) {
|
||
return;
|
||
}
|
||
if (len == 0) {
|
||
lrc_status.lrc_show_status_update_flag = 0;
|
||
return;
|
||
}
|
||
os_mutex_pend(&show_mutex, 0);
|
||
/* 记录当前字符串内容和长度，在更新显示参数实时刷新时需要用到 */
|
||
if (lrc_status.lrc_record_str && lrc_status.lrc_show_status_update_flag == 0) {
|
||
free(lrc_status.lrc_record_str);
|
||
lrc_status.lrc_record_str = NULL;
|
||
}
|
||
if (lrc_status.lrc_record_str == NULL) {
|
||
lrc_status.lrc_record_str = zalloc(len);
|
||
}
|
||
lrc_status.lrc_record_len = len;
|
||
memcpy(lrc_status.lrc_record_str, str, len);
|
||
/* 记录当前字符串内容和长度，在更新显示参数实时刷新时需要用到 */
|
||
str_last_crc = str_curr_crc;
|
||
#if (UI_LED_LRC_DECODE_FONT == 0)
|
||
lrc_buf_push(str, len);
|
||
lrc_status.lrc_show_status_update_flag = 0;
|
||
os_mutex_post(&show_mutex);
|
||
return;
|
||
#endif
|
||
u16 scroll_speed;
|
||
u8 rotate, flip;
|
||
os_mutex_pend(&mutex, 0);
|
||
if (show_info == NULL) {
|
||
rotate = lrc_status.lrc_rotate;
|
||
flip = lrc_status.lrc_flip;
|
||
scroll_speed = lrc_status.lrc_scroll_speed;
|
||
} else {
|
||
rotate = show_info->rotate;
|
||
flip = show_info->flip;
|
||
scroll_speed = show_info->scroll_speed;
|
||
}
|
||
if (font_lyrics_scroll_timer_id) {
|
||
sys_timer_del(font_lyrics_scroll_timer_id);
|
||
font_lyrics_scroll_timer_id = 0;
|
||
}
|
||
if (lrc_update_info.str) {
|
||
free(lrc_update_info.str);
|
||
lrc_update_info.str = NULL;
|
||
}
|
||
lrc_update_info.str = malloc(len);
|
||
memcpy(lrc_update_info.str, str, len);
|
||
lrc_update_info.len = len;
|
||
lrc_update_info.lyrics_info.scroll_offset = 0;
|
||
lrc_update_info.lyrics_info.rotate = rotate;
|
||
lrc_update_info.lyrics_info.flip = flip;
|
||
lrc_update_info.sum_width = Font_GetStringWidth(lrc_update_info.str, len, &(lrc_update_info.lyrics_info));
|
||
lrc_update_info.lyrics_info.center_offset = (lrc_update_info.sum_width < LED_WIDTH) ? ((LED_WIDTH - lrc_update_info.sum_width) / 2) : 0;
|
||
|
||
os_mutex_post(&show_mutex);
|
||
if (lrc_update_info.sum_width <= LED_WIDTH) {
|
||
lyrics_scroll_font((void *)&lrc_update_info);
|
||
} else {
|
||
if (font_lyrics_scroll_timer_id == 0) {
|
||
font_lyrics_scroll_timer_id = sys_timer_add((void *)&lrc_update_info, lyrics_scroll_font, scroll_speed);
|
||
}
|
||
}
|
||
lrc_status.lrc_show_status_update_flag = 0;
|
||
os_mutex_post(&mutex);
|
||
}
|
||
|
||
int UnicodeToUtf8(u8 *pInput, u16 in_len, u8 *pOutput)
|
||
{
|
||
int len = 0; //记录转换后的Utf8字符串的字节数
|
||
int unic_cnt = 0;
|
||
while (unic_cnt < in_len) {
|
||
//处理一个unicode字符
|
||
u8 low = *pInput;//取出unicode字符的低8位
|
||
pInput++;
|
||
unic_cnt++;
|
||
u8 high = *pInput;//取出unicode字符的高8位
|
||
u16 w = high << 8;
|
||
u16 wchar = (high << 8) + low; //高8位和低8位组成一个unicode字符,加法运算级别高
|
||
|
||
if (wchar <= 0x7F) { //英文字符
|
||
pOutput[len] = (char)wchar; //取wchar的低8位
|
||
len++;
|
||
} else if (wchar >= 0x80 && wchar <= 0x7FF) { //可以转换成双字节pOutput字符
|
||
pOutput[len] = 0xc0 | ((wchar >> 6) & 0x1f); //取出unicode编码低6位后的5位，填充到110yyyyy 10zzzzzz 的yyyyy中
|
||
len++;
|
||
pOutput[len] = 0x80 | (wchar & 0x3f); //取出unicode编码的低6位，填充到110yyyyy 10zzzzzz 的zzzzzz中
|
||
len++;
|
||
} else if (wchar >= 0x800 && wchar < 0xFFFF) { //可以转换成3个字节的pOutput字符
|
||
pOutput[len] = 0xe0 | ((wchar >> 12) & 0x0f); //高四位填入1110xxxx 10yyyyyy 10zzzzzz中的xxxx
|
||
len++;
|
||
pOutput[len] = 0x80 | ((wchar >> 6) & 0x3f); //中间6位填入1110xxxx 10yyyyyy 10zzzzzz中的yyyyyy
|
||
len++;
|
||
pOutput[len] = 0x80 | (wchar & 0x3f); //低6位填入1110xxxx 10yyyyyy 10zzzzzz中的zzzzzz
|
||
len++;
|
||
}
|
||
|
||
else { //对于其他字节数的unicode字符不进行处理
|
||
return -1;
|
||
}
|
||
pInput ++;//处理下一个unicode字符
|
||
unic_cnt++;
|
||
}
|
||
//utf8字符串后面，有个\0
|
||
pOutput [len] = 0;
|
||
return len;
|
||
}
|
||
|
||
void lyrics_update_unicbuf(u8 *unic, u16 len)
|
||
{
|
||
if (len == 0 || unic == NULL) {
|
||
return;
|
||
}
|
||
u8 *utf8 = (u8 *)zalloc(len * 2);
|
||
int utf8_len = UnicodeToUtf8(unic, len, utf8);
|
||
lyrics_update_font(utf8, utf8_len, NULL);
|
||
free(utf8);
|
||
}
|
||
|
||
void lyrics_update_gbk_to_utf8(u8 *gbk, u16 len)
|
||
{
|
||
if (len == 0 || gbk == NULL) {
|
||
return;
|
||
}
|
||
u8 *utf8 = (u8 *)zalloc(len * 2);
|
||
int utf8_len = gbk_2_utf8(gbk, len, utf8, len * 2);
|
||
lyrics_update_font(utf8, utf8_len, NULL);
|
||
free(utf8);
|
||
}
|
||
|
||
#endif
|
||
|