apps/voice_thread.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2007 Michael Sevakis
  11  *
  12  * All files in this archive are subject to the GNU General Public License.
  13  * See the file COPYING in the source tree root for full license agreement.
  14  *
  15  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  16  * KIND, either express or implied.
  17  *
  18  ****************************************************************************/
  19 #include "system.h"
  20 #include "thread.h"
  21 #include "logf.h"
  22 #include "voice_thread.h"
  23 #include "talk.h"
  24 #include "dsp.h"
  25 #include "audio.h"
  26 #include "pcmbuf.h"
  27 #include "codecs/libspeex/speex/speex.h"
  28
  29 /* Define any of these as "1" to log regular and/or timeout messages */
  30 #define VOICE_LOGQUEUES 0
  31 #define VOICE_LOGQUEUES_SYS_TIMEOUT 0
  32
  33 #if VOICE_LOGQUEUES
  34 #define LOGFQUEUE logf
  35 #else
  36 #define LOGFQUEUE(...)
  37 #endif
  38
  39 #if VOICE_LOGQUEUES_SYS_TIMEOUT
  40 #define LOGFQUEUE_SYS_TIMEOUT logf
  41 #else
  42 #define LOGFQUEUE_SYS_TIMEOUT(...)
  43 #endif
  44
  45 #ifndef IBSS_ATTR_VOICE_STACK
  46 #define IBSS_ATTR_VOICE_STACK IBSS_ATTR
  47 #endif
  48
  49 #define VOICE_FRAME_SIZE    320 /* Samples / frame */
  50 #define VOICE_SAMPLE_RATE 16000 /* Sample rate in HZ */
  51 #define VOICE_SAMPLE_DEPTH   16 /* Sample depth in bits */
  52
  53 /* Voice thread variables */
  54 static struct thread_entry *voice_thread_p = NULL;
  55 static long voice_stack[0x740/sizeof(long)] IBSS_ATTR_VOICE_STACK;
  56 static const char voice_thread_name[] = "voice";
  57
  58 /* Voice thread synchronization objects */
  59 static struct event_queue voice_queue NOCACHEBSS_ATTR;
  60 static struct mutex voice_mutex NOCACHEBSS_ATTR;
  61 static struct event voice_event NOCACHEBSS_ATTR;
  62 static struct queue_sender_list voice_queue_sender_list NOCACHEBSS_ATTR;
  63
  64 /* Buffer for decoded samples */
  65 static spx_int16_t voice_output_buf[VOICE_FRAME_SIZE] CACHEALIGN_ATTR;
  66
  67 enum voice_thread_states
  68 {
  69     TSTATE_STOPPED = 0,   /* Voice thread is stopped and awaiting commands */
  70     TSTATE_DECODE,        /* Voice is decoding a clip */
  71     TSTATE_BUFFER_INSERT, /* Voice is sending decoded audio to PCM */
  72 };
  73
  74 enum voice_thread_messages
  75 {
  76     Q_VOICE_NULL = 0, /* A message for thread sync - no effect on state */
  77     Q_VOICE_PLAY,     /* Play a clip */
  78     Q_VOICE_STOP,     /* Stop current clip */
  79     Q_VOICE_STATE,    /* Query playing state */
  80 };
  81
  82 /* Structure to store clip data callback info */
  83 struct voice_info
  84 {
  85     pcm_more_callback_type get_more; /* Callback to get more clips */
  86     unsigned char *start;            /* Start of clip */
  87     size_t size;                     /* Size of clip */
  88 };
  89
  90 /* Private thread data for its current state that must be passed to its
  91  * internal functions */
  92 struct voice_thread_data
  93 {
  94     int state;              /* Thread state (TSTATE_*) */
  95     struct queue_event ev;  /* Last queue event pulled from queue */
  96     void *st;               /* Decoder instance */
  97     SpeexBits bits;         /* Bit cursor */
  98     struct dsp_config *dsp; /* DSP used for voice output */
  99     struct voice_info vi;   /* Copy of clip data */
 100     const char *src[2];     /* Current output buffer pointers */
 101     int lookahead;          /* Number of samples to drop at start of clip */
 102     int count;              /* Count of samples remaining to send to PCM */
 103 };
 104
 105 /* Audio playback is in a playing state? */
 106 static inline bool playback_is_playing(void)
 107 {
 108     return (audio_status() & AUDIO_STATUS_PLAY) != 0;
 109 }
 110
 111 /* Stop any current clip and start playing a new one */
 112 void mp3_play_data(const unsigned char* start, int size,
 113                    pcm_more_callback_type get_more)
 114 {
 115     /* Shared struct to get data to the thread - once it replies, it has
 116      * safely cached it in its own private data */
 117     static struct voice_info voice_clip NOCACHEBSS_ATTR;
 118
 119     if (get_more != NULL && start != NULL && (ssize_t)size > 0)
 120     {
 121         mutex_lock(&voice_mutex);
 122
 123         voice_clip.get_more = get_more;
 124         voice_clip.start    = (unsigned char *)start;
 125         voice_clip.size     = size;
 126         LOGFQUEUE("mp3 >| voice Q_VOICE_PLAY");
 127         queue_send(&voice_queue, Q_VOICE_PLAY, (intptr_t)&voice_clip);
 128
 129         mutex_unlock(&voice_mutex);
 130     }
 131 }
 132
 133 /* Stop current voice clip from playing */
 134 void mp3_play_stop(void)
 135 {
 136     mutex_lock(&voice_mutex); /* Sync against voice_stop */
 137
 138     LOGFQUEUE("mp3 >| voice Q_VOICE_STOP: 1");
 139     queue_send(&voice_queue, Q_VOICE_STOP, 1);
 140
 141     mutex_unlock(&voice_mutex);
 142 }
 143
 144 void mp3_play_pause(bool play)
 145 {
 146     /* a dummy */
 147     (void)play;
 148 }
 149
 150 /* Tell is voice is still in a playing state */
 151 bool mp3_is_playing(void)
 152 {
 153     /* TODO: Implement a timeout or state query function for event objects */
 154     LOGFQUEUE("mp3 >| voice Q_VOICE_STATE");
 155     int state = queue_send(&voice_queue, Q_VOICE_STATE, 0);
 156     return state != TSTATE_STOPPED;
 157 }
 158
 159 /* This function is meant to be used by the buffer request functions to
 160    ensure the codec is no longer active */
 161 void voice_stop(void)
 162 {
 163     mutex_lock(&voice_mutex);
 164
 165     /* Stop the output and current clip */
 166     mp3_play_stop();
 167
 168     /* Careful if using sync objects in talk.c - make sure locking order is
 169      * observed with one or the other always granted first */
 170
 171     /* Unqueue all future clips */
 172     talk_force_shutup();
 173
 174     mutex_unlock(&voice_mutex);
 175 } /* voice_stop */
 176
 177 /* Wait for voice to finish speaking. */
 178 void voice_wait(void)
 179 {
 180     /* NOTE: One problem here is that we can't tell if another thread started a
 181      * new clip by the time we wait. This should be resolvable if conditions
 182      * ever require knowing the very clip you requested has finished. */
 183     event_wait(&voice_event, STATE_SIGNALED);
 184 }
 185
 186 /* Initialize voice thread data that must be valid upon starting and the
 187  * setup the DSP parameters */
 188 static void voice_data_init(struct voice_thread_data *td)
 189 {
 190     td->state = TSTATE_STOPPED;
 191     td->dsp = (struct dsp_config *)dsp_configure(NULL, DSP_MYDSP,
 192                                                  CODEC_IDX_VOICE);
 193
 194     dsp_configure(td->dsp, DSP_RESET, 0);
 195     dsp_configure(td->dsp, DSP_SET_FREQUENCY, VOICE_SAMPLE_RATE);
 196     dsp_configure(td->dsp, DSP_SET_SAMPLE_DEPTH, VOICE_SAMPLE_DEPTH);
 197     dsp_configure(td->dsp, DSP_SET_STEREO_MODE, STEREO_MONO);
 198 }
 199
 200 /* Voice thread message processing */
 201 static void voice_message(struct voice_thread_data *td)
 202 {
 203     while (1)
 204     {
 205         switch (td->ev.id)
 206         {
 207         case Q_VOICE_PLAY:
 208             LOGFQUEUE("voice < Q_VOICE_PLAY");
 209             /* Put up a block for completion signal */
 210             event_set_state(&voice_event, STATE_NONSIGNALED);
 211
 212             /* Copy the clip info */
 213             td->vi = *(struct voice_info *)td->ev.data;
 214
 215             /* Be sure audio buffer is initialized */
 216             audio_restore_playback(AUDIO_WANT_VOICE);
 217
 218             /* We need nothing more from the sending thread - let it run */
 219             queue_reply(&voice_queue, 1);
 220
 221             if (td->state == TSTATE_STOPPED)
 222             {
 223                 /* Boost CPU now */
 224                 trigger_cpu_boost();
 225             }
 226             else if (!playback_is_playing())
 227             {
 228                 /* Just voice, stop any clip still playing */
 229                 pcmbuf_play_stop();
 230             }
 231
 232             /* Clean-start the decoder */
 233             td->st = speex_decoder_init(&speex_wb_mode);
 234
 235             /* Make bit buffer use our own buffer */
 236             speex_bits_set_bit_buffer(&td->bits, td->vi.start, td->vi.size);
 237             speex_decoder_ctl(td->st, SPEEX_GET_LOOKAHEAD, &td->lookahead);
 238
 239             td->state = TSTATE_DECODE;
 240             return;
 241
 242         case Q_VOICE_STOP:
 243             LOGFQUEUE("voice < Q_VOICE_STOP: %d", ev.data);
 244
 245             if (td->ev.data != 0 && !playback_is_playing())
 246             {
 247                 /* If not playing, it's just voice so stop pcm playback */
 248                 pcmbuf_play_stop();
 249             }
 250
 251             /* Cancel boost */
 252             sleep(0);
 253
 254             td->state = TSTATE_STOPPED;
 255             event_set_state(&voice_event, STATE_SIGNALED);
 256             break;
 257
 258         case Q_VOICE_STATE:
 259             LOGFQUEUE("voice < Q_VOICE_STATE");
 260             queue_reply(&voice_queue, td->state);
 261
 262             if (td->state == TSTATE_STOPPED)
 263                 break; /* Not in a playback state */
 264
 265             return;
 266
 267         default:
 268             /* Default messages get a reply and thread continues with no
 269              * state transition */
 270             LOGFQUEUE("voice < default");
 271
 272             if (td->state == TSTATE_STOPPED)
 273                 break;  /* Not in playback state */
 274
 275             queue_reply(&voice_queue, 0);
 276             return;
 277         }
 278
 279         queue_wait(&voice_queue, &td->ev);
 280     }
 281 }
 282
 283 /* Voice thread entrypoint */
 284 static void voice_thread(void)
 285 {
 286     struct voice_thread_data td;
 287
 288     voice_data_init(&td);
 289
 290     goto message_wait;
 291
 292     while (1)
 293     {
 294         td.state = TSTATE_DECODE;
 295
 296         if (!queue_empty(&voice_queue))
 297         {
 298         message_wait:
 299             queue_wait(&voice_queue, &td.ev);
 300
 301         message_process:
 302             voice_message(&td);
 303
 304             /* Branch to initial start point or branch back to previous
 305              * operation if interrupted by a message */
 306             switch (td.state)
 307             {
 308             case TSTATE_DECODE:        goto voice_decode;
 309             case TSTATE_BUFFER_INSERT: goto buffer_insert;
 310             default:                   goto message_wait;
 311             }
 312         }
 313
 314     voice_decode:
 315         /* Check if all data was exhausted for this clip */
 316         if (speex_bits_remaining(&td.bits) < 8)
 317         {
 318     voice_error:
 319             /* Get next clip */
 320             td.vi.size = 0;
 321
 322             if (td.vi.get_more != NULL)
 323                 td.vi.get_more(&td.vi.start, &td.vi.size);
 324
 325             if (td.vi.start != NULL && (ssize_t)td.vi.size > 0)
 326             {
 327                 /* Make bit buffer use our own buffer */
 328                 speex_bits_set_bit_buffer(&td.bits, td.vi.start, td.vi.size);
 329                 speex_decoder_ctl(td.st, SPEEX_GET_LOOKAHEAD, &td.lookahead);
 330
 331                 yield();
 332
 333                 if (!queue_empty(&voice_queue))
 334                     goto message_wait;
 335                 else
 336                     goto voice_decode;
 337             }
 338
 339             /* If all clips are done and not playing, force pcm playback. */
 340             if (!pcm_is_playing())
 341                 pcmbuf_play_start();
 342
 343             /* Synthesize a stop request */
 344             /* NOTE: We have no way to know when the pcm data placed in the
 345              * buffer is actually consumed and playback has reached the end
 346              * so until the info is available or inferred somehow, this will
 347              * not be accurate and the stopped signal will come too soon.
 348              * ie. You may not hear the "Shutting Down" splash even though
 349              * it waits for voice to stop. */
 350             td.ev.id = Q_VOICE_STOP;
 351             td.ev.data = 0; /* Let PCM drain by itself */
 352             yield();
 353             goto message_process;
 354         }
 355
 356         /* Decode the data */
 357         int status = speex_decode_int(td.st, &td.bits, voice_output_buf);
 358         yield();
 359
 360         if (status == -2)
 361             goto voice_error; /* error - try some more */
 362
 363         /* Output the decoded frame */
 364         td.count = VOICE_FRAME_SIZE - td.lookahead;
 365         td.src[0] = (const char *)&voice_output_buf[td.lookahead];
 366         td.src[1] = NULL;
 367         td.lookahead -= MIN(VOICE_FRAME_SIZE, td.lookahead);
 368
 369     buffer_insert:
 370         /* Process the PCM samples in the DSP and send out for mixing */
 371         td.state = TSTATE_BUFFER_INSERT;
 372
 373         while (td.count > 0)
 374         {
 375             int out_count = dsp_output_count(td.dsp, td.count);
 376             int inp_count;
 377             char *dest;
 378
 379             while (1)
 380             {
 381                 if (!queue_empty(&voice_queue))
 382                     goto message_wait;
 383
 384                 if ((dest = pcmbuf_request_voice_buffer(&out_count)) != NULL)
 385                     break;
 386
 387                 yield();
 388             }
 389
 390             /* Get the real input_size for output_size bytes, guarding
 391              * against resampling buffer overflows. */
 392             inp_count = dsp_input_count(td.dsp, out_count);
 393
 394             if (inp_count <= 0)
 395                 break;
 396
 397             /* Input size has grown, no error, just don't write more than
 398              * length */
 399             if (inp_count > td.count)
 400                 inp_count = td.count;
 401
 402             out_count = dsp_process(td.dsp, dest, td.src, inp_count);
 403
 404             if (out_count <= 0)
 405                 break;
 406
 407             pcmbuf_write_voice_complete(out_count);
 408             td.count -= inp_count;
 409         }
 410
 411         yield();
 412     } /* end while */
 413 } /* voice_thread */
 414
 415 /* Initialize all synchronization objects create the thread */
 416 void voice_thread_init(void)
 417 {
 418     logf("Starting voice thread");
 419     queue_init(&voice_queue, false);
 420     queue_enable_queue_send(&voice_queue, &voice_queue_sender_list);
 421     mutex_init(&voice_mutex);
 422     event_init(&voice_event, STATE_SIGNALED | EVENT_MANUAL);
 423     voice_thread_p = create_thread(voice_thread, voice_stack,
 424             sizeof(voice_stack), CREATE_THREAD_FROZEN,
 425             voice_thread_name IF_PRIO(, PRIORITY_PLAYBACK) IF_COP(, CPU));
 426 } /* voice_thread_init */
 427
 428 /* Unfreeze the voice thread */
 429 void voice_thread_resume(void)
 430 {
 431     logf("Thawing voice thread");
 432     thread_thaw(voice_thread_p);
 433     /* Wait for initialization to complete (a very short wait until the
 434      * voice thread is available to process messages) */
 435     queue_send(&voice_queue, Q_VOICE_NULL, 0);
 436 }
 437
 438 #ifdef HAVE_PRIORITY_SCHEDULING
 439 /* Set the voice thread priority */
 440 void voice_thread_set_priority(int priority)
 441 {
 442     thread_set_priority(voice_thread_p, priority);
 443 }
 444 #endif