In the last article of this series we started looking at iPhone audio playback. This time we are going to see how to actually play an audio file that our applicaiton has recorded.








The startPlayback method sets everything up for audio playback and starts the playback process.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

- (void)startPlayback
{
    playState.currentPacket = 0;
 
    [self setupAudioFormat:&playState.dataFormat];
 
    OSStatus status;
    status = AudioFileOpenURL(fileURL, fsRdPerm, kAudioFileAIFFType, &playState.audioFile);
    if(status == 0)
    {
        status = AudioQueueNewOutput(
                &playState.dataFormat,
                AudioOutputCallback,
                &playState,
                CFRunLoopGetCurrent(),
                kCFRunLoopCommonModes,
                0,
                &playState.queue);
 
        if(status == 0)
        {
            playState.playing = true;
            for(int i = 0; i < NUM_BUFFERS && playState.playing; i++)
            {
                if(playState.playing)
                {
                    AudioQueueAllocateBuffer(playState.queue, 16000, &playState.buffers[i]);
                    AudioOutputCallback(&playState, playState.queue, playState.buffers[i]);
                }
            }
 
            if(playState.playing)
            {
                status = AudioQueueStart(playState.queue, NULL);
                if(status == 0)
                {
                    labelStatus.text = @"Playing";
                }
            }
        }        
    }
 
    if(status != 0)
    {
        labelStatus.text = @"Play failed";
    }
}

We set up for playing audio by setting the currentPacket variable of the PlayState struct to 0 and using the setupAudioFormat method to initialize the dataFormat. Next we use the AudioFileOpenURL function to open the audio file we are playing. In the case of this example we are always playing and recording the same file.

If the file is opened successfully we call the AudioQueueNewOutput function to open a new audio output queue.

AudioQueueNewOuput arguments:

1. A pointer to the dataFormat variable of our PlayState struct.
2. The audio callback function that will be described later in the article.
3. A pointer to our PlayState struct.
4. The CFRunLoopGetCurrent function causes the callback to be called from the main application thread.
5. The run loop mode to use.
6. No flags are set for our call.
7. A pointer to our audio queue that will be initialized by this call.

Upon successfully opening the output queue we allocate each of the 3 audio output buffers we will use to play audio and we pass each of them to our output callback function. The output callback function will populate the buffers and enqueue them for playback.

Once the three audio buffers are loaded with audio data to be played we call the AudioQueueStart function to start the playback process. As each buffer is played the AudioOutputCallback function will be called with the buffer.

The stopPlayback method stops audio playback and frees up any resources allocated for the playback process.

1
2
3
4
5
6
7
8
9
10
11
12

- (void)stopPlayback
{
    playState.playing = false;
 
    for(int i = 0; i < NUM_BUFFERS; i++)
    {
        AudioQueueFreeBuffer(playState.queue, playState.buffers[i]);
    }
 
    AudioQueueDispose(playState.queue, true);
    AudioFileClose(playState.audioFile);
}

The AudioOutputCallback function is called for each audio buffer that has been played. This function is responsible for loading and queuing additional audio buffers for playback. It will also stop the playback process when the complete audio file has been played.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

void AudioOutputCallback(
        void* inUserData,
        AudioQueueRef outAQ,
        AudioQueueBufferRef outBuffer)
{
    PlayState* playState = (PlayState*)inUserData;	
    if(!playState->playing)
    {
        printf("Not playing, returning\n");
        return;
    }
 
    printf("Queuing buffer %d for playback\n", playState->currentPacket);
 
    AudioStreamPacketDescription* packetDescs;
 
    UInt32 bytesRead;
    UInt32 numPackets = 8000;
    OSStatus status;
    status = AudioFileReadPackets(
            playState->audioFile,
            false,
            &bytesRead,
            packetDescs,
            playState->currentPacket,
            &numPackets,
            outBuffer->mAudioData);
 
    if(numPackets)
    {
        outBuffer->mAudioDataByteSize = bytesRead;
        status = AudioQueueEnqueueBuffer(
                playState->queue,
                outBuffer,
                0,
                packetDescs);
 
        playState->currentPacket += numPackets;
    }
    else
    {
        if(playState->playing)
        {
            AudioQueueStop(playState->queue, false);
            AudioFileClose(playState->audioFile);
            playState->playing = false;
        }
    }
 
}

Our PlayState structure is passed into the callback as the inUserData void* parameter. If the playing flag of our struct is set to false we simply return from the callback. The outBuffer parameter is the buffer that has just finished playing.

We use the AudioFileReadPackets function to read the next hunk of data into the just completed outBuffer buffer. We only work with three audio buffers at any given time just like when we are recording.

AudioFileReadPackets arguments:

1. The audio file we opened.
2. Flag specifying whether or not to cache data.
3. The number of bytes read from the file.
4. A list of packet descriptions.
5. The number of audio packets read from the file.
6. The audio buffer’s data variable.

With the audio data read into our buffer we now set the mAudioDataByteSize variable of our buffer to equal the number of bytes read from the file. Next we enqueue the packet to be played.

If we fail to read any packets from the file we stop the play process with the AudioQueueStop function and close the file. Passing false as the second parameter to AudioQueueStop will cause the remaining buffers that are enqueued to finish playing. If we passed true then playing would stop immediately.

That’s it for the baics of audio recording and play back using the iPhone SDK. I am posting the source files for you reference.

NOTE: On beta 3 of the SDK the AudioQueueStart call is failing when trying to start recording. This was working fine in beta 2. I’ll post an update when I’ve found a solution to this issue. If anyone finds a solution please post a comment.

I’m not sure if I will continue this series of articles into more advanced audio topics or if I’ll start a new “Advanced” series of articles.

Source Files:
main.m - AudioRecorderAppDelegate.h - AudioRecorderAppDelegate.m