28 files changed, 1462 insertions, 69 deletions

diff --git a/firmware/SOURCES b/firmware/SOURCES
index 7c3a909f22..85d9a28f1b 100644
--- a/firmware/SOURCES
+++ b/firmware/SOURCES
@@ -311,6 +311,7 @@ sound.c
 #ifndef BOOTLOADER
 pcm_sampr.c
 pcm.c
+pcm_mixer.c
 #ifdef HAVE_RECORDING
 enc_base.c
 #endif /* HAVE_RECORDING */
diff --git a/firmware/export/config.h b/firmware/export/config.h
index 2c7c6e89db..70047ff866 100644
--- a/firmware/export/config.h
+++ b/firmware/export/config.h
@@ -1048,4 +1048,9 @@ Lyre prototype 1 */
 #define HAVE_IO_PRIORITY
 #endif
 
+#if defined(CPU_COLDIRE) || CONFIG_CPU == IMX31L
+/* Can record and play simultaneously */
+#define HAVE_PCM_FULL_DUPLEX
+#endif
+
 #endif /* __CONFIG_H__ */
diff --git a/firmware/export/pcm-internal.h b/firmware/export/pcm-internal.h
new file mode 100644
index 0000000000..d69138f534
--- /dev/null
+++ b/firmware/export/pcm-internal.h
@@ -0,0 +1,81 @@
+/***************************************************************************
+ *             __________               __   ___.
+ *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
+ *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
+ *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
+ *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
+ *                     \/            \/     \/    \/            \/
+ * $Id$
+ *
+ * Copyright (C) 2005 by Linus Nielsen Feltzing
+ * Copyright (C) 2011 by Michael Sevakis
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ****************************************************************************/
+#ifndef PCM_INTERNAL_H
+#define PCM_INTERNAL_H
+
+/** The following are for internal use between pcm.c and target-
+    specific portion **/
+
+/* Called by the bottom layer ISR when more data is needed. Returns non-
+ * zero size if more data is to be played. Setting start to NULL
+ * forces stop. */
+void pcm_play_get_more_callback(void **start, size_t *size);
+
+/* Called by the bottom layer ISR after next transfer has begun in order
+   to fill more data for next "get more" callback to implement double-buffered
+   callbacks - except for a couple ASM handlers, help drivers to implement
+   this functionality with minimal overhead */
+static FORCE_INLINE void pcm_play_dma_started_callback(void)
+{
+    extern void (* pcm_play_dma_started)(void);
+    void (* callback)(void) = pcm_play_dma_started;
+    if (callback)
+        callback();
+}
+
+extern unsigned long pcm_curr_sampr;
+extern unsigned long pcm_sampr;
+extern int pcm_fsel;
+
+#ifdef HAVE_PCM_DMA_ADDRESS
+void * pcm_dma_addr(void *addr);
+#endif
+
+extern volatile bool pcm_playing;
+extern volatile bool pcm_paused;
+
+void pcm_play_dma_lock(void);
+void pcm_play_dma_unlock(void);
+void pcm_play_dma_init(void) INIT_ATTR;
+void pcm_play_dma_start(const void *addr, size_t size);
+void pcm_play_dma_stop(void);
+void pcm_play_dma_pause(bool pause);
+const void * pcm_play_dma_get_peak_buffer(int *count);
+
+void pcm_dma_apply_settings(void);
+
+#ifdef HAVE_RECORDING
+
+/* DMA transfer in is currently active */
+extern volatile bool pcm_recording;
+
+/* APIs implemented in the target-specific portion */
+void pcm_rec_dma_init(void);
+void pcm_rec_dma_close(void);
+void pcm_rec_dma_start(void *addr, size_t size);
+void pcm_rec_dma_record_more(void *start, size_t size);
+void pcm_rec_dma_stop(void);
+const void * pcm_rec_dma_get_peak_buffer(void);
+
+#endif /* HAVE_RECORDING */
+
+#endif /* PCM_INTERNAL_H */
diff --git a/firmware/export/pcm.h b/firmware/export/pcm.h
index 80b5b09a79..22c5ef350e 100644
--- a/firmware/export/pcm.h
+++ b/firmware/export/pcm.h
@@ -49,7 +49,7 @@
 
 /** RAW PCM routines used with playback and recording **/
 
-/* Typedef for registered callback */
+/* Typedef for registered callbacks */
 typedef void (*pcm_play_callback_type)(unsigned char **start,
                                        size_t *size);
 typedef void (*pcm_rec_callback_type)(int status, void **start, size_t *size);
@@ -90,34 +90,7 @@ void pcm_play_pause(bool play);
 bool pcm_is_paused(void);
 bool pcm_is_playing(void);
 
-/** The following are for internal use between pcm.c and target-
-    specific portion **/
-
-/* Called by the bottom layer ISR when more data is needed. Returns non-
- * zero size if more data is to be played. Setting start to NULL
- * forces stop. */
-void pcm_play_get_more_callback(void **start, size_t *size);
-
-extern unsigned long pcm_curr_sampr;
-extern unsigned long pcm_sampr;
-extern int pcm_fsel;
-
-#ifdef HAVE_PCM_DMA_ADDRESS
-void * pcm_dma_addr(void *addr);
-#endif
-
-extern volatile bool pcm_playing;
-extern volatile bool pcm_paused;
-
-void pcm_play_dma_lock(void);
-void pcm_play_dma_unlock(void);
-void pcm_play_dma_init(void) INIT_ATTR;
-void pcm_play_dma_start(const void *addr, size_t size);
-void pcm_play_dma_stop(void);
-void pcm_play_dma_pause(bool pause);
-const void * pcm_play_dma_get_peak_buffer(int *count);
-
-void pcm_dma_apply_settings(void);
+void pcm_play_set_dma_started_callback(void (* callback)(void));
 
 #ifdef HAVE_RECORDING
 
@@ -148,19 +121,6 @@ void pcm_rec_more_ready_callback(int status, void **start, size_t *size);
 
 void pcm_calculate_rec_peaks(int *left, int *right);
 
-/** The following are for internal use between pcm.c and target-
-    specific portion **/
-/* DMA transfer in is currently active */
-extern volatile bool pcm_recording;
-
-/* APIs implemented in the target-specific portion */
-void pcm_rec_dma_init(void);
-void pcm_rec_dma_close(void);
-void pcm_rec_dma_start(void *addr, size_t size);
-void pcm_rec_dma_record_more(void *start, size_t size);
-void pcm_rec_dma_stop(void);
-const void * pcm_rec_dma_get_peak_buffer(void);
-
 #endif /* HAVE_RECORDING */
 
 #endif /* PCM_PLAYBACK_H */
diff --git a/firmware/export/pcm_mixer.h b/firmware/export/pcm_mixer.h
new file mode 100644
index 0000000000..3b420e1320
--- /dev/null
+++ b/firmware/export/pcm_mixer.h
@@ -0,0 +1,102 @@
+/***************************************************************************
+ *             __________               __   ___.
+ *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
+ *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
+ *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
+ *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
+ *                     \/            \/     \/    \/            \/
+ * $Id$
+ *
+ * Copyright (C) 2011 by Michael Sevakis
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ****************************************************************************/
+
+#ifndef PCM_MIXER_H
+#define PCM_MIXER_H
+
+/** Simple config **/
+
+/* Length of PCM frames (always) */
+#if CONFIG_CPU == PP5002
+/* There's far less time to do mixing because HW FIFOs are short */
+#define MIX_FRAME_SAMPLES 64
+#else
+/* Assume HW DMA engine is available or sufficient latency exists in the
+   PCM pathway */
+#define MIX_FRAME_SAMPLES 256
+#endif
+
+#if defined(CPU_COLDFIRE) || defined(CPU_PP)
+/* For Coldfire, it's just faster
+   For PortalPlayer, this also avoids more expensive cache coherency */
+#define DOWNMIX_BUF_IBSS    IBSS_ATTR
+#else
+/* Otherwise can't DMA from IRAM, IRAM is pointless or worse */
+#define DOWNMIX_BUF_IBSS
+#endif
+
+
+/** Definitions **/
+
+/* Channels are preassigned for simplicity */
+enum pcm_mixer_channel
+{
+    PCM_MIXER_CHAN_PLAYBACK = 0,
+    PCM_MIXER_CHAN_VOICE,
+#ifndef HAVE_HARDWARE_BEEP
+    PCM_MIXER_CHAN_BEEP,
+#endif
+    /* Add new channel indexes above this line */
+    PCM_MIXER_NUM_CHANNELS,
+};
+
+/* Channel playback states */
+enum channel_status
+{
+    CHANNEL_STOPPED = 0,
+    CHANNEL_PLAYING,
+    CHANNEL_PAUSED,
+};
+
+#define MIX_AMP_UNITY    0x00010000
+#define MIX_AMP_MUTE     0x00000000
+
+
+/** Public interfaces **/
+
+/* Start playback on a channel */
+void mixer_channel_play_data(enum pcm_mixer_channel channel,
+                             pcm_play_callback_type get_more,
+                             unsigned char *start, size_t size);
+
+/* Pause or resume a channel (when started) */
+void mixer_channel_play_pause(enum pcm_mixer_channel channel, bool play);
+
+/* Stop playback on a channel */
+void mixer_channel_stop(enum pcm_mixer_channel channel);
+
+/* Set channel's amplitude factor */
+void mixer_channel_set_amplitude(enum pcm_mixer_channel channel,
+                                 unsigned int amplitude);
+
+/* Return channel's playback status */
+enum channel_status mixer_channel_status(enum pcm_mixer_channel channel);
+
+/* Returns amount data remaining in channel before next callback */
+size_t mixer_channel_get_bytes_waiting(enum pcm_mixer_channel channel);
+
+/* Return pointer to channel's playing audio data and the size remaining */
+void * mixer_channel_get_buffer(enum pcm_mixer_channel channel, int *count);
+
+/* Stop ALL channels and PCM and reset state */
+void mixer_reset(void);
+
+#endif /* PCM_MIXER_H */
diff --git a/firmware/pcm.c b/firmware/pcm.c
index d15c129015..b7415f329b 100644
--- a/firmware/pcm.c
+++ b/firmware/pcm.c
@@ -28,6 +28,8 @@
 #include "audio.h"
 #include "sound.h"
 #include "general.h"
+#include "pcm-internal.h"
+#include "pcm_mixer.h"
 
 /**
  * Aspects implemented in the target-specific portion:
@@ -78,8 +80,8 @@
  */
 
 /* the registered callback function to ask for more mp3 data */
-static volatile pcm_play_callback_type pcm_callback_for_more
-    SHAREDBSS_ATTR = NULL;
+static pcm_play_callback_type pcm_callback_for_more SHAREDBSS_ATTR = NULL;
+void (* pcm_play_dma_started)(void) SHAREDBSS_ATTR = NULL;
 /* PCM playback state */
 volatile bool pcm_playing SHAREDBSS_ATTR = false;
 /* PCM paused state. paused implies playing */
@@ -95,6 +97,7 @@ int pcm_fsel SHAREDBSS_ATTR = HW_FREQ_DEFAULT;
 static void pcm_play_stopped(void)
 {
     pcm_callback_for_more = NULL;
+    pcm_play_dma_started = NULL;
     pcm_paused = false;
     pcm_playing = false;
 }
@@ -404,6 +407,12 @@ void pcm_apply_settings(void)
     }
 }
 
+/* register callback to buffer more data */
+void pcm_play_set_dma_started_callback(void (* callback)(void))
+{
+    pcm_play_dma_started = callback;
+}
+
 #ifdef HAVE_RECORDING
 /** Low level pcm recording apis **/
 
@@ -475,6 +484,11 @@ void pcm_init_recording(void)
 {
     logf("pcm_init_recording");
 
+#ifndef HAVE_PCM_FULL_DUPLEX
+    /* Stop the beasty before attempting recording */
+    mixer_reset();
+#endif
+
     /* Recording init is locked unlike general pcm init since this is not
      * just a one-time event at startup and it should and must be safe by
      * now. */
diff --git a/firmware/pcm_mixer.c b/firmware/pcm_mixer.c
new file mode 100644
index 0000000000..cddd3f0f86
--- /dev/null
+++ b/firmware/pcm_mixer.c
@@ -0,0 +1,501 @@
+/***************************************************************************
+ *             __________               __   ___.
+ *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
+ *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
+ *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
+ *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
+ *                     \/            \/     \/    \/            \/
+ * $Id$
+ *
+ * Copyright (C) 2011 by Michael Sevakis
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ****************************************************************************/
+#include "config.h"
+#include "system.h"
+#include "general.h"
+#include "kernel.h"
+#include "pcm.h"
+#include "pcm_mixer.h"
+#include "dsp.h"
+
+/* Channels use standard-style PCM callback interface but a latency of one
+   frame by double-buffering is introduced in order to facilitate mixing and
+   keep the hardware fed. There must be sufficient time to perform operations
+   before the last samples are sent to the codec and so things are done in
+   parallel (as much as possible) with sending-out data. */
+
+/* Define this to nonzero to add a marker pulse at each frame start */
+#define FRAME_BOUNDARY_MARKERS 0
+
+/* Descriptor for each channel */
+struct mixer_channel
+{
+    unsigned char *start;            /* Buffer pointer */
+    size_t size;                     /* Bytes remaining */
+    size_t last_size;                /* Size of consumed data in prev. cycle */
+    pcm_play_callback_type get_more; /* Registered callback */
+    enum channel_status status;      /* Playback status */
+    uint32_t amplitude;              /* Amp. factor: 0x0000 = mute, 0x10000 = unity */
+};
+
+/* Forget about boost here for the moment */
+#define MIX_FRAME_SIZE      (MIX_FRAME_SAMPLES*4)
+
+/* Because of the double-buffering, playback is always from here, otherwise a
+   mechanism for the channel callbacks not to free buffers too early would be
+   needed (if we _really_ want it and it's worth it, we _can_ do that ;-) ) */
+static uint32_t downmix_buf[2][MIX_FRAME_SAMPLES] DOWNMIX_BUF_IBSS MEM_ALIGN_ATTR;
+static int downmix_index = 0;   /* Which downmix_buf? */
+static size_t next_size = 0;    /* Size of buffer to play next time */
+
+/* Descriptors for all available channels */
+static struct mixer_channel channels[PCM_MIXER_NUM_CHANNELS] IBSS_ATTR;
+
+/* Packed pointer array of all playing (active) channels in "channels" array */
+static struct mixer_channel * active_channels[PCM_MIXER_NUM_CHANNELS+1] IBSS_ATTR;
+
+/* Number of silence frames to play after all data has played */
+#define MAX_IDLE_FRAMES     (NATIVE_FREQUENCY*3 / MIX_FRAME_SAMPLES)
+static unsigned int idle_counter = 0;
+
+/* Cheapo buffer align macro to align to the 16-16 PCM size */
+#define ALIGN_CHANNEL(start, size) \
+    ({ start = (void *)(((uintptr_t)start + 3) & ~3); \
+       size &= ~3; })
+
+/* Include any implemented CPU-optimized mixdown routines */
+#if defined(CPU_ARM)
+#if ARM_ARCH >= 6
+#include "pcm-mixer-armv6.c"
+#elif ARM_ARCH >= 5
+#include "pcm-mixer-armv5.c"
+#else
+#include "pcm-mixer-armv4.c"
+#endif /* ARM_ARCH */
+#elif defined (CPU_COLDFIRE)
+#include "pcm-mixer-coldfire.c"
+#endif /* CPU_* */
+
+
+/** Generic mixing routines **/
+
+#ifndef MIXER_OPTIMIZED_MIX_SAMPLES
+/* Clip sample to signed 16 bit range */
+static FORCE_INLINE int32_t clip_sample_16(int32_t sample)
+{
+    if ((int16_t)sample != sample)
+        sample = 0x7fff ^ (sample >> 31);
+    return sample;
+}
+
+/* Mix channels' samples and apply gain factors */
+static FORCE_INLINE void mix_samples(uint32_t *out,
+                                     int16_t *src0,
+                                     int32_t src0_amp,
+                                     int16_t *src1,
+                                     int32_t src1_amp,
+                                     size_t size)
+{
+    if (src0_amp == MIX_AMP_UNITY && src1_amp == MIX_AMP_UNITY)
+    {
+        /* Both are unity amplitude */
+        do
+        {
+            int32_t l = *src0++ + *src1++;
+            int32_t h = *src0++ + *src1++;
+            *out++ = (uint16_t)clip_sample_16(l) | (clip_sample_16(h) << 16);
+        }
+        while ((size -= 4) > 0);
+    }
+    else if (src0_amp != MIX_AMP_UNITY && src1_amp != MIX_AMP_UNITY)
+    {
+        /* Neither are unity amplitude */
+        do
+        {
+            int32_t l = (*src0++ * src0_amp >> 16) + (*src1++ * src1_amp >> 16);
+            int32_t h = (*src0++ * src0_amp >> 16) + (*src1++ * src1_amp >> 16);
+            *out++ = (uint16_t)clip_sample_16(l) | (clip_sample_16(h) << 16);
+        }
+        while ((size -= 4) > 0);
+    }
+    else
+    {
+        /* One is unity amplitude */
+        if (src0_amp != MIX_AMP_UNITY)
+        {
+            /* Keep unity in src0, amp0 */
+            int16_t *src_tmp = src0;
+            src0 = src1;
+            src1 = src_tmp;
+            src1_amp = src0_amp;
+            src0_amp = MIX_AMP_UNITY;
+        }
+
+        do
+        {
+            int32_t l = *src0++ + (*src1++ * src1_amp >> 16);
+            int32_t h = *src0++ + (*src1++ * src1_amp >> 16);
+            *out++ = (uint16_t)clip_sample_16(l) | (clip_sample_16(h) << 16);
+        }
+        while ((size -= 4) > 0);
+    }
+}
+#endif /* MIXER_OPTIMIZED_MIX_SAMPLES */
+
+#ifndef MIXER_OPTIMIZED_WRITE_SAMPLES
+/* Write channel's samples and apply gain factor */
+static FORCE_INLINE void write_samples(uint32_t *out,
+                                       int16_t *src,
+                                       int32_t amp,
+                                       size_t size)
+{
+    if (LIKELY(amp == MIX_AMP_UNITY))
+    {
+        /* Channel is unity amplitude */
+        memcpy(out, src, size);
+    }
+    else
+    {
+        /* Channel needs amplitude cut */
+        do
+        {
+            int32_t l = *src++ * amp >> 16;
+            int32_t h = *src++ * amp & 0xffff0000;
+            *out++ = (uint16_t)l | h;
+        }
+        while ((size -= 4) > 0);
+    }     
+}
+#endif /* MIXER_OPTIMIZED_WRITE_SAMPLES */
+
+
+/** Private generic routines **/
+
+/* Mark channel active to mix its data */
+static void mixer_activate_channel(struct mixer_channel *chan)
+{
+    void **elem = find_array_ptr((void **)active_channels, chan);
+
+    if (!*elem)
+    {
+        idle_counter = 0;
+        *elem = chan;
+    }
+}
+
+/* Stop channel from mixing */
+static void mixer_deactivate_channel(struct mixer_channel *chan)
+{
+    remove_array_ptr((void **)active_channels, chan);
+}
+
+/* Deactivate channel and change it to stopped state */
+static void channel_stopped(struct mixer_channel *chan)
+{
+    mixer_deactivate_channel(chan);
+    chan->size = 0;
+    chan->start = NULL;
+    chan->status = CHANNEL_STOPPED;
+}
+
+/* Main PCM callback - sends the current prepared frame to play */
+static void mixer_pcm_callback(unsigned char **start, size_t *size)
+{
+    *start = (unsigned char *)downmix_buf[downmix_index];
+    *size = next_size;
+}
+
+/* Buffering callback - calls sub-callbacks and mixes the data for next
+   buffer to be sent from mixer_pcm_callback() */
+static void ICODE_ATTR mixer_buffer_callback(void)
+{
+    downmix_index ^= 1; /* Next buffer */
+
+    void *mixptr = downmix_buf[downmix_index];
+    size_t mixsize = MIX_FRAME_SIZE;
+    struct mixer_channel **chan_p;
+
+    next_size = 0;
+
+    /* "Loop" back here if one round wasn't enough to fill a frame */
+fill_frame:
+    chan_p = active_channels;
+
+    while (*chan_p)
+    {
+        /* Find the active channel with the least data remaining and call any
+           callbacks for channels that ran out - stopping whichever report
+           "no more" */
+        struct mixer_channel *chan = *chan_p;
+        chan->start += chan->last_size;
+        chan->size -= chan->last_size;
+
+        if (chan->size == 0)
+        {
+            if (chan->get_more)
+            {
+                chan->get_more(&chan->start, &chan->size);
+                ALIGN_CHANNEL(chan->start, chan->size);
+            }
+
+            if (!(chan->start && chan->size))
+            {
+                /* Channel is stopping */
+                channel_stopped(chan);
+                continue;
+            }
+        }
+
+        /* Channel will play for at least part of this frame */
+
+        /* Channel with least amount of data remaining determines the downmix
+           size */
+        if (chan->size < mixsize)
+            mixsize = chan->size;
+
+        chan_p++;
+    }
+
+    /* Add all still-active channels to the downmix */
+    chan_p = active_channels;
+
+    if (LIKELY(*chan_p))
+    {
+        struct mixer_channel *chan = *chan_p++;
+
+        if (LIKELY(!*chan_p))
+        {
+            write_samples(mixptr, (void *)chan->start,
+                          chan->amplitude, mixsize);
+        }
+        else
+        {
+            void *src0, *src1;
+            unsigned int amp0, amp1;
+
+            /* Mix first two channels with each other as the downmix */
+            src0 = chan->start;
+            amp0 = chan->amplitude;
+            chan->last_size = mixsize;
+
+            chan = *chan_p++;
+            src1 = chan->start;
+            amp1 = chan->amplitude;
+
+            while (1)
+            {
+                mix_samples(mixptr, src0, amp0, src1, amp1, mixsize);
+
+                if (!*chan_p)
+                    break;
+
+                /* More channels to mix - mix each with existing downmix */
+                chan->last_size = mixsize;
+                chan = *chan_p++;
+                src0 = mixptr;
+                amp0 = MIX_AMP_UNITY;
+                src1 = chan->start;
+                amp1 = chan->amplitude;
+            }
+        }
+
+        chan->last_size = mixsize;
+        next_size += mixsize;
+
+        if (next_size < MIX_FRAME_SIZE)
+        {
+            /* There is still space remaining in this frame */
+            mixptr += mixsize;
+            mixsize = MIX_FRAME_SIZE - next_size;
+            goto fill_frame;
+        }
+    }
+    else if (idle_counter++ < MAX_IDLE_FRAMES)
+    {
+        /* Pad incomplete frames with silence */
+        if (idle_counter <= 3)
+            memset(mixptr, 0, MIX_FRAME_SIZE - next_size);
+
+        next_size = MIX_FRAME_SIZE;
+    }
+    /* else silence period ran out - go to sleep */
+
+#if FRAME_BOUNDARY_MARKERS != 0
+    if (next_size)
+        *downmix_buf[downmix_index] = downmix_index ? 0x7fff7fff : 0x80008000;
+#endif
+}
+
+/* Start PCM driver if it's not currently playing */
+static void mixer_start_pcm(void)
+{
+    if (pcm_is_playing())
+        return;
+
+#if defined(HAVE_RECORDING) && !defined(HAVE_PCM_FULL_DUPLEX)
+    if (pcm_is_recording())
+        return;
+#endif
+
+    /* Prepare initial frames and set up the double buffer */
+    mixer_buffer_callback();
+
+    /* Save the previous call's output */
+    void *start = downmix_buf[downmix_index];
+
+    mixer_buffer_callback();
+
+    pcm_play_set_dma_started_callback(mixer_buffer_callback);
+    pcm_play_data(mixer_pcm_callback, start, MIX_FRAME_SIZE);
+}
+
+/* Initialize the channel and start it if it has data */
+static void mixer_channel_play_start(struct mixer_channel *chan,
+                                     pcm_play_callback_type get_more,
+                                     unsigned char *start, size_t size)
+{
+    pcm_play_unlock(); /* Allow playback while doing any callback */
+
+    ALIGN_CHANNEL(start, size);
+
+    if (!(start && size))
+    {
+        /* Initial buffer not passed - call the callback now */
+        size = 0;
+        if (get_more)
+        {
+            get_more(&start, &size);
+            ALIGN_CHANNEL(start, size);
+        }
+    }
+
+    if (start && size)
+    {
+        /* We have data - start the channel */
+        chan->status = CHANNEL_PLAYING;
+        chan->start = start;
+        chan->size = size;
+        chan->last_size = 0;
+        chan->get_more = get_more;
+
+        pcm_play_lock();
+        mixer_activate_channel(chan);
+        mixer_start_pcm();
+    }
+    else
+    {
+        /* Never had anything - stop it now */
+        pcm_play_lock();
+        channel_stopped(chan);
+    }
+}
+
+
+/** Public interfaces **/
+
+/* Start playback on a channel */
+void mixer_channel_play_data(enum pcm_mixer_channel channel,
+                             pcm_play_callback_type get_more,
+                             unsigned char *start, size_t size)
+{
+    struct mixer_channel *chan = &channels[channel];
+
+    pcm_play_lock();
+    mixer_deactivate_channel(chan);
+    mixer_channel_play_start(chan, get_more, start, size);
+    pcm_play_unlock();
+}
+
+/* Pause or resume a channel (when started) */
+void mixer_channel_play_pause(enum pcm_mixer_channel channel, bool play)
+{
+    struct mixer_channel *chan = &channels[channel];
+
+    pcm_play_lock();
+
+    if (play == (chan->status == CHANNEL_PAUSED) &&
+        chan->status != CHANNEL_STOPPED)
+    {
+        if (play)
+        {
+            chan->status = CHANNEL_PLAYING;
+            mixer_activate_channel(chan);
+            mixer_start_pcm();
+        }
+        else
+        {
+            mixer_deactivate_channel(chan);
+            chan->status = CHANNEL_PAUSED;
+        }
+    }
+
+    pcm_play_unlock();
+}
+
+/* Stop playback on a channel */
+void mixer_channel_stop(enum pcm_mixer_channel channel)
+{
+    struct mixer_channel *chan = &channels[channel];
+
+    pcm_play_lock();
+    channel_stopped(chan);
+    pcm_play_unlock();
+}
+
+/* Set channel's amplitude factor */
+void mixer_channel_set_amplitude(enum pcm_mixer_channel channel,
+                                 unsigned int amplitude)
+{
+    channels[channel].amplitude = MIN(amplitude, MIX_AMP_UNITY);
+}
+
+/* Return channel's playback status */
+enum channel_status mixer_channel_status(enum pcm_mixer_channel channel)
+{
+    return channels[channel].status;
+}
+
+/* Returns amount data remaining in channel before next callback */
+size_t mixer_channel_get_bytes_waiting(enum pcm_mixer_channel channel)
+{
+    return channels[channel].size;
+}
+
+/* Return pointer to channel's playing audio data and the size remaining */
+void * mixer_channel_get_buffer(enum pcm_mixer_channel channel, int *count)
+{
+    struct mixer_channel *chan = &channels[channel];
+    void * buf = *(unsigned char * volatile *)&chan->start;
+    size_t size = *(size_t volatile *)&chan->size;
+    void * buf2 = *(unsigned char * volatile *)&chan->start;
+
+    /* Still same buffer? */
+    if (buf == buf2)
+    {
+        *count = size >> 2;
+        return buf;
+    }
+    /* else can't be sure buf and size are related */
+
+    *count = 0;
+    return NULL;
+}
+
+/* Stop ALL channels and PCM and reset state */
+void mixer_reset(void)
+{
+    pcm_play_stop();
+
+    while (*active_channels)
+        channel_stopped(*active_channels);
+
+    idle_counter = 0;
+}
diff --git a/firmware/target/arm/as3525/pcm-as3525.c b/firmware/target/arm/as3525/pcm-as3525.c
index 469833b05c..1b22d48f7f 100644
--- a/firmware/target/arm/as3525/pcm-as3525.c
+++ b/firmware/target/arm/as3525/pcm-as3525.c
@@ -29,6 +29,7 @@
 #include "as3514.h"
 #include "audiohw.h"
 #include "mmu-arm.h"
+#include "pcm-internal.h"
 
 #define MAX_TRANSFER (4*((1<<11)-1)) /* maximum data we can transfer via DMA
                                       * i.e. 32 bits at once (size of I2SO_DATA)
@@ -104,9 +105,13 @@ static void dma_callback(void)
 
         /* force writeback */
         clean_dcache_range(dma_start_addr, dma_start_size);
+        play_start_pcm();
+        pcm_play_dma_started_callback();
+    }
+    else
+    {
+        play_start_pcm();
     }
-
-    play_start_pcm();
 }
 
 void pcm_play_dma_start(const void *addr, size_t size)
diff --git a/firmware/target/arm/imx31/gigabeat-s/pcm-gigabeat-s.c b/firmware/target/arm/imx31/gigabeat-s/pcm-gigabeat-s.c
index c8c1283d12..1f6eef435a 100644
--- a/firmware/target/arm/imx31/gigabeat-s/pcm-gigabeat-s.c
+++ b/firmware/target/arm/imx31/gigabeat-s/pcm-gigabeat-s.c
@@ -26,6 +26,7 @@
 #include "ccm-imx31.h"
 #include "sdma-imx31.h"
 #include "mmu-imx31.h"
+#include "pcm-internal.h"
 
 #define DMA_PLAY_CH_NUM 2
 #define DMA_REC_CH_NUM 1
@@ -105,6 +106,8 @@ static void play_dma_callback(void)
     dma_play_bd.mode.command = TRANSFER_16BIT;
     dma_play_bd.mode.status = BD_DONE | BD_WRAP | BD_INTR;
     sdma_channel_run(DMA_PLAY_CH_NUM);
+
+    pcm_play_dma_started_callback();
 }
 
 void pcm_play_lock(void)
diff --git a/firmware/target/arm/pcm-mixer-armv4.c b/firmware/target/arm/pcm-mixer-armv4.c
new file mode 100644
index 0000000000..4818544d7b
--- /dev/null
+++ b/firmware/target/arm/pcm-mixer-armv4.c
@@ -0,0 +1,182 @@
+/***************************************************************************
+ *             __________               __   ___.
+ *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
+ *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
+ *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
+ *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
+ *                     \/            \/     \/    \/            \/
+ * $Id$
+ *
+ * Copyright (C) 2011 by Michael Sevakis
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ****************************************************************************/
+
+#define MIXER_OPTIMIZED_WRITE_SAMPLES
+#define MIXER_OPTIMIZED_MIX_SAMPLES
+
+/* Mix channels' samples and apply gain factors */
+static FORCE_INLINE void mix_samples(void *out,
+                                     void *src0,
+                                     int32_t src0_amp,
+                                     void *src1,
+                                     int32_t src1_amp,
+                                     size_t size)
+{
+    if (src0_amp == MIX_AMP_UNITY && src1_amp == MIX_AMP_UNITY)
+    {
+        /* Both are unity amplitude */
+        int32_t l0, l1, h0, h1;
+        asm volatile (
+        "1:                             \n"
+            "ldrsh  %4, [%1], #2        \n"
+            "ldrsh  %5, [%2], #2        \n"
+            "ldrsh  %6, [%1], #2        \n"
+            "ldrsh  %7, [%2], #2        \n"
+            "add    %4, %4, %5          \n"
+            "add    %6, %6, %7          \n"
+            "mov    %5, %4, asr #15     \n"
+            "teq    %5, %5, asr #31     \n"
+            "eorne  %4, %8, %4, asr #31 \n"
+            "mov    %7, %6, asr #15     \n"
+            "teq    %7, %7, asr #31     \n"
+            "eorne  %6, %8, %6, asr #31 \n"
+            "subs   %3, %3, #4          \n"
+            "and    %4, %4, %8, lsr #16 \n"
+            "orr    %6, %4, %6, lsl #16 \n"
+            "str    %6, [%0], #4        \n"
+            "bhi    1b                  \n"
+            : "+r"(out), "+r"(src0), "+r"(src1), "+r"(size),
+              "=&r"(l0), "=&r"(l1), "=&r"(h0), "=&r"(h1)
+            : "r"(0xffff7fff));
+    }
+    else if (src0_amp != MIX_AMP_UNITY && src1_amp != MIX_AMP_UNITY)
+    {
+        /* Neither are unity amplitude */
+        int32_t l0, l1, h0, h1;
+        asm volatile (
+        "1:                              \n"
+            "ldrsh  %4, [%1], #2         \n"
+            "ldrsh  %5, [%2], #2         \n"
+            "ldrsh  %6, [%1], #2         \n"
+            "ldrsh  %7, [%2], #2         \n"
+            "mul    %4, %8, %4           \n"
+            "mul    %5, %9, %5           \n"
+            "mul    %6, %8, %6           \n"
+            "mul    %7, %9, %7           \n"
+            "mov    %4, %4, asr #16      \n"
+            "add    %4, %4, %5, asr #16  \n"
+            "mov    %6, %6, asr #16      \n"
+            "add    %6, %6, %7, asr #16  \n"
+            "mov    %5, %4, asr #15      \n"
+            "teq    %5, %5, asr #31      \n"
+            "eorne  %4, %10, %4, asr #31 \n"
+            "mov    %7, %6, asr #15      \n"
+            "teq    %7, %7, asr #31      \n"
+            "eorne  %6, %10, %6, asr #31 \n"
+            "subs   %3, %3, #4           \n"
+            "and    %4, %4, %10, lsr #16 \n"
+            "orr    %6, %4, %6, lsl #16  \n"
+            "str    %6, [%0], #4         \n"
+            "bhi    1b                   \n"
+            : "+r"(out), "+r"(src0), "+r"(src1), "+r"(size),
+              "=&r"(l0), "=&r"(l1), "=&r"(h0), "=&r"(h1)
+            : "r"(src0_amp), "r"(src1_amp), "r"(0xffff7fff));
+    }
+    else
+    {
+        /* One is unity amplitude */
+        if (src0_amp != MIX_AMP_UNITY)
+        {
+            /* Keep unity in src0, amp0 */
+            int16_t *src_tmp = src0;
+            src0 = src1;
+            src1 = src_tmp;
+            src1_amp = src0_amp;
+            src0_amp = MIX_AMP_UNITY;
+        }
+
+        int32_t l0, l1, h0, h1;
+        asm volatile (
+        "1:                             \n"
+            "ldrsh  %4, [%1], #2        \n"
+            "ldrsh  %5, [%2], #2        \n"
+            "ldrsh  %6, [%1], #2        \n"
+            "ldrsh  %7, [%2], #2        \n"
+            "mul    %5, %8, %5          \n"
+            "mul    %7, %8, %7          \n"
+            "add    %4, %4, %5, asr #16 \n"
+            "add    %6, %6, %7, asr #16 \n"
+            "mov    %5, %4, asr #15     \n"
+            "teq    %5, %5, asr #31     \n"
+            "eorne  %4, %9, %4, asr #31 \n"
+            "mov    %7, %6, asr #15     \n"
+            "teq    %7, %7, asr #31     \n"
+            "eorne  %6, %9, %6, asr #31 \n"
+            "subs   %3, %3, #4          \n"
+            "and    %4, %4, %9, lsr #16 \n"
+            "orr    %6, %4, %6, lsl #16 \n"
+            "str    %6, [%0], #4        \n"
+            "bhi    1b                  \n"
+            : "+r"(out), "+r"(src0), "+r"(src1), "+r"(size),
+              "=&r"(l0), "=&r"(l1), "=&r"(h0), "=&r"(h1)
+            : "r"(src1_amp), "r"(0xffff7fff));
+    }
+}
+
+/* Write channel's samples and apply gain factor */
+static FORCE_INLINE void write_samples(void *out,
+                                       void *src,
+                                       int32_t amp,
+                                       size_t size)
+{
+    if (LIKELY(amp == MIX_AMP_UNITY))
+    {
+        /* Channel is unity amplitude */
+        asm volatile (
+            "ands       r1, %2, #0x1f  \n"
+            "beq        2f             \n"
+        "1:                            \n"
+            "ldr        r0, [%1], #4   \n"
+            "subs       r1, r1, #4     \n"
+            "str        r0, [%0], #4   \n"
+            "bne        1b             \n"
+            "bics       %2, %2, #0x1f  \n"
+            "beq        3f             \n"
+        "2:                            \n"
+            "ldmia      %1!, { r0-r7 } \n"
+            "subs       %2, %2, #32    \n"
+            "stmia      %0!, { r0-r7 } \n"
+            "bhi        2b             \n"
+        "3:                            \n"
+            : "+r"(out), "+r"(src), "+r"(size)
+            :
+            : "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7");
+    }
+    else
+    {
+        /* Channel needs amplitude cut */
+        uint32_t l, h;
+        asm volatile (
+        "1:                              \n"
+            "ldrsh   %3, [%1], #2        \n"
+            "ldrsh   %4, [%1], #2        \n"
+            "subs    %2, %2, #4          \n"
+            "mul     %3, %5, %3          \n"
+            "mul     %4, %5, %4          \n"
+            "and     %4, %4, %6, lsl #16 \n"
+            "orr     %4, %4, %3, lsr #16 \n"
+            "str     %4, [%0], #4        \n"
+            "bhi     1b                  \n"
+            : "+r"(out), "+r"(src), "+r"(size),
+              "=&r"(l), "=&r"(h)
+            : "r"(amp), "r"(0xffffffffu));
+    }     
+}
diff --git a/firmware/target/arm/pcm-mixer-armv5.c b/firmware/target/arm/pcm-mixer-armv5.c
new file mode 100644
index 0000000000..64f2c86f52
--- /dev/null
+++ b/firmware/target/arm/pcm-mixer-armv5.c
@@ -0,0 +1,106 @@
+/***************************************************************************
+ *             __________               __   ___.
+ *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
+ *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
+ *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
+ *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
+ *                     \/            \/     \/    \/            \/
+ * $Id$
+ *
+ * Copyright (C) 2011 by Michael Sevakis
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ****************************************************************************/
+
+#define MIXER_OPTIMIZED_WRITE_SAMPLES
+#define MIXER_OPTIMIZED_MIX_SAMPLES
+
+/* Mix channels' samples and apply gain factors */
+static FORCE_INLINE void mix_samples(void *out,
+                                     void *src0,
+                                     int32_t src0_amp,
+                                     void *src1,
+                                     int32_t src1_amp,
+                                     size_t size)
+{
+    int32_t s0, s1, tmp;
+    asm volatile (
+    "1:                             \n"
+        "ldr    %4, [%1], #4        \n"
+        "ldr    %5, [%2], #4        \n"
+        "smulwb %6, %7, %4          \n"
+        "smulwt %4, %7, %4          \n"
+        "smlawb %6, %8, %5, %6      \n"
+        "smlawt %4, %8, %5, %4      \n"
+        "mov    %5, %6, asr #15     \n"
+        "teq    %5, %5, asr #31     \n"
+        "eorne  %6, %9, %6, asr #31 \n"
+        "mov    %5, %4, asr #15     \n"
+        "teq    %5, %5, asr #31     \n"
+        "eorne  %4, %9, %4, asr #31 \n"
+        "subs   %3, %3, #4          \n"
+        "and    %6, %6, %9, lsr #16 \n"
+        "orr    %6, %6, %4, lsl #16 \n"
+        "str    %6, [%0], #4        \n"
+        "bhi    1b                  \n"
+        : "+r"(out), "+r"(src0), "+r"(src1), "+r"(size),
+          "=&r"(s0), "=&r"(s1), "=&r"(tmp)
+        : "r"(src0_amp), "r"(src1_amp), "r"(0xffff7fff));
+}
+
+/* Write channel's samples and apply gain factor */
+static FORCE_INLINE void write_samples(void *out,
+                                       void *src,
+                                       int32_t amp,
+                                       size_t size)
+{
+    if (LIKELY(amp == MIX_AMP_UNITY))
+    {
+        /* Channel is unity amplitude */
+        asm volatile (
+            "ands   r1, %2, #0x1f  \n"
+            "beq    2f             \n"
+        "1:                        \n"
+            "ldr    r0, [%1], #4   \n"
+            "subs   r1, r1, #4     \n"
+            "str    r0, [%0], #4   \n"
+            "bne    1b             \n"
+            "bics   %2, %2, #0x1f  \n"
+            "beq    3f             \n"
+        "2:                        \n"
+            "ldmia  %1!, { r0-r7 } \n"
+            "subs   %2, %2, #32    \n"
+            "stmia  %0!, { r0-r7 } \n"
+            "bhi    2b             \n"
+        "3:                        \n"
+            : "+r"(out), "+r"(src), "+r"(size)
+            :
+            : "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7");
+    }
+    else
+    {
+        /* Channel needs amplitude cut */
+        uint32_t l, h;
+        asm volatile (
+        "1:                             \n"
+            "ldr    %3, [%1], #4        \n"
+            "subs   %2, %2, #4          \n"
+            "smulwt %4, %5, %3          \n"
+            "smulwb %3, %5, %3          \n"
+            "mov    %4, %4, lsl #16     \n"
+            "mov    %3, %3, lsl #16     \n"
+            "orr    %4, %4, %3, lsr #16 \n"
+            "str    %4, [%0], #4        \n"
+            "bhi    1b                  \n"
+            : "+r"(out), "+r"(src), "+r"(size),
+              "=&r"(l), "=&r"(h)
+            : "r"(amp));
+    }     
+}
diff --git a/firmware/target/arm/pcm-mixer-armv6.c b/firmware/target/arm/pcm-mixer-armv6.c
new file mode 100644
index 0000000000..94eecd0f90
--- /dev/null
+++ b/firmware/target/arm/pcm-mixer-armv6.c
@@ -0,0 +1,118 @@
+/***************************************************************************
+ *             __________               __   ___.
+ *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
+ *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
+ *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
+ *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
+ *                     \/            \/     \/    \/            \/
+ * $Id$
+ *
+ * Copyright (C) 2011 by Michael Sevakis
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ****************************************************************************/
+#define MIXER_OPTIMIZED_MIX_SAMPLES
+#define MIXER_OPTIMIZED_WRITE_SAMPLES
+
+/* Mix channels' samples and apply gain factors */
+static FORCE_INLINE void mix_samples(void *out,
+                                     void *src0,
+                                     int32_t src0_amp,
+                                     void *src1,
+                                     int32_t src1_amp,
+                                     size_t size)
+{
+    uint32_t s0, s1;
+
+    if (src0_amp == MIX_AMP_UNITY && src1_amp == MIX_AMP_UNITY)
+    {
+        /* Both are unity amplitude */
+        asm volatile (
+        "1:                      \n"
+            "ldr    %4, [%1], #4 \n"
+            "ldr    %5, [%2], #4 \n"
+            "subs   %3, %3, #4   \n"
+            "qadd16 %5, %5, %4   \n"
+            "str    %5, [%0], #4 \n"
+            "bhi    1b           \n"
+            : "+r"(out), "+r"(src0), "+r"(src1), "+r"(size),
+              "=&r"(s0), "=&r"(s1));
+    }
+    else
+    {
+        /* One or neither are unity amplitude */
+        uint32_t tmp;
+        asm volatile (
+        "1:                             \n"
+            "ldr    %4, [%1], #4        \n"
+            "ldr    %5, [%2], #4        \n"
+            "subs   %3, %3, #4          \n"
+            "smulwb %6, %7, %4          \n"
+            "smulwt %4, %7, %4          \n"
+            "smlawb %6, %8, %5, %6      \n"
+            "smlawt %4, %8, %5, %4      \n"
+            "ssat   %6, #16, %6         \n"
+            "ssat   %4, #16, %4         \n"
+            "pkhbt  %6, %6, %4, asl #16 \n"
+            "str    %6, [%0], #4        \n"
+            "bhi    1b                  \n"
+            : "+r"(out), "+r"(src0), "+r"(src1), "+r"(size),
+              "=&r"(s0), "=&r"(s1), "=&r"(tmp)
+            : "r"(src0_amp), "r"(src1_amp));
+    }
+}
+
+/* Write channel's samples and apply gain factor */
+static FORCE_INLINE void write_samples(void *out,
+                                       void *src,
+                                       int32_t amp,
+                                       size_t size)
+{
+    if (LIKELY(amp == MIX_AMP_UNITY))
+    {
+        /* Channel is unity amplitude */
+        asm volatile (
+            "ands       r1, %2, #0x1f  \n"
+            "beq        2f             \n"
+        "1:                            \n"
+            "ldr        r0, [%1], #4   \n"
+            "subs       r1, r1, #4     \n"
+            "str        r0, [%0], #4   \n"
+            "bne        1b             \n"
+            "bics       %2, %2, #0x1f  \n"
+            "beq        3f             \n"
+        "2:                            \n"
+            "ldmia      %1!, { r0-r7 } \n"
+            "subs       %2, %2, #32    \n"
+            "stmia      %0!, { r0-r7 } \n"
+            "bhi        2b             \n"
+        "3:                            \n"
+            : "+r"(out), "+r"(src), "+r"(size)
+            :
+            : "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7");
+    }
+    else
+    {
+        /* Channel needs amplitude cut */
+        uint32_t s, tmp;
+        asm volatile(
+        "1:                             \n"
+            "ldr    %3, [%1], #4        \n"
+            "subs   %2, %2, #4          \n"
+            "smulwt %4, %5, %3          \n"
+            "smulwb %3, %5, %3          \n"
+            "pkhbt  %4, %3, %4, asl #16 \n"
+            "str    %4, [%0], #4        \n"
+            "bhi    1b                  \n"
+            : "+r"(out), "+r"(src), "+r"(size),
+              "=&r"(s), "=&r"(tmp)
+            : "r"(amp));
+    }     
+}
diff --git a/firmware/target/arm/pcm-pp.c b/firmware/target/arm/pcm-pp.c
index c446f98fcf..704296d407 100644
--- a/firmware/target/arm/pcm-pp.c
+++ b/firmware/target/arm/pcm-pp.c
@@ -26,6 +26,7 @@
 #include "sound.h"
 #include "pcm.h"
 #include "pcm_sampr.h"
+#include "pcm-internal.h"
 
 /** DMA **/
 
@@ -115,6 +116,7 @@ void pcm_dma_apply_settings(void)
 /* NOTE: direct stack use forbidden by GCC stack handling bug for FIQ */
 void ICODE_ATTR __attribute__((interrupt("FIQ"))) fiq_playback(void)
 {
+    bool new_buffer = false;
     register size_t size;
 
     DMA0_STATUS; /* Clear any pending interrupt */
@@ -136,9 +138,14 @@ void ICODE_ATTR __attribute__((interrupt("FIQ"))) fiq_playback(void)
             /* Set the new DMA values and activate channel */
             DMA0_RAM_ADDR = dma_play_data.addr;
             DMA0_CMD = DMA_PLAY_CONFIG | (size - 4) | DMA_CMD_START;
+
+            if (new_buffer)
+                pcm_play_dma_started_callback();
             return;
         }
 
+        new_buffer = true;
+
         /* Buffer empty.  Try to get more. */
         pcm_play_get_more_callback((void **)&dma_play_data.addr,
                                    &dma_play_data.size);
@@ -181,8 +188,9 @@ void fiq_playback(void)
      * r0-r3 and r12 is a working register.
      */
     asm volatile (
-        "stmfd   sp!, { r0-r3, lr }  \n" /* stack scratch regs and lr */
+        "stmfd   sp!, { r0-r4, lr }  \n" /* stack scratch regs and lr */
 
+        "mov     r4, #0              \n" /* Was the callback called? */
 #if CONFIG_CPU == PP5002
         "ldr     r12, =0xcf001040    \n" /* Some magic from iPodLinux */
         "ldr     r12, [r12]          \n"
@@ -212,16 +220,13 @@ void fiq_playback(void)
         "tst     r1, #1              \n" /* two samples (one word) left? */
         "ldrne   r12, [r8], #4       \n" /* load two samples */
         "strne   r12, [r10, %[wr]]   \n" /* write sample 0-1 to IISFIFO_WR */
-
-        "cmp     r9, #0              \n" /* either FIFO is full or source buffer is empty */
-        "bgt     .exit               \n" /* if source buffer is not empty, FIFO must be full */
 #elif SAMPLE_SIZE == 32
     ".check_fifo:                    \n"
         "ldr     r0, [r10, %[cfg]]   \n" /* read IISFIFO_CFG to check FIFO status */
         "and     r0, r0, %[mask]     \n" /* r0 = IIS_TX_FREE_COUNT << 23 (PP5002) */
 
         "movs    r1, r0, lsr #24     \n" /* number of free pairs of FIFO slots */
-        "beq     .exit               \n" /* no complete pair? -> exit */
+        "beq     .fifo_fill_complete \n" /* no complete pair? -> exit */
         "cmp     r1, r9, lsr #2      \n" /* number of words from source */
         "movgt   r1, r9, lsr #2      \n" /* r1 = amount of allowed loops */
         "sub     r9, r9, r1, lsl #2  \n" /* r1 words will be written in following loop */
@@ -234,11 +239,23 @@ void fiq_playback(void)
         "subs    r1, r1, #1          \n" /* one more loop? */
         "bgt     .fifo_loop          \n" /* yes, continue */
 
+    ".fifo_fill_complete:            \n"
+#endif
+        "cmp     r4, #0              \n" /* If fill came after get_more... */
+        "beq     .still_old_buffer   \n"
+        "mov     r4, #0              \n"
+        "ldr     r2, =pcm_play_dma_started \n"
+        "ldrne   r2, [r2]            \n"
+        "cmp     r2, #0              \n"
+        "movne   lr, pc              \n"
+        "bxne    r2                  \n"
+
+    ".still_old_buffer:              \n"
         "cmp     r9, #0              \n" /* either FIFO is full or source buffer is empty */
         "bgt     .exit               \n" /* if source buffer is not empty, FIFO must be full */
-#endif
 
     ".more_data:                     \n"
+        "mov     r4, #1              \n" /* Remember we did this */
         "ldr     r2, =pcm_play_get_more_callback \n"
         "mov     r0, r11             \n" /* r0 = &p */
         "add     r1, r11, #4         \n" /* r1 = &size */
@@ -250,7 +267,7 @@ void fiq_playback(void)
 
     ".exit:                          \n" /* (r9=0 if stopping, look above) */
         "stmia   r11, { r8-r9 }      \n" /* save p and size */
-        "ldmfd   sp!, { r0-r3, lr }  \n"
+        "ldmfd   sp!, { r0-r4, lr }  \n"
         "subs    pc, lr, #4          \n" /* FIQ specific return sequence */
         ".ltorg                      \n"
         : /* These must only be integers! No regs */
@@ -264,6 +281,8 @@ void fiq_playback(void) __attribute__((interrupt ("FIQ"))) ICODE_ATTR;
 /* NOTE: direct stack use forbidden by GCC stack handling bug for FIQ */
 void fiq_playback(void)
 {
+    bool new_buffer = false;
+
 #if CONFIG_CPU == PP5002
     inl(0xcf001040);
 #endif
@@ -271,6 +290,10 @@ void fiq_playback(void)
     do {
         while (dma_play_data.size > 0) {
             if (IIS_TX_FREE_COUNT < 2) {
+                if (new_buffer) {
+                    new_buffer = false;
+                    pcm_play_dma_started_callback();
+                }
                 return;
             }
 #if SAMPLE_SIZE == 16
@@ -282,9 +305,15 @@ void fiq_playback(void)
             dma_play_data.size -= 4;
         }
 
+        if (new_buffer) {
+            new_buffer = false;
+            pcm_play_dma_started_callback();
+        }
+
         /* p is empty, get some more data */
         pcm_play_get_more_callback((void **)&dma_play_data.addr,
                                    &dma_play_data.size);
+        new_buffer = true;
     } while (dma_play_data.size);
 
     /* No more data  */
diff --git a/firmware/target/arm/pcm-telechips.c b/firmware/target/arm/pcm-telechips.c
index 851ebee7de..aff43171f6 100644
--- a/firmware/target/arm/pcm-telechips.c
+++ b/firmware/target/arm/pcm-telechips.c
@@ -27,6 +27,7 @@
 #include "sound.h"
 #include "i2s.h"
 #include "pcm.h"
+#include "pcm-internal.h"
 
 struct dma_data
 {
@@ -247,6 +248,8 @@ void fiq_handler(void)
      * r0-r3 and r12 is a working register.
      */
     asm volatile (
+        "stmfd   sp!, { r0-r4, lr }  \n" /* stack scratch regs and lr */
+        "mov     r4, #0              \n" /* Was the callback called? */
 #if defined(CPU_TCC780X)
         "mov     r8, #0xc000         \n" /* DAI_TX_IRQ_MASK | DAI_RX_IRQ_MASK */
         "ldr     r9, =0xf3001004     \n" /* CREQ */
@@ -279,33 +282,41 @@ void fiq_handler(void)
         "sub     r9, r9, #0x10       \n" /* 4 words written */
         "stmia   r11, { r8-r9 }      \n" /* save p and size */
 
+        "cmp     r4, #0              \n" /* Callback called? */
+        "beq     .exit               \n"
+        /* "mov     r4, #0              \n" If get_more could be called multiple times! */
+        "ldr     r2, =pcm_play_dma_started\n"
+        "ldr     r2, [r2]            \n"
+        "cmp     r2, #0              \n"
+        "blxne   r2                  \n"
+
     ".exit:                          \n"
+        "ldmfd   sp!, { r0-r4, lr }  \n"
         "subs    pc, lr, #4          \n" /* FIQ specific return sequence */
 
     ".more_data:                     \n"
-        "stmfd   sp!, { r0-r3, lr }  \n" /* stack scratch regs and lr */
+        "mov     r4, #1              \n" /* Remember we got more data in this FIQ */
         "ldr     r2, =pcm_play_get_more_callback \n"
         "mov     r0, r11             \n" /* r0 = &p */
         "add     r1, r11, #4         \n" /* r1 = &size */
         "blx     r2                  \n" /* call pcm_play_get_more_callback */
         "ldmia   r11, { r8-r9 }      \n" /* load new p and size */
         "cmp     r9, #0x10           \n" /* did we actually get enough data? */
-        "ldmfd   sp!, { r0-r3, lr }  \n"
         "bpl     .fill_fifo          \n" /* not stop and enough? refill */
         "b       .exit               \n"
         ".ltorg                      \n"
     );
 }
 #else /* C version for reference */
-void fiq_handler(void) ICODE_ATTR __attribute__((naked));
+void fiq_handler(void) ICODE_ATTR;
 void fiq_handler(void)
 {
-    asm volatile(   "stmfd sp!, {r0-r7, ip, lr} \n"   /* Store context */
-                    "sub   sp, sp, #8           \n"); /* Reserve stack */
+    register bool new_buffer = false;
 
     if (dma_play_data.size < 16)
     {
         /* p is empty, get some more data */
+        new_buffer = true;
         pcm_play_get_more_callback((void**)&dma_play_data.p,
                                    &dma_play_data.size);
     }
@@ -327,9 +338,8 @@ void fiq_handler(void)
     /* Clear FIQ status */
     CREQ = DAI_TX_IRQ_MASK | DAI_RX_IRQ_MASK;
 
-    asm volatile(   "add   sp, sp, #8           \n"   /* Cleanup stack   */
-                    "ldmfd sp!, {r0-r7, ip, lr} \n"   /* Restore context */
-                    "subs  pc, lr, #4           \n"); /* Return from FIQ */
+    if (new_buffer)
+        pcm_play_dma_started_callback();
 }
 #endif
 
diff --git a/firmware/target/arm/pnx0101/pcm-pnx0101.c b/firmware/target/arm/pnx0101/pcm-pnx0101.c
index 9d4ffbd773..d4c17454ed 100644
--- a/firmware/target/arm/pnx0101/pcm-pnx0101.c
+++ b/firmware/target/arm/pnx0101/pcm-pnx0101.c
@@ -21,6 +21,7 @@
 #include "system.h"
 #include "audio.h"
 #include "string.h"
+#include "pcm-internal.h"
 
 #define DMA_BUF_SAMPLES 0x100
 
@@ -63,6 +64,8 @@ static inline void fill_dma_buf(int offset)
 
     if (pcm_playing && !pcm_paused)
     {
+        bool new_buffer =false;
+
         do
         {
             int count;
@@ -102,10 +105,20 @@ static inline void fill_dma_buf(int offset)
                 count--;
             }
             p = tmp_p;
+
+            if (new_buffer)
+            {
+                new_buffer = false;
+                pcm_play_dma_started_callback();
+            }
+
             if (l >= lend)
                 return;
 
             pcm_play_get_more_callback((void**)&p, &p_size);
+
+            if (p_size)
+                new_buffer = true;
         }
         while (p_size);
     }
diff --git a/firmware/target/arm/s3c2440/gigabeat-fx/pcm-meg-fx.c b/firmware/target/arm/s3c2440/gigabeat-fx/pcm-meg-fx.c
index c1c9017fbb..33194ae5d9 100644
--- a/firmware/target/arm/s3c2440/gigabeat-fx/pcm-meg-fx.c
+++ b/firmware/target/arm/s3c2440/gigabeat-fx/pcm-meg-fx.c
@@ -25,6 +25,7 @@
 #include "audio.h"
 #include "sound.h"
 #include "file.h"
+#include "pcm-internal.h"
 
 /* PCM interrupt routine lockout */
 static struct
@@ -235,6 +236,8 @@ void fiq_handler(void)
 
     /* Re-Activate the channel */
     DMASKTRIG2 = 0x2;
+
+    pcm_play_dma_started_callback();
 }
 
 size_t pcm_get_bytes_waiting(void)
diff --git a/firmware/target/arm/s3c2440/gigabeat-fx/wmcodec-meg-fx.c b/firmware/target/arm/s3c2440/gigabeat-fx/wmcodec-meg-fx.c
index 01b177da6c..eea4c58e4b 100644
--- a/firmware/target/arm/s3c2440/gigabeat-fx/wmcodec-meg-fx.c
+++ b/firmware/target/arm/s3c2440/gigabeat-fx/wmcodec-meg-fx.c
@@ -99,14 +99,15 @@ void TIMER3(void)
     INTPND = TIMER3_MASK;
 }
 
-void pcmbuf_beep(unsigned int frequency, size_t duration, int amplitude)
+void beep_play(unsigned int frequency, unsigned int duration,
+               unsigned int amplitude)
 {
     #define TIMER3_TICK_SEC (TIMER_FREQ / TIMER234_PRESCALE)
 
     unsigned long tcnt, tcmp;
     int oldstatus;
 
-    if (amplitude <= 0)
+    if (frequency == 0 || duration == 0 || amplitude == 0)
     {
         beep_stop(); /* won't hear it anyway */
         return;
diff --git a/firmware/target/arm/s3c2440/mini2440/pcm-mini2440.c b/firmware/target/arm/s3c2440/mini2440/pcm-mini2440.c
index 8a6b62f31f..0c69c1e6d3 100644
--- a/firmware/target/arm/s3c2440/mini2440/pcm-mini2440.c
+++ b/firmware/target/arm/s3c2440/mini2440/pcm-mini2440.c
@@ -26,6 +26,7 @@
 #include "audio.h"
 #include "sound.h"
 #include "file.h"
+#include "pcm-internal.h"
 
 /* PCM interrupt routine lockout */
 static struct
@@ -275,6 +276,8 @@ void fiq_handler(void)
 
     /* Re-Activate the channel */
     DMASKTRIG2 = 0x2;
+
+    pcm_play_dma_started_callback();
 }
 
 size_t pcm_get_bytes_waiting(void)
diff --git a/firmware/target/arm/s5l8700/pcm-s5l8700.c b/firmware/target/arm/s5l8700/pcm-s5l8700.c
index 08086c37d8..14c515ec47 100644
--- a/firmware/target/arm/s5l8700/pcm-s5l8700.c
+++ b/firmware/target/arm/s5l8700/pcm-s5l8700.c
@@ -27,6 +27,7 @@
 #include "panic.h"
 #include "audiohw.h"
 #include "pcm.h"
+#include "pcm-internal.h"
 #include "pcm_sampr.h"
 #include "dma-target.h"
 #include "mmu-arm.h"
@@ -100,6 +101,7 @@ void pcm_play_unlock(void)
 void INT_DMA(void) ICODE_ATTR;
 void INT_DMA(void)
 {
+    bool new_buffer = false;
     DMACOM0 = 7;
     while (!(DMACON0 & (1 << 18)))
     {
@@ -112,8 +114,12 @@ void INT_DMA(void)
         }
         else
         {
-            if (!nextsize) pcm_play_get_more_callback((void**)&nextbuf, &nextsize);
-            if (!nextsize) break;
+            if (!nextsize)
+            {
+                pcm_play_get_more_callback((void**)&nextbuf, &nextsize);
+                if (!nextsize) break;
+                new_buffer = true;
+            }
             queuedsize = MIN(sizeof(dblbuf), nextsize / 2);
             nextsize -= queuedsize;
             queuedbuf = nextbuf + nextsize;
@@ -124,7 +130,14 @@ void INT_DMA(void)
         clean_dcache();
         DMACOM0 = 4;
         DMACOM0 = 7;
+
+        if (new_buffer)
+        {
+            pcm_play_dma_started_callback();
+            new_buffer = false;
+        }
     }
+
 }
 
 void pcm_play_dma_start(const void* addr, size_t size)
diff --git a/firmware/target/arm/s5l8702/pcm-s5l8702.c b/firmware/target/arm/s5l8702/pcm-s5l8702.c
index c0498a9ce2..dbadf3bac0 100644
--- a/firmware/target/arm/s5l8702/pcm-s5l8702.c
+++ b/firmware/target/arm/s5l8702/pcm-s5l8702.c
@@ -27,6 +27,7 @@
 #include "panic.h"

 #include "audiohw.h"

 #include "pcm.h"

+#include "pcm-internal.h"

 #include "pcm_sampr.h"

 #include "mmu-arm.h"

 #include "pcm-target.h"

@@ -113,6 +114,8 @@ void INT_DMAC0C0(void)
         DMAC0C0CONFIG = 0x8a81;

     }

     else DMAC0C0NEXTLLI = pcm_lli;

+

+    pcm_play_dma_started_callback();

 }

 

 void pcm_play_dma_start(const void* addr, size_t size)

diff --git a/firmware/target/arm/tms320dm320/creative-zvm/pcm-creativezvm.c b/firmware/target/arm/tms320dm320/creative-zvm/pcm-creativezvm.c
index 3c54ce81fb..5ec62cf876 100644
--- a/firmware/target/arm/tms320dm320/creative-zvm/pcm-creativezvm.c
+++ b/firmware/target/arm/tms320dm320/creative-zvm/pcm-creativezvm.c
@@ -27,6 +27,7 @@
 #include "dm320.h"
 #include "audiohw.h"
 #include "dsp-target.h"
+#include "pcm-internal.h"
 
 void pcm_play_dma_init(void)
 {
diff --git a/firmware/target/arm/tms320dm320/mrobe-500/pcm-mr500.c b/firmware/target/arm/tms320dm320/mrobe-500/pcm-mr500.c
index fb94adae71..90c342e868 100644
--- a/firmware/target/arm/tms320dm320/mrobe-500/pcm-mr500.c
+++ b/firmware/target/arm/tms320dm320/mrobe-500/pcm-mr500.c
@@ -28,6 +28,7 @@
 #include "dsp-target.h"
 #include "dsp/ipc.h"
 #include "mmu-arm.h"
+#include "pcm-internal.h"
 
 /* This is global to save some latency when pcm_play_dma_get_peak_buffer is 
  *  called.
@@ -178,6 +179,8 @@ void DSPHINT(void)
             
             DEBUGF("pcm_sdram at 0x%08lx, sdem_addr 0x%08lx",
                 (unsigned long)start, (unsigned long)sdem_addr);
+
+            pcm_play_dma_started_callback();
         }
         
         break;
diff --git a/firmware/target/coldfire/pcm-coldfire.c b/firmware/target/coldfire/pcm-coldfire.c
index a06542c31f..85eeaec815 100644
--- a/firmware/target/coldfire/pcm-coldfire.c
+++ b/firmware/target/coldfire/pcm-coldfire.c
@@ -28,6 +28,7 @@
 #if defined(HAVE_SPDIF_REC) || defined(HAVE_SPDIF_OUT)
 #include "spdif.h"
 #endif
+#include "pcm-internal.h"
 
 #define IIS_PLAY_DEFPARM ( (freq_ent[FPARM_CLOCKSEL] << 12) | \
                            (IIS_PLAY & (7 << 8)) | \
@@ -318,6 +319,9 @@ void DMA0(void)
         SAR0 = (unsigned long)start;     /* Source address */
         BCR0 = size;                     /* Bytes to transfer */
         or_l(DMA_EEXT | DMA_INT, &DCR0); /* per request and int ON */
+
+        /* Call buffer callback */
+        pcm_play_dma_started_callback();
     }
     /* else inished playing */
 } /* DMA0 */
diff --git a/firmware/target/coldfire/pcm-mixer-coldfire.c b/firmware/target/coldfire/pcm-mixer-coldfire.c
new file mode 100644
index 0000000000..d8318fffaf
--- /dev/null
+++ b/firmware/target/coldfire/pcm-mixer-coldfire.c
@@ -0,0 +1,134 @@
+/***************************************************************************
+ *             __________               __   ___.
+ *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
+ *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
+ *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
+ *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
+ *                     \/            \/     \/    \/            \/
+ * $Id$
+ *
+ * Copyright (C) 2011 by Michael Sevakis
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ****************************************************************************/
+
+#define MIXER_OPTIMIZED_MIX_SAMPLES
+#define MIXER_OPTIMIZED_WRITE_SAMPLES
+static struct emac_context
+{
+    unsigned long r[4];
+} emac_context IBSS_ATTR;
+
+/* Save emac context affected in ISR */
+static FORCE_INLINE void save_emac_context(void)
+{
+    asm volatile (
+        "move.l   %%macsr, %%d0             \n"
+        "move.l   %%accext01, %%d1          \n"
+        "movclr.l %%acc0, %%a0              \n"
+        "movclr.l %%acc1, %%a1              \n"
+        "movem.l  %%d0-%%d1/%%a0-%%a1, (%0) \n"
+        :
+        : "a"(&emac_context)
+        : "d0", "d1", "a0", "a1");
+}
+
+/* Restore emac context affected in ISR */
+static FORCE_INLINE void restore_emac_context(void)
+{
+    asm volatile (
+        "movem.l (%0), %%d0-%%d1/%%a0-%%a1  \n"
+        "move.l  %%a1, %%acc1               \n"
+        "move.l  %%a0, %%acc0               \n"
+        "move.l  %%d1, %%accext01           \n"
+        "move.l  %%d0, %%macsr              \n"
+        :
+        : "a"(&emac_context)
+        : "d0", "d1", "a0", "a1");
+}
+
+/* Mix channels' samples and apply gain factors */
+static FORCE_INLINE void mix_samples(void *out,
+                                     void *src0,
+                                     int32_t src0_amp,
+                                     void *src1,
+                                     int32_t src1_amp,
+                                     size_t size)
+{
+    uint32_t s0, s1, s2, s3;
+    save_emac_context();
+    coldfire_set_macsr(EMAC_ROUND | EMAC_SATURATE);
+
+    asm volatile (
+        "move.l     (%1)+, %5                 \n"
+    "1:                                       \n"
+        "movea.w    %5, %4                    \n"
+        "asr.l      %10, %5                   \n"
+        "mac.l      %4, %8,            %%acc0 \n"
+        "mac.l      %5, %8, (%2)+, %5, %%acc1 \n"
+        "movea.w    %5, %4                    \n"
+        "asr.l      %10, %5                   \n"
+        "mac.l      %4, %9,            %%acc0 \n"
+        "mac.l      %5, %9, (%1)+, %5, %%acc1 \n"
+        "movclr.l   %%acc0, %6                \n"
+        "movclr.l   %%acc1, %7                \n"
+        "swap.w     %6                        \n"
+        "move.w     %6, %7                    \n"
+        "move.l     %7, (%0)+                 \n"
+        "subq.l     #4, %3                    \n"
+        "bhi.b      1b                        \n"
+        : "+a"(out), "+a"(src0), "+a"(src1), "+d"(size),
+          "=&a"(s0), "=&d"(s1), "=&d"(s2), "=&d"(s3)
+        : "r"(src0_amp), "r"(src1_amp), "d"(16)
+    );
+
+    restore_emac_context();
+}
+
+/* Write channel's samples and apply gain factor */
+static FORCE_INLINE void write_samples(void *out,
+                                       void *src,
+                                       int32_t amp,
+                                       size_t size)
+{
+    if (LIKELY(amp == MIX_AMP_UNITY))
+    {
+        /* Channel is unity amplitude */
+        memcpy(out, src, size);
+    }
+    else
+    {
+        /* Channel needs amplitude cut */
+        uint32_t s0, s1, s2, s3;
+        save_emac_context();
+        coldfire_set_macsr(EMAC_ROUND | EMAC_SATURATE);
+
+        asm volatile (
+            "move.l     (%1)+, %4                 \n"
+        "1:                                       \n"
+            "movea.w    %4, %3                    \n"
+            "asr.l      %8, %4                    \n"
+            "mac.l      %3, %7,            %%acc0 \n"
+            "mac.l      %4, %7, (%1)+, %4, %%acc1 \n"
+            "movclr.l   %%acc0, %5                \n"
+            "movclr.l   %%acc1, %6                \n"
+            "swap.w     %5                        \n"
+            "move.w     %5, %6                    \n"
+            "move.l     %6, (%0)+                 \n"
+            "subq.l     #4, %2                    \n"
+            "bhi.b      1b                        \n"
+            : "+a"(out), "+a"(src), "+d"(size),
+              "=&a"(s0), "=&d"(s1), "=&d"(s2), "=&d"(s3)
+            : "r"(amp), "d"(16)
+        );
+
+        restore_emac_context();
+    }     
+}
diff --git a/firmware/target/hosted/android/pcm-android.c b/firmware/target/hosted/android/pcm-android.c
index 88792cd76f..cbd6cb3228 100644
--- a/firmware/target/hosted/android/pcm-android.c
+++ b/firmware/target/hosted/android/pcm-android.c
@@ -23,14 +23,18 @@
 #include <stdbool.h>
 #define _SYSTEM_WITH_JNI /* for getJavaEnvironment */
 #include <system.h>
+#include <pthread.h>
 #include "debug.h"
 #include "pcm.h"
+#include "pcm-internal.h"
 
 extern JNIEnv *env_ptr;
 
 /* infos about our pcm chunks */
 static size_t  pcm_data_size;
 static char   *pcm_data_start;
+static int     audio_locked = 0;
+static pthread_mutex_t audio_lock_mutex = PTHREAD_MUTEX_INITIALIZER;
 
 /* cache frequently called methods */
 static jmethodID play_pause_method;
@@ -42,6 +46,20 @@ static jobject   RockboxPCM_instance;
 
 
 /*
+ * mutex lock/unlock wrappers neatness' sake
+ */
+static inline void lock_audio(void)
+{
+    pthread_mutex_lock(&audio_lock_mutex);
+}
+
+static inline void unlock_audio(void)
+{
+    pthread_mutex_unlock(&audio_lock_mutex);
+}
+
+
+/*
  * write pcm samples to the hardware. Calls AudioTrack.write directly (which
  * is usually a blocking call)
  *
@@ -54,10 +72,17 @@ JNIEXPORT jint JNICALL
 Java_org_rockbox_RockboxPCM_nativeWrite(JNIEnv *env, jobject this,
                                         jbyteArray temp_array, jint max_size)
 {
+    bool new_buffer = false;
+
+    lock_audio();
+
     jint left = max_size;
 
     if (!pcm_data_size) /* get some initial data */
+    {
+        new_buffer = true;
         pcm_play_get_more_callback((void**) &pcm_data_start, &pcm_data_size);
+    }
 
     while(left > 0 && pcm_data_size)
     {
@@ -70,23 +95,49 @@ Java_org_rockbox_RockboxPCM_nativeWrite(JNIEnv *env, jobject this,
 
         ret = (*env)->CallIntMethod(env, this, write_method,
                                             temp_array, 0, transfer_size);
+
+        if (new_buffer)
+        {
+            new_buffer = false;
+            pcm_play_dma_started_callback();
+
+            /* NOTE: might need to release the mutex and sleep here if the
+               buffer is shorter than the required buffer (like pcm-sdl.c) to
+               have the mixer clocked at a regular interval */
+        }
+
         if (ret < 0)
+        {
+            unlock_audio();
             return ret;
+        }
 
         if (pcm_data_size == 0) /* need new data */
+        {
+            new_buffer = true;
             pcm_play_get_more_callback((void**)&pcm_data_start, &pcm_data_size);
+        }
         else /* increment data pointer and feed more */
             pcm_data_start += transfer_size;
     }
+
+    if (new_buffer && pcm_data_size)
+        pcm_play_dma_started_callback();
+
+    unlock_audio();
     return max_size - left;
 }
 
 void pcm_play_lock(void)
 {
+    if (++audio_locked == 1)
+        lock_audio();
 }
 
 void pcm_play_unlock(void)
 {
+    if (--audio_locked == 0)
+        unlock_audio();
 }
 
 void pcm_dma_apply_settings(void)
@@ -153,8 +204,6 @@ void pcm_play_dma_init(void)
     set_volume_method = e->GetMethodID(env_ptr, RockboxPCM_class, "set_volume", "(I)V");
     stop_method       = e->GetMethodID(env_ptr, RockboxPCM_class, "stop", "()V");
     write_method      = e->GetMethodID(env_ptr, RockboxPCM_class, "write", "([BII)I");
-    /* get initial pcm data, if any */
-    pcm_play_get_more_callback((void*)&pcm_data_start, &pcm_data_size);
 }
 
 void pcm_postinit(void)
@@ -173,6 +222,7 @@ void pcm_shutdown(void)
     JNIEnv e = *env_ptr;
     jmethodID release = e->GetMethodID(env_ptr, RockboxPCM_class, "release", "()V");
     e->CallVoidMethod(env_ptr, RockboxPCM_instance, release);
+    pthread_mutex_destroy(&audio_lock_mutex);
 }
     
 /* Due to limitations of default_event_handler(), parameters gets swallowed when
diff --git a/firmware/target/hosted/maemo/pcm-gstreamer.c b/firmware/target/hosted/maemo/pcm-gstreamer.c
index e3e40f0619..6069801fba 100644
--- a/firmware/target/hosted/maemo/pcm-gstreamer.c
+++ b/firmware/target/hosted/maemo/pcm-gstreamer.c
@@ -54,6 +54,7 @@
 #endif
 
 #include "pcm.h"
+#include "pcm-internal.h"
 #include "pcm_sampr.h"
 
 /*#define LOGF_ENABLE*/
@@ -182,6 +183,8 @@ static void feed_data(GstElement * appsrc, guint size_hint, void *unused)
 
         if (ret != 0)
             DEBUGF("push-buffer error result: %d\n", ret);
+
+        pcm_play_dma_started_callback();
     } else
     {
         DEBUGF("feed_data: No Data.\n");
diff --git a/firmware/target/hosted/sdl/pcm-sdl.c b/firmware/target/hosted/sdl/pcm-sdl.c
index 7780083b99..dfdd90f29b 100644
--- a/firmware/target/hosted/sdl/pcm-sdl.c
+++ b/firmware/target/hosted/sdl/pcm-sdl.c
@@ -30,6 +30,7 @@
 #include "sound.h"
 #include "audiohw.h"
 #include "system.h"
+#include "panic.h"
 
 #ifdef HAVE_RECORDING
 #include "audiohw.h"
@@ -39,6 +40,7 @@
 #endif
 
 #include "pcm.h"
+#include "pcm-internal.h"
 #include "pcm_sampr.h"
 
 /*#define LOGF_ENABLE*/
@@ -71,15 +73,19 @@ static struct pcm_udata
 
 static SDL_AudioSpec obtained;
 static SDL_AudioCVT cvt;
+static int audio_locked = 0;
+static SDL_mutex *audio_lock;
 
 void pcm_play_lock(void)
 {
-    SDL_LockAudio();
+    if (++audio_locked == 1)
+        SDL_LockMutex(audio_lock);
 }
 
 void pcm_play_unlock(void)
 {
-    SDL_UnlockAudio();
+    if (--audio_locked == 0)
+        SDL_UnlockMutex(audio_lock);
 }
 
 static void pcm_dma_apply_settings_nolock(void)
@@ -227,14 +233,19 @@ static void write_to_soundcard(struct pcm_udata *udata)
 static void sdl_audio_callback(struct pcm_udata *udata, Uint8 *stream, int len)
 {
     logf("sdl_audio_callback: len %d, pcm %d\n", len, pcm_data_size);
+
+    bool new_buffer = false;
     udata->stream = stream;
 
+    SDL_LockMutex(audio_lock);
+
     /* Write what we have in the PCM buffer */
     if (pcm_data_size > 0)
         goto start;
 
     /* Audio card wants more? Get some more then. */
     while (len > 0) {
+        new_buffer = true;
         pcm_play_get_more_callback((void **)&pcm_data, &pcm_data_size);
     start:
         if (pcm_data_size != 0) {
@@ -246,6 +257,28 @@ static void sdl_audio_callback(struct pcm_udata *udata, Uint8 *stream, int len)
             udata->num_in  *= pcm_sample_bytes;
             udata->num_out *= pcm_sample_bytes;
 
+
+            if (new_buffer)
+            {
+                new_buffer = false;
+                pcm_play_dma_started_callback();
+
+                if ((size_t)len > udata->num_out)
+                {
+                    int delay = pcm_data_size*250 / pcm_sampr - 1;
+                
+                    if (delay > 0)
+                    {
+                        SDL_UnlockMutex(audio_lock);
+                        SDL_Delay(delay);
+                        SDL_LockMutex(audio_lock);
+
+                        if (!pcm_is_playing())
+                            break;
+                    }
+                }
+            }
+
             pcm_data      += udata->num_in;
             pcm_data_size -= udata->num_in;
             udata->stream += udata->num_out;
@@ -255,6 +288,8 @@ static void sdl_audio_callback(struct pcm_udata *udata, Uint8 *stream, int len)
             break;
         }
     }
+
+    SDL_UnlockMutex(audio_lock);
 }
 
 const void * pcm_play_dma_get_peak_buffer(int *count)
@@ -320,6 +355,14 @@ void pcm_play_dma_init(void)
         return;
     }
 
+    audio_lock = SDL_CreateMutex();
+
+    if (!audio_lock)
+    {
+        panicf("Could not create audio_lock\n");
+        return;
+    }
+
     SDL_AudioSpec wanted_spec;
 #ifdef DEBUG
     udata.debug = NULL;
diff --git a/firmware/target/mips/ingenic_jz47xx/pcm-jz4740.c b/firmware/target/mips/ingenic_jz47xx/pcm-jz4740.c
index 5cd9c33e18..cfc3c9ef8e 100644
--- a/firmware/target/mips/ingenic_jz47xx/pcm-jz4740.c
+++ b/firmware/target/mips/ingenic_jz47xx/pcm-jz4740.c
@@ -25,6 +25,7 @@
 #include "audio.h"
 #include "sound.h"
 #include "pcm.h"
+#include "pcm-internal.h"
 #include "jz4740.h"
 
 
@@ -109,6 +110,7 @@ static inline void play_dma_callback(void)
     {
         set_dma(start, size);
         REG_DMAC_DCCSR(DMA_AIC_TX_CHANNEL) |= DMAC_DCCSR_EN;
+        pcm_play_dma_started_callback();
     }
 }