Full Implementation: Support for custom recording samplerates across output file formats and encoders.

All bugs fixed.

Author: armaan

.gitignore

@@ -66,5 +66,3 @@ src/mixxx.rc.include
 src/mixxx.res
 src/test/**/*.actual
 res/qrc_mixxx.cc
-
-res/translations/source_copy_allow_list*.tsv

src/coreservices.cpp

@@ -436,7 +436,6 @@ void CoreServices::initializeSettings() {
     }
 #endif
     QString settingsPath = m_cmdlineArgs.getSettingsPath();
-    qDebug() << settingsPath;
     m_pSettingsManager = std::make_unique<SettingsManager>(settingsPath);
 }
 
@@ -650,7 +649,6 @@ void CoreServices::initialize(QApplication* pApp) {
     // Initialize controller sub-system,
     // but do not set up controllers until the end of the application startup
     // (long)
-    qDebug() << "Creating ControllerManager";
     m_pControllerManager = std::make_shared<ControllerManager>(pConfig);
 
     // Scan the library for new files and directories

src/encoder/encoder.cpp

@@ -126,6 +126,7 @@ EncoderPointer EncoderFactory::createEncoder(
         DEBUG_ASSERT(false);
         pEncoder = std::make_shared<EncoderWave>(pCallback);
     }
+    pEncoder->initResampler();
     return pEncoder;
 }
 
@@ -155,3 +156,20 @@ EncoderRecordingSettingsPointer EncoderFactory::getEncoderRecordingSettings(Enco
         return std::make_shared<EncoderWaveSettings>(pConfig, ENCODING_WAVE);
     }
 }
+
+void Encoder::initResampler() {
+    m_pRecResampler = std::make_unique<EngineBufferScaleSR>();
+}
+
+double Encoder::recResampleBuffer(
+        const CSAMPLE* pInputBuffer,
+        CSAMPLE* pOutputBuffer,
+        SINT iInputBufferSize, /*#samples*/
+        double baseRate) {
+    double outputFramesGenerated{};
+    outputFramesGenerated = m_pRecResampler->recScaleBuffer(pInputBuffer,
+            pOutputBuffer,
+            iInputBufferSize,
+            baseRate); // needs to consume all input frames.
+    return outputFramesGenerated;
+}

src/encoder/encoder.h

@@ -4,6 +4,7 @@
 
 #include "encoder/encoderrecordingsettings.h"
 #include "encoder/encodersettings.h"
+#include "engine/bufferscalers/enginebufferscalesr.h"
 #include "preferences/usersettings.h"
 #include "util/types.h"
 
@@ -24,7 +25,8 @@ class Encoder {
         QString fileExtension;
     };
 
-    Encoder() {}
+    Encoder()
+            : m_pRecResampler(nullptr) {};
     virtual ~Encoder() = default;
 
     virtual int initEncoder(mixxx::audio::SampleRate sampleRate, QString* pUserErrorMessage) = 0;
@@ -37,6 +39,18 @@ class Encoder {
     virtual void flush() = 0;
     // Setup the encoder with the specific settings
     virtual void setEncoderSettings(const EncoderSettings& settings) = 0;
+    // Create a bufferscaler object to resample the input buffer (at engine samplerate)
+    // to recording samplerate
+    virtual void initResampler();
+
+    double recResampleBuffer(
+            const CSAMPLE* pInputBuffer,
+            CSAMPLE* pOutputBuffer,
+            SINT iInputBufferSize, /*#samples*/
+            double baseRate);
+
+  private:
+    std::unique_ptr<EngineBufferScaleSR> m_pRecResampler;
 };
 
 typedef std::shared_ptr<Encoder> EncoderPointer;

src/encoder/encoderfdkaac.cpp

@@ -17,6 +17,9 @@
 namespace {
 // recommended in encoder documentation, section 2.4.1
 constexpr int kOutBufferBits = 6144;
+
+// 96Khz/8Khz (max_allowed_sample_rate / min_allowed_sample_rate)
+constexpr int kMaxInterpolationFactor = 12;
 const mixxx::Logger kLogger("EncoderFdkAac");
 } // namespace
 
@@ -345,7 +348,8 @@ int EncoderFdkAac::initEncoder(mixxx::audio::SampleRate sampleRate, QString* pUs
         delete m_pInputFifo;
         m_pInputFifo = nullptr;
     }
-    m_pInputFifo = new FIFO<SAMPLE>(EngineSideChain::SIDECHAIN_BUFFER_SIZE * 2);
+    m_pInputFifo = new FIFO<SAMPLE>(EngineSideChain::SIDECHAIN_BUFFER_SIZE * 2 *
+            kMaxInterpolationFactor);
 
     m_pFifoChunkBuffer.resize(m_readRequired * sizeof(SAMPLE));
     return 0;

src/encoder/encodermp3.cpp

@@ -147,7 +147,7 @@ void EncoderMp3::encodeBuffer(const CSAMPLE* samples, const std::size_t bufferSi
     int rc = 0;
 
     outsize = (int)((1.25 * bufferSize + 7200) + 1);
-    bufferOutGrow(outsize);
+    bufferOutGrow(outsize); // assuming this is to store the LAME-interpolated samples.
 
     bufferInGrow(bufferSize);
 
@@ -179,7 +179,8 @@ void EncoderMp3::initStream() {
 }
 
 int EncoderMp3::initEncoder(mixxx::audio::SampleRate sampleRate, QString* pUserErrorMessage) {
-    unsigned long samplerate_in = sampleRate;
+    unsigned long samplerate_in = sampleRate; // rec samplerate, i.e. samplerate
+                                              // of input stream to encoder
     // samplerate_out 0 means "let LAME pick the appropriate one"
     unsigned long samplerate_out = (samplerate_in > 48000 ? 48000 : 0);
 

src/encoder/encoderopus.cpp

@@ -19,7 +19,10 @@ constexpr int kMaxOpusBufferSize = 1+1275;
 // Opus frame duration in milliseconds. Fixed to 60ms
 constexpr int kOpusFrameMs = 60;
 constexpr int kOpusChannelCount = 2;
+constexpr int kMaxInterpolationFactor = 12; // when we have a 96khz/8khz recording base rate.
+
 // Opus only supports 48 and 96 kHz samplerates
+// XXX Redundant after both record,broadcast resampling are implemented.
 constexpr mixxx::audio::SampleRate kMainSampleRate = mixxx::audio::SampleRate(48000);
 
 const mixxx::Logger kLogger("EncoderOpus");
@@ -71,34 +74,35 @@ int getSerial() {
 }
 } // namespace
 
-//static
+// static
 mixxx::audio::SampleRate EncoderOpus::getMainSampleRate() {
     return kMainSampleRate;
 }
 
-//static
+// static
 QString EncoderOpus::getInvalidSamplerateMessage() {
     return QObject::tr(
             "Using Opus at samplerates other than 48 kHz "
             "is not supported by the Opus encoder. Please use "
             "48000 Hz in \"Sound Hardware\" preferences "
-            "or switch to a different encoding.");
+            ", switch to a different encoding "
+            ", or choose a custom recording samplerate.");
 };
 
 EncoderOpus::EncoderOpus(EncoderCallback* pCallback)
-    : m_bitrate(0),
-      m_bitrateMode(0),
-      m_channels(0),
-      m_readRequired(0),
-      m_pCallback(pCallback),
-      m_fifoBuffer(EngineSideChain::SIDECHAIN_BUFFER_SIZE * kOpusChannelCount),
-      m_pFifoChunkBuffer(),
-      m_pOpus(nullptr),
-      m_opusDataBuffer(kMaxOpusBufferSize),
-      m_header_write(false),
-      m_packetNumber(0),
-      m_granulePos(0)
-{
+        : m_bitrate(0),
+          m_bitrateMode(0),
+          m_channels(0),
+          m_readRequired(0),
+          m_pCallback(pCallback),
+          m_fifoBuffer(EngineSideChain::SIDECHAIN_BUFFER_SIZE *
+                  kOpusChannelCount * kMaxInterpolationFactor),
+          m_pFifoChunkBuffer(),
+          m_pOpus(nullptr),
+          m_opusDataBuffer(kMaxOpusBufferSize),
+          m_header_write(false),
+          m_packetNumber(0),
+          m_granulePos(0) {
     // Regarding m_pFifoBuffer:
     // Size the input FIFO buffer with twice the maximum possible sample count that can be
     // processed at once, to avoid skipping frames or waiting for the required sample count
@@ -139,19 +143,6 @@ void EncoderOpus::setEncoderSettings(const EncoderSettings& settings) {
 int EncoderOpus::initEncoder(mixxx::audio::SampleRate sampleRate, QString* pUserErrorMessage) {
     Q_UNUSED(pUserErrorMessage);
 
-    if (sampleRate != kMainSampleRate) {
-            kLogger.warning() << "initEncoder failed: samplerate not supported by Opus";
-
-            const QString invalidSamplerateMessage = getInvalidSamplerateMessage();
-
-            ErrorDialogProperties* props = ErrorDialogHandler::instance()->newDialogProperties();
-            props->setType(DLG_WARNING);
-            props->setTitle(QObject::tr("Encoder"));
-            props->setText(invalidSamplerateMessage);
-            props->setKey(invalidSamplerateMessage);
-            ErrorDialogHandler::instance()->requestErrorDialog(props);
-            return -1;
-    }
     m_sampleRate = sampleRate;
     DEBUG_ASSERT(m_sampleRate == 8000 || m_sampleRate == 12000 ||
             m_sampleRate == 16000 || m_sampleRate == 24000 ||

src/encoder/encoderwave.cpp

@@ -50,8 +50,12 @@ static sf_count_t  sf_f_read (void *ptr, sf_count_t count, void *user_data)
 //  with ptr and return the count of actually processed bytes.
 static sf_count_t sf_f_write (const void *ptr, sf_count_t count, void *user_data)
 {
+    qDebug() << "in sf_f_write";
     EncoderCallback* pCallback = static_cast<EncoderCallback*>(user_data);
-    pCallback->write(nullptr, static_cast<const unsigned char*>(ptr), 0, static_cast<int>(count));
+    pCallback->write(nullptr,
+            static_cast<const unsigned char*>(ptr),
+            0,
+            static_cast<int>(count)); // EngineRecord::write()
     return count;
 }
 
@@ -62,9 +66,6 @@ static sf_count_t  sf_f_tell (void *user_data)
     return pCallback->tell();
 }
 
-
-
-
 EncoderWave::EncoderWave(EncoderCallback* pCallback)
         : m_pCallback(pCallback),
           m_pSndfile(nullptr) {
@@ -138,7 +139,7 @@ void EncoderWave::flush() {
 
 void EncoderWave::encodeBuffer(const CSAMPLE* pBuffer, const std::size_t bufferSize) {
     qDebug() << "wave encoding buffer";
-    sf_write_float(m_pSndfile, pBuffer, bufferSize);
+    sf_write_float(m_pSndfile, pBuffer, bufferSize); // sndfile core calls user-defined sf_f_write
 }
 
 /* Originally called from enginebroadcast.cpp to update metadata information

src/engine/bufferscalers/enginebufferscalesr.cpp

@@ -2,49 +2,81 @@
 
 #include <QDebug>
 
+#include "engine/enginebuffer.h"
 #include "engine/readaheadmanager.h"
 #include "moc_enginebufferscalesr.cpp"
 #include "util/math.h"
 #include "util/sample.h"
 
-EngineBufferScaleSR::EngineBufferScaleSR(ReadAheadManager* pReadAheadManager)
-        : m_pReadAheadManager(pReadAheadManager),
-          m_bBackwards(false) {
-    qDebug() << "constructed enginebufferscaleSR";
+namespace {
+constexpr int kMaxInterpolationFactor = 12;
+} // namespace
+
+EngineBufferScaleSR::EngineBufferScaleSR()
+        : m_pResampler(nullptr) {
+    int error{};
+    m_dChannels = getOutputSignal().getChannelCount();
+    m_pResampler = src_new(SRC_SINC_BEST_QUALITY, m_dChannels.value(), &error);
+    if (error || !m_pResampler) {
+        qWarning() << "libsamplerate initialization error:" << src_strerror(error);
+        m_pResampler = nullptr;
+    }
+
+    clear();
 }
 
 EngineBufferScaleSR::~EngineBufferScaleSR() {
 }
 
-void EngineBufferScaleSR::setQuality(double engine_quality) {
-    m_pEngineQuality = engine_quality;
+void EngineBufferScaleSR::clear() {
+    if (m_pResampler) {
+        src_reset(m_pResampler);
+    }
 }
 
-// these parameters describe the "request" that
-// needs to be handled by libsamplerate.
-// use the default implementation for now.
-void EngineBufferScaleSR::setScaleParameters(double base_rate,
-        double* pTempoRatio,
-        double* pPitchRatio) {
-    (void)base_rate;
-    (void)pTempoRatio;
-    (void)pPitchRatio;
-}
+// baseRate: engine rate/recordingrate
+double EngineBufferScaleSR::recScaleBuffer(const CSAMPLE* pInputBuffer,
+        CSAMPLE* pOutputBuffer,
+        SINT iInputBufferSize,
+        double srcRatio) {
+    if (!pOutputBuffer || !pInputBuffer || iInputBufferSize <= 0) {
+        return 0.0;
+    }
+    qDebug() << "input buffer size samples (from sidechain): " << iInputBufferSize;
 
-void EngineBufferScaleSR::onSignalChanged() {
-    qDebug() << "onSignalChanged called";
-}
+    // create SRC_DATA struct
+    SRC_DATA src_data;
+    src_data.data_in = pInputBuffer;
 
-void EngineBufferScaleSR::clear() {
-    qDebug() << "clear called";
+    // frames that need to be resampled
+    SINT numInputFrames = getOutputSignal().samples2frames(iInputBufferSize);
+    src_data.input_frames = numInputFrames;
+    src_data.data_out = pOutputBuffer;
+
+    // max # output frames = (96khz/8khz) * #input frames
+    src_data.output_frames = kMaxInterpolationFactor * numInputFrames;
+
+    // conversion ratio
+    src_data.src_ratio = srcRatio;
+    src_data.end_of_input = 0;
+
+    int error = src_process(m_pResampler, &src_data);
+    if (error) {
+        qWarning() << "libsamplerate error:" << src_strerror(error);
+    }
+
+    SINT frames_generated = src_data.output_frames_gen;
+    qDebug() << "SRC consumed " << src_data.input_frames_used << " input frames, produced "
+             << frames_generated << " output frames";
+
+    return frames_generated;
 }
 
-// not called during regular playback
-double EngineBufferScaleSR::scaleBuffer(
-        CSAMPLE* pOutputBuffer,
-        SINT iOutputBufferSize) {
-    qDebug() << "scaling using libsamplerate";
-    (void)pOutputBuffer;
-    (void)iOutputBufferSize;
+double EngineBufferScaleSR::scaleBuffer(CSAMPLE* /*pBuffer*/, SINT /*iBufferSize*/) {
+    qWarning() << "Using temporary stub implementation";
     return 1.0;
 }
+
+void EngineBufferScaleSR::onSignalChanged() {
+    qWarning() << "Using temporary stub implementation";
+}

src/engine/bufferscalers/enginebufferscalesr.h

@@ -18,28 +18,24 @@ class ReadAheadManager;
 class EngineBufferScaleSR : public EngineBufferScale {
     Q_OBJECT
   public:
-    explicit EngineBufferScaleSR(
-            ReadAheadManager* pReadAheadManager);
+    explicit EngineBufferScaleSR(); // input driven
     ~EngineBufferScaleSR() override;
 
-    void setScaleParameters(double base_rate,
-            double* pTempoRatio,
-            double* pPitchRatio) override;
-
-    void setQuality(double engine_quality);
-
     // Main scaler method
     double scaleBuffer(
             CSAMPLE* pOutputBuffer,
             SINT iOutputBufferSize) override;
 
+    double recScaleBuffer(const CSAMPLE* pInputBuffer,
+            CSAMPLE* pOutputBuffer,
+            SINT iInputBufferSize,
+            double baseRate);
+
     void clear() override;
 
   private:
     void onSignalChanged() override;
 
-    ReadAheadManager* m_pReadAheadManager;
-
-    bool m_bBackwards;
-    double m_pEngineQuality;
+    mixxx::audio::ChannelCount m_dChannels;
+    SRC_STATE* m_pResampler;
 };