@storyteller-platform/audiobook 0.2.0 → 0.3.0

package/dist/entry.js

@@ -1,276 +1,127 @@
 import {
-  BufferTarget,
-  Conversion,
-  FLAC,
-  FlacOutputFormat,
-  MP3,
-  MP4,
-  Mp3OutputFormat,
-  Mp4OutputFormat,
-  OGG,
-  OggOutputFormat,
-  Output,
-  WAVE,
-  WavOutputFormat
-} from "mediabunny";
-import { getWriteTags, readTagMap } from "./tagMaps.js";
+  getTrackMetadata,
+  writeTrackMetadata
+} from "./ffmpeg.js";
+import { lookupAudioMime } from "./mime.js";
 function splitNames(names) {
+  if (!names) return [];
   return names.split(/[;,/]/).map((name) => name.trim());
 }
 class AudiobookEntry {
-  metadataTags = null;
-  duration = null;
-  async getMetadataTags() {
-    if (this.metadataTags) return this.metadataTags;
-    const input = await this.getInput();
-    this.metadataTags = await input.getMetadataTags();
-    return this.metadataTags;
+  constructor(filename) {
+    this.filename = filename;
+  }
+  info = null;
+  async getInfo() {
+    this.info ??= await getTrackMetadata(this.filename);
+    return this.info;
   }
-  async getOutputFormat() {
-    const input = await this.getInput();
-    const inputFormat = await input.getFormat();
-    switch (inputFormat) {
-      case MP3: {
-        return new Mp3OutputFormat();
-      }
-      case MP4: {
-        return new Mp4OutputFormat();
-      }
-      case WAVE: {
-        return new WavOutputFormat();
-      }
-      case OGG: {
-        return new OggOutputFormat();
-      }
-      case FLAC: {
-        return new FlacOutputFormat();
-      }
-    }
-    return null;
+  async getMetadataTags() {
+    const info = await this.getInfo();
+    return info.tags;
   }
   async getTitle() {
     const tags = await this.getMetadataTags();
-    if (!tags.raw) return null;
-    for (const tag of readTagMap.title) {
-      if (typeof tags.raw[tag] === "string") {
-        return tags.raw[tag];
-      }
-    }
-    return null;
+    return tags.album ?? tags.title ?? null;
+  }
+  async setTitle(title) {
+    const tags = await this.getMetadataTags();
+    tags.album = title;
   }
   async getTrackTitle() {
     const tags = await this.getMetadataTags();
-    if (!tags.raw) return null;
-    for (const tag of readTagMap.trackTitle) {
-      if (typeof tags.raw[tag] === "string") {
-        return tags.raw[tag];
-      }
-    }
-    return null;
+    return tags.title ?? null;
   }
-  async setTitle(title) {
+  async setTrackTitle(trackTitle) {
     const tags = await this.getMetadataTags();
-    const input = await this.getInput();
-    const inputFormat = await input.getFormat();
-    const writeTags = getWriteTags(inputFormat, "title");
-    tags.raw ??= {};
-    for (const tag of writeTags) {
-      tags.raw[tag] = title;
-    }
+    tags.title = trackTitle;
   }
   async getSubtitle() {
     const tags = await this.getMetadataTags();
-    if (!tags.raw) return null;
-    for (const subtitleTag of readTagMap.subtitle) {
-      if (typeof tags.raw[subtitleTag] === "string") {
-        return tags.raw[subtitleTag];
-      }
-    }
-    return null;
+    return tags.subtitle ?? null;
   }
   async setSubtitle(subtitle) {
     const tags = await this.getMetadataTags();
-    const input = await this.getInput();
-    const inputFormat = await input.getFormat();
-    const writeTags = getWriteTags(inputFormat, "subtitle");
-    tags.raw ??= {};
-    for (const tag of writeTags) {
-      tags.raw[tag] = subtitle;
-    }
+    tags.subtitle = subtitle;
   }
   async getDescription() {
     const tags = await this.getMetadataTags();
-    if (!tags.raw) return null;
-    for (const tag of readTagMap.description) {
-      if (typeof tags.raw[tag] === "string") {
-        return tags.raw[tag];
-      }
-    }
-    return null;
+    return tags.description ?? tags.comment ?? null;
   }
   async setDescription(description) {
     const tags = await this.getMetadataTags();
-    const input = await this.getInput();
-    const inputFormat = await input.getFormat();
-    const writeTags = getWriteTags(inputFormat, "description");
-    tags.raw ??= {};
-    for (const tag of writeTags) {
-      tags.raw[tag] = description;
-    }
+    tags.description = description;
+    tags.comment = description;
   }
   async getAuthors() {
     const tags = await this.getMetadataTags();
-    if (!tags.raw) return [];
-    for (const tag of readTagMap.authors) {
-      if (typeof tags.raw[tag] === "string") {
-        return splitNames(tags.raw[tag]);
-      }
-    }
-    return [];
+    return splitNames(tags.albumArtist ?? tags.artist);
   }
   async setAuthors(authors) {
     const tags = await this.getMetadataTags();
-    const input = await this.getInput();
-    const inputFormat = await input.getFormat();
-    const writeTags = getWriteTags(inputFormat, "authors");
-    tags.raw ??= {};
-    for (const tag of writeTags) {
-      tags.raw[tag] = authors.join(";");
-    }
+    tags.artist = authors.join(";");
+    tags.albumArtist = authors.join(";");
   }
   async getNarrators() {
     const tags = await this.getMetadataTags();
-    if (!tags.raw) return [];
-    for (const tag of readTagMap.narrators) {
-      if (typeof tags.raw[tag] === "string") {
-        return splitNames(tags.raw[tag]);
-      }
-    }
-    return [];
+    return splitNames(tags.composer ?? tags.performer);
   }
   async setNarrators(narrators) {
     const tags = await this.getMetadataTags();
-    const input = await this.getInput();
-    const inputFormat = await input.getFormat();
-    const writeTags = getWriteTags(inputFormat, "narrators");
-    tags.raw ??= {};
-    for (const tag of writeTags) {
-      tags.raw[tag] = narrators.join(";");
-    }
+    tags.composer = narrators.join(";");
+    tags.performer = narrators.join(";");
   }
   async getCoverArt() {
-    var _a;
-    const tags = await this.getMetadataTags();
-    return ((_a = tags.images) == null ? void 0 : _a.find((image) => image.kind === "coverFront")) ?? null;
+    const info = await this.getInfo();
+    return info.attachedPic || null;
   }
   async setCoverArt(picture) {
-    const tags = await this.getMetadataTags();
-    const images = tags.images ?? [];
-    const frontCover = images.find((image) => image.kind === "coverFront");
-    if (frontCover) {
-      Object.assign(frontCover, picture);
-    } else {
-      images.push(picture);
-    }
-    tags.images = images;
+    const info = await this.getInfo();
+    info.attachedPic = picture;
   }
   async getPublisher() {
     const tags = await this.getMetadataTags();
-    if (!tags.raw) return null;
-    for (const tag of readTagMap.publisher) {
-      if (typeof tags.raw[tag] === "string") {
-        return tags.raw[tag];
-      }
-    }
-    return null;
+    return tags.publisher ?? null;
   }
   async setPublisher(publisher) {
     const tags = await this.getMetadataTags();
-    const input = await this.getInput();
-    const inputFormat = await input.getFormat();
-    const writeTags = getWriteTags(inputFormat, "publisher");
-    tags.raw ??= {};
-    for (const tag of writeTags) {
-      tags.raw[tag] = publisher;
-    }
+    tags.publisher = publisher;
   }
   async getReleaseDate() {
     const tags = await this.getMetadataTags();
-    if (!tags.raw) return null;
-    for (const tag of readTagMap.releaseDate) {
-      if (typeof tags.raw[tag] === "string") {
-        return new Date(tags.raw[tag]);
-      }
-    }
-    return null;
+    return tags.date ? new Date(tags.date) : null;
   }
   async setReleaseDate(date) {
     const tags = await this.getMetadataTags();
-    const input = await this.getInput();
-    const inputFormat = await input.getFormat();
-    const writeTags = getWriteTags(inputFormat, "releaseDate");
-    tags.raw ??= {};
-    for (const tag of writeTags) {
-      tags.raw[tag] = `${date.getDate().toString().padStart(2, "0")}-${date.getMonth().toString().padStart(2, "0")}-${date.getFullYear()}`;
-    }
+    tags.date = `${date.getDate().toString().padStart(2, "0")}-${date.getMonth().toString().padStart(2, "0")}-${date.getFullYear()}`;
   }
   async getDuration() {
-    const input = await this.getInput();
-    this.duration ??= await input.computeDuration();
-    return this.duration;
+    const info = await this.getInfo();
+    return info.duration;
   }
   async getResource() {
-    const input = await this.getInput();
-    this.duration ??= await input.computeDuration();
+    const duration = await this.getDuration();
     const title = await this.getTrackTitle() ?? null;
-    const type = await input.getMimeType();
+    const type = lookupAudioMime(this.filename);
     return {
       filename: this.filename,
       title,
       type,
-      duration: this.duration,
+      duration,
       bitrate: null
     };
   }
-  async getArrayAndClose() {
-    const input = await this.getInput();
-    const outputFormat = await this.getOutputFormat();
-    if (!outputFormat) {
-      const inputFormat = await input.getFormat();
-      throw new Error(
-        `Failed to save Audiobook entry: could not find valid output format for input with format ${inputFormat.name}`
-      );
-    }
-    const output = new Output({
-      format: outputFormat,
-      target: new BufferTarget()
-    });
-    const tags = await this.getMetadataTags();
-    const conversion = await Conversion.init({
-      input,
-      output,
-      tags: {
-        // Since we only write raw metadata tags, we
-        // only copy those into the output. Otherwise
-        // the unchanged parsed metadata tags will overwrite
-        // our changes to raw!
-        raw: tags.raw ?? {},
-        images: tags.images ?? []
-      },
-      showWarnings: false
-    });
-    if (!conversion.isValid) {
-      throw new Error(
-        conversion.discardedTracks.map((track) => track.reason).join(";")
-      );
-    }
-    await conversion.execute();
-    input.dispose();
-    return {
-      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-      data: new Uint8Array(output.target.buffer),
-      filename: this.filename
-    };
+  async getChapters() {
+    const info = await this.getInfo();
+    return info.chapters.map((chapter) => ({
+      filename: this.filename,
+      title: chapter.title ?? null,
+      start: chapter.startTime
+    }));
+  }
+  async saveAndClose() {
+    const info = await this.getInfo();
+    await writeTrackMetadata(this.filename, info.tags, info.attachedPic);
   }
 }
 export {

package/dist/ffmpeg.cjs

@@ -18,9 +18,11 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var ffmpeg_exports = {};
 __export(ffmpeg_exports, {
-  getTrackChapters: () => getTrackChapters,
-  getTrackChaptersFromBuffer: () => getTrackChaptersFromBuffer,
-  quotePath: () => quotePath
+  escapeQuotes: () => escapeQuotes,
+  getTrackMetadata: () => getTrackMetadata,
+  getTrackMetadataFromBuffer: () => getTrackMetadataFromBuffer,
+  quotePath: () => quotePath,
+  writeTrackMetadata: () => writeTrackMetadata
 });
 module.exports = __toCommonJS(ffmpeg_exports);
 var import_node_child_process = require("node:child_process");
@@ -30,7 +32,9 @@ var import_promises = require("node:fs/promises");
 var import_node_os = require("node:os");
 var import_node_path = require("node:path");
 var import_node_util = require("node:util");
+var import_path = require("@storyteller-platform/path");
 const execPromise = (0, import_node_util.promisify)(import_node_child_process.exec);
+const execFilePromise = (0, import_node_util.promisify)(import_node_child_process.execFile);
 async function execCmd(command) {
   let stdout = "";
   let stderr = "";
@@ -44,29 +48,198 @@ async function execCmd(command) {
     throw new Error(stderr);
   }
 }
+async function execCmdBuffer(command, args) {
+  var _a, _b;
+  try {
+    const { stdout } = await execFilePromise(command, args, {
+      encoding: "buffer",
+      maxBuffer: 10 * 1024 * 1024,
+      cwd: process.cwd()
+    });
+    return stdout;
+  } catch (error) {
+    console.error(error);
+    if (error && typeof error === "object" && "stdout" in error) {
+      console.warn((_a = error.stdout) == null ? void 0 : _a.toString());
+      throw new Error((_b = error.stdout) == null ? void 0 : _b.toString());
+    }
+    throw error;
+  }
+}
+function escapeQuotes(input) {
+  return input.replaceAll(/"/g, '\\"');
+}
 function quotePath(path) {
-  return `"${path.replaceAll(/"/g, '\\"')}"`;
+  return `"${escapeQuotes(path)}"`;
+}
+function lookup(codecName) {
+  switch (codecName) {
+    case "mjpeg":
+    case "jpeg": {
+      return "image/jpeg";
+    }
+    case "bmp": {
+      return "image/bmp";
+    }
+    case "png": {
+      return "image/png";
+    }
+    case "gif": {
+      return "image/gif";
+    }
+  }
 }
-function parseChapterInfo(ffmpegChapterInfo) {
+async function getTrackMetadata(path) {
+  const stdout = await execCmd(
+    `ffprobe -i ${quotePath(path)} -v quiet -show_format -show_chapters -show_streams -output_format json`
+  );
+  const { chapters, streams, format, duration, bit_rate } = JSON.parse(
+    stdout
+  );
+  const attachedPicStream = streams.find(
+    (stream) => !!stream.disposition.attached_pic
+  );
+  const attachedPic = attachedPicStream && {
+    name: attachedPicStream.tags.title,
+    mimeType: lookup(attachedPicStream.codec_name),
+    kind: attachedPicStream.tags.comment === "Cover (front)" ? "coverFront" : attachedPicStream.tags.comment === "Cover (back)" ? "coverBack" : "unknown",
+    description: attachedPicStream.tags.comment,
+    data: await execCmdBuffer("ffmpeg", [
+      "-nostdin",
+      "-i",
+      path,
+      "-map",
+      "0:v",
+      "-c:v",
+      "copy",
+      "-vframes",
+      "1",
+      "-f",
+      "image2",
+      "-update",
+      "1",
+      "pipe:1"
+    ])
+  };
   return {
-    id: ffmpegChapterInfo.id,
-    startTime: parseFloat(ffmpegChapterInfo.start_time),
-    endTime: parseFloat(ffmpegChapterInfo.end_time),
-    title: ffmpegChapterInfo.tags.title
+    duration: parseFloat(duration),
+    bitRate: bit_rate !== void 0 ? parseFloat(bit_rate) : bit_rate,
+    tags: {
+      title: format.tags.title ?? format.tags.Title,
+      subtitle: format.tags.subtitle ?? format.tags.Subtitle,
+      date: format.tags.date ?? format.tags.Date,
+      album: format.tags.album ?? format.tags.Album,
+      albumArtist: format.tags.album_artist ?? format.tags.Album_Artist,
+      artist: format.tags.artist ?? format.tags.Artist,
+      performer: format.tags.performer ?? format.tags.Performer,
+      composer: format.tags.composer ?? format.tags.Composer,
+      comment: format.tags.comment ?? format.tags.Comment,
+      description: format.tags.description ?? format.tags.Description,
+      publisher: format.tags.publisher ?? format.tags.Publisher
+    },
+    chapters: chapters.map(
+      (chapter) => ({
+        id: chapter.id,
+        startTime: parseFloat(chapter.start_time),
+        endTime: parseFloat(chapter.end_time),
+        title: chapter.tags.title
+      })
+    ),
+    attachedPic
   };
 }
-async function getTrackChapters(path) {
-  const stdout = await execCmd(
-    `ffprobe -i ${quotePath(path)} -show_chapters -of json`
+async function writeTrackMetadata(path, metadata, attachedPic) {
+  const metadataArgs = [];
+  if (metadata.title) {
+    metadataArgs.push(`-metadata title="${escapeQuotes(metadata.title)}"`);
+  }
+  if (metadata.subtitle) {
+    metadataArgs.push(`-metadata subtitle="${escapeQuotes(metadata.subtitle)}"`);
+  }
+  if (metadata.date) {
+    metadataArgs.push(`-metadata date="${escapeQuotes(metadata.date)}"`);
+  }
+  if (metadata.album) {
+    metadataArgs.push(`-metadata album="${escapeQuotes(metadata.album)}"`);
+  }
+  if (metadata.albumArtist) {
+    metadataArgs.push(
+      `-metadata album_artist="${escapeQuotes(metadata.albumArtist)}"`
+    );
+  }
+  if (metadata.artist) {
+    metadataArgs.push(`-metadata artist="${escapeQuotes(metadata.artist)}"`);
+  }
+  if (metadata.performer) {
+    metadataArgs.push(
+      `-metadata performer="${escapeQuotes(metadata.performer)}"`
+    );
+  }
+  if (metadata.composer) {
+    metadataArgs.push(`-metadata composer="${escapeQuotes(metadata.composer)}"`);
+  }
+  if (metadata.comment) {
+    metadataArgs.push(`-metadata comment="${escapeQuotes(metadata.comment)}"`);
+  }
+  if (metadata.description) {
+    metadataArgs.push(
+      `-metadata description="${escapeQuotes(metadata.description)}"`
+    );
+  }
+  if (metadata.publisher) {
+    metadataArgs.push(
+      `-metadata publisher="${escapeQuotes(metadata.publisher)}"`
+    );
+  }
+  const ext = (0, import_path.extname)(path);
+  const tmpPath = (0, import_node_path.join)(
+    (0, import_node_os.tmpdir)(),
+    `storyteller-platform-audiobook-${(0, import_node_crypto.randomUUID)()}${ext}`
   );
-  const { chapters } = JSON.parse(stdout);
-  return chapters.map((chapter) => parseChapterInfo(chapter));
+  let picPath = null;
+  try {
+    if (attachedPic) {
+      const imageExt = attachedPic.mimeType.split("/")[1];
+      picPath = (0, import_node_path.join)(
+        (0, import_node_os.tmpdir)(),
+        `storyteller-platform-audiobook-${(0, import_node_crypto.randomUUID)()}.${imageExt}`
+      );
+      await (0, import_promises.writeFile)(picPath, attachedPic.data);
+      metadataArgs.push(`-disposition:v:0 attached_pic`);
+      if (attachedPic.name) {
+        metadataArgs.push(
+          `-metadata:s:v title="${escapeQuotes(attachedPic.name)}"`
+        );
+      }
+      if (attachedPic.kind !== "unknown") {
+        metadataArgs.push(
+          `-metadata:s:v comment="${attachedPic.kind === "coverFront" ? "Cover (front)" : "Cover (back)"}"`
+        );
+      }
+    }
+    const cmd = `ffmpeg -i "${path}" ${metadataArgs.join(" ")} -codec copy "${tmpPath}"`;
+    await execCmd(cmd);
+    await (0, import_promises.cp)(tmpPath, path, { force: true });
+  } finally {
+    try {
+      await (0, import_promises.rm)(tmpPath);
+    } catch (error) {
+      console.warn(`Failed to clean up temporary file ${tmpPath}:`, error);
+    }
+    if (picPath) {
+      try {
+        await (0, import_promises.rm)(picPath);
+      } catch (error) {
+        console.warn(`Failed to clean up temporary file ${picPath}:`, error);
+      }
+    }
+  }
 }
-async function getTrackChaptersFromBuffer(buffer) {
+async function getTrackMetadataFromBuffer(buffer) {
   const tempFile = (0, import_node_path.join)((0, import_node_os.tmpdir)(), `ffprobe-${(0, import_node_crypto.randomUUID)()}`);
   try {
     (0, import_node_fs.writeFileSync)(tempFile, buffer);
-    const result = await getTrackChapters(tempFile);
+    const result = await getTrackMetadata(tempFile);
     return result;
   } finally {
     try {
@@ -78,7 +251,9 @@ async function getTrackChaptersFromBuffer(buffer) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  getTrackChapters,
-  getTrackChaptersFromBuffer,
-  quotePath
+  escapeQuotes,
+  getTrackMetadata,
+  getTrackMetadataFromBuffer,
+  quotePath,
+  writeTrackMetadata
 });

package/dist/ffmpeg.d.cts

@@ -1,11 +1,67 @@
+declare function escapeQuotes(input: string): string;
 declare function quotePath(path: string): string;
 type ChapterInfo = {
     id: number;
     startTime: number;
     endTime: number;
-    title: string;
+    title?: string | undefined;
 };
-declare function getTrackChapters(path: string): Promise<ChapterInfo[]>;
-declare function getTrackChaptersFromBuffer(buffer: Uint8Array): Promise<ChapterInfo[]>;
+type TrackInfo = Awaited<ReturnType<typeof getTrackMetadata>>;
+type AttachedPic = {
+    data: Uint8Array;
+    mimeType: string;
+    kind: "coverFront" | "coverBack" | "unknown";
+    name?: string;
+    description?: string;
+};
+declare function getTrackMetadata(path: string): Promise<{
+    duration: number;
+    bitRate: number | undefined;
+    tags: {
+        title: string | undefined;
+        subtitle: string | undefined;
+        date: string | undefined;
+        album: string | undefined;
+        albumArtist: string | undefined;
+        artist: string | undefined;
+        performer: string | undefined;
+        composer: string | undefined;
+        comment: string | undefined;
+        description: string | undefined;
+        publisher: string | undefined;
+    };
+    chapters: {
+        id: number;
+        startTime: number;
+        endTime: number;
+        title: string | undefined;
+    }[];
+    attachedPic: AttachedPic | undefined;
+}>;
+declare function writeTrackMetadata(path: string, metadata: TrackInfo["tags"], attachedPic: AttachedPic | undefined): Promise<void>;
+declare function getTrackMetadataFromBuffer(buffer: Uint8Array): Promise<{
+    duration: number;
+    bitRate: number | undefined;
+    tags: {
+        title: string | undefined;
+        subtitle: string | undefined;
+        date: string | undefined;
+        album: string | undefined;
+        albumArtist: string | undefined;
+        artist: string | undefined;
+        performer: string | undefined;
+        composer: string | undefined;
+        comment: string | undefined;
+        description: string | undefined;
+        publisher: string | undefined;
+    };
+    chapters: {
+        id: number;
+        startTime: number;
+        endTime: number;
+        title: string | undefined;
+    }[];
+    attachedPic: AttachedPic | undefined;
+}>;
 
-export { type ChapterInfo, getTrackChapters, getTrackChaptersFromBuffer, quotePath };
+export { type AttachedPic, type ChapterInfo, type TrackInfo, escapeQuotes, getTrackMetadata, getTrackMetadataFromBuffer, quotePath, writeTrackMetadata };