nvmedia_tensor.h

Go to the documentation of this file.

/*
 * Copyright (c) 2017 - 2019, NVIDIA CORPORATION.  All rights reserved.  All
 * information contained herein is proprietary and confidential to NVIDIA
 * Corporation.  Any use, reproduction, or disclosure without the written
 * permission of NVIDIA Corporation is prohibited.
 */

#ifndef NVMEDIA_TENSOR_H
#define NVMEDIA_TENSOR_H

#ifdef __cplusplus
extern "C" {
#endif

#include "nvmedia_core.h"
#include "nvmedia_tensormetadata.h"

#define NVMEDIA_TENSOR_VERSION_MAJOR   (1u)

#define NVMEDIA_TENSOR_VERSION_MINOR   (3u)

#define NVMEDIA_TENSOR_TIMEOUT_INFINITE       (0xFFFFFFFFu)

typedef struct {
    NvMediaStatus status;
    uint32_t durationUs;
} NvMediaTensorTaskStatus;

typedef struct NvMediaTensor NvMediaTensor;

typedef enum {
    NVM_TENSOR_ATTR_DATA_TYPE = 0,
    NVM_TENSOR_ATTR_BITS_PER_ELEMENT,
    NVM_TENSOR_ATTR_DIMENSION_ORDER,
    NVM_TENSOR_ATTR_CPU_ACCESS,
    NVM_TENSOR_ATTR_ALLOC_TYPE,
    NVM_TENSOR_ATTR_4D_N,
    NVM_TENSOR_ATTR_4D_C,
    NVM_TENSOR_ATTR_4D_H,
    NVM_TENSOR_ATTR_4D_W,
    NVM_TENSOR_ATTR_4D_X,

    NVM_TENSOR_ATTR_MAX,

} NvMediaTensorAttrType;




#define NVM_TENSOR_ATTR_CPU_ACCESS_UNCACHED                 (0x00000001u)

#define NVM_TENSOR_ATTR_CPU_ACCESS_CACHED                   (0x00000002u)

#define NVM_TENSOR_ATTR_CPU_ACCESS_UNMAPPED                 (0x00000003u)

#define NVM_TENSOR_ATTR_ALLOC_RESERVED                      (0x00000010u)

#define NVM_TENSOR_ATTR_ALLOC_NONE                          (0x00000000u)

typedef struct {
    NvMediaTensorAttrType type;
    uint32_t value;
} NvMediaTensorAttr;


#define NVM_TENSOR_INIT_ATTR(x)                                                       \
{                                                                                     \
                                                                                      \
        x[0].type  = NVM_TENSOR_ATTR_DATA_TYPE;                                       \
        x[0].value = 0;                                                               \
                                                                                      \
        x[1].type  = NVM_TENSOR_ATTR_4D_N;                                            \
        x[1].value = 0;                                                               \
                                                                                      \
        x[2].type  = NVM_TENSOR_ATTR_4D_C;                                            \
        x[2].value = 0;                                                               \
                                                                                      \
        x[3].type  = NVM_TENSOR_ATTR_4D_H;                                            \
        x[3].value = 0;                                                               \
                                                                                      \
        x[4].type  = NVM_TENSOR_ATTR_4D_W;                                            \
        x[4].value = 0;                                                               \
                                                                                      \
        x[5].type  = NVM_TENSOR_ATTR_4D_X;                                            \
        x[5].value = 0;                                                               \
                                                                                      \
        x[6].type  = NVM_TENSOR_ATTR_BITS_PER_ELEMENT;                                \
        x[6].value = 0;                                                               \
                                                                                      \
        x[7].type  = NVM_TENSOR_ATTR_DIMENSION_ORDER;                                 \
        x[7].value = 0;                                                               \
                                                                                      \
        x[8].type  = NVM_TENSOR_ATTR_CPU_ACCESS;                                      \
        x[8].value = 0;                                                               \
                                                                                      \
        x[9].type  = NVM_TENSOR_ATTR_ALLOC_TYPE;                                      \
        x[9].value = 0;                                                               \
}

#define NVM_TENSOR_DEFINE_ATTR(x)                                                     \
    NvMediaTensorAttr x[NVM_TENSOR_ATTR_MAX];                                         \
    NVM_TENSOR_INIT_ATTR(x);                                                          \


#define NVM_TENSOR_SET_ATTR_4D(attr, N, C, H, W, order, datatype, bpe, accesstype, alloctype, X)\
{                                                                                               \
                                                                                                \
    attr[0].type = NVM_TENSOR_ATTR_DATA_TYPE;                                                   \
    attr[0].value = NVM_TENSOR_ATTR_DATA_TYPE_##datatype;                                       \
                                                                                                \
    attr[1].type = NVM_TENSOR_ATTR_4D_N;                                                        \
    attr[1].value = N;                                                                          \
                                                                                                \
    attr[2].type = NVM_TENSOR_ATTR_4D_C;                                                        \
    attr[2].value = C;                                                                          \
                                                                                                \
    attr[3].type = NVM_TENSOR_ATTR_4D_H;                                                        \
    attr[3].value = H;                                                                          \
                                                                                                \
    attr[4].type = NVM_TENSOR_ATTR_4D_W;                                                        \
    attr[4].value = W;                                                                          \
                                                                                                \
    attr[5].type = NVM_TENSOR_ATTR_4D_X;                                                        \
    attr[5].value = X;                                                                          \
                                                                                                \
    attr[6].type = NVM_TENSOR_ATTR_BITS_PER_ELEMENT;                                            \
    attr[6].value = NVM_TENSOR_ATTR_BITS_PER_ELEMENT_##bpe;                                     \
                                                                                                \
    attr[7].type = NVM_TENSOR_ATTR_DIMENSION_ORDER;                                             \
    attr[7].value = NVM_TENSOR_ATTR_DIMENSION_ORDER_##order;                                    \
                                                                                                \
    attr[8].type = NVM_TENSOR_ATTR_CPU_ACCESS;                                                  \
    attr[8].value = NVM_TENSOR_ATTR_CPU_ACCESS_##accesstype;                                    \
                                                                                                \
    attr[9].type = NVM_TENSOR_ATTR_ALLOC_TYPE;                                                  \
    attr[9].value = NVM_TENSOR_ATTR_ALLOC_##alloctype;                                          \
}

void
NvMediaTensorDestroy(
    NvMediaTensor *tensorDesc
);

typedef enum {
    NVMEDIA_TENSOR_ACCESS_READ       = (1 << 0),
    NVMEDIA_TENSOR_ACCESS_WRITE      = (1 << 1),
    NVMEDIA_TENSOR_ACCESS_READ_WRITE = (NVMEDIA_TENSOR_ACCESS_READ | NVMEDIA_TENSOR_ACCESS_WRITE),
} NvMediaTensorLockAccess;

typedef struct {
    uint32_t size;
    void *mapping;
} NvMediaTensorSurfaceMap;

NvMediaStatus
NvMediaTensorLock(
    NvMediaTensor *tensor,
    uint32_t lockAccessType,
    NvMediaTensorSurfaceMap *surfaceMap
);

void
NvMediaTensorUnlock(
    NvMediaTensor *tensor
);

NvMediaStatus
NvMediaTensorGetStatus(
    NvMediaTensor *tensor,
    uint32_t millisecondWait,
    NvMediaTensorTaskStatus *status
);

NvMediaStatus
NvMediaTensorGetMetaData(
    NvMediaTensor *tensor,
    NvMediaTensorMetaData *tensormetadata
);

/*
 * \defgroup history_nvmedia_tensor History
 * Provides change history for the NvMedia Tensor API.
 *
 * \section history_nvmedia_tensor Version History
 *
 * <b> Version 1.0 </b> May 22, 2017
 * - Initial release
 *
 * <b> Version 1.2 </b> Jun 21, 2019
 * - Fix Minor Misra Violations
 *
 * <b> Version 1.3 </b> Jun 22, 2019
 * - Deprecate the NvMediaTensorCreate API
 *   in support of NvSciBuf APIs
 *
 **/
#ifdef __cplusplus
};     /* extern "C" */
#endif

#endif /* NVMEDIA_TENSOR_H */