Media over QUIC Transport

1.1. Motivation

The development of MOQT is driven by goals in a number of areas - specifically latency, the robustness of QUIC, workflow efficiency and relay support.¶

1.2. Terms and Definitions

The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "NOT RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in BCP 14 [RFC2119] [RFC8174] when, and only when, they appear in all capitals, as shown here.¶

Client:

The party initiating a MoQ transport session.¶

Server:

The party accepting an incoming transport session.¶

Endpoint:

A Client or Server.¶

Producer:

An endpoint sending media over the network.¶

Consumer:

An endpoint receiving media over the network.¶

Transport session:

A raw QUIC connection or a WebTransport session.¶

Congestion:

Packet loss and queuing caused by degraded or overloaded networks.¶

Group:

A temporal sequence of objects. A group represents a join point in a track. See (Section 2.2).¶

Object:

An object is an addressable unit whose payload is a sequence of bytes. Objects form the base element in the MOQT model. See (Section 2.1).¶

Track:

An encoded bitstream. Tracks contain a sequential series of one or more groups and are the subscribable entity with MOQT.¶

1.3. Notational Conventions

This document uses the conventions detailed in ([RFC9000], Section 1.3) when describing the binary encoding.¶

As a quick reference, the following list provides a non normative summary of the parts of RFC9000 field syntax that are used in this specification.¶

x (L):

Indicates that x is L bits long¶

x (i):

Indicates that x holds an integer value using the variable-length encoding as described in ([RFC9000], Section 16)¶

x (..):

Indicates that x can be any length including zero bits long. Values in this format always end on a byte boundary.¶

[x (L)]:

Indicates that x is optional and has a length of L¶

x (L) ...:

Indicates that x is repeated zero or more times and that each instance has a length of L¶

This document extends the RFC9000 syntax and with the additional field types:¶

x (b):

Indicates that x consists of a variable length integer encoding as described in ([RFC9000], Section 16), followed by that many bytes of binary data¶

To reduce unnecessary use of bandwidth, variable length integers SHOULD be encoded using the least number of bytes possible to represent the required value.¶

2.1. Objects

The basic data element of MOQT is an object. An object is an addressable unit whose payload is a sequence of bytes. All objects belong to a group, indicating ordering and potential dependencies. Section 2.2 An object is uniquely identified by its track namespace, track name, group ID, and object ID, and must be an identical sequence of bytes regardless of how or where it is retrieved. An Object can become unavailable, but it's contents MUST NOT change over time.¶

Objects are comprised of two parts: metadata and a payload. The metadata is never encrypted and is always visible to relays. The payload portion may be encrypted, in which case it is only visible to the producer and consumer. The application is solely responsible for the content of the object payload. This includes the underlying encoding, compression, any end-to-end encryption, or authentication. A relay MUST NOT combine, split, or otherwise modify object payloads.¶

2.2. Groups

A group is a collection of objects and is a sub-unit of a track (Section 2.3). Objects within a group SHOULD NOT depend on objects in other groups. A group behaves as a join point for subscriptions. A new subscriber might not want to receive the entire track, and may instead opt to receive only the latest group(s). The sender then selectively transmits objects based on their group membership.¶

2.3. Track

A track is a sequence of groups (Section 2.2). It is the entity against which a consumer issues a subscription request. A subscriber can request to receive individual tracks starting at a group boundary, including any new objects pushed by the producer while the track is active.¶

3.1. Session establishment

This document defines a protocol that can be used interchangeably both over a QUIC connection directly [QUIC], and over WebTransport [WebTransport]. Both provide streams and datagrams with similar semantics (see [I-D.ietf-webtrans-overview], Section 4); thus, the main difference lies in how the servers are identified and how the connection is established. When using QUIC, datagrams MUST be supported via the [QUIC-DATAGRAM] extension, which is already a requirement for WebTransport over HTTP/3.¶

There is no definition of the protocol over other transports, such as TCP, and applications using MoQ might need to fallback to another protocol when QUIC or WebTransport aren't available.¶

moq-URI = "moqt" "://" authority path-abempty [ "?" query ]

3.2. Version and Extension Negotiation

Endpoints use the exchange of Setup messages to negotiate the MOQT version and any extensions to use.¶

The client indicates the MOQT versions it supports in the CLIENT_SETUP message (see Section 6.2). It also includes the union of all Setup Parameters Section 6.2.2 required for a handshake by any of those versions.¶

Within any MOQT version, clients request the use of extensions by adding Setup parameters corresponding to that extension. No extensions are defined in this document.¶

The server replies with a SERVER_SETUP message that indicates the chosen version, includes all parameters required for a handshake in that version, and parameters for every extension requested by the client that it supports.¶

New versions of MOQT MUST specify which existing extensions can be used with that version. New extensions MUST specify the existing versions with which they can be used.¶

If a given parameter carries the same information in multiple versions, but might have different optimal values in those versions, there SHOULD be separate Setup parameters for that information in each version.¶

3.3. Session initialization

The first stream opened is a client-initiated bidirectional control stream where the peers exchange Setup messages (Section 6.2). All messages defined in this draft except OBJECT and OBJECT_WITH_LENGTH are sent on the control stream after the Setup message. Control messages MUST NOT be sent on any other stream, and a peer receiving a control message on a different stream closes the session as a 'Protocol Violation'. Objects MUST NOT be sent on the control stream, and a peer receiving an Object on the control stream closes the session as a 'Protocol Violation'.¶

This draft only specifies a single use of bidirectional streams. Objects are sent on unidirectional streams. Because there are no other uses of bidirectional streams, a peer MAY currently close the session as a 'Protocol Violation' if it receives a second bidirectional stream.¶

The control stream MUST NOT be abruptly closed at the underlying transport layer. Doing so results in the session being closed as a 'Protocol Violation'.¶

3.4. Stream Cancellation

Streams aside from the control stream MAY be canceled due to congestion or other reasons by either the sender or receiver. Early termination of a stream does not affect the MoQ application state, and therefore has no effect on outstanding subscriptions.¶

3.5. Termination

The transport session can be terminated at any point. When native QUIC is used, the session is closed using the CONNECTION_CLOSE frame ([QUIC], Section 19.19). When WebTransport is used, the session is closed using the CLOSE_WEBTRANSPORT_SESSION capsule ([WebTransport], Section 5).¶

The application MAY use any error message and SHOULD use a relevant code, as defined below:¶

• No Error: The session is being terminated without an error.¶

• Internal Error: An implementation specific error occurred.¶

• Unauthorized: The endpoint breached an agreement, which MAY have been pre-negotiated by the application.¶

• Protocol Violation: The remote endpoint performed an action that was disallowed by the specification.¶

• Duplicate Track Alias: The endpoint attempted to use a Track Alias that was already in use.¶

• GOAWAY Timeout: The session was closed because the client took too long to close the session in response to a GOAWAY (Section 6.14) message. See session migration (Section 3.6).¶

3.6. Migration

MoqTransport requires a long-lived and stateful session. However, a service provider needs the ability to shutdown/restart a server without waiting for all sessions to drain naturally, as that can take days for long-form media. MoqTransport avoids this via the GOAWAY message (Section 6.14).¶

The server sends a GOAWAY message, signaling that the client should establish a new session and migrate any active subscriptions. The GOAWAY message may contain a new URI for the new session, otherwise the current URI is reused. The server SHOULD terminate the session with 'GOAWAY Timeout' after a sufficient timeout if there are still open subscriptions on a connection.¶

The GOAWAY message does not immediately impact subscription state. A subscriber SHOULD individually UNSUBSCRIBE for each existing subscription, while a publisher MAY reject new SUBSCRIBEs while in the draining state. When the server is a subscriber, it SHOULD send a GOAWAY message prior to any UNSUBSCRIBE messages.¶

After the client receives a GOAWAY, it's RECOMMENDED that the client waits until there are no more active subscriptions before closing the session with NO_ERROR. Ideally this is transparent to the application using MOQT, which involves establishing a new session in the background and migrating active subscriptions and announcements. The client can choose to delay closing the session if it expects more OBJECTs to be delivered. The server closes the session with a 'GOAWAY Timeout' if the client doesn't close the session quickly enough.¶

4.1. Order Priorities and Options

At the point of this writing, the working group has not reached consensus on several important goals, such as:¶

• Ensuring that objects are delivered in the order intended by the emitter¶

• Allowing nodes and relays to skip or delay some objects to deal with congestion¶

• Ensuring that emitters can accurately predict the behavior of relays¶

• Ensuring that when relays have to skip and delay objects belonging to different tracks that they do it in a predictable way if tracks are explicitly coordinated and in a fair way if they are not.¶

The working group has been considering two alternatives: marking objects belonging to a track with an explicit "send order"; and, defining algorithms combining tracks, priorities and object order within a group. The two proposals are listed in Section 4.1.1 and Section 4.1.2. We expect further work before a consensus is reached.¶

5.1. Subscriber Interactions

Subscribers interact with the Relays by sending a SUBSCRIBE (Section 6.4) control message for the tracks of interest. Relays MUST ensure subscribers are authorized to access the content associated with the track. The authorization information can be part of subscription request itself or part of the encompassing session. The specifics of how a relay authorizes a user are outside the scope of this specification.¶

The subscriber making the subscribe request is notified of the result of the subscription, via SUBSCRIBE_OK (Section 6.5) or the SUBSCRIBE_ERROR Section 6.6 control message. The entity receiving the SUBSCRIBE MUST send only a single response to a given SUBSCRIBE of either SUBSCRIBE_OK or SUBSCRIBE_ERROR.¶

For successful subscriptions, the publisher maintains a list of subscribers for each track. Each new OBJECT belonging to the track within the subscription range is forwarded to each active subscriber, dependent on the congestion response. A subscription remains active until the publisher of the track terminates the track with a SUBSCRIBE_DONE (see Section 6.8).¶

Objects MUST NOT be sent for unsuccessful subscriptions, and if a subscriber receives a SUBSCRIBE_ERROR after receiving objects, it MUST close the session with a 'Protocol Violation'.¶

A relay MUST not reorder or drop objects received on a multi-object stream when forwarding to subscribers, unless it has application specific information.¶

Relays MAY aggregate authorized subscriptions for a given track when multiple subscribers request the same track. Subscription aggregation allows relays to make only a single forward subscription for the track. The published content received from the forward subscription request is cached and shared among the pending subscribers.¶

The application SHOULD use a relevant error code in SUBSCRIBE_ERROR, as defined below:¶

The applicaiton SHOULD use a relevant status code in SUBSCRIBE_DONE, as defined below:¶

5.2. Publisher Interactions

Publishing through the relay starts with publisher sending ANNOUNCE control message with a Track Namespace (Section 2.3).¶

Relays MUST ensure that publishers are authorized by:¶

• Verifying that the publisher is authorized to publish the content associated with the set of tracks whose Track Namespace matches the announced namespace. Specifics of where the authorization happens, either at the relays or forwarded for further processing, depends on the way the relay is managed and is application specific (typically based on prior business agreement).¶

Relays respond with an ANNOUNCE_OK or ANNOUNCE_ERROR control message providing the result of announcement. The entity receiving the ANNOUNCE MUST send only a single response to a given ANNOUNCE of either ANNOUNCE_OK or ANNOUNCE_ERROR. When a publisher wants to stop new subscriptions for an announced namespace it sends an UNANNOUNCE. A subscriber indicates it will no longer route subscriptions for a namespace it previously responded ANNOUNCE_OK to by sending an ANNOUNCE_CANCEL.¶

A relay manages sessions from multiple publishers and subscribers, connecting them based on the track namespace. This MUST use an exact match on track namespace unless otherwise negotiated by the application. For example, a SUBSCRIBE namespace=foobar message will be forwarded to the session that sent ANNOUNCE namespace=foobar.¶

OBJECT message headers carry a short hop-by-hop Track Alias that maps to the Full Track Name (see Section 6.5). Relays use the Track Alias of an incoming OBJECT message to identify its track and find the active subscribers for that track. Relays MUST NOT depend on OBJECT payload content for making forwarding decisions and MUST only depend on the fields, such as priority order and other metadata properties in the OBJECT message header. Unless determined by congestion response, Relays MUST forward the OBJECT message to the matching subscribers.¶

5.3. Congestion Response at Relays

TODO: Refer to Section 4. Add details to describe relay behavior when merging or splitting streams and interactions with congestion response.¶

5.4. Relay Object Handling

MOQT encodes the delivery information for a stream via OBJECT headers (Section 6.3). A relay MUST NOT modify Object properties when forwarding.¶

A relay MUST treat the object payload as opaque. A relay MUST NOT combine, split, or otherwise modify object payloads. A relay SHOULD prioritize streams (Section 4) based on the send order/priority.¶

A sender SHOULD begin sending incomplete objects when available to avoid incurring additional latency.¶

A relay that reads from a stream and writes to stream in order will introduce head-of-line blocking. Packet loss will cause stream data to be buffered in the library, awaiting in order delivery, which will increase latency over additional hops. To mitigate this, a relay SHOULD read and write stream data out of order subject to flow control limits. See section 2.2 in [QUIC].¶

6.1. Parameters

Some messages include a Parameters field that encode optional message elements. They contain a type, length, and value.¶

Senders MUST NOT repeat the same parameter type in a message. Receivers SHOULD check that there are no duplicate parameters and close the session as a 'Protocol Violation' if found.¶

Receivers ignore unrecognized parameters.¶

The format of Parameters is as follows:¶

Parameter {
  Parameter Type (i),
  Parameter Length (i),
  Parameter Value (..),
}

Parameter Type is an integer that indicates the semantic meaning of the parameter. Setup message parameters use a namespace that is constant across all MoQ Transport versions. All other messages use a version-specific namespace. For example, the integer '1' can refer to different parameters for Setup messages and for all other message types.¶

SETUP message parameter types are defined in Section 6.2.2. Version- specific parameter types are defined in Section 6.1.1.¶

The Parameter Length field of the String Parameter encodes the length of the Parameter Value field in bytes.¶

Each parameter description will indicate the data type in the Parameter Value field. If a receiver understands a parameter type, and the parameter length implied by that type does not match the Parameter Length field, the receiver MUST terminate the session with error code 'Parameter Length Mismatch'.¶

6.2. CLIENT_SETUP and SERVER_SETUP

The CLIENT_SETUP and SERVER_SETUP messages are the first messages exchanged by the client and the server; they allows the peers to establish the mutually supported version and agree on the initial configuration before any objects are exchanged. It is a sequence of key-value pairs called Setup parameters; the semantics and format of which can vary based on whether the client or server is sending. To ensure future extensibility of MOQT, the peers MUST ignore unknown setup parameters. TODO: describe GREASE for those.¶

The wire format of the Setup messages are as follows:¶

CLIENT_SETUP Message Payload {
  Number of Supported Versions (i),
  Supported Version (i) ...,
  Number of Parameters (i) ...,
  Setup Parameters (..) ...,
}

SERVER_SETUP Message Payload {
  Selected Version (i),
  Number of Parameters (i) ...,
  Setup Parameters (..) ...,
}

The available versions and Setup parameters are detailed in the next sections.¶

6.3. OBJECT

An OBJECT message contains a range of contiguous bytes from from the specified track, as well as associated metadata required to deliver, cache, and forward it.¶

OBJECT_STREAM Message {
  Subscribe ID (i),
  Track Alias (i),
  Group ID (i),
  Object ID (i),
  Object Send Order (i),
  Object Payload (..),
}

OBJECT_DATAGRAM Message {
  Subscribe ID (i),
  Track Alias (i),
  Group ID (i),
  Object ID (i),
  Object Send Order (i),
  Object Payload (..),
}

STREAM_HEADER_TRACK Message {
  Subscribe ID (i)
  Track Alias (i),
  Object Send Order (i),
}

{
  Group ID (i),
  Object ID (i),
  Object Payload Length (i),
  Object Payload (..),
}

STREAM_HEADER_GROUP Message {
  Subscribe ID (i),
  Track Alias (i),
  Group ID (i)
  Object Send Order (i)
}

{
  Object ID (i),
  Object Payload Length (i),
  Object Payload (..),
}

STREAM_HEADER_TRACK {
  Subscribe ID = 1
  Track Alias = 1
  Object Send Order = 0
}
{
  Group ID = 0
  Object ID = 0
  Object Payload Length = 4
  Payload = "abcd"
}
{
  Group ID = 1
  Object ID = 0
  Object Payload Length = 4
  Payload = "efgh"
}

Stream = 2

STREAM_HEADER_GROUP {
  Subscribe ID = 2
  Track Alias = 2
  Group ID = 0
  Object Send Order = 0
}
{
  Object ID = 0
  Object Payload Length = 4
  Payload = "abcd"
}
{
  Object ID = 1
  Object Payload Length = 4
  Payload = "efgh"
}

Stream = 6

OBJECT_STREAM {
  Subscribe ID = 2
  Track Alias = 2
  Group ID = 0
  Object ID = 1
  Payload = "moqrocks"
}

6.4. SUBSCRIBE

A receiver issues a SUBSCRIBE to a publisher to request a track.¶

Location {
  Mode (i),
  [Value (i)],
}

Sequence:                0    1    2    3    4   [5]  [6] ...
                                             ^
                                      Largest Sequence
RelativePrevious Value:  4    3    2    1    0
RelativeNext Value:                               0    1  ...

SUBSCRIBE Message {
  Subscribe ID (i),
  Track Alias (i),
  Track Namespace (b),
  Track Name (b),
  StartGroup (Location),
  StartObject (Location),
  EndGroup (Location),
  EndObject (Location),
  Number of Parameters (i),
  Track Request Parameters (..) ...
}

1. Now

Start Group: Mode=RelativePrevious, Value=0
Start Object: Mode=RelateiveNext, Value=0
End Group: Mode=None
End Object: Mode=None

StartGroup=Largest Group
StartObject=Largest Object + 1

2. Current

Start Group: Mode=RelativePrevious, Value=0
Start Object: Mode=Absolute, Value=0
End Group: Mode=None
End Object: Mode=None

StartGroup=Largest Group
StartObject=0

3. Previous

Start Group: Mode=RelativePrevious, Value=1
Start Object: Mode=Absolute, Value=0
End Group: Mode=None
End Object: Mode=None

StartGroup=Largest Group - 1
StartObject=0

4. Next

Start Group: Mode=RelativeNext, Value=0
Start Object: Mode=Absolute, Value=0
End Group: Mode=None
End Object: Mode=None
StartGroup=Largest Group + 1
StartObject=0

5. Range, All of group 3

Start Group: Mode=Absolute, Value=3
Start Object: Mode=Absolute, Value=0
End Group: Mode=Absolute, Value=4
End Object: Mode=Absolute, Value=0

Start = Group 3, Object 0
End = Group 3, Object <last>

6.5. SUBSCRIBE_OK

A SUBSCRIBE_OK control message is sent for successful subscriptions.¶

SUBSCRIBE_OK
{
  Subscribe ID (i),
  Expires (i),
  ContentExists (1),
  [Largest Group ID (i)],
  [Largest Object ID (i)]
}

• Subscribe ID: Subscription Identifer as defined in Section 6.4.¶

• Expires: Time in milliseconds after which the subscription is no longer valid. A value of 0 indicates that the subscription does not expire or expires at an unknown time. Expires is advisory and a subscription can end prior to the expiry time or last longer.¶

• ContentExists: 1 if an object has been published on this track, 0 if not. If 0, then the Largest Group ID and Largest Object ID fields will not be present.¶

• Largest Group ID: the largest Group ID available for this track. This field is only present if ContentExists has a value of 1.¶

• Largest Object ID: the largest Object ID available within the largest Group ID for this track. This field is only present if ContentExists has a value of 1.¶

6.6. SUBSCRIBE_ERROR

A publisher sends a SUBSCRIBE_ERROR control message in response to a failed SUBSCRIBE.¶

SUBSCRIBE_ERROR
{
  Subscribe ID (i),
  Error Code (i),
  Reason Phrase (b),
  Track Alias (i),
}

• Subscribe ID: Subscription Identifer as defined in Section 6.4.¶

• Error Code: Identifies an integer error code for subscription failure.¶

• Reason Phrase: Provides the reason for subscription error.¶

• Track Alias: When Error Code is 'Retry Track Alias', the subscriber SHOULD re-issue the SUBSCRIBE with this Track Alias instead. If this Track Alias is already in use, the receiver MUST close the connection with a Duplicate Track Alias error (Section 3.5).¶

6.7. UNSUBSCRIBE

A subscriber issues a UNSUBSCRIBE message to a publisher indicating it is no longer interested in receiving media for the specified track and Objects should stop being sent as soon as possible. The publisher sends a SUBSCRIBE_DONE to acknowledge the unsubscribe was successful and indicate the final Object.¶

The format of UNSUBSCRIBE is as follows:¶

UNSUBSCRIBE Message {
  Subscribe ID (i)
}

• Subscribe ID: Subscription Identifer as defined in Section 6.4.¶

6.8. SUBSCRIBE_DONE

A publisher issues a SUBSCRIBE_DONE message to indicate it is done publishing Objects for that subscription. The Status Code indicates why the subscription ended, and whether it was an error.¶

The format of SUBSCRIBE_DONE is as follows:¶

SUBSCRIBE_DONE Message {
  Subscribe ID (i),
  Status Code (i),
  Reason Phrase (b),
  ContentExists (1),
  [Final Group (i)],
  [Final Object (i)],
}

• Subscribe ID: Subscription identifier as defined in Section 6.4.¶

• Status Code: An integer status code indicating why the subscription ended.¶

• Reason Phrase: Provides the reason for subscription error.¶

• ContentExists: 1 if an object has been published for this subscription, 0 if not. If 0, then the Final Group and Final Object fields will not be present.¶

• Final Group: The largest Group ID sent by the publisher in an OBJECT message in this track.¶

• Final Object: The largest Object ID sent by the publisher in an OBJECT message in the Final Group for this track.¶

6.9. ANNOUNCE

The publisher sends the ANNOUNCE control message to advertise where the receiver can route SUBSCRIBEs for tracks within the announced Track Namespace. The receiver verifies the publisher is authorized to publish tracks under this namespace.¶

ANNOUNCE Message {
  Track Namespace (b),
  Number of Parameters (i),
  Parameters (..) ...,
}

• Track Namespace: Identifies a track's namespace as defined in (Section 2.3.1)¶

• Parameters: The parameters are defined in Section 6.1.1.¶

6.10. ANNOUNCE_OK

The receiver sends an ANNOUNCE_OK control message to acknowledge the successful authorization and acceptance of an ANNOUNCE message.¶

ANNOUNCE_OK
{
  Track Namespace (b),
}

• Track Namespace: Identifies the track namespace in the ANNOUNCE message for which this response is provided.¶

6.11. ANNOUNCE_ERROR

The receiver sends an ANNOUNCE_ERROR control message for tracks that failed authorization.¶

ANNOUNCE_ERROR
{
  Track Namespace (b),
  Error Code (i),
  Reason Phrase (b),
}

• Track Namespace: Identifies the track namespace in the ANNOUNCE message for which this response is provided.¶

• Error Code: Identifies an integer error code for announcement failure.¶

• Reason Phrase: Provides the reason for announcement error.¶

6.12. UNANNOUNCE

The publisher sends the UNANNOUNCE control message to indicate its intent to stop serving new subscriptions for tracks within the provided Track Namespace.¶

UNANNOUNCE Message {
  Track Namespace (b),
}

• Track Namespace: Identifies a track's namespace as defined in (Section 2.3.1).¶

6.13. ANNOUNCE_CANCEL

The subscriber sends an ANNOUNCE_CANCEL control message to indicate it will stop sending new subscriptions for tracks within the provided Track Namespace.¶

If a publisher recieves new subscriptions for that namespace after receiving an ANNOUNCE_CANCEL, it SHOULD close the session as a 'Protocol Violation'.¶

ANNOUNCE_CANCEL Message {
  Track Namespace (b),
}

• Track Namespace: Identifies a track's namespace as defined in (Section 2.3.1).¶

6.14. GOAWAY

The server sends a GOAWAY message to initiate session migration (Section 3.6) with an optional URI.¶

The server MUST terminate the session with a Protocol Violation (Section 3.5) if it receives a GOAWAY message. The client MUST terminate the session with a Protocol Violation (Section 3.5) if it receives multiple GOAWAY messages.¶

GOAWAY Message {
  New Session URI (b)
}

• New Session URI: The client MUST use this URI for the new session if provded. If the URI is zero bytes long, the current URI is reused instead. The new session URI SHOULD use the same scheme as the current URL to ensure compatibility.¶

7.1. Resource Exhaustion

Live content requires significant bandwidth and resources. Failure to set limits will quickly cause resource exhaustion.¶

MOQT uses stream limits and flow control to impose resource limits at the network layer. Endpoints SHOULD set flow control limits based on the anticipated bitrate.¶

Endpoints MAY impose a MAX STREAM count limit which would restrict the number of concurrent streams which a MOQT Streaming Format could have in flight.¶

The producer prioritizes and transmits streams out of order. Streams might be starved indefinitely during congestion. The producer and consumer MUST cancel a stream, preferably the lowest priority, after reaching a resource limit.¶