RecorderExport::Private Class Reference

Public Member Functions
QString	applyVariables (const QString &templateArguments)
void	checkExporter ()
void	cleanupExporter ()
void	fillComboProfiles ()
QString	formatDuration (long durationMs)
void	initDimensions ()
	Private (RecorderExport *q_ptr)
QString	requestFile (const QString &extension, const QString &defaultDir=QString())
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 ()
void	updateWarningVisibility ()

Static Public Member Functions
static void	desktopServicesOpenPath (const QString &path)

Public Attributes
RecorderDirectoryCleaner *	cleaner = nullptr
QElapsedTimer	elapsedTimer
QScopedPointer< Exporter >	exporter
QScopedPointer< RecorderExportPreprocessor >	preprocessor
RecorderExport *	q
RecorderExportSettings *	settings
int	spinInputFPSMaxValue = 0
int	spinInputFPSMinValue = 0
QScopedPointer< Ui::RecorderExport >	ui

Static Public Attributes
static constexpr int	DIMENSION_LIMIT = 1920

Detailed Description

Definition at line 62 of file recorder_export.cpp.

Constructor & Destructor Documentation

Private()

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

inline

Definition at line 80 of file recorder_export.cpp.

        : q(q_ptr)
        , ui(new Ui::RecorderExport)
        , settings(q_ptr->settings)
        , preprocessor(new RecorderExportPreprocessor(settings->inputDirectory, settings->format))
    {
    }

Member Function Documentation

applyVariables()

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

inline

Definition at line 346 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));
    }

References RecorderExportSettings::extendResult, RecorderFormatInfo::fileExtension(), RecorderExportSettings::firstFrameSec, RecorderExportSettings::format, RecorderExportSettings::fps, RecorderExportSettings::framesCount, RecorderExportSettings::h264Encoder, RecorderExportSettings::imageSize, RecorderExportSettings::inputDirectory, RecorderExportSettings::inputFps, RecorderExportSettings::lastFrameSec, RecorderExportSettings::resize, RecorderExportSettings::resultPreview, settings, and RecorderExportSettings::size.

checkExporter()

void RecorderExport::Private::checkExporter ( )

inline

Definition at line 89 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.

cleanupExporter()

void RecorderExport::Private::cleanupExporter ( )

inline

Definition at line 337 of file recorder_export.cpp.

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

References exporter.

desktopServicesOpenPath()

static void RecorderExport::Private::desktopServicesOpenPath ( const QString & path )

inlinestatic

Definition at line 455 of file recorder_export.cpp.

    {
#ifdef Q_OS_ANDROID
        // QDesktopServices doesn't clear exceptions
        KisAndroidUtils::clearJniException(QStringLiteral("before opening ") + path);
        QDesktopServices::openUrl(QUrl(path));
        KisAndroidUtils::clearJniException(QStringLiteral("after opening ") + path);
#else
        QDesktopServices::openUrl(QUrl::fromLocalFile(path));
#endif
    }

References KisAndroidUtils::clearJniException().

fillComboProfiles()

void RecorderExport::Private::fillComboProfiles ( )

inline

Definition at line 119 of file recorder_export.cpp.

    {
        int indexToSelect;
        {
            QSignalBlocker blocker(ui->comboProfile);
            ui->comboProfile->clear();
#ifdef Q_OS_ANDROID
            const QVector<KisMediaEncoderFormat *> formats = KisMediaEncoderWrapper::getSupportedFormats();
            int count = formats.size();
            if (count == 0) {
                return;
            }
 
            indexToSelect = -1;
            for (int i = 0, count = formats.size(); i < count; ++i) {
                QString key = formats[i]->key();
                ui->comboProfile->addItem(formats[i]->title(), QVariant(key));
                if (key == settings->selectedFormat) {
                    indexToSelect = i;
                }
            }
 
            if (indexToSelect == -1) {
                indexToSelect = 0;
                settings->selectedFormat = formats[0]->key();
            }
#else
            for (const RecorderProfile &profile : settings->profiles) {
                ui->comboProfile->addItem(profile.name);
            }
            indexToSelect = settings->profileIndex;
#endif
        }
        ui->comboProfile->setCurrentIndex(indexToSelect);
    }

References KisMediaEncoderWrapper::getSupportedFormats(), RecorderExportSettings::profileIndex, RecorderExportSettings::profiles, settings, and ui.

formatDuration()

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

inline

Definition at line 382 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;
    }

initDimensions()

void RecorderExport::Private::initDimensions ( )

inline

Definition at line 406 of file recorder_export.cpp.

    {
        // Video with dimensions above 1920 pixels isn't widely supported.
        // They often fail to encode with mysterious errors, can't be played
        // back properly and/or are rejected by websites where users attempt to
        // upload the videos. This caps the dimensions to avoid that trap.
        settings->resize = true;
        settings->lockRatio = true;
        if (settings->imageSize.isEmpty()) {
            settings->size = QSize(1024, 1024);
        } else {
            int iw = settings->imageSize.width();
            int ih = settings->imageSize.height();
            if (iw > DIMENSION_LIMIT || ih > DIMENSION_LIMIT) {
                int ow, oh;
                if (iw >= ih) {
                    ow = DIMENSION_LIMIT;
                    oh = qRound(qreal(DIMENSION_LIMIT) / qreal(iw) * qreal(ih));
                } else {
                    ow = qRound(qreal(DIMENSION_LIMIT) / qreal(ih) * qreal(iw));
                    oh = DIMENSION_LIMIT;
                }
                ow &= ~1;
                oh &= ~1;
                settings->size = QSize(ow, oh);
            } else {
                settings->size = settings->imageSize;
            }
        }
    }

References DIMENSION_LIMIT, RecorderExportSettings::imageSize, RecorderExportSettings::lockRatio, RecorderExportSettings::resize, settings, and RecorderExportSettings::size.

requestFile()

QString RecorderExport::Private::requestFile ( const QString & extension, const QString & defaultDir = QString() )

inline

Definition at line 444 of file recorder_export.cpp.

    {
        KoFileDialog dialog(q, KoFileDialog::SaveFile, "ExportTimelapse");
        dialog.setCaption(i18n("Export Timelapse Video As"));
        if (!defaultDir.isEmpty()) {
            dialog.setDefaultDir(defaultDir);
        }
        dialog.setMimeTypeFilters(QStringList(KisMimeDatabase::mimeTypeForSuffix(extension)));
        return dialog.filename();
    }

References KisMimeDatabase::mimeTypeForSuffix(), q, and KoFileDialog::SaveFile.

splitCommand()

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

inline

Definition at line 244 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 285 of file recorder_export.cpp.

    {
        Q_ASSERT(exporter == nullptr);
 
#ifndef Q_OS_ANDROID
        // The android export system is robust enough to not need this
        preprocessor->updateSettings(settings->inputDirectory, settings->format);
        preprocessor->doPreprocessing();
 
        // We don't do this again on Android, it's mind-bogglingly slow.
        updateFrameInfo();
#endif
 
        exporter.reset(new Exporter(q));
        QObject::connect(exporter.data(), SIGNAL(sigStarted()), q, SLOT(onExporterStarted()));
        QObject::connect(exporter.data(), SIGNAL(sigFinished()), q, SLOT(onExporterFinished()));
        QObject::connect(exporter.data(), SIGNAL(sigFinishedWithError(QString)), q, SLOT(onExporterFinishedWithError(QString)));
        QObject::connect(exporter.data(), SIGNAL(sigProgressUpdated(int)), q, SLOT(onExporterProgressUpdated(int)));
 
#ifdef Q_OS_ANDROID
        KisMediaEncoderWrapperSettings exporterSettings = {
            settings->videoFilePath,
            settings->inputFilePaths,
            QString(),
            KisMediaEncoderWrapper::getFormatByKey(settings->selectedFormat),
            settings->formatPreferences.value(settings->selectedFormat).toMap(),
            QString(),
            settings->resize ? settings->size : settings->imageSize,
            settings->inputFps,
            settings->fps,
            settings->firstFrameSec,
            settings->lastFrameSec,
            0,
        };
#else
        const RecorderProfile &profile = settings->profiles[settings->profileIndex];
        KisFFMpegWrapperSettings exporterSettings;
        exporterSettings.processPath = settings->ffmpegPath;
        exporterSettings.args = splitCommand(applyVariables(profile.arguments));
        exporterSettings.outputFile = settings->videoFilePath;
        exporterSettings.batchMode = true; //TODO: Consider renaming to 'silent' mode, meaning no window for extra window handling...
#endif
 
        ui->labelStatus->setText(i18nc("Status for the export of the video record", "Starting exporter..."));
        ui->buttonCancelExport->setEnabled(false);
        ui->progressExport->setValue(0);
        elapsedTimer.start();
 
        // Do this last, it may immediately emit a failure.
        exporter->startNonBlocking(exporterSettings);
    }

References applyVariables(), RecorderProfile::arguments, elapsedTimer, exporter, RecorderExportSettings::ffmpegPath, RecorderExportSettings::firstFrameSec, RecorderExportSettings::format, RecorderExportSettings::fps, KisMediaEncoderWrapper::getFormatByKey(), RecorderExportSettings::imageSize, RecorderExportSettings::inputDirectory, RecorderExportSettings::inputFps, RecorderExportSettings::lastFrameSec, RecorderExport::onExporterFinished(), RecorderExport::onExporterFinishedWithError(), RecorderExport::onExporterProgressUpdated(), RecorderExport::onExporterStarted(), KisMediaEncoderWrapperSettings::outputFile, preprocessor, RecorderExportSettings::profileIndex, RecorderExportSettings::profiles, q, RecorderExportSettings::resize, settings, RecorderExportSettings::size, splitCommand(), ui, updateFrameInfo(), and RecorderExportSettings::videoFilePath.

tryAbortExport()

bool RecorderExport::Private::tryAbortExport ( )

inline

Definition at line 229 of file recorder_export.cpp.

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

References cleanupExporter(), exporter, and q.

updateFps()

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

inline

Definition at line 212 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 155 of file recorder_export.cpp.

    {
        QDir dir(settings->inputDirectory, "*." % RecorderFormatInfo::fileExtension(settings->format),
                QDir::Name, QDir::Files | QDir::NoDotAndDotDot);
        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;
        }
#ifdef Q_OS_ANDROID
        // QDir::entryList is mind-bogglingly slow on Android, so we only load
        // this once and cache the result. Not like these are supposed to change
        // while this modal dialog is up anyway.
        settings->inputFilePaths.clear();
        settings->inputFilePaths.reserve(settings->framesCount);
        for (const QString &frame : frames) {
            settings->inputFilePaths.append(dir.filePath(frame));
        }
#endif
    }

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

updateRatio()

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

inline

Definition at line 195 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 367 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 180 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.

updateWarningVisibility()

void RecorderExport::Private::updateWarningVisibility ( )

inline

Definition at line 437 of file recorder_export.cpp.

    {
        ui->wdgWarnFps->setVisible(settings->fps > 30);
        QSize size = settings->resize ? settings->size : settings->imageSize;
        ui->wdgWarnSize->setVisible(size.width() > DIMENSION_LIMIT || size.height() > DIMENSION_LIMIT);
    }

References DIMENSION_LIMIT, RecorderExportSettings::fps, RecorderExportSettings::imageSize, RecorderExportSettings::resize, settings, RecorderExportSettings::size, and ui.

Member Data Documentation

cleaner

RecorderDirectoryCleaner* RecorderExport::Private::cleaner = nullptr

Definition at line 73 of file recorder_export.cpp.

DIMENSION_LIMIT

constexpr int RecorderExport::Private::DIMENSION_LIMIT = 1920

staticconstexpr

Definition at line 65 of file recorder_export.cpp.

elapsedTimer

QElapsedTimer RecorderExport::Private::elapsedTimer

Definition at line 75 of file recorder_export.cpp.

exporter

QScopedPointer<Exporter> RecorderExport::Private::exporter

Definition at line 72 of file recorder_export.cpp.

preprocessor

QScopedPointer<RecorderExportPreprocessor> RecorderExport::Private::preprocessor

Definition at line 71 of file recorder_export.cpp.

q

RecorderExport* RecorderExport::Private::q

Definition at line 67 of file recorder_export.cpp.

settings

RecorderExportSettings* RecorderExport::Private::settings

Definition at line 69 of file recorder_export.cpp.

spinInputFPSMaxValue

int RecorderExport::Private::spinInputFPSMaxValue = 0

Definition at line 78 of file recorder_export.cpp.

spinInputFPSMinValue

int RecorderExport::Private::spinInputFPSMinValue = 0

Definition at line 77 of file recorder_export.cpp.

ui

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

Definition at line 68 of file recorder_export.cpp.

---

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

• plugins/dockers/recorder/recorder_export.cpp