@blockcast/mmt-base 0.3.0 → 0.4.0-main.1d3ea1cc8ff2

package/src/serial-number.ts

@@ -47,61 +47,3 @@ export function serial32Precedes(a: number, b: number): boolean {
   const distance = serial32Distance(a, b)
   return distance !== 0 && distance < SERIAL32_HALF
 }
-
-/**
- * First SS_ID of block `sbn` under the K-stride numbering every current
- * sender uses (`SS_ID = SBN * K + ESI`, C.5.2), reduced mod 2^32.
- */
-export function kStrideBlockStart(sbn: number, k: number): number {
-  assertUint32(sbn, 'sbn')
-  if (!Number.isInteger(k) || k < 1 || k >= SERIAL32_HALF) {
-    throw new RangeError(`k must be a positive integer below 2^31 (got ${k})`)
-  }
-  // sbn < 2^32 and k < 2^31 keep the product below 2^63, but a double is
-  // exact only to 2^53; split the product so every step is exact.
-  const high = Math.floor(sbn / 0x1_0000) // < 2^16
-  const low = sbn % 0x1_0000              // < 2^16
-  return (((high * k) % SERIAL32_SPAN) * 0x1_0000 + low * k) % SERIAL32_SPAN
-}
-
-/**
- * Whether block `a` precedes block `b`, ordering the blocks by their first
- * SS_ID in serial arithmetic. Identical to `a < b` for any two blocks of a
- * stream that has not wrapped SS_ID.
- */
-export function kStrideBlockPrecedes(a: number, b: number, k: number): boolean {
-  return serial32Precedes(kStrideBlockStart(a, k), kStrideBlockStart(b, k))
-}
-
-/**
- * How many blocks `a` lies behind `b`: 0 when `a` does not precede `b`,
- * otherwise `ceil(distance / K)` over the SS_ID distance between their first
- * symbols. Without a wrap that is exactly `b - a`; across the wrap the one
- * short pre-wrap block (2^32 mod K symbols) still counts as one block.
- */
-export function kStrideBlocksBehind(a: number, b: number, k: number): number {
-  const from = kStrideBlockStart(a, k)
-  const to = kStrideBlockStart(b, k)
-  if (!serial32Precedes(from, to)) return 0
-  return Math.ceil(serial32Distance(from, to) / k)
-}
-
-/**
- * Whether `sbn` and `k` describe a block of the K-stride numbering:
- * `sbn` a uint32, `k` an integer in 1..2^31-1.
- */
-export function isKStrideBlock(sbn: number, k: number): boolean {
-  return Number.isInteger(sbn) && sbn >= 0 && sbn < SERIAL32_SPAN &&
-    Number.isInteger(k) && k >= 1 && k < SERIAL32_HALF
-}
-
-/**
- * The block after `sbn`: `sbn + 1`, or 0 once `(sbn + 1) * K` reaches 2^32
- * and the next SS_ID wraps (C.5.2). There are `ceil(2^32 / K)` blocks per
- * wrap, the last of them short when K does not divide 2^32.
- */
-export function kStrideNextBlock(sbn: number, k: number): number {
-  assertUint32(sbn, 'sbn')
-  kStrideBlockStart(sbn, k) // validates k
-  return (sbn + 1) * k >= SERIAL32_SPAN ? 0 : sbn + 1
-}

package/src/signalling.ts

@@ -23,6 +23,8 @@
 import {
   ALFEC_MESSAGE_ID,
   FEC_CODE_RAPTORQ,
+  FEC_CODE_REED_SOLOMON,
+  MMTP_SIGNALING_PACKET_ID,
   PACKET_TYPE_SIGNALING,
   parseMMTPHeader,
   type MMTPHeader,
@@ -112,20 +114,17 @@ function total<T>(parse: () => T | null): T | null {
 // ---------------------------------------------------------------------------
 
 /**
- * How the signalling payload of an MMTP packet was framed.
+ * How the signalling payload of an MMTP packet was framed: always
+ * `iso-9.3.4.2`, the 2-byte `f_i(2) RES(4) H(1) A(1) | frag_counter(8)`
+ * header of ISO/IEC 23008-1:2023 9.3.4.2 ahead of the message(s).
  *
- * - `iso-9.3.4.2`: the 2-byte `f_i(2) RES(4) H(1) A(1) | frag_counter(8)`
- *   header of ISO/IEC 23008-1:2023 9.3.4.2 precedes the message(s).
- * - `legacy-bare-alfec`: the pre-remediation Blockcast form, where the
- *   AL-FEC message starts directly after the MMTP header. It is recognised
- *   only by its first two bytes being `0x02 0x03` (message_id 0x0203). That
- *   pair is never a valid 9.3.4.2 header for a complete message: f_i=00 with
- *   frag_counter=3 claims three further fragments of a message the same
- *   header declares complete. The peek is therefore exact, not a heuristic.
- *   The legacy branch is deleted once no legacy sender remains (BLO-35597
- *   plan, Phase L).
+ * The pre-remediation Blockcast form, an AL-FEC message directly after the
+ * MMTP header, is not accepted (BLO-35597, Phase L). Its first two bytes,
+ * `0x02 0x03`, read as a 9.3.4.2 header claiming three further fragments
+ * of a complete message, which the header parser refuses: such a packet
+ * parses to null, never to a guess.
  */
-export type SignallingPayloadForm = 'iso-9.3.4.2' | 'legacy-bare-alfec'
+export type SignallingPayloadForm = 'iso-9.3.4.2'
 
 export interface SignallingPayload {
   form: SignallingPayloadForm
@@ -158,10 +157,6 @@ export function parseSignallingPayload(mmtpPacket: Uint8Array): SignallingPayloa
 
 function splitSignallingPayload(payload: Uint8Array): SignallingPayload {
   if (payload.length < 2) fail('short signalling payload')
-  if (payload[0] === (ALFEC_MESSAGE_ID >> 8) && payload[1] === (ALFEC_MESSAGE_ID & 0xff)) {
-    return { form: 'legacy-bare-alfec', messages: [payload] }
-  }
-
   const reader = new WireReader(payload)
   const flags = reader.u8()
   const fragmentation = flags >> 6
@@ -445,9 +440,9 @@ export function parseAlFecMessageBody(message: Uint8Array): AlFecMessageBody | n
 }
 
 /**
- * Parse the AL-FEC message carried by a full MMTP signalling packet, in
- * either payload form (see SignallingPayloadForm). Returns null when the
- * packet carries no AL-FEC message, more than one, or a malformed one.
+ * Parse the AL-FEC message carried by a full MMTP signalling packet (a
+ * 9.3.4.2 payload, see SignallingPayloadForm). Returns null when the packet
+ * carries no AL-FEC message, more than one, or a malformed one.
  */
 export function parseAlFecMessage(mmtpPacket: Uint8Array): AlFecMessage | null {
   const packet = parseSignallingPacket(mmtpPacket)
@@ -460,92 +455,112 @@ export function parseAlFecMessage(mmtpPacket: Uint8Array): AlFecMessage | null {
 }
 
 /**
- * Decoder geometry of one FEC flow under the Blockcast one-stage RaptorQ
- * profile: private_field = RaptorQ FEC OTI (RFC 6330 3.3.2-3.3.3, 12 bytes)
- * followed by the interleave depth (1 byte).
+ * Decoder geometry of one FEC flow's AL-FEC message entry under
+ * draft-ramadan-moq-mmt-01 Section 8.3 ("iso-ssbg1-v1"): one Asset, coding
+ * byte 0x14, fec_code_id_for_repair_flow 3 (RaptorQ) or 1 (Reed-Solomon),
+ * and no OTI (draft-ramadan-moq-mmt-01 Section 7.2). K, T and P come from
+ * the entry's own fields; a private field, if present, is ignored.
  */
 export interface AlFecRaptorQFlowConfig {
+  /** The flow's one Asset packet_id (number_of_assets is 1). */
   sourcePacketIds: number[]
   repairFlowId: number
+  /** `FEC_CODE_RAPTORQ` (3) or `FEC_CODE_REED_SOLOMON` (1). */
+  fecCodeId: number
+  /** Always `SSBG_MODE_1` (`iso-ssbg1-v1`). */
   ssbgMode: number
+  /** Always 0: the profile's coding byte is exactly 0x14. */
   fecPayloadIdMode: 0 | 1
+  /** T, from length_of_repair_symbol. */
   repairSymbolSize: number
+  /** K, from maximum_k_for_repair_flow. */
   maximumK: number
+  /** P, from maximum_p_for_repair_flow: the RSB_length total over every published layer. */
   maximumP: number
-  interleaveDepth: number
-  oti: Uint8Array
   protectionWindowTime: number
   protectionWindowSize: number
 }
 
-const RAPTORQ_PRIVATE_FIELD_LENGTH = 13
 const RAPTORQ_MAX_SOURCE_SYMBOLS = 56_403
 const REPAIR_SYMBOL_ID_MAX = 0x00ff_ffff
-
-function canonicalRaptorQOtiK(oti: Uint8Array, repairSymbolSize: number): number | null {
-  if (oti.length !== 12 || oti[5] !== 0) return null
-  const transferLength = (oti[0]! * 0x1_0000_0000) +
-    (((oti[1]! << 24) | (oti[2]! << 16) | (oti[3]! << 8) | oti[4]!) >>> 0)
-  const symbolSize = (oti[6]! << 8) | oti[7]!
-  const sourceBlocks = oti[8]!
-  const subBlocks = (oti[9]! << 8) | oti[10]!
-  const alignment = oti[11]!
-  if (!Number.isSafeInteger(transferLength) || transferLength <= 0 ||
-      symbolSize !== repairSymbolSize || symbolSize === 0 || symbolSize % 8 !== 0 ||
-      sourceBlocks !== 1 || subBlocks !== 1 || alignment !== 8 ||
-      transferLength % symbolSize !== 0) {
-    return null
-  }
-  const k = transferLength / symbolSize
-  return Number.isInteger(k) && k >= 1 && k <= RAPTORQ_MAX_SOURCE_SYMBOLS ? k : null
-}
+/** The 12-octet MMTP header plus the 2-octet length of the T - 2 construction (moq-fec-01 Section 7.3). */
+const MIN_REPAIR_SYMBOL_SIZE = 14
+const REED_SOLOMON_MAX_BLOCK = 255
 
 /**
- * Validate one parsed FEC flow against the Blockcast one-stage RaptorQ
- * profile and return its decoder geometry, or null when the flow is outside
- * the profile. Nothing is inferred: K comes from the OTI and must equal
- * maximum_k_for_repair_flow.
+ * Validate one parsed FEC flow against draft-ramadan-moq-mmt-01 Sections 8.3
+ * and 12.2 and return its decoder geometry, or null when the entry is
+ * outside them. Fail closed on everything else:
  *
- * ssbg_mode 0 and 1 are both returned as signalled: which source-symbol
- * construction a decoder applies is the stream's FEC block profile, decided
- * by its consumer, not here. ffsrpts_flag=1 is refused because the FFSRP_TS
- * word changes the source/repair packet trailer layout that every Blockcast
- * receiver assumes.
+ * - coding byte other than 0x14 (one-stage, ssbg_mode1, ffsrpts_flag 0,
+ *   fec_payload_id_mode 0). 0x15 is fec_payload_id_mode 1 under Amd 1:2025,
+ *   which "iso-ssbg1-v1" does not describe (moq-fec-01 Section 7.3);
+ * - number_of_assets other than 1;
+ * - fec_code_id_for_repair_flow other than 3 or 1, the retired Blockcast
+ *   code 2 included (ISO/IEC 23008-10 Table 1);
+ * - T < 14, K = 0, P = 0, K + P - 1 > 2^24 - 1;
+ * - RaptorQ: T not a multiple of 8, or K > 56403;
+ * - Reed-Solomon: K + P > 255;
+ * - repair_flow_id 0 (the signalling flow) or the flow's own packet_id.
+ *
+ * Checks that span entries (another entry's packet_id, a duplicate
+ * repair_flow_id or Asset) are `alFecMessageFlowConfigs`'.
  */
 export function alFecRaptorQFlowConfig(flow: AlFecFlow): AlFecRaptorQFlowConfig | null {
   if (flow.fecCodingStructure !== FEC_CODING_STRUCTURE_ONE_STAGE || flow.repairFlows.length !== 1) return null
-  if (flow.ssbgMode !== SSBG_MODE_0 && flow.ssbgMode !== SSBG_MODE_1) return null
-  if (flow.ffsrptsFlag !== 0) return null
+  if (flow.ssbgMode !== SSBG_MODE_1 || flow.ffsrptsFlag !== 0 || flow.fecPayloadIdMode !== 0) return null
+  if (flow.packetIds.length !== 1) return null
   const repair = flow.repairFlows[0]!
-  if (repair.fecCodeId !== FEC_CODE_RAPTORQ) return null
-  const privateField = repair.privateField
-  if (!privateField || privateField.privateFlag !== 1 ||
-      privateField.data.length !== RAPTORQ_PRIVATE_FIELD_LENGTH) {
-    return null
-  }
-  const oti = privateField.data.slice(0, 12)
-  const interleaveDepth = privateField.data[12]!
-  const otiK = canonicalRaptorQOtiK(oti, flow.repairSymbolSize)
-  if (otiK === null || interleaveDepth === 0) return null
-  if (repair.maximumK !== otiK || repair.maximumP === 0 ||
-      repair.maximumK + repair.maximumP - 1 > REPAIR_SYMBOL_ID_MAX) {
+  const { fecCodeId, maximumK: k, maximumP: p } = repair
+  const t = flow.repairSymbolSize
+  if (t < MIN_REPAIR_SYMBOL_SIZE || k < 1 || p < 1 || k + p - 1 > REPAIR_SYMBOL_ID_MAX) return null
+  if (fecCodeId === FEC_CODE_RAPTORQ) {
+    if (t % 8 !== 0 || k > RAPTORQ_MAX_SOURCE_SYMBOLS) return null
+  } else if (fecCodeId === FEC_CODE_REED_SOLOMON) {
+    if (k + p > REED_SOLOMON_MAX_BLOCK) return null
+  } else {
     return null
   }
+  if (repair.repairFlowId === MMTP_SIGNALING_PACKET_ID || repair.repairFlowId === flow.packetIds[0]) return null
   return {
     sourcePacketIds: [...flow.packetIds],
     repairFlowId: repair.repairFlowId,
+    fecCodeId,
     ssbgMode: flow.ssbgMode,
     fecPayloadIdMode: flow.fecPayloadIdMode,
-    repairSymbolSize: flow.repairSymbolSize,
-    maximumK: repair.maximumK,
-    maximumP: repair.maximumP,
-    interleaveDepth,
-    oti,
+    repairSymbolSize: t,
+    maximumK: k,
+    maximumP: p,
     protectionWindowTime: repair.protectionWindowTime,
     protectionWindowSize: repair.protectionWindowSize,
   }
 }
 
+/**
+ * `alFecRaptorQFlowConfig` for every entry of a message, index for index,
+ * plus the draft-ramadan-moq-mmt-01 Section 12.2 checks that span entries: an
+ * entry whose repair_flow_id is another entry's Asset packet_id, and every
+ * entry of two that name one repair_flow_id or list one Asset, is null.
+ */
+export function alFecMessageFlowConfigs(message: AlFecMessageBody): (AlFecRaptorQFlowConfig | null)[] {
+  const assetCount = new Map<number, number>()
+  const repairCount = new Map<number, number>()
+  const bump = (map: Map<number, number>, key: number) => map.set(key, (map.get(key) ?? 0) + 1)
+  for (const flow of message.flows) {
+    for (const id of flow.packetIds) bump(assetCount, id)
+    for (const repair of flow.repairFlows) bump(repairCount, repair.repairFlowId)
+  }
+  return message.flows.map(flow => {
+    const config = alFecRaptorQFlowConfig(flow)
+    if (!config) return null
+    const [asset] = config.sourcePacketIds
+    if (assetCount.get(asset!) !== 1 || repairCount.get(config.repairFlowId) !== 1) return null
+    // Its own packet_id is already refused, so any count here is another entry's.
+    if (assetCount.has(config.repairFlowId)) return null
+    return config
+  })
+}
+
 // ---------------------------------------------------------------------------
 // 10.6 — location, asset_id and identifier mapping
 // ---------------------------------------------------------------------------
@@ -847,10 +862,7 @@ function decodeSignallingMessage(bytes: Uint8Array): MmtSignallingMessage {
  * Parse every signalling message of a full MMTP signalling packet (the
  * packet_id 0 flow). Returns null when the packet or any message in it is
  * malformed: one unparseable message leaves the receiver unable to say what
- * the packet signalled.
- *
- * The legacy bare form carries exactly one AL-FEC message; any other message
- * is only accepted inside a 9.3.4.2 payload.
+ * the packet signalled. Only the 9.3.4.2 payload form is accepted.
  */
 export function parseSignallingPacket(mmtpPacket: Uint8Array): MmtSignallingPacket | null {
   const payload = parseSignallingPayload(mmtpPacket)