Add a cache for samples

include/AutomationEditor.h

@@ -292,7 +292,7 @@ protected slots:
 	QColor m_detuningNoteColor;
 	QColor m_ghostSampleColor;
 
-	SampleThumbnail m_sampleThumbnail;
+	std::shared_ptr<const SampleThumbnail> m_sampleThumbnail;
 
 	friend class AutomationEditorWindow;
 

include/EnvelopeAndLfoParameters.h

@@ -201,7 +201,7 @@ public slots:
 	sample_t * m_lfoShapeData;
 	sample_t m_random;
 	bool m_bad_lfoShapeData;
-	std::shared_ptr<const SampleBuffer> m_userWave = SampleBuffer::emptyBuffer();
+	std::shared_ptr<const SampleBuffer> m_userWave = std::make_shared<SampleBuffer>();
 
 	constexpr static auto NumLfoShapes = static_cast<std::size_t>(LfoShape::Count);
 

include/LfoController.h

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

include/Oscillator.h

@@ -168,8 +168,8 @@ class LMMS_EXPORT Oscillator
 
 	static sample_t userWaveSample(const SampleBuffer* buffer, const float sample)
 	{
-		if (buffer == nullptr || buffer->size() == 0) { return 0; }
-		const auto frames = buffer->size();
+		if (buffer == nullptr || buffer->data().size() == 0) { return 0; }
+		const auto frames = buffer->data().size();
 		const auto frame = absFraction(sample) * frames;
 		const auto f1 = static_cast<f_cnt_t>(frame);
 
@@ -251,7 +251,7 @@ class LMMS_EXPORT Oscillator
 	Oscillator * m_subOsc;
 	float m_phaseOffset;
 	float m_phase;
-	std::shared_ptr<const SampleBuffer> m_userWave = SampleBuffer::emptyBuffer();
+	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

include/PathUtil.h

@@ -28,6 +28,7 @@
 #include "lmms_export.h"
 
 #include <QDir>
+#include <filesystem>
 
 namespace lmms::PathUtil
 {
@@ -68,6 +69,12 @@ namespace lmms::PathUtil
 	//! Defaults to an absolute path if all bases fail.
 	QString LMMS_EXPORT toShortestRelative(const QString & input, bool allowLocal = false);
 
+	//! Converts a QString path to a STL filesystem path.
+	std::filesystem::path LMMS_EXPORT pathFromQString(const QString& path);
+
+	//! Converts an STL filesystem path to a QString path.
+	QString LMMS_EXPORT qStringFromPath(const std::filesystem::path& path);
+
 } // namespace lmms::PathUtil
 
 #endif // LMMS_PATHUTIL_H

include/ResourceCache.h

@@ -0,0 +1,124 @@
+/*
+ * ResourceCache.h
+ *
+ * Copyright (c) 2025 Sotonye Atemie <[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_RESOURCE_CACHE_H
+#define LMMS_RESOURCE_CACHE_H
+
+#include <QCryptographicHash>
+#include <array>
+#include <filesystem>
+#include <fstream>
+#include <memory>
+#include <unordered_map>
+
+namespace lmms {
+class ResourceCache
+{
+public:
+	static constexpr auto CacheSize = 32;
+
+	class Resource
+	{
+		int m_age = 0;
+		friend class ResourceCache;
+	};
+
+	template <typename V, typename K,
+		typename Enable
+		= std::enable_if_t<std::conjunction_v<std::is_base_of<Resource, V>, std::is_default_constructible<V>>>,
+		typename... Args>
+	static auto fetch(const K& key, Args&&... args) -> std::shared_ptr<const V>
+	{
+		const auto digest = hash(key);
+		if (digest.empty()) { return std::make_shared<V>(); }
+
+		auto& resource = s_resources[digest];
+
+		if (resource == nullptr)
+		{
+			if (s_resources.size() == CacheSize)
+			{
+				const auto it = std::min_element(s_resources.begin(), s_resources.end(),
+					[](const auto& first, const auto& second) { return first.second->m_age < first.second->m_age; });
+				s_resources.erase(it);
+			}
+
+			try
+			{
+				resource = std::make_shared<V>(key, std::forward<Args>(args)...);
+			}
+			catch (const std::runtime_error& error)
+			{
+				return std::make_shared<V>();
+			}
+
+			return std::static_pointer_cast<const V>(resource);
+		}
+
+		++resource->m_age;
+		return std::static_pointer_cast<const V>(resource);
+	}
+
+	static auto instance() -> ResourceCache&
+	{
+		static auto s_inst = ResourceCache{};
+		return s_inst;
+	}
+
+private:
+	static auto hash(const std::filesystem::path& path) -> std::string
+	{
+		if (!std::filesystem::exists(path)) { return std::string{}; }
+
+		static constexpr auto blockSize = 8192;
+		static auto block = std::array<char, blockSize>{};
+		static auto hash = QCryptographicHash{QCryptographicHash::Md5};
+
+		auto fstream = std::fstream{path, std::ios::in | std::ios::binary};
+		if (!fstream.is_open()) { return std::string{}; }
+
+		hash.reset();
+
+		do
+		{
+			fstream.read(block.data(), blockSize);
+			hash.addData(block.data(), fstream.gcount());
+		} while (fstream.gcount() > 0);
+
+		return hash.result().toStdString();
+	}
+
+	static auto hash(const std::string& key) -> std::string
+	{
+		const auto data = QByteArray::fromStdString(key);
+		const auto hash = QCryptographicHash::hash(data, QCryptographicHash::Md5).toStdString();
+		return hash;
+	}
+
+	ResourceCache() { s_resources.reserve(CacheSize); }
+	inline static std::unordered_map<std::string, std::shared_ptr<Resource>> s_resources;
+};
+} // namespace lmms
+
+#endif // LMMS_RESOURCE_CACHE_H

include/Sample.h

@@ -28,8 +28,11 @@
 #include <cmath>
 #include <memory>
 
+#include "AudioEngine.h"
 #include "AudioResampler.h"
+#include "Engine.h"
 #include "Note.h"
+#include "PathUtil.h"
 #include "SampleBuffer.h"
 #include "lmms_export.h"
 
@@ -90,14 +93,11 @@ class LMMS_EXPORT Sample
 	auto play(SampleFrame* dst, PlaybackState* state, size_t numFrames, float desiredFrequency = DefaultBaseFreq,
 		Loop loopMode = Loop::Off) const -> bool;
 
-	auto sampleDuration() const -> std::chrono::milliseconds;
-	auto sampleFile() const -> const QString& { return m_buffer->audioFile(); }
-	auto sampleRate() const -> int { return m_buffer->sampleRate(); }
+	auto sampleFile() const -> QString { return PathUtil::qStringFromPath(m_buffer->path()); }
 	auto sampleSize() const -> size_t { return m_buffer->size(); }
+	auto sampleRate() const -> int { return m_buffer->sampleRate(); }
+	auto sampleDuration() const -> std::chrono::milliseconds;
 
-	auto toBase64() const -> QString { return m_buffer->toBase64(); }
-
-	auto data() const -> 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); }
@@ -121,7 +121,7 @@ class LMMS_EXPORT Sample
 	void advance(PlaybackState* state, size_t advanceAmount, Loop loopMode) const;
 
 private:
-	std::shared_ptr<const SampleBuffer> m_buffer = SampleBuffer::emptyBuffer();
+	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;

include/SampleBuffer.h

@@ -25,73 +25,48 @@
 #ifndef LMMS_SAMPLE_BUFFER_H
 #define LMMS_SAMPLE_BUFFER_H
 
-#include <QByteArray>
-#include <QString>
-#include <memory>
-#include <optional>
-#include <samplerate.h>
 #include <vector>
 
 #include "AudioEngine.h"
 #include "Engine.h"
-#include "lmms_basics.h"
+#include "ResourceCache.h"
+#include "SampleFrame.h"
 #include "lmms_export.h"
 
 namespace lmms {
-class LMMS_EXPORT SampleBuffer
+
+class LMMS_EXPORT SampleBuffer : public ResourceCache::Resource
 {
 public:
-	using value_type = SampleFrame;
-	using reference = SampleFrame&;
-	using const_reference = const SampleFrame&;
-	using iterator = std::vector<SampleFrame>::iterator;
-	using const_iterator = std::vector<SampleFrame>::const_iterator;
-	using difference_type = std::vector<SampleFrame>::difference_type;
-	using size_type = std::vector<SampleFrame>::size_type;
-	using reverse_iterator = std::vector<SampleFrame>::reverse_iterator;
-	using const_reverse_iterator = std::vector<SampleFrame>::const_reverse_iterator;
-
 	SampleBuffer() = default;
-	explicit SampleBuffer(const QString& audioFile);
-	SampleBuffer(const QString& base64, int sampleRate);
-	SampleBuffer(std::vector<SampleFrame> data, int sampleRate);
-	SampleBuffer(
-		const SampleFrame* data, size_t numFrames, int sampleRate = Engine::audioEngine()->outputSampleRate());
-
-	friend void swap(SampleBuffer& first, SampleBuffer& second) noexcept;
-	auto toBase64() const -> QString;
-
-	auto audioFile() const -> const QString& { return m_audioFile; }
-	auto sampleRate() const -> sample_rate_t { return m_sampleRate; }
-
-	auto begin() -> iterator { return m_data.begin(); }
-	auto end() -> iterator { return m_data.end(); }
+	explicit SampleBuffer(const std::filesystem::path& path);
+	SampleBuffer(const std::string& base64, int sampleRate = Engine::audioEngine()->outputSampleRate());
+	SampleBuffer(const SampleFrame* buffer, size_t size, int sampleRate);
+	SampleBuffer(std::vector<SampleFrame> buffer, int sampleRate);
 
-	auto begin() const -> const_iterator { return m_data.begin(); }
-	auto end() const -> const_iterator { return m_data.end(); }
+	std::string toBase64() const;
 
-	auto cbegin() const -> const_iterator { return m_data.cbegin(); }
-	auto cend() const -> const_iterator { return m_data.cend(); }
+	int sampleRate() const { return m_sampleRate; }
+	void setSampleRate(int sampleRate) { m_sampleRate = sampleRate; }
 
-	auto rbegin() -> reverse_iterator { return m_data.rbegin(); }
-	auto rend() -> reverse_iterator { return m_data.rend(); }
+	auto path() const -> const std::filesystem::path& { return m_path; }
 
-	auto rbegin() const -> const_reverse_iterator { return m_data.rbegin(); }
-	auto rend() const -> const_reverse_iterator { return m_data.rend(); }
+	auto data() const -> const std::vector<SampleFrame>& { return m_data; }
+	auto data() -> std::vector<SampleFrame>& { return m_data; }
 
-	auto crbegin() const -> const_reverse_iterator { return m_data.crbegin(); }
-	auto crend() const -> const_reverse_iterator { return m_data.crend(); }
+	auto size() const { return m_data.size(); }
+	auto empty() const { return m_data.empty(); }
 
-	auto data() const -> const SampleFrame* { return m_data.data(); }
-	auto size() const -> size_type { return m_data.size(); }
-	auto empty() const -> bool { return m_data.empty(); }
+	auto begin() const { return m_data.begin(); }
+	auto begin() { return m_data.begin(); }
 
-	static auto emptyBuffer() -> std::shared_ptr<const SampleBuffer>;
+	auto end() const { return m_data.end(); }
+	auto end() { return m_data.end(); }
 
 private:
 	std::vector<SampleFrame> m_data;
-	QString m_audioFile;
-	sample_rate_t m_sampleRate = Engine::audioEngine()->outputSampleRate();
+	std::filesystem::path m_path;
+	int m_sampleRate = 0;
 };
 
 } // namespace lmms

include/SampleClip.h

@@ -56,7 +56,7 @@ class SampleClip : public Clip
 
 	void changeLength( const TimePos & _length ) override;
 	void changeLengthToSampleLength();
-	const QString& sampleFile() const;
+	QString sampleFile() const;
 	bool hasSampleFileLoaded(const QString & filename) const;
 
 	void saveSettings( QDomDocument & _doc, QDomElement & _parent ) override;

include/SampleClipView.h

@@ -65,7 +65,7 @@ public slots:
 
 private:
 	SampleClip * m_clip;
-	SampleThumbnail m_sampleThumbnail;
+	std::shared_ptr<const SampleThumbnail> m_sampleThumbnail;
 	QPixmap m_paintPixmap;
 	bool splitClip( const TimePos pos ) override;
 } ;

include/SampleLoader.h → include/SampleFilePicker.h

@@ -1,7 +1,7 @@
 /*
- * SampleLoader.h - Load audio and waveform files
+ * SampleFilePicker.h
  *
- * Copyright (c) 2023 saker <[email protected]>
+ * Copyright (c) 2024 saker
  *
  * This file is part of LMMS - https://lmms.io
  *
@@ -22,27 +22,19 @@
  *
  */
 
-#ifndef LMMS_GUI_SAMPLE_LOADER_H
-#define LMMS_GUI_SAMPLE_LOADER_H
+#ifndef LMMS_GUI_SAMPLE_FILE_PICKER_H
+#define LMMS_GUI_SAMPLE_FILE_PICKER_H
 
 #include <QString>
-#include <memory>
-
-#include "SampleBuffer.h"
 #include "lmms_export.h"
 
 namespace lmms::gui {
-class LMMS_EXPORT SampleLoader
+class LMMS_EXPORT SampleFilePicker
 {
 public:
 	static QString openAudioFile(const QString& previousFile = "");
 	static QString openWaveformFile(const QString& previousFile = "");
-	static std::shared_ptr<const SampleBuffer> createBufferFromFile(const QString& filePath);
-	static std::shared_ptr<const SampleBuffer> createBufferFromBase64(
-		const QString& base64, int sampleRate = Engine::audioEngine()->outputSampleRate());
-private:
-	static void displayError(const QString& message);
 };
 } // namespace lmms::gui
 
-#endif // LMMS_GUI_SAMPLE_LOADER_H
+#endif // LMMS_GUI_SAMPLE_FILE_PICKER_H