@hevcjs/shaka-plugin 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Thibaut Lion
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,49 @@
+# @hevcjs/shaka-plugin
+
+> **Status: experimental skeleton.** Package layout, registration, and Shaka Transmuxer interface are in place. The actual HEVC → H.264 conversion is a TODO that will plug into [`@hevcjs/core`](../core).
+
+HEVC/H.265 playback plugin for [Shaka Player](https://github.com/shaka-project/shaka-player). Registers a custom Shaka `Transmuxer` that ingests HEVC fMP4 segments and (eventually) emits H.264 fMP4 that any browser can play via MSE.
+
+Tracks issue [#101](https://github.com/privaloops/hevc.js/issues/101).
+
+## Install
+
+```bash
+npm install @hevcjs/shaka-plugin shaka-player
+```
+
+## Usage (target API)
+
+```js
+import shaka from 'shaka-player';
+import { registerHevcTransmuxer } from '@hevcjs/shaka-plugin';
+
+const cleanup = registerHevcTransmuxer(shaka, {
+  workerUrl: '/transcode-worker.js',
+  wasmUrl:   '/hevc-decode.js',
+});
+
+const player = new shaka.Player();
+await player.attach(document.querySelector('video'));
+await player.load('https://example.com/stream/manifest.mpd');
+
+// later: cleanup();
+```
+
+## How It Works
+
+Shaka exposes a `TransmuxerEngine` that lets plugins convert one container/codec into another before MSE sees the bytes. This package follows the same pattern as Shaka's built-in `AacTransmuxer`:
+
+1. `registerHevcTransmuxer(shaka)` calls `shaka.transmuxer.TransmuxerEngine.registerTransmuxer()` for `video/mp4; codecs="hev1"` and `hvc1`.
+2. When Shaka encounters HEVC content it can't play natively, it instantiates `HevcTransmuxer` and feeds it segments via `transmux(data, stream, reference, duration)`.
+3. The transmuxer decodes HEVC via `@hevcjs/core` (WASM) and re-encodes to H.264 via WebCodecs, returning an MSE-ready fMP4 segment.
+
+## Requirements
+
+- Chrome 94+, Edge 94+, or Firefox with WebCodecs H.264 encoding support
+- Secure Context (HTTPS or localhost)
+- shaka-player >= 4.0.0
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Shaka Player HEVC Plugin — public entry point.
+ *
+ * Usage (main thread, no Worker):
+ * ```ts
+ * import shaka from 'shaka-player';
+ * import { registerHevcTransmuxer } from '@hevcjs/shaka-plugin';
+ *
+ * registerHevcTransmuxer(shaka, { wasmUrl: '/hevc-decode.js' });
+ * const player = new shaka.Player();
+ * await player.attach(videoElement);
+ * await player.load(manifestUrl);
+ * ```
+ *
+ * Usage (off-main-thread via Web Worker — recommended for 4K / smoothness):
+ * ```ts
+ * registerHevcTransmuxer(shaka, {
+ *   wasmUrl: '/hevc-decode.js',
+ *   workerUrl: '/transcode-worker.js',
+ * });
+ * ```
+ *
+ * To force the transmuxer even on browsers with native HEVC support
+ * (Safari, recent Chrome on macOS), use Shaka's built-in config rather
+ * than patching MSE yourself:
+ *
+ * ```ts
+ * player.configure({ mediaSource: { forceTransmux: true } });
+ * ```
+ */
+import type { HevcTransmuxerConfig } from "./transmuxer.js";
+export { HevcTransmuxer } from "./transmuxer.js";
+export type { TransmuxOutput, HevcTransmuxerConfig } from "./transmuxer.js";
+type ShakaNamespace = any;
+/**
+ * Plugin configuration. Forwarded as-is to `HevcTransmuxer`. Supports the
+ * `SegmentTranscoderConfig` fields (`wasmUrl`, `wasmBinaryUrl`, `fps`,
+ * `bitrate`) plus an optional `workerUrl` that, when set, routes the
+ * HEVC decode + H.264 encode pipeline through a Web Worker.
+ */
+export type HevcShakaPluginConfig = HevcTransmuxerConfig;
+/**
+ * Register the HEVC transmuxer with Shaka's TransmuxerEngine.
+ *
+ * Must be called before `player.load()`. Registers a factory for both
+ * `hev1` and `hvc1` MIME types at APPLICATION priority so Shaka picks
+ * our transmuxer over any default fallback.
+ *
+ * @param shaka the global `shaka` namespace (import or window.shaka)
+ * @param config forwarded to `HevcTransmuxer` (wasmUrl, wasmBinaryUrl, fps, bitrate, workerUrl)
+ * @returns A cleanup function that unregisters the transmuxer.
+ */
+export declare function registerHevcTransmuxer(shaka: ShakaNamespace, config?: HevcShakaPluginConfig): () => void;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAGH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAE5D,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACjD,YAAY,EAAE,cAAc,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAG5E,KAAK,cAAc,GAAG,GAAG,CAAC;AAE1B;;;;;GAKG;AACH,MAAM,MAAM,qBAAqB,GAAG,oBAAoB,CAAC;AAOzD;;;;;;;;;;GAUG;AACH,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,cAAc,EACrB,MAAM,GAAE,qBAA0B,GACjC,MAAM,IAAI,CAoCZ"}

package/dist/index.js

@@ -0,0 +1,162 @@
+// src/transmuxer.ts
+import {
+  SegmentTranscoder,
+  TranscodeWorkerClient,
+  hevcMimeToH264Codec
+} from "@hevcjs/core";
+var HEVC_MIME_PATTERN = /^video\/mp4\s*;.*codecs="?(hev1|hvc1)/i;
+var FREE_BOX_8B = new Uint8Array([
+  0,
+  0,
+  0,
+  8,
+  // size = 8
+  102,
+  114,
+  101,
+  101
+  // 'free'
+]);
+function isInitSegment(bytes) {
+  if (bytes.length < 8) return false;
+  const boxType = String.fromCharCode(
+    bytes[4],
+    bytes[5],
+    bytes[6],
+    bytes[7]
+  );
+  return boxType === "ftyp";
+}
+var HevcTransmuxer = class {
+  constructor(mimeType, config = {}) {
+    this.transcoder_ = null;
+    this.initPromise_ = null;
+    this.pendingHevcInit_ = null;
+    this.h264InitEmitted_ = false;
+    this.originalMimeType_ = mimeType;
+    this.transcoderConfig_ = config;
+  }
+  destroy() {
+    this.transcoder_?.destroy();
+    this.transcoder_ = null;
+    this.initPromise_ = null;
+    this.pendingHevcInit_ = null;
+    this.h264InitEmitted_ = false;
+  }
+  isSupported(mimeType, _contentType) {
+    return HEVC_MIME_PATTERN.test(mimeType);
+  }
+  /**
+   * Output mime advertised to Shaka before any frame has been encoded.
+   * Best-effort mapping based on the HEVC level declared in the input
+   * (see `@hevcjs/core/codec-mapping`). The actual encoded stream may
+   * use a slightly different profile/level if `H264Encoder` decides
+   * differently from the encoded resolution.
+   */
+  convertCodecs(_contentType, mimeType) {
+    if (!HEVC_MIME_PATTERN.test(mimeType)) return mimeType;
+    return `video/mp4; codecs="${hevcMimeToH264Codec(mimeType)}"`;
+  }
+  getOriginalMimeType() {
+    return this.originalMimeType_;
+  }
+  /**
+   * Convert one HEVC fMP4 segment into an MSE-ready H.264 fMP4 segment.
+   *
+   * Shaka calls this once per segment with `reference === null` for the
+   * init segment and a non-null `reference` for media segments.
+   *
+   *  - Init segment: warm up the H.264 encoder eagerly (encodes a single
+   *    black frame to obtain a valid avcC) and return a complete H.264
+   *    init segment that MSE can immediately ingest.
+   *  - Media segment: decode HEVC, re-encode to H.264, mux fMP4, return.
+   *
+   * Returns a raw `Uint8Array` rather than `{data, init}` so the same
+   * code path works on Shaka 4.x (which expects a `Uint8Array` directly)
+   * and on Shaka 5+ (which accepts either via an `ArrayBuffer.isView`
+   * check). Init/media segmentation is implicit in the call sequence.
+   */
+  async transmux(data, _stream, reference, _duration, _contentType) {
+    const bytes = toUint8(data);
+    const isInit = reference == null || isInitSegment(bytes);
+    if (!this.transcoder_) {
+      const workerUrl = this.transcoderConfig_.workerUrl;
+      if (workerUrl) {
+        const worker = new TranscodeWorkerClient({
+          ...this.transcoderConfig_,
+          workerUrl
+        });
+        this.transcoder_ = worker;
+        this.initPromise_ = worker.waitReady();
+        console.log(
+          `[hevc.js/shaka] HEVC transcoding routed through Worker at ${workerUrl}`
+        );
+      } else {
+        const local = new SegmentTranscoder(this.transcoderConfig_);
+        this.transcoder_ = local;
+        this.initPromise_ = local.init();
+        console.log(
+          "[hevc.js/shaka] HEVC transcoding runs on main thread (no workerUrl provided)"
+        );
+      }
+    }
+    await this.initPromise_;
+    if (isInit) {
+      const result = await this.transcoder_.prepareInit(bytes);
+      this.h264InitEmitted_ = true;
+      const copy = new Uint8Array(result.initSegment.byteLength);
+      copy.set(result.initSegment);
+      return copy;
+    }
+    const h264Media = await this.transcoder_.processMediaSegment(bytes);
+    if (!h264Media) {
+      return FREE_BOX_8B;
+    }
+    return h264Media;
+  }
+};
+function toUint8(data) {
+  if (data instanceof Uint8Array) return data;
+  if (data instanceof ArrayBuffer) return new Uint8Array(data);
+  return new Uint8Array(
+    data.buffer,
+    data.byteOffset,
+    data.byteLength
+  );
+}
+
+// src/index.ts
+var HEVC_MIME_TYPES = [
+  'video/mp4; codecs="hev1"',
+  'video/mp4; codecs="hvc1"'
+];
+function registerHevcTransmuxer(shaka, config = {}) {
+  const engine = shaka?.transmuxer?.TransmuxerEngine;
+  if (!engine || typeof engine.registerTransmuxer !== "function") {
+    console.warn(
+      "[hevc.js/shaka] shaka.transmuxer.TransmuxerEngine.registerTransmuxer not found. Make sure shaka-player >= 4.0 is loaded before calling registerHevcTransmuxer()."
+    );
+    return () => {
+    };
+  }
+  const priority = engine.PluginPriority?.APPLICATION ?? engine.PluginPriority?.PREFERRED ?? 4;
+  for (const mimeType of HEVC_MIME_TYPES) {
+    engine.registerTransmuxer(
+      mimeType,
+      () => new HevcTransmuxer(mimeType, config),
+      priority
+    );
+  }
+  return () => {
+    if (typeof engine.unregisterTransmuxer === "function") {
+      for (const mimeType of HEVC_MIME_TYPES) {
+        engine.unregisterTransmuxer(mimeType, priority);
+      }
+    }
+  };
+}
+export {
+  HevcTransmuxer,
+  registerHevcTransmuxer
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/transmuxer.ts","../src/index.ts"],"sourcesContent":["/**\n * HEVC Transmuxer for Shaka Player.\n *\n * Implements the `shaka.extern.Transmuxer` interface so Shaka can ingest\n * HEVC/H.265 fMP4 segments on browsers that lack native HEVC support.\n * Uses `@hevcjs/core` SegmentTranscoder to decode HEVC and re-encode to\n * H.264 fMP4 that the browser's MSE can play.\n *\n * Modeled after `lib/transmuxer/aac_transmuxer.js` in shaka-player.\n */\n\nimport {\n  SegmentTranscoder,\n  TranscodeWorkerClient,\n  hevcMimeToH264Codec,\n} from \"@hevcjs/core\";\nimport type { SegmentTranscoderConfig } from \"@hevcjs/core\";\n\n/**\n * Config accepted by `HevcTransmuxer` (and forwarded by `registerHevcTransmuxer`).\n * When `workerUrl` is set, transcoding runs inside a Web Worker; otherwise\n * the HEVC decode + H.264 encode pipeline runs on the main thread.\n */\nexport interface HevcTransmuxerConfig extends SegmentTranscoderConfig {\n  /** URL to the transcode worker script. When set, transcoding runs off main thread. */\n  workerUrl?: string;\n}\n\n// Loose typing while we don't pull `shaka.extern.*` into the build.\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\ntype ShakaStream = any;\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\ntype ShakaSegmentReference = any;\n\n/**\n * Return type of `HevcTransmuxer.transmux`. Compatible with both Shaka 4.x\n * (which expects a raw `Uint8Array` and passes it straight to MSE) and 5+\n * (which checks `ArrayBuffer.isView` and falls back to `{data, init}`\n * when the value is a plain object). Returning a `Uint8Array` is the\n * common subset that works on every supported Shaka version.\n */\nexport type TransmuxOutput = Uint8Array;\n\nconst HEVC_MIME_PATTERN = /^video\\/mp4\\s*;.*codecs=\"?(hev1|hvc1)/i;\n\n/**\n * 8-byte ISO BMFF `free` box (size + type, no payload). Spec-compliant\n * padding that any MP4 parser ignores. Used as a stand-in when we need\n * to return *something* to Shaka but have nothing real to emit yet —\n * `appendBuffer(emptyUint8Array)` throws \"Overload resolution failed\"\n * on Chrome, so we can't return zero-length buffers.\n */\nconst FREE_BOX_8B = new Uint8Array([\n  0, 0, 0, 8,           // size = 8\n  0x66, 0x72, 0x65, 0x65, // 'free'\n]);\n\n/**\n * Sniff whether a buffer starts with an ISO BMFF init segment.\n * Init segments begin with the `ftyp` box; media segments begin with\n * `moof` (or `styp` followed by `moof`).\n *\n * Box header layout: 4 bytes big-endian size, 4 bytes ASCII type.\n */\nexport function isInitSegment(bytes: Uint8Array): boolean {\n  if (bytes.length < 8) return false;\n  const boxType = String.fromCharCode(\n    bytes[4]!,\n    bytes[5]!,\n    bytes[6]!,\n    bytes[7]!,\n  );\n  return boxType === \"ftyp\";\n}\n\nexport class HevcTransmuxer {\n  private readonly originalMimeType_: string;\n  private readonly transcoderConfig_: HevcTransmuxerConfig;\n  private transcoder_: SegmentTranscoder | TranscodeWorkerClient | null = null;\n  private initPromise_: Promise<void> | null = null;\n  private pendingHevcInit_: Uint8Array | null = null;\n  private h264InitEmitted_ = false;\n\n  constructor(mimeType: string, config: HevcTransmuxerConfig = {}) {\n    this.originalMimeType_ = mimeType;\n    this.transcoderConfig_ = config;\n  }\n\n  destroy(): void {\n    this.transcoder_?.destroy();\n    this.transcoder_ = null;\n    this.initPromise_ = null;\n    this.pendingHevcInit_ = null;\n    this.h264InitEmitted_ = false;\n  }\n\n  isSupported(mimeType: string, _contentType?: string): boolean {\n    return HEVC_MIME_PATTERN.test(mimeType);\n  }\n\n  /**\n   * Output mime advertised to Shaka before any frame has been encoded.\n   * Best-effort mapping based on the HEVC level declared in the input\n   * (see `@hevcjs/core/codec-mapping`). The actual encoded stream may\n   * use a slightly different profile/level if `H264Encoder` decides\n   * differently from the encoded resolution.\n   */\n  convertCodecs(_contentType: string, mimeType: string): string {\n    if (!HEVC_MIME_PATTERN.test(mimeType)) return mimeType;\n    return `video/mp4; codecs=\"${hevcMimeToH264Codec(mimeType)}\"`;\n  }\n\n  getOriginalMimeType(): string {\n    return this.originalMimeType_;\n  }\n\n  /**\n   * Convert one HEVC fMP4 segment into an MSE-ready H.264 fMP4 segment.\n   *\n   * Shaka calls this once per segment with `reference === null` for the\n   * init segment and a non-null `reference` for media segments.\n   *\n   *  - Init segment: warm up the H.264 encoder eagerly (encodes a single\n   *    black frame to obtain a valid avcC) and return a complete H.264\n   *    init segment that MSE can immediately ingest.\n   *  - Media segment: decode HEVC, re-encode to H.264, mux fMP4, return.\n   *\n   * Returns a raw `Uint8Array` rather than `{data, init}` so the same\n   * code path works on Shaka 4.x (which expects a `Uint8Array` directly)\n   * and on Shaka 5+ (which accepts either via an `ArrayBuffer.isView`\n   * check). Init/media segmentation is implicit in the call sequence.\n   */\n  async transmux(\n    data: BufferSource,\n    _stream: ShakaStream,\n    reference: ShakaSegmentReference,\n    _duration: number,\n    _contentType: string,\n  ): Promise<TransmuxOutput> {\n    const bytes = toUint8(data);\n    const isInit = reference == null || isInitSegment(bytes);\n\n    if (!this.transcoder_) {\n      const workerUrl = this.transcoderConfig_.workerUrl;\n      if (workerUrl) {\n        const worker = new TranscodeWorkerClient({\n          ...this.transcoderConfig_,\n          workerUrl,\n        });\n        this.transcoder_ = worker;\n        this.initPromise_ = worker.waitReady();\n        console.log(\n          `[hevc.js/shaka] HEVC transcoding routed through Worker at ${workerUrl}`,\n        );\n      } else {\n        const local = new SegmentTranscoder(this.transcoderConfig_);\n        this.transcoder_ = local;\n        this.initPromise_ = local.init();\n        console.log(\n          \"[hevc.js/shaka] HEVC transcoding runs on main thread (no workerUrl provided)\",\n        );\n      }\n    }\n    await this.initPromise_;\n\n    if (isInit) {\n      const result = await this.transcoder_!.prepareInit(bytes);\n      this.h264InitEmitted_ = true;\n      // Defensive copy: avoids any risk of the underlying ArrayBuffer being\n      // detached or mutated between this return and the eventual MSE append.\n      const copy = new Uint8Array(result.initSegment.byteLength);\n      copy.set(result.initSegment);\n      return copy;\n    }\n\n    const h264Media = await this.transcoder_!.processMediaSegment(bytes);\n    if (!h264Media) {\n      // No frames produced (e.g. drop frames in adaptive switching). Emit\n      // a spec-valid `free` box of 8 bytes — empty buffers crash Chrome's\n      // appendBuffer with \"Overload resolution failed\".\n      return FREE_BOX_8B;\n    }\n    return h264Media;\n  }\n}\n\nfunction toUint8(data: BufferSource): Uint8Array {\n  if (data instanceof Uint8Array) return data;\n  if (data instanceof ArrayBuffer) return new Uint8Array(data);\n  return new Uint8Array(\n    (data as ArrayBufferView).buffer,\n    (data as ArrayBufferView).byteOffset,\n    (data as ArrayBufferView).byteLength,\n  );\n}\n","/**\n * Shaka Player HEVC Plugin — public entry point.\n *\n * Usage (main thread, no Worker):\n * ```ts\n * import shaka from 'shaka-player';\n * import { registerHevcTransmuxer } from '@hevcjs/shaka-plugin';\n *\n * registerHevcTransmuxer(shaka, { wasmUrl: '/hevc-decode.js' });\n * const player = new shaka.Player();\n * await player.attach(videoElement);\n * await player.load(manifestUrl);\n * ```\n *\n * Usage (off-main-thread via Web Worker — recommended for 4K / smoothness):\n * ```ts\n * registerHevcTransmuxer(shaka, {\n *   wasmUrl: '/hevc-decode.js',\n *   workerUrl: '/transcode-worker.js',\n * });\n * ```\n *\n * To force the transmuxer even on browsers with native HEVC support\n * (Safari, recent Chrome on macOS), use Shaka's built-in config rather\n * than patching MSE yourself:\n *\n * ```ts\n * player.configure({ mediaSource: { forceTransmux: true } });\n * ```\n */\n\nimport { HevcTransmuxer } from \"./transmuxer.js\";\nimport type { HevcTransmuxerConfig } from \"./transmuxer.js\";\n\nexport { HevcTransmuxer } from \"./transmuxer.js\";\nexport type { TransmuxOutput, HevcTransmuxerConfig } from \"./transmuxer.js\";\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\ntype ShakaNamespace = any;\n\n/**\n * Plugin configuration. Forwarded as-is to `HevcTransmuxer`. Supports the\n * `SegmentTranscoderConfig` fields (`wasmUrl`, `wasmBinaryUrl`, `fps`,\n * `bitrate`) plus an optional `workerUrl` that, when set, routes the\n * HEVC decode + H.264 encode pipeline through a Web Worker.\n */\nexport type HevcShakaPluginConfig = HevcTransmuxerConfig;\n\nconst HEVC_MIME_TYPES = [\n  'video/mp4; codecs=\"hev1\"',\n  'video/mp4; codecs=\"hvc1\"',\n];\n\n/**\n * Register the HEVC transmuxer with Shaka's TransmuxerEngine.\n *\n * Must be called before `player.load()`. Registers a factory for both\n * `hev1` and `hvc1` MIME types at APPLICATION priority so Shaka picks\n * our transmuxer over any default fallback.\n *\n * @param shaka the global `shaka` namespace (import or window.shaka)\n * @param config forwarded to `HevcTransmuxer` (wasmUrl, wasmBinaryUrl, fps, bitrate, workerUrl)\n * @returns A cleanup function that unregisters the transmuxer.\n */\nexport function registerHevcTransmuxer(\n  shaka: ShakaNamespace,\n  config: HevcShakaPluginConfig = {},\n): () => void {\n  const engine = shaka?.transmuxer?.TransmuxerEngine;\n  if (!engine || typeof engine.registerTransmuxer !== \"function\") {\n    console.warn(\n      \"[hevc.js/shaka] shaka.transmuxer.TransmuxerEngine.registerTransmuxer not found. \" +\n        \"Make sure shaka-player >= 4.0 is loaded before calling registerHevcTransmuxer().\",\n    );\n    return () => {};\n  }\n\n  // External (application-supplied) plugins should register at the\n  // APPLICATION priority so they override any built-in fallback. Values in\n  // shaka.transmuxer.TransmuxerEngine.PluginPriority: FALLBACK=1,\n  // PREFERRED_SECONDARY=2, PREFERRED=3, APPLICATION=4.\n  const priority =\n    engine.PluginPriority?.APPLICATION ??\n    engine.PluginPriority?.PREFERRED ??\n    4;\n\n  for (const mimeType of HEVC_MIME_TYPES) {\n    engine.registerTransmuxer(\n      mimeType,\n      () => new HevcTransmuxer(mimeType, config),\n      priority,\n    );\n  }\n\n  return () => {\n    if (typeof engine.unregisterTransmuxer === \"function\") {\n      for (const mimeType of HEVC_MIME_TYPES) {\n        // unregisterTransmuxer keys on `${mime}-${priority}` so the\n        // priority used at register time must be passed back here.\n        engine.unregisterTransmuxer(mimeType, priority);\n      }\n    }\n  };\n}\n"],"mappings":"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","names":[]}

package/dist/transmuxer.d.ts

@@ -0,0 +1,77 @@
+/**
+ * HEVC Transmuxer for Shaka Player.
+ *
+ * Implements the `shaka.extern.Transmuxer` interface so Shaka can ingest
+ * HEVC/H.265 fMP4 segments on browsers that lack native HEVC support.
+ * Uses `@hevcjs/core` SegmentTranscoder to decode HEVC and re-encode to
+ * H.264 fMP4 that the browser's MSE can play.
+ *
+ * Modeled after `lib/transmuxer/aac_transmuxer.js` in shaka-player.
+ */
+import type { SegmentTranscoderConfig } from "@hevcjs/core";
+/**
+ * Config accepted by `HevcTransmuxer` (and forwarded by `registerHevcTransmuxer`).
+ * When `workerUrl` is set, transcoding runs inside a Web Worker; otherwise
+ * the HEVC decode + H.264 encode pipeline runs on the main thread.
+ */
+export interface HevcTransmuxerConfig extends SegmentTranscoderConfig {
+    /** URL to the transcode worker script. When set, transcoding runs off main thread. */
+    workerUrl?: string;
+}
+type ShakaStream = any;
+type ShakaSegmentReference = any;
+/**
+ * Return type of `HevcTransmuxer.transmux`. Compatible with both Shaka 4.x
+ * (which expects a raw `Uint8Array` and passes it straight to MSE) and 5+
+ * (which checks `ArrayBuffer.isView` and falls back to `{data, init}`
+ * when the value is a plain object). Returning a `Uint8Array` is the
+ * common subset that works on every supported Shaka version.
+ */
+export type TransmuxOutput = Uint8Array;
+/**
+ * Sniff whether a buffer starts with an ISO BMFF init segment.
+ * Init segments begin with the `ftyp` box; media segments begin with
+ * `moof` (or `styp` followed by `moof`).
+ *
+ * Box header layout: 4 bytes big-endian size, 4 bytes ASCII type.
+ */
+export declare function isInitSegment(bytes: Uint8Array): boolean;
+export declare class HevcTransmuxer {
+    private readonly originalMimeType_;
+    private readonly transcoderConfig_;
+    private transcoder_;
+    private initPromise_;
+    private pendingHevcInit_;
+    private h264InitEmitted_;
+    constructor(mimeType: string, config?: HevcTransmuxerConfig);
+    destroy(): void;
+    isSupported(mimeType: string, _contentType?: string): boolean;
+    /**
+     * Output mime advertised to Shaka before any frame has been encoded.
+     * Best-effort mapping based on the HEVC level declared in the input
+     * (see `@hevcjs/core/codec-mapping`). The actual encoded stream may
+     * use a slightly different profile/level if `H264Encoder` decides
+     * differently from the encoded resolution.
+     */
+    convertCodecs(_contentType: string, mimeType: string): string;
+    getOriginalMimeType(): string;
+    /**
+     * Convert one HEVC fMP4 segment into an MSE-ready H.264 fMP4 segment.
+     *
+     * Shaka calls this once per segment with `reference === null` for the
+     * init segment and a non-null `reference` for media segments.
+     *
+     *  - Init segment: warm up the H.264 encoder eagerly (encodes a single
+     *    black frame to obtain a valid avcC) and return a complete H.264
+     *    init segment that MSE can immediately ingest.
+     *  - Media segment: decode HEVC, re-encode to H.264, mux fMP4, return.
+     *
+     * Returns a raw `Uint8Array` rather than `{data, init}` so the same
+     * code path works on Shaka 4.x (which expects a `Uint8Array` directly)
+     * and on Shaka 5+ (which accepts either via an `ArrayBuffer.isView`
+     * check). Init/media segmentation is implicit in the call sequence.
+     */
+    transmux(data: BufferSource, _stream: ShakaStream, reference: ShakaSegmentReference, _duration: number, _contentType: string): Promise<TransmuxOutput>;
+}
+export {};
+//# sourceMappingURL=transmuxer.d.ts.map

package/dist/transmuxer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transmuxer.d.ts","sourceRoot":"","sources":["../src/transmuxer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAOH,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,cAAc,CAAC;AAE5D;;;;GAIG;AACH,MAAM,WAAW,oBAAqB,SAAQ,uBAAuB;IACnE,sFAAsF;IACtF,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAID,KAAK,WAAW,GAAG,GAAG,CAAC;AAEvB,KAAK,qBAAqB,GAAG,GAAG,CAAC;AAEjC;;;;;;GAMG;AACH,MAAM,MAAM,cAAc,GAAG,UAAU,CAAC;AAgBxC;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CASxD;AAED,qBAAa,cAAc;IACzB,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAS;IAC3C,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAuB;IACzD,OAAO,CAAC,WAAW,CAA0D;IAC7E,OAAO,CAAC,YAAY,CAA8B;IAClD,OAAO,CAAC,gBAAgB,CAA2B;IACnD,OAAO,CAAC,gBAAgB,CAAS;gBAErB,QAAQ,EAAE,MAAM,EAAE,MAAM,GAAE,oBAAyB;IAK/D,OAAO,IAAI,IAAI;IAQf,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,MAAM,GAAG,OAAO;IAI7D;;;;;;OAMG;IACH,aAAa,CAAC,YAAY,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM;IAK7D,mBAAmB,IAAI,MAAM;IAI7B;;;;;;;;;;;;;;;OAeG;IACG,QAAQ,CACZ,IAAI,EAAE,YAAY,EAClB,OAAO,EAAE,WAAW,EACpB,SAAS,EAAE,qBAAqB,EAChC,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,MAAM,GACnB,OAAO,CAAC,cAAc,CAAC;CA8C3B"}

package/package.json

@@ -0,0 +1,73 @@
+{
+  "name": "@hevcjs/shaka-plugin",
+  "version": "0.2.0",
+  "description": "Shaka Player plugin for HEVC/H.265 playback — registers a Shaka Transmuxer that decodes HEVC streams via @hevcjs/core",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist/",
+    "README.md"
+  ],
+  "keywords": [
+    "hevc",
+    "h265",
+    "h.265",
+    "webassembly",
+    "wasm",
+    "codec",
+    "video",
+    "browser",
+    "streaming",
+    "shaka",
+    "shaka-player",
+    "shaka-plugin",
+    "transmuxer",
+    "dash",
+    "hls",
+    "mse",
+    "mediasource",
+    "ott",
+    "media-source-extensions"
+  ],
+  "author": "privaloops",
+  "license": "MIT",
+  "homepage": "https://hevcjs.dev",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/privaloops/hevc.js.git",
+    "directory": "packages/shaka-plugin"
+  },
+  "bugs": {
+    "url": "https://github.com/privaloops/hevc.js/issues"
+  },
+  "dependencies": {
+    "@hevcjs/core": "1.2.0"
+  },
+  "peerDependencies": {
+    "shaka-player": ">=4.0.0"
+  },
+  "peerDependenciesMeta": {
+    "shaka-player": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "shaka-player": "^4.11.0",
+    "tsup": "^8.0.0",
+    "typescript": "^6.0.3",
+    "vitest": "^3.0.0"
+  },
+  "scripts": {
+    "build": "tsup && tsc -p tsconfig.build.json",
+    "dev": "tsup --watch",
+    "test": "vitest run"
+  }
+}