Ich schaue mir einige der Beispiele von Midi-Ausgabe mit Core Midi.Verwenden von MIDIPacketList in swift
Speziell this question
und this
Ich habe Code, der auf diese in ObjC basierend arbeitet und ich möchte nun versuchen, das zu rasche zu übersetzen.
die Linie, die ich am wenigsten verstehe, ist diese: MIDIPacketList* pktList = (MIDIPacketList*) pktBuffer;
lese ich dies als einen Zeiger pktlist vom Typ MIDIPacketList erklärt und ihnen den Wert von pktBuffer, warf den Typen MIDIPacketList
Ich bin neu zuweisen zu C und objC und das ergibt für mich keinen Sinn.
MIDIPacketList ist eine Struktur here definiert:
in welcher Art und Weise macht es Sinn, eine bytearray auf die Struktur Typ MIDIPacketList und zu werfen, was diese zu erreichen versucht? Ich denke, es versucht, die Größe der Paketliste zu definieren, aber warum müssen wir das hier tun, und wie macht es das überhaupt? Warum reicht es nicht, es mit MIDIPacketListAdd zu tun, wie es ein paar Zeilen später passiert?
Hier ist mein Versuch einer Midi-Ausgangsklasse in swift - kann jemand sehen, was schief geht? Dieser Code gibt keine Fehler in Xcode, bis es ausgeführt wird. Ich habe eine funktionierende Version von diesem in objC, aber ich kann die Größe der Paketliste nicht erreichen, die in swift definiert wird. (Zumindest glaube ich das ist das Problem)
import Foundation
import CoreMIDI
class MidiOutClass {
var midiClient = MIDIClientRef()
var midiSource = MIDIEndpointRef()
func openOutput() {
MIDIClientCreate("MIDI client", nil, nil, &midiClient)
MIDISourceCreate(midiClient, "MIDI Source",&midiSource)
println("midi out opened")//should only do this if successful
}
func noteOn(channel: Int, note: Int, velocity:Int) {
midisend((0x90+channel), note: note, value: velocity)
}
func polyAfter(channel: Int, note: Int, value:Int) {
midisend((0xA0+channel), note: note, value: value)
}
func noteOff(channel: Int, note: Int) {
midisend((0x90+channel), note: note, value: 0)
}
func midisend(status:Int, note: Int, value:Int) {
var packet: UnsafeMutablePointer<MIDIPacket> = nil
//var buffer = [Byte](count:1024, repeatedValue: 0)
//this is the array I'm trying to use in a similar way to the obj C.
var packetList: UnsafeMutablePointer<MIDIPacketList> = nil
let midiDataToSend:[Byte] = [Byte(status), Byte(note), Byte(value)];
packet = MIDIPacketListInit(packetList);
packet = MIDIPacketListAdd(packetList, 1024, packet, 0, 3, midiDataToSend);
if (packet == nil) {
println("failed to send the midi.")
} else {
MIDIReceived(midiSource, packetList)
println("sent some stuff")
}
}
}//end MidiOutClass
Die doc für die destroy () func sagt "Zerstöre das Objekt, auf das der Zeiger zeigt." Du brauchst das Dealloc also nicht, da das das tut. Denkst du auch nicht: var packet = UnsafeMutablePointer .alloc (sizeof (MIDIPacket)) wäre besser? –
@GeneDeLisa Ich denke, der Parameter für die Alloc-Methode ist die Anzahl der Objekte und nicht die Byte-Größe. Nicht sicher, wie es die Größe des Pakets überhaupt wissen würde. Soweit ich das beurteilen kann, weist es mehr Speicher zu, als er denkt, dass er benötigt wird, und nicht eine genau richtige Menge. Dies entspricht dem Bytearray im ObjC-Beispiel. Ich bin ein Anfänger, also könnte ich es falsch verstanden haben. – Thomas
Ich wusste nicht über zerstören mit Dealloc. Ich habe Beispiele gesehen, in denen beide ausdrücklich genannt wurden, wie ich es hier getan habe. – Thomas