First sound test

.codespellignore

@@ -6,3 +6,4 @@ sord
 doubleClick
 sur
 jus
+caf

CMakeLists.txt

@@ -1337,6 +1337,7 @@ if(APPLE)
 
   target_sources(mixxx-lib PRIVATE
     src/util/darkappearance.mm
+    src/util/macosversion.mm
   )
 
   option(MACOS_ITUNES_LIBRARY "Native macOS iTunes/Music.app library integration" ON)
@@ -3028,6 +3029,7 @@ if(MEDIAFOUNDATION)
   )
   target_link_libraries(mixxx-lib PRIVATE
     ${MediaFoundation_LIBRARIES}
+    Version.lib
   )
 endif()
 

src/sources/soundsourcecoreaudio.cpp

@@ -1,8 +1,9 @@
 #include "sources/soundsourcecoreaudio.h"
-#include "sources/mp3decoding.h"
 
 #include "engine/engine.h"
+#include "sources/mp3decoding.h"
 #include "util/logger.h"
+#include "util/macosversion.h"
 #include "util/math.h"
 
 namespace mixxx {
@@ -27,7 +28,7 @@ constexpr SINT kMp3MaxSeekPrefetchFrames =
 } // namespace
 
 //static
-const QString SoundSourceProviderCoreAudio::kDisplayName = QStringLiteral("Apple Core Audio");
+const QString SoundSourceProviderCoreAudio::kDisplayName = QStringLiteral("Apple CoreAudio");
 
 //static
 const QStringList SoundSourceProviderCoreAudio::kSupportedFileTypes = {
@@ -48,6 +49,10 @@ SoundSourceProviderPriority SoundSourceProviderCoreAudio::getPriorityHint(
     return SoundSourceProviderPriority::Higher;
 }
 
+QString SoundSourceProviderCoreAudio::getVersionString() const {
+    return getMacOsVersion();
+}
+
 SoundSourceCoreAudio::SoundSourceCoreAudio(QUrl url)
         : SoundSource(url),
           LegacyAudioSourceAdapter(this, this),

src/sources/soundsourcecoreaudio.h

@@ -58,7 +58,7 @@ class SoundSourceProviderCoreAudio : public SoundSourceProvider {
     static const QStringList kSupportedFileTypes;
 
     QString getDisplayName() const override {
-        return kDisplayName;
+        return kDisplayName + QChar(' ') + getVersionString();
     }
 
     QStringList getSupportedFileTypes() const override {
@@ -71,6 +71,8 @@ class SoundSourceProviderCoreAudio : public SoundSourceProvider {
     SoundSourcePointer newSoundSource(const QUrl& url) override {
         return newSoundSourceFromUrl<SoundSourceCoreAudio>(url);
     }
+
+    QString getVersionString() const;
 };
 
 } // namespace mixxx

src/sources/soundsourceffmpeg.cpp

@@ -465,6 +465,10 @@ SoundSourceProviderPriority SoundSourceProviderFFmpeg::getPriorityHint(
     return SoundSourceProviderPriority::Lowest;
 }
 
+QString SoundSourceProviderFFmpeg::getVersionString() const {
+    return QString::fromUtf8(av_version_info());
+}
+
 SoundSourceFFmpeg::SoundSourceFFmpeg(const QUrl& url)
         : SoundSource(url),
           m_pavStream(nullptr),

src/sources/soundsourceffmpeg.h

@@ -201,7 +201,7 @@ class SoundSourceProviderFFmpeg : public SoundSourceProvider {
     ~SoundSourceProviderFFmpeg() override = default;
 
     QString getDisplayName() const override {
-        return kDisplayName;
+        return kDisplayName + QChar(' ') + getVersionString();
     }
 
     QStringList getSupportedFileTypes() const override;
@@ -212,6 +212,8 @@ class SoundSourceProviderFFmpeg : public SoundSourceProvider {
     SoundSourcePointer newSoundSource(const QUrl& url) override {
         return newSoundSourceFromUrl<SoundSourceFFmpeg>(url);
     }
+
+    QString getVersionString() const;
 };
 
 } // namespace mixxx

src/sources/soundsourcemediafoundation.cpp

@@ -67,6 +67,39 @@ SoundSourcePointer SoundSourceProviderMediaFoundation::newSoundSource(const QUrl
     return newSoundSourceFromUrl<SoundSourceMediaFoundation>(url);
 }
 
+QString SoundSourceProviderMediaFoundation::getVersionString() const {
+    HMODULE mfModule = GetModuleHandle(L"mfplat.dll");
+    VERIFY_OR_DEBUG_ASSERT(mfModule) {
+        return QString();
+    }
+    wchar_t dllPath[MAX_PATH];
+    DWORD pathLength = GetModuleFileName(mfModule, dllPath, MAX_PATH);
+    DWORD versionInfoSize = GetFileVersionInfoSize(dllPath, nullptr);
+    VERIFY_OR_DEBUG_ASSERT(versionInfoSize > 0) {
+        qWarning() << "failed to read" << dllPath << "error:" << GetLastError();
+        return QString();
+    }
+    QVarLengthArray<BYTE> info(static_cast<int>(versionInfoSize));
+    if (GetFileVersionInfo(dllPath, 0, versionInfoSize, info.data())) {
+        UINT size = 0;
+        VS_FIXEDFILEINFO* pVerInfo = nullptr;
+        if (VerQueryValue(info.data(), L"\\", reinterpret_cast<LPVOID*>(&pVerInfo), &size) &&
+                pVerInfo != nullptr &&
+                size >= sizeof(VS_FIXEDFILEINFO)) {
+            return QStringLiteral("%1.%2.%3.%4")
+                    .arg(QString::number(HIWORD(pVerInfo->dwProductVersionMS)),
+                            QString::number(
+                                    LOWORD(pVerInfo->dwProductVersionMS)),
+                            QString::number(
+                                    HIWORD(pVerInfo->dwProductVersionLS)),
+                            QString::number(
+                                    LOWORD(pVerInfo->dwProductVersionLS)));
+        }
+    }
+    qWarning() << "failed to read version from" << dllPath << "error:" << GetLastError();
+    return QString();
+}
+
 SoundSourceMediaFoundation::SoundSourceMediaFoundation(const QUrl& url)
         : SoundSource(url),
           m_hrCoInitialize(E_FAIL),

src/sources/soundsourcemediafoundation.h

@@ -94,7 +94,7 @@ class SoundSourceProviderMediaFoundation : public SoundSourceProvider {
     static const QStringList kSupportedFileTypes;
 
     QString getDisplayName() const override {
-        return kDisplayName;
+        return kDisplayName + QChar(' ') + getVersionString();
     }
 
     QStringList getSupportedFileTypes() const override {
@@ -105,6 +105,8 @@ class SoundSourceProviderMediaFoundation : public SoundSourceProvider {
             const QString& supportedFileType) const override;
 
     SoundSourcePointer newSoundSource(const QUrl& url) override;
+
+    QString getVersionString() const;
 };
 
 } // namespace mixxx

src/sources/soundsourcemp3.cpp

@@ -161,13 +161,17 @@ bool decodeFrameHeader(
 } // anonymous namespace
 
 //static
-const QString SoundSourceProviderMp3::kDisplayName = QStringLiteral("MAD: MPEG Audio Decoder");
+const QString SoundSourceProviderMp3::kDisplayName = QStringLiteral("MAD");
 
 //static
 const QStringList SoundSourceProviderMp3::kSupportedFileTypes = {
         QStringLiteral("mp3"),
 };
 
+QString SoundSourceProviderMp3::getVersionString() const {
+    return QString(QString(mad_version) + QChar(' ') + QString(mad_build)).trimmed();
+}
+
 SoundSourceMp3::SoundSourceMp3(const QUrl& url)
         : SoundSource(url),
           m_file(getLocalFileName()),
@@ -487,7 +491,8 @@ void SoundSourceMp3::close() {
 void SoundSourceMp3::restartDecoding(
         const SeekFrameType& seekFrame) {
     if (kLogger.debugEnabled()) {
-        kLogger.debug() << "restartDecoding @" << seekFrame.frameIndex;
+        kLogger.info() << "restartDecoding for frame" << seekFrame.frameIndex << "@"
+                       << (seekFrame.pInputData - m_pFileData);
     }
 
     // Discard decoded output
@@ -680,6 +685,14 @@ ReadableSampleFrames SoundSourceMp3::readSampleFramesClamped(
                                     << "Recoverable MP3 frame decoding error:"
                                     << mad_stream_errorstr(&m_madStream);
                         }
+                    } else if (m_madStream.error == MAD_ERROR_BADDATAPTR &&
+                            m_curFrameIndex == firstFrameIndex) {
+                        // This is expected after starting decoding with an offset
+                        if (kLogger.debugEnabled()) {
+                            kLogger.debug()
+                                    << "Recoverable MP3 frame decoding error:"
+                                    << mad_stream_errorstr(&m_madStream);
+                        }
                     } else {
                         kLogger.info() << "Recoverable MP3 frame decoding error:"
                                        << mad_stream_errorstr(&m_madStream);

src/sources/soundsourcemp3.h

@@ -82,7 +82,7 @@ class SoundSourceProviderMp3 : public SoundSourceProvider {
     static const QStringList kSupportedFileTypes;
 
     QString getDisplayName() const override {
-        return kDisplayName;
+        return kDisplayName + QStringLiteral(": ") + getVersionString();
     }
 
     QStringList getSupportedFileTypes() const override {
@@ -92,6 +92,8 @@ class SoundSourceProviderMp3 : public SoundSourceProvider {
     SoundSourcePointer newSoundSource(const QUrl& url) override {
         return newSoundSourceFromUrl<SoundSourceMp3>(url);
     }
+
+    QString getVersionString() const;
 };
 
 } // namespace mixxx

src/test/mixxxtest.h

@@ -35,13 +35,10 @@ class MixxxTest : public testing::Test {
     };
     friend class ApplicationScope;
 
-    static const QDir& getOrInitTestDir(const QString& resourcePath = QString()) {
+    static const QDir& getOrInitTestDir() {
         if (s_TestDir.path() == ".") {
             s_TestDir.setPath(
-                    (resourcePath.isEmpty() ? ConfigObject<ConfigValue>::
-                                                      computeResourcePath()
-                                            : resourcePath) +
-                    QChar('/') + kTestPath);
+                    QDir::cleanPath(ConfigObject<ConfigValue>::computeResourcePath() + kTestPath));
         }
         return s_TestDir;
     }
@@ -63,7 +60,7 @@ class MixxxTest : public testing::Test {
     }
 
     const QDir& getTestDir() const {
-        return getOrInitTestDir(m_pConfig->getResourcePath());
+        return getOrInitTestDir();
     }
 
   private:

src/test/soundproxy_test.cpp

@@ -2,6 +2,7 @@
 #include <QTemporaryFile>
 #include <QtDebug>
 
+#include "analyzer/analyzersilence.h"
 #include "sources/audiosourcestereoproxy.h"
 #include "sources/soundsourceproxy.h"
 #include "test/mixxxtest.h"
@@ -119,8 +120,8 @@ class SoundSourceProxyTest : public MixxxTest, SoundSourceProviderRegistration {
             const CSAMPLE* actual,
             const char* errorMessage) {
         for (SINT i = 0; i < size; ++i) {
-            EXPECT_NEAR(expected[i], actual[i],
-                    kMaxDecodingError) << errorMessage;
+            EXPECT_NEAR(expected[i], actual[i], kMaxDecodingError)
+                    << "i=" << i << " " << errorMessage;
         }
     }
 
@@ -747,6 +748,128 @@ TEST_F(SoundSourceProxyTest, regressionTestCachingReaderChunkJumpForward) {
     }
 }
 
+TEST_F(SoundSourceProxyTest, firstSoundTest) {
+    constexpr SINT kReadFrameCount = 2000;
+
+    struct RefFirstSound {
+        QString path;
+        SINT firstSoundSample;
+    };
+
+    RefFirstSound refs[] = {{QStringLiteral("cover-test.aiff"), 1166},
+            {QStringLiteral("cover-test-alac.caf"), 1166},
+            {QStringLiteral("cover-test.flac"), 1166},
+            {QStringLiteral("cover-test-itunes-12.3.0-aac.m4a"),
+#if defined(__WINDOWS__)
+                    1390}, // Media Foundation 10.0.17763.2989
+                           // Media Foundation 10.0.20348.1
+#else
+                    1166}, // FFmpeg 4.2.7-0ubuntu0.1
+                           // FFmpeg 4.4.2-0ubuntu0.22.04.1
+                           // FFmpeg 5.1.2 windows
+                           // CoreAudio Version 11.7.8 (Build 20G1351)
+                           // CoreAusio Version 12.6.7 (Build 21G651)
+#endif
+            // 1168 FFmpeg 4.2.7-0ubuntu0.1
+
+            {QStringLiteral("cover-test-ffmpeg-aac.m4a"),
+#if defined(__WINDOWS__)
+                    3160}, // Media Foundation 10.0.17763.2989
+                           // Media Foundation 10.0.20348.1
+#else
+                    1112}, // FFmpeg 4.2.7-0ubuntu0.1
+                           // FFmpeg 4.4.2-0ubuntu0.22.04.1
+                           // FFmpeg 5.1.2 windows
+                           // CoreAudio Version 11.7.8 (Build 20G1351)
+                           // CoreAusio Version 12.6.7 (Build 21G651)
+#endif
+
+            {QStringLiteral("cover-test-itunes-12.7.0-alac.m4a"), 1166},
+            {QStringLiteral("cover-test-png.mp3"),
+#if defined(__LINUX__)
+                    1752}, // MAD: MPEG Audio Decoder 0.15.1 (beta) NDEBUG FPM_64BIT
+#elif defined(__WINDOWS__)
+                    1752}, // MAD: MPEG Audio Decoder 0.15.1 (beta) NDEBUG FPM_DEFAULT
+#else
+                                    0}, // CoreAudio Version 11.7.8 (Build 20G1351)
+#endif
+
+            {QStringLiteral("cover-test-vbr.mp3"),
+#if defined(__LINUX__) || defined(__WINDOWS__)
+                    3376}, // MAD: MPEG Audio Decoder 0.15.1 (beta) NDEBUG FPM_64BIT
+#else
+                    2318}, // CoreAudio Version 11.7.8 (Build 20G1351)
+#endif
+            // 3326 MAD: MPEG Audio Decoder 0.15.1 (beta) NDEBUG FPM_DEFAULT
+            // No offset compared to FPM_64BIT builds but rounding differences
+            // https://github.com/mixxxdj/mixxx/issues/11888
+            // 1166 FFmpeg
+
+            {QStringLiteral("cover-test.ogg"), 1166},
+            {QStringLiteral("cover-test.opus"), 1268},
+            {QStringLiteral("cover-test.wav"), 1166},
+            {QStringLiteral("cover-test.wav"), 1166},
+            {QStringLiteral("cover-test.wv"), 1166}};
+
+    for (const auto& ref : refs) {
+        QString filePath = getTestDir().filePath(
+                QStringLiteral("id3-test-data/") +
+                ref.path);
+        ASSERT_TRUE(SoundSourceProxy::isFileNameSupported(filePath));
+        const auto fileUrl = QUrl::fromLocalFile(filePath);
+        const auto providerRegistrations =
+                SoundSourceProxy::allProviderRegistrationsForUrl(fileUrl);
+        for (const auto& providerRegistration : providerRegistrations) {
+            mixxx::AudioSourcePointer pContReadSource = openAudioSource(
+                    filePath,
+                    providerRegistration.getProvider());
+
+            // Obtaining an AudioSource may fail for unsupported file formats,
+            // even if the corresponding file extension is supported, e.g.
+            // AAC vs. ALAC in .m4a files
+            if (!pContReadSource) {
+                // skip test file
+                continue;
+            }
+            mixxx::SampleBuffer contReadData(
+                    pContReadSource->getSignalInfo().frames2samples(kReadFrameCount));
+
+            SINT contFrameIndex = pContReadSource->frameIndexMin();
+            while (pContReadSource->frameIndexRange().containsIndex(contFrameIndex)) {
+                const auto readFrameIndexRange =
+                        mixxx::IndexRange::forward(contFrameIndex, kReadFrameCount);
+                // Read next chunk of frames for Cont source without seeking
+                const auto contSampleFrames =
+                        pContReadSource->readSampleFrames(
+                                mixxx::WritableSampleFrames(
+                                        readFrameIndexRange,
+                                        mixxx::SampleBuffer::WritableSlice(contReadData)));
+                ASSERT_FALSE(contSampleFrames.frameIndexRange().empty());
+                ASSERT_TRUE(contSampleFrames.frameIndexRange().isSubrangeOf(readFrameIndexRange));
+                ASSERT_EQ(contSampleFrames.frameIndexRange().start(), readFrameIndexRange.start());
+                contFrameIndex += contSampleFrames.frameLength();
+
+                const SINT sampleCount =
+                        pContReadSource->getSignalInfo().frames2samples(
+                                contSampleFrames.frameLength());
+
+                auto samples = std::span<const CSAMPLE>(&contReadData[0], sampleCount);
+
+                const SINT firstSoundSample = AnalyzerSilence::findFirstSoundInChunk(samples);
+                if (firstSoundSample < static_cast<SINT>(samples.size())) {
+                    EXPECT_EQ(firstSoundSample, ref.firstSoundSample)
+                            << filePath.toStdString() << " "
+                            << providerRegistration.getProvider()
+                                       ->getDisplayName()
+                                       .toStdString();
+                    break;
+                }
+            }
+            break;
+        }
+    }
+}
+
 TEST_F(SoundSourceProxyTest, getTypeFromFile) {
     QTemporaryDir tempDir;
     ASSERT_TRUE(tempDir.isValid());

src/util/macosversion.h

@@ -0,0 +1,5 @@
+#pragma once
+
+#include <QString>
+
+QString getMacOsVersion();