renamed bin to src since python isn't binary

src/anime4k.py

@@ -0,0 +1,92 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Name: Anime4K Driver
+Author: K4YT3X
+Date Created: August 15, 2019
+Last Modified: August 15, 2019
+
+Description: This class is a high-level wrapper
+for Anime4k.
+"""
+
+# built-in imports
+import subprocess
+import threading
+
+# third-party imports
+from avalon_framework import Avalon
+
+
+class Anime4k:
+    """This class communicates with Anime4K engine
+
+    An object will be created for this class, containing information
+    about the binary address and the processing method. When being called
+    by the main program, other detailed information will be passed to
+    the upscale function.
+    """
+
+    def __init__(self, waifu2x_settings):
+        self.waifu2x_settings = waifu2x_settings
+        self.print_lock = threading.Lock()
+
+    def upscale(self, input_directory, output_directory, scale_ratio, upscaler_exceptions, push_strength=None, push_grad_strength=None):
+        """ Anime4K wrapper
+
+        Arguments:
+            file_in {string} -- input file path
+            file_out {string} -- output file path
+
+        Keyword Arguments:
+            scale {int} -- scale ratio (default: {None})
+            push_strength {int} -- residual push strength (default: {None})
+            push_grad_strength {int} -- residual gradient push strength (default: {None})
+
+        Returns:
+            subprocess.Popen.returncode -- command line return value of execution
+        """
+        try:
+            # return value is the sum of all execution return codes
+            return_value = 0
+
+            # get a list lof all image files in input_directory
+            extracted_frame_files = [f for f in input_directory.iterdir() if str(f).lower().endswith('.png') or str(f).lower().endswith('.jpg')]
+
+            # upscale each image in input_directory
+            for image in extracted_frame_files:
+
+                execute = [
+                    self.waifu2x_settings['java_path'],
+                    '-jar',
+                    self.waifu2x_settings['anime4k_path'],
+                    str(image.absolute()),
+                    str(output_directory / image.name),
+                    str(scale_ratio)
+                ]
+
+                # optional arguments
+                kwargs = [
+                    'push_strength',
+                    'push_grad_strength'
+                ]
+
+                # if optional argument specified, append value to execution list
+                for arg in kwargs:
+                    if locals()[arg] is not None:
+                        execute.extend([locals([arg])])
+
+                self.print_lock.acquire()
+                Avalon.debug_info(f'Executing: {execute}', )
+                self.print_lock.release()
+                return_value += subprocess.run(execute, check=True).returncode
+
+            # print thread exiting message
+            self.print_lock.acquire()
+            Avalon.debug_info(f'[upscaler] Thread {threading.current_thread().name} exiting')
+            self.print_lock.release()
+
+            # return command execution return code
+            return return_value
+        except Exception as e:
+            upscaler_exceptions.append(e)

src/exceptions.py

@@ -0,0 +1,28 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Name: Video2X Exceptions
+Dev: K4YT3X
+Date Created: December 13, 2018
+Last Modified: July 27, 2019
+"""
+
+
+class ArgumentError(Exception):
+    def __init__(self, message):
+        super().__init__(message)
+
+
+class StreamNotFoundError(Exception):
+    def __init__(self, message):
+        super().__init__(message)
+
+
+class UnrecognizedDriverError(Exception):
+    def __init__(self, message):
+        super().__init__(message)
+
+
+class UnsupportedPixelError(Exception):
+    def __init__(self, message):
+        super().__init__(message)

src/ffmpeg.py

@@ -0,0 +1,287 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Name: Video2X FFmpeg Controller
+Author: K4YT3X
+Date Created: Feb 24, 2018
+Last Modified: August 15, 2019
+
+Description: This class handles all FFmpeg related operations.
+"""
+
+# built-in imports
+import json
+import pathlib
+import subprocess
+
+# third-party imports
+from avalon_framework import Avalon
+
+
+class Ffmpeg:
+    """This class communicates with FFmpeg
+
+    This class deals with FFmpeg. It handles extracting
+    frames, stripping audio, converting images into videos
+    and inserting audio tracks to videos.
+    """
+
+    def __init__(self, ffmpeg_settings, image_format):
+        self.ffmpeg_settings = ffmpeg_settings
+
+        self.ffmpeg_path = pathlib.Path(self.ffmpeg_settings['ffmpeg_path'])
+        self.ffmpeg_binary = self.ffmpeg_path / 'ffmpeg.exe'
+        self.ffmpeg_probe_binary = self.ffmpeg_path / 'ffprobe.exe'
+        self.image_format = image_format
+        self.pixel_format = None
+
+    def get_pixel_formats(self):
+        """ Get a dictionary of supported pixel formats
+
+        List all supported pixel formats and their
+        corresponding bit depth.
+
+        Returns:
+            dictionary -- JSON dict of all pixel formats to bit depth
+        """
+        execute = [
+            self.ffmpeg_probe_binary,
+            '-v',
+            'quiet',
+            '-pix_fmts'
+        ]
+
+        # turn elements into str
+        execute = [str(e) for e in execute]
+
+        Avalon.debug_info(f'Executing: {" ".join(execute)}')
+
+        # initialize dictionary to store pixel formats
+        pixel_formats = {}
+
+        # record all pixel formats into dictionary
+        for line in subprocess.run(execute, check=True, stdout=subprocess.PIPE).stdout.decode().split('\n'):
+            try:
+                pixel_formats[' '.join(line.split()).split()[1]] = int(' '.join(line.split()).split()[3])
+            except (IndexError, ValueError):
+                pass
+
+        # print pixel formats for debugging
+        Avalon.debug_info(pixel_formats)
+
+        return pixel_formats
+
+    def get_video_info(self, input_video):
+        """ Gets input video information
+
+        This method reads input video information
+        using ffprobe in dictionary
+
+        Arguments:
+            input_video {string} -- input video file path
+
+        Returns:
+            dictionary -- JSON text of input video information
+        """
+
+        # this execution command needs to be hard-coded
+        # since video2x only strictly recignizes this one format
+        execute = [
+            self.ffmpeg_probe_binary,
+            '-v',
+            'quiet',
+            '-print_format',
+            'json',
+            '-show_format',
+            '-show_streams',
+            '-i',
+            input_video
+        ]
+
+        # turn elements into str
+        execute = [str(e) for e in execute]
+
+        Avalon.debug_info(f'Executing: {" ".join(execute)}')
+        json_str = subprocess.run(execute, check=True, stdout=subprocess.PIPE).stdout
+        return json.loads(json_str.decode('utf-8'))
+
+    def extract_frames(self, input_video, extracted_frames):
+        """Extract every frame from original videos
+
+        This method extracts every frame from input video using FFmpeg
+
+        Arguments:
+            input_video {string} -- input video path
+            extracted_frames {string} -- video output directory
+        """
+        execute = [
+            self.ffmpeg_binary
+        ]
+
+        execute.extend(self._read_configuration(phase='video_to_frames'))
+
+        execute.extend([
+            '-i',
+            input_video
+        ])
+
+        execute.extend(self._read_configuration(phase='video_to_frames', section='output_options'))
+
+        execute.extend([
+            extracted_frames / f'extracted_%0d.{self.image_format}'
+        ])
+
+        self._execute(execute)
+
+    def convert_video(self, framerate, resolution, upscaled_frames):
+        """Converts images into videos
+
+        This method converts a set of images into a video
+
+        Arguments:
+            framerate {float} -- target video framerate
+            resolution {string} -- target video resolution
+            upscaled_frames {string} -- source images directory
+        """
+        execute = [
+            self.ffmpeg_binary,
+            '-r',
+            str(framerate),
+            '-s',
+            resolution
+        ]
+
+        # read other options
+        execute.extend(self._read_configuration(phase='frames_to_video'))
+
+        # read FFmpeg input options
+        execute.extend(self._read_configuration(phase='frames_to_video', section='input_options'))
+
+        # WORKAROUND FOR WAIFU2X-NCNN-VULKAN
+        # Dev: SAT3LL
+        # rename all .png.png suffixes to .png
+        import re
+        regex = re.compile(r'\.png\.png$', re.IGNORECASE)
+        for frame_name in upscaled_frames.iterdir():
+            (upscaled_frames / frame_name).rename(upscaled_frames / regex.sub('.png', str(frame_name)))
+        # END WORKAROUND
+
+        # append input frames path into command
+        execute.extend([
+            '-i',
+            upscaled_frames / f'extracted_%d.{self.image_format}'
+        ])
+
+        # read FFmpeg output options
+        execute.extend(self._read_configuration(phase='frames_to_video', section='output_options'))
+
+        # specify output file location
+        execute.extend([
+            upscaled_frames / 'no_audio.mp4'
+        ])
+
+        self._execute(execute)
+
+    def migrate_audio_tracks_subtitles(self, input_video, output_video, upscaled_frames):
+        """ Migrates audio tracks and subtitles from input video to output video
+
+        Arguments:
+            input_video {string} -- input video file path
+            output_video {string} -- output video file path
+            upscaled_frames {string} -- directory containing upscaled frames
+        """
+        execute = [
+            self.ffmpeg_binary
+        ]
+
+        execute.extend(self._read_configuration(phase='migrating_tracks'))
+
+        execute.extend([
+            '-i',
+            upscaled_frames / 'no_audio.mp4',
+            '-i',
+            input_video
+        ])
+
+        execute.extend(self._read_configuration(phase='migrating_tracks', section='output_options'))
+
+        execute.extend([
+            output_video
+        ])
+
+        self._execute(execute)
+
+    def _read_configuration(self, phase, section=None):
+        """ read configuration from JSON
+
+        Read the configurations (arguments) from the JSON
+        configuration file and append them to the end of the
+        FFmpeg command.
+
+        Arguments:
+            execute {list} -- list of arguments to be executed
+            phase {str} -- phase of operation
+        """
+
+        configuration = []
+
+        # if section is specified, read configurations or keys
+        # from only that section
+        if section:
+            source = self.ffmpeg_settings[phase][section].keys()
+
+            # if pixel format is not specified, use the source pixel format
+            try:
+                if self.ffmpeg_settings[phase][section].get('-pix_fmt') is None:
+                    self.ffmpeg_settings[phase][section]['-pix_fmt'] = self.pixel_format
+            except KeyError:
+                pass
+        else:
+            source = self.ffmpeg_settings[phase].keys()
+
+        for key in source:
+
+            if section:
+                value = self.ffmpeg_settings[phase][section][key]
+            else:
+                value = self.ffmpeg_settings[phase][key]
+
+            # null or None means that leave this option out (keep default)
+            if value is None or value is False or isinstance(value, dict):
+                continue
+
+            # if the value is a list, append the same argument and all values
+            elif isinstance(value, list):
+
+                for subvalue in value:
+                    configuration.append(key)
+                    if value is not True:
+                        configuration.append(str(subvalue))
+
+            # otherwise the value is typical
+            else:
+                configuration.append(key)
+
+                # true means key is an option
+                if value is True:
+                    continue
+
+                configuration.append(str(value))
+
+        return configuration
+
+    def _execute(self, execute):
+        """ execute command
+
+        Arguments:
+            execute {list} -- list of arguments to be executed
+
+        Returns:
+            int -- execution return code
+        """
+        # turn all list elements into string to avoid errors
+        execute = [str(e) for e in execute]
+
+        Avalon.debug_info(f'Executing: {execute}')
+
+        return subprocess.run(execute, shell=True, check=True).returncode

src/image_cleaner.py

@@ -0,0 +1,76 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Name: Video2X Image Cleaner
+Author: BrianPetkovsek
+Author: K4YT3X
+Date Created: March 24, 2019
+Last Modified: July 27, 2019
+
+Description: This class is to remove the extracted frames
+that have already been upscaled.
+"""
+
+# built-in imports
+import threading
+import time
+
+
+class ImageCleaner(threading.Thread):
+    """ Video2X Image Cleaner
+
+    This class creates an object that keeps track of extracted
+    frames that has already been upscaled and are not needed
+    anymore. It then deletes them to save disk space.
+
+    Extends:
+        threading.Thread
+    """
+
+    def __init__(self, input_directory, output_directory, threads):
+        threading.Thread.__init__(self)
+        self.input_directory = input_directory
+        self.output_directory = output_directory
+        self.threads = threads
+        self.running = False
+
+    def run(self):
+        """ Run image cleaner
+        """
+        self.running = True
+
+        while self.running:
+            self.remove_upscaled_frames()
+            time.sleep(1)
+
+    def stop(self):
+        """ Stop the image cleaner
+        """
+        self.running = False
+        self.join()
+
+    def remove_upscaled_frames(self):
+        """ remove frames that have already been upscaled
+
+        This method compares the files in the extracted frames
+        directory with the upscaled frames directory, and removes
+        the frames that has already been upscaled.
+        """
+
+        # list all images in the extracted frames
+        output_frames = [f for f in self.output_directory.iterdir() if f.is_file()]
+
+        # compare and remove frames downscaled images that finished being upscaled
+        # within each thread's  extracted frames directory
+        for thread_id in range(self.threads):
+            dir_path = self.input_directory / str(thread_id)
+
+            # for each file within all the directories
+            for file in dir_path.iterdir():
+                file_path = dir_path / file
+
+                # if file also exists in the output directory, then the file
+                # has already been processed, thus not needed anymore
+                if file_path.is_file() and file in output_frames:
+                    file_path.unlink(file)
+                    output_frames.remove(file)

src/requirements.txt

@@ -0,0 +1,6 @@
+avalon_framework
+colorama
+GPUtil
+psutil
+requests
+tqdm

src/upscaler.py

@@ -0,0 +1,369 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Name: Video2X Upscaler
+Author: K4YT3X
+Date Created: December 10, 2018
+Last Modified: August 21, 2019
+
+Dev: SAT3LL
+
+Licensed under the GNU General Public License Version 3 (GNU GPL v3),
+    available at: https://www.gnu.org/licenses/gpl-3.0.txt
+
+(C) 2018-2019 K4YT3X
+"""
+
+# local imports
+from anime4k import Anime4k
+from exceptions import *
+from ffmpeg import Ffmpeg
+from image_cleaner import ImageCleaner
+from waifu2x_caffe import Waifu2xCaffe
+from waifu2x_converter import Waifu2xConverter
+from waifu2x_ncnn_vulkan import Waifu2xNcnnVulkan
+
+# built-in imports
+from fractions import Fraction
+import contextlib
+import copy
+import pathlib
+import re
+import shutil
+import tempfile
+import threading
+import time
+import traceback
+
+# third-party imports
+from avalon_framework import Avalon
+from tqdm import tqdm
+
+AVAILABLE_DRIVERS = ['waifu2x_caffe', 'waifu2x_converter', 'waifu2x_ncnn_vulkan', 'anime4k']
+
+
+class Upscaler:
+    """ An instance of this class is a upscaler that will
+    upscale all images in the given directory.
+
+    Raises:
+        Exception -- all exceptions
+        ArgumentError -- if argument is not valid
+    """
+
+    def __init__(self, input_video, output_video, method, waifu2x_settings, ffmpeg_settings):
+        # mandatory arguments
+        self.input_video = input_video
+        self.output_video = output_video
+        self.method = method
+        self.waifu2x_settings = waifu2x_settings
+        self.ffmpeg_settings = ffmpeg_settings
+
+        # optional arguments
+        self.waifu2x_driver = 'waifu2x_caffe'
+        self.scale_width = None
+        self.scale_height = None
+        self.scale_ratio = None
+        self.model_dir = None
+        self.threads = 5
+        self.video2x_cache_directory = pathlib.Path(tempfile.gettempdir()) / 'video2x'
+        self.image_format = 'png'
+        self.preserve_frames = False
+
+    def create_temp_directories(self):
+        """create temporary directory
+        """
+        self.extracted_frames = pathlib.Path(tempfile.mkdtemp(dir=self.video2x_cache_directory))
+        Avalon.debug_info(f'Extracted frames are being saved to: {self.extracted_frames}')
+        self.upscaled_frames = pathlib.Path(tempfile.mkdtemp(dir=self.video2x_cache_directory))
+        Avalon.debug_info(f'Upscaled frames are being saved to: {self.upscaled_frames}')
+
+    def cleanup_temp_directories(self):
+        """delete temp directories when done
+        """
+        if not self.preserve_frames:
+            for directory in [self.extracted_frames, self.upscaled_frames]:
+                try:
+                    # avalon framework cannot be used if python is shutting down
+                    # therefore, plain print is used
+                    print(f'Cleaning up cache directory: {directory}')
+                    shutil.rmtree(directory)
+                except (OSError, FileNotFoundError):
+                    print(f'Unable to delete: {directory}')
+                    traceback.print_exc()
+
+    def _check_arguments(self):
+        # check if arguments are valid / all necessary argument
+        # values are specified
+        if not self.input_video:
+            raise ArgumentError('You need to specify the video to process')
+        elif (not self.scale_width or not self.scale_height) and not self.scale_ratio:
+            raise ArgumentError('You must specify output video width and height or upscale factor')
+        elif not self.output_video:
+            raise ArgumentError('You need to specify the output video name')
+        elif not self.method:
+            raise ArgumentError('You need to specify the enlarging processing unit')
+
+    def _progress_bar(self, extracted_frames_directories):
+        """ This method prints a progress bar
+
+        This method prints a progress bar by keeping track
+        of the amount of frames in the input directory
+        and the output directory. This is originally
+        suggested by @ArmandBernard.
+        """
+
+        # get number of extracted frames
+        self.total_frames = 0
+        for directory in extracted_frames_directories:
+            self.total_frames += len([f for f in directory.iterdir() if str(f)[-4:] == f'.{self.image_format}'])
+
+        with tqdm(total=self.total_frames, ascii=True, desc='Upscaling Progress') as progress_bar:
+
+            # tqdm update method adds the value to the progress
+            # bar instead of setting the value. Therefore, a delta
+            # needs to be calculated.
+            previous_cycle_frames = 0
+            while not self.progress_bar_exit_signal:
+
+                with contextlib.suppress(FileNotFoundError):
+                    self.total_frames_upscaled = len([f for f in self.upscaled_frames.iterdir() if str(f)[-4:] == f'.{self.image_format}'])
+                    delta = self.total_frames_upscaled - previous_cycle_frames
+                    previous_cycle_frames = self.total_frames_upscaled
+
+                    # if upscaling is finished
+                    if self.total_frames_upscaled >= self.total_frames:
+                        return
+
+                    # adds the delta into the progress bar
+                    progress_bar.update(delta)
+
+                time.sleep(1)
+
+    def _upscale_frames(self):
+        """ Upscale video frames with waifu2x-caffe
+
+        This function upscales all the frames extracted
+        by ffmpeg using the waifu2x-caffe binary.
+
+        Arguments:
+            w2 {Waifu2x Object} -- initialized waifu2x object
+        """
+
+        # progress bar thread exit signal
+        self.progress_bar_exit_signal = False
+
+        # create a container for exceptions in threads
+        # if this thread is not empty, then an exception has occured
+        self.upscaler_exceptions = []
+
+        # initialize waifu2x driver
+        drivers = AVAILABLE_DRIVERS
+        if self.waifu2x_driver not in drivers:
+            raise UnrecognizedDriverError(f'Unrecognized waifu2x driver: {self.waifu2x_driver}')
+
+        # it's easier to do multi-threading with waifu2x_converter
+        # the number of threads can be passed directly to waifu2x_converter
+        if self.waifu2x_driver == 'waifu2x_converter':
+            w2 = Waifu2xConverter(self.waifu2x_settings, self.model_dir)
+
+            progress_bar = threading.Thread(target=self._progress_bar, args=([self.extracted_frames],))
+            progress_bar.start()
+
+            w2.upscale(self.extracted_frames, self.upscaled_frames, self.scale_ratio, self.threads, self.image_format, self.upscaler_exceptions)
+            for image in [f for f in self.upscaled_frames.iterdir() if f.is_file()]:
+                renamed = re.sub(f'_\[.*-.*\]\[x(\d+(\.\d+)?)\]\.{self.image_format}', f'.{self.image_format}', str(image))
+                (self.upscaled_frames / image).rename(self.upscaled_frames / renamed)
+
+            self.progress_bar_exit_signal = True
+            progress_bar.join()
+            return
+
+        # drivers that are to be multi-threaded by video2x
+        else:
+            # create a container for all upscaler threads
+            upscaler_threads = []
+
+            # list all images in the extracted frames
+            frames = [(self.extracted_frames / f) for f in self.extracted_frames.iterdir() if f.is_file]
+
+            # if we have less images than threads,
+            # create only the threads necessary
+            if len(frames) < self.threads:
+                self.threads = len(frames)
+
+            # create a directory for each thread and append directory
+            # name into a list
+
+            thread_pool = []
+            thread_directories = []
+            for thread_id in range(self.threads):
+                thread_directory = self.extracted_frames / str(thread_id)
+                thread_directories.append(thread_directory)
+
+                # delete old directories and create new directories
+                if thread_directory.is_dir():
+                    shutil.rmtree(thread_directory)
+                thread_directory.mkdir(parents=True, exist_ok=True)
+
+                # append directory path into list
+                thread_pool.append((thread_directory, thread_id))
+
+            # evenly distribute images into each directory
+            # until there is none left in the directory
+            for image in frames:
+                # move image
+                image.rename(thread_pool[0][0] / image.name)
+                # rotate list
+                thread_pool = thread_pool[-1:] + thread_pool[:-1]
+
+            # create threads and start them
+            for thread_info in thread_pool:
+
+                # create a separate w2 instance for each thread
+                if self.waifu2x_driver == 'waifu2x_caffe':
+                    w2 = Waifu2xCaffe(copy.deepcopy(self.waifu2x_settings), self.method, self.model_dir, self.bit_depth)
+                    if self.scale_ratio:
+                        thread = threading.Thread(target=w2.upscale,
+                                                  args=(thread_info[0],
+                                                        self.upscaled_frames,
+                                                        self.scale_ratio,
+                                                        False,
+                                                        False,
+                                                        self.image_format,
+                                                        self.upscaler_exceptions))
+                    else:
+                        thread = threading.Thread(target=w2.upscale,
+                                                  args=(thread_info[0],
+                                                        self.upscaled_frames,
+                                                        False,
+                                                        self.scale_width,
+                                                        self.scale_height,
+                                                        self.image_format,
+                                                        self.upscaler_exceptions))
+
+                # if the driver being used is waifu2x_ncnn_vulkan
+                elif self.waifu2x_driver == 'waifu2x_ncnn_vulkan':
+                    w2 = Waifu2xNcnnVulkan(copy.deepcopy(self.waifu2x_settings))
+                    thread = threading.Thread(target=w2.upscale,
+                                              args=(thread_info[0],
+                                                    self.upscaled_frames,
+                                                    self.scale_ratio,
+                                                    self.upscaler_exceptions))
+
+                # if the driver being used is anime4k
+                elif self.waifu2x_driver == 'anime4k':
+                    w2 = Anime4k(copy.deepcopy(self.waifu2x_settings))
+                    thread = threading.Thread(target=w2.upscale,
+                                              args=(thread_info[0],
+                                                    self.upscaled_frames,
+                                                    self.scale_ratio,
+                                                    self.upscaler_exceptions))
+
+                # create thread
+                thread.name = thread_info[1]
+
+                # add threads into the pool
+                upscaler_threads.append(thread)
+
+            # start progress bar in a different thread
+            progress_bar = threading.Thread(target=self._progress_bar, args=(thread_directories,))
+            progress_bar.start()
+
+            # create the clearer and start it
+            Avalon.debug_info('Starting upscaled image cleaner')
+            image_cleaner = ImageCleaner(self.extracted_frames, self.upscaled_frames, len(upscaler_threads))
+            image_cleaner.start()
+
+            # start all threads
+            for thread in upscaler_threads:
+                thread.start()
+
+            # wait for threads to finish
+            for thread in upscaler_threads:
+                thread.join()
+
+            # upscaling done, kill the clearer
+            Avalon.debug_info('Killing upscaled image cleaner')
+            image_cleaner.stop()
+
+            self.progress_bar_exit_signal = True
+
+            if len(self.upscaler_exceptions) != 0:
+                raise(self.upscaler_exceptions[0])
+
+    def run(self):
+        """Main controller for Video2X
+
+        This function controls the flow of video conversion
+        and handles all necessary functions.
+        """
+
+        # parse arguments for waifu2x
+        # check argument sanity
+        self._check_arguments()
+
+        # convert paths to absolute paths
+        self.input_video = self.input_video.absolute()
+        self.output_video = self.output_video.absolute()
+
+        # initialize objects for ffmpeg and waifu2x-caffe
+        fm = Ffmpeg(self.ffmpeg_settings, self.image_format)
+
+        # extract frames from video
+        fm.extract_frames(self.input_video, self.extracted_frames)
+
+        Avalon.info('Reading video information')
+        video_info = fm.get_video_info(self.input_video)
+        # analyze original video with ffprobe and retrieve framerate
+        # width, height = info['streams'][0]['width'], info['streams'][0]['height']
+
+        # find index of video stream
+        video_stream_index = None
+        for stream in video_info['streams']:
+            if stream['codec_type'] == 'video':
+                video_stream_index = stream['index']
+                break
+
+        # exit if no video stream found
+        if video_stream_index is None:
+            Avalon.error('Aborting: No video stream found')
+            raise StreamNotFoundError('no video stream found')
+
+        # get average frame rate of video stream
+        framerate = float(Fraction(video_info['streams'][video_stream_index]['avg_frame_rate']))
+        fm.pixel_format = video_info['streams'][video_stream_index]['pix_fmt']
+
+        # get a dict of all pixel formats and corresponding bit depth
+        pixel_formats = fm.get_pixel_formats()
+
+        try:
+            self.bit_depth = pixel_formats[fm.pixel_format]
+        except KeyError:
+            Avalon.error(f'Unsupported pixel format: {fm.pixel_format}')
+            raise UnsupportedPixelError(f'unsupported pixel format {fm.pixel_format}')
+
+        Avalon.info(f'Framerate: {framerate}')
+
+        # width/height will be coded width/height x upscale factor
+        if self.scale_ratio:
+            original_width = video_info['streams'][video_stream_index]['width']
+            original_height = video_info['streams'][video_stream_index]['height']
+            self.scale_width = int(self.scale_ratio * original_width)
+            self.scale_height = int(self.scale_ratio * original_height)
+
+        # upscale images one by one using waifu2x
+        Avalon.info('Starting to upscale extracted images')
+        self._upscale_frames()
+        Avalon.info('Upscaling completed')
+
+        # frames to Video
+        Avalon.info('Converting extracted frames into video')
+
+        # use user defined output size
+        fm.convert_video(framerate, f'{self.scale_width}x{self.scale_height}', self.upscaled_frames)
+        Avalon.info('Conversion completed')
+
+        # migrate audio tracks and subtitles
+        Avalon.info('Migrating audio tracks and subtitles to upscaled video')
+        fm.migrate_audio_tracks_subtitles(self.input_video, self.output_video, self.upscaled_frames)

src/video2x.json

@@ -0,0 +1,102 @@
+{
+  "waifu2x_caffe": {
+    "waifu2x_caffe_path": "C:\\Users\\K4YT3X\\AppData\\Local\\video2x\\waifu2x-caffe\\waifu2x-caffe-cui.exe",
+    "input_extention_list": null,
+    "output_extention": null,
+    "mode": "noise_scale",
+    "scale_ratio": null,
+    "scale_width": null,
+    "scale_height": null,
+    "noise_level": 3,
+    "process": "gpu",
+    "crop_size": 128,
+    "output_quality": -1,
+    "output_depth": 8,
+    "batch_size": 1,
+    "gpu": 0,
+    "tta": 0,
+    "input_path": null,
+    "output_path": null,
+    "model_dir": null,
+    "crop_w": null,
+    "crop_h": null
+  },
+  "waifu2x_converter": {
+    "waifu2x_converter_path": "C:\\Users\\K4YT3X\\AppData\\Local\\video2x\\waifu2x-converter-cpp",
+    "output-format": null,
+    "png-compression": null,
+    "image-quality": null,
+    "block-size": null,
+    "disable-gpu": null,
+    "force-OpenCL": null,
+    "processor": null,
+    "jobs": null,
+    "model-dir": null,
+    "scale-ratio": null,
+    "noise-level": 3,
+    "mode": "noise-scale",
+    "silent": true,
+    "output": null,
+    "input": null
+  },
+  "waifu2x_ncnn_vulkan": {
+    "waifu2x_ncnn_vulkan_path": "C:\\Users\\K4YT3X\\AppData\\Local\\video2x\\waifu2x-ncnn-vulkan\\waifu2x-ncnn-vulkan.exe",
+    "v": null,
+    "i": null,
+    "o": null,
+    "n": 2,
+    "s": 2,
+    "t": 400,
+    "m": "models-cunet",
+    "g": 0,
+    "j": "1:2:2"
+  },
+  "anime4k": {
+    "anime4k_path": "C:\\Users\\K4YT3X\\AppData\\Local\\video2x\\anime4k\\Anime4K.jar",
+    "java_path": "C:\\Program Files\\Java\\jdk-12.0.2\\bin\\java.exe"
+  },
+  "ffmpeg": {
+    "ffmpeg_path": "C:\\Users\\K4YT3X\\AppData\\Local\\video2x\\ffmpeg-latest-win64-static\\bin",
+    "video_to_frames": {
+      "output_options": {
+        "-qscale:v": null,
+        "-pix_fmt": "rgba64be"
+      },
+      "-hwaccel": "auto",
+      "-y": true
+    },
+    "frames_to_video": {
+      "input_options": {
+        "-qscale:v": null,
+        "-qscale:a": null,
+        "-f": "image2"
+      },
+      "output_options": {
+        "-vcodec": "libx264",
+        "-crf": 17,
+        "-b:v": null,
+        "-pix_fmt": null
+      },
+      "-hwaccel": "auto",
+      "-y": true
+    },
+    "migrating_tracks": {
+      "output_options": {
+        "-map": [
+          "0:v:0?",
+          "1?",
+          "-1:v?"
+        ],
+        "-c": "copy",
+        "-pix_fmt": null
+      },
+      "-hwaccel": "auto",
+      "-y": true
+    }
+  },
+  "video2x": {
+    "video2x_cache_directory": null,
+    "image_format": "png",
+    "preserve_frames": false
+  }
+}

src/video2x.py

@@ -0,0 +1,445 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+r"""
+
+__      __  _       _                  ___   __   __
+\ \    / / (_)     | |                |__ \  \ \ / /
+ \ \  / /   _    __| |   ___    ___      ) |  \ V /
+  \ \/ /   | |  / _` |  / _ \  / _ \    / /    > <
+   \  /    | | | (_| | |  __/ | (_) |  / /_   / . \
+    \/     |_|  \__,_|  \___|  \___/  |____| /_/ \_\
+
+
+Name: Video2X Controller
+Author: K4YT3X
+Date Created: Feb 24, 2018
+Last Modified: August 29, 2019
+
+Dev: BrianPetkovsek
+Dev: SAT3LL
+
+Licensed under the GNU General Public License Version 3 (GNU GPL v3),
+    available at: https://www.gnu.org/licenses/gpl-3.0.txt
+
+(C) 2018-2019 K4YT3X
+
+Video2X is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+Video2X is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+Description: Video2X is an automation software based on waifu2x image
+enlarging engine. It extracts frames from a video, enlarge it by a
+number of times without losing any details or quality, keeping lines
+smooth and edges sharp.
+"""
+
+# local imports
+from exceptions import *
+from upscaler import AVAILABLE_DRIVERS
+from upscaler import Upscaler
+
+# built-in imports
+import argparse
+import contextlib
+import json
+import pathlib
+import re
+import shutil
+import sys
+import tempfile
+import time
+import traceback
+
+# third-party imports
+from avalon_framework import Avalon
+import GPUtil
+import psutil
+
+VERSION = '2.10.0'
+
+LEGAL_INFO = f'''Video2X Version: {VERSION}
+Author: K4YT3X
+License: GNU GPL v3
+Github Page: https://github.com/k4yt3x/video2x
+Contact: k4yt3x@k4yt3x.com'''
+
+LOGO = r'''
+    __      __  _       _                  ___   __   __
+    \ \    / / (_)     | |                |__ \  \ \ / /
+     \ \  / /   _    __| |   ___    ___      ) |  \ V /
+      \ \/ /   | |  / _` |  / _ \  / _ \    / /    > <
+       \  /    | | | (_| | |  __/ | (_) |  / /_   / . \
+        \/     |_|  \__,_|  \___|  \___/  |____| /_/ \_\
+'''
+
+# each thread might take up to 2.5 GB during initialization.
+# (system memory, not to be confused with GPU memory)
+SYS_MEM_PER_THREAD = 2.5
+GPU_MEM_PER_THREAD = 3.5
+
+
+def process_arguments():
+    """Processes CLI arguments
+
+    This function parses all arguments
+    This allows users to customize options
+    for the output video.
+    """
+    parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+
+    # video options
+    file_options = parser.add_argument_group('File Options')
+    file_options.add_argument('-i', '--input', type=pathlib.Path, help='source video file/directory', action='store')
+    file_options.add_argument('-o', '--output', type=pathlib.Path, help='output video file/directory', action='store')
+
+    # upscaler options
+    upscaler_options = parser.add_argument_group('Upscaler Options')
+    upscaler_options.add_argument('-m', '--method', help='upscaling method', action='store', default='gpu', choices=['cpu', 'gpu', 'cudnn'])
+    upscaler_options.add_argument('-d', '--driver', help='upscaling driver', action='store', default='waifu2x_caffe', choices=AVAILABLE_DRIVERS)
+    upscaler_options.add_argument('-y', '--model_dir', type=pathlib.Path, help='directory containing model JSON files', action='store')
+    upscaler_options.add_argument('-t', '--threads', help='number of threads to use for upscaling', action='store', type=int, default=1)
+    upscaler_options.add_argument('-c', '--config', type=pathlib.Path, help='video2x config file location', action='store', default=pathlib.Path(sys.argv[0]).parent.absolute() / 'video2x.json')
+    upscaler_options.add_argument('-b', '--batch', help='enable batch mode (select all default values to questions)', action='store_true')
+
+    # scaling options
+    scaling_options = parser.add_argument_group('Scaling Options')
+    scaling_options.add_argument('--width', help='output video width', action='store', type=int)
+    scaling_options.add_argument('--height', help='output video height', action='store', type=int)
+    scaling_options.add_argument('-r', '--ratio', help='scaling ratio', action='store', type=float)
+
+    # extra options
+    extra_options = parser.add_argument_group('Extra Options')
+    extra_options.add_argument('-v', '--version', help='display version, lawful information and exit', action='store_true')
+
+    # parse arguments
+    return parser.parse_args()
+
+
+def print_logo():
+    """print video2x logo"""
+    print(LOGO)
+    print(f'\n{"Video2X Video Enlarger".rjust(40, " ")}')
+    print(f'\n{Avalon.FM.BD}{f"Version {VERSION}".rjust(36, " ")}{Avalon.FM.RST}\n')
+
+
+def check_memory():
+    """ Check usable system memory
+    Warn the user if insufficient memory is available for
+    the number of threads that the user have chosen.
+    """
+
+    memory_status = []
+    # get system available memory
+    system_memory_available = psutil.virtual_memory().available / (1024 ** 3)
+    memory_status.append(('system', system_memory_available))
+
+    # check if Nvidia-smi is available
+    # GPUtil requires nvidia-smi.exe to interact with GPU
+    if args.method == 'gpu' or args.method == 'cudnn':
+        if not (shutil.which('nvidia-smi') or
+                pathlib.Path(r'C:\Program Files\NVIDIA Corporation\NVSMI\nvidia-smi.exe').is_file()):
+            # Nvidia System Management Interface not available
+            Avalon.warning('Nvidia-smi not available, skipping available memory check')
+            Avalon.warning('If you experience error \"cudaSuccess out of memory\", try reducing number of threads you\'re using')
+        else:
+            with contextlib.suppress(ValueError):
+                # "0" is GPU ID. Both waifu2x drivers use the first GPU available, therefore only 0 makes sense
+                gpu_memory_available = (GPUtil.getGPUs()[0].memoryTotal - GPUtil.getGPUs()[0].memoryUsed) / 1024
+                memory_status.append(('GPU', gpu_memory_available))
+
+    # go though each checkable memory type and check availability
+    for memory_type, memory_available in memory_status:
+
+        if memory_type == 'system':
+            mem_per_thread = SYS_MEM_PER_THREAD
+        else:
+            mem_per_thread = GPU_MEM_PER_THREAD
+
+        # if user doesn't even have enough memory to run even one thread
+        if memory_available < mem_per_thread:
+            Avalon.warning(f'You might have insufficient amount of {memory_type} memory available to run this program ({memory_available} GB)')
+            Avalon.warning('Proceed with caution')
+            if args.threads > 1:
+                if Avalon.ask('Reduce number of threads to avoid crashing?', default=True, batch=args.batch):
+                    args.threads = 1
+        # if memory available is less than needed, warn the user
+        elif memory_available < (mem_per_thread * args.threads):
+            Avalon.warning(f'Each waifu2x-caffe thread will require up to {SYS_MEM_PER_THREAD} GB of system memory')
+            Avalon.warning(f'You demanded {args.threads} threads to be created, but you only have {round(memory_available, 4)} GB {memory_type} memory available')
+            Avalon.warning(f'{mem_per_thread * args.threads} GB of {memory_type} memory is recommended for {args.threads} threads')
+            Avalon.warning(f'With your current amount of {memory_type} memory available, {int(memory_available // mem_per_thread)} threads is recommended')
+
+            # ask the user if he / she wants to change to the recommended
+            # number of threads
+            if Avalon.ask('Change to the recommended value?', default=True, batch=args.batch):
+                args.threads = int(memory_available // mem_per_thread)
+            else:
+                Avalon.warning('Proceed with caution')
+
+
+def read_config(config_file):
+    """ Reads configuration file
+
+    Returns a dictionary read by JSON.
+    """
+    with open(config_file, 'r') as raw_config:
+        config = json.load(raw_config)
+        return config
+
+
+def absolutify_paths(config):
+    """ Check to see if paths to binaries are absolute
+
+    This function checks if paths to binary files are absolute.
+    If not, then absolutify the path.
+
+    Arguments:
+        config {dict} -- configuration file dictionary
+
+    Returns:
+        dict -- configuration file dictionary
+    """
+    current_directory = pathlib.Path(sys.argv[0]).parent.absolute()
+
+    # check waifu2x-caffe path
+    if not re.match('^[a-z]:', config['waifu2x_caffe']['waifu2x_caffe_path'], re.IGNORECASE):
+        config['waifu2x_caffe']['waifu2x_caffe_path'] = current_directory / config['waifu2x_caffe']['waifu2x_caffe_path']
+
+    # check waifu2x-converter-cpp path
+    if not re.match('^[a-z]:', config['waifu2x_converter']['waifu2x_converter_path'], re.IGNORECASE):
+        config['waifu2x_converter']['waifu2x_converter_path'] = current_directory / config['waifu2x_converter']['waifu2x_converter_path']
+
+    # check waifu2x_ncnn_vulkan path
+    if not re.match('^[a-z]:', config['waifu2x_ncnn_vulkan']['waifu2x_ncnn_vulkan_path'], re.IGNORECASE):
+        config['waifu2x_ncnn_vulkan']['waifu2x_ncnn_vulkan_path'] = current_directory / config['waifu2x_ncnn_vulkan']['waifu2x_ncnn_vulkan_path']
+
+    # check anime4k path
+    if not re.match('^[a-z]:', config['anime4k']['anime4k_path'], re.IGNORECASE):
+        config['anime4k']['anime4k_path'] = current_directory / config['anime4k']['anime4k_path']
+
+    # check ffmpeg path
+    if not re.match('^[a-z]:', config['ffmpeg']['ffmpeg_path'], re.IGNORECASE):
+        config['ffmpeg']['ffmpeg_path'] = current_directory / config['ffmpeg']['ffmpeg_path']
+
+    # check video2x cache path
+    if config['video2x']['video2x_cache_directory']:
+        if not re.match('^[a-z]:', config['video2x']['video2x_cache_directory'], re.IGNORECASE):
+            config['video2x']['video2x_cache_directory'] = current_directory / config['video2x']['video2x_cache_directory']
+
+    return config
+
+
+# /////////////////// Execution /////////////////// #
+
+# this is not a library
+if __name__ != '__main__':
+    Avalon.error('This file cannot be imported')
+    raise ImportError(f'{__file__} cannot be imported')
+
+# print video2x logo
+print_logo()
+
+# process CLI arguments
+args = process_arguments()
+
+# display version and lawful informaition
+if args.version:
+    print(LEGAL_INFO)
+    exit(0)
+
+# arguments sanity check
+if not args.input:
+    Avalon.error('You must specify input video file/directory path')
+    raise ArgumentError('input video path not specified')
+if not args.output:
+    Avalon.error('You must specify output video file/directory path')
+    raise ArgumentError('output video path not specified')
+if (args.driver in ['waifu2x_converter', 'waifu2x_ncnn_vulkan', 'anime4k']) and args.width and args.height:
+    Avalon.error('Selected driver accepts only scaling ratio')
+    raise ArgumentError('selected driver supports only scaling ratio')
+if args.driver == 'waifu2x_ncnn_vulkan' and (args.ratio > 2 or not args.ratio.is_integer()):
+    Avalon.error('Scaling ratio must be 1 or 2 for waifu2x_ncnn_vulkan')
+    raise ArgumentError('scaling ratio must be 1 or 2 for waifu2x_ncnn_vulkan')
+if (args.width or args.height) and args.ratio:
+    Avalon.error('You can only specify either scaling ratio or output width and height')
+    raise ArgumentError('both scaling ration and width/height specified')
+if (args.width and not args.height) or (not args.width and args.height):
+    Avalon.error('You must specify both width and height')
+    raise ArgumentError('only one of width or height is specified')
+
+# check available memory if driver is waifu2x-based
+if args.driver in ['waifu2x_caffe', 'waifu2x_converter', 'waifu2x_ncnn_vulkan']:
+    check_memory()
+
+# anime4k runs significantly faster with more threads
+if args.driver == 'anime4k' and args.threads <= 1:
+    Avalon.warning('Anime4K runs significantly faster with more threads')
+    if Avalon.ask('Use more threads of Anime4K?', True):
+        while True:
+            try:
+                threads = Avalon.gets('Amount of threads to use [5]: ')
+                args.threads = int(threads)
+                break
+            except ValueError:
+                if threads == '':
+                    args.threads = 5
+                    break
+                else:
+                    Avalon.error(f'{threads} is not a valid integer')
+
+# read configurations from JSON
+config = read_config(args.config)
+config = absolutify_paths(config)
+
+# load waifu2x configuration
+if args.driver == 'waifu2x_caffe':
+    waifu2x_settings = config['waifu2x_caffe']
+    if not pathlib.Path(waifu2x_settings['waifu2x_caffe_path']).is_file():
+        Avalon.error('Specified waifu2x-caffe directory doesn\'t exist')
+        Avalon.error('Please check the configuration file settings')
+        raise FileNotFoundError(waifu2x_settings['waifu2x_caffe_path'])
+elif args.driver == 'waifu2x_converter':
+    waifu2x_settings = config['waifu2x_converter']
+    if not pathlib.Path(waifu2x_settings['waifu2x_converter_path']).is_dir():
+        Avalon.error('Specified waifu2x-converter-cpp directory doesn\'t exist')
+        Avalon.error('Please check the configuration file settings')
+        raise FileNotFoundError(waifu2x_settings['waifu2x_converter_path'])
+elif args.driver == 'waifu2x_ncnn_vulkan':
+    waifu2x_settings = config['waifu2x_ncnn_vulkan']
+    if not pathlib.Path(waifu2x_settings['waifu2x_ncnn_vulkan_path']).is_file():
+        Avalon.error('Specified waifu2x_ncnn_vulkan directory doesn\'t exist')
+        Avalon.error('Please check the configuration file settings')
+        raise FileNotFoundError(waifu2x_settings['waifu2x_ncnn_vulkan_path'])
+elif args.driver == 'anime4k':
+    waifu2x_settings = config['anime4k']
+    if not pathlib.Path(waifu2x_settings['anime4k_path']).is_file():
+        Avalon.error('Specified anime4k directory doesn\'t exist')
+        Avalon.error('Please check the configuration file settings')
+        raise FileNotFoundError(waifu2x_settings['anime4k_path'])
+
+# read FFmpeg configuration
+ffmpeg_settings = config['ffmpeg']
+
+# load video2x settings
+image_format = config['video2x']['image_format'].lower()
+preserve_frames = config['video2x']['preserve_frames']
+
+# load cache directory
+if isinstance(config['video2x']['video2x_cache_directory'], str):
+    video2x_cache_directory = pathlib.Path(config['video2x']['video2x_cache_directory'])
+else:
+    video2x_cache_directory = pathlib.Path(tempfile.gettempdir()) / 'video2x'
+
+if video2x_cache_directory.exists() and not video2x_cache_directory.is_dir():
+    Avalon.error('Specified cache directory is a file/link')
+    raise FileExistsError('Specified cache directory is a file/link')
+
+elif not video2x_cache_directory.exists():
+    # if destination file is a file or a symbolic link
+    Avalon.warning(f'Specified cache directory {video2x_cache_directory} does not exist')
+
+    # try creating the cache directory
+    if Avalon.ask('Create directory?', default=True, batch=args.batch):
+        try:
+            video2x_cache_directory.mkdir(parents=True, exist_ok=True)
+            Avalon.info(f'{video2x_cache_directory} created')
+
+        # there can be a number of exceptions here
+        # PermissionError, FileExistsError, etc.
+        # therefore, we put a catch-them-all here
+        except Exception as e:
+            Avalon.error(f'Unable to create {video2x_cache_directory}')
+            Avalon.error('Aborting...')
+            raise e
+    else:
+        raise FileNotFoundError('Could not create cache directory')
+
+
+# start execution
+try:
+    # start timer
+    begin_time = time.time()
+
+    # if input specified is a single file
+    if args.input.is_file():
+
+        # upscale single video file
+        Avalon.info(f'Upscaling single video file: {args.input}')
+
+        # check for input output format mismatch
+        if args.output.is_dir():
+            Avalon.error('Input and output path type mismatch')
+            Avalon.error('Input is single file but output is directory')
+            raise Exception('input output path type mismatch')
+        if not re.search(r'.*\..*$', str(args.output)):
+            Avalon.error('No suffix found in output file path')
+            Avalon.error('Suffix must be specified for FFmpeg')
+            raise Exception('No suffix specified')
+
+        upscaler = Upscaler(input_video=args.input, output_video=args.output, method=args.method, waifu2x_settings=waifu2x_settings, ffmpeg_settings=ffmpeg_settings)
+
+        # set optional options
+        upscaler.waifu2x_driver = args.driver
+        upscaler.scale_width = args.width
+        upscaler.scale_height = args.height
+        upscaler.scale_ratio = args.ratio
+        upscaler.model_dir = args.model_dir
+        upscaler.threads = args.threads
+        upscaler.video2x_cache_directory = video2x_cache_directory
+        upscaler.image_format = image_format
+        upscaler.preserve_frames = preserve_frames
+
+        # run upscaler
+        upscaler.create_temp_directories()
+        upscaler.run()
+        upscaler.cleanup_temp_directories()
+
+    # if input specified is a directory
+    elif args.input.is_dir():
+        # upscale videos in a directory
+        Avalon.info(f'Upscaling videos in directory: {args.input}')
+
+        # make output directory if it doesn't exist
+        args.output.mkdir(parents=True, exist_ok=True)
+
+        for input_video in [f for f in args.input.iterdir() if f.is_file()]:
+            output_video = args.output / input_video.name
+            upscaler = Upscaler(input_video=input_video, output_video=output_video, method=args.method, waifu2x_settings=waifu2x_settings, ffmpeg_settings=ffmpeg_settings)
+
+            # set optional options
+            upscaler.waifu2x_driver = args.driver
+            upscaler.scale_width = args.width
+            upscaler.scale_height = args.height
+            upscaler.scale_ratio = args.ratio
+            upscaler.model_dir = args.model_dir
+            upscaler.threads = args.threads
+            upscaler.video2x_cache_directory = video2x_cache_directory
+            upscaler.image_format = image_format
+            upscaler.preserve_frames = preserve_frames
+
+            # run upscaler
+            upscaler.create_temp_directories()
+            upscaler.run()
+            upscaler.cleanup_temp_directories()
+    else:
+        Avalon.error('Input path is neither a file nor a directory')
+        raise FileNotFoundError(f'{args.input} is neither file nor directory')
+
+    Avalon.info(f'Program completed, taking {round((time.time() - begin_time), 5)} seconds')
+except Exception:
+    Avalon.error('An exception has occurred')
+    traceback.print_exc()
+finally:
+    # remove Video2X cache directory
+    with contextlib.suppress(FileNotFoundError):
+        if not preserve_frames:
+            shutil.rmtree(video2x_cache_directory)

src/video2x_gui.py

@@ -0,0 +1,416 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Name: Video2x GUI
+Author: K4YT3X
+Date Created: July 27, 2019
+Last Modified: August 17, 2019
+
+Description: GUI for Video2X
+"""
+
+# local imports
+from exceptions import *
+from upscaler import Upscaler
+
+# built-in imports
+from tkinter import *
+from tkinter import messagebox
+from tkinter import ttk
+from tkinter.filedialog import *
+import json
+import pathlib
+import tempfile
+import threading
+import time
+
+VERSION = '1.1.1'
+
+LEGAL_INFO = f'''Video2X GUI Version: {VERSION}
+Author: K4YT3X
+License: GNU GPL v3
+Github Page: https://github.com/k4yt3x/video2x
+Contact: k4yt3x@k4yt3x.com'''
+
+# global static variables
+AVAILABLE_METHODS = {
+    'GPU': 'gpu',
+    'CUDNN': 'cudnn',
+    'CPU': 'cpu'
+}
+
+AVAILABLE_DRIVERS = {
+    'Waifu2X Caffe': 'waifu2x_caffe',
+    'Waifu2X Converter CPP': 'waifu2x_converter',
+    'Waifu2x NCNN Vulkan': 'waifu2x_ncnn_vulkan',
+    'Anime4K': 'anime4k'
+}
+
+IMAGE_FORMATS = {'PNG', 'JPG'}
+
+
+class Video2xGui():
+
+    def __init__(self):
+
+        self.running = False
+
+        # create main window
+        self.main_window = Tk()
+        self.main_window.title(f'Video2X GUI {VERSION}')
+        self.main_frame = Frame()
+        self.main_frame.pack(fill=BOTH, expand=True)
+
+        # add menu bar
+        self.menu_bar = Menu(self.main_frame)
+
+        # file menu
+        self.file_menu = Menu(self.menu_bar, tearoff=0)
+        self.file_menu.add_command(label='Exit', command=self.main_frame.quit)
+        self.menu_bar.add_cascade(label='File', menu=self.file_menu)
+
+        # help menu
+        self.help_menu = Menu(self.menu_bar, tearoff=0)
+        self.help_menu.add_command(label='About', command=self._display_help)
+        self.menu_bar.add_cascade(label='Help', menu=self.help_menu)
+
+        self.main_window.config(menu=self.menu_bar)
+
+        # file frame
+        self.file_frame = Frame(self.main_frame)
+        self.file_frame.pack(fill=X, padx=5, pady=5, expand=True)
+
+        # input file
+        self.input_file = StringVar()
+        label_text = StringVar()
+        label_text.set('Input File')
+        Label(self.file_frame, textvariable=label_text, relief=RIDGE, width=10).grid(row=0, column=0, padx=5, pady=5, sticky=W)
+        Entry(self.file_frame, textvariable=self.input_file, width=60).grid(row=0, column=1, padx=5, pady=5, sticky=W)
+        Button(self.file_frame, text='Select', command=self._select_input).grid(row=0, column=2, padx=5, pady=5, sticky=W)
+
+        # output file
+        self.output_file = StringVar()
+        label_text = StringVar()
+        label_text.set('Output File')
+        Label(self.file_frame, textvariable=label_text, relief=RIDGE, width=10).grid(row=1, column=0, padx=5, pady=5, sticky=W)
+        Entry(self.file_frame, textvariable=self.output_file, width=60).grid(row=1, column=1, padx=5, pady=5, sticky=W)
+        Button(self.file_frame, text='Select', command=self._select_output).grid(row=1, column=2, padx=5, pady=5, sticky=W)
+
+        # options
+        self.options_frame = Frame()
+        # self.options_left.pack(fill=X, padx=5, pady=5, expand=True)
+        self.options_frame.pack(fill=X, padx=5, pady=5, expand=True)
+
+        self.options_left = Frame(self.options_frame)
+        # self.options_left.pack(fill=X, padx=5, pady=5, expand=True)
+        self.options_left.grid(row=0, column=0, padx=5, pady=5, sticky=N)
+
+        # width
+        self.width = IntVar()
+        # self.width.set(1920)
+        Label(self.options_left, text='Width', relief=RIDGE, width=15).grid(row=0, column=0, padx=2, pady=3)
+        width_field = Entry(self.options_left, textvariable=self.width)
+        width_field.grid(row=0, column=1, padx=2, pady=3, sticky=W)
+
+        # height
+        self.height = IntVar()
+        # self.height.set(1080)
+        Label(self.options_left, text='Height', relief=RIDGE, width=15).grid(row=1, column=0, padx=2, pady=3)
+        height_field = Entry(self.options_left, textvariable=self.height)
+        height_field.grid(row=1, column=1, padx=2, pady=3, sticky=W)
+
+        # scale ratio
+        self.scale_ratio = DoubleVar()
+        # self.scale_ratio.set(2.0)
+        Label(self.options_left, text='Scale Ratio', relief=RIDGE, width=15).grid(row=2, column=0, padx=2, pady=3)
+        scale_ratio_field = Entry(self.options_left, textvariable=self.scale_ratio)
+        scale_ratio_field.grid(row=2, column=1, padx=2, pady=3, sticky=W)
+
+        # image format
+        self.image_format = StringVar(self.options_left)
+        self.image_format.set('PNG')
+        Label(self.options_left, text='Image Format', relief=RIDGE, width=15).grid(row=3, column=0, padx=2, pady=3)
+        image_format_menu = OptionMenu(self.options_left, self.image_format, *IMAGE_FORMATS)
+        image_format_menu.grid(row=3, column=1, padx=2, pady=3, sticky=W)
+
+        # options
+        self.options_right = Frame(self.options_frame)
+        # self.options_left.pack(fill=X, padx=5, pady=5, expand=True)
+        self.options_right.grid(row=0, column=1, padx=5, pady=5, sticky=N)
+
+        # threads
+        self.threads = IntVar()
+        self.threads.set(1)
+        Label(self.options_right, text='Threads', relief=RIDGE, width=15).grid(row=0, column=0, padx=2, pady=3)
+        threads_field = Entry(self.options_right, textvariable=self.threads)
+        threads_field.grid(row=0, column=1, padx=2, pady=3, sticky=W)
+
+        # method
+        self.method = StringVar(self.options_left)
+        self.method.set('GPU')
+        Label(self.options_right, text='Method', relief=RIDGE, width=15).grid(row=1, column=0, padx=2, pady=3)
+        method_menu = OptionMenu(self.options_right, self.method, *AVAILABLE_METHODS)
+        method_menu.grid(row=1, column=1, padx=2, pady=3, sticky=W)
+
+        # driver
+        self.driver = StringVar(self.options_left)
+        self.driver.set('Waifu2X Caffe')
+        Label(self.options_right, text='Driver', relief=RIDGE, width=15).grid(row=2, column=0, padx=2, pady=3)
+        driver_menu = OptionMenu(self.options_right, self.driver, *AVAILABLE_DRIVERS)
+        driver_menu.grid(row=2, column=1, padx=2, pady=3, sticky=W)
+
+        # preserve frames
+        self.preserve_frames = BooleanVar(self.options_left)
+        self.preserve_frames.set(True)
+        Label(self.options_right, text='Preserve Frames', relief=RIDGE, width=15).grid(row=3, column=0, padx=2, pady=3)
+        preserve_frames_menu = OptionMenu(self.options_right, self.preserve_frames, *{True, False})
+        preserve_frames_menu.grid(row=3, column=1, padx=2, pady=3, sticky=W)
+
+        # progress bar
+        self.progress_bar_frame = Frame()
+        self.progress_bar_frame.pack(fill=X, padx=5, pady=5, expand=True)
+
+        self.progress_bar = ttk.Progressbar(self.progress_bar_frame, orient='horizontal', length=100, mode='determinate')
+        self.progress_bar.pack(fill=X)
+
+        # start button frame
+        self.start_frame = Frame()
+        self.start_frame.pack(fill=X, padx=5, pady=5, expand=True)
+
+        # start button
+        self.start_button_text = StringVar()
+        self.start_button_text.set('Start')
+        Button(self.start_frame, textvariable=self.start_button_text, command=self._launch_upscaling, width=20).pack(side=RIGHT)
+
+        self.main_frame.mainloop()
+    
+    def _display_help(self):
+        messagebox.showinfo('About', LEGAL_INFO)
+    
+    def _launch_upscaling(self):
+
+        # prevent launching multiple instances
+        if self.running:
+            messagebox.showerror('Error', 'Video2X is already running')
+            return
+
+        # arguments sanity check
+        if self.input_file.get() == '':
+            messagebox.showerror('Error', 'You must specify input video file/directory path')
+            return
+        if self.output_file.get() == '':
+            messagebox.showerror('Error', 'You must specify output video file/directory path')
+            return
+        if (self.driver.get() in ['Waifu2X Converter CPP', 'Waifu2x NCNN Vulkan', 'Anime4K']) and self.width.get() and self.height.get():
+            messagebox.showerror('Error', f'Selected driver \"{self.driver.get()}\" accepts only scaling ratio')
+            return
+        if self.driver.get() == 'waifu2x_ncnn_vulkan' and (self.scale_ratio.get() > 2 or not self.scale_ratio.get().is_integer()):
+            messagebox.showerror('Error', 'Scaling ratio must be 1 or 2 for waifu2x_ncnn_vulkan')
+            return
+        if (self.width.get() or self.height.get()) and self.scale_ratio.get():
+            messagebox.showerror('Error', 'You can only specify either scaling ratio or output width and height')
+            return
+        if (self.width.get() and not self.height.get()) or (not self.width.get() and self.height.get()):
+            messagebox.showerror('Error', 'You must specify both width and height')
+            return
+        if (not self.width.get() or not self.height.get()) and not self.scale_ratio.get():
+            messagebox.showerror('Error', 'You must specify either output dimensions or scaling ratio')
+            return
+
+        upscale = threading.Thread(target=self._upscale)
+        upscale.start()
+        self.running = True
+        self.start_button_text.set('Running')
+
+    def _upscale(self):
+
+        # start timer
+        begin_time = time.time()
+
+        # read configuration file
+        config = read_config('video2x.json')
+        config = absolutify_paths(config)
+
+        input_file = pathlib.Path(self.input_file.get())
+        output_file = pathlib.Path(self.output_file.get())
+        driver = AVAILABLE_DRIVERS[self.driver.get()]
+
+        if driver == 'waifu2x_caffe':
+            waifu2x_settings = config['waifu2x_caffe']
+            if not pathlib.Path(waifu2x_settings['waifu2x_caffe_path']).is_file():
+                messagebox.showerror('Error', 'Specified waifu2x-caffe directory doesn\'t exist\nPlease check the configuration file settings')
+                raise FileNotFoundError(waifu2x_settings['waifu2x_caffe_path'])
+        elif driver == 'waifu2x_converter':
+            waifu2x_settings = config['waifu2x_converter']
+            if not pathlib.Path(waifu2x_settings['waifu2x_converter_path']).is_dir():
+                messagebox.showerror('Error', 'Specified waifu2x-converter-cpp directory doesn\'t exist\nPlease check the configuration file settings')
+                raise FileNotFoundError(waifu2x_settings['waifu2x_converter_path'])
+        elif driver == 'waifu2x_ncnn_vulkan':
+            waifu2x_settings = config['waifu2x_ncnn_vulkan']
+            if not pathlib.Path(waifu2x_settings['waifu2x_ncnn_vulkan_path']).is_file():
+                messagebox.showerror('Error', 'Specified waifu2x_ncnn_vulkan directory doesn\'t exist\nPlease check the configuration file settings')
+                raise FileNotFoundError(waifu2x_settings['waifu2x_ncnn_vulkan_path'])
+        elif driver == 'anime4k':
+            waifu2x_settings = config['anime4k']
+            if not pathlib.Path(waifu2x_settings['anime4k_path']).is_file():
+                messagebox.showerror('Error', 'Specified Anime4K directory doesn\'t exist\nPlease check the configuration file settings')
+                raise FileNotFoundError(waifu2x_settings['anime4k_path'])
+
+        # read FFmpeg configuration
+        ffmpeg_settings = config['ffmpeg']
+
+        # load video2x settings
+        image_format = config['video2x']['image_format'].lower()
+        preserve_frames = config['video2x']['preserve_frames']
+
+        # load cache directory
+        if isinstance(config['video2x']['video2x_cache_directory'], str):
+            video2x_cache_directory = pathlib.Path(config['video2x']['video2x_cache_directory'])
+        else:
+            video2x_cache_directory = pathlib.Path(tempfile.gettempdir()) / 'video2x'
+
+        if video2x_cache_directory.exists() and not video2x_cache_directory.is_dir():
+            messagebox.showerror('Error', 'Specified cache directory is a file/link')
+            raise FileExistsError('Specified cache directory is a file/link')
+
+        elif not video2x_cache_directory.exists():
+            # try creating the cache directory
+            if messagebox.askyesno('Question', f'Specified cache directory {video2x_cache_directory} does not exist\nCreate directory?'):
+                try:
+                    video2x_cache_directory.mkdir(parents=True, exist_ok=True)
+
+                # there can be a number of exceptions here
+                # PermissionError, FileExistsError, etc.
+                # therefore, we put a catch-them-all here
+                except Exception as e:
+                    messagebox.showerror('Error', f'Unable to create {video2x_cache_directory}\nAborting...')
+                    raise e
+            else:
+                raise FileNotFoundError('Could not create cache directory')
+
+        # load more settings from gui
+        width = self.width.get()
+        height = self.height.get()
+        scale_ratio = self.scale_ratio.get()
+        image_format = self.image_format.get()
+        threads = self.threads.get()
+        method = AVAILABLE_METHODS[self.method.get()]
+        preserve_frames = self.preserve_frames.get()
+
+        self.upscaler = Upscaler(input_video=input_file, output_video=output_file, method=method, waifu2x_settings=waifu2x_settings, ffmpeg_settings=ffmpeg_settings)
+
+        # set optional options
+        self.upscaler.waifu2x_driver = driver
+        self.upscaler.scale_width = width
+        self.upscaler.scale_height = height
+        self.upscaler.scale_ratio = scale_ratio
+        self.upscaler.model_dir = None
+        self.upscaler.threads = threads
+        self.upscaler.video2x_cache_directory = video2x_cache_directory
+        self.upscaler.image_format = image_format
+        self.upscaler.preserve_frames = preserve_frames
+
+        # run upscaler
+        self.upscaler.create_temp_directories()
+
+        # start progress bar
+        progress_bar = threading.Thread(target=self._progress_bar)
+        progress_bar.start()
+
+        # start upscaling
+        self.upscaler.run()
+        self.upscaler.cleanup_temp_directories()
+
+        # show message when upscaling completes
+        messagebox.showinfo('Info', f'Upscaling Completed\nTime Taken: {round((time.time() - begin_time), 5)} seconds')
+        self.progress_bar['value'] = 100
+        self.running = False
+        self.start_button_text.set('Start')
+
+    def _progress_bar(self):
+        """ This method prints a progress bar
+
+        This method prints a progress bar by keeping track
+        of the amount of frames in the input directory
+        and the output directory. This is originally
+        suggested by @ArmandBernard.
+        """
+        # initialize variables early
+        self.upscaler.progress_bar_exit_signal = False
+        self.upscaler.total_frames_upscaled = 0
+        self.upscaler.total_frames = 1
+
+        # initialize progress bar values
+        self.progress_bar['value'] = 0
+
+        while not self.upscaler.progress_bar_exit_signal:
+            self.progress_bar['value'] = int(100 * self.upscaler.total_frames_upscaled / self.upscaler.total_frames)
+            time.sleep(1)
+
+    def _select_input(self):
+        self.input_file.set(askopenfilename(title='Select Input File'))
+
+        # try to set an output file name automatically
+        output_file = pathlib.Path(f'{self.input_file.get()}_output.mp4')
+
+        output_file_id = 0
+        while output_file.is_file() and output_file_id <= 10:
+            output_file = pathlib.Path(f'{self.input_file.get()}_output_{output_file_id}.mp4')
+            output_file_id += 1
+        
+        if not output_file.exists():
+            self.output_file.set(str(output_file))
+
+    def _select_output(self):
+        self.output_file.set(asksaveasfilename(title='Select Output File'))
+
+
+def read_config(config_file):
+    """ Reads configuration file
+
+    Returns a dictionary read by JSON.
+    """
+    with open(config_file, 'r') as raw_config:
+        config = json.load(raw_config)
+        return config
+
+
+def absolutify_paths(config):
+    """ Check to see if paths to binaries are absolute
+
+    This function checks if paths to binary files are absolute.
+    If not, then absolutify the path.
+
+    Arguments:
+        config {dict} -- configuration file dictionary
+
+    Returns:
+        dict -- configuration file dictionary
+    """
+    current_directory = pathlib.Path(sys.argv[0]).parent.absolute()
+
+    # check waifu2x-caffe path
+    if not re.match('^[a-z]:', config['waifu2x_caffe']['waifu2x_caffe_path'], re.IGNORECASE):
+        config['waifu2x_caffe']['waifu2x_caffe_path'] = current_directory / config['waifu2x_caffe']['waifu2x_caffe_path']
+
+    # check waifu2x-converter-cpp path
+    if not re.match('^[a-z]:', config['waifu2x_converter']['waifu2x_converter_path'], re.IGNORECASE):
+        config['waifu2x_converter']['waifu2x_converter_path'] = current_directory / config['waifu2x_converter']['waifu2x_converter_path']
+
+    # check waifu2x_ncnn_vulkan path
+    if not re.match('^[a-z]:', config['waifu2x_ncnn_vulkan']['waifu2x_ncnn_vulkan_path'], re.IGNORECASE):
+        config['waifu2x_ncnn_vulkan']['waifu2x_ncnn_vulkan_path'] = current_directory / config['waifu2x_ncnn_vulkan']['waifu2x_ncnn_vulkan_path']
+
+    # check ffmpeg path
+    if not re.match('^[a-z]:', config['ffmpeg']['ffmpeg_path'], re.IGNORECASE):
+        config['ffmpeg']['ffmpeg_path'] = current_directory / config['ffmpeg']['ffmpeg_path']
+
+    # check video2x cache path
+    if config['video2x']['video2x_cache_directory']:
+        if not re.match('^[a-z]:', config['video2x']['video2x_cache_directory'], re.IGNORECASE):
+            config['video2x']['video2x_cache_directory'] = current_directory / config['video2x']['video2x_cache_directory']
+
+    return config
+
+
+video2x_gui = Video2xGui()

src/video2x_setup.py

@@ -0,0 +1,351 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Name: Video2X Setup Script
+Author: K4YT3X
+Author: BrianPetkovsek
+Date Created: November 28, 2018
+Last Modified: August 20, 2019
+
+Dev: SAT3LL
+
+Licensed under the GNU General Public License Version 3 (GNU GPL v3),
+    available at: https://www.gnu.org/licenses/gpl-3.0.txt
+
+(C) 2018-2019 K4YT3X
+
+Description: This script helps installing all dependencies of video2x
+and generates a configuration for it.
+
+Installation Details:
+- ffmpeg: %LOCALAPPDATA%\\video2x\\ffmpeg
+- waifu2x-caffe: %LOCALAPPDATA%\\video2x\\waifu2x-caffe
+- waifu2x-cpp-converter: %LOCALAPPDATA%\\video2x\\waifu2x-converter-cpp
+- waifu2x_ncnn_vulkan: %LOCALAPPDATA%\\video2x\\waifu2x-ncnn-vulkan
+- anime4k: %LOCALAPPDATA%\\video2x\\anime4k
+"""
+
+# built-in imports
+import argparse
+import contextlib
+import json
+import os
+import pathlib
+import re
+import shutil
+import subprocess
+import sys
+import tempfile
+import traceback
+import urllib
+import zipfile
+
+# Requests doesn't come with windows, therefore
+# it will be installed as a dependency and imported
+# later in the script.
+# import requests
+
+VERSION = '1.5.0'
+
+# global static variables
+LOCALAPPDATA = pathlib.Path(os.getenv('localappdata'))
+DRIVER_OPTIONS = ['all', 'waifu2x_caffe', 'waifu2x_converter', 'waifu2x_ncnn_vulkan', 'anime4k']
+
+
+def process_arguments():
+    """Processes CLI arguments
+    """
+    parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+
+    # video options
+    general_options = parser.add_argument_group('General Options')
+    general_options.add_argument('-d', '--driver', help='driver to download and configure', action='store', choices=DRIVER_OPTIONS, default='all')
+
+    # parse arguments
+    return parser.parse_args()
+
+
+class Video2xSetup:
+    """ Install dependencies for video2x video enlarger
+
+    This library is meant to be executed as a stand-alone
+    script. All files will be installed under %LOCALAPPDATA%\\video2x.
+    """
+
+    def __init__(self, driver, download_python_modules):
+        self.driver = driver
+        self.download_python_modules = download_python_modules
+        self.trash = []
+
+    def run(self):
+        if self.download_python_modules:
+            print('\nInstalling Python libraries')
+            self._install_python_requirements()
+
+        print('\nInstalling FFmpeg')
+        self._install_ffmpeg()
+
+        if self.driver == 'all':
+            self._install_waifu2x_caffe()
+            self._install_waifu2x_converter_cpp()
+            self._install_waifu2x_ncnn_vulkan()
+            self._install_anime4k()
+        elif self.driver == 'waifu2x_caffe':
+            self._install_waifu2x_caffe()
+        elif self.driver == 'waifu2x_converter':
+            self._install_waifu2x_converter_cpp()
+        elif self.driver == 'waifu2x_ncnn_vulkan':
+            self._install_waifu2x_ncnn_vulkan()
+        elif self.driver == 'anime4k':
+            self._install_anime4k()
+
+        print('\nGenerating Video2X configuration file')
+        self._generate_config()
+
+        print('\nCleaning up temporary files')
+        self._cleanup()
+
+    def _install_python_requirements(self):
+        """ Read requirements.txt and return its content
+        """
+        pip_install('requirements.txt')
+
+    def _cleanup(self):
+        """ Cleanup all the temp files downloaded
+        """
+        for file in self.trash:
+            try:
+                if file.is_dir():
+                    print(f'Deleting directory: {file}')
+                    shutil.rmtree(file)
+                else:
+                    print(f'Deleting file: {file}')
+                    file.unlink()
+            except Exception:
+                print(f'Error deleting: {file}')
+                traceback.print_exc()
+
+    def _install_ffmpeg(self):
+        """ Install FFMPEG
+        """
+        latest_release = 'https://ffmpeg.zeranoe.com/builds/win64/static/ffmpeg-latest-win64-static.zip'
+
+        ffmpeg_zip = download(latest_release, tempfile.gettempdir())
+        self.trash.append(ffmpeg_zip)
+
+        with zipfile.ZipFile(ffmpeg_zip) as zipf:
+            zipf.extractall(LOCALAPPDATA / 'video2x')
+
+    def _install_waifu2x_caffe(self):
+        """ Install waifu2x_caffe
+        """
+        print('\nInstalling waifu2x-caffe')
+        import requests
+
+        # Get latest release of waifu2x-caffe via GitHub API
+        latest_release = requests.get('https://api.github.com/repos/lltcggie/waifu2x-caffe/releases/latest').json()
+
+        for a in latest_release['assets']:
+            if 'waifu2x-caffe.zip' in a['browser_download_url']:
+                waifu2x_caffe_zip = download(a['browser_download_url'], tempfile.gettempdir())
+                self.trash.append(waifu2x_caffe_zip)
+
+        with zipfile.ZipFile(waifu2x_caffe_zip) as zipf:
+            zipf.extractall(LOCALAPPDATA / 'video2x')
+
+    def _install_waifu2x_converter_cpp(self):
+        """ Install waifu2x_caffe
+        """
+        print('\nInstalling waifu2x-converter-cpp')
+        import requests
+
+        # Get latest release of waifu2x-caffe via GitHub API
+        latest_release = requests.get('https://api.github.com/repos/DeadSix27/waifu2x-converter-cpp/releases/latest').json()
+
+        for a in latest_release['assets']:
+            if re.search(r'waifu2x-DeadSix27-win64_v[0-9]*\.zip', a['browser_download_url']):
+                waifu2x_converter_cpp_zip = download(a['browser_download_url'], tempfile.gettempdir())
+                self.trash.append(waifu2x_converter_cpp_zip)
+
+        with zipfile.ZipFile(waifu2x_converter_cpp_zip) as zipf:
+            zipf.extractall(LOCALAPPDATA / 'video2x' / 'waifu2x-converter-cpp')
+
+    def _install_waifu2x_ncnn_vulkan(self):
+        """ Install waifu2x-ncnn-vulkan
+        """
+        print('\nInstalling waifu2x-ncnn-vulkan')
+        import requests
+
+        # Get latest release of waifu2x-ncnn-vulkan via Github API
+        latest_release = requests.get('https://api.github.com/repos/nihui/waifu2x-ncnn-vulkan/releases/latest').json()
+
+        for a in latest_release['assets']:
+            if re.search(r'waifu2x-ncnn-vulkan-\d*\.zip', a['browser_download_url']):
+                waifu2x_ncnn_vulkan_zip = download(a['browser_download_url'], tempfile.gettempdir())
+                self.trash.append(waifu2x_ncnn_vulkan_zip)
+
+        # extract and rename
+        waifu2x_ncnn_vulkan_directory = LOCALAPPDATA / 'video2x' / 'waifu2x-ncnn-vulkan'
+        with zipfile.ZipFile(waifu2x_ncnn_vulkan_zip) as zipf:
+            zipf.extractall(LOCALAPPDATA / 'video2x')
+
+            # if directory already exists, remove it
+            if waifu2x_ncnn_vulkan_directory.exists():
+                shutil.rmtree(waifu2x_ncnn_vulkan_directory)
+
+            # rename the newly extracted directory
+            (LOCALAPPDATA / 'video2x' / zipf.namelist()[0]).rename(waifu2x_ncnn_vulkan_directory)
+
+    def _install_anime4k(self):
+        """ Install Anime4K
+        """
+        print('\nInstalling Anime4K')
+
+        """
+        import requests
+
+        # get latest release of Anime4K via Github API
+        # at the time of writing this portion, Anime4K doesn't yet have a stable release
+        # therefore releases/latest won't work
+        latest_release = requests.get('https://api.github.com/repos/bloc97/Anime4K/releases').json()[0]
+
+        for a in latest_release['assets']:
+            if 'Anime4K_Java.zip' in a['browser_download_url']:
+                anime4k_zip = download(a['browser_download_url'], tempfile.gettempdir())
+                self.trash.append(anime4k_zip)
+        """
+
+        # since Java pre-compiled release has been removed from download
+        # page, we use this cached version as a temporary solution
+        anime4k_zip = download('https://files.flexio.org/Resources/anime4k.zip', tempfile.gettempdir())
+        self.trash.append(anime4k_zip)
+
+        # extract and rename
+        with zipfile.ZipFile(anime4k_zip) as zipf:
+            zipf.extractall(LOCALAPPDATA / 'video2x' / 'anime4k')
+
+    def _generate_config(self):
+        """ Generate video2x config
+        """
+        # Open current video2x.json file as template
+        with open('video2x.json', 'r') as template:
+            template_dict = json.load(template)
+            template.close()
+
+        # configure only the specified drivers
+        if self.driver == 'all':
+            template_dict['waifu2x_caffe']['waifu2x_caffe_path'] = str(LOCALAPPDATA / 'video2x' / 'waifu2x-caffe' / 'waifu2x-caffe-cui.exe')
+            template_dict['waifu2x_converter']['waifu2x_converter_path'] = str(LOCALAPPDATA / 'video2x' / 'waifu2x-converter-cpp')
+            template_dict['waifu2x_ncnn_vulkan']['waifu2x_ncnn_vulkan_path'] = str(LOCALAPPDATA / 'video2x' / 'waifu2x-ncnn-vulkan' / 'waifu2x-ncnn-vulkan.exe')
+            template_dict['anime4k']['anime4k_path'] = str(LOCALAPPDATA / 'video2x' / 'anime4k' / 'Anime4K.jar')
+        elif self.driver == 'waifu2x_caffe':
+            template_dict['waifu2x_caffe']['waifu2x_caffe_path'] = str(LOCALAPPDATA / 'video2x' / 'waifu2x-caffe' / 'waifu2x-caffe-cui.exe')
+        elif self.driver == 'waifu2x_converter':
+            template_dict['waifu2x_converter']['waifu2x_converter_path'] = str(LOCALAPPDATA / 'video2x' / 'waifu2x-converter-cpp')
+        elif self.driver == 'waifu2x_ncnn_vulkan':
+            template_dict['waifu2x_ncnn_vulkan']['waifu2x_ncnn_vulkan_path'] = str(LOCALAPPDATA / 'video2x' / 'waifu2x-ncnn-vulkan' / 'waifu2x-ncnn-vulkan.exe')
+        elif self.driver == 'anime4k':
+            template_dict['anime4k']['anime4k_path'] = str(LOCALAPPDATA / 'video2x' / 'anime4k' / 'Anime4K.jar')
+
+        template_dict['ffmpeg']['ffmpeg_path'] = str(LOCALAPPDATA / 'video2x' / 'ffmpeg-latest-win64-static' / 'bin')
+        template_dict['video2x']['video2x_cache_directory'] = None
+        template_dict['video2x']['preserve_frames'] = False
+
+        # Write configuration into file
+        with open('video2x.json', 'w') as config:
+            json.dump(template_dict, config, indent=2)
+            config.close()
+
+
+def download(url, save_path, chunk_size=4096):
+    """ Download file to local with requests library
+    """
+    from tqdm import tqdm
+    import requests
+
+    save_path = pathlib.Path(save_path)
+
+    # create target folder if it doesn't exist
+    save_path.mkdir(parents=True, exist_ok=True)
+
+    # create requests stream for steaming file
+    stream = requests.get(url, stream=True, allow_redirects=True)
+
+    # get file name
+    file_name = None
+    if 'content-disposition' in stream.headers:
+        disposition = stream.headers['content-disposition']
+        with contextlib.suppress(IndexError):
+            file_name = re.findall("filename=(.+)", disposition)[0].strip('"')
+
+    if file_name is None:
+        # output_file = f'{save_path}\\{stream.url.split("/")[-1]}'
+        output_file = save_path / stream.url.split('/')[-1]
+    else:
+        output_file = save_path / file_name
+
+    # decode url encoding
+    output_file = pathlib.Path(urllib.parse.unquote(str(output_file)))
+
+    # get total size for progress bar if provided in headers
+    total_size = 0
+    if 'content-length' in stream.headers:
+        total_size = int(stream.headers['content-length'])
+
+    # print download information summary
+    print(f'Downloading: {url}')
+    print(f'Total size: {total_size}')
+    print(f'Chunk size: {chunk_size}')
+    print(f'Saving to: {output_file}')
+
+    # Write content into file
+    with open(output_file, 'wb') as output:
+        with tqdm(total=total_size, ascii=True) as progress_bar:
+            for chunk in stream.iter_content(chunk_size=chunk_size):
+                if chunk:
+                    output.write(chunk)
+                    progress_bar.update(len(chunk))
+
+    # return the full path of saved file
+    return output_file
+
+
+def pip_install(file):
+    """ Install python package via python pip module
+
+    pip.main() is not available after pip 9.0.1, thus
+    pip module is not used in this case.
+    """
+    return subprocess.run([sys.executable, '-m', 'pip', 'install', '-U', '-r', file]).returncode
+
+
+if __name__ == '__main__':
+    try:
+        args = process_arguments()
+        print('Video2X Setup Script')
+        print(f'Version: {VERSION}')
+
+        # do not install pip modules if script
+        # is packaged in exe format
+        download_python_modules = True
+        if sys.argv[0].endswith('.exe'):
+            print('\nScript is packaged as exe, skipping pip module download')
+            download_python_modules = False
+
+        setup = Video2xSetup(args.driver, download_python_modules)
+        setup.run()
+        print('\nScript finished successfully')
+    except Exception:
+
+        traceback.print_exc()
+        print('An error has occurred')
+        print('Video2X Automatic Setup has failed')
+
+        # in case of a failure, try cleaning up temp files
+        try:
+            setup._cleanup()
+        except Exception:
+            traceback.print_exc()
+            print('An error occurred while trying to cleanup files')
+
+        exit(1)

src/waifu2x_caffe.py

@@ -0,0 +1,98 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Name: Waifu2x Caffe Driver
+Author: K4YT3X
+Date Created: Feb 24, 2018
+Last Modified: August 3, 2019
+
+Description: This class is a high-level wrapper
+for waifu2x-caffe.
+"""
+
+# built-in imports
+import subprocess
+import threading
+
+# third-party imports
+from avalon_framework import Avalon
+
+
+class Waifu2xCaffe:
+    """This class communicates with waifu2x cui engine
+
+    An object will be created for this class, containing information
+    about the binary address and the processing method. When being called
+    by the main program, other detailed information will be passed to
+    the upscale function.
+    """
+
+    def __init__(self, waifu2x_settings, process, model_dir, bit_depth):
+        self.waifu2x_settings = waifu2x_settings
+        self.waifu2x_settings['process'] = process
+        self.waifu2x_settings['model_dir'] = model_dir
+        self.waifu2x_settings['output_depth'] = bit_depth
+
+        # arguments passed through command line overwrites config file values
+        self.process = process
+        self.model_dir = model_dir
+        self.print_lock = threading.Lock()
+
+    def upscale(self, input_directory, output_directory, scale_ratio, scale_width, scale_height, image_format, upscaler_exceptions):
+        """This is the core function for WAIFU2X class
+
+        Arguments:
+            input_directory {string} -- source directory path
+            output_directory {string} -- output directory path
+            width {int} -- output video width
+            height {int} -- output video height
+        """
+
+        try:
+            # overwrite config file settings
+            self.waifu2x_settings['input_path'] = input_directory
+            self.waifu2x_settings['output_path'] = output_directory
+
+            if scale_ratio:
+                self.waifu2x_settings['scale_ratio'] = scale_ratio
+            elif scale_width and scale_height:
+                self.waifu2x_settings['scale_width'] = scale_width
+                self.waifu2x_settings['scale_height'] = scale_height
+
+            self.waifu2x_settings['output_extention'] = image_format
+
+            # print thread start message
+            self.print_lock.acquire()
+            Avalon.debug_info(f'[upscaler] Thread {threading.current_thread().name} started')
+            self.print_lock.release()
+
+            # list to be executed
+            # initialize the list with waifu2x binary path as the first element
+            execute = [str(self.waifu2x_settings['waifu2x_caffe_path'])]
+
+            for key in self.waifu2x_settings.keys():
+
+                value = self.waifu2x_settings[key]
+
+                # is executable key or null or None means that leave this option out (keep default)
+                if key == 'waifu2x_caffe_path' or value is None or value is False:
+                    continue
+                else:
+                    if len(key) == 1:
+                        execute.append(f'-{key}')
+                    else:
+                        execute.append(f'--{key}')
+                    execute.append(str(value))
+
+            Avalon.debug_info(f'Executing: {execute}')
+            completed_command = subprocess.run(execute, check=True)
+
+            # print thread exiting message
+            self.print_lock.acquire()
+            Avalon.debug_info(f'[upscaler] Thread {threading.current_thread().name} exiting')
+            self.print_lock.release()
+
+            # return command execution return code
+            return completed_command.returncode
+        except Exception as e:
+            upscaler_exceptions.append(e)

src/waifu2x_converter.py

@@ -0,0 +1,96 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Name: Waifu2x Converter CPP Driver
+Author: K4YT3X
+Date Created: February 8, 2019
+Last Modified: August 3, 2019
+
+Description: This class is a high-level wrapper
+for waifu2x-converter-cpp.
+"""
+
+# built-in imports
+import pathlib
+import subprocess
+import threading
+
+# third-party imports
+from avalon_framework import Avalon
+
+
+class Waifu2xConverter:
+    """This class communicates with waifu2x cui engine
+
+    An object will be created for this class, containing information
+    about the binary address and the processing method. When being called
+    by the main program, other detailed information will be passed to
+    the upscale function.
+    """
+
+    def __init__(self, waifu2x_settings, model_dir):
+        self.waifu2x_settings = waifu2x_settings
+        self.waifu2x_settings['model_dir'] = model_dir
+        self.print_lock = threading.Lock()
+
+    def upscale(self, input_directory, output_directory, scale_ratio, jobs, image_format, upscaler_exceptions):
+        """ Waifu2x Converter Driver Upscaler
+        This method executes the upscaling of extracted frames.
+
+        Arguments:
+            input_directory {string} -- source directory path
+            output_directory {string} -- output directory path
+            scale_ratio {int} -- frames' scale ratio
+            threads {int} -- number of threads
+        """
+
+        try:
+            # overwrite config file settings
+            self.waifu2x_settings['input'] = input_directory
+            self.waifu2x_settings['output'] = output_directory
+            self.waifu2x_settings['scale-ratio'] = scale_ratio
+            self.waifu2x_settings['jobs'] = jobs
+            self.waifu2x_settings['output-format'] = image_format
+
+            # models_rgb must be specified manually for waifu2x-converter-cpp
+            # if it's not specified in the arguments, create automatically
+            if self.waifu2x_settings['model-dir'] is None:
+                self.waifu2x_settings['model-dir'] = pathlib.Path(self.waifu2x_settings['waifu2x_converter_path']) / 'models_rgb'
+
+            # print thread start message
+            self.print_lock.acquire()
+            Avalon.debug_info(f'[upscaler] Thread {threading.current_thread().name} started')
+            self.print_lock.release()
+
+            # list to be executed
+            # initialize the list with waifu2x binary path as the first element
+            execute = [str(pathlib.Path(self.waifu2x_settings['waifu2x_converter_path']) / 'waifu2x-converter-cpp.exe')]
+
+            for key in self.waifu2x_settings.keys():
+
+                value = self.waifu2x_settings[key]
+
+                # the key doesn't need to be passed in this case
+                if key == 'waifu2x_converter_path':
+                    continue
+
+                # null or None means that leave this option out (keep default)
+                elif value is None or value is False:
+                    continue
+                else:
+                    if len(key) == 1:
+                        execute.append(f'-{key}')
+                    else:
+                        execute.append(f'--{key}')
+
+                    # true means key is an option
+                    if value is True:
+                        continue
+
+                    execute.append(str(value))
+
+            Avalon.debug_info(f'Executing: {execute}')
+            return subprocess.run(execute, check=True).returncode
+
+        except Exception as e:
+            upscaler_exceptions.append(e)

src/waifu2x_ncnn_vulkan.py

@@ -0,0 +1,93 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Name: Waifu2x NCNN Vulkan Driver
+Author: SAT3LL
+Date Created: June 26, 2019
+Last Modified: August 3, 2019
+
+Dev: K4YT3X
+
+Description: This class is a high-level wrapper
+for waifu2x_ncnn_vulkan.
+"""
+
+# built-in imports
+import os
+import subprocess
+import threading
+
+# third-party imports
+from avalon_framework import Avalon
+
+
+class Waifu2xNcnnVulkan:
+    """This class communicates with waifu2x ncnn vulkan engine
+
+    An object will be created for this class, containing information
+    about the binary address and the processing method. When being called
+    by the main program, other detailed information will be passed to
+    the upscale function.
+    """
+
+    def __init__(self, waifu2x_settings):
+        self.waifu2x_settings = waifu2x_settings
+
+        # arguments passed through command line overwrites config file values
+
+        # waifu2x_ncnn_vulkan can't find its own model directory if its not in the current dir
+        #   so change to it
+        os.chdir(os.path.join(self.waifu2x_settings['waifu2x_ncnn_vulkan_path'], '..'))
+
+        self.print_lock = threading.Lock()
+
+    def upscale(self, input_directory, output_directory, scale_ratio, upscaler_exceptions):
+        """This is the core function for WAIFU2X class
+
+        Arguments:
+            input_directory {string} -- source directory path
+            output_directory {string} -- output directory path
+            ratio {int} -- output video ratio
+        """
+
+        try:
+            # overwrite config file settings
+            self.waifu2x_settings['i'] = input_directory
+            self.waifu2x_settings['o'] = output_directory
+            self.waifu2x_settings['s'] = scale_ratio
+
+            # print thread start message
+            self.print_lock.acquire()
+            Avalon.debug_info(f'[upscaler] Thread {threading.current_thread().name} started')
+            self.print_lock.release()
+
+            # list to be executed
+            # initialize the list with waifu2x binary path as the first element
+            execute = [str(self.waifu2x_settings['waifu2x_ncnn_vulkan_path'])]
+
+            for key in self.waifu2x_settings.keys():
+
+                value = self.waifu2x_settings[key]
+
+                # is executable key or null or None means that leave this option out (keep default)
+                if key == 'waifu2x_ncnn_vulkan_path' or value is None or value is False:
+                    continue
+                else:
+                    if len(key) == 1:
+                        execute.append(f'-{key}')
+                    else:
+                        execute.append(f'--{key}')
+                    execute.append(str(value))
+
+            Avalon.debug_info(f'Executing: {execute}')
+            completed_command = subprocess.run(execute, check=True)
+
+            # print thread exiting message
+            self.print_lock.acquire()
+            Avalon.debug_info(f'[upscaler] Thread {threading.current_thread().name} exiting')
+            self.print_lock.release()
+
+            # return command execution return code
+            return completed_command.returncode
+        except Exception as e:
+            upscaler_exceptions.append(e)