@blockcast/mmt-container 0.1.0 → 0.3.0-main.d9354616fdf2

package/dist/signaling.js

@@ -0,0 +1,572 @@
+// ../mmt-alta-parse/dist/index.js
+var MPU_HEADER_SIZE = 8;
+var MPU_LENGTH_FIELD_SIZE = 2;
+var MPU_HEADER_REMAINDER_SIZE = MPU_HEADER_SIZE - MPU_LENGTH_FIELD_SIZE;
+
+// ../mmt-base/dist/mmtp.js
+var MMTP_HEADER_SIZE = 12;
+var MPU_HEADER_SIZE2 = 8;
+var MPU_LENGTH_FIELD_SIZE2 = 2;
+var MPU_HEADER_REMAINDER_SIZE2 = MPU_HEADER_SIZE2 - MPU_LENGTH_FIELD_SIZE2;
+var PACKET_TYPE_MPU = 0;
+var PACKET_TYPE_SIGNALING = 2;
+var PACKET_TYPE_REPAIR = 3;
+var ALFEC_MESSAGE_ID = 515;
+var FEC_CODE_XOR = 1;
+var FEC_CODE_RAPTORQ = 2;
+function parseMMTPHeader(buffer) {
+  if (buffer.length < MMTP_HEADER_SIZE) {
+    throw new Error(`MMTP packet too small: ${buffer.length} bytes`);
+  }
+  const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+  const version = buffer[0] >> 6 & 3;
+  if (version !== 0) {
+    throw new Error(`Unsupported MMTP version: ${version}`);
+  }
+  const fecType = buffer[0] >> 3 & 3;
+  const packetCounterFlag = (buffer[0] & 32) !== 0;
+  const extensionFlag = (buffer[0] & 2) !== 0;
+  const rapFlag = (buffer[0] & 1) === 1;
+  const packetType = buffer[1] & 63;
+  let offset = 2;
+  const packetId = view.getUint16(offset, false);
+  offset += 2;
+  const timestamp = BigInt(view.getUint32(offset, false));
+  offset += 4;
+  const sequenceNumber = view.getUint32(offset, false);
+  offset += 4;
+  let packetCounter;
+  if (packetCounterFlag) {
+    if (offset + 4 > buffer.length)
+      throw new Error("MMTP packet truncated in packet_counter");
+    packetCounter = view.getUint32(offset, false);
+    offset += 4;
+  }
+  let extension;
+  if (extensionFlag) {
+    if (offset + 4 > buffer.length)
+      throw new Error("MMTP packet truncated in header extension");
+    const type = view.getUint16(offset, false);
+    const length = view.getUint16(offset + 2, false);
+    offset += 4;
+    if (offset + length > buffer.length)
+      throw new Error("MMTP packet truncated in header extension value");
+    extension = { type, data: buffer.subarray(offset, offset + length) };
+    offset += length;
+  }
+  return {
+    version,
+    packetType,
+    packetId,
+    timestamp,
+    sequenceNumber,
+    payloadLength: buffer.length - offset,
+    fecType,
+    packetCounterFlag,
+    packetCounter,
+    extensionFlag,
+    extension,
+    headerLength: offset,
+    rapFlag
+  };
+}
+
+// ../mmt-base/dist/ntp-short.js
+var NTP_SHORT_BITS = 32;
+var NTP_SHORT_MODULUS = 2 ** NTP_SHORT_BITS;
+var NTP_SHORT_HALF_RANGE = 2 ** (NTP_SHORT_BITS - 1);
+
+// ../mmt-base/dist/signalling.js
+var MalformedSignalling = class extends Error {
+};
+var WireReader = class {
+  #bytes;
+  #end;
+  #offset;
+  constructor(bytes, start = 0, end = bytes.length) {
+    this.#bytes = bytes;
+    this.#offset = start;
+    this.#end = end;
+  }
+  get offset() {
+    return this.#offset;
+  }
+  get remaining() {
+    return this.#end - this.#offset;
+  }
+  #take(length) {
+    if (length < 0 || length > this.remaining)
+      throw new MalformedSignalling("truncated");
+    const at = this.#offset;
+    this.#offset += length;
+    return at;
+  }
+  u8() {
+    return this.#bytes[this.#take(1)];
+  }
+  u16() {
+    const at = this.#take(2);
+    return this.#bytes[at] << 8 | this.#bytes[at + 1];
+  }
+  u24() {
+    const at = this.#take(3);
+    return this.#bytes[at] << 16 | this.#bytes[at + 1] << 8 | this.#bytes[at + 2];
+  }
+  u32() {
+    const at = this.#take(4);
+    return (this.#bytes[at] << 24 | this.#bytes[at + 1] << 16 | this.#bytes[at + 2] << 8 | this.#bytes[at + 3]) >>> 0;
+  }
+  /** A copy, so a parsed message never aliases a reused packet buffer. */
+  bytes(length) {
+    const at = this.#take(length);
+    return this.#bytes.slice(at, at + length);
+  }
+  /** Throw unless every byte up to the end bound was consumed. */
+  expectEnd() {
+    if (this.remaining !== 0)
+      throw new MalformedSignalling("trailing bytes");
+  }
+};
+function fail(reason) {
+  throw new MalformedSignalling(reason);
+}
+function total(parse) {
+  try {
+    return parse();
+  } catch (error) {
+    if (error instanceof MalformedSignalling)
+      return null;
+    throw error;
+  }
+}
+var SIGNALLING_FRAGMENTATION_COMPLETE = 0;
+function parseSignallingPayload(mmtpPacket) {
+  let header;
+  try {
+    header = parseMMTPHeader(mmtpPacket);
+  } catch {
+    return null;
+  }
+  if (header.packetType !== PACKET_TYPE_SIGNALING || header.fecType !== 0)
+    return null;
+  const payload = mmtpPacket.subarray(header.headerLength);
+  return total(() => splitSignallingPayload(payload));
+}
+function splitSignallingPayload(payload) {
+  if (payload.length < 2)
+    fail("short signalling payload");
+  if (payload[0] === ALFEC_MESSAGE_ID >> 8 && payload[1] === (ALFEC_MESSAGE_ID & 255)) {
+    return { form: "legacy-bare-alfec", messages: [payload] };
+  }
+  const reader = new WireReader(payload);
+  const flags = reader.u8();
+  const fragmentation = flags >> 6;
+  const lengthIs32Bits = (flags >> 1 & 1) === 1;
+  const aggregated = (flags & 1) === 1;
+  const fragmentCounter = reader.u8();
+  if (fragmentation !== SIGNALLING_FRAGMENTATION_COMPLETE)
+    fail("fragmented signalling message");
+  if (fragmentCounter !== 0)
+    fail("frag_counter on a complete message");
+  if (!aggregated) {
+    if (reader.remaining === 0)
+      fail("empty signalling payload");
+    return { form: "iso-9.3.4.2", messages: [payload.subarray(reader.offset)] };
+  }
+  const messages = [];
+  while (reader.remaining > 0) {
+    const length = lengthIs32Bits ? reader.u32() : reader.u16();
+    if (length === 0)
+      fail("zero MSG_length");
+    const start = reader.offset;
+    reader.bytes(length);
+    messages.push(payload.subarray(start, start + length));
+  }
+  if (messages.length === 0)
+    fail("aggregated payload with no message");
+  return { form: "iso-9.3.4.2", messages };
+}
+var PA_MESSAGE_ID = 0;
+var MPI_MESSAGE_ID_FIRST = 1;
+var MPI_MESSAGE_ID_LAST = 16;
+var MPT_MESSAGE_ID_FIRST = 17;
+var MPT_MESSAGE_ID_COMPLETE = 32;
+function signallingMessageHas32BitLength(messageId) {
+  return messageId === PA_MESSAGE_ID || messageId >= MPI_MESSAGE_ID_FIRST && messageId <= MPI_MESSAGE_ID_LAST || messageId >= 28672 && messageId <= 32767;
+}
+function readMessageHeader(message) {
+  const reader = new WireReader(message);
+  const messageId = reader.u16();
+  const version = reader.u8();
+  const length = signallingMessageHas32BitLength(messageId) ? reader.u32() : reader.u16();
+  if (length === 0 || length !== reader.remaining)
+    fail("message length mismatch");
+  return { reader, messageId, version };
+}
+var FEC_CODING_STRUCTURE_NONE = 0;
+var FEC_CODING_STRUCTURE_ONE_STAGE = 1;
+var FEC_CODING_STRUCTURE_TWO_STAGE = 2;
+var FEC_CODING_STRUCTURE_LAYER_AWARE = 3;
+var SSBG_MODE_2 = 2;
+function readPrivateField(reader) {
+  const head = reader.u8();
+  return { privateFlag: head >> 7, data: reader.bytes(head & 127) };
+}
+function readRepairFlowTail(reader, repairFlowId, fecCodeId, privateField) {
+  const maximumK = reader.u24();
+  const maximumP = reader.u24();
+  const protectionWindowTime = reader.u32();
+  const protectionWindowSize = reader.u32();
+  return {
+    repairFlowId,
+    fecCodeId,
+    ...privateField ? { privateField } : {},
+    maximumK,
+    maximumP,
+    protectionWindowTime,
+    protectionWindowSize
+  };
+}
+function readRepairFlow(reader, privateFecFlag) {
+  const repairFlowId = reader.u16();
+  const fecCodeId = reader.u8();
+  const privateField = privateFecFlag ? readPrivateField(reader) : void 0;
+  return readRepairFlowTail(reader, repairFlowId, fecCodeId, privateField);
+}
+function readFecFlow(reader, privateFecFlag) {
+  const fecFlowId = reader.u8();
+  const sourceFlowId = reader.u8();
+  const numberOfAssets = reader.u8();
+  if (numberOfAssets === 0)
+    fail("FEC flow with no asset");
+  const packetIds = [];
+  for (let i = 0; i < numberOfAssets; i++)
+    packetIds.push(reader.u16());
+  const coding = reader.u8();
+  const fecCodingStructure = coding >> 4;
+  const ssbgMode = coding >> 2 & 3;
+  const ffsrptsFlag = coding >> 1 & 1;
+  const fecPayloadIdMode = coding & 1;
+  if (ssbgMode === 3)
+    fail("reserved ssbg_mode");
+  const repairSymbolSize = reader.u16();
+  const flow = {
+    fecFlowId,
+    sourceFlowId,
+    packetIds,
+    fecCodingStructure,
+    ssbgMode,
+    ffsrptsFlag,
+    fecPayloadIdMode,
+    repairSymbolSize,
+    repairFlows: []
+  };
+  if (ssbgMode === SSBG_MODE_2) {
+    flow.ssbgMode2 = {
+      numRepairSymbolPerPacket: reader.u16(),
+      numSymbolElementPerSourceSymbol: reader.u16()
+    };
+  }
+  switch (fecCodingStructure) {
+    case FEC_CODING_STRUCTURE_NONE:
+      break;
+    case FEC_CODING_STRUCTURE_ONE_STAGE:
+      flow.repairFlows.push(readRepairFlow(reader, privateFecFlag));
+      break;
+    case FEC_CODING_STRUCTURE_TWO_STAGE: {
+      flow.numSubBlockPerSourceBlock = reader.u8();
+      const numberOfParityFlows = reader.u8();
+      for (let k = 0; k < numberOfParityFlows; k++) {
+        flow.repairFlows.push(readRepairFlow(reader, privateFecFlag));
+      }
+      break;
+    }
+    case FEC_CODING_STRUCTURE_LAYER_AWARE: {
+      const numberOfLayers = reader.u8();
+      const fecCodeId = reader.u8();
+      const privateField = privateFecFlag ? readPrivateField(reader) : void 0;
+      for (let l = 0; l < numberOfLayers; l++) {
+        flow.repairFlows.push(readRepairFlowTail(reader, reader.u16(), fecCodeId, privateField));
+      }
+      break;
+    }
+    default:
+      fail(`unsupported fec_coding_structure ${fecCodingStructure}`);
+  }
+  return flow;
+}
+function parseAlFecMessageBody(message) {
+  return total(() => {
+    const { reader, messageId, version } = readMessageHeader(message);
+    if (messageId !== ALFEC_MESSAGE_ID)
+      return null;
+    const flags = reader.u8();
+    const fecFlag = flags >> 7;
+    const privateFecFlag = flags >> 6 & 1;
+    if (fecFlag === 0) {
+      reader.expectEnd();
+      return { version, fecFlag, privateFecFlag, flows: [] };
+    }
+    const descriptorLength = reader.u16();
+    if (descriptorLength === 0 || descriptorLength !== reader.remaining) {
+      fail("length_of_fec_flow_descriptor mismatch");
+    }
+    const numberOfFecFlows = reader.u8();
+    if (numberOfFecFlows === 0)
+      fail("fec_flag=1 with no FEC flow");
+    const flows = [];
+    for (let i = 0; i < numberOfFecFlows; i++)
+      flows.push(readFecFlow(reader, privateFecFlag === 1));
+    reader.expectEnd();
+    return { version, fecFlag, privateFecFlag, flows };
+  });
+}
+function parseAlFecMessage(mmtpPacket) {
+  const packet = parseSignallingPacket(mmtpPacket);
+  if (!packet)
+    return null;
+  const alFec = packet.messages.filter((message) => message.kind === "al-fec");
+  if (alFec.length !== 1)
+    return null;
+  return { ...alFec[0].message, payloadForm: packet.payloadForm };
+}
+function readAssetLocation(reader) {
+  const locationType = reader.u8();
+  switch (locationType) {
+    case 0:
+      return { locationType, packetId: reader.u16() };
+    case 1:
+    case 2: {
+      const addressLength = locationType === 1 ? 4 : 16;
+      const srcAddress = reader.bytes(addressLength);
+      const dstAddress = reader.bytes(addressLength);
+      const dstPort = reader.u16();
+      return { locationType, srcAddress, dstAddress, dstPort, packetId: reader.u16() };
+    }
+    case 3: {
+      const networkId = reader.u16();
+      const transportStreamId = reader.u16();
+      return { locationType, networkId, transportStreamId, mpeg2Pid: reader.u16() & 8191 };
+    }
+    case 4: {
+      const srcAddress = reader.bytes(16);
+      const dstAddress = reader.bytes(16);
+      const dstPort = reader.u16();
+      return { locationType, srcAddress, dstAddress, dstPort, mpeg2Pid: reader.u16() & 8191 };
+    }
+    case 5:
+      return { locationType, url: reader.bytes(reader.u8()) };
+    case 6:
+      return { locationType, data: reader.bytes(reader.u16()) };
+    default:
+      fail(`location_type ${locationType} is not an Asset location`);
+  }
+}
+function readIdentifierMapping(reader) {
+  const identifierType = reader.u8();
+  switch (identifierType) {
+    case 0: {
+      const assetIdScheme = reader.u32();
+      return { identifierType, assetIdScheme, assetId: reader.bytes(reader.u32()) };
+    }
+    case 1: {
+      const urls = [];
+      const urlCount = reader.u16();
+      for (let i = 0; i < urlCount; i++)
+        urls.push(reader.bytes(reader.u16()));
+      return { identifierType, urls };
+    }
+    case 2:
+      return { identifierType, regex: reader.bytes(reader.u16()) };
+    case 3:
+      return { identifierType, representationId: reader.bytes(reader.u16()) };
+    default:
+      return { identifierType, privateIdentifier: reader.bytes(reader.u16()) };
+  }
+}
+var MP_TABLE_ID_SUBSET_0 = 17;
+var MP_TABLE_ID_COMPLETE = 32;
+var MPI_TABLE_ID_FIRST = 1;
+var MPI_TABLE_ID_LAST = 16;
+function readMpTable(reader) {
+  const tableId = reader.u8();
+  if (tableId < MP_TABLE_ID_SUBSET_0 || tableId > MP_TABLE_ID_COMPLETE)
+    fail("not an MP table");
+  const version = reader.u8();
+  const length = reader.u16();
+  if (length === 0)
+    fail("zero MP table length");
+  const table = new WireReader(reader.bytes(length));
+  const mpTableMode = table.u8() & 3;
+  const result = { tableId, version, mpTableMode, assets: [] };
+  if (tableId === MP_TABLE_ID_COMPLETE || tableId === MP_TABLE_ID_SUBSET_0) {
+    result.packageId = table.bytes(table.u8());
+    result.descriptors = table.bytes(table.u16());
+  }
+  const numberOfAssets = table.u8();
+  for (let i = 0; i < numberOfAssets; i++) {
+    const identifier = readIdentifierMapping(table);
+    const assetType = String.fromCharCode(...table.bytes(4));
+    const flags = table.u8();
+    const asset = {
+      identifier,
+      assetType,
+      assetModificationFlag: (flags >> 2 & 1) === 1,
+      defaultAssetFlag: (flags >> 1 & 1) === 1,
+      locations: [],
+      descriptors: new Uint8Array(0)
+    };
+    if ((flags & 1) === 1) {
+      asset.assetClockRelationId = table.u8();
+      if ((table.u8() & 1) === 1)
+        asset.assetTimescale = table.u32();
+    }
+    const locationCount = table.u8();
+    for (let j = 0; j < locationCount; j++)
+      asset.locations.push(readAssetLocation(table));
+    asset.descriptors = table.bytes(table.u16());
+    result.assets.push(asset);
+  }
+  table.expectEnd();
+  return result;
+}
+function parseMpTable(bytes) {
+  return total(() => {
+    const reader = new WireReader(bytes);
+    const table = readMpTable(reader);
+    reader.expectEnd();
+    return table;
+  });
+}
+function parsePaMessageBody(message) {
+  return total(() => {
+    const { reader, messageId, version } = readMessageHeader(message);
+    if (messageId !== PA_MESSAGE_ID)
+      return null;
+    const numberOfTables = reader.u8();
+    const entries = [];
+    for (let i = 0; i < numberOfTables; i++) {
+      entries.push({ tableId: reader.u8(), tableVersion: reader.u8(), tableLength: reader.u16() });
+    }
+    const tables = [];
+    const mpTables = [];
+    for (const entry of entries) {
+      const start = reader.offset;
+      const tableId = reader.u8();
+      const tableVersion = reader.u8();
+      const length = reader.u16();
+      if (length === 0)
+        fail("zero table length");
+      reader.bytes(length);
+      const isMpi = tableId >= MPI_TABLE_ID_FIRST && tableId <= MPI_TABLE_ID_LAST;
+      if (tableId !== entry.tableId || tableVersion !== entry.tableVersion || !isMpi && length !== entry.tableLength) {
+        fail("PA extension does not describe its table");
+      }
+      const bytes = message.subarray(start, reader.offset);
+      tables.push({ tableId, version: tableVersion, bytes });
+      if (tableId >= MP_TABLE_ID_SUBSET_0 && tableId <= MP_TABLE_ID_COMPLETE) {
+        const table = parseMpTable(bytes);
+        if (!table)
+          fail("malformed MP table in PA message");
+        mpTables.push(table);
+      }
+    }
+    reader.expectEnd();
+    return { version, tables, mpTables };
+  });
+}
+function parseMptMessageBody(message) {
+  return total(() => {
+    const { reader, messageId, version } = readMessageHeader(message);
+    if (messageId < MPT_MESSAGE_ID_FIRST || messageId > MPT_MESSAGE_ID_COMPLETE)
+      return null;
+    const table = readMpTable(reader);
+    reader.expectEnd();
+    return { messageId, version, table };
+  });
+}
+function decodeSignallingMessage(bytes) {
+  const { messageId, version } = readMessageHeader(bytes);
+  if (messageId === ALFEC_MESSAGE_ID) {
+    const message = parseAlFecMessageBody(bytes);
+    if (!message)
+      fail("malformed AL-FEC message");
+    return { kind: "al-fec", message };
+  }
+  if (messageId === PA_MESSAGE_ID) {
+    const message = parsePaMessageBody(bytes);
+    if (!message)
+      fail("malformed PA message");
+    return { kind: "pa", message };
+  }
+  if (messageId >= MPT_MESSAGE_ID_FIRST && messageId <= MPT_MESSAGE_ID_COMPLETE) {
+    const message = parseMptMessageBody(bytes);
+    if (!message)
+      fail("malformed MPT message");
+    return { kind: "mpt", message };
+  }
+  return { kind: "other", messageId, version, bytes };
+}
+function parseSignallingPacket(mmtpPacket) {
+  const payload = parseSignallingPayload(mmtpPacket);
+  if (!payload)
+    return null;
+  return total(() => ({
+    payloadForm: payload.form,
+    messages: payload.messages.map(decodeSignallingMessage)
+  }));
+}
+
+// ../mmt-base/dist/fec-block-profile.js
+var FEC_BLOCK_PROFILES = Object.freeze([
+  "k-padded-v1",
+  "iso-ssbg1-v1"
+]);
+
+// src/signaling.ts
+function getPacketType(mmtpPacket) {
+  if (mmtpPacket.length < 2) return -1;
+  return mmtpPacket[1] & 63;
+}
+function isSignalingPacket(mmtpPacket) {
+  return getPacketType(mmtpPacket) === PACKET_TYPE_SIGNALING;
+}
+function isSourcePacket(mmtpPacket) {
+  if (mmtpPacket.length < 2) return false;
+  const packetType = mmtpPacket[1] & 63;
+  const fecType = mmtpPacket[0] >> 3 & 3;
+  return packetType === 0 && fecType <= 1;
+}
+function classifyPacket(mmtpPacket) {
+  if (mmtpPacket.length < 2) return "unknown";
+  const packetType = mmtpPacket[1] & 63;
+  const fecType = mmtpPacket[0] >> 3 & 3;
+  if (mmtpPacket[0] >> 6 !== 0) return "unknown";
+  switch (packetType) {
+    case 0:
+      if (mmtpPacket.length < 20) return "unknown";
+      if (fecType >= 2) return "repair";
+      return "source";
+    case 2:
+      return "signaling";
+    case 3:
+      if (mmtpPacket.length < 20) return "unknown";
+      return "repair";
+    default:
+      return "unknown";
+  }
+}
+export {
+  ALFEC_MESSAGE_ID,
+  FEC_CODE_RAPTORQ,
+  FEC_CODE_XOR,
+  PACKET_TYPE_MPU,
+  PACKET_TYPE_REPAIR,
+  PACKET_TYPE_SIGNALING,
+  classifyPacket,
+  getPacketType,
+  isSignalingPacket,
+  isSourcePacket,
+  parseAlFecMessage
+};
+//# sourceMappingURL=signaling.js.map