[0.99.7] add jack_get_xrun_delay()

git-svn-id: svn+ssh://jackaudio.org/trunk/jack@771 0c269be4-1314-0410-8aa9-9f06e86f4224

configure.in

@@ -15,7 +15,7 @@ dnl                 changes are made
 dnl ---
 JACK_MAJOR_VERSION=0
 JACK_MINOR_VERSION=99
-JACK_MICRO_VERSION=6
+JACK_MICRO_VERSION=7
 
 dnl ---
 dnl HOWTO: updating the jack protocol version

drivers/alsa/alsa_driver.c

@@ -1063,7 +1063,7 @@ alsa_driver_stop (alsa_driver_t *driver)
 }
 
 static int
-alsa_driver_xrun_recovery (alsa_driver_t *driver)
+alsa_driver_xrun_recovery (alsa_driver_t *driver, float *delayed_usecs)
 {
 	snd_pcm_status_t *status;
 	int res;
@@ -1089,9 +1089,10 @@ alsa_driver_xrun_recovery (alsa_driver_t *driver)
 		gettimeofday(&now, 0);
 		snd_pcm_status_get_trigger_tstamp(status, &tstamp);
 		timersub(&now, &tstamp, &diff);
+		*delayed_usecs = diff.tv_sec * 1000000.0 + diff.tv_usec;
 		fprintf(stderr, "\n\n**** alsa_pcm: xrun of at least %.3f "
 			"msecs\n\n",
-			diff.tv_sec * 1000 + diff.tv_usec / 1000.0);
+			*delayed_usecs / 1000.0);
 	}
 
 	if (alsa_driver_stop (driver) ||
@@ -1348,7 +1349,7 @@ alsa_driver_wait (alsa_driver_t *driver, int extra_fd, int *status, float
 	}
 
 	if (xrun_detected) {
-		*status = alsa_driver_xrun_recovery (driver);
+		*status = alsa_driver_xrun_recovery (driver, delayed_usecs);
 		return 0;
 	}
 
@@ -1617,8 +1618,7 @@ alsa_driver_run_cycle (alsa_driver_t *driver)
 		/* we detected an xrun and restarted: notify
 		 * clients about the delay. 
 		 */
-
-		engine->delay (engine);
+		engine->delay (engine, delayed_usecs);
 		return 0;
 	} 
 

drivers/dummy/dummy_driver.c

@@ -74,7 +74,7 @@ dummy_driver_run_cycle (dummy_driver_t *driver)
 	if (nframes == 0) {
 		/* we detected an xrun and restarted: notify
 		 * clients about the delay. */
-		engine->delay (engine);
+		engine->delay (engine, delayed_usecs);
 		return 0;
 	} 
 

jack/engine.h

@@ -64,12 +64,12 @@ struct _jack_engine {
     jack_driver_desc_t    *driver_desc;
     JSList                *driver_params;
 
-    /* these are "callbacks" made by the driver */
+    /* these are "callbacks" made by the driver backend */
     int  (*set_buffer_size) (struct _jack_engine *, jack_nframes_t frames);
     int  (*set_sample_rate) (struct _jack_engine *, jack_nframes_t frames);
     int  (*run_cycle)	    (struct _jack_engine *, jack_nframes_t nframes,
 			     float delayed_usecs);
-    void (*delay)	    (struct _jack_engine *);
+    void (*delay)	    (struct _jack_engine *, float delayed_usecs);
     void (*transport_cycle_start) (struct _jack_engine *, jack_time_t time);
     void (*driver_exit)     (struct _jack_engine *);
 

jack/internal.h

@@ -115,6 +115,7 @@ typedef struct {
     int32_t		  client_priority;
     int32_t		  has_capabilities;
     float                 cpu_load;
+    float		  xrun_delayed_usecs;
     uint32_t		  port_max;
     int32_t		  engine_ok;
     jack_port_type_id_t	  n_port_types;

jack/jack.h

@@ -308,6 +308,13 @@ int jack_set_graph_order_callback (jack_client_t *,
 int jack_set_xrun_callback (jack_client_t *,
 			    JackXRunCallback xrun_callback, void *arg);
 
+/**
+ * @return the delay in microseconds due to the most recent XRUN
+ * occurrence.  This probably only makes sense when called from a @ref
+ * JackXRunCallback defined using jack_set_xrun_callback().
+ */
+float jack_get_xrun_delayed_usecs (jack_client_t *client);
+
 /**
  * Tell the Jack server that the program is ready to start processing
  * audio.

jack/types.h

@@ -100,8 +100,10 @@ typedef void  (*JackThreadInitCallback)(void *arg);
 typedef int  (*JackGraphOrderCallback)(void *arg);
 
 /**
- * Prototype for the client supplied function that is called 
- * whenever an xrun has occured.
+ * Prototype for the client-supplied function that is called whenever
+ * an xrun has occured.
+ *
+ * @see jack_get_xrun_delayed_usecs()
  *
  * @param arg pointer to a client supplied structure
  *

jackd/engine.c

@@ -126,7 +126,8 @@ static int  internal_client_request (void*, jack_request_t *);
 static int  jack_use_driver (jack_engine_t *engine, jack_driver_t *driver);
 static int  jack_run_cycle (jack_engine_t *engine, jack_nframes_t nframes,
 			    float delayed_usecs);
-static void jack_engine_notify_clients_about_delay (jack_engine_t *engine);
+static void jack_engine_notify_clients_about_delay (jack_engine_t *engine,
+						    float delayed_usecs);
 static void jack_engine_driver_exit (jack_engine_t* engine);
 static int  jack_start_freewheeling (jack_engine_t* engine);
 static int  jack_stop_freewheeling (jack_engine_t* engine);
@@ -2157,6 +2158,7 @@ jack_engine_new (int realtime, int rtpriority,
 	engine->control->do_mlock = do_mlock;
 	engine->control->do_munlock = do_unlock;
 	engine->control->cpu_load = 0;
+	engine->control->xrun_delayed_usecs = 0;
  
 	engine->control->buffer_size = 0;
 	jack_transport_init (engine);
@@ -2270,11 +2272,14 @@ jack_start_watchdog (jack_engine_t *engine)
 }
 
 static void
-jack_engine_notify_clients_about_delay (jack_engine_t *engine)
+jack_engine_notify_clients_about_delay (jack_engine_t *engine,
+					float delayed_usecs)
 {
 	JSList *node;
 	jack_event_t event;
 
+	engine->control->xrun_delayed_usecs = delayed_usecs;
+
 	event.type = XRun;
 
 	jack_lock_graph (engine);
@@ -2435,8 +2440,8 @@ jack_run_one_cycle (jack_engine_t *engine, jack_nframes_t nframes,
 				    "... engine pausing");
 			return -1;	/* will exit the thread loop */
 		}
-		
-		jack_engine_notify_clients_about_delay (engine);
+
+		jack_engine_notify_clients_about_delay (engine, delayed_usecs);
 		
 		return 0;
 
@@ -2585,6 +2590,9 @@ jack_engine_delete (jack_engine_t *engine)
 	}
 #endif
 
+	VERBOSE (engine, "last xrun delay: %.3f usecs\n",
+		engine->control->xrun_delayed_usecs);
+
 	/* free engine control shm segment */
 	engine->control = NULL;
 	VERBOSE (engine, "freeing engine shared memory\n");

libjack/ChangeLog

@@ -1,3 +1,7 @@
+2004-10-14  Jack O'Quin  <joq@io.com>
+
+	* new API function: jack_get_xrun_delayed_usecs()
+
 2004-10-08  Jack O'Quin  <joq@io.com>
 
 	* new API functions: jack_client_open(), jack_get_client_name()

libjack/client.c

@@ -1871,6 +1871,12 @@ jack_cpu_load (jack_client_t *client)
 	return client->engine->cpu_load;
 }
 
+float
+jack_get_xrun_delayed_usecs (jack_client_t *client)
+{
+	return client->engine->xrun_delayed_usecs;
+}
+
 pthread_t
 jack_client_thread_id (jack_client_t *client)
 {