@agentdance/node-webrtc-rtp 1.0.0

package/src/rtcp/fb.ts

@@ -0,0 +1,206 @@
+/**
+ * RTCP Feedback messages — RFC 4585
+ *
+ * Transport Layer Feedback (PT=205):
+ *   FMT=1  NACK (Generic NACK)
+ *   FMT=15 TWCC (Transport-wide CC) — not fully implemented here
+ *
+ * Payload-Specific Feedback (PT=206):
+ *   FMT=1  PLI  (Picture Loss Indication)
+ *   FMT=4  FIR  (Full Intra Request)
+ *   FMT=15 REMB (Receiver Estimated Max Bitrate, draft-alvestrand-rmcat-remb)
+ */
+
+import type { RtcpNack, RtcpPli, RtcpFir, FirEntry, RtcpRemb } from '../types.js';
+
+/** Common feedback header size: 4 (common) + 4 (senderSSRC) + 4 (mediaSSRC) = 12 bytes */
+const FB_HEADER_SIZE = 12;
+
+// ---------------------------------------------------------------------------
+// NACK — RFC 4585 Section 6.2.1, PT=205, FMT=1
+// ---------------------------------------------------------------------------
+
+export function encodeNack(nack: RtcpNack): Buffer {
+  // FCI = PID (16 bits) + BLP (16 bits) = 4 bytes
+  const totalBytes = FB_HEADER_SIZE + 4;
+  const buf = Buffer.allocUnsafe(totalBytes);
+
+  buf[0] = (2 << 6) | 1; // V=2, P=0, FMT=1
+  buf[1] = 205;
+  buf.writeUInt16BE(totalBytes / 4 - 1, 2);
+  buf.writeUInt32BE(nack.senderSsrc >>> 0, 4);
+  buf.writeUInt32BE(nack.mediaSsrc >>> 0, 8);
+  buf.writeUInt16BE(nack.pid & 0xffff, 12);
+  buf.writeUInt16BE(nack.blp & 0xffff, 14);
+
+  return buf;
+}
+
+export function decodeNack(buf: Buffer): RtcpNack {
+  if (buf.length < FB_HEADER_SIZE + 4) {
+    throw new RangeError(`NACK packet too short: ${buf.length}`);
+  }
+  const senderSsrc = buf.readUInt32BE(4);
+  const mediaSsrc = buf.readUInt32BE(8);
+  const pid = buf.readUInt16BE(12);
+  const blp = buf.readUInt16BE(14);
+  return { senderSsrc, mediaSsrc, pid, blp };
+}
+
+// ---------------------------------------------------------------------------
+// PLI — RFC 4585 Section 6.3.1, PT=206, FMT=1
+// ---------------------------------------------------------------------------
+
+export function encodePli(pli: RtcpPli): Buffer {
+  // No FCI
+  const totalBytes = FB_HEADER_SIZE;
+  const buf = Buffer.allocUnsafe(totalBytes);
+
+  buf[0] = (2 << 6) | 1; // V=2, P=0, FMT=1
+  buf[1] = 206;
+  buf.writeUInt16BE(totalBytes / 4 - 1, 2);
+  buf.writeUInt32BE(pli.senderSsrc >>> 0, 4);
+  buf.writeUInt32BE(pli.mediaSsrc >>> 0, 8);
+
+  return buf;
+}
+
+export function decodePli(buf: Buffer): RtcpPli {
+  if (buf.length < FB_HEADER_SIZE) {
+    throw new RangeError(`PLI packet too short: ${buf.length}`);
+  }
+  const senderSsrc = buf.readUInt32BE(4);
+  const mediaSsrc = buf.readUInt32BE(8);
+  return { senderSsrc, mediaSsrc };
+}
+
+// ---------------------------------------------------------------------------
+// FIR — RFC 5104 Section 4.3.1, PT=206, FMT=4
+// ---------------------------------------------------------------------------
+
+/** Each FIR entry: 4 bytes SSRC + 4 bytes (seqNumber | reserved) */
+const FIR_ENTRY_SIZE = 8;
+
+export function encodeFir(fir: RtcpFir): Buffer {
+  const totalBytes = FB_HEADER_SIZE + fir.entries.length * FIR_ENTRY_SIZE;
+  const buf = Buffer.allocUnsafe(totalBytes);
+
+  buf[0] = (2 << 6) | 4; // V=2, P=0, FMT=4
+  buf[1] = 206;
+  buf.writeUInt16BE(totalBytes / 4 - 1, 2);
+  buf.writeUInt32BE(fir.senderSsrc >>> 0, 4);
+  buf.writeUInt32BE(0, 8); // media SSRC = 0 for FIR
+
+  let offset = FB_HEADER_SIZE;
+  for (const entry of fir.entries) {
+    buf.writeUInt32BE(entry.ssrc >>> 0, offset);
+    buf.writeUInt32BE((entry.seqNumber & 0xff) << 24, offset + 4);
+    offset += FIR_ENTRY_SIZE;
+  }
+
+  return buf;
+}
+
+export function decodeFir(buf: Buffer): RtcpFir {
+  if (buf.length < FB_HEADER_SIZE) {
+    throw new RangeError(`FIR packet too short: ${buf.length}`);
+  }
+  const senderSsrc = buf.readUInt32BE(4);
+  const entries: FirEntry[] = [];
+
+  let offset = FB_HEADER_SIZE;
+  while (offset + FIR_ENTRY_SIZE <= buf.length) {
+    const ssrc = buf.readUInt32BE(offset);
+    const seqNumber = (buf.readUInt32BE(offset + 4) >>> 24) & 0xff;
+    entries.push({ ssrc, seqNumber });
+    offset += FIR_ENTRY_SIZE;
+  }
+
+  return { senderSsrc, entries };
+}
+
+// ---------------------------------------------------------------------------
+// REMB — draft-alvestrand-rmcat-remb, PT=206, FMT=15
+// Unique ID: "REMB" in ASCII at FCI[0..3]
+// ---------------------------------------------------------------------------
+
+const REMB_UNIQUE_ID = Buffer.from('REMB', 'ascii');
+
+export function encodeRemb(remb: RtcpRemb): Buffer {
+  const ssrcCount = remb.ssrcs.length;
+  // FCI: 4 (REMB) + 1 (numSSRC) + 3 (BR exp+mantissa) + ssrcCount*4
+  const fciSize = 8 + ssrcCount * 4;
+  const totalBytes = FB_HEADER_SIZE + fciSize;
+  const buf = Buffer.allocUnsafe(totalBytes);
+
+  buf[0] = (2 << 6) | 15; // V=2, P=0, FMT=15
+  buf[1] = 206;
+  buf.writeUInt16BE(totalBytes / 4 - 1, 2);
+  buf.writeUInt32BE(remb.senderSsrc >>> 0, 4);
+  buf.writeUInt32BE(remb.mediaSsrc >>> 0, 8);
+
+  // "REMB" unique identifier
+  REMB_UNIQUE_ID.copy(buf, 12);
+
+  // Num SSRC (1 byte)
+  buf[16] = ssrcCount & 0xff;
+
+  // BR Exp (6 bits) + BR Mantissa (18 bits) = 24 bits
+  // bitrate = mantissa * 2^exp
+  const { exp, mantissa } = encodeBitrate(remb.bitrate);
+  buf[17] = ((exp & 0x3f) << 2) | ((mantissa >> 16) & 0x03);
+  buf[18] = (mantissa >> 8) & 0xff;
+  buf[19] = mantissa & 0xff;
+
+  let offset = 20;
+  for (const ssrc of remb.ssrcs) {
+    buf.writeUInt32BE(ssrc >>> 0, offset);
+    offset += 4;
+  }
+
+  return buf;
+}
+
+function encodeBitrate(bitrate: number): { exp: number; mantissa: number } {
+  if (bitrate === 0) return { exp: 0, mantissa: 0 };
+  let exp = 0;
+  let m = bitrate;
+  while (m >= (1 << 18)) {
+    m >>= 1;
+    exp++;
+  }
+  return { exp, mantissa: m & 0x3ffff };
+}
+
+export function decodeRemb(buf: Buffer): RtcpRemb {
+  if (buf.length < FB_HEADER_SIZE + 8) {
+    throw new RangeError(`REMB packet too short: ${buf.length}`);
+  }
+  const senderSsrc = buf.readUInt32BE(4);
+  const mediaSsrc = buf.readUInt32BE(8);
+
+  // Verify "REMB" unique ID
+  const uid = buf.subarray(12, 16).toString('ascii');
+  if (uid !== 'REMB') {
+    throw new Error(`Not a REMB packet, got unique ID: ${uid}`);
+  }
+
+  const numSsrc = buf[16]!;
+  const byte17 = buf[17]!;
+  const byte18 = buf[18]!;
+  const byte19 = buf[19]!;
+
+  const exp = (byte17 >> 2) & 0x3f;
+  const mantissa = ((byte17 & 0x03) << 16) | (byte18 << 8) | byte19;
+  const bitrate = mantissa * Math.pow(2, exp);
+
+  const ssrcs: number[] = [];
+  let offset = 20;
+  for (let i = 0; i < numSsrc; i++) {
+    if (offset + 4 > buf.length) break;
+    ssrcs.push(buf.readUInt32BE(offset));
+    offset += 4;
+  }
+
+  return { senderSsrc, mediaSsrc, bitrate, ssrcs };
+}

package/src/rtcp/index.ts

@@ -0,0 +1,150 @@
+/**
+ * RTCP compound packet dispatch — RFC 3550 Section 6.1
+ *
+ * Compound RTCP packets are multiple RTCP packets concatenated together
+ * in a single UDP datagram.
+ */
+
+import type { RtcpPacket, RtcpPacketType as RtcpPT } from '../types.js';
+import { RtcpPacketType } from '../types.js';
+import { encodeSr, decodeSr } from './sr.js';
+import { encodeRr, decodeRr } from './rr.js';
+import { encodeSdes, decodeSdes } from './sdes.js';
+import { encodeBye, decodeBye } from './bye.js';
+import {
+  encodeNack,
+  decodeNack,
+  encodePli,
+  decodePli,
+  encodeFir,
+  decodeFir,
+  encodeRemb,
+  decodeRemb,
+} from './fb.js';
+
+/**
+ * Returns true if the buffer looks like an RTCP packet:
+ *   - version == 2
+ *   - payload type in 200–207
+ *   - at least 4 bytes
+ */
+export function isRtcpPacket(buf: Buffer): boolean {
+  if (buf.length < 4) return false;
+  const byte0 = buf[0];
+  if (byte0 === undefined) return false;
+  const version = (byte0 >> 6) & 0x03;
+  if (version !== 2) return false;
+  const byte1 = buf[1];
+  if (byte1 === undefined) return false;
+  // RTCP PT is the full second byte value (200–207)
+  return byte1 >= 200 && byte1 <= 207;
+}
+
+/**
+ * Decode a (possibly compound) RTCP buffer into an array of RtcpPacket objects.
+ */
+export function decodeRtcp(buf: Buffer): RtcpPacket[] {
+  const packets: RtcpPacket[] = [];
+  let offset = 0;
+
+  while (offset < buf.length) {
+    if (offset + 4 > buf.length) break;
+
+    const byte0 = buf[offset]!;
+    const byte1 = buf[offset + 1]!;
+    const lengthWords = buf.readUInt16BE(offset + 2);
+    const packetByteLen = (lengthWords + 1) * 4;
+
+    if (offset + packetByteLen > buf.length) {
+      // Truncated — take what we have
+      break;
+    }
+
+    const packetBuf = buf.subarray(offset, offset + packetByteLen) as Buffer;
+    offset += packetByteLen;
+
+    const pt: number = byte1; // RTCP PT occupies the full second byte (no marker bit)
+    const fmt = byte0 & 0x1f; // lower 5 bits (also RC / SC / FMT)
+
+    try {
+      if (pt === RtcpPacketType.SR) {
+        packets.push({ type: 'sr', packet: decodeSr(packetBuf) });
+      } else if (pt === RtcpPacketType.RR) {
+        packets.push({ type: 'rr', packet: decodeRr(packetBuf) });
+      } else if (pt === RtcpPacketType.SDES) {
+        packets.push({ type: 'sdes', packet: decodeSdes(packetBuf) });
+      } else if (pt === RtcpPacketType.BYE) {
+        packets.push({ type: 'bye', packet: decodeBye(packetBuf) });
+      } else if (pt === RtcpPacketType.TransportFeedback) {
+        // FMT=1: NACK
+        if (fmt === 1) {
+          packets.push({ type: 'nack', packet: decodeNack(packetBuf) });
+        } else {
+          packets.push({ type: 'unknown', raw: Buffer.from(packetBuf) });
+        }
+      } else if (pt === RtcpPacketType.PayloadFeedback) {
+        if (fmt === 1) {
+          packets.push({ type: 'pli', packet: decodePli(packetBuf) });
+        } else if (fmt === 4) {
+          packets.push({ type: 'fir', packet: decodeFir(packetBuf) });
+        } else if (fmt === 15) {
+          // Could be REMB — check unique identifier
+          if (packetBuf.length >= 16 && packetBuf.subarray(12, 16).toString('ascii') === 'REMB') {
+            packets.push({ type: 'remb', packet: decodeRemb(packetBuf) });
+          } else {
+            packets.push({ type: 'unknown', raw: Buffer.from(packetBuf) });
+          }
+        } else {
+          packets.push({ type: 'unknown', raw: Buffer.from(packetBuf) });
+        }
+      } else {
+        packets.push({ type: 'unknown', raw: Buffer.from(packetBuf) });
+      }
+    } catch {
+      packets.push({ type: 'unknown', raw: Buffer.from(packetBuf) });
+    }
+  }
+
+  return packets;
+}
+
+/**
+ * Encode an array of RtcpPacket objects into a compound RTCP buffer.
+ */
+export function encodeRtcp(packets: RtcpPacket[]): Buffer {
+  const parts: Buffer[] = [];
+
+  for (const pkt of packets) {
+    switch (pkt.type) {
+      case 'sr':
+        parts.push(encodeSr(pkt.packet));
+        break;
+      case 'rr':
+        parts.push(encodeRr(pkt.packet));
+        break;
+      case 'sdes':
+        parts.push(encodeSdes(pkt.packet));
+        break;
+      case 'bye':
+        parts.push(encodeBye(pkt.packet));
+        break;
+      case 'nack':
+        parts.push(encodeNack(pkt.packet));
+        break;
+      case 'pli':
+        parts.push(encodePli(pkt.packet));
+        break;
+      case 'fir':
+        parts.push(encodeFir(pkt.packet));
+        break;
+      case 'remb':
+        parts.push(encodeRemb(pkt.packet));
+        break;
+      case 'unknown':
+        parts.push(pkt.raw);
+        break;
+    }
+  }
+
+  return Buffer.concat(parts);
+}

package/src/rtcp/rr.ts

@@ -0,0 +1,82 @@
+/**
+ * RTCP Receiver Report (RR) — RFC 3550 Section 6.4.2
+ * Also provides shared ReportBlock encode/decode helpers.
+ */
+
+import type { RtcpReceiverReport, ReportBlock } from '../types.js';
+
+/** Each report block is exactly 24 bytes (6 x 32-bit words) */
+export const REPORT_BLOCK_SIZE = 24;
+
+/** RR base size: 4 (common hdr) + 4 (SSRC) */
+const RR_BASE_SIZE = 8;
+
+export function encodeReportBlock(rb: ReportBlock, buf: Buffer, offset: number): void {
+  buf.writeUInt32BE(rb.ssrc >>> 0, offset);
+
+  // fractionLost (8 bits) | cumulativeLost (24 bits, two's complement)
+  const cumLost = rb.cumulativeLost & 0xffffff;
+  buf.writeUInt32BE(((rb.fractionLost & 0xff) << 24) | cumLost, offset + 4);
+
+  buf.writeUInt32BE(rb.extendedHighestSeq >>> 0, offset + 8);
+  buf.writeUInt32BE(rb.jitter >>> 0, offset + 12);
+  buf.writeUInt32BE(rb.lastSR >>> 0, offset + 16);
+  buf.writeUInt32BE(rb.delaySinceLastSR >>> 0, offset + 20);
+}
+
+export function decodeReportBlock(buf: Buffer, offset: number): ReportBlock {
+  const ssrc = buf.readUInt32BE(offset);
+  const word2 = buf.readUInt32BE(offset + 4);
+
+  const fractionLost = (word2 >>> 24) & 0xff;
+  // cumulativeLost is 24-bit signed
+  let cumulativeLost = word2 & 0xffffff;
+  if (cumulativeLost & 0x800000) {
+    cumulativeLost = cumulativeLost - 0x1000000; // sign extend
+  }
+
+  const extendedHighestSeq = buf.readUInt32BE(offset + 8);
+  const jitter = buf.readUInt32BE(offset + 12);
+  const lastSR = buf.readUInt32BE(offset + 16);
+  const delaySinceLastSR = buf.readUInt32BE(offset + 20);
+
+  return { ssrc, fractionLost, cumulativeLost, extendedHighestSeq, jitter, lastSR, delaySinceLastSR };
+}
+
+export function encodeRr(rr: RtcpReceiverReport): Buffer {
+  const blockCount = rr.reportBlocks.length;
+  const totalBytes = RR_BASE_SIZE + blockCount * REPORT_BLOCK_SIZE;
+  const buf = Buffer.allocUnsafe(totalBytes);
+
+  buf[0] = (2 << 6) | (blockCount & 0x1f);
+  buf[1] = 201;
+  buf.writeUInt16BE(totalBytes / 4 - 1, 2);
+  buf.writeUInt32BE(rr.ssrc >>> 0, 4);
+
+  let offset = RR_BASE_SIZE;
+  for (const rb of rr.reportBlocks) {
+    encodeReportBlock(rb, buf, offset);
+    offset += REPORT_BLOCK_SIZE;
+  }
+
+  return buf;
+}
+
+export function decodeRr(buf: Buffer): RtcpReceiverReport {
+  if (buf.length < RR_BASE_SIZE) {
+    throw new RangeError(`RR packet too short: ${buf.length}`);
+  }
+
+  const rc = (buf[0]! & 0x1f);
+  const ssrc = buf.readUInt32BE(4);
+
+  const reportBlocks: ReportBlock[] = [];
+  let offset = RR_BASE_SIZE;
+  for (let i = 0; i < rc; i++) {
+    if (offset + REPORT_BLOCK_SIZE > buf.length) break;
+    reportBlocks.push(decodeReportBlock(buf, offset));
+    offset += REPORT_BLOCK_SIZE;
+  }
+
+  return { ssrc, reportBlocks };
+}

package/src/rtcp/sdes.ts

@@ -0,0 +1,94 @@
+/**
+ * RTCP SDES (Source Description) — RFC 3550 Section 6.5
+ */
+
+import type { RtcpSdes, SdesChunk, SdesItem } from '../types.js';
+
+/** SDES base header: 4 bytes (common header) */
+const SDES_HEADER_SIZE = 4;
+
+export function encodeSdes(sdes: RtcpSdes): Buffer {
+  const chunkBuffers: Buffer[] = [];
+
+  for (const chunk of sdes.chunks) {
+    const itemParts: Buffer[] = [];
+
+    // SSRC (4 bytes)
+    const ssrcBuf = Buffer.allocUnsafe(4);
+    ssrcBuf.writeUInt32BE(chunk.ssrc >>> 0, 0);
+    itemParts.push(ssrcBuf);
+
+    for (const item of chunk.items) {
+      const textBuf = Buffer.from(item.text, 'utf8');
+      const itemBuf = Buffer.allocUnsafe(2 + textBuf.length);
+      itemBuf[0] = item.type & 0xff;
+      itemBuf[1] = textBuf.length & 0xff;
+      textBuf.copy(itemBuf, 2);
+      itemParts.push(itemBuf);
+    }
+
+    // END item (type=0)
+    itemParts.push(Buffer.from([0x00]));
+
+    // Concatenate and pad to 4-byte boundary
+    const chunkBody = Buffer.concat(itemParts);
+    const padLen = (4 - (chunkBody.length % 4)) % 4;
+    const padding = Buffer.alloc(padLen, 0x00);
+    chunkBuffers.push(Buffer.concat([chunkBody, padding]));
+  }
+
+  const body = Buffer.concat(chunkBuffers);
+  const totalBytes = SDES_HEADER_SIZE + body.length;
+
+  const header = Buffer.allocUnsafe(SDES_HEADER_SIZE);
+  const sc = sdes.chunks.length;
+  header[0] = (2 << 6) | (sc & 0x1f);
+  header[1] = 202;
+  header.writeUInt16BE(totalBytes / 4 - 1, 2);
+
+  return Buffer.concat([header, body]);
+}
+
+export function decodeSdes(buf: Buffer): RtcpSdes {
+  if (buf.length < SDES_HEADER_SIZE) {
+    throw new RangeError(`SDES packet too short: ${buf.length}`);
+  }
+
+  const sc = buf[0]! & 0x1f;
+  // length word gives total 32-bit words - 1, so total bytes = (length+1)*4
+  const totalBytes = (buf.readUInt16BE(2) + 1) * 4;
+
+  const chunks: SdesChunk[] = [];
+  let offset = SDES_HEADER_SIZE;
+
+  for (let c = 0; c < sc; c++) {
+    if (offset + 4 > buf.length) break;
+
+    const ssrc = buf.readUInt32BE(offset);
+    offset += 4;
+
+    const items: SdesItem[] = [];
+
+    while (offset < totalBytes && offset < buf.length) {
+      const itemType = buf[offset];
+      if (itemType === undefined || itemType === 0x00) {
+        // END item — skip to 4-byte boundary
+        offset++;
+        const padTo = (offset + 3) & ~3;
+        offset = Math.min(padTo, buf.length);
+        break;
+      }
+      offset++;
+      const textLen = buf[offset];
+      if (textLen === undefined) break;
+      offset++;
+      const text = buf.subarray(offset, offset + textLen).toString('utf8');
+      offset += textLen;
+      items.push({ type: itemType, text });
+    }
+
+    chunks.push({ ssrc, items });
+  }
+
+  return { chunks };
+}

package/src/rtcp/sr.ts

@@ -0,0 +1,75 @@
+/**
+ * RTCP Sender Report (SR) — RFC 3550 Section 6.4.1
+ */
+
+import type { RtcpSenderReport, ReportBlock } from '../types.js';
+import { encodeReportBlock, decodeReportBlock, REPORT_BLOCK_SIZE } from './rr.js';
+
+/** Fixed size of SR sender info block (without report blocks) */
+const SR_SENDER_INFO_SIZE = 20; // 5 x 32-bit words
+
+/** Full SR packet size without report blocks: 4 (common hdr) + 4 (SSRC) + 20 (sender info) */
+export const SR_BASE_SIZE = 28;
+
+export function encodeSr(sr: RtcpSenderReport): Buffer {
+  const blockCount = sr.reportBlocks.length;
+  const totalBytes = SR_BASE_SIZE + blockCount * REPORT_BLOCK_SIZE;
+  const buf = Buffer.allocUnsafe(totalBytes);
+
+  // Common RTCP header
+  // V=2, P=0, RC=blockCount, PT=200
+  buf[0] = (2 << 6) | (blockCount & 0x1f);
+  buf[1] = 200;
+  // Length in 32-bit words minus 1
+  const lengthWords = totalBytes / 4 - 1;
+  buf.writeUInt16BE(lengthWords, 2);
+
+  // SSRC
+  buf.writeUInt32BE(sr.ssrc >>> 0, 4);
+
+  // NTP timestamp (64-bit)
+  buf.writeBigUInt64BE(sr.ntpTimestamp, 8);
+
+  // RTP timestamp
+  buf.writeUInt32BE(sr.rtpTimestamp >>> 0, 16);
+
+  // Packet count
+  buf.writeUInt32BE(sr.packetCount >>> 0, 20);
+
+  // Octet count
+  buf.writeUInt32BE(sr.octetCount >>> 0, 24);
+
+  // Report blocks
+  let offset = SR_BASE_SIZE;
+  for (const rb of sr.reportBlocks) {
+    encodeReportBlock(rb, buf, offset);
+    offset += REPORT_BLOCK_SIZE;
+  }
+
+  return buf;
+}
+
+export function decodeSr(buf: Buffer): RtcpSenderReport {
+  if (buf.length < SR_BASE_SIZE) {
+    throw new RangeError(`SR packet too short: ${buf.length}`);
+  }
+
+  // byte[0]: V(2)|P(1)|RC(5)  — RC = report count
+  const rc = (buf[0]! & 0x1f);
+
+  const ssrc = buf.readUInt32BE(4);
+  const ntpTimestamp = buf.readBigUInt64BE(8);
+  const rtpTimestamp = buf.readUInt32BE(16);
+  const packetCount = buf.readUInt32BE(20);
+  const octetCount = buf.readUInt32BE(24);
+
+  const reportBlocks: ReportBlock[] = [];
+  let offset = SR_BASE_SIZE;
+  for (let i = 0; i < rc; i++) {
+    if (offset + REPORT_BLOCK_SIZE > buf.length) break;
+    reportBlocks.push(decodeReportBlock(buf, offset));
+    offset += REPORT_BLOCK_SIZE;
+  }
+
+  return { ssrc, ntpTimestamp, rtpTimestamp, packetCount, octetCount, reportBlocks };
+}