Index: app_jack.c
===================================================================
--- app_jack.c	(revision 274530)
+++ app_jack.c	(working copy)
@@ -21,6 +21,7 @@
  * \brief Jack Application
  *
  * \author Russell Bryant <russell@digium.com>
+ * \author Fabio Torchetti <mrwho@wedjaa.net>
  *
  * This is an application to connect an Asterisk channel to an input
  * and output jack port so that the audio can be processed through
@@ -39,6 +40,10 @@
 	<depend>resample</depend>
  ***/
 
+#include <sys/types.h> 
+#include <sys/stat.h> 
+#include <fcntl.h>
+
 #include "asterisk.h"
 
 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
@@ -60,19 +65,41 @@
 
 #define RESAMPLE_QUALITY 1
 
-#define RINGBUFFER_SIZE 16384
+/* The bigger the buffer size is, the more delay will be introduced  */
+/* in the conversation. Make sure that you set the period of Jack to */
+/* multiples of 80 (which is 80*4=320 bytes => the frame size of     */
+/* asterisk) for better performance and quality.                     */
+#define RINGBUFFER_SIZE 1280
 
+/* Asterisk core native rate is 8KHz                                */
+#define NATIVE_RATE	8000.0
+
+/* Number of bytes in a frame sample                                */
+#define FRAME_SAMPLE_SIZE	4
+
+/* The different ringbuffer overrun handling algorithms		    */
+enum {
+	RB_UNDEFINED = 0,
+	RB_DROP,
+	RB_ALLOCATE,
+	RB_FLEXIBLE,
+};
+
 /*! \brief Common options between the Jack() app and JACK_HOOK() function */
 #define COMMON_OPTIONS \
-"    s(<name>) - Connect to the specified jack server name.\n" \
-"    i(<name>) - Connect the output port that gets created to the specified\n" \
-"                jack input port.\n" \
-"    o(<name>) - Connect the input port that gets created to the specified\n" \
-"                jack output port.\n" \
-"    n         - Do not automatically start the JACK server if it is not already\n" \
-"                running.\n" \
-"    c(<name>) - By default, Asterisk will use the channel name for the jack client\n" \
-"                name.  Use this option to specify a custom client name.\n"
+"    s(<name>)  - Connect to the specified jack server name.\n" \
+"    r(<size>)  - Size of the ringbuffer - multiples of 320 will make you happy.\n" \
+"    d          - Drop ringbuffer when filled [Default].\n" \
+"    e          - Empty enough ringbuffer when filled.\n" \
+"    t(<limit>) - Empty enough buffer <limit> consecutive times then drop it.\n" \
+"    i(<name>)  - Connect the output port that gets created to the specified\n" \
+"                 jack input port.\n" \
+"    o(<name>)  - Connect the input port that gets created to the specified\n" \
+"                 jack output port.\n" \
+"    n          - Do not automatically start the JACK server if it is not already\n" \
+"                 running.\n" \
+"    c(<name>)  - By default, Asterisk will use the channel name for the jack client\n" \
+"                 name.  Use this option to specify a custom client name.\n"
 /*** DOCUMENTATION
 	<application name="JACK" language="en_US">
 		<synopsis>
@@ -86,6 +113,37 @@
 							<para>Connect to the specified jack server name</para>
 						</argument>
 					</option>
+					<option name="r">
+						<argument name="size" required="true">
+							<para>Size of the ringbuffer to use, multiples of 320 work better.</para>
+							<para>Choose a period for jack that's a multiple of 80. Say 160. This
+							means that every period jack will ask for 640 bytes - a multiple of
+							320 bytes - the asterisk frame size</para>
+							<para>The ringbuffer should be a multiple of the number of bytes that
+							jack will be asking at every period, so multiply the period bytes (640) by
+							3 and get an ideal ringbuffer size of 1920.</para>
+						</argument>
+					</option>
+					<option name="d">
+						<para>The ringbuffers will be cleared every time a buffer overrun occours. 
+							This is the default behaviour of app_jack.
+						</para>
+					</option>
+					<option name="e">
+						<para>
+							Every time the ringbuffers will overrun enough space will be made by dropping
+							the older data in the buffer.
+						</para>
+					</option>
+					<option name="t">
+						<argument name="limit" required="true">
+							<para>With this option when the ringbuffers overrun app_jack will check
+								how many consecutive times it has happened. If the buffers overrun
+								more than <limit> times in a row it will empty the buffers and 
+								start over.
+							</para>
+						</argument>
+					</option>
 					<option name="i">
 						<argument name="name" required="true">
 							<para>Connect the output port that gets created to the specified jack input port</para>
@@ -134,6 +192,11 @@
 	unsigned int stop:1;
 	unsigned int has_audiohook:1;
 	unsigned int no_start_server:1;
+	/* Used in the buffer overrun handling */
+	unsigned int rb_size;
+	unsigned int rb_handling;
+	unsigned int rb_overruns;
+	unsigned int rb_maxoverruns;
 	/*! Only used with JACK_HOOK */
 	struct ast_audiohook audiohook;
 };
@@ -200,17 +263,16 @@
 
 	jack_srate = jack_get_sample_rate(jack_data->client);
 
-	/* XXX Hard coded 8 kHz */
+	to_srate = input ? NATIVE_RATE : jack_srate;
+	from_srate = input ? jack_srate : NATIVE_RATE;
 
-	to_srate = input ? 8000.0 : jack_srate;
-	from_srate = input ? jack_srate : 8000.0;
-
 	resample_factor = input ? &jack_data->input_resample_factor :
 		&jack_data->output_resample_factor;
 
 	if (from_srate == to_srate) {
 		/* Awesome!  The jack sample rate is the same as ours.
 		 * Resampling isn't needed. */
+		ast_debug(1, "No resampling in use.\n");
 		*resample_factor = 1.0;
 		return 0;
 	}
@@ -231,6 +293,129 @@
 }
 
 /*!
+ * \brief Clear enough data from the ringbuffer to allocate at least 'tofree' bytes
+ *
+ * This function will read out of the ringbuffer at least 'tofree' bytes, making
+ * sure to read out entire frame samples to avoid corruption of the sound data.
+ *
+ */
+
+static int ringbuffer_free(jack_ringbuffer_t *rb, int tofree)
+{
+
+  /* Increase tofree until it is a multiple of the frame sample size */
+  while ( tofree % FRAME_SAMPLE_SIZE ) {
+ 	tofree = tofree + 1;
+  }
+
+  char bufout[tofree];
+
+  /* Read out the data from the ringbuffer */
+  return jack_ringbuffer_read(rb, bufout, tofree);
+
+}
+
+/*!
+ * \brief Writes data to the ringbuffer, dropping stale data 
+ *
+ * Copies 'datalen' bytes of 'data' to the ringbuffer. If the ringbuffer
+ * doesn't have enough space it will make space by dropping stale data.
+ *
+ */
+static int ringbuffer_write(jack_ringbuffer_t *rb, const char * data, int datalen, const char * name, struct jack_data * jack_data)
+{
+
+
+	/* Chech for space available in the ringbuffer */
+        int available = jack_ringbuffer_write_space(rb);
+
+        if ( available < datalen ) {
+		/* We don't have enough space to write the new data */
+
+		if ( ( datalen - available ) > jack_ringbuffer_read_space(rb) ) {
+			/* A little problem here: the ringbuffer is smaller than the chunk
+			 * of data we want to write in it. What do we do? A simple solution 
+			 * is to put in the buffer only the top of the data, dropping the older
+			 * one as stale. NOTICE: this should never happen in real life, but we
+			 * want to be prepared for the worse.
+			 */
+			jack_ringbuffer_reset(rb);
+			available = jack_ringbuffer_write_space(rb);
+			if ( available & 0x01 ) {
+				available = available - 1;
+			}
+                	ast_log(LOG_WARNING, "The  %s RB is too small for incoming data- %d of %d bytes written. Increase RB size.\n", 
+					name, available, datalen);
+			data = &data[datalen-available];
+			datalen = available;
+		}
+		else {
+			/* Clean up the ringbuffer, it seems that the consumer is not
+			 * keeping up with us. We will loose some frames like this, but
+			 * in the long run it will be better for us.
+			 */
+			if ( jack_data->rb_handling == RB_DROP ) {
+
+				/* The simple way out: reset the ring buffer */
+				jack_ringbuffer_reset(rb);
+                		ast_log(LOG_WARNING, "Dropped %s "
+						"RB to make space for %d bytes.\n", name, datalen);
+			}
+
+			if ( jack_data->rb_handling == RB_ALLOCATE ) {
+
+				/* Just make enough space for us to write, just make 
+				 * sure we are cleaning up multiples of 4 bytes, the
+				 * size of an entire frame sample.
+				 */
+				int tofree = datalen - available;
+				int readout = ringbuffer_free(rb, tofree);
+                		ast_log(LOG_WARNING, "Dropped %d bytes (out of %d) from %s "
+						"RB to make space for %d bytes.\n", readout, tofree, name, datalen);
+			}
+
+			if ( jack_data->rb_handling == RB_FLEXIBLE ) {
+				if ( jack_data->rb_overruns >= jack_data->rb_maxoverruns ) {
+					/* We have surpassed the maximum number of consecutive
+					 * overruns we decided to cope with, time for a RB reset.
+					 */
+					jack_ringbuffer_reset(rb);
+					jack_data->rb_overruns = 0;
+                			ast_log(LOG_WARNING, "Dropped %s "
+						"RB to make space for %d bytes.\n", name, datalen);
+				}
+				else {
+					/* We still have some patience here, free enough data
+					 * to write what we need and move on 
+					 */
+					int tofree = datalen - available;
+					int readout = ringbuffer_free(rb, tofree);
+					jack_data->rb_overruns = jack_data->rb_overruns + 1;
+                			ast_log(LOG_WARNING, "Dropped %d bytes (out of %d) from %s "
+						"RB to make space for %d bytes.\n", readout, tofree, name, datalen);
+				}
+			}
+
+		}
+        }
+	else {
+		/* OK, I lied. We're not resetting simply because of one successful
+                 * write to the ringbuffer. The overrun count will be back to  0 after
+		 * we have had at least the same successful writes as we had overruns
+		 * before this one. This allows us not to flip-flop too often.
+		 */
+		if ( jack_data->rb_overruns > 0 ) {
+			jack_data->rb_overruns = jack_data->rb_overruns - 1;
+		}
+	}
+
+        int res = jack_ringbuffer_write(rb, data, datalen);
+
+	return res;
+}
+
+
+/*!
  * \brief Handle jack input port
  *
  * Read nframes number of samples from the input buffer, resample it
@@ -248,10 +433,8 @@
 	if (jack_data->input_resampler) {
 		int total_in_buf_used = 0;
 		int total_out_buf_used = 0;
-		float f_buf[nframes + 1];
+		float f_buf[nframes*2];
 
-		memset(f_buf, 0, sizeof(f_buf));
-
 		while (total_in_buf_used < nframes) {
 			int in_buf_used;
 			int out_buf_used;
@@ -276,21 +459,24 @@
 		}
 
 		for (i = 0; i < total_out_buf_used; i++)
-			s_buf[i] = f_buf[i] * (SHRT_MAX / 1.0);
+			s_buf[i] = ((float) f_buf[i]) * ((float) SHRT_MAX);
 
+
 		write_len = total_out_buf_used * sizeof(int16_t);
 	} else {
 		/* No resampling needed */
 
 		for (i = 0; i < nframes; i++)
-			s_buf[i] = in_buf[i] * (SHRT_MAX / 1.0);
+			s_buf[i] = ((float) in_buf[i]) * ((float) SHRT_MAX);
 	}
 
-	res = jack_ringbuffer_write(jack_data->input_rb, (const char *) s_buf, write_len);
-	if (res != write_len) {
-		ast_debug(2, "Tried to write %d bytes to the ringbuffer, but only wrote %d\n",
-			(int) sizeof(s_buf), (int) res);
+
+	res = ringbuffer_write(jack_data->input_rb, (const char *) s_buf, write_len, "input", jack_data);
+
+	if ( res < write_len ) {
+		ast_debug(5, "Could not write a %d bytes payload to input RB (Wrote: %d).\n", write_len, res);
 	}
+
 }
 
 /*!
@@ -306,10 +492,13 @@
 
 	len = nframes * sizeof(float);
 
+	// Fill with silence first
+	memset(buf,0,len);
+
 	res = jack_ringbuffer_read(jack_data->output_rb, buf, len);
 
 	if (len != res) {
-		ast_debug(2, "Wanted %d bytes to send to the output port, "
+		ast_debug(5, "Wanted %d bytes to send to the output port, "
 			"but only got %d\n", (int) len, (int) res);
 	}
 }
@@ -399,10 +588,10 @@
 		ast_channel_unlock(chan);
 	}
 
-	if (!(jack_data->output_rb = jack_ringbuffer_create(RINGBUFFER_SIZE)))
+	if (!(jack_data->output_rb = jack_ringbuffer_create(jack_data->rb_size)))
 		return -1;
 
-	if (!(jack_data->input_rb = jack_ringbuffer_create(RINGBUFFER_SIZE)))
+	if (!(jack_data->input_rb = jack_ringbuffer_create(jack_data->rb_size)))
 		return -1;
 
 	if (jack_data->no_start_server)
@@ -521,8 +710,6 @@
 	int16_t *s_buf = f->data.ptr;
 	size_t res;
 
-	memset(f_buf, 0, sizeof(f_buf));
-
 	if (!jack_data->output_resample_factor)
 		alloc_resampler(jack_data, 0);
 
@@ -531,10 +718,10 @@
 		int total_in_buf_used = 0;
 		int total_out_buf_used = 0;
 
-		memset(in_buf, 0, sizeof(in_buf));
+		// memset(f_buf, 0, sizeof(f_buf));
 
 		for (i = 0; i < f->samples; i++)
-			in_buf[i] = s_buf[i] * (1.0 / SHRT_MAX);
+			in_buf[i] = ((float) s_buf[i]) / ((float) SHRT_MAX);
 
 		while (total_in_buf_used < ARRAY_LEN(in_buf)) {
 			int in_buf_used;
@@ -565,14 +752,14 @@
 		/* No resampling needed */
 
 		for (i = 0; i < f->samples; i++)
-			f_buf[i] = s_buf[i] * (1.0 / SHRT_MAX);
+			f_buf[i] = ((float) s_buf[i]) / ((float) SHRT_MAX);
 
 		f_buf_used = f->samples;
 	}
 
-	res = jack_ringbuffer_write(jack_data->output_rb, (const char *) f_buf, f_buf_used * sizeof(float));
+	res = ringbuffer_write(jack_data->output_rb, (const char *) f_buf, f_buf_used * sizeof(float), "output", jack_data);
 	if (res != (f_buf_used * sizeof(float))) {
-		ast_debug(2, "Tried to write %d bytes to the ringbuffer, but only wrote %d\n",
+		ast_log(LOG_WARNING, "Tried to write %d bytes to the ringbuffer, but only wrote %d\n",
 			(int) (f_buf_used * sizeof(float)), (int) res);
 	}
 
@@ -613,17 +800,17 @@
 
 	for (;;) {
 		size_t res, read_len;
-		char *read_buf;
+		char * read_buf;
 
 		read_len = out_frame ? out_frame->datalen : sizeof(buf);
 		read_buf = out_frame ? out_frame->data.ptr : buf;
-
+		
 		res = jack_ringbuffer_read_space(jack_data->input_rb);
 
 		if (res < read_len) {
 			/* Not enough data ready for another frame, move on ... */
 			if (out_frame) {
-				ast_debug(1, "Sending an empty frame for the JACK_HOOK\n");
+				ast_debug(2, "Sending an empty frame for the JACK_HOOK\n");
 				memset(out_frame->data.ptr, 0, out_frame->datalen);
 			}
 			break;
@@ -652,6 +839,10 @@
 	OPT_OUTPUT_PORT =    (1 << 2),
 	OPT_NOSTART_SERVER = (1 << 3),
 	OPT_CLIENT_NAME =    (1 << 4),
+	OPT_RB_SIZE =        (1 << 5),
+	OPT_RB_DROP =        (1 << 6),
+	OPT_RB_ALLOCATE =    (1 << 7),
+	OPT_RB_FLEXIBLE =    (1 << 8),
 };
 
 enum {
@@ -659,6 +850,8 @@
 	OPT_ARG_INPUT_PORT,
 	OPT_ARG_OUTPUT_PORT,
 	OPT_ARG_CLIENT_NAME,
+	OPT_ARG_RB_SIZE,
+	OPT_ARG_RB_MAXRUNS,
 
 	/* Must be the last element */
 	OPT_ARG_ARRAY_SIZE,
@@ -666,9 +859,13 @@
 
 AST_APP_OPTIONS(jack_exec_options, BEGIN_OPTIONS
 	AST_APP_OPTION_ARG('s', OPT_SERVER_NAME, OPT_ARG_SERVER_NAME),
+	AST_APP_OPTION_ARG('r', OPT_RB_SIZE, OPT_ARG_RB_SIZE),
 	AST_APP_OPTION_ARG('i', OPT_INPUT_PORT, OPT_ARG_INPUT_PORT),
 	AST_APP_OPTION_ARG('o', OPT_OUTPUT_PORT, OPT_ARG_OUTPUT_PORT),
 	AST_APP_OPTION('n', OPT_NOSTART_SERVER),
+	AST_APP_OPTION('d', OPT_RB_DROP),
+	AST_APP_OPTION('e', OPT_RB_ALLOCATE),
+	AST_APP_OPTION_ARG('t', OPT_RB_FLEXIBLE, OPT_ARG_RB_MAXRUNS),
 	AST_APP_OPTION_ARG('c', OPT_CLIENT_NAME, OPT_ARG_CLIENT_NAME),
 END_OPTIONS );
 
@@ -705,6 +902,61 @@
 		}
 	}
 
+	if (ast_test_flag(&options, OPT_RB_SIZE)) {
+		if (!ast_strlen_zero(option_args[OPT_ARG_RB_SIZE])) {
+			if(sscanf(option_args[OPT_ARG_RB_SIZE], "%d", &jack_data->rb_size)  == EOF ) {
+				ast_log(LOG_ERROR, "The buffer size you specified (%s) can't be converted to a number\n",
+					option_args[OPT_ARG_RB_SIZE]);
+				return -1;
+			}
+		}
+		else {
+			ast_log(LOG_ERROR, "A buffer size must be provided with the r() option\n");
+			return -1;
+		}
+	}
+	else {
+		jack_data->rb_size = RINGBUFFER_SIZE;
+	}
+
+	ast_log(LOG_WARNING, "Jack ringbuffer size set to %d\n", jack_data->rb_size);
+
+	jack_data->rb_handling = RB_UNDEFINED;
+	
+	jack_data->rb_handling = ast_test_flag(&options, OPT_RB_DROP) ? RB_DROP : RB_UNDEFINED;
+
+	if ( jack_data->rb_handling != RB_UNDEFINED &&  ast_test_flag(&options, OPT_RB_ALLOCATE) ) {
+		ast_log(LOG_ERROR, "You can't specify both the 'd' and 'e' options!\n");
+		return -1;
+	}
+
+	jack_data->rb_handling = ast_test_flag(&options, OPT_RB_ALLOCATE) ? RB_ALLOCATE : RB_UNDEFINED;
+
+	if ( jack_data->rb_handling != RB_UNDEFINED &&  ast_test_flag(&options, OPT_RB_FLEXIBLE) ) {
+		ast_log(LOG_ERROR, "You can't specify more than one buffer handling option!\n");
+		return -1;
+	}
+
+	if (ast_test_flag(&options, OPT_RB_FLEXIBLE)) {
+		if (!ast_strlen_zero(option_args[OPT_ARG_RB_MAXRUNS])) {
+			if(sscanf(option_args[OPT_ARG_RB_MAXRUNS], "%d", &jack_data->rb_maxoverruns)  == EOF ) {
+				ast_log(LOG_ERROR, "The number of overruns you specified (%s) can't be converted to a number\n",
+					option_args[OPT_ARG_RB_MAXRUNS]);
+				return -1;
+			}
+			jack_data->rb_handling = RB_FLEXIBLE;
+			jack_data->rb_overruns = 0;
+		}
+		else {
+			ast_log(LOG_ERROR, "You must specify the maximun number of buffer overruns with the t() option.\n");
+			return -1;
+		}
+	}
+
+	if ( jack_data->rb_handling == RB_UNDEFINED ) {
+		jack_data->rb_handling = RB_DROP;
+	}
+	
 	if (ast_test_flag(&options, OPT_CLIENT_NAME)) {
 		if (!ast_strlen_zero(option_args[OPT_ARG_CLIENT_NAME]))
 			ast_string_field_set(jack_data, client_name, option_args[OPT_ARG_CLIENT_NAME]);
@@ -714,6 +966,7 @@
 		}
 	}
 
+
 	if (ast_test_flag(&options, OPT_INPUT_PORT)) {
 		if (!ast_strlen_zero(option_args[OPT_ARG_INPUT_PORT]))
 			ast_string_field_set(jack_data, connect_input_port, option_args[OPT_ARG_INPUT_PORT]);
@@ -817,7 +1070,7 @@
 	if (audiohook->status == AST_AUDIOHOOK_STATUS_DONE)
 		return 0;
 
-	if (direction != AST_AUDIOHOOK_DIRECTION_READ)
+	if (direction == AST_AUDIOHOOK_DIRECTION_READ)
 		return 0;
 
 	if (frame->frametype != AST_FRAME_VOICE)
@@ -839,10 +1092,9 @@
 
 	jack_data = datastore->data;
 
-	queue_voice_frame(jack_data, frame);
-
-	handle_jack_audio(chan, jack_data, frame);
-
+        queue_voice_frame(jack_data, frame);
+        handle_jack_audio(chan, jack_data, frame);
+  
 	ast_channel_unlock(chan);
 
 	return 0;