Refactor SampleBuffer

include/AudioSampleRecorder.h

@@ -28,6 +28,7 @@
 
 #include <QList>
 #include <QPair>
+#include <memory>
 
 #include "AudioDevice.h"
 
@@ -44,8 +45,7 @@ class AudioSampleRecorder : public AudioDevice
 	~AudioSampleRecorder() override;
 
 	f_cnt_t framesRecorded() const;
-	void createSampleBuffer( SampleBuffer** sampleBuffer );
-
+	std::unique_ptr<SampleBuffer> createSampleBuffer();
 
 private:
 	void writeBuffer( const surroundSampleFrame * _ab,

include/EnvelopeAndLfoParameters.h

@@ -25,6 +25,7 @@
 #ifndef LMMS_ENVELOPE_AND_LFO_PARAMETERS_H
 #define LMMS_ENVELOPE_AND_LFO_PARAMETERS_H
 
+#include <memory>
 #include <vector>
 
 #include "JournallingObject.h"
@@ -167,7 +168,7 @@ public slots:
 	sample_t * m_lfoShapeData;
 	sample_t m_random;
 	bool m_bad_lfoShapeData;
-	SampleBuffer m_userWave;
+	std::shared_ptr<const SampleBuffer> m_userWave = std::make_shared<SampleBuffer>();
 
 	enum class LfoShape
 	{

include/LfoController.h

@@ -87,7 +87,7 @@ public slots:
 
 private:
 	float m_heldSample;
-	SampleBuffer * m_userDefSampleBuffer;
+	std::shared_ptr<const SampleBuffer> m_userDefSampleBuffer = std::make_shared<SampleBuffer>();
 
 protected slots:
 	void updatePhase();

include/Oscillator.h

@@ -28,7 +28,9 @@
 
 #include <cassert>
 #include <fftw3.h>
+#include <memory>
 #include <cstdlib>
+#include "interpolation.h"
 
 #include "Engine.h"
 #include "lmms_constants.h"
@@ -46,7 +48,6 @@ class IntModel;
 
 class LMMS_EXPORT Oscillator
 {
-	MM_OPERATORS
 public:
 	enum class WaveShape
 	{
@@ -91,18 +92,23 @@ class LMMS_EXPORT Oscillator
 
 	static void waveTableInit();
 	static void destroyFFTPlans();
-	static void generateAntiAliasUserWaveTable(SampleBuffer* sampleBuffer);
+	static std::unique_ptr<OscillatorConstants::waveform_t> generateAntiAliasUserWaveTable(const SampleBuffer* sampleBuffer);
 
 	inline void setUseWaveTable(bool n)
 	{
 		m_useWaveTable = n;
 	}
 
-	inline void setUserWave( const SampleBuffer * _wave )
+	inline void setUserWave(std::shared_ptr<const SampleBuffer> _wave)
 	{
 		m_userWave = _wave;
 	}
 
+	inline void setUserAntiAliasWaveTable(std::shared_ptr<const OscillatorConstants::waveform_t> waveform)
+	{
+		m_userAntiAliasWaveTable = waveform;
+	}
+
 	void update(sampleFrame* ab, const fpp_t frames, const ch_cnt_t chnl, bool modulator = false);
 
 	// now follow the wave-shape-routines...
@@ -164,9 +170,18 @@ class LMMS_EXPORT Oscillator
 		return 1.0f - fast_rand() * 2.0f / FAST_RAND_MAX;
 	}
 
-	inline sample_t userWaveSample( const float _sample ) const
+	static inline sample_t userWaveSample(const SampleBuffer* buffer, const float sample)
 	{
-		return m_userWave->userWaveSample( _sample );
+		if (buffer == nullptr || buffer->size() == 0) { return 0; }
+		const auto frames = buffer->size();
+		const auto frame = sample * frames;
+		auto f1 = static_cast<f_cnt_t>(frame) % frames;
+		if (f1 < 0)
+		{
+			f1 += frames;
+		}
+
+		return linearInterpolate(buffer->data()[f1][0], buffer->data()[(f1 + 1) % frames][0], fraction(frame));
 	}
 
 	struct wtSampleControl {
@@ -203,7 +218,7 @@ class LMMS_EXPORT Oscillator
 				table[control.band][control.f2], fraction(control.frame));
 	}
 
-	inline sample_t wtSample(const std::unique_ptr<OscillatorConstants::waveform_t>& table, const float sample) const
+	inline sample_t wtSample(const OscillatorConstants::waveform_t* table, const float sample) const
 	{
 		assert(table != nullptr);
 		wtSampleControl control = getWtSampleControl(sample);
@@ -247,7 +262,8 @@ class LMMS_EXPORT Oscillator
 	Oscillator * m_subOsc;
 	float m_phaseOffset;
 	float m_phase;
-	const SampleBuffer * m_userWave;
+	std::shared_ptr<const SampleBuffer> m_userWave = std::make_shared<SampleBuffer>();
+	std::shared_ptr<const OscillatorConstants::waveform_t> m_userAntiAliasWaveTable;
 	bool m_useWaveTable;
 	// There are many update*() variants; the modulator flag is stored as a member variable to avoid
 	// adding more explicit parameters to all of them. Can be converted to a parameter if needed.

include/Sample.h

@@ -0,0 +1,158 @@
+/*
+ * Sample.h - State for container-class SampleBuffer
+ *
+ * Copyright (c) 2023 saker <[email protected]>
+ *
+ * This file is part of LMMS - https://lmms.io
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public
+ * License along with this program (see COPYING); if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301 USA.
+ *
+ */
+
+#ifndef LMMS_SAMPLE_H
+#define LMMS_SAMPLE_H
+
+#include <cmath>
+#include <memory>
+
+#include "Note.h"
+#include "SampleBuffer.h"
+#include "lmms_export.h"
+
+#ifdef __MINGW32__
+#include <mingw.mutex.h>
+#include <mingw.shared_mutex.h>
+#else
+#include <mutex>
+#include <shared_mutex>
+#endif
+
+class QPainter;
+class QRect;
+
+namespace lmms {
+class LMMS_EXPORT Sample
+{
+public:
+	// values for buffer margins, used for various libsamplerate interpolation modes
+	// the array positions correspond to the converter_type parameter values in libsamplerate
+	// if there appears problems with playback on some interpolation mode, then the value for that mode
+	// may need to be higher - conversely, to optimize, some may work with lower values
+	static constexpr auto s_interpolationMargins = std::array<int, 5>{64, 64, 64, 4, 4};
+
+	enum class Loop
+	{
+		Off,
+		On,
+		PingPong
+	};
+
+	class LMMS_EXPORT PlaybackState
+	{
+	public:
+		PlaybackState(bool varyingPitch = false, int interpolationMode = SRC_LINEAR)
+			: m_varyingPitch(varyingPitch)
+			, m_interpolationMode(interpolationMode)
+		{
+			auto error = 0;
+			m_resampleState = src_new(m_interpolationMode, DEFAULT_CHANNELS, &error);
+			if (error != 0)
+			{
+				throw std::runtime_error{"Error creating resample state: " + std::string{src_strerror(error)}};
+			}
+		}
+
+		~PlaybackState() noexcept { src_delete(m_resampleState); }
+
+		auto frameIndex() const -> f_cnt_t { return m_frameIndex; }
+		auto varyingPitch() const -> bool { return m_varyingPitch; }
+		auto backwards() const -> bool { return m_backwards; }
+		auto interpolationMode() const -> int { return m_interpolationMode; }
+
+		auto setFrameIndex(f_cnt_t frameIndex) -> void { m_frameIndex = frameIndex; }
+		auto setVaryingPitch(bool varyingPitch) -> void { m_varyingPitch = varyingPitch; }
+		auto setBackwards(bool backwards) -> void { m_backwards = backwards; }
+
+	private:
+		f_cnt_t m_frameIndex = 0;
+		bool m_varyingPitch = false;
+		bool m_backwards = false;
+		SRC_STATE* m_resampleState = nullptr;
+		int m_interpolationMode = SRC_LINEAR;
+		friend class Sample;
+	};
+
+	Sample() = default;
+	Sample(const QByteArray& base64, int sampleRate = Engine::audioEngine()->processingSampleRate());
+	Sample(const sampleFrame* data, int numFrames, int sampleRate = Engine::audioEngine()->processingSampleRate());
+	Sample(const Sample& other);
+	Sample(Sample&& other);
+	explicit Sample(const QString& audioFile);
+	explicit Sample(std::shared_ptr<const SampleBuffer> buffer);
+
+	auto operator=(const Sample&) -> Sample&;
+	auto operator=(Sample&&) -> Sample&;
+
+	auto play(sampleFrame* dst, PlaybackState* state, int numFrames, float desiredFrequency = DefaultBaseFreq,
+		Loop loopMode = Loop::Off) const -> bool;
+	auto visualize(QPainter& p, const QRect& dr, int fromFrame = 0, int toFrame = 0) const -> void;
+
+	auto sampleDuration() const -> std::chrono::milliseconds;
+	auto sampleFile() const -> const QString& { return m_buffer->audioFile(); }
+	auto sampleRate() const -> int { return m_buffer->sampleRate(); }
+	auto sampleSize() const -> int { return m_buffer->size(); }
+
+	auto toBase64() const -> QString { return m_buffer->toBase64(); }
+
+	auto data() -> const sampleFrame* { return m_buffer->data(); }
+	auto buffer() const -> std::shared_ptr<const SampleBuffer> { return m_buffer; }
+	auto startFrame() const -> int { return m_startFrame.load(std::memory_order_relaxed); }
+	auto endFrame() const -> int { return m_endFrame.load(std::memory_order_relaxed); }
+	auto loopStartFrame() const -> int { return m_loopStartFrame.load(std::memory_order_relaxed); }
+	auto loopEndFrame() const -> int { return m_loopEndFrame.load(std::memory_order_relaxed); }
+	auto amplification() const -> float { return m_amplification.load(std::memory_order_relaxed); }
+	auto frequency() const -> float { return m_frequency.load(std::memory_order_relaxed); }
+	auto reversed() const -> bool { return m_reversed.load(std::memory_order_relaxed); }
+
+	auto setStartFrame(int startFrame) -> void { m_startFrame.store(startFrame, std::memory_order_relaxed); }
+	auto setEndFrame(int endFrame) -> void { m_endFrame.store(endFrame, std::memory_order_relaxed); }
+	auto setLoopStartFrame(int loopStartFrame) -> void { m_loopStartFrame.store(loopStartFrame, std::memory_order_relaxed); }
+	auto setLoopEndFrame(int loopEndFrame) -> void { m_loopEndFrame.store(loopEndFrame, std::memory_order_relaxed); }
+	auto setAllPointFrames(int startFrame, int endFrame, int loopStartFrame, int loopEndFrame) -> void;
+	auto setAmplification(float amplification) -> void { m_amplification.store(amplification, std::memory_order_relaxed); }
+	auto setFrequency(float frequency) -> void { m_frequency.store(frequency, std::memory_order_relaxed); }
+	auto setReversed(bool reversed) -> void { m_reversed.store(reversed, std::memory_order_relaxed); }
+
+private:
+	auto playSampleRange(PlaybackState* state, sampleFrame* dst, size_t numFrames) const -> void;
+	auto resampleSampleRange(SRC_STATE* state, sampleFrame* src, sampleFrame* dst, size_t numInputFrames,
+		size_t numOutputFrames, double ratio) const -> SRC_DATA;
+	auto amplifySampleRange(sampleFrame* src, int numFrames) const -> void;
+	auto copyBufferForward(sampleFrame* dst, int initialPosition, int advanceAmount) const -> void;
+	auto copyBufferBackward(sampleFrame* dst, int initialPosition, int advanceAmount) const -> void;
+
+private:
+	std::shared_ptr<const SampleBuffer> m_buffer = std::make_shared<SampleBuffer>();
+	std::atomic<int> m_startFrame = 0;
+	std::atomic<int> m_endFrame = 0;
+	std::atomic<int> m_loopStartFrame = 0;
+	std::atomic<int> m_loopEndFrame = 0;
+	std::atomic<float> m_amplification = 1.0f;
+	std::atomic<float> m_frequency = DefaultBaseFreq;
+	std::atomic<bool> m_reversed = false;
+};
+} // namespace lmms
+#endif