From 3e92aeaa773bb9fdc6a2f99c250dab4bab72d9c9 Mon Sep 17 00:00:00 2001 From: suhasHere Date: Tue, 7 Nov 2023 05:42:37 -0800 Subject: [PATCH 01/12] first stab at delivery mode --- draft-ietf-moq-transport.md | 69 +++++++++++++++++++++++++++++++++++++ 1 file changed, 69 insertions(+) diff --git a/draft-ietf-moq-transport.md b/draft-ietf-moq-transport.md index 127561e3..67c154c0 100644 --- a/draft-ietf-moq-transport.md +++ b/draft-ietf-moq-transport.md @@ -862,6 +862,7 @@ OBJECT Message { Track Alias (i), Group ID (i), Object ID (i), + Object Delivery Preference (i), Object Send Order (i), [Object Payload Length (i)], Object Payload (b), @@ -879,6 +880,9 @@ OBJECT Message { IDs starts at 0, increasing sequentially for each object within the group. +* Object Delivery Preference: Publisher intended delivery preference, +See {{delivery-prefs}}. + * Object Send Order: An integer indicating the object send order {{send-order}} or priority {{ordering-by-priorities}} value. @@ -889,6 +893,71 @@ field is absent, the object payload continues to the end of the stream. NOT be processed by a relay. +### Object Delivery Preferences {#delivery-prefs} + +The publisher specifies its preference for mapping the elements of the +object model - Tracks, Groups and Objects, to the underlying transport +mechanisms such as QUIC Streams and QUIC Datagrams. A publisher chooses it preference driven by the application needs. + +#### Proposal 1 - Stream Placement Indicator (Victor's Proposal and Text) + +`Stream Placement Indicator` specifies as variable length integer indicating +the publisher's intention when choosing the QUIC stream to transport a given +object. The details of the same is provided below: + +Let `N` be the object sequence of the current object and `D` be the +stream placement indicator, and `S`` be a stack of stream that is initially +empty. + +For every object to be transported: + +1. If `D` is zero, open a new stream, push it at the top of the stack. +Send the object on the stream at the top of the stack. + +2. If `D` is non-zero, check if the object sequence of the most recent object +that sent on the stream at the top of the stack has a value of `N - D`. + + 2.1 If it is, continue sending the object on the stream at the top of the + stack. + + 2.2 If it is not, close the stream at the top of the stack, pop the stream + off the stack and repeat the Step 2. If the stack is empty, close + the connection with appropriate error code. + + +#### Proposal 2 - Object Placement Mode + +`Object Placement Mode` is a enumeration of possible mappings of the object +model to the underlying transport mechanism for delivering media. + + +##### Mode: StreamPerGroup + +The mode `StreamPerGroup` specifies that all the objects for a given group +are sent over a single QUIC stream. `StreamPerGroup` has a value of 0x0. + +##### Mode: StreamPerObject + +The mode `StreamPerObject` specifies that each object is sent +over a single QUIC stream. `StreamPerObject` has a value of 0x1. + +##### Mode: StreamPerTrack + +The mode `StreamPerTrack` specifies that all the groups and objects for a +given track is sent over a single QUIC stream. `StreamPerTrack` has a +value of 0x2. + +##### Mode: StreamPerPriority + +The mode `StreamPerPriority` specifies that objects marked with a +given priorirty shared the same underlying QUIC stream. `StreamPerTrack` has a +value of 0x3. + +##### Mode: Datagram + +The mode `Datagram` specifies that objects are sent using QUIC datagrams and +has a value of 0x4. + ## SUBSCRIBE {#message-subscribe-req} A receiver issues a SUBSCRIBE to a publisher to request a track. From 5d1f2fbb65c65ec1ea5f0eb5078a00db33818bf3 Mon Sep 17 00:00:00 2001 From: suhasHere Date: Wed, 8 Nov 2023 02:08:37 -0800 Subject: [PATCH 02/12] address feedback --- draft-ietf-moq-transport.md | 38 +++++++++++++++++++++++-------------- 1 file changed, 24 insertions(+), 14 deletions(-) diff --git a/draft-ietf-moq-transport.md b/draft-ietf-moq-transport.md index 67c154c0..938078de 100644 --- a/draft-ietf-moq-transport.md +++ b/draft-ietf-moq-transport.md @@ -897,38 +897,44 @@ NOT be processed by a relay. The publisher specifies its preference for mapping the elements of the object model - Tracks, Groups and Objects, to the underlying transport -mechanisms such as QUIC Streams and QUIC Datagrams. A publisher chooses it preference driven by the application needs. +mechanisms such as QUIC Streams and QUIC Datagrams. A publisher chooses it +preference driven by the application needs. #### Proposal 1 - Stream Placement Indicator (Victor's Proposal and Text) -`Stream Placement Indicator` specifies as variable length integer indicating -the publisher's intention when choosing the QUIC stream to transport a given -object. The details of the same is provided below: +`Stream Placement Indicator` specifies as variable length integer informing +the stream to choose for sending a given object. + +Each publisher follows the procedure defined below : Let `N` be the object sequence of the current object and `D` be the -stream placement indicator, and `S`` be a stack of stream that is initially +stream placement indicator, and `S` be a stack of streams that is initially empty. -For every object to be transported: +For each object to be sent: -1. If `D` is zero, open a new stream, push it at the top of the stack. +1. If `D` is zero, open a new stream and push it at the top of the stack. Send the object on the stream at the top of the stack. 2. If `D` is non-zero, check if the object sequence of the most recent object -that sent on the stream at the top of the stack has a value of `N - D`. +that was sent on the stream at the top of the stack has a value of `N - D`. + + - If it is, continue sending the current object on the stream at the top + of the stack. - 2.1 If it is, continue sending the object on the stream at the top of the - stack. - 2.2 If it is not, close the stream at the top of the stack, pop the stream - off the stack and repeat the Step 2. If the stack is empty, close + - If it is not, close the stream at the top of the stack, pop the stream + off the stack and repeat from the Step 2. If the stack is empty, close the connection with appropriate error code. +TODO: More details are needed to determine when the stream can be closed. + Refer to disucssions on issue 318 on explicit markers for signaling + stream completion. #### Proposal 2 - Object Placement Mode `Object Placement Mode` is a enumeration of possible mappings of the object -model to the underlying transport mechanism for delivering media. +model to the underlying transport mechanisms. ##### Mode: StreamPerGroup @@ -944,7 +950,7 @@ over a single QUIC stream. `StreamPerObject` has a value of 0x1. ##### Mode: StreamPerTrack The mode `StreamPerTrack` specifies that all the groups and objects for a -given track is sent over a single QUIC stream. `StreamPerTrack` has a +given track are sent over a single QUIC stream. `StreamPerTrack` has a value of 0x2. ##### Mode: StreamPerPriority @@ -958,6 +964,10 @@ value of 0x3. The mode `Datagram` specifies that objects are sent using QUIC datagrams and has a value of 0x4. +Note: Certain considerations apply when using Datagram. See the +section on datagram that follows from discussions in the PR316.s +under the PR 316 + ## SUBSCRIBE {#message-subscribe-req} A receiver issues a SUBSCRIBE to a publisher to request a track. From 298ca59a3605235589da27c63e0de210492847b3 Mon Sep 17 00:00:00 2001 From: suhasHere Date: Wed, 8 Nov 2023 06:33:01 -0800 Subject: [PATCH 03/12] todo --- draft-ietf-moq-transport.md | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/draft-ietf-moq-transport.md b/draft-ietf-moq-transport.md index 938078de..c1955a37 100644 --- a/draft-ietf-moq-transport.md +++ b/draft-ietf-moq-transport.md @@ -927,9 +927,6 @@ that was sent on the stream at the top of the stack has a value of `N - D`. off the stack and repeat from the Step 2. If the stack is empty, close the connection with appropriate error code. -TODO: More details are needed to determine when the stream can be closed. - Refer to disucssions on issue 318 on explicit markers for signaling - stream completion. #### Proposal 2 - Object Placement Mode @@ -968,6 +965,10 @@ Note: Certain considerations apply when using Datagram. See the section on datagram that follows from discussions in the PR316.s under the PR 316 +TODO: More details are needed to determine when a stream can be closed. + Refer to disucssions on issue 318 on explicit markers for signaling + stream completion. + ## SUBSCRIBE {#message-subscribe-req} A receiver issues a SUBSCRIBE to a publisher to request a track. From e3e3864e5deb7ead302bafa85ea75343d7cea518 Mon Sep 17 00:00:00 2001 From: Alan Frindell Date: Wed, 8 Nov 2023 23:56:33 +0100 Subject: [PATCH 04/12] Proposal 3 - Stream Headers --- draft-ietf-moq-transport.md | 236 +++++++++++++++++++++++++++++++++++- 1 file changed, 235 insertions(+), 1 deletion(-) diff --git a/draft-ietf-moq-transport.md b/draft-ietf-moq-transport.md index c1955a37..576dc4c3 100644 --- a/draft-ietf-moq-transport.md +++ b/draft-ietf-moq-transport.md @@ -865,7 +865,7 @@ OBJECT Message { Object Delivery Preference (i), Object Send Order (i), [Object Payload Length (i)], - Object Payload (b), + Object Payload (...), } ~~~ {: #moq-transport-object-format title="MOQT OBJECT Message"} @@ -969,6 +969,240 @@ TODO: More details are needed to determine when a stream can be closed. Refer to disucssions on issue 318 on explicit markers for signaling stream completion. +## OBJECT (Proposal 3) + +### Canonical Object Fields + +A canonical MoQ Object has the following information: + +* Track Alias: The track alias obtained as part of subscription and/or +publish control message exchanges. + +* Group Sequence : The object is a member of the indicated group +{{model-group}} within the track. + +* Object Sequence: The order of the object within the group. The +sequence starts at 0, increasing sequentially for each object within the +group. + +* Object Send Order: An integer indicating the object send order +{{send-order}} or priority {{ordering-by-priorities}} value. + +* Object Forwarding Preference: An integer indicating how a sender MUST send an +object. The preferences are Track, Group, Object, Priority and Datagram. An +Object MUST be sent according to its `Object Forwarding Preference`, each +section describes how to do so. + +** Implementers Note: the Object Forwarding Preference is never sent directly +on the wire, but can be represented by storing the frame type. Since there's no +frame type for datagram, recommend we reserve a frame type for this purpose. + +* Object Payload: An opaque payload intended for the consumer and SHOULD +NOT be processed by a relay. + +### Object Message Formats + +There are five ways to represent an Object on the wire: `OBJECT_STREAM`, +`OBJECT_DATAGRAM`, `SHORT_OBJECT_TRACK`, `SHORT_OBJECT_GROUP` and +`SHORT_OBJECT_PRIORITY`. + +An `OBJECT_STREAM` message carries a single object on a stream. There is no +explicit length of the payload; it is terminated by the end of the stream. An +`OBJECT_STREAM` message MUST be the first message on a unidirectional stream. + +An Object received in an `OBJECT_STREAM` message has an `Object Forwarding +Preference` = `Object`. + +To send an Object with `Object Forwarding Preference` = `Object`, open transport +stream, serialize object fields below, and terminate the stream. + +~~~ +OBJECT_STREAM Message { + Track Alias (i), + Group Sequence (i), + Object Sequence (i), + Object Send Order (i), + Object Payload (...), +} +~~~ +{: #moq-transport-object-stream-format title="MOQT OBJECT_STREAM Message"} + +An `OBJECT_DATAGRAM` message carries a single object in a transport +datagram. There is no serialized message type, all datagrams in MoQT contain +OBJECT_DATAGRAM messages. There is no explicit length of the payload; it is +terminated by the end of the datagram. + +An Object received in an `OBJECT_DATAGRAM` message has an `Object Forwarding +Preference` = `Datagram`. + +To send an Object with `Object Forwarding Preference` = `Datagram`, send a +datagram with the serialized object fields below. + +~~~ +OBJECT_DATAGRAM { + Track Alias (i), + Group Sequence (i), + Object Sequence (i), + Object Send Order (i), + Object Payload (...), +} +~~~ +{: #moq-transport-object-datagram-format title="MOQT OBJECT_DATAGRAM"} + +### Multi-Object Streams + +When multiple objects are sent on a stream, the stream begins with a stream +header message and is followed by the corresponding type of `SHORT_OBJECT_*` +messages. The stream header messages are `STREAM_HEADER_TRACK`, +`STREAM_HEADER_GROUP`, `STREAM_HEADER_PRIORITY`. Note that `SHORT_OBJECT_*` +messages have no type encoded on the wire. + +TODO: figure out how a relay closes these streams + +When a stream begins with `STREAM_HEADER_TRACK`, all objects on the stream +belong to track indicated by `Track Alias`. + +~~~ +STREAM_HEADER_TRACK Message { + Track Alias (i) +} +~~~ +{: #moq-transport-stream-header-track-format title="MOQT STREAM_HEADER_TRACK Message"} + +An Object received in a `SHORT_OBJECT_TRACK` message has an `Object Forwarding +Preference` = `Track`. + +To send an Object with `Object Forwarding Preference` = `Track`, find the open +stream that is associated with the `Track Alias`, or open a new one and send the +`STREAM_HEADER_TRACK` if needed, then serialize the `SHORT_OBJECT_TRACK` fields. + +~~~ +SHORT_OBJECT_TRACK { + Group Sequence (i), + Object Sequence (i), + Object Send Order (i), + Object Payload Length (i), + Object Payload (...), +} +~~~ +{: #moq-transport-short-object-track-format title="MOQT SHORT_OBJECT_TRACK"} + +When a stream begins with `STREAM_HEADER_GROUP`, all objects on the stream +belong to the track indicated by the `Track Alias` and the group indicated by +`Group Sequence`. + +~~~ +STREAM_HEADER_GROUP Message { + Track Alias (i), + Group Sequence (i) +} +~~~ +{: #moq-transport-stream-header-group-format title="MOQT STREAM_HEADER_GROUP Message"} + +An Object received in a `SHORT_OBJECT_GROUP` message has an `Object Forwarding +Preference` = `Group`. + +To send an Object with `Object Forwarding Preference` = `Group`, find the open +stream that is associated with the `Track Alias` and `Group Sequence`, or open a +new one and send the `STREAM_HEADER_GROUP` if needed, then serialize the +`SHORT_OBJECT_GROUP` fields. + +~~~ +SHORT_OBJECT_GROUP { + Object Sequence (i), + Object Send Order (i), + Object Payload Length (i), + Object Payload (...), +} +~~~ +{: #moq-transport-short-object-group-format title="MOQT SHORT_OBJECT_GROUP"} + +When a stream begins with `STREAM_HEADER_PRIORITY`, all objects on the stream +belong have the same `Object Send Order`. + +~~~ +STREAM_HEADER_PRIORITY Message { + Object Send Order (i) +} +~~~ +{: #moq-transport-stream-header-priority-format title="MOQT STREAM_HEADER_PRIORITY Message"} + +An Object received in a `SHORT_OBJECT_PRIORITY` message has an `Object +Forwarding Preference` = `Priority`. + +To send an Object with `Object Forwarding Preference` = `Priority`, find the +open stream that is associated with the `Object Send Order`, or open a +new one and send the `STREAM_HEADER_PRIORITY` if needed, then serialize the +`SHORT_OBJECT_PRIORITY` fields. + +~~~ +SHORT_OBJECT_PRIORITY { + Track Alias (i), + Group Sequence (i), + Object Sequence (i), + Object Payload Length (i), + Object Payload (...), +} +~~~ +{: #moq-transport-short-object-priority-format title="MOQT SHORT_OBJECT_PRIORITY"} + +### Examples: + +Sending a track on one stream: + +~~~ +STREAM_HEADER_TRACK { + Track Alias = 1 +} +SHORT_OBJECT_TRACK { + Group Sequence = 0 + Object Sequence = 0 + Object Send Order = 0 + Object Payload Length = 4 + Payload = "abcd" +} +SHORT_OBJECT_TRACK { + Group Sequence = 1 + Object Sequence = 0 + Object Send Order = 1 + Object Payload Length = 4 + Payload = "efgh" +} +~~~ + +Sending a group on one stream, with a unordered object in the group appearing +on its own stream. + +~~~ +Stream = 2 + +STREAM_HEADER_GROUP { + Track Alias = 2 + Group Sequence = 0 +} +SHORT_OBJECT_GROUP { + Object Sequence = 0 + Object Send Order = 0 + Object Payload Length = 4 + Payload = "abcd" +} +SHORT_OBJECT_GROUP { + Object Sequence = 1 + Object Send Order = 2 + Object Payload Length = 4 + Payload = "efgh" +} + +Stream = 6 + +OBJECT_STREAM { + Track Alias = 2 + Group Sequence = 0 + Object Sequence = 1 + Payload = "moqrocks" +} +~~~ + ## SUBSCRIBE {#message-subscribe-req} A receiver issues a SUBSCRIBE to a publisher to request a track. From bc897a21fa7f59080a37b5f8fb2ddbe3444b7b56 Mon Sep 17 00:00:00 2001 From: Alan Frindell Date: Mon, 13 Nov 2023 16:27:20 -0800 Subject: [PATCH 05/12] Updates * Remove SHORT_OBJECT_ notation * Allow DATAGRAM on streams when > MTU * Change to DATAGRAM_PREFERRED * Add Track Alias and Group to Priority Header --- draft-ietf-moq-transport.md | 106 +++++++++++++++++------------------- 1 file changed, 51 insertions(+), 55 deletions(-) diff --git a/draft-ietf-moq-transport.md b/draft-ietf-moq-transport.md index 576dc4c3..af16fdcc 100644 --- a/draft-ietf-moq-transport.md +++ b/draft-ietf-moq-transport.md @@ -988,33 +988,25 @@ group. * Object Send Order: An integer indicating the object send order {{send-order}} or priority {{ordering-by-priorities}} value. -* Object Forwarding Preference: An integer indicating how a sender MUST send an +* Object Forwarding Preference: An enumeration indicating how a sender sends an object. The preferences are Track, Group, Object, Priority and Datagram. An -Object MUST be sent according to its `Object Forwarding Preference`, each -section describes how to do so. - -** Implementers Note: the Object Forwarding Preference is never sent directly -on the wire, but can be represented by storing the frame type. Since there's no -frame type for datagram, recommend we reserve a frame type for this purpose. +Object MUST be sent according to its `Object Forwarding Preference`, described +below. * Object Payload: An opaque payload intended for the consumer and SHOULD NOT be processed by a relay. ### Object Message Formats -There are five ways to represent an Object on the wire: `OBJECT_STREAM`, -`OBJECT_DATAGRAM`, `SHORT_OBJECT_TRACK`, `SHORT_OBJECT_GROUP` and -`SHORT_OBJECT_PRIORITY`. - An `OBJECT_STREAM` message carries a single object on a stream. There is no -explicit length of the payload; it is terminated by the end of the stream. An +explicit length of the payload; it is determined by the end of the stream. An `OBJECT_STREAM` message MUST be the first message on a unidirectional stream. An Object received in an `OBJECT_STREAM` message has an `Object Forwarding Preference` = `Object`. -To send an Object with `Object Forwarding Preference` = `Object`, open transport -stream, serialize object fields below, and terminate the stream. +To send an Object with `Object Forwarding Preference` = `Object`, open a stream, +serialize object fields below, and terminate the stream. ~~~ OBJECT_STREAM Message { @@ -1027,19 +1019,24 @@ OBJECT_STREAM Message { ~~~ {: #moq-transport-object-stream-format title="MOQT OBJECT_STREAM Message"} -An `OBJECT_DATAGRAM` message carries a single object in a transport -datagram. There is no serialized message type, all datagrams in MoQT contain -OBJECT_DATAGRAM messages. There is no explicit length of the payload; it is -terminated by the end of the datagram. +An `OBJECT_DATAGRAM_PREFERRED` message carries a single object in a datagram or +a stream. There is no explicit length of the payload; it is determined by the +length of the datagram or stream. If this message appears on a stream, it MUST +be the first message on a unidirectional stream. -An Object received in an `OBJECT_DATAGRAM` message has an `Object Forwarding -Preference` = `Datagram`. +An Object received in an `OBJECT_DATAGRAM_PREFERRED` message has an `Object +Forwarding Preference` = `Datagram`. -To send an Object with `Object Forwarding Preference` = `Datagram`, send a -datagram with the serialized object fields below. +To send an Object with `Object Forwarding Preference` = `Datagram`, serialize +the fields and payload, and compare the serialized size with the maximum +datagram size of the session. If the object size is less than or equal maximum +datagram size, send the serialized data as a datagram. Otherwise, open a +stream, send the serialized data and terminate the stream. An implementation +MUST NOT send an Object with `Object Forwarding Preference` = `Datagram` on a +stream if it is possible to send it as a datagram. ~~~ -OBJECT_DATAGRAM { +OBJECT_DATAGRAM_PREFERRED Message { Track Alias (i), Group Sequence (i), Object Sequence (i), @@ -1047,15 +1044,14 @@ OBJECT_DATAGRAM { Object Payload (...), } ~~~ -{: #moq-transport-object-datagram-format title="MOQT OBJECT_DATAGRAM"} +{: #object-datagram-format title="MOQT OBJECT_DATAGRAM_PREFERRED"} ### Multi-Object Streams When multiple objects are sent on a stream, the stream begins with a stream -header message and is followed by the corresponding type of `SHORT_OBJECT_*` -messages. The stream header messages are `STREAM_HEADER_TRACK`, -`STREAM_HEADER_GROUP`, `STREAM_HEADER_PRIORITY`. Note that `SHORT_OBJECT_*` -messages have no type encoded on the wire. +header message and is followed by one or more sets of serialized object fields. +If a stream ends in the middle of a serialized Object, terminate the session +with a Protocol Violation. TODO: figure out how a relay closes these streams @@ -1067,17 +1063,17 @@ STREAM_HEADER_TRACK Message { Track Alias (i) } ~~~ -{: #moq-transport-stream-header-track-format title="MOQT STREAM_HEADER_TRACK Message"} +{: #stream-header-track-format title="MOQT STREAM_HEADER_TRACK Message"} -An Object received in a `SHORT_OBJECT_TRACK` message has an `Object Forwarding -Preference` = `Track`. +All Objects received on a stream opened with STREAM_HEADER_TRACK have an `Object +Forwarding Preference` = `Track`. To send an Object with `Object Forwarding Preference` = `Track`, find the open stream that is associated with the `Track Alias`, or open a new one and send the -`STREAM_HEADER_TRACK` if needed, then serialize the `SHORT_OBJECT_TRACK` fields. +`STREAM_HEADER_TRACK` if needed, then serialize the the following object fields. ~~~ -SHORT_OBJECT_TRACK { +{ Group Sequence (i), Object Sequence (i), Object Send Order (i), @@ -1085,7 +1081,7 @@ SHORT_OBJECT_TRACK { Object Payload (...), } ~~~ -{: #moq-transport-short-object-track-format title="MOQT SHORT_OBJECT_TRACK"} +{: #object-track-format title="MOQT Track Stream Object Fields"} When a stream begins with `STREAM_HEADER_GROUP`, all objects on the stream belong to the track indicated by the `Track Alias` and the group indicated by @@ -1097,54 +1093,54 @@ STREAM_HEADER_GROUP Message { Group Sequence (i) } ~~~ -{: #moq-transport-stream-header-group-format title="MOQT STREAM_HEADER_GROUP Message"} +{: #stream-header-group-format title="MOQT STREAM_HEADER_GROUP Message"} -An Object received in a `SHORT_OBJECT_GROUP` message has an `Object Forwarding -Preference` = `Group`. +All Objects received on a stream opened with `STREAM_HEADER_GROUP` have an +`Object Forwarding Preference` = `Group`. To send an Object with `Object Forwarding Preference` = `Group`, find the open stream that is associated with the `Track Alias` and `Group Sequence`, or open a new one and send the `STREAM_HEADER_GROUP` if needed, then serialize the -`SHORT_OBJECT_GROUP` fields. +following fields. ~~~ -SHORT_OBJECT_GROUP { +{ Object Sequence (i), Object Send Order (i), Object Payload Length (i), Object Payload (...), } ~~~ -{: #moq-transport-short-object-group-format title="MOQT SHORT_OBJECT_GROUP"} +{: #object-group-format title="MOQT Group Stream Object Fields"} When a stream begins with `STREAM_HEADER_PRIORITY`, all objects on the stream -belong have the same `Object Send Order`. +belong have the same `Track Alias`, `Group Sequence` and `Object Send Order`. ~~~ STREAM_HEADER_PRIORITY Message { + Track Alias (i), + Group Sequence (i), Object Send Order (i) } ~~~ -{: #moq-transport-stream-header-priority-format title="MOQT STREAM_HEADER_PRIORITY Message"} +{: #stream-header-priority-format title="MOQT STREAM_HEADER_PRIORITY Message"} -An Object received in a `SHORT_OBJECT_PRIORITY` message has an `Object -Forwarding Preference` = `Priority`. +All Objects received on a stream opened with `STREAM_HEADER_PRIORITY` have an +`Object Forwarding Preference` = `Priority`. To send an Object with `Object Forwarding Preference` = `Priority`, find the -open stream that is associated with the `Object Send Order`, or open a -new one and send the `STREAM_HEADER_PRIORITY` if needed, then serialize the -`SHORT_OBJECT_PRIORITY` fields. +open stream that is associated with the `Track Alias`, `Group Sequence` and +`Object Send Order`, or open a new one and send the `STREAM_HEADER_PRIORITY` if +needed, then serialize the following fields. ~~~ -SHORT_OBJECT_PRIORITY { - Track Alias (i), - Group Sequence (i), +{ Object Sequence (i), Object Payload Length (i), Object Payload (...), } ~~~ -{: #moq-transport-short-object-priority-format title="MOQT SHORT_OBJECT_PRIORITY"} +{: #object-priority-format title="MOQT Priority Stream Object Fields"} ### Examples: @@ -1154,14 +1150,14 @@ Sending a track on one stream: STREAM_HEADER_TRACK { Track Alias = 1 } -SHORT_OBJECT_TRACK { +{ Group Sequence = 0 Object Sequence = 0 Object Send Order = 0 Object Payload Length = 4 Payload = "abcd" } -SHORT_OBJECT_TRACK { +{ Group Sequence = 1 Object Sequence = 0 Object Send Order = 1 @@ -1180,13 +1176,13 @@ STREAM_HEADER_GROUP { Track Alias = 2 Group Sequence = 0 } -SHORT_OBJECT_GROUP { +{ Object Sequence = 0 Object Send Order = 0 Object Payload Length = 4 Payload = "abcd" } -SHORT_OBJECT_GROUP { +{ Object Sequence = 1 Object Send Order = 2 Object Payload Length = 4 From 90757ab0fb885b369e61f8b1fddfca9e6dad6d52 Mon Sep 17 00:00:00 2001 From: Alan Frindell Date: Wed, 13 Dec 2023 20:47:50 -0800 Subject: [PATCH 06/12] Updates based on review feedback and editors call discussion Made the following changes: 1. Remove datagram mapping for now, will create a separate PR 2. Hoist Object Send Order to the Stream Header in Track and Group modes, and remove Priority as it was identical to Group 3. Add normative language that relays cannot drop or reorder objects that arrive in a multi-object stream 4. Replace Track Alias with Subscribe ID in OBJECT_STREAM and STREAM_HEADER_* to prevent multiple subscriptions to the same track/group from mixing objects on the same stream. 5. Add normative language prohibiting senders using two or more identical multi-object stream simultaneously 6. Other PR review feedback, but did dot (yet) rename messages, reorder group/track, or add new code points. --- draft-ietf-moq-transport.md | 119 +++++++++++------------------------- 1 file changed, 35 insertions(+), 84 deletions(-) diff --git a/draft-ietf-moq-transport.md b/draft-ietf-moq-transport.md index af16fdcc..ca6ebbe5 100644 --- a/draft-ietf-moq-transport.md +++ b/draft-ietf-moq-transport.md @@ -592,6 +592,9 @@ terminates the track with a SUBSCRIBE_FIN (see {{message-subscribe-fin}}) or a SUBSCRIBE_RST (see {{message-subscribe-rst}}). +A relay MUST not reorder or drop objects received on a multi-object stream when +forwarding to subscribers. + 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 @@ -975,10 +978,9 @@ TODO: More details are needed to determine when a stream can be closed. A canonical MoQ Object has the following information: -* Track Alias: The track alias obtained as part of subscription and/or -publish control message exchanges. +* Track Namespace and Track Name: The track this object belongs to. -* Group Sequence : The object is a member of the indicated group +* Group Sequence: The object is a member of the indicated group {{model-group}} within the track. * Object Sequence: The order of the object within the group. The @@ -989,9 +991,8 @@ group. {{send-order}} or priority {{ordering-by-priorities}} value. * Object Forwarding Preference: An enumeration indicating how a sender sends an -object. The preferences are Track, Group, Object, Priority and Datagram. An -Object MUST be sent according to its `Object Forwarding Preference`, described -below. +object. The preferences are Track, Group, and Object. An Object MUST be sent +according to its `Object Forwarding Preference`, described below. * Object Payload: An opaque payload intended for the consumer and SHOULD NOT be processed by a relay. @@ -1000,7 +1001,8 @@ NOT be processed by a relay. An `OBJECT_STREAM` message carries a single object on a stream. There is no explicit length of the payload; it is determined by the end of the stream. An -`OBJECT_STREAM` message MUST be the first message on a unidirectional stream. +`OBJECT_STREAM` message MUST be the first and only message on a unidirectional +stream. An Object received in an `OBJECT_STREAM` message has an `Object Forwarding Preference` = `Object`. @@ -1010,7 +1012,7 @@ serialize object fields below, and terminate the stream. ~~~ OBJECT_STREAM Message { - Track Alias (i), + Subscribe ID (i), Group Sequence (i), Object Sequence (i), Object Send Order (i), @@ -1019,48 +1021,28 @@ OBJECT_STREAM Message { ~~~ {: #moq-transport-object-stream-format title="MOQT OBJECT_STREAM Message"} -An `OBJECT_DATAGRAM_PREFERRED` message carries a single object in a datagram or -a stream. There is no explicit length of the payload; it is determined by the -length of the datagram or stream. If this message appears on a stream, it MUST -be the first message on a unidirectional stream. - -An Object received in an `OBJECT_DATAGRAM_PREFERRED` message has an `Object -Forwarding Preference` = `Datagram`. - -To send an Object with `Object Forwarding Preference` = `Datagram`, serialize -the fields and payload, and compare the serialized size with the maximum -datagram size of the session. If the object size is less than or equal maximum -datagram size, send the serialized data as a datagram. Otherwise, open a -stream, send the serialized data and terminate the stream. An implementation -MUST NOT send an Object with `Object Forwarding Preference` = `Datagram` on a -stream if it is possible to send it as a datagram. - -~~~ -OBJECT_DATAGRAM_PREFERRED Message { - Track Alias (i), - Group Sequence (i), - Object Sequence (i), - Object Send Order (i), - Object Payload (...), -} -~~~ -{: #object-datagram-format title="MOQT OBJECT_DATAGRAM_PREFERRED"} - ### Multi-Object Streams When multiple objects are sent on a stream, the stream begins with a stream header message and is followed by one or more sets of serialized object fields. -If a stream ends in the middle of a serialized Object, terminate the session -with a Protocol Violation. +If a stream ends gracefully in the middle of a serialized Object, terminate the +session with a Protocol Violation. + +A sender SHOULD NOT open more than one multi-object stream at a time with the +same stream header message type and fields. + TODO: figure out how a relay closes these streams When a stream begins with `STREAM_HEADER_TRACK`, all objects on the stream -belong to track indicated by `Track Alias`. +belong to the track requested in the Subscribe message identified by `Subscribe +ID`. All objects on the stream have the same `Object Send Order`. + ~~~ STREAM_HEADER_TRACK Message { - Track Alias (i) + Subscribe ID (i) + Object Send Order (i), } ~~~ {: #stream-header-track-format title="MOQT STREAM_HEADER_TRACK Message"} @@ -1069,14 +1051,13 @@ All Objects received on a stream opened with STREAM_HEADER_TRACK have an `Object Forwarding Preference` = `Track`. To send an Object with `Object Forwarding Preference` = `Track`, find the open -stream that is associated with the `Track Alias`, or open a new one and send the +stream that is associated with the subscription, or open a new one and send the `STREAM_HEADER_TRACK` if needed, then serialize the the following object fields. ~~~ { Group Sequence (i), Object Sequence (i), - Object Send Order (i), Object Payload Length (i), Object Payload (...), } @@ -1084,13 +1065,15 @@ stream that is associated with the `Track Alias`, or open a new one and send the {: #object-track-format title="MOQT Track Stream Object Fields"} When a stream begins with `STREAM_HEADER_GROUP`, all objects on the stream -belong to the track indicated by the `Track Alias` and the group indicated by -`Group Sequence`. +belong to the track requested in the Subscribe message identified by `Subscribe +ID` and the group indicated by `Group Sequence`. All objects on the stream +have the same `Object Send Order`. ~~~ STREAM_HEADER_GROUP Message { - Track Alias (i), + Subscribe ID (i), Group Sequence (i) + Object Send Order (i) } ~~~ {: #stream-header-group-format title="MOQT STREAM_HEADER_GROUP Message"} @@ -1099,68 +1082,37 @@ All Objects received on a stream opened with `STREAM_HEADER_GROUP` have an `Object Forwarding Preference` = `Group`. To send an Object with `Object Forwarding Preference` = `Group`, find the open -stream that is associated with the `Track Alias` and `Group Sequence`, or open a -new one and send the `STREAM_HEADER_GROUP` if needed, then serialize the -following fields. +stream that is associated with the subscription, `Group Sequence` and `Object +Send Order`, or open a new one and send the `STREAM_HEADER_GROUP` if needed, +then serialize the following fields. ~~~ { Object Sequence (i), - Object Send Order (i), Object Payload Length (i), Object Payload (...), } ~~~ {: #object-group-format title="MOQT Group Stream Object Fields"} -When a stream begins with `STREAM_HEADER_PRIORITY`, all objects on the stream -belong have the same `Track Alias`, `Group Sequence` and `Object Send Order`. - -~~~ -STREAM_HEADER_PRIORITY Message { - Track Alias (i), - Group Sequence (i), - Object Send Order (i) -} -~~~ -{: #stream-header-priority-format title="MOQT STREAM_HEADER_PRIORITY Message"} - -All Objects received on a stream opened with `STREAM_HEADER_PRIORITY` have an -`Object Forwarding Preference` = `Priority`. - -To send an Object with `Object Forwarding Preference` = `Priority`, find the -open stream that is associated with the `Track Alias`, `Group Sequence` and -`Object Send Order`, or open a new one and send the `STREAM_HEADER_PRIORITY` if -needed, then serialize the following fields. - -~~~ -{ - Object Sequence (i), - Object Payload Length (i), - Object Payload (...), -} -~~~ -{: #object-priority-format title="MOQT Priority Stream Object Fields"} - ### Examples: Sending a track on one stream: ~~~ STREAM_HEADER_TRACK { - Track Alias = 1 + Subscribe ID = 1 + Object Send Order = 0 } { Group Sequence = 0 Object Sequence = 0 - Object Send Order = 0 Object Payload Length = 4 Payload = "abcd" } { Group Sequence = 1 Object Sequence = 0 - Object Send Order = 1 Object Payload Length = 4 Payload = "efgh" } @@ -1173,18 +1125,17 @@ on its own stream. Stream = 2 STREAM_HEADER_GROUP { - Track Alias = 2 + Subscribe ID = 2 Group Sequence = 0 + Object Send Order = 0 } { Object Sequence = 0 - Object Send Order = 0 Object Payload Length = 4 Payload = "abcd" } { Object Sequence = 1 - Object Send Order = 2 Object Payload Length = 4 Payload = "efgh" } @@ -1192,7 +1143,7 @@ STREAM_HEADER_GROUP { Stream = 6 OBJECT_STREAM { - Track Alias = 2 + Subscribe ID = 2 Group Sequence = 0 Object Sequence = 1 Payload = "moqrocks" From 57648766abb0ef53c3fb5c135737c2245007f7b9 Mon Sep 17 00:00:00 2001 From: Alan Frindell Date: Thu, 11 Jan 2024 09:14:41 -0800 Subject: [PATCH 07/12] Update stream header proposal based on 1/9 Authors' call 1. Rebased all commits on main, updated text to match 2. Remove proposals 1 and 2 3. Add Track Alias back to all OBJECT formats, we now have both Subscription ID and Track Alias. This is redundant, the receiver can determine the track name and namespace from the Susbscription ID alone, but the group is unsure if we need Subscription ID in place in the long term. It was added based on the previous call, when there was concern about mixing objects from different subscriptions on the same stream.The plan is to have both for now, and let implementation experience and continued discussion guide whether we remove one or the other. --- draft-ietf-moq-transport.md | 163 +++++++----------------------------- 1 file changed, 30 insertions(+), 133 deletions(-) diff --git a/draft-ietf-moq-transport.md b/draft-ietf-moq-transport.md index ca6ebbe5..6c6da12a 100644 --- a/draft-ietf-moq-transport.md +++ b/draft-ietf-moq-transport.md @@ -852,127 +852,9 @@ the `query` portion of the URI to the parameter. ## OBJECT {#message-object} -A OBJECT message contains a range of contiguous bytes from from the +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. There are two subtypes of this message. When the -message type is 0x00, the optional Object Payload Length field is -present. When the message type is 0x02, the field is not present. - -The format of the OBJECT message is as follows: - -~~~ -OBJECT Message { - Track Alias (i), - Group ID (i), - Object ID (i), - Object Delivery Preference (i), - Object Send Order (i), - [Object Payload Length (i)], - Object Payload (...), -} -~~~ -{: #moq-transport-object-format title="MOQT OBJECT Message"} - -* Track Alias :The track identifier as specified in the - SUBSCRIBE message {{message-subscribe-req}}. - -* Group ID : The object is a member of the indicated group ID -{{model-group}} within the track. - -* Object ID: The order of the object within the group. The -IDs starts at 0, increasing sequentially for each object within the -group. - -* Object Delivery Preference: Publisher intended delivery preference, -See {{delivery-prefs}}. - -* Object Send Order: An integer indicating the object send order -{{send-order}} or priority {{ordering-by-priorities}} value. - -* Object Payload Length: The length of the following Object Payload. If this -field is absent, the object payload continues to the end of the stream. - -* Object Payload: An opaque payload intended for the consumer and SHOULD -NOT be processed by a relay. - - -### Object Delivery Preferences {#delivery-prefs} - -The publisher specifies its preference for mapping the elements of the -object model - Tracks, Groups and Objects, to the underlying transport -mechanisms such as QUIC Streams and QUIC Datagrams. A publisher chooses it -preference driven by the application needs. - -#### Proposal 1 - Stream Placement Indicator (Victor's Proposal and Text) - -`Stream Placement Indicator` specifies as variable length integer informing -the stream to choose for sending a given object. - -Each publisher follows the procedure defined below : - -Let `N` be the object sequence of the current object and `D` be the -stream placement indicator, and `S` be a stack of streams that is initially -empty. - -For each object to be sent: - -1. If `D` is zero, open a new stream and push it at the top of the stack. -Send the object on the stream at the top of the stack. - -2. If `D` is non-zero, check if the object sequence of the most recent object -that was sent on the stream at the top of the stack has a value of `N - D`. - - - If it is, continue sending the current object on the stream at the top - of the stack. - - - - If it is not, close the stream at the top of the stack, pop the stream - off the stack and repeat from the Step 2. If the stack is empty, close - the connection with appropriate error code. - - -#### Proposal 2 - Object Placement Mode - -`Object Placement Mode` is a enumeration of possible mappings of the object -model to the underlying transport mechanisms. - - -##### Mode: StreamPerGroup - -The mode `StreamPerGroup` specifies that all the objects for a given group -are sent over a single QUIC stream. `StreamPerGroup` has a value of 0x0. - -##### Mode: StreamPerObject - -The mode `StreamPerObject` specifies that each object is sent -over a single QUIC stream. `StreamPerObject` has a value of 0x1. - -##### Mode: StreamPerTrack - -The mode `StreamPerTrack` specifies that all the groups and objects for a -given track are sent over a single QUIC stream. `StreamPerTrack` has a -value of 0x2. - -##### Mode: StreamPerPriority - -The mode `StreamPerPriority` specifies that objects marked with a -given priorirty shared the same underlying QUIC stream. `StreamPerTrack` has a -value of 0x3. - -##### Mode: Datagram - -The mode `Datagram` specifies that objects are sent using QUIC datagrams and -has a value of 0x4. - -Note: Certain considerations apply when using Datagram. See the -section on datagram that follows from discussions in the PR316.s -under the PR 316 - -TODO: More details are needed to determine when a stream can be closed. - Refer to disucssions on issue 318 on explicit markers for signaling - stream completion. - -## OBJECT (Proposal 3) +cache, and forward it. ### Canonical Object Fields @@ -980,11 +862,11 @@ A canonical MoQ Object has the following information: * Track Namespace and Track Name: The track this object belongs to. -* Group Sequence: The object is a member of the indicated group +* Group ID: The object is a member of the indicated group ID {{model-group}} within the track. -* Object Sequence: The order of the object within the group. The -sequence starts at 0, increasing sequentially for each object within the +* Object ID: The order of the object within the group. The +IDs starts at 0, increasing sequentially for each object within the group. * Object Send Order: An integer indicating the object send order @@ -1013,14 +895,26 @@ serialize object fields below, and terminate the stream. ~~~ OBJECT_STREAM Message { Subscribe ID (i), - Group Sequence (i), - Object Sequence (i), + Track Alias (i), + Group ID (i), + Object ID (i), Object Send Order (i), Object Payload (...), } ~~~ {: #moq-transport-object-stream-format title="MOQT OBJECT_STREAM Message"} +* Subscribe ID: Subscription Identifer as defined in {{message-subscribe-req}}. + +* Track Alias: Identifies the Track Namespace and Track Name as defined in +{{message-subscribe-req}}. + +The Track Namespace and Track Name identified by the Track Alias is different +from the one identified by Subscribe ID, the receiver MUST close the session +with a Protocol Violation. + +* Other fields: As described in {{canonical-object-fields}}. + ### Multi-Object Streams When multiple objects are sent on a stream, the stream begins with a stream @@ -1056,8 +950,8 @@ stream that is associated with the subscription, or open a new one and send the ~~~ { - Group Sequence (i), - Object Sequence (i), + Group ID (i), + Object ID (i), Object Payload Length (i), Object Payload (...), } @@ -1066,13 +960,13 @@ stream that is associated with the subscription, or open a new one and send the When a stream begins with `STREAM_HEADER_GROUP`, all objects on the stream belong to the track requested in the Subscribe message identified by `Subscribe -ID` and the group indicated by `Group Sequence`. All objects on the stream +ID` and the group indicated by `Group ID`. All objects on the stream have the same `Object Send Order`. ~~~ STREAM_HEADER_GROUP Message { Subscribe ID (i), - Group Sequence (i) + Group ID (i) Object Send Order (i) } ~~~ @@ -1082,13 +976,13 @@ All Objects received on a stream opened with `STREAM_HEADER_GROUP` have an `Object Forwarding Preference` = `Group`. To send an Object with `Object Forwarding Preference` = `Group`, find the open -stream that is associated with the subscription, `Group Sequence` and `Object +stream that is associated with the subscription, `Group ID` and `Object Send Order`, or open a new one and send the `STREAM_HEADER_GROUP` if needed, then serialize the following fields. ~~~ { - Object Sequence (i), + Object ID (i), Object Payload Length (i), Object Payload (...), } @@ -1102,11 +996,12 @@ Sending a track on one stream: ~~~ STREAM_HEADER_TRACK { Subscribe ID = 1 + Track Alias = 1 Object Send Order = 0 } { - Group Sequence = 0 - Object Sequence = 0 + Group ID = 0 + Object ID = 0 Object Payload Length = 4 Payload = "abcd" } @@ -1126,6 +1021,7 @@ Stream = 2 STREAM_HEADER_GROUP { Subscribe ID = 2 + Track Alias = 2 Group Sequence = 0 Object Send Order = 0 } @@ -1144,6 +1040,7 @@ Stream = 6 OBJECT_STREAM { Subscribe ID = 2 + Track Alias = 2 Group Sequence = 0 Object Sequence = 1 Payload = "moqrocks" From 8c97531bdb70dc766ac6e44bdb976d3b6366dd78 Mon Sep 17 00:00:00 2001 From: Alan Frindell Date: Thu, 11 Jan 2024 20:18:36 -0800 Subject: [PATCH 08/12] First batch of Suhas' feedback 1. Add Track Alias where missing 2. Add codepoints for new messages 3. Update mismatch language --- draft-ietf-moq-transport.md | 30 +++++++++++++++++------------- 1 file changed, 17 insertions(+), 13 deletions(-) diff --git a/draft-ietf-moq-transport.md b/draft-ietf-moq-transport.md index 6c6da12a..73f3ef45 100644 --- a/draft-ietf-moq-transport.md +++ b/draft-ietf-moq-transport.md @@ -674,11 +674,9 @@ MOQT Message { |-------|----------------------------------------------------| | ID | Messages | |------:|:---------------------------------------------------| -| 0x0 | OBJECT with payload length ({{message-object}}) | +| 0x0 | OBJECT_STREAM ({{object-message-formats}}) | |-------|----------------------------------------------------| -| 0x2 | OBJECT without payload length ({{message-object}}) | -|-------|----------------------------------------------------| -| 0x3 | SUBSCRIBE ({{message-subscribe-req}}) | +| 0x3 | SUBSCRIBE ({{message-subscribe-req}}) | |-------|----------------------------------------------------| | 0x4 | SUBSCRIBE_OK ({{message-subscribe-ok}}) | |-------|----------------------------------------------------| @@ -704,6 +702,10 @@ MOQT Message { |-------|----------------------------------------------------| | 0x41 | SERVER_SETUP ({{message-setup}}) | |-------|----------------------------------------------------| +| 0x50 | STREAM_HEADER_TRACK ({{multi-object-streams}}) | +|-------|----------------------------------------------------| +| 0x51 | STREAM_HEADER_GROUP ({{multi-object-streams}}) | +|-------|----------------------------------------------------| ## Parameters {#params} @@ -910,8 +912,8 @@ OBJECT_STREAM Message { {{message-subscribe-req}}. The Track Namespace and Track Name identified by the Track Alias is different -from the one identified by Subscribe ID, the receiver MUST close the session -with a Protocol Violation. +from the one specified in the subscription identified by Subscribe ID, the +receiver MUST close the session with a Protocol Violation. * Other fields: As described in {{canonical-object-fields}}. @@ -936,6 +938,7 @@ ID`. All objects on the stream have the same `Object Send Order`. ~~~ STREAM_HEADER_TRACK Message { Subscribe ID (i) + Track Alias (i), Object Send Order (i), } ~~~ @@ -966,6 +969,7 @@ have the same `Object Send Order`. ~~~ STREAM_HEADER_GROUP Message { Subscribe ID (i), + Track Alias (i), Group ID (i) Object Send Order (i) } @@ -1006,8 +1010,8 @@ STREAM_HEADER_TRACK { Payload = "abcd" } { - Group Sequence = 1 - Object Sequence = 0 + Group ID = 1 + Object ID = 0 Object Payload Length = 4 Payload = "efgh" } @@ -1022,16 +1026,16 @@ Stream = 2 STREAM_HEADER_GROUP { Subscribe ID = 2 Track Alias = 2 - Group Sequence = 0 + Group ID = 0 Object Send Order = 0 } { - Object Sequence = 0 + Object ID = 0 Object Payload Length = 4 Payload = "abcd" } { - Object Sequence = 1 + Object ID = 1 Object Payload Length = 4 Payload = "efgh" } @@ -1041,8 +1045,8 @@ Stream = 6 OBJECT_STREAM { Subscribe ID = 2 Track Alias = 2 - Group Sequence = 0 - Object Sequence = 1 + Group ID = 0 + Object ID = 1 Payload = "moqrocks" } ~~~ From 8a678a681bd508dd4ec8a0e0a5611ed41421f656 Mon Sep 17 00:00:00 2001 From: Alan Frindell Date: Fri, 12 Jan 2024 17:43:28 -0800 Subject: [PATCH 09/12] Additional Suhas feedback 1. Indicate that a relay is allowed to reorder or drop objects on a stream if it has "application specific information". 2. Clarify `Object Send Order` wording for multi-object streams --- draft-ietf-moq-transport.md | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/draft-ietf-moq-transport.md b/draft-ietf-moq-transport.md index 73f3ef45..5bdbde10 100644 --- a/draft-ietf-moq-transport.md +++ b/draft-ietf-moq-transport.md @@ -593,7 +593,7 @@ terminates the track with a SUBSCRIBE_FIN (see {{message-subscribe-rst}}). A relay MUST not reorder or drop objects received on a multi-object stream when -forwarding to subscribers. +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 @@ -932,7 +932,8 @@ TODO: figure out how a relay closes these streams When a stream begins with `STREAM_HEADER_TRACK`, all objects on the stream belong to the track requested in the Subscribe message identified by `Subscribe -ID`. All objects on the stream have the same `Object Send Order`. +ID`. All objects on the stream have the `Object Send Order` specified in the +stream header. ~~~ @@ -964,7 +965,7 @@ stream that is associated with the subscription, or open a new one and send the When a stream begins with `STREAM_HEADER_GROUP`, all objects on the stream belong to the track requested in the Subscribe message identified by `Subscribe ID` and the group indicated by `Group ID`. All objects on the stream -have the same `Object Send Order`. +have the `Object Send Order` specified in the stream header. ~~~ STREAM_HEADER_GROUP Message { From bfa15c0ae549ce949c8bf051cac877b873601385 Mon Sep 17 00:00:00 2001 From: Alan Frindell Date: Wed, 17 Jan 2024 18:14:35 -0800 Subject: [PATCH 10/12] Feedback from 1/17 Editors call 1. Clarify that a relay MUST NOT modify object properties 2. Group ID/Object ID must be monotonically increasing on multi-object streams --- draft-ietf-moq-transport.md | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/draft-ietf-moq-transport.md b/draft-ietf-moq-transport.md index 76f4563c..c0ab8f64 100644 --- a/draft-ietf-moq-transport.md +++ b/draft-ietf-moq-transport.md @@ -652,7 +652,8 @@ congestion response. ## Relay Object Handling MOQT encodes the delivery information for a stream via OBJECT headers -({{message-object}}). +({{message-object}}). 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 @@ -975,6 +976,10 @@ stream that is associated with the subscription, or open a new one and send the ~~~ {: #object-track-format title="MOQT Track Stream Object Fields"} +A sender MUST NOT send an Object on a stream if its Group ID is less than a +previously sent Group ID on that stream, or if its Object ID is less than or +equal to a previously sent Object ID within a given group on that stream. + When a stream begins with `STREAM_HEADER_GROUP`, all objects on the stream belong to the track requested in the Subscribe message identified by `Subscribe ID` and the group indicated by `Group ID`. All objects on the stream @@ -1007,6 +1012,9 @@ then serialize the following fields. ~~~ {: #object-group-format title="MOQT Group Stream Object Fields"} +A sender MUST NOT send an Object on a stream if its Object ID is less than a +previously sent Object ID within a given group in that stream. + ### Examples: Sending a track on one stream: From 989f8a1c87daf46dbe4930c87a891399bacc09a9 Mon Sep 17 00:00:00 2001 From: ianswett Date: Thu, 18 Jan 2024 11:52:13 -0500 Subject: [PATCH 11/12] Update draft-ietf-moq-transport.md --- draft-ietf-moq-transport.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/draft-ietf-moq-transport.md b/draft-ietf-moq-transport.md index c0ab8f64..4477b996 100644 --- a/draft-ietf-moq-transport.md +++ b/draft-ietf-moq-transport.md @@ -925,7 +925,7 @@ OBJECT_STREAM Message { * Track Alias: Identifies the Track Namespace and Track Name as defined in {{message-subscribe-req}}. -The Track Namespace and Track Name identified by the Track Alias is different +If the Track Namespace and Track Name identified by the Track Alias is different from the one specified in the subscription identified by Subscribe ID, the receiver MUST close the session with a Protocol Violation. From 2c3a441bfaeedc50a0db0e1b951111d1cd0129cf Mon Sep 17 00:00:00 2001 From: ianswett Date: Thu, 18 Jan 2024 11:57:24 -0500 Subject: [PATCH 12/12] Update draft-ietf-moq-transport.md --- draft-ietf-moq-transport.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/draft-ietf-moq-transport.md b/draft-ietf-moq-transport.md index 4477b996..28c3a05b 100644 --- a/draft-ietf-moq-transport.md +++ b/draft-ietf-moq-transport.md @@ -925,9 +925,9 @@ OBJECT_STREAM Message { * Track Alias: Identifies the Track Namespace and Track Name as defined in {{message-subscribe-req}}. -If the Track Namespace and Track Name identified by the Track Alias is different -from the one specified in the subscription identified by Subscribe ID, the -receiver MUST close the session with a Protocol Violation. +If the Track Namespace and Track Name identified by the Track Alias are +different from those specified in the subscription identified by Subscribe ID, +the receiver MUST close the session with a Protocol Violation. * Other fields: As described in {{canonical-object-fields}}.