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  * This program is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU General Public License
  14  * as published by the Free Software Foundation; either version 2
  15  * of the License, or (at your option) any later version.
  16  *
  17  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  18  * KIND, either express or implied.
  19  *
  20  ****************************************************************************/
  21 #include <sys/types.h>
  22 #include "system.h"
  23 #include "thread.h"
  24 #include "voice_thread.h"
  25 #include "talk.h"
  26 #include "dsp.h"
  27 #include "audio.h"
  28 #include "playback.h"
  29 #include "pcmbuf.h"
  30 #include "pcm.h"
  31 #include "pcm_mixer.h"
  32 #include "codecs/libspeex/speex/speex.h"
  33
  34 /* Define any of these as "1" and uncomment the LOGF_ENABLE line to log
  35    regular and/or timeout messages */
  36 #define VOICE_LOGQUEUES 0
  37 #define VOICE_LOGQUEUES_SYS_TIMEOUT 0
  38
  39 /*#define LOGF_ENABLE*/
  40 #include "logf.h"
  41
  42 #if VOICE_LOGQUEUES
  43 #define LOGFQUEUE logf
  44 #else
  45 #define LOGFQUEUE(...)
  46 #endif
  47
  48 #if VOICE_LOGQUEUES_SYS_TIMEOUT
  49 #define LOGFQUEUE_SYS_TIMEOUT logf
  50 #else
  51 #define LOGFQUEUE_SYS_TIMEOUT(...)
  52 #endif
  53
  54 #ifndef IBSS_ATTR_VOICE_STACK
  55 #define IBSS_ATTR_VOICE_STACK IBSS_ATTR
  56 #endif
  57
  58 /* Minimum priority needs to be a bit elevated since voice has fairly low
  59    latency */
  60 #define PRIORITY_VOICE (PRIORITY_PLAYBACK-4)
  61
  62 #define VOICE_FRAME_SIZE    320 /* Samples / frame */
  63 #define VOICE_SAMPLE_RATE 16000 /* Sample rate in HZ */
  64 #define VOICE_SAMPLE_DEPTH   16 /* Sample depth in bits */
  65
  66 /* Voice thread variables */
  67 static unsigned int voice_thread_id = 0;
  68 #ifdef CPU_COLDFIRE
  69 /* ISR uses any available stack - need a bit more room */
  70 #define VOICE_STACK_EXTRA   0x400
  71 #else
  72 #define VOICE_STACK_EXTRA   0x3c0
  73 #endif
  74 static long voice_stack[(DEFAULT_STACK_SIZE + VOICE_STACK_EXTRA)/sizeof(long)]
  75     IBSS_ATTR_VOICE_STACK;
  76 static const char voice_thread_name[] = "voice";
  77
  78 /* Voice thread synchronization objects */
  79 static struct event_queue voice_queue SHAREDBSS_ATTR;
  80 static struct queue_sender_list voice_queue_sender_list SHAREDBSS_ATTR;
  81 static bool voice_done SHAREDDATA_ATTR = true;
  82
  83 /* Buffer for decoded samples */
  84 static spx_int16_t voice_output_buf[VOICE_FRAME_SIZE] CACHEALIGN_ATTR;
  85
  86 #define VOICE_PCM_FRAME_COUNT   ((NATIVE_FREQUENCY*VOICE_FRAME_SIZE + \
  87                                  VOICE_SAMPLE_RATE) / VOICE_SAMPLE_RATE)
  88 #define VOICE_PCM_FRAME_SIZE    (VOICE_PCM_FRAME_COUNT*4)
  89
  90 /* Default number of native-frequency PCM frames to queue - adjust as
  91    necessary per-target */
  92 #define VOICE_FRAMES            3
  93
  94 /* Might have lookahead and be skipping samples, so size is needed */
  95 static size_t voicebuf_sizes[VOICE_FRAMES];
  96 static uint32_t (* voicebuf)[VOICE_PCM_FRAME_COUNT];
  97 static unsigned int cur_buf_in, cur_buf_out;
  98
  99 /* A delay to not bring audio back to normal level too soon */
 100 #define QUIET_COUNT 3
 101
 102 enum voice_thread_states
 103 {
 104     TSTATE_STOPPED = 0,   /* Voice thread is stopped and awaiting commands */
 105     TSTATE_DECODE,        /* Voice is decoding a clip */
 106     TSTATE_BUFFER_INSERT, /* Voice is sending decoded audio to PCM */
 107 };
 108
 109 enum voice_thread_messages
 110 {
 111     Q_VOICE_NULL = 0, /* A message for thread sync - no effect on state */
 112     Q_VOICE_PLAY,     /* Play a clip */
 113     Q_VOICE_STOP,     /* Stop current clip */
 114 };
 115
 116 /* Structure to store clip data callback info */
 117 struct voice_info
 118 {
 119     pcm_play_callback_type get_more; /* Callback to get more clips */
 120     unsigned char *start;            /* Start of clip */
 121     size_t size;                     /* Size of clip */
 122 };
 123
 124 /* Private thread data for its current state that must be passed to its
 125  * internal functions */
 126 struct voice_thread_data
 127 {
 128     volatile int state;     /* Thread state (TSTATE_*) */
 129     struct queue_event ev;  /* Last queue event pulled from queue */
 130     void *st;               /* Decoder instance */
 131     SpeexBits bits;         /* Bit cursor */
 132     struct dsp_config *dsp; /* DSP used for voice output */
 133     struct voice_info vi;   /* Copy of clip data */
 134     const char *src[2];     /* Current output buffer pointers */
 135     int lookahead;          /* Number of samples to drop at start of clip */
 136     int count;              /* Count of samples remaining to send to PCM */
 137     int quiet_counter;      /* Countdown until audio goes back to normal */
 138 };
 139
 140 /* Number of frames in queue */
 141 static inline int voice_unplayed_frames(void)
 142 {
 143     return cur_buf_in - cur_buf_out;
 144 }
 145
 146 /* Mixer channel callback */
 147 static void voice_pcm_callback(unsigned char **start, size_t *size)
 148 {
 149     if (voice_unplayed_frames() == 0)
 150         return; /* Done! */
 151
 152     unsigned int i = ++cur_buf_out % VOICE_FRAMES;
 153
 154     *start = (unsigned char *)voicebuf[i];
 155     *size = voicebuf_sizes[i];
 156 }
 157
 158 /* Start playback of voice channel if not already playing */
 159 static void voice_start_playback(void)
 160 {
 161     if (mixer_channel_status(PCM_MIXER_CHAN_VOICE) != CHANNEL_STOPPED)
 162         return;
 163
 164     unsigned int i = cur_buf_out % VOICE_FRAMES;
 165     mixer_channel_play_data(PCM_MIXER_CHAN_VOICE, voice_pcm_callback,
 166                             (unsigned char *)voicebuf[i], voicebuf_sizes[i]);
 167 }
 168
 169 /* Stop the voice channel */
 170 static void voice_stop_playback(void)
 171 {
 172     mixer_channel_stop(PCM_MIXER_CHAN_VOICE);
 173     cur_buf_in = cur_buf_out = 0;
 174 }
 175
 176 /* Grab a free PCM frame */
 177 static uint32_t * voice_buf_get(void)
 178 {
 179     if (voice_unplayed_frames() >= VOICE_FRAMES)
 180     {
 181         /* Full */
 182         voice_start_playback();
 183         return NULL;
 184     }
 185
 186     return voicebuf[cur_buf_in % VOICE_FRAMES];
 187 }
 188
 189 /* Commit a frame returned by voice_buf_get and set the actual size */
 190 static void voice_buf_commit(size_t size)
 191 {
 192     voicebuf_sizes[cur_buf_in++ % VOICE_FRAMES] = size;
 193 }
 194
 195 /* Stop any current clip and start playing a new one */
 196 void mp3_play_data(const unsigned char* start, int size,
 197                    pcm_play_callback_type get_more)
 198 {
 199     if (get_more != NULL && start != NULL && (ssize_t)size > 0)
 200     {
 201         struct voice_info voice_clip =
 202         {
 203             .get_more = get_more,
 204             .start    = (unsigned char *)start,
 205             .size     = size,
 206         };
 207
 208         LOGFQUEUE("mp3 >| voice Q_VOICE_PLAY");
 209         queue_send(&voice_queue, Q_VOICE_PLAY, (intptr_t)&voice_clip);
 210     }
 211 }
 212
 213 /* Stop current voice clip from playing */
 214 void mp3_play_stop(void)
 215 {
 216     if(!audio_is_thread_ready())
 217        return;
 218
 219     LOGFQUEUE("mp3 >| voice Q_VOICE_STOP");
 220     queue_send(&voice_queue, Q_VOICE_STOP, 0);
 221 }
 222
 223 void mp3_play_pause(bool play)
 224 {
 225     /* a dummy */
 226     (void)play;
 227 }
 228
 229 /* Tell if voice is still in a playing state */
 230 bool mp3_is_playing(void)
 231 {
 232     return !voice_done;
 233 }
 234
 235 /* This function is meant to be used by the buffer request functions to
 236    ensure the codec is no longer active */
 237 void voice_stop(void)
 238 {
 239     /* Unqueue all future clips */
 240     talk_force_shutup();
 241 }
 242
 243 /* Wait for voice to finish speaking. */
 244 void voice_wait(void)
 245 {
 246     /* NOTE: One problem here is that we can't tell if another thread started a
 247      * new clip by the time we wait. This should be resolvable if conditions
 248      * ever require knowing the very clip you requested has finished. */
 249
 250     while (!voice_done)
 251         sleep(1);
 252 }
 253
 254 /* Initialize voice thread data that must be valid upon starting and the
 255  * setup the DSP parameters */
 256 static void voice_data_init(struct voice_thread_data *td)
 257 {
 258     td->state = TSTATE_STOPPED;
 259     td->dsp = (struct dsp_config *)dsp_configure(NULL, DSP_MYDSP,
 260                                                  CODEC_IDX_VOICE);
 261
 262     dsp_configure(td->dsp, DSP_RESET, 0);
 263     dsp_configure(td->dsp, DSP_SET_FREQUENCY, VOICE_SAMPLE_RATE);
 264     dsp_configure(td->dsp, DSP_SET_SAMPLE_DEPTH, VOICE_SAMPLE_DEPTH);
 265     dsp_configure(td->dsp, DSP_SET_STEREO_MODE, STEREO_MONO);
 266
 267     mixer_channel_set_amplitude(PCM_MIXER_CHAN_VOICE, MIX_AMP_UNITY);
 268     td->quiet_counter = 0;
 269 }
 270
 271 /* Voice thread message processing */
 272 static void voice_message(struct voice_thread_data *td)
 273 {
 274     while (1)
 275     {
 276         switch (td->ev.id)
 277         {
 278         case Q_VOICE_PLAY:
 279             LOGFQUEUE("voice < Q_VOICE_PLAY");
 280             voice_done = false;
 281
 282             /* Copy the clip info */
 283             td->vi = *(struct voice_info *)td->ev.data;
 284
 285             /* Be sure audio buffer is initialized */
 286             audio_restore_playback(AUDIO_WANT_VOICE);
 287
 288             /* We need nothing more from the sending thread - let it run */
 289             queue_reply(&voice_queue, 1);
 290
 291             if (td->state == TSTATE_STOPPED)
 292             {
 293                 /* Boost CPU now */
 294                 trigger_cpu_boost();
 295             }
 296             else
 297             {
 298                 /* Stop any clip still playing */
 299                 voice_stop_playback();
 300             }
 301
 302             /* Make audio play more softly and set delay to return to normal
 303                playback level */
 304             pcmbuf_soft_mode(true);
 305             td->quiet_counter = QUIET_COUNT;
 306
 307             /* Clean-start the decoder */
 308             td->st = speex_decoder_init(&speex_wb_mode);
 309
 310             /* Make bit buffer use our own buffer */
 311             speex_bits_set_bit_buffer(&td->bits, td->vi.start, td->vi.size);
 312             speex_decoder_ctl(td->st, SPEEX_GET_LOOKAHEAD, &td->lookahead);
 313
 314             td->state = TSTATE_DECODE;
 315             return;
 316
 317         case SYS_TIMEOUT:
 318             if (voice_unplayed_frames())
 319             {
 320                 /* Waiting for PCM to finish */
 321                 break;
 322             }
 323
 324             /* Drop through and stop the first time after clip runs out */
 325             if (td->quiet_counter-- != QUIET_COUNT)
 326             {
 327                 if (td->quiet_counter <= 0)
 328                     pcmbuf_soft_mode(false);
 329
 330                 break;
 331             }
 332
 333             /* Fall-through */
 334         case Q_VOICE_STOP:
 335             LOGFQUEUE("voice < Q_VOICE_STOP");
 336
 337             td->state = TSTATE_STOPPED;
 338             voice_done = true;
 339
 340             cancel_cpu_boost();
 341             voice_stop_playback();
 342             break;
 343
 344         default:
 345             /* Default messages get a reply and thread continues with no
 346              * state transition */
 347             LOGFQUEUE("voice < default");
 348
 349             if (td->state == TSTATE_STOPPED)
 350                 break;  /* Not in (active) playback state */
 351
 352             queue_reply(&voice_queue, 0);
 353             return;
 354         }
 355
 356         if (td->quiet_counter > 0)
 357             queue_wait_w_tmo(&voice_queue, &td->ev, HZ/10);
 358         else
 359             queue_wait(&voice_queue, &td->ev);
 360     }
 361 }
 362
 363 /* Voice thread entrypoint */
 364 static void NORETURN_ATTR voice_thread(void)
 365 {
 366     struct voice_thread_data td;
 367     char *dest;
 368
 369     voice_data_init(&td);
 370
 371     /* audio thread will only set this once after it finished the final
 372      * audio hardware init so this little construct is safe - even
 373      * cross-core. */
 374     while (!audio_is_thread_ready())
 375         sleep(0);
 376
 377     goto message_wait;
 378
 379     while (1)
 380     {
 381         td.state = TSTATE_DECODE;
 382
 383         if (!queue_empty(&voice_queue))
 384         {
 385         message_wait:
 386             queue_wait(&voice_queue, &td.ev);
 387
 388         message_process:
 389             voice_message(&td);
 390
 391             /* Branch to initial start point or branch back to previous
 392              * operation if interrupted by a message */
 393             switch (td.state)
 394             {
 395             case TSTATE_DECODE:        goto voice_decode;
 396             case TSTATE_BUFFER_INSERT: goto buffer_insert;
 397             default:                   goto message_wait;
 398             }
 399         }
 400
 401     voice_decode:
 402         /* Decode the data */
 403         if (speex_decode_int(td.st, &td.bits, voice_output_buf) < 0)
 404         {
 405             /* End of stream or error - get next clip */
 406             td.vi.size = 0;
 407
 408             if (td.vi.get_more != NULL)
 409                 td.vi.get_more(&td.vi.start, &td.vi.size);
 410
 411             if (td.vi.start != NULL && (ssize_t)td.vi.size > 0)
 412             {
 413                 /* Make bit buffer use our own buffer */
 414                 speex_bits_set_bit_buffer(&td.bits, td.vi.start, td.vi.size);
 415                 /* Don't skip any samples when we're stringing clips together */
 416                 td.lookahead = 0;
 417
 418                 /* Paranoid check - be sure never to somehow get stuck in a
 419                  * loop without listening to the queue */
 420                 yield();
 421
 422                 if (!queue_empty(&voice_queue))
 423                     goto message_wait;
 424                 else
 425                     goto voice_decode;
 426             }
 427
 428             /* If all clips are done and not playing, force pcm playback. */
 429             voice_start_playback();
 430
 431             td.state = TSTATE_STOPPED;
 432             td.ev.id = SYS_TIMEOUT;
 433             goto message_process;
 434         }
 435
 436         yield();
 437
 438         /* Output the decoded frame */
 439         td.count = VOICE_FRAME_SIZE - td.lookahead;
 440         td.src[0] = (const char *)&voice_output_buf[td.lookahead];
 441         td.src[1] = NULL;
 442         td.lookahead -= MIN(VOICE_FRAME_SIZE, td.lookahead);
 443
 444         if (td.count <= 0)
 445             continue;
 446
 447         td.state = TSTATE_BUFFER_INSERT;
 448
 449     buffer_insert:
 450         /* Process the PCM samples in the DSP and send out for mixing */
 451
 452         while (1)
 453         {
 454             if (!queue_empty(&voice_queue))
 455                 goto message_wait;
 456
 457             if ((dest = (char *)voice_buf_get()) != NULL)
 458                 break;
 459
 460             sleep(0);
 461         }
 462
 463         voice_buf_commit(dsp_process(td.dsp, dest, td.src, td.count)
 464                          * sizeof (int32_t));
 465     } /* end while */
 466 }
 467
 468 /* Initialize all synchronization objects create the thread */
 469 void voice_thread_init(void)
 470 {
 471     logf("Starting voice thread");
 472     queue_init(&voice_queue, false);
 473
 474     voice_thread_id = create_thread(voice_thread, voice_stack,
 475             sizeof(voice_stack), CREATE_THREAD_FROZEN,
 476             voice_thread_name IF_PRIO(, PRIORITY_VOICE) IF_COP(, CPU));
 477
 478     queue_enable_queue_send(&voice_queue, &voice_queue_sender_list,
 479                             voice_thread_id);
 480 } /* voice_thread_init */
 481
 482 /* Unfreeze the voice thread */
 483 void voice_thread_resume(void)
 484 {
 485     logf("Thawing voice thread");
 486     thread_thaw(voice_thread_id);
 487 }
 488
 489 #ifdef HAVE_PRIORITY_SCHEDULING
 490 /* Set the voice thread priority */
 491 void voice_thread_set_priority(int priority)
 492 {
 493     if (priority > PRIORITY_VOICE)
 494         priority = PRIORITY_VOICE;
 495
 496     thread_set_priority(voice_thread_id, priority);
 497 }
 498 #endif
 499
 500 /* Initialize voice PCM buffer and return size, allocated from the end */
 501 size_t voicebuf_init(unsigned char *bufend)
 502 {
 503     size_t size = VOICE_FRAMES * VOICE_PCM_FRAME_SIZE;
 504     cur_buf_out = cur_buf_in = 0;
 505     voicebuf = (uint32_t (*)[VOICE_PCM_FRAME_COUNT])(bufend - size);
 506     return size;
 507 }