#include <KisDlgImportVideoAnimation.h>

Inheritance diagram for KisDlgImportVideoAnimation:

Public Member Functions
QStringList	documentInfo ()

	KisDlgImportVideoAnimation (KisMainWindow m_mainWindow, KisView m_activeView)

RenderedFrames	renderFrames (const QDir &directory)

QStringList	showOpenFileDialog ()

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	loadVideoFile (const QString &filename)

void	slotDocumentHandlerChanged (int selectedIndex)

void	slotFFMpegFile ()

void	slotFFProbeFile ()

void	slotFrameNumberChanged (int frame)

void	slotImportDurationChanged (qreal time)

void	slotNextFrame ()

void	slotPrevFrame ()

void	slotVideoSliderChanged ()

void	slotVideoTimerTimeout ()

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

Private Member Functions
void	CurrentFrameChanged (int frame)

KisPropertiesConfigurationSP	loadLastUsedConfiguration (QString configurationID)

KisBasicVideoInfo	loadVideoInfo (const QString &inputFile)

QStringList	makeVideoMimeTypesList ()

void	saveLastUsedConfiguration (QString configurationID, KisPropertiesConfigurationSP config)

void	toggleInputControls (bool toggleBool)

void	updateVideoPreview ()

Private Attributes
KisView *	m_activeView

int	m_currentFrame

int	m_ffmpegFindInput

KisMainWindow *	m_mainWindow

Ui_VideoImportDialog	m_ui

KisBasicVideoInfo	m_videoInfo

QTimer *	m_videoSliderTimer

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 52 of file KisDlgImportVideoAnimation.h.

Constructor & Destructor Documentation

◆ KisDlgImportVideoAnimation()

KisDlgImportVideoAnimation::KisDlgImportVideoAnimation	(	KisMainWindow *	m_mainWindow,
		KisView *	m_activeView )

Definition at line 33 of file KisDlgImportVideoAnimation.cpp.

                                                                                                     :
    KoDialog(mainWindow),
    m_mainWindow(mainWindow),
    m_activeView(activeView)
{
    setButtons(Ok | Cancel);
    setDefaultButton(Ok);
    setWindowTitle(i18nc("@title:window", "Import Video Animation"));
 
    QWidget *page = new QWidget(this);
    m_ui.setupUi(page);
    setMainWidget(page);
 
    toggleInputControls(false);
 
    KisPropertiesConfigurationSP config = loadLastUsedConfiguration("ANIMATION_EXPORT");
    QFileInfo ffmpegFileInfo(config->getPropertyLazy("ffmpeg_path",""));
    QFileInfo ffprobeFileInfo(config->getPropertyLazy("ffprobe_path",""));
 
    dbgFile << "Config data =" << "ffmpeg:" << ffmpegFileInfo.absoluteFilePath() << "ffprobe:" << ffprobeFileInfo.absoluteFilePath();
 
    QJsonObject ffmpegInfo = KisFFMpegWrapper::findFFMpeg(ffmpegFileInfo.absoluteFilePath());
 
    if (ffmpegInfo["enabled"].toBool()) {
        m_ui.cmbFFMpegLocation->addItem(ffmpegInfo["path"].toString(),ffmpegInfo);
 
        if (ffprobeFileInfo.filePath().isEmpty())
            ffprobeFileInfo.setFile(ffmpegFileInfo.absoluteDir().filePath("ffprobe"));
 
    } else {
        enableButtonOk(false);
        m_ui.tabGeneral->setEnabled(false);
        QMessageBox::warning(this, i18nc("@title:window", "Krita"), i18n("FFMpeg not found! Please add a path to FFMpeg in the \"Advanced\" tab"));
    }
 
    QJsonObject ffprobeInfo = KisFFMpegWrapper::findFFProbe(ffprobeFileInfo.absoluteFilePath());
 
    if (ffprobeInfo["enabled"].toBool())
        m_ui.cmbFFProbeLocation->addItem(ffprobeInfo["path"].toString(),ffprobeInfo);
 
    m_ui.cmbFFProbeLocation->addItem("[Disabled]",QJsonObject({{"path",""},{"enabled",false}}));
 
    m_ui.fileLocation->setMode(KoFileDialog::OpenFile);
    m_ui.fileLocation->setMimeTypeFilters(makeVideoMimeTypesList());
    m_ui.nextFrameButton->setIcon(KisIconUtils::loadIcon("arrow-right"));
    m_ui.prevFrameButton->setIcon(KisIconUtils::loadIcon("arrow-left"));
 
    m_ui.fpsSpinbox->setValue(24.0);
    m_ui.fpsSpinbox->setSuffix(i18nc("FPS as a unit following a value, like 60 FPS", " FPS"));
 
    m_ui.frameSkipSpinbox->setValue(1);
    m_ui.frameSkipSpinbox->setRange(1,20);
 
    m_ui.startExportingAtSpinbox->setValue(0.0);
    m_ui.startExportingAtSpinbox->setRange(0.0, 9999.0);
    m_ui.startExportingAtSpinbox->setSuffix(i18nc("Second as a unit following a value, like 60 s", " s"));
 
    m_ui.videoPreviewSlider->setTickInterval(1);
    m_ui.videoPreviewSlider->setValue(0);
 
    m_ui.exportDurationSpinbox->setValue(3.0);
    m_ui.exportDurationSpinbox->setSuffix(i18nc("Second as a unit following a value, like 60 s", " s"));
 
    m_ui.lblWarning->hide();
 
    connect(m_ui.cmbDocumentHandler, SIGNAL(currentIndexChanged(int)), SLOT(slotDocumentHandlerChanged(int)));
 
    m_ui.cmbDocumentHandler->addItem(i18nc("Import video to New Document", "New Document"), "0");
 
    if (m_activeView && m_activeView->document()) {
        m_ui.cmbDocumentHandler->addItem(i18nc("Import video to Current Document", "Current Document"), "1");
        m_ui.cmbDocumentHandler->setCurrentIndex(1);
        m_ui.fpsDocumentLabel->setText(i18nc("Video importer: fps of the document you're importing into"
                                             , "<small>Document:\n %1 FPS</small>"
                                             , QString::number(m_activeView->document()->image()->animationInterface()->framerate()))
                                       );
    }
 
    m_ui.documentWidthSpinbox->setValue(0);
    m_ui.documentHeightSpinbox->setValue(0);
    m_ui.documentWidthSpinbox->setRange(1,100000);
    m_ui.documentHeightSpinbox->setRange(1,100000);
 
    m_ui.videoWidthSpinbox->setValue(0);
    m_ui.videoHeightSpinbox->setValue(0);
    m_ui.videoWidthSpinbox->setRange(1,100000);
    m_ui.videoHeightSpinbox->setRange(1,100000);
 
    m_ui.sensitivitySpinbox->setValue(50.0f);
 
    m_ui.cmbVideoScaleFilter->addItem(i18n("Bicubic"), "bicubic");
    m_ui.cmbVideoScaleFilter->addItem(i18n("Bilinear"), "bilinear");
    m_ui.cmbVideoScaleFilter->addItem(i18n("Lanczos3"), "lanczos");
    m_ui.cmbVideoScaleFilter->addItem(i18n("Nearest Neighbor"), "neighbor");
    m_ui.cmbVideoScaleFilter->addItem(i18nc("An interpolation method", "Spline"), "spline");
 
    m_ui.tabWidget->setCurrentIndex(0);
 
    m_videoSliderTimer = new QTimer(this);
    m_videoSliderTimer->setSingleShot(true);
 
    connect(m_videoSliderTimer, SIGNAL(timeout()), SLOT(slotVideoTimerTimeout()));
 
    m_currentFrame = 0;
    CurrentFrameChanged(0);
 
    connect(m_ui.fileLocation, &KisFileNameRequester::fileSelected, this, &KisDlgImportVideoAnimation::loadVideoFile);
    connect(m_ui.nextFrameButton, SIGNAL(clicked()), SLOT(slotNextFrame()));
    connect(m_ui.prevFrameButton, SIGNAL(clicked()), SLOT(slotPrevFrame()));
    connect(m_ui.currentFrameNumberInput, SIGNAL(valueChanged(int)), SLOT(slotFrameNumberChanged(int)));
    connect(m_ui.videoPreviewSlider, SIGNAL(valueChanged(int)), SLOT(slotVideoSliderChanged()));
 
    connect(m_ui.ffprobePickerButton, SIGNAL(clicked()), SLOT(slotFFProbeFile()));
    connect(m_ui.ffmpegPickerButton, SIGNAL(clicked()), SLOT(slotFFMpegFile()));
 
    connect(m_ui.exportDurationSpinbox, SIGNAL(valueChanged(qreal)), SLOT(slotImportDurationChanged(qreal)));
}

References KoDialog::Cancel, connect(), CurrentFrameChanged(), dbgFile, KisView::document, KoDialog::enableButtonOk(), KisFileNameRequester::fileSelected(), KisFFMpegWrapper::findFFMpeg(), KisFFMpegWrapper::findFFProbe(), KisIconUtils::loadIcon(), loadLastUsedConfiguration(), loadVideoFile(), m_activeView, m_currentFrame, m_ui, m_videoSliderTimer, makeVideoMimeTypesList(), KoDialog::Ok, KoFileDialog::OpenFile, KoDialog::setButtons(), KoDialog::setDefaultButton(), KoDialog::setMainWidget(), slotDocumentHandlerChanged(), slotFFMpegFile(), slotFFProbeFile(), slotFrameNumberChanged(), slotImportDurationChanged(), slotNextFrame(), slotPrevFrame(), slotVideoSliderChanged(), slotVideoTimerTimeout(), and toggleInputControls().

Member Function Documentation

◆ CurrentFrameChanged()

void KisDlgImportVideoAnimation::CurrentFrameChanged ( int frame )

private

Definition at line 632 of file KisDlgImportVideoAnimation.cpp.

{
    float currentSeconds = 0;
 
    // update frame and seconds model data if they have changed
    if (m_currentFrame != frame ) {
        dbgFile << "Frame change to:" << frame;
        m_currentFrame = frame;
        currentSeconds = m_currentFrame / m_videoInfo.fps;
    }
 
    // update UI components if they are out of sync
    if (m_currentFrame != m_ui.currentFrameNumberInput->value())
        m_ui.currentFrameNumberInput->setValue(m_currentFrame);
 
    if (m_currentFrame != m_ui.videoPreviewSlider->value())
        m_ui.videoPreviewSlider->setValue(m_currentFrame);
 
    m_ui.videoPreviewSliderValueLabel->setText( QString::number(currentSeconds, 'f', 2).append(i18nc("Second as a unit following a value, like 60 s", " s")) );
}

References dbgFile, KisBasicVideoInfo::fps, m_currentFrame, m_ui, and m_videoInfo.

◆ documentInfo()

QStringList KisDlgImportVideoAnimation::documentInfo ( )

Definition at line 297 of file KisDlgImportVideoAnimation.cpp.

                                                     {
    QStringList documentInfoList;
 
    // We're looking for a possible profile here, otherwise it gets generated. Then we get the name.
    QString profileColorSpace = RGBAColorModelID.id();
    QString profileName = KoColorSpaceRegistry::instance()->p709SRGBProfile()->name();
    if (m_videoInfo.colorTransfer != TRC_UNSPECIFIED && m_videoInfo.colorPrimaries != PRIMARIES_UNSPECIFIED) {
        const KoColorProfile *profile = KoColorSpaceRegistry::instance()->profileFor(QVector<double>(), m_videoInfo.colorPrimaries, m_videoInfo.colorTransfer);
        profileName = profile->name();
        profileColorSpace = profile->colorModelID();
    }
 
    documentInfoList << QString::number(m_ui.frameSkipSpinbox->value())
                     << QString::number(m_ui.fpsSpinbox->value())
                     << QString::number(qCeil(m_ui.fpsSpinbox->value() * m_ui.exportDurationSpinbox->value()))
                     << m_videoInfo.file;
 
    if ( m_ui.cmbDocumentHandler->currentIndex() == 0 ) {
        documentInfoList << "0"
                         << QString::number(m_ui.documentWidthSpinbox->value())
                         << QString::number(m_ui.documentHeightSpinbox->value())
                         << QString::number(72)
                         << profileColorSpace
                         << m_videoInfo.colorDepth
                         << profileName;
    } else {
        documentInfoList << "1";
    }
 
    return documentInfoList;
}

References KisBasicVideoInfo::colorDepth, KoColorProfile::colorModelID(), KisBasicVideoInfo::colorPrimaries, KisBasicVideoInfo::colorTransfer, KisBasicVideoInfo::file, KoID::id(), KoColorSpaceRegistry::instance(), m_ui, m_videoInfo, KoColorProfile::name, KoColorSpaceRegistry::p709SRGBProfile(), PRIMARIES_UNSPECIFIED, KoColorSpaceRegistry::profileFor(), RGBAColorModelID, and TRC_UNSPECIFIED.

◆ loadLastUsedConfiguration()

KisPropertiesConfigurationSP KisDlgImportVideoAnimation::loadLastUsedConfiguration ( QString configurationID )

private

Definition at line 151 of file KisDlgImportVideoAnimation.cpp.

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

References KisConfig::exportConfiguration().

◆ loadVideoFile

void KisDlgImportVideoAnimation::loadVideoFile ( const QString & filename )

protectedslot

Definition at line 368 of file KisDlgImportVideoAnimation.cpp.

{
    const QFileInfo resultFileInfo(filename);
    const QDir videoDir(resultFileInfo.absolutePath());
 
    m_videoInfo = loadVideoInfo(filename);
 
    if ( m_videoInfo.file.isEmpty() ) return;
 
    QStringList textInfo;
 
    textInfo.append(i18nc("video importer: video file statistics", "Width: %1 px", QString::number(m_videoInfo.width)));
    textInfo.append(i18nc("video importer: video file statistics", "Height: %1 px", QString::number(m_videoInfo.height)));
 
    if (m_videoInfo.colorPrimaries != PRIMARIES_UNSPECIFIED && m_videoInfo.colorTransfer != TRC_UNSPECIFIED) {
        textInfo.append(i18nc("video importer: video file statistics"
                              , "Color Primaries: %1"
                              , KoColorProfile::getColorPrimariesName(m_videoInfo.colorPrimaries)));
        textInfo.append(i18nc("video importer: video file statistics"
                              , "Color Transfer: %1"
                              , KoColorProfile::getTransferCharacteristicName(m_videoInfo.colorTransfer)));
    }
    textInfo.append(i18nc("video importer: video file statistics", "Duration: %1 s", QString::number(m_videoInfo.duration, 'f', 2)));
    textInfo.append(i18nc("video importer: video file statistics", "Frames: %1", QString::number(m_videoInfo.frames)));
    textInfo.append(i18nc("video importer: video file statistics", "FPS: %1", QString::number(m_videoInfo.fps)));
 
 
    if ( m_videoInfo.hasOverriddenFPS ) {
        textInfo.append(i18nc("video importer: video file statistics", "*<font size='0.5em'><em>*FPS not right in file. Modified to see full duration</em></font>"));
    }
 
    m_ui.fpsSpinbox->setValue( qCeil(m_videoInfo.fps) );
    m_ui.fileLoadedDetails->setText(textInfo.join("\n"));
 
 
    m_ui.videoPreviewSlider->setRange(0, m_videoInfo.frames);
    m_ui.currentFrameNumberInput->setRange(0, m_videoInfo.frames);
    m_ui.exportDurationSpinbox->setRange(0, 9999.0);
 
    if (m_ui.cmbDocumentHandler->currentIndex() == 0) {
        m_ui.documentWidthSpinbox->setValue(m_videoInfo.width);
        m_ui.documentHeightSpinbox->setValue(m_videoInfo.height);
    }
 
    m_ui.videoWidthSpinbox->setValue(m_videoInfo.width);
    m_ui.videoHeightSpinbox->setValue(m_videoInfo.height);
 
    m_ui.exportDurationSpinbox->setValue(m_videoInfo.duration);
 
    CurrentFrameChanged(0);
 
    if ( m_videoInfo.file.isEmpty() ) {
        toggleInputControls(false);
    } else {
        toggleInputControls(true);
        updateVideoPreview();
    }
 
 
}

◆ loadVideoInfo()

KisBasicVideoInfo KisDlgImportVideoAnimation::loadVideoInfo ( const QString & inputFile )

private

Definition at line 653 of file KisDlgImportVideoAnimation.cpp.

{
    QJsonObject ffmpegInfo = m_ui.cmbFFMpegLocation->currentData().toJsonObject();
    QJsonObject ffprobeInfo = m_ui.cmbFFProbeLocation->currentData().toJsonObject();
    struct KisBasicVideoInfo videoInfoData;
 
    KisFFMpegWrapper *ffprobe = new KisFFMpegWrapper(this);
    QJsonObject ffprobeJsonObj;
 
    std::function<void(void)> warnFFmpegFormatSupport = [this](){
        QMessageBox::warning(this, i18nc("@title:window", "Krita"), i18n("Your FFMpeg version does not support this format"));
    };
 
    if (ffprobeInfo["enabled"].toBool()) {
        ffprobeJsonObj = ffprobe->ffprobe(inputFile, ffprobeInfo["path"].toString());
    }
 
    // Attempt manual probing with ffmpeg itself if ffprobe is disable or if something went wrong with ffprobe.
    if ( !ffprobeInfo["enabled"].toBool() || ffprobeJsonObj["error"].toInt() == FFProbeErrorCodes::INVALID_JSON ) {
        KisFFMpegWrapper *ffmpeg = new KisFFMpegWrapper(this);
 
        ffprobeJsonObj = ffmpeg->ffmpegProbe(inputFile, ffmpegInfo["path"].toString(), false);
 
        dbgFile << "ffmpeg probe1" << ffprobeJsonObj;
 
        QJsonObject ffprobeProgress = ffprobeJsonObj["progress"].toObject();
 
        videoInfoData.frames = ffprobeProgress["frame"].toString().toInt();
    }
 
    if ( ffprobeJsonObj["error"].toInt() == FFProbeErrorCodes::UNSUPPORTED_CODEC) {
        // If, after all of that, we still don't determine a supported codec then we'll back out.
        warnFFmpegFormatSupport();
        return {};
    } else if ( ffprobeJsonObj["error"].toInt() == FFProbeErrorCodes::NONE ) {
 
        QJsonObject ffprobeFormat = ffprobeJsonObj["format"].toObject();
        QJsonArray ffprobeStreams = ffprobeJsonObj["streams"].toArray();
 
        videoInfoData.file = inputFile;
        for (const QJsonValueRef &streamItemRef : ffprobeStreams) {
            QJsonObject streamItemObj = streamItemRef.toObject();
 
            if ( streamItemObj["codec_type"].toString() == "video" ) {
                videoInfoData.stream = streamItemObj["index"].toInt();
                break;
            }
        }
 
        if ( videoInfoData.stream == -1 ) {
            QMessageBox::warning(this, i18nc("@title:window", "Krita"), i18n("No video stream could be found!"));
            return {};
        }
 
        const QJsonObject ffprobeSelectedStream = ffprobeStreams[videoInfoData.stream].toObject();
 
        const QJsonObject decoders = ffmpegInfo.value("codecs").toObject();
 
        const QString codecName = ffprobeSelectedStream["codec_name"].toString();
 
        const auto decoder = decoders.constFind(codecName);
 
        if (decoder == decoders.constEnd() ) {
            dbgFile << "Codec missing or unsupported:" << codecName;
            warnFFmpegFormatSupport();
            return {};
        } else if (!decoder->toObject().value("decoding").toBool()) {
            dbgFile << "Codec not supported for decoding:" << codecName;
            warnFFmpegFormatSupport();
            return {};
        }
 
        videoInfoData.width = ffprobeSelectedStream["width"].toInt();
        videoInfoData.height = ffprobeSelectedStream["height"].toInt();
        videoInfoData.encoding = ffprobeSelectedStream["codec_name"].toString();
        videoInfoData.colorPrimaries = KisFFMpegWrapper::colorPrimariesFromName(ffprobeSelectedStream["color_primaries"].toString());
        videoInfoData.colorTransfer = KisFFMpegWrapper::transferCharacteristicsFromName(ffprobeSelectedStream["color_transfer"].toString());
 
        // bits_per_raw_sample was introduced in 2014.
        if (ffprobeSelectedStream.value("bits_per_raw_sample").toInt() > 8) {
            videoInfoData.colorDepth = Integer16BitsColorDepthID.id();
        } else {
            videoInfoData.colorDepth = Integer8BitsColorDepthID.id();
        }
 
        // frame rate comes back in odd format...so we need to do a bit of work so it is more usable.
        // data will come back like "50/3"
        QStringList rawFrameRate = ffprobeSelectedStream["r_frame_rate"].toString().split('/');
 
        if (!rawFrameRate.isEmpty())
            videoInfoData.fps = qCeil(rawFrameRate[0].toFloat() / rawFrameRate[1].toFloat());
 
        if ( !ffprobeSelectedStream["nb_frames"].isNull() ) {
            videoInfoData.frames = ffprobeSelectedStream["nb_frames"].toString().toInt();
        }
 
        // Get duration from stream, if it doesn't exist such as on VP8 and VP9, try to get it out of format
        if ( !ffprobeSelectedStream["duration"].isNull() ) {
            videoInfoData.duration = ffprobeSelectedStream["duration"].toString().toFloat();
        } else if ( !ffprobeFormat["duration"].isNull() ) {
            videoInfoData.duration = ffprobeFormat["duration"].toString().toFloat();
        } else if ( videoInfoData.frames ) {
            videoInfoData.duration = videoInfoData.frames / videoInfoData.fps;
        }
 
        dbgFile << "Initial video info from probe: "
                << "stream:" << videoInfoData.stream
                << "frames:" << videoInfoData.frames
                << "duration:" << videoInfoData.duration
                << "fps:" << videoInfoData.fps
                << "encoding:" << videoInfoData.encoding;
 
        if ( !videoInfoData.frames && !videoInfoData.duration ) {
            KisFFMpegWrapper *ffmpeg = new KisFFMpegWrapper(this);
 
            QJsonObject ffmpegJsonObj = ffmpeg->ffmpegProbe(inputFile, ffmpegInfo["path"].toString(), false);
 
            dbgFile << "ffmpeg probe2" << ffmpegJsonObj;
 
            if ( ffprobeJsonObj["error"].toInt() != FFProbeErrorCodes::NONE ) {
                QMessageBox::warning(this, i18nc("@title:window", "Krita"), i18n("Failed to load video information"));
                return {};
            }
 
            QJsonObject ffmpegProgressJsonObj = ffmpegJsonObj["progress"].toObject();
            float ffmpegFPS = ffmpegProgressJsonObj["ffmpeg_fps"].toString().toFloat();
 
            videoInfoData.frames = ffmpegProgressJsonObj["frame"].toString().toInt();
 
            if (ffmpegFPS > 0 && videoInfoData.frames) {
                videoInfoData.duration = videoInfoData.frames / ffmpegFPS;
                videoInfoData.fps = ffmpegFPS;
            } else {
                videoInfoData.duration = ffmpegProgressJsonObj["out_time_ms"].toString().toFloat() / 1000000;
                if (videoInfoData.frames) videoInfoData.fps =  videoInfoData.frames / videoInfoData.duration;
            }
 
        }
    }
 
    // if there is no data on frames but duration and fps exists like OGV, try to estimate it
    if ( videoInfoData.fps && videoInfoData.duration && !videoInfoData.frames ) {
        videoInfoData.frames = qCeil( videoInfoData.fps * videoInfoData.duration );
    }
 
    dbgFile << "Final video info from probe: "
            << "stream:" << videoInfoData.stream
            << "frames:" << videoInfoData.frames
            << "duration:" << videoInfoData.duration
            << "fps:" << videoInfoData.fps
            << "encoding:" << videoInfoData.encoding;
 
    const float calculatedFrameRateByDuration = videoInfoData.frames / videoInfoData.duration;
    const int frameRateDifference = qAbs(videoInfoData.fps - calculatedFrameRateByDuration);
 
    if (frameRateDifference > 1) {
        // something is not right with the frame rate with this file, so let's use our calculated value
        // to make  sure we get the whole duration
        videoInfoData.hasOverriddenFPS = true;
        videoInfoData.fps = calculatedFrameRateByDuration;
    } else {
        videoInfoData.hasOverriddenFPS = false;
    }
 
    return videoInfoData;
}

◆ makeVideoMimeTypesList()

QStringList KisDlgImportVideoAnimation::makeVideoMimeTypesList ( )

private

Definition at line 329 of file KisDlgImportVideoAnimation.cpp.

{
    QStringList supportedMimeTypes = QStringList();
    supportedMimeTypes << "video/x-matroska";
    supportedMimeTypes << "image/gif";
    supportedMimeTypes << "image/apng";
    supportedMimeTypes << "image/png";
    supportedMimeTypes << "video/quicktime"; // MOV
    supportedMimeTypes << "video/ogg";
    supportedMimeTypes << "video/mp4";
    supportedMimeTypes << "video/mpeg";
    supportedMimeTypes << "video/webm";
 
    // All files
    supportedMimeTypes << "application/octet-stream";
 
    return supportedMimeTypes;
}

◆ renderFrames()

RenderedFrames KisDlgImportVideoAnimation::renderFrames ( const QDir & directory )

Definition at line 166 of file KisDlgImportVideoAnimation.cpp.

{
    RenderedFrames frames;
    QStringList &frameFileList = frames.renderedFrameFiles;
    QList<int> &frameTimeList = frames.renderedFrameTargetTimes;
 
    if ( !directory.mkpath(".") ) {
        QMessageBox::warning(this, i18nc("@title:window", "Krita"), i18n("Failed to create a work directory, make sure you have write permission"));
        return frames;
    }
 
    QStringList args;
    const float exportDuration = m_ui.exportDurationSpinbox->value();
    const float fps = m_ui.fpsSpinbox->value();
    const float nDuplicateSensitivity = m_ui.sensitivitySpinbox->value() / m_ui.sensitivitySpinbox->maximum();
 
    if (exportDuration / fps > 100.0) {
        if (QMessageBox::warning(this, i18nc("Title for a messagebox", "Krita"),
                             i18n("Warning: you are trying to import more than 100 frames into Krita.\n\n"
                                  "This means you might be overloading your system.\n"
                                  "If you want to edit a clip larger than 100 frames, consider using a real video editor, like Kdenlive (https://kdenlive.org)."),
                                 QMessageBox::Ok | QMessageBox::Cancel,
                                 QMessageBox::Cancel) == QMessageBox::Cancel) {
            return frames;
        }
    }
 
    // Setup FFMpeg Command Args...
    args << "-ss" << QString::number(m_ui.startExportingAtSpinbox->value())
         << "-i" << m_videoInfo.file;
 
    const float sceneFiltrationFilterThreshold = rerange( 1 - nDuplicateSensitivity, 0.0f, 1.0f, 0.0005f, 0.2f);
 
    if (m_ui.optionFilterDuplicates->isChecked()) {
         args << "-filter:v" << QString("select=gt(scene\\,%1)+eq(n\\,0)").arg(sceneFiltrationFilterThreshold)
              << "-vsync" << "0";
    }
 
    args << "-t" << QString::number(exportDuration)
         << "-r" << QString::number(fps);
 
    if ( m_videoInfo.width != m_ui.videoWidthSpinbox->value() || m_videoInfo.height != m_ui.videoHeightSpinbox->value() ) {
        args << "-vf" <<  QString("scale=w=")
                                    .append(QString::number(m_ui.videoWidthSpinbox->value()))
                                    .append(":h=")
                                    .append(QString::number(m_ui.videoHeightSpinbox->value()))
                                    .append(":flags=")
                                    .append(m_ui.cmbVideoScaleFilter->currentData().toString());
    }
 
    QJsonObject ffmpegInfo = m_ui.cmbFFMpegLocation->currentData().toJsonObject();
    QJsonObject ffprobeInfo = m_ui.cmbFFProbeLocation->currentData().toJsonObject();
 
    KisPropertiesConfigurationSP config = loadLastUsedConfiguration("ANIMATION_EXPORT");
 
    config->setProperty("ffmpeg_path", ffmpegInfo["path"].toString());
    config->setProperty("ffprobe_path", ffprobeInfo["path"].toString());
 
    saveLastUsedConfiguration("ANIMATION_EXPORT", config);
 
    {
        KisFFMpegWrapperSettings ffmpegSettings;
 
        ffmpegSettings.processPath = ffmpegInfo["path"].toString();
        ffmpegSettings.args = args;
        ffmpegSettings.outputFile = directory.filePath("output_%04d.png");
        ffmpegSettings.logPath = QDir::tempPath() + QDir::separator() + "krita" + QDir::separator() + "ffmpeg.log";
        ffmpegSettings.totalFrames = qCeil(exportDuration * fps);
        ffmpegSettings.progressMessage = i18nc("FFMPEG animated video import message. arg1: frame progress number. arg2: file suffix."
                                               , "Extracted %1 frames from %2 video.", "[progress]", "[suffix]");
 
        QScopedPointer<KisFFMpegWrapper> ffmpeg(new KisFFMpegWrapper(this));
 
        ffmpeg->startNonBlocking(ffmpegSettings);
 
        bool ffmpegSuccess = ffmpeg->waitForFinished();
        if (!ffmpegSuccess) {
            return RenderedFrames();
        }
 
        frameFileList = directory.entryList(QStringList() << "output_*.png",QDir::Files);
        frameFileList.replaceInStrings("output_", directory.absolutePath() + QDir::separator() + "output_");
 
        dbgFile << "Import frames list:" << frameFileList;
    }
 
    if (m_ui.optionFilterDuplicates->isChecked()){
        KisFFMpegWrapperSettings ffmpegSettings;
        ffmpegSettings.defaultPrependArgs.clear();
        ffmpegSettings.processPath = ffprobeInfo["path"].toString();
 
        QString filter = "movie=" + m_videoInfo.file + QString(",setpts=N+1,select=gt(scene\\,%1)").arg(sceneFiltrationFilterThreshold);
        ffmpegSettings.args = QStringList() << "-select_streams" << "v"
                                            << "-show_entries" << "frame=pkt_pts"
                                            << "-of" << "compact=p=0:nk=1"
                                            << "-f" << "lavfi" << filter;
 
 
        QScopedPointer<KisFFMpegWrapper> ffmpeg(new KisFFMpegWrapper(this));
        frameTimeList = {0}; // We always have a frame 0 here...
        connect(ffmpeg.data(), &KisFFMpegWrapper::sigReadSTDOUT, [&](QByteArray arr) {
            QString out = QString(arr);
 
            QStringList integerOuts = out.split("\n", Qt::SkipEmptyParts);
            Q_FOREACH(const QString& str, integerOuts){
                bool ok = false;
                const int value = str.toUInt(&ok);
                if (ok) {
                    frameTimeList.push_back(value);
                }
            }
        });
 
        ffmpeg->startNonBlocking(ffmpegSettings);
 
        bool ffmpegSuccess = ffmpeg->waitForFinished();
        if (!ffmpegSuccess) {
            return RenderedFrames();
        }
 
        dbgFile << "Assign to frames:" << ppVar(frameTimeList);
    }
 
    if ( frameFileList.isEmpty() ) {
         QMessageBox::critical(this, i18nc("@title:window", "Krita"), i18n("Failed to export frames from video"));
    }
 
    return frames;
}

References KisFFMpegWrapperSettings::args, connect(), dbgFile, KisFFMpegWrapperSettings::defaultPrependArgs, KisBasicVideoInfo::file, KisBasicVideoInfo::height, loadLastUsedConfiguration(), KisFFMpegWrapperSettings::logPath, m_ui, m_videoInfo, KisFFMpegWrapperSettings::outputFile, ppVar, KisFFMpegWrapperSettings::processPath, KisFFMpegWrapperSettings::progressMessage, RenderedFrames::renderedFrameFiles, RenderedFrames::renderedFrameTargetTimes, rerange(), saveLastUsedConfiguration(), KisFFMpegWrapper::sigReadSTDOUT(), KisFFMpegWrapperSettings::totalFrames, and KisBasicVideoInfo::width.

◆ saveLastUsedConfiguration()

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

private

Definition at line 156 of file KisDlgImportVideoAnimation.cpp.

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

References KisConfig::setExportConfiguration().

◆ showOpenFileDialog()

QStringList KisDlgImportVideoAnimation::showOpenFileDialog ( )

Definition at line 348 of file KisDlgImportVideoAnimation.cpp.

{
    KoFileDialog dialog(this, KoFileDialog::ImportFiles, "OpenDocument");
    dialog.setDefaultDir(QStandardPaths::writableLocation(QStandardPaths::PicturesLocation));
    dialog.setMimeTypeFilters( makeVideoMimeTypesList() );
    dialog.setCaption(i18n("Select your Video File"));
 
    return dialog.filenames();
}

References KoFileDialog::ImportFiles, and makeVideoMimeTypesList().

◆ slotDocumentHandlerChanged

void KisDlgImportVideoAnimation::slotDocumentHandlerChanged ( int selectedIndex )

protectedslot

Definition at line 601 of file KisDlgImportVideoAnimation.cpp.

{
    bool toggleDocumentOptions = selectedIndex == 0;
 
    if (toggleDocumentOptions) {
        m_ui.fpsDocumentLabel->setText(" ");
 
        if (m_videoInfo.stream != -1) {
            m_ui.documentWidthSpinbox->setValue(m_videoInfo.width);
            m_ui.documentHeightSpinbox->setValue(m_videoInfo.height);
        }
 
    } else if (m_activeView) {
        m_ui.fpsDocumentLabel->setText(i18nc("Video importer: fps of the document you're importing into"
                                             , "<small>Document:\n %1 FPS</small>"
                                             , QString::number(m_activeView->document()->image()->animationInterface()->framerate()))
                                       );
    }
 
    m_ui.optionsDocumentGroup->setEnabled(toggleDocumentOptions);
 
}

References KisView::document, KisBasicVideoInfo::height, m_activeView, m_ui, m_videoInfo, KisBasicVideoInfo::stream, and KisBasicVideoInfo::width.

◆ slotFFMpegFile

void KisDlgImportVideoAnimation::slotFFMpegFile ( )

protectedslot

Definition at line 573 of file KisDlgImportVideoAnimation.cpp.

{
    KoFileDialog dialog(this, KoFileDialog::OpenFile, i18n("Open FFMpeg"));
    dialog.setDefaultDir(QStandardPaths::standardLocations(QStandardPaths::ApplicationsLocation).last());
    dialog.setCaption(i18n("Open FFMpeg"));
 
    QStringList filenames = dialog.filenames();
 
    if (!filenames.isEmpty()) {
        QJsonObject ffmpegInfo = KisFFMpegWrapper::findFFMpeg(filenames[0]);
 
        if (ffmpegInfo["enabled"].toBool()) {
            if (ffmpegInfo["custom"].toBool()) {
                m_ui.cmbFFMpegLocation->addItem(filenames[0],ffmpegInfo);
                m_ui.cmbFFMpegLocation->setCurrentText(filenames[0]);
            } else {
                QMessageBox::warning(this, i18nc("@title:window", "Krita"), i18n("FFMpeg is invalid!"));
            }
            m_ui.tabGeneral->setEnabled(true);
            return;
        }
 
        m_ui.tabGeneral->setEnabled(false);
        QMessageBox::critical(this, i18nc("@title:window", "Krita"), i18n("No FFMpeg found!"));
    }
 
}

References KisFFMpegWrapper::findFFMpeg(), m_ui, and KoFileDialog::OpenFile.

◆ slotFFProbeFile

void KisDlgImportVideoAnimation::slotFFProbeFile ( )

protectedslot

Definition at line 552 of file KisDlgImportVideoAnimation.cpp.

{
    KoFileDialog dialog(this, KoFileDialog::OpenFile, i18n("Open FFProbe"));
    dialog.setDefaultDir(QStandardPaths::standardLocations(QStandardPaths::ApplicationsLocation).last());
    dialog.setCaption(i18n("Open FFProbe"));
 
    QStringList filenames = dialog.filenames();
 
    if (!filenames.isEmpty()) {
        QJsonObject ffprobeInfo = KisFFMpegWrapper::findFFProbe(filenames[0]);
 
        if (ffprobeInfo["enabled"].toBool() && ffprobeInfo["custom"].toBool()) {
            m_ui.cmbFFProbeLocation->addItem(filenames[0],ffprobeInfo);
            m_ui.cmbFFProbeLocation->setCurrentText(filenames[0]);
            return;
        }
        QMessageBox::warning(this, i18nc("@title:window", "Krita"), i18n("FFProbe is invalid!"));
    }
 
}

References KisFFMpegWrapper::findFFProbe(), m_ui, and KoFileDialog::OpenFile.

◆ slotFrameNumberChanged

void KisDlgImportVideoAnimation::slotFrameNumberChanged ( int frame )

protectedslot

Definition at line 546 of file KisDlgImportVideoAnimation.cpp.

{
    CurrentFrameChanged(frame);
}

References CurrentFrameChanged().

◆ slotImportDurationChanged

void KisDlgImportVideoAnimation::slotImportDurationChanged ( qreal time )

protectedslot

Definition at line 469 of file KisDlgImportVideoAnimation.cpp.

{
    const KisMemoryStatisticsServer::Statistics stats =
            KisMemoryStatisticsServer::instance()
            ->fetchMemoryStatistics(m_activeView ? m_activeView->image() : 0);
    const KFormat format;
 
    const int resolution = m_videoInfo.width * m_videoInfo.height;
    quint32 pixelSize = 4; //how do we even go about getting the bitdepth???
    if (m_activeView && m_ui.cmbDocumentHandler->currentIndex() > 0) {
        pixelSize = m_activeView->image()->colorSpace()->pixelSize() * 4;
    } else if (m_videoInfo.colorDepth == "U16"){
        pixelSize = 8;
    }
    const qint64 frames = std::lround(qreal(m_videoInfo.fps) * time + 2);
    // Sometimes, the potential size of the file is so big (a feature length film taking easily 970 gib), that we cannot put it into a number.
    // It's more efficient therefore to calculate the maximum amount of frames possible.
 
    const qint64 maxFrames = stats.totalMemoryLimit / resolution / pixelSize;
 
    QStringList warnings;
 
    const QString text_frames = i18nc("part of warning in video importer."
                                , "<b>Warning:</b> you are trying to import %1 frames, the maximum amount you can import is %2."
                                , frames
                                , maxFrames);
 
    QString text_memory;
 
    const QString text_video_editor = i18nc("part of warning in video importer.",
                                      "Use a <a href=\"https://kdenlive.org\">video editor</a> instead!");
 
    if (maxFrames < frames) {
        warnings.append(text_frames);
        text_memory = i18nc("part of warning in video importer."
                            , "You do not have enough memory to load this many frames, the computer will be overloaded.");
        warnings.insert(0, "<span style=\"color:#ff692e;\">");
        warnings.append(text_memory);
        warnings.append(text_video_editor);
        m_ui.lblWarning->setVisible(true);
    } else if (maxFrames < frames * 2) {
        warnings.append(text_frames);
        text_memory = i18nc("part of warning in video importer."
                            , "This will take over half the available memory, editing will be difficult.");
        warnings.insert(0, "<span style=\"color:#ffee00;\">");
        warnings.append(text_memory);
        warnings.append(text_video_editor);
        m_ui.lblWarning->setVisible(true);
    } else if (m_videoInfo.colorTransfer == TRC_ITU_R_BT_2100_0_HLG
               || m_videoInfo.colorTransfer == TRC_SMPTE_ST_428_1) {
        warnings.append(text_frames);
        QString text_trc =  i18nc("part of warning in video importer."
                                  , "Krita does not support the video transfer curve (%1), it will be loaded as linear."
                                  , KoColorProfile::getTransferCharacteristicName(m_videoInfo.colorTransfer));
        warnings.append(text_trc);
    }
 
    if (warnings.isEmpty()) {
        m_ui.lblWarning->setVisible(false);
    } else {
        m_ui.lblWarning->setText(warnings.join(" "));
        m_ui.lblWarning->setPixmap(
            m_ui.lblWarning->style()->standardIcon(QStyle::SP_MessageBoxWarning).pixmap(QSize(32, 32)));
        m_ui.lblWarning->setVisible(true);
    }
}

References KisBasicVideoInfo::colorDepth, KisImage::colorSpace(), KisBasicVideoInfo::colorTransfer, KisMemoryStatisticsServer::fetchMemoryStatistics(), KisBasicVideoInfo::fps, KoColorProfile::getTransferCharacteristicName(), KisBasicVideoInfo::height, KisView::image(), KisMemoryStatisticsServer::instance(), m_activeView, m_ui, m_videoInfo, KoColorSpace::pixelSize(), KisMemoryStatisticsServer::Statistics::totalMemoryLimit, TRC_ITU_R_BT_2100_0_HLG, TRC_SMPTE_ST_428_1, and KisBasicVideoInfo::width.

◆ slotNextFrame

void KisDlgImportVideoAnimation::slotNextFrame ( )

protectedslot

Definition at line 536 of file KisDlgImportVideoAnimation.cpp.

{
    CurrentFrameChanged(m_currentFrame+1);
}

References CurrentFrameChanged(), and m_currentFrame.

◆ slotPrevFrame

void KisDlgImportVideoAnimation::slotPrevFrame ( )

protectedslot

Definition at line 541 of file KisDlgImportVideoAnimation.cpp.

{
    CurrentFrameChanged(m_currentFrame-1);
}

References CurrentFrameChanged(), and m_currentFrame.

◆ slotVideoSliderChanged

void KisDlgImportVideoAnimation::slotVideoSliderChanged ( )

protectedslot

Definition at line 624 of file KisDlgImportVideoAnimation.cpp.

{
    CurrentFrameChanged(m_ui.videoPreviewSlider->value());
 
    if (!m_videoSliderTimer->isActive()) m_videoSliderTimer->start(300);
 
}

References CurrentFrameChanged(), m_ui, and m_videoSliderTimer.

◆ slotVideoTimerTimeout

void KisDlgImportVideoAnimation::slotVideoTimerTimeout ( )

protectedslot

Definition at line 464 of file KisDlgImportVideoAnimation.cpp.

{
    updateVideoPreview();
}

References updateVideoPreview().

◆ toggleInputControls()

void KisDlgImportVideoAnimation::toggleInputControls ( bool toggleBool )

private

Definition at line 359 of file KisDlgImportVideoAnimation.cpp.

{
    enableButtonOk(toggleBool);
    m_ui.videoPreviewSlider->setEnabled(toggleBool);
    m_ui.currentFrameNumberInput->setEnabled(toggleBool);
    m_ui.nextFrameButton->setEnabled(toggleBool);
    m_ui.prevFrameButton->setEnabled(toggleBool);
}

References KoDialog::enableButtonOk(), and m_ui.

◆ updateVideoPreview()

void KisDlgImportVideoAnimation::updateVideoPreview ( )

private

Definition at line 430 of file KisDlgImportVideoAnimation.cpp.

{
    float currentDuration = ( m_videoInfo.stream != -1 ) ?  (m_currentFrame / m_videoInfo.fps):0;
    QStringList args;
 
    args << "-ss" << QString::number(currentDuration)
         << "-i" << m_videoInfo.file
         << "-v" << "quiet"
         << "-vframes" << "1"
         << "-vcodec" << "mjpeg"
         << "-f" << "image2pipe"
         << "pipe:1";
 
    struct KisFFMpegWrapperSettings ffmpegSettings;
 
    QJsonObject ffmpegInfo = m_ui.cmbFFMpegLocation->currentData().toJsonObject();
    QByteArray byteImage = KisFFMpegWrapper::runProcessAndReturn(ffmpegInfo["path"].toString(), args, FFMPEG_TIMEOUT);
 
    if ( byteImage.isEmpty() ) {
        m_ui.thumbnailImageHolder->setText( m_videoInfo.frames == m_currentFrame ? "End of Video":"No Preview" );
    } else {
        QPixmap thumbnailPixmap;
        thumbnailPixmap.loadFromData(byteImage,"JFIF");
 
        m_ui.thumbnailImageHolder->clear();
        const QSize previewSize =
            m_ui.thumbnailImageHolder->contentsRect().size() * m_ui.thumbnailImageHolder->devicePixelRatioF();
        QPixmap img = thumbnailPixmap.scaled(previewSize, Qt::KeepAspectRatio, Qt::SmoothTransformation);
        img.setDevicePixelRatio(m_ui.thumbnailImageHolder->devicePixelRatioF());
        m_ui.thumbnailImageHolder->setPixmap(img);
    }
}

References FFMPEG_TIMEOUT, KisBasicVideoInfo::file, KisBasicVideoInfo::fps, KisBasicVideoInfo::frames, m_currentFrame, m_ui, m_videoInfo, KisFFMpegWrapper::runProcessAndReturn(), and KisBasicVideoInfo::stream.

Member Data Documentation

◆ m_activeView

KisView* KisDlgImportVideoAnimation::m_activeView

private

Definition at line 88 of file KisDlgImportVideoAnimation.h.

◆ m_currentFrame

int KisDlgImportVideoAnimation::m_currentFrame

private

Definition at line 92 of file KisDlgImportVideoAnimation.h.

◆ m_ffmpegFindInput

int KisDlgImportVideoAnimation::m_ffmpegFindInput

private

Definition at line 94 of file KisDlgImportVideoAnimation.h.

◆ m_mainWindow

KisMainWindow* KisDlgImportVideoAnimation::m_mainWindow

private

Definition at line 87 of file KisDlgImportVideoAnimation.h.

◆ m_ui

Ui_VideoImportDialog KisDlgImportVideoAnimation::m_ui

private

Definition at line 86 of file KisDlgImportVideoAnimation.h.

◆ m_videoInfo

KisBasicVideoInfo KisDlgImportVideoAnimation::m_videoInfo

private

Definition at line 91 of file KisDlgImportVideoAnimation.h.

◆ m_videoSliderTimer

QTimer* KisDlgImportVideoAnimation::m_videoSliderTimer

private

Definition at line 90 of file KisDlgImportVideoAnimation.h.

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

libs/ui/animation/KisDlgImportVideoAnimation.h
libs/ui/animation/KisDlgImportVideoAnimation.cpp

Public Member Functions

Protected Slots

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ KisDlgImportVideoAnimation()

Member Function Documentation

◆ CurrentFrameChanged()

◆ documentInfo()

◆ loadLastUsedConfiguration()

◆ loadVideoFile

◆ loadVideoInfo()

◆ makeVideoMimeTypesList()

◆ renderFrames()

◆ saveLastUsedConfiguration()

◆ showOpenFileDialog()

◆ slotDocumentHandlerChanged

◆ slotFFMpegFile

◆ slotFFProbeFile

◆ slotFrameNumberChanged

◆ slotImportDurationChanged

◆ slotNextFrame

◆ slotPrevFrame

◆ slotVideoSliderChanged

◆ slotVideoTimerTimeout

◆ toggleInputControls()

◆ updateVideoPreview()

Member Data Documentation

◆ m_activeView

◆ m_currentFrame

◆ m_ffmpegFindInput

◆ m_mainWindow

◆ m_ui

◆ m_videoInfo

◆ m_videoSliderTimer