]> git.donarmstrong.com Git - lilypond.git/blob - lily/staff-performer.cc
Merge branch 'master' into lilypond/translation
[lilypond.git] / lily / staff-performer.cc
1 /*
2   This file is part of LilyPond, the GNU music typesetter.
3
4   Copyright (C) 1997--2011 Jan Nieuwenhuizen <janneke@gnu.org>
5
6   LilyPond is free software: you can redistribute it and/or modify
7   it under the terms of the GNU General Public License as published by
8   the Free Software Foundation, either version 3 of the License, or
9   (at your option) any later version.
10
11   LilyPond is distributed in the hope that it will be useful,
12   but WITHOUT ANY WARRANTY; without even the implied warranty of
13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14   GNU General Public License for more details.
15
16   You should have received a copy of the GNU General Public License
17   along with LilyPond.  If not, see <http://www.gnu.org/licenses/>.
18 */
19
20 #include <map>
21
22 #include "audio-column.hh"
23 #include "audio-item.hh"
24 #include "audio-staff.hh"
25 #include "context.hh"
26 #include "international.hh"
27 #include "performer-group.hh"
28 #include "warn.hh"
29
30 /* Perform a staff. Individual notes should have their instrument
31   (staff-wide) set, so we override play_element ()
32 */
33 class Staff_performer : public Performer
34 {
35 public:
36   TRANSLATOR_DECLARATIONS (Staff_performer);
37   ~Staff_performer ();
38
39 protected:
40   virtual void acknowledge_audio_element (Audio_element_info info);
41   virtual void finalize ();
42   virtual void initialize ();
43   void process_music ();
44   void stop_translation_timestep ();
45
46 private:
47   string new_instrument_string ();
48   void set_instrument_name (string voice);
49   void set_instrument (int channel, string voice);
50   int get_channel (string instrument);
51   Audio_staff* get_audio_staff (string voice);
52   Audio_staff* new_audio_staff (string voice);
53   Audio_dynamic* get_dynamic (string voice);
54
55   string instrument_string_;
56   int channel_;
57   Audio_instrument *instrument_;
58   Audio_text *instrument_name_;
59   Audio_text *name_;
60   Audio_tempo *tempo_;
61   map<string, Audio_staff*> staff_map_;
62   map<string, int> channel_map_;
63   map<string, Audio_dynamic*> dynamic_map_;
64   static map<string, int> static_channel_map_;
65   static int channel_count_;
66 };
67
68 map<string, int> Staff_performer::static_channel_map_;
69 int Staff_performer::channel_count_ = 0;
70
71 #include "translator.icc"
72
73 ADD_TRANSLATOR (Staff_performer,
74                 /* doc */
75                 "",
76
77                 /* create */
78                 "",
79
80                 /* read */
81                 "",
82
83                 /* write */
84                 "");
85
86 Staff_performer::Staff_performer ()
87   : channel_ (-1)
88   , instrument_ (0)
89   , instrument_name_ (0)
90   , name_ (0)
91   , tempo_ (0)
92 {
93 }
94
95 Staff_performer::~Staff_performer ()
96 {
97 }
98
99 void
100 Staff_performer::initialize ()
101 {
102 }
103
104 Audio_staff*
105 Staff_performer::new_audio_staff (string voice)
106 {
107   Audio_staff* audio_staff = new Audio_staff;
108   string track_name = context ()->id_string () + ":" + voice;
109   if (track_name != ":")
110     {
111       name_ = new Audio_text (Audio_text::TRACK_NAME, context ()->id_string ()
112                               + ":" + voice);
113       audio_staff->add_audio_item (name_);
114       announce_element (Audio_element_info (name_, 0));
115     }
116   announce_element (Audio_element_info (audio_staff, 0));
117   staff_map_[voice] = audio_staff;
118   if (!instrument_string_.empty ())
119     set_instrument (channel_, voice);
120   return audio_staff;
121 }
122
123 Audio_staff*
124 Staff_performer::get_audio_staff (string voice)
125 {
126   SCM channel_mapping = get_property ("midiChannelMapping");
127   if (channel_mapping != ly_symbol2scm ("instrument")
128       && staff_map_.size ())
129     return staff_map_.begin ()->second;
130
131   map<string, Audio_staff*>::const_iterator i = staff_map_.find (voice);
132   if (i != staff_map_.end ())
133     return i->second;
134   map<string, Audio_staff*>::const_iterator e = staff_map_.find ("");
135   if (staff_map_.size () == 1 && e != staff_map_.end ())
136     {
137       staff_map_[voice] = e->second;
138       return e->second;
139     }
140   return new_audio_staff (voice);
141 }
142
143 Audio_dynamic*
144 Staff_performer::get_dynamic (string voice)
145 {
146   map<string, Audio_dynamic*>::const_iterator i = dynamic_map_.find (voice);
147   if (i != dynamic_map_.end ())
148     return i->second;
149   return 0;
150 }
151
152 void
153 Staff_performer::process_music ()
154 {
155 }
156
157 void
158 Staff_performer::set_instrument (int channel, string voice)
159 {
160   instrument_ = new Audio_instrument (instrument_string_);
161   instrument_->channel_ = channel;
162   announce_element (Audio_element_info (instrument_, 0));
163   Audio_staff* audio_staff = get_audio_staff (voice);
164   audio_staff->add_audio_item (instrument_);
165   SCM proc = ly_lily_module_constant ("percussion?");
166   SCM drums = scm_call_1 (proc, ly_symbol2scm (instrument_string_.c_str ()));
167   audio_staff->percussion_ = (drums == SCM_BOOL_T);
168 }
169
170 void
171 Staff_performer::set_instrument_name (string voice)
172 {
173   instrument_name_ = new Audio_text (Audio_text::INSTRUMENT_NAME,
174                                      instrument_string_);
175   announce_element (Audio_element_info (instrument_name_, 0));
176   get_audio_staff (voice)->add_audio_item (instrument_name_);
177 }
178
179 void
180 Staff_performer::stop_translation_timestep ()
181 {
182   name_ = 0;
183   tempo_ = 0;
184   instrument_name_ = 0;
185   instrument_ = 0;
186 }
187
188 void
189 Staff_performer::finalize ()
190 {
191   staff_map_.clear ();
192   channel_map_.clear ();
193 }
194
195 string
196 Staff_performer::new_instrument_string ()
197 {
198   // mustn't ask Score for instrument: it will return piano!
199   SCM minstr = get_property ("midiInstrument");
200
201   if (!scm_is_string (minstr)
202       || ly_scm2string (minstr) == instrument_string_)
203     return "";
204
205   instrument_string_ = ly_scm2string (minstr);
206
207   return instrument_string_;
208 }
209
210 int
211 Staff_performer::get_channel (string instrument)
212 {
213   SCM channel_mapping = get_property ("midiChannelMapping");
214   map<string, int>& channel_map
215     = (channel_mapping != ly_symbol2scm ("instrument"))
216     ? channel_map_
217     : static_channel_map_;
218
219   if (channel_mapping == ly_symbol2scm ("staff")
220       && channel_ >= 0)
221     return channel_;
222
223   map<string, int>::const_iterator i = channel_map.find (instrument);
224   if (i != channel_map.end ())
225     return i->second;
226  
227   int channel = (channel_mapping == ly_symbol2scm ("staff"))
228     ? channel_count_++
229     : channel_map.size ();
230
231   /* MIDI players tend to ignore instrument settings on channel
232      10, the percussion channel.  */
233   if (channel % 16 == 9)
234     {
235       channel_map["percussion"] = channel++;
236       channel_count_++;
237     }
238
239   if (channel > 15)
240     {
241       warning (_ ("MIDI channel wrapped around"));
242       warning (_ ("remapping modulo 16"));
243       channel = channel % 16; 
244     }
245
246   channel_map[instrument] = channel;
247   return channel;
248 }
249
250 void
251 Staff_performer::acknowledge_audio_element (Audio_element_info inf)
252 {
253   if (Audio_item *ai = dynamic_cast<Audio_item *> (inf.elem_))
254     {
255       /* map each context (voice) to its own track */
256       Context* c = inf.origin_contexts (this)[0];
257       string voice;
258       if (c->is_alias (ly_symbol2scm ("Voice")))
259         voice = c->id_string ();
260       SCM channel_mapping = get_property ("midiChannelMapping");
261       string str = new_instrument_string ();
262       if (channel_mapping != ly_symbol2scm ("instrument"))
263         channel_ = get_channel (voice);
264       else if (channel_ < 0 && str.empty ())
265         channel_ = get_channel (str);
266       if (str.length ())
267         {
268           if (channel_mapping != ly_symbol2scm ("voice"))
269             channel_ = get_channel (str);
270           set_instrument (channel_, voice);
271           set_instrument_name (voice);
272         }
273       ai->channel_ = channel_;
274       bool encode_dynamics_as_velocity_ = true;
275       if (encode_dynamics_as_velocity_)
276         {
277           if (Audio_dynamic *d = dynamic_cast<Audio_dynamic *> (inf.elem_))
278             {
279               dynamic_map_[voice] = d;
280               // Output volume as velocity: must disable Midi_dynamic output
281               d->silent_ = true;
282             }
283           if (Audio_dynamic *d = get_dynamic (voice))
284             if (Audio_note *n = dynamic_cast<Audio_note *> (inf.elem_))
285               n->dynamic_ = d;
286         }
287       Audio_staff* audio_staff = get_audio_staff (voice);
288       audio_staff->add_audio_item (ai);
289     }
290 }
291