playthread.cpp

Go to the documentation of this file.

/*
    MIDI Sequencer C++ library
    Copyright (C) 2006-2019, 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 2 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 <QReadLocker>
#include <QWriteLocker>
#include <drumstick/playthread.h>
#include <drumstick/alsaclient.h>
#include <drumstick/alsaqueue.h>
 
namespace drumstick {
 
const int TIMEOUT = 100;
 
SequencerOutputThread::SequencerOutputThread(MidiClient *seq, int portId)
    : QThread(),
    m_MidiClient(seq),
    m_Queue(0),
    m_PortId(portId),
    m_Stopped(false),
    m_QueueId(0),
    m_npfds(0),
    m_pfds(0)
{
    if (m_MidiClient != NULL) {
        m_Queue = m_MidiClient->getQueue();
        m_QueueId = m_Queue->getId();
    }
}
 
bool
SequencerOutputThread::stopRequested()
{
    QReadLocker locker(&m_mutex);
    return m_Stopped;
}
 
void
SequencerOutputThread::stop()
{
    QWriteLocker locker(&m_mutex);
    m_Stopped = true;
    locker.unlock();
    while (isRunning())
        wait(TIMEOUT);
}
 
void
SequencerOutputThread::sendEchoEvent(int tick)
{
    if (!stopRequested() && m_MidiClient != NULL) {
        SystemEvent ev(SND_SEQ_EVENT_ECHO);
        ev.setSource(m_PortId);
        ev.setDestination(m_MidiClient->getClientId(), m_PortId);
        ev.scheduleTick(m_QueueId, tick, false);
        sendSongEvent(&ev);
    }
}
 
void
SequencerOutputThread::sendSongEvent(SequencerEvent* ev)
{
    if (m_MidiClient != NULL) {
        while (!stopRequested() &&
               (snd_seq_event_output_direct(m_MidiClient->getHandle(), ev->getHandle()) < 0))
            poll(m_pfds, m_npfds, TIMEOUT);
    }
}
 
void
SequencerOutputThread::drainOutput()
{
    if (m_MidiClient != NULL) {
        while (!stopRequested() &&
               (snd_seq_drain_output(m_MidiClient->getHandle()) < 0))
            poll(m_pfds, m_npfds, TIMEOUT);
    }
}
 
void
SequencerOutputThread::syncOutput()
{
    if (!stopRequested() && m_MidiClient != NULL) {
        QueueStatus status = m_Queue->getStatus();
        while (!stopRequested() && (status.getEvents() > 0)) {
           usleep(TIMEOUT);
           status = m_Queue->getStatus();
        }
    }
}
 
void SequencerOutputThread::run()
{
    unsigned int last_tick;
    if (m_MidiClient != NULL) {
        try  {
            m_npfds = snd_seq_poll_descriptors_count(m_MidiClient->getHandle(), POLLOUT);
            m_pfds = (pollfd*) alloca(m_npfds * sizeof(pollfd));
            snd_seq_poll_descriptors(m_MidiClient->getHandle(), m_pfds, m_npfds, POLLOUT);
            last_tick = getInitialPosition();
            if (last_tick == 0) {
                m_Queue->start();
            } else {
                m_Queue->setTickPosition(last_tick);
                m_Queue->continueRunning();
            }
            while (!stopRequested() && hasNext()) {
                SequencerEvent* ev = nextEvent();
                if (getEchoResolution() > 0) {
                    while (!stopRequested() && (last_tick < ev->getTick())) {
                        last_tick += getEchoResolution();
                        sendEchoEvent(last_tick);
                    }
                }
                if (!stopRequested() && !SequencerEvent::isConnectionChange(ev))
                    sendSongEvent(ev);
            }
            if (stopRequested()) {
                m_Queue->clear();
                emit stopped();
            } else {
                drainOutput();
                syncOutput();
                if (stopRequested())
                    emit stopped();
                else
                    emit finished();
            }
            m_Queue->stop();
        } catch (...) {
            qWarning("exception in output thread");
        }
        m_npfds = 0;
        m_pfds = 0;
    }
}
 
void SequencerOutputThread::start( Priority priority )
{
    QWriteLocker locker(&m_mutex);
    m_Stopped = false;
    QThread::start( priority );
}
 
} /* namespace drumstick */