#include <algorithm>
#include <unistd.h>
-#include <ardour/timestamps.h>
-
#include <pbd/error.h>
-#include <pbd/atomic.h>
-#include <pbd/lockmonitor.h>
+
+#include <glibmm/thread.h>
#include <ardour/ardour.h>
#include <ardour/session.h>
-#include <ardour/diskstream.h>
+#include <ardour/timestamps.h>
+#include <ardour/audio_diskstream.h>
#include <ardour/audioengine.h>
#include <ardour/slave.h>
#include <ardour/auditioner.h>
#include "i18n.h"
using namespace ARDOUR;
-//using namespace sigc;
+using namespace PBD;
using namespace std;
void
-Session::process (jack_nframes_t nframes)
+Session::process (nframes_t nframes)
{
if (synced_to_jack() && waiting_to_start) {
if ( _engine.transport_state() == AudioEngine::TransportRolling) {
}
if (non_realtime_work_pending()) {
- if (atomic_read (&butler_should_do_transport_work) == 0) {
+ if (!transport_work_requested ()) {
post_transport ();
}
}
(this->*process_function) (nframes);
+
+ SendFeedback (); /* EMIT SIGNAL */
}
void
Session::prepare_diskstreams ()
{
- for (DiskStreamList::iterator i = diskstreams.begin(); i != diskstreams.end(); ++i) {
+ boost::shared_ptr<DiskstreamList> 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;
int ret = 0;
bool declick = get_transport_declick_required();
+ boost::shared_ptr<RouteList> 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()) {
continue;
}
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<RouteList> r = routes.reader ();
if (transport_sub_state & StopPendingCapture) {
/* force a declick out */
record_active = actively_recording(); // || (get_record_enabled() && get_punch_in());
- for (RouteList::iterator i = routes.begin(); i != routes.end(); ++i) {
+ for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
int ret;
if ((ret = (*i)->roll (nframes, _transport_frame, _transport_frame + nframes, 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<DiskstreamList> dsl = diskstreams.reader();
+ for (DiskstreamList::iterator ids = dsl->begin(); ids != dsl->end(); ++ids) {
(*ids)->recover ();
}
}
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<RouteList> r = routes.reader ();
if (transport_sub_state & StopPendingCapture) {
/* force a declick out */
declick = -1;
}
- for (RouteList::iterator i = routes.begin(); i != routes.end(); ++i) {
+ for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
int ret;
if ((ret = (*i)->silent_roll (nframes, _transport_frame, _transport_frame + nframes, 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<DiskstreamList> dsl = diskstreams.reader();
+ for (DiskstreamList::iterator ids = dsl->begin(); ids != dsl->end(); ++ids) {
(*ids)->recover ();
}
}
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<DiskstreamList> dsl = diskstreams.reader();
+ for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
if ((*i)->hidden()) {
continue;
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();
}
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;
+ nframes_t this_nframes;
+ nframes_t end_frame;
+ nframes_t offset;
bool session_needs_butler = false;
- jack_nframes_t stop_limit;
+ nframes_t stop_limit;
long frames_moved;
+ /* 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);
}
end_frame = _transport_frame + nframes;
{
- TentativeLockMonitor rm (route_lock, __LINE__, __FILE__);
Event* this_event;
Events::iterator the_next_one;
-
- if (!rm.locked() || (post_transport_work & (PostTransportLocate|PostTransportStop))) {
+
+ if (post_transport_work & (PostTransportLocate|PostTransportStop)) {
no_roll (nframes, 0);
return;
}
nframes -= this_nframes;
offset += this_nframes;
- frames_moved = (jack_nframes_t) floor (_transport_speed * this_nframes);
+ frames_moved = (nframes_t) floor (_transport_speed * this_nframes);
if (frames_moved < 0) {
decrement_transport_position (-frames_moved);
summon_butler ();
}
- if (!_engine.freewheeling() && send_mtc) {
+ if (!_engine.freewheeling() && session_send_mtc) {
send_midi_time_code_in_another_thread ();
}
}
bool
-Session::follow_slave (jack_nframes_t nframes, jack_nframes_t offset)
+Session::transport_locked () const
+{
+ Slave* sl = _slave;
+
+ if (!locate_pending() && ((Config->get_slave_source() == None) || (sl && sl->ok() && sl->locked()))) {
+ return true;
+ }
+
+ return false;
+}
+
+bool
+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;
}
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) {
if (slave_state == Waiting) {
// cerr << "waiting at " << slave_transport_frame << endl;
-
+
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<DiskstreamList> 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;
}
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;
/* 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;
}
// << " tf = " << _transport_frame
// << endl;
- if (_slave_type == JACK) {
+ if (Config->get_slave_source() == JACK) {
last_stop_frame = _transport_frame;
}
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;
}
*/
bool need_butler;
-
+
prepare_diskstreams ();
silent_process_routes (nframes, offset);
commit_diskstreams (nframes, need_butler);
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);
increment_transport_position (frames_moved);
}
- jack_nframes_t stop_limit;
+ nframes_t stop_limit;
if (actively_recording()) {
stop_limit = max_frames;
}
void
-Session::process_without_events (jack_nframes_t nframes)
+Session::process_without_events (nframes_t nframes)
{
bool session_needs_butler = false;
- jack_nframes_t stop_limit;
+ nframes_t stop_limit;
long frames_moved;
-
- {
- TentativeLockMonitor rm (route_lock, __LINE__, __FILE__);
+ nframes_t offset = 0;
- if (!rm.locked() || (post_transport_work & (PostTransportLocate|PostTransportStop))) {
+ {
+ if (post_transport_work & (PostTransportLocate|PostTransportStop)) {
no_roll (nframes, 0);
return;
}
return;
}
- click (_transport_frame, nframes, 0);
+ if (maybe_sync_start (nframes, offset)) {
+ return;
+ }
+
+ click (_transport_frame, nframes, offset);
prepare_diskstreams ();
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);
} else {
increment_transport_position (frames_moved);
}
-
+
maybe_stop (stop_limit);
check_declick_out ();
summon_butler ();
}
- if (!_engine.freewheeling() && send_mtc) {
+ if (!_engine.freewheeling() && session_send_mtc) {
send_midi_time_code_in_another_thread ();
}
}
void
-Session::process_audition (jack_nframes_t nframes)
+Session::process_audition (nframes_t nframes)
{
- TentativeLockMonitor rm (route_lock, __LINE__, __FILE__);
Event* ev;
+ boost::shared_ptr<RouteList> 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)->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);
}
}
}
+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) {
+
+ no_roll (sync_offset, 0);
+ nframes -= sync_offset;
+ offset += sync_offset;
+ waiting_for_sync_offset = false;
+
+ if (nframes == 0) {
+ return true; // done
+ }
+
+ } else {
+ no_roll (nframes, 0);
+ return true; // done
+ }
+
+ return false;
+}
+
projects / ardour.git / blobdiff