textsubtitleparser.cpp

Go to the documentation of this file.

// -*- Mode: c++ -*-
// ANSI C
#include <cstdio>
#include <cstring>
#include <climits>
 
// C++
#include <algorithm>
 
// Qt
#include <QRunnable>
#include <QFile>
#include <QDataStream>
 
// MythTV
#include "libmythbase/mthreadpool.h"
#include "libmythbase/mythcorecontext.h"
#include "libmythbase/mythlogging.h"
#include "libmythbase/remotefile.h"
#include "libmythtv/io/mythmediabuffer.h"
#include "libmyth/mythaverror.h"
 
#include "captions/textsubtitleparser.h"
#include "captions/subtitlereader.h"
 
#define IO_BUFFER_SIZE 32768
 
// This background thread helper class is adapted from the
// RebuildSaver class in mythcommflagplayer.cpp.
class SubtitleLoadHelper : public QRunnable
{
  public:
    SubtitleLoadHelper(TextSubtitleParser *parent,
                       TextSubtitles *target)
 
        : m_parent(parent), m_target(target)
    {
        QMutexLocker locker(&s_lock);
        ++s_loading[m_target];
    }
 
    void run(void) override // QRunnable
    {
        m_parent->LoadSubtitles(false);
 
        QMutexLocker locker(&s_lock);
        --s_loading[m_target];
        if (!s_loading[m_target])
            s_wait.wakeAll();
    }
 
    static bool IsLoading(TextSubtitles *target)
    {
        QMutexLocker locker(&s_lock);
        return s_loading[target] != 0U;
    }
 
    static void Wait(TextSubtitles *target)
    {
        QMutexLocker locker(&s_lock);
        if (!s_loading[target])
            return;
        while (s_wait.wait(&s_lock))
        {
            if (!s_loading[target])
                return;
        }
    }
 
  private:
    TextSubtitleParser *m_parent { nullptr };
    TextSubtitles      *m_target { nullptr };
 
    static QMutex                     s_lock;
    static QWaitCondition             s_wait;
    static QHash<TextSubtitles*,uint> s_loading;
};
QMutex                     SubtitleLoadHelper::s_lock;
QWaitCondition             SubtitleLoadHelper::s_wait;
QHash<TextSubtitles*,uint> SubtitleLoadHelper::s_loading;
 
// Work around the fact that RemoteFile doesn't work when the target
// file is actually local.
class RemoteFileWrapper
{
public:
    explicit RemoteFileWrapper(const QString &filename) {
        // This test stolen from FileRingBuffer::OpenFile()
        bool is_local =
            (!filename.startsWith("/dev")) &&
            ((filename.startsWith("/")) || QFile::exists(filename));
        m_isRemote = !is_local;
        if (m_isRemote)
        {
            m_localFile = nullptr;
            m_remoteFile = new RemoteFile(filename, false, false, 0s);
        }
        else
        {
            m_remoteFile = nullptr;
            m_localFile = new QFile(filename);
            if (!m_localFile->open(QIODevice::ReadOnly))
            {
                delete m_localFile;
                m_localFile = nullptr;
            }
        }
    }
    ~RemoteFileWrapper() {
        delete m_remoteFile;
        delete m_localFile;
    }
 
    RemoteFileWrapper(const RemoteFileWrapper &) = delete;            // not copyable
    RemoteFileWrapper &operator=(const RemoteFileWrapper &) = delete; // not copyable
 
    bool isOpen(void) const {
        if (m_isRemote)
            return m_remoteFile->isOpen();
        return m_localFile;
    }
    long long GetFileSize(void) const {
        if (m_isRemote)
            return m_remoteFile->GetFileSize();
        if (m_localFile)
            return m_localFile->size();
        return 0;
    }
    int Read(void *data, int size) {
        if (m_isRemote)
            return m_remoteFile->Read(data, size);
        if (m_localFile)
        {
            QDataStream stream(m_localFile);
            return stream.readRawData(static_cast<char*>(data), size);
        }
        return 0;
    }
private:
    bool m_isRemote;
    RemoteFile *m_remoteFile;
    QFile *m_localFile;
};
 
TextSubtitles::~TextSubtitles()
{
    SubtitleLoadHelper::Wait(this);
}
 
void TextSubtitles::SetLastLoaded(void)
{
    emit TextSubtitlesUpdated();
    QMutexLocker locker(&m_lock);
    m_lastLoaded = QDateTime::currentDateTimeUtc();
}
 
struct local_buffer_t {
  char              *rbuffer_text;
  off_t              rbuffer_len;
  off_t              rbuffer_cur;
};
 
TextSubtitleParser::~TextSubtitleParser()
{
    avcodec_free_context(&m_decCtx);
    delete m_loadHelper;
}
 
int TextSubtitleParser::read_packet(void *opaque, uint8_t *buf, int buf_size)
{
    auto *bd = (struct local_buffer_t *)opaque;
 
    /* copy internal buffer data to buf */
    off_t remaining = bd->rbuffer_len - bd->rbuffer_cur;
    if (remaining <= 0)
        return AVERROR_EOF;
    buf_size = FFMIN(buf_size, remaining);
    memcpy(buf, bd->rbuffer_text + bd->rbuffer_cur, buf_size);
    bd->rbuffer_cur += buf_size;
 
    return buf_size;
}
 
int64_t TextSubtitleParser::seek_packet(void *opaque, int64_t offset, int whence)
{
    auto *bd = (struct local_buffer_t *)opaque;
 
    switch (whence)
    {
      case SEEK_CUR:
        offset = bd->rbuffer_cur + offset;
        break;
 
      case SEEK_END:
        offset = bd->rbuffer_len - offset;
        break;
 
      case SEEK_SET:
        break;
 
      default:
        return -1;
    }
 
    if ((offset < 0) || (offset > bd->rbuffer_len))
        return -1;
    bd->rbuffer_cur = offset;
    return 0;
}
 
int TextSubtitleParser::decode(AVPacket *pkt)
{
    AVSubtitle sub {};
    int got_sub_ptr {0};
 
    int ret = avcodec_decode_subtitle2(m_decCtx, &sub, &got_sub_ptr, pkt);
    if (ret < 0)
        return ret;
    if (!got_sub_ptr)
        return -1;
 
    sub.start_display_time = av_q2d(m_stream->time_base) * pkt->dts * 1000;
    sub.end_display_time = av_q2d(m_stream->time_base) * (pkt->dts + pkt->duration) * 1000;
 
    m_parent->AddAVSubtitle(sub, m_decCtx->codec_id == AV_CODEC_ID_XSUB, false);
    m_count += 1;
    return ret;
}
 
void TextSubtitleParser::LoadSubtitles(bool inBackground)
{
    std::string errbuf;
 
    if (inBackground)
    {
        if (!SubtitleLoadHelper::IsLoading(m_target))
        {
            m_loadHelper = new SubtitleLoadHelper(this, m_target);
            MThreadPool::globalInstance()->
                start(m_loadHelper, "SubtitleLoadHelper");
        }
        return;
    }
 
    // External subtitles are now presented as AV Subtitles.
    m_parent->EnableAVSubtitles(true);
    m_parent->EnableTextSubtitles(false);
    m_parent->EnableRawTextSubtitles(false);
 
    local_buffer_t sub_data {};
    RemoteFileWrapper rfile(m_fileName/*, false, false, 0*/);
 
    LOG(VB_VBI, LOG_INFO,
        QString("Preparing to load subtitle file %1").arg(m_fileName));
    if (!rfile.isOpen())
    {
        LOG(VB_VBI, LOG_INFO,
            QString("Failed to load subtitle file %1").arg(m_fileName));
        return;
    }
    m_target->SetHasSubtitles(true);
    m_target->SetFilename(m_fileName);
 
    // Only reload if rfile.GetFileSize() has changed.
    // RemoteFile::GetFileSize can return -1 on error.
    off_t new_len = rfile.GetFileSize();
    if (new_len < 0)
    {
        LOG(VB_VBI, LOG_INFO,
            QString("Failed to get file size for %1").arg(m_fileName));
        return;
    }
 
    if (m_target->GetByteCount() == new_len)
    {
        LOG(VB_VBI, LOG_INFO,
            QString("Filesize unchanged (%1), not reloading subs (%2)")
            .arg(new_len).arg(m_fileName));
        m_target->SetLastLoaded();
        return;
    }
    LOG(VB_VBI, LOG_INFO,
        QString("Preparing to read %1 subtitle bytes from %2")
        .arg(new_len).arg(m_fileName));
    m_target->SetByteCount(new_len);
    sub_data.rbuffer_len = new_len;
    sub_data.rbuffer_text = new char[sub_data.rbuffer_len + 1];
    sub_data.rbuffer_cur = 0;
 
    // Slurp the entire file into a buffer.
    int numread = rfile.Read(sub_data.rbuffer_text, sub_data.rbuffer_len);
    LOG(VB_VBI, LOG_INFO,
        QString("Finished reading %1 subtitle bytes (requested %2)")
        .arg(numread).arg(new_len));
 
    // Create a format context and tie it to the file buffer.
    AVFormatContext *fmt_ctx = avformat_alloc_context();
    if (fmt_ctx == nullptr) {
        LOG(VB_VBI, LOG_INFO, "Couldn't allocate format context");
        return;
    }
    auto *avio_ctx_buffer = (uint8_t*)av_malloc(IO_BUFFER_SIZE);
    if (avio_ctx_buffer == nullptr)
    {
        LOG(VB_VBI, LOG_INFO, "Couldn't allocate mamory for avio context");
        avformat_free_context(fmt_ctx);
        return;
    }
    fmt_ctx->pb = avio_alloc_context(avio_ctx_buffer, IO_BUFFER_SIZE,
                                     0, &sub_data,
                                     &read_packet, nullptr, &seek_packet);
    if(int ret = avformat_open_input(&fmt_ctx, nullptr, nullptr, nullptr); ret < 0) {
        LOG(VB_VBI, LOG_INFO, QString("Couldn't open input context %1")
            .arg(av_make_error_stdstring(errbuf,ret)));
        // FFmpeg frees context on error.
        return;
    }
 
    // Find the subtitle stream and its context.
    if (!m_decCtx)
    {
        const AVCodec *codec {nullptr};
        int stream_num = av_find_best_stream(fmt_ctx, AVMEDIA_TYPE_SUBTITLE, -1, -1, &codec, 0);
        if (stream_num < 0) {
            LOG(VB_VBI, LOG_INFO, QString("Couldn't find subtitle stream. %1")
                .arg(av_make_error_stdstring(errbuf,stream_num)));
            avformat_free_context(fmt_ctx);
            return;
        }
        m_stream = fmt_ctx->streams[stream_num];
        if (m_stream == nullptr) {
            LOG(VB_VBI, LOG_INFO, QString("Stream %1 is null").arg(stream_num));
            avformat_free_context(fmt_ctx);
            return;
        }
 
        // Create a decoder for this subtitle stream context.
        m_decCtx = avcodec_alloc_context3(codec);
        if (!m_decCtx) {
            LOG(VB_VBI, LOG_INFO, QString("Couldn't allocate decoder context"));
            avformat_free_context(fmt_ctx);
            return;
        }
        if (avcodec_open2(m_decCtx, codec, nullptr) < 0) {
            LOG(VB_VBI, LOG_INFO, QString("Couldn't open decoder context"));
            avcodec_free_context(&m_decCtx);
            avformat_free_context(fmt_ctx);
            return;
        }
    }
 
    /* decode until eof */
    AVPacket *pkt = av_packet_alloc();
    av_new_packet(pkt, 4096);
    while (av_read_frame(fmt_ctx, pkt) >= 0)
    {
        int bytes {0};
        while ((bytes = decode(pkt)) >= 0)
        {
            pkt->data += bytes;
            pkt->size -= bytes;
        }
 
        // reset buffer for next packet
        pkt->data = pkt->buf->data;
        pkt->size = pkt->buf->size;
    }
 
    /* flush the decoder */
    pkt->data = nullptr;
    pkt->size = 0;
    while (decode(pkt) >= 0)
    {
    }
 
    LOG(VB_GENERAL, LOG_INFO, QString("Loaded %1 %2 subtitles from '%3'")
        .arg(m_count)
        .arg(m_decCtx->codec->long_name, m_fileName));
    m_target->SetLastLoaded();
 
    av_packet_free(&pkt);
    m_stream = nullptr;
    avformat_free_context(fmt_ctx);
}
 
QByteArray TextSubtitleParser::GetSubHeader()
{
    if (nullptr == m_decCtx)
        return {};
    return { reinterpret_cast<char*>(m_decCtx->subtitle_header),
             m_decCtx->subtitle_header_size };
}