anonymous_namespace{MIDIPlay.h}::Iterator Struct Reference

#include <MIDIPlay.h>

Collaboration diagram for anonymous_namespace{MIDIPlay.h}::Iterator:

Public Member Functions
	Iterator (const PlaybackSchedule &schedule, MIDIPlay &midiPlay, NoteTrackConstArray &midiPlaybackTracks, double startTime, double offset, bool send)
	~Iterator ()
void	Prime (bool send, double startTime)
double	GetNextEventTime () const
double	UncorrectedMidiEventTime (double pauseTime)
bool	Unmuted (bool hasSolo) const
bool	OutputEvent (double pauseTime, bool sendMidiState, bool hasSolo)
void	GetNextEvent ()

Public Attributes
const PlaybackSchedule &	mPlaybackSchedule
MIDIPlay &	mMIDIPlay
Alg_iterator	it { nullptr, false }
Alg_event *	mNextEvent = nullptr
	The next event to play (or null) More...
NoteTrack *	mNextEventTrack = nullptr
	Track of next event. More...
bool	mNextIsNoteOn = false
	Is the next event a note-on? More...

Private Attributes
double	mNextEventTime = 0

Detailed Description

Definition at line 40 of file MIDIPlay.h.

Constructor & Destructor Documentation

Iterator()

anonymous_namespace{MIDIPlay.cpp}::Iterator::Iterator	(	const PlaybackSchedule &	schedule,
		MIDIPlay &	midiPlay,
		NoteTrackConstArray &	midiPlaybackTracks,
		double	startTime,
		double	offset,
		bool	send
	)

Definition at line 623 of file MIDIPlay.cpp.

   : mPlaybackSchedule{ schedule }
   , mMIDIPlay{ midiPlay }
{
   // instead of initializing with an Alg_seq, we use begin_seq()
   // below to add ALL Alg_seq's.
   // Iterator not yet initialized, must add each track...
   for (auto &t : midiPlaybackTracks) {
      Alg_seq_ptr seq = &t->GetSeq();
      // mark sequence tracks as "in use" since we're handing this
      // off to another thread and want to make sure nothing happens
      // to the data until playback finishes. This is just a sanity check.
      seq->set_in_use(true);
      const void *cookie = t.get();
      it.begin_seq(seq,
         // casting away const, but allegro just uses the pointer opaquely
         const_cast<void*>(cookie), t->GetStartTime() + offset);
   }
   Prime(send, startTime + offset);
}

References it, and Prime().

Here is the call graph for this function:

~Iterator()

anonymous_namespace{MIDIPlay.cpp}::Iterator::~Iterator

(

)

Definition at line 647 of file MIDIPlay.cpp.

{
   it.end();
}

References it.

Member Function Documentation

GetNextEvent()

void anonymous_namespace{MIDIPlay.cpp}::Iterator::GetNextEvent

(

)

Definition at line 968 of file MIDIPlay.cpp.

{
   mNextEventTrack = nullptr; // clear it just to be safe
   // now get the next event and the track from which it came
   double nextOffset;
   auto midiLoopOffset = mMIDIPlay.MidiLoopOffset();
   mNextEvent = it.next(&mNextIsNoteOn,
      // Allegro retrieves the "cookie" for the event, which is a NoteTrack
      reinterpret_cast<void **>(&mNextEventTrack),
      &nextOffset, mPlaybackSchedule.mT1 + midiLoopOffset);
 
   mNextEventTime  = mPlaybackSchedule.mT1 + midiLoopOffset + 1;
   if (mNextEvent) {
      mNextEventTime = (mNextIsNoteOn ? mNextEvent->time :
                              mNextEvent->get_end_time()) + nextOffset;;
   }
   if (mNextEventTime > (mPlaybackSchedule.mT1 + midiLoopOffset)){ // terminate playback at mT1
      mNextEvent = &gAllNotesOff;
      mNextEventTime = mPlaybackSchedule.mT1 + midiLoopOffset;
      mNextIsNoteOn = true; // do not look at duration
   }
}

References anonymous_namespace{MIDIPlay.h}::gAllNotesOff, it, anonymous_namespace{MIDIPlay.h}::MIDIPlay::MidiLoopOffset(), mMIDIPlay, mNextEvent, mNextEventTime, mNextEventTrack, mNextIsNoteOn, mPlaybackSchedule, and PlaybackSchedule::mT1.

Referenced by Prime().

Here is the call graph for this function:

Here is the caller graph for this function:

GetNextEventTime()

double anonymous_namespace{MIDIPlay.cpp}::Iterator::GetNextEventTime

(

)

const

Definition at line 671 of file MIDIPlay.cpp.

{
   if (mNextEvent == &gAllNotesOff)
      return mNextEventTime - ALG_EPS;
   return mNextEventTime;
}

References anonymous_namespace{MIDIPlay.h}::gAllNotesOff, mNextEvent, and mNextEventTime.

Referenced by Prime(), and UncorrectedMidiEventTime().

Here is the caller graph for this function:

OutputEvent()

bool anonymous_namespace{MIDIPlay.cpp}::Iterator::OutputEvent	(	double	pauseTime,
		bool	sendMidiState,
		bool	hasSolo
	)

Parameters

sendMidiState

when true, sendMidiState means send only updates, not note-ons, used to send state changes that precede the selected notes

Definition at line 806 of file MIDIPlay.cpp.

{
   int channel = (mNextEvent->chan) & 0xF; // must be in [0..15]
   int command = -1;
   int data1 = -1;
   int data2 = -1;
 
   double eventTime = UncorrectedMidiEventTime(pauseTime);
 
   // 0.0005 is for rounding
   double time = eventTime + 0.0005 -
                 (mMIDIPlay.mSynthLatency * 0.001);
 
   time += 1; // MidiTime() has a 1s offset
   // state changes have to go out without delay because the
   // midi stream time gets reset when playback starts, and
   // we don't want to leave any control changes scheduled for later
   if (time < 0 || midiStateOnly)
      time = 0;
   PmTimestamp timestamp = (PmTimestamp) (time * 1000); /* s to ms */
 
   // The special event gAllNotesOff means "end of playback, send
   // all notes off on all channels"
   if (mNextEvent == &gAllNotesOff) {
      bool looping = mPlaybackSchedule.GetPolicy().Looping(mPlaybackSchedule);
      mMIDIPlay.AllNotesOff(looping);
      return true;
   }
 
   // (RBD)
   // if mNextEvent's channel is visible, play it, visibility can
   // be updated while playing.
   
   // Be careful: if we have a note-off,
   // then we must not pay attention to the channel selection
   // or mute/solo buttons because we must turn the note off
   // even if the user changed something after the note began.
 
   // Note that because multiple tracks can output to the same
   // MIDI channels, it is not a good idea to send "All Notes Off"
   // when the user presses the mute button. We have no easy way
   // to know what notes are sounding on any given muted track, so
   // we'll just wait for the note-off events to happen.
 
   // (PRL)
   // Does that mean, try to get right results when playing to the same SET
   // of MIDI channels, but tracks play to different channels?  In the
   // case that two unrelated tracks try to merge events, for notes that
   // overlap in time, to the same channel -- then one track still turns off
   // a note that another turned on.  Maybe the prevention of this case belongs
   // to higher levels of the program, and should just be assumed here.
 
   // (RBD)
   // Also note that note-offs are only sent when we call
   // mIterator->request_note_off(), so notes that are not played
   // will not generate random note-offs. There is the interesting
   // case that if the playback is paused, all-notes-off WILL be sent
   // and if playback resumes, the pending note-off events WILL also
   // be sent (but if that is a problem, there would also be a problem
   // in the non-pause case.
   const bool sendIt = [&]{
      const bool isNote = mNextEvent->is_note();
      if (!(isNote && mNextIsNoteOn))
         // Regardless of channel visibility state,
         // always send note-off events,
         // and update events (program change, control change, pressure, bend)
         // in case the user changes the muting during play
         return true;
      return Unmuted(hasSolo);
   }();
   if (sendIt) {
      // Note event
      if (mNextEvent->is_note() && !midiStateOnly) {
         // Pitch and velocity
         data1 = mNextEvent->get_pitch();
         if (mNextIsNoteOn) {
            data2 = mNextEvent->get_loud(); // get velocity
            int offset = mNextEventTrack->GetVelocity();
            data2 += offset; // offset comes from per-track slider
            // clip velocity to insure a legal note-on value
            data2 = (data2 < 1 ? 1 : (data2 > 127 ? 127 : data2));
            // since we are going to play this note, we need to get a note_off
            it.request_note_off();
 
#ifdef AUDIO_IO_GB_MIDI_WORKAROUND
            mMIDIPlay.mPendingNotesOff.push_back(std::make_pair(channel, data1));
#endif
         }
         else {
            data2 = 0; // 0 velocity means "note off"
#ifdef AUDIO_IO_GB_MIDI_WORKAROUND
            auto end = mMIDIPlay.mPendingNotesOff.end();
            auto iter = std::find(
               mMIDIPlay.mPendingNotesOff.begin(), end, std::make_pair(channel, data1) );
            if (iter != end)
               mMIDIPlay.mPendingNotesOff.erase(iter);
#endif
         }
         command = 0x90; // MIDI NOTE ON (or OFF when velocity == 0)
      // Update event
      } else if (mNextEvent->is_update()) {
         // this code is based on allegrosmfwr.cpp -- it could be improved
         // by comparing attribute pointers instead of string compares
         Alg_update_ptr update = static_cast<Alg_update_ptr>(mNextEvent);
         const char *name = update->get_attribute();
 
         if (!strcmp(name, "programi")) {
            // Instrument change
            data1 = update->parameter.i;
            data2 = 0;
            command = 0xC0; // MIDI PROGRAM CHANGE
         } else if (!strncmp(name, "control", 7)) {
            // Controller change
 
            // The number of the controller being changed is embedded
            // in the parameter name.
            data1 = atoi(name + 7);
            // Allegro normalizes controller values
            data2 = ROUND(update->parameter.r * 127);
            command = 0xB0;
         } else if (!strcmp(name, "bendr")) {
            // Bend change
 
            // Reverse Allegro's post-processing of bend values
            int temp = ROUND(0x2000 * (update->parameter.r + 1));
            if (temp > 0x3fff) temp = 0x3fff; // 14 bits maximum
            if (temp < 0) temp = 0;
            data1 = temp & 0x7f; // low 7 bits
            data2 = temp >> 7;   // high 7 bits
            command = 0xE0; // MIDI PITCH BEND
         } else if (!strcmp(name, "pressurer")) {
            // Pressure change
            data1 = (int) (update->parameter.r * 127);
            if (update->get_identifier() < 0) {
               // Channel pressure
               data2 = 0;
               command = 0xD0; // MIDI CHANNEL PRESSURE
            } else {
               // Key pressure
               data2 = data1;
               data1 = update->get_identifier();
               command = 0xA0; // MIDI POLY PRESSURE
            }
         }
      }
      if (command != -1) {
         // keep track of greatest timestamp used
         if (timestamp > mMIDIPlay.mMaxMidiTimestamp) {
            mMIDIPlay.mMaxMidiTimestamp = timestamp;
         }
         Pm_WriteShort(mMIDIPlay.mMidiStream, timestamp,
                    Pm_Message((int) (command + channel),
                                  (long) data1, (long) data2));
         /* wxPrintf("Pm_WriteShort %lx (%p) @ %d, advance %d\n",
                Pm_Message((int) (command + channel),
                           (long) data1, (long) data2),
                           mNextEvent, timestamp, timestamp - Pt_Time()); */
      }
   }
   return false;
}

References anonymous_namespace{MIDIPlay.h}::MIDIPlay::AllNotesOff(), details::end(), anonymous_namespace{MIDIPlay.h}::gAllNotesOff, PlaybackSchedule::GetPolicy(), NoteTrack::GetVelocity(), it, PlaybackPolicy::Looping(), anonymous_namespace{MIDIPlay.h}::MIDIPlay::mMaxMidiTimestamp, mMIDIPlay, anonymous_namespace{MIDIPlay.h}::MIDIPlay::mMidiStream, mNextEvent, mNextEventTrack, mNextIsNoteOn, anonymous_namespace{MIDIPlay.h}::MIDIPlay::mPendingNotesOff, mPlaybackSchedule, anonymous_namespace{MIDIPlay.h}::MIDIPlay::mSynthLatency, name, ROUND, UncorrectedMidiEventTime(), and Unmuted().

Referenced by Prime().

Here is the call graph for this function:

Here is the caller graph for this function:

Prime()

void anonymous_namespace{MIDIPlay.cpp}::Iterator::Prime	(	bool	send,
		double	startTime
	)

Definition at line 652 of file MIDIPlay.cpp.

{
   GetNextEvent(); // prime the pump for FillOtherBuffers
 
   // Start MIDI from current cursor position
   while (mNextEvent &&
          GetNextEventTime() < startTime) {
      if (send)
         /*
          hasSolo argument doesn't matter because midiStateOnly is true.
          "Fast-forward" all update events from the start of track to the given
          play start time so the notes sound with correct timbre whenever
          turned on.
          */
         OutputEvent(0, true, false);
      GetNextEvent();
   }
}

References GetNextEvent(), GetNextEventTime(), mNextEvent, and OutputEvent().

Referenced by Iterator().

Here is the call graph for this function:

Here is the caller graph for this function:

UncorrectedMidiEventTime()

double anonymous_namespace{MIDIPlay.cpp}::Iterator::UncorrectedMidiEventTime

(

double

pauseTime

)

Definition at line 780 of file MIDIPlay.cpp.

{
   double time;
   if (mPlaybackSchedule.mEnvelope)
      time =
         mPlaybackSchedule.RealDuration(
            GetNextEventTime() - mMIDIPlay.MidiLoopOffset())
         + mPlaybackSchedule.mT0 +
           (mMIDIPlay.mMidiLoopPasses * mPlaybackSchedule.mWarpedLength);
   else
      time = GetNextEventTime();
 
   return time + pauseTime;
}

References GetNextEventTime(), PlaybackSchedule::mEnvelope, anonymous_namespace{MIDIPlay.h}::MIDIPlay::MidiLoopOffset(), anonymous_namespace{MIDIPlay.h}::MIDIPlay::mMidiLoopPasses, mMIDIPlay, mPlaybackSchedule, PlaybackSchedule::mT0, PlaybackSchedule::mWarpedLength, and PlaybackSchedule::RealDuration().

Referenced by OutputEvent().

Here is the call graph for this function:

Here is the caller graph for this function:

Unmuted()

bool anonymous_namespace{MIDIPlay.cpp}::Iterator::Unmuted

(

bool

hasSolo

)

const

Definition at line 795 of file MIDIPlay.cpp.

{
   int channel = (mNextEvent->chan) & 0xF; // must be in [0..15]
   if (!mNextEventTrack->IsVisibleChan(channel))
      return false;
   const bool channelIsMute = hasSolo
      ? !mNextEventTrack->GetSolo()
      : mNextEventTrack->GetMute();
   return !channelIsMute;
}

References PlayableTrack::GetMute(), PlayableTrack::GetSolo(), NoteTrack::IsVisibleChan(), mNextEvent, and mNextEventTrack.

Referenced by OutputEvent().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

it

Alg_iterator anonymous_namespace{MIDIPlay.h}::Iterator::it { nullptr, false }

Definition at line 67 of file MIDIPlay.h.

Referenced by GetNextEvent(), Iterator(), OutputEvent(), and ~Iterator().

mMIDIPlay

MIDIPlay& anonymous_namespace{MIDIPlay.h}::Iterator::mMIDIPlay

Definition at line 66 of file MIDIPlay.h.

Referenced by GetNextEvent(), OutputEvent(), and UncorrectedMidiEventTime().

mNextEvent

Alg_event* anonymous_namespace{MIDIPlay.h}::Iterator::mNextEvent = nullptr

The next event to play (or null)

Definition at line 69 of file MIDIPlay.h.

Referenced by GetNextEvent(), GetNextEventTime(), OutputEvent(), Prime(), and Unmuted().

mNextEventTime

double anonymous_namespace{MIDIPlay.h}::Iterator::mNextEventTime = 0

private

Real time at which the next event should be output, measured in seconds. Note that this could be a note's time+duration for note offs.

Definition at line 80 of file MIDIPlay.h.

Referenced by GetNextEvent(), and GetNextEventTime().

mNextEventTrack

NoteTrack* anonymous_namespace{MIDIPlay.h}::Iterator::mNextEventTrack = nullptr

Track of next event.

Definition at line 72 of file MIDIPlay.h.

Referenced by GetNextEvent(), OutputEvent(), and Unmuted().

mNextIsNoteOn

bool anonymous_namespace{MIDIPlay.h}::Iterator::mNextIsNoteOn = false

Is the next event a note-on?

Definition at line 75 of file MIDIPlay.h.

Referenced by GetNextEvent(), and OutputEvent().

mPlaybackSchedule

const PlaybackSchedule& anonymous_namespace{MIDIPlay.h}::Iterator::mPlaybackSchedule

Definition at line 65 of file MIDIPlay.h.

Referenced by GetNextEvent(), OutputEvent(), and UncorrectedMidiEventTime().

---

The documentation for this struct was generated from the following files:

• MIDIPlay.h
• MIDIPlay.cpp