ReviewOS

also looking at this

home-lang/home

feat(media): add bounded PCM capture, owned snapshots and A/V streaming

#917
Merged chris wants to merge feat/pcm-av-streaming into main
11 files +683 -0
packages/video/src/containers/av_stream.zigadded+154-0
Changes to packages/video/src/containers/av_stream.zig
@@ -0,0 +1,154 @@
1//! Home streaming Matroska video + lossless S16LE PCM. One cluster per packet;
2//! microsecond timecodes, independent per-track ordering, no file-sized buffer.
3const std = @import("std");
4pub const Sink = struct { context: *anyopaque, write: *const fn (*anyopaque, []const u8) anyerror!void };
5pub const Config = struct { width: u32, height: u32, fps_num: u32, fps_den: u32, codec: u32, sample_rate: u32, channels: u32, codec_private: []const u8 = &.{} };
6const Buffer = struct {
7 data: [16384]u8 = undefined,
8 len: usize = 0,
9 fn bytes(s: *Buffer, data: []const u8) !void {
10 if (data.len > s.data.len - s.len) return error.HeaderTooLarge;
11 @memcpy(s.data[s.len..][0..data.len], data);
12 s.len += data.len;
13 }
14 fn slice(s: *const Buffer) []const u8 {
15 return s.data[0..s.len];
16 }
17 fn number(s: *Buffer, value: u64) !void {
18 var b: [8]u8 = undefined;
19 std.mem.writeInt(u64, &b, value, .big);
20 var n: usize = 0;
21 while (n < 7 and b[n] == 0) : (n += 1) {}
22 try s.bytes(b[n..]);
23 }
24 fn vint(s: *Buffer, value: u64) !void {
25 var n: usize = 1;
26 while (n < 8 and value >= (@as(u64, 1) << @intCast(n * 7)) - 1) : (n += 1) {}
27 if (value >= (@as(u64, 1) << 56) - 1) return error.PacketTooLarge;
28 var b: [8]u8 = undefined;
29 std.mem.writeInt(u64, &b, value | (@as(u64, 1) << @intCast(n * 7)), .big);
30 try s.bytes(b[8 - n ..]);
31 }
32 fn element(s: *Buffer, id: u32, value: []const u8) !void {
33 try s.number(id);
34 try s.vint(value.len);
35 try s.bytes(value);
36 }
37 fn uint(s: *Buffer, id: u32, value: u64) !void {
38 var b: Buffer = .{};
39 try b.number(value);
40 try s.element(id, b.slice());
41 }
42};
43pub const Writer = struct {
44 sink: Sink,
45 config: Config,
46 last_video: ?u64 = null,
47 last_audio: ?u64 = null,
48 failed: bool = false,
49 pub fn init(sink: Sink, cfg: Config) !Writer {
50 if (cfg.width == 0 or cfg.height == 0 or cfg.width > 16384 or cfg.height > 16384 or cfg.fps_num == 0 or cfg.fps_den == 0 or cfg.fps_num > 1000000 or cfg.fps_den > 1000000 or cfg.codec < 1 or cfg.codec > 3 or cfg.sample_rate < 8000 or cfg.sample_rate > 192000 or cfg.channels < 1 or cfg.channels > 2 or cfg.codec_private.len > 8192) return error.InvalidConfiguration;
51 if (cfg.codec != 3 and (cfg.codec_private.len < (if (cfg.codec == 1) @as(usize, 7) else 23) or cfg.codec_private[0] != 1)) return error.InvalidConfiguration;
52 var ebml: Buffer = .{};
53 try ebml.uint(0x4286, 1);
54 try ebml.uint(0x42f7, 1);
55 try ebml.uint(0x42f2, 4);
56 try ebml.uint(0x42f3, 8);
57 try ebml.element(0x4282, "matroska");
58 try ebml.uint(0x4287, 4);
59 try ebml.uint(0x4285, 2);
60 var header: Buffer = .{};
61 try header.element(0x1a45dfa3, ebml.slice());
62 try header.bytes(&.{ 0x18, 0x53, 0x80, 0x67, 0x01, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff });
63 var info: Buffer = .{};
64 try info.uint(0x2ad7b1, 1000);
65 try info.element(0x4d80, "Home");
66 try info.element(0x5741, "Home synchronized A/V");
67 try header.element(0x1549a966, info.slice());
68 var tracks: Buffer = .{};
69 var video_info: Buffer = .{};
70 try video_info.uint(0xb0, cfg.width);
71 try video_info.uint(0xba, cfg.height);
72 var track: Buffer = .{};
73 try track.uint(0xd7, 1);
74 try track.uint(0x73c5, 1);
75 try track.uint(0x83, 1);
76 try track.uint(0x9c, 0);
77 try track.element(0x86, if (cfg.codec == 3) "V_MJPEG" else if (cfg.codec == 1) "V_MPEG4/ISO/AVC" else "V_MPEGH/ISO/HEVC");
78 try track.uint(0x23e383, @as(u64, 1_000_000_000) * cfg.fps_den / cfg.fps_num);
79 if (cfg.codec != 3) try track.element(0x63a2, cfg.codec_private);
80 try track.element(0xe0, video_info.slice());
81 try tracks.element(0xae, track.slice());
82 var audio_info: Buffer = .{};
83 var rate: [8]u8 = undefined;
84 std.mem.writeInt(u64, &rate, @bitCast(@as(f64, @floatFromInt(cfg.sample_rate))), .big);
85 try audio_info.element(0xb5, &rate);
86 try audio_info.uint(0x9f, cfg.channels);
87 try audio_info.uint(0x6264, 16);
88 track = .{};
89 try track.uint(0xd7, 2);
90 try track.uint(0x73c5, 2);
91 try track.uint(0x83, 2);
92 try track.uint(0x9c, 0);
93 try track.element(0x86, "A_PCM/INT/LIT");
94 try track.element(0xe1, audio_info.slice());
95 try tracks.element(0xae, track.slice());
96 try header.element(0x1654ae6b, tracks.slice());
97 try sink.write(sink.context, header.slice());
98 // Codec-private bytes were consumed synchronously, not retained.
99 var owned = cfg;
100 owned.codec_private = &.{};
101 return .{ .sink = sink, .config = owned };
102 }
103 fn block(s: *Writer, track: u8, data: []const u8, timestamp_ns: u64, key: bool) !void {
104 if (s.failed) return error.WriterFailed;
105 if (data.len == 0 or data.len > std.math.maxInt(u32)) return error.InvalidPacket;
106 const last = if (track == 1) s.last_video else s.last_audio;
107 if (last) |t| if (timestamp_ns <= t) return error.InvalidTimestamp;
108 var time: Buffer = .{};
109 try time.uint(0xe7, timestamp_ns / 1000);
110 var size: Buffer = .{};
111 try size.vint(data.len + 4);
112 var header: Buffer = .{};
113 try header.number(0x1f43b675);
114 try header.vint(time.len + 1 + size.len + 4 + data.len);
115 try header.bytes(time.slice());
116 try header.bytes(&.{0xa3});
117 try header.bytes(size.slice());
118 try header.bytes(&.{ 0x80 | track, 0, 0, if (key) @as(u8, 0x80) else 0 });
119 errdefer s.failed = true;
120 try s.sink.write(s.sink.context, header.slice());
121 try s.sink.write(s.sink.context, data);
122 if (track == 1) s.last_video = timestamp_ns else s.last_audio = timestamp_ns;
123 }
124 pub fn video(s: *Writer, data: []const u8, timestamp_ns: u64, key: bool) !void {
125 if (s.config.codec == 3 and (data.len < 4 or !std.mem.startsWith(u8, data, &.{ 255, 216 }) or !std.mem.endsWith(u8, data, &.{ 255, 217 }))) return error.InvalidPacket;
126 try s.block(1, data, timestamp_ns, key);
127 }
128 pub fn audio(s: *Writer, data: []const u8, timestamp_ns: u64) !void {
129 if (data.len == 0 or data.len % (s.config.channels * 2) != 0) return error.InvalidPcm;
130 try s.block(2, data, timestamp_ns, true);
131 }
132};
133test "Matroska has real PCM track, allows interleaved track times, and poisons on I/O failure" {
134 const Out = struct {
135 data: std.ArrayList(u8) = .empty,
136 fail: bool = false,
137 fn write(ctx: *anyopaque, data: []const u8) anyerror!void {
138 const s: *@This() = @ptrCast(@alignCast(ctx));
139 if (s.fail) return error.Full;
140 try s.data.appendSlice(std.testing.allocator, data);
141 }
142 };
143 var out: Out = .{};
144 defer out.data.deinit(std.testing.allocator);
145 var writer = try Writer.init(.{ .context = &out, .write = Out.write }, .{ .width = 32, .height = 32, .fps_num = 30, .fps_den = 1, .codec = 3, .sample_rate = 48000, .channels = 2 });
146 try std.testing.expect(std.mem.indexOf(u8, out.data.items, "A_PCM/INT/LIT") != null);
147 try writer.video(&.{ 255, 216, 255, 217 }, 1000000, true);
148 try writer.audio(&.{ 1, 0, 2, 0 }, 0);
149 try std.testing.expectError(error.InvalidPcm, writer.audio(&.{1}, 100));
150 try std.testing.expectError(error.InvalidTimestamp, writer.audio(&.{ 1, 0, 2, 0 }, 0));
151 out.fail = true;
152 try std.testing.expectError(error.Full, writer.audio(&.{ 1, 0, 2, 0 }, 2000000));
153 try std.testing.expectError(error.WriterFailed, writer.video(&.{ 255, 216, 255, 217 }, 3000000, true));
154}