Public Member Functions
QString	applyVariables (const QString &templateArguments)

void	checkFfmpeg ()

void	cleanupFFMpeg ()

void	fillComboProfiles ()

QString	formatDuration (long durationMs)

	Private (RecorderExport *q_ptr)

QStringList	splitCommand (const QString &command)

void	startExport ()

bool	tryAbortExport ()

void	updateFps (RecorderExportConfig &config, bool takeFromInputFps=false)

void	updateFrameInfo ()

void	updateRatio (bool widthToHeight)

void	updateVideoDuration ()

void	updateVideoFilePath ()

Public Attributes
RecorderDirectoryCleaner *	cleaner = nullptr

QElapsedTimer	elapsedTimer

QScopedPointer< KisFFMpegWrapper >	ffmpeg

RecorderExport *	q

RecorderExportSettings *	settings

int	spinInputFPSMaxValue = 0

int	spinInputFPSMinValue = 0

QScopedPointer< Ui::RecorderExport >	ui

Detailed Description

Definition at line 48 of file recorder_export.cpp.

Constructor & Destructor Documentation

◆ Private()

RecorderExport::Private::Private ( RecorderExport * q_ptr )

inline

Definition at line 63 of file recorder_export.cpp.

        : q(q_ptr)
        , ui(new Ui::RecorderExport)
        , settings(q_ptr->settings)
    {
    }

Member Function Documentation

◆ applyVariables()

QString RecorderExport::Private::applyVariables ( const QString & templateArguments )

inline

Definition at line 262 of file recorder_export.cpp.

    {
        const QSize &outSize = settings->resize ? settings->size : settings->imageSize;
        const int previewLength = settings->resultPreview ? settings->firstFrameSec : 0;
        const int resultLength = settings->extendResult ? settings->lastFrameSec : 0;
        const float transitionLength = settings->resultPreview ? 0.7 : 0;
        return QString(templateArguments)
               .replace("$IN_FPS", QString::number(settings->inputFps))
               .replace("$OUT_FPS", QString::number(settings->fps))
               .replace("$WIDTH", QString::number(outSize.width()))
               .replace("$HEIGHT", QString::number(outSize.height()))
               .replace("$FRAMES", QString::number(settings->framesCount))
               .replace("$INPUT_DIR", settings->inputDirectory)
               .replace("$FIRST_FRAME_SEC", QString::number(previewLength))
               .replace("$TRANSITION_LENGTH", QString::number(transitionLength))
               .replace("$H264_ENCODER", settings->h264Encoder)
               .replace("$LAST_FRAME_SEC", QString::number(resultLength))
               .replace("$EXT", RecorderFormatInfo::fileExtension(settings->format));
    }

◆ checkFfmpeg()

void RecorderExport::Private::checkFfmpeg ( )

inline

Definition at line 70 of file recorder_export.cpp.

    {
        const QJsonObject ffmpegJson = KisFFMpegWrapper::findFFMpeg(settings->ffmpegPath);
        const bool success = ffmpegJson["enabled"].toBool();
        const QIcon &icon = KisIconUtils::loadIcon(success ? "dialog-ok" : "window-close");
        const QList<QAction *> &actions = ui->editFfmpegPath->actions();
        QAction *action;
 
        if (!actions.isEmpty()) {
            action = actions.first();
            action->setIcon(icon);
        } else {
            action = ui->editFfmpegPath->addAction(icon, QLineEdit::TrailingPosition);
        }
        if (success) {
            const QJsonArray h264Encoders = ffmpegJson["codecs"].toObject()["h264"].toObject()["encoders"].toArray();
            settings->ffmpegPath = ffmpegJson["path"].toString();
            settings->h264Encoder = h264Encoders.contains("libopenh264") ? "libopenh264" : "libx264";
            ui->editFfmpegPath->setText(settings->ffmpegPath);
            action->setToolTip("Version: "+ffmpegJson["version"].toString()
                                +(ffmpegJson["codecs"].toObject()["h264"].toObject()["encoding"].toBool() ? "":" (MP4/MKV UNSUPPORTED)")
            );
        } else {
            ui->editFfmpegPath->setText(i18nc("This text is displayed instead of path to external tool in case of external tool is not found", "[NOT FOUND]"));
            action->setToolTip(i18n("FFmpeg executable location couldn't be detected, please install it or select its location manually"));
        }
        ui->buttonBox->button(QDialogButtonBox::Save)->setEnabled(success);
    }

References RecorderExportSettings::ffmpegPath, KisFFMpegWrapper::findFFMpeg(), RecorderExportSettings::h264Encoder, KisIconUtils::loadIcon(), settings, and ui.

◆ cleanupFFMpeg()

void RecorderExport::Private::cleanupFFMpeg ( )

inline

Definition at line 254 of file recorder_export.cpp.

    {
        if (ffmpeg) {
            ffmpeg->reset();
            ffmpeg.reset();
        }
    }

References ffmpeg.

◆ fillComboProfiles()

void RecorderExport::Private::fillComboProfiles ( )

inline

Definition at line 99 of file recorder_export.cpp.

    {
        QSignalBlocker blocker(ui->comboProfile);
        ui->comboProfile->clear();
        for (const RecorderProfile &profile : settings->profiles) {
            ui->comboProfile->addItem(profile.name);
        }
        blocker.unblock();
        ui->comboProfile->setCurrentIndex(settings->profileIndex);
    }

References RecorderExportSettings::profileIndex, RecorderExportSettings::profiles, settings, and ui.

◆ formatDuration()

QString RecorderExport::Private::formatDuration ( long durationMs )

inline

Definition at line 297 of file recorder_export.cpp.

    {
        QString result;
        const long ms = (durationMs % 1000) / 10;
 
        result += QString(".%1").arg(ms, 2, 10, QLatin1Char('0'));
 
        long duration = durationMs / 1000;
        const long seconds = duration % 60;
        result = QString("%1%2").arg(seconds, 2, 10, QLatin1Char('0')).arg(result);
 
        duration = duration / 60;
        const long minutes = duration % 60;
        if (minutes != 0) {
            result = QString("%1:%2").arg(minutes, 2, 10, QLatin1Char('0')).arg(result);
 
            duration = duration / 60;
            if (duration != 0)
                result = QString("%1:%2").arg(duration, 2, 10, QLatin1Char('0')).arg(result);
        }
 
        return result;
    }

◆ splitCommand()

QStringList RecorderExport::Private::splitCommand ( const QString & command )

inline

Definition at line 186 of file recorder_export.cpp.

    {
        QStringList args;
        QString tmp;
        int quoteCount = 0;
        bool inQuote = false;
 
        // handle quoting. tokens can be surrounded by double quotes
        // "hello world". three consecutive double quotes represent
        // the quote character itself.
        for (int i = 0; i < command.size(); ++i) {
            if (command.at(i) == QLatin1Char('"')) {
                ++quoteCount;
                if (quoteCount == 3) {
                    // third consecutive quote
                    quoteCount = 0;
                    tmp += command.at(i);
                }
                continue;
            }
            if (quoteCount) {
                if (quoteCount == 1)
                    inQuote = !inQuote;
                quoteCount = 0;
            }
            if (!inQuote && command.at(i).isSpace()) {
                if (!tmp.isEmpty()) {
                    args += tmp;
                    tmp.clear();
                }
            } else {
                tmp += command.at(i);
            }
        }
        if (!tmp.isEmpty())
            args += tmp;
 
        return args;
    }

◆ startExport()

void RecorderExport::Private::startExport ( )

inline

Definition at line 226 of file recorder_export.cpp.

    {
        Q_ASSERT(ffmpeg == nullptr);
 
        updateFrameInfo();
 
        const QString &arguments = applyVariables(settings->profiles[settings->profileIndex].arguments);
 
        ffmpeg.reset(new KisFFMpegWrapper(q));
        QObject::connect(ffmpeg.data(), SIGNAL(sigStarted()), q, SLOT(onFFMpegStarted()));
        QObject::connect(ffmpeg.data(), SIGNAL(sigFinished()), q, SLOT(onFFMpegFinished()));
        QObject::connect(ffmpeg.data(), SIGNAL(sigFinishedWithError(QString)), q, SLOT(onFFMpegFinishedWithError(QString)));
        QObject::connect(ffmpeg.data(), SIGNAL(sigProgressUpdated(int)), q, SLOT(onFFMpegProgressUpdated(int)));
 
        KisFFMpegWrapperSettings FFmpegSettings;
        KisConfig cfg(true);
        FFmpegSettings.processPath = settings->ffmpegPath;
        FFmpegSettings.args = splitCommand(arguments);
        FFmpegSettings.outputFile = settings->videoFilePath;
        FFmpegSettings.batchMode = true; //TODO: Consider renaming to 'silent' mode, meaning no window for extra window handling...
 
        ffmpeg->startNonBlocking(FFmpegSettings);
        ui->labelStatus->setText(i18nc("Status for the export of the video record", "Starting FFmpeg..."));
        ui->buttonCancelExport->setEnabled(false);
        ui->progressExport->setValue(0);
        elapsedTimer.start();
    }

References applyVariables(), KisFFMpegWrapperSettings::args, KisFFMpegWrapperSettings::batchMode, elapsedTimer, ffmpeg, RecorderExportSettings::ffmpegPath, RecorderExport::onFFMpegFinished(), RecorderExport::onFFMpegFinishedWithError(), RecorderExport::onFFMpegProgressUpdated(), RecorderExport::onFFMpegStarted(), KisFFMpegWrapperSettings::outputFile, KisFFMpegWrapperSettings::processPath, RecorderExportSettings::profileIndex, RecorderExportSettings::profiles, q, settings, splitCommand(), ui, updateFrameInfo(), and RecorderExportSettings::videoFilePath.

◆ tryAbortExport()

bool RecorderExport::Private::tryAbortExport ( )

inline

Definition at line 172 of file recorder_export.cpp.

    {
        if (!ffmpeg)
            return true;
 
        if (QMessageBox::question(q, q->windowTitle(), i18n("Abort encoding the timelapse video?"))
            == QMessageBox::Yes) {
            cleanupFFMpeg();
            return true;
        }
 
        return false;
    }

References cleanupFFMpeg(), ffmpeg, and q.

◆ updateFps()

void RecorderExport::Private::updateFps	(	RecorderExportConfig &	config,
		bool	takeFromInputFps = false )

inline

Definition at line 155 of file recorder_export.cpp.

    {
        if (!settings->lockFps)
            return;
 
        if (takeFromInputFps) {
            settings->fps = settings->inputFps;
            config.setFps(settings->fps);
            ui->spinFps->setValue(settings->fps);
        } else {
            settings->inputFps = settings->fps;
            config.setInputFps(settings->inputFps);
            ui->spinInputFps->setValue(settings->inputFps);
        }
        updateVideoDuration();
    }

References RecorderExportSettings::fps, RecorderExportSettings::inputFps, RecorderExportSettings::lockFps, RecorderExportConfig::setFps(), RecorderExportConfig::setInputFps(), settings, ui, and updateVideoDuration().

◆ updateFrameInfo()

void RecorderExport::Private::updateFrameInfo ( )

inline

Definition at line 110 of file recorder_export.cpp.

    {
        QDir dir(settings->inputDirectory, "*." % RecorderFormatInfo::fileExtension(settings->format),
                QDir::Name, QDir::Files | QDir::NoDotAndDotDot);
        const QStringList &frames = dir.entryList(); // dir.count() calls entryList().count() internally
        settings->framesCount = frames.count();
        if (settings->framesCount != 0) {
            const QString &fileName = settings->inputDirectory % QDir::separator() % frames.last();
            settings->imageSize = QImageReader(fileName).size();
            settings->imageSize.rwidth() &= ~1;
            settings->imageSize.rheight() &= ~1;
        }
    }

References RecorderFormatInfo::fileExtension(), RecorderExportSettings::format, RecorderExportSettings::framesCount, RecorderExportSettings::imageSize, RecorderExportSettings::inputDirectory, and settings.

◆ updateRatio()

void RecorderExport::Private::updateRatio ( bool widthToHeight )

inline

Definition at line 138 of file recorder_export.cpp.

    {
        const float ratio = static_cast<float>(settings->imageSize.width()) / static_cast<float>(settings->imageSize.height());
        if (widthToHeight) {
            settings->size.setHeight(static_cast<int>(settings->size.width() / ratio));
        } else {
            settings->size.setWidth(static_cast<int>(settings->size.height() * ratio));
        }
        // make width and height even
        settings->size.rwidth() &= ~1;
        settings->size.rheight() &= ~1;
        QSignalBlocker blockerWidth(ui->spinScaleHeight);
        QSignalBlocker blockerHeight(ui->spinScaleWidth);
        ui->spinScaleHeight->setValue(settings->size.height());
        ui->spinScaleWidth->setValue(settings->size.width());
    }

References RecorderExportSettings::imageSize, settings, RecorderExportSettings::size, and ui.

◆ updateVideoDuration()

void RecorderExport::Private::updateVideoDuration ( )

inline

Definition at line 282 of file recorder_export.cpp.

    {
        long ms = (settings->framesCount * 1000L / (settings->inputFps ? settings->inputFps : 30));
 
        if (settings->resultPreview) {
            ms += (settings->firstFrameSec * 1000L);
        }
 
        if (settings->extendResult) {
            ms += (settings->lastFrameSec * 1000L);
        }
 
        ui->labelVideoDuration->setText(formatDuration(ms));
    }

References RecorderExportSettings::extendResult, RecorderExportSettings::firstFrameSec, formatDuration(), RecorderExportSettings::framesCount, RecorderExportSettings::inputFps, RecorderExportSettings::lastFrameSec, RecorderExportSettings::resultPreview, settings, and ui.

◆ updateVideoFilePath()

void RecorderExport::Private::updateVideoFilePath ( )

inline

Definition at line 124 of file recorder_export.cpp.

    {
        if (settings->videoDirectory.isEmpty())
            settings->videoDirectory = RecorderExportConfig(true).videoDirectory();
 
        settings->videoFilePath = settings->videoDirectory
            % QDir::separator()
            % settings->videoFileName
            % "."
            % settings->profiles[settings->profileIndex].extension;
        QSignalBlocker blocker(ui->editVideoFilePath);
        ui->editVideoFilePath->setText(settings->videoFilePath);
    }

References RecorderExportSettings::profileIndex, RecorderExportSettings::profiles, settings, ui, RecorderExportConfig::videoDirectory(), RecorderExportSettings::videoDirectory, RecorderExportSettings::videoFileName, and RecorderExportSettings::videoFilePath.

Member Data Documentation

◆ cleaner

RecorderDirectoryCleaner* RecorderExport::Private::cleaner = nullptr

Definition at line 56 of file recorder_export.cpp.

◆ elapsedTimer

QElapsedTimer RecorderExport::Private::elapsedTimer

Definition at line 58 of file recorder_export.cpp.

◆ ffmpeg

QScopedPointer<KisFFMpegWrapper> RecorderExport::Private::ffmpeg

Definition at line 55 of file recorder_export.cpp.

◆ q

RecorderExport* RecorderExport::Private::q

Definition at line 51 of file recorder_export.cpp.

◆ settings

RecorderExportSettings* RecorderExport::Private::settings

Definition at line 53 of file recorder_export.cpp.

◆ spinInputFPSMaxValue

int RecorderExport::Private::spinInputFPSMaxValue = 0

Definition at line 61 of file recorder_export.cpp.

◆ spinInputFPSMinValue

int RecorderExport::Private::spinInputFPSMinValue = 0

Definition at line 60 of file recorder_export.cpp.

◆ ui

QScopedPointer<Ui::RecorderExport> RecorderExport::Private::ui

Definition at line 52 of file recorder_export.cpp.

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

plugins/dockers/recorder/recorder_export.cpp

Public Member Functions

Public Attributes

Detailed Description

Constructor & Destructor Documentation

◆ Private()

Member Function Documentation

◆ applyVariables()

◆ checkFfmpeg()

◆ cleanupFFMpeg()

◆ fillComboProfiles()

◆ formatDuration()

◆ splitCommand()

◆ startExport()

◆ tryAbortExport()

◆ updateFps()

◆ updateFrameInfo()

◆ updateRatio()

◆ updateVideoDuration()

◆ updateVideoFilePath()

Member Data Documentation

◆ cleaner

◆ elapsedTimer

◆ ffmpeg

◆ q

◆ settings

◆ spinInputFPSMaxValue

◆ spinInputFPSMinValue

◆ ui