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アニメ『小林さんちのメイドラゴンS』ノンテロップオープニング映像-bEb4xT8lnYU.mkv', idx=lambda x: source(x, force_lsmas=True, cachedir='')) YT_NCED = FileInfo( 'sources/【期間限定公開】TVアニメ『小林さんちのメイドラゴンS』ノンテロップエンディング映像-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: