apps/plugins/mpegplayer/pcm_output.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * PCM output buffer definitions
  11  *
  12  * Copyright (c) 2007 Michael Sevakis
  13  *
  14  * This program is free software; you can redistribute it and/or
  15  * modify it under the terms of the GNU General Public License
  16  * as published by the Free Software Foundation; either version 2
  17  * of the License, or (at your option) any later version.
  18  *
  19  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  20  * KIND, either express or implied.
  21  *
  22  ****************************************************************************/
  23 #include "plugin.h"
  24 #include "mpegplayer.h"
  25
  26 /* Pointers */
  27
  28 /* Start of buffer */
  29 static struct pcm_frame_header * ALIGNED_ATTR(4) pcm_buffer;
  30 /* End of buffer (not guard) */
  31 static struct pcm_frame_header * ALIGNED_ATTR(4) pcmbuf_end;
  32 /* Read pointer */
  33 static struct pcm_frame_header * ALIGNED_ATTR(4) pcmbuf_head IBSS_ATTR;
  34 /* Write pointer */
  35 static struct pcm_frame_header * ALIGNED_ATTR(4) pcmbuf_tail IBSS_ATTR;
  36
  37 /* Bytes */
  38 static ssize_t  pcmbuf_curr_size IBSS_ATTR; /* Size of currently playing frame */
  39 static uint64_t pcmbuf_read      IBSS_ATTR; /* Number of bytes read by DMA */
  40 static uint64_t pcmbuf_written   IBSS_ATTR; /* Number of bytes written by source */
  41 static ssize_t  pcmbuf_threshold IBSS_ATTR; /* Non-silence threshold */
  42
  43 /* Clock */
  44 static uint32_t clock_base   IBSS_ATTR; /* Our base clock */
  45 static uint32_t clock_start  IBSS_ATTR; /* Clock at playback start */
  46 static int32_t  clock_adjust IBSS_ATTR; /* Clock drift adjustment */
  47
  48 int pcm_skipped = 0;
  49 int pcm_underruns = 0;
  50
  51 /* Small silence clip. ~5.80ms @ 44.1kHz */
  52 static int16_t silence[256*2] ALIGNED_ATTR(4) = { 0 };
  53
  54 /* Advance a PCM buffer pointer by size bytes circularly */
  55 static inline void pcm_advance_buffer(struct pcm_frame_header **p,
  56                                       size_t size)
  57 {
  58     *p = SKIPBYTES(*p, size);
  59     if (*p >= pcmbuf_end)
  60         *p = SKIPBYTES(*p, -PCMOUT_BUFSIZE);
  61 }
  62
  63 /* Inline internally but not externally */
  64 inline ssize_t pcm_output_used(void)
  65 {
  66     return (ssize_t)(pcmbuf_written - pcmbuf_read);
  67 }
  68
  69 inline ssize_t pcm_output_free(void)
  70 {
  71     return (ssize_t)(PCMOUT_BUFSIZE - pcmbuf_written + pcmbuf_read);
  72 }
  73
  74 /* Audio DMA handler */
  75 static void get_more(unsigned char **start, size_t *size)
  76 {
  77     ssize_t sz;
  78
  79     /* Free-up the last frame played frame if any */
  80     pcmbuf_read += pcmbuf_curr_size;
  81     pcmbuf_curr_size = 0;
  82
  83     sz = pcm_output_used();
  84
  85     if (sz > pcmbuf_threshold)
  86     {
  87         pcmbuf_threshold = PCMOUT_LOW_WM;
  88
  89         while (1)
  90         {
  91             uint32_t time = pcmbuf_head->time;
  92             int32_t offset = time - (clock_base + clock_adjust);
  93
  94             sz = pcmbuf_head->size;
  95
  96             if (sz < (ssize_t)(sizeof(pcmbuf_head) + 4) ||
  97                 (sz & 3) != 0)
  98             {
  99                 /* Just show a warning about this - will never happen
 100                  * without a bug in the audio thread code or a clobbered
 101                  * buffer */
 102                 DEBUGF("get_more: invalid size (%ld)\n", sz);
 103             }
 104
 105             if (offset < -100*CLOCK_RATE/1000)
 106             {
 107                 /* Frame more than 100ms late - drop it */
 108                 pcm_advance_buffer(&pcmbuf_head, sz);
 109                 pcmbuf_read += sz;
 110                 pcm_skipped++;
 111                 if (pcmbuf_read < pcmbuf_written)
 112                     continue;
 113
 114                 /* Ran out so revert to default watermark */
 115                 pcmbuf_threshold = PCMOUT_PLAY_WM;
 116             }
 117             else if (offset < 100*CLOCK_RATE/1000)
 118             {
 119                 /* Frame less than 100ms early - play it */
 120                 *start = pcmbuf_head->data;
 121
 122                 pcm_advance_buffer(&pcmbuf_head, sz);
 123                 pcmbuf_curr_size = sz;
 124
 125                 sz -= sizeof (struct pcm_frame_header);
 126
 127                 *size = sz;
 128
 129                 /* Audio is time master - keep clock synchronized */
 130                 clock_adjust = time - clock_base;
 131
 132                 /* Update base clock */
 133                 clock_base += sz >> 2;
 134                 return;
 135             }
 136             /* Frame will be dropped - play silence clip */
 137             break;
 138         }
 139     }
 140     else
 141     {
 142         /* Ran out so revert to default watermark */
 143         if (pcmbuf_threshold == PCMOUT_LOW_WM)
 144             pcm_underruns++;
 145
 146         pcmbuf_threshold = PCMOUT_PLAY_WM;
 147     }
 148
 149     /* Keep clock going at all times */
 150     *start = (unsigned char *)silence;
 151     *size = sizeof (silence);
 152
 153     clock_base += sizeof (silence) / 4;
 154
 155     if (pcmbuf_read > pcmbuf_written)
 156         pcmbuf_read = pcmbuf_written;
 157 }
 158
 159 struct pcm_frame_header * pcm_output_get_buffer(void)
 160 {
 161     return pcmbuf_tail;
 162 }
 163
 164 void pcm_output_add_data(void)
 165 {
 166     size_t size = pcmbuf_tail->size;
 167     pcm_advance_buffer(&pcmbuf_tail, size);
 168     pcmbuf_written += size;
 169 }
 170
 171 /* Flushes the buffer - clock keeps counting */
 172 void pcm_output_flush(void)
 173 {
 174     bool playing, paused;
 175
 176     rb->pcm_play_lock();
 177
 178     playing = rb->pcm_is_playing();
 179     paused = rb->pcm_is_paused();
 180
 181     /* Stop PCM to clear current buffer */
 182     if (playing)
 183         rb->pcm_play_stop();
 184
 185     pcmbuf_threshold = PCMOUT_PLAY_WM;
 186     pcmbuf_curr_size = pcmbuf_read = pcmbuf_written = 0;
 187     pcmbuf_head = pcmbuf_tail = pcm_buffer;
 188     pcm_skipped = pcm_underruns = 0;
 189
 190     /* Restart if playing state was current */
 191     if (playing && !paused)
 192         rb->pcm_play_data(get_more, NULL, 0);
 193
 194     rb->pcm_play_unlock();
 195 }
 196
 197 /* Seek the reference clock to the specified time - next audio data ready to
 198    go to DMA should be on the buffer with the same time index or else the PCM
 199    buffer should be empty */
 200 void pcm_output_set_clock(uint32_t time)
 201 {
 202     rb->pcm_play_lock();
 203
 204     clock_base = time;
 205     clock_start = time;
 206     clock_adjust = 0;
 207
 208     rb->pcm_play_unlock();
 209 }
 210
 211 uint32_t pcm_output_get_clock(void)
 212 {
 213     return clock_base + clock_adjust
 214         - (rb->pcm_get_bytes_waiting() >> 2);
 215 }
 216
 217 uint32_t pcm_output_get_ticks(uint32_t *start)
 218 {
 219     if (start)
 220         *start = clock_start;
 221
 222     return clock_base - (rb->pcm_get_bytes_waiting() >> 2);
 223 }
 224
 225 /* Pauses/Starts pcm playback - and the clock */
 226 void pcm_output_play_pause(bool play)
 227 {
 228     rb->pcm_play_lock();
 229
 230     if (rb->pcm_is_playing())
 231     {
 232         rb->pcm_play_pause(play);
 233     }
 234     else if (play)
 235     {
 236         rb->pcm_play_data(get_more, NULL, 0);
 237     }
 238
 239     rb->pcm_play_unlock();
 240 }
 241
 242 /* Stops all playback and resets the clock */
 243 void pcm_output_stop(void)
 244 {
 245     rb->pcm_play_lock();
 246
 247     if (rb->pcm_is_playing())
 248         rb->pcm_play_stop();
 249
 250     pcm_output_flush();
 251     pcm_output_set_clock(0);
 252
 253     rb->pcm_play_unlock();
 254 }
 255
 256 /* Drains any data if the start threshold hasn't been reached */
 257 void pcm_output_drain(void)
 258 {
 259     rb->pcm_play_lock();
 260     pcmbuf_threshold = PCMOUT_LOW_WM;
 261     rb->pcm_play_unlock();
 262 }
 263
 264 bool pcm_output_init(void)
 265 {
 266     pcm_buffer = mpeg_malloc(PCMOUT_ALLOC_SIZE, MPEG_ALLOC_PCMOUT);
 267     if (pcm_buffer == NULL)
 268         return false;
 269
 270     pcmbuf_threshold = PCMOUT_PLAY_WM;
 271     pcmbuf_head = pcm_buffer;
 272     pcmbuf_tail = pcm_buffer;
 273     pcmbuf_end  = SKIPBYTES(pcm_buffer, PCMOUT_BUFSIZE);
 274     pcmbuf_curr_size = pcmbuf_read = pcmbuf_written = 0;
 275
 276     rb->pcm_set_frequency(NATIVE_FREQUENCY);
 277
 278 #if INPUT_SRC_CAPS != 0
 279     /* Select playback */
 280     rb->audio_set_input_source(AUDIO_SRC_PLAYBACK, SRCF_PLAYBACK);
 281     rb->audio_set_output_source(AUDIO_SRC_PLAYBACK);
 282 #endif
 283
 284 #if SILENCE_TEST_TONE
 285     /* Make the silence clip a square wave */
 286     const int16_t silence_amp = INT16_MAX / 16;
 287     unsigned i;
 288
 289     for (i = 0; i < ARRAYLEN(silence); i += 2)
 290     {
 291         if (i < ARRAYLEN(silence)/2)
 292         {
 293             silence[i] = silence_amp;
 294             silence[i+1] = silence_amp;
 295         }
 296         else
 297         {
 298             silence[i] = -silence_amp;
 299             silence[i+1] = -silence_amp;
 300         }
 301     }
 302 #endif
 303
 304     return true;
 305 }
 306
 307 void pcm_output_exit(void)
 308 {
 309     rb->pcm_set_frequency(HW_SAMPR_DEFAULT);
 310 }