vdr-plugin-softhdcuvid/openglosd.h

#ifndef __SOFTHDDEVICE_OPENGLOSD_H
#define __SOFTHDDEVICE_OPENGLOSD_H

#include <GL/glew.h>
#include <GL/freeglut.h>
#include <GL/gl.h>

#define GLM_FORCE_RADIANS
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>
#include <math.h>

#include <ft2build.h>
#include FT_FREETYPE_H
#include FT_LCD_FILTER_H
#include FT_STROKER_H

#undef __FTERRORS_H__
#define FT_ERRORDEF( e, v, s )	{ e, s },
#define FT_ERROR_START_LIST	{
#define FT_ERROR_END_LIST	{ 0, 0 } };
const struct
{
    int code;
    const char *message;
} FT_Errors[] =
#include FT_ERRORS_H
#include <memory>
#include <queue>
#include <vdr/plugin.h>
#include <vdr/osd.h>
#include <vdr/thread.h>
#include "softhddev.h"
extern "C"
{
#include <stdint.h>
#include <libavcodec/avcodec.h>

#include "audio.h"
#include "video.h"
#include "codec.h"

}

extern "C" pthread_mutex_t OSDMutex;

struct sOglImage
{
    GLuint texture;
    GLint width;
    GLint height;
    bool used;
};

/****************************************************************************************
* Helpers
****************************************************************************************/

void ConvertColor(const GLint & colARGB, glm::vec4 & col);

/****************************************************************************************
* cShader
****************************************************************************************/
enum eShaderType
{
    stRect,
    stTexture,
    stText,
    stCount
};

class cShader
{
  private:
    eShaderType type;
    GLuint id;
    bool Compile(const char *vertexCode, const char *fragmentCode);
    bool CheckCompileErrors(GLuint object, bool program = false);
  public:
     cShader(void)
    {
    };
    virtual ~ cShader(void)
    {
    };
    bool Load(eShaderType type);
    void Use(void);
    void SetFloat(const GLchar * name, GLfloat value);
    void SetInteger(const GLchar * name, GLint value);
    void SetVector2f(const GLchar * name, GLfloat x, GLfloat y);
    void SetVector3f(const GLchar * name, GLfloat x, GLfloat y, GLfloat z);
    void SetVector4f(const GLchar * name, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
    void SetMatrix4(const GLchar * name, const glm::mat4 & matrix);
};

/****************************************************************************************
* cOglGlyph
****************************************************************************************/
class cOglGlyph:public cListObject
{
  private:
    struct tKerning
    {
      public:
        tKerning(uint prevSym, GLfloat kerning = 0.0f) {
            this->prevSym = prevSym;
            this->kerning = kerning;
        }
        uint prevSym;
        GLfloat kerning;
    };
    uint charCode;
    int bearingLeft;
    int bearingTop;
    int width;
    int height;
    int advanceX;

    cVector < tKerning > kerningCache;
    GLuint texture;
    void LoadTexture(FT_BitmapGlyph ftGlyph);

  public:
    cOglGlyph(uint charCode, FT_BitmapGlyph ftGlyph);
    virtual ~ cOglGlyph();
    uint CharCode(void)
    {
        return charCode;
    }
    int AdvanceX(void)
    {
        return advanceX;
    }
    int BearingLeft(void) const
    {
        return bearingLeft;
    }
    int BearingTop(void) const
    {
        return bearingTop;
    }
    int Width(void) const
    {
        return width;
    }
    int Height(void) const
    {
        return height;
    }
    int GetKerningCache(uint prevSym);
    void SetKerningCache(uint prevSym, int kerning);
    void BindTexture(void);
};

/****************************************************************************************
* cOglFont
****************************************************************************************/
class cOglFont:public cListObject
{
  private:
    static bool initiated;
    cString name;
    int size;
    int height;
    int bottom;
    static FT_Library ftLib;
    FT_Face face;
    static cList < cOglFont > *fonts;
    mutable cList < cOglGlyph > glyphCache;
     cOglFont(const char *fontName, int charHeight);
    static void Init(void);
  public:
     virtual ~ cOglFont(void);
    static cOglFont *Get(const char *name, int charHeight);
    static void Cleanup(void);
    const char *Name(void)
    {
        return *name;
    };
    int Size(void)
    {
        return size;
    };
    int Bottom(void)
    {
        return bottom;
    };
    int Height(void)
    {
        return height;
    };
    cOglGlyph *Glyph(uint charCode) const;
    int Kerning(cOglGlyph * glyph, uint prevSym) const;
};

/****************************************************************************************
* cOglFb
* Framebuffer Object - OpenGL part of a Pixmap
****************************************************************************************/
class cOglFb
{
  protected:
    bool initiated;
    // GLuint fb;
    // GLuint texture;
    GLint width, height;
    GLint viewPortWidth, viewPortHeight;
    bool scrollable;
  public:
     GLuint fb;
    GLuint texture;

     cOglFb(GLint width, GLint height, GLint viewPortWidth, GLint viewPortHeight);
     virtual ~ cOglFb(void);
    bool Initiated(void)
    {
        return initiated;
    }
    virtual bool Init(void);
    void Bind(void);
    void BindRead(void);
    virtual void BindWrite(void);
    virtual void Unbind(void);
    bool BindTexture(void);
    void Blit(GLint destX1, GLint destY1, GLint destX2, GLint destY2);
    GLint Width(void)
    {
        return width;
    };
    GLint Height(void)
    {
        return height;
    };
    bool Scrollable(void)
    {
        return scrollable;
    };
    GLint ViewportWidth(void)
    {
        return viewPortWidth;
    };
    GLint ViewportHeight(void)
    {
        return viewPortHeight;
    };
};

/****************************************************************************************
* cOglOutputFb
* Output Framebuffer Object - holds Vdpau Output Surface which is our "output framebuffer"
****************************************************************************************/
class cOglOutputFb:public cOglFb
{
  protected:
    bool initiated;
  private:
     GLvdpauSurfaceNV surface;
  public:
     GLuint fb;
    GLuint texture;
     cOglOutputFb(GLint width, GLint height);
     virtual ~ cOglOutputFb(void);
    virtual bool Init(void);
    virtual void BindWrite(void);
    virtual void Unbind(void);
};

/****************************************************************************************
* cOglVb
* Vertex Buffer - OpenGl Vertices for the different drawing commands
****************************************************************************************/
enum eVertexBufferType
{
    vbRect,
    vbEllipse,
    vbSlope,
    vbTexture,
    vbText,
    vbCount
};

class cOglVb
{
  private:
    eVertexBufferType type;
    eShaderType shader;
    GLuint vao;
    GLuint vbo;
    int sizeVertex1;
    int sizeVertex2;
    int numVertices;
    GLuint drawMode;
  public:
     cOglVb(int type);
     virtual ~ cOglVb(void);
    bool Init(void);
    void Bind(void);
    void Unbind(void);
    void ActivateShader(void);
    void EnableBlending(void);
    void DisableBlending(void);
    void SetShaderColor(GLint color);
    void SetShaderAlpha(GLint alpha);
    void SetShaderProjectionMatrix(GLint width, GLint height);
    void SetVertexData(GLfloat * vertices, int count = 0);
    void DrawArrays(int count = 0);
};

/****************************************************************************************
* cOpenGLCmd
****************************************************************************************/
class cOglCmd
{
  protected:
    cOglFb * fb;
  public:
    cOglCmd(cOglFb * fb)
    {
        this->fb = fb;
    };
    virtual ~ cOglCmd(void)
    {
    };
    virtual const char *Description(void) = 0;
    virtual bool Execute(void) = 0;
};

class cOglCmdInitOutputFb:public cOglCmd
{
  private:
    cOglOutputFb * oFb;
  public:
    cOglCmdInitOutputFb(cOglOutputFb * oFb);
    virtual ~ cOglCmdInitOutputFb(void)
    {
    };
    virtual const char *Description(void)
    {
        return "InitOutputFramebuffer";
    }
    virtual bool Execute(void);
};

class cOglCmdInitFb:public cOglCmd
{
  private:
    cCondWait * wait;
  public:
    cOglCmdInitFb(cOglFb * fb, cCondWait * wait = NULL);
    virtual ~ cOglCmdInitFb(void)
    {
    };
    virtual const char *Description(void)
    {
        return "InitFramebuffer";
    }
    virtual bool Execute(void);
};

class cOglCmdDeleteFb:public cOglCmd
{
  public:
    cOglCmdDeleteFb(cOglFb * fb);
    virtual ~ cOglCmdDeleteFb(void)
    {
    };
    virtual const char *Description(void)
    {
        return "DeleteFramebuffer";
    }
    virtual bool Execute(void);
};

class cOglCmdRenderFbToBufferFb:public cOglCmd
{
  private:
    cOglFb * buffer;
    GLfloat x, y;
    GLfloat drawPortX, drawPortY;
    GLint transparency;
  public:
     cOglCmdRenderFbToBufferFb(cOglFb * fb, cOglFb * buffer, GLint x, GLint y, GLint transparency, GLint drawPortX,
        GLint drawPortY);
     virtual ~ cOglCmdRenderFbToBufferFb(void)
    {
    };
    virtual const char *Description(void)
    {
        return "Render Framebuffer to Buffer";
    }
    virtual bool Execute(void);
};

class cOglCmdCopyBufferToOutputFb:public cOglCmd
{
  private:
    cOglOutputFb * oFb;
    GLint x, y;
  public:
     cOglCmdCopyBufferToOutputFb(cOglFb * fb, cOglOutputFb * oFb, GLint x, GLint y);
     virtual ~ cOglCmdCopyBufferToOutputFb(void)
    {
    };
    virtual const char *Description(void)
    {
        return "Copy buffer to OutputFramebuffer";
    }
    virtual bool Execute(void);
};

class cOglCmdFill:public cOglCmd
{
  private:
    GLint color;
  public:
    cOglCmdFill(cOglFb * fb, GLint color);
    virtual ~ cOglCmdFill(void)
    {
    };
    virtual const char *Description(void)
    {
        return "Fill";
    }
    virtual bool Execute(void);
};

class cOglCmdDrawRectangle:public cOglCmd
{
  private:
    GLint x, y;
    GLint width, height;
    GLint color;
  public:
     cOglCmdDrawRectangle(cOglFb * fb, GLint x, GLint y, GLint width, GLint height, GLint color);
     virtual ~ cOglCmdDrawRectangle(void)
    {
    };
    virtual const char *Description(void)
    {
        return "DrawRectangle";
    }
    virtual bool Execute(void);
};

class cOglCmdDrawEllipse:public cOglCmd
{
  private:
    GLint x, y;
    GLint width, height;
    GLint color;
    GLint quadrants;
    GLfloat *CreateVerticesFull(int &numVertices);
    GLfloat *CreateVerticesQuadrant(int &numVertices);
    GLfloat *CreateVerticesHalf(int &numVertices);
  public:
     cOglCmdDrawEllipse(cOglFb * fb, GLint x, GLint y, GLint width, GLint height, GLint color, GLint quadrants);
     virtual ~ cOglCmdDrawEllipse(void)
    {
    };
    virtual const char *Description(void)
    {
        return "DrawEllipse";
    }
    virtual bool Execute(void);
};

class cOglCmdDrawSlope:public cOglCmd
{
  private:
    GLint x, y;
    GLint width, height;
    GLint color;
    GLint type;
  public:
     cOglCmdDrawSlope(cOglFb * fb, GLint x, GLint y, GLint width, GLint height, GLint color, GLint type);
     virtual ~ cOglCmdDrawSlope(void)
    {
    };
    virtual const char *Description(void)
    {
        return "DrawSlope";
    }
    virtual bool Execute(void);
};

class cOglCmdDrawText:public cOglCmd
{
  private:
    GLint x, y;
    GLint limitX;
    GLint colorText;
    cString fontName;
    int fontSize;
    unsigned int *symbols;
  public:
     cOglCmdDrawText(cOglFb * fb, GLint x, GLint y, unsigned int *symbols, GLint limitX, const char *name,
        int fontSize, tColor colorText);
     virtual ~ cOglCmdDrawText(void);
    virtual const char *Description(void)
    {
        return "DrawText";
    }
    virtual bool Execute(void);
};

class cOglCmdDrawImage:public cOglCmd
{
  private:
    tColor * argb;
    GLint x, y, width, height;
    bool overlay;
    GLfloat scaleX, scaleY;
  public:
     cOglCmdDrawImage(cOglFb * fb, tColor * argb, GLint width, GLint height, GLint x, GLint y, bool overlay =
        true, double scaleX = 1.0f, double scaleY = 1.0f);
     virtual ~ cOglCmdDrawImage(void);
    virtual const char *Description(void)
    {
        return "Draw Image";
    }
    virtual bool Execute(void);
};

class cOglCmdDrawTexture:public cOglCmd
{
  private:
    sOglImage * imageRef;
    GLint x, y;
  public:
     cOglCmdDrawTexture(cOglFb * fb, sOglImage * imageRef, GLint x, GLint y);
     virtual ~ cOglCmdDrawTexture(void)
    {
    };
    virtual const char *Description(void)
    {
        return "Draw Texture";
    }
    virtual bool Execute(void);
};

class cOglCmdStoreImage:public cOglCmd
{
  private:
    sOglImage * imageRef;
    tColor *data;
  public:
     cOglCmdStoreImage(sOglImage * imageRef, tColor * argb);
     virtual ~ cOglCmdStoreImage(void);
    virtual const char *Description(void)
    {
        return "Store Image";
    }
    virtual bool Execute(void);
};

class cOglCmdDropImage:public cOglCmd
{
  private:
    sOglImage * imageRef;
    cCondWait *wait;
  public:
     cOglCmdDropImage(sOglImage * imageRef, cCondWait * wait);
     virtual ~ cOglCmdDropImage(void)
    {
    };
    virtual const char *Description(void)
    {
        return "Drop Image";
    }
    virtual bool Execute(void);
};

/******************************************************************************
* cOglThread
******************************************************************************/
#define OGL_MAX_OSDIMAGES 256
#define OGL_CMDQUEUE_SIZE 100

class cOglThread:public cThread
{
  private:
    cCondWait * startWait;
    cCondWait *wait;
    bool stalled;
     std::queue < cOglCmd * >commands;
    GLint maxTextureSize;
    sOglImage imageCache[OGL_MAX_OSDIMAGES];
    long memCached;
    long maxCacheSize;
    bool InitOpenGL(void);
    bool InitShaders(void);
    void DeleteShaders(void);
    bool InitVdpauInterop(void);
    bool InitVertexBuffers(void);
    void DeleteVertexBuffers(void);
    void Cleanup(void);
    int GetFreeSlot(void);
    void ClearSlot(int slot);
  protected:
     virtual void Action(void);
  public:
     cOglThread(cCondWait * startWait, int maxCacheSize);
     virtual ~ cOglThread();
    void Stop(void);
    void DoCmd(cOglCmd * cmd);
    int StoreImage(const cImage & image);
    void DropImageData(int imageHandle);
    sOglImage *GetImageRef(int slot);
    int MaxTextureSize(void)
    {
        return maxTextureSize;
    };
};

/****************************************************************************************
* cOglPixmap
****************************************************************************************/
class cOglPixmap:public cPixmap
{
  private:
    cOglFb * fb;
    std::shared_ptr < cOglThread > oglThread;
    bool dirty;
  public:
     cOglPixmap(std::shared_ptr < cOglThread > oglThread, int Layer, const cRect & ViewPort, const cRect & DrawPort =
        cRect::Null);
     virtual ~ cOglPixmap(void);
    cOglFb *Fb(void)
    {
        return fb;
    };
    int X(void)
    {
        return ViewPort().X();
    };
    int Y(void)
    {
        return ViewPort().Y();
    };
    virtual bool IsDirty(void)
    {
        return dirty;
    }
    virtual void SetDirty(bool dirty = true) {
        this->dirty = dirty;
    }
    virtual void SetAlpha(int Alpha);
    virtual void SetTile(bool Tile);
    virtual void SetViewPort(const cRect & Rect);
    virtual void SetDrawPortPoint(const cPoint & Point, bool Dirty = true);
    virtual void Clear(void);
    virtual void Fill(tColor Color);
    virtual void DrawImage(const cPoint & Point, const cImage & Image);
    virtual void DrawImage(const cPoint & Point, int ImageHandle);
    virtual void DrawPixel(const cPoint & Point, tColor Color);
    virtual void DrawBitmap(const cPoint & Point, const cBitmap & Bitmap, tColor ColorFg = 0, tColor ColorBg =
        0, bool Overlay = false);
    virtual void DrawText(const cPoint & Point, const char *s, tColor ColorFg, tColor ColorBg, const cFont * Font,
        int Width = 0, int Height = 0, int Alignment = taDefault);
    virtual void DrawRectangle(const cRect & Rect, tColor Color);
    virtual void DrawEllipse(const cRect & Rect, tColor Color, int Quadrants = 0);
    virtual void DrawSlope(const cRect & Rect, tColor Color, int Type);
    virtual void Render(const cPixmap * Pixmap, const cRect & Source, const cPoint & Dest);
    virtual void Copy(const cPixmap * Pixmap, const cRect & Source, const cPoint & Dest);
    virtual void Scroll(const cPoint & Dest, const cRect & Source = cRect::Null);
    virtual void Pan(const cPoint & Dest, const cRect & Source = cRect::Null);
};

/******************************************************************************
* cOglOsd
******************************************************************************/
class cOglOsd:public cOsd
{
  private:
    cOglFb * bFb;
    std::shared_ptr < cOglThread > oglThread;
    cVector < cOglPixmap * >oglPixmaps;
    bool isSubtitleOsd;
  protected:
  public:
     cOglOsd(int Left, int Top, uint Level, std::shared_ptr < cOglThread > oglThread);
     virtual ~ cOglOsd();
    virtual eOsdError SetAreas(const tArea * Areas, int NumAreas);
    virtual cPixmap *CreatePixmap(int Layer, const cRect & ViewPort, const cRect & DrawPort = cRect::Null);
    virtual void DestroyPixmap(cPixmap * Pixmap);
    virtual void Flush(void);
    virtual void DrawScaledBitmap(int x, int y, const cBitmap & Bitmap, double FactorX, double FactorY,
        bool AntiAlias = false);
    static cOglOutputFb *oFb;
};

#endif //__SOFTHDDEVICE_OPENGLOSD_H