stouputils 1.14.0__py3-none-any.whl

stouputils/applications/upscaler/config.py

@@ -0,0 +1,128 @@
+"""
+This module provides configuration settings and constants for the upscaler application.
+
+It defines the URLs for downloading dependencies like waifu2x-ncnn-vulkan and FFmpeg,
+and provides a Config class with settings for upscaling operations, including output quality,
+bitrates, executable paths, and command-line arguments for the underlying tools.
+
+Configuration options include:
+- Image quality settings (JPG quality)
+- Video encoding parameters (bitrate, codec, etc.)
+- Paths to external binaries (FFmpeg, waifu2x-ncnn-vulkan)
+- Command-line arguments for upscaling and video processing
+"""
+# Constants
+WAIFU2X_NCNN_VULKAN_RELEASES: dict[str, str] = {
+	"Windows": "https://github.com/nihui/waifu2x-ncnn-vulkan/releases/download/20220728/waifu2x-ncnn-vulkan-20220728-windows.zip",
+	"Linux": "https://github.com/nihui/waifu2x-ncnn-vulkan/releases/download/20220728/waifu2x-ncnn-vulkan-20220728-ubuntu.zip",
+	"Darwin": "https://github.com/nihui/waifu2x-ncnn-vulkan/releases/download/20220728/waifu2x-ncnn-vulkan-20220728-macos.zip"
+}
+""" URLs to download waifu2x-ncnn-vulkan from for each common platform. """
+FFMPEG_RELEASES: dict[str, str] = {
+	"Windows": "https://github.com/BtbN/FFmpeg-Builds/releases/download/latest/ffmpeg-master-latest-win64-gpl.zip",
+	"Linux": "https://github.com/BtbN/FFmpeg-Builds/releases/download/latest/ffmpeg-master-latest-linux64-gpl.tar.xz",
+	"Darwin": "https://github.com/BtbN/FFmpeg-Builds/releases/download/latest/ffmpeg-master-latest-macos64-gpl.tar.xz"
+}
+""" URLs to download FFmpeg from for each common platform. """
+YOUTUBE_BITRATE_RECOMMENDATIONS: dict[str, dict[str, dict[int, int]]] = {
+	"SDR": {
+		"standard": {  # Standard Frame Rate (24, 25, 30)
+			4320: 160000,  # 8K - 160 Mbps
+			2160: 45000,   # 4K - 45 Mbps
+			1440: 16000,   # 2K - 16 Mbps
+			1080: 8000,    # 1080p - 8 Mbps
+			720: 5000,     # 720p - 5 Mbps
+			480: 2500,     # 480p - 2.5 Mbps
+			0: 1000        # 360p or lower - 1 Mbps
+		},
+		"high": {  # High Frame Rate (48, 50, 60)
+			4320: 240000,  # 8K - 240 Mbps
+			2160: 68000,   # 4K - 68 Mbps
+			1440: 24000,   # 2K - 24 Mbps
+			1080: 12000,   # 1080p - 12 Mbps
+			720: 7500,     # 720p - 7.5 Mbps
+			480: 4000,     # 480p - 4 Mbps
+			0: 1500        # 360p or lower - 1.5 Mbps
+		}
+	},
+	"HDR": {
+		"standard": {  # Standard Frame Rate (24, 25, 30)
+			4320: 200000,  # 8K - 200 Mbps
+			2160: 56000,   # 4K - 56 Mbps
+			1440: 20000,   # 2K - 20 Mbps
+			1080: 10000,   # 1080p - 10 Mbps
+			0: 6500        # 720p or lower - 6.5 Mbps
+		},
+		"high": {  # High Frame Rate (48, 50, 60)
+			4320: 300000,  # 8K - 300 Mbps
+			2160: 85000,   # 4K - 85 Mbps
+			1440: 30000,   # 2K - 30 Mbps
+			1080: 15000,   # 1080p - 15 Mbps
+			0: 9500        # 720p or lower - 9.5 Mbps
+		}
+	}
+}
+""" YouTube bitrate recommendations for different resolutions and frame rates.
+
+This dictionary contains recommended bitrates for YouTube uploads based on:
+- SDR vs HDR content
+- Standard frame rate (24, 25, 30 fps) vs high frame rate (48, 50, 60 fps)
+- Video resolution (from 360p up to 8K)
+
+The values are in kbps (kilobits per second).
+
+Source: https://support.google.com/youtube/answer/1722171
+"""
+
+# Configuration class
+class Config:
+	""" Configuration class for the upscaler. """
+	JPG_QUALITY: int = 95
+	""" JPG quality for the output images. (Range: 0-100) """
+
+	VIDEO_FINAL_BITRATE: int = -1
+	""" Video final bitrate for the output video. -1 for YouTube recommended bitrate based on the video resolution. """
+
+	FFMPEG_EXECUTABLE: str = "ffmpeg"
+	""" Path to the ffmpeg executable, default is "ffmpeg" in the PATH. """
+
+	FFMPEG_ARGS: tuple[str, ...] = (
+		"-c:a", "copy",         # Copy the audio without re-encoding
+		"-c:v", "hevc_nvenc",   # Encode the video
+		"-map", "0:v:0",        # Map the first input -i (frames) as video
+		"-map", "1:a:0?",       # Map the second input -i (sound) as audio, with '?' to ignore if no audio stream
+		"-preset", "slow",      # Set the encoding preset to slow (slower but better quality)
+		"-y",					# Overwrite the output file if it exists
+	)
+	""" Additional arguments sent to the ffmpeg executable when calling subprocess.run(). """
+
+	FFPROBE_EXECUTABLE: str = "ffprobe"
+	""" Path to the ffprobe executable, default is "ffprobe" in the PATH. Used to get the framerate of the video. """
+
+	FFMPEG_CHECK_HELP_TEXT: str = "usage: ffmpeg [options]"
+	""" If this text is present in the output of the ffmpeg executable, it means it's installed correctly. """
+
+	UPSCALER_EXECUTABLE: str = "waifu2x-ncnn-vulkan"
+	""" Path to the upscaler executable, default is "waifu2x-ncnn-vulkan" in the PATH. """
+
+	UPSCALER_ARGS: tuple[str, ...] = (
+		"-i", "INPUT_PATH",     # Input file path
+		"-o", "OUTPUT_PATH",    # Output file path
+		"-s", "UPSCALE_RATIO",  # Upscaling ratio
+		"-n", "3",              # Noise level
+	)
+	""" Arguments sent to the upscaler executable when calling subprocess.run(). """
+
+	UPSCALER_EXECUTABLE_HELP_TEXT: str = "Usage: waifu2x-ncnn-vulkan -i"
+	""" If this text is present in the output of the upscaler executable, it means it's installed correctly. """
+
+	SLIGHTLY_FASTER_MODE: bool = False
+	""" If True, the upscaler executable will be called once, which is slightly faster but you can't see the progress. """
+
+	# Variables
+	upscaler_executable_checked: bool = False
+	""" Whether the upscaler executable has been checked for. """
+
+	ffmpeg_executable_checked: bool = False
+	""" Whether the ffmpeg executable has been checked for. """
+

stouputils/applications/upscaler/image.py

@@ -0,0 +1,247 @@
+"""
+This module provides utility functions for upscaling images using waifu2x-ncnn-vulkan.
+
+It includes functions to upscale individual images, batches of images in a folder,
+and handle intermediate operations like converting between image formats.
+The module also manages temporary directories for partial processing and tracks
+progress of batch operations.
+
+Main functionalities:
+
+- Converting frames between image formats (PNG to JPG)
+- Upscaling individual images with configurable upscale ratio
+- Batch processing folders of images with progress tracking
+- Handling already processed images to resume interrupted operations
+
+Example usage:
+
+.. code-block:: python
+
+    from stouputils.applications.upscaler import upscale, upscale_folder
+
+    # Upscale a single image
+    upscale("input.jpg", "output.jpg", 2)
+
+    # Upscale a folder of images
+    upscale_folder("input_folder", "output_folder", 2)
+"""
+
+# Imports
+import os
+import shutil
+import subprocess
+from tempfile import TemporaryDirectory
+
+from PIL import Image
+
+from ...installer import check_executable
+from ...io import clean_path
+from ...parallel import multithreading
+from ...print import colored_for_loop, debug, info
+from .config import WAIFU2X_NCNN_VULKAN_RELEASES, Config
+
+
+# Function to convert a PNG frame to JPG format
+def convert_frame(frame_path: str, delete_png: bool = True) -> None:
+	""" Convert a PNG frame to JPG format to take less space.
+
+	Args:
+		frame_path  (str):   Path to the PNG frame to convert.
+		delete_png  (bool):  Whether to delete the original PNG file after conversion.
+
+	Returns:
+		None: This function doesn't return anything.
+
+	Example:
+		.. code-block:: python
+
+			> convert_frame("input.png", delete_png=True)
+			> # input.png will be converted to input.jpg and the original file will be deleted
+
+			> convert_frame("input.png", delete_png=False)
+			> # input.png will be converted to input.jpg and the original file will be kept
+	"""
+	if frame_path.endswith(".png"):
+		with Image.open(frame_path) as img:
+			img.save(frame_path.replace(".png", ".jpg"), quality=Config.JPG_QUALITY)
+		if delete_png:
+			os.remove(frame_path)
+
+
+# Function to get all frames in a folder
+def get_all_files(folder: str, suffix: str | tuple[str, ...] = "") -> list[str]:
+	""" Get all files paths in a folder, with a specific suffix if provided.
+
+	Args:
+		folder     (str):                    Path to the folder containing the files.
+		suffix     (str | tuple[str, ...]):  Suffix of the files to get (e.g. ".png", ".jpg", etc.).
+
+	Returns:
+		list[str]: List of all files paths in the folder.
+
+	Example:
+		>>> files: list[str] = get_all_files("some_folder", ".png")
+		>>> len(files)
+		0
+	"""
+	if not os.path.exists(folder):
+		return []
+	return [f"{folder}/{f}" for f in os.listdir(folder) if f.endswith(suffix)]
+
+
+# Function to create a temporary directory with not upscaled images
+def create_temp_dir_for_not_upscaled(input_path: str, output_path: str) -> TemporaryDirectory[str] | None:
+    """ Creates a temporary directory containing only images that haven't been upscaled yet.
+
+    Args:
+        input_path  (str):  Path to the folder containing input images.
+        output_path (str):  Path to the folder where upscaled images are saved.
+
+    Returns:
+        TemporaryDirectory[str] | None: A temporary directory object if there are images to process,
+                                        None if all images are already upscaled.
+    """
+    # Get all input images and the not upscaled images
+    all_inputs: list[str] = get_all_files(input_path)
+    not_upscaled_images: list[str] = [x for x in all_inputs if not os.path.exists(f"{output_path}/{os.path.basename(x)}")]
+
+    # If all images or none are already upscaled, return None
+    if len(not_upscaled_images) == 0 or (len(not_upscaled_images) == len(all_inputs)):
+        return None
+
+    # Create a temporary directory and copy the not upscaled images to it
+    temp_dir: TemporaryDirectory[str] = TemporaryDirectory()
+    debug(f"Creating temporary directory to process {len(not_upscaled_images)} images: {temp_dir.name}")
+    for image in not_upscaled_images:
+        shutil.copyfile(image, f"{temp_dir.name}/{os.path.basename(image)}")
+    return temp_dir
+
+
+# Helper function to check if the upscaler executable is installed
+def check_upscaler_executable() -> None:
+	if not Config.upscaler_executable_checked:
+		check_executable(Config.UPSCALER_EXECUTABLE, Config.UPSCALER_EXECUTABLE_HELP_TEXT, WAIFU2X_NCNN_VULKAN_RELEASES)
+		Config.upscaler_executable_checked = True
+
+
+# Function to upscale an image
+def upscale(input_path: str, output_path: str, upscale_ratio: int) -> None:
+	""" Upscale an input image (or a directory of images) with the upscaler executable.
+
+	Args:
+		input_path     (str):  Path to the image to upscale (or a directory).
+		output_path    (str):  Path to the output image (or a directory).
+		upscale_ratio  (int):  Upscaling ratio.
+
+	Example:
+		.. code-block:: python
+
+			> upscale("folder", "folder", 2)
+			Traceback (most recent call last):
+				...
+			AssertionError: Input and output paths cannot be the same, got 'folder'
+
+			> upscale("stouputils", "stouputils/output.jpg", 2)
+			Traceback (most recent call last):
+				...
+			AssertionError: If input is a directory, output must be a directory too, got 'stouputils/output.jpg'
+
+
+			> upscale("input.jpg", "output.jpg", 2)
+			> # The input.jpg will be upscaled to output.jpg with a ratio of 2
+
+			> upscale("input_folder", "output_folder", 2)
+			> # The input_folder will be upscaled to output_folder with a ratio of 2
+	"""
+	check_upscaler_executable()
+	is_input_dir: bool = os.path.isdir(input_path)
+	is_output_dir: bool = os.path.isdir(output_path)
+
+	# Assertions
+	assert input_path != output_path, f"Input and output paths cannot be the same, got '{input_path}'"
+	invalid_dir_combination: bool = is_input_dir == True and is_output_dir == False  # noqa: E712
+	assert not invalid_dir_combination, f"If input is a directory, output must be a directory too, got '{output_path}'"
+
+	# Convert output_path to a file path if it's a directory
+	if is_output_dir and not is_input_dir:
+
+		# Needs to be a PNG file to be converted to JPG later
+		output_file_name: str = os.path.basename(input_path).replace(".jpg", ".png")
+		output_path = clean_path(f"{output_path}/{output_file_name}")
+		is_output_dir = False
+
+	# If both input and output are folders, and there are images already upscaled in the output folder,
+	# Then create a temporary folder with not upscaled images
+	temp_dir: TemporaryDirectory[str] | None = None
+	if is_input_dir and is_output_dir:
+		temp_dir = create_temp_dir_for_not_upscaled(input_path, output_path)
+		if temp_dir:
+			input_path = temp_dir.name
+
+	# Build the command and run it
+	cmd: list[str] = [Config.UPSCALER_EXECUTABLE, *Config.UPSCALER_ARGS]
+	cmd[cmd.index("INPUT_PATH")] = input_path	          # Replace the input path
+	cmd[cmd.index("OUTPUT_PATH")] = output_path	          # Replace the output path
+	cmd[cmd.index("UPSCALE_RATIO")] = str(upscale_ratio)  # Replace the upscaled ratio (if using waifu2x-ncnn-vulkan)
+	subprocess.run(cmd, capture_output=True)
+
+	# If the input was a temporary folder, delete it
+	if temp_dir:
+		temp_dir.cleanup()
+
+	# Convert the output frames to JPG format
+	if not is_output_dir:
+		convert_frame(output_path)
+	else:
+		frames_to_convert: list[str] = get_all_files(output_path, ".png")
+		if frames_to_convert:
+			multithreading(convert_frame, frames_to_convert, desc="Converting frames to JPG format")
+
+
+# Function to upscale multiple images
+def upscale_images(images: list[str], output_folder: str, upscale_ratio: int, desc: str = "Upscaling images") -> None:
+	""" Upscale multiple images from a list.
+
+	Args:
+		images        (list[str]): List of paths to the images to upscale.
+		output_folder (str):       Path to the output folder where the upscaled images will be saved.
+		upscale_ratio (int):       Upscaling ratio.
+		desc          (str):       Description of the function execution displayed in the progress bar.
+			No progress bar will be displayed if desc is empty.
+
+	Returns:
+		None: This function doesn't return anything.
+	"""
+	for image_path in (colored_for_loop(images, desc=desc) if desc != "" else images):
+		upscale(image_path, output_folder, upscale_ratio)
+
+# Function to upscale a folder of images
+def upscale_folder(
+	input_folder: str,
+	output_folder: str,
+	upscale_ratio: int,
+	slightly_faster_mode: bool = True,
+	desc: str = "Upscaling folder"
+) -> None:
+	""" Upscale all images in a folder.
+
+	Args:
+		input_folder          (str):   Path to the input folder containing the images to upscale.
+		output_folder         (str):   Path to the output folder where the upscaled images will be saved.
+		upscale_ratio         (int):   Upscaling ratio.
+		slightly_faster_mode  (bool):  Whether to use the slightly faster mode (no progress bar),
+			one call to the upscaler executable.
+		desc                  (str):   Description of the function execution displayed in the progress bar.
+			No progress bar will be displayed if desc is empty.
+
+	Returns:
+		None: This function doesn't return anything.
+	"""
+	info(f"Upscaling '{input_folder}' to '{output_folder}' with a ratio of {upscale_ratio}...")
+	if slightly_faster_mode:
+		upscale(input_folder, output_folder, upscale_ratio)
+	else:
+		inputs: list[str] = get_all_files(input_folder)
+		not_upscaled_images: list[str] = [x for x in inputs if not os.path.exists(f"{output_folder}/{os.path.basename(x)}")]
+		upscale_images(not_upscaled_images, output_folder, upscale_ratio, desc=desc)
+

stouputils/applications/upscaler/video.py

@@ -0,0 +1,287 @@
+"""
+This module provides utility functions for upscaling videos using waifu2x-ncnn-vulkan.
+
+It extracts frames from videos, upscales them individually, and then recombines them
+into a high-quality output video. The process preserves audio from the original video
+and handles configuration of video encoding parameters like bitrate and framerate.
+
+Main functionalities:
+
+- Extracting frames from videos using FFmpeg
+- Upscaling frames using waifu2x-ncnn-vulkan
+- Recombining frames into videos with optimized bitrates
+- Handling partially processed videos to resume interrupted operations
+- Calculating recommended bitrates based on resolution and framerate
+
+The module includes YouTube's recommended bitrate settings for different resolutions,
+framerates, and HDR/SDR content types, ensuring optimal quality for various outputs.
+
+Example usage:
+
+.. code-block:: python
+
+	# Imports
+	import stouputils.applications.upscaler as app
+	from stouputils.io import get_root_path
+
+	# Constants
+	ROOT: str = get_root_path(__file__) + "/upscaler"
+	INPUT_FOLDER: str = f"{ROOT}/input"
+	PROGRESS_FOLDER: str = f"{ROOT}/progress"
+	OUTPUT_FOLDER: str = f"{ROOT}/output"
+
+	# Main
+	if __name__ == "__main__":
+		app.video_upscaler_cli(INPUT_FOLDER, PROGRESS_FOLDER, OUTPUT_FOLDER)
+"""
+
+# Imports
+import os
+import shutil
+import subprocess
+import sys
+from typing import Literal
+
+from PIL import Image
+
+from ...installer import check_executable
+from ...io import clean_path
+from ...parallel import multithreading
+from ...print import colored_for_loop, debug, error, info, warning
+from .config import FFMPEG_RELEASES, YOUTUBE_BITRATE_RECOMMENDATIONS, Config
+from .image import convert_frame, get_all_files, upscale_folder
+
+
+# Functions
+def get_recommended_bitrate(
+	resolution: tuple[int, int], frame_rate: int = 60, upload_type: Literal["SDR","HDR"] = "SDR"
+) -> int:
+	""" Get the recommended bitrate (in kbps) for the output video based on the video resolution.
+
+	Args:
+		resolution  (tuple[int, int]):       Video resolution (width, height).
+		frame_rate  (int):                   Frame rate of the video, default is 60.
+		upload_type (Literal["SDR","HDR"]):  Upload type from which the recommendation is made, default is "SDR".
+
+	Returns:
+		int:     The recommended bitrate for the output video (in kbps)
+
+	Source: https://support.google.com/youtube/answer/1722171?hl=en#zippy=%2Cbitrate
+
+	Examples:
+		>>> # Valid examples
+		>>> get_recommended_bitrate((3840, 2160), 60, "SDR")
+		68000
+		>>> get_recommended_bitrate((1920, 1080), 60, "HDR")
+		15000
+		>>> get_recommended_bitrate((1920, 1080), 60, "SDR")
+		12000
+		>>> get_recommended_bitrate((1920, 1080), 30, "SDR")
+		8000
+
+		>>> # Invalid examples
+		>>> get_recommended_bitrate((1920, 1080), 60, "Ratio")
+		Traceback (most recent call last):
+			...
+		AssertionError: Invalid upload type: 'Ratio'
+		>>> get_recommended_bitrate("1920x1080", 60, "SDR")
+		Traceback (most recent call last):
+			...
+		AssertionError: Invalid resolution: 1920x1080, must be a tuple of two integers
+		>>> get_recommended_bitrate((1920, 1080), -10, "SDR")
+		Traceback (most recent call last):
+			...
+		AssertionError: Invalid frame rate: -10, must be a positive integer
+	"""
+	# Assertions
+	assert isinstance(resolution, tuple) and len(resolution) == 2, \
+		f"Invalid resolution: {resolution}, must be a tuple of two integers"
+	assert isinstance(frame_rate, int) and frame_rate > 0, \
+		f"Invalid frame rate: {frame_rate}, must be a positive integer"
+	assert upload_type in YOUTUBE_BITRATE_RECOMMENDATIONS, \
+		f"Invalid upload type: '{upload_type}'"
+
+	# Determine frame rate category
+	frame_rate_category: str = "high" if frame_rate >= 48 else "standard"
+
+	# Get the appropriate bitrate dictionary
+	resolution_bitrates: dict[int, int] = YOUTUBE_BITRATE_RECOMMENDATIONS[upload_type][frame_rate_category]
+
+	# Find the appropriate bitrate based on resolution
+	max_dimension: int = min(*resolution)
+	for min_resolution, bitrate in sorted(resolution_bitrates.items(), reverse=True):
+		if max_dimension >= min_resolution:
+			return bitrate
+
+	# Fallback (should never reach here due to the '0' key in dictionaries)
+	return 1000
+
+
+def check_ffmpeg_executable() -> None:
+	if not Config.ffmpeg_executable_checked:
+		check_executable(Config.FFMPEG_EXECUTABLE, Config.FFMPEG_CHECK_HELP_TEXT, FFMPEG_RELEASES, append_to_path="bin")
+		Config.ffmpeg_executable_checked = True
+
+# Routine to handle a video file
+def upscale_video(video_file: str, input_folder: str, progress_folder: str, output_folder: str) -> None:
+	""" Handles a video file. """
+	# Prepare paths
+	input_path: str = f"{input_folder}/{video_file}"
+	progress_path: str = f"{progress_folder}/{video_file}"
+	p_extracted_path: str = f"{progress_path}/extracted"
+	p_upscaled_path: str = f"{progress_path}/upscaled"
+	output_path: str = f"{output_folder}/{video_file}"
+	os.makedirs(p_extracted_path, exist_ok = True)
+	os.makedirs(p_upscaled_path, exist_ok = True)
+
+	# Check if executable is installed
+	check_ffmpeg_executable()
+
+	## Step 1: Check if the video file is already upscaled or partially processed, if not, extract frames
+	# If the video file is already upscaled, skip it
+	if os.path.exists(output_path):
+		warning(f"'{video_file}' has already been processed, remove it from the output folder to reprocess it.")
+		return
+
+	# If the video is already in the list of videos that have been partially processed, ask to restart or skip
+	is_partially_processed: bool = len(os.listdir(p_extracted_path)) > 0 and len(os.listdir(p_upscaled_path)) > 0
+	if is_partially_processed:
+		info(f"'{video_file}' has already been partially processed, do you want to resume the process? (Y/n)")
+		if input().lower() == "n":
+			shutil.rmtree(p_upscaled_path, ignore_errors = True)
+			os.makedirs(p_upscaled_path, exist_ok = True)
+			is_partially_processed = False
+
+	# If the video is not partially processed, extract frames
+	if not is_partially_processed:
+		debug(f"Extracting frames from '{video_file}'...")
+
+		# Extract frames using ffmpeg
+		command: list[str] = [Config.FFMPEG_EXECUTABLE, "-i", input_path, f"{p_extracted_path}/%09d.png"]
+		subprocess.run(command, capture_output = True)
+
+	# Convert all frames to JPG format
+	frames_to_convert: list[str] = get_all_files(p_extracted_path, ".png")
+	if frames_to_convert:
+		multithreading(convert_frame, frames_to_convert, desc="Converting frames to JPG format")
+
+
+	## Step 2: Upscale the frames
+	# Get all the frames in the progress folder
+	all_frames: list[str] = get_all_files(p_extracted_path, ".jpg")
+	upscaled_frames: list[str] = get_all_files(p_upscaled_path, ".jpg")
+
+	# If there are frames to upscale,
+	if len(all_frames) > len(upscaled_frames):
+
+		# Try to get upscaling ratio if any
+		upscale_ratio: int = 2
+		if upscaled_frames:
+			with Image.open(upscaled_frames[0]) as img:
+				upscaled_size: tuple[int, int] = img.size
+			with Image.open(all_frames[0]) as img:
+				extracted_size: tuple[int, int] = img.size
+			upscale_ratio = upscaled_size[0] // extracted_size[0]
+			info(f"Detected upscaling ratio: {upscale_ratio}")
+		else:
+			if "--upscale" in sys.argv:
+				upscale_index: int = sys.argv.index("--upscale")
+				if upscale_index + 1 < len(sys.argv):
+					upscale_ratio = int(sys.argv[upscale_index + 1])
+				else:
+					error(
+						"No upscaling ratio provided with --upscale flag. "
+						"Please provide a ratio after the flag. (1/2/4/8/16/32)",
+						exit=True
+					)
+			else:
+				info("No upscaling ratio provided, please enter one (1/2/4/8/16/32, default=2):")
+				upscale_ratio = int(input() or "2")
+
+		# For each frame that hasn't been upscaled yet, upscale it
+		upscale_folder(p_extracted_path, p_upscaled_path, upscale_ratio, slightly_faster_mode=Config.SLIGHTLY_FASTER_MODE)
+
+	## Step 3: Convert the upscaled frames to a video
+	# Get the video bitrate
+	if Config.VIDEO_FINAL_BITRATE == -1:
+		upscaled_frame: str = get_all_files(p_upscaled_path, ".jpg")[0]
+		with Image.open(upscaled_frame) as img:
+			upscaled_size: tuple[int, int] = img.size
+		video_bitrate: int = get_recommended_bitrate(upscaled_size)
+	else:
+		video_bitrate: int = Config.VIDEO_FINAL_BITRATE
+
+	# Get the framerate of the original video
+	original_framerate: str = "60"
+	ffprobe_command: list[str] = [
+		Config.FFPROBE_EXECUTABLE,                    # Path to the ffprobe executable
+		"-v", "error",                                # Set verbosity level to error (only show errors)
+		"-select_streams", "v:0",                     # Select the first video stream
+		"-show_entries", "stream=r_frame_rate",       # Show only the frame rate information
+		"-of", "default=noprint_wrappers=1:nokey=1",  # Format output without wrappers and keys
+		input_path,                                   # Path to the input video file
+	]
+	try:
+		result = subprocess.run(ffprobe_command, capture_output=True, text=True, check=True)
+		framerate: str = result.stdout.strip()
+		if not framerate or '/' not in framerate: # Basic validation
+			warning(f"Could not reliably determine framerate for '{video_file}'. Falling back to 60.")
+			original_framerate = "60"
+		else:
+			debug(f"Detected original framerate: {framerate}")
+			original_framerate = framerate
+	except (subprocess.CalledProcessError, FileNotFoundError) as e:
+		warning(f"Failed to get framerate using ffprobe for '{video_file}': {e}. Falling back to 60.")
+
+
+	# Prepare the command to convert the upscaled frames to a video
+	subprocess.run([
+		Config.FFMPEG_EXECUTABLE,
+		"-framerate", original_framerate,    # Use the original video's framerate for input frames
+		"-i", f"{p_upscaled_path}/%09d.jpg", # Use p_upscaled_path, not upscaled_path
+		"-i", input_path,                    # Input video for sound and metadata
+		"-b:v", f"{video_bitrate}k",         # Set the video bitrate (in kbps)
+		*Config.FFMPEG_ARGS,			 	 # Additional arguments from the config
+		"-r", original_framerate,            # Set the *output* video framerate
+		output_path,                         # Output video
+	])
+
+
+def video_upscaler_cli(input_folder: str, progress_folder: str, output_folder: str) -> None:
+	""" Upscales videos from an input folder and saves them to an output folder.
+
+	Uses intermediate folders for extracted and upscaled frames within the progress folder.
+	**Handles resuming partially processed videos.**
+
+	Args:
+		input_folder    (str): Path to the folder containing input videos.
+		progress_folder (str): Path to the folder for storing intermediate files (frames).
+		output_folder   (str): Path to the folder where upscaled videos will be saved.
+	"""
+	# Clean paths
+	input_folder = clean_path(input_folder)
+	progress_folder = clean_path(progress_folder)
+	output_folder = clean_path(output_folder)
+	os.makedirs(input_folder, exist_ok = True)
+	os.makedirs(progress_folder, exist_ok = True)
+	os.makedirs(output_folder, exist_ok = True)
+
+	# Ask if we should shutdown the computer after the script is finished
+	info("Do you want to shutdown the computer after the script is finished? (y/N)")
+	shutdown_after_script: bool = input().lower() == "y"
+
+	# Collect all video files in the input folder
+	videos: list[str] = [file for file in os.listdir(input_folder) if not file.endswith(".md")]
+
+	# Handle each video file
+	for video in colored_for_loop(videos, desc="Upscaling videos"):
+		upscale_video(video, input_folder, progress_folder, output_folder)
+
+	# Shutdown the computer after the script is finished
+	if shutdown_after_script:
+		info("Shutting down the computer...")
+		if os.name == "nt":
+			subprocess.run(["shutdown", "/s", "/t", "0", "/f"], capture_output = False)
+		else:
+			subprocess.run(["shutdown", "now"], capture_output = False)
+