X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fsession_process.cc;h=abe802548ad6e55846b2085f02f18c18a5a2ba87;hb=22dc575e4cbc35a5d486d6f448332fb721865d57;hp=bbd35a9055d799515c55a8554f59e25f204fcc35;hpb=74dd5bd7060b337964d5ea5a3d419c26a62c10a6;p=ardour.git diff --git a/libs/ardour/session_process.cc b/libs/ardour/session_process.cc index bbd35a9055..abe802548a 100644 --- a/libs/ardour/session_process.cc +++ b/libs/ardour/session_process.cc @@ -15,7 +15,6 @@ along with this program; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. - $Id$ */ #include @@ -23,15 +22,14 @@ #include #include -#include - #include -#include -#include + +#include #include #include -#include +#include +#include #include #include #include @@ -43,16 +41,19 @@ #include "i18n.h" using namespace ARDOUR; -//using namespace sigc; +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. + */ void -Session::process (jack_nframes_t nframes) +Session::process (nframes_t nframes) { - cerr << "CYCLE START " << _transport_frame << "-------------------" << endl; - MIDI::Manager::instance()->cycle_start(nframes); + _silent = false; + if (synced_to_jack() && waiting_to_start) { if ( _engine.transport_state() == AudioEngine::TransportRolling) { actually_start_transport (); @@ -60,7 +61,7 @@ Session::process (jack_nframes_t nframes) } if (non_realtime_work_pending()) { - if (atomic_read (&butler_should_do_transport_work) == 0) { + if (!transport_work_requested ()) { post_transport (); } } @@ -68,45 +69,41 @@ Session::process (jack_nframes_t nframes) (this->*process_function) (nframes); MIDI::Manager::instance()->cycle_end(); - - cerr << "CYCLE END " << _transport_frame << "-----------------------" << endl; + + SendFeedback (); /* EMIT SIGNAL */ } void Session::prepare_diskstreams () { - for (DiskStreamList::iterator i = diskstreams.begin(); i != diskstreams.end(); ++i) { + boost::shared_ptr dsl = diskstreams.reader(); + for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) { (*i)->prepare (); } } int -Session::no_roll (jack_nframes_t nframes, jack_nframes_t offset) +Session::no_roll (nframes_t nframes, nframes_t offset) { - jack_nframes_t end_frame = _transport_frame + nframes; + nframes_t end_frame = _transport_frame + nframes; // FIXME: varispeed + no_roll ?? int ret = 0; bool declick = get_transport_declick_required(); - - cerr << "[DR] no_roll\n"; + boost::shared_ptr r = routes.reader (); if (_click_io) { _click_io->silence (nframes, offset); } - /* XXX we're supposed to have the route_lock while doing this. - this is really bad ... - */ - - if (atomic_read (&processing_prohibited)) { - for (RouteList::iterator i = routes.begin(); i != routes.end(); ++i) { + if (g_atomic_int_get (&processing_prohibited)) { + for (RouteList::iterator i = r->begin(); i != r->end(); ++i) { (*i)->silence (nframes, offset); } return 0; } - for (RouteList::iterator i = routes.begin(); i != routes.end(); ++i) { + for (RouteList::iterator i = r->begin(); i != r->end(); ++i) { - if ((*i)->hidden()) { + if ((*i)->is_hidden()) { continue; } @@ -124,11 +121,12 @@ Session::no_roll (jack_nframes_t nframes, jack_nframes_t offset) } int -Session::process_routes (jack_nframes_t nframes, jack_nframes_t offset) +Session::process_routes (nframes_t nframes, nframes_t offset) { 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) { /* force a declick out */ @@ -137,24 +135,28 @@ Session::process_routes (jack_nframes_t nframes, jack_nframes_t offset) record_active = actively_recording(); // || (get_record_enabled() && get_punch_in()); - for (RouteList::iterator i = routes.begin(); i != routes.end(); ++i) { + 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) { int ret; - if ((*i)->hidden()) { + if ((*i)->is_hidden()) { continue; } (*i)->set_pending_declick (declick); - if ((ret = (*i)->roll (nframes, _transport_frame, _transport_frame + nframes, offset, declick, record_active, rec_monitors)) < 0) { + if ((ret = (*i)->roll (nframes, start_frame, end_frame, offset, declick, record_active, rec_monitors)) < 0) { - /* we have to do this here. Route::roll() for an AudioTrack will have called DiskStream::process(), - and the DS will expect DiskStream::commit() to be called. but we're aborting from that + /* 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. */ - for (DiskStreamList::iterator ids = diskstreams.begin(); ids != diskstreams.end(); ++ids) { + boost::shared_ptr dsl = diskstreams.reader(); + for (DiskstreamList::iterator ids = dsl->begin(); ids != dsl->end(); ++ids) { (*ids)->recover (); } @@ -167,33 +169,38 @@ Session::process_routes (jack_nframes_t nframes, jack_nframes_t offset) } int -Session::silent_process_routes (jack_nframes_t nframes, jack_nframes_t offset) +Session::silent_process_routes (nframes_t nframes, nframes_t offset) { 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 nframes_t start_frame = _transport_frame; + const nframes_t end_frame = _transport_frame + lrintf(nframes * _transport_speed); - for (RouteList::iterator i = routes.begin(); i != routes.end(); ++i) { + for (RouteList::iterator i = r->begin(); i != r->end(); ++i) { int ret; - if ((*i)->hidden()) { + if ((*i)->is_hidden()) { continue; } - if ((ret = (*i)->silent_roll (nframes, _transport_frame, _transport_frame + nframes, offset, record_active, rec_monitors)) < 0) { + if ((ret = (*i)->silent_roll (nframes, start_frame, end_frame, offset, record_active, rec_monitors)) < 0) { - /* we have to do this here. Route::roll() for an AudioTrack will have called DiskStream::process(), - and the DS will expect DiskStream::commit() to be called. but we're aborting from that + /* 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. */ - for (DiskStreamList::iterator ids = diskstreams.begin(); ids != diskstreams.end(); ++ids) { + boost::shared_ptr dsl = diskstreams.reader(); + for (DiskstreamList::iterator ids = dsl->begin(); ids != dsl->end(); ++ids) { (*ids)->recover (); } @@ -206,19 +213,23 @@ Session::silent_process_routes (jack_nframes_t nframes, jack_nframes_t offset) } void -Session::commit_diskstreams (jack_nframes_t nframes, bool &needs_butler) +Session::commit_diskstreams (nframes_t nframes, bool &needs_butler) { int dret; float pworst = 1.0f; float cworst = 1.0f; - for (DiskStreamList::iterator i = diskstreams.begin(); i != diskstreams.end(); ++i) { + boost::shared_ptr dsl = diskstreams.reader(); + for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) { if ((*i)->hidden()) { 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, 0, actively_recording(), get_rec_monitors_input())) == 0) { @@ -234,39 +245,41 @@ Session::commit_diskstreams (jack_nframes_t nframes, bool &needs_butler) cworst = min (cworst, (*i)->capture_buffer_load()); } - uint32_t pmin = atomic_read (&_playback_load); - uint32_t pminold = atomic_read (&_playback_load_min); - uint32_t cmin = atomic_read (&_capture_load); - uint32_t cminold = atomic_read (&_capture_load_min); + 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); - atomic_set (&_playback_load, (uint32_t) floor (pworst * 100.0f)); - atomic_set (&_capture_load, (uint32_t) floor (cworst * 100.0f)); - atomic_set (&_playback_load_min, min (pmin, pminold)); - atomic_set (&_capture_load_min, min (cmin, cminold)); + 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(); } } - +/** Process callback used when the auditioner is not active */ void -Session::process_with_events (jack_nframes_t nframes) +Session::process_with_events (nframes_t nframes) { Event* ev; - jack_nframes_t this_nframes; - jack_nframes_t end_frame; - jack_nframes_t offset; - jack_nframes_t stop_limit; + nframes_t this_nframes; + nframes_t end_frame; + nframes_t offset; + bool session_needs_butler = false; + nframes_t stop_limit; long frames_moved; - bool session_needs_butler = false; - - cerr << "[DR] with events" << endl; + + /* make sure the auditioner is silent */ if (auditioner) { auditioner->silence (nframes, 0); } + /* handle any pending events */ + while (pending_events.read (&ev, 1) == 1) { merge_event (ev); } @@ -282,34 +295,32 @@ Session::process_with_events (jack_nframes_t nframes) process_event (ev); } - /* Events caused a transport change and we need to send MTC - * [DR] FIXME: best place for this? */ + /* Events caused a transport change, send an MTC Full Frame (SMPTE) 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_smpte_update) { - cerr << "[DR] TIME CHANGE\n" << endl; send_full_time_code(nframes); } if (!process_can_proceed()) { - no_roll (nframes, 0); + _silent = true; return; } - + if (events.empty() || next_event == events.end()) { process_without_events (nframes); return; } - end_frame = _transport_frame + nframes; + end_frame = _transport_frame + (nframes_t)abs(floor(nframes * _transport_speed)); { - TentativeRWLockMonitor rm (route_lock, false, __LINE__, __FILE__); - TentativeRWLockMonitor dsm (diskstream_lock, false, __LINE__, __FILE__); - Event* this_event; Events::iterator the_next_one; - - if (!rm.locked() || !dsm.locked() || (post_transport_work & (PostTransportLocate|PostTransportStop))) { - no_roll (nframes, 0); + + if (!process_can_proceed()) { + _silent = true; return; } @@ -323,6 +334,10 @@ Session::process_with_events (jack_nframes_t nframes) no_roll (nframes, 0); return; } + + if (!_exporting) { + send_midi_time_code_for_cycle (nframes); + } if (actively_recording()) { stop_limit = max_frames; @@ -346,22 +361,19 @@ Session::process_with_events (jack_nframes_t nframes) offset = 0; + /* yes folks, here it is, the actual loop where we really truly + process some audio */ while (nframes) { - if (this_event == 0 || this_event->action_frame > end_frame || this_event->action_frame < _transport_frame) { - - this_nframes = nframes; - - } else { - - /* compute nframes to next event */ + this_nframes = nframes; /* real (jack) time relative */ + frames_moved = (long) floor (_transport_speed * nframes); /* transport relative */ - if (this_event->action_frame < end_frame) { - this_nframes = nframes - (end_frame - this_event->action_frame); - } else { - this_nframes = nframes; - } - } + /* 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) ); + } if (this_nframes) { @@ -380,8 +392,6 @@ Session::process_with_events (jack_nframes_t nframes) nframes -= this_nframes; offset += this_nframes; - frames_moved = (jack_nframes_t) floor (_transport_speed * this_nframes); - if (frames_moved < 0) { decrement_transport_position (-frames_moved); } else { @@ -413,8 +423,7 @@ Session::process_with_events (jack_nframes_t nframes) } /* this is necessary to handle the case of seamless looping */ - /* not sure if it will work in conjuction with varispeed */ - end_frame = _transport_frame + nframes; + end_frame = _transport_frame + (nframes_t) floor (nframes * _transport_speed); } @@ -424,8 +433,6 @@ Session::process_with_events (jack_nframes_t nframes) if (session_needs_butler) summon_butler (); - - send_midi_time_code_for_cycle(nframes); } void @@ -442,7 +449,7 @@ Session::transport_locked () const { Slave* sl = _slave; - if (!locate_pending() && ((_slave_type == None) || (sl && sl->ok() && sl->locked()))) { + if (!locate_pending() && ((Config->get_slave_source() == None) || (sl && sl->ok() && sl->locked()))) { return true; } @@ -450,17 +457,17 @@ Session::transport_locked () const } bool -Session::follow_slave (jack_nframes_t nframes, jack_nframes_t offset) +Session::follow_slave (nframes_t nframes, nframes_t offset) { float slave_speed; - jack_nframes_t slave_transport_frame; - jack_nframes_t this_delta; + nframes_t slave_transport_frame; + nframes_t this_delta; int dir; bool starting; if (!_slave->ok()) { stop_transport (); - set_slave_source (None, 0); + Config->set_slave_source (None); goto noroll; } @@ -486,12 +493,12 @@ Session::follow_slave (jack_nframes_t nframes, jack_nframes_t offset) cerr << "delta = " << (int) (dir * this_delta) << " speed = " << slave_speed << " ts = " << _transport_speed - << " M@"<< slave_transport_frame << " S@" << _transport_frame + << " M@ "<< slave_transport_frame << " S@ " << _transport_frame << " avgdelta = " << average_slave_delta << endl; #endif - if (Config->get_timecode_source_is_synced()) { + if (_slave->is_always_synced() || Config->get_timecode_source_is_synced()) { /* if the TC source is synced, then we assume that its speed is binary: 0.0 or 1.0 @@ -551,9 +558,9 @@ Session::follow_slave (jack_nframes_t nframes, jack_nframes_t offset) Location* al = _locations.auto_loop_location(); - if (al && auto_loop && (slave_transport_frame < al->start() || slave_transport_frame > al->end())) { + if (al && play_loop && (slave_transport_frame < al->start() || slave_transport_frame > al->end())) { // cancel looping - request_auto_loop(false); + request_play_loop(false); } if (slave_transport_frame != _transport_frame) { @@ -573,17 +580,17 @@ Session::follow_slave (jack_nframes_t nframes, jack_nframes_t offset) if (slave_state == Waiting) { // cerr << "waiting at " << slave_transport_frame << endl; - TentativeRWLockMonitor dsm (diskstream_lock, false, __LINE__, __FILE__); - - if (dsm.locked() && slave_transport_frame >= slave_wait_end) { + if (slave_transport_frame >= slave_wait_end) { // cerr << "\tstart at " << _transport_frame << endl; slave_state = Running; bool ok = true; - jack_nframes_t frame_delta = slave_transport_frame - _transport_frame; + nframes_t frame_delta = slave_transport_frame - _transport_frame; + + boost::shared_ptr dsl = diskstreams.reader(); - for (DiskStreamList::iterator i = diskstreams.begin(); i != diskstreams.end(); ++i) { + for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) { if (!(*i)->can_internal_playback_seek (frame_delta)) { ok = false; break; @@ -591,7 +598,7 @@ Session::follow_slave (jack_nframes_t nframes, jack_nframes_t offset) } if (ok) { - for (DiskStreamList::iterator i = diskstreams.begin(); i != diskstreams.end(); ++i) { + for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) { (*i)->internal_playback_seek (frame_delta); } _transport_frame += frame_delta; @@ -601,7 +608,7 @@ Session::follow_slave (jack_nframes_t nframes, jack_nframes_t offset) /* XXX what? */ } - memset (delta_accumulator, 0, sizeof (jack_nframes_t) * delta_accumulator_size); + memset (delta_accumulator, 0, sizeof (nframes_t) * delta_accumulator_size); average_slave_delta = 0; this_delta = 0; } @@ -624,7 +631,7 @@ Session::follow_slave (jack_nframes_t nframes, jack_nframes_t offset) // << " tf = " << _transport_frame // << endl; - if (_slave_type == JACK) { + if (Config->get_slave_source() == JACK) { last_stop_frame = _transport_frame; } @@ -639,7 +646,7 @@ Session::follow_slave (jack_nframes_t nframes, jack_nframes_t offset) slave_state = Stopped; } - if (slave_state == Running && !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) { @@ -672,7 +679,7 @@ Session::follow_slave (jack_nframes_t nframes, jack_nframes_t offset) request_transport_speed (adjusted_speed); #if 1 - if ((jack_nframes_t) average_slave_delta > _slave->resolution()) { + if ((nframes_t) average_slave_delta > _slave->resolution()) { // cerr << "not locked\n"; goto silent_motion; } @@ -695,12 +702,6 @@ Session::follow_slave (jack_nframes_t nframes, jack_nframes_t offset) bool need_butler; - TentativeRWLockMonitor dsm (diskstream_lock, false, __LINE__, __FILE__); - if (!dsm.locked()) { - goto noroll; - } - - prepare_diskstreams (); silent_process_routes (nframes, offset); commit_diskstreams (nframes, need_butler); @@ -709,7 +710,7 @@ Session::follow_slave (jack_nframes_t nframes, jack_nframes_t offset) summon_butler (); } - jack_nframes_t frames_moved = (long) floor (_transport_speed * nframes); + int32_t frames_moved = (int32_t) floor (_transport_speed * nframes); if (frames_moved < 0) { decrement_transport_position (-frames_moved); @@ -717,7 +718,7 @@ Session::follow_slave (jack_nframes_t nframes, jack_nframes_t offset) increment_transport_position (frames_moved); } - jack_nframes_t stop_limit; + nframes_t stop_limit; if (actively_recording()) { stop_limit = max_frames; @@ -739,97 +740,101 @@ Session::follow_slave (jack_nframes_t nframes, jack_nframes_t offset) } void -Session::process_without_events (jack_nframes_t nframes) +Session::process_without_events (nframes_t nframes) { - cerr << "[DR] without events" << endl; - bool session_needs_butler = false; - jack_nframes_t stop_limit; + nframes_t stop_limit; long frames_moved; - - { - TentativeRWLockMonitor rm (route_lock, false, __LINE__, __FILE__); - TentativeRWLockMonitor dsm (diskstream_lock, false, __LINE__, __FILE__); - - if (!rm.locked() || !dsm.locked() || (post_transport_work & (PostTransportLocate|PostTransportStop))) { - no_roll (nframes, 0); - return; - } + nframes_t offset = 0; - if (!_exporting && _slave) { - if (!follow_slave (nframes, 0)) { - return; - } - } + if (!process_can_proceed()) { + _silent = true; + return; + } - if (_transport_speed == 0) { - no_roll (nframes, 0); + if (!_exporting && _slave) { + if (!follow_slave (nframes, 0)) { return; } + } + + if (_transport_speed == 0) { + no_roll (nframes, 0); + return; + } - if (actively_recording()) { - stop_limit = max_frames; + if (!_exporting) { + send_midi_time_code_for_cycle (nframes); + } + + if (actively_recording()) { + stop_limit = max_frames; + } else { + if (Config->get_stop_at_session_end()) { + stop_limit = current_end_frame(); } else { - if (Config->get_stop_at_session_end()) { - stop_limit = current_end_frame(); - } else { - stop_limit = max_frames; - } + stop_limit = max_frames; } + } - if (maybe_stop (stop_limit)) { - no_roll (nframes, 0); - return; - } + if (maybe_stop (stop_limit)) { + no_roll (nframes, 0); + return; + } - click (_transport_frame, nframes, 0); + if (maybe_sync_start (nframes, offset)) { + return; + } - prepare_diskstreams (); + click (_transport_frame, nframes, offset); + + prepare_diskstreams (); - frames_moved = (long) floor (_transport_speed * nframes); + frames_moved = (long) floor (_transport_speed * nframes); - if (process_routes (nframes, 0)) { - no_roll (nframes, 0); - return; - } + if (process_routes (nframes, offset)) { + no_roll (nframes, offset); + return; + } - commit_diskstreams (nframes, session_needs_butler); + commit_diskstreams (nframes, session_needs_butler); - if (frames_moved < 0) { - decrement_transport_position (-frames_moved); - } else { - increment_transport_position (frames_moved); - } - - maybe_stop (stop_limit); - check_declick_out (); - - } /* implicit release of route lock */ + if (frames_moved < 0) { + decrement_transport_position (-frames_moved); + } else { + increment_transport_position (frames_moved); + } - send_midi_time_code_for_cycle(nframes); + maybe_stop (stop_limit); + check_declick_out (); if (session_needs_butler) summon_butler (); } +/** Process callback used when the auditioner is active. + * @param nframes number of frames to process. + */ void -Session::process_audition (jack_nframes_t nframes) +Session::process_audition (nframes_t nframes) { - TentativeRWLockMonitor rm (route_lock, false, __LINE__, __FILE__); Event* ev; + boost::shared_ptr r = routes.reader (); - if (rm.locked()) { - for (RouteList::iterator i = routes.begin(); i != routes.end(); ++i) { - if (!(*i)->hidden()) { - (*i)->silence (nframes, 0); - } + for (RouteList::iterator i = r->begin(); i != r->end(); ++i) { + if (!(*i)->is_hidden()) { + (*i)->silence (nframes, 0); } } + + /* run the auditioner, and if it says we need butler service, ask for it */ if (auditioner->play_audition (nframes) > 0) { summon_butler (); } + /* handle pending events */ + while (pending_events.read (&ev, 1) == 1) { merge_event (ev); } @@ -846,7 +851,56 @@ Session::process_audition (jack_nframes_t nframes) } if (!auditioner->active()) { + /* auditioner no longer active, so go back to the normal process callback */ process_function = &Session::process_with_events; } } +bool +Session::maybe_sync_start (nframes_t& nframes, nframes_t& offset) +{ + nframes_t sync_offset; + + if (!waiting_for_sync_offset) { + return false; + } + + if (_engine.get_sync_offset (sync_offset) && sync_offset < nframes) { + + /* generate silence up to the sync point, then + adjust nframes + offset to reflect whatever + is left to do. + */ + + no_roll (sync_offset, 0); + nframes -= sync_offset; + offset += sync_offset; + waiting_for_sync_offset = false; + + if (nframes == 0) { + return true; // done, nothing left to process + } + + } else { + + /* sync offset point is not within this process() + cycle, so just generate silence. and don't bother + with any fancy stuff here, just the minimal silence. + */ + + g_atomic_int_inc (&processing_prohibited); + no_roll (nframes, 0); + g_atomic_int_dec_and_test (&processing_prohibited); + + if (Config->get_locate_while_waiting_for_sync()) { + if (micro_locate (nframes)) { + /* XXX ERROR !!! XXX */ + } + } + + return true; // done, nothing left to process + } + + return false; +} +