midiplayereventlist.cpp

Go to the documentation of this file.

/*****************************************************************************
 * Copyright 2016-2017 Karolin Stange, Christoph Wick, and Haye Hinrichsen
 *
 * This file is part of JustIntonation.
 *
 * JustIntonation 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.
 *
 * JustIntonation 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 JustIntonation. If not, see http://www.gnu.org/licenses/.
 *****************************************************************************/

//=============================================================================
//                      Midi Player Events and Event List
//=============================================================================

#include "midiplayereventlist.h"

#include <QFile>
#include <QTextStream>

//=============================================================================
//                      Midi Player Event constructor
//=============================================================================


MidiPlayerEvent::MidiPlayerEvent(quint8 track, double deltaticks,
                                 quint8 command, quint8 byte1, quint8 byte2)
{
    this->track = track;
    this->deltaticks = deltaticks;
    this->command = command;
    this->byte1 = byte1;
    this->byte2 = byte2;
}


//*****************************************************************************

//------------------------------------------------------------------------------
//                               Constructor
//------------------------------------------------------------------------------


MidiPlayerEventList::MidiPlayerEventList()
    : mEventList()
    , mMaxTime(0)
    , pEventIterator(mEventList.begin())
    , mAccessMutex()
{}


//------------------------------------------------------------------------------
//                                  Clear
//------------------------------------------------------------------------------


void MidiPlayerEventList::clear()
{
    mEventList.clear();
    pEventIterator = mEventList.begin();
    mMaxTime = 0;
}

//------------------------------------------------------------------------------
//           Insert a new event in the time-ordered list of events
//------------------------------------------------------------------------------


void MidiPlayerEventList::insert(double time, const MidiPlayerEvent &event)
{
    QMutexLocker locker (&mAccessMutex);
    mEventList.insert(time,event);
    if (time > mMaxTime) mMaxTime = time;
}


//------------------------------------------------------------------------------
//                                  Rewind
//------------------------------------------------------------------------------


void MidiPlayerEventList::rewind()
{
    QMutexLocker locker (&mAccessMutex);
    pEventIterator = mEventList.begin();
}


//------------------------------------------------------------------------------
//                            Advance iterator
//------------------------------------------------------------------------------


void MidiPlayerEventList::advance()
{
    QMutexLocker locker (&mAccessMutex);
    pEventIterator++;
}


//------------------------------------------------------------------------------
//                      Are we at the end of the list?
//------------------------------------------------------------------------------


bool MidiPlayerEventList::atEnd() const
{
    QMutexLocker locker (&mAccessMutex);
    return pEventIterator == mEventList.end();
}


//------------------------------------------------------------------------------
//                            Get actual event
//------------------------------------------------------------------------------


const MidiPlayerEvent MidiPlayerEventList::getEvent() const
{
    QMutexLocker locker (&mAccessMutex);
    if (pEventIterator == mEventList.end()) return MidiPlayerEvent();
    else return pEventIterator.value();
}


//------------------------------------------------------------------------------
//                               Get actual time
//------------------------------------------------------------------------------


quint32 MidiPlayerEventList::getCumulativeTime() const
{
    QMutexLocker locker (&mAccessMutex);
    if (pEventIterator == mEventList.end()) return mMaxTime;
    else return pEventIterator.key();
}


//------------------------------------------------------------------------------
//                           Get actual list size
//------------------------------------------------------------------------------


int MidiPlayerEventList::getSize() const
{
    QMutexLocker locker (&mAccessMutex);
    return mEventList.size();
}


//-----------------------------------------------------------------------------
//                   Get the playing progress in percent
//-----------------------------------------------------------------------------


double MidiPlayerEventList::getProgressInPercent() const
{
    QMutexLocker locker (&mAccessMutex);
    if (pEventIterator == mEventList.begin()) return 0;
    else if (pEventIterator == mEventList.end()) return 100;
    else if (mMaxTime<=0) return 0;
    else return 100.0*pEventIterator.key()/mMaxTime;
}


//-----------------------------------------------------------------------------
//     Set the EventList iterator according to a given progress in percent
//-----------------------------------------------------------------------------


void MidiPlayerEventList::setProgress (double percent)
{
    QMutexLocker locker (&mAccessMutex);
    if (mEventList.empty() or mMaxTime <= 0) return;
    pEventIterator = mEventList.begin();
    quint32 threshold = mMaxTime * percent / 100.0;
    while (pEventIterator != mEventList.end()
           and pEventIterator.key() < threshold) pEventIterator++;
}


//-----------------------------------------------------------------------------
//       Debugging: Write content of the list to file in a readable form
//-----------------------------------------------------------------------------


void MidiPlayerEventList::writeListInReadableForm(QString filename)
{
    QFile file(filename);
    if (not file.open(QIODevice::WriteOnly)) return;
    QTextStream out(&file);
    for (MidiPlayerEvent &e: mEventList)
    {
        out << "t=" << e.deltaticks << "\t" << "tr=" << e.track << "\tcmd=" << e.command
            << "\tb1="<< e.byte1  << "\tb2="<< e.byte2 << "\n";
    }
    if (file.isOpen()) file.close();
}