X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Fstaff-performer.cc;h=1af71efd86db801f06c6b6222e8e7d73e8eae730;hb=07125596018d32e3235e80627915cfac77323272;hp=adacd1c6c0806eb7f3a1ebd96c87061209ae3723;hpb=304b5f3aa7eee7b0ff8d4ba7526a1410735f6e74;p=lilypond.git

diff --git a/lily/staff-performer.cc b/lily/staff-performer.cc
index adacd1c6c0..1af71efd86 100644
--- a/lily/staff-performer.cc
+++ b/lily/staff-performer.cc
@@ -1,58 +1,125 @@
 /*
-  staff-performer.cc -- implement Staff_performer
+  This file is part of LilyPond, the GNU music typesetter.
 
-  source file of the GNU LilyPond music typesetter
+  Copyright (C) 1997--2015 Jan Nieuwenhuizen <janneke@gnu.org>
 
-  (c) 1997--2004 Jan Nieuwenhuizen <janneke@gnu.org>
- */
+  LilyPond 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 3 of the License, or
+  (at your option) any later version.
+
+  LilyPond is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with LilyPond.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <map>
+#include <deque>
 
-#include "translator-group.hh"
-#include "warn.hh"
 #include "audio-column.hh"
 #include "audio-item.hh"
 #include "audio-staff.hh"
-#include "performer-group-performer.hh"
 #include "context.hh"
+#include "international.hh"
+#include "midi-cc-announcer.hh"
+#include "performer-group.hh"
+#include "warn.hh"
+#include "lily-imports.hh"
 
-/** Perform a staff. Individual notes should have their instrument
- (staff-wide) set, so we override play_element ()
+#include "translator.icc"
 
-  */
-class Staff_performer : public Performer_group_performer 
+/* Perform a staff. Individual notes should have their instrument
+  (staff-wide) set, so we override play_element ()
+*/
+class Staff_performer : public Performer
 {
 public:
   TRANSLATOR_DECLARATIONS (Staff_performer);
   ~Staff_performer ();
 
-  String new_instrument_string ();
-  String instrument_string_;
-
 protected:
-  virtual void play_element (Audio_element* p);
+  virtual void acknowledge_audio_element (Audio_element_info info);
   virtual void finalize ();
   virtual void initialize ();
-  virtual void create_audio_elements ();
-  virtual void stop_translation_timestep ();
+  void process_music ();
+  void stop_translation_timestep ();
 
 private:
-  Audio_staff* audio_staff_;
-  Audio_instrument* instrument_;
-  Audio_text* instrument_name_;
-  Audio_text* name_;
-  Audio_tempo* tempo_;
+  string new_instrument_string ();
+  void set_instrument_name (const string &voice);
+  void set_instrument (int channel, const string &voice);
+  int get_channel (const string &instrument);
+  Audio_staff *get_audio_staff (const string &voice);
+  Audio_staff *new_audio_staff (const string &voice);
+
+  class Midi_control_initializer : public Midi_control_change_announcer
+  {
+  public:
+    Midi_control_initializer (Staff_performer *performer,
+                              Audio_staff *audio_staff,
+                              int channel);
+
+    SCM get_property_value (const char *property_name);
+    void do_announce (Audio_control_change *item);
+
+  private:
+    Staff_performer *performer_;
+    Audio_staff *audio_staff_;
+    int channel_;
+  };
+
+  string instrument_string_;
+  int channel_;
+  Audio_instrument *instrument_;
+  Audio_text *instrument_name_;
+  Audio_text *name_;
+  Audio_tempo *tempo_;
+  map<string, Audio_staff *> staff_map_;
+  map<string, int> channel_map_;
+  // Would prefer to have the following two items be
+  // members of the containing class Performance,
+  // so they can be reset for each new midi file output.
+  static map<string, int> static_channel_map_;
+  static int channel_count_;
+  // For now, ask the last Staff_performer clean up during its finalize method
+  static int staff_performer_count_;
 };
 
-ENTER_DESCRIPTION (Staff_performer, "", "",
-		   "",
-		   "", "", "");
+map<string, int> Staff_performer::static_channel_map_;
+int Staff_performer::channel_count_ = 0;
+int Staff_performer::staff_performer_count_ = 0;
 
-Staff_performer::Staff_performer ()
+void
+Staff_performer::boot ()
+{
+
+}
+
+ADD_TRANSLATOR (Staff_performer,
+                /* doc */
+                "",
+
+                /* create */
+                "",
+
+                /* read */
+                "",
+
+                /* write */
+                "");
+
+Staff_performer::Staff_performer (Context *c)
+  : Performer (c),
+    channel_ (-1),
+    instrument_ (0),
+    instrument_name_ (0),
+    name_ (0),
+    tempo_ (0)
 {
-  audio_staff_ = 0;
-  instrument_ = 0;
-  instrument_name_ = 0;
-  name_ = 0;
-  tempo_ = 0;
 }
 
 Staff_performer::~Staff_performer ()
@@ -62,82 +129,109 @@ Staff_performer::~Staff_performer ()
 void
 Staff_performer::initialize ()
 {
-  audio_staff_ = new Audio_staff;
-  announce_element (Audio_element_info (audio_staff_, 0));
+  ++staff_performer_count_;
+}
+
+Audio_staff *
+Staff_performer::new_audio_staff (const string &voice)
+{
+  Audio_staff *audio_staff = new Audio_staff;
+  audio_staff->merge_unisons_
+    = to_boolean (get_property ("midiMergeUnisons"));
+  string track_name = context ()->id_string () + ":" + voice;
+  if (track_name != ":")
+    {
+      name_ = new Audio_text (Audio_text::TRACK_NAME, context ()->id_string ()
+                              + ":" + voice);
+      audio_staff->add_audio_item (name_);
+      announce_element (Audio_element_info (name_, 0));
+    }
+  announce_element (Audio_element_info (audio_staff, 0));
+  staff_map_[voice] = audio_staff;
+  if (!instrument_string_.empty ())
+    set_instrument (channel_, voice);
+  // Set initial values (if any) for MIDI controls.
+  Midi_control_initializer i (this, audio_staff, channel_);
+  i.announce_control_changes ();
+  return audio_staff;
+}
 
-  name_ = new Audio_text (Audio_text::TRACK_NAME, daddy_context_->id_string_);
-  announce_element (Audio_element_info (name_, 0));
+Audio_staff *
+Staff_performer::get_audio_staff (const string &voice)
+{
+  SCM channel_mapping = get_property ("midiChannelMapping");
+  if (!scm_is_eq (channel_mapping, ly_symbol2scm ("instrument"))
+      && staff_map_.size ())
+    return staff_map_.begin ()->second;
 
-  tempo_ = new Audio_tempo (get_tempo ());
-  announce_element (Audio_element_info (tempo_, 0));
+  map<string, Audio_staff *>::const_iterator i = staff_map_.find (voice);
+  if (i != staff_map_.end ())
+    return i->second;
+  map<string, Audio_staff *>::const_iterator e = staff_map_.find ("");
+  if (staff_map_.size () == 1 && e != staff_map_.end ())
+    {
+      staff_map_[voice] = e->second;
+      return e->second;
+    }
+  return new_audio_staff (voice);
+}
 
-  Performer_group_performer::initialize ();
+void
+Staff_performer::process_music ()
+{
 }
 
 void
-Staff_performer::create_audio_elements ()
+Staff_performer::set_instrument (int channel, const string &voice)
 {
-  String str = new_instrument_string ();
-  if (str.length ())
-    {
-      instrument_name_ = new Audio_text (Audio_text::INSTRUMENT_NAME, str);
-      announce_element (Audio_element_info (instrument_name_, 0));
-      instrument_ = new Audio_instrument (str);
-      announce_element (Audio_element_info (instrument_, 0));
-    }
-  Performer_group_performer::create_audio_elements ();
+  instrument_ = new Audio_instrument (instrument_string_);
+  instrument_->channel_ = channel;
+  announce_element (Audio_element_info (instrument_, 0));
+  Audio_staff *audio_staff = get_audio_staff (voice);
+  audio_staff->add_audio_item (instrument_);
+  SCM drums = Lily::percussion_p (ly_symbol2scm (instrument_string_.c_str ()));
+  audio_staff->percussion_ = to_boolean (drums);
+}
+
+void
+Staff_performer::set_instrument_name (const string &voice)
+{
+  instrument_name_ = new Audio_text (Audio_text::INSTRUMENT_NAME,
+                                     instrument_string_);
+  announce_element (Audio_element_info (instrument_name_, 0));
+  get_audio_staff (voice)->add_audio_item (instrument_name_);
 }
 
 void
 Staff_performer::stop_translation_timestep ()
 {
-  /*
-    UGH. -> don't use eval.
-  */
-  static SCM proc;
-  if (!proc)
-    proc = scm_primitive_eval (ly_symbol2scm ("percussion?"));
-  
-  SCM drums = gh_call1 (proc, ly_symbol2scm (instrument_string_.to_str0 ()));
-  audio_staff_->channel_ = (drums == SCM_BOOL_T ? 9 : -1 );
-  if (name_)
-    {
-      play_element (name_);
-      name_ = 0;
-    }
-  if (tempo_)
-    {
-      play_element (tempo_);
-      tempo_ = 0;
-    }
-  if (instrument_name_)
-    {
-      play_element (instrument_name_);
-      instrument_name_ = 0;
-    }
-  if (instrument_)
-    {
-      play_element (instrument_);
-      instrument_ = 0;
-    }
-  Performer_group_performer::stop_translation_timestep ();
+  name_ = 0;
+  tempo_ = 0;
+  instrument_name_ = 0;
+  instrument_ = 0;
 }
 
 void
 Staff_performer::finalize ()
 {
-  Performer_group_performer::finalize ();
-  Performer::play_element (audio_staff_);
-  audio_staff_ = 0;
+  staff_map_.clear ();
+  channel_map_.clear ();
+  if (staff_performer_count_)
+    --staff_performer_count_;
+  if (0 == staff_performer_count_)
+    {
+      static_channel_map_.clear ();
+      channel_count_ = 0;
+    }
 }
 
-String 
-Staff_performer::new_instrument_string () 
-{ 
+string
+Staff_performer::new_instrument_string ()
+{
   // mustn't ask Score for instrument: it will return piano!
   SCM minstr = get_property ("midiInstrument");
 
-  if (!gh_string_p (minstr)
+  if (!scm_is_string (minstr)
       || ly_scm2string (minstr) == instrument_string_)
     return "";
 
@@ -146,13 +240,93 @@ Staff_performer::new_instrument_string ()
   return instrument_string_;
 }
 
-void 
-Staff_performer::play_element (Audio_element* p)
+int
+Staff_performer::get_channel (const string &instrument)
 {
-  if (Audio_item *ai = dynamic_cast<Audio_item *> (p)) 
+  SCM channel_mapping = get_property ("midiChannelMapping");
+  map<string, int> &channel_map
+    = (!scm_is_eq (channel_mapping, ly_symbol2scm ("instrument")))
+      ? channel_map_
+      : static_channel_map_;
+
+  if (scm_is_eq (channel_mapping, ly_symbol2scm ("staff"))
+      && channel_ >= 0)
+    return channel_;
+
+  map<string, int>::const_iterator i = channel_map.find (instrument);
+  if (i != channel_map.end ())
+    return i->second;
+
+  int channel = (scm_is_eq (channel_mapping, ly_symbol2scm ("staff")))
+                ? channel_count_++
+                : channel_map.size ();
+
+  /* MIDI players tend to ignore instrument settings on channel
+     10, the percussion channel.  */
+  if (channel % 16 == 9)
     {
-      audio_staff_->add_audio_item (ai);
+      channel_map["percussion"] = channel++;
+      channel_count_++;
     }
-  Performer::play_element (p);
+
+  if (channel > 15)
+    {
+      warning (_ ("MIDI channel wrapped around"));
+      warning (_ ("remapping modulo 16"));
+      channel = channel % 16;
+    }
+
+  channel_map[instrument] = channel;
+  return channel;
+}
+
+void
+Staff_performer::acknowledge_audio_element (Audio_element_info inf)
+{
+  /* map each context (voice) to its own track */
+  Context *c = inf.origin_contexts (this)[0];
+  string voice;
+  if (c->is_alias (ly_symbol2scm ("Voice")))
+    voice = c->id_string ();
+  SCM channel_mapping = get_property ("midiChannelMapping");
+  string str = new_instrument_string ();
+  if (!scm_is_eq (channel_mapping, ly_symbol2scm ("instrument")))
+    channel_ = get_channel (voice);
+  else if (channel_ < 0 && str.empty ())
+    channel_ = get_channel (str);
+  if (str.length ())
+    {
+      if (!scm_is_eq (channel_mapping, ly_symbol2scm ("voice")))
+        channel_ = get_channel (str);
+      set_instrument (channel_, voice);
+      set_instrument_name (voice);
+    }
+  Audio_staff *audio_staff = get_audio_staff (voice);
+  if (Audio_item *ai = dynamic_cast<Audio_item *> (inf.elem_))
+    {
+      ai->channel_ = channel_;
+      audio_staff->add_audio_item (ai);
+    }
+}
+
+Staff_performer::Midi_control_initializer::Midi_control_initializer
+(Staff_performer *performer, Audio_staff *audio_staff, int channel)
+  : performer_ (performer),
+    audio_staff_ (audio_staff),
+    channel_ (channel)
+{
 }
 
+SCM Staff_performer::Midi_control_initializer::get_property_value
+(const char *property_name)
+{
+  return performer_->get_property (property_name);
+}
+
+void Staff_performer::Midi_control_initializer::do_announce
+(Audio_control_change *item)
+{
+  item->channel_ = channel_;
+  audio_staff_->add_audio_item (item);
+  performer_->announce_element (Audio_element_info (item, 0));
+}