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.h"
  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     unsigned char *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 /* History for channel peaks */
  64 static struct pcm_peaks channel_peaks[PCM_MIXER_NUM_CHANNELS];
  65
  66 /* Packed pointer array of all playing (active) channels in "channels" array */
  67 static struct mixer_channel * active_channels[PCM_MIXER_NUM_CHANNELS+1] IBSS_ATTR;
  68
  69 /* Number of silence frames to play after all data has played */
  70 #define MAX_IDLE_FRAMES     (NATIVE_FREQUENCY*3 / MIX_FRAME_SAMPLES)
  71 static unsigned int idle_counter = 0;
  72
  73 /** Mixing routines, CPU optmized **/
  74 #include "asm/pcm-mixer.c"
  75
  76 /** Private generic routines **/
  77
  78 /* Mark channel active to mix its data */
  79 static void mixer_activate_channel(struct mixer_channel *chan)
  80 {
  81     void **elem = find_array_ptr((void **)active_channels, chan);
  82
  83     if (!*elem)
  84     {
  85         idle_counter = 0;
  86         *elem = chan;
  87     }
  88 }
  89
  90 /* Stop channel from mixing */
  91 static void mixer_deactivate_channel(struct mixer_channel *chan)
  92 {
  93     remove_array_ptr((void **)active_channels, chan);
  94 }
  95
  96 /* Deactivate channel and change it to stopped state */
  97 static void channel_stopped(struct mixer_channel *chan)
  98 {
  99     mixer_deactivate_channel(chan);
 100     chan->size = 0;
 101     chan->start = NULL;
 102     chan->status = CHANNEL_STOPPED;
 103 }
 104
 105 /* Main PCM callback - sends the current prepared frame to play */
 106 static void mixer_pcm_callback(unsigned char **start, size_t *size)
 107 {
 108     *start = (unsigned char *)downmix_buf[downmix_index];
 109     *size = next_size;
 110 }
 111
 112 /* Buffering callback - calls sub-callbacks and mixes the data for next
 113    buffer to be sent from mixer_pcm_callback() */
 114 static void MIXER_CALLBACK_ICODE mixer_buffer_callback(void)
 115 {
 116     downmix_index ^= 1; /* Next buffer */
 117
 118     void *mixptr = downmix_buf[downmix_index];
 119     size_t mixsize = MIX_FRAME_SIZE;
 120     struct mixer_channel **chan_p;
 121
 122     next_size = 0;
 123
 124     /* "Loop" back here if one round wasn't enough to fill a frame */
 125 fill_frame:
 126     chan_p = active_channels;
 127
 128     while (*chan_p)
 129     {
 130         /* Find the active channel with the least data remaining and call any
 131            callbacks for channels that ran out - stopping whichever report
 132            "no more" */
 133         struct mixer_channel *chan = *chan_p;
 134         chan->start += chan->last_size;
 135         chan->size -= chan->last_size;
 136
 137         if (chan->size == 0)
 138         {
 139             if (chan->get_more)
 140             {
 141                 chan->get_more(&chan->start, &chan->size);
 142                 ALIGN_AUDIOBUF(chan->start, chan->size);
 143             }
 144
 145             if (!(chan->start && chan->size))
 146             {
 147                 /* Channel is stopping */
 148                 channel_stopped(chan);
 149                 continue;
 150             }
 151         }
 152
 153         /* Channel will play for at least part of this frame */
 154
 155         /* Channel with least amount of data remaining determines the downmix
 156            size */
 157         if (chan->size < mixsize)
 158             mixsize = chan->size;
 159
 160         chan_p++;
 161     }
 162
 163     /* Add all still-active channels to the downmix */
 164     chan_p = active_channels;
 165
 166     if (LIKELY(*chan_p))
 167     {
 168         struct mixer_channel *chan = *chan_p++;
 169
 170         if (LIKELY(!*chan_p))
 171         {
 172             write_samples(mixptr, (void *)chan->start,
 173                           chan->amplitude, mixsize);
 174         }
 175         else
 176         {
 177             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
 233 /* Start PCM driver if it's not currently playing */
 234 static void mixer_start_pcm(void)
 235 {
 236     if (pcm_is_playing())
 237         return;
 238
 239 #if defined(HAVE_RECORDING)
 240     if (pcm_is_recording())
 241         return;
 242 #endif
 243
 244     /* Requires a shared global sample rate for all channels */
 245     pcm_set_frequency(NATIVE_FREQUENCY);
 246
 247     /* Prepare initial frames and set up the double buffer */
 248     mixer_buffer_callback();
 249
 250     /* Save the previous call's output */
 251     void *start = downmix_buf[downmix_index];
 252
 253     mixer_buffer_callback();
 254
 255     pcm_play_set_dma_started_callback(mixer_buffer_callback);
 256     pcm_play_data(mixer_pcm_callback, start, MIX_FRAME_SIZE);
 257 }
 258
 259 /* Initialize the channel and start it if it has data */
 260 static void mixer_channel_play_start(struct mixer_channel *chan,
 261                                      pcm_play_callback_type get_more,
 262                                      unsigned char *start, size_t size)
 263 {
 264     pcm_play_unlock(); /* Allow playback while doing any callback */
 265
 266     ALIGN_AUDIOBUF(start, size);
 267
 268     if (!(start && size))
 269     {
 270         /* Initial buffer not passed - call the callback now */
 271         size = 0;
 272         if (get_more)
 273         {
 274             get_more(&start, &size);
 275             ALIGN_AUDIOBUF(start, size);
 276         }
 277     }
 278
 279     if (start && size)
 280     {
 281         /* We have data - start the channel */
 282         chan->status = CHANNEL_PLAYING;
 283         chan->start = start;
 284         chan->size = size;
 285         chan->last_size = 0;
 286         chan->get_more = get_more;
 287
 288         pcm_play_lock();
 289         mixer_activate_channel(chan);
 290         mixer_start_pcm();
 291     }
 292     else
 293     {
 294         /* Never had anything - stop it now */
 295         pcm_play_lock();
 296         channel_stopped(chan);
 297     }
 298 }
 299
 300
 301 /** Public interfaces **/
 302
 303 /* Start playback on a channel */
 304 void mixer_channel_play_data(enum pcm_mixer_channel channel,
 305                              pcm_play_callback_type get_more,
 306                              unsigned char *start, size_t size)
 307 {
 308     struct mixer_channel *chan = &channels[channel];
 309
 310     pcm_play_lock();
 311     mixer_deactivate_channel(chan);
 312     mixer_channel_play_start(chan, get_more, start, size);
 313     pcm_play_unlock();
 314 }
 315
 316 /* Pause or resume a channel (when started) */
 317 void mixer_channel_play_pause(enum pcm_mixer_channel channel, bool play)
 318 {
 319     struct mixer_channel *chan = &channels[channel];
 320
 321     pcm_play_lock();
 322
 323     if (play == (chan->status == CHANNEL_PAUSED) &&
 324         chan->status != CHANNEL_STOPPED)
 325     {
 326         if (play)
 327         {
 328             chan->status = CHANNEL_PLAYING;
 329             mixer_activate_channel(chan);
 330             mixer_start_pcm();
 331         }
 332         else
 333         {
 334             mixer_deactivate_channel(chan);
 335             chan->status = CHANNEL_PAUSED;
 336         }
 337     }
 338
 339     pcm_play_unlock();
 340 }
 341
 342 /* Stop playback on a channel */
 343 void mixer_channel_stop(enum pcm_mixer_channel channel)
 344 {
 345     struct mixer_channel *chan = &channels[channel];
 346
 347     pcm_play_lock();
 348     channel_stopped(chan);
 349     pcm_play_unlock();
 350 }
 351
 352 /* Set channel's amplitude factor */
 353 void mixer_channel_set_amplitude(enum pcm_mixer_channel channel,
 354                                  unsigned int amplitude)
 355 {
 356     channels[channel].amplitude = MIN(amplitude, MIX_AMP_UNITY);
 357 }
 358
 359 /* Return channel's playback status */
 360 enum channel_status mixer_channel_status(enum pcm_mixer_channel channel)
 361 {
 362     return channels[channel].status;
 363 }
 364
 365 /* Returns amount data remaining in channel before next callback */
 366 size_t mixer_channel_get_bytes_waiting(enum pcm_mixer_channel channel)
 367 {
 368     return channels[channel].size;
 369 }
 370
 371 /* Return pointer to channel's playing audio data and the size remaining */
 372 void * mixer_channel_get_buffer(enum pcm_mixer_channel channel, int *count)
 373 {
 374     struct mixer_channel *chan = &channels[channel];
 375     void * buf = *(unsigned char * volatile *)&chan->start;
 376     size_t size = *(size_t volatile *)&chan->size;
 377     void * buf2 = *(unsigned char * volatile *)&chan->start;
 378
 379     /* Still same buffer? */
 380     if (buf == buf2)
 381     {
 382         *count = size >> 2;
 383         return buf;
 384     }
 385     /* else can't be sure buf and size are related */
 386
 387     *count = 0;
 388     return NULL;
 389 }
 390
 391 /* Calculate peak values for channel */
 392 void mixer_channel_calculate_peaks(enum pcm_mixer_channel channel,
 393                                    int *left, int *right)
 394 {
 395     struct mixer_channel *chan = &channels[channel];
 396     struct pcm_peaks *peaks = &channel_peaks[channel];
 397     int count;
 398     const void *addr = mixer_channel_get_buffer(channel, &count);
 399
 400     pcm_do_peak_calculation(peaks, chan->status == CHANNEL_PLAYING,
 401                             addr, count);
 402
 403     if (left)
 404         *left = peaks->val[0];
 405
 406     if (right)
 407         *right = peaks->val[1];
 408 }
 409
 410 /* Stop ALL channels and PCM and reset state */
 411 void mixer_reset(void)
 412 {
 413     pcm_play_stop();
 414
 415     while (*active_channels)
 416         channel_stopped(*active_channels);
 417
 418     idle_counter = 0;
 419 }