Ios 无法使用AudioFileStreamOpen'；中的AudioConverterFillComplexBuffer将mp3转换为PCM；s AudioFileStream_包存储过程回调

我在

audiofilestreampen

期间设置了

AudioFileStream\u PacketsProc

回调，该回调使用

AudioConverterFillComplexBuffer

将音频包转换为PCM。我遇到的问题是，在调用

AudioConverterFillComplexBuffer

后，我得到了一个-50 OSStatus（paramErr）。下面是

AudioConverterFillComplexBuffer

中使用的参数片段，以及这些参数是如何制作的：

        audioConverterRef = AudioConverterRef()

        // AudioConvertInfo is a struct that contains information
        // for the converter regarding the number of packets and 
        // which audiobuffer is being allocated
        convertInfo? = AudioConvertInfo(done: false, numberOfPackets: numberPackets, audioBuffer: buffer,
            packetDescriptions: packetDescriptions) 

        var framesToDecode: UInt32 = pcmBufferTotalFrameCount! - end

        var localPcmAudioBuffer = AudioBuffer()
        localPcmAudioBuffer.mData = pcmAudioBuffer!.mData.advancedBy(Int(end * pcmBufferFrameSizeInBytes!))

        var localPcmBufferList = AudioBufferList(mNumberBuffers: 1, mBuffers: AudioBuffer(mNumberChannels: 0, mDataByteSize: 0, mData: nil))
        localPcmAudioBuffer = localPcmBufferList.mBuffers
        localPcmAudioBuffer.mData = pcmAudioBuffer!.mData.advancedBy(Int(end * pcmBufferFrameSizeInBytes!))
        localPcmAudioBuffer.mDataByteSize = framesToDecode * pcmBufferFrameSizeInBytes!;
        localPcmAudioBuffer.mNumberChannels = pcmAudioBuffer!.mNumberChannels

        var localPcmBufferList = AudioBufferList(mNumberBuffers: 1, mBuffers: AudioBuffer(mNumberChannels: 0, mDataByteSize: 0, mData: nil))
        localPcmAudioBuffer = localPcmBufferList.mBuffers

        AudioConverterFillComplexBuffer(audioConverterRef, AudioConverter_Callback, &convertInfo, &framesToDecode, &localPcmBufferList, nil)

什么可能导致参数错误

以下是回调的完整方法（如果需要）：

func handleAudioPackets(inputData: UnsafePointer<Void>, numberBytes: UInt32, numberPackets: UInt32, packetDescriptions: UnsafeMutablePointer<AudioStreamPacketDescription>) {
        if currentlyReadingEntry == nil {
            print("currentlyReadingEntry = nil")
            return
        }
        if currentlyReadingEntry.parsedHeader == false {
            print("currentlyReadingEntry.parsedHeader == false")
            return
        }

        if disposedWasRequested == true {
            print("disposedWasRequested == true")
            return
        }

        guard let audioConverterRef = audioConverterRef else {
            return
        }

        if seekToTimeWasRequested == true && currentlyReadingEntry.calculatedBitRate() > 0.0 {
            wakeupPlaybackThread()
            print("seekToTimeWasRequested == true && currentlyReadingEntry.calculatedBitRate() > 0.0")
            return
        }

        discontinuous = false

        var buffer = AudioBuffer()
        buffer.mNumberChannels = audioConverterAudioStreamBasicDescription.mChannelsPerFrame
        buffer.mDataByteSize = numberBytes
        buffer.mData = UnsafeMutablePointer<Void>(inputData)


        convertInfo? = AudioConvertInfo(done: false, numberOfPackets: numberPackets, audioBuffer: buffer,
            packetDescriptions: packetDescriptions)


        if packetDescriptions != nil && currentlyReadingEntry.processedPacketsCount < maxCompressedBacketsForBitrateCalculation {
            let count: Int = min(Int(numberPackets), Int(maxCompressedBacketsForBitrateCalculation - currentlyReadingEntry.processedPacketsCount!))
            for var i = 0;i < count;++i{
                let packetSize: Int32 = Int32(packetDescriptions[i].mDataByteSize)
                OSAtomicAdd32(packetSize, &currentlyReadingEntry.processedPacketsSizeTotal!)
                OSAtomicIncrement32(&currentlyReadingEntry.processedPacketsCount!)
            }
        }
        while true {
            OSSpinLockLock(&pcmBufferSpinLock)
            var used: UInt32 = pcmBufferUsedFrameCount!
            var start: UInt32 = pcmBufferFrameStartIndex!
            var end = (pcmBufferFrameStartIndex! + pcmBufferUsedFrameCount!) % pcmBufferTotalFrameCount!
            var framesLeftInsideBuffer = pcmBufferTotalFrameCount! - used
            OSSpinLockUnlock(&pcmBufferSpinLock)

            if framesLeftInsideBuffer == 0 {
                pthread_mutex_lock(&playerMutex)
                while true {
                    OSSpinLockLock(&pcmBufferSpinLock)
                    used = pcmBufferUsedFrameCount!
                    start = pcmBufferFrameStartIndex!
                    end = (pcmBufferFrameStartIndex! + pcmBufferUsedFrameCount!) % pcmBufferTotalFrameCount!
                    framesLeftInsideBuffer = pcmBufferTotalFrameCount! - used
                    OSSpinLockUnlock(&pcmBufferSpinLock)

                    if framesLeftInsideBuffer > 0 {
                        break
                    }

                    if (disposedWasRequested == true
                        || internalState == SSPlayerInternalState.Disposed) {
                        pthread_mutex_unlock(&playerMutex)
                        return
                    }

                    if (seekToTimeWasRequested == true && currentlyPlayingEntry.calculatedBitRate() > 0.0)
                    {
                        pthread_mutex_unlock(&playerMutex)
                        wakeupPlaybackThread()
                        return;
                    }

                    waiting = true
                    pthread_cond_wait(&playerThreadReadyCondition, &playerMutex)
                    waiting = false
                }
                pthread_mutex_unlock(&playerMutex)
            }
            var localPcmAudioBuffer = AudioBuffer()
            var localPcmBufferList = AudioBufferList(mNumberBuffers: 1, mBuffers: AudioBuffer(mNumberChannels: 0, mDataByteSize: 0, mData: nil))
            localPcmAudioBuffer = localPcmBufferList.mBuffers

            if end >= start {
                var framesAdded: UInt32 = 0
                var framesToDecode: UInt32 = pcmBufferTotalFrameCount! - end
                localPcmAudioBuffer.mData = pcmAudioBuffer!.mData.advancedBy(Int(end * pcmBufferFrameSizeInBytes!))
                localPcmAudioBuffer.mDataByteSize = framesToDecode * pcmBufferFrameSizeInBytes!;
                localPcmAudioBuffer.mNumberChannels = pcmAudioBuffer!.mNumberChannels

                AudioConverterFillComplexBuffer(audioConverterRef, AudioConverter_Callback, &convertInfo, &framesToDecode, &localPcmBufferList, nil)

                framesAdded = framesToDecode

                if status == 100 {
                    OSSpinLockLock(&pcmBufferSpinLock)
                    let newCount = pcmBufferUsedFrameCount! + framesAdded
                    pcmBufferUsedFrameCount = newCount
                    OSSpinLockUnlock(&pcmBufferSpinLock);

                    OSSpinLockLock(&currentlyReadingEntry!.spinLock!)
                    let newFramesAddedCount = currentlyReadingEntry.framesQueued! + Int64(framesAdded)
                    currentlyReadingEntry!.framesQueued! = newFramesAddedCount
                    OSSpinLockUnlock(&currentlyReadingEntry!.spinLock!)
                    return
                } else if status != 0 {
                    print("error")
                    return
                }
                framesToDecode = start

                if framesToDecode == 0 {

                    OSSpinLockLock(&pcmBufferSpinLock)
                    let newCount = pcmBufferUsedFrameCount! + framesAdded
                    pcmBufferUsedFrameCount = newCount
                    OSSpinLockUnlock(&pcmBufferSpinLock);

                    OSSpinLockLock(&currentlyReadingEntry!.spinLock!)
                    let newFramesAddedCount = currentlyReadingEntry.framesQueued! + Int64(framesAdded)
                    currentlyReadingEntry!.framesQueued! = newFramesAddedCount
                    OSSpinLockUnlock(&currentlyReadingEntry!.spinLock!)
                    continue
                }

                localPcmAudioBuffer.mData = pcmAudioBuffer!.mData
                localPcmAudioBuffer.mDataByteSize = framesToDecode * pcmBufferFrameSizeInBytes!
                localPcmAudioBuffer.mNumberChannels = pcmAudioBuffer!.mNumberChannels

                AudioConverterFillComplexBuffer(audioConverterRef, AudioConverter_Callback, &convertInfo, &framesToDecode, &localPcmBufferList, nil)
                let decodedFramesAdded = framesAdded + framesToDecode
                framesAdded = decodedFramesAdded

                if status == 100 {
                    OSSpinLockLock(&pcmBufferSpinLock)
                    let newCount = pcmBufferUsedFrameCount! + framesAdded
                    pcmBufferUsedFrameCount = newCount
                    OSSpinLockUnlock(&pcmBufferSpinLock);

                    OSSpinLockLock(&currentlyReadingEntry!.spinLock!)
                    let newFramesAddedCount = currentlyReadingEntry.framesQueued! + Int64(framesAdded)
                    currentlyReadingEntry!.framesQueued! = newFramesAddedCount
                    OSSpinLockUnlock(&currentlyReadingEntry!.spinLock!)
                    return
                } else if status == 0 {
                    OSSpinLockLock(&pcmBufferSpinLock)
                    let newCount = pcmBufferUsedFrameCount! + framesAdded
                    pcmBufferUsedFrameCount = newCount
                    OSSpinLockUnlock(&pcmBufferSpinLock);

                    OSSpinLockLock(&currentlyReadingEntry!.spinLock!)
                    let newFramesAddedCount = currentlyReadingEntry.framesQueued! + Int64(framesAdded)
                    currentlyReadingEntry!.framesQueued! = newFramesAddedCount
                    OSSpinLockUnlock(&currentlyReadingEntry!.spinLock!)
                    continue
                } else if status != 0 {
                    print("error")
                    return
                } else {
                    var framesAdded: UInt32 = 0
                    var framesToDecode: UInt32 = start - end
                    localPcmAudioBuffer.mData = pcmAudioBuffer!.mData.advancedBy(Int(end * pcmBufferFrameSizeInBytes!))
                    localPcmAudioBuffer.mDataByteSize = framesToDecode * pcmBufferFrameSizeInBytes!;
                    localPcmAudioBuffer.mNumberChannels = pcmAudioBuffer!.mNumberChannels

                    var  convertInfoo: UnsafePointer<Void> = unsafeBitCast(convertInfo, UnsafePointer<Void>.self)

                    status = AudioConverterFillComplexBuffer(audioConverterRef, AudioConverter_Callback, &convertInfoo, &framesToDecode, &localPcmBufferList, nil)

                    framesAdded = framesToDecode

                    if status == 100 {
                        OSSpinLockLock(&pcmBufferSpinLock)
                        let newCount = pcmBufferUsedFrameCount! + framesAdded
                        pcmBufferUsedFrameCount = newCount
                        OSSpinLockUnlock(&pcmBufferSpinLock);

                        OSSpinLockLock(&currentlyReadingEntry!.spinLock!)
                        let newFramesAddedCount = currentlyReadingEntry.framesQueued! + Int64(framesAdded)
                        currentlyReadingEntry!.framesQueued! = newFramesAddedCount
                        OSSpinLockUnlock(&currentlyReadingEntry!.spinLock!)
                        return
                    } else if status == 0 {
                        OSSpinLockLock(&pcmBufferSpinLock)
                        let newCount = pcmBufferUsedFrameCount! + framesAdded
                        pcmBufferUsedFrameCount = newCount
                        OSSpinLockUnlock(&pcmBufferSpinLock);

                        OSSpinLockLock(&currentlyReadingEntry!.spinLock!)
                        let newFramesAddedCount = currentlyReadingEntry.framesQueued! + Int64(framesAdded)
                        currentlyReadingEntry!.framesQueued! = newFramesAddedCount
                        OSSpinLockUnlock(&currentlyReadingEntry!.spinLock!)
                        continue
                    } else if status != 0 {
                        print("error")
                        return
                    }

                }
            }
        }
    }

func handleAudioPackets（输入数据：UnsafePointer，数字字节：UInt32，数字包：UInt32，包描述：UnsafeMutablePointer）{
如果currentlyReadingEntry==nil{
打印（“currentlyReadingEntry=nil”）
返回
}
如果currentlyReadingEntry.parsedHeader==false{
打印（“currentlyReadingEntry.parsedHeader==false”）
返回
}
如果disposedWasRequested==true{
打印（“disposedWasRequested==true”）
返回
}
guard let audioConverterRef=audioConverterRef else{
返回
}
如果seekToTimeWasRequested==true&¤tlyReadingEntry.calculatedBitRate（）>0.0{
wakeupPlaybackThread（）
打印（“seektotimewasrequest==true&¤tlyReadingEntry.calculatedBitRate（）>0.0”）
返回
}
不连续=错误
var buffer=AudioBuffer（）
buffer.mNumberChannels=音频转换器AudioStreamBasicDescription.mChannelsPerFrame
buffer.mDataByteSize=numberBytes
buffer.mData=未配置指针（inputData）
convertInfo？=AudioConvertInfo（完成：false，numberOfPackets:numberPackets，audioBuffer:buffer，
packetDescriptions：packetDescriptions）
如果packetDescriptions！=nil&¤tlyReadingEntry.processedpacketscont0{
打破
}
如果（disposedWasRequested==true
||internalState==SSPlayerInternalState.Disposed）{
pthread_mutex_unlock（&playerMutex）
返回
}
if（seektotimewasrequest==true&¤tlyPlayingEntry.calculatedBitRate（）>0.0）
{
pthread_mutex_unlock（&playerMutex）
wakeupPlaybackThread（）
返回；
}
等待=真
pthread\u cond\u wait（&playerThreadReadyCondition，&playerMutex）
等待=错误
}
pthread_mutex_unlock（&playerMutex）
}
var localPcmAudioBuffer=AudioBuffer（）
var localPcmBufferList=AudioBufferList（mNumberBuffers:1，mBuffers:AudioBuffer（mNumberChannels:0，mDataByteSize:0，mData:nil））
localPcmAudioBuffer=localPcmBufferList.mBuffers
如果结束>=开始{
var framesAdded:UInt32=0
var framesToDecode:UInt32=pcmBufferTotalFrameCount！-结束
localPcmAudioBuffer.mData=pcmAudioBuffer！.mData.advancedBy（Int（end*pcmBufferFrameSizeInBytes！））
localPcmAudioBuffer.mDataByteSize=framesToDecode*pcmBufferFrameSizeInBytes！；
localPcmAudioBuffer.mNumberChannels=pcmAudioBuffer！.mNumberChannels
AudioConverterFillComplexBuffer（audioConverterRef，AudioConverter_回调，&convertInfo，&framesToDecode，&localPcmBufferList，无）
framesAdded=framesToDecode
如果状态==100{
OSSPINLOCK（和pcmBufferSpinLock）
让newCount=pcmBufferUsedFrameCount！+framesAdded
pcmBufferUsedFrameCount=newCount
OSSpinLockUnlock（和PCMBUFERSPINLOCK）；
OSSpinLockLock（¤tlyReadingEntry！.spinLock！）
让newFramesAddedCount=currentlyReadingEntry.FrameSqueed！+Int64（framesAdded）
currentlyReadingEntry！.framesQueued！=新建FrameSaddedCount
OSSpinLockUnlock（¤tlyReadingEntry！.spinLock！））
返回
}否则如果统计
AudioBufferList

var localPcmBufferList = AudioBufferList(mNumberBuffers: 2, mBuffers: AudioBuffer(mNumberChannels: 2, mDataByteSize: UInt32(buffer.count), mData: &buffer))

      let command = "-i input.mp3 -f s16le -acodec pcm_s16le -ac 1 -ar 44100  output.raw"
      let result = MobileFFmpeg.execute(command)
           switch result {
           case RETURN_CODE_SUCCESS:
               print("command exe completed successfully.\n")
           case RETURN_CODE_CANCEL:
               print("command exe cancelled by user.\n")
           default:
               print("command exe failed with rc=\(result) and output=\(String(describing: MobileFFmpegConfig.getLastCommandOutput())).\n")
          }