528 lines
27 KiB
Python
528 lines
27 KiB
Python
#!/usr/bin/env python3
|
|
import os
|
|
import sys
|
|
import subprocess
|
|
import shutil
|
|
import tempfile
|
|
import json
|
|
import re # Added for VFR frame rate parsing
|
|
from datetime import datetime
|
|
from pathlib import Path
|
|
|
|
REQUIRED_TOOLS = [
|
|
"ffmpeg", "ffprobe", "mkvmerge", "mkvpropedit",
|
|
"sox", "opusenc", "mediainfo", "av1an", "HandBrakeCLI" # Added HandBrakeCLI
|
|
]
|
|
DIR_COMPLETED = Path("completed")
|
|
DIR_ORIGINAL = Path("original")
|
|
DIR_CONV_LOGS = Path("conv_logs") # Directory for conversion logs
|
|
|
|
REMUX_CODECS = {"aac", "opus"} # Using a set for efficient lookups
|
|
|
|
def check_tools():
|
|
for tool in REQUIRED_TOOLS:
|
|
if shutil.which(tool) is None:
|
|
print(f"Required tool '{tool}' not found in PATH.")
|
|
sys.exit(1)
|
|
|
|
def run_cmd(cmd, capture_output=False, check=True):
|
|
if capture_output:
|
|
result = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, check=check, text=True)
|
|
return result.stdout
|
|
else:
|
|
subprocess.run(cmd, check=check)
|
|
|
|
def convert_audio_track(index, ch, lang, audio_temp_dir, source_file, should_downmix):
|
|
audio_temp_path = Path(audio_temp_dir)
|
|
temp_extracted = audio_temp_path / f"track_{index}_extracted.flac"
|
|
temp_normalized = audio_temp_path / f"track_{index}_normalized.flac"
|
|
final_opus = audio_temp_path / f"track_{index}_final.opus"
|
|
|
|
print(f" - Extracting Audio Track #{index} to FLAC...")
|
|
ffmpeg_args = [
|
|
"ffmpeg", "-v", "quiet", "-stats", "-y", "-i", str(source_file), "-map", f"0:{index}"
|
|
]
|
|
if should_downmix and ch >= 6:
|
|
if ch == 6:
|
|
ffmpeg_args += ["-af", "pan=stereo|c0=c2+0.30*c0+0.30*c4|c1=c2+0.30*c1+0.30*c5"]
|
|
elif ch == 8:
|
|
ffmpeg_args += ["-af", "pan=stereo|c0=c2+0.30*c0+0.30*c4+0.30*c6|c1=c2+0.30*c1+0.30*c5+0.30*c7"]
|
|
else: # Other multi-channel (e.g. 7ch, 10ch)
|
|
ffmpeg_args += ["-ac", "2"]
|
|
ffmpeg_args += ["-c:a", "flac", str(temp_extracted)]
|
|
run_cmd(ffmpeg_args)
|
|
|
|
print(f" - Normalizing Audio Track #{index} with SoX...")
|
|
run_cmd([
|
|
"sox", str(temp_extracted), str(temp_normalized), "-S", "--temp", str(audio_temp_path), "--guard", "gain", "-n"
|
|
])
|
|
|
|
# Set bitrate based on the final channel count of the Opus file.
|
|
# If we are downmixing, the result is stereo.
|
|
# If not, the result has the original channel count.
|
|
is_being_downmixed = should_downmix and ch >= 6
|
|
|
|
if is_being_downmixed:
|
|
# Downmixing from 5.1 or 7.1 results in a stereo track.
|
|
bitrate = "128k"
|
|
else:
|
|
# Not downmixing (or source is already stereo or less).
|
|
# Base bitrate on the source channel count.
|
|
if ch == 2: # Stereo
|
|
bitrate = "128k"
|
|
elif ch == 6: # 5.1 Surround
|
|
bitrate = "256k"
|
|
elif ch == 8: # 7.1 Surround
|
|
bitrate = "384k"
|
|
else: # Mono or other layouts
|
|
bitrate = "96k" # A sensible default for mono.
|
|
|
|
print(f" - Encoding Audio Track #{index} to Opus at {bitrate}...")
|
|
run_cmd([
|
|
"opusenc", "--vbr", "--bitrate", bitrate, str(temp_normalized), str(final_opus)
|
|
])
|
|
return final_opus
|
|
|
|
def convert_video(source_file_base, source_file_full, is_vfr, target_cfr_fps_for_handbrake):
|
|
print(" --- Starting Video Processing ---")
|
|
# source_file_base is file_path.stem (e.g., "my.anime.episode.01")
|
|
scene_file = Path(f"{source_file_base}.txt")
|
|
vpy_file = Path(f"{source_file_base}.vpy")
|
|
ut_video_file = Path(f"{source_file_base}.ut.mkv")
|
|
encoded_video_file = Path(f"temp-{source_file_base}.mkv")
|
|
handbrake_cfr_intermediate_file = None # To store path of HandBrake output if created
|
|
|
|
current_input_for_utvideo = Path(source_file_full)
|
|
|
|
if is_vfr and target_cfr_fps_for_handbrake:
|
|
print(f" - Source is VFR. Converting to CFR ({target_cfr_fps_for_handbrake}) with HandBrakeCLI...")
|
|
handbrake_cfr_intermediate_file = Path(f"{source_file_base}.cfr_temp.mkv")
|
|
handbrake_args = [
|
|
"HandBrakeCLI",
|
|
"--input", str(source_file_full),
|
|
"--output", str(handbrake_cfr_intermediate_file),
|
|
"--cfr",
|
|
"--rate", str(target_cfr_fps_for_handbrake),
|
|
"--encoder", "x264_10bit", # Changed to x264_10bit for 10-bit CFR intermediate
|
|
"--quality", "0", # CRF 0 for x264 is often considered visually lossless, or near-lossless
|
|
"--encoder-preset", "superfast", # Use a fast preset for quicker processing
|
|
"--encoder-tune", "fastdecode", # Added tune for faster decoding
|
|
"--audio", "none",
|
|
"--subtitle", "none",
|
|
"--crop-mode", "none" # Disable auto-cropping
|
|
]
|
|
print(f" - Running HandBrakeCLI: {' '.join(handbrake_args)}")
|
|
try:
|
|
run_cmd(handbrake_args)
|
|
if handbrake_cfr_intermediate_file.exists() and handbrake_cfr_intermediate_file.stat().st_size > 0:
|
|
print(f" - HandBrake VFR to CFR conversion successful: {handbrake_cfr_intermediate_file}")
|
|
current_input_for_utvideo = handbrake_cfr_intermediate_file
|
|
else:
|
|
print(f" - Warning: HandBrakeCLI VFR-to-CFR conversion failed or produced an empty file. Proceeding with original source for UTVideo.")
|
|
handbrake_cfr_intermediate_file = None # Ensure it's None if failed
|
|
except subprocess.CalledProcessError as e:
|
|
print(f" - Error during HandBrakeCLI execution: {e}")
|
|
print(f" - Proceeding with original source for UTVideo.")
|
|
handbrake_cfr_intermediate_file = None # Ensure it's None if failed
|
|
|
|
|
|
print(" - Creating UTVideo intermediate file (overwriting if exists)...")
|
|
# Check if source is already UTVideo
|
|
ffprobe_cmd = [
|
|
"ffprobe", "-v", "error", "-select_streams", "v:0",
|
|
"-show_entries", "stream=codec_name", "-of", "default=noprint_wrappers=1:nokey=1",
|
|
str(current_input_for_utvideo) # Use current input, which might be HandBrake output
|
|
]
|
|
source_codec = run_cmd(ffprobe_cmd, capture_output=True, check=True).strip()
|
|
|
|
video_codec_args = ["-c:v", "utvideo"]
|
|
if source_codec == "utvideo" and current_input_for_utvideo == Path(source_file_full): # Only copy if original was UTVideo
|
|
print(" - Source is already UTVideo. Copying video stream...")
|
|
video_codec_args = ["-c:v", "copy"]
|
|
|
|
ffmpeg_args = [
|
|
"ffmpeg", "-hide_banner", "-v", "quiet", "-stats", "-y", "-i", str(current_input_for_utvideo),
|
|
"-map", "0:v:0", "-map_metadata", "-1", "-map_chapters", "-1", "-an", "-sn", "-dn",
|
|
] + video_codec_args + [str(ut_video_file)]
|
|
run_cmd(ffmpeg_args)
|
|
ut_video_full_path = os.path.abspath(ut_video_file)
|
|
vpy_script_content = f"""import vapoursynth as vs
|
|
core = vs.core
|
|
core.num_threads = 4
|
|
clip = core.lsmas.LWLibavSource(source=r'''{ut_video_full_path}''')
|
|
clip = core.resize.Point(clip, format=vs.YUV420P10, matrix_in_s="709") # type: ignore
|
|
clip.set_output()
|
|
"""
|
|
with vpy_file.open("w", encoding="utf-8") as f:
|
|
f.write(vpy_script_content)
|
|
|
|
if not scene_file.exists():
|
|
print(" - Performing scene detection with av1an...")
|
|
av1an_sc_args = [
|
|
"av1an", "-i", str(vpy_file), "-s", str(scene_file), "--sc-only", "--verbose"
|
|
]
|
|
run_cmd(av1an_sc_args)
|
|
else:
|
|
print(" - Found existing scene file, skipping detection.")
|
|
|
|
print(" - Starting AV1 encode with av1an (this will take a long time)...")
|
|
total_cores = os.cpu_count() or 4 # Fallback if cpu_count is None
|
|
workers = max(total_cores - 2, 1) # Ensure at least 1 worker
|
|
print(f" - Using {workers} workers for av1an (Total Cores: {total_cores}).")
|
|
|
|
svt_av1_params = {
|
|
"preset": 2,
|
|
"crf": 27,
|
|
"film-grain": 6,
|
|
"lp": 1,
|
|
"tune": 1,
|
|
"keyint": -1,
|
|
"color-primaries": 1,
|
|
"transfer-characteristics": 1,
|
|
"matrix-coefficients": 1,
|
|
}
|
|
# Create the parameter string for av1an's -v option, which expects a single string.
|
|
av1an_video_params_str = " ".join([f"--{key} {value}" for key, value in svt_av1_params.items()])
|
|
print(f" - Using SVT-AV1 parameters: {av1an_video_params_str}")
|
|
|
|
av1an_enc_args = [
|
|
"av1an", "-i", str(vpy_file), "-o", str(encoded_video_file), "-s", str(scene_file), "-n",
|
|
"-e", "svt-av1", "--resume", "--sc-pix-format", "yuv420p", "-c", "mkvmerge",
|
|
"--set-thread-affinity", "1", "--pix-format", "yuv420p10le", "--force",
|
|
"-w", str(workers),
|
|
"-v", av1an_video_params_str
|
|
]
|
|
run_cmd(av1an_enc_args)
|
|
print(" --- Finished Video Processing ---")
|
|
return encoded_video_file, handbrake_cfr_intermediate_file
|
|
|
|
def is_ffmpeg_decodable(file_path):
|
|
"""Quickly check if ffmpeg can decode the input file."""
|
|
try:
|
|
# Try to decode a short segment of the first audio stream
|
|
subprocess.run([
|
|
"ffmpeg", "-v", "error", "-i", str(file_path), "-map", "0:a:0", "-t", "1", "-f", "null", "-"
|
|
], check=True)
|
|
return True
|
|
except subprocess.CalledProcessError:
|
|
return False
|
|
|
|
def main(no_downmix=False):
|
|
check_tools()
|
|
|
|
current_dir = Path(".")
|
|
|
|
# Check if there are any MKV files to process before creating directories
|
|
files_to_process = sorted(
|
|
f for f in current_dir.glob("*.mkv")
|
|
if not (f.name.endswith(".ut.mkv") or f.name.startswith("temp-") or f.name.startswith("output-") or f.name.endswith(".cfr_temp.mkv"))
|
|
)
|
|
|
|
if not files_to_process:
|
|
print("No MKV files found to process. Exiting.")
|
|
return # Exit without creating directories
|
|
|
|
# Only create directories when we actually have files to process
|
|
DIR_COMPLETED.mkdir(exist_ok=True, parents=True)
|
|
DIR_ORIGINAL.mkdir(exist_ok=True, parents=True)
|
|
DIR_CONV_LOGS.mkdir(exist_ok=True, parents=True) # Create conv_logs directory
|
|
|
|
while True:
|
|
files_to_process = sorted(
|
|
f for f in current_dir.glob("*.mkv")
|
|
if not (f.name.endswith(".ut.mkv") or f.name.startswith("temp-") or f.name.startswith("output-") or f.name.endswith(".cfr_temp.mkv"))
|
|
)
|
|
|
|
if not files_to_process:
|
|
print("No more .mkv files found to process in the current directory. The script will now exit.")
|
|
break
|
|
|
|
# Process the first file in the list. The list is requeried in the next iteration.
|
|
file_path = files_to_process[0]
|
|
|
|
# --- Add ffmpeg decodability check here ---
|
|
if not is_ffmpeg_decodable(file_path):
|
|
print(f"ERROR: ffmpeg cannot decode '{file_path.name}'. Skipping this file.", file=sys.stderr)
|
|
shutil.move(str(file_path), DIR_ORIGINAL / file_path.name)
|
|
continue
|
|
|
|
print("-" * shutil.get_terminal_size(fallback=(80, 24)).columns)
|
|
# This print remains on the console, indicating which file is starting.
|
|
# The detailed "Starting full processing for..." will be in the log.
|
|
|
|
log_file_name = f"{file_path.stem}.log" # Use stem to avoid .mkv.log
|
|
log_file_path = DIR_CONV_LOGS / log_file_name
|
|
|
|
original_stdout_console = sys.stdout
|
|
original_stderr_console = sys.stderr
|
|
|
|
# Announce to console (original stdout)
|
|
print(f"Processing: {file_path.name}", file=original_stdout_console)
|
|
print(f"Logging output to: {log_file_path}", file=original_stdout_console)
|
|
|
|
log_file_handle = None
|
|
processing_error_occurred = False
|
|
date_for_runtime_calc = datetime.now() # For runtime calculation
|
|
|
|
try: # Outer try for log redirection and file handling
|
|
log_file_handle = open(log_file_path, 'w', encoding='utf-8')
|
|
sys.stdout = log_file_handle
|
|
sys.stderr = log_file_handle
|
|
|
|
# --- Start of log-specific messages ---
|
|
print(f"STARTING LOG FOR: {file_path.name}")
|
|
print(f"Processing started at: {date_for_runtime_calc}")
|
|
print(f"Full input file path: {file_path.resolve()}")
|
|
print("-" * shutil.get_terminal_size(fallback=(80, 24)).columns)
|
|
|
|
input_file_abs = file_path.resolve() # Used by original logic
|
|
intermediate_output_file = current_dir / f"output-{file_path.name}" # Used by original logic
|
|
audio_temp_dir = None # Initialize before inner try
|
|
handbrake_intermediate_for_cleanup = None # Initialize before inner try
|
|
|
|
# This is the original try...except...finally block for processing a single file.
|
|
# All its print statements will now go to the log file.
|
|
try:
|
|
audio_temp_dir = tempfile.mkdtemp(prefix="anime_audio_")
|
|
print(f"Audio temporary directory created at: {audio_temp_dir}")
|
|
print(f"Analyzing file: {input_file_abs}")
|
|
|
|
ffprobe_info_json = run_cmd([
|
|
"ffprobe", "-v", "quiet", "-print_format", "json", "-show_streams", "-show_format", str(input_file_abs)
|
|
], capture_output=True)
|
|
ffprobe_info = json.loads(ffprobe_info_json)
|
|
|
|
mkvmerge_info_json = run_cmd([
|
|
"mkvmerge", "-J", str(input_file_abs)
|
|
], capture_output=True)
|
|
mkv_info = json.loads(mkvmerge_info_json)
|
|
|
|
mediainfo_json = run_cmd([
|
|
"mediainfo", "--Output=JSON", "-f", str(input_file_abs)
|
|
], capture_output=True)
|
|
media_info = json.loads(mediainfo_json)
|
|
|
|
is_vfr = False
|
|
target_cfr_fps_for_handbrake = None
|
|
video_track_info = None
|
|
|
|
if media_info.get("media") and media_info["media"].get("track"):
|
|
for track in media_info["media"]["track"]:
|
|
if track.get("@type") == "Video":
|
|
video_track_info = track
|
|
break
|
|
|
|
if video_track_info:
|
|
frame_rate_mode = video_track_info.get("FrameRate_Mode")
|
|
if frame_rate_mode and frame_rate_mode.upper() in ["VFR", "VARIABLE"]:
|
|
is_vfr = True
|
|
print(f" - Detected VFR based on MediaInfo FrameRate_Mode: {frame_rate_mode}")
|
|
original_fps_str = video_track_info.get("FrameRate_Original_String")
|
|
if original_fps_str:
|
|
match = re.search(r'\((\d+/\d+)\)', original_fps_str)
|
|
if match:
|
|
target_cfr_fps_for_handbrake = match.group(1)
|
|
else: # Fallback to decimal part if fraction not in parentheses
|
|
target_cfr_fps_for_handbrake = video_track_info.get("FrameRate_Original")
|
|
|
|
if not target_cfr_fps_for_handbrake: # Fallback if Original_String didn't yield
|
|
target_cfr_fps_for_handbrake = video_track_info.get("FrameRate_Original")
|
|
|
|
if not target_cfr_fps_for_handbrake: # Further fallback to current FrameRate
|
|
target_cfr_fps_for_handbrake = video_track_info.get("FrameRate")
|
|
if target_cfr_fps_for_handbrake:
|
|
print(f" - Using MediaInfo FrameRate ({target_cfr_fps_for_handbrake}) as fallback for HandBrake target FPS.")
|
|
|
|
if target_cfr_fps_for_handbrake:
|
|
print(f" - Target CFR for HandBrake: {target_cfr_fps_for_handbrake}")
|
|
# Convert fractional FPS to decimal for HandBrakeCLI if needed
|
|
if isinstance(target_cfr_fps_for_handbrake, str) and "/" in target_cfr_fps_for_handbrake:
|
|
try:
|
|
num, den = map(float, target_cfr_fps_for_handbrake.split('/'))
|
|
target_cfr_fps_for_handbrake = f"{num / den:.3f}"
|
|
print(f" - Converted fractional FPS to decimal for HandBrake: {target_cfr_fps_for_handbrake}")
|
|
except ValueError:
|
|
print(f" - Warning: Could not parse fractional FPS '{target_cfr_fps_for_handbrake}'. HandBrakeCLI might fail.")
|
|
is_vfr = False # Revert if conversion fails
|
|
else:
|
|
print(" - Warning: VFR detected, but could not determine target CFR from MediaInfo. Will attempt standard UTVideo conversion without HandBrake.")
|
|
is_vfr = False # Revert to non-HandBrake path
|
|
else:
|
|
print(f" - Video appears to be CFR or FrameRate_Mode not specified as VFR/Variable by MediaInfo.")
|
|
|
|
encoded_video_file, handbrake_intermediate_for_cleanup = convert_video(
|
|
file_path.stem, str(input_file_abs), is_vfr, target_cfr_fps_for_handbrake
|
|
)
|
|
|
|
print("--- Starting Audio Processing ---")
|
|
processed_audio_files = []
|
|
audio_tracks_to_remux = []
|
|
audio_streams = [s for s in ffprobe_info.get("streams", []) if s.get("codec_type") == "audio"]
|
|
|
|
# Build mkvmerge track mapping by track ID
|
|
mkv_audio_tracks = {t["id"]: t for t in mkv_info.get("tracks", []) if t.get("type") == "audio"}
|
|
|
|
# Build mediainfo track mapping by StreamOrder
|
|
media_tracks_data = media_info.get("media", {}).get("track", [])
|
|
mediainfo_audio_tracks = {int(t.get("StreamOrder", -1)): t for t in media_tracks_data if t.get("@type") == "Audio"}
|
|
|
|
for stream in audio_streams:
|
|
stream_index = stream["index"]
|
|
codec = stream.get("codec_name")
|
|
channels = stream.get("channels", 2)
|
|
language = stream.get("tags", {}).get("language", "und")
|
|
|
|
# Find mkvmerge track by matching ffprobe stream index to mkvmerge track's 'properties'->'stream_id'
|
|
mkv_track = None
|
|
for t in mkv_info.get("tracks", []):
|
|
if t.get("type") == "audio" and t.get("properties", {}).get("stream_id") == stream_index:
|
|
mkv_track = t
|
|
break
|
|
if not mkv_track:
|
|
# Fallback: try by position
|
|
mkv_track = mkv_info.get("tracks", [])[stream_index] if stream_index < len(mkv_info.get("tracks", [])) else {}
|
|
|
|
track_id = mkv_track.get("id", -1)
|
|
track_title = mkv_track.get("properties", {}).get("track_name", "")
|
|
|
|
# Find mediainfo track by StreamOrder
|
|
audio_track_info = mediainfo_audio_tracks.get(stream_index)
|
|
track_delay = 0
|
|
delay_raw = audio_track_info.get("Video_Delay") if audio_track_info else None
|
|
if delay_raw is not None:
|
|
try:
|
|
delay_val = float(delay_raw)
|
|
# If the value is a float < 1, it's seconds, so convert to ms.
|
|
if delay_val < 1:
|
|
track_delay = int(round(delay_val * 1000))
|
|
else:
|
|
track_delay = int(round(delay_val))
|
|
except Exception:
|
|
track_delay = 0
|
|
|
|
print(f"Processing Audio Stream #{stream_index} (TID: {track_id}, Codec: {codec}, Channels: {channels})")
|
|
if codec in REMUX_CODECS:
|
|
audio_tracks_to_remux.append(str(track_id))
|
|
else:
|
|
# Convert any codec that is not in REMUX_CODECS
|
|
opus_file = convert_audio_track(
|
|
stream_index, channels, language, audio_temp_dir, str(input_file_abs), not no_downmix
|
|
)
|
|
processed_audio_files.append({
|
|
"Path": opus_file,
|
|
"Language": language,
|
|
"Title": track_title,
|
|
"Delay": track_delay
|
|
})
|
|
|
|
print("--- Finished Audio Processing ---")
|
|
|
|
# Final mux
|
|
print("Assembling final file with mkvmerge...")
|
|
mkvmerge_args = ["mkvmerge", "-o", str(intermediate_output_file), str(encoded_video_file)]
|
|
for file_info in processed_audio_files:
|
|
sync_switch = ["--sync", f"0:{file_info['Delay']}"] if file_info["Delay"] else []
|
|
mkvmerge_args += [
|
|
"--language", f"0:{file_info['Language']}",
|
|
"--track-name", f"0:{file_info['Title']}"
|
|
] + sync_switch + [str(file_info["Path"])]
|
|
|
|
source_copy_args = ["--no-video"]
|
|
if audio_tracks_to_remux:
|
|
source_copy_args += ["--audio-tracks", ",".join(audio_tracks_to_remux)]
|
|
else:
|
|
source_copy_args += ["--no-audio"]
|
|
mkvmerge_args += source_copy_args + [str(input_file_abs)]
|
|
run_cmd(mkvmerge_args)
|
|
|
|
# Move files
|
|
print("Moving files to final destinations...")
|
|
shutil.move(str(file_path), DIR_ORIGINAL / file_path.name)
|
|
shutil.move(str(intermediate_output_file), DIR_COMPLETED / file_path.name)
|
|
|
|
print("Cleaning up persistent video temporary files (after successful processing)...")
|
|
video_temp_files_on_success = [
|
|
current_dir / f"{file_path.stem}.txt",
|
|
current_dir / f"{file_path.stem}.vpy",
|
|
current_dir / f"{file_path.stem}.ut.mkv",
|
|
current_dir / f"temp-{file_path.stem}.mkv", # This is encoded_video_file
|
|
current_dir / f"{file_path.stem}.ut.mkv.lwi",
|
|
]
|
|
if handbrake_intermediate_for_cleanup and handbrake_intermediate_for_cleanup.exists():
|
|
video_temp_files_on_success.append(handbrake_intermediate_for_cleanup)
|
|
|
|
for temp_vid_file in video_temp_files_on_success:
|
|
if temp_vid_file.exists():
|
|
print(f" Deleting: {temp_vid_file}")
|
|
temp_vid_file.unlink(missing_ok=True)
|
|
else:
|
|
print(f" Skipping (not found): {temp_vid_file}")
|
|
|
|
except Exception as e:
|
|
print(f"ERROR: An error occurred while processing '{file_path.name}': {e}", file=sys.stderr) # Goes to log
|
|
original_stderr_console.write(f"ERROR during processing of '{file_path.name}': {e}\nSee log '{log_file_path}' for details.\n")
|
|
processing_error_occurred = True
|
|
finally:
|
|
# This is the original 'finally' block. Its prints go to the log file.
|
|
print("--- Starting Universal Cleanup (for this file) ---")
|
|
print(" - Cleaning up disposable audio temporary directory...")
|
|
if audio_temp_dir and Path(audio_temp_dir).exists():
|
|
shutil.rmtree(audio_temp_dir, ignore_errors=True)
|
|
print(f" - Deleted audio temp dir: {audio_temp_dir}")
|
|
elif audio_temp_dir: # Was created but now not found
|
|
print(f" - Audio temp dir not found or already cleaned: {audio_temp_dir}")
|
|
else: # Was never created
|
|
print(f" - Audio temp dir was not created.")
|
|
|
|
print(" - Cleaning up intermediate output file (if it wasn't moved on success)...")
|
|
if intermediate_output_file.exists(): # Check if it still exists (e.g. error before move)
|
|
if processing_error_occurred:
|
|
print(f" - WARNING: Processing error occurred. Intermediate output file '{intermediate_output_file}' is being preserved at its original path for inspection.")
|
|
else:
|
|
# No processing error, so it should have been moved.
|
|
# If it's still here, it's unexpected but we'll clean it up.
|
|
print(f" - INFO: Intermediate output file '{intermediate_output_file}' found at original path despite no errors (expected to be moved). Cleaning up.")
|
|
intermediate_output_file.unlink(missing_ok=True) # Only unlink if no error and it exists
|
|
print(f" - Deleted intermediate output file from original path: {intermediate_output_file}")
|
|
else:
|
|
# File does not exist at original path
|
|
if not processing_error_occurred:
|
|
print(f" - Intermediate output file successfully moved (not found at original path, as expected): {intermediate_output_file}")
|
|
else:
|
|
print(f" - Processing error occurred, and intermediate output file '{intermediate_output_file}' not found at original path (likely not created or cleaned by another step).")
|
|
# --- End of original per-file processing block ---
|
|
|
|
print(f"FINISHED LOG FOR: {file_path.name}")
|
|
# --- End of log-specific messages ---
|
|
|
|
finally: # Outer finally for restoring stdout/stderr and closing log file
|
|
runtime = datetime.now() - date_for_runtime_calc
|
|
runtime_str = str(runtime).split('.')[0]
|
|
|
|
# This print goes to the log file, as stdout is not yet restored.
|
|
print(f"\nTotal runtime for this file: {runtime_str}")
|
|
|
|
if sys.stdout != original_stdout_console:
|
|
sys.stdout = original_stdout_console
|
|
if sys.stderr != original_stderr_console:
|
|
sys.stderr = original_stderr_console
|
|
if log_file_handle:
|
|
log_file_handle.close()
|
|
|
|
# Announce to console (original stdout/stderr) that this file is done
|
|
if processing_error_occurred:
|
|
original_stderr_console.write(f"File: {file_path.name}\n")
|
|
original_stderr_console.write(f"Log: {log_file_path}\n")
|
|
original_stderr_console.write(f"Runtime: {runtime_str}\n")
|
|
else:
|
|
original_stdout_console.write(f"File: {file_path.name}\n")
|
|
original_stdout_console.write(f"Log: {log_file_path}\n")
|
|
original_stdout_console.write(f"Runtime: {runtime_str}\n")
|
|
|
|
if __name__ == "__main__":
|
|
import argparse
|
|
parser = argparse.ArgumentParser(description="Batch-process MKV files with resumable video encoding, audio downmixing, and per-file logging.")
|
|
parser.add_argument("--no-downmix", action="store_true", help="Preserve original audio channel layout.")
|
|
args = parser.parse_args()
|
|
main(no_downmix=args.no_downmix)
|