X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Ftie-performer.cc;h=1f95023eb6ab0962146dd13b54ce07f08b665717;hb=97a0169312a260933246ab224e4f8b0969871dd5;hp=b9109b9d86d3d53a37f082e6370b4dd844ea1cf1;hpb=f798a4c8737f0d279fcf54ba4f0951074565fa76;p=lilypond.git diff --git a/lily/tie-performer.cc b/lily/tie-performer.cc index b9109b9d86..1f95023eb6 100644 --- a/lily/tie-performer.cc +++ b/lily/tie-performer.cc @@ -1,168 +1,205 @@ -/* - tie-performer.cc -- implement Tie_performer - - source file of the GNU LilyPond music typesetter - - (c) 1999 Jan Nieuwenhuizen - - */ - -#include "tie-performer.hh" -#include "command-request.hh" -#include "audio-item.hh" -#include "musical-request.hh" +/* + This file is part of LilyPond, the GNU music typesetter. + + Copyright (C) 1998--2015 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 . +*/ -ADD_THIS_TRANSLATOR (Tie_performer); +#include "performer.hh" -Tie_performer::Tie_performer() +#include "audio-item.hh" +#include "context.hh" +#include "stream-event.hh" +#include "translator.icc" +#include + +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; + } +}; + +class Tie_performer : public Performer +{ + Stream_event *event_; + list now_heads_; + list now_tied_heads_; // new tied notes + list heads_to_tie_; // heads waiting for closing tie + +protected: + void stop_translation_timestep (); + void start_translation_timestep (); + virtual void acknowledge_audio_element (Audio_element_info); + void process_music (); + void listen_tie (Stream_event *); +public: + TRANSLATOR_DECLARATIONS (Tie_performer); +}; + +Tie_performer::Tie_performer (Context *c) + : Performer (c) { - req_l_ = 0; + event_ = 0; } -bool -Tie_performer::do_try_music (Music *m) +void +Tie_performer::listen_tie (Stream_event *ev) { - if (!req_l_) - { - if (Tie_req * c = dynamic_cast (m)) - { - req_l_ = c; - return true; - } - } - return false; + event_ = ev; } void -Tie_performer::acknowledge_element (Audio_element_info i) +Tie_performer::process_music () { - if (Audio_note *nh = dynamic_cast (i.elem_l_)) - { - Note_req * m = dynamic_cast (i.req_l_); - if (!m) - return; - 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::do_process_requests () +Tie_performer::acknowledge_audio_element (Audio_element_info inf) { - if (req_l_) + 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 ()); + // 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); + } + } + if (found) + return; + 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)) + continue; + + SCM p1 = left_mus->get_property ("pitch"); + SCM p2 = right_mus->get_property ("pitch"); + if (unsmob (p1) && unsmob (p2) + && unsmob (p1)->tone_pitch () == unsmob (p2)->tone_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::process_acknowledged () +Tie_performer::start_translation_timestep () { - if (req_l_) - { - 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 - = Musical_pitch::compare (now_notes_[i].req_l_->pitch_ , - stopped_notes_[j].req_l_->pitch_); - - if (comp) - { - (comp < 0) ? i ++ : j++; - continue; - } - 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 > tie_p_arr_.size ()) - { - Audio_tie * p = new Audio_tie; - p->set_note (LEFT, stopped_notes_[j].note_l_); - p->set_note (RIGHT, now_notes_[i].note_l_); - tie_p_arr_.push (p); - announce_element (Audio_element_info (p, req_l_)); - } - i++; - j++; - - } - } - - if (!tie_p_arr_.size ()) - { - req_l_->warning (_("No ties were created!")); - } - - } + 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::do_pre_move_processing () +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 the first + // note is still ongoing or we have we have tieWaitForNote set... + if (!to_boolean (get_property ("tieWaitForNote"))) + { + heads_to_tie_.remove_if (end_moment_passed (now_mom ())); + } + + // Append now_heads_ and now_tied_heads to heads_to_tie_ for the next time step + if (event_) { - past_notes_pq_.insert (now_notes_[i]); + heads_to_tie_.splice (heads_to_tie_.end (), now_heads_); } - now_notes_.clear (); - - for (int i=0; i< tie_p_arr_.size (); i++) - { - //play_element (tie_p_arr_[i]); - tie_p_arr_[i]->note_l_drul_[RIGHT]->tie_to (tie_p_arr_[i]->note_l_drul_[LEFT]); - } - tie_p_arr_.clear (); + heads_to_tie_.splice (heads_to_tie_.end (), now_tied_heads_); + + event_ = 0; + now_heads_.clear (); + now_tied_heads_.clear (); } void -Tie_performer::do_post_move_processing () +Tie_performer::boot () { - req_l_ =0; - Moment now = now_mom (); - while (past_notes_pq_.size () && past_notes_pq_.front ().end_ < now) - past_notes_pq_.delmin (); + ADD_LISTENER (Tie_performer, tie); } +ADD_TRANSLATOR (Tie_performer, + /* doc */ + "Generate ties between note heads of equal pitch.", -CNote_melodic_tuple::CNote_melodic_tuple () -{ - note_l_ =0; - req_l_ =0; - end_ = 0; -} + /* create */ + "", -CNote_melodic_tuple::CNote_melodic_tuple (Audio_note *h, Melodic_req*m, Moment mom) -{ - note_l_ = h; - req_l_ = m; - end_ = mom; -} + /* read */ + "tieWaitForNote", -int -CNote_melodic_tuple::pitch_compare (CNote_melodic_tuple const&h1, - CNote_melodic_tuple const &h2) -{ - return Melodic_req::compare (*h1.req_l_, *h2.req_l_); -} - -int -CNote_melodic_tuple::time_compare (CNote_melodic_tuple const&h1, - CNote_melodic_tuple const &h2) -{ - return (h1.end_ - h2.end_ ).sign (); -} + /* write */ + "tieMelismaBusy" + );