DLSS 5 Neural Rendering for Images & Video with Frame Generation, RTX Video Super Resolution, HDR, and Color Grading
TypeScript ai-upscalingdlssdlss-5dlss5dlssgframe-generationframe-interpolationimage-enhancementimage-upscalingneural-renderingnvidianvidia-dlss-5nvidia-rtxrtx-videortx-video-super-resolutionvideo-enhancementvideo-upscaling
#include "paths.hpp"
#include "media/resolution.hpp"
#include <QDir>
#include <QDirIterator>
#include <QFileInfo>
#include <QSet>
#include <QUrl>
#include <QStandardPaths>
#include <algorithm>
#include <stdexcept>
#include <windows.h>
namespace ve {
Paths::Paths() {
root = qEnvironmentVariable("VE_APP_ROOT");
if (root.isEmpty()) {
wchar_t executable[32768]{};
const DWORD length = GetModuleFileNameW(nullptr, executable, DWORD(std::size(executable)));
if (!length || length >= std::size(executable))
throw std::runtime_error("Cannot locate the application executable.");
// The deployed executables live beside their resources. Development
// helpers may select a deployed resource tree with VE_APP_ROOT.
root = QFileInfo(QString::fromWCharArray(executable, int(length))).absolutePath();
}
root = QDir::cleanPath(QFileInfo(root).absoluteFilePath());
}
const Paths& Paths::instance() {
static Paths paths;
return paths;
}
QString Paths::at(const QString& relative) const {
return QDir(root).filePath(relative);
}
QString Paths::ffmpeg() const {
return at("bin/ffmpeg/bin/ffmpeg.exe");
}
QString Paths::ffprobe() const {
return at("bin/ffmpeg/bin/ffprobe.exe");
}
namespace {
QString writableDirectory(QStandardPaths::StandardLocation location, const QString& suffix = {}) {
const auto base = QStandardPaths::writableLocation(location);
if (base.isEmpty())
throw std::runtime_error("Cannot locate per-user application storage.");
const auto directory = suffix.isEmpty() ? base : QDir(base).filePath(suffix);
if (!QDir().mkpath(directory))
throw std::runtime_error(("Cannot create application storage: " + directory).toStdString());
return directory;
}
} // namespace
QString Paths::configurationFile() const {
return QDir(writableDirectory(QStandardPaths::AppConfigLocation)).filePath("config.ini");
}
QString Paths::cacheDirectory() const {
return writableDirectory(QStandardPaths::CacheLocation);
}
QString Paths::nativeDataDirectory() const {
// NGX requires a writable application-data argument, separate from DLL search paths.
return writableDirectory(QStandardPaths::AppLocalDataLocation, "NVIDIA");
}
void Paths::prepare() const {
configureImageDecoding();
for (const auto* relative : {"outputs", "logs"}) {
if (!QDir().mkpath(at(relative)))
throw std::runtime_error(("Cannot create application folder: " + at(relative)).toStdString());
}
}
QString localPath(const QString& urlOrPath) {
const QUrl url(urlOrPath);
return url.isLocalFile() ? url.toLocalFile() : urlOrPath;
}
bool isVideo(const QString& path) {
static const QSet<QString> extensions{"mp4", "mkv", "mov", "avi", "webm", "m4v",
"ts", "mts", "m2ts", "wmv", "flv"};
return extensions.contains(QFileInfo(path).suffix().toLower());
}
bool isImage(const QString& path) {
static const QSet<QString> extensions{
"png", "jpg", "jpeg", "webp", "avif", "tif", "tiff", "bmp", "heic", "heif", "svg", "gif", "3fr",
"arw", "bay", "cap", "cr2", "cr3", "dcr", "dcs", "dng", "drf", "eip", "erf", "fff", "gpr",
"iiq", "k25", "kdc", "mdc", "mef", "mos", "mrw", "nef", "nrw", "obm", "orf", "pef", "ptx",
"pxn", "r3d", "raf", "raw", "rw2", "rwl", "rwz", "sr2", "srf", "srw", "x3f"};
return extensions.contains(QFileInfo(path).suffix().toLower());
}
QStringList collectInputs(const QStringList& inputs, bool recursive, const QString& excluded) {
QStringList result;
QSet<QString> seen;
auto add = [&](const QString& path) {
const QFileInfo file(path);
if (!file.isFile() || (!isImage(path) && !isVideo(path)))
return;
auto absolute = file.canonicalFilePath();
if (absolute.isEmpty())
absolute = file.absoluteFilePath();
if (!excluded.isEmpty() && absolute.startsWith(excluded + '/', Qt::CaseInsensitive))
return;
const auto key = absolute.toCaseFolded();
if (!seen.contains(key)) {
seen.insert(key);
result.append(absolute);
}
};
for (const auto& input : inputs) {
const auto path = localPath(input);
const QFileInfo info(path);
if (info.isDir()) {
QDirIterator it(path, QDir::Files,
recursive ? QDirIterator::Subdirectories : QDirIterator::NoIteratorFlags);
while (it.hasNext())
add(it.next());
} else if (info.isFile())
add(path);
else if (path.contains('*') || path.contains('?')) {
QDir directory(info.absolutePath());
for (const auto& file : directory.entryInfoList({info.fileName()}, QDir::Files, QDir::Name))
add(file.absoluteFilePath());
}
}
std::ranges::sort(result,
[](const QString& a, const QString& b) { return a.toCaseFolded() < b.toCaseFolded(); });
return result;
}
QString uniqueOutputPath(const QString& path) {
if (!QFileInfo::exists(path))
return path;
const QFileInfo info(path);
for (int number = 2;; ++number) {
const auto candidate = info.dir().filePath(info.completeBaseName() + '_' + QString::number(number) +
'.' + info.suffix());
if (!QFileInfo::exists(candidate))
return candidate;
}
}
} // namespace ve