Parse EXT-X-KEY

Author: matvp91

apps/stitcher/src/parser/helpers.ts

@@ -57,3 +57,32 @@ function splitByCommaWithPreservingQuotes(str: string) {
 
   return list;
 }
+
+export function hexToByteSequence(str: string): Uint8Array {
+  if (str.startsWith("0x") || str.startsWith("0X")) {
+    str = str.slice(2);
+  }
+  const numArray = new Uint8Array(str.length / 2);
+  for (let i = 0; i < str.length; i += 2) {
+    numArray[i / 2] = Number.parseInt(str.slice(i, i + 2), 16);
+  }
+  return numArray;
+}
+
+export function byteSequenceToHex(
+  sequence: Uint8Array,
+  start = 0,
+  end = sequence.byteLength,
+) {
+  if (end <= start) {
+    throw new Error("End must be larger than start");
+  }
+  const list: string[] = [];
+  for (let i = start; i < end; i++) {
+    const chunk = sequence[i];
+    if (chunk !== undefined) {
+      list.push(`0${(chunk & 0xff).toString(16).toUpperCase()}`.slice(-2));
+    }
+  }
+  return `0x${list.join("")}`;
+}

apps/stitcher/src/parser/lexical-parse.ts

@@ -1,8 +1,9 @@
 import { DateTime } from "luxon";
 import { assert } from "shared/assert";
-import { mapAttributes, partOf } from "./helpers";
+import { hexToByteSequence, mapAttributes, partOf } from "./helpers";
 import type {
   DateRange,
+  Key,
   MediaInitializationSection,
   PlaylistType,
   Resolution,
@@ -42,7 +43,8 @@ export type Tag =
   | ["EXT-X-MEDIA", Media]
   | ["EXT-X-MAP", MediaInitializationSection]
   | ["EXT-X-DATERANGE", DateRange]
-  | ["EXT-X-CUE-OUT", CueOut];
+  | ["EXT-X-CUE-OUT", CueOut]
+  | ["EXT-X-KEY", Key];
 
 export interface ExtInf {
   duration: number;
@@ -311,11 +313,53 @@ function parseLine(line: string): Tag | null {
       ];
     }
 
+    case "EXT-X-KEY": {
+      assert(param, "EXT-X-KEY: no param");
+
+      const attrs: Partial<Key> = {};
+
+      mapAttributes(param, (key, value) => {
+        switch (key) {
+          case "METHOD":
+          case "URI":
+          case "KEYFORMAT":
+          case "KEYFORMATVERSION":
+            attrs.method = value;
+            break;
+
+          case "IV":
+            attrs.iv = parseIV(value);
+            break;
+        }
+      });
+
+      assert(attrs.method, "EXT-X-KEY: no method");
+
+      return [
+        name,
+        {
+          method: attrs.method,
+          uri: attrs.uri,
+          iv: attrs.iv,
+          format: attrs.format,
+          formatVersion: attrs.formatVersion,
+        },
+      ];
+    }
+
     default:
       return null;
   }
 }
 
+function parseIV(value: string) {
+  const iv = hexToByteSequence(value);
+  if (iv.length !== 16) {
+    throw new Error("IV must be a 128-bit unsigned integer");
+  }
+  return iv;
+}
+
 function splitLine(line: string): [string, string | null] {
   const index = line.indexOf(":");
   if (index === -1) {

apps/stitcher/src/parser/parse.ts

@@ -3,6 +3,7 @@ import { lexicalParse } from "./lexical-parse";
 import type { Tag } from "./lexical-parse";
 import type {
   DateRange,
+  Key,
   MasterPlaylist,
   MediaInitializationSection,
   MediaPlaylist,
@@ -90,12 +91,18 @@ function formatMediaPlaylist(tags: Tag[]): MediaPlaylist {
   let segmentStart = -1;
 
   let map: MediaInitializationSection | undefined;
+  let key: Key | undefined;
   tags.forEach(([name, value], index) => {
     if (name === "EXT-X-MAP") {
       // TODO: We might be better off passing on segments to |parseSegment| and look up
       // the last valid map.
       map = value;
     }
+    if (name === "EXT-X-KEY") {
+      // TODO: We might be better off passing on segments to |parseSegment| and look up
+      // the last valid key.
+      key = value;
+    }
 
     // TODO: When we have EXT-X-KEY support, we're better off passing a full list of segments
     // to |parseSegment|, maybe?
@@ -114,7 +121,7 @@ function formatMediaPlaylist(tags: Tag[]): MediaPlaylist {
       const segmentTags = tags.slice(segmentStart, index + 1);
       const uri = nextLiteral(segmentTags, segmentTags.length - 2);
 
-      const segment = parseSegment(segmentTags, uri, map);
+      const segment = parseSegment(segmentTags, uri, map, key);
       segments.push(segment);
 
       segmentStart = -1;
@@ -164,6 +171,7 @@ function isSegmentTag(name: Tag[0]) {
     case "EXT-X-MAP":
     case "EXT-X-CUE-OUT":
     case "EXT-X-CUE-IN":
+    case "EXT-X-KEY":
       return true;
   }
   return false;
@@ -173,6 +181,7 @@ function parseSegment(
   tags: Tag[],
   uri: string,
   map?: MediaInitializationSection,
+  key?: Key,
 ): Segment {
   let duration: number | undefined;
   let discontinuity: boolean | undefined;
@@ -204,6 +213,7 @@ function parseSegment(
     duration,
     discontinuity,
     map,
+    key,
     programDateTime,
     spliceInfo,
   };

apps/stitcher/src/parser/stringify.ts

@@ -1,4 +1,6 @@
+import { byteSequenceToHex } from "./helpers";
 import type {
+  Key,
   MasterPlaylist,
   MediaInitializationSection,
   MediaPlaylist,
@@ -99,6 +101,7 @@ export function stringifyMediaPlaylist(playlist: MediaPlaylist) {
   }
 
   let lastMap: MediaInitializationSection | undefined;
+  let lastKey: Key | undefined;
 
   playlist.segments.forEach((segment) => {
     // See https://datatracker.ietf.org/doc/html/draft-pantos-hls-rfc8216bis-16#section-4.4.4.5
@@ -111,6 +114,25 @@ export function stringifyMediaPlaylist(playlist: MediaPlaylist) {
       }
       lastMap = segment.map;
     }
+    if (segment.key !== lastKey) {
+      if (segment.key) {
+        const attrs = [`METHOD=${segment.key.method}`];
+        if (segment.key.uri) {
+          attrs.push(`URI="${segment.key.uri}"`);
+        }
+        if (segment.key.iv) {
+          attrs.push(`IV=${byteSequenceToHex(segment.key.iv)}`);
+        }
+        if (segment.key.format) {
+          attrs.push(`KEYFORMAT="${segment.key.format}"`);
+        }
+        if (segment.key.formatVersion) {
+          attrs.push(`KEYFORMATVERSIONS="${segment.key.formatVersion}"`);
+        }
+        lines.push(`#EXT-X-KEY:${attrs.join(",")}`);
+      }
+      lastKey = segment.key;
+    }
 
     if (segment.discontinuity) {
       lines.push(`#EXT-X-DISCONTINUITY`);

apps/stitcher/src/parser/types.ts

@@ -38,6 +38,7 @@ export interface Segment {
   duration: number;
   discontinuity?: boolean;
   map?: MediaInitializationSection;
+  key?: Key;
   programDateTime?: DateTime;
   spliceInfo?: SpliceInfo;
 }
@@ -49,6 +50,14 @@ export interface SpliceInfo {
 
 export type PlaylistType = "EVENT" | "VOD";
 
+export interface Key {
+  method: string;
+  uri?: string;
+  iv?: Uint8Array;
+  format?: string;
+  formatVersion?: string;
+}
+
 export interface MediaPlaylist {
   independentSegments?: boolean;
   targetDuration: number;