GUI resolve driver paths into absolute paths

build script 1.0.1: building into directory with name of version
better exception handling, soft task interruption, GUI stop button, GUI folder processing, better argument checks
2026-02-09 22:34:48 +08:00 · 2020-05-07 16:31:05 -04:00 · 2020-05-07 16:30:36 -04:00 · 2020-05-07 15:58:22 -04:00 · 2020-05-07 10:03:42 -04:00 · 2020-05-07 09:58:25 -04:00
30 changed files with 3626 additions and 1636 deletions
--- a/.github/FUNDING.yml
+++ b/.github/FUNDING.yml
@@ -0,0 +1,12 @@
+# These are supported funding model platforms
+
+github: # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
+patreon: k4yt3x
+open_collective: # Replace with a single Open Collective username
+ko_fi: # Replace with a single Ko-fi username
+tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
+community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
+liberapay: # Replace with a single Liberapay username
+issuehunt: # Replace with a single IssueHunt username
+otechie: # Replace with a single Otechie username
+custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']
--- a/README.md
+++ b/README.md
@@ -1,3 +1,13 @@
+![Master Branch Version](https://img.shields.io/badge/master-v4.0.0-9cf?style=flat-square)
+![GitHub release (latest by date)](https://img.shields.io/github/v/release/k4yt3x/video2x?style=flat-square)
+![GitHub All Releases](https://img.shields.io/github/downloads/k4yt3x/video2x/total?style=flat-square)
+![GitHub](https://img.shields.io/github/license/k4yt3x/video2x?style=flat-square)
+![Platforms](https://img.shields.io/badge/Platforms-Windows%20%7C%20Linux%20%7C%20macOS-blue?style=flat-square)
+<img alt="Become a Patron!"
+src="https://c5.patreon.com/external/logo/become_a_patron_button@2x.png"
+href="https://www.patreon.com/bePatron?u=34970782" 
+height=20 />
+
 # Video2X Lossless Video Enlarger

 ### Official Discussion Group (Telegram): https://t.me/video2x
@@ -6,9 +16,9 @@

 You can go to the [releases page](https://github.com/k4yt3x/video2x/releases) to download the latest builds of `Video2X`. The exe files will require no Python or Python module installation.

-The **`full`** package provides all packages that will possibly be needed by `Video2X`, including `FFmpeg`, `waifu2x-caffe`, `waifu2x-converter-cpp`, `waifu2x-ncnn-vulkan`, and `Anime4K`. The config file (`video2x.json`) is also already configured for the environment. All you need to do is just to launch `video2x.exe`.
+The **`full`** package provides all packages that will possibly be needed by `Video2X`, including `FFmpeg`, `waifu2x-caffe`, `waifu2x-converter-cpp`, `waifu2x-ncnn-vulkan`, `srmd-ncnn-vulkan` and `Anime4KCPP`. The config file (`video2x.yaml`) is also already configured for the environment. All you need to do is just to launch `video2x.exe`.

-The **`light`** package provides only the most basic functions of `Video2X`. Only `video2x.exe`, `video2x_setup.exe` and `video2x.json` are included. To setup dependencies (e.g. `FFmpeg` and `Waifu2X`) automatically, simply launch `video2x_setup.exe`.
+The **`light`** package provides only the most basic functions of `Video2X`. Only `video2x.exe`, `video2x_setup.exe` and `video2x.yaml` are included. To setup dependencies (e.g. `FFmpeg` and `Waifu2X`) automatically, simply launch `video2x_setup.exe`.

 ## Prerequisites

@@ -22,51 +32,69 @@ Component names that are **bolded** can be automatically downloaded and configur
   - [**waifu2x-caffe**](https://github.com/lltcggie/waifu2x-caffe/releases)
   - [**waifu2x-converter-cpp**](https://github.com/DeadSix27/waifu2x-converter-cpp/releases)
   - [**waifu2x-ncnn-vulkan**](https://github.com/nihui/waifu2x-ncnn-vulkan)
-   - [**Anime4K**](https://github.com/bloc97/Anime4K)
+   - [**srmd-ncnn-vulkan**](https://github.com/nihui/srmd-ncnn-vulkan)
+   - [**Anime4KCPP**](https://github.com/TianZerL/Anime4KCPP)

 ## Recent Changes

-### 3.0.0 (November 26, 2019)
+### 4.0.0 (May 5, 2020)

- Linux compatibility
- Configuration file changed to YAML format
-  - You may still use a JSON-formatted config file. To do so, please specify `-c video2x.json`.
- Other code clean-up and optimization
+- Added internationalization support
+  - Added language zh_CN (简体中文)
+  - Language will change automatically according to system locale settings
+- Added support for [Anime4KCPP](https://github.com/TianZerL/Anime4KCPP) in replacement for Anime4K (Java)
+- Driver-specific settings can now be specified in the command line by specifying them after a `--`
+- All driver-specific settings are parsed by the corresponding driver
+- Modularized driver wrappers in Video2X
+- Cleaned up some clutters in the code

-### 2.10.0 (August 16, 2019)
+### 3.2.0 (April 26, 2020)

- **Added support for [Anime4K](https://github.com/bloc97/Anime4K)**
+- Added support for [SRMD-NCNN-Vulkan](https://github.com/nihui/srmd-ncnn-vulkan)

-### 2.9.0 (July 27, 2019)
+### 3.1.0 (February 26, 2020)

- Changed file handling method from `os` to `pathlib`
- Removed f_string dependency and support for legacy versions of Python
- Organized file import statements
+- Removed the redundant layer of multi-threading since multi-process has to be implemented for launching Windows PE files in sub-processes
+- Added support for graceful exit upon `KeyboardInterrupt` or termination signals
+- Other minor improvements such as replacing `' '.join(execute)` with `shlex.join(execute)`

-### Setup Script 1.6.0 (November 26, 2019)
+### Setup Script 1.8.0 (May 5, 2020)

- Added compatibility for new YAML configuration file
- Added better exception handling
+- Added support for Anime4KCPP

 ## 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.

-For short: **Video2X enlarges your video without losing details**
+For short: **Video2X enlarges your video without losing details**.

 Watch for the sharper edges in this screenshot around the shadows:

 ![preview](https://user-images.githubusercontent.com/21986859/49412428-65083280-f73a-11e8-8237-bb34158a545e.png)

+*Upscale Comparison Demonstration*
+
 **You can also watch the YouTube video Demo: https://www.youtube.com/watch?v=PG94iPoeoZk**

 Clip is from trailer of animated movie "千と千尋の神隠し". Copyright belongs to "株式会社スタジオジブリ (STUDIO GHIBLI INC.)". Will delete immediately if use of clip is in violation of copyright.

-## Screenshot
+## Screenshots

-![video2x_gui](https://user-images.githubusercontent.com/21986859/63219691-ee478400-c166-11e9-8c15-dcf59228bd96.png)
+### Video2X GUI

-![screenshot](https://user-images.githubusercontent.com/21986859/40265170-39c0caae-5b01-11e8-8371-8b6c24769639.png)
+![Video2X GUI Main Tab Screenshot](https://user-images.githubusercontent.com/21986859/81241806-dcf71e00-8ffa-11ea-88ed-50b062d9bb5e.png)
+
+*Video2X GUI Main Tab Screenshot*
+
+![Video2X GUI Driver Settings Screenshot](https://user-images.githubusercontent.com/21986859/81241837-f9935600-8ffa-11ea-8b89-5ae098b63de4.png)
+
+*Video2X GUI Driver Settings Screenshot*
+
+### Video2X CLI
+
+![Video2X CLI Screenshot](https://user-images.githubusercontent.com/21986859/81039711-4fe88380-8e99-11ea-9846-175f72100a76.png)
+
+*Video2X CLI Screenshot*

 ---

@@ -80,9 +108,9 @@ You can find all detailed user-facing and developer-facing documentations in the

 For those who want a detailed walk-through of how to use `Video2X`, you can head to the [Step-By-Step Tutorial](https://github.com/k4yt3x/video2x/wiki/Step-By-Step-Tutorial) wiki page. It includes almost every step you need to perform in order to enlarge your first video.

-### [Waifu2X Drivers](https://github.com/k4yt3x/video2x/wiki/Waifu2X-Drivers)
+### [Drivers](https://github.com/k4yt3x/video2x/wiki/Drivers)

-Go to the [Waifu2X Drivers](https://github.com/k4yt3x/video2x/wiki/Waifu2X-Drivers) wiki page if you want to see a detailed description on the different types of `waifu2x` drivers implemented by `Video2X`. This wiki page contains detailed difference between different drivers, and how to download and set each of them up for `Video2X`.
+Go to the [Drivers](https://github.com/k4yt3x/video2x/wiki/Drivers) wiki page if you want to see a detailed description on the different types of drivers implemented by `Video2X`. This wiki page contains detailed difference between different drivers, and how to download and set each of them up for `Video2X`.

 ### [Q&A](https://github.com/k4yt3x/video2x/wiki/Q&A)

@@ -94,18 +122,20 @@ If you have any questions, first try visiting our [Q&A](https://github.com/k4yt3

 ### Prerequisites

- **Python 3**
+- **Python 3.8**
 Download: https://www.python.org/downloads/windows/
 - **FFmpeg Windows Build**
 Download: https://ffmpeg.org/download.html
- **waifu2x-caffe** (for Nvidia CUDA/CUDNN)
+- **waifu2x-caffe** (designed for Nvidia CUDA/cuDNN)
 Download: https://github.com/lltcggie/waifu2x-caffe/releases
- **waifu2x-converter-cpp** (required for AMD, OpenCL and OpenGL processing)
+- **waifu2x-converter-cpp**
 Download: https://github.com/DeadSix27/waifu2x-converter-cpp/releases
 - **waifu2x-ncnn-vulkan**
 Download: https://github.com/nihui/waifu2x-ncnn-vulkan/releases
- **Anime4K**
-Download: https://github.com/bloc97/Anime4K/releases
+- **Anime4KCPP**
+Download: https://github.com/TianZerL/Anime4KCPP/releases
+- **srmd-ncnn-vulkan**
+Download: https://github.com/nihui/srmd-ncnn-vulkan/releases

 ### Installing Dependencies

@@ -113,12 +143,12 @@ First, clone the video2x repository.

 ```shell
 git clone https://github.com/k4yt3x/video2x.git
-cd video2x/bin
+cd video2x/src
 ```

 Then you may run the `video2x_setup.py` script to install and configure the dependencies automatically. This script is designed and tested on Windows 10.

-This script will install the newest version of `ffmpeg`, any one or all `waifu2x-caffe`, `waifu2x-converter-cpp`, and `waifu2x-ncnn-vulkan` to `%LOCALAPPDATA%\\video2x` and all required python libraries.
+This script will install the newest version of `ffmpeg`, and all upscaling drivers to `%LOCALAPPDATA%\\video2x` and all required python libraries.

 ```shell
 python video2x_setup.py
@@ -132,112 +162,80 @@ Then you'll need to install python dependencies before start using video2x. Inst
 pip install -r requirements.txt
 ```

-**Note that all command line arguments/options overwrite configuration file settings.**
-
 ### Sample Videos

 If you can't find a video clip to begin with, or if you want to see a before-after comparison, we have prepared some sample clips for you. The quick start guide down below will also be based on the name of the sample clips.

 ![sample_video](https://user-images.githubusercontent.com/21986859/52905766-d5512b00-3236-11e9-9aea-077636539679.png)

- [Sample Video Original (240P) 1.7MB](https://files.flexio.org/Resources/Videos/sample_input.mp4)
- [Sample Video Upscaled (1080P) 4.8MB](https://files.flexio.org/Resources/Videos/sample_output.mp4)
+*Sample Upscale Videos*
+
+- [Sample Video Original (240P) 1.7MB](https://files.k4yt3x.com/Resources/Videos/sample_input.mp4)
+- [Sample Video Upscaled (1080P) 4.8MB](https://files.k4yt3x.com/Resources/Videos/sample_output.mp4)

 Clip is from anime "さくら荘のペットな彼女". Copyright belongs to "株式会社アニプレックス (Aniplex Inc.)". Will delete immediately if use of clip is in violation of copyright.

-### Nvidia CUDA (waifu2x-caffe)
+### Basic Upscale Example

-Enlarge the video to 1920x1080 using CUDA. You may also use the `-r/--ratio` option.
+This example command below uses `waifu2x-caffe` to enlarge the video `sample-input.mp4` two double its original size.

 ```shell
-python video2x.py -i sample_input.mp4 -o sample_output.mp4 -m gpu --width=1920 --height=1080
+python video2x.py -i sample-input.mp4 -o sample-output.mp4 -r 2 -d waifu2x_caffe
 ```

-### Nvidia CUDNN
+### Advanced Upscale Example

-Enlarge the video to 1920x1080 using CUDNN. You may also use the `-r/--ratio` option.
+If you would like to tweak engine-specific settings, either specify the corresponding argument after `--`, or edit the corresponding field in the configuration file `video2x.yaml`. **Command line arguments will overwrite default values in the config file.**
+
+This example below adds enables TTA for `waifu2x-caffe`.

 ```shell
-python video2x.py -i sample_input.mp4 -o sample_output.mp4 -m cudnn --width=1920 --height=1080
+python video2x.py -i sample-input.mp4 -o sample-output.mp4 -r 2 -d waifu2x_caffe -- --tta 1
 ```

-### AMD or Nvidia (waifu2x-converter-cpp OpenCL)
-
-Enlarge the video by 2 times using OpenCL. Note that `waifu2x-converter-cpp` doesn't support width and height. You'll also have to explicitly specify that the driver to be used is `waifu2x_converter`.
+To see a help page for driver-specific settings, use `-d` to select the driver and append `-- --help` as demonstrated below. This will print all driver-specific settings and descriptions.

 ```shell
-python video2x.py -i sample_input.mp4 -o sample_output.mp4 -m gpu -r 2 -d waifu2x_converter
-```
-
-### AMD or Nvidia (waifu2x-ncnn-vulkan Vulkan)
-
-```shell
-python video2x.py -i sample_input.mp4 -o sample_output.mp4 -m gpu -r 2 -d waifu2x_ncnn_vulkan
-```
-
-### Anime4K
-
-Enlarge the video by 2 times using Anime4K. **Remember to install and configure [JRE 12](https://www.oracle.com/technetwork/java/javase/downloads/java-archive-javase12-5440181.html) path in the configuration file.**
-
-```shell
-python video2x.py -i sample_input.mp4 -o sample_output.mp4 -r 2 -d anime4k
-```
-
-### CPU
-
-Enlarge the video to 1920x1080 using the CPU. You may also use the `-r/--ratio` option. **waifu2x-based upscalers potentially run much slower than using a GPU, but Anime4K is more CPU-dependant**. The configuration file for this method is similar to the previous methods.
-
-```shell
-python video2x.py -i sample_input.mp4 -o sample_output.mp4 -m cpu --width=1920 --height=1080
+python video2x.py -d waifu2x_caffe -- --help
 ```

 ---

 # Full Usage

-## General Options
+## General Options:

 ### -h, --help
    show this help message and exit

-## File Options
-
 ### -i INPUT, --input INPUT
-    Source video file/directory (default: None)
+    source video file/directory

 ### -o OUTPUT, --output OUTPUT
-    Output video file/directory (default: None)
-
-## Upscaling Options
-
-### -m {cpu,gpu,cudnn}, --method {cpu,gpu,cudnn}
-    Upscaling method (default: gpu)
-
-### -d {waifu2x_caffe,waifu2x_converter}, --driver {waifu2x_caffe,waifu2x_converter}
-    Waifu2x driver (default: waifu2x_caffe)
-
-### -y MODEL_DIR, --model_dir MODEL_DIR
-    Folder containing model JSON files
-
-### -t THREADS, --threads THREADS
-    Number of threads to use for upscaling (default: 5)
+    output video file/directory

 ### -c CONFIG, --config CONFIG
-    Video2X config file location (default: video2x\bin\video2x.json)
+    video2x config file path

-### -b, --batch
-    Enable batch mode (select all default values to questions)
+### -d {waifu2x_caffe,waifu2x_converter_cpp,waifu2x_ncnn_vulkan,srmd_ncnn_vulkan,anime4kcpp}, --driver {waifu2x_caffe,waifu2x_converter_cpp,waifu2x_ncnn_vulkan,srmd_ncnn_vulkan,anime4kcpp}
+    upscaling driver (default: waifu2x_caffe)
+
+### -p PROCESSES, --processes PROCESSES
+    number of processes to use for upscaling (default: 1)
+
+### -v, --version
+    display version, lawful information and exit

 ## Scaling Options

 ### --width WIDTH
-    Output video width
+    output video width

 ### --height HEIGHT
-    Output video height
+    output video height

 ### -r RATIO, --ratio RATIO
-    Scaling ratio
+    scaling ratio

 ---

@@ -254,11 +252,12 @@ https://www.gnu.org/licenses/gpl-3.0.txt

 This project relies on the following software and projects.

- [FFmpeg]('https://www.ffmpeg.org/')
+- [FFmpeg](https://www.ffmpeg.org/)
 - [waifu2x-caffe](https://github.com/lltcggie/waifu2x-caffe)
 - [waifu2x-converter-cpp](https://github.com/DeadSix27/waifu2x-converter-cpp)
 - [waifu2x-ncnn-vulkan](https://github.com/nihui/waifu2x-ncnn-vulkan)
- [Anime4K](https://github.com/bloc97/Anime4K)
+- [srmd-ncnn-vulkan](https://github.com/nihui/srmd-ncnn-vulkan)
+- [Anime4KCPP](https://github.com/TianZerL/Anime4KCPP)

 ## Special Thanks

@@ -267,6 +266,7 @@ Appreciations given to the following code contributors:
 - @BrianPetkovsek
 - @SAT3LL

-## Related Resources
+## Related Projects

- [Dandere2x](https://github.com/CardinalPanda/dandere2x): `Dandere2x` is a lossy video upscaler also built around `waifu2x`, but with video compression techniques to shorten the time needed to process a video.
+- [Dandere2x](https://github.com/CardinalPanda/dandere2x): A lossy video upscaler also built around `waifu2x`, but with video compression techniques to shorten the time needed to process a video.
+- [Waifu2x-Extension-GUI](https://github.com/AaronFeng753/Waifu2x-Extension-GUI): A similar project that focuses more and only on building a better graphical user interface. It is built using C++ and Qt5, and currently only supports the Windows platform.
--- a/src/anime4k.py
+++ b/src/anime4k.py
@@ -1,92 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""
-Name: Anime4K Driver
-Author: K4YT3X
-Date Created: August 15, 2019
-Last Modified: November 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, driver_settings):
-        self.driver_settings = driver_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.driver_settings['java_path'],
-                    '-jar',
-                    self.driver_settings['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)
--- a/src/build.ps1
+++ b/src/build.ps1
@@ -0,0 +1,86 @@
+<#
+Name: Video2X Build Script
+Creator: K4YT3X
+Date Created: May 6, 2020
+Last Modified: May 7, 2020
+
+Description: A PowerShell script that will build Video2X
+executable (PE) releases automatically using PyInstaller.
+This script is currently only tuned for K4YT3X's environment.
+
+To start a PowerShell session with execution policy bypass
+powershell –ExecutionPolicy Bypass
+#>
+
+# version number
+$SCRIPT_VERSION = "1.0.1"
+$VIDEO2X_VERSION = "4.0.0_beta2"
+
+Write-Host -ForegroundColor White "Video2X Building Script Version $($SCRIPT_VERSION)
+Starting to build Video2X release packages"
+
+# build Video2X CLI
+Write-Host -ForegroundColor White "`nBuilding Video2X CLI"
+pyinstaller --noconfirm --log-level=WARN `
+    --onefile `
+    --add-data="wrappers;wrappers" `
+    --icon="images\video2x.ico" `
+    video2x.py
+
+# build Video2X GUI
+Write-Host -ForegroundColor White "`nBuilding Video2X GUI"
+pyinstaller --noconfirm --log-level=WARN `
+    --onefile `
+    --add-data="images;images" `
+    --add-data="locale;locale" `
+    --add-data="video2x_gui.ui;." `
+    --add-data="wrappers;wrappers" `
+    --icon="images\video2x.ico" `
+    video2x_gui.py
+
+# build setup script
+Write-Host -ForegroundColor White "`nBuilding Video2X setup script"
+pyinstaller --noconfirm --log-level=WARN `
+    --onefile `
+    --icon="images\video2x.ico" `
+    video2x_setup.py
+
+# remove old builds if found
+if (Test-Path "$($VIDEO2X_VERSION)" -PathType any) {
+    Remove-Item -path "$($VIDEO2X_VERSION)" -recurse
+}
+
+# create build directory
+New-Item "$($VIDEO2X_VERSION)" -ItemType Directory
+
+# copy files into corresponding builds
+# full edition
+Write-Host -ForegroundColor White "`nCreating full package"
+New-Item "$($VIDEO2X_VERSION)\video2x-$($VIDEO2X_VERSION)-win32-full" -ItemType Directory
+Copy-Item "dist\video2x.exe" -Destination "$($VIDEO2X_VERSION)\video2x-$($VIDEO2X_VERSION)-win32-full\"
+Copy-Item "dist\video2x_gui.exe" -Destination "$($VIDEO2X_VERSION)\video2x-$($VIDEO2X_VERSION)-win32-full\"
+Copy-Item -Path "$env:LOCALAPPDATA\video2x" -Destination "$($VIDEO2X_VERSION)\video2x-$($VIDEO2X_VERSION)-win32-full\dependencies" -Recurse
+
+# overwrite paths to relative paths
+(Get-Content "video2x.yaml").replace("%LOCALAPPDATA%\video2x", "dependencies") | Set-Content "video2x.yaml.relative"
+Move-Item "video2x.yaml.relative" -Destination "$($VIDEO2X_VERSION)\video2x-$($VIDEO2X_VERSION)-win32-full\video2x.yaml"
+
+# light edition
+Write-Host -ForegroundColor White "`nCreating light package"
+New-Item "$($VIDEO2X_VERSION)\video2x-$($VIDEO2X_VERSION)-win32-light" -ItemType Directory
+Copy-Item "dist\video2x.exe" -Destination "$($VIDEO2X_VERSION)\video2x-$($VIDEO2X_VERSION)-win32-light\"
+Copy-Item "dist\video2x_gui.exe" -Destination "$($VIDEO2X_VERSION)\video2x-$($VIDEO2X_VERSION)-win32-light\"
+Copy-Item "dist\video2x_setup.exe" -Destination "$($VIDEO2X_VERSION)\video2x-$($VIDEO2X_VERSION)-win32-light\"
+Copy-Item "video2x.yaml" -Destination "$($VIDEO2X_VERSION)\video2x-$($VIDEO2X_VERSION)-win32-light\"
+Copy-Item "requirements.txt" -Destination "$($VIDEO2X_VERSION)\video2x-$($VIDEO2X_VERSION)-win32-light\"
+
+# clean up temporary files
+Write-Host -ForegroundColor White "`nDeleting temporary files"
+$pathsToRemove = "__pycache__", "build", "dist", "*.spec"
+
+foreach ($path in $pathsToRemove){
+    Write-Host "Removing path: $($path)"
+    Remove-Item -path $path -recurse
+}
+
+Write-Host -ForegroundColor White "`nBuild script finished"
--- a/src/image_cleaner.py
+++ b/src/image_cleaner.py
@@ -3,10 +3,15 @@
 """
 Name: Video2X Image Cleaner
 Author: BrianPetkovsek
-Author: K4YT3X
 Date Created: March 24, 2019
 Last Modified: July 27, 2019

+Editor: K4YT3X
+Last Modified: March 23, 2020
+
+Editor: 28598519a
+Last Modified: March 23, 2020
+
 Description: This class is to remove the extracted frames
 that have already been upscaled.
 """
@@ -58,7 +63,7 @@ class ImageCleaner(threading.Thread):
        """

        # list all images in the extracted frames
-        output_frames = [f for f in self.output_directory.iterdir() if f.is_file()]
+        output_frames = [f.name 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
@@ -67,10 +72,8 @@ class ImageCleaner(threading.Thread):

            # 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)
+                if file.is_file() and file.name in output_frames:
+                    file.unlink()
+                    output_frames.remove(file.name)
--- a/src/images/Video2X
+++ b/src/images/Video2X
--- a/src/images/Video2X
+++ b/src/images/Video2X
--- a/src/images/v2x.ico
+++ b/src/images/v2x.ico
--- a/src/images/video2x.ico
+++ b/src/images/video2x.ico
--- a/src/images/video2x.png
+++ b/src/images/video2x.png
--- a/src/locale/zh_CN/LC_MESSAGES/zh_CN.po
+++ b/src/locale/zh_CN/LC_MESSAGES/zh_CN.po
@@ -0,0 +1,268 @@
+# SOME DESCRIPTIVE TITLE.
+# Copyright (C) YEAR ORGANIZATION
+# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
+#
+msgid ""
+msgstr ""
+"Project-Id-Version: \n"
+"POT-Creation-Date: 2020-05-07 15:54-0400\n"
+"PO-Revision-Date: 2020-05-07 15:55-0400\n"
+"Last-Translator: \n"
+"Language-Team: \n"
+"Language: zh_CN\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: pygettext.py 1.5\n"
+"X-Generator: Poedit 2.3\n"
+"Plural-Forms: nplurals=1; plural=0;\n"
+
+#: progress_monitor.py:42
+msgid "Upscaling Progress"
+msgstr "放大进度"
+
+#: upscaler.py:104
+msgid "Specified or default cache directory is a file/link"
+msgstr "指定或默认的缓存目录是文件/链接"
+
+#: upscaler.py:110
+msgid "Creating cache directory {}"
+msgstr "创建缓存目录 {}"
+
+#: upscaler.py:113
+msgid "Unable to create {}"
+msgstr "无法创建 {}"
+
+#: upscaler.py:118
+msgid "Extracted frames are being saved to: {}"
+msgstr "提取的帧将被保存到：{}"
+
+#: upscaler.py:120
+msgid "Upscaled frames are being saved to: {}"
+msgstr "已放大的帧将被保存到：{}"
+
+#: upscaler.py:130
+msgid "Cleaning up cache directory: {}"
+msgstr "清理缓存目录：{}"
+
+#: upscaler.py:133
+msgid "Unable to delete: {}"
+msgstr "无法删除：{}"
+
+#: upscaler.py:140 upscaler.py:151
+msgid "Input and output path type mismatch"
+msgstr "输入和输出路径类型不匹配"
+
+#: upscaler.py:141
+msgid "Input is single file but output is directory"
+msgstr "所选的输入路径是单个文件，但输出路径是目录"
+
+#: upscaler.py:144
+msgid "No suffix found in output file path"
+msgstr "在输出文件路径中未找到后缀"
+
+#: upscaler.py:145
+msgid "Suffix must be specified for FFmpeg"
+msgstr "必须为 FFmpeg 指定后缀"
+
+#: upscaler.py:152
+msgid "Input is directory but output is existing single file"
+msgstr "输入是目录，但输出是现有的单个文件"
+
+#: upscaler.py:157
+msgid "Input path is neither a file nor a directory"
+msgstr "输入路径既不是文件也不是目录"
+
+#: upscaler.py:166
+msgid "FFmpeg or FFprobe cannot be found under the specified path"
+msgstr "在指定的路径下找不到 FFmpeg 或 FFprobe"
+
+#: upscaler.py:167 upscaler.py:177
+msgid "Please check the configuration file settings"
+msgstr "请检查配置文件设置"
+
+#: upscaler.py:176
+msgid "Specified driver executable directory doesn't exist"
+msgstr "指定驱动的可执行文件不存在"
+
+#: upscaler.py:203
+msgid "Failed to parse driver argument: {}"
+msgstr "解析驱动程序参数失败：{}"
+
+#: upscaler.py:218
+msgid "Unrecognized driver: {}"
+msgstr "无法识别的驱动名称：{}"
+
+#: upscaler.py:290
+msgid "Starting progress monitor"
+msgstr "启动进度监视器"
+
+#: upscaler.py:295
+msgid "Starting upscaled image cleaner"
+msgstr "启动已放大图像清理程序"
+
+#: upscaler.py:304 upscaler.py:321
+msgid "Killing progress monitor"
+msgstr "终结进度监视器"
+
+#: upscaler.py:307 upscaler.py:324
+msgid "Killing upscaled image cleaner"
+msgstr "终结已放大图像清理程序"
+
+#: upscaler.py:328
+msgid "Terminating all processes"
+msgstr "正在终止所有进程"
+
+#: upscaler.py:335
+msgid "Main process waiting for subprocesses to exit"
+msgstr "主进程开始等待子进程结束"
+
+#: upscaler.py:354 upscaler.py:358
+msgid "Subprocess {} exited with code {}"
+msgstr "子进程 {} 结束，返回码 {}"
+
+#: upscaler.py:364
+msgid "Stop signal received"
+msgstr "收到停止信号"
+
+#: upscaler.py:369
+msgid "Subprocess execution ran into an error"
+msgstr "子进程执行遇到错误"
+
+#: upscaler.py:395
+msgid "Upscaling single video file: {}"
+msgstr "放大单个视频文件：{}"
+
+#: upscaler.py:414 upscaler.py:477
+msgid "Starting to upscale extracted images"
+msgstr "开始对提取的帧进行放大"
+
+#: upscaler.py:423 upscaler.py:479
+msgid "Upscaling completed"
+msgstr "放大完成"
+
+#: upscaler.py:432
+msgid "Reading video information"
+msgstr "读取视频信息"
+
+#: upscaler.py:446
+msgid "Aborting: No video stream found"
+msgstr "程序中止：文件中未找到视频流"
+
+#: upscaler.py:464
+msgid "Unsupported pixel format: {}"
+msgstr "不支持的像素格式：{}"
+
+#: upscaler.py:467
+msgid "Framerate: {}"
+msgstr "帧率：{}"
+
+#: upscaler.py:482
+msgid "Converting extracted frames into video"
+msgstr "将提取的帧转换为视频"
+
+#: upscaler.py:487
+msgid "Conversion completed"
+msgstr "转换已完成"
+
+#: upscaler.py:490
+msgid "Migrating audio tracks and subtitles to upscaled video"
+msgstr "将音轨和字幕迁移到放大后的视频"
+
+#: video2x.py:87
+msgid ""
+"Video2X Version: {}\n"
+"Author: K4YT3X\n"
+"License: GNU GPL v3\n"
+"Github Page: https://github.com/k4yt3x/video2x\n"
+"Contact: k4yt3x@k4yt3x.com"
+msgstr ""
+"Video2X 版本： {}\n"
+"作者： K4YT3X\n"
+"开源许可： GNU GPL v3\n"
+"GitHub 主页：https://github.com/k4yt3x/video2x\n"
+"联系方式：k4yt3x@k4yt3x.com"
+
+#: video2x.py:109
+msgid "General Options"
+msgstr "通用选项"
+
+#: video2x.py:110
+msgid "show this help message and exit"
+msgstr "显示此帮助消息并退出"
+
+#: video2x.py:111
+msgid "source video file/directory"
+msgstr "源视频文件/目录"
+
+#: video2x.py:112
+msgid "output video file/directory"
+msgstr "输出视频文件/目录"
+
+#: video2x.py:113
+msgid "video2x config file path"
+msgstr "video2x 配置文件路径"
+
+#: video2x.py:115
+msgid "upscaling driver"
+msgstr "视频放大驱动"
+
+#: video2x.py:116
+msgid "number of processes to use for upscaling"
+msgstr "并发进程数"
+
+#: video2x.py:117
+msgid "display version, lawful information and exit"
+msgstr "显示版本和法律信息并退出"
+
+#: video2x.py:120
+msgid "Scaling Options"
+msgstr "缩放选项"
+
+#: video2x.py:121
+msgid "output video width"
+msgstr "输出视频宽度"
+
+#: video2x.py:122
+msgid "output video height"
+msgstr "输出视频高度"
+
+#: video2x.py:123
+msgid "scaling ratio"
+msgstr "缩放比"
+
+#: video2x.py:163
+msgid "This file cannot be imported"
+msgstr "此文件无法被当作模块导入"
+
+#: video2x.py:224
+msgid "Program completed, taking {} seconds"
+msgstr "程序执行完毕，总计花费 {} 秒"
+
+#: video2x.py:227
+msgid "An exception has occurred"
+msgstr "发生了异常"
+
+#~ msgid "You must specify input video file/directory path"
+#~ msgstr "您必须指定输入视频文件/目录路径"
+
+#~ msgid "You must specify output video file/directory path"
+#~ msgstr "您必须指定输出视频文件/目录路径"
+
+#~ msgid "Selected driver accepts only scaling ratio"
+#~ msgstr "所选驱动程序仅接受缩放比率"
+
+#~ msgid "Scaling ratio must be 1 or 2 for waifu2x_ncnn_vulkan"
+#~ msgstr "waifu2x_ncnn_vulkan 的缩放比必须为 1 或 2"
+
+#~ msgid "Scaling ratio must be one of 2, 3 or 4 for srmd_ncnn_vulkan"
+#~ msgstr "srmd_ncnn_vulkan 的缩放比必须为 2、3 或 4"
+
+#~ msgid "You can only specify either scaling ratio or output width and height"
+#~ msgstr "您只能指定缩放比或输出宽度和高度两者之一"
+
+#~ msgid "You must specify both width and height"
+#~ msgstr "您必须同时指定宽度和高度"
+
+#~ msgid "Upscaling videos in directory: {}"
+#~ msgstr "放大该文件夹中的所有视频：{}"
--- a/src/progress_monitor.py
+++ b/src/progress_monitor.py
@@ -0,0 +1,61 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Name: Video2X Upscale Progress Monitor
+Author: BrianPetkovsek
+Date Created: May 7, 2020
+Last Modified: May 7, 2020
+"""
+
+# built-in imports
+import contextlib
+import threading
+import time
+
+# third-party imports
+from tqdm import tqdm
+
+
+class ProgressMonitor(threading.Thread):
+    """ progress monitor
+
+    This class provides progress monitoring functionalities
+    by keeping track of the amount of frames in the input
+    directory and the output directory. This is originally
+    suggested by @ArmandBernard.
+    """
+
+    def __init__(self, upscaler, extracted_frames_directories):
+        threading.Thread.__init__(self)
+        self.upscaler = upscaler
+        self.extracted_frames_directories = extracted_frames_directories
+        self.running = False
+
+    def run(self):
+        self.running = True
+        
+        # get number of extracted frames
+        self.upscaler.total_frames = 0
+        for directory in self.extracted_frames_directories:
+            self.upscaler.total_frames += len([f for f in directory.iterdir() if str(f).lower().endswith(self.upscaler.image_format.lower())])
+
+        with tqdm(total=self.upscaler.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 self.running:
+
+                with contextlib.suppress(FileNotFoundError):
+                    self.upscaler.total_frames_upscaled = len([f for f in self.upscaler.upscaled_frames.iterdir() if str(f).lower().endswith(self.upscaler.image_format.lower())])
+
+                    # update progress bar
+                    delta = self.upscaler.total_frames_upscaled - previous_cycle_frames
+                    previous_cycle_frames = self.upscaler.total_frames_upscaled
+                    progress_bar.update(delta)
+
+                time.sleep(1)
+
+    def stop(self):
+        self.running = False
+        self.join()
--- a/src/requirements.txt
+++ b/src/requirements.txt
@@ -1,7 +1,9 @@
 avalon_framework
 colorama
-GPUtil
+patool
 psutil
+pyqt5
+pyunpack
 pyyaml
 requests
-tqdm
+tqdm
--- a/src/upscaler.py
+++ b/src/upscaler.py
@@ -4,32 +4,33 @@
 Name: Video2X Upscaler
 Author: K4YT3X
 Date Created: December 10, 2018
-Last Modified: December 11, 2019
+Last Modified: May 7, 2020

-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 file contains the Upscaler class. Each
+instance of the Upscaler class is an upscaler on an image or
+a folder.
 """

 # 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
+from progress_monitor import ProgressMonitor
+from wrappers.ffmpeg import Ffmpeg

 # built-in imports
 from fractions import Fraction
 import contextlib
 import copy
+import gettext
+import importlib
+import locale
+import os
 import pathlib
+import queue
 import re
 import shutil
+import subprocess
+import sys
 import tempfile
 import threading
 import time
@@ -37,9 +38,26 @@ import traceback

 # third-party imports
 from avalon_framework import Avalon
-from tqdm import tqdm

-AVAILABLE_DRIVERS = ['waifu2x_caffe', 'waifu2x_converter', 'waifu2x_ncnn_vulkan', 'anime4k']
+# internationalization constants
+DOMAIN = 'video2x'
+LOCALE_DIRECTORY = pathlib.Path(__file__).parent.absolute() / 'locale'
+
+# getting default locale settings
+default_locale, encoding = locale.getdefaultlocale()
+language = gettext.translation(DOMAIN, LOCALE_DIRECTORY, [default_locale], fallback=True)
+language.install()
+_ = language.gettext
+
+# these names are consistent for
+# - driver selection in command line
+# - driver wrapper file names
+# - config file keys
+AVAILABLE_DRIVERS = ['waifu2x_caffe',
+                     'waifu2x_converter_cpp',
+                     'waifu2x_ncnn_vulkan',
+                     'srmd_ncnn_vulkan',
+                     'anime4kcpp']


 class Upscaler:
@@ -51,32 +69,55 @@ class Upscaler:
        ArgumentError -- if argument is not valid
    """

-    def __init__(self, input_video, output_video, method, driver_settings, ffmpeg_settings):
+    def __init__(self, input_path, output_path, driver_settings, ffmpeg_settings):
        # mandatory arguments
-        self.input_video = input_video
-        self.output_video = output_video
-        self.method = method
+        self.input_path = input_path
+        self.output_path = output_path
        self.driver_settings = driver_settings
        self.ffmpeg_settings = ffmpeg_settings

        # optional arguments
-        self.waifu2x_driver = 'waifu2x_caffe'
+        self.driver = 'waifu2x_caffe'
        self.scale_width = None
        self.scale_height = None
        self.scale_ratio = None
-        self.model_dir = None
-        self.threads = 5
+        self.processes = 1
        self.video2x_cache_directory = pathlib.Path(tempfile.gettempdir()) / 'video2x'
        self.image_format = 'png'
        self.preserve_frames = False

+        # other internal members and signals
+        self.stop_signal = False
+        self.total_frames_upscaled = 0
+        self.total_frames = 0
+
    def create_temp_directories(self):
-        """create temporary directory
+        """create temporary directories
        """
+
+        # if cache directory unspecified, use %TEMP%\video2x
+        if self.video2x_cache_directory is None:
+            self.video2x_cache_directory = pathlib.Path(tempfile.gettempdir()) / 'video2x'
+
+        # if specified cache path exists and isn't a directory
+        if self.video2x_cache_directory.exists() and not self.video2x_cache_directory.is_dir():
+            Avalon.error(_('Specified or default cache directory is a file/link'))
+            raise FileExistsError('Specified or default cache directory is a file/link')
+        
+        # if cache directory doesn't exist, try creating it
+        if not self.video2x_cache_directory.exists():
+            try:
+                Avalon.debug_info(_('Creating cache directory {}').format(self.video2x_cache_directory))
+                self.video2x_cache_directory.mkdir(parents=True, exist_ok=True)
+            except Exception as exception:
+                Avalon.error(_('Unable to create {}').format(self.video2x_cache_directory))
+                raise exception
+
+        # create temp directories for extracted frames and upscaled frames
        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}')
+        Avalon.debug_info(_('Extracted frames are being saved to: {}').format(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}')
+        Avalon.debug_info(_('Upscaled frames are being saved to: {}').format(self.upscaled_frames))

    def cleanup_temp_directories(self):
        """delete temp directories when done
@@ -86,59 +127,81 @@ class Upscaler:
                try:
                    # avalon framework cannot be used if python is shutting down
                    # therefore, plain print is used
-                    print(f'Cleaning up cache directory: {directory}')
+                    print(_('Cleaning up cache directory: {}').format(directory))
                    shutil.rmtree(directory)
                except (OSError, FileNotFoundError):
-                    print(f'Unable to delete: {directory}')
+                    print(_('Unable to delete: {}').format(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')
+        # if input is a file
+        if self.input_path.is_file():
+            if self.output_path.is_dir():
+                Avalon.error(_('Input and output path type mismatch'))
+                Avalon.error(_('Input is single file but output is directory'))
+                raise ArgumentError('input output path type mismatch')
+            if not re.search(r'.*\..*$', str(self.output_path)):
+                Avalon.error(_('No suffix found in output file path'))
+                Avalon.error(_('Suffix must be specified for FFmpeg'))
+                raise ArgumentError('no output video suffix specified')

-    def _progress_bar(self, extracted_frames_directories):
-        """ This method prints a progress bar
+        # if input is a directory
+        elif self.input_path.is_dir():
+            if self.output_path.is_file():
+                Avalon.error(_('Input and output path type mismatch'))
+                Avalon.error(_('Input is directory but output is existing single file'))
+                raise ArgumentError('input output path type mismatch')

-        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.
-        """
+        # if input is neither
+        else:
+            Avalon.error(_('Input path is neither a file nor a directory'))
+            raise FileNotFoundError(f'{self.input_path} is neither file nor directory')
+        
+        # check Fmpeg settings
+        ffmpeg_path = pathlib.Path(self.ffmpeg_settings['ffmpeg_path'])
+        if not ((pathlib.Path(ffmpeg_path / 'ffmpeg.exe').is_file() and
+                pathlib.Path(ffmpeg_path / 'ffprobe.exe').is_file()) or
+                (pathlib.Path(ffmpeg_path / 'ffmpeg').is_file() and
+                pathlib.Path(ffmpeg_path / 'ffprobe').is_file())):
+            Avalon.error(_('FFmpeg or FFprobe cannot be found under the specified path'))
+            Avalon.error(_('Please check the configuration file settings'))
+            raise FileNotFoundError(self.ffmpeg_settings['ffmpeg_path'])

-        # 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}'])
+        # check if driver settings
+        driver_settings = copy.deepcopy(self.driver_settings)
+        driver_path = driver_settings.pop('path')

-        with tqdm(total=self.total_frames, ascii=True, desc='Upscaling Progress') as progress_bar:
+        # check if driver path exists
+        if not (pathlib.Path(driver_path).is_file() or pathlib.Path(f'{driver_path}.exe').is_file()):
+            Avalon.error(_('Specified driver executable directory doesn\'t exist'))
+            Avalon.error(_('Please check the configuration file settings'))
+            raise FileNotFoundError(driver_path)

-            # 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:
+        # parse driver arguments using driver's parser
+        # the parser will throw AttributeError if argument doesn't satisfy constraints
+        try:
+            driver_arguments = []
+            for key in driver_settings.keys():

-                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
+                value = driver_settings[key]

-                    # if upscaling is finished
-                    if self.total_frames_upscaled >= self.total_frames:
-                        return
+                if value is None or value is False:
+                    continue

-                    # adds the delta into the progress bar
-                    progress_bar.update(delta)
+                else:
+                    if len(key) == 1:
+                        driver_arguments.append(f'-{key}')
+                    else:
+                        driver_arguments.append(f'--{key}')
+                    # true means key is an option
+                    if value is not True:
+                        driver_arguments.append(str(value))

-                time.sleep(1)
+            DriverWrapperMain = getattr(importlib.import_module(f'wrappers.{self.driver}'), 'WrapperMain')
+            DriverWrapperMain.parse_arguments(driver_arguments)
+        except AttributeError as e:
+            Avalon.error(_('Failed to parse driver argument: {}').format(e.args[0]))
+            raise e

    def _upscale_frames(self):
        """ Upscale video frames with waifu2x-caffe
@@ -150,220 +213,288 @@ class Upscaler:
            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}')
+        if self.driver not in AVAILABLE_DRIVERS:
+            raise UnrecognizedDriverError(_('Unrecognized driver: {}').format(self.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.driver_settings, self.model_dir)
+        # list all images in the extracted frames
+        frames = [(self.extracted_frames / f) for f in self.extracted_frames.iterdir() if f.is_file]

-            progress_bar = threading.Thread(target=self._progress_bar, args=([self.extracted_frames],))
-            progress_bar.start()
+        # if we have less images than processes,
+        # create only the processes necessary
+        if len(frames) < self.processes:
+            self.processes = len(frames)

-            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)
+        # create a directory for each process and append directory
+        # name into a list
+        process_directories = []
+        for process_id in range(self.processes):
+            process_directory = self.extracted_frames / str(process_id)
+            process_directories.append(process_directory)

-            self.progress_bar_exit_signal = True
-            progress_bar.join()
-            return
+            # delete old directories and create new directories
+            if process_directory.is_dir():
+                shutil.rmtree(process_directory)
+            process_directory.mkdir(parents=True, exist_ok=True)
+
+        # waifu2x-converter-cpp will perform multi-threading within its own process
+        if self.driver == 'waifu2x_converter_cpp':
+            process_directories = [self.extracted_frames]

-        # 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)
+                image.rename(process_directories[0] / image.name)
                # rotate list
-                thread_pool = thread_pool[-1:] + thread_pool[:-1]
+                process_directories = process_directories[-1:] + process_directories[:-1]

-            # create threads and start them
-            for thread_info in thread_pool:
+        # create threads and start them
+        for process_directory in process_directories:
+
+            DriverWrapperMain = getattr(importlib.import_module(f'wrappers.{self.driver}'), 'WrapperMain')
+            driver = DriverWrapperMain(copy.deepcopy(self.driver_settings))
+
+            # if the driver being used is waifu2x-caffe
+            if self.driver == 'waifu2x_caffe':
+                self.process_pool.append(driver.upscale(process_directory,
+                                                         self.upscaled_frames,
+                                                         self.scale_ratio,
+                                                         self.scale_width,
+                                                         self.scale_height,
+                                                         self.image_format,
+                                                         self.bit_depth))
+
+            # if the driver being used is waifu2x-converter-cpp
+            elif self.driver == 'waifu2x_converter_cpp':
+                self.process_pool.append(driver.upscale(process_directory,
+                                                         self.upscaled_frames,
+                                                         self.scale_ratio,
+                                                         self.processes,
+                                                         self.image_format))
+
+            # if the driver being used is waifu2x-ncnn-vulkan
+            elif self.driver == 'waifu2x_ncnn_vulkan':
+                self.process_pool.append(driver.upscale(process_directory,
+                                                         self.upscaled_frames,
+                                                         self.scale_ratio))
+
+            # if the driver being used is srmd_ncnn_vulkan
+            elif self.driver == 'srmd_ncnn_vulkan':
+                self.process_pool.append(driver.upscale(process_directory,
+                                                         self.upscaled_frames,
+                                                         self.scale_ratio))
+
+        # start progress bar in a different thread
+        Avalon.debug_info(_('Starting progress monitor'))
+        self.progress_monitor = ProgressMonitor(self, process_directories)
+        self.progress_monitor.start()
+
+        # create the clearer and start it
+        Avalon.debug_info(_('Starting upscaled image cleaner'))
+        self.image_cleaner = ImageCleaner(self.extracted_frames, self.upscaled_frames, len(self.process_pool))
+        self.image_cleaner.start()
+
+        # wait for all process to exit
+        try:
+            self._wait()
+        except (Exception, KeyboardInterrupt, SystemExit) as e:
+            # cleanup
+            Avalon.debug_info(_('Killing progress monitor'))
+            self.progress_monitor.stop()
+
+            Avalon.debug_info(_('Killing upscaled image cleaner'))
+            self.image_cleaner.stop()            
+            raise e
+
+        # if the driver is waifu2x-converter-cpp
+        # images need to be renamed to be recognizable for FFmpeg
+        if self.driver == 'waifu2x_converter_cpp':
+            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.name))
+                (self.upscaled_frames / image).rename(self.upscaled_frames / renamed)
+
+        # upscaling done, kill helper threads
+        Avalon.debug_info(_('Killing progress monitor'))
+        self.progress_monitor.stop()
+
+        Avalon.debug_info(_('Killing upscaled image cleaner'))
+        self.image_cleaner.stop()
+
+    def _terminate_subprocesses(self):
+        Avalon.warning(_('Terminating all processes'))
+        for process in self.process_pool:
+            process.terminate()
+
+    def _wait(self):
+        """ wait for subprocesses in process pool to complete
+        """
+        Avalon.debug_info(_('Main process waiting for subprocesses to exit'))
+
+        try:
+            # while process pool not empty
+            while self.process_pool:
+                
+                # if stop signal received, terminate all processes
+                if self.stop_signal is True:
+                    raise SystemExit
+
+                for process in self.process_pool:
+                    process_status = process.poll()
+
+                    # if process finished
+                    if process_status is None:
+                        continue
+
+                    # if return code is not 0
+                    elif process_status != 0:
+                        Avalon.error(_('Subprocess {} exited with code {}').format(process.pid, process_status))
+                        raise subprocess.CalledProcessError(process_status, process.args)

-                # create a separate w2 instance for each thread
-                if self.waifu2x_driver == 'waifu2x_caffe':
-                    w2 = Waifu2xCaffe(copy.deepcopy(self.driver_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))
+                        Avalon.debug_info(_('Subprocess {} exited with code {}').format(process.pid, process_status))
+                        self.process_pool.remove(process)

-                # if the driver being used is waifu2x_ncnn_vulkan
-                elif self.waifu2x_driver == 'waifu2x_ncnn_vulkan':
-                    w2 = Waifu2xNcnnVulkan(copy.deepcopy(self.driver_settings))
-                    thread = threading.Thread(target=w2.upscale,
-                                              args=(thread_info[0],
-                                                    self.upscaled_frames,
-                                                    self.scale_ratio,
-                                                    self.upscaler_exceptions))
+                time.sleep(0.1)

-                # if the driver being used is anime4k
-                elif self.waifu2x_driver == 'anime4k':
-                    w2 = Anime4k(copy.deepcopy(self.driver_settings))
-                    thread = threading.Thread(target=w2.upscale,
-                                              args=(thread_info[0],
-                                                    self.upscaled_frames,
-                                                    self.scale_ratio,
-                                                    self.upscaler_exceptions))
+        except (KeyboardInterrupt, SystemExit) as e:
+            Avalon.warning(_('Stop signal received'))
+            self._terminate_subprocesses()
+            raise e

-                # 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])
+        except (Exception, subprocess.CalledProcessError) as e:
+            Avalon.error(_('Subprocess execution ran into an error'))
+            self._terminate_subprocesses()
+            raise e

    def run(self):
-        """Main controller for Video2X
+        """ Main controller for Video2X

        This function controls the flow of video conversion
        and handles all necessary functions.
        """
+        
+        # external stop signal when called in a thread
+        self.stop_signal = False
+
+        # define process pool to contain processes
+        self.process_pool = []

        # 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()
+        # define processing queue
+        processing_queue = queue.Queue()

-        # initialize objects for ffmpeg and waifu2x-caffe
-        fm = Ffmpeg(self.ffmpeg_settings, self.image_format)
+        # if input specified is single file
+        if self.input_path.is_file():
+            Avalon.info(_('Upscaling single video file: {}').format(self.input_path))
+            processing_queue.put((self.input_path.absolute(), self.output_path.absolute()))

-        # extract frames from video
-        fm.extract_frames(self.input_video, self.extracted_frames)
+        # if input specified is a directory
+        elif self.input_path.is_dir():

-        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']
+            # make output directory if it doesn't exist
+            self.output_path.mkdir(parents=True, exist_ok=True)
+            for input_video in [f for f in self.input_path.iterdir() if f.is_file()]:
+                output_video = self.output_path / input_video.name
+                processing_queue.put((input_video.absolute(), output_video.absolute()))

-        # 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
+        while not processing_queue.empty():
+            input_video, output_video = processing_queue.get()
+            # drivers that have native support for video processing
+            if self.driver == 'anime4kcpp':
+                # append FFmpeg path to the end of PATH
+                # Anime4KCPP will then use FFmpeg to migrate audio tracks
+                os.environ['PATH'] += f';{self.ffmpeg_settings["ffmpeg_path"]}'
+                Avalon.info(_('Starting to upscale extracted images'))

-        # 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')
+                # import and initialize Anime4KCPP wrapper
+                DriverWrapperMain = getattr(importlib.import_module('wrappers.anime4kcpp'), 'WrapperMain')
+                driver = DriverWrapperMain(copy.deepcopy(self.driver_settings))

-        # 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']
+                # run Anime4KCPP
+                self.process_pool.append(driver.upscale(input_video, output_video, self.scale_ratio, self.processes))
+                self._wait()
+                Avalon.info(_('Upscaling completed'))

-        # get a dict of all pixel formats and corresponding bit depth
-        pixel_formats = fm.get_pixel_formats()
+            else:
+                try:
+                    self.create_temp_directories()

-        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}')
+                    # initialize objects for ffmpeg and waifu2x-caffe
+                    fm = Ffmpeg(self.ffmpeg_settings, self.image_format)

-        Avalon.info(f'Framerate: {framerate}')
+                    Avalon.info(_('Reading video information'))
+                    video_info = fm.get_video_info(input_video)
+                    # analyze original video with ffprobe and retrieve framerate
+                    # width, height = info['streams'][0]['width'], info['streams'][0]['height']

-        # 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)
+                    # 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

-        # upscale images one by one using waifu2x
-        Avalon.info('Starting to upscale extracted images')
-        self._upscale_frames()
-        Avalon.info('Upscaling completed')
+                    # 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')

-        # frames to Video
-        Avalon.info('Converting extracted frames into video')
+                    # extract frames from video
+                    self.process_pool.append((fm.extract_frames(input_video, self.extracted_frames)))
+                    self._wait()

-        # use user defined output size
-        fm.convert_video(framerate, f'{self.scale_width}x{self.scale_height}', self.upscaled_frames)
-        Avalon.info('Conversion completed')
+                    # 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']

-        # 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)
+                    # get a dict of all pixel formats and corresponding bit depth
+                    pixel_formats = fm.get_pixel_formats()
+
+                    # try getting pixel format's corresponding bti depth
+                    try:
+                        self.bit_depth = pixel_formats[fm.pixel_format]
+                    except KeyError:
+                        Avalon.error(_('Unsupported pixel format: {}').format(fm.pixel_format))
+                        raise UnsupportedPixelError(f'unsupported pixel format {fm.pixel_format}')
+
+                    Avalon.info(_('Framerate: {}').format(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
+                    self.process_pool.append(fm.convert_video(framerate, f'{self.scale_width}x{self.scale_height}', self.upscaled_frames))
+                    self._wait()
+                    Avalon.info(_('Conversion completed'))
+
+                    # migrate audio tracks and subtitles
+                    Avalon.info(_('Migrating audio tracks and subtitles to upscaled video'))
+                    self.process_pool.append(fm.migrate_audio_tracks_subtitles(input_video, output_video, self.upscaled_frames))
+                    self._wait()
+
+                    # destroy temp directories
+                    self.cleanup_temp_directories()
+
+                except (Exception, KeyboardInterrupt, SystemExit) as e:
+                    with contextlib.suppress(ValueError):
+                        self.cleanup_temp_directories()
+                    raise e
--- a/src/video2x.json
+++ b/src/video2x.json
@@ -1,102 +0,0 @@
-{
-  "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
-  }
-}
--- a/src/video2x.py
+++ b/src/video2x.py
@@ -13,10 +13,16 @@ __      __  _       _                  ___   __   __
 Name: Video2X Controller
 Creator: K4YT3X
 Date Created: Feb 24, 2018
-Last Modified: January 4, 2020
+Last Modified: May 7, 2020

 Editor: BrianPetkovsek
+Last Modified: June 17, 2019
+
 Editor: SAT3LL
+Last Modified: June 25, 2019
+
+Editor: 28598519a
+Last Modified: March 23, 2020

 Licensed under the GNU General Public License Version 3 (GNU GPL v3),
    available at: https://www.gnu.org/licenses/gpl-3.0.txt
@@ -34,7 +40,7 @@ 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/>.
+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
@@ -43,13 +49,16 @@ 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 gettext
+import importlib
+import locale
+import os
 import pathlib
 import re
 import shutil
@@ -61,17 +70,25 @@ import yaml

 # third-party imports
 from avalon_framework import Avalon
-import GPUtil
-import psutil
+
+# internationalization constants
+DOMAIN = 'video2x'
+LOCALE_DIRECTORY = pathlib.Path(__file__).parent.absolute() / 'locale'
+
+# getting default locale settings
+default_locale, encoding = locale.getdefaultlocale()
+language = gettext.translation(DOMAIN, LOCALE_DIRECTORY, [default_locale], fallback=True)
+language.install()
+_ = language.gettext


-VERSION = '3.0.0'
+VERSION = '4.0.0'

-LEGAL_INFO = f'''Video2X Version: {VERSION}
+LEGAL_INFO = _('''Video2X Version: {}
 Author: K4YT3X
 License: GNU GPL v3
 Github Page: https://github.com/k4yt3x/video2x
-Contact: k4yt3x@k4yt3x.com'''
+Contact: k4yt3x@k4yt3x.com''').format(VERSION)

 LOGO = r'''
    __      __  _       _                  ___   __   __
@@ -82,47 +99,40 @@ LOGO = r'''
        \/     |_|  \__,_|  \___|  \___/  |____| /_/ \_\
 '''

-# 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 parse_arguments():
-    """Processes CLI arguments
-
-    This function parses all arguments
-    This allows users to customize options
-    for the output video.
+    """ parse CLI arguments
    """
-    parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+    parser = argparse.ArgumentParser(prog='video2x', formatter_class=argparse.ArgumentDefaultsHelpFormatter, add_help=False)

    # 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.yaml')
-    upscaler_options.add_argument('-b', '--batch', help='enable batch mode (select all default values to questions)', action='store_true')
+    general_options = parser.add_argument_group(_('General Options'))
+    general_options.add_argument('-h', '--help', action='help', help=_('show this help message and exit'))
+    general_options.add_argument('-i', '--input', type=pathlib.Path, help=_('source video file/directory'))
+    general_options.add_argument('-o', '--output', type=pathlib.Path, help=_('output video file/directory'))
+    general_options.add_argument('-c', '--config', type=pathlib.Path, help=_('video2x config file path'), action='store',
+                                 default=pathlib.Path(__file__).parent.absolute() / 'video2x.yaml')
+    general_options.add_argument('-d', '--driver', help=_('upscaling driver'), choices=AVAILABLE_DRIVERS, default='waifu2x_caffe')
+    general_options.add_argument('-p', '--processes', help=_('number of processes to use for upscaling'), action='store', type=int, default=1)
+    general_options.add_argument('-v', '--version', help=_('display version, lawful information and exit'), 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)
+    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')
+    # if no driver arguments are specified
+    if '--' not in sys.argv:
+        video2x_args = parser.parse_args()
+        return video2x_args, None

-    # parse arguments
-    return parser.parse_args()
+    # if driver arguments are specified
+    else:
+        video2x_args = parser.parse_args(sys.argv[1:sys.argv.index('--')])
+        wrapper = getattr(importlib.import_module(f'wrappers.{video2x_args.driver}'), 'WrapperMain')
+        driver_args = wrapper.parse_arguments(sys.argv[sys.argv.index('--') + 1:])
+        return video2x_args, driver_args


 def print_logo():
@@ -132,61 +142,6 @@ def print_logo():
    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 in ['gpu', '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: pathlib.Path) -> dict:
    """ read video2x configurations from config file

@@ -201,246 +156,73 @@ def read_config(config_file: pathlib.Path) -> dict:
        return yaml.load(config, Loader=yaml.FullLoader)


-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')
+    Avalon.error(_('This file cannot be imported'))
    raise ImportError(f'{__file__} cannot be imported')

 # print video2x logo
 print_logo()

 # parse command line arguments
-args = parse_arguments()
+video2x_args, driver_args = parse_arguments()

 # display version and lawful informaition
-if args.version:
+if video2x_args.version:
    print(LEGAL_INFO)
    sys.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 is not None 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?', default=True, batch=args.batch):
-        while True:
-            try:
-                threads = Avalon.gets('Amount of threads to use [5]: ', default=5, batch=args.batch)
-                args.threads = int(threads)
-                break
-            except ValueError:
-                if threads == '':
-                    args.threads = 5
-                    break
-                Avalon.error(f'{threads} is not a valid integer')
-
 # read configurations from configuration file
-config = read_config(args.config)
-
-# config = absolutify_paths(config)
+config = read_config(video2x_args.config)

 # load waifu2x configuration
-driver_settings = config[args.driver]
-
-# check if driver path exists
-if not pathlib.Path(driver_settings['path']).is_file():
-    if not pathlib.Path(f'{driver_settings["path"]}.exe').is_file():
-        Avalon.error('Specified driver executable directory doesn\'t exist')
-        Avalon.error('Please check the configuration file settings')
-        raise FileNotFoundError(driver_settings['path'])
-
-# if the driver is Anime4K, check if JDK 12 is installed
-if args.driver == 'anime4k':
-    if not pathlib.Path('C:/Program Files/Java/jdk-12.0.2/bin/java.exe').is_file():
-        Avalon.warning('Cannot find JDK 12 at its default installation location')
-        Avalon.warning('Please ensure you have JDK 12 installed and configured')
+driver_settings = config[video2x_args.driver]
+driver_settings['path'] = os.path.expandvars(driver_settings['path'])

 # read FFmpeg configuration
 ffmpeg_settings = config['ffmpeg']
+ffmpeg_settings['ffmpeg_path'] = os.path.expandvars(ffmpeg_settings['ffmpeg_path'])

 # load video2x settings
 image_format = config['video2x']['image_format'].lower()
 preserve_frames = config['video2x']['preserve_frames']
+video2x_cache_directory = config['video2x']['video2x_cache_directory']

-# 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')
-
+# overwrite driver_settings with driver_args
+if driver_args is not None:
+    driver_args_dict = vars(driver_args)
+    for key in driver_args_dict:
+        if driver_args_dict[key] is not None:
+            driver_settings[key] = driver_args_dict[key]

 # start execution
 try:
    # start timer
    begin_time = time.time()

-    # if input specified is a single file
-    if args.input.is_file():
+    # initialize upscaler object
+    upscaler = Upscaler(input_path=video2x_args.input,
+                        output_path=video2x_args.output,
+                        driver_settings=driver_settings,
+                        ffmpeg_settings=ffmpeg_settings)

-        # upscale single video file
-        Avalon.info(f'Upscaling single video file: {args.input}')
+    # set upscaler optional options
+    upscaler.driver = video2x_args.driver
+    upscaler.scale_width = video2x_args.width
+    upscaler.scale_height = video2x_args.height
+    upscaler.scale_ratio = video2x_args.ratio
+    upscaler.processes = video2x_args.processes
+    upscaler.video2x_cache_directory = video2x_cache_directory
+    upscaler.image_format = image_format
+    upscaler.preserve_frames = preserve_frames

-        # 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')
+    # run upscaler
+    upscaler.run()

-        upscaler = Upscaler(input_video=args.input, output_video=args.output, method=args.method, driver_settings=driver_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, driver_settings=driver_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')
+    Avalon.info(_('Program completed, taking {} seconds').format(round((time.time() - begin_time), 5)))

 except Exception:
-    Avalon.error('An exception has occurred')
+    Avalon.error(_('An exception has occurred'))
    traceback.print_exc()
-
-    # try cleaning up temp directories
-    with contextlib.suppress(Exception):
-        upscaler.cleanup_temp_directories()
-
-finally:
-    # remove Video2X cache directory
-    with contextlib.suppress(FileNotFoundError):
-        if not preserve_frames:
-            shutil.rmtree(video2x_cache_directory)
--- a/src/video2x.yaml
+++ b/src/video2x.yaml
@@ -1,89 +1,133 @@
---
+# Name: Video2X Configuration File
+# Creator: K4YT3X
+# Date Created: October 23, 2018
+# Last Modified: May 7, 2020
+# Items commented out are parameters handled by Video2x.
 waifu2x_caffe:
-  path: C:\Users\K4YT3X\AppData\Local\video2x\waifu2x-caffe\waifu2x-caffe-cui
-  input_extention_list:
-  output_extention:
-  mode: noise_scale
-  scale_ratio:
-  scale_width:
-  scale_height:
-  noise_level: 3
-  process: gpu
-  crop_size: 128
-  output_quality: -1
-  output_depth: 8
-  batch_size: 1
-  gpu: 0
-  tta: 0
-  input_path:
-  output_path:
-  model_dir:
-  crop_w:
-  crop_h:
-waifu2x_converter:
-  path: C:\Users\K4YT3X\AppData\Local\video2x\waifu2x-converter-cpp
-  output-format:
-  png-compression:
-  image-quality:
-  block-size:
-  disable-gpu:
-  force-OpenCL:
-  processor:
-  jobs:
-  model-dir:
-  scale-ratio:
-  noise-level: 3
-  mode: noise-scale
-  silent: true
-  output:
-  input:
+  path: '%LOCALAPPDATA%\video2x\waifu2x-caffe\waifu2x-caffe-cui'
+  tta: 0 # <0|1> 8x slower and slightly high quality
+  gpu: 0 # gpu device no
+  batch_size: 1 # input batch size
+  crop_h: null # input image split size(height)
+  crop_w: null # input image split size(width)
+  crop_size: 128 # input image split size
+  output_depth: 8 # output image chaneel depth bit
+  output_quality: -1 # output image quality
+  process: gpu # <cpu|gpu|cudnn> process mode
+  model_dir: null # path to custom model directory (don't append last / )
+  #scale_height: null # custom scale height
+  #scale_width: null # custom scale width
+  #scale_ratio: null # custom scale ratio
+  noise_level: 3 # <0|1|2|3> noise reduction level
+  mode: noise_scale # <noise|scale|noise_scale|auto_scale> image processing mode
+  output_extention: null # extention to output image file when output_path is (auto) or input_path is folder
+  input_extention_list: null # extention to input image file when input_path is folder
+  #output_path: null # path to output image file (when input_path is folder, output_path must be folder)
+  #input_path: null # (required) path to input image file
+waifu2x_converter_cpp:
+  path: '%LOCALAPPDATA%\video2x\waifu2x-converter-cpp\waifu2x-converter-cpp'
+  #list-supported-formats: null # dump currently supported format list
+  #list-opencv-formats: null # (deprecated. Use --list-supported-formats) dump opencv supported format list
+  #list-processor # dump processor list
+  output-format: null # The format used when running in recursive/folder mode
+  png-compression: 5 # Set PNG compression level (0-9), 9 = Max compression (slowest & smallest)
+  image-quality: -1 # JPEG & WebP Compression quality (0-101, 0 being smallest size and lowest quality), use 101 for lossless WebP
+  block-size: 0 # block size
+  disable-gpu: false # disable GPU
+  force-OpenCL: false # force to use OpenCL on Intel Platform
+  processor: -1 # set target processor
+  jobs: 0 # number of threads launching at the same time
+  model-dir: null # path to custom model directory (don't append last / ) default: models_rgb 
+  #scale-ratio: 2.0 # custom scale ratio
+  noise-level: 1 # <0|1|2|3> noise reduction level
+  mode: noise-scale # <noise|scale|noise-scale> image processing mode
+  log-level: 1 # <0|1|2|3|4> Set log level
+  silent: true # Enable silent mode. (same as --log-level 1)
+  tta: 0 # Enable Test-Time Augmentation mode. (0 or 1)
+  #generate-subdir: 0 # Generate sub folder when recursive directory is enabled.
+  #auto-naming: 0 # Add postfix to output name when output path is not specified.
+  #recursive-directory: 0 # Search recursively through directories to find more images to process.
+  #output: null # path to output image file or directory  (you should use the full path)
+  #input: null # (required) path to input image file or directory (you should use the full path)
 waifu2x_ncnn_vulkan:
-  path: C:\Users\K4YT3X\AppData\Local\video2x\waifu2x-ncnn-vulkan\waifu2x-ncnn-vulkan
-  v:
-  i:
-  o:
-  n: 2
-  s: 2
-  t: 400
-  m: models-cunet
-  g: 0
-  j: "1:2:2"
-anime4k:
-  path: C:\Users\K4YT3X\AppData\Local\video2x\anime4k\Anime4K.jar
-  java_path: C:\Program Files\Java\jdk-12.0.2\bin\java.exe
+  path: '%LOCALAPPDATA%\video2x\waifu2x-ncnn-vulkan\waifu2x-ncnn-vulkan'
+  v: null # verbose output
+  #i: null # input-path: input image path (jpg/png) or directory
+  #o: null # output-path: output image path (png) or directory
+  'n': 2 # noise-level: denoise level (-1/0/1/2/3, default=0)
+  s: 2 # scale: upscale ratio (1/2, default=2)
+  t: 400 # tile-size: tile size (>=32, default=400)
+  m: null # model-path: waifu2x model path (default=models-cunet)
+  g: 0 # gpu-id: gpu device to use (default=0)
+  j: '1:2:2' # thread count for load/proc/save (default=1:2:2)
+  x: false # enable tta mode
+srmd_ncnn_vulkan:
+  path: '%LOCALAPPDATA%\video2x\srmd-ncnn-vulkan\srmd-ncnn-vulkan'
+  v: null # verbose output
+  #i: null # input-path: input image path (jpg/png) or directory
+  #o: null # output-path: output image path (png) or directory
+  'n': 3 # noise-level: denoise level (-1/0/1/2/3/4/5/6/7/8/9/10, default=3)
+  s: 2 # upscale ratio (2/3/4, default=2)
+  t: 400 # tile-size: tile size (>=32, default=400)
+  m: null # srmd model path (default=models-srmd)
+  g: 0 # gpu device to use (default=0)
+  j: '1:2:2' # thread count for load/proc/save (default=1:2:2)
+  x: false # enable tta mode
+anime4kcpp:
+  path: '%LOCALAPPDATA%\video2x\anime4kcpp\CLI\Anime4KCPP_CLI\Anime4KCPP_CLI'
+  #input: null # File for loading (string [=./pic/p1.png])
+  #output: null # File for outputting (string [=output.png])
+  passes: 2 # Passes for processing (int [=2])
+  pushColorCount: 2 # Limit the number of color pushes (int [=2])
+  strengthColor: 0.3 # Strength for pushing color,range 0 to 1,higher for thinner (double [=0.3])
+  strengthGradient: 1.0 # Strength for pushing gradient,range 0 to 1,higher for sharper (double [=1])
+  zoomFactor: 2.0 # zoom factor for resizing (double [=2])
+  threads: 16 # Threads count for video processing (unsigned int [=16])
+  fastMode: false # Faster but maybe low quality
+  videoMode: true # Video process
+  preview: null # Preview image
+  preprocessing: False # Enable pre processing
+  postprocessing: False # Enable post processing
+  preFilters: 4 # Enhancement filter, only working when preProcessing is true,there are 5 options by binary:Median blur=0000001, Mean blur=0000010, CAS Sharpening=0000100, Gaussian blur weak=0001000, Gaussian blur=0010000, Bilateral filter=0100000, Bilateral filter faster=1000000, you can freely combine them, eg: Gaussian blur weak + Bilateral filter = 0001000 | 0100000 = 0101000 = 40(D) (unsigned int [=4])
+  postFilters: 40 # Enhancement filter, only working when postProcessing is true,there are 5 options by binary:Median blur=0000001, Mean blur=0000010, CAS Sharpening=0000100, Gaussian blur weak=0001000, Gaussian blur=0010000, Bilateral filter=0100000, Bilateral filter faster=1000000, you can freely combine them, eg: Gaussian blur weak + Bilateral filter = 0001000 | 0100000 = 0101000 = 40(D), so you can put 40 to enable Gaussian blur weak and Bilateral filter, which also is what I recommend for image that < 1080P, 48 for image that >= 1080P, and for performance I recommend to use 72 for video that < 1080P, 80 for video that >=1080P (unsigned int [=40])
+  GPUMode: False # Enable GPU acceleration
+  listGPUs: null # list GPUs
+  platformID: 0 # Specify the platform ID (unsigned int [=0])
+  deviceID: 0 # Specify the device ID (unsigned int [=0])
+  codec: mp4v # Specify the codec for encoding from mp4v(recommended in Windows), dxva(for Windows), avc1(H264, recommended in Linux), vp09(very slow), hevc(not support in Windowds), av01(not support in Windowds) (string [=mp4v])
 ffmpeg:
-  ffmpeg_path: C:\Users\K4YT3X\AppData\Local\video2x\ffmpeg-latest-win64-static\bin
+  ffmpeg_path: '%LOCALAPPDATA%\video2x\ffmpeg-latest-win64-static\bin'
  video_to_frames:
    output_options:
-      "-qscale:v":
-      "-pix_fmt": rgba64be
-    "-hwaccel": auto
-    "-y": true
+      '-qscale:v': null
+      '-pix_fmt': rgba64be
+    '-hwaccel': auto
+    '-y': true
  frames_to_video:
    input_options:
-      "-qscale:v":
-      "-qscale:a":
-      "-f": image2
+      '-qscale:v': null
+      '-qscale:a': null
+      '-f': image2
    output_options:
-      "-vcodec": libx264
-      "-crf": 17
-      "-b:v":
-      "-pix_fmt":
-    "-hwaccel": auto
-    "-y": true
+      '-vcodec': libx264
+      '-crf': 17
+      '-b:v': null
+      '-pix_fmt': null
+    '-hwaccel': auto
+    '-y': true
  migrating_tracks:
    output_options:
-      "-map":
-        - 0:v?
-        - 1:a?
-        - 1:s?
-        - 1:d?
-        - 1:t?
-      "-c": copy
-      "-pix_fmt":
-    "-hwaccel": auto
-    "-y": true
+      '-map':
+        - '0:v?'
+        - '1:a?'
+        - '1:s?'
+        - '1:d?'
+        - '1:t?'
+      '-c': copy
+      '-pix_fmt': null
+    '-hwaccel': auto
+    '-y': true
 video2x:
-  video2x_cache_directory:
+  video2x_cache_directory: null # default: %TEMP%\video2x
  image_format: png
  preserve_frames: false
--- a/src/video2x_gui.py
+++ b/src/video2x_gui.py
--- a/src/video2x_gui.pyproject
+++ b/src/video2x_gui.pyproject
@@ -0,0 +1,3 @@
+{
+    "files": ["video2x_gui.ui","video2x_gui.py"]
+}
--- a/src/video2x_gui.ui
+++ b/src/video2x_gui.ui
--- a/src/video2x_setup.py
+++ b/src/video2x_setup.py
@@ -4,7 +4,7 @@
 Name: Video2X Setup Script
 Creator: K4YT3X
 Date Created: November 28, 2018
-Last Modified: January 4, 2020
+Last Modified: May 7, 2020

 Editor: BrianPetkovsek
 Editor: SAT3LL
@@ -17,7 +17,8 @@ Installation Details:
 - 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
+- anime4kcpp: %LOCALAPPDATA%\\video2x\\anime4kcpp
+- srmd_ncnn_vulkan: %LOCALAPPDATA%\\video2x\\srmd-ncnn-vulkan
 """

 # built-in imports
@@ -41,12 +42,12 @@ import zipfile
 # later in the script.
 # import requests

-VERSION = '1.6.1'
+VERSION = '1.8.0'

 # global static variables
 LOCALAPPDATA = pathlib.Path(os.getenv('localappdata'))
-VIDEO2X_CONFIG = pathlib.Path(sys.argv[0]).parent.absolute() / 'video2x.yaml'
-DRIVER_OPTIONS = ['all', 'waifu2x_caffe', 'waifu2x_converter', 'waifu2x_ncnn_vulkan', 'anime4k']
+VIDEO2X_CONFIG = pathlib.Path(__file__).parent.absolute() / 'video2x.yaml'
+DRIVER_OPTIONS = ['all', 'ffmpeg', 'waifu2x_caffe', 'waifu2x_converter_cpp', 'waifu2x_ncnn_vulkan', 'anime4kcpp', 'srmd_ncnn_vulkan']


 def parse_arguments():
@@ -79,22 +80,25 @@ class Video2xSetup:
            print('\nInstalling Python libraries')
            self._install_python_requirements()

-        print('\nInstalling FFmpeg')
-        self._install_ffmpeg()
-
        if self.driver == 'all':
+            self._install_ffmpeg()
            self._install_waifu2x_caffe()
            self._install_waifu2x_converter_cpp()
            self._install_waifu2x_ncnn_vulkan()
-            self._install_anime4k()
+            self._install_anime4kcpp()
+            self._install_srmd_ncnn_vulkan()
+        elif self.driver == 'ffmpeg':
+            self._install_ffmpeg()
        elif self.driver == 'waifu2x_caffe':
            self._install_waifu2x_caffe()
-        elif self.driver == 'waifu2x_converter':
+        elif self.driver == 'waifu2x_converter_cpp':
            self._install_waifu2x_converter_cpp()
        elif self.driver == 'waifu2x_ncnn_vulkan':
            self._install_waifu2x_ncnn_vulkan()
-        elif self.driver == 'anime4k':
-            self._install_anime4k()
+        elif self.driver == 'anime4kcpp':
+            self._install_anime4kcpp()
+        elif self.driver == 'srmd_ncnn_vulkan':
+            self._install_srmd_ncnn_vulkan()

        print('\nGenerating Video2X configuration file')
        self._generate_config()
@@ -125,6 +129,8 @@ class Video2xSetup:
    def _install_ffmpeg(self):
        """ Install FFMPEG
        """
+        print('\nInstalling FFmpeg')
+
        latest_release = 'https://ffmpeg.zeranoe.com/builds/win64/static/ffmpeg-latest-win64-static.zip'

        ffmpeg_zip = download(latest_release, tempfile.gettempdir())
@@ -193,33 +199,54 @@ class Video2xSetup:
            # rename the newly extracted directory
            (LOCALAPPDATA / 'video2x' / zipf.namelist()[0]).rename(waifu2x_ncnn_vulkan_directory)

-    def _install_anime4k(self):
-        """ Install Anime4K
+    def _install_anime4kcpp(self):
+        """ Install Anime4KCPP
        """
-        print('\nInstalling Anime4K')
+        print('\nInstalling Anime4KCPP')

-        """
+        import pyunpack
        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
+        # get latest release of Anime4KCPP via Github API
+        # at the time of writing this portion, Anime4KCPP 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]
+        latest_release = requests.get('https://api.github.com/repos/TianZerL/Anime4KCPP/releases/latest').json()

        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)
+            if re.search(r'Anime4KCPP_CLI-.*-Win64-msvc\.7z', a['browser_download_url']):
+                anime4kcpp_zip = download(a['browser_download_url'], tempfile.gettempdir())
+                self.trash.append(anime4kcpp_zip)

        # extract and rename
-        with zipfile.ZipFile(anime4k_zip) as zipf:
-            zipf.extractall(LOCALAPPDATA / 'video2x' / 'anime4k')
+        # with py7zr.SevenZipFile(anime4kcpp_zip, mode='r') as archive:
+        (LOCALAPPDATA / 'video2x' / 'anime4kcpp').mkdir(parents=True, exist_ok=True)
+        pyunpack.Archive(anime4kcpp_zip).extractall(LOCALAPPDATA / 'video2x' / 'anime4kcpp')
+
+    def _install_srmd_ncnn_vulkan(self):
+        """ Install srmd-ncnn-vulkan
+        """
+        print('\nInstalling srmd-ncnn-vulkan')
+        import requests
+
+        # Get latest release of srmd-ncnn-vulkan via Github API
+        latest_release = requests.get('https://api.github.com/repos/nihui/srmd-ncnn-vulkan/releases/latest').json()
+
+        for a in latest_release['assets']:
+            if re.search(r'srmd-ncnn-vulkan-\d*\.zip', a['browser_download_url']):
+                srmd_ncnn_vulkan_zip = download(a['browser_download_url'], tempfile.gettempdir())
+                self.trash.append(srmd_ncnn_vulkan_zip)
+
+        # extract and rename
+        srmd_ncnn_vulkan_directory = LOCALAPPDATA / 'video2x' / 'srmd-ncnn-vulkan'
+        with zipfile.ZipFile(srmd_ncnn_vulkan_zip) as zipf:
+            zipf.extractall(LOCALAPPDATA / 'video2x')
+
+            # if directory already exists, remove it
+            if srmd_ncnn_vulkan_directory.exists():
+                shutil.rmtree(srmd_ncnn_vulkan_directory)
+
+            # rename the newly extracted directory
+            (LOCALAPPDATA / 'video2x' / zipf.namelist()[0]).rename(srmd_ncnn_vulkan_directory)

    def _generate_config(self):
        """ Generate video2x config
@@ -233,18 +260,21 @@ class Video2xSetup:

        # configure only the specified drivers
        if self.driver == 'all':
-            template_dict['waifu2x_caffe']['path'] = str(LOCALAPPDATA / 'video2x' / 'waifu2x-caffe' / 'waifu2x-caffe-cui.exe')
-            template_dict['waifu2x_converter']['path'] = str(LOCALAPPDATA / 'video2x' / 'waifu2x-converter-cpp')
-            template_dict['waifu2x_ncnn_vulkan']['path'] = str(LOCALAPPDATA / 'video2x' / 'waifu2x-ncnn-vulkan' / 'waifu2x-ncnn-vulkan.exe')
-            template_dict['anime4k']['path'] = str(LOCALAPPDATA / 'video2x' / 'anime4k' / 'Anime4K.jar')
+            template_dict['waifu2x_caffe']['path'] = str(LOCALAPPDATA / 'video2x' / 'waifu2x-caffe' / 'waifu2x-caffe-cui')
+            template_dict['waifu2x_converter_cpp']['path'] = str(LOCALAPPDATA / 'video2x' / 'waifu2x-converter-cpp')
+            template_dict['waifu2x_ncnn_vulkan']['path'] = str(LOCALAPPDATA / 'video2x' / 'waifu2x-ncnn-vulkan' / 'waifu2x-ncnn-vulkan')
+            template_dict['srmd_ncnn_vulkan']['path'] = str(LOCALAPPDATA / 'video2x' / 'srmd-ncnn-vulkan' / 'srmd-ncnn-vulkan')
+            template_dict['anime4kcpp']['path'] = str(LOCALAPPDATA / 'video2x' / 'anime4kcpp' / 'CLI' / 'Anime4KCPP_CLI' / 'Anime4KCPP_CLI')
        elif self.driver == 'waifu2x_caffe':
-            template_dict['waifu2x_caffe']['path'] = str(LOCALAPPDATA / 'video2x' / 'waifu2x-caffe' / 'waifu2x-caffe-cui.exe')
-        elif self.driver == 'waifu2x_converter':
-            template_dict['waifu2x_converter']['path'] = str(LOCALAPPDATA / 'video2x' / 'waifu2x-converter-cpp')
+            template_dict['waifu2x_caffe']['path'] = str(LOCALAPPDATA / 'video2x' / 'waifu2x-caffe' / 'waifu2x-caffe-cui')
+        elif self.driver == 'waifu2x_converter_cpp':
+            template_dict['waifu2x_converter_cpp']['path'] = str(LOCALAPPDATA / 'video2x' / 'waifu2x-converter-cpp' / 'waifu2x-converter-cpp')
        elif self.driver == 'waifu2x_ncnn_vulkan':
-            template_dict['waifu2x_ncnn_vulkan']['path'] = str(LOCALAPPDATA / 'video2x' / 'waifu2x-ncnn-vulkan' / 'waifu2x-ncnn-vulkan.exe')
-        elif self.driver == 'anime4k':
-            template_dict['anime4k']['path'] = str(LOCALAPPDATA / 'video2x' / 'anime4k' / 'Anime4K.jar')
+            template_dict['waifu2x_ncnn_vulkan']['path'] = str(LOCALAPPDATA / 'video2x' / 'waifu2x-ncnn-vulkan' / 'waifu2x-ncnn-vulkan')
+        elif self.driver == 'srmd_ncnn_vulkan':
+            template_dict['srmd_ncnn_vulkan']['path'] = str(LOCALAPPDATA / 'video2x' / 'srmd-ncnn-vulkan' / 'srmd-ncnn-vulkan')
+        elif self.driver == 'anime4kcpp':
+            template_dict['anime4kcpp']['path'] = str(LOCALAPPDATA / 'video2x' / 'anime4kcpp' / 'CLI' / 'Anime4KCPP_CLI' / 'Anime4KCPP_CLI')

        template_dict['ffmpeg']['ffmpeg_path'] = str(LOCALAPPDATA / 'video2x' / 'ffmpeg-latest-win64-static' / 'bin')
        template_dict['video2x']['video2x_cache_directory'] = None
--- a/src/waifu2x_caffe.py
+++ b/src/waifu2x_caffe.py
@@ -1,98 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""
-Name: Waifu2x Caffe Driver
-Author: K4YT3X
-Date Created: Feb 24, 2018
-Last Modified: October 6, 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, driver_settings, process, model_dir, bit_depth):
-        self.driver_settings = driver_settings
-        self.driver_settings['process'] = process
-        self.driver_settings['model_dir'] = model_dir
-        self.driver_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.driver_settings['input_path'] = input_directory
-            self.driver_settings['output_path'] = output_directory
-
-            if scale_ratio:
-                self.driver_settings['scale_ratio'] = scale_ratio
-            elif scale_width and scale_height:
-                self.driver_settings['scale_width'] = scale_width
-                self.driver_settings['scale_height'] = scale_height
-
-            self.driver_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.driver_settings['path'])]
-
-            for key in self.driver_settings.keys():
-
-                value = self.driver_settings[key]
-
-                # is executable key or null or None means that leave this option out (keep default)
-                if key == '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)
--- a/src/waifu2x_converter.py
+++ b/src/waifu2x_converter.py
@@ -1,96 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""
-Name: Waifu2x Converter CPP Driver
-Author: K4YT3X
-Date Created: February 8, 2019
-Last Modified: October 6, 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, driver_settings, model_dir):
-        self.driver_settings = driver_settings
-        self.driver_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.driver_settings['input'] = input_directory
-            self.driver_settings['output'] = output_directory
-            self.driver_settings['scale-ratio'] = scale_ratio
-            self.driver_settings['jobs'] = jobs
-            self.driver_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.driver_settings['model-dir'] is None:
-                self.driver_settings['model-dir'] = pathlib.Path(self.driver_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.driver_settings['path']) / 'waifu2x-converter-cpp.exe')]
-
-            for key in self.driver_settings.keys():
-
-                value = self.driver_settings[key]
-
-                # the key doesn't need to be passed in this case
-                if key == '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)
--- a/src/waifu2x_ncnn_vulkan.py
+++ b/src/waifu2x_ncnn_vulkan.py
@@ -1,94 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""
-Name: Waifu2x NCNN Vulkan Driver
-Creator: SAT3LL
-Date Created: June 26, 2019
-Last Modified: November 15, 2019
-
-Editor: K4YT3X
-Last Modified: January 4, 2020
-
-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, driver_settings):
-        self.driver_settings = driver_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.driver_settings['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.driver_settings['i'] = input_directory
-            self.driver_settings['o'] = output_directory
-            self.driver_settings['s'] = int(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.driver_settings['path'])]
-
-            for key in self.driver_settings.keys():
-
-                value = self.driver_settings[key]
-
-                # is executable key or null or None means that leave this option out (keep default)
-                if key == '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)
--- a/src/wrappers/anime4kcpp.py
+++ b/src/wrappers/anime4kcpp.py
@@ -0,0 +1,107 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Name: Waifu2x Caffe Driver
+Author: K4YT3X
+Date Created: May 3, 2020
+Last Modified: May 7, 2020
+
+Description: This class is a high-level wrapper
+for waifu2x-caffe.
+"""
+
+# built-in imports
+import argparse
+import os
+import pathlib
+import platform
+import shlex
+import subprocess
+import threading
+
+# third-party imports
+from avalon_framework import Avalon
+
+
+class WrapperMain:
+    """ Anime4K CPP wrapper
+    """
+
+    def __init__(self, driver_settings):
+        self.driver_settings = driver_settings
+        self.print_lock = threading.Lock()
+
+    @staticmethod
+    def parse_arguments(arguments):
+        parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter, add_help=False)
+        parser.error = lambda message: (_ for _ in ()).throw(AttributeError(message))
+        parser.add_argument('--help', action='help', help='show this help message and exit')
+        # parser.add_argument('-i', '--input', type=pathlib.Path, help='File for loading')
+        # parser.add_argument('-o', '--output', type=pathlib.Path, help='File for outputting')
+        parser.add_argument('-p', '--passes', type=int, help='Passes for processing')
+        parser.add_argument('-n', '--pushColorCount', type=int, help='Limit the number of color pushes')
+        parser.add_argument('-c', '--strengthColor', type=float, help='Strength for pushing color,range 0 to 1,higher for thinner')
+        parser.add_argument('-g', '--strengthGradient', type=float, help='Strength for pushing gradient,range 0 to 1,higher for sharper')
+        parser.add_argument('-z', '--zoomFactor', type=float, help='zoom factor for resizing')
+        parser.add_argument('-t', '--threads', type=int, help='Threads count for video processing')
+        parser.add_argument('-f', '--fastMode', action='store_true', help='Faster but maybe low quality')
+        # parser.add_argument('-v', '--videoMode', action='store_true', help='Video process')
+        parser.add_argument('-s', '--preview', action='store_true', help='Preview image')
+        parser.add_argument('-b', '--preprocessing', action='store_true', help='Enable pre processing')
+        parser.add_argument('-a', '--postprocessing', action='store_true', help='Enable post processing')
+        parser.add_argument('-r', '--preFilters', type=int, help='Enhancement filter, only working when preProcessing is true,there are 5 options by binary:Median blur=0000001, Mean blur=0000010, CAS Sharpening=0000100, Gaussian blur weak=0001000, Gaussian blur=0010000, Bilateral filter=0100000, Bilateral filter faster=1000000, you can freely combine them, eg: Gaussian blur weak + Bilateral filter = 0001000 | 0100000 = 0101000 = 40(D)')
+        parser.add_argument('-e', '--postFilters', type=int, help='Enhancement filter, only working when postProcessing is true,there are 5 options by binary:Median blur=0000001, Mean blur=0000010, CAS Sharpening=0000100, Gaussian blur weak=0001000, Gaussian blur=0010000, Bilateral filter=0100000, Bilateral filter faster=1000000, you can freely combine them, eg: Gaussian blur weak + Bilateral filter = 0001000 | 0100000 = 0101000 = 40(D), so you can put 40 to enable Gaussian blur weak and Bilateral filter, which also is what I recommend for image that < 1080P, 48 for image that >= 1080P, and for performance I recommend to use 72 for video that < 1080P, 80 for video that >=1080P')
+        parser.add_argument('-q', '--GPUMode', action='store_true', help='Enable GPU acceleration')
+        parser.add_argument('-l', '--listGPUs', action='store_true', help='list GPUs')
+        parser.add_argument('-h', '--platformID', type=int, help='Specify the platform ID')
+        parser.add_argument('-d', '--deviceID', type=int, help='Specify the device ID')
+        parser.add_argument('-C', '--codec', type=str, help='Specify the codec for encoding from mp4v(recommended in Windows), dxva(for Windows), avc1(H264, recommended in Linux), vp09(very slow), hevc(not support in Windowds), av01(not support in Windowds) (string [=mp4v])')
+        return parser.parse_args(arguments)
+
+    def upscale(self, input_file, output_file, zoom_factor, threads):
+        """This is the core function for WAIFU2X class
+
+        Arguments:
+            input_file {string} -- source directory path
+            output_file {string} -- output directory path
+            width {int} -- output video width
+            height {int} -- output video height
+        """
+
+        # overwrite config file settings
+        self.driver_settings['input'] = input_file
+        self.driver_settings['output'] = output_file
+        self.driver_settings['zoomFactor'] = zoom_factor
+        self.driver_settings['threads'] = threads
+        
+        # Anime4KCPP will look for Anime4KCPPKernel.cl under the current working directory
+        # change the CWD to its containing directory so it will find it
+        if platform.system() == 'Windows':
+            os.chdir(pathlib.Path(self.driver_settings['path']).parent)
+
+        # list to be executed
+        # initialize the list with waifu2x binary path as the first element
+        execute = [self.driver_settings.pop('path')]
+
+        for key in self.driver_settings.keys():
+
+            value = self.driver_settings[key]
+
+            # null or None means that leave this option out (keep default)
+            if 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 not True:
+                    execute.append(str(value))
+
+        # return the Popen object of the new process created
+        self.print_lock.acquire()
+        Avalon.debug_info(f'[upscaler] Subprocess {os.getpid()} executing: {shlex.join(execute)}')
+        self.print_lock.release()
+        return subprocess.Popen(execute)
--- a/src/wrappers/ffmpeg.py
+++ b/src/wrappers/ffmpeg.py
@@ -4,7 +4,7 @@
 Name: Video2X FFmpeg Controller
 Author: K4YT3X
 Date Created: Feb 24, 2018
-Last Modified: November 15, 2019
+Last Modified: May 7, 2020

 Description: This class handles all FFmpeg related operations.
 """
@@ -131,7 +131,7 @@ class Ffmpeg:
            extracted_frames / f'extracted_%0d.{self.image_format}'
        ])

-        self._execute(execute)
+        return(self._execute(execute))

    def convert_video(self, framerate, resolution, upscaled_frames):
        """Converts images into videos
@@ -180,7 +180,7 @@ class Ffmpeg:
            upscaled_frames / 'no_audio.mp4'
        ])

-        self._execute(execute)
+        return(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
@@ -209,7 +209,7 @@ class Ffmpeg:
            output_video
        ])

-        self._execute(execute)
+        return(self._execute(execute))

    def _read_configuration(self, phase, section=None):
        """ read configuration from JSON
@@ -284,4 +284,4 @@ class Ffmpeg:

        Avalon.debug_info(f'Executing: {execute}')

-        return subprocess.run(execute, check=True).returncode
+        return subprocess.Popen(execute)
--- a/src/wrappers/srmd_ncnn_vulkan.py
+++ b/src/wrappers/srmd_ncnn_vulkan.py
@@ -0,0 +1,100 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Name: SRMD NCNN Vulkan Driver
+Creator: K4YT3X
+Date Created: April 26, 2020
+Last Modified: May 7, 2020
+
+Description: This class is a high-level wrapper
+for srmd_ncnn_vulkan.
+"""
+
+# built-in imports
+import argparse
+import os
+import pathlib
+import platform
+import shlex
+import subprocess
+import threading
+
+# third-party imports
+from avalon_framework import Avalon
+
+
+class WrapperMain:
+    """This class communicates with SRMD 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, driver_settings):
+        self.driver_settings = driver_settings
+        self.print_lock = threading.Lock()
+
+    @staticmethod
+    def parse_arguments(arguments):
+        parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter, add_help=False)
+        parser.error = lambda message: (_ for _ in ()).throw(AttributeError(message))
+        parser.add_argument('--help', action='help', help='show this help message and exit')
+        parser.add_argument('-v', action='store_true', help='verbose output')
+        # parser.add_argument('-i', type=pathlib.Path, help='input image path (jpg/png) or directory')
+        # parser.add_argument('-o', type=pathlib.Path, help='output image path (png) or directory')
+        parser.add_argument('-n', type=int, choices=range(-1, 11), help='denoise level')
+        parser.add_argument('-s', type=int, choices=range(2, 5), help='upscale ratio')
+        parser.add_argument('-t', type=int, help='tile size (>=32)')
+        parser.add_argument('-m', type=str, help='srmd model path')
+        parser.add_argument('-g', type=int, help='gpu device to use')
+        parser.add_argument('-j', type=str, help='thread count for load/proc/save')
+        parser.add_argument('-x', action='store_true', help='enable tta mode')
+        return parser.parse_args(arguments)
+
+    def upscale(self, input_directory, output_directory, scale_ratio):
+        """This is the core function for SRMD ncnn Vulkan class
+
+        Arguments:
+            input_directory {string} -- source directory path
+            output_directory {string} -- output directory path
+            ratio {int} -- output video ratio
+        """
+
+        # overwrite config file settings
+        self.driver_settings['i'] = input_directory
+        self.driver_settings['o'] = output_directory
+        self.driver_settings['s'] = scale_ratio
+
+        # by default, srmd-ncnn-vulkan will look for the models under the current working directory
+        # change the working directory to its containing folder if model directory not specified
+        if self.driver_settings['m'] is None and platform.system() == 'Windows':
+            os.chdir(pathlib.Path(self.driver_settings['path']).parent)
+
+        # list to be executed
+        # initialize the list with the binary path as the first element
+        execute = [self.driver_settings.pop('path')]
+
+        for key in self.driver_settings.keys():
+
+            value = self.driver_settings[key]
+
+            # null or None means that leave this option out (keep default)
+            if 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 not True:
+                    execute.append(str(value))
+
+        # return the Popen object of the new process created
+        self.print_lock.acquire()
+        Avalon.debug_info(f'[upscaler] Subprocess {os.getpid()} executing: {shlex.join(execute)}')
+        self.print_lock.release()
+        return subprocess.Popen(execute)
--- a/src/wrappers/waifu2x_caffe.py
+++ b/src/wrappers/waifu2x_caffe.py
@@ -0,0 +1,111 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Name: Waifu2x Caffe Driver
+Author: K4YT3X
+Date Created: Feb 24, 2018
+Last Modified: May 7, 2020
+
+Description: This class is a high-level wrapper
+for waifu2x-caffe.
+"""
+
+# built-in imports
+import argparse
+import os
+import shlex
+import subprocess
+import threading
+
+# third-party imports
+from avalon_framework import Avalon
+
+
+class WrapperMain:
+    """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, driver_settings):
+        self.driver_settings = driver_settings
+        self.print_lock = threading.Lock()
+
+    @staticmethod
+    def parse_arguments(arguments):
+        parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter, add_help=False)
+        parser.error = lambda message: (_ for _ in ()).throw(AttributeError(message))
+        parser.add_argument('--help', action='help', help='show this help message and exit')
+        parser.add_argument('-t', '--tta', type=int, choices=range(2), help='8x slower and slightly high quality')
+        parser.add_argument('--gpu', type=int, help='gpu device no')
+        parser.add_argument('-b', '--batch_size', type=int, help='input batch size')
+        parser.add_argument('--crop_h', type=int, help='input image split size(height)')
+        parser.add_argument('--crop_w', type=int, help='input image split size(width)')
+        parser.add_argument('-c', '--crop_size', type=int, help='input image split size')
+        parser.add_argument('-d', '--output_depth', type=int, help='output image chaneel depth bit')
+        parser.add_argument('-q', '--output_quality', type=int, help='output image quality')
+        parser.add_argument('-p', '--process', choices=['cpu', 'gpu', 'cudnn'], help='process mode')
+        parser.add_argument('--model_dir', type=str, help='path to custom model directory (don\'t append last / )')
+        parser.add_argument('-h', '--scale_height', type=int, help='custom scale height')
+        parser.add_argument('-w', '--scale_width', type=int, help='custom scale width')
+        parser.add_argument('-s', '--scale_ratio', type=float, help='custom scale ratio')
+        parser.add_argument('-n', '--noise_level', type=int, choices=range(4), help='noise reduction level')
+        parser.add_argument('-m', '--mode', choices=['noise', 'scale', 'noise_scale'], help='image processing mode')
+        parser.add_argument('-e', '--output_extension', type=str, help='extention to output image file when output_path is (auto) or input_path is folder')
+        parser.add_argument('-l', '--input_extention_list', type=str, help='extention to input image file when input_path is folder')
+        # parser.add_argument('-o', '--output', type=pathlib.Path, help='path to output image file (when input_path is folder, output_path must be folder)')
+        # parser.add_argument('-i', '--input_file', type=pathlib.Path, help='(required)  path to input image file')
+        return parser.parse_args(arguments)
+
+    def upscale(self, input_directory, output_directory, scale_ratio, scale_width, scale_height, image_format, bit_depth):
+        """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
+        """
+
+        # overwrite config file settings
+        self.driver_settings['input_path'] = input_directory
+        self.driver_settings['output_path'] = output_directory
+
+        if scale_ratio:
+            self.driver_settings['scale_ratio'] = scale_ratio
+        elif scale_width and scale_height:
+            self.driver_settings['scale_width'] = scale_width
+            self.driver_settings['scale_height'] = scale_height
+
+        self.driver_settings['output_extention'] = image_format
+        self.driver_settings['output_depth'] = bit_depth
+
+        # list to be executed
+        # initialize the list with waifu2x binary path as the first element
+        execute = [self.driver_settings.pop('path')]
+
+        for key in self.driver_settings.keys():
+
+            value = self.driver_settings[key]
+
+            # null or None means that leave this option out (keep default)
+            if 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 not True:
+                    execute.append(str(value))
+
+        # return the Popen object of the new process created
+        self.print_lock.acquire()
+        Avalon.debug_info(f'[upscaler] Subprocess {os.getpid()} executing: {shlex.join(execute)}')
+        self.print_lock.release()
+        return subprocess.Popen(execute)
--- a/src/wrappers/waifu2x_converter_cpp.py
+++ b/src/wrappers/waifu2x_converter_cpp.py
@@ -0,0 +1,117 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Name: Waifu2x Converter CPP Driver
+Author: K4YT3X
+Date Created: February 8, 2019
+Last Modified: May 7, 2020
+
+Description: This class is a high-level wrapper
+for waifu2x-converter-cpp.
+"""
+
+# built-in imports
+import argparse
+import os
+import pathlib
+import shlex
+import subprocess
+import threading
+
+# third-party imports
+from avalon_framework import Avalon
+
+
+class WrapperMain:
+    """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, driver_settings):
+        self.driver_settings = driver_settings
+        self.print_lock = threading.Lock()
+
+    @staticmethod
+    def parse_arguments(arguments):
+        parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter, add_help=False)
+        parser.error = lambda message: (_ for _ in ()).throw(AttributeError(message))
+        parser.add_argument('--help', action='help', help='show this help message and exit')
+        parser.add_argument('--list-supported-formats', action='store_true', help='dump currently supported format list')
+        parser.add_argument('--list-opencv-formats', action='store_true', help='(deprecated. Use --list-supported-formats) dump opencv supported format list')
+        parser.add_argument('-l', '--list-processor', action='store_true', help='dump processor list')
+        parser.add_argument('-f', '--output-format', choices=['png', 'jpg'], help='The format used when running in recursive/folder mode\nSee --list-supported-formats for a list of supported formats/extensions.')
+        parser.add_argument('-c', '--png-compression', type=int, choices=range(10), help='Set PNG compression level (0-9), 9 = Max compression (slowest & smallest)')
+        parser.add_argument('-q', '--image-quality', type=int, choices=range(100), help='JPEG & WebP Compression quality (0-101, 0 being smallest size and lowest quality), use 101 for lossless WebP')
+        parser.add_argument('--block-size', type=int, help='block size')
+        parser.add_argument('--disable-gpu', action='store_true', help='disable GPU')
+        parser.add_argument('--force-OpenCL', action='store_true', help='force to use OpenCL on Intel Platform')
+        parser.add_argument('-p', '--processor', type=int, help='set target processor')
+        parser.add_argument('-j', '--jobs', type=int, help='number of threads launching at the same time')
+        parser.add_argument('--model-dir', type=str, help='path to custom model directory (don\'t append last / )')
+        parser.add_argument('--scale-ratio', type=float, help='custom scale ratio')
+        parser.add_argument('--noise-level', type=int, choices=range(4), help='noise reduction level')
+        parser.add_argument('-m', '--mode', choices=['noise', 'scale', 'noise-scale'], help='image processing mode')
+        parser.add_argument('-v', '--log-level', type=int, choices=range(5), help='Set log level')
+        parser.add_argument('-s', '--silent', action='store_true', help='Enable silent mode. (same as --log-level 1)')
+        parser.add_argument('-t', '--tta', type=int, choices=range(2), help='Enable Test-Time Augmentation mode.')
+        parser.add_argument('-g', '--generate-subdir', type=int, choices=range(2), help='Generate sub folder when recursive directory is enabled.')
+        parser.add_argument('-a', '--auto-naming', type=int, choices=range(2), help='Add postfix to output name when output path is not specified.\nSet 0 to disable this.')
+        parser.add_argument('-r', '--recursive-directory', type=int, choices=range(2), help='Search recursively through directories to find more images to process.')
+        # parser.add_argument('-o', '--output', type=pathlib.Pathh, help='path to output image file or directory  (you should use the full path)')
+        # parser.add_argument('-i', '--input', type=pathlib.Path, help='(required)  path to input image file or directory (you should use the full path)')
+        parser.add_argument('--version', action='store_true', help='Displays version information and exits.')
+        return parser.parse_args(arguments)
+
+    def upscale(self, input_directory, output_directory, scale_ratio, jobs, image_format):
+        """ 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
+        """
+
+        # overwrite config file settings
+        self.driver_settings['input'] = input_directory
+        self.driver_settings['output'] = output_directory
+        self.driver_settings['scale-ratio'] = scale_ratio
+        self.driver_settings['jobs'] = jobs
+        self.driver_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.driver_settings['model-dir'] is None:
+            self.driver_settings['model-dir'] = pathlib.Path(self.driver_settings['path']).parent / 'models_rgb'
+
+        # list to be executed
+        # initialize the list with waifu2x binary path as the first element
+        execute = [self.driver_settings.pop('path')]
+
+        for key in self.driver_settings.keys():
+
+            value = self.driver_settings[key]
+
+            # null or None means that leave this option out (keep default)
+            if 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 not True:
+                    execute.append(str(value))
+
+        # return the Popen object of the new process created
+        self.print_lock.acquire()
+        Avalon.debug_info(f'[upscaler] Subprocess {os.getpid()} executing: {shlex.join(execute)}')
+        self.print_lock.release()
+        return subprocess.Popen(execute)
--- a/src/wrappers/waifu2x_ncnn_vulkan.py
+++ b/src/wrappers/waifu2x_ncnn_vulkan.py
@@ -0,0 +1,103 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Name: Waifu2x NCNN Vulkan Driver
+Creator: SAT3LL
+Date Created: June 26, 2019
+Last Modified: May 7, 2020
+
+Editor: K4YT3X
+Last Modified: February 22, 2020
+
+Description: This class is a high-level wrapper
+for waifu2x_ncnn_vulkan.
+"""
+
+# built-in imports
+import argparse
+import os
+import pathlib
+import platform
+import shlex
+import subprocess
+import threading
+
+# third-party imports
+from avalon_framework import Avalon
+
+
+class WrapperMain:
+    """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, driver_settings):
+        self.driver_settings = driver_settings
+        self.print_lock = threading.Lock()
+
+    @staticmethod
+    def parse_arguments(arguments):
+        parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter, add_help=False)
+        parser.error = lambda message: (_ for _ in ()).throw(AttributeError(message))
+        parser.add_argument('--help', action='help', help='show this help message and exit')
+        parser.add_argument('-v', action='store_true', help='verbose output')
+        # parser.add_argument('-i', type=pathlib.Path, help='input image path (jpg/png) or directory')
+        # parser.add_argument('-o', type=pathlib.Path, help='output image path (png) or directory')
+        parser.add_argument('-n', type=int, choices=range(-1, 4), help='denoise level')
+        parser.add_argument('-s', type=int, choices=range(1, 3), help='upscale ratio')
+        parser.add_argument('-t', type=int, help='tile size (>=32)')
+        parser.add_argument('-m', type=str, help='waifu2x model path')
+        parser.add_argument('-g', type=int, help='gpu device to use')
+        parser.add_argument('-j', type=str, help='thread count for load/proc/save')
+        parser.add_argument('-x', action='store_true', help='enable tta mode')
+        return parser.parse_args(arguments)
+
+    def upscale(self, input_directory, output_directory, scale_ratio):
+        """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
+        """
+
+        # overwrite config file settings
+        self.driver_settings['i'] = input_directory
+        self.driver_settings['o'] = output_directory
+        self.driver_settings['s'] = int(scale_ratio)
+
+        # by default, waifu2x-ncnn-vulkan will look for the models under the current working directory
+        # change the working directory to its containing folder if model directory not specified
+        if self.driver_settings['m'] is None and platform.system() == 'Windows':
+            os.chdir(pathlib.Path(self.driver_settings['path']).parent)
+
+        # list to be executed
+        # initialize the list with waifu2x binary path as the first element
+        execute = [self.driver_settings.pop('path')]
+
+        for key in self.driver_settings.keys():
+
+            value = self.driver_settings[key]
+
+            # null or None means that leave this option out (keep default)
+            if 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 not True:
+                    execute.append(str(value))
+
+        # return the Popen object of the new process created
+        self.print_lock.acquire()
+        Avalon.debug_info(f'[upscaler] Subprocess {os.getpid()} executing: {shlex.join(execute)}')
+        self.print_lock.release()
+        return subprocess.Popen(execute)
Author	SHA1	Message	Date
k4yt3x	36aa3bf1d4	GUI resolve driver paths into absolute paths	2020-05-07 16:31:05 -04:00
k4yt3x	9dde3c66f1	build script 1.0.1: building into directory with name of version	2020-05-07 16:30:36 -04:00
k4yt3x	e9c1c22788	better exception handling, soft task interruption, GUI stop button, GUI folder processing, better argument checks	2020-05-07 15:58:22 -04:00
k4yt3x	134e8b7080	uncommented some keys unmanaged by v2x	2020-05-07 10:03:42 -04:00
k4yt3x	a295b4a54f	finished adding comments for all drivers	2020-05-07 09:58:25 -04:00
k4yt3x	c198082190	updated new Anime4KCPP parameters	2020-05-07 09:38:13 -04:00
k4yt3x	8f2dc43af3	updated UI for newest Anime4KCPP	2020-05-07 09:33:37 -04:00
k4yt3x	b0ce8f3ff9	added environment variable expansion support, updated for newest Anime4KCPP	2020-05-07 09:33:12 -04:00
k4yt3x	0b1f7b8422	replaced absolute paths with environment variables, updated for newest Anime4KCPP	2020-05-07 09:32:51 -04:00
k4yt3x	def20650e2	added environment variable expansion support	2020-05-07 09:32:15 -04:00
k4yt3x	7489376404	fixed srmd-ncnn-vulkan path not added issue in the setup script	2020-05-07 09:02:42 -04:00
k4yt3x	826279ce09	fixing image captions	2020-05-06 20:48:19 -04:00
k4yt3x	88d2cd9e14	updated README screenshots and added image captions	2020-05-06 20:40:35 -04:00
k4yt3x	31728ff625	added PowerShell automatic build script	2020-05-06 20:20:51 -04:00
k4yt3x	3168737fd4	added time elapsed, time remaining and speed rate	2020-05-06 20:20:38 -04:00
k4yt3x	5fbc195740	unified config path case	2020-05-06 20:19:49 -04:00
K4YT3X	40d0d79141	added a patreon badge	2020-05-06 20:03:49 +00:00
k4yt3x	37a0966bad	added binary path loading and error dialog system	2020-05-06 15:36:55 -04:00
k4yt3x	baf4c5815f	added pyqt5 into requirements	2020-05-06 14:30:59 -04:00
k4yt3x	d25a478e64	added automatic constraint update upon driver selection	2020-05-06 14:27:21 -04:00
K4YT3X	ba723c6216	enable sponsorships	2020-05-06 17:46:35 +00:00
k4yt3x	11ea8a7a21	added config descriptions for some drivers	2020-05-06 13:24:32 -04:00
k4yt3x	3bce37416b	GUI 2.0 design and basic functionalities finished	2020-05-06 13:24:10 -04:00
k4yt3x	e3cfe13b5c	fixed some bugs in GUI	2020-05-06 11:01:14 -04:00
k4yt3x	81d8ce78cb	updated default values	2020-05-06 10:40:04 -04:00
k4yt3x	89fa91c8c5	updated GUI UI file for new settings	2020-05-06 10:39:47 -04:00
k4yt3x	c8dbb90f5b	added waifu2x-caffe and waifu2x-converter-cpp settings to GUI	2020-05-06 10:39:34 -04:00
k4yt3x	685120011b	added Waifu2x-Extension-GUI into the related projects section	2020-05-06 04:57:43 -04:00
k4yt3x	82da40327b	updated Video2X GUI screenshot	2020-05-06 04:48:04 -04:00
k4yt3x	9b4fb3258a	video2x GUI 2.0.0: completely redesigned and rewritten with PyQt5	2020-05-06 04:45:48 -04:00
k4yt3x	f00a10aa91	added image files and project files	2020-05-06 04:44:36 -04:00
k4yt3x	93e8f36ffb	fixed a typo	2020-05-06 00:12:49 -04:00
k4yt3x	f10e59099c	deprecated JSON config file	2020-05-06 00:12:31 -04:00
k4yt3x	82715ade18	addressed srmd-ncnn-vulkan and waifu2x-ncnn-vulkan model path issues	2020-05-05 02:49:10 -04:00
K4YT3X	63de63e594	added master branch version badge	2020-05-05 06:29:03 +00:00
K4YT3X	8daeb862a4	updated README terminal screenshot	2020-05-05 06:26:39 +00:00
k4yt3x	be0d1f1d08	added some badges	2020-05-05 02:22:37 -04:00
k4yt3x	ec1327b5d8	updated README for version 4.0.0	2020-05-05 01:51:24 -04:00
k4yt3x	5b3e5604cc	fixed srmd-ncnn-vulkan binary path issue	2020-05-05 01:12:12 -04:00
k4yt3x	a2fc71d6c5	fixed Anime4KCPP upscaling bug	2020-05-05 01:11:50 -04:00
k4yt3x	ab684bcd48	updated default Anime4KCPP path	2020-05-05 01:11:37 -04:00
k4yt3x	d26b406813	setup script 1.8.0: added Anime4KCPP setup support	2020-05-05 01:11:26 -04:00
k4yt3x	133b837b15	added language zh_CN	2020-05-04 20:25:43 -04:00
k4yt3x	9aebc77883	removing default values for model directories for multi-platform support	2020-05-04 20:25:32 -04:00
k4yt3x	b8472f155a	added internationalization support	2020-05-04 20:25:12 -04:00
k4yt3x	19e6d241d5	fixing driver argument TypeError	2020-05-04 17:19:48 -04:00
k4yt3x	89860f22cb	4.0.0 new argument parsing mechanism and project structure	2020-05-04 17:12:41 -04:00
k4yt3x	88299d404a	removed anime4k support and added Anime4KCPP support; cleaned up the program	2020-05-03 19:20:23 -04:00
k4yt3x	0f1639ed62	adding Anime4KCPP support	2020-05-03 19:19:19 -04:00
k4yt3x	3b6462d1da	removing support for Anime4K (Java)	2020-05-03 19:19:00 -04:00
k4yt3x	43a2078330	moving wrappers into a sub-directory	2020-05-03 19:18:39 -04:00
k4yt3x	b1e844dcad	updated README for setup script 1.7.0	2020-04-26 20:12:42 -04:00
k4yt3x	becce32d3e	setup script 1.7.0: added support for srmd-ncnn-vulkan	2020-04-26 20:12:06 -04:00
k4yt3x	d2ddf32527	updated README for 3.2.0	2020-04-26 20:04:37 -04:00
k4yt3x	7224c53997	3.2.0 added SRMD NCNN Vulkan support	2020-04-26 20:01:37 -04:00
k4yt3x	2ed9bd4da6	updated configuration files for SRMD NCNN Vulkan	2020-04-26 20:00:01 -04:00
k4yt3x	38c52cdfd2	updated JSON config file to match YAML	2020-04-26 19:40:21 -04:00
k4yt3x	80579d3fa9	updated absolutify paths function	2020-04-26 13:40:22 -04:00
k4yt3x	47f94dfd6c	updated Anime4K ZIP file download URL	2020-04-24 00:22:39 -04:00
k4yt3x	c470dde5da	fixing issue #220	2020-04-04 06:24:40 -04:00
k4yt3x	c532ac3c88	updated file modification dates and editor information	2020-03-23 09:05:24 -04:00
K4YT3X	f50ceecd62	Merge pull request #214 from 28598519a/master Fix k4yt3x#211 bug	2020-03-23 08:55:16 -04:00
劃破黑夜	2ba0e951f9	Fix k4yt3x#211 bug	2020-03-17 22:01:56 +08:00
k4yt3x	5753ea8f52	updated readme for version 3.1.0	2020-02-26 22:31:51 -05:00
k4yt3x	09db8bedd0	3.1.0 switched to multi-processing and added KeyboardInterrupt support	2020-02-26 05:28:48 -05:00
k4yt3x	6a100b1526	removed multi-threading in favor of muti-processing	2020-02-26 05:27:57 -05:00
k4yt3x	a2150a8dbc	fixing progress bar error due to string case mismatch	2020-02-22 02:31:39 -05:00
k4yt3x	78ded08ed5	changed default number of threads to 1	2020-02-21 23:16:22 -05:00