Skip to content
Extraits de code Groupes Projets
Sélectionner une révision Git
  • 4cae57ab2f510fafabc66204b5dd0ad962858dd5
  • master par défaut
  • script
  • new-devel
  • devel
  • timingView-edit
  • fix-mpv
7 résultats

VivyDocument.cc

Blame
  • VivyDocument.cc 7,11 Kio
    #include "VivyDocument.hh"
    #include "../Utils.hh"
    
    #include <QFileInfo>
    #include <QString>
    #include <QStringList>
    #include <QJsonArray>
    #include <QJsonObject>
    
    using namespace Vivy;
    
    VivyDocument::VivyDocument(const QString &documentPath, Options opt)
        : AbstractDocument(AbstractDocument::Type::Vivy, documentPath)
        , documentOptions(opt)
    {
        QFileInfo file(name);
        documentName     = file.baseName();
        documentLocation = file.absoluteDir();
    
        loadSubDocument(name);
        qDebug() << "CONSTRUCTOR: VivyDocument(" << name << "," << opt << ","
                 << getDocumentCapabilitiesString() << ")";
    }
    
    bool
    VivyDocument::loadSubDocument(const QString &subName) noexcept
    {
        QFileInfo file(subName);
        Capabilities ableType;
    
        if (detectDocumentType(file, &ableType)) {
            switch (ableType) {
            case Capabilities::AudioAble:
                qDebug() << "Auto-detect audio document for" << subName;
                setAudioSubDocument(file.absoluteFilePath());
                return true;
    
            case Capabilities::VideoAble:
                qDebug() << "Auto-detect video (and try audio) document for" << subName;
                setVideoSubDocument(file.absoluteFilePath());
                setAudioSubDocument(file.absoluteFilePath());
                return true;
    
            case Capabilities::AssAble:
                qDebug() << "Auto-detect ASS document for" << subName;
                setAssSubDocument(file.absoluteFilePath());
                return true;
            }
        }
    
        return false;
    }
    
    bool
    VivyDocument::loadSubDocument(const QString &subName, VivyDocument::Capabilities asType) noexcept
    {
        QFileInfo file(subName);
        Capabilities ableType;
        if (!detectDocumentType(file, &ableType)) {
            qCritical() << "Failed to detect type for file " << subName;
            return false;
        }
    
        if (ableType == Capabilities::AssAble && asType == Capabilities::AssAble) {
            qDebug() << "Create an ass subDocument from " << subName;
            setAssSubDocument(file.absoluteFilePath());
        }
    
        else if (ableType == Capabilities::VideoAble && asType == Capabilities::VideoAble) {
            qDebug() << "Create a video subDocument from " << subName;
            setVideoSubDocument(file.absoluteFilePath());
        }
    
        else if (const bool requestAudio = (asType == Capabilities::AudioAble);
                 (ableType == Capabilities::VideoAble && requestAudio) ||
                 (ableType == Capabilities::AudioAble && requestAudio)) {
            qDebug() << "Create an audio subDocument from " << subName;
            setAudioSubDocument(file.absoluteFilePath());
        }
    
        return true;
    }
    
    bool
    VivyDocument::detectDocumentType(const QFileInfo &file, Capabilities *ableType) noexcept
    {
        Vivy::Utils::DocumentType docType;
        bool rc = Vivy::Utils::detectDocumentType(file, &docType);
    
        if (docType == Utils::DocumentType::Video)
            *ableType = Capabilities::VideoAble;
    
        else if (docType == Utils::DocumentType::Audio)
            *ableType = Capabilities::AudioAble;
    
        else if (docType == Utils::DocumentType::ASS)
            *ableType = Capabilities::AssAble;
    
        // Invalid document type
        else
            return false;
    
        return rc;
    }
    
    bool
    VivyDocument::rename(const QString &newName) noexcept
    {
        /* Compute new paths */
        const QString newNameWithExtension =
            newName.right(filePrefix.size()) == filePrefix ? newName : newName + "." + filePrefix;
        const QFileInfo newPath(documentLocation, newNameWithExtension);
    
        return renameWith(newPath, [=, this]() noexcept -> void {
            documentLocation = newPath.dir();
            documentName     = newPath.baseName();
        });
    }
    
    std::shared_ptr<AudioSubDocument>
    VivyDocument::getAudioSubDocument() const noexcept
    {
        return audioDocument;
    }
    
    std::shared_ptr<VideoSubDocument>
    VivyDocument::getVideoSubDocument() const noexcept
    {
        return videoDocument;
    }
    
    std::shared_ptr<AssSubDocument>
    VivyDocument::getAssSubDocument() const noexcept
    {
        return assDocument;
    }
    
    bool
    VivyDocument::checkDocumentCapabilities(Capabilities asType) const noexcept
    {
        return static_cast<bool>(documentType & asType);
    }
    
    bool
    VivyDocument::checkDocumentOption(Options opt) const noexcept
    {
        return static_cast<bool>(documentOptions & opt);
    }
    
    QString
    VivyDocument::getDocumentCapabilitiesString() const noexcept
    {
        QStringList ret;
        if (documentType & AudioAble)
            ret.push_back("AudioAble" +
                          QString(audioDocument ? QStringLiteral("") : QStringLiteral("(ack)")));
        if (documentType & VideoAble)
            ret.push_back("VideoAble" +
                          QString(videoDocument ? QStringLiteral("") : QStringLiteral("(ack)")));
        if (documentType & AssAble)
            ret.push_back("AssAble" +
                          QString(assDocument ? QStringLiteral("") : QStringLiteral("(ack)")));
        return ret.join(", ");
    }
    
    void
    VivyDocument::setAudioSubDocument(const QString filename) noexcept
    {
        qDebug() << "[Audio sub-doc] Trying to open file" << filename;
        QFileInfo fileInfo(filename);
        const QString baseName = fileInfo.baseName();
    
        if (auto doc = audioDocument.get()) {
            // Here we may want to do some confirmation / cleanup
            audioDocument.reset();
        }
    
        audioDocument = AudioSubDocument::fromFile(filename);
        if (audioDocument)
            addDocumentType(AudioAble);
    }
    
    void
    VivyDocument::setVideoSubDocument(const QString filename) noexcept
    {
        qDebug() << "[Video sub-doc] Trying to open file" << filename;
        QFileInfo fileInfo(filename);
        const QString baseName = fileInfo.baseName();
    
        if (auto doc = videoDocument.get()) {
            // Here we may want to do some confirmation / cleanup
            videoDocument.reset();
        }
    
        videoDocument = VideoSubDocument::fromFile(filename);
        if (videoDocument)
            addDocumentType(VideoAble);
    }
    
    void
    VivyDocument::setAssSubDocument(const QString filename) noexcept
    {
        qDebug() << "[ASS sub-doc] Trying to open file" << filename;
        QFileInfo fileInfo(filename);
        const QString baseName = fileInfo.baseName();
    
        if (auto doc = assDocument.get()) {
            // Here we may want to do some confirmation / cleanup
            assDocument.reset();
        }
    
        assDocument = AssSubDocument::fromFile(filename);
        if (assDocument)
            addDocumentType(AssAble);
    }
    
    void
    VivyDocument::addDocumentType(Capabilities newCap) noexcept
    {
        documentType |= newCap;
        documentOptions &= ~Options::UntouchedByDefault;
        emit documentChanged();
    }
    
    QString
    VivyDocument::getElementName() const noexcept
    {
        return getName();
    }
    
    QJsonDocument
    VivyDocument::getProperties() const noexcept
    {
        QJsonDocument ret;
        QJsonObject object;
        QJsonObject subDocObject;
    
        subDocObject.insert("Audio sub-document",
                            audioDocument ? audioDocument->getProperties().object() : QJsonValue());
        subDocObject.insert("Video sub-document",
                            videoDocument ? videoDocument->getProperties().object() : QJsonValue());
        subDocObject.insert("ASS sub-document",
                            assDocument ? assDocument->getProperties().object() : QJsonValue());
    
        object.insert("Uuid", getUuid().toString());
        object.insert("Name", getName());
        object.insert("Sub documents", subDocObject);
    
        ret.setObject(object);
        return ret;
    }