valkka-core/html/openglthread_8h_source.html

#ifndef openglthread_HEADER_GUARD

#define openglthread_HEADER_GUARD

/*

 * openglthread.h : The OpenGL thread for presenting frames and related data structures

 *

 * Copyright 2017-2020 Valkka Security Ltd. and Sampsa Riikonen

 *

 * Authors: Sampsa Riikonen <sampsa.riikonen@iki.fi>

 *

 * This file is part of the Valkka library.

 *

 * Valkka is free software: you can redistribute it and/or modify

 * it under the terms of the GNU Lesser General Public License as

 * published by the Free Software Foundation, either version 3 of the

 * License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public License

 * along with this program.  If not, see <https://www.gnu.org/licenses/>

 *

 */


#include "tex.h"

#include "openglframefifo.h"

#include "constant.h"

#include "thread.h"

#include "shader.h"

#include "threadsignal.h"

#include "openglobject.h"


typedef void ( *PFNGLXSWAPINTERVALEXTPROC) (Display *dpy, GLXDrawable drawable, int interval);

// typedef void ( *PFNGLXSWAPINTERVALEXTPROC) (Display *dpy, GLXDrawable drawable, int interval);


class SlotContext {


public:

  SlotContext(YUVTEX *statictex, YUVShader *shader);

  ~SlotContext();

  ban_copy_ctor(SlotContext);

  ban_copy_asm(SlotContext);


public:

  YUVTEX*      yuvtex;

  YUVTEX*      statictex;

  YUVShader*   shader;

  BitmapPars   bmpars;

  long int     lastmstime;


private:

    uint      ref_count;

    bool      active;

    bool      is_dead;

    AVCodecID codec_id;

    bool      load_flag;

    bool      keep_flag;


private:

  long int  prev_mstimestamp;


public:

  // void activate(BitmapPars bmpars, YUVShader* shader);      ///< Allocate SlotContext::yuvtex (for a frame of certain size) and SlotContext::shader.

  void activate(BitmapPars bmpars);

  void deActivate();

  void loadYUVFrame(YUVFrame* yuvframe);

  YUVTEX* getTEX();

  bool manageTimer(long int mstime);

  void checkIfDead(long int mstime);

  bool isPending(long int mstime);


public: // getters

  bool isUsed()   const {return ref_count>0;}

  bool isActive() const {return active;}

  bool isDead()   const {return is_dead;}


public: // setters

    void inc_ref_count() {ref_count++;}

    void dec_ref_count() {ref_count--;}

    void loadFlag(bool val);

    void keepFlag(bool val);

};


class RenderContext {


public:

  RenderContext(SlotContext* slot_context, int id, unsigned int z=0);

  virtual ~RenderContext();

  RenderContext(const RenderContext &f) : z(0) notice_ban_copy_ctor();

  ban_copy_asm(RenderContext);


public: // Initialized at constructor init list or at constructor

  SlotContext* slot_context;

  const unsigned int z;

  // bool active;

  int id;


private: // Initialized at RenderContext::init that calls RenderContext::activate

  GLuint        VAO;

  GLuint        VBO;

  GLuint        EBO;

  std::array<GLfloat,16> transform;

  std::array<GLfloat,20> vertices;

  std::array<GLuint, 6>  indices;


private: // some aux timing variables

    long int render_mstime, render_mstime_old;


private:

  std::list<OverlayObject*> overlays;


private:

  void activate();


public:

  XWindowAttributes x_window_attr;


public: // getters

  int getId() const {return id;}

  // bool isActive() {return active;}   ///< Legacy.  Now, if instantiated, is active!


public:

  // bool activate();        ///< Activate this RenderContext (now it can render).  Legacy

  // bool activateIf();      ///< Try to activate if not active already. Legacy


  void addRectangle(float left, float right, float top, float bottom);

  void clearObjects();


  void renderTexture();

  void renderObjects();


  void render(XWindowAttributes x_window_attr);

  void bindTextures();

  void bindVars();

  void bindVarsObj();


  void bindVertexArray();

};


// https://stackoverflow.com/questions/4421706/what-are-the-basic-rules-and-idioms-for-operator-overloading

// inline bool operator==(const RenderContext& lhs, const RenderContext& rhs){ return (lhs.getId()==rhs.getId()); }


class RenderGroup {


public:

  RenderGroup(Display *display_id, const GLXContext &glc, Window window_id, Window child_id, bool doublebuffer_flag=true);

  ~RenderGroup();


public:

  Display* display_id;

  const GLXContext &glc;

  Window   window_id;

  Window   child_id;

  bool     doublebuffer_flag;

  std::list<RenderContext*> render_contexes;

  XWindowAttributes x_window_attr;


public: // getters

  Window getWindowId() const {return window_id;}

  const std::list<RenderContext*>& getRenderContexes() const {return render_contexes;}


public:

  std::list<RenderContext*>::iterator getContext(int id);

  bool addContext(RenderContext *render_context);

  RenderContext* delContext(int id);

  bool isEmpty();


  void render();

};


namespace swap_flavors {

  const static unsigned     none =0;

  const static unsigned     ext  =1;

  const static unsigned     mesa =2;

  const static unsigned     sgi  =3;

}


class OpenGLThread : public Thread { // <pyapi>


public: // <pyapi>

    OpenGLThread(const char* name, OpenGLFrameFifoContext fifo_ctx=OpenGLFrameFifoContext(), unsigned msbuftime=DEFAULT_OPENGLTHREAD_BUFFERING_TIME, const char* x_connection=""); // <pyapi>

    virtual ~OpenGLThread();


protected: // initialized at init list

    OpenGLFrameFifo   *infifo;

    FifoFrameFilter   infilter;

    std::string       x_connection;


protected: // Shaders. Initialized by makeShaders.

    // Future developments: create a shader instance (and a program) per each stream, etc..?

    // these could be reserved into the stack right here

    // YUVShader   yuv_shader;

    // RGBShader   rgb_shader;

    // .. but, we want to do all OpenGL calls after differentiating the Thread

    YUVShader*    yuv_shader;

    RGBShader*    rgb_shader;


protected:

    YUVTEX*       statictex;

    std::string   static_texture_file;


protected: // Variables related to X11 and GLX.  Initialized by initGLX.

    Display*      display_id;

    bool          doublebuffer_flag;

    GLXContext    glc;

    int*          att;

    Window        root_id;

    XVisualInfo*  vi;

    GLXFBConfig*  fbConfigs;

    Colormap      cmap;

    YUVFrame*     dummyframe;


    std::vector<SlotContext*>              slots_;

    // std::map<SlotNumber, SlotContext>     slots_;        ///< SlotNumber => SlotContext mapping TODO: start using this in the future

    std::map<Window, RenderGroup>         render_groups;

    std::vector<std::list<RenderGroup*>>  render_lists;

    std::map<int, RenderContext*>         render_contexes;


    // std::map<SlotNumber,std::list<RenderGroup*>>  render_lists;  ///< TODO: start using this in the future


private: // function pointers for glx extensions

    PFNGLXSWAPINTERVALEXTPROC     pglXSwapIntervalEXT;

    PFNGLXGETSWAPINTERVALMESAPROC pglXGetSwapIntervalMESA;

    PFNGLXSWAPINTERVALMESAPROC    pglXSwapIntervalMESA;


public: // methods for getting/setting the swap interval .. these choose the correct method to call

    unsigned                      swap_flavor;

    unsigned                      swap_interval_at_startup;

    unsigned                      getSwapInterval(GLXDrawable drawable=0);

    void                          setSwapInterval(unsigned i, GLXDrawable drawable=0);


protected: // Variables related to queing and presentation

    unsigned             msbuftime;

    unsigned             future_ms_tolerance;

    std::list<Frame*>    presfifo;

    long int             calltime, callswaptime;


protected: // debugging variables

    bool  debug;


public: // manipulate RenderGroup(s)

    bool                hasRenderGroup(Window window_id);

    RenderGroup&        getRenderGroup(Window window_id);

    bool                newRenderGroup(Window window_id);

    bool                delRenderGroup(Window window_id);


public: // manipulate RenderContex(es)

    // int                 newRenderContext(SlotNumber slot, Window window_id, unsigned int z); ///< Creates a new render context

    void                newRenderContext(SlotNumber slot, Window window_id, int id, unsigned int z);

    bool                delRenderContext(int id);


public: // add overlay objects (rectangles, etc)

    bool                contextAddRectangle(int id, float left, float right, float top, float bottom);

    bool                contextClearObjects(int id);


public: // loading and rendering actions

    void                loadYUVFrame(SlotNumber n_slot, YUVFrame *yuvframe);

    void                render(SlotNumber n_slot);

    void                checkSlots(long int mstime);


public: // getter methods

    Display*            getDisplayId() {return display_id;}

    const GLXContext&   getGlc() {return glc;}

    const Window&       getRootId() {return root_id;}


public: // slot methods

    bool                slotUsed       (SlotNumber i);

    void                activateSlot   (SlotNumber i, YUVFrame *yuvframe);

    void                activateSlotIf (SlotNumber i, YUVFrame *yuvframe); // Activate slot if it's not already active or if the texture has changed

    bool                manageSlotTimer(SlotNumber i, long int mstime);


public: // setter methods

    void                debugOn()  {debug=true;}

    void                debugOff() {debug=false;}


public: // Thread variables

    std::deque<OpenGLSignalContext> signal_fifo;


public: // Thread virtual methods

    void run();

    void preRun();

    void postRun();

    void handleSignal(OpenGLSignalContext &signal_ctx);

    void handleSignals();

    void sendSignal(OpenGLSignalContext signal_ctx);

    void sendSignalAndWait(OpenGLSignalContext signal_ctx);


public: // methods, internal : initializing / closing .. but we might want to test these separately, keep public

    void initGLX();

    void closeGLX();

    void loadExtensions();

    void VSyncOff();

    int hasCompositor(int screen);

    void makeShaders();

    void delShaders();

    void reserveFrames();

    void releaseFrames();


protected: // internal methods

    void dumpPresFifo();

    void diagnosis();

    void resetCallTime();

    void reportCallTime(unsigned i);

    long unsigned insertFifo(Frame* f);

    void readStaticTex();


    long unsigned handleFifo();

    void delRenderContexes();


public:  // reporting

    void reportSlots();

    void reportRenderGroups();

    void reportRenderList();


    void dumpYUVStacks() {infifo->dumpYUVStacks();}

    void YUVdiagnosis()  {infifo->YUVdiagnosis();}

    void dumpInFifo()    {infifo->dumpFifo();}


public: // testing

    void recycle(Frame* f)             {infifo->recycle(f);}


public: // for testing // <pyapi>

    Window     createWindow(bool map=true, bool show=false);

    void       makeCurrent(const Window window_id);

    unsigned   getVsyncAtStartup();

    void       reConfigWindow(Window window_id);

    Window     getChildWindow(Window parent_id);


public: // API // <pyapi>

    FifoFrameFilter &getFrameFilter();

    void setStaticTexFile(const char* fname);


    void requestStopCall();                                             // <pyapi>


    void infoCall();                                             // <pyapi>


    bool newRenderGroupCall  (Window window_id);                 // <pyapi>


    bool delRenderGroupCall  (Window window_id);                 // <pyapi>


    int newRenderContextCall (SlotNumber slot, Window window_id, unsigned int z);  // <pyapi>


    bool delRenderContextCall(int id);                           // <pyapi>


    void addRectangleCall(int id, float left, float right, float top, float bottom); // <pyapi>


    void clearObjectsCall(int id); // <pyapi>


}; // <pyapi>


#endif