rock-n-code/playdate-kit
1
0
Fork 0
Code Issues Pull Requests Actions Releases 2 Activity

Remove per-call overhead from API access and text conversion

Browse Source 
Two hot-path optimizations for the device's Cortex-M7 (and debug simulator
builds):

- The ten sub-API pointers are cached once in Playdate.initialize(with:);
  wrapper accessors now return UnsafePointer and call sites read a single
  field through it, instead of unwrapping the optional API struct and
  copying a whole sub-API struct of function pointers on every call.
  Nested sub-APIs (sound classes, effects, video, tilemap, http/tcp)
  derive from the cached pointers with one field load.

- String -> C conversions (withPlaydateCString, and a new withPlaydateUTF8
  used by the text drawing/measuring APIs) use withUnsafeTemporaryAllocation
  instead of building a ContiguousArray, so logging and drawText in the
  update loop no longer heap-allocate per call. Verified within the
  Embedded Swift subset by the device cross-compile.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
This commit is contained in:
javier
2026-07-25 07:23:19 +02:00
co-authored by Claude Fable 5
parent e4e99cc894
commit d914e0f8fb
20 changed files with 682 additions and 643 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Sources/PlayDate/SoundSource.swift
+55 -55
View File
@@ -9,7 +9,7 @@ extension Sound {
/// A source of audio: the base class of `FilePlayer`, `SamplePlayer`,
/// `Synth`, `DelayLineTap`, and `CallbackSource`. Wraps `SoundSource`.
public class Source {
private static var api: playdate_sound_source { snd.source.pointee }
private static var api: UnsafePointer<playdate_sound_source> { snd.pointee.source.unsafelyUnwrapped }
/// The underlying C object. Set once, immediately after creation.
var pointer: OpaquePointer!
@@ -23,7 +23,7 @@ extension Sound {
/// Sets the playback volume for the left and right channels, 0...1.
public func setVolume(left: Float, right: Float) {
Source.api.setVolume.unsafelyUnwrapped(pointer, left, right)
Source.api.pointee.setVolume.unsafelyUnwrapped(pointer, left, right)
}
/// Sets the playback volume of both channels.
@@ -34,25 +34,25 @@ extension Sound {
/// The playback volume of the left and right channels.
public var volume: (left: Float, right: Float) {
var left: Float = 0, right: Float = 0
Source.api.getVolume.unsafelyUnwrapped(pointer, &left, &right)
Source.api.pointee.getVolume.unsafelyUnwrapped(pointer, &left, &right)
return (left, right)
}
public var isPlaying: Bool {
Source.api.isPlaying.unsafelyUnwrapped(pointer) != 0
Source.api.pointee.isPlaying.unsafelyUnwrapped(pointer) != 0
}
/// Sets a function called when the source finishes playing.
public func setFinishCallback(_ callback: ((Source) -> Void)?) {
finishCallback = callback
if callback != nil {
Source.api.setFinishCallback.unsafelyUnwrapped(pointer, { _, userdata in
Source.api.pointee.setFinishCallback.unsafelyUnwrapped(pointer, { _, userdata in
guard let userdata else { return }
let source = Unmanaged<Source>.fromOpaque(userdata).takeUnretainedValue()
source.finishCallback?(source)
}, Unmanaged.passUnretained(self).toOpaque())
} else {
Source.api.setFinishCallback.unsafelyUnwrapped(pointer, nil, nil)
Source.api.pointee.setFinishCallback.unsafelyUnwrapped(pointer, nil, nil)
}
}
}
@@ -106,7 +106,7 @@ extension Sound {
/// Streams audio from a file. Wraps `FilePlayer`.
public final class FilePlayer: Source {
private static var api: playdate_sound_fileplayer { snd.fileplayer.pointee }
private static var api: UnsafePointer<playdate_sound_fileplayer> { snd.pointee.fileplayer.unsafelyUnwrapped }
var loopCallback: ((FilePlayer) -> Void)?
var fadeCallback: ((FilePlayer) -> Void)?
@@ -118,7 +118,7 @@ extension Sound {
}
public convenience init() {
self.init(pointer: FilePlayer.api.newPlayer.unsafelyUnwrapped().unsafelyUnwrapped,
self.init(pointer: FilePlayer.api.pointee.newPlayer.unsafelyUnwrapped().unsafelyUnwrapped,
isOwned: true)
}
@@ -130,14 +130,14 @@ extension Sound {
deinit {
if isOwned {
FilePlayer.api.freePlayer.unsafelyUnwrapped(pointer)
FilePlayer.api.pointee.freePlayer.unsafelyUnwrapped(pointer)
}
}
/// Prepares the player to stream the file at `path`.
public func load(path: String) throws(PlaydateError) {
let loaded = path.withPlaydateCString {
FilePlayer.api.loadIntoPlayer.unsafelyUnwrapped(pointer, $0) != 0
FilePlayer.api.pointee.loadIntoPlayer.unsafelyUnwrapped(pointer, $0) != 0
}
if !loaded {
throw PlaydateError(message: "unable to load audio file: \(path)")
@@ -146,69 +146,69 @@ extension Sound {
/// Sets the length of the stream buffer, in seconds. Default 0.25.
public func setBufferLength(_ seconds: Float) {
FilePlayer.api.setBufferLength.unsafelyUnwrapped(pointer, seconds)
FilePlayer.api.pointee.setBufferLength.unsafelyUnwrapped(pointer, seconds)
}
/// Starts playback, looping `repeat` times; 0 loops endlessly.
@discardableResult
public func play(repeat repeatCount: Int = 1) -> Bool {
FilePlayer.api.play.unsafelyUnwrapped(pointer, Int32(repeatCount)) != 0
FilePlayer.api.pointee.play.unsafelyUnwrapped(pointer, Int32(repeatCount)) != 0
}
public func pause() {
FilePlayer.api.pause.unsafelyUnwrapped(pointer)
FilePlayer.api.pointee.pause.unsafelyUnwrapped(pointer)
}
public func stop() {
FilePlayer.api.stop.unsafelyUnwrapped(pointer)
FilePlayer.api.pointee.stop.unsafelyUnwrapped(pointer)
}
/// The file's length in seconds.
public var length: Float {
FilePlayer.api.getLength.unsafelyUnwrapped(pointer)
FilePlayer.api.pointee.getLength.unsafelyUnwrapped(pointer)
}
/// The playback position in seconds.
public var offset: Float {
get { FilePlayer.api.getOffset.unsafelyUnwrapped(pointer) }
set { FilePlayer.api.setOffset.unsafelyUnwrapped(pointer, newValue) }
get { FilePlayer.api.pointee.getOffset.unsafelyUnwrapped(pointer) }
set { FilePlayer.api.pointee.setOffset.unsafelyUnwrapped(pointer, newValue) }
}
/// The playback rate; 1 is normal speed, negative values are not
/// supported.
public var rate: Float {
get { FilePlayer.api.getRate.unsafelyUnwrapped(pointer) }
set { FilePlayer.api.setRate.unsafelyUnwrapped(pointer, newValue) }
get { FilePlayer.api.pointee.getRate.unsafelyUnwrapped(pointer) }
set { FilePlayer.api.pointee.setRate.unsafelyUnwrapped(pointer, newValue) }
}
/// Loops playback between `start` and `end` (seconds) while playing
/// with `repeat` 0. An `end` of 0 means the end of the file.
public func setLoopRange(start: Float, end: Float) {
FilePlayer.api.setLoopRange.unsafelyUnwrapped(pointer, start, end)
FilePlayer.api.pointee.setLoopRange.unsafelyUnwrapped(pointer, start, end)
}
/// Whether playback underran because the file could not be read fast
/// enough.
public var didUnderrun: Bool {
FilePlayer.api.didUnderrun.unsafelyUnwrapped(pointer) != 0
FilePlayer.api.pointee.didUnderrun.unsafelyUnwrapped(pointer) != 0
}
/// Stops playback (instead of looping the buffer) on underrun.
public func setStopOnUnderrun(_ flag: Bool) {
FilePlayer.api.setStopOnUnderrun.unsafelyUnwrapped(pointer, flag ? 1 : 0)
FilePlayer.api.pointee.setStopOnUnderrun.unsafelyUnwrapped(pointer, flag ? 1 : 0)
}
/// Sets a function called every time playback loops.
public func setLoopCallback(_ callback: ((FilePlayer) -> Void)?) {
loopCallback = callback
if callback != nil {
FilePlayer.api.setLoopCallback.unsafelyUnwrapped(pointer, { _, userdata in
FilePlayer.api.pointee.setLoopCallback.unsafelyUnwrapped(pointer, { _, userdata in
guard let userdata else { return }
let player = Unmanaged<FilePlayer>.fromOpaque(userdata).takeUnretainedValue()
player.loopCallback?(player)
}, Unmanaged.passUnretained(self).toOpaque())
} else {
FilePlayer.api.setLoopCallback.unsafelyUnwrapped(pointer, nil, nil)
FilePlayer.api.pointee.setLoopCallback.unsafelyUnwrapped(pointer, nil, nil)
}
}
@@ -218,13 +218,13 @@ extension Sound {
completion: ((FilePlayer) -> Void)? = nil) {
fadeCallback = completion
if completion != nil {
FilePlayer.api.fadeVolume.unsafelyUnwrapped(pointer, left, right, length, { _, userdata in
FilePlayer.api.pointee.fadeVolume.unsafelyUnwrapped(pointer, left, right, length, { _, userdata in
guard let userdata else { return }
let player = Unmanaged<FilePlayer>.fromOpaque(userdata).takeUnretainedValue()
player.fadeCallback?(player)
}, Unmanaged.passUnretained(self).toOpaque())
} else {
FilePlayer.api.fadeVolume.unsafelyUnwrapped(pointer, left, right, length, nil, nil)
FilePlayer.api.pointee.fadeVolume.unsafelyUnwrapped(pointer, left, right, length, nil, nil)
}
}
@@ -234,7 +234,7 @@ extension Sound {
public func setMP3StreamSource(bufferLength: Float,
_ dataSource: @escaping (UnsafeMutableBufferPointer<UInt8>) -> Int) {
mp3DataSource = dataSource
FilePlayer.api.setMP3StreamSource.unsafelyUnwrapped(pointer, { data, bytes, userdata in
FilePlayer.api.pointee.setMP3StreamSource.unsafelyUnwrapped(pointer, { data, bytes, userdata in
guard let userdata, let data else { return 0 }
let player = Unmanaged<FilePlayer>.fromOpaque(userdata).takeUnretainedValue()
let buffer = UnsafeMutableBufferPointer(start: data, count: Int(bytes))
@@ -244,10 +244,10 @@ extension Sound {
/// Modulates the playback rate.
public var rateModulator: SignalValue? {
get { SignalValue.wrap(FilePlayer.api.getRateModulator.unsafelyUnwrapped(pointer)) }
get { SignalValue.wrap(FilePlayer.api.pointee.getRateModulator.unsafelyUnwrapped(pointer)) }
set {
retainedRateModulator = newValue
FilePlayer.api.setRateModulator.unsafelyUnwrapped(pointer, newValue?.pointer)
FilePlayer.api.pointee.setRateModulator.unsafelyUnwrapped(pointer, newValue?.pointer)
}
}
}
@@ -256,7 +256,7 @@ extension Sound {
/// Audio data loaded into memory. Wraps `AudioSample`.
public final class AudioSample {
private static var api: playdate_sound_sample { snd.sample.pointee }
private static var api: UnsafePointer<playdate_sound_sample> { snd.pointee.sample.unsafelyUnwrapped }
let pointer: OpaquePointer
let isOwned: Bool
@@ -268,13 +268,13 @@ extension Sound {
/// Allocates a sample buffer with room for `byteCount` bytes.
public convenience init(byteCount: Int) {
self.init(pointer: AudioSample.api.newSampleBuffer.unsafelyUnwrapped(
self.init(pointer: AudioSample.api.pointee.newSampleBuffer.unsafelyUnwrapped(
Int32(byteCount)).unsafelyUnwrapped, isOwned: true)
}
/// Loads the wav or aiff file at `path`.
public convenience init(path: String) throws(PlaydateError) {
let pointer = path.withPlaydateCString { AudioSample.api.load.unsafelyUnwrapped($0) }
let pointer = path.withPlaydateCString { AudioSample.api.pointee.load.unsafelyUnwrapped($0) }
guard let pointer else {
throw PlaydateError(message: "unable to load sample: \(path)")
}
@@ -287,7 +287,7 @@ extension Sound {
/// sample's lifetime.
public convenience init?(data: UnsafeMutablePointer<UInt8>, format: Format,
sampleRate: UInt32, byteCount: Int, freeWhenDone: Bool) {
guard let pointer = AudioSample.api.newSampleFromData.unsafelyUnwrapped(
guard let pointer = AudioSample.api.pointee.newSampleFromData.unsafelyUnwrapped(
data, format.cValue, sampleRate, Int32(byteCount), freeWhenDone ? 1 : 0) else {
return nil
}
@@ -296,14 +296,14 @@ extension Sound {
deinit {
if isOwned {
AudioSample.api.freeSample.unsafelyUnwrapped(pointer)
AudioSample.api.pointee.freeSample.unsafelyUnwrapped(pointer)
}
}
/// Loads the file at `path` into this sample's buffer.
public func load(path: String) throws(PlaydateError) {
let loaded = path.withPlaydateCString {
AudioSample.api.loadIntoSample.unsafelyUnwrapped(pointer, $0) != 0
AudioSample.api.pointee.loadIntoSample.unsafelyUnwrapped(pointer, $0) != 0
}
if !loaded {
throw PlaydateError(message: "unable to load sample: \(path)")
@@ -316,20 +316,20 @@ extension Sound {
var data: UnsafeMutablePointer<UInt8>?
var format = kSound16bitMono
var sampleRate: UInt32 = 0, byteLength: UInt32 = 0
AudioSample.api.getData.unsafelyUnwrapped(pointer, &data, &format, &sampleRate, &byteLength)
AudioSample.api.pointee.getData.unsafelyUnwrapped(pointer, &data, &format, &sampleRate, &byteLength)
return (data, Format(format), sampleRate, byteLength)
}
/// The sample's length in seconds.
public var length: Float {
AudioSample.api.getLength.unsafelyUnwrapped(pointer)
AudioSample.api.pointee.getLength.unsafelyUnwrapped(pointer)
}
/// Decompresses an ADPCM sample to 16-bit PCM so it can be used in a
/// synth. Returns `false` if there is not enough memory.
@discardableResult
public func decompress() -> Bool {
AudioSample.api.decompress.unsafelyUnwrapped(pointer) != 0
AudioSample.api.pointee.decompress.unsafelyUnwrapped(pointer) != 0
}
}
@@ -337,7 +337,7 @@ extension Sound {
/// Plays an `AudioSample` from memory. Wraps `SamplePlayer`.
public final class SamplePlayer: Source {
private static var api: playdate_sound_sampleplayer { snd.sampleplayer.pointee }
private static var api: UnsafePointer<playdate_sound_sampleplayer> { snd.pointee.sampleplayer.unsafelyUnwrapped }
var loopCallback: ((SamplePlayer) -> Void)?
private var retainedSample: AudioSample?
@@ -348,7 +348,7 @@ extension Sound {
}
public convenience init() {
self.init(pointer: SamplePlayer.api.newPlayer.unsafelyUnwrapped().unsafelyUnwrapped,
self.init(pointer: SamplePlayer.api.pointee.newPlayer.unsafelyUnwrapped().unsafelyUnwrapped,
isOwned: true)
}
@@ -360,7 +360,7 @@ extension Sound {
deinit {
if isOwned {
SamplePlayer.api.freePlayer.unsafelyUnwrapped(pointer)
SamplePlayer.api.pointee.freePlayer.unsafelyUnwrapped(pointer)
}
}
@@ -369,7 +369,7 @@ extension Sound {
get { retainedSample }
set {
retainedSample = newValue
SamplePlayer.api.setSample.unsafelyUnwrapped(pointer, newValue?.pointer)
SamplePlayer.api.pointee.setSample.unsafelyUnwrapped(pointer, newValue?.pointer)
}
}
@@ -377,59 +377,59 @@ extension Sound {
/// endlessly, -1 loops ping-pong.
@discardableResult
public func play(repeat repeatCount: Int = 1, rate: Float = 1) -> Bool {
SamplePlayer.api.play.unsafelyUnwrapped(pointer, Int32(repeatCount), rate) != 0
SamplePlayer.api.pointee.play.unsafelyUnwrapped(pointer, Int32(repeatCount), rate) != 0
}
public func stop() {
SamplePlayer.api.stop.unsafelyUnwrapped(pointer)
SamplePlayer.api.pointee.stop.unsafelyUnwrapped(pointer)
}
public func setPaused(_ paused: Bool) {
SamplePlayer.api.setPaused.unsafelyUnwrapped(pointer, paused ? 1 : 0)
SamplePlayer.api.pointee.setPaused.unsafelyUnwrapped(pointer, paused ? 1 : 0)
}
/// The sample's length in seconds.
public var length: Float {
SamplePlayer.api.getLength.unsafelyUnwrapped(pointer)
SamplePlayer.api.pointee.getLength.unsafelyUnwrapped(pointer)
}
/// The playback position in seconds.
public var offset: Float {
get { SamplePlayer.api.getOffset.unsafelyUnwrapped(pointer) }
set { SamplePlayer.api.setOffset.unsafelyUnwrapped(pointer, newValue) }
get { SamplePlayer.api.pointee.getOffset.unsafelyUnwrapped(pointer) }
set { SamplePlayer.api.pointee.setOffset.unsafelyUnwrapped(pointer, newValue) }
}
/// The playback rate; 1 is normal speed, negative plays backward.
public var rate: Float {
get { SamplePlayer.api.getRate.unsafelyUnwrapped(pointer) }
set { SamplePlayer.api.setRate.unsafelyUnwrapped(pointer, newValue) }
get { SamplePlayer.api.pointee.getRate.unsafelyUnwrapped(pointer) }
set { SamplePlayer.api.pointee.setRate.unsafelyUnwrapped(pointer, newValue) }
}
/// Restricts playback to the given range of sample frames.
public func setPlayRange(start: Int, end: Int) {
SamplePlayer.api.setPlayRange.unsafelyUnwrapped(pointer, Int32(start), Int32(end))
SamplePlayer.api.pointee.setPlayRange.unsafelyUnwrapped(pointer, Int32(start), Int32(end))
}
/// Sets a function called every time playback loops.
public func setLoopCallback(_ callback: ((SamplePlayer) -> Void)?) {
loopCallback = callback
if callback != nil {
SamplePlayer.api.setLoopCallback.unsafelyUnwrapped(pointer, { _, userdata in
SamplePlayer.api.pointee.setLoopCallback.unsafelyUnwrapped(pointer, { _, userdata in
guard let userdata else { return }
let player = Unmanaged<SamplePlayer>.fromOpaque(userdata).takeUnretainedValue()
player.loopCallback?(player)
}, Unmanaged.passUnretained(self).toOpaque())
} else {
SamplePlayer.api.setLoopCallback.unsafelyUnwrapped(pointer, nil, nil)
SamplePlayer.api.pointee.setLoopCallback.unsafelyUnwrapped(pointer, nil, nil)
}
}
/// Modulates the playback rate.
public var rateModulator: SignalValue? {
get { SignalValue.wrap(SamplePlayer.api.getRateModulator.unsafelyUnwrapped(pointer)) }
get { SignalValue.wrap(SamplePlayer.api.pointee.getRateModulator.unsafelyUnwrapped(pointer)) }
set {
retainedRateModulator = newValue
SamplePlayer.api.setRateModulator.unsafelyUnwrapped(pointer, newValue?.pointer)
SamplePlayer.api.pointee.setRateModulator.unsafelyUnwrapped(pointer, newValue?.pointer)
}
}
}