Audio types / stream properties / cue import

CMakeLists.txt

@@ -173,6 +173,9 @@ add_library(mixxx-lib STATIC EXCLUDE_FROM_ALL
   src/analyzer/plugins/analyzersoundtouchbeats.cpp
   src/analyzer/plugins/buffering_utils.cpp
   src/analyzer/trackanalysisscheduler.cpp
+  src/audio/types.cpp
+  src/audio/signalinfo.cpp
+  src/audio/streaminfo.cpp
   src/control/control.cpp
   src/control/controlaudiotaperpot.cpp
   src/control/controlbehavior.cpp
@@ -561,7 +564,6 @@ add_library(mixxx-lib STATIC EXCLUDE_FROM_ALL
   src/track/tracknumbers.cpp
   src/track/trackrecord.cpp
   src/track/trackref.cpp
-  src/util/audiosignal.cpp
   src/util/autohidpi.cpp
   src/util/battery/battery.cpp
   src/util/cache.cpp

build/depends.py

@@ -902,6 +902,10 @@ def sources(self, build):
                    "src/analyzer/plugins/analyzerqueenmarykey.cpp",
                    "src/analyzer/plugins/buffering_utils.cpp",
 
+                   "src/audio/types.cpp",
+                   "src/audio/signalinfo.cpp",
+                   "src/audio/streaminfo.cpp",
+
                    "src/controllers/controller.cpp",
                    "src/controllers/controllerdebug.cpp",
                    "src/controllers/controllerengine.cpp",
@@ -1311,7 +1315,6 @@ def sources(self, build):
                    "src/util/logger.cpp",
                    "src/util/logging.cpp",
                    "src/util/cmdlineargs.cpp",
-                   "src/util/audiosignal.cpp",
                    "src/util/widgethider.cpp",
                    "src/util/autohidpi.cpp",
                    "src/util/screensaver.cpp",

src/analyzer/analyzerthread.cpp

@@ -145,7 +145,7 @@ void AnalyzerThread::doRun() {
             // Make sure not to short-circuit initialize(...)
             if (analyzer.initialize(
                         m_currentTrack,
-                        audioSource->sampleRate(),
+                        audioSource->getSignalInfo().getSampleRate(),
                         audioSource->frameLength() * mixxx::kAnalysisChannels)) {
                 processTrack = true;
             }
@@ -226,7 +226,9 @@ AnalyzerThread::AnalysisResult AnalyzerThread::analyzeAudioSource(
     mixxx::AudioSourceStereoProxy audioSourceProxy(
             audioSource,
             mixxx::kAnalysisFramesPerChunk);
-    DEBUG_ASSERT(audioSourceProxy.channelCount() == mixxx::kAnalysisChannels);
+    DEBUG_ASSERT(
+            audioSourceProxy.getSignalInfo().getChannelCount() ==
+            mixxx::kAnalysisChannels);
 
     // Analysis starts now
     emitBusyProgress(kAnalyzerProgressNone);

src/analyzer/constants.h

@@ -1,15 +1,14 @@
 #pragma once
 
 #include "engine/engine.h"
-#include "util/audiosignal.h"
 
 namespace mixxx {
 
 // Analysis is done in blocks to avoid dynamic allocation of memory
 // depending on the track length. A block size of 4096 frames per block
 // seems to do fine. Signal processing during analysis uses the same,
 // fixed number of channels like the engine does, usually 2 = stereo.
-constexpr mixxx::AudioSignal::ChannelCount kAnalysisChannels = mixxx::kEngineChannelCount;
+constexpr audio::ChannelCount kAnalysisChannels = mixxx::kEngineChannelCount;
 constexpr SINT kAnalysisFramesPerChunk = 4096;
 constexpr SINT kAnalysisSamplesPerChunk =
         kAnalysisFramesPerChunk * kAnalysisChannels;

src/audio/signalinfo.cpp

@@ -0,0 +1,27 @@
+#include "audio/signalinfo.h"
+
+namespace mixxx {
+
+namespace audio {
+
+bool operator==(
+        const SignalInfo& lhs,
+        const SignalInfo& rhs) {
+    return lhs.getChannelCount() == rhs.getChannelCount() &&
+            lhs.getSampleLayout() == rhs.getSampleLayout() &&
+            lhs.getSampleRate() == rhs.getSampleRate();
+}
+
+QDebug
+operator<<(QDebug dbg, const SignalInfo& arg) {
+    dbg << "SignalInfo{";
+    arg.dbgChannelCount(dbg);
+    arg.dbgSampleLayout(dbg);
+    arg.dbgSampleRate(dbg);
+    dbg << '}';
+    return dbg;
+}
+
+} // namespace audio
+
+} // namespace mixxx

src/audio/signalinfo.h

@@ -0,0 +1,99 @@
+#pragma once
+
+#include "audio/types.h"
+#include "util/assert.h"
+#include "util/macros.h"
+#include "util/optional.h"
+
+namespace mixxx {
+
+namespace audio {
+
+// Properties that characterize an uncompressed PCM audio signal.
+class SignalInfo final {
+    // Properties
+    PROPERTY_SET_BYVAL_GET_BYREF(ChannelCount, channelCount, ChannelCount)
+    PROPERTY_SET_BYVAL_GET_BYREF(SampleRate, sampleRate, SampleRate)
+    PROPERTY_SET_BYVAL_GET_BYREF(OptionalSampleLayout, sampleLayout, SampleLayout)
+
+  public:
+    constexpr SignalInfo() = default;
+    constexpr explicit SignalInfo(
+            OptionalSampleLayout sampleLayout)
+            : m_sampleLayout(sampleLayout) {
+    }
+    SignalInfo(
+            ChannelCount channelCount,
+            SampleRate sampleRate,
+            OptionalSampleLayout sampleLayout = std::nullopt)
+            : m_channelCount(channelCount),
+              m_sampleRate(sampleRate),
+              m_sampleLayout(sampleLayout) {
+    }
+    SignalInfo(SignalInfo&&) = default;
+    SignalInfo(const SignalInfo&) = default;
+    /*non-virtual*/ ~SignalInfo() = default;
+
+    constexpr bool isValid() const {
+        return getChannelCount().isValid() &&
+                getSampleLayout() &&
+                getSampleRate().isValid();
+    }
+
+    SignalInfo& operator=(SignalInfo&&) = default;
+    SignalInfo& operator=(const SignalInfo&) = default;
+
+    // Conversion: #samples / sample offset -> #frames / frame offset
+    // Only works for integer sample offsets on frame boundaries!
+    SINT samples2frames(SINT samples) const {
+        DEBUG_ASSERT(getChannelCount().isValid());
+        DEBUG_ASSERT(0 == (samples % getChannelCount()));
+        return samples / getChannelCount();
+    }
+
+    // Conversion: #frames / frame offset -> #samples / sample offset
+    SINT frames2samples(SINT frames) const {
+        DEBUG_ASSERT(getChannelCount().isValid());
+        return frames * getChannelCount();
+    }
+
+    // Conversion: #frames / frame offset -> second offset
+    double frames2secs(SINT frames) const {
+        DEBUG_ASSERT(getSampleRate().isValid());
+        return static_cast<double>(frames) / getSampleRate();
+    }
+
+    // Conversion: second offset -> #frames / frame offset
+    double secs2frames(double seconds) const {
+        DEBUG_ASSERT(getSampleRate().isValid());
+        return seconds * getSampleRate();
+    }
+
+    // Conversion: #frames / frame offset -> millisecond offset
+    double frames2millis(SINT frames) const {
+        return frames2secs(frames) * 1000;
+    }
+
+    // Conversion: millisecond offset -> #frames / frame offset
+    double millis2frames(double milliseconds) const {
+        return secs2frames(milliseconds / 1000);
+    }
+};
+
+bool operator==(
+        const SignalInfo& lhs,
+        const SignalInfo& rhs);
+
+inline bool operator!=(
+        const SignalInfo& lhs,
+        const SignalInfo& rhs) {
+    return !(lhs == rhs);
+}
+
+QDebug operator<<(QDebug dbg, const SignalInfo& arg);
+
+} // namespace audio
+
+} // namespace mixxx
+
+Q_DECLARE_METATYPE(mixxx::audio::SignalInfo)

src/audio/streaminfo.cpp

@@ -0,0 +1,27 @@
+#include "audio/streaminfo.h"
+
+namespace mixxx {
+
+namespace audio {
+
+bool operator==(
+        const StreamInfo& lhs,
+        const StreamInfo& rhs) {
+    return lhs.getSignalInfo() == rhs.getSignalInfo() &&
+            lhs.getBitrate() == rhs.getBitrate() &&
+            lhs.getDuration() == rhs.getDuration();
+}
+
+QDebug
+operator<<(QDebug dbg, const StreamInfo& arg) {
+    dbg << "StreamInfo{";
+    arg.dbgSignalInfo(dbg);
+    arg.dbgBitrate(dbg);
+    arg.dbgDuration(dbg);
+    dbg << '}';
+    return dbg;
+}
+
+} // namespace audio
+
+} // namespace mixxx

src/audio/streaminfo.h

@@ -0,0 +1,64 @@
+#pragma once
+
+#include "audio/signalinfo.h"
+#include "util/duration.h"
+
+namespace mixxx {
+
+namespace audio {
+
+// Properties that characterize a (compressed) PCM audio stream.
+//
+// Currently we assume that every stream has a finite duration
+// that is known upfront!
+class StreamInfo final {
+    // Properties
+    PROPERTY_SET_BYVAL_GET_BYREF(SignalInfo, signalInfo, SignalInfo)
+    PROPERTY_SET_BYVAL_GET_BYREF(Bitrate, bitrate, Bitrate)
+    PROPERTY_SET_BYVAL_GET_BYREF(Duration, duration, Duration)
+
+  public:
+    constexpr StreamInfo() = default;
+    constexpr explicit StreamInfo(
+            const SignalInfo& signalInfo)
+            : m_signalInfo(signalInfo) {
+    }
+    constexpr StreamInfo(
+            const SignalInfo& signalInfo,
+            Bitrate bitrate,
+            Duration duration)
+            : m_signalInfo(signalInfo),
+              m_bitrate(bitrate),
+              m_duration(duration) {
+    }
+    StreamInfo(StreamInfo&&) = default;
+    StreamInfo(const StreamInfo&) = default;
+    /*non-virtual*/ ~StreamInfo() = default;
+
+    constexpr bool isValid() const {
+        return getSignalInfo().isValid() &&
+                getBitrate().isValid() &&
+                (getDuration() > Duration::empty());
+    }
+
+    StreamInfo& operator=(StreamInfo&&) = default;
+    StreamInfo& operator=(const StreamInfo&) = default;
+};
+
+bool operator==(
+        const StreamInfo& lhs,
+        const StreamInfo& rhs);
+
+inline bool operator!=(
+        const StreamInfo& lhs,
+        const StreamInfo& rhs) {
+    return !(lhs == rhs);
+}
+
+QDebug operator<<(QDebug dbg, const StreamInfo& arg);
+
+} // namespace audio
+
+} // namespace mixxx
+
+Q_DECLARE_METATYPE(mixxx::audio::StreamInfo)

src/audio/types.cpp

@@ -0,0 +1,45 @@
+#include "audio/types.h"
+
+namespace mixxx {
+
+namespace audio {
+
+QDebug operator<<(QDebug dbg, ChannelLayout arg) {
+    switch (arg) {
+    case ChannelLayout::Mono:
+        return dbg << "Mono";
+    case ChannelLayout::DualMono:
+        return dbg << "DualMono";
+    case ChannelLayout::Stereo:
+        return dbg << "Stereo";
+    }
+    DEBUG_ASSERT(!"unreachable code");
+    return dbg;
+}
+
+QDebug operator<<(QDebug dbg, SampleLayout arg) {
+    switch (arg) {
+    case SampleLayout::Planar:
+        return dbg << "Planar";
+    case SampleLayout::Interleaved:
+        return dbg << "Interleaved";
+    }
+    DEBUG_ASSERT(!"unreachable code");
+    return dbg;
+}
+
+QDebug operator<<(QDebug dbg, SampleRate arg) {
+    return dbg
+            << static_cast<SampleRate::value_t>(arg)
+            << SampleRate::unit();
+}
+
+QDebug operator<<(QDebug dbg, Bitrate arg) {
+    return dbg
+            << static_cast<Bitrate::value_t>(arg)
+            << Bitrate::unit();
+}
+
+} // namespace audio
+
+} // namespace mixxx