nl.vpro.domain.subtitles.TT888 Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of subtitles-domain Show documentation
Subtitles are related to media, but are implemented completely parallel. Classes to contain, parse, and assemble subtitle objects are here.
The newest version!
package nl.vpro.domain.subtitles;

import lombok.extern.slf4j.Slf4j;

import java.io.*;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.time.Duration;
import java.util.*;
import java.util.function.Function;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;

import org.apache.commons.lang3.StringUtils;


/**
 * @author Michiel Meeuwissen
 * @since 4.8
 */
@Slf4j
public class TT888 {

    private TT888() {
    }

    public static final Charset CHARSET = SubtitlesFormat.TT888.getCharset();

    public static StringBuilder format(Cue cue, StringBuilder builder) {
        //001 0:01:00 0:02:00 ondertitels !

        builder.append(String.format("%04d ", cue.getSequence()));
        if (cue.getStart() != null) {
            builder.append(formatDuration(cue.getStart()));
        }
        builder.append(" ");
        if (cue.getEnd() != null) {
            builder.append(formatDuration(cue.getEnd()));
        }
        builder.append("\n");
        if (cue.getContent() != null) {
            builder.append(cue.getContent());
        }
        builder.append("\n\n");
        return builder;
    }

    static String formatDuration(Duration duration) {
        long millis = duration.toMillis();
        boolean negative = millis < 0;
        if (negative) {
            millis *= -1;
        }
        long centiseconds = millis / 10;
        /*long hours = centiseconds / 360000;
        centiseconds -= hours * 360000;
        */
        long minutes = centiseconds / 6000;
        centiseconds -= minutes * 6000;
        long seconds = centiseconds / 100;
        centiseconds -= seconds * 100;
        return String.format("%s%02d:%02d:%02d", negative ? "-": "", minutes, seconds, centiseconds);
    }



    public static Stream parse(String parent, Duration offset, Function offsetGuesser, InputStream inputStream) {
        return parse(parent, offset, offsetGuesser, inputStream, CHARSET);
    }

    public static Stream parseUTF8(String parent, Duration offset, Function offsetGuesser, InputStream inputStream) {
        return parse(parent, offset, offsetGuesser, inputStream, StandardCharsets.UTF_8);
    }


    public static Stream parse(String parent, Duration offset, Function offsetGuesser, InputStream inputStream, Charset charset) {
        return parse(parent, offset, offsetGuesser, new InputStreamReader(inputStream, charset));
    }

    static Stream parse(final String parent, final Duration offsetParameter, Function offsetGuesser, Reader reader) {
        final Iterator stream = new BufferedReader(reader)
            .lines().iterator();

        Iterator cues = new Iterator() {

            boolean needsFindNext = true;
            String timeLine = null;
            final StringBuilder content = new StringBuilder();
            Duration offset = offsetParameter;

            long count = 0;

            @Override
            public boolean hasNext() {
                findNext();
                return timeLine != null;
            }

            @Override
            public Cue next() {
                findNext();
                if (timeLine == null) {
                    throw new NoSuchElementException();
                }
                needsFindNext = true;
                try {
                    String contentString = content.toString();
                    TimeLine parsedTimeLine = parseTimeline(timeLine);
                    if (offset == null) {
                        offset = offsetGuesser.apply(parsedTimeLine);
                    }
                    return createCue(parent, parsedTimeLine, offset, contentString);
                } catch (IllegalArgumentException e) {
                    log.error(e.getMessage(), e);
                    return null;
                } finally {
                    count++;
                }

            }

            protected void findNext() {
                if (needsFindNext) {
                    timeLine = null;
                    content.setLength(0);
                    while (stream.hasNext()) {
                        String l = stream.next();
                        if (StringUtils.isNotBlank(l)) {
                            timeLine = l.trim();
                            break;
                        }
                    }
                    while (stream.hasNext()) {
                        String l = stream.next();
                        if (StringUtils.isBlank(l) && content.length() > 0) {
                            break;
                        }
                        if (content.length() > 0) {
                            content.append('\n');
                        }
                        content.append(l.trim());
                    }
                    needsFindNext = false;
                }
            }
        };
        return StreamSupport.stream(Spliterators.spliteratorUnknownSize(cues, Spliterator.ORDERED), false);

    }

    static Cue createCue(String parent, TimeLine timeLine, Duration offset, String content) {
        return Cue.builder()
            .mid(parent)
            .sequence(timeLine.sequence)
            .start(timeLine.start.minus(offset))
            .end(timeLine.end.minus(offset))
            .content(content)
            .build();
    }


    private static final Pattern SEQ = Pattern.compile("([-+]?\\d+):?");
    public static TimeLine parseTimeline(String timeLine) {
        String[] split = timeLine.split("\\s+");
        try {
            Matcher matcher = SEQ.matcher(split[0]);
            Integer integer = matcher.matches() ? Integer.parseInt(matcher.group(1)) : null;
            return new TimeLine(
                integer,
                parseTime(split[1]),
                parseTime(split[2])
            );
        } catch (NumberFormatException | ArrayIndexOutOfBoundsException nfe) {
            throw new IllegalArgumentException("Could not parse " + timeLine + " (" + Arrays.asList(split) + ").  Reason: " + nfe.getClass() + " " + nfe.getMessage(), nfe);
        }


    }

    private static Duration parseTime(String duration) {
        String[] split = duration.split(":", 4);
        int index = 0;
        long hours = Long.parseLong(split[0]);
        long minutes = Long.parseLong(split[1]);
        long seconds = Long.parseLong(split[2]);
        long hunderds = Long.parseLong(split[3]);
        return Duration.ofHours(hours).plusMinutes(minutes).plusSeconds(seconds).plusMillis(hunderds * 10);
    }


    static void format(Iterator cueIterator, OutputStream out) throws IOException {
        Writer writer = new OutputStreamWriter(out, CHARSET);
        format(cueIterator, writer);
        writer.flush();
    }

    static void format(Iterator cueIterator, Writer writer) throws IOException {
        StringBuilder builder = new StringBuilder();
        while (cueIterator.hasNext()) {
            Cue cue = cueIterator.next();
            if (cue != null) {
                format(cue, builder);
                writer.write(builder.toString());
                builder.setLength(0);
            }
        }
    }

}