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) {
void
Session::prepare_diskstreams ()
{
- for (AudioDiskstreamList::iterator i = audio_diskstreams.begin(); i != audio_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 (g_atomic_int_get (&processing_prohibited)) {
- for (RouteList::iterator i = routes.begin(); i != routes.end(); ++i) {
+ 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;
call path, so make sure we release any outstanding locks here before we return failure.
*/
- for (AudioDiskstreamList::iterator ids = audio_diskstreams.begin(); ids != audio_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;
call path, so make sure we release any outstanding locks here before we return failure.
*/
- for (AudioDiskstreamList::iterator ids = audio_diskstreams.begin(); ids != audio_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 (AudioDiskstreamList::iterator i = audio_diskstreams.begin(); i != audio_diskstreams.end(); ++i) {
+ boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
+ for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
if ((*i)->hidden()) {
continue;
}
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;
{
- Glib::RWLock::ReaderLock rm (route_lock, Glib::TRY_LOCK);
- Glib::RWLock::ReaderLock dsm (diskstream_lock, Glib::TRY_LOCK);
-
Event* this_event;
Events::iterator the_next_one;
-
- if (!rm.locked() || !dsm.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 ();
}
{
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;
}
}
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;
}
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;
- Glib::RWLock::ReaderLock dsm (diskstream_lock, Glib::TRY_LOCK);
-
- 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<DiskstreamList> dsl = diskstreams.reader();
- for (AudioDiskstreamList::iterator i = audio_diskstreams.begin(); i != audio_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 (AudioDiskstreamList::iterator i = audio_diskstreams.begin(); i != audio_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;
- Glib::RWLock::ReaderLock dsm (diskstream_lock, Glib::TRY_LOCK);
- if (!dsm.locked()) {
- goto noroll;
- }
-
-
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;
-
- {
- Glib::RWLock::ReaderLock rm (route_lock, Glib::TRY_LOCK);
- Glib::RWLock::ReaderLock dsm (diskstream_lock, Glib::TRY_LOCK);
+ nframes_t offset = 0;
- if (!rm.locked() || !dsm.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)
{
- Glib::RWLock::ReaderLock rm (route_lock, Glib::TRY_LOCK);
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;
+}
+