RFC 3119
A More Loss-Tolerant RTP Payload Format for MP3 Audio
Part 1 of 4, bestie, so more is coming! 💖
RFC 3119 🎀 is called A More Loss-Tolerant RTP Payload Format for MP3 Audio. It was written by R. Finlayson from LIVE.COM and dated June 2001. It's a Standards Track doc, so it's an actual Internet protocol spec, not just a chat. The header doesn't list any RFCs it obsoletes or updates, so it's a fresh start, no drama. 🦋
Status of this Memo ✨
This document specifies an Internet standards track protocol for the Internet community, and asks for discussion and suggestions for improvements. For the standardization state and status of this protocol, check the "Internet Official Protocol Standards" (STD 1) list. Distribution of this memo is unlimited. 🌸
Copyright Notice
Copyright (C) The Internet Society (2001). All Rights Reserved.
Abstract
Okay so this doc describes an RTP (Real-Time Protocol) payload format for carrying MPEG (Moving Picture Experts Group) 1 or 2, layer III audio, which everyone knows as "MP3" 🎧. It's an alternative to the one in RFC 2250, and it performs better when packets get lost. Main character energy, honestly. 💅
1. Introduction
So RFC 2250 [2] is generally fine for all kinds of MPEG audio and video, but it's kinda sub-optimal for MP3 🙈. The reason is that an MP3 frame isn't a true "Application Data Unit" (ADU). It contains a back-pointer to data in earlier frames, so it can't be decoded on its own without those earlier frames. RFC 2250 says packet boundaries line up with frame boundaries, so when an MP3 frame gets lost, it handles that inefficiently. Losing one frame can make data in previous (or future) frames useless, even if those frames arrived just fine. Rude. 😭
So this doc defines a different RTP payload format for MP3 audio. It does a data-preserving rearrangement of the original MPEG frames, so packet boundaries now line up with true MP3 "Application Data Units". Those ADUs can also (optionally) be rearranged in an interleaving pattern ✨. This new format is therefore more data-efficient than RFC 2250 when packets are lost. Iconic. 👑
2. The Structure of MP3 Frames
Here's a quick overview of what an MP3 frame looks like 🧚. (For the full details, see the MPEG 1 audio [3] and MPEG 2 audio [4] specifications.)
Every MPEG audio frame starts with a 4-byte header. This header tells you:
- Whether the audio is MPEG 1 or MPEG 2.
- Whether the audio is layer I, II, or III. (The rest of this document assumes layer III, i.e., "MP3" frames.)
- Whether the audio is mono or stereo.
- Whether or not there's a 2-byte CRC field following the header.
- (Indirectly) The size of the frame.
After the header, you'll find these structures:
- (Optionally) A 2-byte CRC field
- A "side info" structure. Its length is:
- 32 bytes for MPEG 1 stereo
- 17 bytes for MPEG 1 mono, or for MPEG 2 stereo
- 9 bytes for MPEG 2 mono
- Encoded audio data, plus optional ancillary data (filling out the rest of the frame)
For this doc, the "side info" structure is the most important one 🥹. It decides the location and size of the "Application Data Unit" (ADU) that an MP3 decoder will process. Specifically, the "side info" structure defines:
- "main_data_begin": This is a back-pointer (in bytes) to the start of the ADU. It's counted from the beginning of the frame, and it only counts encoded audio data and any ancillary data (so any header, CRC, or "side info" fields get ignored).
An MP3 decoder processes each ADU independently. ADUs will usually vary in length, but their average length will be the length of the MP3 frames, minus the length of the header, CRC, and "side info" fields. (In MPEG literature, this ADU is sometimes called a "bit reservoir".) 🍓
3. A New Payload Format
As noted in [5], a payload format should be designed so that packet boundaries line up with "codec frame boundaries", meaning with ADUs 💜. In the RFC 2250 payload format for MPEG audio [2], each RTP packet payload carries MP3 frames. In this new payload format for MP3 audio, each RTP packet payload instead carries "ADU frames", and each one is preceded by an "ADU descriptor".
3.1 ADU frames
An "ADU frame" is made up of:
- The 4-byte MPEG header (the same as the original MP3 frame, except that the first 11 bits are (optionally) replaced by an "Interleaving Sequence Number", as described in section 6 below)
- The optional 2-byte CRC field (the same as the original MP3 frame)
- The "side info" structure (the same as the original MP3 frame)
- The complete sequence of encoded audio data (and any ancillary data) for the ADU, i.e., running from the start of this MP3 frame's "main_data_begin" back-pointer up to the start of the next MP3 frame's back-pointer 🔥
3.2 ADU descriptors
Inside each RTP packet payload, every "ADU frame" is preceded by a 1 or 2-byte "ADU descriptor". It gives the size of the ADU and says whether this packet's data continues the previous packet's data. (That only happens when one "ADU descriptor" plus "ADU frame" is too big to fit in a single RTP packet ✨.)
An ADU descriptor has these fields:
- "C": Continuation flag (1 bit): 1 if the data after the ADU descriptor continues an ADU frame that was too large to fit in a single RTP packet; 0 otherwise.
- "T": Descriptor Type flag (1 bit): 0 if this is a 1-byte ADU descriptor; 1 if this is a 2-byte ADU descriptor.
- "ADU size" (6 or 14 bits): The size (in bytes) of the ADU frame that follows this ADU descriptor, i.e., NOT including the size of the descriptor itself. A 2-byte ADU descriptor (with a 14-bit "ADU size" field) is used for ADU frame sizes of 64 bytes or more. For smaller ADU frame sizes, senders MAY alternatively use a 1-byte ADU descriptor (with a 6-bit "ADU size" field). Receivers MUST be able to accept an ADU descriptor of either size.
So a 1-byte ADU descriptor looks like this:
0 1 2 3 4 5 6 7
+-+-+-+-+-+-+-+-+
|C|0| ADU size |
+-+-+-+-+-+-+-+-+and a 2-byte ADU descriptor looks like this:
0 1
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|C|1| ADU size (14 bits) |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+3.3 Packing rules
Each RTP packet payload starts with an "ADU descriptor", followed by "ADU frame" data. Normally, this "ADU descriptor" plus "ADU frame" fits completely inside the RTP packet. In that case, more than one successive "ADU descriptor" plus "ADU frame" MAY be packed into a single RTP packet, as long as they all fit completely 📦.
But if a single "ADU descriptor" plus "ADU frame" is too big to fit in an RTP packet, the "ADU frame" gets split across two or more successive RTP packets. Each of those packets starts with an ADU descriptor. The first packet's descriptor has a "C" (continuation) flag of 0, and the following packets' descriptors each have a "C" flag of 1. In this case, every descriptor has the same "ADU size" value: the size of the entire "ADU frame", not just the part that fits in one RTP packet. Each such packet, even the last one, contains only one "ADU descriptor". 🧩
3.4 RTP header fields
Payload Type: The (static) payload type 14 that was defined for MPEG audio [6] MUST NOT be used. Instead, a different, dynamic payload type MUST be used, i.e., one in the range [96,127]. 🚫M bit: This payload format doesn't use this bit at all. Senders SHOULD set this bit to zero in each outgoing packet.Timestamp: This is a 32-bit 90 kHz timestamp, representing the presentation time of the first ADU packed within the packet. ⏰
3.5 Handling received data
Here's the key thing: converting a sequence of MP3 frames into a matching sequence of "ADU frames" loses no information 💖. So a receiving RTP implementation can either feed the ADU frames straight into an appropriately modified MP3 decoder, or convert them back into a sequence of MP3 frames, as described in appendix A.2 below.
4. Handling Multiple MPEG Audio Layers
This RTP payload format is only meant for MPEG 1 or 2, layer III audio ("MP3"). By contrast, layer I and layer II frames are self-contained, with no back-pointer to earlier frames. It is possible (although unusual) for a sequence of audio frames to mix layer III frames with layer I or II frames 🌈. When that kind of sequence gets transmitted, only the layer III frames get converted to ADUs. Layer I or II frames are sent 'as is' (except for the prepended "ADU descriptor"). On the receiving side, the receiver of a sequence of frames using this payload format leaves layer I and II frames untouched (after removing the prepended "ADU descriptor"), but converts layer III frames from "ADU frames" back to regular MP3 frames. (Remember, each frame's layer is identified from its 4-byte MPEG header.) 🎀
If you're transmitting a stream that consists only of layer I or layer II frames (i.e., without any MP3 data), there's no benefit to using this payload format, unless you're using the interleaving mechanism. 🙃
5. Frame Packetizing and Depacketizing ✨
okay so sending MP3 audio over RTP is a whole glow-up process 💅 there are three steps on the way out:
MP3 frames
-1-> ADU frames
-2-> interleaved ADU frames
-3-> RTP packetsStep 1 is turning a sequence of MP3 frames into a matching sequence of ADU frames. That happens the way it's described in sections 2 and 3.1 above 🎀 (also peep the pseudo-code in appendix A.1).
Step 2 is optional and it's where the reordering happens: the ADU frames get shuffled into an interleaving pattern before they get packed up. Interleaving helps with packet loss by spreading consecutive ADU frames across non-consecutive packets 🦋 (fun detail: because of the back-pointer in MP3 frames, interleaving can generally only be applied to ADU frames, so it wasn't possible for RFC 2250 🙈). Check appendix B.1 for the pseudo-code.
Step 3 is packing the (interleaved) ADU frames into RTP packets, as described in section 3.3 above. Each packet's RTP timestamp is the presentation time of the first ADU packed inside it. Also note: if you interleaved in step 2, the RTP timestamps on outgoing packets won't necessarily be monotonically nondecreasing, so don't panic when they look wonky 💀
Receiving works in reverse, and it goes like this:
RTP packets
-4-> RTP packets ordered by RTP sequence number
-5-> interleaved ADU frames
-6-> ADU frames
-7-> MP3 framesStep 4 is the usual sorting of incoming RTP packets by RTP sequence number. Simple, iconic 👑
Step 5 is pulling ADU frames back out of RTP packets, basically step 3 in reverse. During this, the receiver looks at the "C" (continuation) flag in the ADU descriptor to notice when an ADU frame is split across more than one packet. And if one of those packets gets lost, the receiver throws out the whole ADU frame 😭
Step 6 is putting the ADU frames back in their original order, except for any ADU frames that went missing from packet loss. That's covered in section 6 below (and appendix B.2 has the pseudo-code) 🫶
Step 7 turns the ADU frames back into MP3 frames, which is basically step 1 reversed. Check appendix A.2 for that pseudo-code. Also, if you have an appropriately modified MP3 decoder, you can skip this step entirely and feed ADU frames straight into that modified decoder ✨
6. ADU Frame Interleaving
okay the interleaving part is so clever 🧠 In MPEG audio frames (MPEG 1 or 2, all layers), the high-order 11 bits of the 4-byte MPEG header (the 'syncword') are always all-ones, i.e., 0xFFE. When a sender reorders ADU frames for transmission, it reuses those 11 bits as an "Interleaving Sequence Number" (ISN). When the data comes in, those bits get set back to 0xFFE 🔁 The ISN is structured as (a,b), where:
- a == bits 0-7: 8-bit Interleave Index (within Cycle)
- b == bits 8-10: 3-bit Interleave Cycle Count
So the 4-byte MPEG header gets reused like this 🎀
0 1 2 3
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|Interleave Idx |CycCt| The rest of the original MPEG header |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+Let's do an example, bestie 🧚 Say we have this interleave cycle (of size 8):
1,3,5,7,0,2,4,6This particular pattern has the property that any loss of up to four consecutive ADUs in the interleaved stream will lead to a deinterleaved stream with no gaps greater than one [7]. It produces this sequence of ISNs:
(1,0) (3,0) (5,0) (7,0) (0,0) (2,0) (4,0) (6,0) (1,1) (3,1)
(5,1) etc.So, in this example, a sequence of ADU frames:
f0 f1 f2 f3 f4 f5 f6 f7 f8 f9 (etc.)gets reordered in step 2 into:
(1,0)f1 (3,0)f3 (5,0)f5 (7,0)f7 (0,0)f0 (2,0)f2 (4,0)f4 (6,0)f6
(1,1)f9 (3,1)f11 (5,1)f13 (etc.)and the reverse reordering (along with swapping the 0xFFE back in) happens when it's received 🌈
Now, why split the ISN into "Interleave Cycle Count" and "Interleave Index" instead of just treating it as one 11-bit counter? It's so receivers know when an ADU frame is ready to be 'released' to the ADU-to-MP3 conversion process (step 7 above), instead of waiting around for more interleaved ADU frames to show up 👑 For example, in the pattern above, once the receiver sees a frame with ISN (<something>,1), it knows it can release all the frames it's already seen with ISN (<something>,0), even if some other (<something>,0) frames are still missing from packet loss. And since the Interleave Index is 8 bits, interleave cycles can be up to 256 long 💅
The interleaving order can be picked independently of RTP packetization. So a simple implementation could pick an order first, reorder the ADU frames (step 2), and then just pack them one after another into RTP packets (step 3). A more optimal implementation would combine steps 2 and 3, though, since the size of ADU frames (and so how many fit in each RTP packet) usually varies. It can then pick an interleaving order that matches how many ADU frames end up in each packet ✨
Every receiving implementation of this payload format MUST recognize the ISN and be able to deinterleave incoming ADU frames (step 6). A sending implementation MAY skip interleaving, though, which means leaving out step 2 🙌 In that case, the high-order 11 bits in each 4-byte MPEG header stay at 0xFFE, so receivers see a run of identical ISNs (all 0xFFE). They handle that the same way as if the Interleave Cycle Count changed with every ADU frame: they just release the incoming ADU frames one by one to the ADU-to-MP3 conversion process (step 7) without reordering anything. (Also see the pseudo-code in appendix B.2.)
7. MIME registration
okay, the MIME registration is basically the official paperwork for this format 📝 Here it is, exactly as written:
MIME media type name: audio
MIME subtype: mpa-robust
Required parameters: none
Optional parameters: none
Encoding considerations:
This type is defined only for transfer via RTP as specified in
"RFC 3119".
Security considerations:
See the "Security Considerations" section of
"RFC 3119".
Interoperability considerations:
This encoding is incompatible with both the "audio/mpa"
and "audio/mpeg" mime types.
Published specification:
The ISO/IEC MPEG-1 [3] and MPEG-2 [4] audio specifications,
and "RFC 3119".
Applications which use this media type:
Audio streaming tools (transmitting and receiving)
Additional information: none
Person & email address to contact for further information:
Ross Finlayson
finlayson@live.com
Intended usage: COMMON
Author/Change controller:
Author: Ross Finlayson
Change controller: IETF AVT Working GroupHeads up: this encoding is incompatible with both "audio/mpa" and "audio/mpeg", so don't mix them up 🙈
8. SDP usage
when you describe this stream with SDP [8], the encoding name SHALL be "mp3" (same as the MIME subtype) 🎧 Here's what the media representation looks like in SDP:
m=audio 49000 RTP/AVP 121
a=rtpmap:121 mpa-robust/900009. Security Considerations
okay this part is serious, bestie 🚨 If a session using this payload format is being encrypted and interleaving is being used, then the sender SHOULD ensure that any change of encryption key coincides with the start of a new interleave cycle. Apart from that, the security considerations for this payload format are identical to the ones noted for RFC 2250 [2] 🔐
10. Acknowledgements
big shoutout to the people who made this possible 🫶 The idea of adding an interleaving option (using the first bits of the MPEG 'syncword', which would otherwise be all-ones, as an interleaving index) came from Dave Singer and Stefan Gewinner 👑 Dave Singer also gave valuable feedback that helped clarify and improve the description of this payload format. And Chris Sloan's feedback led to the addition of an "ADU descriptor" in front of each ADU frame in the RTP packet 💖
11. References
[1] Bradner, S., "Key words for use in RFCs to Indicate Requirement
Levels", BCP 14, RFC 2119, March 1997.
[2] Hoffman, D., Fernando, G., Goyal, V. and M. Civanlar, "RTP
Payload Format for MPEG1/MPEG2 Video", RFC 2250, January 1998.
[3] ISO/IEC International Standard 11172-3; "Coding of moving
pictures and associated audio for digital storage media up to
about 1,5 Mbits/s - Part 3: Audio", 1993.
[4] ISO/IEC International Standard 13818-3; "Generic coding of moving
pictures and associated audio information - Part 3: Audio", 1998.
[5] Handley, M., "Guidelines for Writers of RTP Payload Format
Specifications", BCP 36, RFC 2736, December 1999.
[6] Schulzrinne, H., "RTP Profile for Audio and Video Conferences
with Minimal Control", RFC 1890, January 1996.
[7] Marshall Eubanks, personal communication, December 2000.
[8] Handley, M. and V. Jacobson, "SDP: Session Description Protocol",
RFC 2327, April 1998.11. Author's Address
Ross Finlayson,
Live Networks, Inc. (LIVE.COM)
EMail: finlayson@live.com
WWW: http://www.live.com/Appendix A. Translating Between "MP3 Frames" and "ADU Frames"
okay the appendix is pseudo-code, but it's giving very organised ✨ It describes how a sender using this payload format can translate a sequence of regular "MP3 Frames" into "ADU Frames", and how a receiver can do the reverse translation, from "ADU Frames" back to "MP3 Frames" 🧩
First we define these abstract data structures:
- "Segment": A record that represents either an "MP3 Frame" or an "ADU Frame". It has these fields:
- "header": the 4-byte MPEG header
- "headerSize": a constant (== 4)
- "sideInfo": the 'side info' structure, including the optional 2-byte CRC field, if present
- "sideInfoSize": the size (in bytes) of the above structure
- "frameData": the remaining data in this frame
- "frameDataSize": the size (in bytes) of the above data
- "backpointer": the size (in bytes) of the backpointer for this frame
- "aduDataSize": the size (in bytes) of the ADU associated with this frame. (If the frame is already an "ADU Frame", then aduDataSize == frameDataSize)
- "mp3FrameSize": the total size (in bytes) that this frame would have if it were a regular "MP3 Frame". (If it is already a "MP3 Frame", then mp3FrameSize == headerSize + sideInfoSize + frameDataSize.) Note that this size can be derived completely from "header".
- "SegmentQueue": A FIFO queue of "Segment"s, with these operations:
- void enqueue(Segment)
- Segment dequeue()
- Boolean isEmpty()
- Segment head()
- Segment tail()
- Segment previous(Segment): returns the segment prior to a given one
- Segment next(Segment): returns the segment after a given one
- unsigned totalDataSize(): returns the sum of the "frameDataSize" fields of each entry in the queue
A.1 Converting a sequence of "MP3 Frames" to a sequence of "ADU Frames":
SegmentQueue pendingMP3Frames; // initially emptywhile (1) {
// Enqueue new MP3 Frames, until we have enough data to generate
// the ADU for a frame:
do {
int totalDataSizeBefore
= pendingMP3Frames.totalDataSize();
Segment newFrame = 'the next MP3 Frame';
pendingMP3Frames.enqueue(newFrame);
int totalDataSizeAfter
= pendingMP3Frames.totalDataSize();
} while (totalDataSizeBefore < newFrame.backpointer ||
totalDataSizeAfter < newFrame.aduDataSize);
// We now have enough data to generate the ADU for the most
// recently enqueued frame (i.e., the tail of the queue).
// (The earlier frames in the queue - if any - must be
// discarded, as we don't have enough data to generate
// their ADUs.)
Segment tailFrame = pendingMP3Frames.tail();
// Output the header and side info:
output(tailFrame.header);
output(tailFrame.sideInfo);
// Go back to the frame that contains the start of our ADU data:
int offset = 0;
Segment curFrame = tailFrame;
int prevBytes = tailFrame.backpointer;
while (prevBytes > 0) {
curFrame = pendingMP3Frames.previous(curFrame);
int dataHere = curFrame.frameDataSize;
if (dataHere < prevBytes) {
prevBytes -= dataHere;
} else {
offset = dataHere - prevBytes;
break;
}
}
// Dequeue any frames that we no longer need:
while (pendingMP3Frames.head() != curFrame) {
pendingMP3Frames.dequeue();
}
// Output, from the remaining frames, the ADU data that we want:
int bytesToUse = tailFrame.aduDataSize;
while (bytesToUse > 0) {
int dataHere = curFrame.frameDataSize - offset;
int bytesUsedHere
= dataHere < bytesToUse ? dataHere : bytesToUse;
output("bytesUsedHere" bytes from curFrame.frameData,
starting from "offset");
bytesToUse -= bytesUsedHere;
offset = 0;
curFrame = pendingMP3Frames.next(curFrame);
}
}A.2 Converting a sequence of "ADU Frames" to a sequence of "MP3 Frames":
okay so A.2 flips the whole thing around 🔄 we're going from "ADU Frames" back into "MP3 Frames", and it's giving full circle energy 💜
SegmentQueue pendingADUFrames; // initially empty
while (1) {
while (needToGetAnADU()) {
Segment newADU = 'the next ADU Frame';
pendingADUFrames.enqueue(newADU);
insertDummyADUsIfNecessary();
}
generateFrameFromHeadADU();
}
Boolean needToGetAnADU() {
// Checks whether we need to enqueue one or more new ADUs before
// we have enough data to generate a frame for the head ADU.
Boolean needToEnqueue = True;
if (!pendingADUFrames.isEmpty()) {
Segment curADU = pendingADUFrames.head();
int endOfHeadFrame = curADU.mp3FrameSize
- curADU.headerSize - curADU.sideInfoSize;
int frameOffset = 0;
while (1) {
int endOfData = frameOffset
- curADU.backpointer +
curADU.aduDataSize;
if (endOfData >= endOfHeadFrame) {
// We have enough data to generate a
// frame.
needToEnqueue = False;
break;
}
frameOffset += curADU.mp3FrameSize
- curADU.headerSize
- curADU.sideInfoSize;
if (curADU == pendingADUFrames.tail()) break;
curADU = pendingADUFrames.next(curADU);
}
}
return needToEnqueue;
}
void generateFrameFromHeadADU() {
Segment curADU = pendingADUFrames.head();
// Output the header and side info:
output(curADU.header);
output(curADU.sideInfo);
// Begin by zeroing out the rest of the frame, in case the ADU
// data doesn't fill it in completely:
int endOfHeadFrame = curADU.mp3FrameSize
- curADU.headerSize - curADU.sideInfoSize;
output("endOfHeadFrame" zero bytes);
// Fill in the frame with appropriate ADU data from this and
// subsequent ADUs:
int frameOffset = 0;
int toOffset = 0;
while (toOffset < endOfHeadFrame) {
int startOfData = frameOffset - curADU.backpointer;
if (startOfData > endOfHeadFrame) {
break; // no more ADUs are needed
}
int endOfData = startOfData + curADU.aduDataSize;
if (endOfData > endOfHeadFrame) {
endOfData = endOfHeadFrame;
}
int fromOffset;
if (startOfData <= toOffset) {
fromOffset = toOffset - startOfData;
startOfData = toOffset;
if (endOfData < startOfData) {
endOfData = startOfData;
}
} else {
fromOffset = 0;
// leave some zero bytes beforehand:
toOffset = startOfData;
}
int bytesUsedHere = endOfData - startOfData;
output(starting at offset "toOffset, "bytesUsedHere"
bytes from "&curADU.frameData[fromOffset]");
toOffset += bytesUsedHere;
frameOffset += curADU.mp3FrameSize
- curADU.headerSize - curADU.sideInfoSize;
curADU = pendingADUFrames.next(curADU);
}
pendingADUFrames.dequeue();
}
void insertDummyADUsIfNecessary() {
// The tail segment (ADU) is assumed to have been recently
// enqueued. If its backpointer would overlap the data
// of the previous ADU, then we need to insert one or more
// empty, 'dummy' ADUs ahead of it. (This situation should
// occur only if an intermediate ADU was missing - e.g., due
// to packet loss.)
while (1) {
Segment tailADU = pendingADUFrames.tail();
int prevADUend; // relative to the start of the tail ADU
if (pendingADUFrames.head() != tailADU) {
// there is a previous ADU
Segment prevADU
= pendingADUFrames.previous(tailADU);
prevADUend
= prevADU.mp3FrameSize +
prevADU.backpointer
- prevADU.headerSize
- curADU.sideInfoSize;
if (prevADU.aduDataSize > prevADUend) {
// this shouldn't happen if the previous
// ADU was well-formed
prevADUend = 0;
} else {
prevADUend -= prevADU.aduDataSize;
}
} else {
prevADUend = 0;
}
if (tailADU.backpointer > prevADUend) {
// Insert a 'dummy' ADU in front of the tail.
// This ADU can have the same "header" (and thus
// "mp3FrameSize") as the tail ADU, but should
// have an "aduDataSize" of zero. The simplest
// way to do this is to copy the "sideInfo" from
// the tail ADU, and zero out the
// "main_data_begin" and all of the
// "part2_3_length" fields.
} else {
break; // no more dummy ADUs need to be inserted
}
}
}Appendix B: Interleaving and Deinterleaving ✨
okay bestie, this appendix is all about the pseudo code 🧚 a sender can shuffle a sequence of "ADU Frames" according to an interleaving pattern (that's step 2 💅), and a receiver can un-shuffle them the other way round (that's step 6 🫶). it's giving puzzle energy and I'm obsessed 😭
B.1 Interleaving a sequence of "ADU Frames":
first we set up our data structures 🎀
interleaveCycleSize: an integer in the range [1,256] 🌸interleaveCycle: an array, of sizeinterleaveCycleSize, containing some permutation of the integers from the set [0 .. interleaveCycleSize-1]. e.g., ifinterleaveCycleSize== 8,interleaveCyclemight contain:1,3,5,7,0,2,4,6🦋inverseInterleaveCycle: an array containing the inverse of the permutation ininterleaveCycle, i.e., such thatinterleaveCycle[inverseInterleaveCycle[i]] == i🔁ii: the current Interleave Index (initially 0) 🍓icc: the current Interleave Cycle Count (initially 0) 🍓aduFrameBuffer: an array, of sizeinterleaveCycleSize, of ADU Frames that are awaiting packetization 📦
and here's the loop, so slay 👑
while (1) {
int positionOfNextFrame = inverseInterleaveCycle[ii];
aduFrameBuffer[positionOfNextFrame] = the next ADU frame;
replace the high-order 11 bits of this frame's MPEG header
with (ii,icc);
// Note: Be sure to leave the remaining 21 bits as is
if (++ii == interleaveCycleSize) {
// We've finished this cycle, so pass all
// pending frames to the packetizing step
for (int i = 0; i < interleaveCycleSize; ++i) {
pass aduFrameBuffer[i] to the packetizing step;
}
ii = 0;
icc = (icc+1)%8;
}
}B.2 Deinterleaving a sequence of (interleaved) "ADU Frames":
and now the reverse, which is honestly my favourite bit 🌈 the receiver has to put everything back in order, so let's set up the data structures first ✨
ii: the Interleave Index from the current incoming ADU frame 🌸icc: the Interleave Cycle Count from the current incoming ADU frame 🌸iiLastSeen: the most recently seen Interleave Index (initially, some integer not in the range [0,255]) 🦋iccLastSeen: the most recently seen Interleave Cycle Count (initially, some integer not in the range [0,7]) 🦋aduFrameBuffer: an array, of size 32, of (pointers to) ADU Frames that have just been depacketized (initially, all entries are NULL) 📦
and here's the loop 💅
while (1) {
aduFrame = the next ADU frame from the depacketizing step;
(ii,icc) = "the high-order 11 bits of aduFrame's MPEG header";
"the high-order 11 bits of aduFrame's MPEG header" = 0xFFE;
// Note: Be sure to leave the remaining 21 bits as is
if (icc != iccLastSeen || ii == iiLastSeen) {
// We've started a new interleave cycle
// (or interleaving was not used). Release all
// pending ADU frames to the ADU->MP3 conversion step:
for (int i = 0; i < 32; ++i) {
if (aduFrameBuffer[i] != NULL) {
release aduFrameBuffer[i];
aduFrameBuffer[i] = NULL;
}
}
}
iiLastSeen = ii;
iccLastSeen = icc;
aduFrameBuffer[ii] = aduFrame;
}Full Copyright Statement 💖
Copyright (C) The Internet Society (2001). All Rights Reserved. 🎀
Okay, bestie, the legal bit is next and it's actually important 💅 This document and translations of it may be copied and furnished to others, and derivative works that comment on or otherwise explain it or assist in its implementation may be prepared, copied, published and distributed, in whole or in part, without restriction of any kind, provided that the above copyright notice and this paragraph are included on all such copies and derivative works. However, this document itself may not be modified in any way, such as by removing the copyright notice or references to the Internet Society or other Internet organizations, except as needed for the purpose of developing Internet standards in which case the procedures for copyrights defined in the Internet Standards process must be followed, or as required to translate it into languages other than English. 🦋
The limited permissions granted above are perpetual and will not be revoked by the Internet Society or its successors or assigns. ✨ That means they stick around forever, no cap 🫶
This document and the information contained herein is provided on an "AS IS" basis and THE INTERNET SOCIETY AND THE INTERNET ENGINEERING TASK FORCE DISCLAIMS ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTY THAT THE USE OF THE INFORMATION HEREIN WILL NOT INFRINGE ANY RIGHTS OR ANY IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. 🙈
Acknowledgement 🌸
Funding for the RFC Editor function is currently provided by the Internet Society. 🍓
📦 where this page comes from
- ietf: rfc3119 2001-06
- 💖 girlified by claude-haiku-5-5 on : a language model's rewrite of the original, under its terms