X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fsession_process.cc;h=067a91da48f45449933c1960cdc3482fe7681e3e;hb=2b80aee20a01f70afe9997fd39c4ca8d19c8caf8;hp=834280de917c34bfea38918bb76cfff4ea30a8c6;hpb=14b0ca31bcb62e5b7e9e77634ef9cd2e8cf65800;p=ardour.git diff --git a/libs/ardour/session_process.cc b/libs/ardour/session_process.cc index 834280de91..067a91da48 100644 --- a/libs/ardour/session_process.cc +++ b/libs/ardour/session_process.cc @@ -25,22 +25,28 @@ #include "pbd/error.h" #include "pbd/enumwriter.h" -#include +#include -#include "ardour/ardour.h" -#include "ardour/audio_diskstream.h" #include "ardour/audioengine.h" #include "ardour/auditioner.h" #include "ardour/butler.h" +#include "ardour/cycle_timer.h" #include "ardour/debug.h" +#include "ardour/graph.h" +#include "ardour/port.h" +#include "ardour/process_thread.h" #include "ardour/session.h" #include "ardour/slave.h" -#include "ardour/timestamps.h" +#include "ardour/ticker.h" +#include "ardour/types.h" #include "midi++/manager.h" +#include "midi++/mmc.h" #include "i18n.h" +#include + using namespace ARDOUR; using namespace PBD; using namespace std; @@ -48,10 +54,11 @@ using namespace std; /** Called by the audio engine when there is work to be done with JACK. * @param nframes Number of frames to process. */ + void -Session::process (nframes_t nframes) +Session::process (pframes_t nframes) { - MIDI::Manager::instance()->cycle_start(nframes); + framepos_t transport_at_start = _transport_frame; _silent = false; @@ -66,64 +73,84 @@ Session::process (nframes_t nframes) } } + _engine.main_thread()->get_buffers (); + (this->*process_function) (nframes); - // the ticker is for sending time information like MidiClock - nframes_t transport_frames = transport_frame(); - BBT_Time transport_bbt; - bbt_time(transport_frames, transport_bbt); - Timecode::Time transport_timecode; - timecode_time(transport_frames, transport_timecode); - tick (transport_frames, transport_bbt, transport_timecode); /* EMIT SIGNAL */ + _engine.main_thread()->drop_buffers (); - SendFeedback (); /* EMIT SIGNAL */ + /* deliver MIDI clock. Note that we need to use the transport frame + * position at the start of process(), not the value at the end of + * it. We may already have ticked() because of a transport state + * change, for example. + */ + + try { + if (!_engine.freewheeling() && Config->get_send_midi_clock() && transport_speed() == 1.0f && midi_clock->has_midi_port()) { + midi_clock->tick (transport_at_start); + } + } catch (...) { + /* don't bother with a message */ + } - MIDI::Manager::instance()->cycle_end(); + SendFeedback (); /* EMIT SIGNAL */ } int -Session::fail_roll (nframes_t nframes) +Session::fail_roll (pframes_t nframes) { return no_roll (nframes); } int -Session::no_roll (nframes_t nframes) +Session::no_roll (pframes_t nframes) { - nframes_t end_frame = _transport_frame + nframes; // FIXME: varispeed + no_roll ?? + PT_TIMING_CHECK (4); + + framepos_t end_frame = _transport_frame + nframes; // FIXME: varispeed + no_roll ?? int ret = 0; - bool declick = get_transport_declick_required(); + int declick = get_transport_declick_required(); boost::shared_ptr r = routes.reader (); if (_click_io) { _click_io->silence (nframes); } - for (RouteList::iterator i = r->begin(); i != r->end(); ++i) { + ltc_tx_send_time_code_for_cycle (_transport_frame, end_frame, _target_transport_speed, _transport_speed, nframes); - if ((*i)->is_hidden()) { - continue; - } + 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); + } else { + PT_TIMING_CHECK (10); + for (RouteList::iterator i = r->begin(); i != r->end(); ++i) { - (*i)->set_pending_declick (declick); + if ((*i)->is_auditioner()) { + continue; + } - if ((*i)->no_roll (nframes, _transport_frame, end_frame, non_realtime_work_pending(), - actively_recording(), declick)) { - error << string_compose(_("Session: error in no roll for %1"), (*i)->name()) << endmsg; - ret = -1; - break; + (*i)->set_pending_declick (declick); + + if ((*i)->no_roll (nframes, _transport_frame, end_frame, non_realtime_work_pending())) { + error << string_compose(_("Session: error in no roll for %1"), (*i)->name()) << endmsg; + ret = -1; + break; + } } + PT_TIMING_CHECK (11); } + PT_TIMING_CHECK (5); return ret; } +/** @param need_butler to be set to true by this method if it needs the butler, + * otherwise it must be left alone. + */ int -Session::process_routes (nframes_t nframes, bool& need_butler) +Session::process_routes (pframes_t nframes, bool& need_butler) { - bool record_active; int declick = get_transport_declick_required(); - bool rec_monitors = get_rec_monitors_input(); boost::shared_ptr r = routes.reader (); if (transport_sub_state & StopPendingCapture) { @@ -131,57 +158,72 @@ Session::process_routes (nframes_t nframes, bool& need_butler) declick = -1; } - record_active = actively_recording(); // || (get_record_enabled() && get_punch_in()); + 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); + } else { - const nframes_t start_frame = _transport_frame; - const nframes_t end_frame = _transport_frame + (nframes_t)floor(nframes * _transport_speed); + for (RouteList::iterator i = r->begin(); i != r->end(); ++i) { - for (RouteList::iterator i = r->begin(); i != r->end(); ++i) { + int ret; - int ret; + if ((*i)->is_auditioner()) { + continue; + } - if ((*i)->is_hidden()) { - continue; - } + (*i)->set_pending_declick (declick); - (*i)->set_pending_declick (declick); + bool b = false; - if ((ret = (*i)->roll (nframes, start_frame, end_frame, declick, record_active, rec_monitors, need_butler)) < 0) { - stop_transport (); - return -1; + if ((ret = (*i)->roll (nframes, start_frame, end_frame, declick, b)) < 0) { + stop_transport (); + return -1; + } + + if (b) { + need_butler = true; + } } } return 0; } +/** @param need_butler to be set to true by this method if it needs the butler, + * otherwise it must be left alone. + */ int -Session::silent_process_routes (nframes_t nframes, bool& need_butler) +Session::silent_process_routes (pframes_t nframes, bool& need_butler) { - bool record_active = actively_recording(); - int declick = get_transport_declick_required(); - bool rec_monitors = get_rec_monitors_input(); boost::shared_ptr r = routes.reader (); - if (transport_sub_state & StopPendingCapture) { - /* force a declick out */ - declick = -1; - } + const framepos_t start_frame = _transport_frame; + const framepos_t end_frame = _transport_frame + lrintf(nframes * _transport_speed); - const nframes_t start_frame = _transport_frame; - const nframes_t end_frame = _transport_frame + lrintf(nframes * _transport_speed); + if (_process_graph) { + _process_graph->silent_process_routes (nframes, start_frame, end_frame, need_butler); + } else { + for (RouteList::iterator i = r->begin(); i != r->end(); ++i) { - for (RouteList::iterator i = r->begin(); i != r->end(); ++i) { + int ret; - int ret; + if ((*i)->is_auditioner()) { + continue; + } - if ((*i)->is_hidden()) { - continue; - } + bool b = false; - if ((ret = (*i)->silent_roll (nframes, start_frame, end_frame, record_active, rec_monitors, need_butler)) < 0) { - stop_transport (); - return -1; + if ((ret = (*i)->silent_roll (nframes, start_frame, end_frame, b)) < 0) { + stop_transport (); + return -1; + } + + if (b) { + need_butler = true; + } } } @@ -189,31 +231,26 @@ Session::silent_process_routes (nframes_t nframes, bool& need_butler) } void -Session::get_diskstream_statistics () +Session::get_track_statistics () { float pworst = 1.0f; float cworst = 1.0f; - boost::shared_ptr dsl = diskstreams.reader(); - for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) { + boost::shared_ptr rl = routes.reader(); + for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) { + + boost::shared_ptr tr = boost::dynamic_pointer_cast (*i); - if ((*i)->hidden()) { + if (!tr || tr->hidden()) { continue; } - pworst = min (pworst, (*i)->playback_buffer_load()); - cworst = min (cworst, (*i)->capture_buffer_load()); + pworst = min (pworst, tr->playback_buffer_load()); + cworst = min (cworst, tr->capture_buffer_load()); } - uint32_t pmin = g_atomic_int_get (&_playback_load); - uint32_t pminold = g_atomic_int_get (&_playback_load_min); - uint32_t cmin = g_atomic_int_get (&_capture_load); - uint32_t cminold = g_atomic_int_get (&_capture_load_min); - g_atomic_int_set (&_playback_load, (uint32_t) floor (pworst * 100.0f)); g_atomic_int_set (&_capture_load, (uint32_t) floor (cworst * 100.0f)); - g_atomic_int_set (&_playback_load_min, min (pmin, pminold)); - g_atomic_int_set (&_capture_load_min, min (cmin, cminold)); if (actively_recording()) { set_dirty(); @@ -222,14 +259,15 @@ Session::get_diskstream_statistics () /** Process callback used when the auditioner is not active */ void -Session::process_with_events (nframes_t nframes) +Session::process_with_events (pframes_t nframes) { - SessionEvent* ev; - nframes_t this_nframes; - nframes_t end_frame; + PT_TIMING_CHECK (3); + + SessionEvent* ev; + pframes_t this_nframes; + framepos_t end_frame; bool session_needs_butler = false; - nframes_t stop_limit; - long frames_moved; + framecnt_t frames_moved; /* make sure the auditioner is silent */ @@ -254,13 +292,42 @@ Session::process_with_events (nframes_t nframes) process_event (ev); } - /* Events caused a transport change, send an MTC Full Frame (Timecode) message. - * This is sent whether rolling or not, to give slaves an idea of ardour time - * on locates (and allow slow slaves to position and prepare for rolling) + /* Decide on what to do with quarter-frame MTC during this cycle */ + + bool const was_sending_qf_mtc = _send_qf_mtc; + double const tolerance = Config->get_mtc_qf_speed_tolerance() / 100.0; + + if (_transport_speed != 0) { + _send_qf_mtc = ( + Config->get_send_mtc () && + _transport_speed >= (1 - tolerance) && + _transport_speed <= (1 + tolerance) + ); + + if (_send_qf_mtc && !was_sending_qf_mtc) { + /* we will re-start quarter-frame MTC this cycle, so send a full update to set things up */ + _send_timecode_update = true; + } + + if (Config->get_send_mtc() && !_send_qf_mtc && _pframes_since_last_mtc > (frame_rate () / 4)) { + /* we're sending MTC, but we're not sending QF MTC at the moment, and it's been + a quarter of a second since we sent anything at all, so send a full MTC update + this cycle. + */ + _send_timecode_update = true; + } + + _pframes_since_last_mtc += nframes; + } + + /* Events caused a transport change (or we re-started sending + * MTC), so send an MTC Full Frame (Timecode) message. This + * is sent whether rolling or not, to give slaves an idea of + * ardour time on locates (and allow slow slaves to position + * and prepare for rolling) */ if (_send_timecode_update) { - send_full_time_code(nframes); - deliver_mmc (MIDI::MachineControl::cmdLocate, _transport_frame); + send_full_time_code (_transport_frame); } if (!process_can_proceed()) { @@ -274,14 +341,14 @@ Session::process_with_events (nframes_t nframes) } if (_transport_speed == 1.0) { - frames_moved = (long) nframes; + frames_moved = (framecnt_t) nframes; } else { - interpolation.set_target_speed (fabs(_target_transport_speed)); - interpolation.set_speed (fabs(_transport_speed)); - frames_moved = (long) interpolation.interpolate (0, nframes, 0, 0); + interpolation.set_target_speed (_target_transport_speed); + interpolation.set_speed (_transport_speed); + frames_moved = (framecnt_t) interpolation.interpolate (0, nframes, 0, 0); } - end_frame = _transport_frame + (nframes_t)frames_moved; + end_frame = _transport_frame + frames_moved; { SessionEvent* this_event; @@ -303,20 +370,11 @@ Session::process_with_events (nframes_t nframes) return; } - if (!_exporting) { - send_midi_time_code_for_cycle (nframes); + if (!_exporting && !timecode_transmission_suspended()) { + send_midi_time_code_for_cycle (_transport_frame, end_frame, nframes); } - if (actively_recording()) { - stop_limit = max_frames; - } else { - - if (Config->get_stop_at_session_end()) { - stop_limit = current_end_frame(); - } else { - stop_limit = max_frames; - } - } + framepos_t stop_limit = compute_stop_limit (); if (maybe_stop (stop_limit)) { no_roll (nframes); @@ -334,13 +392,13 @@ Session::process_with_events (nframes_t nframes) while (nframes) { this_nframes = nframes; /* real (jack) time relative */ - frames_moved = (long) floor (_transport_speed * nframes); /* transport relative */ + frames_moved = (framecnt_t) floor (_transport_speed * nframes); /* transport relative */ /* running an event, position transport precisely to its time */ if (this_event && this_event->action_frame <= end_frame && this_event->action_frame >= _transport_frame) { /* this isn't quite right for reverse play */ - frames_moved = (long) (this_event->action_frame - _transport_frame); - this_nframes = (nframes_t) abs( floor(frames_moved / _transport_speed) ); + frames_moved = (framecnt_t) (this_event->action_frame - _transport_frame); + this_nframes = abs (floor(frames_moved / _transport_speed)); } if (this_nframes) { @@ -352,6 +410,8 @@ Session::process_with_events (nframes_t nframes) return; } + get_track_statistics (); + nframes -= this_nframes; if (frames_moved < 0) { @@ -387,8 +447,7 @@ Session::process_with_events (nframes_t nframes) } /* this is necessary to handle the case of seamless looping */ - end_frame = _transport_frame + (nframes_t) floor (nframes * _transport_speed); - + end_frame = _transport_frame + floor (nframes * _transport_speed); } set_next_event (); @@ -422,11 +481,11 @@ Session::transport_locked () const } bool -Session::follow_slave (nframes_t nframes) +Session::follow_slave (pframes_t nframes) { double slave_speed; - nframes64_t slave_transport_frame; - nframes_t this_delta; + framepos_t slave_transport_frame; + framecnt_t this_delta; int dir; if (!_slave->ok()) { @@ -456,7 +515,9 @@ Session::follow_slave (nframes_t nframes) slave_speed = 0.0f; } - if (_slave->is_always_synced() || config.get_timecode_source_is_synced()) { + if (_slave->is_always_synced() || + (Config->get_timecode_source_is_synced() && (dynamic_cast(_slave)) != 0) + ) { /* if the TC source is synced, then we assume that its speed is binary: 0.0 or 1.0 @@ -482,9 +543,11 @@ Session::follow_slave (nframes_t nframes) 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() && (dynamic_cast(_slave)) != 0) + ) { if (_transport_speed != 0.0f) { @@ -509,11 +572,11 @@ Session::follow_slave (nframes_t nframes) slave_speed, _transport_speed, _transport_frame, - slave_transport_frame, + slave_transport_frame, average_slave_delta)); } #endif - + if (_slave->give_slave_full_control_over_transport_speed()) { set_transport_speed (slave_speed, false, false); //std::cout << "set speed = " << slave_speed << "\n"; @@ -524,9 +587,9 @@ Session::follow_slave (nframes_t nframes) delta, adjusted_speed, adjusted_speed/slave_speed, _transport_speed, slave_speed)); } - + #if 1 - if ((nframes_t) abs(average_slave_delta) > _slave->resolution()) { + if (!actively_recording() && (framecnt_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; } @@ -552,7 +615,7 @@ Session::follow_slave (nframes_t nframes) } void -Session::calculate_moving_average_of_slave_delta(int dir, nframes_t this_delta) +Session::calculate_moving_average_of_slave_delta (int dir, framecnt_t this_delta) { if (delta_accumulator_cnt >= delta_accumulator_size) { have_first_delta_accumulator = true; @@ -560,7 +623,7 @@ Session::calculate_moving_average_of_slave_delta(int dir, nframes_t this_delta) } if (delta_accumulator_cnt != 0 || this_delta < _current_frame_rate) { - delta_accumulator[delta_accumulator_cnt++] = long(dir) * long(this_delta); + delta_accumulator[delta_accumulator_cnt++] = (framecnt_t) dir * (framecnt_t) this_delta; } if (have_first_delta_accumulator) { @@ -568,7 +631,7 @@ Session::calculate_moving_average_of_slave_delta(int dir, nframes_t this_delta) for (int i = 0; i < delta_accumulator_size; ++i) { average_slave_delta += delta_accumulator[i]; } - average_slave_delta /= long(delta_accumulator_size); + average_slave_delta /= (int32_t) delta_accumulator_size; if (average_slave_delta < 0L) { average_dir = -1; average_slave_delta = abs(average_slave_delta); @@ -579,7 +642,7 @@ 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) +Session::track_slave_state (float slave_speed, framepos_t slave_transport_frame, framecnt_t /*this_delta*/) { if (slave_speed != 0.0f) { @@ -596,9 +659,12 @@ Session::track_slave_state (float slave_speed, nframes_t slave_transport_frame, } else { - _slave_state = Running; + DEBUG_TRACE (DEBUG::Slave, string_compose ("slave stopped -> running at %1\n", slave_transport_frame)); - Location* al = _locations.auto_loop_location(); + memset (delta_accumulator, 0, sizeof (int32_t) * delta_accumulator_size); + average_slave_delta = 0L; + + Location* al = _locations->auto_loop_location(); if (al && play_loop && (slave_transport_frame < al->start() || slave_transport_frame > al->end())) { // cancel looping @@ -606,8 +672,10 @@ Session::track_slave_state (float slave_speed, nframes_t slave_transport_frame, } if (slave_transport_frame != _transport_frame) { + DEBUG_TRACE (DEBUG::Slave, string_compose ("require locate to run. eng: %1 -> sl: %2\n", _transport_frame, slave_transport_frame)); locate (slave_transport_frame, false, false); } + _slave_state = Running; } break; @@ -632,20 +700,23 @@ Session::track_slave_state (float slave_speed, nframes_t slave_transport_frame, bool ok = true; - nframes_t frame_delta = slave_transport_frame - _transport_frame; + framecnt_t frame_delta = slave_transport_frame - _transport_frame; - boost::shared_ptr dsl = diskstreams.reader(); - - for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) { - if (!(*i)->can_internal_playback_seek (frame_delta)) { + boost::shared_ptr rl = routes.reader(); + for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) { + boost::shared_ptr tr = boost::dynamic_pointer_cast (*i); + if (tr && !tr->can_internal_playback_seek (frame_delta)) { ok = false; break; } } if (ok) { - for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) { - (*i)->internal_playback_seek (frame_delta); + for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) { + boost::shared_ptr tr = boost::dynamic_pointer_cast (*i); + if (tr) { + tr->internal_playback_seek (frame_delta); + } } _transport_frame += frame_delta; @@ -653,10 +724,6 @@ Session::track_slave_state (float slave_speed, nframes_t slave_transport_frame, cerr << "cannot micro-seek\n"; /* XXX what? */ } - - memset (delta_accumulator, 0, sizeof (long) * delta_accumulator_size); - average_slave_delta = 0L; - this_delta = 0; } } @@ -671,7 +738,7 @@ Session::track_slave_state (float slave_speed, nframes_t slave_transport_frame, if (_transport_speed != 0.0f) { DEBUG_TRACE (DEBUG::Slave, string_compose ("slave stops transport: %1 frame %2 tf %3\n", slave_speed, slave_transport_frame, _transport_frame)); - stop_transport(); + stop_transport (); } if (slave_transport_frame != _transport_frame) { @@ -679,12 +746,12 @@ Session::track_slave_state (float slave_speed, nframes_t slave_transport_frame, force_locate (slave_transport_frame, false); } - _slave_state = Stopped; + reset_slave_state(); } } void -Session::follow_slave_silently (nframes_t nframes, float slave_speed) +Session::follow_slave_silently (pframes_t nframes, float slave_speed) { if (slave_speed && _transport_speed) { @@ -696,6 +763,8 @@ Session::follow_slave_silently (nframes_t nframes, float slave_speed) silent_process_routes (nframes, need_butler); + get_track_statistics (); + if (need_butler) { _butler->summon (); } @@ -708,28 +777,16 @@ Session::follow_slave_silently (nframes_t nframes, float slave_speed) increment_transport_position (frames_moved); } - nframes_t stop_limit; - - if (actively_recording()) { - stop_limit = max_frames; - } else { - if (Config->get_stop_at_session_end()) { - stop_limit = current_end_frame(); - } else { - stop_limit = max_frames; - } - } - + framepos_t const stop_limit = compute_stop_limit (); maybe_stop (stop_limit); } } void -Session::process_without_events (nframes_t nframes) +Session::process_without_events (pframes_t nframes) { bool session_needs_butler = false; - nframes_t stop_limit; - long frames_moved; + framecnt_t frames_moved; if (!process_can_proceed()) { _silent = true; @@ -738,6 +795,7 @@ Session::process_without_events (nframes_t nframes) if (!_exporting && _slave) { if (!follow_slave (nframes)) { + ltc_tx_send_time_code_for_cycle (_transport_frame, _transport_frame, 0, 0 , nframes); return; } } @@ -747,20 +805,22 @@ Session::process_without_events (nframes_t nframes) return; } - if (!_exporting) { - send_midi_time_code_for_cycle (nframes); + if (_transport_speed == 1.0) { + frames_moved = (framecnt_t) nframes; + } else { + interpolation.set_target_speed (_target_transport_speed); + interpolation.set_speed (_transport_speed); + frames_moved = (framecnt_t) interpolation.interpolate (0, nframes, 0, 0); } - if (actively_recording()) { - stop_limit = max_frames; - } else { - if (Config->get_stop_at_session_end()) { - stop_limit = current_end_frame(); - } else { - stop_limit = max_frames; - } + if (!_exporting && !timecode_transmission_suspended()) { + send_midi_time_code_for_cycle (_transport_frame, _transport_frame + frames_moved, nframes); } + ltc_tx_send_time_code_for_cycle (_transport_frame, _transport_frame + frames_moved, _target_transport_speed, _transport_speed, nframes); + + framepos_t const stop_limit = compute_stop_limit (); + if (maybe_stop (stop_limit)) { fail_roll (nframes); return; @@ -772,19 +832,13 @@ Session::process_without_events (nframes_t nframes) click (_transport_frame, nframes); - if (_transport_speed == 1.0) { - frames_moved = (long) nframes; - } else { - interpolation.set_target_speed (fabs(_target_transport_speed)); - interpolation.set_speed (fabs(_transport_speed)); - frames_moved = (long) interpolation.interpolate (0, nframes, 0, 0); - } - if (process_routes (nframes, session_needs_butler)) { fail_roll (nframes); return; } + get_track_statistics (); + if (frames_moved < 0) { decrement_transport_position (-frames_moved); } else { @@ -803,13 +857,13 @@ Session::process_without_events (nframes_t nframes) * @param nframes number of frames to process. */ void -Session::process_audition (nframes_t nframes) +Session::process_audition (pframes_t nframes) { SessionEvent* ev; boost::shared_ptr r = routes.reader (); for (RouteList::iterator i = r->begin(); i != r->end(); ++i) { - if (!(*i)->is_hidden()) { + if (!(*i)->is_auditioner()) { (*i)->silence (nframes); } } @@ -820,12 +874,12 @@ Session::process_audition (nframes_t nframes) _butler->summon (); } - /* if using a monitor section, run it because otherwise we don't hear anything */ + /* if using a monitor section, run it because otherwise we don't hear anything */ + + if (auditioner->needs_monitor()) { + _monitor_out->monitor_run (_transport_frame, _transport_frame + nframes, nframes, false); + } - if (auditioner->needs_monitor()) { - _monitor_out->passthru (_transport_frame, _transport_frame + nframes, nframes, false); - } - /* handle pending events */ while (pending_events.read (&ev, 1) == 1) { @@ -850,9 +904,9 @@ Session::process_audition (nframes_t nframes) } bool -Session::maybe_sync_start (nframes_t& nframes) +Session::maybe_sync_start (pframes_t & nframes) { - nframes_t sync_offset; + pframes_t sync_offset; if (!waiting_for_sync_offset) { return false; @@ -867,7 +921,7 @@ Session::maybe_sync_start (nframes_t& nframes) no_roll (sync_offset); nframes -= sync_offset; - Port::increment_port_offset (sync_offset); + Port::increment_global_port_buffer_offset (sync_offset); waiting_for_sync_offset = false; if (nframes == 0) { @@ -962,18 +1016,32 @@ Session::process_event (SessionEvent* ev) case SessionEvent::AutoLoop: if (play_loop) { + /* roll after locate, do not flush, set "with loop" + true only if we are seamless looping + */ start_locate (ev->target_frame, true, false, Config->get_seamless_loop()); } remove = false; del = false; break; + case SessionEvent::AutoLoopDeclick: + if (play_loop) { + /* Request a declick fade-out and a fade-in; the fade-out will happen + at the end of the loop, and the fade-in at the start. + */ + transport_sub_state |= (PendingLoopDeclickOut | PendingLoopDeclickIn); + } + remove = false; + del = false; + break; + case SessionEvent::Locate: if (ev->yes_or_no) { - // cerr << "forced locate to " << ev->target_frame << endl; + /* args: do not roll after locate, do flush, not with loop */ locate (ev->target_frame, false, true, false); } else { - // cerr << "soft locate to " << ev->target_frame << endl; + /* args: do not roll after locate, do flush, not with loop */ start_locate (ev->target_frame, false, true, false); } _send_timecode_update = true; @@ -981,10 +1049,10 @@ Session::process_event (SessionEvent* ev) case SessionEvent::LocateRoll: if (ev->yes_or_no) { - // cerr << "forced locate to+roll " << ev->target_frame << endl; + /* args: roll after locate, do flush, not with loop */ locate (ev->target_frame, true, true, false); } else { - // cerr << "soft locate to+roll " << ev->target_frame << endl; + /* args: roll after locate, do flush, not with loop */ start_locate (ev->target_frame, true, true, false); } _send_timecode_update = true; @@ -998,7 +1066,7 @@ Session::process_event (SessionEvent* ev) case SessionEvent::SetTransportSpeed: - set_transport_speed (ev->speed, ev->yes_or_no, ev->second_yes_or_no); + set_transport_speed (ev->speed, ev->yes_or_no, ev->second_yes_or_no, ev->third_yes_or_no); break; case SessionEvent::PunchIn: @@ -1037,20 +1105,22 @@ Session::process_event (SessionEvent* ev) break; case SessionEvent::RangeLocate: + /* args: roll after locate, do flush, not with loop */ start_locate (ev->target_frame, true, true, false); remove = false; del = false; break; case SessionEvent::Overwrite: - overwrite_some_buffers (static_cast(ev->ptr)); + overwrite_some_buffers (static_cast(ev->ptr)); break; - case SessionEvent::SetDiskstreamSpeed: - set_diskstream_speed (static_cast (ev->ptr), ev->speed); + 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); break; @@ -1074,6 +1144,18 @@ Session::process_event (SessionEvent* ev) del = false; // other side of RT request needs to clean up break; + case SessionEvent::AdjustPlaybackBuffering: + schedule_playback_buffering_adjustment (); + break; + + case SessionEvent::AdjustCaptureBuffering: + schedule_capture_buffering_adjustment (); + break; + + case SessionEvent::SetTimecodeTransmission: + g_atomic_int_set (&_suspend_timecode_transmission, ev->yes_or_no ? 0 : 1); + break; + default: fatal << string_compose(_("Programming error: illegal event type in process_event (%1)"), ev->type) << endmsg; /*NOTREACHED*/ @@ -1089,3 +1171,31 @@ Session::process_event (SessionEvent* ev) } } +framepos_t +Session::compute_stop_limit () const +{ + if (!Config->get_stop_at_session_end ()) { + return max_framepos; + } + + if (_slave) { + 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()); + + if (actively_recording ()) { + /* permanently recording */ + return max_framepos; + } else if (punching_in && !punching_out) { + /* punching in but never out */ + return max_framepos; + } else if (punching_in && punching_out && _locations->auto_punch_location()->end() > current_end_frame()) { + /* punching in and punching out after session end */ + return max_framepos; + } + + return current_end_frame (); +}