KisAnimationVideoSaver Class Reference

#include <KisVideoSaver.h>

Inheritance diagram for KisAnimationVideoSaver:

Public Member Functions
KisImportExportErrorCode	encode (const QString &framesDirectory, const QString &savedFilesMask, const QStringList &savedFiles, const KisAnimationRenderingOptions &options)
KisImageSP	image ()
	image
	KisAnimationVideoSaver (KisDocument *doc, bool batchMode)
	KisAnimationVideoSaver This is the object that takes an animation document and config and tells ffmpeg to render it via KisFFMpegWrapper or uses KisMediaEncoderWrapper on Android.
	~KisAnimationVideoSaver () override

Static Public Member Functions
static KisImportExportErrorCode	convert (KisDocument *document, const QString &framesDirectory, const QString &savedFilesMask, const QStringList &savedFiles, const KisAnimationRenderingOptions &options, bool batchMode)

Private Attributes
bool	m_batchMode
KisDocument *	m_doc
KisImageSP	m_image

Detailed Description

Definition at line 21 of file KisVideoSaver.h.

Constructor & Destructor Documentation

KisAnimationVideoSaver()

KisAnimationVideoSaver::KisAnimationVideoSaver	(	KisDocument *	doc,
		bool	batchMode )

KisAnimationVideoSaver This is the object that takes an animation document and config and tells ffmpeg to render it via KisFFMpegWrapper or uses KisMediaEncoderWrapper on Android.

Parameters

doc	the document to use for rendering.
batchMode	whether Krita is in batchmode and we can thus not show gui widgets.

Definition at line 41 of file KisVideoSaver.cpp.

    : m_image(doc->image())
    , m_doc(doc)
    , m_batchMode(batchMode)
{
}

~KisAnimationVideoSaver()

KisAnimationVideoSaver::~KisAnimationVideoSaver ( )

override

Definition at line 48 of file KisVideoSaver.cpp.

{
}

Member Function Documentation

convert()

KisImportExportErrorCode KisAnimationVideoSaver::convert ( KisDocument * document, const QString & framesDirectory, const QString & savedFilesMask, const QStringList & savedFiles, const KisAnimationRenderingOptions & options, bool batchMode )

static

Definition at line 287 of file KisVideoSaver.cpp.

{
    KisAnimationVideoSaver videoSaver(document, batchMode);
    KisImportExportErrorCode res = videoSaver.encode(framesDirectory, savedFilesMask, savedFiles, options);
    return res;
}

References encode().

encode()

KisImportExportErrorCode KisAnimationVideoSaver::encode	(	const QString &	framesDirectory,
		const QString &	savedFilesMask,
		const QStringList &	savedFiles,
		const KisAnimationRenderingOptions &	options )

Definition at line 57 of file KisVideoSaver.cpp.

{
#ifdef Q_OS_ANDROID
    Q_UNUSED(savedFilesMask);
 
    KisMediaEncoderFormat *format = KisMediaEncoderWrapper::getFormatByKey(options.videoFormatKey);
    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(format, ImportExportCodes::InternalError);
 
    QVariantMap formatPreferences;
    if (!options.videoFormatPreferencesJson.isEmpty()) {
        formatPreferences = QJsonDocument::fromJson(options.videoFormatPreferencesJson.toUtf8()).toVariant().toMap();
    }
 
    KisMediaEncoderWrapperSettings settings = {
        options.videoFileName,
        QStringList(),
        QString(),
        format,
        formatPreferences,
        options.scaleFilter,
        QSize(options.width, options.height),
        options.frameRate,
        options.frameRate,
        0,
        0,
        0,
    };
 
    QString inputDir = framesDirectory;
    if (!inputDir.endsWith(QStringLiteral("/"))) {
        inputDir.append(QStringLiteral("/"));
    }
 
    settings.inputFiles.reserve(savedFiles.size());
    for (const QString &savedFile : savedFiles) {
        settings.inputFiles.append(inputDir + savedFile);
    }
 
    // MLT can't read from Android content URIs, so we have to copy the file
    // into temporary storage and get a real path for it.
    QTemporaryFile audioFile;
    if (format->supportsAudio() && options.includeAudio) {
        QVector<QFileInfo> audioFiles = m_doc->getAudioTracks();
        if (!audioFiles.isEmpty()) {
            QString audioPath = audioFiles.first().filePath();
            QString errorMessage;
            if (KisAndroidUtils::copyFileToTemporary(audioPath, audioFile, &errorMessage)) {
                settings.audioFile = audioFile.fileName();
                settings.audioSeekFrame = options.firstFrame;
            } else {
                return KisImportExportErrorCode(i18n("Error preparing audio file: %1", errorMessage));
            }
        }
    }
 
    // This whole batchMode business is either a vestige or was never actually
    // implemented to completion. It's *supposed* to not show dialogs if Krita
    // is run in batch mode via the command line, but it's not actually wired up
    // properly. KisAnimationRender always sets it to false with a TODO to fetch
    // it correctly and the ffmpeg code here never sets it either, meaning it'll
    // always be false. For consistency, I've made KisMediaEncoderWrapper behave
    // the same, even if it's kind of pointless. But if you're working on this
    // in the future, you should be able to do the same thing for this code path
    // as you're doing for the ffmpeg one.
    bool batchMode = false;
    return KisMediaEncoderWrapper().start(settings, batchMode);
#else
    Q_UNUSED(framesDirectory);
    Q_UNUSED(savedFiles);
 
    if (!QFileInfo(options.ffmpegPath).exists()) {
        m_doc->setErrorMessage(i18n("ffmpeg could not be found at %1", options.ffmpegPath));
        return ImportExportCodes::Failure;
    }
 
    KisImportExportErrorCode resultOuter = ImportExportCodes::OK;
 
    KisImageAnimationInterface *animation = m_image->animationInterface();
 
    const int sequenceStart = options.sequenceStart;
    const KisTimeSpan clipRange = KisTimeSpan::fromTimeToTime(options.firstFrame,
                                                              options.lastFrame);
 
     // export dimensions could be off a little bit, so the last force option tweaks the pixels for the export to work
    const QString exportDimensions =
        QString("scale=w=")
            .append(QString::number(options.width))
            .append(":h=")
            .append(QString::number(options.height))
            .append(":flags=")
            .append(options.scaleFilter);
            //.append(":force_original_aspect_ratio=decrease"); HOTFIX for even:odd dimension images.
 
    const QString resultFile = options.resolveAbsoluteVideoFilePath();
    const QFileInfo resultFileInfo(resultFile);  
    const QDir videoDir(resultFileInfo.absolutePath());
 
    const QString suffix = resultFileInfo.suffix().toLower();
    const QString palettePath = videoDir.filePath("KritaTempPalettegen_\%06d.png");
 
    QStringList additionalOptionsList = options.customFFMpegOptions.split(' ', Qt::SkipEmptyParts);
 
    QScopedPointer<KisFFMpegWrapper> ffmpegWrapper(new KisFFMpegWrapper(this));
    
    {
        QStringList paletteArgs;
        QStringList simpleFilterArgs;
        QStringList complexFilterArgs;
        QStringList args;
        
        args << "-y" // Auto Confirm...
             << "-r" << QString::number(options.frameRate) // Frame rate for video...
             << "-start_number" << QString::number(sequenceStart) << "-start_number_range" << "1"
             << "-i" << savedFilesMask; // Input frame(s) file mask..
 
        const int lavfiOptionsIndex = additionalOptionsList.indexOf("-lavfi");
 
        if ( lavfiOptionsIndex != -1 ) {
            complexFilterArgs << additionalOptionsList.takeAt(lavfiOptionsIndex + 1);
 
            additionalOptionsList.removeAt( lavfiOptionsIndex );
        }                  
      
        if ( options.videoMimeType == "image/gif" ) {
            paletteArgs << "-r" << QString::number(options.frameRate)
                        << "-start_number" << QString::number(sequenceStart) << "-start_number_range" << "1"
                        << "-i" << savedFilesMask;
            
            const int paletteOptionsIndex = additionalOptionsList.indexOf("-palettegen");
            QString palettegenString = "palettegen";
            
            if ( paletteOptionsIndex != -1 ) {
                palettegenString = additionalOptionsList.takeAt(paletteOptionsIndex + 1);
 
                additionalOptionsList.removeAt( paletteOptionsIndex );
            }
                        
            if (m_image->width() != options.width || m_image->height() != options.height) {
                paletteArgs << "-vf" << (exportDimensions + "," + palettegenString );
            } else {
                paletteArgs << "-vf" << palettegenString;
            }
                 
            paletteArgs << "-y" << palettePath;
 
            QStringList ffmpegArgs;
            ffmpegArgs << "-v" << "debug"
                         << paletteArgs;
 
            KisFFMpegWrapperSettings ffmpegSettings;
            ffmpegSettings.args = ffmpegArgs;
            ffmpegSettings.processPath = options.ffmpegPath;
 
            ffmpegSettings.progressIndeterminate = true;
            ffmpegSettings.progressMessage = i18nc("Animation export dialog for palette exporting. arg1: file-suffix",
                                               "Creating palette for %1 file format.", "[suffix]");
            ffmpegSettings.logPath = QDir::tempPath() + QDir::separator() + "krita" + QDir::separator() + "ffmpeg.log";
            
            KisImportExportErrorCode result = ffmpegWrapper->start(ffmpegSettings);
 
            if (!result.isOk()) {
                return result;
            }
            
            if (lavfiOptionsIndex == -1) {
                complexFilterArgs << "[0:v][1:v] paletteuse";
            }
            
            args << "-i" << palettePath;
 
            // We need to kill the process so we can reuse it later down the chain. BUG:446320
            ffmpegWrapper->reset();
        }
        
        QVector<QFileInfo> audioFiles = m_doc->getAudioTracks();
        if (options.includeAudio && audioFiles.count() > 0 && audioFiles.first().exists()) {
            QFileInfo audioFileInfo = audioFiles.first();
            const int msecPerFrame = (1000 / animation->framerate());
            const int msecStart = msecPerFrame * clipRange.start();
            const int msecDuration = msecPerFrame * clipRange.duration();
 
            const QTime startTime = QTime::fromMSecsSinceStartOfDay(msecStart);
            const QTime durationTime = QTime::fromMSecsSinceStartOfDay(msecDuration);
            const QString ffmpegTimeFormat = QStringLiteral("H:m:s.zzz");
 
            args << "-ss" << QLocale::c().toString(startTime, ffmpegTimeFormat);
            args << "-t" << QLocale::c().toString(durationTime, ffmpegTimeFormat);
            args << "-i" << audioFileInfo.absoluteFilePath();
        }
      
        // if we are exporting out at a different image size, we apply scaling filter
        // export options HAVE to go after input options, so make sure this is after the audio import
        if (m_image->width() != options.width || m_image->height() != options.height) {
            simpleFilterArgs << exportDimensions;
        }
 
        if ( !complexFilterArgs.isEmpty() ) { 
            args << "-lavfi" << (!simpleFilterArgs.isEmpty() ? simpleFilterArgs.join(",").append("[0:v];"):"") + complexFilterArgs.join(";");
        } else if ( !simpleFilterArgs.isEmpty() ) {
            args << "-vf" << simpleFilterArgs.join(",");
        }
        
        args << additionalOptionsList;
 
        dbgFile << "savedFilesMask" << savedFilesMask
                << "save files offset" << sequenceStart
                << "start" << QString::number(clipRange.start()) 
                << "duration" << clipRange.duration();
 
 
        KisFFMpegWrapperSettings ffmpegSettings;
        ffmpegSettings.processPath = options.ffmpegPath;
        ffmpegSettings.args = args;
        ffmpegSettings.outputFile = resultFile;
        ffmpegSettings.totalFrames = clipRange.duration();
        ffmpegSettings.logPath = QDir::tempPath() + QDir::separator() + "krita" + QDir::separator() + "ffmpeg.log";
        ffmpegSettings.progressMessage = i18nc("Animation export dialog for tracking ffmpeg progress. arg1: file-suffix, arg2: progress frame number, arg3: totalFrameCount.",
                                               "Creating desired %1 file: %2/%3 frames.", "[suffix]", "[progress]", "[framecount]");
 
        resultOuter = ffmpegWrapper->start(ffmpegSettings);
    }
     
 
    return resultOuter;
#endif
}

References KisImage::animationInterface(), KisFFMpegWrapperSettings::args, KisMediaEncoderWrapperSettings::audioFile, KisMediaEncoderWrapperSettings::audioSeekFrame, KisAndroidUtils::copyFileToTemporary(), KisAnimationRenderingOptions::customFFMpegOptions, dbgFile, KisTimeSpan::duration(), ImportExportCodes::Failure, KisAnimationRenderingOptions::ffmpegPath, KisAnimationRenderingOptions::firstFrame, KisImageAnimationInterface::framerate(), KisAnimationRenderingOptions::frameRate, KisTimeSpan::fromTimeToTime(), KisDocument::getAudioTracks(), KisMediaEncoderWrapper::getFormatByKey(), KisImage::height(), KisAnimationRenderingOptions::height, KisAnimationRenderingOptions::includeAudio, KisMediaEncoderWrapperSettings::inputFiles, ImportExportCodes::InternalError, KisImportExportErrorCode::isOk(), KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, KisAnimationRenderingOptions::lastFrame, KisFFMpegWrapperSettings::logPath, m_doc, m_image, ImportExportCodes::OK, KisFFMpegWrapperSettings::outputFile, KisFFMpegWrapperSettings::processPath, KisFFMpegWrapperSettings::progressIndeterminate, KisFFMpegWrapperSettings::progressMessage, KisAnimationRenderingOptions::resolveAbsoluteVideoFilePath(), KisAnimationRenderingOptions::scaleFilter, KisAnimationRenderingOptions::sequenceStart, KisDocument::setErrorMessage(), KisTimeSpan::start(), KisMediaEncoderWrapper::start(), KisMediaEncoderFormat::supportsAudio(), KisFFMpegWrapperSettings::totalFrames, KisAnimationRenderingOptions::videoFileName, KisAnimationRenderingOptions::videoMimeType, KisImage::width(), and KisAnimationRenderingOptions::width.

image()

KisImageSP KisAnimationVideoSaver::image

(

)

image

Returns

get the image used by this exporter.

Definition at line 52 of file KisVideoSaver.cpp.

{
    return m_image;
}

References m_image.

Member Data Documentation

m_batchMode

bool KisAnimationVideoSaver::m_batchMode

private

Definition at line 55 of file KisVideoSaver.h.

m_doc

KisDocument* KisAnimationVideoSaver::m_doc

private

Definition at line 54 of file KisVideoSaver.h.

m_image

KisImageSP KisAnimationVideoSaver::m_image

private

Definition at line 53 of file KisVideoSaver.h.

---

The documentation for this class was generated from the following files:

• libs/ui/animation/KisVideoSaver.h
• libs/ui/animation/KisVideoSaver.cpp