646 lines
18 KiB
C++
646 lines
18 KiB
C++
#include "mainwindow.h"
|
|
#include "imageselector.h"
|
|
#include "imageswitcher.h"
|
|
#include "pathtraverser.h"
|
|
#include "immichpathtraverser.h"
|
|
#include "mqttcontroller.h"
|
|
#include "overlay.h"
|
|
#include "appconfig.h"
|
|
#include "logger.h"
|
|
|
|
#include <QApplication>
|
|
#include <QRegularExpression>
|
|
#include <iostream>
|
|
#include <sys/file.h>
|
|
#include <errno.h>
|
|
|
|
#include <getopt.h>
|
|
#include <unistd.h>
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <memory>
|
|
#include <QJsonDocument>
|
|
#include <QJsonObject>
|
|
#include <QJsonArray>
|
|
|
|
void usage(std::string programName) {
|
|
std::cerr << "Usage: " << programName << " [-t rotation_seconds] [-T transition_seconds] [-h/--overlay-color #rrggbb] [-a aspect('l','p','a', 'm')] [-o background_opacity(0..255)] [-b blur_radius] -p image_folder [-r] [-s] [-S] [-v] [--verbose] [--stretch] [-c config_file_path]" << std::endl;
|
|
}
|
|
|
|
bool parseCommandLine(AppConfig &appConfig, int argc, char *argv[]) {
|
|
int opt;
|
|
int debugInt = 0;
|
|
int stretchInt = 0;
|
|
static struct option long_options[] =
|
|
{
|
|
{"verbose", no_argument, &debugInt, 1},
|
|
{"stretch", no_argument, &stretchInt, 1},
|
|
{"overlay-color", required_argument, 0, 'h'},
|
|
};
|
|
int option_index = 0;
|
|
while ((opt = getopt_long(argc, argv, "b:p:t:T:o:O:a:i:c:h:rsSv", long_options, &option_index)) != -1) {
|
|
switch (opt) {
|
|
case 0:
|
|
/* If this option set a flag, do nothing else now. */
|
|
if (long_options[option_index].flag != 0)
|
|
break;
|
|
return false;
|
|
break;
|
|
case 'p':
|
|
if(appConfig.paths.count() == 0)
|
|
appConfig.paths.append(PathEntry());
|
|
appConfig.paths[0].path = optarg;
|
|
break;
|
|
case 'a':
|
|
if (appConfig.valid_aspects.find(optarg[0]) == std::string::npos)
|
|
{
|
|
std::cout << "Invalid Aspect option, defaulting to all" << std::endl;
|
|
appConfig.baseDisplayOptions.onlyAspect = ImageAspectScreenFilter_Any;
|
|
}
|
|
else
|
|
{
|
|
appConfig.baseDisplayOptions.onlyAspect = parseAspectFromString(optarg[0]);
|
|
}
|
|
break;
|
|
case 't':
|
|
appConfig.rotationSeconds = atoi(optarg);
|
|
break;
|
|
case 'T':
|
|
appConfig.transitionTime =atoi(optarg);
|
|
break;
|
|
case 'b':
|
|
appConfig.blurRadius = atoi(optarg);
|
|
break;
|
|
case 'o':
|
|
appConfig.backgroundOpacity = atoi(optarg);
|
|
break;
|
|
case 'r':
|
|
if(appConfig.paths.count() == 0)
|
|
appConfig.paths.append(PathEntry());
|
|
appConfig.paths[0].recursive = true;
|
|
break;
|
|
case 's':
|
|
if(appConfig.paths.count() == 0)
|
|
appConfig.paths.append(PathEntry());
|
|
appConfig.paths[0].shuffle = true;
|
|
std::cout << "Shuffle mode is on." << std::endl;
|
|
break;
|
|
case 'S':
|
|
if(appConfig.paths.count() == 0)
|
|
appConfig.paths.append(PathEntry());
|
|
appConfig.paths[0].sorted = true;
|
|
break;
|
|
case 'O':
|
|
appConfig.overlay = optarg;
|
|
break;
|
|
case 'h':
|
|
appConfig.overlayHexRGB = QString::fromStdString(optarg);
|
|
break;
|
|
case 'v':
|
|
appConfig.debugMode = true;
|
|
break;
|
|
case 'i':
|
|
if(appConfig.paths.count() == 0)
|
|
appConfig.paths.append(PathEntry());
|
|
appConfig.paths[0].imageList = optarg;
|
|
break;
|
|
case 'c':
|
|
appConfig.configPath = optarg;
|
|
break;
|
|
default: /* '?' */
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if(debugInt==1)
|
|
{
|
|
appConfig.debugMode = true;
|
|
}
|
|
if(stretchInt==1)
|
|
{
|
|
appConfig.baseDisplayOptions.fitAspectAxisToWindow = true;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void ConfigureWindowFromSettings(MainWindow &w, const AppConfig &appConfig)
|
|
{
|
|
if (appConfig.blurRadius>= 0)
|
|
{
|
|
w.setBlurRadius(appConfig.blurRadius);
|
|
}
|
|
|
|
if (appConfig.backgroundOpacity>= 0)
|
|
{
|
|
w.setBackgroundOpacity(appConfig.backgroundOpacity);
|
|
}
|
|
|
|
w.setTransitionTime(appConfig.transitionTime);
|
|
|
|
if (!appConfig.overlayHexRGB.isEmpty())
|
|
{
|
|
QRegularExpression hexRGBMatcher("^#([0-9A-Fa-f]{3}){1,2}$");
|
|
if(!hexRGBMatcher.match(appConfig.overlayHexRGB).hasMatch())
|
|
{
|
|
std::cout << "Error: hex rgb string expected. e.g. #FFFFFF or #FFF" << std::endl;
|
|
}
|
|
else
|
|
{
|
|
w.setOverlayHexRGB(appConfig.overlayHexRGB);
|
|
}
|
|
}
|
|
|
|
if (!appConfig.overlay.empty())
|
|
{
|
|
std::unique_ptr<Overlay> o = std::unique_ptr<Overlay>(new Overlay(appConfig.overlay));
|
|
w.setOverlay(o);
|
|
}
|
|
w.setDebugThumbnail(appConfig.debugThumbnail);
|
|
w.setBaseOptions(appConfig.baseDisplayOptions);
|
|
}
|
|
|
|
std::unique_ptr<ImageSelector> GetSelectorForConfig(const PathEntry& path)
|
|
{
|
|
std::unique_ptr<PathTraverser> pathTraverser;
|
|
if (path.immich.enabled)
|
|
{
|
|
pathTraverser = std::unique_ptr<PathTraverser>(new ImmichPathTraverser(path.immich));
|
|
}
|
|
else if (!path.imageList.empty())
|
|
{
|
|
pathTraverser = std::unique_ptr<PathTraverser>(new ImageListPathTraverser(path.imageList));
|
|
}
|
|
else if (path.recursive)
|
|
{
|
|
pathTraverser = std::unique_ptr<PathTraverser>(new RecursivePathTraverser(path.path));
|
|
}
|
|
else
|
|
{
|
|
pathTraverser = std::unique_ptr<PathTraverser>(new DefaultPathTraverser(path.path));
|
|
}
|
|
|
|
std::unique_ptr<ImageSelector> selector;
|
|
if (path.sorted)
|
|
{
|
|
selector = std::unique_ptr<ImageSelector>(new SortedImageSelector(pathTraverser));
|
|
}
|
|
else if (path.shuffle)
|
|
{
|
|
selector = std::unique_ptr<ImageSelector>(new ShuffleImageSelector(pathTraverser));
|
|
}
|
|
else
|
|
{
|
|
selector = std::unique_ptr<ImageSelector>(new RandomImageSelector(pathTraverser));
|
|
}
|
|
|
|
return selector;
|
|
}
|
|
|
|
std::unique_ptr<ImageSelector> GetSelectorForApp(const AppConfig& appConfig)
|
|
{
|
|
if(appConfig.paths.count()==1)
|
|
{
|
|
return GetSelectorForConfig(appConfig.paths[0]);
|
|
}
|
|
else
|
|
{
|
|
std::unique_ptr<ListImageSelector> listSelector(new ListImageSelector());
|
|
for(const auto &path : appConfig.paths)
|
|
{
|
|
auto selector = GetSelectorForConfig(path);
|
|
listSelector->AddImageSelector(selector, path.exclusive, path.baseDisplayOptions);
|
|
}
|
|
// new things
|
|
return listSelector;
|
|
}
|
|
}
|
|
|
|
|
|
void ReloadConfigIfNeeded(AppConfig &appConfig, MainWindow &w, ImageSwitcher *switcher)
|
|
{
|
|
if(appConfig.configPath.empty())
|
|
{
|
|
return;
|
|
}
|
|
|
|
QString jsonFile = getAppConfigFilePath(appConfig.configPath);
|
|
QDir directory;
|
|
if(!directory.exists(jsonFile))
|
|
{
|
|
return;
|
|
}
|
|
|
|
if(appConfig.loadTime < QFileInfo(jsonFile).lastModified())
|
|
{
|
|
AppConfig oldConfig = appConfig;
|
|
appConfig = loadAppConfiguration(appConfig);
|
|
|
|
ConfigureWindowFromSettings(w, appConfig);
|
|
if(appConfig.PathOptionsChanged(oldConfig))
|
|
{
|
|
std::unique_ptr<ImageSelector> selector = GetSelectorForApp(appConfig);
|
|
switcher->setImageSelector(selector);
|
|
}
|
|
|
|
switcher->setRotationTime(appConfig.rotationSeconds * 1000);
|
|
}
|
|
}
|
|
|
|
static bool ParseBooleanString(const QString &value, bool &outValue)
|
|
{
|
|
QString v = value.trimmed().toLower();
|
|
if (v == "true" || v == "1" || v == "yes" || v == "on")
|
|
{
|
|
outValue = true;
|
|
return true;
|
|
}
|
|
if (v == "false" || v == "0" || v == "no" || v == "off")
|
|
{
|
|
outValue = false;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static std::vector<std::string> SplitCsv(const QString &value)
|
|
{
|
|
std::vector<std::string> output;
|
|
QStringList parts = value.split(',', Qt::SkipEmptyParts);
|
|
for (const auto &part : parts)
|
|
{
|
|
QString trimmed = part.trimmed();
|
|
if (!trimmed.isEmpty())
|
|
output.push_back(trimmed.toStdString());
|
|
}
|
|
return output;
|
|
}
|
|
|
|
static bool ApplyImmichPayload(ImmichConfig &config, const QString &payload)
|
|
{
|
|
bool changed = false;
|
|
QString trimmed = payload.trimmed();
|
|
if (trimmed.isEmpty())
|
|
return false;
|
|
|
|
if (trimmed.startsWith("{"))
|
|
{
|
|
QJsonDocument doc = QJsonDocument::fromJson(trimmed.toUtf8());
|
|
if (!doc.isObject())
|
|
return false;
|
|
QJsonObject obj = doc.object();
|
|
|
|
if (obj.contains("albumId") && obj["albumId"].isString())
|
|
{
|
|
config.albumIds = { obj["albumId"].toString().toStdString() };
|
|
config.userId.clear();
|
|
config.allowedExtensions.clear();
|
|
changed = true;
|
|
}
|
|
if (obj.contains("albumIds") && obj["albumIds"].isArray())
|
|
{
|
|
config.albumIds.clear();
|
|
QJsonArray arr = obj["albumIds"].toArray();
|
|
for (const auto &value : arr)
|
|
{
|
|
if (value.isString())
|
|
config.albumIds.push_back(value.toString().toStdString());
|
|
}
|
|
config.userId.clear();
|
|
config.allowedExtensions.clear();
|
|
changed = true;
|
|
}
|
|
if (obj.contains("personId") && obj["personId"].isString())
|
|
{
|
|
config.personIds = { obj["personId"].toString().toStdString() };
|
|
config.userId.clear();
|
|
config.allowedExtensions.clear();
|
|
changed = true;
|
|
}
|
|
if (obj.contains("personIds") && obj["personIds"].isArray())
|
|
{
|
|
config.personIds.clear();
|
|
QJsonArray arr = obj["personIds"].toArray();
|
|
for (const auto &value : arr)
|
|
{
|
|
if (value.isString())
|
|
config.personIds.push_back(value.toString().toStdString());
|
|
}
|
|
config.userId.clear();
|
|
config.allowedExtensions.clear();
|
|
changed = true;
|
|
}
|
|
if (obj.contains("userId") && obj["userId"].isString())
|
|
{
|
|
config.userId = obj["userId"].toString().toStdString();
|
|
config.albumIds.clear();
|
|
config.personIds.clear();
|
|
config.allowedExtensions.clear();
|
|
changed = true;
|
|
}
|
|
if (obj.contains("ownerId") && obj["ownerId"].isString())
|
|
{
|
|
config.userId = obj["ownerId"].toString().toStdString();
|
|
config.albumIds.clear();
|
|
config.personIds.clear();
|
|
config.allowedExtensions.clear();
|
|
changed = true;
|
|
}
|
|
if (obj.contains("order") && obj["order"].isString())
|
|
{
|
|
config.order = obj["order"].toString().toStdString();
|
|
changed = true;
|
|
}
|
|
if (obj.contains("size") && obj["size"].isString())
|
|
{
|
|
config.size = obj["size"].toString().toStdString();
|
|
changed = true;
|
|
}
|
|
if (obj.contains("pageSize") && obj["pageSize"].isDouble())
|
|
{
|
|
config.pageSize = (int)obj["pageSize"].toDouble();
|
|
changed = true;
|
|
}
|
|
if (obj.contains("maxAssets") && obj["maxAssets"].isDouble())
|
|
{
|
|
config.maxAssets = (int)obj["maxAssets"].toDouble();
|
|
changed = true;
|
|
}
|
|
if (obj.contains("refreshSeconds") && obj["refreshSeconds"].isDouble())
|
|
{
|
|
config.refreshSeconds = (int)obj["refreshSeconds"].toDouble();
|
|
changed = true;
|
|
}
|
|
if (obj.contains("skipRetrySeconds") && obj["skipRetrySeconds"].isDouble())
|
|
{
|
|
config.skipRetrySeconds = (int)obj["skipRetrySeconds"].toDouble();
|
|
changed = true;
|
|
}
|
|
if (obj.contains("includeArchived"))
|
|
{
|
|
if (obj["includeArchived"].isBool())
|
|
{
|
|
config.includeArchived = obj["includeArchived"].toBool();
|
|
changed = true;
|
|
}
|
|
else if (obj["includeArchived"].isString())
|
|
{
|
|
bool parsed = false;
|
|
bool boolValue = false;
|
|
parsed = ParseBooleanString(obj["includeArchived"].toString(), boolValue);
|
|
if (parsed)
|
|
{
|
|
config.includeArchived = boolValue;
|
|
changed = true;
|
|
}
|
|
}
|
|
}
|
|
if (obj.contains("reset") && obj["reset"].isBool() && obj["reset"].toBool())
|
|
{
|
|
config.albumIds.clear();
|
|
config.personIds.clear();
|
|
config.userId.clear();
|
|
config.allowedExtensions.clear();
|
|
changed = true;
|
|
}
|
|
if (obj.contains("extensions") && obj["extensions"].isArray())
|
|
{
|
|
config.allowedExtensions.clear();
|
|
QJsonArray arr = obj["extensions"].toArray();
|
|
for (const auto &value : arr)
|
|
{
|
|
if (value.isString())
|
|
config.allowedExtensions.push_back(value.toString().toLower().toStdString());
|
|
}
|
|
changed = true;
|
|
}
|
|
if (obj.contains("allowedExtensions") && obj["allowedExtensions"].isArray())
|
|
{
|
|
config.allowedExtensions.clear();
|
|
QJsonArray arr = obj["allowedExtensions"].toArray();
|
|
for (const auto &value : arr)
|
|
{
|
|
if (value.isString())
|
|
config.allowedExtensions.push_back(value.toString().toLower().toStdString());
|
|
}
|
|
changed = true;
|
|
}
|
|
return changed;
|
|
}
|
|
|
|
QString key;
|
|
QString value;
|
|
int idx = trimmed.indexOf('=');
|
|
if (idx < 0)
|
|
idx = trimmed.indexOf(':');
|
|
if (idx < 0)
|
|
idx = trimmed.indexOf(' ');
|
|
|
|
if (idx >= 0)
|
|
{
|
|
key = trimmed.left(idx).trimmed().toLower();
|
|
value = trimmed.mid(idx + 1).trimmed();
|
|
}
|
|
else
|
|
{
|
|
key = trimmed.toLower();
|
|
}
|
|
|
|
if (key == "reset" || key == "clear" || key == "all")
|
|
{
|
|
config.albumIds.clear();
|
|
config.personIds.clear();
|
|
config.userId.clear();
|
|
config.allowedExtensions.clear();
|
|
return true;
|
|
}
|
|
if (key == "album" || key == "albumid")
|
|
{
|
|
config.albumIds = { value.toStdString() };
|
|
config.userId.clear();
|
|
config.allowedExtensions.clear();
|
|
return true;
|
|
}
|
|
if (key == "albums" || key == "albumids")
|
|
{
|
|
config.albumIds = SplitCsv(value);
|
|
config.userId.clear();
|
|
config.allowedExtensions.clear();
|
|
return true;
|
|
}
|
|
if (key == "person" || key == "personid")
|
|
{
|
|
config.personIds = { value.toStdString() };
|
|
config.userId.clear();
|
|
config.allowedExtensions.clear();
|
|
return true;
|
|
}
|
|
if (key == "persons" || key == "personids")
|
|
{
|
|
config.personIds = SplitCsv(value);
|
|
config.userId.clear();
|
|
config.allowedExtensions.clear();
|
|
return true;
|
|
}
|
|
if (key == "user" || key == "userid" || key == "ownerid")
|
|
{
|
|
config.userId = value.toStdString();
|
|
config.albumIds.clear();
|
|
config.personIds.clear();
|
|
config.allowedExtensions.clear();
|
|
return true;
|
|
}
|
|
if (key == "extensions" || key == "allowedextensions")
|
|
{
|
|
config.allowedExtensions = SplitCsv(value);
|
|
for (auto &ext : config.allowedExtensions)
|
|
{
|
|
for (auto &c : ext)
|
|
c = static_cast<char>(::tolower(c));
|
|
}
|
|
return true;
|
|
}
|
|
if (key == "order")
|
|
{
|
|
config.order = value.toStdString();
|
|
return true;
|
|
}
|
|
if (key == "size")
|
|
{
|
|
config.size = value.toStdString();
|
|
return true;
|
|
}
|
|
if (key == "includearchived")
|
|
{
|
|
bool boolValue = false;
|
|
if (ParseBooleanString(value, boolValue))
|
|
{
|
|
config.includeArchived = boolValue;
|
|
return true;
|
|
}
|
|
}
|
|
if (key == "pagesize")
|
|
{
|
|
bool ok = false;
|
|
int parsed = value.toInt(&ok);
|
|
if (ok)
|
|
{
|
|
config.pageSize = parsed;
|
|
return true;
|
|
}
|
|
}
|
|
if (key == "maxassets")
|
|
{
|
|
bool ok = false;
|
|
int parsed = value.toInt(&ok);
|
|
if (ok)
|
|
{
|
|
config.maxAssets = parsed;
|
|
return true;
|
|
}
|
|
}
|
|
if (key == "refreshseconds")
|
|
{
|
|
bool ok = false;
|
|
int parsed = value.toInt(&ok);
|
|
if (ok)
|
|
{
|
|
config.refreshSeconds = parsed;
|
|
return true;
|
|
}
|
|
}
|
|
if (key == "skipretryseconds")
|
|
{
|
|
bool ok = false;
|
|
int parsed = value.toInt(&ok);
|
|
if (ok)
|
|
{
|
|
config.skipRetrySeconds = parsed;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
int main(int argc, char *argv[])
|
|
{
|
|
QApplication a(argc, argv);
|
|
|
|
AppConfig commandLineAppConfig;
|
|
if (!parseCommandLine(commandLineAppConfig, argc, argv))
|
|
{
|
|
usage(argv[0]);
|
|
return 1;
|
|
}
|
|
|
|
AppConfig appConfig = loadAppConfiguration(commandLineAppConfig);
|
|
|
|
if (appConfig.paths.empty())
|
|
{
|
|
std::cout << "Error: Path expected." << std::endl;
|
|
usage(argv[0]);
|
|
return 1;
|
|
}
|
|
SetupLogger(appConfig.debugMode);
|
|
Log( "Rotation Time: ", appConfig.rotationSeconds );
|
|
Log( "Overlay input: ", appConfig.overlay );
|
|
|
|
MainWindow w;
|
|
ConfigureWindowFromSettings(w, appConfig);
|
|
w.show();
|
|
|
|
std::unique_ptr<ImageSelector> selector = GetSelectorForApp(appConfig);
|
|
|
|
ImageSwitcher switcher(w, appConfig.rotationSeconds * 1000, selector);
|
|
w.setImageSwitcher(&switcher);
|
|
std::function<void(MainWindow &w, ImageSwitcher *switcher)> reloader = [&appConfig](MainWindow &w, ImageSwitcher *switcher) { ReloadConfigIfNeeded(appConfig, w, switcher); };
|
|
switcher.setConfigFileReloader(reloader);
|
|
|
|
std::unique_ptr<MqttController> mqttController;
|
|
if (appConfig.mqtt.enabled)
|
|
{
|
|
mqttController = std::unique_ptr<MqttController>(new MqttController(appConfig.mqtt, &a));
|
|
QObject::connect(mqttController.get(), &MqttController::play, [&switcher]() { switcher.resume(); });
|
|
QObject::connect(mqttController.get(), &MqttController::pause, [&switcher]() { switcher.pause(); });
|
|
QObject::connect(mqttController.get(), &MqttController::nextImage, [&switcher]() { switcher.stepOnce(); });
|
|
QObject::connect(mqttController.get(), &MqttController::nextFolder, [&switcher]() {
|
|
if (!switcher.skipToNextFolder())
|
|
switcher.stepOnce();
|
|
});
|
|
QObject::connect(mqttController.get(), &MqttController::restart, [&appConfig, &switcher]() {
|
|
std::unique_ptr<ImageSelector> newSelector = GetSelectorForApp(appConfig);
|
|
switcher.restart(newSelector);
|
|
});
|
|
QObject::connect(mqttController.get(), &MqttController::immichControl, [&appConfig, &switcher](const QString &payload) {
|
|
bool updated = false;
|
|
for (int i = 0; i < appConfig.paths.count(); ++i)
|
|
{
|
|
if (!appConfig.paths[i].immich.enabled)
|
|
continue;
|
|
ImmichConfig newConfig = appConfig.paths[i].immich;
|
|
if (ApplyImmichPayload(newConfig, payload))
|
|
{
|
|
appConfig.paths[i].immich = newConfig;
|
|
updated = true;
|
|
}
|
|
}
|
|
if (updated)
|
|
{
|
|
Log("MQTT immich update applied.");
|
|
std::unique_ptr<ImageSelector> newSelector = GetSelectorForApp(appConfig);
|
|
switcher.setImageSelector(newSelector);
|
|
if (!switcher.isPaused())
|
|
switcher.scheduleImageUpdate();
|
|
}
|
|
else
|
|
{
|
|
Log("MQTT immich update ignored: ", payload.toStdString());
|
|
}
|
|
});
|
|
mqttController->start();
|
|
}
|
|
switcher.start();
|
|
return a.exec();
|
|
}
|