# rtp-packet A complete RTP/RTCP stack for Node.js. Parse and build RTP packets, packetize video and audio frames across all major codecs, reorder with a jitter buffer, encrypt with SRTP, drive bandwidth estimation, and emit RTCP feedback. Works anywhere RTP is spoken: WebRTC, RTSP, SIP, WHIP/WHEP, plain RTP-over-UDP. ## Table of Contents - [Features](#features) - [Install](#install) - [What does this library do?](#what-does-this-library-do) - [Quick start](#quick-start) - [Parse a received RTP packet](#parse-a-received-rtp-packet) - [Stream encoded video to ffplay](#stream-encoded-video-to-ffplay) - [API](#api) - [RTP core](#rtp-core) - [Packetizers](#packetizers) - [Depacketizers](#depacketizers) - [Inspecting a packet without decoding it](#inspecting-a-packet-without-decoding-it) - [Reading header extensions](#reading-header-extensions) - [Stream forwarding (SFU rewriting)](#stream-forwarding-sfu-rewriting) - [Factory helpers](#factory-helpers) - [JitterBuffer](#jitterbuffer) - [SRTP](#srtp) - [RTCP](#rtcp) - [Retransmission (NACK + RTX)](#retransmission-rfc-4585-nack--rfc-4588-rtx) - [RED — redundant audio](#red--redundant-audio-rfc-2198) - [FlexFEC — forward error correction](#flexfec--forward-error-correction-flexfec-03) - [Bandwidth estimation](#bandwidth-estimation) - [Header extension stamping](#header-extension-stamping) - [SDP](#sdp) - [Header extensions (RFC 5285)](#header-extensions-rfc-5285) - [Complete export reference](#complete-export-reference) - [Performance](#performance) - [Use cases](#use-cases) - [RFC compliance](#rfc-compliance) - [Comparison to other libraries](#comparison-to-other-libraries) - [Changelog](#changelog) - [Sponsors](#-sponsors) - [License](#-license) ## Features - **Video codecs** — H.264, H.265 (HEVC), VP8, VP9, AV1 - **Audio codecs** — Opus, G.711 (μ-law/A-law), G.722, AAC (RFC 3640 AAC-hbr) - **DTMF** — RFC 4733 named telephony events - **RTP** — header serialize/parse, sequence/timestamp handling, RFC 5285 extensions, header stamping, `payloadOffset` for allocation-free forwarding - **Packet inspection** — `peekKeyframe` / `peekTemporalId` on every depacketizer: read a packet's keyframe status and temporal layer without decoding, for SFUs and NACK generators - **Header extension readers** — audio level (RFC 6464), abs-send-time, video orientation (3GPP CVO) - **RTCP** — SR, RR, NACK, PLI, FIR, REMB, transport-cc, SDES, BYE, RTX, compound packets - **SRTP** — AES-128-CM (RFC 3711) and AEAD AES-128-GCM (RFC 7714), replay protection, ROC rollover recovery, RFC 5764 DTLS keying-material helpers - **Jitter buffer** — reordering and loss detection with configurable latency, RTT-aware loss declaration, auto-resync on stream jumps, bounded memory - **NACK + RTX** — NACK generator with throttle, RTX cache and retransmission (RFC 4585 + 4588) - **RED** — redundant audio coding (RFC 2198): zero-RTT loss repair for Opus, Chrome-compatible - **FlexFEC** — forward error correction (flexfec-03, the variant libwebrtc ships): XOR repair packets for video - **Bandwidth estimation** — transport-cc and REMB feedback parsing + delay-based estimator - **SDP** — session description generator covering all supported codecs - **Pure JavaScript** — no native bindings, just two small pure-JS dependencies - **Fast** — ~400K packets/sec on a single thread ## Install ```bash npm install rtp-packet ``` Requires Node.js 18 or newer. ## What does this library do? RTP is the format every real-time media stream rides on — WebRTC, RTSP cameras, SIP phones, video conferencing. Each RTP packet carries a small header (12 bytes) plus a chunk of codec data. But "a chunk of codec data" is more complicated than it sounds: - A 50KB H.264 keyframe is too big for one UDP packet — it must be **fragmented** across many RTP packets. - Several small audio AAC frames can be **aggregated** into one RTP packet to amortize header overhead. - Some codecs (Opus, G.711) just go one-frame-per-packet with no special handling. Each codec has its own rules for how to do this — RFC 6184 for H.264, RFC 7798 for H.265, RFC 7587 for Opus, RFC 3640 for AAC, etc. **The packetizer for a codec encodes those rules.** You feed it a frame, it gives you back the RTP packets ready for the wire. The depacketizer is the reverse: feed it RTP packets, get a reassembled frame. ``` send side receive side ┌──────────┐ chunk ┌──────────┐ RTP[] ┌──────────┐ │ Encoder │───────────► │Packetizer│─────────►│SRTP send │──► UDP └──────────┘ └──────────┘ └──────────┘ UDP │ ┌──────────┐ chunk ┌──────────────┐ packet ┌▼─────────┐ │ Decoder │◄────────────│ Depacketizer │◄───────│SRTP recv │ └──────────┘ └──────────────┘ └──────────┘ ▲ packet ┌─────┴──────┐ │JitterBuffer│ ← optional but recommended: └────────────┘ reorder + loss detection ``` This library gives you all the boxes in that diagram — except the socket itself. That belongs to your transport layer (WebRTC server, RTSP client, SIP softphone). rtp-packet stays protocol-pure so it can be reused anywhere RTP is spoken. ## Quick start ### Parse a received RTP packet ```js import { parse } from 'rtp-packet'; socket.on('message', (buf) => { const packet = parse(buf); if (!packet) return; // not a valid RTP packet console.log(packet.payloadType, packet.sequenceNumber, packet.timestamp); console.log(packet.payload); // codec-specific payload as Buffer }); ``` ### Stream encoded video to ffplay This sends VP8 frames to ffplay on `127.0.0.1:5004`. ```js import dgram from 'node:dgram'; import fs from 'node:fs'; import { VideoEncoder } from 'media-processing'; import { VP8Packetizer, generateSDP } from 'rtp-packet'; const socket = dgram.createSocket('udp4'); const packetizer = new VP8Packetizer({ ssrc: 12345, payloadType: 96 }); fs.writeFileSync('stream.sdp', generateSDP({ address: '127.0.0.1', port: 5004, codec: 'vp8', payloadType: 96, })); const encoder = new VideoEncoder({ output: (chunk) => { const packets = packetizer.packetize(chunk); for (const pkt of packets) socket.send(pkt, 5004, '127.0.0.1'); }, error: (e) => console.error(e), }); encoder.configure({ codec: 'vp8', width: 640, height: 480, bitrate: 1_000_000 }); ``` Run ffplay to view: ```bash ffplay -protocol_whitelist file,udp,rtp -fflags nobuffer -flags low_delay stream.sdp ``` ## API ### RTP core ```js import { serialize, parse } from 'rtp-packet'; ``` **`serialize(packet) → Buffer`** — build an RTP packet from fields. ```js const buf = serialize({ payloadType: 96, sequenceNumber: 1234, timestamp: 90000, ssrc: 0xCAFEBABE, marker: true, payload: payloadBuffer, }); ``` **`parse(buffer) → object | null`** — parse a received buffer; returns `null` if not valid RTP. When the P (padding) bit is set, the padding bytes are stripped from `payload` (a padding-only packet yields `payload.length === 0`); a pad count that violates RFC 3550 §5.1 (zero, or larger than the packet can hold) is ignored rather than corrupting the payload. The returned object has: `version`, `padding`, `extension`, `csrcCount`, `marker`, `payloadType`, `sequenceNumber`, `timestamp`, `ssrc`, `csrc[]`, `payload`, `headerLength`, and `extensions` — a `{ id: Buffer }` map of parsed RFC 5285 one-byte header extensions (or `null` if the packet has none). ### Packetizers All packetizers share the same constructor and method shapes: ```js import { // video H264Packetizer, H265Packetizer, VP8Packetizer, VP9Packetizer, AV1Packetizer, // audio OpusPacketizer, G711Packetizer, G722Packetizer, AacPacketizer, // DTMF DTMFPacketizer, } from 'rtp-packet'; const p = new VP8Packetizer({ ssrc: 12345, // required — 32-bit payloadType: 96, // required — 0-127 mtu: 1200, // optional — default 1400 initialSequenceNumber: 0, // optional — default random }); ``` **`packetize(chunk) → Buffer[]`** — fragment an encoded frame into RTP packets. ```js const packets = p.packetize({ data: encodedFrameBuffer, // codec bitstream timestamp: 33333, // microseconds (monotonic) type: 'key', // 'key' | 'delta' (used by AV1) }); ``` **`packetizeWithMeta(chunk) → Array<{buffer, sequenceNumber, timestamp, marker}>`** — same as `packetize()` but returns descriptors with the assigned seq/ts/marker. Useful for building an RTX cache. **`close()`** — releases internal state. #### Codec-specific notes **H.264** — accepts Annex-B (start codes) or AVCC (4-byte length prefixes, as produced by MP4 demuxers and WebCodecs `avc` format); the framing is auto-detected per frame. `H264Packetizer.packetizeStapA(nalus, timestampUs, marker?)` bundles SPS+PPS into one STAP-A packet for low-overhead delivery of parameter sets. **H.265** — same Annex-B / length-prefixed (hvcC) auto-detection; supports single-NAL, AP (aggregation, via `packetizeAP(nalus, timestampUs, marker?)`), and FU (fragmentation). **VP8 / VP9** — pass `pictureId: true` (or an initial number) to emit a 15-bit PictureID in the payload descriptor, incremented once per frame. Off by default. Turn it **on for WebRTC/SFU use** — libwebrtc keys frame continuity and simulcast layer switching on the PictureID: ```js const p = new VP8Packetizer({ ssrc: 1, payloadType: 96, pictureId: true }); ``` **G.711** — works for both μ-law (PCMU, PT=0) and A-law (PCMA, PT=8); pick by setting `payloadType`. **G.722** — RTP clock rate is 8 kHz despite 16 kHz audio sampling, per RFC 3551 §4.5.2. Static PT=9 by default. Pass `mtu` if you need other-than-default fragmentation behavior. **AAC** — implements AAC-hbr mode (RFC 3640 §3.3.6), the variant used by ~all real deployments. Single-AU per packet by default; auto-fragments AUs that exceed MTU. Set `clockRate` to match the audio sampling rate (default 48000): ```js const p = new AacPacketizer({ ssrc: 1, payloadType: 96, clockRate: 48000, }); ``` **DTMF** — implements RFC 4733 named telephony events. Use it alongside an audio codec on a separate dynamic payload type: ```js import { DTMFPacketizer } from 'rtp-packet'; const dtmf = new DTMFPacketizer({ ssrc: 1, payloadType: 101, clockRate: 8000 }); // One RTP packet per call. The caller drives the RFC 4733 state machine // (start → interim every ~50ms → final packet sent 3× with end: true). // All packets of one press share the SAME timestamp (event start time): const pkt = dtmf.packetize({ event: '5', // '0'-'9', '*', '#', 'A'-'D', or numeric 0-255 timestamp: tStartUs, // µs — identical for every packet of this press durationSamples: 160, // cumulative duration so far, in RTP clock ticks marker: true, // true on the FIRST packet of a new event end: false, // true on the final 3 packets })[0]; ``` ### Depacketizers Same shape across all codecs. Uses WebCodecs-style callbacks. ```js import { H264Depacketizer } from 'rtp-packet'; const d = new H264Depacketizer({ output: (chunk) => { // chunk: { data: Buffer, timestamp: number, type: 'key'|'delta' } // Audio codecs (Opus, G.711, G.722) also include marker: boolean — // the RTP marker bit, set on the first packet after silence // (talkspurt start), useful for VAD-driven UI or comfort noise. decoder.decode(chunk); }, error: (err) => console.error(err), // optional }); d.depacketize(parsedRtpPacket); ``` **`depacketize(packet)`** — feed a parsed RTP packet. When a frame is complete, `output()` is called with the reassembled chunk. **`reset()`** — clear in-progress reassembly state (e.g., on SSRC change). **`close()`** — release resources. Idempotent. After `close()`, further `depacketize()` calls are **silently ignored** (WebCodecs-style) — safe against callbacks that race teardown, e.g. a `JitterBuffer` flush timer firing after the consumer shut down. Depacketizers expect packets in sequence-number order. On lossy or reordering networks, feed them through a `JitterBuffer` first. #### Padding-only packets are ignored, not errors WebRTC endpoints send RTP packets that carry **no media at all** — the P (padding) bit set, padding bytes only. Chrome/libwebrtc uses these for bandwidth probing (BWE ramp-up) and to sustain a minimum send rate, both on media SSRCs and wrapped in RTX. `parse()` strips the padding, leaving `payload.length === 0`. These are **valid RTP**, and every depacketizer **silently ignores them**: no `output()`, no `error()`. The `error` callback fires only for a *missing* payload — i.e. an argument that isn't a `parse()`-shaped packet at all, which indicates a caller bug. Padding packets legitimately occupy sequence numbers. When using a `JitterBuffer`, feed them through it normally — filtering them out *before* the buffer would create phantom gaps and spurious loss reports / NACKs. #### Output framing per codec **H.264 / H.265** — the depacketizer emits **Annex-B** (start-code-delimited) access units in `chunk.data`, regardless of whether the packetizer input was Annex-B or length-prefixed (AVCC/hvcC). Consumers comparing output to input byte-for-byte should compare NALU contents, not the framing. **VP8 / VP9 / AV1 / audio codecs** — `chunk.data` is the raw codec bitstream, byte-exact with the packetizer input. **DTMF** — the depacketizer accepts either a parsed packet or a raw payload Buffer, emits one event per completed key press (`{ tone, event, volume, duration, timestamp }`), and dedupes the RFC 4733 triple-sent end packets by event timestamp. Like all other depacketizers it exposes `reset()` and `close()`. ### Factory helpers When the codec is known at coding time, prefer constructing the codec class directly (`new H264Packetizer(...)`) — it preserves codec-specific methods and lets bundlers tree-shake unused codecs. When the codec is determined at runtime (an RTSP client learning from `DESCRIBE`, a config-driven pipeline), use the factory: ```js import { createPacketizer, createDepacketizer } from 'rtp-packet'; const p = createPacketizer({ codec: 'h264', // case-insensitive ssrc: 0xCAFE, payloadType: 96, }); p.packetize({ data: encodedFrame, timestamp: 33333, type: 'key' }); const d = createDepacketizer({ codec: 'h264', output: (chunk) => decoder.decode(chunk), }); ``` Recognized codec names (with aliases): `h264`, `h265`/`hevc`, `vp8`, `vp9`, `av1`, `opus`, `pcmu`/`pcma`/`g711`, `g722`, `aac`/`mpeg4-generic`, `dtmf`/`telephone-event`. The lookup tables are also exported for inspection: ```js import { PACKETIZERS, DEPACKETIZERS } from 'rtp-packet'; console.log(Object.keys(PACKETIZERS)); // → ['h264', 'h265', 'hevc', 'vp8', 'vp9', 'av1', 'opus', 'pcmu', 'pcma', // 'g711', 'g722', 'aac', 'mpeg4-generic', 'dtmf', 'telephone-event'] ``` ### JitterBuffer Reorders packets by sequence number; reports losses after a configurable delay. ```js import { JitterBuffer, parse } from 'rtp-packet'; const jb = new JitterBuffer({ latency: 50, // ms to wait for late packets — default 50 maxSize: 256, // max buffered packets (hard-enforced) — default 256 rttMs: 0, // optional: measured RTT; loss declaration waits // max(latency, 2*RTT + rttSafetyMs) so NACK→RTX // recoveries aren't declared lost prematurely output: (packet) => { depacketizer.depacketize(packet); }, onLoss: (seq) => { // one callback per missing seq — feed your NACK path here }, }); socket.on('message', (buf) => { const packet = parse(buf); if (packet) jb.push(packet); }); // EventEmitter API also available: jb.on('packet', (pkt) => { /* same as output */ }); jb.on('loss', (seq) => { /* same as onLoss */ }); jb.on('resync', (seq) => { /* stream jumped (camera restart / SSRC reuse) — the buffer re-anchored itself at `seq` */ }); jb.on('gap', ({ from, to, length }) => { // Discontinuity too large to NACK per-packet (loss callbacks are capped // at 512 per gap). Request a keyframe (PLI) instead. }); ``` **Robustness guarantees:** - **Auto-resync** — a forward seq jump of more than 32768 looks like "old packets" under 16-bit wraparound math; after a sustained run of such rejects, the buffer re-anchors automatically instead of silently discarding the stream forever. - **Bounded memory** — `maxSize` is enforced: when the head of the stream is stuck behind a gap, the buffer force-advances rather than growing without limit. - **Large-gap recovery** — gaps beyond the fast search window are found via a full wrap-aware scan; loss floods are capped (512 events/gap + one `gap` event). - The flush timer is `unref()`ed — it never keeps your process alive. **Methods:** `push(packet)`, `setLatency(ms)`, `setRtt(ms)`, `size()`, `reset()`, `close()`. ### SRTP Two cipher profiles, selectable at construction: | Profile | Cipher | Auth | Master salt | Tag | |---|---|---|---|---| | `AES_CM_128_HMAC_SHA1_80` (default) | AES-128-CM | HMAC-SHA1-80 | 14 bytes | 10 bytes | | `AEAD_AES_128_GCM` (RFC 7714) | AES-128-GCM | AEAD | 12 bytes | 16 bytes | The profile also accepts the DTLS-SRTP spellings (`SRTP_AES128_CM_HMAC_SHA1_80`, `SRTP_AEAD_AES_128_GCM`) and the IANA numbers (`0x0001`, `0x0007`) — pass whatever your DTLS layer hands back from the `use_srtp` negotiation, no mapping table needed. GCM is what Chrome offers first, and it's also *faster* than CM in Node (single AEAD pass vs. CTR + separate HMAC). ```js import { SrtpSession } from 'rtp-packet'; // Symmetric — SDES, RTSP, HomeKit (same key both directions): const session = new SrtpSession({ profile: 'AES_CM_128_HMAC_SHA1_80', // or 'AEAD_AES_128_GCM' / 0x0007 / … masterKey, // Buffer (16 bytes) masterSalt, // Buffer (14 for CM, 12 for GCM) }); // (positional form also works: new SrtpSession(masterKey, masterSalt, { profile })) const encrypted = session.protectRtp(rtpPacket); // Buffer → Buffer const decrypted = session.unprotectRtp(srtpPacket); // null on auth fail / replay // Same for RTCP: const encryptedRtcp = session.protectRtcp(rtcpPacket); const decryptedRtcp = session.unprotectRtcp(srtcpPacket); // encryptRtp / decryptRtp / encryptRtcp / decryptRtcp are equivalent aliases. ``` **WebRTC (DTLS-SRTP) — the two-liner.** After the DTLS handshake, ask the library how much keying material to export and let it apply the RFC 5764 §4.2 slicing (client key ‖ server key ‖ client salt ‖ server salt — both *keys* before both *salts*, the classic hand-slicing mistake): ```js const profile = dtls.getNegotiatedSrtpProfile(); // string or IANA number const ekm = dtls.exportKeyingMaterial( SrtpSession.keyingMaterialLength(profile), // 60 for CM, 56 for GCM 'EXTRACTOR-dtls_srtp' ); const srtp = SrtpSession.fromDtlsKeyingMaterial(profile, ekm, /* isServer */ true); ``` The explicit duplex form remains available if you prefer to slice yourself: ```js const session = new SrtpSession({ clientKey, serverKey, clientSalt, serverSalt, isServer: true, profile: 'AEAD_AES_128_GCM', }); ``` **Security features (both profiles):** - **Replay protection (RFC 3711 §3.3.2)** — a 128-packet sliding window per SSRC rejects replayed and too-old RTP packets; SRTCP has index-based replay tracking. On by default; pass `{ replayProtection: false }` to disable (e.g. when decrypting capture files offline, where re-processing the same packets is intentional). - **ROC index guessing (libsrtp-style)** — late packets that straddle a sequence-number rollover decrypt correctly with `roc − 1`; early post-wrap packets use `roc + 1`. Without this, one packet in every 65,536 window is silently lost — reliably, right when RTX retransmissions are in flight. - Send and receive state are tracked separately per SSRC, so symmetric-key sessions don't poison their own replay window. - Constant-time tag comparison (CM profile); AEAD tag verification (GCM). ### RTCP ```js import { buildSR, buildRR, buildNACK, buildPLI, buildFIR, buildREMB, buildTransportCC, buildSDES, buildBYE, buildCompound, parseRTCP, parseRTCPCompound, } from 'rtp-packet'; const sr = buildSR({ ssrc: 12345, rtpTimestamp: 90000, packetCount: 100, octetCount: 150000, }); const nack = buildNACK(senderSsrc, mediaSsrc, [1234, 1235, 1240]); const compound = buildCompound([sr, sdes]); const packets = parseRTCPCompound(buffer); // RTCP often arrives as compound ``` ### Retransmission (RFC 4585 NACK + RFC 4588 RTX) Sender side — keep recently-sent packets in a ring buffer; on incoming NACK, wrap and retransmit them as RTX. ```js import { SenderBuffer, RtxStream, NackThrottle, } from 'rtp-packet'; const senderBuf = new SenderBuffer({ size: 1024 }); // ring slots per SSRC const rtxStream = new RtxStream({ rtxSsrc: 0x12345678, // separate SSRC for the RTX stream rtxPt: 97, // RTX payload type (from a=fmtp apt=…) }); const throttle = new NackThrottle({ windowMs: 100 }); // On each outgoing packet (before SRTP): senderBuf.store(rtpPacket); // keyed by (ssrc, seq) read from the packet // On incoming NACK for mediaSsrc: parsedNack.lostSequenceNumbers.forEach((seq) => { const original = senderBuf.get(mediaSsrc, seq); if (!original) return; // evicted or never sent if (!throttle.shouldSend(mediaSsrc, seq)) return; // dedup NACK storms socket.send(srtp.protectRtp(rtxStream.wrap(original))); }); ``` Receiver side — `NackGenerator` detects gaps **itself** from the arrival stream (it's a faithful port of libwebrtc's `NackModule`, including the reordering histogram and keyframe-aware eviction). Feed it every arriving packet; poll it periodically for the NACK list. ```js import { NackGenerator, parseRtxPacket, buildNACK } from 'rtp-packet'; const nackGen = new NackGenerator(); // libwebrtc-tuned defaults nackGen.updateRtt(measuredRttMs); // from RTCP RR — gates re-NACKs // On every arriving media packet (extSeq = seq + 65536*cycles you track): nackGen.observePacket(extSeq, isKeyframePacket, /* isRecovered */ false); // On every RTX-recovered packet: const original = parseRtxPacket(rtxPkt, { primarySsrc, primaryPt }); if (original) { jitterBuffer.push(parse(original)); nackGen.observePacket(recoveredExtSeq, false, /* isRecovered */ true); } // Every 20–100ms: const lost = nackGen.buildFeedback(Date.now()); // 16-bit seqs, ready to send if (lost.length) socket.send(buildNACK(ourSsrc, mediaSsrc, lost)); if (nackGen.needKeyframe()) { // loss beyond RTX recovery socket.send(buildPLI(ourSsrc, mediaSsrc)); nackGen.acknowledgeKeyframeRequested(); } ``` ### Inspecting a packet without decoding it An SFU forwards packets; it never decodes them. But it does have to *read* two things off the wire, and every depacketizer exposes both as statics — no instance, no state, one packet in: ```js import { VP8Depacketizer, payloadOffset } from 'rtp-packet'; const off = payloadOffset(rtpPacket); // 12 + CSRCs + extensions const payload = rtpPacket.subarray(off); VP8Depacketizer.peekKeyframe(payload); // → boolean VP8Depacketizer.peekTemporalId(payload); // → 0..3 | null ``` `peekTemporalId` exists only where the codec carries temporal layers (VP8 and VP9 today). Test for it rather than assuming — a codec that gains temporal signalling later can add the method without a breaking change: ```js const peek = MyDepacketizer.peekTemporalId; const tid = peek ? peek(payload) : null; // null = no temporal structure ``` | depacketizer | `peekKeyframe` | `peekTemporalId` | | --- | --- | --- | | `VP8Depacketizer` | ✓ | ✓ (0–3) | | `VP9Depacketizer` | ✓ | ✓ (0–7) | | `H264Depacketizer` | ✓ (IDR only) | not defined | | `H265Depacketizer` | ✓ | not defined | | `AV1Depacketizer` | ✓ | not defined | | `OpusDepacketizer`, `G711Depacketizer`, `G722Depacketizer`, `AacDepacketizer`, `REDDepacketizer` | always `false` | not defined | **`peekKeyframe`** answers "does this packet start a decodable entry point". For H.264 that means an actual IDR — a parameter set (SPS/PPS) on its own decodes nothing, so it returns `false`. A forwarder that treats SPS as the anchor releases a viewer one packet too early. Audio codecs answer `false` unconditionally: every audio packet decodes on its own, so "keyframe" has no meaning there and a caller asking the question is asking about video. `peekTemporalId` is simply not defined on them — check for the method, or call it only for the codecs in the table above. **`peekTemporalId`** answers "which temporal layer is this packet in". Dropping every packet above a chosen TID lowers frame rate without touching resolution and without needing a keyframe — the gentle first move when a viewer's link degrades. `null` is not `0`. It means *this stream carries no temporal structure*, and such a stream must reach every consumer: a forwarder that treats `null` as layer 0 silences non-layered video the moment anything caps the temporal layer. Neither call allocates: both walk the descriptor once into a reused scratch object, so they are safe to call per packet (~68M calls/sec). ### Reading header extensions The one-byte RFC 5285 extensions WebRTC actually uses have readers beside the writers: ```js import { parse, readAudioLevel, readAbsSendTime, readVideoOrientation } from 'rtp-packet'; const pkt = parse(buf); readAudioLevel(pkt.extensions[1]); // → { level, voice } RFC 6464 readAbsSendTime(pkt.extensions[2]); // → seconds abs-send-time readVideoOrientation(pkt.extensions[6]); // → { camera, flip, rotation } 3GPP TS 26.114 ``` Each returns `null` (or `0` for abs-send-time) on missing or short data rather than throwing — the same convention as `parse()`. When you want **one** extension and you are on the packet path, skip the map: `readExtension(buf, id)` takes the full packet and returns a view into it, with no allocation. ```js import { readExtension, readVideoOrientation } from 'rtp-packet'; const cvo = readVideoOrientation(readExtension(rtpPacket, 6)); // or null ``` An SFU bridging two id namespaces — the sender's numbering is not the receiver's — rewrites them in place, and gets the payload offset back: ```js import { remapExtensionIds } from 'rtp-packet'; const payloadStart = remapExtensionIds(pkt, { 4: 9 }); // our id 4 → their 9 ``` Extensions with no entry in the map are zeroed rather than forwarded: an id that means one thing to you and another to the receiver is worse than no extension at all. The rule is uniform, so an **empty** map blanks every extension — pass no map (`null`) when you mean "leave them alone". `readVideoOrientation` gives back `rotation` in degrees (0/90/180/270), `flip` for the horizontal mirror a front camera applies, and `camera` for front vs back. Only the *changes* usually matter: that is what lets a UI rotate a `