payton/nt9856x
Template
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

1.rtos增加mem存图；2.修改漏图问题

Browse Source
This commit is contained in:
payton 2023-11-16 09:43:45 +08:00
parent 33dec69bff
commit b8b50270f1
8 changed files with 414 additions and 78 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
rtos/code/application/source/cardv/Makefile
View File

@ -142,6 +142,7 @@ SRC = \
./SrcCode/System/SysStrg_CB.c \
./SrcCode/System/SysStrg_Exe.c \
./SrcCode/System/SysSensor_Exe.c \
./SrcCode/System/sys_usrmem.c \
./SrcCode/UIApp/UIAppObj.c \
./SrcCode/UIApp/ExifVendor.c \
./SrcCode/UIApp/Setup/UISetup_Exe.c \

7
rtos/code/application/source/cardv/SrcCode/Dx/565_HUNTING_EVB_LINUX_4G_S550/DxHunting.c
View File

@ -150,8 +150,11 @@ UINT32 DrvGPIO_GetPhotoMovieModeFromMonitor(void)
UIMenuStoreInfo *puiPara = sf_ui_para_get();
vos_perf_mark(&t1);
value = sf_get_power_on_mode();
if(gpio_getIntStatus(GPIO_INT_USBPLUGIN) || FALSE == (gpio_getPin(GPIO_CARD_DETECT) == 0 ? TRUE : FALSE))
#if SF_NO_SD_SEND == ENABLE
if(gpio_getIntStatus(GPIO_INT_USBPLUGIN) /*|| FALSE == (gpio_getPin(GPIO_CARD_DETECT) == 0 ? TRUE : FALSE)*/)
#else
if(gpio_getIntStatus(GPIO_INT_USBPLUGIN) || FALSE == (gpio_getPin(GPIO_CARD_DETECT) == 0 ? TRUE : FALSE))
#endif
{
g_uiBootMode = DX_HUNTING_MODE_OTHER;
Save_MenuInfo();

2
rtos/code/application/source/cardv/SrcCode/FastFlow/flow_preview.c
View File

@ -153,7 +153,7 @@ static HD_RESULT flowpreview_mem_relayout(void)
+VDO_CA_BUF_SIZE(CA_WIN_NUM_W, CA_WIN_NUM_H)
+VDO_LA_BUF_SIZE(LA_WIN_NUM_W, LA_WIN_NUM_H);
mem_cfg.pool_info[idx].blk_cnt = 6;
mem_cfg.pool_info[idx].blk_cnt = 7;
mem_cfg.pool_info[idx].ddr_id = DDR_ID0;
// config common pool (main)
// mem_cfg.pool_info[1].type = HD_COMMON_MEM_COMMON_POOL;

1
rtos/code/application/source/cardv/SrcCode/PrjCfg_HUNTING_S550.h
View File

@ -985,6 +985,7 @@
#ifndef ANR_FUNC
#define ANR_FUNC ENABLE
#endif
#define SF_NO_SD_SEND DISABLE
////////////////////sf end////////////////////////////////

264
rtos/code/application/source/cardv/SrcCode/System/sys_usrmem.c Normal file
View File

@ -0,0 +1,264 @@
#include "sys_usrmem.h"
#include "rtosfdt.h"
#include "libfdt.h"
#include "compiler.h"
#include <kwrap/error_no.h>
#include <kwrap/debug.h>
#include "MemCheck.h"
#include "hdal.h"
#if !defined(__FREERTOS)
#include <fcntl.h>
#include <stdio.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <stdio.h>
#include <unistd.h>
#endif
#if defined(__FREERTOS)
INT32 sys_usrmem_init(SYS_USRMEM* usrmem)
{
const void* fdt = fdt_get_base();
int nodeoffset = fdt_path_offset((const void*)fdt, SYS_USRMEM_NODE);
int len;
if(usrmem == NULL){
DBG_ERR("usrmem can't be null!\n");
return E_SYS;
}
usrmem->is_init = FALSE;
if(nodeoffset >= 0){
const unsigned long *nodep;
nodep = (const unsigned long *)fdt_getprop(fdt, nodeoffset, "reg", &len);
usrmem->used_size = 0;
usrmem->addr = be32_to_cpu(nodep[0]);
usrmem->size = be32_to_cpu(nodep[1]);
usrmem->hdr = (SYS_USRMEM_HDR*) usrmem->addr;
usrmem->hdr->photo_ofs = 0;
usrmem->hdr->photo_size = 0;
usrmem->hdr->photo_sum = 0;
usrmem->hdr->tag = SYS_USRMEM_TAG;
usrmem->used_size += sizeof(SYS_USRMEM_HDR);
usrmem->addr_photo = usrmem->addr + usrmem->used_size;
DBG_DUMP("usrmem addr = %lx, size = %lx, addr_hdr = %lx, addr_photo = %lx\n",
usrmem->addr,
usrmem->size,
usrmem->hdr ,
usrmem->addr_photo);
usrmem->is_init = TRUE;
return E_OK;
}
DBG_ERR("fdt node %s not found!\n", SYS_USRMEM_NODE);
return E_SYS;
}
INT32 sys_usrmem_write_photo(SYS_USRMEM* usrmem, UINT32 buf, UINT32 size)
{
if(usrmem == NULL){
DBG_ERR("usrmem can't be null!\n");
return E_SYS;
}
if(usrmem->addr_photo == 0){
DBG_ERR("address photo can't be null!\n");
return E_SYS;
}
if(buf == 0){
DBG_ERR("buf can't be null!\n");
return E_SYS;
}
if(size == 0){
DBG_ERR("size can't be zero!\n");
return E_SYS;
}
if(usrmem->is_init == FALSE){
DBG_ERR("usrmem is not init yet!\n");
return E_SYS;
}
memcpy((void*)usrmem->addr_photo, (void*)buf, size);
usrmem->hdr->photo_ofs = usrmem->used_size;
usrmem->hdr->photo_size = size;
usrmem->hdr->photo_sum = MemCheck_CalcCheckSum16Bit(usrmem->addr_photo, size);
usrmem->used_size += size;
hd_common_mem_flush_cache((void*)usrmem->addr, usrmem->used_size);
DBG_DUMP("photo addr:%lx, size:%lx, sum:%lx\n", usrmem->addr_photo, usrmem->hdr->photo_size, usrmem->hdr->photo_sum);
return E_OK;
}
#else
static void* usrmem_mmap(int fd, unsigned int mapped_size, off_t phy_addr)
{
void *map_base = NULL;
unsigned page_size = 0;
page_size = getpagesize();
map_base = mmap(NULL,
mapped_size,
PROT_READ | PROT_WRITE,
MAP_SHARED,
fd,
(phy_addr) & ~(off_t)(page_size - 1));
if (map_base == MAP_FAILED)
return NULL;
return map_base;
}
static int usrmem_munmap(void* map_base, unsigned int mapped_size)
{
if (munmap(map_base, mapped_size) == -1)
return -1;
return 0;
}
static int usrmem_init_dev(char* dev)
{
int fd = 0;
DBG_DUMP("open %s\n", dev);
fd = open(dev, O_RDWR | O_SYNC);
return fd;
}
INT32 sys_usrmem_init(SYS_USRMEM* usrmem)
{
const void* fdt = fdt_get_base();
int nodeoffset = fdt_path_offset((const void*)fdt, SYS_USRMEM_NODE);
int len;
if(usrmem == NULL){
DBG_ERR("usrmem can't be null!\n");
return E_SYS;
}
usrmem->is_init = FALSE;
if(nodeoffset >= 0){
const unsigned long *nodep;
nodep = (const unsigned long *)fdt_getprop(fdt, nodeoffset, "reg", &len);
usrmem->addr = be32_to_cpu(nodep[0]);
usrmem->size = be32_to_cpu(nodep[1]);
int fd = usrmem_init_dev("/dev/mem");
if(fd < 0){
DBG_ERR("open %s failed\n", "/dev/mem");
return E_SYS;
}
DBG_DUMP("usrmem addr:%lx size:%lx\n", usrmem->addr, usrmem->size);
void* va = usrmem_mmap(fd, usrmem->size ,usrmem->addr);
if(va){
usrmem->hdr = va;
usrmem->used_size = sizeof(SYS_USRMEM_HDR);
if(usrmem->hdr->tag == SYS_USRMEM_TAG){
DBG_DUMP("check tag ok, hdr ofs:%lx, size:%lx, sum:%lx\n",
usrmem->hdr->photo_ofs,
usrmem->hdr->photo_size,
usrmem->hdr->photo_sum);
usrmem->addr_photo = (UINT32)va + usrmem->hdr->photo_ofs;
DBG_DUMP("photo data = %lx\n", *((UINT32*)usrmem->addr_photo));
UINT32 sum = MemCheck_CalcCheckSum16Bit(usrmem->addr_photo, usrmem->hdr->photo_size);
usrmem->used_size += usrmem->hdr->photo_size;
if(sum == usrmem->hdr->photo_sum){
DBG_DUMP("checksum ok(%lx)\n", sum);
usrmem->is_init = TRUE;
return E_OK;
}
else{
DBG_ERR("checksum err(%lx)\n", sum);
}
}
else{
DBG_WRN("invalid usrmem hdr tag(%lx)!\n", usrmem->hdr->tag);
}
}
else{
DBG_ERR("mmap failed(addr:%lx size:%lx)\n", usrmem->addr, usrmem->size);
}
close(fd);
}
return E_SYS;
}
INT32 sys_usrmem_read_photo(SYS_USRMEM* usrmem, UINT32* addr, UINT32* size)
{
if(usrmem == NULL){
DBG_ERR("usrmem can't be null!\n");
return E_SYS;
}
if(usrmem->is_init == FALSE){
DBG_ERR("usrmem not init yet!\n");
return E_SYS;
}
if(addr == NULL || size == NULL){
DBG_ERR("addr & size can't be null!\n");
return E_SYS;
}
*addr = usrmem->addr_photo;
*size = usrmem->hdr->photo_size;
return E_OK;
}
INT32 sys_usrmem_hdr_uninit(SYS_USRMEM* usrmem)
{
if(usrmem == NULL ){
DBG_ERR("usrmem can't be null!\n");
return E_SYS;
}
if(!usrmem->addr && !usrmem->size){
DBG_ERR("addr & size can't be zero!\n");
return E_SYS;
}
return usrmem_munmap((void* )usrmem->addr, usrmem->size);;
}
#endif

41
rtos/code/application/source/cardv/SrcCode/System/sys_usrmem.h Normal file
View File

@ -0,0 +1,41 @@
#ifndef SYS_USRMEM_H
#define SYS_USRMEM_H
#include "kwrap/type.h"
#define SYS_USRMEM_NODE "/nvt_memory_cfg/usrmem"
#define SYS_USRMEM_TAG MAKEFOURCC('U','S','R','M')
typedef struct{
UINT32 tag;
UINT32 photo_ofs;
UINT32 photo_size;
UINT32 photo_sum;
} SYS_USRMEM_HDR;
typedef struct{
UINT32 addr;
UINT32 size;
UINT32 used_size;
SYS_USRMEM_HDR* hdr;
UINT32 addr_photo;
BOOL is_init;
} SYS_USRMEM;
INT32 sys_usrmem_init(SYS_USRMEM* usrmem);
#if defined(__FREERTOS)
INT32 sys_usrmem_write_photo(SYS_USRMEM* usrmem, UINT32 buf, UINT32 size);
#else
INT32 sys_usrmem_read_photo(SYS_USRMEM* usrmem, UINT32* addr, UINT32* size);
#endif
#endif

5
rtos/code/application/source/cardv/SrcCode/UIApp/PhotoFast/PhotoFast.c
View File

@ -1732,6 +1732,11 @@ THREAD_RETTYPE PhotoFast_FlowPreviewThread(void *arg)
}
else{
DBG_WRN("enq frame failed...\n");
/* release */
if ((hd_ret = hd_videoproc_release_out_buf(vprc_path, &video_frame))!= HD_OK) {
DBG_ERR("failed to hd_videoproc_release_out_buf, er=%d\n", (int)hd_ret);
goto exit;
}
}
if (g_u32PrvCapCnt >= max_cnt) {

171
rtos/code/application/source/cardv/SrcCode/UIApp/PhotoFast/PhotoFastSliceEncode.c
View File

@ -18,6 +18,7 @@
#include "DxHunting.h"
#include "UIAppPhoto_Param.h"
#include "DCF.h"
#include "sys_usrmem.h"
#if HUNTING_CAMERA_MCU == ENABLE
#include <sf_mcu.h>
#endif
@ -40,7 +41,7 @@
#define PHOTOFAST_SLICE_ENC_DBG_SCREENNAIL_JPG 0
#define PHOTOFAST_SLICE_ENC_DBG_THUMBNAIL_JPG 0
#define PHOTOFAST_SLICE_ENC_QUEUE12_MAX_SIZE 2
#define PHOTOFAST_SLICE_ENC_QUEUE12_MAX_SIZE 1
#define PHOTOFAST_SLICE_ENC_QUEUE23_MAX_SIZE 1
#if PHOTOFAST_SLICE_ENC_DBG_PRIMARY_JPG || PHOTOFAST_SLICE_ENC_DBG_SCREENNAIL_JPG || PHOTOFAST_SLICE_ENC_DBG_THUMBNAIL_JPG
@ -2074,7 +2075,7 @@ INT32 PhotoFast_SliceEncode_CB2(void* user_data)
if(PhotoFast_SliceEncode_Alloc_Buffer_Retry(
&slice_encode_primary_info->bs_buf_mem_info,
"slice_enc_primary",
10,
50,
100
) != E_OK){
goto EXIT;
@ -2245,7 +2246,9 @@ INT32 PhotoFast_SliceEncode_CB2(void* user_data)
param->cnt++;
if(param->cnt >= param->max_cnt)
break;
if(fastboot_wait_done_timeout(BOOT_INIT_FILESYSOK, 1) != E_OK){
goto EXIT;
}
} while(1);
EXIT:
@ -2310,95 +2313,113 @@ INT32 PhotoFast_SliceEncode_CB3(void* user_data)
* Output jpg file
******************************************************************/
extern INT32 PhotoFast_WriteFile(UINT32 Addr, UINT32 Size, UINT32 Fmt, UINT32 uiPathId, char* Path);
#if SF_NO_SD_SEND == ENABLE
if(fastboot_wait_done_timeout(BOOT_INIT_FILESYSOK, FASTBOOT_WAIT_FILESYS_TIMEOUT_MS) != E_OK || fastboot_wait_done_timeout(BOOT_INIT_FILENAMINGOK, FASTBOOT_WAIT_FILENAMING_TIMEOUT_MS) != E_OK){
if(fastboot_wait_done_timeout(BOOT_INIT_FILESYSOK, FASTBOOT_WAIT_FILESYS_TIMEOUT_MS) != E_OK){
DBG_WRN("filesys not ready, store data into mem\n");
SYS_USRMEM usrmem = {0};
if(sys_usrmem_init(&usrmem) == E_OK){
sys_usrmem_write_photo(
&usrmem,
(UINT32) queue_ele_in->jpg_combined_addr,
queue_ele_in->jpg_combined_size
);
}
}
else
#else
if(fastboot_wait_done_timeout(BOOT_INIT_FILESYSOK, FASTBOOT_WAIT_FILESYS_TIMEOUT_MS) != E_OK){
goto EXIT;
}
if(fastboot_wait_done_timeout(BOOT_INIT_FILENAMINGOK, FASTBOOT_WAIT_FILENAMING_TIMEOUT_MS) != E_OK){
goto EXIT;
}
#endif
{
vos_perf_mark(&t1);
vos_perf_mark(&t1);
#if !PHOTOFAST_FAST_CLOSE
PhotoFast_WriteFile(
(UINT32)queue_ele_in->jpg_combined_addr,
queue_ele_in->jpg_combined_size,
NAMERULE_FMT_JPG,
0,
0);
#else
PhotoFast_WriteFile(
(UINT32)queue_ele_in->jpg_combined_addr,
queue_ele_in->jpg_combined_size,
NAMERULE_FMT_JPG,
0,
queue_ele_in->file_path);
#endif
#if !PHOTOFAST_FAST_CLOSE
PhotoFast_WriteFile(
(UINT32)queue_ele_in->jpg_combined_addr,
queue_ele_in->jpg_combined_size,
NAMERULE_FMT_JPG,
0,
0);
#else
PhotoFast_WriteFile(
(UINT32)queue_ele_in->jpg_combined_addr,
queue_ele_in->jpg_combined_size,
NAMERULE_FMT_JPG,
0,
queue_ele_in->file_path);
#endif
vos_perf_mark(&t2);
vos_perf_mark(&t2);
{
char tmp[NMC_TOTALFILEPATH_MAX_LEN] = {'\0'};
#if !PHOTOFAST_FAST_CLOSE
extern CHAR* PhotoFast_GetLastWriteFilePath(void);
char* file_path = PhotoFast_GetLastWriteFilePath();
#else
char file_path[NMC_TOTALFILEPATH_MAX_LEN];
#if HUNTING_CAMERA_MCU == ENABLE
sprintf(tmp, "W%03ld%04ld.JPG", queue_ele_in->nextFolderID, queue_ele_in->nextFileID);
strncpy(file_path, tmp, strlen(queue_ele_in->file_path) - 1);
DBG_IND("last send file:%s\r\n", file_path);
#else
strncpy(file_path, FilePath, strlen(queue_ele_in->file_path) - 1);
#endif
#endif
#if HUNTING_CAMERA_MCU == ENABLE
char tmp2[64] = {'\0'};
#endif
#if HUNTING_CAMERA_MCU == ENABLE
snprintf(tmp, sizeof(tmp), "%s%s", PHOTO_THUMB_PATH, file_path); /* DCF 8.3 naming rule */
#else
UINT32 length = strlen(file_path);
snprintf(tmp, sizeof(tmp), "%s%s", PHOTO_THUMB_PATH, file_path + length - 12); /* DCF 8.3 naming rule */
snprintf(tmp + strlen(tmp) - 3, sizeof(tmp), "%s", "JPG");
#endif
DBG_IND("PHOTO THUMB %s\n", tmp);
vos_perf_mark(&t3);
if(FALSE == sf_is_card_full())
{
FST_FILE fp = FileSys_OpenFile(tmp, FST_CREATE_ALWAYS | FST_OPEN_WRITE);
char tmp[NMC_TOTALFILEPATH_MAX_LEN] = {'\0'};
FileSys_WriteFile(fp, (UINT8*)queue_ele_in->jpg_thumb_addr, &queue_ele_in->jpg_thumb_size, 0, NULL);
FileSys_FlushFile(fp);
FileSys_CloseFile(fp);
#if HUNTING_CAMERA_MCU == ENABLE
memset(tmp, '\0', sizeof(tmp));
snprintf(tmp, sizeof(tmp), "%s/%s", SF_SEND_LIST_DIR, file_path); /* DCF 8.3 naming rule */
snprintf(tmp2, sizeof(tmp2), "%s", file_path); /* DCF 8.3 naming rule */
sf_file_thumb_cfg_fill(tmp, tmp2, queue_ele_in->jpg_thumb_size, SF_FILE_TYPE_PIC_SMALL);
DBG_IND("PHOTO THUMB %s \n %s\n %s\n", tmp, tmp2,file_path);
DBG_IND("%s:%d thumbfileSize:%d thumbfileName:%s thumbfilePath:%s\n", __FUNCTION__, __LINE__,queue_ele_in->jpg_thumb_size,tmp2,tmp);
#if !PHOTOFAST_FAST_CLOSE
extern CHAR* PhotoFast_GetLastWriteFilePath(void);
char* file_path = PhotoFast_GetLastWriteFilePath();
#else
char file_path[NMC_TOTALFILEPATH_MAX_LEN];
#if HUNTING_CAMERA_MCU == ENABLE
sprintf(tmp, "W%03ld%04ld.JPG", queue_ele_in->nextFolderID, queue_ele_in->nextFileID);
strncpy(file_path, tmp, strlen(queue_ele_in->file_path) - 1);
DBG_IND("last send file:%s\r\n", file_path);
#else
strncpy(file_path, FilePath, strlen(queue_ele_in->file_path) - 1);
#endif
#endif
#if HUNTING_CAMERA_MCU == ENABLE
char tmp2[64] = {'\0'};
#endif
#if HUNTING_CAMERA_MCU == ENABLE
snprintf(tmp, sizeof(tmp), "%s%s", PHOTO_THUMB_PATH, file_path); /* DCF 8.3 naming rule */
#else
UINT32 length = strlen(file_path);
snprintf(tmp, sizeof(tmp), "%s%s", PHOTO_THUMB_PATH, file_path + length - 12); /* DCF 8.3 naming rule */
snprintf(tmp + strlen(tmp) - 3, sizeof(tmp), "%s", "JPG");
#endif
DBG_IND("PHOTO THUMB %s\n", tmp);
vos_perf_mark(&t3);
if(FALSE == sf_is_card_full())
{
FST_FILE fp = FileSys_OpenFile(tmp, FST_CREATE_ALWAYS | FST_OPEN_WRITE);
FileSys_WriteFile(fp, (UINT8*)queue_ele_in->jpg_thumb_addr, &queue_ele_in->jpg_thumb_size, 0, NULL);
FileSys_FlushFile(fp);
FileSys_CloseFile(fp);
#if HUNTING_CAMERA_MCU == ENABLE
memset(tmp, '\0', sizeof(tmp));
snprintf(tmp, sizeof(tmp), "%s/%s", SF_SEND_LIST_DIR, file_path); /* DCF 8.3 naming rule */
snprintf(tmp2, sizeof(tmp2), "%s", file_path); /* DCF 8.3 naming rule */
sf_file_thumb_cfg_fill(tmp, tmp2, queue_ele_in->jpg_thumb_size, SF_FILE_TYPE_PIC_SMALL);
DBG_IND("PHOTO THUMB %s \n %s\n %s\n", tmp, tmp2,file_path);
DBG_IND("%s:%d thumbfileSize:%d thumbfileName:%s thumbfilePath:%s\n", __FUNCTION__, __LINE__,queue_ele_in->jpg_thumb_size,tmp2,tmp);
#endif
}
}
}
vos_perf_mark(&t4);
vos_perf_mark(&t4);
DBG_DUMP("CB3 cost %lu ms(%lu , %lu , %lu)\n",
vos_perf_duration(t1, t4) / 1000,
vos_perf_duration(t1, t2) / 1000,
vos_perf_duration(t2, t3) / 1000,
vos_perf_duration(t3, t4) / 1000
);
DBG_DUMP("CB3 cost %lu ms(%lu , %lu , %lu)\n",
vos_perf_duration(t1, t4) / 1000,
vos_perf_duration(t1, t2) / 1000,
vos_perf_duration(t2, t3) / 1000,
vos_perf_duration(t3, t4) / 1000
);
}
/* check user bs buffer is freed */
if(queue_ele_in->mem_info_combined.va){
PhotoFast_SliceEncode_Free_Buffer(&queue_ele_in->mem_info_combined);