我可以使用音频文件服务+音频队列服务来传输和播放m4a文件。由于文件类型，音频队列无法使用该文件的比特率信息。
下载完所有音频数据包后，我将它们提供给播放器。
当我选择大约32768或16384的缓冲区大小时，因为较少调用回调并且每个缓冲区大小很大，它似乎几乎以常规速度播放。问题有时我也要播放小文件但是当我选择小型缓冲区大小-512或1024或2048到8192时 - 音频播放速度非常快且偶尔会出现故障。
我知道在c回调中调用objective-c函数不是一个好主意，但为了可读性和容易性，我这样做。无论我认为这不是问题。
// allocate the buffers and prime the queue with some data before starting
AudioQueueBufferRef buffers[XMNumberPlaybackBuffers];
int i;
for (i = 0; i < XMNumberPlaybackBuffers; ++i)
{
err=AudioQueueAllocateBuffer(queue, XMAQDefaultBufSize, &buffers[i]);
if (err) {
[self failWithErrorCode:err customError:AP_AUDIO_QUEUE_BUFFER_ALLOCATION_FAILED];
}
@synchronized(self)
{
state=AP_WAITING_FOR_QUEUE_TO_START;
}
// manually invoke callback to fill buffers with data
MyAQOutputCallBack((__bridge void *)(self), queue, buffers[i]);
}
我还从字典的可变阵列中获取音频数据包......
#define XMNumberPlaybackBuffers 4
#define XMAQDefaultBufSize 8192
#pragma mark playback callback function
static void MyAQOutputCallBack(void *inUserData, AudioQueueRef inAQ, AudioQueueBufferRef inCompleteAQBuffer)
{
// this is called by the audio queue when it has finished decoding our data.
// The buffer is now free to be reused.
NSLog(@"MyAQOutputCallBack..");
//printf("MyAQOutputCallBack...\n");
XMAudioPlayer* player = (__bridge XMAudioPlayer *)inUserData;
[player handleBufferCompleteForQueue:inAQ buffer:inCompleteAQBuffer];
//printf("##################\n");
}
- (void)handleBufferCompleteForQueue:(AudioQueueRef)inAQ
buffer:(AudioQueueBufferRef)inBuffer
{
//NSLog(@"######################\n");
AudioTimeStamp queueTime;
Boolean discontinuity;
err = AudioQueueGetCurrentTime(queue, NULL, &queueTime, &discontinuity);
printf("queueTime.mSampleTime %.2f\n",queueTime.mSampleTime/dataFormat.mSampleRate);
AudioStreamPacketDescription packetDescs[XMAQMaxPacketDescs]; // packet descriptions for enqueuing audio
BOOL isBufferFilled=NO;
size_t bytesFilled=0; // how many bytes have been filled
size_t packetsFilled=0; // how many packets have been filled
size_t bufSpaceRemaining;
while (isBufferFilled==NO && isEOF==NO) {
if (currentlyReadingBufferIndex<[sharedCache.audioCache count]) {
//loop thru untill buffer is enqued
if (sharedCache.audioCache) {
NSMutableDictionary *myDict= [[NSMutableDictionary alloc] init];
myDict=[sharedCache.audioCache objectAtIndex:currentlyReadingBufferIndex];
//why I cant use this info?
//UInt32 inNumberBytes =[[myDict objectForKey:@"inNumberBytes"] intValue];
UInt32 inNumberPackets =[[myDict objectForKey:@"inNumberPackets"] intValue];
NSData *convert=[myDict objectForKey:@"inInputData"];
const void *inInputData=(const char *)[convert bytes];
//AudioStreamPacketDescription *inPacketDescriptions;
AudioStreamPacketDescription *inPacketDescriptions= malloc(sizeof(AudioStreamPacketDescription));
NSNumber *mStartOffset = [myDict objectForKey:@"mStartOffset"];
NSNumber *mDataByteSize = [myDict objectForKey:@"mDataByteSize"];
NSNumber *mVariableFramesInPacket = [myDict objectForKey:@"mVariableFramesInPacket"];
inPacketDescriptions->mVariableFramesInPacket=[mVariableFramesInPacket intValue];
inPacketDescriptions->mStartOffset=[mStartOffset intValue];
inPacketDescriptions->mDataByteSize=[mDataByteSize intValue];
for (int i = 0; i < inNumberPackets; ++i)
{
SInt64 packetOffset = [mStartOffset intValue];
SInt64 packetSize = [mDataByteSize intValue];
//printf("packetOffset %lli\n",packetOffset);
//printf("packetSize %lli\n",packetSize);
currentlyReadingBufferIndex++;
if (packetSize > packetBufferSize)
{
//[self failWithErrorCode:AS_AUDIO_BUFFER_TOO_SMALL];
}
bufSpaceRemaining = packetBufferSize - bytesFilled;
//printf("bufSpaceRemaining %zu\n",bufSpaceRemaining);
// if the space remaining in the buffer is not enough for this packet, then enqueue the buffer.
if (bufSpaceRemaining < packetSize)
{
inBuffer->mAudioDataByteSize = (UInt32)bytesFilled;
err=AudioQueueEnqueueBuffer(inAQ,inBuffer,(UInt32)packetsFilled,packetDescs);
if (err) {
[self failWithErrorCode:err customError:AP_AUDIO_QUEUE_ENQUEUE_FAILED];
}
isBufferFilled=YES;
[self incrementBufferUsedCount];
return;
}
@synchronized(self)
{
//
// If there was some kind of issue with enqueueBuffer and we didn't
// make space for the new audio data then back out
//
if (bytesFilled + packetSize > packetBufferSize)
{
return;
}
// copy data to the audio queue buffer
//error -66686 refers to
//kAudioQueueErr_BufferEmpty = -66686
//memcpy((char*)inBuffer->mAudioData + bytesFilled, (const char*)inInputData + packetOffset, packetSize);
memcpy(inBuffer->mAudioData + bytesFilled, (const char*)inInputData + packetOffset, packetSize);
// fill out packet description
packetDescs[packetsFilled] = inPacketDescriptions[0];
packetDescs[packetsFilled].mStartOffset = bytesFilled;
bytesFilled += packetSize;
packetsFilled += 1;
free(inPacketDescriptions);
}
// if that was the last free packet description, then enqueue the buffer.
// size_t packetsDescsRemaining = kAQMaxPacketDescs - packetsFilled;
// if (packetsDescsRemaining == 0) {
//
// }
if (sharedCache.numberOfToTalPackets>0)
{
if (currentlyReadingBufferIndex==[sharedCache.audioCache count]-1) {
if (loop==NO) {
inBuffer->mAudioDataByteSize = (UInt32)bytesFilled;
lastEnqueudBufferSize=bytesFilled;
lastbufferPacketCount=(int)packetsFilled;
err=AudioQueueEnqueueBuffer(inAQ,inBuffer,(UInt32)packetsFilled,packetDescs);
if (err) {
[self failWithErrorCode:err customError:AP_AUDIO_QUEUE_ENQUEUE_FAILED];
}
printf("if that was the last free packet description, then enqueue the buffer\n");
//go to the next item on keepbuffer array
isBufferFilled=YES;
[self incrementBufferUsedCount];
return;
}
else
{
//if loop is yes return to first packet pointer and fill the rest of the buffer before enqueing it
//set the currently reading to zero
//check the space in buffer
//if space is avaialbele create a while loop till it is filled
//then enqueu the buffer
currentlyReadingBufferIndex=0;
}
}
}
}
}
}
}
}
编辑：
对于将来访问此问题的任何人，事实证明我的确切问题是AudioStreamPacketDescription packetDescs[XMAQMaxPacketDescs];所以XMAQMaxPacketDescs这里是512，当我选择更大的缓冲区大小时我为每个缓冲区排列了更接近数字的512个数据包所以它是以正常速度打球
然而，对于像1024这样的小缓冲区大小，这总共只有2-3个数据包，因此508个数据包的剩余部分为0，并且播放器正在尝试播放所有512个数据包的描述，这就是为什么它太快了。
我通过计算放入缓冲区的数据包总数来解决问题然后我创建了一个动态AudioStreamPacketDescription描述数组..
AudioStreamPacketDescription * tempDesc = (AudioStreamPacketDescription *)(malloc(packetsFilledDesc * sizeof(AudioStreamPacketDescription)));
memcpy(tempDesc,packetDescs, packetsFilledDesc*sizeof(AudioStreamPacketDescription));
err = AudioQueueEnqueueBuffer(inAQ,inBuffer,packetsFilledDesc,tempDesc);
if (err) {
[self failWithErrorCode:err customError:AP_AUDIO_QUEUE_ENQUEUE_FAILED];
}
然而，我接受并获得了100分以下的DAVE答案，很快我意识到我的问题不同了......
答案 0 :(得分：1)
当您为可变比特率分配队列时，不需要使用XMAQDefaultBufSize，对于可变比特率，您需要计算数据包大小。我从this教程中提取了一个方法来展示它是如何完成的。
void DeriveBufferSize (AudioQueueRef audioQueue, AudioStreamBasicDescription ASBDescription, Float64 seconds, UInt32 *outBufferSize)
{
static const int maxBufferSize = 0x50000; // punting with 50k
int maxPacketSize = ASBDescription.mBytesPerPacket;
if (maxPacketSize == 0)
{
UInt32 maxVBRPacketSize = sizeof(maxPacketSize);
AudioQueueGetProperty(audioQueue, kAudioConverterPropertyMaximumOutputPacketSize, &maxPacketSize, &maxVBRPacketSize);
}
Float64 numBytesForTime = ASBDescription.mSampleRate * maxPacketSize * seconds;
*outBufferSize = (UInt32)((numBytesForTime < maxBufferSize) ? numBytesForTime : maxBufferSize);
}
你可以这样使用它。
Float64 bufferDurSeconds = 0.54321;
AudioStreamBasicDescription myAsbd = self.format; // or something
UInt32 bufferByteSize;
DeriveBufferSize(recordState.queue, myAsbd, bufferDurSeconds, &bufferByteSize);
AudioQueueAllocateBuffer(queue, bufferByteSize, &buffers[i]);
使用kAudioConverterPropertyMaximumOutputPacketSize，可以计算出可以安全用于不可预测的可变比特率文件的最小缓冲区大小。如果您的文件太小，您只需要确定哪些样本填充了编解码器。