def do_wizardry() -> None: """It's magic""" filtered = filtering() if isinstance(filtered, vs.VideoNode): filtered = cast(vs.VideoNode, filtered) else: raise ValueError if not Path(WEB_AOD.name_clip_output).exists(): X265Encoder( 'x265', Path('settings/x265_settings'), filtered, WEB_AOD, progress_update=lambda v, e: print( f"\rVapourSynth: {v}/{e} ~ {100 * v // e}% || Encoder: ", end="")) if not Path(WEB_AOD.a_src.format(1)).exists(): BasicTool('mkvextract', [WEB_AOD.src, 'tracks', f'1:{WEB_AOD.a_src.format(1)}']) assert WEB_AOD.a_src is not None BasicTool('mkvmerge', [ '-o', WEB_AOD.name_file_final, '--track-name', '0:HEVC WEBRip by Vardë@Raws-Maji', '--language', '0:jpn', WEB_AOD.name_clip_output, '--track-name', '0:AAC 2.0', '--language', '0:jpn', WEB_AOD.a_src.format(1) ])
def run(self) -> None: assert self.file.a_src assert self.file.a_enc_cut v_encoder = X265Encoder('x265', 'settings/x265_settings_BD_NCOP1v09') a_extracters = [ BasicTool( 'eac3to', [JPBD_NCOP2.path.to_str(), '2:', self.file.a_src.format(2).to_str()] ) ] a_cutters = [AudioCutter(self.file, track=2)] a_encoders = [FlacEncoder(self.file, track=2)] muxer = Mux( self.file, streams=( VideoStream(self.file.name_clip_output, 'HEVC BDRip by LightArrowsEXE@Kaleido', JAPANESE), AudioStream(self.file.a_enc_cut.format(1), 'FLAC 2.0', JAPANESE), None ) ) config = RunnerConfig(v_encoder, None, a_extracters, a_cutters, a_encoders, muxer) runner = SelfRunner(self.clip, self.file, config) runner.run() runner.do_cleanup()
def run(self) -> None: assert self.file.a_src assert self.file.a_src_cut v_encoder = X265Encoder('settings/x265_settings_BD') ap_video_source( self.file.path_without_ext.to_str() + ".mkv", # mkv because >chapters first and begna's code breaks [self.file.frame_start, self.file.frame_end], framerate=self.clip.fps, noflac=True, noaac=False, nocleanup=False, silent=False) os.rename(self.file.path_without_ext.to_str() + "_2_cut.aac", self.file.a_src_cut.to_str()) muxer = Mux(self.file, streams=(VideoStream( self.file.name_clip_output, 'HEVC BDrip by LightArrowsEXE@Kaleido', JAPANESE), AudioStream(self.file.a_src_cut.format(1), 'AAC 2.0', JAPANESE, XML_TAG), None)) config = RunnerConfig(v_encoder, None, None, None, None, muxer) runner = SelfRunner(self.clip, self.file, config) runner.run() 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 _encode(self: EncodeGoBrrr): if self.file.do_lossless: NvencEncoder('C:/NVEncC_5.30_x64/NVEncC64.exe', Path('love_live_common/nvenc_settings'), self.clip, self.file, progress_update=None) self.clip = core.lsmas.LWLibavSource(self.file.name_clip_output_lossless) X265Encoder('x265', Path('love_live_common/x265_settings'), self.clip, self.file, progress_update=lambda v, e: print(f"\rVapourSynth: {v}/{e} ~ {100 * v // e}% || Encoder: ", end=""))
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 _encode(self: EncodeGoBrrr) -> None: if not Path(self.file.name_clip_output): X265Encoder( 'x265', Path('churutto_common/x265_settings'), self.clip, self.file, progress_update=lambda v, e: print( f"\rVapourSynth: {v}/{e} ~ {100 * v // e}% || Encoder: ", end=""))
def run(self, clean_up: bool = True, make_comp: bool = False, settings: str = 'x265_settings_BD') -> 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(f'settings/{settings}') v_lossless_encoder = FFV1Encoder() self.clip = dither_down(self.clip) video_track = VideoStream(self.file.name_clip_output, 'HEVC TVrip by LightArrowsEXE@Kaleido', JAPANESE) 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)] muxer = Mux(self.file, streams=(video_track, AudioStream(self.file.a_src_cut.set_track(1), 'AAC 2.0', JAPANESE), None)) config = RunnerConfig(v_encoder=v_encoder, v_lossless_encoder=v_lossless_encoder, a_extracters=a_extracters, a_cutters=a_cutters, a_encoders=None, muxer=muxer) runner = SelfRunner(self.clip, self.file, config) runner.run() if clean_up: runner.do_cleanup() 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 __init__(self, file: FileInfo, clip: vs.VideoNode, ED: int = None) -> None: self.file = file self.clip = clip assert self.file.a_src if ED: self.file.trims_or_dfs = [(self.file.trims_or_dfs[0], ED), (ED + 2152, ED + 2157), (ED, ED + 2152), (ED + 2157, self.file.trims_or_dfs[-1])] self.v_encoder = X265Encoder('../encode/settings') self.a_extracter = FFmpegAudioExtracter(self.file, track_in=1, track_out=1) self.a_cutters = EztrimCutter(self.file, track=1) self.a_encoders = QAACEncoder(self.file, track=1)
def patch( self, ranges: Union[Union[int, Tuple[int, int]], List[Union[int, Tuple[int, int]]]], clean_up: bool = True, external_file: Optional[Union[os.PathLike[str], str]] = None) -> None: """ :ranges: Frame ranges that require patching. Expects as a list of tuples or integers (can be mixed). Examples: [(0, 100), (400, 600)]; [50, (100, 200), 500] :param clean_up: Perform clean-up procedure after patching :external_file: File to patch into. This is intended for videos like NCs with only one or two changes so you don't need to encode the entire thing multiple times. It will copy the given file and rename it to ``FileInfo.name_file_final``. If None, performs regular patching. """ v_encoder = X265Encoder('settings/x265_settings') self.clip = dither_down(self.clip) if external_file: if os.path.exists(external_file): Status.info( f"Copying {external_file} to {self.file.name_file_final}") shutil.copy(external_file, self.file.name_file_final) else: Status.warn( f"{self.file.name_file_final} already exists; please ensure it's the correct file!" ) runner = Patch( clip=self.clip, ranges=ranges, # type:ignore[arg-type] encoder=v_encoder, file=self.file, ) runner.run() new = f"{self.file.name_file_final.to_str()[:-4]}_new.mkv" Status.info(f"Replacing {self.file.name_file_final} -> {new}") os.replace(new, self.file.name_file_final) if clean_up: runner.do_cleanup()
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) v_lossless_encoder = FFV1Encoder() self.clip = dither_down(self.clip) muxer = Mux(self.file, streams=(VideoStream( self.file.name_clip_output, 'HEVC Switch GameRip by LightArrowsEXE@Kaleido', JAPANESE), AudioStream(self.file.a_src_cut.format(0), 'FLAC 2.0', JAPANESE), 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() 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))
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))
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
WEB_AOD = FileInfo( fr'5-toubun no Hanayome S02 (The Quintessential Quintuplets S02) [AoD]\5-toubun no Hanayome S02E{NUM} [1080p+][AAC][JapDub][GerSub][Web-DL].mkv', ) WEB_CRU = FileInfo( fr'5-toubun no Hanayome S02 (The Quintessential Quintuplets S02) [CR]\5-toubun no Hanayome S02E{NUM} [1080p][AAC][JapDub][GerEngSub][Web-DL].mkv' ) SUB = fr'5-toubun_no_Hanayome_subs\ger\[FeelsBadSubs] 5-toubun no Hanayome ∬ - {NUM} [1080p].4.ger.ass' FONTDIR = '5-toubun_no_Hanayome_subs/_fonts' ENC_LOSS = LosslessEncoder('nvencc', Path('gotoubun_common/nvenc_settings'), progress_update=None) ENCODER = X265Encoder( 'x265', Path('gotoubun_common/x265_settings'), progress_update=lambda v, e: print( f"\rVapourSynth: {v}/{e} ~ {100 * v // e}% || Encoder: ", end="")) A_EXTRACTER = BasicTool( 'eac3to', [JPBD.src, '2:', JPBD.a_src.format(1), '-log=NUL']) A_CUTTER = AudioCutter(JPBD, track=1) A_ENCODER = AudioEncoder('qaac', Path('gotoubun_common/qaac_settings'), JPBD, track=1) class Filtering(): def main(self) -> vs.VideoNode:
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()
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) v_lossless_encoder = FFV1Encoder() self.clip = dither_down(self.clip) a_extracters = FfmpegAudioExtracter(self.file, track_in=0, track_out=0) 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) muxer = Mux(self.file, streams=(VideoStream( self.file.name_clip_output, 'HEVC TVrip by LightArrowsEXE@Kaleido', 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=v_encoder, v_lossless_encoder=v_lossless_encoder, a_extracters=a_extracters, a_cutters=a_cutters, a_encoders=None, muxer=muxer) runner = SelfRunner(self.clip, self.file, config) runner.run() if clean_up: runner.do_cleanup() 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))
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")
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()