初始化 MIDIMetaEvent 结构

我正在努力使用 swift 初始化 MusicPlayer.h 中找到的 MIDIMetaEvent 结构。头文件定义结构如下：

struct MIDIMetaEvent {
  var metaEventType: UInt8
  var unused1: UInt8
  var unused2: UInt8
  var unused3: UInt8
  var dataLength: UInt32
  var data: (UInt8)
}

在“数据”成员之前，这似乎相当简单。这是一个 1 元素元组定义吗？我可以轻松初始化所有其他结构元素，但尝试将“数据”设置为除单个值之外的任何其他值，但徒劳无功。在我的代码中，我使用了一个名为 myData 的 UInt8 数组，并尝试像这样初始化该结构：

var msg = MIDIMetaEvent(
  metaEventType : UInt8(0x7F),
  unused1       : UInt8(0),
  unused2       : UInt8(0),
  unused3       : UInt8(0),
  dataLength    : UInt32(myData.count),
  data          : UnsafeBufferPointer<UInt8>(start: UnsafePointer<UInt8>(myData), count:myData.count) )

但编译器对此并不满意，并抱怨“UnsafeBufferPointer 无法转换为 UInt8”。如果我只是将 data 设置为单个值，但将 dataLength 设置为大于 1 的值，则生成的 MIDIEventData 显示事件中的第一个值是我卡在“data”中的值，后跟与“dataLength”字节一致的乱码数据字节。很明显，“数据”被视为某种连续的记忆。

那么如何将该“data”元素设置为数组中的 UInt8 元素呢？

AudioToolbox框架定义MIDIMetaEvent as

typedef struct MIDIMetaEvent
{
    UInt8       metaEventType;
    UInt8       unused1;
    UInt8       unused2;
    UInt8       unused3;
    UInt32      dataLength;
    UInt8       data[1];
} MIDIMetaEvent;

where data[1]实际上用作“可变长度数组”。 在（Objective-）C 中，我们可以只分配一个指向内存块的指针 实际需要的尺寸：

MIDIMetaEvent *mep = malloc(sizeof(MIDIMetaEvent) + data.count);

Swift 对指针转换更加严格，固定大小的数组映射到 Swift 元组（处理起来可能很麻烦）。

以下实用程序类显示了如何解决此问题：

class MyMetaEvent {
    private let size: Int
    private let mem : UnsafeMutablePointer<UInt8>

    let metaEventPtr : UnsafeMutablePointer<MIDIMetaEvent>

    init(type: UInt8, data: [UInt8]) {
        // Allocate memory of the required size:
        size = sizeof(MIDIMetaEvent) + data.count
        mem = UnsafeMutablePointer<UInt8>.alloc(size)
        // Convert pointer:
        metaEventPtr = UnsafeMutablePointer(mem)

        // Fill data:
        metaEventPtr.memory.metaEventType = type
        metaEventPtr.memory.dataLength = UInt32(data.count)
        memcpy(mem + 8, data, UInt(data.count))
    }

    deinit {
        // Release the allocated memory:
        mem.dealloc(size)
    }
}

然后你可以使用以下命令创建一个实例

let me = MyMetaEvent(type: 0x7F, data: myData)

并通过me.metaEventPtr到 Swift 函数UnsafePointer<MIDIMetaEvent>争论。

Swift 3/4 更新：

简单地将指针转换为不同类型不再可能， 一定是“反弹”：

class MyMetaEvent {
    private let size: Int
    private let mem: UnsafeMutablePointer<UInt8>

    init(type: UInt8, data: [UInt8]) {
        // Allocate memory of the required size:
        size = MemoryLayout<MIDIMetaEvent>.size + data.count
        mem = UnsafeMutablePointer<UInt8>.allocate(capacity: size)
        mem.initialize(to: 0, count: size)

        // Fill data:
        mem.withMemoryRebound(to: MIDIMetaEvent.self, capacity: 1) { metaEventPtr in
            metaEventPtr.pointee.metaEventType = type
            metaEventPtr.pointee.dataLength = UInt32(data.count)
            memcpy(&metaEventPtr.pointee.data, data, data.count)
        }
    }

    deinit {
        // Release the allocated memory:
        mem.deallocate(capacity: size)
    }

    func withMIDIMetaEventPtr(body: (UnsafePointer<MIDIMetaEvent>) -> Void) {
        mem.withMemoryRebound(to: MIDIMetaEvent.self, capacity: 1) { metaEventPtr in
            body(metaEventPtr)
        }
    }
}

使用自定义数据创建实例：

let me = MyMetaEvent(type: 0x7F, data: ...)

传递给一个函数UnsafePointer<MIDIMetaEvent>争论：

me.withMIDIMetaEventPtr { metaEventPtr in
    let status = MusicTrackNewMetaEvent(track, 0, metaEventPtr)
}