Nymiro
533 lines
20 KiB
Python
533 lines
20 KiB
Python
#!/usr/bin/env python3
|
|
"""
|
|
GUI batch utility for inspecting Live Photo / Motion Photo media trees.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import os
|
|
import queue
|
|
import shutil
|
|
import subprocess
|
|
import threading
|
|
from concurrent.futures import ThreadPoolExecutor, as_completed
|
|
from dataclasses import dataclass
|
|
from pathlib import Path
|
|
from typing import Callable, Dict, List, Tuple
|
|
|
|
import tkinter as tk
|
|
from tkinter import filedialog, messagebox, ttk
|
|
|
|
# 假设 pyheic_struct 在你的 Python 路径中
|
|
# from pyheic_struct import AppleTargetAdapter, HEICFile, convert_motion_photo
|
|
|
|
# --- Mocking pyheic_struct for testing if not installed ---
|
|
# 如果你没有安装 pyheic_struct，请取消注释下面的部分来模拟它
|
|
try:
|
|
from pyheic_struct import AppleTargetAdapter, HEICFile, convert_motion_photo
|
|
except ImportError:
|
|
print("Warning: pyheic_struct not found. Using mock objects.")
|
|
|
|
class MockHEICFile:
|
|
def __init__(self, path: str):
|
|
self._path = Path(path)
|
|
def find_box(self, box_type: str) -> bool:
|
|
# 模拟三星 motion photo
|
|
return "samsung" in self._path.name.lower()
|
|
|
|
class MockAppleTargetAdapter:
|
|
pass
|
|
|
|
def mock_convert_motion_photo(heic_path, vendor_hint, target_adapter, output_still, output_video, inject_content_id_into_mov):
|
|
output_still.touch()
|
|
output_video.touch()
|
|
return output_still, output_video
|
|
|
|
HEICFile = MockHEICFile
|
|
AppleTargetAdapter = MockAppleTargetAdapter
|
|
convert_motion_photo = mock_convert_motion_photo
|
|
# --- End of Mocking ---
|
|
|
|
|
|
STILL_SUFFIXES = {".heic", ".heif"}
|
|
VIDEO_SUFFIXES = {".mov", ".mp4", ".m4v", ".qt", ".3gp"}
|
|
|
|
TRANSLATIONS: Dict[str, Dict[str, str]] = {
|
|
"zh": {
|
|
"app_title": "Live Photo / Motion Photo 批处理工具",
|
|
"menu_language": "语言",
|
|
"menu_language_zh": "中文",
|
|
"menu_language_en": "English",
|
|
"label_directory": "处理目录:",
|
|
"button_browse": "选择…",
|
|
"group_options": "可选功能",
|
|
"option_live_pair": "检测 Live Photo 配对并移动缺失伴侣的视频",
|
|
"option_convert_motion": "将三星 Motion Photo 转换为 Live Photo",
|
|
"option_cleanup_mp4": "清除带有 MotionPhoto_Data 标记的多余 MP4",
|
|
"label_workers": "并发线程数:",
|
|
"button_start": "开始处理",
|
|
"progress_status": "进度: {done} / {total}",
|
|
"log_group": "日志",
|
|
"warn_processing_title": "正在处理",
|
|
"warn_processing_body": "任务仍在运行，请稍候。",
|
|
"error_invalid_dir_title": "无效路径",
|
|
"error_invalid_dir_body": "请选择一个有效的目录。",
|
|
"general_yes": "是",
|
|
"general_no": "否",
|
|
"log_root_dir": "处理目录: {path}",
|
|
"log_exiftool": "exiftool 可用: {status}",
|
|
"log_scanning": "正在扫描媒体文件……",
|
|
"log_no_tasks": "未找到任何任务，无需处理。",
|
|
"log_executing": "共有 {total} 个任务，使用 {workers} 个线程执行……",
|
|
"log_task_entry": "[{task}] {result}",
|
|
"log_finished": "全部任务已完成。",
|
|
"log_processing_done": "处理完毕。",
|
|
"task_orphan_video": "孤立视频: {path}",
|
|
"task_motion_convert": "Motion Photo 转 Live Photo: {path}",
|
|
"task_cleanup_mp4": "清理 MP4: {path}",
|
|
"result_moved": "已移动到 {dest}",
|
|
"result_skipped_exists": "已存在转换结果，跳过",
|
|
"result_converted": "已转换为 {heic} / {mov}",
|
|
"result_cleanup_removed": "已删除 (MotionPhoto_Data)",
|
|
"result_cleanup_kept": "保留",
|
|
"result_cleanup_skipped": "跳过 (缺少 exiftool)",
|
|
"result_failed": "失败: {error}",
|
|
},
|
|
"en": {
|
|
"app_title": "Live / Motion Photo Batch Manager",
|
|
"menu_language": "Language",
|
|
"menu_language_zh": "Chinese",
|
|
"menu_language_en": "English",
|
|
"label_directory": "Folder:",
|
|
"button_browse": "Browse…",
|
|
"group_options": "Optional Tasks",
|
|
"option_live_pair": "Check Live Photo pairs and move orphaned videos",
|
|
"option_convert_motion": "Convert Samsung Motion Photos to Live Photo",
|
|
"option_cleanup_mp4": "Remove redundant MP4 files tagged MotionPhoto_Data",
|
|
"label_workers": "Worker threads:",
|
|
"button_start": "Start",
|
|
"progress_status": "Progress: {done} / {total}",
|
|
"log_group": "Log",
|
|
"warn_processing_title": "Processing",
|
|
"warn_processing_body": "Tasks are still running. Please wait.",
|
|
"error_invalid_dir_title": "Invalid Path",
|
|
"error_invalid_dir_body": "Please choose a valid directory.",
|
|
"general_yes": "yes",
|
|
"general_no": "no",
|
|
"log_root_dir": "Root directory: {path}",
|
|
"log_exiftool": "exiftool available: {status}",
|
|
"log_scanning": "Scanning media files...",
|
|
"log_no_tasks": "No tasks found. Nothing to do.",
|
|
"log_executing": "Executing {total} task(s) with {workers} worker(s)...",
|
|
"log_task_entry": "[{task}] {result}",
|
|
"log_finished": "All tasks completed.",
|
|
"log_processing_done": "Processing finished.",
|
|
"task_orphan_video": "Orphan video: {path}",
|
|
"task_motion_convert": "Motion Photo → Live Photo: {path}",
|
|
"task_cleanup_mp4": "Cleanup MP4: {path}",
|
|
"result_moved": "Moved to {dest}",
|
|
"result_skipped_exists": "Skipped (outputs already exist)",
|
|
"result_converted": "Converted to {heic} / {mov}",
|
|
"result_cleanup_removed": "Removed (MotionPhoto_Data)",
|
|
"result_cleanup_kept": "Kept",
|
|
"result_cleanup_skipped": "Skipped (exiftool unavailable)",
|
|
"result_failed": "Failed: {error}",
|
|
},
|
|
}
|
|
|
|
|
|
@dataclass
|
|
class ProcessingOptions:
|
|
root_dir: Path
|
|
handle_live_pairs: bool
|
|
convert_motion: bool
|
|
remove_motion_mp4: bool
|
|
max_workers: int
|
|
|
|
|
|
@dataclass
|
|
class Task:
|
|
func: Callable[[], str | None]
|
|
description: str
|
|
|
|
|
|
def _is_motion_photo(heic_path: Path) -> bool:
|
|
try:
|
|
heic = HEICFile(str(heic_path))
|
|
return heic.find_box("mpvd") is not None
|
|
except Exception:
|
|
return False
|
|
|
|
|
|
def _move_orphan_video(mov_path: Path, root_dir: Path, tr: Callable[[str], str]) -> str:
|
|
error_dir = root_dir / "错误的LivePhoto视频"
|
|
error_dir.mkdir(parents=True, exist_ok=True)
|
|
|
|
destination = error_dir / mov_path.name
|
|
counter = 1
|
|
while destination.exists():
|
|
destination = error_dir / f"{mov_path.stem}_{counter}{mov_path.suffix}"
|
|
counter += 1
|
|
|
|
shutil.move(str(mov_path), str(destination))
|
|
return tr("result_moved", dest=str(destination))
|
|
|
|
|
|
def _convert_motion_photo(heic_path: Path, inject_mov_tag: bool, tr: Callable[[str], str]) -> str:
|
|
output_still = heic_path.with_name(f"{heic_path.stem}_apple_compatible.HEIC")
|
|
output_video = heic_path.with_name(f"{heic_path.stem}_apple_compatible.MOV")
|
|
|
|
if output_still.exists() or output_video.exists():
|
|
return tr("result_skipped_exists")
|
|
|
|
heic_out, mov_out = convert_motion_photo(
|
|
heic_path,
|
|
vendor_hint="samsung",
|
|
target_adapter=AppleTargetAdapter(),
|
|
output_still=output_still,
|
|
output_video=output_video,
|
|
inject_content_id_into_mov=inject_mov_tag,
|
|
)
|
|
return tr("result_converted", heic=heic_out.name, mov=mov_out.name)
|
|
|
|
|
|
def _cleanup_motion_mp4(mp4_path: Path, has_exiftool: bool, tr: Callable[[str], str]) -> str:
|
|
if not has_exiftool:
|
|
return tr("result_cleanup_skipped")
|
|
|
|
cmd = [
|
|
"exiftool",
|
|
"-s",
|
|
"-s",
|
|
"-s",
|
|
"-EmbeddedVideoType",
|
|
str(mp4_path),
|
|
]
|
|
result = subprocess.run(cmd, capture_output=True, text=True, check=False)
|
|
output = result.stdout.strip()
|
|
|
|
if "MotionPhoto_Data" in output:
|
|
mp4_path.unlink(missing_ok=True)
|
|
return tr("result_cleanup_removed")
|
|
return tr("result_cleanup_kept")
|
|
|
|
|
|
def _gather_tasks(
|
|
options: ProcessingOptions,
|
|
has_exiftool: bool,
|
|
log: Callable[[str], None],
|
|
tr: Callable[[str], str],
|
|
) -> List[Task]:
|
|
tasks: List[Task] = []
|
|
base_map: Dict[Tuple[Path, str], Dict[str, object]] = {}
|
|
heic_files: List[Path] = []
|
|
mp4_files: List[Path] = []
|
|
|
|
log(tr("log_scanning"))
|
|
for path in options.root_dir.rglob("*"):
|
|
if not path.is_file():
|
|
continue
|
|
suffix = path.suffix.lower()
|
|
|
|
if suffix in STILL_SUFFIXES:
|
|
heic_files.append(path)
|
|
key = (path.parent, path.stem.lower())
|
|
entry = base_map.setdefault(key, {})
|
|
entry["still"] = path
|
|
elif suffix in VIDEO_SUFFIXES:
|
|
key = (path.parent, path.stem.lower())
|
|
entry = base_map.setdefault(key, {})
|
|
entry.setdefault("videos", []).append(path) # type: ignore
|
|
if suffix == ".mp4":
|
|
mp4_files.append(path)
|
|
|
|
if options.handle_live_pairs:
|
|
for entry in base_map.values():
|
|
has_still = "still" in entry
|
|
videos = entry.get("videos") or []
|
|
if not has_still and videos:
|
|
for video_path in videos: # type: ignore
|
|
tasks.append(
|
|
Task(
|
|
func=lambda p=video_path, tr=tr: _move_orphan_video(p, options.root_dir, tr),
|
|
description=tr("task_orphan_video", path=str(video_path)),
|
|
)
|
|
)
|
|
|
|
if options.convert_motion:
|
|
inject_mov_tag = has_exiftool
|
|
for heic_path in heic_files:
|
|
key = (heic_path.parent, heic_path.stem.lower())
|
|
entry = base_map.get(key, {})
|
|
videos = entry.get("videos") or []
|
|
has_mov = any(v.suffix.lower() == ".mov" for v in videos) # type: ignore
|
|
if has_mov:
|
|
continue
|
|
if not _is_motion_photo(heic_path):
|
|
continue
|
|
tasks.append(
|
|
Task(
|
|
func=lambda p=heic_path, tr=tr: _convert_motion_photo(p, inject_mov_tag, tr),
|
|
description=tr("task_motion_convert", path=str(heic_path)),
|
|
)
|
|
)
|
|
|
|
if options.remove_motion_mp4:
|
|
for mp4_path in mp4_files:
|
|
tasks.append(
|
|
Task(
|
|
func=lambda p=mp4_path, tr=tr: _cleanup_motion_mp4(p, has_exiftool, tr),
|
|
description=tr("task_cleanup_mp4", path=str(mp4_path)),
|
|
)
|
|
)
|
|
|
|
return tasks
|
|
|
|
|
|
def _worker(options: ProcessingOptions, message_queue: queue.Queue, language: str) -> None:
|
|
has_exiftool = shutil.which("exiftool") is not None
|
|
|
|
lang_map = TRANSLATIONS.get(language, TRANSLATIONS["zh"])
|
|
|
|
def tr(key: str, **kwargs) -> str:
|
|
template = lang_map.get(key, TRANSLATIONS["zh"].get(key, key))
|
|
return template.format(**kwargs)
|
|
|
|
def emit_log(message: str) -> None:
|
|
message_queue.put(("log", message))
|
|
|
|
emit_log(tr("log_root_dir", path=str(options.root_dir)))
|
|
status_text = tr("general_yes") if has_exiftool else tr("general_no")
|
|
emit_log(tr("log_exiftool", status=status_text))
|
|
|
|
try:
|
|
tasks = _gather_tasks(options, has_exiftool, emit_log, tr)
|
|
total = len(tasks)
|
|
message_queue.put(("progress_setup", total))
|
|
|
|
if total == 0:
|
|
emit_log(tr("log_no_tasks"))
|
|
message_queue.put(("finished", None))
|
|
return
|
|
|
|
max_workers = max(1, options.max_workers)
|
|
emit_log(tr("log_executing", total=total, workers=max_workers))
|
|
|
|
completed = 0
|
|
with ThreadPoolExecutor(max_workers=max_workers) as executor:
|
|
future_map = {executor.submit(task.func): task for task in tasks}
|
|
for future in as_completed(future_map):
|
|
task = future_map[future]
|
|
try:
|
|
outcome = future.result()
|
|
result_text = outcome if outcome else "done"
|
|
except Exception as exc:
|
|
result_text = tr("result_failed", error=exc)
|
|
emit_log(tr("log_task_entry", task=task.description, result=result_text))
|
|
completed += 1
|
|
message_queue.put(("progress", completed))
|
|
|
|
emit_log(tr("log_finished"))
|
|
except Exception as e:
|
|
emit_log(tr("result_failed", error=e))
|
|
finally:
|
|
message_queue.put(("finished", None))
|
|
|
|
|
|
class BatchManagerGUI:
|
|
|
|
# --- 修复 ---
|
|
# 删除了第一个 __init__，并将 self.lang 添加到第二个 __init__
|
|
|
|
def __init__(self) -> None:
|
|
self.root = tk.Tk()
|
|
self.root.title("Live Photo / Motion Photo 批处理工具")
|
|
self.root.geometry("780x520")
|
|
|
|
# 修复：将 self.lang 的定义合并到这个 __init__ 中
|
|
self.lang = tk.StringVar(value="zh")
|
|
|
|
self.queue: queue.Queue = queue.Queue()
|
|
self.worker_thread: threading.Thread | None = None
|
|
|
|
self.path_var = tk.StringVar()
|
|
self.handle_live_var = tk.BooleanVar(value=True)
|
|
self.convert_motion_var = tk.BooleanVar(value=True)
|
|
self.remove_mp4_var = tk.BooleanVar(value=True)
|
|
default_workers = max(1, min(4, (os.cpu_count() or 4)))
|
|
self.worker_count_var = tk.IntVar(value=default_workers)
|
|
|
|
self.progress_total = 0
|
|
self.progress_done = 0
|
|
|
|
self._build_ui()
|
|
self.root.after(100, self._poll_queue)
|
|
|
|
def run(self) -> None:
|
|
self.root.mainloop()
|
|
|
|
# 辅助函数，用于获取翻译后的文本
|
|
def _t(self, key: str) -> str:
|
|
lang_map = TRANSLATIONS.get(self.lang.get(), TRANSLATIONS["zh"])
|
|
return lang_map.get(key, TRANSLATIONS["zh"].get(key, key))
|
|
|
|
def _build_ui(self) -> None:
|
|
padding = {"padx": 10, "pady": 6}
|
|
|
|
path_frame = ttk.Frame(self.root)
|
|
path_frame.pack(fill="x", **padding)
|
|
|
|
ttk.Label(path_frame, text=self._t("label_directory")).pack(side="left")
|
|
entry = ttk.Entry(path_frame, textvariable=self.path_var)
|
|
entry.pack(side="left", fill="x", expand=True, padx=(8, 8))
|
|
|
|
ttk.Button(path_frame, text=self._t("button_browse"), command=self._choose_directory).pack(side="left")
|
|
|
|
options_frame = ttk.LabelFrame(self.root, text=self._t("group_options"))
|
|
options_frame.pack(fill="x", **padding)
|
|
|
|
ttk.Checkbutton(
|
|
options_frame,
|
|
text=self._t("option_live_pair"),
|
|
variable=self.handle_live_var,
|
|
).pack(anchor="w", padx=8, pady=2)
|
|
ttk.Checkbutton(
|
|
options_frame,
|
|
text=self._t("option_convert_motion"),
|
|
variable=self.convert_motion_var,
|
|
).pack(anchor="w", padx=8, pady=2)
|
|
ttk.Checkbutton(
|
|
options_frame,
|
|
text=self._t("option_cleanup_mp4"),
|
|
variable=self.remove_mp4_var,
|
|
).pack(anchor="w", padx=8, pady=2)
|
|
|
|
worker_frame = ttk.Frame(self.root)
|
|
worker_frame.pack(fill="x", **padding)
|
|
ttk.Label(worker_frame, text=self._t("label_workers")).pack(side="left")
|
|
self.worker_spin = ttk.Spinbox(
|
|
worker_frame,
|
|
from_=1,
|
|
to=32,
|
|
textvariable=self.worker_count_var,
|
|
width=5,
|
|
)
|
|
self.worker_spin.pack(side="left", padx=(8, 0))
|
|
|
|
control_frame = ttk.Frame(self.root)
|
|
control_frame.pack(fill="x", **padding)
|
|
self.start_button = ttk.Button(control_frame, text=self._t("button_start"), command=self._start_processing)
|
|
self.start_button.pack(side="left")
|
|
|
|
self.progress_bar = ttk.Progressbar(self.root, mode="determinate")
|
|
self.progress_bar.pack(fill="x", padx=10, pady=(4, 0))
|
|
|
|
self.progress_label = ttk.Label(self.root, text=self._t("progress_status").format(done=0, total=0))
|
|
self.progress_label.pack(fill="x", padx=10, pady=(2, 6))
|
|
|
|
log_frame = ttk.LabelFrame(self.root, text=self._t("log_group"))
|
|
log_frame.pack(fill="both", expand=True, padx=10, pady=(0, 10))
|
|
self.log_text = tk.Text(log_frame, height=16, wrap="word")
|
|
self.log_text.pack(side="left", fill="both", expand=True)
|
|
scrollbar = ttk.Scrollbar(log_frame, command=self.log_text.yview)
|
|
scrollbar.pack(side="right", fill="y")
|
|
self.log_text.configure(yscrollcommand=scrollbar.set)
|
|
|
|
# P.S. 我还修复了 UI 文本，使其能够响应语言（尽管此脚本中没有切换语言的菜单）
|
|
# 你原来的 _build_ui 使用了硬编码的中文
|
|
self._update_ui_text()
|
|
|
|
def _update_ui_text(self) -> None:
|
|
"""更新界面上所有可翻译的文本 (此脚本中未实现语言切换，但为未来做准备)"""
|
|
self.root.title(self._t("app_title"))
|
|
|
|
# 这里应该重新配置所有 Label, Button, LabelFrame 的 text
|
|
# 为了简洁，我在 _build_ui 中直接使用了 self._t()
|
|
# 如果要实现动态切换，需要在这里引用所有组件并 .config(text=...)
|
|
pass
|
|
|
|
|
|
def _choose_directory(self) -> None:
|
|
selected = filedialog.askdirectory()
|
|
if selected:
|
|
self.path_var.set(selected)
|
|
|
|
def _start_processing(self) -> None:
|
|
# P.S. 我还修复了这里对 _t 方法的调用，你之前遗漏了
|
|
if self.worker_thread and self.worker_thread.is_alive():
|
|
messagebox.showwarning(self._t("warn_processing_title"), self._t("warn_processing_body"))
|
|
return
|
|
|
|
directory = Path(self.path_var.get()).expanduser()
|
|
if not directory.is_dir():
|
|
messagebox.showerror(self._t("error_invalid_dir_title"), self._t("error_invalid_dir_body"))
|
|
return
|
|
|
|
options = ProcessingOptions(
|
|
root_dir=directory,
|
|
handle_live_pairs=self.handle_live_var.get(),
|
|
convert_motion=self.convert_motion_var.get(),
|
|
remove_motion_mp4=self.remove_mp4_var.get(),
|
|
max_workers=self.worker_count_var.get(),
|
|
)
|
|
|
|
self._reset_progress()
|
|
self.start_button.config(state="disabled")
|
|
self.worker_spin.config(state="disabled")
|
|
|
|
self.worker_thread = threading.Thread(
|
|
target=_worker,
|
|
args=(options, self.queue, self.lang.get()), # 这一行现在可以正常工作了
|
|
daemon=True,
|
|
)
|
|
self.worker_thread.start()
|
|
|
|
def _reset_progress(self) -> None:
|
|
self.progress_total = 0
|
|
self.progress_done = 0
|
|
self.progress_bar["value"] = 0
|
|
self.progress_bar["maximum"] = 1
|
|
self.progress_label.config(text=self._t("progress_status").format(done=0, total=0))
|
|
self.log_text.delete("1.0", tk.END)
|
|
|
|
def _poll_queue(self) -> None:
|
|
try:
|
|
while True:
|
|
message = self.queue.get_nowait()
|
|
self._handle_message(message)
|
|
except queue.Empty:
|
|
pass
|
|
finally:
|
|
self.root.after(100, self._poll_queue)
|
|
|
|
def _handle_message(self, message: Tuple[str, object]) -> None:
|
|
kind, payload = message
|
|
|
|
if kind == "log":
|
|
text = str(payload)
|
|
self.log_text.insert(tk.END, text + "\n")
|
|
self.log_text.see(tk.END)
|
|
elif kind == "progress_setup":
|
|
self.progress_total = int(payload) if payload else 0
|
|
self.progress_done = 0
|
|
self.progress_bar["maximum"] = max(1, self.progress_total)
|
|
self.progress_bar["value"] = 0
|
|
self.progress_label.config(text=self._t("progress_status").format(done=0, total=self.progress_total))
|
|
elif kind == "progress":
|
|
self.progress_done = int(payload)
|
|
self.progress_bar["value"] = self.progress_done
|
|
self.progress_label.config(text=self._t("progress_status").format(done=self.progress_done, total=self.progress_total))
|
|
elif kind == "finished":
|
|
self.start_button.config(state="normal")
|
|
self.worker_spin.config(state="normal")
|
|
self.log_text.insert(tk.END, self._t("log_processing_done") + "\n")
|
|
self.log_text.see(tk.END)
|
|
|
|
|
|
def main() -> None:
|
|
gui = BatchManagerGUI()
|
|
gui.run()
|
|
|
|
|
|
if __name__ == "__main__": # pragma: no cover
|
|
main() |