nosignal/nosignal-shell
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

internal: format cpp

Browse source
This commit is contained in:
2 * r + 2 * t 2025-09-01 17:41:26 +10:00
parent 704db7b6a6
commit 8b1f2be27b
9 changed files with 307 additions and 251 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

22
.clang-format Normal file
View file

@ -0,0 +1,22 @@
---
BasedOnStyle: LLVM
IndentWidth: 4
ColumnLimit: 120
---
Language: Cpp
DerivePointerAlignment: false
PointerAlignment: Left
AccessModifierOffset: -4
AlignAfterOpenBracket: DontAlign
AllowShortEnumsOnASingleLine: false
AllowShortFunctionsOnASingleLine: Inline
AllowShortLambdasOnASingleLine: None
BinPackArguments: true
BreakBeforeBraces: Attach
BreakConstructorInitializers: BeforeComma
Cpp11BracedListStyle: false
EmptyLineAfterAccessModifier: Never
EmptyLineBeforeAccessModifier: Always
IndentAccessModifiers: false
IndentCaseLabels: false
...

5
.vscode/settings.json vendored
View file

@ -1,3 +1,6 @@
{
"editor.defaultFormatter": "theqtcompany.qt-qml"
"editor.defaultFormatter": "theqtcompany.qt-qml",
"[cpp]": {
"editor.defaultFormatter": "llvm-vs-code-extensions.vscode-clangd"
}
}

130
assets/cpp/beat-detector.cpp
View file

@ -1,20 +1,18 @@
#include <algorithm>
#include <atomic>
#include <aubio/aubio.h>
#include <chrono>
#include <csignal>
#include <cstring>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <memory>
#include <pipewire/pipewire.h>
#include <spa/param/audio/format-utils.h>
#include <spa/param/props.h>
#include <aubio/aubio.h>
#include <memory>
#include <iostream>
#include <fstream>
#include <csignal>
#include <atomic>
#include <vector>
#include <cstring>
#include <chrono>
#include <iomanip>
#include <sstream>
#include <thread>
#include <cmath>
#include <vector>
class EnhancedBeatDetector {
private:
@ -65,15 +63,18 @@ private:
// Useless Visual feedback
std::string generate_beat_visual(float bpm, bool is_beat) {
if (!enable_visual_feedback_) return "";
if (!enable_visual_feedback_)
return "";
std::stringstream ss;
if (is_beat) {
// Useless Animated beat indicator based on BPM intensity
int intensity = static_cast<int>(std::min(bpm / 20.0f, 10.0f));
ss << "\r";
for (int i = 0; i < intensity; ++i) ss << "█";
for (int i = intensity; i < 10; ++i) ss << "░";
for (int i = 0; i < intensity; ++i)
ss << "█";
for (int i = intensity; i < 10; ++i)
ss << "░";
ss << " BPM: " << std::fixed << std::setprecision(1) << bpm;
ss << " | Avg: " << get_average_bpm();
}
@ -81,11 +82,8 @@ private:
}
public:
explicit EnhancedBeatDetector(uint32_t buf_size = 512,
bool enable_logging = true,
bool enable_performance_stats = true,
bool enable_pitch_detection = false,
bool enable_visual_feedback = true)
explicit EnhancedBeatDetector(uint32_t buf_size = 512, bool enable_logging = true,
bool enable_performance_stats = true, bool enable_pitch_detection = false, bool enable_visual_feedback = true)
: main_loop_(nullptr)
, context_(nullptr)
, core_(nullptr)
@ -104,8 +102,7 @@ public:
, enable_visual_feedback_(enable_visual_feedback)
, total_beats_(0)
, total_onsets_(0)
, last_bpm_(0.0f)
{
, last_bpm_(0.0f) {
instance_ = this;
recent_bpms_.reserve(BPM_HISTORY_SIZE);
if (enable_performance_stats_) {
@ -135,7 +132,8 @@ public:
filename << "beat_log_" << std::put_time(std::localtime(&time_t), "%Y%m%d_%H%M%S") << ".txt";
log_file_.open(filename.str());
if (log_file_.is_open()) {
log_file_ << "# Beat Detection Log - " << std::put_time(std::localtime(&time_t), "%Y-%m-%d %H:%M:%S") << "\n";
log_file_ << "# Beat Detection Log - " << std::put_time(std::localtime(&time_t), "%Y-%m-%d %H:%M:%S")
<< "\n";
log_file_ << "# Timestamp,BPM,Onset,Pitch(Hz),ProcessTime(ms)\n";
std::cout << " Logging to: " << filename.str() << std::endl;
}
@ -199,7 +197,8 @@ public:
}
void run() {
if (!main_loop_) return;
if (!main_loop_)
return;
print_startup_info();
pw_main_loop_run(main_loop_);
@ -232,7 +231,8 @@ private:
}
void print_final_stats() {
if (!enable_performance_stats_) return;
if (!enable_performance_stats_)
return;
auto end_time = std::chrono::steady_clock::now();
auto duration = std::chrono::duration_cast<std::chrono::seconds>(end_time - start_time_);
@ -244,14 +244,15 @@ private:
if (!process_times_.empty()) {
double avg_time = 0;
for (double t : process_times_) avg_time += t;
for (double t : process_times_)
avg_time += t;
avg_time /= process_times_.size();
auto max_time = *std::max_element(process_times_.begin(), process_times_.end());
auto min_time = *std::min_element(process_times_.begin(), process_times_.end());
std::cout << " ⚡ Average processing time: " << std::fixed << std::setprecision(3)
<< avg_time << " ms" << std::endl;
std::cout << " ⚡ Average processing time: " << std::fixed << std::setprecision(3) << avg_time << " ms"
<< std::endl;
std::cout << " 📈 Max processing time: " << max_time << " ms" << std::endl;
std::cout << " 📉 Min processing time: " << min_time << " ms" << std::endl;
}
@ -262,9 +263,11 @@ private:
}
float get_average_bpm() const {
if (recent_bpms_.empty()) return 0.0f;
if (recent_bpms_.empty())
return 0.0f;
float sum = 0;
for (float bpm : recent_bpms_) sum += bpm;
for (float bpm : recent_bpms_)
sum += bpm;
return sum / recent_bpms_.size();
}
@ -285,18 +288,10 @@ private:
.trigger_done = nullptr,
};
stream_ = pw_stream_new_simple(
pw_main_loop_get_loop(main_loop_),
"enhanced-beat-detector",
stream_ = pw_stream_new_simple(pw_main_loop_get_loop(main_loop_), "enhanced-beat-detector",
pw_properties_new(
PW_KEY_MEDIA_TYPE, "Audio",
PW_KEY_MEDIA_CATEGORY, "Capture",
PW_KEY_MEDIA_ROLE, "Music",
nullptr
),
&stream_events,
this
);
PW_KEY_MEDIA_TYPE, "Audio", PW_KEY_MEDIA_CATEGORY, "Capture", PW_KEY_MEDIA_ROLE, "Music", nullptr),
&stream_events, this);
if (!stream_) {
std::cerr << " Failed to create stream" << std::endl;
@ -316,13 +311,9 @@ private:
const spa_pod* params[1];
params[0] = spa_format_audio_raw_build(&pod_builder, SPA_PARAM_EnumFormat, &audio_info);
if (pw_stream_connect(stream_,
PW_DIRECTION_INPUT,
PW_ID_ANY,
if (pw_stream_connect(stream_, PW_DIRECTION_INPUT, PW_ID_ANY,
static_cast<pw_stream_flags>(
PW_STREAM_FLAG_AUTOCONNECT |
PW_STREAM_FLAG_MAP_BUFFERS |
PW_STREAM_FLAG_RT_PROCESS),
PW_STREAM_FLAG_AUTOCONNECT | PW_STREAM_FLAG_MAP_BUFFERS | PW_STREAM_FLAG_RT_PROCESS),
params, 1) < 0) {
std::cerr << " Failed to connect stream" << std::endl;
return false;
@ -331,17 +322,27 @@ private:
return true;
}
static void on_state_changed(void* userdata, enum pw_stream_state /* old_state */,
enum pw_stream_state state, const char* error) {
static void on_state_changed(
void* userdata, enum pw_stream_state /* old_state */, enum pw_stream_state state, const char* error) {
auto* detector = static_cast<EnhancedBeatDetector*>(userdata);
const char* state_emoji = "󰑓 ";
switch (state) {
case PW_STREAM_STATE_CONNECTING: state_emoji = "󰄙 "; break;
case PW_STREAM_STATE_PAUSED: state_emoji = ""; break;
case PW_STREAM_STATE_STREAMING: state_emoji = "󰝚 "; break;
case PW_STREAM_STATE_ERROR: state_emoji = ""; break;
case PW_STREAM_STATE_UNCONNECTED: state_emoji = ""; break;
case PW_STREAM_STATE_CONNECTING:
state_emoji = "󰄙 ";
break;
case PW_STREAM_STATE_PAUSED:
state_emoji = "";
break;
case PW_STREAM_STATE_STREAMING:
state_emoji = "󰝚 ";
break;
case PW_STREAM_STATE_ERROR:
state_emoji = "";
break;
case PW_STREAM_STATE_UNCONNECTED:
state_emoji = "";
break;
}
std::cout << state_emoji << " Stream state: " << pw_stream_state_as_string(state) << std::endl;
@ -358,12 +359,14 @@ private:
}
void process_audio() {
if (should_quit_) return;
if (should_quit_)
return;
auto process_start = std::chrono::high_resolution_clock::now();
pw_buffer* buffer = pw_stream_dequeue_buffer(stream_);
if (!buffer) return;
if (!buffer)
return;
spa_buffer* spa_buf = buffer->buffer;
if (!spa_buf->datas[0].data) {
@ -419,14 +422,11 @@ private:
if (enable_logging_ && log_file_.is_open() && (is_beat || is_onset)) {
auto now = std::chrono::system_clock::now();
auto time_t = std::chrono::system_clock::to_time_t(now);
auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(
now.time_since_epoch()) % 1000;
auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch()) % 1000;
log_file_ << std::put_time(std::localtime(&time_t), "%H:%M:%S")
<< "." << std::setfill('0') << std::setw(3) << ms.count() << ","
<< (is_beat ? last_bpm_ : 0) << ","
<< (is_onset ? 1 : 0) << ","
<< pitch_hz << ",";
log_file_ << std::put_time(std::localtime(&time_t), "%H:%M:%S") << "." << std::setfill('0')
<< std::setw(3) << ms.count() << "," << (is_beat ? last_bpm_ : 0) << "," << (is_onset ? 1 : 0)
<< "," << pitch_hz << ",";
}
}
@ -550,8 +550,8 @@ int main(int argc, char* argv[]) {
std::signal(SIGTERM, EnhancedBeatDetector::signal_handler);
try {
EnhancedBeatDetector detector(buffer_size, enable_logging, enable_performance_stats,
enable_pitch_detection, enable_visual_feedback);
EnhancedBeatDetector detector(
buffer_size, enable_logging, enable_performance_stats, enable_pitch_detection, enable_visual_feedback);
detector.run();
} catch (const std::exception& e) {
std::cerr << " Error: " << e.what() << std::endl;

32
plugin/src/Caelestia/cachingimagemanager.cpp
View file

@ -1,14 +1,14 @@
#include "cachingimagemanager.hpp"
#include <QCryptographicHash>
#include <QDir>
#include <QFile>
#include <QImageReader>
#include <QObject>
#include <QPainter>
#include <QThreadPool>
#include <QtQuick/QQuickItem>
#include <QtQuick/QQuickWindow>
#include <QCryptographicHash>
#include <QThreadPool>
#include <QFile>
#include <QDir>
#include <QPainter>
#include <QImageReader>
qreal CachingImageManager::effectiveScale() const {
if (m_item && m_item->window()) {
@ -49,8 +49,12 @@ void CachingImageManager::setItem(QQuickItem* item) {
emit itemChanged();
if (item) {
m_widthConn = connect(item, &QQuickItem::widthChanged, this, [this]() { updateSource(); });
m_heightConn = connect(item, &QQuickItem::heightChanged, this, [this]() { updateSource(); });
m_widthConn = connect(item, &QQuickItem::widthChanged, this, [this]() {
updateSource();
});
m_heightConn = connect(item, &QQuickItem::heightChanged, this, [this]() {
updateSource();
});
updateSource();
}
}
@ -104,7 +108,9 @@ void CachingImageManager::updateSource(const QString& path) {
QThreadPool::globalInstance()->start([path, self] {
const QString sha = self->sha256sum(path);
QMetaObject::invokeMethod(self, [path, sha, self]() {
QMetaObject::invokeMethod(
self,
[path, sha, self]() {
if (!self || self->m_path != path) {
// Object is destroyed or path has changed, ignore
return;
@ -117,9 +123,11 @@ void CachingImageManager::updateSource(const QString& path) {
}
const QString fillMode = self->m_item->property("fillMode").toString();
// clang-format off
const QString filename = QString("%1@%2x%3-%4.png")
.arg(sha).arg(size.width()).arg(size.height())
.arg(fillMode == "PreserveAspectCrop" ? "crop" : fillMode == "PreserveAspectFit" ? "fit" : "stretch");
// clang-format on
const QUrl cache = self->m_cacheDir.resolved(QUrl(filename));
if (self->m_cachePath == cache) {
@ -146,7 +154,8 @@ void CachingImageManager::updateSource(const QString& path) {
if (self->m_shaPath == path) {
self->m_shaPath = QString();
}
}, Qt::QueuedConnection);
},
Qt::QueuedConnection);
});
}
@ -154,7 +163,8 @@ QUrl CachingImageManager::cachePath() const {
return m_cachePath;
}
void CachingImageManager::createCache(const QString& path, const QString& cache, const QString& fillMode, const QSize& size) const {
void CachingImageManager::createCache(
const QString& path, const QString& cache, const QString& fillMode, const QSize& size) const {
QThreadPool::globalInstance()->start([path, cache, fillMode, size] {
QImage image(path);

5
plugin/src/Caelestia/cachingimagemanager.hpp
View file

@ -1,8 +1,8 @@
#pragma once
#include <QtQuick/QQuickItem>
#include <qobject.h>
#include <qqmlintegration.h>
#include <QtQuick/QQuickItem>
class CachingImageManager : public QObject {
Q_OBJECT
@ -15,7 +15,8 @@ class CachingImageManager : public QObject {
Q_PROPERTY(QUrl cachePath READ cachePath NOTIFY cachePathChanged)
public:
explicit CachingImageManager(QObject* parent = nullptr): QObject(parent) {}
explicit CachingImageManager(QObject* parent = nullptr)
: QObject(parent) {}
[[nodiscard]] QQuickItem* item() const;
void setItem(QQuickItem* item);

66
plugin/src/Caelestia/cutils.cpp
View file

@ -1,12 +1,12 @@
#include "cutils.hpp"
#include <QDir>
#include <QObject>
#include <QtQuick/QQuickWindow>
#include <QQmlEngine>
#include <QThreadPool>
#include <QtQuick/QQuickItem>
#include <QtQuick/QQuickItemGrabResult>
#include <QThreadPool>
#include <QQmlEngine>
#include <QDir>
#include <QtQuick/QQuickWindow>
void CUtils::saveItem(QQuickItem* target, const QUrl& path) {
this->saveItem(target, path, QRect(), QJSValue(), QJSValue());
@ -47,7 +47,8 @@ void CUtils::saveItem(QQuickItem* target, const QUrl& path, const QRect& rect, Q
auto scaledRect = rect;
const qreal scale = target->window()->devicePixelRatio();
if (rect.isValid() && scale != 1.0) {
scaledRect = QRectF(rect.left() * scale, rect.top() * scale, rect.width() * scale, rect.height() * scale).toRect();
scaledRect =
QRectF(rect.left() * scale, rect.top() * scale, rect.width() * scale, rect.height() * scale).toRect();
}
const QSharedPointer<const QQuickItemGrabResult> grabResult = target->grabToImage();
@ -65,10 +66,13 @@ void CUtils::saveItem(QQuickItem* target, const QUrl& path, const QRect& rect, Q
const QString parent = QFileInfo(file).absolutePath();
const bool success = QDir().mkpath(parent) && image.save(file);
QMetaObject::invokeMethod(this, [file, success, path, onSaved, onFailed, this]() {
QMetaObject::invokeMethod(
this,
[file, success, path, onSaved, onFailed, this]() {
if (success) {
if (onSaved.isCallable()) {
onSaved.call({ QJSValue(file), qmlEngine(this)->toScriptValue(QVariant::fromValue(path)) });
onSaved.call(
{ QJSValue(file), qmlEngine(this)->toScriptValue(QVariant::fromValue(path)) });
}
} else {
qWarning() << "CUtils::saveItem: failed to save" << path;
@ -76,10 +80,10 @@ void CUtils::saveItem(QQuickItem* target, const QUrl& path, const QRect& rect, Q
onFailed.call({ qmlEngine(this)->toScriptValue(QVariant::fromValue(path)) });
}
}
}, Qt::QueuedConnection);
},
Qt::QueuedConnection);
});
});
}
);
}
bool CUtils::copyFile(const QUrl& source, const QUrl& target) const {
@ -120,21 +124,23 @@ void CUtils::getDominantColour(QQuickItem* item, int rescaleSize, QJSValue callb
const QSharedPointer<const QQuickItemGrabResult> grabResult = item->grabToImage();
QObject::connect(grabResult.data(), &QQuickItemGrabResult::ready, this,
[grabResult, rescaleSize, callback, this]() {
QObject::connect(
grabResult.data(), &QQuickItemGrabResult::ready, this, [grabResult, rescaleSize, callback, this]() {
const QImage image = grabResult->image();
QThreadPool::globalInstance()->start([grabResult, image, rescaleSize, callback, this]() {
const QColor color = this->findDominantColour(image, rescaleSize);
if (callback.isCallable()) {
QMetaObject::invokeMethod(this, [color, callback, this]() {
QMetaObject::invokeMethod(
this,
[color, callback, this]() {
callback.call({ qmlEngine(this)->toScriptValue(QVariant::fromValue(color)) });
}, Qt::QueuedConnection);
},
Qt::QueuedConnection);
}
});
}
);
});
}
void CUtils::getDominantColour(const QString& path, QJSValue callback) {
@ -158,9 +164,12 @@ void CUtils::getDominantColour(const QString& path, int rescaleSize, QJSValue ca
const QColor color = this->findDominantColour(image, rescaleSize);
if (callback.isCallable()) {
QMetaObject::invokeMethod(this, [color, callback, this]() {
QMetaObject::invokeMethod(
this,
[color, callback, this]() {
callback.call({ qmlEngine(this)->toScriptValue(QVariant::fromValue(color)) });
}, Qt::QueuedConnection);
},
Qt::QueuedConnection);
}
});
}
@ -234,21 +243,23 @@ void CUtils::getAverageLuminance(QQuickItem* item, int rescaleSize, QJSValue cal
const QSharedPointer<const QQuickItemGrabResult> grabResult = item->grabToImage();
QObject::connect(grabResult.data(), &QQuickItemGrabResult::ready, this,
[grabResult, rescaleSize, callback, this]() {
QObject::connect(
grabResult.data(), &QQuickItemGrabResult::ready, this, [grabResult, rescaleSize, callback, this]() {
const QImage image = grabResult->image();
QThreadPool::globalInstance()->start([grabResult, image, rescaleSize, callback, this]() {
const qreal luminance = this->findAverageLuminance(image, rescaleSize);
if (callback.isCallable()) {
QMetaObject::invokeMethod(this, [luminance, callback]() {
QMetaObject::invokeMethod(
this,
[luminance, callback]() {
callback.call({ QJSValue(luminance) });
}, Qt::QueuedConnection);
},
Qt::QueuedConnection);
}
});
}
);
});
}
void CUtils::getAverageLuminance(const QString& path, QJSValue callback) {
@ -272,9 +283,12 @@ void CUtils::getAverageLuminance(const QString& path, int rescaleSize, QJSValue
const qreal luminance = this->findAverageLuminance(image, rescaleSize);
if (callback.isCallable()) {
QMetaObject::invokeMethod(this, [luminance, callback]() {
QMetaObject::invokeMethod(
this,
[luminance, callback]() {
callback.call({ QJSValue(luminance) });
}, Qt::QueuedConnection);
},
Qt::QueuedConnection);
}
});
}

5
plugin/src/Caelestia/cutils.hpp
View file

@ -1,8 +1,8 @@
#pragma once
#include <QtQuick/QQuickItem>
#include <qobject.h>
#include <qqmlintegration.h>
#include <QtQuick/QQuickItem>
class CUtils : public QObject {
Q_OBJECT
@ -15,7 +15,8 @@ public:
Q_INVOKABLE void saveItem(QQuickItem* target, const QUrl& path, QJSValue onSaved);
Q_INVOKABLE void saveItem(QQuickItem* target, const QUrl& path, QJSValue onSaved, QJSValue onFailed);
Q_INVOKABLE void saveItem(QQuickItem* target, const QUrl& path, const QRect& rect, QJSValue onSaved);
Q_INVOKABLE void saveItem(QQuickItem* target, const QUrl& path, const QRect& rect, QJSValue onSaved, QJSValue onFailed);
Q_INVOKABLE void saveItem(
QQuickItem* target, const QUrl& path, const QRect& rect, QJSValue onSaved, QJSValue onFailed);
Q_INVOKABLE bool copyFile(const QUrl& source, const QUrl& target) const;
Q_INVOKABLE bool copyFile(const QUrl& source, const QUrl& target, bool overwrite) const;

6
plugin/src/Caelestia/filesystemmodel.cpp
View file

@ -1,12 +1,12 @@
#include "filesystemmodel.hpp"
#include <QObject>
#include <qqmlintegration.h>
#include <QAbstractListModel>
#include <QFileInfo>
#include <QDir>
#include <QDirIterator>
#include <QFileInfo>
#include <QImageReader>
#include <QObject>
#include <qqmlintegration.h>
int FileSystemModel::rowCount(const QModelIndex& parent) const {
if (parent != QModelIndex()) {

19
plugin/src/Caelestia/filesystemmodel.hpp
View file

@ -1,12 +1,12 @@
#pragma once
#include <QAbstractListModel>
#include <QDir>
#include <QFileInfo>
#include <QFileSystemWatcher>
#include <QImageReader>
#include <QObject>
#include <qqmlintegration.h>
#include <QAbstractListModel>
#include <QFileSystemWatcher>
#include <QFileInfo>
#include <QDir>
#include <QImageReader>
class FileSystemEntry : public QObject {
Q_OBJECT
@ -23,7 +23,10 @@ class FileSystemEntry : public QObject {
public:
explicit FileSystemEntry(const QString& path, const QString& relativePath, QObject* parent = nullptr)
: QObject(parent), m_fileInfo(QFileInfo(path)), m_path(path), m_relativePath(relativePath) {}
: QObject(parent)
, m_fileInfo(QFileInfo(path))
, m_path(path)
, m_relativePath(relativePath) {}
QString path() const { return m_path; };
QString relativePath() const { return m_relativePath; };
@ -71,7 +74,9 @@ public:
Q_ENUM(Filter)
explicit FileSystemModel(QObject* parent = nullptr)
: QAbstractListModel(parent), m_recursive(true), m_filter(NoFilter) {
: QAbstractListModel(parent)
, m_recursive(true)
, m_filter(NoFilter) {
connect(&m_watcher, &QFileSystemWatcher::directoryChanged, this, &FileSystemModel::watchDirIfRecursive);
connect(&m_watcher, &QFileSystemWatcher::directoryChanged, this, &FileSystemModel::updateEntries);
}