mirror of
https://github.com/WarmUpTill/SceneSwitcher.git
synced 2026-03-28 21:05:26 -05:00
f8ad8c31be
use double internally instead of two ints rework save / load to file to reuse existing functionality add option to select between seconds / minutes / hours
527 lines
14 KiB
C++
527 lines
14 KiB
C++
#pragma once
|
|
#include <condition_variable>
|
|
#include <chrono>
|
|
#include <string>
|
|
#include <vector>
|
|
#include <regex>
|
|
#include <mutex>
|
|
#include <fstream>
|
|
#include <QDateTime>
|
|
#include <QThread>
|
|
#include "utility.hpp"
|
|
|
|
#define DEFAULT_INTERVAL 300
|
|
|
|
#define DEFAULT_IDLE_TIME 60
|
|
|
|
#define PREVIOUS_SCENE_NAME "Previous Scene"
|
|
|
|
#define READ_FILE_FUNC 0
|
|
#define ROUND_TRIP_FUNC 1
|
|
#define IDLE_FUNC 2
|
|
#define EXE_FUNC 3
|
|
#define SCREEN_REGION_FUNC 4
|
|
#define WINDOW_TITLE_FUNC 5
|
|
#define MEDIA_FUNC 6
|
|
#define TIME_FUNC 7
|
|
|
|
#define DEFAULT_PRIORITY_0 READ_FILE_FUNC
|
|
#define DEFAULT_PRIORITY_1 ROUND_TRIP_FUNC
|
|
#define DEFAULT_PRIORITY_2 IDLE_FUNC
|
|
#define DEFAULT_PRIORITY_3 EXE_FUNC
|
|
#define DEFAULT_PRIORITY_4 SCREEN_REGION_FUNC
|
|
#define DEFAULT_PRIORITY_5 WINDOW_TITLE_FUNC
|
|
#define DEFAULT_PRIORITY_6 MEDIA_FUNC
|
|
#define DEFAULT_PRIORITY_7 TIME_FUNC
|
|
|
|
/********************************************************************************
|
|
* Data structs for each scene switching method
|
|
********************************************************************************/
|
|
struct WindowSceneSwitch {
|
|
OBSWeakSource scene;
|
|
std::string window;
|
|
OBSWeakSource transition;
|
|
bool fullscreen;
|
|
bool focus;
|
|
|
|
inline WindowSceneSwitch(OBSWeakSource scene_, const char *window_,
|
|
OBSWeakSource transition_, bool fullscreen_,
|
|
bool focus_)
|
|
: scene(scene_),
|
|
window(window_),
|
|
transition(transition_),
|
|
fullscreen(fullscreen_),
|
|
focus(focus_)
|
|
{
|
|
}
|
|
};
|
|
|
|
struct ExecutableSceneSwitch {
|
|
OBSWeakSource mScene;
|
|
OBSWeakSource mTransition;
|
|
QString mExe;
|
|
bool mInFocus;
|
|
|
|
inline ExecutableSceneSwitch(OBSWeakSource scene,
|
|
OBSWeakSource transition,
|
|
const QString &exe, bool inFocus)
|
|
: mScene(scene),
|
|
mTransition(transition),
|
|
mExe(exe),
|
|
mInFocus(inFocus)
|
|
{
|
|
}
|
|
};
|
|
|
|
struct ScreenRegionSwitch {
|
|
OBSWeakSource scene;
|
|
OBSWeakSource transition;
|
|
int minX, minY, maxX, maxY;
|
|
std::string regionStr;
|
|
|
|
inline ScreenRegionSwitch(OBSWeakSource scene_,
|
|
OBSWeakSource transition_, int minX_,
|
|
int minY_, int maxX_, int maxY_,
|
|
std::string regionStr_)
|
|
: scene(scene_),
|
|
transition(transition_),
|
|
minX(minX_),
|
|
minY(minY_),
|
|
maxX(maxX_),
|
|
maxY(maxY_),
|
|
regionStr(regionStr_)
|
|
{
|
|
}
|
|
};
|
|
|
|
struct SceneRoundTripSwitch {
|
|
OBSWeakSource scene1;
|
|
OBSWeakSource scene2;
|
|
OBSWeakSource transition;
|
|
double delay;
|
|
bool usePreviousScene;
|
|
std::string sceneRoundTripStr;
|
|
|
|
inline SceneRoundTripSwitch(OBSWeakSource scene1_,
|
|
OBSWeakSource scene2_,
|
|
OBSWeakSource transition_, int delay_,
|
|
bool usePreviousScene_, std::string str)
|
|
: scene1(scene1_),
|
|
scene2(scene2_),
|
|
transition(transition_),
|
|
delay(delay_),
|
|
usePreviousScene(usePreviousScene_),
|
|
sceneRoundTripStr(str)
|
|
{
|
|
}
|
|
};
|
|
|
|
struct RandomSwitch {
|
|
OBSWeakSource scene;
|
|
OBSWeakSource transition;
|
|
double delay;
|
|
std::string randomSwitchStr;
|
|
|
|
inline RandomSwitch(OBSWeakSource scene_, OBSWeakSource transition_,
|
|
double delay_, std::string str)
|
|
: scene(scene_),
|
|
transition(transition_),
|
|
delay(delay_),
|
|
randomSwitchStr(str)
|
|
{
|
|
}
|
|
};
|
|
|
|
struct SceneTransition {
|
|
OBSWeakSource scene1;
|
|
OBSWeakSource scene2;
|
|
OBSWeakSource transition;
|
|
std::string sceneTransitionStr;
|
|
|
|
inline SceneTransition(OBSWeakSource scene1_, OBSWeakSource scene2_,
|
|
OBSWeakSource transition_,
|
|
std::string sceneTransitionStr_)
|
|
: scene1(scene1_),
|
|
scene2(scene2_),
|
|
transition(transition_),
|
|
sceneTransitionStr(sceneTransitionStr_)
|
|
{
|
|
}
|
|
};
|
|
|
|
struct DefaultSceneTransition {
|
|
OBSWeakSource scene;
|
|
OBSWeakSource transition;
|
|
std::string sceneTransitionStr;
|
|
|
|
inline DefaultSceneTransition(OBSWeakSource scene_,
|
|
OBSWeakSource transition_,
|
|
std::string sceneTransitionStr_)
|
|
: scene(scene_),
|
|
transition(transition_),
|
|
sceneTransitionStr(sceneTransitionStr_)
|
|
{
|
|
}
|
|
};
|
|
|
|
struct FileSwitch {
|
|
OBSWeakSource scene;
|
|
OBSWeakSource transition;
|
|
std::string file;
|
|
std::string text;
|
|
bool remote = false;
|
|
bool useRegex = false;
|
|
bool useTime = false;
|
|
QDateTime lastMod;
|
|
|
|
inline FileSwitch(OBSWeakSource scene_, OBSWeakSource transition_,
|
|
const char *file_, const char *text_, bool remote_,
|
|
bool useRegex_, bool useTime_)
|
|
: scene(scene_),
|
|
transition(transition_),
|
|
file(file_),
|
|
text(text_),
|
|
remote(remote_),
|
|
useRegex(useRegex_),
|
|
useTime(useTime_),
|
|
lastMod()
|
|
{
|
|
}
|
|
};
|
|
|
|
struct FileIOData {
|
|
bool readEnabled = false;
|
|
std::string readPath;
|
|
bool writeEnabled = false;
|
|
std::string writePath;
|
|
};
|
|
|
|
struct IdleData {
|
|
bool idleEnable = false;
|
|
int time = DEFAULT_IDLE_TIME;
|
|
OBSWeakSource scene;
|
|
OBSWeakSource transition;
|
|
bool usePreviousScene;
|
|
bool alreadySwitched = false;
|
|
};
|
|
|
|
struct MediaSwitch {
|
|
OBSWeakSource scene;
|
|
OBSWeakSource source;
|
|
OBSWeakSource transition;
|
|
obs_media_state state;
|
|
int64_t time;
|
|
time_restriction restriction;
|
|
bool matched;
|
|
bool usePreviousScene;
|
|
std::string mediaSwitchStr;
|
|
|
|
inline MediaSwitch(OBSWeakSource scene_, OBSWeakSource source_,
|
|
OBSWeakSource transition_, obs_media_state state_,
|
|
time_restriction restriction_, uint64_t time_,
|
|
bool usePreviousScene_, std::string mediaSwitchStr_)
|
|
: scene(scene_),
|
|
source(source_),
|
|
transition(transition_),
|
|
state(state_),
|
|
restriction(restriction_),
|
|
time(time_),
|
|
usePreviousScene(usePreviousScene_),
|
|
mediaSwitchStr(mediaSwitchStr_)
|
|
{
|
|
}
|
|
};
|
|
|
|
struct TimeSwitch {
|
|
OBSWeakSource scene;
|
|
OBSWeakSource transition;
|
|
QTime time;
|
|
bool matched;
|
|
bool usePreviousScene;
|
|
std::string timeSwitchStr;
|
|
|
|
inline TimeSwitch(OBSWeakSource scene_, OBSWeakSource transition_,
|
|
QTime time_, bool usePreviousScene_,
|
|
std::string timeSwitchStr_)
|
|
: scene(scene_),
|
|
transition(transition_),
|
|
time(time_),
|
|
usePreviousScene(usePreviousScene_),
|
|
timeSwitchStr(timeSwitchStr_)
|
|
{
|
|
}
|
|
};
|
|
|
|
typedef enum { NO_SWITCH = 0, SWITCH = 1, RANDOM_SWITCH = 2 } NoMatch;
|
|
|
|
class SwitcherThread;
|
|
|
|
/********************************************************************************
|
|
* SwitcherData
|
|
********************************************************************************/
|
|
struct SwitcherData {
|
|
SwitcherThread *th = nullptr;
|
|
|
|
std::condition_variable cv;
|
|
std::mutex m;
|
|
bool transitionActive = false;
|
|
bool waitForTransition = false;
|
|
std::condition_variable transitionCv;
|
|
bool startAtLaunch = false;
|
|
bool stop = false;
|
|
bool verbose = false;
|
|
bool tansitionOverrideOverride = false;
|
|
|
|
int interval = DEFAULT_INTERVAL;
|
|
|
|
obs_source_t *waitScene = NULL; //scene during which wait started
|
|
OBSWeakSource previousScene = NULL;
|
|
OBSWeakSource PreviousScene2 = NULL;
|
|
OBSWeakSource lastRandomScene;
|
|
OBSWeakSource nonMatchingScene;
|
|
NoMatch switchIfNotMatching = NO_SWITCH;
|
|
|
|
std::vector<WindowSceneSwitch> windowSwitches;
|
|
std::vector<std::string> ignoreIdleWindows;
|
|
std::string lastTitle;
|
|
|
|
std::vector<ScreenRegionSwitch> screenRegionSwitches;
|
|
|
|
std::vector<OBSWeakSource> pauseScenesSwitches;
|
|
|
|
std::vector<std::string> pauseWindowsSwitches;
|
|
|
|
std::vector<std::string> ignoreWindowsSwitches;
|
|
|
|
std::vector<SceneRoundTripSwitch> sceneRoundTripSwitches;
|
|
int sceneRoundTripUnitMultiplier = 1;
|
|
|
|
std::vector<RandomSwitch> randomSwitches;
|
|
|
|
FileIOData fileIO;
|
|
IdleData idleData;
|
|
std::vector<FileSwitch> fileSwitches;
|
|
|
|
std::vector<ExecutableSceneSwitch> executableSwitches;
|
|
|
|
bool autoStopEnable = false;
|
|
OBSWeakSource autoStopScene;
|
|
|
|
std::vector<SceneTransition> sceneTransitions;
|
|
std::vector<DefaultSceneTransition> defaultSceneTransitions;
|
|
|
|
std::vector<MediaSwitch> mediaSwitches;
|
|
|
|
std::vector<TimeSwitch> timeSwitches;
|
|
|
|
std::vector<int> functionNamesByPriority = std::vector<int>{
|
|
DEFAULT_PRIORITY_0, DEFAULT_PRIORITY_1, DEFAULT_PRIORITY_2,
|
|
DEFAULT_PRIORITY_3, DEFAULT_PRIORITY_4, DEFAULT_PRIORITY_5,
|
|
DEFAULT_PRIORITY_6, DEFAULT_PRIORITY_7};
|
|
|
|
struct ThreadPrio {
|
|
std::string name;
|
|
std::string description;
|
|
uint32_t value;
|
|
};
|
|
|
|
std::vector<ThreadPrio> threadPriorities{
|
|
{"Idle",
|
|
"scheduled only when no other threads are running (lowest CPU load)",
|
|
QThread::IdlePriority},
|
|
{"Lowest", "scheduled less often than LowPriority",
|
|
QThread::LowestPriority},
|
|
{"Low", "scheduled less often than NormalPriority",
|
|
QThread::LowPriority},
|
|
{"Normal", "the default priority of the operating system",
|
|
QThread::NormalPriority},
|
|
{"High", "scheduled more often than NormalPriority",
|
|
QThread::HighPriority},
|
|
{"Highest", "scheduled more often than HighPriority",
|
|
QThread::HighestPriority},
|
|
{"Time critical",
|
|
"scheduled as often as possible (highest CPU load)",
|
|
QThread::TimeCriticalPriority},
|
|
};
|
|
|
|
uint32_t threadPriority = QThread::NormalPriority;
|
|
|
|
std::vector<int> tabOrder;
|
|
|
|
void Thread();
|
|
void Start();
|
|
void Stop();
|
|
|
|
bool sceneChangedDuringWait();
|
|
bool prioFuncsValid();
|
|
void writeSceneInfoToFile();
|
|
void setDefaultSceneTransitions();
|
|
void autoStopStreamAndRecording();
|
|
bool checkPause();
|
|
void checkSceneRoundTrip(bool &match, OBSWeakSource &scene,
|
|
OBSWeakSource &transition,
|
|
std::unique_lock<std::mutex> &lock);
|
|
void checkIdleSwitch(bool &match, OBSWeakSource &scene,
|
|
OBSWeakSource &transition);
|
|
void checkWindowTitleSwitch(bool &match, OBSWeakSource &scene,
|
|
OBSWeakSource &transition);
|
|
void checkExeSwitch(bool &match, OBSWeakSource &scene,
|
|
OBSWeakSource &transition);
|
|
void checkScreenRegionSwitch(bool &match, OBSWeakSource &scene,
|
|
OBSWeakSource &transition);
|
|
void checkSwitchInfoFromFile(bool &match, OBSWeakSource &scene,
|
|
OBSWeakSource &transition);
|
|
void checkFileContent(bool &match, OBSWeakSource &scene,
|
|
OBSWeakSource &transition);
|
|
void checkRandom(bool &match, OBSWeakSource &scene,
|
|
OBSWeakSource &transition, int &delay);
|
|
void checkMediaSwitch(bool &match, OBSWeakSource &scene,
|
|
OBSWeakSource &transition);
|
|
void checkTimeSwitch(bool &match, OBSWeakSource &scene,
|
|
OBSWeakSource &transition);
|
|
|
|
void saveWindowTitleSwitches(obs_data_t *obj);
|
|
void saveScreenRegionSwitches(obs_data_t *obj);
|
|
void savePauseSwitches(obs_data_t *obj);
|
|
void saveSceneRoundTripSwitches(obs_data_t *obj);
|
|
void saveSceneTransitions(obs_data_t *obj);
|
|
void saveIdleSwitches(obs_data_t *obj);
|
|
void saveExecutableSwitches(obs_data_t *obj);
|
|
void saveRandomSwitches(obs_data_t *obj);
|
|
void saveFileSwitches(obs_data_t *obj);
|
|
void saveMediaSwitches(obs_data_t *obj);
|
|
void saveTimeSwitches(obs_data_t *obj);
|
|
void saveGeneralSettings(obs_data_t *obj);
|
|
|
|
void loadWindowTitleSwitches(obs_data_t *obj);
|
|
void loadScreenRegionSwitches(obs_data_t *obj);
|
|
void loadPauseSwitches(obs_data_t *obj);
|
|
void loadSceneRoundTripSwitches(obs_data_t *obj);
|
|
void loadSceneTransitions(obs_data_t *obj);
|
|
void loadIdleSwitches(obs_data_t *obj);
|
|
void loadExecutableSwitches(obs_data_t *obj);
|
|
void loadRandomSwitches(obs_data_t *obj);
|
|
void loadFileSwitches(obs_data_t *obj);
|
|
void loadMediaSwitches(obs_data_t *obj);
|
|
void loadTimeSwitches(obs_data_t *obj);
|
|
void loadGeneralSettings(obs_data_t *obj);
|
|
|
|
void Prune()
|
|
{
|
|
for (size_t i = 0; i < windowSwitches.size(); i++) {
|
|
WindowSceneSwitch &s = windowSwitches[i];
|
|
if (!WeakSourceValid(s.scene) ||
|
|
!WeakSourceValid(s.transition))
|
|
windowSwitches.erase(windowSwitches.begin() +
|
|
i--);
|
|
}
|
|
|
|
if (nonMatchingScene && !WeakSourceValid(nonMatchingScene)) {
|
|
switchIfNotMatching = NO_SWITCH;
|
|
nonMatchingScene = nullptr;
|
|
}
|
|
|
|
for (size_t i = 0; i < randomSwitches.size(); i++) {
|
|
RandomSwitch &s = randomSwitches[i];
|
|
if (!WeakSourceValid(s.scene) ||
|
|
!WeakSourceValid(s.transition))
|
|
randomSwitches.erase(randomSwitches.begin() +
|
|
i--);
|
|
}
|
|
|
|
for (size_t i = 0; i < screenRegionSwitches.size(); i++) {
|
|
ScreenRegionSwitch &s = screenRegionSwitches[i];
|
|
if (!WeakSourceValid(s.scene) ||
|
|
!WeakSourceValid(s.transition))
|
|
screenRegionSwitches.erase(
|
|
screenRegionSwitches.begin() + i--);
|
|
}
|
|
|
|
for (size_t i = 0; i < pauseScenesSwitches.size(); i++) {
|
|
OBSWeakSource &scene = pauseScenesSwitches[i];
|
|
if (!WeakSourceValid(scene))
|
|
pauseScenesSwitches.erase(
|
|
pauseScenesSwitches.begin() + i--);
|
|
}
|
|
|
|
for (size_t i = 0; i < sceneRoundTripSwitches.size(); i++) {
|
|
SceneRoundTripSwitch &s = sceneRoundTripSwitches[i];
|
|
if (!WeakSourceValid(s.scene1) ||
|
|
(!s.usePreviousScene &&
|
|
!WeakSourceValid(s.scene2)) ||
|
|
!WeakSourceValid(s.transition))
|
|
sceneRoundTripSwitches.erase(
|
|
sceneRoundTripSwitches.begin() + i--);
|
|
}
|
|
|
|
if (!WeakSourceValid(autoStopScene)) {
|
|
autoStopScene = nullptr;
|
|
autoStopEnable = false;
|
|
}
|
|
|
|
for (size_t i = 0; i < sceneTransitions.size(); i++) {
|
|
SceneTransition &s = sceneTransitions[i];
|
|
if (!WeakSourceValid(s.scene1) ||
|
|
!WeakSourceValid(s.scene2) ||
|
|
!WeakSourceValid(s.transition))
|
|
sceneTransitions.erase(
|
|
sceneTransitions.begin() + i--);
|
|
}
|
|
|
|
for (size_t i = 0; i < defaultSceneTransitions.size(); i++) {
|
|
DefaultSceneTransition &s = defaultSceneTransitions[i];
|
|
if (!WeakSourceValid(s.scene) ||
|
|
!WeakSourceValid(s.transition))
|
|
defaultSceneTransitions.erase(
|
|
defaultSceneTransitions.begin() + i--);
|
|
}
|
|
|
|
for (size_t i = 0; i < executableSwitches.size(); i++) {
|
|
ExecutableSceneSwitch &s = executableSwitches[i];
|
|
if (!WeakSourceValid(s.mScene) ||
|
|
!WeakSourceValid(s.mTransition))
|
|
executableSwitches.erase(
|
|
executableSwitches.begin() + i--);
|
|
}
|
|
|
|
for (size_t i = 0; i < fileSwitches.size(); i++) {
|
|
FileSwitch &s = fileSwitches[i];
|
|
if (!WeakSourceValid(s.scene) ||
|
|
!WeakSourceValid(s.transition))
|
|
fileSwitches.erase(fileSwitches.begin() + i--);
|
|
}
|
|
|
|
for (size_t i = 0; i < timeSwitches.size(); i++) {
|
|
TimeSwitch &s = timeSwitches[i];
|
|
if ((!s.usePreviousScene &&
|
|
!WeakSourceValid(s.scene)) ||
|
|
!WeakSourceValid(s.transition))
|
|
timeSwitches.erase(timeSwitches.begin() + i--);
|
|
}
|
|
|
|
if (!idleData.usePreviousScene &&
|
|
!WeakSourceValid(idleData.scene) ||
|
|
!WeakSourceValid(idleData.transition)) {
|
|
idleData.idleEnable = false;
|
|
}
|
|
|
|
for (size_t i = 0; i < mediaSwitches.size(); i++) {
|
|
MediaSwitch &s = mediaSwitches[i];
|
|
if ((!s.usePreviousScene &&
|
|
!WeakSourceValid(s.scene)) ||
|
|
!WeakSourceValid(s.source) ||
|
|
!WeakSourceValid(s.transition))
|
|
mediaSwitches.erase(mediaSwitches.begin() +
|
|
i--);
|
|
}
|
|
}
|
|
inline ~SwitcherData() { Stop(); }
|
|
};
|
|
|
|
extern SwitcherData *switcher;
|
|
class SwitcherThread : public QThread {
|
|
public:
|
|
explicit SwitcherThread(){};
|
|
void run() { switcher->Thread(); };
|
|
};
|