File content as of revision 0:c79e1f29f029:

#include <string.h>
#include "sound.h"
#include "lpc111x.h"

// Useful Macros
#define ISNUMBER(a) ((a >= '0') && (a <= '9'))
#define ISALPHA(a) (((a >= 'a') && (a <= 'z')) || ((a >= 'A') && (a <= 'Z')))
#define TOLOWER(a) if ((a >= 'A') && (a <= 'Z')) a = (a - 'A') + 'a';

//  ======== Waveform Definitions ========
// 64 elements
const char sine[] = {
    0x80,0x83,0x86,0x89,0x8c,0x8f,0x92,0x95,0x98,0x9c,0x9f,0xa2,0xa5,0xa8,0xab,0xae,
    0xb0,0xb3,0xb6,0xb9,0xbc,0xbf,0xc1,0xc4,0xc7,0xc9,0xcc,0xce,0xd1,0xd3,0xd5,0xd8,
    0xda,0xdc,0xde,0xe0,0xe2,0xe4,0xe6,0xe8,0xea,0xec,0xed,0xef,0xf0,0xf2,0xf3,0xf5,
    0xf6,0xf7,0xf8,0xf9,0xfa,0xfb,0xfc,0xfc,0xfd,0xfe,0xfe,0xff,0xff,0xff,0xff,0xff,
    0xff,0xff,0xff,0xff,0xff,0xff,0xfe,0xfe,0xfd,0xfc,0xfc,0xfb,0xfa,0xf9,0xf8,0xf7,
    0xf6,0xf5,0xf3,0xf2,0xf0,0xef,0xed,0xec,0xea,0xe8,0xe6,0xe4,0xe2,0xe0,0xde,0xdc,
    0xda,0xd8,0xd5,0xd3,0xd1,0xce,0xcc,0xc9,0xc7,0xc4,0xc1,0xbf,0xbc,0xb9,0xb6,0xb3,
    0xb0,0xae,0xab,0xa8,0xa5,0xa2,0x9f,0x9c,0x98,0x95,0x92,0x8f,0x8c,0x89,0x86,0x83,
    0x80,0x7c,0x79,0x76,0x73,0x70,0x6d,0x6a,0x67,0x63,0x60,0x5d,0x5a,0x57,0x54,0x51,
    0x4f,0x4c,0x49,0x46,0x43,0x40,0x3e,0x3b,0x38,0x36,0x33,0x31,0x2e,0x2c,0x2a,0x27,
    0x25,0x23,0x21,0x1f,0x1d,0x1b,0x19,0x17,0x15,0x13,0x12,0x10,0x0f,0x0d,0x0c,0x0a,
    0x09,0x08,0x07,0x06,0x05,0x04,0x03,0x03,0x02,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
    0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x02,0x03,0x03,0x04,0x05,0x06,0x07,0x08,
    0x09,0x0a,0x0c,0x0d,0x0f,0x10,0x12,0x13,0x15,0x17,0x19,0x1b,0x1d,0x1f,0x21,0x23,
    0x25,0x27,0x2a,0x2c,0x2e,0x31,0x33,0x36,0x38,0x3b,0x3e,0x40,0x43,0x46,0x49,0x4c,
    0x4f,0x51,0x54,0x57,0x5a,0x5d,0x60,0x63,0x67,0x6a,0x6d,0x70,0x73,0x76,0x79,0x7c};
    
const char square[] =  {
    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
    0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
    0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
    0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
    0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
    0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
    0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
    0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff};

const char sawtooth[] = {
    0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,
    0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1a,0x1b,0x1c,0x1d,0x1e,0x1f,
    0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29,0x2a,0x2b,0x2c,0x2d,0x2e,0x2f,
    0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x3a,0x3b,0x3c,0x3d,0x3e,0x3f,
    0x40,0x41,0x42,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4a,0x4b,0x4c,0x4d,0x4e,0x4f,
    0x50,0x51,0x52,0x53,0x54,0x55,0x56,0x57,0x58,0x59,0x5a,0x5b,0x5c,0x5d,0x5e,0x5f,
    0x60,0x61,0x62,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6a,0x6b,0x6c,0x6d,0x6e,0x6f,
    0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7a,0x7b,0x7c,0x7d,0x7e,0x7f,
    0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8a,0x8b,0x8c,0x8d,0x8e,0x8f,
    0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9a,0x9b,0x9c,0x9d,0x9e,0x9f,
    0xa0,0xa1,0xa2,0xa3,0xa4,0xa5,0xa6,0xa7,0xa8,0xa9,0xaa,0xab,0xac,0xad,0xae,0xaf,
    0xb0,0xb1,0xb2,0xb3,0xb4,0xb5,0xb6,0xb7,0xb8,0xb9,0xba,0xbb,0xbc,0xbd,0xbe,0xbf,
    0xc0,0xc1,0xc2,0xc3,0xc4,0xc5,0xc6,0xc7,0xc8,0xc9,0xca,0xcb,0xcc,0xcd,0xce,0xcf,
    0xd0,0xd1,0xd2,0xd3,0xd4,0xd5,0xd6,0xd7,0xd8,0xd9,0xda,0xdb,0xdc,0xdd,0xde,0xdf,
    0xe0,0xe1,0xe2,0xe3,0xe4,0xe5,0xe6,0xe7,0xe8,0xe9,0xea,0xeb,0xec,0xed,0xee,0xef,
    0xf0,0xf1,0xf2,0xf3,0xf4,0xf5,0xf6,0xf7,0xf8,0xf9,0xfa,0xfb,0xfc,0xfd,0xfe,0xff};

const char triangle[] = {
    0x00,0x02,0x04,0x06,0x08,0x0a,0x0c,0x0e,0x10,0x12,0x14,0x16,0x18,0x1a,0x1c,0x1e,
    0x20,0x22,0x24,0x26,0x28,0x2a,0x2c,0x2e,0x30,0x32,0x34,0x36,0x38,0x3a,0x3c,0x3e,
    0x40,0x42,0x44,0x46,0x48,0x4a,0x4c,0x4e,0x50,0x52,0x54,0x56,0x58,0x5a,0x5c,0x5e,
    0x60,0x62,0x64,0x66,0x68,0x6a,0x6c,0x6e,0x70,0x72,0x74,0x76,0x78,0x7a,0x7c,0x7e,
    0x80,0x82,0x84,0x86,0x88,0x8a,0x8c,0x8e,0x90,0x92,0x94,0x96,0x98,0x9a,0x9c,0x9e,
    0xa0,0xa2,0xa4,0xa6,0xa8,0xaa,0xac,0xae,0xb0,0xb2,0xb4,0xb6,0xb8,0xba,0xbc,0xbe,
    0xc0,0xc2,0xc4,0xc6,0xc8,0xca,0xcc,0xce,0xd0,0xd2,0xd4,0xd6,0xd8,0xda,0xdc,0xde,
    0xe0,0xe2,0xe4,0xe6,0xe8,0xea,0xec,0xee,0xf0,0xf2,0xf4,0xf6,0xf8,0xfa,0xfc,0xfe,
    0xff,0xfd,0xfb,0xf9,0xf7,0xf5,0xf3,0xf1,0xef,0xef,0xeb,0xe9,0xe7,0xe5,0xe3,0xe1,
    0xdf,0xdd,0xdb,0xd9,0xd7,0xd5,0xd3,0xd1,0xcf,0xcf,0xcb,0xc9,0xc7,0xc5,0xc3,0xc1,
    0xbf,0xbd,0xbb,0xb9,0xb7,0xb5,0xb3,0xb1,0xaf,0xaf,0xab,0xa9,0xa7,0xa5,0xa3,0xa1,
    0x9f,0x9d,0x9b,0x99,0x97,0x95,0x93,0x91,0x8f,0x8f,0x8b,0x89,0x87,0x85,0x83,0x81,
    0x7f,0x7d,0x7b,0x79,0x77,0x75,0x73,0x71,0x6f,0x6f,0x6b,0x69,0x67,0x65,0x63,0x61,
    0x5f,0x5d,0x5b,0x59,0x57,0x55,0x53,0x51,0x4f,0x4f,0x4b,0x49,0x47,0x45,0x43,0x41,
    0x3f,0x3d,0x3b,0x39,0x37,0x35,0x33,0x31,0x2f,0x2f,0x2b,0x29,0x27,0x25,0x23,0x21,
    0x1f,0x1d,0x1b,0x19,0x17,0x15,0x13,0x11,0x0f,0x0f,0x0b,0x09,0x07,0x05,0x03,0x01};


// For vibrato - 64 elements in length - thanks lft
const int8_t sinetable[] = {
    0, 12, 25, 37, 49, 60, 71, 81, 90, 98, 106, 112, 117, 122, 125, 126,
    127, 126, 125, 122, 117, 112, 106, 98, 90, 81, 71, 60, 49, 37, 25, 12,
    0, -12, -25, -37, -49, -60, -71, -81, -90, -98, -106, -112, -117, -122,
    -125, -126, -127, -126, -125, -122, -117, -112, -106, -98, -90, -81,
    -71, -60, -49, -37, -25, -12
};

// -=-=-=-=-=-=-= End Waveforms -=-=-=-=-=-=-=-=-=

#define PWM_FREQUENCY       23448       // 23.448 kHz => Match value of ~2047 (Convenient for binary math)
#define PWM_MATCH_VAL       (48000000 / PWM_FREQUENCY)
#define EFFECT_CALL_FREQ    50          // Hz
#define EFFECT_CALL_WAIT    PWM_FREQUENCY / EFFECT_CALL_FREQ
#define MAX_FREQ            8000                                      // 8 kHz (something pratical.. and not ear splitting)
#define MAX_FREQ_INC        ((65535 * MAX_FREQ) / PWM_FREQUENCY)
#define SLIDE_SCALER        ((65535 * 10) / PWM_FREQUENCY)            // 10 Hz per tick...

// Volatile Interrupt Variables
volatile int timer32_0_counter;
Sound *pSound = NULL;
volatile unsigned short int effect_wait = EFFECT_CALL_WAIT;

// Interrupt ---------------------------------------

void TIMER32_0_IRQHandler(void)
{    
    // Check to see if the PWM interrupt is triggered (MR3)
    if (TMR32B0IR & BIT3)
    {
        if (!pSound) return;
        
        effect_wait--;
        if (effect_wait == 0)
        {
            // Do the effects at 50 Hz ... why because everyone does it that way
            pSound->DoEffects();
            effect_wait = EFFECT_CALL_WAIT;
            // Do the song at 50 Hz
            pSound->DoSong();
        }
        
        static unsigned int noiseseed = 1;
        unsigned char newbit;
        
        newbit = 0;
        if(noiseseed & 0x80000000L) newbit ^= 1;
        if(noiseseed & 0x01000000L) newbit ^= 1;
        if(noiseseed & 0x00000040L) newbit ^= 1;
        if(noiseseed & 0x00000200L) newbit ^= 1;
        noiseseed = (noiseseed << 1) | newbit;
        
        // Reset the interrupt flag
        TMR32B0IR = BIT3;
        
        // Increment the counter
        timer32_0_counter++;
        
        register int master_acc = 0;
        register int acc = 0;
        register int channels = 0;
        bool bMuted = pSound->bMuted;
        
        for (int i = 0; i < SOUND_MAX_CHANNELS; i++)
        {
            SOUND_CHANNEL *pChannel = &pSound->channel[i];
            if ((pChannel->active) && (pChannel->volume > 0))
            {
                pChannel->phase_acc += pChannel->phase_inc;
                acc = pChannel->pWaveform[pChannel->phase_acc >> 8];    // -128 to 127
                if (pChannel->use_noise) acc = (noiseseed & 0xFF) - 127;// -128 to 127
                acc *= pChannel->volume;                                // 0 to 65535
                acc = acc >> 8;                                         // Rescale to -128 to 127
                acc += 128;                                             // 0 to 255
                master_acc += acc;
                channels++;
            }
        }
        
        if (channels > 1) master_acc /= channels;
        master_acc = master_acc << 3;                               // 0 to 2047 (PWM_MATCH_VAL)
        //master_acc = acc << 3;
        if (master_acc > PWM_MATCH_VAL) master_acc = PWM_MATCH_VAL;
        
        // Check to see if we are muted
        if (bMuted) master_acc = 0;
        
        // Bounds check the master accumulator
        TMR32B0MR0 = master_acc;  // ( xx >> 8 equivalent to x / 256)
    }
    
    return;
}

// Implementation ----------------------------------

Sound::Sound()
{
    timer32_0_counter = 0;
    pSound = this;
    for (int i = 0; i < SOUND_MAX_CHANNELS; i++)
        channel[i].active = false;
    // Initialize the song stuff
    bPlaySong = false;
    bLoopSong = false;
    m_pSong = NULL;
    m_pSongBuffer = NULL;
    iSongChannel = 0;
    iSongNoteOffset = 0;
    iNoteCounter = 0;
    iTicksPerBeat = 0;
    bMuted = false;
}
    
Sound::~Sound()
{
}

void Sound::Init()
{
    SetupDefaults();
    
    // DISABLE the TImer
    TMR32B0TCR = 0;
    
    // DEBUG - do not enable the output pin so we do not make so much noise!!!
    // Initialize the PWM Match Output
    // Configure IO control register IOCON_PIO0_18 offset 0x40044048 with CT32B0_MAT0 bit set (0x02)
    REGISTER_32(0x40044048) = BIT1 | BIT4;
    
    // Configure the interrupt
    NVIC_SetVector(TIMER_32_0_IRQn, (uint32_t)TIMER32_0_IRQHandler);
    NVIC_SetPriority(TIMER_32_1_IRQn,0);
    NVIC_EnableIRQ(TIMER_32_0_IRQn);
    
    // CT32B0 base address 0x40014000
    // Turn ON CT32B0 => System Clock Control Register => SYSAHBCLKCTRL Bit 9
    SYSAHBCLKCTRL |= BIT9;
    // Set our frequency (counter value) in Match Register 0 (as it does not map directly to a pin) => Match Register 0 MR0
    TMR32B0MR3 = PWM_MATCH_VAL;        // PWM Frequency
    TMR32B0MR0 = 0;        // 0% Duty for now (OFF)
    // Configure Reset TC on Match with MR0 MR0R (Bit 1) MR0I (Bit 0) => Match Control Register MCR
    // Reset on Match Register 3 MR3 (as this is the register we use for the base frequency ... MR0 is used to set the duty cycle)
    TMR32B0MCR = BIT10 | BIT9;
    // PWM Control Register
    TMR32B0PWMC = BIT0;
    // Zero the counter 0 => Timer Counter Register TC
    TMR32B0TC = 0;
    // Set the PreScale Register
    TMR32B0PR = 0;
    // Clear the Prescale Counter
    TMR32B0PC = 0;
    // Enable the timer => Timer Control Register CR
    TMR32B0TCR = BIT0;
    
    __enable_irq();     // Enable Interrupts
}

void Sound::PlaySound(int iChannel, int iFreqHz, int iLength)
{
    // Check the channel
    if (iChannel < 0) return;
    if (iChannel >= SOUND_MAX_CHANNELS) return;
    
    if (iFreqHz == 0)
    {
        StopSound(iChannel);
        return;
    }
    
    // Get a pointer to the sound channel structure
    SOUND_CHANNEL *pChannel = &channel[iChannel];
    
    // Calculate a phase increment value
    int inc = (65535 * iFreqHz) / PWM_FREQUENCY;
    pChannel->phase_inc = (unsigned short)inc;
    pChannel->orig_phase_inc = (unsigned short)inc;
    // Clear the phase accumulator
    pChannel->phase_acc = 0;
    
    // Set the play length (0 to 255, 0 = INFINITE, 1 to 255 delay in 50 Hz ticks)
    pChannel->play_length = iLength;
    
    // Reset the volume level to its initial setting
    pChannel->volume = pChannel->vol_level;
    
    // Reset the change wait to the change speed
    pChannel->change_wait = pChannel->change_speed;
    
    // Set the active flag last
    pChannel->active = true;
}

void Sound::StopSound(int iChannel)
{
    // Check the channel
    if (iChannel < 0) return;
    if (iChannel >= SOUND_MAX_CHANNELS) return;
    
    // Clear the active flag
    channel[iChannel].active = false;
}

bool Sound::IsBusy(int iChannel)
{
    // Check the channel
    if (iChannel < 0) return false;
    if (iChannel >= SOUND_MAX_CHANNELS) return false;
    
    return (channel[iChannel].active && (channel[iChannel].volume > 0));
}

int Sound::GetCounter(void)
{
    return timer32_0_counter;
}

void Sound::SetInstrument(int iChannel, int iWaveform, int iVolume, int iDecayTime, int iSlide, int iChangeAmount, int iChangeSpeed, int iRepeatSpeed, int iVibratoDepth, int iVibratoSpeed)
{
    // Bounds check the channel
    if (iChannel < 0) return;
    if (iChannel >= SOUND_MAX_CHANNELS) return;
    
    // Set the waveform
    channel[iChannel].use_noise = false;
    switch (iWaveform)
    {
    default:
    case (SOUND_SQUARE):
        channel[iChannel].pWaveform = (unsigned char *)square;
        break;
    case (SOUND_SAW):
        channel[iChannel].pWaveform = (unsigned char *)sawtooth;
        break;
    case (SOUND_TRIANGLE):
        channel[iChannel].pWaveform = (unsigned char *)triangle;
        break;
    case (SOUND_SINE):
        channel[iChannel].pWaveform = (unsigned char *)sine;
        break;
    case (SOUND_NOISE):
        channel[iChannel].pWaveform = (unsigned char *)square;
        channel[iChannel].use_noise = true;
        break;
    }
    
    // Set the volume level
    channel[iChannel].vol_level = iVolume;
    channel[iChannel].volume = iVolume;
    
    // Set the Decay time
    channel[iChannel].decay_amount = iDecayTime;
    
    // Set the Slide value
    channel[iChannel].slide = iSlide;
    
    // Set the Change Amount and Change Speed
    int inc = (65535 * iChangeAmount / PWM_FREQUENCY);
    channel[iChannel].change_inc = (signed short)inc; // frequency amount in phase increments
    channel[iChannel].change_speed = iChangeSpeed;                                          // change delay in 50 hz ticks
    channel[iChannel].change_wait = iChangeSpeed;
    
    // Set the repeat speed
    channel[iChannel].repeat_speed = iRepeatSpeed;  // effect repeat speed in 50 hz ticks (really a delay)
    channel[iChannel].repeat_wait = iRepeatSpeed;
    
    // Set the vibrato parameters
    channel[iChannel].vibrato_depth = iVibratoDepth;                // Vibrato amplitude
    channel[iChannel].vibrato_speed = iVibratoSpeed;                // Vibrato speed in 50 Hz ticks (delay)
    channel[iChannel].vibrato_phase = 0;
    channel[iChannel].vibrato_inc = 0;
}
    
// Setup the default instruments and stuff
void Sound::SetupDefaults(void)
{
    for (int i = 0; i < SOUND_MAX_CHANNELS; i++)
    {
        // Set the default instrument parameters
        SetInstrument(i, SOUND_SQUARE, 255, 0, 0, 0, 0, 0, 0, 0);
    }
}

void Sound::DoEffects(void)
{
    for (int i = 0; i < SOUND_MAX_CHANNELS; i++)
    {
    
        if (!channel[i].active) continue;
        
        // Set the play length (0 to 255, 0 = INFINITE, 1 to 255 delay in 50 Hz ticks)
        if (channel[i].play_length > 0)
        {
            // Subtract 1 tick
            channel[i].play_length--;
            // If we get to 0 set the channel to inactive
            if (channel[i].play_length == 0) channel[i].active = false;
        }
    
        // Volume Related Effects
        if (channel[i].volume > 0)
        {
            short int vol = channel[i].volume;
            // Decay
            if (channel[i].decay_amount)
            {
                if (channel[i].decay_amount < vol)
                    vol -= channel[i].decay_amount;
                else
                    vol = 0;
            }
            // Set the adjusted volume level
            channel[i].volume = vol;
        }
        // If the volume is 0 then who cares?
        // Do not turn the channel off as Repeat will not work?
        /*
        if (channel[i].volume == 0)
        {
            // Turn this channel off for now
            channel[i].active = false;
        }
        */
        
        // Slide (Frequency Shifting) Effects
        if (channel[i].slide != 0)
        {
            int inc = (int)channel[i].phase_inc + ((int)channel[i].slide * SLIDE_SCALER);
            if ((inc > 0) && (inc < MAX_FREQ_INC))
                channel[i].phase_inc = inc;
            else
                //channel[i].active = false;
                channel[i].volume = 0;
        }
        
        // Change (Frequency Change after Delay)
        if (channel[i].change_wait > 0)
        {
            channel[i].change_wait--;
            if (channel[i].change_wait == 0)
                channel[i].phase_inc += channel[i].change_inc;
        }
        
        // Vibrato
        if (channel[i].vibrato_speed > 0)
        {
            // Calculate the vibrato waveform's phase
            channel[i].vibrato_phase += (channel[i].vibrato_speed * SLIDE_SCALER);
            // Calculate the sinewave values
            int inc = sinetable[channel[i].vibrato_phase & 63] * channel[i].vibrato_depth;
            // Rescale (from 65535 to 255)
            inc = inc >> 8;
            
            inc = inc + (int)channel[i].phase_inc;
            channel[i].phase_inc = inc;
        }
        
        // Repeat (resets parameters after a certain mount of time ... pew pew pew)
        if (channel[i].repeat_speed > 0)
        {
            channel[i].repeat_wait--;
            if (channel[i].repeat_wait == 0)
            {
                // Reset the repeat wait (so we can do this again!
                channel[i].repeat_wait = channel[i].repeat_speed;
                // Reset the frequency and amplitude to the original
                channel[i].phase_inc = channel[i].orig_phase_inc;
                // Reset the volume (amplitude) to the original
                channel[i].volume = channel[i].vol_level;
            }
        }
    }
}

void Sound::PlaySong(char *pRTTTL, int iChannel, int iBPM, bool bLoop)
{
    // Check the RTTTL pointer
    if (!pRTTTL) return;
    
    // Stop the song temporarily
    bPlaySong = false;
    
    // Setup the song variables
    iSongChannel = iChannel;
    SetSongTempo(iBPM);
    bLoopSong = bLoop;
    iNoteCounter = 0;
    
    // Get the length of this song (in characters)
    int iNewLen = strlen(pRTTTL);
    
    // Copy and allocate the song buffer
    
    // Deal with the song buffer if it has already allocated memory
    if (m_pSongBuffer)
    {
        // Check to see if we need to allocate more memory
        if (iSongBufferLen < iNewLen)
        {
            // Cleanup the old and allocate a new buffer
            delete [] m_pSongBuffer;
            m_pSongBuffer = NULL;
        }
    }
    // Allocate a new song buffer if we need to
    if (!m_pSongBuffer)
    {
        m_pSongBuffer = new char[iNewLen + 1];
    }
    // Copy the song into the song buffer
    memcpy(m_pSongBuffer, pRTTTL, iNewLen);
    // Add an extra NULL terminator just incase
    m_pSongBuffer[iNewLen] = 0;
    
    // Set the song pointer to the beginning
    m_pSong = m_pSongBuffer;
    
    // Start the song
    bPlaySong = true;
}

#define TICKSPERMINUTE  (60 * 50)

void Sound::SetSongTempo(int iBPM)
{
    // Setup the note wait time in 50Hz ticks
    iTicksPerBeat = TICKSPERMINUTE / iBPM;
    if (iTicksPerBeat < 1) iTicksPerBeat = 1;
    if (iTicksPerBeat > TICKSPERMINUTE) iTicksPerBeat = TICKSPERMINUTE;
}

void Sound::TransposeSong(int iOffset)
{
    iSongNoteOffset = iOffset;
}

void Sound::StopSong(void)
{
    // clear the play sound
    bPlaySong = false;
    // Silence
    StopSound(iSongChannel);
    // All done with this function
    return;
}

void Sound::DoSong(void)
{
    // Check to see if we are playing a song
    if (!bPlaySong) return;
    
    // Check to see if there is a song to play
    if (!m_pSong) return;
    
    // Check to see if we need to play the next note
    iNoteCounter--;
    if (iNoteCounter > 0) return;
    
    int duration = 4;
    int octave = 5;
    int freq = NOTE_C4;
    char note = 'c';
    bool bSharp = false;
    bool bDotted = false;
    int volume = channel[iSongChannel].volume;
    while (*m_pSong != ',')
    {
        // Parse and play a note
        // Check for duration
        if (ISNUMBER(*m_pSong))
        {
            duration = *m_pSong - '0';
            m_pSong++;
            if (ISNUMBER(*m_pSong))
            {
                duration = (duration * 10) + (*m_pSong - '0');
                m_pSong++;
            }
        }
        // Check for the note
        if (ISALPHA(*m_pSong))
        {
            TOLOWER(*m_pSong);
            note = *m_pSong;
            m_pSong++;
        }
        // Check for a sharp
        if (*m_pSong == '#') { bSharp = true; m_pSong++; }
        // Check for dotted
        if (*m_pSong == '.') { bDotted = true; m_pSong++; }
        // Check for the octave
        if (ISNUMBER(*m_pSong))
        {
            octave = *m_pSong - '0';
            m_pSong++;
        }
        // Check to see if we need to start over
        if (*m_pSong == 0)
        {  
            if (bLoopSong)
            {
                // Set the song buffer to the beginning
                m_pSong = m_pSongBuffer;
                // and process the first note all over again
                continue;
            }
            else
            {
                StopSong();
                // All done with this function
                return;
            }
        }
        // Next character so we do not get stuck
        if (*m_pSong != ',') m_pSong++;
        // Check for silence
        if (note != 'p')
        {
            // Convert the note to a frequency
            freq = SongGetFreq(note, octave, bSharp);
            // Play the note
            PlaySound(iSongChannel, freq, volume + 1);
        }
        else
        {
            // Silence (Pause)
            StopSound(iSongChannel);
        }
        
        // Set the note counter so we play the note for so many frames
        switch(duration)
        {
        case (1): iNoteCounter = 4 * iTicksPerBeat; break;
        case (2): iNoteCounter = 2 * iTicksPerBeat; break;
        default:
        case (4): iNoteCounter = iTicksPerBeat; break;
        case (8): iNoteCounter = iTicksPerBeat >> 1; break;
        case (16): iNoteCounter = iTicksPerBeat >> 2; break;
        case (32): iNoteCounter = iTicksPerBeat >> 3; break;
        }
        if (bDotted) iNoteCounter += iNoteCounter >> 1;
        
        //char cTemp[32];
        //snprintf(cTemp, 32, "N(%c%c)D(%02d)O(%d)", note, bSharp ? '#' : ' ', duration, octave);
        //disp.drawString(0, 16, cTemp, DisplayN18::RED, DisplayN18::BLACK);

    }
    m_pSong++;
}

int Sound::SongGetFreq(char note, int octave, bool bSharp)
{
    // Bounds check the octave
    if (octave < 4) octave = 4;
    if (octave > 6) octave = 6;
    
    switch(octave)
    {
    case (4):
        switch(note)
        {
        case ('a'):
            if (bSharp) return NOTE_As4;
            return NOTE_A4;
        case ('b'):
            if (bSharp) return NOTE_C5;
            return NOTE_B4;
        case ('c'):
            if (bSharp) return NOTE_Cs4;
            return NOTE_C4;
        case ('d'):
            if (bSharp) return NOTE_Ds4;
            return NOTE_D4;
        case ('e'):
            if (bSharp) return NOTE_F4;
            return NOTE_E4;
        case ('f'):
            if (bSharp) return NOTE_Fs4;
            return NOTE_F4;
        case ('g'):
            if (bSharp) return NOTE_Gs4;
            return NOTE_G4;
        }
    case (5):
        switch(note)
        {
        case ('a'):
            if (bSharp) return NOTE_As5;
            return NOTE_A5;
        case ('b'):
            if (bSharp) return NOTE_C6;
            return NOTE_B5;
        case ('c'):
            if (bSharp) return NOTE_Cs5;
            return NOTE_C5;
        case ('d'):
            if (bSharp) return NOTE_Ds5;
            return NOTE_D5;
        case ('e'):
            if (bSharp) return NOTE_F5;
            return NOTE_E5;
        case ('f'):
            if (bSharp) return NOTE_Fs5;
            return NOTE_F5;
        case ('g'):
            if (bSharp) return NOTE_Gs5;
            return NOTE_G5;
        }
    case (6):
        switch(note)
        {
        case ('a'):
            if (bSharp) return NOTE_As6;
            return NOTE_A6;
        case ('b'):
            if (bSharp) return NOTE_C7;
            return NOTE_B6;
        case ('c'):
            if (bSharp) return NOTE_Cs6;
            return NOTE_C6;
        case ('d'):
            if (bSharp) return NOTE_Ds6;
            return NOTE_D6;
        case ('e'):
            if (bSharp) return NOTE_F6;
            return NOTE_E6;
        case ('f'):
            if (bSharp) return NOTE_Fs6;
            return NOTE_F6;
        case ('g'):
            if (bSharp) return NOTE_Gs6;
            return NOTE_G6;
        }
    }
    
    return NOTE_C7;
}

void Sound:: Mute(bool mute)
{
    bMuted = mute;   
}