Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
4 changes: 2 additions & 2 deletions .taplo.toml
Original file line number Diff line number Diff line change
@@ -1,5 +1,5 @@
# Skip vendored, build, and scratch trees so `taplo format` doesn't recurse into them.
exclude = ["**/node_modules/**", "**/target/**", "**/dist/**", "**/.venv/**", "**/.direnv/**", "**/.tmp/**"]
# Skip vendored, build, and scratch trees (c/moq/build links into target/) so `taplo format` doesn't recurse into them.
exclude = ["**/node_modules/**", "**/target/**", "c/moq/build/**", "**/dist/**", "**/.venv/**", "**/.direnv/**", "**/.tmp/**"]

# Match the existing repo style (4-space indent on Cargo.toml, lines up
# to ~120 chars) so the initial format pass stays minimal.
Expand Down
3 changes: 3 additions & 0 deletions dart/moq/lib/src/aliases.dart
Original file line number Diff line number Diff line change
Expand Up @@ -144,6 +144,9 @@ typedef Anchor = MoqAnchor;
/// Which pending group the publisher sends first.
typedef Order = MoqOrder;

/// A location within a track: a group sequence and a frame index in it.
typedef Position = MoqPosition;

/// Options for fetching one past group by sequence.
typedef FetchGroupOptions = MoqFetchGroupOptions;

Expand Down
189 changes: 189 additions & 0 deletions dart/moq_ffi/lib/src/moq.dart
Original file line number Diff line number Diff line change
Expand Up @@ -8,7 +8,9 @@ import "dart:ffi";
import "dart:io" show Platform, File, Directory;
import "dart:isolate";
import "dart:typed_data";

import "package:ffi/ffi.dart";

import "uniffi_runtime.dart";
export "uniffi_runtime.dart";

Expand Down Expand Up @@ -2860,6 +2862,65 @@ class FfiConverterMoqRoute {
}
}

class MoqPosition {
final int group;
final int frame;
MoqPosition({required this.group, required this.frame});
}

class FfiConverterMoqPosition {
static MoqPosition lift(RustBuffer buf) {
return FfiConverterMoqPosition.read(buf.asUint8List()).value;
}

static LiftRetVal<MoqPosition> read(Uint8List buf) {
int new_offset = buf.offsetInBytes;
final group_lifted = FfiConverterUInt64.read(
Uint8List.view(buf.buffer, new_offset),
);
final group = group_lifted.value;
new_offset += group_lifted.bytesRead;
final frame_lifted = FfiConverterUInt64.read(
Uint8List.view(buf.buffer, new_offset),
);
final frame = frame_lifted.value;
new_offset += frame_lifted.bytesRead;
return LiftRetVal(
MoqPosition(group: group, frame: frame),
new_offset - buf.offsetInBytes,
);
}

static RustBuffer lower(MoqPosition value) {
final total_length =
FfiConverterUInt64.allocationSize(value.group) +
FfiConverterUInt64.allocationSize(value.frame) +
0;
final buf = Uint8List(total_length);
write(value, buf);
return toRustBuffer(buf);
}

static int write(MoqPosition value, Uint8List buf) {
int new_offset = buf.offsetInBytes;
new_offset += FfiConverterUInt64.write(
value.group,
Uint8List.view(buf.buffer, new_offset),
);
new_offset += FfiConverterUInt64.write(
value.frame,
Uint8List.view(buf.buffer, new_offset),
);
return new_offset - buf.offsetInBytes;
}

static int allocationSize(MoqPosition value) {
return FfiConverterUInt64.allocationSize(value.group) +
FfiConverterUInt64.allocationSize(value.frame) +
0;
}
}

class MoqTrackInfo {
final int priority;
final Duration? maxAge;
Expand Down Expand Up @@ -9379,6 +9440,7 @@ class FfiConverterMoqReservation {
}

abstract class MoqBroadcastConsumerInterface {
UniffiRustFuture<void> closed();
UniffiRustFuture<MoqGroupConsumer> fetchGroup({
required String name,
required int sequence,
Expand Down Expand Up @@ -9428,6 +9490,20 @@ class MoqBroadcastConsumer implements MoqBroadcastConsumerInterface {
);
}

UniffiRustFuture<void> closed() {
return uniffiRustCallAsync(
() => uniffi_moq_ffi_fn_method_moqbroadcastconsumer_closed(
uniffiClonePointer(),
),
ffi_moq_ffi_rust_future_poll_void,
ffi_moq_ffi_rust_future_complete_void,
ffi_moq_ffi_rust_future_cancel_void,
ffi_moq_ffi_rust_future_free_void,
(_) {},
moqExceptionErrorHandler,
);
}

UniffiRustFuture<MoqGroupConsumer> fetchGroup({
required String name,
required int sequence,
Expand Down Expand Up @@ -12823,6 +12899,8 @@ abstract class MoqTrackProducerInterface {
MoqTrackDemand demand();
void finish();
void finishAt({required int finalSequence});
void insertDatagram({required int sequence, required MoqFrame frame});
MoqPosition? largest();
MoqTrackRequests requests();
void writeFrame({required MoqFrame frame});
}
Expand Down Expand Up @@ -12945,6 +13023,28 @@ class MoqTrackProducer implements MoqTrackProducerInterface {
}, moqExceptionErrorHandler);
}

void insertDatagram({required int sequence, required MoqFrame frame}) {
return rustCall((status) {
uniffi_moq_ffi_fn_method_moqtrackproducer_insert_datagram(
uniffiClonePointer(),
FfiConverterUInt64.lower(sequence),
FfiConverterMoqFrame.lower(frame),
status,
);
}, moqExceptionErrorHandler);
}

MoqPosition? largest() {
return rustCallWithLifter(
(status) => uniffi_moq_ffi_fn_method_moqtrackproducer_largest(
uniffiClonePointer(),
status,
),
FfiConverterOptionalMoqPosition.lift,
moqExceptionErrorHandler,
);
}

MoqTrackRequests requests() {
return rustCallWithLifter(
(status) => uniffi_moq_ffi_fn_method_moqtrackproducer_requests(
Expand Down Expand Up @@ -15806,6 +15906,53 @@ class FfiConverterOptionalMoqOriginProducer {
}
}

class FfiConverterOptionalMoqPosition {
static MoqPosition? lift(RustBuffer buf) {
return FfiConverterOptionalMoqPosition.read(buf.asUint8List()).value;
}

static LiftRetVal<MoqPosition?> read(Uint8List buf) {
if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) {
return LiftRetVal(null, 1);
}
final result = FfiConverterMoqPosition.read(
Uint8List.view(buf.buffer, buf.offsetInBytes + 1),
);
return LiftRetVal<MoqPosition?>(result.value, result.bytesRead + 1);
}

static int allocationSize([MoqPosition? value]) {
if (value == null) {
return 1;
}
return FfiConverterMoqPosition.allocationSize(value) + 1;
}

static RustBuffer lower(MoqPosition? value) {
if (value == null) {
return toRustBuffer(Uint8List.fromList([0]));
}
final buf = Uint8List(
FfiConverterOptionalMoqPosition.allocationSize(value),
);
FfiConverterOptionalMoqPosition.write(value, buf);
return toRustBuffer(buf);
}

static int write(MoqPosition? value, Uint8List buf) {
if (value == null) {
buf[0] = 0;
return 1;
}
buf[0] = 1;
return FfiConverterMoqPosition.write(
value,
Uint8List.view(buf.buffer, buf.offsetInBytes + 1),
) +
1;
}
}

class FfiConverterOptionalMoqRequest {
static MoqRequest? lift(RustBuffer buf) {
return FfiConverterOptionalMoqRequest.read(buf.asUint8List()).value;
Expand Down Expand Up @@ -17321,6 +17468,11 @@ external void uniffi_moq_ffi_fn_free_moqbroadcastconsumer(
Pointer<RustCallStatus> uniffiStatus,
);

@Native<Pointer<Void> Function(Pointer<Void>)>(assetId: _uniffiAssetId)
external Pointer<Void> uniffi_moq_ffi_fn_method_moqbroadcastconsumer_closed(
Pointer<Void> ptr,
);

@Native<Pointer<Void> Function(Pointer<Void>, RustBuffer, Uint64, RustBuffer)>(
assetId: _uniffiAssetId,
)
Expand Down Expand Up @@ -18876,6 +19028,24 @@ external void uniffi_moq_ffi_fn_method_moqtrackproducer_finish_at(
Pointer<RustCallStatus> uniffiStatus,
);

@Native<
Void Function(Pointer<Void>, Uint64, RustBuffer, Pointer<RustCallStatus>)
>(assetId: _uniffiAssetId)
external void uniffi_moq_ffi_fn_method_moqtrackproducer_insert_datagram(
Pointer<Void> ptr,
int sequence,
RustBuffer frame,
Pointer<RustCallStatus> uniffiStatus,
);

@Native<RustBuffer Function(Pointer<Void>, Pointer<RustCallStatus>)>(
assetId: _uniffiAssetId,
)
external RustBuffer uniffi_moq_ffi_fn_method_moqtrackproducer_largest(
Pointer<Void> ptr,
Pointer<RustCallStatus> uniffiStatus,
);

@Native<Pointer<Void> Function(Pointer<Void>, Pointer<RustCallStatus>)>(
assetId: _uniffiAssetId,
)
Expand Down Expand Up @@ -19974,6 +20144,9 @@ external int uniffi_moq_ffi_checksum_method_moqreservation_rate();
@Native<Uint16 Function()>(assetId: _uniffiAssetId)
external int uniffi_moq_ffi_checksum_method_moqreservation_update();

@Native<Uint16 Function()>(assetId: _uniffiAssetId)
external int uniffi_moq_ffi_checksum_method_moqbroadcastconsumer_closed();

@Native<Uint16 Function()>(assetId: _uniffiAssetId)
external int uniffi_moq_ffi_checksum_method_moqbroadcastconsumer_fetch_group();

Expand Down Expand Up @@ -20318,6 +20491,12 @@ external int uniffi_moq_ffi_checksum_method_moqtrackproducer_finish();
@Native<Uint16 Function()>(assetId: _uniffiAssetId)
external int uniffi_moq_ffi_checksum_method_moqtrackproducer_finish_at();

@Native<Uint16 Function()>(assetId: _uniffiAssetId)
external int uniffi_moq_ffi_checksum_method_moqtrackproducer_insert_datagram();

@Native<Uint16 Function()>(assetId: _uniffiAssetId)
external int uniffi_moq_ffi_checksum_method_moqtrackproducer_largest();

@Native<Uint16 Function()>(assetId: _uniffiAssetId)
external int uniffi_moq_ffi_checksum_method_moqtrackproducer_requests();

Expand Down Expand Up @@ -20670,6 +20849,9 @@ void _checkApiChecksums() {
if (uniffi_moq_ffi_checksum_method_moqreservation_update() != 9626) {
throw UniffiInternalError.panicked("UniFFI API checksum mismatch");
}
if (uniffi_moq_ffi_checksum_method_moqbroadcastconsumer_closed() != 12232) {
throw UniffiInternalError.panicked("UniFFI API checksum mismatch");
}
if (uniffi_moq_ffi_checksum_method_moqbroadcastconsumer_fetch_group() !=
18633) {
throw UniffiInternalError.panicked("UniFFI API checksum mismatch");
Expand Down Expand Up @@ -21030,6 +21212,13 @@ void _checkApiChecksums() {
if (uniffi_moq_ffi_checksum_method_moqtrackproducer_finish_at() != 24581) {
throw UniffiInternalError.panicked("UniFFI API checksum mismatch");
}
if (uniffi_moq_ffi_checksum_method_moqtrackproducer_insert_datagram() !=
29400) {
throw UniffiInternalError.panicked("UniFFI API checksum mismatch");
}
if (uniffi_moq_ffi_checksum_method_moqtrackproducer_largest() != 3968) {
throw UniffiInternalError.panicked("UniFFI API checksum mismatch");
}
if (uniffi_moq_ffi_checksum_method_moqtrackproducer_requests() != 60252) {
throw UniffiInternalError.panicked("UniFFI API checksum mismatch");
}
Expand Down
3 changes: 2 additions & 1 deletion go/wrapper/README.md
Original file line number Diff line number Diff line change
Expand Up @@ -150,7 +150,8 @@ See the package doc for details.
## Raw datagrams

Raw tracks support best-effort datagrams alongside groups: `TrackProducer.AppendDatagram`
sends one `Frame` and returns its sequence number, while `TrackConsumer.RecvDatagram`
sends one `Frame` and returns its sequence number (`InsertDatagram` takes the caller's
own sequence instead), while `TrackConsumer.RecvDatagram`
and `TrackConsumer.Datagrams` receive them in arrival order. Payloads are capped at
1200 bytes. Datagram delivery requires a datagram-capable transport and lite-05 or
newer moq-lite, or moq-transport; pre-lite-05, WebSocket, and TCP paths do not
Expand Down
64 changes: 64 additions & 0 deletions go/wrapper/moq_test.go
Original file line number Diff line number Diff line change
Expand Up @@ -530,6 +530,70 @@ func testDecodeVideoFrame(t *testing.T, surface bool) {
}
}

func TestInsertDatagramAndLargest(t *testing.T) {
ctx, cancel := context.WithTimeout(context.Background(), testTimeout)
defer cancel()

broadcast, err := moq.NewBroadcastProducer()
if err != nil {
t.Fatal(err)
}
track, err := broadcast.PublishTrack("events", timedInfo())
if err != nil {
t.Fatal(err)
}
consumer, err := track.Consume(nil)
if err != nil {
t.Fatal(err)
}
if largest, err := track.Largest(); err != nil || largest != nil {
t.Fatalf("empty track: largest %v, err %v", largest, err)
}

if err := track.InsertDatagram(7, moq.Frame{Payload: []byte("seven"), Timestamp: ts(0)}); err != nil {
t.Fatal(err)
}
datagram, err := consumer.RecvDatagram(ctx)
if err != nil {
t.Fatal(err)
}
if datagram == nil || datagram.Sequence != 7 || string(datagram.Payload) != "seven" {
t.Fatalf("got datagram %+v", datagram)
}
largest, err := track.Largest()
if err != nil {
t.Fatal(err)
}
if largest == nil || *largest != (moq.Position{Group: 7, Frame: 0}) {
t.Fatalf("largest %+v", largest)
}
if next, err := track.AppendDatagram(moq.Frame{Payload: []byte("next"), Timestamp: ts(0)}); err != nil || next != 8 {
t.Fatalf("appended at %d, err %v", next, err)
}
}

func TestBroadcastConsumerClosed(t *testing.T) {
ctx, cancel := context.WithTimeout(context.Background(), testTimeout)
defer cancel()

broadcast, err := moq.NewBroadcastProducer()
if err != nil {
t.Fatal(err)
}
consumer, err := broadcast.Consume()
if err != nil {
t.Fatal(err)
}
closed := make(chan error, 1)
go func() { closed <- consumer.Closed(ctx) }()
if err := broadcast.Close(); err != nil {
t.Fatal(err)
}
if err := <-closed; err != nil {
t.Fatal(err)
}
}

func TestFetchGroupAndServeDynamicMiss(t *testing.T) {
ctx, cancel := context.WithTimeout(context.Background(), testTimeout)
defer cancel()
Expand Down
Loading
Loading