also looking at this
feat(media): add bounded PCM capture, owned snapshots and A/V streaming
#917
11 files
+683
-0
| @@ -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. | |
| 3 | const std = @import("std"); | |
| 4 | pub const Sink = struct { context: *anyopaque, write: *const fn (*anyopaque, []const u8) anyerror!void }; | |
| 5 | pub const Config = struct { width: u32, height: u32, fps_num: u32, fps_den: u32, codec: u32, sample_rate: u32, channels: u32, codec_private: []const u8 = &.{} }; | |
| 6 | const 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 | }; | |
| 43 | pub 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 | }; | |
| 133 | test "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 | } | |