vehicle-backup/ZJ_OPENH264/webrtcinterop/include/NvEglRenderer.h

/*
 * Copyright (c) 2016, NVIDIA CORPORATION. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *  * Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *  * Neither the name of NVIDIA CORPORATION nor the names of its
 *    contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``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 THE COPYRIGHT OWNER OR
 * CONTRIBUTORS 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.
 */

/**
 * @file
 * <b>NVIDIA Multimedia API: EGL Renderer API</b>
 *
 * @b Description: This file declares the NvEgl Renderer API.
 */
#ifndef __NV_EGL_RENDERER_H__
#define __NV_EGL_RENDERER_H__

#include "NvElement.h"

#include <EGL/egl.h>
#include <EGL/eglext.h>
#include <GLES2/gl2.h>
#include <GLES2/gl2ext.h>

#include <X11/Xlib.h>

/**
 * @defgroup l4t_mm_nveglrenderer_group Rendering API
 *
 * The \c %NvEglRenderer API provides EGL and Open GL ES 2.0 rendering
 * functionality.
 *
 * @ingroup aa_framework_api_group
 * @{
 */

/**
 *
 * @c %NvEglRenderer is a helper class for rendering using EGL and OpenGL
 * ES 2.0. The renderer requires the file descriptor (FD) of a buffer
 * as an input. The rendering rate, in frames per second (fps), is
 * configurable.
 *
 * The renderer creates an X Window of its own. The width, height,
 * horizontal offset, and vertical offset of the window are
 * configurable.
 *
 * All EGL calls must be made through one thread only. This class
 * internally creates a thread which performs all EGL/GL
 * initializations, gets @c EGLImage objects from FD, renders the @c
 * EGLImage objects, and then deinitializes all the EGL/GL structures.
 *
 */
class NvEglRenderer:public NvElement
{
public:
    /**
     * Creates a new EGL-based renderer named @a name.
     *
     * This method creates a new X window for rendering, of size @a
     * width and @a height, that is offset by @a x_offset and @a
     * y_offset. If @a width or @a height is zero, a full screen
     * window is created with @a x_offset and @a y_offset set to zero.
     *
     * It internally initializes EGL, creates an @c eglContext, an
     * @c eglSurface, a GL texture, and shaders for rendering.
     *
     *
     * @param[in] name Specifies a pointer to a unique name to identity the
     *                 element instance.
     * @param[in] width Specifies the width of the window in pixels.
     * @param[in] height Specifies the height of the window in pixels.
     * @param[in] x_offset Specifies the horizontal offset of the window in pixels.
     * @param[in] y_offset Specifies the vertical offset of the window in pixels.
     * @return A reference to the newly created renderer object, otherwise @c NULL in
     *          case of failure during initialization.
     */
    static NvEglRenderer *createEglRenderer(const char *name, uint32_t width,
                                          uint32_t height, uint32_t x_offset,
                                          uint32_t y_offset);
     ~NvEglRenderer();

    /**
     * Renders a buffer.
     *
     * This method waits until the rendering time of the next buffer,
     * caluclated from the rendering time of the last buffer and the
     * render rate in frames per second (fps). This is a blocking
     * call.
     *
     * @param[in] fd Specifies the file descriptor (FD) of the exported buffer
     *               to render.
     * @return 0 for success, -1 otherwise.
     */
    int render(int fd);

    /**
     * Sets the rendering rate in frames per second (fps).
     *
     * @warning An @a fps of zero is not allowed.
     *
     * @param[in] fps Specifies the render rate in fps.
     * @return 0 for success, -1 otherwise.
     */
    int setFPS(float fps);

    /**
     * Gets underlying EGLDisplay.
     *
     * @return EGLDisplay handle
     */
    EGLDisplay getEGLDisplay() { return egl_display; }

    /**
     * Gets the display resolution.
     *
     *
     * @param[out] width A pointer to the full screen width, in pixels.
     * @param[out] height A pointer to the full screen height, in pixels.
     * @return 0 for success, -1 otherwise.
     */
    static int getDisplayResolution(uint32_t &width, uint32_t &height);

    /**
     * Sets the overlay string.
     *
     *
     * @param[in] str A pointer to the overlay text.
     * @param[in] x Horizontal offset, in pixels.
     * @param[in] y Vertical offset, in pixels.
     * @return 0 for success, -1 otherwise.
     */
    int setOverlayText(char *str, uint32_t x, uint32_t y);

private:
    Display * x_display;    /**< Connection to the X server created using
                                  XOpenDisplay(). */
    Window x_window;        /**< Holds the window to be used for rendering created using
                                  XCreateWindow(). */

    EGLDisplay egl_display;     /**< Holds the EGL Display connection. */
    EGLContext egl_context;     /**< Holds the EGL rendering context. */
    EGLSurface egl_surface;     /**< Holds the EGL Window render surface. */
    EGLConfig egl_config;       /**< Holds the EGL frame buffer configuration to be used
                                     for rendering. */

    uint32_t texture_id;        /**< Holds the GL Texture ID used for rendering. */
    GC gc;                      /**< Graphic Context */
    XFontStruct *fontinfo;      /**< Brush's font info */
    char overlay_str[512];       /**< Overlay's text */

    /**
     * Creates a GL texture used for rendering.
     *
     * @return 0 for success, -1 otherwise.
     */
    int create_texture();
    /**
     * Initializes shaders with shader programs required for drawing a
     * buffer.
     *
     * @return 0 for success, -1 otherwise.
     */
    int InitializeShaders();
    /**
     * Creates, compiles and attaches a shader to the @a program.
     *
     * @param[in] program Specifies the GL Program ID.
     * @param[in] type Specifies the type of the vertex shader. Must be either
                       @c GL_VERTEX_SHADER or @c GL_FRAGMENT_SHADER.
     * @param[in] source Specifies the source code of the shader in form of a string.
     * @param[in] size Specifies the character length of @a source.
     */
    void CreateShader(GLuint program, GLenum type, const char *source,
                      int size);

    struct timespec last_render_time;   /**< Rendering time for the last buffer. */

    int render_fd;      /**< File descriptor (FD) of the next buffer to
                             render. */
    bool stop_thread;   /**< Boolean variable used to signal rendering thread
                             to stop. */
    pthread_t render_thread;        /**< The pthread id of the rendering thread. */
    pthread_mutex_t render_lock;    /**< Used for synchronization. */
    pthread_cond_t render_cond;     /**< Used for synchronization. */
    uint32_t overlay_str_x_offset;  /**< Overlay text's position in horizontal direction. */
    uint32_t overlay_str_y_offset;  /**< Overlay text's position in vertical direction. */
    float fps;                      /**< The render rate in frames per second. */
    uint64_t render_time_sec;       /**< Seconds component of the time for which a
                                         frame should be displayed. */
    uint64_t render_time_nsec;      /**< Nanoseconds component of the time for which
                                         a frame should be displayed. */

    /**
     * Constructor called by the wrapper createEglRenderer.
     */
    NvEglRenderer(const char *name, uint32_t width, uint32_t height,
                  uint32_t x_offset, uint32_t y_offset);
    /**
     * Gets the pointers to the required EGL methods.
     */
    static int initEgl();
    /**
     * Method executed by the renderThread.
     *
     * This method continues to execute infinitely until signalled to
     * stop with the @c stop_thread variable. This method contains a
     * while loop that calls NvEglRenderer::renderInternal().
     */
    static void * renderThread(void *arg);
    /**
     * This method contains the actual logic of rendering a buffer
     * and waiting until the buffer render time.
     */
    int renderInternal();

    /**
     * These EGL function pointers are required by the renderer.
     */
    static PFNEGLCREATEIMAGEKHRPROC eglCreateImageKHR;
    static PFNEGLDESTROYIMAGEKHRPROC eglDestroyImageKHR;
    static PFNEGLCREATESYNCKHRPROC eglCreateSyncKHR;
    static PFNEGLDESTROYSYNCKHRPROC eglDestroySyncKHR;
    static PFNEGLCLIENTWAITSYNCKHRPROC eglClientWaitSyncKHR;
    static PFNEGLGETSYNCATTRIBKHRPROC eglGetSyncAttribKHR;
    static PFNGLEGLIMAGETARGETTEXTURE2DOESPROC glEGLImageTargetTexture2DOES;

    static const NvElementProfiler::ProfilerField valid_fields =
            NvElementProfiler::PROFILER_FIELD_TOTAL_UNITS |
            NvElementProfiler::PROFILER_FIELD_FPS |
            NvElementProfiler::PROFILER_FIELD_LATE_UNITS;
};
/** @} */
#endif