X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fsession_process.cc;h=1674cd9a7a367d375472f3891ee10f07418708d2;hb=4e5423b3487771220cdca4c2b1a79c4d74b6afa5;hp=fa5d16632da170cf574c04fc2ab5f03971c49f9e;hpb=2a192dbbd674b859d448e0c903359dde6e9713a4;p=ardour.git diff --git a/libs/ardour/session_process.cc b/libs/ardour/session_process.cc index fa5d16632d..1674cd9a7a 100644 --- a/libs/ardour/session_process.cc +++ b/libs/ardour/session_process.cc @@ -53,13 +53,13 @@ using namespace PBD; using namespace std; /** Called by the audio engine when there is work to be done with JACK. - * @param nframes Number of frames to process. + * @param nframes Number of samples to process. */ void Session::process (pframes_t nframes) { - framepos_t transport_at_start = _transport_frame; + samplepos_t transport_at_start = _transport_sample; _silent = false; @@ -103,7 +103,7 @@ Session::process (pframes_t nframes) _engine.main_thread()->drop_buffers (); - /* deliver MIDI clock. Note that we need to use the transport frame + /* deliver MIDI clock. Note that we need to use the transport sample * 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. @@ -134,7 +134,7 @@ Session::no_roll (pframes_t nframes) { PT_TIMING_CHECK (4); - framepos_t end_frame = _transport_frame + nframes; // FIXME: varispeed + no_roll ?? + samplepos_t end_sample = _transport_sample + nframes; // FIXME: varispeed + no_roll ?? int ret = 0; int declick = (config.get_use_transport_fades() ? get_transport_declick_required() : false); boost::shared_ptr r = routes.reader (); @@ -143,16 +143,16 @@ Session::no_roll (pframes_t nframes) _click_io->silence (nframes); } - ltc_tx_send_time_code_for_cycle (_transport_frame, end_frame, _target_transport_speed, _transport_speed, nframes); + ltc_tx_send_time_code_for_cycle (_transport_sample, end_sample, _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); + (*i)->automation_run (_transport_sample, 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); + _process_graph->routes_no_roll( nframes, _transport_sample, end_sample, non_realtime_work_pending(), declick); } else { PT_TIMING_CHECK (10); for (RouteList::iterator i = r->begin(); i != r->end(); ++i) { @@ -163,7 +163,7 @@ Session::no_roll (pframes_t nframes) (*i)->set_pending_declick (declick); - if ((*i)->no_roll (nframes, _transport_frame, end_frame, non_realtime_work_pending())) { + if ((*i)->no_roll (nframes, _transport_sample, end_sample, non_realtime_work_pending())) { error << string_compose(_("Session: error in no roll for %1"), (*i)->name()) << endmsg; ret = -1; break; @@ -185,19 +185,19 @@ Session::process_routes (pframes_t nframes, bool& need_butler) 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); + const samplepos_t start_sample = _transport_sample; + const samplepos_t end_sample = _transport_sample + 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); + (*i)->automation_run (start_sample, nframes); } _global_locate_pending = locate_pending (); 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) { + if (_process_graph->process_routes (nframes, start_sample, end_sample, declick, need_butler) < 0) { stop_transport (); return -1; } @@ -215,7 +215,7 @@ Session::process_routes (pframes_t nframes, bool& need_butler) bool b = false; - if ((ret = (*i)->roll (nframes, start_frame, end_frame, declick, b)) < 0) { + if ((ret = (*i)->roll (nframes, start_sample, end_sample, declick, b)) < 0) { stop_transport (); return -1; } @@ -265,9 +265,9 @@ Session::process_with_events (pframes_t nframes) SessionEvent* ev; pframes_t this_nframes; - framepos_t end_frame; + samplepos_t end_sample; bool session_needs_butler = false; - framecnt_t frames_moved; + samplecnt_t samples_moved; /* make sure the auditioner is silent */ @@ -298,10 +298,10 @@ Session::process_with_events (pframes_t nframes) } if (_count_in_samples > 0) { - framecnt_t ns = std::min ((framecnt_t)nframes, _count_in_samples); + samplecnt_t ns = std::min ((samplecnt_t)nframes, _count_in_samples); no_roll (ns); - run_click (_transport_frame - _count_in_samples, ns); + run_click (_transport_sample - _count_in_samples, ns); _count_in_samples -= ns; nframes -= ns; @@ -312,7 +312,7 @@ Session::process_with_events (pframes_t nframes) Events::iterator the_next_one = next_event; ++the_next_one; - while (this_event && this_event->action_frame == _transport_frame) { + while (this_event && this_event->action_sample == _transport_sample) { process_event (this_event); if (the_next_one == events.end()) { this_event = 0; @@ -350,7 +350,7 @@ Session::process_with_events (pframes_t nframes) _send_timecode_update = true; } - if (Config->get_send_mtc() && !_send_qf_mtc && _pframes_since_last_mtc > (frame_rate () / 4)) { + if (Config->get_send_mtc() && !_send_qf_mtc && _pframes_since_last_mtc > (sample_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. @@ -368,7 +368,7 @@ Session::process_with_events (pframes_t nframes) * and prepare for rolling) */ if (_send_timecode_update) { - send_full_time_code (_transport_frame, nframes); + send_full_time_code (_transport_sample, nframes); } if (!process_can_proceed()) { @@ -388,19 +388,15 @@ Session::process_with_events (pframes_t nframes) } } - if (locate_pending()) { - frames_moved = 0; + if (_transport_speed == 1.0) { + samples_moved = (samplecnt_t) nframes; } else { - 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); - } + interpolation.set_target_speed (_target_transport_speed); + interpolation.set_speed (_transport_speed); + samples_moved = (samplecnt_t) interpolation.interpolate (0, nframes, 0, 0); } - end_frame = _transport_frame + frames_moved; + end_sample = _transport_sample + samples_moved; { SessionEvent* this_event; @@ -423,12 +419,12 @@ Session::process_with_events (pframes_t nframes) } if (!_exporting && !timecode_transmission_suspended()) { - send_midi_time_code_for_cycle (_transport_frame, end_frame, nframes); + send_midi_time_code_for_cycle (_transport_sample, end_sample, nframes); } - ltc_tx_send_time_code_for_cycle (_transport_frame, end_frame, _target_transport_speed, _transport_speed, nframes); + ltc_tx_send_time_code_for_cycle (_transport_sample, end_sample, _target_transport_speed, _transport_speed, nframes); - framepos_t stop_limit = compute_stop_limit (); + samplepos_t stop_limit = compute_stop_limit (); if (maybe_stop (stop_limit)) { no_roll (nframes); @@ -446,24 +442,20 @@ Session::process_with_events (pframes_t nframes) while (nframes) { this_nframes = nframes; /* real (jack) time relative */ - if (locate_pending()) { - frames_moved = 0; - } else { - frames_moved = (framecnt_t) floor (_transport_speed * nframes); /* transport relative */ - } + samples_moved = (samplecnt_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) { + if (this_event && this_event->action_sample <= end_sample && this_event->action_sample >= _transport_sample) { /* this isn't quite right for reverse play */ - frames_moved = (framecnt_t) (this_event->action_frame - _transport_frame); - this_nframes = abs (floor(frames_moved / _transport_speed)); + samples_moved = (samplecnt_t) (this_event->action_sample - _transport_sample); + this_nframes = abs (floor(samples_moved / _transport_speed)); } try_run_lua (this_nframes); if (this_nframes) { - click (_transport_frame, this_nframes); + click (_transport_sample, this_nframes); if (process_routes (this_nframes, session_needs_butler)) { fail_roll (nframes); @@ -474,10 +466,10 @@ Session::process_with_events (pframes_t nframes) nframes -= this_nframes; - if (frames_moved < 0) { - decrement_transport_position (-frames_moved); - } else if (frames_moved) { - increment_transport_position (frames_moved); + if (samples_moved < 0) { + decrement_transport_position (-samples_moved); + } else if (samples_moved) { + increment_transport_position (samples_moved); } maybe_stop (stop_limit); @@ -490,7 +482,7 @@ Session::process_with_events (pframes_t nframes) /* now handle this event and all others scheduled for the same time */ - while (this_event && this_event->action_frame == _transport_frame) { + while (this_event && this_event->action_sample == _transport_sample) { process_event (this_event); if (the_next_one == events.end()) { @@ -509,7 +501,7 @@ Session::process_with_events (pframes_t nframes) } /* this is necessary to handle the case of seamless looping */ - end_frame = _transport_frame + floor (nframes * _transport_speed); + end_sample = _transport_sample + floor (nframes * _transport_speed); } set_next_event (); @@ -529,6 +521,7 @@ Session::reset_slave_state () delta_accumulator_cnt = 0; have_first_delta_accumulator = false; _slave_state = Stopped; + DiskReader::set_no_disk_output (false); } bool @@ -547,8 +540,8 @@ bool Session::follow_slave (pframes_t nframes) { double slave_speed; - framepos_t slave_transport_frame; - framecnt_t this_delta; + samplepos_t slave_transport_sample; + samplecnt_t this_delta; int dir; if (!_slave->ok()) { @@ -557,20 +550,20 @@ Session::follow_slave (pframes_t nframes) goto noroll; } - _slave->speed_and_position (slave_speed, slave_transport_frame); + _slave->speed_and_position (slave_speed, slave_transport_sample); - DEBUG_TRACE (DEBUG::Slave, string_compose ("Slave position %1 speed %2\n", slave_transport_frame, slave_speed)); + DEBUG_TRACE (DEBUG::Slave, string_compose ("Slave position %1 speed %2\n", slave_transport_sample, slave_speed)); if (!_slave->locked()) { DEBUG_TRACE (DEBUG::Slave, "slave not locked\n"); goto noroll; } - if (slave_transport_frame > _transport_frame) { - this_delta = slave_transport_frame - _transport_frame; + if (slave_transport_sample > _transport_sample) { + this_delta = slave_transport_sample - _transport_sample; dir = 1; } else { - this_delta = _transport_frame - slave_transport_frame; + this_delta = _transport_sample - slave_transport_sample; dir = -1; } @@ -602,10 +595,10 @@ Session::follow_slave (pframes_t nframes) } } - track_slave_state (slave_speed, slave_transport_frame, this_delta); + track_slave_state (slave_speed, slave_transport_sample, 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)); + _slave_state, slave_transport_sample, slave_speed, this_delta, average_slave_delta)); if (_slave_state == Running && !_slave->is_always_synced() && !(Config->get_timecode_source_is_synced() && (dynamic_cast(_slave)) != 0)) { @@ -634,8 +627,8 @@ Session::follow_slave (pframes_t nframes) (int) (dir * this_delta), slave_speed, _transport_speed, - _transport_frame, - slave_transport_frame, + _transport_sample, + slave_transport_sample, average_slave_delta)); } #endif @@ -644,22 +637,22 @@ Session::follow_slave (pframes_t nframes) set_transport_speed (slave_speed, 0, false, false); //std::cout << "set speed = " << slave_speed << "\n"; } else { - float adjusted_speed = slave_speed + (1.5 * (delta / float(_current_frame_rate))); + float adjusted_speed = slave_speed + (1.5 * (delta / float(_current_sample_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 (!actively_recording() && (framecnt_t) average_slave_delta > _slave->resolution()) { - DEBUG_TRACE (DEBUG::Slave, string_compose ("average slave delta %1 greater than slave resolution %2 => silent motion\n", average_slave_delta, _slave->resolution())); + if (!actively_recording() && (samplecnt_t) average_slave_delta > _slave->resolution()) { + DEBUG_TRACE (DEBUG::Slave, string_compose ("average slave delta %1 greater than slave resolution %2 => no disk output\n", average_slave_delta, _slave->resolution())); /* run routes as normal, but no disk output */ DiskReader::set_no_disk_output (true); return true; } if (!have_first_delta_accumulator) { - DEBUG_TRACE (DEBUG::Slave, "waiting for first slave delta accumulator to be ready\n"); + DEBUG_TRACE (DEBUG::Slave, "waiting for first slave delta accumulator to be ready, no disk output\n"); /* run routes as normal, but no disk output */ DiskReader::set_no_disk_output (true); return true; @@ -669,6 +662,7 @@ Session::follow_slave (pframes_t nframes) if (!have_first_delta_accumulator) { + DEBUG_TRACE (DEBUG::Slave, "still waiting to compute slave delta, no disk output\n"); DiskReader::set_no_disk_output (true); } else { DiskReader::set_no_disk_output (false); @@ -687,15 +681,15 @@ Session::follow_slave (pframes_t nframes) } void -Session::calculate_moving_average_of_slave_delta (int dir, framecnt_t this_delta) +Session::calculate_moving_average_of_slave_delta (int dir, samplecnt_t this_delta) { if (delta_accumulator_cnt >= delta_accumulator_size) { have_first_delta_accumulator = true; delta_accumulator_cnt = 0; } - if (delta_accumulator_cnt != 0 || this_delta < _current_frame_rate) { - delta_accumulator[delta_accumulator_cnt++] = (framecnt_t) dir * (framecnt_t) this_delta; + if (delta_accumulator_cnt != 0 || this_delta < _current_sample_rate) { + delta_accumulator[delta_accumulator_cnt++] = (samplecnt_t) dir * (samplecnt_t) this_delta; } if (have_first_delta_accumulator) { @@ -714,7 +708,7 @@ Session::calculate_moving_average_of_slave_delta (int dir, framecnt_t this_delta } void -Session::track_slave_state (float slave_speed, framepos_t slave_transport_frame, framecnt_t /*this_delta*/) +Session::track_slave_state (float slave_speed, samplepos_t slave_transport_sample, samplecnt_t /*this_delta*/) { if (slave_speed != 0.0f) { @@ -723,7 +717,7 @@ Session::track_slave_state (float slave_speed, framepos_t slave_transport_frame, switch (_slave_state) { case Stopped: if (_slave->requires_seekahead()) { - slave_wait_end = slave_transport_frame + _slave->seekahead_distance (); + slave_wait_end = slave_transport_sample + _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); @@ -731,21 +725,21 @@ Session::track_slave_state (float slave_speed, framepos_t slave_transport_frame, } else { - DEBUG_TRACE (DEBUG::Slave, string_compose ("slave stopped -> running at %1\n", slave_transport_frame)); + DEBUG_TRACE (DEBUG::Slave, string_compose ("slave stopped -> running at %1\n", slave_transport_sample)); 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())) { + if (al && play_loop && (slave_transport_sample < al->start() || slave_transport_sample > al->end())) { // cancel looping request_play_loop(false); } - 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); + if (slave_transport_sample != _transport_sample) { + DEBUG_TRACE (DEBUG::Slave, string_compose ("require locate to run. eng: %1 -> sl: %2\n", _transport_sample, slave_transport_sample)); + locate (slave_transport_sample, false, false); } _slave_state = Running; } @@ -758,11 +752,11 @@ Session::track_slave_state (float slave_speed, framepos_t slave_transport_frame, if (_slave_state == Waiting) { - DEBUG_TRACE (DEBUG::Slave, string_compose ("slave waiting at %1\n", slave_transport_frame)); + DEBUG_TRACE (DEBUG::Slave, string_compose ("slave waiting at %1\n", slave_transport_sample)); - if (slave_transport_frame >= slave_wait_end) { + if (slave_transport_sample >= slave_wait_end) { - DEBUG_TRACE (DEBUG::Slave, string_compose ("slave start at %1 vs %2\n", slave_transport_frame, _transport_frame)); + DEBUG_TRACE (DEBUG::Slave, string_compose ("slave start at %1 vs %2\n", slave_transport_sample, _transport_sample)); _slave_state = Running; @@ -772,12 +766,12 @@ Session::track_slave_state (float slave_speed, framepos_t slave_transport_frame, bool ok = true; - framecnt_t frame_delta = slave_transport_frame - _transport_frame; + samplecnt_t sample_delta = slave_transport_sample - _transport_sample; 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)) { + if (tr && !tr->can_internal_playback_seek (sample_delta)) { ok = false; break; } @@ -787,10 +781,10 @@ Session::track_slave_state (float slave_speed, framepos_t slave_transport_frame, 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); + tr->internal_playback_seek (sample_delta); } } - _transport_frame += frame_delta; + _transport_sample += sample_delta; } else { cerr << "cannot micro-seek\n"; @@ -809,13 +803,13 @@ Session::track_slave_state (float slave_speed, framepos_t slave_transport_frame, /* slave has stopped */ 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)); + DEBUG_TRACE (DEBUG::Slave, string_compose ("slave stops transport: %1 sample %2 tf %3\n", slave_speed, slave_transport_sample, _transport_sample)); stop_transport (); } - if (slave_transport_frame != _transport_frame) { - DEBUG_TRACE (DEBUG::Slave, string_compose ("slave stopped, move to %1\n", slave_transport_frame)); - force_locate (slave_transport_frame, false); + if (slave_transport_sample != _transport_sample) { + DEBUG_TRACE (DEBUG::Slave, string_compose ("slave stopped, move to %1\n", slave_transport_sample)); + force_locate (slave_transport_sample, false); } reset_slave_state(); @@ -826,7 +820,7 @@ void Session::process_without_events (pframes_t nframes) { bool session_needs_butler = false; - framecnt_t frames_moved; + samplecnt_t samples_moved; if (!process_can_proceed()) { _silent = true; @@ -835,7 +829,7 @@ Session::process_without_events (pframes_t nframes) if (!_exporting && _slave) { if (!follow_slave (nframes)) { - ltc_tx_send_time_code_for_cycle (_transport_frame, _transport_frame, 0, 0 , nframes); + ltc_tx_send_time_code_for_cycle (_transport_sample, _transport_sample, 0, 0 , nframes); return; } } @@ -845,25 +839,21 @@ Session::process_without_events (pframes_t nframes) return; } - if (locate_pending()) { - frames_moved = 0; + if (_transport_speed == 1.0) { + samples_moved = (samplecnt_t) nframes; } else { - 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); - } + interpolation.set_target_speed (_target_transport_speed); + interpolation.set_speed (_transport_speed); + samples_moved = (samplecnt_t) interpolation.interpolate (0, nframes, 0, 0); } if (!_exporting && !timecode_transmission_suspended()) { - send_midi_time_code_for_cycle (_transport_frame, _transport_frame + frames_moved, nframes); + send_midi_time_code_for_cycle (_transport_sample, _transport_sample + samples_moved, nframes); } - ltc_tx_send_time_code_for_cycle (_transport_frame, _transport_frame + frames_moved, _target_transport_speed, _transport_speed, nframes); + ltc_tx_send_time_code_for_cycle (_transport_sample, _transport_sample + samples_moved, _target_transport_speed, _transport_speed, nframes); - framepos_t const stop_limit = compute_stop_limit (); + samplepos_t const stop_limit = compute_stop_limit (); if (maybe_stop (stop_limit)) { no_roll (nframes); @@ -874,7 +864,7 @@ Session::process_without_events (pframes_t nframes) return; } - click (_transport_frame, nframes); + click (_transport_sample, nframes); if (process_routes (nframes, session_needs_butler)) { fail_roll (nframes); @@ -883,10 +873,10 @@ Session::process_without_events (pframes_t nframes) get_track_statistics (); - if (frames_moved < 0) { - decrement_transport_position (-frames_moved); - } else if (frames_moved) { - increment_transport_position (frames_moved); + if (samples_moved < 0) { + decrement_transport_position (-samples_moved); + } else if (samples_moved) { + increment_transport_position (samples_moved); } maybe_stop (stop_limit); @@ -899,7 +889,7 @@ Session::process_without_events (pframes_t nframes) } /** Process callback used when the auditioner is active. - * @param nframes number of frames to process. + * @param nframes number of samples to process. */ void Session::process_audition (pframes_t nframes) @@ -923,7 +913,7 @@ Session::process_audition (pframes_t nframes) /* if using a monitor section, run it because otherwise we don't hear anything */ if (_monitor_out && auditioner->needs_monitor()) { - _monitor_out->monitor_run (_transport_frame, _transport_frame + nframes, nframes, false); + _monitor_out->monitor_run (_transport_sample, _transport_sample + nframes, nframes, false); } /* handle pending events */ @@ -1020,12 +1010,12 @@ Session::set_next_event () next_event = events.begin(); } - if ((*next_event)->action_frame > _transport_frame) { + if ((*next_event)->action_sample > _transport_sample) { next_event = events.begin(); } for (; next_event != events.end(); ++next_event) { - if ((*next_event)->action_frame >= _transport_frame) { + if ((*next_event)->action_sample >= _transport_sample) { break; } } @@ -1054,7 +1044,7 @@ Session::process_event (SessionEvent* ev) } } - DEBUG_TRACE (DEBUG::SessionEvents, string_compose ("Processing event: %1 @ %2\n", enum_2_string (ev->type), _transport_frame)); + DEBUG_TRACE (DEBUG::SessionEvents, string_compose ("Processing event: %1 @ %2\n", enum_2_string (ev->type), _transport_sample)); switch (ev->type) { case SessionEvent::SetLoop: @@ -1066,7 +1056,7 @@ Session::process_event (SessionEvent* ev) /* 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()); + start_locate (ev->target_sample, true, false, Config->get_seamless_loop()); } remove = false; del = false; @@ -1084,12 +1074,12 @@ Session::process_event (SessionEvent* ev) break; case SessionEvent::Locate: - if (ev->yes_or_no) { + if (ev->yes_or_no) { /* force locate */ /* args: do not roll after locate, do flush, not with loop */ - locate (ev->target_frame, false, true, false); + locate (ev->target_sample, false, true, false); } else { /* args: do not roll after locate, do flush, not with loop */ - start_locate (ev->target_frame, false, true, false); + start_locate (ev->target_sample, false, true, false); } _send_timecode_update = true; break; @@ -1097,17 +1087,17 @@ Session::process_event (SessionEvent* ev) case SessionEvent::LocateRoll: if (ev->yes_or_no) { /* args: roll after locate, do flush, not with loop */ - locate (ev->target_frame, true, true, false); + locate (ev->target_sample, true, true, false); } else { /* args: roll after locate, do flush, not with loop */ - start_locate (ev->target_frame, true, true, false); + start_locate (ev->target_sample, true, true, false); } _send_timecode_update = true; break; case SessionEvent::Skip: if (Config->get_skip_playback()) { - start_locate (ev->target_frame, true, true, false); + start_locate (ev->target_sample, true, true, false); _send_timecode_update = true; } remove = false; @@ -1116,17 +1106,17 @@ Session::process_event (SessionEvent* ev) case SessionEvent::LocateRollLocate: // locate is handled by ::request_roll_at_and_return() - _requested_return_frame = ev->target_frame; - request_locate (ev->target2_frame, true); + _requested_return_sample = ev->target_sample; + request_locate (ev->target2_sample, true); break; case SessionEvent::SetTransportSpeed: - set_transport_speed (ev->speed, ev->target_frame, ev->yes_or_no, ev->second_yes_or_no, ev->third_yes_or_no); + set_transport_speed (ev->speed, ev->target_sample, ev->yes_or_no, ev->second_yes_or_no, ev->third_yes_or_no); break; case SessionEvent::PunchIn: - // cerr << "PunchIN at " << transport_frame() << endl; + // cerr << "PunchIN at " << transport_sample() << endl; if (config.get_punch_in() && record_status() == Enabled && !preroll_record_punch_enabled()) { enable_record (); } @@ -1135,7 +1125,7 @@ Session::process_event (SessionEvent* ev) break; case SessionEvent::PunchOut: - // cerr << "PunchOUT at " << transport_frame() << endl; + // cerr << "PunchOUT at " << transport_sample() << endl; if (config.get_punch_out() && !preroll_record_punch_enabled()) { step_back_from_record (); } @@ -1170,7 +1160,7 @@ Session::process_event (SessionEvent* ev) case SessionEvent::RangeLocate: /* args: roll after locate, do flush, not with loop */ - start_locate (ev->target_frame, true, true, false); + start_locate (ev->target_sample, true, true, false); remove = false; del = false; break; @@ -1230,19 +1220,19 @@ Session::process_event (SessionEvent* ev) } } -framepos_t +samplepos_t Session::compute_stop_limit () const { if (!Config->get_stop_at_session_end ()) { - return max_framepos; + return max_samplepos; } if (_slave) { - return max_framepos; + return max_samplepos; } if (preroll_record_punch_enabled ()) { - return max_framepos; + return max_samplepos; } bool const punching_in = (config.get_punch_in () && _locations->auto_punch_location()); @@ -1250,16 +1240,16 @@ Session::compute_stop_limit () const if (actively_recording ()) { /* permanently recording */ - return max_framepos; + return max_samplepos; } 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()) { + return max_samplepos; + } else if (punching_in && punching_out && _locations->auto_punch_location()->end() > current_end_sample()) { /* punching in and punching out after session end */ - return max_framepos; + return max_samplepos; } - return current_end_frame (); + return current_end_sample (); }