lily/midi-walker.cc

   1 /*
   2   midi-walker.cc -- implement Midi_walker
   3
   4   source file of the GNU LilyPond music typesetter
   5
   6   (c) 1997--2004 Han-Wen Nienhuys <hanwen@cs.uu.nl>
   7          Jan Nieuwenhuizen <janneke@gnu.org>
   8  */
   9
  10 #include "midi-walker.hh"
  11 #include "audio-column.hh"
  12 #include "audio-item.hh"
  13 #include "audio-staff.hh"
  14 #include "midi-item.hh"
  15 #include "midi-stream.hh"
  16 #include "warn.hh"
  17
  18 Midi_note_event::Midi_note_event ()
  19 {
  20   ignore_b_ = false;
  21 }
  22
  23 int
  24 compare (Midi_note_event const& left, Midi_note_event const& right)
  25 {
  26   Moment m =   (left.key - right.key);
  27
  28   if (m<0)
  29     return -1;
  30   else if (m > 0)
  31     return 1;
  32   else
  33     return 0;
  34 }
  35
  36 Midi_walker::Midi_walker (Audio_staff* audio_staff, Midi_track* track)
  37 {
  38   track_ = track;
  39   index_= 0;
  40   items_ = &audio_staff->audio_items_;
  41
  42   last_mom_ = 0;
  43 }
  44
  45 Midi_walker::~Midi_walker ()
  46 {
  47   // ugh
  48   do_stop_notes (last_mom_ + Moment (Rational (10, 1)));
  49 }
  50
  51 /**
  52   Find out if start_note event is needed, and do it if needed.
  53  */
  54 void
  55 Midi_walker::do_start_note (Midi_note* note)
  56 {
  57   Audio_item* ptr = (*items_)[index_];
  58   Moment stop_mom = note->get_length () + ptr->audio_column_->at_mom ();
  59
  60   bool play_start = true;
  61   for (int i=0; i < stop_note_queue.size (); i++)
  62     {
  63       /* if this pith already in queue */
  64       if (stop_note_queue[i].val->get_pitch () == note->get_pitch ())
  65         {
  66           if (stop_note_queue[i].key < stop_mom)
  67             {
  68               /* let stopnote in queue be ignored,
  69                new stop note wins */
  70               stop_note_queue[i].ignore_b_ = true;
  71               /* don't replay start note, */
  72               play_start = false;
  73               break;
  74             }
  75           else
  76             {
  77               /* skip this stopnote,
  78                  don't play the start note */
  79               delete note;
  80               note = 0;
  81               break;
  82           }
  83         }
  84     }
  85
  86   if (note)
  87     {
  88       Midi_note_event e;
  89       e.val = new Midi_note_off (note);
  90       e.key = stop_mom;
  91       stop_note_queue.insert (e);
  92
  93       if (play_start)
  94         output_event (ptr->audio_column_->at_mom (), note);
  95     }
  96 }
  97
  98 /**
  99   Output note events for all notes which end before #max_mom#
 100  */
 101 void
 102 Midi_walker::do_stop_notes (Moment max_mom)
 103 {
 104   while (stop_note_queue.size () && stop_note_queue.front ().key <= max_mom)
 105     {
 106       Midi_note_event e = stop_note_queue.get ();
 107       if (e.ignore_b_)
 108         {
 109           delete e.val;
 110           continue;
 111         }
 112
 113       Moment stop_mom = e.key;
 114       Midi_note* note = e.val;
 115
 116       output_event (stop_mom, note);
 117     }
 118 }
 119
 120 /**
 121   Advance the track to #now#, output the item, and adjust current "moment".
 122  */
 123 void
 124 Midi_walker::output_event (Moment now_mom, Midi_item* l)
 125 {
 126   Moment delta_t = now_mom - last_mom_ ;
 127   last_mom_ = now_mom;
 128
 129   /*
 130     this is not correct, but at least it doesn't crash when you
 131     start with graces
 132    */
 133   if (delta_t < Moment (0))
 134     {
 135       delta_t = Moment (0);
 136     }
 137
 138
 139   track_->add (delta_t, l);
 140 }
 141
 142 void
 143 Midi_walker::process ()
 144 {
 145   Audio_item* audio = (*items_)[index_];
 146   do_stop_notes (audio->audio_column_->at_mom ());
 147
 148   if (Midi_item* midi = Midi_item::get_midi (audio))
 149     {
 150       midi->channel_ = track_->channel_;
 151       //midi->channel_ = track_->number_;
 152       if (Midi_note* note = dynamic_cast<Midi_note*> (midi))
 153         {
 154           if (note->get_length ().to_bool ())
 155             do_start_note (note);
 156         }
 157       else
 158         output_event (audio->audio_column_->at_mom (), midi);
 159     }
 160 }
 161
 162 bool
 163 Midi_walker::ok () const
 164 {
 165   return index_ <items_->size ();
 166 }
 167
 168 void
 169 Midi_walker::operator ++ (int)
 170 {
 171   assert (ok ());
 172   index_++;
 173 }