def extract_frames(clip: vs.VideoNode,
name: str,
path: str = 'assets') -> None:
"""
Extract all frames of a given clip to a given directory.
Heavily based off of vardautomation's Extract function,
but simplified to only have what I personally need here.
"""
from lvsfunc.render import clip_async_render
frames = clip.num_frames
frames = range(frames)
clip = clip.resize.Bicubic(format=vs.RGB24,
matrix_in=1,
dither_type='error_diffusion')
clip = clip.std.ShufflePlanes([1, 2, 0], vs.RGB).std.AssumeFPS(fpsnum=1,
fpsden=1)
path_images = [
VPath(path) / VPath(
(f'{name}_' + f'{f}'.zfill(len("%i" % max(frames))) + '.png'))
for f in frames
]
try:
VPath(path).mkdir(parents=True)
except FileExistsError:
pass
# Frames are extracted using ffmpeg. This is much faster than using imwri
outputs = []
for i, path_image in enumerate(path_images):
outputs += [
'-compression_level',
str(-1), '-pred', 'mixed', '-ss', f'{i}', '-t', '1',
f'{path_image.to_str()}'
]
settings = [
'-hide_banner', '-loglevel', 'error', '-f', 'rawvideo', '-video_size',
f'{clip.width}x{clip.height}', '-pixel_format', 'gbrp', '-framerate',
str(clip.fps), '-i', 'pipe:', *outputs
]
encoder = VideoEncoder(BinaryPath.ffmpeg, settings)
def _cb(n: int, f: vs.VideoFrame) -> None:
encoder.run_enc(clip, None, y4m=False)
clip_async_render(clip,
progress=f"Extracting frames to {path}...",
callback=_cb)
def run(self, clean_up: bool = True, make_comp: bool = True) -> None:
"""
:param clean_up: Perform clean-up procedure after encoding
:param make_comp: Create a slowpics-compatible comparison between src, flt, and enc
"""
v_encoder = X265Encoder('settings/x265_settings_BD')
v_lossless_encoder = FFV1Encoder()
self.clip = dither_down(self.clip)
video_track = VideoStream(self.file.name_clip_output,
'HEVC BDRip by LightArrowsEXE@Kaleido',
JAPANESE)
audio_files = video_source(self.file.path.to_str(),
out_file=self.file.a_src_cut,
trim_list=resolve_trims(
self.file.trims_or_dfs),
trims_framerate=self.file.clip.fps,
frames_total=self.file.clip.num_frames,
flac=False,
aac=True,
silent=False)
audio_tracks: List[AudioStream] = []
for track in audio_files:
audio_tracks += [
AudioStream(VPath(track), 'AAC 2.0', JAPANESE, XML_TAG)
]
muxer = Mux(self.file, streams=(video_track, audio_tracks, None))
config = RunnerConfig(v_encoder=v_encoder,
v_lossless_encoder=v_lossless_encoder,
a_extracters=None,
a_cutters=None,
a_encoders=None,
muxer=muxer)
runner = SelfRunner(self.clip, self.file, config)
runner.run()
if clean_up:
runner.do_cleanup()
for at in audio_files:
try:
os.remove(at)
except FileNotFoundError:
Status.warn(f"File {at} not found! Skipping...")
if make_comp:
try:
generate_comparison(self.file,
self.file.name_file_final.to_str(),
self.clip)
except ValueError as e:
print(e)
def run(self,
clean_up: bool = True,
zones: Optional[Dict[Tuple[int, int], Dict[str,
Any]]] = None) -> None:
"""
:param clean_up: Perform clean-up procedure after encoding
:param zones: Zones for x265
"""
v_encoder = X265Encoder('settings/x265_settings', zones=zones)
v_lossless_encoder = FFV1Encoder()
self.clip = dither_down(self.clip)
video_track = VideoStream(self.file.name_clip_output,
'HEVC BDRip by LightArrowsEXE@Kaleido',
JAPANESE)
audio_files = video_source(self.file.path.to_str(),
out_file=self.file.a_src_cut,
trim_list=resolve_trims(
self.file.trims_or_dfs),
trims_framerate=self.file.clip.fps,
frames_total=self.file.clip.num_frames,
flac=True,
aac=False,
silent=False)
audio_tracks: List[AudioStream] = []
for track in audio_files:
audio_tracks += [AudioStream(VPath(track), 'FLAC 2.0', JAPANESE)]
muxer = Mux(self.file, streams=(video_track, audio_tracks, None))
config = RunnerConfig(v_encoder=v_encoder,
v_lossless_encoder=v_lossless_encoder,
a_extracters=None,
a_cutters=None,
a_encoders=None,
muxer=muxer)
runner = SelfRunner(self.clip, self.file, config)
runner.run()
if clean_up:
runner.do_cleanup()
for at in audio_files:
try:
os.remove(at)
except FileNotFoundError:
Status.warn(f"File {at} not found! Skipping...")
def run(self, clean_up: bool = True, make_comp: bool = True) -> None:
"""
:param clean_up: Perform clean-up procedure after encoding
:param make_comp: Create a slowpics-compatible comparison between src, flt, and enc
"""
assert self.audio_file.a_src
assert self.audio_file.a_enc_cut
v_encoder = X265Encoder('settings/x265_settings')
self.clip = dither_down(self.clip)
audio_files = video_source(self.file.path.to_str(),
trim_list=resolve_trims(
self.file.trims_or_dfs),
trims_framerate=self.file.clip.fps,
flac=False,
aac=True,
silent=False)
audio_tracks: List[AudioStream] = []
for track in audio_files:
audio_tracks += [
AudioStream(VPath(track), 'AAC 2.0', JAPANESE, XML_TAG)
]
muxer = Mux(self.file,
streams=(VideoStream(
self.file.name_clip_output,
'HEVC BDRip by LightArrowsEXE@Kaleido',
JAPANESE), audio_tracks, None))
config = RunnerConfig(v_encoder, None, None, None, None, muxer)
runner = SelfRunner(self.clip, self.file, config)
runner.run()
try:
if make_comp:
generate_comparison_NCOP1(self.file,
self.file.name_file_final.to_str(),
self.clip)
except ValueError as e:
Status.fail(str(e))
if clean_up:
runner.do_cleanup()
def run(self) -> None:
assert self.file.a_src
assert self.file.a_enc_cut
self.preqpfileflt()
v_encoder = X265Encoder('x265', 'settings/x265_settings_BD')
p = Patch(file_to_fix=f'premux/{JPBD_NCOP.name[:-2]}01 (Premux).mkv',
filtered_clip=filtered,
frame_start=281,
frame_end=527,
encoder=X265Encoder('x265', 'settings/x265_settings_BD'),
file=JPBD_NCOP,
output_filename=VPath(fr"{JPBD_NCOP.name} (Premux).mkv"))
p.run()
p.do_cleanup()
def run(self,
clean_up: bool = True,
wraw: bool = False,
make_comp: bool = True) -> None:
assert self.file.a_src
assert self.file.a_enc_cut
settings_file = 'settings/x264_settings' if not wraw else 'settings/x264_settings_wraw'
v_encoder = X264Encoder(settings_file)
self.clip = dither_down(self.clip)
audio_files = ap_video_source(self.file.path.to_str(),
trimlist=verify_trim(
self.file.trims_or_dfs),
framerate=self.file.clip.fps,
noflac=True,
noaac=False,
silent=False)
audio_tracks: List[AudioStream] = []
for track in audio_files:
audio_tracks += [
AudioStream(VPath(track), 'AAC 2.0', JAPANESE, XML_TAG)
]
muxer = Mux(self.file,
streams=(VideoStream(
self.file.name_clip_output,
'h264 WEBrip by LightArrowsEXE@DameDesuYo',
JAPANESE), audio_tracks, None))
config = RunnerConfig(v_encoder, None, None, None, None, muxer)
runner = SelfRunner(self.clip, self.file, config)
runner.run()
appendCRC(self.file.name_file_final)
if make_comp:
generate_comparison(self.file, self.file.name_file_final.to_str(),
self.clip)
if clean_up:
runner.do_cleanup()
from project_module import encoder as enc
from project_module import flt
core = vs.core
shader_file = 'assets/FSRCNNX_x2_16-0-4-1.glsl'
if not Path(shader_file).exists():
hookpath = r"mpv/shaders/FSRCNNX_x2_16-0-4-1.glsl"
shader_file = os.path.join(str(os.getenv("APPDATA")), hookpath)
# Sources
JP_BD = FileInfo(r"E:/src/Idol Time PriPara/IDOL_TIME_PRIPARA_BDBOX4_D2/BDMV/STREAM/00016.m2ts", (24, -24),
idx=lambda x: source(x, force_lsmas=True, cachedir=''), preset=[PresetBD, PresetFLAC])
JP_BD.name_file_final = VPath(fr"premux/{JP_BD.name} (Premux).mkv")
JP_BD.a_src_cut = JP_BD.name
JP_BD.do_qpfile = True
zones: Dict[Tuple[int, int], Dict[str, Any]] = { # Zones for x265
}
def filterchain() -> Union[vs.VideoNode, Tuple[vs.VideoNode, ...]]:
"""Main VapourSynth filterchain"""
import havsfunc as haf
import lvsfunc as lvf
import vardefunc as vdf
from ccd import ccd
from muvsfunc import SSIM_downsample
from project_module import encoder as enc
from project_module import flt # noqa
core = vs.core
make_wraw: bool = False # Create a workraw
enc_type = 'Premux' if not make_wraw else 'wraw'
EP_NUM = __file__[-5:-3]
# Sources
JP_clip = FileInfo(
f'sources/{EP_NUM}/Jahy-sama wa Kujikenai E{EP_NUM} [1080p][AAC][JapDub][GerEngSub][Web-DL].mkv',
idx=lambda x: source(x, force_lsmas=True, cachedir=''),
preset=[PresetWEB, PresetAAC])
JP_clip.name_file_final = VPath(
f"{enc_type.lower()}/Jahy_{EP_NUM} ({enc_type}).mkv")
JP_clip.name_clip_output = VPath(JP_clip.name + '.265')
JP_clip.do_qpfile = True
# Common variables
# OP/ED frames
opstart: Union[int, bool] = 2014
edstart: Union[int, bool] = 31746
op_offset: int = 1
ed_offset: int = 1
freeze_ranges: List[List[int]] = [ # [start_frame, end_frame, frame]
[opstart, opstart + 18, opstart],
[opstart + 87, opstart + 96, opstart + 87],
[opstart + 201, opstart + 207, opstart],
[opstart + 238, opstart + 244, opstart],
from bento_filters import flt
core = vs.core
core.num_threads = 16
EPNUM = __file__[-5:-3]
# Sources
JPBD_NCOP = FileInfo(r'BDMV/Vol.1/BDMV/STREAM/00003.m2ts', 0, -24,
idx=lambda x: source(x, cachedir=''),
preset=[PresetBD, PresetFLAC])
JPBD_EP = FileInfo(r'BDMV/Vol.1/BDMV/STREAM/00001.m2ts', 2877, 2877+JPBD_NCOP.clip_cut.num_frames,
idx=lambda x: source(x, cachedir=''),
preset=[PresetBD, PresetFLAC])
JPBD_NCOP.name_file_final = VPath(fr"premux/{JPBD_NCOP.name} (Premux).mkv")
JPBD_NCOP.do_qpfile = True
# Common variables
replace_op: List[Range] = [(418, 526)]
op_aisle: List[Range] = [(281, 373)]
red_circle: List[Range] = [(1934, 1951), (1956, 1979), (1984, 2054)]
def main() -> vs.VideoNode:
"""Vapoursynth filtering"""
from adptvgrnMod import adptvgrnMod
from havsfunc import FastLineDarkenMOD
from vsutil import depth
def run(self,
clean_up: bool = True,
make_comp: bool = True,
zones: Optional[Dict[Tuple[int, int], Dict[str,
Any]]] = None) -> None:
"""
:param clean_up: Perform clean-up procedure after encoding
:param make_comp: Create a slowpics-compatible comparison between src, flt, and enc
"""
assert self.file.a_src
v_encoder = X265Encoder(pick_settings(self.file), zones=zones)
self.clip = dither_down(self.clip)
audio_files = video_source(self.file.path.to_str(),
trim_list=resolve_trims(
self.file.trims_or_dfs),
trims_framerate=self.file.clip.fps,
flac=False,
aac=True,
silent=False)
audio_tracks: List[AudioStream] = []
for track in audio_files:
audio_tracks += [
AudioStream(VPath(track), 'AAC 2.0', JAPANESE, XML_TAG)
]
if self.chapter_list:
assert self.file.chapter
assert self.file.trims_or_dfs
if not isinstance(self.chapter_offset, int):
self.chapter_offset = self.file.trims_or_dfs[
0] * -1 # type: ignore
chapxml = MatroskaXMLChapters(self.file.chapter)
chapxml.create(self.chapter_list, self.file.clip.fps)
chapxml.shift_times(self.chapter_offset,
self.file.clip.fps) # type: ignore
chapxml.set_names(self.chapter_names)
chapters = ChapterStream(chapxml.chapter_file, JAPANESE)
muxer = Mux(self.file,
streams=(VideoStream(
self.file.name_clip_output,
'HEVC BDRip by LightArrowsEXE@Kaleido',
JAPANESE), audio_tracks,
chapters if self.chapter_list else None))
config = RunnerConfig(v_encoder, None, None, None, None, muxer)
runner = SelfRunner(self.clip, self.file, config)
runner.run()
try:
if make_comp:
generate_comparison(self.file,
self.file.name_file_final.to_str(),
self.clip)
except ValueError as e:
Status.fail(str(e))
if clean_up:
runner.do_cleanup()
for at in audio_files:
try:
os.remove(at)
except FileNotFoundError:
Status.warn(f"File \"{at}\" not found! Skipping")
# Sources
JP_CR = FileInfo(
f'sources/{EP_NUM}/Kobayashi-san Chi no Maid Dragon S E{EP_NUM} [1080p][AAC][JapDub][GerEngSub][Web-DL].mkv',
idx=lambda x: source(x, force_lsmas=True, cachedir=''))
JP_AOD = FileInfo(
f'sources/{EP_NUM}/Kobayashi-san Chi no Maid Dragon S E{EP_NUM} [1080p+][AAC][JapDub][GerSub][Web-DL].mkv',
idx=lambda x: source(x, force_lsmas=True, cachedir=''),
preset=[PresetWEB, PresetAAC])
YT_NCOP = FileInfo(
'sources/【期間限定公開】TVアニメ『小林さんちのメイドラゴンＳ』ノンテロップオープニング映像-bEb4xT8lnYU.mkv',
idx=lambda x: source(x, force_lsmas=True, cachedir=''))
YT_NCED = FileInfo(
'sources/【期間限定公開】TVアニメ『小林さんちのメイドラゴンＳ』ノンテロップエンディング映像-kMWLe37SMBs.mp4',
idx=lambda x: source(x, force_lsmas=True, cachedir=''))
JP_AOD.name_file_final = VPath(fr"[Premux] Maid Dragon S2 - {EP_NUM}.mkv")
JP_AOD.name_clip_output = VPath(JP_AOD.name + '.264')
JP_AOD.a_src_cut = VPath(f"{JP_AOD.name}_cut.aac")
JP_AOD.do_qpfile = True
# Common variables
# OP/ED frames
opstart: Union[int, bool] = 1582
edstart: Union[int, bool] = False
op_offset: int = 1
ed_offset: int = 1
hardsub_sign: List[
Range] = [ # Leftover hardsubbed signs that need a stronger mask
(129, 184), (14763, 14950), (23616, 23722), (30563, 30597),
(23927, 23991), (16173, 16244), (17328, 17400), (17401, 17472),
def run(self, clean_up: bool = True, make_comp: bool = True) -> None:
"""
:param clean_up: Perform clean-up procedure after encoding
:param make_comp: Create a slowpics-compatible comparison between src, flt, and enc
"""
assert self.file.a_src
is_dvd = False if self.file.clip.width > 1280 else True
if is_dvd:
Status.info("DVD encode detected: Switching over to DVD settings")
x265_settings = 'settings/x265_settings' if not is_dvd else 'settings/x265_settings_dvd'
msg = 'HEVC BDRip by LightArrowsEXE@Kaleido' if not is_dvd else 'HEVC DVDrip by LightArrowsEXE@Kaleido'
v_encoder = X265Encoder(x265_settings)
self.clip = dither_down(self.clip)
audio_files = video_source(self.file.path.to_str(),
trim_list=resolve_trims(
self.file.trims_or_dfs),
trims_framerate=self.file.clip.fps,
flac=False,
aac=True,
silent=False)
if not is_dvd:
audio_tracks: List[AudioStream] = []
for track in audio_files:
audio_tracks += [
AudioStream(VPath(track), 'AAC 2.0', JAPANESE, XML_TAG)
]
else:
a_extracters = FfmpegAudioExtracter(self.file,
track_in=0,
track_out=0)
a_cutters = EztrimCutter(self.file, track=1)
audio_tracks = AudioStream(self.file.a_src_cut.set_track(1),
'AC-3 2.0', JAPANESE)
if self.chapter_list:
assert self.file.chapter
assert self.file.trims_or_dfs
if not isinstance(self.chapter_offset, int):
self.chapter_offset = self.file.trims_or_dfs[
0] * -1 # type: ignore
chapxml = MatroskaXMLChapters(self.file.chapter)
chapxml.create(self.chapter_list, self.file.clip.fps)
chapxml.shift_times(self.chapter_offset,
self.file.clip.fps) # type: ignore
chapxml.set_names(self.chapter_names)
chapters = ChapterStream(chapxml.chapter_file, JAPANESE)
muxer = Mux(self.file,
streams=(VideoStream(self.file.name_clip_output, msg,
JAPANESE), audio_tracks,
chapters if self.chapter_list else None))
if not is_dvd:
config = RunnerConfig(v_encoder, None, None, None, None, muxer)
else:
config = RunnerConfig(v_encoder, None, a_extracters, a_cutters,
None, muxer)
runner = SelfRunner(self.clip, self.file, config)
runner.run()
try:
if make_comp:
generate_comparison(self.file,
self.file.name_file_final.to_str(),
self.clip)
except ValueError as e:
Status.fail(str(e))
if clean_up:
runner.do_cleanup()
def run(self, clean_up: bool = True,
make_comp: bool = True,
wraw: bool = False,
ep_num: Optional[int] = None) -> None:
"""
:param clean_up: Perform clean-up procedure after encoding
:param make_comp: Create a slowpics-compatible comparison between src, flt, and enc
"""
assert self.file.a_src
assert self.file.a_src_cut
v_encoder = X265Encoder('settings/x265_settings') if not wraw \
else X264Encoder('settings/x264_settings_wraw')
self.clip = dither_down(self.clip)
a_extracters = [
BasicTool(
'eac3to',
[self.file.path.to_str(),
'2:', self.file.a_src.set_track(1).to_str()]
)
]
a_cutters = [EztrimCutter(self.file, track=1)]
if self.chapter_list:
assert self.file.chapter
assert self.file.trims_or_dfs
if not isinstance(self.chapter_offset, int):
self.chapter_offset = self.file.trims_or_dfs[0] * -1 # type: ignore
chapxml = MatroskaXMLChapters(self.file.chapter)
chapxml.create(self.chapter_list, self.file.clip.fps)
chapxml.shift_times(self.chapter_offset, self.file.clip.fps) # type: ignore
chapxml.set_names(self.chapter_names)
chapters = ChapterStream(chapxml.chapter_file, JAPANESE)
metadata_message = 'HEVC WEBrip by LightArrowsEXE@GoodJob!Media' if not wraw \
else 'h264 Workraw by LightArrowsEXE@GoodJob!Media'
muxer = Mux(
self.file,
streams=(
VideoStream(self.file.name_clip_output, metadata_message, JAPANESE),
AudioStream(self.file.a_src_cut.set_track(1), 'AAC 2.0', JAPANESE),
chapters if self.chapter_list else None
)
)
config = RunnerConfig(v_encoder, None, a_extracters, a_cutters, None, muxer)
runner = SelfRunner(self.clip, self.file, config)
runner.run()
appendCRC(self.file.name_file_final)
if make_comp:
try:
generate_comparison(self.file, self.file.name_file_final.to_str(), self.clip)
except ValueError as e:
Status.fail(f"{e}")
if wraw:
mini_file = self.file
# One of our staff has limited internet, so we need to mini-fy one wraw.
# Also this can 100% be written way nicer, but I am too lazy and This Works:tm:
wraw2encoder = X264Encoder('settings/x264_settings_wraw_mini')
mini_file.name_file_final = VPath(f"wraw/Jahy_{ep_num} (mini wraw).mkv")
mini_file.name_clip_output = VPath(mini_file.name_clip_output.to_str()[:-4] + '_mini.265')
wraw2muxer = Mux(
mini_file,
streams=(
VideoStream(mini_file.name_clip_output, metadata_message, JAPANESE),
AudioStream(self.file.a_src_cut.set_track(1), 'AAC 2.0', JAPANESE),
chapters if self.chapter_list else None
)
)
wraw2config = RunnerConfig(wraw2encoder, None, a_extracters, a_cutters, None, wraw2muxer)
wraw2runner = SelfRunner(self.clip, self.file, wraw2config)
wraw2runner.run()
appendCRC(mini_file.name_file_final)
if make_comp:
try:
generate_comparison(self.file, self.file.name_file_final.to_str(), self.clip)
except ValueError as e:
Status.fail(f"{e}")
if clean_up:
wraw2runner.do_cleanup()
if clean_up:
try:
runner.do_cleanup()
except:
pass
# Sources
JP_BD = FileInfo(
r'BDMV/[BDMV][210728][Yuru Camp Season 2][Vol.3 Fin]/BD/BDMV/STREAM/00005.m2ts',
[(24, -24)],
idx=lambda x: source(x, force_lsmas=True, cachedir=''),
preset=[PresetBD, PresetAAC])
JP_NCOP = FileInfo(
r'BDMV/[BDMV][210728][Yuru Camp Season 2][Vol.3 Fin]/BD/BDMV/STREAM/00013.m2ts',
[(24, -24)],
idx=lambda x: source(x, force_lsmas=True, cachedir=''))
JP_NCED = FileInfo(
r'BDMV/[BDMV][210728][Yuru Camp Season 2][Vol.3 Fin]/BD/BDMV/STREAM/00014.m2ts',
[(24, -24)],
idx=lambda x: source(x, force_lsmas=True, cachedir=''))
JP_BD.name_file_final = VPath(f"premux/{JP_BD.name} (Premux).mkv")
JP_BD.a_src_cut = VPath(JP_BD.name)
JP_BD.do_qpfile = True
# OP/ED scenefiltering
opstart = 2882
edstart = 31528
op_offset = 7
ed_offset = 3
def filterchain() -> Union[vs.VideoNode, Tuple[vs.VideoNode, ...]]:
"""Main VapourSynth filterchain"""
import EoEfunc as eoe
import lvsfunc as lvf
import vardefunc as vdf
import vapoursynth as vs
from lvsfunc.misc import source
from vardautomation import FileInfo, PresetAAC, PresetWEB, VPath
from project_module import enc, flt
core = vs.core
use_cuda: bool = __name__ == '__main__'
# Sources
JP_BD = FileInfo(r'src/fate project 2021.dgi', [(165411, 166311)],
idx=lambda x: source(x),
preset=[PresetWEB, PresetAAC])
JP_BD.name_file_final = VPath(f"premux/{JP_BD.name} (Premux).mkv")
JP_BD.a_src = VPath(JP_BD.path_without_ext.to_str() + "_track_1.aac")
JP_BD.do_qpfile = True
def filterchain() -> Union[vs.VideoNode, Tuple[vs.VideoNode, ...]]:
"""Main VapourSynth filterchain"""
import EoEfunc as eoe
import havsfunc as haf
import lvsfunc as lvf
import vardefunc as vdf
from vsutil import depth
src = JP_BD.clip_cut
yt = lvf.src(r"src/『魔法使いの夜』ティザーPV-NHIgc-seeSo.mkv", ref=src) \
.std.AssumeFPS(fpsnum=24000, fpsden=1001)
from project_module import encoder as enc
from project_module import flt
core = vs.core
shader_file = Path(r'assets/FSRCNNX_x2_56-16-4-1.glsl')
if not shader_file.exists:
hookpath = r"mpv/shaders/FSRCNNX_x2_56-16-4-1.glsl"
shader_file = os.path.join(os.getenv("APPDATA"), hookpath)
# Sources
JP_BD = FileInfo(r'src/4mx21x.mkv', (None, None),
preset=[PresetBD, PresetFLAC],
idx=lambda x: source(x, force_lsmas=True, cachedir=''))
JP_BD.name_file_final = VPath(fr"premux/{JP_BD.name} (Premux).mkv")
JP_BD.a_src_cut = VPath("stack black.flac")
JP_BD.do_qpfile = True
"""
Switch OP has significantly more detail, but the Steam OP has much less haloing
and weird "wavey" artefacting (but also uses the wrong colourspace lol).
I can't really take the best of both worlds unfortunately,
so it's a trade-off between whether you like having more detail or less artefacting.
If you prefer less artefacting, grab the OPMan release. Else this one.
"""
def filterchain() -> Union[vs.VideoNode, Tuple[vs.VideoNode, ...]]:
"""Main filterchain"""
import lvsfunc as lvf
core = vs.core
core.num_threads = 4
# Sources
JP_DVD = FileInfo(r'BDMV/130208_JOSHIRAKU_OAD/VIDEO_TS/VTS_01_0.d2v', (26, -34),
idx=lambda x: source(x, rff=False), preset=[PresetBD, PresetAAC])
JP_BD_NCOP = FileInfo(r'BDMV/120926_JOSHIRAKU_VOL1/BDMV/STREAM/00001.m2ts', (24, -24),
idx=lambda x: source(x, cachedir=''))
JP_BD_NCED = FileInfo(r'BDMV/120926_JOSHIRAKU_VOL1/BDMV/STREAM/00002.m2ts', (24, -24),
idx=lambda x: source(x, cachedir=''))
JP_BD_03 = FileInfo(r'BDMV/121024_JOSHIRAKU_VOL2/BDMV/STREAM/00000.m2ts', (24, 34789),
idx=lambda x: source(x, cachedir=''))
JP_DVD.clip = core.std.AssumeFPS(JP_DVD.clip, fpsnum=24000, fpsden=1001) # To get it to trim properly
JP_DVD.name_file_final = VPath(fr"premux/{JP_DVD.name} (Premux).mkv")
JP_DVD.a_src = VPath(r"BDMV/130208_JOSHIRAKU_OAD/VIDEO_TS/VTS_01_0 T80 stereo 448 kbps DELAY 0 ms.ac3")
JP_DVD.a_src_cut = VPath(f"{JP_DVD.name}_cut.ac3")
JP_DVD.do_qpfile = True
PROPS_DVD: Set[Tuple[str, int]] = {
('_ChromaLocation', 0),
('_Matrix', 6),
('_Transfer', 6),
('_Primaries', 6),
('_FieldBased', 0)
}
PROPS_BD: Set[Tuple[str, int]] = {
('_Matrix', 1),
def run(self, clean_up: bool = True, make_comp: bool = True) -> None:
"""
:param clean_up: Perform clean-up procedure after encoding
:param make_comp: Create a slowpics-compatible comparison between src, flt, and enc
"""
assert self.file.a_src
v_encoder = X265Encoder('settings/x265_settings')
self.clip = dither_down(self.clip)
audio_files = video_source(self.file.path.to_str(),
trimlist=verify_trim(
self.file.trims_or_dfs),
framerate=self.file.clip.fps,
noflac=True,
noaac=False,
silent=False)
audio_tracks: List[AudioStream] = []
for track in audio_files:
audio_tracks += [
AudioStream(VPath(track), 'AAC 2.0', JAPANESE, XML_TAG)
]
if self.chapter_list:
assert self.file.chapter
assert self.file.trims_or_dfs
Path("/chapters").mkdir(parents=True, exist_ok=True)
if not isinstance(self.chapter_offset, int):
self.chapter_offset = self.file.trims_or_dfs[
0] * -1 # type: ignore
chapxml = MatroskaXMLChapters(self.file.chapter)
chapxml.create(self.chapter_list, self.file.clip.fps)
chapxml.shift_times(self.chapter_offset,
self.file.clip.fps) # type: ignore
chapxml.set_names(self.chapter_names)
chapters = ChapterStream(chapxml.chapter_file, JAPANESE)
muxer = Mux(self.file,
streams=(VideoStream(
self.file.name_clip_output,
'HEVC BDRip by LightArrowsEXE@Kaleido',
JAPANESE), audio_tracks,
chapters if self.chapter_list else None))
config = RunnerConfig(v_encoder, None, None, None, None, muxer)
runner = SelfRunner(self.clip, self.file, config)
runner.run()
try:
if make_comp:
generate_comparison(self.file,
self.file.name_file_final.to_str(),
self.clip)
except ValueError as e:
Status.fail(str(e))
if clean_up:
runner.do_cleanup()
core.num_threads = 4
# Sources
JP_BD = FileInfo(r'BDMV//00003.m2ts', (24, -24),
idx=lambda x: source(x, cachedir=''),
preset=[PresetBD, PresetAAC, PresetChapXML])
JP_BD_NCOP = FileInfo(r'BDMV/120926_JOSHIRAKU_VOL1/BDMV/STREAM/00001.m2ts',
(24, -24),
idx=lambda x: source(x, cachedir=''))
JP_BD_NCED = FileInfo(r'BDMV/120926_JOSHIRAKU_VOL1/BDMV/STREAM/00002.m2ts',
(24, -24),
idx=lambda x: source(x, cachedir=''))
JP_BD_03 = FileInfo(r'BDMV/121024_JOSHIRAKU_VOL2/BDMV/STREAM/00000.m2ts',
(24, 2182),
idx=lambda x: source(x, cachedir=''))
JP_BD.name_file_final = VPath(fr"premux/{JP_BD.name} (Premux).mkv")
JP_BD.a_src_cut = VPath(f"{JP_BD.name}_cut.aac")
JP_BD.do_qpfile = True
# OP/ED Variables
opstart = 0
edstart = 31888
op_offset = 2
ed_offset = 1
def filterchain() -> Union[vs.VideoNode, Tuple[vs.VideoNode, ...]]:
"""Main filterchain"""
import havsfunc as haf
import lvsfunc as lvf
import rekt
import vapoursynth as vs
from lvsfunc.misc import source
from lvsfunc.types import Range
from vardautomation import FileInfo, PresetWEB, PresetAAC, VPath
from project_module import encoder as enc
core = vs.core
# Sources
JP_TV = FileInfo(
r'src/Code Geass - Hangyaku no Lelouch - 01 [15th Anniversary Rebroadcast] (TBS).d2v',
(50972, 53670),
preset=[PresetWEB, PresetAAC],
idx=lambda x: source(x))
JP_TV.name_file_final = VPath(fr"premux/{JP_TV.name} (Premux).mkv")
JP_TV.a_src = VPath(JP_TV.path.to_str()[:-4] + ".aac")
JP_TV.a_src_cut = VPath(JP_TV.path.to_str()[:-4] + "_cut.aac")
JP_TV.do_qpfile = True
zones: Dict[Tuple[int, int], Dict[str, Any]] = { # Zones for x265
}
def filterchain() -> Union[vs.VideoNode, Tuple[vs.VideoNode, ...]]:
"""Main filterchain"""
import debandshit as dbs
import lvsfunc as lvf
from adptvgrnMod import adptvgrnMod
from vsutil import depth
def run(self,
clean_up: bool = True,
make_comp: bool = True,
BDMV: bool = False,
zones: Optional[Dict[Tuple[int, int], Dict[str,
Any]]] = None) -> None:
"""
:param clean_up: Perform clean-up procedure after encoding
:param make_comp: Create a slowpics-compatible comparison between src, flt, and enc
"""
# assert self.file.a_src
v_encoder = X265Encoder(pick_settings(self.file), zones=zones)
v_lossless_encoder = FFV1Encoder()
self.clip = dither_down(self.clip)
if BDMV: # For use with BDMVs, *not* Switch/PS4 rips
audio_files = video_source(self.file.path.to_str(),
out_file=self.file.a_src_cut,
trim_list=resolve_trims(
self.file.trims_or_dfs),
trims_framerate=self.file.clip.fps,
flac=True,
aac=False,
silent=False)
audio_tracks: List[AudioStream] = []
for track in audio_files:
audio_tracks += [
AudioStream(VPath(track), 'FLAC 2.0', JAPANESE)
]
else:
a_extracters = FfmpegAudioExtracter(self.file,
track_in=0,
track_out=0)
a_cutters = EztrimCutter(self.file, track=1)
credit = 'HEVC GameRip by LightArrowsEXE@Kaleido' if not BDMV \
else 'HEVC BDRip by LightArrowsEXE@Kaleido'
muxer = Mux(
self.file,
streams=(VideoStream(
self.file.name_clip_output, credit,
JAPANESE), audio_tracks[0] if BDMV else AudioStream(
self.file.a_src_cut.set_track(1), 'AAC 2.0', JAPANESE),
None))
config = RunnerConfig(v_encoder, v_lossless_encoder,
None if BDMV else a_extracters,
None if BDMV else a_cutters, None, muxer)
runner = SelfRunner(self.clip, self.file, config)
runner.run()
if clean_up:
runner.do_cleanup()
for at in audio_files:
try:
os.remove(at)
except FileNotFoundError:
Status.warn(f"File {at} not found! Skipping")
if make_comp:
try:
generate_comparison(self.file,
self.file.name_file_final.to_str(),
self.clip)
except ValueError as e:
Status.fail(str(e))
core = vs.core
core.num_threads = 16
EPNUM = __file__[-5:-3]
# Sources
JPBD_EP = FileInfo(r'BDMV/Vol.6/BDMV/STREAM/00000.m2ts', 1630, 3789,
idx=lambda x: source(x, cachedir=''))
JPBD_NCOP1 = FileInfo(r'BDMV/Vol.1/BDMV/STREAM/00003.m2ts', 0, -24,
idx=lambda x: source(x, cachedir=''))
JPBD_NCOP2 = FileInfo(r'BDMV/Vol.5/BDMV/STREAM/00002.m2ts', 0, -25,
idx=lambda x: source(x, cachedir=''),
preset=[PresetBD, PresetFLAC])
JPBD_NCOP2.name_file_final = VPath(fr"premux/{JPBD_NCOP2.name} (Premux).mkv")
JPBD_NCOP2.do_qpfile = True
JPBD_NCOP2.a_src = VPath(f"{JPBD_NCOP2.name}.wav")
JPBD_NCOP2.a_src_cut = VPath(f"{JPBD_NCOP2.name}_cut.wav")
JPBD_NCOP2.a_enc_cut = VPath(f"{JPBD_NCOP2.name}_cut.flac")
# Common variables
replace_op: List[Range] = [(0, 205), (527, 597), (1350, 1575), (1613, 1673), (1735, 1933)]
replace_ep: List[Range] = [(206, 280), (425, 526), (1248, 1316)]
op_aisle: List[Range] = [(281, 373)]
red_circle: List[Range] = [(1934, 1951), (1956, 1979), (1984, 2054)]
replace_ncop: List[Range] = [(206, 280), (1039, 1062), (1554, 1575)]
def main() -> vs.VideoNode:
