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>
#include <float.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) 24)
#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)

#define TIDL_MAX_PRIORITY_LEVEL    ((int32_t) 8)
#define TIDL_MAX_OBJECTS_PER_LEVEL ((int32_t) 16)

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

typedef int32_t (*TIDL_Lock_t) (void) ;
typedef void (*TIDL_Unlock_t) (int32_t);

#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_OdOutputReformatLayer     ((int32_t) 28)
#define TIDL_DataConvertLayer          ((int32_t) 29)
#define TIDL_CustomLayer               ((int32_t) 30)
#define TIDL_BatchReshapeLayer         ((int32_t) 31)
#define TIDL_ReduceLayer               ((int32_t) 32)
#define TIDL_ScatterElementsLayer      ((int32_t) 33)
#define TIDL_SqueezeLayer              ((int32_t) 34)
#define TIDL_TanhLayer                 ((int32_t) 35)
#define TIDL_HardSigmoidLayer          ((int32_t) 36)
#define TIDL_ELULayer                  ((int32_t) 37)
#define TIDL_ReshapeLayer              ((int32_t) 38)
#define TIDL_ConstDataLayer            ((int32_t) 39)
#define TIDL_UnsupportedLayer          ((int32_t) 40)
/* @} */

#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_UnsignedDoubleWord    ((int32_t) 7)
#define TIDL_SignedDoubleWord      ((int32_t) 8)
/* @} */

#define TIDL_LT_NCHW             ((uint32_t) 0)
#define TIDL_LT_NHWC             ((uint32_t) 1)
#define TIDL_LT_MAX              (TIDLRT_LT_NHWC+1)
/* @} */


#define TIDL_DC_TYPE_INPUT       ((uint32_t) 0)
#define TIDL_DC_TYPE_OUTPUT      ((uint32_t) 1)
#define TIDL_DC_TYPE_INTERMEDIATE      ((uint32_t) 2)
#define TIDL_DC_TYPE_MAX              (TIDL_DC_TYPE_INTERMEDIATE+1)
/* @} */


#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_QuantStyleNonP2

#define TIDL_QuantStyleAsymNP2_TFL   ((int32_t) 5)

#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_CalibOptionBiasRange ((int32_t) 64)

/* @} */

#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_Tanh                  ((int32_t) 6)
#define TIDL_HardSigmoid           ((int32_t) 7)
#define TIDL_ELU                   ((int32_t) 8)
/* @} */

#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_E_INVALID_DDR_INFO_FROM_GC            ((int32_t) (TIDL_E_COMMON - 6))
#define TIDL_E_EXCEED_PREEMPTION_LEVEL             ((int32_t) (TIDL_E_COMMON - 7))
#define TIDL_E_EXCEED_OBJECTS_PER_LEVEL            ((int32_t) (TIDL_E_COMMON - 8))

/*Device specific error codes*/
#define TIDL_E_DEV_ERROR                            ((int32_t) -1120)
#define TIDL_E_OTF_ERROR                            ((int32_t) (TIDL_E_DEV_ERROR - 0))
#define TIDL_E_ASYM_ERROR                           ((int32_t) (TIDL_E_DEV_ERROR - 1))
/* @} */

#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_INFER_PROCESS          ((int32_t) 2)
#define TIDL_EXEC_MODE_INFER_PROCESS_REF      ((int32_t) 3)


#define TIDL_PROFILE_LAYER                      ((int32_t) 0)
#define TIDL_PROFILE_KERNEL_ONLY                ((int32_t) 1)
#define TIDL_PROFILE_CORE_LOOP                  ((int32_t) 2)
#define TIDL_PROFILE_LAYER_SETUP                ((int32_t) 3)
#define TIDL_PROFILE_PREFETCH                   ((int32_t) 4)
#define TIDL_PROFILE_DMA_PIPEUP                 ((int32_t) 5)
#define TIDL_PROFILE_LAYER_WITHOUT_PADDING      ((int32_t) 6)
#define TIDL_PROFILE_LAYER_PADDING_TRIGGER      ((int32_t) 7)
#define TIDL_PROFILE_LAYER_PADDING_WAIT         ((int32_t) 8)
#define TIDL_PROFILE_KERNEL_COPY                ((int32_t) 9)
#define TIDL_PROFILE_LAYER_SETUP_HANDLE_COPY    ((int32_t) 10)
#define TIDL_PROFILE_LAYER_DEINIT               ((int32_t) 11)
#define TIDL_PROFILE_LAST_BLOCK_CYCLES          ((int32_t) 12)
#define TIDL_PROFILE_DMA_PIPEDOWN               ((int32_t) 13)
#define TIDL_PROFILE_BACKUP                     ((int32_t) 14)
#define TIDL_PROFILE_RESTORE                    ((int32_t) 15)
#define TIDL_PROFILE_MAX                        ((int32_t) 16)

/* @} */

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

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

typedef sTIDL_sysMemHandle_t sTIDL_NetBuffer_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  tensorZeroPoint;
  int32_t padW;
  int32_t padH;
  int32_t batchPadW;
  int32_t batchPadH;
  int32_t numBatchW;
  int32_t numBatchH;
  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;  
  int32_t   perChannelPadConstTensorSize ;  
}sTIDL_PadLayerParams_t;

typedef struct {
  int32_t layerType;
  int32_t inWidthOdNetwork;
  int32_t inHeightOdNetwork;
}sTIDL_odOutputReformatLayerParams_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_DetectionBoxesTflite = 0,
  TIDL_DetectionClassesTflite,
  TIDL_DetectionScoresTflite,
  TIDL_NumDetectionsTflite,
  TIDL_DetectionBoxesSsd,
  TIDL_DetectionClassesSsd,
  TIDL_DetectionScoresSsd,
  TIDL_DetectionBoxesAndScoresMmdetection,
  TIDL_DetectionClassesMmdetection,
  TIDL_DetectionBoxesScoresLabelsYoloV5,
  TIDL_DetectionBoxesScoresLabelsTfliteEfficientdet,
  TIDL_Detection3dOd
}eTIDL_odOutputReformatType;

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 forceInPlace ;  
  int32_t doesLayerChangePadding;
  int32_t doesLayerFillOutXPadding;
  int32_t rsvdPassThrough;
  int32_t rsvdPassThroughSize;
}sTIDL_CustomParams_t;

typedef struct {
  int32_t   weights;
  int32_t   bias;
  int32_t   weightScales;
  int32_t   weightZeroPoints;
  int32_t   biasScales;
  int32_t   biasZeroPoints;
  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;
  int32_t   padL;
  int32_t   padR;
  int32_t   padT;
  int32_t   padB;
  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;
  int32_t minPSAT;
  int32_t maxPSAT;
  int32_t quantizationStyle;
}sTIDL_ConvParams_t;

typedef enum
{
  TIDL_metaArchCaffeJacinto = 0,
  TIDL_metaArchTFSSD = 1,
  TIDL_metaArchTFFasterRcnn = 2,
  TIDL_metaArchTIDLSSD = 3,
  TIDL_metaArchTIDLYolo= 4,
  TIDL_metaArchTIDLRetinaNet= 5,
  TIDL_metaArchTIDLYoloV5 = 6,
  TIDL_metaArchTIDL3DOD= 7,
  TIDL_metaArchMax = 8
}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
{
  float32_tidl  fX;
  float32_tidl  fY;
  float32_tidl  pX;
  float32_tidl  pY;

} sTIDL_CameraIntrinsicsParams_t;

/* CHECK_MISRA("-18.4")  -> Disable rule 18.4  */

typedef union {
  sTIDL_CameraIntrinsicsParams_t        cameraParams;
} sTIDL_DetectionLayerSubCodeParams_t;


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  topKAllClasses;
  int32_t  keepTopK;
  int32_t  shareLocation;
  int32_t  varianceEncoded;
  int32_t  numKeypoints;
  int32_t  keypointConfidence;
  int32_t  subCodeType;
   sTIDL_DetectionLayerSubCodeParams_t subCodeParams;

  int32_t  numHeads;

  int32_t  numSubHeads;

  int32_t imWidth;

  int32_t imHeight;

  float32_tidl point3dRange[3][2];

  float32_tidl voxelSize[3];

  int32_t maxPointsPerVoxel;

  /*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;  //Layer Params


typedef enum
{
  TIDL_Invalid = 0,  //sTIDL_DetectOutputParams_t.subCodeParams are not populated and used.
  TIDL_ObjectPose = 1, //sTIDL_DetectOutputParams_t.subCodeParams are used for objectPose processing.
} eTIDL_SubCodeType;


#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 strideL;
  float32_tidl offsetW;
  float32_tidl offsetH;
  float32_tidl offsetL;
  float32_tidl offsetDir;
  float32_tidl boxScales[4];
  float32_tidl kpScales[TIDL_OD_MAX_KEYPOINTS];
  float32_tidl boxLength[TIDL_OD_MAX_ANCHORS_PER_HEAD];
  float32_tidl boxWidth[TIDL_OD_MAX_ANCHORS_PER_HEAD];
  float32_tidl boxHeight[TIDL_OD_MAX_ANCHORS_PER_HEAD];
  float32_tidl boxAngle[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;
  /*Asymmetric Parameters*/
  uint8_t mmaScale;
  uint8_t mmaShift;
  int32_t biasTerm;
}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;


typedef struct {
  int32_t type;
  int32_t layout;
  int32_t inZeroPoint;
  int32_t outZeroPoint;
}sTIDL_dataConvertParams_t;

typedef struct {
  int32_t   axis;
  /*keep the dimension or squeeze the dimension*/
  int32_t   keepDims;
  /*which operation to happen as per @ref eTIDL_inReduceOp*/
  int32_t   ops;
}sTIDL_ReduceParams_t;

typedef struct {
  int32_t   axis;
  int8_t    dataTensorName[TIDL_STRING_SIZE];
  int8_t    indicesTensorName[TIDL_STRING_SIZE];
  int8_t    updateTensorName[TIDL_STRING_SIZE];
}sTIDL_ScatterElementsParams_t;

typedef struct {
  /*Offset for data parameter*/
  int32_t offset; 
  float32_tidl weightScale;
}sTIDL_ConstDataParams_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_odOutputReformatLayerParams_t   odOutputReformatLayerParams;
  sTIDL_dataConvertParams_t             dataConvertParams;
  sTIDL_CustomParams_t                  customParams;
  sTIDL_ReduceParams_t                  reduceParams;
  sTIDL_ScatterElementsParams_t         scatterElementsParams;
  sTIDL_ConstDataParams_t               constDataParams;
}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;
  int32_t inData[TIDL_NUM_IN_BUFS];
  sTIDL_DataParams_t outData;
  sTIDL_DataParams_t * inDataPtr;
  int32_t coreID;
  int32_t layersGroupId;
  int32_t weightsElementSizeInBits;
  int32_t strideOffsetMethod;
}sTIDL_Layer_t;

#define TIDL_NET_STRUCTURE_BUF ((uint32_t) 0)
#define TIDL_NET_PARAMS_BUF    ((uint32_t) 1)
#define TIDL_NET_COMPILER_BUF  ((uint32_t) 2)
#define TIDL_NET_TOTAL_BUF     ((uint32_t) 3)
/* @} */

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

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;
  float32_tidl preEmptWorstCaseDelay;
  int32_t reserved;
  int32_t modelGroupId;
  sTIDL_NetBuffer_t netBufInfo[TIDL_NET_TOTAL_BUF];

  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 enum
{
  TIDL_inReduceOpMax       = 0,
  TIDL_inReduceOpMin       = 1
}eTIDL_inReduceOp;

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 inNumBatches[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 rawDataInElementType[TIDL_MAX_ALG_IN_BUFS];
  int32_t inElementType[TIDL_MAX_ALG_IN_BUFS];
  int32_t inZeroPoint[TIDL_MAX_ALG_IN_BUFS];
  int32_t inLayout[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 outNumBatches[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];
  float32_tidl outTensorScale[TIDL_MAX_ALG_OUT_BUFS];
  int32_t outZeroPoint[TIDL_MAX_ALG_OUT_BUFS];
  int32_t outLayout[TIDL_MAX_ALG_OUT_BUFS];

} sTIDL_IOBufDesc_t;


typedef enum
{
  TIDL_Detect2DBox = 0,  //Bit position in TIDL_ODLayerHeaderInfo.odObjectType for 2Dbox
  TIDL_Detect3DBox = 1,  //Bit position in TIDL_ODLayerHeaderInfo.odObjectType for 3Dbox
  TIDL_DetectKeyPoints = 2, //Bit position in TIDL_ODLayerHeaderInfo.odObjectType for keypoints
  TIDL_DetectObjectPose = 3, //Bit position in TIDL_ODLayerHeaderInfo.odObjectType for objectPose
} eTIDL_DetectionOutputFormat;

static inline int32_t TIDL_SetObjDetectionFormat( int32_t* odObjectType,
  int32_t odObjectFormat){
    *odObjectType = *odObjectType | ( 1 << odObjectFormat) ;
    return  *odObjectType;
  }
static inline int32_t TIDL_GetObjDetectionFormatState(int32_t odObjectType,
  int32_t odObjectFormat){
    int32_t odObjectFormatState;
    odObjectFormatState = odObjectType & ( 1 << odObjectFormat) ;
    return odObjectFormatState;
  }

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

} TIDL_ODLayerHeaderInfo;

typedef struct
{
  float32_tidl x;
  float32_tidl y;
  float32_tidl kpt_confidence;

} TIDL_ODLayerKeyPoint;

#define TIDL_OD_MAX_KEY_POINTS     (32)


typedef struct
{
  float32_tidl r11;
  float32_tidl r21;
  float32_tidl r31;
  float32_tidl r12;
  float32_tidl r22;
  float32_tidl r32;
  float32_tidl tx;
  float32_tidl ty;
  float32_tidl tz;

} TIDL_ODLayerObjectPose;

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;

typedef struct
{
  float32_tidl ObjId;
  float32_tidl label;
  float32_tidl score;
  float32_tidl x;
  float32_tidl y;
  float32_tidl z;
  float32_tidl w;
  float32_tidl l;
  float32_tidl h;
  float32_tidl yaw;
} TIDL_3DODLayerObjInfo;

#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;
  float32_tidl maxPreEmptDelay;
  void * traceBaseName;
  void * udmaDrvObj;
  sTIDL_Network_t * net;

  uint32_t targetPriority ;
  
  TIDL_Lock_t pFxnLock;
  TIDL_Unlock_t pFxnUnLock;
  int32_t(*TIDLVprintf)(const char * format, va_list arg);
  void *tracePtr;
  int32_t(*TIDLWriteBinToFile)(const char * fileName, void * addr, int32_t size, void *tracePtr);
  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);
}
TIDL_CreateParams;

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

typedef struct {
  int32_t totalOps;
  int32_t actualOps;
  int32_t layerExecId;
  uint64_t profilePoint[TIDL_PROFILE_MAX];
}TIDL_LayerMetaData;

typedef struct
{
  IVISION_OutArgs iVisionOutArgs;
  int32_t numOutBufs;
  float32_tidl scale[TIDL_NUM_OUT_BUFS];
  int32_t numLayers ;
  /* Private arguments - For debug and internal use */
  void *privArgs ;
  TIDL_LayerMetaData metaDataLayer[TIDL_NUM_MAX_LAYERS];

} TIDL_outArgs;

static inline float32_tidl TIDL_getWorstcaseDelayForPreemption(sTIDL_Network_t * net)
{
  return net->preEmptWorstCaseDelay;
}

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->maxPreEmptDelay           = FLT_MAX;
  params->visionParams.algParams.size = sizeof(TIDL_CreateParams);
  params->visionParams.cacheWriteBack = NULL;
  params->TIDLWriteBinToFile         = NULL;
  params->TIDLReadBinFromFile        = NULL;
  params->TIDLVprintf                = NULL;
  params->pFxnLock                   = NULL;
  params->pFxnUnLock                 = NULL;
  params->traceLogLevel              = 0;
  params->traceWriteLevel            = 0;
  params->traceBaseName            = NULL;
  params->tracePtr                 = NULL;
  params->reservedCtrl             = 0;
#if defined(x86_64) || defined(HOST_EMULATION)
  params->flowCtrl                 = 1;
#else
  params->flowCtrl                 = 0;
#endif
  params->targetPriority           = 0;
  return IALG_EOK;
}

#endif

#ifdef __cplusplus
}
#endif

/* iTI_DL */

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