X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Ftie-performer.cc;h=e6cb44de8f317a8fbe56a7e24e95d98354bceaa4;hb=eee9576c5d8ee45e432365d15159044f9a06229c;hp=d76b71c4d8ebb06c0368943540e6ee7131b9a586;hpb=0a8f98072c53d877cbb53dd490ba4394d03fa8d2;p=lilypond.git diff --git a/lily/tie-performer.cc b/lily/tie-performer.cc index d76b71c4d8..e6cb44de8f 100644 --- a/lily/tie-performer.cc +++ b/lily/tie-performer.cc @@ -1,223 +1,164 @@ -/* - tie-performer.cc -- implement Tie_performer - - source file of the GNU LilyPond music typesetter - - (c) 1999--2002 Jan Nieuwenhuizen - - */ - -#include "command-request.hh" -#include "audio-item.hh" -#include "musical-request.hh" -#include "pqueue.hh" +/* + This file is part of LilyPond, the GNU music typesetter. + + Copyright (C) 1998--2009 Han-Wen Nienhuys + + 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 . +*/ + #include "performer.hh" -struct CNote_melodic_tuple { - Music *req_ ; - 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 &); -}; +#include "audio-item.hh" +#include "context.hh" +#include "stream-event.hh" +#include "translator.icc" +// #include "international.hh" +#include -inline int compare (CNote_melodic_tuple const &a, CNote_melodic_tuple const &b) +struct Head_event_tuple { - return CNote_melodic_tuple::time_compare (a,b); -} - + Audio_element_info head_; + Moment moment_; + Head_event_tuple () { } + Head_event_tuple (Audio_element_info h, Moment m) + { + head_ = h; + moment_ = m; + } +}; -/** - 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. - TODO: should share code with Tie_engraver ? - */ class Tie_performer : public Performer { -public: - TRANSLATOR_DECLARATIONS(Tie_performer); -private: - bool done_; - PQueue past_notes_pq_; - Music *req_; - Array now_notes_; - Array stopped_notes_; - Link_array ties_; - + Stream_event *event_; + // We don't really need a deque here. A vector would suffice. However, + // for some strange reason, using vectors always leads to memory + // corruption in the STL templates! (i.e. after the first + // now_heads_.push_back (inf_mom), the now_heads_.size() will be + // something like 3303820998 :( + deque now_heads_; + deque now_tied_heads_; + deque heads_to_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 () { - req_ = 0; - done_ = false; + event_ = 0; } -ENTER_DESCRIPTION (Tie_performer, "", "", - "tie-event", - "", "", ""); - - +IMPLEMENT_TRANSLATOR_LISTENER (Tie_performer, tie); void -Tie_performer::initialize () -{ - req_ = 0; -} - - -bool -Tie_performer::try_music (Music *m) +Tie_performer::listen_tie (Stream_event *ev) { - if (!req_) - { - req_ = m; - return true; - } - return false; + event_ = ev; } void -Tie_performer::acknowledge_audio_element (Audio_element_info i) +Tie_performer::process_music () { - if (Audio_note *nh = dynamic_cast (i.elem_)) - { - Music *m = i.req_; - if (m->is_mus_type ("note-event")) - now_notes_.push (CNote_melodic_tuple (nh, m, now_mom ()+ m->length_mom ())); - } + if (event_) + context ()->set_property ("tieMelismaBusy", SCM_BOOL_T); } void -Tie_performer::create_audio_elements () +Tie_performer::acknowledge_audio_element (Audio_element_info inf) { - if (req_ && ! done_) + if (Audio_note *an = dynamic_cast (inf.elem_)) { - Moment now = now_mom (); - Link_array nharr; - - stopped_notes_.clear (); - while (past_notes_pq_.size () - && past_notes_pq_.front ().end_ == now) - stopped_notes_.push (past_notes_pq_.get ()); - done_ = true; - return; - } - - if (req_) - { - now_notes_.sort (CNote_melodic_tuple::pitch_compare); - stopped_notes_.sort (CNote_melodic_tuple::pitch_compare); - int i=0; - int j=0; - int tie_count=0; - while (i < now_notes_.size () && j < stopped_notes_.size ()) - { - int comp - = Pitch::compare (*unsmob_pitch (now_notes_[i].req_->get_mus_property ("pitch")), - *unsmob_pitch (stopped_notes_[j].req_->get_mus_property ("pitch"))); - - if (comp) +// message (_f ("acknowledge_audio_element, Size of now_heads_=%d", now_heads_.size ())); + Head_event_tuple inf_mom (inf, now_mom ()); + if (an->tie_event_) + now_tied_heads_.push_back (inf_mom); + else + now_heads_.push_back (inf_mom); + +// message (_f ("acknowledge_audio_element, added, Size of now_heads_=%d", now_heads_.size ())); + // 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 + deque::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"))) { - (comp < 0) ? i ++ : j++; - continue; + found = true; + Moment skip = now_mom() - (*it).moment_ - th->length_mom_; + an->tie_to (th, skip); + // this invalidates the iterator, we are leaving the loop anyway + heads_to_tie_.erase (it); } - else - { - tie_count ++; - - /* don't go around recreating ties that were already - made. Not infallible. Due to reordering in sort (), - we will make the wrong ties when notenotes are - added. */ - if (tie_count > ties_.size ()) - { - Audio_tie * p = new Audio_tie; - p->set_note (LEFT, stopped_notes_[j].note_); - p->set_note (RIGHT, now_notes_[i].note_); - ties_.push (p); - announce_element (Audio_element_info (p, req_)); - } - i++; - j++; - - } - } - - if (!ties_.size ()) - { - req_->origin ()->warning (_ ("No ties were created!")); } } } +void +Tie_performer::start_translation_timestep () +{ + context ()->set_property ("tieMelismaBusy", + ly_bool2scm (heads_to_tie_.size ())); +} void Tie_performer::stop_translation_timestep () { - for (int i=0; i < now_notes_.size (); i++) + // We might have dangling open ties like c~ d. Close them, unless we have + // tieWaitForNote set... + if (!to_boolean (get_property ("tieWaitForNote"))) { - past_notes_pq_.insert (now_notes_[i]); + heads_to_tie_.clear (); } - now_notes_.clear (); - - for (int i=0; i< ties_.size (); i++) - { - //play_element (ties_[i]); - ties_[i]->note_l_drul_[RIGHT]->tie_to (ties_[i]->note_l_drul_[LEFT]); - } - ties_.clear (); -} -void -Tie_performer::start_translation_timestep () -{ - req_ =0; - done_ = false; - Moment now = now_mom (); - while (past_notes_pq_.size () && past_notes_pq_.front ().end_ < now) - past_notes_pq_.delmin (); -} + if (event_) + { + for (vsize i = now_heads_.size (); i--;) + heads_to_tie_.push_back (now_heads_[i]); + } + for (vsize i = now_tied_heads_.size (); i--;) + heads_to_tie_.push_back (now_tied_heads_[i]); -CNote_melodic_tuple::CNote_melodic_tuple () -{ - note_ =0; - req_ =0; - end_ = 0; + event_ = 0; + now_heads_.clear (); + now_tied_heads_.clear (); } -CNote_melodic_tuple::CNote_melodic_tuple (Audio_note *h, Music*m, Moment mom) -{ - note_ = h; - req_ = m; - end_ = mom; -} +ADD_TRANSLATOR (Tie_performer, + /* doc */ + "Generate ties between note heads of equal pitch.", -int -CNote_melodic_tuple::pitch_compare (CNote_melodic_tuple const&h1, - CNote_melodic_tuple const &h2) -{ - SCM p1 = h1.req_->get_mus_property ("pitch"); - SCM p2 = h2.req_->get_mus_property ("pitch"); - return Pitch::compare (*unsmob_pitch (p1), - *unsmob_pitch (p2)); -} + /* create */ + "", -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" + );