RFC 6801
Pseudo Content Delivery Protocol (CDP) for Protecting Multiple Source Flows in the Forward Error Correction (FEC) Framework
RFC 6801 💖 Pseudo Content Delivery Protocol (CDP) for Protecting Multiple Source Flows in the Forward Error Correction (FEC) Framework
okay bestie, let's get into this one 🦋 here's the lowdown:
- Number: RFC 6801
- Authors: U. Kozat (DOCOMO Innovations) and A. Begen (Cisco)
- Category: Informational
- ISSN: 2070-1721
- Date: November 2012
- Obsoletes/Updates: it doesn't list any documents it obsoletes or updates ✨
Abstract 🎀
so this doc gives you a pseudo Content Delivery Protocol (CDP) that protects multiple source flows with one or more repair flows 🔥. it's built on the Forward Error Correction (FEC) Framework and the Session Description Protocol (SDP) elements defined for that framework. it's not a full-fledged protocol, though. the whole point is to show how the framework and SDP elements combine to build a CDP 🧚
Status of This Memo 🌸
this one is not an Internet Standards Track spec. it's published for informational purposes 📚
it's a product of the Internet Engineering Task Force (IETF) and represents the consensus of the IETF community. it got public review and was approved for publication by the Internet Engineering Steering Group (IESG). not every IESG-approved doc is a candidate for any level of Internet Standard, so check Section 2 of RFC 5741 for the deets 💅
for the current status, any errata, and how to give feedback, go to http://www.rfc-editor.org/info/rfc6801 🫶
Copyright Notice 🌈
Copyright (c) 2012 IETF Trust and the persons identified as the document authors. All rights reserved.
this doc is subject to BCP 78 and the IETF Trust's Legal Provisions Relating to IETF Documents (http://trustee.ietf.org/license-info) in effect on the date of publication. please read these carefully, bestie, because they spell out your rights and restrictions for this doc. Code Components extracted from this document must include Simplified BSD License text as described in Section 4.e of the Trust Legal Provisions, and they come without warranty as described in the Simplified BSD License ⚠️
this doc may contain material from IETF Documents or IETF Contributions published or made publicly available before November 10, 2008. the people controlling the copyright in some of that material may not have granted the IETF Trust the right to allow modifications outside the IETF Standards Process. so unless you get an adequate license from those copyright holders, this doc may not be modified outside the IETF Standards Process, and derivative works of it may not be created outside the IETF Standards Process. the exceptions are formatting it for publication as an RFC or translating it into languages other than English 💖
Table of Contents 📋
1. Introduction ....................................................3
2. Definitions/Abbreviations .......................................3
3. Construction of a Repair Flow from Multiple Source Flows ........3
3.1. Example: Two Source Flows Protected by a Single
Repair Flow ................................................6
4. Reconstruction of Source Flows from Repair Flow(s) ..............9
4.1. Example: Multiple Source Flows Protected by a
Single Repair Flow .........................................9
5. Security Considerations ........................................10
6. Acknowledgments ................................................10
7. Normative References ...........................................111. Introduction ✨
okay so the FEC Framework (described in [RFC6363]) and the SDP Elements for FEC Framework (described in [RFC6364]) together define mechanisms that are sufficient to build an actual Content Delivery Protocol (CDP) with FEC protection 🎀. then there are the methods to convey FEC Framework Configuration Information (described in [RFC6695]). those are the signaling protocols that may be used as part of a CDP to communicate FEC-Scheme-Specific Information from the FEC sender to a single as well as multiple FEC receivers 📡
this doc gives you a guideline on how the mechanisms in [RFC6363] and [RFC6364] can be sufficiently used to design a CDP in a non-trivial scenario: protecting multiple source flows with one or more repair flows. it's giving main character energy 👑
specifically, we clarify and describe how:
- source and repair flows may be uniquely identified,
- source blocks may be generated from one or more source flows,
- repair flows may be paired with the source flows,
- the receiver explicitly and implicitly identifies individual flows, and
- source blocks are regenerated at the receiver and the missing source symbols in a source block are recovered 🧚
2. Definitions/Abbreviations 🍓
this doc uses all the definitions and abbreviations from Section 2 of [RFC6363], minus the RFC 2119 requirements language 💅
3. Construction of a Repair Flow from Multiple Source Flows 🦋
so on the sender side, the CDP builds the source blocks (SBs) by multiplexing transport payloads from multiple flows (see Figures 1 and 2) 🔥. the FEC Framework says each source block is FEC-protected separately. each source block gets handed to the specific FEC encoder used within the CDP as input, and the outputs (the Explicit Source FEC Payload ID, the Repair FEC Payload ID, and the Repair Payloads for that source block) get generated from it 💖. quick note: the Explicit Source FEC Payload ID is optional. if the CDP has an implicit way of building the source block at the sender/receiver (for example, using existing sequence numbers in the payload), the Explicit Source FEC Payload ID might not be output 🫶
+------------+
s_1 --------> | |
. Source | Source | +--------+ +--------+ +--------+
. Flows | Block |==> ..|SB_(j+1)| | SB_j | |SB_(j-1)| ..
s_n --------> | Generation | +--------+ +--------+ +--------+
+------------+
Figure 1: Source Block Generation for a FEC Schemefigure 2 shows the structure of a source block. a CDP must clearly specify which payload corresponds to which source flow, plus the length of each payload 📝
<------------------ Source Block (SB) ------------------->
+-------...-----+-------...-----+- -+-------...-----+
| Payload_1 | Payload_2 | . . . | Payload_n |
+-------...-----+-------...-----+- -+-------...-----+
\______ _______|______ _______| |______ _______|
\/ \/ \/
FID_1,Len_1 FID_2,Len_2 FID_n,Len_n
Figure 2: Structure of a Source Blockthe Flow ID (FID) is a unique shorthand identifier for the source flows 🆔. the FID is specified and associated with a possibly wildcarded tuple of {source IP address, source port, destination IP address, destination port, transport protocol} in the SDP description. when something in the tuple is wildcarded, those fields aren't needed to tell the source flows apart 🧩. the tuple gets carried in the IP and transport headers of the source packets. since the CDP and FEC scheme use the FID to distinguish source packets, the tuple must have a one-to-one mapping to a valid FID. the specific example later in this section makes this way clearer 🎀. the length of the FID must be a priori fixed and known to both the receiver and the sender. alternatively, it might be specified in the FEC-Scheme-Specific Information field in the SDP element [RFC6364] ✨
the payload length (Len) info is needed to figure out how many bits, bytes, or symbols (depending on the FEC scheme) from a particular source flow are included in the source block 📏. if the payload isn't an integer multiple of the specified symbol length, the leftover portion gets padded with zeros (see Figures 3 and 4) 🧸
+------+
+--------+ +--------+ +--------+ | | -------> r_1
.. |SB_(j+1)| | SB_j | |SB_(j-1)| .. ==> | FEC | Repair .
+--------+ +--------+ +--------+ |Scheme| Flows .
| | -------> r_k
+------+
Figure 3: Repair Flow Generation by a FEC Scheme <------------------ Source Block (SB) ------------------->
| | | | | |
+-------...-----+-------...-----+- -+-------...-----+ |
| Payload_1 | Payload_2 | . . . | Payload_n |0|
+-------...-----+-------...-----+- -+-------...-----+ |
| | | | | |
| Symbol_1 | Symbol_2 | Symbol_3 | . . . | Symbol_m |
|<-------->|<-------->|<-------->| |<-------->|
+------+
Symbol_1,..,Symbol_m => | FEC | => Symbol_u,..,Symbol_1
| Enc. |
+------+
Figure 4: Repair Flow Payload GenerationFEC schemes usually expect a source block of a certain size, say m symbols 🍰. so the FEC encoder divides each source block into m symbols (padding it if the source block is shorter than the expected m symbols) and generates u repair symbols. those repair symbols are functions of the m symbols in the original source block 🔁. the FEC scheme groups the repair symbols into repair payloads, and each repair payload gets a Repair FEC Payload ID so the receiver can associate it with a particular source block 🧲. if the payloads in a given source block have sequence numbers that can uniquely specify their location in the source block, an Explicit Source FEC Payload ID may not be generated for them. otherwise, Explicit Source FEC Payload IDs are generated for each payload and indicate the order the payloads appear in the source block 🫶
note that the FID and length info are not actually transmitted with the source payloads, since both can be figured out by other means, as the next sections make clear 💜
3.1. Example: Two Source Flows Protected by a Single Repair Flow 🎀
okay bestie, let's walk through a real example of the CDP generating source and repair flows 💅 We've got two source flows, with flow IDs 0 and 1, both protected by a single repair flow (see Figure 5 ✨). S1 is multicast to 233.252.0.1 and S2 is multicast to 233.252.0.2. Both use port 30000.
SOURCE FLOWS
S1: Source Flow | | INSTANCE #1
|---------| R3: Repair Flow
S2: Source Flow |
Figure 5: Example: Two Source Flows and One Repair FlowThe SDP description below says that the source flow defined by the tuple {*,*,233.252.0.1,30000} is identified with FID=0, and the source flow defined by the tuple {*,*,233.252.0.2,30000} is identified with FID=1 (via the id parameter of the "fec-source-flow" attribute) 🦋 It also says the repair flow gets received at the multicast address 233.252.0.3 on port 30000.
v=0
o=ali 1122334455 1122334466 IN IP4 fec.example.com
s=FEC Framework Examples
t=0 0
a=group:FEC-FR S1 S2 R3
m=video 30000 RTP/AVP 100
c=IN IP4 233.252.0.1/127
a=rtpmap:100 MP2T/90000
a=fec-source-flow: id=0
a=mid:S1
m=video 30000 RTP/AVP 101
c=IN IP4 233.252.0.2/127
a=rtpmap:101 MP2T/90000
a=fec-source-flow: id=1
a=mid:S2
m=application 30000 UDP/FEC
c=IN IP4 233.252.0.3/127
a=fec-repair-flow: encoding-id=0; ss-fssi=n:7,k:5
a=repair-window:150ms
a=mid:R3Figure 6 shows the first and second source blocks (SB_1 and SB_2) generated from these two source flows 🌸 In this example, SB_1 is 10000 bytes long. Say the FEC scheme uses a symbol length of 512 bytes. Then SB_1 can be split into 20 symbols after padding the source block with 240 bytes. The FEC scheme is a rate-2/3 erasure code, so it generates 10 repair symbols from the 20 original symbols for SB_1. SB_2 is 7000 bytes long, so it can be split into 14 symbols after padding with 168 bytes. Using the same encoder, seven repair symbols are generated for SB_2 🧚
<-------- Source Block 1 -------->
+------------+-------------------+
| $1 $2 $3 $4| #1 #2 #3 #4 #5 #6 | 0..00
+------------+-------------------+
\__________________ __________________/
\/
@1 @2 @3 @4 @5 @6 @7 @8 @9 @10
<---- Source Block 2 ---->
+----------------+-------+
| $5 $6 $7 $8 $9 | #7 #8 |0..00
+----------------+-------+
\______________ _____________/
\/
@11 @12 @13 @14 @15 @16 @17
$: 1000-byte payload from source flow 1
#: 1000-byte payload from source flow 2
@: Repair symbol
Figure 6: Source Block with Two Source FlowsThe unit of payload length, FEC scheme, symbol size, and coding rates can be specified in the FEC-Scheme-Specific Information (FSSI) field of the SDP element ✨ If the payload lengths from each source flow and the order of source flows in every source block are fixed during the session, those values can also go in the FSSI field. To carry FSSI information to the FEC receivers, you can use the signaling methods described in [RFC6695]. In our example, the ordering is fixed and known at both the sender and the receiver, but the payload lengths vary from one source block to another. We assume that the payload of a source flow with a smaller FID than another flow's FID comes before the other payloads in a source block 💖
The FEC scheme takes the source blocks as input and generates parity blocks for each source block, protecting the whole thing 🔥 In the example, the repair payloads for SB_1 are 512-byte symbols called @1 to @10. Likewise, @11 to @17 are the repair payloads for SB_2. The FEC scheme outputs the repair payloads along with the Repair FEC Payload IDs. Here, the Repair FEC Payload ID tells you the source block sequence number and the order the repair symbols were generated in. For instance, @3 is the third FEC repair symbol for SB_1, and the three-tuple {@3,SB_1,3} uniquely delivers that info 👑 The FEC scheme also provides Explicit Source FEC Payload IDs, which say which source symbols belong to which source block sequence number and where they sit in that block. For example, the two-tuple {SB_2,2} can be attached to $6 as its Explicit Source FEC Payload ID, meaning $6 is protected together with packets from SB_2 and is the second payload in SB_2 🫶
The source packets are built from source symbols by concatenating consecutive symbols into one packet. There should not be any fragmentation of a source symbol. For example, symbols #7 and #8 can be concatenated in one transport payload of 2000 bytes (the implementation should make sure the resulting source packet, payload plus overhead, is not larger than the path MTU). But one portion of symbol #7 should not go in one source packet while the rest goes in another 🙈 The simplest approach is to put each source symbol in its own source packet, as shown in Figure 7.
+------------------------------------+
| IP header {233.252.0.1} |
+------------------------------------+
| Transport header {30000} |
+------------------------------------+
| Original Transport Payload {$6} |
+------------------------------------+
| Source FEC Payload ID {SB_2,2} |
+------------------------------------+
Figure 7: Example of a Source Packet for IPv4Repair packets are generated from the repair symbols in the same source block by grouping consecutive symbols into one packet 🦋 Same rule here: there should not be any fragmentation of a repair symbol. For example, symbols @4, @5, and @6 can be concatenated in one transport payload of 1536 bytes, but @6 should not be divided into smaller sub-symbols and spread across multiple repair packets. The Repair FEC Payload ID must carry enough info for decoding. In our example, it's sufficient to indicate the source block sequence number, the length of each source payload, and the order of the first parity symbol in the repair packet among all parity symbols generated for that source block. The exact header format of the Repair FEC Payload ID may be specified in the FSSI field of the SDP element 🌈 In Figure 8, the repair symbols @4, @5, and @6 are concatenated together. The Payload ID {SB_1,4,4,6} says the repair symbols protect SB_1, the first repair symbol in the payload is generated as the fourth symbol, and the source block consists of two source flows carrying four and six packets from each.
+------------------------------------+
| IP header {233.252.0.3} |
+------------------------------------+
| Transport header {30000} |
+------------------------------------+
| Repair FEC Payload ID {SB_1,4,4,6} |
+------------------------------------+
| Repair Symbols {@4,@5,@6} |
+------------------------------------+
Figure 8: Example of a Repair Packet for IPv44. Reconstruction of Source Flows from Repair Flow(s) 🌸
Here we give an example of reconstructing multiple source flows from a single repair flow 💜
4.1. Example: Multiple Source Flows Protected by a Single Repair Flow
At the receiver, source flows 1 and 2 are received at {233.252.0.1,30000} and {233.252.0.2,30000}, while the repair flow is received at {233.252.0.3,30000}. The CDP can map these tuples to flow IDs using the SDP elements. So the payloads received at {233.252.0.1,30000} and {233.252.0.2,30000} get mapped to flow IDs 0 and 1, respectively ✨
The CDP passes the flow IDs and received payloads, along with the Explicit Source FEC Payload ID, to the FEC scheme defined in the SDP description. It also passes the received repair packet payloads and the Repair FEC Payload ID to the FEC scheme. The FEC scheme can build the original source block with missing packets by using the info in the FEC Payload IDs 🧠 The FEC Repair Payload ID tells it that SB_1 has packets from two flows: four from the first and six from the second. Flow IDs say the packets from source flow 0 come before the packets from source flow 1. The Explicit Source FEC Payload IDs, on the other hand, tell it which source payload shows up in what order. So the FEC scheme can map out a source block with the exact locations of the missing packets 😭 Figure 9 shows this for SB_1. Since the decoder can construct the original source block with missing packets, and the FEC scheme knows the coding rate (which might be carried in the FSSI field in the SDP description), proper decoding can start as soon as the repair symbols reach the FEC scheme 🎀
<-------- Source Block 1 -------->
+------------+-------------------+
| $1 $2 X X | #1 X #3 #4 #5 #6 |
+------------+-------------------+
O: Symbols received from the source flow 1 for SB_1
#: Symbols received from the source flow 2 for SB_1
X: Lost source symbols
Figure 9: Source Block RegenerationIf the FEC scheme can recover any missing symbol while more repair symbols are still arriving, it hands the recovered blocks, along with the source flow IDs of those blocks, to the CDP as output 💅 The receiver knows how long to wait to repair the remaining missing packets (for example, as specified by the repair-window attribute in the SDP description) ⭐ When the associated timer expires, the CDP hands over whatever could be recovered from the source flow to the application layer and moves on to processing the next source block.
5. Security Considerations 🔐
For the general security considerations related to the FEC Framework, refer to [RFC6363]. For the security considerations related to the SDP elements in the FEC Framework, refer to [RFC6364]. There are no additional security considerations that apply to this document 🫶
6. Acknowledgments 💖
The authors would like to thank the FEC Framework design team for their inputs, suggestions, and contributions 👑
7. Normative References 🔗
okay bestie, these are the docs this RFC leans on 🫶 you can't really build this without reading them first. no cap, they're the foundation 💅
[RFC6363] Watson, M., Begen, A., and V. Roca, "Forward Error Correction (FEC) Framework", RFC 6363, October 2011. 🧚
[RFC6364] Begen, A., "Session Description Protocol Elements for the Forward Error Correction (FEC) Framework", RFC 6364, October 2011. 🦋
[RFC6695] Asati, R., "Methods to Convey Forward Error Correction (FEC) Framework Configuration Information", RFC 6695, August 2012. 💜
Authors' Addresses 💌
meet the people who wrote this, besties ✨ here's where you can reach them 🌸
Ulas C. Kozat
DOCOMO Innovations
3240 Hillview Avenue
Palo Alto, CA 94304-1201
USA
Phone: +1 650 496 4739
EMail: kozat@docomolabs-usa.com
Ali Begen
Cisco
181 Bay Street
Toronto, ON M5J 2T3
Canada
EMail: abegen@cisco.comand that's the whole doc, babe!! 🎀👑
📦 where this page comes from
- ietf: rfc6801 2012-11
- 💖 girlified by claude-haiku-5-5 on : a language model's rewrite of the original, under its terms