More ACEness

Here's a more portable command-line driven utility to generate wav files ready for ACE's ears. There's a tiny enhancement that ramps up the volume during the lead-in which should prevent the kind of pants-wetting shock that I keep delivering to myself :)

/*
* Support code for ACE - the arduino cassette engine
*
* Example code to write a wav file which can be played to
* a microcontroller running the ACE software.
*
* Should be fairly portable unlike the original example.
*
* Enjoy.
*
*/

#include <iostream>
#include <fstream>

typedef unsigned char uint8_t;

// adjust these to control endiannesses.
//
static const int ENDIAN0 = 0;
static const int ENDIAN1 = 1;
static const int ENDIAN2 = 2;
static const int ENDIAN3 = 3;

static const int ENDIAN0_S = 0;
static const int ENDIAN1_S = 1;

// desired wave structure - AHEM THESE ARE READ-ONLY
// - THEY CAN'T BE CHANGED WITHOUT FUTZING THE CODE. SORRY.
//
static const int CHANNELS = 2;
static const int SAMPLERATE = 44100;
static const int BITSPERSAMPLE = 16;

// this is as loud as we can get. not quite 11,
// but approaching it.
//
static const double maxLevel = (double)SHRT_MAX * 1.0;
static const short maxLevelS = (short)maxLevel;
static const double minLevel = (double)SHRT_MIN * 1.0;
static const short minLevelS = (short)minLevel;


// number of samples per cycle. 60 samples = 1 low or 2 high cycles.
//
static const int f1 = 60;
static const int f1cyc = 1;
static const int f2 = f1 / 2;
static const int f2cyc = f1cyc * 2;

// useful values, maybe
//
static const int usPerCycle = (int)(((double)f1 / 44100) * 1000000.0);
static const int usPerHalfCycle = (int)(((double)f1 / 44100) * 500000.0);
static const int usPerQuarterCycle = (int)(((double)f1 / 44100) * 250000.0);
static const int usPerEighthCycle = (int)(((double)f1 / 44100) * 125000.0);

static const int baudrate = (1000000 / usPerCycle);

// 8 + stop + start;
//
static const int bitsPerFrame = 10;

static const int samplesPerBit = f1 * f1cyc;
static const int samplesPerFrame = bitsPerFrame * samplesPerBit;


static const int LOW_BIT = 0;
static const int HIGH_BIT = !LOW_BIT;

static const int LEADIN_BIT = LOW_BIT;
static const int START_BIT = !LEADIN_BIT;
static const int STOP_BIT = !START_BIT;


// NASTY HACK FOR WRITING WAVS. PLEASE LOOK AWAY NOW.

void CreateWaveFile(std::ostream& output)
{
    char chars[4];

    output << "RIFF";
    *(int*)chars = 16;
    output << chars[ENDIAN0] << chars[ENDIAN1] << chars[ENDIAN2] << chars[ENDIAN3];

    output << "WAVE";
    output << "fmt ";

    *(int*)chars = 16;
    output << chars[ENDIAN0] << chars[ENDIAN1] << chars[ENDIAN2] << chars[ENDIAN3];

    *(short*)chars = 1;
    output << chars[ENDIAN0_S] << chars[ENDIAN1_S];

    *(short*)chars = CHANNELS;
    output << chars[ENDIAN0_S] << chars[ENDIAN1_S];

    *(int*)chars = SAMPLERATE;
    output << chars[ENDIAN0] << chars[ENDIAN1] << chars[ENDIAN2] << chars[ENDIAN3];

    *(int*)chars = (int)(SAMPLERATE*(BITSPERSAMPLE/8*CHANNELS));
    output << chars[ENDIAN0] << chars[ENDIAN1] << chars[ENDIAN2] << chars[ENDIAN3];

    *(short*)chars = (short)(BITSPERSAMPLE/8*CHANNELS);
    output << chars[ENDIAN0_S] << chars[ENDIAN1_S];

    *(short*)chars = (short)BITSPERSAMPLE;
    output << chars[ENDIAN0_S] << chars[ENDIAN1_S];

    output << "data";
    *(int*)chars = 0;
    output << chars[ENDIAN0] << chars[ENDIAN1] << chars[ENDIAN2] << chars[ENDIAN3];
}


void FinaliseWaveFile(std::ostream& output, size_t bytesWrit)
{
    char chars[4];

    output.seekp(40);

    *(int*)chars = (int)bytesWrit;
    output << chars[ENDIAN0] << chars[ENDIAN1] << chars[ENDIAN2] << chars[ENDIAN3];

    output.seekp(4);

    *(int*)chars = (int)(bytesWrit + 36);
    output << chars[ENDIAN0] << chars[ENDIAN1] << chars[ENDIAN2] << chars[ENDIAN3];
}

// OK IT'S SAFE TO LOOK AGAIN



// here we represent:
//
//   0 bit as 1 cycle of low frequency,
//   1 bit as 2 cycles of high frequency
//
// where the high frequency is double that of the low.
//
void OutputBit(std::ostream& output, int bit, size_t& written,
    short maxval = maxLevelS, short minval = minLevelS)
{
    // default to low
    //
    int cycles = f1cyc;
    int samplesPerCycle = f1;

    if (bit != 0)
    {
        cycles = f2cyc;
        samplesPerCycle = f2;
    }

    // generate square pulse, start with rising edge
    //
    for (int i = 0; i < cycles; ++i)
    {
        for (int j = 0; j < samplesPerCycle / 2; ++j)
        {
            // high [1] period
            //
            output << uint8_t(maxval & 0xff);
            output << uint8_t(maxval >> 8);
            output << uint8_t(maxval & 0xff);
            output << uint8_t(maxval >> 8);
            written += 4;
        }
        for (int j = 0; j < samplesPerCycle / 2; ++j)
        {
            // low [0] period
            //
            output << uint8_t(minval & 0xff);
            output << uint8_t(minval >> 8);
            output << uint8_t(minval & 0xff);
            output << uint8_t(minval >> 8);
            written += 4;
        }
    }
}


// outputs a start bit, 8 data bits and a stop bit
//
void OutputByte(std::ostream& output, uint8_t value, size_t& written)
{
    OutputBit(output, START_BIT, written);

    for (int i = 0; i < 8; ++i)
    {
        OutputBit(output, (value & 0x80) ? HIGH_BIT : LOW_BIT, written);
        value <<= 1;
    }

    OutputBit(output, STOP_BIT, written);
}


// outputs a lead train of bits, terminated with a start bit.
//
void OutputLeader(std::ostream& output, int milliseconds, size_t& written)
{
    int microseconds = (milliseconds * 1000) - usPerCycle;;

    // this is a bit of a decoration - 
    // ramp up the volume during the 1st half of the leader. this might
    // prevent some unexpected eardrum-rupture events.. and yes, i know
    // that volume should be ramped non-linearly :) this will do for
    // the time being.
    //
    double vol = 0, ramp = 1.0 / (microseconds/(usPerCycle*2));

    while (microseconds >= 0)
    {
        OutputBit(output, LEADIN_BIT, written, (short)(vol * maxLevel), (short)(vol * minLevel));
        vol += ramp;
        vol = __min(vol, 1.0);
        
        microseconds -= usPerCycle;
    }

    OutputBit(output, START_BIT, written);
}


void main (int argc, char **argv)
{
    if (argc < 3)
    {
        std::cout << "Usage: makewav [input file] [output file]" << std::endl;
        exit(1);
    }

    std::ifstream inner(argv[1], std::ios_base::binary);
    if (!inner.is_open())
    {
        std::cout << "Could not open input file." << std::endl;
        exit(1);
    }

    std::ofstream outer(argv[2], std::ios_base::binary);
    if (!outer.is_open())
    {
        std::cout << "Could not open output file." << std::endl;
        exit(1);
    }

    // write wav header
    //
    CreateWaveFile(outer);

    // determine input file size
    //
    inner.seekg(0, std::ios_base::end);
    size_t size = (size_t)inner.tellg();
    inner.seekg(0);

    size_t pc = 0;
    size_t written = 0;

    // file is structured:
    //   some seconds of leader
    //   size msb
    //   size lsb
    //   {
    //    data[512]
    //    some milliseconds of leader
    //   }

    OutputLeader(outer, 2000, written);

    OutputByte(outer, uint8_t(size >> 8), written);
    OutputByte(outer, uint8_t(size & 0xff), written);

    while (pc != size)
    {
        // dummy data - replace this with either read from buffer indexed by [pc]
        // or a byte get from the file to be encoded
        // 
        OutputByte(outer, inner.get(), written);

        ++pc;
        if (pc % 512 == 0 && pc != size)
        {
            OutputLeader(outer, 50, written);
        }
    }

    FinaliseWaveFile(outer, written);

    outer.close();
}