def trim_video(context: Context, output_file: str):
"""
Create a trimmed video using -ss and -to commands from FFMPEG. The trimmed video will be named 'output_file'
"""
# load context
input_file = context.input_file
trim_video_command = [
context.ffmpeg_dir, "-hwaccel", context.hwaccel, "-i", input_file
]
trim_video_time = get_options_from_section(
context.config_yaml["ffmpeg"]["trim_video"]["time"])
for element in trim_video_time:
trim_video_command.append(element)
trim_video_options = \
get_options_from_section(context.config_yaml["ffmpeg"]["trim_video"]["output_options"], ffmpeg_command=True)
for element in trim_video_options:
trim_video_command.append(element)
trim_video_command.append(output_file)
console_output = open(
context.console_output_dir + "ffmpeg_trim_video_command.txt", "w")
console_output.write(str(trim_video_command))
subprocess.call(trim_video_command,
shell=False,
stderr=console_output,
stdout=console_output)
def __init__(self, context: Context):
# load context
self.frame_count = context.frame_count
self.waifu2x_converter_cpp_file_path = context.waifu2x_converter_cpp_file_path
self.waifu2x_converter_cpp_path = context.waifu2x_converter_cpp_path
self.residual_images_dir = context.residual_images_dir
self.residual_upscaled_dir = context.residual_upscaled_dir
self.noise_level = context.noise_level
self.scale_factor = context.scale_factor
self.workspace = context.workspace
self.context = context
self.waifu2x_conv_upscale_frame = [
self.waifu2x_converter_cpp_file_path, "-i", "[input_file]",
"--noise-level",
str(self.noise_level), "--scale-ratio",
str(self.scale_factor)
]
waifu2x_conv_options = get_options_from_section(
self.context.config_yaml["waifu2x_converter"]["output_options"])
# add custom options to waifu2x_vulkan
for element in waifu2x_conv_options:
self.waifu2x_conv_upscale_frame.append(element)
self.waifu2x_conv_upscale_frame.extend(["-o", "[output_file]"])
threading.Thread.__init__(self)
logging.basicConfig(filename=self.workspace + 'waifu2x.log',
level=logging.INFO)
def start_task(self):
extract_frames_command = [self.context.ffmpeg_dir,
"-hwaccel", self.context.hwaccel,
"-i", self.input_file]
extract_frames_options = \
get_options_from_section(self.context.config_yaml["ffmpeg"]["video_to_frames"]['output_options'],
ffmpeg_command=True)
for element in extract_frames_options:
extract_frames_command.append(element)
extract_frames_command.append("-r")
extract_frames_command.append(str(self.frame_rate))
extract_frames_command.extend([self.output_file])
self.logger.info("extracting frames")
console_output = open(self.context.console_output_dir + "ffmpeg_extract_frames_console.txt", "w")
console_output.write(str(extract_frames_command))
self.P = subprocess.Popen(extract_frames_command, shell=False,
stderr=console_output, stdout=console_output)
self.pause_resume = psutil.Process(self.P.pid)
self.pause_resume.suspend()
def create_video_from_extract_frames(context: Context, output_file: str):
"""
Create a new video by applying the filters that d2x needs to work into it's own seperate video.
"""
input_file = context.input_file
logger = logging.getLogger(__name__)
command = [
context.ffmpeg_dir, "-hwaccel", context.hwaccel, "-i", input_file
]
extract_frames_options = \
get_options_from_section(context.config_yaml["ffmpeg"]["video_to_frames"]['output_options'],
ffmpeg_command=True)
for element in extract_frames_options:
command.append(element)
command.extend([output_file])
logger.info("Applying filter to video...")
console_output = open(
context.console_output_dir +
"ffmpeg_create_video_from_extract_frame_filters.txt", "w")
console_output.write(str(command))
subprocess.call(command,
shell=False,
stderr=console_output,
stdout=console_output)
def concat_encoded_vids(context: Context, output_file: str):
"""
Concatonate a video using 2) in this stackoverflow post.
https://stackoverflow.com/questions/7333232/how-to-concatenate-two-mp4-files-using-ffmpeg
The 'list.txt' should already exist, as it's produced in realtime_encoding.py
"""
encoded_dir = context.encoded_dir
text_file = encoded_dir + "list.txt"
concat_videos_command = [
context.ffmpeg_dir, "-f", "concat", "-safe", "0", "-hwaccel",
context.hwaccel, "-i", text_file
]
concat_videos_option = \
get_options_from_section(context.config_yaml["ffmpeg"]["concat_videos"]['output_options'], ffmpeg_command=True)
for element in concat_videos_option:
concat_videos_command.append(element)
concat_videos_command.extend([output_file])
console_output = open(
context.console_output_dir + "ffmpeg_concat_videos_command.txt", "w")
console_output.write((str(concat_videos_command)))
subprocess.call(concat_videos_command,
shell=False,
stderr=console_output,
stdout=console_output)
def _setup_pipe(self) -> None:
# load variables..
output_no_sound = self.output_no_sound
frame_rate = str(self.context.frame_rate)
output_no_sound = output_no_sound
ffmpeg_dir = self.context.ffmpeg_dir
dar = self.context.dar
# constructing the pipe command...
ffmpeg_pipe_command = [ffmpeg_dir, "-r", frame_rate]
options = get_options_from_section(
self.context.config_yaml["ffmpeg"]["pipe_video"]['output_options'],
ffmpeg_command=True)
for item in options:
ffmpeg_pipe_command.append(item)
ffmpeg_pipe_command.append("-r")
ffmpeg_pipe_command.append(frame_rate)
if dar:
ffmpeg_pipe_command.append("-vf")
ffmpeg_pipe_command.append("setdar=" + dar.replace(":", "/"))
ffmpeg_pipe_command.append(output_no_sound)
# Starting the Pipe Command
console_output = open(
self.context.console_output_dir + "pipe_output.txt", "w")
self.ffmpeg_pipe_subprocess = subprocess.Popen(ffmpeg_pipe_command,
stdin=subprocess.PIPE,
stdout=console_output)
def __init__(self, context: Context):
self.frame_count = context.frame_count
self.waifu2x_caffe_cui_dir = context.waifu2x_caffe_cui_dir
self.residual_images_dir = context.residual_images_dir
self.residual_upscaled_dir = context.residual_upscaled_dir
self.noise_level = context.noise_level
self.scale_factor = context.scale_factor
self.workspace = context.workspace
self.context = context
# Create Caffe Command
self.waifu2x_caffe_upscale_frame = [
self.waifu2x_caffe_cui_dir, "-i", "[input_file]", "-n",
str(self.noise_level), "-s",
str(self.scale_factor)
]
waifu2x_caffe_options = get_options_from_section(
context.config_yaml["waifu2x_caffe"]["output_options"])
for element in waifu2x_caffe_options:
self.waifu2x_caffe_upscale_frame.append(element)
self.waifu2x_caffe_upscale_frame.extend(["-o", "[output_file]"])
threading.Thread.__init__(self)
logging.basicConfig(filename=self.workspace + 'waifu2x.log',
level=logging.INFO)
def migrate_tracks(context: Context, no_audio: str, file_dir: str,
output_file: str):
"""
Add the audio tracks from the original video to the output video.
"""
migrate_tracks_command = [
context.ffmpeg_dir, "-i", no_audio, "-i", file_dir, "-map", "0:v:0?",
"-map", "1?", "-c", "copy", "-map", "-1:v?"
]
migrate_tracks_options = \
get_options_from_section(context.config_yaml["ffmpeg"]["migrating_tracks"]['output_options'],
ffmpeg_command=True)
for element in migrate_tracks_options:
migrate_tracks_command.append(element)
migrate_tracks_command.extend([str(output_file)])
console_output = open(context.log_dir + "migrate_tracks_command.txt", "w")
console_output.write(str(migrate_tracks_command))
subprocess.call(migrate_tracks_command,
shell=False,
stderr=console_output,
stdout=console_output)
def extract_frames(context: Context, input_file: str):
"""
Extract frames from a video using ffmpeg.
"""
input_frames_dir = context.input_frames_dir
extension_type = context.extension_type
output_file = input_frames_dir + "frame%01d" + extension_type
logger = logging.getLogger(__name__)
frame_rate = context.frame_rate
extract_frames_command = [
context.ffmpeg_dir, "-hwaccel", context.hwaccel, "-i", input_file
]
extract_frames_options = \
get_options_from_section(context.config_yaml["ffmpeg"]["video_to_frames"]['output_options'],
ffmpeg_command=True)
for element in extract_frames_options:
extract_frames_command.append(element)
extract_frames_command.append("-r")
extract_frames_command.append(str(frame_rate))
extract_frames_command.extend([output_file])
console_output = open(
context.console_output_dir + "ffmpeg_extract_frames_console.txt", "w")
console_output.write(str(extract_frames_command))
subprocess.call(extract_frames_command,
shell=False,
stderr=console_output,
stdout=console_output)
def __init__(self, context, output_no_sound: str):
self.context = context
# load variables from context
self.workspace = self.context.workspace
self.upscaled_dir = self.context.residual_upscaled_dir
self.compressed_static_dir = self.context.compressed_static_dir
self.compressed_moving_dir = self.context.compressed_moving_dir
self.input_frames_dir = self.context.input_frames_dir
self.merged_dir = self.context.merged_dir
self.residual_data_dir = self.context.residual_data_dir
self.pframe_data_dir = self.context.pframe_data_dir
self.correction_data_dir = self.context.correction_data_dir
self.fade_data_dir = self.context.fade_data_dir
self.frame_count = self.context.frame_count
self.waifu2x_type = self.context.waifu2x_type
# How many images to have maximum in a buffer at a given time.
self.buffer_limit = 20
self.pipe_running = True
self.images_to_pipe = []
self.nosound_file = output_no_sound
self.frame_rate = str(self.context.frame_rate)
self.dar = self.context.dar
self.input_file = self.context.input_file
self.output_file = self.context.output_file
self.ffmpeg_dir = self.context.ffmpeg_dir
# Create the piping command
self.ffmpeg_pipe_command = [self.ffmpeg_dir, "-r", self.frame_rate]
options = get_options_from_section(
context.config_yaml["ffmpeg"]["pipe_video"]['output_options'],
ffmpeg_command=True)
for item in options:
self.ffmpeg_pipe_command.append(item)
self.ffmpeg_pipe_command.append("-r")
self.ffmpeg_pipe_command.append(self.frame_rate)
if self.dar:
self.ffmpeg_pipe_command.append("-vf")
self.ffmpeg_pipe_command.append("setdar=" +
self.dar.replace(":", "/"))
self.ffmpeg_pipe_command.append(self.nosound_file)
self.ffmpeg_pipe_subprocess = None
# thread variables
self.thread_alive = True
def migrate_tracks(context: Context,
no_audio: str,
file_dir: str,
output_file: str,
copy_if_failed=False):
"""
Add the audio tracks from the original video to the output video.
"""
# to remove
def convert(lst):
return ' '.join(lst)
log = logging.getLogger()
migrate_tracks_command = [
context.ffmpeg_dir, "-i", no_audio, "-i", file_dir, "-map", "0:v?",
"-map", "1:a?", "-map", "1:s?", "-map", "1:d?", "-map", "1:t?"
]
migrate_tracks_options = \
get_options_from_section(context.config_yaml["ffmpeg"]["migrating_tracks"]['output_options'],
ffmpeg_command=True)
for element in migrate_tracks_options:
migrate_tracks_command.append(element)
migrate_tracks_command.extend([str(output_file)])
console_file_dir = context.console_output_dir + "migrate_tracks_command.txt"
log.info("Writing files to %s" % console_file_dir)
log.info("Migrate Command: %s" % convert(migrate_tracks_command))
console_output = open(console_file_dir, "w", encoding="utf8")
console_output.write(str(migrate_tracks_command))
subprocess.call(migrate_tracks_command,
shell=False,
stderr=console_output,
stdout=console_output)
if copy_if_failed:
with open(context.console_output_dir + "migrate_tracks_command.txt",
encoding="utf8") as f:
if 'Conversion failed!' in f.read():
import os
import shutil
print(
"Migrating Tracks failed... copying video in order to continue with dandere2x."
)
os.remove(output_file)
shutil.copy(no_audio, output_file)
def _construct_upscale_command(self) -> list:
""" A generic, recyclable upscale command that can be used for single-file upscaling or batch upscaling. """
waifu2x_vulkan_upscale_frame_command = [
self.realsr_ncnn_vulkan_file_path, "-i", "[input_file]"
]
waifu2x_vulkan_options = get_options_from_section(
self.context.config_yaml["realsr_ncnn_vulkan"]["output_options"])
# add custom options to waifu2x_vulkan
for element in waifu2x_vulkan_options:
waifu2x_vulkan_upscale_frame_command.append(element)
waifu2x_vulkan_upscale_frame_command.extend(["-o", "[output_file]"])
return waifu2x_vulkan_upscale_frame_command
def _construct_upscale_command(self) -> list:
upscale_command = [self.context.waifu2x_caffe_cui_dir,
"-i", "[input_file]",
"-n", str(self.noise_level),
"-s", str(self.scale_factor)]
optional_paramaters = get_options_from_section(
self.context.config_yaml["waifu2x_caffe"]["output_options"])
# add optional paramaters to upscaling command.
for element in optional_paramaters:
upscale_command.append(element)
upscale_command.extend(["-o", "[output_file]"])
return upscale_command
def re_encode_video(context: Context,
input_file: str,
output_file: str,
throw_exception=False):
"""
Using the "re_encode_video" commands in the yaml to re-encode the input video in an opencv2 friendly
manner. Without this step, certain containers might not be compatible with opencv2, and will cause
a plethora of errors.
throw_exception: Will throw a detailed exception and print statement if conversion failed.
"""
logger = logging.getLogger(__name__)
frame_rate = context.frame_rate
extract_frames_command = [
context.ffmpeg_dir, "-hwaccel", context.hwaccel, "-i", input_file
]
extract_frames_options = \
get_options_from_section(context.config_yaml["ffmpeg"]['re_encode_video']['output_options'],
ffmpeg_command=True)
for element in extract_frames_options:
extract_frames_command.append(element)
extract_frames_command.append("-r")
extract_frames_command.append(str(frame_rate))
extract_frames_command.extend([output_file])
log_file = context.console_output_dir + "ffmpeg_convert_video.txt"
console_output = open(log_file, "w", encoding="utf8")
console_output.write(str(extract_frames_command))
subprocess.call(extract_frames_command,
shell=False,
stderr=console_output,
stdout=console_output)
if throw_exception:
with open(context.console_output_dir + "ffmpeg_convert_video.txt",
encoding="utf8") as f:
if 'Conversion failed!' in f.read():
print("Failed to convert: " + input_file + " -> " +
output_file + ".")
print("Check the output file for more information: " +
log_file)
raise TypeError
def _construct_upscale_command(self) -> list:
waifu2x_vulkan_upscale_frame_command = [
self.context.waifu2x_ncnn_vulkan_legacy_file_name, "-i",
"[input_file]", "-n",
str(self.noise_level), "-s",
str(self.scale_factor)
]
waifu2x_vulkan_options = get_options_from_section(
self.context.config_yaml["waifu2x_ncnn_vulkan"]["output_options"])
# add custom options to waifu2x_vulkan
for element in waifu2x_vulkan_options:
waifu2x_vulkan_upscale_frame_command.append(element)
waifu2x_vulkan_upscale_frame_command.extend(["-o", "[output_file]"])
return waifu2x_vulkan_upscale_frame_command
def _construct_upscale_command(self) -> list:
waifu2x_converter_cpp_upscale_command = [
self.context.waifu2x_converter_cpp_file_path, "-i", "[input_file]",
"--noise-level",
str(self.noise_level), "--scale-ratio",
str(self.scale_factor)
]
waifu2x_conv_options = get_options_from_section(
self.context.config_yaml["waifu2x_converter"]["output_options"])
# add custom options to waifu2x_vulkan
for element in waifu2x_conv_options:
waifu2x_converter_cpp_upscale_command.append(element)
waifu2x_converter_cpp_upscale_command.extend(["-o", "[output_file]"])
return waifu2x_converter_cpp_upscale_command
def create_video_from_specific_frames(context: Context, file_prefix,
output_file, start_number,
frames_per_video):
"""
Create a video using the 'start_number' ffmpeg flag and the 'vframes' input flag to create a video
using frames for a range of output images.
"""
# load context
logger = context.logger
extension_type = context.extension_type
input_files = file_prefix + "%d" + extension_type
video_from_frames_command = [
context.ffmpeg_dir, "-start_number",
str(start_number), "-hwaccel", context.hwaccel, "-framerate",
str(context.frame_rate), "-i", input_files, "-vframes",
str(frames_per_video), "-r",
str(context.frame_rate)
]
frame_to_video_option = get_options_from_section(
context.config_yaml["ffmpeg"]["frames_to_video"]['output_options'],
ffmpeg_command=True)
for element in frame_to_video_option:
video_from_frames_command.append(element)
video_from_frames_command.extend([output_file])
logger.info("running ffmpeg command: " + str(video_from_frames_command))
console_output = open(
context.console_output_dir + "video_from_frames_command.txt", "w")
console_output.write(str(video_from_frames_command))
subprocess.call(video_from_frames_command,
shell=False,
stderr=console_output,
stdout=console_output)
def __init__(self, context: Context):
self.frame_count = context.frame_count
self.waifu2x_caffe_cui_dir = context.waifu2x_caffe_cui_dir
self.residual_images_dir = context.residual_images_dir
self.residual_upscaled_dir = context.residual_upscaled_dir
self.noise_level = context.noise_level
self.scale_factor = context.scale_factor
self.workspace = context.workspace
self.context = context
self.signal_upscale = True
self.active_waifu2x_subprocess = None
self.start_frame = 1
# Create Caffe Command
self.waifu2x_caffe_upscale_frame = [
self.waifu2x_caffe_cui_dir, "-i", "[input_file]", "-n",
str(self.noise_level), "-s",
str(self.scale_factor)
]
waifu2x_caffe_options = get_options_from_section(
context.config_yaml["waifu2x_caffe"]["output_options"])
for element in waifu2x_caffe_options:
self.waifu2x_caffe_upscale_frame.append(element)
self.waifu2x_caffe_upscale_frame.extend(["-o", "[output_file]"])
# Threading Specific
self.alive = True
self.cancel_token = CancellationToken()
self._stopevent = threading.Event()
threading.Thread.__init__(self, name="Waifu2xCaffeThread")
logging.basicConfig(filename=self.workspace + 'waifu2x.log',
level=logging.INFO)
def __init__(self, context: Context):
# load context
self.frame_count = context.frame_count
self.waifu2x_ncnn_vulkan_file_path = context.waifu2x_ncnn_vulkan_legacy_file_name
self.waifu2x_ncnn_vulkan_path = context.waifu2x_ncnn_vulkan_path
self.residual_images_dir = context.residual_images_dir
self.residual_upscaled_dir = context.residual_upscaled_dir
self.noise_level = context.noise_level
self.scale_factor = context.scale_factor
self.workspace = context.workspace
self.context = context
self.signal_upscale = True
self.active_waifu2x_subprocess = None
self.start_frame = 1
self.waifu2x_vulkan_upscale_frame = [
self.waifu2x_ncnn_vulkan_file_path, "-i", "[input_file]", "-n",
str(self.noise_level), "-s",
str(self.scale_factor)
]
waifu2x_vulkan_options = get_options_from_section(
self.context.config_yaml["waifu2x_ncnn_vulkan"]["output_options"])
# add custom options to waifu2x_vulkan
for element in waifu2x_vulkan_options:
self.waifu2x_vulkan_upscale_frame.append(element)
self.waifu2x_vulkan_upscale_frame.extend(["-o", "[output_file]"])
# Threading Specific
self.alive = True
self.cancel_token = CancellationToken()
self._stopevent = threading.Event()
threading.Thread.__init__(self, name="Waifu2xVulkanThread")
def __init__(self, config_file_unparsed: json):
"""
Create all the needed values that will be used in various parts of dandere2x. A lot of these values
are derived from external files, such as the json, ffmpeg and ffprobe, or are joined from directories.
Having all the variables here allows dandere2x the values needed to be global, but at the same time not really.
"""
self.this_folder = None
# load 'this folder' in a pyinstaller friendly way
if getattr(sys, 'frozen', False):
self.this_folder = os.path.dirname(sys.executable)
elif __file__:
self.this_folder = os.path.dirname(__file__)
self.this_folder = pathlib.Path(self.this_folder)
# Parse the unparsed config into a parsed (../externals -> C:/this_folder/externals)
self.config_yaml = absolutify_yaml(config_file_unparsed,
str(self.this_folder.absolute()),
absolutify_key="..")
################################
# setup all the directories.. #
################################
# TODO: since this is a fail-safe method on loading the waifu2x clients
# we gotta check at least one is ok before running dandere2x?
if self.config_yaml['dandere2x']['usersettings'][
'waifu2x_type'] == "converter_cpp":
self.waifu2x_converter_cpp_path = self.config_yaml[
'waifu2x_converter']['waifu2x_converter_path']
self.waifu2x_converter_file_name = self.config_yaml[
'waifu2x_converter']['waifu2x_converter_file_name']
self.waifu2x_converter_cpp_file_path = os.path.join(
self.waifu2x_converter_cpp_path,
self.waifu2x_converter_file_name)
if self.config_yaml['dandere2x']['usersettings'][
'waifu2x_type'] == "vulkan":
self.waifu2x_ncnn_vulkan_path = self.config_yaml[
'waifu2x_ncnn_vulkan']['waifu2x_ncnn_vulkan_path']
self.waifu2x_ncnn_vulkan_file_name = self.config_yaml[
'waifu2x_ncnn_vulkan']['waifu2x_ncnn_vulkan_file_name']
self.waifu2x_ncnn_vulkan_legacy_file_name = os.path.join(
self.waifu2x_ncnn_vulkan_path,
self.waifu2x_ncnn_vulkan_file_name)
if self.config_yaml['dandere2x']['usersettings'][
'waifu2x_type'] == "vulkan_legacy":
self.waifu2x_ncnn_vulkan_legacy_path = self.config_yaml[
'waifu2x_ncnn_vulkan_legacy'][
'waifu2x_ncnn_vulkan_legacy_path']
self.waifu2x_ncnn_vulkan_legacy_file_name = self.config_yaml[
'waifu2x_ncnn_vulkan_legacy'][
'waifu2x_ncnn_vulkan_legacy_file_name']
self.waifu2x_ncnn_vulkan_legacy_file_path = os.path.join(
self.waifu2x_ncnn_vulkan_legacy_path,
self.waifu2x_ncnn_vulkan_legacy_file_name)
if self.config_yaml['dandere2x']['usersettings'][
'waifu2x_type'] == "caffe":
self.waifu2x_caffe_cui_dir = self.config_yaml['waifu2x_caffe'][
'waifu2x_caffe_path']
self.workspace = self.config_yaml['dandere2x']['developer_settings'][
'workspace']
self.workspace_use_temp = self.config_yaml['dandere2x'][
'developer_settings']['workspace_use_temp']
# if we're using a temporary workspace, assign workspace to be in the temp folder
if self.workspace_use_temp:
self.workspace = os.path.join(pathlib.Path(tempfile.gettempdir()),
'dandere2x') + os.path.sep
# setup directories
self.input_frames_dir = self.workspace + "inputs" + os.path.sep
self.residual_images_dir = self.workspace + "residual_images" + os.path.sep
self.residual_upscaled_dir = self.workspace + "residual_upscaled" + os.path.sep
self.residual_data_dir = self.workspace + "residual_data" + os.path.sep
self.pframe_data_dir = self.workspace + "pframe_data" + os.path.sep
self.correction_data_dir = self.workspace + "correction_data" + os.path.sep
self.merged_dir = self.workspace + "merged" + os.path.sep
self.fade_data_dir = self.workspace + "fade_data" + os.path.sep
self.debug_dir = self.workspace + "debug" + os.path.sep
self.log_dir = self.workspace + "logs" + os.path.sep
self.compressed_static_dir = self.workspace + "compressed_static" + os.path.sep
self.compressed_moving_dir = self.workspace + "compressed_moving" + os.path.sep
self.encoded_dir = self.workspace + "encoded" + os.path.sep
self.temp_image_folder = self.workspace + "temp_image_folder" + os.path.sep
# put all the directories that need to be created into a list for creation / deleting.
self.directories = {
self.workspace, self.input_frames_dir, self.correction_data_dir,
self.residual_images_dir, self.residual_upscaled_dir,
self.merged_dir, self.residual_data_dir, self.pframe_data_dir,
self.debug_dir, self.log_dir, self.compressed_static_dir,
self.compressed_moving_dir, self.fade_data_dir, self.encoded_dir,
self.temp_image_folder
}
self.ffmpeg_dir = self.config_yaml['ffmpeg']['ffmpeg_path']
self.ffprobe_dir = self.config_yaml['ffmpeg']['ffprobe_path']
self.hwaccel = self.config_yaml['ffmpeg']['-hwaccel']
################################
# Load Dandere2x User Settings #
################################
# User Settings
self.block_size = self.config_yaml['dandere2x']['usersettings'][
'block_size']
self.quality_minimum = self.config_yaml['dandere2x']['usersettings'][
'quality_minimum']
self.waifu2x_type = self.config_yaml['dandere2x']['usersettings'][
'waifu2x_type']
self.noise_level = self.config_yaml['dandere2x']['usersettings'][
'denoise_level']
self.scale_factor = self.config_yaml['dandere2x']['usersettings'][
'scale_factor']
self.input_file = self.config_yaml['dandere2x']['usersettings'][
'input_file']
self.output_file = self.config_yaml['dandere2x']['usersettings'][
'output_file']
# Developer Settings
self.quality_moving_ratio = self.config_yaml['dandere2x'][
'developer_settings']['quality_moving_ratio']
self.step_size = self.config_yaml['dandere2x']['developer_settings'][
'step_size']
self.bleed = self.config_yaml['dandere2x']['developer_settings'][
'bleed']
self.extension_type = self.config_yaml['dandere2x'][
'developer_settings']['extension_type']
self.debug = self.config_yaml['dandere2x']['developer_settings'][
'debug']
self.dandere2x_cpp_dir = self.config_yaml['dandere2x'][
'developer_settings']['dandere2x_cpp_dir']
self.correction_block_size = 2
# FFMPEG Pipe Encoding, NOTE: THIS OVERRIDES REALTIME ENCODING
self.ffmpeg_pipe_encoding = self.config_yaml['dandere2x'][
'developer_settings']['ffmpeg_pipe_encoding']
self.ffmpeg_pipe_encoding_type = self.config_yaml['dandere2x'][
'developer_settings']['ffmpeg_pipe_encoding_type']
self.nosound_file = os.path.join(
self.workspace,
"nosound") # missing an extension, will set it in a few
if not self.ffmpeg_pipe_encoding:
# Real Time Encoding, traditional way
self.realtime_encoding_enabled = self.config_yaml['dandere2x'][
'developer_settings']['realtime_encoding'][
'realtime_encoding_enabled']
self.realtime_encoding_delete_files = \
self.config_yaml['dandere2x']['developer_settings']['realtime_encoding']['realtime_encoding_delete_files']
self.realtime_encoding_seconds_per_video = \
self.config_yaml['dandere2x']['developer_settings']['realtime_encoding'][
'realtime_encoding_seconds_per_video']
else:
# disable traditional "RTE" because we're piping
self.realtime_encoding_enabled = False
# get the substring after the last dot in the output_file "asd/aert/asd.mkv" --> "mkv"
# but "important/rapgod" will default to rapgod.mp4 because we'll get
# pipe_ext equals to the string itself "important/rapgod" and that's not an format :P
supported_formats = [".mkv", ".mp4", ".avi"]
pipe_ext = "." + self.output_file.split(".")[-1]
# add the extension to nosound file
self.nosound_file += ".mp4" if not pipe_ext in supported_formats else pipe_ext
##################
# Video Settings #
##################
# find out if the user trimmed a video by checking the time part of the json. IF theres nothing there,
# then the user didn't trim anything
self.user_trim_video = False
find_out_if_trim = get_options_from_section(
self.config_yaml["ffmpeg"]["trim_video"]['time'])
if find_out_if_trim:
self.user_trim_video = True
# load the needed video settings
self.video_settings = VideoSettings(self.ffprobe_dir, self.input_file)
self.frame_rate = math.ceil(self.video_settings.frame_rate)
self.width, self.height = self.video_settings.width, self.video_settings.height
self.frame_count = 0
