itidl_ti.h

Go to the documentation of this file.

/*
*
* Copyright (c) {2015 - 2020} Texas Instruments Incorporated
*
* All rights reserved not granted herein.
*
* Limited License.
*
* Texas Instruments Incorporated grants a world-wide, royalty-free, non-exclusive
* license under copyrights and patents it now or hereafter owns or controls to make,
* have made, use, import, offer to sell and sell ("Utilize") this software subject to the
* terms herein.  With respect to the foregoing patent license, such license is granted
* solely to the extent that any such patent is necessary to Utilize the software alone.
* The patent license shall not apply to any combinations which include this software,
* other than combinations with devices manufactured by or for TI ("TI Devices").
* No hardware patent is licensed hereunder.
*
* Redistributions must preserve existing copyright notices and reproduce this license
* (including the above copyright notice and the disclaimer and (if applicable) source
* code license limitations below) in the documentation and/or other materials provided
* with the distribution
*
* Redistribution and use in binary form, without modification, are permitted provided
* that the following conditions are met:
*
* *       No reverse engineering, decompilation, or disassembly of this software is
* permitted with respect to any software provided in binary form.
*
* *       any redistribution and use are licensed by TI for use only with TI Devices.
*
* *       Nothing shall obligate TI to provide you with source code for the software
* licensed and provided to you in object code.
*
* If software source code is provided to you, modification and redistribution of the
* source code are permitted provided that the following conditions are met:
*
* *       any redistribution and use of the source code, including any resulting derivative
* works, are licensed by TI for use only with TI Devices.
*
* *       any redistribution and use of any object code compiled from the source code
* and any resulting derivative works, are licensed by TI for use only with TI Devices.
*
* Neither the name of Texas Instruments Incorporated nor the names of its suppliers
*
* may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* DISCLAIMER.
*
* THIS SOFTWARE IS PROVIDED BY TI AND TI'S LICENSORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL TI AND TI'S LICENSORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/


#ifndef ITIDL_H_
#define ITIDL_H_

#define USE_IVISION (1)

#include <stdint.h>
#include <stdarg.h>
#include <stdlib.h>

#ifdef  TIDL_IMPORT_TOOL
#define USE_IVISION (0)
#endif

#if USE_IVISION
#include <ivision.h>



extern const IVISION_Fxns TIDL_VISION_FXNS;

#endif
#ifdef __cplusplus
extern "C" {
#endif

#define TIDL_NUM_MAX_LAYERS     ((int32_t) 1024)
#define TIDL_NUM_IN_BUFS        ((int32_t) 16)
#define TIDL_NUM_OUT_BUFS       ((int32_t) 16)
#define TIDL_STRING_SIZE        ((int32_t) 512)
#define TIDL_MAX_DATA_BUFS      ((int32_t) 1024)
#define TIDL_MAX_ALG_IN_BUFS    ((int32_t) 32)
#define TIDL_MAX_ALG_OUT_BUFS   ((int32_t) 32)
#define TIDL_MAX_NUM_GROUPS     ((int32_t) 64)


/* Typedef for 32 bit float */
typedef float float32_tidl;
/* Typedef for 64 bit float */
typedef double float64_tidl;

#define TIDL_DataLayer                 ((int32_t) 0)
#define TIDL_ConvolutionLayer          ((int32_t) 1)
#define TIDL_PoolingLayer              ((int32_t) 2)
#define TIDL_ReLULayer                 ((int32_t) 3)
#define TIDL_PReLULayer                ((int32_t) 4)
#define TIDL_EltWiseLayer              ((int32_t) 5)
#define TIDL_InnerProductLayer         ((int32_t) 6)
#define TIDL_SoftMaxLayer              ((int32_t) 7)
#define TIDL_BatchNormLayer            ((int32_t) 8)
#define TIDL_BiasLayer                 ((int32_t) 9)
#define TIDL_ScaleLayer                ((int32_t) 10)
#define TIDL_Deconv2DLayer             ((int32_t) 11)
#define TIDL_ConcatLayer               ((int32_t) 12)
#define TIDL_SplitLayer                ((int32_t) 13)
#define TIDL_SliceLayer                ((int32_t) 14)
#define TIDL_CropLayer                 ((int32_t) 15)
#define TIDL_FlattenLayer              ((int32_t) 16)
#define TIDL_DropOutLayer              ((int32_t) 17)
#define TIDL_ArgMaxLayer               ((int32_t) 18)
#define TIDL_DetectionOutputLayer      ((int32_t) 19)
#define TIDL_ShuffleChannelLayer       ((int32_t) 20)
#define TIDL_ResizeLayer               ((int32_t) 21)
#define TIDL_RoiPoolingLayer           ((int32_t) 22)
#define TIDL_OdPostProcessingLayer     ((int32_t) 23)
#define TIDL_DepthToSpaceLayer         ((int32_t) 24)
#define TIDL_SigmoidLayer              ((int32_t) 25)
#define TIDL_PadLayer                  ((int32_t) 26)
#define TIDL_ColorConversionLayer      ((int32_t) 27)
#define TIDL_TfODOutputLayer           ((int32_t) 28)
#define TIDL_CustomLayer               ((int32_t) 29)
#define TIDL_UnsupportedLayer          ((int32_t) 30)
/* @} */

#define TIDL_UnsignedChar          ((int32_t) 0)
#define TIDL_SignedChar            ((int32_t) 1)
#define TIDL_UnsignedShort         ((int32_t) 2)
#define TIDL_SignedShort           ((int32_t) 3)
#define TIDL_UnsignedWord          ((int32_t) 4)
#define TIDL_SignedWord            ((int32_t) 5)
#define TIDL_SinglePrecFloat       ((int32_t) 6)
/* @} */

#define TIDL_QuantStyleFixed       ((int32_t) 0)

#define TIDL_QuantStyleDynamic     ((int32_t) 1)

#define TIDL_QuantStyleNP2Fixed    ((int32_t) 2)

#define TIDL_QuantStyleP2Dynamic   ((int32_t) 3)

#define TIDL_QuantStyleCustom      ((int32_t) 10)
/* @} */

#define TIDL_CalibOptionActivationRange        ((int32_t) 1)

#define TIDL_CalibOptionWeightRange            ((int32_t) 2)

#define TIDL_CalibOptionBiasCalibration           ((int32_t) 4)

#define TIDL_CalibOptionPerChannelWeightQuantization ((int32_t) 8)

#define TIDL_CalibOptionMixedPrecisionDepthwise ((int32_t) 16)

#define TIDL_CalibOptionMixedPrecisionInput ((int32_t) 32)


/* @} */

#define TIDL_ActivationRangeMethodHistogram           ((int32_t) 0)

#define TIDL_ActivationRangeMethodGlobalHistogram           ((int32_t) 1)


/* @} */

#define TIDL_WeightRangeMethodHistogram        ((int32_t) 0)

#define TIDL_WeightRangeMethodMedian        ((int32_t) 1)
/* @} */


#define TIDL_OptimiseExtMemL0      ((int32_t) 0)

#define TIDL_OptimiseExtMemL1      ((int32_t) 1)

#define TIDL_OptimiseExtMemL2      ((int32_t) 2)
/* @} */

#define TIDL_Sparse                ((int32_t) 0)

#define TIDL_Dense                 ((int32_t) 1)
/* @} */

#define TIDL_StrideOffsetTopLeft   ((int32_t) 0)
#define TIDL_StrideOffsetCenter    ((int32_t) 1)
#define TIDL_StrideOffsetMax       ((int32_t) 2)
/* @} */

#define TIDL_MaxPooling            ((int32_t) 0)
#define TIDL_AveragePooling        ((int32_t) 1)
/* @} */


#define TIDL_NoAct                 ((int32_t) 0)
#define TIDL_RelU                  ((int32_t) 1)
#define TIDL_PRelU                 ((int32_t) 2)
#define TIDL_RelU6                 ((int32_t) 3)
#define TIDL_Clip                  ((int32_t) 4)
#define TIDL_Sigmoid               ((int32_t) 5)
/* @} */

#define TIDL_EltWiseProduct        ((int32_t) 0)
#define TIDL_EltWiseSum            ((int32_t) 1)
#define TIDL_EltWiseMax            ((int32_t) 2)
/* @} */

#define TIDL_DIM_BATCH             ((int32_t) 0)
#define TIDL_DIM_NUMCH             ((int32_t) 1)
#define TIDL_DIM_HEIGHT            ((int32_t) 2)
#define TIDL_DIM_WIDTH             ((int32_t) 3)
#define TIDL_DIM_MAX               ((int32_t) 4)
/* @} */

#define TIDL_ROI_PITCH             ((uint32_t) 0)
#define TIDL_CHANNEL_PITCH         ((uint32_t) 1)
#define TIDL_LINE_PITCH            ((uint32_t) 2)
#define TIDL_PITCH_MAX             ((uint32_t) (TIDL_DIM_MAX - 1))
/* @} */

/* Convolution layer error types */
#define TIDL_E_CONVOLUTION                         ((int32_t) -1000)
#define TIDL_E_CONV_INVALID_INPUT_WIDTH            ((int32_t) (TIDL_E_CONVOLUTION - 0))
#define TIDL_E_CONV_INVALID_INPUT_HEIGHT           ((int32_t) (TIDL_E_CONVOLUTION - 1))
#define TIDL_E_CONV_INVALID_OUTPUT_WIDTH           ((int32_t) (TIDL_E_CONVOLUTION - 2))
#define TIDL_E_CONV_INVALID_OUTPUT_HEIGHT          ((int32_t) (TIDL_E_CONVOLUTION - 3))
#define TIDL_E_CONV_INVALID_NUM_IN_CHANNELS        ((int32_t) (TIDL_E_CONVOLUTION - 4))
#define TIDL_E_CONV_INVALID_NUM_OUT_CHANNELS       ((int32_t) (TIDL_E_CONVOLUTION - 5))
#define TIDL_E_CONV_INVALID_KER_WIDTH              ((int32_t) (TIDL_E_CONVOLUTION - 6))
#define TIDL_E_CONV_INVALID_KER_HEIGHT             ((int32_t) (TIDL_E_CONVOLUTION - 7))
#define TIDL_E_CONV_INVALID_KER_TYPE               ((int32_t) (TIDL_E_CONVOLUTION - 8))
#define TIDL_E_CONV_INVALID_STRIDE_WIDTH           ((int32_t) (TIDL_E_CONVOLUTION - 9))
#define TIDL_E_CONV_INVALID_STRIDE_HEIGHT          ((int32_t) (TIDL_E_CONVOLUTION - 10))
#define TIDL_E_CONV_NEGATIVE_OUTPUT_SHIFT          ((int32_t) (TIDL_E_CONVOLUTION - 11))
/* Convolution pooling error types */
#define TIDL_E_CONV_POOL_INVALID_POOL_TYPE         ((int32_t) (TIDL_E_CONVOLUTION - 12))
#define TIDL_E_CONV_POOL_INVALID_KER_WIDTH         ((int32_t) (TIDL_E_CONVOLUTION - 13))
#define TIDL_E_CONV_POOL_INVALID_KER_HEIGHT        ((int32_t) (TIDL_E_CONVOLUTION - 14))
#define TIDL_E_CONV_POOL_INVALID_STRIDE_WIDTH      ((int32_t) (TIDL_E_CONVOLUTION - 15))
#define TIDL_E_CONV_POOL_INVALID_STRIDE_HEIGHT     ((int32_t) (TIDL_E_CONVOLUTION - 16))
/* EltWise layer error types */
#define TIDL_E_ELTWISE                             ((int32_t) -1020)
#define TIDL_E_ELTWISE_INVALID_INPUT_WIDTH         ((int32_t) (TIDL_E_ELTWISE - 0))
#define TIDL_E_ELTWISE_INVALID_INPUT_HEIGHT        ((int32_t) (TIDL_E_ELTWISE - 1))
#define TIDL_E_ELTWISE_INVALID_OUTPUT_WIDTH        ((int32_t) (TIDL_E_ELTWISE - 2))
#define TIDL_E_ELTWISE_INVALID_OUTPUT_HEIGHT       ((int32_t) (TIDL_E_ELTWISE - 3))
#define TIDL_E_ELTWISE_INVALID_ELTWISE_TYPE        ((int32_t) (TIDL_E_ELTWISE - 4))
#define TIDL_E_ELTWISE_INVALID_NUM_CHANNELS        ((int32_t) (TIDL_E_ELTWISE - 5))
/* Pooling error types */
#define TIDL_E_POOLING                             ((int32_t) -1030)
#define TIDL_E_POOL_INVALID_INPUT_WIDTH            ((int32_t) (TIDL_E_POOLING - 0))
#define TIDL_E_POOL_INVALID_INPUT_HEIGHT           ((int32_t) (TIDL_E_POOLING - 1))
#define TIDL_E_POOL_INVALID_OUTPUT_WIDTH           ((int32_t) (TIDL_E_POOLING - 2))
#define TIDL_E_POOL_INVALID_OUTPUT_HEIGHT          ((int32_t) (TIDL_E_POOLING - 3))
#define TIDL_E_POOL_INVALID_POOL_TYPE              ((int32_t) (TIDL_E_POOLING - 4))
#define TIDL_E_POOL_INVALID_NUM_CHANNELS           ((int32_t) (TIDL_E_POOLING - 5))
#define TIDL_E_POOL_INVALID_KER_WIDTH              ((int32_t) (TIDL_E_POOLING - 6))
#define TIDL_E_POOL_INVALID_KER_HEIGHT             ((int32_t) (TIDL_E_POOLING - 7))
#define TIDL_E_POOL_INVALID_STRIDE_WIDTH           ((int32_t) (TIDL_E_POOLING - 8))
#define TIDL_E_POOL_INVALID_STRIDE_HEIGHT          ((int32_t) (TIDL_E_POOLING - 9))
/* Inner product error types */
#define TIDL_E_INNER_PRODUCT                       ((int32_t) -1040)
#define TIDL_E_IP_INVALID_NUM_IN_NODES             ((int32_t) (TIDL_E_INNER_PRODUCT - 0))
#define TIDL_E_IP_INVALID_NUM_OUT_NODES            ((int32_t) (TIDL_E_INNER_PRODUCT - 1))
#define TIDL_E_IP_NEGATIVE_OUTPUT_SHIFT            ((int32_t) (TIDL_E_INNER_PRODUCT - 2))
/* Argmax error types */
#define TIDL_E_ARGMAX                              ((int32_t) -1050)
#define TIDL_E_ARGMAX_INVALID_NUM_CHANNELS         ((int32_t) (TIDL_E_ARGMAX - 0))
/* Bias error types */
#define TIDL_E_BN                                  ((int32_t) -1060)
#define TIDL_E_BN_INVALID_INPUT_WIDTH              ((int32_t) (TIDL_E_BN - 0))
#define TIDL_E_BN_INVALID_INPUT_HEIGHT             ((int32_t) (TIDL_E_BN - 1))
#define TIDL_E_BN_INVALID_OUTPUT_WIDTH             ((int32_t) (TIDL_E_BN - 2))
#define TIDL_E_BN_INVALID_OUTPUT_HEIGHT            ((int32_t) (TIDL_E_BN - 3))
#define TIDL_E_BN_INVALID_NUM_CHANNELS             ((int32_t) (TIDL_E_BN - 4))
#define TIDL_E_BN_INVALID_ENABLE_RELU              ((int32_t) (TIDL_E_BN - 5))
#define TIDL_E_BN_NEGATIVE_OUTPUT_SHIFT            ((int32_t) (TIDL_E_BN - 6))
/* Crop layer error types */
#define TIDL_E_CROP                                ((int32_t) -1070)
#define TIDL_E_CROP_INVALID_INPUT_WIDTH            ((int32_t) (TIDL_E_CROP - 0))
#define TIDL_E_CROP_INVALID_INPUT_HEIGHT           ((int32_t) (TIDL_E_CROP - 1))
#define TIDL_E_CROP_INVALID_OUTPUT_WIDTH           ((int32_t) (TIDL_E_CROP - 2))
#define TIDL_E_CROP_INVALID_OUTPUT_HEIGHT          ((int32_t) (TIDL_E_CROP - 3))
#define TIDL_E_CROP_INVALID_NUM_CHANNELS           ((int32_t) (TIDL_E_CROP - 4))
#define TIDL_E_CROP_INVALID_OFFSET_WIDTH           ((int32_t) (TIDL_E_CROP - 5))
#define TIDL_E_CROP_INVALID_OFFSET_HEIGHT          ((int32_t) (TIDL_E_CROP - 6))
/* Flatten layer error types */
#define TIDL_E_FLATTEN                             ((int32_t) -1080)
#define TIDL_E_FLATTEN_INVALID_INPUT_WIDTH         ((int32_t) (TIDL_E_FLATTEN - 0))
#define TIDL_E_FLATTEN_INVALID_INPUT_HEIGHT        ((int32_t) (TIDL_E_FLATTEN - 1))
#define TIDL_E_FLATTEN_INVALID_OUTPUT_WIDTH        ((int32_t) (TIDL_E_FLATTEN - 2))
#define TIDL_E_FLATTEN_INVALID_OUTPUT_HEIGHT       ((int32_t) (TIDL_E_FLATTEN - 3))
/* SoftMax error types */
#define TIDL_E_SOFTMAX                             ((int32_t) -1090)
#define TIDL_E_SOFTMAX_INVALID_NUM_CHANNELS        ((int32_t) (TIDL_E_SOFTMAX - 0))
/* ShuffleChanel error types */
#define TIDL_E_SHUFFLECHANNEL                       ((int32_t) -1100)
#define TIDL_E_SHUFFLECHANNEL_INVALID_INPUT_WIDTH   ((int32_t) (TIDL_E_SHUFFLECHANNEL - 0))
#define TIDL_E_SHUFFLECHANNEL_INVALID_INPUT_HEIGHT  ((int32_t) (TIDL_E_SHUFFLECHANNEL - 1))
#define TIDL_E_SHUFFLECHANNEL_INVALID_OUTPUT_WIDTH  ((int32_t) (TIDL_E_SHUFFLECHANNEL - 2))
#define TIDL_E_SHUFFLECHANNEL_INVALID_OUTPUT_HEIGHT ((int32_t) (TIDL_E_SHUFFLECHANNEL - 3))
#define TIDL_E_SHUFFLECHANNEL_INVALID_NUM_GROUPS    ((int32_t) (TIDL_E_SHUFFLECHANNEL - 4))
/* Error types common to layers */
#define TIDL_E_COMMON                              ((int32_t) -1110)
#define TIDL_E_UNSUPPORTED_LAYER                   ((int32_t) (TIDL_E_COMMON - 0))
#define TIDL_E_DATAFLOW_INFO_NULL                  ((int32_t) (TIDL_E_COMMON - 1))
#define TIDL_E_INVALID_DEBUG_TRACE_PRM             ((int32_t) (TIDL_E_COMMON - 2))
#define TIDL_E_INVALID_NET_VERSION                 ((int32_t) (TIDL_E_COMMON - 3))
#define TIDL_E_INVALID_IO_LINE_PITCH               ((int32_t) (TIDL_E_COMMON - 4))
#define TIDL_E_QUANT_STATS_NOT_AVAILABALE          ((int32_t) (TIDL_E_COMMON - 5))
/* @} */

#define TIDL_SYSMEM_L1_SCRATCH     ((uint32_t) 0)
#define TIDL_SYSMEM_L2_SCRATCH     ((uint32_t) 1)
#define TIDL_SYSMEM_L3_SCRATCH     ((uint32_t) 2)
#define TIDL_SYSMEM_DDR_SCRATCH    ((uint32_t) 3)
#define TIDL_SYSMEM_MAX            ((uint32_t) 4)
/* @} */

#define TIDL_EXEC_MODE_STATS_COLLECTION       ((int32_t) 0)

#define TIDL_EXEC_MODE_UPDATE_TENSOR_SCALE    ((int32_t) 1)

#define TIDL_EXEC_MODE_INFER_PROCESS          ((int32_t) 2)
#define TIDL_EXEC_MODE_INFER_PROCESS_REF      ((int32_t) 3)


/* @} */

typedef struct
{
  void* ptr;
  int32_t bufSize;
  int32_t reserved[2];
}sBuffer_t;

typedef struct
{
  void    *base;
  int32_t  size;
  int32_t  offset;
}sTIDL_sysMemHandle_t;

typedef struct {
  int32_t dataId;
  int32_t elementType;
  int32_t numDim;
  int32_t dataQ;
  int32_t minValue;
  int32_t maxValue;
  float32_tidl   minTensorValue;
  float32_tidl   maxTensorValue;
  float32_tidl   tensorScale;
  int32_t padW;
  int32_t padH;
  int32_t roundBits;
  int32_t pitch[TIDL_DIM_MAX-1];
  int32_t dimValues[TIDL_DIM_MAX];
}sTIDL_DataParams_t;



typedef struct {
  int32_t   numChannels;
  int32_t   dataQ;
}sTIDL_DataLayerParams_t;


typedef struct {
  int32_t   numGroups;
  int32_t   resvd;
}sTIDL_ShuffleLayerParams_t;

typedef struct {
  int32_t   blockSize;
}sTIDL_DepthToSpaceParams_t;

typedef struct {
  int32_t padT;
  int32_t padB;
  int32_t padL;
  int32_t padR;
  int32_t   padConstValue;
  int32_t   padType;
  int32_t   perChannelPadConstTensorOffset;
}sTIDL_PadLayerParams_t;

typedef struct {
  int32_t layerType;
}sTIDL_TfODOutputLayerParams_t;

typedef enum
{
  TIDL_ResizeNearest = 0,
  TIDL_ResizeBilinear = 1,
  TIDL_ResizeMax,
}eTIDL_ResizeType;

typedef struct {
  int32_t   mode;
  float32_tidl     resizeRatio[TIDL_DIM_MAX];
}sTIDL_ResizeLayerParams_t;

typedef enum
{
  TIDL_RoiPoolingFasterRCNN = 0,
  TIDL_RoiPoolingMax,
}eTIDL_RoiPoolingType;

typedef enum
{
  TIDL_PadZero = 0,
  TIDL_PadNonZeroConstant,
  TIDL_PadPerChannel,
}eTIDL_PadLayerPadType;

typedef enum
{
  TIDL_DetectionBoxes = 0,
  TIDL_DetectionClasses,
  TIDL_DetectionScores,
  TIDL_NumDetections,
}eTIDL_TfODOutputType;

typedef struct {
  int32_t   poolingType;
  int32_t imWidth;
  int32_t imHeight;
}sTIDL_RoiPoolingLayerParams_t;


typedef struct {
  int32_t   slicePoints[TIDL_NUM_OUT_BUFS+1];
  int32_t  axis;
  int32_t  stride;
}sTIDL_SliceLayerParams_t;

typedef struct {
  int32_t   slope;
  float32_tidl     slopeScale;
  float32_tidl     clipMin;
  //**  maximum value for clip */
  float32_tidl     clipMax;
  int32_t   actType;
}sTIDL_ActParams_t;

typedef struct {
  int32_t activationRangeMethod;
  int32_t weightRangeMethod;
  float32_tidl percentileActRangeShrink;
  float32_tidl percentileWtRangeShrink;
  float32_tidl biasCalibrationFactor;
  int32_t biasCalibrationIterations;
}sTIDL_CalibParams_t;


typedef struct {
  int32_t   numChannels;
  int32_t   inDataQ;
  int32_t   outDataQ;
}sTIDL_ArgMaxParams_t;

typedef struct {
  int32_t   numChannels;
  int32_t   poolingType;
  int32_t   kernelW;
  int32_t   kernelH;
  int32_t   strideW;
  int32_t   strideH;
  int32_t   padW;
  int32_t   padH;
  int32_t   inDataQ;
  int32_t   outDataQ;
  int32_t   useCeil;
}sTIDL_PoolingParams_t;

typedef struct {
  int32_t   customLayerType;
  int32_t padW;
  int32_t padH;
  int32_t memOverlapType;
  int32_t doesLayerChangePadding;
  int32_t doesLayerFillOutXPadding;
  int32_t rsvdPassThrough;
}sTIDL_CustomParams_t;

typedef struct {
  int32_t   weights;
  int32_t   bias;
  int32_t   perChannelWeightScaleOffset;
  int32_t   convolutionType;
  int32_t   numInChannels;
  int32_t   numOutChannels;
  int32_t   numGroups;
  int32_t   kernelW;
  int32_t   kernelH;
  int32_t   strideW;
  int32_t   strideH;
  int32_t   dilationW;
  int32_t   dilationH;
  int32_t   padW;
  int32_t   padH;
  float32_tidl     weightScale;
  float32_tidl     biasScale;
  int32_t   weightsQ;
  int32_t   zeroWeightValue;
  int32_t   biasB;
  int32_t   biasQ;
  int32_t   inDataQ;
  int32_t   outDataQ;
  int32_t   interDataQ;
  int32_t   enableBias;
  int32_t   enablePooling;
  int32_t   enableEltWise;
  int32_t   enableEWRelU;
  int32_t   kernelType;
  int32_t   enableDepthToSpace;
  int32_t   upscaleFactor;
  sTIDL_PoolingParams_t poolParams;
}sTIDL_ConvParams_t;

typedef enum
{
  TIDL_metaArchCaffeJacinto = 0,
  TIDL_metaArchTFSSD = 1,
  TIDL_metaArchTFFasterRcnn = 2,
  TIDL_metaArchTIDLSSD = 3,
  TIDL_metaArchTIDLYolo= 4,
  TIDL_metaArchTIDLRetinaNet= 5,
  TIDL_metaArchMax = 6
}eTIDL_metaArchType;

typedef enum
{
  TIDL_processingTypeDetectionOutput = 0,
  TIDL_processingTypeOdPostProcessing = 1,
  TIDL_processingTypeMax = 3
}eTIDL_processingType;

typedef enum
{
  TIDL_scoreConverterLINEAR = 0,
  TIDL_scoreConverterSIGMOID = 1,
  TIDL_scoreConverterSOFTMAX = 2
}eTIDL_scoreConverterType;

typedef struct {
   int32_t  processingType;
  int32_t  priorBox;
  int32_t  priorBoxSize;
  int32_t  numClasses;
  int32_t  backgroundLabelId;
  int32_t  codeType;
  float32_tidl  confThreshold;
  float32_tidl  nmsThreshold;
  float32_tidl  eta;
  int32_t  topK;
  int32_t  keepTopK;
  int32_t  shareLocation;
  int32_t  varianceEncoded;
  int32_t  numKeypoints;

  int32_t  numHeads;

  int32_t imWidth;

  int32_t imHeight;

  /*0 -> IDENTITY, 1 -> SIGMOID, 2 -> SOFTMAX*/
  int32_t scoreConverter;

  int32_t metaArchType;

  /* 0 -> All the Data from given Anchor Box are together, 
     1 -> Data from all Anchor Box are interleaved */
  int32_t dataLayout;

}sTIDL_DetectOutputParams_t;


#define TIDL_OD_MAX_KEYPOINTS         (16)
#define TIDL_OD_MAX_ANCHORS_PER_HEAD  (16)

typedef struct {

  int32_t  numAnchors;
  int32_t  numKeyPoints;
  int32_t headWidth;
  int32_t headHeight;
  float32_tidl strideW;
  float32_tidl strideH;
  float32_tidl offsetW;
  float32_tidl offsetH;
  float32_tidl boxScales[4];
  float32_tidl kpScales[TIDL_OD_MAX_KEYPOINTS];
  float32_tidl boxWidth[TIDL_OD_MAX_ANCHORS_PER_HEAD];
  float32_tidl boxHeight[TIDL_OD_MAX_ANCHORS_PER_HEAD];
  float32_tidl * anchorInputs;

}sTIDL_AnchorBoxParams_t;

typedef struct {
  int32_t  axis;
  int32_t  outDataQ;
}sTIDL_ConcatParams_t;


typedef struct {
  int32_t   weights;
  int32_t   bias;
  int32_t   numChannels;
  int32_t   biasQ;
  int32_t   inDataQ;
  int32_t   outDataQ;
  int32_t   weightsQ;
  float32_tidl weightScale;
  float32_tidl biasScale;
  int32_t   zeroWeightValue;
}sTIDL_BatchNormParams_t;

typedef struct {
  int32_t   bias;
  int32_t   numChannels;
  int32_t   biasQ;
  int32_t   inDataQ;
  int32_t   outDataQ;
}sTIDL_BiasParams_t;

typedef struct {
  int32_t   weights;
  int32_t   bias;
  int32_t   activationType;
  int32_t   numInNodes;
  int32_t   numOutNodes;
  int32_t   weightsQ;
  float32_tidl     weightScale;
  float32_tidl     biasScale;
  int32_t   zeroWeightValue;
  int32_t   biasQ;
  int32_t   inDataQ;
  int32_t   outDataQ;
  int32_t   interDataQ;
  int32_t   biasB;
}sTIDL_InnerProductParams_t;

typedef struct {
  int32_t bias;
  int32_t numChannels;
  int32_t eltWiseType;
  int32_t numInData;
  int32_t biasQ;
  int32_t inDataQ[TIDL_NUM_IN_BUFS];
  int32_t outDataQ;
}sTIDL_EltWiseParams_t;

typedef struct {
  int32_t   numChannels;
  int32_t   inDataQ;
  int32_t   outDataQ;
}sTIDL_SoftMaxParams_t;

typedef struct {
  int32_t   numChannels;
  int32_t   inDataQ;
  int32_t   outDataQ;
  int32_t       offsetW;
  int32_t       offsetH;
}sTIDL_CropParams_t;

/* CHECK_MISRA("-18.4")  -> Disable rule 18.4  */
typedef union {
  sTIDL_ConvParams_t              convParams;
  sTIDL_EltWiseParams_t           eltWiseParams;
  sTIDL_PoolingParams_t           poolParams;
  sTIDL_InnerProductParams_t      innerProductParams;
  sTIDL_DataLayerParams_t         dataLayerParams;
  sTIDL_ArgMaxParams_t            argMaxParams;
  sTIDL_SoftMaxParams_t           softMaxParams;
  sTIDL_CropParams_t              cropParams;
  sTIDL_ConcatParams_t            concatParams;
  sTIDL_DetectOutputParams_t      detectOutParams;
  sTIDL_BiasParams_t              biasParams;
  sTIDL_BatchNormParams_t         batchNormParams;
  sTIDL_ShuffleLayerParams_t      shuffleLayerParams ;
  sTIDL_SliceLayerParams_t        sliceParams;
  sTIDL_ResizeLayerParams_t       resizeParams;
  sTIDL_RoiPoolingLayerParams_t   roiPoolingParams;
  sTIDL_DepthToSpaceParams_t      depthToSpaceParams ;
  sTIDL_PadLayerParams_t          padLayerParams;
  sTIDL_TfODOutputLayerParams_t   tfODOutputLayerParams;
  sTIDL_CustomParams_t            customParams;
}sTIDL_LayerParams_t;
/*RESET_MISRA("18.4")  -> Reset rule 18.4 */

typedef struct {
  sTIDL_LayerParams_t layerParams;
  sTIDL_ActParams_t    actParams;
  int32_t layerType;
  int32_t numInBufs;
  int32_t numOutBufs;
  sTIDL_DataParams_t inData[TIDL_NUM_IN_BUFS];
  sTIDL_DataParams_t outData[TIDL_NUM_OUT_BUFS];
  int32_t coreID;
  int32_t layersGroupId;
  int32_t weightsElementSizeInBits;
  int32_t strideOffsetMethod;
}sTIDL_Layer_t;

/* Based on last Updated Date */
#define TIDL_NET_VERSION  (0x20210123)

typedef struct {
  int32_t netVersion;
  int32_t deviceName;
  int32_t numLayers;
  int32_t weightsElementSize;
  int32_t slopeElementSize;
  int32_t biasElementSize;
  int32_t dataElementSize;
  int32_t interElementSize;
  int32_t quantizationStyle;
  int32_t calibrationOption;
  sTIDL_CalibParams_t    calibrationParams;
  int32_t dataFlowInfo;
  int32_t isQuantStatsAvailable;
  int32_t reserved;
  sTIDL_Layer_t TIDLLayers[TIDL_NUM_MAX_LAYERS];
}sTIDL_Network_t;

typedef enum
{
  TIDL_inDataFormatBGRPlanar = 0,
  TIDL_inDataFormatRGBPlanar = 1,
  TIDL_inDataFormatRGBMax    = 2
}eTIDL_inDataFormat;

typedef enum
{
  TIDL_inYuvFormatYuv420_NV12  = 0,
  TIDL_inYuvFormatYuv422I_YUYV = 1,
  TIDL_inYuvFormatYuv422I_UYVY = 2,
  TIDL_inYuvFormatYuvMax       = 3
}eTIDL_inYuvFormat;

typedef enum
{
  TIDL_inResizeTypeDefault   = 0,
  TIDL_inResizeTypeKeepAR    = 1,
  TIDL_inResizeTypeMax       = 2
}eTIDL_inResizeType;

typedef struct
{
  int32_t numInputBuf;
  int32_t numOutputBuf;
  int32_t inDataFormat[TIDL_MAX_ALG_IN_BUFS];
  int32_t inResizeType[TIDL_MAX_ALG_IN_BUFS];
  int32_t resizeWidth[TIDL_MAX_ALG_IN_BUFS];
  int32_t resizeHeight[TIDL_MAX_ALG_IN_BUFS];
  int32_t inWidth[TIDL_MAX_ALG_IN_BUFS];
  int32_t inHeight[TIDL_MAX_ALG_IN_BUFS];
  int32_t inNumChannels[TIDL_MAX_ALG_IN_BUFS];
  int32_t inChannelPitch[TIDL_MAX_ALG_IN_BUFS];
  int32_t inPadL[TIDL_MAX_ALG_IN_BUFS];
  int32_t inPadT[TIDL_MAX_ALG_IN_BUFS];
  int32_t inPadR[TIDL_MAX_ALG_IN_BUFS];
  int32_t inPadB[TIDL_MAX_ALG_IN_BUFS];
  int32_t inPadCh[TIDL_MAX_ALG_IN_BUFS];
  int32_t inElementType[TIDL_MAX_ALG_IN_BUFS];
  int32_t rawDataInElementType[TIDL_MAX_ALG_IN_BUFS];
  int32_t inDataId[TIDL_MAX_ALG_IN_BUFS];
  float32_tidl inTensorScale[TIDL_MAX_ALG_IN_BUFS];
  int8_t inDataName[TIDL_MAX_ALG_IN_BUFS][TIDL_STRING_SIZE];
  int32_t outWidth[TIDL_MAX_ALG_OUT_BUFS];
  int32_t outHeight[TIDL_MAX_ALG_OUT_BUFS];
  int32_t outNumChannels[TIDL_MAX_ALG_OUT_BUFS];
  int32_t outChannelPitch[TIDL_MAX_ALG_OUT_BUFS];
  int32_t outPadL[TIDL_MAX_ALG_OUT_BUFS];
  int32_t outPadT[TIDL_MAX_ALG_OUT_BUFS];
  int32_t outPadR[TIDL_MAX_ALG_OUT_BUFS];
  int32_t outPadB[TIDL_MAX_ALG_OUT_BUFS];
  int32_t outPadCh[TIDL_MAX_ALG_OUT_BUFS];
  int32_t outElementType[TIDL_MAX_ALG_OUT_BUFS];
  int32_t outDataId[TIDL_MAX_ALG_OUT_BUFS];
  int8_t outDataName[TIDL_MAX_ALG_OUT_BUFS][TIDL_STRING_SIZE];
} sTIDL_IOBufDesc_t;

#if USE_IVISION

typedef struct
{
  IVISION_Params visionParams;
  int32_t currLayersGroupId;
  int32_t isInbufsPaded;
  int32_t optimiseExtMem;
  float32_tidl quantRangeExpansionFactor;

  float32_tidl quantRangeUpdateFactor;
  int32_t traceLogLevel;
  int32_t traceWriteLevel;
  int32_t reservedCtrl;
  int32_t flowCtrl;
  void * traceBaseName;
  /* Note : All the addresses given to TIDL are assumed to be virtual addresses.
  If udma driver is initialized with virtual to physical function pointer initPrms.virtToPhyFxn
  then the same function will be used for this conversion in TIDL whereever it is needed.*/
  void * udmaDrvObj;
  sTIDL_Network_t * net;
  int32_t(*TIDLVprintf)(const char * format, va_list arg);
  int32_t(*TIDLWriteBinToFile)(const char * fileName, void * addr, int32_t size);
  int32_t(*TIDLReadBinFromFile)(const char * fileName, void * addr, int32_t size);
  int32_t (*TIDL_CustomLayerProcess)(void * tidlHandle,
                                sTIDL_Layer_t *tidlLayer,
                                void *inPtrs[],
                                void *outPtrs[],
                                void *params,
                                void *dmaUtilsContext,
                                const sTIDL_sysMemHandle_t sysMems[TIDL_SYSMEM_MAX],
                                int32_t execMode,
                                float maxTensorScale);
}
TIDL_CreateParams;

typedef struct
{
  IVISION_InArgs iVisionInArgs;
  int32_t numInBufs;
  float32_tidl scale[TIDL_NUM_IN_BUFS];
  int32_t enableLayerPerfTraces;
} TIDL_InArgs;

typedef struct
{
  IVISION_OutArgs iVisionOutArgs;
  int32_t numOutBufs;
  float32_tidl scale[TIDL_NUM_OUT_BUFS];

} TIDL_outArgs;

typedef struct
{
  float32_tidl numDetObjects;
  float32_tidl objInfoSize;
  float32_tidl odNumKeyPoints;
  float32_tidl objInfoOffset;

} TIDL_ODLayerHeaderInfo;


typedef struct
{
  float32_tidl x;
  float32_tidl y;

} TIDL_ODLayerKeyPoint;

#define TIDL_OD_MAX_KEY_POINTS     (8)


typedef struct
{
  float32_tidl ObjId;
  float32_tidl label;
  float32_tidl score;
  float32_tidl xmin;
  float32_tidl ymin;
  float32_tidl xmax;
  float32_tidl ymax;
  TIDL_ODLayerKeyPoint keyPoints[TIDL_OD_MAX_KEY_POINTS];

} TIDL_ODLayerObjInfo;

static inline int TIDL_createParamsInit(TIDL_CreateParams * params)
{
  params->net                       = NULL;
  params->udmaDrvObj                = NULL;
  params->currLayersGroupId         = 1;
  params->isInbufsPaded             = 0;
  params->optimiseExtMem            = TIDL_OptimiseExtMemL1;
  params->quantRangeExpansionFactor = 1.0;
  params->quantRangeUpdateFactor    = -1.0;
  params->visionParams.algParams.size = sizeof(TIDL_CreateParams);
  params->visionParams.cacheWriteBack = NULL;
  params->TIDLWriteBinToFile         = NULL;
  params->TIDLReadBinFromFile        = NULL;
  params->TIDLVprintf                = NULL;
  params->traceLogLevel              = 0;
  params->traceWriteLevel            = 0;
  params->traceBaseName            = NULL;
  params->reservedCtrl             = 0;
#if defined(x86_64) || (HOST_EMULATION)
  params->flowCtrl                 = 1;
#else
  params->flowCtrl                 = 0;
#endif

  return IALG_EOK;
}

#endif

#ifdef __cplusplus
}
#endif

/* iTI_DL */

#endif /*ITIDL_H_ */
/*==========================================================================*/
/*     END of the FILE                                                      */
/*==========================================================================*/