apps/pcmbuf.c

/***************************************************************************
 *             __________               __   ___.
 *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
 *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
 *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
 *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
 *                     \/            \/     \/    \/            \/
 * $Id$
 *
 * Copyright (C) 2005 by Miika Pekkarinen
 *
 * All files in this archive are subject to the GNU General Public License.
 * See the file COPYING in the source tree root for full license agreement.
 *
 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
 * KIND, either express or implied.
 *
 ****************************************************************************/

#include <stdbool.h>
#include <stdio.h>
#include "config.h"
#include "debug.h"
#include "panic.h"
#include <kernel.h>
#include "pcmbuf.h"
#include "pcm_playback.h"
#include "logf.h"
#ifndef SIMULATOR
#include "cpu.h"
#endif
#include "system.h"
#include <string.h>
#include "buffer.h"
#include "settings.h"
#include "audio.h"
#include "dsp.h"

#define CHUNK_SIZE           32768
/* Must be a power of 2 */
#define NUM_PCM_BUFFERS      128
#define NUM_PCM_BUFFERS_MASK (NUM_PCM_BUFFERS - 1)
/* Watermark level at 1s. */
#define PCMBUF_WATERMARK     (NATIVE_FREQUENCY * 4 * 1)

/* Audio buffer related settings. */
static long pcmbuf_size = 0;      /* Size of the PCM buffer. */
static char *audiobuffer;
static long audiobuffer_pos;      /* Current audio buffer write index. */
long audiobuffer_free IDATA_ATTR; /* Amount of bytes left in the buffer. */
static long audiobuffer_fillpos;  /* Amount audiobuffer_pos will be increased.*/
static char *guardbuf;

static void (*pcmbuf_event_handler)(void);

/* Crossfade related. */
static int crossfade_mode;
static bool crossfade_enabled;
static bool crossfade_active;
static bool crossfade_init;
static int crossfade_pos;
static int crossfade_rem;

static struct mutex pcmbuf_mutex;

/* Crossfade modes. If CFM_CROSSFADE is selected, normal
 * crossfader will activate. Selecting CFM_FLUSH is a special
 * operation that only overwrites the pcm buffer without crossfading.
 */
enum {
    CFM_CROSSFADE,
    CFM_MIX,
    CFM_FLUSH
};

static int crossfade_fade_in_amount;
static int crossfade_fade_in_rem;

/* Structure we can use to queue pcm chunks in memory to be played
 * by the driver code. */
struct pcmbufdesc
{
    void *addr;
    int size;
    /* Call this when the buffer has been played */
    void (*callback)(void);
} pcmbuffers[NUM_PCM_BUFFERS] IDATA_ATTR; /* Do we really need IRAM for this? */

static int pcmbuf_read_index;
static int pcmbuf_write_index;
static int pcmbuf_unplayed_bytes IDATA_ATTR;
static int pcmbuf_mix_used_bytes;
static int pcmbuf_watermark;
static void pcmbuf_under_watermark(int bytes_left);
static int pcmbuf_num_used_buffers(void);
static void (*position_callback)(int size);
static int last_chunksize;
static long mixpos = 0;
static bool low_latency_mode = false;

#ifdef HAVE_ADJUSTABLE_CPU_FREQ
static bool boost_mode;

void pcmbuf_boost(bool state)
{
    static bool boost_state = false;
    
    if (crossfade_init || crossfade_active || boost_mode)
        return ;
        
    if (state != boost_state) {
        cpu_boost(state);
        boost_state = state;
    }
}

void pcmbuf_set_boost_mode(bool state)
{
    if (state)
        pcmbuf_boost(true);
    boost_mode = state;
}
#endif

static int pcmbuf_num_used_buffers(void)
{
    return (pcmbuf_write_index - pcmbuf_read_index) & NUM_PCM_BUFFERS_MASK;
}

static void pcmbuf_callback(unsigned char** start, long* size) ICODE_ATTR;
static void pcmbuf_callback(unsigned char** start, long* size)
{
    struct pcmbufdesc *desc = &pcmbuffers[pcmbuf_read_index];

    if (position_callback) {
        position_callback(last_chunksize);
    }
    
    pcmbuf_unplayed_bytes -= last_chunksize;
    audiobuffer_free += last_chunksize;
        
    if(desc->size == 0)
    {
        /* The buffer is finished, call the callback function */
        if(desc->callback)
            desc->callback();

        /* Advance to the next buffer */
        pcmbuf_read_index = (pcmbuf_read_index + 1) & NUM_PCM_BUFFERS_MASK;
        desc = &pcmbuffers[pcmbuf_read_index];
    }
    
    if(pcmbuf_num_used_buffers())
    {
    
        *start = desc->addr;
        *size = desc->size;

        /* Update the buffer descriptor */
        desc->addr += desc->size;
        desc->size = 0;
    }
    else
    {
        /* No more buffers */
        *size = 0;
        if (pcmbuf_event_handler)
            pcmbuf_event_handler();
    }

    last_chunksize = *size;

    if(pcmbuf_unplayed_bytes <= pcmbuf_watermark)
    {
        pcmbuf_under_watermark(pcmbuf_unplayed_bytes);
    }
}

void pcmbuf_set_position_callback(void (*callback)(int size)) {
    position_callback = callback;
}

static void pcmbuf_set_watermark_bytes(int numbytes)
{
    pcmbuf_watermark = numbytes;
}

bool pcmbuf_add_chunk(void *addr, int size, void (*callback)(void))
{
    /* We don't use the last buffer, since we can't see the difference
       between the full and empty condition */
    if(pcmbuf_num_used_buffers() < (NUM_PCM_BUFFERS - 2))
    {
        pcmbuffers[pcmbuf_write_index].addr = addr;
        pcmbuffers[pcmbuf_write_index].size = size;
        pcmbuffers[pcmbuf_write_index].callback = callback;
        pcmbuf_write_index = (pcmbuf_write_index+1) & NUM_PCM_BUFFERS_MASK;
        pcmbuf_unplayed_bytes += size;
        pcmbuf_mix_used_bytes = MAX(0, pcmbuf_mix_used_bytes - size);
        return true;
    }
    else
        return false;
}

static void pcmbuf_under_watermark(int bytes_left)
{
    /* Fill audio buffer by boosting cpu */
    pcmbuf_boost(true);
    if (bytes_left <= CHUNK_SIZE * 2 && crossfade_mode != CFM_FLUSH)
        crossfade_active = false;
}

void pcmbuf_add_event(void (*event_handler)(void))
{
    pcmbuf_event_handler = event_handler;
}

unsigned int pcmbuf_get_latency(void)
{
    int latency = (pcmbuf_unplayed_bytes + pcm_get_bytes_waiting()) 
        * 1000 / 4 / 44100;
    
    return latency<0?0:latency;
}

void pcmbuf_set_low_latency(bool state)
{
    low_latency_mode = state;
}

bool pcmbuf_is_lowdata(void)
{
    if (!pcm_is_playing() || pcm_is_paused() || crossfade_init || crossfade_active)
        return false;

    /* 0.5s. */
    if (pcmbuf_unplayed_bytes < NATIVE_FREQUENCY * 4 / 2)
        return true;
        
    return false;
}

bool pcmbuf_crossfade_init(bool manual_skip)
{
    if (pcmbuf_size - audiobuffer_free < CHUNK_SIZE * 8
        || !pcmbuf_is_crossfade_enabled()
        || crossfade_active || crossfade_init || low_latency_mode) {
        pcmbuf_flush_audio();
        return false;
    }
    logf("pcmbuf_crossfade_init");
    pcmbuf_boost(true);

    /* Don't enable mix mode when skipping tracks manually. */
    if (manual_skip)
        crossfade_mode = CFM_CROSSFADE;
    else
        crossfade_mode = global_settings.crossfade_fade_out_mixmode
                ? CFM_MIX : CFM_CROSSFADE;
    crossfade_init = true;
    
    return true;
    
}

void pcmbuf_play_stop(void)
{
    mutex_lock(&pcmbuf_mutex);
    
    /** Prevent a very tiny pop from happening by muting audio
     *  until dma has been initialized. */
    pcm_mute(true);
    pcm_play_stop();
    pcm_mute(false);
    
    last_chunksize = 0;
    pcmbuf_unplayed_bytes = 0;
    pcmbuf_mix_used_bytes = 0;
    pcmbuf_read_index = 0;
    pcmbuf_write_index = 0;
    audiobuffer_pos = 0;
    audiobuffer_fillpos = 0;
    audiobuffer_free = pcmbuf_size;
    crossfade_init = false;
    crossfade_active = false;
    
    pcmbuf_set_boost_mode(false);
    pcmbuf_boost(false);

    mutex_unlock(&pcmbuf_mutex);
}

void pcmbuf_init(long bufsize)
{
    mutex_init(&pcmbuf_mutex);
    pcmbuf_size = bufsize;
    audiobuffer = (char *)&audiobuf[(audiobufend - audiobuf) - 
                                    pcmbuf_size - PCMBUF_GUARD];
    guardbuf = &audiobuffer[pcmbuf_size];
    position_callback = NULL;
    pcmbuf_event_handler = NULL;
    pcmbuf_play_stop();
}

long pcmbuf_get_bufsize(void)
{
    return pcmbuf_size;
}

/** Initialize a track switch so that audio playback will not stop but
 *  the switch to next track would happen as soon as possible.
 */
void pcmbuf_flush_audio(void)
{
    if (crossfade_init || crossfade_active || !pcm_is_playing()) {
        pcmbuf_play_stop();
        return ;
    }
    
    pcmbuf_boost(true);
    crossfade_mode = CFM_FLUSH;
    crossfade_init = true;
}

/* Force playback. */
void pcmbuf_play_start(void)
{
    if (!pcm_is_playing() && pcmbuf_unplayed_bytes)
    {
        /** Prevent a very tiny pop from happening by muting audio
         *  until dma has been initialized. */
        pcm_mute(true);
    
        pcm_play_data(pcmbuf_callback);

        /* Now unmute the audio. */
        pcm_mute(false);
    }
}

/**
 * Commit samples waiting to the pcm buffer.
 */
void pcmbuf_flush_fillpos(void)
{
    int copy_n;

    mutex_lock(&pcmbuf_mutex);
    
    copy_n = MIN(audiobuffer_fillpos, CHUNK_SIZE);
    
    if (copy_n) {
        while (!pcmbuf_add_chunk(&audiobuffer[audiobuffer_pos],
                                   copy_n, pcmbuf_event_handler)) {
            pcmbuf_boost(false);
            sleep(1);
            /* This is a fatal error situation that should never happen. */
            if (!pcm_is_playing()) {
                logf("pcm_flush_fillpos error");
                pcmbuf_play_start();
                mutex_unlock(&pcmbuf_mutex);
                return ;
            }
        }
        position_callback = NULL;
        pcmbuf_event_handler = NULL;
        audiobuffer_pos += copy_n;
        if (audiobuffer_pos >= pcmbuf_size)
            audiobuffer_pos -= pcmbuf_size;
        audiobuffer_free -= copy_n;
        audiobuffer_fillpos -= copy_n;
    }
    
    mutex_unlock(&pcmbuf_mutex);
}

/**
 * Completely process the crossfade fade out effect with current pcm buffer.
 */
static void crossfade_process_buffer(
        int fade_in_delay, int fade_out_delay, int fade_out_rem)
{
    int amount;
    int pos;
    short *buf;

    /* Fade out the entire current buffer according to settings. */
    amount = fade_out_rem;
    pos = crossfade_pos + fade_out_delay*2;
    
    while (fade_out_rem > 0 && crossfade_mode == CFM_CROSSFADE)
    {
        int blocksize = MIN(8192, fade_out_rem);
        int factor = (fade_out_rem<<8)/amount;

        /* Prevent pcmbuffer from wrapping. */
        if (pos >= pcmbuf_size)
            pos -= pcmbuf_size;
        blocksize = MIN((pcmbuf_size - pos)/2, blocksize);
        buf = (short *)&audiobuffer[pos];
        
        fade_out_rem -= blocksize;
        pos += blocksize * 2;
        while (blocksize > 0)
        {
            *buf = (*buf * factor) >> 8;
            *buf++;
            blocksize--;
        }
        //yield();
    }

    /* And finally set the mixing position where we should start fading in. */
    crossfade_rem -= fade_in_delay;
    crossfade_pos += fade_in_delay*2;
    if (crossfade_pos >= pcmbuf_size)
        crossfade_pos -= pcmbuf_size;
    logf("process done!");
}

/**
 * Initializes crossfader, calculates all necessary parameters and
 * performs fade-out with the pcm buffer.
 */
static void crossfade_start(void)
{
    int bytesleft = pcmbuf_unplayed_bytes;
    int fade_out_rem = 0, fade_out_delay = 0;
    int fade_in_delay = 0;
    
    crossfade_init = 0;
    if (bytesleft < CHUNK_SIZE * 4) {
        logf("crossfade rejected");
        pcmbuf_play_stop();
        return ;
    }

    logf("crossfade_start");
    pcmbuf_boost(true);
    while (audiobuffer_fillpos != 0)
        pcmbuf_flush_fillpos();
    crossfade_active = true;
    crossfade_pos = audiobuffer_pos;

    switch (crossfade_mode) {
        case CFM_MIX:
        case CFM_CROSSFADE:
            /* Initialize the crossfade buffer size. */
            // FIXME: Crashes unless we use CHUNK_SIZE here
            crossfade_rem = (bytesleft - (CHUNK_SIZE * 2))/2;

            /* Get fade out delay from settings. */
            fade_out_delay = NATIVE_FREQUENCY
                    * global_settings.crossfade_fade_out_delay * 2;

            /* Get fade out duration from settings. */
            fade_out_rem = NATIVE_FREQUENCY
                    * global_settings.crossfade_fade_out_duration * 2;

            /* We want only to modify the last part of the buffer. */
            if (crossfade_rem > fade_out_rem + fade_out_delay)
                crossfade_rem = fade_out_rem + fade_out_delay;

            /* Truncate fade out duration if necessary. */
            if (crossfade_rem < fade_out_rem + fade_out_delay)
                fade_out_rem -= (fade_out_rem + fade_out_delay) - crossfade_rem;

            /* Get also fade in duration and delays from settings. */
            crossfade_fade_in_rem = NATIVE_FREQUENCY
                    * global_settings.crossfade_fade_in_duration * 2;
            crossfade_fade_in_amount = crossfade_fade_in_rem;

            /* We should avoid to divide by zero. */
            if (crossfade_fade_in_amount == 0)
                crossfade_fade_in_amount = 1;

            fade_in_delay = NATIVE_FREQUENCY
                    * global_settings.crossfade_fade_in_delay * 2;
        
            /* Decrease the fade out delay if necessary. */
            fade_out_delay += MIN(crossfade_rem -
                                  fade_out_rem -
                                  fade_out_delay, 0);
            if (fade_out_delay < 0)
                fade_out_delay = 0;
            break ;

        case CFM_FLUSH:
            crossfade_rem = (bytesleft - CHUNK_SIZE) /2;
            crossfade_fade_in_rem = 0;
            crossfade_fade_in_amount = 0;
            break ;
    }
    
    crossfade_pos -= crossfade_rem*2;
    if (crossfade_pos < 0)
        crossfade_pos += pcmbuf_size;
    
    if (crossfade_mode != CFM_FLUSH) {
        /* Process the fade out part of the crossfade. */
        crossfade_process_buffer(fade_in_delay, fade_out_delay, fade_out_rem);
    }
    
}

/**
 * Fades in samples passed to the function and inserts them
 * to the pcm buffer.
 */
static void fade_insert(const short *inbuf, int length)
{
    int copy_n;
    int factor;
    int i, samples;
    short *buf;
    
    factor = ((crossfade_fade_in_amount-crossfade_fade_in_rem)
            <<8)/crossfade_fade_in_amount;

    while (audiobuffer_free < length + audiobuffer_fillpos
        + CHUNK_SIZE)
    {
        pcmbuf_boost(false);
        sleep(1);
    }
    
    while (length > 0) {
        copy_n = MIN(length, pcmbuf_size - audiobuffer_pos -
                audiobuffer_fillpos);
        copy_n = MIN(CHUNK_SIZE - audiobuffer_fillpos, copy_n);

        buf = (short *)&audiobuffer[audiobuffer_pos+audiobuffer_fillpos];
        samples = copy_n / 2;
        for (i = 0; i < samples; i++)
            buf[i] = (inbuf[i] * factor) >> 8;
        
        inbuf += samples;
        audiobuffer_fillpos += copy_n;
        length -= copy_n;
        
        /* Pre-buffer to meet CHUNK_SIZE requirement */
        if (audiobuffer_fillpos < CHUNK_SIZE && length == 0) {
            break ;
        }

        pcmbuf_flush_fillpos();
    }
}

/**
 * Fades in buf2 and mixes it with buf.
 */
static __inline
int crossfade(short *buf, const short *buf2, int length)
{
    int size, i;
    int size_insert = 0;
    int factor;
    
    size = MAX(0, MIN(length, crossfade_rem));
    switch (crossfade_mode) {
        /* Fade in the current stream and mix it. */
        case CFM_MIX:
        case CFM_CROSSFADE:
            factor = ((crossfade_fade_in_amount-crossfade_fade_in_rem)
                    <<8)/crossfade_fade_in_amount;
            
            for (i = 0; i < size; i++) {
                buf[i] = MIN(MAX(buf[i] + ((buf2[i] * factor) >> 8), -32768), 32767);
            }
            break ;

        /* Join two streams. */
        case CFM_FLUSH:
            for (i = 0; i < size; i++) {
                buf[i] = buf2[i];
            }
            //memcpy((char *)buf, (char *)buf2, size*2);
            break ;
    }

    crossfade_fade_in_rem = MAX(0, crossfade_fade_in_rem - size);
    crossfade_rem -= size;
    if (crossfade_rem <= 0)
    {
        if (crossfade_fade_in_rem > 0 && crossfade_fade_in_amount > 0)
        {
            size_insert = MAX(0, MIN(crossfade_fade_in_rem, length - size));
            fade_insert(&buf2[size], size_insert*2);
            crossfade_fade_in_rem -= size_insert;
        }
        
        if (crossfade_fade_in_rem <= 0)
            crossfade_active = false;
    }

    return size + size_insert;
}

static bool prepare_insert(long length)
{
    if (crossfade_init)
        crossfade_start();

    if (low_latency_mode)
    {
        /* 1/4s latency. */
        if (pcmbuf_unplayed_bytes > NATIVE_FREQUENCY * 4 / 4
            && pcm_is_playing())
            return false;
    }
    
    if (audiobuffer_free < length + audiobuffer_fillpos
           + CHUNK_SIZE && !crossfade_active) {
        pcmbuf_boost(false);
        return false;
    }

    if (!pcm_is_playing()) {
        pcmbuf_boost(true);
        crossfade_active = false;
        /* Pre-buffer 1s. */
        if (audiobuffer_free < pcmbuf_size - NATIVE_FREQUENCY*4) {
            logf("pcm starting");
            pcmbuf_play_start();
        }
    }
    
    return true;
}

void* pcmbuf_request_buffer(long length, long *realsize)
{
    void *ptr = NULL;

    if (!prepare_insert(length))
    {
        *realsize = 0;
        return NULL;
    }
    
    if (crossfade_active) {
        *realsize = MIN(length, PCMBUF_GUARD);
        ptr = &guardbuf[0];
    } else {
        *realsize = MIN(length, pcmbuf_size - audiobuffer_pos
                            - audiobuffer_fillpos);
        if (*realsize < length) {
            *realsize += MIN((long)(length - *realsize), PCMBUF_GUARD);
        }
        ptr = &audiobuffer[audiobuffer_pos + audiobuffer_fillpos];
    }
    
    return ptr;
}

bool pcmbuf_is_crossfade_active(void)
{
    return crossfade_active || crossfade_init;
}

void pcmbuf_flush_buffer(long length)
{
    int copy_n;
    char *buf;

    if (crossfade_active) {
        buf = &guardbuf[0];
        length = MIN(length, PCMBUF_GUARD);
        while (length > 0 && crossfade_active) {
            copy_n = MIN(length, pcmbuf_size - crossfade_pos);
            copy_n = 2 * crossfade((short *)&audiobuffer[crossfade_pos], 
                    (const short *)buf, copy_n/2);
            buf += copy_n;
            length -= copy_n;
            crossfade_pos += copy_n;
            if (crossfade_pos >= pcmbuf_size)
                crossfade_pos -= pcmbuf_size;
        }
        
        while (length > 0) {
            pcmbuf_flush_fillpos();
            copy_n = MIN(length, pcmbuf_size - audiobuffer_pos);
            memcpy(&audiobuffer[audiobuffer_pos], buf, copy_n);
            audiobuffer_fillpos = copy_n;
            buf += copy_n;
            length -= copy_n;
        }
    }

    audiobuffer_fillpos += length;

    try_flush:
    if (audiobuffer_fillpos < CHUNK_SIZE && pcmbuf_size
        - audiobuffer_pos - audiobuffer_fillpos > 0)
        return ;

    copy_n = audiobuffer_fillpos - (pcmbuf_size - audiobuffer_pos);
    if (copy_n > 0) {
        audiobuffer_fillpos -= copy_n;
        pcmbuf_flush_fillpos();
        copy_n = MIN(copy_n, PCMBUF_GUARD);
        memcpy(&audiobuffer[0], &guardbuf[0], copy_n);
        audiobuffer_fillpos = copy_n;
        goto try_flush;
    }
    pcmbuf_flush_fillpos();
}

bool pcmbuf_insert_buffer(char *buf, long length)
{
    long copy_n = 0;
    
    if (!prepare_insert(length))
        return false;

    
    if (crossfade_active) {
        while (length > 0 && crossfade_active) {
            copy_n = MIN(length, pcmbuf_size - crossfade_pos);
                
            copy_n = 2 * crossfade((short *)&audiobuffer[crossfade_pos],
                                    (const short *)buf, copy_n/2);
            buf += copy_n;
            length -= copy_n;
            crossfade_pos += copy_n;
            if (crossfade_pos >= pcmbuf_size)
                crossfade_pos -= pcmbuf_size;
        }
        
        while (length > 0) {
            pcmbuf_flush_fillpos();
            copy_n = MIN(length, pcmbuf_size - audiobuffer_pos);
            memcpy(&audiobuffer[audiobuffer_pos], buf, copy_n);
            audiobuffer_fillpos = copy_n;
            buf += copy_n;
            length -= copy_n;
        }
    }
        
    while (length > 0) {
        copy_n = MIN(length, pcmbuf_size - audiobuffer_pos -
                    audiobuffer_fillpos);
        copy_n = MIN(CHUNK_SIZE - audiobuffer_fillpos, copy_n);

        memcpy(&audiobuffer[audiobuffer_pos+audiobuffer_fillpos],
                buf, copy_n);
        buf += copy_n;
        audiobuffer_fillpos += copy_n;
        length -= copy_n;
        
        /* Pre-buffer to meet CHUNK_SIZE requirement */
        if (audiobuffer_fillpos < CHUNK_SIZE && length == 0) {
            return true;
        }

        pcmbuf_flush_fillpos();
    }

    return true;
}

/* Generates a constant square wave sound with a given frequency
   in Hertz for a duration in milliseconds. */
void pcmbuf_beep(int frequency, int duration, int amplitude)
{
    int state = 0, count = 0;
    int interval = NATIVE_FREQUENCY / frequency;
    int pos;
    short *buf = (short *)audiobuffer;
    int bufsize = pcmbuf_size / 2;
    
    /* FIXME: Should start playback. */
    //if (pcmbuf_unplayed_bytes * 1000 < 4 * NATIVE_FREQUENCY * duration)
    //    return ;

    pos = (audiobuffer_pos - pcmbuf_unplayed_bytes) / 2;
    if (pos < 0)
        pos += bufsize;

    duration = NATIVE_FREQUENCY / 1000 * duration;
    while (duration-- > 0)
    {
        if (state) {
            buf[pos] = MIN(MAX(buf[pos] + amplitude, -32768), 32767);
            if (++pos >= bufsize)
                pos = 0;
            buf[pos] = MIN(MAX(buf[pos] + amplitude, -32768), 32767);
        } else {
            buf[pos] = MIN(MAX(buf[pos] - amplitude, -32768), 32767);
            if (++pos >= bufsize)
                pos = 0;
            buf[pos] = MIN(MAX(buf[pos] - amplitude, -32768), 32767);
        }
        
        if (++count >= interval)
        {
            count = 0;
            if (state)
                state = 0;
            else
                state = 1;
        }
        pos++;
        if (pos >= bufsize)
            pos = 0;
    }
}

/* Returns pcm buffer usage in percents (0 to 100). */
int pcmbuf_usage(void)
{
    return pcmbuf_unplayed_bytes * 100 / pcmbuf_size;
}

int pcmbuf_mix_usage(void)
{
    return pcmbuf_mix_used_bytes * 100 / pcmbuf_unplayed_bytes;
}

void pcmbuf_reset_mixpos(void)
{
    int bufsize = pcmbuf_size / 2;

    pcmbuf_mix_used_bytes = 0;
    mixpos = (audiobuffer_pos - pcmbuf_unplayed_bytes) / 2;
    if (mixpos < 0)
        mixpos += bufsize;
    if (mixpos >= bufsize)
        mixpos -= bufsize;
}

void pcmbuf_mix(char *buf, long length)
{
    short *ibuf = (short *)buf;
    short *obuf = (short *)audiobuffer;
    int bufsize = pcmbuf_size / 2;

    if (pcmbuf_mix_used_bytes == 0)
        pcmbuf_reset_mixpos();
    
    pcmbuf_mix_used_bytes += length;
    length /= 2;

    while (length-- > 0) {
        obuf[mixpos] = MIN(MAX(obuf[mixpos]/4 + *ibuf, -32768), 32767);
        
        ibuf++;
        mixpos++;
        if (mixpos >= bufsize)
            mixpos = 0;
    }
}

void pcmbuf_crossfade_enable(bool on_off)
{
    crossfade_enabled = on_off;

    if (crossfade_enabled) {
        pcmbuf_set_watermark_bytes(pcmbuf_size - (NATIVE_FREQUENCY*4/2));
    } else {
        pcmbuf_set_watermark_bytes(PCMBUF_WATERMARK);
    }
}

bool pcmbuf_is_crossfade_enabled(void)
{
    if (global_settings.crossfade == CROSSFADE_ENABLE_SHUFFLE)
        return global_settings.playlist_shuffle;

    return crossfade_enabled;
}