MOQT Test Ultra low latency with Webcodecs: ENCODER
MOQT Version
:
-
,
LOC MediaPackager Version
:
-
,
CMSF MediaPackager Version
:
-
Data needed
MOQT WT Relay:
Use backup relay:
MOQT WT backup relay:
Namespace:
Use character '/' to separate tuples
Tracks prefix:
Video suffix:
Audio suffix:
Media packager:
LOC (draft-ietf-moq-loc)
CMSF (AKA CMAF, draft-ietf-moq-cmsf)
⚠️ Set "Media packager expected" to CMSF in the player too, there is no catalog to negotiate it
Add latency information in video:
Advanced ▼
Old Track name:
Use single PUBLISH_NAMESPACE instead of PUBLISH per track:
Full track names (based on namespace and track name):
Token (type = out of band):
Active:
MOQ video packager:
MOQ audio packager:
Queue limits
Max send-queue audio objects:
Max send-queue video objects:
QUIC stream limits
Max QUIC streams for audio:
Max QUIC streams for video:
Simulated frame drops (A/V sync testing)
Video frame drops:
None
Random
Fixed
Video one drop every:
Video burst length of the drop:
Audio frame drops:
None
Random
Fixed
Audio one drop every:
Audio burst length of the drop:
Those drops are at QUIC STREAM / datagram level, so the data dropped will depend on the selected QUIC mapping
Simulated slowness (A/V sync testing)
Video hold:
None
Random
Fixed
Video hold every:
Video burst length:
Audio hold:
None
Random
Fixed
Audio hold every:
Audio burst length:
Those holds are at QUIC STREAM / datagram level, so the data hold will depend on the selected QUIC mapping
Save media to a local file (dumper)
Save the first N seconds (0 = off):
Media to save:
Video + audio
Video only
Audio only
The file is the concatenation of the packaged objects, it is saved when the N seconds are captured or when you press Stop. With CMSF it is a playable fragmented MP4 (cmaf-video.mp4), with LOC it is the raw elementary stream (loc-video.bin). The capture does NOT need a relay, and it buffers in memory
⚠️ It also stops at
-
objects per media type (one object = one frame), whichever limit comes first. At 30fps that caps video at
-
s, and at 10ms frames it caps audio at
-
s
Last saved:
Start
Stop
Current lane:
-
, requested:
-
Lane selector:
ABR Switch to
Media sources ▼
Video
Input sources:
(If you select "Screen" and a window with small refresh rate it can affect A LOT the time to 1st frame and time to loss recovery)
Audio
Input sources:
Encoding settings ▼
Video encoding params (h264)
ABR lanes (Add uses the Resolution @ fps, GOP and Bitrate below; click a name to edit it). The Default lane is the one encoded:
Resolution @ fps:
GOP (frames):
Bitrate (bps):
Add
Name
Resolution @ fps
Bitrate (bps)
GOP
Default
Delete
Set default
Audio encoding params
Codec:
Bitrate (bps):
Inject network issues (QUICStream level)
Drop
Main Video
Backup Video
Main Audio
Backup Audio
Hold
Main Video
Backup Video
Main Audio
Backup Audio
Main: Send queue / open streams timeline (last 60s)
Audio queued
Video queued
Audio open streams
Video open streams
Audio packet loss
Video packet loss
Backup: Send queue / open streams timeline (last 60s)
Audio queued
Video queued
Audio open streams
Video open streams
Audio packet loss
Video packet loss
Audio
overhead (last 60s)
Main: Overhead % of payload
Main: Overhead bytes
Backup: Overhead % of payload
Backup: Overhead bytes
Video
overhead (last 60s)
Main: Overhead % of payload
Main: Overhead bytes
Backup: Overhead % of payload
Backup: Overhead bytes
One point per subgroup sent. Overhead = packager (CMSF boxes / CMAF Header, none for LOC) + MoQ signaling (subgroup header, object headers, properties, end of group). % = overhead / payload, so it goes over 100% when the overhead is bigger than the media itself
Main: Dropped data
Backup: Dropped data
Capture
Encoder output
Main: Muxer sender
Backup: Muxer sender
Data overhead
Main: Dropped data (frames / chunks):
Total dropped audio chunks:
Total dropped video chunks:
Enable UI logging (could be CPU intense):
Backup: Dropped data (frames / chunks):
Total dropped audio chunks:
Total dropped video chunks:
Enable UI logging (could be CPU intense):
Capture(uncompressed domain)
First audio TS(ms):
First video TS(ms):
V-A start diff(ms):
First comp audio TS(ms):
First comp video TS(ms):
V-A comp start diff(ms):
Encoder output (chunks)
Current comp audio TS(ms):
Raw capture audio clock:
Encoding audio latency (ms):
Current comp video TS(ms):
Raw capture video clock:
Encoding video latency (ms):
Current V-A TS(ms):
Main: Muxer sender
Send queue / open streams
Queued audio objects:
Queued video objects:
Open audio streams:
Open video streams:
Backup: Muxer sender
Send queue / open streams
Queued audio objects:
Queued video objects:
Open audio streams:
Open video streams:
Data overhead (instant: last subgroup sent)
Audio
Payload bytes:
Overhead bytes:
Overhead (%):
Video
Payload bytes:
Overhead bytes:
Overhead (%):
Payload = encoded media bytes of the subgroup. Overhead = packager (CMSF boxes / CMAF Header, none for LOC) + MoQ signaling (subgroup header, object headers, properties, end of group). % = overhead / payload, so 100% means the overhead doubles what goes on the wire. See the per-track "<track name> overhead (last 60s)" graphs above for the trend