mpup 0.1.0__py3-none-any.whl

mpup/__init__.py

@@ -0,0 +1,3 @@
+"""MPUp song background and video generator."""
+
+__version__ = "0.1.0"

mpup/__main__.py

@@ -0,0 +1,5 @@
+from mpup.cli import entrypoint
+
+
+if __name__ == "__main__":
+    entrypoint()

mpup/background.py

@@ -0,0 +1,122 @@
+"""Render song title and artist onto a background template."""
+
+from __future__ import annotations
+
+import os
+import tempfile
+from pathlib import Path
+
+from PIL import Image, ImageDraw, ImageFont
+
+from mpup.config import TemplateConfig, TextBox
+
+
+FONT_CANDIDATES = (
+    Path("/System/Library/Fonts/PingFang.ttc"),
+    Path("/System/Library/Fonts/STHeiti Medium.ttc"),
+    Path("/System/Library/Fonts/Supplemental/Arial Unicode.ttf"),
+    Path("/usr/share/fonts/opentype/noto/NotoSansCJK-Regular.ttc"),
+    Path("/usr/share/fonts/truetype/wqy/wqy-zenhei.ttc"),
+    Path("C:/Windows/Fonts/msyh.ttc"),
+)
+
+
+def resolve_font(explicit_path: Path | None = None) -> Path:
+    """Resolve an explicit or common system CJK font."""
+    if explicit_path is not None:
+        candidate = explicit_path.expanduser()
+        if not candidate.is_file():
+            raise ValueError(f"字体文件不存在：{explicit_path}")
+        return candidate.resolve()
+    for candidate in FONT_CANDIDATES:
+        if candidate.is_file():
+            return candidate.resolve()
+    raise ValueError("未找到可用中文字体，请通过 --font 指定字体文件")
+
+
+def fit_font(
+    draw: ImageDraw.ImageDraw,
+    text: str,
+    font_path: Path,
+    box: TextBox,
+) -> ImageFont.FreeTypeFont:
+    """Return the largest configured font that fits the text box."""
+    if not text:
+        raise ValueError("文本不能为空")
+    for size in range(box.max_font_size, box.min_font_size - 1, -1):
+        font = ImageFont.truetype(str(font_path), size=size)
+        left, top, right, bottom = draw.textbbox((0, 0), text, font=font)
+        if right - left <= box.rect.width and bottom - top <= box.rect.height:
+            return font
+    raise ValueError(
+        f"文本在最小字号 {box.min_font_size}px 下仍无法放入配置区域：{text}"
+    )
+
+
+def _draw_text(
+    draw: ImageDraw.ImageDraw,
+    text: str,
+    font_path: Path,
+    box: TextBox,
+    config: TemplateConfig,
+) -> None:
+    font = fit_font(draw, text, font_path, box)
+    position = (box.horizontal_center, box.rect.center_y)
+    shadow = (
+        position[0] + config.shadow_offset,
+        position[1] + config.shadow_offset,
+    )
+    draw.text(shadow, text, font=font, fill=config.shadow_fill, anchor="mm")
+    draw.text(position, text, font=font, fill=config.text_fill, anchor="mm")
+
+
+def render_background(
+    base_path: Path,
+    output_path: Path,
+    config: TemplateConfig,
+    title: str,
+    artist: str,
+    font_path: Path,
+    overwrite: bool = False,
+) -> None:
+    """Render a song-specific PNG and publish it atomically."""
+    if output_path.exists() and not overwrite:
+        raise FileExistsError(f"背景图已存在：{output_path}")
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+
+    try:
+        with Image.open(base_path) as source:
+            source.load()
+            if source.size != (config.width, config.height):
+                raise ValueError(
+                    "背景图尺寸与配置不一致："
+                    f"实际 {source.width}x{source.height}，"
+                    f"配置 {config.width}x{config.height}"
+                )
+            image = source.convert("RGB")
+    except OSError as error:
+        raise ValueError(f"无法读取背景图：{base_path}") from error
+
+    draw = ImageDraw.Draw(image)
+    _draw_text(draw, title, font_path, config.song_title, config)
+    _draw_text(draw, artist, font_path, config.artist, config)
+
+    temporary = tempfile.NamedTemporaryFile(
+        prefix=f".{output_path.stem}.",
+        suffix=".tmp.png",
+        dir=output_path.parent,
+        delete=False,
+    )
+    temporary_path = Path(temporary.name)
+    temporary.close()
+    try:
+        image.save(temporary_path, format="PNG")
+        with Image.open(temporary_path) as verification:
+            verification.load()
+            if verification.size != (config.width, config.height):
+                raise RuntimeError("生成的背景图尺寸验证失败")
+        os.replace(temporary_path, output_path)
+    except OSError as error:
+        raise RuntimeError(f"无法写入背景图：{output_path}") from error
+    finally:
+        temporary_path.unlink(missing_ok=True)

mpup/cli.py

@@ -0,0 +1,159 @@
+"""Command-line interface for the song background video pipeline."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from collections.abc import Sequence
+from pathlib import Path
+from typing import TextIO
+
+from tqdm import tqdm
+
+from mpup.background import resolve_font
+from mpup.config import load_template_config
+from mpup.discovery import discover_audio
+from mpup.metadata import require_media_tools, require_remotion_runtime
+from mpup.pipeline import BatchResult, ProgressEvent, ProgressReporter, process_batch
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="mpup",
+        description="根据音频元数据、封面和同步歌词生成 1080P 音乐视频",
+    )
+    parser.add_argument("input", metavar="INPUT", help="音频文件或音频目录")
+    parser.add_argument(
+        "--background",
+        default="assets/background.png",
+        metavar="PATH",
+        help="基础背景 PNG（默认：assets/background.png）",
+    )
+    parser.add_argument(
+        "--config",
+        default="assets/bg-cfg.json",
+        metavar="PATH",
+        help="背景布局 JSON（默认：assets/bg-cfg.json）",
+    )
+    parser.add_argument(
+        "--output-dir",
+        default="output",
+        metavar="PATH",
+        help="PNG 和 MP4 输出目录（默认：output）",
+    )
+    parser.add_argument(
+        "--font",
+        metavar="PATH",
+        help="中文 TrueType/OpenType 字体；默认自动发现",
+    )
+    parser.add_argument(
+        "--overwrite",
+        action="store_true",
+        help="允许覆盖已有的最终 MP4；中间产物会直接复用",
+    )
+    return parser
+
+
+def _print_summary(result: BatchResult, stdout: TextIO) -> None:
+    for item in result.successes:
+        sources = ""
+        if item.cover_source is not None and item.lyrics_source is not None:
+            sources = f"（封面={item.cover_source}，歌词={item.lyrics_source}）"
+        audio_target = item.enriched_audio_path or item.input_path
+        print(
+            f"完成 {item.input_path} -> {audio_target} -> {item.video_path}{sources}",
+            file=stdout,
+        )
+        for warning in item.warnings:
+            print(f"警告 {item.input_path}：{warning}", file=stdout)
+    for item in result.skipped:
+        print(f"跳过 {item.input_path}：{item.message}", file=stdout)
+    for item in result.failed:
+        print(f"失败 {item.input_path}：{item.message}", file=stdout)
+    print(
+        f"完成：{len(result.successes)}，"
+        f"跳过：{len(result.skipped)}，"
+        f"失败：{len(result.failed)}",
+        file=stdout,
+    )
+
+
+_STAGE_LABELS = {
+    "metadata": "读取元数据",
+    "cover": "获取封面",
+    "lyrics": "获取 LRC/歌词",
+    "enriched_audio": "写入增强 MP3",
+    "background": "绘制背景图",
+    "render_prepare": "准备 Remotion",
+    "remotion": "Remotion 渲染",
+    "publish": "校验并发布视频",
+    "completed": "处理完成",
+}
+
+
+def _progress_reporter(audio_paths: Sequence[Path], stdout: TextIO) -> ProgressReporter:
+    """Render detailed milestones for one song or one quiet bar for a batch."""
+    if len(audio_paths) == 1:
+        def report_single(event: ProgressEvent) -> None:
+            if event.input_path is None:
+                return
+            label = _STAGE_LABELS.get(event.stage)
+            if label is not None:
+                print(f"[{event.input_path.name}] {label}", file=stdout)
+
+        return report_single
+
+    progress_bar: object | None = None
+
+    def report_batch(event: ProgressEvent) -> None:
+        nonlocal progress_bar
+        if event.stage == "batch_start":
+            progress_bar = tqdm(total=len(audio_paths), desc="处理音频", unit="首")
+        elif event.stage == "completed" and progress_bar is not None:
+            progress_bar.set_postfix_str(event.input_path.name if event.input_path else "")
+            progress_bar.update()
+        elif event.stage == "batch_completed" and progress_bar is not None:
+            progress_bar.close()
+
+    return report_batch
+
+
+def main(
+    argv: Sequence[str] | None = None,
+    *,
+    stdout: TextIO = sys.stdout,
+    stderr: TextIO = sys.stderr,
+) -> int:
+    args = build_parser().parse_args(argv)
+    try:
+        audio_paths = discover_audio(Path(args.input))
+        config = load_template_config(Path(args.config))
+        font_path = resolve_font(Path(args.font) if args.font else None)
+        ffmpeg, ffprobe = require_media_tools()
+        node, _remotion_entry = require_remotion_runtime()
+        progress = _progress_reporter(audio_paths, stdout)
+        result = process_batch(
+            audio_paths,
+            Path(args.background),
+            config,
+            Path(args.output_dir),
+            font_path,
+            ffmpeg,
+            ffprobe,
+            args.overwrite,
+            node=node,
+            progress=progress,
+        )
+    except KeyboardInterrupt:
+        print("错误：操作已中断", file=stderr)
+        return 130
+    except Exception as error:
+        print(f"错误：{error}", file=stderr)
+        return 2
+
+    _print_summary(result, stdout)
+    return result.exit_code
+
+
+def entrypoint() -> None:
+    raise SystemExit(main())

mpup/config.py

@@ -0,0 +1,187 @@
+"""Load and validate background template configuration."""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+
+@dataclass(frozen=True)
+class Rect:
+    x: int
+    y: int
+    width: int
+    height: int
+
+    @property
+    def right(self) -> int:
+        return self.x + self.width
+
+    @property
+    def bottom(self) -> int:
+        return self.y + self.height
+
+    @property
+    def center_y(self) -> float:
+        return self.y + self.height / 2
+
+    def contains(self, other: "Rect") -> bool:
+        return (
+            self.x <= other.x
+            and self.y <= other.y
+            and self.right >= other.right
+            and self.bottom >= other.bottom
+        )
+
+
+@dataclass(frozen=True)
+class TextBox:
+    rect: Rect
+    horizontal_center: int
+    min_font_size: int
+    max_font_size: int
+
+
+@dataclass(frozen=True)
+class TemplateConfig:
+    width: int
+    height: int
+    song_title: TextBox
+    artist: TextBox
+    text_fill: str = "#F4F8FF"
+    shadow_fill: str = "#142A66"
+    shadow_offset: int = 3
+
+
+def _mapping(value: object, path: str) -> dict[str, Any]:
+    if not isinstance(value, dict):
+        raise ValueError(f"{path} 必须是 JSON 对象")
+    return value
+
+
+def _field(mapping: dict[str, Any], name: str, path: str) -> Any:
+    if name not in mapping:
+        raise ValueError(f"缺少配置字段：{path}.{name}")
+    return mapping[name]
+
+
+def _integer(
+    mapping: dict[str, Any],
+    name: str,
+    path: str,
+    *,
+    allow_zero: bool = False,
+) -> int:
+    value = _field(mapping, name, path)
+    minimum = 0 if allow_zero else 1
+    if isinstance(value, bool) or not isinstance(value, int) or value < minimum:
+        qualifier = "非负整数" if allow_zero else "正整数"
+        raise ValueError(f"{path}.{name} 必须是{qualifier}")
+    return value
+
+
+def _rect(mapping: dict[str, Any], path: str, canvas: Rect) -> Rect:
+    rect = Rect(
+        x=_integer(mapping, "x", path, allow_zero=True),
+        y=_integer(mapping, "y", path, allow_zero=True),
+        width=_integer(mapping, "width", path),
+        height=_integer(mapping, "height", path),
+    )
+    if not canvas.contains(rect):
+        raise ValueError(f"{path} 必须完整位于 canvas 内")
+    return rect
+
+
+def _text_box(
+    mapping: dict[str, Any],
+    path: str,
+    canvas: Rect,
+    safe_area: Rect,
+    maximum_text_y: int,
+) -> TextBox:
+    rect = _rect(mapping, path, canvas)
+    if not safe_area.contains(rect):
+        raise ValueError(f"{path} 必须完整位于 speechBubble.safeTextArea 内")
+    if rect.bottom > maximum_text_y:
+        raise ValueError(f"{path} 不能超过 recommendations.maximumTextY")
+
+    horizontal_center = _integer(mapping, "horizontalCenter", path, allow_zero=True)
+    if not rect.x <= horizontal_center <= rect.right:
+        raise ValueError(f"{path}.horizontalCenter 必须位于文本框内")
+    if _field(mapping, "alignment", path) != "center":
+        raise ValueError(f"{path}.alignment 必须为 center")
+
+    font_path = f"{path}.recommendedFontSize"
+    font_sizes = _mapping(_field(mapping, "recommendedFontSize", path), font_path)
+    minimum = _integer(font_sizes, "min", font_path)
+    maximum = _integer(font_sizes, "max", font_path)
+    if minimum > maximum:
+        raise ValueError(f"{font_path}.min 不能大于 max")
+    if _field(font_sizes, "unit", font_path) != "px":
+        raise ValueError(f"{font_path}.unit 必须为 px")
+    return TextBox(rect, horizontal_center, minimum, maximum)
+
+
+def load_template_config(path: Path) -> TemplateConfig:
+    """Load the supplied JSON template into validated typed values."""
+    try:
+        raw = path.read_text(encoding="utf-8")
+    except OSError as error:
+        raise ValueError(f"无法读取配置文件：{path}") from error
+    try:
+        payload = json.loads(raw)
+    except json.JSONDecodeError as error:
+        raise ValueError(f"配置文件包含无效 JSON：{path}") from error
+    root = _mapping(payload, "root")
+
+    canvas_raw = _mapping(_field(root, "canvas", "root"), "canvas")
+    width = _integer(canvas_raw, "width", "canvas")
+    height = _integer(canvas_raw, "height", "canvas")
+    if _field(canvas_raw, "coordinateOrigin", "canvas") != "top-left":
+        raise ValueError("canvas.coordinateOrigin 必须为 top-left")
+    canvas = Rect(0, 0, width, height)
+
+    bubble_raw = _mapping(_field(root, "speechBubble", "root"), "speechBubble")
+    bubble_bounds = _rect(
+        _mapping(_field(bubble_raw, "bounds", "speechBubble"), "speechBubble.bounds"),
+        "speechBubble.bounds",
+        canvas,
+    )
+    safe_area = _rect(
+        _mapping(
+            _field(bubble_raw, "safeTextArea", "speechBubble"),
+            "speechBubble.safeTextArea",
+        ),
+        "speechBubble.safeTextArea",
+        canvas,
+    )
+    if not bubble_bounds.contains(safe_area):
+        raise ValueError("speechBubble.safeTextArea 必须位于 speechBubble.bounds 内")
+
+    recommendations = _mapping(
+        _field(root, "recommendations", "root"), "recommendations"
+    )
+    maximum_text_y = _integer(
+        recommendations, "maximumTextY", "recommendations", allow_zero=True
+    )
+    if maximum_text_y > height:
+        raise ValueError("recommendations.maximumTextY 不能超过 canvas.height")
+
+    text_boxes = _mapping(_field(root, "textBoxes", "root"), "textBoxes")
+    song_title = _text_box(
+        _mapping(_field(text_boxes, "songTitle", "textBoxes"), "textBoxes.songTitle"),
+        "textBoxes.songTitle",
+        canvas,
+        safe_area,
+        maximum_text_y,
+    )
+    artist = _text_box(
+        _mapping(_field(text_boxes, "artist", "textBoxes"), "textBoxes.artist"),
+        "textBoxes.artist",
+        canvas,
+        safe_area,
+        maximum_text_y,
+    )
+    return TemplateConfig(width, height, song_title, artist)