X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Fnote-performer.cc;h=44efd745742744e43afa4c7e1033503058ab9ce4;hb=750b714488c5af6eae22d07163bba8b554734ac6;hp=5390447402089e9b33aa00c1ab748ffc1c9689fe;hpb=051d7e7cbdbbe5f5337ab2b477b0bd1e72eedd04;p=lilypond.git diff --git a/lily/note-performer.cc b/lily/note-performer.cc index 5390447402..44efd74574 100644 --- a/lily/note-performer.cc +++ b/lily/note-performer.cc @@ -1,132 +1,202 @@ /* - note-performer.cc -- implement Note_performer + This file is part of LilyPond, the GNU music typesetter. - source file of the GNU LilyPond music typesetter + Copyright (C) 1996--2015 Jan Nieuwenhuizen - (c) 1996--2002 Jan Nieuwenhuizen - */ + 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" -#include "request.hh" #include "audio-item.hh" #include "audio-column.hh" -#include "global-translator.hh" +#include "global-context.hh" +#include "stream-event.hh" #include "warn.hh" -/** -Convert reqs to audio notes. -*/ -class Note_performer : public Performer { +#include "translator.icc" + +class Note_performer : public Performer +{ public: - TRANSLATOR_DECLARATIONS(Note_performer); - -protected: - virtual bool try_music (Music *req) ; + TRANSLATOR_DECLARATIONS (Note_performer); - virtual void stop_translation_timestep (); - virtual void create_audio_elements (); - Global_translator* get_global_translator (); +protected: + void stop_translation_timestep (); + void process_music (); + void listen_note (Stream_event *); + void listen_breathing (Stream_event *); + void listen_tie (Stream_event *); + void listen_articulation (Stream_event *); private: - Link_array note_reqs_; - Link_array notes_; - Link_array delayeds_; + vector note_evs_, script_evs_; + vector notes_; + + vector last_notes_; + Moment last_start_; }; -void -Note_performer::create_audio_elements () +void +Note_performer::process_music () { - if (note_reqs_.size ()) + if (!note_evs_.size ()) + return; + + Pitch transposing; + SCM prop = get_property ("instrumentTransposition"); + if (unsmob (prop)) + transposing = *unsmob (prop); + + for (vsize i = 0; i < note_evs_.size (); i++) { - int transposing_i = 0; - //urg - SCM prop = get_property ("transposing"); - if (gh_number_p (prop)) - transposing_i = gh_scm2int (prop); - - while (note_reqs_.size ()) - { - Music* n = note_reqs_.pop (); - Pitch pit = * unsmob_pitch (n->get_mus_property ("pitch")); - Audio_note* p = new Audio_note (pit, n->get_length (), transposing_i); - Audio_element_info info (p, n); - announce_element (info); - notes_.push (p); - } - note_reqs_.clear (); + Stream_event *n = note_evs_[i]; + SCM pit = n->get_property ("pitch"); + + if (Pitch *pitp = unsmob (pit)) + { + SCM articulations = n->get_property ("articulations"); + Stream_event *tie_event = 0; + Moment len = get_event_length (n, now_mom ()); + int velocity = 0; + + for (vsize j = script_evs_.size (); j--;) + articulations = scm_cons (script_evs_[j]->self_scm (), articulations); + + for (SCM s = articulations; scm_is_pair (s); s = scm_cdr (s)) + { + Stream_event *ev = unsmob (scm_car (s)); + if (!ev) + continue; + + if (ev->in_event_class ("tie-event")) + tie_event = ev; + SCM f = ev->get_property ("midi-length"); + if (ly_is_procedure (f)) + len = robust_scm2moment (scm_call_2 (f, len.smobbed_copy (), + context ()->self_scm ()), + len); + velocity += robust_scm2int (ev->get_property ("midi-extra-velocity"), 0); + } + + Audio_note *p = new Audio_note (*pitp, len, + tie_event, transposing, velocity); + Audio_element_info info (p, n); + announce_element (info); + notes_.push_back (p); + + /* + Grace notes shorten the previous non-grace note. If it was + part of a tie, shorten the first note in the tie. + */ + if (now_mom ().grace_part_) + { + if (last_start_.grace_part_ == Rational (0)) + { + for (vsize i = 0; i < last_notes_.size (); i++) + { + Audio_note *tie_head = last_notes_[i]->tie_head (); + Moment start = tie_head->audio_column_->when (); + //Shorten the note if it would overlap. It might + //not if there's a rest in between. + if (start + tie_head->length_mom_ > now_mom ()) + tie_head->length_mom_ = now_mom () - start; + } + } + } + } } } -Global_translator* -Note_performer::get_global_translator () +void +Note_performer::stop_translation_timestep () { - Translator *t = this; - Global_translator *global =0; - do + if (note_evs_.size ()) { - t = t->daddy_trans_ ; - global = dynamic_cast (t); + last_notes_ = notes_; + last_start_ = now_mom (); } - while (!global); - return global; + notes_.clear (); + note_evs_.clear (); + script_evs_.clear (); } +void +Note_performer::listen_note (Stream_event *ev) +{ + note_evs_.push_back (ev); +} void -Note_performer::stop_translation_timestep () +Note_performer::listen_tie (Stream_event *ev) { + script_evs_.push_back (ev); +} - // why don't grace notes show up here? - // --> grace notes effectively do not get delayed - Global_translator* global = get_global_translator (); - for (int i=0; i < notes_.size (); i++) - { - Audio_note* n = notes_[i]; - Moment m= n->delayed_until_mom_; - if (m.to_bool ()) - { - global->add_moment_to_process (m); - delayeds_.push (n); - notes_[i] = 0; - notes_.del (i); - i--; - } - } +void +Note_performer::listen_articulation (Stream_event *ev) +{ + script_evs_.push_back (ev); +} - Moment now = now_mom (); - for (int i=0; i < notes_.size (); i++) - { - play_element (notes_[i]); - } - notes_.clear (); - note_reqs_.clear (); - for (int i=0; i < delayeds_.size (); i++) - { - Audio_note* n = delayeds_[i]; - if (n->delayed_until_mom_ <= now) - { - play_element (n); - delayeds_[i] = 0; - delayeds_.del (i); - i--; - } - } +void +Note_performer::listen_breathing (Stream_event *ev) +{ + //Shorten previous note if needed + SCM f = ev->get_property ("midi-length"); + if (ly_is_procedure (f)) + for (vsize i = 0; i < last_notes_.size (); i++) + { + //Pass midi-length the available time since the last note started, + //including any intervening rests. It returns how much is left for the + //note. + Moment start = last_notes_[i]->audio_column_->when (); + Moment available = now_mom () - start; + Moment len = robust_scm2moment (scm_call_2 (f, available.smobbed_copy (), + context ()->self_scm ()), available); + //Take time from the first note of the tie, since it has all the length. + Audio_note *tie_head = last_notes_[i]->tie_head (); + len += start - tie_head->audio_column_->when (); + if (len < tie_head->length_mom_) + tie_head->length_mom_ = len; + } } - -bool -Note_performer::try_music (Music* req) + +void +Note_performer::boot () { - if (req->is_mus_type ("note-event")) - { - note_reqs_.push (req); - return true; - } - return false; + ADD_LISTENER (Note_performer, note); + ADD_LISTENER (Note_performer, breathing); + ADD_LISTENER (Note_performer, tie); + ADD_LISTENER (Note_performer, articulation); } -ENTER_DESCRIPTION(Note_performer,"","","note-event","","",""); +ADD_TRANSLATOR (Note_performer, + /* doc */ + "", + + /* create */ + "", + + /* read */ + "", + + /* write */ + "" + ); -Note_performer::Note_performer() +Note_performer::Note_performer (Context *c) + : Performer (c) { }