KisFFMpegWrapper Class Reference

#include <KisFFMpegWrapper.h>

Inheritance diagram for KisFFMpegWrapper:

Signals
void	sigFinished ()
void	sigFinishedWithError (QString message)
void	sigProgressUpdated (int frameNo)
void	sigReadLine (int pipe, QString line)
void	sigReadSTDERR (QByteArray stderrBuffer)
void	sigReadSTDOUT (QByteArray stdoutBuffer)
void	sigStarted ()

Public Member Functions
QJsonObject	ffmpegProbe (const QString &inputFile, const QString &ffmpegPath, bool batchMode)
QJsonObject	ffprobe (const QString &inputFile, const QString &ffprobePath)
	KisFFMpegWrapper (QObject *parent=nullptr)
void	reset ()
KisImportExportErrorCode	start (const KisFFMpegWrapperSettings &settings)
void	startNonBlocking (const KisFFMpegWrapperSettings &settings)
bool	waitForFinished (int msecs=FFMPEG_TIMEOUT)
	~KisFFMpegWrapper ()

Static Public Member Functions
static ColorPrimaries	colorPrimariesFromName (QString name)
static QString	configuredFFMpegLocation ()
static QJsonObject	findFFMpeg (const QString &customLocation)
static QJsonObject	findFFProbe (const QString &customLocation)
static QJsonObject	findProcessInfo (const QString &processName, const QString &processPath, bool includeProcessInfo)
static QJsonObject	findProcessPath (const QString &processName, const QString &customLocation, bool processInfo)
static QStringList	getSupportedCodecs (const QJsonObject &ffmpegJsonProcessInput)
static QByteArray	runProcessAndReturn (const QString &processPath, const QStringList &args, int msecs=FFMPEG_TIMEOUT)
static void	setConfiguredFFMpegLocation (QString &location)
static TransferCharacteristics	transferCharacteristicsFromName (QString name)

Private Slots
void	slotFinished (int exitCode)
void	slotReadyReadSTDERR ()
void	slotReadyReadSTDOUT ()
void	slotStarted ()

Private Member Functions
bool	ffprobeCheckStreamsValid (const QJsonObject &ffprobeJsonObj, const QString &ffprobeSTDERR)
	ffprobeCheckStreamsValid
void	updateProgressDialog (int progressValue)

Static Private Member Functions
static void	fixUpNonEmbeddedProcessEnvironment (const QString &processPath, QProcess &process)

Private Attributes
QString	m_errorMessage
QScopedPointer< QProcess >	m_process
KisFFMpegWrapperSettings	m_processSettings
QString	m_processSTDERR
QByteArray	m_processSTDOUT
QSharedPointer< QProgressDialog >	m_progress = nullptr
QString	m_stderrBuffer
QString	m_stdoutBuffer

Detailed Description

Definition at line 46 of file KisFFMpegWrapper.h.

Constructor & Destructor Documentation

KisFFMpegWrapper()

KisFFMpegWrapper::KisFFMpegWrapper ( QObject * parent = nullptr )

explicit

Definition at line 36 of file KisFFMpegWrapper.cpp.

    : QObject(parent)
{
}

~KisFFMpegWrapper()

KisFFMpegWrapper::~KisFFMpegWrapper

(

)

Definition at line 41 of file KisFFMpegWrapper.cpp.

{
}

Member Function Documentation

colorPrimariesFromName()

ColorPrimaries KisFFMpegWrapper::colorPrimariesFromName ( QString name )

static

Definition at line 787 of file KisFFMpegWrapper.cpp.

{
    if (name == "bt709") {
        return PRIMARIES_ITU_R_BT_709_5;
    }
    if (name == "bt470m") {
        return PRIMARIES_ITU_R_BT_470_6_SYSTEM_M;
    }
    if (name == "bt470bg") {
        return PRIMARIES_ITU_R_BT_470_6_SYSTEM_B_G;
    }
    if (name == "smpte170m") {
        return PRIMARIES_ITU_R_BT_601_6;
    }
    if (name == "smpte240m") {
        return PRIMARIES_SMPTE_240M;
    }
    if (name == "film") {
        return PRIMARIES_GENERIC_FILM;
    }
    if (name == "bt2020") {
        return PRIMARIES_ITU_R_BT_2020_2_AND_2100_0;
    }
    if (name.startsWith("smpte428")) {
        return PRIMARIES_SMPTE_ST_428_1;
    }
    if (name == "smpte431") {
        return PRIMARIES_SMPTE_RP_431_2;
    }
    if (name == "smpte432") {
        return PRIMARIES_SMPTE_EG_432_1;
    }
    if (name == "jedec-p22") {
        return PRIMARIES_EBU_Tech_3213_E;
    }
 
    return PRIMARIES_UNSPECIFIED;
}

References PRIMARIES_EBU_Tech_3213_E, PRIMARIES_GENERIC_FILM, PRIMARIES_ITU_R_BT_2020_2_AND_2100_0, PRIMARIES_ITU_R_BT_470_6_SYSTEM_B_G, PRIMARIES_ITU_R_BT_470_6_SYSTEM_M, PRIMARIES_ITU_R_BT_601_6, PRIMARIES_ITU_R_BT_709_5, PRIMARIES_SMPTE_240M, PRIMARIES_SMPTE_EG_432_1, PRIMARIES_SMPTE_RP_431_2, PRIMARIES_SMPTE_ST_428_1, and PRIMARIES_UNSPECIFIED.

configuredFFMpegLocation()

QString KisFFMpegWrapper::configuredFFMpegLocation ( )

static

Definition at line 433 of file KisFFMpegWrapper.cpp.

{
    KisConfig cfg(true);
    return cfg.ffmpegLocation();
}

References KisConfig::ffmpegLocation().

ffmpegProbe()

QJsonObject KisFFMpegWrapper::ffmpegProbe	(	const QString &	inputFile,
		const QString &	ffmpegPath,
		bool	batchMode )

Definition at line 686 of file KisFFMpegWrapper.cpp.

{
    struct KisFFMpegWrapperSettings ffmpegSettings;
     
    ffmpegSettings.processPath = ffmpegPath;
    ffmpegSettings.storeOutput = true;
    ffmpegSettings.progressMessage = i18nc("Video information probing dialog. arg1: frame number.", "Loading video data... %1 frames examined.", "[progress]");
    ffmpegSettings.batchMode = batchMode;
 
    ffmpegSettings.args << "-stats"
                        << "-v" << "info" 
                        << "-progress" << "pipe:1" 
                        << "-map" << "0:v:0"
                        << "-c" << "copy"
                        << "-f" << "null" << "pipe:1"
                        << "-i" << inputFile;
                        
 
    this->startNonBlocking(ffmpegSettings);
    this->waitForFinished();
 
    
    QString ffmpegSTDOUT = m_processSTDERR + "\n" + m_processSTDOUT;
    
    dbgFile << "ffmpegProbe stdout:" << ffmpegSTDOUT;
 
    QJsonObject ffmpegJsonObj;
    QJsonArray ffmpegStreamsJsonArr;
    QJsonObject ffmpegFormatJsonObj;
    QJsonObject ffmpegProgressJsonObj;
    
    QStringList stdoutLines = ffmpegSTDOUT.split('\n');
    
    ffmpegJsonObj["error"] = FFProbeErrorCodes::UNSUPPORTED_CODEC;
    
    for (const QString &line : stdoutLines) {
        dbgFile << "ffmpeg probe stdout" << line;
        QRegularExpression videoInfoInputRX("Duration: (\\d+):(\\d+):([\\d\\.]+),");
        QRegularExpressionMatch durationMatch = videoInfoInputRX.match(line);
 
        if (ffmpegFormatJsonObj.value("duration").isUndefined() && durationMatch.hasMatch()) {
            ffmpegFormatJsonObj["duration"] = QString::number( (durationMatch.captured(1).toInt() * 60 * 60)
                                                             + (durationMatch.captured(2).toInt() * 60) 
                                                             + durationMatch.captured(3).toFloat()
                                                             );
        } else {
            QRegularExpression videoInfoStreamRX(
                QString("Stream #(\\d+):(\\d+)(?:[ ]*?\\((\\w+)\\)|): Video: (\\w+?)(?:[ ]*?\\((.+?)\\)|),[ ]*?")
                        .append("(\\w+?)(?:[ ]*?\\((.+?)\\)|),[ ]*?")
                        .append("(\\d+)x(\\d+)([ ]*?\\[.+?\\]|.*?),[ ]*?")
                        .append("(?:([\\d\\.]+) fps,|) (\\S+?) tbr, (.+?) tbn, (.+?) tbc")
            );
            
            QRegularExpressionMatch streamMatch = videoInfoStreamRX.match(line);
            
            if (streamMatch.hasMatch() && ffmpegStreamsJsonArr[streamMatch.captured(1).toInt()].isUndefined() ) {
                int index = streamMatch.captured(1).toInt();
                QJsonObject ffmpegJsonOnStreamObj;
                
                ffmpegJsonOnStreamObj["index"] = index;
                ffmpegJsonOnStreamObj["codec_name"] = streamMatch.captured(4);
                ffmpegJsonOnStreamObj["profile"] = streamMatch.captured(5);
                ffmpegJsonOnStreamObj["pix_fmt"] = streamMatch.captured(6);
                ffmpegJsonOnStreamObj["width"] = streamMatch.captured(8).toInt();
                ffmpegJsonOnStreamObj["height"] = streamMatch.captured(9).toInt();
                
                ffmpegJsonOnStreamObj["codec_type"] = "video";
                
                if (streamMatch.captured(11).toFloat() > 0) {
                    float fps = streamMatch.captured(11).toFloat();
 
                    ffmpegProgressJsonObj["ffmpeg_fps"] = QString::number(fps);
                    ffmpegJsonOnStreamObj["r_frame_rate"] = QString::number( fps * 10000 ).append(QString("/10000"));
                } else {
                    ffmpegProgressJsonObj["ffmpeg_fps"] = 0;
                }
 
                ffmpegJsonObj["error"] = FFProbeErrorCodes::NONE;
                
                dbgFile << "ffmpegProbe stream:" << ffmpegJsonOnStreamObj;
                
                ffmpegStreamsJsonArr.insert(index, ffmpegJsonOnStreamObj);
                
            } else {
                
                QRegularExpression videoInfoFrameRX("^(\\w+?)=([\\w\\./:]+?)$");
                QRegularExpressionMatch frameMatch = videoInfoFrameRX.match(line);
 
                if (frameMatch.hasMatch()) ffmpegProgressJsonObj[frameMatch.captured(1)] = frameMatch.captured(2);
    
            }
        }
    }
    
    ffmpegJsonObj.insert("streams",ffmpegStreamsJsonArr);
    ffmpegJsonObj.insert("format",ffmpegFormatJsonObj);
    ffmpegJsonObj.insert("progress",ffmpegProgressJsonObj);
    
    return ffmpegJsonObj;
}

References KisFFMpegWrapperSettings::args, KisFFMpegWrapperSettings::batchMode, dbgFile, m_processSTDERR, m_processSTDOUT, NONE, KisFFMpegWrapperSettings::processPath, KisFFMpegWrapperSettings::progressMessage, startNonBlocking(), KisFFMpegWrapperSettings::storeOutput, UNSUPPORTED_CODEC, and waitForFinished().

ffprobe()

QJsonObject KisFFMpegWrapper::ffprobe	(	const QString &	inputFile,
		const QString &	ffprobePath )

Definition at line 649 of file KisFFMpegWrapper.cpp.

{
    struct KisFFMpegWrapperSettings ffprobeSettings;
     
    ffprobeSettings.processPath = ffprobePath;
    ffprobeSettings.storeOutput = true;
    ffprobeSettings.defaultPrependArgs.clear();
    
    ffprobeSettings.args << "-hide_banner" 
                         << "-v" << "warning" 
                         << "-of" << "json=compact=1" 
                         << "-show_format" 
                         << "-show_streams" 
                         << "-i" << inputFile;
    startNonBlocking(ffprobeSettings);
    waitForFinished();
    
    QString ffprobeSTDOUT = m_processSTDOUT;
    QString ffprobeSTDERR = m_processSTDERR;
     
    QJsonDocument ffprobeJsonDoc = QJsonDocument::fromJson(ffprobeSTDOUT.toUtf8());
    QJsonObject ffprobeJsonObj;
 
    if (ffprobeJsonDoc.isNull() || !ffprobeJsonDoc.isObject()) {
        ffprobeJsonObj["error"] = FFProbeErrorCodes::INVALID_JSON;
        return ffprobeJsonObj;
    }
 
    ffprobeJsonObj = ffprobeJsonDoc.object();
 
    const bool hasValidStreams = ffprobeCheckStreamsValid(ffprobeJsonObj, ffprobeSTDERR);
    ffprobeJsonObj["error"] = hasValidStreams ? FFProbeErrorCodes::NONE : FFProbeErrorCodes::UNSUPPORTED_CODEC;
 
    
    return ffprobeJsonObj;
}

References KisFFMpegWrapperSettings::args, KisFFMpegWrapperSettings::defaultPrependArgs, ffprobeCheckStreamsValid(), INVALID_JSON, m_processSTDERR, m_processSTDOUT, NONE, KisFFMpegWrapperSettings::processPath, startNonBlocking(), KisFFMpegWrapperSettings::storeOutput, UNSUPPORTED_CODEC, and waitForFinished().

ffprobeCheckStreamsValid()

bool KisFFMpegWrapper::ffprobeCheckStreamsValid ( const QJsonObject & ffprobeJsonObj, const QString & ffprobeSTDERR )

private

ffprobeCheckStreamsValid

Parameters

ffprobeJsonObj	JsonObject resulting from ffprobe process.
ffprobeSTDERR	STDERR output from ffprobe.

Returns

bool -> Whether we support a video format based on it's internal streams.

Definition at line 228 of file KisFFMpegWrapper.cpp.

{
    // Sanity checks..
    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(ffprobeJsonObj.contains("streams"), false);
 
    QRegularExpression invalidStreamRX("(?:Unsupported codec with id .+? for input stream|Could not find codec parameters for stream) ([0-9]+)");
    QRegularExpressionMatchIterator invalidStreamMatchList = invalidStreamRX.globalMatch(ffprobeSTDERR);
 
    while (invalidStreamMatchList.hasNext()) {
        QRegularExpressionMatch invalidStreamMatch = invalidStreamMatchList.next();
 
        if (invalidStreamMatch.hasMatch()) {
            const int invalidStreamId = invalidStreamMatch.captured(1).toInt();
 
            // We make sure we're talking about video streams here.
            if (ffprobeJsonObj["streams"].toArray()[invalidStreamId].toObject()["codec_type"] == "video") {
                return false;
            }
        }
    }
 
    return true;
}

References KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE.

findFFMpeg()

QJsonObject KisFFMpegWrapper::findFFMpeg ( const QString & customLocation )

static

Definition at line 639 of file KisFFMpegWrapper.cpp.

{
    return findProcessPath("ffmpeg", customLocation, true);
}

References findProcessPath().

findFFProbe()

QJsonObject KisFFMpegWrapper::findFFProbe ( const QString & customLocation )

static

Definition at line 644 of file KisFFMpegWrapper.cpp.

{
    return findProcessPath("ffprobe", customLocation, false);
}

References findProcessPath().

findProcessInfo()

QJsonObject KisFFMpegWrapper::findProcessInfo ( const QString & processName, const QString & processPath, bool includeProcessInfo )

static

Definition at line 518 of file KisFFMpegWrapper.cpp.

{
 
    QJsonObject ffmpegInfo {{"path", rawProcessPath},
                            {"enabled",false},
                            {"version", "0"},
                            {"encoder",QJsonValue::Object},
                            {"decoder",QJsonValue::Object}};
                            
    if (!QFile::exists(rawProcessPath)) return ffmpegInfo;
 
    const QString processPath = QFileInfo(rawProcessPath).absoluteFilePath();
    ffmpegInfo["path"] = processPath;
    
    dbgFile << "Found process at:" << processPath;    
    QString processVersion = KisFFMpegWrapper::runProcessAndReturn(processPath, QStringList() << "-version", FFMPEG_TIMEOUT);
 
    if (!processVersion.isEmpty()) {
        
        QRegularExpressionMatch versionMatch = ffmpegVersionRX.match(processVersion);
        
        if (versionMatch.hasMatch() && versionMatch.captured(1) == processName ) {
            ffmpegInfo["version"] = versionMatch.captured(2);
            dbgFile << "found version" << ffmpegInfo.value("version").toString();
            ffmpegInfo["enabled"] = true;
        }
        
        if (!includeProcessInfo || !ffmpegInfo["enabled"].toBool()) return ffmpegInfo;
        
        QString processCodecs = KisFFMpegWrapper::runProcessAndReturn(processPath, QStringList() << "-codecs", FFMPEG_TIMEOUT);
 
        QJsonObject codecsJson {};
        
        {
            // For regular expression advice, check out https://regexr.com/.
            // Beware: We need double backslashes here for C++, in regular regex it would be a single backslash instead.
            QRegularExpression ffmpegCodecsRX("(D|\\.)(E|\\.)....\\s+(.+?)\\s+([^\\r\\n]*)");
            QRegularExpressionMatchIterator codecsMatchList = ffmpegCodecsRX.globalMatch(processCodecs);
            
            // Find out codec types.. (e.g. H264, VP9, etc)
            while (codecsMatchList.hasNext()) {
                QRegularExpressionMatch codecsMatch = codecsMatchList.next();
 
                if (codecsMatch.hasMatch()) {
                    QJsonObject codecInfoJson {};
                    
                    bool encodingSupported = codecsMatch.captured(2) == "E" ? true:false;
                    bool decodingSupported = codecsMatch.captured(1) == "D" ? true:false;
                    QString codecName = codecsMatch.captured(3);
                    QString codecRemainder = codecsMatch.captured(4); 
 
                    codecInfoJson.insert("encoding", encodingSupported);
                    codecInfoJson.insert("decoding", decodingSupported);
 
 
                    // Regular expression for grouping specific encoders and decoders..
                    QRegularExpression ffmpegSpecificCodecRX("\\(decoders:(.+?)\\)|\\(encoders:(.+?)\\)");
                    QRegularExpressionMatchIterator specificCodecMatchList = ffmpegSpecificCodecRX.globalMatch(codecRemainder);
 
                    QJsonArray encodersList;
                    QJsonArray decodersList;
 
                    while (specificCodecMatchList.hasNext()) {
                        QRegularExpressionMatch specificCodecMatch = specificCodecMatchList.next();
                        if (specificCodecMatch.hasMatch()) {
                            // Add specific decoders..
                            QStringList decoders = specificCodecMatch.captured(1).split(" ");
                            Q_FOREACH(const QString& string, decoders) {
                                if (!string.isEmpty()) {
                                    decodersList.push_back(string);
                                }
                            }
 
                            // Add specific encoders.. (e.g. for h264: h264_vaapi, libopenh264, etc )
                            QStringList encoders = specificCodecMatch.captured(2).split(" ");
                            Q_FOREACH(const QString& string, encoders) {
                                if (!string.isEmpty()) {
                                    encodersList.push_back(string);
                                }
                            }
                        }
                    }
                    
                    codecInfoJson.insert("encoders", encodersList);
                    codecInfoJson.insert("decoders", decodersList);
                    codecsJson.insert(codecName, codecInfoJson);
                }
            }
        }
 
        ffmpegInfo.insert("codecs", codecsJson);
        
            
        dbgFile << "codec support:" << ffmpegInfo; 
    } else {
        dbgFile << "Not a valid process at:" << processPath;
    }
    
    return ffmpegInfo;
    
}

References dbgFile, FFMPEG_TIMEOUT, and runProcessAndReturn().

findProcessPath()

QJsonObject KisFFMpegWrapper::findProcessPath ( const QString & processName, const QString & customLocation, bool processInfo )

static

Definition at line 445 of file KisFFMpegWrapper.cpp.

{
    QJsonObject resultJsonObj;
    QStringList proposedPaths;
 
    // User-specified..
    if (!customLocation.isEmpty()) {
        proposedPaths << customLocation;
        proposedPaths << customLocation + '/' + processName;
    }
 
    // Krita-bundled..
    proposedPaths << KoResourcePaths::getApplicationRoot() + '/' + "bin" + '/' + processName;
 
    // OS-specific..
#ifdef Q_OS_WIN
    // Look for winget-installed ffmpeg packages in C:\users\USERNAME\appdata\local\microsoft\winget\packages\FFMPEGVERSION\bin
    QDir wingetPackageDir = QDir(QDir::homePath() + "/AppData/Local/Microsoft/WinGet/Packages/");
    QStringList wingetPackageFolderNames = wingetPackageDir.entryList();
    for (const auto &folderName : wingetPackageFolderNames) {
        if (folderName.contains("ffmpeg", Qt::CaseInsensitive)) {
            QDir ffmpegPackageFolder = QDir(wingetPackageDir.path() + "/" + folderName);
            QStringList ffmpegRootNames = ffmpegPackageFolder.entryList();
            for (const auto &ffmpegRootName : ffmpegRootNames) {
                proposedPaths << ffmpegPackageFolder.path() + "/" + ffmpegRootName + "/bin/";
            }
        }
    }
#endif
 
#ifdef Q_OS_MACOS
    proposedPaths << QCoreApplication::applicationDirPath() + '/' + processName;
#endif
 
#ifndef Q_OS_WIN
    proposedPaths << QDir::homePath() + "/bin/" + processName;
    proposedPaths << "/usr/bin/" + processName;
    proposedPaths << "/usr/local/bin/" + processName;
#endif
 
    dbgFile << proposedPaths;
    for (int i = 0; i != proposedPaths.size(); ++i) {
        if (proposedPaths[i].isEmpty()) continue;
 
#ifdef Q_OS_WIN
        proposedPaths[i] = QDir::toNativeSeparators(QDir::cleanPath(proposedPaths[i]));
 
        if (proposedPaths[i].endsWith('/')) {
            continue;
        }
 
        if (!proposedPaths[i].endsWith(".exe", Qt::CaseInsensitive)) {
            if (!QFile::exists(proposedPaths[i])) {
                proposedPaths[i] += ".exe";
                if (!QFile::exists(proposedPaths[i])) {
                    continue;
                }
            }
        }
#endif
 
        QJsonObject processInfoJsonObj = findProcessInfo(processName, proposedPaths[i], includeProcessInfo);
        dbgFile << "PATH" << proposedPaths[i] << processInfoJsonObj.value("enabled").toBool();
        if (processInfoJsonObj.value("enabled").toBool()) {
            processInfoJsonObj["custom"]=(!customLocation.isEmpty() && i <= 1) ? true:false;
            resultJsonObj = processInfoJsonObj;
            break;
        }        
    }
 
    return resultJsonObj;
}

References dbgFile, findProcessInfo(), and KoResourcePaths::getApplicationRoot().

fixUpNonEmbeddedProcessEnvironment()

void KisFFMpegWrapper::fixUpNonEmbeddedProcessEnvironment ( const QString & processPath, QProcess & process )

staticprivate

Definition at line 368 of file KisFFMpegWrapper.cpp.

{
#ifdef Q_OS_LINUX
 
    QProcessEnvironment env = QProcessEnvironment::systemEnvironment();
 
    const QStringList libraryPaths = env.value("LD_LIBRARY_PATH").split(':');
    const QString processAbsPath = QFileInfo(QFileInfo(processPath).absolutePath() + "/../").absoluteFilePath();
 
    bool isCustomBuildOfFFmpeg = false;
 
    Q_FOREACH (const QString &path, libraryPaths) {
        const QString absPath1 = QFileInfo(path + "/").absoluteFilePath();
        const QString absPath2 = QFileInfo(path + "/../").absoluteFilePath();
 
        if (absPath1 == processAbsPath || absPath2 == processAbsPath) {
            dbgFile << "Detected embedded ffmpeg:" << processPath;
            dbgFile << "    " << ppVar(processAbsPath);
            dbgFile << "    " << ppVar(absPath1);
            dbgFile << "    " << ppVar(absPath2);
 
            isCustomBuildOfFFmpeg = true;
 
            break;
        }
    }
 
    if (!isCustomBuildOfFFmpeg) {
        dbgFile << "Removing LD_LIBRARY_PATH for running" << processPath;
 
        env.remove("LD_LIBRARY_PATH");
        process.setProcessEnvironment(env);
    }
#endif /* Q_OS_LINUX */
}

References dbgFile, and ppVar.

getSupportedCodecs()

QStringList KisFFMpegWrapper::getSupportedCodecs ( const QJsonObject & ffmpegJsonProcessInput )

static

Definition at line 620 of file KisFFMpegWrapper.cpp.

                                                                                     {
    // TODO: I really don't like having to deal with JSON in C++ code as frequently as we are here.
    // We should make a proper datatype for FFMPEG Process Information!
    
    QStringList encodersToReturn = {};
    
    // For now, I'm just treating this as strictly typed using KIS_SAFE_ASSERT_RECOVER_RETURN
    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(ffmpegProcessInfo["enabled"].toBool(), encodersToReturn);
 
    QJsonObject encoders = ffmpegProcessInfo["codecs"].toObject();
    Q_FOREACH( const QString& key, encoders.keys()) {
        if (encoders[key].toObject()["encoding"].toBool()) {
            encodersToReturn << key;
        }
    }
 
    return encodersToReturn;
}

References KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE.

reset()

void KisFFMpegWrapper::reset

(

)

Definition at line 252 of file KisFFMpegWrapper.cpp.

{
    if (m_process == nullptr)
        return;
 
    m_process->disconnect(this);
    if (m_process->state() != QProcess::NotRunning) {
        m_process->kill();
    }
    m_process.reset();
}

References m_process.

runProcessAndReturn()

QByteArray KisFFMpegWrapper::runProcessAndReturn ( const QString & processPath, const QStringList & args, int msecs = FFMPEG_TIMEOUT )

static

Definition at line 412 of file KisFFMpegWrapper.cpp.

{
    QProcess runProcess;
    
    fixUpNonEmbeddedProcessEnvironment(processPath, runProcess);
    
    runProcess.start(processPath, args);
    
    if (runProcess.waitForStarted(msecs)) runProcess.waitForFinished(msecs);
 
    const bool successfulStart =
        runProcess.state() == QProcess::NotRunning &&
        runProcess.error() == QProcess::UnknownError;
 
    dbgFile << "runProcessAndReturn Success:" << successfulStart;
    
    if (successfulStart) return runProcess.readAllStandardOutput();
 
    return "";
}

References dbgFile, and fixUpNonEmbeddedProcessEnvironment().

setConfiguredFFMpegLocation()

void KisFFMpegWrapper::setConfiguredFFMpegLocation ( QString & location )

static

Definition at line 439 of file KisFFMpegWrapper.cpp.

{
    KisConfig cfg(false);
    cfg.setFFMpegLocation(location);
}

References KisConfig::setFFMpegLocation().

sigFinished

void KisFFMpegWrapper::sigFinished ( )

signal

sigFinishedWithError

void KisFFMpegWrapper::sigFinishedWithError ( QString message )

signal

sigProgressUpdated

void KisFFMpegWrapper::sigProgressUpdated ( int frameNo )

signal

sigReadLine

void KisFFMpegWrapper::sigReadLine ( int pipe, QString line )

signal

sigReadSTDERR

void KisFFMpegWrapper::sigReadSTDERR ( QByteArray stderrBuffer )

signal

sigReadSTDOUT

void KisFFMpegWrapper::sigReadSTDOUT ( QByteArray stdoutBuffer )

signal

sigStarted

void KisFFMpegWrapper::sigStarted ( )

signal

slotFinished

void KisFFMpegWrapper::slotFinished ( int exitCode )

privateslot

Definition at line 349 of file KisFFMpegWrapper.cpp.

{
    dbgFile << "FFMpeg finished with code" << exitCode;
    if (!m_processSettings.batchMode && m_progress){
        m_progress->setValue(100);
    }
    
    if (exitCode != 0) {
        m_errorMessage.remove(junkRegex);
        if (m_process->exitStatus() == QProcess::CrashExit) {
            m_errorMessage = i18n("FFMpeg Crashed") % "\n" % m_errorMessage;
        }
 
        Q_EMIT sigFinishedWithError(m_errorMessage);
    } else {
        Q_EMIT sigFinished();
    }
}

References KisFFMpegWrapperSettings::batchMode, dbgFile, m_errorMessage, m_process, m_processSettings, m_progress, sigFinished(), and sigFinishedWithError().

slotReadyReadSTDERR

void KisFFMpegWrapper::slotReadyReadSTDERR ( )

privateslot

Definition at line 264 of file KisFFMpegWrapper.cpp.

{
    QByteArray stderrRawBuffer = m_process->readAllStandardError();
    
    Q_EMIT sigReadSTDERR(stderrRawBuffer);
    m_stderrBuffer += stderrRawBuffer;
    
    int frameNo = -1;
    int startPos = 0;
    int endPos = 0;
    
    while ((endPos = m_stderrBuffer.indexOf(lineDelimiter, startPos)) != -1) {
        const QString &line = m_stderrBuffer.mid(startPos, endPos - startPos).trimmed();
 
        if (m_processSettings.storeOutput) m_processSTDERR += line + "\n";
                
        Q_EMIT sigReadLine(2,line);
        
        for (const QString &word : errorWords) {
            if (line.contains(word)) {
                m_errorMessage += line % "\n";
                break;
            }
        }
        
        const QRegularExpressionMatch &match = frameRegexp.match(line);
        
        if (match.hasMatch()) {
            frameNo = match.captured(1).toInt();
        }
 
 
        dbgFile << "ffmpeg stderr:" << line;
        startPos = endPos + 1;
    }
 
    m_stderrBuffer.remove(0, startPos);
    
    if (frameNo != -1) {
        updateProgressDialog(frameNo);
        Q_EMIT sigProgressUpdated(frameNo);
    }
    
}

References dbgFile, m_errorMessage, m_process, m_processSettings, m_processSTDERR, m_stderrBuffer, sigProgressUpdated(), sigReadLine(), sigReadSTDERR(), KisFFMpegWrapperSettings::storeOutput, and updateProgressDialog().

slotReadyReadSTDOUT

void KisFFMpegWrapper::slotReadyReadSTDOUT ( )

privateslot

Definition at line 309 of file KisFFMpegWrapper.cpp.

{
    QByteArray stdoutRawBuffer = m_process->readAllStandardOutput();
    
    Q_EMIT sigReadSTDOUT(stdoutRawBuffer);
    m_stdoutBuffer += stdoutRawBuffer;
 
  
    if (m_processSettings.binaryOutput) {
        if (m_processSettings.storeOutput) m_processSTDOUT += stdoutRawBuffer;
    } else {
        
        int startPos = 0;
        int endPos = 0;
        QString str;
        
        if (m_processSettings.storeOutput) m_processSTDOUT += stdoutRawBuffer + "\n";
        
        // ffmpeg splits normal lines by '\n' and progress data lines by '\r'
        while ((endPos = m_stdoutBuffer.indexOf(lineDelimiter, startPos)) != -1) {
            const QString &line = m_stdoutBuffer.mid(startPos, endPos - startPos).trimmed();
 
            dbgFile << "ffmpeg stdout:" << line;
            Q_EMIT sigReadLine(1,line);
            startPos = endPos + 1;
        }
        
        m_stdoutBuffer.remove(0, startPos);
    }
 
    
}

References KisFFMpegWrapperSettings::binaryOutput, dbgFile, m_process, m_processSettings, m_processSTDOUT, m_stdoutBuffer, sigReadLine(), sigReadSTDOUT(), and KisFFMpegWrapperSettings::storeOutput.

slotStarted

void KisFFMpegWrapper::slotStarted ( )

privateslot

Definition at line 342 of file KisFFMpegWrapper.cpp.

{
    dbgFile << "ffmpeg process started!";
 
    Q_EMIT sigStarted();
}

References dbgFile, and sigStarted().

start()

KisImportExportErrorCode KisFFMpegWrapper::start

(

const KisFFMpegWrapperSettings &

settings

)

Definition at line 162 of file KisFFMpegWrapper.cpp.

{
    struct ProcessResults {
        bool finish = false;
        QString error = QString();
    };
 
    QSharedPointer<ProcessResults> processResults = toQShared(new ProcessResults);
 
    connect( this, &KisFFMpegWrapper::sigFinishedWithError, [processResults](const QString& errMsg){
        processResults->finish = true;
        processResults->error = errMsg;
    });
 
    connect( this, &KisFFMpegWrapper::sigFinished, [processResults](){
       processResults->finish = true;
    });
 
    startNonBlocking(settings);
    waitForFinished(FFMPEG_TIMEOUT);
 
    if (processResults->finish == true) {
        if (processResults->error.isEmpty()) {
            return ImportExportCodes::OK;
        } else {
            return ImportExportCodes::Failure;
        }
    } else {
        reset(); // Ensure process isn't running before returning failure here.
        return ImportExportCodes::Failure;
    }
}

References connect(), ImportExportCodes::Failure, FFMPEG_TIMEOUT, ImportExportCodes::OK, reset(), sigFinished(), sigFinishedWithError(), startNonBlocking(), toQShared(), and waitForFinished().

startNonBlocking()

void KisFFMpegWrapper::startNonBlocking

(

const KisFFMpegWrapperSettings &

settings

)

Definition at line 46 of file KisFFMpegWrapper.cpp.

{
    KIS_ASSERT(m_process == nullptr);
 
    m_stdoutBuffer.clear();
    m_errorMessage.clear();
    m_processSTDOUT.clear();
    m_processSTDERR.clear();
 
    m_process.reset(new QProcess(this));
    QStringList env(m_process->systemEnvironment());
 
    m_processSettings = settings;
 
    const QString renderLogPath = m_processSettings.outputFile + ".log";
 
    // Create a new log per each ffmpeg operation..
    if (QFile::exists(renderLogPath)) {
        QFile existingFile(renderLogPath);
        existingFile.remove();
    }
 
    QFile renderLog(renderLogPath); // Logs ONLY this render operation.
 
    // Log ffmpeg command info..
    if (renderLog.open(QIODevice::WriteOnly | QIODevice::Truncate)) {
        QString command = m_processSettings.processPath + " " + settings.defaultPrependArgs.join(" ") + " " + m_processSettings.args.join(" ") + " " + m_processSettings.outputFile;
        renderLog.write(command.toUtf8());
        renderLog.write("\n");
        renderLog.write("=====================================================\n");
 
        // Handle logged errors..
        // Due to various reasons (including image preview), ffmpeg uses STDERR and not STDOUT for general output logging.
        connect(this, &KisFFMpegWrapper::sigReadSTDERR, [renderLogPath](QByteArray stderrBuffer){
            QFile renderLog(renderLogPath);
            if (renderLog.open(QIODevice::WriteOnly | QIODevice::Append)) {
                renderLog.write(stderrBuffer);
            }
        });
    }
 
    if (!settings.logPath.isEmpty()) {
        QString sessionRenderLogPath(settings.logPath);
        // Logs FULL history of Krita session render operations.
        QFile sessionRenderLog(sessionRenderLogPath);
 
        // Make directory..
        const QString logDirPath = QFileInfo(sessionRenderLogPath).dir().path();
        QDir().mkpath(logDirPath);
 
        if (sessionRenderLog.open(QIODevice::WriteOnly | QIODevice::Append)) {
            // Append finished renderlog to sessionlog..
            connect(this, &KisFFMpegWrapper::sigFinishedWithError, [renderLogPath, sessionRenderLogPath](QString){
                QFile renderLog(renderLogPath);
                QFile sessionRenderLog(sessionRenderLogPath);
                renderLog.open(QIODevice::ReadOnly);
                sessionRenderLog.open(QIODevice::WriteOnly | QIODevice::Append);
 
                QByteArray buffer;
                int chunksize = 256;
                while (!(buffer = renderLog.read(chunksize)).isEmpty()) {
                    sessionRenderLog.write(buffer);
                }
            });
        }
    }
    
    if (!m_processSettings.batchMode) {
        QString progressText = m_processSettings.progressMessage;
    
        progressText.replace("[progress]", "0");
    
        m_progress = toQShared(new QProgressDialog(progressText, "", 0, 0));
 
        m_progress->setWindowModality(Qt::ApplicationModal);
        m_progress->setCancelButton(0);
        m_progress->setMinimumDuration(0);
        m_progress->setValue(0);
 
        if (settings.progressIndeterminate) {
            m_progress->setRange(0,0);
        } else {
            m_progress->setRange(0, 100);
        }
        
        connect(m_progress.data(), SIGNAL(canceled()), m_process.data(), SLOT(kill()));
 
        m_progress->show();
        
        dbgFile << "Open progress dialog!";
    }
 
    connect(m_process.data(), SIGNAL(readyReadStandardOutput()), SLOT(slotReadyReadSTDOUT()));
    connect(m_process.data(), SIGNAL(readyReadStandardError()), SLOT(slotReadyReadSTDERR()));
    connect(m_process.data(), SIGNAL(started()), SLOT(slotStarted()));
    connect(m_process.data(), SIGNAL(finished(int, QProcess::ExitStatus)), SLOT(slotFinished(int)));
 
    QStringList args;
 
    if ( !settings.defaultPrependArgs.isEmpty() ) {
        args << settings.defaultPrependArgs;
    }
    
    args << settings.args;
    
    if ( !settings.outputFile.isEmpty() ) {
        args << settings.outputFile;
    }
 
    dbgFile << "starting process: " << qUtf8Printable(settings.processPath) << args;
 
    fixUpNonEmbeddedProcessEnvironment(settings.processPath, *m_process);
 
    m_process->start(settings.processPath, args);
}

References KisFFMpegWrapperSettings::args, KisFFMpegWrapperSettings::batchMode, connect(), dbgFile, KisFFMpegWrapperSettings::defaultPrependArgs, fixUpNonEmbeddedProcessEnvironment(), KIS_ASSERT, KisFFMpegWrapperSettings::logPath, m_errorMessage, m_process, m_processSettings, m_processSTDERR, m_processSTDOUT, m_progress, m_stdoutBuffer, KisFFMpegWrapperSettings::outputFile, KisFFMpegWrapperSettings::processPath, KisFFMpegWrapperSettings::progressIndeterminate, KisFFMpegWrapperSettings::progressMessage, sigFinishedWithError(), sigReadSTDERR(), slotFinished(), slotReadyReadSTDERR(), slotReadyReadSTDOUT(), slotStarted(), and toQShared().

transferCharacteristicsFromName()

TransferCharacteristics KisFFMpegWrapper::transferCharacteristicsFromName ( QString name )

static

Definition at line 826 of file KisFFMpegWrapper.cpp.

{
    if (name == "bt709") {
        return TRC_ITU_R_BT_709_5;
    }
    if (name == "gamma22") {
        return TRC_ITU_R_BT_470_6_SYSTEM_M;
    }
    if (name == "gamma28") {
        return TRC_ITU_R_BT_470_6_SYSTEM_B_G;
    }
    if (name == "smpte170m") {
        return TRC_ITU_R_BT_601_6;
    }
    if (name == "smpte240m") {
        return TRC_SMPTE_240M;
    }
    if (name == "linear") {
        return TRC_LINEAR;
    }
    if (name == "log" || name == "log100") {
        return TRC_LOGARITHMIC_100;
    }
    if (name == "log316" || name == "log_sqrt") {
        return TRC_LOGARITHMIC_100_sqrt10;
    }
    if (name == "iec61966_2_4" || name == "iec61966-2-4") {
        return TRC_IEC_61966_2_4;
    }
    if (name.startsWith("bt1361")) {
        return TRC_ITU_R_BT_1361;
    }
    if (name == "iec61966_2_1" || name == "iec61966-2-1") {
        return TRC_IEC_61966_2_1;
    }
    if (name.startsWith("bt2020_10")) {
        return TRC_ITU_R_BT_2020_2_10bit;
    }
    if (name.startsWith("bt2020_12")) {
        return TRC_ITU_R_BT_2020_2_12bit;
    }
    if (name == "smpte2084") {
        return TRC_ITU_R_BT_2100_0_PQ;
    }
    if (name == "smpte240m") {
        return TRC_SMPTE_240M;
    }
    if (name.startsWith("smpte428")) {
        return TRC_SMPTE_ST_428_1;
    }
    if (name == "arib-std-b67") {
        return TRC_ITU_R_BT_2100_0_HLG;
    }
 
    return TRC_UNSPECIFIED;
}

References TRC_IEC_61966_2_1, TRC_IEC_61966_2_4, TRC_ITU_R_BT_1361, TRC_ITU_R_BT_2020_2_10bit, TRC_ITU_R_BT_2020_2_12bit, TRC_ITU_R_BT_2100_0_HLG, TRC_ITU_R_BT_2100_0_PQ, TRC_ITU_R_BT_470_6_SYSTEM_B_G, TRC_ITU_R_BT_470_6_SYSTEM_M, TRC_ITU_R_BT_601_6, TRC_ITU_R_BT_709_5, TRC_LINEAR, TRC_LOGARITHMIC_100, TRC_LOGARITHMIC_100_sqrt10, TRC_SMPTE_240M, TRC_SMPTE_ST_428_1, and TRC_UNSPECIFIED.

updateProgressDialog()

void KisFFMpegWrapper::updateProgressDialog ( int progressValue )

private

Definition at line 206 of file KisFFMpegWrapper.cpp.

                                                             {
    
    dbgFile << "Update Progress" << progressValue << "/" << m_processSettings.totalFrames;
    
    if (!m_progress) return;
 
    QString progressText = m_processSettings.progressMessage;
    QStringList outputFileParts = m_processSettings.outputFile.split(".");
    QString suffix = outputFileParts.size() == 2 ? outputFileParts[1] : m_processSettings.outputFile;
 
    progressText.replace("[progress]", QString::number(progressValue));
    progressText.replace("[framecount]", QString::number(m_processSettings.totalFrames));
    progressText.replace("[suffix]", suffix );
    m_progress->setLabelText(progressText);
 
    if (m_processSettings.totalFrames > 0) m_progress->setValue(100 * progressValue / m_processSettings.totalFrames);
 
    if (m_process && m_process->state() == QProcess::Running) {
        QApplication::processEvents();
    }
}

References dbgFile, m_process, m_processSettings, m_progress, KisFFMpegWrapperSettings::outputFile, KisFFMpegWrapperSettings::progressMessage, and KisFFMpegWrapperSettings::totalFrames.

waitForFinished()

bool KisFFMpegWrapper::waitForFinished

(

int

msecs = FFMPEG_TIMEOUT

)

Definition at line 195 of file KisFFMpegWrapper.cpp.

{
    if (!m_process) return false;
 
    if (m_process->waitForStarted(msecs)) {
        return (m_process->waitForFinished(msecs) && m_process->exitStatus() == QProcess::ExitStatus::NormalExit);
    }
 
    return false;
}

References m_process.

Member Data Documentation

m_errorMessage

QString KisFFMpegWrapper::m_errorMessage

private

Definition at line 108 of file KisFFMpegWrapper.h.

m_process

QScopedPointer<QProcess> KisFFMpegWrapper::m_process

private

Definition at line 102 of file KisFFMpegWrapper.h.

m_processSettings

KisFFMpegWrapperSettings KisFFMpegWrapper::m_processSettings

private

Definition at line 104 of file KisFFMpegWrapper.h.

m_processSTDERR

QString KisFFMpegWrapper::m_processSTDERR

private

Definition at line 111 of file KisFFMpegWrapper.h.

m_processSTDOUT

QByteArray KisFFMpegWrapper::m_processSTDOUT

private

Definition at line 110 of file KisFFMpegWrapper.h.

m_progress

QSharedPointer<QProgressDialog> KisFFMpegWrapper::m_progress = nullptr

private

Definition at line 103 of file KisFFMpegWrapper.h.

m_stderrBuffer

QString KisFFMpegWrapper::m_stderrBuffer

private

Definition at line 107 of file KisFFMpegWrapper.h.

m_stdoutBuffer

QString KisFFMpegWrapper::m_stdoutBuffer

private

Definition at line 106 of file KisFFMpegWrapper.h.

---

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

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