videodevicepool.cpp

Go to the documentation of this file.

/*
    videodevicepool.cpp  -  Kopete Video Device Low-level Support

    Copyright (c) 2005-2006 by Cláudio da Silveira Pinheiro   <taupter@gmail.com>
    Copyright (c) 2010      by Frank Schaefer                 <fschaefer.oss@googlemail.com>

    Kopete    (c) 2002-2003      by the Kopete developers  <kopete-devel@kde.org>

    *************************************************************************
    *                                                                       *
    * This library is free software; you can redistribute it and/or         *
    * modify it under the terms of the GNU Lesser General Public            *
    * License as published by the Free Software Foundation; either          *
    * version 2 of the License, or (at your option) any later version.      *
    *                                                                       *
    *************************************************************************
*/

#define ENABLE_AV

#include <assert.h>
#include <cstdlib>
#include <cerrno>
#include <cstring>

#include <kdebug.h>
#include <klocale.h>
#include <kglobal.h>
#include <kconfig.h>
#include <kconfiggroup.h>
#include <qapplication.h>
#include <qdir.h>
#include <solid/device.h>
#include <solid/devicenotifier.h>
#include <solid/deviceinterface.h>
#include <solid/video.h>


#include "videodevice.h"
#include "videodevicepool.h"

#define CLEAR(x) memset (&(x), 0, sizeof (x))

namespace Kopete {

namespace AV {

VideoDevicePool *VideoDevicePool::s_self = NULL;
__u64 VideoDevicePool::m_clients = 0;

VideoDevicePool* VideoDevicePool::self()
{
    kDebug() << "called";
    if (s_self == NULL)
    {
        kDebug() << "Generated new instance.";
        s_self = new VideoDevicePool;
        if (s_self)
            m_clients = 0;
    }
    return s_self;
}

VideoDevicePool::VideoDevicePool()
: QObject(qApp), m_current_device(-1)
{
    connect( Solid::DeviceNotifier::instance(), SIGNAL(deviceAdded(QString)), SLOT(deviceAdded(QString)) );
    connect( Solid::DeviceNotifier::instance(), SIGNAL(deviceRemoved(QString)), SLOT(deviceRemoved(QString)) );
    /* NOTE: No locking needed as long as we don't connect with Qt::ConnectionType = Qt::DirectConnection
             while the signals are emitted by other threads
     */
    foreach( Solid::Device device, Solid::Device::listFromType(Solid::DeviceInterface::Video, QString()) )
        registerDevice( device );
}

VideoDevicePool::~VideoDevicePool()
{
    s_self = 0L;
    foreach ( VideoDevice* vd, m_videodevices )
        delete vd;
}



bool VideoDevicePool::isOpen()
{
    if ((m_current_device >= 0) && (m_current_device < m_videodevices.size()))
        return m_videodevices[m_current_device]->isOpen();
    else
        return false;
}

int VideoDevicePool::open( int device )
{
    kDebug() << "called with device" << device;
    if (!m_videodevices.size() || (device >= m_videodevices.size()))
    {
        kDebug() << "Device not found.";
        return EXIT_FAILURE;
    }
    if (device < 0)
    {
        kDebug() << "Trying to load saved device.";
        device = getSavedDevice();
        if (device < 0)
        {
            if (m_current_device < 0)
                device = 0;
            else
                device = m_current_device;
            kDebug() << "Saved device is not available, using default device:" << device;
        }
    }
    int isopen = EXIT_FAILURE;
    if ((device != m_current_device) || !isOpen())
    {
        if (isOpen())
        {
            if (EXIT_SUCCESS == m_videodevices[m_current_device]->close())
                m_clients--;
            else
                return EXIT_FAILURE;
        }
        isopen = m_videodevices[device]->open();
        if (isopen == EXIT_SUCCESS)
        {
            m_current_device = device;
            loadDeviceConfig(); // Load and apply device parameters
            m_clients++;
        }
    }
    else
    {
        isopen = EXIT_SUCCESS;
        m_clients++;
    }
    kDebug() << "Number of clients: " << m_clients;
    return isopen;
}

int VideoDevicePool::close()
{
    int ret = EXIT_FAILURE;
    if ((m_current_device < 0) || (m_current_device >= m_videodevices.size()))
    {
        kDebug() << "Current device out of range.";
    }
    else if (!m_clients)
    {
        ret = EXIT_SUCCESS;
    }
    else if (m_clients > 1)
    {
        m_clients--;
        kDebug() << "The video device is still in use:" << m_clients << "clients";
        ret = EXIT_SUCCESS;
    }
    else
    {
        ret = m_videodevices[m_current_device]->close();
        if (EXIT_SUCCESS == ret)
            m_clients--;
    }
    return ret;
}



int VideoDevicePool::size()
{
    return m_videodevices.size();
}

int VideoDevicePool::currentDevice()
{
    if (m_videodevices.size())
        return m_current_device;
    else    // to be sure...
        return -1;
}

QString VideoDevicePool::currentDeviceUdi()
{
    if ((m_current_device >= 0) && (m_current_device < m_videodevices.size()))
        return m_videodevices[m_current_device]->udi();
    else
        return QString();
}

int VideoDevicePool::inputs()
{
    if ((m_current_device >= 0) && (m_current_device < m_videodevices.size()))
        return m_videodevices[m_current_device]->inputs();
    else
        return 0;
}

int VideoDevicePool::currentInput()
{
    if ((m_current_device >= 0) && (m_current_device < m_videodevices.size()))
        return m_videodevices[m_current_device]->currentInput();
    else
        return -1;
}

int VideoDevicePool::selectInput( int input )
{
    kDebug() << "called with input" << input;
    if ((m_current_device >= 0) && (m_current_device < m_videodevices.size()))
        return m_videodevices[m_current_device]->selectInput(input);
    else
        return EXIT_FAILURE;
}



QList<NumericVideoControl> VideoDevicePool::getSupportedNumericControls()
{
    if ((m_current_device >= 0) && (m_current_device < m_videodevices.size()))
        return m_videodevices[m_current_device]->getSupportedNumericControls();
    else
        return QList<NumericVideoControl>();
}

QList<BooleanVideoControl> VideoDevicePool::getSupportedBooleanControls()
{
    if ((m_current_device >= 0) && (m_current_device < m_videodevices.size()))
        return m_videodevices[m_current_device]->getSupportedBooleanControls();
    else
        return QList<BooleanVideoControl>();
}

QList<MenuVideoControl> VideoDevicePool::getSupportedMenuControls()
{
    if ((m_current_device >= 0) && (m_current_device < m_videodevices.size()))
        return m_videodevices[m_current_device]->getSupportedMenuControls();
    else
        return QList<MenuVideoControl>();
}

QList<ActionVideoControl> VideoDevicePool::getSupportedActionControls()
{
    if ((m_current_device >= 0) && (m_current_device < m_videodevices.size()))
        return m_videodevices[m_current_device]->getSupportedActionControls();
    else
        return QList<ActionVideoControl>();
}

int VideoDevicePool::getControlValue( quint32 ctrl_id, qint32 * value )
{
    if ((m_current_device >= 0) && (m_current_device < m_videodevices.size()))
        return m_videodevices[m_current_device]->getControlValue(ctrl_id, value);
    else
        return EXIT_FAILURE;
}

int VideoDevicePool::setControlValue( quint32 ctrl_id, qint32 value )
{
    if ((m_current_device >= 0) && (m_current_device < m_videodevices.size()))
        return m_videodevices[m_current_device]->setControlValue(ctrl_id, value);
    else
        return EXIT_FAILURE;
}



int VideoDevicePool::startCapturing()
{
    kDebug() << "startCapturing() called.";
    if ((m_current_device >= 0) && (m_current_device < m_videodevices.size()))
        return m_videodevices[m_current_device]->startCapturing();
    else
        return EXIT_FAILURE;
}


int VideoDevicePool::stopCapturing()
{
    if ((m_current_device >= 0) && (m_current_device < m_videodevices.size()))
        return m_videodevices[m_current_device]->stopCapturing();
    else
        return EXIT_FAILURE;
}

int VideoDevicePool::getFrame()
{
//  kDebug() << "VideoDevicePool::getFrame() called.";
    if ((m_current_device >= 0) && (m_current_device < m_videodevices.size()))
        return m_videodevices[m_current_device]->getFrame();
    else
        return EXIT_FAILURE;
}

int VideoDevicePool::getImage( QImage *qimage )
{
//  kDebug() << "VideoDevicePool::getImage() called.";
    if ((m_current_device >= 0) && (m_current_device < m_videodevices.size()))
        return m_videodevices[m_current_device]->getImage(qimage);
    else
        return EXIT_FAILURE;
}



int VideoDevicePool::width()
{
    if ((m_current_device >= 0) && (m_current_device < m_videodevices.size()))
        return m_videodevices[m_current_device]->width();
    else
        return 0;
}

int VideoDevicePool::minWidth()
{
    if ((m_current_device >= 0) && (m_current_device < m_videodevices.size()))
        return m_videodevices[m_current_device]->minWidth();
    else
        return 0;
}

int VideoDevicePool::maxWidth()
{
    if ((m_current_device >= 0) && (m_current_device < m_videodevices.size()))
        return m_videodevices[m_current_device]->maxWidth();
    else
        return 0;
}

int VideoDevicePool::height()
{
    if ((m_current_device >= 0) && (m_current_device < m_videodevices.size()))
        return m_videodevices[m_current_device]->height();
    else
        return 0;
}

int VideoDevicePool::minHeight()
{
    if ((m_current_device >= 0) && (m_current_device < m_videodevices.size()))
        return m_videodevices[m_current_device]->minHeight();
    else
        return 0;
}

int VideoDevicePool::maxHeight()
{
    if ((m_current_device >= 0) && (m_current_device < m_videodevices.size()))
        return m_videodevices[m_current_device]->maxHeight();
    else
        return 0;
}

int VideoDevicePool::setImageSize( int newwidth, int newheight )
{
    if ((m_current_device >= 0) && (m_current_device < m_videodevices.size()))
        return m_videodevices[m_current_device]->setSize(newwidth, newheight);
    else
        return EXIT_FAILURE;
}



void VideoDevicePool::fillDeviceKComboBox( KComboBox *combobox )
{
    kDebug() << "Called.";
    if (combobox == NULL)
        return;
    combobox->clear();
    if (m_videodevices.size())
    {
        for (int loop = 0; loop < m_videodevices.size(); loop++)
        {
            combobox->addItem(m_videodevices[loop]->m_name);
            kDebug() << "Added device" << loop << ":  " << m_videodevices[loop]->m_name;
        }
        combobox->setCurrentIndex(m_current_device);
    }
    combobox->setEnabled(m_videodevices.size());
}

void VideoDevicePool::fillInputKComboBox( KComboBox *combobox )
{
    kDebug() << "Called.";
    if (combobox == NULL)
        return;
    combobox->clear();
    if ((m_current_device >= 0) && (m_current_device < m_videodevices.size()))
    {
        if (m_videodevices[m_current_device]->inputs() > 0)
        {
            for (int loop = 0; loop < m_videodevices[m_current_device]->inputs(); loop++)
            {
                combobox->addItem(m_videodevices[m_current_device]->m_input[loop].name);
                kDebug() << "Added input" << loop << ":  " << m_videodevices[m_current_device]->m_input[loop].name
                         << " (tuner: " << m_videodevices[m_current_device]->m_input[loop].hastuner << ")";
            }
            combobox->setCurrentIndex(m_videodevices[m_current_device]->currentInput());
        }
    }
    combobox->setEnabled(combobox->count());
}

void VideoDevicePool::fillStandardKComboBox( KComboBox *combobox )
{
    kDebug() << "Called.";
    if (combobox == NULL)
        return;
    combobox->clear();
    if ((m_current_device >= 0) && (m_current_device < m_videodevices.size()))
    {
        if (m_videodevices[m_current_device]->inputs() > 0)
        {
            for (unsigned int loop = 0; loop < 25; loop++)
            {
                if (m_videodevices[m_current_device]->m_input[currentInput()].m_standards & (1 << loop))
                {
                    combobox->addItem(m_videodevices[m_current_device]->signalStandardName(1 << loop));
                    kDebug() << "Added signal standard" << loop << ":  " << m_videodevices[m_current_device]->signalStandardName(1 << loop);
                }
                  
            }
            combobox->setCurrentIndex(0);   // FIXME: set to actual signal standard
        }  
    }
    combobox->setEnabled(combobox->count());
}



int VideoDevicePool::getSavedDevice()
{
    kDebug() << "called";
    if (m_videodevices.size())
    {
        KConfigGroup config(KGlobal::config(), "Video Device Settings");
        QString currentdevice = config.readEntry("Current Device", QString());
        kDebug() << "Device name:" << config.readEntry( QString::fromLocal8Bit( "Device %1 Name" ).arg( currentdevice ), QString("NOT SAVED") );
        if (!currentdevice.isEmpty())
        {
            kDebug() << "Saved device:" << currentdevice;
            QVector<VideoDevice*>::iterator vditerator;
            for( vditerator = m_videodevices.begin(); vditerator != m_videodevices.end(); ++vditerator )
            {
                if ((*vditerator)->udi() == currentdevice)
                {
                    int devIndex = std::distance (m_videodevices.begin(), vditerator);
                    kDebug() << "Saved device is available, device index is" << devIndex;
                    return devIndex;
                }
            }
            kDebug() << "Saved device is not available.";
        }
        else
            kDebug() << "No device saved.";
    }
    return -1;
}

void VideoDevicePool::loadDeviceConfig()
{
    kDebug() << "called";
    if ((m_current_device >= 0) && (m_current_device < m_videodevices.size()))
    {
        KConfigGroup config(KGlobal::config(), "Video Device Settings");
        // Load input and apply
        const QString key_currentinput = QString::fromLocal8Bit( "Device %1 Current Input" ).arg( m_videodevices[m_current_device]->udi() );
        const int currentinput = config.readEntry(key_currentinput, 0);
        kDebug() << "Setting input to" << currentinput;
        if (currentinput != m_videodevices[m_current_device]->currentInput())
            m_videodevices[m_current_device]->selectInput(currentinput);
        // Load video-controls and apply
        quint32 ctrl_id;
        qint32 ctrl_value;
        QString ctrl_key;
        bool ok = false;
        const QString key_control_start = QString::fromLocal8Bit( "Device %1 Input %2 Control " ).arg( m_videodevices[m_current_device]->udi() ).arg( m_videodevices[m_current_device]->currentInput() );
        QStringList ctrl_keys = config.keyList().filter(key_control_start);
        kDebug() << "Found" << ctrl_keys.size() << "saved values for video-controls";
        foreach (ctrl_key, ctrl_keys)
        {
            ctrl_id = QString(ctrl_key).remove(key_control_start).toUInt(&ok);
            if (ok)
            {
                /* NOTE: we do not read the value as int with readEntry() directly
                  because it doesn't tell us if the saved value was valid.
                  If not, we do NOT apply a standard value.
                */
                QString tmpstr = config.readEntry(ctrl_key, QString());
                ctrl_value = tmpstr.toInt(&ok);
                if (ok && !tmpstr.isEmpty())
                {
                    kDebug() << "Setting control" << ctrl_id << "to value" << ctrl_value;
                    m_videodevices[m_current_device]->setControlValue(ctrl_id, ctrl_value);
                }
                else
                    kDebug() << "Saved value for control" << ctrl_id << "is invalid:" << tmpstr;
            }
            else
                kDebug() << "Invalid key:" << ctrl_key;
        }
    }
    /* TODO: load and apply signal standard */
}

void VideoDevicePool::saveCurrentDeviceConfig()
{
    kDebug() << "called";
    if ((m_current_device >= 0) && (m_current_device < m_videodevices.size()))
    {
        KConfigGroup config(KGlobal::config(), "Video Device Settings");
        // Save current device:
        kDebug() << "Current device:" << m_videodevices[m_current_device]->udi();
        config.writeEntry( "Current Device", m_videodevices[m_current_device]->udi() );
        // Save current device name (for debugging only):
        kDebug() << "Current device name:" << m_videodevices[m_current_device]->m_name;
        const QString name = QString::fromLocal8Bit( "Device %1 Name" ).arg( m_videodevices[m_current_device]->udi() );
        config.writeEntry( name, m_videodevices[m_current_device]->m_name );
        // Open device if closed:
        bool wasClosed = false;
        if (!m_videodevices[m_current_device]->isOpen())
        {
            kDebug() << "Device is currently closed, will be opened.";
            wasClosed = true;
            if (EXIT_SUCCESS != m_videodevices[m_current_device]->open())
            {
                kDebug() << "Failed to open the device. Saving aborted.";
                config.sync();
                return;
            }
        }
        // Save current input:
        kDebug() << "Current input:" << m_videodevices[m_current_device]->currentInput();
        const QString key_currentinput = QString::fromLocal8Bit( "Device %1 Current Input" ).arg( m_videodevices[m_current_device]->udi() );
        config.writeEntry( key_currentinput, m_videodevices[m_current_device]->currentInput() );
        // --- Save values of the controls ---:
        qint32 ctrl_value;
        const QString key_control_start = QString::fromLocal8Bit( "Device %1 Input %2 Control " ).arg( m_videodevices[m_current_device]->udi() ).arg( m_videodevices[m_current_device]->currentInput() );
        // Save values of the numeric controls:
        QList<NumericVideoControl> numCtrls = m_videodevices[m_current_device]->getSupportedNumericControls();
        NumericVideoControl numCtrl;
        foreach (numCtrl, numCtrls)
        {
            if (EXIT_SUCCESS == m_videodevices[m_current_device]->getControlValue(numCtrl.id, &ctrl_value))
            {
                kDebug() << "Numeric control:" << numCtrl.id << "value" << ctrl_value;
                config.writeEntry( key_control_start + QString::number(numCtrl.id), ctrl_value );
            }
            else
                kDebug() << "Error: couldn't get current value for numeric control" << numCtrl.id;
        }
        // Save values of the boolean controls:
        QList<BooleanVideoControl> boolCtrls = m_videodevices[m_current_device]->getSupportedBooleanControls();
        BooleanVideoControl boolCtrl;
        foreach (boolCtrl, boolCtrls)
        {
            if (EXIT_SUCCESS == m_videodevices[m_current_device]->getControlValue(boolCtrl.id, &ctrl_value))
            {
                kDebug() << "Boolean control:" << boolCtrl.id << "value" << ctrl_value;
                config.writeEntry( key_control_start + QString::number(boolCtrl.id), ctrl_value );
            }
            else
                kDebug() << "Error: couldn't get current value for boolean control" << numCtrl.id;
        }
        // Save values of the menu controls:
        QList<MenuVideoControl> menuCtrls = m_videodevices[m_current_device]->getSupportedMenuControls();
        MenuVideoControl menuCtrl;
        foreach (menuCtrl, menuCtrls)
        {
            if (EXIT_SUCCESS == m_videodevices[m_current_device]->getControlValue(menuCtrl.id, &ctrl_value))
            {
                kDebug() << "Menu-control:" << menuCtrl.id << "value" << ctrl_value;
                config.writeEntry( key_control_start + QString::number(menuCtrl.id), ctrl_value );
            }
            else
                kDebug() << "Error: couldn't get current value for menu-control" << numCtrl.id;
        }
        // NOTE: Action-video-controls don't have values, so there is nothing to save.
        // Close device again (if it was closed before):
        if (wasClosed)
        {
            if (EXIT_SUCCESS == m_videodevices[m_current_device]->close())
                kDebug() << "Device successfully closed.";
            else
                kDebug() << "Error: failed to close the device.";
        }
        config.sync();
    }
    /* TODO: save signal standard */
}

int VideoDevicePool::showDeviceCapabilities(int device)
{
    if (device < 0)
        device = m_current_device;
    if ((device >= 0) && (device < m_videodevices.size()))
        return m_videodevices[device]->showDeviceCapabilities();
    else
        return EXIT_FAILURE;
}



void VideoDevicePool::deviceAdded( const QString & udi )
{
    kDebug() << "called with UDI" << udi;
    Solid::Device dev( udi );
    if ( dev.is<Solid::Video>() )
    {
        kDebug() << "Device is a video device, trying to register it.";
        if ( registerDevice( dev ) )
            emit deviceRegistered( udi );
    }
    else
        kDebug() << "Device is not a video device";
}

void VideoDevicePool::deviceRemoved( const QString & udi )
{
    kDebug() << "called with UDI" << udi;
    int i = 0;
    foreach ( VideoDevice* vd, m_videodevices )
    {
        if ( vd->udi() == udi )
        {
            kDebug() << "Video device with UDI" << udi << "has been removed!";
            delete m_videodevices[i]; // NOTE: device is closed in destructor
            m_videodevices.remove( i );
            if (m_current_device == i)
            {
                if (m_videodevices.size())
                    m_current_device = 0;
                else
                    m_current_device = -1;
                m_clients = 0;
            }
            else if (m_current_device > i)
            {
                m_current_device--;
            }
            emit deviceUnregistered( udi );
            return;
        }
        else
            i++;
    }
}

bool VideoDevicePool::registerDevice( Solid::Device & device )
{
    kDebug() << "called, UDI is:\n   " << device.udi();
    const Solid::Device * vendorDevice = &device;
    while (vendorDevice->isValid() && vendorDevice->vendor().isEmpty())
        vendorDevice = new Solid::Device(vendorDevice->parentUdi());
    /* NOTE: The device we register has usually an empty vendor string and a less meaningfull product string.
       So we go up to the first parent device that has a non-empty vendor string,
       because we find the expected strings describing the device there.
     */
    if (vendorDevice->isValid())
        kDebug() << "vendor:" << vendorDevice->vendor() << ", product:" << vendorDevice->product();
    else
        kDebug() << "vendor:" << device.vendor() << ", product:" << device.product();
 
    if (device.isValid())
    {
        Solid::Video * solidVideoDevice = device.as<Solid::Video>();
        if (solidVideoDevice)
        {
            QStringList protocols = solidVideoDevice->supportedProtocols();
            if (protocols.contains("video4linux"))
            {
                QStringList drivers = solidVideoDevice->supportedDrivers("video4linux");
                if (drivers.contains("video4linux"))
                {
                    VideoDevice* videodevice = new VideoDevice;
                    videodevice->setUdi( device.udi() );
                    videodevice->setFileName(solidVideoDevice->driverHandle("video4linux").toString());
                    kDebug() << "V4L device path is" << solidVideoDevice->driverHandle("video4linux").toString();
                    if (EXIT_SUCCESS == videodevice->open())
                    {
                        bool cap = videodevice->canCapture();
                        videodevice->close();
                        if (cap)
                        {
                            if (m_videodevices.size() == 0)
                                m_current_device = 0;
                            m_videodevices.push_back(videodevice);
                            kDebug() << "Device is a valid video device, adding it to video device pool.";
                            return true;
                        }
                        else
                            kDebug() << "Device does not support capturing.";
                    }
                    else
                        kDebug() << "Device could not be opened.";
                    delete videodevice;
                }
            }
        }
        else
            kDebug() << "Device is not a video device.";
    }
    else
        kDebug() << "Not a valid Solid device: device is not available in the system.";
    return false;
}

} // namespace AV

} // namespace Kopete