multithreading

Make espeakup a multi-threaded program.  One thread reads from the softsynth
device, queuing text and synthesis commands.  The other thread processes
items from the queue.

queue.c

@@ -21,9 +21,13 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <pthread.h>
 
 #include "espeakup.h"
 
+pthread_cond_t runner_awake = PTHREAD_COND_INITIALIZER;
+pthread_mutex_t queue_guard = PTHREAD_MUTEX_INITIALIZER;
+
 struct queue_entry_t {
 	enum command_t cmd;
 	enum adjust_t adjust;
@@ -38,6 +42,7 @@ static struct queue_entry_t *last = NULL;
 
 static void queue_add(struct queue_entry_t *entry)
 {
+	pthread_mutex_lock(&queue_guard);
 	assert(entry);
 	entry->next = NULL;
 	if (!last)
@@ -48,26 +53,45 @@ static void queue_add(struct queue_entry_t *entry)
 		first->next = entry;
 		first = first->next;
 	}
+	pthread_mutex_unlock(&queue_guard);
+	pthread_cond_signal(&runner_awake);
 }
 
-static void queue_remove(void)
+static void free_entry(struct queue_entry_t *entry)
 {
-	struct queue_entry_t *temp;
+	if (entry->cmd == CMD_SPEAK_TEXT)
+		free(entry->buf);
+	free(entry);
+}
 
-	assert(last);
-	temp = last;
-	last = temp->next;
-	if (temp->cmd == CMD_SPEAK_TEXT)
-		free(temp->buf);
-	free(temp);
-	if (!last)
-		first = last;
+/* Remove and return the entry at the head of the queue.
+ * Return NULL if queue is empty. */
+
+static struct queue_entry_t *queue_remove(void)
+{
+	struct queue_entry_t *temp = NULL;
+
+	if(last) {
+		temp = last;
+		last = temp->next;
+
+		if (!last)
+			first = last;
+	}
+
+	return temp;
 }
 
 void queue_clear(void)
 {
-	while (last)
-		queue_remove();
+	pthread_mutex_lock(&queue_guard);
+	while (last) {
+		struct queue_entry_t *entry = queue_remove();
+		if(entry)
+			free_entry(entry);
+	}
+	pthread_mutex_unlock(&queue_guard);
+	/* We aren't adding data to the queue, so no need to signal. */
 }
 
 void queue_add_cmd(enum command_t cmd, enum adjust_t adj, int value)
@@ -106,39 +130,76 @@ void queue_add_text(char *txt, size_t length)
 	queue_add(entry);
 }
 
-void queue_process_entry(struct synth_t *s)
+static void queue_process_entry(struct synth_t *s)
 {
 	espeak_ERROR error;
+	struct queue_entry_t *current = queue_remove();
 
-	if (!last)
-		return;
+	pthread_mutex_unlock(&queue_guard); /* So "reader" can go. */
 
-	switch (last->cmd) {
-	case CMD_SET_FREQUENCY:
-		error = set_frequency(s, last->value, last->adjust);
-		break;
-	case CMD_SET_PITCH:
-		error = set_pitch(s, last->value, last->adjust);
-		break;
-	case CMD_SET_PUNCTUATION:
-		error = set_punctuation(s, last->value, last->adjust);
-		break;
-	case CMD_SET_RATE:
-		error = set_rate(s, last->value, last->adjust);
-		break;
-	case CMD_SET_VOICE:
-		break;
-	case CMD_SET_VOLUME:
-		error = set_volume(s, last->value, last->adjust);
-		break;
-	case CMD_SPEAK_TEXT:
-		s->buf = last->buf;
-		s->len = last->len;
-		error = speak_text(s);
-		break;
-	default:
-		break;
+	if(current) {
+		switch (current->cmd) {
+		case CMD_SET_FREQUENCY:
+			error = set_frequency(s, current->value, current->adjust);
+			break;
+		case CMD_SET_PITCH:
+			error = set_pitch(s, current->value, current->adjust);
+			break;
+		case CMD_SET_PUNCTUATION:
+			error = set_punctuation(s, current->value, current->adjust);
+			break;
+		case CMD_SET_RATE:
+			error = set_rate(s, current->value, current->adjust);
+			break;
+		case CMD_SET_VOICE:
+			break;
+		case CMD_SET_VOLUME:
+			error = set_volume(s, current->value, current->adjust);
+			break;
+		case CMD_SPEAK_TEXT:
+			s->buf = current->buf;
+			s->len = current->len;
+			error = speak_text(s);
+			break;
+		default:
+			break;
+		}
+
+		free_entry(current);
 	}
-	if (error == EE_OK)
-		queue_remove();
+}
+
+/* queue_runner is the "main" function of our secondary (queue-processing)
+ * thread.
+ * First, lock queue_guard, because it needs to be locked when we call
+ * pthread_cond_wait on the runner_awake condition variable.
+ * Next, enter an infinite loop.
+ * The wait call also unlocks queue_guard, so that the other thread can
+ * manipulate the queue.
+ * When runner_awake is signaled, the pthread_cond_wait call re-locks
+ * queue_guard, and the "queue processor" thread has access to the queue.
+ * While there is an entry in the queue, call queue_process_entry.
+ * queue_process_entry unlocks queue_guard after removing an item from the
+ * queue, so that the main thread doesn't have to wait for us to finish
+ * processing the entry.  So re-lock queue_guard after each call to
+ * queue_process_entry.
+ *
+ * The main thread can add items to the queue in exactly two situations:
+ * 1. We are waiting on runner_awake, or
+ * 2. We are processing an entry that has just been removed from the queue.
+*/
+
+void *queue_runner(void *arg) {
+	struct synth_t *synth = (struct synth_t *) arg;
+		pthread_mutex_lock(&queue_guard);
+	while(1) {
+		pthread_cond_wait(&runner_awake, &queue_guard);
+
+		while(last) {
+			queue_process_entry(synth);
+			pthread_mutex_lock(&queue_guard);
+		}
+	}
+
+	return NULL;
 }