pure sdk for main

This commit is contained in:
divadiow
2025-08-27 09:51:58 +01:00
parent f0d033f1c9
commit 0571416e7c
3283 changed files with 1577720 additions and 1 deletions
+42
View File
@@ -0,0 +1,42 @@
#ifndef __LVGL_UI_H
#define __LVGL_UI_H
#include "lvgl/lvgl.h"
lv_obj_t *system_msg_ui(lv_group_t *group,lv_obj_t *base_ui);
lv_obj_t *preview_encode_selct_ui(lv_group_t *group,lv_obj_t *base_ui);
lv_obj_t *preview_encode_selct_ui(lv_group_t *group,lv_obj_t *base_ui);
lv_obj_t *player2_ui(lv_group_t *group,lv_obj_t *base_ui);
lv_obj_t *preview_usb_ui(lv_group_t *group,lv_obj_t *base_ui);
lv_obj_t *preview_usb_select_ui(lv_group_t *group,lv_obj_t *base_ui);
lv_obj_t *photo_ui(lv_group_t *group,lv_obj_t *base_ui);
lv_obj_t *preview_encode_QVGA_ui(lv_group_t *group,lv_obj_t *base_ui);
lv_obj_t *preview_encode_QQVGA_ui(lv_group_t *group,lv_obj_t *base_ui);
lv_obj_t *preview_dvp_pip_ui(lv_group_t *group,lv_obj_t *base_ui);
lv_obj_t *player_ui(lv_group_t *group,lv_obj_t *base_ui);
lv_obj_t *player2_ui(lv_group_t *group,lv_obj_t *base_ui);
lv_obj_t *preview_encode_takephoto_ui(lv_group_t *group,lv_obj_t *base_ui);
lv_obj_t *preview_encode_960P_ui(lv_group_t *group,lv_obj_t *base_ui);
lv_obj_t *preview_encode_selct_ui(lv_group_t *group,lv_obj_t *base_ui);
lv_obj_t *zbar_ui(lv_group_t *group,lv_obj_t *base_ui);
lv_obj_t *zbar_dvp_ui(lv_group_t *group,lv_obj_t *base_ui);
lv_obj_t *zbar_usb_ui(lv_group_t *group,lv_obj_t *base_ui);
lv_obj_t *photo_ui(lv_group_t *group,lv_obj_t *base_ui);
lv_obj_t *preview_usb_encode_ui(lv_group_t *group,lv_obj_t *base_ui);
lv_obj_t *preview_dvp_usb_ui(lv_group_t *group,lv_obj_t *base_ui);
lv_obj_t *preview_net_jpg_ui(lv_group_t *group,lv_obj_t *base_ui);
#include "stream_frame.h"
stream *scale3_stream_not_bind(const char *name,uint16_t iw,uint16_t ih,uint16_t ow,uint16_t oh,uint16_t type);
stream *new_video_app_stream(const char *name);
stream *prc_stream(const char *name,stream *d_s);
stream *jpg_decode_stream_not_bind(const char *name);
stream *other_jpg_stream_not_bind(const char *name,uint16_t out_w,uint16_t out_h,uint16_t step_w,uint16_t step_h,uint32_t type);
stream *scale1_stream_not_bind(const char *name,uint16_t iw,uint16_t ih,uint16_t ow,uint16_t oh);
stream *new_video_app_stream_with_mode(const char *name,uint8_t from_vpp,uint16_t w,uint16_t h);
stream *zbar_stream(const char *name,uint32_t filter);
stream *independ_video_usb();
stream *newavi_player_init(const char *stream_name,const char *filename);
stream *prc_stream_filter(const char *name,stream *d_s,uint16_t type);
void set_lvgl_get_key_func(void *func);
#endif
+99
View File
@@ -0,0 +1,99 @@
#include "lvgl/lvgl.h"
#include "ui/preview_ui.h"
#include "project_config.h"
#include "lvgl_ui.h"
#define MINI_DV_UI 0
#define IPC_UI 1
#define BBM_UI 2
#define CHILDREN_UI 3
#define DEFINE_UI MINI_DV_UI
lv_indev_t * indev_keypad;
extern lv_style_t g_style;
lv_obj_t *main_Mini_DV_ui(lv_obj_t *base_ui,lv_group_t *group)
{
lv_obj_t *btn;
//可以打印系统一些信息
btn = system_msg_ui(group,base_ui);
//预览dvp的镜头数据
btn = preview_ui(group,base_ui);
//可以进行录像拍照
btn = preview_encode_selct_ui(group,base_ui);
//播放自己录制的视频文件
btn = player2_ui(group,base_ui);
return base_ui;
}
lv_obj_t *main_IPC_ui(lv_obj_t *base_ui,lv_group_t *group)
{
lv_obj_t *btn;
//可以打印系统一些信息
btn = system_msg_ui(group,base_ui);
//预览USB的镜头数据
btn = preview_usb_ui(group,base_ui);
btn = preview_usb_select_ui(group,base_ui);
btn = photo_ui(group,base_ui);
return base_ui;
}
lv_obj_t *main_BBM_ui(lv_obj_t *base_ui,lv_group_t *group)
{
lv_obj_t *btn;
//可以打印系统一些信息
btn = system_msg_ui(group,base_ui);
btn = preview_net_jpg_ui(group,base_ui);
return base_ui;
}
lv_obj_t *main_children_ui(lv_obj_t *base_ui,lv_group_t *group)
{
lv_obj_t *btn;
btn = system_msg_ui(group,base_ui);
btn = preview_ui(group,base_ui);
btn = preview_encode_QVGA_ui(group,base_ui);
btn = preview_encode_QQVGA_ui(group,base_ui);
btn = preview_dvp_pip_ui(group,base_ui);
btn = preview_usb_ui(group,base_ui);
btn = preview_usb_encode_ui(group,base_ui);
btn = preview_dvp_usb_ui(group,base_ui);
btn = player_ui(group,base_ui);
btn = player2_ui(group,base_ui);
btn = preview_encode_takephoto_ui(group,base_ui);
btn = preview_encode_960P_ui(group,base_ui);
btn = preview_encode_selct_ui(group,base_ui);
btn = zbar_ui(group,base_ui);
btn = zbar_dvp_ui(group,base_ui);
btn = zbar_usb_ui(group,base_ui);
btn = preview_usb_select_ui(group,base_ui);
btn = photo_ui(group,base_ui);
return base_ui;
}
lv_obj_t *main_ui(lv_obj_t *base_ui)
{
lv_group_t *group;
group = lv_group_create();
lv_indev_set_group(indev_keypad, group);
lv_obj_t * ui = lv_list_create(lv_scr_act());
lv_obj_add_style(ui,&g_style,0);
lv_obj_set_size(ui, LV_PCT(100), LV_PCT(100));
#if DEFINE_UI == MINI_DV_UI
main_Mini_DV_ui(ui,group);
#elif DEFINE_UI == IPC_UI
main_IPC_ui(ui,group);
#elif DEFINE_UI == BBM_UI
main_BBM_ui(ui,group);
#elif DEFINE_UI == CHILDREN_UI
main_children_ui(ui,group);
#endif
return ui;
}
+5
View File
@@ -0,0 +1,5 @@
#ifndef __MAIN_UI_H
#define __MAIN_UI_H
#include "lvgl/lvgl.h"
lv_obj_t *main_ui(lv_obj_t *base_ui);
#endif
+459
View File
@@ -0,0 +1,459 @@
/***************************************************************************************
***************************************************************************************/
#include "lvgl/lvgl.h"
#include "lvgl_ui.h"
#include "osal/string.h"
#include "stream_frame.h"
#include "osal/work.h"
#include "keyWork.h"
#include "keyScan.h"
#include "new_avi/newavi_player.h"
#include "custom_mem/custom_mem.h"
#include "fatfs/osal_file.h"
#define CHECK_DIR "photo"
#define EXT_NAME "*jpg"
//data申请空间函数
#define STREAM_MALLOC custom_malloc_psram
#define STREAM_FREE custom_free_psram
#define STREAM_ZALLOC custom_zalloc_psram
//结构体申请空间函数
#define STREAM_LIBC_MALLOC custom_malloc
#define STREAM_LIBC_FREE custom_free
#define STREAM_LIBC_ZALLOC custom_zalloc
extern void set_lvgl_get_key_func(void *func);
extern lv_style_t g_style;
extern lv_indev_t * indev_keypad;
struct photo_ui_s
{
lv_group_t *last_group;
lv_obj_t *base_ui;
lv_group_t *now_group;
lv_obj_t *now_ui;
stream *photo_s;
stream *other_s;
stream *decode_s;
lv_obj_t * label_path;
};
struct photo_list_param
{
lv_group_t *group;
lv_obj_t *ui;
struct photo_ui_s *ui_s;
};
typedef int (*list_ui)(const char *filename,void *data);
static void exit_show_filelist(lv_event_t * e)
{
os_printf("%s:%d\n",__FUNCTION__,__LINE__);
struct photo_ui_s *ui_s = (struct photo_ui_s *)lv_event_get_user_data(e);
lv_obj_t *list_item = lv_event_get_current_target(e);
if(ui_s->now_group)
{
lv_indev_set_group(indev_keypad, ui_s->now_group);
}
if(list_item->user_data)
{
//由于是子控件回调函数需要删除父控件,所以需要用到异步删除,否则删除内部链表会有异常
lv_obj_del_async(list_item->user_data);
}
}
//读取图片,发送出去显示
static void play_photo(lv_event_t * e)
{
void *fp = NULL;
void *photo_buf = NULL;
struct data_structure *data_s;
uint32_t len;
struct photo_ui_s *ui_s = (struct photo_ui_s *)lv_event_get_user_data(e);
lv_obj_t *list_item = lv_event_get_current_target(e);
lv_obj_t *list = list_item->user_data;
char path[64];
const char *filename = lv_list_get_btn_text(list,list_item);
os_sprintf(path,"0:%s/%s",CHECK_DIR,filename);
if(!ui_s->photo_s)
{
goto play_photo_fail;
}
//读取图片文件,通过流去发送
data_s = get_src_data_f(ui_s->photo_s);
if(data_s)
{
lv_label_set_text(ui_s->label_path, path);
//开始显示图片
fp = osal_fopen(path,"rb");
if(fp)
{
uint32_t filesize = osal_fsize(fp);
photo_buf = (void*)STREAM_MALLOC(filesize);
if(!photo_buf)
{
force_del_data(data_s);
goto play_photo_fail;
}
else
{
len = osal_fread(photo_buf,1,filesize,fp);
if(len != filesize)
{
goto play_photo_fail;
}
data_s->data = (void*)photo_buf;
data_s->type = SET_DATA_TYPE(JPEG,JPEG_FULL);
set_stream_real_data_len(data_s,filesize);
send_data_to_stream(data_s);
photo_buf = NULL;
data_s = NULL;
goto play_photo_end;
}
}
goto play_photo_fail;
}
play_photo_fail:
//显示失败
os_sprintf(path,"0:%s/%s fail",CHECK_DIR,filename);
lv_label_set_text(ui_s->label_path, path);
play_photo_end:
if(fp)
{
osal_fclose(fp);
}
if(photo_buf)
{
STREAM_FREE(photo_buf);
}
exit_show_filelist(e);
}
static int photo_list_show(const char *filename,void *data)
{
struct photo_list_param *param = (struct photo_list_param*)data;
lv_obj_t * btn = lv_list_add_btn(param->ui, NULL, (const char *)filename);
btn->user_data = (void*)param->ui;
if(param->group)
{
lv_group_add_obj(param->group, btn);
}
//回调函数,进入回放功能
lv_obj_add_event_cb(btn, play_photo, LV_EVENT_CLICKED, param->ui_s);
return 0;
}
//遍历文件夹
//遍历文件夹
static int each_read_file(list_ui fn,void *param)
{
DIR dir;
FILINFO finfo;
FRESULT fr;
if(!fn)
{
goto each_read_file_end;
}
fr = f_findfirst(&dir, &finfo, CHECK_DIR, EXT_NAME);
while(fr == FR_OK && finfo.fname[0] != 0)
{
fn(finfo.fname,param);
fr = f_findnext(&dir, &finfo);
}
f_closedir(&dir);
each_read_file_end:
os_printf("%s:%d\tret:%d\n",__FUNCTION__,__LINE__,fr);
return fr;
}
static void clear_list_group_ui(lv_event_t * e)
{
lv_group_t *group = (lv_group_t *)lv_event_get_user_data(e);
os_printf("group:%X\n",group);
if(group)
{
lv_group_del(group);
}
}
static void show_filelist(lv_event_t * e)
{
int32_t c = *((int32_t *)lv_event_get_param(e));
if(c == 'e')
{
struct photo_ui_s *ui_s = (struct photo_ui_s *)lv_event_get_user_data(e);
struct photo_list_param param;
lv_obj_t *list = lv_list_create(ui_s->now_ui);
lv_obj_set_size(list, LV_PCT(100), LV_PCT(100));
param.ui_s = ui_s;
param.ui = list;
param.group = lv_group_create();
lv_indev_set_group(indev_keypad, param.group);
//创建exit的控件
lv_obj_t *list_item = lv_list_add_btn(list, NULL, "exit");
list_item->user_data = (void*)list;
lv_group_add_obj(param.group, list_item);
lv_obj_add_event_cb(list_item, exit_show_filelist, LV_EVENT_SHORT_CLICKED, ui_s);
each_read_file(photo_list_show,(void*)&param);
lv_obj_add_event_cb(list, clear_list_group_ui, LV_EVENT_DELETE, param.group);
}
}
static uint32_t self_key(uint32_t val)
{
uint32_t key_ret = 0;
if(val > 0)
{
if((val&0xff) == KEY_EVENT_SUP)
{
switch(val>>8)
{
case AD_UP:
key_ret = LV_KEY_PREV;
break;
case AD_DOWN:
key_ret = LV_KEY_NEXT;
break;
case AD_LEFT:
key_ret = 'a';
break;
case AD_RIGHT:
key_ret = 'd';
break;
case AD_A:
key_ret = 'q';
break;
case AD_B:
key_ret = 'e';
break;
case AD_PRESS:
key_ret = LV_KEY_ENTER;
break;
break;
default:
break;
}
}
}
return key_ret;
}
static int opcode_func(stream *s,void *priv,int opcode)
{
int res = 0;
switch(opcode)
{
case STREAM_OPEN_ENTER:
break;
case STREAM_OPEN_EXIT:
{
}
break;
case STREAM_OPEN_FAIL:
break;
case STREAM_DATA_DIS:
{
}
break;
case STREAM_RECV_DATA_FINISH:
{
}
break;
//在发送到这个流的时候,进行数据包过滤
case STREAM_FILTER_DATA:
{
}
break;
//流接收后,数据包也要检查是否需要过滤或者是不是因为逻辑条件符合需要过滤
case STREAM_RECV_FILTER_DATA:
{
}
break;
case STREAM_DATA_FREE:
{
struct data_structure *data = (struct data_structure *)priv;
if(data->data)
{
STREAM_FREE(data->data);
data->data = NULL;
}
}
break;
case STREAM_CLOSE_EXIT:
{
}
break;
case STREAM_MARK_GC_END:
{
}
break;
default:
break;
}
return res;
}
//创建播放器的流,这个流主要实现的是控制速度转发作用,暂时控制的是视频
//如果要控制音频,需要计算时间来控制速度
static stream *photo_stream(const char *name)
{
stream *s = open_stream_available(name,4,0,opcode_func,NULL);
return s;
}
static void exit_player_ui(lv_event_t * e)
{
int32_t c = *((int32_t *)lv_event_get_param(e));
if(c == 'q')
{
struct photo_ui_s *ui_s = (struct photo_ui_s *)lv_event_get_user_data(e);
lv_indev_set_group(indev_keypad, ui_s->last_group);
lv_obj_clear_flag(ui_s->base_ui, LV_OBJ_FLAG_HIDDEN);
lv_group_del(ui_s->now_group);
ui_s->now_group = NULL;
close_stream(ui_s->decode_s);
close_stream(ui_s->other_s);
close_stream(ui_s->photo_s);
ui_s->decode_s = NULL;
ui_s->other_s = NULL;
ui_s->photo_s = NULL;
lv_obj_del(ui_s->now_ui);
set_lvgl_get_key_func(NULL);
}
}
static void enter_player_ui(lv_event_t * e)
{
set_lvgl_get_key_func(self_key);
struct photo_ui_s *ui_s = (struct photo_ui_s *)lv_event_get_user_data(e);
lv_obj_t *base_ui = ui_s->base_ui;
lv_obj_add_flag(base_ui, LV_OBJ_FLAG_HIDDEN);
lv_obj_t *ui = lv_obj_create(lv_scr_act());
ui_s->now_ui = ui;
lv_obj_add_style(ui, &g_style, 0);
lv_obj_set_size(ui, LV_PCT(100), LV_PCT(100));
ui_s->label_path = lv_label_create(ui);
lv_label_set_text(ui_s->label_path, "");
lv_obj_align(ui_s->label_path,LV_ALIGN_TOP_MID,0,0);
ui_s->photo_s = photo_stream(S_LVGL_PHOTO);
streamSrc_bind_streamDest(ui_s->photo_s,SR_OTHER_JPG);
enable_stream(ui_s->photo_s,1);
//SR_OTHER_JPG接收数据,然后发送到decode
ui_s->other_s = other_jpg_stream_not_bind(SR_OTHER_JPG,320,240,320,240,YUV_P0);
streamSrc_bind_streamDest(ui_s->other_s,S_JPG_DECODE);
enable_stream(ui_s->other_s,1);
//decode发送到S_NEWPLAYER控制速度后,转发到P0
ui_s->decode_s = jpg_decode_stream_not_bind(S_JPG_DECODE);
streamSrc_bind_streamDest(ui_s->decode_s,R_VIDEO_P0);
enable_stream(ui_s->decode_s,1);
lv_group_t *group;
group = lv_group_create();
lv_indev_set_group(indev_keypad, group);
lv_group_add_obj(group, ui);
ui_s->now_group = group;
//弹出菜单栏,用于切换分辨率
lv_obj_add_event_cb(ui, show_filelist, LV_EVENT_KEY, ui_s);
lv_obj_add_event_cb(ui, exit_player_ui, LV_EVENT_KEY, ui_s);
}
lv_obj_t *photo_ui(lv_group_t *group,lv_obj_t *base_ui)
{
struct photo_ui_s *ui_s = (struct photo_ui_s*)STREAM_LIBC_ZALLOC(sizeof(struct photo_ui_s));
ui_s->last_group = group;
ui_s->base_ui = base_ui;
lv_obj_t *btn = lv_list_add_btn(base_ui, NULL, "photo");
lv_group_add_obj(group, btn);
lv_obj_add_event_cb(btn, enter_player_ui, LV_EVENT_SHORT_CLICKED, ui_s);
return btn;
}
+796
View File
@@ -0,0 +1,796 @@
/***************************************************************************************
***************************************************************************************/
#include "lvgl/lvgl.h"
#include "lvgl_ui.h"
#include "osal/string.h"
#include "stream_frame.h"
#include "osal/work.h"
#include "keyWork.h"
#include "keyScan.h"
#include "new_avi/newavi_player.h"
#include "custom_mem/custom_mem.h"
#include "fatfs/osal_file.h"
#define PLAY_UI_DIR "DCIM"
#define PLAY_AVI_STREAM_NAME (64)
enum
{
PLAY_STATUS_STOP_PLAY = BIT(0),
PLAY_STATUS_PLAY_1FPS = BIT(1), //播放一帧,然后自动暂停
PLAY_STATUS_PLAY_END = BIT(2), //播放完毕,需要重新播放
};
//转发流的播放流结构体
struct player_forward_stream_s
{
struct os_work work;
stream *s;
struct data_structure *data_s;
uint32_t magic;
uint32_t start_time;
uint32_t last_fps_play_time; //上一帧播放的时间(非系统时间,是视频帧的时间)
uint8_t play_status; //自己的播放状态,第一bit代表播放或者暂停
};
//data申请空间函数
#define STREAM_MALLOC custom_malloc_psram
#define STREAM_FREE custom_free_psram
#define STREAM_ZALLOC custom_zalloc_psram
//结构体申请空间函数
#define STREAM_LIBC_MALLOC custom_malloc
#define STREAM_LIBC_FREE custom_free
#define STREAM_LIBC_ZALLOC custom_zalloc
extern void set_lvgl_get_key_func(void *func);
extern lv_style_t g_style;
extern lv_indev_t * indev_keypad;
stream *newavi_player2_init(const char *filename,const char *stream_name);
struct player_ui_s
{
lv_group_t *last_group;
lv_obj_t *base_ui;
lv_group_t *now_group;
lv_obj_t *now_ui;
stream *other_s;
stream *decode_s;
stream *player_s;
stream *avi_s;
lv_timer_t *timer;
lv_obj_t * label_time;
uint8_t *play_name;
};
//文件列表读取
static uint32_t avi_open_dir(DIR *avi_dir,char *dir_name)
{
char filepath[64];
os_sprintf(filepath,"0:%s",dir_name);
os_printf("filepath:%s\n",filepath);
return f_opendir(avi_dir,filepath);
}
static uint32_t avi_close_dir(DIR *avi_dir)
{
f_closedir(avi_dir);
return 0;
}
static uint32_t next_file(DIR *avi_dir,FILINFO* finfo)
{
uint32_t ret = f_readdir(avi_dir,finfo);
if(ret != FR_OK || finfo->fname[0] == 0)
{
return ~0;
}
return ret;
}
struct avi_list_param
{
lv_group_t *group;
lv_obj_t *ui;
struct player_ui_s *ui_s;
};
typedef int (*creat_avi_list_ui)(const char *filename,void *data);
static void exit_show_filelist(lv_event_t * e)
{
os_printf("%s:%d\n",__FUNCTION__,__LINE__);
struct player_ui_s *ui_s = (struct player_ui_s *)lv_event_get_user_data(e);
lv_obj_t *list_item = lv_event_get_current_target(e);
if(ui_s->now_group)
{
lv_indev_set_group(indev_keypad, ui_s->now_group);
}
if(list_item->user_data)
{
//由于是子控件回调函数需要删除父控件,所以需要用到异步删除,否则删除内部链表会有异常
lv_obj_del_async(list_item->user_data);
}
}
//进入回放
static void enter_playback(lv_event_t * e)
{
struct player_ui_s *ui_s = (struct player_ui_s *)lv_event_get_user_data(e);
lv_obj_t *list_item = lv_event_get_current_target(e);
lv_obj_t *list = list_item->user_data;
//将当前的流关闭,内部判断是否=NULL,这里就不判断了
close_stream(ui_s->avi_s);
if(ui_s->play_name)
{
STREAM_FREE(ui_s->play_name);
ui_s->play_name = NULL;
}
os_printf("ui_s->label_time:%X\n",ui_s->label_time);
lv_label_set_text(ui_s->label_time, "00:00");
//重新打开一个视频文件
uint8_t path[64];
const char *filename = lv_list_get_btn_text(list,list_item);
os_printf("play filename:%s\n",filename);
os_sprintf(path,"0:%s/%s",PLAY_UI_DIR,filename);
ui_s->play_name = (uint8_t*)STREAM_MALLOC(PLAY_AVI_STREAM_NAME);
os_sprintf(ui_s->play_name,"%s_%04d",filename,(uint32_t)os_jiffies());
os_printf("stream play_name:%s\n",ui_s->play_name);
ui_s->avi_s = newavi_player2_init((const char *)ui_s->play_name,(const char *)path);
if(ui_s->avi_s)
{
//设置播放一帧,先去停止播放器
struct player_forward_stream_s *player_msg = ui_s->player_s->priv;
os_work_cancle2(&player_msg->work, 1);
streamSrc_bind_streamDest(ui_s->avi_s,S_NEWPLAYER);
//streamSrc_bind_streamDest(ui_s->avi_s,SR_OTHER_JPG);
//streamSrc_bind_streamDest(ui_s->avi_s,R_SPEAKER);
//重新开始播放,修改启动时间
player_msg->last_fps_play_time = 0;
player_msg->start_time = os_jiffies();
player_msg->magic = os_jiffies();
stream_self_cmd_func(ui_s->avi_s,NEWAVI_PLAYER_MAGIC,player_msg->magic);
player_msg->play_status = (PLAY_STATUS_STOP_PLAY|PLAY_STATUS_PLAY_1FPS);
OS_WORK_REINIT(&player_msg->work);
os_run_work_delay(&player_msg->work, 1);
//文件开始解析
enable_stream(ui_s->avi_s,1);
}
exit_show_filelist(e);
}
static int avi_list_show(const char *filename,void *data)
{
struct avi_list_param *param = (struct avi_list_param*)data;
lv_obj_t * btn = lv_list_add_btn(param->ui, NULL, (const char *)filename);
btn->user_data = (void*)param->ui;
if(param->group)
{
lv_group_add_obj(param->group, btn);
}
//回调函数,进入回放功能
lv_obj_add_event_cb(btn, enter_playback, LV_EVENT_CLICKED, param->ui_s);
return 0;
}
//遍历文件夹
static int each_read_file(char *dir_name,creat_avi_list_ui fn,void *param)
{
DIR dir;
FILINFO finfo;
int ret = 0;
if(!fn)
{
goto each_read_file_end;
}
ret = avi_open_dir(&dir,dir_name);
if(ret)
{
goto each_read_file_end;
}
while(next_file(&dir,&finfo) == FR_OK)
{
if(ret == FR_OK && finfo.fname[0] != 0)
{
#if 0
os_printf("fname:%s\n",finfo.fname);
btn = lv_list_add_btn(list, NULL, (const char *)finfo.fname);
lv_group_add_obj(group, btn);
lv_obj_add_event_cb(btn, MP3_replay, LV_EVENT_ALL, list);
#endif
fn(finfo.fname,param);
}
else
{
break;
}
}
avi_close_dir(&dir);
each_read_file_end:
os_printf("%s:%d\tret:%d\n",__FUNCTION__,__LINE__,ret);
return ret;
}
static void clear_list_group_ui(lv_event_t * e)
{
lv_group_t *group = (lv_group_t *)lv_event_get_user_data(e);
os_printf("group:%X\n",group);
if(group)
{
lv_group_del(group);
}
}
static void show_filelist(lv_event_t * e)
{
int32_t c = *((int32_t *)lv_event_get_param(e));
if(c == 'e')
{
struct player_ui_s *ui_s = (struct player_ui_s *)lv_event_get_user_data(e);
struct avi_list_param param;
lv_obj_t *list = lv_list_create(ui_s->now_ui);
lv_obj_set_size(list, LV_PCT(100), LV_PCT(100));
param.ui_s = ui_s;
param.ui = list;
param.group = lv_group_create();
lv_indev_set_group(indev_keypad, param.group);
//创建exit的控件
lv_obj_t *list_item = lv_list_add_btn(list, NULL, "exit");
list_item->user_data = (void*)list;
lv_group_add_obj(param.group, list_item);
lv_obj_add_event_cb(list_item, exit_show_filelist, LV_EVENT_SHORT_CLICKED, ui_s);
each_read_file(PLAY_UI_DIR,avi_list_show,(void*)&param);
lv_obj_add_event_cb(list, clear_list_group_ui, LV_EVENT_DELETE, param.group);
}
}
static uint32_t self_key(uint32_t val)
{
uint32_t key_ret = 0;
if(val > 0)
{
if((val&0xff) == KEY_EVENT_SUP)
{
switch(val>>8)
{
case AD_UP:
key_ret = LV_KEY_PREV;
break;
case AD_DOWN:
key_ret = LV_KEY_NEXT;
break;
case AD_LEFT:
key_ret = 'a';
break;
case AD_RIGHT:
key_ret = 'd';
break;
case AD_A:
key_ret = 'q';
break;
case AD_B:
key_ret = 'e';
break;
case AD_PRESS:
key_ret = LV_KEY_ENTER;
break;
break;
default:
break;
}
}
}
return key_ret;
}
//stream_self_cmd_func(jpg_de->parent_data_s->s,JPG_DECODE_ARG,(uint32_t)jpg_de->parent_data_s);
//这里要创建一个流,专门是控制avi播放流的,由jpg解码,发送到这里缓存起来,然后控制播放速度、暂停等
//这里使用lvgl的timer来代替workqueue
static uint32_t custom_get_data_len(void *data)
{
struct data_structure *data_s = (struct data_structure *)data;
return get_stream_real_data_len(data_s->data);
}
static void *custom_get_data(void *data)
{
struct data_structure *data_s = (struct data_structure *)data;
return get_stream_real_data(data_s->data);;
}
static uint32_t custom_get_data_time(void *data)
{
struct data_structure *data_s = (struct data_structure *)data;
return get_stream_data_timestamp(data_s->data);
}
static uint32_t forward_stream_cmd_func(stream *s,int opcode,uint32_t arg)
{
struct data_structure *data = (struct data_structure *)arg;
if(data->data)
{
struct data_structure *data_parent = (struct data_structure *)data->data;
return stream_self_cmd_func(data_parent->s,YUV_ARG,(uint32_t)data_parent);
}
return 0;
}
//这个是转发的流,只是添加一些必要信息,所以这里获取的data信息要更换
static const stream_ops_func forward_stream_ops =
{
.get_data_len = custom_get_data_len,
.get_data = custom_get_data,
.get_data_time = custom_get_data_time,
};
static int32_t player_work(struct os_work *work)
{
struct player_forward_stream_s *player_msg = (struct player_forward_stream_s *)work;
struct data_structure *data_s = NULL;
uint32_t time;
//static int count = 0;
if(!player_msg->s->enable)
{
goto player_work_get_data;
}
if(!(player_msg->play_status&PLAY_STATUS_STOP_PLAY))
{
goto player_work_get_data;
}
if(player_msg->data_s)
{
time = get_stream_data_timestamp(player_msg->data_s);
//先检查时间是否合适
if(player_msg->start_time + time > os_jiffies())
{
if(player_msg->magic != player_msg->data_s->magic)
{
free_data(player_msg->data_s);
player_msg->data_s = NULL;
}
goto player_work_end;
}
//再次检查是否符合需要播放(有可能是缓存或者快进导致进入这里)
if(player_msg->magic != player_msg->data_s->magic)
{
free_data(player_msg->data_s);
player_msg->data_s = NULL;
_os_printf("=");
goto player_work_end;
}
if(player_msg->play_status&PLAY_STATUS_PLAY_1FPS)
{
player_msg->play_status &= ~(PLAY_STATUS_STOP_PLAY|PLAY_STATUS_PLAY_1FPS);
}
//os_printf("time:%d\tstart_time:%d\tmagic:%d\n",time,player_msg->start_time,player_msg->data_s->magic);
player_msg->last_fps_play_time = time;
//判断一下时间是否需要播放
data_s = get_src_data_f(player_msg->s);
//准备填好显示、解码参数信息,然后发送到解码的模块去解码,主要如果没有成功要如何处理,这里没有考虑
if(data_s)
{
data_s->type = player_msg->data_s->type;
data_s->data = player_msg->data_s;
//os_printf("time:%d\ttype:%X\n",time,player_msg->data_s->type);
_os_printf("=");
send_data_to_stream(data_s);
player_msg->data_s = NULL;
}
}
player_work_get_data:
if(!player_msg->data_s)
{
player_msg->data_s = recv_real_data(player_msg->s);
}
else
{
if(player_msg->magic != player_msg->data_s->magic)
{
free_data(player_msg->data_s);
player_msg->data_s = NULL;
goto player_work_end;
}
}
player_work_end:
os_run_work_delay(work, 1);
return 0;
}
static int opcode_func(stream *s,void *priv,int opcode)
{
int res = 0;
switch(opcode)
{
case STREAM_OPEN_ENTER:
break;
case STREAM_OPEN_EXIT:
{
struct player_forward_stream_s *msg = (struct player_forward_stream_s *)STREAM_ZALLOC(sizeof(struct player_forward_stream_s));
msg->s = s;
s->priv = msg;
msg->start_time = os_jiffies();
msg->data_s = NULL;
msg->magic = 0;
msg->play_status = (PLAY_STATUS_STOP_PLAY|PLAY_STATUS_PLAY_1FPS);
msg->last_fps_play_time = 0;
register_stream_self_cmd_func(s,forward_stream_cmd_func);
stream_data_dis_mem_custom(s);
OS_WORK_INIT(&msg->work, player_work, 0);
os_run_work_delay(&msg->work, 1);
//enable_stream(s,1);
}
break;
case STREAM_OPEN_FAIL:
break;
case STREAM_DATA_DIS:
{
struct data_structure *data = (struct data_structure *)priv;
data->ops = (stream_ops_func*)&forward_stream_ops;
}
break;
case STREAM_RECV_DATA_FINISH:
{
}
break;
//在发送到这个流的时候,进行数据包过滤
case STREAM_FILTER_DATA:
{
}
break;
//流接收后,数据包也要检查是否需要过滤或者是不是因为逻辑条件符合需要过滤
case STREAM_RECV_FILTER_DATA:
{
struct data_structure *data = (struct data_structure *)priv;
struct player_forward_stream_s *msg = (struct player_forward_stream_s *)s->priv;
//过滤一下没有用的数据包,只是接收play_time_start之后的数据包
if(!(msg->magic == data->magic))
{
res = 1;
}
}
break;
case STREAM_DATA_FREE:
{
struct data_structure *data = (struct data_structure *)priv;
if(data->data)
{
//因为是转发,所以这里移除的话是交给原来的方法移除
_os_printf("$");
free_data(data->data);
data->data = NULL;
}
}
break;
case STREAM_CLOSE_EXIT:
{
struct player_forward_stream_s *msg = (struct player_forward_stream_s *)s->priv;
os_work_cancle2(&msg->work, 1);
//清理不需要的资源
if(msg->data_s)
{
os_printf("msg->data_s:%X\n",msg->data_s);
free_data(msg->data_s);
}
}
break;
case STREAM_MARK_GC_END:
{
struct player_forward_stream_s *msg = (struct player_forward_stream_s *)s->priv;
if(msg)
{
STREAM_FREE(msg);
}
}
break;
default:
break;
}
return res;
}
//创建播放器的流,这个流主要实现的是控制速度转发作用,暂时控制的是视频
//如果要控制音频,需要计算时间来控制速度
static stream *player_stream(const char *name)
{
stream *s = open_stream_available(name,16,16,opcode_func,NULL);
return s;
}
static void player_locate_ctrl_ui(lv_event_t * e)
{
struct player_ui_s *ui_s = (struct player_ui_s *)lv_event_get_user_data(e);
struct player_forward_stream_s *player_msg = ui_s->player_s->priv;
int32_t c = *((int32_t *)lv_event_get_param(e));
//printf("c:%d\n",c);
switch(c)
{
//后退
case 'a':
{
os_work_cancle2(&player_msg->work, 1);
uint32_t now_play_time = stream_self_cmd_func(ui_s->avi_s,NEWAVI_PLAYER_LOCATE_REWIND_INDEX,player_msg->last_fps_play_time);
//重新开始播放,修改启动时间
player_msg->last_fps_play_time = now_play_time;
player_msg->start_time = os_jiffies() - now_play_time;
player_msg->magic = os_jiffies();
stream_self_cmd_func(ui_s->avi_s,NEWAVI_PLAYER_MAGIC,player_msg->magic);
player_msg->play_status = (PLAY_STATUS_STOP_PLAY|PLAY_STATUS_PLAY_1FPS);
OS_WORK_REINIT(&player_msg->work);
os_run_work_delay(&player_msg->work, 1);
}
break;
//前进
case 'd':
{
os_work_cancle2(&player_msg->work, 1);
uint32_t now_play_time = stream_self_cmd_func(ui_s->avi_s,NEWAVI_PLAYER_LOCATE_FORWARD_INDEX,player_msg->last_fps_play_time);
//重新开始播放,修改启动时间
player_msg->last_fps_play_time = now_play_time;
player_msg->start_time = os_jiffies() - now_play_time;
player_msg->magic = os_jiffies();
stream_self_cmd_func(ui_s->avi_s,NEWAVI_PLAYER_MAGIC,player_msg->magic);
player_msg->play_status = (PLAY_STATUS_STOP_PLAY|PLAY_STATUS_PLAY_1FPS);
OS_WORK_REINIT(&player_msg->work);
os_run_work_delay(&player_msg->work, 1);
}
break;
default:
break;
}
}
static void player_ctrl_ui(lv_event_t * e)
{
struct player_ui_s *ui_s = (struct player_ui_s *)lv_event_get_user_data(e);
struct player_forward_stream_s *player_msg = ui_s->player_s->priv;
os_printf("%s:%d\n",__FUNCTION__,__LINE__);
//根据播放状态设置
if(player_msg->play_status&PLAY_STATUS_STOP_PLAY)
{
player_msg->play_status &= (~PLAY_STATUS_STOP_PLAY);
}
else
{
//重新开始播放,修改启动时间
player_msg->start_time = os_jiffies() - player_msg->last_fps_play_time;
player_msg->play_status |= PLAY_STATUS_STOP_PLAY;
os_printf("################## stop time:%d\tlast_time:%d\n",player_msg->start_time,player_msg->last_fps_play_time);
}
}
static void exit_player_ui(lv_event_t * e)
{
struct player_ui_s *ui_s = (struct player_ui_s *)lv_event_get_user_data(e);
int32_t c = *((int32_t *)lv_event_get_param(e));
if(c == 'q')
{
lv_timer_del(ui_s->timer);
struct player_ui_s *ui_s = (struct player_ui_s *)lv_event_get_user_data(e);
lv_indev_set_group(indev_keypad, ui_s->last_group);
lv_obj_clear_flag(ui_s->base_ui, LV_OBJ_FLAG_HIDDEN);
lv_group_del(ui_s->now_group);
ui_s->now_group = NULL;
close_stream(ui_s->other_s);
close_stream(ui_s->decode_s);
close_stream(ui_s->player_s);
close_stream(ui_s->avi_s);
ui_s->other_s = NULL;
ui_s->decode_s = NULL;
ui_s->player_s = NULL;
ui_s->avi_s = NULL;
lv_obj_del(ui_s->now_ui);
if(ui_s->play_name)
{
STREAM_FREE(ui_s->play_name);
ui_s->play_name = NULL;
}
set_lvgl_get_key_func(NULL);
os_printf("sram mem:%d\tpsram mem:%d\n",sysheap_freesize(&sram_heap),sysheap_freesize(&psram_heap));
print_custom_sram();
print_custom_psram();
}
}
static void player_ui_timer(lv_timer_t *t)
{
struct player_ui_s *ui_s = (struct player_ui_s *)t->user_data;
if(ui_s->avi_s)
{
//获取当前播放器的流结构体
struct player_forward_stream_s *player_msg = ui_s->player_s->priv;
//os_printf("play time:%d\tstart_time:%d\n",player_msg->last_fps_play_time,player_msg->start_time);
char show_time[64];
sprintf(show_time,"%02d:%02d",(player_msg->last_fps_play_time/1000)/60,(player_msg->last_fps_play_time/1000)%60);
lv_label_set_text(ui_s->label_time, show_time);
#if 0
//判断文件已经播放完毕,如果需要重新播放,则重新建立播放文件
int status = stream_self_cmd_func(ui_s->avi_s,NEWAVI_PLAYER_STATUS,0);
if(status)
{
os_printf("status:%d\n",status);
}
#endif
}
}
static void enter_player_ui(lv_event_t * e)
{
set_lvgl_get_key_func(self_key);
struct player_ui_s *ui_s = (struct player_ui_s *)lv_event_get_user_data(e);
lv_obj_t *base_ui = ui_s->base_ui;
lv_obj_add_flag(base_ui, LV_OBJ_FLAG_HIDDEN);
lv_obj_t *ui = lv_obj_create(lv_scr_act());
ui_s->now_ui = ui;
lv_obj_add_style(ui, &g_style, 0);
lv_obj_set_size(ui, LV_PCT(100), LV_PCT(100));
#if 0
struct avi_list_param param;
lv_obj_t *list = lv_list_create(ui_s->now_ui);
lv_obj_set_size(list, LV_PCT(100), LV_PCT(100));
param.ui_s = ui_s;
param.ui = list;
param.group = NULL;
each_read_file("DCIM",avi_list_show,(void*)&param);
return;
#endif
//播放转发发送到P0,控制速度
ui_s->player_s = player_stream(S_NEWPLAYER);
//streamSrc_bind_streamDest(ui_s->player_s,R_VIDEO_P0);
streamSrc_bind_streamDest(ui_s->player_s,R_SPEAKER);
streamSrc_bind_streamDest(ui_s->player_s,SR_OTHER_JPG);
enable_stream(ui_s->player_s,1);
//SR_OTHER_JPG接收数据,然后发送到decode
ui_s->other_s = other_jpg_stream_not_bind(SR_OTHER_JPG,320,240,320,240,YUV_P0);
streamSrc_bind_streamDest(ui_s->other_s,S_JPG_DECODE);
enable_stream(ui_s->other_s,1);
//decode发送到S_NEWPLAYER控制速度后,转发到P0
ui_s->decode_s = jpg_decode_stream_not_bind(S_JPG_DECODE);
streamSrc_bind_streamDest(ui_s->decode_s,R_VIDEO_P0);
//streamSrc_bind_streamDest(ui_s->decode_s,S_NEWPLAYER);
enable_stream(ui_s->decode_s,1);
#if 0
ui_s->avi_s = newavi_player2_init(S_NEWAVI,"0:DCIM/AVI1.avi");
if(ui_s->avi_s)
{
streamSrc_bind_streamDest(ui_s->avi_s,S_NEWPLAYER);
//streamSrc_bind_streamDest(ui_s->avi_s,SR_OTHER_JPG);
//streamSrc_bind_streamDest(ui_s->avi_s,R_SPEAKER);
enable_stream(ui_s->avi_s,1);
}
#endif
//创建lvgl的timer,用于获取播放的时间
ui_s->label_time = lv_label_create(ui);
lv_label_set_text(ui_s->label_time, "00:00");
lv_obj_align(ui_s->label_time,LV_ALIGN_TOP_MID,0,0);
ui_s->timer = lv_timer_create(player_ui_timer, 100, (void*)ui_s);
lv_group_t *group;
group = lv_group_create();
lv_indev_set_group(indev_keypad, group);
lv_group_add_obj(group, ui);
ui_s->now_group = group;
lv_obj_add_event_cb(ui, exit_player_ui, LV_EVENT_KEY, ui_s);
//控制暂停、播放
lv_obj_add_event_cb(ui, player_ctrl_ui, LV_EVENT_SHORT_CLICKED, ui_s);
//快进快退,一次尝试快进5秒,一次尝试快退5秒
lv_obj_add_event_cb(ui, player_locate_ctrl_ui, LV_EVENT_KEY, ui_s);
//弹出菜单栏,用于切换分辨率
lv_obj_add_event_cb(ui, show_filelist, LV_EVENT_KEY, ui_s);
}
lv_obj_t *player2_ui(lv_group_t *group,lv_obj_t *base_ui)
{
struct player_ui_s *ui_s = (struct player_ui_s*)STREAM_LIBC_ZALLOC(sizeof(struct player_ui_s));
ui_s->last_group = group;
ui_s->base_ui = base_ui;
ui_s->play_name = NULL;
lv_obj_t *btn = lv_list_add_btn(base_ui, NULL, "player2");
lv_group_add_obj(group, btn);
lv_obj_add_event_cb(btn, enter_player_ui, LV_EVENT_SHORT_CLICKED, ui_s);
return btn;
}
+773
View File
@@ -0,0 +1,773 @@
/***************************************************************************************
***************************************************************************************/
#include "lvgl/lvgl.h"
#include "lvgl_ui.h"
#include "osal/string.h"
#include "stream_frame.h"
#include "osal/work.h"
#include "keyWork.h"
#include "keyScan.h"
#include "new_avi/newavi_player.h"
#include "custom_mem/custom_mem.h"
#include "fatfs/osal_file.h"
#define CHECK_DIR "AVI1"
#define EXT_NAME "*avi"
#define PLAY_AVI_STREAM_NAME (64)
enum
{
PLAY_STATUS_STOP_PLAY = BIT(0),
PLAY_STATUS_PLAY_1FPS = BIT(1), //播放一帧,然后自动暂停
PLAY_STATUS_PLAY_END = BIT(2), //播放完毕,需要重新播放
};
//转发流的播放流结构体
struct player_forward_stream_s
{
struct os_work work;
stream *s;
struct data_structure *data_s;
uint32_t magic;
uint32_t start_time;
uint32_t last_fps_play_time; //上一帧播放的时间(非系统时间,是视频帧的时间)
uint8_t play_status; //自己的播放状态,第一bit代表播放或者暂停
};
//data申请空间函数
#define STREAM_MALLOC custom_malloc_psram
#define STREAM_FREE custom_free_psram
#define STREAM_ZALLOC custom_zalloc_psram
//结构体申请空间函数
#define STREAM_LIBC_MALLOC custom_malloc
#define STREAM_LIBC_FREE custom_free
#define STREAM_LIBC_ZALLOC custom_zalloc
extern void set_lvgl_get_key_func(void *func);
extern lv_style_t g_style;
extern lv_indev_t * indev_keypad;
stream *newavi_player2_init(const char *filename,const char *stream_name);
struct player_ui_s
{
lv_group_t *last_group;
lv_obj_t *base_ui;
lv_group_t *now_group;
lv_obj_t *now_ui;
stream *other_s;
stream *decode_s;
stream *player_s;
stream *avi_s;
lv_timer_t *timer;
lv_obj_t * label_time;
uint8_t *play_name;
};
struct avi_list_param
{
lv_group_t *group;
lv_obj_t *ui;
struct player_ui_s *ui_s;
};
typedef int (*creat_avi_list_ui)(const char *filename,void *data);
static void exit_show_filelist(lv_event_t * e)
{
os_printf("%s:%d\n",__FUNCTION__,__LINE__);
struct player_ui_s *ui_s = (struct player_ui_s *)lv_event_get_user_data(e);
lv_obj_t *list_item = lv_event_get_current_target(e);
if(ui_s->now_group)
{
lv_indev_set_group(indev_keypad, ui_s->now_group);
}
if(list_item->user_data)
{
//由于是子控件回调函数需要删除父控件,所以需要用到异步删除,否则删除内部链表会有异常
lv_obj_del_async(list_item->user_data);
}
}
//进入回放
static void enter_playback(lv_event_t * e)
{
struct player_ui_s *ui_s = (struct player_ui_s *)lv_event_get_user_data(e);
lv_obj_t *list_item = lv_event_get_current_target(e);
lv_obj_t *list = list_item->user_data;
//将当前的流关闭,内部判断是否=NULL,这里就不判断了
close_stream(ui_s->avi_s);
if(ui_s->play_name)
{
STREAM_FREE(ui_s->play_name);
ui_s->play_name = NULL;
}
os_printf("ui_s->label_time:%X\n",ui_s->label_time);
lv_label_set_text(ui_s->label_time, "00:00");
//重新打开一个视频文件
char path[64];
const char *filename = lv_list_get_btn_text(list,list_item);
os_printf("play filename:%s\n",filename);
os_sprintf(path,"0:%s/%s",CHECK_DIR,filename);
ui_s->play_name = (uint8_t*)STREAM_MALLOC(PLAY_AVI_STREAM_NAME);
os_sprintf(ui_s->play_name,"%s_%04d",filename,(uint32_t)os_jiffies());
os_printf("stream play_name:%s\n",ui_s->play_name);
ui_s->avi_s = newavi_player_init((const char *)ui_s->play_name,(const char *)path);
if(ui_s->avi_s)
{
//设置播放一帧,先去停止播放器
struct player_forward_stream_s *player_msg = ui_s->player_s->priv;
os_work_cancle2(&player_msg->work, 1);
streamSrc_bind_streamDest(ui_s->avi_s,S_NEWPLAYER);
//streamSrc_bind_streamDest(ui_s->avi_s,SR_OTHER_JPG);
//streamSrc_bind_streamDest(ui_s->avi_s,R_SPEAKER);
//重新开始播放,修改启动时间
player_msg->last_fps_play_time = 0;
player_msg->start_time = os_jiffies();
player_msg->magic = os_jiffies();
stream_self_cmd_func(ui_s->avi_s,NEWAVI_PLAYER_MAGIC,player_msg->magic);
player_msg->play_status = (PLAY_STATUS_STOP_PLAY|PLAY_STATUS_PLAY_1FPS);
OS_WORK_REINIT(&player_msg->work);
os_run_work_delay(&player_msg->work, 1);
//文件开始解析
enable_stream(ui_s->avi_s,1);
}
exit_show_filelist(e);
}
static int avi_list_show(const char *filename,void *data)
{
struct avi_list_param *param = (struct avi_list_param*)data;
lv_obj_t * btn = lv_list_add_btn(param->ui, NULL, (const char *)filename);
btn->user_data = (void*)param->ui;
if(param->group)
{
lv_group_add_obj(param->group, btn);
}
//回调函数,进入回放功能
lv_obj_add_event_cb(btn, enter_playback, LV_EVENT_CLICKED, param->ui_s);
return 0;
}
//遍历文件夹
static int each_read_file(creat_avi_list_ui fn,void *param)
{
DIR dir;
FILINFO finfo;
FRESULT fr;
if(!fn)
{
goto each_read_file_end;
}
fr = f_findfirst(&dir, &finfo, CHECK_DIR, EXT_NAME);
while(fr == FR_OK && finfo.fname[0] != 0)
{
fn(finfo.fname,param);
fr = f_findnext(&dir, &finfo);
}
f_closedir(&dir);
each_read_file_end:
os_printf("%s:%d\tret:%d\n",__FUNCTION__,__LINE__,fr);
return fr;
}
static void clear_list_group_ui(lv_event_t * e)
{
lv_group_t *group = (lv_group_t *)lv_event_get_user_data(e);
os_printf("group:%X\n",group);
if(group)
{
lv_group_del(group);
}
}
static void show_filelist(lv_event_t * e)
{
int32_t c = *((int32_t *)lv_event_get_param(e));
if(c == 'e')
{
struct player_ui_s *ui_s = (struct player_ui_s *)lv_event_get_user_data(e);
struct avi_list_param param;
lv_obj_t *list = lv_list_create(ui_s->now_ui);
lv_obj_set_size(list, LV_PCT(100), LV_PCT(100));
param.ui_s = ui_s;
param.ui = list;
param.group = lv_group_create();
lv_indev_set_group(indev_keypad, param.group);
//创建exit的控件
lv_obj_t *list_item = lv_list_add_btn(list, NULL, "exit");
list_item->user_data = (void*)list;
lv_group_add_obj(param.group, list_item);
lv_obj_add_event_cb(list_item, exit_show_filelist, LV_EVENT_SHORT_CLICKED, ui_s);
each_read_file(avi_list_show,(void*)&param);
lv_obj_add_event_cb(list, clear_list_group_ui, LV_EVENT_DELETE, param.group);
}
}
static uint32_t self_key(uint32_t val)
{
uint32_t key_ret = 0;
if(val > 0)
{
if((val&0xff) == KEY_EVENT_SUP)
{
switch(val>>8)
{
case AD_UP:
key_ret = LV_KEY_PREV;
break;
case AD_DOWN:
key_ret = LV_KEY_NEXT;
break;
case AD_LEFT:
key_ret = 'a';
break;
case AD_RIGHT:
key_ret = 'd';
break;
case AD_A:
key_ret = 'q';
break;
case AD_B:
key_ret = 'e';
break;
case AD_PRESS:
key_ret = LV_KEY_ENTER;
break;
break;
default:
break;
}
}
}
return key_ret;
}
//stream_self_cmd_func(jpg_de->parent_data_s->s,JPG_DECODE_ARG,(uint32_t)jpg_de->parent_data_s);
//这里要创建一个流,专门是控制avi播放流的,由jpg解码,发送到这里缓存起来,然后控制播放速度、暂停等
//这里使用lvgl的timer来代替workqueue
static uint32_t custom_get_data_len(void *data)
{
struct data_structure *data_s = (struct data_structure *)data;
return get_stream_real_data_len(data_s->data);
}
static void *custom_get_data(void *data)
{
struct data_structure *data_s = (struct data_structure *)data;
return get_stream_real_data(data_s->data);;
}
static uint32_t custom_get_data_time(void *data)
{
struct data_structure *data_s = (struct data_structure *)data;
return get_stream_data_timestamp(data_s->data);
}
static uint32_t forward_stream_cmd_func(stream *s,int opcode,uint32_t arg)
{
struct data_structure *data = (struct data_structure *)arg;
if(data->data)
{
struct data_structure *data_parent = (struct data_structure *)data->data;
return stream_self_cmd_func(data_parent->s,YUV_ARG,(uint32_t)data_parent);
}
return 0;
}
//这个是转发的流,只是添加一些必要信息,所以这里获取的data信息要更换
static const stream_ops_func forward_stream_ops =
{
.get_data_len = custom_get_data_len,
.get_data = custom_get_data,
.get_data_time = custom_get_data_time,
};
static int32_t player_work(struct os_work *work)
{
struct player_forward_stream_s *player_msg = (struct player_forward_stream_s *)work;
struct data_structure *data_s = NULL;
uint32_t time;
//static int count = 0;
if(!player_msg->s->enable)
{
goto player_work_get_data;
}
if(!(player_msg->play_status&PLAY_STATUS_STOP_PLAY))
{
goto player_work_get_data;
}
if(player_msg->data_s)
{
time = get_stream_data_timestamp(player_msg->data_s);
//先检查时间是否合适
if(player_msg->start_time + time > os_jiffies())
{
if(player_msg->magic != player_msg->data_s->magic)
{
free_data(player_msg->data_s);
player_msg->data_s = NULL;
}
goto player_work_end;
}
//再次检查是否符合需要播放(有可能是缓存或者快进导致进入这里)
if(player_msg->magic != player_msg->data_s->magic)
{
free_data(player_msg->data_s);
player_msg->data_s = NULL;
_os_printf("=");
goto player_work_end;
}
if(player_msg->play_status&PLAY_STATUS_PLAY_1FPS)
{
player_msg->play_status &= ~(PLAY_STATUS_STOP_PLAY|PLAY_STATUS_PLAY_1FPS);
}
//os_printf("time:%d\tstart_time:%d\tmagic:%d\n",time,player_msg->start_time,player_msg->data_s->magic);
player_msg->last_fps_play_time = time;
//判断一下时间是否需要播放
data_s = get_src_data_f(player_msg->s);
//准备填好显示、解码参数信息,然后发送到解码的模块去解码,主要如果没有成功要如何处理,这里没有考虑
if(data_s)
{
data_s->type = player_msg->data_s->type;
data_s->data = player_msg->data_s;
//os_printf("time:%d\ttype:%X\n",time,player_msg->data_s->type);
_os_printf("=");
//如果不是音频,就是视频,就显示
if(GET_DATA_TYPE1(data_s->type) != SOUND)
{
send_data_to_stream(data_s);
}
else
{
//如果是音频,看看是否需要暂停的,如果是,则不播放,因为可能是快进快退,这个时候是不需要去播音频
if(!(player_msg->play_status&PLAY_STATUS_STOP_PLAY))
{
force_del_data(data_s);
}
else
{
send_data_to_stream(data_s);
}
}
player_msg->data_s = NULL;
}
}
player_work_get_data:
if(!player_msg->data_s)
{
player_msg->data_s = recv_real_data(player_msg->s);
}
else
{
if(player_msg->magic != player_msg->data_s->magic)
{
free_data(player_msg->data_s);
player_msg->data_s = NULL;
goto player_work_end;
}
}
player_work_end:
os_run_work_delay(work, 1);
return 0;
}
static int opcode_func(stream *s,void *priv,int opcode)
{
int res = 0;
switch(opcode)
{
case STREAM_OPEN_ENTER:
break;
case STREAM_OPEN_EXIT:
{
struct player_forward_stream_s *msg = (struct player_forward_stream_s *)STREAM_ZALLOC(sizeof(struct player_forward_stream_s));
msg->s = s;
s->priv = msg;
msg->start_time = os_jiffies();
msg->data_s = NULL;
msg->magic = 0;
msg->play_status = (PLAY_STATUS_STOP_PLAY|PLAY_STATUS_PLAY_1FPS);
msg->last_fps_play_time = 0;
register_stream_self_cmd_func(s,forward_stream_cmd_func);
stream_data_dis_mem_custom(s);
OS_WORK_INIT(&msg->work, player_work, 0);
os_run_work_delay(&msg->work, 1);
//enable_stream(s,1);
}
break;
case STREAM_OPEN_FAIL:
break;
case STREAM_DATA_DIS:
{
struct data_structure *data = (struct data_structure *)priv;
data->ops = (stream_ops_func*)&forward_stream_ops;
}
break;
case STREAM_RECV_DATA_FINISH:
{
}
break;
//在发送到这个流的时候,进行数据包过滤
case STREAM_FILTER_DATA:
{
}
break;
//流接收后,数据包也要检查是否需要过滤或者是不是因为逻辑条件符合需要过滤
case STREAM_RECV_FILTER_DATA:
{
struct data_structure *data = (struct data_structure *)priv;
struct player_forward_stream_s *msg = (struct player_forward_stream_s *)s->priv;
//过滤一下没有用的数据包,只是接收play_time_start之后的数据包
if(!(msg->magic == data->magic))
{
res = 1;
}
}
break;
case STREAM_DATA_FREE:
{
struct data_structure *data = (struct data_structure *)priv;
if(data->data)
{
//因为是转发,所以这里移除的话是交给原来的方法移除
_os_printf("$");
free_data(data->data);
data->data = NULL;
}
}
break;
case STREAM_CLOSE_EXIT:
{
struct player_forward_stream_s *msg = (struct player_forward_stream_s *)s->priv;
os_work_cancle2(&msg->work, 1);
//清理不需要的资源
if(msg->data_s)
{
os_printf("msg->data_s:%X\n",msg->data_s);
free_data(msg->data_s);
}
}
break;
case STREAM_MARK_GC_END:
{
struct player_forward_stream_s *msg = (struct player_forward_stream_s *)s->priv;
if(msg)
{
STREAM_FREE(msg);
}
}
break;
default:
break;
}
return res;
}
//创建播放器的流,这个流主要实现的是控制速度转发作用,暂时控制的是视频
//如果要控制音频,需要计算时间来控制速度
static stream *player_stream(const char *name)
{
stream *s = open_stream_available(name,16,16,opcode_func,NULL);
return s;
}
static void player_locate_ctrl_ui(lv_event_t * e)
{
struct player_ui_s *ui_s = (struct player_ui_s *)lv_event_get_user_data(e);
struct player_forward_stream_s *player_msg = ui_s->player_s->priv;
int32_t c = *((int32_t *)lv_event_get_param(e));
//printf("c:%d\n",c);
switch(c)
{
//后退
case 'a':
{
os_work_cancle2(&player_msg->work, 1);
uint32_t now_play_time = stream_self_cmd_func(ui_s->avi_s,NEWAVI_PLAYER_LOCATE_REWIND_INDEX,player_msg->last_fps_play_time);
//重新开始播放,修改启动时间
player_msg->last_fps_play_time = now_play_time;
player_msg->start_time = os_jiffies() - now_play_time;
player_msg->magic = os_jiffies();
stream_self_cmd_func(ui_s->avi_s,NEWAVI_PLAYER_MAGIC,player_msg->magic);
player_msg->play_status = (PLAY_STATUS_STOP_PLAY|PLAY_STATUS_PLAY_1FPS);
OS_WORK_REINIT(&player_msg->work);
os_run_work_delay(&player_msg->work, 1);
}
break;
//前进
case 'd':
{
os_work_cancle2(&player_msg->work, 1);
uint32_t now_play_time = stream_self_cmd_func(ui_s->avi_s,NEWAVI_PLAYER_LOCATE_FORWARD_INDEX,player_msg->last_fps_play_time);
//重新开始播放,修改启动时间
player_msg->last_fps_play_time = now_play_time;
player_msg->start_time = os_jiffies() - now_play_time;
player_msg->magic = os_jiffies();
stream_self_cmd_func(ui_s->avi_s,NEWAVI_PLAYER_MAGIC,player_msg->magic);
player_msg->play_status = (PLAY_STATUS_STOP_PLAY|PLAY_STATUS_PLAY_1FPS);
OS_WORK_REINIT(&player_msg->work);
os_run_work_delay(&player_msg->work, 1);
}
break;
default:
break;
}
}
static void player_ctrl_ui(lv_event_t * e)
{
struct player_ui_s *ui_s = (struct player_ui_s *)lv_event_get_user_data(e);
struct player_forward_stream_s *player_msg = ui_s->player_s->priv;
os_printf("%s:%d\n",__FUNCTION__,__LINE__);
//根据播放状态设置
if(player_msg->play_status&PLAY_STATUS_STOP_PLAY)
{
player_msg->play_status &= (~PLAY_STATUS_STOP_PLAY);
}
else
{
//重新开始播放,修改启动时间
player_msg->start_time = os_jiffies() - player_msg->last_fps_play_time;
player_msg->play_status |= PLAY_STATUS_STOP_PLAY;
os_printf("################## stop time:%d\tlast_time:%d\n",player_msg->start_time,player_msg->last_fps_play_time);
}
}
static void exit_player_ui(lv_event_t * e)
{
struct player_ui_s *ui_s = (struct player_ui_s *)lv_event_get_user_data(e);
//struct player_forward_stream_s *player_msg = ui_s->player_s->priv;
int32_t c = *((int32_t *)lv_event_get_param(e));
if(c == 'q')
{
lv_timer_del(ui_s->timer);
struct player_ui_s *ui_s = (struct player_ui_s *)lv_event_get_user_data(e);
lv_indev_set_group(indev_keypad, ui_s->last_group);
lv_obj_clear_flag(ui_s->base_ui, LV_OBJ_FLAG_HIDDEN);
lv_group_del(ui_s->now_group);
ui_s->now_group = NULL;
close_stream(ui_s->other_s);
close_stream(ui_s->decode_s);
close_stream(ui_s->player_s);
close_stream(ui_s->avi_s);
ui_s->other_s = NULL;
ui_s->decode_s = NULL;
ui_s->player_s = NULL;
ui_s->avi_s = NULL;
lv_obj_del(ui_s->now_ui);
if(ui_s->play_name)
{
STREAM_FREE(ui_s->play_name);
ui_s->play_name = NULL;
}
set_lvgl_get_key_func(NULL);
os_printf("sram mem:%d\tpsram mem:%d\n",sysheap_freesize(&sram_heap),sysheap_freesize(&psram_heap));
print_custom_sram();
print_custom_psram();
}
}
static void player_ui_timer(lv_timer_t *t)
{
struct player_ui_s *ui_s = (struct player_ui_s *)t->user_data;
if(ui_s->avi_s)
{
//获取当前播放器的流结构体
struct player_forward_stream_s *player_msg = ui_s->player_s->priv;
//os_printf("play time:%d\tstart_time:%d\n",player_msg->last_fps_play_time,player_msg->start_time);
char show_time[64];
sprintf(show_time,"%02d:%02d",(player_msg->last_fps_play_time/1000)/60,(player_msg->last_fps_play_time/1000)%60);
lv_label_set_text(ui_s->label_time, show_time);
//判断文件已经播放完毕,如果需要重新播放,则重新建立播放文件
int status = stream_self_cmd_func(ui_s->avi_s,NEWAVI_PLAYER_STATUS,0);
if(status)
{
os_printf("status:%d\n",status);
}
}
}
static void enter_player_ui(lv_event_t * e)
{
set_lvgl_get_key_func(self_key);
struct player_ui_s *ui_s = (struct player_ui_s *)lv_event_get_user_data(e);
lv_obj_t *base_ui = ui_s->base_ui;
lv_obj_add_flag(base_ui, LV_OBJ_FLAG_HIDDEN);
lv_obj_t *ui = lv_obj_create(lv_scr_act());
ui_s->now_ui = ui;
lv_obj_add_style(ui, &g_style, 0);
lv_obj_set_size(ui, LV_PCT(100), LV_PCT(100));
#if 0
struct avi_list_param param;
lv_obj_t *list = lv_list_create(ui_s->now_ui);
lv_obj_set_size(list, LV_PCT(100), LV_PCT(100));
param.ui_s = ui_s;
param.ui = list;
param.group = NULL;
each_read_file("DCIM",avi_list_show,(void*)&param);
return;
#endif
//播放转发发送到P0,控制速度
ui_s->player_s = player_stream(S_NEWPLAYER);
//streamSrc_bind_streamDest(ui_s->player_s,R_VIDEO_P0);
streamSrc_bind_streamDest(ui_s->player_s,R_SPEAKER);
streamSrc_bind_streamDest(ui_s->player_s,SR_OTHER_JPG);
enable_stream(ui_s->player_s,1);
//SR_OTHER_JPG接收数据,然后发送到decode
ui_s->other_s = other_jpg_stream_not_bind(SR_OTHER_JPG,320,240,320,240,YUV_P0);
streamSrc_bind_streamDest(ui_s->other_s,S_JPG_DECODE);
enable_stream(ui_s->other_s,1);
//decode发送到S_NEWPLAYER控制速度后,转发到P0
ui_s->decode_s = jpg_decode_stream_not_bind(S_JPG_DECODE);
streamSrc_bind_streamDest(ui_s->decode_s,R_VIDEO_P0);
//streamSrc_bind_streamDest(ui_s->decode_s,S_NEWPLAYER);
enable_stream(ui_s->decode_s,1);
#if 0
ui_s->avi_s = newavi_player2_init(S_NEWAVI,"0:DCIM/AVI1.avi");
if(ui_s->avi_s)
{
streamSrc_bind_streamDest(ui_s->avi_s,S_NEWPLAYER);
//streamSrc_bind_streamDest(ui_s->avi_s,SR_OTHER_JPG);
//streamSrc_bind_streamDest(ui_s->avi_s,R_SPEAKER);
enable_stream(ui_s->avi_s,1);
}
#endif
//创建lvgl的timer,用于获取播放的时间
ui_s->label_time = lv_label_create(ui);
lv_label_set_text(ui_s->label_time, "00:00");
lv_obj_align(ui_s->label_time,LV_ALIGN_TOP_MID,0,0);
ui_s->timer = lv_timer_create(player_ui_timer, 100, (void*)ui_s);
lv_group_t *group;
group = lv_group_create();
lv_indev_set_group(indev_keypad, group);
lv_group_add_obj(group, ui);
ui_s->now_group = group;
lv_obj_add_event_cb(ui, exit_player_ui, LV_EVENT_KEY, ui_s);
//控制暂停、播放
lv_obj_add_event_cb(ui, player_ctrl_ui, LV_EVENT_SHORT_CLICKED, ui_s);
//快进快退,一次尝试快进5秒,一次尝试快退5秒
lv_obj_add_event_cb(ui, player_locate_ctrl_ui, LV_EVENT_KEY, ui_s);
//弹出菜单栏,用于切换分辨率
lv_obj_add_event_cb(ui, show_filelist, LV_EVENT_KEY, ui_s);
}
lv_obj_t *player_ui(lv_group_t *group,lv_obj_t *base_ui)
{
struct player_ui_s *ui_s = (struct player_ui_s*)STREAM_LIBC_ZALLOC(sizeof(struct player_ui_s));
ui_s->last_group = group;
ui_s->base_ui = base_ui;
ui_s->play_name = NULL;
lv_obj_t *btn = lv_list_add_btn(base_ui, NULL, "player1");
lv_group_add_obj(group, btn);
lv_obj_add_event_cb(btn, enter_player_ui, LV_EVENT_SHORT_CLICKED, ui_s);
return btn;
}
+123
View File
@@ -0,0 +1,123 @@
/*****************************************************************************************************************************************************************
这个主要是实现通过一个dvp,通过编码再解码达到画中画效果
S_PREVIEW_SCALE3 ----> R_VIDEO_P0(320x240)
(scale3) | (lcd_video_p0)
|
----> R_YUV_TO_JPG(启动jpg0,video_app,然后默认绑定了SR_OTHER_JPG) ---->SR_OTHER_JPG ---->S_JPG_DECODE ---->R_VIDEO_P1(160x120)
(借用prc寄存器,启动jpg0,打开video_app的流) (接收jpg,配置解码参数) (jpg1解码) (lcd_video_p1)
(使用yuv:320x240,编码成320x240) (jpg0:320x240) (yuv:160x120)
******************************************************************************************************************************************************************* */
#include "lvgl/lvgl.h"
#include "lvgl_ui.h"
#include "osal/string.h"
#include "stream_frame.h"
#include "other_jpg_show/other_jpg_show_stream.h"
#include "custom_mem/custom_mem.h"
//data申请空间函数
#define STREAM_MALLOC custom_malloc_psram
#define STREAM_FREE custom_free_psram
#define STREAM_ZALLOC custom_zalloc_psram
//结构体申请空间函数
#define STREAM_LIBC_MALLOC custom_malloc
#define STREAM_LIBC_FREE custom_free
#define STREAM_LIBC_ZALLOC custom_zalloc
extern lv_indev_t * indev_keypad;
extern lv_style_t g_style;
struct preview_pip_ui_s
{
lv_group_t *last_group;
lv_obj_t *base_ui;
lv_group_t *now_group;
lv_obj_t *now_ui;
//这个是需要的流,但命名不一定对应,有可能通过中间流进行中转实现
stream *scale3_s;
stream *yuv_jpg_s;
stream *other_jpg_s;
stream *decode_s;
stream *jpg_s;
};
static void exit_preview_dvp_pip_ui(lv_event_t * e)
{
struct preview_pip_ui_s *ui_s = (struct preview_pip_ui_s *)lv_event_get_user_data(e);
lv_indev_set_group(indev_keypad, ui_s->last_group);
lv_obj_clear_flag(ui_s->base_ui, LV_OBJ_FLAG_HIDDEN);
lv_group_del(ui_s->now_group);
ui_s->now_group = NULL;
close_stream(ui_s->scale3_s);
close_stream(ui_s->yuv_jpg_s);
close_stream(ui_s->jpg_s);
close_stream(ui_s->other_jpg_s);
close_stream(ui_s->decode_s);
lv_obj_del(ui_s->now_ui);
}
//进入预览的ui,那么就要创建新的ui去显示预览图了
static void enter_preview_dvp_pip_ui(lv_event_t * e)
{
struct preview_pip_ui_s *ui_s = (struct preview_pip_ui_s *)lv_event_get_user_data(e);
lv_obj_add_flag(ui_s->base_ui, LV_OBJ_FLAG_HIDDEN);
lv_obj_t *ui = lv_obj_create(lv_scr_act());
ui_s->now_ui = ui;
lv_obj_add_style(ui, &g_style, 0);
lv_obj_set_size(ui, LV_PCT(100), LV_PCT(100));
//scale3 从640x480拉伸到320x240
ui_s->scale3_s = scale3_stream_not_bind(S_PREVIEW_SCALE3,640,480,320,240,YUV_P0);
//绑定流到Video P0显示
streamSrc_bind_streamDest(ui_s->scale3_s,R_VIDEO_P0);
//给到yuv_to_jpg编码
streamSrc_bind_streamDest(ui_s->scale3_s,R_YUV_TO_JPG);
enable_stream(ui_s->scale3_s,1);
ui_s->decode_s = jpg_decode_stream_not_bind(S_JPG_DECODE);
//将解码的数据推送到Video P1
streamSrc_bind_streamDest(ui_s->decode_s,R_VIDEO_P1);
enable_stream(ui_s->decode_s,1);
//先创建jpg_s,然后绑定流(jpg给到谁用),最后使能
ui_s->jpg_s = new_video_app_stream(S_JPEG);
//给到图传测试使用
streamSrc_bind_streamDest(ui_s->jpg_s,SR_OTHER_JPG);
enable_stream(ui_s->jpg_s,1);
//scale3的数据发送到R_YUV_TO_JPG,R_YUV_TO_JPG接收到yuv后,启动jpg0编码
ui_s->yuv_jpg_s = prc_stream(R_YUV_TO_JPG,ui_s->jpg_s);
enable_stream(ui_s->yuv_jpg_s,1);
//从video_app那边接收到jpg数据,然后配置解码参数(160x120),最后给到解码模块
ui_s->other_jpg_s = other_jpg_stream_not_bind(SR_OTHER_JPG,160,120,160,120,YUV_P1);
//将other_jpg的数据给到S_JPG_DECODE进行编码
streamSrc_bind_streamDest(ui_s->other_jpg_s,S_JPG_DECODE);
enable_stream(ui_s->other_jpg_s,1);
lv_group_t *group;
group = lv_group_create();
lv_indev_set_group(indev_keypad, group);
lv_group_add_obj(group, ui);
ui_s->now_group = group;
lv_obj_add_event_cb(ui, exit_preview_dvp_pip_ui, LV_EVENT_PRESSED, ui_s);
}
lv_obj_t *preview_dvp_pip_ui(lv_group_t *group,lv_obj_t *base_ui)
{
struct preview_pip_ui_s *ui_s = (struct preview_pip_ui_s*)STREAM_LIBC_ZALLOC(sizeof(struct preview_pip_ui_s));
ui_s->last_group = group;
ui_s->base_ui = base_ui;
lv_obj_t *btn = lv_list_add_btn(base_ui, NULL, "preview_dvp_pip");
lv_group_add_obj(group, btn);
lv_obj_add_event_cb(btn, enter_preview_dvp_pip_ui, LV_EVENT_PRESSED, ui_s);
return btn;
}
+109
View File
@@ -0,0 +1,109 @@
/***********************************************************************************************************
这个主要是dvp+uvc实现画中画效果
S_PREVIEW_SCALE3---->R_VIDEO_P1(320x240)
(scale3) ---->(lcd_video_p1)
S_USB_JPEG_PSRAM ----> SR_OTHER_JPG_USB2 ----> S_JPG_DECODE ----> R_VIDEO_P0(160x120)
(uvc) (uvc的jpg,配置解码size:160x120) (解码成yuv:160x120) (lcd_video_p0)
********************************************************************************************************** */
#include "lvgl/lvgl.h"
#include "lvgl_ui.h"
#include "osal/string.h"
#include "stream_frame.h"
#include "other_jpg_show/other_jpg_show_stream.h"
#include "custom_mem/custom_mem.h"
//data申请空间函数
#define STREAM_MALLOC custom_malloc_psram
#define STREAM_FREE custom_free_psram
#define STREAM_ZALLOC custom_zalloc_psram
//结构体申请空间函数
#define STREAM_LIBC_MALLOC custom_malloc
#define STREAM_LIBC_FREE custom_free
#define STREAM_LIBC_ZALLOC custom_zalloc
extern lv_indev_t * indev_keypad;
extern lv_style_t g_style;
struct preview_usb_s
{
lv_group_t *last_group;
lv_obj_t *base_ui;
lv_group_t *now_group;
lv_obj_t *now_ui;
//这个是需要的流,但命名不一定对应,有可能通过中间流进行中转实现
stream *scale3_s;
stream *decode_s;
stream *USB_P0_jpg_s;
};
static void exit_preview_dvp_usb_ui(lv_event_t * e)
{
struct preview_usb_s *ui_s = (struct preview_usb_s *)lv_event_get_user_data(e);
lv_indev_set_group(indev_keypad, ui_s->last_group);
lv_obj_clear_flag(ui_s->base_ui, LV_OBJ_FLAG_HIDDEN);
lv_group_del(ui_s->now_group);
ui_s->now_group = NULL;
close_stream(ui_s->scale3_s);
close_stream(ui_s->decode_s);
close_stream(ui_s->USB_P0_jpg_s);
lv_obj_del(ui_s->now_ui);
}
//进入预览的ui,那么就要创建新的ui去显示预览图了
static void enter_preview_dvp_usb_ui(lv_event_t * e)
{
struct preview_usb_s *ui_s = (struct preview_usb_s *)lv_event_get_user_data(e);
lv_obj_add_flag(ui_s->base_ui, LV_OBJ_FLAG_HIDDEN);
lv_obj_t *ui = lv_obj_create(lv_scr_act());
ui_s->now_ui = ui;
lv_obj_add_style(ui, &g_style, 0);
lv_obj_set_size(ui, LV_PCT(100), LV_PCT(100));
ui_s->scale3_s = scale3_stream_not_bind(S_PREVIEW_SCALE3,640,480,160,120,YUV_P1);
//绑定流到Video P1显示
streamSrc_bind_streamDest(ui_s->scale3_s,R_VIDEO_P1);
enable_stream(ui_s->scale3_s,1);
ui_s->decode_s = jpg_decode_stream_not_bind(S_JPG_DECODE);
//将解码的数据推送到Video P0
streamSrc_bind_streamDest(ui_s->decode_s,R_VIDEO_P0);
enable_stream(ui_s->decode_s,1);
//接收UVC的jpg,配置解码需要的参数(320x240),最后给到解码模块
ui_s->USB_P0_jpg_s = other_jpg_stream_not_bind(SR_OTHER_JPG_USB2,320,240,320,240,YUV_P0);
//将other_jpg的数据给到S_JPG_DECODE进行编码
streamSrc_bind_streamDest(ui_s->USB_P0_jpg_s,S_JPG_DECODE);
enable_stream(ui_s->USB_P0_jpg_s,1);
lv_group_t *group;
group = lv_group_create();
lv_indev_set_group(indev_keypad, group);
lv_group_add_obj(group, ui);
ui_s->now_group = group;
lv_obj_add_event_cb(ui, exit_preview_dvp_usb_ui, LV_EVENT_PRESSED, ui_s);
}
lv_obj_t *preview_dvp_usb_ui(lv_group_t *group,lv_obj_t *base_ui)
{
struct preview_usb_s *ui_s = (struct preview_usb_s*)STREAM_LIBC_ZALLOC(sizeof(struct preview_usb_s));
ui_s->last_group = group;
ui_s->base_ui = base_ui;
lv_obj_t *btn = lv_list_add_btn(base_ui, NULL, "preview_dvp_usb");
lv_group_add_obj(group, btn);
lv_obj_add_event_cb(btn, enter_preview_dvp_usb_ui, LV_EVENT_PRESSED, ui_s);
return btn;
}
+306
View File
@@ -0,0 +1,306 @@
/***************************************************************************************
***************************************************************************************/
#include "lvgl/lvgl.h"
#include "lvgl_ui.h"
#include "osal/string.h"
#include "stream_frame.h"
#include "keyWork.h"
#include "keyScan.h"
#include "fatfs/osal_file.h"
#include "custom_mem/custom_mem.h"
//data申请空间函数
#define STREAM_MALLOC custom_malloc_psram
#define STREAM_FREE custom_free_psram
#define STREAM_ZALLOC custom_zalloc_psram
//结构体申请空间函数
#define STREAM_LIBC_MALLOC custom_malloc
#define STREAM_LIBC_FREE custom_free
#define STREAM_LIBC_ZALLOC custom_zalloc
#define LV_OBJ_TAKEPHOTO_FLAG LV_OBJ_FLAG_USER_1
extern lv_indev_t * indev_keypad;
extern lv_style_t g_style;
struct preview_encode_takephoto_960P_ui_s
{
lv_group_t *last_group;
lv_obj_t *base_ui;
lv_group_t *now_group;
lv_obj_t *now_ui;
lv_timer_t *timer;
stream *s;
stream *scale1_stream;
stream *jpg0_stream;
stream *takephoto_s;
};
static uint32_t self_key(uint32_t val)
{
uint32_t key_ret = 0;
if(val > 0)
{
if((val&0xff) == KEY_EVENT_SUP)
{
switch(val>>8)
{
case AD_UP:
key_ret = 'q';
break;
case AD_DOWN:
key_ret = 's';
break;
case AD_LEFT:
key_ret = 'a';
break;
case AD_RIGHT:
key_ret = 'd';
break;
case AD_PRESS:
key_ret = LV_KEY_ENTER;
break;
default:
break;
}
}
else if((val&0xff) == KEY_EVENT_LUP)
{
switch(val>>8)
{
case AD_PRESS:
key_ret = 'e';
break;
default:
break;
}
}
}
return key_ret;
}
//生成一个流,专门接收图片,用于拍照的,拍照之前可以将缓冲区的删除,这样可以保证得到最新的图片
//要考虑一些问题,如果拍照放在workqueue,要考虑写卡时间是否影响workqueue
//这里尝试使用lvgl的timer事件去保存(影响lvgl,如果需要更加好,可能要创建任务去保存)
static int opcode_func(stream *s,void *priv,int opcode)
{
int res = 0;
switch(opcode)
{
case STREAM_OPEN_ENTER:
break;
case STREAM_OPEN_EXIT:
{
}
break;
case STREAM_OPEN_FAIL:
break;
case STREAM_DATA_DIS:
{
}
break;
case STREAM_RECV_DATA_FINISH:
{
}
break;
//在发送到这个流的时候,进行数据包过滤
case STREAM_FILTER_DATA:
{
}
break;
//流接收后,数据包也要检查是否需要过滤或者是不是因为逻辑条件符合需要过滤
case STREAM_RECV_FILTER_DATA:
{
}
break;
case STREAM_DATA_FREE:
{
}
break;
case STREAM_CLOSE_EXIT:
{
}
break;
case STREAM_MARK_GC_END:
{
}
break;
default:
break;
}
return res;
}
static stream *takephoto_stream(const char *name)
{
//设置接收1,是为了不要接收太多的图片,因为是拍照,需要保持实时性
//如果接收过多,如果不处理,会导致源头没有空间产生新的图片
//如果要结合录像,则需要在应用层去处理(实际录像时可以创建另一个独立的流)
stream *s = open_stream_available(name,0,1,opcode_func,NULL);
return s;
}
extern int no_frame_record_video_psram(void *fp,void *d,int flen);
static void takephoto_timer(lv_timer_t *t)
{
struct preview_encode_takephoto_960P_ui_s *ui_s = (struct preview_encode_takephoto_960P_ui_s *)t->user_data;
struct data_structure *data_s;
//看看对应的流有没有图片,如果有,则保存
data_s = recv_real_data(ui_s->takephoto_s);
if(data_s)
{
enable_stream(ui_s->takephoto_s,0);
char filename[64];
sprintf(filename,"0:%08d.jpg",(uint32_t)os_jiffies());
void *fp = osal_fopen(filename,"wb");
if(fp)
{
no_frame_record_video_psram(fp,data_s,get_stream_real_data_len(data_s));
osal_fclose(fp);
}
else
{
os_printf("takephoto fail,filename:%s\n",filename);
}
//保存图片
free_data(data_s);
while(data_s)
{
data_s = recv_real_data(ui_s->takephoto_s);
if(data_s)
{
free_data(data_s);
}
}
os_printf("takephoto success\n");
lv_obj_clear_flag(ui_s->now_ui, LV_OBJ_TAKEPHOTO_FLAG);
ui_s->timer = NULL;
lv_timer_del(t);
}
}
//使能拍照
static void encode_takephoto_ui(lv_event_t * e)
{
struct preview_encode_takephoto_960P_ui_s *ui_s = (struct preview_encode_takephoto_960P_ui_s *)lv_event_get_user_data(e);
stream *s = ui_s->takephoto_s;
if(!lv_obj_has_flag(ui_s->now_ui,LV_OBJ_TAKEPHOTO_FLAG))
{
lv_obj_add_flag(ui_s->now_ui, LV_OBJ_TAKEPHOTO_FLAG);
enable_stream(s,1);
//启动timer,10ms检查一次
ui_s->timer = lv_timer_create(takephoto_timer, 10, (void*)ui_s);
}
else
{
//已经在拍照了
os_printf("%s already running\n",__FUNCTION__);
}
}
static void exit_preview_encode_960P_ui(lv_event_t * e)
{
int32_t c = *((int32_t *)lv_event_get_param(e));
if(c == 'q')
{
struct preview_encode_takephoto_960P_ui_s *ui_s = (struct preview_encode_takephoto_960P_ui_s *)lv_event_get_user_data(e);
lv_indev_set_group(indev_keypad, ui_s->last_group);
lv_obj_clear_flag(ui_s->base_ui, LV_OBJ_FLAG_HIDDEN);
lv_group_del(ui_s->now_group);
ui_s->now_group = NULL;
close_stream(ui_s->s);
close_stream(ui_s->scale1_stream);
close_stream(ui_s->jpg0_stream);
close_stream(ui_s->takephoto_s);
lv_obj_del(ui_s->now_ui);
set_lvgl_get_key_func(NULL);
}
}
//进入预览的ui,那么就要创建新的ui去显示预览图了
static void enter_preview_encode_960P_ui(lv_event_t * e)
{
set_lvgl_get_key_func(self_key);
struct preview_encode_takephoto_960P_ui_s *ui_s = (struct preview_encode_takephoto_960P_ui_s *)lv_event_get_user_data(e);
lv_obj_add_flag(ui_s->base_ui, LV_OBJ_FLAG_HIDDEN);
lv_obj_t *ui = lv_obj_create(lv_scr_act());
ui_s->now_ui = ui;
lv_obj_add_style(ui, &g_style, 0);
lv_obj_set_size(ui, LV_PCT(100), LV_PCT(100));
ui_s->s = scale3_stream_not_bind(S_PREVIEW_ENCODE_QVGA,640,480,320,240,YUV_P0);
//绑定流到Video P0显示
streamSrc_bind_streamDest(ui_s->s,R_VIDEO_P0);
enable_stream(ui_s->s,1);
//打开scale1
ui_s->scale1_stream = scale1_stream_not_bind(S_SCALE1_STREAM,640,480,1280,960);
os_sleep_ms(10);
ui_s->jpg0_stream = new_video_app_stream_with_mode(R_JPEG_DEMO,2,1280,960);
streamSrc_bind_streamDest(ui_s->jpg0_stream,R_LVGL_TAKEPHOTO);
streamSrc_bind_streamDest(ui_s->jpg0_stream,R_RTP_JPEG);
enable_stream(ui_s->jpg0_stream,1);
ui_s->takephoto_s = takephoto_stream(R_LVGL_TAKEPHOTO);
lv_group_t *group;
group = lv_group_create();
lv_indev_set_group(indev_keypad, group);
lv_group_add_obj(group, ui);
ui_s->now_group = group;
lv_obj_add_event_cb(ui, exit_preview_encode_960P_ui, LV_EVENT_KEY, ui_s);
//拍照的按键事件
lv_obj_add_event_cb(ui, encode_takephoto_ui, LV_EVENT_PRESSED, ui_s);
}
lv_obj_t *preview_encode_960P_ui(lv_group_t *group,lv_obj_t *base_ui)
{
struct preview_encode_takephoto_960P_ui_s *ui_s = (struct preview_encode_takephoto_960P_ui_s*)STREAM_LIBC_ZALLOC(sizeof(struct preview_encode_takephoto_960P_ui_s));
ui_s->last_group = group;
ui_s->base_ui = base_ui;
lv_obj_t *btn = lv_list_add_btn(base_ui, NULL, "preview_encode_960P");
lv_group_add_obj(group, btn);
lv_obj_add_event_cb(btn, enter_preview_encode_960P_ui, LV_EVENT_SHORT_CLICKED, ui_s);
return btn;
}
+100
View File
@@ -0,0 +1,100 @@
/***************************************************************************************
S_PREVIEW_SCALE3---->R_VIDEO_P0(160x120)
(scale3) ---->(lcd_video_p0)
***************************************************************************************/
#include "lvgl/lvgl.h"
#include "lvgl_ui.h"
#include "osal/string.h"
#include "stream_frame.h"
#include "custom_mem/custom_mem.h"
//data申请空间函数
#define STREAM_MALLOC custom_malloc_psram
#define STREAM_FREE custom_free_psram
#define STREAM_ZALLOC custom_zalloc_psram
//结构体申请空间函数
#define STREAM_LIBC_MALLOC custom_malloc
#define STREAM_LIBC_FREE custom_free
#define STREAM_LIBC_ZALLOC custom_zalloc
extern lv_indev_t * indev_keypad;
extern lv_style_t g_style;
struct preview_encode_QVGA_ui_s
{
lv_group_t *last_group;
lv_obj_t *base_ui;
lv_group_t *now_group;
lv_obj_t *now_ui;
stream *s;
stream *yuv_jpg_s;
stream *jpg_s;
};
static void exit_preview_encode_ui(lv_event_t * e)
{
struct preview_encode_QVGA_ui_s *ui_s = (struct preview_encode_QVGA_ui_s *)lv_event_get_user_data(e);
lv_indev_set_group(indev_keypad, ui_s->last_group);
lv_obj_clear_flag(ui_s->base_ui, LV_OBJ_FLAG_HIDDEN);
lv_group_del(ui_s->now_group);
ui_s->now_group = NULL;
close_stream(ui_s->s);
close_stream(ui_s->yuv_jpg_s);
close_stream(ui_s->jpg_s);
lv_obj_del(ui_s->now_ui);
}
//进入预览的ui,那么就要创建新的ui去显示预览图了
static void enter_preview_encode_ui(lv_event_t * e)
{
struct preview_encode_QVGA_ui_s *ui_s = (struct preview_encode_QVGA_ui_s *)lv_event_get_user_data(e);
lv_obj_add_flag(ui_s->base_ui, LV_OBJ_FLAG_HIDDEN);
lv_obj_t *ui = lv_obj_create(lv_scr_act());
ui_s->now_ui = ui;
lv_obj_add_style(ui, &g_style, 0);
lv_obj_set_size(ui, LV_PCT(100), LV_PCT(100));
ui_s->s = scale3_stream_not_bind(S_PREVIEW_ENCODE_QQVGA,640,480,160,120,YUV_P0);
//绑定流到Video P0显示
streamSrc_bind_streamDest(ui_s->s,R_VIDEO_P0);
//绑定流到YUV_TO_JPG,意思就是将160x120数据给到yuv_to_jpg,然后yuv_to_jpg启动jpg0编码,得到160x120的jpg数据
streamSrc_bind_streamDest(ui_s->s,R_YUV_TO_JPG);
enable_stream(ui_s->s,1);
//先创建jpg_s,然后绑定流(jpg给到谁用),最后使能
ui_s->jpg_s = new_video_app_stream(S_JPEG);
//给到图传测试使用
streamSrc_bind_streamDest(ui_s->jpg_s,R_RTP_JPEG);
enable_stream(ui_s->jpg_s,1);
ui_s->yuv_jpg_s = prc_stream(R_YUV_TO_JPG,ui_s->jpg_s);
enable_stream(ui_s->yuv_jpg_s,1);
lv_group_t *group;
group = lv_group_create();
lv_indev_set_group(indev_keypad, group);
lv_group_add_obj(group, ui);
ui_s->now_group = group;
lv_obj_add_event_cb(ui, exit_preview_encode_ui, LV_EVENT_PRESSED, ui_s);
}
lv_obj_t *preview_encode_QQVGA_ui(lv_group_t *group,lv_obj_t *base_ui)
{
struct preview_encode_QVGA_ui_s *ui_s = (struct preview_encode_QVGA_ui_s*)STREAM_LIBC_ZALLOC(sizeof(struct preview_encode_QVGA_ui_s));
ui_s->last_group = group;
ui_s->base_ui = base_ui;
lv_obj_t *btn = lv_list_add_btn(base_ui, NULL, "preview_encode_QQVGA");
lv_group_add_obj(group, btn);
lv_obj_add_event_cb(btn, enter_preview_encode_ui, LV_EVENT_PRESSED, ui_s);
return btn;
}
+559
View File
@@ -0,0 +1,559 @@
/***************************************************************************************
***************************************************************************************/
#include "lvgl/lvgl.h"
#include "lvgl_ui.h"
#include "osal/string.h"
#include "stream_frame.h"
#include "keyWork.h"
#include "keyScan.h"
#include "custom_mem/custom_mem.h"
#include "osal_file.h"
#define PHOTO_DIR "photo"
extern stream *avi_save_stream(const char *manage_stream_name,const char *video_name,const char *audio_name,uint16_t video_cache_num,uint16_t audio_cache_num,uint16_t fps,uint16_t frq);
//data申请空间函数
#define STREAM_MALLOC custom_malloc_psram
#define STREAM_FREE custom_free_psram
#define STREAM_ZALLOC custom_zalloc_psram
//结构体申请空间函数
#define STREAM_LIBC_MALLOC custom_malloc
#define STREAM_LIBC_FREE custom_free
#define STREAM_LIBC_ZALLOC custom_zalloc
#define LV_OBJ_TAKEPHOTO_FLAG LV_OBJ_FLAG_USER_1
#define LV_OBJ_RECORD_FLAG LV_OBJ_FLAG_USER_2
extern void set_lvgl_get_key_func(void *func);
extern lv_indev_t * indev_keypad;
extern lv_style_t g_style;
struct preview_encode_takephoto_selct_ui_s
{
lv_group_t *last_group;
lv_obj_t *base_ui;
lv_group_t *now_group;
lv_obj_t *now_ui;
lv_obj_t *status_obj;
lv_timer_t *timer;
stream *s;
stream *scale1_stream;
stream *jpg0_stream;
stream *takephoto_s;
stream *avi_save_s;
stream *audio_s;
uint8_t is_takephoto;
};
static uint32_t self_key(uint32_t val)
{
uint32_t key_ret = 0;
if(val > 0)
{
if((val&0xff) == KEY_EVENT_SUP)
{
switch(val>>8)
{
case AD_UP:
key_ret = LV_KEY_PREV;
break;
case AD_DOWN:
key_ret = LV_KEY_NEXT;
break;
case AD_LEFT:
key_ret = 'a';
break;
case AD_RIGHT:
key_ret = 'd';
break;
case AD_PRESS:
key_ret = LV_KEY_ENTER;
break;
case AD_A:
key_ret = 'q';
break;
default:
break;
}
}
else if((val&0xff) == KEY_EVENT_LUP)
{
switch(val>>8)
{
default:
break;
}
}
}
return key_ret;
}
//生成一个流,专门接收图片,用于拍照的,拍照之前可以将缓冲区的删除,这样可以保证得到最新的图片
//要考虑一些问题,如果拍照放在workqueue,要考虑写卡时间是否影响workqueue
//这里尝试使用lvgl的timer事件去保存(影响lvgl,如果需要更加好,可能要创建任务去保存)
static int opcode_func(stream *s,void *priv,int opcode)
{
int res = 0;
switch(opcode)
{
case STREAM_OPEN_ENTER:
break;
case STREAM_OPEN_EXIT:
{
}
break;
case STREAM_OPEN_FAIL:
break;
case STREAM_DATA_DIS:
{
}
break;
case STREAM_RECV_DATA_FINISH:
{
}
break;
//在发送到这个流的时候,进行数据包过滤
case STREAM_FILTER_DATA:
{
}
break;
//流接收后,数据包也要检查是否需要过滤或者是不是因为逻辑条件符合需要过滤
case STREAM_RECV_FILTER_DATA:
{
}
break;
case STREAM_DATA_FREE:
{
}
break;
case STREAM_CLOSE_EXIT:
{
}
break;
case STREAM_MARK_GC_END:
{
}
break;
default:
break;
}
return res;
}
static stream *takephoto_stream(const char *name)
{
//设置接收1,是为了不要接收太多的图片,因为是拍照,需要保持实时性
//如果接收过多,如果不处理,会导致源头没有空间产生新的图片
//如果要结合录像,则需要在应用层去处理(实际录像时可以创建另一个独立的流)
stream *s = open_stream_available(name,0,1,opcode_func,NULL);
return s;
}
extern int no_frame_record_video_psram(void *fp,void *d,int flen);
static void takephoto_timer(lv_timer_t *t)
{
struct preview_encode_takephoto_selct_ui_s *ui_s = (struct preview_encode_takephoto_selct_ui_s *)t->user_data;
struct data_structure *data_s;
//看看对应的流有没有图片,如果有,则保存
data_s = recv_real_data(ui_s->takephoto_s);
if(data_s)
{
enable_stream(ui_s->takephoto_s,0);
char filename[64];
sprintf(filename,"0:%s/%08d.jpg",PHOTO_DIR,(uint32_t)os_jiffies());
void *fp = osal_fopen(filename,"wb");
if(fp)
{
no_frame_record_video_psram(fp,data_s,get_stream_real_data_len(data_s));
osal_fclose(fp);
}
else
{
os_printf("takephoto fail,filename:%s\n",filename);
}
//保存图片
free_data(data_s);
while(data_s)
{
data_s = recv_real_data(ui_s->takephoto_s);
if(data_s)
{
free_data(data_s);
}
}
os_printf("takephoto success\n");
lv_obj_clear_flag(ui_s->now_ui, LV_OBJ_TAKEPHOTO_FLAG);
ui_s->timer = NULL;
lv_timer_del(t);
}
}
//使能拍照
static void encode_takephoto_ui(lv_event_t * e)
{
struct preview_encode_takephoto_selct_ui_s *ui_s = (struct preview_encode_takephoto_selct_ui_s *)lv_event_get_user_data(e);
stream *s = ui_s->takephoto_s;
if(ui_s->is_takephoto)
{
if(!lv_obj_has_flag(ui_s->now_ui,LV_OBJ_TAKEPHOTO_FLAG))
{
lv_obj_add_flag(ui_s->now_ui, LV_OBJ_TAKEPHOTO_FLAG);
enable_stream(s,1);
//启动timer,10ms检查一次
ui_s->timer = lv_timer_create(takephoto_timer, 10, (void*)ui_s);
}
else
{
//已经在拍照了
os_printf("%s already running\n",__FUNCTION__);
}
}
else
{
if(!lv_obj_has_flag(ui_s->now_ui,LV_OBJ_RECORD_FLAG))
{
if(ui_s->audio_s)
{
ui_s->avi_save_s = avi_save_stream(MANAGE_STREAM_NAME,R_AVI_SAVE_VIDEO,R_AVI_SAVE_AUDIO,2,8,30,8000);
}
else
{
ui_s->avi_save_s = avi_save_stream(MANAGE_STREAM_NAME,R_AVI_SAVE_VIDEO,NULL,2,0,30,0);
}
if(ui_s->avi_save_s)
{
lv_obj_add_flag(ui_s->now_ui, LV_OBJ_RECORD_FLAG);
}
}
else
{
close_stream(ui_s->avi_save_s);
ui_s->avi_save_s = NULL;
}
}
}
static void exit_preview_encode_select_ui(lv_event_t * e)
{
int32_t c = *((int32_t *)lv_event_get_param(e));
if(c == 'q')
{
struct preview_encode_takephoto_selct_ui_s *ui_s = (struct preview_encode_takephoto_selct_ui_s *)lv_event_get_user_data(e);
lv_indev_set_group(indev_keypad, ui_s->last_group);
lv_obj_clear_flag(ui_s->base_ui, LV_OBJ_FLAG_HIDDEN);
lv_group_del(ui_s->now_group);
ui_s->now_group = NULL;
close_stream(ui_s->avi_save_s);
close_stream(ui_s->s);
close_stream(ui_s->scale1_stream);
close_stream(ui_s->jpg0_stream);
close_stream(ui_s->takephoto_s);
close_stream(ui_s->audio_s); //因为外部打开的,所以实际这里关闭不会真的关闭,需要所有地方都关闭才会真的关闭的
lv_obj_del(ui_s->now_ui);
set_lvgl_get_key_func(NULL);
}
}
static void exit_menu_select_ui(lv_event_t * e)
{
struct preview_encode_takephoto_selct_ui_s *ui_s = (struct preview_encode_takephoto_selct_ui_s *)lv_event_get_user_data(e);
lv_obj_t *list_item = lv_event_get_current_target(e);
os_printf("list_item:%X\n",list_item);
if(ui_s->now_group)
{
lv_indev_set_group(indev_keypad, ui_s->now_group);
}
if(list_item->user_data)
{
//由于是子控件回调函数需要删除父控件,所以需要用到异步删除,否则删除内部链表会有异常
lv_obj_del_async(list_item->user_data);
}
}
static void clear_menu_select_ui(lv_event_t * e)
{
os_printf("%s:%d\n",__FUNCTION__,__LINE__);
lv_group_t *group = (lv_group_t *)lv_event_get_user_data(e);
os_printf("group:%X\n",group);
if(group)
{
lv_group_del(group);
}
}
static void DPI_640x480_select_ui(lv_event_t * e)
{
struct preview_encode_takephoto_selct_ui_s *ui_s = (struct preview_encode_takephoto_selct_ui_s *)lv_event_get_user_data(e);
stream *jpeg_s = ui_s->jpg0_stream;
stream *scale1_stream = ui_s->scale1_stream;
//scale1先停止
stream_self_cmd_func(scale1_stream,STREAM_STOP_CMD,0);
//先停止jpg?
stream_self_cmd_func(jpeg_s,STREAM_STOP_CMD,0);
//重新配置参数
stream_self_cmd_func(jpeg_s,RESET_MJPEG_FROM,1);
//启动jpeg
stream_self_cmd_func(jpeg_s,RESET_MJPEG_DPI,(640<<16 | 480));
//不需要重启scale1
exit_menu_select_ui(e);
}
static void DPI_1280x960_select_ui(lv_event_t * e)
{
struct preview_encode_takephoto_selct_ui_s *ui_s = (struct preview_encode_takephoto_selct_ui_s *)lv_event_get_user_data(e);
stream *jpeg_s = ui_s->jpg0_stream;
stream *scale1_stream = ui_s->scale1_stream;
//scale1先停止
stream_self_cmd_func(scale1_stream,STREAM_STOP_CMD,0);
//先停止jpg?
stream_self_cmd_func(jpeg_s,STREAM_STOP_CMD,0);
//重新配置参数
stream_self_cmd_func(jpeg_s,RESET_MJPEG_FROM,2);
//启动jpeg
stream_self_cmd_func(jpeg_s,RESET_MJPEG_DPI,(1280<<16 | 960));
//启动scale1
stream_self_cmd_func(scale1_stream,SCALE1_RESET_DPI,(1280<<16 | 960));
exit_menu_select_ui(e);
}
static void DPI_1920x1440_select_ui(lv_event_t * e)
{
struct preview_encode_takephoto_selct_ui_s *ui_s = (struct preview_encode_takephoto_selct_ui_s *)lv_event_get_user_data(e);
stream *jpeg_s = ui_s->jpg0_stream;
stream *scale1_stream = ui_s->scale1_stream;
//scale1先停止
stream_self_cmd_func(scale1_stream,STREAM_STOP_CMD,0);
//先停止jpg?
stream_self_cmd_func(jpeg_s,STREAM_STOP_CMD,0);
//重新配置参数
stream_self_cmd_func(jpeg_s,RESET_MJPEG_FROM,2);
//启动jpeg
stream_self_cmd_func(jpeg_s,RESET_MJPEG_DPI,(1920<<16 | 1440));
//启动scale1
stream_self_cmd_func(scale1_stream,SCALE1_RESET_DPI,(1920<<16 | 1440));
exit_menu_select_ui(e);
}
//切换拍照还是录像
static void change_mode_ui(lv_event_t * e)
{
struct preview_encode_takephoto_selct_ui_s *ui_s = (struct preview_encode_takephoto_selct_ui_s *)lv_event_get_user_data(e);
int32_t c = *((int32_t *)lv_event_get_param(e));
if(c == 'd')
{
if(ui_s->is_takephoto)
{
ui_s->is_takephoto = 0;
}
else
{
ui_s->is_takephoto = 1;
}
//将ui修改
if(ui_s->is_takephoto)
{
//修改成了拍照模式,那么看看是不是在录像,在录像就要停止录像
if(lv_obj_has_flag(ui_s->now_ui,LV_OBJ_RECORD_FLAG))
{
lv_obj_clear_flag(ui_s->now_ui, LV_OBJ_RECORD_FLAG);
//关闭录像的流
close_stream(ui_s->avi_save_s);
ui_s->avi_save_s = NULL;
}
lv_label_set_text(ui_s->status_obj,"takephoto");
}
else
{
lv_label_set_text(ui_s->status_obj,"record");
}
}
}
//菜单栏
static void enter_menu_select_ui(lv_event_t * e)
{
int32_t c = *((int32_t *)lv_event_get_param(e));
if(c == 'a')
{
//创建ui
lv_obj_t *list;
lv_obj_t *list_item;
lv_group_t *group;
group = lv_group_create();
lv_indev_set_group(indev_keypad, group);
struct preview_encode_takephoto_selct_ui_s *ui_s = (struct preview_encode_takephoto_selct_ui_s *)lv_event_get_user_data(e);
list = lv_list_create(ui_s->now_ui);
//删除group
lv_obj_add_event_cb(list, clear_menu_select_ui, LV_EVENT_DELETE, group);
//分辨率切换完毕后,就退出
list_item = lv_list_add_btn(list, NULL, "640x480");
list_item->user_data = (void*)list;
lv_group_add_obj(group, list_item);
os_printf("list_item:%X\n",list_item);
lv_obj_add_event_cb(list_item, DPI_640x480_select_ui, LV_EVENT_SHORT_CLICKED, ui_s);
//分辨率切换完毕后,就退出
list_item = lv_list_add_btn(list, NULL, "1280x960");
list_item->user_data = (void*)list;
lv_group_add_obj(group, list_item);
os_printf("list_item:%X\n",list_item);
lv_obj_add_event_cb(list_item, DPI_1280x960_select_ui, LV_EVENT_SHORT_CLICKED, ui_s);
list_item = lv_list_add_btn(list, NULL, "1920x1440");
list_item->user_data = (void*)list;
lv_group_add_obj(group, list_item);
os_printf("list_item:%X\n",list_item);
lv_obj_add_event_cb(list_item, DPI_1920x1440_select_ui, LV_EVENT_SHORT_CLICKED, ui_s);
#if 1
//退出,还原group
list_item = lv_list_add_btn(list, NULL, "exit");
list_item->user_data = (void*)list;
lv_group_add_obj(group, list_item);
os_printf("list_item:%X\n",list_item);
lv_obj_add_event_cb(list_item, exit_menu_select_ui, LV_EVENT_SHORT_CLICKED, ui_s);
#endif
}
}
//进入预览的ui,那么就要创建新的ui去显示预览图了
static void enter_preview_encode_select_ui(lv_event_t * e)
{
set_lvgl_get_key_func(self_key);
struct preview_encode_takephoto_selct_ui_s *ui_s = (struct preview_encode_takephoto_selct_ui_s *)lv_event_get_user_data(e);
lv_obj_add_flag(ui_s->base_ui, LV_OBJ_FLAG_HIDDEN);
lv_obj_t *ui = lv_obj_create(lv_scr_act());
ui_s->now_ui = ui;
//创建takephoto或者record的显示ui
ui_s->status_obj = lv_label_create(ui);
ui_s->is_takephoto = 1;
lv_label_set_text(ui_s->status_obj,"takephoto");
lv_obj_set_style_text_color(ui_s->status_obj, lv_palette_main(LV_PALETTE_RED), 0);
lv_obj_add_style(ui, &g_style, 0);
lv_obj_set_size(ui, LV_PCT(100), LV_PCT(100));
ui_s->s = scale3_stream_not_bind(S_PREVIEW_ENCODE_QVGA,640,480,320,240,YUV_P0);
//绑定流到Video P0显示
streamSrc_bind_streamDest(ui_s->s,R_VIDEO_P0);
enable_stream(ui_s->s,1);
//默认拍照分辨率
//打开scale1
ui_s->scale1_stream = scale1_stream_not_bind(S_SCALE1_STREAM,640,480,1280,960);
os_sleep_ms(10);
ui_s->jpg0_stream = new_video_app_stream_with_mode(R_JPEG_DEMO,2,1280,960);
streamSrc_bind_streamDest(ui_s->jpg0_stream,R_LVGL_TAKEPHOTO);
//发送到图传
streamSrc_bind_streamDest(ui_s->jpg0_stream,R_RTP_JPEG);
//发送到录像
streamSrc_bind_streamDest(ui_s->jpg0_stream,R_AVI_SAVE_VIDEO);
enable_stream(ui_s->jpg0_stream,1);
ui_s->takephoto_s = takephoto_stream(R_LVGL_TAKEPHOTO);
//获取adc,由外部已经打开了,如果没有打开,这里要处理一下,这里名称固定了(因为与硬件绑定,就不作为灵活变动),就不做成灵活变动了
ui_s->audio_s = get_stream_available(S_ADC_AUDIO);
//发送测试一下
streamSrc_bind_streamDest(ui_s->audio_s,R_AVI_SAVE_AUDIO);
lv_group_t *group;
group = lv_group_create();
lv_indev_set_group(indev_keypad, group);
lv_group_add_obj(group, ui);
ui_s->now_group = group;
lv_obj_add_event_cb(ui, exit_preview_encode_select_ui, LV_EVENT_KEY, ui_s);
//拍照的按键事件
lv_obj_add_event_cb(ui, encode_takephoto_ui, LV_EVENT_PRESSED, ui_s);
//弹出菜单栏,用于切换分辨率
lv_obj_add_event_cb(ui, enter_menu_select_ui, LV_EVENT_KEY, ui_s);
//切换录像还是拍照功能
lv_obj_add_event_cb(ui, change_mode_ui, LV_EVENT_KEY, ui_s);
}
lv_obj_t *preview_encode_selct_ui(lv_group_t *group,lv_obj_t *base_ui)
{
struct preview_encode_takephoto_selct_ui_s *ui_s = (struct preview_encode_takephoto_selct_ui_s*)STREAM_LIBC_ZALLOC(sizeof(struct preview_encode_takephoto_selct_ui_s));
ui_s->last_group = group;
ui_s->base_ui = base_ui;
lv_obj_t *btn = lv_list_add_btn(base_ui, NULL, "preview_encode_slect");
lv_group_add_obj(group, btn);
lv_obj_add_event_cb(btn, enter_preview_encode_select_ui, LV_EVENT_SHORT_CLICKED, ui_s);
return btn;
}
+307
View File
@@ -0,0 +1,307 @@
/***************************************************************************************
S_PREVIEW_SCALE3 ----> R_VIDEO_P0(320x240)
(scale3) | (lcd_video_p0)
|
----> R_YUV_TO_JPG(启动jpg0,video_app)
(编码成jpg:320x240)
***************************************************************************************/
#include "lvgl/lvgl.h"
#include "lvgl_ui.h"
#include "osal/string.h"
#include "stream_frame.h"
#include "keyWork.h"
#include "keyScan.h"
#include "custom_mem/custom_mem.h"
#include "fatfs/osal_file.h"
//data申请空间函数
#define STREAM_MALLOC custom_malloc_psram
#define STREAM_FREE custom_free_psram
#define STREAM_ZALLOC custom_zalloc_psram
//结构体申请空间函数
#define STREAM_LIBC_MALLOC custom_malloc
#define STREAM_LIBC_FREE custom_free
#define STREAM_LIBC_ZALLOC custom_zalloc
#define LV_OBJ_TAKEPHOTO_FLAG LV_OBJ_FLAG_USER_1
extern lv_indev_t * indev_keypad;
extern lv_style_t g_style;
struct preview_encode_takephoto_ui_s
{
lv_group_t *last_group;
lv_obj_t *base_ui;
lv_group_t *now_group;
lv_obj_t *now_ui;
lv_timer_t *timer;
stream *s;
stream *jpg_s;
stream *takephoto_s;
};
static uint32_t self_key(uint32_t val)
{
uint32_t key_ret = 0;
if(val > 0)
{
if((val&0xff) == KEY_EVENT_SUP)
{
switch(val>>8)
{
case AD_UP:
key_ret = 'q';
break;
case AD_DOWN:
key_ret = 's';
break;
case AD_LEFT:
key_ret = 'a';
break;
case AD_RIGHT:
key_ret = 'd';
break;
case AD_PRESS:
key_ret = LV_KEY_ENTER;
break;
break;
default:
break;
}
}
else if((val&0xff) == KEY_EVENT_LUP)
{
switch(val>>8)
{
case AD_PRESS:
key_ret = 'e';
break;
default:
break;
}
}
}
return key_ret;
}
//生成一个流,专门接收图片,用于拍照的,拍照之前可以将缓冲区的删除,这样可以保证得到最新的图片
//要考虑一些问题,如果拍照放在workqueue,要考虑写卡时间是否影响workqueue
//这里尝试使用lvgl的timer事件去保存(影响lvgl,如果需要更加好,可能要创建任务去保存)
static int opcode_func(stream *s,void *priv,int opcode)
{
int res = 0;
switch(opcode)
{
case STREAM_OPEN_ENTER:
break;
case STREAM_OPEN_EXIT:
{
}
break;
case STREAM_OPEN_FAIL:
break;
case STREAM_DATA_DIS:
{
}
break;
case STREAM_RECV_DATA_FINISH:
{
}
break;
//在发送到这个流的时候,进行数据包过滤
case STREAM_FILTER_DATA:
{
}
break;
//流接收后,数据包也要检查是否需要过滤或者是不是因为逻辑条件符合需要过滤
case STREAM_RECV_FILTER_DATA:
{
}
break;
case STREAM_DATA_FREE:
{
}
break;
case STREAM_CLOSE_EXIT:
{
}
break;
case STREAM_MARK_GC_END:
{
}
break;
default:
break;
}
return res;
}
static stream *takephoto_stream(const char *name)
{
//设置接收1,是为了不要接收太多的图片,因为是拍照,需要保持实时性
//如果接收过多,如果不处理,会导致源头没有空间产生新的图片
//如果要结合录像,则需要在应用层去处理(实际录像时可以创建另一个独立的流)
stream *s = open_stream_available(name,0,1,opcode_func,NULL);
return s;
}
extern int no_frame_record_video_psram(void *fp,void *d,int flen);
static void takephoto_timer(lv_timer_t *t)
{
struct preview_encode_takephoto_ui_s *ui_s = (struct preview_encode_takephoto_ui_s *)t->user_data;
struct data_structure *data_s;
//看看对应的流有没有图片,如果有,则保存
data_s = recv_real_data(ui_s->takephoto_s);
if(data_s)
{
enable_stream(ui_s->takephoto_s,0);
char filename[64];
sprintf(filename,"0:%08d.jpg",(uint32_t)os_jiffies());
void *fp = osal_fopen(filename,"wb");
if(fp)
{
no_frame_record_video_psram(fp,data_s,get_stream_real_data_len(data_s));
osal_fclose(fp);
}
else
{
os_printf("takephoto fail,filename:%s\n",filename);
}
//保存图片
free_data(data_s);
while(data_s)
{
data_s = recv_real_data(ui_s->takephoto_s);
if(data_s)
{
free_data(data_s);
}
}
os_printf("takephoto success\n");
lv_obj_clear_flag(ui_s->now_ui, LV_OBJ_TAKEPHOTO_FLAG);
ui_s->timer = NULL;
lv_timer_del(t);
}
}
//使能拍照
static void encode_takephoto_ui(lv_event_t * e)
{
struct preview_encode_takephoto_ui_s *ui_s = (struct preview_encode_takephoto_ui_s *)lv_event_get_user_data(e);
stream *s = ui_s->takephoto_s;
if(!lv_obj_has_flag(ui_s->now_ui,LV_OBJ_TAKEPHOTO_FLAG))
{
lv_obj_add_flag(ui_s->now_ui, LV_OBJ_TAKEPHOTO_FLAG);
enable_stream(s,1);
//启动timer,10ms检查一次
ui_s->timer = lv_timer_create(takephoto_timer, 10, (void*)ui_s);
}
else
{
//已经在拍照了
os_printf("%s already running\n",__FUNCTION__);
}
}
static void exit_preview_encode_takephoto_ui(lv_event_t * e)
{
struct preview_encode_takephoto_ui_s *ui_s = (struct preview_encode_takephoto_ui_s *)lv_event_get_user_data(e);
int32_t c = *((int32_t *)lv_event_get_param(e));
if(c == 'q')
{
if(ui_s->timer)
{
lv_timer_del(ui_s->timer);
}
struct preview_encode_takephoto_ui_s *ui_s = (struct preview_encode_takephoto_ui_s *)lv_event_get_user_data(e);
lv_indev_set_group(indev_keypad, ui_s->last_group);
lv_obj_clear_flag(ui_s->base_ui, LV_OBJ_FLAG_HIDDEN);
lv_group_del(ui_s->now_group);
ui_s->now_group = NULL;
close_stream(ui_s->s);
close_stream(ui_s->jpg_s);
close_stream(ui_s->takephoto_s);
lv_obj_del(ui_s->now_ui);
set_lvgl_get_key_func(NULL);
}
}
//进入预览的ui,那么就要创建新的ui去显示预览图了
static void enter_preview_encode_takephoto_ui(lv_event_t * e)
{
set_lvgl_get_key_func(self_key);
struct preview_encode_takephoto_ui_s *ui_s = (struct preview_encode_takephoto_ui_s *)lv_event_get_user_data(e);
lv_obj_add_flag(ui_s->base_ui, LV_OBJ_FLAG_HIDDEN);
lv_obj_t *ui = lv_obj_create(lv_scr_act());
ui_s->now_ui = ui;
lv_obj_add_style(ui, &g_style, 0);
lv_obj_set_size(ui, LV_PCT(100), LV_PCT(100));
ui_s->s = scale3_stream_not_bind(S_PREVIEW_ENCODE_VPP,640,480,320,240,YUV_P0);
//绑定流到Video P0显示
streamSrc_bind_streamDest(ui_s->s,R_VIDEO_P0);
enable_stream(ui_s->s,1);
//创建jpg流,设置从vpp取数据,所以是1
ui_s->jpg_s = new_video_app_stream_with_mode(S_JPEG,1,0,0);
//给到图传测试使用
streamSrc_bind_streamDest(ui_s->jpg_s,R_RTP_JPEG);
streamSrc_bind_streamDest(ui_s->jpg_s,R_LVGL_TAKEPHOTO);
enable_stream(ui_s->jpg_s,1);
ui_s->takephoto_s = takephoto_stream(R_LVGL_TAKEPHOTO);
lv_group_t *group;
group = lv_group_create();
lv_indev_set_group(indev_keypad, group);
lv_group_add_obj(group, ui);
ui_s->now_group = group;
lv_obj_add_event_cb(ui, exit_preview_encode_takephoto_ui, LV_EVENT_KEY, ui_s);
//拍照的按键事件
lv_obj_add_event_cb(ui, encode_takephoto_ui, LV_EVENT_PRESSED, ui_s);
}
lv_obj_t *preview_encode_takephoto_ui(lv_group_t *group,lv_obj_t *base_ui)
{
struct preview_encode_takephoto_ui_s *ui_s = (struct preview_encode_takephoto_ui_s*)STREAM_LIBC_ZALLOC(sizeof(struct preview_encode_takephoto_ui_s));
ui_s->last_group = group;
ui_s->base_ui = base_ui;
lv_obj_t *btn = lv_list_add_btn(base_ui, NULL, "preview_encode_takephoto");
lv_group_add_obj(group, btn);
lv_obj_add_event_cb(btn, enter_preview_encode_takephoto_ui, LV_EVENT_SHORT_CLICKED, ui_s);
return btn;
}
+99
View File
@@ -0,0 +1,99 @@
/***************************************************************************************
S_PREVIEW_SCALE3 ----> R_VIDEO_P0(320x240)
(scale3) | (lcd_video_p0)
|
----> R_YUV_TO_JPG(启动jpg0,video_app)
(编码成jpg:320x240)
***************************************************************************************/
#include "lvgl/lvgl.h"
#include "lvgl_ui.h"
#include "osal/string.h"
#include "stream_frame.h"
#include "custom_mem/custom_mem.h"
//data申请空间函数
#define STREAM_MALLOC custom_malloc_psram
#define STREAM_FREE custom_free_psram
#define STREAM_ZALLOC custom_zalloc_psram
//结构体申请空间函数
#define STREAM_LIBC_MALLOC custom_malloc
#define STREAM_LIBC_FREE custom_free
#define STREAM_LIBC_ZALLOC custom_zalloc
extern lv_indev_t * indev_keypad;
extern lv_style_t g_style;
struct preview_encode_QVGA_ui_s
{
lv_group_t *last_group;
lv_obj_t *base_ui;
lv_group_t *now_group;
lv_obj_t *now_ui;
stream *s;
stream *yuv_jpg_s;
stream *jpg_s;
};
static void exit_preview_encode_ui(lv_event_t * e)
{
struct preview_encode_QVGA_ui_s *ui_s = (struct preview_encode_QVGA_ui_s *)lv_event_get_user_data(e);
lv_indev_set_group(indev_keypad, ui_s->last_group);
lv_obj_clear_flag(ui_s->base_ui, LV_OBJ_FLAG_HIDDEN);
lv_group_del(ui_s->now_group);
ui_s->now_group = NULL;
close_stream(ui_s->s);
close_stream(ui_s->jpg_s);
close_stream(ui_s->yuv_jpg_s);
lv_obj_del(ui_s->now_ui);
}
//进入预览的ui,那么就要创建新的ui去显示预览图了
static void enter_preview_encode_ui(lv_event_t * e)
{
struct preview_encode_QVGA_ui_s *ui_s = (struct preview_encode_QVGA_ui_s *)lv_event_get_user_data(e);
lv_obj_add_flag(ui_s->base_ui, LV_OBJ_FLAG_HIDDEN);
lv_obj_t *ui = lv_obj_create(lv_scr_act());
ui_s->now_ui = ui;
lv_obj_add_style(ui, &g_style, 0);
lv_obj_set_size(ui, LV_PCT(100), LV_PCT(100));
ui_s->s = scale3_stream_not_bind(S_PREVIEW_ENCODE_QVGA,640,480,320,240,YUV_P0);
//绑定流到Video P0显示
streamSrc_bind_streamDest(ui_s->s,R_VIDEO_P0);
//绑定流到YUV_TO_JPG,意思就是将320x240数据给到yuv_to_jpg,然后yuv_to_jpg启动jpg0编码,得到320x240的jpg数据
streamSrc_bind_streamDest(ui_s->s,R_YUV_TO_JPG);
enable_stream(ui_s->s,1);
//先创建jpg_s,然后绑定流(jpg给到谁用),最后使能
ui_s->jpg_s = new_video_app_stream(S_JPEG);
//给到图传测试使用
streamSrc_bind_streamDest(ui_s->jpg_s,R_RTP_JPEG);
enable_stream(ui_s->jpg_s,1);
ui_s->yuv_jpg_s = prc_stream(R_YUV_TO_JPG,ui_s->jpg_s);
enable_stream(ui_s->yuv_jpg_s,1);
lv_group_t *group;
group = lv_group_create();
lv_indev_set_group(indev_keypad, group);
lv_group_add_obj(group, ui);
ui_s->now_group = group;
lv_obj_add_event_cb(ui, exit_preview_encode_ui, LV_EVENT_PRESSED, ui_s);
}
lv_obj_t *preview_encode_QVGA_ui(lv_group_t *group,lv_obj_t *base_ui)
{
struct preview_encode_QVGA_ui_s *ui_s = (struct preview_encode_QVGA_ui_s*)STREAM_LIBC_ZALLOC(sizeof(struct preview_encode_QVGA_ui_s));
ui_s->last_group = group;
ui_s->base_ui = base_ui;
lv_obj_t *btn = lv_list_add_btn(base_ui, NULL, "preview_encode_QVGA");
lv_group_add_obj(group, btn);
lv_obj_add_event_cb(btn, enter_preview_encode_ui, LV_EVENT_PRESSED, ui_s);
return btn;
}
+6
View File
@@ -0,0 +1,6 @@
#ifndef PREVIEW_ENCODE_UI_H
#define PREVIEW_ENCODE_UI_H
#include "lvgl/lvgl.h"
lv_obj_t *preview_encode_ui(lv_group_t *group,lv_obj_t *base_ui);
lv_obj_t *preview_encode_QQVGA_ui(lv_group_t *group,lv_obj_t *base_ui);
#endif
+86
View File
@@ -0,0 +1,86 @@
/***********************************************************************************************************
* 主要用于显示网络接收的图像数据
SR_OTHER_JPG ----> S_JPG_DECODE ----> R_VIDEO_P0
(320x240) (320x240)
********************************************************************************************************** */
#include "lvgl/lvgl.h"
#include "lvgl_ui.h"
#include "osal/string.h"
#include "stream_frame.h"
#include "custom_mem/custom_mem.h"
#include "other_jpg_show/other_jpg_show_stream.h"
//data申请空间函数
#define STREAM_MALLOC custom_malloc_psram
#define STREAM_FREE custom_free_psram
#define STREAM_ZALLOC custom_zalloc_psram
//结构体申请空间函数
#define STREAM_LIBC_MALLOC custom_malloc
#define STREAM_LIBC_FREE custom_free
#define STREAM_LIBC_ZALLOC custom_zalloc
extern lv_indev_t * indev_keypad;
extern lv_style_t g_style;
struct preview_net_jpg_s
{
lv_group_t *last_group;
lv_obj_t *base_ui;
lv_group_t *now_group;
lv_obj_t *now_ui;
//这个是需要的流,但命名不一定对应,有可能通过中间流进行中转实现
stream *net_jpg_s;
stream *decode_s;
};
static void exit_preview_net_jpg_ui(lv_event_t * e)
{
struct preview_net_jpg_s *ui_s = (struct preview_net_jpg_s *)lv_event_get_user_data(e);
lv_indev_set_group(indev_keypad, ui_s->last_group);
lv_obj_clear_flag(ui_s->base_ui, LV_OBJ_FLAG_HIDDEN);
lv_group_del(ui_s->now_group);
ui_s->now_group = NULL;
close_stream(ui_s->net_jpg_s);
close_stream(ui_s->decode_s);
lv_obj_del(ui_s->now_ui);
}
static void enter_preview_net_jpg_ui(lv_event_t * e)
{
struct preview_net_jpg_s *ui_s = (struct preview_net_jpg_s *)lv_event_get_user_data(e);
lv_obj_add_flag(ui_s->base_ui, LV_OBJ_FLAG_HIDDEN);
lv_obj_t *ui = lv_obj_create(lv_scr_act());
ui_s->now_ui = ui;
lv_obj_add_style(ui, &g_style, 0);
lv_obj_set_size(ui, LV_PCT(100), LV_PCT(100));
ui_s->decode_s = jpg_decode_stream_not_bind(S_JPG_DECODE);
//将解码的数据推送到Video P0显示
streamSrc_bind_streamDest(ui_s->decode_s,R_VIDEO_P0);
enable_stream(ui_s->decode_s,1);
//接收网络的jpg数据,配置需要解码的参数(320x240),然后给到S_JPG_DECODE进行解码,最后给到P0去显示(设置时P0的类型)
ui_s->net_jpg_s = other_jpg_stream_not_bind(SR_OTHER_JPG,320,240,320,240,YUV_P0);
//将other_jpg的数据给到S_JPG_DECODE进行编码
streamSrc_bind_streamDest(ui_s->net_jpg_s,S_JPG_DECODE);
enable_stream(ui_s->net_jpg_s,1);
lv_group_t *group;
group = lv_group_create();
lv_indev_set_group(indev_keypad, group);
lv_group_add_obj(group, ui);
ui_s->now_group = group;
lv_obj_add_event_cb(ui, exit_preview_net_jpg_ui, LV_EVENT_PRESSED, ui_s);
}
lv_obj_t *preview_net_jpg_ui(lv_group_t *group,lv_obj_t *base_ui)
{
struct preview_net_jpg_s *ui_s = (struct preview_net_jpg_s*)STREAM_LIBC_ZALLOC(sizeof(struct preview_net_jpg_s));
ui_s->last_group = group;
ui_s->base_ui = base_ui;
lv_obj_t *btn = lv_list_add_btn(base_ui, NULL, "preview_net_jpg");
lv_group_add_obj(group, btn);
lv_obj_add_event_cb(btn, enter_preview_net_jpg_ui, LV_EVENT_PRESSED, ui_s);
return btn;
}
+84
View File
@@ -0,0 +1,84 @@
/***************************************************************************************
这个主要是预览,通过scale3_stream将dvp数据scale到对应的分辨率作为数据流发送出去
然后lcd_stream需要接收对应的数据去显示
这里只是产生对应数据流,数据用途实际需要终端流(比如lcd流)接收后去处理
S_PREVIEW_SCALE3 ----> R_VIDEO_P0(320x240)
(scale3) (lcd_video_p0)
***************************************************************************************/
#include "lvgl/lvgl.h"
#include "lvgl_ui.h"
#include "osal/string.h"
#include "stream_frame.h"
#include "custom_mem/custom_mem.h"
//data申请空间函数
#define STREAM_MALLOC custom_malloc_psram
#define STREAM_FREE custom_free_psram
#define STREAM_ZALLOC custom_zalloc_psram
//结构体申请空间函数
#define STREAM_LIBC_MALLOC custom_malloc
#define STREAM_LIBC_FREE custom_free
#define STREAM_LIBC_ZALLOC custom_zalloc
extern lv_indev_t * indev_keypad;
extern lv_style_t g_style;
struct preview_ui_s
{
lv_group_t *last_group;
lv_obj_t *base_ui;
lv_group_t *now_group;
lv_obj_t *now_ui;
stream *s;
};
static void exit_preview_ui(lv_event_t * e)
{
struct preview_ui_s *ui_s = (struct preview_ui_s *)lv_event_get_user_data(e);
lv_indev_set_group(indev_keypad, ui_s->last_group);
lv_obj_clear_flag(ui_s->base_ui, LV_OBJ_FLAG_HIDDEN);
lv_group_del(ui_s->now_group);
ui_s->now_group = NULL;
close_stream(ui_s->s);
lv_obj_del(ui_s->now_ui);
}
//进入预览的ui,那么就要创建新的ui去显示预览图了
static void enter_preview_ui(lv_event_t * e)
{
struct preview_ui_s *ui_s = (struct preview_ui_s *)lv_event_get_user_data(e);
lv_obj_add_flag(ui_s->base_ui, LV_OBJ_FLAG_HIDDEN);
lv_obj_t *ui = lv_obj_create(lv_scr_act());
ui_s->now_ui = ui;
lv_obj_add_style(ui, &g_style, 0);
lv_obj_set_size(ui, LV_PCT(100), LV_PCT(100));
//绑定流到Video_P0,显示
ui_s->s = scale3_stream_not_bind(S_PREVIEW_SCALE3,640,480,320,240,YUV_P0);
streamSrc_bind_streamDest(ui_s->s,R_VIDEO_P0);
enable_stream(ui_s->s,1);
lv_group_t *group;
group = lv_group_create();
lv_indev_set_group(indev_keypad, group);
lv_group_add_obj(group, ui);
ui_s->now_group = group;
lv_obj_add_event_cb(ui, exit_preview_ui, LV_EVENT_PRESSED, ui_s);
}
lv_obj_t *preview_ui(lv_group_t *group,lv_obj_t *base_ui)
{
struct preview_ui_s *ui_s = (struct preview_ui_s*)STREAM_LIBC_ZALLOC(sizeof(struct preview_ui_s));
ui_s->last_group = group;
ui_s->base_ui = base_ui;
lv_obj_t *btn = lv_list_add_btn(base_ui, NULL, "preview");
lv_group_add_obj(group, btn);
lv_obj_add_event_cb(btn, enter_preview_ui, LV_EVENT_PRESSED, ui_s);
return btn;
}
+5
View File
@@ -0,0 +1,5 @@
#ifndef PREVIEW_UI_H
#define PREVIEW_UI_H
#include "lvgl/lvgl.h"
lv_obj_t *preview_ui(lv_group_t *group,lv_obj_t *base_ui);
#endif
+123
View File
@@ -0,0 +1,123 @@
/***********************************************************************************************************
S_USB_JPEG_PSRAM ----> SR_OTHER_JPG_USB1 ----> S_JPG_DECODE ----
| (320x240) (320x240) |
| ----> R_YUV_TO_JPG
| | (编码,取决于如何过滤)
----> SR_OTHER_JPG_USB2 ----> S_JPG_DECODE ----
(160x120) (160x120)
********************************************************************************************************** */
#include "lvgl/lvgl.h"
#include "lvgl_ui.h"
#include "osal/string.h"
#include "stream_frame.h"
#include "other_jpg_show/other_jpg_show_stream.h"
#include "custom_mem/custom_mem.h"
//data申请空间函数
#define STREAM_MALLOC custom_malloc_psram
#define STREAM_FREE custom_free_psram
#define STREAM_ZALLOC custom_zalloc_psram
//结构体申请空间函数
#define STREAM_LIBC_MALLOC custom_malloc
#define STREAM_LIBC_FREE custom_free
#define STREAM_LIBC_ZALLOC custom_zalloc
extern lv_indev_t * indev_keypad;
extern lv_style_t g_style;
struct preview_usb_s
{
lv_group_t *last_group;
lv_obj_t *base_ui;
lv_group_t *now_group;
lv_obj_t *now_ui;
//这个是需要的流,但命名不一定对应,有可能通过中间流进行中转实现
stream *USB_P0_jpg_s;
stream *USB_jpg_encode_s;
stream *decode_s;
stream *yuv_jpg_s;
stream *jpg_s;
};
static void exit_preview_usb_encode_ui(lv_event_t * e)
{
struct preview_usb_s *ui_s = (struct preview_usb_s *)lv_event_get_user_data(e);
lv_indev_set_group(indev_keypad, ui_s->last_group);
lv_obj_clear_flag(ui_s->base_ui, LV_OBJ_FLAG_HIDDEN);
lv_group_del(ui_s->now_group);
ui_s->now_group = NULL;
close_stream(ui_s->USB_P0_jpg_s);
close_stream(ui_s->USB_jpg_encode_s);
close_stream(ui_s->decode_s);
close_stream(ui_s->yuv_jpg_s);
close_stream(ui_s->jpg_s);
lv_obj_del(ui_s->now_ui);
}
//进入预览的ui,那么就要创建新的ui去显示预览图了
static void enter_preview_usb_encode_ui(lv_event_t * e)
{
struct preview_usb_s *ui_s = (struct preview_usb_s *)lv_event_get_user_data(e);
lv_obj_add_flag(ui_s->base_ui, LV_OBJ_FLAG_HIDDEN);
lv_obj_t *ui = lv_obj_create(lv_scr_act());
ui_s->now_ui = ui;
lv_obj_add_style(ui, &g_style, 0);
lv_obj_set_size(ui, LV_PCT(100), LV_PCT(100));
ui_s->decode_s = jpg_decode_stream_not_bind(S_JPG_DECODE);
//将解码的数据推送到Video P0和Video P1显示
streamSrc_bind_streamDest(ui_s->decode_s,R_VIDEO_P0);
streamSrc_bind_streamDest(ui_s->decode_s,R_VIDEO_P1);
streamSrc_bind_streamDest(ui_s->decode_s,R_YUV_TO_JPG);
enable_stream(ui_s->decode_s,1);
//先创建jpg_s,然后绑定流(jpg给到谁用),最后使能
ui_s->jpg_s = new_video_app_stream(S_JPEG);
//给到图传测试使用
streamSrc_bind_streamDest(ui_s->jpg_s,R_RTP_JPEG);
enable_stream(ui_s->jpg_s,1);
//接收S_JPG_DECODE的数据,然后进行编码,设置接收哪种类型
ui_s->yuv_jpg_s = prc_stream_filter(R_YUV_TO_JPG,ui_s->jpg_s,YUV_P1);
enable_stream(ui_s->yuv_jpg_s,1);
//接收usb的jpg,设置解码参数(320x240),然后给到P0显示
ui_s->USB_P0_jpg_s = other_jpg_stream_not_bind(SR_OTHER_JPG_USB1,320,240,320,240,YUV_P0);
//将jpg的数据给到S_JPG_DECODE进行编码
streamSrc_bind_streamDest(ui_s->USB_P0_jpg_s,S_JPG_DECODE);
enable_stream(ui_s->USB_P0_jpg_s,1);
ui_s->USB_jpg_encode_s = other_jpg_stream_not_bind(SR_OTHER_JPG_USB2,160,120,160,120,YUV_P1);
//将other_jpg的数据给到S_JPG_DECODE进行编码
streamSrc_bind_streamDest(ui_s->USB_jpg_encode_s,S_JPG_DECODE);
enable_stream(ui_s->USB_jpg_encode_s,1);
lv_group_t *group;
group = lv_group_create();
lv_indev_set_group(indev_keypad, group);
lv_group_add_obj(group, ui);
ui_s->now_group = group;
lv_obj_add_event_cb(ui, exit_preview_usb_encode_ui, LV_EVENT_PRESSED, ui_s);
}
lv_obj_t *preview_usb_encode_ui(lv_group_t *group,lv_obj_t *base_ui)
{
struct preview_usb_s *ui_s = (struct preview_usb_s*)STREAM_LIBC_ZALLOC(sizeof(struct preview_usb_s));
ui_s->last_group = group;
ui_s->base_ui = base_ui;
lv_obj_t *btn = lv_list_add_btn(base_ui, NULL, "preview_usb_encode");
lv_group_add_obj(group, btn);
lv_obj_add_event_cb(btn, enter_preview_usb_encode_ui, LV_EVENT_PRESSED, ui_s);
return btn;
}
+426
View File
@@ -0,0 +1,426 @@
/***************************************************************************************
***************************************************************************************/
#include "lvgl/lvgl.h"
#include "lvgl_ui.h"
#include "osal/string.h"
#include "stream_frame.h"
#include "keyWork.h"
#include "keyScan.h"
#include "custom_mem/custom_mem.h"
#include "osal_file.h"
#define PHOTO_DIR "photo"
extern stream *avi_save_stream(const char *manage_stream_name,const char *video_name,const char *audio_name,uint16_t video_cache_num,uint16_t audio_cache_num,uint16_t fps,uint16_t frq);
//data申请空间函数
#define STREAM_MALLOC custom_malloc_psram
#define STREAM_FREE custom_free_psram
#define STREAM_ZALLOC custom_zalloc_psram
//结构体申请空间函数
#define STREAM_LIBC_MALLOC custom_malloc
#define STREAM_LIBC_FREE custom_free
#define STREAM_LIBC_ZALLOC custom_zalloc
#define LV_OBJ_TAKEPHOTO_FLAG LV_OBJ_FLAG_USER_1
#define LV_OBJ_RECORD_FLAG LV_OBJ_FLAG_USER_2
extern void set_lvgl_get_key_func(void *func);
extern lv_indev_t * indev_keypad;
extern lv_style_t g_style;
struct preview_encode_takephoto_selct_ui_s
{
lv_group_t *last_group;
lv_obj_t *base_ui;
lv_group_t *now_group;
lv_obj_t *now_ui;
lv_obj_t *status_obj;
lv_timer_t *timer;
stream *decode_s;
stream *usb_P0_jpg_s;
stream *usb_s;
stream *takephoto_s;
stream *avi_save_s;
stream *audio_s;
uint8_t is_takephoto;
};
static uint32_t self_key(uint32_t val)
{
uint32_t key_ret = 0;
if(val > 0)
{
if((val&0xff) == KEY_EVENT_SUP)
{
switch(val>>8)
{
case AD_UP:
key_ret = LV_KEY_PREV;
break;
case AD_DOWN:
key_ret = LV_KEY_NEXT;
break;
case AD_LEFT:
key_ret = 'a';
break;
case AD_RIGHT:
key_ret = 'd';
break;
case AD_PRESS:
key_ret = LV_KEY_ENTER;
break;
case AD_A:
key_ret = 'q';
break;
default:
break;
}
}
else if((val&0xff) == KEY_EVENT_LUP)
{
switch(val>>8)
{
default:
break;
}
}
}
return key_ret;
}
//生成一个流,专门接收图片,用于拍照的,拍照之前可以将缓冲区的删除,这样可以保证得到最新的图片
//要考虑一些问题,如果拍照放在workqueue,要考虑写卡时间是否影响workqueue
//这里尝试使用lvgl的timer事件去保存(影响lvgl,如果需要更加好,可能要创建任务去保存)
static int opcode_func(stream *s,void *priv,int opcode)
{
int res = 0;
switch(opcode)
{
case STREAM_OPEN_ENTER:
break;
case STREAM_OPEN_EXIT:
{
}
break;
case STREAM_OPEN_FAIL:
break;
case STREAM_DATA_DIS:
{
}
break;
case STREAM_RECV_DATA_FINISH:
{
}
break;
//在发送到这个流的时候,进行数据包过滤
case STREAM_FILTER_DATA:
{
}
break;
//流接收后,数据包也要检查是否需要过滤或者是不是因为逻辑条件符合需要过滤
case STREAM_RECV_FILTER_DATA:
{
}
break;
case STREAM_DATA_FREE:
{
}
break;
case STREAM_CLOSE_EXIT:
{
}
break;
case STREAM_MARK_GC_END:
{
}
break;
default:
break;
}
return res;
}
static stream *takephoto_stream(const char *name)
{
//设置接收1,是为了不要接收太多的图片,因为是拍照,需要保持实时性
//如果接收过多,如果不处理,会导致源头没有空间产生新的图片
//如果要结合录像,则需要在应用层去处理(实际录像时可以创建另一个独立的流)
stream *s = open_stream_available(name,0,1,opcode_func,NULL);
return s;
}
extern int no_frame_record_video_psram(void *fp,void *d,int flen);
static void takephoto_timer(lv_timer_t *t)
{
struct preview_encode_takephoto_selct_ui_s *ui_s = (struct preview_encode_takephoto_selct_ui_s *)t->user_data;
struct data_structure *data_s;
//看看对应的流有没有图片,如果有,则保存
data_s = recv_real_data(ui_s->takephoto_s);
if(data_s)
{
enable_stream(ui_s->takephoto_s,0);
char filename[64];
sprintf(filename,"0:%s/%08d.jpg",PHOTO_DIR,(uint32_t)os_jiffies());
void *fp = osal_fopen(filename,"wb");
os_printf("filename:%s\n",filename);
if(fp)
{
os_printf("len:%d\n",get_stream_real_data_len(data_s));
no_frame_record_video_psram(fp,data_s,get_stream_real_data_len(data_s));
osal_fclose(fp);
}
else
{
os_printf("takephoto fail,filename:%s\n",filename);
}
//保存图片
free_data(data_s);
while(data_s)
{
data_s = recv_real_data(ui_s->takephoto_s);
if(data_s)
{
free_data(data_s);
}
}
os_printf("takephoto success\n");
lv_obj_clear_flag(ui_s->now_ui, LV_OBJ_TAKEPHOTO_FLAG);
ui_s->timer = NULL;
lv_timer_del(t);
}
}
//使能拍照
static void encode_takephoto_ui(lv_event_t * e)
{
struct preview_encode_takephoto_selct_ui_s *ui_s = (struct preview_encode_takephoto_selct_ui_s *)lv_event_get_user_data(e);
stream *s = ui_s->takephoto_s;
if(ui_s->is_takephoto)
{
if(!lv_obj_has_flag(ui_s->now_ui,LV_OBJ_TAKEPHOTO_FLAG))
{
lv_obj_add_flag(ui_s->now_ui, LV_OBJ_TAKEPHOTO_FLAG);
enable_stream(s,1);
//启动timer,10ms检查一次
ui_s->timer = lv_timer_create(takephoto_timer, 10, (void*)ui_s);
}
else
{
//已经在拍照了
os_printf("%s already running\n",__FUNCTION__);
}
}
else
{
if(!lv_obj_has_flag(ui_s->now_ui,LV_OBJ_RECORD_FLAG))
{
if(ui_s->audio_s)
{
ui_s->avi_save_s = avi_save_stream(MANAGE_STREAM_NAME,R_AVI_SAVE_VIDEO,R_AVI_SAVE_AUDIO,2,8,30,8000);
}
else
{
ui_s->avi_save_s = avi_save_stream(MANAGE_STREAM_NAME,R_AVI_SAVE_VIDEO,NULL,2,0,30,0);
}
if(ui_s->avi_save_s)
{
lv_obj_add_flag(ui_s->now_ui, LV_OBJ_RECORD_FLAG);
}
}
else
{
close_stream(ui_s->avi_save_s);
ui_s->avi_save_s = NULL;
}
}
}
static void exit_preview_encode_select_ui(lv_event_t * e)
{
int32_t c = *((int32_t *)lv_event_get_param(e));
if(c == 'q')
{
struct preview_encode_takephoto_selct_ui_s *ui_s = (struct preview_encode_takephoto_selct_ui_s *)lv_event_get_user_data(e);
lv_indev_set_group(indev_keypad, ui_s->last_group);
lv_obj_clear_flag(ui_s->base_ui, LV_OBJ_FLAG_HIDDEN);
lv_group_del(ui_s->now_group);
ui_s->now_group = NULL;
close_stream(ui_s->avi_save_s);
close_stream(ui_s->decode_s);
close_stream(ui_s->usb_P0_jpg_s);
close_stream(ui_s->usb_s);
close_stream(ui_s->takephoto_s);
close_stream(ui_s->audio_s); //因为外部打开的,所以实际这里关闭不会真的关闭,需要所有地方都关闭才会真的关闭的
lv_obj_del(ui_s->now_ui);
set_lvgl_get_key_func(NULL);
}
}
static void exit_menu_select_ui(lv_event_t * e)
{
struct preview_encode_takephoto_selct_ui_s *ui_s = (struct preview_encode_takephoto_selct_ui_s *)lv_event_get_user_data(e);
lv_obj_t *list_item = lv_event_get_current_target(e);
os_printf("list_item:%X\n",list_item);
if(ui_s->now_group)
{
lv_indev_set_group(indev_keypad, ui_s->now_group);
}
if(list_item->user_data)
{
//由于是子控件回调函数需要删除父控件,所以需要用到异步删除,否则删除内部链表会有异常
lv_obj_del_async(list_item->user_data);
}
}
//切换拍照还是录像
static void change_mode_ui(lv_event_t * e)
{
struct preview_encode_takephoto_selct_ui_s *ui_s = (struct preview_encode_takephoto_selct_ui_s *)lv_event_get_user_data(e);
int32_t c = *((int32_t *)lv_event_get_param(e));
if(c == 'd')
{
if(ui_s->is_takephoto)
{
ui_s->is_takephoto = 0;
}
else
{
ui_s->is_takephoto = 1;
}
//将ui修改
if(ui_s->is_takephoto)
{
//修改成了拍照模式,那么看看是不是在录像,在录像就要停止录像
if(lv_obj_has_flag(ui_s->now_ui,LV_OBJ_RECORD_FLAG))
{
lv_obj_clear_flag(ui_s->now_ui, LV_OBJ_RECORD_FLAG);
//关闭录像的流
close_stream(ui_s->avi_save_s);
ui_s->avi_save_s = NULL;
}
lv_label_set_text(ui_s->status_obj,"takephoto");
}
else
{
lv_label_set_text(ui_s->status_obj,"record");
}
}
}
//进入预览的ui,那么就要创建新的ui去显示预览图了
static void enter_preview_encode_select_ui(lv_event_t * e)
{
set_lvgl_get_key_func(self_key);
struct preview_encode_takephoto_selct_ui_s *ui_s = (struct preview_encode_takephoto_selct_ui_s *)lv_event_get_user_data(e);
lv_obj_add_flag(ui_s->base_ui, LV_OBJ_FLAG_HIDDEN);
lv_obj_t *ui = lv_obj_create(lv_scr_act());
ui_s->now_ui = ui;
//创建takephoto或者record的显示ui
ui_s->status_obj = lv_label_create(ui);
ui_s->is_takephoto = 1;
lv_label_set_text(ui_s->status_obj,"takephoto");
lv_obj_set_style_text_color(ui_s->status_obj, lv_palette_main(LV_PALETTE_RED), 0);
lv_obj_add_style(ui, &g_style, 0);
lv_obj_set_size(ui, LV_PCT(100), LV_PCT(100));
ui_s->decode_s = jpg_decode_stream_not_bind(S_JPG_DECODE);
//将解码的数据推送到Video P0和Video P1显示
streamSrc_bind_streamDest(ui_s->decode_s,R_VIDEO_P0);
enable_stream(ui_s->decode_s,1);
//接收usb的jpg数据,配置需要解码的参数(320x240),然后给到S_JPG_DECODE进行解码,最后给到P0去显示(设置时P0的类型)
ui_s->usb_P0_jpg_s = other_jpg_stream_not_bind(SR_OTHER_JPG_USB1,320,240,320,240,YUV_P0);
//将other_jpg的数据给到S_JPG_DECODE进行编码
streamSrc_bind_streamDest(ui_s->usb_P0_jpg_s,S_JPG_DECODE);
enable_stream(ui_s->usb_P0_jpg_s,1);
ui_s->usb_s = independ_video_usb();
streamSrc_bind_streamDest(ui_s->usb_s,R_LVGL_TAKEPHOTO);
//发送到录像
streamSrc_bind_streamDest(ui_s->usb_s,R_AVI_SAVE_VIDEO);
enable_stream(ui_s->usb_s,1);
ui_s->takephoto_s = takephoto_stream(R_LVGL_TAKEPHOTO);
lv_group_t *group;
group = lv_group_create();
lv_indev_set_group(indev_keypad, group);
lv_group_add_obj(group, ui);
ui_s->now_group = group;
lv_obj_add_event_cb(ui, exit_preview_encode_select_ui, LV_EVENT_KEY, ui_s);
//拍照的按键事件
lv_obj_add_event_cb(ui, encode_takephoto_ui, LV_EVENT_PRESSED, ui_s);
//切换录像还是拍照功能
lv_obj_add_event_cb(ui, change_mode_ui, LV_EVENT_KEY, ui_s);
}
lv_obj_t *preview_usb_select_ui(lv_group_t *group,lv_obj_t *base_ui)
{
struct preview_encode_takephoto_selct_ui_s *ui_s = (struct preview_encode_takephoto_selct_ui_s*)STREAM_LIBC_ZALLOC(sizeof(struct preview_encode_takephoto_selct_ui_s));
ui_s->last_group = group;
ui_s->base_ui = base_ui;
lv_obj_t *btn = lv_list_add_btn(base_ui, NULL, "preview_usb_select");
lv_group_add_obj(group, btn);
lv_obj_add_event_cb(btn, enter_preview_encode_select_ui, LV_EVENT_SHORT_CLICKED, ui_s);
return btn;
}
+112
View File
@@ -0,0 +1,112 @@
/***********************************************************************************************************
* 画中画效果,可以根据情况只显示一个
S_USB_JPEG_PSRAM ----> SR_OTHER_JPG_USB1 ----> S_JPG_DECODE
| (320x240) (320x240)
|
|
----> SR_OTHER_JPG_USB2 ----> S_JPG_DECODE
(160x120) (160x120)
********************************************************************************************************** */
#include "lvgl/lvgl.h"
#include "lvgl_ui.h"
#include "osal/string.h"
#include "stream_frame.h"
#include "custom_mem/custom_mem.h"
#include "other_jpg_show/other_jpg_show_stream.h"
//是否打开画中画demo(usb数据解码两次显示的demo)
#define PIP_EN 0
//data申请空间函数
#define STREAM_MALLOC custom_malloc_psram
#define STREAM_FREE custom_free_psram
#define STREAM_ZALLOC custom_zalloc_psram
//结构体申请空间函数
#define STREAM_LIBC_MALLOC custom_malloc
#define STREAM_LIBC_FREE custom_free
#define STREAM_LIBC_ZALLOC custom_zalloc
extern lv_indev_t * indev_keypad;
extern lv_style_t g_style;
struct preview_usb_s
{
lv_group_t *last_group;
lv_obj_t *base_ui;
lv_group_t *now_group;
lv_obj_t *now_ui;
//这个是需要的流,但命名不一定对应,有可能通过中间流进行中转实现
stream *usb_P0_jpg_s;
stream *usb_P1_jpg_s;
stream *decode_s;
};
static void exit_preview_usb_ui(lv_event_t * e)
{
struct preview_usb_s *ui_s = (struct preview_usb_s *)lv_event_get_user_data(e);
lv_indev_set_group(indev_keypad, ui_s->last_group);
lv_obj_clear_flag(ui_s->base_ui, LV_OBJ_FLAG_HIDDEN);
lv_group_del(ui_s->now_group);
ui_s->now_group = NULL;
close_stream(ui_s->usb_P0_jpg_s);
#if PIP_EN == 1
close_stream(ui_s->usb_P1_jpg_s);
#endif
close_stream(ui_s->decode_s);
lv_obj_del(ui_s->now_ui);
}
//进入预览的ui,那么就要创建新的ui去显示预览图了
static void enter_preview_usb_ui(lv_event_t * e)
{
struct preview_usb_s *ui_s = (struct preview_usb_s *)lv_event_get_user_data(e);
lv_obj_add_flag(ui_s->base_ui, LV_OBJ_FLAG_HIDDEN);
lv_obj_t *ui = lv_obj_create(lv_scr_act());
ui_s->now_ui = ui;
lv_obj_add_style(ui, &g_style, 0);
lv_obj_set_size(ui, LV_PCT(100), LV_PCT(100));
ui_s->decode_s = jpg_decode_stream_not_bind(S_JPG_DECODE);
//将解码的数据推送到Video P0和Video P1显示
streamSrc_bind_streamDest(ui_s->decode_s,R_VIDEO_P0);
streamSrc_bind_streamDest(ui_s->decode_s,R_VIDEO_P1);
enable_stream(ui_s->decode_s,1);
//接收usb的jpg数据,配置需要解码的参数(320x240),然后给到S_JPG_DECODE进行解码,最后给到P0去显示(设置时P0的类型)
ui_s->usb_P0_jpg_s = other_jpg_stream_not_bind(SR_OTHER_JPG_USB1,320,240,320,240,YUV_P0);
//将other_jpg的数据给到S_JPG_DECODE进行编码
streamSrc_bind_streamDest(ui_s->usb_P0_jpg_s,S_JPG_DECODE);
enable_stream(ui_s->usb_P0_jpg_s,1);
#if PIP_EN == 1
//接收usb的jpg数据,配置需要解码的参数(160x120),然后给到S_JPG_DECODE进行解码,最后给到P1去显示(设置时P1的类型)
ui_s->usb_P1_jpg_s = other_jpg_stream_not_bind(SR_OTHER_JPG_USB2,160,120,160,120,YUV_P1);
//将other_jpg的数据给到S_JPG_DECODE进行编码
streamSrc_bind_streamDest(ui_s->usb_P1_jpg_s,S_JPG_DECODE);
enable_stream(ui_s->usb_P1_jpg_s,1);
#endif
lv_group_t *group;
group = lv_group_create();
lv_indev_set_group(indev_keypad, group);
lv_group_add_obj(group, ui);
ui_s->now_group = group;
lv_obj_add_event_cb(ui, exit_preview_usb_ui, LV_EVENT_PRESSED, ui_s);
}
lv_obj_t *preview_usb_ui(lv_group_t *group,lv_obj_t *base_ui)
{
struct preview_usb_s *ui_s = (struct preview_usb_s*)STREAM_LIBC_ZALLOC(sizeof(struct preview_usb_s));
ui_s->last_group = group;
ui_s->base_ui = base_ui;
lv_obj_t *btn = lv_list_add_btn(base_ui, NULL, "preview_usb_pip");
lv_group_add_obj(group, btn);
lv_obj_add_event_cb(btn, enter_preview_usb_ui, LV_EVENT_PRESSED, ui_s);
return btn;
}
+23
View File
@@ -0,0 +1,23 @@
/***************************************************************************************
***************************************************************************************/
#include "lvgl/lvgl.h"
#include "osal/string.h"
#include "stream_frame.h"
stream *yuv_to_jpg_stream(const char *name);
extern lv_indev_t * indev_keypad;
static void print_system_msg(lv_event_t * e)
{
//uint32_t buf[1024/4];
//print_custom_psram_heap_status(buf,1024);
}
lv_obj_t *system_msg_ui(lv_group_t *group,lv_obj_t *base_ui)
{
lv_obj_t *btn = lv_list_add_btn(base_ui, NULL, "systemMsg");
lv_group_add_obj(group, btn);
lv_obj_add_event_cb(btn, print_system_msg, LV_EVENT_PRESSED, NULL);
lv_group_add_obj(group, btn);
return btn;
}
+155
View File
@@ -0,0 +1,155 @@
#include "lvgl/lvgl.h"
#include "lvgl_ui.h"
#include "osal/string.h"
#include "stream_frame.h"
#include "other_jpg_show/other_jpg_show_stream.h"
#include "custom_mem/custom_mem.h"
#include "keyWork.h"
#include "keyScan.h"
//data申请空间函数
#define STREAM_MALLOC custom_malloc_psram
#define STREAM_FREE custom_free_psram
#define STREAM_ZALLOC custom_zalloc_psram
//结构体申请空间函数
#define STREAM_LIBC_MALLOC custom_malloc
#define STREAM_LIBC_FREE custom_free
#define STREAM_LIBC_ZALLOC custom_zalloc
extern lv_indev_t * indev_keypad;
extern lv_style_t g_style;
struct lvgl_zbar_s
{
lv_group_t *last_group;
lv_obj_t *base_ui;
lv_group_t *now_group;
lv_obj_t *now_ui;
//这个是需要的流,但命名不一定对应,有可能通过中间流进行中转实现
stream *scale3_stream;
stream *zbar_stream;
};
//这创建一个由lvgl读取sd,然后发送的的数据流
static uint32_t self_key(uint32_t val)
{
uint32_t key_ret = 0;
if(val > 0)
{
if((val&0xff) == KEY_EVENT_SUP)
{
switch(val>>8)
{
case AD_UP:
key_ret = 'q';
break;
case AD_DOWN:
key_ret = 's';
break;
case AD_LEFT:
key_ret = 'a';
break;
case AD_RIGHT:
key_ret = 'd';
break;
case AD_PRESS:
key_ret = LV_KEY_ENTER;
break;
break;
default:
break;
}
}
else if((val&0xff) == KEY_EVENT_LUP)
{
switch(val>>8)
{
case AD_PRESS:
key_ret = 'e';
break;
default:
break;
}
}
}
return key_ret;
}
static void exit_zbar_ui(lv_event_t * e)
{
struct lvgl_zbar_s *ui_s = (struct lvgl_zbar_s *)lv_event_get_user_data(e);
int32_t c = *((int32_t *)lv_event_get_param(e));
if(c == 'q')
{
lv_indev_set_group(indev_keypad, ui_s->last_group);
lv_obj_clear_flag(ui_s->base_ui, LV_OBJ_FLAG_HIDDEN);
lv_group_del(ui_s->now_group);
ui_s->now_group = NULL;
close_stream(ui_s->scale3_stream);
close_stream(ui_s->zbar_stream);
lv_obj_del(ui_s->now_ui);
set_lvgl_get_key_func(NULL);
}
}
//进入预览的ui,那么就要创建新的ui去显示预览图了
static void enter_zbar_ui(lv_event_t * e)
{
set_lvgl_get_key_func(self_key);
struct lvgl_zbar_s *ui_s = (struct lvgl_zbar_s *)lv_event_get_user_data(e);
lv_obj_add_flag(ui_s->base_ui, LV_OBJ_FLAG_HIDDEN);
lv_obj_t *ui = lv_obj_create(lv_scr_act());
ui_s->now_ui = ui;
lv_obj_add_style(ui, &g_style, 0);
lv_obj_set_size(ui, LV_PCT(100), LV_PCT(100));
ui_s->scale3_stream = scale3_stream_not_bind(S_PREVIEW_SCALE3,640,480,320,240,YUV_P0|YUV_OTHER);
streamSrc_bind_streamDest(ui_s->scale3_stream,R_VIDEO_P0);
streamSrc_bind_streamDest(ui_s->scale3_stream,R_ZBAR);
enable_stream(ui_s->scale3_stream,1);
//启动二维码的流
ui_s->zbar_stream = zbar_stream(R_ZBAR,YUV_OTHER);
lv_group_t *group;
group = lv_group_create();
lv_indev_set_group(indev_keypad, group);
lv_group_add_obj(group, ui);
ui_s->now_group = group;
lv_obj_add_event_cb(ui, exit_zbar_ui, LV_EVENT_KEY, ui_s);
}
lv_obj_t *zbar_dvp_ui(lv_group_t *group,lv_obj_t *base_ui)
{
struct lvgl_zbar_s *ui_s = (struct lvgl_zbar_s*)STREAM_LIBC_ZALLOC(sizeof(struct lvgl_zbar_s));
ui_s->last_group = group;
ui_s->base_ui = base_ui;
lv_obj_t *btn = lv_list_add_btn(base_ui, NULL, "zbar_from_dvp");
lv_group_add_obj(group, btn);
lv_obj_add_event_cb(btn, enter_zbar_ui, LV_EVENT_SHORT_CLICKED, ui_s);
return btn;
}
+314
View File
@@ -0,0 +1,314 @@
#include "lvgl/lvgl.h"
#include "lvgl_ui.h"
#include "osal/string.h"
#include "stream_frame.h"
#include "other_jpg_show/other_jpg_show_stream.h"
#include "custom_mem/custom_mem.h"
#include "fatfs/osal_file.h"
#include "keyWork.h"
#include "keyScan.h"
//data申请空间函数
#define STREAM_MALLOC custom_malloc_psram
#define STREAM_FREE custom_free_psram
#define STREAM_ZALLOC custom_zalloc_psram
//结构体申请空间函数
#define STREAM_LIBC_MALLOC custom_malloc
#define STREAM_LIBC_FREE custom_free
#define STREAM_LIBC_ZALLOC custom_zalloc
extern lv_indev_t * indev_keypad;
extern lv_style_t g_style;
struct lvgl_zbar_s
{
lv_group_t *last_group;
lv_obj_t *base_ui;
lv_group_t *now_group;
lv_obj_t *now_ui;
//这个是需要的流,但命名不一定对应,有可能通过中间流进行中转实现
stream *zbar_jpg_s;
stream *decode_s;
stream *lvgl_zbar_sd_s;
stream *zbar_stream;
};
//这创建一个由lvgl读取sd,然后发送的的数据流
static uint32_t self_key(uint32_t val)
{
uint32_t key_ret = 0;
if(val > 0)
{
if((val&0xff) == KEY_EVENT_SUP)
{
switch(val>>8)
{
case AD_UP:
key_ret = 'q';
break;
case AD_DOWN:
key_ret = 's';
break;
case AD_LEFT:
key_ret = 'a';
break;
case AD_RIGHT:
key_ret = 'd';
break;
case AD_PRESS:
key_ret = LV_KEY_ENTER;
break;
break;
default:
break;
}
}
else if((val&0xff) == KEY_EVENT_LUP)
{
switch(val>>8)
{
case AD_PRESS:
key_ret = 'e';
break;
default:
break;
}
}
}
return key_ret;
}
static uint32_t lvgl_zbar_stream_cmd_func(stream *s,int opcode,uint32_t arg)
{
uint32_t res = 0;
// uint32_t flags;
switch(opcode)
{
case STREAM_ZBAR_FROM_SD:
{
//sd卡读取,然后发送,arg是图片地址
//获取一个data_s
struct data_structure *data_s = get_src_data_f(s);
uint8_t flag = 0;
if(data_s)
{
os_printf("%s:%d\tfilename:%s\n",__FUNCTION__,__LINE__,(char*)arg);
void *fp = osal_fopen((const char*)arg,"rb");
if(fp)
{
uint32_t filesize = osal_fsize(fp);
uint8_t *buf = (uint8_t*)STREAM_MALLOC(filesize);
if(buf)
{
osal_fread(buf,1,filesize,fp);
//发送出去
data_s->data = buf;
data_s->type = SET_DATA_TYPE(JPEG,JPEG_FULL);
set_stream_real_data_len(data_s,filesize);
send_data_to_stream(data_s);
os_printf("zbar read file send end\n");
flag = 1;
}
osal_fclose(fp);
}
if(!flag)
{
force_del_data(data_s);
}
}
}
break;
default:
break;
}
return res;
}
static int opcode_func_not_bind(stream *s,void *priv,int opcode)
{
int res = 0;
switch(opcode)
{
case STREAM_OPEN_ENTER:
break;
case STREAM_OPEN_EXIT:
{
register_stream_self_cmd_func(s,lvgl_zbar_stream_cmd_func);
}
break;
case STREAM_OPEN_FAIL:
break;
case STREAM_DATA_DIS:
{
}
break;
case STREAM_DATA_FREE:
{
struct data_structure *data = (struct data_structure *)priv;
if(data->data)
{
//os_printf("%s:%d\tdata:%X\tdata->data:%X\n",__FUNCTION__,__LINE__,data,data->data);
STREAM_FREE(data->data);
data->data = NULL;
}
}
break;
case STREAM_FILTER_DATA:
{
}
break;
case STREAM_DATA_FREE_END:
break;
//数据发送完成,可以选择唤醒对应的任务
case STREAM_SEND_DATA_FINISH:
break;
case STREAM_SEND_DATA_START:
{
}
break;
case STREAM_DATA_DESTORY:
{
}
break;
case STREAM_CLOSE_EXIT:
{
}
break;
case STREAM_MARK_GC_END:
{
}
break;
default:
//默认都返回成功
break;
}
return res;
}
stream *lvgl_zbar_from_sd_stream(const char *name)
{
stream *s = open_stream_available(name,8,0,opcode_func_not_bind,NULL);
return s;
}
static void send_zbar_ui(lv_event_t * e)
{
struct lvgl_zbar_s *ui_s = (struct lvgl_zbar_s *)lv_event_get_user_data(e);
//发送命令,去读取sd卡数据发到对应的流
stream_self_cmd_func(ui_s->lvgl_zbar_sd_s,STREAM_ZBAR_FROM_SD,(uint32_t)"0:1.jpg");
}
static void exit_zbar_ui(lv_event_t * e)
{
struct lvgl_zbar_s *ui_s = (struct lvgl_zbar_s *)lv_event_get_user_data(e);
int32_t c = *((int32_t *)lv_event_get_param(e));
if(c == 'q')
{
lv_indev_set_group(indev_keypad, ui_s->last_group);
lv_obj_clear_flag(ui_s->base_ui, LV_OBJ_FLAG_HIDDEN);
lv_group_del(ui_s->now_group);
ui_s->now_group = NULL;
close_stream(ui_s->zbar_jpg_s);
close_stream(ui_s->decode_s);
close_stream(ui_s->lvgl_zbar_sd_s);
close_stream(ui_s->zbar_stream);
lv_obj_del(ui_s->now_ui);
set_lvgl_get_key_func(NULL);
}
}
//进入预览的ui,那么就要创建新的ui去显示预览图了
static void enter_zbar_ui(lv_event_t * e)
{
set_lvgl_get_key_func(self_key);
struct lvgl_zbar_s *ui_s = (struct lvgl_zbar_s *)lv_event_get_user_data(e);
lv_obj_add_flag(ui_s->base_ui, LV_OBJ_FLAG_HIDDEN);
lv_obj_t *ui = lv_obj_create(lv_scr_act());
ui_s->now_ui = ui;
lv_obj_add_style(ui, &g_style, 0);
lv_obj_set_size(ui, LV_PCT(100), LV_PCT(100));
ui_s->decode_s = jpg_decode_stream_not_bind(S_JPG_DECODE);
//将解码的数据推送到Video P0和Video P1显示
streamSrc_bind_streamDest(ui_s->decode_s,R_VIDEO_P0);
streamSrc_bind_streamDest(ui_s->decode_s,R_ZBAR);
enable_stream(ui_s->decode_s,1);
//显示一下要识别的二维码,还需要创建一个从sd读取jpg图到SR_ZBAR_JPG
ui_s->zbar_jpg_s = other_jpg_stream_not_bind(SR_ZBAR_JPG,200,120,200,120,YUV_P0 | YUV_OTHER);
//将other_jpg的数据给到S_JPG_DECODE进行编码
streamSrc_bind_streamDest(ui_s->zbar_jpg_s,S_JPG_DECODE);
enable_stream(ui_s->zbar_jpg_s,1);
//启动二维码的流
ui_s->zbar_stream = zbar_stream(R_ZBAR,YUV_OTHER);
ui_s->lvgl_zbar_sd_s = lvgl_zbar_from_sd_stream(S_ZBAR_FROM_SD);
streamSrc_bind_streamDest(ui_s->lvgl_zbar_sd_s,SR_ZBAR_JPG);
enable_stream(ui_s->zbar_jpg_s,1);
lv_group_t *group;
group = lv_group_create();
lv_indev_set_group(indev_keypad, group);
lv_group_add_obj(group, ui);
ui_s->now_group = group;
lv_obj_add_event_cb(ui, exit_zbar_ui, LV_EVENT_KEY, ui_s);
//发送一张图片去识别
lv_obj_add_event_cb(ui, send_zbar_ui, LV_EVENT_PRESSED, ui_s);
}
lv_obj_t *zbar_ui(lv_group_t *group,lv_obj_t *base_ui)
{
struct lvgl_zbar_s *ui_s = (struct lvgl_zbar_s*)STREAM_LIBC_ZALLOC(sizeof(struct lvgl_zbar_s));
ui_s->last_group = group;
ui_s->base_ui = base_ui;
lv_obj_t *btn = lv_list_add_btn(base_ui, NULL, "zbar_from_sd_test");
lv_group_add_obj(group, btn);
lv_obj_add_event_cb(btn, enter_zbar_ui, LV_EVENT_SHORT_CLICKED, ui_s);
return btn;
}
+173
View File
@@ -0,0 +1,173 @@
#include "lvgl/lvgl.h"
#include "lvgl_ui.h"
#include "osal/string.h"
#include "stream_frame.h"
#include "other_jpg_show/other_jpg_show_stream.h"
#include "custom_mem/custom_mem.h"
#include "keyWork.h"
#include "keyScan.h"
//data申请空间函数
#define STREAM_MALLOC custom_malloc_psram
#define STREAM_FREE custom_free_psram
#define STREAM_ZALLOC custom_zalloc_psram
//结构体申请空间函数
#define STREAM_LIBC_MALLOC custom_malloc
#define STREAM_LIBC_FREE custom_free
#define STREAM_LIBC_ZALLOC custom_zalloc
extern lv_indev_t * indev_keypad;
extern lv_style_t g_style;
struct lvgl_zbar_s
{
lv_group_t *last_group;
lv_obj_t *base_ui;
lv_group_t *now_group;
lv_obj_t *now_ui;
//这个是需要的流,但命名不一定对应,有可能通过中间流进行中转实现
//usb接收打jpg的流,实际这里只是中转,为了适应动态绑定
stream *usb_jpg_stream;
//配置解码信息的流
stream *other_jpg_stream;
//解码流
stream *decode_s;
stream *zbar_stream;
};
//这创建一个由lvgl读取sd,然后发送的的数据流
static uint32_t self_key(uint32_t val)
{
uint32_t key_ret = 0;
if(val > 0)
{
if((val&0xff) == KEY_EVENT_SUP)
{
switch(val>>8)
{
case AD_UP:
key_ret = 'q';
break;
case AD_DOWN:
key_ret = 's';
break;
case AD_LEFT:
key_ret = 'a';
break;
case AD_RIGHT:
key_ret = 'd';
break;
case AD_PRESS:
key_ret = LV_KEY_ENTER;
break;
break;
default:
break;
}
}
else if((val&0xff) == KEY_EVENT_LUP)
{
switch(val>>8)
{
case AD_PRESS:
key_ret = 'e';
break;
default:
break;
}
}
}
return key_ret;
}
static void exit_zbar_ui(lv_event_t * e)
{
struct lvgl_zbar_s *ui_s = (struct lvgl_zbar_s *)lv_event_get_user_data(e);
int32_t c = *((int32_t *)lv_event_get_param(e));
if(c == 'q')
{
lv_indev_set_group(indev_keypad, ui_s->last_group);
lv_obj_clear_flag(ui_s->base_ui, LV_OBJ_FLAG_HIDDEN);
lv_group_del(ui_s->now_group);
ui_s->now_group = NULL;
close_stream(ui_s->usb_jpg_stream);
close_stream(ui_s->other_jpg_stream);
close_stream(ui_s->decode_s);
close_stream(ui_s->zbar_stream);
lv_obj_del(ui_s->now_ui);
set_lvgl_get_key_func(NULL);
}
}
//进入预览的ui,那么就要创建新的ui去显示预览图了
static void enter_zbar_ui(lv_event_t * e)
{
set_lvgl_get_key_func(self_key);
struct lvgl_zbar_s *ui_s = (struct lvgl_zbar_s *)lv_event_get_user_data(e);
lv_obj_add_flag(ui_s->base_ui, LV_OBJ_FLAG_HIDDEN);
lv_obj_t *ui = lv_obj_create(lv_scr_act());
ui_s->now_ui = ui;
lv_obj_add_style(ui, &g_style, 0);
lv_obj_set_size(ui, LV_PCT(100), LV_PCT(100));
ui_s->decode_s = jpg_decode_stream_not_bind(S_JPG_DECODE);
//将解码的数据推送到Video P0和Video P1显示
streamSrc_bind_streamDest(ui_s->decode_s,R_VIDEO_P0);
streamSrc_bind_streamDest(ui_s->decode_s,R_ZBAR);
enable_stream(ui_s->decode_s,1);
ui_s->other_jpg_stream = other_jpg_stream_not_bind(SR_OTHER_JPG,320,240,320,240,YUV_P0|YUV_OTHER);
//将other_jpg的数据给到S_JPG_DECODE进行编码
streamSrc_bind_streamDest(ui_s->other_jpg_stream,S_JPG_DECODE);
enable_stream(ui_s->other_jpg_stream,1);
ui_s->usb_jpg_stream = independ_video_usb();
streamSrc_bind_streamDest(ui_s->usb_jpg_stream,SR_OTHER_JPG);
enable_stream(ui_s->usb_jpg_stream,1);
//启动二维码的流
ui_s->zbar_stream = zbar_stream(R_ZBAR,YUV_OTHER);
lv_group_t *group;
group = lv_group_create();
lv_indev_set_group(indev_keypad, group);
lv_group_add_obj(group, ui);
ui_s->now_group = group;
lv_obj_add_event_cb(ui, exit_zbar_ui, LV_EVENT_KEY, ui_s);
}
lv_obj_t *zbar_usb_ui(lv_group_t *group,lv_obj_t *base_ui)
{
struct lvgl_zbar_s *ui_s = (struct lvgl_zbar_s*)STREAM_LIBC_ZALLOC(sizeof(struct lvgl_zbar_s));
ui_s->last_group = group;
ui_s->base_ui = base_ui;
lv_obj_t *btn = lv_list_add_btn(base_ui, NULL, "zbar_from_usb");
lv_group_add_obj(group, btn);
lv_obj_add_event_cb(btn, enter_zbar_ui, LV_EVENT_SHORT_CLICKED, ui_s);
return btn;
}