lily/midi-walker.cc

   1 /*
   2   This file is part of LilyPond, the GNU music typesetter.
   3
   4   Copyright (C) 1997--2015 Han-Wen Nienhuys <hanwen@xs4all.nl>
   5   Jan Nieuwenhuizen <janneke@gnu.org>
   6
   7   LilyPond is free software: you can redistribute it and/or modify
   8   it under the terms of the GNU General Public License as published by
   9   the Free Software Foundation, either version 3 of the License, or
  10   (at your option) any later version.
  11
  12   LilyPond is distributed in the hope that it will be useful,
  13   but WITHOUT ANY WARRANTY; without even the implied warranty of
  14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15   GNU General Public License for more details.
  16
  17   You should have received a copy of the GNU General Public License
  18   along with LilyPond.  If not, see <http://www.gnu.org/licenses/>.
  19 */
  20
  21 #include "midi-walker.hh"
  22
  23 #include "audio-column.hh"
  24 #include "audio-staff.hh"
  25 #include "midi-item.hh"
  26 #include "midi-chunk.hh"
  27 #include "midi-stream.hh"
  28 #include "warn.hh"
  29
  30 Midi_note_event::Midi_note_event ()
  31 {
  32   ignore_ = false;
  33 }
  34
  35 int
  36 compare (Midi_note_event const &left, Midi_note_event const &right)
  37 {
  38   Moment m = (left.key - right.key);
  39
  40   if (m < 0)
  41     return -1;
  42   else if (m > 0)
  43     return 1;
  44   else
  45     return 0;
  46 }
  47
  48 bool
  49 audio_item_less (Audio_item *const a,
  50                  Audio_item *const b)
  51 {
  52   return a->get_column ()->when_ < b->get_column ()->when_;
  53 }
  54
  55 Midi_walker::Midi_walker (Audio_staff *audio_staff, Midi_track *track, int start_tick)
  56 {
  57   track_ = track;
  58   index_ = 0;
  59   items_ = audio_staff->audio_items_;
  60   vector_sort (items_, audio_item_less);
  61   //Scores that begin with grace notes start at negative times. This
  62   //is OK - MIDI output doesn't use absolute ticks, only differences.
  63   last_tick_ = start_tick;
  64   percussion_ = audio_staff->percussion_;
  65   merge_unisons_ = audio_staff->merge_unisons_;
  66 }
  67
  68 Midi_walker::~Midi_walker ()
  69 {
  70   junk_pointers (midi_events_);
  71 }
  72
  73 void
  74 Midi_walker::finalize ()
  75 {
  76   do_stop_notes (INT_MAX);
  77 }
  78
  79 /**
  80    Find out if start_note event is needed, and do it if needed.
  81 */
  82 void
  83 Midi_walker::do_start_note (Midi_note *note)
  84 {
  85   Audio_item *ptr = items_[index_];
  86   assert (note->audio_ == ptr);
  87   int now_ticks = ptr->audio_column_->ticks ();
  88   int stop_ticks = int (moment_to_real (note->audio_->length_mom_) *
  89                         Real (384 * 4)) + now_ticks;
  90   for (vsize i = 0; i < stop_note_queue.size (); i++)
  91     {
  92       /* if this pitch already in queue, and is not already ignored */
  93       if (!stop_note_queue[i].ignore_ &&
  94           stop_note_queue[i].val->get_semitone_pitch ()
  95           == note->get_semitone_pitch ())
  96         {
  97           int queued_ticks
  98             = stop_note_queue[i].val->audio_->audio_column_->ticks ();
  99           // If the two notes started at the same time, or option is set,
 100           if (now_ticks == queued_ticks || merge_unisons_)
 101             {
 102               // merge them.
 103               if (stop_note_queue[i].key < stop_ticks)
 104                 {
 105                   Midi_note_event e;
 106                   e.val = stop_note_queue[i].val;
 107                   e.key = stop_ticks;
 108                   stop_note_queue[i].ignore_ = true;
 109                   stop_note_queue.insert (e);
 110                 }
 111               note = 0;
 112               break;
 113             }
 114           else
 115             {
 116               // A note was played that interruped a played note.
 117               // Stop the old note, and continue to the greatest moment
 118               // between the two.
 119               if (stop_note_queue[i].key > stop_ticks)
 120                 {
 121                   stop_ticks = stop_note_queue[i].key;
 122                 }
 123               output_event (now_ticks, stop_note_queue[i].val);
 124               stop_note_queue[i].ignore_ = true;
 125               break;
 126             }
 127         }
 128     }
 129
 130   if (note)
 131     {
 132       Midi_note_event e;
 133       e.val = new Midi_note_off (note);
 134
 135       midi_events_.push_back (e.val);
 136       e.key = stop_ticks;
 137       stop_note_queue.insert (e);
 138
 139       output_event (now_ticks, note);
 140     }
 141 }
 142
 143 void
 144 Midi_walker::do_stop_notes (int max_ticks)
 145 {
 146   while (stop_note_queue.size () && stop_note_queue.front ().key <= max_ticks)
 147     {
 148       Midi_note_event e = stop_note_queue.get ();
 149       if (e.ignore_)
 150         {
 151           continue;
 152         }
 153
 154       int stop_ticks = e.key;
 155       Midi_note *note = e.val;
 156
 157       output_event (stop_ticks, note);
 158     }
 159 }
 160
 161 void
 162 Midi_walker::output_event (int now_ticks, Midi_item *l)
 163 {
 164   int delta_ticks = now_ticks - last_tick_;
 165   last_tick_ = now_ticks;
 166
 167   /*
 168     this is not correct, but at least it doesn't crash when you
 169     start with graces
 170   */
 171   if (delta_ticks < 0)
 172     {
 173       programming_error ("Going back in MIDI time.");
 174       delta_ticks = 0;
 175     }
 176
 177   track_->add (delta_ticks, l);
 178 }
 179
 180 void
 181 Midi_walker::process ()
 182 {
 183   Audio_item *audio = items_[index_];
 184   Audio_column *col = audio->get_column ();
 185   do_stop_notes (col->ticks ());
 186
 187   if (Midi_item *midi = get_midi (audio))
 188     {
 189       if (Midi_note *note = dynamic_cast<Midi_note *> (midi))
 190         {
 191           if (note->audio_->length_mom_.to_bool ())
 192             do_start_note (note);
 193         }
 194       else
 195         output_event (audio->audio_column_->ticks (), midi);
 196     }
 197 }
 198
 199 Midi_item *
 200 Midi_walker::get_midi (Audio_item *i)
 201 {
 202   Midi_item *mi = Midi_item::get_midi (i);
 203
 204   if (percussion_)
 205     if (Midi_channel_item *mci = dynamic_cast<Midi_channel_item *> (mi))
 206       mci->channel_ = 9;
 207
 208   midi_events_.push_back (mi);
 209   return mi;
 210 }
 211
 212 bool
 213 Midi_walker::ok () const
 214 {
 215   return index_ < items_.size ();
 216 }
 217
 218 void
 219 Midi_walker::operator ++(int)
 220 {
 221   assert (ok ());
 222   index_++;
 223 }