Image.h

Go to the documentation of this file.

// This code contains NVIDIA Confidential Information and is disclosed
// under the Mutual Non-Disclosure Agreement.
//
// Notice
// ALL NVIDIA DESIGN SPECIFICATIONS AND CODE ("MATERIALS") ARE PROVIDED "AS IS" NVIDIA MAKES
// NO REPRESENTATIONS, WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
// THE MATERIALS, AND EXPRESSLY DISCLAIMS ANY IMPLIED WARRANTIES OF NONINFRINGEMENT,
// MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
//
// NVIDIA Corporation assumes no responsibility for the consequences of use of such
// information or for any infringement of patents or other rights of third parties that may
// result from its use. No license is granted by implication or otherwise under any patent
// or patent rights of NVIDIA Corporation. No third party distribution is allowed unless
// expressly authorized by NVIDIA.  Details are subject to change without notice.
// This code supersedes and replaces all information previously supplied.
// NVIDIA Corporation products are not authorized for use as critical
// components in life support devices or systems without express written approval of
// NVIDIA Corporation.
//
// Copyright (c) 2016-2017 NVIDIA Corporation. All rights reserved.
//
// NVIDIA Corporation and its licensors retain all intellectual property and proprietary
// rights in and to this software and related documentation and any modifications thereto.
// Any use, reproduction, disclosure or distribution of this software and related
// documentation without an express license agreement from NVIDIA Corporation is
// strictly prohibited.
//

#ifndef DW_IMAGE_IMAGE_H__
#define DW_IMAGE_IMAGE_H__

#include <dw/core/Config.h>
#include <dw/core/Exports.h>
#include <dw/core/Types.h>
#include <dw/core/Status.h>
#include <dw/core/Context.h>

// Forward defines from GL
// Note: GL defines the specific bitdepth of these types
//       so it is safe to declare then here without including GL.h
typedef uint32_t GLenum;
typedef uint32_t GLuint;

#if (defined LINUX || VIBRANTE)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wold-style-cast"
#endif

#include <cuda_runtime.h>

#if (defined LINUX || VIBRANTE)
#pragma GCC diagnostic pop
#endif

#ifdef VIBRANTE
#include <nvmedia_image.h>
#endif

#ifdef __cplusplus
extern "C" {
#endif

#define DW_MAX_IMAGE_PLANES 3

typedef enum dwImageType {
    DW_IMAGE_CPU = 0,
    DW_IMAGE_GL,
    DW_IMAGE_CUDA,
#ifdef VIBRANTE
    DW_IMAGE_NVMEDIA
#endif
} dwImageType;

typedef enum dwImagePixelFormat {
    DW_IMAGE_PIXEL_FORMAT_UNKNOWN = 0,

    DW_IMAGE_R      = 1000,
    DW_IMAGE_RGB    = 2000,
    DW_IMAGE_RCB    = 2100,
    DW_IMAGE_RCC    = 2200,

    DW_IMAGE_RGBA   = 3000,

    // DEPRECATED: DW_IMAGE_SRGB_PLANAR_FP16_NORM  = 5000,
    // use: DW_IMAGE_RGB, planeCount=3, pxlType=DW_TYPE_FLOAT16 instead

    DW_IMAGE_YUV420     = 6000,
    DW_IMAGE_YUV422     = 6100,

    DW_IMAGE_RAW        = 10000

} dwImagePixelFormat;

typedef enum {
    DW_IMAGE_CUDA_PITCH,
    DW_IMAGE_CUDA_BLOCK
} dwImageCUDAMemoryType;

typedef struct dwImageDataLines {
    uint32_t bytesPerLine;

    dwVector2ui embeddedDataSize;

    uint8_t* topLineData;
    uint8_t* bottomLineData;
} dwImageDataLines;

typedef enum {

    DW_IMAGE_FLAGS_EMBEDDED_LINES           = (1 << 2),

    DW_IMAGE_FLAGS_SENSOR_SETTINGS        = (1 << 3),

} dwImageMetaDataFlags;

typedef struct dwImageMetaData {

    int32_t flags;

    float32_t exposureTime;
    float32_t analogGain;
    float32_t conversionGain;
    float32_t digitalGain;
    float32_t wbGain[4];

    dwImageDataLines dataLines;

} dwImageMetaData;

typedef struct dwImageProperties {
    dwImageType type;
    uint32_t width;
    uint32_t height;
    dwImagePixelFormat pxlFormat;
    dwTrivialDataType pxlType;
    uint32_t planeCount;

    dwImageMetaData meta;
} dwImageProperties;

typedef struct dwImageCPU {
    dwImageProperties prop;
    size_t pitch[DW_MAX_IMAGE_PLANES];
    uint8_t *data[DW_MAX_IMAGE_PLANES];
    dwTime_t timestamp_us;
} dwImageCPU;

typedef struct dwImageGL {
    dwImageProperties prop;
    GLuint tex;
    GLenum target;
    dwTime_t timestamp_us;
} dwImageGL;

typedef struct dwImageCUDA {
    dwImageProperties prop;
    dwImageCUDAMemoryType layout;
    size_t pitch[DW_MAX_IMAGE_PLANES]; // pitch in bytes
    void *dptr[DW_MAX_IMAGE_PLANES];
    cudaArray_t array[DW_MAX_IMAGE_PLANES];
    dwTime_t timestamp_us;
} dwImageCUDA;

#ifdef VIBRANTE
typedef struct dwImageNvMedia {
    dwImageProperties prop;
    NvMediaImage *img;
    dwTime_t timestamp_us;
} dwImageNvMedia;
#endif

DW_API_PUBLIC dwStatus dwImageCPU_create(dwImageCPU* cpuImage, const dwImageProperties *prop);

DW_API_PUBLIC dwStatus dwImageCPU_destroy(dwImageCPU* cpuImage);

DW_API_PUBLIC dwStatus dwImageCUDA_create(dwImageCUDA* cudaImage, const dwImageProperties *prop,
                                      dwImageCUDAMemoryType layout);

DW_API_PUBLIC dwStatus dwImageCUDA_destroy(dwImageCUDA* cudaImage);

DW_API_PUBLIC dwStatus dwImageGL_create(dwImageGL* glImage, const dwImageProperties *prop,
                                      GLenum target);

DW_API_PUBLIC dwStatus dwImageGL_destroy(dwImageGL* glImage);

#ifdef VIBRANTE

DW_API_PUBLIC dwStatus dwImageNvMedia_create(dwImageNvMedia* nvmImage, const dwImageProperties *prop,
                                             const dwContextHandle_t context);

DW_API_PUBLIC dwStatus dwImageNvMedia_destroy(dwImageNvMedia* nvmImage);
#endif

DW_API_PUBLIC dwStatus dwImage_getDataLayout(size_t *elementSize,
                                             uint32_t planeChannelCount[DW_MAX_IMAGE_PLANES],
                                             dwVector2ui planeSize[DW_MAX_IMAGE_PLANES],
                                             const dwImageProperties *prop);
DW_API_PUBLIC dwStatus dwImageGL_setupTexture(dwImageGL* glImg, const uint8_t* data, int32_t level,
                                              uint32_t depth);

DW_API_PUBLIC dwStatus dwImageCUDA_setFromPitch(dwImageCUDA *result,
                                                void *devicePtr,
                                                uint32_t width,
                                                uint32_t height,
                                                size_t pitchInBytes,
                                                dwImagePixelFormat pixelFormat);

DW_API_PUBLIC dwStatus dwImageCUDA_getPlaneAsImage(dwImageCUDA *planeImage,
                                               const dwImageCUDA *srcImage,
                                               uint32_t planeIdx);

#ifdef VIBRANTE

DW_API_PUBLIC dwStatus dwImageNvMedia_setFromImage(dwImageNvMedia *dstImage, const NvMediaImage *srcImage);
#endif

DW_API_PUBLIC dwStatus dwImageCPU_mapToROI(dwImageCPU *dstImg, const dwImageCPU *srcImg, dwRect roi);

DW_API_PUBLIC dwStatus dwImageCUDA_mapToROI(dwImageCUDA *dstImg, const dwImageCUDA *srcImg, dwRect roi);
#ifdef __cplusplus
}
#endif

#endif // DW_IMAGE_IMAGE_H__