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