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 /* Cheapo buffer align macro to align to the 16-16 PCM size */
  74 #define ALIGN_CHANNEL(start, size) \
  75     ({ start = (void *)(((uintptr_t)start + 3) & ~3); \
  76        size &= ~3; })
  77
  78 #if (CONFIG_PLATFORM & PLATFORM_NATIVE)
  79
  80 /* Include any implemented CPU-optimized mixdown routines */
  81 #if defined(CPU_ARM)
  82 #if ARM_ARCH >= 6
  83 #include "pcm-mixer-armv6.c"
  84 #elif ARM_ARCH >= 5
  85 #include "pcm-mixer-armv5.c"
  86 #else
  87 #include "pcm-mixer-armv4.c"
  88 #endif /* ARM_ARCH */
  89 #elif defined (CPU_COLDFIRE)
  90 #include "pcm-mixer-coldfire.c"
  91 #endif /* CPU_* */
  92
  93 #endif /* CONFIG_PLATFORM */
  94
  95 /** Generic mixing routines **/
  96
  97 #ifndef MIXER_OPTIMIZED_MIX_SAMPLES
  98 /* Clip sample to signed 16 bit range */
  99 static FORCE_INLINE int32_t clip_sample_16(int32_t sample)
 100 {
 101     if ((int16_t)sample != sample)
 102         sample = 0x7fff ^ (sample >> 31);
 103     return sample;
 104 }
 105
 106 /* Mix channels' samples and apply gain factors */
 107 static FORCE_INLINE void mix_samples(uint32_t *out,
 108                                      int16_t *src0,
 109                                      int32_t src0_amp,
 110                                      int16_t *src1,
 111                                      int32_t src1_amp,
 112                                      size_t size)
 113 {
 114     if (src0_amp == MIX_AMP_UNITY && src1_amp == MIX_AMP_UNITY)
 115     {
 116         /* Both are unity amplitude */
 117         do
 118         {
 119             int32_t l = *src0++ + *src1++;
 120             int32_t h = *src0++ + *src1++;
 121             *out++ = (uint16_t)clip_sample_16(l) | (clip_sample_16(h) << 16);
 122         }
 123         while ((size -= 4) > 0);
 124     }
 125     else if (src0_amp != MIX_AMP_UNITY && src1_amp != MIX_AMP_UNITY)
 126     {
 127         /* Neither are unity amplitude */
 128         do
 129         {
 130             int32_t l = (*src0++ * src0_amp >> 16) + (*src1++ * src1_amp >> 16);
 131             int32_t h = (*src0++ * src0_amp >> 16) + (*src1++ * src1_amp >> 16);
 132             *out++ = (uint16_t)clip_sample_16(l) | (clip_sample_16(h) << 16);
 133         }
 134         while ((size -= 4) > 0);
 135     }
 136     else
 137     {
 138         /* One is unity amplitude */
 139         if (src0_amp != MIX_AMP_UNITY)
 140         {
 141             /* Keep unity in src0, amp0 */
 142             int16_t *src_tmp = src0;
 143             src0 = src1;
 144             src1 = src_tmp;
 145             src1_amp = src0_amp;
 146             src0_amp = MIX_AMP_UNITY;
 147         }
 148
 149         do
 150         {
 151             int32_t l = *src0++ + (*src1++ * src1_amp >> 16);
 152             int32_t h = *src0++ + (*src1++ * src1_amp >> 16);
 153             *out++ = (uint16_t)clip_sample_16(l) | (clip_sample_16(h) << 16);
 154         }
 155         while ((size -= 4) > 0);
 156     }
 157 }
 158 #endif /* MIXER_OPTIMIZED_MIX_SAMPLES */
 159
 160 #ifndef MIXER_OPTIMIZED_WRITE_SAMPLES
 161 /* Write channel's samples and apply gain factor */
 162 static FORCE_INLINE void write_samples(uint32_t *out,
 163                                        int16_t *src,
 164                                        int32_t amp,
 165                                        size_t size)
 166 {
 167     if (LIKELY(amp == MIX_AMP_UNITY))
 168     {
 169         /* Channel is unity amplitude */
 170         memcpy(out, src, size);
 171     }
 172     else
 173     {
 174         /* Channel needs amplitude cut */
 175         do
 176         {
 177             int32_t l = *src++ * amp >> 16;
 178             int32_t h = *src++ * amp & 0xffff0000;
 179             *out++ = (uint16_t)l | h;
 180         }
 181         while ((size -= 4) > 0);
 182     }
 183 }
 184 #endif /* MIXER_OPTIMIZED_WRITE_SAMPLES */
 185
 186
 187 /** Private generic routines **/
 188
 189 /* Mark channel active to mix its data */
 190 static void mixer_activate_channel(struct mixer_channel *chan)
 191 {
 192     void **elem = find_array_ptr((void **)active_channels, chan);
 193
 194     if (!*elem)
 195     {
 196         idle_counter = 0;
 197         *elem = chan;
 198     }
 199 }
 200
 201 /* Stop channel from mixing */
 202 static void mixer_deactivate_channel(struct mixer_channel *chan)
 203 {
 204     remove_array_ptr((void **)active_channels, chan);
 205 }
 206
 207 /* Deactivate channel and change it to stopped state */
 208 static void channel_stopped(struct mixer_channel *chan)
 209 {
 210     mixer_deactivate_channel(chan);
 211     chan->size = 0;
 212     chan->start = NULL;
 213     chan->status = CHANNEL_STOPPED;
 214 }
 215
 216 /* Main PCM callback - sends the current prepared frame to play */
 217 static void mixer_pcm_callback(unsigned char **start, size_t *size)
 218 {
 219     *start = (unsigned char *)downmix_buf[downmix_index];
 220     *size = next_size;
 221 }
 222
 223 /* Buffering callback - calls sub-callbacks and mixes the data for next
 224    buffer to be sent from mixer_pcm_callback() */
 225 static void MIXER_CALLBACK_ICODE mixer_buffer_callback(void)
 226 {
 227     downmix_index ^= 1; /* Next buffer */
 228
 229     void *mixptr = downmix_buf[downmix_index];
 230     size_t mixsize = MIX_FRAME_SIZE;
 231     struct mixer_channel **chan_p;
 232
 233     next_size = 0;
 234
 235     /* "Loop" back here if one round wasn't enough to fill a frame */
 236 fill_frame:
 237     chan_p = active_channels;
 238
 239     while (*chan_p)
 240     {
 241         /* Find the active channel with the least data remaining and call any
 242            callbacks for channels that ran out - stopping whichever report
 243            "no more" */
 244         struct mixer_channel *chan = *chan_p;
 245         chan->start += chan->last_size;
 246         chan->size -= chan->last_size;
 247
 248         if (chan->size == 0)
 249         {
 250             if (chan->get_more)
 251             {
 252                 chan->get_more(&chan->start, &chan->size);
 253                 ALIGN_CHANNEL(chan->start, chan->size);
 254             }
 255
 256             if (!(chan->start && chan->size))
 257             {
 258                 /* Channel is stopping */
 259                 channel_stopped(chan);
 260                 continue;
 261             }
 262         }
 263
 264         /* Channel will play for at least part of this frame */
 265
 266         /* Channel with least amount of data remaining determines the downmix
 267            size */
 268         if (chan->size < mixsize)
 269             mixsize = chan->size;
 270
 271         chan_p++;
 272     }
 273
 274     /* Add all still-active channels to the downmix */
 275     chan_p = active_channels;
 276
 277     if (LIKELY(*chan_p))
 278     {
 279         struct mixer_channel *chan = *chan_p++;
 280
 281         if (LIKELY(!*chan_p))
 282         {
 283             write_samples(mixptr, (void *)chan->start,
 284                           chan->amplitude, mixsize);
 285         }
 286         else
 287         {
 288             void *src0, *src1;
 289             unsigned int amp0, amp1;
 290
 291             /* Mix first two channels with each other as the downmix */
 292             src0 = chan->start;
 293             amp0 = chan->amplitude;
 294             chan->last_size = mixsize;
 295
 296             chan = *chan_p++;
 297             src1 = chan->start;
 298             amp1 = chan->amplitude;
 299
 300             while (1)
 301             {
 302                 mix_samples(mixptr, src0, amp0, src1, amp1, mixsize);
 303
 304                 if (!*chan_p)
 305                     break;
 306
 307                 /* More channels to mix - mix each with existing downmix */
 308                 chan->last_size = mixsize;
 309                 chan = *chan_p++;
 310                 src0 = mixptr;
 311                 amp0 = MIX_AMP_UNITY;
 312                 src1 = chan->start;
 313                 amp1 = chan->amplitude;
 314             }
 315         }
 316
 317         chan->last_size = mixsize;
 318         next_size += mixsize;
 319
 320         if (next_size < MIX_FRAME_SIZE)
 321         {
 322             /* There is still space remaining in this frame */
 323             mixptr += mixsize;
 324             mixsize = MIX_FRAME_SIZE - next_size;
 325             goto fill_frame;
 326         }
 327     }
 328     else if (idle_counter++ < MAX_IDLE_FRAMES)
 329     {
 330         /* Pad incomplete frames with silence */
 331         if (idle_counter <= 3)
 332             memset(mixptr, 0, MIX_FRAME_SIZE - next_size);
 333
 334         next_size = MIX_FRAME_SIZE;
 335     }
 336     /* else silence period ran out - go to sleep */
 337
 338 #if FRAME_BOUNDARY_MARKERS != 0
 339     if (next_size)
 340         *downmix_buf[downmix_index] = downmix_index ? 0x7fff7fff : 0x80008000;
 341 #endif
 342 }
 343
 344 /* Start PCM driver if it's not currently playing */
 345 static void mixer_start_pcm(void)
 346 {
 347     if (pcm_is_playing())
 348         return;
 349
 350 #if defined(HAVE_RECORDING)
 351     if (pcm_is_recording())
 352         return;
 353 #endif
 354
 355     /* Requires a shared global sample rate for all channels */
 356     pcm_set_frequency(NATIVE_FREQUENCY);
 357
 358     /* Prepare initial frames and set up the double buffer */
 359     mixer_buffer_callback();
 360
 361     /* Save the previous call's output */
 362     void *start = downmix_buf[downmix_index];
 363
 364     mixer_buffer_callback();
 365
 366     pcm_play_set_dma_started_callback(mixer_buffer_callback);
 367     pcm_play_data(mixer_pcm_callback, start, MIX_FRAME_SIZE);
 368 }
 369
 370 /* Initialize the channel and start it if it has data */
 371 static void mixer_channel_play_start(struct mixer_channel *chan,
 372                                      pcm_play_callback_type get_more,
 373                                      unsigned char *start, size_t size)
 374 {
 375     pcm_play_unlock(); /* Allow playback while doing any callback */
 376
 377     ALIGN_CHANNEL(start, size);
 378
 379     if (!(start && size))
 380     {
 381         /* Initial buffer not passed - call the callback now */
 382         size = 0;
 383         if (get_more)
 384         {
 385             get_more(&start, &size);
 386             ALIGN_CHANNEL(start, size);
 387         }
 388     }
 389
 390     if (start && size)
 391     {
 392         /* We have data - start the channel */
 393         chan->status = CHANNEL_PLAYING;
 394         chan->start = start;
 395         chan->size = size;
 396         chan->last_size = 0;
 397         chan->get_more = get_more;
 398
 399         pcm_play_lock();
 400         mixer_activate_channel(chan);
 401         mixer_start_pcm();
 402     }
 403     else
 404     {
 405         /* Never had anything - stop it now */
 406         pcm_play_lock();
 407         channel_stopped(chan);
 408     }
 409 }
 410
 411
 412 /** Public interfaces **/
 413
 414 /* Start playback on a channel */
 415 void mixer_channel_play_data(enum pcm_mixer_channel channel,
 416                              pcm_play_callback_type get_more,
 417                              unsigned char *start, size_t size)
 418 {
 419     struct mixer_channel *chan = &channels[channel];
 420
 421     pcm_play_lock();
 422     mixer_deactivate_channel(chan);
 423     mixer_channel_play_start(chan, get_more, start, size);
 424     pcm_play_unlock();
 425 }
 426
 427 /* Pause or resume a channel (when started) */
 428 void mixer_channel_play_pause(enum pcm_mixer_channel channel, bool play)
 429 {
 430     struct mixer_channel *chan = &channels[channel];
 431
 432     pcm_play_lock();
 433
 434     if (play == (chan->status == CHANNEL_PAUSED) &&
 435         chan->status != CHANNEL_STOPPED)
 436     {
 437         if (play)
 438         {
 439             chan->status = CHANNEL_PLAYING;
 440             mixer_activate_channel(chan);
 441             mixer_start_pcm();
 442         }
 443         else
 444         {
 445             mixer_deactivate_channel(chan);
 446             chan->status = CHANNEL_PAUSED;
 447         }
 448     }
 449
 450     pcm_play_unlock();
 451 }
 452
 453 /* Stop playback on a channel */
 454 void mixer_channel_stop(enum pcm_mixer_channel channel)
 455 {
 456     struct mixer_channel *chan = &channels[channel];
 457
 458     pcm_play_lock();
 459     channel_stopped(chan);
 460     pcm_play_unlock();
 461 }
 462
 463 /* Set channel's amplitude factor */
 464 void mixer_channel_set_amplitude(enum pcm_mixer_channel channel,
 465                                  unsigned int amplitude)
 466 {
 467     channels[channel].amplitude = MIN(amplitude, MIX_AMP_UNITY);
 468 }
 469
 470 /* Return channel's playback status */
 471 enum channel_status mixer_channel_status(enum pcm_mixer_channel channel)
 472 {
 473     return channels[channel].status;
 474 }
 475
 476 /* Returns amount data remaining in channel before next callback */
 477 size_t mixer_channel_get_bytes_waiting(enum pcm_mixer_channel channel)
 478 {
 479     return channels[channel].size;
 480 }
 481
 482 /* Return pointer to channel's playing audio data and the size remaining */
 483 void * mixer_channel_get_buffer(enum pcm_mixer_channel channel, int *count)
 484 {
 485     struct mixer_channel *chan = &channels[channel];
 486     void * buf = *(unsigned char * volatile *)&chan->start;
 487     size_t size = *(size_t volatile *)&chan->size;
 488     void * buf2 = *(unsigned char * volatile *)&chan->start;
 489
 490     /* Still same buffer? */
 491     if (buf == buf2)
 492     {
 493         *count = size >> 2;
 494         return buf;
 495     }
 496     /* else can't be sure buf and size are related */
 497
 498     *count = 0;
 499     return NULL;
 500 }
 501
 502 /* Calculate peak values for channel */
 503 void mixer_channel_calculate_peaks(enum pcm_mixer_channel channel,
 504                                    int *left, int *right)
 505 {
 506     struct mixer_channel *chan = &channels[channel];
 507     struct pcm_peaks *peaks = &channel_peaks[channel];
 508     int count;
 509     const void *addr = mixer_channel_get_buffer(channel, &count);
 510
 511     pcm_do_peak_calculation(peaks, chan->status == CHANNEL_PLAYING,
 512                             addr, count);
 513
 514     if (left)
 515         *left = peaks->val[0];
 516
 517     if (right)
 518         *right = peaks->val[1];
 519 }
 520
 521 /* Stop ALL channels and PCM and reset state */
 522 void mixer_reset(void)
 523 {
 524     pcm_play_stop();
 525
 526     while (*active_channels)
 527         channel_stopped(*active_channels);
 528
 529     idle_counter = 0;
 530 }