payton/nt9856x
Template
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
2a2652c0f6
nt9856x/code/hdal/vendor/ai2/include/vendor_ai.h
payton 543d2da268 1.一次S530代码提交
2023-03-28 15:07:53 +08:00

479 lines
23 KiB
C
Executable File
Raw Blame History

/**
@brief Header file of definition of vendor user-space net flow sample.
@file vendor_ai.h
@ingroup vendor_ai
@note Nothing.
Copyright Novatek Microelectronics Corp. 2018. All rights reserved.
*/
#ifndef _VENDOR_AI_NET_H_
#define _VENDOR_AI_NET_H_
/********************************************************************
INCLUDE FILES
********************************************************************/
#include "hd_type.h"
#include "hd_common.h"
#include "vendor_ai_dla/vendor_ai_dla.h"
/********************************************************************
MACRO CONSTANT DEFINITIONS
********************************************************************/
#ifndef VENDOR_AI_VERSION
#define VENDOR_AI_VERSION 0x020000
#endif
#define MAX_PROC_CNT 128
/* ai layer id */
#define VENDOR_AI_NET_PARAM_LAYER(layer_id) (0x80000000 | ((layer_id) & 0xffff)) ///< layer
#define VENDOR_AI_MAXLAYER 0xffff ///< max layer id (auto)
/* ai i/o buffer path_id */
#define VENDOR_AI_NET_PARAM_IN(layer_id, in_id) (0x90000000 | (((in_id) & 0xfff) << 16) | ((layer_id) & 0xffff)) ///< input buffer
#define VENDOR_AI_NET_PARAM_OUT(layer_id, out_id) (0xa0000000 | (((out_id) & 0xfff) << 16) | ((layer_id) & 0xffff)) ///< output buffer
/* ai dep buffer path_id */
#define VENDOR_AI_NET_PARAM_DEP(dep_id) (0xb0000000 | ((dep_id) & 0xffff)) ///< dependent buffer
/* ai output buffer real access size */
#define VENDOR_AI_NET_OUTBUF_SIZE(w, h, c, b, fmt) (w * h * c * b * (HD_VIDEO_PXLFMT_BITS(fmt) >> 3))
/* ai buf format */
#define HD_VIDEO_PXLFMT_AI_SINT8 0xa1080000 ///< signed int 8-bits
#define HD_VIDEO_PXLFMT_AI_UINT8 0xa2080000 ///< unsigned int 8-bits
#define HD_VIDEO_PXLFMT_AI_SINT16 0xa1100000 ///< signed int 16-bits
#define HD_VIDEO_PXLFMT_AI_UINT16 0xa2100000 ///< unsigned int 16-bits
#define HD_VIDEO_PXLFMT_AI_FLOAT16 0xa3100000 ///< float 16-bits
#define HD_VIDEO_PXLFMT_AI_SINT32 0xa1200000 ///< signed int 32-bits
#define HD_VIDEO_PXLFMT_AI_UINT32 0xa2200000 ///< unsigned int 32-bits
#define HD_VIDEO_PXLFMT_AI_FLOAT32 0xa3200000 ///< float 32-bits
#define HD_VIDEO_PXLFMT_CLASS_AI 0xa
#define HD_VIDEO_PXLFMT_TYPE_MASK 0x0f000000
#define HD_VIDEO_PXLFMT_BITS_MASK 0x00ff0000
#define HD_VIDEO_PXLFMT_INT_MASK 0x0000ff00
#define HD_VIDEO_PXLFMT_FRAC_MASK 0x000000ff
#define HD_VIDEO_PXLFMT_SIGN(pxlfmt) ((((pxlfmt) & HD_VIDEO_PXLFMT_TYPE_MASK) >> 24) & 0x01)
#define HD_VIDEO_PXLFMT_BITS(pxlfmt) (((pxlfmt) & HD_VIDEO_PXLFMT_BITS_MASK) >> 16)
#define HD_VIDEO_PXLFMT_INT(pxlfmt) (INT8)(((pxlfmt) & HD_VIDEO_PXLFMT_INT_MASK) >> 8)
#define HD_VIDEO_PXLFMT_FRAC(pxlfmt) (INT8)((pxlfmt) & HD_VIDEO_PXLFMT_FRAC_MASK)
#define HD_VIDEO_PXLFMT_FMT(pxlfmt) ((pxlfmt) & (((HD_VIDEO_PXLFMT_CLASS_AI << 28) | HD_VIDEO_PXLFMT_TYPE_MASK) | HD_VIDEO_PXLFMT_BITS_MASK))
#define HD_VIDEO_PXLFMT_AI_SFIXED8(frac_bits) (HD_VIDEO_PXLFMT_AI_SINT8 | (((8-(frac_bits)-1)&0xff) << 8) | ((frac_bits)&0xff)) ///< signed fixpoint 8-bits
#define HD_VIDEO_PXLFMT_AI_UFIXED8(frac_bits) (HD_VIDEO_PXLFMT_AI_UINT8 | (((8-(frac_bits))&0xff) << 8) | ((frac_bits)&0xff)) ///< unsigned fixpoint 8-bits
#define HD_VIDEO_PXLFMT_AI_SFIXED16(frac_bits) (HD_VIDEO_PXLFMT_AI_SINT16 | (((16-(frac_bits)-1)&0xff) << 8) | ((frac_bits)&0xff)) ///< signed fixpoint 16-bits
#define HD_VIDEO_PXLFMT_AI_UFIXED16(frac_bits) (HD_VIDEO_PXLFMT_AI_UINT16 | (((16-(frac_bits))&0xff) << 8) | ((frac_bits)&0xff)) ///< unsigned fixpoint 16-bits
#define HD_VIDEO_PXLFMT_AI_SFIXED32(frac_bits) (HD_VIDEO_PXLFMT_AI_SINT32 | (((32-(frac_bits)-1)&0xff) << 8) | ((frac_bits)&0xff)) ///< signed fixpoint 32-bits
#define HD_VIDEO_PXLFMT_AI_UFIXED32(frac_bits) (HD_VIDEO_PXLFMT_AI_UINT32 | (((32-(frac_bits))&0xff) << 8) | ((frac_bits)&0xff)) ///< unsigned fixpoint 32-bits
/* ai buf format (addiitonal) */
#define HD_VIDEO_PXLFMT_BGR888_PLANAR 0x2B180888 ///< 3 plane, pixel=B(w,h), G(w,h), R(w,h)
#define HD_VIDEO_PXLFMT_UV 0x51100044 ///< 1 plane, pixel=UV(w,h)
#define HD_VIDEO_PXLFMT_R8 0x21080800 ///< 1 plane, pixel=R(w,h)
#define HD_VIDEO_PXLFMT_G8 0x21080080 ///< 1 plane, pixel=G(w,h)
#define HD_VIDEO_PXLFMT_B8 0x21080008 ///< 1 plane, pixel=B(w,h)
/* type of AI_PXLFMT */
#define AI_PXLFMT_TYPE(pxlfmt) (((pxlfmt) & (HD_VIDEO_PXLFMT_CLASS_MASK | HD_VIDEO_PXLFMT_PLANE_MASK | HD_VIDEO_PXLFMT_BPP_MASK)))
/* ai schd parm */
#define VENDOR_AI_FAIR_CORE_ALL 0x000000ff ///< fair: all dla core
#define VENDOR_AI_FAIR_CORE(ch) ((ch) & 0xff) ///< fair: select dla core (default 0)
#define VENDOR_AI_FAIR_CPU_ALL 0x00000000 ///< cpu: all core
#define VENDOR_AI_FAIR_CPU(ch) ((((ch)+1) & 0xff)<<8) ///< cpu: select cpu core (default 0)
#define VENDOR_AI_CAPA_RATE(r) (((r) & 0xff) << 24) ///< capacity: max rate (TODO)
/********************************************************************
TYPE DEFINITION
********************************************************************/
// set/get set/get/start
// ^ | ^ |
// | v | v
// [UNINIT] -- init --> [INIT] -- open --> [OPEN] -- start --> [START]
// <-- uninit -- <-- close -- <-- stop --
//
typedef enum _VENDOR_AI_PROC_STATE {
VENDOR_AI_PROC_STATE_UNINIT = 0,
VENDOR_AI_PROC_STATE_INIT,
VENDOR_AI_PROC_STATE_OPEN,
VENDOR_AI_PROC_STATE_START,
} VENDOR_AI_PROC_STATE;
/**
@name scheduler for all proc handle
*/
typedef enum {
VENDOR_AI_PROC_SCHD_FAIR = 0, ///< overlapping with fair core (default)
VENDOR_AI_PROC_SCHD_CAPACITY = 1, ///< overlapping with max rate (TODO)
VENDOR_AI_PROC_SCHD_FIFO = 2, ///< first in first out
} VENDOR_AI_PROC_SCHD;
/**
@name proc_id max count
*/
typedef struct _VENDOR_AI_CFG_PROC_COUNT {
UINT32 max_proc_count; ///< supported max count of proc_id
} VENDOR_AI_NET_CFG_PROC_COUNT;
/**
@name ai implement version
*/
#define VENDOR_AI_IMPL_VERSION_LENGTH 32
typedef struct _VENDOR_AI_NET_CFG_IMPL_VERSION {
CHAR vendor_ai_impl_version[VENDOR_AI_IMPL_VERSION_LENGTH];
CHAR kflow_ai_impl_version[VENDOR_AI_IMPL_VERSION_LENGTH];
CHAR kdrv_ai_impl_version[VENDOR_AI_IMPL_VERSION_LENGTH];
} VENDOR_AI_NET_CFG_IMPL_VERSION;
#define CORE_MAX 16
typedef struct _VENDOR_AI_CORE_UT {
CHAR name[8]; ///< name
UINT32 time; ///< time
UINT32 util; ///< utility
} VENDOR_AI_CORE_UT;
typedef struct _VENDOR_AI_PERF_UT {
UINT32 core_count;
VENDOR_AI_CORE_UT core[CORE_MAX];
} VENDOR_AI_PERF_UT;
/**
@name ai parameter id
*/
typedef enum _VENDOR_AI_CFG_ID {
//set before init
VENDOR_AI_CFG_PLUGIN_ENGINE = 0, ///< set/get, config engine pluign
VENDOR_AI_CFG_PROC_SCHD = 1, ///< set/get, config scheduler for all proc handle
VENDOR_AI_CFG_PROC_COUNT = 2, ///< get , max proc count , using VENDOR_AI_NET_CFG_PROC_COUNT struct
VENDOR_AI_CFG_IMPL_VERSION = 3, ///< get , implement version, using VENDOR_AI_NET_CFG_IMPL_VERSION struct
VENDOR_AI_CFG_PROC_CHK_INTERVAL = 4, ///< set/get, config timeout check interval (ms) (default 100, should > 100)
VENDOR_AI_CFG_PERF_UT = 5, ///< set/get, support perf ut between set and get
VENDOR_AI_CFG_SHAREMODEL_MODE = 6, ///< set/get, share model mode, value = [0/1], default 0
VENDOR_AI_CFG_MULTI_THREAD = 7, ///< set , support init multiply times (default 0, set to 0 or 1)
VENDOR_AI_CFG_MULTI_PROCESS = 8, ///< set , support multi process (default 0, set to 0 or 1)
VENDOR_AI_CFG_LIB_IMPL_VERSION = 9, ///< get , lib implement version
VENDOR_AI_CFG_KFLOW_IMPL_VERSION = 10, ///< get , kflow implement version
VENDOR_AI_CFG_KDRV_IMPL_VERSION = 11, ///< get , kdrv implement version
VENDOR_AI_CFG_NOTCHECK_INPUT_ALIGN = 12, ///< set/get, not check input align
ENUM_DUMMY4WORD(VENDOR_AI_CFG_ID)
} VENDOR_AI_CFG_ID;
/**
@name struct of model memory
*/
typedef struct _VENDOR_AI_NET_CFG_MODEL {
UINT32 pa; ///< physical address
UINT32 va; ///< virtual address
UINT32 size; ///< buffer size
} VENDOR_AI_NET_CFG_MODEL;
/**
@name struct of work memory
*/
typedef struct _VENDOR_AI_NET_CFG_WORKBUF {
UINT32 pa; ///< physical address
UINT32 va; ///< virtual address
UINT32 size; ///< buffer size
} VENDOR_AI_NET_CFG_WORKBUF;
/**
@name struct of internal memory
*/
typedef struct _VENDOR_AI_NET_CFG_INTLBUF {
UINT32 pa; ///< physical address
UINT32 va; ///< virtual address
UINT32 size; ///< buffer size
} VENDOR_AI_NET_CFG_INTLBUF;
typedef enum {
VENDOR_AI_NET_JOB_OPT_LINEAR = 0, ///< sequential trigger jobs (default)
VENDOR_AI_NET_JOB_OPT_LINEAR_O1 = 1, ///< sequential trigger jobs, with subgraph optimize level 1
VENDOR_AI_NET_JOB_OPT_GRAPH = 10, ///< parallel trigger jobs
VENDOR_AI_NET_JOB_OPT_GRAPH_O1 = 11, ///< parallel trigger jobs, with subgraph optimize level 1
VENDOR_AI_NET_JOB_OPT_GRAPH_O2 = 12, ///< parallel trigger jobs, with subgraph optimize level 2 (TODO)
VENDOR_AI_NET_JOB_OPT_GRAPH_O3 = 13, ///< parallel trigger jobs, with subgraph optimize level 3 (TODO)
} VENDOR_AI_NET_JOB_OPT;
/**
@name parameters of job optimize
*/
typedef struct _VENDOR_AI_NET_CFG_JOB_OPT {
VENDOR_AI_NET_JOB_OPT method; ///< job optimize method
INT32 wait_ms; ///< -1: sync mode, 0: async mode, >0: async mode with timeout
UINT32 schd_parm; ///< scheduler additional parameter, if not used, should set to 0
} VENDOR_AI_NET_CFG_JOB_OPT;
typedef enum {
VENDOR_AI_NET_BUF_OPT_FULL = 0, ///< allocate each buffer
VENDOR_AI_NET_BUF_OPT_SHRINK = 1, ///< shrink buffer space (default)
VENDOR_AI_NET_BUF_OPT_SHRINK_O1 = 2, ///< shrink buffer space with buffer optimize level 1
VENDOR_AI_NET_BUF_OPT_SHRINK_O2 = 3, ///< shrink buffer space with buffer optimize level 2
VENDOR_AI_NET_BUF_OPT_SHRINK_O3 = 4, ///< shrink buffer space with buffer optimize level 3 (TODO)
VENDOR_AI_NET_BUF_OPT_NONE = -1, ///< do nothing, using buffer space already in model bin
} VENDOR_AI_NET_BUF_OPT;
/**
@name parameters of buffer optimize
*/
typedef struct _VENDOR_AI_NET_CFG_BUF_OPT {
VENDOR_AI_NET_BUF_OPT method; ///< buffer optimize method
HD_COMMON_MEM_DDR_ID ddr_id; ///< ddr id
} VENDOR_AI_NET_CFG_BUF_OPT;
/**
@name net info
*/
typedef struct _VENDOR_AI_NET_INFO {
// model job info
UINT32 model_layer_cnt; ///< model layer count
UINT32 model_bind_cnt; ///< model bind count
// model buf info
UINT32 model_buf_cnt; ///< model total io buffer count
UINT32 model_dep_cnt; ///< model total dep buffer count
// model buf size
UINT32 model_buf_size; ///< model buffer size
UINT32 model_part1_size; ///< -model part1 size (header, job-desc, io-buffer-desc, job-workload)
UINT32 model_part2_size; ///< -model part2 size (weight-buffer-desc, weight-buffer)
// open buf info
UINT32 total_buf_cnt; ///< total buffer count
UINT32 in_buf_cnt; ///< in buffer count
UINT32 out_buf_cnt; ///< out buffer count
UINT32 in_buf_type; ///< in buffer type (signature)
UINT32 out_buf_type; ///< out buffer type (signature)
// open buf size
UINT32 work_buf_size; ///< work buffer size
UINT32 in_buf_size; ///< -in buffer size
UINT32 io_buf_size; ///< -io buffer size
UINT32 out_buf_size; ///< -out buffer size
UINT32 misc_buf_size; ///< -misc buffer size
// start job info
UINT32 total_job_cnt; ///< total job count
UINT32 total_bind_cnt; ///< total bind count
UINT32 in_job_cnt; ///< in job count
UINT32 out_job_cnt; ///< out job count
} VENDOR_AI_NET_INFO;
/**
@name input buffer / output buffer
*/
typedef struct _VENDOR_AI_BUF {
UINT32 sign; ///< signature = MAKEFOURCC('A','B','U','F')
UINT32 chunk_size; ///< sizeof(this sturct) - 8;
HD_COMMON_MEM_DDR_ID ddr_id; ///< ddr id
UINT32 pa; ///< physical address
UINT32 va; ///< virtual address
UINT32 size; ///< buffer size
HD_VIDEO_PXLFMT fmt; ///< format
UINT32 width; ///< width
UINT32 height; ///< height
UINT32 channel; ///< channel
UINT32 batch_num; ///< number of batch
UINT32 time; ///< number of time
union {
UINT32 reserve; ///< reserved
FLOAT scale_ratio; ///< for fixed and float
};
UINT32 line_ofs; ///< line offset
UINT32 channel_ofs; ///< channel offset
UINT32 batch_ofs; ///< batch offset
UINT32 time_ofs; ///< time offset
CHAR layout[8]; ///< layout order of W,H,C,N
CHAR *name; ///< buffer name, eg: "mylayer.out0"
CHAR *op_name; ///< related operation name
} VENDOR_AI_BUF;
/**
@name input buffer list / output buffer list
*/
typedef struct _VENDOR_AI_BUF_LIST {
UINT32 sign; ///< signature = MAKEFOURCC('A','L','S','T')
UINT32 chunk_size; ///< sizeof(this sturct) - 8;
UINT32 buf_count; ///< buffer count
VENDOR_AI_BUF *buf_list;
} VENDOR_AI_BUF_LIST;
/**
@name struct for finding buffer path
*/
typedef struct _VENDOR_AI_BUF_NAME {
CHAR name[100]; ///< buffer name, eg: "mylayer.out0"
UINT32 path_id; ///< path_id with VENDOR_AI_NET_PARAM_OUT() value
} VENDOR_AI_BUF_NAME;
/**
@name network parameter id
*/
typedef enum _VENDOR_AI_NET_PARAM_ID {
VENDOR_AI_NET_PARAM_STATE = 0, ///< get, proc state, using VENDOR_AI_PROC_STATE type, 1=ready, 2=open, 3=start
//set before open
VENDOR_AI_NET_PARAM_CFG_MODEL = 1, ///< set/get, config model , using VENDOR_AI_NET_CFG_MODEL struct
VENDOR_AI_NET_PARAM_CFG_MODEL_RESINFO = 2, ///< set , set difference resolution model bin, using VENDOR_AI_NET_CFG_MODEL struct
VENDOR_AI_NET_PARAM_CFG_SHAREMODEL = 3, ///< set/get, config share model , using VENDOR_AI_NET_CFG_MODEL struct
VENDOR_AI_NET_PARAM_CFG_JOB_OPT = 4, ///< set/get, config job optimize , using VENDOR_AI_NET_CFG_JOB_OPT struct
VENDOR_AI_NET_PARAM_CFG_BUF_OPT = 5, ///< set/get, config buf optimize , using VENDOR_AI_NET_CFG_BUF_OPT struct
VENDOR_AI_NET_PARAM_CFG_USER_POSTPROC = 6, ///< set , config user postproc, using void* (get_user_postproc)(void) to return VENDOR_AI_ENGINE_PLUGIN struct pointer
//get after open
VENDOR_AI_NET_PARAM_INFO = 20, ///< get , get net info, using VENDOR_AI_NET_INFO struct
VENDOR_AI_NET_PARAM_IN_PATH_LIST = 21, ///< get , get path_id of multiple input buffer, using UINT32 array
VENDOR_AI_NET_PARAM_OUT_PATH_LIST = 22, ///< get , get path_id of multiple output buffer, using UINT32 array
VENDOR_AI_NET_PARAM_OUT_PATH_BY_NAME = 24, ///< get , get output path by output name, using VENDOR_AI_BUF_NAME struct
VENDOR_AI_NET_PARAM_LAST_LAYER_LABELNUM = 25, ///< get , get last layer label number
//set after open ~ before start
VENDOR_AI_NET_PARAM_CFG_WORKBUF = 41, ///< get , set work memory, using VENDOR_AI_NET_CFG_WORKBUF struct
VENDOR_AI_NET_PARAM_RES_ID = 42, ///< set/get, set resolution by id (0 means default resolution)
VENDOR_AI_NET_PARAM_RES_DIM = 43, ///< set/get, set resolution by dim, using HD_DIM struct
VENDOR_AI_NET_PARAM_CFG_INTLBUF = 44, ///< get , set work memory, using VENDOR_AI_NET_CFG_INTLBUF struct
VENDOR_AI_NET_PARAM_BATCH_ID = 45, ///< set/get, set batch number by id, using UINT32
VENDOR_AI_NET_PARAM_BATCH_N = 46, ///< set/get, set batch number, using UINT32
VENDOR_AI_NET_PARAM_RES_ID_IMM = 47, ///< set/get, set resolution by id (0 means default resolution), MUST set after START
VENDOR_AI_NET_PARAM_RES_DIM_IMM = 48, ///< set/get, set resolution by dim, using HD_DIM struct, MUST set after START
//get/set after start ~ before stop
//VENDOR_AI_NET_PARAM_IN(layer_id, in_id), ///< set , set single input buffer, using VENDOR_AI_BUF struct
///< get , get single input buffer, using VENDOR_AI_BUF struct
//VENDOR_AI_NET_PARAM_OUT(layer_id, out_id), ///< get , get single output buffer, using VENDOR_AI_BUF struct
//VENDOR_AI_NET_PARAM_DEP(dep_id), ///< get , get dependent buffer size, using UINT32
///< push_in, push_in dependent buffer for signal "ready to use"
///< push_out, push_out dependent buffer for waiting "use finished"
VENDOR_AI_NET_PARAM_IN_BUF_LIST = 51, ///< set , set multiple input buffer, using related output struct array (TODO)
///< get , get multiple input buffer, using related output struct array (TODO)
VENDOR_AI_NET_PARAM_OUT_BUF_LIST = 52, ///< get , get multiple output buffer, using related output struct array (TODO)
VENDOR_AI_NET_PARAM_CUSTOM_INFO = 53, ///< set , set user info
ENUM_DUMMY4WORD(VENDOR_AI_NET_PARAM_ID)
} VENDOR_AI_NET_PARAM_ID;
/********************************************************************
SINGLE OPERATION DEFINITION
********************************************************************/
/**
@name operator id
*/
typedef enum _VENDOR_AI_OP {
VENDOR_AI_OP_END = 0, ///< end
VENDOR_AI_OP_FC = 1, ///< fully connect (vector dot vector), (deprecated)
VENDOR_AI_OP_PREPROC = 2, ///< image transform (color convert, crop, scale, sub, crop, pad and rotate)
VENDOR_AI_OP_LIST = 0xffff, ///< op command list
ENUM_DUMMY4WORD(VENDOR_AI_OP)
} VENDOR_AI_OP;
/**
@name struct of work memory
*/
typedef struct _VENDOR_AI_OP_CFG_WORKBUF {
VENDOR_AI_OP op; ///< config op
UINT32 pa; ///< physical address
UINT32 va; ///< virtual address
UINT32 size; ///< buffer size
} VENDOR_AI_OP_CFG_WORKBUF;
typedef VENDOR_AI_OP_CFG_WORKBUF VENDOR_AI_OP_FC_CMDBUF;
/**
@name op parameter id
*/
typedef enum _VENDOR_AI_OP_PARAM_ID {
//set before open
VENDOR_AI_OP_PARAM_CFG_MAX = 1, ///< set/get, config max , using VENDOR_AI_OP_CFG_MAX struct
//get after open
//set after open ~ before start
VENDOR_AI_OP_PARAM_CFG_WORKBUF = 41, ///< get , set work memory, using VENDOR_AI_OP_CFG_WORKBUF struct
ENUM_DUMMY4WORD(VENDOR_AI_OP_PARAM_ID)
} VENDOR_AI_OP_PARAM_ID;
/**
@name struct of op config max
*/
typedef struct _VENDOR_AI_OP_CFG_MAX {
VENDOR_AI_OP op; ///< config op
UINT32 max_cnt; ///< max count of op
UINT32 max_param[4]; ///< max parameters of op
UINT32 size; ///< buffer size
} VENDOR_AI_OP_CFG_MAX;
typedef struct _VENDOR_AI_OP_PREPROC_PARAM {
HD_DIM scale_dim; ///< scale dim, set (0,0) to OFF
VENDOR_AI_BUF p_out_sub; ///< out subtract plane, packed format, set NULL to OFF
UINT32 out_sub_color[3]; ///< out subtract constant value, set [0,0,0] to OFF
HD_IRECT in_crop_win; ///< in crop window, coord is based on in_buf.dim, set (0,0,0,0) to OFF (TODO)
HD_IRECT out_crop_win; ///< out crop window, coord is based on scale dim, set (0,0,0,0) to OFF (TODO)
HD_IPOINT out_crop_pt; ///< out crop window, coord is based on out_buf.dim, set (0,0) to OFF (TODO)
HD_DIM pad_dim; ///< out padding window, coord is based on out_buf.dim, set (0,0) to OFF (TODO)
UINT32 pad_color[3]; ///< out padding constant value, set [???] to OFF (TODO)
UINT32 dir; ///< out direct: mirror-x, mirror-y, rotate, set 0 to OFF, use HD_VIDEO_DIR_XXXX flags (TODO)
} VENDOR_AI_OP_PREPROC_PARAM;
/********************************************************************
EXTERN VARIABLES & FUNCTION PROTOTYPES DECLARATIONS
********************************************************************/
#ifdef __cplusplus
extern "C" {
#endif
extern HD_RESULT vendor_ai_init (VOID);
extern HD_RESULT vendor_ai_uninit (VOID);
extern HD_RESULT vendor_ai_get_id (UINT32* proc_id);
extern HD_RESULT vendor_ai_release_id (UINT32 proc_id);
// general config
extern HD_RESULT vendor_ai_cfg_set (VENDOR_AI_CFG_ID cfg_id, void* p_param);
extern HD_RESULT vendor_ai_cfg_get (VENDOR_AI_CFG_ID cfg_id, void* p_param);
// static network
extern HD_RESULT vendor_ai_net_set (UINT32 proc_id, VENDOR_AI_NET_PARAM_ID param_id, void* p_param);
extern HD_RESULT vendor_ai_net_get (UINT32 proc_id, VENDOR_AI_NET_PARAM_ID param_id, void* p_param);
extern HD_RESULT vendor_ai_net_open (UINT32 proc_id);
extern HD_RESULT vendor_ai_net_close (UINT32 proc_id);
extern HD_RESULT vendor_ai_net_start (UINT32 proc_id);
extern HD_RESULT vendor_ai_net_stop (UINT32 proc_id);
extern HD_RESULT vendor_ai_net_proc (UINT32 proc_id);
extern HD_RESULT vendor_ai_net_proc_buf (UINT32 proc_id, VENDOR_AI_NET_PARAM_ID in_param_id, void* p_in_buf, VENDOR_AI_NET_PARAM_ID out_param_id, void* p_out_buf);
extern HD_RESULT vendor_ai_net_push_in_buf (UINT32 proc_id, VENDOR_AI_NET_PARAM_ID in_param_id, void* p_in_buf, INT32 wait_ms);
extern HD_RESULT vendor_ai_net_pull_out_buf (UINT32 proc_id, VENDOR_AI_NET_PARAM_ID out_param_id, void* p_out_buf, INT32 wait_ms);
// dynamic operator
extern HD_RESULT vendor_ai_op_set (UINT32 proc_id, VENDOR_AI_OP_PARAM_ID param_id, void* p_param);
extern HD_RESULT vendor_ai_op_get (UINT32 proc_id, VENDOR_AI_OP_PARAM_ID param_id, void* p_param);
extern HD_RESULT vendor_ai_op_open (UINT32 proc_id);
extern HD_RESULT vendor_ai_op_close (UINT32 proc_id);
extern HD_RESULT vendor_ai_op_start (UINT32 proc_id);
extern HD_RESULT vendor_ai_op_stop (UINT32 proc_id);
extern HD_RESULT vendor_ai_op_proc (UINT32 proc_id, VENDOR_AI_OP op_id, void* p_op_param, UINT32 in_cnt, VENDOR_AI_BUF* p_in_buf, UINT32 out_cnt, VENDOR_AI_BUF* p_out_buf);
extern HD_RESULT vendor_ai_op_add (UINT32 proc_id, VENDOR_AI_OP op_id, void* p_op_param, UINT32 in_cnt, VENDOR_AI_BUF* p_in_buf, UINT32 out_cnt, VENDOR_AI_BUF* p_out_buf);
#ifdef __cplusplus
}
#endif
#endif /* _VENDOR_AI_NET_H_ */
Reference in New Issue View Git Blame Copy Permalink