enums.py

#
# Copyright (c) 2017-2019 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.
#
#

from enum import Enum
from . import *



class Type(Enum):
    
    INVALID = 1
    
    CHAR    = 2
    
    INT8    = 3
    
    UINT8   = 4
    
    INT16   = 5
    
    UINT16  = 6
    
    INT32   = 7
    
    UINT32  = 8
    
    INT64   = 9
    
    UINT64  = 10
    
    FLOAT32 = 11
    
    FLOAT64 = 12
    
    ENUM    = 13
    
    SIZE    = 14
    
    DF_IMAGE= 15
    
    BOOL    = 16
    
    REFERENCE    = 17
    
    CONTEXT      = 18
    
    GRAPH        = 19
    
    NODE         = 20
    
    KERNEL       = 21
    
    PARAMETER    = 22
    
    DELAY        = 23
    
    LUT          = 24
    
    DISTRIBUTION = 25
    
    PYRAMID      = 26
    
    THRESHOLD    = 27
    
    MATRIX       = 28
    
    CONVOLUTION  = 29
    
    SCALAR       = 30
    
    ARRAY        = 31
    
    IMAGE        = 32
    
    REMAP        = 33
    
    ERROR        = 34
    
    META_FORMAT  = 35
    
    OBJECT_ARRAY = 36
    
    RECTANGLE     = 37
    
    KEYPOINT     = 38
    
    COORDINATES2D = 39
    
    COORDINATES3D = 40
    
    USER_DATA_OBJECT = 41
    
    RAW_IMAGE = 42
    
    TENSOR = 43
    
    NULL = 44

    def __lt__(self, other):
        if self.__class__ is other.__class__:
            return self.value < other.value
        return NotImplemented

    def __gt__(self, other):
        if self.__class__ is other.__class__:
            return self.value > other.value
        return NotImplemented

    def __eq__(self, other):
        if self.__class__ is other.__class__:
            return self.value == other.value
        return NotImplemented

    def get_vx_enum_name(type) :
        if type == Type.NULL :
            return NULL
        elif type == Type.RAW_IMAGE :
            return "TIVX_TYPE_" + type.name
        else :
            return "VX_TYPE_" + type.name

    def get_vx_name(type) :
        if type == Type.RAW_IMAGE :
            return "tivx_" + type.name.lower()
        else :
            return "vx_" + type.name.lower()

    def is_scalar_type(type) :
        if type > Type.INVALID and type < Type.REFERENCE :
            return True
        if type == Type.SCALAR :
            return True
        return False

    def is_array_type(type) :
        if type > Type.INVALID and type < Type.REFERENCE :
            return True
        if type == Type.RECTANGLE :
            return True
        if type == Type.KEYPOINT :
            return True
        if type == Type.COORDINATES2D :
            return True
        if type == Type.COORDINATES3D :
            return True
        return False

    def get_obj_desc_name(type):
        if Type.is_scalar_type(type) :
            type = Type.SCALAR
        return "tivx_obj_desc_" + type.name.lower() +  "_t"

    def get_scalar_obj_desc_data_name(type) :
        if Type.is_scalar_type(type) :
            if type is Type.CHAR :
                return "chr"
            if type is Type.INT8 :
                return "s08"
            if type is Type.UINT8 :
                return "u08"
            if type is Type.INT16:
                return "s16"
            if type is Type.UINT16:
                return "u16"
            if type is Type.INT32:
                return "s32"
            if type is Type.UINT32:
                return "u32"
            if type is Type.INT64:
                return "s64"
            if type is Type.UINT64:
                return "u64"
            if type is Type.FLOAT32:
                return "f32"
            if type is Type.FLOAT64:
                return "f64"
            if type is Type.ENUM :
                return "enm"
            if type is Type.SIZE :
                return "size"
            if type is Type.DF_IMAGE:
                return "fcc"
            if type is Type.BOOL :
                return "boolean"
            return "invalid"
        return "invalid"


class DfImage(Enum) :
    
    INVALID = 0
    
    VIRT = 1
    
    RGB  = 2
    
    RGBX = 3
    
    NV12 = 4
    
    NV21 = 5
    
    UYVY = 6
    
    YUYV = 7
    
    IYUV = 8
    
    YUV4 = 9
    
    U8   = 10
    
    U16  = 11
    
    S16  = 12
    
    U32  = 13
    
    S32  = 14
    
    P12  = 15
    
    NV12_P12  = 16
    
    RGB565 = 17
    
    BGRX = 18

    def get_vx_enum_name(df_format) :
        if df_format == DfImage.P12 or df_format == DfImage.NV12_P12 or df_format == DfImage.RGB565 or df_format == DfImage.BGRX :
            return "TIVX_DF_IMAGE_" + df_format.name
        else :
            return "VX_DF_IMAGE_" + df_format.name

    def get_vx_name(df_format) :
        if df_format == DfImage.P12 or df_format == DfImage.NV12_P12 or df_format == DfImage.RGB565 or df_format == DfImage.BGRX :
            return "tivx_df_image_e"
        else :
            return "vx_df_image_e"

    def get_df_enum_from_string(full_df_name) :
        index = full_df_name.find("VX_DF_IMAGE_")
        if index == 0 :
            newstr = full_df_name.replace("VX_DF_IMAGE_", "")
            if newstr in DfImage.__members__ :
                return DfImage[newstr]
        elif index == 2 :
            newstr = full_df_name.replace("TIVX_DF_IMAGE_", "")
            if newstr in DfImage.__members__ :
                return DfImage[newstr]
        return DfImage.INVALID

    def get_num_planes(df_format) :
        if df_format == DfImage.NV12 or df_format == DfImage.NV21 or df_format == DfImage.NV12_P12 :
            return 2
        if df_format == DfImage.IYUV or df_format == DfImage.YUV4 :
            return 3
        return 1


class Channel(Enum) :
    
    C0 = 1
    
    C1 = 2
    
    C2 = 3
    
    C3 = 4
    
    R  = 5
    
    G  = 6
    
    B  = 7
    
    A  = 8
    
    Y  = 9
    
    U  = 10
    
    V  = 11

    def get_vx_enum_name(type) :
        if type == Channel.C0 :
            return "VX_CHANNEL_0"
        if type == Channel.C1 :
            return "VX_CHANNEL_1"
        if type == Channel.C2 :
            return "VX_CHANNEL_2"
        if type == Channel.C3 :
            return "VX_CHANNEL_3"
        return "VX_CHANNEL_" + type.name

    def get_vx_name(type) :
        return "vx_channel_e"

class Cpu(Enum) :
    INVALID  = 1
    DSP1     = 2
    DSP2     = 3
    EVE1     = 4
    EVE2     = 5
    EVE3     = 6
    EVE4     = 7
    A15_0    = 8
    IPU1_0   = 9
    IPU1_1   = 10
    IPU2     = 11
    DSP_C7_1 = 12
    A72_0    = 13

    def get_vx_enum_name(type) :
        if type.name == "IPU2" :
            return "TIVX_CPU_ID_IPU2_0"
        else :
            return "TIVX_CPU_ID_" + type.name



class Target(Enum) :
    
    INVALID = 1
    
    DSP1    = 2
    
    DSP2    = 3
    
    EVE1    = 4
    
    EVE2    = 5
    
    EVE3    = 6
    
    EVE4    = 7
    
    A15_0   = 8
    
    IPU1_0  = 9
    
    IPU1_1  = 10
    
    IPU2    = 11
    
    VPAC_NF      = 12
    
    VPAC_LDC1    = 13
    
    VPAC_LDC2    = 14
    
    VPAC_MSC1    = 15
    
    VPAC_MSC2    = 16
    
    DMPAC_SDE    = 17
    
    DMPAC_DOF    = 18
    
    VPAC_VISS1   = 19
    
    VDEC1         = 20
    
    VDEC2         = 21
    
    VENC1         = 22
    
    VENC2         = 23
    
    DSP_C7_1     = 24
    
    A72_0        = 25
    
    DEFAULT = DSP1

    def get_vx_enum_name(type) :
        return "TIVX_TARGET_" + type.name

    def get_target_folder_name(type) :
        if target == Target.DSP1 :
            return c66
        if target == Target.DSP2 :
            return c66
        if target == Target.EVE1 :
            return eve
        if target == Target.EVE2 :
            return eve
        if target == Target.EVE3 :
            return eve
        if target == Target.EVE4 :
            return eve
        if target == Target.A15_0 :
            return a15
        if target == Target.IPU1_0 :
            return ipu
        if target == Target.IPU1_1 :
            return ipu
        if target == Target.IPU2 :
            return ipu
        if target == Target.VPAC_NF :
            return "vpac_nf"
        if target == Target.VPAC_LDC1 :
            return "vpac_ldc"
        if target == Target.VPAC_LDC2 :
            return "vpac_ldc"
        if target == Target.VPAC_MSC1 :
            return "vpac_msc"
        if target == Target.VPAC_MSC2 :
            return "vpac_msc"
        if target == Target.DMPAC_SDE :
            return "dmpac_sde"
        if target == Target.DMPAC_DOF :
            return "dmpac_sde"
        if target == Target.VPAC_VISS1 :
            return "vpac_viss"
        if target == Target.VDEC1 :
            return "vdec"
        if target == Target.VDEC2 :
            return "vdec"
        if target == Target.VENC1 :
            return "venc"
        if target == Target.VENC2 :
            return "venc"
        if target == Target.DSP_C7_1 :
            return "c7x"
        if target == Target.A72_0 :
            return "a72"
        return None

    def is_j6_target(target) :
        if target == Target.DSP1 :
            return True
        if target == Target.DSP2 :
            return True
        if target == Target.EVE1 :
            return True
        if target == Target.EVE2 :
            return True
        if target == Target.EVE3 :
            return True
        if target == Target.EVE4 :
            return True
        if target == Target.A15_0 :
            return True
        if target == Target.IPU1_0 :
            return True
        if target == Target.IPU1_1 :
            return True
        if target == Target.IPU2 :
            return True

        return False

    def get_cpu(target) :
        if target == Target.DSP1 :
            return Cpu.DSP1
        if target == Target.DSP2 :
            return Cpu.DSP2
        if target == Target.EVE1 :
            return Cpu.EVE1
        if target == Target.EVE2 :
            return Cpu.EVE2
        if target == Target.EVE3 :
            return Cpu.EVE3
        if target == Target.EVE4 :
            return Cpu.EVE4
        if target == Target.A15_0 :
            return Cpu.A15_0
        if target == Target.IPU1_0 :
            return Cpu.IPU1_0
        if target == Target.IPU1_1 :
            return Cpu.IPU1_1
        if target == Target.IPU2 :
            return Cpu.IPU2
        if target == Target.VPAC_NF :
            return Cpu.IPU1_0
        if target == Target.VPAC_LDC1 :
            return Cpu.IPU1_0
        if target == Target.VPAC_LDC2 :
            return Cpu.IPU1_0
        if target == Target.VPAC_MSC1 :
            return Cpu.IPU1_0
        if target == Target.VPAC_MSC2 :
            return Cpu.IPU1_0
        if target == Target.DMPAC_SDE :
            return Cpu.IPU1_0
        if target == Target.DMPAC_DOF :
            return Cpu.IPU1_0
        if target == Target.VPAC_VISS1 :
            return Cpu.IPU1_0
        if target == Target.VDEC1 :
            return Cpu.IPU1_0
        if target == Target.VDEC2 :
            return Cpu.IPU1_0
        if target == Target.VENC1 :
            return Cpu.IPU1_0
        if target == Target.VENC2 :
            return Cpu.IPU1_0
        if target == Target.DSP_C7_1 :
            return Cpu.DSP_C7_1
        if target == Target.A72_0 :
            return Cpu.A72_0
        return Cpu.INVALID


class Policy(Enum) :
    
    WRAP      = 1
    
    SATURATE  = 2

    def get_vx_enum_name(type) :
        return "VX_CONVERT_POLICY_" + type.name

    def get_vx_name(type) :
        return "vx_convert_policy_e"


class Round(Enum) :
    
    TO_ZERO          = 1
    
    TO_NEAREST_EVEN  = 2

    def get_vx_enum_name(type) :
        return "VX_ROUND_POLICY_" + type.name

    def get_vx_name(type) :
        return "vx_round_policy_e"


class NonLinearFilter(Enum) :
    
    MEDIAN   = 1
    
    MIN      = 2
    
    MAX      = 3

    def get_vx_enum_name(type) :
        return "VX_NONLINEAR_FILTER_" + type.name

    def get_vx_name(type) :
        return "vx_non_linear_filter_e"


class Pattern(Enum) :
    
    BOX      = 1
    
    CROSS    = 2
    
    DISK     = 3
    
    OTHER    = 4

    def get_vx_enum_name(type) :
        return "VX_PATTERN_" + type.name

    def get_vx_name(type) :
        return "vx_pattern_e"


class InterpolationType(Enum) :
    
    NEAREST_NEIGHBOR    = 1
    
    BILINEAR            = 2
    
    AREA                = 3

    def get_vx_enum_name(type) :
        return "VX_INTERPOLATION_" + type.name

    def get_vx_name(type) :
        return "vx_interpolation_type_e"


class Bool(Enum) :
    
    FALSE           = 0
    
    TRUE            = 1

    def get_vx_enum_name(type) :
        return "vx_" + type.name.lower() + "_e"

    def get_vx_name(type) :
        return "vx_bool"


class Norm(Enum):
    
    L1 = 1
    
    L2 = 2

    def get_vx_enum_name(type) :
        return "VX_NORM_" + type.name

    def get_vx_name(type) :
        return "vx_norm_e"


class Direction(Enum):
    
    INPUT = 1
    
    OUTPUT = 2
    
    BIDIRECTIONAL = 3

    def get_vx_enum_name(type) :
        return "VX_" + type.name

    def get_vx_name(type) :
        return "vx_direction_e"

    def get_access_type(type) :
        if type == Direction.INPUT:
            return "VX_READ_ONLY"
        if type == Direction.OUTPUT:
            return "VX_WRITE_ONLY"
        if type == Direction.BIDIRECTIONAL:
            return "VX_READ_WRITE"
        return "INVALID"

    def get_doxygen_name(type) :
        if type == Direction.INPUT:
            return "in"
        if type == Direction.OUTPUT:
            return "out"
        if type == Direction.BIDIRECTIONAL:
            return "in,out"
        return "INVALID"



class ParamState(Enum):
    
    REQUIRED = 1
    
    OPTIONAL = 2

    def get_vx_enum_name(type) :
        return "VX_PARAMETER_STATE_" + type.name

    def get_vx_name(type) :
        return "vx_parameter_state_e"


class PyramidScale(Enum):
    
    HALF = 1
    
    ORB = 2

    def get_vx_enum_name(type) :
        return "VX_SCALE_PYRAMID_" + type.name


class ThresholdType(Enum):
    
    BINARY = 1
    
    RANGE = 2

    def get_vx_enum_name(type) :
        return "VX_THRESHOLD_TYPE_" + type.name

    def get_vx_name(type) :
        return "vx_threshold_type_e"


class TermCriteria(Enum):
    
    ITERATIONS = 1
    
    EPSILON = 2
    
    BOTH = 3

    def get_vx_enum_name(type) :
        return "VX_TERM_CRITERIA_" + type.name

    def get_vx_name(type) :
        return "vx_termination_criteria_e"