Enum SubtitleFile

pub enum SubtitleFile {
    SubRipFile(SrtFile),
    SubStationAlpha(SsaFile),
    VobSubIdxFile(IdxFile),
    VobSubSubFile(VobFile),
    MicroDVDFile(MdvdFile),
}

Unified wrapper around the all individual subtitle file types.

Variants

SubRipFile(SrtFile)

.srt file

SubStationAlpha(SsaFile)

.ssa/.ass file

VobSubIdxFile(IdxFile)

.idx file

VobSubSubFile(VobFile)

.sub file (VobSub/binary)

MicroDVDFile(MdvdFile)

.sub file (MicroDVD/text)

Implementations

impl SubtitleFile

pub fn get_subtitle_entries(&self) -> Result<Vec<SubtitleEntry>>

The subtitle entries can be changed by calling update_subtitle_entries().

Examples found in repository

examples/example1.rs (line 24)

fn main() {
    // your setup goes here
    let path = PathBuf::from("path/your_example_file.ssa");
    let file_content: String = read_file(&path); // your own load routine

    // parse the file
    let format = get_subtitle_format(path.extension(), file_content.as_bytes()).expect("unknown format");
    let mut subtitle_file = parse_str(format, &file_content, 25.0).expect("parser error");
    let mut subtitle_entries: Vec<SubtitleEntry> = subtitle_file.get_subtitle_entries().expect("unexpected error");

    // shift all subtitle entries by 1 minute and append "subparse" to each subtitle line
    for subtitle_entry in &mut subtitle_entries {
        subtitle_entry.timespan += TimeDelta::from_mins(1);

        // image based subtitles like .idx (VobSub) don't have text, so
        // a text is optional
        if let Some(ref mut line_ref) = subtitle_entry.line {
            line_ref.push_str("subparse");
        }
    }

    // update the entries in the subtitle file
    subtitle_file.update_subtitle_entries(&subtitle_entries).expect("unexpected error");

    // print the corrected file to stdout
    let data: Vec<u8> = subtitle_file.to_data().expect("unexpected errror");
    let data_string = String::from_utf8(data).expect("UTF-8 conversion error");
    println!("{}", data_string);
}

pub fn update_subtitle_entries(&mut self, i: &[SubtitleEntry]) -> Result<()>

Set the entries from the subtitle entries from the get_subtitle_entries().

The length of the given input slice should always match the length of the vector length from get_subtitle_entries(). This function can not delete/create new entries, but preserves everything else in the file (formatting, authors, …).

If the input entry has entry.line == None, the line will not be overwritten.

Be aware that .idx files cannot save time_spans_ (a subtitle will be shown between two consecutive timepoints/there are no separate starts and ends) - so the timepoint will be set to the start of the corresponding input-timespan.

Examples found in repository

examples/example1.rs (line 38)

fn main() {
    // your setup goes here
    let path = PathBuf::from("path/your_example_file.ssa");
    let file_content: String = read_file(&path); // your own load routine

    // parse the file
    let format = get_subtitle_format(path.extension(), file_content.as_bytes()).expect("unknown format");
    let mut subtitle_file = parse_str(format, &file_content, 25.0).expect("parser error");
    let mut subtitle_entries: Vec<SubtitleEntry> = subtitle_file.get_subtitle_entries().expect("unexpected error");

    // shift all subtitle entries by 1 minute and append "subparse" to each subtitle line
    for subtitle_entry in &mut subtitle_entries {
        subtitle_entry.timespan += TimeDelta::from_mins(1);

        // image based subtitles like .idx (VobSub) don't have text, so
        // a text is optional
        if let Some(ref mut line_ref) = subtitle_entry.line {
            line_ref.push_str("subparse");
        }
    }

    // update the entries in the subtitle file
    subtitle_file.update_subtitle_entries(&subtitle_entries).expect("unexpected error");

    // print the corrected file to stdout
    let data: Vec<u8> = subtitle_file.to_data().expect("unexpected errror");
    let data_string = String::from_utf8(data).expect("UTF-8 conversion error");
    println!("{}", data_string);
}

pub fn to_data(&self) -> Result<Vec<u8>>

Returns a byte-stream in the respective format (.ssa, .srt, etc.) with the (probably) altered information.

Examples found in repository

examples/example1.rs (line 41)

fn main() {
    // your setup goes here
    let path = PathBuf::from("path/your_example_file.ssa");
    let file_content: String = read_file(&path); // your own load routine

    // parse the file
    let format = get_subtitle_format(path.extension(), file_content.as_bytes()).expect("unknown format");
    let mut subtitle_file = parse_str(format, &file_content, 25.0).expect("parser error");
    let mut subtitle_entries: Vec<SubtitleEntry> = subtitle_file.get_subtitle_entries().expect("unexpected error");

    // shift all subtitle entries by 1 minute and append "subparse" to each subtitle line
    for subtitle_entry in &mut subtitle_entries {
        subtitle_entry.timespan += TimeDelta::from_mins(1);

        // image based subtitles like .idx (VobSub) don't have text, so
        // a text is optional
        if let Some(ref mut line_ref) = subtitle_entry.line {
            line_ref.push_str("subparse");
        }
    }

    // update the entries in the subtitle file
    subtitle_file.update_subtitle_entries(&subtitle_entries).expect("unexpected error");

    // print the corrected file to stdout
    let data: Vec<u8> = subtitle_file.to_data().expect("unexpected errror");
    let data_string = String::from_utf8(data).expect("UTF-8 conversion error");
    println!("{}", data_string);
}

Trait Implementations

impl Clone for SubtitleFile

fn clone(&self) -> SubtitleFile

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for SubtitleFile

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

Formats the value using the given formatter.

impl From<IdxFile> for SubtitleFile

fn from(f: IdxFile) -> SubtitleFile

Converts to this type from the input type.

impl From<MdvdFile> for SubtitleFile

fn from(f: MdvdFile) -> SubtitleFile

Converts to this type from the input type.

impl From<SrtFile> for SubtitleFile

fn from(f: SrtFile) -> SubtitleFile

Converts to this type from the input type.

impl From<SsaFile> for SubtitleFile

fn from(f: SsaFile) -> SubtitleFile

Converts to this type from the input type.

impl From<VobFile> for SubtitleFile

fn from(f: VobFile) -> SubtitleFile

Converts to this type from the input type.