Fix svt-av1 encode tune for streams

utils/encode_downloads.py

@@ -21,36 +21,33 @@ def _encode_video(
     hentai_title: str, 
     input_aspect: str = "16:9"
 ):
-    print(f'Encoding {preset['h']}p AV1')
+    print(f"Encoding {preset['h']}p AV1")
 
     cmd = [
-        "ffmpeg", "-v", "quiet", "-stats",
+        "ffmpeg", "-v", "quiet", "-stats",
-        "-i", f'"{preset['input_video']}"',
+        "-i", preset['input_video'],
-        "-i", f'"{source_video}"',
+        "-i", source_video,
         "-map", "0:v:0", # Video from upscale or interpolated file
         "-map", "1:a:0", # Audio from source video
         "-map", "1:s:0", # Subtitle from source video
         "-map", "1:t?",  # Attachments from source video (optional)
         "-map", "1:d?",  # Other Data from source video (optional)
         "-disposition:v:0", "default", # Mark video as default in mkv container
-        "-metadata", f'Title=\"{hentai_title} [hstream.moe]\"',
+        "-metadata", f"Title={hentai_title} [hstream.moe]",
         "-c:v", "libsvtav1",
         "-crf", preset['crf'],
         "-preset", "4",
-        "-pix_fmt", "yuv420p10le", # 10bit
+        "-pix_fmt", "yuv420p10le",
-        "-vf", f"\"scale=\'min({preset['w']},iw)\':-2,setsar=1:1\"",
+        "-vf", f"scale=min({preset['w']}\\,iw):-2,setsar=1:1",
         "-aspect", input_aspect,
         "-c:a", "libopus",
         "-b:a", "160k",
         "-c:s", "copy",
-        f'"{output_video}"'
+        output_video
     ]
 
-    if sys.platform == 'linux':
-        cmd = ' '.join(cmd)
-
     try:
-        subprocess.run(cmd, shell=True, check=True)
+        subprocess.run(cmd, check=True)
     except subprocess.CalledProcessError as e:
         print(f"\nffmpeg failed with error code {e.returncode}", file=sys.stderr)
         sys.exit(e.returncode)
@@ -65,13 +62,13 @@ def encode_downloads(
     input_aspect: str = "16:9"
 ):
     presets = [
-        {"w": "1920", "h": "1080", "crf": "22", "name": "[1080p-AV1]",        "input_video": upscaled_video},
+        {"w": "1920", "h": "1080", "crf": "24", "name": "[1080p-AV1]",        "input_video": upscaled_video},
-        {"w": "1920", "h": "1080", "crf": "22", "name": "[1080p-AV1][48fps]", "input_video": interpolated_video},
+        {"w": "1920", "h": "1080", "crf": "24", "name": "[1080p-AV1][48fps]", "input_video": interpolated_video},
-        {"w": "3840", "h": "2160", "crf": "24", "name": "[2160p-AV1]",        "input_video": upscaled_video},
+        {"w": "3840", "h": "2160", "crf": "26", "name": "[2160p-AV1]",        "input_video": upscaled_video},
     ]
 
     if interpolated_uhd_video is not None:
-        presets.append({"w": "3840", "h": "2160", "crf": "24", "name": "[2160p-AV1][48fps]", "input_video": interpolated_uhd_video})
+        presets.append({"w": "3840", "h": "2160", "crf": "26", "name": "[2160p-AV1][48fps]", "input_video": interpolated_uhd_video})
 
     for preset in presets:
         file_name = f"{hentai_title} {preset['name']}[hstream.moe].mkv"
@@ -80,7 +77,7 @@ def encode_downloads(
 
         if os.path.exists(mux_out):
             print(f'Skipped {preset['h']}p AV1 Encode')
-            return
+            continue
 
         _encode_video(preset, source_video, tmp_out, hentai_title, input_aspect)
         _remux_video(tmp_out, mux_out)

utils/encode_stream.py

@@ -1,220 +1,208 @@
-import os
+import os
-import subprocess
+import subprocess
-import shutil
+import shutil
-import platform
+import platform
-import sys
+import sys
-
+
-def _extract_subs(
+def _extract_subs(
-    source_video: str,
+    source_video: str,
-    cdn_folder: str
+    cdn_folder: str
-):
+):
-    out_ass = os.path.join(cdn_folder, 'eng.ass')
+    out_ass = os.path.join(cdn_folder, 'eng.ass')
-    out_vtt = os.path.join(cdn_folder, 'eng.vtt')
+    out_vtt = os.path.join(cdn_folder, 'eng.vtt')
-
+
-    if os.path.exists(out_ass):
+    if os.path.exists(out_ass):
-        print('Skipped Sub Extract')
+        print('Skipped Sub Extract')
-        return
+        return
-    
+    
-    print('Extracting Sub')
+    print('Extracting Sub')
-    subprocess.call(f'ffmpeg -y -v quiet -stats -i "{source_video}" -c copy "{out_ass}"', shell=True)
+    subprocess.call(f'ffmpeg -y -v quiet -stats -i "{source_video}" -c copy "{out_ass}"', shell=True)
-    subprocess.call(f'ffmpeg -y -v quiet -stats -i "{out_ass}" "{out_vtt}"', shell=True)
+    subprocess.call(f'ffmpeg -y -v quiet -stats -i "{out_ass}" "{out_vtt}"', shell=True)
-
+
-def _create_sprites(cdn_folder: str):
+def _create_sprites(cdn_folder: str):
-    """
+    """
-    Creates video player sprites
+    Creates video player sprites
-    """
+    """
-    video_file = os.path.join(cdn_folder, 'x264.720p.mp4')
+    video_file = os.path.join(cdn_folder, 'x264.720p.mp4')
-    # Generating Sprites
+    # Generating Sprites
-    if not os.path.exists(os.path.join(cdn_folder, 'thumbs.vtt')) and os.path.exists(video_file):
+    if not os.path.exists(os.path.join(cdn_folder, 'thumbs.vtt')) and os.path.exists(video_file):
-        os.system(f'python makesprites.py "{video_file}"')
+        os.system(f'python makesprites.py "{video_file}"')
-        os.rename("thumbs.vtt", os.path.join(cdn_folder, 'thumbs.vtt'))
+        os.rename("thumbs.vtt", os.path.join(cdn_folder, 'thumbs.vtt'))
-        os.rename("sprite.jpg",  os.path.join(cdn_folder, 'sprite.jpg'))
+        os.rename("sprite.jpg",  os.path.join(cdn_folder, 'sprite.jpg'))
-        shutil.rmtree('thumbs')
+        shutil.rmtree('thumbs')
-        shutil.rmtree('logs')
+        shutil.rmtree('logs')
-        return
+        return
-
+
-    print('Skipped Sprites')
+    print('Skipped Sprites')
-
+
-def _encode_720p_fallback(
+def _encode_720p_fallback(
-    cdn_folder: str, 
+    cdn_folder: str, 
-    video_source: str, 
+    video_source: str, 
-    upscale_output: str, 
+    upscale_output: str, 
-    aspect_ratio: str = "16:9"
+    aspect_ratio: str = "16:9"
-):
+):
-    """
+    """
-    Fallback video stream for apple devices
+    Fallback video stream for apple devices
-    """
+    """
-    output = os.path.join(cdn_folder, 'x264.720p.mp4')
+    output = os.path.join(cdn_folder, 'x264.720p.mp4')
-    
+    
-    if os.path.exists(output):
+    if os.path.exists(output):
-        print('Skipped 720p Encode')
+        print('Skipped 720p Encode')
-        return
+        return
-    
+    
-    cmd = [
+    cmd = [
-        "ffmpeg", "-v", "quiet", "-stats",
+        "ffmpeg", "-v", "quiet", "-stats",
-        "-i", f'"{upscale_output}"',
+        "-i", upscale_output,
-        "-i", f'"{video_source}"',
+        "-i", video_source,
-        "-map", "0:v:0",
+        "-map", "0:v:0",
-        "-map", "1:a:0",
+        "-map", "1:a:0",
-        "-c:v", "libx264",
+        "-c:v", "libx264",
-        "-pix_fmt", "yuv420p",
+        "-pix_fmt", "yuv420p",
-        "-vf", "scale=1280:720,setsar=1:1",
+        "-vf", "scale=1280:720,setsar=1:1",
-        "-aspect", aspect_ratio,
+        "-aspect", aspect_ratio,
-        "-c:a", "aac",
+        "-c:a", "aac",
-        "-b:a", "128k",
+        "-b:a", "128k",
-        "-sn",
+        "-sn",
-        "-map_metadata", "-1",
+        "-map_metadata", "-1",
-        "-movflags", "+faststart",
+        "-movflags", "+faststart",
-        f'"{output}"'
+        output
-    ]
+    ]
-
+
-    if sys.platform == 'linux':
+    try:
-        cmd = ' '.join(cmd)
+        subprocess.run(cmd, check=True)
-
+    except subprocess.CalledProcessError as e:
-    try:
+        print(f"\nffmpeg failed with error code {e.returncode}", file=sys.stderr)
-        subprocess.run(cmd, shell=True, check=True)
+        sys.exit(e.returncode)
-    except subprocess.CalledProcessError as e:
+
-        print(f"\nffmpeg failed with error code {e.returncode}", file=sys.stderr)
+def _change_chunk_extension(
-        sys.exit(e.returncode)
+    preset: dict[str, str],
-
+    cdn_folder: str,
-
+):
-def _change_chunk_extension(
+    chunks_folder = os.path.join(cdn_folder, preset['out_folder'], 'chunks')
-    preset: dict[str, str],
+    mpd_file = os.path.join(cdn_folder, preset['out_folder'], 'manifest.mpd')
-    cdn_folder: str,
+
-):
+    # Move encodes on Windows to correct folder
-    chunks_folder = os.path.join(cdn_folder, preset['out_folder'], 'chunks')
+    if platform.system() != 'Linux':
-    mpd_file = os.path.join(cdn_folder, preset['out_folder'], 'manifest.mpd')
+        shutil.move('chunks', chunks_folder)
-
+
-    # Move encodes on Windows to correct folder
+    # Rename files
-    if platform.system() != 'Linux':
+    for filename in os.listdir(chunks_folder):
-        shutil.move('chunks', chunks_folder)
+        file_path = os.path.join(chunks_folder, filename)
-
+        if not os.path.isfile(file_path): 
-    # Rename files
+            continue
-    for filename in os.listdir(chunks_folder):
+
-        file_path = os.path.join(chunks_folder, filename)
+        new_file_path = file_path.replace('.webm', '.webp')
-        if not os.path.isfile(file_path): 
+        os.rename(file_path, new_file_path)
-            continue
+
-
+    # Modify manifest
-        new_file_path = file_path.replace('.webm', '.webp')
+    with open(mpd_file, 'r') as file :
-        os.rename(file_path, new_file_path)
+        filedata = file.read()
-
+
-    # Modify manifest
+    # Replace the target string
-    with open(mpd_file, 'r') as file :
+    filedata = filedata.replace('.webm', '.webp')
-        filedata = file.read()
+
-
+    # Write the file out again
-    # Replace the target string
+    with open(mpd_file, 'w') as file:
-    filedata = filedata.replace('.webm', '.webp')
+        file.write(filedata)
-
+
-    # Write the file out again
+def _create_folder(
-    with open(mpd_file, 'w') as file:
+    preset: dict[str, str],
-        file.write(filedata)
+    cdn_folder: str,
-
+):
-def _create_folder(
+    if platform.system() == 'Linux' and not os.path.exists(os.path.join(cdn_folder, preset['out_folder'], 'chunks')):
-    preset: dict[str, str],
+        os.makedirs(os.path.join(cdn_folder, preset['out_folder'], 'chunks'))
-    cdn_folder: str,
+        return
-):
+
-    if platform.system() == 'Linux' and not os.path.exists(os.path.join(cdn_folder, preset['out_folder'], 'chunks')):
+    # FFmpeg on Windows writes the chunk files
-        os.makedirs(os.path.join(cdn_folder, preset['out_folder'], 'chunks'))
+    # to the chunks folder at the root of where ffmpeg is invoked
-        return
+    if not os.path.exists('chunks'):
-
+        os.makedirs('chunks')
-    # FFmpeg on Windows writes the chunk files
+
-    # to the chunks folder at the root of where ffmpeg is invoked
+    # The mpd file however is stored at the correct location
-    if not os.path.exists('chunks'):
+    if not os.path.exists(os.path.join(cdn_folder, preset['out_folder'])):
-        os.makedirs('chunks')
+        os.makedirs(os.path.join(cdn_folder, preset['out_folder']))
-
+
-    # The mpd file however is stored at the correct location
+def _encode(
-    if not os.path.exists(os.path.join(cdn_folder, preset['out_folder'])):
+    preset: dict[str, str],
-        os.makedirs(os.path.join(cdn_folder, preset['out_folder']))
+    cdn_folder: str,
-
+    source_video: str,
-def _encode(
+    aspect_ratio: str,
-    preset: dict[str, str],
+    segment_duration: int = 10,
-    cdn_folder: str,
+    keyframe_interval: int = 2,
-    source_video: str,
+):
-    aspect_ratio: str,
+    print(f"Encoding {preset['name']}")
-    segment_duration: int = 10,
+
-    keyframe_interval: int = 2,
+    cmd = [
-):
+        "ffmpeg", "-v", "quiet", "-stats",
-    print(f"Encoding {preset['name']}")
+        "-i", preset['input_video'],
-
+        "-i", source_video,
-    cmd = [
+        "-map", "0:v:0", # Video from Upscale
-        "ffmpeg", "-v", "quiet", "-stats",
+        "-map", "1:a:0", # Audio from Source
-        "-i", f'"{preset['input_video']}"',
+        "-c:v", preset['encoder'],
-        "-i", f'"{source_video}"',
+        "-preset", preset['preset'],
-        "-map", "0:v:0", # Video from Upscale
+        "-crf", str(preset['crf']),
-        "-map", "1:a:0", # Audio from Source
+        "-pix_fmt", "yuv420p", # 8bit to increase decode performance
-        "-c:v", preset['encoder'],
+        "-vf", f"scale={preset['w']}:{preset['h']},setsar=1:1",
-        "-preset", preset['preset'],
+        "-aspect", aspect_ratio,
-        "-crf", preset['crf'],
+    ]
-        "-pix_fmt", "yuv420p", # 8bit to increase decode performance
+
-        "-vf", f"scale={preset['w']}:{preset['h']},setsar=1:1",
+    if preset["encoder"] == "libx264":
-        "-aspect", aspect_ratio,
+        cmd += ["-x264-params", "keyint=24:min-keyint=24:scenecut=0"]
-    ]
+        cmd += ["-c:a", "aac", "-b:a", "160k"]
-
+    elif preset["encoder"] == "libsvtav1":
-    if preset["encoder"] == "libx264":
+        cmd += ["-svtav1-params", f"keyint={keyframe_interval}s:fast-decode=1:tune=1"]
-        cmd += ["-x264-params", f"keyint=24:min-keyint=24:scenecut=0"]
+        cmd += ["-c:a", "aac", "-b:a", "160k"]
-        cmd += ["-c:a", "aac", "-b:a", "128k"]
+
-    elif preset["encoder"] == "libsvtav1":
+    output_path = os.path.join(cdn_folder, preset['out_folder'], 'manifest.mpd')
-        cmd += ["-svtav1-params", f"keyint={keyframe_interval}s,fast-decode=1,tune=0"]
+
-        cmd += ["-c:a", "libopus", "-b:a", "128k"]
+    cmd += [
-
+        "-ac", "2",
-    init_seg_name = "chunks/init-stream$RepresentationID$.webm"
+        "-sn", # No subtitles
-    media_seg_name = "chunks/chunk-stream$RepresentationID$-$Number%05d$.webm"
+        "-map_metadata", "-1", # Get rid of metadata which might be incorrect
-
+        "-use_template", "1", # Don't list every segment url, use template instead
-    if sys.platform == 'linux':
+        "-use_timeline", "1", # Make sure segment timing is always correct
-        init_seg_name = "chunks/init-stream\$RepresentationID\$.webm"
+        "-init_seg_name", "chunks/init-stream$RepresentationID$.webm",
-        media_seg_name = "chunks/chunk-stream\$RepresentationID\$-\$Number%05d\$.webm"
+        "-media_seg_name", "chunks/chunk-stream$RepresentationID$-$Number%05d$.webm",
-    
+        "-seg_duration", str(segment_duration),
-    cmd += [
+        "-f", "dash",
-        "-ac", "2",
+        output_path
-        "-sn", # No subtitles
+    ]
-        "-map_metadata", "-1", # Get rid of metadata which might be incorrect
+
-        "-use_template", "1", # Don't list every segment url, use template instead
+    try:
-        "-use_timeline", "1", # Make sure segment timing is always correct
+        subprocess.run(cmd, check=True)
-        "-init_seg_name", init_seg_name, # Init segment
+    except subprocess.CalledProcessError as e:
-        "-media_seg_name", media_seg_name, # Media segments
+        print(f"\nffmpeg failed with error code {e.returncode}", file=sys.stderr)
-        "-seg_duration", str(segment_duration), # DASH segment duration
+        sys.exit(e.returncode)
-        "-f", "dash", 
+
-        f'"{os.path.join(cdn_folder, preset['out_folder'], 'manifest.mpd')}"'
+def encode_streams(
-    ]
+    cdn_folder: str,
-
+    source_video: str,
-    if sys.platform == 'linux':
+    upscaled_video: str,
-        cmd = ' '.join(cmd)
+    interpolated_video: str,
-
+    interpolated_uhd_video: str | None,
-    try:
+    aspect_ratio: str = "16:9",
-        subprocess.run(cmd, shell=True, check=True)
+):
-    except subprocess.CalledProcessError as e:
+    presets = [
-        print(f"\nffmpeg failed with error code {e.returncode}", file=sys.stderr)
+        {"name": "720p",    "w": "1280", "h": "720",  "encoder": "libx264",   "preset": "medium", "crf": "22", "input_video": upscaled_video,     "out_folder": '720'},
-        sys.exit(e.returncode)
+        {"name": "1080p",   "w": "1920", "h": "1080", "encoder": "libsvtav1", "preset": "6",      "crf": "26", "input_video": upscaled_video,     "out_folder": '1080'},
-
+        {"name": "1080p48", "w": "1920", "h": "1080", "encoder": "libsvtav1", "preset": "6",      "crf": "26", "input_video": interpolated_video, "out_folder": '1080i'},
-def encode_streams(
+        {"name": "2160",    "w": "3840", "h": "2160", "encoder": "libsvtav1", "preset": "6",      "crf": "28", "input_video": upscaled_video,     "out_folder": '2160'},
-    cdn_folder: str,
+    ]
-    source_video: str,
+
-    upscaled_video: str,
+    # Optional UHD Interpolate encode
-    interpolated_video: str,
+    if interpolated_uhd_video is not None:
-    interpolated_uhd_video: str | None,
+        presets.append({"name": "2160p48", "w": "3840", "h": "2160", "encoder": "libsvtav1", "preset": "6", "crf": "28", "input_video": interpolated_uhd_video, "out_folder": '2160i'})
-    aspect_ratio: str = "16:9",
+
-):
+    for preset in presets:
-    presets = [
+        # Skip already encoded streams
-        {"name": "720p",    "w": "1280", "h": "720",  "encoder": "libx264",   "preset": "medium", "crf": "22", "input_video": upscaled_video,     "out_folder": '720'},
+        if os.path.exists(os.path.join(cdn_folder, preset['out_folder'], 'manifest.mpd')):
-        {"name": "1080p",   "w": "1920", "h": "1080", "encoder": "libsvtav1", "preset": "6",      "crf": "26", "input_video": upscaled_video,     "out_folder": '1080'},
+            print(f"Skipped {preset['name']}")
-        {"name": "1080p48", "w": "1920", "h": "1080", "encoder": "libsvtav1", "preset": "6",      "crf": "26", "input_video": interpolated_video, "out_folder": '1080i'},
+            continue
-        {"name": "2160",    "w": "3840", "h": "2160", "encoder": "libsvtav1", "preset": "6",      "crf": "28", "input_video": upscaled_video,     "out_folder": '2160'},
+
-    ]
+        _create_folder(preset, cdn_folder)
-
+        _encode(preset, cdn_folder, source_video, aspect_ratio)
-    # Optional UHD Interpolate encode
+        _change_chunk_extension(preset, cdn_folder)
-    if interpolated_uhd_video is not None:
+
-        presets.append({"name": "2160p48", "w": "3840", "h": "2160", "encoder": "libsvtav1", "preset": "6", "crf": "28", "input_video": interpolated_uhd_video, "out_folder": '2160i'})
+    _extract_subs(source_video, cdn_folder)
-
+    _encode_720p_fallback(cdn_folder, source_video, upscaled_video, aspect_ratio)
-    for preset in presets:
+    _create_sprites(cdn_folder)
-        # Skip already encoded streams
-        if os.path.exists(os.path.join(cdn_folder, preset['out_folder'], 'manifest.mpd')):
-            print(f"Skipped {preset['name']}")
-            continue
-
-        _create_folder(preset, cdn_folder)
-        _encode(preset, cdn_folder, source_video, aspect_ratio)
-        _change_chunk_extension(preset, cdn_folder)
-
-    _extract_subs(source_video, cdn_folder)
-    _encode_720p_fallback(cdn_folder, source_video, upscaled_video, aspect_ratio)
-    _create_sprites(cdn_folder)

utils/interpolate.py

@@ -26,9 +26,6 @@ def _create_vsrife_script(
         script = [
             'import vapoursynth as vs',
             'from vsrife import rife',
-            # this isn't a real fix, as this SHOULDN'T FIX IT
-            # however for some reason it does
-            'vs.core.max_cache_size=8192',
             f'clip = vs.core.ffms2.Source(source="./{hentai_name} [4k][HEVC].mkv")',
             f'clip = vs.core.resize.Bicubic(clip, width={video_width}, height=2160, format=vs.RGBS, matrix_in_s="709")',
             'clip = rife(clip=clip, model="4.25.lite", factor_num=2, factor_den=1)',
@@ -43,23 +40,43 @@ def _interpolate(
     vapoursynth_file: str,
     interpolate_output: str,
 ):
-    cmd = [
+    print('Started Interpolation')
-        "vspipe", 
-        "-c", "y4m",
-        f'"{vapoursynth_file}"',
-        "-", "|",
-        "ffmpeg", "-v", "quiet", "-stats",
-        "-i", "-",
-        "-c:v", "hevc_nvenc",
-        "-qp", "5",
-        f'"{interpolate_output}"'
-    ]
-
-    if sys.platform == 'linux':
-        cmd = ' '.join(cmd)
 
     try:
-        subprocess.run(cmd, shell=True, check=True)
+        # First process (vspipe)
+        vspipe = subprocess.Popen(
+            [
+                "vspipe",
+                "-c", "y4m",
+                vapoursynth_file,
+                "-"
+            ],
+            stdout=subprocess.PIPE
+        )
+
+        # Second process (ffmpeg), reading from vspipe
+        ffmpeg = subprocess.Popen(
+            [
+                "ffmpeg",
+                "-v", "quiet", "-stats",
+                "-f", "yuv4mpegpipe",
+                "-i", "-",
+                "-c:v", "hevc_nvenc",
+                "-qp", "5",
+                interpolate_output
+            ],
+            stdin=vspipe.stdout
+        )
+
+        # Important: allow vspipe to receive SIGPIPE if ffmpeg exits
+        vspipe.stdout.close()
+
+        ffmpeg.wait()
+        vspipe.wait()
+
+        if ffmpeg.returncode != 0:
+            raise subprocess.CalledProcessError(ffmpeg.returncode, "ffmpeg")
+    
     except subprocess.CalledProcessError as e:
         print(f"\nffmpeg failed with error code {e.returncode}", file=sys.stderr)
         sys.exit(e.returncode)

utils/upcale.py

@@ -1,98 +1,115 @@
-import os
+import os
-import sys
+import sys
-import subprocess
+import subprocess
-
+
-from utils.mediainfo import get_framerate
+from utils.mediainfo import get_framerate
-
+
-MAX_INPUT_WIDTH  = '720'
+MAX_INPUT_WIDTH  = '720'
-
+
-def _re_encode(
+def _re_encode(
-    source_video: str, 
+    source_video: str, 
-    temp_out_video: str,
+    temp_out_video: str,
-    input_aspect: str = "16:9"
+    input_aspect: str = "16:9"
-):
+):
-    """
+    """
-    Re-Encodes the source video to avoid nasty video bugs
+    Re-Encodes the source video to avoid nasty video bugs
-    
+    
-    :param source_video: Video Input
+    :param source_video: Video Input
-    :type source_video: str
+    :type source_video: str
-    :param input_aspect: Aspect Ratio of Video
+    :param input_aspect: Aspect Ratio of Video
-    :type input_aspect: str
+    :type input_aspect: str
-    """
+    """
-
+
-    cmd = [
+    fps = get_framerate(source_video)
-        "ffmpeg", "-v", "quiet", "-stats",
+
-        "-i", f'"{source_video}"',
+    vf_filter = f"fps={fps},scale=-1:min({MAX_INPUT_WIDTH}\\,ih)"
-        "-c:v", "ffv1",
+
-        "-level", "3",
+    cmd = [
-        "-vf", f"\"fps={get_framerate(source_video)},scale=-1:\'min({MAX_INPUT_WIDTH},ih)\'\"",
+        "ffmpeg", "-v", "quiet", "-stats",
-        "-aspect", input_aspect,
+        "-i", source_video,
-        "-pix_fmt", "yuv420p",
+        "-c:v", "ffv1",
-        "-color_primaries", "1",
+        "-level", "3",
-        "-color_trc", "1",
+        "-vf", vf_filter,
-        "-colorspace", "1",
+        "-aspect", input_aspect,
-        "-an", 
+        "-pix_fmt", "yuv420p",
-        "-sn",
+        "-color_primaries", "1",
-        "-map_metadata", "-1",
+        "-color_trc", "1",
-        f'"{temp_out_video}"'
+        "-colorspace", "1",
-    ]
+        "-an",
-
+        "-sn",
-    if sys.platform == 'linux':
+        "-map_metadata", "-1",
-        cmd = ' '.join(cmd)
+        temp_out_video
-
+    ]
-    try:
+
-        subprocess.run(cmd, shell=True, check=True)
+    try:
-    except subprocess.CalledProcessError as e:
+        subprocess.run(cmd, check=True)
-        print(f"\nffmpeg failed with error code {e.returncode} at _re_encode()", file=sys.stderr)
+    except subprocess.CalledProcessError as e:
-        sys.exit(e.returncode)
+        print(f"\nffmpeg failed with error code {e.returncode} at _re_encode()", file=sys.stderr)
-
+        sys.exit(e.returncode)
-def _upscale(
+
-    upscale_output: str,
+def _upscale(
-    input_aspect: str = "16:9"
+    upscale_output: str,
-):
+    input_aspect: str = "16:9"
-    print('Started Upscale')
+):
-
+    print('Started Upscale')
-    vapoursynth_script = os.path.join('utils', 'vs-realesrgan.vpy')
+
-
+    vapoursynth_script = os.path.join('utils', 'vs-realesrgan.vpy')
-    cmd = [
+
-        "vspipe", 
+    try:
-        "-c", "y4m",
+        # First process (vspipe)
-        f"\"{vapoursynth_script}\"",
+        vspipe = subprocess.Popen(
-        "-", # Video output to pipe
+            [
-        "|", # Pipe
+                "vspipe",
-        "ffmpeg", "-v", "quiet", "-stats",
+                "-c", "y4m",
-        "-f", "yuv4mpegpipe",
+                vapoursynth_script,
-        "-i", "-", # Pipe Video Input
+                "-"
-        "-c:v", "hevc_nvenc",
+            ],
-        "-qp", "5",
+            stdout=subprocess.PIPE
-        "-aspect", input_aspect,
+        )
-        f"\"{upscale_output}\""
+
-    ]
+        # Second process (ffmpeg), reading from vspipe
-
+        ffmpeg = subprocess.Popen(
-    if sys.platform == 'linux':
+            [
-        cmd = ' '.join(cmd)
+                "ffmpeg",
-
+                "-v", "quiet", "-stats",
-    try:
+                "-f", "yuv4mpegpipe",
-        subprocess.run(cmd, shell=True, check=True)
+                "-i", "-",
-    except subprocess.CalledProcessError as e:
+                "-c:v", "hevc_nvenc",
-        print(f"\nffmpeg failed with error code {e.returncode}", file=sys.stderr)
+                "-qp", "5",
-        sys.exit(e.returncode)
+                "-aspect", input_aspect,
-
+                upscale_output
-
+            ],
-def upscale(
+            stdin=vspipe.stdout
-    source_video: str, 
+        )
-    upscaled_video_output: str, 
+
-    input_aspect: str,
+        # Important: allow vspipe to receive SIGPIPE if ffmpeg exits
-):
+        vspipe.stdout.close()
-    if os.path.exists(upscaled_video_output):
+
-        print('Skipped Upscale')
+        ffmpeg.wait()
-        return
+        vspipe.wait()
-    
+
-    temp_out_video = os.path.join('1-Temp', 'source.mkv')
+        if ffmpeg.returncode != 0:
-
+            raise subprocess.CalledProcessError(ffmpeg.returncode, "ffmpeg")
-    _re_encode(source_video, temp_out_video, input_aspect)
+
-    _upscale(upscaled_video_output, input_aspect)
+    except subprocess.CalledProcessError as e:
-    
+        print(f"\nffmpeg failed with error code {e.returncode}", file=sys.stderr)
-    # Remove Temp Files
+        sys.exit(e.returncode)
-    os.remove(temp_out_video)
+
-    os.remove(f'{temp_out_video}.ffindex')
+
+def upscale(
+    source_video: str, 
+    upscaled_video_output: str, 
+    input_aspect: str,
+):
+    if os.path.exists(upscaled_video_output):
+        print('Skipped Upscale')
+        return
+    
+    temp_out_video = os.path.join('1-Temp', 'source.mkv')
+
+    _re_encode(source_video, temp_out_video, input_aspect)
+    _upscale(upscaled_video_output, input_aspect)
+    
+    # Remove Temp Files
+    os.remove(temp_out_video)
+    os.remove(f'{temp_out_video}.ffindex')