KisAnimationVideoSaver Class Reference

#include <KisVideoSaver.h>

Inheritance diagram for KisAnimationVideoSaver:

Public Member Functions
KisImportExportErrorCode	encode (const QString &savedFilesMask, const KisAnimationRenderingOptions &options)
	encode the main encoding function. This in turn calls runFFMpeg, which is a private function inside this class.
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.
	~KisAnimationVideoSaver () override

Static Public Member Functions
static KisImportExportErrorCode	convert (KisDocument *document, const QString &savedFilesMask, 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.

Parameters

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

Definition at line 33 of file KisVideoSaver.cpp.

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

~KisAnimationVideoSaver()

KisAnimationVideoSaver::~KisAnimationVideoSaver ( )

override

Definition at line 40 of file KisVideoSaver.cpp.

{
}

Member Function Documentation

convert()

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

static

Definition at line 207 of file KisVideoSaver.cpp.

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

References encode().

encode()

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

encode the main encoding function. This in turn calls runFFMpeg, which is a private function inside this class.

Parameters

filename	the filename to which to render the animation.
configuration	the configuration

Returns

whether it is successful or had another failure.

Definition at line 49 of file KisVideoSaver.cpp.

{
    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;
}

References KisImage::animationInterface(), KisFFMpegWrapperSettings::args, KisAnimationRenderingOptions::customFFMpegOptions, dbgFile, KisTimeSpan::duration(), ImportExportCodes::Failure, KisAnimationRenderingOptions::ffmpegPath, KisAnimationRenderingOptions::firstFrame, KisImageAnimationInterface::framerate(), KisAnimationRenderingOptions::frameRate, KisTimeSpan::fromTimeToTime(), KisDocument::getAudioTracks(), KisImage::height(), KisAnimationRenderingOptions::height, KisAnimationRenderingOptions::includeAudio, KisImportExportErrorCode::isOk(), 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(), KisFFMpegWrapperSettings::totalFrames, KisAnimationRenderingOptions::videoMimeType, KisImage::width(), and KisAnimationRenderingOptions::width.

image()

KisImageSP KisAnimationVideoSaver::image

(

)

image

Returns

get the image used by this exporter.

Definition at line 44 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