taglib-wasm 1.1.1 → 1.2.0

package/dist/simple.browser.js

@@ -88,6 +88,20 @@ var init_pictures = __esm({
   }
 });
 
+// src/types/chapters.ts
+var init_chapters = __esm({
+  "src/types/chapters.ts"() {
+    "use strict";
+  }
+});
+
+// src/types/bwf.ts
+var init_bwf = __esm({
+  "src/types/bwf.ts"() {
+    "use strict";
+  }
+});
+
 // src/types/config.ts
 var init_config = __esm({
   "src/types/config.ts"() {
@@ -110,6 +124,8 @@ var init_types = __esm({
     init_tags();
     init_metadata_mappings();
     init_pictures();
+    init_chapters();
+    init_bwf();
     init_config();
     init_format_property_keys();
   }
@@ -123,6 +139,136 @@ var init_types2 = __esm({
   }
 });
 
+// src/bwf/bext.ts
+function readFixedString(bytes, offset, len) {
+  let end = offset;
+  const max = Math.min(offset + len, bytes.length);
+  while (end < max && bytes[end] !== 0) end++;
+  let s = "";
+  for (let i = offset; i < end; i++) s += String.fromCharCode(bytes[i]);
+  return s;
+}
+function writeFixedString(bytes, offset, len, value) {
+  for (let i = 0; i < len; i++) {
+    bytes[offset + i] = i < value.length ? value.charCodeAt(i) & 255 : 0;
+  }
+}
+function clampInt16(n) {
+  return Math.max(-32768, Math.min(32767, Math.round(n)));
+}
+function loudnessRaw(v) {
+  return v === void 0 ? LOUDNESS_UNSET : clampInt16(v * 100);
+}
+function loudnessFromRaw(raw) {
+  return raw === LOUDNESS_UNSET ? void 0 : raw / 100;
+}
+function bytesToHex(bytes) {
+  let s = "";
+  for (const b of bytes) s += b.toString(16).padStart(2, "0");
+  return s;
+}
+function hexToBytes(hex, outLen) {
+  const clean = hex.replace(/[^0-9a-fA-F]/g, "");
+  const out = new Uint8Array(outLen);
+  for (let i = 0; i + 1 < clean.length + 1 && i / 2 < outLen; i += 2) {
+    const pair = clean.slice(i, i + 2);
+    if (pair.length === 2) out[i / 2] = parseInt(pair, 16);
+  }
+  return out;
+}
+function decodeBext(bytes) {
+  if (bytes.length < VERSION_OFFSET + 2) return void 0;
+  const dv = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const timeRefLow = dv.getUint32(338, true);
+  const timeRefHigh = dv.getUint32(342, true);
+  const version = dv.getUint16(VERSION_OFFSET, true);
+  const result = {
+    description: readFixedString(bytes, 0, 256),
+    originator: readFixedString(bytes, 256, 32),
+    originatorReference: readFixedString(bytes, 288, 32),
+    originationDate: readFixedString(bytes, 320, 10),
+    originationTime: readFixedString(bytes, 330, 8),
+    timeReferenceSamples: BigInt(timeRefHigh) << 32n | BigInt(timeRefLow),
+    version,
+    codingHistory: bytes.length > FIXED_PREFIX_LEN ? readFixedString(
+      bytes,
+      FIXED_PREFIX_LEN,
+      bytes.length - FIXED_PREFIX_LEN
+    ) : ""
+  };
+  if (version >= 1 && bytes.length >= UMID_OFFSET + UMID_LEN) {
+    result.umid = bytesToHex(
+      bytes.subarray(UMID_OFFSET, UMID_OFFSET + UMID_LEN)
+    );
+  }
+  if (version >= 2 && bytes.length >= LOUDNESS_OFFSET + 10) {
+    const lv = loudnessFromRaw(dv.getInt16(LOUDNESS_OFFSET, true));
+    const lr = loudnessFromRaw(dv.getInt16(LOUDNESS_OFFSET + 2, true));
+    const mtp = loudnessFromRaw(dv.getInt16(LOUDNESS_OFFSET + 4, true));
+    const mml = loudnessFromRaw(dv.getInt16(LOUDNESS_OFFSET + 6, true));
+    const msl = loudnessFromRaw(dv.getInt16(LOUDNESS_OFFSET + 8, true));
+    if (lv !== void 0) result.loudnessValueDb = lv;
+    if (lr !== void 0) result.loudnessRangeDb = lr;
+    if (mtp !== void 0) result.maxTruePeakLevelDbtp = mtp;
+    if (mml !== void 0) result.maxMomentaryLoudnessDb = mml;
+    if (msl !== void 0) result.maxShortTermLoudnessDb = msl;
+  }
+  return result;
+}
+function encodeBext(b) {
+  const codingHistory = b.codingHistory ?? "";
+  const bytes = new Uint8Array(FIXED_PREFIX_LEN + codingHistory.length);
+  const dv = new DataView(bytes.buffer);
+  const hasLoudness = b.loudnessValueDb !== void 0 || b.loudnessRangeDb !== void 0 || b.maxTruePeakLevelDbtp !== void 0 || b.maxMomentaryLoudnessDb !== void 0 || b.maxShortTermLoudnessDb !== void 0;
+  const version = Number.isInteger(b.version) ? b.version : hasLoudness ? 2 : b.umid ? 1 : 0;
+  writeFixedString(bytes, 0, 256, b.description ?? "");
+  writeFixedString(bytes, 256, 32, b.originator ?? "");
+  writeFixedString(bytes, 288, 32, b.originatorReference ?? "");
+  writeFixedString(bytes, 320, 10, b.originationDate ?? "");
+  writeFixedString(bytes, 330, 8, b.originationTime ?? "");
+  const tr = b.timeReferenceSamples ?? 0n;
+  dv.setUint32(338, Number(tr & 0xffffffffn), true);
+  dv.setUint32(342, Number(tr >> 32n & 0xffffffffn), true);
+  dv.setUint16(VERSION_OFFSET, version, true);
+  if (version >= 1 && b.umid) {
+    bytes.set(hexToBytes(b.umid, UMID_LEN), UMID_OFFSET);
+  }
+  if (version >= 2) {
+    dv.setInt16(LOUDNESS_OFFSET, loudnessRaw(b.loudnessValueDb), true);
+    dv.setInt16(LOUDNESS_OFFSET + 2, loudnessRaw(b.loudnessRangeDb), true);
+    dv.setInt16(LOUDNESS_OFFSET + 4, loudnessRaw(b.maxTruePeakLevelDbtp), true);
+    dv.setInt16(
+      LOUDNESS_OFFSET + 6,
+      loudnessRaw(b.maxMomentaryLoudnessDb),
+      true
+    );
+    dv.setInt16(
+      LOUDNESS_OFFSET + 8,
+      loudnessRaw(b.maxShortTermLoudnessDb),
+      true
+    );
+  }
+  writeFixedString(
+    bytes,
+    FIXED_PREFIX_LEN,
+    codingHistory.length,
+    codingHistory
+  );
+  return bytes;
+}
+var FIXED_PREFIX_LEN, VERSION_OFFSET, UMID_OFFSET, UMID_LEN, LOUDNESS_OFFSET, LOUDNESS_UNSET;
+var init_bext = __esm({
+  "src/bwf/bext.ts"() {
+    "use strict";
+    FIXED_PREFIX_LEN = 602;
+    VERSION_OFFSET = 346;
+    UMID_OFFSET = 348;
+    UMID_LEN = 64;
+    LOUDNESS_OFFSET = 412;
+    LOUDNESS_UNSET = 32767;
+  }
+});
+
 // src/errors/base.ts
 var SUPPORTED_FORMATS, TagLibError;
 var init_base = __esm({
@@ -365,6 +511,47 @@ var init_errors2 = __esm({
   }
 });
 
+// src/taglib/audio-file-bwf.ts
+function requireBwf(format) {
+  if (!BWF_FORMATS.has(format)) {
+    throw new UnsupportedFormatError(format, ["WAV", "FLAC"], {
+      operation: "BWF metadata"
+    });
+  }
+}
+function getBextData(handle) {
+  const raw = handle.getBextData();
+  return raw && raw.length > 0 ? raw : void 0;
+}
+function setBextData(handle, format, data) {
+  requireBwf(format);
+  handle.setBextData(data);
+}
+function getBext(handle) {
+  const raw = handle.getBextData();
+  return raw && raw.length > 0 ? decodeBext(raw) : void 0;
+}
+function setBext(handle, format, bext) {
+  requireBwf(format);
+  handle.setBextData(encodeBext(bext));
+}
+function getIxml(handle) {
+  return handle.getIxml();
+}
+function setIxml(handle, format, data) {
+  requireBwf(format);
+  handle.setIxml(data);
+}
+var BWF_FORMATS;
+var init_audio_file_bwf = __esm({
+  "src/taglib/audio-file-bwf.ts"() {
+    "use strict";
+    init_bext();
+    init_errors2();
+    BWF_FORMATS = /* @__PURE__ */ new Set(["WAV", "FLAC"]);
+  }
+});
+
 // browser-stub:platform-io-browser-stub
 function getPlatformIO() {
   throw new Error("Filesystem operations are not available in the browser.");
@@ -1222,61 +1409,63 @@ var init_audio_file_base = __esm({
         return this.getFormat() === format;
       }
       tag() {
-        const tagWrapper = this.handle.getTag();
-        if (!tagWrapper) {
-          throw new MetadataError(
-            "read",
-            "Tag may be corrupted or format not fully supported"
-          );
-        }
+        const handle = this.handle;
+        let data = handle.getTagData();
         const tag = {
           get title() {
-            return tagWrapper.title();
+            return data.title;
           },
           get artist() {
-            return tagWrapper.artist();
+            return data.artist;
           },
           get album() {
-            return tagWrapper.album();
+            return data.album;
           },
           get comment() {
-            return tagWrapper.comment();
+            return data.comment;
           },
           get genre() {
-            return tagWrapper.genre();
+            return data.genre;
           },
           get year() {
-            return tagWrapper.year();
+            return data.year;
           },
           get track() {
-            return tagWrapper.track();
+            return data.track;
           },
           setTitle: (value) => {
-            tagWrapper.setTitle(value);
+            handle.setTagData({ title: value });
+            data = handle.getTagData();
             return tag;
           },
           setArtist: (value) => {
-            tagWrapper.setArtist(value);
+            handle.setTagData({ artist: value });
+            data = handle.getTagData();
             return tag;
           },
           setAlbum: (value) => {
-            tagWrapper.setAlbum(value);
+            handle.setTagData({ album: value });
+            data = handle.getTagData();
             return tag;
           },
           setComment: (value) => {
-            tagWrapper.setComment(value);
+            handle.setTagData({ comment: value });
+            data = handle.getTagData();
             return tag;
           },
           setGenre: (value) => {
-            tagWrapper.setGenre(value);
+            handle.setTagData({ genre: value });
+            data = handle.getTagData();
             return tag;
           },
           setYear: (value) => {
-            tagWrapper.setYear(value);
+            handle.setTagData({ year: value });
+            data = handle.getTagData();
             return tag;
           },
           setTrack: (value) => {
-            tagWrapper.setTrack(value);
+            handle.setTagData({ track: value });
+            data = handle.getTagData();
             return tag;
           }
         };
@@ -1284,28 +1473,9 @@ var init_audio_file_base = __esm({
       }
       audioProperties() {
         if (!this.cachedAudioProperties) {
-          const propsWrapper = this.handle.getAudioProperties();
-          if (!propsWrapper) {
-            return void 0;
-          }
-          const containerFormat = propsWrapper.containerFormat() || "unknown";
-          const mpegVersion = propsWrapper.mpegVersion();
-          const formatVersion = propsWrapper.formatVersion();
-          this.cachedAudioProperties = {
-            duration: propsWrapper.lengthInSeconds(),
-            bitrate: propsWrapper.bitrate(),
-            sampleRate: propsWrapper.sampleRate(),
-            channels: propsWrapper.channels(),
-            bitsPerSample: propsWrapper.bitsPerSample(),
-            codec: propsWrapper.codec() || "unknown",
-            containerFormat,
-            isLossless: propsWrapper.isLossless(),
-            ...mpegVersion > 0 ? { mpegVersion, mpegLayer: propsWrapper.mpegLayer() } : {},
-            ...containerFormat === "MP4" || containerFormat === "ASF" ? { isEncrypted: propsWrapper.isEncrypted() } : {},
-            ...formatVersion > 0 ? { formatVersion } : {}
-          };
+          this.cachedAudioProperties = this.handle.getAudioProperties() ?? null;
         }
-        return this.cachedAudioProperties;
+        return this.cachedAudioProperties ?? void 0;
       }
       properties() {
         return remapKeysFromTagLib(this.handle.getProperties());
@@ -1363,7 +1533,102 @@ var init_audio_file_base = __esm({
   }
 });
 
+// src/taglib/embind-adapter.ts
+function isValidBitrateMode(value) {
+  return value === "CBR" || value === "VBR" || value === "ABR";
+}
+function wrapEmbindHandle(raw) {
+  const overrides = {
+    getTagData() {
+      const tw = raw.getTag();
+      return {
+        title: tw.title(),
+        artist: tw.artist(),
+        album: tw.album(),
+        comment: tw.comment(),
+        genre: tw.genre(),
+        year: tw.year(),
+        track: tw.track()
+      };
+    },
+    setTagData(data) {
+      const tw = raw.getTag();
+      if (data.title !== void 0) tw.setTitle(data.title);
+      if (data.artist !== void 0) tw.setArtist(data.artist);
+      if (data.album !== void 0) tw.setAlbum(data.album);
+      if (data.comment !== void 0) tw.setComment(data.comment);
+      if (data.genre !== void 0) tw.setGenre(data.genre);
+      if (data.year !== void 0) tw.setYear(data.year);
+      if (data.track !== void 0) tw.setTrack(data.track);
+    },
+    getBextData() {
+      const v = raw.getBextData();
+      if (v === void 0 || v === null) return void 0;
+      const u8 = v instanceof Uint8Array ? v : new Uint8Array(v);
+      return u8.length > 0 ? u8 : void 0;
+    },
+    setBextData(data) {
+      raw.setBextData(data ?? null);
+    },
+    getIxml() {
+      const v = raw.getIxml();
+      return typeof v === "string" && v.length > 0 ? v : void 0;
+    },
+    setIxml(data) {
+      raw.setIxml(
+        data ?? null
+      );
+    },
+    getAudioProperties() {
+      const pw = raw.getAudioProperties();
+      if (!pw) return null;
+      const containerFormat = pw.containerFormat() || "unknown";
+      const codec = pw.codec() || "unknown";
+      const mpegVersion = pw.mpegVersion();
+      const formatVersion = pw.formatVersion();
+      const bitrateMode = pw.bitrateMode();
+      return {
+        duration: pw.lengthInSeconds(),
+        durationMs: pw.lengthInMilliseconds(),
+        bitrate: pw.bitrate(),
+        sampleRate: pw.sampleRate(),
+        channels: pw.channels(),
+        bitsPerSample: pw.bitsPerSample(),
+        codec,
+        containerFormat,
+        isLossless: pw.isLossless(),
+        ...mpegVersion > 0 ? { mpegVersion, mpegLayer: pw.mpegLayer() } : {},
+        ...containerFormat === "MP4" || containerFormat === "ASF" ? { isEncrypted: pw.isEncrypted() } : {},
+        ...formatVersion > 0 ? { formatVersion } : {},
+        ...isValidBitrateMode(bitrateMode) ? { bitrateMode } : {},
+        ...codec === "Opus" ? { outputGainDb: pw.outputGainDb() } : {}
+      };
+    }
+  };
+  return new Proxy(raw, {
+    get(target, prop, receiver) {
+      if (prop in overrides) return overrides[prop];
+      const value = Reflect.get(target, prop, receiver);
+      return typeof value === "function" ? value.bind(target) : value;
+    }
+  });
+}
+var init_embind_adapter = __esm({
+  "src/taglib/embind-adapter.ts"() {
+    "use strict";
+  }
+});
+
 // src/taglib/audio-file-impl.ts
+function sortChapters(list) {
+  return [...list].sort((a, b) => a.startTimeMs - b.startTimeMs);
+}
+function inferEndTimeMs(sorted, index, trackEndMs) {
+  const own = sorted[index].endTimeMs;
+  if (own !== void 0) return own;
+  const next = sorted[index + 1];
+  return next ? next.startTimeMs : trackEndMs;
+}
 function readFileSync(path) {
   if (typeof Deno !== "undefined") return Deno.readFileSync(path);
   if (_nodeFs === void 0) {
@@ -1381,10 +1646,12 @@ var init_audio_file_impl = __esm({
   "src/taglib/audio-file-impl.ts"() {
     "use strict";
     init_types2();
+    init_audio_file_bwf();
     init_errors2();
     init_file();
     init_write();
     init_audio_file_base();
+    init_embind_adapter();
     AudioFileImpl = class extends BaseAudioFileImpl {
       constructor(module, fileHandle, sourcePath, originalSource, isPartiallyLoaded = false, partialLoadOptions) {
         super(
@@ -1430,7 +1697,8 @@ var init_audio_file_impl = __esm({
           );
         }
         if (this.isPartiallyLoaded && this.originalSource) {
-          const fullFileHandle = this.module.createFileHandle();
+          const rawFullHandle = this.module.createFileHandle();
+          const fullFileHandle = this.module.isWasi ? rawFullHandle : wrapEmbindHandle(rawFullHandle);
           try {
             const success = await (async () => {
               const data = await readFileData(this.originalSource);
@@ -1441,19 +1709,13 @@ var init_audio_file_impl = __esm({
                 "Failed to load full audio file for saving"
               );
             }
-            const partialTag = this.handle.getTag();
-            const fullTag = fullFileHandle.getTag();
-            if (partialTag && fullTag) {
-              fullTag.setTitle(partialTag.title());
-              fullTag.setArtist(partialTag.artist());
-              fullTag.setAlbum(partialTag.album());
-              fullTag.setComment(partialTag.comment());
-              fullTag.setGenre(partialTag.genre());
-              fullTag.setYear(partialTag.year());
-              fullTag.setTrack(partialTag.track());
-            }
+            fullFileHandle.setTagData(this.handle.getTagData());
             fullFileHandle.setProperties(this.handle.getProperties());
             fullFileHandle.setPictures(this.handle.getPictures());
+            const bextBytes = this.handle.getBextData();
+            if (bextBytes !== void 0) fullFileHandle.setBextData(bextBytes);
+            const ixmlStr = this.handle.getIxml();
+            if (ixmlStr !== void 0) fullFileHandle.setIxml(ixmlStr);
             if (!fullFileHandle.save()) {
               throw new FileOperationError(
                 "save",
@@ -1508,6 +1770,52 @@ var init_audio_file_impl = __esm({
       removePictures() {
         this.handle.removePictures();
       }
+      getChapters() {
+        const sorted = sortChapters(this.handle.getChapters());
+        const trackEndMs = this.audioProperties()?.durationMs;
+        return sorted.map((c, i) => ({
+          startTimeMs: c.startTimeMs,
+          endTimeMs: inferEndTimeMs(sorted, i, trackEndMs),
+          title: c.title || void 0,
+          id: c.id || void 0,
+          source: c.source
+        }));
+      }
+      setChapters(chapters, options) {
+        const fmt = this.getFormat();
+        if (fmt !== "MP3" && fmt !== "MP4") {
+          throw new UnsupportedFormatError(fmt, ["MP3", "MP4"], {
+            operation: "setChapters"
+          });
+        }
+        const sorted = sortChapters(chapters);
+        const trackEndMs = this.audioProperties()?.durationMs;
+        const raw = sorted.map((c, i) => ({
+          id: c.id,
+          startTimeMs: c.startTimeMs,
+          endTimeMs: inferEndTimeMs(sorted, i, trackEndMs) ?? c.startTimeMs,
+          title: c.title
+        }));
+        this.handle.setChapters(raw, options?.mp4ChapterStyle ?? "quicktime");
+      }
+      getBext() {
+        return getBext(this.handle);
+      }
+      setBext(bext) {
+        setBext(this.handle, this.getFormat(), bext);
+      }
+      getBextData() {
+        return getBextData(this.handle);
+      }
+      setBextData(data) {
+        setBextData(this.handle, this.getFormat(), data);
+      }
+      getIxml() {
+        return getIxml(this.handle);
+      }
+      setIxml(data) {
+        setIxml(this.handle, this.getFormat(), data);
+      }
       getRatings() {
         return this.handle.getRatings().map(
           (r) => ({
@@ -1681,7 +1989,7 @@ var VERSION;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    VERSION = "1.1.1";
+    VERSION = "1.2.0";
   }
 });
 
@@ -1768,6 +2076,7 @@ var init_taglib_class = __esm({
     init_tag_mapping();
     init_errors2();
     init_version();
+    init_embind_adapter();
     TagLib = class _TagLib {
       constructor(module) {
         __publicField(this, "module");
@@ -1843,7 +2152,8 @@ var init_taglib_class = __esm({
             audioData.byteOffset + audioData.byteLength
           )
         ) : audioData;
-        const fileHandle = this.module.createFileHandle();
+        const rawHandle = this.module.createFileHandle();
+        const fileHandle = this.module.isWasi ? rawHandle : wrapEmbindHandle(rawHandle);
         try {
           const success = fileHandle.loadFromBuffer(uint8Array);
           if (!success) {

package/dist/src/bwf/bext.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @fileoverview EBU Tech 3285 BWF `bext` chunk codec. Pure functions — no Wasm
+ * or TagLib dependency. The fixed prefix is 602 bytes for all versions; the
+ * `version` field selects which optional fields are meaningful (0 = none,
+ * 1 = UMID, 2 = UMID + loudness). Fixed-width string fields are NUL-padded
+ * ASCII; `codingHistory` is exposed verbatim (the spec uses CR/LF lines) and
+ * is not promised to preserve embedded NUL bytes. Loudness fields use the EBU
+ * "value not set" sentinel `0x7FFF`: a sentinel decodes to `undefined`, and an
+ * `undefined` loudness field on a v2 encode is written as the sentinel.
+ */
+import type { BroadcastAudioExtension } from "../types/bwf.js";
+/**
+ * Parse a raw `bext` chunk. Returns `undefined` only if `bytes` is shorter than
+ * 348 (cannot even read the `Version` field). Optional fields are populated per
+ * the chunk's declared version and the available length, so compact/legacy v0
+ * chunks parse into a partial struct.
+ */
+export declare function decodeBext(bytes: Uint8Array): BroadcastAudioExtension | undefined;
+/**
+ * Serialize a `bext` chunk. The result is always `602 + codingHistory.length`
+ * bytes. `version` defaults to 2 when any loudness field is present (else 1 if
+ * `umid` is set, else 0). Over-long string fields are truncated to their widths;
+ * loudness values are clamped to the Int16 range after ×100, with `undefined`
+ * written as the EBU `0x7FFF` "not set" sentinel; UMID is written only for
+ * version ≥ 1.
+ */
+export declare function encodeBext(b: BroadcastAudioExtension): Uint8Array;
+//# sourceMappingURL=bext.d.ts.map

package/dist/src/bwf/bext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bext.d.ts","sourceRoot":"","sources":["../../../src/bwf/bext.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,iBAAiB,CAAC;AA6D/D;;;;;GAKG;AACH,wBAAgB,UAAU,CACxB,KAAK,EAAE,UAAU,GAChB,uBAAuB,GAAG,SAAS,CAwCrC;AAED;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,uBAAuB,GAAG,UAAU,CA6CjE"}