Changeset c9b9edd in orbit for iOS


Ignore:
Timestamp:
10/21/13 07:25:15 (6 years ago)
Author:
Steve Castellotti <sc@…>
Branches:
master, Servo
Children:
ac05196
Parents:
0d2b1fc
Message:

iOS:

  • Signal generation update by Hao Zhang
Location:
iOS/Orbit/Orbit
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • iOS/Orbit/Orbit/AudioGenerator.m

    r835f156 rc9b9edd  
    99#import "AudioGenerator.h" 
    1010 
    11 #define sampleRate 44100 
     11 
     12 
     13#define SAMPLE_RATE_F 44100.f 
     14#define SIGNAL_WAVE_FREQUENCY 100.f 
     15 
    1216 
    1317/** 
     
    1923#define shortLOW 0.000378351 
    2024 
     25#define IDLE_TIME_MS 20 
     26 
     27 
     28volatile BOOL g_refreshCtrCode = NO; 
     29 
     30 
     31@interface AudioGenerator() 
     32{ 
     33     
     34    AudioUnit   m_audioUnit; 
     35    Float32     m_sampleRate; 
     36    BOOL        m_isPlaying; 
     37    double      m_signalPhaseCur; 
     38 
     39     
     40    int         waveBit_01_len[2]; 
     41    Float32     *waveBit_01[2]; 
     42     
     43    int         ctrWaveMaxLen; 
     44    int         ctrWaveDataLen; 
     45    Float32     *ctrWave; 
     46     
     47    int         ctrWaveHeadLen; 
     48    Float32     *ctrWaveHead; 
     49     
     50    int         ctrWaveReadIdx; 
     51     
     52    int         idleWaveLen; 
     53    int         idleWaveReadIdx; 
     54} 
     55 
     56@end 
     57 
     58 
    2159@implementation AudioGenerator { 
     60     
    2261    float sampleTime; 
    23         AudioComponentInstance toneUnit; 
    24      
    2562    int longHighLength, shortHighLength, longZeroLength, longLowLength, mediumLowLength, shortLowLength, waveBitLength; 
    2663    float *waveLongHigh, *waveShortHigh, *waveLongZero, *waveLongLow, *waveMediumLow, *waveShortLow, *waveBit; 
    2764     
     65     
     66     
    2867    int MAX_BUFFER_SIZE; 
     68 
    2969} 
    3070 
     
    3575    self = [super init]; 
    3676    if (self) { 
    37         sampleTime = 1 / (float)sampleRate; 
     77        sampleTime = 1.0f / SAMPLE_RATE_F; 
    3878         
    3979        [self prepareStaticArrays]; 
     
    4181    return self; 
    4282} 
     83 
     84#pragma mark - ---- interface ---- 
     85 
     86- (void) playWithThrottle: (int)t yaw: (int)y pitch: (int)p 
     87{ 
     88    self.yaw = y; 
     89    self.pitch = p; 
     90    self.throttle = t; 
     91     
     92    [self audioUnitStart]; 
     93     
     94} 
     95 
     96 
     97- (void) stop 
     98{ 
     99    [self audioUnitStop]; 
     100} 
     101 
     102 
     103#pragma mark - ---- Audio Unit func ---- 
     104 
     105- (void) audioUnitStart 
     106{ 
     107 
     108    if (m_audioUnit == nil) { 
     109        [self prepareAudioUnit]; 
     110    } 
     111     
     112    if (!m_isPlaying) { 
     113         
     114        [self updateCtrCode:NO]; 
     115         
     116        OSStatus status = AudioUnitInitialize(m_audioUnit); 
     117         
     118        if (status != noErr) { 
     119            NSLog(@"AudioUnitInitialize - error"); 
     120        } 
     121 
     122         
     123        status = AudioOutputUnitStart(m_audioUnit); 
     124        if (status != noErr) { 
     125            NSLog(@"AudioOutputUnitStart - error"); 
     126        } 
     127         
     128        m_isPlaying = YES; 
     129    } 
     130    else { 
     131        [self updateCtrCode:YES]; 
     132    } 
     133 
     134     
     135} 
     136 
     137 
     138- (void) audioUnitStop 
     139{ 
     140     
     141    if (m_isPlaying) { 
     142        OSStatus status = AudioOutputUnitStop(m_audioUnit); 
     143        if (status != noErr) { 
     144            NSLog(@"AudioOutputUnitStop - error"); 
     145        } 
     146         
     147        m_isPlaying = NO; 
     148    } 
     149     
     150    if (m_audioUnit) { 
     151        OSStatus status = AudioUnitUninitialize(m_audioUnit); 
     152        if (status != noErr) { 
     153            NSLog(@"AudioUnitUninitialize - error"); 
     154        } 
     155         
     156        status = AudioComponentInstanceDispose(m_audioUnit); 
     157        if (status != noErr) { 
     158            NSLog(@"AudioComponentInstanceDispose - error"); 
     159        } 
     160         
     161        m_audioUnit = nil; 
     162    } 
     163     
     164     
     165} 
     166 
     167 
     168 
     169- (void) prepareAudioUnit 
     170{ 
     171    m_sampleRate = SAMPLE_RATE_F; 
     172    m_isPlaying = NO; 
     173    m_signalPhaseCur = 0.0; 
     174     
     175    OSStatus status = noErr; 
     176     
     177    AudioComponentDescription au_cd; 
     178    au_cd.componentType = kAudioUnitType_Output; 
     179    au_cd.componentSubType = kAudioUnitSubType_RemoteIO; 
     180    au_cd.componentManufacturer = kAudioUnitManufacturer_Apple; 
     181    au_cd.componentFlags = 0; 
     182    au_cd.componentFlagsMask = 0; 
     183     
     184    AudioComponent component = AudioComponentFindNext(NULL, &au_cd); 
     185    if (component == NULL) { 
     186        NSLog(@"AudioComponentFindNext - error"); 
     187    } 
     188     
     189     
     190    status = AudioComponentInstanceNew(component, &m_audioUnit); 
     191    if (status != noErr) { 
     192        NSLog(@"AudioComponentInstanceNew - error"); 
     193    } 
     194     
     195     
     196    AURenderCallbackStruct callbackStruct; 
     197    callbackStruct.inputProc = renderAudioUnitCallback; 
     198    callbackStruct.inputProcRefCon = (__bridge void *)(self); 
     199     
     200    status = AudioUnitSetProperty(m_audioUnit, 
     201                         kAudioUnitProperty_SetRenderCallback, 
     202                         kAudioUnitScope_Input, 
     203                         0, 
     204                         &callbackStruct, 
     205                         sizeof(AURenderCallbackStruct)); 
     206     
     207    if (status != noErr) { 
     208        NSLog(@"kAudioUnitProperty_SetRenderCallback - error"); 
     209    } 
     210     
     211     
     212        AudioStreamBasicDescription streamFormat; 
     213        streamFormat.mSampleRate         = m_sampleRate; 
     214        streamFormat.mFormatID           = kAudioFormatLinearPCM; 
     215        streamFormat.mFormatFlags        = kAudioFormatFlagsNativeFloatPacked | kAudioFormatFlagIsNonInterleaved; 
     216        streamFormat.mChannelsPerFrame   = 2; 
     217        streamFormat.mBytesPerPacket     = sizeof(Float32); 
     218        streamFormat.mBytesPerFrame      = sizeof(Float32); 
     219        streamFormat.mFramesPerPacket    = 1; 
     220        streamFormat.mBitsPerChannel     = 8 * sizeof(Float32); 
     221     
     222        status = AudioUnitSetProperty(m_audioUnit, 
     223                                                 kAudioUnitProperty_StreamFormat, 
     224                                                 kAudioUnitScope_Input, 
     225                                                 0, 
     226                                                 &streamFormat, 
     227                                                 sizeof(AudioStreamBasicDescription)); 
     228     
     229    if (status != noErr) { 
     230        NSLog(@"kAudioUnitProperty_StreamFormat - error"); 
     231    } 
     232     
     233} 
     234 
     235 
     236OSStatus renderAudioUnitCallback(void*                       inRefCon, 
     237                                   AudioUnitRenderActionFlags* ioActionFlags, 
     238                                   const AudioTimeStamp*       inTimeStamp, 
     239                                   UInt32                      inBusNumber, 
     240                                   UInt32                      inNumberFrames, 
     241                                   AudioBufferList*            ioData) 
     242{ 
     243    AudioGenerator *generator = (__bridge AudioGenerator*)inRefCon; 
     244     
     245    Float32 *ctr_buffer = ioData->mBuffers[0].mData; 
     246    [generator writeCtrWaveToBuffer:ctr_buffer maxSize:inNumberFrames]; 
     247     
     248    Float32 *signal_buffer = ioData->mBuffers[1].mData; 
     249    [generator writeSignalWaveToBuffer:signal_buffer maxSize:inNumberFrames]; 
     250     
     251    return noErr; 
     252} 
     253 
     254 
     255- (void)writeCtrWaveToBuffer:(Float32*)buffer maxSize:(UInt32)frames 
     256{ 
     257     
     258    for (int i=0; i < frames; ++i) { 
     259         
     260        if (g_refreshCtrCode) { 
     261            ctrWaveReadIdx = 0; 
     262            idleWaveReadIdx = 0; 
     263            g_refreshCtrCode = NO; 
     264            break; 
     265        } 
     266         
     267        if (ctrWaveReadIdx <= ctrWaveDataLen && idleWaveReadIdx == 0) { 
     268            *buffer++ = ctrWave[ctrWaveReadIdx++]; 
     269        } 
     270        else if (ctrWaveReadIdx > ctrWaveDataLen && idleWaveReadIdx <= idleWaveLen) 
     271        { 
     272            *buffer++ = 0.0f; 
     273            idleWaveReadIdx++; 
     274        } 
     275        else if (ctrWaveReadIdx > ctrWaveDataLen && idleWaveReadIdx > idleWaveLen) 
     276        { 
     277            ctrWaveReadIdx = 0; 
     278            idleWaveReadIdx = 0; 
     279            *buffer++ = ctrWave[ctrWaveReadIdx++]; 
     280        } 
     281         
     282    } 
     283} 
     284 
     285- (void)writeSignalWaveToBuffer:(Float32*)buffer maxSize:(UInt32)frames 
     286{ 
     287    double phase_step = SIGNAL_WAVE_FREQUENCY * 2.0 * M_PI / SAMPLE_RATE_F; 
     288         
     289        for (int i = 0; i < frames; ++i){ 
     290                float wave = sin(m_signalPhaseCur); 
     291                *buffer++ = wave; 
     292        m_signalPhaseCur += phase_step; 
     293         
     294        if (m_signalPhaseCur > 2.0 * M_PI) { 
     295            m_signalPhaseCur -= 2.0 * M_PI; 
     296        } 
     297    } 
     298} 
     299 
     300 
     301 
     302#pragma mark - ---- Audio Generator func ---- 
     303 
     304 
    43305 
    44306- (void) prepareStaticArrays 
     
    59321     
    60322     
    61     longZeroLength = (int)floor((0.002 + 1 / sampleRate) * sampleRate); 
     323    longZeroLength = (int)floor((0.002 + 1 / SAMPLE_RATE_F) * SAMPLE_RATE_F); 
    62324    waveLongZero = malloc(longZeroLength); 
    63325     
    64326    [self generateWaveBit]; 
     327     
     328    [self generateCtrWaveHead]; 
     329    [self generateWaveBit_01]; 
     330     
     331    [self setupCtrWave]; 
     332} 
     333 
     334- (void)setupCtrWave 
     335{ 
     336    ctrWaveMaxLen = ctrWaveHeadLen + 
     337                27 * (waveBit_01_len[0] > waveBit_01_len[1] ? waveBit_01_len[0] : waveBit_01_len[1]) + 
     338                longHighLength; 
     339     
     340    idleWaveLen = (int)floor(IDLE_TIME_MS * 0.001f * SAMPLE_RATE_F); 
     341     
     342    ctrWave = malloc(sizeof(Float32) * ctrWaveMaxLen); 
     343     
     344    memcpy(ctrWave, ctrWaveHead, sizeof(Float32) * ctrWaveHeadLen); 
     345     
     346    ctrWaveReadIdx = 0; 
     347    idleWaveReadIdx = 0; 
     348} 
     349 
     350- (void)generateCtrWaveHead 
     351{ 
     352    int ctr_longH_len = [self arraySizeWithHalfPeriod:longHIGH - sampleTime * 2]; 
     353    int ctr_shortL_len = [self arraySizeWithHalfPeriod:shortLOW + sampleTime * 2]; 
     354     
     355    ctrWaveHeadLen = longLowLength + 2 * ctr_longH_len + 2 * ctr_shortL_len; 
     356    ctrWaveHead = malloc(sizeof(Float32) * ctrWaveHeadLen); 
     357     
     358    int idx = 0; 
     359     
     360    for (int i=0; i < longLowLength; ++i) { 
     361        ctrWaveHead[idx++] = waveLongLow[i]; 
     362    } 
     363     
     364    double increment = M_PI/((longHIGH - sampleTime * 2) * SAMPLE_RATE_F); 
     365    double angle = 0; 
     366     
     367    for (int i=0; i < ctr_longH_len; ++i) { 
     368        Float32 value = sinf(angle); 
     369        ctrWaveHead[idx + ctr_longH_len + ctr_shortL_len] = value; 
     370        ctrWaveHead[idx++] = value; 
     371        angle += increment; 
     372    } 
     373     
     374    memset(ctrWaveHead + idx, 0, sizeof(Float32) * ctr_shortL_len); 
     375    memset(ctrWaveHead + (idx + ctr_longH_len + ctr_shortL_len), 0, sizeof(Float32) * ctr_shortL_len); 
     376 
     377} 
     378 
     379- (void) generateWaveBit_01 
     380{ 
     381    waveBit_01_len[0] = shortHighLength + shortLowLength; 
     382    waveBit_01_len[1] = longHighLength + longLowLength; 
     383     
     384    waveBit_01[0] = malloc(sizeof(Float32) * waveBit_01_len[0]); 
     385    waveBit_01[1] = malloc(sizeof(Float32) * waveBit_01_len[1]); 
     386     
     387    int idx = 0; 
     388    for (int i=0; i < shortHighLength; ++i) { 
     389        waveBit_01[0][idx++] = waveShortHigh[i]; 
     390    } 
     391    for (int i=0; i < shortLowLength; ++i) { 
     392        waveBit_01[0][idx++] = waveShortLow[i]; 
     393    } 
     394     
     395    idx = 0; 
     396    for (int i=0; i < longHighLength; ++i) { 
     397        waveBit_01[1][idx++] = waveLongHigh[i]; 
     398    } 
     399    for (int i=0; i < longLowLength; ++i) { 
     400        waveBit_01[1][idx++] = waveLongLow[i]; 
     401    } 
     402     
    65403} 
    66404 
     
    85423 
    86424 
    87 - (void) stop 
    88 { 
    89     if (toneUnit != nil) { 
    90         AudioOutputUnitStop(toneUnit); 
    91         AudioUnitUninitialize(toneUnit); 
    92         AudioComponentInstanceDispose(toneUnit); 
    93         toneUnit = nil; 
    94     } 
    95 } 
    96  
    97 - (void) playWithThrottle: (int)t yaw: (int)y pitch: (int)p 
    98 { 
    99     self.yaw = y; 
    100     self.pitch = p; 
    101     self.throttle = t; 
    102      
    103     if (toneUnit == nil) { 
    104         [self createToneUnit]; 
    105          
    106         // Stop changing parameters on the unit 
    107         OSErr err = AudioUnitInitialize(toneUnit); 
    108          
    109         // Start playback 
    110         err = AudioOutputUnitStart(toneUnit); 
    111     } 
    112 } 
    113  
    114 OSStatus RenderTone( 
    115                     void *inRefCon, 
    116                     AudioUnitRenderActionFlags  *ioActionFlags, 
    117                     const AudioTimeStamp                *inTimeStamp, 
    118                     UInt32                                              inBusNumber, 
    119                     UInt32                                              inNumberFrames, 
    120                     AudioBufferList                     *ioData) 
    121  
    122 { 
    123      
    124          
    125 //      // This is a mono tone generator so we only need the first buffer 
    126 //      const int channel = 0; 
    127     
    128    // There are two channels to the audio control stream (left and right) 
    129    const int channel = 0; // Output to left channel 
    130 //   const int channel = 1; // Output to right channel 
    131  
    132     
    133     
    134         Float32 *buffer = (Float32 *)ioData->mBuffers[channel].mData; 
    135      
    136     AudioGenerator *generator = (__bridge AudioGenerator *)inRefCon; 
    137     [generator writeBytesToBuffer:buffer maxSize:inNumberFrames]; 
    138     return noErr; 
    139 } 
    140  
    141 /** 
    142  * All this code stolen from http://www.cocoawithlove.com/2010/10/ios-tone-generator-introduction-to.html 
    143  */ 
    144 - (void) createToneUnit 
    145 { 
    146     // Configure the search parameters to find the default playback output unit 
    147     // (called the kAudioUnitSubType_RemoteIO on iOS but 
    148     // kAudioUnitSubType_DefaultOutput on Mac OS X) 
    149     AudioComponentDescription defaultOutputDescription; 
    150     defaultOutputDescription.componentType = kAudioUnitType_Output; 
    151     defaultOutputDescription.componentSubType = kAudioUnitSubType_RemoteIO; 
    152     defaultOutputDescription.componentManufacturer = kAudioUnitManufacturer_Apple; 
    153     defaultOutputDescription.componentFlags = 0; 
    154     defaultOutputDescription.componentFlagsMask = 0; 
    155      
    156     // Get the default playback output unit 
    157     AudioComponent defaultOutput = AudioComponentFindNext(NULL, &defaultOutputDescription); 
    158     if (defaultOutput == NULL) { 
    159         NSLog(@"Can't find default output"); 
    160     } 
    161      
    162     // Create a new unit based on this that we'll use for output 
    163     OSErr err = AudioComponentInstanceNew(defaultOutput, &toneUnit); 
    164     if (toneUnit == NULL) { 
    165         NSLog(@"Error creating unit: %hd", err); 
    166     } 
    167      
    168     // Set our tone rendering function on the unit 
    169     AURenderCallbackStruct input; 
    170     input.inputProc = RenderTone; 
    171     input.inputProcRefCon = (__bridge void *)(self); 
    172     err = AudioUnitSetProperty(toneUnit, 
    173                                kAudioUnitProperty_SetRenderCallback, 
    174                                kAudioUnitScope_Input, 
    175                                0, 
    176                                &input, 
    177                                sizeof(input)); 
    178     if (err != noErr) { 
    179         NSLog(@"Error setting callback: %hd", err); 
    180     } 
    181      
    182     // Set the format to 32 bit, single channel, floating point, linear PCM 
    183     const int four_bytes_per_float = 4; 
    184     const int eight_bits_per_byte = 8; 
    185     AudioStreamBasicDescription streamFormat; 
    186     streamFormat.mSampleRate = sampleRate; 
    187     streamFormat.mFormatID = kAudioFormatLinearPCM; 
    188     streamFormat.mFormatFlags = 
    189     kAudioFormatFlagsNativeFloatPacked | kAudioFormatFlagIsNonInterleaved; 
    190     streamFormat.mBytesPerPacket = four_bytes_per_float; 
    191     streamFormat.mFramesPerPacket = 1; 
    192     streamFormat.mBytesPerFrame = four_bytes_per_float; 
    193     
    194    // There are two channels to the audio stream 
    195 //   streamFormat.mChannelsPerFrame = 1; 
    196    streamFormat.mChannelsPerFrame = 2; 
    197     
    198     streamFormat.mBitsPerChannel = four_bytes_per_float * eight_bits_per_byte; 
    199     err = AudioUnitSetProperty (toneUnit, 
    200                                 kAudioUnitProperty_StreamFormat, 
    201                                 kAudioUnitScope_Input, 
    202                                 0, 
    203                                 &streamFormat, 
    204                                 sizeof(AudioStreamBasicDescription)); 
    205     if (err != noErr) { 
    206         NSLog(@"Error setting stream format: %hd", err); 
    207     } 
    208 } 
    209425 
    210426// calculate the checksum for the generated code used to generate the WAV array 
     
    228444    int channel = 1; 
    229445    int code = throttle << 21; 
    230     code += 1048576; // code += 1 << 20 ; 
     446    code += 1 << 20; 
    231447    code += yaw << 12; 
    232     code += pitch << 4 ; 
     448    code += pitch << 4; 
    233449    code += ((channel >> 1) & 1) << 19; 
    234450    code += (channel & 1) << 11; 
     
    236452} 
    237453 
    238 - (void) writeBytesToBuffer:(Float32 *) buffer maxSize:(UInt32) frames 
     454- (void)updateCtrCode:(BOOL)refresh 
     455{ 
     456    int ctr_code = [self generateCode]; 
     457     
     458    //ctr_code = 0; 
     459     
     460    [self codeToWave:ctr_code]; 
     461     
     462    if (refresh) { 
     463        g_refreshCtrCode = YES; 
     464    } 
     465     
     466} 
     467 
     468- (void)codeToWave:(int)code 
     469{ 
     470    Float32 *pos = ctrWave + ctrWaveHeadLen; 
     471     
     472    for (int i=27; i >= 0 ; --i) { 
     473        int bit = (code >> i) & 1; 
     474        memcpy(pos, waveBit_01[bit], sizeof(Float32) * waveBit_01_len[bit]); 
     475        pos += waveBit_01_len[bit]; 
     476    } 
     477     
     478    memcpy(pos, waveLongHigh, sizeof(Float32) * longHighLength); 
     479    pos += longHighLength; 
     480     
     481    ctrWaveDataLen = pos - ctrWave; 
     482    int lost_len = ctrWaveMaxLen - ctrWaveDataLen; 
     483     
     484    memset(pos, 0, sizeof(Float32) * lost_len); 
     485} 
     486 
     487 
     488 
     489 
     490- (int) writeBytesToBuffer:(Float32 *) buffer maxSize:(UInt32) frames 
    239491{ 
    240492    MAX_BUFFER_SIZE = sizeof(buffer) * frames; 
     
    242494    [self writeWaveToBuffer:buffer        at:&position]; 
    243495    [self writeInitialWaveToBuffer:buffer at:&position]; 
     496     
     497    return position; 
    244498} 
    245499 
     
    306560- (void) writePauseInSamplesTo:(Float32 *) buffer at:(int *) position 
    307561{ 
    308     int length = (int)floor(0.010 * sampleRate); // length of pause to insert 
     562    int length = (int)floor(0.010 * SAMPLE_RATE_F); // length of pause to insert 
    309563    float arr[length]; 
    310564    [self writeArray:arr to:buffer length:length at:position]; 
     
    351605    
    352606    int sampleCount = [self arraySizeWithHalfPeriod:halfPeriod]; 
    353     double increment = M_PI/(halfPeriod * sampleRate); 
     607    double increment = M_PI/(halfPeriod * SAMPLE_RATE_F); 
    354608    double angle = upper ? 0 : M_PI; 
    355609         
     
    362616- (int) arraySizeWithHalfPeriod: (double)halfPeriod 
    363617{ 
    364     return (int)floor(halfPeriod * sampleRate); 
     618    return (int)floor(halfPeriod * SAMPLE_RATE_F); 
    365619} 
    366620 
     
    375629{ 
    376630    int sampleCount = [self arraySizeWithHalfPeriod:halfPeriod]; 
    377     float *array = malloc(sizeof(*array) * sampleCount); 
    378     double increment = M_PI/(halfPeriod * sampleRate); 
    379     double angle = upper ? 0 : M_PI; 
     631    Float32 *array = malloc(sizeof(Float32) * sampleCount); 
     632    double increment = M_PI/(halfPeriod * SAMPLE_RATE_F); 
     633    double angle = 0; 
    380634     
    381635    for (int i = 0; i < sampleCount; i++) { 
    382         array[i] = sinf(angle); 
    383         angle += increment; 
     636        if (upper) { 
     637            array[i] = sinf(angle); 
     638            angle += increment; 
     639        } 
     640        else { 
     641            array[i] = 0.0f; 
     642        } 
     643         
    384644    } 
    385645    return array; 
  • iOS/Orbit/Orbit/SignalConverter.h

    rad40faa rc9b9edd  
    1515#import "AudioGenerator.h" 
    1616 
     17#define USE_AUDIO_GENERATOR 1 
     18 
     19 
    1720@interface SignalConverter : NSObject <TGAccessoryDelegate> { 
     21     
     22#if USE_AUDIO_GENERATOR 
    1823   // Generate Signal 
    19 //   AudioGenerator *audioPlayer; 
     24   AudioGenerator *audioPlayer; 
     25#else 
    2026   // Play WAV 
    2127   AVAudioPlayer *audioPlayer; 
     28#endif 
    2229} 
    2330 
  • iOS/Orbit/Orbit/SignalConverter.m

    r3434fbc rc9b9edd  
    5151        AudioSessionInitialize(NULL, NULL, NULL, NULL); 
    5252        AudioSessionSetActive(YES); 
     53         
     54#if USE_AUDIO_GENERATOR 
     55        audioPlayer = [[AudioGenerator alloc] init]; 
     56#endif 
    5357    } 
    5458    return self; 
     
    230234    if (!running && !testing) { 
    231235        testing = YES; 
     236#if USE_AUDIO_GENERATOR 
    232237        // Generate Sound 
    233         //        [audioPlayer playWithThrottle:throttle yaw:yaw pitch:pitch]; 
    234          
     238        [audioPlayer playWithThrottle:throttle yaw:yaw pitch:pitch]; 
     239#else 
    235240        // Play WAV 
    236241        [self prepareAudio]; 
    237242        [audioPlayer play]; 
     243#endif 
    238244    } 
    239245} 
     
    277283    throttle = t; 
    278284    pitch = p; 
     285     
     286    [audioPlayer playWithThrottle:throttle yaw:yaw pitch:pitch]; 
    279287} 
    280288 
     
    286294    if ([self currentPowerLevel] > 0) { 
    287295         
     296#if USE_AUDIO_GENERATOR 
     297        // Generate Signal 
     298        [audioPlayer playWithThrottle:throttle yaw:yaw pitch:pitch]; 
     299#else 
    288300        audioPlayer.volume = 1.0; 
    289          
    290         // Generate Signal 
    291 //        [audioPlayer playWithThrottle:throttle yaw:yaw pitch:pitch]; 
    292          
     301 
    293302        // Play WAV 
    294303        [self prepareAudio]; 
    295304        [audioPlayer play]; 
     305#endif 
    296306         
    297307    } else { 
     
    333343- (void) prepareAudio 
    334344{ 
     345#if USE_AUDIO_GENERATOR 
     346#else 
    335347    NSURL *audioFilePath = [[NSBundle mainBundle] URLForResource:AUDIO_FILE_NAME withExtension:nil]; 
    336348     
     
    343355        [audioPlayer prepareToPlay]; 
    344356    } 
     357#endif 
    345358} 
    346359 
Note: See TracChangeset for help on using the changeset viewer.