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

rtos/code/application/source/cardv/Makefile

@@ -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 \

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

@@ -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 SF_NO_SD_SEND == ENABLE
-		if(gpio_getIntStatus(GPIO_INT_USBPLUGIN) || FALSE == (gpio_getPin(GPIO_CARD_DETECT) == 0 ? TRUE : FALSE))
+		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();

rtos/code/application/source/cardv/SrcCode/FastFlow/flow_preview.c

@@ -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;

rtos/code/application/source/cardv/SrcCode/PrjCfg_HUNTING_S550.h

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

rtos/code/application/source/cardv/SrcCode/System/sys_usrmem.c

@@ -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
+
+
+

rtos/code/application/source/cardv/SrcCode/System/sys_usrmem.h

@@ -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

rtos/code/application/source/cardv/SrcCode/UIApp/PhotoFast/PhotoFast.c

@@ -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) {

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

@@ -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
+            vos_perf_mark(&t2);
-		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);
-
-		{
-			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);
+                #if !PHOTOFAST_FAST_CLOSE
-                FileSys_FlushFile(fp);
+                    extern CHAR* PhotoFast_GetLastWriteFilePath(void);
-                FileSys_CloseFile(fp);
+                    char* file_path = PhotoFast_GetLastWriteFilePath();
-                #if HUNTING_CAMERA_MCU == ENABLE
+                #else
-                memset(tmp, '\0', sizeof(tmp));
+                    char file_path[NMC_TOTALFILEPATH_MAX_LEN];
-                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 */
+                    #if HUNTING_CAMERA_MCU == ENABLE
-                sf_file_thumb_cfg_fill(tmp, tmp2, queue_ele_in->jpg_thumb_size, SF_FILE_TYPE_PIC_SMALL);
+                        sprintf(tmp, "W%03ld%04ld.JPG", queue_ele_in->nextFolderID, queue_ele_in->nextFileID);
-                DBG_IND("PHOTO THUMB %s \n %s\n %s\n", tmp, tmp2,file_path);
+                        strncpy(file_path, tmp, strlen(queue_ele_in->file_path) - 1);
-                DBG_IND("%s:%d thumbfileSize:%d thumbfileName:%s thumbfilePath:%s\n", __FUNCTION__, __LINE__,queue_ele_in->jpg_thumb_size,tmp2,tmp);
+                        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,
-		DBG_DUMP("CB3 cost %lu ms(%lu , %lu , %lu)\n", 	
+            vos_perf_duration(t1, t2) / 1000,
-		vos_perf_duration(t1, t4) / 1000,
+            vos_perf_duration(t2, t3) / 1000,
-		vos_perf_duration(t1, t2) / 1000,
+            vos_perf_duration(t3, t4) / 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);