alsaclient.cpp

Go to the documentation of this file.

/*
    MIDI Sequencer C++ library
    Copyright (C) 2006-2023, Pedro Lopez-Cabanillas <plcl@users.sf.net>
 
    This library is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
 
#include "errorcheck.h"
#include <QCoreApplication>
#include <QFile>
#include <QReadLocker>
#include <QRegularExpression>
#include <QThread>
#include <QWriteLocker>
#include <drumstick/alsaclient.h>
#include <drumstick/alsaevent.h>
#include <drumstick/alsaqueue.h>
 
#if defined(RTKIT_SUPPORT)
#include <QDBusConnection>
#include <QDBusInterface>
#include <sys/resource.h>
#include <sys/syscall.h>
#include <sys/types.h>
#endif
#include <pthread.h>
 
#ifndef RLIMIT_RTTIME
#define RLIMIT_RTTIME 15
#endif
 
#ifndef SCHED_RESET_ON_FORK
#define SCHED_RESET_ON_FORK 0x40000000
#endif
 
#ifndef DEFAULT_INPUT_TIMEOUT
#define DEFAULT_INPUT_TIMEOUT 500
#endif
 
namespace drumstick { namespace ALSA {
 
class MidiClient::SequencerInputThread: public QThread
{
public:
    SequencerInputThread(MidiClient *seq, int timeout)
        : QThread(),
        m_MidiClient(seq),
        m_Wait(timeout),
        m_Stopped(false),
        m_RealTime(true) {}
    virtual ~SequencerInputThread() = default;
    void run() override;
    bool stopped();
    void stop();
    void setRealtimePriority();
 
    MidiClient *m_MidiClient;
    int m_Wait;
    bool m_Stopped;
    bool m_RealTime;
    QReadWriteLock m_mutex;
};
 
class MidiClient::MidiClientPrivate
{
public:
    MidiClientPrivate() :
        m_eventsEnabled(false),
        m_BlockMode(false),
        m_NeedRefreshClientList(true),
        m_OpenMode(SND_SEQ_OPEN_DUPLEX),
        m_DeviceName("default"),
        m_SeqHandle(nullptr),
        m_Thread(nullptr),
        m_Queue(nullptr),
        m_handler(nullptr)
    { }
 
    bool m_eventsEnabled;
    bool m_BlockMode;
    bool m_NeedRefreshClientList;
    int  m_OpenMode;
    QString m_DeviceName;
    snd_seq_t* m_SeqHandle;
    QPointer<SequencerInputThread> m_Thread;
    QPointer<MidiQueue> m_Queue;
    SequencerEventHandler* m_handler;
 
    ClientInfo m_Info;
    ClientInfoList m_ClientList;
    MidiPortList m_Ports;
    PortInfoList m_OutputsAvail;
    PortInfoList m_InputsAvail;
    QObjectList m_listeners;
    SystemInfo m_sysInfo;
    PoolInfo m_poolInfo;
};
 
MidiClient::MidiClient( QObject* parent ) :
    QObject(parent),
    d(new MidiClientPrivate)
{ 
    qRegisterMetaType<drumstick::ALSA::SequencerEvent>();
    qRegisterMetaType<drumstick::ALSA::SequencerEvent*>();
}
 
MidiClient::~MidiClient()
{
    stopSequencerInput();
    detachAllPorts();
    delete d->m_Queue;
    close();
    freeClients();
    delete d->m_Thread;
}
 
snd_seq_t*
MidiClient::getHandle()
{
    return d->m_SeqHandle;
}
 
bool MidiClient::isOpened()
{
    return !d.isNull() && (d->m_SeqHandle != nullptr);
}
 
QString MidiClient::getDeviceName()
{
    return d->m_DeviceName;
}
 
int MidiClient::getOpenMode()
{
    return d->m_OpenMode;
}
 
bool MidiClient::getBlockMode()
{
    return d->m_BlockMode;
}
 
bool MidiClient::getEventsEnabled() const
{
    return d->m_eventsEnabled;
}
 
void MidiClient::setHandler(SequencerEventHandler* handler)
{
    d->m_handler = handler;
}
 
 
void MidiClient::setRealTimeInput(bool enable)
{
    if (d->m_Thread == nullptr) {
        d->m_Thread = new SequencerInputThread(this, DEFAULT_INPUT_TIMEOUT);
        d->m_Thread->m_RealTime = enable;
    }
}
 
bool MidiClient::realTimeInputEnabled()
{
    if (d->m_Thread == nullptr)
        return true;
    return d->m_Thread->m_RealTime;
}
 
void
MidiClient::open( const QString deviceName,
                  const int openMode,
                  const bool blockMode)
{
    DRUMSTICK_ALSA_CHECK_ERROR( snd_seq_open( &d->m_SeqHandle, deviceName.toLocal8Bit().data(),
                              openMode, blockMode ? 0 : SND_SEQ_NONBLOCK ) );
    DRUMSTICK_ALSA_CHECK_WARNING( snd_seq_get_client_info( d->m_SeqHandle, d->m_Info.m_Info ) );
    d->m_DeviceName = deviceName;
    d->m_OpenMode = openMode;
    d->m_BlockMode = blockMode;
}
 
void
MidiClient::open( snd_config_t* conf,
                  const QString deviceName,
                  const int openMode,
                  const bool blockMode )
{
    DRUMSTICK_ALSA_CHECK_ERROR( snd_seq_open_lconf( &d->m_SeqHandle,
                                     deviceName.toLocal8Bit().data(),
                                     openMode,
                                     blockMode ? 0 : SND_SEQ_NONBLOCK,
                                     conf ));
    DRUMSTICK_ALSA_CHECK_WARNING( snd_seq_get_client_info(d->m_SeqHandle, d->m_Info.m_Info));
    d->m_DeviceName = deviceName;
    d->m_OpenMode = openMode;
    d->m_BlockMode = blockMode;
}
 
void
MidiClient::close()
{
    if (d->m_SeqHandle != nullptr) {
        stopSequencerInput();
        DRUMSTICK_ALSA_CHECK_WARNING(snd_seq_close(d->m_SeqHandle));
        d->m_SeqHandle = nullptr;
    }
}
 
size_t
MidiClient::getOutputBufferSize()
{
    return snd_seq_get_output_buffer_size(d->m_SeqHandle);
}
 
void
MidiClient::setOutputBufferSize(size_t newSize)
{
    if (getOutputBufferSize() != newSize) {
        DRUMSTICK_ALSA_CHECK_WARNING(snd_seq_set_output_buffer_size(d->m_SeqHandle, newSize));
    }
}
 
size_t
MidiClient::getInputBufferSize()
{
    return snd_seq_get_input_buffer_size(d->m_SeqHandle);
}
 
void
MidiClient::setInputBufferSize(size_t newSize)
{
    if (getInputBufferSize() != newSize) {
        DRUMSTICK_ALSA_CHECK_WARNING(snd_seq_set_input_buffer_size(d->m_SeqHandle, newSize));
    }
}
 
void
MidiClient::setBlockMode(bool newValue)
{
    if (d->m_BlockMode != newValue)
    {
        d->m_BlockMode = newValue;
        if (d->m_SeqHandle != nullptr)
        {
            DRUMSTICK_ALSA_CHECK_WARNING(snd_seq_nonblock(d->m_SeqHandle, d->m_BlockMode ? 0 : 1));
        }
    }
}
 
int
MidiClient::getClientId()
{
    return DRUMSTICK_ALSA_CHECK_WARNING(snd_seq_client_id(d->m_SeqHandle));
}
 
snd_seq_type_t
MidiClient::getSequencerType()
{
    return snd_seq_type(d->m_SeqHandle);
}
 
void
MidiClient::doEvents()
{
    do {
        int err = 0;
        snd_seq_event_t* evp = nullptr;
        SequencerEvent* event = nullptr;
        err = snd_seq_event_input(d->m_SeqHandle, &evp);
        if ((err >= 0) && (evp != nullptr)) {
            switch (evp->type) {
 
            case SND_SEQ_EVENT_NOTE:
                event = new NoteEvent(evp);
                break;
 
            case SND_SEQ_EVENT_NOTEON:
                event = new NoteOnEvent(evp);
                break;
 
            case SND_SEQ_EVENT_NOTEOFF:
                event = new NoteOffEvent(evp);
                break;
 
            case SND_SEQ_EVENT_KEYPRESS:
                event = new KeyPressEvent(evp);
                break;
 
            case SND_SEQ_EVENT_CONTROLLER:
            case SND_SEQ_EVENT_CONTROL14:
            case SND_SEQ_EVENT_REGPARAM:
            case SND_SEQ_EVENT_NONREGPARAM:
                event = new ControllerEvent(evp);
                break;
 
            case SND_SEQ_EVENT_PGMCHANGE:
                event = new ProgramChangeEvent(evp);
                break;
 
            case SND_SEQ_EVENT_CHANPRESS:
                event = new ChanPressEvent(evp);
                break;
 
            case SND_SEQ_EVENT_PITCHBEND:
                event = new PitchBendEvent(evp);
                break;
 
            case SND_SEQ_EVENT_SYSEX:
                event = new SysExEvent(evp);
                break;
 
            case SND_SEQ_EVENT_PORT_SUBSCRIBED:
            case SND_SEQ_EVENT_PORT_UNSUBSCRIBED:
                event = new SubscriptionEvent(evp);
                break;
 
            case SND_SEQ_EVENT_PORT_CHANGE:
            case SND_SEQ_EVENT_PORT_EXIT:
            case SND_SEQ_EVENT_PORT_START:
                event = new PortEvent(evp);
                d->m_NeedRefreshClientList = true;
                break;
 
            case SND_SEQ_EVENT_CLIENT_CHANGE:
            case SND_SEQ_EVENT_CLIENT_EXIT:
            case SND_SEQ_EVENT_CLIENT_START:
                event = new ClientEvent(evp);
                d->m_NeedRefreshClientList = true;
                break;
 
            case SND_SEQ_EVENT_SONGPOS:
            case SND_SEQ_EVENT_SONGSEL:
            case SND_SEQ_EVENT_QFRAME:
            case SND_SEQ_EVENT_TIMESIGN:
            case SND_SEQ_EVENT_KEYSIGN:
                event = new ValueEvent(evp);
                break;
 
            case SND_SEQ_EVENT_SETPOS_TICK:
            case SND_SEQ_EVENT_SETPOS_TIME:
            case SND_SEQ_EVENT_QUEUE_SKEW:
                event = new QueueControlEvent(evp);
                break;
 
            case SND_SEQ_EVENT_TEMPO:
                event = new TempoEvent(evp);
                break;
 
            default:
                event = new SequencerEvent(evp);
                break;
            }
            // first, process the callback (if any)
            if (d->m_handler != nullptr) {
                d->m_handler->handleSequencerEvent(event->clone());
            } else {
                // second, process the event listeners
                if (d->m_eventsEnabled) {
                   QObjectList::Iterator it;
                    for(it=d->m_listeners.begin(); it!=d->m_listeners.end(); ++it) {
                        QObject* sub = (*it);
                        QCoreApplication::postEvent(sub, event->clone());
                    }
                } else {
                    // finally, process signals
                    Q_EMIT eventReceived(event->clone());
                }
            }
            delete event;
        }
    }
    while (snd_seq_event_input_pending(d->m_SeqHandle, 0) > 0);
}
 
void
MidiClient::startSequencerInput()
{
    if (d->m_Thread == nullptr) {
        d->m_Thread = new SequencerInputThread(this, DEFAULT_INPUT_TIMEOUT);
    }
    d->m_Thread->start( d->m_Thread->m_RealTime ?
            QThread::TimeCriticalPriority : QThread::InheritPriority );
}
 
void
MidiClient::stopSequencerInput()
{
    int counter = 0;
    if (d->m_Thread != nullptr) {
        if (d->m_Thread->isRunning()) {
            d->m_Thread->stop();
            while (!d->m_Thread->wait(500) && (counter < 10)) {
                counter++;
            }
            if (!d->m_Thread->isFinished()) {
                d->m_Thread->terminate();
            }
        }
        delete d->m_Thread;
    }
}
 
void
MidiClient::readClients()
{
    ClientInfo cInfo;
    freeClients();
    cInfo.setClient(-1);
    while (snd_seq_query_next_client(d->m_SeqHandle, cInfo.m_Info) >= 0) {
        cInfo.readPorts(this);
        d->m_ClientList.append(cInfo);
    }
    d->m_NeedRefreshClientList = false;
}
 
void
MidiClient::freeClients()
{
    d->m_ClientList.clear();
}
 
ClientInfoList
MidiClient::getAvailableClients()
{
    if (d->m_NeedRefreshClientList)
        readClients();
    ClientInfoList lst = d->m_ClientList; // copy
    return lst;
}
 
ClientInfo&
MidiClient::getThisClientInfo()
{
    snd_seq_get_client_info(d->m_SeqHandle, d->m_Info.m_Info);
    return d->m_Info;
}
 
void
MidiClient::setThisClientInfo(const ClientInfo& val)
{
    d->m_Info = val;
    snd_seq_set_client_info(d->m_SeqHandle, d->m_Info.m_Info);
}
 
void
MidiClient::applyClientInfo()
{
    if (d->m_SeqHandle != nullptr) {
        snd_seq_set_client_info(d->m_SeqHandle, d->m_Info.m_Info);
    }
}
 
QString
MidiClient::getClientName()
{
    return d->m_Info.getName();
}
 
QString
MidiClient::getClientName(const int clientId)
{
    ClientInfoList::Iterator it;
    if (d->m_NeedRefreshClientList)
        readClients();
    for (it = d->m_ClientList.begin(); it != d->m_ClientList.end(); ++it) {
        if ((*it).getClientId() == clientId) {
            return (*it).getName();
        }
    }
    return QString();
}
 
void
MidiClient::setClientName(QString const& newName)
{
    if (newName != d->m_Info.getName()) {
        d->m_Info.setName(newName);
        applyClientInfo();
    }
}
 
MidiPortList
MidiClient::getMidiPorts() const
{
    return d->m_Ports;
}
 
MidiPort*
MidiClient::createPort()
{
    MidiPort* port = new MidiPort(this);
    port->attach(this);
    return port;
}
 
void
MidiClient::portAttach(MidiPort* port)
{
    if (d->m_SeqHandle != nullptr) {
        DRUMSTICK_ALSA_CHECK_ERROR(snd_seq_create_port(d->m_SeqHandle, port->m_Info.m_Info));
        d->m_Ports.push_back(port);
    }
}
 
void
MidiClient::portDetach(MidiPort* port)
{
    if (d->m_SeqHandle != nullptr) {
        if(port->getPortInfo()->getClient() == getClientId())
        {
            return;
        }
        DRUMSTICK_ALSA_CHECK_ERROR(snd_seq_delete_port(d->m_SeqHandle, port->getPortInfo()->getPort()));
        port->setMidiClient(nullptr);
 
        MidiPortList::iterator it;
        for(it = d->m_Ports.begin(); it != d->m_Ports.end(); ++it)
        {
            if ((*it)->getPortInfo()->getPort() == port->getPortInfo()->getPort())
            {
                d->m_Ports.erase(it);
                break;
            }
        }
    }
}
 
void MidiClient::detachAllPorts()
{
    if (d->m_SeqHandle != nullptr) {
        QMutableListIterator<MidiPort*> it(d->m_Ports);
        while (it.hasNext()) {
            MidiPort* p = it.next();
            DRUMSTICK_ALSA_CHECK_WARNING(snd_seq_delete_port(d->m_SeqHandle, p->getPortInfo()->getPort()));
            p->setMidiClient(nullptr);
            it.remove();
        }
    }
}
 
void
MidiClient::addEventFilter(int evtype)
{
    snd_seq_set_client_event_filter(d->m_SeqHandle, evtype);
}
 
bool
MidiClient::getBroadcastFilter()
{
    return d->m_Info.getBroadcastFilter();
}
 
void
MidiClient::setBroadcastFilter(bool newValue)
{
    d->m_Info.setBroadcastFilter(newValue);
    applyClientInfo();
}
 
bool
MidiClient::getErrorBounce()
{
    return d->m_Info.getErrorBounce();
}
 
void
MidiClient::setErrorBounce(bool newValue)
{
    d->m_Info.setErrorBounce(newValue);
    applyClientInfo();
}
 
void
MidiClient::output(SequencerEvent* ev, bool async, int timeout)
{
    pollfd* pfds = nullptr;
    if (async) {
        DRUMSTICK_ALSA_CHECK_WARNING(snd_seq_event_output(d->m_SeqHandle, ev->getHandle()));
    } else {
        int npfds = snd_seq_poll_descriptors_count(d->m_SeqHandle, POLLOUT);
        pfds = (pollfd*) calloc(npfds, sizeof(pollfd));
        snd_seq_poll_descriptors(d->m_SeqHandle, pfds, npfds, POLLOUT);
        while (snd_seq_event_output(d->m_SeqHandle, ev->getHandle()) < 0)
        {
            poll(pfds, npfds, timeout);
        }
        free(pfds);
    }
}
 
void MidiClient::outputDirect(SequencerEvent* ev, bool async, int timeout)
{
    if (async) {
        DRUMSTICK_ALSA_CHECK_WARNING(snd_seq_event_output_direct(d->m_SeqHandle, ev->getHandle()));
    } else {
        int npfds = snd_seq_poll_descriptors_count(d->m_SeqHandle, POLLOUT);
        pollfd* pfds = (pollfd*) calloc(npfds, sizeof(pollfd));
        snd_seq_poll_descriptors(d->m_SeqHandle, pfds, npfds, POLLOUT);
        while (snd_seq_event_output_direct(d->m_SeqHandle, ev->getHandle()) < 0)
        {
            poll(pfds, npfds, timeout);
        }
        free(pfds);
    }
}
 
void
MidiClient::outputBuffer(SequencerEvent* ev)
{
    DRUMSTICK_ALSA_CHECK_WARNING(snd_seq_event_output_buffer(d->m_SeqHandle, ev->getHandle()));
}
 
void MidiClient::drainOutput(bool async, int timeout)
{
    if (async) {
        DRUMSTICK_ALSA_CHECK_WARNING(snd_seq_drain_output(d->m_SeqHandle));
    } else {
        int npfds = snd_seq_poll_descriptors_count(d->m_SeqHandle, POLLOUT);
        pollfd* pfds = (pollfd*) calloc(npfds, sizeof(pollfd));
        snd_seq_poll_descriptors(d->m_SeqHandle, pfds, npfds, POLLOUT);
        while (snd_seq_drain_output(d->m_SeqHandle) < 0)
        {
            poll(pfds, npfds, timeout);
        }
        free(pfds);
    }
}
 
void
MidiClient::synchronizeOutput()
{
    snd_seq_sync_output_queue(d->m_SeqHandle);
}
 
MidiQueue*
MidiClient::getQueue()
{
    if (d->m_Queue == nullptr) {
        createQueue();
    }
    return d->m_Queue;
}
 
MidiQueue*
MidiClient::createQueue()
{
    if (d->m_Queue != nullptr) {
        delete d->m_Queue;
    }
    d->m_Queue = new MidiQueue(this, this);
    return d->m_Queue;
}
 
MidiQueue*
MidiClient::createQueue(QString const& queueName )
{
    if (d->m_Queue != nullptr) {
        delete d->m_Queue;
    }
    d->m_Queue = new MidiQueue(this, queueName, this);
    return d->m_Queue;
}
 
MidiQueue*
MidiClient::useQueue(int queue_id)
{
    if (d->m_Queue != nullptr) {
        delete d->m_Queue;
    }
    d->m_Queue = new MidiQueue(this, queue_id, this);
    return d->m_Queue;
}
 
MidiQueue*
MidiClient::useQueue(const QString& name)
{
    if (d->m_Queue != nullptr) {
        delete d->m_Queue;
    }
    int queue_id = getQueueId(name);
    if ( queue_id >= 0) {
       d->m_Queue = new MidiQueue(this, queue_id, this);
    }
    return d->m_Queue;
}
 
MidiQueue*
MidiClient::useQueue(MidiQueue* queue)
{
    if (d->m_Queue != nullptr) {
        delete d->m_Queue;
    }
    queue->setParent(this);
    d->m_Queue = queue;
    return d->m_Queue;
}
 
QList<int>
MidiClient::getAvailableQueues()
{
    int q, err, max;
    QList<int> queues;
    snd_seq_queue_info_t* qinfo;
    snd_seq_queue_info_alloca(&qinfo);
    max = getSystemInfo().getMaxQueues();
    for ( q = 0; q < max; ++q ) {
        err = snd_seq_get_queue_info(d->m_SeqHandle, q, qinfo);
        if (err == 0) {
            queues.append(q);
        }
    }
    return queues;
}
 
PortInfoList
MidiClient::filterPorts(unsigned int filter)
{
    PortInfoList result;
    ClientInfoList::ConstIterator itc;
    PortInfoList::ConstIterator itp;
 
    if (d->m_NeedRefreshClientList)
        readClients();
 
    for (itc = d->m_ClientList.constBegin(); itc != d->m_ClientList.constEnd(); ++itc) {
        ClientInfo ci = (*itc);
        if ((ci.getClientId() == SND_SEQ_CLIENT_SYSTEM) ||
            (ci.getClientId() == d->m_Info.getClientId()))
            continue;
        PortInfoList lstPorts = ci.getPorts();
        for(itp = lstPorts.constBegin(); itp != lstPorts.constEnd(); ++itp) {
            PortInfo pi = (*itp);
            unsigned int cap = pi.getCapability();
            if ( ((filter & cap) != 0) &&
                 ((SND_SEQ_PORT_CAP_NO_EXPORT & cap) == 0) ) {
                result.append(pi);
            }
        }
    }
    return result;
}
 
void
MidiClient::updateAvailablePorts()
{
    d->m_InputsAvail.clear();
    d->m_OutputsAvail.clear();
    d->m_InputsAvail = filterPorts( SND_SEQ_PORT_CAP_READ |
                                 SND_SEQ_PORT_CAP_SUBS_READ );
    d->m_OutputsAvail = filterPorts( SND_SEQ_PORT_CAP_WRITE |
                                  SND_SEQ_PORT_CAP_SUBS_WRITE );
}
 
PortInfoList
MidiClient::getAvailableInputs()
{
    d->m_NeedRefreshClientList = true;
    updateAvailablePorts();
    return d->m_InputsAvail;
}
 
PortInfoList
MidiClient::getAvailableOutputs()
{
    d->m_NeedRefreshClientList = true;
    updateAvailablePorts();
    return d->m_OutputsAvail;
}
 
void
MidiClient::addListener(QObject* listener)
{
    d->m_listeners.append(listener);
}
 
void
MidiClient::removeListener(QObject* listener)
{
    d->m_listeners.removeAll(listener);
}
 
void
MidiClient::setEventsEnabled(bool bEnabled)
{
    if (bEnabled != d->m_eventsEnabled) {
        d->m_eventsEnabled = bEnabled;
    }
}
 
SystemInfo&
MidiClient::getSystemInfo()
{
    snd_seq_system_info(d->m_SeqHandle, d->m_sysInfo.m_Info);
    return d->m_sysInfo;
}
 
PoolInfo&
MidiClient::getPoolInfo()
{
    snd_seq_get_client_pool(d->m_SeqHandle, d->m_poolInfo.m_Info);
    return d->m_poolInfo;
}
 
void
MidiClient::setPoolInfo(const PoolInfo& info)
{
    d->m_poolInfo = info;
    DRUMSTICK_ALSA_CHECK_WARNING(snd_seq_set_client_pool(d->m_SeqHandle, d->m_poolInfo.m_Info));
}
 
void
MidiClient::resetPoolInput()
{
    DRUMSTICK_ALSA_CHECK_WARNING(snd_seq_reset_pool_input(d->m_SeqHandle));
}
 
void
MidiClient::resetPoolOutput()
{
    DRUMSTICK_ALSA_CHECK_WARNING(snd_seq_reset_pool_output(d->m_SeqHandle));
}
 
void
MidiClient::setPoolInput(int size)
{
    DRUMSTICK_ALSA_CHECK_WARNING(snd_seq_set_client_pool_input(d->m_SeqHandle, size));
}
 
void
MidiClient::setPoolOutput(int size)
{
    DRUMSTICK_ALSA_CHECK_WARNING(snd_seq_set_client_pool_output(d->m_SeqHandle, size));
}
 
void
MidiClient::setPoolOutputRoom(int size)
{
    DRUMSTICK_ALSA_CHECK_WARNING(snd_seq_set_client_pool_output_room(d->m_SeqHandle, size));
}
 
void
MidiClient::dropInput()
{
    DRUMSTICK_ALSA_CHECK_WARNING(snd_seq_drop_input(d->m_SeqHandle));
}
 
void
MidiClient::dropInputBuffer()
{
    DRUMSTICK_ALSA_CHECK_WARNING(snd_seq_drop_input_buffer(d->m_SeqHandle));
}
 
void
MidiClient::dropOutput()
{
    DRUMSTICK_ALSA_CHECK_WARNING(snd_seq_drop_output(d->m_SeqHandle));
}
 
void
MidiClient::dropOutputBuffer()
{
    DRUMSTICK_ALSA_CHECK_WARNING(snd_seq_drop_output_buffer(d->m_SeqHandle));
}
 
void
MidiClient::removeEvents(const RemoveEvents* spec)
{
    DRUMSTICK_ALSA_CHECK_WARNING(snd_seq_remove_events(d->m_SeqHandle, spec->m_Info));
}
 
SequencerEvent*
MidiClient::extractOutput()
{
    snd_seq_event_t* ev;
    if (DRUMSTICK_ALSA_CHECK_WARNING(snd_seq_extract_output(d->m_SeqHandle, &ev) == 0)) {
        return new SequencerEvent(ev);
    }
    return nullptr;
}
 
int
MidiClient::outputPending()
{
    return snd_seq_event_output_pending(d->m_SeqHandle);
}
 
int
MidiClient::inputPending(bool fetch)
{
    return snd_seq_event_input_pending(d->m_SeqHandle, fetch ? 1 : 0);
}
 
int
MidiClient::getQueueId(const QString& name)
{
    return snd_seq_query_named_queue(d->m_SeqHandle, name.toLocal8Bit().data());
}
 
int
MidiClient::getPollDescriptorsCount(short events)
{
    return snd_seq_poll_descriptors_count(d->m_SeqHandle, events);
}
 
int
MidiClient::pollDescriptors( struct pollfd *pfds, unsigned int space,
                             short events )
{
    return snd_seq_poll_descriptors(d->m_SeqHandle, pfds, space, events);
}
 
unsigned short
MidiClient::pollDescriptorsRevents(struct pollfd *pfds, unsigned int nfds)
{
    unsigned short revents;
    DRUMSTICK_ALSA_CHECK_WARNING( snd_seq_poll_descriptors_revents( d->m_SeqHandle,
                                                     pfds, nfds,
                                                     &revents ));
    return revents;
}
 
const char *
MidiClient::_getDeviceName()
{
    return snd_seq_name(d->m_SeqHandle);
}
 
void
MidiClient::_setClientName(const char *name)
{
    DRUMSTICK_ALSA_CHECK_WARNING(snd_seq_set_client_name(d->m_SeqHandle, name));
}
 
int
MidiClient::createSimplePort( const char *name,
                              unsigned int caps,
                              unsigned int type )
{
    return DRUMSTICK_ALSA_CHECK_WARNING( snd_seq_create_simple_port( d->m_SeqHandle,
                                                      name, caps, type ));
}
 
void
MidiClient::deleteSimplePort(int port)
{
    DRUMSTICK_ALSA_CHECK_WARNING( snd_seq_delete_simple_port( d->m_SeqHandle, port ));
}
 
void
MidiClient::connectFrom(int myport, int client, int port)
{
    DRUMSTICK_ALSA_CHECK_WARNING( snd_seq_connect_from(d->m_SeqHandle, myport, client, port ));
}
 
void
MidiClient::connectTo(int myport, int client, int port)
{
    DRUMSTICK_ALSA_CHECK_WARNING( snd_seq_connect_to(d->m_SeqHandle, myport, client, port ));
}
 
void
MidiClient::disconnectFrom(int myport, int client, int port)
{
    DRUMSTICK_ALSA_CHECK_WARNING( snd_seq_disconnect_from(d->m_SeqHandle, myport, client, port ));
}
 
void
MidiClient::disconnectTo(int myport, int client, int port)
{
    DRUMSTICK_ALSA_CHECK_WARNING( snd_seq_disconnect_to(d->m_SeqHandle, myport, client, port ));
}
 
bool
MidiClient::parseAddress( const QString& straddr, snd_seq_addr& addr )
{
    bool ok(false);
    QString testClient, testPort;
    ClientInfoList::ConstIterator cit;
    int pos = straddr.indexOf(':');
    if (pos > -1) {
        testClient = straddr.left(pos);
        testPort = straddr.mid(pos+1);
    } else {
        testClient = straddr;
        testPort = '0';
    }
    addr.client = testClient.toInt(&ok);
    if (ok)
        addr.port = testPort.toInt(&ok);
    if (!ok) {
        if (d->m_NeedRefreshClientList)
            readClients();
        for ( cit = d->m_ClientList.constBegin();
              cit != d->m_ClientList.constEnd(); ++cit ) {
            ClientInfo ci = *cit;
            if (testClient.compare(ci.getName(), Qt::CaseInsensitive) == 0) {
                addr.client = ci.getClientId();
                addr.port = testPort.toInt(&ok);
                return ok;
            }
        }
    }
    return ok;
}
 
bool
MidiClient::SequencerInputThread::stopped()
{
    QReadLocker locker(&m_mutex);
    return m_Stopped;
}
 
void
MidiClient::SequencerInputThread::stop()
{
    QWriteLocker locker(&m_mutex);
    m_Stopped = true;
}
 
#if defined(RTKIT_SUPPORT)
static pid_t _gettid() {
    return (pid_t) ::syscall(SYS_gettid);
}
#endif
 
void
MidiClient::SequencerInputThread::setRealtimePriority()
{
    struct sched_param p;
    int rt, policy = SCHED_RR | SCHED_RESET_ON_FORK;
    quint32 priority = 6;
#if defined(RTKIT_SUPPORT)
    bool ok;
    quint32 max_prio;
    quint64 thread;
    struct rlimit old_limit, new_limit;
    long long max_rttime;
#endif
 
    ::memset(&p, 0, sizeof(p));
    p.sched_priority = priority;
    rt = ::pthread_setschedparam(::pthread_self(), policy, &p);
    if (rt != 0) {
#if defined(RTKIT_SUPPORT)
        const QString rtkit_service =
                QStringLiteral("org.freedesktop.RealtimeKit1");
        const QString rtkit_path =
                QStringLiteral("/org/freedesktop/RealtimeKit1");
        const QString rtkit_iface = rtkit_service;
        thread = _gettid();
        QDBusConnection bus = QDBusConnection::systemBus();
        QDBusInterface realtimeKit(rtkit_service, rtkit_path, rtkit_iface, bus);
        QVariant maxRTPrio = realtimeKit.property("MaxRealtimePriority");
        max_prio = maxRTPrio.toUInt(&ok);
        if (!ok) {
            qWarning() << "invalid property RealtimeKit.MaxRealtimePriority";
            return;
        }
        if (priority > max_prio)
            priority = max_prio;
        QVariant maxRTNSec = realtimeKit.property("RTTimeNSecMax");
        max_rttime = maxRTNSec.toLongLong(&ok);
        if (!ok || max_rttime < 0) {
            qWarning() << "invalid property RealtimeKit.RTTimeNSecMax";
            return;
        }
        new_limit.rlim_cur = new_limit.rlim_max = max_rttime;
        rt = ::getrlimit(RLIMIT_RTTIME, &old_limit);
        if (rt < 0) {
            qWarning() << "getrlimit() failed. err=" << rt << ::strerror(rt);
            return;
        }
        rt = ::setrlimit(RLIMIT_RTTIME, &new_limit);
        if ( rt < 0) {
            qWarning() << "setrlimit() failed, err=" << rt << ::strerror(rt);
            return;
        }
        QDBusMessage reply = realtimeKit.call("MakeThreadRealtime", thread, priority);
        if (reply.type() == QDBusMessage::ErrorMessage )
            qWarning() << "error returned by RealtimeKit.MakeThreadRealtime:"
                        << reply.errorMessage();
#endif
    } else {
        qWarning() << "pthread_setschedparam() failed, err="
                   << rt << ::strerror(rt);
    }
}
 
void
MidiClient::SequencerInputThread::run()
{
    if ( priority() == TimeCriticalPriority ) {
        setRealtimePriority();
    }
    if (m_MidiClient != nullptr) {
        int npfd = snd_seq_poll_descriptors_count(m_MidiClient->getHandle(), POLLIN);
        pollfd* pfd = (pollfd *) calloc(npfd, sizeof(pollfd));
        try
        {
            snd_seq_poll_descriptors(m_MidiClient->getHandle(), pfd, npfd, POLLIN);
            while (!stopped() && (m_MidiClient != nullptr))
            {
                int rt = poll(pfd, npfd, m_Wait);
                if (rt > 0) {
                    m_MidiClient->doEvents();
                }
            }
        }
        catch (...)
        {
            qWarning() << "exception in input thread";
        }
        free(pfd);
    }
}
 
ClientInfo::ClientInfo()
{
    snd_seq_client_info_malloc(&m_Info);
}
 
ClientInfo::ClientInfo(const ClientInfo& other)
{
    snd_seq_client_info_malloc(&m_Info);
    snd_seq_client_info_copy(m_Info, other.m_Info);
    m_Ports = other.m_Ports;
}
 
ClientInfo::ClientInfo(snd_seq_client_info_t* other)
{
    snd_seq_client_info_malloc(&m_Info);
    snd_seq_client_info_copy(m_Info, other);
}
 
ClientInfo::ClientInfo(MidiClient* seq, int id)
{
    snd_seq_client_info_malloc(&m_Info);
    snd_seq_get_any_client_info(seq->getHandle(), id, m_Info);
}
 
ClientInfo::~ClientInfo()
{
    freePorts();
    snd_seq_client_info_free(m_Info);
}
 
ClientInfo*
ClientInfo::clone()
{
    return new ClientInfo(m_Info);
}
 
ClientInfo&
ClientInfo::operator=(const ClientInfo& other)
{
    if (this == &other)
        return *this;
    snd_seq_client_info_copy(m_Info, other.m_Info);
    m_Ports = other.m_Ports;
    return *this;
}
 
int
ClientInfo::getClientId()
{
    return snd_seq_client_info_get_client(m_Info);
}
 
snd_seq_client_type_t
ClientInfo::getClientType()
{
    return snd_seq_client_info_get_type(m_Info);
}
 
QString
ClientInfo::getName()
{
    return QString(snd_seq_client_info_get_name(m_Info));
}
 
bool
ClientInfo::getBroadcastFilter()
{
    return (snd_seq_client_info_get_broadcast_filter(m_Info) != 0);
}
 
bool
ClientInfo::getErrorBounce()
{
    return (snd_seq_client_info_get_error_bounce(m_Info) != 0);
}
 
const unsigned char*
ClientInfo::getEventFilter()
{
    return snd_seq_client_info_get_event_filter(m_Info);
}
 
int
ClientInfo::getNumPorts()
{
    return snd_seq_client_info_get_num_ports(m_Info);
}
 
int
ClientInfo::getEventLost()
{
    return snd_seq_client_info_get_event_lost(m_Info);
}
 
void
ClientInfo::setClient(int client)
{
    snd_seq_client_info_set_client(m_Info, client);
}
 
void
ClientInfo::setName(QString name)
{
    snd_seq_client_info_set_name(m_Info, name.toLocal8Bit().data());
}
 
void
ClientInfo::setBroadcastFilter(bool val)
{
    snd_seq_client_info_set_broadcast_filter(m_Info, val ? 1 : 0);
}
 
void
ClientInfo::setErrorBounce(bool val)
{
    snd_seq_client_info_set_error_bounce(m_Info, val ? 1 : 0);
}
 
void
ClientInfo::setEventFilter(unsigned char *filter)
{
    snd_seq_client_info_set_event_filter(m_Info, filter);
}
 
void
ClientInfo::readPorts(MidiClient* seq)
{
    PortInfo info;
    freePorts();
    info.setClient(getClientId());
    info.setClientName(getName());
    info.setPort(-1);
    while (snd_seq_query_next_port(seq->getHandle(), info.m_Info) >= 0) {
        info.readSubscribers(seq);
        m_Ports.append(info);
    }
}
 
void
ClientInfo::freePorts()
{
    m_Ports.clear();
}
 
PortInfoList
ClientInfo::getPorts() const
{
    PortInfoList lst = m_Ports; // copy
    return lst;
}
 
int
ClientInfo::getSizeOfInfo() const
{
    return snd_seq_client_info_sizeof();
}
 
#if SND_LIB_VERSION > 0x010010
void
ClientInfo::addFilter(int eventType)
{
    snd_seq_client_info_event_filter_add(m_Info, eventType);
}
 
bool
ClientInfo::isFiltered(int eventType)
{
    return (snd_seq_client_info_event_filter_check(m_Info, eventType) != 0);
}
 
void
ClientInfo::clearFilter()
{
    snd_seq_client_info_event_filter_clear(m_Info);
}
 
void
ClientInfo::removeFilter(int eventType)
{
    snd_seq_client_info_event_filter_del(m_Info, eventType);
}
#endif
 
SystemInfo::SystemInfo()
{
    snd_seq_system_info_malloc(&m_Info);
}
 
SystemInfo::SystemInfo(const SystemInfo& other)
{
    snd_seq_system_info_malloc(&m_Info);
    snd_seq_system_info_copy(m_Info, other.m_Info);
}
 
SystemInfo::SystemInfo(snd_seq_system_info_t* other)
{
    snd_seq_system_info_malloc(&m_Info);
    snd_seq_system_info_copy(m_Info, other);
}
 
SystemInfo::SystemInfo(MidiClient* seq)
{
    snd_seq_system_info_malloc(&m_Info);
    snd_seq_system_info(seq->getHandle(), m_Info);
}
 
SystemInfo::~SystemInfo()
{
    snd_seq_system_info_free(m_Info);
}
 
SystemInfo*
SystemInfo::clone()
{
    return new SystemInfo(m_Info);
}
 
SystemInfo&
SystemInfo::operator=(const SystemInfo& other)
{
    if (this == &other)
        return *this;
    snd_seq_system_info_copy(m_Info, other.m_Info);
    return *this;
}
 
int SystemInfo::getMaxClients()
{
    return snd_seq_system_info_get_clients(m_Info);
}
 
int SystemInfo::getMaxPorts()
{
    return snd_seq_system_info_get_ports(m_Info);
}
 
int SystemInfo::getMaxQueues()
{
    return snd_seq_system_info_get_queues(m_Info);
}
 
int SystemInfo::getMaxChannels()
{
    return snd_seq_system_info_get_channels(m_Info);
}
 
int SystemInfo::getCurrentQueues()
{
    return snd_seq_system_info_get_cur_queues(m_Info);
}
 
int SystemInfo::getCurrentClients()
{
    return snd_seq_system_info_get_cur_clients(m_Info);
}
 
int SystemInfo::getSizeOfInfo() const
{
    return snd_seq_system_info_sizeof();
}
 
PoolInfo::PoolInfo()
{
    snd_seq_client_pool_malloc(&m_Info);
}
 
PoolInfo::PoolInfo(const PoolInfo& other)
{
    snd_seq_client_pool_malloc(&m_Info);
    snd_seq_client_pool_copy(m_Info, other.m_Info);
}
 
PoolInfo::PoolInfo(snd_seq_client_pool_t* other)
{
    snd_seq_client_pool_malloc(&m_Info);
    snd_seq_client_pool_copy(m_Info, other);
}
 
PoolInfo::PoolInfo(MidiClient* seq)
{
    snd_seq_client_pool_malloc(&m_Info);
    snd_seq_get_client_pool(seq->getHandle(), m_Info);
}
 
PoolInfo::~PoolInfo()
{
    snd_seq_client_pool_free(m_Info);
}
 
PoolInfo*
PoolInfo::clone()
{
    return new PoolInfo(m_Info);
}
 
PoolInfo&
PoolInfo::operator=(const PoolInfo& other)
{
    if (this == &other)
        return *this;
    snd_seq_client_pool_copy(m_Info, other.m_Info);
    return *this;
}
 
int
PoolInfo::getClientId()
{
    return snd_seq_client_pool_get_client(m_Info);
}
 
int
PoolInfo::getInputFree()
{
    return snd_seq_client_pool_get_input_free(m_Info);
}
 
int
PoolInfo::getInputPool()
{
    return snd_seq_client_pool_get_input_pool(m_Info);
}
 
int
PoolInfo::getOutputFree()
{
    return snd_seq_client_pool_get_output_free(m_Info);
}
 
int
PoolInfo::getOutputPool()
{
    return snd_seq_client_pool_get_output_pool(m_Info);
}
 
int
PoolInfo::getOutputRoom()
{
    return snd_seq_client_pool_get_output_room(m_Info);
}
 
void
PoolInfo::setInputPool(int size)
{
    snd_seq_client_pool_set_input_pool(m_Info, size);
}
 
void
PoolInfo::setOutputPool(int size)
{
    snd_seq_client_pool_set_output_pool(m_Info, size);
}
 
void
PoolInfo::setOutputRoom(int size)
{
    snd_seq_client_pool_set_output_room(m_Info, size);
}
 
int
PoolInfo::getSizeOfInfo() const
{
    return snd_seq_client_pool_sizeof();
}
 
#if SND_LIB_VERSION > 0x010004
QString
getRuntimeALSALibraryVersion()
{
    return QString(snd_asoundlib_version());
}
 
int
getRuntimeALSALibraryNumber()
{
    QRegularExpression rx("(\\d+)");
    QString str = getRuntimeALSALibraryVersion();
    bool ok;
    int result = 0, j = 0;
    QRegularExpressionMatchIterator i = rx.globalMatch(str);
    while (i.hasNext() && (j < 3)) {
        QRegularExpressionMatch m = i.next();
        int v = m.captured(1).toInt(&ok);
        if (ok) {
            result <<= 8;
            result += v;
        }
        j++;
    }
    return result;
}
#endif // SND_LIB_VERSION > 0x010004
 
QString
getRuntimeALSADriverVersion()
{
    QRegularExpression rx("([\\d\\.]+)");
    QString s;
    QFile f("/proc/asound/version");
    if (f.open(QFile::ReadOnly)) {
        QTextStream str(&f);
        QString sub = str.readLine().trimmed();
        QRegularExpressionMatch m = rx.match(sub);
        if (m.hasMatch()) {
            s = m.captured(1);
        }
    }
    return s;
}
 
int
getRuntimeALSADriverNumber()
{
    QRegularExpression rx("(\\d+)");
    QString str = getRuntimeALSADriverVersion();
    bool ok;
    int result = 0, j = 0;
    QRegularExpressionMatchIterator i = rx.globalMatch(str);
    while (i.hasNext() && (j < 3)) {
        QRegularExpressionMatch m = i.next();
        int v = m.captured(1).toInt(&ok);
        if (ok) {
            result <<= 8;
            result += v;
        }
        j++;
    }
    return result;
}
 
QString getCompiledALSALibraryVersion()
{
    return QStringLiteral(SND_LIB_VERSION_STR);
}
 
QString getDrumstickLibraryVersion()
{
    return QStringLiteral(QT_STRINGIFY(VERSION));
}
 
} // namespace ALSA
} // namespace drumstick