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,11 +65,19 @@
 
 #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
+
 /*! \brief Common options between the Jack() app and JACK_HOOK() function */
 #define COMMON_OPTIONS \
 "    s(<name>) - Connect to the specified jack server name.\n" \
+"    r(<size>) - Size of the ringbuffer - multiples of 320 will make you happy.\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" \
@@ -86,6 +99,17 @@
 							<para>Connect to the specified jack server name</para>
 						</argument>
 					</option>
+					<option name="r">
+						<argument name="name" 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="i">
 						<argument name="name" required="true">
 							<para>Connect the output port that gets created to the specified jack input port</para>
@@ -134,6 +158,7 @@
 	unsigned int stop:1;
 	unsigned int has_audiohook:1;
 	unsigned int no_start_server:1;
+	unsigned int rb_size;
 	/*! Only used with JACK_HOOK */
 	struct ast_audiohook audiohook;
 };
@@ -200,17 +225,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 +255,86 @@
 }
 
 /*!
+ * \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)
+{
+
+        /* We need to write to the buffer, new data had precedence over stale one: if there is not */
+        /* enough space to write to the buffer, we make space by reading off the amount of data we */
+        /* want to insert. Using this tecnique we make sure that the data stays in sync, since  if */
+        /* it doesn't the channels may receive noise due to the misalignment of the sample data.   */
+
+        int available = jack_ringbuffer_write_space(rb);
+        if ( available < datalen ) {
+		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 time, 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, "Reset the %s RB - writing the last %d of %d bytes of data.\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.
+
+			jack_ringbuffer_reset(rb);
+
+			// The following code is a testament to my being naive. What
+			// would happen is that the system would be constantly underunning
+			// the buffer wasting CPU cycles that would be better used by
+			// doing our job.
+			// Feel free to uncomment the code and see for yourself why
+			// being too clever ends up being too stupid.
+
+			/*
+                	int tofree = datalen - available;
+
+                	if ( tofree & 0x01 ) {
+                        	// We should always keep the parity of the buffer,
+                        	// if we only drop one byte parity is gone and 
+                        	// noise is the result. 
+                        	tofree = tofree + 1;
+                	}
+			if ( tofree >= datalen ) {
+				// Severe buffer underrun. Reset the buffer, it may be a good
+				// choice in the long run, avoiding a continuous underrun.
+				jack_ringbuffer_reset(rb);
+                		ast_log(LOG_WARNING, "%s RB has been reset for a %d block of data\n", name, datalen);
+			}
+			else {
+				// Normal buffer underrun, just clear what we need
+                		char bufout[tofree];
+                		int readout = jack_ringbuffer_read(rb, bufout, 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);
+			}
+			*/
+
+		}
+        }
+
+        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 +352,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 +378,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");
+
+	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 +411,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 +507,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 +629,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 +637,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 +671,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");
 	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 +719,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 +758,7 @@
 	OPT_OUTPUT_PORT =    (1 << 2),
 	OPT_NOSTART_SERVER = (1 << 3),
 	OPT_CLIENT_NAME =    (1 << 4),
+	OPT_RB_SIZE =        (1 << 5),
 };
 
 enum {
@@ -659,6 +766,7 @@
 	OPT_ARG_INPUT_PORT,
 	OPT_ARG_OUTPUT_PORT,
 	OPT_ARG_CLIENT_NAME,
+	OPT_ARG_RB_SIZE,
 
 	/* Must be the last element */
 	OPT_ARG_ARRAY_SIZE,
@@ -666,6 +774,7 @@
 
 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),
@@ -705,6 +814,25 @@
 		}
 	}
 
+	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_SERVER_NAME]);
+				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);
+
 	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]);
@@ -817,7 +945,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 +967,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;