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
9 changes: 9 additions & 0 deletions cpp/moq/MIGRATE.md
Original file line number Diff line number Diff line change
Expand Up @@ -4,6 +4,15 @@ How to update your code for each breaking change, newest first.

## Unreleased

### Container byte streams use `MediaContainerProducer` (#5919)

`moq::MediaContainerStreamProducer` and `moq::ContainerStreamInit` are gone: a container recovers its own framing, so `moq::MediaContainerProducer` takes chunks split anywhere.
Pass empty `data` and write the stream through it.

```cpp
auto stream = ok(moq::MediaContainerProducer::init(broadcast, {moq::ContainerFormat::kFmp4, {}}));
```

### Subscriptions carry group ranges (#5732)

`Subscription::group_start` and `group_end` are replaced by `ranges`, a list of `Range` whose ends are an `Anchor` (an absolute group and frame, or a count of groups before the latest), and an optional `order`.
Expand Down
9 changes: 3 additions & 6 deletions cpp/moq/test/probe.cpp
Original file line number Diff line number Diff line change
Expand Up @@ -102,12 +102,9 @@ int main() {
auto timebase_owner = ok(moq::BroadcastProducer::init(), "timebase owner");
auto timebase_other = ok(moq::BroadcastProducer::init(), "timebase other");
auto timebase = ok(moq::MediaTimebase::init(timebase_owner), "timebase");
auto foreign_chunks = moq::MediaContainerProducer::init(timebase_other, {moq::ContainerFormat::kFmp4, {}, timebase});
CHECK(!foreign_chunks);
CHECK(std::holds_alternative<moq::Error::kCodec>(foreign_chunks.error().get_variant()));
auto foreign_stream = moq::MediaContainerStreamProducer::init(timebase_other, {moq::ContainerFormat::kFmp4, timebase});
CHECK(!foreign_stream);
CHECK(std::holds_alternative<moq::Error::kCodec>(foreign_stream.error().get_variant()));
auto foreign = moq::MediaContainerProducer::init(timebase_other, {moq::ContainerFormat::kFmp4, {}, timebase});
CHECK(!foreign);
CHECK(std::holds_alternative<moq::Error::kCodec>(foreign.error().get_variant()));
ok(timebase_owner->close(), "close timebase owner");
CHECK(!moq::MediaTimebase::init(timebase_owner));
ok(timebase_other->close(), "close timebase other");
Expand Down
12 changes: 8 additions & 4 deletions dart/moq/MIGRATE.md
Original file line number Diff line number Diff line change
Expand Up @@ -92,11 +92,15 @@ Producers drop `name`, `used`, and `unused`; read them through `demand()`.
final audio = media.TrackProducer.audio(broadcast: broadcast, target: media.Named(null), init: init);
```

### Container byte-stream importers take an init record
### Container byte streams use `media.ContainerProducer` (#5919)

`media.ContainerStreamProducer` takes a `ContainerStreamInit` holding the format instead of a bare format.
Its optional `timebase`, also on `ContainerInit`, shares one source's offset across container imports.
Replace `format: ...` with `init: media.ContainerStreamInit(format: ...)`.
`publishContainerStream` has no separate importer: a container recovers its own framing, so `media.ContainerProducer` takes chunks split anywhere.
Pass empty `data` and write the stream through it.
`ContainerInit`'s optional `timebase` shares one source's offset across container imports.

```dart
final stream = media.ContainerProducer(broadcast: broadcast, init: media.ContainerInit(format: media.ContainerFormat.fmp4, data: Uint8List(0)));
```

### Timestamps are optional

Expand Down
6 changes: 0 additions & 6 deletions dart/moq/lib/media.dart
Original file line number Diff line number Diff line change
Expand Up @@ -12,9 +12,6 @@ typedef TrackStreamProducer = MoqMediaTrackStreamProducer;
/// The write side of a container, which publishes each track it describes.
typedef ContainerProducer = MoqMediaContainerProducer;

/// The write side of a container fed a raw byte stream.
typedef ContainerStreamProducer = MoqMediaContainerStreamProducer;

/// The read side of a media track: yields frames with codec metadata in decode order.
typedef TrackConsumer = MoqMediaTrackConsumer;

Expand Down Expand Up @@ -60,9 +57,6 @@ typedef ContainerFormat = MoqContainerFormat;
/// A shared source timestamp offset that does not keep its broadcast open.
typedef Timebase = MoqMediaTimebase;

/// A byte-stream container format and an optional shared source timebase.
typedef ContainerStreamInit = MoqContainerStreamInit;

/// A container format, its leading bytes, and an optional shared source timebase.
typedef ContainerInit = MoqContainerInit;

Expand Down
10 changes: 0 additions & 10 deletions dart/moq/test/moq_test.dart
Original file line number Diff line number Diff line change
Expand Up @@ -34,16 +34,6 @@ void main() {
),
throwsA(isA<CodecMoqException>()),
);
expect(
() => moq_media.ContainerStreamProducer(
broadcast: other,
init: moq_media.ContainerStreamInit(
format: moq_media.ContainerFormat.fmp4,
timebase: timebase,
),
),
throwsA(isA<CodecMoqException>()),
);
owner.close();
expect(
() => moq_media.Timebase(broadcast: owner),
Expand Down
234 changes: 1 addition & 233 deletions dart/moq_ffi/lib/src/moq.dart
Original file line number Diff line number Diff line change
Expand Up @@ -1419,65 +1419,6 @@ class FfiConverterMoqContainerInit {
}
}

class MoqContainerStreamInit {
final MoqContainerFormat format;
final MoqMediaTimebase? timebase;
MoqContainerStreamInit({required this.format, this.timebase = null});
}

class FfiConverterMoqContainerStreamInit {
static MoqContainerStreamInit lift(RustBuffer buf) {
return FfiConverterMoqContainerStreamInit.read(buf.asUint8List()).value;
}

static LiftRetVal<MoqContainerStreamInit> read(Uint8List buf) {
int new_offset = buf.offsetInBytes;
final format_lifted = FfiConverterMoqContainerFormat.read(
Uint8List.view(buf.buffer, new_offset),
);
final format = format_lifted.value;
new_offset += format_lifted.bytesRead;
final timebase_lifted = FfiConverterOptionalMoqMediaTimebase.read(
Uint8List.view(buf.buffer, new_offset),
);
final timebase = timebase_lifted.value;
new_offset += timebase_lifted.bytesRead;
return LiftRetVal(
MoqContainerStreamInit(format: format, timebase: timebase),
new_offset - buf.offsetInBytes,
);
}

static RustBuffer lower(MoqContainerStreamInit value) {
final total_length =
FfiConverterMoqContainerFormat.allocationSize(value.format) +
FfiConverterOptionalMoqMediaTimebase.allocationSize(value.timebase) +
0;
final buf = Uint8List(total_length);
write(value, buf);
return toRustBuffer(buf);
}

static int write(MoqContainerStreamInit value, Uint8List buf) {
int new_offset = buf.offsetInBytes;
new_offset += FfiConverterMoqContainerFormat.write(
value.format,
Uint8List.view(buf.buffer, new_offset),
);
new_offset += FfiConverterOptionalMoqMediaTimebase.write(
value.timebase,
Uint8List.view(buf.buffer, new_offset),
);
return new_offset - buf.offsetInBytes;
}

static int allocationSize(MoqContainerStreamInit value) {
return FfiConverterMoqContainerFormat.allocationSize(value.format) +
FfiConverterOptionalMoqMediaTimebase.allocationSize(value.timebase) +
0;
}
}

class MoqDatagram {
final int sequence;
final int? timestampUs;
Expand Down Expand Up @@ -9558,112 +9499,6 @@ class FfiConverterMoqMediaContainerProducer {
}
}

abstract class MoqMediaContainerStreamProducerInterface {
void finish();
void write({required Uint8List payload});
}

final _MoqMediaContainerStreamProducerFinalizer = Finalizer<Pointer<Void>>((
ptr,
) {
rustCall(
(status) =>
uniffi_moq_ffi_fn_free_moqmediacontainerstreamproducer(ptr, status),
);
});

class MoqMediaContainerStreamProducer
implements MoqMediaContainerStreamProducerInterface {
late final Pointer<Void> _ptr;
bool _isDisposed = false;
MoqMediaContainerStreamProducer._(this._ptr) {
_MoqMediaContainerStreamProducerFinalizer.attach(this, _ptr, detach: this);
}
MoqMediaContainerStreamProducer({
required MoqBroadcastProducer broadcast,
required MoqContainerStreamInit init,
}) : _ptr = rustCall(
(status) =>
uniffi_moq_ffi_fn_constructor_moqmediacontainerstreamproducer_new(
FfiConverterMoqBroadcastProducer.lower(broadcast),
FfiConverterMoqContainerStreamInit.lower(init),
status,
),
moqExceptionErrorHandler,
) {
_MoqMediaContainerStreamProducerFinalizer.attach(this, _ptr, detach: this);
}
factory MoqMediaContainerStreamProducer.lift(Pointer<Void> ptr) {
return MoqMediaContainerStreamProducer._(ptr);
}
Pointer<Void> uniffiClonePointer() {
if (_isDisposed) {
throw StateError("Object has already been disposed");
}
return rustCall(
(status) =>
uniffi_moq_ffi_fn_clone_moqmediacontainerstreamproducer(_ptr, status),
);
}

void dispose() {
if (_isDisposed) {
return;
}
_isDisposed = true;
_MoqMediaContainerStreamProducerFinalizer.detach(this);
rustCall(
(status) =>
uniffi_moq_ffi_fn_free_moqmediacontainerstreamproducer(_ptr, status),
);
}

void finish() {
return rustCall((status) {
uniffi_moq_ffi_fn_method_moqmediacontainerstreamproducer_finish(
uniffiClonePointer(),
status,
);
}, moqExceptionErrorHandler);
}

void write({required Uint8List payload}) {
return rustCall((status) {
uniffi_moq_ffi_fn_method_moqmediacontainerstreamproducer_write(
uniffiClonePointer(),
FfiConverterUint8List.lower(payload),
status,
);
}, moqExceptionErrorHandler);
}
}

class FfiConverterMoqMediaContainerStreamProducer {
static MoqMediaContainerStreamProducer lift(Pointer<Void> ptr) {
return MoqMediaContainerStreamProducer.lift(ptr);
}

static Pointer<Void> lower(MoqMediaContainerStreamProducer value) {
return value.uniffiClonePointer();
}

static int allocationSize(MoqMediaContainerStreamProducer value) {
return 8;
}

static LiftRetVal<MoqMediaContainerStreamProducer> read(Uint8List buf) {
final handle = buf.buffer.asByteData(buf.offsetInBytes).getInt64(0);
final pointer = Pointer<Void>.fromAddress(handle);
return LiftRetVal(MoqMediaContainerStreamProducer.lift(pointer), 8);
}

static int write(MoqMediaContainerStreamProducer value, Uint8List buf) {
final handle = lower(value);
buf.buffer.asByteData(buf.offsetInBytes).setInt64(0, handle.address);
return 8;
}
}

abstract class MoqMediaGroupConsumerInterface {
void cancel();
Future<MoqMediaFrame?> next();
Expand Down Expand Up @@ -16014,49 +15849,6 @@ external void uniffi_moq_ffi_fn_method_moqmediacontainerproducer_write(
Pointer<RustCallStatus> uniffiStatus,
);

@Native<Pointer<Void> Function(Pointer<Void>, Pointer<RustCallStatus>)>(
assetId: _uniffiAssetId,
)
external Pointer<Void> uniffi_moq_ffi_fn_clone_moqmediacontainerstreamproducer(
Pointer<Void> handle,
Pointer<RustCallStatus> uniffiStatus,
);

@Native<Void Function(Pointer<Void>, Pointer<RustCallStatus>)>(
assetId: _uniffiAssetId,
)
external void uniffi_moq_ffi_fn_free_moqmediacontainerstreamproducer(
Pointer<Void> handle,
Pointer<RustCallStatus> uniffiStatus,
);

@Native<
Pointer<Void> Function(Pointer<Void>, RustBuffer, Pointer<RustCallStatus>)
>(assetId: _uniffiAssetId)
external Pointer<Void>
uniffi_moq_ffi_fn_constructor_moqmediacontainerstreamproducer_new(
Pointer<Void> broadcast,
RustBuffer init,
Pointer<RustCallStatus> uniffiStatus,
);

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

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

@Native<Pointer<Void> Function(Pointer<Void>, Pointer<RustCallStatus>)>(
assetId: _uniffiAssetId,
)
Expand Down Expand Up @@ -18076,14 +17868,6 @@ external int uniffi_moq_ffi_checksum_method_moqmediacontainerproducer_seek();
@Native<Uint16 Function()>(assetId: _uniffiAssetId)
external int uniffi_moq_ffi_checksum_method_moqmediacontainerproducer_write();

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

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

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

Expand Down Expand Up @@ -18461,10 +18245,6 @@ external int uniffi_moq_ffi_checksum_constructor_moqmediacatalogproducer_new();
external int
uniffi_moq_ffi_checksum_constructor_moqmediacontainerproducer_new();

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

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

Expand Down Expand Up @@ -18745,15 +18525,7 @@ void _checkApiChecksums() {
throw UniffiInternalError.panicked("UniFFI API checksum mismatch");
}
if (uniffi_moq_ffi_checksum_method_moqmediacontainerproducer_write() !=
44490) {
throw UniffiInternalError.panicked("UniFFI API checksum mismatch");
}
if (uniffi_moq_ffi_checksum_method_moqmediacontainerstreamproducer_finish() !=
29671) {
throw UniffiInternalError.panicked("UniFFI API checksum mismatch");
}
if (uniffi_moq_ffi_checksum_method_moqmediacontainerstreamproducer_write() !=
13648) {
17951) {
throw UniffiInternalError.panicked("UniFFI API checksum mismatch");
}
if (uniffi_moq_ffi_checksum_method_moqmediagroupconsumer_cancel() != 4852) {
Expand Down Expand Up @@ -19148,10 +18920,6 @@ void _checkApiChecksums() {
41369) {
throw UniffiInternalError.panicked("UniFFI API checksum mismatch");
}
if (uniffi_moq_ffi_checksum_constructor_moqmediacontainerstreamproducer_new() !=
54958) {
throw UniffiInternalError.panicked("UniFFI API checksum mismatch");
}
if (uniffi_moq_ffi_checksum_constructor_moqmediagroupconsumer_fetch() !=
32566) {
throw UniffiInternalError.panicked("UniFFI API checksum mismatch");
Expand Down
8 changes: 4 additions & 4 deletions doc/lib/cpp/index.md
Original file line number Diff line number Diff line change
Expand Up @@ -105,10 +105,10 @@ when its session does.
`MediaTrackConsumer` reads in decode order. For arrival-order reads, decode each group
from `TrackConsumer::recv_group` with `moq::MediaGroupConsumer::init(group, container)`;
frames carry container media time as they land.
Share `moq::MediaTimebase::init(broadcast)` through container init records when several
imports use one source timeline. `MediaContainerStreamProducer::init` takes
`ContainerStreamInit`; omitting its timebase keeps an independent offset. A timebase
belongs to its broadcast and does not keep it open.
Share `moq::MediaTimebase::init(broadcast)` through `ContainerInit` when several imports
use one source timeline; omitting it keeps an independent offset. A timebase belongs to
its broadcast and does not keep it open. `MediaContainerProducer` takes chunks split
anywhere, so a raw byte stream needs no other importer.

```cpp
// Publish encoded frames, or raw pixels with the codec inside the binding.
Expand Down
Loading
Loading