nvros_egl_utils.h

Go to the documentation of this file.

/*Copyright (c) 2020, NVIDIA CORPORATION.  All rights reserved.
 
NVIDIA CORPORATION and its licensors retain all intellectual property
and proprietary rights in and to this software, 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 _NVROSEGLUTIL_H_
#define _NVROSEGLUTIL_H_
 
#include <EGL/egl.h>
#include <EGL/eglext.h>
 
#include "nvmedia_core.h"
#include "nvroscommon.h"
#include "egl_extensions.h"
 
#include "cuda.h"
#include "cudaEGL.h"
 
 namespace nvros
 {
typedef enum _ConsumerType
{
 
    VIDEO_CONSUMER,
 
    IMAGE_CONSUMER,
 
    GL_CONSUMER,
 
    CUDA_CONSUMER,
 
    EGLOUTPUT_CONSUMER,
 
    DEFAULT_CONSUMER = EGLOUTPUT_CONSUMER,
 
    INVALID_CONSUMER = -1,
} ConsumerType;
 
typedef enum _ProducerType
{
 
    VIDEO_PRODUCER = 0,
 
    IMAGE_PRODUCER,
 
    GL_PRODUCER,
 
    CUDA_PRODUCER,
 
    DEFAULT_PRODUCER = IMAGE_PRODUCER,
 
    INVALID_PRODUCER = -1,
} ProducerType;
 
typedef enum _WinSys
{
 
    X11 = 0,
 
    WAYLAND,
 
    EGLDEVICE,
 
    NONE,
 
    DEFAULT_WINSYS = EGLDEVICE,
} WinSys;
 
typedef enum _OpMode
{
 
    MAILBOX = 0,
 
    FIFO,
 
    DEFAULT_OP_MODE = MAILBOX,
} OpMode;
 
typedef struct _EglUtilOptions
{
    uint8_t winSizeX;
 
    uint8_t winSizeY;
 
    uint8_t winOffsetX;
 
    uint8_t winOffsetY;
 
    uint8_t dispId;
 
    uint8_t winId;
} EglUtilOptions;
 
typedef struct _EglUtilState
{
    EGLDisplay display;
 
    EGLSurface surface;
 
    EGLConfig config;
 
    EGLContext context;
 
    EGLint width;
 
    EGLint height;
 
    EGLint xoffset;
 
    EGLint yoffset;
 
    EGLint displayId;
 
    EGLint windowId;
} EglUtilState;
 
typedef struct _CudaEglParams {
 
    EGLDisplay display;
 
    EGLStreamKHR eglStream;
 
    CUcontext context;
 
    CUeglStreamConnection cuEglConn;
} CudaEglParams;
 
class NvRosEglUtil {
 
public:
    NvRosEglUtil(ConsumerType cons_type, WinSys win_sys_type, OpMode op_mode);
 
    NvRosEglUtil(ProducerType prod_type, WinSys win_sys_type, OpMode op_mode);
 
    ~NvRosEglUtil();
 
    NvMediaStatus CheckNvMediaEGLStreamVersion(void);
 
    NvRosErr EglUtilInit(EglUtilOptions* options, EglUtilState* eglUtil);
 
    EGLStreamKHR EglStreamInit(EGLDisplay display, const char* socket_path);
 
    EGLint GetStreamState(EGLDisplay display, EGLStreamKHR eglStream);
 
    NvRosErr InitConsumer(EGLDisplay display, EGLStreamKHR eglStream);
 
    NvRosErr InitConsumer(EGLDisplay display, EGLStreamKHR eglStream,
                CudaEglParams* cudaConsumerParams);
 
    NvRosErr DeInitConsumer(CudaEglParams* cudaConsumerParams);
 
    NvRosErr EglStreamFinish(EGLDisplay display, EGLStreamKHR eglStream);
 
    NvRosErr EglUtilDeInit(EglUtilState* state);
 
private:
    ConsumerType mConsType;
    ProducerType mProdType;
    WinSys mWinSys;
    OpMode mOpMode;
 
    typedef struct _EglDeviceState {
        EGLDeviceEXT egl_dev;
        int drm_fd;
        int32_t drm_crtc_id;
        uint32_t drm_conn_id;
        EGLStreamKHR egl_str;
        EGLOutputLayerEXT egl_lyr;
    } EglDeviceState;
 
    EglDeviceState* eglDeviceState;
 
    //Private methods
    NvRosErr EglUtilSetupExtensions();
    NvRosErr WindowSystemInit(EglUtilState* state);
    NvRosErr WindowSystemWindowInit(EglUtilState* state);
    NvRosErr WindowSystemEglSurfaceCreate(EglUtilState* state);
    NvRosErr GetOutputLayer(EglUtilState* state);
    NvRosErr WindowSystemTerminate(void);
    NvRosErr WindowSystemWindowTerminate(EglUtilState* state);
    EGLStreamKHR InitConsumerEglStream(EGLDisplay display, const char* socket_path);
    EGLStreamKHR InitProducerEglStream(EGLDisplay display, const char* socket_path);
    NvRosErr EGLStreamSendFd(const char* socket_name, int fd);
    int EGLStreamReceiveFd(const char* socket_name);
    NvRosErr InitEglOutputConsumer(EGLDisplay display, EGLStreamKHR eglStream);
    NvRosErr InitCudaConsumer(EGLDisplay display, EGLStreamKHR eglStream,
                    CudaEglParams* cudaCondumerParams);
    NvRosErr DeInitCudaConsumer(CudaEglParams* cudaConsParams);
 
};
}
#endif