[multimedia/kwave] /: OverviewCache: replaced QUuid with qunt64 to speed up hash lookups
Thomas Eschenbacher <[email protected]>
| Newsgroups | gmane.comp.kde.cvs |
|---|---|
| Message-ID | <[email protected]> |
Git commit e0afc858feb6c5e0d3702df890b8f078f5c90331 by Thomas Eschenbacher.
Committed on 25/07/2026 at 12:56.
Pushed by eschenbacher into branch 'master'.
OverviewCache: replaced QUuid with qunt64 to speed up hash lookups
M +36 -36 libgui/OverViewCache.cpp
M +8 -9 libgui/OverViewCache.h
M +37 -37 libgui/SelectionTracker.cpp
M +11 -12 libgui/SelectionTracker.h
M +7 -7 libkwave/Signal.cpp
M +4 -5 libkwave/Signal.h
M +3 -3 libkwave/SignalManager.cpp
M +3 -3 libkwave/SignalManager.h
M +11 -3 libkwave/Track.cpp
M +4 -5 libkwave/Track.h
M +2 -2 libkwave/autotests/test_Track.cpp
M +2 -2 libkwave/undo/UndoDeleteTrack.cpp
M +1 -2 libkwave/undo/UndoDeleteTrack.h
M +11 -12 plugins/sonagram/SonagramPlugin.cpp
M +5 -5 plugins/sonagram/SonagramPlugin.h
https://invent.kde.org/multimedia/kwave/-/commit/e0afc858feb6c5e0d3702df890b8f078f5c90331
diff --git a/libgui/OverViewCache.cpp b/libgui/OverViewCache.cpp
index 136f925a..24e32be4 100644
--- a/libgui/OverViewCache.cpp
+++ b/libgui/OverViewCache.cpp
@@ -42,22 +42,22 @@ Kwave::OverViewCache::OverViewCache(Kwave::SignalManager &signal,
m_lock()
{
- connect(&m_selection, SIGNAL(sigTrackInserted(QUuid)),
- this, SLOT(slotTrackInserted(QUuid)));
- connect(&m_selection, SIGNAL(sigTrackDeleted(QUuid)),
- this, SLOT(slotTrackDeleted(QUuid)));
+ connect(&m_selection, SIGNAL(sigTrackInserted(quint64)),
+ this, SLOT(slotTrackInserted(quint64)));
+ connect(&m_selection, SIGNAL(sigTrackDeleted(qint64)),
+ this, SLOT(slotTrackDeleted(quint64)));
connect(&m_selection, SIGNAL(sigLengthChanged(sample_index_t)),
this, SLOT(slotLengthChanged(sample_index_t)));
connect(
&m_selection,
- SIGNAL(sigInvalidated(const QUuid*,sample_index_t,sample_index_t)),
+ SIGNAL(sigInvalidated(quint64,sample_index_t,sample_index_t)),
this,
- SLOT(slotInvalidated(const QUuid*,sample_index_t,sample_index_t))
+ SLOT(slotInvalidated(quint64,sample_index_t,sample_index_t))
);
// take over the initial list of tracks
- for (const QUuid &uuid : m_selection.allTracks())
- slotTrackInserted(uuid);
+ for (const quint64 uid : m_selection.allTracks())
+ slotTrackInserted(uid);
}
//***************************************************************************
@@ -85,17 +85,17 @@ void Kwave::OverViewCache::scaleUp()
if (shrink <= 1) return; // nothing to shrink, just ignore new scale
// loop over all tracks
- for (QHash<QUuid, QVector <CacheState> >::iterator
+ for (QHash<quint64, QVector <CacheState> >::iterator
it(m_state.begin()); it != m_state.end(); ++it)
{
- const QUuid &uuid = it.key();
+ const quint64 uid = it.key();
unsigned int dst = 0;
unsigned int count = CACHE_SIZE / shrink;
Q_ASSERT(count <= CACHE_SIZE);
// source pointers
- sample_t *smin = m_min[uuid].data();
- sample_t *smax = m_max[uuid].data();
+ sample_t *smin = m_min[uid].data();
+ sample_t *smax = m_max[uid].data();
CacheState *sstate = it.value().data();
// destination pointers
@@ -144,18 +144,18 @@ void Kwave::OverViewCache::scaleDown()
if (m_scale == new_scale) return;
m_scale = new_scale;
- invalidateCache(nullptr, 0, CACHE_SIZE - 1);
+ invalidateCache(0, 0, CACHE_SIZE - 1);
}
//***************************************************************************
-void Kwave::OverViewCache::invalidateCache(const QUuid *track_id,
+void Kwave::OverViewCache::invalidateCache(quint64 track_id,
unsigned int first,
unsigned int last)
{
if (track_id) {
// invalidate a single track
- Q_ASSERT(m_state.contains(*track_id));
- if (!m_state.contains(*track_id)) return;
+ Q_ASSERT(m_state.contains(track_id));
+ if (!m_state.contains(track_id)) return;
if (last >= CACHE_SIZE) last = CACHE_SIZE - 1;
@@ -164,20 +164,20 @@ void Kwave::OverViewCache::invalidateCache(const QUuid *track_id,
// first, last);
for (unsigned int pos = first; pos <= last; ++pos)
- m_state[*track_id][pos] = Invalid;
+ m_state[track_id][pos] = Invalid;
} else {
// invalidate all tracks
- for (QHash<QUuid, QVector <CacheState> >::const_iterator
+ for (QHash<quint64, QVector <CacheState> >::const_iterator
it(m_state.constBegin()); it != m_state.constEnd(); ++it)
{
- const QUuid &uuid = it.key();
- invalidateCache(&uuid, first, last);
+ const quint64 uid = it.key();
+ invalidateCache(uid, first, last);
}
}
}
//***************************************************************************
-void Kwave::OverViewCache::slotTrackInserted(const QUuid &track_id)
+void Kwave::OverViewCache::slotTrackInserted(quint64 track_id)
{
QMutexLocker lock(&m_lock);
@@ -200,13 +200,13 @@ void Kwave::OverViewCache::slotTrackInserted(const QUuid &track_id)
m_state.insert(track_id, state);
// mark the new cache content as invalid
- invalidateCache(&track_id, 0, CACHE_SIZE - 1);
+ invalidateCache(track_id, 0, CACHE_SIZE - 1);
emit changed();
}
//***************************************************************************
-void Kwave::OverViewCache::slotTrackDeleted(const QUuid &track_id)
+void Kwave::OverViewCache::slotTrackDeleted(quint64 track_id)
{
QMutexLocker lock(&m_lock);
@@ -218,7 +218,7 @@ void Kwave::OverViewCache::slotTrackDeleted(const QUuid &track_id)
}
//***************************************************************************
-void Kwave::OverViewCache::slotInvalidated(const QUuid *track_id,
+void Kwave::OverViewCache::slotInvalidated(quint64 track_id,
sample_index_t first,
sample_index_t last)
{
@@ -277,9 +277,9 @@ int Kwave::OverViewCache::getMinMax(int width, MinMaxArray &minmax)
width = static_cast<int>(minmax.count());
QVector<unsigned int> track_list;
- const QList<QUuid> selected_tracks = m_selection.allTracks();
+ const QList<quint64> selected_tracks = m_selection.allTracks();
for (unsigned int track : m_signal.allTracks())
- if (selected_tracks.contains(m_signal.uuidOfTrack(track)))
+ if (selected_tracks.contains(m_signal.uidOfTrack(track)))
track_list.append(track);
if (track_list.isEmpty())
return 0;
@@ -299,17 +299,17 @@ int Kwave::OverViewCache::getMinMax(int width, MinMaxArray &minmax)
unsigned int count = qBound<unsigned int>(
1, Kwave::toUint(length / m_scale), CACHE_SIZE);
- QUuid uuid = m_signal.uuidOfTrack(track_list[index]);
- if (uuid.isNull()) continue; // track has just been deleted
+ quint64 uid = m_signal.uidOfTrack(track_list[index]);
+ if (uid == 0) continue; // track has just been deleted
// check: maybe slotTrackInserted has not yet been called
// or slotTrackDeleted has just been called
- if (!m_state.contains(uuid))
+ if (!m_state.contains(uid))
continue;
- sample_t *min = m_min[uuid].data();
- sample_t *max = m_max[uuid].data();
- CacheState *state = m_state[uuid].data();
+ sample_t *min = m_min[uid].data();
+ sample_t *max = m_max[uid].data();
+ CacheState *state = m_state[uid].data();
Q_ASSERT(min && max && state);
Kwave::SampleReader *reader = src[index];
Q_ASSERT(reader);
@@ -346,12 +346,12 @@ int Kwave::OverViewCache::getMinMax(int width, MinMaxArray &minmax)
sample_t maximum = SAMPLE_MIN;
for (; index <= last_index; ++index) {
// loop over all tracks
- for (QHash<QUuid, QVector <CacheState> >::const_iterator
+ for (QHash<quint64, QVector <CacheState> >::const_iterator
it(m_state.constBegin()); it != m_state.constEnd(); ++it)
{
- const QUuid &uuid = it.key();
- sample_t *min = m_min[uuid].data();
- sample_t *max = m_max[uuid].data();
+ const quint64 uid = it.key();
+ sample_t *min = m_min[uid].data();
+ sample_t *max = m_max[uid].data();
const CacheState *state = it.value().constData();
Q_ASSERT(state);
if (!state) continue;
diff --git a/libgui/OverViewCache.h b/libgui/OverViewCache.h
index 49b27e70..a9619c97 100644
--- a/libgui/OverViewCache.h
+++ b/libgui/OverViewCache.h
@@ -27,7 +27,6 @@
#include <QList>
#include <QObject>
#include <QRecursiveMutex>
-#include <QUuid>
#include <QVector>
#include "libkwave/Sample.h"
@@ -111,14 +110,14 @@ namespace Kwave
* @param track_id unique ID of the track
* @see SelectionTracker::sigTrackInserted
*/
- void slotTrackInserted(const QUuid &track_id);
+ void slotTrackInserted(quint64 track_id);
/**
* Connected to the selection tracker's sigTrackInserted.
* @param track_id unique ID of the track
* @see SelectionTracker::sigTrackDeleted
*/
- void slotTrackDeleted(const QUuid &track_id);
+ void slotTrackDeleted(quint64 track_id);
/**
* Connected to the selection tracker's sigLengthChanged.
@@ -129,11 +128,11 @@ namespace Kwave
/**
* Connected to the selection tracker's sigInvalidated.
- * @param track_id UUID of the track or null for "all tracks"
+ * @param track_id UUID of the track or zero for "all tracks"
* @param first index of the first invalidated sample
* @param last index of the last invalidated sample
*/
- void slotInvalidated(const QUuid *track_id,
+ void slotInvalidated(quint64 track_id,
sample_index_t first,
sample_index_t last);
@@ -168,7 +167,7 @@ namespace Kwave
* @param last index of the last entry
* (will be truncated to CACHE_SIZE-1)
*/
- void invalidateCache(const QUuid *uuid,
+ void invalidateCache(quint64 uuid,
unsigned int first,
unsigned int last);
@@ -181,13 +180,13 @@ namespace Kwave
Kwave::SelectionTracker m_selection;
/** list of minimum value arrays, one array per track */
- QHash<QUuid, QVector <sample_t> > m_min;
+ QHash<quint64, QVector <sample_t> > m_min;
/** list of maximum value arrays, one array per track */
- QHash<QUuid, QVector <sample_t> > m_max;
+ QHash<quint64, QVector <sample_t> > m_max;
/** bitmask for "validity" of the min/max values */
- QHash<QUuid, QVector <CacheState> > m_state;
+ QHash<quint64, QVector <CacheState> > m_state;
/** list of min/max pairs, cached internally for getOverView */
MinMaxArray m_minmax;
diff --git a/libgui/SelectionTracker.cpp b/libgui/SelectionTracker.cpp
index 4301ee4b..d2a578f6 100644
--- a/libgui/SelectionTracker.cpp
+++ b/libgui/SelectionTracker.cpp
@@ -72,14 +72,14 @@ Kwave::SelectionTracker::SelectionTracker(Kwave::SignalManager *signal,
for (unsigned int track : *tracks) {
slotTrackInserted(track, nullptr);
if (m_selection_only)
- m_tracks.append(m_signal->uuidOfTrack(track));
+ m_tracks.append(m_signal->uidOfTrack(track));
}
} else {
// take over all tracks from the signal manager
for (unsigned int track : m_signal->allTracks()) {
slotTrackInserted(track, nullptr);
if (m_selection_only)
- m_tracks.append(m_signal->uuidOfTrack(track));
+ m_tracks.append(m_signal->uidOfTrack(track));
}
}
}
@@ -95,7 +95,7 @@ Kwave::SelectionTracker::~SelectionTracker()
}
//***************************************************************************
-QList<QUuid> Kwave::SelectionTracker::allTracks()
+QList<quint64> Kwave::SelectionTracker::allTracks()
{
return m_tracks;
}
@@ -140,8 +140,8 @@ void Kwave::SelectionTracker::slotTrackInserted(unsigned int index,
Q_ASSERT(track || !m_signal.isNull());
if (!track && m_signal.isNull()) return;
- const QUuid &uuid = (track) ? track->uuid() : m_signal->uuidOfTrack(index);
- Q_ASSERT(!uuid.isNull());
+ const quint64 uid = (track) ? track->uid() : m_signal->uidOfTrack(index);
+ Q_ASSERT(uid != 0);
// track signal length changes when tracks were inserted
sample_index_t new_len = m_signal->length();
@@ -151,8 +151,8 @@ void Kwave::SelectionTracker::slotTrackInserted(unsigned int index,
}
// a new track has been inserted
- m_tracks.append(uuid);
- emit sigTrackInserted(uuid);
+ m_tracks.append(uid);
+ emit sigTrackInserted(uid);
}
//***************************************************************************
@@ -166,9 +166,9 @@ void Kwave::SelectionTracker::slotTrackDeleted(unsigned int index,
Q_ASSERT(track);
if (!track) return;
- const QUuid &uuid = track->uuid();
- Q_ASSERT(!uuid.isNull());
- if (!m_tracks.contains(uuid))
+ const quint64 uid = track->uid();
+ Q_ASSERT(uid != 0);
+ if (!m_tracks.contains(uid))
return; // track not selected
// track signal length changes when tracks were inserted
@@ -181,8 +181,8 @@ void Kwave::SelectionTracker::slotTrackDeleted(unsigned int index,
}
// one of our selected tracks was deleted
- m_tracks.removeAll(uuid);
- emit sigTrackDeleted(uuid);
+ m_tracks.removeAll(uid);
+ emit sigTrackDeleted(uid);
}
//***************************************************************************
@@ -195,15 +195,15 @@ void Kwave::SelectionTracker::slotSamplesInserted(unsigned int track,
Q_ASSERT(!m_signal.isNull());
if (m_signal.isNull()) return;
- const QUuid uuid = m_signal->uuidOfTrack(track);
- if (!m_tracks.contains(uuid))
+ const quint64 uid = m_signal->uidOfTrack(track);
+ if (!m_tracks.contains(uid))
return; // track not selected
if (!length)
return; // nothing to do
// NOTE: adjust offsets/lengths only for the first selected track
- const bool is_first = (uuid == m_tracks.first());
+ const bool is_first = (uid == m_tracks.first());
if (m_selection_only) {
if (offset >= (m_offset + m_length))
@@ -226,7 +226,7 @@ void Kwave::SelectionTracker::slotSamplesInserted(unsigned int track,
emit sigLengthChanged(m_length);
}
- emit sigInvalidated(&uuid, offset, SAMPLE_INDEX_MAX);
+ emit sigInvalidated(uid, offset, SAMPLE_INDEX_MAX);
}
//***************************************************************************
@@ -239,8 +239,8 @@ void Kwave::SelectionTracker::slotSamplesDeleted(unsigned int track,
Q_ASSERT(!m_signal.isNull());
if (m_signal.isNull()) return;
- const QUuid uuid = m_signal->uuidOfTrack(track);
- if (!m_tracks.contains(uuid))
+ const quint64 uid = m_signal->uidOfTrack(track);
+ if (!m_tracks.contains(uid))
return; // track not selected
if (!length)
@@ -250,7 +250,7 @@ void Kwave::SelectionTracker::slotSamplesDeleted(unsigned int track,
return; // right of us
// NOTE: adjust offsets/lengths only for the first selected track
- const bool is_first = (uuid == m_tracks.first());
+ const bool is_first = (uid == m_tracks.first());
if ((offset + length - 1) < m_offset) {
// left of us, no overlap
@@ -283,7 +283,7 @@ void Kwave::SelectionTracker::slotSamplesDeleted(unsigned int track,
}
// in our range -> invalidate all samples from offset to end of file
- emit sigInvalidated(&uuid, left, SAMPLE_INDEX_MAX);
+ emit sigInvalidated(uid, left, SAMPLE_INDEX_MAX);
}
//***************************************************************************
@@ -298,8 +298,8 @@ void Kwave::SelectionTracker::slotSamplesModified(unsigned int track,
Q_ASSERT(!m_signal.isNull());
if (m_signal.isNull()) return;
- const QUuid uuid = m_signal->uuidOfTrack(track);
- if (!m_tracks.contains(uuid))
+ const quint64 uid = m_signal->uidOfTrack(track);
+ if (!m_tracks.contains(uid))
return; // track not selected
if (offset >= (m_offset + m_length))
@@ -314,29 +314,29 @@ void Kwave::SelectionTracker::slotSamplesModified(unsigned int track,
sample_index_t left = qMax(first_mod, m_offset);
sample_index_t right = qMin(last_mod, m_offset + m_length - 1);
- emit sigInvalidated(&uuid, left, right);
+ emit sigInvalidated(uid, left, right);
}
//***************************************************************************
-void Kwave::SelectionTracker::selectRange(QList<QUuid> tracks,
+void Kwave::SelectionTracker::selectRange(QList<quint64> tracks,
sample_index_t offset,
sample_index_t length)
{
QMutexLocker lock(&m_lock);
// remove deleted tracks
- for (const QUuid &uuid : m_tracks) {
- if (!tracks.contains(uuid)) {
- m_tracks.removeAll(uuid);
- emit sigTrackDeleted(uuid);
+ for (const quint64 uid : m_tracks) {
+ if (!tracks.contains(uid)) {
+ m_tracks.removeAll(uid);
+ emit sigTrackDeleted(uid);
}
}
// add new tracks
- for (const QUuid &uuid : tracks) {
- if (!m_tracks.contains(uuid)) {
- m_tracks.append(uuid);
- emit sigTrackInserted(uuid);
+ for (const quint64 uid : tracks) {
+ if (!m_tracks.contains(uid)) {
+ m_tracks.append(uid);
+ emit sigTrackInserted(uid);
}
}
@@ -370,14 +370,14 @@ void Kwave::SelectionTracker::selectRange(QList<QUuid> tracks,
// offset has changed -> invalidate all
m_offset = offset;
emit sigOffsetChanged(m_offset);
- emit sigInvalidated(nullptr, m_offset, SAMPLE_INDEX_MAX);
+ emit sigInvalidated(0, m_offset, SAMPLE_INDEX_MAX);
} else if (length > old_len) {
// length has changed and increased -> invalidate new area
- emit sigInvalidated(nullptr, m_offset + old_len - 1,
+ emit sigInvalidated(0, m_offset + old_len - 1,
SAMPLE_INDEX_MAX);
} else if (length < old_len) {
// length was reduced -> invalidate shrunken area at end
- emit sigInvalidated(nullptr, m_offset + length - 1,
+ emit sigInvalidated(0, m_offset + length - 1,
SAMPLE_INDEX_MAX);
}
}
@@ -387,7 +387,7 @@ void Kwave::SelectionTracker::selectRange(QList<QUuid> tracks,
Kwave::SelectionTracker::Undo::Undo(Kwave::SelectionTracker *selection)
:Kwave::UndoAction(),
m_tracker(selection),
- m_tracks(selection ? selection->allTracks() : QList<QUuid>()),
+ m_tracks(selection ? selection->allTracks() : QList<quint64>()),
m_offset(selection ? selection->offset() : 0),
m_length(selection ? selection->length() : 0)
{
@@ -430,7 +430,7 @@ Kwave::UndoAction *Kwave::SelectionTracker::Undo::undo(
Q_UNUSED(manager)
if (!m_tracker.isNull()) {
- QList<QUuid> tracks = m_tracks;
+ QList<quint64> tracks = m_tracks;
sample_index_t ofs = m_offset;
sample_index_t len = m_length;
diff --git a/libgui/SelectionTracker.h b/libgui/SelectionTracker.h
index 57fd0441..6f26e028 100644
--- a/libgui/SelectionTracker.h
+++ b/libgui/SelectionTracker.h
@@ -26,7 +26,6 @@
#include <QObject>
#include <QPointer>
#include <QRecursiveMutex>
-#include <QUuid>
#include <QVector>
#include "libkwave/Sample.h"
@@ -63,7 +62,7 @@ namespace Kwave
/**
* Returns all currently selected tracks
*/
- QList<QUuid> allTracks();
+ QList<quint64> allTracks();
/**
* changes the selected range covered by the cache
@@ -72,7 +71,7 @@ namespace Kwave
* @param offset index of the first selected sample
* @param length number of selected samples
*/
- void selectRange(QList<QUuid> tracks,
+ void selectRange(QList<quint64> tracks,
sample_index_t offset, sample_index_t length);
/**
@@ -106,15 +105,15 @@ namespace Kwave
/**
* Signals that a track has been inserted.
- * @param uuid unique ID of the track
+ * @param uid unique ID of the track
*/
- void sigTrackInserted(const QUuid &uuid);
+ void sigTrackInserted(quint64 uid);
/**
* Signals that a track has been deleted.
- * @param uuid unique ID of the track
+ * @param uid unique ID of the track
*/
- void sigTrackDeleted(const QUuid &uuid);
+ void sigTrackDeleted(quint64 uid);
/**
* signals that the offset of the selection has changed
@@ -130,11 +129,11 @@ namespace Kwave
/**
* signals that a range of samples has become invalid
- * @param track UUID of the track or null for "all tracks"
+ * @param track UID of the track or zero for "all tracks"
* @param first index of the first invalidated sample
* @param last index of the last invalidated sample
*/
- void sigInvalidated(const QUuid *track,
+ void sigInvalidated(quint64 track,
sample_index_t first,
sample_index_t last);
@@ -260,7 +259,7 @@ namespace Kwave
* UndoAction object after undo.
*/
Kwave::UndoAction *undo(Kwave::SignalManager &manager,
- bool with_redo) override;
+ bool with_redo) override;
/**
* This undo action does not contribute to the modification
@@ -282,7 +281,7 @@ namespace Kwave
QPointer<Kwave::SelectionTracker> m_tracker;
/** list of selected tracks */
- QList<QUuid> m_tracks;
+ QList<quint64> m_tracks;
/** start of the selection, first sample */
sample_index_t m_offset;
@@ -304,7 +303,7 @@ namespace Kwave
sample_index_t m_length;
/** list of currently selected source tracks */
- QList<QUuid> m_tracks;
+ QList<quint64> m_tracks;
/** if true, track the selection only, otherwise the whole signal */
bool m_selection_only;
diff --git a/libkwave/Signal.cpp b/libkwave/Signal.cpp
index 01e697eb..f43d88be 100644
--- a/libkwave/Signal.cpp
+++ b/libkwave/Signal.cpp
@@ -48,7 +48,7 @@ Kwave::Signal::Signal(unsigned int tracks, sample_index_t length)
:m_tracks(), m_lock_tracks()
{
while (tracks--) {
- insertTrack(0, length, nullptr);
+ insertTrack(0, length, 0);
}
}
@@ -69,13 +69,13 @@ void Kwave::Signal::close()
//***************************************************************************
Kwave::Track *Kwave::Signal::insertTrack(unsigned int index,
sample_index_t length,
- QUuid *uuid)
+ quint64 uid)
{
Kwave::Track *t = nullptr;
{
QWriteLocker lock(&m_lock_tracks);
- t = new(std::nothrow) Kwave::Track(length, uuid);
+ t = new(std::nothrow) Kwave::Track(length, uid);
Q_ASSERT(t);
if (!t) return nullptr;
@@ -289,15 +289,15 @@ void Kwave::Signal::selectTrack(unsigned int track, bool select)
}
//***************************************************************************
-QUuid Kwave::Signal::uuidOfTrack(unsigned int track)
+quint64 Kwave::Signal::uidOfTrack(unsigned int track)
{
QReadLocker lock(&m_lock_tracks);
- if (static_cast<size_t>(track) >= m_tracks.size()) return QUuid();
+ if (static_cast<size_t>(track) >= m_tracks.size()) return 0;
Q_ASSERT(m_tracks.at(track));
- if (!m_tracks.at(track)) return QUuid();
+ if (!m_tracks.at(track)) return 0;
- return m_tracks.at(track)->uuid();
+ return m_tracks.at(track)->uid();
}
//// now follow the various editing and effects functions
diff --git a/libkwave/Signal.h b/libkwave/Signal.h
index 51591213..8e8ec2bc 100644
--- a/libkwave/Signal.h
+++ b/libkwave/Signal.h
@@ -28,7 +28,6 @@
#include <QtGlobal>
#include <QReadWriteLock>
-#include <QUuid>
#include <QVector>
#include "libkwave/InsertMode.h"
@@ -80,13 +79,13 @@ namespace Kwave
* If the position is at or after the last track, the new track
* will be appended to the end.
* @param length number of samples of the new track (zero is allowed)
- * @param uuid pointer to a unique ID (optional, can be null)
+ * @param uid a unique ID (optional, can be zero)
* @return pointer to the created track. If the length is
* omitted or zero, the track will have zero length.
*/
Kwave::Track *insertTrack(unsigned int index,
sample_index_t length,
- QUuid *uuid);
+ quint64 uid);
/**
* Deletes a track.
@@ -198,10 +197,10 @@ namespace Kwave
/**
* Returns the uuid of a track
* @param track index of the track [0...tracks-1]
- * @return the QUuid of the track or a "null" uuid if the track
+ * @return the uid of the track or a "zero" uid if the track
* does not exist
*/
- QUuid uuidOfTrack(unsigned int track);
+ quint64 uidOfTrack(unsigned int track);
signals:
diff --git a/libkwave/SignalManager.cpp b/libkwave/SignalManager.cpp
index f80d2f8a..53dea138 100644
--- a/libkwave/SignalManager.cpp
+++ b/libkwave/SignalManager.cpp
@@ -186,7 +186,7 @@ int Kwave::SignalManager::loadFile(const QUrl &url)
if (!tracks) break;
for (track = 0; track < tracks; ++track) {
- Kwave::Track *t = m_signal.insertTrack(0, length, nullptr);
+ Kwave::Track *t = m_signal.insertTrack(0, length, 0);
Q_ASSERT(t);
if (!t || (t->length() != length)) {
qWarning("SignalManager::loadFile: out of memory");
@@ -516,7 +516,7 @@ void Kwave::SignalManager::newSignal(sample_index_t samples, double rate,
// add all empty tracks
while (tracks) {
- m_signal.insertTrack(0, samples, nullptr);
+ m_signal.insertTrack(0, samples, 0);
tracks--;
}
@@ -925,7 +925,7 @@ void Kwave::SignalManager::insertTrack(unsigned int index)
sample_index_t len = (count) ? length() : m_last_length;
// insert/append to the list
- m_signal.insertTrack(index, len, nullptr);
+ m_signal.insertTrack(index, len, 0);
// remember the last length
m_last_length = length();
diff --git a/libkwave/SignalManager.h b/libkwave/SignalManager.h
index f36cf0f2..b50ecd57 100644
--- a/libkwave/SignalManager.h
+++ b/libkwave/SignalManager.h
@@ -399,11 +399,11 @@ namespace Kwave
/**
* Returns the uuid of a track
* @param track index of the track [0...tracks-1]
- * @return the QUuid of the track or a "null" uuid if the track
+ * @return the uid of the track or a "zero" uid if the track
* does not exist
*/
- QUuid uuidOfTrack(unsigned int track) {
- return m_signal.uuidOfTrack(track);
+ quint64 uidOfTrack(unsigned int track) {
+ return m_signal.uidOfTrack(track);
}
/**
diff --git a/libkwave/Track.cpp b/libkwave/Track.cpp
index 97f1879a..cf93e4f8 100644
--- a/libkwave/Track.cpp
+++ b/libkwave/Track.cpp
@@ -18,6 +18,7 @@
#include "config.h"
#include <algorithm>
+#include <atomic>
#include <new>
#include <QMutexLocker>
@@ -55,17 +56,24 @@
*/
#define STRIPE_LENGTH_MINIMUM (STRIPE_LENGTH_OPTIMAL / 2)
+//***************************************************************************
+static inline quint64 createUid()
+{
+ static std::atomic<quint64> s_counter{1};
+ return s_counter.fetch_add(1, std::memory_order_relaxed);
+}
+
//***************************************************************************
Kwave::Track::Track()
:m_lock(), m_lock_usage(), m_stripes(), m_selected(true),
- m_uuid(QUuid::createUuid())
+ m_uid(createUid())
{
}
//***************************************************************************
-Kwave::Track::Track(sample_index_t length, QUuid *uuid)
+Kwave::Track::Track(sample_index_t length, quint64 uid)
:m_lock(), m_lock_usage(), m_stripes(), m_selected(true),
- m_uuid((uuid) ? *uuid : QUuid::createUuid())
+ m_uid((uid) ? uid : createUid())
{
if (length <= STRIPE_LENGTH_MAXIMUM) {
if (length) appendStripe(length);
diff --git a/libkwave/Track.h b/libkwave/Track.h
index 8f7a8cd7..1f5b135b 100644
--- a/libkwave/Track.h
+++ b/libkwave/Track.h
@@ -27,7 +27,6 @@
#include <QObject>
#include <QReadWriteLock>
#include <QRecursiveMutex>
-#include <QUuid>
#include "libkwave/InsertMode.h"
#include "libkwave/ReaderMode.h"
@@ -55,9 +54,9 @@ namespace Kwave
/**
* Constructor. Creates an empty track with a specified length.
* @param length the length in samples
- * @param uuid unique ID of the track, can be null
+ * @param uid unique ID of the track, can be zero
*/
- Track(sample_index_t length, QUuid *uuid);
+ Track(sample_index_t length, quint64 uid);
/**
* Destructor.
@@ -141,7 +140,7 @@ namespace Kwave
void select(bool select);
/** returns the unique ID of this track instance */
- const QUuid &uuid() const { return m_uuid; }
+ const quint64 &uid() const { return m_uid; }
public slots:
@@ -318,7 +317,7 @@ namespace Kwave
bool m_selected;
/** unique ID */
- QUuid m_uuid;
+ const quint64 m_uid;
};
}
diff --git a/libkwave/autotests/test_Track.cpp b/libkwave/autotests/test_Track.cpp
index 6dcdd8b2..e9c645fd 100644
--- a/libkwave/autotests/test_Track.cpp
+++ b/libkwave/autotests/test_Track.cpp
@@ -31,8 +31,8 @@ void TestTrack::deleteRange()
QFETCH(sample_index_t, offset);
QFETCH(sample_index_t, deleteLen);
- auto uuid{QUuid::createUuid()};
- auto t = Kwave::Track{trackLen, &uuid};
+ quint64 uid = 1;
+ auto t = Kwave::Track{trackLen, uid};
t.deleteRange(offset, deleteLen);
QCOMPARE(t.length(), trackLen - deleteLen);
}
diff --git a/libkwave/undo/UndoDeleteTrack.cpp b/libkwave/undo/UndoDeleteTrack.cpp
index fb3038c2..1f782c45 100644
--- a/libkwave/undo/UndoDeleteTrack.cpp
+++ b/libkwave/undo/UndoDeleteTrack.cpp
@@ -30,7 +30,7 @@
Kwave::UndoDeleteTrack::UndoDeleteTrack(Kwave::Signal &signal,
unsigned int track)
:UndoAction(), m_signal(signal), m_track(track),
- m_length(signal.length()), m_stripes(), m_uuid(signal.uuidOfTrack(track))
+ m_length(signal.length()), m_stripes(), m_uid(signal.uidOfTrack(track))
{
}
@@ -87,7 +87,7 @@ Kwave::UndoAction *Kwave::UndoDeleteTrack::undo(Kwave::SignalManager &manager,
}
// insert an empty track into the signal
- m_signal.insertTrack(m_track, m_length, &m_uuid);
+ m_signal.insertTrack(m_track, m_length, m_uid);
// merge the stripes back into the signal
QVector<unsigned int> track_list;
diff --git a/libkwave/undo/UndoDeleteTrack.h b/libkwave/undo/UndoDeleteTrack.h
index 4f9c43f7..aa6f16ca 100644
--- a/libkwave/undo/UndoDeleteTrack.h
+++ b/libkwave/undo/UndoDeleteTrack.h
@@ -22,7 +22,6 @@
#include "config.h"
#include <QString>
-#include <QUuid>
#include "libkwave/Sample.h"
#include "libkwave/Stripe.h"
@@ -83,7 +82,7 @@ namespace Kwave
QList<Kwave::Stripe::List> m_stripes;
/** unique ID of the deleted track */
- QUuid m_uuid;
+ quint64 m_uid;
};
}
diff --git a/plugins/sonagram/SonagramPlugin.cpp b/plugins/sonagram/SonagramPlugin.cpp
index b788b906..8632ad45 100644
--- a/plugins/sonagram/SonagramPlugin.cpp
+++ b/plugins/sonagram/SonagramPlugin.cpp
@@ -27,7 +27,6 @@
#include <QApplication>
#include <QColor>
#include <QFutureSynchronizer>
-#include <QImage>
#include <QMutexLocker>
#include <QPointer>
#include <QString>
@@ -211,15 +210,15 @@ int Kwave::SonagramPlugin::start(QStringList ¶ms)
Q_ASSERT(m_selection);
if (!m_selection) return -ENOMEM;
- connect(m_selection, SIGNAL(sigTrackInserted(QUuid)),
- this, SLOT(slotTrackInserted(QUuid)));
- connect(m_selection, SIGNAL(sigTrackDeleted(QUuid)),
- this, SLOT(slotTrackDeleted(QUuid)));
+ connect(m_selection, SIGNAL(sigTrackInserted(quint64)),
+ this, SLOT(slotTrackInserted(quint64)));
+ connect(m_selection, SIGNAL(sigTrackDeleted(quint64)),
+ this, SLOT(slotTrackDeleted(quint64)));
connect(
m_selection,
- SIGNAL(sigInvalidated(const QUuid*,sample_index_t,sample_index_t)),
+ SIGNAL(sigInvalidated(quint64,sample_index_t,sample_index_t)),
this,
- SLOT(slotInvalidated(const QUuid*,sample_index_t,sample_index_t))
+ SLOT(slotInvalidated(quint64,sample_index_t,sample_index_t))
);
// create a new empty image
@@ -293,9 +292,9 @@ void Kwave::SonagramPlugin::makeAllValid()
valid = m_valid;
m_valid.fill(true);
- const QList<QUuid> selected_tracks(m_selection->allTracks());
+ const QList<quint64> selected_tracks(m_selection->allTracks());
for (unsigned int track : signalManager().allTracks())
- if (selected_tracks.contains(signalManager().uuidOfTrack(track)))
+ if (selected_tracks.contains(signalManager().uidOfTrack(track)))
track_list.append(track);
}
const unsigned int tracks = static_cast<unsigned int>(track_list.count());
@@ -537,7 +536,7 @@ void Kwave::SonagramPlugin::validate()
}
//***************************************************************************
-void Kwave::SonagramPlugin::slotTrackInserted(const QUuid &track_id)
+void Kwave::SonagramPlugin::slotTrackInserted(quint64 track_id)
{
QMutexLocker _lock(&m_lock_job_list);
@@ -552,7 +551,7 @@ void Kwave::SonagramPlugin::slotTrackInserted(const QUuid &track_id)
}
//***************************************************************************
-void Kwave::SonagramPlugin::slotTrackDeleted(const QUuid &track_id)
+void Kwave::SonagramPlugin::slotTrackDeleted(quint64 track_id)
{
QMutexLocker _lock(&m_lock_job_list);
@@ -567,7 +566,7 @@ void Kwave::SonagramPlugin::slotTrackDeleted(const QUuid &track_id)
}
//***************************************************************************
-void Kwave::SonagramPlugin::slotInvalidated(const QUuid *track_id,
+void Kwave::SonagramPlugin::slotInvalidated(quint64 track_id,
sample_index_t first,
sample_index_t last)
{
diff --git a/plugins/sonagram/SonagramPlugin.h b/plugins/sonagram/SonagramPlugin.h
index 02cdc586..5554b261 100644
--- a/plugins/sonagram/SonagramPlugin.h
+++ b/plugins/sonagram/SonagramPlugin.h
@@ -25,6 +25,7 @@
#include <QBitArray>
#include <QByteArray>
#include <QFuture>
+#include <QImage>
#include <QList>
#include <QMutex>
#include <QQueue>
@@ -32,7 +33,6 @@
#include <QRecursiveMutex>
#include <QString>
#include <QTimer>
-#include <QUuid>
#include "libkwave/FixedPool.h"
#include "libkwave/Plugin.h"
@@ -145,22 +145,22 @@ namespace Kwave
* @param track_id unique ID of the track
* @see SelectionTracker::sigTrackInserted
*/
- void slotTrackInserted(const QUuid &track_id);
+ void slotTrackInserted(quint64 track_id);
/**
* Connected to the selection tracker's sigTrackInserted.
* @param track_id unique ID of the track
* @see SelectionTracker::sigTrackDeleted
*/
- void slotTrackDeleted(const QUuid &track_id);
+ void slotTrackDeleted(quint64 track_id);
/**
* Connected to the selection tracker's sigInvalidated.
- * @param track_id UUID of the track or null for "all tracks"
+ * @param track_id uinque ID of the track or zero for "all tracks"
* @param first index of the first invalidated sample
* @param last index of the last invalidated sample
*/
- void slotInvalidated(const QUuid *track_id,
+ void slotInvalidated(quint64 track_id,
sample_index_t first,
sample_index_t last);