Impossibile convertire mp3 in PCM usando AudioConverterFillComplexBuffer in AudioFileStream_PacketsProc callback di AudioFileStreamOpen

Question

Ho un AudioFileStream_PacketsProc richiamata set durante una AudioFileStreamOpen che gestisce la conversione di pacchetti audio in PCM usando AudioConverterFillComplexBuffer. Il problema che sto avendo è che sto ottenendo un -50 OSStatus (paramErr) dopo che è stato chiamato AudioConverterFillComplexBuffer. Di seguito è riportato un frammento di ciò che i parametri sono stati utilizzati in AudioConverterFillComplexBuffer e come sono stati fatti:

 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) 

fa quello che potrebbe essere la causa dell'errore param?

Ecco il metodo completo per la richiamata in caso di necessità:

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 
        } 

       } 
      } 
     } 
    } 

Answer 1

Hej @ 3.254.523, ho alcune risposte con possibili soluzioni per voi. Spero di guidarti nel modo giusto nonostante io non sia esperto in questo importante. Quindi, il problema è sicuramente la configurazione di:

AudioBufferList 

Ecco i link che sonda i suggerimenti di questo -50 OSStatus relativo al AudioBufferList: http://lists.apple.com/archives/coreaudio-api/2012/Apr/msg00041.html https://forums.developer.apple.com/thread/6313

Ora, abbiamo concentrarsi su una soluzione Guardando attraverso il vostro AudioBufferList, non avete assegnato alcun valore, ma mNumberBuffers che è 1. Prova a modificare i valori nel modo seguente (come mostrato nel secondo link):

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

Se ancora è non funziona, dobbiamo concentrarci per correggere in modo corretto, quindi qui è possibile trovare la soluzione al -50 OSStatus in AudioConverterFillComplexBuffer anche se non in rapido:

AudioConverterFillComplexBuffer return -50 (paramErr)

iPhone: AudioBufferList init and release