X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Ftie-performer.cc;h=77fb9e336df5c90c70f2a30e67379d30ed642b92;hb=9e781b7dc83b60a543ce218aa1a5f139f74c760f;hp=3ca52b6c4920b9c42d8306b8719fca40ada12ac5;hpb=6d73c34ae1b5c281b0fa3ba3a5c775d44140f620;p=lilypond.git diff --git a/lily/tie-performer.cc b/lily/tie-performer.cc index 3ca52b6c49..77fb9e336d 100644 --- a/lily/tie-performer.cc +++ b/lily/tie-performer.cc @@ -1,221 +1,174 @@ -/* - tie-performer.cc -- implement Tie_performer - - source file of the GNU LilyPond music typesetter - - (c) 1999--2003 Jan Nieuwenhuizen - - */ +/* + This file is part of LilyPond, the GNU music typesetter. + Copyright (C) 1998--2014 Han-Wen Nienhuys -#include "audio-item.hh" -#include "event.hh" -#include "pqueue.hh" -#include "performer.hh" + 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. -struct CNote_melodic_tuple { - Music *event_ ; - Audio_note *note_; - Moment end_; - CNote_melodic_tuple (); - CNote_melodic_tuple (Audio_note*, Music*, Moment); - static int pitch_compare (CNote_melodic_tuple const &, CNote_melodic_tuple const &); - static int time_compare (CNote_melodic_tuple const &, CNote_melodic_tuple const &); -}; + 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. -inline int compare (CNote_melodic_tuple const &a, CNote_melodic_tuple const &b) -{ - return CNote_melodic_tuple::time_compare (a,b); -} + You should have received a copy of the GNU General Public License + along with LilyPond. If not, see . +*/ + +#include "performer.hh" +#include "audio-item.hh" +#include "context.hh" +#include "stream-event.hh" +#include "translator.icc" +#include -/** - Manufacture ties. Acknowledge notes, and put them into a - priority queue. If we have a Music, connect the notes that finish - just at this time, and note that start at this time. +struct Head_audio_event_tuple +{ + Audio_element_info head_; + // The end moment of the note, so we can calculate a skip and check whether + // the note still goes on + Moment end_moment_; + Head_audio_event_tuple () {} + Head_audio_event_tuple (Audio_element_info h, Moment m) + { + head_ = h; + end_moment_ = m; + } +}; - TODO: should share code with Tie_engraver ? - */ class Tie_performer : public Performer { -public: - TRANSLATOR_DECLARATIONS(Tie_performer); -private: - - bool ties_created_; - Array now_notes_; - Array tied_notes_; - - Music *event_; - Music * prev_event_; - - Link_array ties_; - + Stream_event *event_; + list now_heads_; + list now_tied_heads_; // new tied notes + list heads_to_tie_; // heads waiting for closing tie + protected: - virtual void initialize (); - virtual void start_translation_timestep (); - virtual void stop_translation_timestep (); + void stop_translation_timestep (); + void start_translation_timestep (); virtual void acknowledge_audio_element (Audio_element_info); - virtual bool try_music (Music*); - virtual void create_audio_elements (); + void process_music (); + DECLARE_TRANSLATOR_LISTENER (tie); +public: + TRANSLATOR_DECLARATIONS (Tie_performer); }; - Tie_performer::Tie_performer () { event_ = 0; - ties_created_ = false; } -ENTER_DESCRIPTION (Tie_performer, "", "", - "tie-event", - "", "", ""); - - +IMPLEMENT_TRANSLATOR_LISTENER (Tie_performer, tie); void -Tie_performer::initialize () +Tie_performer::listen_tie (Stream_event *ev) { - event_ = 0; + event_ = ev; } - -bool -Tie_performer::try_music (Music *m) +void +Tie_performer::process_music () { - if (!event_) - { - event_ = m; - return true; - } - return false; + if (event_) + context ()->set_property ("tieMelismaBusy", SCM_BOOL_T); } void -Tie_performer::acknowledge_audio_element (Audio_element_info i) +Tie_performer::acknowledge_audio_element (Audio_element_info inf) { - if (Audio_note *nh = dynamic_cast (i.elem_)) + if (Audio_note *an = dynamic_cast (inf.elem_)) { - Music *m = i.event_; - if (m->is_mus_type ("note-event")) - now_notes_.push (CNote_melodic_tuple (nh, m, now_mom ()+ m->get_length ())); + // for each tied note, store the info and its end moment, so we can + // later on check whether (1) the note is still ongoing and (2) how + // long the skip is with tieWaitForNote + Head_audio_event_tuple inf_mom (inf, now_mom () + an->length_mom_); + if (an->tie_event_) + now_tied_heads_.push_back (inf_mom); + else + now_heads_.push_back (inf_mom); + + // Find a previous note that ties to the current note. If it exists, + // remove it from the heads_to_tie vector and create the tie + list::iterator it; + bool found = false; + Stream_event *right_mus = inf.event_; + for (it = heads_to_tie_.begin (); + !found && (it != heads_to_tie_.end ()); + it++) + { + Audio_element_info et = (*it).head_; + Audio_note *th = dynamic_cast (et.elem_); + Stream_event *left_mus = et.event_; + + if (th && right_mus && left_mus + && ly_is_equal (right_mus->get_property ("pitch"), + left_mus->get_property ("pitch"))) + { + found = true; + // (*it).moment_ already stores the end of the tied note! + Moment skip = now_mom () - (*it).end_moment_; + an->tie_to (th, skip); + it = heads_to_tie_.erase (it); + } + } } } void -Tie_performer::create_audio_elements () +Tie_performer::start_translation_timestep () { - /* - This is a nested loop. Not optimal, but good enough. - */ - if (tied_notes_.size ()) - { - Moment now = now_mom(); - for (int i = tied_notes_.size (); i--; ) - { - if (tied_notes_[i].end_ != now) - continue; - - for (int j = now_notes_.size(); j--;) - { - int comp - = Pitch::compare (*unsmob_pitch (tied_notes_[i].event_->get_mus_property ("pitch")), - *unsmob_pitch (now_notes_[j].event_->get_mus_property ("pitch"))); - - if (comp == 0) - { - - Audio_tie * p = new Audio_tie; - p->set_note (LEFT, tied_notes_[i].note_); - p->set_note (RIGHT, now_notes_[j].note_); - ties_.push (p); - announce_element (Audio_element_info (p, event_)); - ties_created_ = true; - - tied_notes_.del (i); - break ; - } - } - } - } + context ()->set_property ("tieMelismaBusy", + ly_bool2scm (heads_to_tie_.size ())); } +// a predicate implemented as a class, used to delete all tied notes with end +// moment in the past: +class end_moment_passed +{ +protected: + Moment now; +public: + end_moment_passed (Moment mom) : now (mom) {} + bool operator () (const Head_audio_event_tuple &value) + { + return (value.end_moment_ <= now); + } +}; void Tie_performer::stop_translation_timestep () { - if (prev_event_ && tied_notes_.size () && !ties_.size () - && now_notes_.size ()) + // We might have dangling open ties like c~ d. Close them, unless the first + // note is still ongoing or we have we have tieWaitForNote set... + if (!to_boolean (get_property ("tieWaitForNote"))) { - prev_event_->origin ()->warning (_ ("No ties were performed.")); + heads_to_tie_.remove_if (end_moment_passed (now_mom ())); } - if (ties_created_) - { - prev_event_ = 0; - tied_notes_.clear(); - } - + // Append now_heads_ and now_tied_heads to heads_to_tie_ for the next time step if (event_) { - tied_notes_ = now_notes_ ; - prev_event_ = event_; + heads_to_tie_.splice (heads_to_tie_.end (), now_heads_); } + heads_to_tie_.splice (heads_to_tie_.end (), now_tied_heads_); event_ = 0; - now_notes_ .clear (); - - for (int i=ties_.size (); i--;) - { - ties_[i]->note_drul_[RIGHT]->tie_to (ties_[i]->note_drul_[LEFT]); - } - - ties_.clear (); -} - -void -Tie_performer::start_translation_timestep () -{ - event_ =0; - ties_created_ = false; - Moment now = now_mom (); - for (int i= tied_notes_.size (); i-- ;) - { - if (tied_notes_[i].end_ < now) - tied_notes_.del (i); - else - break ; - } + now_heads_.clear (); + now_tied_heads_.clear (); } +ADD_TRANSLATOR (Tie_performer, + /* doc */ + "Generate ties between note heads of equal pitch.", -CNote_melodic_tuple::CNote_melodic_tuple () -{ - note_ =0; - event_ =0; - end_ = 0; -} + /* create */ + "", -CNote_melodic_tuple::CNote_melodic_tuple (Audio_note *h, Music*m, Moment mom) -{ - note_ = h; - event_ = m; - end_ = mom; -} - -int -CNote_melodic_tuple::pitch_compare (CNote_melodic_tuple const&h1, - CNote_melodic_tuple const &h2) -{ - SCM p1 = h1.event_->get_mus_property ("pitch"); - SCM p2 = h2.event_->get_mus_property ("pitch"); - return Pitch::compare (*unsmob_pitch (p1), - *unsmob_pitch (p2)); -} - -int -CNote_melodic_tuple::time_compare (CNote_melodic_tuple const&h1, - CNote_melodic_tuple const &h2) -{ - return (h1.end_ - h2.end_).main_part_.sign (); -} + /* read */ + "tieWaitForNote", + /* write */ + "tieMelismaBusy" + );