X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fsession_process.cc;h=eaa1d055038cf48b610933f40b3ca48da356f29e;hb=cf52d6e4b40111eb04b244ec054055a4ec15dbe0;hp=8d94fbb064807b9a1dc0e6cd3428a80b2c55b0d3;hpb=1e0c1751a53999a8b9ac6978393486afbf317529;p=ardour.git diff --git a/libs/ardour/session_process.cc b/libs/ardour/session_process.cc index 8d94fbb064..eaa1d05503 100644 --- a/libs/ardour/session_process.cc +++ b/libs/ardour/session_process.cc @@ -43,7 +43,7 @@ #include "midi++/mmc.h" -#include "i18n.h" +#include "pbd/i18n.h" using namespace ARDOUR; using namespace PBD; @@ -75,6 +75,29 @@ Session::process (pframes_t nframes) (this->*process_function) (nframes); + /* 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::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 (); /* deliver MIDI clock. Note that we need to use the transport frame @@ -107,10 +130,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) { @@ -151,15 +174,18 @@ 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); - + if (_process_graph) { DEBUG_TRACE(DEBUG::ProcessThreads,"calling graph/process-routes\n"); - _process_graph->process_routes (nframes, start_frame, end_frame, declick, need_butler); + if (_process_graph->process_routes (nframes, start_frame, end_frame, declick, need_butler) < 0) { + stop_transport (); + return -1; + } } else { for (RouteList::iterator i = r->begin(); i != r->end(); ++i) { @@ -248,12 +274,6 @@ Session::get_track_statistics () g_atomic_int_set (&_playback_load, (uint32_t) floor (pworst * 100.0f)); g_atomic_int_set (&_capture_load, (uint32_t) floor (cworst * 100.0f)); - if (cworst < 0.4 || pworst < 0.4) { - GTimeVal now; - g_get_current_time (&now); - std::cerr << g_time_val_to_iso8601 (&now) << " *** WARNING *** CAPTURE BUFFERS (WORST): " << cworst << "PLAYBACK BUFFERS (WORST): " << pworst << endl; - } - if (actively_recording()) { set_dirty(); } @@ -264,7 +284,7 @@ void Session::process_with_events (pframes_t nframes) { PT_TIMING_CHECK (3); - + SessionEvent* ev; pframes_t this_nframes; framepos_t end_frame; @@ -338,6 +358,7 @@ Session::process_with_events (pframes_t nframes) } if (events.empty() || next_event == events.end()) { + try_run_lua (nframes); // also during export ?? ->move to process_without_events() process_without_events (nframes); return; } @@ -376,6 +397,8 @@ Session::process_with_events (pframes_t nframes) send_midi_time_code_for_cycle (_transport_frame, end_frame, nframes); } + ltc_tx_send_time_code_for_cycle (_transport_frame, end_frame, _target_transport_speed, _transport_speed, nframes); + framepos_t stop_limit = compute_stop_limit (); if (maybe_stop (stop_limit)) { @@ -403,6 +426,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); @@ -1199,7 +1224,7 @@ Session::compute_stop_limit () const 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()); @@ -1216,3 +1241,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); +}