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

plugin: use qt typedefs for fixed ints

Browse source
This commit is contained in:
2 * r + 2 * t 2025-09-11 02:07:12 +10:00
parent 2832de18d7
commit 6f147b21cc
3 changed files with 30 additions and 32 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

23
plugin/src/Caelestia/audiocollector.cpp
View file

@ -2,7 +2,6 @@
#include "service.hpp" #include "service.hpp"
#include <algorithm> #include <algorithm>
#include <cstdint>
#include <pipewire/pipewire.h> #include <pipewire/pipewire.h>
#include <qdebug.h> #include <qdebug.h>
#include <qmutex.h> #include <qmutex.h>
@ -45,7 +44,7 @@ PipeWireWorker::PipeWireWorker(std::stop_token token, AudioCollector* collector)
std::vector<uint8_t> buffer(collector->chunkSize()); std::vector<uint8_t> buffer(collector->chunkSize());
spa_pod_builder b; spa_pod_builder b;
spa_pod_builder_init(&b, buffer.data(), static_cast<uint32_t>(buffer.size())); spa_pod_builder_init(&b, buffer.data(), static_cast<quint32>(buffer.size()));
spa_audio_info_raw info{}; spa_audio_info_raw info{};
info.format = SPA_AUDIO_FORMAT_S16; info.format = SPA_AUDIO_FORMAT_S16;
@ -136,12 +135,12 @@ void PipeWireWorker::processStream() {
} }
const spa_buffer* buf = buffer->buffer; const spa_buffer* buf = buffer->buffer;
const int16_t* samples = reinterpret_cast<const int16_t*>(buf->datas[0].data); const qint16* samples = reinterpret_cast<const qint16*>(buf->datas[0].data);
if (samples == nullptr) { if (samples == nullptr) {
return; return;
} }
const uint32_t count = buf->datas[0].chunk->size / 2; const quint32 count = buf->datas[0].chunk->size / 2;
m_collector->loadChunk(samples, count); m_collector->loadChunk(samples, count);
pw_stream_queue_buffer(m_stream, buffer); pw_stream_queue_buffer(m_stream, buffer);
@ -177,20 +176,20 @@ AudioCollector::~AudioCollector() {
stop(); stop();
} }
uint32_t AudioCollector::sampleRate() const { quint32 AudioCollector::sampleRate() const {
return m_sampleRate; return m_sampleRate;
} }
uint32_t AudioCollector::chunkSize() const { quint32 AudioCollector::chunkSize() const {
return m_chunkSize; return m_chunkSize;
} }
uint32_t AudioCollector::nodeId() { quint32 AudioCollector::nodeId() {
QMutexLocker locker(&m_nodeIdMutex); QMutexLocker locker(&m_nodeIdMutex);
return m_nodeId; return m_nodeId;
} }
void AudioCollector::setNodeId(uint32_t nodeId) { void AudioCollector::setNodeId(quint32 nodeId) {
{ {
QMutexLocker locker(&m_nodeIdMutex); QMutexLocker locker(&m_nodeIdMutex);
@ -216,13 +215,13 @@ void AudioCollector::clearBuffer() {
m_writeBuffer.store(oldRead, std::memory_order_release); m_writeBuffer.store(oldRead, std::memory_order_release);
} }
void AudioCollector::loadChunk(const int16_t* samples, uint32_t count) { void AudioCollector::loadChunk(const qint16* samples, quint32 count) {
if (count > m_chunkSize) { if (count > m_chunkSize) {
count = m_chunkSize; count = m_chunkSize;
} }
auto* writeBuffer = m_writeBuffer.load(std::memory_order_relaxed); auto* writeBuffer = m_writeBuffer.load(std::memory_order_relaxed);
std::transform(samples, samples + count, writeBuffer->begin(), [](int16_t sample) { std::transform(samples, samples + count, writeBuffer->begin(), [](qint16 sample) {
return sample / 32768.0f; return sample / 32768.0f;
}); });
@ -230,7 +229,7 @@ void AudioCollector::loadChunk(const int16_t* samples, uint32_t count) {
m_writeBuffer.store(oldRead, std::memory_order_release); m_writeBuffer.store(oldRead, std::memory_order_release);
} }
uint32_t AudioCollector::readChunk(float* out, uint32_t count) { quint32 AudioCollector::readChunk(float* out, quint32 count) {
if (count == 0 || count > m_chunkSize) { if (count == 0 || count > m_chunkSize) {
count = m_chunkSize; count = m_chunkSize;
} }
@ -241,7 +240,7 @@ uint32_t AudioCollector::readChunk(float* out, uint32_t count) {
return count; return count;
} }
uint32_t AudioCollector::readChunk(double* out, uint32_t count) { quint32 AudioCollector::readChunk(double* out, quint32 count) {
if (count == 0 || count > m_chunkSize) { if (count == 0 || count > m_chunkSize) {
count = m_chunkSize; count = m_chunkSize;
} }

27
plugin/src/Caelestia/audiocollector.hpp
View file

@ -2,7 +2,6 @@
#include "service.hpp" #include "service.hpp"
#include <atomic> #include <atomic>
#include <cstdint>
#include <pipewire/pipewire.h> #include <pipewire/pipewire.h>
#include <qmutex.h> #include <qmutex.h>
#include <qqmlintegration.h> #include <qqmlintegration.h>
@ -35,7 +34,7 @@ private:
static void handleTimeout(void* data, uint64_t expirations); static void handleTimeout(void* data, uint64_t expirations);
void streamStateChanged(pw_stream_state state); void streamStateChanged(pw_stream_state state);
void processStream(); void processStream();
void processSamples(const int16_t* samples, uint32_t count); void processSamples(const qint16* samples, quint32 count);
[[nodiscard]] unsigned int nextPowerOf2(unsigned int n); [[nodiscard]] unsigned int nextPowerOf2(unsigned int n);
}; };
@ -44,22 +43,22 @@ class AudioCollector : public Service {
Q_OBJECT Q_OBJECT
QML_ELEMENT QML_ELEMENT
Q_PROPERTY(uint32_t nodeId READ nodeId WRITE setNodeId NOTIFY nodeIdChanged) Q_PROPERTY(quint32 nodeId READ nodeId WRITE setNodeId NOTIFY nodeIdChanged)
public: public:
explicit AudioCollector(QObject* parent = nullptr); explicit AudioCollector(QObject* parent = nullptr);
~AudioCollector(); ~AudioCollector();
[[nodiscard]] uint32_t sampleRate() const; [[nodiscard]] quint32 sampleRate() const;
[[nodiscard]] uint32_t chunkSize() const; [[nodiscard]] quint32 chunkSize() const;
[[nodiscard]] uint32_t nodeId(); [[nodiscard]] quint32 nodeId();
void setNodeId(uint32_t nodeId); void setNodeId(quint32 nodeId);
void clearBuffer(); void clearBuffer();
void loadChunk(const int16_t* samples, uint32_t count); void loadChunk(const qint16* samples, quint32 count);
uint32_t readChunk(float* out, uint32_t count = 0); quint32 readChunk(float* out, quint32 count = 0);
uint32_t readChunk(double* out, uint32_t count = 0); quint32 readChunk(double* out, quint32 count = 0);
signals: signals:
void sampleRateChanged(); void sampleRateChanged();
@ -67,9 +66,9 @@ signals:
void nodeIdChanged(); void nodeIdChanged();
private: private:
const uint32_t m_sampleRate; const quint32 m_sampleRate;
const uint32_t m_chunkSize; const quint32 m_chunkSize;
uint32_t m_nodeId; quint32 m_nodeId;
QMutex m_nodeIdMutex; QMutex m_nodeIdMutex;
std::jthread m_thread; std::jthread m_thread;
@ -77,7 +76,7 @@ private:
std::vector<float> m_buffer2; std::vector<float> m_buffer2;
std::atomic<std::vector<float>*> m_readBuffer; std::atomic<std::vector<float>*> m_readBuffer;
std::atomic<std::vector<float>*> m_writeBuffer; std::atomic<std::vector<float>*> m_writeBuffer;
uint32_t m_sampleCount; quint32 m_sampleCount;
void reload(); void reload();
void start() override; void start() override;

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

@ -191,7 +191,7 @@ QColor CUtils::findDominantColour(const QImage& image, int rescaleSize) const {
img = img.convertToFormat(QImage::Format_ARGB32); img = img.convertToFormat(QImage::Format_ARGB32);
} }
std::unordered_map<uint32_t, int> colours; std::unordered_map<quint32, int> colours;
const uchar* data = img.bits(); const uchar* data = img.bits();
const int width = img.width(); const int width = img.width();
const int height = img.height(); const int height = img.height();
@ -206,16 +206,16 @@ QColor CUtils::findDominantColour(const QImage& image, int rescaleSize) const {
continue; continue;
} }
uint32_t r = static_cast<uint32_t>(pixel[0] & 0xF8); quint32 r = static_cast<quint32>(pixel[0] & 0xF8);
uint32_t g = static_cast<uint32_t>(pixel[1] & 0xF8); quint32 g = static_cast<quint32>(pixel[1] & 0xF8);
uint32_t b = static_cast<uint32_t>(pixel[2] & 0xF8); quint32 b = static_cast<quint32>(pixel[2] & 0xF8);
uint32_t colour = (r << 16) | (g << 8) | b; quint32 colour = (r << 16) | (g << 8) | b;
++colours[colour]; ++colours[colour];
} }
} }
uint32_t dominantColour = 0; quint32 dominantColour = 0;
int maxCount = 0; int maxCount = 0;
for (const auto& [colour, count] : colours) { for (const auto& [colour, count] : colours) {
if (count > maxCount) { if (count > maxCount) {