lily/part-combine-iterator.cc

   1 /*
   2   This file is part of LilyPond, the GNU music typesetter.
   3
   4   Copyright (C) 2004--2015 Han-Wen Nienhuys
   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 "context.hh"
  21 #include "dispatcher.hh"
  22 #include "lily-guile.hh"
  23 #include "music.hh"
  24 #include "music-iterator.hh"
  25 #include "music-sequence.hh"
  26 #include "warn.hh"
  27
  28 enum Outlet_type
  29 {
  30   CONTEXT_ONE, CONTEXT_TWO,
  31   CONTEXT_SHARED, CONTEXT_SOLO,
  32   CONTEXT_NULL, NUM_OUTLETS
  33 };
  34
  35 static const char *outlet_names_[NUM_OUTLETS]
  36   = {"one", "two", "shared", "solo", "null"};
  37
  38 class Part_combine_iterator : public Music_iterator
  39 {
  40 public:
  41   Part_combine_iterator ();
  42
  43   DECLARE_SCHEME_CALLBACK (constructor, ());
  44 protected:
  45   virtual void derived_substitute (Context *f, Context *t);
  46   virtual void derived_mark () const;
  47
  48   virtual void construct_children ();
  49   virtual Moment pending_moment () const;
  50   virtual void do_quit ();
  51   virtual void process (Moment);
  52
  53   virtual bool ok () const;
  54
  55 private:
  56   /* used by try_process */
  57   void set_busy (SCM);
  58   bool busy_;
  59   bool notice_busy_;
  60
  61   bool try_process (Music_iterator *i, Moment m);
  62
  63   Music_iterator *first_iter_;
  64   Music_iterator *second_iter_;
  65   Moment start_moment_;
  66
  67   SCM split_list_;
  68
  69   Stream_event *mmrest_event_;
  70
  71   enum Status
  72   {
  73     APART,
  74     TOGETHER,
  75     SOLO,
  76     UNISONO,
  77     UNISILENCE,
  78   };
  79   Status state_;
  80
  81   // For states in which it matters, this is the relevant part,
  82   // e.g. 1 for Solo I, 2 for Solo II.
  83   int chosen_part_;
  84
  85   int last_playing_;
  86
  87   /*
  88     TODO: this is getting off hand...
  89   */
  90   Context_handle handles_[NUM_OUTLETS];
  91
  92   void substitute_both (Outlet_type to1,
  93                         Outlet_type to2);
  94   void kill_mmrest_in_inactive_outlets ();
  95   /* parameter is really Outlet_type */
  96   void kill_mmrest (int in);
  97   void chords_together ();
  98   void solo1 ();
  99   void solo2 ();
 100   void apart (bool silent);
 101   void unisono (bool silent, int newpart);
 102 };
 103
 104 void
 105 Part_combine_iterator::do_quit ()
 106 {
 107   if (first_iter_)
 108     first_iter_->quit ();
 109   if (second_iter_)
 110     second_iter_->quit ();
 111
 112   // Add listeners to all contexts except Devnull.
 113   for (int i = 0; i < NUM_OUTLETS; i++)
 114     {
 115       Context *c = handles_[i].get_context ();
 116       if (c->is_alias (ly_symbol2scm ("Voice")))
 117         c->event_source ()->remove_listener (GET_LISTENER (Part_combine_iterator, set_busy), ly_symbol2scm ("music-event"));
 118       handles_[i].set_context (0);
 119     }
 120 }
 121
 122 Part_combine_iterator::Part_combine_iterator ()
 123 {
 124   mmrest_event_ = 0;
 125
 126   first_iter_ = 0;
 127   second_iter_ = 0;
 128   split_list_ = SCM_EOL;
 129   state_ = APART;
 130   chosen_part_ = 1;
 131   last_playing_ = 0;
 132
 133   busy_ = false;
 134   notice_busy_ = false;
 135 }
 136
 137 void
 138 Part_combine_iterator::derived_mark () const
 139 {
 140   if (first_iter_)
 141     scm_gc_mark (first_iter_->self_scm ());
 142   if (second_iter_)
 143     scm_gc_mark (second_iter_->self_scm ());
 144   if (mmrest_event_)
 145     scm_gc_mark (mmrest_event_->self_scm ());
 146 }
 147
 148 void
 149 Part_combine_iterator::derived_substitute (Context *f,
 150                                            Context *t)
 151 {
 152   if (first_iter_)
 153     first_iter_->substitute_outlet (f, t);
 154 }
 155
 156 Moment
 157 Part_combine_iterator::pending_moment () const
 158 {
 159   Moment p;
 160   p.set_infinite (1);
 161   if (first_iter_->ok ())
 162     p = min (p, first_iter_->pending_moment ());
 163
 164   if (second_iter_->ok ())
 165     p = min (p, second_iter_->pending_moment ());
 166   return p;
 167 }
 168
 169 bool
 170 Part_combine_iterator::ok () const
 171 {
 172   return first_iter_->ok () || second_iter_->ok ();
 173 }
 174
 175 void
 176 Part_combine_iterator::substitute_both (Outlet_type to1,
 177                                         Outlet_type to2)
 178 {
 179   first_iter_->substitute_outlet (first_iter_->get_outlet (),
 180                                   handles_[to1].get_context ());
 181   second_iter_->substitute_outlet (second_iter_->get_outlet (),
 182                                    handles_[to2].get_context ());
 183 }
 184
 185 void Part_combine_iterator::kill_mmrest_in_inactive_outlets ()
 186 {
 187   for (int j = 0; j < NUM_OUTLETS; j++)
 188     {
 189       Context *c = handles_[j].get_context ();
 190
 191       if (first_iter_->get_outlet () == c)
 192         continue;
 193
 194       if (second_iter_->get_outlet () == c)
 195         continue;
 196
 197       kill_mmrest (j);
 198     }
 199 }
 200
 201 void
 202 Part_combine_iterator::kill_mmrest (int in)
 203 {
 204
 205   if (!mmrest_event_)
 206     {
 207       mmrest_event_ = new Stream_event
 208         (scm_call_1 (ly_lily_module_constant ("ly:make-event-class"),
 209                      ly_symbol2scm ("multi-measure-rest-event")));
 210       mmrest_event_->set_property ("duration", SCM_EOL);
 211       mmrest_event_->unprotect ();
 212     }
 213
 214   handles_[in].get_context ()->event_source ()->broadcast (mmrest_event_);
 215 }
 216
 217 void
 218 Part_combine_iterator::unisono (bool silent, int newpart)
 219 {
 220   Status newstate = (silent) ? UNISILENCE : UNISONO;
 221
 222   if ((newstate == state_) and (newpart == chosen_part_))
 223     return;
 224   else
 225     {
 226       Outlet_type c1 = (newpart == 2) ? CONTEXT_NULL : CONTEXT_SHARED;
 227       Outlet_type c2 = (newpart == 2) ? CONTEXT_SHARED : CONTEXT_NULL;
 228       substitute_both (c1, c2);
 229
 230       state_ = newstate;
 231       chosen_part_ = newpart;
 232     }
 233 }
 234
 235 void
 236 Part_combine_iterator::solo1 ()
 237 {
 238   if ((state_ == SOLO) && (chosen_part_ == 1))
 239     return;
 240   else
 241     {
 242       state_ = SOLO;
 243       chosen_part_ = 1;
 244       substitute_both (CONTEXT_SOLO, CONTEXT_NULL);
 245     }
 246 }
 247
 248 void
 249 Part_combine_iterator::solo2 ()
 250 {
 251   if ((state_ == SOLO) and (chosen_part_ == 2))
 252     return;
 253   else
 254     {
 255       state_ = SOLO;
 256       chosen_part_ = 2;
 257       substitute_both (CONTEXT_NULL, CONTEXT_SOLO);
 258     }
 259 }
 260
 261 void
 262 Part_combine_iterator::chords_together ()
 263 {
 264   if (state_ == TOGETHER)
 265     return;
 266   else
 267     {
 268       state_ = TOGETHER;
 269
 270       substitute_both (CONTEXT_SHARED, CONTEXT_SHARED);
 271     }
 272 }
 273
 274 void
 275 Part_combine_iterator::apart (bool silent)
 276 {
 277   if (state_ == APART)
 278     return;
 279   else
 280     {
 281       state_ = APART;
 282       substitute_both (CONTEXT_ONE, CONTEXT_TWO);
 283     }
 284 }
 285
 286 void
 287 Part_combine_iterator::construct_children ()
 288 {
 289   start_moment_ = get_outlet ()->now_mom ();
 290   split_list_ = get_music ()->get_property ("split-list");
 291
 292   Context *c = get_outlet ();
 293
 294   for (int i = 0; i < NUM_OUTLETS; i++)
 295     {
 296       SCM type = (i == CONTEXT_NULL) ? ly_symbol2scm ("Devnull") : ly_symbol2scm ("Voice");
 297       /* find context below c: otherwise we may create new staff for each voice */
 298       c = c->find_create_context (type, outlet_names_[i], SCM_EOL);
 299       handles_[i].set_context (c);
 300       if (c->is_alias (ly_symbol2scm ("Voice")))
 301         c->event_source ()->add_listener (GET_LISTENER (Part_combine_iterator, set_busy), ly_symbol2scm ("music-event"));
 302     }
 303
 304   SCM lst = get_music ()->get_property ("elements");
 305   Context *one = handles_[CONTEXT_ONE].get_context ();
 306   set_context (one);
 307   first_iter_ = Music_iterator::unsmob (get_iterator (Music::unsmob (scm_car (lst))));
 308   Context *two = handles_[CONTEXT_TWO].get_context ();
 309   set_context (two);
 310   second_iter_ = Music_iterator::unsmob (get_iterator (Music::unsmob (scm_cadr (lst))));
 311   Context *shared = handles_[CONTEXT_SHARED].get_context ();
 312   set_context (shared);
 313 }
 314
 315 void
 316 Part_combine_iterator::set_busy (SCM se)
 317 {
 318   if (!notice_busy_)
 319     return;
 320
 321   Stream_event *e = Stream_event::unsmob (se);
 322
 323   if (e->in_event_class ("note-event") || e->in_event_class ("cluster-note-event"))
 324     busy_ = true;
 325 }
 326
 327 /*
 328   Processes a moment in an iterator, and returns whether any new music
 329   was reported.
 330 */
 331 bool
 332 Part_combine_iterator::try_process (Music_iterator *i, Moment m)
 333 {
 334   busy_ = false;
 335   notice_busy_ = true;
 336
 337   i->process (m);
 338
 339   notice_busy_ = false;
 340   return busy_;
 341 }
 342
 343 void
 344 Part_combine_iterator::process (Moment m)
 345 {
 346   Moment now = get_outlet ()->now_mom ();
 347   Moment *splitm = 0;
 348
 349   /* This is needed if construct_children was called before iteration
 350      started */
 351   if (start_moment_.main_part_.is_infinity () && start_moment_ < 0)
 352     start_moment_ = now;
 353
 354   for (; scm_is_pair (split_list_); split_list_ = scm_cdr (split_list_))
 355     {
 356       splitm = Moment::unsmob (scm_caar (split_list_));
 357       if (splitm && *splitm + start_moment_ > now)
 358         break;
 359
 360       SCM tag = scm_cdar (split_list_);
 361
 362       Context *outletsBefore[] = { first_iter_->get_outlet (),
 363                                    second_iter_->get_outlet () };
 364
 365       if (scm_is_eq (tag, ly_symbol2scm ("chords")))
 366         chords_together ();
 367       else if (scm_is_eq (tag, ly_symbol2scm ("apart"))
 368                || scm_is_eq (tag, ly_symbol2scm ("apart-silence"))
 369                || scm_is_eq (tag, ly_symbol2scm ("apart-spanner")))
 370         apart (scm_is_eq (tag, ly_symbol2scm ("apart-silence")));
 371       else if (scm_is_eq (tag, ly_symbol2scm ("unisono")))
 372         {
 373           // Continue to use the most recently used part because we might have
 374           // killed mmrests in the other part.
 375           unisono (false, (last_playing_ == 2) ? 2 : 1);
 376         }
 377       else if (scm_is_eq (tag, ly_symbol2scm ("unisilence")))
 378         {
 379           // as for unisono
 380           unisono (true, (last_playing_ == 2) ? 2 : 1);
 381         }
 382       else if (scm_is_eq (tag, ly_symbol2scm ("silence1")))
 383         unisono (true, 1);
 384       else if (scm_is_eq (tag, ly_symbol2scm ("silence2")))
 385         unisono (true, 2);
 386       else if (scm_is_eq (tag, ly_symbol2scm ("solo1")))
 387         solo1 ();
 388       else if (scm_is_eq (tag, ly_symbol2scm ("solo2")))
 389         solo2 ();
 390       else if (scm_is_symbol (tag))
 391         {
 392           string s = "Unknown split directive: "
 393                      + (scm_is_symbol (tag) ? ly_symbol2string (tag) : string ("not a symbol"));
 394           programming_error (s);
 395         }
 396
 397       if ((first_iter_->get_outlet () != outletsBefore[0])
 398           || (second_iter_->get_outlet () != outletsBefore[1]))
 399         kill_mmrest_in_inactive_outlets ();
 400     }
 401
 402   if (first_iter_->ok ())
 403     {
 404       if (try_process (first_iter_, m))
 405         last_playing_ = 1;
 406     }
 407
 408   if (second_iter_->ok ())
 409     {
 410       if (try_process (second_iter_, m))
 411         last_playing_ = 2;
 412     }
 413 }
 414
 415 IMPLEMENT_CTOR_CALLBACK (Part_combine_iterator);