144 lines
5.3 KiB
Python
144 lines
5.3 KiB
Python
import copy
|
|
from pathlib import Path
|
|
from typing import Optional, List
|
|
|
|
from ytdl_sub.entries.entry import Entry
|
|
from ytdl_sub.plugins.plugin import Plugin
|
|
from ytdl_sub.plugins.plugin import PluginOptions
|
|
from ytdl_sub.utils.chapters import Chapters, Timestamp
|
|
from ytdl_sub.utils.ffmpeg import FFMPEG
|
|
from ytdl_sub.utils.file_handler import FileHandler
|
|
from ytdl_sub.utils.thumbnail import convert_download_thumbnail
|
|
from ytdl_sub.validators.string_select_validator import StringSelectValidator
|
|
|
|
def _split_video_ffmpeg_cmd(
|
|
input_file: str, output_file: str, timestamps: List[Timestamp], idx: int
|
|
) -> List[str]:
|
|
timestamp_begin = timestamps[idx].standardized_str
|
|
timestamp_end = timestamps[idx + 1].standardized_str if idx + 1 < len(timestamps) else ""
|
|
|
|
cmd = ["-i", input_file, "-ss", timestamp_begin]
|
|
if timestamp_end:
|
|
cmd += ["-to", timestamp_end]
|
|
cmd += ["-vcodec", "copy", "-acodec", "copy", output_file]
|
|
return cmd
|
|
|
|
|
|
def _split_video_uid(source_uid: str, idx: int) -> str:
|
|
return f"{source_uid}___{idx}"
|
|
|
|
|
|
class WhenNoChaptersValidator(StringSelectValidator):
|
|
_expected_value_type = "when no chapters option"
|
|
_select_values = {"pass", "drop", "error"}
|
|
|
|
|
|
class SplitByChaptersOptions(PluginOptions):
|
|
"""
|
|
Splits a file by chapters into multiple files. Each file becomes its own entry with ``title``
|
|
set to its chapter name, and is processed separately by other plugins.
|
|
|
|
Usage:
|
|
|
|
.. code-block:: yaml
|
|
|
|
presets:
|
|
my_example_preset:
|
|
split_by_chapters:
|
|
when_no_chapters: "pass" # "drop"/"error"
|
|
"""
|
|
|
|
_required_keys = {"when_no_chapters"}
|
|
|
|
def __init__(self, name, value):
|
|
super().__init__(name, value)
|
|
self._when_no_chapters = self._validate_key(
|
|
key="when_no_chapters", validator=WhenNoChaptersValidator
|
|
).value
|
|
|
|
@property
|
|
def when_no_chapters(self) -> str:
|
|
"""
|
|
Behavior to perform when no chapters are present. Supports "pass" (continue processing),
|
|
"drop" (exclude it from output), and "error" (stop processing for everything).
|
|
"""
|
|
return self._when_no_chapters
|
|
|
|
|
|
class SplitByChaptersPlugin(Plugin[SplitByChaptersOptions]):
|
|
plugin_options_type = SplitByChaptersOptions
|
|
|
|
def _create_split_entry(
|
|
self, source_entry: Entry, title: str, idx: int, chapters: Chapters
|
|
) -> Entry:
|
|
"""
|
|
Runs ffmpeg to create the split video
|
|
"""
|
|
entry_dict = copy.deepcopy(source_entry)
|
|
entry_dict["title"] = title
|
|
entry_dict["playlist_index"] = idx + 1
|
|
entry_dict["playlist_count"] = len(chapters.timestamps)
|
|
entry_dict["id"] = _split_video_uid(source_uid=entry_dict["id"], idx=idx)
|
|
|
|
# Remove track and artist since its now split
|
|
if "track" in entry_dict:
|
|
del entry_dict["track"]
|
|
if "artist" in entry_dict:
|
|
del entry_dict["artist"]
|
|
|
|
timestamp_begin = chapters.timestamps[idx].readable_str
|
|
timestamp_end = Timestamp(source_entry_dict["duration"]).readable_str
|
|
if idx + 1 < len(chapters.timestamps):
|
|
timestamp_end = chapters.timestamps[idx + 1].readable_str
|
|
|
|
metadata = FileMetadata(metadata=f"{timestamp_begin} - {timestamp_end}")
|
|
return (
|
|
YoutubePlaylistVideo(entry_dict=entry_dict, working_directory=self.working_directory),
|
|
metadata,
|
|
)
|
|
|
|
def modify_entry(self, entry: Entry) -> Optional[Entry]:
|
|
"""
|
|
Tags the entry's audio file using values defined in the metadata options
|
|
"""
|
|
split_entries: List[Entry] = []
|
|
chapters = Chapters.from_embedded_chapters(file_path=entry.get_download_file_path())
|
|
|
|
# convert the entry thumbnail early so we do not have to guess the thumbnail extension
|
|
# when copying it
|
|
if not self.is_dry_run:
|
|
convert_download_thumbnail(entry=entry)
|
|
|
|
for idx, title in enumerate(chapters.titles):
|
|
new_uid = _split_video_uid(source_uid=entry.uid, idx=idx)
|
|
|
|
if not self.is_dry_run:
|
|
# Get the input/output file paths
|
|
input_file = entry.get_download_file_path()
|
|
output_file = str(Path(self.working_directory) / f"{new_uid}.{entry.ext}")
|
|
|
|
# Run ffmpeg to create the split the video
|
|
FFMPEG.run(
|
|
_split_video_ffmpeg_cmd(
|
|
input_file=input_file,
|
|
output_file=output_file,
|
|
timestamps=chapters.timestamps,
|
|
idx=idx,
|
|
)
|
|
)
|
|
|
|
# Copy the original vid thumbnail to the working directory with the new uid. This so
|
|
# downstream logic thinks this split video has its own thumbnail
|
|
FileHandler.copy(
|
|
src_file_path=entry.get_download_thumbnail_path(),
|
|
dst_file_path=Path(self.working_directory) / f"{new_uid}.{entry.thumbnail_ext}",
|
|
)
|
|
|
|
# Format the split video as a YoutubePlaylistVideo
|
|
split_videos_and_metadata.append(
|
|
self._create_split_video_entry(
|
|
source_entry_dict=entry_dict, title=title, idx=idx, chapters=chapters
|
|
)
|
|
)
|
|
|
|
return split_videos_and_metadata
|