X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fsession_process.cc;h=5a28fd5890c6b8d26f1efcb7abf7c1ada1fa022e;hb=89e4d352445e9394073804f78fbd6845e6820f20;hp=e99478e0b40e73aa63f3ab353ef955e1754bdf36;hpb=25d1670a61d19e795227b939a98be9cf5a050c67;p=ardour.git

diff --git a/libs/ardour/session_process.cc b/libs/ardour/session_process.cc
index e99478e0b4..5a28fd5890 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 <cmath>
@@ -45,19 +44,22 @@ using namespace ARDOUR;
 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)
 {
+	// This is no more the appriopriate place to call cycle
+	// start. cycle_start needs to be called at the Route::roll()
+	// where the signals which we want to mixdown have been calculated.
+	//
 	MIDI::Manager::instance()->cycle_start(nframes);
 
-	if (synced_to_jack() && waiting_to_start) {
-		if ( _engine.transport_state() == AudioEngine::TransportRolling) {
-			actually_start_transport ();
-		}
-	}
+	_silent = false;
 
 	if (non_realtime_work_pending()) {
-		if (g_atomic_int_get (&butler_should_do_transport_work) == 0) {
+		if (!transport_work_requested ()) {
 			post_transport ();
 		} 
 	} 
@@ -79,9 +81,9 @@ Session::prepare_diskstreams ()
 }
 
 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; // FIXME: varispeed + no_roll ??
+	nframes_t end_frame = _transport_frame + nframes; // FIXME: varispeed + no_roll ??
 	int ret = 0;
 	bool declick = get_transport_declick_required();
 	boost::shared_ptr<RouteList> r = routes.reader ();
@@ -99,7 +101,7 @@ Session::no_roll (jack_nframes_t nframes, jack_nframes_t offset)
 
 	for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
 		
-		if ((*i)->hidden()) {
+		if ((*i)->is_hidden()) {
 			continue;
 		}
 		
@@ -117,7 +119,7 @@ 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();
@@ -131,14 +133,14 @@ Session::process_routes (jack_nframes_t nframes, jack_nframes_t offset)
 
 	record_active = actively_recording(); // || (get_record_enabled() && get_punch_in());
 
-	const jack_nframes_t start_frame = _transport_frame;
-	const jack_nframes_t end_frame = _transport_frame + (jack_nframes_t)floor(nframes * _transport_speed);
+	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;
 		}
 
@@ -165,7 +167,7 @@ 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();
@@ -177,14 +179,14 @@ Session::silent_process_routes (jack_nframes_t nframes, jack_nframes_t offset)
 		declick = -1;
 	}
 	
-	const jack_nframes_t start_frame = _transport_frame;
-	const jack_nframes_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);
 
 	for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
 
 		int ret;
 
-		if ((*i)->hidden()) {
+		if ((*i)->is_hidden()) {
 			continue;
 		}
 
@@ -209,7 +211,7 @@ 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;
@@ -223,6 +225,9 @@ Session::commit_diskstreams (jack_nframes_t nframes, bool &needs_butler)
 		}
 		
 		/* 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) {
@@ -253,18 +258,18 @@ Session::commit_diskstreams (jack_nframes_t nframes, bool &needs_butler)
 	}
 }
 
-
+/** 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;
-
+	
 	/* make sure the auditioner is silent */
 
 	if (auditioner) {
@@ -297,7 +302,7 @@ Session::process_with_events (jack_nframes_t nframes)
 	}
 
 	if (!process_can_proceed()) {
-		no_roll (nframes, 0);
+		_silent = true;
 		return;
 	}
 
@@ -306,14 +311,14 @@ Session::process_with_events (jack_nframes_t nframes)
 		return;
 	}
 
-	end_frame = _transport_frame + nframes;
+	end_frame = _transport_frame + (nframes_t)abs(floor(nframes * _transport_speed));
 
 	{
 		Event* this_event;
 		Events::iterator the_next_one;
 		
-		if (post_transport_work & (PostTransportLocate|PostTransportStop)) {
-			no_roll (nframes, 0);
+		if (!process_can_proceed()) {
+			_silent = true;
 			return;
 		}
 		
@@ -328,7 +333,9 @@ Session::process_with_events (jack_nframes_t nframes)
 			return;
 		}
 	
-		send_midi_time_code_for_cycle(nframes);
+		if (!_exporting) {
+			send_midi_time_code_for_cycle (nframes);
+		}
 
 		if (actively_recording()) {
 			stop_limit = max_frames;
@@ -352,22 +359,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; /* real (jack) time relative */
+			frames_moved = (long) floor (_transport_speed * nframes); /* transport relative */
 
-				this_nframes = nframes;
-				
-			} else {
-				
-				/* compute nframes to next event */
-
-				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) {
 				
@@ -386,8 +390,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 {
@@ -419,8 +421,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);
 			
 		}
 
@@ -446,7 +447,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;
 	}
 
@@ -454,17 +455,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;
 	}
 	
@@ -490,12 +491,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
@@ -555,9 +556,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) {
@@ -583,7 +584,7 @@ Session::follow_slave (jack_nframes_t nframes, jack_nframes_t offset)
 				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();
 				
@@ -605,7 +606,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;
 			}
@@ -628,7 +629,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;
 			}
 
@@ -643,7 +644,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) {
@@ -676,7 +677,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;
 			}
@@ -715,7 +716,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;
@@ -737,82 +738,89 @@ 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)
 {
 	bool session_needs_butler = false;
-	jack_nframes_t stop_limit;
+	nframes_t stop_limit;
 	long frames_moved;
-	
-	{
-		if (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;
 		}
-	
-		send_midi_time_code_for_cycle(nframes);
+	} 
+
+	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 ();
+	if (frames_moved < 0) {
+		decrement_transport_position (-frames_moved);
+	} else {
+		increment_transport_position (frames_moved);
+	}
 
-	} /* implicit release of route lock */
+	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)
 {
 	Event* ev;
 	boost::shared_ptr<RouteList> r = routes.reader ();
 
 	for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
-		if (!(*i)->hidden()) {
+		if (!(*i)->is_hidden()) {
 			(*i)->silence (nframes, 0);
 		}
 	}
@@ -841,7 +849,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;
+}
+