Added old abandoned KDE3 version of the RoseGarden MIDI tool

git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/applications/rosegarden@1097595 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

1 files changed, 702 insertions, 0 deletions

diff --git a/src/sequencer/MmappedSegment.cpp b/src/sequencer/MmappedSegment.cpp
new file mode 100644
index 0000000..57b3dc9
--- /dev/null
+++ b/src/sequencer/MmappedSegment.cpp
@@ -0,0 +1,702 @@
+
+/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */
+
+/*
+    Rosegarden
+    A MIDI and audio sequencer and musical notation editor.
+
+    This program is Copyright 2000-2008
+        Guillaume Laurent   <[email protected]>,
+        Chris Cannam        <[email protected]>,
+        Richard Bown        <[email protected]>
+
+    The moral rights of Guillaume Laurent, Chris Cannam, and Richard
+    Bown to claim authorship of this work have been asserted.
+
+    Other copyrights also apply to some parts of this work.  Please
+    see the AUTHORS file and individual file headers for details.
+
+    This program 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.  See the file
+    COPYING included with this distribution for more information.
+*/
+
+#include "MmappedSegment.h"
+#include "misc/Debug.h"
+
+#include "sound/MappedComposition.h"
+#include "sound/Midi.h"
+
+//#define DEBUG_META_ITERATOR 1
+//#define DEBUG_PLAYING_AUDIO_FILES 1
+
+namespace Rosegarden
+{
+
+MmappedSegment::MmappedSegment(const QString filename)
+        : m_fd( -1),
+        m_mmappedSize(0),
+        m_mmappedRegion(0),
+        m_mmappedEventBuffer((MappedEvent*)0),
+        m_filename(filename)
+{
+    SEQUENCER_DEBUG << "mmapping " << filename << endl;
+
+    map();
+}
+
+bool MmappedSegment::isMetronome()
+{
+    return (getFileName().contains("metronome", false) > 0);
+}
+
+
+
+void MmappedSegment::map()
+{
+    QFileInfo fInfo(m_filename);
+    if (!fInfo.exists()) {
+        SEQUENCER_DEBUG << "MmappedSegment::map() : file " << m_filename << " doesn't exist\n";
+        throw Exception("file not found");
+    }
+
+    m_mmappedSize = fInfo.size();
+
+    m_fd = ::open(m_filename.latin1(), O_RDWR);
+
+    m_mmappedRegion = ::mmap(0, m_mmappedSize, PROT_READ, MAP_SHARED, m_fd, 0);
+
+    if (m_mmappedRegion == (void*) - 1) {
+
+        SEQUENCER_DEBUG << QString("mmap failed : (%1) %2\n").
+        arg(errno).arg(strerror(errno));
+
+        throw Exception("mmap failed");
+    }
+
+    m_mmappedEventBuffer = (MappedEvent *)((size_t *)m_mmappedRegion + 1);
+
+    SEQUENCER_DEBUG << "MmappedSegment::map() : "
+    << (void*)m_mmappedRegion << "," << m_mmappedSize << endl;
+
+}
+
+MmappedSegment::~MmappedSegment()
+{
+    unmap();
+}
+
+void MmappedSegment::unmap()
+{
+    ::munmap(m_mmappedRegion, m_mmappedSize);
+    ::close(m_fd);
+}
+
+size_t
+MmappedSegment::getNbMappedEvents() const
+{
+    if (m_mmappedRegion || !m_mmappedSize) {
+
+        // The shared memory area consists of one size_t giving the
+        // number of following mapped events, followed by the mapped
+        // events themselves.
+
+        // So this is the number of mapped events that we expect:
+        size_t nominal = *(size_t *)m_mmappedRegion;
+
+        // But we want to be sure not to read off the end of the
+        // shared memory area, so just in case, this is the number of
+        // events that can actually be accommodated in the memory area
+        // as we see it:
+        size_t actual = (m_mmappedSize - sizeof(size_t)) /
+                        sizeof(MappedEvent);
+
+        return std::min(nominal, actual);
+
+    } else
+        return 0;
+}
+
+bool MmappedSegment::remap(size_t newSize)
+{
+    SEQUENCER_DEBUG << "remap() from " << m_mmappedSize << " to "
+    << newSize << endl;
+
+    if (m_mmappedSize == newSize) {
+
+        SEQUENCER_DEBUG << "remap() : sizes are identical, remap not forced - "
+        << "nothing to do\n";
+        return false;
+    }
+
+#ifdef linux
+    void *oldRegion = m_mmappedRegion;
+    m_mmappedRegion = (MappedEvent*)::mremap(m_mmappedRegion, m_mmappedSize, newSize, MREMAP_MAYMOVE);
+    if (m_mmappedRegion != oldRegion) {
+        SEQUENCER_DEBUG << "NOTE: buffer moved from " << oldRegion <<
+        " to " << (void *)m_mmappedRegion << endl;
+    }
+#else
+    ::munmap(m_mmappedRegion, m_mmappedSize);
+    m_mmappedRegion = (MappedEvent*)::mmap(0, newSize, PROT_READ, MAP_SHARED, m_fd, 0);
+#endif
+
+    if (m_mmappedRegion == (void*) - 1) {
+
+        SEQUENCER_DEBUG << QString("mremap failed : (%1) %2\n").
+        arg(errno).arg(strerror(errno));
+
+        throw Exception("mremap failed");
+    }
+
+    m_mmappedEventBuffer = (MappedEvent *)((size_t *)m_mmappedRegion + 1);
+    m_mmappedSize = newSize;
+
+    return true;
+}
+
+MmappedSegment::iterator::iterator(MmappedSegment* s)
+        : m_s(s), m_currentEvent(m_s->getBuffer())
+{}
+
+MmappedSegment::iterator& MmappedSegment::iterator::operator=(const iterator& it)
+{
+    if (&it == this)
+        return * this;
+
+    m_s = it.m_s;
+    m_currentEvent = it.m_currentEvent;
+
+    return *this;
+}
+
+MmappedSegment::iterator& MmappedSegment::iterator::operator++()
+{
+    if (!atEnd()) {
+
+        do
+            ++m_currentEvent;
+        while (!atEnd() && (m_currentEvent->getType() == 0));
+        // skip null events - there can be some if the file has been
+        // zeroed out after events have been deleted
+
+    } else {
+
+        SEQUENCER_DEBUG << "MmappedSegment::iterator::operator++() " << this
+        << " - reached end of stream\n";
+
+    }
+
+    return *this;
+}
+
+MmappedSegment::iterator MmappedSegment::iterator::operator++(int)
+{
+    iterator r = *this;
+
+    if (!atEnd()) {
+        do
+            ++m_currentEvent;
+        while (!atEnd() && m_currentEvent->getType() == 0);
+
+    }
+
+    return r;
+}
+
+MmappedSegment::iterator& MmappedSegment::iterator::operator+=(int offset)
+{
+    m_currentEvent += offset;
+
+    if (atEnd()) {
+        m_currentEvent = m_s->getBuffer() + m_s->getNbMappedEvents();
+    }
+
+    return *this;
+}
+
+MmappedSegment::iterator& MmappedSegment::iterator::operator-=(int offset)
+{
+    m_currentEvent -= offset;
+    if (m_currentEvent < m_s->getBuffer()) {
+        m_currentEvent = m_s->getBuffer();
+    }
+
+    return *this;
+}
+
+
+bool MmappedSegment::iterator::operator==(const iterator& it)
+{
+    return (m_currentEvent == it.m_currentEvent) || (atEnd() == it.atEnd());
+}
+
+void MmappedSegment::iterator::reset()
+{
+    m_currentEvent = m_s->getBuffer();
+}
+
+const MappedEvent &MmappedSegment::iterator::operator*()
+{
+    return *m_currentEvent;
+}
+
+bool MmappedSegment::iterator::atEnd() const
+{
+    return (m_currentEvent == 0) ||
+           (m_currentEvent > (m_s->getBuffer() + m_s->getNbMappedEvents() - 1));
+}
+
+//----------------------------------------
+
+MmappedSegmentsMetaIterator::MmappedSegmentsMetaIterator(
+    mmappedsegments& segments,
+    ControlBlockMmapper* controlBlockMmapper)
+        : m_controlBlockMmapper(controlBlockMmapper),
+        m_segments(segments)
+{
+    for (mmappedsegments::iterator i = m_segments.begin();
+            i != m_segments.end(); ++i)
+        m_iterators.push_back(new MmappedSegment::iterator(i->second));
+}
+
+MmappedSegmentsMetaIterator::~MmappedSegmentsMetaIterator()
+{
+    clear();
+}
+
+void MmappedSegmentsMetaIterator::addSegment(MmappedSegment* ms)
+{
+    MmappedSegment::iterator* iter = new MmappedSegment::iterator(ms);
+    moveIteratorToTime(*iter, m_currentTime);
+    m_iterators.push_back(iter);
+}
+
+void MmappedSegmentsMetaIterator::deleteSegment(MmappedSegment* ms)
+{
+    for (segmentiterators::iterator i = m_iterators.begin(); i != m_iterators.end(); ++i) {
+        if ((*i)->getSegment() == ms) {
+            SEQUENCER_DEBUG << "deleteSegment : found segment to delete : "
+            << ms->getFileName() << endl;
+            delete (*i);
+            m_iterators.erase(i);
+            break;
+        }
+    }
+}
+
+void MmappedSegmentsMetaIterator::clear()
+{
+    for (unsigned int i = 0; i < m_iterators.size(); ++i)
+        delete m_iterators[i];
+
+    m_iterators.clear();
+}
+
+void MmappedSegmentsMetaIterator::reset()
+{
+    m_currentTime.sec = m_currentTime.nsec = 0;
+
+    for (segmentiterators::iterator i = m_iterators.begin(); i != m_iterators.end(); ++i) {
+        (*i)->reset();
+    }
+
+}
+
+bool MmappedSegmentsMetaIterator::jumpToTime(const RealTime& startTime)
+{
+    SEQUENCER_DEBUG << "jumpToTime(" << startTime << ")" << endl;
+
+    reset();
+
+    bool res = true;
+
+    m_currentTime = startTime;
+
+    for (segmentiterators::iterator i = m_iterators.begin(); i != m_iterators.end(); ++i)
+        if (!moveIteratorToTime(*(*i), startTime))
+            res = false;
+
+    return res;
+}
+
+bool MmappedSegmentsMetaIterator::moveIteratorToTime(MmappedSegment::iterator& iter,
+        const RealTime& startTime)
+{
+    while ((!iter.atEnd()) &&
+            (iter.peek()->getEventTime() < startTime) &&
+            ((iter.peek()->getEventTime() + iter.peek()->getDuration()) < startTime)
+          ) {
+        ++iter;
+    }
+    bool res = !iter.atEnd();
+
+    return res;
+}
+
+bool MmappedSegmentsMetaIterator::acceptEvent(MappedEvent *evt, bool evtIsFromMetronome)
+{
+    if (evt->getType() == 0)
+        return false; // discard those right away
+
+    if (evtIsFromMetronome) {
+        if (evt->getType() == MappedEvent::MidiSystemMessage &&
+                evt->getData1() == MIDI_TIMING_CLOCK) {
+            /*
+            std::cout << "MmappedSegmentsMetaIterator::acceptEvent - " 
+                      << "found clock" << std::endl;
+                      */ 
+            return true;
+        }
+
+        return !m_controlBlockMmapper->isMetronomeMuted();
+    }
+
+    // else, evt is not from metronome : first check if we're soloing (i.e. playing only the selected track)
+    if (m_controlBlockMmapper->isSolo())
+        return (evt->getTrackId() == m_controlBlockMmapper->getSelectedTrack());
+
+    // finally we're not soloing, so check if track is muted
+    TrackId track = evt->getTrackId();
+    bool muted = m_controlBlockMmapper->isTrackMuted(evt->getTrackId());
+
+#ifdef DEBUG_META_ITERATOR
+
+    SEQUENCER_DEBUG << "MSMI::acceptEvent: track " << track << " muted status: " << muted << endl;
+#endif
+
+    return !muted;
+}
+
+
+bool
+MmappedSegmentsMetaIterator::fillCompositionWithEventsUntil(bool /*firstFetch*/,
+        MappedComposition* c,
+        const RealTime& startTime,
+        const RealTime& endTime)
+{
+#ifdef DEBUG_META_ITERATOR
+    SEQUENCER_DEBUG << "MSMI::fillCompositionWithEventsUntil " << startTime << " -> " << endTime << endl;
+#endif
+
+    m_currentTime = endTime;
+
+    // keep track of the segments which still have valid events
+    std::vector<bool> validSegments;
+    for (unsigned int i = 0; i < m_segments.size(); ++i)
+        validSegments.push_back(true);
+
+    bool foundOneEvent = false, eventsRemaining = false;
+
+    do {
+        foundOneEvent = false;
+
+        for (unsigned int i = 0; i < m_iterators.size(); ++i) {
+
+            MmappedSegment::iterator* iter = m_iterators[i];
+
+            //std::cerr << "Iterating on Segment #" << i << std::endl;
+
+#ifdef DEBUG_META_ITERATOR
+
+            SEQUENCER_DEBUG << "MSMI::fillCompositionWithEventsUntil : "
+            << "checking segment #" << i << " "
+            << iter->getSegment()->getFileName() << endl;
+#endif
+
+            if (!validSegments[i]) {
+#ifdef DEBUG_META_ITERATOR
+                SEQUENCER_DEBUG << "MSMI::fillCompositionWithEventsUntil : "
+                << "no more events to get for this slice "
+                << "in segment #" << i << endl;
+#endif
+
+                continue; // skip this segment
+            }
+
+            bool evtIsFromMetronome = iter->getSegment()->isMetronome();
+
+            if (iter->atEnd()) {
+#ifdef DEBUG_META_ITERATOR
+                SEQUENCER_DEBUG << "MSMI::fillCompositionWithEventsUntil : "
+                << endTime
+                << " reached end of segment #"
+                << i << endl;
+#endif
+
+                continue;
+            } else if (!evtIsFromMetronome) {
+                eventsRemaining = true;
+            }
+
+            if ((**iter).getEventTime() < endTime) {
+
+                MappedEvent *evt = new MappedEvent(*(*iter));
+
+                // set event's instrument
+                //
+                if (evtIsFromMetronome) {
+
+                    evt->setInstrument(m_controlBlockMmapper->
+                                       getInstrumentForMetronome());
+
+                } else {
+
+                    evt->setInstrument(m_controlBlockMmapper->
+                                       getInstrumentForTrack(evt->getTrackId()));
+
+                }
+
+#ifdef DEBUG_META_ITERATOR
+                SEQUENCER_DEBUG << "MSMI::fillCompositionWithEventsUntil : " << endTime
+                << " inserting evt from segment #"
+                << i
+                << " : trackId: " << evt->getTrackId()
+                << " - inst: " << evt->getInstrument()
+                << " - type: " << evt->getType()
+                << " - time: " << evt->getEventTime()
+                << " - duration: " << evt->getDuration()
+                << " - data1: " << (unsigned int)evt->getData1()
+                << " - data2: " << (unsigned int)evt->getData2()
+                << " - metronome event: " << evtIsFromMetronome
+                << endl;
+#endif
+
+                if (evt->getType() == MappedEvent::TimeSignature) {
+
+                    // Process time sig and tempo changes along with
+                    // everything else, as the sound driver probably
+                    // wants to know when they happen
+
+                    c->insert(evt);
+
+                } else if (evt->getType() == MappedEvent::Tempo) {
+
+                    c->insert(evt);
+
+                } else if (evt->getType() == MappedEvent::MidiSystemMessage &&
+
+                           // #1048388:
+                           // Ensure sysex heeds mute status, but ensure
+                           // clocks etc still get through
+                           evt->getData1() != MIDI_SYSTEM_EXCLUSIVE) {
+
+                    c->insert(evt);
+
+                } else if (acceptEvent(evt, evtIsFromMetronome) &&
+
+                           ((evt->getEventTime() + evt->getDuration() > startTime) ||
+                            (evt->getDuration() == RealTime::zeroTime &&
+                             evt->getEventTime() == startTime))) {
+
+                    //                    std::cout << "inserting event" << std::endl;
+
+                    /*
+                    std::cout << "Inserting event (type = "
+                        << evt->getType() << ")" << std::endl;
+                        */
+
+
+                    c->insert(evt);
+
+                } else {
+
+#ifdef DEBUG_META_ITERATOR
+                    std::cout << "MSMI: skipping event"
+                    << " - event time = " << evt->getEventTime()
+                    << ", duration = " << evt->getDuration()
+                    << ", startTime = " << startTime << std::endl;
+#endif
+
+                    delete evt;
+                }
+
+                if (!evtIsFromMetronome)
+                    foundOneEvent = true;
+                ++(*iter);
+
+            } else {
+                validSegments[i] = false; // no more events to get from this segment
+#ifdef DEBUG_META_ITERATOR
+
+                SEQUENCER_DEBUG << "fillCompositionWithEventsUntil : no more events to get from segment #"
+                << i << endl;
+#endif
+
+            }
+
+        }
+
+    } while (foundOneEvent);
+
+#ifdef DEBUG_META_ITERATOR
+
+    SEQUENCER_DEBUG << "fillCompositionWithEventsUntil : eventsRemaining = " << eventsRemaining << endl;
+#endif
+
+    return eventsRemaining || foundOneEvent;
+}
+
+void MmappedSegmentsMetaIterator::resetIteratorForSegment(const QString& filename)
+{
+    for (segmentiterators::iterator i = m_iterators.begin(); i != m_iterators.end(); ++i) {
+        MmappedSegment::iterator* iter = *i;
+
+        if (iter->getSegment()->getFileName() == filename) {
+            SEQUENCER_DEBUG << "MSMI::resetIteratorForSegment(" << filename << ") : found iterator\n";
+            // delete iterator and create another one
+            MmappedSegment* ms = (*i)->getSegment();
+            delete iter;
+            m_iterators.erase(i);
+            iter = new MmappedSegment::iterator(ms);
+            m_iterators.push_back(iter);
+            moveIteratorToTime(*iter, m_currentTime);
+            break;
+        }
+
+    }
+}
+
+void
+MmappedSegmentsMetaIterator::getAudioEvents(std::vector<MappedEvent> &v)
+{
+    v.clear();
+
+    for (mmappedsegments::iterator i = m_segments.begin();
+            i != m_segments.end(); ++i) {
+
+        MmappedSegment::iterator itr(i->second);
+
+        while (!itr.atEnd()) {
+
+            if ((*itr).getType() != MappedEvent::Audio) {
+                ++itr;
+                continue;
+            }
+
+            MappedEvent evt(*itr);
+            ++itr;
+
+            if (m_controlBlockMmapper->isTrackMuted(evt.getTrackId())) {
+#ifdef DEBUG_PLAYING_AUDIO_FILES
+                std::cout << "MSMI::getAudioEvents - "
+                << "track " << evt.getTrackId() << " is muted" << std::endl;
+#endif
+
+                continue;
+            }
+
+            if (m_controlBlockMmapper->isSolo() == true &&
+                    evt.getTrackId() != m_controlBlockMmapper->getSelectedTrack()) {
+#ifdef DEBUG_PLAYING_AUDIO_FILES
+                std::cout << "MSMI::getAudioEvents - "
+                << "track " << evt.getTrackId() << " is not solo track" << std::endl;
+#endif
+
+                continue;
+            }
+
+            v.push_back(evt);
+        }
+    }
+}
+
+
+std::vector<MappedEvent>&
+MmappedSegmentsMetaIterator::getPlayingAudioFiles(const RealTime &
+        songPosition)
+{
+    // Clear playing audio segments
+    //
+    m_playingAudioSegments.clear();
+
+#ifdef DEBUG_PLAYING_AUDIO_FILES
+
+    std::cout << "MSMI::getPlayingAudioFiles" << std::endl;
+#endif
+
+    for (mmappedsegments::iterator i = m_segments.begin();
+            i != m_segments.end(); ++i) {
+
+        MmappedSegment::iterator iter(i->second);
+
+        bool found = false;
+
+        //!!! any point to this loop at all? can found ever fail?
+        for (segmentiterators::iterator sI = m_iterators.begin();
+                sI != m_iterators.end(); ++sI) {
+            if ((*sI)->getSegment() == iter.getSegment())
+                found = true;
+        }
+
+        if (!found)
+            continue;
+
+        while (!iter.atEnd()) {
+            if ((*iter).getType() != MappedEvent::Audio) {
+                ++iter;
+                continue;
+            }
+
+            //std::cout << "CONSTRUCTING MAPPEDEVENT" << std::endl;
+            MappedEvent evt(*iter);
+
+            // Check for this track being muted or soloed
+            //
+            if (m_controlBlockMmapper->isTrackMuted(evt.getTrackId()) == true) {
+#ifdef DEBUG_PLAYING_AUDIO_FILES
+                std::cout << "MSMI::getPlayingAudioFiles - "
+                << "track " << evt.getTrackId() << " is muted" << std::endl;
+#endif
+
+                ++iter;
+                continue;
+            }
+
+            if (m_controlBlockMmapper->isSolo() == true &&
+                    evt.getTrackId() != m_controlBlockMmapper->getSelectedTrack()) {
+#ifdef DEBUG_PLAYING_AUDIO_FILES
+                std::cout << "MSMI::getPlayingAudioFiles - "
+                << "track " << evt.getTrackId() << " is not solo track" << std::endl;
+#endif
+
+                ++iter;
+                continue;
+            }
+
+            // If there's an audio event and it should be playing at this time
+            // then flag as such.
+            //
+            if (songPosition > evt.getEventTime() - RealTime(1, 0) &&
+                    songPosition < evt.getEventTime() + evt.getDuration()) {
+
+#ifdef DEBUG_PLAYING_AUDIO_FILES
+                std::cout << "MSMI::getPlayingAudioFiles - "
+                << "instrument id = " << evt.getInstrument() << std::endl;
+
+
+                std::cout << "MSMI::getPlayingAudioFiles - "
+                << " id " << evt.getRuntimeSegmentId() << ", audio event time     = " << evt.getEventTime() << std::endl;
+                std::cout << "MSMI::getPlayingAudioFiles - "
+                << "audio event duration = " << evt.getDuration() << std::endl;
+
+
+#endif // DEBUG_PLAYING_AUDIO_FILES
+
+                m_playingAudioSegments.push_back(evt);
+            }
+
+            ++iter;
+        }
+
+        //std::cout << "END OF ITERATOR" << std::endl << std::endl;
+
+    }
+
+    return m_playingAudioSegments;
+}
+
+}
+