X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fsession_process.cc;h=9baa0aea9e81dc6657bb08c8ed3e82b42f0426f9;hb=7d96960b162d25da87c388a3083775e8770bba56;hp=e277a2dbccf6f17e193d6bd3cde5a07d7c5851fe;hpb=6a847f553c9e274c8b1a464590e41ae78018af45;p=ardour.git diff --git a/libs/ardour/session_process.cc b/libs/ardour/session_process.cc index e277a2dbcc..9baa0aea9e 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 @@ -50,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; @@ -274,7 +271,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; @@ -299,7 +296,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); } @@ -334,7 +331,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()) { @@ -461,7 +458,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 +480,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,9 +489,10 @@ Session::follow_slave (nframes_t nframes) _slave->speed_and_position (slave_speed, slave_transport_frame); - DEBUG_TRACE (DEBUG::Slave, string_compose ("Slave @ %1 speed %2\n", 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; } @@ -507,7 +504,7 @@ Session::follow_slave (nframes_t nframes) dir = -1; } - if ((starting = _slave->starting())) { + if (_slave->starting()) { slave_speed = 0.0f; } @@ -523,17 +520,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) { @@ -543,50 +546,48 @@ 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); + 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 } } -#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, - slave_transport_frame, - _transport_frame, - average_slave_delta)); - } -#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; } @@ -630,27 +631,24 @@ Session::calculate_moving_average_of_slave_delta(int dir, nframes_t this_delta) } void -Session::track_slave_state( - float slave_speed, - nframes_t slave_transport_frame, - nframes_t this_delta, - bool starting) +Session::track_slave_state (float slave_speed, nframes_t slave_transport_frame, nframes_t this_delta) { if (slave_speed != 0.0f) { /* slave is running */ - switch (slave_state) { + switch (_slave_state) { case Stopped: if (_slave->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(); @@ -666,23 +664,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; @@ -713,7 +712,7 @@ Session::track_slave_state( } } - if (slave_state == Running && _transport_speed == 0.0f) { + if (_slave_state == Running && _transport_speed == 0.0f) { DEBUG_TRACE (DEBUG::Slave, "slave starts transport\n"); start_transport (); } @@ -732,7 +731,7 @@ Session::track_slave_state( force_locate (slave_transport_frame, false); } - slave_state = Stopped; + _slave_state = Stopped; } } @@ -864,7 +863,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) { @@ -891,7 +890,7 @@ 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); } @@ -948,3 +947,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; + } +} +