SubtitleFile.h

Go to the documentation of this file.

#pragma once
#include <NDEVR/TimeSpan.h>
#include <NDEVR/BufferedScanner.h>
namespace NDEVR
{
    class SubtitleFileWriter
    {
    public:
        SubtitleFileWriter(const File& file)
            : m_file(file)
            , m_current_time(TimeSpan(0.0))
            , m_text_index(1U)
        {
            m_file.create(true);
            m_file.open(File::OpenMode::e_ascii_write);
        }
        void setCurrentTime(TimeSpan span)
        {
            lib_assert(m_current_time <= span, "Unexpected out of order subtitle time");
            if(m_current_time < span)
                m_current_time = span;
        }
        void addSubtitle(const String& text)
        {
            if (m_last_text == text)
                return;
            if (m_last_text.size() > 0)
                writeText();
            m_last_subtitle_start = m_current_time;
            m_last_text = text;
        }
        void writeText()
        {
            if (m_last_text.size() > 0)
            {
                if (m_current_time > m_last_subtitle_start)
                {
                    m_file << String(m_text_index) + "\n";
                    m_file << m_last_subtitle_start.getTimeString("HH:mm:ss,fff");
                    m_file << " --> ";
                    m_file << m_current_time.getTimeString("HH:mm:ss,fff");
                    m_file << "\n";
                    m_file << m_last_text + "\n\n";
                    m_text_index++;
                    m_last_text.clear();
                }
            }
        }
        void finish(File file)
        {
            if (m_last_text.size() > 0)
                writeText();
            m_file.close();
            if (m_file != file)
            {
                m_file.moveTo(file, true);
            }
        }
    protected:
        File m_file;
        String m_last_text;
        TimeSpan m_last_subtitle_start;
        TimeSpan m_current_time;
        uint04 m_text_index = 0;
    };
 
    class SubtitleFileReader
    {
    public:
        SubtitleFileReader(const File& file)
            : m_scanner(file)
        {
            readText();
        }
        void readText()
        {
            while (m_scanner.nextLine())
            {
                m_scanner.getNext<uint04>();
                m_scanner.nextLine();
                String time_string = m_scanner.getNext<String>();
                Buffer<String> times = time_string.splitString('>');
                Vector<2, TimeSpan> spans;
                if (times.size() >= 2)
                {
                    spans[0] = convertFromString(times[0]);
                    spans[1] = convertFromString(times[1]);
                }
                m_scanner.nextLine();
                m_subtitles.add({ spans, m_scanner.getNext<String>() });
            }
        }
        String currentText(const TimeSpan& current) const
        {
            for (auto iter : m_subtitles)
            {
                if (iter.first[MAX] >= current)
                {
                    if (iter.first[MIN] <= current)
                        return iter.second;
                    else
                        return String();
                }
            }
            return String();
        }
    protected:
        TimeSpan convertFromString(const String& string)
        {
            Buffer<String> parts = string.splitString(':');
            sint08 nano_seconds = 0;
            nano_seconds += parts[0].getAs<sint08>() * cast<sint08>(Time::HOUR);
            nano_seconds += parts[1].getAs<sint08>() * cast<sint08>(Time::MINUTE);
            nano_seconds += parts[2].getAs<sint08>() * cast<sint08>(Time::SECOND);
            return TimeSpan(nano_seconds);
        }
    protected:
        Buffer<std::pair<Vector<2, TimeSpan>, String>> m_subtitles;
        BufferedScanner m_scanner;
    };
    
}