easylinux/OpenTXW81X
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

pure sdk for main

Browse Source
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
Download Patch File Download Diff File Expand all files Collapse all files
sdk/app/decode/jpg_decode_stream.c
+722
View File
@@ -0,0 +1,722 @@
#include "sys_config.h"
#include "typesdef.h"
#include "dev.h"
#include "devid.h"
#include "stream_frame.h"
#include "utlist.h"
#include "osal/work.h"
#include "lib/lcd/lcd.h"
#include "dev/scale/hgscale.h"
#include "dev/jpg/hgjpg.h"
#include "jpg_decode_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
struct jpg_decode_s
{
struct os_work work;
stream *s;
uint8_t *scaler2buf; //scale的buf
uint32_t scalerbuf_size;
struct jpg_device *jpg_dev;
struct scale_device *scale_dev;
uint32_t last_decode_time; //记录上一次解码的时间,预防有异常的时候可以计算超时
uint32_t dec_y_offset;
uint32_t dec_uv_offset;
uint32_t scale_p1_w;
uint32_t p1_w;
uint32_t p1_h;
//这两个值如果有用,会同时存在,不能只是存在一个
//图片的data_s,等图片解码完成后,可以选择释放
struct data_structure *parent_data_s;
//当前的使用的data_s,已经分配好了空间
struct data_structure *current_data_s;
//硬件模块是否准备好
uint8_t hardware_ready;
uint8_t hardware_err;
uint8_t is_register_isr;
};
struct jpg_decode_cmd_s
{
struct jpg_decode_arg_s *msg;
union
{
struct
{
uint32_t w;
uint32_t h;
uint32_t rotate;
}config;
struct
{
uint32_t in_w;
uint32_t in_h;
uint32_t out_w;
uint32_t out_h;
}in_out_size;
struct
{
uint32_t in_w;
uint32_t in_h;
uint32_t out_w;
uint32_t out_h;
}step;
};
};
static void stream_jpg_decode_scale2_done(uint32 irq_flag,uint32 irq_data,uint32 param1){
//struct jpg_decode_s *jpg_decode = (struct jpg_decode_s *)irq_data;
//struct jpg_device *jpg_dev = jpg_decode->jpg_dev;
//struct scale_device *scale_dev = jpg_decode->scale_dev;
//jpg_decode->hardware_ready = 1;
//os_printf("%s:%d\n",__FUNCTION__,__LINE__);
//_os_printf("S");
}
static void stream_jpg_decode_scale2_ov_isr(uint32 irq_flag,uint32 irq_data,uint32 param1){
//struct scale_device *scale_dev = (struct scale_device *)irq_data;
os_printf("sor2");
}
static void stream_jpg_decode_done(uint32 irq_flag,uint32 irq_data,uint32 param1,uint32 param2)
{
struct jpg_decode_s *jpg_decode = (struct jpg_decode_s *)irq_data;
//os_printf("!!!!!!!!!!!!!!!!decode finish\r\n");
//_os_printf("D");
jpg_decode->hardware_ready = 1;
}
//这里解码失败,暂时代表硬件完成,后面应该有错误标志位,主要为了解码失败移除当前frame
static void stream_jpg_decode_err(uint32 irq_flag,uint32 irq_data,uint32 param1,uint32 param2)
{
struct jpg_decode_s *jpg_decode = (struct jpg_decode_s *)irq_data;
os_printf("decode err\r\n");
os_printf("jpg_de->parent_data_s data:%X\n",get_stream_real_data(jpg_decode->parent_data_s));
//jpg_decode->hardware_ready = 1;
jpg_decode->hardware_err = 1;
}
static uint32_t jpg_decode_stream_cmd_func(stream *s,int opcode,uint32_t arg)
{
uint32_t res = 0;
// uint32_t flags;
switch(opcode)
{
case JPG_DECODE_ARG:
{
struct data_structure *data_s = (struct data_structure *)arg;
res = (uint32_t)data_s->priv;
}
break;
case YUV_ARG:
{
struct data_structure *data_s = (struct data_structure *)arg;
struct jpg_decode_arg_s *msg = (struct jpg_decode_arg_s*)data_s->priv;
res = (uint32_t)&msg->yuv_arg;
}
break;
//配置解码的参数大小
//配置输出到屏的size
case JPG_DECODE_SET_CONFIG:
{
struct jpg_decode_cmd_s *cfg = (struct jpg_decode_cmd_s*)arg;
struct jpg_decode_s *jpg_decode = (struct jpg_decode_s*)s->priv;
jpg_decode->p1_w = cfg->config.w;
jpg_decode->p1_h = cfg->config.h;
jpg_decode->scale_p1_w = ((jpg_decode->p1_w+3)/4)*4;
if(cfg->config.rotate)
{
jpg_decode->dec_y_offset = jpg_decode->p1_w*(jpg_decode->p1_h-1);
jpg_decode->dec_uv_offset = ((jpg_decode->scale_p1_w/2+3)/4)*4 * (jpg_decode->p1_h/2-1);
}
else
{
jpg_decode->dec_y_offset = 0;
jpg_decode->dec_uv_offset = 0;
}
cfg->msg->yuv_arg.y_off = jpg_decode->dec_y_offset;
cfg->msg->yuv_arg.uv_off = jpg_decode->dec_uv_offset;
cfg->msg->yuv_arg.y_size = jpg_decode->scale_p1_w*jpg_decode->p1_h;
}
break;
//这只scale的输入参数大小和输出参数大小
case JPG_DECODE_SET_IN_OUT_SIZE:
{
struct jpg_decode_cmd_s *cfg = (struct jpg_decode_cmd_s*)arg;
struct jpg_decode_s *jpg_decode = (struct jpg_decode_s*)s->priv;
scale_set_in_out_size(jpg_decode->scale_dev,cfg->in_out_size.in_w,cfg->in_out_size.in_h,cfg->in_out_size.out_w,cfg->in_out_size.out_h);
}
break;
//设置scale的步长,这里可以决定是否裁剪,如果step设置过大,到最后就不会有数据,解码的图片会补充0(黑色)
case JPG_DECODE_SET_STEP:
{
struct jpg_decode_cmd_s *cfg = (struct jpg_decode_cmd_s*)arg;
struct jpg_decode_s *jpg_decode = (struct jpg_decode_s*)s->priv;
scale_set_step(jpg_decode->scale_dev,cfg->step.in_w,cfg->step.in_h,cfg->step.out_w,cfg->step.out_h);
}
break;
case JPG_DECODE_READY:
{
struct jpg_decode_s *jpg_decode = (struct jpg_decode_s*)s->priv;
uint32 dst = (uint32)arg;
//scale_close(jpg_decode->scale_dev);
scale_set_out_yaddr(jpg_decode->scale_dev,(uint32)dst);
scale_set_out_uaddr(jpg_decode->scale_dev,(uint32)dst+jpg_decode->scale_p1_w*jpg_decode->p1_h);
scale_set_out_vaddr(jpg_decode->scale_dev,(uint32)dst+jpg_decode->scale_p1_w*jpg_decode->p1_h+jpg_decode->scale_p1_w*jpg_decode->p1_h/4);
//os_printf("scale_p1_w:%d\tp1_w:%d\tp1_h:%d\r\n",jpg_decode->scale_p1_w,jpg_decode->p1_w,jpg_decode->p1_h);
//如果空间不够,就重新申请把
if(32+jpg_decode->p1_w*2+(32*SRAMBUF_WLEN*4*3)/2 > jpg_decode->scalerbuf_size)
{
if(jpg_decode->scaler2buf)
{
STREAM_LIBC_FREE(jpg_decode->scaler2buf);
}
//默认一定申请到,没有做申请失败的处理
jpg_decode->scaler2buf = STREAM_LIBC_MALLOC(32+jpg_decode->p1_w*2+(32*SRAMBUF_WLEN*4*3)/2);
jpg_decode->scalerbuf_size = 32+jpg_decode->p1_w*2+(32*SRAMBUF_WLEN*4*3)/2;
}
scale_set_line_buf_addr(jpg_decode->scale_dev,(uint32)jpg_decode->scaler2buf);
scale_set_srambuf_wlen(jpg_decode->scale_dev,SRAMBUF_WLEN);
scale_set_start_addr(jpg_decode->scale_dev,0,0);
if(!jpg_decode->is_register_isr)
{
scale_request_irq(jpg_decode->scale_dev,FRAME_END,(scale_irq_hdl )&stream_jpg_decode_scale2_done,(uint32)jpg_decode);
scale_request_irq(jpg_decode->scale_dev,INBUF_OV,(scale_irq_hdl )&stream_jpg_decode_scale2_ov_isr,(uint32)jpg_decode);
jpg_request_irq(jpg_decode->jpg_dev,(jpg_irq_hdl )&stream_jpg_decode_done,JPG_IRQ_FLAG_JPG_DONE,(void *)jpg_decode);
jpg_request_irq(jpg_decode->jpg_dev,(jpg_irq_hdl )&stream_jpg_decode_err,JPG_IRQ_FLAG_ERROR,(void *)jpg_decode);
jpg_decode->is_register_isr = 1;
}
jpg_decode_target(jpg_decode->jpg_dev,1);
break;
}
case JPG_DECODE_START:
{
struct jpg_decode_s *jpg_decode = (struct jpg_decode_s*)s->priv;
uint32 dst = (uint32)arg;
jpg_decode->hardware_ready = 0;
jpg_decode->last_decode_time = os_jiffies();
scale_open(jpg_decode->scale_dev);
jpg_decode_photo(jpg_decode->jpg_dev,dst);
}
break;
default:
break;
}
return res;
}
static int32 jpg_decode_work(struct os_work *work)
{
struct jpg_decode_s *jpg_de = (struct jpg_decode_s *)work;
struct data_structure *data_s;
//static int count = 0;
//检测解码模块是否完成或者超时代表解码失败
//能进去,模块需要reset或者已经解码完毕,可以重新去解码,否则只能慢慢等超时或者硬件解码完成
if(jpg_de->hardware_err || jpg_de->hardware_ready || os_jiffies() - jpg_de->last_decode_time > 1000)
{
if(jpg_de->current_data_s && (os_jiffies() - jpg_de->last_decode_time > 1000))
{
//解码可能失败了
_os_printf("decode failed1\n");
jpg_de->hardware_ready = 1;
//无论是完成还是失败,都要释放这张图片了
free_data(jpg_de->parent_data_s);
jpg_de->parent_data_s = NULL;
//不再解码了
force_del_data(jpg_de->current_data_s);
jpg_de->current_data_s = NULL;
//这里最好将硬件模块停止
}
//解码异常
else if(jpg_de->hardware_err)
{
_os_printf("decode failed2\n");
jpg_de->hardware_err = 0;
jpg_de->hardware_ready = 1;
if(jpg_de->current_data_s)
{
//无论是完成还是失败,都要释放这张图片了
free_data(jpg_de->parent_data_s);
jpg_de->parent_data_s = NULL;
//不再解码了
force_del_data(jpg_de->current_data_s);
jpg_de->current_data_s = NULL;
}
}
//解码完成,检查有解码完的数据需要发送
else if(jpg_de->current_data_s)
{
//os_printf("%s:%d\tbuf:%X\n",__FUNCTION__,__LINE__,get_stream_real_data(jpg_de->current_data_s));
data_s = jpg_de->current_data_s;
set_stream_data_time(data_s,get_stream_data_timestamp(jpg_de->parent_data_s));
data_s->magic = jpg_de->parent_data_s->magic;
//os_printf("%s:%d\tdata_s:%X\tdata->data:%X\n",__FUNCTION__,__LINE__,data_s,data_s->data);
_os_printf("&");
send_data_to_stream(data_s);
//无论是完成还是失败,都要释放这张图片了
free_data(jpg_de->parent_data_s);
jpg_de->parent_data_s = NULL;
jpg_de->current_data_s = NULL;
}
//硬件可用,但是current_data_s不存在
//有两种可能
//一、没有需要解码的图片
//二、有需要解码的图片,但是data_s没有申请成功或者内存空间不足以去解码图片数据
else
{
}
//这里没有解码的图片,尝试去看看有没有需要解码图片
if(!jpg_de->parent_data_s)
{
//接收图片,尝试看看是否要解码
jpg_de->parent_data_s = recv_real_data(jpg_de->s);
//需要解码,然后申请空间
if(jpg_de->parent_data_s)
{
//os_printf("parent_data_s:%X\n",jpg_de->parent_data_s);
goto start_decode;
}
//不需要解码
else
{
goto not_decode;
}
}
else
{
goto start_decode;
}
//开始尝试解码
start_decode:
data_s = get_src_data_f(jpg_de->s);
//申请到data_s,申请解码空间
if(data_s)
{
//struct jpg_decode_arg_s *msg = (struct jpg_decode_arg_s *)jpg_de->parent_data_s->priv;
struct jpg_decode_arg_s *msg = (struct jpg_decode_arg_s *)stream_self_cmd_func(jpg_de->parent_data_s->s,JPG_DECODE_ARG,(uint32_t)jpg_de->parent_data_s);
//没有找到,代表发送过来的不是jpg或者说对应参数没有配置,不解码
if(msg)
{
//为data_s申请解码空间,申请不到下次申请
data_s->data = (uint8 *)STREAM_MALLOC(msg->yuv_arg.out_w*msg->yuv_arg.out_h*3/2);
if(data_s->data)
{
struct jpg_decode_cmd_s cfg;
memset(&cfg,0,sizeof(struct jpg_decode_cmd_s));
//提前配置好data的长度
set_stream_real_data_len(data_s,msg->yuv_arg.out_w*msg->yuv_arg.out_h*3/2);
memcpy(data_s->priv,msg,sizeof(struct jpg_decode_arg_s));
//将data_s的struct jpg_yuv_decode_msg_s接入cfg,后面有参数改动
cfg.msg = (struct jpg_decode_arg_s*)data_s->priv;
cfg.config.w = msg->yuv_arg.out_w;
cfg.config.h = msg->yuv_arg.out_h;
cfg.config.rotate = msg->rotate;
stream_self_cmd_func(jpg_de->s,JPG_DECODE_SET_CONFIG,(uint32_t)&cfg);
cfg.in_out_size.in_w = msg->decode_w;
cfg.in_out_size.in_h = msg->decode_h;
cfg.in_out_size.out_w = msg->yuv_arg.out_w;
cfg.in_out_size.out_h = msg->yuv_arg.out_h;
stream_self_cmd_func(jpg_de->s,JPG_DECODE_SET_IN_OUT_SIZE,(uint32_t)&cfg);
cfg.in_out_size.in_w = msg->decode_w;
cfg.in_out_size.in_h = msg->decode_h;
cfg.in_out_size.out_w = msg->step_w;
cfg.in_out_size.out_h = msg->step_h;
data_s->type = SET_DATA_TYPE(YUV,GET_DATA_TYPE2(jpg_de->parent_data_s->type));
void *ptr = get_stream_real_data(jpg_de->parent_data_s);
uint32_t len = get_stream_real_data_len(jpg_de->parent_data_s);
sys_dcache_clean_range((uint32_t*)((uint32_t)(ptr) & CACHE_CIR_INV_ADDR_Msk), len + ((uint32_t)(ptr)-((uint32_t)(ptr) & CACHE_CIR_INV_ADDR_Msk)));
stream_self_cmd_func(jpg_de->s,JPG_DECODE_SET_STEP,(uint32_t)&cfg);
stream_self_cmd_func(jpg_de->s,JPG_DECODE_READY,(uint32_t)get_stream_real_data(data_s));
stream_self_cmd_func(jpg_de->s,JPG_DECODE_START,(uint32_t)ptr);
jpg_de->current_data_s = data_s;
}
else
{
force_del_data(data_s);
data_s = NULL;
}
}
else
{
os_printf("%s:%d\tdecode msg isn't normal\tmsg:%X\tname:%s\n",__FUNCTION__,__LINE__,msg,jpg_de->parent_data_s->s->name);
force_del_data(data_s);
data_s = NULL;
}
}
}
not_decode:
os_run_work_delay(work, 1);
return 0;
}
//这个流主要是为了解码流使用
//为了充分利用psram，这里需要申请psram,可能效率会低,但是空间不至于容易浪费
//只有在极端情况下才会需要比原来更多的内存,但可以通过错开时间使用,来缓解这个问题
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 jpg_decode_s *jpg_de = (struct jpg_decode_s*)STREAM_LIBC_ZALLOC(sizeof(struct jpg_decode_s));
jpg_de->jpg_dev = (struct jpg_device *)dev_get(HG_JPG1_DEVID);
jpg_de->scale_dev = (struct scale_device *)dev_get(HG_SCALE2_DEVID);
//通过命令去申请空间以及配置寄存器,如果停止,则需要释放空间
jpg_de->scaler2buf = NULL;
s->priv = (void*)jpg_de;
register_stream_self_cmd_func(s,jpg_decode_stream_cmd_func);
stream_data_dis_mem_custom(s);
streamSrc_bind_streamDest(s,R_VIDEO_P0);
streamSrc_bind_streamDest(s,R_VIDEO_P1);
streamSrc_bind_streamDest(s,R_JPG_TO_RGB);
streamSrc_bind_streamDest(s,R_YUV_TO_JPG);
//启动一个workqueueu去接收图片,然后将图片解码成yuv数据,并且发送出去
jpg_de->s = s;
OS_WORK_INIT(&jpg_de->work, jpg_decode_work, 0);
os_run_work_delay(&jpg_de->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->priv = (struct jpg_decode_arg_s *)STREAM_LIBC_ZALLOC(sizeof(struct jpg_decode_arg_s));
}
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:
{
struct data_structure *data = (struct data_structure *)priv;
//os_printf("%s:%d\tdata:%X\n",__FUNCTION__,__LINE__,data);
if(GET_DATA_TYPE1(data->type) != JPEG)
{
res = 1;
break;
}
}
break;
case STREAM_DATA_FREE_END:
break;
//数据发送完成,可以选择唤醒对应的任务
case STREAM_SEND_DATA_FINISH:
break;
case STREAM_SEND_DATA_START:
{
}
break;
case STREAM_DATA_DESTORY:
{
struct data_structure *data = (struct data_structure *)priv;
if(data->priv)
{
STREAM_LIBC_FREE(data->priv);
}
}
break;
case STREAM_CLOSE_ENTER:
{
struct jpg_decode_s *jpg_de = (struct jpg_decode_s *)s->priv;
os_work_cancle2(&jpg_de->work, 1);
}
break;
case STREAM_CLOSE_EXIT:
{
struct jpg_decode_s *jpg_de = (struct jpg_decode_s *)s->priv;
os_work_cancle2(&jpg_de->work, 1);
//关闭硬件
scale_close(jpg_de->scale_dev);
jpg_close(jpg_de->jpg_dev);
if(jpg_de->parent_data_s)
{
os_printf("parent_data_s:%X\n",jpg_de->parent_data_s);
free_data(jpg_de->parent_data_s);
jpg_de->parent_data_s = NULL;
}
if(jpg_de->current_data_s)
{
os_printf("parent_data_s:%X\n",jpg_de->current_data_s);
force_del_data(jpg_de->current_data_s);
jpg_de->current_data_s = NULL;
}
//释放line_buf
STREAM_LIBC_FREE(jpg_de->scaler2buf);
}
break;
case STREAM_MARK_GC_END:
{
STREAM_LIBC_FREE(s->priv);
}
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:
{
struct jpg_decode_s *jpg_de = (struct jpg_decode_s*)STREAM_LIBC_ZALLOC(sizeof(struct jpg_decode_s));
jpg_de->jpg_dev = (struct jpg_device *)dev_get(HG_JPG1_DEVID);
jpg_de->scale_dev = (struct scale_device *)dev_get(HG_SCALE2_DEVID);
//通过命令去申请空间以及配置寄存器,如果停止,则需要释放空间
jpg_de->scaler2buf = NULL;
jpg_de->scalerbuf_size = 0;
s->priv = (void*)jpg_de;
register_stream_self_cmd_func(s,jpg_decode_stream_cmd_func);
stream_data_dis_mem_custom(s);
//启动一个workqueueu去接收图片,然后将图片解码成yuv数据,并且发送出去
jpg_de->s = s;
OS_WORK_INIT(&jpg_de->work, jpg_decode_work, 0);
os_run_work_delay(&jpg_de->work, 1);
}
break;
case STREAM_OPEN_FAIL:
break;
case STREAM_DATA_DIS:
{
struct data_structure *data = (struct data_structure *)priv;
data->priv = (struct jpg_decode_arg_s *)STREAM_LIBC_ZALLOC(sizeof(struct jpg_decode_arg_s));
os_printf("jpg decode data->priv:%x\n",data->priv);
}
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:
{
struct data_structure *data = (struct data_structure *)priv;
//os_printf("%s:%d\tdata:%X\n",__FUNCTION__,__LINE__,data);
if(GET_DATA_TYPE1(data->type) != JPEG)
{
res = 1;
break;
}
}
break;
case STREAM_DATA_FREE_END:
break;
//数据发送完成,可以选择唤醒对应的任务
case STREAM_SEND_DATA_FINISH:
break;
case STREAM_SEND_DATA_START:
{
}
break;
case STREAM_DATA_DESTORY:
{
struct data_structure *data = (struct data_structure *)priv;
if(data->priv)
{
STREAM_LIBC_FREE(data->priv);
}
}
break;
case STREAM_CLOSE_ENTER:
{
struct jpg_decode_s *jpg_de = (struct jpg_decode_s *)s->priv;
os_work_cancle2(&jpg_de->work, 1);
}
break;
case STREAM_CLOSE_EXIT:
{
struct jpg_decode_s *jpg_de = (struct jpg_decode_s *)s->priv;
os_work_cancle2(&jpg_de->work, 1);
//关闭硬件
scale_close(jpg_de->scale_dev);
jpg_close(jpg_de->jpg_dev);
if(jpg_de->parent_data_s)
{
os_printf("parent_data_s:%X\n",jpg_de->parent_data_s);
free_data(jpg_de->parent_data_s);
jpg_de->parent_data_s = NULL;
}
if(jpg_de->current_data_s)
{
os_printf("parent_data_s:%X\n",jpg_de->current_data_s);
force_del_data(jpg_de->current_data_s);
jpg_de->current_data_s = NULL;
}
//释放line_buf
STREAM_LIBC_FREE(jpg_de->scaler2buf);
jpg_de->scalerbuf_size = 0;
}
break;
case STREAM_MARK_GC_END:
{
STREAM_LIBC_FREE(s->priv);
}
break;
default:
//默认都返回成功
break;
}
return res;
}
stream *jpg_decode_stream(const char *name)
{
stream *s = open_stream_available(name,8,8,opcode_func,NULL);
return s;
}
//不是立刻绑定,动态绑定
stream *jpg_decode_stream_not_bind(const char *name)
{
stream *s = open_stream_available(name,8,8,opcode_func_not_bind,NULL);
return s;
}
sdk/app/decode/jpg_decode_stream.h
+14
View File
@@ -0,0 +1,14 @@
#ifndef __JPG_DECODE_STREAM_H__
#define __JPG_DECODE_STREAM_H__
enum jpg_decode_cmd_e
{
JPG_DECODE_SET_CONFIG = CUSTOM_STREAM_CMD +1, //配置w、h、rotate
JPG_DECODE_SET_IN_OUT_SIZE,
JPG_DECODE_SET_STEP,
JPG_DECODE_READY,
JPG_DECODE_START,
};
#endif
sdk/app/decode/read_jpg_file_demo.c
+176
View File
@@ -0,0 +1,176 @@
#include "sys_config.h"
#include "typesdef.h"
#include "dev.h"
#include "devid.h"
#include "stream_frame.h"
#include "utlist.h"
#include "osal/task.h"
#include "jpg_decode_stream.h"
#include "osal/string.h"
#include "osal_file.h"
#include "custom_mem/custom_mem.h"
void read_file_thread(void*d)
{
os_printf("%s:%d\n",__FUNCTION__,__LINE__);
stream *s = (stream *)d;
//struct data_structure *data;
void *fp = osal_fopen("0:0.jpg","rb");
uint32_t filesize = 0;
uint8_t *tmp = (uint8_t*)os_malloc(4096);
uint8_t *sd_buf = NULL;
uint32_t offset = 0;
uint32_t readlen;
if(fp)
{
filesize = osal_fsize(fp);
}
os_printf("%s:%d\ttmp:%X\n",__FUNCTION__,__LINE__,tmp);
if(filesize)
{
sd_buf = (uint8_t*)custom_malloc_psram(filesize);
if(sd_buf)
{
while(filesize)
{
if(filesize < 4096)
{
readlen = osal_fread(tmp,filesize,1,fp);
}
else
{
readlen = osal_fread(tmp,4096,1,fp);
}
if(readlen)
{
hw_memcpy(sd_buf+offset,tmp,readlen);
}
offset += readlen;
filesize -= readlen;
}
}
}
while(1)
{
struct data_structure *data = get_src_data_f(s);
if(data)
{
os_printf("data:%X\n",data);
if(sd_buf)
{
data->data = (void*)custom_malloc_psram(offset);
if(data->data)
{
//配置显示的参数
struct jpg_decode_arg_s *msg = data->priv;
msg->yuv_arg.out_w = 320;
msg->yuv_arg.out_h = 240;
msg->rotate = 0;
msg->decode_w = 640;
msg->decode_h = 480;
msg->step_w = 320;
msg->step_h = 240;
hw_memcpy(data->data,sd_buf,offset);
set_stream_real_data_len(data,offset);
os_printf("%s:%d\n",__FUNCTION__,__LINE__);
data->type = SET_DATA_TYPE(JPEG,JPEG_FILE);
int success = send_data_to_stream(data);
os_printf("success:%d\n",success);
data = NULL;
}
else
{
force_del_data(data);
}
}
else
{
force_del_data(data);
}
}
os_sleep_ms(1000);
}
}
static int opcode_func(stream *s,void *priv,int opcode)
{
int res = 0;
switch(opcode)
{
case STREAM_OPEN_ENTER:
break;
case STREAM_OPEN_EXIT:
{
s->priv = priv;
stream_data_dis_mem_custom(s);
streamSrc_bind_streamDest(s,S_JPG_DECODE);
enable_stream(s,1);
//创建一个线程
os_task_create("aaa", read_file_thread, s, OS_TASK_PRIORITY_NORMAL, 0, NULL, 1024);
}
break;
case STREAM_OPEN_FAIL:
break;
case STREAM_DATA_DIS:
{
struct data_structure *data = (struct data_structure *)priv;
data->priv = (void *)custom_zalloc(sizeof(struct jpg_decode_arg_s));
data->data = NULL;
}
break;
case STREAM_DATA_FREE:
{
struct data_structure *data = (struct data_structure *)priv;
os_printf("%s:%d\tdata:%X\n",__FUNCTION__,__LINE__,data);
if(data->data)
{
custom_free_psram(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:
{
struct data_structure *data = (struct data_structure *)priv;
if(data->priv)
{
custom_free(data->priv);
}
}
break;
default:
//默认都返回成功
break;
}
return res;
}
void *read_jpg_file_stream()
{
os_printf("%s:%d\n",__FUNCTION__,__LINE__);
stream *s = open_stream_available("read_jpg", 3, 0, opcode_func,NULL);
os_printf("%s:%d\n",__FUNCTION__,__LINE__);
return s;
}
sdk/app/decode/recv_jpg_yuv_demo.c
+147
View File
@@ -0,0 +1,147 @@
#include "sys_config.h"
#include "typesdef.h"
#include "dev.h"
#include "devid.h"
#include "stream_frame.h"
#include "utlist.h"
#include "osal/work.h"
#include "osal_file.h"
#include "jpg_decode_stream.h"
#include "recv_jpg_yuv_demo.h"
#include "custom_mem/custom_mem.h"
static stream *lvgl_yuv_s = NULL;
static int32 yuv_recv_work(struct os_work *work)
{
static int flag = 0;
struct data_structure *data_s;
struct recv_jpg_yuv_s *yuv = (struct recv_jpg_yuv_s *)work;
data_s = recv_real_data(yuv->s);
if(data_s)
{
if(!flag)
{
flag = 0;
//写卡
{
void *fp = osal_fopen("0:0.yuv","wb");
os_printf("%s:%d\tfp:%X\n",__FUNCTION__,__LINE__,fp);
if(fp)
{
osal_fwrite(get_stream_real_data(data_s),1,get_stream_real_data_len(data_s),fp);
osal_fclose(fp);
}
}
}
free_data(data_s);
}
os_run_work_delay(work, 1);
return 0;
}
static uint32_t lvgl_yuv_cmd_func(stream *s,int opcode,uint32_t arg)
{
uint32_t res = 0;
switch(opcode)
{
case SET_LVGL_YUV_UPDATE_TIME:
{
struct recv_jpg_yuv_s *yuv = (struct recv_jpg_yuv_s *)s->priv;
yuv->show_photo_time_start = arg;
break;
}
case GET_LVGL_YUV_UPDATE_TIME:
{
struct recv_jpg_yuv_s *yuv = (struct recv_jpg_yuv_s *)s->priv;
res = yuv->show_photo_time_start;
break;
}
default:
break;
}
return res;
}
static int opcode_func(stream *s,void *priv,int opcode)
{
int res = 0;
switch(opcode)
{
case STREAM_OPEN_ENTER:
break;
case STREAM_OPEN_EXIT:
{
s->priv = (void*)custom_zalloc(sizeof(struct recv_jpg_yuv_s));
struct recv_jpg_yuv_s *yuv = (struct recv_jpg_yuv_s *)s->priv;
yuv->s = s;
register_stream_self_cmd_func(s,lvgl_yuv_cmd_func);
//启动一个workqueue去接收数据
//OS_WORK_INIT(&yuv->work, yuv_recv_work, 0);
//os_run_work_delay(&yuv->work, 1);
enable_stream(s,1);
}
break;
case STREAM_OPEN_FAIL:
break;
case STREAM_RECV_DATA_FINISH:
break;
//在发送到这个流的时候,进行数据包过滤
case STREAM_FILTER_DATA:
{
struct data_structure *data = (struct data_structure *)priv;
if(GET_DATA_TYPE1(data->type) != YUV)
{
res = 1;
break;
}
//先特殊处理一下某些帧不显示,遇到是需要转换rgb的,就不要接收
if(GET_DATA_TYPE2(data->type) == LVGL_JPEG_TO_RGB)
{
res = 1;
break;
}
if(!(GET_DATA_TYPE2(data->type)& YUV_P1))
{
res = 1;
break;
}
}
break;
//流接收后,数据包也要检查是否需要过滤或者是不是因为逻辑条件符合需要过滤
case STREAM_RECV_FILTER_DATA:
break;
default:
break;
}
return res;
}
stream *yuv_recv_stream(const char *name)
{
stream *s = open_stream_available(name,0,2,opcode_func,NULL);
lvgl_yuv_s = s;
return s;
}
//如果需要重新换页面,可以更新一下这个时间,可以保证旧的没有用的video数据不显示,保证显示最新的
void update_yuv_stream_time(uint32_t time)
{
if(lvgl_yuv_s)
{
stream_self_cmd_func(lvgl_yuv_s,SET_LVGL_YUV_UPDATE_TIME,(uint32_t)time);
}
}
sdk/app/decode/recv_jpg_yuv_demo.h
+21
View File
@@ -0,0 +1,21 @@
#ifndef __RECV_JPG_YUV_DEMO_H
#define __RECV_JPG_YUV_DEMO_H
#include "sys_config.h"
#include "typesdef.h"
#include "dev.h"
#include "devid.h"
#include "stream_frame.h"
#include "utlist.h"
#include "osal/work.h"
#include "jpg_decode_stream.h"
struct recv_jpg_yuv_s
{
struct os_work work;
stream *s;
struct data_structure *last_data_s;
uint32_t show_photo_time_start;
uint8_t enable; //使能
};
void update_yuv_stream_time(uint32_t time);
#endif
sdk/app/decode/yuv_stream.c
+115
View File
@@ -0,0 +1,115 @@
#include "sys_config.h"
#include "typesdef.h"
#include "dev.h"
#include "devid.h"
#include "stream_frame.h"
#include "utlist.h"
#include "osal/work.h"
#include "osal_file.h"
#include "jpg_decode_stream.h"
#include "recv_jpg_yuv_demo.h"
#include "custom_mem/custom_mem.h"
#include "yuv_stream.h"
static uint32_t yuv_stream_cmd_func(stream *s,int opcode,uint32_t arg)
{
uint32_t res = 0;
switch(opcode)
{
case SET_LVGL_YUV_UPDATE_TIME:
{
struct yuv_stream_s *yuv = (struct yuv_stream_s *)s->priv;
yuv->show_yuv_time_start = arg;
break;
}
case GET_LVGL_YUV_UPDATE_TIME:
{
struct yuv_stream_s *yuv = (struct yuv_stream_s *)s->priv;
res = yuv->show_yuv_time_start;
break;
}
default:
break;
}
return res;
}
static int opcode_func(stream *s,void *priv,int opcode)
{
int res = 0;
switch(opcode)
{
case STREAM_OPEN_ENTER:
break;
case STREAM_OPEN_EXIT:
{
s->priv = (void*)custom_zalloc(sizeof(struct yuv_stream_s));
struct yuv_stream_s *yuv = (struct yuv_stream_s *)s->priv;
yuv->last_data_s = NULL;
register_stream_self_cmd_func(s,yuv_stream_cmd_func);
enable_stream(s,1);
}
break;
case STREAM_OPEN_FAIL:
break;
case STREAM_RECV_DATA_FINISH:
break;
//在发送到这个流的时候,进行数据包过滤
case STREAM_FILTER_DATA:
{
struct data_structure *data = (struct data_structure *)priv;
if(GET_DATA_TYPE1(data->type) != YUV)
{
res = 1;
break;
}
if(!(GET_DATA_TYPE2(data->type)& YUV_P0))
{
res = 1;
break;
}
}
break;
//流接收后,数据包也要检查是否需要过滤或者是不是因为逻辑条件符合需要过滤
case STREAM_RECV_FILTER_DATA:
break;
case STREAM_CLOSE_EXIT:
{
struct yuv_stream_s *yuv = (struct yuv_stream_s *)s->priv;
//相当于已经不需要显示了,接收到对应帧的流需要主动释放该流
yuv->show_yuv_time_start = -1;
}
break;
case STREAM_MARK_GC_END:
{
struct yuv_stream_s *yuv = (struct yuv_stream_s *)s->priv;
if(yuv)
{
custom_free(yuv);
}
}
break;
default:
break;
}
return res;
}
stream *yuv_stream(const char *name)
{
stream *s = open_stream_available(name,0,2,opcode_func,NULL);
return s;
}
sdk/app/decode/yuv_stream.h
+19
View File
@@ -0,0 +1,19 @@
#ifndef __YUV_STREAM_H
#define __YUV_STREAM_H
#include "sys_config.h"
#include "typesdef.h"
#include "dev.h"
#include "devid.h"
#include "stream_frame.h"
#include "utlist.h"
#include "osal/work.h"
#include "jpg_decode_stream.h"
struct yuv_stream_s
{
struct data_structure *last_data_s;
uint32_t show_yuv_time_start;
uint8_t enable; //使能
};
stream *yuv_stream(const char *name);
#endif