anonymous_namespace{MIDIPlay.h}::MIDIPlay Struct Reference

#include <MIDIPlay.h>

Inheritance diagram for anonymous_namespace{MIDIPlay.h}::MIDIPlay:

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

Public Member Functions
	MIDIPlay (const PlaybackSchedule &schedule)
	~MIDIPlay () override
double	AudioTime (double rate) const
double	MidiLoopOffset ()
void	PrepareMidiIterator (bool send, double startTime, double offset)
bool	StartPortMidiStream (double rate)
double	PauseTime (double rate, unsigned long pauseFrames)
void	AllNotesOff (bool looping=false)
PmTimestamp	MidiTime ()
	Compute the current PortMidi timestamp time. More...
bool	IsOtherStreamActive () const override
void	ComputeOtherTimings (double rate, bool paused, const PaStreamCallbackTimeInfo *timeInfo, unsigned long framesPerBuffer) override
void	SignalOtherCompletion () override
unsigned	CountOtherSolo () const override
bool	StartOtherStream (const TransportSequences &tracks, const PaStreamInfo *info, double startTime, double rate) override
void	AbortOtherStream () override
void	FillOtherBuffers (double rate, unsigned long pauseFrames, bool paused, bool hasSolo) override
void	StopOtherStream () override
AudioIODiagnostics	Dump () const override
	Get diagnostic information for audio devices and also for extensions. More...
Public Member Functions inherited from AudioIOExt
virtual	~AudioIOExt ()
virtual void	ComputeOtherTimings (double rate, bool paused, const PaStreamCallbackTimeInfo *timeInfo, unsigned long framesPerBuffer)=0
virtual void	SignalOtherCompletion ()=0
virtual unsigned	CountOtherSolo () const =0
virtual bool	StartOtherStream (const TransportSequences &tracks, const PaStreamInfo *info, double startTime, double rate)=0
virtual void	AbortOtherStream ()=0
virtual void	FillOtherBuffers (double rate, unsigned long pauseFrames, bool paused, bool hasSolo)=0
virtual void	StopOtherStream ()=0
Public Member Functions inherited from AudioIOExtBase
virtual	~AudioIOExtBase ()
virtual bool	IsOtherStreamActive () const =0
virtual AudioIODiagnostics	Dump () const =0
	Get diagnostic information for audio devices and also for extensions. More...

Static Public Member Functions
static bool	IsActive ()
Static Public Member Functions inherited from AudioIOExt
static Factories &	GetFactories ()

Public Attributes
const PlaybackSchedule &	mPlaybackSchedule
NoteTrackConstArray	mMidiPlaybackTracks
PmStream *	mMidiStream = nullptr
int	mLastPmError = 0
long	mSynthLatency = MIDISynthLatency_ms.GetDefault()
	Latency of MIDI synthesizer. More...
long	mNumFrames = 0
	Number of frames output, including pauses. More...
int	mMidiLoopPasses = 0
	total of backward jumps More...
long	mAudioFramesPerBuffer = 0
bool	mMidiPaused = false
PmTimestamp	mMaxMidiTimestamp = 0
double	mSystemMinusAudioTime = 0.0
double	mAudioOutLatency = 0.0
double	mStartTime = 0.0
long	mCallbackCount = 0
	number of callbacks since stream start More...
double	mSystemMinusAudioTimePlusLatency = 0.0
std::optional< Iterator >	mIterator
std::vector< std::pair< int, int > >	mPendingNotesOff
bool	mUsingAlsa = false

Static Public Attributes
static bool	mMidiOutputComplete = true
	True when output reaches mT1. More...
static bool	mMidiStreamActive = false
	mMidiStreamActive tells when mMidiStream is open for output More...

Additional Inherited Members
Public Types inherited from AudioIOExt
using	Factory = std::function< std::unique_ptr< AudioIOExt >(const PlaybackSchedule &) >
using	Factories = std::vector< AudioIOExt::Factory >

Detailed Description

Definition at line 83 of file MIDIPlay.h.

Constructor & Destructor Documentation

MIDIPlay()

MIDIPlay::MIDIPlay ( const PlaybackSchedule &  schedule )

explicit

Definition at line 517 of file MIDIPlay.cpp.

   : mPlaybackSchedule{ schedule }
{
#ifdef AUDIO_IO_GB_MIDI_WORKAROUND
   // Pre-allocate with a likely sufficient size, exceeding probable number of
   // channels
   mPendingNotesOff.reserve(64);
#endif
 
   PmError pmErr = Pm_Initialize();
 
   if (pmErr != pmNoError) {
      auto errStr =
              XO("There was an error initializing the midi i/o layer.\n");
      errStr += XO("You will not be able to play midi.\n\n");
      wxString pmErrStr = LAT1CTOWX(Pm_GetErrorText(pmErr));
      if (!pmErrStr.empty())
         errStr += XO("Error: %s").Format( pmErrStr );
      // XXX: we are in libaudacity, popping up dialogs not allowed!  A
      // long-term solution will probably involve exceptions
      using namespace BasicUI;
      ShowMessageBox(
         errStr,
         MessageBoxOptions{}
            .Caption(XO("Error Initializing Midi"))
            .ButtonStyle(Button::Ok)
            .IconStyle(Icon::Error));
 
      // Same logic for PortMidi as described above for PortAudio
   }
}

References BasicUI::MessageBoxOptions::Caption(), LAT1CTOWX, mPendingNotesOff, BasicUI::ShowMessageBox(), and XO().

Here is the call graph for this function:

~MIDIPlay()

MIDIPlay::~MIDIPlay ( )

override

Definition at line 549 of file MIDIPlay.cpp.

{
   Pm_Terminate();
}

Member Function Documentation

AbortOtherStream()

void MIDIPlay::AbortOtherStream ( )

overridevirtual

Implements AudioIOExt.

Definition at line 604 of file MIDIPlay.cpp.

{
   mMidiPlaybackTracks.clear();
}

References mMidiPlaybackTracks.

AllNotesOff()

void MIDIPlay::AllNotesOff

(

bool

looping = false

)

Definition at line 1064 of file MIDIPlay.cpp.

{
#ifdef __WXGTK__
   bool doDelay = !looping;
#else
   bool doDelay = false;
   static_cast<void>(looping);// compiler food.
#endif
 
   // to keep track of when MIDI should all be delivered,
   // update mMaxMidiTimestamp to now:
   PmTimestamp now = MidiTime();
   if (mMaxMidiTimestamp < now) {
       mMaxMidiTimestamp = now;
   }
#ifdef AUDIO_IO_GB_MIDI_WORKAROUND
   // PRL:
   // Send individual note-off messages for each note-on not yet paired.
 
   // RBD:
   // Even this did not work as planned. My guess is ALSA does not use
   // a "stable sort" for timed messages, so that when a note-off is
   // added later at the same time as a future note-on, the order is
   // not respected, and the note-off can go first, leaving a stuck note.
   // The workaround here is to use mMaxMidiTimestamp to ensure that
   // note-offs come at least 1ms later than any previous message
 
   // PRL:
   // I think we should do that only when stopping or pausing, not when looping
   // Note that on Linux, MIDI always uses ALSA, no matter whether portaudio
   // uses some other host api.
 
   mMaxMidiTimestamp += 1;
   for (const auto &pair : mPendingNotesOff) {
      Pm_WriteShort(mMidiStream,
                    (doDelay ? mMaxMidiTimestamp : 0),
                    Pm_Message(
         0x90 + pair.first, pair.second, 0));
      mMaxMidiTimestamp++; // allow 1ms per note-off
   }
   mPendingNotesOff.clear();
 
   // Proceed to do the usual messages too.
#endif
 
   for (int chan = 0; chan < 16; chan++) {
      Pm_WriteShort(mMidiStream,
                    (doDelay ? mMaxMidiTimestamp : 0),
                    Pm_Message(0xB0 + chan, 0x7B, 0));
      mMaxMidiTimestamp++; // allow 1ms per all-notes-off
   }
}

References MidiTime(), mMaxMidiTimestamp, mMidiStream, and mPendingNotesOff.

Referenced by ComputeOtherTimings(), anonymous_namespace{MIDIPlay.h}::Iterator::OutputEvent(), and StopOtherStream().

Here is the call graph for this function:

Here is the caller graph for this function:

AudioTime()

double anonymous_namespace{MIDIPlay.h}::MIDIPlay::AudioTime ( double  rate ) const

inline

Definition at line 88 of file MIDIPlay.h.

   { return mPlaybackSchedule.mT0 + mNumFrames / rate; }

Referenced by ComputeOtherTimings(), and FillOtherBuffers().

Here is the caller graph for this function:

ComputeOtherTimings()

void MIDIPlay::ComputeOtherTimings ( double  rate, bool  paused, const PaStreamCallbackTimeInfo *  timeInfo, unsigned long  framesPerBuffer  )

overridevirtual

Implements AudioIOExt.

Definition at line 1117 of file MIDIPlay.cpp.

{
   if (mCallbackCount++ == 0) {
       // This is effectively mSystemMinusAudioTime when the buffer is empty:
       mStartTime = SystemTime(mUsingAlsa) - mPlaybackSchedule.mT0;
       // later, mStartTime - mSystemMinusAudioTime will tell us latency
   }
 
   /* for Linux, estimate a smooth audio time as a slowly-changing
      offset from system time */
   // rnow is system time as a double to simplify math
   double rnow = SystemTime(mUsingAlsa);
   // anow is next-sample-to-be-computed audio time as a double
   double anow = AudioTime(rate);
 
   if (mUsingAlsa) {
      // timeInfo's fields are not all reliable.
 
      // enow is audio time estimated from our clock synchronization protocol,
      //   which produces mSystemMinusAudioTime. But we want the estimate
      //   to drift low, so we steadily increase mSystemMinusAudioTime to
      //   simulate a fast system clock or a slow audio clock. If anow > enow,
      //   we'll update mSystemMinusAudioTime to keep in sync. (You might think
      //   we could just use anow as the "truth", but it has a lot of jitter,
      //   so we are using enow to smooth out this jitter, in fact to < 1ms.)
      // Add worst-case clock drift using previous framesPerBuffer:
      const auto increase =
         mAudioFramesPerBuffer * 0.0002 / rate;
      mSystemMinusAudioTime += increase;
      mSystemMinusAudioTimePlusLatency += increase;
      double enow = rnow - mSystemMinusAudioTime;
 
 
      // now, use anow instead if it is ahead of enow
      if (anow > enow) {
         mSystemMinusAudioTime = rnow - anow;
         // Update our mAudioOutLatency estimate during the first 20 callbacks.
         // During this period, the buffer should fill. Once we have a good
         // estimate of mSystemMinusAudioTime (expected in fewer than 20 callbacks)
         // we want to stop the updating in case there is clock drift, which would
         // cause the mAudioOutLatency estimation to drift as well. The clock drift
         // in the first 20 callbacks should be negligible, however.
         if (mCallbackCount < 20) {
            mAudioOutLatency = mStartTime -
               mSystemMinusAudioTime;
         }
         mSystemMinusAudioTimePlusLatency =
            mSystemMinusAudioTime + mAudioOutLatency;
      }
   }
   else {
      // If not using Alsa, rely on timeInfo to have meaningful values that are
      // more precise than the output latency value reported at stream start.
      mSystemMinusAudioTime = rnow - anow;
      mSystemMinusAudioTimePlusLatency =
         mSystemMinusAudioTime +
            (timeInfo->outputBufferDacTime - timeInfo->currentTime);
   }
 
   mAudioFramesPerBuffer = framesPerBuffer;
   mNumFrames += framesPerBuffer;
 
   // Keep track of time paused.
   if (paused) {
      if (!mMidiPaused) {
         mMidiPaused = true;
         AllNotesOff(); // to avoid hanging notes during pause
      }
   }
   else if (mMidiPaused)
      mMidiPaused = false;
}

References AllNotesOff(), AudioTime(), mAudioFramesPerBuffer, mAudioOutLatency, mCallbackCount, mMidiPaused, mNumFrames, mPlaybackSchedule, mStartTime, mSystemMinusAudioTime, mSystemMinusAudioTimePlusLatency, PlaybackSchedule::mT0, mUsingAlsa, and anonymous_namespace{MIDIPlay.cpp}::SystemTime().

Here is the call graph for this function:

CountOtherSolo()

unsigned MIDIPlay::CountOtherSolo ( ) const

overridevirtual

Implements AudioIOExt.

Definition at line 1193 of file MIDIPlay.cpp.

{
   return std::count_if(
      mMidiPlaybackTracks.begin(), mMidiPlaybackTracks.end(),
      [](const auto &pTrack){ return pTrack->GetSolo(); } );
}

References mMidiPlaybackTracks.

Dump()

AudioIODiagnostics MIDIPlay::Dump ( ) const

overridevirtual

Get diagnostic information for audio devices and also for extensions.

Implements AudioIOExtBase.

Definition at line 1216 of file MIDIPlay.cpp.

{
   return {
      wxT("mididev.txt"),
      GetMIDIDeviceInfo(),
      wxT("MIDI Device Info")
   };
}

References GetMIDIDeviceInfo(), and wxT().

Here is the call graph for this function:

FillOtherBuffers()

void MIDIPlay::FillOtherBuffers ( double  rate, unsigned long  pauseFrames, bool  paused, bool  hasSolo  )

overridevirtual

Implements AudioIOExt.

Definition at line 992 of file MIDIPlay.cpp.

{
   if (!mMidiStream)
      return;
 
   // If not paused, fill buffers.
   if (paused)
      return;
 
   // If we compute until GetNextEventTime() > current audio time,
   // we would have a built-in compute-ahead of mAudioOutLatency, and
   // it's probably good to compute MIDI when we compute audio (so when
   // we stop, both stop about the same time).
   double time = AudioTime(rate); // compute to here
   // But if mAudioOutLatency is very low, we might need some extra
   // compute-ahead to deal with mSynthLatency or even this thread.
   double actual_latency  = (MIDI_MINIMAL_LATENCY_MS + mSynthLatency) * 0.001;
   if (actual_latency > mAudioOutLatency) {
       time += actual_latency - mAudioOutLatency;
   }
   while (mIterator &&
          mIterator->mNextEvent &&
          mIterator->UncorrectedMidiEventTime(PauseTime(rate, pauseFrames)) < time) {
      if (mIterator->OutputEvent(PauseTime(rate, pauseFrames), false, hasSolo)) {
         if (mPlaybackSchedule.GetPolicy().Looping(mPlaybackSchedule)) {
            // jump back to beginning of loop
            ++mMidiLoopPasses;
            PrepareMidiIterator(false, mPlaybackSchedule.mT0, MidiLoopOffset());
         }
         else
            mIterator.reset();
      }
      else if (mIterator)
         mIterator->GetNextEvent();
   }
}

References AudioTime(), PlaybackSchedule::GetPolicy(), PlaybackPolicy::Looping(), mAudioOutLatency, anonymous_namespace{MIDIPlay.cpp}::MIDI_MINIMAL_LATENCY_MS, MidiLoopOffset(), mIterator, mMidiLoopPasses, mMidiStream, mPlaybackSchedule, mSynthLatency, PlaybackSchedule::mT0, PauseTime(), and PrepareMidiIterator().

Here is the call graph for this function:

IsActive()

bool MIDIPlay::IsActive ( )

static

Definition at line 1206 of file MIDIPlay.cpp.

{
   return ( mMidiStreamActive && !mMidiOutputComplete );
}

IsOtherStreamActive()

bool MIDIPlay::IsOtherStreamActive ( ) const

overridevirtual

Implements AudioIOExtBase.

Definition at line 1211 of file MIDIPlay.cpp.

{
   return IsActive();
}

MidiLoopOffset()

double anonymous_namespace{MIDIPlay.h}::MIDIPlay::MidiLoopOffset ( )

inline

Definition at line 113 of file MIDIPlay.h.

                                  {
      return mMidiLoopPasses * (mPlaybackSchedule.mT1 - mPlaybackSchedule.mT0);
   }

References PlaybackSchedule::mT0, and PlaybackSchedule::mT1.

Referenced by FillOtherBuffers(), anonymous_namespace{MIDIPlay.h}::Iterator::GetNextEvent(), and anonymous_namespace{MIDIPlay.h}::Iterator::UncorrectedMidiEventTime().

Here is the caller graph for this function:

MidiTime()

PmTimestamp MIDIPlay::MidiTime

(

)

Compute the current PortMidi timestamp time.

This is used by PortMidi to synchronize midi time to audio samples

Definition at line 1040 of file MIDIPlay.cpp.

{
   // note: the extra 0.0005 is for rounding. Round down by casting to
   // unsigned long, then convert to PmTimeStamp (currently signed)
 
   // PRL: the time correction is really Midi latency achieved by different
   // means than specifying it to Pm_OpenStream.  The use of the accumulated
   // sample count generated by the audio callback (in AudioTime()) might also
   // have the virtue of keeping the Midi output synched with audio.
 
   PmTimestamp ts;
   // subtract latency here because mSystemMinusAudioTime gets us
   // to the current *write* time, but we're writing ahead by audio output
   // latency (mAudioOutLatency).
   double now = SystemTime(mUsingAlsa);
   ts = (PmTimestamp) ((unsigned long)
         (1000 * (now + 1.0005 -
                  mSystemMinusAudioTimePlusLatency)));
   // wxPrintf("AudioIO::MidiTime() %d time %g sys-aud %g\n",
   //        ts, now, mSystemMinusAudioTime);
   return ts + MIDI_MINIMAL_LATENCY_MS;
}

References anonymous_namespace{MIDIPlay.cpp}::MIDI_MINIMAL_LATENCY_MS, mSystemMinusAudioTimePlusLatency, mUsingAlsa, and anonymous_namespace{MIDIPlay.cpp}::SystemTime().

Referenced by AllNotesOff(), StartPortMidiStream(), and StopOtherStream().

Here is the call graph for this function:

Here is the caller graph for this function:

PauseTime()

double MIDIPlay::PauseTime	(	double	rate,
		unsigned long	pauseFrames
	)

Definition at line 1030 of file MIDIPlay.cpp.

{
   return pauseFrames / rate;
}

Referenced by FillOtherBuffers().

Here is the caller graph for this function:

PrepareMidiIterator()

void MIDIPlay::PrepareMidiIterator	(	bool	send,
		double	startTime,
		double	offset
	)

Definition at line 618 of file MIDIPlay.cpp.

{
   mIterator.emplace(mPlaybackSchedule, *this,
      mMidiPlaybackTracks, startTime, offset, send);
}

References mIterator, mMidiPlaybackTracks, and mPlaybackSchedule.

Referenced by FillOtherBuffers(), and StartPortMidiStream().

Here is the caller graph for this function:

SignalOtherCompletion()

void MIDIPlay::SignalOtherCompletion ( )

overridevirtual

Implements AudioIOExt.

Definition at line 1200 of file MIDIPlay.cpp.

{
   mMidiOutputComplete = true;
}

References mMidiOutputComplete.

StartOtherStream()

bool MIDIPlay::StartOtherStream ( const TransportSequences &  tracks, const PaStreamInfo *  info, double  startTime, double  rate  )

overridevirtual

Implements AudioIOExt.

Definition at line 554 of file MIDIPlay.cpp.

{
   mMidiPlaybackTracks.clear();
   for (const auto &pSequence : tracks.otherPlayableSequences)
      if (const auto pNoteTrack =
         dynamic_cast<const NoteTrack *>(pSequence.get())
      )
         mMidiPlaybackTracks.push_back(
            pNoteTrack->SharedPointer<const NoteTrack>());
 
   streamStartTime = 0;
   streamStartTime = SystemTime(mUsingAlsa);
 
   mNumFrames = 0;
   // we want this initial value to be way high. It should be
   // sufficient to assume AudioTime is zero and therefore
   // mSystemMinusAudioTime is SystemTime(), but we'll add 1000s
   // for good measure. On the first callback, this should be
   // reduced to SystemTime() - mT0, and note that mT0 is always
   // positive.
   mSystemMinusAudioTimePlusLatency =
      mSystemMinusAudioTime = SystemTime(mUsingAlsa) + 1000;
   mAudioOutLatency = 0.0; // set when stream is opened
   mCallbackCount = 0;
   mAudioFramesPerBuffer = 0;
 
   // We use audio latency to estimate how far ahead of DACS we are writing
   if (info) {
      // this is an initial guess, but for PA/Linux/ALSA it's wrong and will be
      // updated with a better value:
      mAudioOutLatency = info->outputLatency;
      mSystemMinusAudioTimePlusLatency += mAudioOutLatency;
   }
 
   // TODO: it may be that midi out will not work unless audio in or out is
   // active -- this would be a bug and may require a change in the
   // logic here.
 
   bool successMidi = true;
 
   if(!mMidiPlaybackTracks.empty()){
      successMidi = StartPortMidiStream(rate);
   }
 
   // On the other hand, if MIDI cannot be opened, we will not complain
   // return successMidi;
   return true;
}

References mAudioFramesPerBuffer, mAudioOutLatency, mCallbackCount, mMidiPlaybackTracks, mNumFrames, mSystemMinusAudioTime, mSystemMinusAudioTimePlusLatency, mUsingAlsa, StartPortMidiStream(), anonymous_namespace{MIDIPlay.cpp}::streamStartTime, anonymous_namespace{MIDIPlay.cpp}::SystemTime(), and tracks.

Here is the call graph for this function:

StartPortMidiStream()

bool MIDIPlay::StartPortMidiStream

(

double

rate

)

Definition at line 679 of file MIDIPlay.cpp.

{
#ifdef __WXGTK__
   // Duplicating a bit of AudioIO::StartStream
   // Detect whether ALSA is the chosen host, and do the various involved MIDI
   // timing compensations only then.
   mUsingAlsa = (AudioIOHost.Read() == L"ALSA");
#endif
 
   int i;
   int nTracks = mMidiPlaybackTracks.size();
   // Only start MIDI stream if there is an open track
   if (nTracks == 0)
      return false;
 
   //wxPrintf("StartPortMidiStream: mT0 %g mTime %g\n",
   //       mT0, mTime);
 
   /* get midi playback device */
   PmDeviceID playbackDevice = Pm_GetDefaultOutputDeviceID();
   auto playbackDeviceName = MIDIPlaybackDevice.Read();
   mSynthLatency = MIDISynthLatency_ms.Read();
   if (wxStrcmp(playbackDeviceName, wxT("")) != 0) {
      for (i = 0; i < Pm_CountDevices(); i++) {
         const PmDeviceInfo *info = Pm_GetDeviceInfo(i);
         if (!info) continue;
         if (!info->output) continue;
         wxString interf = wxSafeConvertMB2WX(info->interf);
         wxString name = wxSafeConvertMB2WX(info->name);
         interf.Append(wxT(": ")).Append(name);
         if (wxStrcmp(interf, playbackDeviceName) == 0) {
            playbackDevice = i;
         }
      }
   } // (else playback device has Pm_GetDefaultOuputDeviceID())
 
   if (playbackDevice < 0)
      return false;
 
   /* open output device */
   mLastPmError = Pm_OpenOutput(&mMidiStream,
                                playbackDevice,
                                NULL,
                                0,
                                &::MidiTime,
                                this, // supplies pInfo argument to MidiTime
                                MIDI_MINIMAL_LATENCY_MS);
   if (mLastPmError == pmNoError) {
      mMidiStreamActive = true;
      mMidiPaused = false;
      mMidiLoopPasses = 0;
      mMidiOutputComplete = false;
      mMaxMidiTimestamp = 0;
      PrepareMidiIterator(true, mPlaybackSchedule.mT0, 0);
 
      // It is ok to call this now, but do not send timestamped midi
      // until after the first audio callback, which provides necessary
      // data for MidiTime().
      Pm_Synchronize(mMidiStream); // start using timestamps
   }
   return (mLastPmError == pmNoError);
}

References AudioIOHost, anonymous_namespace{MIDIPlay.cpp}::MIDI_MINIMAL_LATENCY_MS, MIDIPlaybackDevice, MIDISynthLatency_ms, MidiTime(), mLastPmError, mMaxMidiTimestamp, mMidiLoopPasses, mMidiOutputComplete, mMidiPaused, mMidiPlaybackTracks, mMidiStream, mMidiStreamActive, mPlaybackSchedule, mSynthLatency, PlaybackSchedule::mT0, mUsingAlsa, name, PrepareMidiIterator(), Setting< T >::Read(), and wxT().

Referenced by StartOtherStream().

Here is the call graph for this function:

Here is the caller graph for this function:

StopOtherStream()

void MIDIPlay::StopOtherStream ( )

overridevirtual

Implements AudioIOExt.

Definition at line 742 of file MIDIPlay.cpp.

{
   if (mMidiStream && mMidiStreamActive) {
      /* Stop Midi playback */
      mMidiStreamActive = false;
 
      mMidiOutputComplete = true;
 
      // now we can assume "ownership" of the mMidiStream
      // if output in progress, send all off, etc.
      AllNotesOff();
      // AllNotesOff() should be sufficient to stop everything, but
      // in Linux, if you Pm_Close() immediately, it looks like
      // messages are dropped. ALSA then seems to send All Sound Off
      // and Reset All Controllers messages, but not all synthesizers
      // respond to these messages. This is probably a bug in PortMidi
      // if the All Off messages do not get out, but for security,
      // delay a bit so that messages can be delivered before closing
      // the stream. Add 2ms of "padding" to avoid any rounding errors.
      while (mMaxMidiTimestamp + 2 > MidiTime()) {
         using namespace std::chrono;
         std::this_thread::sleep_for(1ms); // deliver the all-off messages
      }
      Pm_Close(mMidiStream);
      mMidiStream = NULL;
      mIterator.reset();
 
      // set in_use flags to false
      int nTracks = mMidiPlaybackTracks.size();
      for (int i = 0; i < nTracks; i++) {
         const auto t = mMidiPlaybackTracks[i].get();
         Alg_seq_ptr seq = &t->GetSeq();
         seq->set_in_use(false);
      }
   }
 
   mMidiPlaybackTracks.clear();
}

References AllNotesOff(), MidiTime(), mIterator, mMaxMidiTimestamp, mMidiOutputComplete, mMidiPlaybackTracks, mMidiStream, and mMidiStreamActive.

Here is the call graph for this function:

Member Data Documentation

mAudioFramesPerBuffer

long anonymous_namespace{MIDIPlay.h}::MIDIPlay::mAudioFramesPerBuffer = 0

Definition at line 117 of file MIDIPlay.h.

Referenced by ComputeOtherTimings(), and StartOtherStream().

mAudioOutLatency

double anonymous_namespace{MIDIPlay.h}::MIDIPlay::mAudioOutLatency = 0.0

audio output latency reported by PortAudio (initially; for Alsa, we adjust it to the largest "observed" value)

Definition at line 131 of file MIDIPlay.h.

Referenced by ComputeOtherTimings(), FillOtherBuffers(), and StartOtherStream().

mCallbackCount

long anonymous_namespace{MIDIPlay.h}::MIDIPlay::mCallbackCount = 0

number of callbacks since stream start

Definition at line 140 of file MIDIPlay.h.

Referenced by ComputeOtherTimings(), and StartOtherStream().

mIterator

std::optional<Iterator> anonymous_namespace{MIDIPlay.h}::MIDIPlay::mIterator

Definition at line 144 of file MIDIPlay.h.

Referenced by FillOtherBuffers(), PrepareMidiIterator(), and StopOtherStream().

mLastPmError

int anonymous_namespace{MIDIPlay.h}::MIDIPlay::mLastPmError = 0

Definition at line 101 of file MIDIPlay.h.

Referenced by StartPortMidiStream().

mMaxMidiTimestamp

PmTimestamp anonymous_namespace{MIDIPlay.h}::MIDIPlay::mMaxMidiTimestamp = 0

The largest timestamp written so far, used to delay stream closing until last message has been delivered

Definition at line 123 of file MIDIPlay.h.

Referenced by AllNotesOff(), anonymous_namespace{MIDIPlay.h}::Iterator::OutputEvent(), StartPortMidiStream(), and StopOtherStream().

mMidiLoopPasses

int anonymous_namespace{MIDIPlay.h}::MIDIPlay::mMidiLoopPasses = 0

total of backward jumps

Definition at line 111 of file MIDIPlay.h.

Referenced by FillOtherBuffers(), StartPortMidiStream(), and anonymous_namespace{MIDIPlay.h}::Iterator::UncorrectedMidiEventTime().

mMidiOutputComplete

bool MIDIPlay::mMidiOutputComplete = true

static

True when output reaches mT1.

Definition at line 95 of file MIDIPlay.h.

Referenced by SignalOtherCompletion(), StartPortMidiStream(), and StopOtherStream().

mMidiPaused

bool anonymous_namespace{MIDIPlay.h}::MIDIPlay::mMidiPaused = false

Used by Midi process to record that pause has begun, so that AllNotesOff() is only delivered once

Definition at line 120 of file MIDIPlay.h.

Referenced by ComputeOtherTimings(), and StartPortMidiStream().

mMidiPlaybackTracks

NoteTrackConstArray anonymous_namespace{MIDIPlay.h}::MIDIPlay::mMidiPlaybackTracks

Definition at line 92 of file MIDIPlay.h.

Referenced by AbortOtherStream(), CountOtherSolo(), PrepareMidiIterator(), StartOtherStream(), StartPortMidiStream(), and StopOtherStream().

mMidiStream

PmStream* anonymous_namespace{MIDIPlay.h}::MIDIPlay::mMidiStream = nullptr

Definition at line 100 of file MIDIPlay.h.

Referenced by AllNotesOff(), FillOtherBuffers(), anonymous_namespace{MIDIPlay.h}::Iterator::OutputEvent(), StartPortMidiStream(), and StopOtherStream().

mMidiStreamActive

bool MIDIPlay::mMidiStreamActive = false

static

mMidiStreamActive tells when mMidiStream is open for output

Definition at line 98 of file MIDIPlay.h.

Referenced by StartPortMidiStream(), and StopOtherStream().

mNumFrames

long anonymous_namespace{MIDIPlay.h}::MIDIPlay::mNumFrames = 0

Number of frames output, including pauses.

Definition at line 109 of file MIDIPlay.h.

Referenced by ComputeOtherTimings(), and StartOtherStream().

mPendingNotesOff

std::vector< std::pair< int, int > > anonymous_namespace{MIDIPlay.h}::MIDIPlay::mPendingNotesOff

Definition at line 147 of file MIDIPlay.h.

Referenced by AllNotesOff(), MIDIPlay(), and anonymous_namespace{MIDIPlay.h}::Iterator::OutputEvent().

mPlaybackSchedule

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

Definition at line 91 of file MIDIPlay.h.

Referenced by ComputeOtherTimings(), FillOtherBuffers(), PrepareMidiIterator(), and StartPortMidiStream().

mStartTime

double anonymous_namespace{MIDIPlay.h}::MIDIPlay::mStartTime = 0.0

time of first callback used to find "observed" latency

Definition at line 138 of file MIDIPlay.h.

Referenced by ComputeOtherTimings().

mSynthLatency

long anonymous_namespace{MIDIPlay.h}::MIDIPlay::mSynthLatency = MIDISynthLatency_ms.GetDefault()

Latency of MIDI synthesizer.

Definition at line 104 of file MIDIPlay.h.

Referenced by FillOtherBuffers(), anonymous_namespace{MIDIPlay.h}::Iterator::OutputEvent(), and StartPortMidiStream().

mSystemMinusAudioTime

double anonymous_namespace{MIDIPlay.h}::MIDIPlay::mSystemMinusAudioTime = 0.0

Offset from ideal sample computation time to system time, where "ideal" means when we would get the callback if there were no scheduling delays or computation time

Definition at line 128 of file MIDIPlay.h.

Referenced by ComputeOtherTimings(), and StartOtherStream().

mSystemMinusAudioTimePlusLatency

double anonymous_namespace{MIDIPlay.h}::MIDIPlay::mSystemMinusAudioTimePlusLatency = 0.0

Definition at line 142 of file MIDIPlay.h.

Referenced by ComputeOtherTimings(), MidiTime(), and StartOtherStream().

mUsingAlsa

bool anonymous_namespace{MIDIPlay.h}::MIDIPlay::mUsingAlsa = false

Definition at line 161 of file MIDIPlay.h.

Referenced by ComputeOtherTimings(), MidiTime(), StartOtherStream(), and StartPortMidiStream().

---

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

• MIDIPlay.h
• MIDIPlay.cpp