add missing file

middleware/v2/.gitignore

@@ -1,15 +1,8 @@
 *.d
 *.o
-*.a
-*.so
 *.dep
 *.dwo
 
-lib
-bin
-include
-tags
-
 *_asan
 sample/audio/sample_audio
 sample/audio/sample_audio_aec
@@ -48,5 +41,3 @@ modules/venc/vc/vcodec/codebase/sample/cvi_vcodec_version.h
 modules/venc/vc/jpeg/driver/include/version.h
 
 .vscode/settings.json
-
-modules/isp

middleware/v2/3rdparty/cli/include/cli.h

@@ -0,0 +1,96 @@
+#ifndef __CLIAPI_H__
+#define __CLIAPI_H__
+
+#ifdef __cplusplus
+#if __cplusplus
+extern "C" {
+#endif
+#endif /* __cplusplus */
+
+#define CLI_UART_SUPPORT 0x01
+#define CLI_TELNET_SUPPORT 0x02
+#define CLI_UART_CLIENT_SUPPORT 0x04
+
+
+#define DECLARE_TELNET_CLI_CMD_MACRO(name, child, Cbfunc, help, usermode) {     \
+(#name),                                                      \
+child,                                                      \
+Cbfunc,                                                     \
+(#help),                                                      \
+usermode,                                                   \
+0,                                                    \
+0,                                                   \
+0                                                    \
+}
+
+#define DECLARE_TELNET_CLI_CMD_MACRO_END() {              \
+(0),                                                   \
+(0),                                                   \
+(0),                                                   \
+(0),                                                   \
+(0),                                                   \
+(0),                                                    \
+(0),                                                   \
+(0)                                                   \
+}
+
+typedef enum{
+	DEBUG_EN_TRACE_NONE = 0, //always print
+	DEBUG_EN_TRACE_ERROR,
+	DEBUG_EN_TRACE_WARNING,
+	DEBUG_EN_TRACE_INFO,
+	DEBUG_EN_TRACE_BUTT
+} DEBUG_EN_LEVEL;
+
+typedef struct TELNET_CLI_S_COMMANDtag {
+	char *pcName;
+	struct TELNET_CLI_S_COMMANDtag *pChildren;
+	int (*pCallback)(int argc, char *argv[]);
+	char *pcCmdHelp;
+	int i32UserMode;
+	struct TELNET_CLI_S_COMMANDtag *next;
+	struct TELNET_CLI_S_COMMANDtag *parent;
+	struct TELNET_CLI_S_COMMANDtag *prev;
+} TELNET_CLI_S_COMMAND, *TELNET_CLI_S_COMMAND_PTR;
+
+// for_register_cmd
+typedef TELNET_CLI_S_COMMAND TELNET_S_CLICMD;
+
+#define DECLARE_CLI_CMD_MACRO(name, child, Cbfunc, help, usermode) \
+		DECLARE_TELNET_CLI_CMD_MACRO(name, child, Cbfunc, help, usermode)
+
+#define DECLARE_CLI_CMD_MACRO_END()   DECLARE_TELNET_CLI_CMD_MACRO_END()
+// end for_register_cmd
+
+extern void TelnetTracePrint(const DEBUG_EN_LEVEL enLevel, char *pcpathname,
+							const unsigned int u32Line, const char *fmt, ...);
+extern int RegisterCliCommand(void *pstCliCmd);
+extern void CliInit(int flag);
+extern void CliDeInit(void);
+
+
+#ifndef tcli_info
+#define tcli_info(fmt...) TelnetTracePrint(DEBUG_EN_TRACE_INFO, __FILE__, __LINE__, fmt)
+#endif
+
+#ifndef tcli_warning
+#define tcli_warning(fmt...) TelnetTracePrint(DEBUG_EN_TRACE_WARNING, __FILE__, __LINE__, fmt)
+#endif
+
+#ifndef tcli_error
+#define tcli_error(fmt...) TelnetTracePrint(DEBUG_EN_TRACE_ERROR, __FILE__, __LINE__, fmt)
+#endif
+
+
+//always print,can not be control
+#ifndef tcli_print
+#define tcli_print(fmt...) TelnetTracePrint(DEBUG_EN_TRACE_NONE, __FILE__, __LINE__, fmt)
+#endif
+
+
+#ifdef __cplusplus
+#if __cplusplus
+}
+#endif
+#endif /* __cplusplus */
+#endif

middleware/v2/3rdparty/cli/lib

@@ -0,0 +1 @@
+lib_musl_riscv64

middleware/v2/component/isp/.gitignore

@@ -1,4 +1,2 @@
 *.d
 *.o
-*.so
-*.a

middleware/v2/modules/bin/Makefile

@@ -0,0 +1,87 @@
+SHELL = /bin/bash
+ifeq ($(PARAM_FILE), )
+     PARAM_FILE:=../../Makefile.param
+     include $(PARAM_FILE)
+endif
+
+SDIR = $(PWD)/src
+SRCS := $(wildcard $(SDIR)/*.c)
+
+# 3rdparty lib
+OSS_MODULE_INSTALL_PATH = $(OUTPUT_DIR)/mw_$(SDK_VER)/cvitek_mw_sdk
+OSS_MODULE_INCLUDE_PATH = $(OSS_MODULE_INSTALL_PATH)/include
+OSS_MODULE_LIB_PATH = $(OSS_MODULE_INSTALL_PATH)/lib
+
+ISP_BIN_DIR = $(MW_PATH)/modules/isp/$(shell echo $(CHIP_ARCH) | tr A-Z a-z)/isp_bin/inc
+
+SRCS_ASM = $(wildcard $(SDIR)/*.S)
+INCS = -I$(MW_INC) -I$(KERNEL_INC) -I$(SYS_INC) -I$(VPU_INC) -I$(ISP_INC) -Iinclude
+INCS += -I$(SYS_INC) -I$(OSS_MODULE_INCLUDE_PATH)/cvi_json-c -I$(ISP_BIN_DIR) -I$(OSS_MODULE_INCLUDE_PATH)/cvi_miniz
+OBJS = $(SRCS:.c=.o)
+OBJS_ASM = $(SRCS_ASM:.S=.o)
+DEPS = $(SRCS:.c=.d)
+
+TARGET_A = $(MW_LIB)/libcvi_bin.a
+TARGET_SO = $(MW_LIB)/libcvi_bin.so
+
+EXTRA_CFLAGS = $(INCS) -fpack-struct=8
+EXTRA_CFLAGS += -DMMF_VERSION=\"$(shell git describe --always)\"
+EXTRA_CFLAGS += -DSDK_VER=\"$(SDK_VER)\"
+EXTRA_CFLAGS += -DISP_COMMIT=\"$(shell git rev-parse --short HEAD)\"
+EXTRA_CFLAGS += -DISP_GERRIT=\"$(shell git log -n1 | grep Reviewed-on | tail -n1 | sed "s/.*\///g")\"
+ifeq ($(MULTI_PROCESS_SUPPORT), 1)
+EXTRA_CFLAGS += -DRPC_MULTI_PROCESS
+endif
+
+.PHONY : clean all prepare_3rdparty_module
+all : prepare_3rdparty_module $(TARGET_A) $(TARGET_SO)
+
+OSS_BUILD_SRCIPT = $(TOP_DIR)/oss/run_build.sh
+OSS_TARBALL_PATH = $(OUTPUT_DIR)/tpu_$(SDK_VER)/third_party
+OSS_TARBALL_CVI_JSONC_PATH = $(OSS_TARBALL_PATH)/cvi-json-c.tar.gz
+OSS_TARBALL_CVI_MINIZ_PATH = $(OSS_TARBALL_PATH)/cvi-miniz.tar.gz
+OSS_MODULE_LIB_CVI_JSONC_CHECK_PATH = $(OSS_MODULE_LIB_PATH)/libcvi_json-c*
+OSS_MODULE_LIB_CVI_MINIZ_CHECK_PATH = $(OSS_MODULE_LIB_PATH)/libcvi_miniz*
+
+prepare_3rdparty_module:
+# cvi_json-c
+ifeq "$(wildcard $(OSS_MODULE_LIB_CVI_JSONC_CHECK_PATH))" ""
+ifeq "$(wildcard $(OSS_TARBALL_CVI_JSONC_PATH))" ""
+	$(error libcvi_json-c source tarball not exist, please run build_3rd_party first!!)
+endif
+	@mkdir -p $(OSS_MODULE_INSTALL_PATH)
+	@$(OSS_BUILD_SRCIPT) -n cvi-json-c -e -t "$(OSS_TARBALL_PATH)" -i "$(OSS_MODULE_INSTALL_PATH)"
+endif
+
+# cvi_miniz
+ifeq "$(wildcard $(OSS_MODULE_LIB_CVI_MINIZ_CHECK_PATH))" ""
+ifeq "$(wildcard $(OSS_TARBALL_CVI_MINIZ_PATH))" ""
+	$(error libcvi_miniz source tarball not exist, please run build_3rd_party first!!)
+endif
+	@mkdir -p $(OSS_MODULE_INSTALL_PATH)
+	@$(OSS_BUILD_SRCIPT) -n cvi-miniz -e -t "$(OSS_TARBALL_PATH)" -i "$(OSS_MODULE_INSTALL_PATH)"
+endif
+
+$(SDIR)/%.o: $(SDIR)/%.c
+	@$(CC) $(DEPFLAGS) $(CFLAGS) $(EXTRA_CFLAGS) -o $@ -c $<
+	@echo [$(notdir $(CC))] $(notdir $@)
+
+$(SDIR)/%.o: $(SDIR)/%.S
+	$(CC) $(DEPFLAGS) $(CFLAGS) $(EXTRA_CFLAGS) -o $@ -c $<
+	@echo [$(notdir $(CC))] $(notdir $@)
+
+$(TARGET_A): $(OBJS) $(OBJS_ASM)
+	@$(AR) $(ARFLAGS) $(TARGET_A) $(OBJS) $(OBJS_ASM)
+	@echo -e $(YELLOW)[LINK]$(END)[$(notdir $(AR))] $(notdir $(TARGET_A))
+	@echo "$$AR_MRI" | $(AR) -M
+
+$(TARGET_SO): $(OBJS) $(OBJS_ASM)
+	@$(LD) $(LDFLAGS) $(EXTRA_LDFLAGS) -o $(TARGET_SO) --start-group $(OBJS) $(OBJS_ASM) $(LIBS) --end-group
+	@echo -e $(GREEN)[LINK]$(END)[$(notdir $(LD))] $(notdir $(TARGET_SO))
+	@$(STRIP) $(TARGET_SO)
+
+clean:
+	@rm -f $(OBJS) $(OBJS_ASM) $(DEPS) $(TARGET_A) $(TARGET_SO)
+	@rm -rf $(OSS_MODULE_INSTALL_PATH)
+
+-include $(DEPS)

middleware/v2/modules/bin/include/md5.h

@@ -0,0 +1,67 @@
+#ifndef _MD5_H_
+#define _MD5_H_
+
+#include <stdint.h>
+
+#define MD5_STRING_LEN (32 + 1)
+
+typedef int BOOL;
+typedef unsigned char Uint8;
+typedef unsigned short Uint16;
+typedef unsigned int Uint32;
+typedef char Int8;
+typedef short Int16;
+typedef int Int32;
+
+#define osal_memset(ptr, val, size) memset((ptr), (val), (size))
+#define osal_memcpy(dst, src, size) memcpy((dst), (src), (size))
+
+#ifdef PLATFORM_QNX
+#include <sys/stat.h>
+#endif
+
+#define MATCH_OR_MISMATCH(_expected, _value, _ret)                             \
+	((_ret = (_expected == _value)) ? "MATCH" : "MISMATCH")
+
+#if defined(WIN32) || defined(WIN64)
+/*
+ *	( _MSC_VER => 1200 )     6.0     vs6
+ *	( _MSC_VER => 1310 )     7.1     vs2003
+ *	( _MSC_VER => 1400 )     8.0     vs2005
+ *	( _MSC_VER => 1500 )     9.0     vs2008
+ *	( _MSC_VER => 1600 )    10.0     vs2010
+ */
+#if (_MSC_VER == 1200)
+#define strcasecmp stricmp
+#define strncasecmp strnicmp
+#else
+#define strcasecmp _stricmp
+#define strncasecmp _strnicmp
+#endif
+#define inline _inline
+#if (_MSC_VER == 1600)
+#define strdup _strdup
+#endif
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+#define MD5_DIGEST_LENGTH 16
+
+typedef struct MD5state_st {
+	Uint32 A, B, C, D;
+	Uint32 Nl, Nh;
+	Uint32 data[16];
+	Uint32 num;
+} MD5_CTX;
+
+void calcute_md5_value(const uint8_t *src, size_t len, Uint8 *result);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* _MD5_ */
+

middleware/v2/modules/bin/include/rw_json.h

@@ -0,0 +1,24 @@
+#ifndef _RW_JSON_H
+#define _RW_JSON_H
+
+#include <linux/cvi_type.h>
+#include "cvi_bin.h"
+#include <linux/cvi_common.h>
+
+
+typedef CVI_S32 (*pfn_cvi_bin_getbinsize)(CVI_U32 *size);
+typedef CVI_S32 (*pfn_cvi_bin_getparamfrombin)(CVI_U8 *addr, CVI_U32 size);
+typedef CVI_S32 (*pfn_cvi_bin_setparamtobin)(FILE *fp);
+typedef CVI_S32(*pfn_cvi_bin_setparamtobuf)(unsigned char *buffer);
+#ifndef DISABLE_PQBIN_JSON
+typedef CVI_S32 (*pfn_cvi_json_getparamfrombuf)(const char *buffer, enum CVI_BIN_SECTION_ID id);
+typedef CVI_S32 (*pfn_cvi_json_setparamtobuf)(signed char **buffer, enum CVI_BIN_SECTION_ID id, CVI_S32 *len);
+
+CVI_S32 CVI_JSON_LoadParamFromBuffer(enum CVI_BIN_SECTION_ID id, CVI_U8 *buf,
+				     pfn_cvi_json_getparamfrombuf pFuncgetParam);
+CVI_S32 CVI_JSON_SaveParamToBuffer(unsigned char *buffer, enum CVI_BIN_SECTION_ID id, CVI_JSON_INFO *pJsonInfo,
+				   pfn_cvi_json_setparamtobuf pFuncsetParam, CVI_U32 u32FreeSpaceSize);
+CVI_S32 CVI_JSON_SaveParamToFile(FILE *fp, enum CVI_BIN_SECTION_ID id, CVI_JSON_INFO *pJsonInfo,
+				 pfn_cvi_json_setparamtobuf pFuncsetParam);
+#endif
+#endif

middleware/v2/modules/bin/include/vo_bin.h

@@ -0,0 +1,25 @@
+#ifndef _VO_BIN_H
+#define _VO_BIN_H
+
+#include <linux/cvi_type.h>
+#include "cvi_bin.h"
+#include <linux/cvi_common.h>
+#include <linux/cvi_comm_vo.h>
+
+#ifndef UNUSED
+#define UNUSED(x) ((void)(x))
+#endif
+
+CVI_S32 vo_bin_getbinsize(CVI_U32 *size);
+CVI_S32 vo_bin_getparamfrombin(CVI_U8 *addr, CVI_U32 size);
+CVI_S32 vo_bin_setparamtobuf(CVI_U8 *buffer);
+CVI_S32 vo_bin_setparamtobin(FILE *fp);
+#ifndef DISABLE_PQBIN_JSON
+CVI_S32 vo_json_getParamFromJsonbuffer(const char *buffer, enum CVI_BIN_SECTION_ID id);
+CVI_S32 vo_json_setParamToJsonbuffer(CVI_S8 **buffer, enum CVI_BIN_SECTION_ID id, CVI_S32 *len);
+#endif
+
+VO_BIN_INFO_S *get_vo_bin_info_addr(void);
+CVI_U32 get_vo_bin_guardmagic_code(void);
+
+#endif

middleware/v2/modules/bin/include/vo_json_struct.h

@@ -0,0 +1,22 @@
+#ifndef _VO_JSON_STRUCT_H
+#define _VO_JSON_STRUCT_H
+
+#ifdef __cplusplus
+#if __cplusplus
+extern "C" {
+#endif
+#endif /* End of #ifdef __cplusplus */
+
+#include <linux/cvi_comm_vo.h>
+#include "cvi_json_struct_comm.h"
+
+void VO_GAMMA_INFO_S_JSON(int r_w_flag, JSON*j, char *key, VO_GAMMA_INFO_S*data);
+void VO_BIN_INFO_S_JSON(int r_w_flag, JSON *j, char *key, VO_BIN_INFO_S *data);
+
+#ifdef __cplusplus
+#if __cplusplus
+}
+#endif
+#endif /* End of #ifdef __cplusplus */
+
+#endif

middleware/v2/modules/bin/include/vpss_bin.h

@@ -0,0 +1,38 @@
+#ifndef _VPSS_BIN_H
+#define _VPSS_BIN_H
+
+#include <linux/cvi_type.h>
+#include "cvi_base.h"
+
+
+#ifdef __cplusplus
+#if __cplusplus
+extern "C" {
+#endif
+#endif /* End of #ifdef __cplusplus */
+
+#ifndef UNUSED
+#define UNUSED(x) (void)(x)
+#endif
+#ifndef DISABLE_PQBIN_JSON
+CVI_S32 vpss_json_getParamFromJsonbuffer(const char *buffer, enum CVI_BIN_SECTION_ID id);
+CVI_S32 vpss_json_setParamToJsonbuffer(CVI_S8 **buffer, enum CVI_BIN_SECTION_ID id, CVI_S32 *len);
+#endif
+CVI_S32 vpss_bin_getbinsize(CVI_U32 *size);
+CVI_S32 vpss_bin_getparamfrombin(CVI_U8 *addr, CVI_U32 size);
+
+CVI_S32 vpss_bin_setparamtobuf(CVI_U8 *buffer);
+CVI_S32 vpss_bin_setparamtobin(FILE *fp);
+
+VPSS_BIN_DATA *get_vpssbindata_addr(void);
+CVI_BOOL get_loadbin_state(void);
+
+
+
+#ifdef __cplusplus
+#if __cplusplus
+}
+#endif
+#endif /* End of #ifdef __cplusplus */
+
+#endif

middleware/v2/modules/bin/include/vpss_json_struct.h

@@ -0,0 +1,22 @@
+#ifndef _VPSS_JSON_STRUCT_H
+#define _VPSS_JSON_STRUCT_H
+
+#ifdef __cplusplus
+#if __cplusplus
+extern "C" {
+#endif
+#endif /* End of #ifdef __cplusplus */
+
+#include "cvi_json_struct_comm.h"
+#include "cvi_base.h"
+#include "cvi_vpss.h"
+
+void VPSS_PARAMETER_BUFFER_JSON(int r_w_flag, JSON *j, char *key, VPSS_PARAMETER_BUFFER *data);
+
+#ifdef __cplusplus
+#if __cplusplus
+}
+#endif
+#endif /* End of #ifdef __cplusplus */
+
+#endif

middleware/v2/modules/bin/src/cvi_bin.c

@@ -0,0 +1,817 @@
+#include <sys/stat.h>
+#include "stdlib.h"
+#include "cvi_bin.h"
+#include "cvi_vi.h"
+#include <linux/cvi_comm_sys.h>
+#include <linux/cvi_comm_vi.h>
+#include "rw_json.h"
+#include "isp_bin.h"
+#include "vpss_bin.h"
+#include "md5.h"
+#include "vo_bin.h"
+
+#define MAGIC_NUMBER 0x1835 /*the macro is used as magic number and can't be modified!*/
+
+//following info is V1.0 and V1.1 bin header field. difference of V1.0 and V1.1 is end of  V1.1's file that
+//contains the whole file PQbin's md5 value.
+
+/***The following macro comes from module/bin/cv18xx/isp_bin/src/isp_bin.c***/
+//CVI_BIN_EXTRA_S.Desc[624-1023] 400 bytes
+//[pqbin md5 50] + [reserved 50]
+//[tool version 40] + [isp commitId 10] + [sensorNum 5] + [sensorName1 55] + [sensorName2 55]
+//[sensorName3 55]  + [sensorName4 55] + [isp branch 20] + [version 4] + [generate mode - A:auto M:Manual 1]
+#define PQBIN_VERSION_V10 "V1.0"
+#define PQBIN_VERSION_V11 "V1.1"
+
+#define DESC_SIZE 624
+#define BIN_MD5_SIZE 50
+#define PQBIN_RESERVE_SIZE 50
+#define TOOLVERSION_SIZE 40
+#define BIN_COMMIT_SIZE 10
+#define SENSORNUM_SIZE 5
+#define SENSORNAME_SIZE 55
+#define BIN_GERRIT_SIZE 20
+#define PQBINVERSION_SIZE 4
+#define PQBINCREATE_MODE_SIZE 1
+/****************************************************************************/
+struct BIN_BUF_INFO {
+	CVI_U32 u32BlkSize[CVI_BIN_ID_MAX];
+	CVI_U32 u32BinParaSize;
+	CVI_U32 u32JsonParaSize;
+	CVI_U32 u32ParaTotalSize;
+	CVI_U32 u32SensorNumber;
+	CVI_CHAR achBinVersion[PQBINVERSION_SIZE + 1];
+	CVI_CHAR achBinMode[PQBINCREATE_MODE_SIZE + 1];
+	CVI_CHAR achBinMD5Code[BIN_MD5_SIZE + 1];
+	CVI_CHAR achTotalParaMD5Value[MD5_STRING_LEN];
+	CVI_BOOL bNewVerisonMatch; /*it's not match new version*/
+};
+
+static struct BIN_BUF_INFO g_stBinBufInfo = {0};
+static CVI_BOOL g_bUseOldLoadAPI = CVI_TRUE;
+
+static char userBinName[WDR_MODE_MAX][BIN_FILE_LENGTH] = {
+	"/mnt/cfg/param/cvi_sdr_bin", "/mnt/cfg/param/cvi_sdr_bin",
+	"/mnt/cfg/param/cvi_sdr_bin", "/mnt/cfg/param/cvi_wdr_bin",
+	"/mnt/cfg/param/cvi_wdr_bin", "/mnt/cfg/param/cvi_wdr_bin",
+	"/mnt/cfg/param/cvi_wdr_bin", "/mnt/cfg/param/cvi_wdr_bin",
+	"/mnt/cfg/param/cvi_wdr_bin", "/mnt/cfg/param/cvi_wdr_bin",
+	"/mnt/cfg/param/cvi_wdr_bin", "/mnt/cfg/param/cvi_wdr_bin" };
+static CVI_S32 _setBinNameImp(WDR_MODE_E wdrMode, const CVI_CHAR *binName);
+static CVI_S32 _getBinNameImp(CVI_CHAR *binName);
+static CVI_S32 check_is_register_id(enum CVI_BIN_SECTION_ID id);
+static CVI_S32 get_file_size(FILE *fp, CVI_U32 *size);
+static CVI_S32 id_is_valid_IspID(enum CVI_BIN_SECTION_ID id);
+static CVI_BOOL check_bin_file_is_new_version(CVI_CHAR *pchVersion);
+static CVI_S32 write_md5_value_to_buf(CVI_U8 *buf, CVI_U32 u32BufSize);
+static CVI_S32 check_sensor_num_is_exceeded(enum CVI_BIN_SECTION_ID id);
+
+static pfn_cvi_bin_getbinsize getBinSizeFunc[CVI_BIN_ID_MAX] = {
+	header_bin_getBinSize, /*CVI_BIN_ID_HEADER*/
+	isp_bin_getBinSize_p0, /*CVI_BIN_ID_ISP0*/
+	isp_bin_getBinSize_p1, /*CVI_BIN_ID_ISP1*/
+	isp_bin_getBinSize_p2, /*CVI_BIN_ID_ISP2*/
+	isp_bin_getBinSize_p3, /*CVI_BIN_ID_ISP3*/
+	vpss_bin_getbinsize,	/*CVI_BIN_ID_VPSS*/
+	NULL, /*CVI_BIN_ID_VDEC*/
+	NULL, /*CVI_BIN_ID_VENC*/
+	vo_bin_getbinsize, /*CVI_BIN_ID_VO*/
+};
+static pfn_cvi_bin_getparamfrombin getParamFromBinFunc[CVI_BIN_ID_MAX] = {
+	header_bin_getBinParam, /*CVI_BIN_ID_HEADER*/
+	isp_bin_getBinParam_p0, /*CVI_BIN_ID_ISP0*/
+	isp_bin_getBinParam_p1, /*CVI_BIN_ID_ISP1*/
+	isp_bin_getBinParam_p2, /*CVI_BIN_ID_ISP2*/
+	isp_bin_getBinParam_p3, /*CVI_BIN_ID_ISP3*/
+	vpss_bin_getparamfrombin, /*CVI_BIN_ID_VPSS*/
+	NULL, /*CVI_BIN_ID_VDEC*/
+	NULL, /*CVI_BIN_ID_VENC*/
+	vo_bin_getparamfrombin, /*CVI_BIN_ID_VO*/
+};
+static pfn_cvi_bin_setparamtobin setParamToBinFunc[CVI_BIN_ID_MAX] = {
+	header_bin_setBinParam, /*CVI_BIN_ID_HEADER*/
+	isp_bin_setBinParam_p0, /*CVI_BIN_ID_ISP0*/
+	isp_bin_setBinParam_p1, /*CVI_BIN_ID_ISP1*/
+	isp_bin_setBinParam_p2, /*CVI_BIN_ID_ISP2*/
+	isp_bin_setBinParam_p3, /*CVI_BIN_ID_ISP3*/
+	vpss_bin_setparamtobin,	/*CVI_BIN_ID_VPSS*/
+	NULL, /*CVI_BIN_ID_VDEC*/
+	NULL, /*CVI_BIN_ID_VENC*/
+	vo_bin_setparamtobin, /*CVI_BIN_ID_VO*/
+};
+static pfn_cvi_bin_setparamtobuf setParamToBufFunc[CVI_BIN_ID_MAX] = {
+	header_bin_setBinParambuf, /*CVI_BIN_ID_HEADER*/
+	isp_bin_setBinParambuf_p0, /*CVI_BIN_ID_ISP0*/
+	isp_bin_setBinParambuf_p1, /*CVI_BIN_ID_ISP1*/
+	isp_bin_setBinParambuf_p2, /*CVI_BIN_ID_ISP2*/
+	isp_bin_setBinParambuf_p3, /*CVI_BIN_ID_ISP3*/
+	vpss_bin_setparamtobuf,	/*CVI_BIN_ID_VPSS*/
+	NULL, /*CVI_BIN_ID_VDEC*/
+	NULL, /*CVI_BIN_ID_VENC*/
+	vo_bin_setparamtobuf, /*CVI_BIN_ID_VO*/
+};
+#ifndef DISABLE_PQBIN_JSON
+static pfn_cvi_json_getparamfrombuf getParamFromJsonBuf[CVI_BIN_ID_MAX] = {
+	NULL, /*CVI_BIN_ID_HEADER*/
+	isp_json_getParamFromJsonbuffer, /*CVI_BIN_ID_ISP0*/
+	isp_json_getParamFromJsonbuffer, /*CVI_BIN_ID_ISP1*/
+	isp_json_getParamFromJsonbuffer, /*CVI_BIN_ID_ISP2*/
+	isp_json_getParamFromJsonbuffer, /*CVI_BIN_ID_ISP3*/
+	vpss_json_getParamFromJsonbuffer, /*CVI_BIN_ID_VPSS*/
+	NULL, /*CVI_BIN_ID_VDEC*/
+	NULL, /*CVI_BIN_ID_VENC*/
+	vo_json_getParamFromJsonbuffer, /*CVI_BIN_ID_VO*/
+};
+static pfn_cvi_json_setparamtobuf setParamToJsonBuf[CVI_BIN_ID_MAX] = {
+	NULL, /*CVI_BIN_ID_HEADER*/
+	isp_json_setParamToJsonbuffer, /*CVI_BIN_ID_ISP0*/
+	isp_json_setParamToJsonbuffer, /*CVI_BIN_ID_ISP1*/
+	isp_json_setParamToJsonbuffer, /*CVI_BIN_ID_ISP2*/
+	isp_json_setParamToJsonbuffer, /*CVI_BIN_ID_ISP3*/
+	vpss_json_setParamToJsonbuffer, /*CVI_BIN_ID_VPSS*/
+	NULL, /*CVI_BIN_ID_VDEC*/
+	NULL, /*CVI_BIN_ID_VENC*/
+	vo_json_setParamToJsonbuffer, /*CVI_BIN_ID_VO*/
+};
+#endif
+static CVI_S32 _isSectionIdValid(enum CVI_BIN_SECTION_ID id)
+{
+	CVI_S32 ret = CVI_SUCCESS;
+
+	if ((id < CVI_BIN_ID_MIN) || (id >= CVI_BIN_ID_MAX)) {
+		ret = CVI_FAILURE;
+	}
+
+	return ret;
+}
+
+static CVI_S32 get_file_size(FILE *fp, CVI_U32 *size)
+{
+	CVI_S32 ret = CVI_SUCCESS;
+
+	fseek(fp, 0L, SEEK_END);
+	*size = ftell(fp);
+	rewind(fp);
+
+	return ret;
+}
+
+static struct BIN_BUF_INFO *get_current_buf_info(void)
+{
+	return &g_stBinBufInfo;
+}
+
+static CVI_S32 get_bin_Info_from_buf(CVI_U8 *buf, struct BIN_BUF_INFO *pstBufInfo)
+{
+	CVI_S32 ret = CVI_SUCCESS;
+	CVI_BIN_HEADER *pstHeader = (CVI_BIN_HEADER *)buf;
+	CVI_JSON_HEADER *pstJsonHeader = NULL;
+	CVI_CHAR *pchDesc = (CVI_CHAR *)pstHeader->extraInfo.Desc;
+	CVI_U32 u32BinSize = 0, u32JsonSize = 0;
+	CVI_U32 u32SensorNum = 0;
+	CVI_BOOL bBlkSizeInvalid = CVI_FALSE;
+	CVI_CHAR achSensorNum[SENSORNUM_SIZE];
+
+	/*get sensor number,version and mode from buffer.*/
+	memset(achSensorNum, 0, SENSORNUM_SIZE);
+	memset(pstBufInfo->achBinVersion, 0, sizeof(pstBufInfo->achBinVersion));
+	memset(pstBufInfo->achBinMode, 0, sizeof(pstBufInfo->achBinMode));
+	memset(pstBufInfo->achBinMD5Code, 0, sizeof(pstBufInfo->achBinMD5Code));
+	pchDesc += DESC_SIZE;
+	strncpy(pstBufInfo->achBinMD5Code, pchDesc, BIN_MD5_SIZE);
+	pchDesc += BIN_MD5_SIZE;
+	pchDesc += PQBIN_RESERVE_SIZE;
+	pchDesc += TOOLVERSION_SIZE;
+	pchDesc += BIN_COMMIT_SIZE;
+	strncpy(achSensorNum, pchDesc, SENSORNUM_SIZE);
+	pstBufInfo->u32SensorNumber = (CVI_U32)atoi(achSensorNum);
+	pchDesc += SENSORNUM_SIZE;
+	pchDesc += SENSORNAME_SIZE * VI_MAX_PIPE_NUM;
+	pchDesc += BIN_GERRIT_SIZE;
+	strncpy(pstBufInfo->achBinVersion, pchDesc, PQBINVERSION_SIZE);
+	pchDesc += PQBINVERSION_SIZE;
+	strncpy(pstBufInfo->achBinMode, pchDesc, PQBINCREATE_MODE_SIZE);
+	if (check_bin_file_is_new_version(pstBufInfo->achBinVersion)) {
+		pstBufInfo->bNewVerisonMatch = CVI_TRUE;
+	} else {
+		pstBufInfo->bNewVerisonMatch = CVI_FALSE;
+		for (CVI_U32 idx = CVI_BIN_ID_MIN; idx < CVI_BIN_ID_MAX; idx++) {
+			if (id_is_valid_IspID(idx) == CVI_SUCCESS) {
+				bBlkSizeInvalid = pstHeader->size[idx];
+				if (bBlkSizeInvalid) {
+					u32SensorNum++;
+				}
+			}
+		}
+		pstBufInfo->u32SensorNumber = u32SensorNum;
+	}
+
+	/*get bin size total size.*/
+	for (CVI_U32 idx = CVI_BIN_ID_MIN; idx < CVI_BIN_ID_MAX; idx++) {
+		if ((getBinSizeFunc[idx] != NULL) && (check_sensor_num_is_exceeded(idx) == CVI_SUCCESS)) {
+			pstBufInfo->u32BlkSize[idx] = pstHeader->size[idx];
+			u32BinSize += pstHeader->size[idx];
+		}
+	}
+
+	/*get json size total size.*/
+	if (check_bin_file_is_new_version(pstBufInfo->achBinVersion)) {
+		pstJsonHeader = (CVI_JSON_HEADER *)(buf + u32BinSize);
+		for (CVI_U32 idx = CVI_BIN_ID_MIN; idx < CVI_BIN_ID_MAX; idx++) {
+			if ((getBinSizeFunc[idx] != NULL) && (check_sensor_num_is_exceeded(idx)) == CVI_SUCCESS) {
+				u32JsonSize += pstJsonHeader->size[idx].u32CompreSize;
+			}
+		}
+	}
+
+	/*set bufinfo struct.*/
+	pstBufInfo->u32BinParaSize = u32BinSize;
+	pstBufInfo->u32JsonParaSize = u32JsonSize;
+	pstBufInfo->u32ParaTotalSize = u32BinSize + u32JsonSize;
+	if (strncmp(pstBufInfo->achBinVersion, PQBIN_VERSION_V11, PQBINVERSION_SIZE) >= 0) {
+		strncpy(pstBufInfo->achTotalParaMD5Value,
+					(CVI_CHAR *)buf + pstBufInfo->u32ParaTotalSize, MD5_STRING_LEN);
+		pstBufInfo->u32ParaTotalSize += MD5_STRING_LEN;
+	}
+
+	return ret;
+}
+
+static CVI_S32 id_is_valid_IspID(enum CVI_BIN_SECTION_ID id)
+{
+	if ((id <= CVI_BIN_ID_ISP3) && (id >= CVI_BIN_ID_ISP0)) {
+		return CVI_SUCCESS;
+	}
+
+	return CVI_FAILURE;
+}
+
+static CVI_S32 check_sensor_num_is_exceeded(enum CVI_BIN_SECTION_ID id)
+{
+	CVI_S32 ret = CVI_SUCCESS;
+	CVI_U32 u32CurSensorNum = id - CVI_BIN_ID_ISP0 + 1;
+	struct BIN_BUF_INFO *pstBufInfo = get_current_buf_info();
+
+	if (id_is_valid_IspID(id) == CVI_SUCCESS) {
+		if (u32CurSensorNum > pstBufInfo->u32SensorNumber) {
+			ret = CVI_BIN_SENSORNUM_ERROR;
+		}
+	}
+
+	return ret;
+}
+
+static CVI_S32 check_is_register_id(enum CVI_BIN_SECTION_ID id)
+{
+	CVI_U32 u32DevNum = 0;
+
+	if (id_is_valid_IspID(id) == CVI_SUCCESS) {
+		CVI_VI_GetDevNum(&u32DevNum);
+		if (id - CVI_BIN_ID_ISP0 >= u32DevNum) {
+			return CVI_FAILURE;
+		}
+	}
+	return CVI_SUCCESS;
+}
+/* Static function */
+static CVI_S32 _setBinNameImp(WDR_MODE_E wdrMode, const CVI_CHAR *binName)
+{
+	if (binName == NULL) {
+		CVI_TRACE_SYS(CVI_DBG_WARN, "binName is NULL\n");
+		return CVI_FAILURE;
+	}
+
+	CVI_U32 len = (CVI_U32)strlen(binName);
+
+	if (len >= BIN_FILE_LENGTH) {
+		CVI_TRACE_SYS(CVI_DBG_WARN, "Set bin name failed, strlen(%u) >= %d!\n", len, BIN_FILE_LENGTH);
+		return CVI_FAILURE;
+	}
+
+	strncpy(userBinName[wdrMode], binName, BIN_FILE_LENGTH);
+
+	return CVI_SUCCESS;
+}
+
+static CVI_S32 _getBinNameImp(CVI_CHAR *binName)
+{
+	if (binName == NULL) {
+		CVI_TRACE_SYS(CVI_DBG_WARN, "binName is NULL\n");
+		return CVI_FAILURE;
+	}
+
+	VI_DEV_ATTR_S pstDevAttr;
+	WDR_MODE_E wdrMode;
+
+	CVI_VI_GetDevAttr(0, &pstDevAttr);
+	wdrMode = pstDevAttr.stWDRAttr.enWDRMode;
+
+	sprintf(binName, "%s", userBinName[wdrMode]);
+
+	return CVI_SUCCESS;
+}
+
+static CVI_BOOL check_bin_file_is_new_version(CVI_CHAR *pchVersion)
+{
+	if (strncmp(pchVersion, PQBIN_VERSION_V10, strlen(PQBIN_VERSION_V10)) >= 0) {
+		return CVI_TRUE;
+	} else {
+		return CVI_FALSE;
+	}
+}
+
+static CVI_S32 check_bin_file_validity(CVI_U8 *buf, CVI_U32 u32DataLen)
+{
+	CVI_S32 ret = CVI_SUCCESS;
+	CVI_U8 au8Md5Value[MD5_STRING_LEN] = { 0 };
+	CVI_BIN_HEADER *pstHeader = (CVI_BIN_HEADER *)buf;
+	struct BIN_BUF_INFO *pstBufInfo = get_current_buf_info();
+
+	if (pstHeader->chipId != MAGIC_NUMBER) {
+		ret = CVI_BIN_FILE_ERROR;
+		CVI_TRACE_SYS(CVI_DBG_ERR, "PQbin file isn't valid!\n");
+		goto FINISH_HANDLER;
+	}
+	/*Get PQbin information from buf.*/
+	get_bin_Info_from_buf(buf, pstBufInfo);
+
+	/*calcute md5 of buf. if u32DataLen is 0, it's old loading param API. */
+	if (u32DataLen != 0) {
+		if (strncmp(pstBufInfo->achBinVersion, PQBIN_VERSION_V11, PQBINVERSION_SIZE) >= 0) {
+			calcute_md5_value(buf, u32DataLen - MD5_STRING_LEN, au8Md5Value);
+			if (strncmp((char *)au8Md5Value, (char *)pstBufInfo->achTotalParaMD5Value,
+				MD5_STRING_LEN) != 0) {
+				ret = CVI_BIN_DATA_ERR;
+				CVI_TRACE_SYS(CVI_DBG_ERR, "Data of PQbin file isn't normal!\n");
+			}
+		}
+	}
+
+FINISH_HANDLER:
+	return ret;
+}
+#ifndef DISABLE_PQBIN_JSON
+static CVI_S32 get_json_para_from_buffer(enum CVI_BIN_SECTION_ID id, CVI_U8 *buf)
+{
+	CVI_S32 ret = CVI_SUCCESS;
+	struct BIN_BUF_INFO *pstBufInfo = get_current_buf_info();
+
+	if (buf == NULL) {
+		ret = CVI_BIN_NULL_POINT;
+		return ret;
+	}
+
+	/*check that json is valid or not in cur file.*/
+	if (pstBufInfo->bNewVerisonMatch != CVI_TRUE) {
+		ret = CVI_BIN_NOJSON_ERROR;
+		CVI_TRACE_SYS(CVI_DBG_WARN, "Json is invalid in current PQBin file!\n");
+		goto FINISH_HANDLER;
+	}
+
+	/*load para from json.*/
+	ret = CVI_JSON_LoadParamFromBuffer(id, buf, getParamFromJsonBuf[id]);
+	if (ret != CVI_SUCCESS) {
+		CVI_TRACE_SYS(CVI_DBG_ERR, "Load Json failed!\n");
+		goto FINISH_HANDLER;
+	}
+
+FINISH_HANDLER:
+	return ret;
+}
+#endif
+static CVI_S32 get_file_md5_value(FILE *fp, CVI_U8 *md5_value)
+{
+	CVI_U32 u32FileSize = 0;
+	CVI_U8 *buf = NULL;
+	CVI_U32 u32TempLen = 0;
+	CVI_S32 ret = CVI_SUCCESS;
+
+	get_file_size(fp, &u32FileSize);
+	buf = (CVI_U8 *)malloc(u32FileSize);
+	if (buf == NULL) {
+		ret = CVI_BIN_MALLOC_ERR;
+		CVI_TRACE_SYS(CVI_DBG_WARN, "calcute md5: Allocate memory fail\n");
+		goto ERROR_HANDLER;
+	}
+	u32TempLen = fread(buf, u32FileSize, 1, fp);
+	if (u32TempLen <= 0) {
+		CVI_TRACE_SYS(CVI_DBG_WARN, "calcute md5: read data to buff fail!\n");
+		ret = CVI_BIN_READ_ERROR;
+		goto ERROR_HANDLER;
+	}
+	calcute_md5_value(buf, u32FileSize, md5_value);
+
+ERROR_HANDLER:
+	if (buf != NULL) {
+		free(buf);
+	}
+	return ret;
+}
+
+static CVI_S32 write_md5_value_to_file(FILE *fp)
+{
+	CVI_S32 ret = CVI_SUCCESS;
+	CVI_U32 u32TempLen = 0;
+	CVI_U8 au8Md5Value[MD5_STRING_LEN] = { 0 };
+
+	ret = get_file_md5_value(fp, au8Md5Value);
+	fseek(fp, 0L, SEEK_END);
+	u32TempLen = fwrite(au8Md5Value, MD5_STRING_LEN, 1, fp);
+	if (u32TempLen != 1) {
+		ret = CVI_BIN_UPDATE_ERROR;
+		CVI_TRACE_SYS(CVI_DBG_WARN, "Write md5 to end of file fail!\n");
+	}
+
+	return ret;
+}
+
+static CVI_S32 write_md5_value_to_buf(CVI_U8 *buf, CVI_U32 u32BufSize)
+{
+	CVI_S32 ret = CVI_SUCCESS;
+	CVI_U8 au8Md5Value[MD5_STRING_LEN] = { 0 };
+	CVI_U32 u32ValidDataLen = u32BufSize - MD5_STRING_LEN;
+
+	calcute_md5_value(buf, u32ValidDataLen, au8Md5Value);
+	memcpy(buf + u32ValidDataLen, au8Md5Value, MD5_STRING_LEN);
+
+	return ret;
+}
+
+CVI_U32 CVI_BIN_GetBinTotalLen(void)
+{
+	CVI_BIN_HEADER stHeader = { 0 };
+	CVI_U32 u32ParaTotalSize = 0;
+	CVI_JSON_HEADER stJsonHeader = { 0 };
+
+	/*get size of json and bin content.*/
+	for (CVI_U32 idx = CVI_BIN_ID_MIN; idx < CVI_BIN_ID_MAX; idx++) {
+		if (idx == CVI_BIN_ID_HEADER) {
+			stJsonHeader.size[CVI_BIN_ID_HEADER].u32InitSize = sizeof(CVI_JSON_HEADER);
+			stJsonHeader.size[CVI_BIN_ID_HEADER].u32CompreSize = sizeof(CVI_JSON_HEADER);
+		} else {
+			#ifndef DISABLE_PQBIN_JSON
+			if ((getBinSizeFunc[idx] != NULL) && (check_is_register_id(idx) == CVI_SUCCESS)) {
+				CVI_JSON_SaveParamToBuffer(NULL, idx, &stJsonHeader.size[idx], setParamToJsonBuf[idx],
+				0);
+			}
+			#endif
+		}
+	}
+
+	for (CVI_U32 idx = CVI_BIN_ID_MIN; idx < CVI_BIN_ID_MAX; idx++) {
+		if ((getBinSizeFunc[idx] != NULL) && (check_is_register_id(idx) == CVI_SUCCESS)) {
+			getBinSizeFunc[idx]((CVI_U32 *)&(stHeader.size[idx]));
+		}
+		u32ParaTotalSize += stJsonHeader.size[idx].u32CompreSize + stHeader.size[idx];
+	}
+
+	/*plus length of Md5.*/
+	u32ParaTotalSize += MD5_STRING_LEN;
+
+	return u32ParaTotalSize;
+}
+
+CVI_S32 CVI_BIN_ExportBinData(CVI_U8 *pu8Buffer, CVI_U32 u32DataLength)
+{
+	if (pu8Buffer == NULL) {
+		return CVI_BIN_NULL_POINT;
+	}
+
+	CVI_S32 ret = CVI_SUCCESS;
+	CVI_BIN_HEADER *pstHeader = (CVI_BIN_HEADER *)pu8Buffer;
+	CVI_U8 *pu8JsonAddr = NULL;
+	CVI_U8 *pu8BufStartAddr = pu8Buffer;
+	CVI_U32 u32BufSize = u32DataLength;
+	CVI_JSON_HEADER stJsonHeader = { 0 };
+
+	/*remove md5 length.*/
+	u32DataLength -= MD5_STRING_LEN;
+	pstHeader->chipId = MAGIC_NUMBER;
+
+	for (CVI_U32 idx = CVI_BIN_ID_MIN; idx < CVI_BIN_ID_MAX; idx++) {
+		if ((getBinSizeFunc[idx] != NULL) && (check_is_register_id(idx) == CVI_SUCCESS)) {
+			getBinSizeFunc[idx]((CVI_U32 *)&(pstHeader->size[idx]));
+		}
+		u32DataLength -= pstHeader->size[idx];
+	}
+
+	/*get bin param to buf*/
+	for (CVI_U32 idx = CVI_BIN_ID_MIN; idx < CVI_BIN_ID_MAX; idx++) {
+		if ((setParamToBufFunc[idx] != NULL) && (check_is_register_id(idx) == CVI_SUCCESS)) {
+			ret = setParamToBufFunc[idx](pu8Buffer);
+		}
+		pu8Buffer += pstHeader->size[idx];
+	}
+
+	/*set json param to buf*/
+	pu8JsonAddr = pu8Buffer;
+
+	/*save compress json para to cvi_sdr_bin*/
+	for (CVI_U32 idx = CVI_BIN_ID_MIN; idx < CVI_BIN_ID_MAX; idx++) {
+		if (idx == CVI_BIN_ID_HEADER) {
+			stJsonHeader.size[CVI_BIN_ID_HEADER].u32InitSize = sizeof(CVI_JSON_HEADER);
+			stJsonHeader.size[CVI_BIN_ID_HEADER].u32CompreSize = sizeof(CVI_JSON_HEADER);
+		} else {
+			#ifndef DISABLE_PQBIN_JSON
+			if ((setParamToBufFunc[idx] != NULL) && (check_is_register_id(idx) == CVI_SUCCESS)) {
+				ret = CVI_JSON_SaveParamToBuffer(pu8Buffer, idx, &stJsonHeader.size[idx],
+				setParamToJsonBuf[idx], u32DataLength);
+				if (ret != CVI_SUCCESS) {
+					break;
+				}
+			}
+			#endif
+		}
+		u32DataLength -= stJsonHeader.size[idx].u32CompreSize;
+		pu8Buffer += stJsonHeader.size[idx].u32CompreSize;
+	}
+	memcpy(pu8JsonAddr, &stJsonHeader, sizeof(CVI_JSON_HEADER));
+	write_md5_value_to_buf(pu8BufStartAddr, u32BufSize);
+
+	return ret;
+}
+
+CVI_S32 CVI_BIN_ImportBinData(CVI_U8 *pu8Buffer, CVI_U32 u32DataLength)
+{
+	CVI_S32 ret = CVI_SUCCESS, tmpRet = CVI_SUCCESS;
+
+	if (pu8Buffer == NULL) {
+		return CVI_BIN_NULL_POINT;
+	}
+	if (u32DataLength == 0) {
+		CVI_TRACE_SYS(CVI_DBG_ERR, "input length of buffer can't be 0!\n");
+		return CVI_BIN_SIZE_ERR;
+	}
+
+	#ifdef RPC_MULTI_PROCESS
+	if (!isMaster()) {
+		for (CVI_U32 idx = CVI_BIN_ID_MIN; idx < CVI_BIN_ID_MAX; idx++) {
+			ret = rpc_client_bin_loadparamfrombin(idx, pu8Buffer);
+		}
+		return ret;
+	}
+	#endif
+
+	CVI_BIN_HEADER *pstHeader = (CVI_BIN_HEADER *)pu8Buffer;
+	CVI_U8 *pu8BlockAddr = (CVI_U8 *)pu8Buffer;
+	CVI_BOOL bBlkSizeInvalid = CVI_FALSE;
+
+	ret = check_bin_file_validity(pu8Buffer, u32DataLength);
+	if (ret == (CVI_S32)CVI_BIN_FILE_ERROR) {
+		goto ERROR_HANDLER;
+	}
+
+	for (CVI_U32 idx = CVI_BIN_ID_MIN; idx < CVI_BIN_ID_MAX; idx++) {
+		if ((getParamFromBinFunc[idx] != NULL) && (check_is_register_id(idx) == CVI_SUCCESS)) {
+			ret = check_sensor_num_is_exceeded(idx);
+			if (ret != CVI_SUCCESS) {
+				CVI_TRACE_SYS(CVI_DBG_WARN, "Sensor number exceeds specified number in PQbin file\n");
+				goto ERROR_HANDLER;
+			}
+			bBlkSizeInvalid = !(pstHeader->size[idx]);
+			if (bBlkSizeInvalid) {
+				#ifndef DISABLE_PQBIN_JSON
+				CVI_TRACE_SYS(CVI_DBG_WARN, "Size of block(%d) is 0, get para from json!\n", idx);
+				ret = get_json_para_from_buffer(idx, pu8Buffer);
+				if (ret != CVI_SUCCESS) {
+					tmpRet = ret;
+				}
+				#else
+				CVI_TRACE_SYS(CVI_DBG_WARN, "Size of block(%d) is 0 & json inexistence!\n", idx);
+				tmpRet = CVI_BIN_JSON_ERR;
+				#endif
+			} else {
+				ret = getParamFromBinFunc[idx](pu8BlockAddr, pstHeader->size[idx]);
+				if (ret != CVI_SUCCESS) {
+					#ifndef DISABLE_PQBIN_JSON
+					CVI_TRACE_SYS(CVI_DBG_WARN, "Get cur block(%d) para from json!\n", idx);
+					ret = get_json_para_from_buffer(idx, pu8Buffer);
+					if (ret != CVI_SUCCESS) {
+						tmpRet = ret;
+					}
+					#else
+					CVI_TRACE_SYS(CVI_DBG_WARN,
+						"Get cur block(%d) err=0x%08x & json inexistence!\n", idx, ret);
+					tmpRet = CVI_BIN_JSON_ERR;
+					#endif
+				}
+			}
+		}
+		pu8BlockAddr += pstHeader->size[idx];
+	}
+	ret = tmpRet;
+
+ERROR_HANDLER:
+	return ret;
+}
+
+CVI_S32 CVI_BIN_SaveParamToBin(FILE *fp, CVI_BIN_EXTRA_S *extraInfo)
+{
+#ifdef RPC_MULTI_PROCESS
+	if (!isMaster()) {
+		return rpc_client_bin_saveparamtobin(fp, extraInfo);
+	}
+#endif
+
+	CVI_S32 ret = CVI_SUCCESS;
+	CVI_BIN_HEADER header = { 0 };
+	CVI_U32 u32BinParaSize = 0, u32TempLen = 0;
+	CVI_JSON_HEADER stJsonHeader = { 0 };
+
+	header.chipId = MAGIC_NUMBER;
+	header.extraInfo = *extraInfo;
+	header.size[CVI_BIN_ID_HEADER] = sizeof(CVI_BIN_HEADER);
+
+	for (CVI_U32 idx = CVI_BIN_ID_MIN; idx < CVI_BIN_ID_MAX; idx++) {
+		if ((getBinSizeFunc[idx] != NULL) && (check_is_register_id(idx) == CVI_SUCCESS)) {
+			getBinSizeFunc[idx]((CVI_U32 *)&(header.size[idx]));
+		}
+	}
+
+	u32TempLen = fwrite(&header, sizeof(CVI_BIN_HEADER), 1, fp);
+	if (u32TempLen != 1) {
+		ret = CVI_BIN_UPDATE_ERROR;
+		CVI_TRACE_SYS(CVI_DBG_WARN, "Write bin header infor to file fail!\n");
+	}
+
+	for (CVI_U32 idx = CVI_BIN_ID_MIN; idx < CVI_BIN_ID_MAX; idx++) {
+		CVI_U32 addr = ftell(fp);
+
+		u32BinParaSize += header.size[idx];
+		if ((setParamToBinFunc[idx] != NULL) && (check_is_register_id(idx) == CVI_SUCCESS)) {
+			ret = setParamToBinFunc[idx](fp);
+			if (header.size[idx] != (ftell(fp) - addr) && idx != CVI_BIN_ID_MIN) {
+				CVI_TRACE_SYS(CVI_DBG_WARN, "Write data length mismatch (%ld > %d)\n",
+					      (ftell(fp) - addr), header.size[idx]);
+				ret = CVI_FAILURE;
+			}
+		}
+	}
+
+	/*save json para to bin file.*/
+	fseek(fp, u32BinParaSize + sizeof(CVI_JSON_HEADER), SEEK_SET);
+	/*save compress jsonfile para to cvi_sdr_bin*/
+	for (CVI_U32 idx = CVI_BIN_ID_MIN; idx < CVI_BIN_ID_MAX; idx++) {
+		if (idx == CVI_BIN_ID_HEADER) {
+			stJsonHeader.size[idx].u32InitSize = sizeof(CVI_JSON_HEADER);
+			stJsonHeader.size[idx].u32CompreSize = sizeof(CVI_JSON_HEADER);
+		} else {
+			#ifndef DISABLE_PQBIN_JSON
+			if ((setParamToBinFunc[idx] != NULL) && (check_is_register_id(idx) == CVI_SUCCESS)) {
+				CVI_JSON_SaveParamToFile(fp, idx, &stJsonHeader.size[idx], setParamToJsonBuf[idx]);
+			}
+			#endif
+		}
+	}
+	fseek(fp, u32BinParaSize, SEEK_SET);
+	u32TempLen = fwrite(&stJsonHeader, sizeof(CVI_JSON_HEADER), 1, fp);
+	if (u32TempLen != 1) {
+		ret = CVI_BIN_UPDATE_ERROR;
+		CVI_TRACE_SYS(CVI_DBG_WARN, "Write json header infor to file fail!\n");
+	}
+
+	/*calcute md5 value and write md5 to end of file.*/
+	ret = write_md5_value_to_file(fp);
+
+	return ret;
+}
+
+CVI_S32 CVI_BIN_LoadParamFromBin(enum CVI_BIN_SECTION_ID id, CVI_U8 *buf)
+{
+#ifdef RPC_MULTI_PROCESS
+	if (!isMaster()) {
+		return rpc_client_bin_loadparamfrombin(id, buf);
+	}
+#endif
+	if (buf == NULL) {
+		return CVI_BIN_NULL_POINT;
+	}
+
+	CVI_S32 ret = CVI_SUCCESS;
+	CVI_BOOL bBlkSizeInvalid = CVI_FALSE;
+
+	/*reserve the API. if customer use directly, it may report following warning log.*/
+	if (g_bUseOldLoadAPI) {
+		CVI_TRACE_SYS(CVI_DBG_WARN,
+				"Note: this API interface is deprecated and may be removed in the future.\n");
+		ret = check_bin_file_validity(buf, 0);
+		if (ret == (CVI_S32)CVI_BIN_FILE_ERROR) {
+			goto ERROR_HANDLER;
+		}
+	}
+	ret = _isSectionIdValid(id);
+	if (ret != CVI_SUCCESS) {
+		ret = CVI_BIN_ID_ERROR;
+		CVI_TRACE_SYS(CVI_DBG_WARN, "Invalid id(%d)\n", id);
+		goto ERROR_HANDLER;
+	}
+
+	CVI_BIN_HEADER *pstHeader = (CVI_BIN_HEADER *)buf;
+	CVI_U32 secSize = pstHeader->size[CVI_BIN_ID_HEADER] - sizeof(CVI_U32) - sizeof(CVI_BIN_EXTRA_S);
+	CVI_U32 secCnt = secSize / sizeof(CVI_U32);
+	CVI_U8 *addr = (CVI_U8 *)buf;
+
+	if (secCnt < id) {
+		ret = CVI_BIN_ID_ERROR;
+		CVI_TRACE_SYS(CVI_DBG_WARN, "Module(%d) not contained in this BIN\n", id);
+	} else {
+		for (CVI_U32 idx = CVI_BIN_ID_MIN; idx < id; idx++) {
+			addr += pstHeader->size[idx];
+		}
+		if ((getParamFromBinFunc[id] != NULL) && (check_is_register_id(id) == CVI_SUCCESS)) {
+			ret = check_sensor_num_is_exceeded(id);
+			if (ret != CVI_SUCCESS) {
+				CVI_TRACE_SYS(CVI_DBG_WARN, "Sensor number exceeds specified number in PQbin file\n");
+				goto ERROR_HANDLER;
+			}
+			bBlkSizeInvalid = !(pstHeader->size[id]);
+			if (bBlkSizeInvalid) {
+				#ifndef DISABLE_PQBIN_JSON
+				CVI_TRACE_SYS(CVI_DBG_WARN, "Size of block(%d) is 0, get para from json!\n", id);
+				ret = get_json_para_from_buffer(id, buf);
+				#else
+				CVI_TRACE_SYS(CVI_DBG_WARN, "Size of block(%d) is 0 & json inexistence!\n", id);
+				ret = CVI_BIN_JSON_ERR;
+				#endif
+			} else {
+				ret = getParamFromBinFunc[id](addr, pstHeader->size[id]);
+				if (ret != CVI_SUCCESS) {
+					#ifndef DISABLE_PQBIN_JSON
+					CVI_TRACE_SYS(CVI_DBG_WARN, "Get cur block(%d) para from json!\n", id);
+					ret = get_json_para_from_buffer(id, buf);
+					#else
+					CVI_TRACE_SYS(CVI_DBG_WARN,
+						"Get cur block(%d) err=%08x & json inexistence!\n", id, ret);
+					ret = CVI_BIN_JSON_ERR;
+					#endif
+				}
+			}
+		}
+	}
+
+ERROR_HANDLER:
+	return ret;
+}
+
+CVI_S32 CVI_BIN_LoadParamFromBinEx(enum CVI_BIN_SECTION_ID id, CVI_U8 *buf, CVI_U32 u32DataLength)
+{
+	CVI_S32 ret = CVI_SUCCESS;
+
+	if (u32DataLength == 0) {
+		CVI_TRACE_SYS(CVI_DBG_ERR, "input length of buffer can't be 0!\n");
+		return CVI_BIN_SIZE_ERR;
+	}
+
+	g_bUseOldLoadAPI = CVI_FALSE;
+	ret = check_bin_file_validity(buf, u32DataLength);
+	if (ret == (CVI_S32)CVI_BIN_FILE_ERROR) {
+		goto ERROR_HANDLER;
+	}
+	ret = CVI_BIN_LoadParamFromBin(id, buf);
+	g_bUseOldLoadAPI = CVI_TRUE;
+
+ERROR_HANDLER:
+	return ret;
+}
+
+CVI_S32 CVI_BIN_GetBinExtraAttr(FILE *fp, CVI_BIN_EXTRA_S *extraInfo)
+{
+	CVI_S32 ret = CVI_SUCCESS;
+	CVI_BIN_HEADER header;
+
+	fread(&header, sizeof(CVI_BIN_HEADER), 1, fp);
+	memcpy(extraInfo, &(header.extraInfo), sizeof(CVI_BIN_EXTRA_S));
+
+	return ret;
+}
+
+CVI_S32 CVI_BIN_SetBinName(WDR_MODE_E wdrMode, const CVI_CHAR *binName)
+{
+#ifdef RPC_MULTI_PROCESS
+	if (!isMaster()) {
+		return rpc_client_bin_setbinname(wdrMode, binName);
+	}
+#endif
+	if (binName == NULL) {
+		CVI_TRACE_SYS(CVI_DBG_WARN, "binName is NULL\n");
+		return CVI_FAILURE;
+	}
+
+	return _setBinNameImp(wdrMode, binName);
+}
+
+CVI_S32 CVI_BIN_GetBinName(CVI_CHAR *binName)
+{
+#ifdef RPC_MULTI_PROCESS
+	if (!isMaster()) {
+		return rpc_client_bin_getbinname(binName);
+	}
+#endif
+
+	if (binName == NULL) {
+		CVI_TRACE_SYS(CVI_DBG_WARN, "binName is NULL\n");
+		return CVI_FAILURE;
+	}
+
+	return _getBinNameImp(binName);
+}

middleware/v2/modules/bin/src/md5.c

@@ -0,0 +1,340 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "md5.h"
+
+#define MD5_CBLOCK 64
+#define MD5_LBLOCK (MD5_CBLOCK / 4)
+
+#define DATA_ORDER_IS_LITTLE_ENDIAN
+
+#define HASH_MAKE_STRING(c, s)                                                 \
+	do {                                                                         \
+		unsigned long ll;                                                          \
+		ll = (c)->A;                                                               \
+		HOST_l2c(ll, (s));                                                         \
+		ll = (c)->B;                                                               \
+		HOST_l2c(ll, (s));                                                         \
+		ll = (c)->C;                                                               \
+		HOST_l2c(ll, (s));                                                         \
+		ll = (c)->D;                                                               \
+		HOST_l2c(ll, (s));                                                         \
+	} while (0)
+
+#define ROTATE(a, n) (((a) << (n)) | (((a)&0xffffffff) >> (32 - (n))))
+
+#if defined(DATA_ORDER_IS_BIG_ENDIAN)
+#define HOST_c2l(c, l)                                                         \
+	(l = (((unsigned long)(*((c)++))) << 24),                                    \
+	l |= (((unsigned long)(*((c)++))) << 16),                                   \
+	l |= (((unsigned long)(*((c)++))) << 8),                                    \
+	l |= (((unsigned long)(*((c)++)))))
+
+#define HOST_l2c(l, c)                                                         \
+	(*((c)++) = (unsigned char)(((l) >> 24) & 0xff),                             \
+	*((c)++) = (unsigned char)(((l) >> 16) & 0xff),                             \
+	*((c)++) = (unsigned char)(((l) >> 8) & 0xff),                              \
+	*((c)++) = (unsigned char)(((l)) & 0xff))
+#endif
+#if defined(DATA_ORDER_IS_LITTLE_ENDIAN)
+#define HOST_c2l(c, l)                                                         \
+	(l = (((unsigned long)(*((c)++)))), l |= (((unsigned long)(*((c)++))) << 8), \
+	l |= (((unsigned long)(*((c)++))) << 16),                                   \
+	l |= (((unsigned long)(*((c)++))) << 24))
+
+#define HOST_l2c(l, c)                                                         \
+	(*((c)++) = (unsigned char)(((l)) & 0xff),                                   \
+	*((c)++) = (unsigned char)(((l) >> 8) & 0xff),                              \
+	*((c)++) = (unsigned char)(((l) >> 16) & 0xff),                             \
+	*((c)++) = (unsigned char)(((l) >> 24) & 0xff))
+#endif
+
+#define MD32_REG_T int
+
+#define F(b, c, d) ((((c) ^ (d)) & (b)) ^ (d))
+#define G(b, c, d) ((((b) ^ (c)) & (d)) ^ (c))
+#define H(b, c, d) ((b) ^ (c) ^ (d))
+#define I(b, c, d) (((~(d)) | (b)) ^ (c))
+
+#define R0(a, b, c, d, k, s, t)                                                \
+{                                                                            \
+	a += ((k) + (t) + F((b), (c), (d)));                                       \
+	a = ROTATE(a, s);                                                          \
+	a += b;                                                                    \
+}
+#define R1(a, b, c, d, k, s, t)                                                \
+{                                                                            \
+	a += ((k) + (t) + G((b), (c), (d)));                                       \
+	a = ROTATE(a, s);                                                          \
+	a += b;                                                                    \
+}
+#define R2(a, b, c, d, k, s, t)                                                \
+{                                                                            \
+	a += ((k) + (t) + H((b), (c), (d)));                                       \
+	a = ROTATE(a, s);                                                          \
+	a += b;                                                                    \
+}
+#define R3(a, b, c, d, k, s, t)                                                \
+{                                                                            \
+	a += ((k) + (t) + I((b), (c), (d)));                                       \
+	a = ROTATE(a, s);                                                          \
+	a += b;                                                                    \
+}
+
+static void md5_block_data_order(MD5_CTX *c, const void *data_, size_t num)
+{
+	const unsigned char *data = data_;
+
+	register unsigned MD32_REG_T A, B, C, D, l;
+
+	A = c->A;
+	B = c->B;
+	C = c->C;
+	D = c->D;
+
+	for (; num--;) {
+#ifndef MD32_XARRAY
+		/* See comment in crypto/sha/sha_locl.h for details. */
+		unsigned MD32_REG_T XX0, XX1, XX2, XX3, XX4, XX5, XX6, XX7, XX8, XX9, XX10,
+			XX11, XX12, XX13, XX14, XX15;
+#define X(i) XX##i
+#else
+		Uint32 XX[MD5_LBLOCK];
+#define X(i) XX[i]
+#endif
+		HOST_c2l(data, l);
+		X(0) = l;
+		HOST_c2l(data, l);
+		X(1) = l;
+		/* Round 0 */
+		R0(A, B, C, D, X(0), 7, 0xd76aa478L);
+		HOST_c2l(data, l);
+		X(2) = l;
+		R0(D, A, B, C, X(1), 12, 0xe8c7b756L);
+		HOST_c2l(data, l);
+		X(3) = l;
+		R0(C, D, A, B, X(2), 17, 0x242070dbL);
+		HOST_c2l(data, l);
+		X(4) = l;
+		R0(B, C, D, A, X(3), 22, 0xc1bdceeeL);
+		HOST_c2l(data, l);
+		X(5) = l;
+		R0(A, B, C, D, X(4), 7, 0xf57c0fafL);
+		HOST_c2l(data, l);
+		X(6) = l;
+		R0(D, A, B, C, X(5), 12, 0x4787c62aL);
+		HOST_c2l(data, l);
+		X(7) = l;
+		R0(C, D, A, B, X(6), 17, 0xa8304613L);
+		HOST_c2l(data, l);
+		X(8) = l;
+		R0(B, C, D, A, X(7), 22, 0xfd469501L);
+		HOST_c2l(data, l);
+		X(9) = l;
+		R0(A, B, C, D, X(8), 7, 0x698098d8L);
+		HOST_c2l(data, l);
+		X(10) = l;
+		R0(D, A, B, C, X(9), 12, 0x8b44f7afL);
+		HOST_c2l(data, l);
+		X(11) = l;
+		R0(C, D, A, B, X(10), 17, 0xffff5bb1L);
+		HOST_c2l(data, l);
+		X(12) = l;
+		R0(B, C, D, A, X(11), 22, 0x895cd7beL);
+		HOST_c2l(data, l);
+		X(13) = l;
+		R0(A, B, C, D, X(12), 7, 0x6b901122L);
+		HOST_c2l(data, l);
+		X(14) = l;
+		R0(D, A, B, C, X(13), 12, 0xfd987193L);
+		HOST_c2l(data, l);
+		X(15) = l;
+		R0(C, D, A, B, X(14), 17, 0xa679438eL);
+		R0(B, C, D, A, X(15), 22, 0x49b40821L);
+		/* Round 1 */
+		R1(A, B, C, D, X(1), 5, 0xf61e2562L);
+		R1(D, A, B, C, X(6), 9, 0xc040b340L);
+		R1(C, D, A, B, X(11), 14, 0x265e5a51L);
+		R1(B, C, D, A, X(0), 20, 0xe9b6c7aaL);
+		R1(A, B, C, D, X(5), 5, 0xd62f105dL);
+		R1(D, A, B, C, X(10), 9, 0x02441453L);
+		R1(C, D, A, B, X(15), 14, 0xd8a1e681L);
+		R1(B, C, D, A, X(4), 20, 0xe7d3fbc8L);
+		R1(A, B, C, D, X(9), 5, 0x21e1cde6L);
+		R1(D, A, B, C, X(14), 9, 0xc33707d6L);
+		R1(C, D, A, B, X(3), 14, 0xf4d50d87L);
+		R1(B, C, D, A, X(8), 20, 0x455a14edL);
+		R1(A, B, C, D, X(13), 5, 0xa9e3e905L);
+		R1(D, A, B, C, X(2), 9, 0xfcefa3f8L);
+		R1(C, D, A, B, X(7), 14, 0x676f02d9L);
+		R1(B, C, D, A, X(12), 20, 0x8d2a4c8aL);
+		/* Round 2 */
+		R2(A, B, C, D, X(5), 4, 0xfffa3942L);
+		R2(D, A, B, C, X(8), 11, 0x8771f681L);
+		R2(C, D, A, B, X(11), 16, 0x6d9d6122L);
+		R2(B, C, D, A, X(14), 23, 0xfde5380cL);
+		R2(A, B, C, D, X(1), 4, 0xa4beea44L);
+		R2(D, A, B, C, X(4), 11, 0x4bdecfa9L);
+		R2(C, D, A, B, X(7), 16, 0xf6bb4b60L);
+		R2(B, C, D, A, X(10), 23, 0xbebfbc70L);
+		R2(A, B, C, D, X(13), 4, 0x289b7ec6L);
+		R2(D, A, B, C, X(0), 11, 0xeaa127faL);
+		R2(C, D, A, B, X(3), 16, 0xd4ef3085L);
+		R2(B, C, D, A, X(6), 23, 0x04881d05L);
+		R2(A, B, C, D, X(9), 4, 0xd9d4d039L);
+		R2(D, A, B, C, X(12), 11, 0xe6db99e5L);
+		R2(C, D, A, B, X(15), 16, 0x1fa27cf8L);
+		R2(B, C, D, A, X(2), 23, 0xc4ac5665L);
+		/* Round 3 */
+		R3(A, B, C, D, X(0), 6, 0xf4292244L);
+		R3(D, A, B, C, X(7), 10, 0x432aff97L);
+		R3(C, D, A, B, X(14), 15, 0xab9423a7L);
+		R3(B, C, D, A, X(5), 21, 0xfc93a039L);
+		R3(A, B, C, D, X(12), 6, 0x655b59c3L);
+		R3(D, A, B, C, X(3), 10, 0x8f0ccc92L);
+		R3(C, D, A, B, X(10), 15, 0xffeff47dL);
+		R3(B, C, D, A, X(1), 21, 0x85845dd1L);
+		R3(A, B, C, D, X(8), 6, 0x6fa87e4fL);
+		R3(D, A, B, C, X(15), 10, 0xfe2ce6e0L);
+		R3(C, D, A, B, X(6), 15, 0xa3014314L);
+		R3(B, C, D, A, X(13), 21, 0x4e0811a1L);
+		R3(A, B, C, D, X(4), 6, 0xf7537e82L);
+		R3(D, A, B, C, X(11), 10, 0xbd3af235L);
+		R3(C, D, A, B, X(2), 15, 0x2ad7d2bbL);
+		R3(B, C, D, A, X(9), 21, 0xeb86d391L);
+
+		A = c->A += A;
+		B = c->B += B;
+		C = c->C += C;
+		D = c->D += D;
+	}
+}
+
+/* Implemented from RFC1321 The MD5 Message-Digest Algorithm
+ */
+
+#define INIT_DATA_A (0x67452301L)
+#define INIT_DATA_B (0xefcdab89L)
+#define INIT_DATA_C (0x98badcfeL)
+#define INIT_DATA_D (0x10325476L)
+
+static Int32 MD5_Init(MD5_CTX *c)
+{
+	c->A = INIT_DATA_A;
+	c->B = INIT_DATA_B;
+	c->C = INIT_DATA_C;
+	c->D = INIT_DATA_D;
+	c->Nl = 0;
+	c->Nh = 0;
+	c->num = 0;
+	return 1;
+}
+
+static Int32 MD5_Update(MD5_CTX *c, const void *data_, size_t len)
+{
+	const unsigned char *data = data_;
+	unsigned char *p;
+	Uint32 l;
+	size_t n;
+
+	if (len == 0)
+		return 1;
+
+	l = (c->Nl + (((Uint32)len) << 3)) & 0xffffffffUL;
+	/* 95-05-24 eay Fixed a bug with the overflow handling, thanks to
+	 * Wei Dai <weidai@eskimo.com> for pointing it out.
+	 */
+	if (l < c->Nl) /* overflow */
+		c->Nh++;
+	c->Nh += (len >> 29); /* might cause compiler warning on 16-bit */
+	c->Nl = l;
+
+	n = c->num;
+	if (n != 0) {
+		p = (unsigned char *)c->data;
+
+		if (len >= MD5_CBLOCK || len + n >= MD5_CBLOCK) {
+			osal_memcpy(p + n, data, MD5_CBLOCK - n);
+			md5_block_data_order(c, p, 1);
+			n = MD5_CBLOCK - n;
+			data += n;
+			len -= n;
+			c->num = 0;
+			osal_memset(p, 0, MD5_CBLOCK); /* keep it zeroed */
+		} else {
+			osal_memcpy(p + n, data, len);
+			c->num += (unsigned int)len;
+			return 1;
+		}
+	}
+
+	n = len / MD5_CBLOCK;
+	if (n > 0) {
+		md5_block_data_order(c, data, n);
+		n *= MD5_CBLOCK;
+		data += n;
+		len -= n;
+	}
+
+	if (len != 0) {
+		p = (unsigned char *)c->data;
+		c->num = len;
+		osal_memcpy(p, data, len);
+	}
+	return 1;
+}
+
+static Int32 MD5_Final(Uint8 *md, MD5_CTX *c)
+{
+	unsigned char *p = (unsigned char *)c->data;
+	size_t n = c->num;
+
+	p[n] = 0x80; /* there is always room for one */
+	n++;
+
+	if (n > (MD5_CBLOCK - 8)) {
+		osal_memset(p + n, 0, MD5_CBLOCK - n);
+		n = 0;
+		md5_block_data_order(c, p, 1);
+	}
+	osal_memset(p + n, 0, MD5_CBLOCK - 8 - n);
+
+	p += MD5_CBLOCK - 8;
+#if defined(DATA_ORDER_IS_BIG_ENDIAN)
+	(void)HOST_l2c(c->Nh, p);
+	(void)HOST_l2c(c->Nl, p);
+#elif defined(DATA_ORDER_IS_LITTLE_ENDIAN)
+	(void)HOST_l2c(c->Nl, p);
+	(void)HOST_l2c(c->Nh, p);
+#endif
+	p -= MD5_CBLOCK;
+	md5_block_data_order(c, p, 1);
+	c->num = 0;
+	osal_memset(p, 0, MD5_CBLOCK);
+
+	HASH_MAKE_STRING(c, md);
+
+	return 1;
+}
+
+static void MD5(const Uint8 *d, size_t n, Uint8 *md)
+{
+	MD5_CTX c;
+
+	MD5_Init(&c);
+	MD5_Update(&c, d, n);
+	MD5_Final(md, &c);
+}
+
+void calcute_md5_value(const uint8_t *src, size_t len, Uint8 *result)
+{
+	unsigned char md5[MD5_DIGEST_LENGTH];
+	unsigned char *p = result;
+
+	MD5(src, len, md5);
+	for (int i = 0; i < MD5_DIGEST_LENGTH; i++) {
+		sprintf((char *)p, "%02x", md5[i]);
+		p += 2;
+	}
+}
+

middleware/v2/modules/bin/src/rw_json.c

@@ -0,0 +1,218 @@
+#ifndef DISABLE_PQBIN_JSON
+#include <stdlib.h>
+#include "rw_json.h"
+#include "cvi_miniz.h"
+#include <linux/cvi_comm_sys.h>
+#include "cvi_bin.h"
+#include "cvi_debug.h"
+
+static CVI_S32 _isSectionIdValid(enum CVI_BIN_SECTION_ID id)
+{
+	CVI_S32 ret = CVI_SUCCESS;
+
+	if ((id < CVI_BIN_ID_MIN) || (id >= CVI_BIN_ID_MAX)) {
+		ret = CVI_FAILURE;
+	}
+
+	return ret;
+}
+
+CVI_S32 CVI_JSON_LoadParamFromBuffer(enum CVI_BIN_SECTION_ID id, CVI_U8 *buf,
+pfn_cvi_json_getparamfrombuf pFuncgetParam)
+{
+	CVI_S32 ret = CVI_SUCCESS;
+	CVI_U8 *addr = (CVI_U8 *)buf;
+	CVI_U8 *pu8Uncomprebuf = NULL;
+	uLongf UncompreBufLen = 0;
+	uLongf CompreBufLen = 0;
+	int iResult = 0;
+
+	ret = _isSectionIdValid(id);
+	if (ret != CVI_SUCCESS) {
+		ret = CVI_BIN_ID_ERROR;
+		CVI_TRACE_SYS(LOG_ERR, "Invalid id(%d)\n", id);
+		goto ERROR_HANDLER;
+	}
+
+	if (buf == NULL) {
+		ret = CVI_BIN_NULL_POINT;
+		CVI_TRACE_SYS(LOG_ERR, "input buffer pointer is null!");
+		goto ERROR_HANDLER;
+	}
+	if (pFuncgetParam == NULL) {
+		ret = CVI_BIN_NULL_POINT;
+		CVI_TRACE_SYS(LOG_ERR, "get json callback isn't registered!");
+		goto ERROR_HANDLER;
+	}
+
+	/*get addr of bin header*/
+	CVI_BIN_HEADER *header = (CVI_BIN_HEADER *)buf;
+
+	for (CVI_U32 idx = CVI_BIN_ID_MIN; idx < CVI_BIN_ID_MAX; idx++) {
+		addr += header->size[idx];
+	}
+	/*get addr of json header*/
+	CVI_JSON_HEADER *pJsonHeader = (CVI_JSON_HEADER *)addr;
+
+	for (CVI_U32 idx = CVI_BIN_ID_MIN; idx < id; idx++) {
+		addr += pJsonHeader->size[idx].u32CompreSize;
+	}
+	UncompreBufLen = pJsonHeader->size[id].u32InitSize;
+	pu8Uncomprebuf = (CVI_U8 *)malloc(UncompreBufLen);
+	if (pu8Uncomprebuf == NULL) {
+		ret = CVI_BIN_MALLOC_ERR;
+		goto ERROR_HANDLER;
+	}
+
+	/*start to uncompress*/
+	CompreBufLen = pJsonHeader->size[id].u32CompreSize;
+	iResult = cvi_uncompress2(pu8Uncomprebuf, &UncompreBufLen, addr, &CompreBufLen);
+	if (iResult != Z_OK) {
+		ret = CVI_BIN_UNCOMPRESS_ERROR;
+		CVI_TRACE_SYS(LOG_ERR, "block(%d) Uncompress abnormally! abnormal value is:%d\n", id, iResult);
+		goto ERROR_HANDLER;
+	}
+	/*load json para to struct*/
+	ret = pFuncgetParam((char *)pu8Uncomprebuf, id);
+
+ERROR_HANDLER:
+	if (pu8Uncomprebuf != NULL) {
+		free(pu8Uncomprebuf);
+	}
+
+	return ret;
+}
+
+CVI_S32 CVI_JSON_SaveParamToBuffer(unsigned char *buffer, enum CVI_BIN_SECTION_ID id, CVI_JSON_INFO *pJsonInfo,
+pfn_cvi_json_setparamtobuf pFuncsetParam, CVI_U32 u32FreeSpaceSize)
+{
+	CVI_S32 ret = CVI_SUCCESS;
+	CVI_S8 *buf = NULL;
+	CVI_U8 *pu8CompressDestBuf = NULL;
+	uLongf CompressBufLen = 0;
+	CVI_U32 u32BufferLen = 0;
+	int iResult = 0;
+
+	ret = _isSectionIdValid(id);
+	if (ret != CVI_SUCCESS) {
+		ret = CVI_BIN_ID_ERROR;
+		CVI_TRACE_SYS(LOG_ERR, "Invalid id(%d)\n", id);
+		goto ERROR_HANDLER;
+	}
+
+	if (pJsonInfo == NULL) {
+		ret = CVI_BIN_NULL_POINT;
+		CVI_TRACE_SYS(LOG_ERR, "input pJsonInfo pointer is null!");
+		goto ERROR_HANDLER;
+	}
+	if (pFuncsetParam == NULL) {
+		ret = CVI_BIN_NULL_POINT;
+		CVI_TRACE_SYS(LOG_ERR, "set json callback isn't registered!");
+		goto ERROR_HANDLER;
+	}
+
+	pFuncsetParam(&buf, id, (CVI_S32 *)&u32BufferLen);
+	CompressBufLen = cvi_compressBound(u32BufferLen);
+
+	/*compress json buf*/
+	pu8CompressDestBuf = (CVI_U8 *)malloc(CompressBufLen);
+	if (pu8CompressDestBuf == NULL) {
+		ret = CVI_BIN_MALLOC_ERR;
+		CVI_TRACE_SYS(LOG_WARNING, "%s\n", "Allocate memory fail");
+		goto ERROR_HANDLER;
+	}
+
+	iResult = cvi_compress2((Bytef *)pu8CompressDestBuf, &CompressBufLen, (const Bytef *)buf,
+			    (uLong)u32BufferLen, Z_DEFAULT_COMPRESSION);
+	if (iResult != Z_OK) {
+		ret = CVI_BIN_COMPRESS_ERROR;
+		CVI_TRACE_SYS(LOG_ERR, "block(%d) Compress abnormally! abnormal value is:%d\n", id, iResult);
+		goto ERROR_HANDLER;
+	}
+	pJsonInfo->u32InitSize = u32BufferLen;
+	pJsonInfo->u32CompreSize = (CVI_U32)CompressBufLen;
+	if ((CompressBufLen > u32FreeSpaceSize) && (buffer != NULL)) {
+		ret = CVI_BIN_SAPCE_ERR;
+		CVI_TRACE_SYS(LOG_ERR, "%s\n", "Remaining space of input buffer isn't enough!");
+		goto ERROR_HANDLER;
+	}
+
+	if (buffer != NULL) {
+		memcpy(buffer, pu8CompressDestBuf, CompressBufLen);
+	}
+
+ERROR_HANDLER:
+	if (pu8CompressDestBuf) {
+		free(pu8CompressDestBuf);
+	}
+	if (buf) {
+		free(buf);
+	}
+	return ret;
+}
+
+CVI_S32 CVI_JSON_SaveParamToFile(FILE *fp, enum CVI_BIN_SECTION_ID id, CVI_JSON_INFO *pJsonInfo,
+pfn_cvi_json_setparamtobuf pFuncsetParam)
+{
+	CVI_S32 ret = CVI_SUCCESS;
+	CVI_S8 *buf = NULL;
+	CVI_U8 *pu8CompressDestBuf = NULL;
+	uLongf CompressBufLen = 0;
+	CVI_U32 u32BufferLen = 0;
+	int iResult = 0;
+	size_t size = 0;
+
+	ret = _isSectionIdValid(id);
+	if (ret != CVI_SUCCESS) {
+		ret = CVI_BIN_ID_ERROR;
+		CVI_TRACE_SYS(LOG_ERR, "Invalid id(%d)\n", id);
+		goto ERROR_HANDLER;
+	}
+
+	if (pJsonInfo == NULL) {
+		ret = CVI_BIN_NULL_POINT;
+		CVI_TRACE_SYS(LOG_ERR, "input pJsonInfo pointer is null!");
+		goto ERROR_HANDLER;
+	}
+	if (pFuncsetParam == NULL) {
+		ret = CVI_BIN_NULL_POINT;
+		CVI_TRACE_SYS(LOG_ERR, "set json callback isn't registered!");
+		goto ERROR_HANDLER;
+	}
+
+	pFuncsetParam(&buf, id, (CVI_S32 *)&u32BufferLen);
+	CompressBufLen = cvi_compressBound(u32BufferLen);
+
+	/*compress json buf*/
+	pu8CompressDestBuf = (CVI_U8 *)malloc(CompressBufLen);
+	if (pu8CompressDestBuf == NULL) {
+		ret = CVI_BIN_MALLOC_ERR;
+		CVI_TRACE_SYS(LOG_WARNING, "%s\n", "Allocate memory fail");
+		goto ERROR_HANDLER;
+	}
+
+	iResult = cvi_compress2((Bytef *)pu8CompressDestBuf, &CompressBufLen, (const Bytef *)buf,
+			    (uLong)u32BufferLen, Z_DEFAULT_COMPRESSION);
+	if (iResult != Z_OK) {
+		ret = CVI_BIN_COMPRESS_ERROR;
+		CVI_TRACE_SYS(LOG_ERR, "block(%d) Compress abnormally! abnormal value is:%d\n", id, iResult);
+		goto ERROR_HANDLER;
+	}
+	pJsonInfo->u32InitSize = u32BufferLen;
+	pJsonInfo->u32CompreSize = (CVI_U32)CompressBufLen;
+	size = fwrite(pu8CompressDestBuf, CompressBufLen, 1, fp);
+	if (size != 1) {
+		ret = CVI_BIN_UPDATE_ERROR;
+		CVI_TRACE_SYS(LOG_WARNING, "Update block(%d) para fail!\n", id);
+	}
+
+ERROR_HANDLER:
+	if (pu8CompressDestBuf) {
+		free(pu8CompressDestBuf);
+	}
+	if (buf) {
+		free(buf);
+	}
+	return ret;
+}
+#endif

middleware/v2/modules/bin/src/vo_bin.c

@@ -0,0 +1,129 @@
+#include <linux/cvi_comm_vo.h>
+#include "vo_bin.h"
+#include "cvi_base.h"
+#include "cvi_bin.h"
+#include "cvi_vo.h"
+#include "vo_json_struct.h"
+#include "cvi_json_struct_comm.h"
+
+/**************************************************************************
+ *   Bin related APIs.
+ **************************************************************************/
+CVI_S32 vo_bin_getbinsize(CVI_U32 *size)
+{
+	MOD_CHECK_NULL_PTR(CVI_ID_VO, size);
+	*size = sizeof(VO_BIN_INFO_S);
+
+	return CVI_SUCCESS;
+}
+
+CVI_S32 vo_bin_getparamfrombin(CVI_U8 *addr, CVI_U32 size)
+{
+	CVI_U32 data_size;
+	VO_BIN_INFO_S info_from_bin;
+
+	MOD_CHECK_NULL_PTR(CVI_ID_VO, addr);
+
+	vo_bin_getbinsize(&data_size);
+	if (size > data_size) {
+		CVI_TRACE_VO(CVI_DBG_ERR, "Bin size(%d) > max size(%d).\n", size, data_size);
+		return CVI_FAILURE;
+	}
+	memcpy(&info_from_bin, addr, size);
+
+	//check guard pattern
+	if (info_from_bin.guard_magic != get_vo_bin_guardmagic_code()) {
+		CVI_TRACE_VO(CVI_DBG_ERR, "readback guardpattern incorrect guard_magic(0x%x)\n",
+			     info_from_bin.guard_magic);
+	} else {
+		CVI_TRACE_VO(CVI_DBG_DEBUG, "get param from bin success\n");
+		CVI_VO_SetGammaInfo(&(info_from_bin.gamma_info));
+	}
+
+	return CVI_SUCCESS;
+}
+
+CVI_S32 vo_bin_setparamtobuf(CVI_U8 *buffer)
+{
+	CVI_U32 data_size = 0;
+	VO_BIN_INFO_S *pstVoBinInfo = get_vo_bin_info_addr();
+
+	MOD_CHECK_NULL_PTR(CVI_ID_VO, buffer);
+
+	vo_bin_getbinsize(&data_size);
+	memcpy(buffer, pstVoBinInfo, data_size);
+
+	return CVI_SUCCESS;
+}
+
+CVI_S32 vo_bin_setparamtobin(FILE *fp)
+{
+	CVI_U32 data_size = 0;
+	VO_BIN_INFO_S *pstVoBinInfo = get_vo_bin_info_addr();
+
+	MOD_CHECK_NULL_PTR(CVI_ID_VO, fp);
+
+	vo_bin_getbinsize(&data_size);
+	fwrite(pstVoBinInfo, data_size, 1, fp);
+
+	return CVI_SUCCESS;
+}
+
+#ifndef DISABLE_PQBIN_JSON
+CVI_S32 vo_json_getParamFromJsonbuffer(const char *buffer, enum CVI_BIN_SECTION_ID id)
+{
+	JSON *json_object;
+	CVI_S32 ret = CVI_SUCCESS;
+	VO_GAMMA_INFO_S vo_parameter = { 0 };
+
+	json_object = JSON_TokenerParse(buffer);
+	if (json_object) {
+		CVI_VO_GetGammaInfo(&vo_parameter);
+		JSON_(R_FLAG, json_object, VO_GAMMA_INFO_S, "vo_parameter", &vo_parameter);
+		CVI_VO_SetGammaInfo(&vo_parameter);
+
+		JSON_ObjectPut(json_object);
+	} else {
+		CVI_TRACE_VO(LOG_WARNING, "(id:%d)Creat json tokener fail.\n", id);
+		ret = CVI_BIN_JSONHANLE_ERROR;
+	}
+
+	UNUSED(id);
+
+	return ret;
+}
+
+CVI_S32 vo_json_setParamToJsonbuffer(CVI_S8 **buffer, enum CVI_BIN_SECTION_ID id, CVI_S32 *len)
+{
+	VO_GAMMA_INFO_S vo_parameter = { 0 };
+	JSON *json_object;
+	CVI_S32 ret = CVI_SUCCESS;
+
+	json_object = JSON_GetNewObject();
+	if (json_object) {
+		CVI_VO_GetGammaInfo(&vo_parameter);
+		JSON_(W_FLAG, json_object, VO_GAMMA_INFO_S, "vo_parameter", &vo_parameter);
+
+		*len = JSON_GetJsonStrLen(json_object);
+		*buffer = (CVI_S8 *)malloc(*len);
+		if (*buffer == NULL) {
+			ret = CVI_BIN_MALLOC_ERR;
+			CVI_TRACE_VO(LOG_WARNING, "%s\n", "Allocate memory fail");
+			goto ERROR_HANDLER;
+		}
+		memcpy(*buffer, JSON_GetJsonStrContent(json_object), *len);
+	} else {
+		CVI_TRACE_VO(LOG_WARNING, "(id:%d)Get New Object fail.\n", id);
+		ret = CVI_BIN_JSONHANLE_ERROR;
+	}
+
+ERROR_HANDLER:
+	if (json_object) {
+		JSON_ObjectPut(json_object);
+	}
+
+	UNUSED(id);
+
+	return ret;
+}
+#endif

middleware/v2/modules/bin/src/vo_json_struct.c

@@ -0,0 +1,26 @@
+#include <string.h>
+#include "vo_json_struct.h"
+
+/**************************************************************************
+ *   Json struct related APIs.
+ **************************************************************************/
+void VO_GAMMA_INFO_S_JSON(int r_w_flag, JSON *j, char *key, VO_GAMMA_INFO_S *data)
+{
+	JSON_START(r_w_flag);
+
+	JSON(r_w_flag, CVI_BOOL, enable);
+	JSON(r_w_flag, CVI_BOOL, osd_apply);
+	JSON_A(r_w_flag, CVI_U8, value, VO_GAMMA_NODENUM);
+
+	JSON_END(r_w_flag);
+}
+void VO_BIN_INFO_S_JSON(int r_w_flag, JSON *j, char *key, VO_BIN_INFO_S *data)
+{
+	JSON_START(r_w_flag);
+
+	JSON(r_w_flag, VO_GAMMA_INFO_S, gamma_info);
+	JSON(r_w_flag, CVI_U32, guard_magic);
+
+	JSON_END(r_w_flag);
+}
+

middleware/v2/modules/bin/src/vpss_bin.c

@@ -0,0 +1,192 @@
+#include <linux/cvi_type.h>
+#include "cvi_bin.h"
+#include "cvi_base.h"
+#include "vpss_bin.h"
+#include "cvi_vpss.h"
+#include "rw_json.h"
+#include <linux/cvi_defines.h>
+#include "vpss_json_struct.h"
+#include "cvi_json_struct_comm.h"
+#include "vpss_ioctl.h"
+
+
+static VPSS_BIN_DATA vpss_bin_data[VPSS_MAX_GRP_NUM];
+static CVI_BOOL g_bLoadBinDone = CVI_FALSE;
+
+VPSS_BIN_DATA *get_vpssbindata_addr(void)
+{
+	return vpss_bin_data;
+}
+
+CVI_BOOL get_loadbin_state(void)
+{
+	return g_bLoadBinDone;
+}
+
+static CVI_S32 get_vpss_ctx_proc_amp(VPSS_BIN_DATA *pBinData)
+{
+	CVI_S32 fd = get_vpss_fd();
+	CVI_S32 s32Ret;
+	struct vpss_all_proc_amp_cfg cfg;
+
+	s32Ret = vpss_get_all_proc_amp(fd, &cfg);
+	if (s32Ret != CVI_SUCCESS) {
+		CVI_TRACE_VPSS(CVI_DBG_ERR, "vpss_get_all_proc_amp fail\n");
+		return s32Ret;
+	}
+	for (int i = 0; i < VPSS_MAX_GRP_NUM; ++i)
+		memcpy(pBinData[i].proc_amp, cfg.proc_amp[i], sizeof(pBinData[i].proc_amp));
+
+	return CVI_SUCCESS;
+}
+
+/**************************************************************************
+ *   Bin related APIs.
+ **************************************************************************/
+CVI_S32 vpss_bin_getbinsize(CVI_U32 *size)
+{
+	*size = sizeof(VPSS_BIN_DATA) * VPSS_MAX_GRP_NUM;
+
+	return CVI_SUCCESS;
+}
+
+CVI_S32 vpss_bin_getparamfrombin(CVI_U8 *addr, CVI_U32 size)
+{
+	CVI_U32 u32DataSize = 0;
+	VPSS_BIN_DATA *pstVpssBinData = vpss_bin_data;
+
+	vpss_bin_getbinsize(&u32DataSize);
+	memset(pstVpssBinData, 0, u32DataSize);
+	if (size > u32DataSize) {
+		CVI_TRACE_VPSS(CVI_DBG_WARN, "Bin size(%d) > max size(%d).\n", size, u32DataSize);
+		return CVI_FAILURE;
+	}
+	memcpy(pstVpssBinData, addr, size);
+	g_bLoadBinDone = CVI_TRUE;
+
+	return CVI_SUCCESS;
+}
+
+CVI_S32 vpss_bin_setparamtobuf(CVI_U8 *buffer)
+{
+	CVI_S32 ret = CVI_SUCCESS;
+	CVI_U32 u32DataSize = 0;
+	VPSS_BIN_DATA *pstVpssBinData = vpss_bin_data;
+	VPSS_BIN_DATA stVpssCtxProcAmp[VPSS_MAX_GRP_NUM];
+
+	get_vpss_ctx_proc_amp(stVpssCtxProcAmp);
+	vpss_bin_getbinsize(&u32DataSize);
+	for (int i = 0; i < VPSS_MAX_GRP_NUM; ++i) {
+		memcpy(pstVpssBinData[i].proc_amp, stVpssCtxProcAmp[i].proc_amp, sizeof(pstVpssBinData[i].proc_amp));
+	}
+	memcpy(buffer, pstVpssBinData, u32DataSize);
+	return ret;
+}
+
+CVI_S32 vpss_bin_setparamtobin(FILE *fp)
+{
+	CVI_S32 ret = CVI_SUCCESS;
+	CVI_U32 u32DataSize = 0;
+	VPSS_BIN_DATA *pstVpssBinData = vpss_bin_data;
+	VPSS_BIN_DATA stVpssCtxProcAmp[VPSS_MAX_GRP_NUM];
+
+	get_vpss_ctx_proc_amp(stVpssCtxProcAmp);
+	vpss_bin_getbinsize(&u32DataSize);
+	for (int i = 0; i < VPSS_MAX_GRP_NUM; ++i) {
+		memcpy(pstVpssBinData[i].proc_amp, stVpssCtxProcAmp[i].proc_amp, sizeof(pstVpssBinData[i].proc_amp));
+	}
+	fwrite(pstVpssBinData, u32DataSize, 1, fp);
+	return ret;
+}
+
+#ifndef DISABLE_PQBIN_JSON
+/**************************************************************************
+ *   Json related APIs.
+ **************************************************************************/
+
+static CVI_S32 vpss_json_getparam(CVI_U8 *addr)
+{
+	CVI_S32 ret = CVI_SUCCESS;
+	CVI_U32 u32DataSize = 0;
+	VPSS_BIN_DATA *pstPtr = (VPSS_BIN_DATA *)addr;
+	VPSS_BIN_DATA *pstVpssBinData = vpss_bin_data;
+	VPSS_BIN_DATA stVpssCtxProcAmp[VPSS_MAX_GRP_NUM];
+
+	get_vpss_ctx_proc_amp(stVpssCtxProcAmp);
+	vpss_bin_getbinsize(&u32DataSize);
+	for (int i = 0; i < VPSS_MAX_GRP_NUM; ++i)
+		memcpy(pstVpssBinData[i].proc_amp, stVpssCtxProcAmp[i].proc_amp, sizeof(pstVpssBinData[i].proc_amp));
+
+	memcpy(pstPtr, pstVpssBinData, u32DataSize);
+
+	return ret;
+}
+
+static CVI_S32 vpss_json_setparam(CVI_U8 *addr)
+{
+	CVI_U32 u32DataSize = 0;
+	VPSS_BIN_DATA *pstVpssBinData = vpss_bin_data;
+
+	vpss_bin_getbinsize(&u32DataSize);
+	memcpy(pstVpssBinData, addr, u32DataSize);
+	g_bLoadBinDone = CVI_TRUE;
+
+	return CVI_SUCCESS;
+}
+
+CVI_S32 vpss_json_getParamFromJsonbuffer(const char *buffer, enum CVI_BIN_SECTION_ID id)
+{
+	JSON *json_object;
+	CVI_S32 ret = CVI_SUCCESS;
+	VPSS_PARAMETER_BUFFER vpss_parameter = { 0 };
+
+	json_object = JSON_TokenerParse(buffer);
+	if (json_object) {
+		vpss_json_getparam((CVI_U8 *)vpss_parameter.vpss_bin_data);
+		JSON_(R_FLAG, json_object, VPSS_PARAMETER_BUFFER, "vpss_parameter", &vpss_parameter);
+		vpss_json_setparam((CVI_U8 *)vpss_parameter.vpss_bin_data);
+
+		JSON_ObjectPut(json_object);
+	} else {
+		CVI_TRACE_VPSS(LOG_WARNING, "(id:%d)Creat json tokener fail.\n", id);
+		ret = CVI_BIN_JSONHANLE_ERROR;
+	}
+
+	UNUSED(id);
+	return ret;
+}
+
+CVI_S32 vpss_json_setParamToJsonbuffer(CVI_S8 **buffer, enum CVI_BIN_SECTION_ID id, CVI_S32 *len)
+{
+	VPSS_PARAMETER_BUFFER vpss_parameter = { 0 };
+	JSON *json_object;
+	CVI_S32 ret = CVI_SUCCESS;
+
+	json_object = JSON_GetNewObject();
+	if (json_object) {
+		vpss_json_getparam((CVI_U8 *)vpss_parameter.vpss_bin_data);
+		JSON_(W_FLAG, json_object, VPSS_PARAMETER_BUFFER, "vpss_parameter", &vpss_parameter);
+
+		*len = JSON_GetJsonStrLen(json_object);
+		*buffer = (CVI_S8 *)malloc(*len);
+		if (*buffer == NULL) {
+			ret = CVI_BIN_MALLOC_ERR;
+			CVI_TRACE_VPSS(LOG_WARNING, "%s\n", "Allocate memory fail");
+			goto ERROR_HANDLER;
+		}
+		memcpy(*buffer, JSON_GetJsonStrContent(json_object), *len);
+	} else {
+		CVI_TRACE_VPSS(LOG_WARNING, "(id:%d)Get New Object fail.\n", id);
+		ret = CVI_BIN_JSONHANLE_ERROR;
+	}
+
+ERROR_HANDLER:
+	if (json_object) {
+		JSON_ObjectPut(json_object);
+	}
+
+	UNUSED(id);
+
+	return ret;
+}
+#endif

middleware/v2/modules/bin/src/vpss_json_struct.c

@@ -0,0 +1,24 @@
+#include "cvi_json_struct_comm.h"
+#include "cvi_vpss.h"
+#include "vpss_json_struct.h"
+
+/**************************************************************************
+ *   Json struct related APIs.
+ **************************************************************************/
+//VPSS_PARAMETER_BUFFER json & struct
+static void VPSS_BIN_DATA_JSON(int r_w_flag, JSON *j, char *key, VPSS_BIN_DATA *data)
+{
+	JSON_START(r_w_flag);
+
+	JSON_A(r_w_flag, CVI_S32, proc_amp, PROC_AMP_MAX);
+
+	JSON_END(r_w_flag);
+}
+void VPSS_PARAMETER_BUFFER_JSON(int r_w_flag, JSON *j, char *key, VPSS_PARAMETER_BUFFER *data)
+{
+	JSON_START(r_w_flag);
+
+	JSON_A(r_w_flag, VPSS_BIN_DATA, vpss_bin_data, VPSS_MAX_GRP_NUM);
+
+	JSON_END(r_w_flag);
+}

middleware/v2/modules/gyro/include/cvi_gyro.h

@@ -0,0 +1,183 @@
+/*
+ * Copyright (C) Cvitek Co., Ltd. 2019-2020. All rights reserved.
+ *
+ * File Name: cvi_ive.h
+ * Description:
+ */
+
+#ifndef __CVI_GYRO_H__
+#define __CVI_GYRO_H__
+
+#include "linux/cvi_type.h"
+#ifndef UNUSED
+#define UNUSED(x) ((void)(x))
+#endif
+#ifdef __cplusplus
+#if __cplusplus
+extern "C" {
+extern __attribute__((weak)) void *__dso_handle;
+#endif
+#endif /* End of #ifdef __cplusplus */
+
+enum registers {
+	//main chip
+	USER_CTRL         = 0x6A,
+	PWR_MGMT_1        = 0x6B,
+	PWR_MGMT_2        = 0x6C,
+	SIGNAL_PATH_RESET = 0x68,
+	INT_PIN_CFG       = 0x37,
+	ACCEL_CONFIG      = 0x1C,
+	ACCEL_CONFIG_2    = 0x1D,
+	MOT_DETECT_CTRL   = 0x69,
+	WOM_THR           = 0x1F,
+	GYRO_CONFIG       = 0x1B,
+	CONFIG            = 0x1A,
+	SMPLRT_DIV        = 0x19,
+	INT_ENABLE        = 0x38,
+	INT_STATUS        = 0x3A,
+	WHO_AM_I          = 0x75,
+
+	/// gyro
+	GYRO_XOUT_H       = 0x43,
+	GYRO_XOUT_L       = 0x44,
+	GYRO_YOUT_H       = 0x45,
+	GYRO_YOUT_L       = 0x46,
+	GYRO_ZOUT_H       = 0x47,
+	GYRO_ZOUT_L       = 0x48,
+
+	/// accelerometer
+	ACCEL_XOUT_H      = 0x3B,
+	ACCEL_XOUT_L      = 0x3C,
+	ACCEL_YOUT_H      = 0x3D,
+	ACCEL_YOUT_L      = 0x3E,
+	ACCEL_ZOUT_H      = 0x3F,
+	ACCEL_ZOUT_L      = 0x40,
+
+	// thermometer
+	TEMP_OUT_H        = 0x41,
+	TEMP_OUT_L        = 0x42,
+};
+
+/**
+ * @brief Create gyro instance.
+ *
+ * @return CVI_SUCCESS if create succeed.
+ */
+CVI_S32 CVI_GYRO_Create(void);
+
+/**
+ * @brief Destroy gyro instance.
+ */
+CVI_VOID CVI_GYRO_Destroy(void);
+
+/**
+ * @brief Reset gyro.
+ *
+ * @return CVI_SUCCESS if create succeed.
+ */
+CVI_S32 CVI_GYRO_Reset(void);
+
+/**
+ * @brief Check gyro sensor id.
+ *
+ * @param val Receive sensor id result, expect 0x70.
+ * @return CVI_SUCCESS if create succeed.
+ */
+CVI_S32 CVI_GYRO_WHO_AM_I(CVI_U8 *val);
+
+/**
+ * @brief Gyro (x y z axis) calibration.
+ *
+ * @return CVI_SUCCESS if calibration succeed.
+ */
+CVI_S32 CVI_GYRO_CALIBRATION(void);
+
+/**
+ * @brief Accelerometer (x y z axis) calibration.
+ *
+ * @return CVI_SUCCESS if calibration succeed.
+ */
+CVI_S32 CVI_GYRO_ACC_CALIBRATION(void);
+
+/**
+ * @brief Get gyro x, y, z axis value.
+ *
+ * @param val Receive axis result.
+ * @return CVI_SUCCESS if create succeed.
+ */
+CVI_S32 CVI_GYRO_GET_GX(CVI_S16 *val);
+CVI_S32 CVI_GYRO_GET_GY(CVI_S16 *val);
+CVI_S32 CVI_GYRO_GET_GZ(CVI_S16 *val);
+
+/**
+ * @brief Get accelerometer x, y, z axis value.
+ *
+ * @param val Receive axis result.
+ * @return CVI_SUCCESS if create succeed.
+ */
+CVI_S32 CVI_GYRO_GET_AX(CVI_S16 *val);
+CVI_S32 CVI_GYRO_GET_AY(CVI_S16 *val);
+CVI_S32 CVI_GYRO_GET_AZ(CVI_S16 *val);
+
+/**
+ * @brief Get acc/gyro x, y, z axis value at same time.
+ *
+ * @param x_val Receive x axis result.
+ * @param y_val Receive y axis result.
+ * @param z_val Receive z axis result.
+ * @return CVI_SUCCESS if create succeed.
+ */
+CVI_S32 CVI_GYRO_GET_G_XYZ(CVI_S16 *x_val, CVI_S16 *y_val, CVI_S16 *z_val);
+CVI_S32 CVI_GYRO_GET_A_XYZ(CVI_S16 *x_val, CVI_S16 *y_val, CVI_S16 *z_val);
+
+/**
+ * @brief Get thermometer value.
+ *
+ * @param val Receive thermometer result.
+ * @return CVI_SUCCESS if create succeed.
+ */
+CVI_S32 CVI_GYRO_GET_TEMP(CVI_S16 *val);
+
+/**
+ * @brief Read mpuxxxx register address value.
+ *
+ * @param addr Set register address, you want.
+ * @param val Receive address value.
+ * @return CVI_SUCCESS if create succeed.
+ */
+CVI_S32 CVI_GYRO_READ(CVI_U8 addr, CVI_U8 *val);
+
+/**
+ * @brief Write value to mpuxxxx register address.
+ *
+ * @param addr Set register address, you want.
+ * @param val Set value to addr.
+ * @return CVI_SUCCESS if create succeed.
+ */
+CVI_S32 CVI_GYRO_WRITE(CVI_U8 addr, CVI_U8 val);
+
+/**
+ * @brief The value with addr OR first, then write.
+ *
+ * @param addr Set register address, you want.
+ * @param val Set (value | addr value) to addr.
+ * @return CVI_SUCCESS if create succeed.
+ */
+CVI_S32 CVI_GYRO_WRITE_OR(CVI_U8 addr, CVI_U8 val);
+
+/**
+ * @brief The value with addr AND first, then write.
+ *
+ * @param addr Set register address, you want.
+ * @param val Set (value & addr value) to addr.
+ * @return CVI_SUCCESS if create succeed.
+ */
+CVI_S32 CVI_GYRO_WRITE_AND(CVI_U8 addr, CVI_U8 val);
+
+#ifdef __cplusplus
+#if __cplusplus
+}
+#endif
+#endif /* __cplusplus */
+
+#endif // __CVI_GYRO_H__

middleware/v2/modules/isp/Makefile

@@ -0,0 +1,10 @@
+.PHONY: clean all
+.SILENT: clean all
+
+include isp.mk
+
+all:
+	cp lib/$(SDK_VER)/lib* $(MW_LIB)
+
+clean:
+

middleware/v2/modules/isp/isp.mk

@@ -0,0 +1,8 @@
+ifeq ($(PARAM_FILE), )
+	PARAM_FILE:=../../../$(shell echo $(MW_VER))/Makefile.param
+	include $(PARAM_FILE)
+endif
+
+isp_chip_dir := $(shell echo $(CHIP_ARCH) | tr A-Z a-z)
+
+