osdprovider.cpp

Go to the documentation of this file.

// SPDX-License-Identifier: AGPL-3.0-or-later
 
#include "dummyosd.h"
#include "logger.h"
#ifdef USE_GLES
#include "openglosd.h"
#endif
#include "device.h"
#include "softosd.h"
#include "osdprovider.h"
 
/*****************************************************************************
 * OSD provider
 ****************************************************************************/
 
cDeviceOsdProvider::cDeviceOsdProvider(cOutputDevice *device)
    : cOsdProvider(),
      m_pDevice(device)
{
    LOGDEBUG2(L_OSD, "osdprovider: %s:", __FUNCTION__);
}
 
cDeviceOsdProvider::~cDeviceOsdProvider()
{
    LOGDEBUG2(L_OSD, "osdprovider %s:", __FUNCTION__);
 
    if (m_pDevice->IsOsdProviderSet()) {
        m_pDevice->ResetOsdProvider();
#ifdef USE_GLES
        if (!m_pDevice->OglOsdIsDisabled())
            StopOpenGlThread();
#endif
    }
}
 
cOsd *cDeviceOsdProvider::CreateOsd(int left, int top, uint level)
{
#ifdef USE_GLES
    if (m_pDevice->IsDetached()) {
        LOGDEBUG("osdprovider: %s: %d, %d, %d, device detached, using dummy osd", __FUNCTION__, left, top, level);
        return m_pOsd = new cDummyOsd(left, top, level);
    }
 
    if (m_pDevice->OglOsdIsDisabled()) {
        LOGDEBUG("osdprovider: %s: %d, %d, %d, OpenGL disabled, using software rendering", __FUNCTION__, left, top, level);
        return m_pOsd = new cSoftOsd(left, top, level, m_pDevice);
    }
 
    if (StartOpenGlThread()) {
        LOGDEBUG2(L_OSD, "osdprovider: %s: %d, %d, %d, using OpenGL OSD support", __FUNCTION__, left, top, level);
        return m_pOsd = new cOglOsd(left, top, level, m_pOglThread, m_pDevice);
    }
 
    LOGDEBUG("osdprovider: %s: %d, %d, %d, OpenGL failed, using software rendering", __FUNCTION__, left, top, 999);
    m_pDevice->SetDisableOglOsd();
    return m_pOsd = new cSoftOsd(left, top, 999, m_pDevice);
#else
    if (m_pDevice->IsDetached()) {
        LOGDEBUG("osdprovider: %s: %d, %d, %d, device detached, using dummy osd", __FUNCTION__, left, top, level);
        return m_pOsd = new cDummyOsd(left, top, level);
    }
 
    LOGDEBUG2(L_OSD, "osdprovider: %s: %d, %d, %d", __FUNCTION__, left, top, level);
    return m_pOsd = new cSoftOsd(left, top, level, m_pDevice);
#endif
}
 
#ifdef USE_GLES
void cDeviceOsdProvider::OsdSizeChanged(void) {
    // cleanup OpenGL context
    if (!m_pDevice->OglOsdIsDisabled())
        cDeviceOsdProvider::StopOpenGlThread();
    cDeviceOsdProvider::UpdateOsdSize();
}
 
bool cDeviceOsdProvider::StartOpenGlThread(void) {
    if (m_pDevice->OglOsdIsDisabled()) {
        LOGDEBUG2(L_OPENGL, "osdprovider: %s: OpenGL OSD disabled, OpenGL worker thread NOT started", __FUNCTION__);
        return false;
    }
 
    if (m_pOglThread.get()) {
        if (m_pOglThread->Active()) {
            return true;
        }
        m_pOglThread.reset();
    }
    cCondWait wait;
    LOGDEBUG2(L_OPENGL, "osdprovider: %s: Trying to start OpenGL worker thread", __FUNCTION__);
    m_pOglThread.reset(new cOglThread(&wait, m_pDevice->MaxSizeGPUImageCache(), m_pDevice));
    wait.Wait();
 
    if (m_pOglThread->Active()) {
        LOGINFO("OpenGL worker thread started");
        return true;
    }
 
    LOGDEBUG2(L_OPENGL, "osdprovider: %s: OpenGL worker thread NOT started", __FUNCTION__);
    return false;
}
 
void cDeviceOsdProvider::RequestStopOpenGlThread(void) {
    if (m_pOglThread) {
        LOGDEBUG2(L_OPENGL, "osdprovider: %s: request stopping OpenGL worker thread", __FUNCTION__);
        m_pOglThread->RequestStop();
    }
}
 
void cDeviceOsdProvider::StopOpenGlThread(void) {
    if (m_pOglThread) {
        LOGDEBUG2(L_OPENGL, "osdprovider: %s: stop OpenGL worker thread", __FUNCTION__);
        m_pOglThread->Stop();
    }
    m_pOglThread.reset();
}
 
bool cDeviceOsdProvider::LockOpenGlThread(void) {
    if (m_pOglThread) {
        LOGDEBUG2(L_OPENGL, "osdprovider: %s: lock OpenGL worker thread", __FUNCTION__);
        m_pOglThread->LockOutputFb();
        return true;
    }
 
    return false;
}
 
void cDeviceOsdProvider::UnlockOpenGlThread(void) {
    if (m_pOglThread) {
        LOGDEBUG2(L_OPENGL, "osdprovider: %s: unlock OpenGL worker thread", __FUNCTION__);
        m_pOglThread->UnlockOutputFb();
    }
}
 
int cDeviceOsdProvider::StoreImageData(const cImage &Image)
{
    if (StartOpenGlThread()) {
        int imgHandle = m_pOglThread->StoreImage(Image);
        return imgHandle;
    }
    return 0;
}
 
const cImage *cDeviceOsdProvider::GetImageData(int ImageHandle) {
    return cOsdProvider::GetImageData(ImageHandle);
}
 
void cDeviceOsdProvider::DropImageData(int imgHandle)
{
    if (StartOpenGlThread())
        m_pOglThread->DropImageData(imgHandle);
}
#endif