GK SDK 源码库: XMIPCLinuxV100R005C00SPC030 (kernel/tools/open_source excluded)

sample/quickstart/Makefile

@@ -0,0 +1,23 @@
+ifeq ($(CFG_XMEDIA_EXPORT_FLAG),)
+        SDK_DIR := $(shell  cd $(CURDIR)/../../ && /bin/pwd)
+endif
+
+include $(SDK_DIR)/build/base.mk
+
+objects :=
+objects += quickstart_ramfs
+objects += quickstart_rootfs
+objects_clean := $(addsuffix _clean, $(objects))
+
+.PHONY: all clean $(objects) $(objects_clean)
+
+all: $(objects)
+
+clean: $(objects_clean)
+
+$(objects):
+	$(AT)$(MAKE) -C $@
+
+$(objects_clean):
+	$(AT)$(MAKE) -C $(patsubst %_clean, %, $@) clean
+

sample/quickstart/media_comm/media_comm.h

@@ -0,0 +1,191 @@
+#ifndef __MEDIA_COMM_H__
+#define __MEDIA_COMM_H__
+
+#include <stdio.h>
+
+#include "xmedia_type.h"
+#include "xmedia_video_common.h"
+#include "xmedia_sys.h"
+#include "xmedia_vb.h"
+#include "xmedia_vi.h"
+#include "xmedia_isp.h"
+#include "xmedia_ae.h"
+#include "xmedia_awb.h"
+#include "xmedia_venc.h"
+#include "xmedia_vpss.h"
+#include "xmedia_vgs.h"
+#include "xmedia_svp.h"
+#include "xmedia_tde.h"
+#include "xmedia_pm.h"
+#include "xmedia_cl.h"
+#include "xmedia_mmz.h"
+#include "xmedia_ive_common.h"
+#include "xmedia_ive.h"
+#include "xmedia_md.h"
+
+#define MEDIA_PRINTF 1
+#define MEDIA_ERROR  1
+
+#define VI_MAX_BIND_PIPE   2
+#define MAGIC_DATA_LEN 16
+
+
+#define MEDIA_PRT(fmt...)   \
+    do {\
+       if(MEDIA_PRINTF == 1)\
+       {\
+            printf("[%s]-%d: ", __FUNCTION__, __LINE__);\
+            printf(fmt);\
+       }\
+    }while(0)
+
+#define MEDIA_ERR(fmt...)   \
+    do {\
+       if(MEDIA_ERROR == 1)\
+       {\
+           printf("[%s]-%d: ", __FUNCTION__, __LINE__);\
+           printf(fmt);\
+       }\
+    }while(0)
+
+#define SCENE_AUTO_BIN_PATH      "/usr/param/pq.bin"
+#define FPN_BIN_PATH             "/usr/param/fpn.bin"
+#define ISP_AINR_MODEL_PATH      "/usr/param/neuron_network.xmm"
+
+typedef enum media_comm_sensor_num {
+    MEDIA_SENSOR0 = 0,
+    MEDIA_SENSOR1,
+} media_comm_sensor_num;
+
+typedef struct media_comm_sys_config {
+    xmedia_sys_config sys_conf;
+    xmedia_vb_config vb_conf;
+} media_comm_sys_config;
+
+typedef struct media_comm_isp_cfg {
+    xmedia_s32 vi_dev;
+    xmedia_s32 isp_pipe;
+    media_comm_sensor_num sns_num;
+    xmedia_bool en_quickstart;
+} media_comm_isp_cfg;
+
+typedef struct media_comm_vi_pipe_info {
+     xmedia_vi_pipe_config vi_pipe_cfg;
+     xmedia_vi_chn_config  vi_chn_cfg;
+     xmedia_bool en_vi_cap_lowdelay;
+     xmedia_vi_lowdelay_attr vi_cap_lowdelay;
+     xmedia_bool en_vi_proc_lowdelay;
+     xmedia_vi_lowdelay_attr vi_proc_lowdelay;
+} media_comm_vi_pipe_info;
+
+typedef struct media_comm_vi_pipe_param {
+    xmedia_s32 vi_pipe_work_num;
+    xmedia_s32 vi_pipe[VI_MAX_BIND_PIPE];
+    media_comm_vi_pipe_info vi_pipe_info[VI_MAX_BIND_PIPE];
+} media_comm_vi_pipe_param;
+
+typedef struct media_comm_vi_grp_param {
+    xmedia_s32 vi_grp_work_num;
+    xmedia_s32 vi_grp[VI_MAX_GRP_NUM];
+    xmedia_vi_grp_config vi_grp_cfg[VI_MAX_GRP_NUM];
+} media_comm_vi_grp_param;
+
+typedef struct media_comm_vi_cfg {
+    xmedia_s32 vi_dev_work_num;
+    xmedia_s32 vi_dev[VI_MAX_DEV_NUM];
+    xmedia_bool en_quickstart[VI_MAX_DEV_NUM];
+    xmedia_vi_dev_mipi_phy_config mipi_cfg[VI_MAX_DEV_NUM];
+    xmedia_vi_dev_config vi_dev_cfg[VI_MAX_DEV_NUM];
+    media_comm_vi_pipe_param vi_pipe_param[VI_MAX_DEV_NUM];
+    media_comm_vi_grp_param vi_grp_param;
+} media_comm_vi_cfg;
+
+typedef struct media_comm_vpss_ochn_info {
+    xmedia_s32 vpss_ochn_work_num;
+    xmedia_s32 vpss_ochn[VPSS_MAX_PHY_OCHN_NUM];
+    xmedia_vpss_ochn_config vpss_ochn_cfg[VPSS_MAX_PHY_OCHN_NUM];
+    xmedia_vpss_low_delay_attr vpss_lowdelay_cfg[VPSS_MAX_PHY_OCHN_NUM];
+    xmedia_video_wrap_attr vpss_wrap_cfg[VPSS_MAX_PHY_OCHN_NUM];
+} media_comm_vpss_ochn_info;
+
+typedef struct media_comm_vpss_cfg {
+    xmedia_s32 vpss_pipe_work_num;
+    xmedia_s32 vpss_pipe[VPSS_MAX_PIPE_NUM];
+    xmedia_vpss_pipe_config pipe_cfg[VPSS_MAX_PIPE_NUM];
+    media_comm_vpss_ochn_info vpss_ochn_info[VPSS_MAX_PIPE_NUM];
+} media_comm_vpss_cfg;
+
+typedef struct media_comm_venc_cfg {
+    xmedia_u32 max_pic_width;
+    xmedia_u32 max_pic_height;
+    xmedia_u32 profile;
+    xmedia_payload_type en_type;
+    xmedia_venc_rc_mode rc_mode;
+    xmedia_bool rcn_ref_share_buf;
+    xmedia_u32 src_frame_rate;
+    xmedia_u32 dst_frame_rate;
+    xmedia_venc_gop_attr venc_gop_attr;
+} media_comm_venc_cfg;
+
+typedef struct media_comm_isp_ainr_cfg {
+    xmedia_cl_context    cl_ctx;
+    xmedia_u32           cl_device_num;
+    xmedia_cl_device_id *cl_device;
+    xmedia_u64           work_space_phyaddr;
+    xmedia_void         *work_space_viraddr;
+} media_comm_isp_ainr_cfg;
+
+typedef struct media_comm_isp_sensor_info {
+    xmedia_video_size sns_max_size;
+    xmedia_float      frame_rate;
+} media_comm_isp_sensor_info;
+
+typedef struct vi_info {
+    xmedia_s32 enable;
+    xmedia_s32 pipe;
+} bin_vi_info;
+
+typedef struct module_info {
+    bin_vi_info vi;
+} bin_module_info;
+
+static const xmedia_u8 magic_isp[MAGIC_DATA_LEN] = "ISP_BIN";
+
+xmedia_s32 media_comm_sys_init(media_comm_sys_config* sys_cfg);
+xmedia_s32 media_comm_sys_exit();
+xmedia_s32 media_comm_media_init();
+xmedia_s32 media_comm_media_exit();
+xmedia_s32 media_comm_mem_open(xmedia_void);
+xmedia_void media_comm_mem_close(xmedia_void);
+xmedia_void media_comm_set_reg(xmedia_u32 addr,xmedia_u32 value);
+xmedia_s32 media_comm_get_reg(xmedia_u32 u32Addr);
+xmedia_u64 media_comm_get_cur_time();
+xmedia_s32 media_comm_vi_bind_vpss(xmedia_s32 vi_pipe, xmedia_s32 vi_chn, xmedia_s32 vpss_pipe, xmedia_s32 vpss_ichn);
+xmedia_s32 media_comm_vi_unbind_vpss(xmedia_s32 vi_pipe, xmedia_s32 vi_chn, xmedia_s32 vpss_pipe, xmedia_s32 vpss_ichn);
+xmedia_s32 media_comm_sys_vpss_bind_venc(xmedia_s32 vpss_pipe, xmedia_s32 vpss_ochn, xmedia_s32 venc_chn);
+xmedia_s32 media_comm_sys_vpss_unbind_venc(xmedia_s32 vpss_pipe, xmedia_s32 vpss_ochn, xmedia_s32 venc_chn);
+xmedia_s32 media_comm_isp_get_sensor_info(media_comm_sensor_num sns_num, media_comm_isp_sensor_info *sns_info);
+xmedia_s32 media_comm_isp_set_sensor_info(media_comm_sensor_num sns_num, media_comm_isp_sensor_info *sns_info);
+xmedia_s32 media_comm_isp_init(media_comm_isp_cfg media_isp_cfg);
+xmedia_s32 media_comm_isp_exit(xmedia_s32 pipe, media_comm_sensor_num sns_num);
+xmedia_s32 media_comm_isp_start(xmedia_s32 pipe, xmedia_bool en_start);
+xmedia_s32 media_comm_isp_stop(xmedia_s32 pipe, xmedia_bool en_start);
+xmedia_s32 media_comm_isp_get_mipi_rate(xmedia_s32 isp_pipe);
+xmedia_s32 media_comm_vi_start(media_comm_vi_cfg* vi_cfg);
+xmedia_s32 media_comm_vi_stop(media_comm_vi_cfg* vi_cfg);
+xmedia_s32 media_comm_vpss_start(media_comm_vpss_cfg* vpss_cfg);
+xmedia_s32 media_comm_vpss_stop(media_comm_vpss_cfg* vpss_cfg);
+xmedia_s32 media_comm_venc_start(xmedia_s32 venc_chn, media_comm_venc_cfg* venc_cfg);
+xmedia_s32 media_comm_venc_stop(xmedia_s32 venc_chn);
+xmedia_s32 media_comm_venc_get_max_chn_size(xmedia_s32 venc_chn);
+
+xmedia_s32 media_comm_isp_ainr_init(const xmedia_char* ainr_model_name);
+xmedia_s32 media_comm_isp_ainr_exit();
+xmedia_s32 media_comm_isp_ainr_load_model(xmedia_s32 isp_pipe, xmedia_s32 model_num, xmedia_char** ainr_model_name);
+xmedia_s32 media_comm_isp_ainr_unload_model(xmedia_s32 isp_pipe);
+xmedia_s32 media_comm_isp_ainr_enable(xmedia_s32 isp_pipe);
+xmedia_s32 media_comm_scene_auto_enable(bin_module_info *module);
+xmedia_s32 media_comm_fpn_enable(xmedia_s32 isp_pipe, xmedia_s32 width, xmedia_s32 height);
+
+
+#endif /*__MEDIA_COMM_H__*/

sample/quickstart/media_comm/media_param.h

@@ -0,0 +1,389 @@
+#ifndef __MEDIA_PARAM_H__
+#define __MEDIA_PARAM_H__
+
+#include "media_comm.h"
+
+
+/****************************************************
+***************support sensor list*******************
+SMART_SC485SL_MIPI_4M_30FPS_2LANE_12BIT
+SMART_SC485SL_MIPI_4M_30FPS_4LANE_12BIT
+SMART_SC485SL_MIPI_4M_60FPS_4LANE_12BIT
+SMART_SC235HAI_MIPI_2M_2LANE_30FPS_10BIT
+*****************************************************/
+
+#ifdef SMART_SC485SL_MIPI_4M_30FPS_2LANE_12BIT
+
+static xmedia_isp_config MEDIA_COMM_ISP_CFG_SENSOR0 = {
+    .fps = 30,
+    .size = {
+        .width = 2560,
+        .height = 1440,
+    },
+    .bayer_fmt = XMEDIA_VIDEO_BAYER_FMT_BGGR,
+    .pixel_fmt = XMEDIA_VIDEO_PIXEL_FMT_RAW,
+    .wdr_mode = XMEDIA_VIDEO_WDR_MODE_NONE,
+    .mode_config = {
+        .work_mode = XMEDIA_ISP_WORK_MODE_MASTER,
+        .master_mode = {
+            .blend_stat_enable = XMEDIA_FALSE,
+            .slave_num = 0,
+        },
+    },
+};
+
+static xmedia_vi_dev_config MEDIA_COMM_VI_DEV_CFG_SENSOR0 = {
+    .intf_type = XMEDIA_INTF_TYPE_MIPI_CSI,
+    .mipi_attr = {
+        .input_data_type = XMEDIA_INTF_MIPI_CSI_DATA_TYPE_RAW_12BIT,
+        .lane_mode = XMEDIA_VI_MIPI_LANE_DIVIDE_MODE_2_LANE,
+        .wdr_format = XMEDIA_VIDEO_WDR_FMT_NONE,
+    },
+};
+
+static xmedia_vi_pipe_config MEDIA_COMM_VI_PIPE_CFG_SENSOR0 = {
+    .bit_width = XMEDIA_VIDEO_DATA_WIDTH_12,
+    .compress_mode = XMEDIA_VIDEO_COMPRESS_MODE_NONE,
+    .frm_rate_ctrl = {
+        .src_frm_rate = -1,
+        .dst_frm_rate = -1,
+    },
+    .isp_bypass = XMEDIA_FALSE,
+    .pipe_bypass_mode = XMEDIA_VI_PIPE_BYPASS_NONE,
+    .pix_fmt = XMEDIA_VIDEO_PIXEL_FMT_RAW,
+    .gdc_en = XMEDIA_FALSE, //default false
+    .in_size = {
+        .width = 2560,
+        .height = 1440,
+    },
+    .bnr_attr = {
+        .bnr_en = XMEDIA_TRUE,
+        .compress_mode = XMEDIA_VIDEO_COMPRESS_MODE_LINE,
+    },
+    .stnr_attr = {
+        .stnr_en = XMEDIA_TRUE,
+        .compress_mode = XMEDIA_VIDEO_COMPRESS_MODE_LINE,
+    },
+};
+
+static xmedia_vi_chn_config MEDIA_COMM_VI_CHN_CFG_SENSOR0 = {
+    .compress_mode = XMEDIA_VIDEO_COMPRESS_MODE_NONE,
+    .dynamic_range = XMEDIA_VIDEO_DYNAMIC_RANGE_SDR,
+    .flip_en = XMEDIA_FALSE,
+    .mirror_en = XMEDIA_FALSE,
+    .pix_fmt = XMEDIA_VIDEO_PIXEL_FMT_YVU_SEMIPLANAR_420,
+    .video_fmt = XMEDIA_VIDEO_FMT_LINEAR,
+    .depth = 0,
+    .frm_rate_ctrl = {
+        .src_frm_rate = -1,
+        .dst_frm_rate = -1,
+    },
+    .out_size = {
+        .width = 2560,
+        .height = 1440,
+    },
+};
+
+#endif
+
+#ifdef SMART_SC485SL_MIPI_4M_30FPS_4LANE_12BIT
+
+static const xmedia_s32 sc485sl_width  = 2688;
+static const xmedia_s32 sc485sl_height = 1520;
+
+static xmedia_isp_config MEDIA_COMM_ISP_CFG_SENSOR0 = {
+    .fps = 12,
+    .size = {
+        .width = sc485sl_width,
+        .height = sc485sl_height,
+    },
+    .bayer_fmt = XMEDIA_VIDEO_BAYER_FMT_BGGR,
+    .pixel_fmt = XMEDIA_VIDEO_PIXEL_FMT_RAW,
+    .wdr_mode = XMEDIA_VIDEO_WDR_MODE_NONE,
+    .mode_config = {
+        .work_mode = XMEDIA_ISP_WORK_MODE_MASTER,
+        .master_mode = {
+            .blend_stat_enable = XMEDIA_FALSE,
+            .slave_num = 0,
+        },
+    },
+};
+
+static xmedia_vi_dev_config MEDIA_COMM_VI_DEV_CFG_SENSOR0 = {
+    .intf_type = XMEDIA_INTF_TYPE_MIPI_CSI,
+    .mipi_attr = {
+        .input_data_type = XMEDIA_INTF_MIPI_CSI_DATA_TYPE_RAW_12BIT,
+        .lane_mode = XMEDIA_VI_MIPI_LANE_DIVIDE_MODE_4_LANE,
+        .wdr_format = XMEDIA_VIDEO_WDR_FMT_NONE,
+    },
+};
+
+static xmedia_vi_pipe_config MEDIA_COMM_VI_PIPE_CFG_SENSOR0 = {
+    .bit_width = XMEDIA_VIDEO_DATA_WIDTH_12,
+    .compress_mode = XMEDIA_VIDEO_COMPRESS_MODE_NONE,
+    .frm_rate_ctrl = {
+        .src_frm_rate = -1,
+        .dst_frm_rate = -1,
+    },
+    .isp_bypass = XMEDIA_FALSE,
+    .pipe_bypass_mode = XMEDIA_VI_PIPE_BYPASS_NONE,
+    .pix_fmt = XMEDIA_VIDEO_PIXEL_FMT_RAW,
+    .gdc_en = XMEDIA_FALSE, //default false
+    .in_size = {
+        .width = sc485sl_width,
+        .height = sc485sl_height,
+    },
+    .bnr_attr = {
+        .bnr_en = XMEDIA_TRUE,
+        .compress_mode = XMEDIA_VIDEO_COMPRESS_MODE_LINE,
+    },
+    .stnr_attr = {
+        .stnr_en = XMEDIA_TRUE,
+        .compress_mode = XMEDIA_VIDEO_COMPRESS_MODE_LINE,
+    },
+};
+
+static xmedia_vi_chn_config MEDIA_COMM_VI_CHN_CFG_SENSOR0 = {
+    .compress_mode = XMEDIA_VIDEO_COMPRESS_MODE_NONE,
+    .dynamic_range = XMEDIA_VIDEO_DYNAMIC_RANGE_SDR,
+    .flip_en = XMEDIA_FALSE,
+    .mirror_en = XMEDIA_FALSE,
+    .pix_fmt = XMEDIA_VIDEO_PIXEL_FMT_YVU_SEMIPLANAR_420,
+    .video_fmt = XMEDIA_VIDEO_FMT_LINEAR,
+    .depth = 0,
+    .frm_rate_ctrl = {
+        .src_frm_rate = -1,
+        .dst_frm_rate = -1,
+    },
+    .out_size = {
+        .width = sc485sl_width,
+        .height = sc485sl_height,
+    },
+};
+
+#endif
+
+#ifdef SMART_SC485SL_MIPI_4M_60FPS_4LANE_12BIT
+
+static const xmedia_s32 sc485sl_width  = 2560;
+static const xmedia_s32 sc485sl_height = 1440;
+
+static xmedia_isp_config MEDIA_COMM_ISP_CFG_SENSOR0 = {
+    .fps = 30,
+    .size = {
+        .width = sc485sl_width,
+        .height = sc485sl_height,
+    },
+    .bayer_fmt = XMEDIA_VIDEO_BAYER_FMT_BGGR,
+    .pixel_fmt = XMEDIA_VIDEO_PIXEL_FMT_RAW,
+    .wdr_mode = XMEDIA_VIDEO_WDR_MODE_NONE,
+    .mode_config = {
+        .work_mode = XMEDIA_ISP_WORK_MODE_MASTER,
+        .master_mode = {
+            .blend_stat_enable = XMEDIA_FALSE,
+            .slave_num = 0,
+        },
+    },
+};
+
+static xmedia_vi_dev_config MEDIA_COMM_VI_DEV_CFG_SENSOR0 = {
+    .intf_type = XMEDIA_INTF_TYPE_MIPI_CSI,
+    .mipi_attr = {
+        .input_data_type = XMEDIA_INTF_MIPI_CSI_DATA_TYPE_RAW_12BIT,
+        .lane_mode = XMEDIA_VI_MIPI_LANE_DIVIDE_MODE_4_LANE,
+        .wdr_format = XMEDIA_VIDEO_WDR_FMT_NONE,
+    },
+};
+
+static xmedia_vi_pipe_config MEDIA_COMM_VI_PIPE_CFG_SENSOR0 = {
+    .bit_width = XMEDIA_VIDEO_DATA_WIDTH_12,
+    .compress_mode = XMEDIA_VIDEO_COMPRESS_MODE_NONE,
+    .frm_rate_ctrl = {
+        .src_frm_rate = -1,
+        .dst_frm_rate = -1,
+    },
+    .isp_bypass = XMEDIA_FALSE,
+    .pipe_bypass_mode = XMEDIA_VI_PIPE_BYPASS_NONE,
+    .pix_fmt = XMEDIA_VIDEO_PIXEL_FMT_RAW,
+    .gdc_en = XMEDIA_FALSE, //default false
+    .in_size = {
+        .width = sc485sl_width,
+        .height = sc485sl_height,
+    },
+    .bnr_attr = {
+        .bnr_en = XMEDIA_TRUE,
+        .compress_mode = XMEDIA_VIDEO_COMPRESS_MODE_LINE,
+    },
+    .stnr_attr = {
+        .stnr_en = XMEDIA_TRUE,
+        .compress_mode = XMEDIA_VIDEO_COMPRESS_MODE_LINE,
+    },
+};
+
+static xmedia_vi_chn_config MEDIA_COMM_VI_CHN_CFG_SENSOR0 = {
+    .compress_mode = XMEDIA_VIDEO_COMPRESS_MODE_NONE,
+    .dynamic_range = XMEDIA_VIDEO_DYNAMIC_RANGE_SDR,
+    .flip_en = XMEDIA_FALSE,
+    .mirror_en = XMEDIA_FALSE,
+    .pix_fmt = XMEDIA_VIDEO_PIXEL_FMT_YVU_SEMIPLANAR_420,
+    .video_fmt = XMEDIA_VIDEO_FMT_LINEAR,
+    .depth = 0,
+    .frm_rate_ctrl = {
+        .src_frm_rate = -1,
+        .dst_frm_rate = -1,
+    },
+    .out_size = {
+        .width = sc485sl_width,
+        .height = sc485sl_height,
+    },
+};
+#endif
+
+#ifdef SMART_SC235HAI_MIPI_2M_2LANE_30FPS_10BIT
+static xmedia_isp_config MEDIA_COMM_ISP_CFG_SENSOR0 = {
+    .fps = 30,
+    .size = {
+        .width = 1920,
+        .height = 1080,
+    },
+    .bayer_fmt = XMEDIA_VIDEO_BAYER_FMT_BGGR,
+    .pixel_fmt = XMEDIA_VIDEO_PIXEL_FMT_RAW,
+    .wdr_mode = XMEDIA_VIDEO_WDR_MODE_NONE,
+    .mode_config = {
+        .work_mode = XMEDIA_ISP_WORK_MODE_MASTER,
+        .master_mode = {
+            .blend_stat_enable = XMEDIA_FALSE,
+            .slave_num = 0,
+        },
+    },
+};
+
+static xmedia_vi_dev_config MEDIA_COMM_VI_DEV_CFG_SENSOR0 = {
+    .intf_type = XMEDIA_INTF_TYPE_MIPI_CSI,
+    .mipi_attr = {
+        .input_data_type = XMEDIA_INTF_MIPI_CSI_DATA_TYPE_RAW_10BIT,
+        .lane_mode = XMEDIA_VI_MIPI_LANE_DIVIDE_MODE_2_LANE,
+        .wdr_format = XMEDIA_VIDEO_WDR_FMT_NONE,
+    },
+};
+
+static xmedia_vi_pipe_config MEDIA_COMM_VI_PIPE_CFG_SENSOR0 = {
+    .bit_width = XMEDIA_VIDEO_DATA_WIDTH_10,
+    .compress_mode = XMEDIA_VIDEO_COMPRESS_MODE_NONE,
+    .frm_rate_ctrl = {
+        .src_frm_rate = -1,
+        .dst_frm_rate = -1,
+    },
+    .isp_bypass = XMEDIA_FALSE,
+    .pipe_bypass_mode = XMEDIA_VI_PIPE_BYPASS_NONE,
+    .pix_fmt = XMEDIA_VIDEO_PIXEL_FMT_RAW,
+    .gdc_en = XMEDIA_FALSE, //default false
+    .in_size = {
+        .width = 1920,
+        .height = 1080,
+    },
+    .bnr_attr = {
+        .bnr_en = XMEDIA_TRUE,
+        .compress_mode = XMEDIA_VIDEO_COMPRESS_MODE_LINE,
+    },
+    .stnr_attr = {
+        .stnr_en = XMEDIA_TRUE,
+        .compress_mode = XMEDIA_VIDEO_COMPRESS_MODE_LINE,
+    },
+};
+
+static xmedia_vi_chn_config MEDIA_COMM_VI_CHN_CFG_SENSOR0 = {
+    .compress_mode = XMEDIA_VIDEO_COMPRESS_MODE_NONE,
+    .dynamic_range = XMEDIA_VIDEO_DYNAMIC_RANGE_SDR,
+    .flip_en = XMEDIA_FALSE,
+    .mirror_en = XMEDIA_FALSE,
+    .pix_fmt = XMEDIA_VIDEO_PIXEL_FMT_YVU_SEMIPLANAR_420,
+    .video_fmt = XMEDIA_VIDEO_FMT_LINEAR,
+    .depth = 0,
+    .frm_rate_ctrl = {
+        .src_frm_rate = -1,
+        .dst_frm_rate = -1,
+    },
+    .out_size = {
+        .width = 1920,
+        .height = 1080,
+    },
+};
+
+#endif
+
+#ifdef OMNIVISION_OS04D10_MIPI_4M_30FPS_10BIT
+
+static xmedia_isp_config MEDIA_COMM_ISP_CFG_SENSOR0 = {
+    .fps = 25,
+    .size = {
+        .width = 2560,
+        .height = 1440,
+    },
+    .bayer_fmt = XMEDIA_VIDEO_BAYER_FMT_BGGR,
+    .pixel_fmt = XMEDIA_VIDEO_PIXEL_FMT_RAW,
+    .wdr_mode = XMEDIA_VIDEO_WDR_MODE_NONE,
+    .mode_config = {
+        .work_mode = XMEDIA_ISP_WORK_MODE_MASTER,
+        .master_mode = {
+            .blend_stat_enable = XMEDIA_FALSE,
+            .slave_num = 0,
+        },
+    },
+};
+
+static xmedia_vi_dev_config MEDIA_COMM_VI_DEV_CFG_SENSOR0 = {
+    .intf_type = XMEDIA_INTF_TYPE_MIPI_CSI,
+    .mipi_attr = {
+        .input_data_type = XMEDIA_INTF_MIPI_CSI_DATA_TYPE_RAW_10BIT,
+        .lane_mode = XMEDIA_VI_MIPI_LANE_DIVIDE_MODE_2_LANE,
+        .wdr_format = XMEDIA_VIDEO_WDR_FMT_NONE,
+    },
+};
+
+static xmedia_vi_pipe_config MEDIA_COMM_VI_PIPE_CFG_SENSOR0 = {
+    .bit_width = XMEDIA_VIDEO_DATA_WIDTH_10,
+    .compress_mode = XMEDIA_VIDEO_COMPRESS_MODE_NONE,
+    .frm_rate_ctrl = {
+        .src_frm_rate = -1,
+        .dst_frm_rate = -1,
+    },
+    .isp_bypass = XMEDIA_FALSE,
+    .pipe_bypass_mode = XMEDIA_VI_PIPE_BYPASS_NONE,
+    .pix_fmt = XMEDIA_VIDEO_PIXEL_FMT_RAW,
+    .gdc_en = XMEDIA_FALSE, //default false
+    .in_size = {
+        .width = 2560,
+        .height = 1440,
+    },
+    .bnr_attr = {
+        .bnr_en = XMEDIA_TRUE,
+        .compress_mode = XMEDIA_VIDEO_COMPRESS_MODE_LINE,
+    },
+    .stnr_attr = {
+        .stnr_en = XMEDIA_TRUE,
+        .compress_mode = XMEDIA_VIDEO_COMPRESS_MODE_LINE,
+    },
+};
+
+static xmedia_vi_chn_config MEDIA_COMM_VI_CHN_CFG_SENSOR0 = {
+    .compress_mode = XMEDIA_VIDEO_COMPRESS_MODE_NONE,
+    .dynamic_range = XMEDIA_VIDEO_DYNAMIC_RANGE_SDR,
+    .flip_en = XMEDIA_FALSE,
+    .mirror_en = XMEDIA_FALSE,
+    .pix_fmt = XMEDIA_VIDEO_PIXEL_FMT_YVU_SEMIPLANAR_420,
+    .video_fmt = XMEDIA_VIDEO_FMT_LINEAR,
+    .depth = 0,
+    .frm_rate_ctrl = {
+        .src_frm_rate = -1,
+        .dst_frm_rate = -1,
+    },
+    .out_size = {
+        .width = 2560,
+        .height = 1440,
+    },
+};
+
+#endif
+
+#endif

sample/quickstart/quickstart_base.mk

@@ -0,0 +1,36 @@
+
+SAMPLE_LIB_MODE := static
+
+SAMPLE_INCLUDES := -I$(SDK_DIR)/source/gmp/include \
+		   -I$(SDK_DIR)/source/gmp/modules/osal/include \
+		   -I$(SDK_DIR)/source/gmp/usr/include \
+		   -I$(SDK_DIR)/sample/common \
+		   -I$(SDK_DIR)/source/gmp/usr/common/include \
+		   -I$(SDK_DIR)/source/gmp/drv/osal/include
+
+SYS_LIBS := -lpthread -lm -lc -lrt -ldl -lstdc++
+
+# gmp base
+GMP_LIBS := -lxmedia_venc -lxmedia_vpss -lxmedia_region -lxmedia_vi -lxmedia_vgs -lxmedia_common -lxmedia_tde -lxmedia_cl -lxmedia_npu -lxmedia_svp -lxmedia_ive
+GMP_LIBS += -lxmedia_isp -lxmedia_ae -lxmedia_awb -lxmedia_flatcc -lxmedia_pm
+GMP_LIBS += -lsns_sc485sl
+#GMP_LIBS += -lsns_sc235hai
+
+SAMPLE_LIBS += -L$(OUT_DIR)/lib/static
+SAMPLE_LIBS += -static -Wl,-Bstatic,--start-group $(GMP_LIBS) $(SYS_LIBS) -Wl,--end-group
+
+SAMPLE_CFLAGS := $(SDK_USR_CFLAGS)
+SAMPLE_CFLAGS += -DUSER_BIT_32 -DKERNEL_BIT_32 -Wno-date-time -D_GNU_SOURCE
+SAMPLE_CFLAGS += -DACODEC_TYPE_INNER -DVQE_USE_STATIC_MODULE_REGISTER -DAAC_USE_STATIC_MODULE_REGISTER -DAAC_HAVE_SBR_LIB -DCHIPSET=$(CHIPSET)
+
+#SENSOR0_TYPE := SMART_SC235HAI_MIPI_2M_2LANE_30FPS_10BIT
+SENSOR0_TYPE := SMART_SC485SL_MIPI_4M_30FPS_2LANE_12BIT
+
+SAMPLE_CFLAGS += -D$(SENSOR0_TYPE)
+
+#### reserve double sensor cfg
+###SENSOR1_TYPE := SMART_SC3338_MIPI_3M_30FPS_10BIT
+###SAMPLE_CFLAGS += -D$(SENSOR1_TYPE)
+
+BOARD_TYPE := IPC_RB_B
+SAMPLE_CFLAGS += -DBOARD_TYPE=$(BOARD_TYPE)

sample/quickstart/quickstart_build/quickstart_build.sh

@@ -0,0 +1,82 @@
+SDK_DIR=$(pwd)/..
+INITRAMDISK_DIR=${SDK_DIR}/source/initramdisk/scripts
+INITRAMDISK_PARAM_DIR=${SDK_DIR}/tools/linux/utils/bin
+CHIP=xm7206v11a
+BOARD=rba
+AI_MODLE=gnn_person_detect_640x360_rgb888hwc_v0102_20240909.bin
+
+function make_img()
+{
+	cd ${SDK_DIR}
+	cp ${SDK_DIR}/configs/${CHIP}/${CHIP}${BOARD}_linux-5.10_quickstart_cfg.mk ${SDK_DIR}/cfg.mk
+	source build/env.sh
+	make clean
+	make build -j 32
+	cd -
+}
+
+function make_samlpe()
+{
+	cd ${SDK_DIR}/sample/quickstart
+	make clean
+	make -j32
+	cd -
+}
+
+function update_initramdisk()
+{
+	cd ${INITRAMDISK_DIR}
+	tar -zxvf initramdisk.tgz
+	cp ${SDK_DIR}/sample/quickstart/quickstart_ramfs/sample_quickstart ${INITRAMDISK_DIR}/initramdisk/root
+	arm-gcc12.2.0-linux-uclibceabi-strip ${INITRAMDISK_DIR}/initramdisk/root/sample_quickstart
+	rm -rf ${INITRAMDISK_DIR}/initramdisk/param
+	cd -
+}
+
+function update_ai_modle()
+{
+	cd ${INITRAMDISK_DIR}/initramdisk
+	mkdir param
+	cd -
+	cp ${SDK_DIR}/sample/npu/demo_ai/model/${AI_MODLE} ${INITRAMDISK_DIR}/initramdisk/param/${AI_MODLE}
+}
+
+function re_compress_initramdisk()
+{
+	cd ${INITRAMDISK_DIR}
+	rm -rf initramdisk.tgz
+	tar -zcvf initramdisk.tgz initramdisk/
+	rm -rf initramdisk/
+	cd -
+}
+
+function update_kernel_param()
+{
+	cp ${SDK_DIR}/sample/quickstart/quickstart_build/src/fakeroot-scripts-initramdisk ${INITRAMDISK_PARAM_DIR}/
+}
+
+function update_kernel_img()
+{
+	cd ${SDK_DIR}
+	make initrd_clean
+	make linux -j32
+	cd -
+}
+
+function update_rootfs()
+{
+	cd ${SDK_DIR}
+	cp ${SDK_DIR}/sample/quickstart/quickstart_rootfs/quickstart_rootfs ${SDK_DIR}/out/${CHIP}/rootfs/usr/bin
+	make jffs2_clean
+	make jffs2
+	cd -
+}
+
+make_img
+make_samlpe
+update_initramdisk
+update_ai_modle
+re_compress_initramdisk
+update_kernel_param
+update_kernel_img
+update_rootfs

sample/quickstart/quickstart_build/readme.txt

@@ -0,0 +1,12 @@
+1. 确认sensor类型
+-- mcu 修改
+ a. 修改sdk/mcu/media/sensors/Makefile.riscv，保留需要用到的sensor
+ b. 修改sdk/mcu/media/include/media_sample.h  仅放开需要用到的sensor
+ c. 修改sdk/mcu/riscv/configs/xmorca_defconfig 放开CONFIG_MEDIA_SAMPLE_QUICKSTART 支持
+-- sample 修改
+ a. 修改sdk/sample/quickstart/quickstart_base.mk 支持对应sensor
+
+2. 完成以上修改后，将该文件夹放在sdk/目录下
+3. 请根据具体的版型型号更新quickstart_build.sh中相应路径和命名
+4. 进入quickstart_build，source quickstart_build.sh
+5. 该脚本仅作参考使用，相关启动异常或编译异常请参考<<快启使用指南>> 

sample/quickstart/quickstart_build/src/fakeroot-scripts-initramdisk

@@ -0,0 +1,69 @@
+#!/usr/bin/env bash
+###############################################################################
+#
+#  Copyright (c) XMEDIA.
+#  All rights reserved.
+#  Create By Caizhiyong 2021/3/16
+#
+###############################################################################
+
+SELF=$(basename ${0})
+ROOTDIR=${1}
+CMD=${2}
+
+if [ ! -d "${ROOTDIR}" ]; then
+	echo "${SELF}: *** Directory \"${ROOTDIR}\" not exists"
+	exit 2
+fi
+
+cd "${ROOTDIR}"
+
+if [ ! -f init ]; then
+	ln -svf sbin/init init
+fi
+
+chmod 0755 init
+chmod 0755 -R usr/bin usr/sbin usr/lib bin sbin lib
+chmod 0755 -R etc/rc
+chown 0:0 -R ./*
+
+mknod dev/mmz_userdev c 10 63
+mknod dev/mem c 1 1
+mknod dev/sys c 218 8
+mknod dev/vb c 218 9
+mknod dev/mipi_rx c 218 63
+mknod dev/vi c 218 62
+mknod dev/viproc c 218 61
+mknod dev/isp c 218 20
+mknod dev/vpu c 218 32
+mknod dev/vgs c 218 19
+mknod dev/ive c 218 17
+mknod dev/rgn c 218 16
+mknod dev/venc c 218 2
+mknod dev/log c 218 12
+mknod dev/vpss c 218 10
+mknod dev/venc c 218 2
+mknod dev/npu.0 c 218 48
+mknod dev/ddr_ost_qos c 218 49
+mknod dev/i2c-0 c 89 0
+
+mknod dev/console c 5 1
+mknod dev/ttyAMA0 c 204 64
+mknod dev/ttyAMA1 c 204 65
+mknod dev/ttyS000 c 204 64
+mknod dev/mtdblock0 b 31 0
+mknod dev/mtdblock1 b 31 1
+mknod dev/mtdblock2 b 31 2
+mknod dev/mtdblock3 b 31 3
+mknod dev/mtdblock4 b 31 4
+mknod dev/null c 1 3
+mknod dev/zero c 1 5
+mknod dev/loop0 b 7 0
+mknod dev/loop1 b 7 1
+mknod dev/loop2 b 7 2
+mknod dev/loop3 b 7 3
+mknod dev/loop4 b 7 4
+ln -s mtdblock4 dev/rootfs
+
+echo ${CMD}
+eval ${CMD}

sample/quickstart/quickstart_comm.c

@@ -0,0 +1,335 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <signal.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <pthread.h>
+#include <fcntl.h>
+#include <sys/mman.h>
+#include <linux/netlink.h>
+#include <linux/rtnetlink.h>
+#include <sys/select.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+
+#include <errno.h>
+
+#include "xmedia_npu.h"
+
+#include "quickstart_comm.h"
+#include "media_comm.h"
+
+
+#define SVP_CHECK_FRAME_COUNT    1
+#define LAYER_NUM_FOUR 4
+
+static xmedia_s32 g_svp_handle = -1;
+static pthread_t g_venc_thread_pid = 0;
+static quickstart_comm_venc_get_stream_param g_stream_param = {0};
+
+static xmedia_s32 quickstart_comm_venc_save_stream(FILE* pFd, xmedia_venc_stream* pstStream)
+{
+    xmedia_s32 i;
+
+    for (i = 0; i < pstStream->pack_count; i++) {
+        fwrite(pstStream->pack[i].vir_addr + pstStream->pack[i].offset,
+               pstStream->pack[i].len - pstStream->pack[i].offset, 1, pFd);
+    }
+
+    return XMEDIA_SUCCESS;
+}
+
+static xmedia_s32 quickstart_comm_svp_proc(xmedia_void)
+{
+    xmedia_s32 s32Ret = XMEDIA_FAILURE;
+    xmedia_video_frame_info video_frame = {0};
+    xmedia_s32 vpss_pipe = 0;
+    xmedia_s32 vpss_chn = 2;
+    xmedia_svp_task_input task_input = {0};
+    xmedia_svp_aov_detect_output svp_result = {0};
+    xmedia_s32 milli_sec = 20000;
+    xmedia_s32 i = 0;
+
+    for(i = 0; i < SVP_CHECK_FRAME_COUNT; i++) {
+        s32Ret = xmedia_vpss_acquire_ochn_frame(vpss_pipe, vpss_chn, &video_frame, milli_sec);
+        if (XMEDIA_SUCCESS != s32Ret) {
+            MEDIA_ERR("Warning, acquire vpss ochn frame fail, continue, ret = 0x%x\n", s32Ret);
+            continue;
+        }
+
+        task_input.frame_num = 1;
+        task_input.frame = &video_frame;
+        s32Ret = xmedia_svp_task_process(g_svp_handle, &task_input, &svp_result);
+        if (s32Ret != XMEDIA_SUCCESS) {
+            MEDIA_ERR("xmedia_svp_process failed with %#x!\n", s32Ret);
+            return XMEDIA_FAILURE;
+        }
+
+        if (svp_result.detect_output.target_num > 0) {
+            MEDIA_ERR("check person success \n");
+        }
+
+        s32Ret = xmedia_vpss_release_ochn_frame(vpss_pipe, vpss_chn, &video_frame);
+        if (s32Ret != XMEDIA_SUCCESS) {
+            MEDIA_ERR("XMEDIA_API_VPSS_ReleaseChnFrame failed with %#x!\n", s32Ret);
+        }
+    }
+
+    return XMEDIA_SUCCESS;
+}
+
+static xmedia_void* quickstart_comm_svp_thread(xmedia_void* args)
+{
+    xmedia_s32 s32Ret = XMEDIA_FAILURE;
+    xmedia_svp_modules model[1] = {0};
+    xmedia_svp_task_cfg task_cfg = {0};
+    xmedia_svp_aov_attr yolov5_attr = {0};
+    xmedia_s32 npu_quickstart_flag = 1;
+
+    s32Ret = xmedia_npu_set_quick_start_flag(npu_quickstart_flag);
+    if (XMEDIA_SUCCESS != s32Ret) {
+        MEDIA_ERR("set npu cfg fail");
+        return XMEDIA_NULL;
+    }
+
+    s32Ret = xmedia_tde_init();
+    if (XMEDIA_SUCCESS != s32Ret) {
+        MEDIA_ERR("tde init fail");
+        return XMEDIA_NULL;
+    }
+
+    s32Ret = xmedia_svp_init();
+    if (XMEDIA_SUCCESS != s32Ret) {
+        MEDIA_ERR("svp init fail");
+        return XMEDIA_NULL;
+    }
+
+    model[0].pathname = "/usr/bin/gnn_person_detect_640x360_rgb888hwc_v0102_20240909.bin";
+    model[0].alg_type = XMEDIA_SVP_ALG_TYPE_PERSON;
+    model[0].load_mode = XMEDIA_SVP_MODEL_FILE;
+    model[0].format = XMEDIA_SVP_INPUTDATA_FORMAT_RGB888;
+
+    task_cfg.module_num = 1;
+    task_cfg.modules = model;
+    task_cfg.task_type = XMEDIA_SVP_TASK_DETECT;
+
+    s32Ret = xmedia_svp_task_create(&g_svp_handle, task_cfg);
+    if (XMEDIA_SUCCESS != s32Ret) {
+        MEDIA_ERR("svp create fail.\n");
+        xmedia_svp_uninit();
+        return XMEDIA_NULL;
+    }
+
+    s32Ret = xmedia_svp_task_get_attr(g_svp_handle, &yolov5_attr);
+    if (XMEDIA_SUCCESS != s32Ret) {
+        MEDIA_ERR("svp get task attr fail.\n");
+        xmedia_svp_task_destroy(g_svp_handle);
+        xmedia_svp_uninit();
+        return XMEDIA_NULL;
+    }
+
+    yolov5_attr.detect_threshold = 0.5f;
+    yolov5_attr.classifier_threshold = 0.01f;
+    yolov5_attr.iou_threshold = 0.45f;
+    yolov5_attr.max_target_num = 10;
+    yolov5_attr.bytetrack_enable = XMEDIA_TRUE;
+    yolov5_attr.motionless_filter_enable = XMEDIA_FALSE;
+    yolov5_attr.aov_only_target = XMEDIA_FALSE;
+
+    s32Ret = xmedia_svp_task_set_attr(g_svp_handle, &yolov5_attr);
+    if(s32Ret != XMEDIA_SUCCESS) {
+        MEDIA_ERR("svp set task attr fail.\n");
+        xmedia_svp_task_destroy(g_svp_handle);
+        xmedia_svp_uninit();
+        return XMEDIA_NULL;
+    }
+
+    quickstart_comm_svp_proc();
+
+    s32Ret = xmedia_svp_task_destroy(g_svp_handle);
+    if (XMEDIA_SUCCESS != s32Ret) {
+        MEDIA_ERR("svp destory error\n");
+    }
+
+    g_svp_handle = -1;
+    xmedia_svp_uninit();
+    xmedia_tde_exit();
+
+    return XMEDIA_NULL;
+}
+
+static xmedia_void* quickstart_comm_venc_get_venc_stream_proc(xmedia_void* p)
+{
+    xmedia_s32 s32Ret = XMEDIA_FAILURE;
+    xmedia_s32 i = 0;
+    xmedia_s32 venc_chn_num = 0;
+    xmedia_u32 venc_mask = 0;
+    FILE *venc_fd[VENC_MAX_CHN_NUM];
+    xmedia_char file_path[VENC_MAX_CHN_NUM][256] = {0};
+    struct timeval time_out;
+    xmedia_venc_chn_attr venc_chn_attr = {0};
+    xmedia_venc_chn_status stat = {0};
+    xmedia_venc_stream venc_stream = {0}; 
+    quickstart_comm_venc_get_stream_param* pst_param = NULL;
+
+    pst_param = (quickstart_comm_venc_get_stream_param*)p;
+
+    venc_chn_num = pst_param->s32Cnt;
+    if (venc_chn_num > VENC_MAX_CHN_NUM) {
+        MEDIA_ERR("input venc chn num is invail \n");
+        return NULL;
+    }
+
+    for (i = 0; i < venc_chn_num; i++) {
+        if (pst_param->venc_chn[i] < 0) {
+            MEDIA_ERR("input venc chn is invail \n");
+            continue;
+        }
+
+        s32Ret = xmedia_venc_get_chn_attr(pst_param->venc_chn[i], &venc_chn_attr);
+        if (XMEDIA_SUCCESS != s32Ret) {
+            MEDIA_ERR("xmedia_venc_get_chn_attr chn[%d] failed with %#x!\n", pst_param->venc_chn[i], s32Ret);
+            return XMEDIA_NULL;
+        }
+
+        switch (venc_chn_attr.venc_attr.en_type)
+        {
+            case PT_H264:
+                snprintf(file_path[i], 255, "/mnt/stream_chn%d%s", i, ".h264");
+                break;
+            case PT_H265:
+                snprintf(file_path[i], 255, "/mnt/stream_chn%d%s", i, ".h265");
+                break;
+            case PT_JPEG:
+                snprintf(file_path[i], 255, "/mnt/stream_chn%d%s", i, ".jpg");
+                break;
+            case PT_MJPEG:
+                snprintf(file_path[i], 255, "/mnt/stream_chn%d%s", i, ".mjpeg");
+                break;
+            default:
+                MEDIA_ERR("venc type is invail exit stream thread \n");
+                return NULL;
+        }
+
+        venc_fd[i] = fopen(file_path[i],"wb");
+        if (venc_fd[i] == NULL) {
+            MEDIA_ERR("open venc stream save file fail\n");
+            return NULL;
+        }
+
+        venc_mask |= 1 << pst_param->venc_chn[i];
+    }
+
+    while (g_stream_param.thread_start)
+    {
+        time_out.tv_sec  = 2;
+        time_out.tv_usec = 0;
+        s32Ret = xmedia_venc_select(venc_mask, &time_out);
+        if (s32Ret == XMEDIA_ERRCODE_INVALID_PARAM || s32Ret == XMEDIA_FAILURE) {
+            MEDIA_ERR("select err\n");
+            break;
+        } else if (s32Ret == XMEDIA_ERRCODE_TIMEOUT) {
+            MEDIA_PRT("get venc stream time out, continue. \n");
+            continue;
+        }
+
+        for (i = 0; i < venc_chn_num; i++) {
+            if (pst_param->venc_chn[i] < 0) {
+                MEDIA_ERR("input venc chn is invail \n");
+                continue;
+            }
+
+            s32Ret = xmedia_venc_query_status(pst_param->venc_chn[i], &stat);
+            if (XMEDIA_SUCCESS != s32Ret) {
+                MEDIA_ERR("xmedia_venc_query_status chn[%d] failed with %#x!\n", pst_param->venc_chn[i], s32Ret);
+                break;
+            }
+
+            if (0 == stat.cur_packs) {
+                continue;
+            }
+
+            memset(&venc_stream, 0, sizeof(venc_stream));
+            venc_stream.pack = (xmedia_venc_pack*)malloc(sizeof(xmedia_venc_pack) * stat.cur_packs);
+            if (XMEDIA_NULL == venc_stream.pack) {
+                MEDIA_ERR("malloc stream pack failed!\n");
+                break;
+            }
+
+            venc_stream.pack_count = stat.cur_packs;
+            s32Ret = xmedia_venc_get_stream(pst_param->venc_chn[i], &venc_stream, XMEDIA_TRUE);
+            if (XMEDIA_SUCCESS != s32Ret) {
+                free(venc_stream.pack);
+                venc_stream.pack = XMEDIA_NULL;
+                xmedia_venc_release_stream(pst_param->venc_chn[i], &venc_stream);
+                MEDIA_ERR("xmedia_venc_get_stream failed with %#x!\n", s32Ret);
+                break;
+            }
+
+            quickstart_comm_venc_save_stream(venc_fd[i], &venc_stream);
+
+            s32Ret = xmedia_venc_release_stream(pst_param->venc_chn[i], &venc_stream);
+            if (XMEDIA_SUCCESS != s32Ret) {
+                MEDIA_ERR("xmedia_venc_release_stream failed!\n");
+                free(venc_stream.pack);
+                venc_stream.pack = XMEDIA_NULL;
+                break;
+            }
+
+            free(venc_stream.pack);
+            venc_stream.pack = XMEDIA_NULL;
+        }
+    }
+
+    for (i = 0; i < venc_chn_num; i++) {
+        if (venc_fd[i] != NULL) {
+            fclose(venc_fd[i]);
+            venc_fd[i] = NULL;
+        }
+    }
+
+    return NULL;
+}
+
+xmedia_s32 quickstart_comm_venc_start_get_stream(xmedia_s32 venc_chn[], xmedia_s32 venc_chn_num)
+{
+    xmedia_s32 i = 0;
+    g_stream_param.thread_start = XMEDIA_TRUE;
+    g_stream_param.s32Cnt = venc_chn_num;
+
+    for (i = 0; i < venc_chn_num; i++) {
+        g_stream_param.venc_chn[i] = venc_chn[i];
+    }
+
+    return pthread_create(&g_venc_thread_pid, 0, quickstart_comm_venc_get_venc_stream_proc, (xmedia_void*)&g_stream_param);
+}
+
+xmedia_s32 quickstart_comm_venc_stop_get_stream(void)
+{
+    if (XMEDIA_TRUE == g_stream_param.thread_start) {
+        g_stream_param.thread_start = XMEDIA_FALSE;
+
+        if (g_venc_thread_pid > 0) {
+            pthread_join(g_venc_thread_pid, 0);
+        }
+    }
+    return XMEDIA_SUCCESS;
+}
+
+xmedia_s32 quickstart_comm_svp_thread_create(xmedia_void)
+{
+    xmedia_s32 s32Ret = -1;
+    pthread_attr_t svp_create;
+    pthread_t svp_thread;
+    pthread_attr_init(&svp_create);
+    pthread_attr_setdetachstate(&svp_create, PTHREAD_CREATE_DETACHED);
+
+    s32Ret = pthread_create(&svp_thread, &svp_create, quickstart_comm_svp_thread, NULL);
+    if(s32Ret != 0)
+    {
+        MEDIA_ERR("create svp fail \n");
+    }
+    return s32Ret;
+}

sample/quickstart/quickstart_comm.h

@@ -0,0 +1,22 @@
+#ifndef __QUICKSTART_COMM_H__
+#define __QUICKSTART_COMM_H__
+
+#include <stdio.h>
+#include "media_comm.h"
+
+typedef struct quickstart_comm_venc_get_stream_param {
+    xmedia_bool thread_start;
+    xmedia_u32  venc_chn[VENC_MAX_CHN_NUM];
+    xmedia_s32  s32Cnt;
+} quickstart_comm_venc_get_stream_param;
+
+xmedia_s32 quickstart_comm_venc_start_get_stream(xmedia_s32 venc_chn[], xmedia_s32 venc_chn_num);
+xmedia_s32 quickstart_comm_venc_stop_get_stream(void);
+xmedia_s32 quickstart_comm_svp_thread_create(xmedia_void);
+xmedia_s32 quickstart_comm_test();
+xmedia_bool quickstart_comm_get_ai_detect();
+xmedia_s32 quickstart_comm_set_ai_detect(xmedia_bool ai_detect);
+
+
+
+#endif //__QUICKSTART_COMM_H__

sample/quickstart/quickstart_ramfs/Makefile

@@ -0,0 +1,35 @@
+ifeq ($(CFG_XMEDIA_EXPORT_FLAG),)
+        SDK_DIR := $(shell  cd $(CURDIR)/../../../ && /bin/pwd)
+endif
+
+include $(SDK_DIR)/build/base.mk
+include $(SDK_DIR)/sample/quickstart/quickstart_base.mk
+
+INCLUDES := -I$(SDK_DIR)/sample/quickstart/media_comm
+INCLUDES += -I$(SDK_DIR)/sample/quickstart
+INCLUDES += $(SAMPLE_INCLUDES)
+
+LIBS := $(SAMPLE_LIBS)
+
+TARGET:= sample_quickstart
+
+CFLAGS := $(SAMPLE_CFLAGS) $(LIBS) $(INCLUDES)
+
+SRCS := $(wildcard ./quickstart_ramfs.c)
+SRCS += $(wildcard ./../quickstart_comm.c)
+SRCS += $(wildcard ./../media_comm/media_comm.c)
+
+OBJS := $(patsubst %.c, %.o, $(SRCS))
+
+
+.PHONY: all clean
+
+all: $(OBJS)
+	$(AT)$(CC) -o $(TARGET) $^ $(CFLAGS)
+	$(AT)$(STRIP) $(TARGET)
+
+%.o : %.c
+	$(AT)$(CC) -c -o $@ $< $(CFLAGS)
+
+clean:
+	$(AT)rm -rf $(OBJS) $(TARGET)

sample/quickstart/quickstart_ramfs/quickstart_ramfs.c

@@ -0,0 +1,383 @@
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#include "quickstart_comm.h"
+
+#define MCU_CPU_SYNC_REG      0x1202014c
+#define MCU_END_VALUE         0xbeef0002
+#define MCU_ALREADY_END_VALUE 0xbeef0003
+
+#ifdef SMART_SC485SL_MIPI_4M_30FPS_4LANE_12BIT
+#define SENSOR_MAX_WIDTH      2688
+#define SENSOR_MAX_HEIGHT     1520
+#endif
+
+#ifdef SMART_SC485SL_MIPI_4M_30FPS_2LANE_12BIT
+#define SENSOR_MAX_WIDTH      2560
+#define SENSOR_MAX_HEIGHT     1440
+#endif
+
+#ifdef SMART_SC485SL_MIPI_4M_60FPS_4LANE_12BIT
+#define SENSOR_MAX_WIDTH      2560
+#define SENSOR_MAX_HEIGHT     1440
+#endif
+
+#ifdef SMART_SC235HAI_MIPI_2M_2LANE_30FPS_10BIT
+#define SENSOR_MAX_WIDTH      1920
+#define SENSOR_MAX_HEIGHT     1080
+#endif
+
+#define VENC_SUBCHN_WIDTH     640
+#define VENC_SUBCHN_HEIGHT    360
+#define NPU_CHN_WIDTH       640
+#define NPU_CHN_HEIGHT       360
+//#define SCENE_AUTO_SUPPORT
+#define SUBCHN_SUPPORT
+
+xmedia_void quickstart_media_start(xmedia_void)
+{
+    xmedia_s32 s32Ret = XMEDIA_FAILURE;
+    xmedia_s32 pool_num = 0;
+    xmedia_s32 wrap_blk_size = 0;
+    xmedia_s32 vi_dev = 0;
+    xmedia_s32 vi_pipe = 0;
+    xmedia_s32 vpss_ichn = 0;
+    xmedia_s32 vpss_ochn[3] = {0, 1, 2};
+    xmedia_s32 vpss_pipe = 0;
+    xmedia_s32 venc_chn[2] = {0,1};
+    media_comm_sys_config sys_cfg = {0};
+    xmedia_vb_base_info vb_base_info = {0};
+    xmedia_vb_cal_cfg vb_cfg = {0};
+    media_comm_isp_cfg isp_cfg = {0};
+    media_comm_vi_cfg vi_cfg = {0};
+    media_comm_vpss_cfg vpss_cfg = {0};
+    media_comm_venc_cfg venc_cfg = {0};
+
+    /*sys init*/
+    for (xmedia_s32 i = 0; i < VI_MAX_PIPE_NUM; i++)
+    {
+        sys_cfg.sys_conf.pipe_mode[i].vicap_viproc_mode = XMEDIA_WORK_MODE_OFFLINE;
+        sys_cfg.sys_conf.pipe_mode[i].gdc_vpss_mode = XMEDIA_WORK_MODE_OFFLINE;
+        sys_cfg.sys_conf.pipe_mode[i].viproc_vpss_mode = XMEDIA_WORK_MODE_ONLINE;
+    }
+    sys_cfg.sys_conf.pipe_mode[0].vicap_viproc_mode = XMEDIA_WORK_MODE_ONLINE;
+
+    vb_base_info.width = SENSOR_MAX_WIDTH;
+    vb_base_info.height = SENSOR_MAX_HEIGHT;
+    vb_base_info.cmp_mode = XMEDIA_VIDEO_COMPRESS_MODE_NONE;
+    vb_base_info.bit_width = XMEDIA_VIDEO_DATA_WIDTH_12;//XMEDIA_VIDEO_DATA_WIDTH_12;
+    vb_base_info.pixel_fmt = XMEDIA_VIDEO_PIXEL_FMT_RAW;
+    vb_base_info.video_fmt = XMEDIA_VIDEO_FMT_LINEAR;
+    vb_base_info.align = DEFAULT_ALIGN;
+    vb_base_info.ainr_attr.ainr_en = XMEDIA_FALSE;
+
+    xmedia_vb_get_buffer_config(&vb_base_info, &vb_cfg);
+    sys_cfg.vb_conf.common_pool[pool_num].block_size = vb_cfg.vb_size;
+    sys_cfg.vb_conf.common_pool[pool_num].block_cnt = 2;
+    pool_num ++;
+
+    vb_base_info.width = SENSOR_MAX_WIDTH;
+    vb_base_info.height = SENSOR_MAX_HEIGHT;
+    vb_base_info.cmp_mode = XMEDIA_VIDEO_COMPRESS_MODE_NONE;
+    vb_base_info.video_fmt = XMEDIA_VIDEO_FMT_LINEAR;
+    vb_base_info.align = DEFAULT_ALIGN;
+    //vpss
+    vb_base_info.bit_width = XMEDIA_VIDEO_DATA_WIDTH_8;
+    vb_base_info.pixel_fmt = XMEDIA_VIDEO_PIXEL_FMT_YVU_SEMIPLANAR_420;
+    vb_base_info.ainr_attr.ainr_en = XMEDIA_FALSE;
+
+#if 0//wrap disable
+    xmedia_vb_get_buffer_config(&vb_base_info, &vb_cfg);
+    sys_cfg.vb_conf.common_pool[pool_num].block_size = vb_cfg.vb_size;
+    sys_cfg.vb_conf.common_pool[pool_num].block_cnt = 2;
+    pool_num ++;
+#else
+    wrap_blk_size = xmedia_vb_get_wrap_buffer_size(&vb_base_info, SENSOR_MAX_WIDTH / 2);
+    sys_cfg.vb_conf.common_pool[pool_num].block_size = wrap_blk_size;
+    sys_cfg.vb_conf.common_pool[pool_num].block_cnt = 1;
+    pool_num ++;
+#endif
+
+    vb_base_info.width = VENC_SUBCHN_WIDTH;
+    vb_base_info.height = VENC_SUBCHN_HEIGHT;
+
+    xmedia_vb_get_buffer_config(&vb_base_info, &vb_cfg);
+    sys_cfg.vb_conf.common_pool[pool_num].block_size = vb_cfg.vb_size;
+    sys_cfg.vb_conf.common_pool[pool_num].block_cnt = 2;
+    pool_num ++;
+
+    vb_base_info.width = NPU_CHN_WIDTH;
+    vb_base_info.height = NPU_CHN_HEIGHT;
+
+    xmedia_vb_get_buffer_config(&vb_base_info, &vb_cfg);
+    sys_cfg.vb_conf.common_pool[pool_num].block_size = vb_cfg.vb_size;
+    sys_cfg.vb_conf.common_pool[pool_num].block_cnt = 4;
+    pool_num ++;
+
+    sys_cfg.vb_conf.max_pool_cnt = pool_num;
+    sys_cfg.vb_conf.supplement_config = 1;
+
+    s32Ret = media_comm_sys_init(&sys_cfg);
+    if (XMEDIA_SUCCESS != s32Ret) {
+        MEDIA_PRT("sys init fail \n");
+        goto error0;
+    }
+
+    /*media init*/
+    s32Ret = media_comm_media_init();
+    if (XMEDIA_SUCCESS != s32Ret) {
+        MEDIA_PRT("media init fail \n");
+        goto error1;
+    }
+
+    /*isp init*/
+    isp_cfg.en_quickstart = XMEDIA_TRUE;
+    isp_cfg.sns_num = MEDIA_SENSOR0;
+    isp_cfg.isp_pipe = vi_pipe;
+    isp_cfg.vi_dev = vi_dev;
+
+    s32Ret = media_comm_isp_init(isp_cfg);
+    if (XMEDIA_SUCCESS != s32Ret) {
+        MEDIA_PRT("isp init fail \n");
+        goto error2;
+    }
+
+    /*vi init*/
+    vi_cfg.vi_dev_work_num = 1;
+    vi_cfg.vi_dev[0] = vi_dev;
+    vi_cfg.en_quickstart[0] = XMEDIA_TRUE;
+    vi_cfg.vi_grp_param.vi_grp_work_num = 0;
+    vi_cfg.vi_pipe_param[0].vi_pipe_work_num = 1;
+    vi_cfg.vi_pipe_param[0].vi_pipe[0] = vi_pipe;
+    vi_cfg.mipi_cfg[0].mipi_rate = media_comm_isp_get_mipi_rate(isp_cfg.isp_pipe);
+
+#if 0
+    
+    xmedia_vi_lowdelay_attr vi_cap_lowdelay = {0};
+    xmedia_vi_lowdelay_attr vi_proc_lowdelay = {0};
+    vi_cap_lowdelay.enable = XMEDIA_TRUE;
+    vi_cap_lowdelay.line_cnt = SENSOR_MAX_HEIGHT / 2;
+    vi_cap_lowdelay.one_buf_en = XMEDIA_TRUE;
+
+    vi_proc_lowdelay.enable = XMEDIA_TRUE;
+    vi_proc_lowdelay.line_cnt = SENSOR_MAX_HEIGHT / 2;
+    vi_proc_lowdelay.one_buf_en = XMEDIA_TRUE;
+
+    memcpy(&vi_cfg.vi_pipe_param[0].vi_pipe_info[0].vi_cap_lowdelay, &vi_cap_lowdelay, sizeof(xmedia_vi_lowdelay_attr));
+    memcpy(&vi_cfg.vi_pipe_param[0].vi_pipe_info[0].vi_proc_lowdelay, &vi_proc_lowdelay, sizeof(xmedia_vi_lowdelay_attr));
+    vi_cfg.vi_pipe_param[0].vi_pipe_info[0].en_vi_cap_lowdelay = XMEDIA_TRUE; //开启 会丢1fps
+    //vi_cfg.vi_pipe_param[0].vi_pipe_info[0].en_vi_proc_lowdelay = XMEDIA_TRUE; // vi 离线 vpss在线不支持
+#endif
+
+    s32Ret = media_comm_vi_start(&vi_cfg);
+    if (XMEDIA_SUCCESS != s32Ret) {
+        MEDIA_PRT("vi start fail \n");
+        goto error3;
+    }
+
+    s32Ret = media_comm_isp_start(vi_pipe, XMEDIA_FALSE);
+    if (XMEDIA_SUCCESS != s32Ret) {
+        MEDIA_PRT("isp start fail \n");
+        goto error4;
+    }
+
+    /*vpss init*/
+    vpss_cfg.vpss_pipe_work_num = 1;
+    vpss_cfg.vpss_pipe[0] = vpss_pipe;
+
+    vpss_cfg.pipe_cfg[0].max_w = SENSOR_MAX_WIDTH;
+    vpss_cfg.pipe_cfg[0].max_h = SENSOR_MAX_HEIGHT;
+    vpss_cfg.pipe_cfg[0].dync_range = XMEDIA_VIDEO_DYNAMIC_RANGE_SDR;
+    vpss_cfg.pipe_cfg[0].frm_rate_ctrl.src_frm_rate = -1;
+    vpss_cfg.pipe_cfg[0].frm_rate_ctrl.dst_frm_rate = -1;
+    vpss_cfg.pipe_cfg[0].pixel_fmt = XMEDIA_VIDEO_PIXEL_FMT_YVU_SEMIPLANAR_420;
+    vpss_cfg.pipe_cfg[0].nr_attr.nr_en = XMEDIA_FALSE;
+    vpss_cfg.pipe_cfg[0].nr_attr.compress_mode = XMEDIA_VIDEO_COMPRESS_MODE_NONE;
+    vpss_cfg.pipe_cfg[0].stitch_blend_cfg.stitch_blend_en = XMEDIA_FALSE;
+
+    vpss_cfg.vpss_ochn_info[0].vpss_ochn_work_num = 1;
+    vpss_cfg.vpss_ochn_info[0].vpss_ochn[0] = vpss_ochn[0];
+    vpss_cfg.vpss_ochn_info[0].vpss_ochn_cfg[0].cmp_mode = XMEDIA_VIDEO_COMPRESS_MODE_NONE;
+    vpss_cfg.vpss_ochn_info[0].vpss_ochn_cfg[0].depth = 1;
+    vpss_cfg.vpss_ochn_info[0].vpss_ochn_cfg[0].dync_range = XMEDIA_VIDEO_DYNAMIC_RANGE_SDR;
+    vpss_cfg.vpss_ochn_info[0].vpss_ochn_cfg[0].flip_en = XMEDIA_FALSE;
+    vpss_cfg.vpss_ochn_info[0].vpss_ochn_cfg[0].mirror_en = XMEDIA_FALSE;
+    vpss_cfg.vpss_ochn_info[0].vpss_ochn_cfg[0].frm_rate_ctrl.src_frm_rate = -1;
+    vpss_cfg.vpss_ochn_info[0].vpss_ochn_cfg[0].frm_rate_ctrl.dst_frm_rate = -1;
+    vpss_cfg.vpss_ochn_info[0].vpss_ochn_cfg[0].width = SENSOR_MAX_WIDTH;
+    vpss_cfg.vpss_ochn_info[0].vpss_ochn_cfg[0].height = SENSOR_MAX_HEIGHT;
+    vpss_cfg.vpss_ochn_info[0].vpss_ochn_cfg[0].pix_fmt = XMEDIA_VIDEO_PIXEL_FMT_YVU_SEMIPLANAR_420;
+    vpss_cfg.vpss_ochn_info[0].vpss_ochn_cfg[0].video_fmt = XMEDIA_VIDEO_FMT_LINEAR;
+    vpss_cfg.vpss_ochn_info[0].vpss_ochn_cfg[0].mode = XMEDIA_VPSS_OCHN_MODE_USER;
+
+    xmedia_vpss_low_delay_attr vpss_lowdelay_cfg = {0};
+    vpss_lowdelay_cfg.enable = XMEDIA_FALSE;
+    vpss_lowdelay_cfg.line_cnt = 16;
+    vpss_lowdelay_cfg.one_buf_en = XMEDIA_FALSE;
+
+    xmedia_video_wrap_attr vpss_wrap_cfg = {0};
+    vpss_wrap_cfg.enable = XMEDIA_TRUE;
+    vpss_wrap_cfg.buf_line = SENSOR_MAX_HEIGHT/2;
+    vpss_wrap_cfg.buf_size = wrap_blk_size;
+
+    //memcpy(&vpss_cfg.vpss_ochn_info[0].vpss_lowdelay_cfg[0], &vpss_lowdelay_cfg, sizeof(xmedia_vpss_low_delay_attr));
+    memcpy(&vpss_cfg.vpss_ochn_info[0].vpss_wrap_cfg[0], &vpss_wrap_cfg, sizeof(xmedia_video_wrap_attr));
+
+#ifdef SUBCHN_SUPPORT
+    vpss_cfg.vpss_ochn_info[0].vpss_ochn_work_num += 1;
+    vpss_cfg.vpss_ochn_info[0].vpss_ochn[1] = vpss_ochn[1];
+    vpss_cfg.vpss_ochn_info[0].vpss_ochn_cfg[1].cmp_mode = XMEDIA_VIDEO_COMPRESS_MODE_NONE;
+    vpss_cfg.vpss_ochn_info[0].vpss_ochn_cfg[1].depth = 0;
+    vpss_cfg.vpss_ochn_info[0].vpss_ochn_cfg[1].dync_range = XMEDIA_VIDEO_DYNAMIC_RANGE_SDR;
+    vpss_cfg.vpss_ochn_info[0].vpss_ochn_cfg[1].flip_en = XMEDIA_FALSE;
+    vpss_cfg.vpss_ochn_info[0].vpss_ochn_cfg[1].mirror_en = XMEDIA_FALSE;
+    vpss_cfg.vpss_ochn_info[0].vpss_ochn_cfg[1].frm_rate_ctrl.src_frm_rate = -1;
+    vpss_cfg.vpss_ochn_info[0].vpss_ochn_cfg[1].frm_rate_ctrl.dst_frm_rate = -1;
+    vpss_cfg.vpss_ochn_info[0].vpss_ochn_cfg[1].width = VENC_SUBCHN_WIDTH;
+    vpss_cfg.vpss_ochn_info[0].vpss_ochn_cfg[1].height = VENC_SUBCHN_HEIGHT;
+    vpss_cfg.vpss_ochn_info[0].vpss_ochn_cfg[1].pix_fmt = XMEDIA_VIDEO_PIXEL_FMT_YVU_SEMIPLANAR_420;
+    vpss_cfg.vpss_ochn_info[0].vpss_ochn_cfg[1].video_fmt = XMEDIA_VIDEO_FMT_LINEAR;
+    vpss_cfg.vpss_ochn_info[0].vpss_ochn_cfg[1].mode = XMEDIA_VPSS_OCHN_MODE_USER;
+
+
+    vpss_cfg.vpss_ochn_info[0].vpss_ochn_work_num += 1;
+    vpss_cfg.vpss_ochn_info[0].vpss_ochn[2] = vpss_ochn[2];
+    vpss_cfg.vpss_ochn_info[0].vpss_ochn_cfg[2].cmp_mode = XMEDIA_VIDEO_COMPRESS_MODE_NONE;
+    vpss_cfg.vpss_ochn_info[0].vpss_ochn_cfg[2].depth = 1;
+    vpss_cfg.vpss_ochn_info[0].vpss_ochn_cfg[2].dync_range = XMEDIA_VIDEO_DYNAMIC_RANGE_SDR;
+    vpss_cfg.vpss_ochn_info[0].vpss_ochn_cfg[2].flip_en = XMEDIA_FALSE;
+    vpss_cfg.vpss_ochn_info[0].vpss_ochn_cfg[2].mirror_en = XMEDIA_FALSE;
+    vpss_cfg.vpss_ochn_info[0].vpss_ochn_cfg[2].frm_rate_ctrl.src_frm_rate = -1;
+    vpss_cfg.vpss_ochn_info[0].vpss_ochn_cfg[2].frm_rate_ctrl.dst_frm_rate = -1;
+    vpss_cfg.vpss_ochn_info[0].vpss_ochn_cfg[2].width = NPU_CHN_WIDTH;
+    vpss_cfg.vpss_ochn_info[0].vpss_ochn_cfg[2].height = NPU_CHN_HEIGHT;
+    vpss_cfg.vpss_ochn_info[0].vpss_ochn_cfg[2].pix_fmt = XMEDIA_VIDEO_PIXEL_FMT_YVU_SEMIPLANAR_420;
+    vpss_cfg.vpss_ochn_info[0].vpss_ochn_cfg[2].video_fmt = XMEDIA_VIDEO_FMT_LINEAR;
+    vpss_cfg.vpss_ochn_info[0].vpss_ochn_cfg[2].mode = XMEDIA_VPSS_OCHN_MODE_USER;
+#endif
+    vpss_lowdelay_cfg.enable = XMEDIA_FALSE;
+    memcpy(&vpss_cfg.vpss_ochn_info[0].vpss_lowdelay_cfg[1], &vpss_lowdelay_cfg, sizeof(xmedia_vpss_low_delay_attr));
+    vpss_lowdelay_cfg.enable = XMEDIA_FALSE;
+    memcpy(&vpss_cfg.vpss_ochn_info[0].vpss_lowdelay_cfg[2], &vpss_lowdelay_cfg, sizeof(xmedia_vpss_low_delay_attr));
+
+
+    s32Ret = media_comm_vpss_start(&vpss_cfg);
+    if (XMEDIA_SUCCESS != s32Ret) {
+        MEDIA_PRT("vpss start fail \n");
+        goto error5;
+    }
+
+    s32Ret = media_comm_vi_bind_vpss(vi_pipe, 0, vpss_pipe, vpss_ichn);
+    if (XMEDIA_SUCCESS != s32Ret) {
+        MEDIA_PRT("vi bind vpss fail \n");
+        goto error6;
+    }
+
+    /*venc init*/
+    venc_cfg.src_frame_rate = 30;
+    venc_cfg.dst_frame_rate = 30;
+    venc_cfg.max_pic_width = SENSOR_MAX_WIDTH;
+    venc_cfg.max_pic_height = SENSOR_MAX_HEIGHT;
+    venc_cfg.en_type = PT_H265;
+    venc_cfg.profile = 0;
+    venc_cfg.rcn_ref_share_buf = XMEDIA_FALSE;
+    venc_cfg.rc_mode = VENC_RC_MODE_H265CBR;
+
+    venc_cfg.venc_gop_attr.gop_mode = VENC_GOPMODE_NORMALP;
+    venc_cfg.venc_gop_attr.normal_p.ip_qp_delta = 2;
+
+    s32Ret = media_comm_venc_start(venc_chn[0], &venc_cfg);
+    if (XMEDIA_SUCCESS != s32Ret) {
+        MEDIA_PRT("venc start fail \n");
+        goto error7;
+    }
+
+    s32Ret = media_comm_sys_vpss_bind_venc(vpss_pipe, vpss_ochn[0], venc_chn[0]);
+    if (XMEDIA_SUCCESS != s32Ret) {
+        MEDIA_PRT("vpss bind venc fail \n");
+        goto error8;
+    }
+
+#ifdef SUBCHN_SUPPORT
+    /*venc init*/
+    venc_cfg.max_pic_width = VENC_SUBCHN_WIDTH;
+    venc_cfg.max_pic_height = VENC_SUBCHN_HEIGHT;
+
+    s32Ret = media_comm_venc_start(venc_chn[1], &venc_cfg);
+    if (XMEDIA_SUCCESS != s32Ret) {
+        MEDIA_PRT("venc start fail \n");
+        goto error9;
+    }
+
+    s32Ret = media_comm_sys_vpss_bind_venc(vpss_pipe, vpss_ochn[1], venc_chn[1]);
+    if (XMEDIA_SUCCESS != s32Ret) {
+        MEDIA_PRT("vpss bind venc fail \n");
+        goto error10;
+    }
+#endif
+    
+#ifdef SCENE_AUTO_SUPPORT
+        bin_module_info scene_auto_info = {0};
+        scene_auto_info.vi.enable = XMEDIA_TRUE;
+        scene_auto_info.vi.pipe = vi_pipe;
+    
+        media_comm_scene_auto_enable(&scene_auto_info);
+#endif
+
+#if 0
+    s32Ret = quickstart_comm_venc_start_get_stream(venc_chn, 2);
+    if (XMEDIA_SUCCESS != s32Ret) {
+        MEDIA_PRT("media init fail \n");
+    }
+#endif
+
+    sleep(30);
+
+#ifdef SUBCHN_SUPPORT
+error10:
+    media_comm_sys_vpss_unbind_venc(vpss_pipe, vpss_ochn[1], venc_chn[1]);
+error9:
+    media_comm_venc_stop(venc_chn[1]);
+#endif
+
+error8:
+    media_comm_sys_vpss_unbind_venc(vpss_pipe, vpss_ochn[0], venc_chn[0]);
+error7:
+    media_comm_venc_stop(venc_chn[0]);
+error6:
+    media_comm_vi_unbind_vpss(vi_pipe, 0, vpss_pipe, vpss_ichn);
+error5:
+    media_comm_vpss_stop(&vpss_cfg);
+error4:
+    media_comm_isp_stop(vi_pipe, XMEDIA_FALSE);
+error3:
+    media_comm_vi_stop(&vi_cfg);
+error2:
+    media_comm_isp_exit(isp_cfg.isp_pipe, isp_cfg.sns_num);
+error1:
+    media_comm_media_exit();
+error0:
+    media_comm_sys_exit();
+
+    return;
+}
+
+xmedia_s32 main(int argc, char **argv)
+{
+    media_comm_mem_open();
+    media_comm_set_reg(MCU_CPU_SYNC_REG, MCU_END_VALUE);
+    while(1)
+    {
+        if (MCU_ALREADY_END_VALUE == media_comm_get_reg(MCU_CPU_SYNC_REG))
+        {
+            break;
+        }
+        usleep(1000*2);
+    }
+
+    quickstart_media_start();
+
+    media_comm_mem_close();
+}

sample/quickstart/quickstart_rootfs/Makefile

@@ -0,0 +1,35 @@
+ifeq ($(CFG_XMEDIA_EXPORT_FLAG),)
+        SDK_DIR := $(shell  cd $(CURDIR)/../../../ && /bin/pwd)
+endif
+
+include $(SDK_DIR)/build/base.mk
+include $(SDK_DIR)/sample/quickstart/quickstart_base.mk
+
+INCLUDES := -I$(SDK_DIR)/sample/quickstart/media_comm
+INCLUDES += -I$(SDK_DIR)/sample/quickstart
+INCLUDES += $(SAMPLE_INCLUDES)
+
+LIBS := $(SAMPLE_LIBS)
+
+TARGET:= quickstart_rootfs
+
+CFLAGS := $(SAMPLE_CFLAGS) $(LIBS) $(INCLUDES)
+
+SRCS := $(wildcard ./quickstart_rootfs.c)
+SRCS += $(wildcard ./../quickstart_comm.c)
+SRCS += $(wildcard ./../media_comm/media_comm.c)
+
+OBJS := $(patsubst %.c, %.o, $(SRCS))
+
+
+.PHONY: all clean
+
+all: $(OBJS)
+	$(AT)$(CC) -o $(TARGET) $^ $(CFLAGS)
+	$(AT)$(STRIP) $(TARGET)
+
+%.o : %.c
+	$(AT)$(CC) -c -o $@ $< $(CFLAGS)
+
+clean:
+	$(AT)rm -rf $(OBJS) $(TARGET)

sample/quickstart/quickstart_rootfs/quickstart_rootfs.c

@@ -0,0 +1,40 @@
+#include <string.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#include "quickstart_comm.h"
+
+
+xmedia_void quickstart_media_start(xmedia_void)
+{
+    xmedia_s32 s32Ret = XMEDIA_FAILURE;
+    xmedia_s32 venc_chn[2] = {0,1};
+
+    s32Ret = media_comm_media_init();
+    if (XMEDIA_SUCCESS != s32Ret) {
+        MEDIA_PRT("media init fail \n");
+        goto error0;
+    }
+
+    s32Ret = quickstart_comm_venc_start_get_stream(venc_chn, 2);
+    if (XMEDIA_SUCCESS != s32Ret) {
+        MEDIA_PRT("media init fail \n");
+        goto error1;
+    }
+
+    sleep(15);
+
+error1:
+    quickstart_comm_venc_stop_get_stream();
+
+error0:
+    media_comm_media_exit();
+    return;
+}
+
+
+xmedia_s32 main(xmedia_void)
+{
+    quickstart_media_start();
+    return 0;
+}