Merge pull request #5 from FarisR99/release-1.1.2

Release 1.1.2

Author: FarisR99

Anime4K.py

@@ -1,7 +1,9 @@
 import argparse
+import glob
 import os
 import sys
 
+from encode import encode_to_hevc
 from extract_audio import extract_audio
 from extract_subs import extract_subs
 from multi import multi
@@ -11,7 +13,7 @@
 from utils import __current_version__, is_tool, credz, str2dict
 
 # Constant variables
-MODES_SUPPORTING_MULTI_INPUTS = ["shader", "multi"]
+MODES_SUPPORTING_MULTI_INPUTS = ["shader", "multi", "encode"]
 
 # Print credits
 credz()
@@ -43,6 +45,7 @@
  subs - Extract subtitles from a media file
  mux - Mux/compile a media file with audio files and subtitle files
  multi - Apply shader with -ss and -sa, audio, subs and mux mode in order
+ encode - Encode media files using X265 with predefined settings
  split - Split a media file into parts''')
 parser.add_argument("-ew", "--width", required=False, type=int, default=3840,
                     help="Desired width when applying shader")
@@ -69,10 +72,14 @@
                     default=False,
                     help="Set this flag if you want to manually mux audio when using mode shader")
 parser.add_argument("-sm", "--skip_menus", required=False, type=str2dict,
-                    help='''Skip shader/encoding choice menus when using mode shader
-Example:
+                    help='''Skip choice menus
+Examples for mode shader:
  --skip_menus="shader=4,encoder=cpu,codec=h264,preset=fast,crf=23"
- --skip_menus="shader=4,encoder=nvenc,codec=hevc,preset=fast,qp=24"''')
+ --skip_menus="shader=4,encoder=nvenc,codec=hevc,preset=fast,qp=24"
+Example for mode audio:
+ --skip_menus="convert=0"
+Example for mode encode:
+ --skip_menus="encode=0"''')
 parser.add_argument("-al", "--audio_language", required=False, type=str,
                     help=
                     '''Set this to the audio track language for the output video.
@@ -82,6 +89,8 @@
                     action='store_true',
                     default=False,
                     help="Set this flag to delete output files that have failed to compile when using mode multi")
+parser.add_argument("-si", "--skip_input", required=False, action='append',
+                    help="Input file to skip when using a directory as an input for modes shader and multi")
 
 args = vars(parser.parse_args())
 if args['version']:
@@ -97,21 +106,25 @@ def exit_if_missing(file_path: str, allow_dir: bool = True):
     elif allow_dir is False:
         print("error: cannot use a directory ({0}) as an input for this mode"
               .format(file_path))
+        sys.exit(-2)
 
 
-fn = args['input']
+# Validate "mode" argument
 mode = str(args['mode']).lower()
+if mode == "subtitles":
+    mode = "subs"
 
 # Validate "input" argument
+fn = args['input']
 if fn is None:
     parser.print_help()
     print("error: the following arguments are required: -i/--input")
     sys.exit(-2)
 if type(fn) is list:
     if len(fn) != 1:
-        if mode != "shader":
+        if mode not in MODES_SUPPORTING_MULTI_INPUTS:
             print(
-                "error: Cannot use multiple inputs with mode={0}".format(mode))
+                "error: cannot use multiple inputs with mode={0}".format(mode))
             sys.exit(-2)
         for file in fn:
             exit_if_missing(file, mode in MODES_SUPPORTING_MULTI_INPUTS)
@@ -120,9 +133,9 @@ def exit_if_missing(file_path: str, allow_dir: bool = True):
         exit_if_missing(fn, mode in MODES_SUPPORTING_MULTI_INPUTS)
 else:
     exit_if_missing(fn, mode in MODES_SUPPORTING_MULTI_INPUTS)
-
-if mode == "subtitles":
-    mode = "subs"
+if mode in MODES_SUPPORTING_MULTI_INPUTS:
+    if type(fn) is str:
+        fn = [fn]
 
 # Validate "output" argument
 if mode == "audio" or mode == "subs":
@@ -131,36 +144,86 @@ def exit_if_missing(file_path: str, allow_dir: bool = True):
         output = ""
     if output != "":
         if not os.path.isdir(output):
-            print("Output directory {0} does not exist".format(output))
+            print("error: output directory {0} does not exist".format(output))
             sys.exit(-2)
         else:
             if not output.endswith("/"):
                 output = output + "/"
-elif mode == "mux" or mode == "shader" or mode == "multi":
+elif mode in MODES_SUPPORTING_MULTI_INPUTS:
+    output = args['output'] or "out.mkv"
+    if os.path.isdir(output) and not os.path.exists(output):
+        try:
+            os.mkdir(output)
+        except Exception as e:
+            print(
+                "error: failed to create output directory={0}:".format(output))
+            print(e)
+            sys.exit(-2)
+else:
     output = args['output'] or "out.mkv"
-elif mode == "split":
-    output = args['output']
 
+# Collect input file paths from the input argument(s)
+in_files = []
+if mode in MODES_SUPPORTING_MULTI_INPUTS:
+    skip_inputs = args['skip_input']
+    if skip_inputs is None:
+        skip_inputs = []
+    elif type(skip_inputs) is str:
+        skip_inputs = [skip_inputs]
+
+    for file in fn:
+        if os.path.isdir(file):
+            for file_in_dir in glob.glob(
+                    os.path.join(file, "*.mkv")
+            ) + glob.glob(
+                os.path.join(file, "*.mp4")
+            ):
+                file_name = os.path.basename(file_in_dir)
+                if file_name in skip_inputs:
+                    continue
+                in_files.append(os.path.join(file_in_dir))
+        else:
+            # Only here for consistency
+            # Why would you specify a file input then add that file
+            # to a list of files to ignore?
+            if file in skip_inputs:
+                continue
+            in_files.append(os.path.join(file))
+    file_count = len(in_files)
+    if file_count > 1:
+        if not os.path.isdir(output):
+            print(
+                "error: output path must be a directory when there are more than one input files")
+            sys.exit(-2)
+    elif file_count == 0:
+        print("error: no valid input media files found")
+        sys.exit(-2)
+
+# Validate "skip_menus" argument
+skip_menus = args['skip_menus']
+if skip_menus is None:
+    skip_menus = {}
+
+# Perform action based on mode
 if mode == "audio":
-    extract_audio(fn, output)
+    extract_audio(fn, output, skip_menus)
 elif mode == "subs":
     extract_subs(fn, output)
 elif mode == "mux":
     mux(fn, output)
 elif mode == "shader":
-    if type(fn) is str:
-        fn = [fn]
-    shader(fn, args['width'], args['height'], args['shader_dir'], args['bit'],
-           args['audio_language'], args['softsubs'], args['softaudio'],
-           args['skip_menus'] or {}, output)
+    shader(in_files, args['width'], args['height'],
+           args['shader_dir'], args['bit'], args['audio_language'],
+           args['softsubs'], args['softaudio'], skip_menus, True, output)
 elif mode == "multi":
-    if type(fn) is str:
-        fn = [fn]
-    multi(fn, args['width'], args['height'], args['shader_dir'], args['bit'],
-          args['skip_menus'], args['delete_failures'], output)
+    multi(in_files, args['width'], args['height'],
+          args['shader_dir'], args['bit'], skip_menus,
+          args['delete_failures'], output)
+elif mode == "encode":
+    encode_to_hevc(in_files, output, skip_menus)
 elif mode == "split":
     length = get_video_length(fn)
     split_by_seconds(filename=fn, split_length=args['split_length'],
                      video_length=length, split_dir=output)
 else:
-    print("Unknown option: {0}".format(mode))
+    print("Unknown mode: {0}".format(mode))

encode.py

@@ -1,4 +1,3 @@
-import glob
 import os
 import subprocess
 import sys
@@ -8,134 +7,128 @@
 from utils import current_date, is_tool, clear
 
 
-def encode_to_hevc(fn: str, out: str):
+def encode_to_hevc(input_files: "list[str]", out: str,
+                   skip_menus: dict) -> dict:
     """
-    Encode a media file to HEVC
+    Encode a media file to HEVC using X265
 
     Args:
-        fn: media file path
+        input_files: list of input media file paths
         out: output path
+        skip_menus: menu skipping options passed from command line
+    Returns:
+        a mapping of successfully encoded input files to their output paths
     """
 
     param_line = "crf=18.0:limit-sao=1:bframes=8:aq-mode=3:psy-rd=1.0"
 
-    detail_menu = TerminalMenu([
-        "One setting to rule them all (Recommended if you don't know)",
-        "Flat, slow anime (slice of life, everything is well lit, e.g. Your Name)",
-        "Some dark scenes, some battle scenes (shonen, historical, etc., e.g. Kimetsu no Yaiba)",
-        "[TV Series] Movie-tier dark scene, complex grain/detail (Rarely used)",
-        "[Movie] Movie-tier dark scene, complex grain/detail (Rarely used)",
-    ], title="Choose the encode options")
+    detail_choice = None
+    if "encode" in skip_menus:
+        detail_choice = int(skip_menus["encode"])
+        if detail_choice < 0 or detail_choice > 4:
+            detail_choice = None
+    if detail_choice is None:
+        detail_menu = TerminalMenu([
+            "One setting to rule them all (Recommended if you don't know)",
+            "Flat, slow anime (slice of life, everything is well lit, e.g. Your Name)",
+            "Some dark scenes, some battle scenes (shonen, historical, etc., e.g. Kimetsu no Yaiba)",
+            "[TV Series] Movie-tier dark scene, complex grain/detail (Rarely used)",
+            "[Movie] Movie-tier dark scene, complex grain/detail (Rarely used)",
+        ], title="Choose the encode options")
+        detail_choice = detail_menu.show()
+        if detail_choice is None:
+            print("Cancelled")
+            sys.exit(-1)
 
-    choice = detail_menu.show()
-    # Flat, slow anime (slice of life, everything is well lit)
-    if choice == 1:
+    if detail_choice == 1:
+        # Flat, slow anime (slice of life, everything is well lit)
         param_line = "crf=19.0:bframes=8:aq-mode=3:psy-rd=1:aq-strength=0.8:deblock=1,1"
-    # Some dark scenes, some battle scenes (shonen, historical, etc.)
-    elif choice == 2:
+    elif detail_choice == 2:
+        # Some dark scenes, some battle scenes (shonen, historical, etc.)
         param_line = "crf=18.0:bframes=8:aq-mode=3:psy-rd=1.5:psy-rdoq=2"
-    # [TV Series] Movie-tier dark scene, complex grain/detail
-    elif choice == 3:
+    elif detail_choice == 3:
+        # [TV Series] Movie-tier dark scene, complex grain/detail
         param_line = "crf=18.0:limit-sao=1:bframes=8:aq-mode=3:psy-rd=1.5:psy-rdoq=3.5"
-    # [Movie] Movie-tier dark scene, complex grain/detail
-    elif choice == 4:
+    elif detail_choice == 4:
+        # [Movie] Movie-tier dark scene, complex grain/detail
         param_line = "crf=16.0:limit-sao=1:bframes=8:aq-mode=3:psy-rd=1.5:psy-rdoq=3.5"
 
     if is_tool("ffmpeg-bar"):
         binary = "ffmpeg-bar"
     else:
         binary = "ffmpeg"
 
-    files = []
-    if os.path.isdir(fn):
-        for file in glob.glob(os.path.join(fn, "*.mkv")):
-            files.append(os.path.join(file))
-    if len(files) == 0:
-        print("Encoding start time: " + current_date())
-        cmd = [
-            binary,
-            "-hide_banner",
-            "-i",
-            fn,
-            "-c:v",
-            "libx265",
-            "-profile:v",
-            "main10",
-            "-pix_fmt",
-            "yuv420p10le",
-            "-preset",
-            "slow",
-            "-x265-params",
-            param_line,
-            "-map",
-            "0:v:0",
-            "-f",
-            "matroska",
-            '-vf',
-            'scale=out_color_matrix=bt709',
-            '-color_primaries',
-            'bt709',
-            '-color_trc',
-            'bt709',
-            '-colorspace',
-            'bt709',
-            out
-        ]
+    cmd = [
+        binary,
+        "-hide_banner",
+        "-c:v",
+        "libx265",
+        "-profile:v",
+        "main10",
+        "-pix_fmt",
+        "yuv420p10le",
+        "-preset",
+        "slow",
+        "-x265-params",
+        param_line,
+        "-map",
+        "0:v:0",
+        "-f",
+        "matroska",
+        '-vf',
+        'scale=out_color_matrix=bt709',
+        '-color_primaries',
+        'bt709',
+        '-color_trc',
+        'bt709',
+        '-colorspace',
+        'bt709'
+    ]
+
+    encoded_files = {}
+
+    file_count = len(input_files)
+    start_time = current_date()
+    print("Encoding start time: " + start_time)
+    i = 0
+    for f in input_files:
+        print("Encoding start time for file={0}: {1}".format(
+            str(i + 1),
+            current_date()
+        ))
+
+        cmd.append("-i")
+        cmd.append(f)
+        output_path = None
+        if file_count == 1 and not os.path.isdir(out):
+            output_path = os.path.join(out)
+        else:
+            name = f.split("/")
+            name = name[len(name) - 1]
+            output_path = os.path.join(out, name + "-encoded.mkv")
+        cmd.append(output_path)
+
+        return_code = -1
         try:
-            subprocess.call(cmd)
+            return_code = subprocess.call(cmd)
         except KeyboardInterrupt:
-            print("Cancelled encoding, exiting program...")
+            print("Cancelled encoding for file={0}".format(f))
+            print("Exiting program...")
             try:
                 sys.exit(-1)
             except SystemExit:
                 os._exit(-1)
-        print("Encoding end time: " + current_date())
-    else:
-        print("Encoding start time: " + current_date())
-        i = 0
-        for f in files:
-            clear()
-            name = f.split("/")
-            name = name[len(name) - 1]
-            cmd = [
-                binary,
-                "-hide_banner",
-                "-i",
-                f,
-                "-c:v",
-                "libx265",
-                "-profile:v",
-                "main10",
-                "-pix_fmt",
-                "yuv420p10le",
-                "-preset",
-                "slow",
-                "-x265-params",
-                param_line,
-                "-map",
-                "0:v:0",
-                "-f",
-                "matroska",
-                '-vf',
-                'scale=out_color_matrix=bt709',
-                '-color_primaries',
-                'bt709',
-                '-color_trc',
-                'bt709',
-                '-colorspace',
-                'bt709',
-                os.path.join(out, name)
-            ]
-            try:
-                subprocess.call(cmd)
-            except KeyboardInterrupt:
-                print("Cancelled encoding for file={0}".format(f))
-                print("Exiting program...")
-                try:
-                    sys.exit(-1)
-                except SystemExit:
-                    os._exit(-1)
-            print("Encoding end time for file=" + str(
-                i + 1) + ": " + current_date())
-            i = i + 1
-        print("Encoding end time: " + current_date())
+        if return_code == 0:
+            encoded_files[f] = output_path
+        else:
+            print("error: failed to encode file={0}".format(f))
+        print("Encoding end time for file={0}: {1}".format(
+            str(i + 1),
+            current_date())
+        )
+        i = i + 1
+        clear()
+    print("Encoding start time: " + start_time)
+    print("Encoded files: {0}".format(", ".join(encoded_files.keys())))
+    print("Encoding end time: " + current_date())
+    return encoded_files

extract_audio.py

@@ -10,13 +10,14 @@
 from utils import current_date, language_mapping
 
 
-def extract_audio(fn: str, out_dir: str) -> bool:
+def extract_audio(fn: str, out_dir: str, skip_menus: dict) -> bool:
     """
     Extract audio from a media file.
 
     Args:
         fn: input media file path
         out_dir: directory where audio files are extracted to
+        skip_menus: menu skipping options passed from command line
     Returns:
         True if the audio tracks were successfully extracted
     """
@@ -44,6 +45,7 @@ def extract_audio(fn: str, out_dir: str) -> bool:
                 ])
             except KeyboardInterrupt:
                 print("Cancelled track extraction.")
+                print("Please clear the audio files in the current directory.")
                 print("Exiting program...")
                 try:
                     sys.exit(-1)
@@ -58,31 +60,54 @@ def extract_audio(fn: str, out_dir: str) -> bool:
     for file in glob.glob(out_dir + "*.FLAC"):
         flacs.append(file)
     if len(flacs) > 0:
-        convert_menu = TerminalMenu(
-            ["Yes", "No"],
-            title="Do you want to convert every FLAC to Opus?"
-        )
-        convert_choice = convert_menu.show()
+        convert_choice = None
+        if "convert" in skip_menus:
+            convert_choice = int(skip_menus['convert'])
+            if convert_choice < 0 or convert_choice > 1:
+                convert_choice = None
+            else:
+                # Flip the value, because "1" in the command line arg means
+                # "Yes" which is at index 0 in convert_menu choice array
+                convert_choice = 1 - convert_choice
+        if convert_choice is None:
+            convert_menu = TerminalMenu(
+                ["Yes", "No"],
+                title="Do you want to convert every FLAC to Opus?"
+            )
+            convert_choice = convert_menu.show()
+            if convert_choice is None:
+                print("Cancelled conversion")
+
         if convert_choice == 0:
             print("Conversion start time: " + current_date())
             for f in flacs:
-                br_menu = TerminalMenu(
-                    ["192K", "256K", "320K"],
-                    title="What's the format of the file? => {0}".format(f)
-                )
-                br_choice = br_menu.show()
+                bit_rates = ["192K", "256K", "320K"]
+                br_choice = None
+                if "bitrate" in skip_menus:
+                    br_choice = bit_rates.index(skip_menus["bitrate"])
+                    if br_choice < 0 or br_choice > 2:
+                        br_choice = None
+                if br_choice is None:
+                    br_menu = TerminalMenu(
+                        bit_rates,
+                        title="What's the format of the file? => {0}".format(f)
+                    )
+                    br_choice = br_menu.show()
+                    if br_choice is None:
+                        print("Cancelled conversion")
+                        continue
                 if br_choice == 0:
                     br = "192K"
                 elif br_choice == 1:
                     br = "256K"
                 elif br_choice == 2:
                     br = "320K"
-                else:
-                    br = "192K"
+
                 fn_base = f.split(".")[0]
                 out_audio = fn_base + ".Opus"
+                return_code = -1
                 try:
-                    subprocess.call([
+                    return_code = subprocess.call([
                         "ffmpeg",
                         "-hide_banner",
                         "-i",
@@ -98,12 +123,8 @@ def extract_audio(fn: str, out_dir: str) -> bool:
                 except KeyboardInterrupt:
                     print("Cancelled conversion.")
                     os.remove(out_audio)
-                    print("Exiting program...")
-                    try:
-                        sys.exit(-1)
-                    except SystemExit:
-                        os._exit(-1)
                 time.sleep(1)
-                os.remove(f)
+                if return_code == 0:
+                    os.remove(f)
             print("Conversion end time: " + current_date())
     return success

multi.py

@@ -5,9 +5,10 @@
 from extract_subs import extract_subs
 from mux import clean_up, mux
 from shader import shader
+from utils import clear
 
 
-def multi(fn: "list[str]", width: int, height: int, shader_path: str,
+def multi(input_files: "list[str]", width: int, height: int, shader_path: str,
           ten_bit: bool, skip_menus: dict, del_failures: bool, outname: str):
     """
     Run mode shader on the input files, then for each file successfully
@@ -16,7 +17,7 @@ def multi(fn: "list[str]", width: int, height: int, shader_path: str,
     extracted subs and audio track files.
 
     Args:
-        fn: list of input files
+        input_files: list of input media files
         width: desired width of video
         height: desired height of video
         shader_path: path where the shaders are located
@@ -30,15 +31,17 @@ def multi(fn: "list[str]", width: int, height: int, shader_path: str,
 
     if skip_menus is None:
         skip_menus = {}
-    encoded_files = shader(fn=fn, width=width, height=height,
-                           shader_path=shader_path,
-                           ten_bit=ten_bit, language="", softsubs=True,
-                           softaudio=True,
-                           skip_menus=skip_menus, outname=outname)
+    encoded_files = shader(input_files=input_files, width=width, height=height,
+                           shader_path=shader_path, ten_bit=ten_bit,
+                           language="", softsubs=True,
+                           softaudio=True, skip_menus=skip_menus,
+                           exit_on_cancel=False, outname=outname)
+    clear()
     if len(encoded_files) == 0:
-        print()
         print("error: no files encoded, terminating program early...")
         sys.exit(-2)
+    else:
+        print("Encoded files: {0}".format(", ".join(encoded_files.keys())))
 
     successful_inputs = {}
     failed_inputs = []
@@ -59,7 +62,7 @@ def multi(fn: "list[str]", width: int, height: int, shader_path: str,
             continue
         print()
         print("Starting mode audio for input={0}".format(input_path))
-        if not extract_audio(input_path, ""):
+        if not extract_audio(input_path, "", skip_menus):
             print(
                 "Failed to extract audio for file={0}".format(input_path)
             )

shader.py

@@ -1,4 +1,3 @@
-import glob
 import os
 import subprocess
 import sys
@@ -24,10 +23,12 @@ def menu_fhd_shaders(shader_path: str, skip_menus: dict) -> str:
     """
 
     mode_choice = None
-    if "shader" in skip_menus and skip_menus['shader'] is not None:
+    if "shader" in skip_menus:
         mode_choice = int(skip_menus['shader'])
         if mode_choice < 0 or mode_choice > 5:
             mode_choice = None
+    elif "recommended" in skip_menus and skip_menus['recommended'] == "1":
+        mode_choice = 4
     if mode_choice is None:
         mode_menu = TerminalMenu(
             [
@@ -133,14 +134,16 @@ def menu_fhd_shaders(shader_path: str, skip_menus: dict) -> str:
 
 # Core
 
-def remove_audio_and_subs(fn: str, softsubs: bool, softaudio: bool):
+def remove_audio_and_subs(fn: str, softsubs: bool, softaudio: bool) -> int:
     """
     Remove audio and optionally subtitles from a file.
 
     Args:
         fn: media file path
         softsubs: true if subtitles should be removed
         softaudio: true if audio should be removed
+    Returns:
+        return code of the merge process
     """
 
     args = [
@@ -155,7 +158,7 @@ def remove_audio_and_subs(fn: str, softsubs: bool, softaudio: bool):
     args.append(fn)
 
     try:
-        subprocess.call(args)
+        return subprocess.call(args)
     except KeyboardInterrupt:
         print("File processing cancelled for file={0}".format(fn))
         shader_cleanup()
@@ -174,15 +177,42 @@ def shader_cleanup():
     os.remove("temp.mkv")
 
 
-def shader(fn: "list[str]", width: int, height: int, shader_path: str,
-           ten_bit: bool,
-           language: str, softsubs: bool, softaudio: bool, skip_menus: dict,
-           outname: str) -> dict:
+def handle_encoding_cancellation(file_name: str, output_file, start_time: str,
+                                 exit: bool):
+    """
+    Handle cancellation during encoding
+
+    Args:
+        file_name: The current file being encoded
+        output_file: The output file to delete
+        start_time: The time the first file began encoding
+        exit: true if the program should terminate
+    """
+
+    print("Cancelled encoding of file={0}".format(file_name))
+    print("Start time: {0}".format(start_time))
+    print("End time: " + current_date())
+    print()
+    print("Deleting temporary files...")
+    shader_cleanup()
+    if output_file is not None:
+        os.remove(output_file)
+    if exit:
+        print("Exiting program...")
+        try:
+            sys.exit(-1)
+        except SystemExit:
+            os._exit(-1)
+
+
+def shader(input_files: "list[str]", width: int, height: int, shader_path: str,
+           ten_bit: bool, language: str, softsubs: bool, softaudio: bool,
+           skip_menus: dict, exit_on_cancel: bool, outname: str) -> dict:
     """
     Select encoding and start the encoding process.
 
     Args:
-        fn: list of input media paths
+        input_files: list of input media paths
         width: output width
         height: output height
         shader_path: path the shaders are located at
@@ -191,6 +221,8 @@ def shader(fn: "list[str]", width: int, height: int, shader_path: str,
         softsubs: true if subtitles should be removed
         softaudio: true if audio should be removed
         skip_menus: menu skipping options passed from command line
+        exit_on_cancel: true if the program should exit when the user cancels
+            during encoding, false if the function call should terminate
         outname: output path
 
     Returns:
@@ -202,41 +234,33 @@ def shader(fn: "list[str]", width: int, height: int, shader_path: str,
             shader_path))
         sys.exit(-2)
 
-    files = []
-    for file in fn:
-        if os.path.isdir(file):
-            for fileInDir in glob.glob(os.path.join(file, "*.mkv")):
-                files.append(os.path.join(fileInDir))
-            for fileInDir in glob.glob(os.path.join(file, "*.mp4")):
-                files.append(os.path.join(fileInDir))
-        else:
-            files.append(os.path.join(file))
-    file_count = len(files)
-    if file_count > 1:
-        if not os.path.isdir(outname):
-            print(
-                "error: output path must be a directory when there are more than one input files")
-            sys.exit(-2)
-    elif file_count == 0:
-        print("error: no valid input media files found")
-        sys.exit(-2)
-    else:
-        clear()
-        if os.path.isdir(outname):
-            outname = os.path.join(outname, "out.mkv")
-        remove_audio_and_subs(files[0], softsubs, softaudio)
+    output_is_dir = os.path.isdir(outname)
+    if len(input_files) == 1:
+        if output_is_dir:
+            new_outname = os.path.join(outname, "out.mkv")
+            out_name_index = 1
+            while os.path.exists(new_outname):
+                new_outname = os.path.join(outname, "out-{0}.mkv"
+                                           .format(str(out_name_index)))
+                out_name_index = out_name_index + 1
+            outname = new_outname
+            output_is_dir = False
+        remove_audio_and_subs(input_files[0], softsubs, softaudio)
         clear()
 
     # Select encoder
     codec = ""
     encoder = ""
 
-    if "encoder" in skip_menus and skip_menus['encoder'] is not None:
+    if "encoder" in skip_menus:
         encoder = skip_menus['encoder']
         if encoder != 'cpu' and encoder != 'nvenc' and encoder != 'amf':
             print("Unsupported encoder: {0}".format(encoder))
             sys.exit(-2)
-    if "codec" in skip_menus and skip_menus['codec'] is not None:
+    if encoder == "":
+        if "recommended" in skip_menus and skip_menus["recommended"] == "1":
+            encoder = "cpu"
+    if "codec" in skip_menus:
         codec = skip_menus['codec']
         if codec == 'x264':
             codec = 'h264'
@@ -249,6 +273,9 @@ def shader(fn: "list[str]", width: int, height: int, shader_path: str,
         if codec != 'h264' and codec != 'hevc':
             print("Unsupported codec={0}".format(encoder))
             sys.exit(-2)
+    if codec == "":
+        if "recommended" in skip_menus and skip_menus["recommended"] == "1":
+            codec = "h264"
     if codec == "" or encoder == "":
         cg_menu = TerminalMenu(
             [
@@ -286,58 +313,17 @@ def shader(fn: "list[str]", width: int, height: int, shader_path: str,
             sys.exit(-2)
 
     return start_encoding(codec, encoder, width, height, shader_path, ten_bit,
-                          language, softsubs, softaudio, skip_menus, outname,
-                          files)
-
-
-def handle_encoding_cancellation(file_name: str, output_file, start_time: str):
-    """
-    Handle cancellation during encoding
-
-    Args:
-        file_name: The current file being encoded
-        output_file: The output file to delete
-        start_time: The time the first file began encoding
-    """
-
-    print("Cancelled encoding of file={0}".format(file_name))
-    print("Start time: {0}".format(start_time))
-    print("End time: " + current_date())
-    print()
-    print("Deleting temporary files...")
-    shader_cleanup()
-    if output_file is not None:
-        os.remove(output_file)
-    print("Exiting program...")
-    try:
-        sys.exit(-1)
-    except SystemExit:
-        os._exit(-1)
+                          language, softsubs, softaudio, skip_menus,
+                          exit_on_cancel, input_files, outname)
 
 
 def start_encoding(codec: str, encoder: str, width: int, height: int,
                    shader_path: str, ten_bit: bool, language: str,
                    softsubs: bool, softaudio: bool, skip_menus: dict,
-                   outname: str, files: "list[str]") -> dict:
+                   exit_on_cancel: bool, files: "list[str]",
+                   outname: str) -> dict:
     """
     Start the encoding of input file(s) to the specified encoding using the CPU.
-
-    Args:
-        codec: h264/hevc
-        encoder: cpu/nvenc/amf
-        width: output width
-        height: output height
-        shader_path: path the shaders are located at
-        ten_bit: true if the input media is a 10 bit source
-        language: optional desired audio track language
-        softsubs: true if subtitles should be removed
-        softaudio: true if audio should be removed
-        skip_menus: menu skipping options passed from command line
-        outname: output path
-        files: list of input media file paths
-
-    Returns:
-        mapping of files that were successfully encoded to their output paths
     """
 
     clear()
@@ -365,10 +351,12 @@ def start_encoding(codec: str, encoder: str, width: int, height: int,
         elif encoder == "nvenc":
             codec_presets = ["fast", "medium", "slow", "lossless"]
         codec_preset = None
-        if "preset" in skip_menus and skip_menus['preset'] is not None:
+        if "preset" in skip_menus:
             codec_preset = skip_menus['preset']
             if codec_preset not in codec_presets:
                 codec_preset = None
+        elif "recommended" in skip_menus and skip_menus["recommended"] == "1":
+            codec_preset = "fast"
         if codec_preset is None:
             selected_codec_preset = TerminalMenu(codec_presets,
                                                  title="Choose Encoder Preset:").show()
@@ -380,29 +368,33 @@ def start_encoding(codec: str, encoder: str, width: int, height: int,
 
     comp_level = ""
     if encoder == "cpu":
-        if "crf" in skip_menus and skip_menus['crf'] is not None:
+        if "crf" in skip_menus:
             crf = int(skip_menus['crf'])
             if 0 <= crf <= 51:
                 comp_level = str(crf)
             else:
                 comp_level = "23"
                 print("Invalid crf provided, using default crf={0}".format(
                     comp_level))
+        elif "recommended" in skip_menus and skip_menus["recommended"] == "1":
+            comp_level = "23"
         else:
             comp_level = input(
                 "Insert compression factor (CRF) 0-51\n0 = Lossless | 23 = Default | 51 = Highest compression\n"
             )
             if comp_level == "" or comp_level is None:
                 comp_level = "23"
     elif encoder == "nvenc" or encoder == "amf":
-        if "qp" in skip_menus and skip_menus['qp'] is not None:
+        if "qp" in skip_menus:
             qp = int(skip_menus['qp'])
             if 0 <= qp <= 51:
                 comp_level = str(qp)
             else:
                 comp_level = "24"
                 print("Invalid qp provided, using default qp={0}".format(
                     comp_level))
+        elif "recommended" in skip_menus and skip_menus["recommended"] == "1":
+            comp_level = "24"
         else:
             comp_level = input(
                 "Insert Quantization Parameter (QP) 0-51\n0 = Lossless | 24 = Default | 51 = Highest compression\n"
@@ -505,7 +497,9 @@ def start_encoding(codec: str, encoder: str, width: int, height: int,
                 encoding_args + ['--o=' + outname, "temp.mkv"]
             )
         except KeyboardInterrupt:
-            handle_encoding_cancellation(files[0], outname, start_time)
+            handle_encoding_cancellation(files[0], outname, start_time,
+                                         exit_on_cancel)
+            return successful_encodes
         print("End time: " + current_date())
         os.remove("temp.mkv")
         print()
@@ -524,7 +518,15 @@ def start_encoding(codec: str, encoder: str, width: int, height: int,
             name = name[len(name) - 1]
             remove_audio_and_subs(f, softsubs, softaudio)
             clear()
-            print("Files: {0}".format(files_string))
+            print("Encoded files: {0}".format(
+                ", ".join(successful_encodes.keys())))
+            print("Remaining files: {0}".format(", ".join(
+                [
+                    item for item in files
+                    if
+                    item not in failed_files and item not in successful_encodes
+                ]
+            )))
             print("Start time: {0}".format(start_time))
             print("Start time for file={0}: {1}".format(str(i + 1),
                                                         current_date()))
@@ -538,7 +540,10 @@ def start_encoding(codec: str, encoder: str, width: int, height: int,
                     "temp.mkv"
                 ])
             except KeyboardInterrupt:
-                handle_encoding_cancellation(f, output_path, start_time)
+                handle_encoding_cancellation(f, output_path, start_time,
+                                             exit_on_cancel)
+                return successful_encodes
+
             if return_code != 0:
                 failed_files.append(f)
             else:

utils.py

@@ -2,7 +2,7 @@
 from datetime import datetime
 from shutil import which
 
-__current_version__ = '1.1.1'
+__current_version__ = '1.1.2'
 
 
 def credz():