如何在Swift中复现C语言分配双声道AudioBufferList的行为？

Got it! Replicating that C-style behavior for creating an AudioBufferList with two buffers (one per stereo channel) in Swift is straightforward once you understand how Core Audio types translate. Below are two reliable approaches, along with critical memory management notes.

Approach 1: Use UnsafeMutableAudioBufferListPointer (Recommended) #

This is the safer, more Swift-idiomatic way to work with AudioBufferList, as it handles some memory layout details automatically.

import AVFoundation

func createStereoAudioBufferList(bufferSizeBytes: Int) -> UnsafeMutableAudioBufferListPointer? {
    // Guard against invalid buffer size
    guard bufferSizeBytes > 0 else {
        print("Error: Buffer size must be greater than 0")
        return nil
    }
    
    // Allocate space for 2 buffers (one per stereo channel)
    guard let bufferList = AudioBufferList.allocate(maximumBuffers: 2) else {
        print("Error: Failed to allocate AudioBufferList")
        return nil
    }
    
    // Configure left channel buffer
    bufferList[0].mNumberChannels = 1
    bufferList[0].mDataByteSize = UInt32(bufferSizeBytes)
    bufferList[0].mData = malloc(bufferSizeBytes)
    
    // Configure right channel buffer
    bufferList[1].mNumberChannels = 1
    bufferList[1].mDataByteSize = UInt32(bufferSizeBytes)
    bufferList[1].mData = malloc(bufferSizeBytes)
    
    // Validate memory allocations and clean up on failure
    guard bufferList[0].mData != nil && bufferList[1].mData != nil else {
        print("Error: Failed to allocate channel buffers")
        if let leftData = bufferList[0].mData { free(leftData) }
        if let rightData = bufferList[1].mData { free(rightData) }
        bufferList.deallocate()
        return nil
    }
    
    return bufferList
}

Breakdown: #

• We start by allocating an AudioBufferList with space for 2 buffers using AudioBufferList.allocate().
• Each buffer is set to handle a single channel (mNumberChannels = 1), with the specified bufferSizeBytes for both the buffer size property and the malloc'd memory block.
• We add error checking to catch allocation failures, and clean up any partially allocated memory to avoid leaks.

Approach 2: Manual Memory Allocation (C-Style) #

If you want a direct translation of the original C code, you can manually calculate and allocate memory for the AudioBufferList and its buffers:

import AVFoundation

func createStereoAudioBufferListManual(bufferSizeBytes: Int) -> UnsafeMutablePointer<AudioBufferList>? {
    guard bufferSizeBytes > 0 else {
        print("Error: Buffer size must be greater than 0")
        return nil
    }
    
    // Calculate total memory needed: struct size + 1 extra AudioBuffer (first is included in the struct)
    let totalSize = MemoryLayout<AudioBufferList>.size + MemoryLayout<AudioBuffer>.stride * (2 - 1)
    guard let bufferListPtr = malloc(totalSize)?.bindMemory(to: AudioBufferList.self, capacity: 1) else {
        print("Error: Failed to allocate AudioBufferList memory")
        return nil
    }
    
    // Set the number of buffers to 2
    bufferListPtr.pointee.mNumberBuffers = 2
    
    // Access and configure left channel buffer
    let leftBuffer = UnsafeMutableAudioBufferPointer(bufferListPtr)[0]
    leftBuffer.mNumberChannels = 1
    leftBuffer.mDataByteSize = UInt32(bufferSizeBytes)
    leftBuffer.mData = malloc(bufferSizeBytes)
    
    // Access and configure right channel buffer
    let rightBuffer = UnsafeMutableAudioBufferPointer(bufferListPtr)[1]
    rightBuffer.mNumberChannels = 1
    rightBuffer.mDataByteSize = UInt32(bufferSizeBytes)
    rightBuffer.mData = malloc(bufferSizeBytes)
    
    // Validate allocations and clean up on failure
    guard leftBuffer.mData != nil && rightBuffer.mData != nil else {
        print("Error: Failed to allocate channel buffers")
        if let leftData = leftBuffer.mData { free(leftData) }
        if let rightData = rightBuffer.mData { free(rightData) }
        free(bufferListPtr)
        return nil
    }
    
    return bufferListPtr
}

Key Notes: #

• The AudioBufferList struct includes space for one AudioBuffer by default, so we calculate extra space for the second buffer using MemoryLayout.
• We bind the malloc'd memory to the AudioBufferList type, then use UnsafeMutableAudioBufferPointer to access individual buffers easily.

Critical: Memory Management #

Since we use malloc for buffer memory, you must manually free this memory when finished to avoid leaks. Here's how to clean up each approach:

For Approach 1: #

// Example usage and cleanup
if let stereoBufferList = createStereoAudioBufferList(bufferSizeBytes: 4096) {
    // Use the buffer list for audio processing...
    
    // Free each channel's buffer memory
    for buffer in stereoBufferList {
        if let data = buffer.mData {
            free(data)
        }
    }
    // Deallocate the AudioBufferList itself
    stereoBufferList.deallocate()
}

For Approach 2: #

// Example usage and cleanup
if let stereoBufferListPtr = createStereoAudioBufferListManual(bufferSizeBytes: 4096) {
    let stereoBufferList = UnsafeMutableAudioBufferListPointer(stereoBufferListPtr)
    // Use the buffer list...
    
    // Free channel buffers
    for buffer in stereoBufferList {
        if let data = buffer.mData {
            free(data)
        }
    }
    // Free the AudioBufferList memory
    free(stereoBufferListPtr)
}

内容的提问来源于stack exchange，提问作者Pierre P.