X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fsession_process.cc;h=483a8f071a6164d13ef6b125445bf325b0c35454;hb=5e8b3f08328424299c264d70bba307dcea1f2b17;hp=a79a2e4cd8744460c1f85dab6f4a5e9a62bb9101;hpb=498dfebcca3b97cdd7b83444040042fe06626241;p=ardour.git diff --git a/libs/ardour/session_process.cc b/libs/ardour/session_process.cc index a79a2e4cd8..483a8f071a 100644 --- a/libs/ardour/session_process.cc +++ b/libs/ardour/session_process.cc @@ -23,6 +23,7 @@ #include #include "pbd/error.h" +#include "pbd/enumwriter.h" #include @@ -31,8 +32,7 @@ #include "ardour/audioengine.h" #include "ardour/auditioner.h" #include "ardour/butler.h" -#include "ardour/cycle_timer.h" -#include "ardour/cycles.h" +#include "ardour/debug.h" #include "ardour/session.h" #include "ardour/slave.h" #include "ardour/timestamps.h" @@ -51,10 +51,6 @@ using namespace std; void Session::process (nframes_t nframes) { - // This is no more the appropriate place to call cycle - // start. cycle_start needs to be called at the Route::roll() - // where the signals which we want to mixdown have been calculated. - // MIDI::Manager::instance()->cycle_start(nframes); _silent = false; @@ -85,15 +81,6 @@ Session::process (nframes_t nframes) MIDI::Manager::instance()->cycle_end(); } -void -Session::prepare_diskstreams () -{ - boost::shared_ptr dsl = diskstreams.reader(); - for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) { - (*i)->prepare (); - } -} - int Session::fail_roll (nframes_t nframes) { @@ -132,7 +119,7 @@ Session::no_roll (nframes_t nframes) } int -Session::process_routes (nframes_t nframes) +Session::process_routes (nframes_t nframes, bool& need_butler) { bool record_active; int declick = get_transport_declick_required(); @@ -159,18 +146,7 @@ Session::process_routes (nframes_t nframes) (*i)->set_pending_declick (declick); - if ((ret = (*i)->roll (nframes, start_frame, end_frame, declick, record_active, rec_monitors)) < 0) { - - /* we have to do this here. Route::roll() for an AudioTrack will have called AudioDiskstream::process(), - and the DS will expect AudioDiskstream::commit() to be called. but we're aborting from that - call path, so make sure we release any outstanding locks here before we return failure. - */ - - boost::shared_ptr dsl = diskstreams.reader(); - for (DiskstreamList::iterator ids = dsl->begin(); ids != dsl->end(); ++ids) { - (*ids)->recover (); - } - + if ((ret = (*i)->roll (nframes, start_frame, end_frame, declick, record_active, rec_monitors, need_butler)) < 0) { stop_transport (); return -1; } @@ -180,7 +156,7 @@ Session::process_routes (nframes_t nframes) } int -Session::silent_process_routes (nframes_t nframes) +Session::silent_process_routes (nframes_t nframes, bool& need_butler) { bool record_active = actively_recording(); int declick = get_transport_declick_required(); @@ -203,18 +179,7 @@ Session::silent_process_routes (nframes_t nframes) continue; } - if ((ret = (*i)->silent_roll (nframes, start_frame, end_frame, record_active, rec_monitors)) < 0) { - - /* we have to do this here. Route::roll() for an AudioTrack will have called AudioDiskstream::process(), - and the DS will expect AudioDiskstream::commit() to be called. but we're aborting from that - call path, so make sure we release any outstanding locks here before we return failure. - */ - - boost::shared_ptr dsl = diskstreams.reader(); - for (DiskstreamList::iterator ids = dsl->begin(); ids != dsl->end(); ++ids) { - (*ids)->recover (); - } - + if ((ret = (*i)->silent_roll (nframes, start_frame, end_frame, record_active, rec_monitors, need_butler)) < 0) { stop_transport (); return -1; } @@ -224,7 +189,7 @@ Session::silent_process_routes (nframes_t nframes) } void -Session::commit_diskstreams (nframes_t nframes, bool &needs_butler) +Session::get_diskstream_statistics () { int dret; float pworst = 1.0f; @@ -237,21 +202,6 @@ Session::commit_diskstreams (nframes_t nframes, bool &needs_butler) continue; } - /* force all diskstreams not handled by a Route to call do their stuff. - Note: the diskstreams that were handled by a route will just return zero - from this call, because they know they were processed. So in fact, this - also runs commit() for every diskstream. - */ - - if ((dret = (*i)->process (_transport_frame, nframes, actively_recording(), get_rec_monitors_input())) == 0) { - if ((*i)->commit (nframes)) { - needs_butler = true; - } - - } else if (dret < 0) { - (*i)->recover(); - } - pworst = min (pworst, (*i)->playback_buffer_load()); cworst = min (cworst, (*i)->capture_buffer_load()); } @@ -275,7 +225,7 @@ Session::commit_diskstreams (nframes_t nframes, bool &needs_butler) void Session::process_with_events (nframes_t nframes) { - Event* ev; + SessionEvent* ev; nframes_t this_nframes; nframes_t end_frame; bool session_needs_butler = false; @@ -300,7 +250,7 @@ Session::process_with_events (nframes_t nframes) */ while (!non_realtime_work_pending() && !immediate_events.empty()) { - Event *ev = immediate_events.front (); + SessionEvent *ev = immediate_events.front (); immediate_events.pop_front (); process_event (ev); } @@ -311,6 +261,7 @@ Session::process_with_events (nframes_t nframes) */ if (_send_timecode_update) { send_full_time_code(nframes); + deliver_mmc (MIDI::MachineControl::cmdLocate, _transport_frame); } if (!process_can_proceed()) { @@ -334,7 +285,7 @@ Session::process_with_events (nframes_t nframes) end_frame = _transport_frame + (nframes_t)frames_moved; { - Event* this_event; + SessionEvent* this_event; Events::iterator the_next_one; if (!process_can_proceed()) { @@ -397,16 +348,11 @@ Session::process_with_events (nframes_t nframes) click (_transport_frame, this_nframes); - /* now process frames between now and the first event in this block */ - prepare_diskstreams (); - - if (process_routes (this_nframes)) { + if (process_routes (this_nframes, session_needs_butler)) { fail_roll (nframes); return; } - commit_diskstreams (this_nframes, session_needs_butler); - nframes -= this_nframes; if (frames_moved < 0) { @@ -461,7 +407,7 @@ Session::reset_slave_state () average_slave_delta = 1800; delta_accumulator_cnt = 0; have_first_delta_accumulator = false; - slave_state = Stopped; + _slave_state = Stopped; } bool @@ -483,7 +429,6 @@ Session::follow_slave (nframes_t nframes) nframes64_t slave_transport_frame; nframes_t this_delta; int dir; - bool starting; if (!_slave->ok()) { stop_transport (); @@ -493,7 +438,10 @@ Session::follow_slave (nframes_t nframes) _slave->speed_and_position (slave_speed, slave_transport_frame); + DEBUG_TRACE (DEBUG::Slave, string_compose ("Slave position %1 speed %2\n", slave_transport_frame, slave_speed)); + if (!_slave->locked()) { + DEBUG_TRACE (DEBUG::Slave, "slave not locked\n"); goto noroll; } @@ -505,7 +453,7 @@ Session::follow_slave (nframes_t nframes) dir = -1; } - if ((starting = _slave->starting())) { + if (_slave->starting()) { slave_speed = 0.0f; } @@ -521,17 +469,23 @@ Session::follow_slave (nframes_t nframes) } else { - /* TC source is able to drift relative to us (slave) - so we need to keep track of the drift and adjust - our speed to remain locked. + /* if we are chasing and the average delta between us and the + master gets too big, we want to switch to silent + motion. so keep track of that here. */ - calculate_moving_average_of_slave_delta(dir, this_delta); + if (_slave_state == Running) { + calculate_moving_average_of_slave_delta(dir, this_delta); + } } - track_slave_state(slave_speed, slave_transport_frame, this_delta, starting); + track_slave_state (slave_speed, slave_transport_frame, this_delta); + + DEBUG_TRACE (DEBUG::Slave, string_compose ("slave state %1 @ %2 speed %3 cur delta %4 avg delta %5\n", + _slave_state, slave_transport_frame, slave_speed, this_delta, average_slave_delta)); + - if (slave_state == Running && !_slave->is_always_synced() && !config.get_timecode_source_is_synced()) { + if (_slave_state == Running && !_slave->is_always_synced() && !config.get_timecode_source_is_synced()) { if (_transport_speed != 0.0f) { @@ -541,69 +495,59 @@ Session::follow_slave (nframes_t nframes) float delta; - #ifdef USE_MOVING_AVERAGE_OF_SLAVE - if (average_slave_delta == 0) { - delta = this_delta; - delta *= dir; - } else { - delta = average_slave_delta; - delta *= average_dir; - } - #else + if (average_slave_delta == 0) { delta = this_delta; delta *= dir; - #endif - - float adjusted_speed = slave_speed + (delta / float(_current_frame_rate)); + } else { + delta = average_slave_delta; + delta *= average_dir; + } +#ifndef NDEBUG + if (slave_speed != 0.0) { + DEBUG_TRACE (DEBUG::Slave, string_compose ("delta = %1 speed = %2 ts = %3 M@%4 S@%5 avgdelta %6\n", + (int) (dir * this_delta), + slave_speed, + _transport_speed, + _transport_frame, + slave_transport_frame, + average_slave_delta)); + } +#endif + if (_slave->give_slave_full_control_over_transport_speed()) { - request_transport_speed(slave_speed); + set_transport_speed (slave_speed, false, false); + //std::cout << "set speed = " << slave_speed << "\n"; } else { - request_transport_speed(adjusted_speed); - #ifdef DEBUG_SLAVES - cerr << "adjust using " << delta - << " towards " << adjusted_speed - << " ratio = " << adjusted_speed / slave_speed - << " current = " << _transport_speed - << " slave @ " << slave_speed - << endl; - #endif + float adjusted_speed = slave_speed + (1.5 * (delta / float(_current_frame_rate))); + request_transport_speed (adjusted_speed); + DEBUG_TRACE (DEBUG::Slave, string_compose ("adjust using %1 towards %2 ratio %3 current %4 slave @ %5\n", + delta, adjusted_speed, adjusted_speed/slave_speed, _transport_speed, + slave_speed)); } - - if (abs(average_slave_delta) > (long) _slave->resolution()) { - cerr << "average slave delta greater than slave resolution, going to silent motion\n"; + +#if 1 + if ((nframes_t) abs(average_slave_delta) > _slave->resolution()) { + cerr << "average slave delta greater than slave resolution (" << _slave->resolution() << "), going to silent motion\n"; goto silent_motion; } +#endif } } - #ifdef DEBUG_SLAVES - if (slave_speed != 0.0) - cerr << "delta = " << (int) (dir * this_delta) - << " speed = " << slave_speed - << " ts = " << _transport_speed - << " M@ "<< slave_transport_frame << " S@ " << _transport_frame - << " avgdelta = " << average_slave_delta - << endl; - #endif - if (!starting && !non_realtime_work_pending()) { + if (_slave_state == Running && !non_realtime_work_pending()) { /* speed is set, we're locked, and good to go */ return true; } silent_motion: - #ifdef DEBUG_SLAVES - cerr << "reached silent_motion:" <requires_seekahead()) { - slave_wait_end = slave_transport_frame + _current_frame_rate; + slave_wait_end = slave_transport_frame + _slave->seekahead_distance (); + DEBUG_TRACE (DEBUG::Slave, string_compose ("slave stopped, but running, requires seekahead to %1\n", slave_wait_end)); + /* we can call locate() here because we are in process context */ locate (slave_wait_end, false, false); - slave_state = Waiting; - starting = true; + _slave_state = Waiting; } else { - slave_state = Running; + _slave_state = Running; Location* al = _locations.auto_loop_location(); @@ -672,23 +613,24 @@ Session::track_slave_state( break; case Waiting: - break; - default: break; - } - if (slave_state == Waiting) { + if (_slave_state == Waiting) { + + DEBUG_TRACE (DEBUG::Slave, string_compose ("slave waiting at %1\n", slave_transport_frame)); - #ifdef DEBUG_SLAVES - cerr << "waiting at " << slave_transport_frame << endl; - #endif if (slave_transport_frame >= slave_wait_end) { -#ifdef DEBUG_SLAVES - cerr << "\tstart at " << _transport_frame << endl; -#endif - slave_state = Running; + + DEBUG_TRACE (DEBUG::Slave, string_compose ("slave start at %1 vs %2\n", slave_transport_frame, _transport_frame)); + + _slave_state = Running; + + /* now perform a "micro-seek" within the disk buffers to realign ourselves + precisely with the master. + */ + bool ok = true; nframes_t frame_delta = slave_transport_frame - _transport_frame; @@ -719,11 +661,8 @@ Session::track_slave_state( } } - if (slave_state == Running && _transport_speed == 0.0f) { - - #ifdef DEBUG_SLAVES - cerr << "slave starts transport\n"; - #endif + if (_slave_state == Running && _transport_speed == 0.0f) { + DEBUG_TRACE (DEBUG::Slave, "slave starts transport\n"); start_transport (); } @@ -732,23 +671,16 @@ Session::track_slave_state( /* slave has stopped */ if (_transport_speed != 0.0f) { - - #ifdef DEBUG_SLAVES - cerr << "slave stops transport: " << slave_speed << " frame: " << slave_transport_frame - << " tf = " << _transport_frame << endl; - #endif - + DEBUG_TRACE (DEBUG::Slave, string_compose ("slave stops transport: %1 frame %2 tf %3\n", slave_speed, slave_transport_frame, _transport_frame)); stop_transport(); } if (slave_transport_frame != _transport_frame) { - #ifdef DEBUG_SLAVES - cerr << "slave stopped, move to " << slave_transport_frame << endl; - #endif + DEBUG_TRACE (DEBUG::Slave, string_compose ("slave stopped, move to %1\n", slave_transport_frame)); force_locate (slave_transport_frame, false); } - slave_state = Stopped; + _slave_state = Stopped; } } @@ -763,9 +695,7 @@ Session::follow_slave_silently (nframes_t nframes, float slave_speed) bool need_butler; - prepare_diskstreams (); - silent_process_routes (nframes); - commit_diskstreams (nframes, need_butler); + silent_process_routes (nframes, need_butler); if (need_butler) { _butler->summon (); @@ -843,8 +773,6 @@ Session::process_without_events (nframes_t nframes) click (_transport_frame, nframes); - prepare_diskstreams (); - if (_transport_speed == 1.0) { frames_moved = (long) nframes; } else { @@ -853,13 +781,11 @@ Session::process_without_events (nframes_t nframes) frames_moved = (long) interpolation.interpolate (0, nframes, 0, 0); } - if (process_routes (nframes)) { + if (process_routes (nframes, session_needs_butler)) { fail_roll (nframes); return; } - commit_diskstreams (nframes, session_needs_butler); - if (frames_moved < 0) { decrement_transport_position (-frames_moved); } else { @@ -880,7 +806,7 @@ Session::process_without_events (nframes_t nframes) void Session::process_audition (nframes_t nframes) { - Event* ev; + SessionEvent* ev; boost::shared_ptr r = routes.reader (); for (RouteList::iterator i = r->begin(); i != r->end(); ++i) { @@ -895,6 +821,12 @@ Session::process_audition (nframes_t nframes) _butler->summon (); } + /* if using a monitor section, run it because otherwise we don't hear anything */ + + if (auditioner->needs_monitor()) { + _monitor_out->passthru (_transport_frame, _transport_frame + nframes, nframes, false); + } + /* handle pending events */ while (pending_events.read (&ev, 1) == 1) { @@ -907,12 +839,12 @@ Session::process_audition (nframes_t nframes) */ while (!non_realtime_work_pending() && !immediate_events.empty()) { - Event *ev = immediate_events.front (); + SessionEvent *ev = immediate_events.front (); immediate_events.pop_front (); process_event (ev); } - if (!auditioner->active()) { + if (!auditioner->auditioning()) { /* auditioner no longer active, so go back to the normal process callback */ process_function = &Session::process_with_events; } @@ -964,3 +896,197 @@ Session::maybe_sync_start (nframes_t& nframes) return false; } +void +Session::queue_event (SessionEvent* ev) +{ + if (_state_of_the_state & Deletion) { + return; + } else if (_state_of_the_state & Loading) { + merge_event (ev); + } else { + pending_events.write (&ev, 1); + } +} + +void +Session::set_next_event () +{ + if (events.empty()) { + next_event = events.end(); + return; + } + + if (next_event == events.end()) { + next_event = events.begin(); + } + + if ((*next_event)->action_frame > _transport_frame) { + next_event = events.begin(); + } + + for (; next_event != events.end(); ++next_event) { + if ((*next_event)->action_frame >= _transport_frame) { + break; + } + } +} + +void +Session::process_event (SessionEvent* ev) +{ + bool remove = true; + bool del = true; + + /* if we're in the middle of a state change (i.e. waiting + for the butler thread to complete the non-realtime + part of the change), we'll just have to queue this + event for a time when the change is complete. + */ + + if (non_realtime_work_pending()) { + + /* except locates, which we have the capability to handle */ + + if (ev->type != SessionEvent::Locate) { + immediate_events.insert (immediate_events.end(), ev); + _remove_event (ev); + return; + } + } + + DEBUG_TRACE (DEBUG::SessionEvents, string_compose ("Processing event: %1 @ %2\n", enum_2_string (ev->type), _transport_frame)); + + switch (ev->type) { + case SessionEvent::SetLoop: + set_play_loop (ev->yes_or_no); + break; + + case SessionEvent::AutoLoop: + if (play_loop) { + start_locate (ev->target_frame, true, false, Config->get_seamless_loop()); + } + remove = false; + del = false; + break; + + case SessionEvent::Locate: + if (ev->yes_or_no) { + // cerr << "forced locate to " << ev->target_frame << endl; + locate (ev->target_frame, false, true, false); + } else { + // cerr << "soft locate to " << ev->target_frame << endl; + start_locate (ev->target_frame, false, true, false); + } + _send_timecode_update = true; + break; + + case SessionEvent::LocateRoll: + if (ev->yes_or_no) { + // cerr << "forced locate to+roll " << ev->target_frame << endl; + locate (ev->target_frame, true, true, false); + } else { + // cerr << "soft locate to+roll " << ev->target_frame << endl; + start_locate (ev->target_frame, true, true, false); + } + _send_timecode_update = true; + break; + + case SessionEvent::LocateRollLocate: + // locate is handled by ::request_roll_at_and_return() + _requested_return_frame = ev->target_frame; + request_locate (ev->target2_frame, true); + break; + + + case SessionEvent::SetTransportSpeed: + set_transport_speed (ev->speed, ev->yes_or_no, ev->second_yes_or_no); + break; + + case SessionEvent::PunchIn: + // cerr << "PunchIN at " << transport_frame() << endl; + if (config.get_punch_in() && record_status() == Enabled) { + enable_record (); + } + remove = false; + del = false; + break; + + case SessionEvent::PunchOut: + // cerr << "PunchOUT at " << transport_frame() << endl; + if (config.get_punch_out()) { + step_back_from_record (); + } + remove = false; + del = false; + break; + + case SessionEvent::StopOnce: + if (!non_realtime_work_pending()) { + stop_transport (ev->yes_or_no); + _clear_event_type (SessionEvent::StopOnce); + } + remove = false; + del = false; + break; + + case SessionEvent::RangeStop: + if (!non_realtime_work_pending()) { + stop_transport (ev->yes_or_no); + } + remove = false; + del = false; + break; + + case SessionEvent::RangeLocate: + start_locate (ev->target_frame, true, true, false); + remove = false; + del = false; + break; + + case SessionEvent::Overwrite: + overwrite_some_buffers (static_cast(ev->ptr)); + break; + + case SessionEvent::SetDiskstreamSpeed: + set_diskstream_speed (static_cast (ev->ptr), ev->speed); + break; + + case SessionEvent::SetSyncSource: + use_sync_source (ev->slave); + break; + + case SessionEvent::Audition: + set_audition (ev->region); + // drop reference to region + 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; + + case SessionEvent::RealTimeOperation: + process_rtop (ev); + del = false; // other side of RT request needs to clean up + break; + + default: + fatal << string_compose(_("Programming error: illegal event type in process_event (%1)"), ev->type) << endmsg; + /*NOTREACHED*/ + break; + }; + + if (remove) { + del = del && !_remove_event (ev); + } + + if (del) { + delete ev; + } +} +