firmware/pcm_mixer.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2011 by 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 "config.h"
  22 #include "system.h"
  23 #include "general.h"
  24 #include "kernel.h"
  25 #include "pcm.h"
  26 #include "pcm-internal.h"
  27 #include "pcm_mixer.h"
  28 #include "dsp_core.h" /* For NATIVE_FREQUENCY */
  29
  30 /* Channels use standard-style PCM callback interface but a latency of one
  31    frame by double-buffering is introduced in order to facilitate mixing and
  32    keep the hardware fed. There must be sufficient time to perform operations
  33    before the last samples are sent to the codec and so things are done in
  34    parallel (as much as possible) with sending-out data. */
  35
  36 /* Define this to nonzero to add a marker pulse at each frame start */
  37 #define FRAME_BOUNDARY_MARKERS 0
  38
  39 /* Descriptor for each channel */
  40 struct mixer_channel
  41 {
  42     const void *start;               /* Buffer pointer */
  43     size_t size;                     /* Bytes remaining */
  44     size_t last_size;                /* Size of consumed data in prev. cycle */
  45     pcm_play_callback_type get_more; /* Registered callback */
  46     enum channel_status status;      /* Playback status */
  47     uint32_t amplitude;              /* Amp. factor: 0x0000 = mute, 0x10000 = unity */
  48 };
  49
  50 /* Forget about boost here for the moment */
  51 #define MIX_FRAME_SIZE      (MIX_FRAME_SAMPLES*4)
  52
  53 /* Because of the double-buffering, playback is always from here, otherwise a
  54    mechanism for the channel callbacks not to free buffers too early would be
  55    needed (if we _really_ want it and it's worth it, we _can_ do that ;-) ) */
  56 static uint32_t downmix_buf[2][MIX_FRAME_SAMPLES] DOWNMIX_BUF_IBSS MEM_ALIGN_ATTR;
  57 static int downmix_index = 0;   /* Which downmix_buf? */
  58 static size_t next_size = 0;    /* Size of buffer to play next time */
  59
  60 /* Descriptors for all available channels */
  61 static struct mixer_channel channels[PCM_MIXER_NUM_CHANNELS] IBSS_ATTR;
  62
  63 /* Packed pointer array of all playing (active) channels in "channels" array */
  64 static struct mixer_channel * active_channels[PCM_MIXER_NUM_CHANNELS+1] IBSS_ATTR;
  65
  66 /* Number of silence frames to play after all data has played */
  67 #define MAX_IDLE_FRAMES     (NATIVE_FREQUENCY*3 / MIX_FRAME_SAMPLES)
  68 static unsigned int idle_counter = 0;
  69
  70 /** Mixing routines, CPU optmized **/
  71 #include "asm/pcm-mixer.c"
  72
  73 /** Private generic routines **/
  74
  75 /* Mark channel active to mix its data */
  76 static void mixer_activate_channel(struct mixer_channel *chan)
  77 {
  78     void **elem = find_array_ptr((void **)active_channels, chan);
  79
  80     if (!*elem)
  81     {
  82         idle_counter = 0;
  83         *elem = chan;
  84     }
  85 }
  86
  87 /* Stop channel from mixing */
  88 static void mixer_deactivate_channel(struct mixer_channel *chan)
  89 {
  90     remove_array_ptr((void **)active_channels, chan);
  91 }
  92
  93 /* Deactivate channel and change it to stopped state */
  94 static void channel_stopped(struct mixer_channel *chan)
  95 {
  96     mixer_deactivate_channel(chan);
  97     chan->size = 0;
  98     chan->start = NULL;
  99     chan->status = CHANNEL_STOPPED;
 100 }
 101
 102 /* Main PCM callback - sends the current prepared frame to play */
 103 static void mixer_pcm_callback(const void **addr, size_t *size)
 104 {
 105     *addr = downmix_buf[downmix_index];
 106     *size = next_size;
 107 }
 108
 109 /* Buffering callback - calls sub-callbacks and mixes the data for next
 110    buffer to be sent from mixer_pcm_callback() */
 111 static enum pcm_dma_status MIXER_CALLBACK_ICODE
 112 mixer_buffer_callback(enum pcm_dma_status status)
 113 {
 114     if (status != PCM_DMAST_STARTED)
 115         return status;
 116
 117     downmix_index ^= 1; /* Next buffer */
 118
 119     void *mixptr = downmix_buf[downmix_index];
 120     size_t mixsize = MIX_FRAME_SIZE;
 121     struct mixer_channel **chan_p;
 122
 123     next_size = 0;
 124
 125     /* "Loop" back here if one round wasn't enough to fill a frame */
 126 fill_frame:
 127     chan_p = active_channels;
 128
 129     while (*chan_p)
 130     {
 131         /* Find the active channel with the least data remaining and call any
 132            callbacks for channels that ran out - stopping whichever report
 133            "no more" */
 134         struct mixer_channel *chan = *chan_p;
 135         chan->start += chan->last_size;
 136         chan->size -= chan->last_size;
 137
 138         if (chan->size == 0)
 139         {
 140             if (chan->get_more)
 141             {
 142                 chan->get_more(&chan->start, &chan->size);
 143                 ALIGN_AUDIOBUF(chan->start, chan->size);
 144             }
 145
 146             if (!(chan->start && chan->size))
 147             {
 148                 /* Channel is stopping */
 149                 channel_stopped(chan);
 150                 continue;
 151             }
 152         }
 153
 154         /* Channel will play for at least part of this frame */
 155
 156         /* Channel with least amount of data remaining determines the downmix
 157            size */
 158         if (chan->size < mixsize)
 159             mixsize = chan->size;
 160
 161         chan_p++;
 162     }
 163
 164     /* Add all still-active channels to the downmix */
 165     chan_p = active_channels;
 166
 167     if (LIKELY(*chan_p))
 168     {
 169         struct mixer_channel *chan = *chan_p++;
 170
 171         if (LIKELY(!*chan_p))
 172         {
 173             write_samples(mixptr, chan->start, chan->amplitude, mixsize);
 174         }
 175         else
 176         {
 177             const void *src0, *src1;
 178             unsigned int amp0, amp1;
 179
 180             /* Mix first two channels with each other as the downmix */
 181             src0 = chan->start;
 182             amp0 = chan->amplitude;
 183             chan->last_size = mixsize;
 184
 185             chan = *chan_p++;
 186             src1 = chan->start;
 187             amp1 = chan->amplitude;
 188
 189             while (1)
 190             {
 191                 mix_samples(mixptr, src0, amp0, src1, amp1, mixsize);
 192
 193                 if (!*chan_p)
 194                     break;
 195
 196                 /* More channels to mix - mix each with existing downmix */
 197                 chan->last_size = mixsize;
 198                 chan = *chan_p++;
 199                 src0 = mixptr;
 200                 amp0 = MIX_AMP_UNITY;
 201                 src1 = chan->start;
 202                 amp1 = chan->amplitude;
 203             }
 204         }
 205
 206         chan->last_size = mixsize;
 207         next_size += mixsize;
 208
 209         if (next_size < MIX_FRAME_SIZE)
 210         {
 211             /* There is still space remaining in this frame */
 212             mixptr += mixsize;
 213             mixsize = MIX_FRAME_SIZE - next_size;
 214             goto fill_frame;
 215         }
 216     }
 217     else if (idle_counter++ < MAX_IDLE_FRAMES)
 218     {
 219         /* Pad incomplete frames with silence */
 220         if (idle_counter <= 3)
 221             memset(mixptr, 0, MIX_FRAME_SIZE - next_size);
 222
 223         next_size = MIX_FRAME_SIZE;
 224     }
 225     /* else silence period ran out - go to sleep */
 226
 227 #if FRAME_BOUNDARY_MARKERS != 0
 228     if (next_size)
 229         *downmix_buf[downmix_index] = downmix_index ? 0x7fff7fff : 0x80008000;
 230 #endif
 231
 232     /* Certain SoC's have to do cleanup */
 233     mixer_buffer_callback_exit();
 234
 235     return PCM_DMAST_OK;
 236 }
 237
 238 /* Start PCM driver if it's not currently playing */
 239 static void mixer_start_pcm(void)
 240 {
 241     if (pcm_is_playing())
 242         return;
 243
 244 #if defined(HAVE_RECORDING)
 245     if (pcm_is_recording())
 246         return;
 247 #endif
 248
 249     /* Requires a shared global sample rate for all channels */
 250     pcm_set_frequency(NATIVE_FREQUENCY);
 251
 252     /* Prepare initial frames and set up the double buffer */
 253     mixer_buffer_callback(PCM_DMAST_STARTED);
 254
 255     /* Save the previous call's output */
 256     void *start = downmix_buf[downmix_index];
 257
 258     mixer_buffer_callback(PCM_DMAST_STARTED);
 259
 260     pcm_play_data(mixer_pcm_callback, mixer_buffer_callback,
 261                   start, MIX_FRAME_SIZE);
 262 }
 263
 264 /** Public interfaces **/
 265
 266 /* Start playback on a channel */
 267 void mixer_channel_play_data(enum pcm_mixer_channel channel,
 268                              pcm_play_callback_type get_more,
 269                              const void *start, size_t size)
 270 {
 271     struct mixer_channel *chan = &channels[channel];
 272
 273     ALIGN_AUDIOBUF(start, size);
 274
 275     if (!(start && size) && get_more)
 276     {
 277         /* Initial buffer not passed - call the callback now */
 278         pcm_play_lock();
 279         mixer_deactivate_channel(chan); /* Protect chan struct if active;
 280                                            may also be same callback which
 281                                            must not be reentered */
 282         pcm_play_unlock(); /* Allow playback while doing callback */
 283
 284         size = 0;
 285         get_more(&start, &size);
 286         ALIGN_AUDIOBUF(start, size);
 287     }
 288
 289     pcm_play_lock();
 290
 291     if (start && size)
 292     {
 293         /* We have data - start the channel */
 294         chan->status = CHANNEL_PLAYING;
 295         chan->start = start;
 296         chan->size = size;
 297         chan->last_size = 0;
 298         chan->get_more = get_more;
 299
 300         mixer_activate_channel(chan);
 301         mixer_start_pcm();
 302     }
 303     else
 304     {
 305         /* Never had anything - stop it now */
 306         channel_stopped(chan);
 307     }
 308
 309     pcm_play_unlock();
 310 }
 311
 312 /* Pause or resume a channel (when started) */
 313 void mixer_channel_play_pause(enum pcm_mixer_channel channel, bool play)
 314 {
 315     struct mixer_channel *chan = &channels[channel];
 316
 317     pcm_play_lock();
 318
 319     if (play == (chan->status == CHANNEL_PAUSED) &&
 320         chan->status != CHANNEL_STOPPED)
 321     {
 322         if (play)
 323         {
 324             chan->status = CHANNEL_PLAYING;
 325             mixer_activate_channel(chan);
 326             mixer_start_pcm();
 327         }
 328         else
 329         {
 330             mixer_deactivate_channel(chan);
 331             chan->status = CHANNEL_PAUSED;
 332         }
 333     }
 334
 335     pcm_play_unlock();
 336 }
 337
 338 /* Stop playback on a channel */
 339 void mixer_channel_stop(enum pcm_mixer_channel channel)
 340 {
 341     struct mixer_channel *chan = &channels[channel];
 342
 343     pcm_play_lock();
 344     channel_stopped(chan);
 345     pcm_play_unlock();
 346 }
 347
 348 /* Set channel's amplitude factor */
 349 void mixer_channel_set_amplitude(enum pcm_mixer_channel channel,
 350                                  unsigned int amplitude)
 351 {
 352     channels[channel].amplitude = MIN(amplitude, MIX_AMP_UNITY);
 353 }
 354
 355 /* Return channel's playback status */
 356 enum channel_status mixer_channel_status(enum pcm_mixer_channel channel)
 357 {
 358     return channels[channel].status;
 359 }
 360
 361 /* Returns amount data remaining in channel before next callback */
 362 size_t mixer_channel_get_bytes_waiting(enum pcm_mixer_channel channel)
 363 {
 364     return channels[channel].size;
 365 }
 366
 367 /* Return pointer to channel's playing audio data and the size remaining */
 368 const void * mixer_channel_get_buffer(enum pcm_mixer_channel channel, int *count)
 369 {
 370     struct mixer_channel *chan = &channels[channel];
 371     const void * buf = *(const void * volatile *)&chan->start;
 372     size_t size = *(size_t volatile *)&chan->size;
 373     const void * buf2 = *(const void * volatile *)&chan->start;
 374
 375     /* Still same buffer? */
 376     if (buf == buf2)
 377     {
 378         *count = size >> 2;
 379         return buf;
 380     }
 381     /* else can't be sure buf and size are related */
 382
 383     *count = 0;
 384     return NULL;
 385 }
 386
 387 /* Calculate peak values for channel */
 388 void mixer_channel_calculate_peaks(enum pcm_mixer_channel channel,
 389                                    struct pcm_peaks *peaks)
 390 {
 391     int count;
 392     const void *addr = mixer_channel_get_buffer(channel, &count);
 393
 394     pcm_do_peak_calculation(peaks,
 395                             channels[channel].status == CHANNEL_PLAYING,
 396                             addr, count);
 397 }
 398
 399 /* Adjust channel pointer by a given offset to support movable buffers */
 400 void mixer_adjust_channel_address(enum pcm_mixer_channel channel,
 401                                   off_t offset)
 402 {
 403     pcm_play_lock();
 404     /* Makes no difference if it's stopped */
 405     channels[channel].start += offset;
 406     pcm_play_unlock();
 407 }
 408
 409 /* Stop ALL channels and PCM and reset state */
 410 void mixer_reset(void)
 411 {
 412     pcm_play_stop();
 413
 414     while (*active_channels)
 415         channel_stopped(*active_channels);
 416
 417     idle_counter = 0;
 418 }