X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fsession_process.cc;h=a162303d428980e6f6358962c76fb13feb21c487;hb=cb0d9f5607da6465efa619cc7f5fb2152bf1b498;hp=7db46f915724b3b605670975aae0e2760058da8a;hpb=6ac8588cd8a34eb5fd2698d3396cb06bd4501fb3;p=ardour.git diff --git a/libs/ardour/session_process.cc b/libs/ardour/session_process.cc index 7db46f9157..a162303d42 100644 --- a/libs/ardour/session_process.cc +++ b/libs/ardour/session_process.cc @@ -40,10 +40,12 @@ #include "ardour/slave.h" #include "ardour/ticker.h" #include "ardour/types.h" +#include "ardour/vca.h" +#include "ardour/vca_manager.h" #include "midi++/mmc.h" -#include "i18n.h" +#include "pbd/i18n.h" using namespace ARDOUR; using namespace PBD; @@ -75,15 +77,27 @@ Session::process (pframes_t nframes) (this->*process_function) (nframes); - /* realtime-safe meter-position changes + /* realtime-safe meter-position and processor-order changes * * ideally this would be done in * Route::process_output_buffers() but various functions * callig it hold a _processor_lock reader-lock */ boost::shared_ptr r = routes.reader (); - for (RouteList::iterator i = r->begin(); i != r->end(); ++i) { - (*i)->apply_meter_change_rt(); + for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) { + if ((*i)->apply_processor_changes_rt()) { + _rt_emit_pending = true; + } + } + if (_rt_emit_pending) { + if (!_rt_thread_active) { + emit_route_signals (); + } + if (pthread_mutex_trylock (&_rt_emit_mutex) == 0) { + pthread_cond_signal (&_rt_emit_cond); + pthread_mutex_unlock (&_rt_emit_mutex); + _rt_emit_pending = false; + } } _engine.main_thread()->drop_buffers (); @@ -118,10 +132,10 @@ int Session::no_roll (pframes_t nframes) { PT_TIMING_CHECK (4); - + framepos_t end_frame = _transport_frame + nframes; // FIXME: varispeed + no_roll ?? int ret = 0; - int declick = get_transport_declick_required(); + int declick = (config.get_use_transport_fades() ? get_transport_declick_required() : false); boost::shared_ptr r = routes.reader (); if (_click_io) { @@ -130,6 +144,11 @@ Session::no_roll (pframes_t nframes) ltc_tx_send_time_code_for_cycle (_transport_frame, end_frame, _target_transport_speed, _transport_speed, nframes); + VCAList v = _vca_manager->vcas (); + for (VCAList::const_iterator i = v.begin(); i != v.end(); ++i) { + (*i)->automation_run (_transport_frame, nframes); + } + if (_process_graph) { DEBUG_TRACE(DEBUG::ProcessThreads,"calling graph/no-roll\n"); _process_graph->routes_no_roll( nframes, _transport_frame, end_frame, non_realtime_work_pending(), declick); @@ -162,12 +181,17 @@ Session::no_roll (pframes_t nframes) int Session::process_routes (pframes_t nframes, bool& need_butler) { - int declick = get_transport_declick_required(); + int declick = (config.get_use_transport_fades() ? get_transport_declick_required() : false); boost::shared_ptr r = routes.reader (); const framepos_t start_frame = _transport_frame; const framepos_t end_frame = _transport_frame + floor (nframes * _transport_speed); - + + VCAList v = _vca_manager->vcas (); + for (VCAList::const_iterator i = v.begin(); i != v.end(); ++i) { + (*i)->automation_run (start_frame, nframes); + } + if (_process_graph) { DEBUG_TRACE(DEBUG::ProcessThreads,"calling graph/process-routes\n"); if (_process_graph->process_routes (nframes, start_frame, end_frame, declick, need_butler) < 0) { @@ -194,6 +218,7 @@ Session::process_routes (pframes_t nframes, bool& need_butler) } if (b) { + DEBUG_TRACE (DEBUG::Butler, string_compose ("%1 rolled and needs butler\n", (*i)->name())); need_butler = true; } } @@ -213,6 +238,11 @@ Session::silent_process_routes (pframes_t nframes, bool& need_butler) const framepos_t start_frame = _transport_frame; const framepos_t end_frame = _transport_frame + lrintf(nframes * _transport_speed); + VCAList v = _vca_manager->vcas (); + for (VCAList::const_iterator i = v.begin(); i != v.end(); ++i) { + (*i)->automation_run (start_frame, nframes); + } + if (_process_graph) { _process_graph->silent_process_routes (nframes, start_frame, end_frame, need_butler); } else { @@ -272,7 +302,7 @@ void Session::process_with_events (pframes_t nframes) { PT_TIMING_CHECK (3); - + SessionEvent* ev; pframes_t this_nframes; framepos_t end_frame; @@ -302,6 +332,47 @@ Session::process_with_events (pframes_t nframes) process_event (ev); } + /* count in */ + if (_transport_speed != 1.0 && _count_in_samples > 0) { + _count_in_samples = 0; + } + + if (_count_in_samples > 0) { + framecnt_t ns = std::min ((framecnt_t)nframes, _count_in_samples); + + no_roll (ns); + run_click (_transport_frame - _count_in_samples, ns); + + _count_in_samples -= ns; + nframes -= ns; + + /* process events.. */ + if (!events.empty() && next_event != events.end()) { + SessionEvent* this_event = *next_event; + Events::iterator the_next_one = next_event; + ++the_next_one; + + while (this_event && this_event->action_frame == _transport_frame) { + process_event (this_event); + if (the_next_one == events.end()) { + this_event = 0; + } else { + this_event = *the_next_one; + ++the_next_one; + } + } + set_next_event (); + } + + check_declick_out (); + + if (nframes == 0) { + return; + } else { + _engine.split_cycle (ns); + } + } + /* Decide on what to do with quarter-frame MTC during this cycle */ bool const was_sending_qf_mtc = _send_qf_mtc; @@ -346,8 +417,15 @@ Session::process_with_events (pframes_t nframes) } if (events.empty() || next_event == events.end()) { - process_without_events (nframes); - return; + try_run_lua (nframes); // also during export ?? ->move to process_without_events() + /* lua scripts may inject events */ + while (_n_lua_scripts > 0 && pending_events.read (&ev, 1) == 1) { + merge_event (ev); + } + if (events.empty() || next_event == events.end()) { + process_without_events (nframes); + return; + } } if (_transport_speed == 1.0) { @@ -413,6 +491,8 @@ Session::process_with_events (pframes_t nframes) this_nframes = abs (floor(frames_moved / _transport_speed)); } + try_run_lua (this_nframes); + if (this_nframes) { click (_transport_frame, this_nframes); @@ -469,6 +549,7 @@ Session::process_with_events (pframes_t nframes) } /* implicit release of route lock */ if (session_needs_butler) { + DEBUG_TRACE (DEBUG::Butler, "p-with-events: session needs butler, call it\n"); _butler->summon (); } } @@ -612,7 +693,7 @@ Session::follow_slave (pframes_t nframes) } - if (_slave_state == Running && !non_realtime_work_pending()) { + if (_slave_state == Running && 0 == (post_transport_work () & ~PostTransportSpeed)) { /* speed is set, we're locked, and good to go */ return true; } @@ -780,6 +861,7 @@ Session::follow_slave_silently (pframes_t nframes, float slave_speed) get_track_statistics (); if (need_butler) { + DEBUG_TRACE (DEBUG::Butler, "f-slave-silently: session needs butler, call it\n"); _butler->summon (); } @@ -863,6 +945,7 @@ Session::process_without_events (pframes_t nframes) check_declick_out (); if (session_needs_butler) { + DEBUG_TRACE (DEBUG::Butler, "p-without-events: session needs butler, call it\n"); _butler->summon (); } } @@ -885,6 +968,7 @@ Session::process_audition (pframes_t nframes) /* run the auditioner, and if it says we need butler service, ask for it */ if (auditioner->play_audition (nframes) > 0) { + DEBUG_TRACE (DEBUG::Butler, "auditioner needs butler, call it\n"); _butler->summon (); } @@ -971,6 +1055,7 @@ Session::queue_event (SessionEvent* ev) } else if (_state_of_the_state & Loading) { merge_event (ev); } else { + Glib::Threads::Mutex::Lock lm (rb_write_lock); pending_events.write (&ev, 1); } } @@ -1094,7 +1179,7 @@ Session::process_event (SessionEvent* ev) case SessionEvent::PunchIn: // cerr << "PunchIN at " << transport_frame() << endl; - if (config.get_punch_in() && record_status() == Enabled) { + if (config.get_punch_in() && record_status() == Enabled && !preroll_record_punch_enabled()) { enable_record (); } remove = false; @@ -1103,13 +1188,21 @@ Session::process_event (SessionEvent* ev) case SessionEvent::PunchOut: // cerr << "PunchOUT at " << transport_frame() << endl; - if (config.get_punch_out()) { + if (config.get_punch_out() && !preroll_record_punch_enabled()) { step_back_from_record (); } remove = false; del = false; break; + case SessionEvent::RecordStart: + if (preroll_record_punch_enabled() && record_status() == Enabled) { + enable_record (); + } + remove = false; + del = false; + break; + case SessionEvent::StopOnce: if (!non_realtime_work_pending()) { _clear_event_type (SessionEvent::StopOnce); @@ -1138,10 +1231,6 @@ Session::process_event (SessionEvent* ev) overwrite_some_buffers (static_cast(ev->ptr)); break; - case SessionEvent::SetTrackSpeed: - set_track_speed (static_cast (ev->ptr), ev->speed); - break; - case SessionEvent::SetSyncSource: DEBUG_TRACE (DEBUG::Slave, "seen request for new slave\n"); use_sync_source (ev->slave); @@ -1153,11 +1242,6 @@ Session::process_event (SessionEvent* ev) ev->region.reset (); break; - case SessionEvent::InputConfigurationChange: - add_post_transport_work (PostTransportInputChange); - _butler->schedule_transport_work (); - break; - case SessionEvent::SetPlayAudioRange: set_play_range (ev->audio_range, (ev->speed == 1.0f)); break; @@ -1209,7 +1293,10 @@ Session::compute_stop_limit () const return max_framepos; } - + if (preroll_record_punch_enabled ()) { + return max_framepos; + } + bool const punching_in = (config.get_punch_in () && _locations->auto_punch_location()); bool const punching_out = (config.get_punch_out () && _locations->auto_punch_location()); @@ -1226,3 +1313,79 @@ Session::compute_stop_limit () const return current_end_frame (); } + + + +/* dedicated thread for signal emission. + * + * while sending cross-thread signals from the process thread + * is fine in general, PBD::Signal's use of boost::function and + * boost:bind can produce a vast overhead which is not + * acceptable for low latency. + * + * This works around the issue by moving the boost overhead + * out of the RT thread. The overall load is probably higher but + * the realtime thread remains unaffected. + */ + +void +Session::emit_route_signals () +{ + // TODO use RAII to allow using these signals in other places + BatchUpdateStart(); /* EMIT SIGNAL */ + boost::shared_ptr r = routes.reader (); + for (RouteList::const_iterator ci = r->begin(); ci != r->end(); ++ci) { + (*ci)->emit_pending_signals (); + } + BatchUpdateEnd(); /* EMIT SIGNAL */ +} + +void +Session::emit_thread_start () +{ + if (_rt_thread_active) { + return; + } + _rt_thread_active = true; + + if (pthread_create (&_rt_emit_thread, NULL, emit_thread, this)) { + _rt_thread_active = false; + } +} + +void +Session::emit_thread_terminate () +{ + if (!_rt_thread_active) { + return; + } + _rt_thread_active = false; + + if (pthread_mutex_lock (&_rt_emit_mutex) == 0) { + pthread_cond_signal (&_rt_emit_cond); + pthread_mutex_unlock (&_rt_emit_mutex); + } + + void *status; + pthread_join (_rt_emit_thread, &status); +} + +void * +Session::emit_thread (void *arg) +{ + Session *s = static_cast(arg); + s->emit_thread_run (); + pthread_exit (0); + return 0; +} + +void +Session::emit_thread_run () +{ + pthread_mutex_lock (&_rt_emit_mutex); + while (_rt_thread_active) { + emit_route_signals(); + pthread_cond_wait (&_rt_emit_cond, &_rt_emit_mutex); + } + pthread_mutex_unlock (&_rt_emit_mutex); +}