<AudioToolbox/AudioFile.h>

/*!

    @struct     AudioFilePacketTableInfo

    @abstract   This contains information about the number of valid frames in a file and where they begin and

                end.

    @discussion Some data formats may have packets whose contents are not completely valid, but represent

                priming or remainder frames that are not meant to be played. For example a file with 100

                packets of AAC is nominally 1024 * 100 = 102400 frames of data. However the first 2112 frames

                of that may be priming frames and there may be some number of remainder frames added to pad

                out to a full packet of 1024 frames. The priming and remainder frames should be discarded. The

                total number of packets in the file times the frames per packet (or counting each packet's

                frames individually for a variable frames per packet format) minus mPrimingFrames, minus

                mRemainderFrames, should equal mNumberValidFrames.

    @field      mNumberValidFrames the number of valid frames in the file.

    @field      mPrimingFrames the number of invalid frames at the beginning of the file.

    @field      mRemainderFrames the number of invalid frames at the end of the file.

*/

struct AudioFilePacketTableInfo

{

        SInt64  mNumberValidFrames;

        SInt32  mPrimingFrames;

        SInt32  mRemainderFrames;

};

typedef struct AudioFilePacketTableInfo AudioFilePacketTableInfo;

AudioFilePacketTableInfo thePacketTableInfo;

UInt32 size = sizeof(thePacketTableInfo);

AudioFileGetProperty(myAudioFileID, kAudioFilePropertyPacketTableInfo, &size, &thePacketTableInfo);

myAudioLooper->mPrimingFrames = thePacketTableInfo.mPrimingFrames;

myAudioLooper->mRemainderFrames = thePacketTableInfo.mRemainderFrames;

UInt32 size = sizeof(myAudioLooper->mAudioFilePacketCount);

AudioFileGetProperty(myAudioFileID, kAudioFileStreamProperty_AudioDataPacketCount,

                                    &size, &myAudioLooper->mAudioFilePacketCount);

AudioQueueEnqueueBufferWithParameters(AudioQueueRef                        inAQ,

                                      AudioQueueBufferRef                  inBuffer,

                                      UInt32                               inNumPacketDescs,

                                      const AudioStreamPacketDescription * inPacketDescs,

                                      UInt32                               inTrimFramesAtStart,

                                      UInt32                               inTrimFramesAtEnd,

                                      UInt32                               inNumParamValues,

                                      const AudioQueueParameterEvent *     inParamValues,

                                      const AudioTimeStamp *               inStartTime,

                                      AudioTimeStamp *                     outActualStartTime)

Assigns a buffer to an audio queue for playback, providing parameters and start time information.

You can exert some control of the buffer queue by using this function. You can assign audio queue settings that are in effect carried by an audio queue buffer as you enqueue it. Hence, these changes only take effect when an audio queue buffer begins playing.

This function queues a buffer for playback only, not for recording. Audio queues for recording have no parameters, do not support variable-bit-rate (VBR) formats (which might require trimming), and have a different way to handle timing. When queued for playback, the buffer must contain the audio data to be played back. See AudioQueueEnqueueBuffer for details on queuing a buffer for recording.

Parameters:

inAQ - The audio queue associated with the buffer.

inBuffer - The buffer to be played from.

inNumPacketDescs - The number of packet descriptions pointed to by the inPacketDescs parameter. Required only

                   for variable-bit-rate (VBR) audio formats. Pass 0 if no packet descriptions are required.

inPacketDescs - A pointer to an array of audio stream packet descriptions. Required only for VBR audio

                formats. Pass NULL if no packet descriptions are required.

inTrimFramesAtStart - The number of priming frames to skip at the start of the buffer.

inTrimFramesAtEnd - The number of frames to skip at the end of the buffer.

inNumParamValues - The number of parameter values pointed to by the inParamValues parameter.

inParamValues - An array of parameter values(In Mac OS X v10.5, there is only one parameter,

                kAudioQueueParam_Volume.) These values are set before buffer playback and cannot be

                changed while the buffer is playing. How accurately changes in parameters can be

                scheduled depends on the size of the buffer. If there are no parameters to set

                (inNumParamValues = 0), pass NULL.

inStartTime - A pointer to a structure containing the desired start time for playing the buffer. If

               you specify the time using the mSampleTime field of the AudioTimeStamp structure, the

               sample time is relative to the time the queue started. If you pass NULL for the start

               time, the buffer starts immediately after the previously queued buffer, or as soon as

               possible if no buffers are queued ahead of it. Buffers are played in the order they are

               queued. If multiple buffers are queued, their times must be in ascending order or NULL;

               otherwise, an error occurs. The start time indicates when the actual audio data in the

               buffer is to be played (that is, the trim frames are not counted).

outActualStartTime - On return, points to an AudioTimeStamp structure indicating when the buffer will

                     actually play.

void AQLooper::AQBufferCallback(void *inUserData, AudioQueueRef inAQ, AudioQueueBufferRef inCompleteAQBuffer)

{

    AQLooper *THIS = (AQLooper *)inUserData;

    if (THIS->mIsDone) return;

    UInt32 numBytes;

    UInt32 nPackets = THIS->GetNumPacketsToRead(); // generally enough for a half second of audio based on the

                                                   // format -- see CalculateBytesForTime() from aqplay.cpp

    OSStatus result = AudioFileReadPackets(THIS->GetAudioFileID(),

                                           false,

                                           &numBytes,

                                           inCompleteAQBuffer->mPacketDescriptions,

                                           THIS->GetCurrentPacket(),

                                           &nPackets,

                                           inCompleteAQBuffer->mAudioData);

    if (result) printf("AudioFileReadPackets failed: %d", result);

    if (nPackets > 0) {

        UInt32 trimFramesAtStart = 0;

        UInt32 trimFramesAtEnd = 0;

        inCompleteAQBuffer->mAudioDataByteSize = numBytes;

        inCompleteAQBuffer->mPacketDescriptionCount = nPackets;

        if (THIS->mCurrentPacket == 0) {

            // at the beginning -- need to trim priming frames

            trimFramesAtStart = THIS->mPrimingFrames;

        }

        THIS->mCurrentPacket = (THIS->GetCurrentPacket() + nPackets);

        if (THIS->mCurrentPacket == THIS->mAudioFilePacketCount) {

            // at the end -- need to trim remainder frames

            inTrimFramesAtEnd = THIS->mRemainderFrames;

            // reset read from the beginning again

            THIS->mCurrentPacket = 0;

        }

        result = AudioQueueEnqueueBufferWithParameters(inAQ,

                                                       inCompleteAQBuffer,

                                                       0,

                                                       NULL,

                                                       trimFramesAtStart,

                                                       trimFramesAtEnd,

                                                       0, NULL, NULL, NULL);

        if (result) printf("AudioQueueEnqueueBufferWithParameters failed: %d", result);

    }

}