tiny.sys.CoreaudioPlaybackStorage

1pub const Storage = struct {2    phase: alloc_phase.capacity.Phase,3    capacity: CoreAudioCapacity,4    state: *State,56    pub const Limits: type = StorageLimits;7    pub const Capacity: type = CoreAudioCapacity;8    pub const Exhaustion = error{BufferLimitExceeded};9    pub const InitError = std.mem.Allocator.Error || CapacityError;1011    pub const claim: alloc_phase.capacity.Declaration = .{12        .source = .{13            .id = "sys.coreaudio_playback_storage",14            .kind = .phase_static,15            .limit_source = .caller,16            .storage = .{17                .covered = &.{18                    .{19                        .id = "one_stable_coreaudio_callback_state",20                        .lifetime = .steady,21                        .detail = "one stable CoreAudio callback state",22                    },23                },24                .excluded = &.{25                    "caller-owned interleaved PCM frames",26                    "AudioQueue objects and framework-allocated playback buffers",27                    "CoreAudio device, converter, and callback thread storage",28                },29            },30            .capacity = .{31                .inputs = &.{},32                .type_selectors = &.{33                    alloc_phase.capacity.bindType(State, "state"),34                },35                .nodes = &.{36                    .{ .constant = 1 },37                    .{ .scale = .{ .node = 0, .coefficient = .{ .size_of_concrete_type = 0 } } },38                },39                .assertions = &.{.{40                    .scope = .closure_total,41                    .measure = .retained,42                    .relation = .exact,43                    .expression = 1,44                }},45            },46            .overload = .{47                .kind = .reject_before_mutation,48                .detail = "oversize playback payloads reject before a free queue buffer is acquired",49            },50            .risks = .{51                .transitive = .{52                    .status = .open,53                    .detail = "playback synchronization enters the host thread implementation",54                },55                .foreign = .{56                    .status = .open,57                    .detail = "AudioQueue owns three bounded buffers and internal device state",58                },59            },60            .obligations = &.{61                .{ .key = "sys_coreaudio_playback_capacity_capacity_model", .role = .capacity_model },62                .{ .key = "sys_coreaudio_playback_capacity_overload", .role = .overload },63                .{ .key = "sys_coreaudio_playback_oom_retry", .role = .custom },64            },65        },66        .bindings = .{67            .owner = @This(),68            .seal = .{69                .family = alloc_phase.capacity.selector(@This().activate),70                .premise = .{71                    .class = .checked_semantic_fact,72                    .authority = .checker,73                },74            },75            .teardown = .{76                .family = alloc_phase.capacity.selector(@This().deinit),77                .premise = .{78                    .class = .checked_semantic_fact,79                    .authority = .checker,80                },81            },82        },83    };8485    pub fn init(allocator: std.mem.Allocator, limits: StorageLimits) InitError!Storage {86        const capacity = try CoreAudioCapacity.derive(limits);87        const state = try allocator.create(State);88        state.* = .{};89        return .{90            .phase = .initialization,91            .capacity = capacity,92            .state = state,93        };94    }9596    pub fn activate(self: *Storage) void {97        std.debug.assert(self.phase == .initialization);98        self.phase = .steady;99    }100101    pub fn validatePayload(self: *Storage, byte_count: usize) Exhaustion!void {102        std.debug.assert(self.phase == .steady);103        if (byte_count > self.capacity.buffer_bytes) return error.BufferLimitExceeded;104    }105106    pub fn deinit(self: *Storage, allocator: std.mem.Allocator) void {107        std.debug.assert(self.phase != .teardown);108        self.phase = .teardown;109        allocator.destroy(self.state);110        self.state = undefined;111    }112};

1pub const CoreaudioPlaybackStorage = @import("coreaudio.zig").Storage;