X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Fscore-performer.cc;h=ac8f656c482152e3f31380b7b9bd1f923568c213;hb=5bbfc22fce036b9b69df5e420de93e11da23c05e;hp=a3b1abf6c6ba04eccdf9442dabfb5c19c67785db;hpb=7e72a1e50e94a7f9738d62599de79fe7745f600c;p=lilypond.git diff --git a/lily/score-performer.cc b/lily/score-performer.cc index a3b1abf6c6..ac8f656c48 100644 --- a/lily/score-performer.cc +++ b/lily/score-performer.cc @@ -1,121 +1,187 @@ /* - score-performer.cc -- implement Score_performer + This file is part of LilyPond, the GNU music typesetter. - source file of the GNU LilyPond music typesetter + Copyright (C) 1996--2014 Jan Nieuwenhuizen - (c) 1996--2004 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 "score-performer.hh" -#include "midi-def.hh" + #include "audio-column.hh" #include "audio-item.hh" +#include "context-def.hh" +#include "dispatcher.hh" +#include "global-context.hh" #include "performance.hh" #include "midi-stream.hh" +#include "output-def.hh" #include "string-convert.hh" #include "warn.hh" -#include "context-def.hh" +#include "audio-staff.hh" +#include "audio-item.hh" +ADD_TRANSLATOR_GROUP (Score_performer, + /* doc */ + "", + /* create */ + "", -ENTER_DESCRIPTION(Score_performer, -/* descr */ "", -/* creats*/ "", -/* accepts */ "", -/* acks */ "", -/* reads */ "", -/* write */ ""); + /* read */ + "", + /* write */ + "" + ); Score_performer::Score_performer () { performance_ = 0; + skipping_ = false; + audio_column_ = 0; } - Score_performer::~Score_performer () { } void -Score_performer::play_element (Audio_element * p) +Score_performer::announce_element (Audio_element_info info) { - if (Audio_item * i=dynamic_cast (p)) + announce_infos_.push_back (info); + if (Audio_staff *s = dynamic_cast (info.elem_)) { - audio_column_->add_audio_item (i); + performance_->audio_staffs_.push_back (s); } - performance_->add_element (p); + + performance_->add_element (info.elem_); } void -Score_performer::announce_element (Audio_element_info info) +Score_performer::acknowledge_audio_elements () { - announce_infos_.push (info); - - - /* - huh? - copied from score-engraver, but - this way staff gets in list twice - if (Audio_item* i = dynamic_cast (info.elem_)) - performance_->add_element (i); - */ + for (vsize i = 0; i < announce_infos_.size (); i++) + { + if (Audio_item *ai = dynamic_cast (announce_infos_[i].elem_)) + audio_column_->add_audio_item (ai); + } + Performer_group::acknowledge_audio_elements (); } -void -Score_performer::prepare (Moment m) +void +Score_performer::connect_to_context (Context *c) { - Global_translator::prepare (m); - audio_column_ = new Audio_column (m); - play_element (audio_column_); - start_translation_timestep (); -} + Performer_group::connect_to_context (c); + Dispatcher *d = c->get_global_context ()->event_source (); + d->add_listener (GET_LISTENER (one_time_step), ly_symbol2scm ("OneTimeStep")); + d->add_listener (GET_LISTENER (prepare), ly_symbol2scm ("Prepare")); + d->add_listener (GET_LISTENER (finish), ly_symbol2scm ("Finish")); +} -void -Score_performer::one_time_step () +void +Score_performer::disconnect_from_context () { - // fixme: put this back. - // process_music (); - do_announces (); - stop_translation_timestep (); - check_removal (); + Dispatcher *d = context ()->get_global_context ()->event_source (); + d->remove_listener (GET_LISTENER (one_time_step), ly_symbol2scm ("OneTimeStep")); + d->remove_listener (GET_LISTENER (prepare), ly_symbol2scm ("Prepare")); + d->remove_listener (GET_LISTENER (finish), ly_symbol2scm ("Finish")); + + Performer_group::disconnect_from_context (); } +IMPLEMENT_LISTENER (Score_performer, prepare); void -Score_performer::start () +Score_performer::prepare (SCM sev) { + Stream_event *ev = unsmob_stream_event (sev); + SCM sm = ev->get_property ("moment"); + Moment *m = Moment::unsmob (sm); + audio_column_ = new Audio_column (*m); + announce_element (Audio_element_info (audio_column_, 0)); + precomputed_recurse_over_translators (context (), START_TRANSLATION_TIMESTEP, UP); } - -int -Score_performer::get_tempo () const +IMPLEMENT_LISTENER (Score_performer, finish); +void +Score_performer::finish (SCM) { - return performance_->midi_->get_tempo (Moment (Rational (1, 4))); + SCM channel_mapping = context ()->get_property ("midiChannelMapping"); + bool use_ports = channel_mapping == ly_symbol2scm ("voice"); + performance_->ports_ = use_ports; + recurse_over_translators (context (), + &Translator::finalize, + &Translator_group::finalize, + UP); } +IMPLEMENT_LISTENER (Score_performer, one_time_step); void -Score_performer::finish () +Score_performer::one_time_step (SCM) { - check_removal (); - finalize (); + // audio_column_ can be 0 when prepare has not been called. The + // condition is triggered when Simple_music_iterator implicitly + // creates a Score context, like when writing + // + // \score { { | c4 c c c } \midi { } } + // + // The same situation happens with the Score_engraver group, but it + // would appear not to suffer any bad side effects. + + if (!audio_column_) + audio_column_ = new Audio_column (context ()->now_mom ()); + if (to_boolean (context ()->get_property ("skipTypesetting"))) + { + if (!skipping_) + { + skip_start_mom_ = audio_column_->when (); + skipping_ = true; + } + } + else + { + if (skipping_) + { + offset_mom_ -= audio_column_->when () - skip_start_mom_; + skipping_ = false; + } + + audio_column_->offset_when (offset_mom_); + precomputed_recurse_over_translators (context (), PROCESS_MUSIC, UP); + do_announces (); + } + + precomputed_recurse_over_translators (context (), STOP_TRANSLATION_TIMESTEP, UP); } -Music_output * -Score_performer::get_output () +void +Score_performer::derived_mark () const { - Music_output * o = performance_; - performance_ =0; - return o; + if (performance_) + scm_gc_mark (performance_->self_scm ()); + + Performer_group::derived_mark (); } void Score_performer::initialize () { - unsmob_context_def (definition_)->apply_default_property_operations (this); - assert (dynamic_cast (output_def_)); performance_ = new Performance; - performance_->midi_ = dynamic_cast (output_def_); + performance_->unprotect (); + context ()->set_property ("output", performance_->self_scm ()); + performance_->midi_ = context ()->get_output_def (); Translator_group::initialize (); }