openglthread.h

Go to the documentation of this file.

#ifndef openglthread_HEADER_GUARD
#define openglthread_HEADER_GUARD
/*
 * openglthread.h : The OpenGL thread for presenting frames and related data structures
 * 
 * (c) Copyright 2017-2024 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