summaryrefslogtreecommitdiffstats
path: root/apps/voice_thread.c
diff options
context:
space:
mode:
authorMichael Sevakis <jethead71@rockbox.org>2007-11-18 17:12:19 +0000
committerMichael Sevakis <jethead71@rockbox.org>2007-11-18 17:12:19 +0000
commit99617d71bad0e5870a38e37c8654e46868e2a5ba (patch)
treee0ecc3b73e8e167c7f5bf00a6c88b83c1119aea3 /apps/voice_thread.c
parent75432619e8be2f22f86ed0869d46bf7245c7c14d (diff)
downloadrockbox-99617d71bad0e5870a38e37c8654e46868e2a5ba.tar.gz
rockbox-99617d71bad0e5870a38e37c8654e46868e2a5ba.tar.bz2
rockbox-99617d71bad0e5870a38e37c8654e46868e2a5ba.zip
Make speex the new voice format for SWCODEC targets (non-Archos). Remove codec swapping and build speex voice decoding directly into the core binary.
git-svn-id: svn://svn.rockbox.org/rockbox/trunk@15668 a1c6a512-1295-4272-9138-f99709370657
Diffstat (limited to 'apps/voice_thread.c')
-rw-r--r--apps/voice_thread.c444
1 files changed, 444 insertions, 0 deletions
diff --git a/apps/voice_thread.c b/apps/voice_thread.c
new file mode 100644
index 0000000000..8792d1c752
--- /dev/null
+++ b/apps/voice_thread.c
@@ -0,0 +1,444 @@
+/***************************************************************************
+ * __________ __ ___.
+ * Open \______ \ ____ ____ | | _\_ |__ _______ ___
+ * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
+ * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
+ * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
+ * \/ \/ \/ \/ \/
+ * $Id$
+ *
+ * Copyright (C) 2007 Michael Sevakis
+ *
+ * All files in this archive are subject to the GNU General Public License.
+ * See the file COPYING in the source tree root for full license agreement.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ****************************************************************************/
+#include "system.h"
+#include "thread.h"
+#include "logf.h"
+#include "voice_thread.h"
+#include "talk.h"
+#include "dsp.h"
+#include "audio.h"
+#include "pcmbuf.h"
+#include "codecs/libspeex/speex/speex.h"
+
+/* Define any of these as "1" to log regular and/or timeout messages */
+#define VOICE_LOGQUEUES 0
+#define VOICE_LOGQUEUES_SYS_TIMEOUT 0
+
+#if VOICE_LOGQUEUES
+#define LOGFQUEUE logf
+#else
+#define LOGFQUEUE(...)
+#endif
+
+#if VOICE_LOGQUEUES_SYS_TIMEOUT
+#define LOGFQUEUE_SYS_TIMEOUT logf
+#else
+#define LOGFQUEUE_SYS_TIMEOUT(...)
+#endif
+
+#ifndef IBSS_ATTR_VOICE_STACK
+#define IBSS_ATTR_VOICE_STACK IBSS_ATTR
+#endif
+
+#define VOICE_FRAME_SIZE 320 /* Samples / frame */
+#define VOICE_SAMPLE_RATE 16000 /* Sample rate in HZ */
+#define VOICE_SAMPLE_DEPTH 16 /* Sample depth in bits */
+
+/* Voice thread variables */
+static struct thread_entry *voice_thread_p = NULL;
+static long voice_stack[0x740/sizeof(long)] IBSS_ATTR_VOICE_STACK;
+static const char voice_thread_name[] = "voice";
+
+/* Voice thread synchronization objects */
+static struct event_queue voice_queue NOCACHEBSS_ATTR;
+static struct mutex voice_mutex NOCACHEBSS_ATTR;
+static struct event voice_event NOCACHEBSS_ATTR;
+static struct queue_sender_list voice_queue_sender_list NOCACHEBSS_ATTR;
+
+/* Buffer for decoded samples */
+static spx_int16_t voice_output_buf[VOICE_FRAME_SIZE] CACHEALIGN_ATTR;
+
+enum voice_thread_states
+{
+ TSTATE_STOPPED = 0, /* Voice thread is stopped and awaiting commands */
+ TSTATE_DECODE, /* Voice is decoding a clip */
+ TSTATE_BUFFER_INSERT, /* Voice is sending decoded audio to PCM */
+};
+
+enum voice_thread_messages
+{
+ Q_VOICE_NULL = 0, /* A message for thread sync - no effect on state */
+ Q_VOICE_PLAY, /* Play a clip */
+ Q_VOICE_STOP, /* Stop current clip */
+ Q_VOICE_STATE, /* Query playing state */
+};
+
+/* Structure to store clip data callback info */
+struct voice_info
+{
+ pcm_more_callback_type get_more; /* Callback to get more clips */
+ unsigned char *start; /* Start of clip */
+ ssize_t size; /* Size of clip */
+};
+
+/* Private thread data for its current state that must be passed to its
+ * internal functions */
+struct voice_thread_data
+{
+ int state; /* Thread state (TSTATE_*) */
+ struct queue_event ev; /* Last queue event pulled from queue */
+ void *st; /* Decoder instance */
+ SpeexBits bits; /* Bit cursor */
+ struct dsp_config *dsp; /* DSP used for voice output */
+ struct voice_info vi; /* Copy of clip data */
+ const char *src[2]; /* Current output buffer pointers */
+ int lookahead; /* Number of samples to drop at start of clip */
+ int count; /* Count of samples remaining to send to PCM */
+};
+
+/* Audio playback is in a playing state? */
+static inline bool playback_is_playing(void)
+{
+ return (audio_status() & AUDIO_STATUS_PLAY) != 0;
+}
+
+/* Stop any current clip and start playing a new one */
+void mp3_play_data(const unsigned char* start, int size,
+ pcm_more_callback_type get_more)
+{
+ /* Shared struct to get data to the thread - once it replies, it has
+ * safely cached it in its own private data */
+ static struct voice_info voice_clip NOCACHEBSS_ATTR;
+
+ if (get_more != NULL && start != NULL && size > 0)
+ {
+ mutex_lock(&voice_mutex);
+
+ voice_clip.get_more = get_more;
+ voice_clip.start = (unsigned char *)start;
+ voice_clip.size = size;
+ LOGFQUEUE("mp3 >| voice Q_VOICE_PLAY");
+ queue_send(&voice_queue, Q_VOICE_PLAY, (intptr_t)&voice_clip);
+
+ mutex_unlock(&voice_mutex);
+ }
+}
+
+/* Stop current voice clip from playing */
+void mp3_play_stop(void)
+{
+ mutex_lock(&voice_mutex); /* Sync against voice_stop */
+
+ LOGFQUEUE("mp3 >| voice Q_VOICE_STOP: 1");
+ queue_send(&voice_queue, Q_VOICE_STOP, 1);
+
+ mutex_unlock(&voice_mutex);
+}
+
+void mp3_play_pause(bool play)
+{
+ /* a dummy */
+ (void)play;
+}
+
+/* Tell is voice is still in a playing state */
+bool mp3_is_playing(void)
+{
+ /* TODO: Implement a timeout or state query function for event objects */
+ LOGFQUEUE("mp3 >| voice Q_VOICE_STATE");
+ int state = queue_send(&voice_queue, Q_VOICE_STATE, 0);
+ return state != TSTATE_STOPPED;
+}
+
+/* This function is meant to be used by the buffer request functions to
+ ensure the codec is no longer active */
+void voice_stop(void)
+{
+ mutex_lock(&voice_mutex);
+
+ /* Stop the output and current clip */
+ mp3_play_stop();
+
+ /* Careful if using sync objects in talk.c - make sure locking order is
+ * observed with one or the other always granted first */
+
+ /* Unqueue all future clips */
+ talk_force_shutup();
+
+ mutex_unlock(&voice_mutex);
+} /* voice_stop */
+
+/* Wait for voice to finish speaking. */
+void voice_wait(void)
+{
+ /* NOTE: One problem here is that we can't tell if another thread started a
+ * new clip by the time we wait. This should be resolvable if conditions
+ * ever require knowing the very clip you requested has finished. */
+ event_wait(&voice_event, STATE_SIGNALED);
+}
+
+/* Initialize voice thread data that must be valid upon starting and the
+ * setup the DSP parameters */
+static void voice_data_init(struct voice_thread_data *td)
+{
+ td->state = TSTATE_STOPPED;
+ td->dsp = (struct dsp_config *)dsp_configure(NULL, DSP_MYDSP,
+ CODEC_IDX_VOICE);
+
+ dsp_configure(td->dsp, DSP_RESET, 0);
+ dsp_configure(td->dsp, DSP_SET_FREQUENCY, VOICE_SAMPLE_RATE);
+ dsp_configure(td->dsp, DSP_SET_SAMPLE_DEPTH, VOICE_SAMPLE_DEPTH);
+ dsp_configure(td->dsp, DSP_SET_STEREO_MODE, STEREO_MONO);
+}
+
+/* Voice thread message processing */
+static void voice_message(struct voice_thread_data *td)
+{
+ while (1)
+ {
+ switch (td->ev.id)
+ {
+ case Q_VOICE_PLAY:
+ LOGFQUEUE("voice < Q_VOICE_PLAY");
+ /* Put up a block for completion signal */
+ event_set_state(&voice_event, STATE_NONSIGNALED);
+
+ /* Copy the clip info */
+ td->vi = *(struct voice_info *)td->ev.data;
+
+ /* Be sure audio buffer is initialized */
+ audio_restore_playback(AUDIO_WANT_VOICE);
+
+ /* We need nothing more from the sending thread - let it run */
+ queue_reply(&voice_queue, 1);
+
+ if (td->state == TSTATE_STOPPED)
+ {
+ /* Boost CPU now */
+ trigger_cpu_boost();
+ }
+ else if (!playback_is_playing())
+ {
+ /* Just voice, stop any clip still playing */
+ pcmbuf_play_stop();
+ }
+
+ /* Clean-start the decoder */
+ td->st = speex_decoder_init(&speex_wb_mode);
+
+ /* Make bit buffer use our own buffer */
+ speex_bits_set_bit_buffer(&td->bits, td->vi.start, td->vi.size);
+ speex_decoder_ctl(td->st, SPEEX_GET_LOOKAHEAD, &td->lookahead);
+
+ td->state = TSTATE_DECODE;
+ return;
+
+ case Q_VOICE_STOP:
+ LOGFQUEUE("voice < Q_VOICE_STOP: %d", ev.data);
+
+ if (td->ev.data != 0 && !playback_is_playing())
+ {
+ /* If not playing, it's just voice so stop pcm playback */
+ pcmbuf_play_stop();
+ }
+
+ /* Cancel boost */
+ sleep(0);
+
+ td->state = TSTATE_STOPPED;
+ event_set_state(&voice_event, STATE_SIGNALED);
+ break;
+
+ case Q_VOICE_STATE:
+ LOGFQUEUE("voice < Q_VOICE_STATE");
+ queue_reply(&voice_queue, td->state);
+
+ if (td->state == TSTATE_STOPPED)
+ break; /* Not in a playback state */
+
+ return;
+
+ default:
+ /* Default messages get a reply and thread continues with no
+ * state transition */
+ LOGFQUEUE("voice < default");
+
+ if (td->state == TSTATE_STOPPED)
+ break; /* Not in playback state */
+
+ queue_reply(&voice_queue, 0);
+ return;
+ }
+
+ queue_wait(&voice_queue, &td->ev);
+ }
+}
+
+/* Voice thread entrypoint */
+static void voice_thread(void)
+{
+ struct voice_thread_data td;
+
+ voice_data_init(&td);
+
+ goto message_wait;
+
+ while (1)
+ {
+ td.state = TSTATE_DECODE;
+
+ if (!queue_empty(&voice_queue))
+ {
+ message_wait:
+ queue_wait(&voice_queue, &td.ev);
+
+ message_process:
+ voice_message(&td);
+
+ /* Branch to initial start point or branch back to previous
+ * operation if interrupted by a message */
+ switch (td.state)
+ {
+ case TSTATE_DECODE: goto voice_decode;
+ case TSTATE_BUFFER_INSERT: goto buffer_insert;
+ default: goto message_wait;
+ }
+ }
+
+ voice_decode:
+ /* Check if all data was exhausted for this clip */
+ if (speex_bits_remaining(&td.bits) < 8)
+ {
+ voice_error:
+ /* Get next clip */
+ td.vi.size = 0;
+
+ if (td.vi.get_more != NULL)
+ td.vi.get_more(&td.vi.start, &td.vi.size);
+
+ if (td.vi.start != NULL && td.vi.size > 0)
+ {
+ /* Make bit buffer use our own buffer */
+ speex_bits_set_bit_buffer(&td.bits, td.vi.start, td.vi.size);
+ speex_decoder_ctl(td.st, SPEEX_GET_LOOKAHEAD, &td.lookahead);
+
+ yield();
+
+ if (!queue_empty(&voice_queue))
+ goto message_wait;
+ else
+ goto voice_decode;
+ }
+
+ /* If all clips are done and not playing, force pcm playback. */
+ if (!pcm_is_playing())
+ pcmbuf_play_start();
+
+ /* Synthesize a stop request */
+ /* NOTE: We have no way to know when the pcm data placed in the
+ * buffer is actually consumed and playback has reached the end
+ * so until the info is available or inferred somehow, this will
+ * not be accurate and the stopped signal will come too soon.
+ * ie. You may not hear the "Shutting Down" splash even though
+ * it waits for voice to stop. */
+ td.ev.id = Q_VOICE_STOP;
+ td.ev.data = 0; /* Let PCM drain by itself */
+ yield();
+ goto message_process;
+ }
+
+ /* Decode the data */
+ int status = speex_decode_int(td.st, &td.bits, voice_output_buf);
+ yield();
+
+ if (status == -2)
+ goto voice_error; /* error - try some more */
+
+ /* Output the decoded frame */
+ td.count = VOICE_FRAME_SIZE - td.lookahead;
+ td.src[0] = (const char *)&voice_output_buf[td.lookahead];
+ td.src[1] = NULL;
+ td.lookahead -= MIN(VOICE_FRAME_SIZE, td.lookahead);
+
+ buffer_insert:
+ /* Process the PCM samples in the DSP and send out for mixing */
+ td.state = TSTATE_BUFFER_INSERT;
+
+ while (td.count > 0)
+ {
+ int out_count = dsp_output_count(td.dsp, td.count);
+ int inp_count;
+ char *dest;
+
+ while (1)
+ {
+ if (!queue_empty(&voice_queue))
+ goto message_wait;
+
+ if ((dest = pcmbuf_request_voice_buffer(&out_count)) != NULL)
+ break;
+
+ yield();
+ }
+
+ /* Get the real input_size for output_size bytes, guarding
+ * against resampling buffer overflows. */
+ inp_count = dsp_input_count(td.dsp, out_count);
+
+ if (inp_count <= 0)
+ break;
+
+ /* Input size has grown, no error, just don't write more than
+ * length */
+ if (inp_count > td.count)
+ inp_count = td.count;
+
+ out_count = dsp_process(td.dsp, dest, td.src, inp_count);
+
+ if (out_count <= 0)
+ break;
+
+ pcmbuf_write_voice_complete(out_count);
+ td.count -= inp_count;
+ }
+
+ yield();
+ } /* end while */
+} /* voice_thread */
+
+/* Initialize all synchronization objects create the thread */
+void voice_thread_init(void)
+{
+ logf("Starting voice thread");
+ queue_init(&voice_queue, false);
+ queue_enable_queue_send(&voice_queue, &voice_queue_sender_list);
+ mutex_init(&voice_mutex);
+ event_init(&voice_event, STATE_SIGNALED | EVENT_MANUAL);
+ voice_thread_p = create_thread(voice_thread, voice_stack,
+ sizeof(voice_stack), CREATE_THREAD_FROZEN,
+ voice_thread_name IF_PRIO(, PRIORITY_PLAYBACK) IF_COP(, CPU));
+} /* voice_thread_init */
+
+/* Unfreeze the voice thread */
+void voice_thread_resume(void)
+{
+ logf("Thawing voice thread");
+ thread_thaw(voice_thread_p);
+ /* Wait for initialization to complete (a very short wait until the
+ * voice thread is available to process messages) */
+ queue_send(&voice_queue, Q_VOICE_NULL, 0);
+}
+
+#ifdef HAVE_PRIORITY_SCHEDULING
+/* Set the voice thread priority */
+void voice_thread_set_priority(int priority)
+{
+ thread_set_priority(voice_thread_p, priority);
+}
+#endif