source: orbit/iOS/Orbit/Orbit/AudioGenerator.m @ ce0a7ee

//
//  AudioGenerator.m
//  orbit
//
//  Created by Jonathon Horsman on 19/07/2013.
//  Copyright (c) 2013 Puzzlebox Productions, LLC. All rights reserved.
//

#import "AudioGenerator.h"

#define sampleRate 44100

/**
 * Half periods in the audio code, in seconds.
 */
#define longHIGH 0.000829649
#define longLOW 0.000797027
#define shortHIGH 0.000412649
#define shortLOW 0.000378351

@implementation AudioGenerator {
    float sampleTime;
        AudioComponentInstance toneUnit;
    
    int longHighLength, shortHighLength, longZeroLength, longLowLength, mediumLowLength, shortLowLength, waveBitLength;
    float *waveLongHigh, *waveShortHigh, *waveLongZero, *waveLongLow, *waveMediumLow, *waveShortLow, *waveBit;
    
    int MAX_BUFFER_SIZE;
}

@synthesize yaw, pitch, throttle;

- (id) init
{
    self = [super init];
    if (self) {
        sampleTime = 1 / (float)sampleRate;
        
        [self prepareStaticArrays];
    }
    return self;
}

- (void) prepareStaticArrays
{
    
    waveLongHigh = [self generateHalfSine:true halfPeriod:longHIGH];
    longHighLength = [self arraySizeWithHalfPeriod:longHIGH];
    waveLongLow = [self generateHalfSine:false halfPeriod:longLOW];
    longLowLength = [self arraySizeWithHalfPeriod:longLOW];
    waveShortHigh = [self generateHalfSine:true halfPeriod:shortHIGH];
    shortHighLength = [self arraySizeWithHalfPeriod:shortHIGH];
    waveShortLow = [self generateHalfSine:false halfPeriod:shortLOW];
    shortLowLength = [self arraySizeWithHalfPeriod:shortLOW];
    
    float mediumLow = 0.0005 - sampleTime;
    waveMediumLow = [self generateHalfSine:false halfPeriod:mediumLow];
    mediumLowLength = [self arraySizeWithHalfPeriod:mediumLow];
    
    
    longZeroLength = (int)floor((0.002 + 1 / sampleRate) * sampleRate);
    waveLongZero = malloc(longZeroLength);
    
    [self generateWaveBit];
}

- (void) generateWaveBit
{
    waveBitLength = longHighLength + longLowLength + shortHighLength + shortLowLength;
    waveBit = malloc(sizeof(waveBit) * waveBitLength);
    int c = 0;
    for (int i = 0; i < longHighLength; i++) {
        waveBit[c++] = waveLongHigh[i];
    }
    for (int i = 0; i < longLowLength; i++) {
        waveBit[c++] = waveLongLow[i];
    }
    for (int i = 0; i < shortHighLength; i++) {
        waveBit[c++] = waveShortHigh[i];
    }
    for (int i = 0; i < shortLowLength; i++) {
        waveBit[c++] = waveShortLow[i];
    }
}


- (void) stop
{
    if (toneUnit != nil) {
        AudioOutputUnitStop(toneUnit);
        AudioUnitUninitialize(toneUnit);
        AudioComponentInstanceDispose(toneUnit);
        toneUnit = nil;
    }
}

- (void) playWithThrottle: (int)t yaw: (int)y pitch: (int)p
{
    self.yaw = y;
    self.pitch = p;
    self.throttle = t;
    
    if (toneUnit == nil) {
        [self createToneUnit];
        
        // Stop changing parameters on the unit
        OSErr err = AudioUnitInitialize(toneUnit);
        
        // Start playback
        err = AudioOutputUnitStart(toneUnit);
    }
}

OSStatus RenderTone(
                    void *inRefCon,
                    AudioUnitRenderActionFlags  *ioActionFlags,
                    const AudioTimeStamp                *inTimeStamp,
                    UInt32                                              inBusNumber,
                    UInt32                                              inNumberFrames,
                    AudioBufferList                     *ioData)

{
    
        
        // This is a mono tone generator so we only need the first buffer
        const int channel = 0;
        Float32 *buffer = (Float32 *)ioData->mBuffers[channel].mData;
    
    AudioGenerator *generator = (__bridge AudioGenerator *)inRefCon;
    [generator writeBytesToBuffer:buffer maxSize:inNumberFrames];
    return noErr;
}

/**
 * All this code stolen from http://www.cocoawithlove.com/2010/10/ios-tone-generator-introduction-to.html
 */
- (void) createToneUnit
{
    // Configure the search parameters to find the default playback output unit
    // (called the kAudioUnitSubType_RemoteIO on iOS but
    // kAudioUnitSubType_DefaultOutput on Mac OS X)
    AudioComponentDescription defaultOutputDescription;
    defaultOutputDescription.componentType = kAudioUnitType_Output;
    defaultOutputDescription.componentSubType = kAudioUnitSubType_RemoteIO;
    defaultOutputDescription.componentManufacturer = kAudioUnitManufacturer_Apple;
    defaultOutputDescription.componentFlags = 0;
    defaultOutputDescription.componentFlagsMask = 0;
    
    // Get the default playback output unit
    AudioComponent defaultOutput = AudioComponentFindNext(NULL, &defaultOutputDescription);
    if (defaultOutput == NULL) {
        NSLog(@"Can't find default output");
    }
    
    // Create a new unit based on this that we'll use for output
    OSErr err = AudioComponentInstanceNew(defaultOutput, &toneUnit);
    if (toneUnit == NULL) {
        NSLog(@"Error creating unit: %hd", err);
    }
    
    // Set our tone rendering function on the unit
    AURenderCallbackStruct input;
    input.inputProc = RenderTone;
    input.inputProcRefCon = (__bridge void *)(self);
    err = AudioUnitSetProperty(toneUnit,
                               kAudioUnitProperty_SetRenderCallback,
                               kAudioUnitScope_Input,
                               0,
                               &input,
                               sizeof(input));
    if (err != noErr) {
        NSLog(@"Error setting callback: %hd", err);
    }
    
    // Set the format to 32 bit, single channel, floating point, linear PCM
    const int four_bytes_per_float = 4;
    const int eight_bits_per_byte = 8;
    AudioStreamBasicDescription streamFormat;
    streamFormat.mSampleRate = sampleRate;
    streamFormat.mFormatID = kAudioFormatLinearPCM;
    streamFormat.mFormatFlags =
    kAudioFormatFlagsNativeFloatPacked | kAudioFormatFlagIsNonInterleaved;
    streamFormat.mBytesPerPacket = four_bytes_per_float;
    streamFormat.mFramesPerPacket = 1;
    streamFormat.mBytesPerFrame = four_bytes_per_float;
    streamFormat.mChannelsPerFrame = 1;
    streamFormat.mBitsPerChannel = four_bytes_per_float * eight_bits_per_byte;
    err = AudioUnitSetProperty (toneUnit,
                                kAudioUnitProperty_StreamFormat,
                                kAudioUnitScope_Input,
                                0,
                                &streamFormat,
                                sizeof(AudioStreamBasicDescription));
    if (err != noErr) {
        NSLog(@"Error setting stream format: %hd", err);
    }
}

// calculate the checksum for the generated code used to generate the WAV array
- (int) codeChecksum:(int)code
{
    int checksum = 0;
    for (int i = 0; i < 7; i++) {
        checksum += (code >> 4*i) & 15;
    }
    return 16 - (checksum & 15);
}

// Generate the code used to create the WAV file based on the given throttle, yaw and pitch.
// Copied from AudioService.java in the Android app (command2code method)
// throttle: 0~127, nothing will happen if this value is below 30.
// yaw: 0~127, normally 78 will keep orbit from rotating.
// pitch: 0~63, normally 31 will stop the top propeller.
// channel: 1=Channel A, 0=Channel B 2= Channel C, depend on which channel you want to pair to the orbit. You can fly at most 3 orbit in a same room.
- (int) generateCode
{
    int channel = 1;
    int code = throttle << 21;
    code += 1048576; // code += 1 << 20 ;
    code += yaw << 12;
    code += pitch << 4 ;
    code += ((channel >> 1) & 1) << 19;
    code += (channel & 1) << 11;
    return code + [self codeChecksum:code];
}

- (void) writeBytesToBuffer:(Float32 *) buffer maxSize:(UInt32) frames
{
    MAX_BUFFER_SIZE = sizeof(buffer) * frames;
    int position = 0;
    [self writeWaveToBuffer:buffer        at:&position];
    [self writeInitialWaveToBuffer:buffer at:&position];
}

- (void) writeInitialWaveToBuffer:(Float32 *) buffer at: (int *) position
{
    [self writeWave123To: buffer at: position];
    [self writeWave123To: buffer at: position];
    [self writeWave456To: buffer at: position];
    [self writeWave456To: buffer at: position];
    [self writeWave456To: buffer at: position];
}

- (void) writeWave123To:(Float32 *) buffer at:(int *) position
{
    [self writeOriginalTo:buffer at: position];
    [self writeArray:waveMediumLow to:buffer length:mediumLowLength at:position];
    for (int i = 0; i < 4; i++) {
        [self writeShortHShortLTo:buffer at:position];
    }
    [self writeArray:waveShortHigh to:buffer length:shortHighLength at:position];
    [self writeMediumLShortHTo:buffer at:position];
    [self writePauseInSamplesTo:buffer at:position];
}

- (void) writeWave456To:(Float32 *) buffer at:(int *) position
{
    [self writeOriginalTo:buffer at:position];
    [self writeArray:waveShortLow to:buffer length:shortLowLength at:position];
    for (int i = 0; i < 4; i++) {
        [self writeShortHShortLTo:buffer at:position];
    }
    [self writeArray:waveShortHigh to:buffer length:shortHighLength at:position];
    [self writeMediumLShortHTo:buffer at:position];
    [self writePauseInSamplesTo:buffer at:position];
}


- (void) writeOriginalTo:(Float32 *) buffer at:(int *) position
{
    [self writeLongHLongZeroTo: buffer at: position];
    [self writeLongHLongZeroTo: buffer at: position];
    [self writeArray:waveLongHigh to:buffer length:longHighLength at:position];
    [self writeMediumLShortHTo:buffer at:position];
}

- (void) writeLongHLongZeroTo:(Float32 *) buffer at:(int *) position
{
    [self writeArray:waveLongHigh to:buffer length:longHighLength at:position];
    [self writeArray:waveLongZero to:buffer length:longZeroLength at:position];
}

- (void) writeMediumLShortHTo:(Float32 *) buffer at:(int *) position
{
    [self writeArray:waveMediumLow to:buffer length:mediumLowLength at:position];
    [self writeArray:waveShortHigh to:buffer length:shortHighLength at:position];
}

- (void) writeShortHShortLTo:(Float32 *) buffer at:(int *) position
{
    [self writeArray:waveShortHigh to:buffer length:shortHighLength at:position];
    [self writeArray:waveShortLow to:buffer length:shortLowLength at:position];
}

- (void) writePauseInSamplesTo:(Float32 *) buffer at:(int *) position
{
    int length = (int)floor(0.010 * sampleRate);
    float arr[length];
    [self writeArray:arr to:buffer length:length at:position];
}

- (void) writeArray:(float *) array to:(Float32 *) buffer length: (int)length at:(int *) position
{
    for (int i = 0; i < length; i++) {
        if (*position < MAX_BUFFER_SIZE) buffer[(*position)++] = array[i];
    }
}

- (void) writeWaveToBuffer:(Float32 *) buffer at: (int *) position
{
    [self halfSineGen: false halfPeriod: longLOW                   toBuffer:buffer at:position];
    [self halfSineGen: true  halfPeriod: longHIGH - sampleTime * 2 toBuffer:buffer at:position];
    [self halfSineGen: false halfPeriod: shortLOW + sampleTime * 2 toBuffer:buffer at:position];
    [self halfSineGen: true  halfPeriod: longHIGH - sampleTime * 2 toBuffer:buffer at:position]; // duplicate?
    [self halfSineGen: false halfPeriod: shortLOW + sampleTime * 2 toBuffer:buffer at:position]; // duplicate?
    
    int code = [self generateCode];
    for (int i=0; i < 27; i++) {
        buffer[(*position)++] = waveBit[((code >> (27 - i)) & 1)];
    }
    for (int i = 0; i < longHighLength; i++) {
        buffer[(*position)++] = waveLongHigh[i];
    }
    
}

/**
 * Generate half sine signal.
 * Copied from AudioService.java in the AndroidApp
 * @param upper, means it's the upper half or lower half or sine wave.
 * @param halfPeriod: half of the period of sine wave, in seconds
 * @param toBuffer the buffer (float array) to write to
 * @param position the position in the array to start writing to
 */
- (void) halfSineGen:(BOOL)upper halfPeriod: (double)halfPeriod toBuffer:(Float32 *) buffer at:(int *) position
{
    int sampleCount = [self arraySizeWithHalfPeriod:halfPeriod];
    double increment = M_PI/(halfPeriod * sampleRate);
    double angle = upper ? 0 : M_PI;
        
    for (int i = 0; i < sampleCount; i++) {
        buffer[(*position)++] = sinf(angle);
        angle += increment;
    }
}

- (int) arraySizeWithHalfPeriod: (double)halfPeriod
{
    return (int)floor(halfPeriod * sampleRate);
}

/**
 * Generate half sine signal.
 * Copied from AudioService.java in the AndroidApp
 * @param upper, means it's the upper half or lower half of sine wave.
 * @param halfPeriod: half of the period of sine wave, in seconds
 * @return the length of the array
 */
- (float *) generateHalfSine:(BOOL)upper halfPeriod: (double)halfPeriod
{
    int sampleCount = [self arraySizeWithHalfPeriod:halfPeriod];
    float *array = malloc(sizeof(*array) * sampleCount);
    double increment = M_PI/(halfPeriod * sampleRate);
    double angle = upper ? 0 : M_PI;
    
    for (int i = 0; i < sampleCount; i++) {
        array[i] = sinf(angle);
        angle += increment;
    }
    return array;
}

@end