KisDlgAnimationRenderer Class Reference

#include <KisDlgAnimationRenderer.h>

Inheritance diagram for KisDlgAnimationRenderer:

Public Member Functions
KisAnimationRenderingOptions	getEncoderOptions () const
	KisDlgAnimationRenderer (KisDocument *doc, QWidget *parent=0)
	~KisDlgAnimationRenderer () override
Public Member Functions inherited from KoDialog
QPushButton *	button (ButtonCode id) const
QIcon	buttonIcon (ButtonCode id) const
QString	buttonText (ButtonCode id) const
QString	buttonToolTip (ButtonCode id) const
QString	buttonWhatsThis (ButtonCode id) const
ButtonCode	defaultButton () const
QString	helpLinkText () const
void	incrementInitialSize (const QSize &size)
bool	isButtonEnabled (ButtonCode id) const
	KoDialog (QWidget *parent=0, Qt::WindowFlags f=Qt::WindowFlags())
QWidget *	mainWidget ()
QSize	minimumSizeHint () const override
void	setButtonFocus (ButtonCode id)
void	setButtonGuiItem (ButtonCode id, const KGuiItem &item)
void	setButtonIcon (ButtonCode id, const QIcon &icon)
void	setButtons (ButtonCodes buttonMask)
void	setButtonsOrientation (Qt::Orientation orientation)
void	setButtonText (ButtonCode id, const QString &text)
void	setButtonToolTip (ButtonCode id, const QString &text)
void	setButtonWhatsThis (ButtonCode id, const QString &text)
void	setDefaultButton (ButtonCode id)
void	setEscapeButton (ButtonCode id)
void	setInitialSize (const QSize &size)
void	setMainWidget (QWidget *widget)
void	showButton (ButtonCode id, bool state)
void	showButtonSeparator (bool state)
QSize	sizeHint () const override
	~KoDialog () override

Protected Slots
void	slotButtonClicked (int button) override
void	slotDialogAccepted ()
Protected Slots inherited from KoDialog
virtual void	slotButtonClicked (int button)

Private Types
enum	FFmpegValidationResult { VALID = 1 , INVALID = 0 , NOT_A_BINARY = -1 , COMPRESSED_FORMAT = -2 }

Private Slots
static bool	getPngHdr (KisPropertiesConfigurationSP cfg, bool wantsRenderWithHdr)
void	selectRenderOptions ()
void	selectRenderType (int i)
void	sequenceMimeTypeOptionsClicked ()
	sequenceMimeTypeSelected calls the dialog for the export widget.
void	setFFmpegPath (const QString &path)
static void	setPngHdr (KisPropertiesConfigurationSP cfg, bool enable=true)
void	slotCheckWarnings ()
void	slotExportTypeChanged ()
void	slotLockAspectRatioDimensionsHeight (int height)
void	slotLockAspectRatioDimensionsWidth (int width)
void	slotRenderTypeChanged ()

Private Member Functions
QStringList	filterMimeTypeListByAvailableEncoders (const QStringList &mimeTypes)
void	initializeRenderSettings (const KisDocument &doc, const KisAnimationRenderingOptions &lastUsedOptions)
KisHDRMetadataOptions	optionsFromImage ()
void	updateWarnings ()
FFmpegValidationResult	validateFFmpeg (const QString &ffmpegPath)
bool	wantImageSequenceExport () const
bool	wantVideoExport () const

Static Private Member Functions
static QString	defaultVideoFileName (KisDocument *doc, const QString &mimeType)
static void	filterSequenceMimeTypes (QStringList &mimeTypes)
static void	getDefaultVideoEncoderOptions (const QString &mimeType, KisPropertiesConfigurationSP cfg, const QStringList &availableEncoders, QString *customFFMpegOptionsString, bool *forceHDRVideo)
static bool	imageMimeSupportsHDR (QString &hdr)
static KisPropertiesConfigurationSP	loadLastConfiguration (QString configurationID)
static bool	looksLikeGif (const QString &videoType)
static QStringList	makeVideoMimeTypesList ()
static void	saveLastUsedConfiguration (QString configurationID, KisPropertiesConfigurationSP config)
static bool	supportsAudio (const QString &videoType)

Private Attributes
QStringList	ffmpegCodecs = QStringList()
QMap< QString, QStringList >	ffmpegEncoderTypes
QString	ffmpegVersion = "None"
QString	m_customFFMpegOptionsString
KisDocument *	m_doc
KisImageSP	m_image
WdgAnimationRenderer *	m_page {0}
bool	m_wantsRenderWithHDR = false

Additional Inherited Members
Public Types inherited from KoDialog
enum	ButtonCode {   None = 0x00000000 , Help = 0x00000001 , Default = 0x00000002 , Ok = 0x00000004 ,   Apply = 0x00000008 , Try = 0x00000010 , Cancel = 0x00000020 , Close = 0x00000040 ,   No = 0x00000080 , Yes = 0x00000100 , Reset = 0x00000200 , Details = 0x00000400 ,   User1 = 0x00001000 , User2 = 0x00002000 , User3 = 0x00004000 , NoDefault = 0x00008000 }
enum	ButtonPopupMode { InstantPopup = 0 , DelayedPopup = 1 }
enum	CaptionFlag { NoCaptionFlags = 0 , AppNameCaption = 1 , ModifiedCaption = 2 , HIGCompliantCaption = AppNameCaption }
Public Slots inherited from KoDialog
void	delayedDestruct ()
void	enableButton (ButtonCode id, bool state)
void	enableButtonApply (bool state)
void	enableButtonCancel (bool state)
void	enableButtonOk (bool state)
void	enableLinkedHelp (bool state)
bool	isDetailsWidgetVisible () const
virtual void	setCaption (const QString &caption)
virtual void	setCaption (const QString &caption, bool modified)
void	setDetailsWidget (QWidget *detailsWidget)
void	setDetailsWidgetVisible (bool visible)
void	setHelp (const QString &anchor, const QString &appname=QString())
void	setHelpLinkText (const QString &text)
virtual void	setPlainCaption (const QString &caption)
Signals inherited from KoDialog
void	aboutToShowDetails ()
void	applyClicked ()
void	buttonClicked (KoDialog::ButtonCode button)
void	cancelClicked ()
void	closeClicked ()
void	defaultClicked ()
void	finished ()
void	helpClicked ()
void	hidden ()
void	layoutHintChanged ()
void	noClicked ()
void	okClicked ()
void	resetClicked ()
void	tryClicked ()
void	user1Clicked ()
void	user2Clicked ()
void	user3Clicked ()
void	yesClicked ()
Static Public Member Functions inherited from KoDialog
static int	groupSpacingHint ()
static QString	makeStandardCaption (const QString &userCaption, QWidget *window=0, CaptionFlags flags=HIGCompliantCaption)
static int	marginHint ()
static void	resizeLayout (QLayout *lay, int margin, int spacing)
static void	resizeLayout (QWidget *widget, int margin, int spacing)
static int	spacingHint ()
Protected Member Functions inherited from KoDialog
void	closeEvent (QCloseEvent *e) override
void	hideEvent (QHideEvent *) override
void	keyPressEvent (QKeyEvent *) override
void	showEvent (QShowEvent *e) override

Detailed Description

Definition at line 43 of file KisDlgAnimationRenderer.h.

Member Enumeration Documentation

FFmpegValidationResult

enum KisDlgAnimationRenderer::FFmpegValidationResult

private

Enumerator
VALID
INVALID
NOT_A_BINARY
COMPRESSED_FORMAT

Definition at line 89 of file KisDlgAnimationRenderer.h.

                                {
        VALID = 1,
        INVALID = 0,
        NOT_A_BINARY = -1,
        COMPRESSED_FORMAT = -2
    };

Constructor & Destructor Documentation

KisDlgAnimationRenderer()

KisDlgAnimationRenderer::KisDlgAnimationRenderer	(	KisDocument *	doc,
		QWidget *	parent = 0 )

Definition at line 58 of file KisDlgAnimationRenderer.cpp.

    : KoDialog(parent)
    , m_image(doc->image())
    , m_doc(doc)
{
    KisConfig cfg(true);
 
    setCaption(i18n("Render Animation"));
    setButtons(Ok | Cancel);
    setDefaultButton(Ok);
 
    m_page = new WdgAnimationRenderer(this);
    m_page->layout()->setContentsMargins(0, 0, 0, 0);
 
    {
        QIcon editIcon = KisIconUtils::loadIcon("document-edit");
        m_page->bnExportOptions->setIcon(editIcon);
        m_page->bnRenderOptions->setIcon(editIcon);
    }
 
    m_page->lblWarnings->hide();
    m_page->lblWarnings->setPixmap(KisIconUtils::loadIcon(QStringLiteral("dialog-warning")).pixmap(32, 32));
 
#ifdef Q_OS_ANDROID
    m_exportButtonGroup = new QButtonGroup(this);
    m_exportButtonGroup->addButton(m_page->bnExportImages);
    m_exportButtonGroup->addButton(m_page->bnExportVideo);
    m_page->shouldExportOnlyImageSequence->setChecked(false);
    m_page->shouldExportOnlyVideo->setChecked(false);
    m_page->shouldExportOnlyImageSequence->setCheckable(false);
    m_page->shouldExportOnlyVideo->setCheckable(false);
    m_page->pgImages->layout()->addWidget(m_page->shouldExportOnlyImageSequence);
    m_page->pgVideo->layout()->addWidget(m_page->shouldExportOnlyVideo);
    m_page->lblVideoFilenameTitle->hide();
    m_page->videoFilename->hide();
    m_page->lblDirRequester->hide();
    m_page->dirRequester->hide();
    m_page->lblFFMpegLocationTitle->hide();
    m_page->ffmpegLocation->hide();
    m_page->lblFFMpegVersionTitle->hide();
    m_page->lblFFMpegVersion->hide();
#else
    m_page->wdgExportButtons->hide();
    m_page->stkExport->hide();
#endif
 
    m_page->dirRequester->setMode(KoFileDialog::OpenDirectory);
 
    m_page->intStart->setMinimum(0);
    m_page->intStart->setMaximum(doc->image()->animationInterface()->documentPlaybackRange().end());
    m_page->intEnd->setMinimum(doc->image()->animationInterface()->documentPlaybackRange().start());
 
    m_page->intHeight->setMinimum(1);
    m_page->intHeight->setMaximum(100000);
 
    m_page->intWidth->setMinimum(1);
    m_page->intWidth->setMaximum(100000);
 
    // Setup audio...
    QVector<QFileInfo> audioFiles = doc->getAudioTracks();
    const bool hasAudio = audioFiles.count() > 0;
    m_page->chkIncludeAudio->setEnabled(hasAudio);
 
    // Setup image mimeTypes...
    QStringList mimes = KisImportExportManager::supportedMimeTypes(KisImportExportManager::Export);
    mimes.sort();
    filterSequenceMimeTypes(mimes);
    Q_FOREACH(const QString &mime, mimes) {
        QString description = KisMimeDatabase::descriptionForMimeType(mime);
        if (description.isEmpty()) {
            description = mime;
        }
 
        m_page->cmbMimetype->addItem(description, mime);
 
        if (mime == "image/png") {
            m_page->cmbMimetype->setCurrentIndex(m_page->cmbMimetype->count() - 1);
        }
    }
 
#ifdef Q_OS_ANDROID
    // Set up video export formats on Android. No ffmpeg here.
    m_videoFormatPreferences = loadVideoFormatPreferences();
    const QVector<KisMediaEncoderFormat *> videoFormats = KisMediaEncoderWrapper::getSupportedFormats();
    for (KisMediaEncoderFormat *videoFormat : videoFormats) {
        m_page->cmbRenderType->addItem(videoFormat->title(), QVariant(videoFormat->key()));
    }
#endif
 
    m_page->cmbScaleFilter->addItem(i18nc("bicubic filtering", "bicubic"), "bicubic");
    m_page->cmbScaleFilter->addItem(i18nc("bilinear filtering", "bilinear"), "bilinear");
    m_page->cmbScaleFilter->addItem(i18nc("lanczos3 filtering", "lanczos3"), "lanczos");
    m_page->cmbScaleFilter->addItem(i18nc("nearest neighbor filtering", "neighbor"), "neighbor");
    m_page->cmbScaleFilter->addItem(i18nc("spline filtering", "spline"), "spline");
 
#ifndef Q_OS_ANDROID
    m_page->videoFilename->setMode(KoFileDialog::SaveFile);
    m_page->ffmpegLocation->setMode(KoFileDialog::OpenFile);
#endif
 
    m_page->cmbRenderType->setPlaceholderText(i18nc("Not applicable. No render types without valid ffmpeg path.", "N/A"));
 
    {   // Establish connections...
        connect(m_page->bnExportOptions, SIGNAL(clicked()), this, SLOT(sequenceMimeTypeOptionsClicked()));
        connect(m_page->bnRenderOptions, SIGNAL(clicked()), this, SLOT(selectRenderOptions()));
 
#ifdef Q_OS_ANDROID
        connect(m_exportButtonGroup,
                QOverload<QAbstractButton *>::of(&QButtonGroup::buttonClicked),
                this,
                &KisDlgAnimationRenderer::slotExportTypeChanged);
#else
        connect(m_page->shouldExportOnlyImageSequence, SIGNAL(toggled(bool)), this, SLOT(slotExportTypeChanged()));
        connect(m_page->shouldExportOnlyVideo, SIGNAL(toggled(bool)), this, SLOT(slotExportTypeChanged()));
#endif
        connect(m_page->cmbRenderType, SIGNAL(currentIndexChanged(int)), SLOT(slotRenderTypeChanged()));
 
        connect(m_page->intFramesPerSecond, SIGNAL(valueChanged(int)), SLOT(slotCheckWarnings()));
        connect(m_page->intWidth, SIGNAL(valueChanged(int)), SLOT(slotCheckWarnings()));
        connect(m_page->intHeight, SIGNAL(valueChanged(int)), SLOT(slotCheckWarnings()));
 
#ifndef Q_OS_ANDROID
        connect(m_page->ffmpegLocation, SIGNAL(fileSelected(QString)), SLOT(setFFmpegPath(QString)));
#endif
 
        connect(this, SIGNAL(accepted()), SLOT(slotDialogAccepted()));
    }
 
 
    // try to lock the width and height being updated
    KisAcyclicSignalConnector *constrainsConnector = new KisAcyclicSignalConnector(this);
    constrainsConnector->createCoordinatedConnector()->connectBackwardInt(m_page->intWidth, SIGNAL(valueChanged(int)), this, SLOT(slotLockAspectRatioDimensionsWidth(int)));
    constrainsConnector->createCoordinatedConnector()->connectForwardInt(m_page->intHeight, SIGNAL(valueChanged(int)), this, SLOT(slotLockAspectRatioDimensionsHeight(int)));
 
    {   // Initialize settings from last configuration...
        KisPropertiesConfigurationSP animProperties = loadLastConfiguration("ANIMATION_EXPORT");
        KisAnimationRenderingOptions options;
        options.fromProperties(animProperties);
 
        initializeRenderSettings(*doc, options);
    }
 
    setMainWidget(m_page);
    slotCheckWarnings();
}

References KisImage::animationInterface(), KoDialog::Cancel, KisAcyclicSignalConnector::connectBackwardInt(), KisAcyclicSignalConnector::connectForwardInt(), KisAcyclicSignalConnector::createCoordinatedConnector(), KisMimeDatabase::descriptionForMimeType(), KisImageAnimationInterface::documentPlaybackRange(), KisTimeSpan::end(), KisImportExportManager::Export, filterSequenceMimeTypes(), KisAnimationRenderingOptions::fromProperties(), KisDocument::getAudioTracks(), KisMediaEncoderWrapper::getSupportedFormats(), KisDocument::image, initializeRenderSettings(), KisIconUtils::loadIcon(), loadLastConfiguration(), m_page, KoDialog::Ok, KoFileDialog::OpenDirectory, KoFileDialog::OpenFile, KoFileDialog::SaveFile, selectRenderOptions(), sequenceMimeTypeOptionsClicked(), KoDialog::setButtons(), KoDialog::setCaption(), KoDialog::setDefaultButton(), setFFmpegPath(), KoDialog::setMainWidget(), slotCheckWarnings(), slotDialogAccepted(), slotExportTypeChanged(), slotLockAspectRatioDimensionsHeight(), slotLockAspectRatioDimensionsWidth(), slotRenderTypeChanged(), KisTimeSpan::start(), and KisImportExportManager::supportedMimeTypes().

~KisDlgAnimationRenderer()

KisDlgAnimationRenderer::~KisDlgAnimationRenderer ( )

override

Definition at line 204 of file KisDlgAnimationRenderer.cpp.

{
    delete m_page;
}

References m_page.

Member Function Documentation

defaultVideoFileName()

QString KisDlgAnimationRenderer::defaultVideoFileName ( KisDocument * doc, const QString & mimeType )

staticprivate

Definition at line 733 of file KisDlgAnimationRenderer.cpp.

{
    const QString docFileName = !doc->localFilePath().isEmpty() ? doc->localFilePath() : i18n("Untitled");
 
    if (!mimeType.isEmpty()) {
        return QString("%1.%2").arg(QFileInfo(docFileName).completeBaseName(),
                                    KisMimeDatabase::suffixesForMimeType(mimeType).first());
    } else {
        return docFileName;
    }
}

References KisDocument::localFilePath(), and KisMimeDatabase::suffixesForMimeType().

filterMimeTypeListByAvailableEncoders()

QStringList KisDlgAnimationRenderer::filterMimeTypeListByAvailableEncoders ( const QStringList & mimeTypes )

private

Definition at line 453 of file KisDlgAnimationRenderer.cpp.

{
    QStringList retValue;
 
    Q_FOREACH(const QString& mime, input) {
        if ( mime == "video/x-matroska" ) {
            if ( ffmpegCodecs.contains("h264") || ffmpegCodecs.contains("vp9") ) {
                QList<QString> encodersPresent;
                encodersPresent << ffmpegEncoderTypes["h264"] << ffmpegEncoderTypes["vp9"];
                if (meetsEncoderRequirementsForContainer(KisVideoExportOptionsDialog::MKV, encodersPresent))
                    retValue << mime;
            }
        } else if (mime == "video/mp4") {
            if ( ffmpegCodecs.contains("h264") || ffmpegCodecs.contains("vp9") ) {
                QList<QString> encodersPresent;
                encodersPresent << ffmpegEncoderTypes["h264"] << ffmpegEncoderTypes["vp9"];
                if (meetsEncoderRequirementsForContainer(KisVideoExportOptionsDialog::MP4, encodersPresent))
                    retValue << mime;
            }
        } else if (mime == "video/webm") {
            if ( ffmpegCodecs.contains("vp9") ) {
                QList<QString> encodersPresent;
                encodersPresent << ffmpegEncoderTypes["vp9"];
                if (meetsEncoderRequirementsForContainer(KisVideoExportOptionsDialog::WEBM, encodersPresent))
                    retValue << mime;
            }
        } else if (mime == "image/gif") {
            if ( ffmpegCodecs.contains("gif") ) {
                retValue << mime;
            }
        } else if (mime == "image/apng") {
            if ( ffmpegCodecs.contains("apng") ) {
                retValue << mime;
            }
        } else if (mime == "image/webp") {
            if ( ffmpegCodecs.contains("webp") ) {
                retValue << mime;
            }
        } else if (mime == "video/ogg") {
            if ( ffmpegCodecs.contains("theora") ) {
                retValue << mime;
            }
        }
    }
 
    return retValue;
}

References ffmpegCodecs, ffmpegEncoderTypes, meetsEncoderRequirementsForContainer(), KisVideoExportOptionsDialog::MKV, KisVideoExportOptionsDialog::MP4, and KisVideoExportOptionsDialog::WEBM.

filterSequenceMimeTypes()

void KisDlgAnimationRenderer::filterSequenceMimeTypes ( QStringList & mimeTypes )

staticprivate

Definition at line 417 of file KisDlgAnimationRenderer.cpp.

{
    KritaUtils::filterContainer(mimeTypes, [](QString type) {
        return (type.startsWith("image/")
                || (type.startsWith("application/") &&
                    !type.startsWith("application/x-spriter")));
    });
}

References KritaUtils::filterContainer().

getDefaultVideoEncoderOptions()

void KisDlgAnimationRenderer::getDefaultVideoEncoderOptions ( const QString & mimeType, KisPropertiesConfigurationSP cfg, const QStringList & availableEncoders, QString * customFFMpegOptionsString, bool * forceHDRVideo )

staticprivate

Definition at line 397 of file KisDlgAnimationRenderer.cpp.

{
    const KisVideoExportOptionsDialog::ContainerType containerType =
            KisVideoExportOptionsDialog::mimeToContainer(mimeType);
 
    QScopedPointer<KisVideoExportOptionsDialog> encoderConfigWidget(
        new KisVideoExportOptionsDialog(containerType, availableEncoders, KisHDRMetadataOptions(), 0));
 
    // we always enable HDR, letting the user to force it
    encoderConfigWidget->setSupportsHDR(true);
    encoderConfigWidget->setConfiguration(cfg);
    *customFFMpegOptionsString = encoderConfigWidget->customUserOptionsString();
    *renderHDR = encoderConfigWidget->videoConfiguredForHDR();
}

References KisVideoExportOptionsDialog::mimeToContainer().

getEncoderOptions()

KisAnimationRenderingOptions KisDlgAnimationRenderer::getEncoderOptions

(

)

const

Definition at line 889 of file KisDlgAnimationRenderer.cpp.

{
    KisAnimationRenderingOptions options;
 
    options.lastDocumentPath = m_doc->localFilePath();
    QString videoType = m_page->cmbRenderType->currentData().toString();
 
#ifdef Q_OS_ANDROID
    bool video = wantVideoExport();
    options.shouldEncodeVideo = video;
    options.includeAudio = video && supportsAudio(videoType) && m_page->chkIncludeAudio->isChecked();
    options.wantsOnlyUniqueFrameSequence = !video && m_page->chkOnlyUniqueFrames->isChecked();
 
    if (video) {
        options.frameMimeType = QStringLiteral("image/png");
        options.videoFileName = m_videoFileName;
        options.videoFormatKey = videoType;
        QVariantMap videoFormatPreferences = m_videoFormatPreferences.value(videoType).toMap();
        if (!videoFormatPreferences.isEmpty()) {
            options.videoFormatPreferencesJson =
                QString::fromUtf8(QJsonDocument::fromVariant(videoFormatPreferences).toJson(QJsonDocument::Compact));
        }
    } else {
        options.directory = m_imageDirectory;
        options.frameMimeType = m_page->cmbMimetype->currentData().toString();
    }
#else
    options.videoMimeType = videoType;
    options.videoFileName = m_page->videoFilename->fileName();
    options.ffmpegPath = m_page->ffmpegLocation->fileName();
    options.customFFMpegOptions = m_customFFMpegOptionsString;
    options.directory = m_page->dirRequester->fileName();
    options.shouldEncodeVideo = wantVideoExport();
    options.shouldDeleteSequence = !wantImageSequenceExport();
    options.includeAudio = supportsAudio(videoType) && m_page->chkIncludeAudio->isChecked();
    options.wantsOnlyUniqueFrameSequence = m_page->chkOnlyUniqueFrames->isChecked();
    options.frameMimeType = m_page->cmbMimetype->currentData().toString();
#endif
    options.scaleFilter = m_page->cmbScaleFilter->currentData().toString();
 
    options.basename = m_page->txtBasename->text();
    options.firstFrame = m_page->intStart->value();
    options.lastFrame = m_page->intEnd->value();
    options.sequenceStart = m_page->sequenceStart->value();
 
    options.frameRate = m_page->intFramesPerSecond->value();
    if (options.frameRate > 50 && looksLikeGif(videoType)) {
        options.frameRate = 50;
    }
 
    options.width = m_page->intWidth->value();
    options.height = m_page->intHeight->value();
 
    {
        KisPropertiesConfigurationSP cfg = loadLastConfiguration("img_sequence/" + options.frameMimeType);
        if (cfg) {
            KisImportExportManager::fillStaticExportConfigurationProperties(cfg, m_image);
        }
 
#ifndef Q_OS_ANDROID
        const bool forceNecessaryHDRSettings = m_wantsRenderWithHDR && imageMimeSupportsHDR(options.frameMimeType);
        if (forceNecessaryHDRSettings) {
            KIS_SAFE_ASSERT_RECOVER_NOOP(options.frameMimeType == "image/png");
            cfg->setProperty("forceSRGB", false);
            setPngHdr(cfg);
        }
#endif
 
        options.frameExportConfig = cfg;
    }
 
    return options;
}

References KisAnimationRenderingOptions::basename, KisAnimationRenderingOptions::customFFMpegOptions, KisAnimationRenderingOptions::directory, KisAnimationRenderingOptions::ffmpegPath, KisImportExportManager::fillStaticExportConfigurationProperties(), KisAnimationRenderingOptions::firstFrame, KisAnimationRenderingOptions::frameExportConfig, KisAnimationRenderingOptions::frameMimeType, KisAnimationRenderingOptions::frameRate, KisAnimationRenderingOptions::height, imageMimeSupportsHDR(), KisAnimationRenderingOptions::includeAudio, KIS_SAFE_ASSERT_RECOVER_NOOP, KisAnimationRenderingOptions::lastDocumentPath, KisAnimationRenderingOptions::lastFrame, loadLastConfiguration(), KisDocument::localFilePath(), looksLikeGif(), m_customFFMpegOptionsString, m_doc, m_image, m_page, m_wantsRenderWithHDR, KisAnimationRenderingOptions::scaleFilter, KisAnimationRenderingOptions::sequenceStart, setPngHdr(), KisAnimationRenderingOptions::shouldDeleteSequence, KisAnimationRenderingOptions::shouldEncodeVideo, supportsAudio(), KisAnimationRenderingOptions::videoFileName, KisAnimationRenderingOptions::videoMimeType, wantImageSequenceExport(), KisAnimationRenderingOptions::wantsOnlyUniqueFrameSequence, wantVideoExport(), and KisAnimationRenderingOptions::width.

getPngHdr

bool KisDlgAnimationRenderer::getPngHdr ( KisPropertiesConfigurationSP cfg, bool wantsRenderWithHdr )

staticprivateslot

Definition at line 1056 of file KisDlgAnimationRenderer.cpp.

{
    return cfg->getPropertyLazy("storeColorSpaceInfo", wantsRenderWithHdr)
        && cfg->getPropertyLazy("writeCicpIfPossible", wantsRenderWithHdr)
        && (cfg->getPropertyLazy("floatingPointConversionOption", wantsRenderWithHdr? "Rec2100PQ": "KeepSame") == "Rec2100PQ");
}

imageMimeSupportsHDR()

bool KisDlgAnimationRenderer::imageMimeSupportsHDR ( QString & hdr )

staticprivate

Definition at line 502 of file KisDlgAnimationRenderer.cpp.

{
    return (mime == "image/png");
}

initializeRenderSettings()

void KisDlgAnimationRenderer::initializeRenderSettings ( const KisDocument & doc, const KisAnimationRenderingOptions & lastUsedOptions )

private

Definition at line 209 of file KisDlgAnimationRenderer.cpp.

{
#ifndef Q_OS_ANDROID
    // Initialize FFmpeg location... (!)
    KisConfig cfg(false);
    QString cfgFFmpegPath = cfg.ffmpegLocation();
#ifdef Q_OS_MACOS
    if (cfgFFmpegPath.isEmpty()) {
        QJsonObject ffmpegInfo =  KisFFMpegWrapper::findFFMpeg(cfgFFmpegPath);
        cfgFFmpegPath = (ffmpegInfo["enabled"].toBool()) ? ffmpegInfo["path"].toString() : "";
    }
#endif
 
    // Check known ffmpeg locations..
    QString likelyFFmpegPath = [&]() {
        // Check last used
        if (!lastUsedOptions.ffmpegPath.isEmpty() && QFileInfo(lastUsedOptions.ffmpegPath).isExecutable()) {
            return lastUsedOptions.ffmpegPath;
        }
 
        // Check krita config
        if (!cfgFFmpegPath.isEmpty() && QFileInfo(cfgFFmpegPath).isExecutable()) {
            return cfgFFmpegPath;
        }
 
        // Check standard paths
        QString systemFFmpeg = QStandardPaths::findExecutable("ffmpeg");
        if (!systemFFmpeg.isEmpty() && QFileInfo(systemFFmpeg).isExecutable()) {
           return systemFFmpeg;
        }
 
        // Find ffmpeg elsewhere...
        QJsonObject ffmpegJsonObj = KisFFMpegWrapper::findFFMpeg("");
        return (ffmpegJsonObj["enabled"].toBool()) ? ffmpegJsonObj["path"].toString() : "";
    }();
 
    if (!likelyFFmpegPath.isEmpty() && QFileInfo(likelyFFmpegPath).isExecutable()) {
        setFFmpegPath(likelyFFmpegPath);
    }
#endif
 
    const QString documentPath = m_doc->localFilePath();
 
    // Initialize these settings based on last used configuration when possible..
    if (!lastUsedOptions.lastDocumentPath.isEmpty() &&
        lastUsedOptions.lastDocumentPath == documentPath) {
 
        // If the file is the same as last time, we use the last used basename.
        m_page->txtBasename->setText(lastUsedOptions.basename);
 
        m_page->sequenceStart->setValue(lastUsedOptions.sequenceStart);
        m_page->intWidth->setValue(lastUsedOptions.width);
        m_page->intHeight->setValue(lastUsedOptions.height);
 
#ifdef Q_OS_ANDROID
        m_page->dirRequester->setStartDir(documentPath);
#else
        m_page->videoFilename->setStartDir(lastUsedOptions.resolveAbsoluteDocumentFilePath(documentPath));
        m_page->videoFilename->setFileName(lastUsedOptions.videoFileName);
        m_page->dirRequester->setStartDir(lastUsedOptions.resolveAbsoluteDocumentFilePath(documentPath));
#endif
        m_page->dirRequester->setFileName(lastUsedOptions.directory);
 
    } else {
        m_page->sequenceStart->setValue(m_image->animationInterface()->activePlaybackRange().start());
        m_page->intWidth->setValue(m_image->width());
        m_page->intHeight->setValue(m_image->height());
 
#ifdef Q_OS_ANDROID
        m_page->dirRequester->setStartDir(documentPath);
#else
        m_page->videoFilename->setStartDir(lastUsedOptions.resolveAbsoluteDocumentFilePath(documentPath));
        m_page->videoFilename->setFileName(defaultVideoFileName(m_doc, lastUsedOptions.videoMimeType));
        m_page->dirRequester->setStartDir(lastUsedOptions.resolveAbsoluteDocumentFilePath(documentPath));
#endif
        m_page->dirRequester->setFileName(lastUsedOptions.directory);
    }
 
    // Initialize FRAME render format...
    for (int i = 0; i < m_page->cmbMimetype->count(); ++i) {
        if (m_page->cmbMimetype->itemData(i).toString() == lastUsedOptions.frameMimeType) {
            m_page->cmbMimetype->setCurrentIndex(i);
            break;
        }
    }
 
    for (int i = 0; i < m_page->cmbScaleFilter->count(); ++i) {
        if (m_page->cmbScaleFilter->itemData(i).toString() == lastUsedOptions.scaleFilter) {
            m_page->cmbScaleFilter->setCurrentIndex(i);
            break;
        }
    }
 
    // Initialize VIDEO render format...
#ifdef Q_OS_ANDROID
    const QString &lastVideoType = lastUsedOptions.videoFormatKey;
#else
    const QString &lastVideoType = lastUsedOptions.videoMimeType;
#endif
    for (int i = 0; i < m_page->cmbRenderType->count(); ++i) {
        if (m_page->cmbRenderType->itemData(i).toString() == lastVideoType) {
            m_page->cmbRenderType->setCurrentIndex(i);
            break;
        }
    }
 
    m_page->chkOnlyUniqueFrames->setChecked(lastUsedOptions.wantsOnlyUniqueFrameSequence);
#ifdef Q_OS_ANDROID
    if (lastUsedOptions.shouldEncodeVideo) {
        m_page->bnExportVideo->setChecked(true);
    } else {
        m_page->bnExportImages->setChecked(true);
    }
#else
    m_page->shouldExportOnlyVideo->setChecked(lastUsedOptions.shouldEncodeVideo);
    m_page->shouldExportOnlyImageSequence->setChecked(!lastUsedOptions.shouldDeleteSequence);
#endif
 
    slotExportTypeChanged();
 
#ifndef Q_OS_ANDROID
    {
        KisPropertiesConfigurationSP settings = loadLastConfiguration("VIDEO_ENCODER");
 
        QStringList encodersPresent;
        Q_FOREACH(const QString& key, ffmpegEncoderTypes.keys()) {
            encodersPresent << ffmpegEncoderTypes[key];
        }
 
        getDefaultVideoEncoderOptions(lastUsedOptions.videoMimeType, settings,
                                      encodersPresent,
                                      &m_customFFMpegOptionsString,
                                      &m_wantsRenderWithHDR);
    }
 
    {
        KisPropertiesConfigurationSP settings = loadLastConfiguration("img_sequence/" + lastUsedOptions.frameMimeType);
        m_wantsRenderWithHDR = getPngHdr(settings, m_wantsRenderWithHDR);
    }
 
    m_page->ffmpegLocation->setFileName(likelyFFmpegPath);
    m_page->ffmpegLocation->setStartDir(QFileInfo(m_doc->localFilePath()).path());
    m_page->ffmpegLocation->setReadOnlyText(true);
#endif
 
    // Initialize these settings based on the current document context..
    m_page->intStart->setValue(doc.image()->animationInterface()->activePlaybackRange().start());
    m_page->intEnd->setValue(doc.image()->animationInterface()->activePlaybackRange().end());
    m_page->intFramesPerSecond->setValue(doc.image()->animationInterface()->framerate());
 
    if (!doc.image()->animationInterface()->exportSequenceFilePath().isEmpty()
        && QDir(doc.image()->animationInterface()->exportSequenceFilePath()).exists() ) {
        m_page->dirRequester->setStartDir(doc.image()->animationInterface()->exportSequenceFilePath());
        m_page->dirRequester->setFileName(doc.image()->animationInterface()->exportSequenceFilePath());
    }
 
    if (!doc.image()->animationInterface()->exportSequenceBaseName().isEmpty()) {
        m_page->txtBasename->setText(doc.image()->animationInterface()->exportSequenceBaseName());
    }
 
    if (doc.image()->animationInterface()->exportInitialFrameNumber() != -1) {
        m_page->sequenceStart->setValue(doc.image()->animationInterface()->exportInitialFrameNumber());
    }
 
    bool hasAudioLoaded = doc.getAudioTracks().count() > 0;
    m_page->chkIncludeAudio->setChecked(hasAudioLoaded);
    slotRenderTypeChanged();
}

References KisImageAnimationInterface::activePlaybackRange(), KisImage::animationInterface(), KisAnimationRenderingOptions::basename, defaultVideoFileName(), KisAnimationRenderingOptions::directory, KisTimeSpan::end(), KisImageAnimationInterface::exportInitialFrameNumber(), KisImageAnimationInterface::exportSequenceBaseName(), KisImageAnimationInterface::exportSequenceFilePath(), ffmpegEncoderTypes, KisConfig::ffmpegLocation(), KisAnimationRenderingOptions::ffmpegPath, KisFFMpegWrapper::findFFMpeg(), KisAnimationRenderingOptions::frameMimeType, KisImageAnimationInterface::framerate(), KisDocument::getAudioTracks(), getDefaultVideoEncoderOptions(), getPngHdr(), KisImage::height(), KisAnimationRenderingOptions::height, KisDocument::image, KisAnimationRenderingOptions::lastDocumentPath, loadLastConfiguration(), KisDocument::localFilePath(), m_customFFMpegOptionsString, m_doc, m_image, m_page, m_wantsRenderWithHDR, KisAnimationRenderingOptions::resolveAbsoluteDocumentFilePath(), KisAnimationRenderingOptions::scaleFilter, KisAnimationRenderingOptions::sequenceStart, setFFmpegPath(), KisAnimationRenderingOptions::shouldDeleteSequence, KisAnimationRenderingOptions::shouldEncodeVideo, slotExportTypeChanged(), slotRenderTypeChanged(), KisTimeSpan::start(), KisAnimationRenderingOptions::videoFileName, KisAnimationRenderingOptions::videoMimeType, KisAnimationRenderingOptions::wantsOnlyUniqueFrameSequence, KisImage::width(), and KisAnimationRenderingOptions::width.

loadLastConfiguration()

KisPropertiesConfigurationSP KisDlgAnimationRenderer::loadLastConfiguration ( QString configurationID )

staticprivate

Definition at line 530 of file KisDlgAnimationRenderer.cpp.

                                                                                                   {
    KisConfig globalConfig(true);
    return globalConfig.exportConfiguration(configurationID);
}

References KisConfig::exportConfiguration().

looksLikeGif()

bool KisDlgAnimationRenderer::looksLikeGif ( const QString & videoType )

staticprivate

Definition at line 541 of file KisDlgAnimationRenderer.cpp.

{
#ifdef Q_OS_ANDROID
    return videoType.contains(QStringLiteral(":gif"));
#else
    return videoType == QStringLiteral("image/gif");
#endif
}

makeVideoMimeTypesList()

QStringList KisDlgAnimationRenderer::makeVideoMimeTypesList ( )

staticprivate

Definition at line 427 of file KisDlgAnimationRenderer.cpp.

{
    QStringList supportedMimeTypes = QStringList();
    supportedMimeTypes << "video/x-matroska";
    supportedMimeTypes << "video/mp4";
    supportedMimeTypes << "video/webm";
    supportedMimeTypes << "image/gif";
    supportedMimeTypes << "image/apng";    
    supportedMimeTypes << "image/webp";       
    supportedMimeTypes << "video/ogg";
 
    return supportedMimeTypes;
}

optionsFromImage()

KisHDRMetadataOptions KisDlgAnimationRenderer::optionsFromImage ( )

private

Definition at line 560 of file KisDlgAnimationRenderer.cpp.

{
    KisHDRMetadataOptions hdrOptions;
    if (m_image->relativeContentLightLevelInformation()) {
        hdrOptions.clli = *m_image->relativeContentLightLevelInformation();
    }
    if (m_image->colorVolumeInformation()) {
        hdrOptions.cvi = *m_image->colorVolumeInformation();
    }
    if (m_image->hdrReferenceWhiteLightLevel()) {
        hdrOptions.hdrReferenceWhite = *m_image->hdrReferenceWhiteLightLevel();
    }
    return hdrOptions;
}

References KisHDRMetadataOptions::clli, KisImage::colorVolumeInformation(), KisHDRMetadataOptions::cvi, KisHDRMetadataOptions::hdrReferenceWhite, KisImage::hdrReferenceWhiteLightLevel(), m_image, and KisImage::relativeContentLightLevelInformation().

saveLastUsedConfiguration()

void KisDlgAnimationRenderer::saveLastUsedConfiguration ( QString configurationID, KisPropertiesConfigurationSP config )

staticprivate

Definition at line 535 of file KisDlgAnimationRenderer.cpp.

{
    KisConfig globalConfig(false);
    globalConfig.setExportConfiguration(configurationID, config);
}

References KisConfig::setExportConfiguration().

selectRenderOptions

void KisDlgAnimationRenderer::selectRenderOptions ( )

privateslot

Definition at line 786 of file KisDlgAnimationRenderer.cpp.

{
#ifdef Q_OS_ANDROID
    QString key = m_page->cmbRenderType->currentData().toString();
    KisMediaEncoderFormat *format = KisMediaEncoderWrapper::getFormatByKey(key);
    KIS_SAFE_ASSERT_RECOVER_RETURN(format);
 
    KisMediaEncoderPreferencesDialog dlg(format, m_videoFormatPreferences.value(key).toMap(), this);
    if (dlg.exec() == QDialog::Accepted) {
        m_videoFormatPreferences.insert(key, dlg.preferences());
        saveVideoFormatPreferences(m_videoFormatPreferences);
    }
#else
    const int index = m_page->cmbRenderType->currentIndex();
    const QString mimetype = m_page->cmbRenderType->itemData(index).toString();
 
    const KisVideoExportOptionsDialog::ContainerType containerType =
        KisVideoExportOptionsDialog::mimeToContainer(mimetype);
 
    QStringList encodersPresent;
    Q_FOREACH(const QString& key, ffmpegEncoderTypes.keys()) {
        encodersPresent << ffmpegEncoderTypes[key];
    }
 
    KisHDRMetadataOptions hdrOptions = optionsFromImage();
 
    KisVideoExportOptionsDialog *encoderConfigWidget =
        new KisVideoExportOptionsDialog(containerType, encodersPresent, hdrOptions, this);
 
    // we always enable HDR, letting the user to force it
    encoderConfigWidget->setSupportsHDR(true);
 
    {
        KisPropertiesConfigurationSP settings = loadLastConfiguration("VIDEO_ENCODER");
        encoderConfigWidget->setConfiguration(settings);
        encoderConfigWidget->setHDRConfiguration(m_wantsRenderWithHDR);
    }
 
    KoDialog dlg(this);
    dlg.setMainWidget(encoderConfigWidget);
    dlg.setButtons(KoDialog::Ok | KoDialog::Cancel);
    if (dlg.exec() == QDialog::Accepted) {
        saveLastUsedConfiguration("VIDEO_ENCODER", encoderConfigWidget->configuration());
#ifndef Q_OS_ANDROID
        m_customFFMpegOptionsString = encoderConfigWidget->customUserOptionsString();
        m_wantsRenderWithHDR = encoderConfigWidget->videoConfiguredForHDR();
#endif
    }
 
    dlg.setMainWidget(0);
    encoderConfigWidget->deleteLater();
#endif
}

References KoDialog::Cancel, KisVideoExportOptionsDialog::configuration(), KisVideoExportOptionsDialog::customUserOptionsString(), ffmpegEncoderTypes, KisMediaEncoderWrapper::getFormatByKey(), KIS_SAFE_ASSERT_RECOVER_RETURN, loadLastConfiguration(), m_customFFMpegOptionsString, m_page, m_wantsRenderWithHDR, KisVideoExportOptionsDialog::mimeToContainer(), KoDialog::Ok, optionsFromImage(), KisMediaEncoderPreferencesDialog::preferences(), saveLastUsedConfiguration(), KisVideoExportOptionsDialog::setConfiguration(), KisVideoExportOptionsDialog::setHDRConfiguration(), KisVideoExportOptionsDialog::setSupportsHDR(), and KisVideoExportOptionsDialog::videoConfiguredForHDR().

selectRenderType

void KisDlgAnimationRenderer::selectRenderType ( int i )

privateslot

Definition at line 745 of file KisDlgAnimationRenderer.cpp.

{
    if (m_page->cmbRenderType->count() == 0) return;
 
    const QString mimeType = m_page->cmbRenderType->itemData(index).toString();
 
    slotCheckWarnings();
 
    QString videoFileName = defaultVideoFileName(m_doc, mimeType);
 
    if (!m_page->videoFilename->fileName().isEmpty()) {
        const QFileInfo info = QFileInfo(m_page->videoFilename->fileName());
        const QString baseName = info.completeBaseName();
        const QString path = info.path();
 
        videoFileName = QString("%1%2%3.%4")
                            .arg(path, "/", baseName, KisMimeDatabase::suffixesForMimeType(mimeType).first());
    }
    m_page->videoFilename->setMimeTypeFilters(QStringList() << mimeType, mimeType);
    m_page->videoFilename->setFileName(videoFileName);
 
    m_wantsRenderWithHDR = (mimeType == "video/mp4") ? m_wantsRenderWithHDR : false;
 
    {   // We've got to reload the render settings to account for the user changing render type without configuration.
        // If this is removed from the configuration, ogg vorbis can fail to render on first attempt. BUG:421658
        // This should be revisited at some point, too much configuration juggling in this class makes it error-prone...
 
        QStringList encodersPresent;
        Q_FOREACH(const QString& key, ffmpegEncoderTypes.keys()) {
            encodersPresent << ffmpegEncoderTypes[key];
        }
 
        KisPropertiesConfigurationSP settings = loadLastConfiguration("VIDEO_ENCODER");
        getDefaultVideoEncoderOptions(mimeType, settings,
                                      encodersPresent,
                                      &m_customFFMpegOptionsString,
                                      &m_wantsRenderWithHDR);
    }
}

References defaultVideoFileName(), ffmpegEncoderTypes, getDefaultVideoEncoderOptions(), loadLastConfiguration(), m_customFFMpegOptionsString, m_doc, m_page, m_wantsRenderWithHDR, slotCheckWarnings(), and KisMimeDatabase::suffixesForMimeType().

sequenceMimeTypeOptionsClicked

void KisDlgAnimationRenderer::sequenceMimeTypeOptionsClicked ( )

privateslot

sequenceMimeTypeSelected calls the dialog for the export widget.

Definition at line 840 of file KisDlgAnimationRenderer.cpp.

{
    int index = m_page->cmbMimetype->currentIndex();
 
    KisConfigWidget *frameExportConfigWidget = 0;
 
    QString mimetype = m_page->cmbMimetype->itemData(index).toString();
    QSharedPointer<KisImportExportFilter> filter(KisImportExportManager::filterForMimeType(mimetype, KisImportExportManager::Export));
    if (filter) {
        frameExportConfigWidget = filter->createConfigurationWidget(0, KisDocument::nativeFormatMimeType(), mimetype.toLatin1());
 
        if (frameExportConfigWidget) {
 
            KisPropertiesConfigurationSP exportConfig = loadLastConfiguration("img_sequence/" + mimetype);
            if (exportConfig) {
                KisImportExportManager::fillStaticExportConfigurationProperties(exportConfig, m_image);
            }
 
            //Important -- m_useHDR allows the synchronization of both the video and image render settings.
#ifndef Q_OS_ANDROID
            if(imageMimeSupportsHDR(mimetype)) {
                setPngHdr(exportConfig, m_wantsRenderWithHDR);
                if (m_wantsRenderWithHDR) {
                    exportConfig->setProperty("forceSRGB", false);
                }
            }
#endif
 
            frameExportConfigWidget->setConfiguration(exportConfig);
            KoDialog dlg(this);
            dlg.setMainWidget(frameExportConfigWidget);
            dlg.setButtons(KoDialog::Ok | KoDialog::Cancel);
            if (dlg.exec() == QDialog::Accepted) {
#ifndef Q_OS_ANDROID
                m_wantsRenderWithHDR = getPngHdr(frameExportConfigWidget->configuration(), false);
#endif
                saveLastUsedConfiguration("img_sequence/" + mimetype, frameExportConfigWidget->configuration());
            }
 
            frameExportConfigWidget->hide();
            dlg.setMainWidget(0);
            frameExportConfigWidget->setParent(0);
            frameExportConfigWidget->deleteLater();
 
        }
    }
}

References KoDialog::Cancel, KisConfigWidget::configuration(), KisImportExportManager::Export, KisImportExportManager::fillStaticExportConfigurationProperties(), KisImportExportManager::filterForMimeType(), getPngHdr(), imageMimeSupportsHDR(), loadLastConfiguration(), m_image, m_page, m_wantsRenderWithHDR, KisDocument::nativeFormatMimeType(), KoDialog::Ok, saveLastUsedConfiguration(), KoDialog::setButtons(), KisConfigWidget::setConfiguration(), KoDialog::setMainWidget(), and setPngHdr().

setFFmpegPath

void KisDlgAnimationRenderer::setFFmpegPath ( const QString & path )

privateslot

Definition at line 577 of file KisDlgAnimationRenderer.cpp.

                                                               {
    // Let's START with the assumption that user-specified ffmpeg path is invalid
    // and clear out all of the ffmpeg-specific fields to fill post-validation...
    m_page->cmbRenderType->setDisabled(true);
    m_page->bnRenderOptions->setDisabled(true);
 
    QString previousMimeType = m_page->cmbRenderType->currentData().toString();
 
    m_page->cmbRenderType->clear();
    ffmpegEncoderTypes.clear();
 
    // Validate FFmpeg binary and setup FFMpeg...
    if (validateFFmpeg(path)) {
        QJsonObject ffmpegJsonObj = KisFFMpegWrapper::findFFMpeg(path);
        ffmpegVersion = ffmpegJsonObj["enabled"].toBool() ? ffmpegJsonObj["version"].toString() : i18n("No valid FFmpeg binary supplied...");
        ffmpegCodecs = KisFFMpegWrapper::getSupportedCodecs(ffmpegJsonObj);
 
        // Build map of encoding types to their specific encoder support (e.g. h264 => libopenh264, h264, h264_vaapi or whatever)
        Q_FOREACH(const QString& codec, ffmpegCodecs) {
            QJsonObject codecjson = ffmpegJsonObj["codecs"].toObject()[codec].toObject();
            if ( codecjson["encoding"].toBool() ) {
                QJsonArray codecEncoders = codecjson["encoders"].toArray();
 
                // In the case where no specific codec "library" is specified but we do support
                // encoding, we simply push the type onto the list regardless. This basically
                // means that there's no "specific" requirements that we need to meet and
                // encoding should be possible.
                if (codecEncoders.size() == 0) {
                    codecEncoders.push_back(QJsonValue(codec));
                }
 
                Q_FOREACH(const QJsonValue& value, codecEncoders) {
                    if (ffmpegEncoderTypes.contains(codec)) {
                        ffmpegEncoderTypes[codec].push_back(value.toString());
                    } else {
                        ffmpegEncoderTypes.insert(codec, {value.toString()} );
                    }
                }
            }
        }
 
        KisConfig cfg(false);
 
        {   // Build list of supported container types and repopulate cmbRenderType.
            KisSignalsBlocker(m_page->cmbRenderType);
 
            QStringList supportedMimeTypes = makeVideoMimeTypesList();
            supportedMimeTypes = filterMimeTypeListByAvailableEncoders(supportedMimeTypes);
 
            int previousMimeTypeIndex = -1;
            Q_FOREACH (const QString &mime, supportedMimeTypes) {
                QString description = KisMimeDatabase::descriptionForMimeType(mime);
                if (description.isEmpty()) {
                    description = mime;
                }
 
                m_page->cmbRenderType->addItem(description, mime);
                if (mime == previousMimeType) {
                    previousMimeTypeIndex = m_page->cmbRenderType->count() - 1;
                }
            }
 
            const int indexCount = m_page->cmbRenderType->count();
            if (indexCount > 0) {
                if (previousMimeTypeIndex >= 0) {
                    m_page->cmbRenderType->setCurrentIndex(previousMimeTypeIndex % indexCount);
                } else {
                    m_page->cmbRenderType->setCurrentIndex(0);
                }
 
                selectRenderType(m_page->cmbRenderType->currentIndex());
                m_page->cmbRenderType->setDisabled(false);
                m_page->bnRenderOptions->setDisabled(false);
                connect(m_page->cmbRenderType, SIGNAL(currentIndexChanged(int)), this, SLOT(selectRenderType(int)));
            }
        }
 
        m_page->lblFFMpegVersion->setText(ffmpegVersion);
 
        // Store configuration..
        cfg.setFFMpegLocation(ffmpegJsonObj["path"].toString());
 
        slotCheckWarnings();
    }
}

References KisMimeDatabase::descriptionForMimeType(), ffmpegCodecs, ffmpegEncoderTypes, ffmpegVersion, filterMimeTypeListByAvailableEncoders(), KisFFMpegWrapper::findFFMpeg(), KisFFMpegWrapper::getSupportedCodecs(), m_page, makeVideoMimeTypesList(), selectRenderType(), KisConfig::setFFMpegLocation(), slotCheckWarnings(), validateFFmpeg(), and value().

setPngHdr

void KisDlgAnimationRenderer::setPngHdr ( KisPropertiesConfigurationSP cfg, bool enable = true )

staticprivateslot

Definition at line 1046 of file KisDlgAnimationRenderer.cpp.

{
    cfg->setProperty("storeColorSpaceInfo", enable);
    cfg->setProperty("writeCicpIfPossible", enable);
    if (enable) {
        cfg->setProperty("storeExtraColorChunks", false);
        cfg->setProperty("floatingPointConversionOption", "Rec2100PQ");
    }
}

slotButtonClicked

void KisDlgAnimationRenderer::slotButtonClicked ( int button )

overrideprotectedslot

Definition at line 985 of file KisDlgAnimationRenderer.cpp.

{
    if (button == KoDialog::Ok && !m_page->shouldExportOnlyImageSequence->isChecked()) {
        QString fileName = m_page->videoFilename->fileName();
 
        if (fileName.isEmpty()) {
            QMessageBox::warning(this, i18nc("@title:window", "Krita"), i18n("Please enter a file name to render to."));
            return;
        }
        else {
            switch (validateFFmpeg(m_page->ffmpegLocation->fileName())) {
                case FFmpegValidationResult::COMPRESSED_FORMAT:
                    QMessageBox::warning(this, i18nc("@title:window", "Krita"), i18n("The FFmpeg that you've given us appears to be compressed. Please try to extract FFmpeg from the archive first."));
                    return;
                case FFmpegValidationResult::NOT_A_BINARY:
                    QMessageBox::warning(this, i18nc("@title:window", "Krita"), i18n("The FFmpeg that you've given us appears to be invalid. Please select the correct location of an FFmpeg executable on your system."));
                    return;
                default:
                    break;
            }
        }
    }
    KoDialog::slotButtonClicked(button);
}

References KoDialog::button(), COMPRESSED_FORMAT, m_page, NOT_A_BINARY, KoDialog::Ok, KoDialog::slotButtonClicked(), and validateFFmpeg().

slotCheckWarnings

void KisDlgAnimationRenderer::slotCheckWarnings ( )

privateslot

Definition at line 664 of file KisDlgAnimationRenderer.cpp.

{
    setUpdatesEnabled(false);
    updateWarnings();
    m_page->adjustSize();
    setUpdatesEnabled(true);
}

References m_page, and updateWarnings().

slotDialogAccepted

void KisDlgAnimationRenderer::slotDialogAccepted ( )

protectedslot

Definition at line 1011 of file KisDlgAnimationRenderer.cpp.

{
#ifdef Q_OS_ANDROID
    m_imageDirectory.clear();
    m_videoFileName.clear();
 
    if (wantVideoExport()) {
        KisMediaEncoderFormat *format = KisMediaEncoderWrapper::getFormatByKey(m_page->cmbRenderType->currentData().toString());
        KIS_SAFE_ASSERT_RECOVER_RETURN(format);
        KoFileDialog dialog(this, KoFileDialog::SaveFile, QStringLiteral("ExportAnimation"));
        dialog.setMimeTypeFilters(QStringList(KisMimeDatabase::mimeTypeForSuffix(format->extension())));
        dialog.setDefaultDir(m_doc->localFilePath());
        m_videoFileName = dialog.filename();
        if (m_videoFileName.isEmpty()) {
            return;
        }
 
    } else {
        KoFileDialog dialog(this, KoFileDialog::OpenDirectory, QStringLiteral("ExportAnimation"));
        m_imageDirectory = dialog.filename();
        if (m_imageDirectory.isEmpty()) {
            return;
        }
    }
#endif
 
    KisConfig cfg(false);
    KisAnimationRenderingOptions options = getEncoderOptions();
    saveLastUsedConfiguration("ANIMATION_EXPORT", options.toProperties());
 
    m_image->animationInterface()->setExportSequenceBaseName(options.basename);
    m_image->animationInterface()->setExportSequenceFilePath(options.directory);
    m_image->animationInterface()->setExportInitialFrameNumber(options.sequenceStart);
}

References KisImage::animationInterface(), KisAnimationRenderingOptions::basename, KisAnimationRenderingOptions::directory, KisMediaEncoderFormat::extension(), getEncoderOptions(), KisMediaEncoderWrapper::getFormatByKey(), KIS_SAFE_ASSERT_RECOVER_RETURN, KisDocument::localFilePath(), m_doc, m_image, m_page, KisMimeDatabase::mimeTypeForSuffix(), KoFileDialog::OpenDirectory, KoFileDialog::SaveFile, saveLastUsedConfiguration(), KisAnimationRenderingOptions::sequenceStart, KisImageAnimationInterface::setExportInitialFrameNumber(), KisImageAnimationInterface::setExportSequenceBaseName(), KisImageAnimationInterface::setExportSequenceFilePath(), KisAnimationRenderingOptions::toProperties(), and wantVideoExport().

slotExportTypeChanged

void KisDlgAnimationRenderer::slotExportTypeChanged ( )

privateslot

A fallback fix for a case when both checkboxes are unchecked

Definition at line 1063 of file KisDlgAnimationRenderer.cpp.

{
    setUpdatesEnabled(false);
 
#ifdef Q_OS_ANDROID
    if (wantVideoExport()) {
        m_page->stkExport->setCurrentWidget(m_page->pgVideo);
    } else {
        m_page->lblWarnings->hide();
        m_page->stkExport->setCurrentWidget(m_page->pgImages);
    }
#else
    // if a video format needs to be outputted
    if (m_page->shouldExportOnlyVideo->isChecked()) {
         // videos always uses PNG for creating video, so disable the ability to change the format
         m_page->cmbMimetype->setEnabled(false);
         m_page->cmbMimetype->setCurrentIndex(m_page->cmbMimetype->findData("image/png"));
    }
 
    if (!m_page->shouldExportOnlyVideo->isChecked() &&
        !m_page->shouldExportOnlyImageSequence->isChecked()) {
 
         KisSignalsBlocker b(m_page->shouldExportOnlyImageSequence);
         m_page->shouldExportOnlyImageSequence->setChecked(true);
    }
#endif
 
    updateWarnings();
    m_page->adjustSize();
    setUpdatesEnabled(true);
}

References m_page, updateWarnings(), and wantVideoExport().

slotLockAspectRatioDimensionsHeight

void KisDlgAnimationRenderer::slotLockAspectRatioDimensionsHeight ( int height )

privateslot

Definition at line 1118 of file KisDlgAnimationRenderer.cpp.

{
    Q_UNUSED(height);
 
    float aspectRatio = (float)m_image->width() / (float)m_image->height();
 
    // update width here
     float newWidth = aspectRatio *  m_page->intHeight->value();
 
     m_page->intWidth->setValue(newWidth);
}

References KisImage::height(), m_image, m_page, and KisImage::width().

slotLockAspectRatioDimensionsWidth

void KisDlgAnimationRenderer::slotLockAspectRatioDimensionsWidth ( int width )

privateslot

Definition at line 1105 of file KisDlgAnimationRenderer.cpp.

{
    Q_UNUSED(width);
 
    float aspectRatio = (float)m_image->width() / (float)m_image->height();
 
    // update height here
    float newHeight = m_page->intWidth->value() / aspectRatio  ;
 
    m_page->intHeight->setValue(newHeight);
 
}

References KisImage::height(), m_image, m_page, and KisImage::width().

slotRenderTypeChanged

void KisDlgAnimationRenderer::slotRenderTypeChanged ( )

privateslot

Definition at line 1098 of file KisDlgAnimationRenderer.cpp.

{
    m_page->chkIncludeAudio->setVisible(m_page->cmbRenderType->count() != 0
                                        && supportsAudio(m_page->cmbRenderType->currentData().toString()));
    m_page->adjustSize();
}

References m_page, and supportsAudio().

supportsAudio()

bool KisDlgAnimationRenderer::supportsAudio ( const QString & videoType )

staticprivate

Definition at line 550 of file KisDlgAnimationRenderer.cpp.

{
#ifdef Q_OS_ANDROID
    KisMediaEncoderFormat *format = KisMediaEncoderWrapper::getFormatByKey(videoType);
    return format && format->supportsAudio();
#else
    return !videoType.startsWith(QStringLiteral("image/"));
#endif
}

References KisMediaEncoderWrapper::getFormatByKey(), and KisMediaEncoderFormat::supportsAudio().

updateWarnings()

void KisDlgAnimationRenderer::updateWarnings ( )

private

Definition at line 672 of file KisDlgAnimationRenderer.cpp.

{
    QStringList warnings;
    bool exportMayFail = false;
 
    if (wantVideoExport()) {
        QString videoType = m_page->cmbRenderType->itemData(m_page->cmbRenderType->currentIndex()).toString();
        bool gif = looksLikeGif(videoType);
 
#ifndef Q_OS_ANDROID
        const QRegularExpression minVerFFMpegRX(R"(^n{0,1}(?:[0-3]|4\.[01])[\.\-])");
        const QRegularExpressionMatch minVerFFMpegMatch = minVerFFMpegRX.match(ffmpegVersion);
 
        if (gif && minVerFFMpegMatch.hasMatch()) {
            warnings << i18nc("ffmpeg warning checks",
                              "FFmpeg must be at least version 4.2+ for GIF transparency to work");
        }
#endif
 
        int fps = m_page->intFramesPerSecond->value();
        if (gif && fps > 50) {
            warnings << i18nc("ffmpeg warning checks",
                              "Animated GIF images cannot have a framerate higher than 50. The framerate will be "
                              "reduced to 50 frames per second");
        }
 
        if (fps > 30) {
            exportMayFail = true;
            warnings << i18nc("ffmpeg warning checks", "FPS beyond 30 are not widely supported.");
        }
 
        if (m_page->intWidth->value() > 1920 || m_page->intHeight->value() > 1920) {
            exportMayFail = true;
            warnings << i18nc("ffmpeg warnings checks", "Dimensions larger than 1920 pixels are not widely supported.");
        }
    }
 
    if (warnings.isEmpty()) {
        m_page->lblWarnings->hide();
    } else {
        QString text = QString("<p><b>%1</b>").arg(i18n("Warning(s):"));
        text.append("<ul>");
        Q_FOREACH (const QString &warning, warnings) {
            text.append("<li>");
            text.append(warning.toHtmlEscaped());
            text.append("</li>");
        }
        text.append("</ul></p>");
        if (exportMayFail) {
            text.append(QStringLiteral("<p>"));
            text.append(
                i18nc("ffmpeg warning checks", "The export may fail and some devices may not be able to play it.")
                    .toHtmlEscaped());
            text.append(QStringLiteral("</p>"));
        }
        m_page->lblWarnings->setText(text);
        m_page->lblWarnings->show();
    }
}

References ffmpegVersion, looksLikeGif(), m_page, and wantVideoExport().

validateFFmpeg()

KisDlgAnimationRenderer::FFmpegValidationResult KisDlgAnimationRenderer::validateFFmpeg ( const QString & ffmpegPath )

private

Definition at line 964 of file KisDlgAnimationRenderer.cpp.

{
    if (!ffmpegPath.isEmpty()) {
        QFileInfo ffmpegBinary(ffmpegPath);
        if (ffmpegBinary.exists() && ffmpegBinary.isExecutable()) {
            QStringList commpressedFormats{"zip", "7z", "tar.bz2"};
            Q_FOREACH(const QString& compressedFormat, commpressedFormats) {
                if (ffmpegBinary.fileName().endsWith(compressedFormat)) {
                    return FFmpegValidationResult::COMPRESSED_FORMAT;
                }
            }
            return FFmpegValidationResult::VALID;
        } else if (ffmpegBinary.exists()) {
            return FFmpegValidationResult::NOT_A_BINARY;
        }
    }
    return FFmpegValidationResult::INVALID;
}

References COMPRESSED_FORMAT, INVALID, NOT_A_BINARY, and VALID.

wantImageSequenceExport()

bool KisDlgAnimationRenderer::wantImageSequenceExport ( ) const

private

Definition at line 378 of file KisDlgAnimationRenderer.cpp.

{
#ifdef Q_OS_ANDROID
    return !wantVideoExport();
#else
    return m_page->shouldExportOnlyImageSequence->isChecked();
#endif
}

References m_page, and wantVideoExport().

wantVideoExport()

bool KisDlgAnimationRenderer::wantVideoExport ( ) const

private

Definition at line 387 of file KisDlgAnimationRenderer.cpp.

{
#ifdef Q_OS_ANDROID
    return m_page->bnExportVideo->isChecked();
#else
    return m_page->shouldExportOnlyVideo->isChecked();
#endif
}

References m_page.

Member Data Documentation

ffmpegCodecs

QStringList KisDlgAnimationRenderer::ffmpegCodecs = QStringList()

private

Definition at line 150 of file KisDlgAnimationRenderer.h.

ffmpegEncoderTypes

QMap<QString, QStringList> KisDlgAnimationRenderer::ffmpegEncoderTypes

private

Definition at line 151 of file KisDlgAnimationRenderer.h.

ffmpegVersion

QString KisDlgAnimationRenderer::ffmpegVersion = "None"

private

Definition at line 148 of file KisDlgAnimationRenderer.h.

m_customFFMpegOptionsString

QString KisDlgAnimationRenderer::m_customFFMpegOptionsString

private

Definition at line 147 of file KisDlgAnimationRenderer.h.

m_doc

KisDocument* KisDlgAnimationRenderer::m_doc

private

Definition at line 139 of file KisDlgAnimationRenderer.h.

m_image

KisImageSP KisDlgAnimationRenderer::m_image

private

Definition at line 138 of file KisDlgAnimationRenderer.h.

m_page

WdgAnimationRenderer* KisDlgAnimationRenderer::m_page {0}

private

Definition at line 156 of file KisDlgAnimationRenderer.h.

{0};

m_wantsRenderWithHDR

bool KisDlgAnimationRenderer::m_wantsRenderWithHDR = false

private

Definition at line 153 of file KisDlgAnimationRenderer.h.

---

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

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