plugin: use qt typedefs for fixed ints

3 files changed, 30 insertions, 32 deletions

diff --git a/plugin/src/Caelestia/audiocollector.cpp b/plugin/src/Caelestia/audiocollector.cpp
index 04d609c..9dc3871 100644
--- a/plugin/src/Caelestia/audiocollector.cpp
+++ b/plugin/src/Caelestia/audiocollector.cpp
@@ -2,7 +2,6 @@
 
 #include "service.hpp"
 #include <algorithm>
-#include <cstdint>
 #include <pipewire/pipewire.h>
 #include <qdebug.h>
 #include <qmutex.h>
@@ -45,7 +44,7 @@ PipeWireWorker::PipeWireWorker(std::stop_token token, AudioCollector* collector)
 
     std::vector<uint8_t> buffer(collector->chunkSize());
     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{};
     info.format = SPA_AUDIO_FORMAT_S16;
@@ -136,12 +135,12 @@ void PipeWireWorker::processStream() {
     }
 
     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) {
         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);
 
     pw_stream_queue_buffer(m_stream, buffer);
@@ -177,20 +176,20 @@ AudioCollector::~AudioCollector() {
     stop();
 }
 
-uint32_t AudioCollector::sampleRate() const {
+quint32 AudioCollector::sampleRate() const {
     return m_sampleRate;
 }
 
-uint32_t AudioCollector::chunkSize() const {
+quint32 AudioCollector::chunkSize() const {
     return m_chunkSize;
 }
 
-uint32_t AudioCollector::nodeId() {
+quint32 AudioCollector::nodeId() {
     QMutexLocker locker(&m_nodeIdMutex);
     return m_nodeId;
 }
 
-void AudioCollector::setNodeId(uint32_t nodeId) {
+void AudioCollector::setNodeId(quint32 nodeId) {
     {
         QMutexLocker locker(&m_nodeIdMutex);
 
@@ -216,13 +215,13 @@ void AudioCollector::clearBuffer() {
     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) {
         count = m_chunkSize;
     }
 
     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;
     });
 
@@ -230,7 +229,7 @@ void AudioCollector::loadChunk(const int16_t* samples, uint32_t count) {
     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) {
         count = m_chunkSize;
     }
@@ -241,7 +240,7 @@ uint32_t AudioCollector::readChunk(float* out, uint32_t 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) {
         count = m_chunkSize;
     }
diff --git a/plugin/src/Caelestia/audiocollector.hpp b/plugin/src/Caelestia/audiocollector.hpp
index ecfae09..74b0877 100644
--- a/plugin/src/Caelestia/audiocollector.hpp
+++ b/plugin/src/Caelestia/audiocollector.hpp
@@ -2,7 +2,6 @@
 
 #include "service.hpp"
 #include <atomic>
-#include <cstdint>
 #include <pipewire/pipewire.h>
 #include <qmutex.h>
 #include <qqmlintegration.h>
@@ -35,7 +34,7 @@ private:
     static void handleTimeout(void* data, uint64_t expirations);
     void streamStateChanged(pw_stream_state state);
     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);
 };
@@ -44,22 +43,22 @@ class AudioCollector : public Service {
     Q_OBJECT
     QML_ELEMENT
 
-    Q_PROPERTY(uint32_t nodeId READ nodeId WRITE setNodeId NOTIFY nodeIdChanged)
+    Q_PROPERTY(quint32 nodeId READ nodeId WRITE setNodeId NOTIFY nodeIdChanged)
 
 public:
     explicit AudioCollector(QObject* parent = nullptr);
     ~AudioCollector();
 
-    [[nodiscard]] uint32_t sampleRate() const;
-    [[nodiscard]] uint32_t chunkSize() const;
+    [[nodiscard]] quint32 sampleRate() const;
+    [[nodiscard]] quint32 chunkSize() const;
 
-    [[nodiscard]] uint32_t nodeId();
-    void setNodeId(uint32_t nodeId);
+    [[nodiscard]] quint32 nodeId();
+    void setNodeId(quint32 nodeId);
 
     void clearBuffer();
-    void loadChunk(const int16_t* samples, uint32_t count);
-    uint32_t readChunk(float* out, uint32_t count = 0);
-    uint32_t readChunk(double* out, uint32_t count = 0);
+    void loadChunk(const qint16* samples, quint32 count);
+    quint32 readChunk(float* out, quint32 count = 0);
+    quint32 readChunk(double* out, quint32 count = 0);
 
 signals:
     void sampleRateChanged();
@@ -67,9 +66,9 @@ signals:
     void nodeIdChanged();
 
 private:
-    const uint32_t m_sampleRate;
-    const uint32_t m_chunkSize;
-    uint32_t m_nodeId;
+    const quint32 m_sampleRate;
+    const quint32 m_chunkSize;
+    quint32 m_nodeId;
     QMutex m_nodeIdMutex;
 
     std::jthread m_thread;
@@ -77,7 +76,7 @@ private:
     std::vector<float> m_buffer2;
     std::atomic<std::vector<float>*> m_readBuffer;
     std::atomic<std::vector<float>*> m_writeBuffer;
-    uint32_t m_sampleCount;
+    quint32 m_sampleCount;
 
     void reload();
     void start() override;
diff --git a/plugin/src/Caelestia/cutils.cpp b/plugin/src/Caelestia/cutils.cpp
index 0e0ded5..5608eeb 100644
--- a/plugin/src/Caelestia/cutils.cpp
+++ b/plugin/src/Caelestia/cutils.cpp
@@ -191,7 +191,7 @@ QColor CUtils::findDominantColour(const QImage& image, int rescaleSize) const {
         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 int width = img.width();
     const int height = img.height();
@@ -206,16 +206,16 @@ QColor CUtils::findDominantColour(const QImage& image, int rescaleSize) const {
                 continue;
             }
 
-            uint32_t r = static_cast<uint32_t>(pixel[0] & 0xF8);
-            uint32_t g = static_cast<uint32_t>(pixel[1] & 0xF8);
-            uint32_t b = static_cast<uint32_t>(pixel[2] & 0xF8);
+            quint32 r = static_cast<quint32>(pixel[0] & 0xF8);
+            quint32 g = static_cast<quint32>(pixel[1] & 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];
         }
     }
 
-    uint32_t dominantColour = 0;
+    quint32 dominantColour = 0;
     int maxCount = 0;
     for (const auto& [colour, count] : colours) {
         if (count > maxCount) {