24 #include "libavutil/ffversion.h"
25 #include "libavutil/bprint.h"
42#include <condition_variable>
59#define SESSION_MAP_SIZE 1000
125static bool fs_exists(
const std::string& s,
const bool isFile,
const bool isDirectory) {
126 struct stat dir_info;
128 if (stat(s.c_str(), &dir_info) == 0) {
129 if (isFile && S_ISREG(dir_info.st_mode)) {
132 if (isDirectory && S_ISDIR(dir_info.st_mode)) {
142 if (mkdir(s.c_str(), S_IRWXU | S_IRWXG | S_IROTH) != 0) {
143 std::cout <<
"Failed to create directory: " << s <<
". Operation failed with " << errno <<
"." << std::endl;
153 if (first !=
nullptr) {
161 std::unique_lock<std::recursive_mutex> lock(
sessionMutex, std::defer_lock);
163 const long sessionId = session->getSessionId();
185 CallbackData(
const long sessionId,
const int logLevel,
const AVBPrint* data) :
187 av_bprint_init(&
_logData, 0, AV_BPRINT_SIZE_UNLIMITED);
188 av_bprintf(&
_logData,
"%s", data->str);
192 const int videoFrameNumber,
193 const float videoFps,
194 const float videoQuality,
197 const double bitrate,
198 const double speed) :
277 callbackMonitor.wait_for(callbackLock, std::chrono::milliseconds(milliSeconds));
312static void avutil_log_format_line(
void *avcl,
int level,
const char *fmt, va_list vl, AVBPrint part[4],
int *print_prefix) {
313 int flags = av_log_get_flags();
314 AVClass* avc = avcl ? *(AVClass **) avcl : NULL;
315 av_bprint_init(part+0, 0, 1);
316 av_bprint_init(part+1, 0, 1);
317 av_bprint_init(part+2, 0, 1);
318 av_bprint_init(part+3, 0, 65536);
320 if (*print_prefix && avc) {
321 if (avc->parent_log_context_offset) {
322 AVClass** parent = *(AVClass ***) (((uint8_t *) avcl) +
323 avc->parent_log_context_offset);
324 if (parent && *parent) {
325 av_bprintf(part+0,
"[%s @ %p] ",
326 (*parent)->item_name(parent), parent);
329 av_bprintf(part+1,
"[%s @ %p] ",
330 avc->item_name(avcl), avcl);
333 if (*print_prefix && (level > AV_LOG_QUIET) && (flags & AV_LOG_PRINT_LEVEL))
336 av_vbprintf(part+3, fmt, vl);
338 if(*part[0].str || *part[1].str || *part[2].str || *part[3].str) {
339 char lastc = part[3].len && part[3].len <= part[3].size ? part[3].str[part[3].len - 1] : 0;
340 *print_prefix = lastc ==
'\n' || lastc ==
'\r';
346 if(*line < 0x08 || (*line > 0x0D && *line < 0x20))
473 int print_prefix = 1;
479 int activeLogLevel = av_log_get_level();
486 av_bprint_init(&fullLine, 0, AV_BPRINT_SIZE_UNLIMITED);
495 av_bprintf(&fullLine,
"%s%s%s%s", part[0].str, part[1].str, part[2].str, part[3].str);
497 if (fullLine.len > 0) {
501 av_bprint_finalize(part, NULL);
502 av_bprint_finalize(part+1, NULL);
503 av_bprint_finalize(part+2, NULL);
504 av_bprint_finalize(part+3, NULL);
505 av_bprint_finalize(&fullLine, NULL);
523static void process_log(
long sessionId,
int levelValueInt, AVBPrint* logMessage) {
524 int activeLogLevel = av_log_get_level();
526 std::shared_ptr<ffmpegkit::Log> log = std::make_shared<ffmpegkit::Log>(sessionId, levelValue, logMessage->str);
527 bool globalCallbackDefined =
false;
528 bool sessionCallbackDefined =
false;
538 if (session !=
nullptr) {
539 activeLogRedirectionStrategy = session->getLogRedirectionStrategy();
540 session->addLog(log);
543 if (sessionLogCallback !=
nullptr) {
544 sessionCallbackDefined =
true;
548 sessionLogCallback(log);
549 }
catch(
const std::exception& exception) {
550 std::cout <<
"Exception thrown inside session log callback. " << exception.what() << std::endl;
556 if (globalLogCallback !=
nullptr) {
557 globalCallbackDefined =
true;
561 globalLogCallback(log);
562 }
catch(
const std::exception& exception) {
563 std::cout <<
"Exception thrown inside global log callback. " << exception.what() << std::endl;
568 switch (activeLogRedirectionStrategy) {
573 if (globalCallbackDefined) {
579 if (sessionCallbackDefined) {
585 if (globalCallbackDefined || sessionCallbackDefined) {
596 switch (levelValue) {
607void process_statistics(
long sessionId,
int videoFrameNumber,
float videoFps,
float videoQuality,
long size,
int time,
double bitrate,
double speed) {
608 std::shared_ptr<ffmpegkit::Statistics> statistics = std::make_shared<ffmpegkit::Statistics>(sessionId, videoFrameNumber, videoFps, videoQuality, size, time, bitrate, speed);
611 if (session !=
nullptr && session->isFFmpeg()) {
612 std::shared_ptr<ffmpegkit::FFmpegSession> ffmpegSession = std::static_pointer_cast<ffmpegkit::FFmpegSession>(session);
613 ffmpegSession->addStatistics(statistics);
616 if (sessionStatisticsCallback !=
nullptr) {
618 sessionStatisticsCallback(statistics);
619 }
catch(
const std::exception& exception) {
620 std::cout <<
"Exception thrown inside session statistics callback. " << exception.what() << std::endl;
626 if (globalStatisticsCallback !=
nullptr) {
628 globalStatisticsCallback(statistics);
629 }
catch(
const std::exception& exception) {
630 std::cout <<
"Exception thrown inside global statistics callback. " << exception.what() << std::endl;
639 int activeLogLevel = av_log_get_level();
641 std::cout <<
"Async callback block started." << std::endl;
648 if (callbackData !=
nullptr) {
652 av_bprint_finalize(callbackData->
getLogData(), NULL);
670 }
catch(
const std::exception& exception) {
671 activeLogLevel = av_log_get_level();
673 std::cout <<
"Async callback block received error: " << exception.what() << std::endl;
678 activeLogLevel = av_log_get_level();
680 std::cout <<
"Async callback block stopped." << std::endl;
686static int executeFFmpeg(
const long sessionId,
const std::shared_ptr<std::list<std::string>> arguments) {
687 const char* LIB_NAME =
"ffmpeg";
692 char **commandCharPArray = (
char **)av_malloc(
sizeof(
char*) * (arguments->size() + 1));
698 commandCharPArray[0] = (
char *)av_malloc(
sizeof(
char) * (strlen(LIB_NAME) + 1));
699 strcpy(commandCharPArray[0], LIB_NAME);
703 for (
auto it=arguments->begin(); it != arguments->end(); it++, i++) {
704 commandCharPArray[i + 1] = (
char*)it->c_str();
714 int returnCode =
ffmpeg_execute((arguments->size() + 1), commandCharPArray);
720 av_free(commandCharPArray[0]);
721 av_free(commandCharPArray);
726int executeFFprobe(
const long sessionId,
const std::shared_ptr<std::list<std::string>> arguments) {
727 const char* LIB_NAME =
"ffprobe";
732 char **commandCharPArray = (
char **)av_malloc(
sizeof(
char*) * (arguments->size() + 1));
738 commandCharPArray[0] = (
char *)av_malloc(
sizeof(
char) * (strlen(LIB_NAME) + 1));
739 strcpy(commandCharPArray[0], LIB_NAME);
743 for (
auto it=arguments->begin(); it != arguments->end(); it++, i++) {
744 commandCharPArray[i + 1] = (
char*)it->c_str();
754 int returnCode =
ffprobe_execute((arguments->size() + 1), commandCharPArray);
760 av_free(commandCharPArray[0]);
761 av_free(commandCharPArray);
768 std::cout <<
"Loading ffmpeg-kit." << std::endl;
809 std::cout <<
"Failed to create async callback block: %d" << rc << std::endl;
835 av_log_set_callback(av_log_default_callback);
848 int validFontNameMappingCount = 0;
850 const char *parentDirectory = std::getenv(
"HOME");
851 if (parentDirectory == NULL) {
852 parentDirectory = std::getenv(
"TMPDIR");
853 if (parentDirectory == NULL) {
854 parentDirectory =
".";
858 std::string cacheDir = std::string(parentDirectory) +
"/.cache";
859 std::string ffmpegKitDir = cacheDir +
"/ffmpegkit";
860 auto tempConfigurationDirectory = ffmpegKitDir +
"/fontconfig";
861 auto fontConfigurationFile = std::string(tempConfigurationDirectory) +
"/fonts.conf";
866 std::cout <<
"Created temporary font conf directory: TRUE." << std::endl;
868 if (
fs_exists(fontConfigurationFile,
true,
false)) {
869 bool fontConfigurationDeleted = std::remove(fontConfigurationFile.c_str());
870 std::cout <<
"Deleted old temporary font configuration: " << (fontConfigurationDeleted == 0?
"TRUE":
"FALSE") <<
"." << std::endl;
874 std::string fontNameMappingBlock =
"";
875 for (
auto const& pair : fontNameMapping) {
876 if ((pair.first.size() > 0) && (pair.second.size() > 0)) {
878 fontNameMappingBlock +=
" <match target=\"pattern\">\n";
879 fontNameMappingBlock +=
" <test qual=\"any\" name=\"family\">\n";
880 fontNameMappingBlock +=
" <string>";
881 fontNameMappingBlock += pair.first;
882 fontNameMappingBlock +=
"</string>\n";
883 fontNameMappingBlock +=
" </test>\n";
884 fontNameMappingBlock +=
" <edit name=\"family\" mode=\"assign\" binding=\"same\">\n";
885 fontNameMappingBlock +=
" <string>";
886 fontNameMappingBlock += pair.second;
887 fontNameMappingBlock +=
"</string>\n";
888 fontNameMappingBlock +=
" </edit>\n";
889 fontNameMappingBlock +=
" </match>\n";
891 validFontNameMappingCount++;
895 std::string fontConfiguration;
896 fontConfiguration +=
"<?xml version=\"1.0\"?>\n";
897 fontConfiguration +=
"<!DOCTYPE fontconfig SYSTEM \"fonts.dtd\">\n";
898 fontConfiguration +=
"<fontconfig>\n";
899 fontConfiguration +=
" <dir prefix=\"cwd\">.</dir>\n";
901 for (
const auto& fontDirectoryPath : fontDirectoryList) {
902 fontConfiguration +=
" <dir>";
903 fontConfiguration += fontDirectoryPath;
904 fontConfiguration +=
"</dir>\n";
906 fontConfiguration += fontNameMappingBlock;
907 fontConfiguration +=
"</fontconfig>\n";
909 std::ofstream fontConfigurationStream(fontConfigurationFile, std::ios::out | std::ios::trunc);
910 if (fontConfigurationStream) {
911 fontConfigurationStream << fontConfiguration;
913 if (fontConfigurationStream.bad()) {
914 std::cout <<
"Failed to set font directory. Error received while saving font configuration: " << fontConfigurationStream.rdbuf() <<
"." << std::endl;
916 fontConfigurationStream.close();
918 std::cout <<
"Saved new temporary font configuration with " << validFontNameMappingCount <<
" font name mappings." << std::endl;
922 for (
const auto& fontDirectoryPath : fontDirectoryList) {
923 std::cout <<
"Font directory " << fontDirectoryPath <<
" registered successfully." << std::endl;
928 const char *parentDirectory = std::getenv(
"HOME");
929 if (parentDirectory == NULL) {
930 parentDirectory = std::getenv(
"TMPDIR");
931 if (parentDirectory == NULL) {
932 parentDirectory =
".";
937 std::string cacheDir = std::string(parentDirectory) +
"/.cache";
938 std::string ffmpegKitDir = cacheDir +
"/ffmpegkit";
939 std::string pipesDir = ffmpegKitDir +
"/pipes";
945 std::shared_ptr<std::string> newFFmpegPipePath = std::make_shared<std::string>(pipesDir +
"/" + FFmpegKitNamedPipePrefix + std::to_string(
pipeIndexGenerator++));
950 int rc = mkfifo(newFFmpegPipePath->c_str(), S_IRWXU | S_IRWXG | S_IROTH);
952 return newFFmpegPipePath;
954 std::cout <<
"Failed to register new FFmpeg pipe " << newFFmpegPipePath <<
". Operation failed with rc=" << rc <<
"." << std::endl;
960 std::remove(ffmpegPipePath.c_str());
964 return FFMPEG_VERSION;
969 return std::string(
"").append(FFmpegKitVersion).append(
"-lts");
971 return FFmpegKitVersion;
976 #if defined(FFMPEG_KIT_LTS)
985 sprintf(buildDate,
"%d", FFMPEG_KIT_BUILD_DATE);
986 return std::string(buildDate);
990 return setenv(variableName.c_str(), variableValue.c_str(),
true);
1008 ffmpegSession->startRunning();
1011 int returnCode =
executeFFmpeg(ffmpegSession->getSessionId(), ffmpegSession->getArguments());
1012 ffmpegSession->complete(std::make_shared<ffmpegkit::ReturnCode>(returnCode));
1013 }
catch(
const std::exception& exception) {
1014 ffmpegSession->fail(exception.what());
1020 ffprobeSession->startRunning();
1023 int returnCode =
executeFFprobe(ffprobeSession->getSessionId(), ffprobeSession->getArguments());
1024 ffprobeSession->complete(std::make_shared<ffmpegkit::ReturnCode>(returnCode));
1025 }
catch(
const std::exception& exception) {
1026 ffprobeSession->fail(exception.what());
1032 mediaInformationSession->startRunning();
1035 int returnCodeValue =
executeFFprobe(mediaInformationSession->getSessionId(), mediaInformationSession->getArguments());
1036 auto returnCode = std::make_shared<ffmpegkit::ReturnCode>(returnCodeValue);
1037 mediaInformationSession->complete(returnCode);
1038 if (returnCode->isValueSuccess()) {
1039 auto allLogs = mediaInformationSession->getAllLogsWithTimeout(waitTimeout);
1040 std::string ffprobeJsonOutput;
1041 std::for_each(allLogs->cbegin(), allLogs->cend(), [&](std::shared_ptr<ffmpegkit::Log> log) {
1042 if (log->getLevel() == LevelAVLogStdErr) {
1043 ffprobeJsonOutput.append(log->getMessage());
1047 mediaInformationSession->setMediaInformation(mediaInformation);
1049 }
catch(
const std::exception& exception) {
1050 mediaInformationSession->fail(exception.what());
1056 auto thread = std::thread([ffmpegSession]() {
1060 if (completeCallback !=
nullptr) {
1063 completeCallback(ffmpegSession);
1064 }
catch(
const std::exception& exception) {
1065 std::cout <<
"Exception thrown inside session complete callback. " << exception.what() << std::endl;
1070 if (globalFFmpegSessionCompleteCallback !=
nullptr) {
1073 globalFFmpegSessionCompleteCallback(ffmpegSession);
1074 }
catch(
const std::exception& exception) {
1075 std::cout <<
"Exception thrown inside global complete callback. " << exception.what() << std::endl;
1084 auto thread = std::thread([ffprobeSession]() {
1088 if (completeCallback !=
nullptr) {
1091 completeCallback(ffprobeSession);
1092 }
catch(
const std::exception& exception) {
1093 std::cout <<
"Exception thrown inside session complete callback. " << exception.what() << std::endl;
1098 if (globalFFprobeSessionCompleteCallback !=
nullptr) {
1101 globalFFprobeSessionCompleteCallback(ffprobeSession);
1102 }
catch(
const std::exception& exception) {
1103 std::cout <<
"Exception thrown inside global complete callback. " << exception.what() << std::endl;
1112 auto thread = std::thread([mediaInformationSession,waitTimeout]() {
1116 if (completeCallback !=
nullptr) {
1119 completeCallback(mediaInformationSession);
1120 }
catch(
const std::exception& exception) {
1121 std::cout <<
"Exception thrown inside session complete callback. " << exception.what() << std::endl;
1126 if (globalMediaInformationSessionCompleteCallback !=
nullptr) {
1129 globalMediaInformationSessionCompleteCallback(mediaInformationSession);
1130 }
catch(
const std::exception& exception) {
1131 std::cout <<
"Exception thrown inside global complete callback. " << exception.what() << std::endl;
1205 throw std::runtime_error(
"Session history size must not exceed the hard limit!");
1206 }
else if (newSessionHistorySize > 0) {
1213 std::unique_lock<std::recursive_mutex> lock(
sessionMutex, std::defer_lock);
1218 return session->second;
1225 std::unique_lock<std::recursive_mutex> lock(
sessionMutex, std::defer_lock);
1232 std::unique_lock<std::recursive_mutex> lock(
sessionMutex, std::defer_lock);
1237 auto session = *rit;
1247 std::unique_lock<std::recursive_mutex> lock(
sessionMutex, std::defer_lock);
1250 auto sessionHistoryListCopy = std::make_shared<std::list<std::shared_ptr<ffmpegkit::Session>>>(
sessionHistoryList);
1254 return sessionHistoryListCopy;
1258 std::unique_lock<std::recursive_mutex> lock(
sessionMutex, std::defer_lock);
1268 std::unique_lock<std::recursive_mutex> lock(
sessionMutex, std::defer_lock);
1269 const auto ffmpegSessions = std::make_shared<std::list<std::shared_ptr<ffmpegkit::FFmpegSession>>>();
1275 if (session->isFFmpeg()) {
1276 ffmpegSessions->push_back(std::static_pointer_cast<ffmpegkit::FFmpegSession>(session));
1282 return ffmpegSessions;
1286 std::unique_lock<std::recursive_mutex> lock(
sessionMutex, std::defer_lock);
1287 const auto ffprobeSessions = std::make_shared<std::list<std::shared_ptr<ffmpegkit::FFprobeSession>>>();
1293 if (session->isFFprobe()) {
1294 ffprobeSessions->push_back(std::static_pointer_cast<ffmpegkit::FFprobeSession>(session));
1300 return ffprobeSessions;
1304 std::unique_lock<std::recursive_mutex> lock(
sessionMutex, std::defer_lock);
1305 const auto mediaInformationSessions = std::make_shared<std::list<std::shared_ptr<ffmpegkit::MediaInformationSession>>>();
1311 if (session->isMediaInformation()) {
1312 mediaInformationSessions->push_back(std::static_pointer_cast<ffmpegkit::MediaInformationSession>(session));
1318 return mediaInformationSessions;
1322 std::unique_lock<std::recursive_mutex> lock(
sessionMutex, std::defer_lock);
1323 auto sessions = std::make_shared<std::list<std::shared_ptr<ffmpegkit::Session>>>();
1329 if (session->getState() == state) {
1330 sessions->push_back(session);
1362 std::list<std::string> argumentList;
1363 std::string currentArgument;
1365 bool singleQuoteStarted =
false;
1366 bool doubleQuoteStarted =
false;
1368 for (
int i = 0; i < command.size(); i++) {
1371 previousChar = command[i - 1];
1375 char currentChar = command[i];
1377 if (currentChar ==
' ') {
1378 if (singleQuoteStarted || doubleQuoteStarted) {
1379 currentArgument += currentChar;
1380 }
else if (currentArgument.size() > 0) {
1381 argumentList.push_back(currentArgument);
1382 currentArgument =
"";
1384 }
else if (currentChar ==
'\'' && (previousChar == 0 || previousChar !=
'\\')) {
1385 if (singleQuoteStarted) {
1386 singleQuoteStarted =
false;
1387 }
else if (doubleQuoteStarted) {
1388 currentArgument += currentChar;
1390 singleQuoteStarted =
true;
1392 }
else if (currentChar ==
'\"' && (previousChar == 0 || previousChar !=
'\\')) {
1393 if (doubleQuoteStarted) {
1394 doubleQuoteStarted =
false;
1395 }
else if (singleQuoteStarted) {
1396 currentArgument += currentChar;
1398 doubleQuoteStarted =
true;
1401 currentArgument += currentChar;
1405 if (currentArgument.size() > 0) {
1406 argumentList.push_back(currentArgument);
1409 return argumentList;
1413 if (arguments ==
nullptr) {
1418 for(
auto it=arguments->begin(); it != arguments->end(); ++it) {
1419 auto argument = *it;
1420 if (it != arguments->begin()) {
static std::mutex callbackMutex
void ffmpegkit_log_callback_function(void *ptr, int level, const char *format, va_list vargs)
static void process_log(long sessionId, int levelValueInt, AVBPrint *logMessage)
void * callbackThreadFunction(void *pointer)
int executeFFprobe(const long sessionId, const std::shared_ptr< std::list< std::string > > arguments)
static std::atomic< long > pipeIndexGenerator(1)
static void statisticsCallbackDataAdd(int frameNumber, float fps, float quality, int64_t size, int time, double bitrate, double speed)
void cancelSession(long sessionId)
static int sessionHistorySize
static bool fs_exists(const std::string &s, const bool isFile, const bool isDirectory)
static std::list< CallbackData * > callbackDataList
static std::recursive_mutex callbackDataMutex
static void logCallbackDataAdd(int level, AVBPrint *data)
static void avutil_log_sanitize(char *line)
volatile int handleSIGINT
static void registerSessionId(long sessionId)
int ffprobe_execute(int argc, char **argv)
volatile int handleSIGTERM
static ffmpegkit::FFmpegSessionCompleteCallback ffmpegSessionCompleteCallback
static std::atomic< int > sessionInTransitMessageCountMap[SESSION_MAP_SIZE]
static const char * avutil_log_get_level_str(int level)
void ffmpegkit_statistics_callback_function(int frameNumber, float fps, float quality, int64_t size, int time, double bitrate, double speed)
static void avutil_log_format_line(void *avcl, int level, const char *fmt, va_list vl, AVBPrint part[4], int *print_prefix)
static std::recursive_mutex sessionMutex
static std::atomic< short > sessionMap[SESSION_MAP_SIZE]
void addSessionToSessionHistory(const std::shared_ptr< ffmpegkit::Session > session)
static void resetMessagesInTransmit(long sessionId)
static ffmpegkit::LogCallback logCallback
static void callbackNotify()
static pthread_t callbackThread
static std::condition_variable callbackMonitor
static std::list< std::shared_ptr< ffmpegkit::Session > > sessionHistoryList
static std::map< long, std::shared_ptr< ffmpegkit::Session > > sessionHistoryMap
static ffmpegkit::StatisticsCallback statisticsCallback
static ffmpegkit::LogRedirectionStrategy globalLogRedirectionStrategy
static std::once_flag ffmpegKitInitializerFlag
void * ffmpegKitInitialize()
static int executeFFmpeg(const long sessionId, const std::shared_ptr< std::list< std::string > > arguments)
void deleteExpiredSessions()
__thread long globalSessionId
static int redirectionEnabled
static void callbackWait(int milliSeconds)
void process_statistics(long sessionId, int videoFrameNumber, float videoFps, float videoQuality, long size, int time, double bitrate, double speed)
int cancelRequested(long sessionId)
volatile int handleSIGPIPE
static CallbackData * callbackDataRemove()
volatile int handleSIGXCPU
static ffmpegkit::FFprobeSessionCompleteCallback ffprobeSessionCompleteCallback
static void removeSession(long sessionId)
static bool fs_create_dir(const std::string &s)
static ffmpegkit::MediaInformationSessionCompleteCallback mediaInformationSessionCompleteCallback
int ffmpeg_execute(int argc, char **argv)
const void * _ffmpegKitConfigInitializer
volatile int handleSIGQUIT
float getStatisticsQuality()
double _statisticsBitrate
CallbackData(const long sessionId, const int videoFrameNumber, const float videoFps, const float videoQuality, const int64_t size, const int time, const double bitrate, const double speed)
double getStatisticsSpeed()
int getStatisticsFrameNumber()
int64_t getStatisticsSize()
CallbackData(const long sessionId, const int logLevel, const AVBPrint *data)
int _statisticsFrameNumber
double getStatisticsBitrate()
static std::string getArch()
static std::string getVersion()
static void disableRedirection()
static std::shared_ptr< std::list< std::shared_ptr< ffmpegkit::MediaInformationSession > > > getMediaInformationSessions()
static void enableFFmpegSessionCompleteCallback(const FFmpegSessionCompleteCallback ffmpegSessionCompleteCallback)
static int getSessionHistorySize()
static std::shared_ptr< ffmpegkit::Session > getLastSession()
static void enableRedirection()
static void enableLogCallback(const ffmpegkit::LogCallback logCallback)
static std::shared_ptr< std::string > registerNewFFmpegPipe()
static LogRedirectionStrategy getLogRedirectionStrategy()
static std::shared_ptr< std::list< std::shared_ptr< ffmpegkit::FFprobeSession > > > getFFprobeSessions()
static int messagesInTransmit(const long sessionId)
static void closeFFmpegPipe(const std::string &ffmpegPipePath)
static void asyncFFprobeExecute(const std::shared_ptr< ffmpegkit::FFprobeSession > ffprobeSession)
static ffmpegkit::Level getLogLevel()
static std::shared_ptr< ffmpegkit::Session > getSession(const long sessionId)
static void asyncGetMediaInformationExecute(const std::shared_ptr< ffmpegkit::MediaInformationSession > mediaInformationSession, int waitTimeout)
static void setLogRedirectionStrategy(const LogRedirectionStrategy logRedirectionStrategy)
static void getMediaInformationExecute(const std::shared_ptr< ffmpegkit::MediaInformationSession > mediaInformationSession, const int waitTimeout)
static int setEnvironmentVariable(const std::string &variableName, const std::string &variableValue)
static std::shared_ptr< std::list< std::shared_ptr< ffmpegkit::Session > > > getSessionsByState(const SessionState state)
static void enableStatisticsCallback(const ffmpegkit::StatisticsCallback statisticsCallback)
static std::list< std::string > parseArguments(const std::string &command)
static void ffprobeExecute(const std::shared_ptr< ffmpegkit::FFprobeSession > ffprobeSession)
static void setSessionHistorySize(const int sessionHistorySize)
static void setLogLevel(const ffmpegkit::Level level)
static void setFontDirectory(const std::string &fontDirectoryPath, const std::map< std::string, std::string > &fontNameMapping)
static void asyncFFmpegExecute(const std::shared_ptr< ffmpegkit::FFmpegSession > ffmpegSession)
static FFmpegSessionCompleteCallback getFFmpegSessionCompleteCallback()
static void ignoreSignal(const ffmpegkit::Signal signal)
static FFprobeSessionCompleteCallback getFFprobeSessionCompleteCallback()
static std::shared_ptr< ffmpegkit::Session > getLastCompletedSession()
static void clearSessions()
static std::string sessionStateToString(SessionState state)
static std::shared_ptr< std::list< std::shared_ptr< ffmpegkit::FFmpegSession > > > getFFmpegSessions()
static int setFontconfigConfigurationPath(const std::string &path)
static std::string argumentsToString(std::shared_ptr< std::list< std::string > > arguments)
static std::string logLevelToString(const ffmpegkit::Level level)
static void setFontDirectoryList(const std::list< std::string > &fontDirectoryList, const std::map< std::string, std::string > &fontNameMapping)
static void enableMediaInformationSessionCompleteCallback(const MediaInformationSessionCompleteCallback mediaInformationSessionCompleteCallback)
static void enableFFprobeSessionCompleteCallback(const FFprobeSessionCompleteCallback ffprobeSessionCompleteCallback)
static std::string getFFmpegVersion()
static std::shared_ptr< std::list< std::shared_ptr< ffmpegkit::Session > > > getSessions()
static std::string getBuildDate()
static void ffmpegExecute(const std::shared_ptr< ffmpegkit::FFmpegSession > ffmpegSession)
static MediaInformationSessionCompleteCallback getMediaInformationSessionCompleteCallback()
static std::string getPackageName()
@ LogRedirectionStrategyPrintLogsWhenSessionCallbackNotDefined
@ LogRedirectionStrategyAlwaysPrintLogs
@ LogRedirectionStrategyNeverPrintLogs
@ LogRedirectionStrategyPrintLogsWhenNoCallbacksDefined
@ LogRedirectionStrategyPrintLogsWhenGlobalCallbackNotDefined
std::function< void(const std::shared_ptr< ffmpegkit::Statistics > statistics)> StatisticsCallback
std::function< void(const std::shared_ptr< ffmpegkit::MediaInformationSession > session)> MediaInformationSessionCompleteCallback
std::function< void(const std::shared_ptr< ffmpegkit::Log > log)> LogCallback
std::function< void(const std::shared_ptr< ffmpegkit::FFprobeSession > session)> FFprobeSessionCompleteCallback
std::function< void(const std::shared_ptr< ffmpegkit::FFmpegSession > session)> FFmpegSessionCompleteCallback