303 lines
10 KiB
Python
303 lines
10 KiB
Python
"""Audio extraction, remuxing, and encoding helpers."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import json
|
|
import subprocess
|
|
from dataclasses import dataclass
|
|
from pathlib import Path
|
|
|
|
from tools.console import ProgressView, prompt_input
|
|
from tools.filesystem import collect_files
|
|
from tools.user_config import load_setting, save_setting
|
|
|
|
|
|
COMMON_AUDIO_CODECS = ("aac", "opus", "flac", "mp3")
|
|
M4A_CODECS = {"aac", "alac", "opus", "flac", "mp3"}
|
|
NATIVE_EXTENSIONS = {
|
|
"aac": ".m4a",
|
|
"alac": ".m4a",
|
|
"opus": ".opus",
|
|
"flac": ".flac",
|
|
"mp3": ".mp3",
|
|
"vorbis": ".ogg",
|
|
"pcm_s16le": ".wav",
|
|
"pcm_s24le": ".wav",
|
|
"pcm_s32le": ".wav",
|
|
}
|
|
POOR_M4A_COMPATIBILITY = M4A_CODECS - {"aac", "alac"}
|
|
|
|
|
|
@dataclass(frozen=True)
|
|
class AudioStream:
|
|
index: int
|
|
codec: str
|
|
channels: int | None
|
|
sample_rate: int | None
|
|
bit_rate: int | None
|
|
|
|
@property
|
|
def layout(self) -> tuple[str, int | None, int | None]:
|
|
return self.codec, self.channels, self.sample_rate
|
|
|
|
|
|
@dataclass(frozen=True)
|
|
class AudioInput:
|
|
path: Path
|
|
container: str
|
|
streams: list[AudioStream]
|
|
has_video: bool
|
|
|
|
@property
|
|
def audio_only(self) -> bool:
|
|
return not self.has_video
|
|
|
|
|
|
@dataclass(frozen=True)
|
|
class AudioSettings:
|
|
mode: str
|
|
codec: str | None
|
|
container: str
|
|
matching_action: str
|
|
encoder: str | None = None
|
|
bitrate: str | None = None
|
|
quality: int | None = None
|
|
compression: int | None = None
|
|
output_dir: Path | None = None
|
|
encoder_ffmpeg: str | None = None
|
|
|
|
|
|
def collect_audio_inputs(ffprobe: str, args: list[str]) -> tuple[list[AudioInput], list[Path]]:
|
|
media, unreadable = [], []
|
|
files = collect_files(args, print_missing=True)
|
|
progress = ProgressView(len(files), "Probing files")
|
|
for index, path in enumerate(files, 1):
|
|
try:
|
|
media.append(probe_audio_input(ffprobe, path))
|
|
except (OSError, subprocess.CalledProcessError, json.JSONDecodeError):
|
|
unreadable.append(path)
|
|
progress.update(index)
|
|
progress.finish(keep=True)
|
|
return media, unreadable
|
|
|
|
|
|
def probe_audio_input(ffprobe: str, path: Path) -> AudioInput:
|
|
command = [
|
|
ffprobe,
|
|
"-v",
|
|
"error",
|
|
"-show_entries",
|
|
"format=format_name:stream=index,codec_type,codec_name,channels,sample_rate,bit_rate",
|
|
"-of",
|
|
"json",
|
|
str(path),
|
|
]
|
|
completed = subprocess.run(command, check=True, capture_output=True, text=True)
|
|
data = json.loads(completed.stdout)
|
|
streams = [
|
|
AudioStream(
|
|
int(stream["index"]),
|
|
str(stream.get("codec_name") or "unknown"),
|
|
_as_int(stream.get("channels")),
|
|
_as_int(stream.get("sample_rate")),
|
|
_as_int(stream.get("bit_rate")),
|
|
)
|
|
for stream in data.get("streams", [])
|
|
if stream.get("codec_type") == "audio"
|
|
]
|
|
return AudioInput(
|
|
path.resolve(),
|
|
str(data.get("format", {}).get("format_name") or "unknown"),
|
|
streams,
|
|
any(stream.get("codec_type") == "video" for stream in data.get("streams", [])),
|
|
)
|
|
|
|
|
|
def ffmpeg_encoders(ffmpeg: str) -> set[str]:
|
|
completed = subprocess.run(
|
|
[ffmpeg, "-hide_banner", "-encoders"], check=True, capture_output=True, text=True
|
|
)
|
|
return {
|
|
line.split()[1]
|
|
for line in completed.stdout.splitlines()
|
|
if len(line.split()) >= 2 and line.lstrip().startswith("A")
|
|
}
|
|
|
|
|
|
def universal_containers(codecs: set[str]) -> list[str]:
|
|
containers = ["MKA"]
|
|
if codecs and codecs <= M4A_CODECS:
|
|
containers.append("M4A")
|
|
return containers
|
|
|
|
|
|
def native_extension(codec: str) -> str:
|
|
return NATIVE_EXTENSIONS.get(codec, ".mka")
|
|
|
|
|
|
def same_container(source: AudioInput, extension: str) -> bool:
|
|
if not source.audio_only:
|
|
return False
|
|
names = {part.strip().lower() for part in source.container.split(",")}
|
|
wanted = extension.lower().lstrip(".")
|
|
return (
|
|
wanted in names
|
|
or wanted == "mka" and bool(names & {"matroska", "mka"})
|
|
or wanted == "m4a" and bool(names & {"mov", "mp4", "m4a", "3gp", "3g2", "mj2"})
|
|
)
|
|
|
|
|
|
def output_extension(container: str, codec: str) -> str:
|
|
return native_extension(codec) if container == "Native" else f".{container.lower()}"
|
|
|
|
|
|
def matching_actions(inputs: list[AudioInput], stream_indexes: dict[Path, int], extension: str, codec: str) -> list[str]:
|
|
matching = [
|
|
item
|
|
for item in inputs
|
|
if item.streams and item.streams[stream_indexes[item.path]].codec == codec
|
|
]
|
|
actions = ["re-encode"]
|
|
if matching:
|
|
actions.insert(0, "remux")
|
|
if any(same_container(item, extension) for item in matching):
|
|
actions.insert(0, "skip")
|
|
return actions
|
|
|
|
|
|
def select_fdk_ffmpeg(system_ffmpeg: str) -> str:
|
|
if "libfdk_aac" in ffmpeg_encoders(system_ffmpeg):
|
|
return system_ffmpeg
|
|
remembered = load_setting("fdk_aac_ffmpeg")
|
|
while True:
|
|
default = f" [{remembered}]" if remembered else ""
|
|
answer = prompt_input(
|
|
"FDK AAC needs an FFmpeg build with libfdk_aac. "
|
|
f"Absolute path{default} (blank = {'use remembered path' if remembered else 'cancel'}): "
|
|
).strip().strip('"')
|
|
if not answer and remembered:
|
|
answer = remembered
|
|
if not answer:
|
|
raise RuntimeError("FDK AAC was selected but no FDK-enabled FFmpeg was provided.")
|
|
path = Path(answer).expanduser()
|
|
if not path.is_absolute() or not path.is_file():
|
|
print("Enter an existing absolute FFmpeg path.")
|
|
continue
|
|
try:
|
|
resolved = str(path.resolve())
|
|
if "libfdk_aac" not in ffmpeg_encoders(resolved):
|
|
print("That FFmpeg build does not provide libfdk_aac.")
|
|
continue
|
|
except (OSError, subprocess.CalledProcessError):
|
|
print("Could not run that FFmpeg executable.")
|
|
continue
|
|
save_setting("fdk_aac_ffmpeg", resolved)
|
|
return resolved
|
|
|
|
|
|
def run_audio_batch(
|
|
ffmpeg: str,
|
|
inputs: list[AudioInput],
|
|
stream_indexes: dict[Path, int],
|
|
settings: AudioSettings,
|
|
) -> list[str]:
|
|
failures, reserved = [], set()
|
|
processable = [item for item in inputs if item.streams]
|
|
progress = ProgressView(len(processable), "Processing audio")
|
|
fdk_ffmpeg = settings.encoder_ffmpeg or ffmpeg
|
|
for number, item in enumerate(processable, 1):
|
|
stream = item.streams[stream_indexes[item.path]]
|
|
try:
|
|
action, codec = _action_for(item, stream, settings)
|
|
if action == "skip":
|
|
print(f"Skipped {item.path.name}: already matches the requested output.")
|
|
else:
|
|
extension = output_extension(settings.container, codec)
|
|
target = unique_audio_target(item.path, extension, reserved, settings.output_dir)
|
|
_run_ffmpeg(fdk_ffmpeg if codec == "aac" and settings.encoder == "libfdk_aac" else ffmpeg, item, stream, target, action, settings)
|
|
print(f"{item.path.name} -> {target.name}")
|
|
progress.update(number)
|
|
except (OSError, subprocess.CalledProcessError, RuntimeError) as exc:
|
|
failures.append(f"{item.path}: {exc}")
|
|
progress.update(number, "failed")
|
|
progress.finish(keep=True)
|
|
return failures
|
|
|
|
|
|
def unique_audio_target(
|
|
source: Path,
|
|
extension: str,
|
|
reserved: set[Path],
|
|
output_dir: Path | None = None,
|
|
) -> Path:
|
|
base = (output_dir or source.parent) / f"{source.stem}{extension}"
|
|
for index in range(10000):
|
|
target = base if index == 0 else base.with_name(f"{base.stem}-{index}{base.suffix}")
|
|
resolved = target.resolve()
|
|
if not target.exists() and resolved not in reserved:
|
|
reserved.add(resolved)
|
|
return target
|
|
raise RuntimeError(f"Could not create a unique output name for {source.name}")
|
|
|
|
|
|
def _action_for(item: AudioInput, stream: AudioStream, settings: AudioSettings) -> tuple[str, str]:
|
|
if settings.mode == "remux":
|
|
extension = output_extension(settings.container, stream.codec)
|
|
return ("skip", stream.codec) if settings.matching_action == "skip" and same_container(item, extension) else ("remux", stream.codec)
|
|
assert settings.codec is not None
|
|
same_codec = stream.codec == settings.codec
|
|
extension = output_extension(settings.container, settings.codec)
|
|
if same_codec and settings.matching_action == "skip" and same_container(item, extension):
|
|
return "skip", settings.codec
|
|
if same_codec and settings.matching_action == "remux":
|
|
return "remux", settings.codec
|
|
return "encode", settings.codec
|
|
|
|
|
|
def _run_ffmpeg(
|
|
ffmpeg: str,
|
|
item: AudioInput,
|
|
stream: AudioStream,
|
|
target: Path,
|
|
action: str,
|
|
settings: AudioSettings,
|
|
) -> None:
|
|
target.parent.mkdir(parents=True, exist_ok=True)
|
|
command = [ffmpeg, "-hide_banner", "-nostdin", "-i", str(item.path), "-map", f"0:{stream.index}", "-vn", "-map_metadata", "0"]
|
|
if action == "remux":
|
|
command.extend(["-c:a", "copy"])
|
|
else:
|
|
assert settings.encoder
|
|
command.extend(["-c:a", settings.encoder])
|
|
if settings.bitrate:
|
|
command.extend(["-b:a", settings.bitrate])
|
|
if settings.quality is not None:
|
|
command.extend(["-vbr", str(settings.quality)] if settings.encoder == "libfdk_aac" else ["-q:a", str(settings.quality)])
|
|
if settings.compression is not None:
|
|
command.extend(["-compression_level", str(settings.compression)])
|
|
if settings.container == "M4A":
|
|
command.extend(["-f", "mp4"])
|
|
command.extend(["-n", str(target)])
|
|
completed = subprocess.run(command, check=False, capture_output=True, text=True)
|
|
if completed.returncode:
|
|
detail = (completed.stderr or completed.stdout).strip()
|
|
raise RuntimeError(detail[-2000:] or f"FFmpeg exited with {completed.returncode}")
|
|
|
|
|
|
def encoder_for(codec: str, encoders: set[str]) -> str | None:
|
|
choices = {
|
|
"aac": "aac",
|
|
"opus": "libopus",
|
|
"flac": "flac",
|
|
"mp3": "libmp3lame",
|
|
}
|
|
value = choices[codec]
|
|
return value if value in encoders else None
|
|
|
|
|
|
def _as_int(value: object) -> int | None:
|
|
try:
|
|
return int(str(value))
|
|
except (TypeError, ValueError):
|
|
return None
|