@mekuru/audio 0.0.0-stage → 0.1.4

package/README.jp.md

@@ -0,0 +1,3 @@
+# @mekuru/audio
+
+`AudioSource`・`Audio`・`readAudio` を提供します。WAVの長さ取得・結合・PCM変換は `@mekuru/audio/wav` から利用します。coreだけに依存し、音声合成や立ち絵に関する処理は持ちません。

package/README.md

@@ -1,3 +1,5 @@
-# Temporary Holding Version
+# @mekuru/audio
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Audio resources and WAV processing.
+
+`AudioSource`, `Audio`, and `readAudio` are exported from `@mekuru/audio`. WAV duration, joining and PCM decoding are available from `@mekuru/audio/wav`. This package depends on core, never on speech engines or narrator.

package/package.json

@@ -1,6 +1,25 @@
 {
   "name": "@mekuru/audio",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.4",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kanade-k-1228/mekuru.git",
+    "directory": "pkgs/audio"
+  },
+  "homepage": "https://github.com/kanade-k-1228/mekuru/blob/main/pkgs/audio/README.md",
+  "type": "module",
+  "exports": {
+    ".": "./src/index.tsx",
+    "./wav": "./src/wav.ts"
+  },
+  "files": [
+    "src"
+  ],
+  "sideEffects": false,
+  "dependencies": {
+    "@mekuru/types": "^0.1.4"
+  },
+  "engines": {
+    "bun": ">=1.4"
+  }
+}

package/src/index.tsx

@@ -0,0 +1,36 @@
+/** @jsxImportSource @mekuru/types */
+import { relative, resolve, sep } from "node:path";
+import { fps, projectRoot, type At, type Time } from "@mekuru/types";
+import { wavSeconds } from "./wav.ts";
+/** A finite audio resource in the current video's frames, including trailing silence. */
+export type AudioSource = Readonly<{
+  len: number;
+  label?: string;
+  volume?: number;
+}> &
+  (Readonly<{ status: "draft" }> | Readonly<{ status: "ready"; src: string }>);
+
+const frames = (seconds: number) => Math.ceil(seconds * fps() - 1e-6);
+
+const frameCount = (name: string, value: number): number => {
+  if (!Number.isSafeInteger(value) || value < 0) throw new Error(`${name} must be a non-negative whole number of frames`);
+  return value;
+};
+
+export const readAudio = async (src: string, options: { len?: Time; gap?: Time; label?: string; volume?: number } = {}): Promise<AudioSource> => {
+  const file = resolve(projectRoot(), src);
+  const gap = frameCount("gap", options.gap ?? 0);
+  const len = options.len ?? frames(wavSeconds(Buffer.from(await Bun.file(file).arrayBuffer()), file)) + gap;
+  return Object.freeze({ status: "ready", src: file, len: frameCount("len", len), label: options.label, volume: options.volume });
+};
+
+export const Audio = ({ source, id, at }: { source: AudioSource; id?: string; at?: At }) => (
+  <dur id={id} at={at} len={source.len}>
+    <audio
+      src={source.status === "ready" ? relative(projectRoot(), source.src).split(sep).join("/") : undefined}
+      draft={source.status === "draft"}
+      volume={source.volume}
+      label={source.label}
+    />
+  </dur>
+);

package/src/wav.ts

@@ -0,0 +1,80 @@
+interface Wav {
+  fmt: Buffer;
+  data: Buffer;
+}
+
+const parseWav = (bytes: Buffer, what: string): Wav => {
+  if (bytes.length < 12 || bytes.toString("latin1", 0, 4) !== "RIFF" || bytes.toString("latin1", 8, 12) !== "WAVE") {
+    throw new Error(`${what} is not a WAV file`);
+  }
+  let fmt: Buffer | undefined;
+  let data: Buffer | undefined;
+  for (let at = 12; at + 8 <= bytes.length; ) {
+    const id = bytes.toString("latin1", at, at + 4);
+    const size = Math.min(bytes.readUInt32LE(at + 4), bytes.length - at - 8);
+    if (id === "fmt ") fmt = bytes.subarray(at + 8, at + 8 + size);
+    if (id === "data") data = bytes.subarray(at + 8, at + 8 + size);
+    at += 8 + size + (size % 2);
+  }
+  if (!fmt || fmt.length < 16 || !data) throw new Error(`${what} is not a WAV file (no samples)`);
+  return { fmt, data };
+};
+
+export const wavSeconds = (bytes: Buffer, what = "the audio"): number => {
+  const { fmt, data } = parseWav(bytes, what);
+  const bytesPerSecond = fmt.readUInt32LE(8);
+  if (bytesPerSecond === 0) throw new Error(`${what} is not a WAV file (no sample rate)`);
+  return data.length / bytesPerSecond;
+};
+
+export const joinWavs = (parts: Buffer[]): Buffer => {
+  const wavs = parts.map((p, i) => parseWav(p, `part ${i + 1}`));
+  const { fmt } = wavs[0];
+  if (wavs.some((w) => !w.fmt.equals(fmt))) throw new Error("the parts of the line have different audio formats");
+  const data = Buffer.concat(wavs.map((w) => w.data));
+  const head = Buffer.alloc(12 + 8 + fmt.length + (fmt.length % 2) + 8);
+  head.write("RIFF", 0, "latin1");
+  head.writeUInt32LE(head.length - 8 + data.length, 4);
+  head.write("WAVEfmt ", 8, "latin1");
+  head.writeUInt32LE(fmt.length, 16);
+  fmt.copy(head, 20);
+  head.write("data", head.length - 8, "latin1");
+  head.writeUInt32LE(data.length, head.length - 4);
+  return Buffer.concat([head, data]);
+};
+
+export const samples = (wav: Buffer): { rate: number; data: Float32Array } => {
+  const { fmt, data } = parseWav(wav, "the audio");
+  const body = data;
+  let format = fmt.readUInt16LE(0);
+  if (format === 0xfffe && fmt.length >= 26) format = fmt.readUInt16LE(24);
+  const channels = Math.max(1, fmt.readUInt16LE(2));
+  const rate = fmt.readUInt32LE(4);
+  const bits = fmt.readUInt16LE(14);
+  const bytes = bits / 8;
+  const read: ((at: number) => number) | undefined =
+    format === 3 && bits === 32
+      ? (at) => body.readFloatLE(at)
+      : format === 3 && bits === 64
+        ? (at) => body.readDoubleLE(at)
+        : format !== 1
+          ? undefined
+          : bits === 8
+            ? (at) => (body.readUInt8(at) - 128) / 128
+            : bits === 16
+              ? (at) => body.readInt16LE(at) / 32768
+              : bits === 24
+                ? (at) => body.readIntLE(at, 3) / 8388608
+                : bits === 32
+                  ? (at) => body.readInt32LE(at) / 2147483648
+                  : undefined;
+  if (!read || rate === 0) throw new Error(`the WAV format is not supported (format ${format}, ${bits} bit)`);
+  const n = Math.floor(data.length / (bytes * channels));
+  const out = new Float32Array(n);
+  for (let i = 0; i < n; i++) {
+    let sum = 0;
+    for (let c = 0; c < channels; c++) sum += read((i * channels + c) * bytes);
+    out[i] = sum / channels;
+  }
+  return { rate, data: out };
+};