getraw 0.1.0

package/src/postprocessors/metadata.ts

@@ -0,0 +1,73 @@
+import { PostProcessor } from "../core/types";
+import type { InfoDict, PostProcessResult } from "../core/types";
+import { FFmpegRunner } from "./ffmpeg";
+import { dirname, basename, extname, join } from "node:path";
+
+export interface MetadataOptions {
+  title?: string;
+  artist?: string;
+  date?: string;
+  description?: string;
+  comment?: string;
+  ffmpegLocation?: string | null;
+}
+
+export class MetadataPostProcessor extends PostProcessor {
+  readonly _NAME = "EmbedMetadata";
+
+  private opts: MetadataOptions;
+
+  constructor(opts: MetadataOptions = {}) {
+    super();
+    this.opts = opts;
+  }
+
+  async run(info: InfoDict, filepath: string): Promise<PostProcessResult> {
+    const ext = extname(filepath).slice(1).toLowerCase();
+    const dir = dirname(filepath);
+    const stem = basename(filepath, extname(filepath));
+    const tmpPath = join(dir, `${stem}.meta_tmp.${ext}`);
+
+    const runner = await FFmpegRunner.detect(this.opts.ffmpegLocation);
+
+    const title = this.opts.title ?? info.title;
+    const artist = this.opts.artist ?? info.uploader ?? info.channel;
+    const date = this.opts.date ?? info.upload_date;
+    const description = this.opts.description ?? info.description;
+    const comment = this.opts.comment;
+
+    const args: string[] = ["-i", filepath, "-map", "0", "-c", "copy", "-map_metadata", "0"];
+
+    const isMp4 = ext === "mp4" || ext === "m4a" || ext === "mov";
+    const isMkv = ext === "mkv" || ext === "mka" || ext === "webm";
+
+    if (isMp4) {
+      if (title) args.push("-metadata", `title=${title}`);
+      if (artist) args.push("-metadata", `artist=${artist}`);
+      if (date) args.push("-metadata", `date=${date}`);
+      if (description) args.push("-metadata", `description=${description}`);
+      if (comment) args.push("-metadata", `comment=${comment}`);
+    } else if (isMkv) {
+      if (title) args.push("-metadata", `TITLE=${title}`);
+      if (artist) args.push("-metadata", `ARTIST=${artist}`);
+      if (date) args.push("-metadata", `DATE=${date}`);
+      if (description) args.push("-metadata", `DESCRIPTION=${description}`);
+      if (comment) args.push("-metadata", `COMMENT=${comment}`);
+    } else {
+      if (title) args.push("-metadata", `title=${title}`);
+      if (artist) args.push("-metadata", `artist=${artist}`);
+      if (date) args.push("-metadata", `date=${date}`);
+      if (description) args.push("-metadata", `description=${description}`);
+      if (comment) args.push("-metadata", `comment=${comment}`);
+    }
+
+    args.push(tmpPath);
+
+    await runner.run(args);
+
+    const { rename } = await import("node:fs/promises");
+    await rename(tmpPath, filepath);
+
+    return { filepath, info, files_to_delete: [] };
+  }
+}

package/src/postprocessors/sponsorblock.ts

@@ -0,0 +1,162 @@
+import { PostProcessor, PostProcessError } from "../core/types";
+import type { InfoDict, PostProcessResult, Chapter } from "../core/types";
+import { FFmpegRunner } from "./ffmpeg";
+import { dirname, basename, extname, join } from "node:path";
+import { writeFile, unlink } from "node:fs/promises";
+
+const SPONSORBLOCK_API = "https://sponsor.ajay.app/api/skipSegments?videoID=";
+
+export type SponsorCategory =
+  | "sponsor"
+  | "selfpromo"
+  | "interaction"
+  | "intro"
+  | "outro"
+  | "preview"
+  | "filler"
+  | "music_offtopic";
+
+interface SponsorSegment {
+  segment: [number, number];
+  category: SponsorCategory;
+  UUID: string;
+  videoDuration: number;
+}
+
+export interface SponsorBlockOptions {
+  categories?: SponsorCategory[];
+  ffmpegLocation?: string | null;
+  onProgress?: (percent: number) => void;
+}
+
+export class SponsorBlockPostProcessor extends PostProcessor {
+  readonly _NAME = "SponsorBlock";
+
+  private opts: SponsorBlockOptions;
+
+  constructor(opts: SponsorBlockOptions = {}) {
+    super();
+    this.opts = opts;
+  }
+
+  async run(info: InfoDict, filepath: string): Promise<PostProcessResult> {
+    const videoId = info.id;
+    if (!videoId) return { filepath, info, files_to_delete: [] };
+
+    const categories = this.opts.categories ?? ["sponsor"];
+    const segments = await fetchSegments(videoId, categories);
+
+    if (segments.length === 0) {
+      return { filepath, info, files_to_delete: [] };
+    }
+
+    const duration = info.duration ?? segments[0]?.videoDuration ?? 0;
+    const keepSegments = invertSegments(segments.map((s) => s.segment), duration);
+
+    if (keepSegments.length === 0) {
+      return { filepath, info, files_to_delete: [] };
+    }
+
+    const runner = await FFmpegRunner.detect(this.opts.ffmpegLocation);
+    const dir = dirname(filepath);
+    const ext = extname(filepath).slice(1).toLowerCase();
+    const stem = basename(filepath, extname(filepath));
+    const tmpPath = join(dir, `${stem}.sb_tmp.${ext}`);
+
+    const segmentListPath = join(dir, `${stem}.segments.txt`);
+    const segmentListContent = keepSegments
+      .map(([s, e]) => `inpoint ${s}\noutpoint ${e}`)
+      .join("\n");
+
+    await writeFile(segmentListPath, segmentListContent, "utf8");
+
+    const args = [
+      "-i", filepath,
+      "-f", "concat",
+      "-safe", "0",
+      "-i", segmentListPath,
+      "-c", "copy",
+      tmpPath,
+    ];
+
+    try {
+      await runner.run(
+        args,
+        this.opts.onProgress
+          ? (p) => { if (p.percent !== undefined) this.opts.onProgress!(p.percent); }
+          : undefined,
+        duration,
+      );
+    } finally {
+      await unlink(segmentListPath).catch(() => undefined);
+    }
+
+    const updatedChapters = rewriteChapters(info.chapters ?? [], segments.map((s) => s.segment));
+    const updatedInfo: InfoDict = { ...info, chapters: updatedChapters };
+
+    const { rename } = await import("node:fs/promises");
+    await rename(tmpPath, filepath);
+
+    return { filepath, info: updatedInfo, files_to_delete: [] };
+  }
+}
+
+async function fetchSegments(
+  videoId: string,
+  categories: SponsorCategory[],
+): Promise<SponsorSegment[]> {
+  const catParam = categories.map((c) => `categories[]=${encodeURIComponent(c)}`).join("&");
+  const url = `${SPONSORBLOCK_API}${encodeURIComponent(videoId)}&${catParam}`;
+
+  const res = await fetch(url);
+  if (res.status === 404) return [];
+  if (!res.ok) throw new PostProcessError(`SponsorBlock API error: HTTP ${res.status}`);
+
+  return (await res.json()) as SponsorSegment[];
+}
+
+function invertSegments(
+  skipSegments: [number, number][],
+  duration: number,
+): [number, number][] {
+  const sorted = skipSegments.slice().sort((a, b) => a[0] - b[0]);
+  const keep: [number, number][] = [];
+  let cursor = 0;
+
+  for (const [start, end] of sorted) {
+    if (cursor < start) keep.push([cursor, start]);
+    cursor = Math.max(cursor, end);
+  }
+
+  if (cursor < duration) keep.push([cursor, duration]);
+
+  return keep.filter(([s, e]) => e - s > 0.1);
+}
+
+function rewriteChapters(
+  chapters: Chapter[],
+  removedSegments: [number, number][],
+): Chapter[] {
+  if (chapters.length === 0) return chapters;
+
+  const kept = chapters.filter((ch) => {
+    for (const [s, e] of removedSegments) {
+      if (ch.start_time >= s && ch.end_time <= e) return false;
+    }
+    return true;
+  });
+
+  const removedSorted = removedSegments.slice().sort((a, b) => a[0] - b[0]);
+
+  return kept.map((ch) => {
+    let removedBefore = 0;
+    for (const [s, e] of removedSorted) {
+      if (e <= ch.start_time) removedBefore += e - s;
+    }
+    return {
+      ...ch,
+      start_time: ch.start_time - removedBefore,
+      end_time: ch.end_time - removedBefore,
+    };
+  });
+}

package/src/postprocessors/subtitles.ts

@@ -0,0 +1,285 @@
+import { PostProcessor, PostProcessError } from "../core/types";
+import type { InfoDict, PostProcessResult, Subtitle } from "../core/types";
+import { FFmpegRunner } from "./ffmpeg";
+import { dirname, basename, extname, join } from "node:path";
+
+export type SubtitleFormat = "srt" | "ass" | "vtt" | "json3" | "lrc";
+export type EmbedMode = "soft" | "burn";
+
+export interface SubtitleOptions {
+  convertTo?: SubtitleFormat;
+  embed?: EmbedMode;
+  language?: string;
+  ffmpegLocation?: string | null;
+  onProgress?: (percent: number) => void;
+}
+
+export class SubtitlePostProcessor extends PostProcessor {
+  readonly _NAME = "Subtitles";
+
+  private opts: SubtitleOptions;
+
+  constructor(opts: SubtitleOptions = {}) {
+    super();
+    this.opts = opts;
+  }
+
+  async run(info: InfoDict, filepath: string): Promise<PostProcessResult> {
+    const lang = this.opts.language ?? "en";
+    const subsMap = info.subtitles ?? info.automatic_captions ?? {};
+    const subs: Subtitle[] | undefined = subsMap[lang] ?? Object.values(subsMap)[0];
+
+    if (!subs || subs.length === 0) {
+      return { filepath, info, files_to_delete: [] };
+    }
+
+    const filesToDelete: string[] = [];
+    const runner = await FFmpegRunner.detect(this.opts.ffmpegLocation);
+    const dir = dirname(filepath);
+    const stem = basename(filepath, extname(filepath));
+    const videoExt = extname(filepath).slice(1).toLowerCase();
+
+    let subPath: string | null = null;
+    let subData: string | null = null;
+
+    for (const sub of subs) {
+      if (sub.data) {
+        subData = sub.data;
+        break;
+      }
+      if (sub.url) {
+        const res = await fetch(sub.url);
+        if (res.ok) {
+          subData = await res.text();
+          break;
+        }
+      }
+    }
+
+    if (!subData) {
+      return { filepath, info, files_to_delete: [] };
+    }
+
+    const sourceSub = subs[0];
+    const sourceExt = (sourceSub?.ext ?? "vtt") as SubtitleFormat;
+
+    if (this.opts.convertTo && this.opts.convertTo !== sourceExt) {
+      const convertedPath = join(dir, `${stem}.${lang}.${this.opts.convertTo}`);
+      await convertSubtitle(runner, subData, sourceExt, this.opts.convertTo, convertedPath);
+      subPath = convertedPath;
+      filesToDelete.push(convertedPath);
+    } else {
+      subPath = join(dir, `${stem}.${lang}.${sourceExt}`);
+      await Bun.write(subPath, subData);
+      filesToDelete.push(subPath);
+    }
+
+    if (!subPath) {
+      return { filepath, info, files_to_delete: filesToDelete };
+    }
+
+    const embed = this.opts.embed;
+
+    if (embed === "soft") {
+      const outputPath = await softEmbed(runner, filepath, subPath, lang, videoExt, info);
+      return {
+        filepath: outputPath,
+        info,
+        files_to_delete: outputPath !== filepath
+          ? [filepath, ...filesToDelete]
+          : filesToDelete,
+      };
+    }
+
+    if (embed === "burn") {
+      const outputPath = await burnInSubtitle(runner, filepath, subPath, videoExt, info, this.opts.onProgress);
+      return {
+        filepath: outputPath,
+        info,
+        files_to_delete: outputPath !== filepath
+          ? [filepath, ...filesToDelete]
+          : filesToDelete,
+      };
+    }
+
+    return { filepath, info, files_to_delete: filesToDelete };
+  }
+}
+
+async function convertSubtitle(
+  runner: FFmpegRunner,
+  data: string,
+  fromExt: SubtitleFormat,
+  toExt: SubtitleFormat,
+  outputPath: string,
+): Promise<void> {
+  if ((fromExt === "json3" || toExt === "json3") || fromExt === "lrc" || toExt === "lrc") {
+    const converted = convertNative(data, fromExt, toExt);
+    await Bun.write(outputPath, converted);
+    return;
+  }
+
+  const tmpInput = outputPath + ".tmp_in." + fromExt;
+  await Bun.write(tmpInput, data);
+
+  await runner.run(["-i", tmpInput, outputPath]);
+
+  const { unlink } = await import("node:fs/promises");
+  await unlink(tmpInput);
+}
+
+function convertNative(data: string, from: SubtitleFormat, to: SubtitleFormat): string {
+  if (from === "json3") {
+    const srtData = json3ToSrt(data);
+    if (to === "srt") return srtData;
+    if (to === "vtt") return srtToVtt(srtData);
+    if (to === "lrc") return srtToLrc(srtData);
+    return srtData;
+  }
+  if (from === "vtt" && to === "srt") return vttToSrt(data);
+  if (from === "srt" && to === "vtt") return srtToVtt(data);
+  if (from === "srt" && to === "lrc") return srtToLrc(data);
+  return data;
+}
+
+function json3ToSrt(json: string): string {
+  interface Json3Event {
+    tStartMs: number;
+    dDurationMs: number;
+    segs?: Array<{ utf8: string }>;
+  }
+  const parsed = JSON.parse(json) as { events?: Json3Event[] };
+  const events = parsed.events ?? [];
+  const lines: string[] = [];
+  let index = 1;
+
+  for (const ev of events) {
+    if (!ev.segs) continue;
+    const text = ev.segs.map((s) => s.utf8).join("").replace(/\n$/, "");
+    if (!text.trim()) continue;
+    const start = msToSrtTime(ev.tStartMs);
+    const end = msToSrtTime(ev.tStartMs + ev.dDurationMs);
+    lines.push(`${index}\n${start} --> ${end}\n${text}\n`);
+    index++;
+  }
+
+  return lines.join("\n");
+}
+
+function msToSrtTime(ms: number): string {
+  const h = Math.floor(ms / 3600000);
+  const m = Math.floor((ms % 3600000) / 60000);
+  const s = Math.floor((ms % 60000) / 1000);
+  const msPart = ms % 1000;
+  return `${pad(h)}:${pad(m)}:${pad(s)},${pad(msPart, 3)}`;
+}
+
+function vttToSrt(vtt: string): string {
+  return vtt
+    .replace(/^WEBVTT.*\n?/m, "")
+    .replace(/^\d+:\d+:\d+\.\d+ --> \d+:\d+:\d+\.\d+.*$/gm, (m) =>
+      m.replace(/\./g, ","),
+    )
+    .trim();
+}
+
+function srtToVtt(srt: string): string {
+  return "WEBVTT\n\n" + srt.replace(/,(\d{3})/g, ".$1");
+}
+
+function srtToLrc(srt: string): string {
+  const lines: string[] = [];
+  const blocks = srt.split(/\n\n+/);
+  for (const block of blocks) {
+    const blockLines = block.trim().split("\n");
+    if (blockLines.length < 3) continue;
+    const timeLine = blockLines[1] ?? "";
+    const startMatch = timeLine.match(/^(\d{2}:\d{2}:\d{2}),(\d{3})/);
+    if (!startMatch) continue;
+    const [, time, ms] = startMatch;
+    const [h, m, s] = (time ?? "").split(":").map(Number);
+    const totalMin = (h ?? 0) * 60 + (m ?? 0);
+    const sec = s ?? 0;
+    const text = blockLines.slice(2).join(" ");
+    lines.push(`[${pad(totalMin)}:${pad(sec)}.${(ms ?? "00").slice(0, 2)}]${text}`);
+  }
+  return lines.join("\n");
+}
+
+function pad(n: number, len = 2): string {
+  return String(n).padStart(len, "0");
+}
+
+async function softEmbed(
+  runner: FFmpegRunner,
+  videoPath: string,
+  subPath: string,
+  lang: string,
+  ext: string,
+  info: InfoDict,
+): Promise<string> {
+  const dir = dirname(videoPath);
+  const stem = basename(videoPath, extname(videoPath));
+  const outPath = join(dir, `${stem}.${ext}`);
+  const tmpPath = join(dir, `${stem}.sub_tmp.${ext}`);
+
+  let args: string[];
+
+  if (ext === "mkv") {
+    args = [
+      "-i", videoPath,
+      "-i", subPath,
+      "-c", "copy",
+      "-metadata:s:s:0", `language=${lang}`,
+      tmpPath,
+    ];
+  } else if (ext === "mp4") {
+    args = [
+      "-i", videoPath,
+      "-i", subPath,
+      "-c", "copy",
+      "-c:s", "mov_text",
+      "-metadata:s:s:0", `language=${lang}`,
+      tmpPath,
+    ];
+  } else {
+    return videoPath;
+  }
+
+  await runner.run(args, undefined, info.duration);
+
+  const { rename } = await import("node:fs/promises");
+  await rename(tmpPath, outPath);
+  return outPath;
+}
+
+async function burnInSubtitle(
+  runner: FFmpegRunner,
+  videoPath: string,
+  subPath: string,
+  ext: string,
+  info: InfoDict,
+  onProgress?: (p: number) => void,
+): Promise<string> {
+  const dir = dirname(videoPath);
+  const stem = basename(videoPath, extname(videoPath));
+  const outPath = join(dir, `${stem}_hardsub.${ext}`);
+
+  const subExt = extname(subPath).slice(1).toLowerCase();
+  const filter = subExt === "ass" ? `ass=${subPath}` : `subtitles=${subPath}`;
+
+  const args = [
+    "-i", videoPath,
+    "-vf", filter,
+    "-c:a", "copy",
+    outPath,
+  ];
+
+  await runner.run(
+    args,
+    onProgress ? (p) => { if (p.percent !== undefined) onProgress(p.percent); } : undefined,
+    info.duration,
+  );
+
+  return outPath;
+}

package/src/postprocessors/thumbnails.ts

@@ -0,0 +1,194 @@
+import { PostProcessor, PostProcessError } from "../core/types";
+import type { InfoDict, PostProcessResult } from "../core/types";
+import { FFmpegRunner } from "./ffmpeg";
+import { dirname, basename, extname, join } from "node:path";
+
+export type ThumbnailFormat = "jpg" | "png" | "webp";
+
+export interface ThumbnailOptions {
+  format?: ThumbnailFormat;
+  embedInAudio?: boolean;
+  embedInVideo?: boolean;
+  ffmpegLocation?: string | null;
+}
+
+export class ThumbnailPostProcessor extends PostProcessor {
+  readonly _NAME = "EmbedThumbnail";
+
+  private opts: ThumbnailOptions;
+
+  constructor(opts: ThumbnailOptions = {}) {
+    super();
+    this.opts = opts;
+  }
+
+  async run(info: InfoDict, filepath: string): Promise<PostProcessResult> {
+    const thumbnails = info.thumbnails;
+    if (!thumbnails || thumbnails.length === 0) {
+      return { filepath, info, files_to_delete: [] };
+    }
+
+    const best = thumbnails
+      .slice()
+      .sort((a, b) => (b.preference ?? 0) - (a.preference ?? 0))[0];
+
+    if (!best?.url) {
+      return { filepath, info, files_to_delete: [] };
+    }
+
+    const runner = await FFmpegRunner.detect(this.opts.ffmpegLocation);
+    const dir = dirname(filepath);
+    const ext = extname(filepath).slice(1).toLowerCase();
+
+    const thumbExt = this.opts.format ?? "jpg";
+    const thumbPath = join(dir, `${basename(filepath, extname(filepath))}.${thumbExt}`);
+    const filesToDelete: string[] = [];
+
+    await downloadThumbnail(best.url, thumbPath);
+    filesToDelete.push(thumbPath);
+
+    if (this.opts.embedInAudio && isAudio(ext)) {
+      const result = await embedInAudio(runner, filepath, thumbPath, ext, info);
+      return { ...result, files_to_delete: [...result.files_to_delete, ...filesToDelete] };
+    }
+
+    if (this.opts.embedInVideo !== false && isVideo(ext)) {
+      const result = await embedInVideo(runner, filepath, thumbPath, ext, info);
+      return { ...result, files_to_delete: [...result.files_to_delete, ...filesToDelete] };
+    }
+
+    return { filepath, info, files_to_delete: filesToDelete };
+  }
+}
+
+async function downloadThumbnail(url: string, dest: string): Promise<void> {
+  const res = await fetch(url);
+  if (!res.ok) throw new PostProcessError(`Failed to download thumbnail: HTTP ${res.status}`);
+  const buffer = await res.arrayBuffer();
+  await Bun.file(dest).writer().write(new Uint8Array(buffer));
+}
+
+async function embedInAudio(
+  runner: FFmpegRunner,
+  audioPath: string,
+  thumbPath: string,
+  ext: string,
+  info: InfoDict,
+): Promise<PostProcessResult> {
+  const dir = dirname(audioPath);
+  const stem = basename(audioPath, extname(audioPath));
+  const tmpPath = join(dir, `${stem}.thumb_tmp.${ext}`);
+
+  let args: string[];
+
+  if (ext === "mp3") {
+    args = [
+      "-i", audioPath,
+      "-i", thumbPath,
+      "-map", "0:a",
+      "-map", "1:v",
+      "-c:a", "copy",
+      "-c:v", "mjpeg",
+      "-id3v2_version", "3",
+      "-metadata:s:v", "title=Album cover",
+      "-metadata:s:v", "comment=Cover (front)",
+      tmpPath,
+    ];
+  } else if (ext === "m4a") {
+    args = [
+      "-i", audioPath,
+      "-i", thumbPath,
+      "-map", "0:a",
+      "-map", "1:v",
+      "-c:a", "copy",
+      "-c:v", "copy",
+      "-disposition:v:0", "attached_pic",
+      tmpPath,
+    ];
+  } else if (ext === "flac") {
+    args = [
+      "-i", audioPath,
+      "-i", thumbPath,
+      "-map", "0",
+      "-map", "1:v",
+      "-c", "copy",
+      "-metadata:s:v:0", "comment=Cover (front)",
+      tmpPath,
+    ];
+  } else {
+    args = [
+      "-i", audioPath,
+      "-i", thumbPath,
+      "-map", "0:a",
+      "-map", "1:v",
+      "-c", "copy",
+      tmpPath,
+    ];
+  }
+
+  await runner.run(args, undefined, info.duration);
+
+  const { rename } = await import("node:fs/promises");
+  await rename(tmpPath, audioPath);
+
+  return { filepath: audioPath, info, files_to_delete: [] };
+}
+
+async function embedInVideo(
+  runner: FFmpegRunner,
+  videoPath: string,
+  thumbPath: string,
+  ext: string,
+  info: InfoDict,
+): Promise<PostProcessResult> {
+  const dir = dirname(videoPath);
+  const stem = basename(videoPath, extname(videoPath));
+  const tmpPath = join(dir, `${stem}.thumb_tmp.${ext}`);
+
+  let args: string[];
+
+  if (ext === "mkv" || ext === "webm") {
+    args = [
+      "-i", videoPath,
+      "-attach", thumbPath,
+      "-metadata:s:t", "mimetype=image/jpeg",
+      "-c", "copy",
+      tmpPath,
+    ];
+  } else if (ext === "mp4") {
+    args = [
+      "-i", videoPath,
+      "-i", thumbPath,
+      "-map", "0",
+      "-map", "1",
+      "-c", "copy",
+      "-c:v:1", "png",
+      "-disposition:v:1", "attached_pic",
+      tmpPath,
+    ];
+  } else {
+    args = [
+      "-i", videoPath,
+      "-i", thumbPath,
+      "-map", "0",
+      "-map", "1:v",
+      "-c", "copy",
+      tmpPath,
+    ];
+  }
+
+  await runner.run(args, undefined, info.duration);
+
+  const { rename } = await import("node:fs/promises");
+  await rename(tmpPath, videoPath);
+
+  return { filepath: videoPath, info, files_to_delete: [] };
+}
+
+function isAudio(ext: string): boolean {
+  return ["mp3", "m4a", "flac", "ogg", "wav", "aac", "opus"].includes(ext);
+}
+
+function isVideo(ext: string): boolean {
+  return ["mp4", "mkv", "webm", "avi", "mov"].includes(ext);
+}