softhddevice-drm-gles.cpp

Go to the documentation of this file.

// SPDX-License-Identifier: AGPL-3.0-or-later
 
#include <libintl.h>
 
#include <vdr/player.h>
#include <vdr/plugin.h>
 
#include "logger.h"
 
#include "softhddevice-drm-gles.h"
 
#include "config.h"
#include "mediaplayer.h"
#include "softhddevice.h"
#include "softhdmenu.h"
#include "softhdsetupmenu.h"
 
/*****************************************************************************
 * Static variables
 ****************************************************************************/
static const char *const VERSION = "1.6.7" GIT_DESCRIBE;    
 
static const char *const DESCRIPTION = trNOOP("A software and GPU emulated HD device");
 
static const char *const MAINMENUENTRY = trNOOP("Softhddevice");
 
cSoftHdMenu *cSoftHdMenu::pSoftHdMenu = NULL;  
 
/*****************************************************************************
 * cPluginSoftHdDevice
 ****************************************************************************/
 
cPluginSoftHdDevice::cPluginSoftHdDevice(void)
{
    m_pConfig = new cSoftHdConfig();
    m_pDevice = new cSoftHdDevice(m_pConfig); // no need to delete m_pDevice, because VDR does it for us
}
 
cPluginSoftHdDevice::~cPluginSoftHdDevice(void)
{
    delete m_pConfig;
}
 
const char *cPluginSoftHdDevice::Version(void)
{
    return VERSION;
}
 
const char *cPluginSoftHdDevice::Description(void)
{
    return tr(DESCRIPTION);
}
 
const char *cPluginSoftHdDevice::CommandLineHelp(void)
{
    return "  -a device\taudio device (e.g. alsa: hw:0,0)\n"
           "  -c channel\taudio mixer channel name (e.g. PCM)\n"
           "  -o device\tdrm device (e.g. /dev/dri/card0)\n"
           "  -d resolution\tdisplay resolution (e.g. 1920x1080@50)\n"
           "  -g resolution\tosd resolution (e.g. 1920x1080)\n"
           "  -D start in detached state\n"
           "  -w workaround\tenable/disable workarounds\n"
#ifdef USE_GLES
           "\tdisable-ogl-osd disable openGL osd\n"
#endif
           "\tdisable-pip disable picture-in-picture\n"
           "\n";
}
 
bool cPluginSoftHdDevice::ProcessArgs(int argc, char *argv[])
{
//  LOGDEBUG("plugin: %s:", __FUNCTION__);
 
    //
    // Parse arguments.
    //
 
    for (;;) {
#ifdef USE_GLES
        switch (getopt(argc, argv, "-a:c:o:x:d:g:Dw:")) {
#else
        switch (getopt(argc, argv, "-a:c:o:x:d:g:D")) {
#endif
        case 'a':           // audio device for pcm
            m_pConfig->ConfigAudioPCMDevice = optarg;
            continue;
        case 'c':           // channel of audio mixer
            m_pConfig->ConfigAudioMixerChannel = optarg;
            continue;
        case 'o':           // set display drm device
            m_pConfig->ConfigDrmDevice = optarg;
            continue;
        case 'x':           // set display drm connector
            m_pConfig->ConfigDrmConnector = optarg;
            continue;
        case 'd': {         // set display output
            m_pConfig->ConfigDisplayResolution = optarg;
            int w = 0;
            int h = 0;
            double rate = 0.0;
            if (sscanf(m_pConfig->ConfigDisplayResolution, "%dx%d@%lf", &w, &h, &rate) != 3) {
                fprintf(stderr, gettext("Wring argument for option '%c'\n"), optopt);
                return 0;
            }
            m_pConfig->UserSetDrmMode = { w, h, rate, false };
            continue;
        }
        case 'g':           // set osd (rendering) size
            m_pConfig->ConfigOsdResolution = optarg;
            continue;
        case 'D':           // start plugin in detached state
            m_pDevice->SetStartDetached();
            continue;
        case 'w':           // workarounds
            if (!strcasecmp("disable-pip", optarg)) {
                m_pDevice->SetDisablePip();
#ifdef USE_GLES
            } else if (!strcasecmp("disable-ogl-osd", optarg)) {
                m_pDevice->SetDisableOglOsd();
#endif
            } else {
                fprintf(stderr, gettext("Workaround '%s' unsupported\n"),
                optarg);
                return 0;
            }
            continue;
        case EOF:
            break;
        case '-':
            fprintf(stderr, gettext("We need no long options\n"));
            return 0;
        case ':':
            fprintf(stderr, gettext("Missing argument for option '%c'\n"), optopt);
            return 0;
        default:
            fprintf(stderr, gettext("Unknown option '%c'\n"), optopt);
            return 0;
        }
        break;
    }
 
    while (optind < argc) {
        fprintf(stderr, gettext("Unhandled argument '%s'\n"), argv[optind++]);
    }
 
    return 1;
}
 
bool cPluginSoftHdDevice::Initialize(void)
{
//  LOGDEBUG("plugin: %s:", __FUNCTION__);
 
    return m_pDevice->Initialize();
}
 
bool cPluginSoftHdDevice::Start(void)
{
//  LOGDEBUG("plugin: %s:", __FUNCTION__);
 
    return m_pDevice->Start();
}
 
void cPluginSoftHdDevice::Stop(void)
{
    //LOGDEBUG("plugin: %s:", __FUNCTION__);
 
    m_pDevice->Stop();
}
 
const char *cPluginSoftHdDevice::MainMenuEntry(void)
{
    //LOGDEBUG("plugin: %s:", __FUNCTION__);
 
    return m_pConfig->ConfigHideMainMenuEntry ? NULL : tr(MAINMENUENTRY);
}
 
cOsdObject *cPluginSoftHdDevice::MainMenuAction(void)
{
    //LOGDEBUG("plugin: %s:", __FUNCTION__);
 
    return new cSoftHdMenu("SoftHdDevice", m_pDevice);
}
 
cMenuSetupPage *cPluginSoftHdDevice::SetupMenu(void)
{
    //LOGDEBUG("plugin: %s:", __FUNCTION__);
 
    return new cMenuSetupSoft(m_pDevice);
}
 
/*****************************************************************************
 * cPluginSoftHdDevice - Setup parameters
 ****************************************************************************/
 
bool cPluginSoftHdDevice::SetupParse(const char *name, const char *value)
{
    return m_pConfig->SetupParse(name, value);
}
 
bool cPluginSoftHdDevice::Service(const char *id, void *data)
{
    //LOGDEBUG("plugin: %s: id %s", __FUNCTION__, id);
    (void)id;
    (void)data;
 
    return false;
}
 
/*****************************************************************************
 * cPluginSoftHdDevice - SVDRP
 ****************************************************************************/
 
static const char *SVDRPHelpText[] = {
    "PLAY Url\n" "    Play the media from the given url.\n",
    "DETA\n" "        Detach the plugin.\n",
    "ATTA\n" "        Attach the plugin.\n",
    "STAT\n" "        Get attached/detached status.\n"
    "    ATTACHED -> 910\n"
    "    DETACHED -> 911\n",
    "PION\n" "        Enable picture-in-picture.\n",
    "PIOF\n" "        Disable picture-in-picture.\n",
    "PITO\n" "        Toggle picture-in-picture.\n",
    "PIPU\n" "        Pip channel up.\n",
    "PIPD\n" "        Pip channel down.\n",
    "PIPC\n" "        Pip swap channels.\n",
    "PIPS\n" "        Pip switch main stream to pip channel and close pip.\n",
    "PIIP\n" "        Pip swap positions.\n",
    NULL
};
 
const char **cPluginSoftHdDevice::SVDRPHelpPages(void)
{
    return SVDRPHelpText;
}
 
cString cPluginSoftHdDevice::SVDRPCommand(const char *command, const char *option, int &reply_code)
{
    // mediaplayer
    if (!strcasecmp(command, "PLAY")) {
        LOGDEBUG2(L_MEDIA, "plugin: %s: SVDRPCommand: %s %s", __FUNCTION__, command, option);
        cControl::Launch(new cSoftHdControl(option, m_pDevice));
        return "PLAY url";
    }
 
    // attach/detach
    if (!strcasecmp(command, "DETA")) {
        LOGDEBUG("plugin: %s: SVDRPCommand: %s %s", __FUNCTION__, command, option);
        if (m_pDevice->IsDetached())
            return "SoftHdDevice is already detached";
 
        m_pDevice->Detach();
        return "Detached SoftHdDevice";
    }
    if (!strcasecmp(command, "ATTA")) {
        LOGDEBUG("plugin: %s: SVDRPCommand: %s %s", __FUNCTION__, command, option);
        if (!m_pDevice->IsDetached())
            return "SoftHdDevice is not detached";
 
        m_pDevice->Attach();
        return "Attached SoftHdDevice";
    }
    if (!strcasecmp(command, "STAT")) {
        LOGDEBUG("plugin: %s: SVDRPCommand: %s %s", __FUNCTION__, command, option);
        if (!m_pDevice->IsDetached()) {
            reply_code = 910;
            return "SoftHdDevice is attached";
        } else {
            reply_code = 911;
            return "SoftHdDevice is detached";
        }
    }
 
    // pip
    if (m_pDevice->UsePip()) {
        if (!strcasecmp(command, "PION")) {
            LOGDEBUG("plugin: %s: SVDRPCommand: %s %s", __FUNCTION__, command, option);
            if (m_pDevice->PipIsEnabled())
                return "Pip is already enabled";
 
            m_pDevice->PipEnable();
            return "Pip was enabled";
        }
        if (!strcasecmp(command, "PIOF")) {
            LOGDEBUG("plugin: %s: SVDRPCommand: %s %s", __FUNCTION__, command, option);
            if (!m_pDevice->PipIsEnabled())
                return "Pip isn't enabled";
 
            m_pDevice->PipDisable();
            return "Pip was disabled";
        }
        if (!strcasecmp(command, "PITO")) {
            LOGDEBUG("plugin: %s: SVDRPCommand: %s %s", __FUNCTION__, command, option);
            if (!m_pDevice->PipIsEnabled()) {
                m_pDevice->PipEnable();
                return "Pip was enabled";
            } else {
                m_pDevice->PipDisable();
                return "Pip was disabled";
            }
        }
        if (!strcasecmp(command, "PIPU")) {
            LOGDEBUG("plugin: %s: SVDRPCommand: %s %s", __FUNCTION__, command, option);
            if (!m_pDevice->PipIsEnabled())
                return "Pip isn't enabled";
 
            m_pDevice->PipChannelChange(1);
            return "Pip channel up";
        }
        if (!strcasecmp(command, "PIPD")) {
            LOGDEBUG("plugin: %s: SVDRPCommand: %s %s", __FUNCTION__, command, option);
            if (!m_pDevice->PipIsEnabled())
                return "Pip isn't enabled";
 
            m_pDevice->PipChannelChange(-1);
            return "Pip channel down";
        }
        if (!strcasecmp(command, "PIPC")) {
            LOGDEBUG("plugin: %s: SVDRPCommand: %s %s", __FUNCTION__, command, option);
            if (!m_pDevice->PipIsEnabled())
                return "Pip isn't enabled";
 
            m_pDevice->PipChannelSwap(false);
            return "Pip swap channels";
        }
        if (!strcasecmp(command, "PIPS")) {
            LOGDEBUG("plugin: %s: SVDRPCommand: %s %s", __FUNCTION__, command, option);
            if (!m_pDevice->PipIsEnabled())
                return "Pip isn't enabled";
 
            m_pDevice->PipChannelSwap(true);
            return "Pip switch main stream to pip channel and close pip";
        }
        if (!strcasecmp(command, "PIPP")) {
            LOGDEBUG("plugin: %s: SVDRPCommand: %s %s", __FUNCTION__, command, option);
            if (!m_pDevice->PipIsEnabled())
                return "Pip isn't enabled";
 
            m_pDevice->PipSwapPosition();
            return "Pip swap position";
        }
    }
 
    return NULL;
}
 
VDRPLUGINCREATOR(cPluginSoftHdDevice);  // Don't touch this!