Enum TimedSubtitleFile

pub enum TimedSubtitleFile {
    Ass(AssSubtitle),
    MicroDvd(TimedMicroDvdSubtitle),
    Ssa(SsaSubtitle),
    SubRip(SubRipSubtitle),
    WebVtt(WebVttSubtitle),
}

Convenience interface for interacting with time-based subtitle files in a generic manner.

For example, managing a collection of multiple subtitles of unknown or different formats.

For accessing or modifying format-specific data/methods, such as embedded fonts in SubStation Alpha files, you should convert to the format-specific types using from() or into()

Variants

Ass(AssSubtitle)

File in Advanced SubStation Alpha V4+ (.ass) format

MicroDvd(TimedMicroDvdSubtitle)

Timed version of file in MicroDVD (.sub) format

Ssa(SsaSubtitle)

File in Substation Alpha V4 (.ssa) format

SubRip(SubRipSubtitle)

File in SubRip (.srt) format

WebVtt(WebVttSubtitle)

File in WebVTT (.vtt) format

Implementations

impl TimedSubtitleFile

pub fn new(path: impl AsRef<Path>) -> Result<Self, Error>

Automatically attempts to detect format using the file extension and file contents.

Using the detected format, try to parse the given path and load its data

Errors

• If an error is encountered while opening the file, returns Error::FileIoError
• If the format cannot be successfully detected, returns Error::FormatUnknownError

Examples found in repository

examples/conversion.rs (line 4)

fn main() -> Result<(), Error> {
    let sub = TimedSubtitleFile::new("/path/to/file.srt")?;

    // Get the file as its specific format
    let srt = SubRipSubtitle::from(sub);

    // You can use into() to convert the file
    let vtt: WebVttSubtitle = srt.into();

    // or from()
    let ass = AssSubtitle::from(vtt);

    ass.export("/path/to/converted.ass")?;

    Ok(())
}

examples/modification.rs (line 4)

fn main() -> Result<(), Error> {
    let sub = TimedSubtitleFile::new("/path/to/subtitle.ass")?;
    let mut ass = AssSubtitle::from(sub);

    println!("{}", ass.script_info());

    for event in ass.events_mut() {
        event.style = Some("Karaoke".to_string());

        if event.duration() > TimeDelta::from(500) {
            event.shift(2000.into());
        }
    }

    ass.export("/path/to/output.ass")
}

examples/basic.rs (line 11)

fn main() -> Result<(), Error> {
    // We can directly specify the format to open a subtitle file
    let vtt = WebVttSubtitle::from_path("/path/to/some.vtt")?;

    // and then directly work with its data
    println!("{}", vtt.header().cloned().unwrap_or_default());

    // or we could use the more general interface to open (timed) subtitle files
    let sub = TimedSubtitleFile::new("/path/to/file.srt")?;

    // Move the underlying data out in order to access format-specific properties
    // Note that if the format doesn't match, this will perform a conversion instead of just moving the data
    let mut srt = SubRipSubtitle::from(sub);

    // Now we can access format-specific methods like SubRipSubtitle::renumber()
    srt.renumber();

    // Access and modify events
    for event in srt.events_mut() {
        event.shift(600.into());
    }

    // Write the modified subtitle to file
    srt.export("/path/to/output.srt")?;

    Ok(())
}

pub fn with_format( path: impl AsRef<Path>, format: Format, ) -> Result<Self, Error>

Try to load and parse file as the given format

Errors

If an error is encountered while opening the file, returns Error::FileIoError

pub fn export(&self, path: impl AsRef<Path>) -> Result<(), Error>

Exports contents to file in the corresponding format

Errors

If an error is encountered while creating the file, returns Error::FileIoError

Trait Implementations

impl Debug for TimedSubtitleFile

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<TimedSubtitleFile> for AssSubtitle

fn from(value: TimedSubtitleFile) -> Self

Converts to this type from the input type.

impl From<TimedSubtitleFile> for PlainSubtitle

fn from(value: TimedSubtitleFile) -> Self

Converts to this type from the input type.

impl From<TimedSubtitleFile> for SsaSubtitle

fn from(value: TimedSubtitleFile) -> Self

Converts to this type from the input type.

impl From<TimedSubtitleFile> for SubRipSubtitle

fn from(value: TimedSubtitleFile) -> Self

Converts to this type from the input type.

impl From<TimedSubtitleFile> for WebVttSubtitle

fn from(value: TimedSubtitleFile) -> Self

Converts to this type from the input type.