From 8204e77bdcbf8e7648c99193b12f5df53ff1f69e Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Thu, 19 Nov 2026 17:09:08 -0800 Subject: [PATCH 1/9] chore(quest): claim quest/m1/ffi-export/niche-values.md Quest-Claim: 2597088673a7797a From bbfcac29d2f3fc0fbfae2d56ff09a08dea08e65b Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Thu, 19 Nov 2026 17:26:17 -0800 Subject: [PATCH 2/9] ffi: a variant without data writes its niche's whole scalar, so a value holding Option> crosses as its bytes --- ffi/moq/bench/export.c | 34 +- ffi/moq/bench/export.dart | 17 +- ffi/moq/bench/export.go | 17 +- ffi/moq/bench/export.kt | 11 +- ffi/moq/bench/export.ts | 20 +- ffi/moq/moq.c | 25 +- ffi/moq/moq.dart | 6 +- ffi/moq/moq.go | 5 +- ffi/moq/moq.kt | 6 +- ffi/moq/moq.py | 6 +- ffi/moq/moq.swift | 6 +- ffi/src/collect.rs | 108 +++++-- ffi/surface/moq-web/web.d.ts | 39 ++- ffi/surface/moq/c.h | 595 ++++++++++++++++++----------------- ffi/surface/moq/cpp.hpp | 293 ++++++++--------- ffi/surface/moq/dart.dart | 106 +++---- ffi/surface/moq/go.txt | 398 ++++++++++++----------- ffi/surface/moq/kotlin.kt | 126 ++++---- ffi/surface/moq/python.pyi | 122 ++++--- ffi/surface/moq/swift.swift | 124 ++++---- ffi/tests/fixtures.rs | 21 +- 21 files changed, 1036 insertions(+), 1049 deletions(-) diff --git a/ffi/moq/bench/export.c b/ffi/moq/bench/export.c index d5773fc9c..973356159 100644 --- a/ffi/moq/bench/export.c +++ b/ffi/moq/bench/export.c @@ -98,9 +98,9 @@ static moq_frame_Frame *read_frame(moq_group_Consumer *reader) { return read; } -/* A new timestamp `micros` microseconds in, to free. */ -static moq_Timestamp *stamp(uint64_t micros) { - moq_Timestamp *at = NULL; +/* A timestamp `micros` microseconds in. */ +static moq_Timestamp stamp(uint64_t micros) { + moq_Timestamp at; moq_TimeOverflow overflow; if (!moq_Timestamp_from_micros(micros, &at, &overflow)) { fail("from_micros"); @@ -109,7 +109,7 @@ static moq_Timestamp *stamp(uint64_t micros) { } /* A group keyed by its start, which must exceed every earlier group's on the track. */ -static moq_group_Producer *append_group(moq_track_Producer *track, const moq_Timestamp *start) { +static moq_group_Producer *append_group(moq_track_Producer *track, moq_Timestamp start) { moq_group_Producer *group = NULL; moq_Error *err = NULL; if (!moq_track_Producer_append_group(track, start, &group, &err, NULL)) { @@ -118,7 +118,7 @@ static moq_group_Producer *append_group(moq_track_Producer *track, const moq_Tim return group; } -static void write_frame(moq_group_Producer *group, const moq_Timestamp *at, moq_buf frame) { +static void write_frame(moq_group_Producer *group, moq_Timestamp at, moq_buf frame) { moq_Error *err = NULL; if (!moq_group_Producer_write_frame(group, at, frame, &err, NULL)) { fail("write_frame"); @@ -147,7 +147,7 @@ static span throughput(moq_track_Producer *track, moq_track_Subscriber *subscrib snprintf(name, sizeof name, "throughput[%zu]", size); span start = begin(); for (size_t g = 0; g < groups; g++) { - moq_Timestamp *at = stamp((*micros)++); + moq_Timestamp at = stamp((*micros)++); moq_group_Producer *group = append_group(track, at); moq_group_Consumer *reader = recv_group(subscriber); for (int f = 0; f < FRAMES; f++) { @@ -159,7 +159,6 @@ static span throughput(moq_track_Producer *track, moq_track_Subscriber *subscrib moq_frame_Frame_free(read); } finish(group); - moq_Timestamp_free(at); moq_group_Consumer_free(reader); } span ns = end(start, (double)(groups * FRAMES * size), name); @@ -254,9 +253,7 @@ static void round_(int print) { /* Groups start where the frames before them left off, as moq's own bench keys them. */ uint64_t micros = 0; - moq_Timestamp *demanded_at = stamp(micros++); - moq_group_Producer *demanded = append_group(track, demanded_at); - moq_Timestamp_free(demanded_at); + moq_group_Producer *demanded = append_group(track, stamp(micros++)); moq_group_Demand *demand = moq_group_Producer_demand(demanded, NULL); start = begin(); for (int i = 0; i < N; i++) { @@ -313,13 +310,9 @@ static void round_(int print) { * group started at its first frame's. */ start = begin(); for (int g = 0; g < GROUPS; g++) { - moq_Timestamp *first = stamp(micros); - moq_group_Producer *group = append_group(track, first); - moq_Timestamp_free(first); + moq_group_Producer *group = append_group(track, stamp(micros)); for (int f = 0; f < FRAMES; f++) { - moq_Timestamp *at = stamp(micros++); - write_frame(group, at, frame); - moq_Timestamp_free(at); + write_frame(group, stamp(micros++), frame); } finish(group); } @@ -328,13 +321,12 @@ static void round_(int print) { /* Every frame at its group's start, converted once per group. */ start = begin(); for (int g = 0; g < GROUPS; g++) { - moq_Timestamp *at = stamp(micros++); + moq_Timestamp at = stamp(micros++); moq_group_Producer *group = append_group(track, at); for (int f = 0; f < FRAMES; f++) { write_frame(group, at, frame); } finish(group); - moq_Timestamp_free(at); } span write = end(start, N, "write"); @@ -351,7 +343,7 @@ static void round_(int print) { moq_frame_Frame *last = NULL; start = begin(); for (int g = 0; g < GROUPS; g++) { - moq_Timestamp *at = stamp(micros++); + moq_Timestamp at = stamp(micros++); moq_group_Producer *group = append_group(track, at); moq_group_Consumer *reader = recv_group(subscriber); for (int f = 0; f < FRAMES; f++) { @@ -362,7 +354,6 @@ static void round_(int print) { last = read_frame(reader); } finish(group); - moq_Timestamp_free(at); moq_group_Consumer_free(reader); } span ready = end(start, N, "ready"); @@ -370,7 +361,7 @@ static void round_(int print) { /* Each read polled before its frame is written, so it pends, then polled again. */ start = begin(); for (int g = 0; g < GROUPS; g++) { - moq_Timestamp *at = stamp(micros++); + moq_Timestamp at = stamp(micros++); moq_group_Producer *group = append_group(track, at); moq_group_Consumer *reader = recv_group(subscriber); for (int f = 0; f < FRAMES; f++) { @@ -387,7 +378,6 @@ static void round_(int print) { moq_frame_Frame_free(read); } finish(group); - moq_Timestamp_free(at); moq_group_Consumer_free(reader); } span woken = end(start, N, "woken"); diff --git a/ffi/moq/bench/export.dart b/ffi/moq/bench/export.dart index ac0d6356c..d6f7dab94 100644 --- a/ffi/moq/bench/export.dart +++ b/ffi/moq/bench/export.dart @@ -117,7 +117,6 @@ Future throughput(moq.TrackProducer track, moq.TrackSubscriber subscriber, reader.close(); group.finish().close(); group.close(); - at.close(); } final ns = end(start, name, count * frames * size); return Span(1e3 / ns.wall, 1e3 / ns.cpu); @@ -136,9 +135,7 @@ Future> round() async { } out['call'] = end(start, 'call'); - final demandedAt = groupStart(); - final demanded = track.appendGroup(demandedAt); - demandedAt.close(); + final demanded = track.appendGroup(groupStart()); final demand = demanded.demand(); start = begin(); for (var i = 0; i < n; i++) { @@ -190,13 +187,9 @@ Future> round() async { // Each frame stamped through a fresh timestamp, as a caller holding an int must. start = begin(); for (var g = 0; g < groups; g++) { - final first = moq.Timestamp.fromMicros(moq.U64(micros)); - final group = track.appendGroup(first); - first.close(); + final group = track.appendGroup(moq.Timestamp.fromMicros(moq.U64(micros))); for (var f = 0; f < frames; f++) { - final at = moq.Timestamp.fromMicros(moq.U64(micros++)); - group.writeFrame(at, frame); - at.close(); + group.writeFrame(moq.Timestamp.fromMicros(moq.U64(micros++)), frame); } group.finish().close(); group.close(); @@ -212,7 +205,6 @@ Future> round() async { } group.finish().close(); group.close(); - at.close(); } out['write'] = end(start, 'write'); @@ -236,7 +228,6 @@ Future> round() async { reader.close(); group.finish().close(); group.close(); - at.close(); } out['ready'] = end(start, 'ready'); @@ -255,7 +246,6 @@ Future> round() async { reader.close(); group.finish().close(); group.close(); - at.close(); } out['woken'] = end(start, 'woken'); @@ -274,7 +264,6 @@ Future> round() async { if (!await next.moveNext()) throw StateError('missing group acknowledgement'); group.finish().close(); group.close(); - at.close(); } await next.cancel(); } diff --git a/ffi/moq/bench/export.go b/ffi/moq/bench/export.go index 48c9dbf26..e9638685e 100644 --- a/ffi/moq/bench/export.go +++ b/ffi/moq/bench/export.go @@ -113,7 +113,6 @@ func throughput(ctx context.Context, track *net.TrackProducer, subscriber *net.T } reader.Close() must(group.Finish()).Close() - at.Close() } ns := end(start, name, count*frames*size) return span{1e3 / ns.wall, 1e3 / ns.cpu} @@ -188,10 +187,8 @@ func round(measured bool) []result { // Groups are keyed by their start, which must rise, so each starts at the next of // micros, the time its frames are stamped at. var micros uint64 - demandedAt := must(net.TimestampFromMicros(micros)) + demanded := must(track.AppendGroup(must(net.TimestampFromMicros(micros)))) micros++ - demanded := must(track.AppendGroup(demandedAt)) - demandedAt.Close() demand := must(demanded.Demand()) start = begin() for range n { @@ -253,14 +250,10 @@ func round(measured bool) []result { // Each frame stamped through a fresh timestamp, as a caller holding a u64 must. start = begin() for range groups { - groupAt := must(net.TimestampFromMicros(micros)) - group := must(track.AppendGroup(groupAt)) - groupAt.Close() + group := must(track.AppendGroup(must(net.TimestampFromMicros(micros)))) for range frames { - at := must(net.TimestampFromMicros(micros)) + check(group.WriteFrame(must(net.TimestampFromMicros(micros)), frame)) micros++ - check(group.WriteFrame(at, frame)) - at.Close() } must(group.Finish()).Close() } @@ -275,7 +268,6 @@ func round(measured bool) []result { check(group.WriteFrame(at, frame)) } must(group.Finish()).Close() - at.Close() } out = append(out, result{"write", end(start, "write", n)}) @@ -302,7 +294,6 @@ func round(measured bool) []result { } reader.Close() must(group.Finish()).Close() - at.Close() } out = append(out, result{"ready", end(start, "ready", n)}) @@ -323,7 +314,6 @@ func round(measured bool) []result { } reader.Close() must(group.Finish()).Close() - at.Close() } out = append(out, result{"woken", end(start, "woken", n)}) @@ -345,7 +335,6 @@ func round(measured bool) []result { } <-permits // Keep this group until its reader has consumed every frame. must(group.Finish()).Close() - at.Close() } }() for range groups { diff --git a/ffi/moq/bench/export.kt b/ffi/moq/bench/export.kt index 0a04f0977..11d4b3c93 100644 --- a/ffi/moq/bench/export.kt +++ b/ffi/moq/bench/export.kt @@ -109,7 +109,6 @@ suspend fun throughput(track: TrackProducer, subscriber: TrackSubscriber, next: } group.finish().close() } - at.close() } sink += sum val ns = end(start, name, groups.toDouble() * FRAMES * size) @@ -132,7 +131,7 @@ fun round(measured: Boolean): Map { repeat(N) { if (track.isClosed()) sum++ } out["call"] = end(start, "call") - next().use { track.appendGroup(it) }.use { group -> + track.appendGroup(next()).use { group -> group.demand().use { demand -> start = begin() repeat(N) { sum += demand.start().toInt() } @@ -181,9 +180,9 @@ fun round(measured: Boolean): Map { // group starting at its first frame's. start = begin() repeat(GROUPS) { - Timestamp.fromMicros(micros).use { track.appendGroup(it) }.use { group -> + track.appendGroup(Timestamp.fromMicros(micros)).use { group -> repeat(FRAMES) { - Timestamp.fromMicros(micros++).use { group.writeFrame(it, frame) } + group.writeFrame(Timestamp.fromMicros(micros++), frame) } group.finish().close() } @@ -197,7 +196,6 @@ fun round(measured: Boolean): Map { repeat(FRAMES) { group.writeFrame(at, frame) } group.finish().close() } - at.close() } out["write"] = end(start, "write") @@ -220,7 +218,6 @@ fun round(measured: Boolean): Map { } group.finish().close() } - at.close() } out["ready"] = end(t0, "ready") @@ -239,7 +236,6 @@ fun round(measured: Boolean): Map { } group.finish().close() } - at.close() } out["woken"] = end(t0, "woken") @@ -257,7 +253,6 @@ fun round(measured: Boolean): Map { permits.receive() group.finish().close() } - at.close() } } repeat(GROUPS) { diff --git a/ffi/moq/bench/export.ts b/ffi/moq/bench/export.ts index 06e9527bb..1f84e51f0 100644 --- a/ffi/moq/bench/export.ts +++ b/ffi/moq/bench/export.ts @@ -103,7 +103,7 @@ function finish(group: GroupProducer.GroupProducer): void { */ let micros = 0; -/** The next group's start, which its frames are stamped with too; the caller disposes it. */ +/** The next group's start, which its frames are stamped with too. */ function next(): Timestamp.Timestamp { return ok(Timestamp.fromMicros(micros++), "fromMicros"); } @@ -160,7 +160,6 @@ async function throughput( } reader[Symbol.dispose](); finish(group); - at[Symbol.dispose](); } const ns = end(start, `throughput[${size}]`, count * frames * size); return { wall: 1e3 / ns.wall, cpu: 1e3 / ns.cpu }; @@ -178,7 +177,6 @@ async function payload( const group = append(track, at); const reader = some(ok(await TrackSubscriber.recvGroup(subscriber), "recvGroup"), "recvGroup"); ok(GroupProducer.writeFrame(group, at, new Uint8Array(size)), "writeFrame"); - at[Symbol.dispose](); const read = some(ok(await GroupConsumer.readFrame(reader), "readFrame"), "readFrame"); reader[Symbol.dispose](); finish(group); @@ -207,9 +205,7 @@ async function round(): Promise> { } out.set("call", end(start, "call")); - const demandedAt = next(); - const demanded = append(track, demandedAt); - demandedAt[Symbol.dispose](); + const demanded = append(track, next()); const demand = GroupProducer.demand(demanded); start = begin(); for (let i = 0; i < n; i++) { @@ -234,13 +230,9 @@ async function round(): Promise> { // Each frame stamped through a fresh timestamp, as a caller holding a number must. start = begin(); for (let g = 0; g < groups; g++) { - const first = ok(Timestamp.fromMicros(micros), "fromMicros"); - const group = append(track, first); - first[Symbol.dispose](); + const group = append(track, ok(Timestamp.fromMicros(micros), "fromMicros")); for (let f = 0; f < frames; f++) { - const at = next(); - ok(GroupProducer.writeFrame(group, at, frame), "writeFrame"); - at[Symbol.dispose](); + ok(GroupProducer.writeFrame(group, next(), frame), "writeFrame"); } finish(group); } @@ -255,7 +247,6 @@ async function round(): Promise> { ok(GroupProducer.writeFrame(group, at, frame), "writeFrame"); } finish(group); - at[Symbol.dispose](); } out.set("write", end(start, "write")); @@ -278,7 +269,6 @@ async function round(): Promise> { } reader[Symbol.dispose](); finish(group); - at[Symbol.dispose](); } out.set("ready", end(start, "ready")); @@ -296,7 +286,6 @@ async function round(): Promise> { } reader[Symbol.dispose](); finish(group); - at[Symbol.dispose](); } out.set("woken", end(start, "woken")); @@ -314,7 +303,6 @@ async function round(): Promise> { // The reader's acknowledgement of the group, before the next. await permits.take(); finish(group); - at[Symbol.dispose](); } })(); for (let g = 0; g < groups; g++) { diff --git a/ffi/moq/moq.c b/ffi/moq/moq.c index cf65f7550..ed219f785 100644 --- a/ffi/moq/moq.c +++ b/ffi/moq/moq.c @@ -191,7 +191,7 @@ int main(void) { moq_group_Consumer *group = NULL; CHECK(moq_track_Subscriber_recv_group_poll(receiving, waker, &group, &err) == MOQ_POLL_PENDING); /* The track is untimed, so its group's start is a bare key, which frames reuse. */ - moq_Timestamp *key = moq_Timestamp_unscaled(0); + moq_Timestamp key = moq_Timestamp_unscaled(0); moq_group_Producer *writer = NULL; CHECK(moq_track_Producer_append_group(track, key, &writer, &err, NULL)); CHECK(wakes == 1); @@ -208,32 +208,29 @@ int main(void) { CHECK(moq_group_Consumer_read_frame_poll(reading, waker, &frame, &err) == MOQ_POLL_READY); moq_group_Consumer_read_frame_future_free(reading); CHECK(frame != NULL && is(moq_frame_Frame_payload_get(frame, NULL), "hello")); - moq_Timestamp *stamp = moq_frame_Frame_timestamp_get(frame, NULL); - CHECK(stamp != NULL && !moq_Timestamp_scale(stamp, NULL).some); - moq_Timestamp_free(stamp); + moq_Timestamp stamp = moq_frame_Frame_timestamp_get(frame, NULL); + CHECK(!moq_Timestamp_scale(&stamp).some); /* When it arrived: kio's clock's `Instant`, from kio's own export. */ moq_clock_Instant arrived = moq_frame_Frame_arrived(frame, NULL); moq_clock_Instant now = moq_clock_now(); CHECK(moq_clock_Instant_checked_duration_since(&now, arrived).some); moq_frame_Frame_free(frame); - /* A timestamp is lent to a call, which leaves it to C. The track is untimed, so a - * timed frame is refused. */ - moq_Timestamp *at = NULL; + /* A timestamp is copied into a call, which leaves C's as it was. The track is untimed, + * so a timed frame is refused. */ + moq_Timestamp at; moq_TimeOverflow overflow; uint64_t secs = 0; CHECK(moq_Timestamp_from_millis(1500, &at, &overflow)); - CHECK(moq_Timestamp_as_secs(at, &secs, &overflow, NULL) && secs == 1); + CHECK(moq_Timestamp_as_secs(&at, &secs, &overflow) && secs == 1); CHECK(!moq_group_Producer_write_frame(writer, at, str("late"), &err, NULL)); CHECK(err != NULL && is(moq_Error_to_string(err, NULL), "frame timestamp doesn't fit its track")); moq_Error_free(err); secs = 0; - CHECK(moq_Timestamp_as_secs(at, &secs, &overflow, NULL) && secs == 1); - moq_Timestamp_free(at); + CHECK(moq_Timestamp_as_secs(&at, &secs, &overflow) && secs == 1); /* The last frame, bytes that are not UTF-8, then the group's end, which reads as None. */ CHECK(moq_group_Producer_write_frame(writer, key, str("\xffworld"), &err, NULL)); - moq_Timestamp_free(key); moq_group_Finished *finished = NULL; CHECK(moq_group_Producer_finish(writer, &finished, &err, NULL)); moq_group_Finished_free(finished); @@ -470,10 +467,9 @@ int main(void) { moq_Json *latest = NULL; moq_buf json_err; CHECK(moq_Json_parse(str("{\"on\": true}"), &latest, &json_err)); - moq_Timestamp *updated = NULL; + moq_Timestamp updated; CHECK(moq_Timestamp_from_millis(1, &updated, &overflow)); CHECK(moq_mux_json_Snapshot_Json_update(status_snapshot, latest, updated, &mux_err, NULL)); - moq_Timestamp_free(updated); moq_Json_free(latest); moq_track_Subscriber *status_subscriber = moq_mux_json_Snapshot_Json_consume(status_snapshot, NULL); moq_track_Subscriber_recv_group_future *status_receiving = moq_track_Subscriber_recv_group(status_subscriber, NULL); @@ -617,11 +613,10 @@ int main(void) { moq_broadcast_Producer *live_broadcast = moq_origin_Route_broadcast(live); moq_track_Producer *live_track = NULL; CHECK(moq_broadcast_Producer_create_track(live_broadcast, str("video"), NULL, &live_track, &err, NULL)); - moq_Timestamp *live_key = moq_Timestamp_unscaled(0); + moq_Timestamp live_key = moq_Timestamp_unscaled(0); moq_group_Producer *live_group = NULL; CHECK(moq_track_Producer_append_group(live_track, live_key, &live_group, &err, NULL)); CHECK(moq_group_Producer_write_frame(live_group, live_key, str("hello"), &err, NULL)); - moq_Timestamp_free(live_key); moq_group_Finished *live_finished = NULL; CHECK(moq_group_Producer_finish(live_group, &live_finished, &err, NULL)); moq_group_Finished_free(live_finished); diff --git a/ffi/moq/moq.dart b/ffi/moq/moq.dart index 4823207d9..a2b1c7023 100644 --- a/ffi/moq/moq.dart +++ b/ffi/moq/moq.dart @@ -121,8 +121,8 @@ Future local() async { // When it arrived: kio's clock's `Instant`, from kio's own export. expect(moq.clockNow().checkedDurationSince(hello.arrived()) != null, 'a frame arrived before now'); - // A timestamp is a handle, which a call borrows and leaves usable. The track is untimed, - // so a timed frame is refused. + // A timestamp is a `Copy` value copied across, which allocates nothing. The track is + // untimed, so a timed frame is refused. final at = moq.Timestamp.fromMillis(moq.U64(1500)); expect(at.asSecs() == moq.U64(1), '1500 ms is 1 s'); throws( @@ -130,7 +130,7 @@ Future local() async { (e) => '$e' == "frame timestamp doesn't fit its track", "the late frame's error is Rust's", ); - expect(at.asSecs() == 1, 'a lent timestamp stays usable'); + expect(at.asSecs() == 1, 'a copied timestamp stays usable'); // The last frame, bytes that are not UTF-8, then the group's end, which reads as null. final world = [0xff, ...utf8.encode('world')]; diff --git a/ffi/moq/moq.go b/ffi/moq/moq.go index 270c50c9e..e67d29de0 100644 --- a/ffi/moq/moq.go +++ b/ffi/moq/moq.go @@ -162,14 +162,13 @@ func script() { // When it arrived: kio's clock's `Instant`, from kio's own export. expect(kio.ClockNow().CheckedDurationSince(must(hello.Arrived())) != nil, "a frame arrived before now") - // A timestamp is a handle a call borrows, so Go keeps it. The track is + // A timestamp is a `Copy` value Go copies, which allocates nothing. The track is // untimed, so a timed frame is refused. at := must(net.TimestampFromMillis(1500)) expect(must(at.AsSecs()) == 1, "1500 ms is 1 s") err = writer.WriteFrame(at, rt.NewBytes([]byte("late"))) expect(errors.As(err, &merr) && err.Error() == "frame timestamp doesn't fit its track", "the late frame's error is Rust's") - expect(must(at.AsSecs()) == 1, "a lent timestamp stays usable") - at.Close() + expect(must(at.AsSecs()) == 1, "a copied timestamp stays usable") // The last frame, bytes that are not UTF-8, then the group's end, which reads as nil. world := append([]byte{0xff}, "world"...) diff --git a/ffi/moq/moq.kt b/ffi/moq/moq.kt index e1d1a0cee..19ff21a8c 100644 --- a/ffi/moq/moq.kt +++ b/ffi/moq/moq.kt @@ -88,8 +88,8 @@ fun main() { // When it arrived: kio's clock's `Instant`, from kio's own export. expect(clockNow().checkedDurationSince(hello.arrived()) != null, "a frame arrived before now") - // A timestamp is a handle, which a call borrows and leaves usable. The track is untimed, - // so a timed frame is refused. + // A timestamp is a `Copy` value copied across, which allocates nothing. The track is + // untimed, so a timed frame is refused. val at = Timestamp.fromMillis(1500u) expect(at.asSecs() == 1uL, "1500 ms is 1 s") try { @@ -98,7 +98,7 @@ fun main() { } catch (e: ErrorException) { expect(e.message == "frame timestamp doesn't fit its track", "the late frame's error is Rust's") } - expect(at.asSecs() == 1uL, "a lent timestamp stays usable") + expect(at.asSecs() == 1uL, "a copied timestamp stays usable") // The last frame, bytes that are not UTF-8, then the group's end, which reads as null. val world = byteArrayOf(0xff.toByte()) + "world".encodeToByteArray() diff --git a/ffi/moq/moq.py b/ffi/moq/moq.py index 4ff6e52b0..ecaee06d3 100644 --- a/ffi/moq/moq.py +++ b/ffi/moq/moq.py @@ -85,8 +85,8 @@ def local(loop): # When it arrived: kio's clock's `Instant`, from kio's own export. expect(moq.clock_now().checked_duration_since(hello.arrived()) is not None, "a frame arrived before now") - # A timestamp is a handle, which a call borrows and leaves usable. The track is untimed, - # so a timed frame is refused. + # A timestamp is a `Copy` value copied across, which allocates nothing. The track is + # untimed, so a timed frame is refused. at = moq.Timestamp.from_millis(1500) expect(at.as_secs() == 1, "1500 ms is 1 s") try: @@ -94,7 +94,7 @@ def local(loop): expect(False, "a timed frame on an untimed track is an error") except moq.ErrorException as e: expect(str(e) == "frame timestamp doesn't fit its track", "the late frame's error is Rust's") - expect(at.as_secs() == 1, "a lent timestamp stays usable") + expect(at.as_secs() == 1, "a copied timestamp stays usable") # The last frame, bytes that are not UTF-8, then the group's end, which reads as None. world = b"\xffworld" diff --git a/ffi/moq/moq.swift b/ffi/moq/moq.swift index 2a8e344c7..620725224 100644 --- a/ffi/moq/moq.swift +++ b/ffi/moq/moq.swift @@ -252,8 +252,8 @@ func script() throws { // When it arrived: kio's clock's `Instant`, from kio's own export. expect(try clockNow().checkedDurationSince(hello.arrived()) != nil, "a frame arrived before now") - // A timestamp is a handle, which a call borrows and leaves usable. The track is untimed, - // so a timed frame is refused. + // A timestamp is a `Copy` value copied across, which allocates nothing. The track is + // untimed, so a timed frame is refused. let at = try Timestamp.fromMillis(1500) expect(try at.asSecs() == 1, "1500 ms is 1 s") do { @@ -262,7 +262,7 @@ func script() throws { } catch let e as Moq.Error { expect(try e.description == "frame timestamp doesn't fit its track", "the late frame's error is Rust's") } - expect(try at.asSecs() == 1, "a lent timestamp stays usable") + expect(try at.asSecs() == 1, "a copied timestamp stays usable") // The last frame, bytes that are not UTF-8, then the group's end, which reads as nil. let world = Bytes(Data([0xff]) + Data("world".utf8)) diff --git a/ffi/src/collect.rs b/ffi/src/collect.rs index 15505d2d0..b3964b337 100644 --- a/ffi/src/collect.rs +++ b/ffi/src/collect.rs @@ -6740,7 +6740,10 @@ fn links(tcx: TyCtxt<'_>) -> Vec { /// `rustc` picks at its size on this target: the bytes its fields always initialize fill /// it, so no field order leaves padding. The glue asserts the size, which is what lets /// another `rustc` build it; a type with padding, or bytes that depend on its value, such -/// as a union's or `Option`'s, is a handle instead. +/// as a union's or `Option`'s, is a handle instead. A variant without data that an +/// enum encodes in another's niche writes the niche's whole scalar, so `None` of +/// `Option>` initializes its 8 bytes, but `None` of `Option<&[u8]>` only the +/// pointer's word. /// /// The fields must also fill a model layout at each pointer width, 4 and 8 bytes, with each /// primitive aligned to its size. So every target decides alike, and adding one never @@ -6761,9 +6764,41 @@ fn full<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> bool { /// The fewest it initializes in the model at each of `WIDTHS`, and its alignment there. model: [u64; 2], align: [u64; 2], - /// Whether it may have a niche: invalid values an enum around it could encode - /// another variant in. - niche: bool, + /// Whether it may have a niche, invalid values an enum around it could encode + /// another variant in, and the fewest bytes the scalar holding one spans. + niche: Option, + } + /// The bytes of a niche's scalar, which a variant encoded in it writes whole: on this + /// target, and in the model at each of `WIDTHS`. + #[derive(Clone, Copy)] + struct Niche { + bytes: u64, + model: [u64; 2], + } + impl Niche { + /// The smaller of two niches, at each width alike. + fn min(self, other: Self) -> Self { + Self { + bytes: self.bytes.min(other.bytes), + model: [self.model[0].min(other.model[0]), self.model[1].min(other.model[1])], + } + } + /// A niche of `bytes` in a scalar of `least`, as rustc's layout gives it: a thin + /// pointer's whole word, or a wide one's first. + fn of(least: Least, bytes: u64) -> Option { + Some(Self { + bytes, + model: least.model.map(|model| model * bytes / least.bytes), + }) + .filter(|_| least.bytes > 0) + } + } + /// The smallest of two niches, either of which may be absent. + fn smaller(a: Option, b: Option) -> Option { + match (a, b) { + (Some(a), Some(b)) => Some(a.min(b)), + (a, b) => a.or(b), + } } // The fields of an aggregate, which never overlap: none when they leave the model a // gap, after them, as `(u64, u32)` does on a 64-bit target, or between them where its @@ -6786,12 +6821,12 @@ fn full<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> bool { bytes: 0, model: [0; 2], align: [repr.and_then(|r| r.align).map_or(1, |a| a.bytes()); 2], - niche: false, + niche: None, }; for &ty in tys { let field = least(tcx, env, ty)?; sum.bytes = sum.bytes.checked_add(field.bytes)?; - sum.niche |= field.niche; + sum.niche = smaller(sum.niche, field.niche); for w in 0..WIDTHS.len() { let align = pack.map_or(field.align[w], |pack| field.align[w].min(pack)); if ordered && !sum.model[w].is_multiple_of(align) { @@ -6812,24 +6847,34 @@ fn full<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> bool { fn least<'tcx>(tcx: TyCtxt<'tcx>, env: TypingEnv<'tcx>, ty: Ty<'tcx>) -> Option { let layout = tcx.layout_of(env.as_query_input(ty)).ok()?; let size = layout.size.bytes(); - let primitive = |niche| { + let primitive = |niche: bool| { Some(Least { bytes: size, model: [size; 2], align: [size.max(1); 2], - niche, + niche: niche.then_some(Niche { + bytes: size, + model: [size; 2], + }), }) }; - // A pointer is a width's bytes in the model, and a wide one two of them. - let pointer = |niche| { - let words = size / tcx.data_layout.pointer_size().bytes(); + // A pointer is a width's bytes in the model, and a wide one two of them, whose + // niche is its first. + let pointer = |niche: bool| { + let word = tcx.data_layout.pointer_size().bytes(); Some(Least { bytes: size, - model: WIDTHS.map(|width| width * words), + model: WIDTHS.map(|width| width * (size / word)), align: WIDTHS, - niche, + niche: niche.then_some(Niche { + bytes: word, + model: WIDTHS, + }), }) }; + // The niche rustc's layout gives a type whose own valid range makes one, as a + // pattern type's or `NonNull`'s does, within the scalar or pair `least` counts. + let ranged = |least: Least| Niche::of(least, layout.largest_niche?.value.size(&tcx).bytes()); let normalized = |fields: &mut dyn Iterator, args| { (fields.map(|field| { let field = field.ty(tcx, args).skip_norm_wip(); @@ -6843,17 +6888,20 @@ fn full<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> bool { ty::Ref(..) | ty::FnPtr(..) => pointer(true), ty::Int(_) | ty::Uint(_) | ty::Float(_) => primitive(false), ty::Bool | ty::Char => primitive(true), - ty::Pat(base, _) => Some(Least { - niche: true, - ..least(tcx, env, *base)? - }), + ty::Pat(base, _) => { + let base = least(tcx, env, *base)?; + Some(Least { + niche: smaller(base.niche, ranged(base)), + ..base + }) + } ty::Array(element, len) => { let n = len.try_to_target_usize(tcx)?; let each = least(tcx, env, *element)?; Some(Least { bytes: each.bytes.checked_mul(n)?, model: [each.model[0].checked_mul(n)?, each.model[1].checked_mul(n)?], - niche: each.niche && n > 0, + niche: each.niche.filter(|_| n > 0), ..each }) } @@ -6862,7 +6910,7 @@ fn full<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> bool { let sum = fields(tcx, env, &normalized(&mut adt.all_fields(), *args)?, Some(&adt.repr()))?; // A field's own valid range, as `NonNull`'s, is a niche no field shows. Some(Least { - niche: sum.niche || layout.largest_niche.is_some(), + niche: sum.niche.or_else(|| ranged(sum)), ..sum }) } @@ -6881,7 +6929,7 @@ fn full<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> bool { bytes: size, model, align: model, - niche: true, + niche: Some(Niche { bytes: size, model }), }); } let mut each = Vec::new(); @@ -6890,9 +6938,18 @@ fn full<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> bool { } // With no niche to encode the others in, two or more variants take a tag // of at least a byte beside each one's fields; with one, a variant's own - // fields may hold the tag, so they count alone. - let niche = each.iter().any(|v| v.niche); - let tag = u64::from(each.len() > 1 && !niche); + // fields may hold the tag, so they count alone, but for a variant without + // data, which an encoding in the niche writes whole. Should a `rustc` give + // it a tag instead, the enum is a byte past a variant whose fields fill it, + // so it is never full, and a wrong count here never reaches a value. + let niche = each.iter().filter_map(|v| v.niche).reduce(Niche::min); + let tag = u64::from(each.len() > 1 && niche.is_none()); + if let Some(niche) = niche.filter(|_| each.len() > 1) { + for v in each.iter_mut().filter(|v| v.bytes == 0 && v.model == [0; 2]) { + v.bytes = niche.bytes; + v.model = niche.model; + } + } let mut model = [0; 2]; let mut align = [1; 2]; for w in 0..WIDTHS.len() { @@ -6900,11 +6957,14 @@ fn full<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> bool { align[w] = each.iter().map(|v| v.align[w]).max().unwrap_or(1); } let bytes = each.iter().map(|v| v.bytes).min()?.checked_add(tag)?; + // A full enum is encoded in a variant's niche, whose scalar holds what values + // remain; any other's niche, a tag's or one only partly written, may be a byte. + let least = Niche { bytes: 1, model: [1; 2] }; filled(Least { bytes, model, align, - niche: true, + niche: Some(niche.filter(|_| bytes == size).unwrap_or(least)), }) } _ => None, diff --git a/ffi/surface/moq-web/web.d.ts b/ffi/surface/moq-web/web.d.ts index e7855956d..3fb5994c7 100644 --- a/ffi/surface/moq-web/web.d.ts +++ b/ffi/surface/moq-web/web.d.ts @@ -1149,12 +1149,11 @@ import * as rt from "./rt.ts"; import type { ClockWall } from "./ClockWall.ts"; import type { HangError } from "./HangError.ts"; import type { Timestamp } from "./Timestamp.ts"; -export type HangCatalogClock = rt.Handle<"HangCatalogClock">; +export type HangCatalogClock = rt.Opaque<"HangCatalogClock">; export declare function debug(self: HangCatalogClock): string; -export declare function clone(self: HangCatalogClock): HangCatalogClock; export declare function eq(a: HangCatalogClock, b: HangCatalogClock): boolean; export declare function wallGet(self: HangCatalogClock): Timestamp; -export declare function wallSet(self: HangCatalogClock, value: Timestamp): void; +export declare function wallSet(self: HangCatalogClock, value: Timestamp): HangCatalogClock; export declare function new$(wall: Timestamp): rt.Result; export declare function wallClock(self: HangCatalogClock, pts: Timestamp): rt.Result; export { new$ as new }; @@ -8718,9 +8717,8 @@ export { new$ as new }; import * as rt from "./rt.ts"; import type { TimeOverflow } from "./TimeOverflow.ts"; import type { Timescale } from "./Timescale.ts"; -export type Timestamp = rt.Handle<"Timestamp">; +export type Timestamp = rt.Opaque<"Timestamp">; export declare function debug(self: Timestamp): string; -export declare function clone(self: Timestamp): Timestamp; export declare function eq(a: Timestamp, b: Timestamp): boolean; export declare function hash(self: Timestamp): rt.u64; export declare function ZERO(): Timestamp; @@ -9132,13 +9130,12 @@ export { default$ as default }; // TransportLimits.ts import * as rt from "./rt.ts"; -export type TransportLimits = rt.Handle<"TransportLimits">; +export type TransportLimits = rt.Opaque<"TransportLimits">; export declare function debug(self: TransportLimits): string; -export declare function clone(self: TransportLimits): TransportLimits; export declare function eq(a: TransportLimits, b: TransportLimits): boolean; export declare function default$(): TransportLimits; export declare function receiveWindowGet(self: TransportLimits): rt.u64 | undefined; -export declare function receiveWindowSet(self: TransportLimits, value: rt.u64 | undefined): void; +export declare function receiveWindowSet(self: TransportLimits, value: rt.u64 | undefined): TransportLimits; export { default$ as default }; // TransportLimitsError.ts @@ -9224,14 +9221,13 @@ export { default$ as default, new$ as new }; // TransportReceiveWindow.ts import * as rt from "./rt.ts"; -export type TransportReceiveWindow = rt.Handle<"TransportReceiveWindow">; +export type TransportReceiveWindow = rt.Opaque<"TransportReceiveWindow">; export declare function debug(self: TransportReceiveWindow): string; -export declare function clone(self: TransportReceiveWindow): TransportReceiveWindow; export declare function eq(a: TransportReceiveWindow, b: TransportReceiveWindow): boolean; export declare function connectionGet(self: TransportReceiveWindow): rt.u64 | undefined; -export declare function connectionSet(self: TransportReceiveWindow, value: rt.u64 | undefined): void; +export declare function connectionSet(self: TransportReceiveWindow, value: rt.u64 | undefined): TransportReceiveWindow; export declare function streamGet(self: TransportReceiveWindow): rt.u64; -export declare function streamSet(self: TransportReceiveWindow, value: rt.u64): void; +export declare function streamSet(self: TransportReceiveWindow, value: rt.u64): TransportReceiveWindow; export declare function new$(connection: rt.u64 | undefined, stream: rt.u64): TransportReceiveWindow; export { new$ as new }; @@ -9350,6 +9346,7 @@ import type { HangCatalogAudioLayout } from "./HangCatalogAudioLayout.ts"; import type { HangCatalogAv1 } from "./HangCatalogAv1.ts"; import type { HangCatalogBinaryConfig } from "./HangCatalogBinaryConfig.ts"; import type { HangCatalogChromaticity } from "./HangCatalogChromaticity.ts"; +import type { HangCatalogClock } from "./HangCatalogClock.ts"; import type { HangCatalogColorRange } from "./HangCatalogColorRange.ts"; import type { HangCatalogContentLight } from "./HangCatalogContentLight.ts"; import type { HangCatalogDisplay } from "./HangCatalogDisplay.ts"; @@ -9482,9 +9479,11 @@ import type { TrackSubscriber } from "./TrackSubscriber.ts"; import type { TrackSubscription } from "./TrackSubscription.ts"; import type { TransportAddress } from "./TransportAddress.ts"; import type { TransportCloseKind } from "./TransportCloseKind.ts"; +import type { TransportLimits } from "./TransportLimits.ts"; import type { TransportLimitsError } from "./TransportLimitsError.ts"; import type { TransportMemoryError } from "./TransportMemoryError.ts"; import type { TransportPollAcked } from "./TransportPollAcked.ts"; +import type { TransportReceiveWindow } from "./TransportReceiveWindow.ts"; import type { Version } from "./Version.ts"; import type { Waiter } from "./Waiter.ts"; export declare function e_EncodeError(v: EncodeError): number; @@ -9578,7 +9577,6 @@ export declare const k_Patterns: rt.Kind; export declare const k_Server: rt.Kind; export declare const k_Session: rt.Kind; export declare const k_Specificity: rt.Kind; -export declare const k_Timestamp: rt.Kind; export declare const k_Url: rt.Kind; export declare const k_Version: rt.Kind; export declare const k_Versions: rt.Kind; @@ -9647,7 +9645,6 @@ export declare const k_hang_catalog_Audio: rt.Kind; export declare const k_hang_catalog_AudioConfig: rt.Kind; export declare const k_hang_catalog_Binary: rt.Kind; export declare const k_hang_catalog_BinaryConfig: rt.Kind; -export declare const k_hang_catalog_Clock: rt.Kind; export declare const k_hang_catalog_Color: rt.Kind; export declare const k_hang_catalog_Consumer: rt.Kind; export declare const k_hang_catalog_Container: rt.Kind; @@ -9931,9 +9928,7 @@ export declare const k_track_Request: rt.Kind; export declare const k_track_Requests: rt.Kind; export declare const k_track_Subscriber: rt.Kind; export declare const k_track_Subscription: rt.Kind; -export declare const k_transport_Limits: rt.Kind; export declare const k_transport_Probe: rt.Kind; -export declare const k_transport_ReceiveWindow: rt.Kind; export declare const k_transport_Wire: rt.Kind; export declare const k_transport_memory_Closer: rt.Kind; export declare const k_transport_memory_Config: rt.Kind; @@ -10089,6 +10084,7 @@ export declare function r_SessionError(p: number, o: boolean): SessionError; export declare function r_StreamError(p: number, o: boolean): StreamError; export declare function r_TimeOverflow(p: number, o: boolean): TimeOverflow; export declare function r_Timescale(p: number, o: boolean): Timescale; +export declare function r_Timestamp(p: number, o: boolean): Timestamp; export declare function r_bandwidth_Rate(p: number, o: boolean): BandwidthRate; export declare function r_clock_Elapsed(p: number, o: boolean): ClockElapsed; export declare function r_clock_Instant(p: number, o: boolean): ClockInstant; @@ -10099,6 +10095,7 @@ export declare function r_hang_catalog_AV1(p: number, o: boolean): HangCatalogAv export declare function r_hang_catalog_AudioCodec(p: number, o: boolean): HangCatalogAudioCodec; export declare function r_hang_catalog_AudioLayout(p: number, o: boolean): HangCatalogAudioLayout; export declare function r_hang_catalog_Chromaticity(p: number, o: boolean): HangCatalogChromaticity; +export declare function r_hang_catalog_Clock(p: number, o: boolean): HangCatalogClock; export declare function r_hang_catalog_ContentLight(p: number, o: boolean): HangCatalogContentLight; export declare function r_hang_catalog_Display(p: number, o: boolean): HangCatalogDisplay; export declare function r_hang_catalog_H264(p: number, o: boolean): HangCatalogH264; @@ -10129,6 +10126,7 @@ export declare function r_mux_rate_Target(p: number, o: boolean): MuxRateTarget; export declare function r_option_SessionError(p: number, o: boolean): SessionError | undefined; export declare function r_option_StreamError(p: number, o: boolean): StreamError | undefined; export declare function r_option_Timescale(p: number, o: boolean): Timescale | undefined; +export declare function r_option_Timestamp(p: number, o: boolean): Timestamp | undefined; export declare function r_option_bandwidth_Rate(p: number, o: boolean): BandwidthRate | undefined; export declare function r_option_bool(p: number, o: boolean): boolean | undefined; export declare function r_option_clock_Instant(p: number, o: boolean): ClockInstant | undefined; @@ -10137,6 +10135,7 @@ export declare function r_option_datagram_Datagram(p: number, o: boolean): Datag export declare function r_option_duration(p: number, o: boolean): rt.Duration | undefined; export declare function r_option_f64(p: number, o: boolean): number | undefined; export declare function r_option_hang_catalog_AudioLayout(p: number, o: boolean): HangCatalogAudioLayout | undefined; +export declare function r_option_hang_catalog_Clock(p: number, o: boolean): HangCatalogClock | undefined; export declare function r_option_hang_catalog_ColorRange(p: number, o: boolean): HangCatalogColorRange | undefined; export declare function r_option_hang_catalog_ContentLight(p: number, o: boolean): HangCatalogContentLight | undefined; export declare function r_option_hang_catalog_Display(p: number, o: boolean): HangCatalogDisplay | undefined; @@ -10182,6 +10181,8 @@ export declare function r_track_Anchor(p: number, o: boolean): TrackAnchor; export declare function r_track_Delay(p: number, o: boolean): TrackDelay; export declare function r_track_Position(p: number, o: boolean): TrackPosition; export declare function r_track_Range(p: number, o: boolean): TrackRange; +export declare function r_transport_Limits(p: number, o: boolean): TransportLimits; +export declare function r_transport_ReceiveWindow(p: number, o: boolean): TransportReceiveWindow; export declare function r_tuple_stats_Tier_stats_Activity(p: number, o: boolean): [StatsTier, StatsActivity]; export declare function r_tuple_stats_Tier_stats_Message_stats_Totals(p: number, o: boolean): [StatsTier, StatsMessage, StatsTotals]; export declare function r_tuple_stats_Tier_stats_Presence(p: number, o: boolean): [StatsTier, StatsPresence]; @@ -10258,6 +10259,7 @@ export declare function w_SessionError(p: number, v: SessionError): void; export declare function w_StreamError(p: number, v: StreamError): void; export declare function w_TimeOverflow(p: number, v: TimeOverflow): void; export declare function w_Timescale(p: number, v: Timescale): void; +export declare function w_Timestamp(p: number, v: Timestamp): void; export declare function w_bandwidth_Rate(p: number, v: BandwidthRate): void; export declare function w_bound_u64(p: number, v: { readonly tag: "Included"; @@ -10299,6 +10301,7 @@ export declare function w_hang_catalog_AV1(p: number, v: HangCatalogAv1): void; export declare function w_hang_catalog_AudioCodec(p: number, v: HangCatalogAudioCodec): void; export declare function w_hang_catalog_AudioLayout(p: number, v: HangCatalogAudioLayout): void; export declare function w_hang_catalog_Chromaticity(p: number, v: HangCatalogChromaticity): void; +export declare function w_hang_catalog_Clock(p: number, v: HangCatalogClock): void; export declare function w_hang_catalog_ContentLight(p: number, v: HangCatalogContentLight): void; export declare function w_hang_catalog_Display(p: number, v: HangCatalogDisplay): void; export declare function w_hang_catalog_H264(p: number, v: HangCatalogH264): void; @@ -10333,12 +10336,14 @@ export declare function w_mux_container_ts_Step(p: number, v: MuxContainerTsStep export declare function w_mux_import_Format(p: number, v: MuxImportFormat): void; export declare function w_mux_rate_Target(p: number, v: MuxRateTarget): void; export declare function w_option_Timescale(p: number, v: Timescale | undefined): void; +export declare function w_option_Timestamp(p: number, v: Timestamp | undefined): void; export declare function w_option_bandwidth_Rate(p: number, v: BandwidthRate | undefined): void; export declare function w_option_bool(p: number, v: boolean | undefined): void; export declare function w_option_clock_Instant(p: number, v: ClockInstant | undefined): void; export declare function w_option_duration(p: number, v: rt.Duration | undefined): void; export declare function w_option_f64(p: number, v: number | undefined): void; export declare function w_option_hang_catalog_AudioLayout(p: number, v: HangCatalogAudioLayout | undefined): void; +export declare function w_option_hang_catalog_Clock(p: number, v: HangCatalogClock | undefined): void; export declare function w_option_hang_catalog_ColorRange(p: number, v: HangCatalogColorRange | undefined): void; export declare function w_option_hang_catalog_ContentLight(p: number, v: HangCatalogContentLight | undefined): void; export declare function w_option_hang_catalog_Display(p: number, v: HangCatalogDisplay | undefined): void; @@ -10376,7 +10381,9 @@ export declare function w_track_Anchor(p: number, v: TrackAnchor): void; export declare function w_track_Delay(p: number, v: TrackDelay): void; export declare function w_track_Position(p: number, v: TrackPosition): void; export declare function w_track_Range(p: number, v: TrackRange): void; +export declare function w_transport_Limits(p: number, v: TransportLimits): void; export declare function w_transport_LimitsError(p: number, v: TransportLimitsError): void; +export declare function w_transport_ReceiveWindow(p: number, v: TransportReceiveWindow): void; export declare function w_transport_memory_Error(p: number, v: TransportMemoryError): void; export declare function w_tuple_string_Json(p: number, v: [string, Json]): void; export declare function w_tuple_string_hang_catalog_AudioConfig(p: number, v: [string, HangCatalogAudioConfig]): void; diff --git a/ffi/surface/moq/c.h b/ffi/surface/moq/c.h index 3120435e1..8a0fe5405 100644 --- a/ffi/surface/moq/c.h +++ b/ffi/surface/moq/c.h @@ -7,7 +7,7 @@ #ifdef __cplusplus extern "C" { #endif -#define MOQ_CONTRACT ((uint64_t)0x4e64edc3aadb27fcULL) +#define MOQ_CONTRACT ((uint64_t)0x3b5f5e9ca073b2a1ULL) uint64_t moq_contract(void); uint32_t moq_target(void); typedef int32_t moq_status; @@ -102,7 +102,6 @@ typedef struct moq_Server moq_Server; typedef struct moq_Session moq_Session; typedef struct moq_Client moq_Client; typedef struct moq_Error moq_Error; -typedef struct moq_Timestamp moq_Timestamp; typedef struct moq_Version moq_Version; typedef struct moq_Versions moq_Versions; typedef struct moq_Specificity moq_Specificity; @@ -167,8 +166,6 @@ typedef struct moq_stats_Session moq_stats_Session; typedef struct moq_stats_Bill moq_stats_Bill; typedef struct moq_transport_Wire moq_transport_Wire; typedef struct moq_transport_Probe moq_transport_Probe; -typedef struct moq_transport_ReceiveWindow moq_transport_ReceiveWindow; -typedef struct moq_transport_Limits moq_transport_Limits; typedef struct moq_bandwidth_Limit moq_bandwidth_Limit; typedef struct moq_bandwidth_Demand moq_bandwidth_Demand; typedef struct moq_bandwidth_Reservation moq_bandwidth_Reservation; @@ -245,7 +242,6 @@ typedef struct moq_hang_catalog_Audio moq_hang_catalog_Audio; typedef struct moq_hang_catalog_AudioConfig moq_hang_catalog_AudioConfig; typedef struct moq_hang_catalog_Binary moq_hang_catalog_Binary; typedef struct moq_hang_catalog_BinaryConfig moq_hang_catalog_BinaryConfig; -typedef struct moq_hang_catalog_Clock moq_hang_catalog_Clock; typedef struct moq_hang_catalog_Container moq_hang_catalog_Container; typedef struct moq_hang_catalog_Echo moq_hang_catalog_Echo; typedef struct moq_hang_catalog_Include moq_hang_catalog_Include; @@ -858,8 +854,11 @@ typedef struct moq_vec_Segment { void *owner; } moq_vec_Segment; void moq_vec_Segment_free(moq_vec_Segment vec); +typedef struct moq_Timestamp { + uint64_t opaque[2]; +} moq_Timestamp; typedef struct moq_vec_Timestamp { - moq_Timestamp *const *ptr; + const moq_Timestamp *ptr; size_t len; void *owner; } moq_vec_Timestamp; @@ -924,9 +923,13 @@ typedef struct moq_vec_moq_tokio_connect_Addr { void *owner; } moq_vec_moq_tokio_connect_Addr; void moq_vec_moq_tokio_connect_Addr_free(moq_vec_moq_tokio_connect_Addr vec); +typedef struct moq_option_Timestamp { + bool some; + moq_Timestamp value; +} moq_option_Timestamp; typedef struct moq_mux_container_Frame { - moq_Timestamp *timestamp; - moq_Timestamp *duration; + moq_Timestamp timestamp; + moq_option_Timestamp duration; moq_buf payload; bool keyframe; } moq_mux_container_Frame; @@ -1407,7 +1410,7 @@ typedef struct moq_option_clock_Wall { } moq_option_clock_Wall; typedef struct moq_datagram_Datagram { uint64_t sequence; - moq_Timestamp *timestamp; + moq_Timestamp timestamp; moq_buf payload; } moq_datagram_Datagram; typedef struct moq_option_datagram_Datagram { @@ -1439,6 +1442,13 @@ typedef struct moq_option_hang_catalog_AudioLayout { bool some; moq_hang_catalog_AudioLayout value; } moq_option_hang_catalog_AudioLayout; +typedef struct moq_hang_catalog_Clock { + uint64_t opaque[2]; +} moq_hang_catalog_Clock; +typedef struct moq_option_hang_catalog_Clock { + bool some; + moq_hang_catalog_Clock value; +} moq_option_hang_catalog_Clock; typedef struct moq_option_hang_catalog_ColorRange { bool some; moq_hang_catalog_ColorRange value; @@ -1642,12 +1652,12 @@ typedef struct moq_mux_container_Read_Frame { moq_mux_container_Frame frame; } moq_mux_container_Read_Frame; typedef struct moq_mux_container_Read_Gap { - moq_Timestamp *timestamp; - moq_Timestamp *duration; + moq_Timestamp timestamp; + moq_Timestamp duration; } moq_mux_container_Read_Gap; typedef struct moq_mux_container_Read_End { uint64_t group; - moq_Timestamp *end; + moq_Timestamp end; } moq_mux_container_Read_End; typedef struct moq_mux_container_Read { moq_mux_container_Read_tag tag; @@ -1826,9 +1836,15 @@ typedef struct moq_stats_Routes { typedef struct moq_stats_Withdrawals { uint64_t opaque[2]; } moq_stats_Withdrawals; +typedef struct moq_transport_ReceiveWindow { + uint64_t opaque[2]; +} moq_transport_ReceiveWindow; +typedef struct moq_transport_Limits { + uint64_t opaque[1]; +} moq_transport_Limits; typedef struct moq_frame_Info { uint64_t size; - moq_Timestamp *timestamp; + moq_Timestamp timestamp; } moq_frame_Info; typedef struct moq_group_Info { uint64_t start; @@ -1850,12 +1866,12 @@ typedef struct moq_hang_catalog_Priorities { uint8_t opaque[4]; } moq_hang_catalog_Priorities; typedef struct moq_hang_container_Frame { - moq_Timestamp *timestamp; + moq_Timestamp timestamp; moq_buf payload; } moq_hang_container_Frame; typedef struct moq_mux_container_TimestampRewind { - moq_Timestamp *timestamp; - moq_Timestamp *floor; + moq_Timestamp timestamp; + moq_Timestamp floor; } moq_mux_container_TimestampRewind; typedef struct moq_mux_container_Playout { moq_track_Delay delay; @@ -2332,6 +2348,28 @@ moq_Timescale moq_Timescale_MICRO(void); moq_Timescale moq_Timescale_NANO(void); bool moq_Timescale_new(uint64_t units_per_second, moq_Timescale *out, moq_TimeOverflow *err); uint64_t moq_Timescale_as_u64(const moq_Timescale *self); +bool moq_Timestamp_eq(const moq_Timestamp *a, const moq_Timestamp *b); +uint64_t moq_Timestamp_hash(const moq_Timestamp *self); +moq_buf moq_Timestamp_debug(const moq_Timestamp *self); +moq_Timestamp moq_Timestamp_ZERO(void); +bool moq_Timestamp_new(uint64_t value, moq_Timescale scale, moq_Timestamp *out, moq_TimeOverflow *err); +moq_Timestamp moq_Timestamp_unscaled(uint64_t key); +bool moq_Timestamp_from_scale(uint64_t value, uint64_t units_per_second, moq_Timestamp *out, moq_TimeOverflow *err); +bool moq_Timestamp_from_secs(uint64_t seconds, moq_Timestamp *out, moq_TimeOverflow *err); +bool moq_Timestamp_from_millis(uint64_t millis, moq_Timestamp *out, moq_TimeOverflow *err); +bool moq_Timestamp_from_micros(uint64_t micros, moq_Timestamp *out, moq_TimeOverflow *err); +bool moq_Timestamp_from_nanos(uint64_t nanos, moq_Timestamp *out, moq_TimeOverflow *err); +uint64_t moq_Timestamp_value(const moq_Timestamp *self); +moq_option_Timescale moq_Timestamp_scale(const moq_Timestamp *self); +bool moq_Timestamp_is_zero(const moq_Timestamp *self); +bool moq_Timestamp_convert(const moq_Timestamp *self, moq_Timescale new_scale, moq_Timestamp *out, moq_TimeOverflow *err); +bool moq_Timestamp_as_scale(const moq_Timestamp *self, moq_Timescale target, moq_u128 *out, moq_TimeOverflow *err); +bool moq_Timestamp_as_secs(const moq_Timestamp *self, uint64_t *out, moq_TimeOverflow *err); +bool moq_Timestamp_as_millis(const moq_Timestamp *self, moq_u128 *out, moq_TimeOverflow *err); +bool moq_Timestamp_as_micros(const moq_Timestamp *self, moq_u128 *out, moq_TimeOverflow *err); +bool moq_Timestamp_as_nanos(const moq_Timestamp *self, moq_u128 *out, moq_TimeOverflow *err); +bool moq_Timestamp_checked_add(const moq_Timestamp *self, moq_Timestamp rhs, moq_Timestamp *out, moq_TimeOverflow *err); +bool moq_Timestamp_checked_sub(const moq_Timestamp *self, moq_Timestamp rhs, moq_Timestamp *out, moq_TimeOverflow *err); bool moq_clock_Instant_eq(const moq_clock_Instant *a, const moq_clock_Instant *b); uint64_t moq_clock_Instant_hash(const moq_clock_Instant *self); moq_buf moq_clock_Instant_debug(const moq_clock_Instant *self); @@ -2556,6 +2594,18 @@ uint64_t moq_stats_Withdrawals_count(const moq_stats_Withdrawals *self, moq_stat uint64_t moq_stats_Withdrawals_total(const moq_stats_Withdrawals *self); void moq_stats_Withdrawals_add(moq_stats_Withdrawals *self, moq_stats_Withdrawals other); bool moq_stats_Withdrawals_regressed(const moq_stats_Withdrawals *self, moq_stats_Withdrawals previous); +bool moq_transport_ReceiveWindow_eq(const moq_transport_ReceiveWindow *a, const moq_transport_ReceiveWindow *b); +moq_buf moq_transport_ReceiveWindow_debug(const moq_transport_ReceiveWindow *self); +moq_option_non_zero_u64 moq_transport_ReceiveWindow_connection_get(const moq_transport_ReceiveWindow *self); +void moq_transport_ReceiveWindow_connection_set(moq_transport_ReceiveWindow *self, moq_option_non_zero_u64 value); +uint64_t moq_transport_ReceiveWindow_stream_get(const moq_transport_ReceiveWindow *self); +void moq_transport_ReceiveWindow_stream_set(moq_transport_ReceiveWindow *self, uint64_t value); +moq_transport_ReceiveWindow moq_transport_ReceiveWindow_new(moq_option_non_zero_u64 connection, uint64_t stream); +bool moq_transport_Limits_eq(const moq_transport_Limits *a, const moq_transport_Limits *b); +moq_buf moq_transport_Limits_debug(const moq_transport_Limits *self); +moq_transport_Limits moq_transport_Limits_default(void); +moq_option_non_zero_u64 moq_transport_Limits_receive_window_get(const moq_transport_Limits *self); +void moq_transport_Limits_receive_window_set(moq_transport_Limits *self, moq_option_non_zero_u64 value); bool moq_bandwidth_Rate_eq(const moq_bandwidth_Rate *a, const moq_bandwidth_Rate *b); uint64_t moq_bandwidth_Rate_hash(const moq_bandwidth_Rate *self); moq_buf moq_bandwidth_Rate_debug(const moq_bandwidth_Rate *self); @@ -2568,10 +2618,10 @@ uint64_t moq_bandwidth_Rate_as_bps(const moq_bandwidth_Rate *self); moq_bandwidth_Rate moq_bandwidth_Rate_scaled(const moq_bandwidth_Rate *self, double factor); moq_bandwidth_Rate moq_bandwidth_Rate_abs_diff(const moq_bandwidth_Rate *self, moq_bandwidth_Rate other); void moq_datagram_Datagram_free(moq_datagram_Datagram *self); -bool moq_datagram_Datagram_eq(const moq_datagram_Datagram *a, const moq_datagram_Datagram *b, moq_status *status); -moq_buf moq_datagram_Datagram_debug(const moq_datagram_Datagram *self, moq_status *status); +bool moq_datagram_Datagram_eq(const moq_datagram_Datagram *a, const moq_datagram_Datagram *b); +moq_buf moq_datagram_Datagram_debug(const moq_datagram_Datagram *self); void moq_frame_Info_free(moq_frame_Info *self); -moq_buf moq_frame_Info_debug(const moq_frame_Info *self, moq_status *status); +moq_buf moq_frame_Info_debug(const moq_frame_Info *self); void moq_group_Info_free(moq_group_Info *self); bool moq_group_Info_eq(const moq_group_Info *a, const moq_group_Info *b); uint64_t moq_group_Info_hash(const moq_group_Info *self); @@ -2613,6 +2663,12 @@ void moq_hang_catalog_AAC_free(moq_hang_catalog_AAC *self); bool moq_hang_catalog_AAC_eq(const moq_hang_catalog_AAC *a, const moq_hang_catalog_AAC *b); moq_buf moq_hang_catalog_AAC_to_string(const moq_hang_catalog_AAC *self); moq_buf moq_hang_catalog_AAC_debug(const moq_hang_catalog_AAC *self); +bool moq_hang_catalog_Clock_eq(const moq_hang_catalog_Clock *a, const moq_hang_catalog_Clock *b); +moq_buf moq_hang_catalog_Clock_debug(const moq_hang_catalog_Clock *self); +moq_Timestamp moq_hang_catalog_Clock_wall_get(const moq_hang_catalog_Clock *self); +void moq_hang_catalog_Clock_wall_set(moq_hang_catalog_Clock *self, moq_Timestamp value); +bool moq_hang_catalog_Clock_new(moq_Timestamp wall, moq_hang_catalog_Clock *out, moq_hang_Error **err); +bool moq_hang_catalog_Clock_wall_clock(const moq_hang_catalog_Clock *self, moq_Timestamp pts, moq_clock_Wall *out, moq_hang_Error **err); bool moq_hang_catalog_Priorities_eq(const moq_hang_catalog_Priorities *a, const moq_hang_catalog_Priorities *b); moq_buf moq_hang_catalog_Priorities_debug(const moq_hang_catalog_Priorities *self); int8_t moq_hang_catalog_Priorities_catalog_get(const moq_hang_catalog_Priorities *self); @@ -2655,16 +2711,16 @@ void moq_hang_catalog_Display_free(moq_hang_catalog_Display *self); bool moq_hang_catalog_Display_eq(const moq_hang_catalog_Display *a, const moq_hang_catalog_Display *b); moq_buf moq_hang_catalog_Display_debug(const moq_hang_catalog_Display *self); void moq_hang_container_Frame_free(moq_hang_container_Frame *self); -moq_buf moq_hang_container_Frame_debug(const moq_hang_container_Frame *self, moq_status *status); -bool moq_hang_container_Frame_encode(const moq_hang_container_Frame *self, moq_buf buf, moq_buf *buf_out, moq_hang_Error **err, moq_status *status); +moq_buf moq_hang_container_Frame_debug(const moq_hang_container_Frame *self); +bool moq_hang_container_Frame_encode(const moq_hang_container_Frame *self, moq_buf buf, moq_buf *buf_out, moq_hang_Error **err); bool moq_hang_container_Frame_decode(moq_buf buf, moq_hang_container_Frame *out, moq_hang_Error **err); bool moq_hang_container_Frame_write_to(const moq_hang_container_Frame *self, moq_group_Producer *group, moq_hang_Error **err, moq_status *status); void moq_mux_container_Frame_free(moq_mux_container_Frame *self); -moq_buf moq_mux_container_Frame_debug(const moq_mux_container_Frame *self, moq_status *status); +moq_buf moq_mux_container_Frame_debug(const moq_mux_container_Frame *self); void moq_mux_container_TimestampRewind_free(moq_mux_container_TimestampRewind *self); -bool moq_mux_container_TimestampRewind_eq(const moq_mux_container_TimestampRewind *a, const moq_mux_container_TimestampRewind *b, moq_status *status); -moq_buf moq_mux_container_TimestampRewind_to_string(const moq_mux_container_TimestampRewind *self, moq_status *status); -moq_buf moq_mux_container_TimestampRewind_debug(const moq_mux_container_TimestampRewind *self, moq_status *status); +bool moq_mux_container_TimestampRewind_eq(const moq_mux_container_TimestampRewind *a, const moq_mux_container_TimestampRewind *b); +moq_buf moq_mux_container_TimestampRewind_to_string(const moq_mux_container_TimestampRewind *self); +moq_buf moq_mux_container_TimestampRewind_debug(const moq_mux_container_TimestampRewind *self); void moq_mux_container_Playout_free(moq_mux_container_Playout *self); bool moq_mux_container_Playout_eq(const moq_mux_container_Playout *a, const moq_mux_container_Playout *b); moq_buf moq_mux_container_Playout_debug(const moq_mux_container_Playout *self); @@ -2876,7 +2932,7 @@ moq_option_mux_catalog_CatalogFormat moq_mux_catalog_CatalogFormat_detect(moq_bu bool moq_mux_container_Kind_eq(const moq_mux_container_Kind *a, const moq_mux_container_Kind *b); moq_buf moq_mux_container_Kind_debug(const moq_mux_container_Kind *self); void moq_mux_container_Read_free(moq_mux_container_Read *self); -moq_buf moq_mux_container_Read_debug(const moq_mux_container_Read *self, moq_status *status); +moq_buf moq_mux_container_Read_debug(const moq_mux_container_Read *self); void moq_mux_container_ReorderError_free(moq_mux_container_ReorderError *self); bool moq_mux_container_ReorderError_eq(const moq_mux_container_ReorderError *a, const moq_mux_container_ReorderError *b); moq_buf moq_mux_container_ReorderError_to_string(const moq_mux_container_ReorderError *self); @@ -3219,32 +3275,6 @@ moq_option_StreamError moq_Error_stream(const moq_Error *self, moq_status *statu moq_Error *moq_Error_from_transport_Error(moq_Error *err_, moq_status *status); moq_Error *moq_Error_from_transport_memory_Error(moq_transport_memory_Error err_); moq_Retry moq_Error_retry(const moq_Error *self, moq_status *status); -void moq_Timestamp_free(moq_Timestamp *self); -void moq_Timestamp_drop(moq_Timestamp *self, moq_status *status); -bool moq_Timestamp_borrowed(const moq_Timestamp *self); -moq_Timestamp *moq_Timestamp_clone(const moq_Timestamp *self, moq_status *status); -bool moq_Timestamp_eq(const moq_Timestamp *a, const moq_Timestamp *b, moq_status *status); -uint64_t moq_Timestamp_hash(const moq_Timestamp *self, moq_status *status); -moq_buf moq_Timestamp_debug(const moq_Timestamp *self, moq_status *status); -moq_Timestamp *moq_Timestamp_ZERO(void); -bool moq_Timestamp_new(uint64_t value, moq_Timescale scale, moq_Timestamp **out, moq_TimeOverflow *err); -moq_Timestamp *moq_Timestamp_unscaled(uint64_t key); -bool moq_Timestamp_from_scale(uint64_t value, uint64_t units_per_second, moq_Timestamp **out, moq_TimeOverflow *err); -bool moq_Timestamp_from_secs(uint64_t seconds, moq_Timestamp **out, moq_TimeOverflow *err); -bool moq_Timestamp_from_millis(uint64_t millis, moq_Timestamp **out, moq_TimeOverflow *err); -bool moq_Timestamp_from_micros(uint64_t micros, moq_Timestamp **out, moq_TimeOverflow *err); -bool moq_Timestamp_from_nanos(uint64_t nanos, moq_Timestamp **out, moq_TimeOverflow *err); -uint64_t moq_Timestamp_value(const moq_Timestamp *self, moq_status *status); -moq_option_Timescale moq_Timestamp_scale(const moq_Timestamp *self, moq_status *status); -bool moq_Timestamp_is_zero(const moq_Timestamp *self, moq_status *status); -bool moq_Timestamp_convert(const moq_Timestamp *self, moq_Timescale new_scale, moq_Timestamp **out, moq_TimeOverflow *err, moq_status *status); -bool moq_Timestamp_as_scale(const moq_Timestamp *self, moq_Timescale target, moq_u128 *out, moq_TimeOverflow *err, moq_status *status); -bool moq_Timestamp_as_secs(const moq_Timestamp *self, uint64_t *out, moq_TimeOverflow *err, moq_status *status); -bool moq_Timestamp_as_millis(const moq_Timestamp *self, moq_u128 *out, moq_TimeOverflow *err, moq_status *status); -bool moq_Timestamp_as_micros(const moq_Timestamp *self, moq_u128 *out, moq_TimeOverflow *err, moq_status *status); -bool moq_Timestamp_as_nanos(const moq_Timestamp *self, moq_u128 *out, moq_TimeOverflow *err, moq_status *status); -bool moq_Timestamp_checked_add(const moq_Timestamp *self, const moq_Timestamp *rhs, moq_Timestamp **out, moq_TimeOverflow *err, moq_status *status); -bool moq_Timestamp_checked_sub(const moq_Timestamp *self, const moq_Timestamp *rhs, moq_Timestamp **out, moq_TimeOverflow *err, moq_status *status); void moq_Version_free(moq_Version *self); bool moq_Version_borrowed(const moq_Version *self); moq_Version *moq_Version_clone(const moq_Version *self); @@ -3469,11 +3499,11 @@ moq_mux_Clock *moq_mux_Clock_default(void); moq_Timescale moq_mux_Clock_TIMESCALE(void); moq_mux_Clock *moq_mux_Clock_new(void); bool moq_mux_Clock_at(moq_clock_Instant epoch, moq_clock_Wall wall, moq_mux_Clock **out, moq_mux_Error **err); -moq_Timestamp *moq_mux_Clock_now(const moq_mux_Clock *self, moq_status *status); -bool moq_mux_Clock_capture(const moq_mux_Clock *self, moq_clock_Instant at, moq_Timestamp **out, moq_mux_Error **err, moq_status *status); +moq_Timestamp moq_mux_Clock_now(const moq_mux_Clock *self, moq_status *status); +bool moq_mux_Clock_capture(const moq_mux_Clock *self, moq_clock_Instant at, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); moq_Timescale moq_mux_Clock_timescale(const moq_mux_Clock *self, moq_status *status); -moq_hang_catalog_Clock *moq_mux_Clock_wall(const moq_mux_Clock *self, moq_status *status); -bool moq_mux_Clock_wall_clock(const moq_mux_Clock *self, const moq_Timestamp *pts, moq_clock_Wall *out, moq_mux_Error **err, moq_status *status); +moq_option_hang_catalog_Clock moq_mux_Clock_wall(const moq_mux_Clock *self, moq_status *status); +bool moq_mux_Clock_wall_clock(const moq_mux_Clock *self, moq_Timestamp pts, moq_clock_Wall *out, moq_mux_Error **err, moq_status *status); void moq_mux_Ingest_free(moq_mux_Ingest *self); void moq_mux_Ingest_drop(moq_mux_Ingest *self, moq_status *status); moq_mux_Ingest *moq_mux_Ingest_clone(const moq_mux_Ingest *self, moq_status *status); @@ -3502,10 +3532,10 @@ void moq_mux_Pacer_drop(moq_mux_Pacer *self, moq_status *status); moq_mux_Pacer *moq_mux_Pacer_default(void); moq_mux_Pacer *moq_mux_Pacer_with_lead(moq_mux_Pacer *self, moq_duration lead, moq_status *status); moq_mux_Pacer *moq_mux_Pacer_with_delay(moq_mux_Pacer *self, moq_duration delay, moq_status *status); -moq_clock_Instant moq_mux_Pacer_pace(moq_mux_Pacer *self, const moq_Timestamp *ts, moq_clock_Instant now, moq_status *status); -moq_option_clock_Instant moq_mux_Pacer_due(const moq_mux_Pacer *self, const moq_Timestamp *ts, moq_status *status); +moq_clock_Instant moq_mux_Pacer_pace(moq_mux_Pacer *self, moq_Timestamp ts, moq_clock_Instant now, moq_status *status); +moq_option_clock_Instant moq_mux_Pacer_due(const moq_mux_Pacer *self, moq_Timestamp ts, moq_status *status); moq_duration moq_mux_Pacer_slack(const moq_mux_Pacer *self, moq_status *status); -moq_clock_Instant moq_mux_Pacer_hurry(moq_mux_Pacer *self, const moq_Timestamp *ts, moq_clock_Instant now, moq_status *status); +moq_clock_Instant moq_mux_Pacer_hurry(moq_mux_Pacer *self, moq_Timestamp ts, moq_clock_Instant now, moq_status *status); void moq_mux_Binding_free(moq_mux_Binding *self); moq_mux_Binding *moq_mux_Binding_new(moq_broadcast_Consumer *broadcast, moq_status *status); typedef struct moq_mux_Binding_broadcast_future moq_mux_Binding_broadcast_future; @@ -4045,24 +4075,6 @@ moq_transport_Probe *moq_transport_Probe_default(void); moq_transport_Probe *moq_transport_Probe_new(void); moq_bandwidth_Rate moq_transport_Probe_target(const moq_transport_Probe *self); void moq_transport_Probe_set_target(const moq_transport_Probe *self, moq_bandwidth_Rate rate); -void moq_transport_ReceiveWindow_free(moq_transport_ReceiveWindow *self); -void moq_transport_ReceiveWindow_drop(moq_transport_ReceiveWindow *self, moq_status *status); -moq_transport_ReceiveWindow *moq_transport_ReceiveWindow_clone(const moq_transport_ReceiveWindow *self, moq_status *status); -bool moq_transport_ReceiveWindow_eq(const moq_transport_ReceiveWindow *a, const moq_transport_ReceiveWindow *b, moq_status *status); -moq_buf moq_transport_ReceiveWindow_debug(const moq_transport_ReceiveWindow *self, moq_status *status); -moq_option_non_zero_u64 moq_transport_ReceiveWindow_connection_get(const moq_transport_ReceiveWindow *self, moq_status *status); -void moq_transport_ReceiveWindow_connection_set(moq_transport_ReceiveWindow *self, moq_option_non_zero_u64 value, moq_status *status); -uint64_t moq_transport_ReceiveWindow_stream_get(const moq_transport_ReceiveWindow *self, moq_status *status); -void moq_transport_ReceiveWindow_stream_set(moq_transport_ReceiveWindow *self, uint64_t value, moq_status *status); -moq_transport_ReceiveWindow *moq_transport_ReceiveWindow_new(moq_option_non_zero_u64 connection, uint64_t stream); -void moq_transport_Limits_free(moq_transport_Limits *self); -void moq_transport_Limits_drop(moq_transport_Limits *self, moq_status *status); -moq_transport_Limits *moq_transport_Limits_clone(const moq_transport_Limits *self, moq_status *status); -bool moq_transport_Limits_eq(const moq_transport_Limits *a, const moq_transport_Limits *b, moq_status *status); -moq_buf moq_transport_Limits_debug(const moq_transport_Limits *self, moq_status *status); -moq_transport_Limits *moq_transport_Limits_default(void); -moq_option_non_zero_u64 moq_transport_Limits_receive_window_get(const moq_transport_Limits *self, moq_status *status); -void moq_transport_Limits_receive_window_set(moq_transport_Limits *self, moq_option_non_zero_u64 value, moq_status *status); void moq_bandwidth_Limit_free(moq_bandwidth_Limit *self); void moq_bandwidth_Limit_drop(moq_bandwidth_Limit *self, moq_status *status); moq_bandwidth_Limit *moq_bandwidth_Limit_clone(const moq_bandwidth_Limit *self, moq_status *status); @@ -4287,7 +4299,7 @@ void moq_datagram_Producer_drop(moq_datagram_Producer *self, moq_status *status) moq_datagram_Producer *moq_datagram_Producer_clone(const moq_datagram_Producer *self, moq_status *status); moq_buf moq_datagram_Producer_name(const moq_datagram_Producer *self, moq_status *status); moq_datagram_Info *moq_datagram_Producer_info(const moq_datagram_Producer *self, moq_status *status); -bool moq_datagram_Producer_append(moq_datagram_Producer *self, const moq_Timestamp *timestamp, moq_buf payload, uint64_t *out, moq_Error **err, moq_status *status); +bool moq_datagram_Producer_append(moq_datagram_Producer *self, moq_Timestamp timestamp, moq_buf payload, uint64_t *out, moq_Error **err, moq_status *status); bool moq_datagram_Producer_insert(moq_datagram_Producer *self, moq_datagram_Datagram datagram, moq_Error **err, moq_status *status); moq_datagram_Consumer *moq_datagram_Producer_consume(const moq_datagram_Producer *self, moq_status *status); void moq_datagram_Producer_finish(moq_datagram_Producer *self, moq_status *status); @@ -4332,7 +4344,7 @@ int8_t moq_datagram_Info_priority_get(const moq_datagram_Info *self, moq_status void moq_datagram_Info_priority_set(moq_datagram_Info *self, int8_t value, moq_status *status); moq_datagram_Info *moq_datagram_Info_with_timescale(const moq_datagram_Info *self, moq_option_Timescale timescale, moq_status *status); moq_datagram_Info *moq_datagram_Info_with_priority(const moq_datagram_Info *self, int8_t priority, moq_status *status); -bool moq_datagram_Info_rescale(const moq_datagram_Info *self, const moq_Timestamp *timestamp, moq_Timestamp **out, moq_Error **err, moq_status *status); +bool moq_datagram_Info_rescale(const moq_datagram_Info *self, moq_Timestamp timestamp, moq_Timestamp *out, moq_Error **err, moq_status *status); void moq_frame_Producer_free(moq_frame_Producer *self); void moq_frame_Producer_drop(moq_frame_Producer *self, moq_status *status); moq_group_Producer *moq_frame_Producer_group(const moq_frame_Producer *self, moq_status *status); @@ -4341,16 +4353,16 @@ bool moq_frame_Producer_write(moq_frame_Producer *self, moq_buf chunk, moq_Error bool moq_frame_Producer_finish(moq_frame_Producer *self, moq_group_Producer **out, moq_Error **err, moq_status *status); bool moq_frame_Producer_abort(moq_frame_Producer *self, moq_Error *err_, moq_Error **err, moq_status *status); uint64_t moq_frame_Producer_size_get(const moq_frame_Producer *self, moq_status *status); -moq_Timestamp *moq_frame_Producer_timestamp_get(const moq_frame_Producer *self, moq_status *status); +moq_Timestamp moq_frame_Producer_timestamp_get(const moq_frame_Producer *self, moq_status *status); void moq_frame_Frame_free(moq_frame_Frame *self); void moq_frame_Frame_drop(moq_frame_Frame *self, moq_status *status); moq_frame_Frame *moq_frame_Frame_clone(const moq_frame_Frame *self, moq_status *status); moq_buf moq_frame_Frame_debug(const moq_frame_Frame *self, moq_status *status); -moq_Timestamp *moq_frame_Frame_timestamp_get(const moq_frame_Frame *self, moq_status *status); -void moq_frame_Frame_timestamp_set(moq_frame_Frame *self, const moq_Timestamp *value, moq_status *status); +moq_Timestamp moq_frame_Frame_timestamp_get(const moq_frame_Frame *self, moq_status *status); +void moq_frame_Frame_timestamp_set(moq_frame_Frame *self, moq_Timestamp value, moq_status *status); moq_buf moq_frame_Frame_payload_get(const moq_frame_Frame *self, moq_status *status); void moq_frame_Frame_payload_set(moq_frame_Frame *self, moq_buf value, moq_status *status); -moq_frame_Frame *moq_frame_Frame_new(const moq_Timestamp *timestamp, moq_buf payload, moq_status *status); +moq_frame_Frame *moq_frame_Frame_new(moq_Timestamp timestamp, moq_buf payload); moq_clock_Instant moq_frame_Frame_arrived(const moq_frame_Frame *self, moq_status *status); void moq_frame_Consumer_free(moq_frame_Consumer *self); void moq_frame_Consumer_drop(moq_frame_Consumer *self, moq_status *status); @@ -4366,12 +4378,12 @@ moq_poll moq_frame_Consumer_read_all_start(moq_frame_Consumer *self, moq_buf *ou moq_poll moq_frame_Consumer_read_all_poll(moq_frame_Consumer_read_all_future *future, moq_waker waker, moq_buf *out, moq_Error **err); void moq_frame_Consumer_read_all_future_free(moq_frame_Consumer_read_all_future *future); uint64_t moq_frame_Consumer_size_get(const moq_frame_Consumer *self, moq_status *status); -moq_Timestamp *moq_frame_Consumer_timestamp_get(const moq_frame_Consumer *self, moq_status *status); +moq_Timestamp moq_frame_Consumer_timestamp_get(const moq_frame_Consumer *self, moq_status *status); void moq_group_Producer_free(moq_group_Producer *self); void moq_group_Producer_drop(moq_group_Producer *self, moq_status *status); moq_option_Timescale moq_group_Producer_timescale(const moq_group_Producer *self, moq_status *status); bool moq_group_Producer_start_at(moq_group_Producer *self, uint64_t index, moq_Error **err, moq_status *status); -bool moq_group_Producer_write_frame(moq_group_Producer *self, const moq_Timestamp *timestamp, moq_buf data_, moq_Error **err, moq_status *status); +bool moq_group_Producer_write_frame(moq_group_Producer *self, moq_Timestamp timestamp, moq_buf data_, moq_Error **err, moq_status *status); bool moq_group_Producer_create_frame(moq_group_Producer *self, moq_frame_Info frame, moq_frame_Producer **out, moq_Error **err, moq_status *status); bool moq_group_Producer_finish_at(moq_group_Producer *self, uint64_t end, moq_group_Finished **out, moq_Error **err, moq_status *status); bool moq_group_Producer_finish(moq_group_Producer *self, moq_group_Finished **out, moq_Error **err, moq_status *status); @@ -4600,8 +4612,8 @@ moq_track_Info *moq_track_Info_with_max_age(moq_track_Info *self, moq_option_dur moq_track_Info *moq_track_Info_with_priority(moq_track_Info *self, int8_t priority, moq_status *status); moq_track_Info *moq_track_Info_with_compression(moq_track_Info *self, moq_track_Compression compression, moq_status *status); moq_track_Info *moq_track_Info_with_refresh(moq_track_Info *self, const moq_track_Refresh *refresh, moq_status *status); -bool moq_track_Info_rescale(const moq_track_Info *self, const moq_Timestamp *timestamp, moq_Timestamp **out, moq_Error **err, moq_status *status); -bool moq_track_Info_rescale_in(const moq_track_Info *self, const moq_Timestamp *timestamp, uint64_t key, moq_Timestamp **out, moq_Error **err, moq_status *status); +bool moq_track_Info_rescale(const moq_track_Info *self, moq_Timestamp timestamp, moq_Timestamp *out, moq_Error **err, moq_status *status); +bool moq_track_Info_rescale_in(const moq_track_Info *self, moq_Timestamp timestamp, uint64_t key, moq_Timestamp *out, moq_Error **err, moq_status *status); void moq_track_Refresh_free(moq_track_Refresh *self); void moq_track_Refresh_drop(moq_track_Refresh *self, moq_status *status); moq_track_Refresh *moq_track_Refresh_clone(const moq_track_Refresh *self, moq_status *status); @@ -4622,8 +4634,8 @@ moq_buf moq_track_Producer_name(const moq_track_Producer *self, moq_status *stat moq_broadcast_Info *moq_track_Producer_broadcast(const moq_track_Producer *self, moq_status *status); moq_track_Info *moq_track_Producer_info(const moq_track_Producer *self, moq_status *status); bool moq_track_Producer_create_group(const moq_track_Producer *self, moq_group_Info group, moq_group_Producer **out, moq_Error **err, moq_status *status); -bool moq_track_Producer_append_group(const moq_track_Producer *self, const moq_Timestamp *start, moq_group_Producer **out, moq_Error **err, moq_status *status); -bool moq_track_Producer_write_frame(moq_track_Producer *self, const moq_Timestamp *timestamp, moq_buf frame, moq_Error **err, moq_status *status); +bool moq_track_Producer_append_group(const moq_track_Producer *self, moq_Timestamp start, moq_group_Producer **out, moq_Error **err, moq_status *status); +bool moq_track_Producer_write_frame(moq_track_Producer *self, moq_Timestamp timestamp, moq_buf frame, moq_Error **err, moq_status *status); bool moq_track_Producer_finish(moq_track_Producer *self, moq_track_Finished **out, moq_Error **err, moq_status *status); bool moq_track_Producer_fail(moq_track_Producer *self, moq_Error *err_, moq_track_Finished **out, moq_Error **err, moq_status *status); bool moq_track_Producer_finish_at(moq_track_Producer *self, moq_track_Position end, moq_Error **err, moq_status *status); @@ -4958,11 +4970,11 @@ void moq_hang_echo_Arrival_drop(moq_hang_echo_Arrival *self, moq_status *status) moq_hang_echo_Arrival *moq_hang_echo_Arrival_clone(const moq_hang_echo_Arrival *self, moq_status *status); bool moq_hang_echo_Arrival_eq(const moq_hang_echo_Arrival *a, const moq_hang_echo_Arrival *b, moq_status *status); moq_buf moq_hang_echo_Arrival_debug(const moq_hang_echo_Arrival *self, moq_status *status); -moq_Timestamp *moq_hang_echo_Arrival_timestamp_get(const moq_hang_echo_Arrival *self, moq_status *status); -void moq_hang_echo_Arrival_timestamp_set(moq_hang_echo_Arrival *self, const moq_Timestamp *value, moq_status *status); +moq_Timestamp moq_hang_echo_Arrival_timestamp_get(const moq_hang_echo_Arrival *self, moq_status *status); +void moq_hang_echo_Arrival_timestamp_set(moq_hang_echo_Arrival *self, moq_Timestamp value, moq_status *status); moq_clock_Wall moq_hang_echo_Arrival_wall_get(const moq_hang_echo_Arrival *self, moq_status *status); void moq_hang_echo_Arrival_wall_set(moq_hang_echo_Arrival *self, moq_clock_Wall value, moq_status *status); -moq_hang_echo_Arrival *moq_hang_echo_Arrival_new(const moq_Timestamp *timestamp, moq_clock_Wall wall, moq_status *status); +moq_hang_echo_Arrival *moq_hang_echo_Arrival_new(moq_Timestamp timestamp, moq_clock_Wall wall); void moq_hang_catalog_Skipped_free(moq_hang_catalog_Skipped *self); void moq_hang_catalog_Skipped_drop(moq_hang_catalog_Skipped *self, moq_status *status); moq_hang_catalog_Skipped *moq_hang_catalog_Skipped_clone(const moq_hang_catalog_Skipped *self, moq_status *status); @@ -5076,15 +5088,6 @@ void moq_hang_catalog_BinaryConfig_delay_set(moq_hang_catalog_BinaryConfig *self moq_vec_tuple_string_Json moq_hang_catalog_BinaryConfig_extra_get(const moq_hang_catalog_BinaryConfig *self, moq_status *status); void moq_hang_catalog_BinaryConfig_extra_set(moq_hang_catalog_BinaryConfig *self, moq_vec_tuple_string_Json value, moq_status *status); moq_hang_catalog_BinaryConfig *moq_hang_catalog_BinaryConfig_new(moq_hang_catalog_Mode mode); -void moq_hang_catalog_Clock_free(moq_hang_catalog_Clock *self); -void moq_hang_catalog_Clock_drop(moq_hang_catalog_Clock *self, moq_status *status); -moq_hang_catalog_Clock *moq_hang_catalog_Clock_clone(const moq_hang_catalog_Clock *self, moq_status *status); -bool moq_hang_catalog_Clock_eq(const moq_hang_catalog_Clock *a, const moq_hang_catalog_Clock *b, moq_status *status); -moq_buf moq_hang_catalog_Clock_debug(const moq_hang_catalog_Clock *self, moq_status *status); -moq_Timestamp *moq_hang_catalog_Clock_wall_get(const moq_hang_catalog_Clock *self, moq_status *status); -void moq_hang_catalog_Clock_wall_set(moq_hang_catalog_Clock *self, const moq_Timestamp *value, moq_status *status); -bool moq_hang_catalog_Clock_new(const moq_Timestamp *wall, moq_hang_catalog_Clock **out, moq_hang_Error **err, moq_status *status); -bool moq_hang_catalog_Clock_wall_clock(const moq_hang_catalog_Clock *self, const moq_Timestamp *pts, moq_clock_Wall *out, moq_hang_Error **err, moq_status *status); void moq_hang_catalog_Container_free(moq_hang_catalog_Container *self); void moq_hang_catalog_Container_drop(moq_hang_catalog_Container *self, moq_status *status); moq_hang_catalog_Container *moq_hang_catalog_Container_clone(const moq_hang_catalog_Container *self, moq_status *status); @@ -5195,8 +5198,8 @@ moq_hang_catalog_Timeline *moq_hang_catalog_Timeline_clone(const moq_hang_catalo bool moq_hang_catalog_Timeline_eq(const moq_hang_catalog_Timeline *a, const moq_hang_catalog_Timeline *b, moq_status *status); moq_buf moq_hang_catalog_Timeline_debug(const moq_hang_catalog_Timeline *self, moq_status *status); moq_hang_catalog_Timeline *moq_hang_catalog_Timeline_default(void); -moq_hang_catalog_Clock *moq_hang_catalog_Timeline_clock_get(const moq_hang_catalog_Timeline *self, moq_status *status); -void moq_hang_catalog_Timeline_clock_set(moq_hang_catalog_Timeline *self, const moq_hang_catalog_Clock *value, moq_status *status); +moq_option_hang_catalog_Clock moq_hang_catalog_Timeline_clock_get(const moq_hang_catalog_Timeline *self, moq_status *status); +void moq_hang_catalog_Timeline_clock_set(moq_hang_catalog_Timeline *self, moq_option_hang_catalog_Clock value, moq_status *status); moq_option_duration moq_hang_catalog_Timeline_interval_get(const moq_hang_catalog_Timeline *self, moq_status *status); void moq_hang_catalog_Timeline_interval_set(moq_hang_catalog_Timeline *self, moq_option_duration value, moq_status *status); bool moq_hang_catalog_Timeline_is_empty(const moq_hang_catalog_Timeline *self, moq_status *status); @@ -5471,7 +5474,7 @@ void moq_mux_catalog_Producer_drop(moq_mux_catalog_Producer *self, moq_status *s moq_mux_catalog_Producer *moq_mux_catalog_Producer_clone(const moq_mux_catalog_Producer *self, moq_status *status); bool moq_mux_catalog_Producer_new(moq_broadcast_Producer *broadcast, moq_mux_catalog_Config *config, moq_mux_catalog_Producer **out, moq_mux_Error **err, moq_status *status); moq_track_Info *moq_mux_catalog_Producer_track_info(const moq_mux_catalog_Producer *self, int8_t priority, moq_status *status); -bool moq_mux_catalog_Producer_timestamp(const moq_mux_catalog_Producer *self, const moq_Timestamp *hint, moq_Timestamp **out, moq_mux_Error **err, moq_status *status); +bool moq_mux_catalog_Producer_timestamp(const moq_mux_catalog_Producer *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); bool moq_mux_catalog_Producer_mutate(moq_mux_catalog_Producer *self, void (*f)(void *data, moq_hang_Catalog *), void *f_data, moq_mux_Error **err, moq_status *status); bool moq_mux_catalog_Producer_modify(moq_mux_catalog_Producer *self, moq_mux_catalog_Guard **out, moq_mux_Error **err, moq_status *status); bool moq_mux_catalog_Producer_modify_homed(moq_mux_catalog_Producer *self, moq_mux_catalog_Guard **out, moq_mux_Error **err, moq_status *status); @@ -5529,7 +5532,7 @@ void moq_mux_catalog_Producer_Extra_drop(moq_mux_catalog_Producer_Extra *self, m moq_mux_catalog_Producer_Extra *moq_mux_catalog_Producer_Extra_clone(const moq_mux_catalog_Producer_Extra *self, moq_status *status); bool moq_mux_catalog_Producer_Extra_new(moq_broadcast_Producer *broadcast, moq_mux_catalog_Config_Extra *config, moq_mux_catalog_Producer_Extra **out, moq_mux_Error **err, moq_status *status); moq_track_Info *moq_mux_catalog_Producer_Extra_track_info(const moq_mux_catalog_Producer_Extra *self, int8_t priority, moq_status *status); -bool moq_mux_catalog_Producer_Extra_timestamp(const moq_mux_catalog_Producer_Extra *self, const moq_Timestamp *hint, moq_Timestamp **out, moq_mux_Error **err, moq_status *status); +bool moq_mux_catalog_Producer_Extra_timestamp(const moq_mux_catalog_Producer_Extra *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); bool moq_mux_catalog_Producer_Extra_mutate(moq_mux_catalog_Producer_Extra *self, void (*f)(void *data, moq_hang_Catalog_Extra *), void *f_data, moq_mux_Error **err, moq_status *status); bool moq_mux_catalog_Producer_Extra_modify(moq_mux_catalog_Producer_Extra *self, moq_mux_catalog_Guard_Extra **out, moq_mux_Error **err, moq_status *status); bool moq_mux_catalog_Producer_Extra_modify_homed(moq_mux_catalog_Producer_Extra *self, moq_mux_catalog_Guard_Extra **out, moq_mux_Error **err, moq_status *status); @@ -5587,7 +5590,7 @@ void moq_mux_catalog_Producer_Ext_drop(moq_mux_catalog_Producer_Ext *self, moq_s moq_mux_catalog_Producer_Ext *moq_mux_catalog_Producer_Ext_clone(const moq_mux_catalog_Producer_Ext *self, moq_status *status); bool moq_mux_catalog_Producer_Ext_new(moq_broadcast_Producer *broadcast, moq_mux_catalog_Config_Ext *config, moq_mux_catalog_Producer_Ext **out, moq_mux_Error **err, moq_status *status); moq_track_Info *moq_mux_catalog_Producer_Ext_track_info(const moq_mux_catalog_Producer_Ext *self, int8_t priority, moq_status *status); -bool moq_mux_catalog_Producer_Ext_timestamp(const moq_mux_catalog_Producer_Ext *self, const moq_Timestamp *hint, moq_Timestamp **out, moq_mux_Error **err, moq_status *status); +bool moq_mux_catalog_Producer_Ext_timestamp(const moq_mux_catalog_Producer_Ext *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); bool moq_mux_catalog_Producer_Ext_mutate(moq_mux_catalog_Producer_Ext *self, void (*f)(void *data, moq_hang_Catalog_Ext *), void *f_data, moq_mux_Error **err, moq_status *status); bool moq_mux_catalog_Producer_Ext_modify(moq_mux_catalog_Producer_Ext *self, moq_mux_catalog_Guard_Ext **out, moq_mux_Error **err, moq_status *status); bool moq_mux_catalog_Producer_Ext_modify_homed(moq_mux_catalog_Producer_Ext *self, moq_mux_catalog_Guard_Ext **out, moq_mux_Error **err, moq_status *status); @@ -5643,15 +5646,15 @@ bool moq_mux_catalog_Producer_Ext_finish(moq_mux_catalog_Producer_Ext *self, moq void moq_mux_catalog_Timebase_free(moq_mux_catalog_Timebase *self); moq_mux_catalog_Timebase *moq_mux_catalog_Timebase_clone(const moq_mux_catalog_Timebase *self); moq_mux_catalog_Reserved *moq_mux_catalog_Timebase_reserve(const moq_mux_catalog_Timebase *self); -bool moq_mux_catalog_Timebase_place(const moq_mux_catalog_Timebase *self, const moq_Timestamp *pts, moq_clock_Wall wall, moq_mux_Error **err, moq_status *status); +bool moq_mux_catalog_Timebase_place(const moq_mux_catalog_Timebase *self, moq_Timestamp pts, moq_clock_Wall wall, moq_mux_Error **err); void moq_mux_catalog_Timebase_Extra_free(moq_mux_catalog_Timebase_Extra *self); moq_mux_catalog_Timebase_Extra *moq_mux_catalog_Timebase_Extra_clone(const moq_mux_catalog_Timebase_Extra *self); moq_mux_catalog_Reserved_Extra *moq_mux_catalog_Timebase_Extra_reserve(const moq_mux_catalog_Timebase_Extra *self); -bool moq_mux_catalog_Timebase_Extra_place(const moq_mux_catalog_Timebase_Extra *self, const moq_Timestamp *pts, moq_clock_Wall wall, moq_mux_Error **err, moq_status *status); +bool moq_mux_catalog_Timebase_Extra_place(const moq_mux_catalog_Timebase_Extra *self, moq_Timestamp pts, moq_clock_Wall wall, moq_mux_Error **err); void moq_mux_catalog_Timebase_Ext_free(moq_mux_catalog_Timebase_Ext *self); moq_mux_catalog_Timebase_Ext *moq_mux_catalog_Timebase_Ext_clone(const moq_mux_catalog_Timebase_Ext *self); moq_mux_catalog_Reserved_Ext *moq_mux_catalog_Timebase_Ext_reserve(const moq_mux_catalog_Timebase_Ext *self); -bool moq_mux_catalog_Timebase_Ext_place(const moq_mux_catalog_Timebase_Ext *self, const moq_Timestamp *pts, moq_clock_Wall wall, moq_mux_Error **err, moq_status *status); +bool moq_mux_catalog_Timebase_Ext_place(const moq_mux_catalog_Timebase_Ext *self, moq_Timestamp pts, moq_clock_Wall wall, moq_mux_Error **err); void moq_mux_catalog_Reserved_free(moq_mux_catalog_Reserved *self); void moq_mux_catalog_Reserved_drop(moq_mux_catalog_Reserved *self, moq_status *status); moq_mux_catalog_Reserved *moq_mux_catalog_Reserved_clone(const moq_mux_catalog_Reserved *self, moq_status *status); @@ -5689,7 +5692,7 @@ bool moq_mux_catalog_Reserved_track_loc_Wire_BinaryConfig(const moq_mux_catalog_ bool moq_mux_catalog_Reserved_track_loc_Wire_VideoConfig(const moq_mux_catalog_Reserved *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_loc_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); bool moq_mux_catalog_Reserved_track_loc_Wire_AudioConfig(const moq_mux_catalog_Reserved *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_loc_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); bool moq_mux_catalog_Reserved_track_loc_Wire_TextConfig(const moq_mux_catalog_Reserved *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_loc_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_timestamp(const moq_mux_catalog_Reserved *self, const moq_Timestamp *hint, moq_Timestamp **out, moq_mux_Error **err, moq_status *status); +bool moq_mux_catalog_Reserved_timestamp(const moq_mux_catalog_Reserved *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); void moq_mux_catalog_Reserved_Extra_free(moq_mux_catalog_Reserved_Extra *self); void moq_mux_catalog_Reserved_Extra_drop(moq_mux_catalog_Reserved_Extra *self, moq_status *status); moq_mux_catalog_Reserved_Extra *moq_mux_catalog_Reserved_Extra_clone(const moq_mux_catalog_Reserved_Extra *self, moq_status *status); @@ -5727,7 +5730,7 @@ bool moq_mux_catalog_Reserved_Extra_track_loc_Wire_BinaryConfig(const moq_mux_ca bool moq_mux_catalog_Reserved_Extra_track_loc_Wire_VideoConfig(const moq_mux_catalog_Reserved_Extra *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_loc_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); bool moq_mux_catalog_Reserved_Extra_track_loc_Wire_AudioConfig(const moq_mux_catalog_Reserved_Extra *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_loc_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); bool moq_mux_catalog_Reserved_Extra_track_loc_Wire_TextConfig(const moq_mux_catalog_Reserved_Extra *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_loc_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_Extra_timestamp(const moq_mux_catalog_Reserved_Extra *self, const moq_Timestamp *hint, moq_Timestamp **out, moq_mux_Error **err, moq_status *status); +bool moq_mux_catalog_Reserved_Extra_timestamp(const moq_mux_catalog_Reserved_Extra *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); void moq_mux_catalog_Reserved_Ext_free(moq_mux_catalog_Reserved_Ext *self); void moq_mux_catalog_Reserved_Ext_drop(moq_mux_catalog_Reserved_Ext *self, moq_status *status); moq_mux_catalog_Reserved_Ext *moq_mux_catalog_Reserved_Ext_clone(const moq_mux_catalog_Reserved_Ext *self, moq_status *status); @@ -5765,7 +5768,7 @@ bool moq_mux_catalog_Reserved_Ext_track_loc_Wire_BinaryConfig(const moq_mux_cata bool moq_mux_catalog_Reserved_Ext_track_loc_Wire_VideoConfig(const moq_mux_catalog_Reserved_Ext *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_loc_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); bool moq_mux_catalog_Reserved_Ext_track_loc_Wire_AudioConfig(const moq_mux_catalog_Reserved_Ext *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_loc_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); bool moq_mux_catalog_Reserved_Ext_track_loc_Wire_TextConfig(const moq_mux_catalog_Reserved_Ext *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_loc_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_Ext_timestamp(const moq_mux_catalog_Reserved_Ext *self, const moq_Timestamp *hint, moq_Timestamp **out, moq_mux_Error **err, moq_status *status); +bool moq_mux_catalog_Reserved_Ext_timestamp(const moq_mux_catalog_Reserved_Ext *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); void moq_mux_catalog_VideoHint_free(moq_mux_catalog_VideoHint *self); void moq_mux_catalog_VideoHint_drop(moq_mux_catalog_VideoHint *self, moq_status *status); moq_mux_catalog_VideoHint *moq_mux_catalog_VideoHint_clone(const moq_mux_catalog_VideoHint *self, moq_status *status); @@ -6238,21 +6241,21 @@ void moq_mux_container_Producer_Container_AudioConfig_drop(moq_mux_container_Pro bool moq_mux_container_Producer_Container_AudioConfig_set(moq_mux_container_Producer_Container_AudioConfig *self, moq_hang_catalog_AudioConfig *config, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_Container_AudioConfig_set_bitrate(moq_mux_container_Producer_Container_AudioConfig *self, uint64_t bitrate, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_Container_AudioConfig_modify(moq_mux_container_Producer_Container_AudioConfig *self, moq_mux_container_Guard_AudioConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_Container_AudioConfig_timestamp(const moq_mux_container_Producer_Container_AudioConfig *self, const moq_Timestamp *hint, moq_Timestamp **out, moq_mux_Error **err, moq_status *status); +bool moq_mux_container_Producer_Container_AudioConfig_timestamp(const moq_mux_container_Producer_Container_AudioConfig *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); moq_buf moq_mux_container_Producer_Container_AudioConfig_name(const moq_mux_container_Producer_Container_AudioConfig *self, moq_status *status); moq_track_Demand *moq_mux_container_Producer_Container_AudioConfig_demand(const moq_mux_container_Producer_Container_AudioConfig *self, moq_status *status); moq_mux_catalog_Estimate *moq_mux_container_Producer_Container_AudioConfig_estimate(const moq_mux_container_Producer_Container_AudioConfig *self, moq_status *status); -void moq_mux_container_Producer_Container_AudioConfig_reorder(moq_mux_container_Producer_Container_AudioConfig *self, const moq_Timestamp *delay, moq_status *status); -void moq_mux_container_Producer_Container_AudioConfig_history(moq_mux_container_Producer_Container_AudioConfig *self, const moq_Timestamp *until, moq_status *status); +void moq_mux_container_Producer_Container_AudioConfig_reorder(moq_mux_container_Producer_Container_AudioConfig *self, moq_Timestamp delay, moq_status *status); +void moq_mux_container_Producer_Container_AudioConfig_history(moq_mux_container_Producer_Container_AudioConfig *self, moq_Timestamp until, moq_status *status); bool moq_mux_container_Producer_Container_AudioConfig_needs_keyframe(const moq_mux_container_Producer_Container_AudioConfig *self, moq_status *status); moq_mux_container_Producer_Container_AudioConfig *moq_mux_container_Producer_Container_AudioConfig_with_buffer(moq_mux_container_Producer_Container_AudioConfig *self, moq_duration duration, moq_status *status); moq_mux_container_Producer_Container_AudioConfig *moq_mux_container_Producer_Container_AudioConfig_with_bandwidth(moq_mux_container_Producer_Container_AudioConfig *self, moq_bandwidth_Allocator *allocator, moq_status *status); void moq_mux_container_Producer_Container_AudioConfig_report_skipped(const moq_mux_container_Producer_Container_AudioConfig *self, uint64_t frames, moq_status *status); void moq_mux_container_Producer_Container_AudioConfig_report_bitrate(const moq_mux_container_Producer_Container_AudioConfig *self, moq_bandwidth_Rate bitrate, moq_status *status); moq_track_Producer *moq_mux_container_Producer_Container_AudioConfig_track(const moq_mux_container_Producer_Container_AudioConfig *self, moq_status *status); -moq_Timestamp *moq_mux_container_Producer_Container_AudioConfig_live_edge(const moq_mux_container_Producer_Container_AudioConfig *self, moq_status *status); +moq_option_Timestamp moq_mux_container_Producer_Container_AudioConfig_live_edge(const moq_mux_container_Producer_Container_AudioConfig *self, moq_status *status); bool moq_mux_container_Producer_Container_AudioConfig_write(moq_mux_container_Producer_Container_AudioConfig *self, moq_mux_container_Frame frame, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_Container_AudioConfig_cut(moq_mux_container_Producer_Container_AudioConfig *self, const moq_Timestamp *end, moq_mux_Error **err, moq_status *status); +bool moq_mux_container_Producer_Container_AudioConfig_cut(moq_mux_container_Producer_Container_AudioConfig *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_Container_AudioConfig_seek(moq_mux_container_Producer_Container_AudioConfig *self, uint64_t start, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_Container_AudioConfig_discontinuity(moq_mux_container_Producer_Container_AudioConfig *self, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_Container_AudioConfig_finish(moq_mux_container_Producer_Container_AudioConfig *self, moq_mux_container_Finished_Container_AudioConfig **out, moq_mux_Error **err, moq_status *status); @@ -6263,7 +6266,7 @@ moq_track_Subscriber *moq_mux_container_Producer_Container_AudioConfig_consume(c moq_broadcast_Info *moq_mux_container_Producer_Container_AudioConfig_broadcast(const moq_mux_container_Producer_Container_AudioConfig *self, moq_status *status); moq_track_Info *moq_mux_container_Producer_Container_AudioConfig_info(const moq_mux_container_Producer_Container_AudioConfig *self, moq_status *status); bool moq_mux_container_Producer_Container_AudioConfig_create_group(const moq_mux_container_Producer_Container_AudioConfig *self, moq_group_Info group, moq_group_Producer **out, moq_Error **err, moq_status *status); -bool moq_mux_container_Producer_Container_AudioConfig_append_group(const moq_mux_container_Producer_Container_AudioConfig *self, const moq_Timestamp *start, moq_group_Producer **out, moq_Error **err, moq_status *status); +bool moq_mux_container_Producer_Container_AudioConfig_append_group(const moq_mux_container_Producer_Container_AudioConfig *self, moq_Timestamp start, moq_group_Producer **out, moq_Error **err, moq_status *status); void moq_mux_container_Producer_Container_AudioConfig_skip_groups(const moq_mux_container_Producer_Container_AudioConfig *self, moq_range_u64 groups, moq_status *status); moq_option_track_Position moq_mux_container_Producer_Container_AudioConfig_finished(const moq_mux_container_Producer_Container_AudioConfig *self, moq_status *status); typedef struct moq_mux_container_Producer_Container_AudioConfig_closed_future moq_mux_container_Producer_Container_AudioConfig_closed_future; @@ -6283,21 +6286,21 @@ void moq_mux_container_Producer_Container_BinaryConfig_drop(moq_mux_container_Pr bool moq_mux_container_Producer_Container_BinaryConfig_set(moq_mux_container_Producer_Container_BinaryConfig *self, moq_hang_catalog_BinaryConfig *config, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_Container_BinaryConfig_set_bitrate(moq_mux_container_Producer_Container_BinaryConfig *self, uint64_t bitrate, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_Container_BinaryConfig_modify(moq_mux_container_Producer_Container_BinaryConfig *self, moq_mux_container_Guard_BinaryConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_Container_BinaryConfig_timestamp(const moq_mux_container_Producer_Container_BinaryConfig *self, const moq_Timestamp *hint, moq_Timestamp **out, moq_mux_Error **err, moq_status *status); +bool moq_mux_container_Producer_Container_BinaryConfig_timestamp(const moq_mux_container_Producer_Container_BinaryConfig *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); moq_buf moq_mux_container_Producer_Container_BinaryConfig_name(const moq_mux_container_Producer_Container_BinaryConfig *self, moq_status *status); moq_track_Demand *moq_mux_container_Producer_Container_BinaryConfig_demand(const moq_mux_container_Producer_Container_BinaryConfig *self, moq_status *status); moq_mux_catalog_Estimate *moq_mux_container_Producer_Container_BinaryConfig_estimate(const moq_mux_container_Producer_Container_BinaryConfig *self, moq_status *status); -void moq_mux_container_Producer_Container_BinaryConfig_reorder(moq_mux_container_Producer_Container_BinaryConfig *self, const moq_Timestamp *delay, moq_status *status); -void moq_mux_container_Producer_Container_BinaryConfig_history(moq_mux_container_Producer_Container_BinaryConfig *self, const moq_Timestamp *until, moq_status *status); +void moq_mux_container_Producer_Container_BinaryConfig_reorder(moq_mux_container_Producer_Container_BinaryConfig *self, moq_Timestamp delay, moq_status *status); +void moq_mux_container_Producer_Container_BinaryConfig_history(moq_mux_container_Producer_Container_BinaryConfig *self, moq_Timestamp until, moq_status *status); bool moq_mux_container_Producer_Container_BinaryConfig_needs_keyframe(const moq_mux_container_Producer_Container_BinaryConfig *self, moq_status *status); moq_mux_container_Producer_Container_BinaryConfig *moq_mux_container_Producer_Container_BinaryConfig_with_buffer(moq_mux_container_Producer_Container_BinaryConfig *self, moq_duration duration, moq_status *status); moq_mux_container_Producer_Container_BinaryConfig *moq_mux_container_Producer_Container_BinaryConfig_with_bandwidth(moq_mux_container_Producer_Container_BinaryConfig *self, moq_bandwidth_Allocator *allocator, moq_status *status); void moq_mux_container_Producer_Container_BinaryConfig_report_skipped(const moq_mux_container_Producer_Container_BinaryConfig *self, uint64_t frames, moq_status *status); void moq_mux_container_Producer_Container_BinaryConfig_report_bitrate(const moq_mux_container_Producer_Container_BinaryConfig *self, moq_bandwidth_Rate bitrate, moq_status *status); moq_track_Producer *moq_mux_container_Producer_Container_BinaryConfig_track(const moq_mux_container_Producer_Container_BinaryConfig *self, moq_status *status); -moq_Timestamp *moq_mux_container_Producer_Container_BinaryConfig_live_edge(const moq_mux_container_Producer_Container_BinaryConfig *self, moq_status *status); +moq_option_Timestamp moq_mux_container_Producer_Container_BinaryConfig_live_edge(const moq_mux_container_Producer_Container_BinaryConfig *self, moq_status *status); bool moq_mux_container_Producer_Container_BinaryConfig_write(moq_mux_container_Producer_Container_BinaryConfig *self, moq_mux_container_Frame frame, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_Container_BinaryConfig_cut(moq_mux_container_Producer_Container_BinaryConfig *self, const moq_Timestamp *end, moq_mux_Error **err, moq_status *status); +bool moq_mux_container_Producer_Container_BinaryConfig_cut(moq_mux_container_Producer_Container_BinaryConfig *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_Container_BinaryConfig_seek(moq_mux_container_Producer_Container_BinaryConfig *self, uint64_t start, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_Container_BinaryConfig_discontinuity(moq_mux_container_Producer_Container_BinaryConfig *self, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_Container_BinaryConfig_finish(moq_mux_container_Producer_Container_BinaryConfig *self, moq_mux_container_Finished_Container_BinaryConfig **out, moq_mux_Error **err, moq_status *status); @@ -6308,7 +6311,7 @@ moq_track_Subscriber *moq_mux_container_Producer_Container_BinaryConfig_consume( moq_broadcast_Info *moq_mux_container_Producer_Container_BinaryConfig_broadcast(const moq_mux_container_Producer_Container_BinaryConfig *self, moq_status *status); moq_track_Info *moq_mux_container_Producer_Container_BinaryConfig_info(const moq_mux_container_Producer_Container_BinaryConfig *self, moq_status *status); bool moq_mux_container_Producer_Container_BinaryConfig_create_group(const moq_mux_container_Producer_Container_BinaryConfig *self, moq_group_Info group, moq_group_Producer **out, moq_Error **err, moq_status *status); -bool moq_mux_container_Producer_Container_BinaryConfig_append_group(const moq_mux_container_Producer_Container_BinaryConfig *self, const moq_Timestamp *start, moq_group_Producer **out, moq_Error **err, moq_status *status); +bool moq_mux_container_Producer_Container_BinaryConfig_append_group(const moq_mux_container_Producer_Container_BinaryConfig *self, moq_Timestamp start, moq_group_Producer **out, moq_Error **err, moq_status *status); void moq_mux_container_Producer_Container_BinaryConfig_skip_groups(const moq_mux_container_Producer_Container_BinaryConfig *self, moq_range_u64 groups, moq_status *status); moq_option_track_Position moq_mux_container_Producer_Container_BinaryConfig_finished(const moq_mux_container_Producer_Container_BinaryConfig *self, moq_status *status); typedef struct moq_mux_container_Producer_Container_BinaryConfig_closed_future moq_mux_container_Producer_Container_BinaryConfig_closed_future; @@ -6328,21 +6331,21 @@ void moq_mux_container_Producer_Container_JsonConfig_drop(moq_mux_container_Prod bool moq_mux_container_Producer_Container_JsonConfig_set(moq_mux_container_Producer_Container_JsonConfig *self, moq_hang_catalog_JsonConfig *config, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_Container_JsonConfig_set_bitrate(moq_mux_container_Producer_Container_JsonConfig *self, uint64_t bitrate, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_Container_JsonConfig_modify(moq_mux_container_Producer_Container_JsonConfig *self, moq_mux_container_Guard_JsonConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_Container_JsonConfig_timestamp(const moq_mux_container_Producer_Container_JsonConfig *self, const moq_Timestamp *hint, moq_Timestamp **out, moq_mux_Error **err, moq_status *status); +bool moq_mux_container_Producer_Container_JsonConfig_timestamp(const moq_mux_container_Producer_Container_JsonConfig *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); moq_buf moq_mux_container_Producer_Container_JsonConfig_name(const moq_mux_container_Producer_Container_JsonConfig *self, moq_status *status); moq_track_Demand *moq_mux_container_Producer_Container_JsonConfig_demand(const moq_mux_container_Producer_Container_JsonConfig *self, moq_status *status); moq_mux_catalog_Estimate *moq_mux_container_Producer_Container_JsonConfig_estimate(const moq_mux_container_Producer_Container_JsonConfig *self, moq_status *status); -void moq_mux_container_Producer_Container_JsonConfig_reorder(moq_mux_container_Producer_Container_JsonConfig *self, const moq_Timestamp *delay, moq_status *status); -void moq_mux_container_Producer_Container_JsonConfig_history(moq_mux_container_Producer_Container_JsonConfig *self, const moq_Timestamp *until, moq_status *status); +void moq_mux_container_Producer_Container_JsonConfig_reorder(moq_mux_container_Producer_Container_JsonConfig *self, moq_Timestamp delay, moq_status *status); +void moq_mux_container_Producer_Container_JsonConfig_history(moq_mux_container_Producer_Container_JsonConfig *self, moq_Timestamp until, moq_status *status); bool moq_mux_container_Producer_Container_JsonConfig_needs_keyframe(const moq_mux_container_Producer_Container_JsonConfig *self, moq_status *status); moq_mux_container_Producer_Container_JsonConfig *moq_mux_container_Producer_Container_JsonConfig_with_buffer(moq_mux_container_Producer_Container_JsonConfig *self, moq_duration duration, moq_status *status); moq_mux_container_Producer_Container_JsonConfig *moq_mux_container_Producer_Container_JsonConfig_with_bandwidth(moq_mux_container_Producer_Container_JsonConfig *self, moq_bandwidth_Allocator *allocator, moq_status *status); void moq_mux_container_Producer_Container_JsonConfig_report_skipped(const moq_mux_container_Producer_Container_JsonConfig *self, uint64_t frames, moq_status *status); void moq_mux_container_Producer_Container_JsonConfig_report_bitrate(const moq_mux_container_Producer_Container_JsonConfig *self, moq_bandwidth_Rate bitrate, moq_status *status); moq_track_Producer *moq_mux_container_Producer_Container_JsonConfig_track(const moq_mux_container_Producer_Container_JsonConfig *self, moq_status *status); -moq_Timestamp *moq_mux_container_Producer_Container_JsonConfig_live_edge(const moq_mux_container_Producer_Container_JsonConfig *self, moq_status *status); +moq_option_Timestamp moq_mux_container_Producer_Container_JsonConfig_live_edge(const moq_mux_container_Producer_Container_JsonConfig *self, moq_status *status); bool moq_mux_container_Producer_Container_JsonConfig_write(moq_mux_container_Producer_Container_JsonConfig *self, moq_mux_container_Frame frame, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_Container_JsonConfig_cut(moq_mux_container_Producer_Container_JsonConfig *self, const moq_Timestamp *end, moq_mux_Error **err, moq_status *status); +bool moq_mux_container_Producer_Container_JsonConfig_cut(moq_mux_container_Producer_Container_JsonConfig *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_Container_JsonConfig_seek(moq_mux_container_Producer_Container_JsonConfig *self, uint64_t start, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_Container_JsonConfig_discontinuity(moq_mux_container_Producer_Container_JsonConfig *self, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_Container_JsonConfig_finish(moq_mux_container_Producer_Container_JsonConfig *self, moq_mux_container_Finished_Container_JsonConfig **out, moq_mux_Error **err, moq_status *status); @@ -6353,7 +6356,7 @@ moq_track_Subscriber *moq_mux_container_Producer_Container_JsonConfig_consume(co moq_broadcast_Info *moq_mux_container_Producer_Container_JsonConfig_broadcast(const moq_mux_container_Producer_Container_JsonConfig *self, moq_status *status); moq_track_Info *moq_mux_container_Producer_Container_JsonConfig_info(const moq_mux_container_Producer_Container_JsonConfig *self, moq_status *status); bool moq_mux_container_Producer_Container_JsonConfig_create_group(const moq_mux_container_Producer_Container_JsonConfig *self, moq_group_Info group, moq_group_Producer **out, moq_Error **err, moq_status *status); -bool moq_mux_container_Producer_Container_JsonConfig_append_group(const moq_mux_container_Producer_Container_JsonConfig *self, const moq_Timestamp *start, moq_group_Producer **out, moq_Error **err, moq_status *status); +bool moq_mux_container_Producer_Container_JsonConfig_append_group(const moq_mux_container_Producer_Container_JsonConfig *self, moq_Timestamp start, moq_group_Producer **out, moq_Error **err, moq_status *status); void moq_mux_container_Producer_Container_JsonConfig_skip_groups(const moq_mux_container_Producer_Container_JsonConfig *self, moq_range_u64 groups, moq_status *status); moq_option_track_Position moq_mux_container_Producer_Container_JsonConfig_finished(const moq_mux_container_Producer_Container_JsonConfig *self, moq_status *status); typedef struct moq_mux_container_Producer_Container_JsonConfig_closed_future moq_mux_container_Producer_Container_JsonConfig_closed_future; @@ -6373,21 +6376,21 @@ void moq_mux_container_Producer_Container_TextConfig_drop(moq_mux_container_Prod bool moq_mux_container_Producer_Container_TextConfig_set(moq_mux_container_Producer_Container_TextConfig *self, moq_hang_catalog_TextConfig *config, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_Container_TextConfig_set_bitrate(moq_mux_container_Producer_Container_TextConfig *self, uint64_t bitrate, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_Container_TextConfig_modify(moq_mux_container_Producer_Container_TextConfig *self, moq_mux_container_Guard_TextConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_Container_TextConfig_timestamp(const moq_mux_container_Producer_Container_TextConfig *self, const moq_Timestamp *hint, moq_Timestamp **out, moq_mux_Error **err, moq_status *status); +bool moq_mux_container_Producer_Container_TextConfig_timestamp(const moq_mux_container_Producer_Container_TextConfig *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); moq_buf moq_mux_container_Producer_Container_TextConfig_name(const moq_mux_container_Producer_Container_TextConfig *self, moq_status *status); moq_track_Demand *moq_mux_container_Producer_Container_TextConfig_demand(const moq_mux_container_Producer_Container_TextConfig *self, moq_status *status); moq_mux_catalog_Estimate *moq_mux_container_Producer_Container_TextConfig_estimate(const moq_mux_container_Producer_Container_TextConfig *self, moq_status *status); -void moq_mux_container_Producer_Container_TextConfig_reorder(moq_mux_container_Producer_Container_TextConfig *self, const moq_Timestamp *delay, moq_status *status); -void moq_mux_container_Producer_Container_TextConfig_history(moq_mux_container_Producer_Container_TextConfig *self, const moq_Timestamp *until, moq_status *status); +void moq_mux_container_Producer_Container_TextConfig_reorder(moq_mux_container_Producer_Container_TextConfig *self, moq_Timestamp delay, moq_status *status); +void moq_mux_container_Producer_Container_TextConfig_history(moq_mux_container_Producer_Container_TextConfig *self, moq_Timestamp until, moq_status *status); bool moq_mux_container_Producer_Container_TextConfig_needs_keyframe(const moq_mux_container_Producer_Container_TextConfig *self, moq_status *status); moq_mux_container_Producer_Container_TextConfig *moq_mux_container_Producer_Container_TextConfig_with_buffer(moq_mux_container_Producer_Container_TextConfig *self, moq_duration duration, moq_status *status); moq_mux_container_Producer_Container_TextConfig *moq_mux_container_Producer_Container_TextConfig_with_bandwidth(moq_mux_container_Producer_Container_TextConfig *self, moq_bandwidth_Allocator *allocator, moq_status *status); void moq_mux_container_Producer_Container_TextConfig_report_skipped(const moq_mux_container_Producer_Container_TextConfig *self, uint64_t frames, moq_status *status); void moq_mux_container_Producer_Container_TextConfig_report_bitrate(const moq_mux_container_Producer_Container_TextConfig *self, moq_bandwidth_Rate bitrate, moq_status *status); moq_track_Producer *moq_mux_container_Producer_Container_TextConfig_track(const moq_mux_container_Producer_Container_TextConfig *self, moq_status *status); -moq_Timestamp *moq_mux_container_Producer_Container_TextConfig_live_edge(const moq_mux_container_Producer_Container_TextConfig *self, moq_status *status); +moq_option_Timestamp moq_mux_container_Producer_Container_TextConfig_live_edge(const moq_mux_container_Producer_Container_TextConfig *self, moq_status *status); bool moq_mux_container_Producer_Container_TextConfig_write(moq_mux_container_Producer_Container_TextConfig *self, moq_mux_container_Frame frame, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_Container_TextConfig_cut(moq_mux_container_Producer_Container_TextConfig *self, const moq_Timestamp *end, moq_mux_Error **err, moq_status *status); +bool moq_mux_container_Producer_Container_TextConfig_cut(moq_mux_container_Producer_Container_TextConfig *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_Container_TextConfig_seek(moq_mux_container_Producer_Container_TextConfig *self, uint64_t start, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_Container_TextConfig_discontinuity(moq_mux_container_Producer_Container_TextConfig *self, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_Container_TextConfig_finish(moq_mux_container_Producer_Container_TextConfig *self, moq_mux_container_Finished_Container_TextConfig **out, moq_mux_Error **err, moq_status *status); @@ -6398,7 +6401,7 @@ moq_track_Subscriber *moq_mux_container_Producer_Container_TextConfig_consume(co moq_broadcast_Info *moq_mux_container_Producer_Container_TextConfig_broadcast(const moq_mux_container_Producer_Container_TextConfig *self, moq_status *status); moq_track_Info *moq_mux_container_Producer_Container_TextConfig_info(const moq_mux_container_Producer_Container_TextConfig *self, moq_status *status); bool moq_mux_container_Producer_Container_TextConfig_create_group(const moq_mux_container_Producer_Container_TextConfig *self, moq_group_Info group, moq_group_Producer **out, moq_Error **err, moq_status *status); -bool moq_mux_container_Producer_Container_TextConfig_append_group(const moq_mux_container_Producer_Container_TextConfig *self, const moq_Timestamp *start, moq_group_Producer **out, moq_Error **err, moq_status *status); +bool moq_mux_container_Producer_Container_TextConfig_append_group(const moq_mux_container_Producer_Container_TextConfig *self, moq_Timestamp start, moq_group_Producer **out, moq_Error **err, moq_status *status); void moq_mux_container_Producer_Container_TextConfig_skip_groups(const moq_mux_container_Producer_Container_TextConfig *self, moq_range_u64 groups, moq_status *status); moq_option_track_Position moq_mux_container_Producer_Container_TextConfig_finished(const moq_mux_container_Producer_Container_TextConfig *self, moq_status *status); typedef struct moq_mux_container_Producer_Container_TextConfig_closed_future moq_mux_container_Producer_Container_TextConfig_closed_future; @@ -6418,21 +6421,21 @@ void moq_mux_container_Producer_Container_VideoConfig_drop(moq_mux_container_Pro bool moq_mux_container_Producer_Container_VideoConfig_set(moq_mux_container_Producer_Container_VideoConfig *self, moq_hang_catalog_VideoConfig *config, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_Container_VideoConfig_set_bitrate(moq_mux_container_Producer_Container_VideoConfig *self, uint64_t bitrate, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_Container_VideoConfig_modify(moq_mux_container_Producer_Container_VideoConfig *self, moq_mux_container_Guard_VideoConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_Container_VideoConfig_timestamp(const moq_mux_container_Producer_Container_VideoConfig *self, const moq_Timestamp *hint, moq_Timestamp **out, moq_mux_Error **err, moq_status *status); +bool moq_mux_container_Producer_Container_VideoConfig_timestamp(const moq_mux_container_Producer_Container_VideoConfig *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); moq_buf moq_mux_container_Producer_Container_VideoConfig_name(const moq_mux_container_Producer_Container_VideoConfig *self, moq_status *status); moq_track_Demand *moq_mux_container_Producer_Container_VideoConfig_demand(const moq_mux_container_Producer_Container_VideoConfig *self, moq_status *status); moq_mux_catalog_Estimate *moq_mux_container_Producer_Container_VideoConfig_estimate(const moq_mux_container_Producer_Container_VideoConfig *self, moq_status *status); -void moq_mux_container_Producer_Container_VideoConfig_reorder(moq_mux_container_Producer_Container_VideoConfig *self, const moq_Timestamp *delay, moq_status *status); -void moq_mux_container_Producer_Container_VideoConfig_history(moq_mux_container_Producer_Container_VideoConfig *self, const moq_Timestamp *until, moq_status *status); +void moq_mux_container_Producer_Container_VideoConfig_reorder(moq_mux_container_Producer_Container_VideoConfig *self, moq_Timestamp delay, moq_status *status); +void moq_mux_container_Producer_Container_VideoConfig_history(moq_mux_container_Producer_Container_VideoConfig *self, moq_Timestamp until, moq_status *status); bool moq_mux_container_Producer_Container_VideoConfig_needs_keyframe(const moq_mux_container_Producer_Container_VideoConfig *self, moq_status *status); moq_mux_container_Producer_Container_VideoConfig *moq_mux_container_Producer_Container_VideoConfig_with_buffer(moq_mux_container_Producer_Container_VideoConfig *self, moq_duration duration, moq_status *status); moq_mux_container_Producer_Container_VideoConfig *moq_mux_container_Producer_Container_VideoConfig_with_bandwidth(moq_mux_container_Producer_Container_VideoConfig *self, moq_bandwidth_Allocator *allocator, moq_status *status); void moq_mux_container_Producer_Container_VideoConfig_report_skipped(const moq_mux_container_Producer_Container_VideoConfig *self, uint64_t frames, moq_status *status); void moq_mux_container_Producer_Container_VideoConfig_report_bitrate(const moq_mux_container_Producer_Container_VideoConfig *self, moq_bandwidth_Rate bitrate, moq_status *status); moq_track_Producer *moq_mux_container_Producer_Container_VideoConfig_track(const moq_mux_container_Producer_Container_VideoConfig *self, moq_status *status); -moq_Timestamp *moq_mux_container_Producer_Container_VideoConfig_live_edge(const moq_mux_container_Producer_Container_VideoConfig *self, moq_status *status); +moq_option_Timestamp moq_mux_container_Producer_Container_VideoConfig_live_edge(const moq_mux_container_Producer_Container_VideoConfig *self, moq_status *status); bool moq_mux_container_Producer_Container_VideoConfig_write(moq_mux_container_Producer_Container_VideoConfig *self, moq_mux_container_Frame frame, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_Container_VideoConfig_cut(moq_mux_container_Producer_Container_VideoConfig *self, const moq_Timestamp *end, moq_mux_Error **err, moq_status *status); +bool moq_mux_container_Producer_Container_VideoConfig_cut(moq_mux_container_Producer_Container_VideoConfig *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_Container_VideoConfig_seek(moq_mux_container_Producer_Container_VideoConfig *self, uint64_t start, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_Container_VideoConfig_discontinuity(moq_mux_container_Producer_Container_VideoConfig *self, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_Container_VideoConfig_finish(moq_mux_container_Producer_Container_VideoConfig *self, moq_mux_container_Finished_Container_VideoConfig **out, moq_mux_Error **err, moq_status *status); @@ -6443,7 +6446,7 @@ moq_track_Subscriber *moq_mux_container_Producer_Container_VideoConfig_consume(c moq_broadcast_Info *moq_mux_container_Producer_Container_VideoConfig_broadcast(const moq_mux_container_Producer_Container_VideoConfig *self, moq_status *status); moq_track_Info *moq_mux_container_Producer_Container_VideoConfig_info(const moq_mux_container_Producer_Container_VideoConfig *self, moq_status *status); bool moq_mux_container_Producer_Container_VideoConfig_create_group(const moq_mux_container_Producer_Container_VideoConfig *self, moq_group_Info group, moq_group_Producer **out, moq_Error **err, moq_status *status); -bool moq_mux_container_Producer_Container_VideoConfig_append_group(const moq_mux_container_Producer_Container_VideoConfig *self, const moq_Timestamp *start, moq_group_Producer **out, moq_Error **err, moq_status *status); +bool moq_mux_container_Producer_Container_VideoConfig_append_group(const moq_mux_container_Producer_Container_VideoConfig *self, moq_Timestamp start, moq_group_Producer **out, moq_Error **err, moq_status *status); void moq_mux_container_Producer_Container_VideoConfig_skip_groups(const moq_mux_container_Producer_Container_VideoConfig *self, moq_range_u64 groups, moq_status *status); moq_option_track_Position moq_mux_container_Producer_Container_VideoConfig_finished(const moq_mux_container_Producer_Container_VideoConfig *self, moq_status *status); typedef struct moq_mux_container_Producer_Container_VideoConfig_closed_future moq_mux_container_Producer_Container_VideoConfig_closed_future; @@ -6464,21 +6467,21 @@ moq_mux_container_Producer_Container *moq_mux_container_Producer_Container_new(m bool moq_mux_container_Producer_Container_set(moq_mux_container_Producer_Container *self, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_Container_set_bitrate(moq_mux_container_Producer_Container *self, uint64_t bitrate, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_Container_modify(moq_mux_container_Producer_Container *self, moq_mux_container_Guard_unit **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_Container_timestamp(const moq_mux_container_Producer_Container *self, const moq_Timestamp *hint, moq_Timestamp **out, moq_mux_Error **err, moq_status *status); +bool moq_mux_container_Producer_Container_timestamp(const moq_mux_container_Producer_Container *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); moq_buf moq_mux_container_Producer_Container_name(const moq_mux_container_Producer_Container *self, moq_status *status); moq_track_Demand *moq_mux_container_Producer_Container_demand(const moq_mux_container_Producer_Container *self, moq_status *status); moq_mux_catalog_Estimate *moq_mux_container_Producer_Container_estimate(const moq_mux_container_Producer_Container *self, moq_status *status); -void moq_mux_container_Producer_Container_reorder(moq_mux_container_Producer_Container *self, const moq_Timestamp *delay, moq_status *status); -void moq_mux_container_Producer_Container_history(moq_mux_container_Producer_Container *self, const moq_Timestamp *until, moq_status *status); +void moq_mux_container_Producer_Container_reorder(moq_mux_container_Producer_Container *self, moq_Timestamp delay, moq_status *status); +void moq_mux_container_Producer_Container_history(moq_mux_container_Producer_Container *self, moq_Timestamp until, moq_status *status); bool moq_mux_container_Producer_Container_needs_keyframe(const moq_mux_container_Producer_Container *self, moq_status *status); moq_mux_container_Producer_Container *moq_mux_container_Producer_Container_with_buffer(moq_mux_container_Producer_Container *self, moq_duration duration, moq_status *status); moq_mux_container_Producer_Container *moq_mux_container_Producer_Container_with_bandwidth(moq_mux_container_Producer_Container *self, moq_bandwidth_Allocator *allocator, moq_status *status); void moq_mux_container_Producer_Container_report_skipped(const moq_mux_container_Producer_Container *self, uint64_t frames, moq_status *status); void moq_mux_container_Producer_Container_report_bitrate(const moq_mux_container_Producer_Container *self, moq_bandwidth_Rate bitrate, moq_status *status); moq_track_Producer *moq_mux_container_Producer_Container_track(const moq_mux_container_Producer_Container *self, moq_status *status); -moq_Timestamp *moq_mux_container_Producer_Container_live_edge(const moq_mux_container_Producer_Container *self, moq_status *status); +moq_option_Timestamp moq_mux_container_Producer_Container_live_edge(const moq_mux_container_Producer_Container *self, moq_status *status); bool moq_mux_container_Producer_Container_write(moq_mux_container_Producer_Container *self, moq_mux_container_Frame frame, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_Container_cut(moq_mux_container_Producer_Container *self, const moq_Timestamp *end, moq_mux_Error **err, moq_status *status); +bool moq_mux_container_Producer_Container_cut(moq_mux_container_Producer_Container *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_Container_seek(moq_mux_container_Producer_Container *self, uint64_t start, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_Container_discontinuity(moq_mux_container_Producer_Container *self, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_Container_finish(moq_mux_container_Producer_Container *self, moq_mux_container_Finished_Container **out, moq_mux_Error **err, moq_status *status); @@ -6489,7 +6492,7 @@ moq_track_Subscriber *moq_mux_container_Producer_Container_consume(const moq_mux moq_broadcast_Info *moq_mux_container_Producer_Container_broadcast(const moq_mux_container_Producer_Container *self, moq_status *status); moq_track_Info *moq_mux_container_Producer_Container_info(const moq_mux_container_Producer_Container *self, moq_status *status); bool moq_mux_container_Producer_Container_create_group(const moq_mux_container_Producer_Container *self, moq_group_Info group, moq_group_Producer **out, moq_Error **err, moq_status *status); -bool moq_mux_container_Producer_Container_append_group(const moq_mux_container_Producer_Container *self, const moq_Timestamp *start, moq_group_Producer **out, moq_Error **err, moq_status *status); +bool moq_mux_container_Producer_Container_append_group(const moq_mux_container_Producer_Container *self, moq_Timestamp start, moq_group_Producer **out, moq_Error **err, moq_status *status); void moq_mux_container_Producer_Container_skip_groups(const moq_mux_container_Producer_Container *self, moq_range_u64 groups, moq_status *status); moq_option_track_Position moq_mux_container_Producer_Container_finished(const moq_mux_container_Producer_Container *self, moq_status *status); typedef struct moq_mux_container_Producer_Container_closed_future moq_mux_container_Producer_Container_closed_future; @@ -6509,21 +6512,21 @@ void moq_mux_container_Producer_fmp4_Wire_AudioConfig_drop(moq_mux_container_Pro bool moq_mux_container_Producer_fmp4_Wire_AudioConfig_set(moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_hang_catalog_AudioConfig *config, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_fmp4_Wire_AudioConfig_set_bitrate(moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, uint64_t bitrate, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_fmp4_Wire_AudioConfig_modify(moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_mux_container_Guard_AudioConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_AudioConfig_timestamp(const moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, const moq_Timestamp *hint, moq_Timestamp **out, moq_mux_Error **err, moq_status *status); +bool moq_mux_container_Producer_fmp4_Wire_AudioConfig_timestamp(const moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); moq_buf moq_mux_container_Producer_fmp4_Wire_AudioConfig_name(const moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_status *status); moq_track_Demand *moq_mux_container_Producer_fmp4_Wire_AudioConfig_demand(const moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_status *status); moq_mux_catalog_Estimate *moq_mux_container_Producer_fmp4_Wire_AudioConfig_estimate(const moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_status *status); -void moq_mux_container_Producer_fmp4_Wire_AudioConfig_reorder(moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, const moq_Timestamp *delay, moq_status *status); -void moq_mux_container_Producer_fmp4_Wire_AudioConfig_history(moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, const moq_Timestamp *until, moq_status *status); +void moq_mux_container_Producer_fmp4_Wire_AudioConfig_reorder(moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_Timestamp delay, moq_status *status); +void moq_mux_container_Producer_fmp4_Wire_AudioConfig_history(moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_Timestamp until, moq_status *status); bool moq_mux_container_Producer_fmp4_Wire_AudioConfig_needs_keyframe(const moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_status *status); moq_mux_container_Producer_fmp4_Wire_AudioConfig *moq_mux_container_Producer_fmp4_Wire_AudioConfig_with_buffer(moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_duration duration, moq_status *status); moq_mux_container_Producer_fmp4_Wire_AudioConfig *moq_mux_container_Producer_fmp4_Wire_AudioConfig_with_bandwidth(moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_bandwidth_Allocator *allocator, moq_status *status); void moq_mux_container_Producer_fmp4_Wire_AudioConfig_report_skipped(const moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, uint64_t frames, moq_status *status); void moq_mux_container_Producer_fmp4_Wire_AudioConfig_report_bitrate(const moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_bandwidth_Rate bitrate, moq_status *status); moq_track_Producer *moq_mux_container_Producer_fmp4_Wire_AudioConfig_track(const moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_status *status); -moq_Timestamp *moq_mux_container_Producer_fmp4_Wire_AudioConfig_live_edge(const moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_status *status); +moq_option_Timestamp moq_mux_container_Producer_fmp4_Wire_AudioConfig_live_edge(const moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_status *status); bool moq_mux_container_Producer_fmp4_Wire_AudioConfig_write(moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_mux_container_Frame frame, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_AudioConfig_cut(moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, const moq_Timestamp *end, moq_mux_Error **err, moq_status *status); +bool moq_mux_container_Producer_fmp4_Wire_AudioConfig_cut(moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_fmp4_Wire_AudioConfig_seek(moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, uint64_t start, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_fmp4_Wire_AudioConfig_discontinuity(moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_fmp4_Wire_AudioConfig_finish(moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_mux_container_Finished_fmp4_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); @@ -6534,7 +6537,7 @@ moq_track_Subscriber *moq_mux_container_Producer_fmp4_Wire_AudioConfig_consume(c moq_broadcast_Info *moq_mux_container_Producer_fmp4_Wire_AudioConfig_broadcast(const moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_status *status); moq_track_Info *moq_mux_container_Producer_fmp4_Wire_AudioConfig_info(const moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_status *status); bool moq_mux_container_Producer_fmp4_Wire_AudioConfig_create_group(const moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_group_Info group, moq_group_Producer **out, moq_Error **err, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_AudioConfig_append_group(const moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, const moq_Timestamp *start, moq_group_Producer **out, moq_Error **err, moq_status *status); +bool moq_mux_container_Producer_fmp4_Wire_AudioConfig_append_group(const moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_Timestamp start, moq_group_Producer **out, moq_Error **err, moq_status *status); void moq_mux_container_Producer_fmp4_Wire_AudioConfig_skip_groups(const moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_range_u64 groups, moq_status *status); moq_option_track_Position moq_mux_container_Producer_fmp4_Wire_AudioConfig_finished(const moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_status *status); typedef struct moq_mux_container_Producer_fmp4_Wire_AudioConfig_closed_future moq_mux_container_Producer_fmp4_Wire_AudioConfig_closed_future; @@ -6554,21 +6557,21 @@ void moq_mux_container_Producer_fmp4_Wire_BinaryConfig_drop(moq_mux_container_Pr bool moq_mux_container_Producer_fmp4_Wire_BinaryConfig_set(moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_hang_catalog_BinaryConfig *config, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_fmp4_Wire_BinaryConfig_set_bitrate(moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, uint64_t bitrate, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_fmp4_Wire_BinaryConfig_modify(moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_mux_container_Guard_BinaryConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_BinaryConfig_timestamp(const moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, const moq_Timestamp *hint, moq_Timestamp **out, moq_mux_Error **err, moq_status *status); +bool moq_mux_container_Producer_fmp4_Wire_BinaryConfig_timestamp(const moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); moq_buf moq_mux_container_Producer_fmp4_Wire_BinaryConfig_name(const moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_status *status); moq_track_Demand *moq_mux_container_Producer_fmp4_Wire_BinaryConfig_demand(const moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_status *status); moq_mux_catalog_Estimate *moq_mux_container_Producer_fmp4_Wire_BinaryConfig_estimate(const moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_status *status); -void moq_mux_container_Producer_fmp4_Wire_BinaryConfig_reorder(moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, const moq_Timestamp *delay, moq_status *status); -void moq_mux_container_Producer_fmp4_Wire_BinaryConfig_history(moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, const moq_Timestamp *until, moq_status *status); +void moq_mux_container_Producer_fmp4_Wire_BinaryConfig_reorder(moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_Timestamp delay, moq_status *status); +void moq_mux_container_Producer_fmp4_Wire_BinaryConfig_history(moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_Timestamp until, moq_status *status); bool moq_mux_container_Producer_fmp4_Wire_BinaryConfig_needs_keyframe(const moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_status *status); moq_mux_container_Producer_fmp4_Wire_BinaryConfig *moq_mux_container_Producer_fmp4_Wire_BinaryConfig_with_buffer(moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_duration duration, moq_status *status); moq_mux_container_Producer_fmp4_Wire_BinaryConfig *moq_mux_container_Producer_fmp4_Wire_BinaryConfig_with_bandwidth(moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_bandwidth_Allocator *allocator, moq_status *status); void moq_mux_container_Producer_fmp4_Wire_BinaryConfig_report_skipped(const moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, uint64_t frames, moq_status *status); void moq_mux_container_Producer_fmp4_Wire_BinaryConfig_report_bitrate(const moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_bandwidth_Rate bitrate, moq_status *status); moq_track_Producer *moq_mux_container_Producer_fmp4_Wire_BinaryConfig_track(const moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_status *status); -moq_Timestamp *moq_mux_container_Producer_fmp4_Wire_BinaryConfig_live_edge(const moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_status *status); +moq_option_Timestamp moq_mux_container_Producer_fmp4_Wire_BinaryConfig_live_edge(const moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_status *status); bool moq_mux_container_Producer_fmp4_Wire_BinaryConfig_write(moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_mux_container_Frame frame, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_BinaryConfig_cut(moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, const moq_Timestamp *end, moq_mux_Error **err, moq_status *status); +bool moq_mux_container_Producer_fmp4_Wire_BinaryConfig_cut(moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_fmp4_Wire_BinaryConfig_seek(moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, uint64_t start, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_fmp4_Wire_BinaryConfig_discontinuity(moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_fmp4_Wire_BinaryConfig_finish(moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_mux_container_Finished_fmp4_Wire_BinaryConfig **out, moq_mux_Error **err, moq_status *status); @@ -6579,7 +6582,7 @@ moq_track_Subscriber *moq_mux_container_Producer_fmp4_Wire_BinaryConfig_consume( moq_broadcast_Info *moq_mux_container_Producer_fmp4_Wire_BinaryConfig_broadcast(const moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_status *status); moq_track_Info *moq_mux_container_Producer_fmp4_Wire_BinaryConfig_info(const moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_status *status); bool moq_mux_container_Producer_fmp4_Wire_BinaryConfig_create_group(const moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_group_Info group, moq_group_Producer **out, moq_Error **err, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_BinaryConfig_append_group(const moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, const moq_Timestamp *start, moq_group_Producer **out, moq_Error **err, moq_status *status); +bool moq_mux_container_Producer_fmp4_Wire_BinaryConfig_append_group(const moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_Timestamp start, moq_group_Producer **out, moq_Error **err, moq_status *status); void moq_mux_container_Producer_fmp4_Wire_BinaryConfig_skip_groups(const moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_range_u64 groups, moq_status *status); moq_option_track_Position moq_mux_container_Producer_fmp4_Wire_BinaryConfig_finished(const moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_status *status); typedef struct moq_mux_container_Producer_fmp4_Wire_BinaryConfig_closed_future moq_mux_container_Producer_fmp4_Wire_BinaryConfig_closed_future; @@ -6599,21 +6602,21 @@ void moq_mux_container_Producer_fmp4_Wire_JsonConfig_drop(moq_mux_container_Prod bool moq_mux_container_Producer_fmp4_Wire_JsonConfig_set(moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_hang_catalog_JsonConfig *config, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_fmp4_Wire_JsonConfig_set_bitrate(moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, uint64_t bitrate, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_fmp4_Wire_JsonConfig_modify(moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_mux_container_Guard_JsonConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_JsonConfig_timestamp(const moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, const moq_Timestamp *hint, moq_Timestamp **out, moq_mux_Error **err, moq_status *status); +bool moq_mux_container_Producer_fmp4_Wire_JsonConfig_timestamp(const moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); moq_buf moq_mux_container_Producer_fmp4_Wire_JsonConfig_name(const moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_status *status); moq_track_Demand *moq_mux_container_Producer_fmp4_Wire_JsonConfig_demand(const moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_status *status); moq_mux_catalog_Estimate *moq_mux_container_Producer_fmp4_Wire_JsonConfig_estimate(const moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_status *status); -void moq_mux_container_Producer_fmp4_Wire_JsonConfig_reorder(moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, const moq_Timestamp *delay, moq_status *status); -void moq_mux_container_Producer_fmp4_Wire_JsonConfig_history(moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, const moq_Timestamp *until, moq_status *status); +void moq_mux_container_Producer_fmp4_Wire_JsonConfig_reorder(moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_Timestamp delay, moq_status *status); +void moq_mux_container_Producer_fmp4_Wire_JsonConfig_history(moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_Timestamp until, moq_status *status); bool moq_mux_container_Producer_fmp4_Wire_JsonConfig_needs_keyframe(const moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_status *status); moq_mux_container_Producer_fmp4_Wire_JsonConfig *moq_mux_container_Producer_fmp4_Wire_JsonConfig_with_buffer(moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_duration duration, moq_status *status); moq_mux_container_Producer_fmp4_Wire_JsonConfig *moq_mux_container_Producer_fmp4_Wire_JsonConfig_with_bandwidth(moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_bandwidth_Allocator *allocator, moq_status *status); void moq_mux_container_Producer_fmp4_Wire_JsonConfig_report_skipped(const moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, uint64_t frames, moq_status *status); void moq_mux_container_Producer_fmp4_Wire_JsonConfig_report_bitrate(const moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_bandwidth_Rate bitrate, moq_status *status); moq_track_Producer *moq_mux_container_Producer_fmp4_Wire_JsonConfig_track(const moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_status *status); -moq_Timestamp *moq_mux_container_Producer_fmp4_Wire_JsonConfig_live_edge(const moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_status *status); +moq_option_Timestamp moq_mux_container_Producer_fmp4_Wire_JsonConfig_live_edge(const moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_status *status); bool moq_mux_container_Producer_fmp4_Wire_JsonConfig_write(moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_mux_container_Frame frame, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_JsonConfig_cut(moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, const moq_Timestamp *end, moq_mux_Error **err, moq_status *status); +bool moq_mux_container_Producer_fmp4_Wire_JsonConfig_cut(moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_fmp4_Wire_JsonConfig_seek(moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, uint64_t start, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_fmp4_Wire_JsonConfig_discontinuity(moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_fmp4_Wire_JsonConfig_finish(moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_mux_container_Finished_fmp4_Wire_JsonConfig **out, moq_mux_Error **err, moq_status *status); @@ -6624,7 +6627,7 @@ moq_track_Subscriber *moq_mux_container_Producer_fmp4_Wire_JsonConfig_consume(co moq_broadcast_Info *moq_mux_container_Producer_fmp4_Wire_JsonConfig_broadcast(const moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_status *status); moq_track_Info *moq_mux_container_Producer_fmp4_Wire_JsonConfig_info(const moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_status *status); bool moq_mux_container_Producer_fmp4_Wire_JsonConfig_create_group(const moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_group_Info group, moq_group_Producer **out, moq_Error **err, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_JsonConfig_append_group(const moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, const moq_Timestamp *start, moq_group_Producer **out, moq_Error **err, moq_status *status); +bool moq_mux_container_Producer_fmp4_Wire_JsonConfig_append_group(const moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_Timestamp start, moq_group_Producer **out, moq_Error **err, moq_status *status); void moq_mux_container_Producer_fmp4_Wire_JsonConfig_skip_groups(const moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_range_u64 groups, moq_status *status); moq_option_track_Position moq_mux_container_Producer_fmp4_Wire_JsonConfig_finished(const moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_status *status); typedef struct moq_mux_container_Producer_fmp4_Wire_JsonConfig_closed_future moq_mux_container_Producer_fmp4_Wire_JsonConfig_closed_future; @@ -6644,21 +6647,21 @@ void moq_mux_container_Producer_fmp4_Wire_TextConfig_drop(moq_mux_container_Prod bool moq_mux_container_Producer_fmp4_Wire_TextConfig_set(moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_hang_catalog_TextConfig *config, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_fmp4_Wire_TextConfig_set_bitrate(moq_mux_container_Producer_fmp4_Wire_TextConfig *self, uint64_t bitrate, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_fmp4_Wire_TextConfig_modify(moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_mux_container_Guard_TextConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_TextConfig_timestamp(const moq_mux_container_Producer_fmp4_Wire_TextConfig *self, const moq_Timestamp *hint, moq_Timestamp **out, moq_mux_Error **err, moq_status *status); +bool moq_mux_container_Producer_fmp4_Wire_TextConfig_timestamp(const moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); moq_buf moq_mux_container_Producer_fmp4_Wire_TextConfig_name(const moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_status *status); moq_track_Demand *moq_mux_container_Producer_fmp4_Wire_TextConfig_demand(const moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_status *status); moq_mux_catalog_Estimate *moq_mux_container_Producer_fmp4_Wire_TextConfig_estimate(const moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_status *status); -void moq_mux_container_Producer_fmp4_Wire_TextConfig_reorder(moq_mux_container_Producer_fmp4_Wire_TextConfig *self, const moq_Timestamp *delay, moq_status *status); -void moq_mux_container_Producer_fmp4_Wire_TextConfig_history(moq_mux_container_Producer_fmp4_Wire_TextConfig *self, const moq_Timestamp *until, moq_status *status); +void moq_mux_container_Producer_fmp4_Wire_TextConfig_reorder(moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_Timestamp delay, moq_status *status); +void moq_mux_container_Producer_fmp4_Wire_TextConfig_history(moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_Timestamp until, moq_status *status); bool moq_mux_container_Producer_fmp4_Wire_TextConfig_needs_keyframe(const moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_status *status); moq_mux_container_Producer_fmp4_Wire_TextConfig *moq_mux_container_Producer_fmp4_Wire_TextConfig_with_buffer(moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_duration duration, moq_status *status); moq_mux_container_Producer_fmp4_Wire_TextConfig *moq_mux_container_Producer_fmp4_Wire_TextConfig_with_bandwidth(moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_bandwidth_Allocator *allocator, moq_status *status); void moq_mux_container_Producer_fmp4_Wire_TextConfig_report_skipped(const moq_mux_container_Producer_fmp4_Wire_TextConfig *self, uint64_t frames, moq_status *status); void moq_mux_container_Producer_fmp4_Wire_TextConfig_report_bitrate(const moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_bandwidth_Rate bitrate, moq_status *status); moq_track_Producer *moq_mux_container_Producer_fmp4_Wire_TextConfig_track(const moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_status *status); -moq_Timestamp *moq_mux_container_Producer_fmp4_Wire_TextConfig_live_edge(const moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_status *status); +moq_option_Timestamp moq_mux_container_Producer_fmp4_Wire_TextConfig_live_edge(const moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_status *status); bool moq_mux_container_Producer_fmp4_Wire_TextConfig_write(moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_mux_container_Frame frame, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_TextConfig_cut(moq_mux_container_Producer_fmp4_Wire_TextConfig *self, const moq_Timestamp *end, moq_mux_Error **err, moq_status *status); +bool moq_mux_container_Producer_fmp4_Wire_TextConfig_cut(moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_fmp4_Wire_TextConfig_seek(moq_mux_container_Producer_fmp4_Wire_TextConfig *self, uint64_t start, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_fmp4_Wire_TextConfig_discontinuity(moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_fmp4_Wire_TextConfig_finish(moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_mux_container_Finished_fmp4_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); @@ -6669,7 +6672,7 @@ moq_track_Subscriber *moq_mux_container_Producer_fmp4_Wire_TextConfig_consume(co moq_broadcast_Info *moq_mux_container_Producer_fmp4_Wire_TextConfig_broadcast(const moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_status *status); moq_track_Info *moq_mux_container_Producer_fmp4_Wire_TextConfig_info(const moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_status *status); bool moq_mux_container_Producer_fmp4_Wire_TextConfig_create_group(const moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_group_Info group, moq_group_Producer **out, moq_Error **err, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_TextConfig_append_group(const moq_mux_container_Producer_fmp4_Wire_TextConfig *self, const moq_Timestamp *start, moq_group_Producer **out, moq_Error **err, moq_status *status); +bool moq_mux_container_Producer_fmp4_Wire_TextConfig_append_group(const moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_Timestamp start, moq_group_Producer **out, moq_Error **err, moq_status *status); void moq_mux_container_Producer_fmp4_Wire_TextConfig_skip_groups(const moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_range_u64 groups, moq_status *status); moq_option_track_Position moq_mux_container_Producer_fmp4_Wire_TextConfig_finished(const moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_status *status); typedef struct moq_mux_container_Producer_fmp4_Wire_TextConfig_closed_future moq_mux_container_Producer_fmp4_Wire_TextConfig_closed_future; @@ -6689,21 +6692,21 @@ void moq_mux_container_Producer_fmp4_Wire_VideoConfig_drop(moq_mux_container_Pro bool moq_mux_container_Producer_fmp4_Wire_VideoConfig_set(moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_hang_catalog_VideoConfig *config, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_fmp4_Wire_VideoConfig_set_bitrate(moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, uint64_t bitrate, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_fmp4_Wire_VideoConfig_modify(moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_mux_container_Guard_VideoConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_VideoConfig_timestamp(const moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, const moq_Timestamp *hint, moq_Timestamp **out, moq_mux_Error **err, moq_status *status); +bool moq_mux_container_Producer_fmp4_Wire_VideoConfig_timestamp(const moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); moq_buf moq_mux_container_Producer_fmp4_Wire_VideoConfig_name(const moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_status *status); moq_track_Demand *moq_mux_container_Producer_fmp4_Wire_VideoConfig_demand(const moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_status *status); moq_mux_catalog_Estimate *moq_mux_container_Producer_fmp4_Wire_VideoConfig_estimate(const moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_status *status); -void moq_mux_container_Producer_fmp4_Wire_VideoConfig_reorder(moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, const moq_Timestamp *delay, moq_status *status); -void moq_mux_container_Producer_fmp4_Wire_VideoConfig_history(moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, const moq_Timestamp *until, moq_status *status); +void moq_mux_container_Producer_fmp4_Wire_VideoConfig_reorder(moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_Timestamp delay, moq_status *status); +void moq_mux_container_Producer_fmp4_Wire_VideoConfig_history(moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_Timestamp until, moq_status *status); bool moq_mux_container_Producer_fmp4_Wire_VideoConfig_needs_keyframe(const moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_status *status); moq_mux_container_Producer_fmp4_Wire_VideoConfig *moq_mux_container_Producer_fmp4_Wire_VideoConfig_with_buffer(moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_duration duration, moq_status *status); moq_mux_container_Producer_fmp4_Wire_VideoConfig *moq_mux_container_Producer_fmp4_Wire_VideoConfig_with_bandwidth(moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_bandwidth_Allocator *allocator, moq_status *status); void moq_mux_container_Producer_fmp4_Wire_VideoConfig_report_skipped(const moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, uint64_t frames, moq_status *status); void moq_mux_container_Producer_fmp4_Wire_VideoConfig_report_bitrate(const moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_bandwidth_Rate bitrate, moq_status *status); moq_track_Producer *moq_mux_container_Producer_fmp4_Wire_VideoConfig_track(const moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_status *status); -moq_Timestamp *moq_mux_container_Producer_fmp4_Wire_VideoConfig_live_edge(const moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_status *status); +moq_option_Timestamp moq_mux_container_Producer_fmp4_Wire_VideoConfig_live_edge(const moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_status *status); bool moq_mux_container_Producer_fmp4_Wire_VideoConfig_write(moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_mux_container_Frame frame, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_VideoConfig_cut(moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, const moq_Timestamp *end, moq_mux_Error **err, moq_status *status); +bool moq_mux_container_Producer_fmp4_Wire_VideoConfig_cut(moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_fmp4_Wire_VideoConfig_seek(moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, uint64_t start, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_fmp4_Wire_VideoConfig_discontinuity(moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_fmp4_Wire_VideoConfig_finish(moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_mux_container_Finished_fmp4_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); @@ -6714,7 +6717,7 @@ moq_track_Subscriber *moq_mux_container_Producer_fmp4_Wire_VideoConfig_consume(c moq_broadcast_Info *moq_mux_container_Producer_fmp4_Wire_VideoConfig_broadcast(const moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_status *status); moq_track_Info *moq_mux_container_Producer_fmp4_Wire_VideoConfig_info(const moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_status *status); bool moq_mux_container_Producer_fmp4_Wire_VideoConfig_create_group(const moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_group_Info group, moq_group_Producer **out, moq_Error **err, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_VideoConfig_append_group(const moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, const moq_Timestamp *start, moq_group_Producer **out, moq_Error **err, moq_status *status); +bool moq_mux_container_Producer_fmp4_Wire_VideoConfig_append_group(const moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_Timestamp start, moq_group_Producer **out, moq_Error **err, moq_status *status); void moq_mux_container_Producer_fmp4_Wire_VideoConfig_skip_groups(const moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_range_u64 groups, moq_status *status); moq_option_track_Position moq_mux_container_Producer_fmp4_Wire_VideoConfig_finished(const moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_status *status); typedef struct moq_mux_container_Producer_fmp4_Wire_VideoConfig_closed_future moq_mux_container_Producer_fmp4_Wire_VideoConfig_closed_future; @@ -6735,21 +6738,21 @@ moq_mux_container_Producer_fmp4_Wire *moq_mux_container_Producer_fmp4_Wire_new(m bool moq_mux_container_Producer_fmp4_Wire_set(moq_mux_container_Producer_fmp4_Wire *self, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_fmp4_Wire_set_bitrate(moq_mux_container_Producer_fmp4_Wire *self, uint64_t bitrate, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_fmp4_Wire_modify(moq_mux_container_Producer_fmp4_Wire *self, moq_mux_container_Guard_unit **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_timestamp(const moq_mux_container_Producer_fmp4_Wire *self, const moq_Timestamp *hint, moq_Timestamp **out, moq_mux_Error **err, moq_status *status); +bool moq_mux_container_Producer_fmp4_Wire_timestamp(const moq_mux_container_Producer_fmp4_Wire *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); moq_buf moq_mux_container_Producer_fmp4_Wire_name(const moq_mux_container_Producer_fmp4_Wire *self, moq_status *status); moq_track_Demand *moq_mux_container_Producer_fmp4_Wire_demand(const moq_mux_container_Producer_fmp4_Wire *self, moq_status *status); moq_mux_catalog_Estimate *moq_mux_container_Producer_fmp4_Wire_estimate(const moq_mux_container_Producer_fmp4_Wire *self, moq_status *status); -void moq_mux_container_Producer_fmp4_Wire_reorder(moq_mux_container_Producer_fmp4_Wire *self, const moq_Timestamp *delay, moq_status *status); -void moq_mux_container_Producer_fmp4_Wire_history(moq_mux_container_Producer_fmp4_Wire *self, const moq_Timestamp *until, moq_status *status); +void moq_mux_container_Producer_fmp4_Wire_reorder(moq_mux_container_Producer_fmp4_Wire *self, moq_Timestamp delay, moq_status *status); +void moq_mux_container_Producer_fmp4_Wire_history(moq_mux_container_Producer_fmp4_Wire *self, moq_Timestamp until, moq_status *status); bool moq_mux_container_Producer_fmp4_Wire_needs_keyframe(const moq_mux_container_Producer_fmp4_Wire *self, moq_status *status); moq_mux_container_Producer_fmp4_Wire *moq_mux_container_Producer_fmp4_Wire_with_buffer(moq_mux_container_Producer_fmp4_Wire *self, moq_duration duration, moq_status *status); moq_mux_container_Producer_fmp4_Wire *moq_mux_container_Producer_fmp4_Wire_with_bandwidth(moq_mux_container_Producer_fmp4_Wire *self, moq_bandwidth_Allocator *allocator, moq_status *status); void moq_mux_container_Producer_fmp4_Wire_report_skipped(const moq_mux_container_Producer_fmp4_Wire *self, uint64_t frames, moq_status *status); void moq_mux_container_Producer_fmp4_Wire_report_bitrate(const moq_mux_container_Producer_fmp4_Wire *self, moq_bandwidth_Rate bitrate, moq_status *status); moq_track_Producer *moq_mux_container_Producer_fmp4_Wire_track(const moq_mux_container_Producer_fmp4_Wire *self, moq_status *status); -moq_Timestamp *moq_mux_container_Producer_fmp4_Wire_live_edge(const moq_mux_container_Producer_fmp4_Wire *self, moq_status *status); +moq_option_Timestamp moq_mux_container_Producer_fmp4_Wire_live_edge(const moq_mux_container_Producer_fmp4_Wire *self, moq_status *status); bool moq_mux_container_Producer_fmp4_Wire_write(moq_mux_container_Producer_fmp4_Wire *self, moq_mux_container_Frame frame, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_cut(moq_mux_container_Producer_fmp4_Wire *self, const moq_Timestamp *end, moq_mux_Error **err, moq_status *status); +bool moq_mux_container_Producer_fmp4_Wire_cut(moq_mux_container_Producer_fmp4_Wire *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_fmp4_Wire_seek(moq_mux_container_Producer_fmp4_Wire *self, uint64_t start, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_fmp4_Wire_discontinuity(moq_mux_container_Producer_fmp4_Wire *self, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_fmp4_Wire_finish(moq_mux_container_Producer_fmp4_Wire *self, moq_mux_container_Finished_fmp4_Wire **out, moq_mux_Error **err, moq_status *status); @@ -6760,7 +6763,7 @@ moq_track_Subscriber *moq_mux_container_Producer_fmp4_Wire_consume(const moq_mux moq_broadcast_Info *moq_mux_container_Producer_fmp4_Wire_broadcast(const moq_mux_container_Producer_fmp4_Wire *self, moq_status *status); moq_track_Info *moq_mux_container_Producer_fmp4_Wire_info(const moq_mux_container_Producer_fmp4_Wire *self, moq_status *status); bool moq_mux_container_Producer_fmp4_Wire_create_group(const moq_mux_container_Producer_fmp4_Wire *self, moq_group_Info group, moq_group_Producer **out, moq_Error **err, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_append_group(const moq_mux_container_Producer_fmp4_Wire *self, const moq_Timestamp *start, moq_group_Producer **out, moq_Error **err, moq_status *status); +bool moq_mux_container_Producer_fmp4_Wire_append_group(const moq_mux_container_Producer_fmp4_Wire *self, moq_Timestamp start, moq_group_Producer **out, moq_Error **err, moq_status *status); void moq_mux_container_Producer_fmp4_Wire_skip_groups(const moq_mux_container_Producer_fmp4_Wire *self, moq_range_u64 groups, moq_status *status); moq_option_track_Position moq_mux_container_Producer_fmp4_Wire_finished(const moq_mux_container_Producer_fmp4_Wire *self, moq_status *status); typedef struct moq_mux_container_Producer_fmp4_Wire_closed_future moq_mux_container_Producer_fmp4_Wire_closed_future; @@ -6780,21 +6783,21 @@ void moq_mux_container_Producer_legacy_Wire_AudioConfig_drop(moq_mux_container_P bool moq_mux_container_Producer_legacy_Wire_AudioConfig_set(moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_hang_catalog_AudioConfig *config, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_legacy_Wire_AudioConfig_set_bitrate(moq_mux_container_Producer_legacy_Wire_AudioConfig *self, uint64_t bitrate, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_legacy_Wire_AudioConfig_modify(moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_mux_container_Guard_AudioConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_AudioConfig_timestamp(const moq_mux_container_Producer_legacy_Wire_AudioConfig *self, const moq_Timestamp *hint, moq_Timestamp **out, moq_mux_Error **err, moq_status *status); +bool moq_mux_container_Producer_legacy_Wire_AudioConfig_timestamp(const moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); moq_buf moq_mux_container_Producer_legacy_Wire_AudioConfig_name(const moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_status *status); moq_track_Demand *moq_mux_container_Producer_legacy_Wire_AudioConfig_demand(const moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_status *status); moq_mux_catalog_Estimate *moq_mux_container_Producer_legacy_Wire_AudioConfig_estimate(const moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_status *status); -void moq_mux_container_Producer_legacy_Wire_AudioConfig_reorder(moq_mux_container_Producer_legacy_Wire_AudioConfig *self, const moq_Timestamp *delay, moq_status *status); -void moq_mux_container_Producer_legacy_Wire_AudioConfig_history(moq_mux_container_Producer_legacy_Wire_AudioConfig *self, const moq_Timestamp *until, moq_status *status); +void moq_mux_container_Producer_legacy_Wire_AudioConfig_reorder(moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_Timestamp delay, moq_status *status); +void moq_mux_container_Producer_legacy_Wire_AudioConfig_history(moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_Timestamp until, moq_status *status); bool moq_mux_container_Producer_legacy_Wire_AudioConfig_needs_keyframe(const moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_status *status); moq_mux_container_Producer_legacy_Wire_AudioConfig *moq_mux_container_Producer_legacy_Wire_AudioConfig_with_buffer(moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_duration duration, moq_status *status); moq_mux_container_Producer_legacy_Wire_AudioConfig *moq_mux_container_Producer_legacy_Wire_AudioConfig_with_bandwidth(moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_bandwidth_Allocator *allocator, moq_status *status); void moq_mux_container_Producer_legacy_Wire_AudioConfig_report_skipped(const moq_mux_container_Producer_legacy_Wire_AudioConfig *self, uint64_t frames, moq_status *status); void moq_mux_container_Producer_legacy_Wire_AudioConfig_report_bitrate(const moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_bandwidth_Rate bitrate, moq_status *status); moq_track_Producer *moq_mux_container_Producer_legacy_Wire_AudioConfig_track(const moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_status *status); -moq_Timestamp *moq_mux_container_Producer_legacy_Wire_AudioConfig_live_edge(const moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_status *status); +moq_option_Timestamp moq_mux_container_Producer_legacy_Wire_AudioConfig_live_edge(const moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_status *status); bool moq_mux_container_Producer_legacy_Wire_AudioConfig_write(moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_mux_container_Frame frame, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_AudioConfig_cut(moq_mux_container_Producer_legacy_Wire_AudioConfig *self, const moq_Timestamp *end, moq_mux_Error **err, moq_status *status); +bool moq_mux_container_Producer_legacy_Wire_AudioConfig_cut(moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_legacy_Wire_AudioConfig_seek(moq_mux_container_Producer_legacy_Wire_AudioConfig *self, uint64_t start, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_legacy_Wire_AudioConfig_discontinuity(moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_legacy_Wire_AudioConfig_finish(moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_mux_container_Finished_legacy_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); @@ -6805,7 +6808,7 @@ moq_track_Subscriber *moq_mux_container_Producer_legacy_Wire_AudioConfig_consume moq_broadcast_Info *moq_mux_container_Producer_legacy_Wire_AudioConfig_broadcast(const moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_status *status); moq_track_Info *moq_mux_container_Producer_legacy_Wire_AudioConfig_info(const moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_status *status); bool moq_mux_container_Producer_legacy_Wire_AudioConfig_create_group(const moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_group_Info group, moq_group_Producer **out, moq_Error **err, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_AudioConfig_append_group(const moq_mux_container_Producer_legacy_Wire_AudioConfig *self, const moq_Timestamp *start, moq_group_Producer **out, moq_Error **err, moq_status *status); +bool moq_mux_container_Producer_legacy_Wire_AudioConfig_append_group(const moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_Timestamp start, moq_group_Producer **out, moq_Error **err, moq_status *status); void moq_mux_container_Producer_legacy_Wire_AudioConfig_skip_groups(const moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_range_u64 groups, moq_status *status); moq_option_track_Position moq_mux_container_Producer_legacy_Wire_AudioConfig_finished(const moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_status *status); typedef struct moq_mux_container_Producer_legacy_Wire_AudioConfig_closed_future moq_mux_container_Producer_legacy_Wire_AudioConfig_closed_future; @@ -6825,21 +6828,21 @@ void moq_mux_container_Producer_legacy_Wire_BinaryConfig_drop(moq_mux_container_ bool moq_mux_container_Producer_legacy_Wire_BinaryConfig_set(moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_hang_catalog_BinaryConfig *config, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_legacy_Wire_BinaryConfig_set_bitrate(moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, uint64_t bitrate, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_legacy_Wire_BinaryConfig_modify(moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_mux_container_Guard_BinaryConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_BinaryConfig_timestamp(const moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, const moq_Timestamp *hint, moq_Timestamp **out, moq_mux_Error **err, moq_status *status); +bool moq_mux_container_Producer_legacy_Wire_BinaryConfig_timestamp(const moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); moq_buf moq_mux_container_Producer_legacy_Wire_BinaryConfig_name(const moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_status *status); moq_track_Demand *moq_mux_container_Producer_legacy_Wire_BinaryConfig_demand(const moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_status *status); moq_mux_catalog_Estimate *moq_mux_container_Producer_legacy_Wire_BinaryConfig_estimate(const moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_status *status); -void moq_mux_container_Producer_legacy_Wire_BinaryConfig_reorder(moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, const moq_Timestamp *delay, moq_status *status); -void moq_mux_container_Producer_legacy_Wire_BinaryConfig_history(moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, const moq_Timestamp *until, moq_status *status); +void moq_mux_container_Producer_legacy_Wire_BinaryConfig_reorder(moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_Timestamp delay, moq_status *status); +void moq_mux_container_Producer_legacy_Wire_BinaryConfig_history(moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_Timestamp until, moq_status *status); bool moq_mux_container_Producer_legacy_Wire_BinaryConfig_needs_keyframe(const moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_status *status); moq_mux_container_Producer_legacy_Wire_BinaryConfig *moq_mux_container_Producer_legacy_Wire_BinaryConfig_with_buffer(moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_duration duration, moq_status *status); moq_mux_container_Producer_legacy_Wire_BinaryConfig *moq_mux_container_Producer_legacy_Wire_BinaryConfig_with_bandwidth(moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_bandwidth_Allocator *allocator, moq_status *status); void moq_mux_container_Producer_legacy_Wire_BinaryConfig_report_skipped(const moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, uint64_t frames, moq_status *status); void moq_mux_container_Producer_legacy_Wire_BinaryConfig_report_bitrate(const moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_bandwidth_Rate bitrate, moq_status *status); moq_track_Producer *moq_mux_container_Producer_legacy_Wire_BinaryConfig_track(const moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_status *status); -moq_Timestamp *moq_mux_container_Producer_legacy_Wire_BinaryConfig_live_edge(const moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_status *status); +moq_option_Timestamp moq_mux_container_Producer_legacy_Wire_BinaryConfig_live_edge(const moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_status *status); bool moq_mux_container_Producer_legacy_Wire_BinaryConfig_write(moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_mux_container_Frame frame, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_BinaryConfig_cut(moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, const moq_Timestamp *end, moq_mux_Error **err, moq_status *status); +bool moq_mux_container_Producer_legacy_Wire_BinaryConfig_cut(moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_legacy_Wire_BinaryConfig_seek(moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, uint64_t start, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_legacy_Wire_BinaryConfig_discontinuity(moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_legacy_Wire_BinaryConfig_finish(moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_mux_container_Finished_legacy_Wire_BinaryConfig **out, moq_mux_Error **err, moq_status *status); @@ -6850,7 +6853,7 @@ moq_track_Subscriber *moq_mux_container_Producer_legacy_Wire_BinaryConfig_consum moq_broadcast_Info *moq_mux_container_Producer_legacy_Wire_BinaryConfig_broadcast(const moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_status *status); moq_track_Info *moq_mux_container_Producer_legacy_Wire_BinaryConfig_info(const moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_status *status); bool moq_mux_container_Producer_legacy_Wire_BinaryConfig_create_group(const moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_group_Info group, moq_group_Producer **out, moq_Error **err, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_BinaryConfig_append_group(const moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, const moq_Timestamp *start, moq_group_Producer **out, moq_Error **err, moq_status *status); +bool moq_mux_container_Producer_legacy_Wire_BinaryConfig_append_group(const moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_Timestamp start, moq_group_Producer **out, moq_Error **err, moq_status *status); void moq_mux_container_Producer_legacy_Wire_BinaryConfig_skip_groups(const moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_range_u64 groups, moq_status *status); moq_option_track_Position moq_mux_container_Producer_legacy_Wire_BinaryConfig_finished(const moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_status *status); typedef struct moq_mux_container_Producer_legacy_Wire_BinaryConfig_closed_future moq_mux_container_Producer_legacy_Wire_BinaryConfig_closed_future; @@ -6870,21 +6873,21 @@ void moq_mux_container_Producer_legacy_Wire_JsonConfig_drop(moq_mux_container_Pr bool moq_mux_container_Producer_legacy_Wire_JsonConfig_set(moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_hang_catalog_JsonConfig *config, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_legacy_Wire_JsonConfig_set_bitrate(moq_mux_container_Producer_legacy_Wire_JsonConfig *self, uint64_t bitrate, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_legacy_Wire_JsonConfig_modify(moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_mux_container_Guard_JsonConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_JsonConfig_timestamp(const moq_mux_container_Producer_legacy_Wire_JsonConfig *self, const moq_Timestamp *hint, moq_Timestamp **out, moq_mux_Error **err, moq_status *status); +bool moq_mux_container_Producer_legacy_Wire_JsonConfig_timestamp(const moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); moq_buf moq_mux_container_Producer_legacy_Wire_JsonConfig_name(const moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_status *status); moq_track_Demand *moq_mux_container_Producer_legacy_Wire_JsonConfig_demand(const moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_status *status); moq_mux_catalog_Estimate *moq_mux_container_Producer_legacy_Wire_JsonConfig_estimate(const moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_status *status); -void moq_mux_container_Producer_legacy_Wire_JsonConfig_reorder(moq_mux_container_Producer_legacy_Wire_JsonConfig *self, const moq_Timestamp *delay, moq_status *status); -void moq_mux_container_Producer_legacy_Wire_JsonConfig_history(moq_mux_container_Producer_legacy_Wire_JsonConfig *self, const moq_Timestamp *until, moq_status *status); +void moq_mux_container_Producer_legacy_Wire_JsonConfig_reorder(moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_Timestamp delay, moq_status *status); +void moq_mux_container_Producer_legacy_Wire_JsonConfig_history(moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_Timestamp until, moq_status *status); bool moq_mux_container_Producer_legacy_Wire_JsonConfig_needs_keyframe(const moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_status *status); moq_mux_container_Producer_legacy_Wire_JsonConfig *moq_mux_container_Producer_legacy_Wire_JsonConfig_with_buffer(moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_duration duration, moq_status *status); moq_mux_container_Producer_legacy_Wire_JsonConfig *moq_mux_container_Producer_legacy_Wire_JsonConfig_with_bandwidth(moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_bandwidth_Allocator *allocator, moq_status *status); void moq_mux_container_Producer_legacy_Wire_JsonConfig_report_skipped(const moq_mux_container_Producer_legacy_Wire_JsonConfig *self, uint64_t frames, moq_status *status); void moq_mux_container_Producer_legacy_Wire_JsonConfig_report_bitrate(const moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_bandwidth_Rate bitrate, moq_status *status); moq_track_Producer *moq_mux_container_Producer_legacy_Wire_JsonConfig_track(const moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_status *status); -moq_Timestamp *moq_mux_container_Producer_legacy_Wire_JsonConfig_live_edge(const moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_status *status); +moq_option_Timestamp moq_mux_container_Producer_legacy_Wire_JsonConfig_live_edge(const moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_status *status); bool moq_mux_container_Producer_legacy_Wire_JsonConfig_write(moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_mux_container_Frame frame, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_JsonConfig_cut(moq_mux_container_Producer_legacy_Wire_JsonConfig *self, const moq_Timestamp *end, moq_mux_Error **err, moq_status *status); +bool moq_mux_container_Producer_legacy_Wire_JsonConfig_cut(moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_legacy_Wire_JsonConfig_seek(moq_mux_container_Producer_legacy_Wire_JsonConfig *self, uint64_t start, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_legacy_Wire_JsonConfig_discontinuity(moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_legacy_Wire_JsonConfig_finish(moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_mux_container_Finished_legacy_Wire_JsonConfig **out, moq_mux_Error **err, moq_status *status); @@ -6895,7 +6898,7 @@ moq_track_Subscriber *moq_mux_container_Producer_legacy_Wire_JsonConfig_consume( moq_broadcast_Info *moq_mux_container_Producer_legacy_Wire_JsonConfig_broadcast(const moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_status *status); moq_track_Info *moq_mux_container_Producer_legacy_Wire_JsonConfig_info(const moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_status *status); bool moq_mux_container_Producer_legacy_Wire_JsonConfig_create_group(const moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_group_Info group, moq_group_Producer **out, moq_Error **err, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_JsonConfig_append_group(const moq_mux_container_Producer_legacy_Wire_JsonConfig *self, const moq_Timestamp *start, moq_group_Producer **out, moq_Error **err, moq_status *status); +bool moq_mux_container_Producer_legacy_Wire_JsonConfig_append_group(const moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_Timestamp start, moq_group_Producer **out, moq_Error **err, moq_status *status); void moq_mux_container_Producer_legacy_Wire_JsonConfig_skip_groups(const moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_range_u64 groups, moq_status *status); moq_option_track_Position moq_mux_container_Producer_legacy_Wire_JsonConfig_finished(const moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_status *status); typedef struct moq_mux_container_Producer_legacy_Wire_JsonConfig_closed_future moq_mux_container_Producer_legacy_Wire_JsonConfig_closed_future; @@ -6915,21 +6918,21 @@ void moq_mux_container_Producer_legacy_Wire_TextConfig_drop(moq_mux_container_Pr bool moq_mux_container_Producer_legacy_Wire_TextConfig_set(moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_hang_catalog_TextConfig *config, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_legacy_Wire_TextConfig_set_bitrate(moq_mux_container_Producer_legacy_Wire_TextConfig *self, uint64_t bitrate, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_legacy_Wire_TextConfig_modify(moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_mux_container_Guard_TextConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_TextConfig_timestamp(const moq_mux_container_Producer_legacy_Wire_TextConfig *self, const moq_Timestamp *hint, moq_Timestamp **out, moq_mux_Error **err, moq_status *status); +bool moq_mux_container_Producer_legacy_Wire_TextConfig_timestamp(const moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); moq_buf moq_mux_container_Producer_legacy_Wire_TextConfig_name(const moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_status *status); moq_track_Demand *moq_mux_container_Producer_legacy_Wire_TextConfig_demand(const moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_status *status); moq_mux_catalog_Estimate *moq_mux_container_Producer_legacy_Wire_TextConfig_estimate(const moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_status *status); -void moq_mux_container_Producer_legacy_Wire_TextConfig_reorder(moq_mux_container_Producer_legacy_Wire_TextConfig *self, const moq_Timestamp *delay, moq_status *status); -void moq_mux_container_Producer_legacy_Wire_TextConfig_history(moq_mux_container_Producer_legacy_Wire_TextConfig *self, const moq_Timestamp *until, moq_status *status); +void moq_mux_container_Producer_legacy_Wire_TextConfig_reorder(moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_Timestamp delay, moq_status *status); +void moq_mux_container_Producer_legacy_Wire_TextConfig_history(moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_Timestamp until, moq_status *status); bool moq_mux_container_Producer_legacy_Wire_TextConfig_needs_keyframe(const moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_status *status); moq_mux_container_Producer_legacy_Wire_TextConfig *moq_mux_container_Producer_legacy_Wire_TextConfig_with_buffer(moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_duration duration, moq_status *status); moq_mux_container_Producer_legacy_Wire_TextConfig *moq_mux_container_Producer_legacy_Wire_TextConfig_with_bandwidth(moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_bandwidth_Allocator *allocator, moq_status *status); void moq_mux_container_Producer_legacy_Wire_TextConfig_report_skipped(const moq_mux_container_Producer_legacy_Wire_TextConfig *self, uint64_t frames, moq_status *status); void moq_mux_container_Producer_legacy_Wire_TextConfig_report_bitrate(const moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_bandwidth_Rate bitrate, moq_status *status); moq_track_Producer *moq_mux_container_Producer_legacy_Wire_TextConfig_track(const moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_status *status); -moq_Timestamp *moq_mux_container_Producer_legacy_Wire_TextConfig_live_edge(const moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_status *status); +moq_option_Timestamp moq_mux_container_Producer_legacy_Wire_TextConfig_live_edge(const moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_status *status); bool moq_mux_container_Producer_legacy_Wire_TextConfig_write(moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_mux_container_Frame frame, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_TextConfig_cut(moq_mux_container_Producer_legacy_Wire_TextConfig *self, const moq_Timestamp *end, moq_mux_Error **err, moq_status *status); +bool moq_mux_container_Producer_legacy_Wire_TextConfig_cut(moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_legacy_Wire_TextConfig_seek(moq_mux_container_Producer_legacy_Wire_TextConfig *self, uint64_t start, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_legacy_Wire_TextConfig_discontinuity(moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_legacy_Wire_TextConfig_finish(moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_mux_container_Finished_legacy_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); @@ -6940,7 +6943,7 @@ moq_track_Subscriber *moq_mux_container_Producer_legacy_Wire_TextConfig_consume( moq_broadcast_Info *moq_mux_container_Producer_legacy_Wire_TextConfig_broadcast(const moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_status *status); moq_track_Info *moq_mux_container_Producer_legacy_Wire_TextConfig_info(const moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_status *status); bool moq_mux_container_Producer_legacy_Wire_TextConfig_create_group(const moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_group_Info group, moq_group_Producer **out, moq_Error **err, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_TextConfig_append_group(const moq_mux_container_Producer_legacy_Wire_TextConfig *self, const moq_Timestamp *start, moq_group_Producer **out, moq_Error **err, moq_status *status); +bool moq_mux_container_Producer_legacy_Wire_TextConfig_append_group(const moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_Timestamp start, moq_group_Producer **out, moq_Error **err, moq_status *status); void moq_mux_container_Producer_legacy_Wire_TextConfig_skip_groups(const moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_range_u64 groups, moq_status *status); moq_option_track_Position moq_mux_container_Producer_legacy_Wire_TextConfig_finished(const moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_status *status); typedef struct moq_mux_container_Producer_legacy_Wire_TextConfig_closed_future moq_mux_container_Producer_legacy_Wire_TextConfig_closed_future; @@ -6960,21 +6963,21 @@ void moq_mux_container_Producer_legacy_Wire_VideoConfig_drop(moq_mux_container_P bool moq_mux_container_Producer_legacy_Wire_VideoConfig_set(moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_hang_catalog_VideoConfig *config, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_legacy_Wire_VideoConfig_set_bitrate(moq_mux_container_Producer_legacy_Wire_VideoConfig *self, uint64_t bitrate, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_legacy_Wire_VideoConfig_modify(moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_mux_container_Guard_VideoConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_VideoConfig_timestamp(const moq_mux_container_Producer_legacy_Wire_VideoConfig *self, const moq_Timestamp *hint, moq_Timestamp **out, moq_mux_Error **err, moq_status *status); +bool moq_mux_container_Producer_legacy_Wire_VideoConfig_timestamp(const moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); moq_buf moq_mux_container_Producer_legacy_Wire_VideoConfig_name(const moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_status *status); moq_track_Demand *moq_mux_container_Producer_legacy_Wire_VideoConfig_demand(const moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_status *status); moq_mux_catalog_Estimate *moq_mux_container_Producer_legacy_Wire_VideoConfig_estimate(const moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_status *status); -void moq_mux_container_Producer_legacy_Wire_VideoConfig_reorder(moq_mux_container_Producer_legacy_Wire_VideoConfig *self, const moq_Timestamp *delay, moq_status *status); -void moq_mux_container_Producer_legacy_Wire_VideoConfig_history(moq_mux_container_Producer_legacy_Wire_VideoConfig *self, const moq_Timestamp *until, moq_status *status); +void moq_mux_container_Producer_legacy_Wire_VideoConfig_reorder(moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_Timestamp delay, moq_status *status); +void moq_mux_container_Producer_legacy_Wire_VideoConfig_history(moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_Timestamp until, moq_status *status); bool moq_mux_container_Producer_legacy_Wire_VideoConfig_needs_keyframe(const moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_status *status); moq_mux_container_Producer_legacy_Wire_VideoConfig *moq_mux_container_Producer_legacy_Wire_VideoConfig_with_buffer(moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_duration duration, moq_status *status); moq_mux_container_Producer_legacy_Wire_VideoConfig *moq_mux_container_Producer_legacy_Wire_VideoConfig_with_bandwidth(moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_bandwidth_Allocator *allocator, moq_status *status); void moq_mux_container_Producer_legacy_Wire_VideoConfig_report_skipped(const moq_mux_container_Producer_legacy_Wire_VideoConfig *self, uint64_t frames, moq_status *status); void moq_mux_container_Producer_legacy_Wire_VideoConfig_report_bitrate(const moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_bandwidth_Rate bitrate, moq_status *status); moq_track_Producer *moq_mux_container_Producer_legacy_Wire_VideoConfig_track(const moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_status *status); -moq_Timestamp *moq_mux_container_Producer_legacy_Wire_VideoConfig_live_edge(const moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_status *status); +moq_option_Timestamp moq_mux_container_Producer_legacy_Wire_VideoConfig_live_edge(const moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_status *status); bool moq_mux_container_Producer_legacy_Wire_VideoConfig_write(moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_mux_container_Frame frame, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_VideoConfig_cut(moq_mux_container_Producer_legacy_Wire_VideoConfig *self, const moq_Timestamp *end, moq_mux_Error **err, moq_status *status); +bool moq_mux_container_Producer_legacy_Wire_VideoConfig_cut(moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_legacy_Wire_VideoConfig_seek(moq_mux_container_Producer_legacy_Wire_VideoConfig *self, uint64_t start, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_legacy_Wire_VideoConfig_discontinuity(moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_legacy_Wire_VideoConfig_finish(moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_mux_container_Finished_legacy_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); @@ -6985,7 +6988,7 @@ moq_track_Subscriber *moq_mux_container_Producer_legacy_Wire_VideoConfig_consume moq_broadcast_Info *moq_mux_container_Producer_legacy_Wire_VideoConfig_broadcast(const moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_status *status); moq_track_Info *moq_mux_container_Producer_legacy_Wire_VideoConfig_info(const moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_status *status); bool moq_mux_container_Producer_legacy_Wire_VideoConfig_create_group(const moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_group_Info group, moq_group_Producer **out, moq_Error **err, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_VideoConfig_append_group(const moq_mux_container_Producer_legacy_Wire_VideoConfig *self, const moq_Timestamp *start, moq_group_Producer **out, moq_Error **err, moq_status *status); +bool moq_mux_container_Producer_legacy_Wire_VideoConfig_append_group(const moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_Timestamp start, moq_group_Producer **out, moq_Error **err, moq_status *status); void moq_mux_container_Producer_legacy_Wire_VideoConfig_skip_groups(const moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_range_u64 groups, moq_status *status); moq_option_track_Position moq_mux_container_Producer_legacy_Wire_VideoConfig_finished(const moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_status *status); typedef struct moq_mux_container_Producer_legacy_Wire_VideoConfig_closed_future moq_mux_container_Producer_legacy_Wire_VideoConfig_closed_future; @@ -7006,21 +7009,21 @@ moq_mux_container_Producer_legacy_Wire *moq_mux_container_Producer_legacy_Wire_n bool moq_mux_container_Producer_legacy_Wire_set(moq_mux_container_Producer_legacy_Wire *self, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_legacy_Wire_set_bitrate(moq_mux_container_Producer_legacy_Wire *self, uint64_t bitrate, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_legacy_Wire_modify(moq_mux_container_Producer_legacy_Wire *self, moq_mux_container_Guard_unit **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_timestamp(const moq_mux_container_Producer_legacy_Wire *self, const moq_Timestamp *hint, moq_Timestamp **out, moq_mux_Error **err, moq_status *status); +bool moq_mux_container_Producer_legacy_Wire_timestamp(const moq_mux_container_Producer_legacy_Wire *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); moq_buf moq_mux_container_Producer_legacy_Wire_name(const moq_mux_container_Producer_legacy_Wire *self, moq_status *status); moq_track_Demand *moq_mux_container_Producer_legacy_Wire_demand(const moq_mux_container_Producer_legacy_Wire *self, moq_status *status); moq_mux_catalog_Estimate *moq_mux_container_Producer_legacy_Wire_estimate(const moq_mux_container_Producer_legacy_Wire *self, moq_status *status); -void moq_mux_container_Producer_legacy_Wire_reorder(moq_mux_container_Producer_legacy_Wire *self, const moq_Timestamp *delay, moq_status *status); -void moq_mux_container_Producer_legacy_Wire_history(moq_mux_container_Producer_legacy_Wire *self, const moq_Timestamp *until, moq_status *status); +void moq_mux_container_Producer_legacy_Wire_reorder(moq_mux_container_Producer_legacy_Wire *self, moq_Timestamp delay, moq_status *status); +void moq_mux_container_Producer_legacy_Wire_history(moq_mux_container_Producer_legacy_Wire *self, moq_Timestamp until, moq_status *status); bool moq_mux_container_Producer_legacy_Wire_needs_keyframe(const moq_mux_container_Producer_legacy_Wire *self, moq_status *status); moq_mux_container_Producer_legacy_Wire *moq_mux_container_Producer_legacy_Wire_with_buffer(moq_mux_container_Producer_legacy_Wire *self, moq_duration duration, moq_status *status); moq_mux_container_Producer_legacy_Wire *moq_mux_container_Producer_legacy_Wire_with_bandwidth(moq_mux_container_Producer_legacy_Wire *self, moq_bandwidth_Allocator *allocator, moq_status *status); void moq_mux_container_Producer_legacy_Wire_report_skipped(const moq_mux_container_Producer_legacy_Wire *self, uint64_t frames, moq_status *status); void moq_mux_container_Producer_legacy_Wire_report_bitrate(const moq_mux_container_Producer_legacy_Wire *self, moq_bandwidth_Rate bitrate, moq_status *status); moq_track_Producer *moq_mux_container_Producer_legacy_Wire_track(const moq_mux_container_Producer_legacy_Wire *self, moq_status *status); -moq_Timestamp *moq_mux_container_Producer_legacy_Wire_live_edge(const moq_mux_container_Producer_legacy_Wire *self, moq_status *status); +moq_option_Timestamp moq_mux_container_Producer_legacy_Wire_live_edge(const moq_mux_container_Producer_legacy_Wire *self, moq_status *status); bool moq_mux_container_Producer_legacy_Wire_write(moq_mux_container_Producer_legacy_Wire *self, moq_mux_container_Frame frame, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_cut(moq_mux_container_Producer_legacy_Wire *self, const moq_Timestamp *end, moq_mux_Error **err, moq_status *status); +bool moq_mux_container_Producer_legacy_Wire_cut(moq_mux_container_Producer_legacy_Wire *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_legacy_Wire_seek(moq_mux_container_Producer_legacy_Wire *self, uint64_t start, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_legacy_Wire_discontinuity(moq_mux_container_Producer_legacy_Wire *self, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_legacy_Wire_finish(moq_mux_container_Producer_legacy_Wire *self, moq_mux_container_Finished_legacy_Wire **out, moq_mux_Error **err, moq_status *status); @@ -7031,7 +7034,7 @@ moq_track_Subscriber *moq_mux_container_Producer_legacy_Wire_consume(const moq_m moq_broadcast_Info *moq_mux_container_Producer_legacy_Wire_broadcast(const moq_mux_container_Producer_legacy_Wire *self, moq_status *status); moq_track_Info *moq_mux_container_Producer_legacy_Wire_info(const moq_mux_container_Producer_legacy_Wire *self, moq_status *status); bool moq_mux_container_Producer_legacy_Wire_create_group(const moq_mux_container_Producer_legacy_Wire *self, moq_group_Info group, moq_group_Producer **out, moq_Error **err, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_append_group(const moq_mux_container_Producer_legacy_Wire *self, const moq_Timestamp *start, moq_group_Producer **out, moq_Error **err, moq_status *status); +bool moq_mux_container_Producer_legacy_Wire_append_group(const moq_mux_container_Producer_legacy_Wire *self, moq_Timestamp start, moq_group_Producer **out, moq_Error **err, moq_status *status); void moq_mux_container_Producer_legacy_Wire_skip_groups(const moq_mux_container_Producer_legacy_Wire *self, moq_range_u64 groups, moq_status *status); moq_option_track_Position moq_mux_container_Producer_legacy_Wire_finished(const moq_mux_container_Producer_legacy_Wire *self, moq_status *status); typedef struct moq_mux_container_Producer_legacy_Wire_closed_future moq_mux_container_Producer_legacy_Wire_closed_future; @@ -7051,21 +7054,21 @@ void moq_mux_container_Producer_loc_Wire_AudioConfig_drop(moq_mux_container_Prod bool moq_mux_container_Producer_loc_Wire_AudioConfig_set(moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_hang_catalog_AudioConfig *config, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_loc_Wire_AudioConfig_set_bitrate(moq_mux_container_Producer_loc_Wire_AudioConfig *self, uint64_t bitrate, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_loc_Wire_AudioConfig_modify(moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_mux_container_Guard_AudioConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_AudioConfig_timestamp(const moq_mux_container_Producer_loc_Wire_AudioConfig *self, const moq_Timestamp *hint, moq_Timestamp **out, moq_mux_Error **err, moq_status *status); +bool moq_mux_container_Producer_loc_Wire_AudioConfig_timestamp(const moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); moq_buf moq_mux_container_Producer_loc_Wire_AudioConfig_name(const moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_status *status); moq_track_Demand *moq_mux_container_Producer_loc_Wire_AudioConfig_demand(const moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_status *status); moq_mux_catalog_Estimate *moq_mux_container_Producer_loc_Wire_AudioConfig_estimate(const moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_status *status); -void moq_mux_container_Producer_loc_Wire_AudioConfig_reorder(moq_mux_container_Producer_loc_Wire_AudioConfig *self, const moq_Timestamp *delay, moq_status *status); -void moq_mux_container_Producer_loc_Wire_AudioConfig_history(moq_mux_container_Producer_loc_Wire_AudioConfig *self, const moq_Timestamp *until, moq_status *status); +void moq_mux_container_Producer_loc_Wire_AudioConfig_reorder(moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_Timestamp delay, moq_status *status); +void moq_mux_container_Producer_loc_Wire_AudioConfig_history(moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_Timestamp until, moq_status *status); bool moq_mux_container_Producer_loc_Wire_AudioConfig_needs_keyframe(const moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_status *status); moq_mux_container_Producer_loc_Wire_AudioConfig *moq_mux_container_Producer_loc_Wire_AudioConfig_with_buffer(moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_duration duration, moq_status *status); moq_mux_container_Producer_loc_Wire_AudioConfig *moq_mux_container_Producer_loc_Wire_AudioConfig_with_bandwidth(moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_bandwidth_Allocator *allocator, moq_status *status); void moq_mux_container_Producer_loc_Wire_AudioConfig_report_skipped(const moq_mux_container_Producer_loc_Wire_AudioConfig *self, uint64_t frames, moq_status *status); void moq_mux_container_Producer_loc_Wire_AudioConfig_report_bitrate(const moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_bandwidth_Rate bitrate, moq_status *status); moq_track_Producer *moq_mux_container_Producer_loc_Wire_AudioConfig_track(const moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_status *status); -moq_Timestamp *moq_mux_container_Producer_loc_Wire_AudioConfig_live_edge(const moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_status *status); +moq_option_Timestamp moq_mux_container_Producer_loc_Wire_AudioConfig_live_edge(const moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_status *status); bool moq_mux_container_Producer_loc_Wire_AudioConfig_write(moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_mux_container_Frame frame, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_AudioConfig_cut(moq_mux_container_Producer_loc_Wire_AudioConfig *self, const moq_Timestamp *end, moq_mux_Error **err, moq_status *status); +bool moq_mux_container_Producer_loc_Wire_AudioConfig_cut(moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_loc_Wire_AudioConfig_seek(moq_mux_container_Producer_loc_Wire_AudioConfig *self, uint64_t start, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_loc_Wire_AudioConfig_discontinuity(moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_loc_Wire_AudioConfig_finish(moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_mux_container_Finished_loc_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); @@ -7076,7 +7079,7 @@ moq_track_Subscriber *moq_mux_container_Producer_loc_Wire_AudioConfig_consume(co moq_broadcast_Info *moq_mux_container_Producer_loc_Wire_AudioConfig_broadcast(const moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_status *status); moq_track_Info *moq_mux_container_Producer_loc_Wire_AudioConfig_info(const moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_status *status); bool moq_mux_container_Producer_loc_Wire_AudioConfig_create_group(const moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_group_Info group, moq_group_Producer **out, moq_Error **err, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_AudioConfig_append_group(const moq_mux_container_Producer_loc_Wire_AudioConfig *self, const moq_Timestamp *start, moq_group_Producer **out, moq_Error **err, moq_status *status); +bool moq_mux_container_Producer_loc_Wire_AudioConfig_append_group(const moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_Timestamp start, moq_group_Producer **out, moq_Error **err, moq_status *status); void moq_mux_container_Producer_loc_Wire_AudioConfig_skip_groups(const moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_range_u64 groups, moq_status *status); moq_option_track_Position moq_mux_container_Producer_loc_Wire_AudioConfig_finished(const moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_status *status); typedef struct moq_mux_container_Producer_loc_Wire_AudioConfig_closed_future moq_mux_container_Producer_loc_Wire_AudioConfig_closed_future; @@ -7096,21 +7099,21 @@ void moq_mux_container_Producer_loc_Wire_BinaryConfig_drop(moq_mux_container_Pro bool moq_mux_container_Producer_loc_Wire_BinaryConfig_set(moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_hang_catalog_BinaryConfig *config, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_loc_Wire_BinaryConfig_set_bitrate(moq_mux_container_Producer_loc_Wire_BinaryConfig *self, uint64_t bitrate, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_loc_Wire_BinaryConfig_modify(moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_mux_container_Guard_BinaryConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_BinaryConfig_timestamp(const moq_mux_container_Producer_loc_Wire_BinaryConfig *self, const moq_Timestamp *hint, moq_Timestamp **out, moq_mux_Error **err, moq_status *status); +bool moq_mux_container_Producer_loc_Wire_BinaryConfig_timestamp(const moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); moq_buf moq_mux_container_Producer_loc_Wire_BinaryConfig_name(const moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_status *status); moq_track_Demand *moq_mux_container_Producer_loc_Wire_BinaryConfig_demand(const moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_status *status); moq_mux_catalog_Estimate *moq_mux_container_Producer_loc_Wire_BinaryConfig_estimate(const moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_status *status); -void moq_mux_container_Producer_loc_Wire_BinaryConfig_reorder(moq_mux_container_Producer_loc_Wire_BinaryConfig *self, const moq_Timestamp *delay, moq_status *status); -void moq_mux_container_Producer_loc_Wire_BinaryConfig_history(moq_mux_container_Producer_loc_Wire_BinaryConfig *self, const moq_Timestamp *until, moq_status *status); +void moq_mux_container_Producer_loc_Wire_BinaryConfig_reorder(moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_Timestamp delay, moq_status *status); +void moq_mux_container_Producer_loc_Wire_BinaryConfig_history(moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_Timestamp until, moq_status *status); bool moq_mux_container_Producer_loc_Wire_BinaryConfig_needs_keyframe(const moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_status *status); moq_mux_container_Producer_loc_Wire_BinaryConfig *moq_mux_container_Producer_loc_Wire_BinaryConfig_with_buffer(moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_duration duration, moq_status *status); moq_mux_container_Producer_loc_Wire_BinaryConfig *moq_mux_container_Producer_loc_Wire_BinaryConfig_with_bandwidth(moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_bandwidth_Allocator *allocator, moq_status *status); void moq_mux_container_Producer_loc_Wire_BinaryConfig_report_skipped(const moq_mux_container_Producer_loc_Wire_BinaryConfig *self, uint64_t frames, moq_status *status); void moq_mux_container_Producer_loc_Wire_BinaryConfig_report_bitrate(const moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_bandwidth_Rate bitrate, moq_status *status); moq_track_Producer *moq_mux_container_Producer_loc_Wire_BinaryConfig_track(const moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_status *status); -moq_Timestamp *moq_mux_container_Producer_loc_Wire_BinaryConfig_live_edge(const moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_status *status); +moq_option_Timestamp moq_mux_container_Producer_loc_Wire_BinaryConfig_live_edge(const moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_status *status); bool moq_mux_container_Producer_loc_Wire_BinaryConfig_write(moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_mux_container_Frame frame, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_BinaryConfig_cut(moq_mux_container_Producer_loc_Wire_BinaryConfig *self, const moq_Timestamp *end, moq_mux_Error **err, moq_status *status); +bool moq_mux_container_Producer_loc_Wire_BinaryConfig_cut(moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_loc_Wire_BinaryConfig_seek(moq_mux_container_Producer_loc_Wire_BinaryConfig *self, uint64_t start, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_loc_Wire_BinaryConfig_discontinuity(moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_loc_Wire_BinaryConfig_finish(moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_mux_container_Finished_loc_Wire_BinaryConfig **out, moq_mux_Error **err, moq_status *status); @@ -7121,7 +7124,7 @@ moq_track_Subscriber *moq_mux_container_Producer_loc_Wire_BinaryConfig_consume(c moq_broadcast_Info *moq_mux_container_Producer_loc_Wire_BinaryConfig_broadcast(const moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_status *status); moq_track_Info *moq_mux_container_Producer_loc_Wire_BinaryConfig_info(const moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_status *status); bool moq_mux_container_Producer_loc_Wire_BinaryConfig_create_group(const moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_group_Info group, moq_group_Producer **out, moq_Error **err, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_BinaryConfig_append_group(const moq_mux_container_Producer_loc_Wire_BinaryConfig *self, const moq_Timestamp *start, moq_group_Producer **out, moq_Error **err, moq_status *status); +bool moq_mux_container_Producer_loc_Wire_BinaryConfig_append_group(const moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_Timestamp start, moq_group_Producer **out, moq_Error **err, moq_status *status); void moq_mux_container_Producer_loc_Wire_BinaryConfig_skip_groups(const moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_range_u64 groups, moq_status *status); moq_option_track_Position moq_mux_container_Producer_loc_Wire_BinaryConfig_finished(const moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_status *status); typedef struct moq_mux_container_Producer_loc_Wire_BinaryConfig_closed_future moq_mux_container_Producer_loc_Wire_BinaryConfig_closed_future; @@ -7141,21 +7144,21 @@ void moq_mux_container_Producer_loc_Wire_JsonConfig_drop(moq_mux_container_Produ bool moq_mux_container_Producer_loc_Wire_JsonConfig_set(moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_hang_catalog_JsonConfig *config, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_loc_Wire_JsonConfig_set_bitrate(moq_mux_container_Producer_loc_Wire_JsonConfig *self, uint64_t bitrate, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_loc_Wire_JsonConfig_modify(moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_mux_container_Guard_JsonConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_JsonConfig_timestamp(const moq_mux_container_Producer_loc_Wire_JsonConfig *self, const moq_Timestamp *hint, moq_Timestamp **out, moq_mux_Error **err, moq_status *status); +bool moq_mux_container_Producer_loc_Wire_JsonConfig_timestamp(const moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); moq_buf moq_mux_container_Producer_loc_Wire_JsonConfig_name(const moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_status *status); moq_track_Demand *moq_mux_container_Producer_loc_Wire_JsonConfig_demand(const moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_status *status); moq_mux_catalog_Estimate *moq_mux_container_Producer_loc_Wire_JsonConfig_estimate(const moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_status *status); -void moq_mux_container_Producer_loc_Wire_JsonConfig_reorder(moq_mux_container_Producer_loc_Wire_JsonConfig *self, const moq_Timestamp *delay, moq_status *status); -void moq_mux_container_Producer_loc_Wire_JsonConfig_history(moq_mux_container_Producer_loc_Wire_JsonConfig *self, const moq_Timestamp *until, moq_status *status); +void moq_mux_container_Producer_loc_Wire_JsonConfig_reorder(moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_Timestamp delay, moq_status *status); +void moq_mux_container_Producer_loc_Wire_JsonConfig_history(moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_Timestamp until, moq_status *status); bool moq_mux_container_Producer_loc_Wire_JsonConfig_needs_keyframe(const moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_status *status); moq_mux_container_Producer_loc_Wire_JsonConfig *moq_mux_container_Producer_loc_Wire_JsonConfig_with_buffer(moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_duration duration, moq_status *status); moq_mux_container_Producer_loc_Wire_JsonConfig *moq_mux_container_Producer_loc_Wire_JsonConfig_with_bandwidth(moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_bandwidth_Allocator *allocator, moq_status *status); void moq_mux_container_Producer_loc_Wire_JsonConfig_report_skipped(const moq_mux_container_Producer_loc_Wire_JsonConfig *self, uint64_t frames, moq_status *status); void moq_mux_container_Producer_loc_Wire_JsonConfig_report_bitrate(const moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_bandwidth_Rate bitrate, moq_status *status); moq_track_Producer *moq_mux_container_Producer_loc_Wire_JsonConfig_track(const moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_status *status); -moq_Timestamp *moq_mux_container_Producer_loc_Wire_JsonConfig_live_edge(const moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_status *status); +moq_option_Timestamp moq_mux_container_Producer_loc_Wire_JsonConfig_live_edge(const moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_status *status); bool moq_mux_container_Producer_loc_Wire_JsonConfig_write(moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_mux_container_Frame frame, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_JsonConfig_cut(moq_mux_container_Producer_loc_Wire_JsonConfig *self, const moq_Timestamp *end, moq_mux_Error **err, moq_status *status); +bool moq_mux_container_Producer_loc_Wire_JsonConfig_cut(moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_loc_Wire_JsonConfig_seek(moq_mux_container_Producer_loc_Wire_JsonConfig *self, uint64_t start, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_loc_Wire_JsonConfig_discontinuity(moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_loc_Wire_JsonConfig_finish(moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_mux_container_Finished_loc_Wire_JsonConfig **out, moq_mux_Error **err, moq_status *status); @@ -7166,7 +7169,7 @@ moq_track_Subscriber *moq_mux_container_Producer_loc_Wire_JsonConfig_consume(con moq_broadcast_Info *moq_mux_container_Producer_loc_Wire_JsonConfig_broadcast(const moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_status *status); moq_track_Info *moq_mux_container_Producer_loc_Wire_JsonConfig_info(const moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_status *status); bool moq_mux_container_Producer_loc_Wire_JsonConfig_create_group(const moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_group_Info group, moq_group_Producer **out, moq_Error **err, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_JsonConfig_append_group(const moq_mux_container_Producer_loc_Wire_JsonConfig *self, const moq_Timestamp *start, moq_group_Producer **out, moq_Error **err, moq_status *status); +bool moq_mux_container_Producer_loc_Wire_JsonConfig_append_group(const moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_Timestamp start, moq_group_Producer **out, moq_Error **err, moq_status *status); void moq_mux_container_Producer_loc_Wire_JsonConfig_skip_groups(const moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_range_u64 groups, moq_status *status); moq_option_track_Position moq_mux_container_Producer_loc_Wire_JsonConfig_finished(const moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_status *status); typedef struct moq_mux_container_Producer_loc_Wire_JsonConfig_closed_future moq_mux_container_Producer_loc_Wire_JsonConfig_closed_future; @@ -7186,21 +7189,21 @@ void moq_mux_container_Producer_loc_Wire_TextConfig_drop(moq_mux_container_Produ bool moq_mux_container_Producer_loc_Wire_TextConfig_set(moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_hang_catalog_TextConfig *config, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_loc_Wire_TextConfig_set_bitrate(moq_mux_container_Producer_loc_Wire_TextConfig *self, uint64_t bitrate, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_loc_Wire_TextConfig_modify(moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_mux_container_Guard_TextConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_TextConfig_timestamp(const moq_mux_container_Producer_loc_Wire_TextConfig *self, const moq_Timestamp *hint, moq_Timestamp **out, moq_mux_Error **err, moq_status *status); +bool moq_mux_container_Producer_loc_Wire_TextConfig_timestamp(const moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); moq_buf moq_mux_container_Producer_loc_Wire_TextConfig_name(const moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_status *status); moq_track_Demand *moq_mux_container_Producer_loc_Wire_TextConfig_demand(const moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_status *status); moq_mux_catalog_Estimate *moq_mux_container_Producer_loc_Wire_TextConfig_estimate(const moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_status *status); -void moq_mux_container_Producer_loc_Wire_TextConfig_reorder(moq_mux_container_Producer_loc_Wire_TextConfig *self, const moq_Timestamp *delay, moq_status *status); -void moq_mux_container_Producer_loc_Wire_TextConfig_history(moq_mux_container_Producer_loc_Wire_TextConfig *self, const moq_Timestamp *until, moq_status *status); +void moq_mux_container_Producer_loc_Wire_TextConfig_reorder(moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_Timestamp delay, moq_status *status); +void moq_mux_container_Producer_loc_Wire_TextConfig_history(moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_Timestamp until, moq_status *status); bool moq_mux_container_Producer_loc_Wire_TextConfig_needs_keyframe(const moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_status *status); moq_mux_container_Producer_loc_Wire_TextConfig *moq_mux_container_Producer_loc_Wire_TextConfig_with_buffer(moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_duration duration, moq_status *status); moq_mux_container_Producer_loc_Wire_TextConfig *moq_mux_container_Producer_loc_Wire_TextConfig_with_bandwidth(moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_bandwidth_Allocator *allocator, moq_status *status); void moq_mux_container_Producer_loc_Wire_TextConfig_report_skipped(const moq_mux_container_Producer_loc_Wire_TextConfig *self, uint64_t frames, moq_status *status); void moq_mux_container_Producer_loc_Wire_TextConfig_report_bitrate(const moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_bandwidth_Rate bitrate, moq_status *status); moq_track_Producer *moq_mux_container_Producer_loc_Wire_TextConfig_track(const moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_status *status); -moq_Timestamp *moq_mux_container_Producer_loc_Wire_TextConfig_live_edge(const moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_status *status); +moq_option_Timestamp moq_mux_container_Producer_loc_Wire_TextConfig_live_edge(const moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_status *status); bool moq_mux_container_Producer_loc_Wire_TextConfig_write(moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_mux_container_Frame frame, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_TextConfig_cut(moq_mux_container_Producer_loc_Wire_TextConfig *self, const moq_Timestamp *end, moq_mux_Error **err, moq_status *status); +bool moq_mux_container_Producer_loc_Wire_TextConfig_cut(moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_loc_Wire_TextConfig_seek(moq_mux_container_Producer_loc_Wire_TextConfig *self, uint64_t start, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_loc_Wire_TextConfig_discontinuity(moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_loc_Wire_TextConfig_finish(moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_mux_container_Finished_loc_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); @@ -7211,7 +7214,7 @@ moq_track_Subscriber *moq_mux_container_Producer_loc_Wire_TextConfig_consume(con moq_broadcast_Info *moq_mux_container_Producer_loc_Wire_TextConfig_broadcast(const moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_status *status); moq_track_Info *moq_mux_container_Producer_loc_Wire_TextConfig_info(const moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_status *status); bool moq_mux_container_Producer_loc_Wire_TextConfig_create_group(const moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_group_Info group, moq_group_Producer **out, moq_Error **err, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_TextConfig_append_group(const moq_mux_container_Producer_loc_Wire_TextConfig *self, const moq_Timestamp *start, moq_group_Producer **out, moq_Error **err, moq_status *status); +bool moq_mux_container_Producer_loc_Wire_TextConfig_append_group(const moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_Timestamp start, moq_group_Producer **out, moq_Error **err, moq_status *status); void moq_mux_container_Producer_loc_Wire_TextConfig_skip_groups(const moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_range_u64 groups, moq_status *status); moq_option_track_Position moq_mux_container_Producer_loc_Wire_TextConfig_finished(const moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_status *status); typedef struct moq_mux_container_Producer_loc_Wire_TextConfig_closed_future moq_mux_container_Producer_loc_Wire_TextConfig_closed_future; @@ -7231,21 +7234,21 @@ void moq_mux_container_Producer_loc_Wire_VideoConfig_drop(moq_mux_container_Prod bool moq_mux_container_Producer_loc_Wire_VideoConfig_set(moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_hang_catalog_VideoConfig *config, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_loc_Wire_VideoConfig_set_bitrate(moq_mux_container_Producer_loc_Wire_VideoConfig *self, uint64_t bitrate, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_loc_Wire_VideoConfig_modify(moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_mux_container_Guard_VideoConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_VideoConfig_timestamp(const moq_mux_container_Producer_loc_Wire_VideoConfig *self, const moq_Timestamp *hint, moq_Timestamp **out, moq_mux_Error **err, moq_status *status); +bool moq_mux_container_Producer_loc_Wire_VideoConfig_timestamp(const moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); moq_buf moq_mux_container_Producer_loc_Wire_VideoConfig_name(const moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_status *status); moq_track_Demand *moq_mux_container_Producer_loc_Wire_VideoConfig_demand(const moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_status *status); moq_mux_catalog_Estimate *moq_mux_container_Producer_loc_Wire_VideoConfig_estimate(const moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_status *status); -void moq_mux_container_Producer_loc_Wire_VideoConfig_reorder(moq_mux_container_Producer_loc_Wire_VideoConfig *self, const moq_Timestamp *delay, moq_status *status); -void moq_mux_container_Producer_loc_Wire_VideoConfig_history(moq_mux_container_Producer_loc_Wire_VideoConfig *self, const moq_Timestamp *until, moq_status *status); +void moq_mux_container_Producer_loc_Wire_VideoConfig_reorder(moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_Timestamp delay, moq_status *status); +void moq_mux_container_Producer_loc_Wire_VideoConfig_history(moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_Timestamp until, moq_status *status); bool moq_mux_container_Producer_loc_Wire_VideoConfig_needs_keyframe(const moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_status *status); moq_mux_container_Producer_loc_Wire_VideoConfig *moq_mux_container_Producer_loc_Wire_VideoConfig_with_buffer(moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_duration duration, moq_status *status); moq_mux_container_Producer_loc_Wire_VideoConfig *moq_mux_container_Producer_loc_Wire_VideoConfig_with_bandwidth(moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_bandwidth_Allocator *allocator, moq_status *status); void moq_mux_container_Producer_loc_Wire_VideoConfig_report_skipped(const moq_mux_container_Producer_loc_Wire_VideoConfig *self, uint64_t frames, moq_status *status); void moq_mux_container_Producer_loc_Wire_VideoConfig_report_bitrate(const moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_bandwidth_Rate bitrate, moq_status *status); moq_track_Producer *moq_mux_container_Producer_loc_Wire_VideoConfig_track(const moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_status *status); -moq_Timestamp *moq_mux_container_Producer_loc_Wire_VideoConfig_live_edge(const moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_status *status); +moq_option_Timestamp moq_mux_container_Producer_loc_Wire_VideoConfig_live_edge(const moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_status *status); bool moq_mux_container_Producer_loc_Wire_VideoConfig_write(moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_mux_container_Frame frame, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_VideoConfig_cut(moq_mux_container_Producer_loc_Wire_VideoConfig *self, const moq_Timestamp *end, moq_mux_Error **err, moq_status *status); +bool moq_mux_container_Producer_loc_Wire_VideoConfig_cut(moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_loc_Wire_VideoConfig_seek(moq_mux_container_Producer_loc_Wire_VideoConfig *self, uint64_t start, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_loc_Wire_VideoConfig_discontinuity(moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_loc_Wire_VideoConfig_finish(moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_mux_container_Finished_loc_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); @@ -7256,7 +7259,7 @@ moq_track_Subscriber *moq_mux_container_Producer_loc_Wire_VideoConfig_consume(co moq_broadcast_Info *moq_mux_container_Producer_loc_Wire_VideoConfig_broadcast(const moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_status *status); moq_track_Info *moq_mux_container_Producer_loc_Wire_VideoConfig_info(const moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_status *status); bool moq_mux_container_Producer_loc_Wire_VideoConfig_create_group(const moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_group_Info group, moq_group_Producer **out, moq_Error **err, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_VideoConfig_append_group(const moq_mux_container_Producer_loc_Wire_VideoConfig *self, const moq_Timestamp *start, moq_group_Producer **out, moq_Error **err, moq_status *status); +bool moq_mux_container_Producer_loc_Wire_VideoConfig_append_group(const moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_Timestamp start, moq_group_Producer **out, moq_Error **err, moq_status *status); void moq_mux_container_Producer_loc_Wire_VideoConfig_skip_groups(const moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_range_u64 groups, moq_status *status); moq_option_track_Position moq_mux_container_Producer_loc_Wire_VideoConfig_finished(const moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_status *status); typedef struct moq_mux_container_Producer_loc_Wire_VideoConfig_closed_future moq_mux_container_Producer_loc_Wire_VideoConfig_closed_future; @@ -7277,21 +7280,21 @@ moq_mux_container_Producer_loc_Wire *moq_mux_container_Producer_loc_Wire_new(moq bool moq_mux_container_Producer_loc_Wire_set(moq_mux_container_Producer_loc_Wire *self, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_loc_Wire_set_bitrate(moq_mux_container_Producer_loc_Wire *self, uint64_t bitrate, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_loc_Wire_modify(moq_mux_container_Producer_loc_Wire *self, moq_mux_container_Guard_unit **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_timestamp(const moq_mux_container_Producer_loc_Wire *self, const moq_Timestamp *hint, moq_Timestamp **out, moq_mux_Error **err, moq_status *status); +bool moq_mux_container_Producer_loc_Wire_timestamp(const moq_mux_container_Producer_loc_Wire *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); moq_buf moq_mux_container_Producer_loc_Wire_name(const moq_mux_container_Producer_loc_Wire *self, moq_status *status); moq_track_Demand *moq_mux_container_Producer_loc_Wire_demand(const moq_mux_container_Producer_loc_Wire *self, moq_status *status); moq_mux_catalog_Estimate *moq_mux_container_Producer_loc_Wire_estimate(const moq_mux_container_Producer_loc_Wire *self, moq_status *status); -void moq_mux_container_Producer_loc_Wire_reorder(moq_mux_container_Producer_loc_Wire *self, const moq_Timestamp *delay, moq_status *status); -void moq_mux_container_Producer_loc_Wire_history(moq_mux_container_Producer_loc_Wire *self, const moq_Timestamp *until, moq_status *status); +void moq_mux_container_Producer_loc_Wire_reorder(moq_mux_container_Producer_loc_Wire *self, moq_Timestamp delay, moq_status *status); +void moq_mux_container_Producer_loc_Wire_history(moq_mux_container_Producer_loc_Wire *self, moq_Timestamp until, moq_status *status); bool moq_mux_container_Producer_loc_Wire_needs_keyframe(const moq_mux_container_Producer_loc_Wire *self, moq_status *status); moq_mux_container_Producer_loc_Wire *moq_mux_container_Producer_loc_Wire_with_buffer(moq_mux_container_Producer_loc_Wire *self, moq_duration duration, moq_status *status); moq_mux_container_Producer_loc_Wire *moq_mux_container_Producer_loc_Wire_with_bandwidth(moq_mux_container_Producer_loc_Wire *self, moq_bandwidth_Allocator *allocator, moq_status *status); void moq_mux_container_Producer_loc_Wire_report_skipped(const moq_mux_container_Producer_loc_Wire *self, uint64_t frames, moq_status *status); void moq_mux_container_Producer_loc_Wire_report_bitrate(const moq_mux_container_Producer_loc_Wire *self, moq_bandwidth_Rate bitrate, moq_status *status); moq_track_Producer *moq_mux_container_Producer_loc_Wire_track(const moq_mux_container_Producer_loc_Wire *self, moq_status *status); -moq_Timestamp *moq_mux_container_Producer_loc_Wire_live_edge(const moq_mux_container_Producer_loc_Wire *self, moq_status *status); +moq_option_Timestamp moq_mux_container_Producer_loc_Wire_live_edge(const moq_mux_container_Producer_loc_Wire *self, moq_status *status); bool moq_mux_container_Producer_loc_Wire_write(moq_mux_container_Producer_loc_Wire *self, moq_mux_container_Frame frame, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_cut(moq_mux_container_Producer_loc_Wire *self, const moq_Timestamp *end, moq_mux_Error **err, moq_status *status); +bool moq_mux_container_Producer_loc_Wire_cut(moq_mux_container_Producer_loc_Wire *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_loc_Wire_seek(moq_mux_container_Producer_loc_Wire *self, uint64_t start, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_loc_Wire_discontinuity(moq_mux_container_Producer_loc_Wire *self, moq_mux_Error **err, moq_status *status); bool moq_mux_container_Producer_loc_Wire_finish(moq_mux_container_Producer_loc_Wire *self, moq_mux_container_Finished_loc_Wire **out, moq_mux_Error **err, moq_status *status); @@ -7302,7 +7305,7 @@ moq_track_Subscriber *moq_mux_container_Producer_loc_Wire_consume(const moq_mux_ moq_broadcast_Info *moq_mux_container_Producer_loc_Wire_broadcast(const moq_mux_container_Producer_loc_Wire *self, moq_status *status); moq_track_Info *moq_mux_container_Producer_loc_Wire_info(const moq_mux_container_Producer_loc_Wire *self, moq_status *status); bool moq_mux_container_Producer_loc_Wire_create_group(const moq_mux_container_Producer_loc_Wire *self, moq_group_Info group, moq_group_Producer **out, moq_Error **err, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_append_group(const moq_mux_container_Producer_loc_Wire *self, const moq_Timestamp *start, moq_group_Producer **out, moq_Error **err, moq_status *status); +bool moq_mux_container_Producer_loc_Wire_append_group(const moq_mux_container_Producer_loc_Wire *self, moq_Timestamp start, moq_group_Producer **out, moq_Error **err, moq_status *status); void moq_mux_container_Producer_loc_Wire_skip_groups(const moq_mux_container_Producer_loc_Wire *self, moq_range_u64 groups, moq_status *status); moq_option_track_Position moq_mux_container_Producer_loc_Wire_finished(const moq_mux_container_Producer_loc_Wire *self, moq_status *status); typedef struct moq_mux_container_Producer_loc_Wire_closed_future moq_mux_container_Producer_loc_Wire_closed_future; @@ -7398,11 +7401,11 @@ bool moq_mux_import_Track_audio_unit(moq_track_Request *request, moq_mux_catalog bool moq_mux_import_Track_video_Extra(moq_track_Request *request, moq_mux_catalog_Reserved_Extra *reserved, moq_mux_import_VideoInit *init, moq_mux_import_Track **out, moq_mux_Error **err, moq_status *status); bool moq_mux_import_Track_video_Ext(moq_track_Request *request, moq_mux_catalog_Reserved_Ext *reserved, moq_mux_import_VideoInit *init, moq_mux_import_Track **out, moq_mux_Error **err, moq_status *status); bool moq_mux_import_Track_video_unit(moq_track_Request *request, moq_mux_catalog_Reserved *reserved, moq_mux_import_VideoInit *init, moq_mux_import_Track **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_import_Track_decode(moq_mux_import_Track *self, moq_buf frame, const moq_Timestamp *pts, moq_mux_Error **err, moq_status *status); +bool moq_mux_import_Track_decode(moq_mux_import_Track *self, moq_buf frame, moq_option_Timestamp pts, moq_mux_Error **err, moq_status *status); bool moq_mux_import_Track_finish(moq_mux_import_Track *self, moq_mux_import_track_Finished **out, moq_mux_Error **err, moq_status *status); void moq_mux_import_Track_abort(moq_mux_import_Track *self, moq_Error *err_, moq_status *status); bool moq_mux_import_Track_abort_unwanted(moq_mux_import_Track *self, moq_Error *err_, moq_mux_import_Track **err, moq_status *status); -bool moq_mux_import_Track_cut(moq_mux_import_Track *self, const moq_Timestamp *end, moq_mux_Error **err, moq_status *status); +bool moq_mux_import_Track_cut(moq_mux_import_Track *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); bool moq_mux_import_Track_discontinuity(moq_mux_import_Track *self, moq_mux_Error **err, moq_status *status); bool moq_mux_import_Track_set_enabled(moq_mux_import_Track *self, bool enabled, moq_mux_Error **err, moq_status *status); bool moq_mux_import_Track_seek(moq_mux_import_Track *self, uint64_t start, moq_mux_Error **err, moq_status *status); @@ -7419,7 +7422,7 @@ bool moq_mux_import_TrackStream_finish(moq_mux_import_TrackStream *self, moq_mux bool moq_mux_import_TrackStream_set_enabled(moq_mux_import_TrackStream *self, bool enabled, moq_mux_Error **err, moq_status *status); void moq_mux_import_TrackStream_abort(moq_mux_import_TrackStream *self, moq_Error *err_, moq_status *status); bool moq_mux_import_TrackStream_abort_unwanted(moq_mux_import_TrackStream *self, moq_Error *err_, moq_mux_import_TrackStream **err, moq_status *status); -bool moq_mux_import_TrackStream_cut(moq_mux_import_TrackStream *self, const moq_Timestamp *end, moq_mux_Error **err, moq_status *status); +bool moq_mux_import_TrackStream_cut(moq_mux_import_TrackStream *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); bool moq_mux_import_TrackStream_seek(moq_mux_import_TrackStream *self, uint64_t start, moq_mux_Error **err, moq_status *status); moq_track_Demand *moq_mux_import_TrackStream_demand(const moq_mux_import_TrackStream *self, moq_status *status); moq_buf moq_mux_import_TrackStream_name(const moq_mux_import_TrackStream *self, moq_status *status); @@ -7433,7 +7436,7 @@ moq_mux_json_Snapshot_Json_refresh_future *moq_mux_json_Snapshot_Json_refresh(co moq_poll moq_mux_json_Snapshot_Json_refresh_start(const moq_mux_json_Snapshot_Json *self, moq_mux_Error **err, moq_mux_json_Snapshot_Json_refresh_future **future, moq_status *status); moq_poll moq_mux_json_Snapshot_Json_refresh_poll(moq_mux_json_Snapshot_Json_refresh_future *future, moq_waker waker, moq_mux_Error **err); void moq_mux_json_Snapshot_Json_refresh_future_free(moq_mux_json_Snapshot_Json_refresh_future *future); -bool moq_mux_json_Snapshot_Json_update(moq_mux_json_Snapshot_Json *self, const moq_Json *value, const moq_Timestamp *timestamp, moq_mux_Error **err, moq_status *status); +bool moq_mux_json_Snapshot_Json_update(moq_mux_json_Snapshot_Json *self, const moq_Json *value, moq_Timestamp timestamp, moq_mux_Error **err, moq_status *status); bool moq_mux_json_Snapshot_Json_finish(moq_mux_json_Snapshot_Json *self, moq_mux_Error **err, moq_status *status); bool moq_mux_json_Snapshot_Json_abort(moq_mux_json_Snapshot_Json *self, moq_Error *err_, moq_mux_Error **err, moq_status *status); bool moq_mux_json_Snapshot_Json_abort_unwanted(moq_mux_json_Snapshot_Json *self, moq_Error *err_, moq_mux_json_Snapshot_Json **err, moq_status *status); @@ -7442,7 +7445,7 @@ void moq_mux_json_Stream_Json_drop(moq_mux_json_Stream_Json *self, moq_status *s moq_buf moq_mux_json_Stream_Json_name(const moq_mux_json_Stream_Json *self, moq_status *status); moq_track_Subscriber *moq_mux_json_Stream_Json_consume(const moq_mux_json_Stream_Json *self, moq_status *status); moq_track_Demand *moq_mux_json_Stream_Json_demand(const moq_mux_json_Stream_Json *self, moq_status *status); -bool moq_mux_json_Stream_Json_append(moq_mux_json_Stream_Json *self, const moq_Json *value, const moq_Timestamp *timestamp, moq_mux_Error **err, moq_status *status); +bool moq_mux_json_Stream_Json_append(moq_mux_json_Stream_Json *self, const moq_Json *value, moq_Timestamp timestamp, moq_mux_Error **err, moq_status *status); bool moq_mux_json_Stream_Json_finish(moq_mux_json_Stream_Json *self, moq_mux_Error **err, moq_status *status); bool moq_mux_json_Stream_Json_abort(moq_mux_json_Stream_Json *self, moq_Error *err_, moq_mux_Error **err, moq_status *status); bool moq_mux_json_Stream_Json_abort_unwanted(moq_mux_json_Stream_Json *self, moq_Error *err_, moq_mux_json_Stream_Json **err, moq_status *status); @@ -7542,7 +7545,7 @@ moq_mux_select_Audio *moq_mux_select_Audio_default(void); moq_mux_select_Audio *moq_mux_select_Audio_name(moq_mux_select_Audio *self, moq_buf name, moq_status *status); moq_mux_select_Audio *moq_mux_select_Audio_codec(moq_mux_select_Audio *self, moq_hang_catalog_AudioCodecKind codec, moq_status *status); void moq_mux_sync_Track_free(moq_mux_sync_Track *self); -bool moq_mux_sync_Track_received(const moq_mux_sync_Track *self, const moq_Timestamp *timestamp, moq_clock_Instant now, moq_status *status); +bool moq_mux_sync_Track_received(const moq_mux_sync_Track *self, moq_Timestamp timestamp, moq_clock_Instant now); void moq_mux_sync_Track_reset(const moq_mux_sync_Track *self); bool moq_mux_sync_Track_set_target(const moq_mux_sync_Track *self, moq_duration target); typedef struct moq_mux_sync_Track_delay_changed_future moq_mux_sync_Track_delay_changed_future; @@ -7556,7 +7559,7 @@ moq_mux_sync_Schedule *moq_mux_sync_Schedule_clone(const moq_mux_sync_Schedule * bool moq_mux_sync_Schedule_eq(const moq_mux_sync_Schedule *a, const moq_mux_sync_Schedule *b); moq_buf moq_mux_sync_Schedule_debug(const moq_mux_sync_Schedule *self); moq_duration moq_mux_sync_Schedule_delay(const moq_mux_sync_Schedule *self); -moq_option_clock_Instant moq_mux_sync_Schedule_due(const moq_mux_sync_Schedule *self, const moq_Timestamp *timestamp, moq_status *status); +moq_option_clock_Instant moq_mux_sync_Schedule_due(const moq_mux_sync_Schedule *self, moq_Timestamp timestamp); void moq_mux_sync_Producer_free(moq_mux_sync_Producer *self); void moq_mux_sync_Producer_drop(moq_mux_sync_Producer *self, moq_status *status); bool moq_mux_sync_Producer_borrowed(const moq_mux_sync_Producer *self); @@ -7565,13 +7568,13 @@ moq_mux_sync_Producer *moq_mux_sync_Producer_new(moq_duration delay); moq_mux_sync_Producer *moq_mux_sync_Producer_reset(moq_mux_sync_Producer *self, moq_duration delay, moq_status *status); moq_mux_sync_Consumer *moq_mux_sync_Producer_consume(const moq_mux_sync_Producer *self, moq_status *status); moq_mux_sync_Track *moq_mux_sync_Producer_track(const moq_mux_sync_Producer *self, moq_mux_container_Kind kind, moq_status *status); -moq_option_clock_Instant moq_mux_sync_Producer_due(const moq_mux_sync_Producer *self, const moq_Timestamp *timestamp, moq_status *status); +moq_option_clock_Instant moq_mux_sync_Producer_due(const moq_mux_sync_Producer *self, moq_Timestamp timestamp, moq_status *status); void moq_mux_sync_Consumer_free(moq_mux_sync_Consumer *self); void moq_mux_sync_Consumer_drop(moq_mux_sync_Consumer *self, moq_status *status); bool moq_mux_sync_Consumer_borrowed(const moq_mux_sync_Consumer *self); moq_mux_sync_Consumer *moq_mux_sync_Consumer_clone(const moq_mux_sync_Consumer *self, moq_status *status); moq_duration moq_mux_sync_Consumer_delay(const moq_mux_sync_Consumer *self, moq_status *status); -moq_option_clock_Instant moq_mux_sync_Consumer_due(const moq_mux_sync_Consumer *self, const moq_Timestamp *timestamp, moq_status *status); +moq_option_clock_Instant moq_mux_sync_Consumer_due(const moq_mux_sync_Consumer *self, moq_Timestamp timestamp, moq_status *status); moq_option_duration moq_mux_sync_Consumer_position(const moq_mux_sync_Consumer *self, moq_clock_Instant at, moq_status *status); moq_mux_sync_Schedule *moq_mux_sync_Consumer_schedule(const moq_mux_sync_Consumer *self, moq_status *status); typedef struct moq_mux_sync_Consumer_changed_future moq_mux_sync_Consumer_changed_future; @@ -7993,10 +7996,10 @@ moq_track_Demand *moq_mux_codec_aac_Import_demand(const moq_mux_codec_aac_Import bool moq_mux_codec_aac_Import_finish(moq_mux_codec_aac_Import *self, moq_mux_container_Finished_Container_AudioConfig **out, moq_mux_Error **err, moq_status *status); void moq_mux_codec_aac_Import_abort(moq_mux_codec_aac_Import *self, moq_Error *err_, moq_status *status); bool moq_mux_codec_aac_Import_abort_unwanted(moq_mux_codec_aac_Import *self, moq_Error *err_, moq_mux_codec_aac_Import **err, moq_status *status); -bool moq_mux_codec_aac_Import_cut(moq_mux_codec_aac_Import *self, const moq_Timestamp *end, moq_mux_Error **err, moq_status *status); +bool moq_mux_codec_aac_Import_cut(moq_mux_codec_aac_Import *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); bool moq_mux_codec_aac_Import_discontinuity(moq_mux_codec_aac_Import *self, moq_mux_Error **err, moq_status *status); bool moq_mux_codec_aac_Import_seek(moq_mux_codec_aac_Import *self, uint64_t start, moq_mux_Error **err, moq_status *status); -bool moq_mux_codec_aac_Import_decode(moq_mux_codec_aac_Import *self, moq_buf frame, const moq_Timestamp *pts, moq_mux_Error **err, moq_status *status); +bool moq_mux_codec_aac_Import_decode(moq_mux_codec_aac_Import *self, moq_buf frame, moq_option_Timestamp pts, moq_mux_Error **err, moq_status *status); void moq_mux_codec_annexb_Error_free(moq_mux_codec_annexb_Error *self); bool moq_mux_codec_annexb_Error_borrowed(const moq_mux_codec_annexb_Error *self); moq_mux_codec_annexb_Error *moq_mux_codec_annexb_Error_clone(const moq_mux_codec_annexb_Error *self); @@ -8012,7 +8015,7 @@ moq_track_Demand *moq_mux_codec_av1_Import_demand(const moq_mux_codec_av1_Import bool moq_mux_codec_av1_Import_finish(moq_mux_codec_av1_Import *self, moq_mux_container_Finished_Container_VideoConfig **out, moq_mux_Error **err, moq_status *status); void moq_mux_codec_av1_Import_abort(moq_mux_codec_av1_Import *self, moq_Error *err_, moq_status *status); bool moq_mux_codec_av1_Import_abort_unwanted(moq_mux_codec_av1_Import *self, moq_Error *err_, moq_mux_codec_av1_Import **err, moq_status *status); -bool moq_mux_codec_av1_Import_cut(moq_mux_codec_av1_Import *self, const moq_Timestamp *end, moq_mux_Error **err, moq_status *status); +bool moq_mux_codec_av1_Import_cut(moq_mux_codec_av1_Import *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); bool moq_mux_codec_av1_Import_discontinuity(moq_mux_codec_av1_Import *self, moq_mux_Error **err, moq_status *status); bool moq_mux_codec_av1_Import_set_enabled(moq_mux_codec_av1_Import *self, bool enabled, moq_mux_Error **err, moq_status *status); bool moq_mux_codec_av1_Import_seek(moq_mux_codec_av1_Import *self, uint64_t start, moq_mux_Error **err, moq_status *status); @@ -8021,8 +8024,8 @@ void moq_mux_codec_av1_Split_free(moq_mux_codec_av1_Split *self); void moq_mux_codec_av1_Split_drop(moq_mux_codec_av1_Split *self, moq_status *status); moq_mux_codec_av1_Split *moq_mux_codec_av1_Split_default(void); moq_mux_codec_av1_Split *moq_mux_codec_av1_Split_new(void); -bool moq_mux_codec_av1_Split_decode(moq_mux_codec_av1_Split *self, moq_buf data_, const moq_Timestamp *pts, moq_vec_mux_container_Frame *out, moq_mux_Error **err, moq_status *status); -bool moq_mux_codec_av1_Split_flush(moq_mux_codec_av1_Split *self, const moq_Timestamp *pts, moq_vec_mux_container_Frame *out, moq_mux_Error **err, moq_status *status); +bool moq_mux_codec_av1_Split_decode(moq_mux_codec_av1_Split *self, moq_buf data_, moq_option_Timestamp pts, moq_vec_mux_container_Frame *out, moq_mux_Error **err, moq_status *status); +bool moq_mux_codec_av1_Split_flush(moq_mux_codec_av1_Split *self, moq_option_Timestamp pts, moq_vec_mux_container_Frame *out, moq_mux_Error **err, moq_status *status); void moq_mux_codec_av1_Split_reset(moq_mux_codec_av1_Split *self, moq_status *status); void moq_mux_codec_flac_Import_free(moq_mux_codec_flac_Import *self); void moq_mux_codec_flac_Import_drop(moq_mux_codec_flac_Import *self, moq_status *status); @@ -8033,10 +8036,10 @@ moq_track_Demand *moq_mux_codec_flac_Import_demand(const moq_mux_codec_flac_Impo bool moq_mux_codec_flac_Import_finish(moq_mux_codec_flac_Import *self, moq_mux_container_Finished_Container_AudioConfig **out, moq_mux_Error **err, moq_status *status); void moq_mux_codec_flac_Import_abort(moq_mux_codec_flac_Import *self, moq_Error *err_, moq_status *status); bool moq_mux_codec_flac_Import_abort_unwanted(moq_mux_codec_flac_Import *self, moq_Error *err_, moq_mux_codec_flac_Import **err, moq_status *status); -bool moq_mux_codec_flac_Import_cut(moq_mux_codec_flac_Import *self, const moq_Timestamp *end, moq_mux_Error **err, moq_status *status); +bool moq_mux_codec_flac_Import_cut(moq_mux_codec_flac_Import *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); bool moq_mux_codec_flac_Import_discontinuity(moq_mux_codec_flac_Import *self, moq_mux_Error **err, moq_status *status); bool moq_mux_codec_flac_Import_seek(moq_mux_codec_flac_Import *self, uint64_t start, moq_mux_Error **err, moq_status *status); -bool moq_mux_codec_flac_Import_decode(moq_mux_codec_flac_Import *self, moq_buf frame, const moq_Timestamp *pts, moq_mux_Error **err, moq_status *status); +bool moq_mux_codec_flac_Import_decode(moq_mux_codec_flac_Import *self, moq_buf frame, moq_option_Timestamp pts, moq_mux_Error **err, moq_status *status); void moq_mux_codec_h264_Avc1_free(moq_mux_codec_h264_Avc1 *self); void moq_mux_codec_h264_Avc1_drop(moq_mux_codec_h264_Avc1 *self, moq_status *status); moq_mux_codec_h264_Avc1 *moq_mux_codec_h264_Avc1_default(void); @@ -8081,20 +8084,20 @@ moq_track_Producer *moq_mux_codec_h264_Import_track(const moq_mux_codec_h264_Imp bool moq_mux_codec_h264_Import_finish(moq_mux_codec_h264_Import *self, moq_mux_container_Finished_Container_VideoConfig **out, moq_mux_Error **err, moq_status *status); void moq_mux_codec_h264_Import_abort(moq_mux_codec_h264_Import *self, moq_Error *err_, moq_status *status); bool moq_mux_codec_h264_Import_abort_unwanted(moq_mux_codec_h264_Import *self, moq_Error *err_, moq_mux_codec_h264_Import **err, moq_status *status); -bool moq_mux_codec_h264_Import_cut(moq_mux_codec_h264_Import *self, const moq_Timestamp *end, moq_mux_Error **err, moq_status *status); +bool moq_mux_codec_h264_Import_cut(moq_mux_codec_h264_Import *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); bool moq_mux_codec_h264_Import_discontinuity(moq_mux_codec_h264_Import *self, moq_mux_Error **err, moq_status *status); bool moq_mux_codec_h264_Import_set_enabled(moq_mux_codec_h264_Import *self, bool enabled, moq_mux_Error **err, moq_status *status); void moq_mux_codec_h264_Import_report_skipped(const moq_mux_codec_h264_Import *self, uint64_t frames, moq_status *status); void moq_mux_codec_h264_Import_report_bitrate(const moq_mux_codec_h264_Import *self, moq_bandwidth_Rate bitrate, moq_status *status); bool moq_mux_codec_h264_Import_seek(moq_mux_codec_h264_Import *self, uint64_t start, moq_mux_Error **err, moq_status *status); -bool moq_mux_codec_h264_Import_observe_reorder(moq_mux_codec_h264_Import *self, const moq_Timestamp *reorder, moq_mux_Error **err, moq_status *status); +bool moq_mux_codec_h264_Import_observe_reorder(moq_mux_codec_h264_Import *self, moq_Timestamp reorder, moq_mux_Error **err, moq_status *status); bool moq_mux_codec_h264_Import_decode(moq_mux_codec_h264_Import *self, moq_vec_mux_container_Frame frames, moq_mux_Error **err, moq_status *status); void moq_mux_codec_h264_Split_free(moq_mux_codec_h264_Split *self); void moq_mux_codec_h264_Split_drop(moq_mux_codec_h264_Split *self, moq_status *status); moq_mux_codec_h264_Split *moq_mux_codec_h264_Split_default(void); moq_mux_codec_h264_Split *moq_mux_codec_h264_Split_new(void); -bool moq_mux_codec_h264_Split_decode(moq_mux_codec_h264_Split *self, moq_buf data_, const moq_Timestamp *pts, moq_vec_mux_container_Frame *out, moq_mux_Error **err, moq_status *status); -bool moq_mux_codec_h264_Split_flush(moq_mux_codec_h264_Split *self, const moq_Timestamp *pts, moq_vec_mux_container_Frame *out, moq_mux_Error **err, moq_status *status); +bool moq_mux_codec_h264_Split_decode(moq_mux_codec_h264_Split *self, moq_buf data_, moq_option_Timestamp pts, moq_vec_mux_container_Frame *out, moq_mux_Error **err, moq_status *status); +bool moq_mux_codec_h264_Split_flush(moq_mux_codec_h264_Split *self, moq_option_Timestamp pts, moq_vec_mux_container_Frame *out, moq_mux_Error **err, moq_status *status); void moq_mux_codec_h264_Split_reset(moq_mux_codec_h264_Split *self, moq_status *status); void moq_mux_codec_h265_Hvc1_free(moq_mux_codec_h265_Hvc1 *self); void moq_mux_codec_h265_Hvc1_drop(moq_mux_codec_h265_Hvc1 *self, moq_status *status); @@ -8139,20 +8142,20 @@ moq_track_Producer *moq_mux_codec_h265_Import_track(const moq_mux_codec_h265_Imp bool moq_mux_codec_h265_Import_finish(moq_mux_codec_h265_Import *self, moq_mux_container_Finished_Container_VideoConfig **out, moq_mux_Error **err, moq_status *status); void moq_mux_codec_h265_Import_abort(moq_mux_codec_h265_Import *self, moq_Error *err_, moq_status *status); bool moq_mux_codec_h265_Import_abort_unwanted(moq_mux_codec_h265_Import *self, moq_Error *err_, moq_mux_codec_h265_Import **err, moq_status *status); -bool moq_mux_codec_h265_Import_cut(moq_mux_codec_h265_Import *self, const moq_Timestamp *end, moq_mux_Error **err, moq_status *status); +bool moq_mux_codec_h265_Import_cut(moq_mux_codec_h265_Import *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); bool moq_mux_codec_h265_Import_discontinuity(moq_mux_codec_h265_Import *self, moq_mux_Error **err, moq_status *status); bool moq_mux_codec_h265_Import_set_enabled(moq_mux_codec_h265_Import *self, bool enabled, moq_mux_Error **err, moq_status *status); void moq_mux_codec_h265_Import_report_skipped(const moq_mux_codec_h265_Import *self, uint64_t frames, moq_status *status); void moq_mux_codec_h265_Import_report_bitrate(const moq_mux_codec_h265_Import *self, moq_bandwidth_Rate bitrate, moq_status *status); bool moq_mux_codec_h265_Import_seek(moq_mux_codec_h265_Import *self, uint64_t start, moq_mux_Error **err, moq_status *status); -bool moq_mux_codec_h265_Import_observe_reorder(moq_mux_codec_h265_Import *self, const moq_Timestamp *reorder, moq_mux_Error **err, moq_status *status); +bool moq_mux_codec_h265_Import_observe_reorder(moq_mux_codec_h265_Import *self, moq_Timestamp reorder, moq_mux_Error **err, moq_status *status); bool moq_mux_codec_h265_Import_decode(moq_mux_codec_h265_Import *self, moq_vec_mux_container_Frame frames, moq_mux_Error **err, moq_status *status); void moq_mux_codec_h265_Split_free(moq_mux_codec_h265_Split *self); void moq_mux_codec_h265_Split_drop(moq_mux_codec_h265_Split *self, moq_status *status); moq_mux_codec_h265_Split *moq_mux_codec_h265_Split_default(void); moq_mux_codec_h265_Split *moq_mux_codec_h265_Split_new(void); -bool moq_mux_codec_h265_Split_decode(moq_mux_codec_h265_Split *self, moq_buf data_, const moq_Timestamp *pts, moq_vec_mux_container_Frame *out, moq_mux_Error **err, moq_status *status); -bool moq_mux_codec_h265_Split_flush(moq_mux_codec_h265_Split *self, const moq_Timestamp *pts, moq_vec_mux_container_Frame *out, moq_mux_Error **err, moq_status *status); +bool moq_mux_codec_h265_Split_decode(moq_mux_codec_h265_Split *self, moq_buf data_, moq_option_Timestamp pts, moq_vec_mux_container_Frame *out, moq_mux_Error **err, moq_status *status); +bool moq_mux_codec_h265_Split_flush(moq_mux_codec_h265_Split *self, moq_option_Timestamp pts, moq_vec_mux_container_Frame *out, moq_mux_Error **err, moq_status *status); void moq_mux_codec_h265_Split_reset(moq_mux_codec_h265_Split *self, moq_status *status); void moq_mux_codec_mp3_Import_free(moq_mux_codec_mp3_Import *self); void moq_mux_codec_mp3_Import_drop(moq_mux_codec_mp3_Import *self, moq_status *status); @@ -8163,10 +8166,10 @@ moq_track_Demand *moq_mux_codec_mp3_Import_demand(const moq_mux_codec_mp3_Import bool moq_mux_codec_mp3_Import_finish(moq_mux_codec_mp3_Import *self, moq_mux_container_Finished_Container_AudioConfig **out, moq_mux_Error **err, moq_status *status); void moq_mux_codec_mp3_Import_abort(moq_mux_codec_mp3_Import *self, moq_Error *err_, moq_status *status); bool moq_mux_codec_mp3_Import_abort_unwanted(moq_mux_codec_mp3_Import *self, moq_Error *err_, moq_mux_codec_mp3_Import **err, moq_status *status); -bool moq_mux_codec_mp3_Import_cut(moq_mux_codec_mp3_Import *self, const moq_Timestamp *end, moq_mux_Error **err, moq_status *status); +bool moq_mux_codec_mp3_Import_cut(moq_mux_codec_mp3_Import *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); bool moq_mux_codec_mp3_Import_discontinuity(moq_mux_codec_mp3_Import *self, moq_mux_Error **err, moq_status *status); bool moq_mux_codec_mp3_Import_seek(moq_mux_codec_mp3_Import *self, uint64_t start, moq_mux_Error **err, moq_status *status); -bool moq_mux_codec_mp3_Import_decode(moq_mux_codec_mp3_Import *self, moq_buf frame, const moq_Timestamp *pts, moq_mux_Error **err, moq_status *status); +bool moq_mux_codec_mp3_Import_decode(moq_mux_codec_mp3_Import *self, moq_buf frame, moq_option_Timestamp pts, moq_mux_Error **err, moq_status *status); void moq_mux_codec_opus_Config_free(moq_mux_codec_opus_Config *self); void moq_mux_codec_opus_Config_drop(moq_mux_codec_opus_Config *self, moq_status *status); moq_mux_codec_opus_Config *moq_mux_codec_opus_Config_clone(const moq_mux_codec_opus_Config *self, moq_status *status); @@ -8196,22 +8199,22 @@ moq_track_Demand *moq_mux_codec_opus_Import_demand(const moq_mux_codec_opus_Impo bool moq_mux_codec_opus_Import_finish(moq_mux_codec_opus_Import *self, moq_mux_container_Finished_Container_AudioConfig **out, moq_mux_Error **err, moq_status *status); void moq_mux_codec_opus_Import_abort(moq_mux_codec_opus_Import *self, moq_Error *err_, moq_status *status); bool moq_mux_codec_opus_Import_abort_unwanted(moq_mux_codec_opus_Import *self, moq_Error *err_, moq_mux_codec_opus_Import **err, moq_status *status); -bool moq_mux_codec_opus_Import_cut(moq_mux_codec_opus_Import *self, const moq_Timestamp *end, moq_mux_Error **err, moq_status *status); +bool moq_mux_codec_opus_Import_cut(moq_mux_codec_opus_Import *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); bool moq_mux_codec_opus_Import_discontinuity(moq_mux_codec_opus_Import *self, moq_mux_Error **err, moq_status *status); bool moq_mux_codec_opus_Import_seek(moq_mux_codec_opus_Import *self, uint64_t start, moq_mux_Error **err, moq_status *status); -bool moq_mux_codec_opus_Import_decode(moq_mux_codec_opus_Import *self, moq_buf frame, const moq_Timestamp *pts, moq_mux_Error **err, moq_status *status); +bool moq_mux_codec_opus_Import_decode(moq_mux_codec_opus_Import *self, moq_buf frame, moq_option_Timestamp pts, moq_mux_Error **err, moq_status *status); void moq_mux_codec_vp8_Import_free(moq_mux_codec_vp8_Import *self); void moq_mux_codec_vp8_Import_drop(moq_mux_codec_vp8_Import *self, moq_status *status); bool moq_mux_codec_vp8_Import_new_Extra(moq_track_Producer *track, moq_mux_catalog_Reserved_Extra *reserved, moq_mux_catalog_VideoHint *hint, moq_mux_codec_vp8_Import **out, moq_mux_Error **err, moq_status *status); bool moq_mux_codec_vp8_Import_new_Ext(moq_track_Producer *track, moq_mux_catalog_Reserved_Ext *reserved, moq_mux_catalog_VideoHint *hint, moq_mux_codec_vp8_Import **out, moq_mux_Error **err, moq_status *status); bool moq_mux_codec_vp8_Import_new_unit(moq_track_Producer *track, moq_mux_catalog_Reserved *reserved, moq_mux_catalog_VideoHint *hint, moq_mux_codec_vp8_Import **out, moq_mux_Error **err, moq_status *status); bool moq_mux_codec_vp8_Import_initialize(moq_mux_codec_vp8_Import *self, moq_buf buf, moq_mux_Error **err, moq_status *status); -bool moq_mux_codec_vp8_Import_decode(moq_mux_codec_vp8_Import *self, moq_buf frame, const moq_Timestamp *pts, moq_mux_Error **err, moq_status *status); +bool moq_mux_codec_vp8_Import_decode(moq_mux_codec_vp8_Import *self, moq_buf frame, moq_option_Timestamp pts, moq_mux_Error **err, moq_status *status); moq_track_Demand *moq_mux_codec_vp8_Import_demand(const moq_mux_codec_vp8_Import *self, moq_status *status); bool moq_mux_codec_vp8_Import_finish(moq_mux_codec_vp8_Import *self, moq_mux_container_Finished_Container_VideoConfig **out, moq_mux_Error **err, moq_status *status); void moq_mux_codec_vp8_Import_abort(moq_mux_codec_vp8_Import *self, moq_Error *err_, moq_status *status); bool moq_mux_codec_vp8_Import_abort_unwanted(moq_mux_codec_vp8_Import *self, moq_Error *err_, moq_mux_codec_vp8_Import **err, moq_status *status); -bool moq_mux_codec_vp8_Import_cut(moq_mux_codec_vp8_Import *self, const moq_Timestamp *end, moq_mux_Error **err, moq_status *status); +bool moq_mux_codec_vp8_Import_cut(moq_mux_codec_vp8_Import *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); bool moq_mux_codec_vp8_Import_discontinuity(moq_mux_codec_vp8_Import *self, moq_mux_Error **err, moq_status *status); bool moq_mux_codec_vp8_Import_set_enabled(moq_mux_codec_vp8_Import *self, bool enabled, moq_mux_Error **err, moq_status *status); bool moq_mux_codec_vp8_Import_seek(moq_mux_codec_vp8_Import *self, uint64_t start, moq_mux_Error **err, moq_status *status); @@ -8221,12 +8224,12 @@ bool moq_mux_codec_vp9_Import_new_Extra(moq_track_Producer *track, moq_mux_catal bool moq_mux_codec_vp9_Import_new_Ext(moq_track_Producer *track, moq_mux_catalog_Reserved_Ext *reserved, moq_mux_catalog_VideoHint *hint, moq_mux_codec_vp9_Import **out, moq_mux_Error **err, moq_status *status); bool moq_mux_codec_vp9_Import_new_unit(moq_track_Producer *track, moq_mux_catalog_Reserved *reserved, moq_mux_catalog_VideoHint *hint, moq_mux_codec_vp9_Import **out, moq_mux_Error **err, moq_status *status); bool moq_mux_codec_vp9_Import_initialize(moq_mux_codec_vp9_Import *self, moq_buf buf, moq_mux_Error **err, moq_status *status); -bool moq_mux_codec_vp9_Import_decode(moq_mux_codec_vp9_Import *self, moq_buf frame, const moq_Timestamp *pts, moq_mux_Error **err, moq_status *status); +bool moq_mux_codec_vp9_Import_decode(moq_mux_codec_vp9_Import *self, moq_buf frame, moq_option_Timestamp pts, moq_mux_Error **err, moq_status *status); moq_track_Demand *moq_mux_codec_vp9_Import_demand(const moq_mux_codec_vp9_Import *self, moq_status *status); bool moq_mux_codec_vp9_Import_finish(moq_mux_codec_vp9_Import *self, moq_mux_container_Finished_Container_VideoConfig **out, moq_mux_Error **err, moq_status *status); void moq_mux_codec_vp9_Import_abort(moq_mux_codec_vp9_Import *self, moq_Error *err_, moq_status *status); bool moq_mux_codec_vp9_Import_abort_unwanted(moq_mux_codec_vp9_Import *self, moq_Error *err_, moq_mux_codec_vp9_Import **err, moq_status *status); -bool moq_mux_codec_vp9_Import_cut(moq_mux_codec_vp9_Import *self, const moq_Timestamp *end, moq_mux_Error **err, moq_status *status); +bool moq_mux_codec_vp9_Import_cut(moq_mux_codec_vp9_Import *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); bool moq_mux_codec_vp9_Import_discontinuity(moq_mux_codec_vp9_Import *self, moq_mux_Error **err, moq_status *status); bool moq_mux_codec_vp9_Import_set_enabled(moq_mux_codec_vp9_Import *self, bool enabled, moq_mux_Error **err, moq_status *status); bool moq_mux_codec_vp9_Import_seek(moq_mux_codec_vp9_Import *self, uint64_t start, moq_mux_Error **err, moq_status *status); @@ -8329,14 +8332,14 @@ moq_poll moq_mux_container_fmp4_Muxer_read_poll(moq_mux_container_fmp4_Muxer_rea void moq_mux_container_fmp4_Muxer_read_future_free(moq_mux_container_fmp4_Muxer_read_future *future); bool moq_mux_container_fmp4_Muxer_picture_size(moq_mux_container_fmp4_Muxer *self, moq_mux_container_Frame keyframe, moq_option_tuple_u32_u32 *out, moq_mux_Error **err, moq_status *status); bool moq_mux_container_fmp4_Muxer_init(const moq_mux_container_fmp4_Muxer *self, moq_buf *out, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_fmp4_Muxer_fragment(const moq_mux_container_fmp4_Muxer *self, uint32_t sequence, moq_vec_mux_container_Frame frames, const moq_Timestamp *end, moq_buf *out, moq_mux_Error **err, moq_status *status); +bool moq_mux_container_fmp4_Muxer_fragment(const moq_mux_container_fmp4_Muxer *self, uint32_t sequence, moq_vec_mux_container_Frame frames, moq_option_Timestamp end, moq_buf *out, moq_mux_Error **err, moq_status *status); void moq_mux_container_legacy_Audio_free(moq_mux_container_legacy_Audio *self); bool moq_mux_container_legacy_Audio_borrowed(const moq_mux_container_legacy_Audio *self); moq_mux_container_legacy_Audio *moq_mux_container_legacy_Audio_clone(const moq_mux_container_legacy_Audio *self); bool moq_mux_container_legacy_Audio_eq(const moq_mux_container_legacy_Audio *a, const moq_mux_container_legacy_Audio *b); moq_buf moq_mux_container_legacy_Audio_debug(const moq_mux_container_legacy_Audio *self); moq_mux_container_legacy_Audio *moq_mux_container_legacy_Audio_new(const moq_hang_catalog_AudioConfig *config, moq_status *status); -moq_Timestamp *moq_mux_container_legacy_Audio_duration(const moq_mux_container_legacy_Audio *self, moq_buf payload); +moq_option_Timestamp moq_mux_container_legacy_Audio_duration(const moq_mux_container_legacy_Audio *self, moq_buf payload); void moq_mux_container_mkv_Import_free(moq_mux_container_mkv_Import *self); void moq_mux_container_mkv_Import_drop(moq_mux_container_mkv_Import *self, moq_status *status); moq_mux_container_mkv_Import *moq_mux_container_mkv_Import_new(moq_broadcast_Producer *broadcast, moq_mux_catalog_Reserved *reserved, moq_status *status); @@ -8856,9 +8859,9 @@ bool moq_moq_json_Timed_Catalog_eq(const moq_moq_json_Timed_Catalog *a, const mo moq_buf moq_moq_json_Timed_Catalog_debug(const moq_moq_json_Timed_Catalog *self, moq_status *status); moq_hang_Catalog *moq_moq_json_Timed_Catalog_value_get(const moq_moq_json_Timed_Catalog *self, moq_status *status); void moq_moq_json_Timed_Catalog_value_set(moq_moq_json_Timed_Catalog *self, moq_hang_Catalog *value, moq_status *status); -moq_Timestamp *moq_moq_json_Timed_Catalog_at_get(const moq_moq_json_Timed_Catalog *self, moq_status *status); -void moq_moq_json_Timed_Catalog_at_set(moq_moq_json_Timed_Catalog *self, const moq_Timestamp *value, moq_status *status); -moq_moq_json_Timed_Catalog *moq_moq_json_Timed_Catalog_new(moq_hang_Catalog *value, const moq_Timestamp *at, moq_status *status); +moq_Timestamp moq_moq_json_Timed_Catalog_at_get(const moq_moq_json_Timed_Catalog *self, moq_status *status); +void moq_moq_json_Timed_Catalog_at_set(moq_moq_json_Timed_Catalog *self, moq_Timestamp value, moq_status *status); +moq_moq_json_Timed_Catalog *moq_moq_json_Timed_Catalog_new(moq_hang_Catalog *value, moq_Timestamp at, moq_status *status); void moq_moq_json_Timed_Json_free(moq_moq_json_Timed_Json *self); void moq_moq_json_Timed_Json_drop(moq_moq_json_Timed_Json *self, moq_status *status); moq_moq_json_Timed_Json *moq_moq_json_Timed_Json_clone(const moq_moq_json_Timed_Json *self, moq_status *status); @@ -8866,9 +8869,9 @@ bool moq_moq_json_Timed_Json_eq(const moq_moq_json_Timed_Json *a, const moq_moq_ moq_buf moq_moq_json_Timed_Json_debug(const moq_moq_json_Timed_Json *self, moq_status *status); moq_Json *moq_moq_json_Timed_Json_value_get(const moq_moq_json_Timed_Json *self, moq_status *status); void moq_moq_json_Timed_Json_value_set(moq_moq_json_Timed_Json *self, moq_Json *value, moq_status *status); -moq_Timestamp *moq_moq_json_Timed_Json_at_get(const moq_moq_json_Timed_Json *self, moq_status *status); -void moq_moq_json_Timed_Json_at_set(moq_moq_json_Timed_Json *self, const moq_Timestamp *value, moq_status *status); -moq_moq_json_Timed_Json *moq_moq_json_Timed_Json_new(moq_Json *value, const moq_Timestamp *at, moq_status *status); +moq_Timestamp moq_moq_json_Timed_Json_at_get(const moq_moq_json_Timed_Json *self, moq_status *status); +void moq_moq_json_Timed_Json_at_set(moq_moq_json_Timed_Json *self, moq_Timestamp value, moq_status *status); +moq_moq_json_Timed_Json *moq_moq_json_Timed_Json_new(moq_Json *value, moq_Timestamp at, moq_status *status); void moq_rustls_ClientConfig_free(moq_rustls_ClientConfig *self); void moq_rustls_ClientConfig_drop(moq_rustls_ClientConfig *self, moq_status *status); moq_rustls_ClientConfig *moq_rustls_ClientConfig_clone(const moq_rustls_ClientConfig *self, moq_status *status); diff --git a/ffi/surface/moq/cpp.hpp b/ffi/surface/moq/cpp.hpp index f53295c6f..f8ec44aa7 100644 --- a/ffi/surface/moq/cpp.hpp +++ b/ffi/surface/moq/cpp.hpp @@ -306,18 +306,6 @@ namespace moq { RUST2_FFI_CALLABLE void extra_set(::moq::taken<::std::tuple<::moq::view, ::moq::Json>> value); static ::moq::hang_catalog_BinaryConfig new_(const ::moq::hang_catalog_Mode &mode); }; - class RUST2_FFI_CONSUMABLE hang_catalog_Clock { - RUST2_FFI_UNCONSUMED hang_catalog_Clock(hang_catalog_Clock &&other RUST2_FFI_MOVED_FROM) noexcept = default; - hang_catalog_Clock &operator=(hang_catalog_Clock &&other) noexcept = default; - RUST2_FFI_CALLABLE hang_catalog_Clock clone() const; - friend bool operator==(const hang_catalog_Clock &a, const hang_catalog_Clock &b); - friend bool operator!=(const hang_catalog_Clock &a, const hang_catalog_Clock &b); - RUST2_FFI_CALLABLE ::moq::buf debug() const; - RUST2_FFI_CALLABLE ::moq::Timestamp wall_get() const; - RUST2_FFI_CALLABLE void wall_set(const ::moq::Timestamp &value); - static ::moq::result<::moq::hang_catalog_Clock, ::moq::hang_Error> new_(const ::moq::Timestamp &wall); - RUST2_FFI_CALLABLE ::moq::result<::moq::clock_Wall, ::moq::hang_Error> wall_clock(const ::moq::Timestamp &pts) const; - }; class RUST2_FFI_CONSUMABLE hang_catalog_Container { RUST2_FFI_UNCONSUMED hang_catalog_Container(hang_catalog_Container &&other RUST2_FFI_MOVED_FROM) noexcept = default; hang_catalog_Container &operator=(hang_catalog_Container &&other) noexcept = default; @@ -455,7 +443,7 @@ namespace moq { RUST2_FFI_CALLABLE ::moq::buf debug() const; static hang_catalog_Timeline default_(); RUST2_FFI_CALLABLE ::std::optional<::moq::hang_catalog_Clock> clock_get() const; - RUST2_FFI_CALLABLE void clock_set(const ::moq::hang_catalog_Clock *value); + RUST2_FFI_CALLABLE void clock_set(const ::std::optional<::moq::hang_catalog_Clock> &value); RUST2_FFI_CALLABLE ::std::optional<::moq::duration> interval_get() const; RUST2_FFI_CALLABLE void interval_set(const ::std::optional<::moq::duration> &value); RUST2_FFI_CALLABLE bool is_empty() const; @@ -604,6 +592,15 @@ namespace moq { ::moq::buf to_string() const; ::moq::buf debug() const; }; + class hang_catalog_Clock { + friend bool operator==(const hang_catalog_Clock &a, const hang_catalog_Clock &b); + friend bool operator!=(const hang_catalog_Clock &a, const hang_catalog_Clock &b); + ::moq::buf debug() const; + ::moq::Timestamp wall_get() const; + void wall_set(const ::moq::Timestamp &value); + static ::moq::result<::moq::hang_catalog_Clock, ::moq::hang_Error> new_(const ::moq::Timestamp &wall); + ::moq::result<::moq::clock_Wall, ::moq::hang_Error> wall_clock(const ::moq::Timestamp &pts) const; + }; class hang_catalog_Priorities { friend bool operator==(const hang_catalog_Priorities &a, const hang_catalog_Priorities &b); friend bool operator!=(const hang_catalog_Priorities &a, const hang_catalog_Priorities &b); @@ -790,6 +787,7 @@ namespace moq { ::moq::buf _0; }; inline bool operator==(const hang_catalog_AAC &a, const hang_catalog_AAC &b); + inline bool operator==(const hang_catalog_Clock &a, const hang_catalog_Clock &b); inline bool operator==(const hang_catalog_Priorities &a, const hang_catalog_Priorities &b); inline bool operator==(const hang_catalog_AV1 &a, const hang_catalog_AV1 &b); inline bool operator==(const hang_catalog_Chromaticity &a, const hang_catalog_Chromaticity &b); @@ -1463,7 +1461,7 @@ namespace moq { RUST2_FFI_CALLABLE mux_catalog_Producer clone() const; static ::moq::result<::moq::mux_catalog_Producer, ::moq::mux_Error> new_(::moq::broadcast_Producer &broadcast, ::moq::mux_catalog_Config config); RUST2_FFI_CALLABLE ::moq::track_Info track_info(::std::int8_t priority) const; - RUST2_FFI_CALLABLE ::moq::result<::moq::Timestamp, ::moq::mux_Error> timestamp(const ::moq::Timestamp *hint) const; + RUST2_FFI_CALLABLE ::moq::result<::moq::Timestamp, ::moq::mux_Error> timestamp(const ::std::optional<::moq::Timestamp> &hint) const; template RUST2_FFI_CALLABLE ::moq::result mutate(F0 &&f); RUST2_FFI_CALLABLE ::moq::result<::moq::mux_catalog_Guard, ::moq::mux_Error> modify(); RUST2_FFI_CALLABLE ::moq::hang_Catalog snapshot() const; @@ -1522,7 +1520,7 @@ namespace moq { RUST2_FFI_CALLABLE mux_catalog_Producer_Extra clone() const; static ::moq::result<::moq::mux_catalog_Producer_Extra, ::moq::mux_Error> new_(::moq::broadcast_Producer &broadcast, ::moq::mux_catalog_Config_Extra config); RUST2_FFI_CALLABLE ::moq::track_Info track_info(::std::int8_t priority) const; - RUST2_FFI_CALLABLE ::moq::result<::moq::Timestamp, ::moq::mux_Error> timestamp(const ::moq::Timestamp *hint) const; + RUST2_FFI_CALLABLE ::moq::result<::moq::Timestamp, ::moq::mux_Error> timestamp(const ::std::optional<::moq::Timestamp> &hint) const; template RUST2_FFI_CALLABLE ::moq::result mutate(F0 &&f); RUST2_FFI_CALLABLE ::moq::result<::moq::mux_catalog_Guard_Extra, ::moq::mux_Error> modify(); RUST2_FFI_CALLABLE ::moq::hang_Catalog_Extra snapshot() const; @@ -1581,7 +1579,7 @@ namespace moq { RUST2_FFI_CALLABLE mux_catalog_Producer_Ext clone() const; static ::moq::result<::moq::mux_catalog_Producer_Ext, ::moq::mux_Error> new_(::moq::broadcast_Producer &broadcast, ::moq::mux_catalog_Config_Ext config); RUST2_FFI_CALLABLE ::moq::track_Info track_info(::std::int8_t priority) const; - RUST2_FFI_CALLABLE ::moq::result<::moq::Timestamp, ::moq::mux_Error> timestamp(const ::moq::Timestamp *hint) const; + RUST2_FFI_CALLABLE ::moq::result<::moq::Timestamp, ::moq::mux_Error> timestamp(const ::std::optional<::moq::Timestamp> &hint) const; template RUST2_FFI_CALLABLE ::moq::result mutate(F0 &&f); RUST2_FFI_CALLABLE ::moq::result<::moq::mux_catalog_Guard_Ext, ::moq::mux_Error> modify(); RUST2_FFI_CALLABLE ::moq::hang_Catalog_Ext snapshot() const; @@ -1693,7 +1691,7 @@ namespace moq { RUST2_FFI_CALLABLE ::moq::result<::moq::mux_container_Producer_loc_Wire_VideoConfig, ::moq::mux_Error> track_loc_Wire_VideoConfig(::moq::track_Producer track, const ::moq::mux_container_loc_Wire &container, ::std::optional<::moq::hang_catalog_VideoConfig> config) const; RUST2_FFI_CALLABLE ::moq::result<::moq::mux_container_Producer_loc_Wire_AudioConfig, ::moq::mux_Error> track_loc_Wire_AudioConfig(::moq::track_Producer track, const ::moq::mux_container_loc_Wire &container, ::std::optional<::moq::hang_catalog_AudioConfig> config) const; RUST2_FFI_CALLABLE ::moq::result<::moq::mux_container_Producer_loc_Wire_TextConfig, ::moq::mux_Error> track_loc_Wire_TextConfig(::moq::track_Producer track, const ::moq::mux_container_loc_Wire &container, ::std::optional<::moq::hang_catalog_TextConfig> config) const; - RUST2_FFI_CALLABLE ::moq::result<::moq::Timestamp, ::moq::mux_Error> timestamp(const ::moq::Timestamp *hint) const; + RUST2_FFI_CALLABLE ::moq::result<::moq::Timestamp, ::moq::mux_Error> timestamp(const ::std::optional<::moq::Timestamp> &hint) const; }; class RUST2_FFI_CONSUMABLE mux_catalog_Reserved_Extra { RUST2_FFI_UNCONSUMED mux_catalog_Reserved_Extra(mux_catalog_Reserved_Extra &&other RUST2_FFI_MOVED_FROM) noexcept = default; @@ -1733,7 +1731,7 @@ namespace moq { RUST2_FFI_CALLABLE ::moq::result<::moq::mux_container_Producer_loc_Wire_VideoConfig, ::moq::mux_Error> track_loc_Wire_VideoConfig(::moq::track_Producer track, const ::moq::mux_container_loc_Wire &container, ::std::optional<::moq::hang_catalog_VideoConfig> config) const; RUST2_FFI_CALLABLE ::moq::result<::moq::mux_container_Producer_loc_Wire_AudioConfig, ::moq::mux_Error> track_loc_Wire_AudioConfig(::moq::track_Producer track, const ::moq::mux_container_loc_Wire &container, ::std::optional<::moq::hang_catalog_AudioConfig> config) const; RUST2_FFI_CALLABLE ::moq::result<::moq::mux_container_Producer_loc_Wire_TextConfig, ::moq::mux_Error> track_loc_Wire_TextConfig(::moq::track_Producer track, const ::moq::mux_container_loc_Wire &container, ::std::optional<::moq::hang_catalog_TextConfig> config) const; - RUST2_FFI_CALLABLE ::moq::result<::moq::Timestamp, ::moq::mux_Error> timestamp(const ::moq::Timestamp *hint) const; + RUST2_FFI_CALLABLE ::moq::result<::moq::Timestamp, ::moq::mux_Error> timestamp(const ::std::optional<::moq::Timestamp> &hint) const; }; class RUST2_FFI_CONSUMABLE mux_catalog_Reserved_Ext { RUST2_FFI_UNCONSUMED mux_catalog_Reserved_Ext(mux_catalog_Reserved_Ext &&other RUST2_FFI_MOVED_FROM) noexcept = default; @@ -1773,7 +1771,7 @@ namespace moq { RUST2_FFI_CALLABLE ::moq::result<::moq::mux_container_Producer_loc_Wire_VideoConfig, ::moq::mux_Error> track_loc_Wire_VideoConfig(::moq::track_Producer track, const ::moq::mux_container_loc_Wire &container, ::std::optional<::moq::hang_catalog_VideoConfig> config) const; RUST2_FFI_CALLABLE ::moq::result<::moq::mux_container_Producer_loc_Wire_AudioConfig, ::moq::mux_Error> track_loc_Wire_AudioConfig(::moq::track_Producer track, const ::moq::mux_container_loc_Wire &container, ::std::optional<::moq::hang_catalog_AudioConfig> config) const; RUST2_FFI_CALLABLE ::moq::result<::moq::mux_container_Producer_loc_Wire_TextConfig, ::moq::mux_Error> track_loc_Wire_TextConfig(::moq::track_Producer track, const ::moq::mux_container_loc_Wire &container, ::std::optional<::moq::hang_catalog_TextConfig> config) const; - RUST2_FFI_CALLABLE ::moq::result<::moq::Timestamp, ::moq::mux_Error> timestamp(const ::moq::Timestamp *hint) const; + RUST2_FFI_CALLABLE ::moq::result<::moq::Timestamp, ::moq::mux_Error> timestamp(const ::std::optional<::moq::Timestamp> &hint) const; }; class RUST2_FFI_CONSUMABLE mux_catalog_VideoHint { RUST2_FFI_UNCONSUMED mux_catalog_VideoHint(mux_catalog_VideoHint &&other RUST2_FFI_MOVED_FROM) noexcept = default; @@ -2295,7 +2293,7 @@ namespace moq { RUST2_FFI_CALLABLE ::moq::result set(::moq::hang_catalog_AudioConfig config); RUST2_FFI_CALLABLE ::moq::result set_bitrate(::std::uint64_t bitrate); RUST2_FFI_CALLABLE ::moq::result<::moq::mux_container_Guard_AudioConfig, ::moq::mux_Error> modify(); - RUST2_FFI_CALLABLE ::moq::result<::moq::Timestamp, ::moq::mux_Error> timestamp(const ::moq::Timestamp *hint) const; + RUST2_FFI_CALLABLE ::moq::result<::moq::Timestamp, ::moq::mux_Error> timestamp(const ::std::optional<::moq::Timestamp> &hint) const; RUST2_FFI_CALLABLE ::moq::buf name() const; RUST2_FFI_CALLABLE ::moq::track_Demand demand() const; RUST2_FFI_CALLABLE ::moq::mux_catalog_Estimate estimate() const; @@ -2309,7 +2307,7 @@ namespace moq { RUST2_FFI_CALLABLE ::moq::track_Producer track() const; RUST2_FFI_CALLABLE ::std::optional<::moq::Timestamp> live_edge() const; RUST2_FFI_CALLABLE ::moq::result write(const ::moq::mux_container_Frame &frame); - RUST2_FFI_CALLABLE ::moq::result cut(const ::moq::Timestamp *end); + RUST2_FFI_CALLABLE ::moq::result cut(const ::std::optional<::moq::Timestamp> &end); RUST2_FFI_CALLABLE ::moq::result seek(::std::uint64_t start); RUST2_FFI_CALLABLE ::moq::result discontinuity(); RUST2_FFI_CONSUMES ::moq::result<::moq::mux_container_Finished_Container_AudioConfig, ::moq::mux_Error> finish() &&; @@ -2338,7 +2336,7 @@ namespace moq { RUST2_FFI_CALLABLE ::moq::result set(::moq::hang_catalog_BinaryConfig config); RUST2_FFI_CALLABLE ::moq::result set_bitrate(::std::uint64_t bitrate); RUST2_FFI_CALLABLE ::moq::result<::moq::mux_container_Guard_BinaryConfig, ::moq::mux_Error> modify(); - RUST2_FFI_CALLABLE ::moq::result<::moq::Timestamp, ::moq::mux_Error> timestamp(const ::moq::Timestamp *hint) const; + RUST2_FFI_CALLABLE ::moq::result<::moq::Timestamp, ::moq::mux_Error> timestamp(const ::std::optional<::moq::Timestamp> &hint) const; RUST2_FFI_CALLABLE ::moq::buf name() const; RUST2_FFI_CALLABLE ::moq::track_Demand demand() const; RUST2_FFI_CALLABLE ::moq::mux_catalog_Estimate estimate() const; @@ -2352,7 +2350,7 @@ namespace moq { RUST2_FFI_CALLABLE ::moq::track_Producer track() const; RUST2_FFI_CALLABLE ::std::optional<::moq::Timestamp> live_edge() const; RUST2_FFI_CALLABLE ::moq::result write(const ::moq::mux_container_Frame &frame); - RUST2_FFI_CALLABLE ::moq::result cut(const ::moq::Timestamp *end); + RUST2_FFI_CALLABLE ::moq::result cut(const ::std::optional<::moq::Timestamp> &end); RUST2_FFI_CALLABLE ::moq::result seek(::std::uint64_t start); RUST2_FFI_CALLABLE ::moq::result discontinuity(); RUST2_FFI_CONSUMES ::moq::result<::moq::mux_container_Finished_Container_BinaryConfig, ::moq::mux_Error> finish() &&; @@ -2381,7 +2379,7 @@ namespace moq { RUST2_FFI_CALLABLE ::moq::result set(::moq::hang_catalog_JsonConfig config); RUST2_FFI_CALLABLE ::moq::result set_bitrate(::std::uint64_t bitrate); RUST2_FFI_CALLABLE ::moq::result<::moq::mux_container_Guard_JsonConfig, ::moq::mux_Error> modify(); - RUST2_FFI_CALLABLE ::moq::result<::moq::Timestamp, ::moq::mux_Error> timestamp(const ::moq::Timestamp *hint) const; + RUST2_FFI_CALLABLE ::moq::result<::moq::Timestamp, ::moq::mux_Error> timestamp(const ::std::optional<::moq::Timestamp> &hint) const; RUST2_FFI_CALLABLE ::moq::buf name() const; RUST2_FFI_CALLABLE ::moq::track_Demand demand() const; RUST2_FFI_CALLABLE ::moq::mux_catalog_Estimate estimate() const; @@ -2395,7 +2393,7 @@ namespace moq { RUST2_FFI_CALLABLE ::moq::track_Producer track() const; RUST2_FFI_CALLABLE ::std::optional<::moq::Timestamp> live_edge() const; RUST2_FFI_CALLABLE ::moq::result write(const ::moq::mux_container_Frame &frame); - RUST2_FFI_CALLABLE ::moq::result cut(const ::moq::Timestamp *end); + RUST2_FFI_CALLABLE ::moq::result cut(const ::std::optional<::moq::Timestamp> &end); RUST2_FFI_CALLABLE ::moq::result seek(::std::uint64_t start); RUST2_FFI_CALLABLE ::moq::result discontinuity(); RUST2_FFI_CONSUMES ::moq::result<::moq::mux_container_Finished_Container_JsonConfig, ::moq::mux_Error> finish() &&; @@ -2424,7 +2422,7 @@ namespace moq { RUST2_FFI_CALLABLE ::moq::result set(::moq::hang_catalog_TextConfig config); RUST2_FFI_CALLABLE ::moq::result set_bitrate(::std::uint64_t bitrate); RUST2_FFI_CALLABLE ::moq::result<::moq::mux_container_Guard_TextConfig, ::moq::mux_Error> modify(); - RUST2_FFI_CALLABLE ::moq::result<::moq::Timestamp, ::moq::mux_Error> timestamp(const ::moq::Timestamp *hint) const; + RUST2_FFI_CALLABLE ::moq::result<::moq::Timestamp, ::moq::mux_Error> timestamp(const ::std::optional<::moq::Timestamp> &hint) const; RUST2_FFI_CALLABLE ::moq::buf name() const; RUST2_FFI_CALLABLE ::moq::track_Demand demand() const; RUST2_FFI_CALLABLE ::moq::mux_catalog_Estimate estimate() const; @@ -2438,7 +2436,7 @@ namespace moq { RUST2_FFI_CALLABLE ::moq::track_Producer track() const; RUST2_FFI_CALLABLE ::std::optional<::moq::Timestamp> live_edge() const; RUST2_FFI_CALLABLE ::moq::result write(const ::moq::mux_container_Frame &frame); - RUST2_FFI_CALLABLE ::moq::result cut(const ::moq::Timestamp *end); + RUST2_FFI_CALLABLE ::moq::result cut(const ::std::optional<::moq::Timestamp> &end); RUST2_FFI_CALLABLE ::moq::result seek(::std::uint64_t start); RUST2_FFI_CALLABLE ::moq::result discontinuity(); RUST2_FFI_CONSUMES ::moq::result<::moq::mux_container_Finished_Container_TextConfig, ::moq::mux_Error> finish() &&; @@ -2467,7 +2465,7 @@ namespace moq { RUST2_FFI_CALLABLE ::moq::result set(::moq::hang_catalog_VideoConfig config); RUST2_FFI_CALLABLE ::moq::result set_bitrate(::std::uint64_t bitrate); RUST2_FFI_CALLABLE ::moq::result<::moq::mux_container_Guard_VideoConfig, ::moq::mux_Error> modify(); - RUST2_FFI_CALLABLE ::moq::result<::moq::Timestamp, ::moq::mux_Error> timestamp(const ::moq::Timestamp *hint) const; + RUST2_FFI_CALLABLE ::moq::result<::moq::Timestamp, ::moq::mux_Error> timestamp(const ::std::optional<::moq::Timestamp> &hint) const; RUST2_FFI_CALLABLE ::moq::buf name() const; RUST2_FFI_CALLABLE ::moq::track_Demand demand() const; RUST2_FFI_CALLABLE ::moq::mux_catalog_Estimate estimate() const; @@ -2481,7 +2479,7 @@ namespace moq { RUST2_FFI_CALLABLE ::moq::track_Producer track() const; RUST2_FFI_CALLABLE ::std::optional<::moq::Timestamp> live_edge() const; RUST2_FFI_CALLABLE ::moq::result write(const ::moq::mux_container_Frame &frame); - RUST2_FFI_CALLABLE ::moq::result cut(const ::moq::Timestamp *end); + RUST2_FFI_CALLABLE ::moq::result cut(const ::std::optional<::moq::Timestamp> &end); RUST2_FFI_CALLABLE ::moq::result seek(::std::uint64_t start); RUST2_FFI_CALLABLE ::moq::result discontinuity(); RUST2_FFI_CONSUMES ::moq::result<::moq::mux_container_Finished_Container_VideoConfig, ::moq::mux_Error> finish() &&; @@ -2511,7 +2509,7 @@ namespace moq { RUST2_FFI_CALLABLE ::moq::result set(); RUST2_FFI_CALLABLE ::moq::result set_bitrate(::std::uint64_t bitrate); RUST2_FFI_CALLABLE ::moq::result<::moq::mux_container_Guard_unit, ::moq::mux_Error> modify(); - RUST2_FFI_CALLABLE ::moq::result<::moq::Timestamp, ::moq::mux_Error> timestamp(const ::moq::Timestamp *hint) const; + RUST2_FFI_CALLABLE ::moq::result<::moq::Timestamp, ::moq::mux_Error> timestamp(const ::std::optional<::moq::Timestamp> &hint) const; RUST2_FFI_CALLABLE ::moq::buf name() const; RUST2_FFI_CALLABLE ::moq::track_Demand demand() const; RUST2_FFI_CALLABLE ::moq::mux_catalog_Estimate estimate() const; @@ -2525,7 +2523,7 @@ namespace moq { RUST2_FFI_CALLABLE ::moq::track_Producer track() const; RUST2_FFI_CALLABLE ::std::optional<::moq::Timestamp> live_edge() const; RUST2_FFI_CALLABLE ::moq::result write(const ::moq::mux_container_Frame &frame); - RUST2_FFI_CALLABLE ::moq::result cut(const ::moq::Timestamp *end); + RUST2_FFI_CALLABLE ::moq::result cut(const ::std::optional<::moq::Timestamp> &end); RUST2_FFI_CALLABLE ::moq::result seek(::std::uint64_t start); RUST2_FFI_CALLABLE ::moq::result discontinuity(); RUST2_FFI_CONSUMES ::moq::result<::moq::mux_container_Finished_Container, ::moq::mux_Error> finish() &&; @@ -2554,7 +2552,7 @@ namespace moq { RUST2_FFI_CALLABLE ::moq::result set(::moq::hang_catalog_AudioConfig config); RUST2_FFI_CALLABLE ::moq::result set_bitrate(::std::uint64_t bitrate); RUST2_FFI_CALLABLE ::moq::result<::moq::mux_container_Guard_AudioConfig, ::moq::mux_Error> modify(); - RUST2_FFI_CALLABLE ::moq::result<::moq::Timestamp, ::moq::mux_Error> timestamp(const ::moq::Timestamp *hint) const; + RUST2_FFI_CALLABLE ::moq::result<::moq::Timestamp, ::moq::mux_Error> timestamp(const ::std::optional<::moq::Timestamp> &hint) const; RUST2_FFI_CALLABLE ::moq::buf name() const; RUST2_FFI_CALLABLE ::moq::track_Demand demand() const; RUST2_FFI_CALLABLE ::moq::mux_catalog_Estimate estimate() const; @@ -2568,7 +2566,7 @@ namespace moq { RUST2_FFI_CALLABLE ::moq::track_Producer track() const; RUST2_FFI_CALLABLE ::std::optional<::moq::Timestamp> live_edge() const; RUST2_FFI_CALLABLE ::moq::result write(const ::moq::mux_container_Frame &frame); - RUST2_FFI_CALLABLE ::moq::result cut(const ::moq::Timestamp *end); + RUST2_FFI_CALLABLE ::moq::result cut(const ::std::optional<::moq::Timestamp> &end); RUST2_FFI_CALLABLE ::moq::result seek(::std::uint64_t start); RUST2_FFI_CALLABLE ::moq::result discontinuity(); RUST2_FFI_CONSUMES ::moq::result<::moq::mux_container_Finished_fmp4_Wire_AudioConfig, ::moq::mux_Error> finish() &&; @@ -2597,7 +2595,7 @@ namespace moq { RUST2_FFI_CALLABLE ::moq::result set(::moq::hang_catalog_BinaryConfig config); RUST2_FFI_CALLABLE ::moq::result set_bitrate(::std::uint64_t bitrate); RUST2_FFI_CALLABLE ::moq::result<::moq::mux_container_Guard_BinaryConfig, ::moq::mux_Error> modify(); - RUST2_FFI_CALLABLE ::moq::result<::moq::Timestamp, ::moq::mux_Error> timestamp(const ::moq::Timestamp *hint) const; + RUST2_FFI_CALLABLE ::moq::result<::moq::Timestamp, ::moq::mux_Error> timestamp(const ::std::optional<::moq::Timestamp> &hint) const; RUST2_FFI_CALLABLE ::moq::buf name() const; RUST2_FFI_CALLABLE ::moq::track_Demand demand() const; RUST2_FFI_CALLABLE ::moq::mux_catalog_Estimate estimate() const; @@ -2611,7 +2609,7 @@ namespace moq { RUST2_FFI_CALLABLE ::moq::track_Producer track() const; RUST2_FFI_CALLABLE ::std::optional<::moq::Timestamp> live_edge() const; RUST2_FFI_CALLABLE ::moq::result write(const ::moq::mux_container_Frame &frame); - RUST2_FFI_CALLABLE ::moq::result cut(const ::moq::Timestamp *end); + RUST2_FFI_CALLABLE ::moq::result cut(const ::std::optional<::moq::Timestamp> &end); RUST2_FFI_CALLABLE ::moq::result seek(::std::uint64_t start); RUST2_FFI_CALLABLE ::moq::result discontinuity(); RUST2_FFI_CONSUMES ::moq::result<::moq::mux_container_Finished_fmp4_Wire_BinaryConfig, ::moq::mux_Error> finish() &&; @@ -2640,7 +2638,7 @@ namespace moq { RUST2_FFI_CALLABLE ::moq::result set(::moq::hang_catalog_JsonConfig config); RUST2_FFI_CALLABLE ::moq::result set_bitrate(::std::uint64_t bitrate); RUST2_FFI_CALLABLE ::moq::result<::moq::mux_container_Guard_JsonConfig, ::moq::mux_Error> modify(); - RUST2_FFI_CALLABLE ::moq::result<::moq::Timestamp, ::moq::mux_Error> timestamp(const ::moq::Timestamp *hint) const; + RUST2_FFI_CALLABLE ::moq::result<::moq::Timestamp, ::moq::mux_Error> timestamp(const ::std::optional<::moq::Timestamp> &hint) const; RUST2_FFI_CALLABLE ::moq::buf name() const; RUST2_FFI_CALLABLE ::moq::track_Demand demand() const; RUST2_FFI_CALLABLE ::moq::mux_catalog_Estimate estimate() const; @@ -2654,7 +2652,7 @@ namespace moq { RUST2_FFI_CALLABLE ::moq::track_Producer track() const; RUST2_FFI_CALLABLE ::std::optional<::moq::Timestamp> live_edge() const; RUST2_FFI_CALLABLE ::moq::result write(const ::moq::mux_container_Frame &frame); - RUST2_FFI_CALLABLE ::moq::result cut(const ::moq::Timestamp *end); + RUST2_FFI_CALLABLE ::moq::result cut(const ::std::optional<::moq::Timestamp> &end); RUST2_FFI_CALLABLE ::moq::result seek(::std::uint64_t start); RUST2_FFI_CALLABLE ::moq::result discontinuity(); RUST2_FFI_CONSUMES ::moq::result<::moq::mux_container_Finished_fmp4_Wire_JsonConfig, ::moq::mux_Error> finish() &&; @@ -2683,7 +2681,7 @@ namespace moq { RUST2_FFI_CALLABLE ::moq::result set(::moq::hang_catalog_TextConfig config); RUST2_FFI_CALLABLE ::moq::result set_bitrate(::std::uint64_t bitrate); RUST2_FFI_CALLABLE ::moq::result<::moq::mux_container_Guard_TextConfig, ::moq::mux_Error> modify(); - RUST2_FFI_CALLABLE ::moq::result<::moq::Timestamp, ::moq::mux_Error> timestamp(const ::moq::Timestamp *hint) const; + RUST2_FFI_CALLABLE ::moq::result<::moq::Timestamp, ::moq::mux_Error> timestamp(const ::std::optional<::moq::Timestamp> &hint) const; RUST2_FFI_CALLABLE ::moq::buf name() const; RUST2_FFI_CALLABLE ::moq::track_Demand demand() const; RUST2_FFI_CALLABLE ::moq::mux_catalog_Estimate estimate() const; @@ -2697,7 +2695,7 @@ namespace moq { RUST2_FFI_CALLABLE ::moq::track_Producer track() const; RUST2_FFI_CALLABLE ::std::optional<::moq::Timestamp> live_edge() const; RUST2_FFI_CALLABLE ::moq::result write(const ::moq::mux_container_Frame &frame); - RUST2_FFI_CALLABLE ::moq::result cut(const ::moq::Timestamp *end); + RUST2_FFI_CALLABLE ::moq::result cut(const ::std::optional<::moq::Timestamp> &end); RUST2_FFI_CALLABLE ::moq::result seek(::std::uint64_t start); RUST2_FFI_CALLABLE ::moq::result discontinuity(); RUST2_FFI_CONSUMES ::moq::result<::moq::mux_container_Finished_fmp4_Wire_TextConfig, ::moq::mux_Error> finish() &&; @@ -2726,7 +2724,7 @@ namespace moq { RUST2_FFI_CALLABLE ::moq::result set(::moq::hang_catalog_VideoConfig config); RUST2_FFI_CALLABLE ::moq::result set_bitrate(::std::uint64_t bitrate); RUST2_FFI_CALLABLE ::moq::result<::moq::mux_container_Guard_VideoConfig, ::moq::mux_Error> modify(); - RUST2_FFI_CALLABLE ::moq::result<::moq::Timestamp, ::moq::mux_Error> timestamp(const ::moq::Timestamp *hint) const; + RUST2_FFI_CALLABLE ::moq::result<::moq::Timestamp, ::moq::mux_Error> timestamp(const ::std::optional<::moq::Timestamp> &hint) const; RUST2_FFI_CALLABLE ::moq::buf name() const; RUST2_FFI_CALLABLE ::moq::track_Demand demand() const; RUST2_FFI_CALLABLE ::moq::mux_catalog_Estimate estimate() const; @@ -2740,7 +2738,7 @@ namespace moq { RUST2_FFI_CALLABLE ::moq::track_Producer track() const; RUST2_FFI_CALLABLE ::std::optional<::moq::Timestamp> live_edge() const; RUST2_FFI_CALLABLE ::moq::result write(const ::moq::mux_container_Frame &frame); - RUST2_FFI_CALLABLE ::moq::result cut(const ::moq::Timestamp *end); + RUST2_FFI_CALLABLE ::moq::result cut(const ::std::optional<::moq::Timestamp> &end); RUST2_FFI_CALLABLE ::moq::result seek(::std::uint64_t start); RUST2_FFI_CALLABLE ::moq::result discontinuity(); RUST2_FFI_CONSUMES ::moq::result<::moq::mux_container_Finished_fmp4_Wire_VideoConfig, ::moq::mux_Error> finish() &&; @@ -2770,7 +2768,7 @@ namespace moq { RUST2_FFI_CALLABLE ::moq::result set(); RUST2_FFI_CALLABLE ::moq::result set_bitrate(::std::uint64_t bitrate); RUST2_FFI_CALLABLE ::moq::result<::moq::mux_container_Guard_unit, ::moq::mux_Error> modify(); - RUST2_FFI_CALLABLE ::moq::result<::moq::Timestamp, ::moq::mux_Error> timestamp(const ::moq::Timestamp *hint) const; + RUST2_FFI_CALLABLE ::moq::result<::moq::Timestamp, ::moq::mux_Error> timestamp(const ::std::optional<::moq::Timestamp> &hint) const; RUST2_FFI_CALLABLE ::moq::buf name() const; RUST2_FFI_CALLABLE ::moq::track_Demand demand() const; RUST2_FFI_CALLABLE ::moq::mux_catalog_Estimate estimate() const; @@ -2784,7 +2782,7 @@ namespace moq { RUST2_FFI_CALLABLE ::moq::track_Producer track() const; RUST2_FFI_CALLABLE ::std::optional<::moq::Timestamp> live_edge() const; RUST2_FFI_CALLABLE ::moq::result write(const ::moq::mux_container_Frame &frame); - RUST2_FFI_CALLABLE ::moq::result cut(const ::moq::Timestamp *end); + RUST2_FFI_CALLABLE ::moq::result cut(const ::std::optional<::moq::Timestamp> &end); RUST2_FFI_CALLABLE ::moq::result seek(::std::uint64_t start); RUST2_FFI_CALLABLE ::moq::result discontinuity(); RUST2_FFI_CONSUMES ::moq::result<::moq::mux_container_Finished_fmp4_Wire, ::moq::mux_Error> finish() &&; @@ -2813,7 +2811,7 @@ namespace moq { RUST2_FFI_CALLABLE ::moq::result set(::moq::hang_catalog_AudioConfig config); RUST2_FFI_CALLABLE ::moq::result set_bitrate(::std::uint64_t bitrate); RUST2_FFI_CALLABLE ::moq::result<::moq::mux_container_Guard_AudioConfig, ::moq::mux_Error> modify(); - RUST2_FFI_CALLABLE ::moq::result<::moq::Timestamp, ::moq::mux_Error> timestamp(const ::moq::Timestamp *hint) const; + RUST2_FFI_CALLABLE ::moq::result<::moq::Timestamp, ::moq::mux_Error> timestamp(const ::std::optional<::moq::Timestamp> &hint) const; RUST2_FFI_CALLABLE ::moq::buf name() const; RUST2_FFI_CALLABLE ::moq::track_Demand demand() const; RUST2_FFI_CALLABLE ::moq::mux_catalog_Estimate estimate() const; @@ -2827,7 +2825,7 @@ namespace moq { RUST2_FFI_CALLABLE ::moq::track_Producer track() const; RUST2_FFI_CALLABLE ::std::optional<::moq::Timestamp> live_edge() const; RUST2_FFI_CALLABLE ::moq::result write(const ::moq::mux_container_Frame &frame); - RUST2_FFI_CALLABLE ::moq::result cut(const ::moq::Timestamp *end); + RUST2_FFI_CALLABLE ::moq::result cut(const ::std::optional<::moq::Timestamp> &end); RUST2_FFI_CALLABLE ::moq::result seek(::std::uint64_t start); RUST2_FFI_CALLABLE ::moq::result discontinuity(); RUST2_FFI_CONSUMES ::moq::result<::moq::mux_container_Finished_legacy_Wire_AudioConfig, ::moq::mux_Error> finish() &&; @@ -2856,7 +2854,7 @@ namespace moq { RUST2_FFI_CALLABLE ::moq::result set(::moq::hang_catalog_BinaryConfig config); RUST2_FFI_CALLABLE ::moq::result set_bitrate(::std::uint64_t bitrate); RUST2_FFI_CALLABLE ::moq::result<::moq::mux_container_Guard_BinaryConfig, ::moq::mux_Error> modify(); - RUST2_FFI_CALLABLE ::moq::result<::moq::Timestamp, ::moq::mux_Error> timestamp(const ::moq::Timestamp *hint) const; + RUST2_FFI_CALLABLE ::moq::result<::moq::Timestamp, ::moq::mux_Error> timestamp(const ::std::optional<::moq::Timestamp> &hint) const; RUST2_FFI_CALLABLE ::moq::buf name() const; RUST2_FFI_CALLABLE ::moq::track_Demand demand() const; RUST2_FFI_CALLABLE ::moq::mux_catalog_Estimate estimate() const; @@ -2870,7 +2868,7 @@ namespace moq { RUST2_FFI_CALLABLE ::moq::track_Producer track() const; RUST2_FFI_CALLABLE ::std::optional<::moq::Timestamp> live_edge() const; RUST2_FFI_CALLABLE ::moq::result write(const ::moq::mux_container_Frame &frame); - RUST2_FFI_CALLABLE ::moq::result cut(const ::moq::Timestamp *end); + RUST2_FFI_CALLABLE ::moq::result cut(const ::std::optional<::moq::Timestamp> &end); RUST2_FFI_CALLABLE ::moq::result seek(::std::uint64_t start); RUST2_FFI_CALLABLE ::moq::result discontinuity(); RUST2_FFI_CONSUMES ::moq::result<::moq::mux_container_Finished_legacy_Wire_BinaryConfig, ::moq::mux_Error> finish() &&; @@ -2899,7 +2897,7 @@ namespace moq { RUST2_FFI_CALLABLE ::moq::result set(::moq::hang_catalog_JsonConfig config); RUST2_FFI_CALLABLE ::moq::result set_bitrate(::std::uint64_t bitrate); RUST2_FFI_CALLABLE ::moq::result<::moq::mux_container_Guard_JsonConfig, ::moq::mux_Error> modify(); - RUST2_FFI_CALLABLE ::moq::result<::moq::Timestamp, ::moq::mux_Error> timestamp(const ::moq::Timestamp *hint) const; + RUST2_FFI_CALLABLE ::moq::result<::moq::Timestamp, ::moq::mux_Error> timestamp(const ::std::optional<::moq::Timestamp> &hint) const; RUST2_FFI_CALLABLE ::moq::buf name() const; RUST2_FFI_CALLABLE ::moq::track_Demand demand() const; RUST2_FFI_CALLABLE ::moq::mux_catalog_Estimate estimate() const; @@ -2913,7 +2911,7 @@ namespace moq { RUST2_FFI_CALLABLE ::moq::track_Producer track() const; RUST2_FFI_CALLABLE ::std::optional<::moq::Timestamp> live_edge() const; RUST2_FFI_CALLABLE ::moq::result write(const ::moq::mux_container_Frame &frame); - RUST2_FFI_CALLABLE ::moq::result cut(const ::moq::Timestamp *end); + RUST2_FFI_CALLABLE ::moq::result cut(const ::std::optional<::moq::Timestamp> &end); RUST2_FFI_CALLABLE ::moq::result seek(::std::uint64_t start); RUST2_FFI_CALLABLE ::moq::result discontinuity(); RUST2_FFI_CONSUMES ::moq::result<::moq::mux_container_Finished_legacy_Wire_JsonConfig, ::moq::mux_Error> finish() &&; @@ -2942,7 +2940,7 @@ namespace moq { RUST2_FFI_CALLABLE ::moq::result set(::moq::hang_catalog_TextConfig config); RUST2_FFI_CALLABLE ::moq::result set_bitrate(::std::uint64_t bitrate); RUST2_FFI_CALLABLE ::moq::result<::moq::mux_container_Guard_TextConfig, ::moq::mux_Error> modify(); - RUST2_FFI_CALLABLE ::moq::result<::moq::Timestamp, ::moq::mux_Error> timestamp(const ::moq::Timestamp *hint) const; + RUST2_FFI_CALLABLE ::moq::result<::moq::Timestamp, ::moq::mux_Error> timestamp(const ::std::optional<::moq::Timestamp> &hint) const; RUST2_FFI_CALLABLE ::moq::buf name() const; RUST2_FFI_CALLABLE ::moq::track_Demand demand() const; RUST2_FFI_CALLABLE ::moq::mux_catalog_Estimate estimate() const; @@ -2956,7 +2954,7 @@ namespace moq { RUST2_FFI_CALLABLE ::moq::track_Producer track() const; RUST2_FFI_CALLABLE ::std::optional<::moq::Timestamp> live_edge() const; RUST2_FFI_CALLABLE ::moq::result write(const ::moq::mux_container_Frame &frame); - RUST2_FFI_CALLABLE ::moq::result cut(const ::moq::Timestamp *end); + RUST2_FFI_CALLABLE ::moq::result cut(const ::std::optional<::moq::Timestamp> &end); RUST2_FFI_CALLABLE ::moq::result seek(::std::uint64_t start); RUST2_FFI_CALLABLE ::moq::result discontinuity(); RUST2_FFI_CONSUMES ::moq::result<::moq::mux_container_Finished_legacy_Wire_TextConfig, ::moq::mux_Error> finish() &&; @@ -2985,7 +2983,7 @@ namespace moq { RUST2_FFI_CALLABLE ::moq::result set(::moq::hang_catalog_VideoConfig config); RUST2_FFI_CALLABLE ::moq::result set_bitrate(::std::uint64_t bitrate); RUST2_FFI_CALLABLE ::moq::result<::moq::mux_container_Guard_VideoConfig, ::moq::mux_Error> modify(); - RUST2_FFI_CALLABLE ::moq::result<::moq::Timestamp, ::moq::mux_Error> timestamp(const ::moq::Timestamp *hint) const; + RUST2_FFI_CALLABLE ::moq::result<::moq::Timestamp, ::moq::mux_Error> timestamp(const ::std::optional<::moq::Timestamp> &hint) const; RUST2_FFI_CALLABLE ::moq::buf name() const; RUST2_FFI_CALLABLE ::moq::track_Demand demand() const; RUST2_FFI_CALLABLE ::moq::mux_catalog_Estimate estimate() const; @@ -2999,7 +2997,7 @@ namespace moq { RUST2_FFI_CALLABLE ::moq::track_Producer track() const; RUST2_FFI_CALLABLE ::std::optional<::moq::Timestamp> live_edge() const; RUST2_FFI_CALLABLE ::moq::result write(const ::moq::mux_container_Frame &frame); - RUST2_FFI_CALLABLE ::moq::result cut(const ::moq::Timestamp *end); + RUST2_FFI_CALLABLE ::moq::result cut(const ::std::optional<::moq::Timestamp> &end); RUST2_FFI_CALLABLE ::moq::result seek(::std::uint64_t start); RUST2_FFI_CALLABLE ::moq::result discontinuity(); RUST2_FFI_CONSUMES ::moq::result<::moq::mux_container_Finished_legacy_Wire_VideoConfig, ::moq::mux_Error> finish() &&; @@ -3029,7 +3027,7 @@ namespace moq { RUST2_FFI_CALLABLE ::moq::result set(); RUST2_FFI_CALLABLE ::moq::result set_bitrate(::std::uint64_t bitrate); RUST2_FFI_CALLABLE ::moq::result<::moq::mux_container_Guard_unit, ::moq::mux_Error> modify(); - RUST2_FFI_CALLABLE ::moq::result<::moq::Timestamp, ::moq::mux_Error> timestamp(const ::moq::Timestamp *hint) const; + RUST2_FFI_CALLABLE ::moq::result<::moq::Timestamp, ::moq::mux_Error> timestamp(const ::std::optional<::moq::Timestamp> &hint) const; RUST2_FFI_CALLABLE ::moq::buf name() const; RUST2_FFI_CALLABLE ::moq::track_Demand demand() const; RUST2_FFI_CALLABLE ::moq::mux_catalog_Estimate estimate() const; @@ -3043,7 +3041,7 @@ namespace moq { RUST2_FFI_CALLABLE ::moq::track_Producer track() const; RUST2_FFI_CALLABLE ::std::optional<::moq::Timestamp> live_edge() const; RUST2_FFI_CALLABLE ::moq::result write(const ::moq::mux_container_Frame &frame); - RUST2_FFI_CALLABLE ::moq::result cut(const ::moq::Timestamp *end); + RUST2_FFI_CALLABLE ::moq::result cut(const ::std::optional<::moq::Timestamp> &end); RUST2_FFI_CALLABLE ::moq::result seek(::std::uint64_t start); RUST2_FFI_CALLABLE ::moq::result discontinuity(); RUST2_FFI_CONSUMES ::moq::result<::moq::mux_container_Finished_legacy_Wire, ::moq::mux_Error> finish() &&; @@ -3072,7 +3070,7 @@ namespace moq { RUST2_FFI_CALLABLE ::moq::result set(::moq::hang_catalog_AudioConfig config); RUST2_FFI_CALLABLE ::moq::result set_bitrate(::std::uint64_t bitrate); RUST2_FFI_CALLABLE ::moq::result<::moq::mux_container_Guard_AudioConfig, ::moq::mux_Error> modify(); - RUST2_FFI_CALLABLE ::moq::result<::moq::Timestamp, ::moq::mux_Error> timestamp(const ::moq::Timestamp *hint) const; + RUST2_FFI_CALLABLE ::moq::result<::moq::Timestamp, ::moq::mux_Error> timestamp(const ::std::optional<::moq::Timestamp> &hint) const; RUST2_FFI_CALLABLE ::moq::buf name() const; RUST2_FFI_CALLABLE ::moq::track_Demand demand() const; RUST2_FFI_CALLABLE ::moq::mux_catalog_Estimate estimate() const; @@ -3086,7 +3084,7 @@ namespace moq { RUST2_FFI_CALLABLE ::moq::track_Producer track() const; RUST2_FFI_CALLABLE ::std::optional<::moq::Timestamp> live_edge() const; RUST2_FFI_CALLABLE ::moq::result write(const ::moq::mux_container_Frame &frame); - RUST2_FFI_CALLABLE ::moq::result cut(const ::moq::Timestamp *end); + RUST2_FFI_CALLABLE ::moq::result cut(const ::std::optional<::moq::Timestamp> &end); RUST2_FFI_CALLABLE ::moq::result seek(::std::uint64_t start); RUST2_FFI_CALLABLE ::moq::result discontinuity(); RUST2_FFI_CONSUMES ::moq::result<::moq::mux_container_Finished_loc_Wire_AudioConfig, ::moq::mux_Error> finish() &&; @@ -3115,7 +3113,7 @@ namespace moq { RUST2_FFI_CALLABLE ::moq::result set(::moq::hang_catalog_BinaryConfig config); RUST2_FFI_CALLABLE ::moq::result set_bitrate(::std::uint64_t bitrate); RUST2_FFI_CALLABLE ::moq::result<::moq::mux_container_Guard_BinaryConfig, ::moq::mux_Error> modify(); - RUST2_FFI_CALLABLE ::moq::result<::moq::Timestamp, ::moq::mux_Error> timestamp(const ::moq::Timestamp *hint) const; + RUST2_FFI_CALLABLE ::moq::result<::moq::Timestamp, ::moq::mux_Error> timestamp(const ::std::optional<::moq::Timestamp> &hint) const; RUST2_FFI_CALLABLE ::moq::buf name() const; RUST2_FFI_CALLABLE ::moq::track_Demand demand() const; RUST2_FFI_CALLABLE ::moq::mux_catalog_Estimate estimate() const; @@ -3129,7 +3127,7 @@ namespace moq { RUST2_FFI_CALLABLE ::moq::track_Producer track() const; RUST2_FFI_CALLABLE ::std::optional<::moq::Timestamp> live_edge() const; RUST2_FFI_CALLABLE ::moq::result write(const ::moq::mux_container_Frame &frame); - RUST2_FFI_CALLABLE ::moq::result cut(const ::moq::Timestamp *end); + RUST2_FFI_CALLABLE ::moq::result cut(const ::std::optional<::moq::Timestamp> &end); RUST2_FFI_CALLABLE ::moq::result seek(::std::uint64_t start); RUST2_FFI_CALLABLE ::moq::result discontinuity(); RUST2_FFI_CONSUMES ::moq::result<::moq::mux_container_Finished_loc_Wire_BinaryConfig, ::moq::mux_Error> finish() &&; @@ -3158,7 +3156,7 @@ namespace moq { RUST2_FFI_CALLABLE ::moq::result set(::moq::hang_catalog_JsonConfig config); RUST2_FFI_CALLABLE ::moq::result set_bitrate(::std::uint64_t bitrate); RUST2_FFI_CALLABLE ::moq::result<::moq::mux_container_Guard_JsonConfig, ::moq::mux_Error> modify(); - RUST2_FFI_CALLABLE ::moq::result<::moq::Timestamp, ::moq::mux_Error> timestamp(const ::moq::Timestamp *hint) const; + RUST2_FFI_CALLABLE ::moq::result<::moq::Timestamp, ::moq::mux_Error> timestamp(const ::std::optional<::moq::Timestamp> &hint) const; RUST2_FFI_CALLABLE ::moq::buf name() const; RUST2_FFI_CALLABLE ::moq::track_Demand demand() const; RUST2_FFI_CALLABLE ::moq::mux_catalog_Estimate estimate() const; @@ -3172,7 +3170,7 @@ namespace moq { RUST2_FFI_CALLABLE ::moq::track_Producer track() const; RUST2_FFI_CALLABLE ::std::optional<::moq::Timestamp> live_edge() const; RUST2_FFI_CALLABLE ::moq::result write(const ::moq::mux_container_Frame &frame); - RUST2_FFI_CALLABLE ::moq::result cut(const ::moq::Timestamp *end); + RUST2_FFI_CALLABLE ::moq::result cut(const ::std::optional<::moq::Timestamp> &end); RUST2_FFI_CALLABLE ::moq::result seek(::std::uint64_t start); RUST2_FFI_CALLABLE ::moq::result discontinuity(); RUST2_FFI_CONSUMES ::moq::result<::moq::mux_container_Finished_loc_Wire_JsonConfig, ::moq::mux_Error> finish() &&; @@ -3201,7 +3199,7 @@ namespace moq { RUST2_FFI_CALLABLE ::moq::result set(::moq::hang_catalog_TextConfig config); RUST2_FFI_CALLABLE ::moq::result set_bitrate(::std::uint64_t bitrate); RUST2_FFI_CALLABLE ::moq::result<::moq::mux_container_Guard_TextConfig, ::moq::mux_Error> modify(); - RUST2_FFI_CALLABLE ::moq::result<::moq::Timestamp, ::moq::mux_Error> timestamp(const ::moq::Timestamp *hint) const; + RUST2_FFI_CALLABLE ::moq::result<::moq::Timestamp, ::moq::mux_Error> timestamp(const ::std::optional<::moq::Timestamp> &hint) const; RUST2_FFI_CALLABLE ::moq::buf name() const; RUST2_FFI_CALLABLE ::moq::track_Demand demand() const; RUST2_FFI_CALLABLE ::moq::mux_catalog_Estimate estimate() const; @@ -3215,7 +3213,7 @@ namespace moq { RUST2_FFI_CALLABLE ::moq::track_Producer track() const; RUST2_FFI_CALLABLE ::std::optional<::moq::Timestamp> live_edge() const; RUST2_FFI_CALLABLE ::moq::result write(const ::moq::mux_container_Frame &frame); - RUST2_FFI_CALLABLE ::moq::result cut(const ::moq::Timestamp *end); + RUST2_FFI_CALLABLE ::moq::result cut(const ::std::optional<::moq::Timestamp> &end); RUST2_FFI_CALLABLE ::moq::result seek(::std::uint64_t start); RUST2_FFI_CALLABLE ::moq::result discontinuity(); RUST2_FFI_CONSUMES ::moq::result<::moq::mux_container_Finished_loc_Wire_TextConfig, ::moq::mux_Error> finish() &&; @@ -3244,7 +3242,7 @@ namespace moq { RUST2_FFI_CALLABLE ::moq::result set(::moq::hang_catalog_VideoConfig config); RUST2_FFI_CALLABLE ::moq::result set_bitrate(::std::uint64_t bitrate); RUST2_FFI_CALLABLE ::moq::result<::moq::mux_container_Guard_VideoConfig, ::moq::mux_Error> modify(); - RUST2_FFI_CALLABLE ::moq::result<::moq::Timestamp, ::moq::mux_Error> timestamp(const ::moq::Timestamp *hint) const; + RUST2_FFI_CALLABLE ::moq::result<::moq::Timestamp, ::moq::mux_Error> timestamp(const ::std::optional<::moq::Timestamp> &hint) const; RUST2_FFI_CALLABLE ::moq::buf name() const; RUST2_FFI_CALLABLE ::moq::track_Demand demand() const; RUST2_FFI_CALLABLE ::moq::mux_catalog_Estimate estimate() const; @@ -3258,7 +3256,7 @@ namespace moq { RUST2_FFI_CALLABLE ::moq::track_Producer track() const; RUST2_FFI_CALLABLE ::std::optional<::moq::Timestamp> live_edge() const; RUST2_FFI_CALLABLE ::moq::result write(const ::moq::mux_container_Frame &frame); - RUST2_FFI_CALLABLE ::moq::result cut(const ::moq::Timestamp *end); + RUST2_FFI_CALLABLE ::moq::result cut(const ::std::optional<::moq::Timestamp> &end); RUST2_FFI_CALLABLE ::moq::result seek(::std::uint64_t start); RUST2_FFI_CALLABLE ::moq::result discontinuity(); RUST2_FFI_CONSUMES ::moq::result<::moq::mux_container_Finished_loc_Wire_VideoConfig, ::moq::mux_Error> finish() &&; @@ -3288,7 +3286,7 @@ namespace moq { RUST2_FFI_CALLABLE ::moq::result set(); RUST2_FFI_CALLABLE ::moq::result set_bitrate(::std::uint64_t bitrate); RUST2_FFI_CALLABLE ::moq::result<::moq::mux_container_Guard_unit, ::moq::mux_Error> modify(); - RUST2_FFI_CALLABLE ::moq::result<::moq::Timestamp, ::moq::mux_Error> timestamp(const ::moq::Timestamp *hint) const; + RUST2_FFI_CALLABLE ::moq::result<::moq::Timestamp, ::moq::mux_Error> timestamp(const ::std::optional<::moq::Timestamp> &hint) const; RUST2_FFI_CALLABLE ::moq::buf name() const; RUST2_FFI_CALLABLE ::moq::track_Demand demand() const; RUST2_FFI_CALLABLE ::moq::mux_catalog_Estimate estimate() const; @@ -3302,7 +3300,7 @@ namespace moq { RUST2_FFI_CALLABLE ::moq::track_Producer track() const; RUST2_FFI_CALLABLE ::std::optional<::moq::Timestamp> live_edge() const; RUST2_FFI_CALLABLE ::moq::result write(const ::moq::mux_container_Frame &frame); - RUST2_FFI_CALLABLE ::moq::result cut(const ::moq::Timestamp *end); + RUST2_FFI_CALLABLE ::moq::result cut(const ::std::optional<::moq::Timestamp> &end); RUST2_FFI_CALLABLE ::moq::result seek(::std::uint64_t start); RUST2_FFI_CALLABLE ::moq::result discontinuity(); RUST2_FFI_CONSUMES ::moq::result<::moq::mux_container_Finished_loc_Wire, ::moq::mux_Error> finish() &&; @@ -3420,11 +3418,11 @@ namespace moq { static ::moq::result<::moq::mux_import_Track, ::moq::mux_Error> video_Extra(::moq::track_Request request, ::moq::mux_catalog_Reserved_Extra reserved, ::moq::mux_import_VideoInit init); static ::moq::result<::moq::mux_import_Track, ::moq::mux_Error> video_Ext(::moq::track_Request request, ::moq::mux_catalog_Reserved_Ext reserved, ::moq::mux_import_VideoInit init); static ::moq::result<::moq::mux_import_Track, ::moq::mux_Error> video_unit(::moq::track_Request request, ::moq::mux_catalog_Reserved reserved, ::moq::mux_import_VideoInit init); - RUST2_FFI_CALLABLE ::moq::result decode(::moq::input frame, const ::moq::Timestamp *pts); + RUST2_FFI_CALLABLE ::moq::result decode(::moq::input frame, const ::std::optional<::moq::Timestamp> &pts); RUST2_FFI_CONSUMES ::moq::result<::moq::mux_import_track_Finished, ::moq::mux_Error> finish() &&; RUST2_FFI_CONSUMES void abort(::moq::Error err) &&; RUST2_FFI_CONSUMES ::moq::result abort_unwanted(::moq::Error err) &&; - RUST2_FFI_CALLABLE ::moq::result cut(const ::moq::Timestamp *end); + RUST2_FFI_CALLABLE ::moq::result cut(const ::std::optional<::moq::Timestamp> &end); RUST2_FFI_CALLABLE ::moq::result discontinuity(); RUST2_FFI_CALLABLE ::moq::result set_enabled(bool enabled); RUST2_FFI_CALLABLE ::moq::result seek(::std::uint64_t start); @@ -3443,7 +3441,7 @@ namespace moq { RUST2_FFI_CALLABLE ::moq::result set_enabled(bool enabled); RUST2_FFI_CONSUMES void abort(::moq::Error err) &&; RUST2_FFI_CONSUMES ::moq::result abort_unwanted(::moq::Error err) &&; - RUST2_FFI_CALLABLE ::moq::result cut(const ::moq::Timestamp *end); + RUST2_FFI_CALLABLE ::moq::result cut(const ::std::optional<::moq::Timestamp> &end); RUST2_FFI_CALLABLE ::moq::result seek(::std::uint64_t start); RUST2_FFI_CALLABLE ::moq::track_Demand demand() const; RUST2_FFI_CALLABLE ::moq::buf name() const; @@ -3699,10 +3697,10 @@ namespace moq { RUST2_FFI_CONSUMES ::moq::result<::moq::mux_container_Finished_Container_AudioConfig, ::moq::mux_Error> finish() &&; RUST2_FFI_CONSUMES void abort(::moq::Error err) &&; RUST2_FFI_CONSUMES ::moq::result abort_unwanted(::moq::Error err) &&; - RUST2_FFI_CALLABLE ::moq::result cut(const ::moq::Timestamp *end); + RUST2_FFI_CALLABLE ::moq::result cut(const ::std::optional<::moq::Timestamp> &end); RUST2_FFI_CALLABLE ::moq::result discontinuity(); RUST2_FFI_CALLABLE ::moq::result seek(::std::uint64_t start); - RUST2_FFI_CALLABLE ::moq::result decode(::moq::input frame, const ::moq::Timestamp *pts); + RUST2_FFI_CALLABLE ::moq::result decode(::moq::input frame, const ::std::optional<::moq::Timestamp> &pts); }; class RUST2_FFI_CONSUMABLE mux_codec_annexb_Error { RUST2_FFI_UNCONSUMED mux_codec_annexb_Error(mux_codec_annexb_Error &&other RUST2_FFI_MOVED_FROM) noexcept = default; @@ -3723,7 +3721,7 @@ namespace moq { RUST2_FFI_CONSUMES ::moq::result<::moq::mux_container_Finished_Container_VideoConfig, ::moq::mux_Error> finish() &&; RUST2_FFI_CONSUMES void abort(::moq::Error err) &&; RUST2_FFI_CONSUMES ::moq::result abort_unwanted(::moq::Error err) &&; - RUST2_FFI_CALLABLE ::moq::result cut(const ::moq::Timestamp *end); + RUST2_FFI_CALLABLE ::moq::result cut(const ::std::optional<::moq::Timestamp> &end); RUST2_FFI_CALLABLE ::moq::result discontinuity(); RUST2_FFI_CALLABLE ::moq::result set_enabled(bool enabled); RUST2_FFI_CALLABLE ::moq::result seek(::std::uint64_t start); @@ -3734,8 +3732,8 @@ namespace moq { mux_codec_av1_Split &operator=(mux_codec_av1_Split &&other) noexcept = default; static mux_codec_av1_Split default_(); static ::moq::mux_codec_av1_Split new_(); - RUST2_FFI_CALLABLE ::moq::result<::std::vector<::moq::mux_container_Frame>, ::moq::mux_Error> decode(::moq::input data, const ::moq::Timestamp *pts); - RUST2_FFI_CALLABLE ::moq::result<::std::vector<::moq::mux_container_Frame>, ::moq::mux_Error> flush(const ::moq::Timestamp *pts); + RUST2_FFI_CALLABLE ::moq::result<::std::vector<::moq::mux_container_Frame>, ::moq::mux_Error> decode(::moq::input data, const ::std::optional<::moq::Timestamp> &pts); + RUST2_FFI_CALLABLE ::moq::result<::std::vector<::moq::mux_container_Frame>, ::moq::mux_Error> flush(const ::std::optional<::moq::Timestamp> &pts); RUST2_FFI_CALLABLE void reset(); }; class RUST2_FFI_CONSUMABLE mux_codec_flac_Import { @@ -3748,10 +3746,10 @@ namespace moq { RUST2_FFI_CONSUMES ::moq::result<::moq::mux_container_Finished_Container_AudioConfig, ::moq::mux_Error> finish() &&; RUST2_FFI_CONSUMES void abort(::moq::Error err) &&; RUST2_FFI_CONSUMES ::moq::result abort_unwanted(::moq::Error err) &&; - RUST2_FFI_CALLABLE ::moq::result cut(const ::moq::Timestamp *end); + RUST2_FFI_CALLABLE ::moq::result cut(const ::std::optional<::moq::Timestamp> &end); RUST2_FFI_CALLABLE ::moq::result discontinuity(); RUST2_FFI_CALLABLE ::moq::result seek(::std::uint64_t start); - RUST2_FFI_CALLABLE ::moq::result decode(::moq::input frame, const ::moq::Timestamp *pts); + RUST2_FFI_CALLABLE ::moq::result decode(::moq::input frame, const ::std::optional<::moq::Timestamp> &pts); }; class RUST2_FFI_CONSUMABLE mux_codec_h264_Avc1 { RUST2_FFI_UNCONSUMED mux_codec_h264_Avc1(mux_codec_h264_Avc1 &&other RUST2_FFI_MOVED_FROM) noexcept = default; @@ -3805,7 +3803,7 @@ namespace moq { RUST2_FFI_CONSUMES ::moq::result<::moq::mux_container_Finished_Container_VideoConfig, ::moq::mux_Error> finish() &&; RUST2_FFI_CONSUMES void abort(::moq::Error err) &&; RUST2_FFI_CONSUMES ::moq::result abort_unwanted(::moq::Error err) &&; - RUST2_FFI_CALLABLE ::moq::result cut(const ::moq::Timestamp *end); + RUST2_FFI_CALLABLE ::moq::result cut(const ::std::optional<::moq::Timestamp> &end); RUST2_FFI_CALLABLE ::moq::result discontinuity(); RUST2_FFI_CALLABLE ::moq::result set_enabled(bool enabled); RUST2_FFI_CALLABLE void report_skipped(::std::uint64_t frames) const; @@ -3819,8 +3817,8 @@ namespace moq { mux_codec_h264_Split &operator=(mux_codec_h264_Split &&other) noexcept = default; static mux_codec_h264_Split default_(); static ::moq::mux_codec_h264_Split new_(); - RUST2_FFI_CALLABLE ::moq::result<::std::vector<::moq::mux_container_Frame>, ::moq::mux_Error> decode(::moq::input data, const ::moq::Timestamp *pts); - RUST2_FFI_CALLABLE ::moq::result<::std::vector<::moq::mux_container_Frame>, ::moq::mux_Error> flush(const ::moq::Timestamp *pts); + RUST2_FFI_CALLABLE ::moq::result<::std::vector<::moq::mux_container_Frame>, ::moq::mux_Error> decode(::moq::input data, const ::std::optional<::moq::Timestamp> &pts); + RUST2_FFI_CALLABLE ::moq::result<::std::vector<::moq::mux_container_Frame>, ::moq::mux_Error> flush(const ::std::optional<::moq::Timestamp> &pts); RUST2_FFI_CALLABLE void reset(); }; class RUST2_FFI_CONSUMABLE mux_codec_h265_Hvc1 { @@ -3877,7 +3875,7 @@ namespace moq { RUST2_FFI_CONSUMES ::moq::result<::moq::mux_container_Finished_Container_VideoConfig, ::moq::mux_Error> finish() &&; RUST2_FFI_CONSUMES void abort(::moq::Error err) &&; RUST2_FFI_CONSUMES ::moq::result abort_unwanted(::moq::Error err) &&; - RUST2_FFI_CALLABLE ::moq::result cut(const ::moq::Timestamp *end); + RUST2_FFI_CALLABLE ::moq::result cut(const ::std::optional<::moq::Timestamp> &end); RUST2_FFI_CALLABLE ::moq::result discontinuity(); RUST2_FFI_CALLABLE ::moq::result set_enabled(bool enabled); RUST2_FFI_CALLABLE void report_skipped(::std::uint64_t frames) const; @@ -3891,8 +3889,8 @@ namespace moq { mux_codec_h265_Split &operator=(mux_codec_h265_Split &&other) noexcept = default; static mux_codec_h265_Split default_(); static ::moq::mux_codec_h265_Split new_(); - RUST2_FFI_CALLABLE ::moq::result<::std::vector<::moq::mux_container_Frame>, ::moq::mux_Error> decode(::moq::input data, const ::moq::Timestamp *pts); - RUST2_FFI_CALLABLE ::moq::result<::std::vector<::moq::mux_container_Frame>, ::moq::mux_Error> flush(const ::moq::Timestamp *pts); + RUST2_FFI_CALLABLE ::moq::result<::std::vector<::moq::mux_container_Frame>, ::moq::mux_Error> decode(::moq::input data, const ::std::optional<::moq::Timestamp> &pts); + RUST2_FFI_CALLABLE ::moq::result<::std::vector<::moq::mux_container_Frame>, ::moq::mux_Error> flush(const ::std::optional<::moq::Timestamp> &pts); RUST2_FFI_CALLABLE void reset(); }; class RUST2_FFI_CONSUMABLE mux_codec_mp3_Import { @@ -3905,10 +3903,10 @@ namespace moq { RUST2_FFI_CONSUMES ::moq::result<::moq::mux_container_Finished_Container_AudioConfig, ::moq::mux_Error> finish() &&; RUST2_FFI_CONSUMES void abort(::moq::Error err) &&; RUST2_FFI_CONSUMES ::moq::result abort_unwanted(::moq::Error err) &&; - RUST2_FFI_CALLABLE ::moq::result cut(const ::moq::Timestamp *end); + RUST2_FFI_CALLABLE ::moq::result cut(const ::std::optional<::moq::Timestamp> &end); RUST2_FFI_CALLABLE ::moq::result discontinuity(); RUST2_FFI_CALLABLE ::moq::result seek(::std::uint64_t start); - RUST2_FFI_CALLABLE ::moq::result decode(::moq::input frame, const ::moq::Timestamp *pts); + RUST2_FFI_CALLABLE ::moq::result decode(::moq::input frame, const ::std::optional<::moq::Timestamp> &pts); }; class RUST2_FFI_CONSUMABLE mux_codec_opus_Config { RUST2_FFI_UNCONSUMED mux_codec_opus_Config(mux_codec_opus_Config &&other RUST2_FFI_MOVED_FROM) noexcept = default; @@ -3943,10 +3941,10 @@ namespace moq { RUST2_FFI_CONSUMES ::moq::result<::moq::mux_container_Finished_Container_AudioConfig, ::moq::mux_Error> finish() &&; RUST2_FFI_CONSUMES void abort(::moq::Error err) &&; RUST2_FFI_CONSUMES ::moq::result abort_unwanted(::moq::Error err) &&; - RUST2_FFI_CALLABLE ::moq::result cut(const ::moq::Timestamp *end); + RUST2_FFI_CALLABLE ::moq::result cut(const ::std::optional<::moq::Timestamp> &end); RUST2_FFI_CALLABLE ::moq::result discontinuity(); RUST2_FFI_CALLABLE ::moq::result seek(::std::uint64_t start); - RUST2_FFI_CALLABLE ::moq::result decode(::moq::input frame, const ::moq::Timestamp *pts); + RUST2_FFI_CALLABLE ::moq::result decode(::moq::input frame, const ::std::optional<::moq::Timestamp> &pts); }; class RUST2_FFI_CONSUMABLE mux_codec_vp8_Import { RUST2_FFI_UNCONSUMED mux_codec_vp8_Import(mux_codec_vp8_Import &&other RUST2_FFI_MOVED_FROM) noexcept = default; @@ -3955,12 +3953,12 @@ namespace moq { static ::moq::result<::moq::mux_codec_vp8_Import, ::moq::mux_Error> new_Ext(::moq::track_Producer track, ::moq::mux_catalog_Reserved_Ext reserved, ::moq::mux_catalog_VideoHint hint); static ::moq::result<::moq::mux_codec_vp8_Import, ::moq::mux_Error> new_unit(::moq::track_Producer track, ::moq::mux_catalog_Reserved reserved, ::moq::mux_catalog_VideoHint hint); RUST2_FFI_CALLABLE ::moq::result initialize(::moq::input buf_); - RUST2_FFI_CALLABLE ::moq::result decode(::moq::input frame, const ::moq::Timestamp *pts); + RUST2_FFI_CALLABLE ::moq::result decode(::moq::input frame, const ::std::optional<::moq::Timestamp> &pts); RUST2_FFI_CALLABLE ::moq::track_Demand demand() const; RUST2_FFI_CONSUMES ::moq::result<::moq::mux_container_Finished_Container_VideoConfig, ::moq::mux_Error> finish() &&; RUST2_FFI_CONSUMES void abort(::moq::Error err) &&; RUST2_FFI_CONSUMES ::moq::result abort_unwanted(::moq::Error err) &&; - RUST2_FFI_CALLABLE ::moq::result cut(const ::moq::Timestamp *end); + RUST2_FFI_CALLABLE ::moq::result cut(const ::std::optional<::moq::Timestamp> &end); RUST2_FFI_CALLABLE ::moq::result discontinuity(); RUST2_FFI_CALLABLE ::moq::result set_enabled(bool enabled); RUST2_FFI_CALLABLE ::moq::result seek(::std::uint64_t start); @@ -3972,12 +3970,12 @@ namespace moq { static ::moq::result<::moq::mux_codec_vp9_Import, ::moq::mux_Error> new_Ext(::moq::track_Producer track, ::moq::mux_catalog_Reserved_Ext reserved, ::moq::mux_catalog_VideoHint hint); static ::moq::result<::moq::mux_codec_vp9_Import, ::moq::mux_Error> new_unit(::moq::track_Producer track, ::moq::mux_catalog_Reserved reserved, ::moq::mux_catalog_VideoHint hint); RUST2_FFI_CALLABLE ::moq::result initialize(::moq::input buf_); - RUST2_FFI_CALLABLE ::moq::result decode(::moq::input frame, const ::moq::Timestamp *pts); + RUST2_FFI_CALLABLE ::moq::result decode(::moq::input frame, const ::std::optional<::moq::Timestamp> &pts); RUST2_FFI_CALLABLE ::moq::track_Demand demand() const; RUST2_FFI_CONSUMES ::moq::result<::moq::mux_container_Finished_Container_VideoConfig, ::moq::mux_Error> finish() &&; RUST2_FFI_CONSUMES void abort(::moq::Error err) &&; RUST2_FFI_CONSUMES ::moq::result abort_unwanted(::moq::Error err) &&; - RUST2_FFI_CALLABLE ::moq::result cut(const ::moq::Timestamp *end); + RUST2_FFI_CALLABLE ::moq::result cut(const ::std::optional<::moq::Timestamp> &end); RUST2_FFI_CALLABLE ::moq::result discontinuity(); RUST2_FFI_CALLABLE ::moq::result set_enabled(bool enabled); RUST2_FFI_CALLABLE ::moq::result seek(::std::uint64_t start); @@ -4107,7 +4105,7 @@ namespace moq { RUST2_FFI_CALLABLE ::moq::mux_container_fmp4_Muxer_read_future read(::moq::group_Consumer &group); RUST2_FFI_CALLABLE ::moq::result<::std::optional<::std::tuple<::std::uint32_t, ::std::uint32_t>>, ::moq::mux_Error> picture_size(const ::moq::mux_container_Frame &keyframe); RUST2_FFI_CALLABLE ::moq::result<::std::optional<::moq::buf>, ::moq::mux_Error> init() const; - RUST2_FFI_CALLABLE ::moq::result<::moq::buf, ::moq::mux_Error> fragment(::std::uint32_t sequence, const ::std::vector<::moq::mux_container_Frame> &frames, const ::moq::Timestamp *end) const; + RUST2_FFI_CALLABLE ::moq::result<::moq::buf, ::moq::mux_Error> fragment(::std::uint32_t sequence, const ::std::vector<::moq::mux_container_Frame> &frames, const ::std::optional<::moq::Timestamp> &end) const; }; class RUST2_FFI_CONSUMABLE mux_container_legacy_Audio { RUST2_FFI_UNCONSUMED mux_container_legacy_Audio(mux_container_legacy_Audio &&other RUST2_FFI_MOVED_FROM) noexcept = default; @@ -5309,35 +5307,6 @@ namespace moq { static ::moq::Error from_transport_memory_Error(const ::moq::transport_memory_Error &err); RUST2_FFI_CALLABLE ::moq::Retry retry() const; }; - class RUST2_FFI_CONSUMABLE Timestamp { - RUST2_FFI_UNCONSUMED Timestamp(Timestamp &&other RUST2_FFI_MOVED_FROM) noexcept = default; - Timestamp &operator=(Timestamp &&other) noexcept = default; - RUST2_FFI_UNCONSUMED Timestamp(const Timestamp &other) = default; - Timestamp &operator=(const Timestamp &other) = default; - friend bool operator==(const Timestamp &a, const Timestamp &b); - friend bool operator!=(const Timestamp &a, const Timestamp &b); - RUST2_FFI_CALLABLE ::std::uint64_t hash() const; - RUST2_FFI_CALLABLE ::moq::buf debug() const; - static ::moq::Timestamp ZERO(); - static ::moq::result<::moq::Timestamp, ::moq::TimeOverflow> new_(::std::uint64_t value, const ::moq::Timescale &scale); - static ::moq::Timestamp unscaled(::std::uint64_t key); - static ::moq::result<::moq::Timestamp, ::moq::TimeOverflow> from_scale(::std::uint64_t value, ::std::uint64_t units_per_second); - static ::moq::result<::moq::Timestamp, ::moq::TimeOverflow> from_secs(::std::uint64_t seconds); - static ::moq::result<::moq::Timestamp, ::moq::TimeOverflow> from_millis(::std::uint64_t millis); - static ::moq::result<::moq::Timestamp, ::moq::TimeOverflow> from_micros(::std::uint64_t micros); - static ::moq::result<::moq::Timestamp, ::moq::TimeOverflow> from_nanos(::std::uint64_t nanos); - RUST2_FFI_CALLABLE ::std::uint64_t value() const; - RUST2_FFI_CALLABLE ::std::optional<::moq::Timescale> scale() const; - RUST2_FFI_CALLABLE bool is_zero() const; - RUST2_FFI_CALLABLE ::moq::result<::moq::Timestamp, ::moq::TimeOverflow> convert(const ::moq::Timescale &new_scale) const; - RUST2_FFI_CALLABLE ::moq::result<::moq::u128, ::moq::TimeOverflow> as_scale(const ::moq::Timescale &target) const; - RUST2_FFI_CALLABLE ::moq::result<::std::uint64_t, ::moq::TimeOverflow> as_secs() const; - RUST2_FFI_CALLABLE ::moq::result<::moq::u128, ::moq::TimeOverflow> as_millis() const; - RUST2_FFI_CALLABLE ::moq::result<::moq::u128, ::moq::TimeOverflow> as_micros() const; - RUST2_FFI_CALLABLE ::moq::result<::moq::u128, ::moq::TimeOverflow> as_nanos() const; - RUST2_FFI_CALLABLE ::moq::result<::moq::Timestamp, ::moq::TimeOverflow> checked_add(const ::moq::Timestamp &rhs) const; - RUST2_FFI_CALLABLE ::moq::result<::moq::Timestamp, ::moq::TimeOverflow> checked_sub(const ::moq::Timestamp &rhs) const; - }; class RUST2_FFI_CONSUMABLE Version { RUST2_FFI_UNCONSUMED Version(Version &&other RUST2_FFI_MOVED_FROM) noexcept = default; Version &operator=(Version &&other) noexcept = default; @@ -5780,30 +5749,6 @@ namespace moq { RUST2_FFI_CALLABLE ::moq::bandwidth_Rate target() const; RUST2_FFI_CALLABLE void set_target(const ::moq::bandwidth_Rate &rate) const; }; - class RUST2_FFI_CONSUMABLE transport_ReceiveWindow { - RUST2_FFI_UNCONSUMED transport_ReceiveWindow(transport_ReceiveWindow &&other RUST2_FFI_MOVED_FROM) noexcept = default; - transport_ReceiveWindow &operator=(transport_ReceiveWindow &&other) noexcept = default; - RUST2_FFI_CALLABLE transport_ReceiveWindow clone() const; - friend bool operator==(const transport_ReceiveWindow &a, const transport_ReceiveWindow &b); - friend bool operator!=(const transport_ReceiveWindow &a, const transport_ReceiveWindow &b); - RUST2_FFI_CALLABLE ::moq::buf debug() const; - RUST2_FFI_CALLABLE ::std::optional<::std::uint64_t> connection_get() const; - RUST2_FFI_CALLABLE void connection_set(const ::std::optional<::std::uint64_t> &value); - RUST2_FFI_CALLABLE ::std::uint64_t stream_get() const; - RUST2_FFI_CALLABLE void stream_set(::std::uint64_t value); - static ::moq::transport_ReceiveWindow new_(const ::std::optional<::std::uint64_t> &connection, ::std::uint64_t stream); - }; - class RUST2_FFI_CONSUMABLE transport_Limits { - RUST2_FFI_UNCONSUMED transport_Limits(transport_Limits &&other RUST2_FFI_MOVED_FROM) noexcept = default; - transport_Limits &operator=(transport_Limits &&other) noexcept = default; - RUST2_FFI_CALLABLE transport_Limits clone() const; - friend bool operator==(const transport_Limits &a, const transport_Limits &b); - friend bool operator!=(const transport_Limits &a, const transport_Limits &b); - RUST2_FFI_CALLABLE ::moq::buf debug() const; - static transport_Limits default_(); - RUST2_FFI_CALLABLE ::std::optional<::std::uint64_t> receive_window_get() const; - RUST2_FFI_CALLABLE void receive_window_set(const ::std::optional<::std::uint64_t> &value); - }; class RUST2_FFI_CONSUMABLE bandwidth_Limit { RUST2_FFI_UNCONSUMED bandwidth_Limit(bandwidth_Limit &&other RUST2_FFI_MOVED_FROM) noexcept = default; bandwidth_Limit &operator=(bandwidth_Limit &&other) noexcept = default; @@ -6610,6 +6555,30 @@ namespace moq { static ::moq::result<::moq::Timescale, ::moq::TimeOverflow> new_(::std::uint64_t units_per_second); ::std::uint64_t as_u64() const; }; + class Timestamp { + friend bool operator==(const Timestamp &a, const Timestamp &b); + friend bool operator!=(const Timestamp &a, const Timestamp &b); + ::moq::buf debug() const; + static ::moq::Timestamp ZERO(); + static ::moq::result<::moq::Timestamp, ::moq::TimeOverflow> new_(::std::uint64_t value, const ::moq::Timescale &scale); + static ::moq::Timestamp unscaled(::std::uint64_t key); + static ::moq::result<::moq::Timestamp, ::moq::TimeOverflow> from_scale(::std::uint64_t value, ::std::uint64_t units_per_second); + static ::moq::result<::moq::Timestamp, ::moq::TimeOverflow> from_secs(::std::uint64_t seconds); + static ::moq::result<::moq::Timestamp, ::moq::TimeOverflow> from_millis(::std::uint64_t millis); + static ::moq::result<::moq::Timestamp, ::moq::TimeOverflow> from_micros(::std::uint64_t micros); + static ::moq::result<::moq::Timestamp, ::moq::TimeOverflow> from_nanos(::std::uint64_t nanos); + ::std::uint64_t value() const; + ::std::optional<::moq::Timescale> scale() const; + bool is_zero() const; + ::moq::result<::moq::Timestamp, ::moq::TimeOverflow> convert(const ::moq::Timescale &new_scale) const; + ::moq::result<::moq::u128, ::moq::TimeOverflow> as_scale(const ::moq::Timescale &target) const; + ::moq::result<::std::uint64_t, ::moq::TimeOverflow> as_secs() const; + ::moq::result<::moq::u128, ::moq::TimeOverflow> as_millis() const; + ::moq::result<::moq::u128, ::moq::TimeOverflow> as_micros() const; + ::moq::result<::moq::u128, ::moq::TimeOverflow> as_nanos() const; + ::moq::result<::moq::Timestamp, ::moq::TimeOverflow> checked_add(const ::moq::Timestamp &rhs) const; + ::moq::result<::moq::Timestamp, ::moq::TimeOverflow> checked_sub(const ::moq::Timestamp &rhs) const; + }; struct setup_Token { ::std::uint64_t kind; ::moq::buf value; @@ -6845,6 +6814,24 @@ namespace moq { void add(const ::moq::stats_Withdrawals &other); bool regressed(const ::moq::stats_Withdrawals &previous) const; }; + class transport_ReceiveWindow { + friend bool operator==(const transport_ReceiveWindow &a, const transport_ReceiveWindow &b); + friend bool operator!=(const transport_ReceiveWindow &a, const transport_ReceiveWindow &b); + ::moq::buf debug() const; + ::std::optional<::std::uint64_t> connection_get() const; + void connection_set(const ::std::optional<::std::uint64_t> &value); + ::std::uint64_t stream_get() const; + void stream_set(::std::uint64_t value); + static ::moq::transport_ReceiveWindow new_(const ::std::optional<::std::uint64_t> &connection, ::std::uint64_t stream); + }; + class transport_Limits { + friend bool operator==(const transport_Limits &a, const transport_Limits &b); + friend bool operator!=(const transport_Limits &a, const transport_Limits &b); + ::moq::buf debug() const; + static transport_Limits default_(); + ::std::optional<::std::uint64_t> receive_window_get() const; + void receive_window_set(const ::std::optional<::std::uint64_t> &value); + }; class bandwidth_Rate { friend bool operator==(const bandwidth_Rate &a, const bandwidth_Rate &b); friend bool operator!=(const bandwidth_Rate &a, const bandwidth_Rate &b); @@ -7020,6 +7007,7 @@ namespace moq { }; inline bool operator==(const TimeOverflow &a, const TimeOverflow &b); inline bool operator==(const Timescale &a, const Timescale &b); + inline bool operator==(const Timestamp &a, const Timestamp &b); inline bool operator==(const setup_Token &a, const setup_Token &b); inline bool operator==(const session_Limits &a, const session_Limits &b); inline bool operator==(const stats_Content &a, const stats_Content &b); @@ -7033,6 +7021,8 @@ namespace moq { inline bool operator==(const stats_RouteRefusals &a, const stats_RouteRefusals &b); inline bool operator==(const stats_Routes &a, const stats_Routes &b); inline bool operator==(const stats_Withdrawals &a, const stats_Withdrawals &b); + inline bool operator==(const transport_ReceiveWindow &a, const transport_ReceiveWindow &b); + inline bool operator==(const transport_Limits &a, const transport_Limits &b); inline bool operator==(const bandwidth_Rate &a, const bandwidth_Rate &b); inline bool operator==(const datagram_Datagram &a, const datagram_Datagram &b); inline bool operator==(const group_Info &a, const group_Info &b); @@ -7172,11 +7162,6 @@ namespace std { size_t operator()(const ::moq::Path &value) const noexcept; }; } -namespace std { - template <> struct hash<::moq::Timestamp> { - size_t operator()(const ::moq::Timestamp &value) const noexcept; - }; -} namespace std { template <> struct hash<::moq::Version> { size_t operator()(const ::moq::Version &value) const noexcept; @@ -7623,6 +7608,7 @@ namespace moq { enum class Level; class TimeOverflow; class Timescale; + class Timestamp; class clock_Instant; class clock_Elapsed; class clock_Wall; @@ -7639,6 +7625,8 @@ namespace moq { class stats_RouteRefusals; class stats_Routes; class stats_Withdrawals; + class transport_ReceiveWindow; + class transport_Limits; class bandwidth_Rate; struct datagram_Datagram; struct frame_Info; @@ -7649,6 +7637,7 @@ namespace moq { class origin_Cost; class origin_Priority; struct hang_catalog_AAC; + class hang_catalog_Clock; class hang_catalog_Priorities; struct hang_catalog_AV1; struct hang_catalog_Mastering; @@ -7686,7 +7675,6 @@ namespace moq { class Session; class Client; class Error; - class Timestamp; class Version; class Versions; class Specificity; @@ -7751,8 +7739,6 @@ namespace moq { class stats_Bill; class transport_Wire; class transport_Probe; - class transport_ReceiveWindow; - class transport_Limits; class bandwidth_Limit; class bandwidth_Demand; class bandwidth_Reservation; @@ -7829,7 +7815,6 @@ namespace moq { class hang_catalog_AudioConfig; class hang_catalog_Binary; class hang_catalog_BinaryConfig; - class hang_catalog_Clock; class hang_catalog_Container; class hang_catalog_Echo; class hang_catalog_Include; diff --git a/ffi/surface/moq/dart.dart b/ffi/surface/moq/dart.dart index 911580ecd..0877483b2 100644 --- a/ffi/surface/moq/dart.dart +++ b/ffi/surface/moq/dart.dart @@ -191,6 +191,30 @@ final class Timescale { factory Timescale(U64 unitsPerSecond); U64 asU64(); } +final class Timestamp { + String debug(); + @override bool operator ==(Object other); + @override int get hashCode; + static Timestamp get ZERO; + factory Timestamp(U64 value, Timescale scale); + factory Timestamp.unscaled(U64 key); + factory Timestamp.fromScale(U64 value, U64 unitsPerSecond); + factory Timestamp.fromSecs(U64 seconds); + factory Timestamp.fromMillis(U64 millis); + factory Timestamp.fromMicros(U64 micros); + factory Timestamp.fromNanos(U64 nanos); + U64 value(); + Timescale? scale(); + bool isZero(); + Timestamp convert(Timescale newScale); + BigInt asScale(Timescale target); + U64 asSecs(); + BigInt asMillis(); + BigInt asMicros(); + BigInt asNanos(); + Timestamp checkedAdd(Timestamp rhs); + Timestamp checkedSub(Timestamp rhs); +} final class ClockInstant { String debug(); @override bool operator ==(Object other); @@ -463,6 +487,24 @@ final class StatsWithdrawals { StatsWithdrawals add(StatsWithdrawals other); bool regressed(StatsWithdrawals previous); } +final class TransportReceiveWindow { + String debug(); + @override bool operator ==(Object other); + @override int get hashCode; + U64? get connectionGet; + TransportReceiveWindow connectionSet(U64? value); + U64 get streamGet; + TransportReceiveWindow streamSet(U64 value); + factory TransportReceiveWindow(U64? connection, U64 stream); +} +final class TransportLimits { + String debug(); + @override bool operator ==(Object other); + @override int get hashCode; + factory TransportLimits.default_(); + U64? get receiveWindowGet; + TransportLimits receiveWindowSet(U64? value); +} final class BandwidthRate { String debug(); @override bool operator ==(Object other); @@ -555,6 +597,15 @@ final class HangCatalogAac { @override bool operator ==(Object other); @override int get hashCode; } +final class HangCatalogClock { + String debug(); + @override bool operator ==(Object other); + @override int get hashCode; + Timestamp get wallGet; + HangCatalogClock wallSet(Timestamp value); + factory HangCatalogClock(Timestamp wall); + ClockWall wallClock(Timestamp pts); +} final class HangCatalogPriorities { String debug(); @override bool operator ==(Object other); @@ -2170,31 +2221,6 @@ final class Error extends _Object implements Exception { factory Error.fromTransportMemoryError(TransportMemoryError err); Retry retry(); } -final class Timestamp extends _Object { - String debug(); - Timestamp clone(); - @override bool operator ==(Object other); - @override int get hashCode; - static Timestamp get ZERO; - factory Timestamp(U64 value, Timescale scale); - factory Timestamp.unscaled(U64 key); - factory Timestamp.fromScale(U64 value, U64 unitsPerSecond); - factory Timestamp.fromSecs(U64 seconds); - factory Timestamp.fromMillis(U64 millis); - factory Timestamp.fromMicros(U64 micros); - factory Timestamp.fromNanos(U64 nanos); - U64 value(); - Timescale? scale(); - bool isZero(); - Timestamp convert(Timescale newScale); - BigInt asScale(Timescale target); - U64 asSecs(); - BigInt asMillis(); - BigInt asMicros(); - BigInt asNanos(); - Timestamp checkedAdd(Timestamp rhs); - Timestamp checkedSub(Timestamp rhs); -} final class Version extends _Object { @override String toString(); String debug(); @@ -2887,26 +2913,6 @@ final class TransportProbe extends _Object { BandwidthRate target(); void setTarget(BandwidthRate rate); } -final class TransportReceiveWindow extends _Object { - String debug(); - TransportReceiveWindow clone(); - @override bool operator ==(Object other); - @override int get hashCode; - U64? get connectionGet; - void connectionSet(U64? value); - U64 get streamGet; - void streamSet(U64 value); - factory TransportReceiveWindow(U64? connection, U64 stream); -} -final class TransportLimits extends _Object { - String debug(); - TransportLimits clone(); - @override bool operator ==(Object other); - @override int get hashCode; - factory TransportLimits.default_(); - U64? get receiveWindowGet; - void receiveWindowSet(U64? value); -} final class BandwidthLimit extends _Object { String debug(); BandwidthLimit clone(); @@ -3729,16 +3735,6 @@ final class HangCatalogBinaryConfig extends _Object { void extraSet(List<(String, Json)> value); factory HangCatalogBinaryConfig(HangCatalogMode mode); } -final class HangCatalogClock extends _Object { - String debug(); - HangCatalogClock clone(); - @override bool operator ==(Object other); - @override int get hashCode; - Timestamp get wallGet; - void wallSet(Timestamp value); - factory HangCatalogClock(Timestamp wall); - ClockWall wallClock(Timestamp pts); -} final class HangCatalogContainer extends _Object { String debug(); HangCatalogContainer clone(); diff --git a/ffi/surface/moq/go.txt b/ffi/surface/moq/go.txt index 24b635f79..7b9124614 100644 --- a/ffi/surface/moq/go.txt +++ b/ffi/surface/moq/go.txt @@ -266,16 +266,15 @@ type CatalogChromaticity struct { func (self CatalogChromaticity) Equal(other CatalogChromaticity) bool func (self CatalogChromaticity) GoString() string type CatalogClock struct { - Handle_ *p_rt.Handle_ + Bytes_ [2]uint64 + Made_ bool } -func NewCatalogClock(wall *p_net.Timestamp) (*CatalogClock, error) -func (self *CatalogClock) Clone() (*CatalogClock, error) -func (self *CatalogClock) Close() error -func (self *CatalogClock) Equal(other *CatalogClock) (bool, error) -func (self *CatalogClock) GoString() string -func (self *CatalogClock) WallClock(pts *p_net.Timestamp) (p_kio.ClockWall, error) -func (self *CatalogClock) WallGet() (*p_net.Timestamp, error) -func (self *CatalogClock) WallSet(value *p_net.Timestamp) error +func NewCatalogClock(wall p_net.Timestamp) (CatalogClock, error) +func (self CatalogClock) Equal(other CatalogClock) bool +func (self CatalogClock) GoString() string +func (self CatalogClock) WallClock(pts p_net.Timestamp) (p_kio.ClockWall, error) +func (self CatalogClock) WallGet() p_net.Timestamp +func (self *CatalogClock) WallSet(value p_net.Timestamp) type CatalogColor struct { Handle_ *p_rt.Handle_ } @@ -790,7 +789,7 @@ func (self CatalogVp9) Equal(other CatalogVp9) bool func (self CatalogVp9) GoString() string func (self CatalogVp9) String() string type ContainerFrame struct { - Timestamp *p_net.Timestamp + Timestamp p_net.Timestamp Payload p_rt.Bytes } func ContainerFrameDecode(buf p_rt.Bytes) (ContainerFrame, error) @@ -800,13 +799,13 @@ func (self ContainerFrame) WriteTo(group *p_net.GroupProducer) error type EchoArrival struct { Handle_ *p_rt.Handle_ } -func NewEchoArrival(timestamp *p_net.Timestamp, wall p_kio.ClockWall) (*EchoArrival, error) +func NewEchoArrival(timestamp p_net.Timestamp, wall p_kio.ClockWall) *EchoArrival func (self *EchoArrival) Clone() (*EchoArrival, error) func (self *EchoArrival) Close() error func (self *EchoArrival) Equal(other *EchoArrival) (bool, error) func (self *EchoArrival) GoString() string -func (self *EchoArrival) TimestampGet() (*p_net.Timestamp, error) -func (self *EchoArrival) TimestampSet(value *p_net.Timestamp) error +func (self *EchoArrival) TimestampGet() (p_net.Timestamp, error) +func (self *EchoArrival) TimestampSet(value p_net.Timestamp) error func (self *EchoArrival) WallGet() (p_kio.ClockWall, error) func (self *EchoArrival) WallSet(value p_kio.ClockWall) error type EchoRendition struct { @@ -858,9 +857,9 @@ func (self *Error) String() string type MoqJsonTimedCatalog struct { Handle_ *p_rt.Handle_ } -func NewMoqJsonTimedCatalog(value *Catalog, at *p_net.Timestamp) (*MoqJsonTimedCatalog, error) -func (self *MoqJsonTimedCatalog) AtGet() (*p_net.Timestamp, error) -func (self *MoqJsonTimedCatalog) AtSet(value *p_net.Timestamp) error +func NewMoqJsonTimedCatalog(value *Catalog, at p_net.Timestamp) (*MoqJsonTimedCatalog, error) +func (self *MoqJsonTimedCatalog) AtGet() (p_net.Timestamp, error) +func (self *MoqJsonTimedCatalog) AtSet(value p_net.Timestamp) error func (self *MoqJsonTimedCatalog) Clone() (*MoqJsonTimedCatalog, error) func (self *MoqJsonTimedCatalog) Close() error func (self *MoqJsonTimedCatalog) Equal(other *MoqJsonTimedCatalog) (bool, error) @@ -922,9 +921,9 @@ TYPES type TimedJson struct { Handle_ *p_rt.Handle_ } -func NewTimedJson(value *p_serdejson.Json, at *p_net.Timestamp) (*TimedJson, error) -func (self *TimedJson) AtGet() (*p_net.Timestamp, error) -func (self *TimedJson) AtSet(value *p_net.Timestamp) error +func NewTimedJson(value *p_serdejson.Json, at p_net.Timestamp) (*TimedJson, error) +func (self *TimedJson) AtGet() (p_net.Timestamp, error) +func (self *TimedJson) AtSet(value p_net.Timestamp) error func (self *TimedJson) Clone() (*TimedJson, error) func (self *TimedJson) Close() error func (self *TimedJson) Equal(other *TimedJson) (bool, error) @@ -1516,7 +1515,7 @@ func (self *CatalogProducer) TextFmp4Wire(track *p_net.TrackProducer, container func (self *CatalogProducer) TextLegacyWire(track *p_net.TrackProducer, container ContainerLegacyWire, config *p_hang.CatalogTextConfig) (*ContainerProducerLegacyWireTextConfig, error) func (self *CatalogProducer) TextLocWire(track *p_net.TrackProducer, container ContainerLocWire, config *p_hang.CatalogTextConfig) (*ContainerProducerLocWireTextConfig, error) func (self *CatalogProducer) Timebase() (*CatalogTimebase, error) -func (self *CatalogProducer) Timestamp(hint *p_net.Timestamp) (*p_net.Timestamp, error) +func (self *CatalogProducer) Timestamp(hint *p_net.Timestamp) (p_net.Timestamp, error) func (self *CatalogProducer) TrackContainerAudioConfig(track *p_net.TrackProducer, container *CatalogHangContainer, config *p_hang.CatalogAudioConfig) (*ContainerProducerContainerAudioConfig, error) func (self *CatalogProducer) TrackContainerBinaryConfig(track *p_net.TrackProducer, container *CatalogHangContainer, config *p_hang.CatalogBinaryConfig) (*ContainerProducerContainerBinaryConfig, error) func (self *CatalogProducer) TrackContainerJsonConfig(track *p_net.TrackProducer, container *CatalogHangContainer, config *p_hang.CatalogJsonConfig) (*ContainerProducerContainerJsonConfig, error) @@ -1575,7 +1574,7 @@ func (self *CatalogProducerExt) TextFmp4Wire(track *p_net.TrackProducer, contain func (self *CatalogProducerExt) TextLegacyWire(track *p_net.TrackProducer, container ContainerLegacyWire, config *p_hang.CatalogTextConfig) (*ContainerProducerLegacyWireTextConfig, error) func (self *CatalogProducerExt) TextLocWire(track *p_net.TrackProducer, container ContainerLocWire, config *p_hang.CatalogTextConfig) (*ContainerProducerLocWireTextConfig, error) func (self *CatalogProducerExt) Timebase() (*CatalogTimebaseExt, error) -func (self *CatalogProducerExt) Timestamp(hint *p_net.Timestamp) (*p_net.Timestamp, error) +func (self *CatalogProducerExt) Timestamp(hint *p_net.Timestamp) (p_net.Timestamp, error) func (self *CatalogProducerExt) TrackContainerAudioConfig(track *p_net.TrackProducer, container *CatalogHangContainer, config *p_hang.CatalogAudioConfig) (*ContainerProducerContainerAudioConfig, error) func (self *CatalogProducerExt) TrackContainerBinaryConfig(track *p_net.TrackProducer, container *CatalogHangContainer, config *p_hang.CatalogBinaryConfig) (*ContainerProducerContainerBinaryConfig, error) func (self *CatalogProducerExt) TrackContainerJsonConfig(track *p_net.TrackProducer, container *CatalogHangContainer, config *p_hang.CatalogJsonConfig) (*ContainerProducerContainerJsonConfig, error) @@ -1634,7 +1633,7 @@ func (self *CatalogProducerExtra) TextFmp4Wire(track *p_net.TrackProducer, conta func (self *CatalogProducerExtra) TextLegacyWire(track *p_net.TrackProducer, container ContainerLegacyWire, config *p_hang.CatalogTextConfig) (*ContainerProducerLegacyWireTextConfig, error) func (self *CatalogProducerExtra) TextLocWire(track *p_net.TrackProducer, container ContainerLocWire, config *p_hang.CatalogTextConfig) (*ContainerProducerLocWireTextConfig, error) func (self *CatalogProducerExtra) Timebase() (*CatalogTimebaseExtra, error) -func (self *CatalogProducerExtra) Timestamp(hint *p_net.Timestamp) (*p_net.Timestamp, error) +func (self *CatalogProducerExtra) Timestamp(hint *p_net.Timestamp) (p_net.Timestamp, error) func (self *CatalogProducerExtra) TrackContainerAudioConfig(track *p_net.TrackProducer, container *CatalogHangContainer, config *p_hang.CatalogAudioConfig) (*ContainerProducerContainerAudioConfig, error) func (self *CatalogProducerExtra) TrackContainerBinaryConfig(track *p_net.TrackProducer, container *CatalogHangContainer, config *p_hang.CatalogBinaryConfig) (*ContainerProducerContainerBinaryConfig, error) func (self *CatalogProducerExtra) TrackContainerJsonConfig(track *p_net.TrackProducer, container *CatalogHangContainer, config *p_hang.CatalogJsonConfig) (*ContainerProducerContainerJsonConfig, error) @@ -1673,7 +1672,7 @@ func (self *CatalogReserved) TextContainer(track *p_net.TrackProducer, container func (self *CatalogReserved) TextFmp4Wire(track *p_net.TrackProducer, container *ContainerFmp4Wire, config *p_hang.CatalogTextConfig) (*ContainerProducerFmp4WireTextConfig, error) func (self *CatalogReserved) TextLegacyWire(track *p_net.TrackProducer, container ContainerLegacyWire, config *p_hang.CatalogTextConfig) (*ContainerProducerLegacyWireTextConfig, error) func (self *CatalogReserved) TextLocWire(track *p_net.TrackProducer, container ContainerLocWire, config *p_hang.CatalogTextConfig) (*ContainerProducerLocWireTextConfig, error) -func (self *CatalogReserved) Timestamp(hint *p_net.Timestamp) (*p_net.Timestamp, error) +func (self *CatalogReserved) Timestamp(hint *p_net.Timestamp) (p_net.Timestamp, error) func (self *CatalogReserved) TrackContainerAudioConfig(track *p_net.TrackProducer, container *CatalogHangContainer, config *p_hang.CatalogAudioConfig) (*ContainerProducerContainerAudioConfig, error) func (self *CatalogReserved) TrackContainerBinaryConfig(track *p_net.TrackProducer, container *CatalogHangContainer, config *p_hang.CatalogBinaryConfig) (*ContainerProducerContainerBinaryConfig, error) func (self *CatalogReserved) TrackContainerJsonConfig(track *p_net.TrackProducer, container *CatalogHangContainer, config *p_hang.CatalogJsonConfig) (*ContainerProducerContainerJsonConfig, error) @@ -1713,7 +1712,7 @@ func (self *CatalogReservedExt) TextContainer(track *p_net.TrackProducer, contai func (self *CatalogReservedExt) TextFmp4Wire(track *p_net.TrackProducer, container *ContainerFmp4Wire, config *p_hang.CatalogTextConfig) (*ContainerProducerFmp4WireTextConfig, error) func (self *CatalogReservedExt) TextLegacyWire(track *p_net.TrackProducer, container ContainerLegacyWire, config *p_hang.CatalogTextConfig) (*ContainerProducerLegacyWireTextConfig, error) func (self *CatalogReservedExt) TextLocWire(track *p_net.TrackProducer, container ContainerLocWire, config *p_hang.CatalogTextConfig) (*ContainerProducerLocWireTextConfig, error) -func (self *CatalogReservedExt) Timestamp(hint *p_net.Timestamp) (*p_net.Timestamp, error) +func (self *CatalogReservedExt) Timestamp(hint *p_net.Timestamp) (p_net.Timestamp, error) func (self *CatalogReservedExt) TrackContainerAudioConfig(track *p_net.TrackProducer, container *CatalogHangContainer, config *p_hang.CatalogAudioConfig) (*ContainerProducerContainerAudioConfig, error) func (self *CatalogReservedExt) TrackContainerBinaryConfig(track *p_net.TrackProducer, container *CatalogHangContainer, config *p_hang.CatalogBinaryConfig) (*ContainerProducerContainerBinaryConfig, error) func (self *CatalogReservedExt) TrackContainerJsonConfig(track *p_net.TrackProducer, container *CatalogHangContainer, config *p_hang.CatalogJsonConfig) (*ContainerProducerContainerJsonConfig, error) @@ -1753,7 +1752,7 @@ func (self *CatalogReservedExtra) TextContainer(track *p_net.TrackProducer, cont func (self *CatalogReservedExtra) TextFmp4Wire(track *p_net.TrackProducer, container *ContainerFmp4Wire, config *p_hang.CatalogTextConfig) (*ContainerProducerFmp4WireTextConfig, error) func (self *CatalogReservedExtra) TextLegacyWire(track *p_net.TrackProducer, container ContainerLegacyWire, config *p_hang.CatalogTextConfig) (*ContainerProducerLegacyWireTextConfig, error) func (self *CatalogReservedExtra) TextLocWire(track *p_net.TrackProducer, container ContainerLocWire, config *p_hang.CatalogTextConfig) (*ContainerProducerLocWireTextConfig, error) -func (self *CatalogReservedExtra) Timestamp(hint *p_net.Timestamp) (*p_net.Timestamp, error) +func (self *CatalogReservedExtra) Timestamp(hint *p_net.Timestamp) (p_net.Timestamp, error) func (self *CatalogReservedExtra) TrackContainerAudioConfig(track *p_net.TrackProducer, container *CatalogHangContainer, config *p_hang.CatalogAudioConfig) (*ContainerProducerContainerAudioConfig, error) func (self *CatalogReservedExtra) TrackContainerBinaryConfig(track *p_net.TrackProducer, container *CatalogHangContainer, config *p_hang.CatalogBinaryConfig) (*ContainerProducerContainerBinaryConfig, error) func (self *CatalogReservedExtra) TrackContainerJsonConfig(track *p_net.TrackProducer, container *CatalogHangContainer, config *p_hang.CatalogJsonConfig) (*ContainerProducerContainerJsonConfig, error) @@ -1785,21 +1784,21 @@ type CatalogTimebase struct { } func (self *CatalogTimebase) Clone() (*CatalogTimebase, error) func (self *CatalogTimebase) Close() error -func (self *CatalogTimebase) Place(pts *p_net.Timestamp, wall p_kio.ClockWall) error +func (self *CatalogTimebase) Place(pts p_net.Timestamp, wall p_kio.ClockWall) error func (self *CatalogTimebase) Reserve() (*CatalogReserved, error) type CatalogTimebaseExt struct { Handle_ *p_rt.Handle_ } func (self *CatalogTimebaseExt) Clone() (*CatalogTimebaseExt, error) func (self *CatalogTimebaseExt) Close() error -func (self *CatalogTimebaseExt) Place(pts *p_net.Timestamp, wall p_kio.ClockWall) error +func (self *CatalogTimebaseExt) Place(pts p_net.Timestamp, wall p_kio.ClockWall) error func (self *CatalogTimebaseExt) Reserve() (*CatalogReservedExt, error) type CatalogTimebaseExtra struct { Handle_ *p_rt.Handle_ } func (self *CatalogTimebaseExtra) Clone() (*CatalogTimebaseExtra, error) func (self *CatalogTimebaseExtra) Close() error -func (self *CatalogTimebaseExtra) Place(pts *p_net.Timestamp, wall p_kio.ClockWall) error +func (self *CatalogTimebaseExtra) Place(pts p_net.Timestamp, wall p_kio.ClockWall) error func (self *CatalogTimebaseExtra) Reserve() (*CatalogReservedExtra, error) type CatalogVideoHint struct { Handle_ *p_rt.Handle_ @@ -1844,15 +1843,15 @@ type Clock struct { func ClockAt(epoch p_kio.ClockInstant, wall p_kio.ClockWall) (*Clock, error) func ClockDefault() *Clock func NewClock() *Clock -func (self *Clock) Capture(at p_kio.ClockInstant) (*p_net.Timestamp, error) +func (self *Clock) Capture(at p_kio.ClockInstant) (p_net.Timestamp, error) func (self *Clock) Clone() (*Clock, error) func (self *Clock) Close() error func (self *Clock) Equal(other *Clock) (bool, error) func (self *Clock) GoString() string -func (self *Clock) Now() (*p_net.Timestamp, error) +func (self *Clock) Now() (p_net.Timestamp, error) func (self *Clock) Timescale() (p_net.Timescale, error) func (self *Clock) Wall() (*p_hang.CatalogClock, error) -func (self *Clock) WallClock(pts *p_net.Timestamp) (p_kio.ClockWall, error) +func (self *Clock) WallClock(pts p_net.Timestamp) (p_kio.ClockWall, error) type CodecAacAdtsError interface { String() string GoString() string @@ -2104,7 +2103,7 @@ func (self *CodecH264Import) Error() string func (self *CodecH264Import) Finish() (*ContainerFinishedContainerVideoConfig, error) func (self *CodecH264Import) Initialize(buf p_rt.Bytes) error func (self *CodecH264Import) Name() (string, error) -func (self *CodecH264Import) ObserveReorder(reorder *p_net.Timestamp) error +func (self *CodecH264Import) ObserveReorder(reorder p_net.Timestamp) error func (self *CodecH264Import) ReportBitrate(bitrate p_net.BandwidthRate) error func (self *CodecH264Import) ReportSkipped(frames uint64) error func (self *CodecH264Import) Seek(start uint64) error @@ -2176,7 +2175,7 @@ func (self *CodecH265Import) Error() string func (self *CodecH265Import) Finish() (*ContainerFinishedContainerVideoConfig, error) func (self *CodecH265Import) Initialize(buf p_rt.Bytes) error func (self *CodecH265Import) Name() (string, error) -func (self *CodecH265Import) ObserveReorder(reorder *p_net.Timestamp) error +func (self *CodecH265Import) ObserveReorder(reorder p_net.Timestamp) error func (self *CodecH265Import) ReportBitrate(bitrate p_net.BandwidthRate) error func (self *CodecH265Import) ReportSkipped(frames uint64) error func (self *CodecH265Import) Seek(start uint64) error @@ -2826,7 +2825,7 @@ type ContainerFmp4Wire struct { func ContainerFmp4WireFromInit(initData p_rt.Bytes) (*ContainerFmp4Wire, error) func (self *ContainerFmp4Wire) Close() error type ContainerFrame struct { - Timestamp *p_net.Timestamp + Timestamp p_net.Timestamp Duration *p_net.Timestamp Payload p_rt.Bytes Keyframe bool @@ -3119,7 +3118,7 @@ func NewContainerProducerContainer(track *p_net.TrackProducer, container *Catalo func (self *ContainerProducerContainer) Abort(err *p_net.Error) error func (self *ContainerProducerContainer) AbortHandle() (*p_net.TrackAbortHandle, error) func (self *ContainerProducerContainer) AbortUnwanted(err *p_net.Error) error -func (self *ContainerProducerContainer) AppendGroup(start *p_net.Timestamp) (*p_net.GroupProducer, error) +func (self *ContainerProducerContainer) AppendGroup(start p_net.Timestamp) (*p_net.GroupProducer, error) func (self *ContainerProducerContainer) Broadcast() (*p_net.BroadcastInfo, error) func (self *ContainerProducerContainer) Close() error func (self *ContainerProducerContainer) Closed(ctx context.Context) error @@ -3133,7 +3132,7 @@ func (self *ContainerProducerContainer) Estimate() (*CatalogEstimate, error) func (self *ContainerProducerContainer) Fail(err *p_net.Error) (*ContainerFinishedContainer, error) func (self *ContainerProducerContainer) Finish() (*ContainerFinishedContainer, error) func (self *ContainerProducerContainer) Finished() (*p_net.TrackPosition, error) -func (self *ContainerProducerContainer) History(until *p_net.Timestamp) error +func (self *ContainerProducerContainer) History(until p_net.Timestamp) error func (self *ContainerProducerContainer) Info() (*p_net.TrackInfo, error) func (self *ContainerProducerContainer) IsClone(other_ *p_net.TrackProducer) (bool, error) func (self *ContainerProducerContainer) IsClosed() (bool, error) @@ -3142,7 +3141,7 @@ func (self *ContainerProducerContainer) LiveEdge() (*p_net.Timestamp, error) func (self *ContainerProducerContainer) Modify() (*ContainerGuardUnit, error) func (self *ContainerProducerContainer) Name() (string, error) func (self *ContainerProducerContainer) NeedsKeyframe() (bool, error) -func (self *ContainerProducerContainer) Reorder(delay *p_net.Timestamp) error +func (self *ContainerProducerContainer) Reorder(delay p_net.Timestamp) error func (self *ContainerProducerContainer) ReportBitrate(bitrate p_net.BandwidthRate) error func (self *ContainerProducerContainer) ReportSkipped(frames uint64) error func (self *ContainerProducerContainer) Requests() (*p_net.TrackRequests, error) @@ -3152,7 +3151,7 @@ func (self *ContainerProducerContainer) SetBitrate(bitrate uint64) error func (self *ContainerProducerContainer) SkipGroups(groups p_rt.RangeU64) error func (self *ContainerProducerContainer) Subscribe(subscription *p_net.TrackSubscription) (*p_net.TrackSubscriber, error) func (self *ContainerProducerContainer) Subscription() (*p_net.TrackSubscription, error) -func (self *ContainerProducerContainer) Timestamp(hint *p_net.Timestamp) (*p_net.Timestamp, error) +func (self *ContainerProducerContainer) Timestamp(hint *p_net.Timestamp) (p_net.Timestamp, error) func (self *ContainerProducerContainer) Track() (*p_net.TrackProducer, error) func (self *ContainerProducerContainer) WithBandwidth(allocator *p_net.BandwidthAllocator) (*ContainerProducerContainer, error) func (self *ContainerProducerContainer) WithBuffer(duration p_rt.Duration) (*ContainerProducerContainer, error) @@ -3163,7 +3162,7 @@ type ContainerProducerContainerAudioConfig struct { func (self *ContainerProducerContainerAudioConfig) Abort(err *p_net.Error) error func (self *ContainerProducerContainerAudioConfig) AbortHandle() (*p_net.TrackAbortHandle, error) func (self *ContainerProducerContainerAudioConfig) AbortUnwanted(err *p_net.Error) error -func (self *ContainerProducerContainerAudioConfig) AppendGroup(start *p_net.Timestamp) (*p_net.GroupProducer, error) +func (self *ContainerProducerContainerAudioConfig) AppendGroup(start p_net.Timestamp) (*p_net.GroupProducer, error) func (self *ContainerProducerContainerAudioConfig) Broadcast() (*p_net.BroadcastInfo, error) func (self *ContainerProducerContainerAudioConfig) Close() error func (self *ContainerProducerContainerAudioConfig) Closed(ctx context.Context) error @@ -3177,7 +3176,7 @@ func (self *ContainerProducerContainerAudioConfig) Estimate() (*CatalogEstimate, func (self *ContainerProducerContainerAudioConfig) Fail(err *p_net.Error) (*ContainerFinishedContainerAudioConfig, error) func (self *ContainerProducerContainerAudioConfig) Finish() (*ContainerFinishedContainerAudioConfig, error) func (self *ContainerProducerContainerAudioConfig) Finished() (*p_net.TrackPosition, error) -func (self *ContainerProducerContainerAudioConfig) History(until *p_net.Timestamp) error +func (self *ContainerProducerContainerAudioConfig) History(until p_net.Timestamp) error func (self *ContainerProducerContainerAudioConfig) Info() (*p_net.TrackInfo, error) func (self *ContainerProducerContainerAudioConfig) IsClone(other_ *p_net.TrackProducer) (bool, error) func (self *ContainerProducerContainerAudioConfig) IsClosed() (bool, error) @@ -3186,7 +3185,7 @@ func (self *ContainerProducerContainerAudioConfig) LiveEdge() (*p_net.Timestamp, func (self *ContainerProducerContainerAudioConfig) Modify() (*ContainerGuardAudioConfig, error) func (self *ContainerProducerContainerAudioConfig) Name() (string, error) func (self *ContainerProducerContainerAudioConfig) NeedsKeyframe() (bool, error) -func (self *ContainerProducerContainerAudioConfig) Reorder(delay *p_net.Timestamp) error +func (self *ContainerProducerContainerAudioConfig) Reorder(delay p_net.Timestamp) error func (self *ContainerProducerContainerAudioConfig) ReportBitrate(bitrate p_net.BandwidthRate) error func (self *ContainerProducerContainerAudioConfig) ReportSkipped(frames uint64) error func (self *ContainerProducerContainerAudioConfig) Requests() (*p_net.TrackRequests, error) @@ -3196,7 +3195,7 @@ func (self *ContainerProducerContainerAudioConfig) SetBitrate(bitrate uint64) er func (self *ContainerProducerContainerAudioConfig) SkipGroups(groups p_rt.RangeU64) error func (self *ContainerProducerContainerAudioConfig) Subscribe(subscription *p_net.TrackSubscription) (*p_net.TrackSubscriber, error) func (self *ContainerProducerContainerAudioConfig) Subscription() (*p_net.TrackSubscription, error) -func (self *ContainerProducerContainerAudioConfig) Timestamp(hint *p_net.Timestamp) (*p_net.Timestamp, error) +func (self *ContainerProducerContainerAudioConfig) Timestamp(hint *p_net.Timestamp) (p_net.Timestamp, error) func (self *ContainerProducerContainerAudioConfig) Track() (*p_net.TrackProducer, error) func (self *ContainerProducerContainerAudioConfig) WithBandwidth(allocator *p_net.BandwidthAllocator) (*ContainerProducerContainerAudioConfig, error) func (self *ContainerProducerContainerAudioConfig) WithBuffer(duration p_rt.Duration) (*ContainerProducerContainerAudioConfig, error) @@ -3207,7 +3206,7 @@ type ContainerProducerContainerBinaryConfig struct { func (self *ContainerProducerContainerBinaryConfig) Abort(err *p_net.Error) error func (self *ContainerProducerContainerBinaryConfig) AbortHandle() (*p_net.TrackAbortHandle, error) func (self *ContainerProducerContainerBinaryConfig) AbortUnwanted(err *p_net.Error) error -func (self *ContainerProducerContainerBinaryConfig) AppendGroup(start *p_net.Timestamp) (*p_net.GroupProducer, error) +func (self *ContainerProducerContainerBinaryConfig) AppendGroup(start p_net.Timestamp) (*p_net.GroupProducer, error) func (self *ContainerProducerContainerBinaryConfig) Broadcast() (*p_net.BroadcastInfo, error) func (self *ContainerProducerContainerBinaryConfig) Close() error func (self *ContainerProducerContainerBinaryConfig) Closed(ctx context.Context) error @@ -3221,7 +3220,7 @@ func (self *ContainerProducerContainerBinaryConfig) Estimate() (*CatalogEstimate func (self *ContainerProducerContainerBinaryConfig) Fail(err *p_net.Error) (*ContainerFinishedContainerBinaryConfig, error) func (self *ContainerProducerContainerBinaryConfig) Finish() (*ContainerFinishedContainerBinaryConfig, error) func (self *ContainerProducerContainerBinaryConfig) Finished() (*p_net.TrackPosition, error) -func (self *ContainerProducerContainerBinaryConfig) History(until *p_net.Timestamp) error +func (self *ContainerProducerContainerBinaryConfig) History(until p_net.Timestamp) error func (self *ContainerProducerContainerBinaryConfig) Info() (*p_net.TrackInfo, error) func (self *ContainerProducerContainerBinaryConfig) IsClone(other_ *p_net.TrackProducer) (bool, error) func (self *ContainerProducerContainerBinaryConfig) IsClosed() (bool, error) @@ -3230,7 +3229,7 @@ func (self *ContainerProducerContainerBinaryConfig) LiveEdge() (*p_net.Timestamp func (self *ContainerProducerContainerBinaryConfig) Modify() (*ContainerGuardBinaryConfig, error) func (self *ContainerProducerContainerBinaryConfig) Name() (string, error) func (self *ContainerProducerContainerBinaryConfig) NeedsKeyframe() (bool, error) -func (self *ContainerProducerContainerBinaryConfig) Reorder(delay *p_net.Timestamp) error +func (self *ContainerProducerContainerBinaryConfig) Reorder(delay p_net.Timestamp) error func (self *ContainerProducerContainerBinaryConfig) ReportBitrate(bitrate p_net.BandwidthRate) error func (self *ContainerProducerContainerBinaryConfig) ReportSkipped(frames uint64) error func (self *ContainerProducerContainerBinaryConfig) Requests() (*p_net.TrackRequests, error) @@ -3240,7 +3239,7 @@ func (self *ContainerProducerContainerBinaryConfig) SetBitrate(bitrate uint64) e func (self *ContainerProducerContainerBinaryConfig) SkipGroups(groups p_rt.RangeU64) error func (self *ContainerProducerContainerBinaryConfig) Subscribe(subscription *p_net.TrackSubscription) (*p_net.TrackSubscriber, error) func (self *ContainerProducerContainerBinaryConfig) Subscription() (*p_net.TrackSubscription, error) -func (self *ContainerProducerContainerBinaryConfig) Timestamp(hint *p_net.Timestamp) (*p_net.Timestamp, error) +func (self *ContainerProducerContainerBinaryConfig) Timestamp(hint *p_net.Timestamp) (p_net.Timestamp, error) func (self *ContainerProducerContainerBinaryConfig) Track() (*p_net.TrackProducer, error) func (self *ContainerProducerContainerBinaryConfig) WithBandwidth(allocator *p_net.BandwidthAllocator) (*ContainerProducerContainerBinaryConfig, error) func (self *ContainerProducerContainerBinaryConfig) WithBuffer(duration p_rt.Duration) (*ContainerProducerContainerBinaryConfig, error) @@ -3251,7 +3250,7 @@ type ContainerProducerContainerJsonConfig struct { func (self *ContainerProducerContainerJsonConfig) Abort(err *p_net.Error) error func (self *ContainerProducerContainerJsonConfig) AbortHandle() (*p_net.TrackAbortHandle, error) func (self *ContainerProducerContainerJsonConfig) AbortUnwanted(err *p_net.Error) error -func (self *ContainerProducerContainerJsonConfig) AppendGroup(start *p_net.Timestamp) (*p_net.GroupProducer, error) +func (self *ContainerProducerContainerJsonConfig) AppendGroup(start p_net.Timestamp) (*p_net.GroupProducer, error) func (self *ContainerProducerContainerJsonConfig) Broadcast() (*p_net.BroadcastInfo, error) func (self *ContainerProducerContainerJsonConfig) Close() error func (self *ContainerProducerContainerJsonConfig) Closed(ctx context.Context) error @@ -3265,7 +3264,7 @@ func (self *ContainerProducerContainerJsonConfig) Estimate() (*CatalogEstimate, func (self *ContainerProducerContainerJsonConfig) Fail(err *p_net.Error) (*ContainerFinishedContainerJsonConfig, error) func (self *ContainerProducerContainerJsonConfig) Finish() (*ContainerFinishedContainerJsonConfig, error) func (self *ContainerProducerContainerJsonConfig) Finished() (*p_net.TrackPosition, error) -func (self *ContainerProducerContainerJsonConfig) History(until *p_net.Timestamp) error +func (self *ContainerProducerContainerJsonConfig) History(until p_net.Timestamp) error func (self *ContainerProducerContainerJsonConfig) Info() (*p_net.TrackInfo, error) func (self *ContainerProducerContainerJsonConfig) IsClone(other_ *p_net.TrackProducer) (bool, error) func (self *ContainerProducerContainerJsonConfig) IsClosed() (bool, error) @@ -3274,7 +3273,7 @@ func (self *ContainerProducerContainerJsonConfig) LiveEdge() (*p_net.Timestamp, func (self *ContainerProducerContainerJsonConfig) Modify() (*ContainerGuardJsonConfig, error) func (self *ContainerProducerContainerJsonConfig) Name() (string, error) func (self *ContainerProducerContainerJsonConfig) NeedsKeyframe() (bool, error) -func (self *ContainerProducerContainerJsonConfig) Reorder(delay *p_net.Timestamp) error +func (self *ContainerProducerContainerJsonConfig) Reorder(delay p_net.Timestamp) error func (self *ContainerProducerContainerJsonConfig) ReportBitrate(bitrate p_net.BandwidthRate) error func (self *ContainerProducerContainerJsonConfig) ReportSkipped(frames uint64) error func (self *ContainerProducerContainerJsonConfig) Requests() (*p_net.TrackRequests, error) @@ -3284,7 +3283,7 @@ func (self *ContainerProducerContainerJsonConfig) SetBitrate(bitrate uint64) err func (self *ContainerProducerContainerJsonConfig) SkipGroups(groups p_rt.RangeU64) error func (self *ContainerProducerContainerJsonConfig) Subscribe(subscription *p_net.TrackSubscription) (*p_net.TrackSubscriber, error) func (self *ContainerProducerContainerJsonConfig) Subscription() (*p_net.TrackSubscription, error) -func (self *ContainerProducerContainerJsonConfig) Timestamp(hint *p_net.Timestamp) (*p_net.Timestamp, error) +func (self *ContainerProducerContainerJsonConfig) Timestamp(hint *p_net.Timestamp) (p_net.Timestamp, error) func (self *ContainerProducerContainerJsonConfig) Track() (*p_net.TrackProducer, error) func (self *ContainerProducerContainerJsonConfig) WithBandwidth(allocator *p_net.BandwidthAllocator) (*ContainerProducerContainerJsonConfig, error) func (self *ContainerProducerContainerJsonConfig) WithBuffer(duration p_rt.Duration) (*ContainerProducerContainerJsonConfig, error) @@ -3295,7 +3294,7 @@ type ContainerProducerContainerTextConfig struct { func (self *ContainerProducerContainerTextConfig) Abort(err *p_net.Error) error func (self *ContainerProducerContainerTextConfig) AbortHandle() (*p_net.TrackAbortHandle, error) func (self *ContainerProducerContainerTextConfig) AbortUnwanted(err *p_net.Error) error -func (self *ContainerProducerContainerTextConfig) AppendGroup(start *p_net.Timestamp) (*p_net.GroupProducer, error) +func (self *ContainerProducerContainerTextConfig) AppendGroup(start p_net.Timestamp) (*p_net.GroupProducer, error) func (self *ContainerProducerContainerTextConfig) Broadcast() (*p_net.BroadcastInfo, error) func (self *ContainerProducerContainerTextConfig) Close() error func (self *ContainerProducerContainerTextConfig) Closed(ctx context.Context) error @@ -3309,7 +3308,7 @@ func (self *ContainerProducerContainerTextConfig) Estimate() (*CatalogEstimate, func (self *ContainerProducerContainerTextConfig) Fail(err *p_net.Error) (*ContainerFinishedContainerTextConfig, error) func (self *ContainerProducerContainerTextConfig) Finish() (*ContainerFinishedContainerTextConfig, error) func (self *ContainerProducerContainerTextConfig) Finished() (*p_net.TrackPosition, error) -func (self *ContainerProducerContainerTextConfig) History(until *p_net.Timestamp) error +func (self *ContainerProducerContainerTextConfig) History(until p_net.Timestamp) error func (self *ContainerProducerContainerTextConfig) Info() (*p_net.TrackInfo, error) func (self *ContainerProducerContainerTextConfig) IsClone(other_ *p_net.TrackProducer) (bool, error) func (self *ContainerProducerContainerTextConfig) IsClosed() (bool, error) @@ -3318,7 +3317,7 @@ func (self *ContainerProducerContainerTextConfig) LiveEdge() (*p_net.Timestamp, func (self *ContainerProducerContainerTextConfig) Modify() (*ContainerGuardTextConfig, error) func (self *ContainerProducerContainerTextConfig) Name() (string, error) func (self *ContainerProducerContainerTextConfig) NeedsKeyframe() (bool, error) -func (self *ContainerProducerContainerTextConfig) Reorder(delay *p_net.Timestamp) error +func (self *ContainerProducerContainerTextConfig) Reorder(delay p_net.Timestamp) error func (self *ContainerProducerContainerTextConfig) ReportBitrate(bitrate p_net.BandwidthRate) error func (self *ContainerProducerContainerTextConfig) ReportSkipped(frames uint64) error func (self *ContainerProducerContainerTextConfig) Requests() (*p_net.TrackRequests, error) @@ -3328,7 +3327,7 @@ func (self *ContainerProducerContainerTextConfig) SetBitrate(bitrate uint64) err func (self *ContainerProducerContainerTextConfig) SkipGroups(groups p_rt.RangeU64) error func (self *ContainerProducerContainerTextConfig) Subscribe(subscription *p_net.TrackSubscription) (*p_net.TrackSubscriber, error) func (self *ContainerProducerContainerTextConfig) Subscription() (*p_net.TrackSubscription, error) -func (self *ContainerProducerContainerTextConfig) Timestamp(hint *p_net.Timestamp) (*p_net.Timestamp, error) +func (self *ContainerProducerContainerTextConfig) Timestamp(hint *p_net.Timestamp) (p_net.Timestamp, error) func (self *ContainerProducerContainerTextConfig) Track() (*p_net.TrackProducer, error) func (self *ContainerProducerContainerTextConfig) WithBandwidth(allocator *p_net.BandwidthAllocator) (*ContainerProducerContainerTextConfig, error) func (self *ContainerProducerContainerTextConfig) WithBuffer(duration p_rt.Duration) (*ContainerProducerContainerTextConfig, error) @@ -3339,7 +3338,7 @@ type ContainerProducerContainerVideoConfig struct { func (self *ContainerProducerContainerVideoConfig) Abort(err *p_net.Error) error func (self *ContainerProducerContainerVideoConfig) AbortHandle() (*p_net.TrackAbortHandle, error) func (self *ContainerProducerContainerVideoConfig) AbortUnwanted(err *p_net.Error) error -func (self *ContainerProducerContainerVideoConfig) AppendGroup(start *p_net.Timestamp) (*p_net.GroupProducer, error) +func (self *ContainerProducerContainerVideoConfig) AppendGroup(start p_net.Timestamp) (*p_net.GroupProducer, error) func (self *ContainerProducerContainerVideoConfig) Broadcast() (*p_net.BroadcastInfo, error) func (self *ContainerProducerContainerVideoConfig) Close() error func (self *ContainerProducerContainerVideoConfig) Closed(ctx context.Context) error @@ -3353,7 +3352,7 @@ func (self *ContainerProducerContainerVideoConfig) Estimate() (*CatalogEstimate, func (self *ContainerProducerContainerVideoConfig) Fail(err *p_net.Error) (*ContainerFinishedContainerVideoConfig, error) func (self *ContainerProducerContainerVideoConfig) Finish() (*ContainerFinishedContainerVideoConfig, error) func (self *ContainerProducerContainerVideoConfig) Finished() (*p_net.TrackPosition, error) -func (self *ContainerProducerContainerVideoConfig) History(until *p_net.Timestamp) error +func (self *ContainerProducerContainerVideoConfig) History(until p_net.Timestamp) error func (self *ContainerProducerContainerVideoConfig) Info() (*p_net.TrackInfo, error) func (self *ContainerProducerContainerVideoConfig) IsClone(other_ *p_net.TrackProducer) (bool, error) func (self *ContainerProducerContainerVideoConfig) IsClosed() (bool, error) @@ -3362,7 +3361,7 @@ func (self *ContainerProducerContainerVideoConfig) LiveEdge() (*p_net.Timestamp, func (self *ContainerProducerContainerVideoConfig) Modify() (*ContainerGuardVideoConfig, error) func (self *ContainerProducerContainerVideoConfig) Name() (string, error) func (self *ContainerProducerContainerVideoConfig) NeedsKeyframe() (bool, error) -func (self *ContainerProducerContainerVideoConfig) Reorder(delay *p_net.Timestamp) error +func (self *ContainerProducerContainerVideoConfig) Reorder(delay p_net.Timestamp) error func (self *ContainerProducerContainerVideoConfig) ReportBitrate(bitrate p_net.BandwidthRate) error func (self *ContainerProducerContainerVideoConfig) ReportSkipped(frames uint64) error func (self *ContainerProducerContainerVideoConfig) Requests() (*p_net.TrackRequests, error) @@ -3372,7 +3371,7 @@ func (self *ContainerProducerContainerVideoConfig) SetBitrate(bitrate uint64) er func (self *ContainerProducerContainerVideoConfig) SkipGroups(groups p_rt.RangeU64) error func (self *ContainerProducerContainerVideoConfig) Subscribe(subscription *p_net.TrackSubscription) (*p_net.TrackSubscriber, error) func (self *ContainerProducerContainerVideoConfig) Subscription() (*p_net.TrackSubscription, error) -func (self *ContainerProducerContainerVideoConfig) Timestamp(hint *p_net.Timestamp) (*p_net.Timestamp, error) +func (self *ContainerProducerContainerVideoConfig) Timestamp(hint *p_net.Timestamp) (p_net.Timestamp, error) func (self *ContainerProducerContainerVideoConfig) Track() (*p_net.TrackProducer, error) func (self *ContainerProducerContainerVideoConfig) WithBandwidth(allocator *p_net.BandwidthAllocator) (*ContainerProducerContainerVideoConfig, error) func (self *ContainerProducerContainerVideoConfig) WithBuffer(duration p_rt.Duration) (*ContainerProducerContainerVideoConfig, error) @@ -3384,7 +3383,7 @@ func NewContainerProducerFmp4Wire(track *p_net.TrackProducer, container *Contain func (self *ContainerProducerFmp4Wire) Abort(err *p_net.Error) error func (self *ContainerProducerFmp4Wire) AbortHandle() (*p_net.TrackAbortHandle, error) func (self *ContainerProducerFmp4Wire) AbortUnwanted(err *p_net.Error) error -func (self *ContainerProducerFmp4Wire) AppendGroup(start *p_net.Timestamp) (*p_net.GroupProducer, error) +func (self *ContainerProducerFmp4Wire) AppendGroup(start p_net.Timestamp) (*p_net.GroupProducer, error) func (self *ContainerProducerFmp4Wire) Broadcast() (*p_net.BroadcastInfo, error) func (self *ContainerProducerFmp4Wire) Close() error func (self *ContainerProducerFmp4Wire) Closed(ctx context.Context) error @@ -3398,7 +3397,7 @@ func (self *ContainerProducerFmp4Wire) Estimate() (*CatalogEstimate, error) func (self *ContainerProducerFmp4Wire) Fail(err *p_net.Error) (*ContainerFinishedFmp4Wire, error) func (self *ContainerProducerFmp4Wire) Finish() (*ContainerFinishedFmp4Wire, error) func (self *ContainerProducerFmp4Wire) Finished() (*p_net.TrackPosition, error) -func (self *ContainerProducerFmp4Wire) History(until *p_net.Timestamp) error +func (self *ContainerProducerFmp4Wire) History(until p_net.Timestamp) error func (self *ContainerProducerFmp4Wire) Info() (*p_net.TrackInfo, error) func (self *ContainerProducerFmp4Wire) IsClone(other_ *p_net.TrackProducer) (bool, error) func (self *ContainerProducerFmp4Wire) IsClosed() (bool, error) @@ -3407,7 +3406,7 @@ func (self *ContainerProducerFmp4Wire) LiveEdge() (*p_net.Timestamp, error) func (self *ContainerProducerFmp4Wire) Modify() (*ContainerGuardUnit, error) func (self *ContainerProducerFmp4Wire) Name() (string, error) func (self *ContainerProducerFmp4Wire) NeedsKeyframe() (bool, error) -func (self *ContainerProducerFmp4Wire) Reorder(delay *p_net.Timestamp) error +func (self *ContainerProducerFmp4Wire) Reorder(delay p_net.Timestamp) error func (self *ContainerProducerFmp4Wire) ReportBitrate(bitrate p_net.BandwidthRate) error func (self *ContainerProducerFmp4Wire) ReportSkipped(frames uint64) error func (self *ContainerProducerFmp4Wire) Requests() (*p_net.TrackRequests, error) @@ -3417,7 +3416,7 @@ func (self *ContainerProducerFmp4Wire) SetBitrate(bitrate uint64) error func (self *ContainerProducerFmp4Wire) SkipGroups(groups p_rt.RangeU64) error func (self *ContainerProducerFmp4Wire) Subscribe(subscription *p_net.TrackSubscription) (*p_net.TrackSubscriber, error) func (self *ContainerProducerFmp4Wire) Subscription() (*p_net.TrackSubscription, error) -func (self *ContainerProducerFmp4Wire) Timestamp(hint *p_net.Timestamp) (*p_net.Timestamp, error) +func (self *ContainerProducerFmp4Wire) Timestamp(hint *p_net.Timestamp) (p_net.Timestamp, error) func (self *ContainerProducerFmp4Wire) Track() (*p_net.TrackProducer, error) func (self *ContainerProducerFmp4Wire) WithBandwidth(allocator *p_net.BandwidthAllocator) (*ContainerProducerFmp4Wire, error) func (self *ContainerProducerFmp4Wire) WithBuffer(duration p_rt.Duration) (*ContainerProducerFmp4Wire, error) @@ -3428,7 +3427,7 @@ type ContainerProducerFmp4WireAudioConfig struct { func (self *ContainerProducerFmp4WireAudioConfig) Abort(err *p_net.Error) error func (self *ContainerProducerFmp4WireAudioConfig) AbortHandle() (*p_net.TrackAbortHandle, error) func (self *ContainerProducerFmp4WireAudioConfig) AbortUnwanted(err *p_net.Error) error -func (self *ContainerProducerFmp4WireAudioConfig) AppendGroup(start *p_net.Timestamp) (*p_net.GroupProducer, error) +func (self *ContainerProducerFmp4WireAudioConfig) AppendGroup(start p_net.Timestamp) (*p_net.GroupProducer, error) func (self *ContainerProducerFmp4WireAudioConfig) Broadcast() (*p_net.BroadcastInfo, error) func (self *ContainerProducerFmp4WireAudioConfig) Close() error func (self *ContainerProducerFmp4WireAudioConfig) Closed(ctx context.Context) error @@ -3442,7 +3441,7 @@ func (self *ContainerProducerFmp4WireAudioConfig) Estimate() (*CatalogEstimate, func (self *ContainerProducerFmp4WireAudioConfig) Fail(err *p_net.Error) (*ContainerFinishedFmp4WireAudioConfig, error) func (self *ContainerProducerFmp4WireAudioConfig) Finish() (*ContainerFinishedFmp4WireAudioConfig, error) func (self *ContainerProducerFmp4WireAudioConfig) Finished() (*p_net.TrackPosition, error) -func (self *ContainerProducerFmp4WireAudioConfig) History(until *p_net.Timestamp) error +func (self *ContainerProducerFmp4WireAudioConfig) History(until p_net.Timestamp) error func (self *ContainerProducerFmp4WireAudioConfig) Info() (*p_net.TrackInfo, error) func (self *ContainerProducerFmp4WireAudioConfig) IsClone(other_ *p_net.TrackProducer) (bool, error) func (self *ContainerProducerFmp4WireAudioConfig) IsClosed() (bool, error) @@ -3451,7 +3450,7 @@ func (self *ContainerProducerFmp4WireAudioConfig) LiveEdge() (*p_net.Timestamp, func (self *ContainerProducerFmp4WireAudioConfig) Modify() (*ContainerGuardAudioConfig, error) func (self *ContainerProducerFmp4WireAudioConfig) Name() (string, error) func (self *ContainerProducerFmp4WireAudioConfig) NeedsKeyframe() (bool, error) -func (self *ContainerProducerFmp4WireAudioConfig) Reorder(delay *p_net.Timestamp) error +func (self *ContainerProducerFmp4WireAudioConfig) Reorder(delay p_net.Timestamp) error func (self *ContainerProducerFmp4WireAudioConfig) ReportBitrate(bitrate p_net.BandwidthRate) error func (self *ContainerProducerFmp4WireAudioConfig) ReportSkipped(frames uint64) error func (self *ContainerProducerFmp4WireAudioConfig) Requests() (*p_net.TrackRequests, error) @@ -3461,7 +3460,7 @@ func (self *ContainerProducerFmp4WireAudioConfig) SetBitrate(bitrate uint64) err func (self *ContainerProducerFmp4WireAudioConfig) SkipGroups(groups p_rt.RangeU64) error func (self *ContainerProducerFmp4WireAudioConfig) Subscribe(subscription *p_net.TrackSubscription) (*p_net.TrackSubscriber, error) func (self *ContainerProducerFmp4WireAudioConfig) Subscription() (*p_net.TrackSubscription, error) -func (self *ContainerProducerFmp4WireAudioConfig) Timestamp(hint *p_net.Timestamp) (*p_net.Timestamp, error) +func (self *ContainerProducerFmp4WireAudioConfig) Timestamp(hint *p_net.Timestamp) (p_net.Timestamp, error) func (self *ContainerProducerFmp4WireAudioConfig) Track() (*p_net.TrackProducer, error) func (self *ContainerProducerFmp4WireAudioConfig) WithBandwidth(allocator *p_net.BandwidthAllocator) (*ContainerProducerFmp4WireAudioConfig, error) func (self *ContainerProducerFmp4WireAudioConfig) WithBuffer(duration p_rt.Duration) (*ContainerProducerFmp4WireAudioConfig, error) @@ -3472,7 +3471,7 @@ type ContainerProducerFmp4WireBinaryConfig struct { func (self *ContainerProducerFmp4WireBinaryConfig) Abort(err *p_net.Error) error func (self *ContainerProducerFmp4WireBinaryConfig) AbortHandle() (*p_net.TrackAbortHandle, error) func (self *ContainerProducerFmp4WireBinaryConfig) AbortUnwanted(err *p_net.Error) error -func (self *ContainerProducerFmp4WireBinaryConfig) AppendGroup(start *p_net.Timestamp) (*p_net.GroupProducer, error) +func (self *ContainerProducerFmp4WireBinaryConfig) AppendGroup(start p_net.Timestamp) (*p_net.GroupProducer, error) func (self *ContainerProducerFmp4WireBinaryConfig) Broadcast() (*p_net.BroadcastInfo, error) func (self *ContainerProducerFmp4WireBinaryConfig) Close() error func (self *ContainerProducerFmp4WireBinaryConfig) Closed(ctx context.Context) error @@ -3486,7 +3485,7 @@ func (self *ContainerProducerFmp4WireBinaryConfig) Estimate() (*CatalogEstimate, func (self *ContainerProducerFmp4WireBinaryConfig) Fail(err *p_net.Error) (*ContainerFinishedFmp4WireBinaryConfig, error) func (self *ContainerProducerFmp4WireBinaryConfig) Finish() (*ContainerFinishedFmp4WireBinaryConfig, error) func (self *ContainerProducerFmp4WireBinaryConfig) Finished() (*p_net.TrackPosition, error) -func (self *ContainerProducerFmp4WireBinaryConfig) History(until *p_net.Timestamp) error +func (self *ContainerProducerFmp4WireBinaryConfig) History(until p_net.Timestamp) error func (self *ContainerProducerFmp4WireBinaryConfig) Info() (*p_net.TrackInfo, error) func (self *ContainerProducerFmp4WireBinaryConfig) IsClone(other_ *p_net.TrackProducer) (bool, error) func (self *ContainerProducerFmp4WireBinaryConfig) IsClosed() (bool, error) @@ -3495,7 +3494,7 @@ func (self *ContainerProducerFmp4WireBinaryConfig) LiveEdge() (*p_net.Timestamp, func (self *ContainerProducerFmp4WireBinaryConfig) Modify() (*ContainerGuardBinaryConfig, error) func (self *ContainerProducerFmp4WireBinaryConfig) Name() (string, error) func (self *ContainerProducerFmp4WireBinaryConfig) NeedsKeyframe() (bool, error) -func (self *ContainerProducerFmp4WireBinaryConfig) Reorder(delay *p_net.Timestamp) error +func (self *ContainerProducerFmp4WireBinaryConfig) Reorder(delay p_net.Timestamp) error func (self *ContainerProducerFmp4WireBinaryConfig) ReportBitrate(bitrate p_net.BandwidthRate) error func (self *ContainerProducerFmp4WireBinaryConfig) ReportSkipped(frames uint64) error func (self *ContainerProducerFmp4WireBinaryConfig) Requests() (*p_net.TrackRequests, error) @@ -3505,7 +3504,7 @@ func (self *ContainerProducerFmp4WireBinaryConfig) SetBitrate(bitrate uint64) er func (self *ContainerProducerFmp4WireBinaryConfig) SkipGroups(groups p_rt.RangeU64) error func (self *ContainerProducerFmp4WireBinaryConfig) Subscribe(subscription *p_net.TrackSubscription) (*p_net.TrackSubscriber, error) func (self *ContainerProducerFmp4WireBinaryConfig) Subscription() (*p_net.TrackSubscription, error) -func (self *ContainerProducerFmp4WireBinaryConfig) Timestamp(hint *p_net.Timestamp) (*p_net.Timestamp, error) +func (self *ContainerProducerFmp4WireBinaryConfig) Timestamp(hint *p_net.Timestamp) (p_net.Timestamp, error) func (self *ContainerProducerFmp4WireBinaryConfig) Track() (*p_net.TrackProducer, error) func (self *ContainerProducerFmp4WireBinaryConfig) WithBandwidth(allocator *p_net.BandwidthAllocator) (*ContainerProducerFmp4WireBinaryConfig, error) func (self *ContainerProducerFmp4WireBinaryConfig) WithBuffer(duration p_rt.Duration) (*ContainerProducerFmp4WireBinaryConfig, error) @@ -3516,7 +3515,7 @@ type ContainerProducerFmp4WireJsonConfig struct { func (self *ContainerProducerFmp4WireJsonConfig) Abort(err *p_net.Error) error func (self *ContainerProducerFmp4WireJsonConfig) AbortHandle() (*p_net.TrackAbortHandle, error) func (self *ContainerProducerFmp4WireJsonConfig) AbortUnwanted(err *p_net.Error) error -func (self *ContainerProducerFmp4WireJsonConfig) AppendGroup(start *p_net.Timestamp) (*p_net.GroupProducer, error) +func (self *ContainerProducerFmp4WireJsonConfig) AppendGroup(start p_net.Timestamp) (*p_net.GroupProducer, error) func (self *ContainerProducerFmp4WireJsonConfig) Broadcast() (*p_net.BroadcastInfo, error) func (self *ContainerProducerFmp4WireJsonConfig) Close() error func (self *ContainerProducerFmp4WireJsonConfig) Closed(ctx context.Context) error @@ -3530,7 +3529,7 @@ func (self *ContainerProducerFmp4WireJsonConfig) Estimate() (*CatalogEstimate, e func (self *ContainerProducerFmp4WireJsonConfig) Fail(err *p_net.Error) (*ContainerFinishedFmp4WireJsonConfig, error) func (self *ContainerProducerFmp4WireJsonConfig) Finish() (*ContainerFinishedFmp4WireJsonConfig, error) func (self *ContainerProducerFmp4WireJsonConfig) Finished() (*p_net.TrackPosition, error) -func (self *ContainerProducerFmp4WireJsonConfig) History(until *p_net.Timestamp) error +func (self *ContainerProducerFmp4WireJsonConfig) History(until p_net.Timestamp) error func (self *ContainerProducerFmp4WireJsonConfig) Info() (*p_net.TrackInfo, error) func (self *ContainerProducerFmp4WireJsonConfig) IsClone(other_ *p_net.TrackProducer) (bool, error) func (self *ContainerProducerFmp4WireJsonConfig) IsClosed() (bool, error) @@ -3539,7 +3538,7 @@ func (self *ContainerProducerFmp4WireJsonConfig) LiveEdge() (*p_net.Timestamp, e func (self *ContainerProducerFmp4WireJsonConfig) Modify() (*ContainerGuardJsonConfig, error) func (self *ContainerProducerFmp4WireJsonConfig) Name() (string, error) func (self *ContainerProducerFmp4WireJsonConfig) NeedsKeyframe() (bool, error) -func (self *ContainerProducerFmp4WireJsonConfig) Reorder(delay *p_net.Timestamp) error +func (self *ContainerProducerFmp4WireJsonConfig) Reorder(delay p_net.Timestamp) error func (self *ContainerProducerFmp4WireJsonConfig) ReportBitrate(bitrate p_net.BandwidthRate) error func (self *ContainerProducerFmp4WireJsonConfig) ReportSkipped(frames uint64) error func (self *ContainerProducerFmp4WireJsonConfig) Requests() (*p_net.TrackRequests, error) @@ -3549,7 +3548,7 @@ func (self *ContainerProducerFmp4WireJsonConfig) SetBitrate(bitrate uint64) erro func (self *ContainerProducerFmp4WireJsonConfig) SkipGroups(groups p_rt.RangeU64) error func (self *ContainerProducerFmp4WireJsonConfig) Subscribe(subscription *p_net.TrackSubscription) (*p_net.TrackSubscriber, error) func (self *ContainerProducerFmp4WireJsonConfig) Subscription() (*p_net.TrackSubscription, error) -func (self *ContainerProducerFmp4WireJsonConfig) Timestamp(hint *p_net.Timestamp) (*p_net.Timestamp, error) +func (self *ContainerProducerFmp4WireJsonConfig) Timestamp(hint *p_net.Timestamp) (p_net.Timestamp, error) func (self *ContainerProducerFmp4WireJsonConfig) Track() (*p_net.TrackProducer, error) func (self *ContainerProducerFmp4WireJsonConfig) WithBandwidth(allocator *p_net.BandwidthAllocator) (*ContainerProducerFmp4WireJsonConfig, error) func (self *ContainerProducerFmp4WireJsonConfig) WithBuffer(duration p_rt.Duration) (*ContainerProducerFmp4WireJsonConfig, error) @@ -3560,7 +3559,7 @@ type ContainerProducerFmp4WireTextConfig struct { func (self *ContainerProducerFmp4WireTextConfig) Abort(err *p_net.Error) error func (self *ContainerProducerFmp4WireTextConfig) AbortHandle() (*p_net.TrackAbortHandle, error) func (self *ContainerProducerFmp4WireTextConfig) AbortUnwanted(err *p_net.Error) error -func (self *ContainerProducerFmp4WireTextConfig) AppendGroup(start *p_net.Timestamp) (*p_net.GroupProducer, error) +func (self *ContainerProducerFmp4WireTextConfig) AppendGroup(start p_net.Timestamp) (*p_net.GroupProducer, error) func (self *ContainerProducerFmp4WireTextConfig) Broadcast() (*p_net.BroadcastInfo, error) func (self *ContainerProducerFmp4WireTextConfig) Close() error func (self *ContainerProducerFmp4WireTextConfig) Closed(ctx context.Context) error @@ -3574,7 +3573,7 @@ func (self *ContainerProducerFmp4WireTextConfig) Estimate() (*CatalogEstimate, e func (self *ContainerProducerFmp4WireTextConfig) Fail(err *p_net.Error) (*ContainerFinishedFmp4WireTextConfig, error) func (self *ContainerProducerFmp4WireTextConfig) Finish() (*ContainerFinishedFmp4WireTextConfig, error) func (self *ContainerProducerFmp4WireTextConfig) Finished() (*p_net.TrackPosition, error) -func (self *ContainerProducerFmp4WireTextConfig) History(until *p_net.Timestamp) error +func (self *ContainerProducerFmp4WireTextConfig) History(until p_net.Timestamp) error func (self *ContainerProducerFmp4WireTextConfig) Info() (*p_net.TrackInfo, error) func (self *ContainerProducerFmp4WireTextConfig) IsClone(other_ *p_net.TrackProducer) (bool, error) func (self *ContainerProducerFmp4WireTextConfig) IsClosed() (bool, error) @@ -3583,7 +3582,7 @@ func (self *ContainerProducerFmp4WireTextConfig) LiveEdge() (*p_net.Timestamp, e func (self *ContainerProducerFmp4WireTextConfig) Modify() (*ContainerGuardTextConfig, error) func (self *ContainerProducerFmp4WireTextConfig) Name() (string, error) func (self *ContainerProducerFmp4WireTextConfig) NeedsKeyframe() (bool, error) -func (self *ContainerProducerFmp4WireTextConfig) Reorder(delay *p_net.Timestamp) error +func (self *ContainerProducerFmp4WireTextConfig) Reorder(delay p_net.Timestamp) error func (self *ContainerProducerFmp4WireTextConfig) ReportBitrate(bitrate p_net.BandwidthRate) error func (self *ContainerProducerFmp4WireTextConfig) ReportSkipped(frames uint64) error func (self *ContainerProducerFmp4WireTextConfig) Requests() (*p_net.TrackRequests, error) @@ -3593,7 +3592,7 @@ func (self *ContainerProducerFmp4WireTextConfig) SetBitrate(bitrate uint64) erro func (self *ContainerProducerFmp4WireTextConfig) SkipGroups(groups p_rt.RangeU64) error func (self *ContainerProducerFmp4WireTextConfig) Subscribe(subscription *p_net.TrackSubscription) (*p_net.TrackSubscriber, error) func (self *ContainerProducerFmp4WireTextConfig) Subscription() (*p_net.TrackSubscription, error) -func (self *ContainerProducerFmp4WireTextConfig) Timestamp(hint *p_net.Timestamp) (*p_net.Timestamp, error) +func (self *ContainerProducerFmp4WireTextConfig) Timestamp(hint *p_net.Timestamp) (p_net.Timestamp, error) func (self *ContainerProducerFmp4WireTextConfig) Track() (*p_net.TrackProducer, error) func (self *ContainerProducerFmp4WireTextConfig) WithBandwidth(allocator *p_net.BandwidthAllocator) (*ContainerProducerFmp4WireTextConfig, error) func (self *ContainerProducerFmp4WireTextConfig) WithBuffer(duration p_rt.Duration) (*ContainerProducerFmp4WireTextConfig, error) @@ -3604,7 +3603,7 @@ type ContainerProducerFmp4WireVideoConfig struct { func (self *ContainerProducerFmp4WireVideoConfig) Abort(err *p_net.Error) error func (self *ContainerProducerFmp4WireVideoConfig) AbortHandle() (*p_net.TrackAbortHandle, error) func (self *ContainerProducerFmp4WireVideoConfig) AbortUnwanted(err *p_net.Error) error -func (self *ContainerProducerFmp4WireVideoConfig) AppendGroup(start *p_net.Timestamp) (*p_net.GroupProducer, error) +func (self *ContainerProducerFmp4WireVideoConfig) AppendGroup(start p_net.Timestamp) (*p_net.GroupProducer, error) func (self *ContainerProducerFmp4WireVideoConfig) Broadcast() (*p_net.BroadcastInfo, error) func (self *ContainerProducerFmp4WireVideoConfig) Close() error func (self *ContainerProducerFmp4WireVideoConfig) Closed(ctx context.Context) error @@ -3618,7 +3617,7 @@ func (self *ContainerProducerFmp4WireVideoConfig) Estimate() (*CatalogEstimate, func (self *ContainerProducerFmp4WireVideoConfig) Fail(err *p_net.Error) (*ContainerFinishedFmp4WireVideoConfig, error) func (self *ContainerProducerFmp4WireVideoConfig) Finish() (*ContainerFinishedFmp4WireVideoConfig, error) func (self *ContainerProducerFmp4WireVideoConfig) Finished() (*p_net.TrackPosition, error) -func (self *ContainerProducerFmp4WireVideoConfig) History(until *p_net.Timestamp) error +func (self *ContainerProducerFmp4WireVideoConfig) History(until p_net.Timestamp) error func (self *ContainerProducerFmp4WireVideoConfig) Info() (*p_net.TrackInfo, error) func (self *ContainerProducerFmp4WireVideoConfig) IsClone(other_ *p_net.TrackProducer) (bool, error) func (self *ContainerProducerFmp4WireVideoConfig) IsClosed() (bool, error) @@ -3627,7 +3626,7 @@ func (self *ContainerProducerFmp4WireVideoConfig) LiveEdge() (*p_net.Timestamp, func (self *ContainerProducerFmp4WireVideoConfig) Modify() (*ContainerGuardVideoConfig, error) func (self *ContainerProducerFmp4WireVideoConfig) Name() (string, error) func (self *ContainerProducerFmp4WireVideoConfig) NeedsKeyframe() (bool, error) -func (self *ContainerProducerFmp4WireVideoConfig) Reorder(delay *p_net.Timestamp) error +func (self *ContainerProducerFmp4WireVideoConfig) Reorder(delay p_net.Timestamp) error func (self *ContainerProducerFmp4WireVideoConfig) ReportBitrate(bitrate p_net.BandwidthRate) error func (self *ContainerProducerFmp4WireVideoConfig) ReportSkipped(frames uint64) error func (self *ContainerProducerFmp4WireVideoConfig) Requests() (*p_net.TrackRequests, error) @@ -3637,7 +3636,7 @@ func (self *ContainerProducerFmp4WireVideoConfig) SetBitrate(bitrate uint64) err func (self *ContainerProducerFmp4WireVideoConfig) SkipGroups(groups p_rt.RangeU64) error func (self *ContainerProducerFmp4WireVideoConfig) Subscribe(subscription *p_net.TrackSubscription) (*p_net.TrackSubscriber, error) func (self *ContainerProducerFmp4WireVideoConfig) Subscription() (*p_net.TrackSubscription, error) -func (self *ContainerProducerFmp4WireVideoConfig) Timestamp(hint *p_net.Timestamp) (*p_net.Timestamp, error) +func (self *ContainerProducerFmp4WireVideoConfig) Timestamp(hint *p_net.Timestamp) (p_net.Timestamp, error) func (self *ContainerProducerFmp4WireVideoConfig) Track() (*p_net.TrackProducer, error) func (self *ContainerProducerFmp4WireVideoConfig) WithBandwidth(allocator *p_net.BandwidthAllocator) (*ContainerProducerFmp4WireVideoConfig, error) func (self *ContainerProducerFmp4WireVideoConfig) WithBuffer(duration p_rt.Duration) (*ContainerProducerFmp4WireVideoConfig, error) @@ -3649,7 +3648,7 @@ func NewContainerProducerLegacyWire(track *p_net.TrackProducer, container Contai func (self *ContainerProducerLegacyWire) Abort(err *p_net.Error) error func (self *ContainerProducerLegacyWire) AbortHandle() (*p_net.TrackAbortHandle, error) func (self *ContainerProducerLegacyWire) AbortUnwanted(err *p_net.Error) error -func (self *ContainerProducerLegacyWire) AppendGroup(start *p_net.Timestamp) (*p_net.GroupProducer, error) +func (self *ContainerProducerLegacyWire) AppendGroup(start p_net.Timestamp) (*p_net.GroupProducer, error) func (self *ContainerProducerLegacyWire) Broadcast() (*p_net.BroadcastInfo, error) func (self *ContainerProducerLegacyWire) Close() error func (self *ContainerProducerLegacyWire) Closed(ctx context.Context) error @@ -3663,7 +3662,7 @@ func (self *ContainerProducerLegacyWire) Estimate() (*CatalogEstimate, error) func (self *ContainerProducerLegacyWire) Fail(err *p_net.Error) (*ContainerFinishedLegacyWire, error) func (self *ContainerProducerLegacyWire) Finish() (*ContainerFinishedLegacyWire, error) func (self *ContainerProducerLegacyWire) Finished() (*p_net.TrackPosition, error) -func (self *ContainerProducerLegacyWire) History(until *p_net.Timestamp) error +func (self *ContainerProducerLegacyWire) History(until p_net.Timestamp) error func (self *ContainerProducerLegacyWire) Info() (*p_net.TrackInfo, error) func (self *ContainerProducerLegacyWire) IsClone(other_ *p_net.TrackProducer) (bool, error) func (self *ContainerProducerLegacyWire) IsClosed() (bool, error) @@ -3672,7 +3671,7 @@ func (self *ContainerProducerLegacyWire) LiveEdge() (*p_net.Timestamp, error) func (self *ContainerProducerLegacyWire) Modify() (*ContainerGuardUnit, error) func (self *ContainerProducerLegacyWire) Name() (string, error) func (self *ContainerProducerLegacyWire) NeedsKeyframe() (bool, error) -func (self *ContainerProducerLegacyWire) Reorder(delay *p_net.Timestamp) error +func (self *ContainerProducerLegacyWire) Reorder(delay p_net.Timestamp) error func (self *ContainerProducerLegacyWire) ReportBitrate(bitrate p_net.BandwidthRate) error func (self *ContainerProducerLegacyWire) ReportSkipped(frames uint64) error func (self *ContainerProducerLegacyWire) Requests() (*p_net.TrackRequests, error) @@ -3682,7 +3681,7 @@ func (self *ContainerProducerLegacyWire) SetBitrate(bitrate uint64) error func (self *ContainerProducerLegacyWire) SkipGroups(groups p_rt.RangeU64) error func (self *ContainerProducerLegacyWire) Subscribe(subscription *p_net.TrackSubscription) (*p_net.TrackSubscriber, error) func (self *ContainerProducerLegacyWire) Subscription() (*p_net.TrackSubscription, error) -func (self *ContainerProducerLegacyWire) Timestamp(hint *p_net.Timestamp) (*p_net.Timestamp, error) +func (self *ContainerProducerLegacyWire) Timestamp(hint *p_net.Timestamp) (p_net.Timestamp, error) func (self *ContainerProducerLegacyWire) Track() (*p_net.TrackProducer, error) func (self *ContainerProducerLegacyWire) WithBandwidth(allocator *p_net.BandwidthAllocator) (*ContainerProducerLegacyWire, error) func (self *ContainerProducerLegacyWire) WithBuffer(duration p_rt.Duration) (*ContainerProducerLegacyWire, error) @@ -3693,7 +3692,7 @@ type ContainerProducerLegacyWireAudioConfig struct { func (self *ContainerProducerLegacyWireAudioConfig) Abort(err *p_net.Error) error func (self *ContainerProducerLegacyWireAudioConfig) AbortHandle() (*p_net.TrackAbortHandle, error) func (self *ContainerProducerLegacyWireAudioConfig) AbortUnwanted(err *p_net.Error) error -func (self *ContainerProducerLegacyWireAudioConfig) AppendGroup(start *p_net.Timestamp) (*p_net.GroupProducer, error) +func (self *ContainerProducerLegacyWireAudioConfig) AppendGroup(start p_net.Timestamp) (*p_net.GroupProducer, error) func (self *ContainerProducerLegacyWireAudioConfig) Broadcast() (*p_net.BroadcastInfo, error) func (self *ContainerProducerLegacyWireAudioConfig) Close() error func (self *ContainerProducerLegacyWireAudioConfig) Closed(ctx context.Context) error @@ -3707,7 +3706,7 @@ func (self *ContainerProducerLegacyWireAudioConfig) Estimate() (*CatalogEstimate func (self *ContainerProducerLegacyWireAudioConfig) Fail(err *p_net.Error) (*ContainerFinishedLegacyWireAudioConfig, error) func (self *ContainerProducerLegacyWireAudioConfig) Finish() (*ContainerFinishedLegacyWireAudioConfig, error) func (self *ContainerProducerLegacyWireAudioConfig) Finished() (*p_net.TrackPosition, error) -func (self *ContainerProducerLegacyWireAudioConfig) History(until *p_net.Timestamp) error +func (self *ContainerProducerLegacyWireAudioConfig) History(until p_net.Timestamp) error func (self *ContainerProducerLegacyWireAudioConfig) Info() (*p_net.TrackInfo, error) func (self *ContainerProducerLegacyWireAudioConfig) IsClone(other_ *p_net.TrackProducer) (bool, error) func (self *ContainerProducerLegacyWireAudioConfig) IsClosed() (bool, error) @@ -3716,7 +3715,7 @@ func (self *ContainerProducerLegacyWireAudioConfig) LiveEdge() (*p_net.Timestamp func (self *ContainerProducerLegacyWireAudioConfig) Modify() (*ContainerGuardAudioConfig, error) func (self *ContainerProducerLegacyWireAudioConfig) Name() (string, error) func (self *ContainerProducerLegacyWireAudioConfig) NeedsKeyframe() (bool, error) -func (self *ContainerProducerLegacyWireAudioConfig) Reorder(delay *p_net.Timestamp) error +func (self *ContainerProducerLegacyWireAudioConfig) Reorder(delay p_net.Timestamp) error func (self *ContainerProducerLegacyWireAudioConfig) ReportBitrate(bitrate p_net.BandwidthRate) error func (self *ContainerProducerLegacyWireAudioConfig) ReportSkipped(frames uint64) error func (self *ContainerProducerLegacyWireAudioConfig) Requests() (*p_net.TrackRequests, error) @@ -3726,7 +3725,7 @@ func (self *ContainerProducerLegacyWireAudioConfig) SetBitrate(bitrate uint64) e func (self *ContainerProducerLegacyWireAudioConfig) SkipGroups(groups p_rt.RangeU64) error func (self *ContainerProducerLegacyWireAudioConfig) Subscribe(subscription *p_net.TrackSubscription) (*p_net.TrackSubscriber, error) func (self *ContainerProducerLegacyWireAudioConfig) Subscription() (*p_net.TrackSubscription, error) -func (self *ContainerProducerLegacyWireAudioConfig) Timestamp(hint *p_net.Timestamp) (*p_net.Timestamp, error) +func (self *ContainerProducerLegacyWireAudioConfig) Timestamp(hint *p_net.Timestamp) (p_net.Timestamp, error) func (self *ContainerProducerLegacyWireAudioConfig) Track() (*p_net.TrackProducer, error) func (self *ContainerProducerLegacyWireAudioConfig) WithBandwidth(allocator *p_net.BandwidthAllocator) (*ContainerProducerLegacyWireAudioConfig, error) func (self *ContainerProducerLegacyWireAudioConfig) WithBuffer(duration p_rt.Duration) (*ContainerProducerLegacyWireAudioConfig, error) @@ -3737,7 +3736,7 @@ type ContainerProducerLegacyWireBinaryConfig struct { func (self *ContainerProducerLegacyWireBinaryConfig) Abort(err *p_net.Error) error func (self *ContainerProducerLegacyWireBinaryConfig) AbortHandle() (*p_net.TrackAbortHandle, error) func (self *ContainerProducerLegacyWireBinaryConfig) AbortUnwanted(err *p_net.Error) error -func (self *ContainerProducerLegacyWireBinaryConfig) AppendGroup(start *p_net.Timestamp) (*p_net.GroupProducer, error) +func (self *ContainerProducerLegacyWireBinaryConfig) AppendGroup(start p_net.Timestamp) (*p_net.GroupProducer, error) func (self *ContainerProducerLegacyWireBinaryConfig) Broadcast() (*p_net.BroadcastInfo, error) func (self *ContainerProducerLegacyWireBinaryConfig) Close() error func (self *ContainerProducerLegacyWireBinaryConfig) Closed(ctx context.Context) error @@ -3751,7 +3750,7 @@ func (self *ContainerProducerLegacyWireBinaryConfig) Estimate() (*CatalogEstimat func (self *ContainerProducerLegacyWireBinaryConfig) Fail(err *p_net.Error) (*ContainerFinishedLegacyWireBinaryConfig, error) func (self *ContainerProducerLegacyWireBinaryConfig) Finish() (*ContainerFinishedLegacyWireBinaryConfig, error) func (self *ContainerProducerLegacyWireBinaryConfig) Finished() (*p_net.TrackPosition, error) -func (self *ContainerProducerLegacyWireBinaryConfig) History(until *p_net.Timestamp) error +func (self *ContainerProducerLegacyWireBinaryConfig) History(until p_net.Timestamp) error func (self *ContainerProducerLegacyWireBinaryConfig) Info() (*p_net.TrackInfo, error) func (self *ContainerProducerLegacyWireBinaryConfig) IsClone(other_ *p_net.TrackProducer) (bool, error) func (self *ContainerProducerLegacyWireBinaryConfig) IsClosed() (bool, error) @@ -3760,7 +3759,7 @@ func (self *ContainerProducerLegacyWireBinaryConfig) LiveEdge() (*p_net.Timestam func (self *ContainerProducerLegacyWireBinaryConfig) Modify() (*ContainerGuardBinaryConfig, error) func (self *ContainerProducerLegacyWireBinaryConfig) Name() (string, error) func (self *ContainerProducerLegacyWireBinaryConfig) NeedsKeyframe() (bool, error) -func (self *ContainerProducerLegacyWireBinaryConfig) Reorder(delay *p_net.Timestamp) error +func (self *ContainerProducerLegacyWireBinaryConfig) Reorder(delay p_net.Timestamp) error func (self *ContainerProducerLegacyWireBinaryConfig) ReportBitrate(bitrate p_net.BandwidthRate) error func (self *ContainerProducerLegacyWireBinaryConfig) ReportSkipped(frames uint64) error func (self *ContainerProducerLegacyWireBinaryConfig) Requests() (*p_net.TrackRequests, error) @@ -3770,7 +3769,7 @@ func (self *ContainerProducerLegacyWireBinaryConfig) SetBitrate(bitrate uint64) func (self *ContainerProducerLegacyWireBinaryConfig) SkipGroups(groups p_rt.RangeU64) error func (self *ContainerProducerLegacyWireBinaryConfig) Subscribe(subscription *p_net.TrackSubscription) (*p_net.TrackSubscriber, error) func (self *ContainerProducerLegacyWireBinaryConfig) Subscription() (*p_net.TrackSubscription, error) -func (self *ContainerProducerLegacyWireBinaryConfig) Timestamp(hint *p_net.Timestamp) (*p_net.Timestamp, error) +func (self *ContainerProducerLegacyWireBinaryConfig) Timestamp(hint *p_net.Timestamp) (p_net.Timestamp, error) func (self *ContainerProducerLegacyWireBinaryConfig) Track() (*p_net.TrackProducer, error) func (self *ContainerProducerLegacyWireBinaryConfig) WithBandwidth(allocator *p_net.BandwidthAllocator) (*ContainerProducerLegacyWireBinaryConfig, error) func (self *ContainerProducerLegacyWireBinaryConfig) WithBuffer(duration p_rt.Duration) (*ContainerProducerLegacyWireBinaryConfig, error) @@ -3781,7 +3780,7 @@ type ContainerProducerLegacyWireJsonConfig struct { func (self *ContainerProducerLegacyWireJsonConfig) Abort(err *p_net.Error) error func (self *ContainerProducerLegacyWireJsonConfig) AbortHandle() (*p_net.TrackAbortHandle, error) func (self *ContainerProducerLegacyWireJsonConfig) AbortUnwanted(err *p_net.Error) error -func (self *ContainerProducerLegacyWireJsonConfig) AppendGroup(start *p_net.Timestamp) (*p_net.GroupProducer, error) +func (self *ContainerProducerLegacyWireJsonConfig) AppendGroup(start p_net.Timestamp) (*p_net.GroupProducer, error) func (self *ContainerProducerLegacyWireJsonConfig) Broadcast() (*p_net.BroadcastInfo, error) func (self *ContainerProducerLegacyWireJsonConfig) Close() error func (self *ContainerProducerLegacyWireJsonConfig) Closed(ctx context.Context) error @@ -3795,7 +3794,7 @@ func (self *ContainerProducerLegacyWireJsonConfig) Estimate() (*CatalogEstimate, func (self *ContainerProducerLegacyWireJsonConfig) Fail(err *p_net.Error) (*ContainerFinishedLegacyWireJsonConfig, error) func (self *ContainerProducerLegacyWireJsonConfig) Finish() (*ContainerFinishedLegacyWireJsonConfig, error) func (self *ContainerProducerLegacyWireJsonConfig) Finished() (*p_net.TrackPosition, error) -func (self *ContainerProducerLegacyWireJsonConfig) History(until *p_net.Timestamp) error +func (self *ContainerProducerLegacyWireJsonConfig) History(until p_net.Timestamp) error func (self *ContainerProducerLegacyWireJsonConfig) Info() (*p_net.TrackInfo, error) func (self *ContainerProducerLegacyWireJsonConfig) IsClone(other_ *p_net.TrackProducer) (bool, error) func (self *ContainerProducerLegacyWireJsonConfig) IsClosed() (bool, error) @@ -3804,7 +3803,7 @@ func (self *ContainerProducerLegacyWireJsonConfig) LiveEdge() (*p_net.Timestamp, func (self *ContainerProducerLegacyWireJsonConfig) Modify() (*ContainerGuardJsonConfig, error) func (self *ContainerProducerLegacyWireJsonConfig) Name() (string, error) func (self *ContainerProducerLegacyWireJsonConfig) NeedsKeyframe() (bool, error) -func (self *ContainerProducerLegacyWireJsonConfig) Reorder(delay *p_net.Timestamp) error +func (self *ContainerProducerLegacyWireJsonConfig) Reorder(delay p_net.Timestamp) error func (self *ContainerProducerLegacyWireJsonConfig) ReportBitrate(bitrate p_net.BandwidthRate) error func (self *ContainerProducerLegacyWireJsonConfig) ReportSkipped(frames uint64) error func (self *ContainerProducerLegacyWireJsonConfig) Requests() (*p_net.TrackRequests, error) @@ -3814,7 +3813,7 @@ func (self *ContainerProducerLegacyWireJsonConfig) SetBitrate(bitrate uint64) er func (self *ContainerProducerLegacyWireJsonConfig) SkipGroups(groups p_rt.RangeU64) error func (self *ContainerProducerLegacyWireJsonConfig) Subscribe(subscription *p_net.TrackSubscription) (*p_net.TrackSubscriber, error) func (self *ContainerProducerLegacyWireJsonConfig) Subscription() (*p_net.TrackSubscription, error) -func (self *ContainerProducerLegacyWireJsonConfig) Timestamp(hint *p_net.Timestamp) (*p_net.Timestamp, error) +func (self *ContainerProducerLegacyWireJsonConfig) Timestamp(hint *p_net.Timestamp) (p_net.Timestamp, error) func (self *ContainerProducerLegacyWireJsonConfig) Track() (*p_net.TrackProducer, error) func (self *ContainerProducerLegacyWireJsonConfig) WithBandwidth(allocator *p_net.BandwidthAllocator) (*ContainerProducerLegacyWireJsonConfig, error) func (self *ContainerProducerLegacyWireJsonConfig) WithBuffer(duration p_rt.Duration) (*ContainerProducerLegacyWireJsonConfig, error) @@ -3825,7 +3824,7 @@ type ContainerProducerLegacyWireTextConfig struct { func (self *ContainerProducerLegacyWireTextConfig) Abort(err *p_net.Error) error func (self *ContainerProducerLegacyWireTextConfig) AbortHandle() (*p_net.TrackAbortHandle, error) func (self *ContainerProducerLegacyWireTextConfig) AbortUnwanted(err *p_net.Error) error -func (self *ContainerProducerLegacyWireTextConfig) AppendGroup(start *p_net.Timestamp) (*p_net.GroupProducer, error) +func (self *ContainerProducerLegacyWireTextConfig) AppendGroup(start p_net.Timestamp) (*p_net.GroupProducer, error) func (self *ContainerProducerLegacyWireTextConfig) Broadcast() (*p_net.BroadcastInfo, error) func (self *ContainerProducerLegacyWireTextConfig) Close() error func (self *ContainerProducerLegacyWireTextConfig) Closed(ctx context.Context) error @@ -3839,7 +3838,7 @@ func (self *ContainerProducerLegacyWireTextConfig) Estimate() (*CatalogEstimate, func (self *ContainerProducerLegacyWireTextConfig) Fail(err *p_net.Error) (*ContainerFinishedLegacyWireTextConfig, error) func (self *ContainerProducerLegacyWireTextConfig) Finish() (*ContainerFinishedLegacyWireTextConfig, error) func (self *ContainerProducerLegacyWireTextConfig) Finished() (*p_net.TrackPosition, error) -func (self *ContainerProducerLegacyWireTextConfig) History(until *p_net.Timestamp) error +func (self *ContainerProducerLegacyWireTextConfig) History(until p_net.Timestamp) error func (self *ContainerProducerLegacyWireTextConfig) Info() (*p_net.TrackInfo, error) func (self *ContainerProducerLegacyWireTextConfig) IsClone(other_ *p_net.TrackProducer) (bool, error) func (self *ContainerProducerLegacyWireTextConfig) IsClosed() (bool, error) @@ -3848,7 +3847,7 @@ func (self *ContainerProducerLegacyWireTextConfig) LiveEdge() (*p_net.Timestamp, func (self *ContainerProducerLegacyWireTextConfig) Modify() (*ContainerGuardTextConfig, error) func (self *ContainerProducerLegacyWireTextConfig) Name() (string, error) func (self *ContainerProducerLegacyWireTextConfig) NeedsKeyframe() (bool, error) -func (self *ContainerProducerLegacyWireTextConfig) Reorder(delay *p_net.Timestamp) error +func (self *ContainerProducerLegacyWireTextConfig) Reorder(delay p_net.Timestamp) error func (self *ContainerProducerLegacyWireTextConfig) ReportBitrate(bitrate p_net.BandwidthRate) error func (self *ContainerProducerLegacyWireTextConfig) ReportSkipped(frames uint64) error func (self *ContainerProducerLegacyWireTextConfig) Requests() (*p_net.TrackRequests, error) @@ -3858,7 +3857,7 @@ func (self *ContainerProducerLegacyWireTextConfig) SetBitrate(bitrate uint64) er func (self *ContainerProducerLegacyWireTextConfig) SkipGroups(groups p_rt.RangeU64) error func (self *ContainerProducerLegacyWireTextConfig) Subscribe(subscription *p_net.TrackSubscription) (*p_net.TrackSubscriber, error) func (self *ContainerProducerLegacyWireTextConfig) Subscription() (*p_net.TrackSubscription, error) -func (self *ContainerProducerLegacyWireTextConfig) Timestamp(hint *p_net.Timestamp) (*p_net.Timestamp, error) +func (self *ContainerProducerLegacyWireTextConfig) Timestamp(hint *p_net.Timestamp) (p_net.Timestamp, error) func (self *ContainerProducerLegacyWireTextConfig) Track() (*p_net.TrackProducer, error) func (self *ContainerProducerLegacyWireTextConfig) WithBandwidth(allocator *p_net.BandwidthAllocator) (*ContainerProducerLegacyWireTextConfig, error) func (self *ContainerProducerLegacyWireTextConfig) WithBuffer(duration p_rt.Duration) (*ContainerProducerLegacyWireTextConfig, error) @@ -3869,7 +3868,7 @@ type ContainerProducerLegacyWireVideoConfig struct { func (self *ContainerProducerLegacyWireVideoConfig) Abort(err *p_net.Error) error func (self *ContainerProducerLegacyWireVideoConfig) AbortHandle() (*p_net.TrackAbortHandle, error) func (self *ContainerProducerLegacyWireVideoConfig) AbortUnwanted(err *p_net.Error) error -func (self *ContainerProducerLegacyWireVideoConfig) AppendGroup(start *p_net.Timestamp) (*p_net.GroupProducer, error) +func (self *ContainerProducerLegacyWireVideoConfig) AppendGroup(start p_net.Timestamp) (*p_net.GroupProducer, error) func (self *ContainerProducerLegacyWireVideoConfig) Broadcast() (*p_net.BroadcastInfo, error) func (self *ContainerProducerLegacyWireVideoConfig) Close() error func (self *ContainerProducerLegacyWireVideoConfig) Closed(ctx context.Context) error @@ -3883,7 +3882,7 @@ func (self *ContainerProducerLegacyWireVideoConfig) Estimate() (*CatalogEstimate func (self *ContainerProducerLegacyWireVideoConfig) Fail(err *p_net.Error) (*ContainerFinishedLegacyWireVideoConfig, error) func (self *ContainerProducerLegacyWireVideoConfig) Finish() (*ContainerFinishedLegacyWireVideoConfig, error) func (self *ContainerProducerLegacyWireVideoConfig) Finished() (*p_net.TrackPosition, error) -func (self *ContainerProducerLegacyWireVideoConfig) History(until *p_net.Timestamp) error +func (self *ContainerProducerLegacyWireVideoConfig) History(until p_net.Timestamp) error func (self *ContainerProducerLegacyWireVideoConfig) Info() (*p_net.TrackInfo, error) func (self *ContainerProducerLegacyWireVideoConfig) IsClone(other_ *p_net.TrackProducer) (bool, error) func (self *ContainerProducerLegacyWireVideoConfig) IsClosed() (bool, error) @@ -3892,7 +3891,7 @@ func (self *ContainerProducerLegacyWireVideoConfig) LiveEdge() (*p_net.Timestamp func (self *ContainerProducerLegacyWireVideoConfig) Modify() (*ContainerGuardVideoConfig, error) func (self *ContainerProducerLegacyWireVideoConfig) Name() (string, error) func (self *ContainerProducerLegacyWireVideoConfig) NeedsKeyframe() (bool, error) -func (self *ContainerProducerLegacyWireVideoConfig) Reorder(delay *p_net.Timestamp) error +func (self *ContainerProducerLegacyWireVideoConfig) Reorder(delay p_net.Timestamp) error func (self *ContainerProducerLegacyWireVideoConfig) ReportBitrate(bitrate p_net.BandwidthRate) error func (self *ContainerProducerLegacyWireVideoConfig) ReportSkipped(frames uint64) error func (self *ContainerProducerLegacyWireVideoConfig) Requests() (*p_net.TrackRequests, error) @@ -3902,7 +3901,7 @@ func (self *ContainerProducerLegacyWireVideoConfig) SetBitrate(bitrate uint64) e func (self *ContainerProducerLegacyWireVideoConfig) SkipGroups(groups p_rt.RangeU64) error func (self *ContainerProducerLegacyWireVideoConfig) Subscribe(subscription *p_net.TrackSubscription) (*p_net.TrackSubscriber, error) func (self *ContainerProducerLegacyWireVideoConfig) Subscription() (*p_net.TrackSubscription, error) -func (self *ContainerProducerLegacyWireVideoConfig) Timestamp(hint *p_net.Timestamp) (*p_net.Timestamp, error) +func (self *ContainerProducerLegacyWireVideoConfig) Timestamp(hint *p_net.Timestamp) (p_net.Timestamp, error) func (self *ContainerProducerLegacyWireVideoConfig) Track() (*p_net.TrackProducer, error) func (self *ContainerProducerLegacyWireVideoConfig) WithBandwidth(allocator *p_net.BandwidthAllocator) (*ContainerProducerLegacyWireVideoConfig, error) func (self *ContainerProducerLegacyWireVideoConfig) WithBuffer(duration p_rt.Duration) (*ContainerProducerLegacyWireVideoConfig, error) @@ -3914,7 +3913,7 @@ func NewContainerProducerLocWire(track *p_net.TrackProducer, container Container func (self *ContainerProducerLocWire) Abort(err *p_net.Error) error func (self *ContainerProducerLocWire) AbortHandle() (*p_net.TrackAbortHandle, error) func (self *ContainerProducerLocWire) AbortUnwanted(err *p_net.Error) error -func (self *ContainerProducerLocWire) AppendGroup(start *p_net.Timestamp) (*p_net.GroupProducer, error) +func (self *ContainerProducerLocWire) AppendGroup(start p_net.Timestamp) (*p_net.GroupProducer, error) func (self *ContainerProducerLocWire) Broadcast() (*p_net.BroadcastInfo, error) func (self *ContainerProducerLocWire) Close() error func (self *ContainerProducerLocWire) Closed(ctx context.Context) error @@ -3928,7 +3927,7 @@ func (self *ContainerProducerLocWire) Estimate() (*CatalogEstimate, error) func (self *ContainerProducerLocWire) Fail(err *p_net.Error) (*ContainerFinishedLocWire, error) func (self *ContainerProducerLocWire) Finish() (*ContainerFinishedLocWire, error) func (self *ContainerProducerLocWire) Finished() (*p_net.TrackPosition, error) -func (self *ContainerProducerLocWire) History(until *p_net.Timestamp) error +func (self *ContainerProducerLocWire) History(until p_net.Timestamp) error func (self *ContainerProducerLocWire) Info() (*p_net.TrackInfo, error) func (self *ContainerProducerLocWire) IsClone(other_ *p_net.TrackProducer) (bool, error) func (self *ContainerProducerLocWire) IsClosed() (bool, error) @@ -3937,7 +3936,7 @@ func (self *ContainerProducerLocWire) LiveEdge() (*p_net.Timestamp, error) func (self *ContainerProducerLocWire) Modify() (*ContainerGuardUnit, error) func (self *ContainerProducerLocWire) Name() (string, error) func (self *ContainerProducerLocWire) NeedsKeyframe() (bool, error) -func (self *ContainerProducerLocWire) Reorder(delay *p_net.Timestamp) error +func (self *ContainerProducerLocWire) Reorder(delay p_net.Timestamp) error func (self *ContainerProducerLocWire) ReportBitrate(bitrate p_net.BandwidthRate) error func (self *ContainerProducerLocWire) ReportSkipped(frames uint64) error func (self *ContainerProducerLocWire) Requests() (*p_net.TrackRequests, error) @@ -3947,7 +3946,7 @@ func (self *ContainerProducerLocWire) SetBitrate(bitrate uint64) error func (self *ContainerProducerLocWire) SkipGroups(groups p_rt.RangeU64) error func (self *ContainerProducerLocWire) Subscribe(subscription *p_net.TrackSubscription) (*p_net.TrackSubscriber, error) func (self *ContainerProducerLocWire) Subscription() (*p_net.TrackSubscription, error) -func (self *ContainerProducerLocWire) Timestamp(hint *p_net.Timestamp) (*p_net.Timestamp, error) +func (self *ContainerProducerLocWire) Timestamp(hint *p_net.Timestamp) (p_net.Timestamp, error) func (self *ContainerProducerLocWire) Track() (*p_net.TrackProducer, error) func (self *ContainerProducerLocWire) WithBandwidth(allocator *p_net.BandwidthAllocator) (*ContainerProducerLocWire, error) func (self *ContainerProducerLocWire) WithBuffer(duration p_rt.Duration) (*ContainerProducerLocWire, error) @@ -3958,7 +3957,7 @@ type ContainerProducerLocWireAudioConfig struct { func (self *ContainerProducerLocWireAudioConfig) Abort(err *p_net.Error) error func (self *ContainerProducerLocWireAudioConfig) AbortHandle() (*p_net.TrackAbortHandle, error) func (self *ContainerProducerLocWireAudioConfig) AbortUnwanted(err *p_net.Error) error -func (self *ContainerProducerLocWireAudioConfig) AppendGroup(start *p_net.Timestamp) (*p_net.GroupProducer, error) +func (self *ContainerProducerLocWireAudioConfig) AppendGroup(start p_net.Timestamp) (*p_net.GroupProducer, error) func (self *ContainerProducerLocWireAudioConfig) Broadcast() (*p_net.BroadcastInfo, error) func (self *ContainerProducerLocWireAudioConfig) Close() error func (self *ContainerProducerLocWireAudioConfig) Closed(ctx context.Context) error @@ -3972,7 +3971,7 @@ func (self *ContainerProducerLocWireAudioConfig) Estimate() (*CatalogEstimate, e func (self *ContainerProducerLocWireAudioConfig) Fail(err *p_net.Error) (*ContainerFinishedLocWireAudioConfig, error) func (self *ContainerProducerLocWireAudioConfig) Finish() (*ContainerFinishedLocWireAudioConfig, error) func (self *ContainerProducerLocWireAudioConfig) Finished() (*p_net.TrackPosition, error) -func (self *ContainerProducerLocWireAudioConfig) History(until *p_net.Timestamp) error +func (self *ContainerProducerLocWireAudioConfig) History(until p_net.Timestamp) error func (self *ContainerProducerLocWireAudioConfig) Info() (*p_net.TrackInfo, error) func (self *ContainerProducerLocWireAudioConfig) IsClone(other_ *p_net.TrackProducer) (bool, error) func (self *ContainerProducerLocWireAudioConfig) IsClosed() (bool, error) @@ -3981,7 +3980,7 @@ func (self *ContainerProducerLocWireAudioConfig) LiveEdge() (*p_net.Timestamp, e func (self *ContainerProducerLocWireAudioConfig) Modify() (*ContainerGuardAudioConfig, error) func (self *ContainerProducerLocWireAudioConfig) Name() (string, error) func (self *ContainerProducerLocWireAudioConfig) NeedsKeyframe() (bool, error) -func (self *ContainerProducerLocWireAudioConfig) Reorder(delay *p_net.Timestamp) error +func (self *ContainerProducerLocWireAudioConfig) Reorder(delay p_net.Timestamp) error func (self *ContainerProducerLocWireAudioConfig) ReportBitrate(bitrate p_net.BandwidthRate) error func (self *ContainerProducerLocWireAudioConfig) ReportSkipped(frames uint64) error func (self *ContainerProducerLocWireAudioConfig) Requests() (*p_net.TrackRequests, error) @@ -3991,7 +3990,7 @@ func (self *ContainerProducerLocWireAudioConfig) SetBitrate(bitrate uint64) erro func (self *ContainerProducerLocWireAudioConfig) SkipGroups(groups p_rt.RangeU64) error func (self *ContainerProducerLocWireAudioConfig) Subscribe(subscription *p_net.TrackSubscription) (*p_net.TrackSubscriber, error) func (self *ContainerProducerLocWireAudioConfig) Subscription() (*p_net.TrackSubscription, error) -func (self *ContainerProducerLocWireAudioConfig) Timestamp(hint *p_net.Timestamp) (*p_net.Timestamp, error) +func (self *ContainerProducerLocWireAudioConfig) Timestamp(hint *p_net.Timestamp) (p_net.Timestamp, error) func (self *ContainerProducerLocWireAudioConfig) Track() (*p_net.TrackProducer, error) func (self *ContainerProducerLocWireAudioConfig) WithBandwidth(allocator *p_net.BandwidthAllocator) (*ContainerProducerLocWireAudioConfig, error) func (self *ContainerProducerLocWireAudioConfig) WithBuffer(duration p_rt.Duration) (*ContainerProducerLocWireAudioConfig, error) @@ -4002,7 +4001,7 @@ type ContainerProducerLocWireBinaryConfig struct { func (self *ContainerProducerLocWireBinaryConfig) Abort(err *p_net.Error) error func (self *ContainerProducerLocWireBinaryConfig) AbortHandle() (*p_net.TrackAbortHandle, error) func (self *ContainerProducerLocWireBinaryConfig) AbortUnwanted(err *p_net.Error) error -func (self *ContainerProducerLocWireBinaryConfig) AppendGroup(start *p_net.Timestamp) (*p_net.GroupProducer, error) +func (self *ContainerProducerLocWireBinaryConfig) AppendGroup(start p_net.Timestamp) (*p_net.GroupProducer, error) func (self *ContainerProducerLocWireBinaryConfig) Broadcast() (*p_net.BroadcastInfo, error) func (self *ContainerProducerLocWireBinaryConfig) Close() error func (self *ContainerProducerLocWireBinaryConfig) Closed(ctx context.Context) error @@ -4016,7 +4015,7 @@ func (self *ContainerProducerLocWireBinaryConfig) Estimate() (*CatalogEstimate, func (self *ContainerProducerLocWireBinaryConfig) Fail(err *p_net.Error) (*ContainerFinishedLocWireBinaryConfig, error) func (self *ContainerProducerLocWireBinaryConfig) Finish() (*ContainerFinishedLocWireBinaryConfig, error) func (self *ContainerProducerLocWireBinaryConfig) Finished() (*p_net.TrackPosition, error) -func (self *ContainerProducerLocWireBinaryConfig) History(until *p_net.Timestamp) error +func (self *ContainerProducerLocWireBinaryConfig) History(until p_net.Timestamp) error func (self *ContainerProducerLocWireBinaryConfig) Info() (*p_net.TrackInfo, error) func (self *ContainerProducerLocWireBinaryConfig) IsClone(other_ *p_net.TrackProducer) (bool, error) func (self *ContainerProducerLocWireBinaryConfig) IsClosed() (bool, error) @@ -4025,7 +4024,7 @@ func (self *ContainerProducerLocWireBinaryConfig) LiveEdge() (*p_net.Timestamp, func (self *ContainerProducerLocWireBinaryConfig) Modify() (*ContainerGuardBinaryConfig, error) func (self *ContainerProducerLocWireBinaryConfig) Name() (string, error) func (self *ContainerProducerLocWireBinaryConfig) NeedsKeyframe() (bool, error) -func (self *ContainerProducerLocWireBinaryConfig) Reorder(delay *p_net.Timestamp) error +func (self *ContainerProducerLocWireBinaryConfig) Reorder(delay p_net.Timestamp) error func (self *ContainerProducerLocWireBinaryConfig) ReportBitrate(bitrate p_net.BandwidthRate) error func (self *ContainerProducerLocWireBinaryConfig) ReportSkipped(frames uint64) error func (self *ContainerProducerLocWireBinaryConfig) Requests() (*p_net.TrackRequests, error) @@ -4035,7 +4034,7 @@ func (self *ContainerProducerLocWireBinaryConfig) SetBitrate(bitrate uint64) err func (self *ContainerProducerLocWireBinaryConfig) SkipGroups(groups p_rt.RangeU64) error func (self *ContainerProducerLocWireBinaryConfig) Subscribe(subscription *p_net.TrackSubscription) (*p_net.TrackSubscriber, error) func (self *ContainerProducerLocWireBinaryConfig) Subscription() (*p_net.TrackSubscription, error) -func (self *ContainerProducerLocWireBinaryConfig) Timestamp(hint *p_net.Timestamp) (*p_net.Timestamp, error) +func (self *ContainerProducerLocWireBinaryConfig) Timestamp(hint *p_net.Timestamp) (p_net.Timestamp, error) func (self *ContainerProducerLocWireBinaryConfig) Track() (*p_net.TrackProducer, error) func (self *ContainerProducerLocWireBinaryConfig) WithBandwidth(allocator *p_net.BandwidthAllocator) (*ContainerProducerLocWireBinaryConfig, error) func (self *ContainerProducerLocWireBinaryConfig) WithBuffer(duration p_rt.Duration) (*ContainerProducerLocWireBinaryConfig, error) @@ -4046,7 +4045,7 @@ type ContainerProducerLocWireJsonConfig struct { func (self *ContainerProducerLocWireJsonConfig) Abort(err *p_net.Error) error func (self *ContainerProducerLocWireJsonConfig) AbortHandle() (*p_net.TrackAbortHandle, error) func (self *ContainerProducerLocWireJsonConfig) AbortUnwanted(err *p_net.Error) error -func (self *ContainerProducerLocWireJsonConfig) AppendGroup(start *p_net.Timestamp) (*p_net.GroupProducer, error) +func (self *ContainerProducerLocWireJsonConfig) AppendGroup(start p_net.Timestamp) (*p_net.GroupProducer, error) func (self *ContainerProducerLocWireJsonConfig) Broadcast() (*p_net.BroadcastInfo, error) func (self *ContainerProducerLocWireJsonConfig) Close() error func (self *ContainerProducerLocWireJsonConfig) Closed(ctx context.Context) error @@ -4060,7 +4059,7 @@ func (self *ContainerProducerLocWireJsonConfig) Estimate() (*CatalogEstimate, er func (self *ContainerProducerLocWireJsonConfig) Fail(err *p_net.Error) (*ContainerFinishedLocWireJsonConfig, error) func (self *ContainerProducerLocWireJsonConfig) Finish() (*ContainerFinishedLocWireJsonConfig, error) func (self *ContainerProducerLocWireJsonConfig) Finished() (*p_net.TrackPosition, error) -func (self *ContainerProducerLocWireJsonConfig) History(until *p_net.Timestamp) error +func (self *ContainerProducerLocWireJsonConfig) History(until p_net.Timestamp) error func (self *ContainerProducerLocWireJsonConfig) Info() (*p_net.TrackInfo, error) func (self *ContainerProducerLocWireJsonConfig) IsClone(other_ *p_net.TrackProducer) (bool, error) func (self *ContainerProducerLocWireJsonConfig) IsClosed() (bool, error) @@ -4069,7 +4068,7 @@ func (self *ContainerProducerLocWireJsonConfig) LiveEdge() (*p_net.Timestamp, er func (self *ContainerProducerLocWireJsonConfig) Modify() (*ContainerGuardJsonConfig, error) func (self *ContainerProducerLocWireJsonConfig) Name() (string, error) func (self *ContainerProducerLocWireJsonConfig) NeedsKeyframe() (bool, error) -func (self *ContainerProducerLocWireJsonConfig) Reorder(delay *p_net.Timestamp) error +func (self *ContainerProducerLocWireJsonConfig) Reorder(delay p_net.Timestamp) error func (self *ContainerProducerLocWireJsonConfig) ReportBitrate(bitrate p_net.BandwidthRate) error func (self *ContainerProducerLocWireJsonConfig) ReportSkipped(frames uint64) error func (self *ContainerProducerLocWireJsonConfig) Requests() (*p_net.TrackRequests, error) @@ -4079,7 +4078,7 @@ func (self *ContainerProducerLocWireJsonConfig) SetBitrate(bitrate uint64) error func (self *ContainerProducerLocWireJsonConfig) SkipGroups(groups p_rt.RangeU64) error func (self *ContainerProducerLocWireJsonConfig) Subscribe(subscription *p_net.TrackSubscription) (*p_net.TrackSubscriber, error) func (self *ContainerProducerLocWireJsonConfig) Subscription() (*p_net.TrackSubscription, error) -func (self *ContainerProducerLocWireJsonConfig) Timestamp(hint *p_net.Timestamp) (*p_net.Timestamp, error) +func (self *ContainerProducerLocWireJsonConfig) Timestamp(hint *p_net.Timestamp) (p_net.Timestamp, error) func (self *ContainerProducerLocWireJsonConfig) Track() (*p_net.TrackProducer, error) func (self *ContainerProducerLocWireJsonConfig) WithBandwidth(allocator *p_net.BandwidthAllocator) (*ContainerProducerLocWireJsonConfig, error) func (self *ContainerProducerLocWireJsonConfig) WithBuffer(duration p_rt.Duration) (*ContainerProducerLocWireJsonConfig, error) @@ -4090,7 +4089,7 @@ type ContainerProducerLocWireTextConfig struct { func (self *ContainerProducerLocWireTextConfig) Abort(err *p_net.Error) error func (self *ContainerProducerLocWireTextConfig) AbortHandle() (*p_net.TrackAbortHandle, error) func (self *ContainerProducerLocWireTextConfig) AbortUnwanted(err *p_net.Error) error -func (self *ContainerProducerLocWireTextConfig) AppendGroup(start *p_net.Timestamp) (*p_net.GroupProducer, error) +func (self *ContainerProducerLocWireTextConfig) AppendGroup(start p_net.Timestamp) (*p_net.GroupProducer, error) func (self *ContainerProducerLocWireTextConfig) Broadcast() (*p_net.BroadcastInfo, error) func (self *ContainerProducerLocWireTextConfig) Close() error func (self *ContainerProducerLocWireTextConfig) Closed(ctx context.Context) error @@ -4104,7 +4103,7 @@ func (self *ContainerProducerLocWireTextConfig) Estimate() (*CatalogEstimate, er func (self *ContainerProducerLocWireTextConfig) Fail(err *p_net.Error) (*ContainerFinishedLocWireTextConfig, error) func (self *ContainerProducerLocWireTextConfig) Finish() (*ContainerFinishedLocWireTextConfig, error) func (self *ContainerProducerLocWireTextConfig) Finished() (*p_net.TrackPosition, error) -func (self *ContainerProducerLocWireTextConfig) History(until *p_net.Timestamp) error +func (self *ContainerProducerLocWireTextConfig) History(until p_net.Timestamp) error func (self *ContainerProducerLocWireTextConfig) Info() (*p_net.TrackInfo, error) func (self *ContainerProducerLocWireTextConfig) IsClone(other_ *p_net.TrackProducer) (bool, error) func (self *ContainerProducerLocWireTextConfig) IsClosed() (bool, error) @@ -4113,7 +4112,7 @@ func (self *ContainerProducerLocWireTextConfig) LiveEdge() (*p_net.Timestamp, er func (self *ContainerProducerLocWireTextConfig) Modify() (*ContainerGuardTextConfig, error) func (self *ContainerProducerLocWireTextConfig) Name() (string, error) func (self *ContainerProducerLocWireTextConfig) NeedsKeyframe() (bool, error) -func (self *ContainerProducerLocWireTextConfig) Reorder(delay *p_net.Timestamp) error +func (self *ContainerProducerLocWireTextConfig) Reorder(delay p_net.Timestamp) error func (self *ContainerProducerLocWireTextConfig) ReportBitrate(bitrate p_net.BandwidthRate) error func (self *ContainerProducerLocWireTextConfig) ReportSkipped(frames uint64) error func (self *ContainerProducerLocWireTextConfig) Requests() (*p_net.TrackRequests, error) @@ -4123,7 +4122,7 @@ func (self *ContainerProducerLocWireTextConfig) SetBitrate(bitrate uint64) error func (self *ContainerProducerLocWireTextConfig) SkipGroups(groups p_rt.RangeU64) error func (self *ContainerProducerLocWireTextConfig) Subscribe(subscription *p_net.TrackSubscription) (*p_net.TrackSubscriber, error) func (self *ContainerProducerLocWireTextConfig) Subscription() (*p_net.TrackSubscription, error) -func (self *ContainerProducerLocWireTextConfig) Timestamp(hint *p_net.Timestamp) (*p_net.Timestamp, error) +func (self *ContainerProducerLocWireTextConfig) Timestamp(hint *p_net.Timestamp) (p_net.Timestamp, error) func (self *ContainerProducerLocWireTextConfig) Track() (*p_net.TrackProducer, error) func (self *ContainerProducerLocWireTextConfig) WithBandwidth(allocator *p_net.BandwidthAllocator) (*ContainerProducerLocWireTextConfig, error) func (self *ContainerProducerLocWireTextConfig) WithBuffer(duration p_rt.Duration) (*ContainerProducerLocWireTextConfig, error) @@ -4134,7 +4133,7 @@ type ContainerProducerLocWireVideoConfig struct { func (self *ContainerProducerLocWireVideoConfig) Abort(err *p_net.Error) error func (self *ContainerProducerLocWireVideoConfig) AbortHandle() (*p_net.TrackAbortHandle, error) func (self *ContainerProducerLocWireVideoConfig) AbortUnwanted(err *p_net.Error) error -func (self *ContainerProducerLocWireVideoConfig) AppendGroup(start *p_net.Timestamp) (*p_net.GroupProducer, error) +func (self *ContainerProducerLocWireVideoConfig) AppendGroup(start p_net.Timestamp) (*p_net.GroupProducer, error) func (self *ContainerProducerLocWireVideoConfig) Broadcast() (*p_net.BroadcastInfo, error) func (self *ContainerProducerLocWireVideoConfig) Close() error func (self *ContainerProducerLocWireVideoConfig) Closed(ctx context.Context) error @@ -4148,7 +4147,7 @@ func (self *ContainerProducerLocWireVideoConfig) Estimate() (*CatalogEstimate, e func (self *ContainerProducerLocWireVideoConfig) Fail(err *p_net.Error) (*ContainerFinishedLocWireVideoConfig, error) func (self *ContainerProducerLocWireVideoConfig) Finish() (*ContainerFinishedLocWireVideoConfig, error) func (self *ContainerProducerLocWireVideoConfig) Finished() (*p_net.TrackPosition, error) -func (self *ContainerProducerLocWireVideoConfig) History(until *p_net.Timestamp) error +func (self *ContainerProducerLocWireVideoConfig) History(until p_net.Timestamp) error func (self *ContainerProducerLocWireVideoConfig) Info() (*p_net.TrackInfo, error) func (self *ContainerProducerLocWireVideoConfig) IsClone(other_ *p_net.TrackProducer) (bool, error) func (self *ContainerProducerLocWireVideoConfig) IsClosed() (bool, error) @@ -4157,7 +4156,7 @@ func (self *ContainerProducerLocWireVideoConfig) LiveEdge() (*p_net.Timestamp, e func (self *ContainerProducerLocWireVideoConfig) Modify() (*ContainerGuardVideoConfig, error) func (self *ContainerProducerLocWireVideoConfig) Name() (string, error) func (self *ContainerProducerLocWireVideoConfig) NeedsKeyframe() (bool, error) -func (self *ContainerProducerLocWireVideoConfig) Reorder(delay *p_net.Timestamp) error +func (self *ContainerProducerLocWireVideoConfig) Reorder(delay p_net.Timestamp) error func (self *ContainerProducerLocWireVideoConfig) ReportBitrate(bitrate p_net.BandwidthRate) error func (self *ContainerProducerLocWireVideoConfig) ReportSkipped(frames uint64) error func (self *ContainerProducerLocWireVideoConfig) Requests() (*p_net.TrackRequests, error) @@ -4167,7 +4166,7 @@ func (self *ContainerProducerLocWireVideoConfig) SetBitrate(bitrate uint64) erro func (self *ContainerProducerLocWireVideoConfig) SkipGroups(groups p_rt.RangeU64) error func (self *ContainerProducerLocWireVideoConfig) Subscribe(subscription *p_net.TrackSubscription) (*p_net.TrackSubscriber, error) func (self *ContainerProducerLocWireVideoConfig) Subscription() (*p_net.TrackSubscription, error) -func (self *ContainerProducerLocWireVideoConfig) Timestamp(hint *p_net.Timestamp) (*p_net.Timestamp, error) +func (self *ContainerProducerLocWireVideoConfig) Timestamp(hint *p_net.Timestamp) (p_net.Timestamp, error) func (self *ContainerProducerLocWireVideoConfig) Track() (*p_net.TrackProducer, error) func (self *ContainerProducerLocWireVideoConfig) WithBandwidth(allocator *p_net.BandwidthAllocator) (*ContainerProducerLocWireVideoConfig, error) func (self *ContainerProducerLocWireVideoConfig) WithBuffer(duration p_rt.Duration) (*ContainerProducerLocWireVideoConfig, error) @@ -4177,7 +4176,7 @@ type ContainerRead interface { } type ContainerReadEnd struct { Group uint64 - End *p_net.Timestamp + End p_net.Timestamp } func (self ContainerReadEnd) GoString() string type ContainerReadFrame struct { @@ -4186,8 +4185,8 @@ type ContainerReadFrame struct { } func (self ContainerReadFrame) GoString() string type ContainerReadGap struct { - Timestamp *p_net.Timestamp - Duration *p_net.Timestamp + Timestamp p_net.Timestamp + Duration p_net.Timestamp } func (self ContainerReadGap) GoString() string type ContainerReorderError interface { @@ -4232,10 +4231,10 @@ func (self ContainerReorderErrorUndrained) Equal(other ContainerReorderError) (b func (self ContainerReorderErrorUndrained) GoString() string func (self ContainerReorderErrorUndrained) String() string type ContainerTimestampRewind struct { - Timestamp *p_net.Timestamp - Floor *p_net.Timestamp + Timestamp p_net.Timestamp + Floor p_net.Timestamp } -func (self ContainerTimestampRewind) Equal(other ContainerTimestampRewind) (bool, error) +func (self ContainerTimestampRewind) Equal(other ContainerTimestampRewind) bool func (self ContainerTimestampRewind) GoString() string func (self ContainerTimestampRewind) String() string type ContainerTsDescriptor struct { @@ -5086,13 +5085,13 @@ func (self *JsonSnapshotJson) Error() string func (self *JsonSnapshotJson) Finish() error func (self *JsonSnapshotJson) Name() (string, error) func (self *JsonSnapshotJson) Refresh(ctx context.Context) error -func (self *JsonSnapshotJson) Update(value *p_serdejson.Json, timestamp *p_net.Timestamp) error +func (self *JsonSnapshotJson) Update(value *p_serdejson.Json, timestamp p_net.Timestamp) error type JsonStreamJson struct { Handle_ *p_rt.Handle_ } func (self *JsonStreamJson) Abort(err *p_net.Error) error func (self *JsonStreamJson) AbortUnwanted(err *p_net.Error) error -func (self *JsonStreamJson) Append(value *p_serdejson.Json, timestamp *p_net.Timestamp) error +func (self *JsonStreamJson) Append(value *p_serdejson.Json, timestamp p_net.Timestamp) error func (self *JsonStreamJson) Close() error func (self *JsonStreamJson) Consume() (*p_net.TrackSubscriber, error) func (self *JsonStreamJson) Demand() (*p_net.TrackDemand, error) @@ -5110,9 +5109,9 @@ type Pacer struct { } func PacerDefault() *Pacer func (self *Pacer) Close() error -func (self *Pacer) Due(ts *p_net.Timestamp) (*p_kio.ClockInstant, error) -func (self *Pacer) Hurry(ts *p_net.Timestamp, now p_kio.ClockInstant) (p_kio.ClockInstant, error) -func (self *Pacer) Pace(ts *p_net.Timestamp, now p_kio.ClockInstant) (p_kio.ClockInstant, error) +func (self *Pacer) Due(ts p_net.Timestamp) (*p_kio.ClockInstant, error) +func (self *Pacer) Hurry(ts p_net.Timestamp, now p_kio.ClockInstant) (p_kio.ClockInstant, error) +func (self *Pacer) Pace(ts p_net.Timestamp, now p_kio.ClockInstant) (p_kio.ClockInstant, error) func (self *Pacer) Slack() (p_rt.Duration, error) func (self *Pacer) WithDelay(delay p_rt.Duration) (*Pacer, error) func (self *Pacer) WithLead(lead p_rt.Duration) (*Pacer, error) @@ -5218,9 +5217,9 @@ func (self *SyncConsumer) Changed(ctx context.Context, seen *SyncSchedule) (*Syn func (self *SyncConsumer) Clone() (*SyncConsumer, error) func (self *SyncConsumer) Close() error func (self *SyncConsumer) Delay() (p_rt.Duration, error) -func (self *SyncConsumer) Due(timestamp *p_net.Timestamp) (*p_kio.ClockInstant, error) +func (self *SyncConsumer) Due(timestamp p_net.Timestamp) (*p_kio.ClockInstant, error) func (self *SyncConsumer) Position(at p_kio.ClockInstant) (*p_rt.Duration, error) -func (self *SyncConsumer) Present(timestamps []*p_net.Timestamp, now p_kio.ClockInstant) (*uint, error) +func (self *SyncConsumer) Present(timestamps []p_net.Timestamp, now p_kio.ClockInstant) (*uint, error) func (self *SyncConsumer) Schedule() (*SyncSchedule, error) type SyncProducer struct { Handle_ *p_rt.Handle_ @@ -5229,7 +5228,7 @@ func NewSyncProducer(delay p_rt.Duration) *SyncProducer func (self *SyncProducer) Clone() (*SyncProducer, error) func (self *SyncProducer) Close() error func (self *SyncProducer) Consume() (*SyncConsumer, error) -func (self *SyncProducer) Due(timestamp *p_net.Timestamp) (*p_kio.ClockInstant, error) +func (self *SyncProducer) Due(timestamp p_net.Timestamp) (*p_kio.ClockInstant, error) func (self *SyncProducer) Reset(delay p_rt.Duration) (*SyncProducer, error) func (self *SyncProducer) Track(kind ContainerKind) (*SyncTrack, error) type SyncSchedule struct { @@ -5238,7 +5237,7 @@ type SyncSchedule struct { func (self *SyncSchedule) Clone() (*SyncSchedule, error) func (self *SyncSchedule) Close() error func (self *SyncSchedule) Delay() (p_rt.Duration, error) -func (self *SyncSchedule) Due(timestamp *p_net.Timestamp) (*p_kio.ClockInstant, error) +func (self *SyncSchedule) Due(timestamp p_net.Timestamp) (*p_kio.ClockInstant, error) func (self *SyncSchedule) Equal(other *SyncSchedule) (bool, error) func (self *SyncSchedule) GoString() string type SyncTrack struct { @@ -5246,7 +5245,7 @@ type SyncTrack struct { } func (self *SyncTrack) Close() error func (self *SyncTrack) DelayChanged(ctx context.Context, seen p_rt.Duration) (p_rt.Duration, error) -func (self *SyncTrack) Received(timestamp *p_net.Timestamp, now p_kio.ClockInstant) (bool, error) +func (self *SyncTrack) Received(timestamp p_net.Timestamp, now p_kio.ClockInstant) (bool, error) func (self *SyncTrack) Reset() error func (self *SyncTrack) SetTarget(target p_rt.Duration) (bool, error) @@ -5655,10 +5654,10 @@ func (self *DatagramConsumer) Recv(ctx context.Context) (*DatagramDatagram, erro func (self *DatagramConsumer) SetPriority(priority int8) error type DatagramDatagram struct { Sequence uint64 - Timestamp *Timestamp + Timestamp Timestamp Payload p_rt.Bytes } -func (self DatagramDatagram) Equal(other DatagramDatagram) (bool, error) +func (self DatagramDatagram) Equal(other DatagramDatagram) bool func (self DatagramDatagram) GoString() string type DatagramInfo struct { Handle_ *p_rt.Handle_ @@ -5670,7 +5669,7 @@ func (self *DatagramInfo) Equal(other *DatagramInfo) (bool, error) func (self *DatagramInfo) GoString() string func (self *DatagramInfo) PriorityGet() (int8, error) func (self *DatagramInfo) PrioritySet(value int8) error -func (self *DatagramInfo) Rescale(timestamp *Timestamp) (*Timestamp, error) +func (self *DatagramInfo) Rescale(timestamp Timestamp) (Timestamp, error) func (self *DatagramInfo) TimescaleGet() (*Timescale, error) func (self *DatagramInfo) TimescaleSet(value *Timescale) error func (self *DatagramInfo) WithPriority(priority int8) (*DatagramInfo, error) @@ -5679,7 +5678,7 @@ type DatagramProducer struct { Handle_ *p_rt.Handle_ } func (self *DatagramProducer) Abort(err *Error) error -func (self *DatagramProducer) Append(timestamp *Timestamp, payload p_rt.Bytes) (uint64, error) +func (self *DatagramProducer) Append(timestamp Timestamp, payload p_rt.Bytes) (uint64, error) func (self *DatagramProducer) Clone() (*DatagramProducer, error) func (self *DatagramProducer) Close() error func (self *DatagramProducer) Consume() (*DatagramConsumer, error) @@ -5747,22 +5746,22 @@ func (self *FrameConsumer) Close() error func (self *FrameConsumer) ReadAll(ctx context.Context) (p_rt.Bytes, error) func (self *FrameConsumer) ReadChunk(ctx context.Context) (*p_rt.Bytes, error) func (self *FrameConsumer) SizeGet() (uint64, error) -func (self *FrameConsumer) TimestampGet() (*Timestamp, error) +func (self *FrameConsumer) TimestampGet() (Timestamp, error) type FrameFrame struct { Handle_ *p_rt.Handle_ } -func NewFrameFrame(timestamp *Timestamp, payload p_rt.Bytes) (*FrameFrame, error) +func NewFrameFrame(timestamp Timestamp, payload p_rt.Bytes) *FrameFrame func (self *FrameFrame) Arrived() (p_kio.ClockInstant, error) func (self *FrameFrame) Clone() (*FrameFrame, error) func (self *FrameFrame) Close() error func (self *FrameFrame) GoString() string func (self *FrameFrame) PayloadGet() (p_rt.Bytes, error) func (self *FrameFrame) PayloadSet(value p_rt.Bytes) error -func (self *FrameFrame) TimestampGet() (*Timestamp, error) -func (self *FrameFrame) TimestampSet(value *Timestamp) error +func (self *FrameFrame) TimestampGet() (Timestamp, error) +func (self *FrameFrame) TimestampSet(value Timestamp) error type FrameInfo struct { Size uint64 - Timestamp *Timestamp + Timestamp Timestamp } func (self FrameInfo) GoString() string type FrameProducer struct { @@ -5774,7 +5773,7 @@ func (self *FrameProducer) Finish() (*GroupProducer, error) func (self *FrameProducer) Group() (*GroupProducer, error) func (self *FrameProducer) Remaining() (uint, error) func (self *FrameProducer) SizeGet() (uint64, error) -func (self *FrameProducer) TimestampGet() (*Timestamp, error) +func (self *FrameProducer) TimestampGet() (Timestamp, error) func (self *FrameProducer) Write(chunk p_rt.Bytes) error type GoawayConsumer struct { Handle_ *p_rt.Handle_ @@ -5862,7 +5861,7 @@ func (self *GroupProducer) Ready(ctx context.Context, frame FrameInfo) error func (self *GroupProducer) StartAt(index uint64) error func (self *GroupProducer) StartGet() (uint64, error) func (self *GroupProducer) Timescale() (*Timescale, error) -func (self *GroupProducer) WriteFrame(timestamp *Timestamp, data p_rt.Bytes) error +func (self *GroupProducer) WriteFrame(timestamp Timestamp, data p_rt.Bytes) error type Instance struct { Handle_ *p_rt.Handle_ } @@ -6998,31 +6997,30 @@ func (self Timescale) Equal(other Timescale) bool func (self Timescale) GoString() string func (self Timescale) String() string type Timestamp struct { - Handle_ *p_rt.Handle_ + Bytes_ [2]uint64 + Made_ bool } -func NewTimestamp(value uint64, scale Timescale) (*Timestamp, error) -func TimestampFromMicros(micros uint64) (*Timestamp, error) -func TimestampFromMillis(millis uint64) (*Timestamp, error) -func TimestampFromNanos(nanos uint64) (*Timestamp, error) -func TimestampFromScale(value uint64, unitsPerSecond uint64) (*Timestamp, error) -func TimestampFromSecs(seconds uint64) (*Timestamp, error) -func TimestampUnscaled(key uint64) *Timestamp -func TimestampZERO() *Timestamp -func (self *Timestamp) AsMicros() (p_rt.U128, error) -func (self *Timestamp) AsMillis() (p_rt.U128, error) -func (self *Timestamp) AsNanos() (p_rt.U128, error) -func (self *Timestamp) AsScale(target Timescale) (p_rt.U128, error) -func (self *Timestamp) AsSecs() (uint64, error) -func (self *Timestamp) CheckedAdd(rhs *Timestamp) (*Timestamp, error) -func (self *Timestamp) CheckedSub(rhs *Timestamp) (*Timestamp, error) -func (self *Timestamp) Clone() (*Timestamp, error) -func (self *Timestamp) Close() error -func (self *Timestamp) Convert(newScale Timescale) (*Timestamp, error) -func (self *Timestamp) Equal(other *Timestamp) (bool, error) -func (self *Timestamp) GoString() string -func (self *Timestamp) IsZero() (bool, error) -func (self *Timestamp) Scale() (*Timescale, error) -func (self *Timestamp) Value() (uint64, error) +func NewTimestamp(value uint64, scale Timescale) (Timestamp, error) +func TimestampFromMicros(micros uint64) (Timestamp, error) +func TimestampFromMillis(millis uint64) (Timestamp, error) +func TimestampFromNanos(nanos uint64) (Timestamp, error) +func TimestampFromScale(value uint64, unitsPerSecond uint64) (Timestamp, error) +func TimestampFromSecs(seconds uint64) (Timestamp, error) +func TimestampUnscaled(key uint64) Timestamp +func TimestampZERO() Timestamp +func (self Timestamp) AsMicros() (p_rt.U128, error) +func (self Timestamp) AsMillis() (p_rt.U128, error) +func (self Timestamp) AsNanos() (p_rt.U128, error) +func (self Timestamp) AsScale(target Timescale) (p_rt.U128, error) +func (self Timestamp) AsSecs() (uint64, error) +func (self Timestamp) CheckedAdd(rhs Timestamp) (Timestamp, error) +func (self Timestamp) CheckedSub(rhs Timestamp) (Timestamp, error) +func (self Timestamp) Convert(newScale Timescale) (Timestamp, error) +func (self Timestamp) Equal(other Timestamp) bool +func (self Timestamp) GoString() string +func (self Timestamp) IsZero() bool +func (self Timestamp) Scale() *Timescale +func (self Timestamp) Value() uint64 type TrackAbortHandle struct { Handle_ *p_rt.Handle_ } @@ -7128,8 +7126,8 @@ func (self *TrackInfo) PriorityGet() (int8, error) func (self *TrackInfo) PrioritySet(value int8) error func (self *TrackInfo) RefreshGet() (*TrackRefresh, error) func (self *TrackInfo) RefreshSet(value *TrackRefresh) error -func (self *TrackInfo) Rescale(timestamp *Timestamp) (*Timestamp, error) -func (self *TrackInfo) RescaleIn(timestamp *Timestamp, key uint64) (*Timestamp, error) +func (self *TrackInfo) Rescale(timestamp Timestamp) (Timestamp, error) +func (self *TrackInfo) RescaleIn(timestamp Timestamp, key uint64) (Timestamp, error) func (self *TrackInfo) TimescaleGet() (*Timescale, error) func (self *TrackInfo) TimescaleSet(value *Timescale) error func (self *TrackInfo) WithCompression(compression TrackCompression) (*TrackInfo, error) @@ -7185,7 +7183,7 @@ type TrackProducer struct { func (self *TrackProducer) Abort(err *Error) error func (self *TrackProducer) AbortHandle() (*TrackAbortHandle, error) func (self *TrackProducer) AbortUnwanted(err *Error) error -func (self *TrackProducer) AppendGroup(start *Timestamp) (*GroupProducer, error) +func (self *TrackProducer) AppendGroup(start Timestamp) (*GroupProducer, error) func (self *TrackProducer) Broadcast() (*BroadcastInfo, error) func (self *TrackProducer) Clone() (*TrackProducer, error) func (self *TrackProducer) Close() error @@ -7209,7 +7207,7 @@ func (self *TrackProducer) StartAt(key *uint64) error func (self *TrackProducer) Subscribe(subscription *TrackSubscription) (*TrackSubscriber, error) func (self *TrackProducer) Subscription() (*TrackSubscription, error) func (self *TrackProducer) SubscriptionChanged(ctx context.Context) (*TrackSubscription, error) -func (self *TrackProducer) WriteFrame(timestamp *Timestamp, frame p_rt.Bytes) error +func (self *TrackProducer) WriteFrame(timestamp Timestamp, frame p_rt.Bytes) error type TrackRange struct { Start TrackAnchor End *TrackAnchor @@ -7312,14 +7310,13 @@ func TransportCloseKindDefault() TransportCloseKind func (self TransportCloseKind) Equal(other TransportCloseKind) bool func (self TransportCloseKind) GoString() string type TransportLimits struct { - Handle_ *p_rt.Handle_ + Bytes_ [1]uint64 + Made_ bool } -func TransportLimitsDefault() *TransportLimits -func (self *TransportLimits) Clone() (*TransportLimits, error) -func (self *TransportLimits) Close() error -func (self *TransportLimits) Equal(other *TransportLimits) (bool, error) -func (self *TransportLimits) GoString() string -func (self *TransportLimits) ReceiveWindowGet() (*uint64, error) +func TransportLimitsDefault() TransportLimits +func (self TransportLimits) Equal(other TransportLimits) bool +func (self TransportLimits) GoString() string +func (self TransportLimits) ReceiveWindowGet() *uint64 func (self *TransportLimits) ReceiveWindowSet(value *uint64) error type TransportLimitsError interface { String() string @@ -7412,17 +7409,16 @@ func (self *TransportProbe) GoString() string func (self *TransportProbe) SetTarget(rate BandwidthRate) error func (self *TransportProbe) Target() (BandwidthRate, error) type TransportReceiveWindow struct { - Handle_ *p_rt.Handle_ + Bytes_ [2]uint64 + Made_ bool } -func NewTransportReceiveWindow(connection *uint64, stream uint64) (*TransportReceiveWindow, error) -func (self *TransportReceiveWindow) Clone() (*TransportReceiveWindow, error) -func (self *TransportReceiveWindow) Close() error -func (self *TransportReceiveWindow) ConnectionGet() (*uint64, error) +func NewTransportReceiveWindow(connection *uint64, stream uint64) (TransportReceiveWindow, error) +func (self TransportReceiveWindow) ConnectionGet() *uint64 func (self *TransportReceiveWindow) ConnectionSet(value *uint64) error -func (self *TransportReceiveWindow) Equal(other *TransportReceiveWindow) (bool, error) -func (self *TransportReceiveWindow) GoString() string -func (self *TransportReceiveWindow) StreamGet() (uint64, error) -func (self *TransportReceiveWindow) StreamSet(value uint64) error +func (self TransportReceiveWindow) Equal(other TransportReceiveWindow) bool +func (self TransportReceiveWindow) GoString() string +func (self TransportReceiveWindow) StreamGet() uint64 +func (self *TransportReceiveWindow) StreamSet(value uint64) type TransportWire struct { Handle_ *p_rt.Handle_ } diff --git a/ffi/surface/moq/kotlin.kt b/ffi/surface/moq/kotlin.kt index dfede547d..4a706406c 100644 --- a/ffi/surface/moq/kotlin.kt +++ b/ffi/surface/moq/kotlin.kt @@ -137,6 +137,32 @@ class ArrayU8x6(bytes: ByteArray) { fun new(unitsPerSecond: kotlin.ULong): moq.Timescale } } +class Timestamp internal constructor() { + fun debug(): kotlin.String + override fun equals(other: kotlin.Any?): kotlin.Boolean + override fun hashCode(): kotlin.Int + fun value(): kotlin.ULong + fun scale(): moq.Timescale? + fun isZero(): kotlin.Boolean + fun convert(newScale: moq.Timescale): moq.Timestamp + fun asScale(target: moq.Timescale): java.math.BigInteger + fun asSecs(): kotlin.ULong + fun asMillis(): java.math.BigInteger + fun asMicros(): java.math.BigInteger + fun asNanos(): java.math.BigInteger + fun checkedAdd(rhs: moq.Timestamp): moq.Timestamp + fun checkedSub(rhs: moq.Timestamp): moq.Timestamp + companion object { + val ZERO: moq.Timestamp + fun new(value: kotlin.ULong, scale: moq.Timescale): moq.Timestamp + fun unscaled(key: kotlin.ULong): moq.Timestamp + fun fromScale(value: kotlin.ULong, unitsPerSecond: kotlin.ULong): moq.Timestamp + fun fromSecs(seconds: kotlin.ULong): moq.Timestamp + fun fromMillis(millis: kotlin.ULong): moq.Timestamp + fun fromMicros(micros: kotlin.ULong): moq.Timestamp + fun fromNanos(nanos: kotlin.ULong): moq.Timestamp + } +} @kotlin.jvm.JvmInline value class ClockInstant internal constructor(internal val bits: Long) { fun debug(): kotlin.String fun elapsed(): moq.Duration @@ -424,6 +450,28 @@ class StatsWithdrawals internal constructor() { fun default(): moq.StatsWithdrawals } } +class TransportReceiveWindow internal constructor() { + fun debug(): kotlin.String + override fun equals(other: kotlin.Any?): kotlin.Boolean + override fun hashCode(): kotlin.Int + val connectionGet: kotlin.ULong? + fun connectionSet(value: kotlin.ULong?): moq.TransportReceiveWindow + val streamGet: kotlin.ULong + fun streamSet(value: kotlin.ULong): moq.TransportReceiveWindow + companion object { + fun new(connection: kotlin.ULong?, stream: kotlin.ULong): moq.TransportReceiveWindow + } +} +class TransportLimits internal constructor() { + fun debug(): kotlin.String + override fun equals(other: kotlin.Any?): kotlin.Boolean + override fun hashCode(): kotlin.Int + val receiveWindowGet: kotlin.ULong? + fun receiveWindowSet(value: kotlin.ULong?): moq.TransportLimits + companion object { + fun default(): moq.TransportLimits + } +} @kotlin.jvm.JvmInline value class BandwidthRate internal constructor(internal val bits: Long) { fun debug(): kotlin.String fun asBps(): kotlin.ULong @@ -495,6 +543,17 @@ data class HangCatalogAac(val profile: kotlin.UByte) { final override fun toString(): kotlin.String fun debug(): kotlin.String } +class HangCatalogClock internal constructor() { + fun debug(): kotlin.String + override fun equals(other: kotlin.Any?): kotlin.Boolean + override fun hashCode(): kotlin.Int + val wallGet: moq.Timestamp + fun wallSet(value: moq.Timestamp): moq.HangCatalogClock + fun wallClock(pts: moq.Timestamp): moq.ClockWall + companion object { + fun new(wall: moq.Timestamp): moq.HangCatalogClock + } +} @kotlin.jvm.JvmInline value class HangCatalogPriorities internal constructor(internal val bits: Long) { fun debug(): kotlin.String val catalogGet: kotlin.Byte @@ -1574,34 +1633,6 @@ class Error internal constructor(raw: Long, lent: Boolean = false) : AutoCloseab fun fromTransportMemoryError(err: moq.TransportMemoryError): moq.Error } } -class Timestamp internal constructor(raw: Long, lent: Boolean = false) : AutoCloseable { - override fun close() - fun debug(): kotlin.String - fun clone(): moq.Timestamp - override fun equals(other: kotlin.Any?): kotlin.Boolean - override fun hashCode(): kotlin.Int - fun value(): kotlin.ULong - fun scale(): moq.Timescale? - fun isZero(): kotlin.Boolean - fun convert(newScale: moq.Timescale): moq.Timestamp - fun asScale(target: moq.Timescale): java.math.BigInteger - fun asSecs(): kotlin.ULong - fun asMillis(): java.math.BigInteger - fun asMicros(): java.math.BigInteger - fun asNanos(): java.math.BigInteger - fun checkedAdd(rhs: moq.Timestamp): moq.Timestamp - fun checkedSub(rhs: moq.Timestamp): moq.Timestamp - companion object { - val ZERO: moq.Timestamp - fun new(value: kotlin.ULong, scale: moq.Timescale): moq.Timestamp - fun unscaled(key: kotlin.ULong): moq.Timestamp - fun fromScale(value: kotlin.ULong, unitsPerSecond: kotlin.ULong): moq.Timestamp - fun fromSecs(seconds: kotlin.ULong): moq.Timestamp - fun fromMillis(millis: kotlin.ULong): moq.Timestamp - fun fromMicros(micros: kotlin.ULong): moq.Timestamp - fun fromNanos(nanos: kotlin.ULong): moq.Timestamp - } -} class Version internal constructor(raw: Long, lent: Boolean = false) : AutoCloseable { override fun close() final override fun toString(): kotlin.String @@ -2448,32 +2479,6 @@ class TransportProbe internal constructor(raw: Long, lent: Boolean = false) : Au fun new(): moq.TransportProbe } } -class TransportReceiveWindow internal constructor(raw: Long, lent: Boolean = false) : AutoCloseable { - override fun close() - fun debug(): kotlin.String - fun clone(): moq.TransportReceiveWindow - override fun equals(other: kotlin.Any?): kotlin.Boolean - override fun hashCode(): kotlin.Int - val connectionGet: kotlin.ULong? - fun connectionSet(value: kotlin.ULong?) - val streamGet: kotlin.ULong - fun streamSet(value: kotlin.ULong) - companion object { - fun new(connection: kotlin.ULong?, stream: kotlin.ULong): moq.TransportReceiveWindow - } -} -class TransportLimits internal constructor(raw: Long, lent: Boolean = false) : AutoCloseable { - override fun close() - fun debug(): kotlin.String - fun clone(): moq.TransportLimits - override fun equals(other: kotlin.Any?): kotlin.Boolean - override fun hashCode(): kotlin.Int - val receiveWindowGet: kotlin.ULong? - fun receiveWindowSet(value: kotlin.ULong?) - companion object { - fun default(): moq.TransportLimits - } -} class BandwidthLimit internal constructor(raw: Long, lent: Boolean = false) : AutoCloseable { override fun close() fun debug(): kotlin.String @@ -3432,19 +3437,6 @@ class HangCatalogBinaryConfig internal constructor(raw: Long, lent: Boolean = fa fun new(mode: moq.HangCatalogMode): moq.HangCatalogBinaryConfig } } -class HangCatalogClock internal constructor(raw: Long, lent: Boolean = false) : AutoCloseable { - override fun close() - fun debug(): kotlin.String - fun clone(): moq.HangCatalogClock - override fun equals(other: kotlin.Any?): kotlin.Boolean - override fun hashCode(): kotlin.Int - val wallGet: moq.Timestamp - fun wallSet(value: moq.Timestamp) - fun wallClock(pts: moq.Timestamp): moq.ClockWall - companion object { - fun new(wall: moq.Timestamp): moq.HangCatalogClock - } -} class HangCatalogContainer internal constructor(raw: Long, lent: Boolean = false) : AutoCloseable { override fun close() fun debug(): kotlin.String diff --git a/ffi/surface/moq/python.pyi b/ffi/surface/moq/python.pyi index a6b3c1163..57d1b7976 100644 --- a/ffi/surface/moq/python.pyi +++ b/ffi/surface/moq/python.pyi @@ -55,6 +55,37 @@ class Timescale(_n.Value): MILLI = _Const(_n.Timescale_MILLI) MICRO = _Const(_n.Timescale_MICRO) NANO = _Const(_n.Timescale_NANO) +class Timestamp(_n.Value): + def __eq__(self, other: _object) -> _bool: ... + def __repr__(self) -> _str: ... + def __hash__(self) -> _int: ... + ZERO = _n.Timestamp_ZERO() + @_staticmethod + def new(value: _int, scale: Timescale) -> Timestamp: ... + @_staticmethod + def unscaled(key: _int) -> Timestamp: ... + @_staticmethod + def from_scale(value: _int, units_per_second: _int) -> Timestamp: ... + @_staticmethod + def from_secs(seconds: _int) -> Timestamp: ... + @_staticmethod + def from_millis(millis: _int) -> Timestamp: ... + @_staticmethod + def from_micros(micros: _int) -> Timestamp: ... + @_staticmethod + def from_nanos(nanos: _int) -> Timestamp: ... + def value(self) -> _int: ... + def scale(self) -> Timescale | None: ... + def is_zero(self) -> _bool: ... + def convert(self, new_scale: Timescale) -> Timestamp: ... + def as_scale(self, target: Timescale) -> _int: ... + def as_secs(self) -> _int: ... + def as_millis(self) -> _int: ... + def as_micros(self) -> _int: ... + def as_nanos(self) -> _int: ... + def checked_add(self, rhs: Timestamp) -> Timestamp: ... + def checked_sub(self, rhs: Timestamp) -> Timestamp: ... + ZERO = _Const(_n.Timestamp_ZERO) class ClockInstant(_n.Value): def __eq__(self, other: _object) -> _bool: ... def __repr__(self) -> _str: ... @@ -379,6 +410,25 @@ class StatsWithdrawals(_n.Value): def total(self) -> _int: ... def add(self, other: StatsWithdrawals) -> StatsWithdrawals: ... def regressed(self, previous: StatsWithdrawals) -> _bool: ... +class TransportReceiveWindow(_n.Value): + def __eq__(self, other: _object) -> _bool: ... + def __repr__(self) -> _str: ... + @_property + def connection_get(self) -> _int | None: ... + def connection_set(self, value: _int | None) -> TransportReceiveWindow: ... + @_property + def stream_get(self) -> _int: ... + def stream_set(self, value: _int) -> TransportReceiveWindow: ... + @_staticmethod + def new(connection: _int | None, stream: _int) -> TransportReceiveWindow: ... +class TransportLimits(_n.Value): + def __eq__(self, other: _object) -> _bool: ... + def __repr__(self) -> _str: ... + @_staticmethod + def default() -> TransportLimits: ... + @_property + def receive_window_get(self) -> _int | None: ... + def receive_window_set(self, value: _int | None) -> TransportLimits: ... class BandwidthRate(_n.Value): def __eq__(self, other: _object) -> _bool: ... def __repr__(self) -> _str: ... @@ -467,6 +517,15 @@ class HangCatalogAac: profile: _int def __str__(self) -> _str: ... def __repr__(self) -> _str: ... +class HangCatalogClock(_n.Value): + def __eq__(self, other: _object) -> _bool: ... + def __repr__(self) -> _str: ... + @_property + def wall_get(self) -> Timestamp: ... + def wall_set(self, value: Timestamp) -> HangCatalogClock: ... + @_staticmethod + def new(wall: Timestamp) -> HangCatalogClock: ... + def wall_clock(self, pts: Timestamp) -> ClockWall: ... class HangCatalogPriorities(_n.Value): def __eq__(self, other: _object) -> _bool: ... def __repr__(self) -> _str: ... @@ -1949,38 +2008,6 @@ class Error(_n.Object): @_staticmethod def from_transport_memory_error(err: TransportMemoryError) -> Error: ... def retry(self) -> Retry: ... -class Timestamp(_n.Object): - def __eq__(self, other: _object) -> _bool: ... - def __repr__(self) -> _str: ... - def clone(self) -> Timestamp: ... - def __hash__(self) -> _int: ... - ZERO = _n.Timestamp_ZERO() - @_staticmethod - def new(value: _int, scale: Timescale) -> Timestamp: ... - @_staticmethod - def unscaled(key: _int) -> Timestamp: ... - @_staticmethod - def from_scale(value: _int, units_per_second: _int) -> Timestamp: ... - @_staticmethod - def from_secs(seconds: _int) -> Timestamp: ... - @_staticmethod - def from_millis(millis: _int) -> Timestamp: ... - @_staticmethod - def from_micros(micros: _int) -> Timestamp: ... - @_staticmethod - def from_nanos(nanos: _int) -> Timestamp: ... - def value(self) -> _int: ... - def scale(self) -> Timescale | None: ... - def is_zero(self) -> _bool: ... - def convert(self, new_scale: Timescale) -> Timestamp: ... - def as_scale(self, target: Timescale) -> _int: ... - def as_secs(self) -> _int: ... - def as_millis(self) -> _int: ... - def as_micros(self) -> _int: ... - def as_nanos(self) -> _int: ... - def checked_add(self, rhs: Timestamp) -> Timestamp: ... - def checked_sub(self, rhs: Timestamp) -> Timestamp: ... - ZERO = _Const(_n.Timestamp_ZERO) class Version(_n.Object): def __eq__(self, other: _object) -> _bool: ... def __str__(self) -> _str: ... @@ -2755,27 +2782,6 @@ class TransportProbe(_n.Object): def new() -> TransportProbe: ... def target(self) -> BandwidthRate: ... def set_target(self, rate: BandwidthRate) -> None: ... -class TransportReceiveWindow(_n.Object): - def __eq__(self, other: _object) -> _bool: ... - def __repr__(self) -> _str: ... - def clone(self) -> TransportReceiveWindow: ... - @_property - def connection_get(self) -> _int | None: ... - def connection_set(self, value: _int | None) -> None: ... - @_property - def stream_get(self) -> _int: ... - def stream_set(self, value: _int) -> None: ... - @_staticmethod - def new(connection: _int | None, stream: _int) -> TransportReceiveWindow: ... -class TransportLimits(_n.Object): - def __eq__(self, other: _object) -> _bool: ... - def __repr__(self) -> _str: ... - def clone(self) -> TransportLimits: ... - @_staticmethod - def default() -> TransportLimits: ... - @_property - def receive_window_get(self) -> _int | None: ... - def receive_window_set(self, value: _int | None) -> None: ... class BandwidthLimit(_n.Object): async def changed(self) -> BandwidthCap | None: ... def __repr__(self) -> _str: ... @@ -3645,16 +3651,6 @@ class HangCatalogBinaryConfig(_n.Object): def extra_set(self, value: _typing.Iterable[_tuple[_str, Json]]) -> None: ... @_staticmethod def new(mode: HangCatalogMode) -> HangCatalogBinaryConfig: ... -class HangCatalogClock(_n.Object): - def __eq__(self, other: _object) -> _bool: ... - def __repr__(self) -> _str: ... - def clone(self) -> HangCatalogClock: ... - @_property - def wall_get(self) -> Timestamp: ... - def wall_set(self, value: Timestamp) -> None: ... - @_staticmethod - def new(wall: Timestamp) -> HangCatalogClock: ... - def wall_clock(self, pts: Timestamp) -> ClockWall: ... class HangCatalogContainer(_n.Object): def __eq__(self, other: _object) -> _bool: ... def __repr__(self) -> _str: ... diff --git a/ffi/surface/moq/swift.swift b/ffi/surface/moq/swift.swift index 3c524d1db..a292e1b9d 100644 --- a/ffi/surface/moq/swift.swift +++ b/ffi/surface/moq/swift.swift @@ -273,6 +273,30 @@ public struct Timescale: Sendable, CustomStringConvertible, CustomDebugStringCon @inlinable public static func new(_ unitsPerSecond: Swift.UInt64) throws -> Timescale @inlinable public func asU64() -> Swift.UInt64 } +public struct Timestamp: Sendable, CustomDebugStringConvertible, Hashable { + @inlinable public var debugDescription: Swift.String { get } + @inlinable public static func == (a: Timestamp, b: Timestamp) -> Swift.Bool + @inlinable public func hash(into hasher: inout Swift.Hasher) + @inlinable public static var ZERO: Timestamp { get } + @inlinable public static func new(_ value: Swift.UInt64, _ scale: Timescale) throws -> Timestamp + @inlinable public static func unscaled(_ key: Swift.UInt64) -> Timestamp + @inlinable public static func fromScale(_ value: Swift.UInt64, _ unitsPerSecond: Swift.UInt64) throws -> Timestamp + @inlinable public static func fromSecs(_ seconds: Swift.UInt64) throws -> Timestamp + @inlinable public static func fromMillis(_ millis: Swift.UInt64) throws -> Timestamp + @inlinable public static func fromMicros(_ micros: Swift.UInt64) throws -> Timestamp + @inlinable public static func fromNanos(_ nanos: Swift.UInt64) throws -> Timestamp + @inlinable public func value() -> Swift.UInt64 + @inlinable public func scale() -> Timescale? + @inlinable public func isZero() -> Swift.Bool + @inlinable public func convert(_ newScale: Timescale) throws -> Timestamp + @inlinable public func asScale(_ target: Timescale) throws -> U128 + @inlinable public func asSecs() throws -> Swift.UInt64 + @inlinable public func asMillis() throws -> U128 + @inlinable public func asMicros() throws -> U128 + @inlinable public func asNanos() throws -> U128 + @inlinable public func checkedAdd(_ rhs: Timestamp) throws -> Timestamp + @inlinable public func checkedSub(_ rhs: Timestamp) throws -> Timestamp +} public struct ClockInstant: Sendable, CustomDebugStringConvertible, Hashable { @inlinable public var debugDescription: Swift.String { get } @inlinable public static func == (a: ClockInstant, b: ClockInstant) -> Swift.Bool @@ -531,6 +555,22 @@ public struct StatsWithdrawals: Sendable, CustomDebugStringConvertible, Equatabl @inlinable public mutating func add(_ other: StatsWithdrawals) @inlinable public func regressed(_ previous: StatsWithdrawals) -> Swift.Bool } +public struct TransportReceiveWindow: Sendable, CustomDebugStringConvertible, Equatable { + @inlinable public var debugDescription: Swift.String { get } + @inlinable public static func == (a: TransportReceiveWindow, b: TransportReceiveWindow) -> Swift.Bool + @inlinable public var connectionGet: NonZero? { get } + @inlinable public mutating func connectionSet(_ value: NonZero?) + @inlinable public var streamGet: Swift.UInt64 { get } + @inlinable public mutating func streamSet(_ value: Swift.UInt64) + @inlinable public static func new(_ connection: NonZero?, _ stream: Swift.UInt64) -> TransportReceiveWindow +} +public struct TransportLimits: Sendable, CustomDebugStringConvertible, Equatable { + @inlinable public var debugDescription: Swift.String { get } + @inlinable public static func == (a: TransportLimits, b: TransportLimits) -> Swift.Bool + @inlinable public static func `default`() -> TransportLimits + @inlinable public var receiveWindowGet: NonZero? { get } + @inlinable public mutating func receiveWindowSet(_ value: NonZero?) +} public struct BandwidthRate: Sendable, CustomDebugStringConvertible, Hashable { @inlinable public var debugDescription: Swift.String { get } @inlinable public static func == (a: BandwidthRate, b: BandwidthRate) -> Swift.Bool @@ -544,15 +584,15 @@ public struct BandwidthRate: Sendable, CustomDebugStringConvertible, Hashable { @inlinable public func scaled(_ factor: Swift.Double) -> BandwidthRate @inlinable public func absDiff(_ other: BandwidthRate) -> BandwidthRate } -public struct DatagramDatagram: Sendable { +public struct DatagramDatagram: Sendable, CustomDebugStringConvertible, Equatable { public var sequence: Swift.UInt64 public var timestamp: Timestamp public var payload: Bytes @inlinable public init(sequence: Swift.UInt64, timestamp: Timestamp, payload: Bytes) @inlinable public var debugDescription: Swift.String { get } - @inlinable public static func == (a: DatagramDatagram, b: DatagramDatagram) throws -> Swift.Bool + @inlinable public static func == (a: DatagramDatagram, b: DatagramDatagram) -> Swift.Bool } -public struct FrameInfo: Sendable { +public struct FrameInfo: Sendable, CustomDebugStringConvertible { public var size: Swift.UInt64 public var timestamp: Timestamp @inlinable public init(size: Swift.UInt64, timestamp: Timestamp) @@ -619,6 +659,14 @@ public struct HangCatalogAac: Sendable, CustomStringConvertible, CustomDebugStri @inlinable public var debugDescription: Swift.String { get } @inlinable public static func == (a: HangCatalogAac, b: HangCatalogAac) -> Swift.Bool } +public struct HangCatalogClock: Sendable, CustomDebugStringConvertible, Equatable { + @inlinable public var debugDescription: Swift.String { get } + @inlinable public static func == (a: HangCatalogClock, b: HangCatalogClock) -> Swift.Bool + @inlinable public var wallGet: Timestamp { get } + @inlinable public mutating func wallSet(_ value: Timestamp) + @inlinable public static func new(_ wall: Timestamp) throws -> HangCatalogClock + @inlinable public func wallClock(_ pts: Timestamp) throws -> ClockWall +} public struct HangCatalogPriorities: Sendable, CustomDebugStringConvertible, Equatable { @inlinable public var debugDescription: Swift.String { get } @inlinable public static func == (a: HangCatalogPriorities, b: HangCatalogPriorities) -> Swift.Bool @@ -721,7 +769,7 @@ public struct HangCatalogDisplay: Sendable, CustomDebugStringConvertible, Equata @inlinable public var debugDescription: Swift.String { get } @inlinable public static func == (a: HangCatalogDisplay, b: HangCatalogDisplay) -> Swift.Bool } -public struct HangContainerFrame: Sendable { +public struct HangContainerFrame: Sendable, CustomDebugStringConvertible { public var timestamp: Timestamp public var payload: Bytes @inlinable public init(timestamp: Timestamp, payload: Bytes) @@ -730,7 +778,7 @@ public struct HangContainerFrame: Sendable { @inlinable public static func decode(_ buf: Bytes) throws -> HangContainerFrame @inlinable public func writeTo(_ group: inout GroupProducer) throws } -public struct MuxContainerFrame: Sendable { +public struct MuxContainerFrame: Sendable, CustomDebugStringConvertible { public var timestamp: Timestamp public var duration: Timestamp? public var payload: Bytes @@ -738,13 +786,13 @@ public struct MuxContainerFrame: Sendable { @inlinable public init(timestamp: Timestamp, duration: Timestamp?, payload: Bytes, keyframe: Swift.Bool) @inlinable public var debugDescription: Swift.String { get } } -public struct MuxContainerTimestampRewind: Sendable { +public struct MuxContainerTimestampRewind: Sendable, CustomStringConvertible, CustomDebugStringConvertible, Equatable { public var timestamp: Timestamp public var floor: Timestamp @inlinable public init(timestamp: Timestamp, floor: Timestamp) @inlinable public var description: Swift.String { get } @inlinable public var debugDescription: Swift.String { get } - @inlinable public static func == (a: MuxContainerTimestampRewind, b: MuxContainerTimestampRewind) throws -> Swift.Bool + @inlinable public static func == (a: MuxContainerTimestampRewind, b: MuxContainerTimestampRewind) -> Swift.Bool } public struct MuxContainerPlayout: Sendable, CustomDebugStringConvertible, Equatable { public var delay: TrackDelay @@ -1279,7 +1327,7 @@ public enum MuxContainerKind: Sendable, CustomDebugStringConvertible, Equatable @inlinable public var debugDescription: Swift.String { get } @inlinable public static func == (a: MuxContainerKind, b: MuxContainerKind) -> Swift.Bool } -public enum MuxContainerRead: Sendable { +public enum MuxContainerRead: Sendable, CustomDebugStringConvertible { case frame(group: Swift.UInt64, frame: MuxContainerFrame) case gap(timestamp: Timestamp, duration: Timestamp) case end(group: Swift.UInt64, end: Timestamp) @@ -1776,31 +1824,6 @@ public final class Error: @unchecked Sendable { @inlinable public static func fromTransportMemoryError(_ err: TransportMemoryError) -> Error @inlinable public func retry() throws -> Retry } -public final class Timestamp: @unchecked Sendable { - @inlinable public var debugDescription: Swift.String { get } - @inlinable public func clone() throws -> Timestamp - @inlinable public static func == (a: Timestamp, b: Timestamp) throws -> Swift.Bool - @inlinable public func hash(into hasher: inout Swift.Hasher) throws - @inlinable public static var ZERO: Timestamp { get } - @inlinable public static func new(_ value: Swift.UInt64, _ scale: Timescale) throws -> Timestamp - @inlinable public static func unscaled(_ key: Swift.UInt64) -> Timestamp - @inlinable public static func fromScale(_ value: Swift.UInt64, _ unitsPerSecond: Swift.UInt64) throws -> Timestamp - @inlinable public static func fromSecs(_ seconds: Swift.UInt64) throws -> Timestamp - @inlinable public static func fromMillis(_ millis: Swift.UInt64) throws -> Timestamp - @inlinable public static func fromMicros(_ micros: Swift.UInt64) throws -> Timestamp - @inlinable public static func fromNanos(_ nanos: Swift.UInt64) throws -> Timestamp - @inlinable public func value() throws -> Swift.UInt64 - @inlinable public func scale() throws -> Timescale? - @inlinable public func isZero() throws -> Swift.Bool - @inlinable public func convert(_ newScale: Timescale) throws -> Timestamp - @inlinable public func asScale(_ target: Timescale) throws -> U128 - @inlinable public func asSecs() throws -> Swift.UInt64 - @inlinable public func asMillis() throws -> U128 - @inlinable public func asMicros() throws -> U128 - @inlinable public func asNanos() throws -> U128 - @inlinable public func checkedAdd(_ rhs: Timestamp) throws -> Timestamp - @inlinable public func checkedSub(_ rhs: Timestamp) throws -> Timestamp -} public final class Version: @unchecked Sendable, CustomStringConvertible, CustomDebugStringConvertible, Hashable { @inlinable public var description: Swift.String { get } @inlinable public var debugDescription: Swift.String { get } @@ -2497,24 +2520,6 @@ public struct TransportProbe: ~Copyable, @unchecked Sendable { @inlinable public func target() -> BandwidthRate @inlinable public func setTarget(_ rate: BandwidthRate) } -public final class TransportReceiveWindow: @unchecked Sendable { - @inlinable public var debugDescription: Swift.String { get } - @inlinable public func clone() throws -> TransportReceiveWindow - @inlinable public static func == (a: TransportReceiveWindow, b: TransportReceiveWindow) throws -> Swift.Bool - @inlinable public var connectionGet: NonZero? { get } - @inlinable public func connectionSet(_ value: NonZero?) throws - @inlinable public var streamGet: Swift.UInt64 { get } - @inlinable public func streamSet(_ value: Swift.UInt64) throws - @inlinable public static func new(_ connection: NonZero?, _ stream: Swift.UInt64) -> TransportReceiveWindow -} -public final class TransportLimits: @unchecked Sendable { - @inlinable public var debugDescription: Swift.String { get } - @inlinable public func clone() throws -> TransportLimits - @inlinable public static func == (a: TransportLimits, b: TransportLimits) throws -> Swift.Bool - @inlinable public static func `default`() -> TransportLimits - @inlinable public var receiveWindowGet: NonZero? { get } - @inlinable public func receiveWindowSet(_ value: NonZero?) throws -} public struct BandwidthLimit: ~Copyable, @unchecked Sendable { @inlinable public var debugDescription: Swift.String { get } @inlinable public func clone() throws -> BandwidthLimit @@ -2747,7 +2752,7 @@ public struct FrameFrame: ~Copyable, @unchecked Sendable { @inlinable public mutating func timestampSet(_ value: Timestamp) throws @inlinable public var payloadGet: Bytes { get } @inlinable public mutating func payloadSet(_ value: Bytes) throws - @inlinable public static func new(_ timestamp: Timestamp, _ payload: Bytes) throws -> FrameFrame + @inlinable public static func new(_ timestamp: Timestamp, _ payload: Bytes) -> FrameFrame @inlinable public func arrived() throws -> ClockInstant } public struct FrameConsumer: ~Copyable, @unchecked Sendable { @@ -3209,7 +3214,7 @@ public struct HangEchoArrival: ~Copyable, @unchecked Sendable { @inlinable public mutating func timestampSet(_ value: Timestamp) throws @inlinable public var wallGet: ClockWall { get } @inlinable public mutating func wallSet(_ value: ClockWall) throws - @inlinable public static func new(_ timestamp: Timestamp, _ wall: ClockWall) throws -> HangEchoArrival + @inlinable public static func new(_ timestamp: Timestamp, _ wall: ClockWall) -> HangEchoArrival } public struct HangCatalogSkipped: ~Copyable, @unchecked Sendable { @inlinable public var debugDescription: Swift.String { get } @@ -3320,15 +3325,6 @@ public struct HangCatalogBinaryConfig: ~Copyable, @unchecked Sendable { @inlinable public mutating func extraSet(_ value: consuming UniqueArray) throws @inlinable public static func new(_ mode: HangCatalogMode) -> HangCatalogBinaryConfig } -public final class HangCatalogClock: @unchecked Sendable { - @inlinable public var debugDescription: Swift.String { get } - @inlinable public func clone() throws -> HangCatalogClock - @inlinable public static func == (a: HangCatalogClock, b: HangCatalogClock) throws -> Swift.Bool - @inlinable public var wallGet: Timestamp { get } - @inlinable public func wallSet(_ value: Timestamp) throws - @inlinable public static func new(_ wall: Timestamp) throws -> HangCatalogClock - @inlinable public func wallClock(_ pts: Timestamp) throws -> ClockWall -} public struct HangCatalogContainer: ~Copyable, @unchecked Sendable { @inlinable public var debugDescription: Swift.String { get } @inlinable public func clone() throws -> HangCatalogContainer @@ -5619,7 +5615,7 @@ public struct MuxSelectAudio: ~Copyable, @unchecked Sendable { @inlinable public consuming func codec(_ codec: HangCatalogAudioCodecKind) throws -> MuxSelectAudio } public struct MuxSyncTrack: ~Copyable, @unchecked Sendable { - @inlinable public func received(_ timestamp: Timestamp, _ now: ClockInstant) throws -> Swift.Bool + @inlinable public func received(_ timestamp: Timestamp, _ now: ClockInstant) -> Swift.Bool @inlinable public func reset() @inlinable public func setTarget(_ target: RustDuration) -> Swift.Bool @inlinable nonisolated(nonsending) public func delayChanged(_ seen: RustDuration) async throws -> RustDuration @@ -5629,7 +5625,7 @@ public final class MuxSyncSchedule: @unchecked Sendable, CustomDebugStringConver @inlinable public func clone() -> MuxSyncSchedule @inlinable public static func == (a: MuxSyncSchedule, b: MuxSyncSchedule) -> Swift.Bool @inlinable public func delay() -> RustDuration - @inlinable public func due(_ timestamp: Timestamp) throws -> ClockInstant? + @inlinable public func due(_ timestamp: Timestamp) -> ClockInstant? } public struct MuxSyncProducer: ~Copyable, @unchecked Sendable { @inlinable public func clone() throws -> MuxSyncProducer diff --git a/ffi/tests/fixtures.rs b/ffi/tests/fixtures.rs index d9a4a360f..b39605a4e 100644 --- a/ffi/tests/fixtures.rs +++ b/ffi/tests/fixtures.rs @@ -3733,7 +3733,14 @@ fn opaque_values() { #[derive(Clone, Copy)]\n#[repr(C)]\npub struct Mixed(u32, u64, u32);\n\npub fn mixed() -> Mixed {\n\tMixed(1, 2, 3)\n}\n\n\ #[derive(Clone, Copy)]\n#[repr(C)]\npub struct MixedWord(usize, u64);\n\npub fn mixed_word() -> MixedWord {\n\tMixedWord(1, 2)\n}\n\n\ #[derive(Clone, Copy)]\n#[repr(C)]\npub struct Words(u64, usize, usize);\n\npub fn words() -> Words {\n\tWords(1, 2, 3)\n}\n\n\ - #[derive(Clone, Copy)]\n#[repr(u8)]\nenum Kind {\n\tA,\n\tB,\n}\n\n#[derive(Clone, Copy)]\n#[repr(C)]\npub struct Ordered(u64, u32, u16, u8, Kind);\n\npub fn ordered() -> Ordered {\n\tOrdered(1, 2, 3, 4, Kind::B)\n}\n"; + #[derive(Clone, Copy)]\n#[repr(u8)]\nenum Kind {\n\tA,\n\tB,\n}\n\n#[derive(Clone, Copy)]\n#[repr(C)]\npub struct Ordered(u64, u32, u16, u8, Kind);\n\npub fn ordered() -> Ordered {\n\tOrdered(1, 2, 3, 4, Kind::B)\n}\n\n\ + #[derive(Clone, Copy)]\npub struct Scaled {\n\tvalue: u64,\n\tscale: Option>,\n}\n\npub fn scaled() -> Scaled {\n\tScaled { value: 1, scale: None }\n}\n\n\ + #[derive(Clone, Copy)]\npub struct Lent(Option<&'static u32>);\n\npub fn lent() -> Lent {\n\tLent(None)\n}\n\n\ + #[derive(Clone, Copy)]\npub struct Nested(Option>);\n\npub fn nested() -> Nested {\n\tNested(Some(None))\n}\n\n\ + #[derive(Clone, Copy)]\npub struct Chars(Option);\n\npub fn chars() -> Chars {\n\tChars(None)\n}\n\n\ + #[derive(Clone, Copy)]\npub struct Unset(Option);\n\npub fn unset() -> Unset {\n\tUnset(None)\n}\n\n\ + #[derive(Clone, Copy)]\npub struct Narrow(Option<(u32, std::num::NonZero)>);\n\npub fn narrow() -> Narrow {\n\tNarrow(None)\n}\n\n\ + #[derive(Clone, Copy)]\npub struct Sliced(Option<&'static [u8]>);\n\npub fn sliced() -> Sliced {\n\tSliced(None)\n}\n"; let package = package("opaque_values", &[("src/lib.rs", lib)]); let out = package.join("out"); run(Command::new(env!("CARGO_BIN_EXE_rust2-ffi")) @@ -3751,8 +3758,10 @@ fn opaque_values() { ); // A `bool` beside integers that fill the struct; a tag byte beside each variant's byte; // fields in an order `repr(C)` keeps that leaves no gap, a `repr(u8)` tag among them; - // two `usize`s after a `u64`, which fill it at either pointer width. - for value in ["Flag", "Tagged", "Ordered", "Words"] { + // two `usize`s after a `u64`, which fill it at either pointer width; a `None` that writes + // its niche's whole scalar, a `u64`'s, a pointer's at either width, a `bool`'s an outer + // `None` shares with an inner one, or a `char`'s. + for value in ["Flag", "Tagged", "Ordered", "Words", "Scaled", "Lent", "Nested", "Chars"] { assert!( header.contains(&format!("}} opaque_values_{value};")), "{value} is no opaque value:\n{header}" @@ -3761,8 +3770,10 @@ fn opaque_values() { // Padding after each `u8`; a tag and a `u16` short of a `u32`'s room; a niche the tag // may hide in, leaving `B` a byte short; padding after the `u32` on a 64-bit target, // though none on wasm32, so a handle on both; a `u64` that `repr(C)` keeps after a `u32`, - // or after a `usize`, which is a gap on wasm32 alone. - for handle in ["Pairs", "Wide", "Niched", "Word", "Mixed", "MixedWord"] { + // or after a `usize`, which is a gap on wasm32 alone; a `None` with no niche, writing + // only its tag, or with a niche narrower than its payload, a `NonZero`'s beside a + // `u32`, or a slice's pointer beside its length. + for handle in ["Pairs", "Wide", "Niched", "Word", "Mixed", "MixedWord", "Unset", "Narrow", "Sliced"] { assert!( header.contains(&format!("void opaque_values_{handle}_free(")), "{handle} is no handle:\n{header}" From 1145f491a4891dede7cb0c141252e08644f0194c Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Thu, 19 Nov 2026 21:01:12 -0800 Subject: [PATCH 3/9] ffi: a Miri check of a niche value's bytes, docs, and the quest's deletion --- ffi/README.md | 16 ++++++------ ffi/fixtures/api/src/lib.rs | 23 +++++++++++++++++ ffi/moq/moq.go | 2 +- ffi/surface/api/c.h | 9 ++++++- ffi/surface/api/cpp.hpp | 9 +++++++ ffi/surface/api/dart.dart | 7 ++++++ ffi/surface/api/go.txt | 8 ++++++ ffi/surface/api/kotlin.kt | 9 +++++++ ffi/surface/api/python.pyi | 6 +++++ ffi/surface/api/swift.swift | 6 +++++ ffi/surface/api/web.d.ts | 12 +++++++++ ffi/tests/miri/api.rs | 14 +++++++++++ quest/m1/ffi-export/niche-values.md | 39 ----------------------------- quest/m1/ffi-export/ship.md | 1 - 14 files changed, 112 insertions(+), 49 deletions(-) delete mode 100644 quest/m1/ffi-export/niche-values.md diff --git a/ffi/README.md b/ffi/README.md index 2e9a3cd0a..8457c4756 100644 --- a/ffi/README.md +++ b/ffi/README.md @@ -345,13 +345,15 @@ Linux's exports, as the merge queue runs on, since a header names its targets. included, as a ` *` Rust writes what the call left back through, so only that copy changes; it never makes or reads one itself, and frees none. Its fields fill it under any order a `rustc` may give them, with a byte for an enum's tag where no field has a - niche to hold it, so it has no padding whichever `rustc` builds the glue, which asserts - each target's size. They must also fill a model layout at both 4- and 8-byte pointers, - each primitive aligned to its size and a `repr`'s field order kept, so every target - decides alike. Any other `Copy` type, such as std's `Instant`, padded on a 64-bit - target, or an `Option`, whose bytes depend on its value, is an object instead, so - no byte Rust leaves uninitialized reaches a language, which may serialize what it - holds. Its size and alignment are the largest of the export's targets, so one + niche to hold it, and a variant without data in another's niche counted as that niche's + whole scalar, which it writes, so it has no padding whichever `rustc` builds the glue, + which asserts each target's size: `None` of an `Option>` fills its 8 bytes. + They must also fill a model layout at both 4- and 8-byte pointers, each primitive + aligned to its size and a `repr`'s field order kept, so every target decides alike. Any + other `Copy` type, such as std's `Instant`, padded on a 64-bit target, or an + `Option` or `Option<&[u8]>`, whose `None` leaves bytes uninitialized, is an object + instead, so no byte Rust leaves uninitialized reaches a language, which may serialize + what it holds. Its size and alignment are the largest of the export's targets, so one header serves them all, a few bytes past a 32-bit target's own. A change of size is an ABI change, as a record's field change is. - **In and out**: a `&mut` of a value is two parameters, the value passed in as one taken diff --git a/ffi/fixtures/api/src/lib.rs b/ffi/fixtures/api/src/lib.rs index b9f325e25..bb1e40ae2 100644 --- a/ffi/fixtures/api/src/lib.rs +++ b/ffi/fixtures/api/src/lib.rs @@ -1934,6 +1934,29 @@ impl Berth { } } +/// A count at a scale that may be absent: `Copy` with private fields, whose `None` writes +/// its niche's whole `u64`, so a value whatever it holds. +#[derive(Clone, Copy, Debug, PartialEq)] +pub struct Rated { + count: u64, + scale: Option>, +} + +impl Rated { + /// `count` at `scale` a second, or unscaled at a scale of zero. + pub fn new(count: u64, scale: u64) -> Self { + Self { + count, + scale: NonZero::new(scale), + } + } + + /// Its scale, or zero when unscaled. + pub fn scale(&self) -> u64 { + self.scale.map_or(0, NonZero::get) + } +} + /// A running count, as moq's `stats::Traffic`: `Copy` with private fields, changed in place /// through `&mut self`, so a value whose every copy changes alone. #[derive(Clone, Copy, Debug)] diff --git a/ffi/moq/moq.go b/ffi/moq/moq.go index e67d29de0..c9b764b3b 100644 --- a/ffi/moq/moq.go +++ b/ffi/moq/moq.go @@ -158,7 +158,7 @@ func script() { expect(writer.WriteFrame(net.TimestampUnscaled(0), rt.NewBytes([]byte("hello"))) == nil, "a frame writes") hello := within(frame, "a frame's arrival wakes the read") expect(string(must(hello.PayloadGet()).Copy()) == "hello", "a frame has its payload") - expect(must(must(hello.TimestampGet()).Scale()) == nil, "an untimed frame's timestamp has no scale") + expect(must(hello.TimestampGet()).Scale() == nil, "an untimed frame's timestamp has no scale") // When it arrived: kio's clock's `Instant`, from kio's own export. expect(kio.ClockNow().CheckedDurationSince(must(hello.Arrived())) != nil, "a frame arrived before now") diff --git a/ffi/surface/api/c.h b/ffi/surface/api/c.h index 0a5137410..4490979a1 100644 --- a/ffi/surface/api/c.h +++ b/ffi/surface/api/c.h @@ -7,7 +7,7 @@ #ifdef __cplusplus extern "C" { #endif -#define API_CONTRACT ((uint64_t)0xdcf4774fd2b0babdULL) +#define API_CONTRACT ((uint64_t)0xe9d68701a2cb3223ULL) uint64_t api_contract(void); uint32_t api_target(void); typedef int32_t api_status; @@ -686,6 +686,9 @@ typedef struct api_Clocked { api_Moment at; uint32_t count; } api_Clocked; +typedef struct api_Rated { + uint64_t opaque[2]; +} api_Rated; typedef struct api_Hits { uint64_t opaque[2]; } api_Hits; @@ -1157,6 +1160,10 @@ uint64_t api_Wide_sum(const api_Wide *self); void api_Clocked_free(api_Clocked *self); bool api_Clocked_eq(const api_Clocked *a, const api_Clocked *b); api_buf api_Clocked_debug(const api_Clocked *self); +bool api_Rated_eq(const api_Rated *a, const api_Rated *b); +api_buf api_Rated_debug(const api_Rated *self); +api_Rated api_Rated_new(uint64_t count, uint64_t scale); +uint64_t api_Rated_scale(const api_Rated *self); api_buf api_Score_debug(const api_Score *self); api_Score api_Score_of(uint64_t count); uint64_t api_Score_count(const api_Score *self); diff --git a/ffi/surface/api/cpp.hpp b/ffi/surface/api/cpp.hpp index 7717f7551..9ba8d6d61 100644 --- a/ffi/surface/api/cpp.hpp +++ b/ffi/surface/api/cpp.hpp @@ -801,6 +801,13 @@ namespace api { friend bool operator!=(const Clocked &a__, const Clocked &b_); ::api::buf debug() const; }; + class Rated { + friend bool operator==(const Rated &a__, const Rated &b_); + friend bool operator!=(const Rated &a__, const Rated &b_); + ::api::buf debug() const; + static ::api::Rated new_(::std::uint64_t count, ::std::uint64_t scale); + ::std::uint64_t scale() const; + }; class Hits { friend bool operator==(const Hits &a__, const Hits &b_); friend bool operator!=(const Hits &a__, const Hits &b_); @@ -1213,6 +1220,7 @@ namespace api { inline bool operator==(const OptIn &a__, const OptIn &b_); inline bool operator==(const Wide &a__, const Wide &b_); inline bool operator==(const Clocked &a__, const Clocked &b_); + inline bool operator==(const Rated &a__, const Rated &b_); inline bool operator==(const Hits &a__, const Hits &b_); inline bool operator==(const Extent &a__, const Extent &b_); inline bool operator==(const Pair_Size_u8 &a__, const Pair_Size_u8 &b_); @@ -1843,6 +1851,7 @@ namespace api { struct OptIn; class Wide; struct Clocked; + class Rated; class Score; class Hits; class Extent; diff --git a/ffi/surface/api/dart.dart b/ffi/surface/api/dart.dart index 3cde662a5..d79546c94 100644 --- a/ffi/surface/api/dart.dart +++ b/ffi/surface/api/dart.dart @@ -337,6 +337,13 @@ final class Clocked { @override bool operator ==(Object other); @override int get hashCode; } +final class Rated { + String debug(); + @override bool operator ==(Object other); + @override int get hashCode; + factory Rated(U64 count, U64 scale); + U64 scale(); +} final class Score { String debug(); factory Score.of(U64 count); diff --git a/ffi/surface/api/go.txt b/ffi/surface/api/go.txt index eec351aa7..065570e1b 100644 --- a/ffi/surface/api/go.txt +++ b/ffi/surface/api/go.txt @@ -1361,6 +1361,14 @@ type Qualifiers struct { Kotlin float64 } func (self Qualifiers) Equal(other Qualifiers) bool +type Rated struct { + Bytes_ [2]uint64 + Made_ bool +} +func NewRated(count uint64, scale uint64) Rated +func (self Rated) Equal(other Rated) bool +func (self Rated) GoString() string +func (self Rated) Scale() uint64 type Reading struct { Ok bool Level float32 diff --git a/ffi/surface/api/kotlin.kt b/ffi/surface/api/kotlin.kt index 280423217..9a5b781ec 100644 --- a/ffi/surface/api/kotlin.kt +++ b/ffi/surface/api/kotlin.kt @@ -206,6 +206,15 @@ class Wide internal constructor() { data class Clocked(val at: api.Moment, val count: kotlin.UInt) { fun debug(): kotlin.String } +class Rated internal constructor() { + fun debug(): kotlin.String + override fun equals(other: kotlin.Any?): kotlin.Boolean + override fun hashCode(): kotlin.Int + fun scale(): kotlin.ULong + companion object { + fun new(count: kotlin.ULong, scale: kotlin.ULong): api.Rated + } +} @kotlin.jvm.JvmInline value class Score internal constructor(internal val bits: Long) { fun debug(): kotlin.String fun count(): kotlin.ULong diff --git a/ffi/surface/api/python.pyi b/ffi/surface/api/python.pyi index 1a31c83bb..400af12eb 100644 --- a/ffi/surface/api/python.pyi +++ b/ffi/surface/api/python.pyi @@ -174,6 +174,12 @@ class Clocked: at: Moment count: _int def __repr__(self) -> _str: ... +class Rated(_n.Value): + def __eq__(self, other: _object) -> _bool: ... + def __repr__(self) -> _str: ... + @_staticmethod + def new(count: _int, scale: _int) -> Rated: ... + def scale(self) -> _int: ... class Score(_n.Value): def __repr__(self) -> _str: ... @_staticmethod diff --git a/ffi/surface/api/swift.swift b/ffi/surface/api/swift.swift index cc6d70a84..5f52ed13e 100644 --- a/ffi/surface/api/swift.swift +++ b/ffi/surface/api/swift.swift @@ -331,6 +331,12 @@ public struct Clocked: Sendable, CustomDebugStringConvertible, Equatable { @inlinable public var debugDescription: Swift.String { get } @inlinable public static func == (a: Clocked, b: Clocked) -> Swift.Bool } +public struct Rated: Sendable, CustomDebugStringConvertible, Equatable { + @inlinable public var debugDescription: Swift.String { get } + @inlinable public static func == (a: Rated, b: Rated) -> Swift.Bool + @inlinable public static func new(_ count: Swift.UInt64, _ scale: Swift.UInt64) -> Rated + @inlinable public func scale() -> Swift.UInt64 +} public struct Score: Sendable, CustomDebugStringConvertible { @inlinable public var debugDescription: Swift.String { get } @inlinable public static func of(_ count: Swift.UInt64) -> Score diff --git a/ffi/surface/api/web.d.ts b/ffi/surface/api/web.d.ts index 19c475741..ebcbe647a 100644 --- a/ffi/surface/api/web.d.ts +++ b/ffi/surface/api/web.d.ts @@ -1057,6 +1057,15 @@ export type Qualifiers = { }; export declare function eq(a: Qualifiers, b: Qualifiers): boolean; +// Rated.ts +import * as rt from "./rt.ts"; +export type Rated = rt.Opaque<"Rated">; +export declare function debug(self: Rated): string; +export declare function eq(a: Rated, b: Rated): boolean; +export declare function new$(count: rt.u64, scale: rt.u64): Rated; +export declare function scale(self: Rated): rt.u64; +export { new$ as new }; + // Reading.ts import * as rt from "./rt.ts"; import type { Point } from "./Point.ts"; @@ -1544,6 +1553,7 @@ import type { PolarPoint } from "./PolarPoint.ts"; import type { PolarTurn } from "./PolarTurn.ts"; import type { Polar_Turn } from "./Polar_Turn.ts"; import type { Qualifiers } from "./Qualifiers.ts"; +import type { Rated } from "./Rated.ts"; import type { Reading } from "./Reading.ts"; import type { Refusal } from "./Refusal.ts"; import type { RightLeftU8 } from "./RightLeftU8.ts"; @@ -1725,6 +1735,7 @@ export declare function r_Peer(p: number, o: boolean): Peer; export declare function r_Placement(p: number, o: boolean): Placement; export declare function r_Platform(p: number, o: boolean): Platform; export declare function r_Point(p: number, o: boolean): Point; +export declare function r_Rated(p: number, o: boolean): Rated; export declare function r_Reading(p: number, o: boolean): Reading; export declare function r_Score(p: number, o: boolean): Score; export declare function r_Seat(p: number, o: boolean): Seat; @@ -1907,6 +1918,7 @@ export declare function w_Platform(p: number, v: Platform): void; export declare function w_Point(p: number, v: Point): void; export declare function w_PolarTurn(p: number, v: PolarTurn): void; export declare function w_Qualifiers(p: number, v: Qualifiers): void; +export declare function w_Rated(p: number, v: Rated): void; export declare function w_Reading(p: number, v: Reading): void; export declare function w_Right_Left_u8(p: number, v: RightLeftU8): void; export declare function w_Right_u8(p: number, v: RightU8): void; diff --git a/ffi/tests/miri/api.rs b/ffi/tests/miri/api.rs index 7a16ffa0d..07330b139 100644 --- a/ffi/tests/miri/api.rs +++ b/ffi/tests/miri/api.rs @@ -116,6 +116,20 @@ fn handles() { } } +/// A value whose `None` its niche encodes crosses with every byte initialized, as C reads +/// each of its words: Miri fails on one Rust left uninitialized. +#[test] +fn niche_value() { + for scale in [0, 1000] { + unsafe { + let rated = api_Rated_new(7, scale); + let words = rated.opaque.map(|word| word.assume_init()); + assert_eq!(words.iter().filter(|&&word| word == 7).count(), 1); + assert_eq!(api_Rated_scale(&rated), scale); + } + } +} + /// A close while a call reserved the value to move out fails as borrowed, so the call's /// rollback, once a later check of it fails, revives no value the close reported dropped. #[test] diff --git a/quest/m1/ffi-export/niche-values.md b/quest/m1/ffi-export/niche-values.md deleted file mode 100644 index e73cada39..000000000 --- a/quest/m1/ffi-export/niche-values.md +++ /dev/null @@ -1,39 +0,0 @@ -# [M] Cross a value whose niche fills its bytes as an opaque value - -## Goal - -A `Copy` type with private fields whose every value initializes all its bytes crosses as an -opaque value, copied across, even when a field is an enum whose dataless variant is encoded -in another variant's niche, such as `Option>`. moq's `Timestamp`, `{ value: -u64, scale: Option }` at moq `1aa86d5e6`, crosses as its 16 bytes again, and the -binding benchmark's stamped write is back to the cost it had as a value. - -An enum whose dataless variant leaves bytes uninitialized, such as `Option` or -`Option<(u32, NonZero)>`, whose `None` writes only the niche's 4 bytes, stays an -object. - -## Plan - -This is a general rule for every `Copy` type with a niche-encoded enum field, not a fix for -moq: `Timestamp` is only the case that found it, and nothing in the rule or its tests names -moq (maintainer decision on [kixel-ai/rust2#881](https://github.com/kixel-ai/rust2/pull/881)). - -`full` in `ffi/src/collect.rs` takes an enum's fewest initialized bytes as its smallest -variant's fields, so `None` of `Option>` counts as 0 bytes and `Timestamp` -falls back to an object. With a niche, though, rustc writes a dataless variant as the -niche field's invalid value, so it initializes that field's bytes. Count them: a dataless -variant initializes exactly the niche field's range, and the enum is full only when every -variant, so counted, fills the layout under every field order and at both model widths, -as `full` already requires of a struct. Take the niche's offset and size from rustc's -layout (`largest_niche`), and keep the model's 4- and 8-byte-pointer check on it. - -Prove it beside `full`'s existing cases: a fixture type with an `Option>` -field exports as an opaque value, and the reject fixtures keep `Option` and a niche -narrower than its payload as objects; a Miri run of the api fixture's C ABI copies a -`None` without reading uninitialized bytes. - -Found by [kixel-ai/rust2#881](https://github.com/kixel-ai/rust2/pull/881), the bump to moq -`1aa86d5e6`, where moq's `Timestamp` gained `Option` for unscaled group keys and -became a handle: its one-round benchmark there puts the stamped write at 208 ns against -173 ns with one reused timestamp in C (35 ns a timestamp), and the bench README's 2026-11-10 -measurements give the handle's cost in each language (21 ns in C up to 260 in Go). diff --git a/quest/m1/ffi-export/ship.md b/quest/m1/ffi-export/ship.md index 48e5d7073..fd044b010 100644 --- a/quest/m1/ffi-export/ship.md +++ b/quest/m1/ffi-export/ship.md @@ -26,4 +26,3 @@ then see change. A sibling planned later adds itself to `Required` here. - [Python idioms](/quest/m1/ffi-export/python-idioms.md) - the exception hierarchy changes the Python API - [Dart analysis](/quest/m1/ffi-export/dart-analyze.md) - lint fixes may rename generated Dart - [Docs](/quest/m1/ffi-export/docs.md) - doc links and deprecations in every binding -- [Niche values](/quest/m1/ffi-export/niche-values.md) - moq's `Timestamp` changes from a handle back to a value in every binding From 0a7be7f0af3c9c46f9e380f99fc80aaac2a3eac0 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Thu, 19 Nov 2026 21:01:48 -0800 Subject: [PATCH 4/9] ffi: a niche's share of a scalar, computed only when it has bytes --- ffi/src/collect.rs | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/ffi/src/collect.rs b/ffi/src/collect.rs index b3964b337..91478190e 100644 --- a/ffi/src/collect.rs +++ b/ffi/src/collect.rs @@ -6786,11 +6786,10 @@ fn full<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> bool { /// A niche of `bytes` in a scalar of `least`, as rustc's layout gives it: a thin /// pointer's whole word, or a wide one's first. fn of(least: Least, bytes: u64) -> Option { - Some(Self { + (least.bytes > 0).then(|| Self { bytes, model: least.model.map(|model| model * bytes / least.bytes), }) - .filter(|_| least.bytes > 0) } } /// The smallest of two niches, either of which may be absent. @@ -6938,10 +6937,11 @@ fn full<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> bool { } // With no niche to encode the others in, two or more variants take a tag // of at least a byte beside each one's fields; with one, a variant's own - // fields may hold the tag, so they count alone, but for a variant without - // data, which an encoding in the niche writes whole. Should a `rustc` give - // it a tag instead, the enum is a byte past a variant whose fields fill it, - // so it is never full, and a wrong count here never reaches a value. + // fields may hold the tag, so they count alone, and a variant without data + // counts the smallest niche's scalar, which an encoding in it writes whole. + // Should a `rustc` give the enum a tag instead, it is a byte past a variant + // whose fields fill it, so neither it nor what holds it is ever full, and + // the count never reaches a value. let niche = each.iter().filter_map(|v| v.niche).reduce(Niche::min); let tag = u64::from(each.len() > 1 && niche.is_none()); if let Some(niche) = niche.filter(|_| each.len() > 1) { From 910e2a54f5dcbd42a90489dd366e79e228a8f0e8 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Thu, 19 Nov 2026 21:02:02 -0800 Subject: [PATCH 5/9] ffi: fmt --- ffi/src/collect.rs | 5 ++++- ffi/tests/fixtures.rs | 16 ++++++++++++++-- 2 files changed, 18 insertions(+), 3 deletions(-) diff --git a/ffi/src/collect.rs b/ffi/src/collect.rs index 91478190e..7c37fe111 100644 --- a/ffi/src/collect.rs +++ b/ffi/src/collect.rs @@ -6959,7 +6959,10 @@ fn full<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> bool { let bytes = each.iter().map(|v| v.bytes).min()?.checked_add(tag)?; // A full enum is encoded in a variant's niche, whose scalar holds what values // remain; any other's niche, a tag's or one only partly written, may be a byte. - let least = Niche { bytes: 1, model: [1; 2] }; + let least = Niche { + bytes: 1, + model: [1; 2], + }; filled(Least { bytes, model, diff --git a/ffi/tests/fixtures.rs b/ffi/tests/fixtures.rs index b39605a4e..a9fe126b4 100644 --- a/ffi/tests/fixtures.rs +++ b/ffi/tests/fixtures.rs @@ -3761,7 +3761,9 @@ fn opaque_values() { // two `usize`s after a `u64`, which fill it at either pointer width; a `None` that writes // its niche's whole scalar, a `u64`'s, a pointer's at either width, a `bool`'s an outer // `None` shares with an inner one, or a `char`'s. - for value in ["Flag", "Tagged", "Ordered", "Words", "Scaled", "Lent", "Nested", "Chars"] { + for value in [ + "Flag", "Tagged", "Ordered", "Words", "Scaled", "Lent", "Nested", "Chars", + ] { assert!( header.contains(&format!("}} opaque_values_{value};")), "{value} is no opaque value:\n{header}" @@ -3773,7 +3775,17 @@ fn opaque_values() { // or after a `usize`, which is a gap on wasm32 alone; a `None` with no niche, writing // only its tag, or with a niche narrower than its payload, a `NonZero`'s beside a // `u32`, or a slice's pointer beside its length. - for handle in ["Pairs", "Wide", "Niched", "Word", "Mixed", "MixedWord", "Unset", "Narrow", "Sliced"] { + for handle in [ + "Pairs", + "Wide", + "Niched", + "Word", + "Mixed", + "MixedWord", + "Unset", + "Narrow", + "Sliced", + ] { assert!( header.contains(&format!("void opaque_values_{handle}_free(")), "{handle} is no handle:\n{header}" From a020da50d1e15e2d053d5b0c2d94eb276749f0ce Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Thu, 19 Nov 2026 21:07:36 -0800 Subject: [PATCH 6/9] bench: the stamped write as a value again, measured against main's handle --- bench/ffi/README.md | 33 +++++++++++++++++++++++---------- 1 file changed, 23 insertions(+), 10 deletions(-) diff --git a/bench/ffi/README.md b/bench/ffi/README.md index 88531c952..bb84d24e1 100644 --- a/bench/ffi/README.md +++ b/bench/ffi/README.md @@ -522,13 +522,13 @@ From the CPU tables of 2026-11-10, measured at rust2 `7383790d` at a load averag 29 and since replaced by the tables above, read against the code each call runs. In order of what it costs moq's frame path: -1. **A call per frame timestamp.** At moq `ffcb7cd9`, `Timestamp` was `Copy` with private - fields, so it crossed as its 16 bytes, and a stamped frame allocated and freed nothing in - Rust; at `1aa86d5e6` it is a handle again until - [niche values](/quest/m1/ffi-export/niche-values.md) lands. As a handle, it cost 21 ns - in C, 27 in Swift, 140 in Python, 250 in Kotlin, 260 in Go, and 245 in Dart (stamped - write minus write, in the tables above); as a value, see [Copy values](#copy-values): - what remains is each language's call and, in Kotlin and Python, an object of its own. +1. **A call per frame timestamp.** `Timestamp` is `Copy` with private fields, so it + crosses as its 16 bytes, and a stamped frame allocates and frees nothing in Rust. As a + handle, at moq `1aa86d5e6` before its `Option` field crossed by value, it + cost 21 ns in C, 27 in Swift, 140 in Python, 250 in Kotlin, 260 in Go, and 245 in Dart + (stamped write minus write, in the tables above); as a value, see + [Copy values](#copy-values): what remains is each language's call and, in Kotlin and + Python, an object of its own. 2. **Ownership of a returned object.** An object return costs C 25 ns, but Go 263 and Dart 242, ten times C, and most of the difference is each runtime's per-object registration with its collector. Profiled 2026-11-14 on **nixos** with `perf`, for an @@ -655,9 +655,9 @@ measure them at the load beside them. ### Copy values A `Copy` type with private fields whose every value fills its bytes crosses by value, as -`Timestamp` did at moq `ffcb7cd9`: a struct of its bytes in C, C++, Swift, Go, and Dart, a -class of a `Long` per word in Kotlin (a word value class when it fits one), and a class of -the runtime's `Value` holding its bytes in Python. +`Timestamp` does, its `None` scale written as its niche's whole `u64`: a struct of its bytes +in C, C++, Swift, Go, and Dart, a class of a `Long` per word in Kotlin (a word value class +when it fits one), and a class of the runtime's `Value` holding its bytes in Python. Measured 2026-11-13 at rust2 `7766768f`, moq `ffcb7cd9`, on an AMD Ryzen 9 9950X (32 threads), Linux, at a load average of 13 to 15, the median of 3 rounds, in CPU time: @@ -681,6 +681,19 @@ in the tables above came from another load, so Python's was also measured agains build on the same host, interleaved over 5 rounds at a load of 10 to 12: stamped minus write fell from 205 ns to 166, and the stamped write from 441 to 391. +At moq `1aa86d5e6`, `Timestamp` gained an `Option` and crossed as a handle until +the exporter counted a `None` as the niche it writes. Measured 2026-11-19 on **fedora**, the +same CPU, at a load average of 17 to 24, the median of 3 rounds of `just ffi bench` each, in +CPU time, stamped minus write: + +| | C | C++ | Swift | Go | Dart | Kotlin | Python | TS (Node) | +|---|---|---|---|---|---|---|---|---| +| handle, main at `2f63f110` | 40 | 30 | 56 | 149 | 111 | 210 | 218 | 283 | +| value | 20 | 10 | 7 | 58 | 36 | 220 | 138 | 138 | + +Rust's own `from_micros` takes 8 to 9 ns of each, against none at `ffcb7cd9`. Kotlin's CPU +time, which counts its JIT and collector, moved within its noise. + ### Against the targets Where the cases match, on wall time: Kotlin's getter costs 24 ns against BoltFFI's 5.8, From ca23749b07ca4a7ef19996f2c1fa71eba12e5cb9 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Thu, 19 Nov 2026 21:13:16 -0800 Subject: [PATCH 7/9] ffi: the surfaces regenerated after merging main --- ffi/surface/api/c.h | 9 ++- ffi/surface/api/kotlin.kt | 2 +- ffi/surface/moq/kotlin.kt | 126 ++++++++++++++++++-------------------- 3 files changed, 68 insertions(+), 69 deletions(-) diff --git a/ffi/surface/api/c.h b/ffi/surface/api/c.h index 400991c6d..9e6a27ec4 100644 --- a/ffi/surface/api/c.h +++ b/ffi/surface/api/c.h @@ -7,7 +7,7 @@ #ifdef __cplusplus extern "C" { #endif -#define API_CONTRACT ((uint64_t)0xe9e73593591b8c17ULL) +#define API_CONTRACT ((uint64_t)0x56dc8776c75ad783ULL) uint64_t api_contract(void); uint32_t api_target(void); typedef int32_t api_status; @@ -690,6 +690,9 @@ typedef struct api_Clocked { api_Moment at; uint32_t count; } api_Clocked; +typedef struct api_Rated { + uint64_t opaque[2]; +} api_Rated; typedef struct api_Hits { uint64_t opaque[2]; } api_Hits; @@ -1162,6 +1165,10 @@ uint64_t api_Wide_sum(const api_Wide *self); void api_Clocked_free(api_Clocked *self); bool api_Clocked_eq(const api_Clocked *a, const api_Clocked *b); api_buf api_Clocked_debug(const api_Clocked *self); +bool api_Rated_eq(const api_Rated *a, const api_Rated *b); +api_buf api_Rated_debug(const api_Rated *self); +api_Rated api_Rated_new(uint64_t count, uint64_t scale); +uint64_t api_Rated_scale(const api_Rated *self); api_buf api_Score_debug(const api_Score *self); api_Score api_Score_of(uint64_t count); uint64_t api_Score_count(const api_Score *self); diff --git a/ffi/surface/api/kotlin.kt b/ffi/surface/api/kotlin.kt index 983632c0d..102c15088 100644 --- a/ffi/surface/api/kotlin.kt +++ b/ffi/surface/api/kotlin.kt @@ -215,7 +215,7 @@ class Rated internal constructor() { override fun hashCode(): kotlin.Int fun scale(): kotlin.ULong companion object { - fun new(count: kotlin.ULong, scale: kotlin.ULong): api.Rated + @kotlin.jvm.JvmStatic fun new(count: kotlin.ULong, scale: kotlin.ULong): api.Rated } } @kotlin.jvm.JvmInline value class Score internal constructor(internal val bits: Long) { diff --git a/ffi/surface/moq/kotlin.kt b/ffi/surface/moq/kotlin.kt index 9267adda9..a8d95a454 100644 --- a/ffi/surface/moq/kotlin.kt +++ b/ffi/surface/moq/kotlin.kt @@ -139,6 +139,32 @@ class ArrayU8x6(bytes: ByteArray) { @kotlin.jvm.JvmStatic @kotlin.jvm.Throws(TimeOverflowException::class) fun new(unitsPerSecond: kotlin.ULong): moq.Timescale } } +class Timestamp internal constructor() { + fun debug(): kotlin.String + override fun equals(other: kotlin.Any?): kotlin.Boolean + override fun hashCode(): kotlin.Int + fun value(): kotlin.ULong + fun scale(): moq.Timescale? + fun isZero(): kotlin.Boolean + @kotlin.jvm.Throws(TimeOverflowException::class) fun convert(newScale: moq.Timescale): moq.Timestamp + @kotlin.jvm.Throws(TimeOverflowException::class) fun asScale(target: moq.Timescale): java.math.BigInteger + @kotlin.jvm.Throws(TimeOverflowException::class) fun asSecs(): kotlin.ULong + @kotlin.jvm.Throws(TimeOverflowException::class) fun asMillis(): java.math.BigInteger + @kotlin.jvm.Throws(TimeOverflowException::class) fun asMicros(): java.math.BigInteger + @kotlin.jvm.Throws(TimeOverflowException::class) fun asNanos(): java.math.BigInteger + @kotlin.jvm.Throws(TimeOverflowException::class) fun checkedAdd(rhs: moq.Timestamp): moq.Timestamp + @kotlin.jvm.Throws(TimeOverflowException::class) fun checkedSub(rhs: moq.Timestamp): moq.Timestamp + companion object { + @kotlin.jvm.JvmStatic val ZERO: moq.Timestamp + @kotlin.jvm.JvmStatic @kotlin.jvm.Throws(TimeOverflowException::class) fun new(value: kotlin.ULong, scale: moq.Timescale): moq.Timestamp + @kotlin.jvm.JvmStatic fun unscaled(key: kotlin.ULong): moq.Timestamp + @kotlin.jvm.JvmStatic @kotlin.jvm.Throws(TimeOverflowException::class) fun fromScale(value: kotlin.ULong, unitsPerSecond: kotlin.ULong): moq.Timestamp + @kotlin.jvm.JvmStatic @kotlin.jvm.Throws(TimeOverflowException::class) fun fromSecs(seconds: kotlin.ULong): moq.Timestamp + @kotlin.jvm.JvmStatic @kotlin.jvm.Throws(TimeOverflowException::class) fun fromMillis(millis: kotlin.ULong): moq.Timestamp + @kotlin.jvm.JvmStatic @kotlin.jvm.Throws(TimeOverflowException::class) fun fromMicros(micros: kotlin.ULong): moq.Timestamp + @kotlin.jvm.JvmStatic @kotlin.jvm.Throws(TimeOverflowException::class) fun fromNanos(nanos: kotlin.ULong): moq.Timestamp + } +} @kotlin.jvm.JvmInline value class ClockInstant internal constructor(internal val bits: Long) { fun debug(): kotlin.String fun elapsed(): moq.Duration @@ -426,6 +452,28 @@ class StatsWithdrawals internal constructor() { @kotlin.jvm.JvmStatic fun default(): moq.StatsWithdrawals } } +class TransportReceiveWindow internal constructor() { + fun debug(): kotlin.String + override fun equals(other: kotlin.Any?): kotlin.Boolean + override fun hashCode(): kotlin.Int + val connectionGet: kotlin.ULong? + fun connectionSet(value: kotlin.ULong?): moq.TransportReceiveWindow + val streamGet: kotlin.ULong + fun streamSet(value: kotlin.ULong): moq.TransportReceiveWindow + companion object { + @kotlin.jvm.JvmStatic fun new(connection: kotlin.ULong?, stream: kotlin.ULong): moq.TransportReceiveWindow + } +} +class TransportLimits internal constructor() { + fun debug(): kotlin.String + override fun equals(other: kotlin.Any?): kotlin.Boolean + override fun hashCode(): kotlin.Int + val receiveWindowGet: kotlin.ULong? + fun receiveWindowSet(value: kotlin.ULong?): moq.TransportLimits + companion object { + @kotlin.jvm.JvmStatic fun default(): moq.TransportLimits + } +} @kotlin.jvm.JvmInline value class BandwidthRate internal constructor(internal val bits: Long) { fun debug(): kotlin.String fun asBps(): kotlin.ULong @@ -497,6 +545,17 @@ data class HangCatalogAac(val profile: kotlin.UByte) { final override fun toString(): kotlin.String fun debug(): kotlin.String } +class HangCatalogClock internal constructor() { + fun debug(): kotlin.String + override fun equals(other: kotlin.Any?): kotlin.Boolean + override fun hashCode(): kotlin.Int + val wallGet: moq.Timestamp + fun wallSet(value: moq.Timestamp): moq.HangCatalogClock + @kotlin.jvm.Throws(HangErrorException::class) fun wallClock(pts: moq.Timestamp): moq.ClockWall + companion object { + @kotlin.jvm.JvmStatic @kotlin.jvm.Throws(HangErrorException::class) fun new(wall: moq.Timestamp): moq.HangCatalogClock + } +} @kotlin.jvm.JvmInline value class HangCatalogPriorities internal constructor(internal val bits: Long) { fun debug(): kotlin.String val catalogGet: kotlin.Byte @@ -1576,34 +1635,6 @@ class Error internal constructor(raw: Long, lent: Boolean = false) : AutoCloseab @kotlin.jvm.JvmStatic fun fromTransportMemoryError(err: moq.TransportMemoryError): moq.Error } } -class Timestamp internal constructor(raw: Long, lent: Boolean = false) : AutoCloseable { - override fun close() - fun debug(): kotlin.String - fun clone(): moq.Timestamp - override fun equals(other: kotlin.Any?): kotlin.Boolean - override fun hashCode(): kotlin.Int - fun value(): kotlin.ULong - fun scale(): moq.Timescale? - fun isZero(): kotlin.Boolean - @kotlin.jvm.Throws(TimeOverflowException::class) fun convert(newScale: moq.Timescale): moq.Timestamp - @kotlin.jvm.Throws(TimeOverflowException::class) fun asScale(target: moq.Timescale): java.math.BigInteger - @kotlin.jvm.Throws(TimeOverflowException::class) fun asSecs(): kotlin.ULong - @kotlin.jvm.Throws(TimeOverflowException::class) fun asMillis(): java.math.BigInteger - @kotlin.jvm.Throws(TimeOverflowException::class) fun asMicros(): java.math.BigInteger - @kotlin.jvm.Throws(TimeOverflowException::class) fun asNanos(): java.math.BigInteger - @kotlin.jvm.Throws(TimeOverflowException::class) fun checkedAdd(rhs: moq.Timestamp): moq.Timestamp - @kotlin.jvm.Throws(TimeOverflowException::class) fun checkedSub(rhs: moq.Timestamp): moq.Timestamp - companion object { - @kotlin.jvm.JvmStatic val ZERO: moq.Timestamp - @kotlin.jvm.JvmStatic @kotlin.jvm.Throws(TimeOverflowException::class) fun new(value: kotlin.ULong, scale: moq.Timescale): moq.Timestamp - @kotlin.jvm.JvmStatic fun unscaled(key: kotlin.ULong): moq.Timestamp - @kotlin.jvm.JvmStatic @kotlin.jvm.Throws(TimeOverflowException::class) fun fromScale(value: kotlin.ULong, unitsPerSecond: kotlin.ULong): moq.Timestamp - @kotlin.jvm.JvmStatic @kotlin.jvm.Throws(TimeOverflowException::class) fun fromSecs(seconds: kotlin.ULong): moq.Timestamp - @kotlin.jvm.JvmStatic @kotlin.jvm.Throws(TimeOverflowException::class) fun fromMillis(millis: kotlin.ULong): moq.Timestamp - @kotlin.jvm.JvmStatic @kotlin.jvm.Throws(TimeOverflowException::class) fun fromMicros(micros: kotlin.ULong): moq.Timestamp - @kotlin.jvm.JvmStatic @kotlin.jvm.Throws(TimeOverflowException::class) fun fromNanos(nanos: kotlin.ULong): moq.Timestamp - } -} class Version internal constructor(raw: Long, lent: Boolean = false) : AutoCloseable { override fun close() final override fun toString(): kotlin.String @@ -2450,32 +2481,6 @@ class TransportProbe internal constructor(raw: Long, lent: Boolean = false) : Au @kotlin.jvm.JvmStatic fun new(): moq.TransportProbe } } -class TransportReceiveWindow internal constructor(raw: Long, lent: Boolean = false) : AutoCloseable { - override fun close() - fun debug(): kotlin.String - fun clone(): moq.TransportReceiveWindow - override fun equals(other: kotlin.Any?): kotlin.Boolean - override fun hashCode(): kotlin.Int - val connectionGet: kotlin.ULong? - fun connectionSet(value: kotlin.ULong?) - val streamGet: kotlin.ULong - fun streamSet(value: kotlin.ULong) - companion object { - @kotlin.jvm.JvmStatic fun new(connection: kotlin.ULong?, stream: kotlin.ULong): moq.TransportReceiveWindow - } -} -class TransportLimits internal constructor(raw: Long, lent: Boolean = false) : AutoCloseable { - override fun close() - fun debug(): kotlin.String - fun clone(): moq.TransportLimits - override fun equals(other: kotlin.Any?): kotlin.Boolean - override fun hashCode(): kotlin.Int - val receiveWindowGet: kotlin.ULong? - fun receiveWindowSet(value: kotlin.ULong?) - companion object { - @kotlin.jvm.JvmStatic fun default(): moq.TransportLimits - } -} class BandwidthLimit internal constructor(raw: Long, lent: Boolean = false) : AutoCloseable { override fun close() fun debug(): kotlin.String @@ -3434,19 +3439,6 @@ class HangCatalogBinaryConfig internal constructor(raw: Long, lent: Boolean = fa @kotlin.jvm.JvmStatic fun new(mode: moq.HangCatalogMode): moq.HangCatalogBinaryConfig } } -class HangCatalogClock internal constructor(raw: Long, lent: Boolean = false) : AutoCloseable { - override fun close() - fun debug(): kotlin.String - fun clone(): moq.HangCatalogClock - override fun equals(other: kotlin.Any?): kotlin.Boolean - override fun hashCode(): kotlin.Int - val wallGet: moq.Timestamp - fun wallSet(value: moq.Timestamp) - @kotlin.jvm.Throws(HangErrorException::class) fun wallClock(pts: moq.Timestamp): moq.ClockWall - companion object { - @kotlin.jvm.JvmStatic @kotlin.jvm.Throws(HangErrorException::class) fun new(wall: moq.Timestamp): moq.HangCatalogClock - } -} class HangCatalogContainer internal constructor(raw: Long, lent: Boolean = false) : AutoCloseable { override fun close() fun debug(): kotlin.String From 635032ed2a33479248b7367bb3c7580c410ca3c6 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Thu, 19 Nov 2026 21:39:52 -0800 Subject: [PATCH 8/9] ffi: the C surface regenerated after merging main --- ffi/surface/api/c.h | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/ffi/surface/api/c.h b/ffi/surface/api/c.h index 3a97c236e..08d047e2a 100644 --- a/ffi/surface/api/c.h +++ b/ffi/surface/api/c.h @@ -7,7 +7,7 @@ #ifdef __cplusplus extern "C" { #endif -#define API_CONTRACT ((uint64_t)0xcadf3d448a865171ULL) +#define API_CONTRACT ((uint64_t)0xe8ef8b7c46c50cebULL) uint64_t api_contract(void); uint32_t api_target(void); typedef int32_t api_status; @@ -691,6 +691,9 @@ typedef struct api_Clocked { api_Moment at; uint32_t count; } api_Clocked; +typedef struct api_Rated { + uint64_t opaque[2]; +} api_Rated; typedef struct api_Hits { uint64_t opaque[2]; } api_Hits; @@ -1163,6 +1166,10 @@ uint64_t api_Wide_sum(const api_Wide *self); void api_Clocked_free(api_Clocked *self); bool api_Clocked_eq(const api_Clocked *a, const api_Clocked *b); api_buf api_Clocked_debug(const api_Clocked *self); +bool api_Rated_eq(const api_Rated *a, const api_Rated *b); +api_buf api_Rated_debug(const api_Rated *self); +api_Rated api_Rated_new(uint64_t count, uint64_t scale); +uint64_t api_Rated_scale(const api_Rated *self); api_buf api_Score_debug(const api_Score *self); api_Score api_Score_of(uint64_t count); uint64_t api_Score_count(const api_Score *self); From efe55a94267d46a4ddf9b7a40efecb6eb958e5b1 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Thu, 19 Nov 2026 22:08:11 -0800 Subject: [PATCH 9/9] ffi: moq.cpp says a timestamp is copied, as the other scripts do --- ffi/moq/moq.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/ffi/moq/moq.cpp b/ffi/moq/moq.cpp index eb4ef8b59..c81b62342 100644 --- a/ffi/moq/moq.cpp +++ b/ffi/moq/moq.cpp @@ -161,8 +161,8 @@ int main() { CHECK(moq::clock_now().checked_duration_since(hello.arrived()).has_value()); } - // A timestamp is a handle, which a call borrows and leaves usable. The track is untimed, - // so a timed frame is refused. + // A timestamp is a `Copy` value copied across, which allocates nothing. The track is + // untimed, so a timed frame is refused. auto at = moq::Timestamp::from_millis(1500); CHECK(at && at->as_secs() && *at->as_secs() == 1); auto late = writer->write_frame(*at, "late");