enregistrer les sons joués par mon application iPhone avec des unités audio

Question

J'ai lu beaucoup de choses intéressantes aujourd'hui à propos de Unités iOS et audio et j'ai trouvé beaucoup de ressources utiles (y compris le SO).

Tout d'abord Mais je ne comprends pas très bien : est-il vraiment nécessaire de créer un graphique audio con unité de mélange pour enregistrer des sons joués par une application ?

Ou suffit-il de jouer des sons avec ObjectAL (ou plus simplement des appels à AVAudioPlayer) et créer un seul fichier unité io à distance adressée au bon bus avec un rappel d'enregistrement ?

Deuxième , une question qui relève davantage de la programmation ! Comme je ne suis pas encore à l'aise avec Unités audio concepts, j'essaie d'adapter les projet apple Mixer Host avec la possibilité d'enregistrer le mélange obtenu. Évidemment, j'essaie de le faire avec le Michael Tyson RemoteIO post .

Et j'obtiens un EXC_BAD_ACCESS sur ma fonction callback :

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

    AudioBufferList *bufferList; // <- Fill this up with buffers (you will want to malloc it, as it's a dynamic-length list)

    EffectState *effectState = (EffectState *)inRefCon;
    AudioUnit rioUnit = effectState->rioUnit;

    OSStatus status;

    // BELOW I GET THE ERROR
    status = AudioUnitRender(rioUnit,      
                             ioActionFlags, 
                             inTimeStamp, 
                             inBusNumber, 
                             inNumberFrames, 
                             bufferList);

    if (noErr != status) { NSLog(@"AudioUnitRender error"); return noErr;}

    // Now, we have the samples we just read sitting in buffers in bufferList
    //ExtAudioFileWriteAsync(effectState->audioFileRef, inNumberFrames, bufferList);

    return noErr;
}

Avant d'utiliser la fonction de rappel que j'ai fait dans MixerHostAudio.h

typedef struct {
    AudioUnit rioUnit;
    ExtAudioFileRef audioFileRef;
} EffectState;

Et créer dans l'interface :

AudioUnit                       iOUnit;
EffectState effectState;
AudioStreamBasicDescription     iOStreamFormat;
...
@property                       AudioUnit           iOUnit;
@property (readwrite)           AudioStreamBasicDescription iOStreamFormat;

Ensuite, dans le fichier de mise en œuvre MixerHostAudio.h :

#define kOutputBus 0
#define kInputBus 1
...
@synthesize iOUnit;                    // the Remote IO unit
...
result =    AUGraphNodeInfo (
                             processingGraph,
                             iONode,
                             NULL,
                             &iOUnit
                             );

if (noErr != result) {[self printErrorMessage: @"AUGraphNodeInfo" withStatus: result]; return;}

// Enable IO for recording
UInt32 flag = 1;
result = AudioUnitSetProperty(iOUnit, 
                              kAudioOutputUnitProperty_EnableIO, 
                              kAudioUnitScope_Input, 
                              kInputBus,
                              &flag, 
                              sizeof(flag));

if (noErr != result) {[self printErrorMessage: @"AudioUnitSetProperty" withStatus: result]; return;}
// Describe format
iOStreamFormat.mSampleRate          = 44100.00;
iOStreamFormat.mFormatID            = kAudioFormatLinearPCM;
iOStreamFormat.mFormatFlags     = kAudioFormatFlagIsSignedInteger | kAudioFormatFlagIsPacked;
iOStreamFormat.mFramesPerPacket = 1;
iOStreamFormat.mChannelsPerFrame    = 1;
iOStreamFormat.mBitsPerChannel      = 16;
iOStreamFormat.mBytesPerPacket      = 2;
iOStreamFormat.mBytesPerFrame       = 2;

// Apply format
result = AudioUnitSetProperty(iOUnit, 
                              kAudioUnitProperty_StreamFormat, 
                              kAudioUnitScope_Output, 
                              kInputBus, 
                              &iOStreamFormat, 
                              sizeof(iOStreamFormat));

if (noErr != result) {[self printErrorMessage: @"AudioUnitSetProperty" withStatus: result]; return;}

result = AudioUnitSetProperty(iOUnit, 
                              kAudioUnitProperty_StreamFormat, 
                              kAudioUnitScope_Input, 
                              kOutputBus, 
                              &iOStreamFormat, 
                              sizeof(iOStreamFormat));

if (noErr != result) {[self printErrorMessage: @"AudioUnitSetProperty" withStatus: result]; return;}

effectState.rioUnit = iOUnit;

// Set input callback ----> RECORDING
AURenderCallbackStruct callbackStruct;
callbackStruct.inputProc = recordingCallback;
callbackStruct.inputProcRefCon = self;
result = AudioUnitSetProperty(iOUnit, 
                              kAudioOutputUnitProperty_SetInputCallback, 
                              kAudioUnitScope_Global, 
                              kInputBus, 
                              &callbackStruct, 
                              sizeof(callbackStruct));

if (noErr != result) {[self printErrorMessage: @"AudioUnitSetProperty" withStatus: result]; return;}

Mais je ne sais pas ce qui ne va pas et je ne sais pas comment digger. Note : Le État de l'effet La structure est présente parce que j'essaie aussi d'intégrer les Projet BioAudio possibilité d'écrire des fichiers à partir de tampons.

Et troisièmement Je me demande s'il n'y a pas quelque chose de plus facile à faire pour enregistrer les sons joués par mon application iPhone (c'est à dire sans microphone) ?

Answer 1

Trouvé par moi-même. J'ai oublié d'enchaîner comme ça :

callbackStruct.inputProcRefCon = &effectState;

Il s'agit de la partie code. Maintenant, j'ai à nouveau des problèmes conceptuels ...