title ¶

@staticmethod
def split_audio(title: Title, splits: list[int], i: int = 0) -> tuple[vs.AudioNode | None, ...]:
    reta = SplitHelper._cut_split(title, splits, title.audios[i], SplitHelper._cut_fz_a)
    assert len(reta) == len(splits) + 1
    return reta

@staticmethod
def split_chapters(title: Title, splits: list[int]) -> list[list[int]]:
    out = list[list[int]]()

    rebase = title.chapters[0]  # normally 0
    chaps = list[int]()

    for i, a in enumerate(title.chapters):
        chaps.append(a - rebase)

        if (i + 1) in splits:
            rebase = a

            out.append(chaps)
            chaps = [0]

    if len(chaps) >= 1:
        out.append(chaps)

    assert len(out) == len(splits) + 1

    return out

@staticmethod
def split_range_ac3(title: Title, f: int, t: int, audio_i: int, outfile: str) -> float:
    nd = vs.core.dvdsrc2.RawAc3(str(title._core.iso_path), title._vts, audio_i, title._dvdsrc_ranges)

    start, end = (get_prop(nd, f"Stuff_{x}_PTS", int) for x in ("Start", "End"))

    debug_print(f"Stuff_Start_PTS pts {start} Stuff_End_PTS {end}")

    raw_start = title._absolute_time[title.chapters[f - 1]] * PCR_CLOCK
    raw_end = (title._absolute_time[title.chapters[t]] + title._duration_times[title.chapters[t]]) * PCR_CLOCK

    start_pts = raw_start + start
    end_pts = start_pts + (raw_end - raw_start)

    audio_offset_pts = 0.0

    with open(outfile, "wb") as outf:
        debug_print(f"start_pts  {start_pts} end_pts {end_pts}")

        start = int(start_pts / AC3_FRAME_LENGTH)

        debug_print("first ", start, len(nd))

        for i, frame in enumerate(nd.frames(close=True)):
            pkt_start_pts = i * AC3_FRAME_LENGTH
            pkt_end_pts = (i + 1) * AC3_FRAME_LENGTH

            assert pkt_end_pts > start_pts

            if pkt_start_pts < start_pts:
                audio_offset_pts = start_pts - pkt_start_pts

            outf.write(bytes(frame[0]))

            if pkt_end_pts > end_pts:
                break

    debug_print("wrote", (i - (start_pts // AC3_FRAME_LENGTH)))
    debug_print("offset is", (audio_offset_pts) / 90, "ms")

    return audio_offset_pts / PCR_CLOCK

@staticmethod
def split_video(title: Title, splits: list[int]) -> tuple[vs.VideoNode | None, ...]:
    reta = SplitHelper._cut_split(title, splits, title.video, SplitHelper._cut_fz_v)
    assert len(reta) == len(splits) + 1
    return reta

def ac3(self, outfile: str, audio_i: int = 0) -> float:
    return SplitHelper.split_range_ac3(self._title, *self._split_chpts, audio_i, outfile)

def dump_ac3(self, a: str, audio_i: int = 0, only_calc_delay: bool = False) -> float:
    self._assert_dvdsrc2(self.dump_ac3)

    if not self._audios[audio_i].startswith("ac3"):
        raise CustomValueError(f"Audio at {audio_i} is not ac3", self.dump_ac3)

    nd = vs.core.dvdsrc2.RawAc3(str(self._core.iso_path), self._vts, audio_i, self._dvdsrc_ranges)

    if not only_calc_delay:
        with open(a, "wb") as wrt:
            for f in nd.frames():
                wrt.write(bytes(f[0]))

    return float(get_prop(nd, "Stuff_Start_PTS", int)) / PCR_CLOCK

def preview(self, split: SplitTitle | Sequence[SplitTitle] | None = None) -> None:
    set_output(self.video, f"title v{self._title}")

    if split is not None:
        split = to_arr(split)

        for i, s in enumerate(split):
            if s.video:
                set_output(s.video, f"split {i}")

        for i, s in enumerate(split):
            if len(s.audios) >= 1:
                for j, audio in enumerate(s.audios):
                    if audio:
                        set_output(audio, f"split {i} - {j}")

def split_at(self, splits: list[int], audio: int | list[int] | None = None) -> tuple[SplitTitle, ...]:
    # Check if chapters are still valid, user is allowed to manipulated them
    last_chpt = -1
    for a in self.chapters:
        if a < 0:
            raise CustomValueError(f"Negative chapter point {a}", self.split_at)
        if a <= last_chpt:
            raise CustomValueError(f"Chapter must be monotonly increasing {a} before {last_chpt}", self.split_at)
        if a > len(self.video):
            raise CustomValueError("Chapter must not be higher than video length", self.split_at)
        last_chpt = a
    output_cnt = SplitHelper._sanitize_splits(self, splits)
    video = SplitHelper.split_video(self, splits)
    chapters = SplitHelper.split_chapters(self, splits)

    audios: list[list[vs.AudioNode | None]]

    if audio is not None and (audio := to_arr(audio)):
        audio_per_output_cnt = len(audio)

        auds = [SplitHelper.split_audio(self, splits, a) for a in audio]

        audios = [[auds[j][i] for j in range(audio_per_output_cnt)] for i in range(output_cnt)]
    else:
        audios = [[]] * output_cnt

    fromy = 1
    from_to_s = list[tuple[int, int]]()

    for j in splits:
        from_to_s.append((fromy, j - 1))
        fromy = j

    from_to_s.append((fromy, len(self.chapters) - 1))

    return tuple(SplitTitle(v, a, c, self, f) for v, a, c, f in zip(video, audios, chapters, from_to_s))

def split_range(self, start: int, end: int, audio: list[int] | int | None = None) -> SplitTitle:
    if start < 0:
        start = len(self.chapters) + start

    if end < 0:
        end = len(self.chapters) + end

    if start == 1 and end == len(self.chapters) - 1:
        return self.split_at([], audio)[0]

    if start == 1:
        return self.split_at([end + 1], audio)[0]

    if end == len(self.chapters) - 1:
        return self.split_at([start], audio)[1]

    return self.split_at([start, end + 1], audio)[1]

def split_ranges(
    self, split: list[tuple[int, int]], audio: list[int] | int | None = None
) -> tuple[SplitTitle, ...]:
    return tuple(self.split_range(start, end, audio) for start, end in split)