vdr-plugin-softhdcuvid/openglosd.cpp

#define __STL_CONFIG_H
#include "openglosd.h"
#include <algorithm>

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

void ConvertColor(const GLint &colARGB, glm::vec4 &col) {
    col.a = ((colARGB & 0xFF000000) >> 24) / 255.0;
    col.r = ((colARGB & 0x00FF0000) >> 16) / 255.0;
    col.g = ((colARGB & 0x0000FF00) >> 8) / 255.0;
    col.b = ((colARGB & 0x000000FF)) / 255.0;
}

/****************************************************************************************
 * cShader
 ****************************************************************************************/

#ifdef CUVID
const char *glversion = "#version 330 core ";
#else
const char *glversion = "#version 300 es  ";
#endif

const char *rectVertexShader = "%s\n \
\
layout (location = 0) in vec2 position; \
out vec4 rectCol; \
uniform vec4 inColor; \
uniform mat4 projection; \
\
void main() \
{ \
    gl_Position = projection * vec4(position.x, position.y, 0.0, 1.0); \
    rectCol = inColor; \
} \
";

const char *rectFragmentShader = "%s\n \
\
precision mediump float; \
in vec4 rectCol; \
out vec4 color; \
\
void main() \
{ \
    color = rectCol; \
} \
";

const char *textureVertexShader = "%s\n \
\
layout (location = 0) in vec2 position; \
layout (location = 1) in vec2 texCoords; \
\
out vec2 TexCoords; \
out vec4 alphaValue;\
\
uniform mat4 projection; \
uniform vec4 alpha; \
\
void main() \
{ \
    gl_Position = projection * vec4(position.x, position.y, 0.0, 1.0); \
    TexCoords = texCoords; \
    alphaValue = alpha; \
} \
";

const char *textureFragmentShader = "%s\n \
precision mediump float; \
in vec2 TexCoords; \
in vec4 alphaValue; \
out vec4 color; \
\
uniform sampler2D screenTexture; \
\
void main() \
{ \
	color = texture(screenTexture, TexCoords) * alphaValue; \
} \
";

const char *textVertexShader = "%s\n \
\
layout (location = 0) in vec2 position; \
layout (location = 1) in vec2 texCoords; \
\
out vec2 TexCoords; \
out vec4 textColor; \
\
uniform mat4 projection; \
uniform vec4 inColor; \
\
void main() \
{ \
    gl_Position = projection * vec4(position.x, position.y, 0.0, 1.0); \
    TexCoords = texCoords; \
    textColor = inColor; \
} \
";

const char *textFragmentShader = "%s\n \
precision mediump float; \
in vec2 TexCoords; \
in vec4 textColor; \
\
out vec4 color; \
\
uniform sampler2D glyphTexture; \
\
void main() \
{  \
    vec4 sampled = vec4(1.0, 1.0, 1.0, texture(glyphTexture, TexCoords).r); \
    color = textColor * sampled; \
} \
";

///
/// GLX check error.
///
#define GlxCheck(void)                                                                                                \
    {                                                                                                                 \
        GLenum err;                                                                                                   \
                                                                                                                      \
        if ((err = glGetError()) != GL_NO_ERROR) {                                                                    \
            esyslog("video/glx: error %s:%d %d '%s'\n", __FILE__, __LINE__, err, gluErrorString(err));                \
        }                                                                                                             \
    }

static cShader *Shaders[stCount];

void cShader::Use(void) { glUseProgram(id); }

bool cShader::Load(eShaderType type) {
    this->type = type;

    const char *vertexCode = NULL;
    const char *fragmentCode = NULL;

    switch (type) {
        case stRect:
            vertexCode = rectVertexShader;
            fragmentCode = rectFragmentShader;
            break;
        case stTexture:
            vertexCode = textureVertexShader;
            fragmentCode = textureFragmentShader;
            break;
        case stText:
            vertexCode = textVertexShader;
            fragmentCode = textFragmentShader;
            break;
        default:
            esyslog("[softhddev]unknown shader type\n");
            break;
    }

    if (vertexCode == NULL || fragmentCode == NULL) {
        esyslog("[softhddev]ERROR reading shader\n");
        return false;
    }

    if (!Compile(vertexCode, fragmentCode)) {
        esyslog("[softhddev]ERROR compiling shader\n");
        return false;
    }
    return true;
}

void cShader::SetFloat(const GLchar *name, GLfloat value) { glUniform1f(glGetUniformLocation(id, name), value); }

void cShader::SetInteger(const GLchar *name, GLint value) { glUniform1i(glGetUniformLocation(id, name), value); }

void cShader::SetVector2f(const GLchar *name, GLfloat x, GLfloat y) {
    glUniform2f(glGetUniformLocation(id, name), x, y);
}

void cShader::SetVector3f(const GLchar *name, GLfloat x, GLfloat y, GLfloat z) {
    glUniform3f(glGetUniformLocation(id, name), x, y, z);
}

void cShader::SetVector4f(const GLchar *name, GLfloat x, GLfloat y, GLfloat z, GLfloat w) {
    glUniform4f(glGetUniformLocation(id, name), x, y, z, w);
}

void cShader::SetMatrix4(const GLchar *name, const glm::mat4 &matrix) {
    glUniformMatrix4fv(glGetUniformLocation(id, name), 1, GL_FALSE, glm::value_ptr(matrix));
}

bool cShader::Compile(const char *vertexCode, const char *fragmentCode) {
    GLuint sVertex, sFragment;
    char *buffer = (char *)malloc(1000);

    // Vertex Shader
    sVertex = glCreateShader(GL_VERTEX_SHADER);
    sprintf(buffer, vertexCode, glversion);
    glShaderSource(sVertex, 1, (const GLchar **)&buffer, NULL);
    glCompileShader(sVertex);
    // esyslog("[softhddev]:SHADER:VERTEX %s\n",vertexCode);
    if (!CheckCompileErrors(sVertex)) {
        free(buffer);
        return false;
    }
    // Fragment Shader
    sFragment = glCreateShader(GL_FRAGMENT_SHADER);
    sprintf(buffer, fragmentCode, glversion);
    glShaderSource(sFragment, 1, (const GLchar **)&buffer, NULL);
    glCompileShader(sFragment);
    // esyslog("[softhddev]:SHADER:FRAGMENT %s\n",fragmentCode);
    if (!CheckCompileErrors(sFragment)) {
        free(buffer);
        return false;
    }
    // link Program
    id = glCreateProgram();
    glAttachShader(id, sVertex);
    glAttachShader(id, sFragment);
    glLinkProgram(id);
    if (!CheckCompileErrors(id, true))
        return false;
    // Delete the shaders as they're linked into our program now and no longer
    // necessery
    glDeleteShader(sVertex);
    glDeleteShader(sFragment);
    free(buffer);
    return true;
}

bool cShader::CheckCompileErrors(GLuint object, bool program) {
    GLint success;
    GLchar infoLog[1024];

    if (!program) {
        glGetShaderiv(object, GL_COMPILE_STATUS, &success);
        if (!success) {
            glGetShaderInfoLog(object, 1024, NULL, infoLog);
            esyslog("\n[softhddev]:SHADER: Compile-time error: Type: %d - \n>%s<\n", type, infoLog);
            return false;
        }
    } else {
        glGetProgramiv(object, GL_LINK_STATUS, &success);
        if (!success) {
            glGetProgramInfoLog(object, 1024, NULL, infoLog);
            esyslog("[softhddev]:SHADER: Link-time error: Type: %d - \n>%s<\n", type, infoLog);
            return false;
        }
    }
    return true;
}

#define KERNING_UNKNOWN (-10000)

/****************************************************************************************
 * cOglGlyph
 ****************************************************************************************/
cOglGlyph::cOglGlyph(FT_ULong charCode, FT_BitmapGlyph ftGlyph) {
    this->charCode = charCode;
    bearingLeft = ftGlyph->left;
    bearingTop = ftGlyph->top;
    width = ftGlyph->bitmap.width;
    height = ftGlyph->bitmap.rows;
    advanceX = ftGlyph->root.advance.x >> 16; // value in 1/2^16 pixel
    LoadTexture(ftGlyph);
}

cOglGlyph::~cOglGlyph(void) {}

int cOglGlyph::GetKerningCache(FT_ULong prevSym) {
    for (int i = kerningCache.Size(); --i > 0;) {
        if (kerningCache[i].prevSym == prevSym)
            return kerningCache[i].kerning;
    }
    return KERNING_UNKNOWN;
}

void cOglGlyph::SetKerningCache(FT_ULong prevSym, int kerning) { kerningCache.Append(tKerning(prevSym, kerning)); }

void cOglGlyph::BindTexture(void) { glBindTexture(GL_TEXTURE_2D, texture); }

void cOglGlyph::LoadTexture(FT_BitmapGlyph ftGlyph) {
    // Disable byte-alignment restriction

    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
    glGenTextures(1, &texture);
    glBindTexture(GL_TEXTURE_2D, texture);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RED, ftGlyph->bitmap.width, ftGlyph->bitmap.rows, 0, GL_RED, GL_UNSIGNED_BYTE,
                 ftGlyph->bitmap.buffer);
    // Set texture options
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glBindTexture(GL_TEXTURE_2D, 0);
    glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
}

extern "C" void GlxInitopengl();
extern "C" void GlxDrawopengl();
extern "C" void GlxDestroy();
extern "C" void makejpg(uint8_t *data, int width, int height);

/****************************************************************************************
 * cOglFont
 ****************************************************************************************/
FT_Library cOglFont::ftLib = 0;

cList<cOglFont> *cOglFont::fonts = 0;
bool cOglFont::initiated = false;

cOglFont::cOglFont(const char *fontName, int charHeight) : name(fontName) {
    size = charHeight;
    height = 0;
    bottom = 0;

    int error = FT_New_Face(ftLib, fontName, 0, &face);

    if (error)
        esyslog("[softhddev]ERROR: failed to open %s!", *name);

    FT_Set_Char_Size(face, 0, charHeight * 64, 0, 0);
    height = (face->size->metrics.ascender - face->size->metrics.descender + 63) / 64;
    bottom = abs((face->size->metrics.descender - 63) / 64);
}

cOglFont::~cOglFont(void) { FT_Done_Face(face); }

cOglFont *cOglFont::Get(const char *name, int charHeight) {
    if (!fonts)
        Init();

    cOglFont *font;

    for (font = fonts->First(); font; font = fonts->Next(font))
        if (!strcmp(font->Name(), name) && charHeight == font->Size()) {
            return font;
        }
    font = new cOglFont(name, charHeight);
    fonts->Add(font);
    return font;
}

void cOglFont::Init(void) {

    if (FT_Init_FreeType(&ftLib)) {
        esyslog("[softhddev]failed to initialize FreeType library!");
        return;
    }
    fonts = new cList<cOglFont>;
    initiated = true;
}

void cOglFont::Cleanup(void) {
    if (!initiated)
        return;
    delete fonts;

    fonts = 0;
    if (ftLib) {
        if (FT_Done_FreeType(ftLib))
            esyslog("failed to deinitialize FreeType library!");
    }
    ftLib = 0;
}

cOglGlyph *cOglFont::Glyph(FT_ULong charCode) const {
    // Non-breaking space:
    if (charCode == 0xA0)
        charCode = 0x20;

    // Lookup in cache:
    for (cOglGlyph *g = glyphCache.First(); g; g = glyphCache.Next(g)) {
        if (g->CharCode() == charCode) {
            return g;
        }
    }

    FT_UInt glyph_index = FT_Get_Char_Index(face, charCode);

    FT_Int32 loadFlags = FT_LOAD_NO_BITMAP;

    // Load glyph image into the slot (erase previous one):
    int error = FT_Load_Glyph(face, glyph_index, loadFlags);

    if (error) {
        esyslog("[softhddev]FT_Error (0x%02x) : %s\n", FT_Errors[error].code, FT_Errors[error].message);
        return NULL;
    }

    FT_Glyph ftGlyph;
    FT_Stroker stroker;

    error = FT_Stroker_New(ftLib, &stroker);
    if (error) {
        esyslog("[softhddev]FT_Stroker_New FT_Error (0x%02x) : %s\n", FT_Errors[error].code, FT_Errors[error].message);
        return NULL;
    }
    float outlineWidth = 0.25f;

    FT_Stroker_Set(stroker, (int)(outlineWidth * 64), FT_STROKER_LINECAP_ROUND, FT_STROKER_LINEJOIN_ROUND, 0);

    error = FT_Get_Glyph(face->glyph, &ftGlyph);
    if (error) {
        esyslog("[softhddev]FT_Get_Glyph FT_Error (0x%02x) : %s\n", FT_Errors[error].code, FT_Errors[error].message);
        return NULL;
    }

    error = FT_Glyph_StrokeBorder(&ftGlyph, stroker, 0, 1);
    if (error) {
        esyslog("[softhddev]FT_Glyph_StrokeBorder FT_Error (0x%02x) : %s\n", FT_Errors[error].code,
                FT_Errors[error].message);
        return NULL;
    }
    FT_Stroker_Done(stroker);

    error = FT_Glyph_To_Bitmap(&ftGlyph, FT_RENDER_MODE_NORMAL, 0, 1);
    if (error) {
        esyslog("[softhddev]FT_Glyph_To_Bitmap FT_Error (0x%02x) : %s\n", FT_Errors[error].code,
                FT_Errors[error].message);
        return NULL;
    }

    cOglGlyph *Glyph = new cOglGlyph(charCode, (FT_BitmapGlyph)ftGlyph);

    glyphCache.Add(Glyph);
    FT_Done_Glyph(ftGlyph);

    return Glyph;
}

int cOglFont::Kerning(cOglGlyph *glyph, FT_ULong prevSym) const {
    int kerning = 0;

    if (glyph && prevSym) {
        kerning = glyph->GetKerningCache(prevSym);
        if (kerning == KERNING_UNKNOWN) {
            FT_Vector delta;
            FT_UInt glyph_index = FT_Get_Char_Index(face, glyph->CharCode());
            FT_UInt glyph_index_prev = FT_Get_Char_Index(face, prevSym);

            FT_Get_Kerning(face, glyph_index_prev, glyph_index, FT_KERNING_DEFAULT, &delta);
            kerning = delta.x / 64;
            glyph->SetKerningCache(prevSym, kerning);
        }
    }
    return kerning;
}

/****************************************************************************************
 * cOglFb
 ****************************************************************************************/
cOglFb::cOglFb(GLint width, GLint height, GLint viewPortWidth, GLint viewPortHeight) {
    initiated = false;
    fb = 0;
    texture = 0;

    this->width = width;
    this->height = height;
    this->viewPortWidth = viewPortWidth;
    this->viewPortHeight = viewPortHeight;
    if (width != viewPortWidth || height != viewPortHeight)
        scrollable = true;
    else
        scrollable = false;
}

cOglFb::~cOglFb(void) {
    if (texture)
        glDeleteTextures(1, &texture);
    if (fb)
        glDeleteFramebuffers(1, &fb);
}

bool cOglFb::Init(void) {
    initiated = true;
    glGenTextures(1, &texture);
    glBindTexture(GL_TEXTURE_2D, texture);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);

    glGenFramebuffers(1, &fb);
    glBindFramebuffer(GL_FRAMEBUFFER, fb);

    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0);

    if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
        esyslog("[softhddev]ERROR: %d Framebuffer is not complete!\n", __LINE__);

        return false;
    }

    return true;
}

void cOglFb::Bind(void) {
    if (!initiated)
        Init();
    glViewport(0, 0, width, height);
    glBindFramebuffer(GL_FRAMEBUFFER, fb);
}

void cOglFb::BindRead(void) { glBindFramebuffer(GL_READ_FRAMEBUFFER, fb); }

void cOglFb::BindWrite(void) { glBindFramebuffer(GL_DRAW_FRAMEBUFFER, fb); }

void cOglFb::Unbind(void) {
    glBindFramebuffer(GL_FRAMEBUFFER, 0);
    glBindTexture(GL_TEXTURE_2D, 0);
}

bool cOglFb::BindTexture(void) {
    if (!initiated)
        return false;
    glBindTexture(GL_TEXTURE_2D, texture);
    return true;
}

void cOglFb::Blit(GLint destX1, GLint destY1, GLint destX2, GLint destY2) {
    glBlitFramebuffer(0, 0, width, height, destX1, destY1, destX2, destY2, GL_COLOR_BUFFER_BIT, GL_NEAREST);
    glFlush();
}

/****************************************************************************************
 * cOglOutputFb
 ****************************************************************************************/
cOglOutputFb::cOglOutputFb(GLint width, GLint height) : cOglFb(width, height, width, height) {
    // surface = 0;
    initiated = false;
    fb = 0;
    texture = 0;
}

cOglOutputFb::~cOglOutputFb(void) {
    // glVDPAUUnregisterSurfaceNV(surface);
    glDeleteTextures(1, &texture);
    glDeleteFramebuffers(1, &fb);
}

bool cOglOutputFb::Init(void) {
    initiated = true;

    glGenTextures(1, &texture);
    glBindTexture(GL_TEXTURE_2D, texture);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);

    glGenFramebuffers(1, &fb);
    glBindFramebuffer(GL_FRAMEBUFFER, fb);
    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0);
    if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
        esyslog("[softhddev]ERROR::cOglOutputFb: Framebuffer is not complete!");
        return false;
    }
    return true;
}

void cOglOutputFb::BindWrite(void) {
    if (!initiated)
        Init();
    glBindFramebuffer(GL_DRAW_FRAMEBUFFER, fb);
}

void cOglOutputFb::Unbind(void) { glBindFramebuffer(GL_FRAMEBUFFER, 0); }

/****************************************************************************************
 * cOglVb
 ****************************************************************************************/
static cOglVb *VertexBuffers[vbCount];

cOglVb::cOglVb(int type) {
    this->type = (eVertexBufferType)type;
    vao = 0;
    vbo = 0;
    sizeVertex1 = 0;
    sizeVertex2 = 0;
    numVertices = 0;
    drawMode = 0;
}

cOglVb::~cOglVb(void) {}

bool cOglVb::Init(void) {

    if (type == vbTexture) {
        // Texture VBO definition
        sizeVertex1 = 2;
        sizeVertex2 = 2;
        numVertices = 6;
        drawMode = GL_TRIANGLES;
        shader = stTexture;
    } else if (type == vbRect) {
        // Rectangle VBO definition
        sizeVertex1 = 2;
        sizeVertex2 = 0;
        numVertices = 4;
        drawMode = GL_TRIANGLE_FAN;
        shader = stRect;
    } else if (type == vbEllipse) {
        // Ellipse VBO definition
        sizeVertex1 = 2;
        sizeVertex2 = 0;
        numVertices = 182;
        drawMode = GL_TRIANGLE_FAN;
        shader = stRect;
    } else if (type == vbSlope) {
        // Slope VBO definition
        sizeVertex1 = 2;
        sizeVertex2 = 0;
        numVertices = 102;
        drawMode = GL_TRIANGLE_FAN;
        shader = stRect;
    } else if (type == vbText) {
        // Text VBO definition
        sizeVertex1 = 2;
        sizeVertex2 = 2;
        numVertices = 6;
        drawMode = GL_TRIANGLES;
        shader = stText;
    }
    glGenVertexArrays(1, &vao);
    glGenBuffers(1, &vbo);
    glBindVertexArray(vao);
    glBindBuffer(GL_ARRAY_BUFFER, vbo);

    glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * (sizeVertex1 + sizeVertex2) * numVertices, NULL, GL_DYNAMIC_DRAW);

    glEnableVertexAttribArray(0);
    glVertexAttribPointer(0, sizeVertex1, GL_FLOAT, GL_FALSE, (sizeVertex1 + sizeVertex2) * sizeof(GLfloat),
                          (GLvoid *)0);
    if (sizeVertex2 > 0) {
        glEnableVertexAttribArray(1);
        glVertexAttribPointer(1, sizeVertex2, GL_FLOAT, GL_FALSE, (sizeVertex1 + sizeVertex2) * sizeof(GLfloat),
                              (GLvoid *)(sizeVertex1 * sizeof(GLfloat)));
    }

    glBindBuffer(GL_ARRAY_BUFFER, 0);
    glBindVertexArray(0);

    return true;
}

void cOglVb::Bind(void) { glBindVertexArray(vao); }

void cOglVb::Unbind(void) { glBindVertexArray(0); }

void cOglVb::ActivateShader(void) { Shaders[shader]->Use(); }

void cOglVb::EnableBlending(void) {
    glEnable(GL_BLEND);
    glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
}

void cOglVb::DisableBlending(void) { glDisable(GL_BLEND); }

void cOglVb::SetShaderColor(GLint color) {
    glm::vec4 col;
    ConvertColor(color, col);
    Shaders[shader]->SetVector4f("inColor", col.r, col.g, col.b, col.a);
}

void cOglVb::SetShaderAlpha(GLint alpha) {
    Shaders[shader]->SetVector4f("alpha", 1.0f, 1.0f, 1.0f, (GLfloat)(alpha) / 255.0f);
}

void cOglVb::SetShaderProjectionMatrix(GLint width, GLint height) {
    glm::mat4 projection = glm::ortho(0.0f, (GLfloat)width, (GLfloat)height, 0.0f, -1.0f, 1.0f);
    Shaders[shader]->SetMatrix4("projection", projection);
}

void cOglVb::SetVertexData(GLfloat *vertices, int count) {
    if (count == 0)
        count = numVertices;
    glBindBuffer(GL_ARRAY_BUFFER, vbo);
    glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(GLfloat) * (sizeVertex1 + sizeVertex2) * count, vertices);
    glBindBuffer(GL_ARRAY_BUFFER, 0);
}

void cOglVb::DrawArrays(int count) {
    if (count == 0)
        count = numVertices;
    glDrawArrays(drawMode, 0, count);
    glFlush();
}

/****************************************************************************************
 * cOpenGLCmd
 ****************************************************************************************/
//------------------ cOglCmdInitOutputFb --------------------
cOglCmdInitOutputFb::cOglCmdInitOutputFb(cOglOutputFb *oFb) : cOglCmd(NULL) { this->oFb = oFb; }

bool cOglCmdInitOutputFb::Execute(void) {
    bool ok = oFb->Init();

    oFb->Unbind();
    return ok;
}

//------------------ cOglCmdInitFb --------------------
cOglCmdInitFb::cOglCmdInitFb(cOglFb *fb, cCondWait *wait) : cOglCmd(fb) { this->wait = wait; }

bool cOglCmdInitFb::Execute(void) {
    bool ok = fb->Init();

    fb->Unbind();
    if (wait)
        wait->Signal();
    return ok;
}

//------------------ cOglCmdDeleteFb --------------------
cOglCmdDeleteFb::cOglCmdDeleteFb(cOglFb *fb) : cOglCmd(fb) {}

bool cOglCmdDeleteFb::Execute(void) {
    if (fb)
        delete fb;

    return true;
}

//------------------ cOglCmdRenderFbToBufferFb --------------------
cOglCmdRenderFbToBufferFb::cOglCmdRenderFbToBufferFb(cOglFb *fb, cOglFb *buffer, GLint x, GLint y, GLint transparency,
                                                     GLint drawPortX, GLint drawPortY)
    : cOglCmd(fb) {
    this->buffer = buffer;
    this->x = (GLfloat)x;
    this->y = (GLfloat)y;
    this->drawPortX = (GLfloat)drawPortX;
    this->drawPortY = (GLfloat)drawPortY;
    this->transparency = transparency;
}

bool cOglCmdRenderFbToBufferFb::Execute(void) {
    GLfloat x2 = x + fb->ViewportWidth();  // right
    GLfloat y2 = y + fb->ViewportHeight(); // bottom

    GLfloat texX1 = drawPortX / (GLfloat)fb->Width();
    GLfloat texY1 = drawPortY / (GLfloat)fb->Height();
    GLfloat texX2 = texX1 + 1.0f;
    GLfloat texY2 = texY1 + 1.0f;

    if (fb->Scrollable()) {
        GLfloat pageHeight = (GLfloat)fb->ViewportHeight() / (GLfloat)fb->Height();

        texX1 = abs(drawPortX) / (GLfloat)fb->Width();
        texY1 = 1.0f - pageHeight - abs(drawPortY) / (GLfloat)fb->Height();
        texX2 = texX1 + (GLfloat)fb->ViewportWidth() / (GLfloat)fb->Width();
        //	  x2 = x + fb->Width();
        texY2 = texY1 + pageHeight;
    }
    GLfloat quadVertices[] = {
        // Pos	  // TexCoords
        x,  y,  texX1, texY2, // left top
        x,  y2, texX1, texY1, // left bottom
        x2, y2, texX2, texY1, // right bottom

        x,  y,  texX1, texY2, // left top
        x2, y2, texX2, texY1, // right bottom
        x2, y,  texX2, texY2  // right top
    };

    VertexBuffers[vbTexture]->ActivateShader();
    VertexBuffers[vbTexture]->SetShaderAlpha(transparency);
    VertexBuffers[vbTexture]->SetShaderProjectionMatrix(buffer->Width(), buffer->Height());

    buffer->Bind();

    if (!fb->BindTexture())
        return false;

    VertexBuffers[vbTexture]->Bind();
    VertexBuffers[vbTexture]->SetVertexData(quadVertices);
    VertexBuffers[vbTexture]->DrawArrays();
    VertexBuffers[vbTexture]->Unbind();
    buffer->Unbind();

    return true;
}

//------------------ cOglCmdCopyBufferToOutputFb --------------------
cOglCmdCopyBufferToOutputFb::cOglCmdCopyBufferToOutputFb(cOglFb *fb, cOglOutputFb *oFb, GLint x, GLint y)
    : cOglCmd(fb) {
    this->oFb = oFb;
    this->x = x;
    this->y = y;
}

extern unsigned char *posd;

bool cOglCmdCopyBufferToOutputFb::Execute(void) {

    pthread_mutex_lock(&OSDMutex);
    fb->BindRead();

    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
    glPixelStorei(GL_PACK_ALIGNMENT, 1);
    if (posd)
        glReadPixels(0, 0, fb->Width(), fb->Height(), GL_RGBA, GL_UNSIGNED_BYTE, posd);
    glFlush();

    pthread_mutex_unlock(&OSDMutex);
    ActivateOsd(oFb->texture, x, y, fb->Width(), fb->Height());
    return true;
}

//------------------ cOglCmdFill --------------------
cOglCmdFill::cOglCmdFill(cOglFb *fb, GLint color) : cOglCmd(fb) { this->color = color; }

bool cOglCmdFill::Execute(void) {
    glm::vec4 col;
    ConvertColor(color, col);
    fb->Bind();
    glClearColor(col.r, col.g, col.b, col.a);
    glClear(GL_COLOR_BUFFER_BIT);
    fb->Unbind();
    return true;
}

//------------------ cOglCmdDrawRectangle --------------------
cOglCmdDrawRectangle::cOglCmdDrawRectangle(cOglFb *fb, GLint x, GLint y, GLint width, GLint height, GLint color)
    : cOglCmd(fb) {
    this->x = x;
    this->y = y;
    this->width = width;
    this->height = height;
    this->color = color;
}

bool cOglCmdDrawRectangle::Execute(void) {
    GLfloat x1 = x;
    GLfloat y1 = y;
    GLfloat x2 = x + width;
    GLfloat y2 = y + height;

    GLfloat vertices[] = {
        x1, y1, // left top
        x2, y1, // right top
        x2, y2, // right bottom
        x1, y2  // left bottom
    };

    VertexBuffers[vbRect]->ActivateShader();
    VertexBuffers[vbRect]->SetShaderColor(color);
    VertexBuffers[vbRect]->SetShaderProjectionMatrix(fb->Width(), fb->Height());

    fb->Bind();
    VertexBuffers[vbRect]->DisableBlending();
    VertexBuffers[vbRect]->Bind();
    VertexBuffers[vbRect]->SetVertexData(vertices);
    VertexBuffers[vbRect]->DrawArrays();
    VertexBuffers[vbRect]->Unbind();
    VertexBuffers[vbRect]->EnableBlending();
    fb->Unbind();

    return true;
}

//------------------ cOglCmdDrawEllipse --------------------
/// quadrants:
///< 0	     draws the entire ellipse
///< 1..4    draws only the first, second, third or fourth quadrant,
///< respectively 5..8    draws the right, top, left or bottom half,
///< respectively -1..-4  draws the inverted part of the given quadrant
cOglCmdDrawEllipse::cOglCmdDrawEllipse(cOglFb *fb, GLint x, GLint y, GLint width, GLint height, GLint color,
                                       GLint quadrants)
    : cOglCmd(fb) {
    this->x = x;
    this->y = y;
    this->width = width;
    this->height = height;
    this->color = color;
    this->quadrants = quadrants;
}

bool cOglCmdDrawEllipse::Execute(void) {
    int numVertices = 0;
    GLfloat *vertices = NULL;

    switch (quadrants) {
        case 0:
            vertices = CreateVerticesFull(numVertices);
            break;
        case 1:
        case 2:
        case 3:
        case 4:
        case -1:
        case -2:
        case -3:
        case -4:
            vertices = CreateVerticesQuadrant(numVertices);
            break;
        case 5:
        case 6:
        case 7:
        case 8:
            vertices = CreateVerticesHalf(numVertices);
            break;
        default:
            break;
    }

    VertexBuffers[vbEllipse]->ActivateShader();
    VertexBuffers[vbEllipse]->SetShaderColor(color);
    VertexBuffers[vbEllipse]->SetShaderProjectionMatrix(fb->Width(), fb->Height());

    // not antialiased
    fb->Bind();
    VertexBuffers[vbEllipse]->DisableBlending();
    VertexBuffers[vbEllipse]->Bind();
    VertexBuffers[vbEllipse]->SetVertexData(vertices, numVertices);
    VertexBuffers[vbEllipse]->DrawArrays(numVertices);
    VertexBuffers[vbEllipse]->Unbind();
    VertexBuffers[vbEllipse]->EnableBlending();
    fb->Unbind();

    delete[] vertices;
    return true;
}

GLfloat *cOglCmdDrawEllipse::CreateVerticesFull(int &numVertices) {
    int size = 364;

    numVertices = size / 2;
    GLfloat radiusX = (GLfloat)width / 2;
    GLfloat radiusY = (GLfloat)height / 2;
    GLfloat *vertices = new GLfloat[size];

    vertices[0] = x + radiusX;
    vertices[1] = y + radiusY;
    for (int i = 0; i <= 180; i++) {
        vertices[2 * i + 2] = x + radiusX + (GLfloat)cos(2 * i * M_PI / 180.0f) * radiusX;
        vertices[2 * i + 3] = y + radiusY - (GLfloat)sin(2 * i * M_PI / 180.0f) * radiusY;
    }
    return vertices;
}

GLfloat *cOglCmdDrawEllipse::CreateVerticesQuadrant(int &numVertices) {
    int size = 94;

    numVertices = size / 2;
    GLfloat radiusX = (GLfloat)width;
    GLfloat radiusY = (GLfloat)height;
    GLint transX = 0;
    GLint transY = 0;
    GLint startAngle = 0;
    GLfloat *vertices = new GLfloat[size];

    switch (quadrants) {
        case 1:
            vertices[0] = x;
            vertices[1] = y + height;
            transY = radiusY;
            break;
        case 2:
            vertices[0] = x + width;
            vertices[1] = y + height;
            transX = radiusX;
            transY = radiusY;
            startAngle = 90;
            break;
        case 3:
            vertices[0] = x + width;
            vertices[1] = y;
            transX = radiusX;
            startAngle = 180;
            break;
        case 4:
            vertices[0] = x;
            vertices[1] = y;
            startAngle = 270;
            break;
        case -1:
            vertices[0] = x + width;
            vertices[1] = y;
            transY = radiusY;
            break;
        case -2:
            vertices[0] = x;
            vertices[1] = y;
            transX = radiusX;
            transY = radiusY;
            startAngle = 90;
            break;
        case -3:
            vertices[0] = x;
            vertices[1] = y + height;
            transX = radiusX;
            startAngle = 180;
            break;
        case -4:
            vertices[0] = x + width;
            vertices[1] = y + height;
            startAngle = 270;
            break;
        default:
            break;
    }
    for (int i = 0; i <= 45; i++) {
        vertices[2 * i + 2] = x + transX + (GLfloat)cos((2 * i + startAngle) * M_PI / 180.0f) * radiusX;
        vertices[2 * i + 3] = y + transY - (GLfloat)sin((2 * i + startAngle) * M_PI / 180.0f) * radiusY;
    }
    return vertices;
}

GLfloat *cOglCmdDrawEllipse::CreateVerticesHalf(int &numVertices) {
    int size = 184;

    numVertices = size / 2;
    GLfloat radiusX = 0.0f;
    GLfloat radiusY = 0.0f;
    GLint transX = 0;
    GLint transY = 0;
    GLint startAngle = 0;
    GLfloat *vertices = new GLfloat[size];

    switch (quadrants) {
        case 5:
            radiusX = (GLfloat)width;
            radiusY = (GLfloat)height / 2;
            vertices[0] = x;
            vertices[1] = y + radiusY;
            startAngle = 270;
            transY = radiusY;
            break;
        case 6:
            radiusX = (GLfloat)width / 2;
            radiusY = (GLfloat)height;
            vertices[0] = x + radiusX;
            vertices[1] = y + radiusY;
            startAngle = 0;
            transX = radiusX;
            transY = radiusY;
            break;
        case 7:
            radiusX = (GLfloat)width;
            radiusY = (GLfloat)height / 2;
            vertices[0] = x + radiusX;
            vertices[1] = y + radiusY;
            startAngle = 90;
            transX = radiusX;
            transY = radiusY;
            break;
        case 8:
            radiusX = (GLfloat)width / 2;
            radiusY = (GLfloat)height;
            vertices[0] = x + radiusX;
            vertices[1] = y;
            startAngle = 180;
            transX = radiusX;
            break;
        default:
            break;
    }
    for (int i = 0; i <= 90; i++) {
        vertices[2 * i + 2] = x + transX + (GLfloat)cos((2 * i + startAngle) * M_PI / 180.0f) * radiusX;
        vertices[2 * i + 3] = y + transY - (GLfloat)sin((2 * i + startAngle) * M_PI / 180.0f) * radiusY;
    }
    return vertices;
}

//------------------ cOglCmdDrawSlope --------------------
/// type:
///< 0: horizontal, rising,  lower
///< 1: horizontal, rising,  upper
///< 2: horizontal, falling, lower
///< 3: horizontal, falling, upper
///< 4: vertical,   rising,  lower
///< 5: vertical,   rising,  upper
///< 6: vertical,   falling, lower
///< 7: vertical,   falling, upper
cOglCmdDrawSlope::cOglCmdDrawSlope(cOglFb *fb, GLint x, GLint y, GLint width, GLint height, GLint color, GLint type)
    : cOglCmd(fb) {
    this->x = x;
    this->y = y;
    this->width = width;
    this->height = height;
    this->color = color;
    this->type = type;
}

bool cOglCmdDrawSlope::Execute(void) {
    bool falling = type & 0x02;
    bool vertical = type & 0x04;

    int steps = 100;

    if (width < 100)
        steps = 25;
    int numVertices = steps + 2;
    GLfloat *vertices = new GLfloat[numVertices * 2];

    switch (type) {
        case 0:
        case 4:
            vertices[0] = (GLfloat)(x + width);
            vertices[1] = (GLfloat)(y + height);
            break;
        case 1:
        case 5:
            vertices[0] = (GLfloat)x;
            vertices[1] = (GLfloat)y;
            break;
        case 2:
        case 6:
            vertices[0] = (GLfloat)x;
            vertices[1] = (GLfloat)(y + height);
            break;
        case 3:
        case 7:
            vertices[0] = (GLfloat)(x + width);
            vertices[1] = (GLfloat)y;
            break;
        default:
            vertices[0] = (GLfloat)(x);
            vertices[1] = (GLfloat)(y);
            break;
    }

    for (int i = 0; i <= steps; i++) {
        GLfloat c = cos(i * M_PI / steps);

        if (falling)
            c = -c;
        if (vertical) {
            vertices[2 * i + 2] = (GLfloat)x + (GLfloat)width / 2.0f + (GLfloat)width * c / 2.0f;
            vertices[2 * i + 3] = (GLfloat)y + (GLfloat)i * ((GLfloat)height) / steps;
        } else {
            vertices[2 * i + 2] = (GLfloat)x + (GLfloat)i * ((GLfloat)width) / steps;
            vertices[2 * i + 3] = (GLfloat)y + (GLfloat)height / 2.0f + (GLfloat)height * c / 2.0f;
        }
    }

    VertexBuffers[vbSlope]->ActivateShader();
    VertexBuffers[vbSlope]->SetShaderColor(color);
    VertexBuffers[vbSlope]->SetShaderProjectionMatrix(fb->Width(), fb->Height());

    // not antialiased
    fb->Bind();
    VertexBuffers[vbSlope]->DisableBlending();
    VertexBuffers[vbSlope]->Bind();
    VertexBuffers[vbSlope]->SetVertexData(vertices, numVertices);
    VertexBuffers[vbSlope]->DrawArrays(numVertices);
    VertexBuffers[vbSlope]->Unbind();
    VertexBuffers[vbSlope]->EnableBlending();
    fb->Unbind();

    delete[] vertices;
    return true;
}

//------------------ cOglCmdDrawText --------------------
cOglCmdDrawText::cOglCmdDrawText(cOglFb *fb, GLint x, GLint y, unsigned int *symbols, GLint limitX, const char *name,
                                 int fontSize, tColor colorText)
    : cOglCmd(fb), fontName(name) {
    this->x = x;
    this->y = y;
    this->limitX = limitX;
    this->colorText = colorText;
    this->fontSize = fontSize;
    this->symbols = symbols;
    this->fontName = name;
}

cOglCmdDrawText::~cOglCmdDrawText(void) { free(symbols); }

bool cOglCmdDrawText::Execute(void) {
    cOglFont *f = cOglFont::Get(*fontName, fontSize);

    if (!f)
        return false;

    VertexBuffers[vbText]->ActivateShader();
    VertexBuffers[vbText]->SetShaderColor(colorText);
    VertexBuffers[vbText]->SetShaderProjectionMatrix(fb->Width(), fb->Height());

    fb->Bind();
    VertexBuffers[vbText]->Bind();

    int xGlyph = x;
    int fontHeight = f->Height();
    int bottom = f->Bottom();
    FT_ULong sym = 0;
    FT_ULong prevSym = 0;
    int kerning = 0;

    for (int i = 0; symbols[i]; i++) {
        sym = symbols[i];
        cOglGlyph *g = f->Glyph(sym);

        if (!g) {
            esyslog("[softhddev]ERROR: could not load glyph %lx", sym);
        }

        if (limitX && xGlyph + g->AdvanceX() > limitX) {
            break;
        }

        kerning = f->Kerning(g, prevSym);
        prevSym = sym;

        GLfloat x1 = xGlyph + kerning + g->BearingLeft();         // left
        GLfloat y1 = y + (fontHeight - bottom - g->BearingTop()); // top
        GLfloat x2 = x1 + g->Width();                             // right
        GLfloat y2 = y1 + g->Height();                            // bottom

        GLfloat vertices[] = {
            x1, y2, 0.0, 1.0, // left bottom
            x1, y1, 0.0, 0.0, // left top
            x2, y1, 1.0, 0.0, // right top

            x1, y2, 0.0, 1.0, // left bottom
            x2, y1, 1.0, 0.0, // right top
            x2, y2, 1.0, 1.0  // right bottom
        };

        g->BindTexture();
        VertexBuffers[vbText]->SetVertexData(vertices);
        VertexBuffers[vbText]->DrawArrays();

        xGlyph += kerning + g->AdvanceX();

        if (xGlyph > fb->Width() - 1)
            break;
    }
    glBindTexture(GL_TEXTURE_2D, 0);
    VertexBuffers[vbText]->Unbind();
    fb->Unbind();
    return true;
}

//------------------ cOglCmdDrawImage --------------------
cOglCmdDrawImage::cOglCmdDrawImage(cOglFb *fb, tColor *argb, GLint width, GLint height, GLint x, GLint y, bool overlay,
                                   double scaleX, double scaleY)
    : cOglCmd(fb) {
    this->argb = argb;
    this->x = x;
    this->y = y;
    this->width = width;
    this->height = height;
    this->overlay = overlay;
    this->scaleX = scaleX;
    this->scaleY = scaleY;
}

cOglCmdDrawImage::~cOglCmdDrawImage(void) { free(argb); }

bool cOglCmdDrawImage::Execute(void) {
    GLuint texture;

#ifdef USE_DRM
    //  pthread_mutex_lock(&OSDMutex);
    GlxDrawopengl(); // here we need the Shared Context for upload
    GlxCheck();
#endif
    glGenTextures(1, &texture);
    glBindTexture(GL_TEXTURE_2D, texture);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, width, height, 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, argb);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glBindTexture(GL_TEXTURE_2D, 0);
    glFlush();
#ifdef USE_DRM
    GlxInitopengl(); // Reset Context
    GlxCheck();
//  pthread_mutex_unlock(&OSDMutex);
#endif

    GLfloat x1 = x;          // left
    GLfloat y1 = y;          // top
    GLfloat x2 = x + width;  // right
    GLfloat y2 = y + height; // bottom

    GLfloat quadVertices[] = {
        x1, y2, 0.0, 1.0, // left bottom
        x1, y1, 0.0, 0.0, // left top
        x2, y1, 1.0, 0.0, // right top

        x1, y2, 0.0, 1.0, // left bottom
        x2, y1, 1.0, 0.0, // right top
        x2, y2, 1.0, 1.0  // right bottom
    };

    VertexBuffers[vbTexture]->ActivateShader();
    VertexBuffers[vbTexture]->SetShaderAlpha(255);
    VertexBuffers[vbTexture]->SetShaderProjectionMatrix(fb->Width(), fb->Height());

    fb->Bind();
    glBindTexture(GL_TEXTURE_2D, texture);
    if (overlay)
        VertexBuffers[vbTexture]->DisableBlending();
    VertexBuffers[vbTexture]->Bind();
    VertexBuffers[vbTexture]->SetVertexData(quadVertices);
    VertexBuffers[vbTexture]->DrawArrays();
    VertexBuffers[vbTexture]->Unbind();
    if (overlay)
        VertexBuffers[vbTexture]->EnableBlending();
    fb->Unbind();
    glBindTexture(GL_TEXTURE_2D, 0);
    glDeleteTextures(1, &texture);

    return true;
}

//------------------ cOglCmdDrawTexture --------------------
cOglCmdDrawTexture::cOglCmdDrawTexture(cOglFb *fb, sOglImage *imageRef, GLint x, GLint y) : cOglCmd(fb) {
    this->imageRef = imageRef;
    this->x = x;
    this->y = y;
}

bool cOglCmdDrawTexture::Execute(void) {
    GLfloat x1 = x;                    // top
    GLfloat y1 = y;                    // left
    GLfloat x2 = x + imageRef->width;  // right
    GLfloat y2 = y + imageRef->height; // bottom

    GLfloat quadVertices[] = {
        // Pos	  // TexCoords
        x1, y1, 0.0f, 0.0f, // left bottom
        x1, y2, 0.0f, 1.0f, // left top
        x2, y2, 1.0f, 1.0f, // right top

        x1, y1, 0.0f, 0.0f, // left bottom
        x2, y2, 1.0f, 1.0f, // right top
        x2, y1, 1.0f, 0.0f  // right bottom
    };

    VertexBuffers[vbTexture]->ActivateShader();
    VertexBuffers[vbTexture]->SetShaderAlpha(255);
    VertexBuffers[vbTexture]->SetShaderProjectionMatrix(fb->Width(), fb->Height());

    fb->Bind();
    glBindTexture(GL_TEXTURE_2D, imageRef->texture);
    VertexBuffers[vbTexture]->Bind();
    VertexBuffers[vbTexture]->SetVertexData(quadVertices);
    VertexBuffers[vbTexture]->DrawArrays();
    VertexBuffers[vbTexture]->Unbind();
    fb->Unbind();

    return true;
}

//------------------ cOglCmdStoreImage --------------------
cOglCmdStoreImage::cOglCmdStoreImage(sOglImage *imageRef, tColor *argb) : cOglCmd(NULL) {
    this->imageRef = imageRef;
    data = argb;
}

cOglCmdStoreImage::~cOglCmdStoreImage(void) { free(data); }

bool cOglCmdStoreImage::Execute(void) {
#ifdef USE_DRM
    //  pthread_mutex_lock(&OSDMutex);
    GlxDrawopengl(); // here we need the Shared Context for upload
    GlxCheck();
#endif
    glGenTextures(1, &imageRef->texture);
    glBindTexture(GL_TEXTURE_2D, imageRef->texture);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, imageRef->width, imageRef->height, 0, GL_BGRA,
                 GL_UNSIGNED_INT_8_8_8_8_REV, data);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glBindTexture(GL_TEXTURE_2D, 0);
    glFlush();
#ifdef USE_DRM
    GlxInitopengl(); // Reset Context
    GlxCheck();
//  pthread_mutex_lock(&OSDMutex);
#endif
    return true;
}

//------------------ cOglCmdDropImage --------------------
cOglCmdDropImage::cOglCmdDropImage(sOglImage *imageRef, cCondWait *wait) : cOglCmd(NULL) {
    this->imageRef = imageRef;
    this->wait = wait;
}

bool cOglCmdDropImage::Execute(void) {
    if (imageRef->texture != GL_NONE)
        glDeleteTextures(1, &imageRef->texture);
    wait->Signal();
    return true;
}

/******************************************************************************
 * cOglThread
 ******************************************************************************/
cOglThread::cOglThread(cCondWait *startWait, int maxCacheSize) : cThread("oglThread") {
    stalled = false;
    memCached = 0;

    this->maxCacheSize = maxCacheSize * 1024 * 1024;
    this->startWait = startWait;
    wait = new cCondWait();
    maxTextureSize = 0;
    for (int i = 0; i < OGL_MAX_OSDIMAGES; i++) {
        imageCache[i].used = false;
        imageCache[i].texture = GL_NONE;
        imageCache[i].width = 0;
        imageCache[i].height = 0;
    }

    Start();
}

cOglThread::~cOglThread() {
    delete wait;

    wait = NULL;
}

void cOglThread::Stop(void) {
    for (int i = 0; i < OGL_MAX_OSDIMAGES; i++) {
        if (imageCache[i].used) {
            DropImageData(i);
        }
    }
    Cancel(2);
    stalled = false;
}

void cOglThread::DoCmd(cOglCmd *cmd) {
    while (stalled)
        cCondWait::SleepMs(10);

    bool doSignal = false;

    Lock();
    if (commands.size() == 0)
        doSignal = true;
    commands.push(cmd);
    Unlock();

    if (commands.size() > OGL_CMDQUEUE_SIZE) {
        stalled = true;
    }

    if (doSignal || stalled)
        wait->Signal();
}

int cOglThread::StoreImage(const cImage &image) {

    if (!maxCacheSize) {
        return 0;
    }

    if (image.Width() > maxTextureSize || image.Height() > maxTextureSize) {
        esyslog("[softhddev] cannot store image of %dpx x %dpx "
                "(maximum size is %dpx x %dpx) - falling back to "
                "cOsdProvider::StoreImageData()",
                image.Width(), image.Height(), maxTextureSize, maxTextureSize);
        return 0;
    }

    int imgSize = image.Width() * image.Height();
    int newMemUsed = imgSize * sizeof(tColor) + memCached;

    if (newMemUsed > maxCacheSize) {
        float cachedMB = memCached / 1024.0f / 1024.0f;
        float maxMB = maxCacheSize / 1024.0f / 1024.0f;

        esyslog("[softhddev]Maximum size for GPU cache reached. Used: %.2fMB Max: "
                "%.2fMB",
                cachedMB, maxMB);
        return 0;
    }

    int slot = GetFreeSlot();

    if (!slot)
        return 0;

    tColor *argb = MALLOC(tColor, imgSize);

    if (!argb) {
        esyslog("[softhddev]memory allocation of %ld kb for OSD image failed", (imgSize * sizeof(tColor)) / 1024);
        ClearSlot(slot);
        slot = 0;
        return 0;
    }

    memcpy(argb, image.Data(), sizeof(tColor) * imgSize);

    sOglImage *imageRef = GetImageRef(slot);

    imageRef->width = image.Width();
    imageRef->height = image.Height();
    DoCmd(new cOglCmdStoreImage(imageRef, argb));

    cTimeMs timer(5000);

    while (imageRef->used && imageRef->texture == 0 && !timer.TimedOut())
        cCondWait::SleepMs(2);

    if (imageRef->texture == GL_NONE) {
        esyslog("[softhddev]failed to store OSD image texture! (%s)",
                timer.TimedOut() ? "timed out" : "allocation failed");
        DropImageData(slot);
        slot = 0;
    }

    memCached += imgSize * sizeof(tColor);
    return slot;
}

int cOglThread::GetFreeSlot(void) {
    Lock();
    int slot = 0;

    for (int i = 0; i < OGL_MAX_OSDIMAGES && !slot; i++) {
        if (!imageCache[i].used) {
            imageCache[i].used = true;
            slot = -i - 1;
        }
    }
    Unlock();
    return slot;
}

void cOglThread::ClearSlot(int slot) {
    int i = -slot - 1;

    if (i >= 0 && i < OGL_MAX_OSDIMAGES) {
        Lock();
        imageCache[i].used = false;
        imageCache[i].texture = GL_NONE;
        imageCache[i].width = 0;
        imageCache[i].height = 0;
        Unlock();
    }
}

sOglImage *cOglThread::GetImageRef(int slot) {
    int i = -slot - 1;

    if (0 <= i && i < OGL_MAX_OSDIMAGES)
        return &imageCache[i];
    return 0;
}

void cOglThread::DropImageData(int imageHandle) {
    sOglImage *imageRef = GetImageRef(imageHandle);

    if (!imageRef)
        return;
    int imgSize = imageRef->width * imageRef->height * sizeof(tColor);

    memCached -= imgSize;
    cCondWait dropWait;

    DoCmd(new cOglCmdDropImage(imageRef, &dropWait));
    dropWait.Wait();
    ClearSlot(imageHandle);
}

void cOglThread::Action(void) {
    if (!InitOpenGL()) {
        esyslog("[softhddev]Could not initiate OpenGL Context");
        Cleanup();
        startWait->Signal();
        return;
    }
    dsyslog("[softhddev]OpenGL Context initialized");

    if (!InitShaders()) {
        esyslog("[softhddev]Could not initiate Shaders");
        Cleanup();
        startWait->Signal();
        return;
    }
    dsyslog("[softhddev]Shaders initialized");

    if (!InitVdpauInterop()) {
        esyslog("[softhddev]: vdpau interop NOT initialized");
        Cleanup();
        startWait->Signal();
        return;
    }
    dsyslog("[softhddev]vdpau interop initialized");

    if (!InitVertexBuffers()) {
        esyslog("[softhddev]: Vertex Buffers NOT initialized");
        Cleanup();
        startWait->Signal();
        return;
    }
    dsyslog("[softhddev]Vertex buffers initialized");

    glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxTextureSize);
    dsyslog("[softhddev]Maximum Pixmap size: %dx%dpx", maxTextureSize, maxTextureSize);

    // now Thread is ready to do his job
    startWait->Signal();
    stalled = false;

    while (Running()) {

        if (commands.empty()) {
            wait->Wait(20);
            continue;
        }

        Lock();
        cOglCmd *cmd = commands.front();

        commands.pop();
        Unlock();
        // uint64_t start = cTimeMs::Now();
        cmd->Execute();
        // esyslog("[softhddev]\"%s\", %dms, %d commands left, time %" PRIu64 "",
        // cmd->Description(), (int)(cTimeMs::Now() - start), commands.size(),
        // cTimeMs::Now());
        delete cmd;

        if (stalled && commands.size() < OGL_CMDQUEUE_SIZE / 2)
            stalled = false;
    }

    dsyslog("[softhddev]Cleaning up OpenGL stuff");
    Cleanup();
    dsyslog("[softhddev]OpenGL Worker Thread Ended");
}

bool cOglThread::InitOpenGL(void) {
#ifdef USE_DRM
    GlxInitopengl();
#else
    const char *displayName = X11DisplayName;

    if (!displayName) {
        displayName = getenv("DISPLAY");
        if (!displayName) {
            displayName = ":0.0";
        }
    }

    dsyslog("[softhddev]OpenGL using display %s", displayName);

    int argc = 3;
    char *buffer[3];

    buffer[0] = strdup("openglosd");
    buffer[1] = strdup("-display");
    buffer[2] = strdup(displayName);

    char **argv = buffer;

    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA | GLUT_ALPHA);
    glutInitWindowSize(1, 1);
    glutInitWindowPosition(0, 0);
    glutCreateWindow("openglosd");
    glutHideWindow();
    free(buffer[0]);
    free(buffer[1]);
    free(buffer[2]);

    GLenum err = glewInit();

    if (err != GLEW_OK) {
        esyslog("[softhddev]glewInit failed:  %s   Using Version: %s\n", glewGetErrorString(err),
                glewGetString(GLEW_VERSION));
        //	  return false;
    }
#endif

    VertexBuffers[vbText]->EnableBlending();
    glDisable(GL_DEPTH_TEST);
    return true;
}

bool cOglThread::InitShaders(void) {
    for (int i = 0; i < stCount; i++) {
        cShader *shader = new cShader();

        if (!shader->Load((eShaderType)i))
            return false;
        Shaders[i] = shader;
    }
    return true;
}

void cOglThread::DeleteShaders(void) {
    for (int i = 0; i < stCount; i++)
        delete Shaders[i];
}

bool cOglThread::InitVdpauInterop(void) {
#if 0
    void *vdpDevice = GetVDPAUDevice();
    void *procAdress = GetVDPAUProcAdress();

    while (glGetError() != GL_NO_ERROR) ;
    glVDPAUInitNV(vdpDevice, procAdress);
    if (glGetError() != GL_NO_ERROR)
	return false;
#endif
    return true;
}

bool cOglThread::InitVertexBuffers(void) {
    for (int i = 0; i < vbCount; i++) {
        cOglVb *vb = new cOglVb(i);

        if (!vb->Init())
            return false;
        VertexBuffers[i] = vb;
    }
    return true;
}

void cOglThread::DeleteVertexBuffers(void) {
    for (int i = 0; i < vbCount; i++) {
        delete VertexBuffers[i];
    }
}

void cOglThread::Cleanup(void) {
    esyslog("[softhddev]OglThread cleanup\n");
    pthread_mutex_lock(&OSDMutex);
    OsdClose();

    DeleteVertexBuffers();
    delete cOglOsd::oFb;

    cOglOsd::oFb = NULL;
    DeleteShaders();
    // glVDPAUFiniNV();
    cOglFont::Cleanup();
#ifndef USE_DRM
    glutExit();
#else
    GlxDestroy();
#endif
    pthread_mutex_unlock(&OSDMutex);
}

/****************************************************************************************
 * cOglPixmap
 ****************************************************************************************/

cOglPixmap::cOglPixmap(std::shared_ptr<cOglThread> oglThread, int Layer, const cRect &ViewPort, const cRect &DrawPort)
    : cPixmap(Layer, ViewPort, DrawPort) {
    this->oglThread = oglThread;
    int width = DrawPort.IsEmpty() ? ViewPort.Width() : DrawPort.Width();
    int height = DrawPort.IsEmpty() ? ViewPort.Height() : DrawPort.Height();

    fb = new cOglFb(width, height, ViewPort.Width(), ViewPort.Height());
    dirty = true;
}

cOglPixmap::~cOglPixmap(void) {
    if (!oglThread->Active())
        return;
    oglThread->DoCmd(new cOglCmdDeleteFb(fb));
}

void cOglPixmap::SetAlpha(int Alpha) {
    Alpha = constrain(Alpha, ALPHA_TRANSPARENT, ALPHA_OPAQUE);
    if (Alpha != cPixmap::Alpha()) {
        cPixmap::SetAlpha(Alpha);
        SetDirty();
    }
}

void cOglPixmap::SetTile(bool Tile) {
    cPixmap::SetTile(Tile);
    SetDirty();
}

void cOglPixmap::SetViewPort(const cRect &Rect) {
    cPixmap::SetViewPort(Rect);
    SetDirty();
}

void cOglPixmap::SetDrawPortPoint(const cPoint &Point, bool Dirty) {
    cPixmap::SetDrawPortPoint(Point, Dirty);
    if (Dirty)
        SetDirty();
}

void cOglPixmap::Clear(void) {
    if (!oglThread->Active())
        return;
    LOCK_PIXMAPS;
    oglThread->DoCmd(new cOglCmdFill(fb, clrTransparent));
    SetDirty();
    MarkDrawPortDirty(DrawPort());
}

void cOglPixmap::Fill(tColor Color) {
    if (!oglThread->Active())
        return;
    LOCK_PIXMAPS;
    oglThread->DoCmd(new cOglCmdFill(fb, Color));
    SetDirty();
    MarkDrawPortDirty(DrawPort());
}

void cOglPixmap::DrawImage(const cPoint &Point, const cImage &Image) {
    if (!oglThread->Active())
        return;
    tColor *argb = MALLOC(tColor, Image.Width() * Image.Height());

    if (!argb)
        return;
    memcpy(argb, Image.Data(), sizeof(tColor) * Image.Width() * Image.Height());

    oglThread->DoCmd(new cOglCmdDrawImage(fb, argb, Image.Width(), Image.Height(), Point.X(), Point.Y()));
    SetDirty();
    MarkDrawPortDirty(cRect(Point, cSize(Image.Width(), Image.Height())).Intersected(DrawPort().Size()));
}

void cOglPixmap::DrawImage(const cPoint &Point, int ImageHandle) {
    if (!oglThread->Active())
        return;

    if (ImageHandle < 0 && oglThread->GetImageRef(ImageHandle)) {
        sOglImage *img = oglThread->GetImageRef(ImageHandle);

        oglThread->DoCmd(new cOglCmdDrawTexture(fb, img, Point.X(), Point.Y()));
    }
    /*
       Fallback to VDR implementation, needs to separate cSoftOsdProvider from
       softhddevice.cpp else { if (cSoftOsdProvider::GetImageData(ImageHandle))
       DrawImage(Point, *cSoftOsdProvider::GetImageData(ImageHandle));
       }
     */
    SetDirty();
    MarkDrawPortDirty(DrawPort());
}

void cOglPixmap::DrawPixel(const cPoint &Point, tColor Color) {
    cRect r(Point.X(), Point.Y(), 1, 1);

    oglThread->DoCmd(new cOglCmdDrawRectangle(fb, r.X(), r.Y(), r.Width(), r.Height(), Color));

    SetDirty();
    MarkDrawPortDirty(r);
}

void cOglPixmap::DrawBitmap(const cPoint &Point, const cBitmap &Bitmap, tColor ColorFg, tColor ColorBg, bool Overlay) {
    if (!oglThread->Active())
        return;
    LOCK_PIXMAPS;
    bool specialColors = ColorFg || ColorBg;
    tColor *argb = MALLOC(tColor, Bitmap.Width() * Bitmap.Height());

    if (!argb)
        return;

    tColor *p = argb;

    for (int py = 0; py < Bitmap.Height(); py++)
        for (int px = 0; px < Bitmap.Width(); px++) {
            tIndex index = *Bitmap.Data(px, py);

            *p++ = (!index && Overlay) ? clrTransparent
                                       : (specialColors ? (index == 0   ? ColorBg
                                                           : index == 1 ? ColorFg
                                                                        : Bitmap.Color(index))
                                                        : Bitmap.Color(index));
        }

    oglThread->DoCmd(new cOglCmdDrawImage(fb, argb, Bitmap.Width(), Bitmap.Height(), Point.X(), Point.Y(), true));
    SetDirty();
    MarkDrawPortDirty(cRect(Point, cSize(Bitmap.Width(), Bitmap.Height())).Intersected(DrawPort().Size()));
}

void cOglPixmap::DrawText(const cPoint &Point, const char *s, tColor ColorFg, tColor ColorBg, const cFont *Font,
                          int Width, int Height, int Alignment) {
    if (!oglThread->Active())
        return;
    LOCK_PIXMAPS;
    int len = s ? Utf8StrLen(s) : 0;
    unsigned int *symbols = MALLOC(unsigned int, len + 1);

    if (!symbols)
        return;

    if (len)
        Utf8ToArray(s, symbols, len + 1);
    else
        symbols[0] = 0;
    int x = Point.X();
    int y = Point.Y();
    int w = Font->Width(s);
    int h = Font->Height();
    int limitX = 0;
    int cw = Width ? Width : w;
    int ch = Height ? Height : h;
    cRect r(x, y, cw, ch);

    if (ColorBg != clrTransparent)
        oglThread->DoCmd(new cOglCmdDrawRectangle(fb, r.X(), r.Y(), r.Width(), r.Height(), ColorBg));

    if (Width || Height) {
        limitX = x + cw;
        if (Width) {
            if ((Alignment & taLeft) != 0) {
                if ((Alignment & taBorder) != 0)
                    x += std::max(h / TEXT_ALIGN_BORDER, 1);
            } else if ((Alignment & taRight) != 0) {
                if (w < Width)
                    x += Width - w;
                if ((Alignment & taBorder) != 0)
                    x -= std::max(h / TEXT_ALIGN_BORDER, 1);
            } else { // taCentered
                if (w < Width)
                    x += (Width - w) / 2;
            }
        }

        if (Height) {
            if ((Alignment & taTop) != 0)
                ;
            else if ((Alignment & taBottom) != 0) {
                if (h < Height)
                    y += Height - h;
            } else { // taCentered
                if (h < Height)
                    y += (Height - h) / 2;
            }
        }
    }
    oglThread->DoCmd(new cOglCmdDrawText(fb, x, y, symbols, limitX, Font->FontName(), Font->Size(), ColorFg));

    SetDirty();
    MarkDrawPortDirty(r);
}

void cOglPixmap::DrawRectangle(const cRect &Rect, tColor Color) {
    if (!oglThread->Active())
        return;
    LOCK_PIXMAPS;
    oglThread->DoCmd(new cOglCmdDrawRectangle(fb, Rect.X(), Rect.Y(), Rect.Width(), Rect.Height(), Color));
    SetDirty();
    MarkDrawPortDirty(Rect);
}

void cOglPixmap::DrawEllipse(const cRect &Rect, tColor Color, int Quadrants) {
    if (!oglThread->Active())
        return;
    LOCK_PIXMAPS;
    oglThread->DoCmd(new cOglCmdDrawEllipse(fb, Rect.X(), Rect.Y(), Rect.Width(), Rect.Height(), Color, Quadrants));
    SetDirty();
    MarkDrawPortDirty(Rect);
}

void cOglPixmap::DrawSlope(const cRect &Rect, tColor Color, int Type) {
    if (!oglThread->Active())
        return;
    LOCK_PIXMAPS;
    oglThread->DoCmd(new cOglCmdDrawSlope(fb, Rect.X(), Rect.Y(), Rect.Width(), Rect.Height(), Color, Type));
    SetDirty();
    MarkDrawPortDirty(Rect);
}

void cOglPixmap::Render(const cPixmap *Pixmap, const cRect &Source, const cPoint &Dest) {
    esyslog("[softhddev] Render %d %d %d not implemented in OpenGl OSD", Pixmap->ViewPort().X(), Source.X(), Dest.X());
}

void cOglPixmap::Copy(const cPixmap *Pixmap, const cRect &Source, const cPoint &Dest) {
    esyslog("[softhddev] Copy %d %d %d not implemented in OpenGl OSD", Pixmap->ViewPort().X(), Source.X(), Dest.X());
}

void cOglPixmap::Scroll(const cPoint &Dest, const cRect &Source) {
    esyslog("[softhddev] Scroll %d %d not implemented in OpenGl OSD", Source.X(), Dest.X());
}

void cOglPixmap::Pan(const cPoint &Dest, const cRect &Source) {
    esyslog("[softhddev] Pan %d %d not implemented in OpenGl OSD", Source.X(), Dest.X());
}

/******************************************************************************
 * cOglOsd
 ******************************************************************************/
cOglOutputFb *cOglOsd::oFb = NULL;

cOglOsd::cOglOsd(int Left, int Top, uint Level, std::shared_ptr<cOglThread> oglThread) : cOsd(Left, Top, Level) {
    this->oglThread = oglThread;
    bFb = NULL;
    isSubtitleOsd = false;
    int osdWidth = 0;
    int osdHeight = 0;

    //    pthread_mutex_lock(&OSDMutex);
    VideoGetOsdSize(&osdWidth, &osdHeight);
    // osdWidth = 1920;
    // osdHeight = 1080;

    dsyslog("[softhddev]cOglOsd osdLeft %d osdTop %d screenWidth %d screenHeight %d", Left, Top, osdWidth, osdHeight);

#if 0
    if (posd)
	free(posd);
    posd = (unsigned char *)calloc(osdWidth * osdHeight * 4, 1);
#endif
    // create output framebuffer

    if (!oFb) {
        oFb = new cOglOutputFb(osdWidth, osdHeight);
        oglThread->DoCmd(new cOglCmdInitOutputFb(oFb));
    }
    //    pthread_mutex_unlock(&OSDMutex);
}

cOglOsd::~cOglOsd() {
    OsdClose();
    SetActive(false);

    oglThread->DoCmd(new cOglCmdDeleteFb(bFb));
}

eOsdError cOglOsd::SetAreas(const tArea *Areas, int NumAreas) {
    cRect r;

    if (NumAreas > 1)
        isSubtitleOsd = true;
    for (int i = 0; i < NumAreas; i++)
        r.Combine(cRect(Areas[i].x1, Areas[i].y1, Areas[i].Width(), Areas[i].Height()));

    tArea area = {r.Left(), r.Top(), r.Right(), r.Bottom(), 32};

    // now we know the actuaL osd size, create double buffer frame buffer
    if (bFb) {
        oglThread->DoCmd(new cOglCmdDeleteFb(bFb));
        DestroyPixmap(oglPixmaps[0]);
    }
    bFb = new cOglFb(r.Width(), r.Height(), r.Width(), r.Height());
    cCondWait initiated;

    oglThread->DoCmd(new cOglCmdInitFb(bFb, &initiated));
    initiated.Wait();

    return cOsd::SetAreas(&area, 1);
}

cPixmap *cOglOsd::CreatePixmap(int Layer, const cRect &ViewPort, const cRect &DrawPort) {
    if (!oglThread->Active())
        return NULL;
    LOCK_PIXMAPS;
    int width = DrawPort.IsEmpty() ? ViewPort.Width() : DrawPort.Width();
    int height = DrawPort.IsEmpty() ? ViewPort.Height() : DrawPort.Height();

    if (width > oglThread->MaxTextureSize() || height > oglThread->MaxTextureSize()) {
        esyslog("[softhddev] cannot allocate pixmap of %dpx x %dpx, clipped to "
                "%dpx x %dpx!",
                width, height, std::min(width, oglThread->MaxTextureSize()),
                std::min(height, oglThread->MaxTextureSize()));
        width = std::min(width, oglThread->MaxTextureSize());
        height = std::min(height, oglThread->MaxTextureSize());
    }

    cOglPixmap *p = new cOglPixmap(oglThread, Layer, ViewPort, DrawPort);

    if (cOsd::AddPixmap(p)) {
        // find free slot
        for (int i = 0; i < oglPixmaps.Size(); i++)
            if (!oglPixmaps[i])
                return oglPixmaps[i] = p;
        // append at end
        oglPixmaps.Append(p);
        return p;
    }
    delete p;

    return NULL;
}

void cOglOsd::DestroyPixmap(cPixmap *Pixmap) {
    if (!oglThread->Active())
        return;
    if (!Pixmap)
        return;

    LOCK_PIXMAPS;
    int start = 1;

    if (isSubtitleOsd)
        start = 0;
    for (int i = start; i < oglPixmaps.Size(); i++) {
        if (oglPixmaps[i] == Pixmap) {
            if (Pixmap->Layer() >= 0)
                oglPixmaps[0]->SetDirty();
            oglPixmaps[i] = NULL;
            cOsd::DestroyPixmap(Pixmap);
            return;
        }
    }
}

void cOglOsd::Flush(void) {
    if (!oglThread->Active())
        return;
    LOCK_PIXMAPS;
    // check if any pixmap is dirty
    bool dirty = false;

    for (int i = 0; i < oglPixmaps.Size() && !dirty; i++)
        if (oglPixmaps[i] && oglPixmaps[i]->Layer() >= 0 && oglPixmaps[i]->IsDirty())
            dirty = true;
    if (!dirty)
        return;
    // clear buffer
    // uint64_t start = cTimeMs::Now();
    // dsyslog("[softhddev]Start Flush at %" PRIu64 "", cTimeMs::Now());

    oglThread->DoCmd(new cOglCmdFill(bFb, clrTransparent));

    // render pixmap textures blended to buffer
    for (int layer = 0; layer < MAXPIXMAPLAYERS; layer++) {
        for (int i = 0; i < oglPixmaps.Size(); i++) {
            if (oglPixmaps[i]) {
                if (oglPixmaps[i]->Layer() == layer) {
                    oglThread->DoCmd(new cOglCmdRenderFbToBufferFb(
                        oglPixmaps[i]->Fb(), bFb, oglPixmaps[i]->ViewPort().X(),
                        (!isSubtitleOsd) ? oglPixmaps[i]->ViewPort().Y() : 0, oglPixmaps[i]->Alpha(),
                        oglPixmaps[i]->DrawPort().X(), oglPixmaps[i]->DrawPort().Y()));
                    oglPixmaps[i]->SetDirty(false);
                }
            }
        }
    }
    oglThread->DoCmd(new cOglCmdCopyBufferToOutputFb(bFb, oFb, Left(), Top()));

    // dsyslog("[softhddev]End Flush at %" PRIu64 ", duration %d", cTimeMs::Now(),
    // (int)(cTimeMs::Now()-start));
}

void cOglOsd::DrawScaledBitmap(int x, int y, const cBitmap &Bitmap, double FactorX, double FactorY, bool AntiAlias) {
    (void)FactorX;
    (void)FactorY;
    (void)AntiAlias;
    int yNew = y - oglPixmaps[0]->ViewPort().Y();

    oglPixmaps[0]->DrawBitmap(cPoint(x, yNew), Bitmap);
}