adding sample exporter

include/FlacExporter.h

@@ -0,0 +1,53 @@
+/*
+ * FlacExporter.h - exports .flac files outside of AudioEngine
+ *
+ * Copyright (c) 2024 - 2025 szeli1
+ *
+ * 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_FLAC_EXPORTER_H
+#define LMMS_FLAC_EXPORTER_H
+
+#include <sndfile.h>
+
+#include <QString>
+
+namespace lmms
+{
+
+class SampleFrame;
+
+class FlacExporter
+{
+public:
+	FlacExporter(int sampleRate, int bitDepth, const QString& outputLocationAndName);
+	~FlacExporter();
+
+	void writeThisBuffer(const SampleFrame* samples, size_t sampleCount);
+	bool getIsSuccesful() const;
+
+private:
+	bool m_isSuccesful;
+	SNDFILE* m_fileDescriptor;
+};
+
+} // namespace lmms
+
+#endif // LMMS_FLAC_EXPORTER_H

include/SampleClip.h

@@ -32,6 +32,7 @@
 namespace lmms
 {
 
+class ThreadedExportManager;
 class SampleBuffer;
 
 namespace gui
@@ -90,10 +91,18 @@ public slots:
 
 
 private:
+	void exportSampleBuffer(const QString& fileName);
+	static void exportSampleBufferCallback(void* thisObject);
+
 	Sample m_sample;
 	BoolModel m_recordModel;
 	bool m_isPlaying;
 
+	//! used when a sample is exported and before it is reinported
+	QString m_exportedSampleName;	
+
+	static std::unique_ptr<ThreadedExportManager> s_sampleExporter;
+
 	friend class gui::SampleClipView;
 
 

include/SampleClipView.h

@@ -48,6 +48,7 @@ public slots:
 	void updateSample();
 	void reverseSample();
 	void setAutomationGhost();
+	void exportSampleBuffer();
 
 
 

include/ThreadedExportManager.h

@@ -0,0 +1,76 @@
+/*
+ * ThreadedExportManager.h - exports files in .flac format on an other thread
+ *
+ * Copyright (c) 2024 - 2025 szeli1
+ *
+ * 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_THREADED_EXPORT_MANAGER_H
+#define LMMS_THREADED_EXPORT_MANAGER_H
+
+#include <atomic>
+#include <memory>
+#include <thread>
+#include <tuple>
+#include <vector>
+#include <mutex>
+
+#include <sndfile.h>
+
+#include <QString>
+
+namespace lmms
+{
+
+class SampleBuffer;
+
+typedef void (*callbackFn)(void*);
+
+class ThreadedExportManager
+{
+public:
+	ThreadedExportManager();
+	~ThreadedExportManager();
+
+	//! outputLocationAndName: should include path and name, could include ".flac"
+	void startExporting(const QString& outputLocationAndName, std::shared_ptr<const SampleBuffer> buffer, callbackFn callbackFunction = nullptr, void* callbackObject = nullptr);
+	void stopExporting();
+
+	//void writeBuffer(const SampleFrame* _ab, fpp_t const frames);
+
+private:
+	static void threadedExportFunction(ThreadedExportManager* thisExporter, volatile std::atomic<bool>* abortExport);
+
+	void stopThread();
+	bool openFile(const QString& outputLocationAndName, std::shared_ptr<const SampleBuffer> buffer);
+	void exportBuffer(std::shared_ptr<const SampleBuffer> buffer);
+	void closeFile();
+
+	std::vector<std::tuple<QString, std::shared_ptr<const SampleBuffer>, callbackFn, void*>> m_buffers;
+
+	volatile std::atomic<bool> m_abortExport;
+	bool m_isThreadRunning;
+	std::mutex m_readMutex;
+	std::thread* m_thread;
+};
+
+} // namespace lmms
+
+#endif // LMMS_THREADED_EXPORT_MANAGER_H

src/core/CMakeLists.txt

@@ -77,6 +77,7 @@ set(LMMS_SRCS
 	core/SerializingObject.cpp
 	core/Song.cpp
 	core/TempoSyncKnobModel.cpp
+	core/ThreadedExportManager.cpp
 	core/ThreadPool.cpp
 	core/Timeline.cpp
 	core/TimePos.cpp
@@ -106,6 +107,7 @@ set(LMMS_SRCS
 	core/audio/AudioPulseAudio.cpp
 	core/audio/AudioSampleRecorder.cpp
 	core/audio/AudioSdl.cpp
+	core/audio/FlacExporter.cpp
 
 	core/lv2/Lv2Basics.cpp
 	core/lv2/Lv2ControlBase.cpp

src/core/SampleClip.cpp

@@ -27,6 +27,7 @@
 #include <QDomElement>
 #include <QFileInfo>
 
+#include "ThreadedExportManager.h"
 #include "PathUtil.h"
 #include "SampleBuffer.h"
 #include "SampleClipView.h"
@@ -37,10 +38,14 @@
 namespace lmms
 {
 
-SampleClip::SampleClip(Track* _track, Sample sample, bool isPlaying)
-	: Clip(_track)
-	, m_sample(std::move(sample))
-	, m_isPlaying(false)
+std::unique_ptr<ThreadedExportManager> SampleClip::s_sampleExporter = std::make_unique<ThreadedExportManager>();
+
+
+SampleClip::SampleClip(Track* _track, Sample sample, bool isPlaying) :
+	Clip(_track),
+	m_sample(std::move(sample)),
+	m_isPlaying(false),
+	m_exportedSampleName("")
 {
 	saveJournallingState( false );
 	setSampleFile( "" );
@@ -79,6 +84,7 @@ SampleClip::SampleClip(Track* _track, Sample sample, bool isPlaying)
 			setAutoResize( false );
 			break;
 	}
+
 	updateTrackClips();
 }
 
@@ -336,5 +342,19 @@ gui::ClipView * SampleClip::createView( gui::TrackView * _tv )
 	return new gui::SampleClipView( this, _tv );
 }
 
+void SampleClip::exportSampleBuffer(const QString& fileName)
+{
+	m_exportedSampleName = fileName;
+	s_sampleExporter->startExporting(fileName, m_sample.buffer(), &SampleClip::exportSampleBufferCallback, this);
+}
+
+void SampleClip::exportSampleBufferCallback(void* thisObject)
+{
+	if (thisObject == nullptr) { return; }
+	SampleClip* castedThis = static_cast<SampleClip*>(thisObject);
+	castedThis->setSampleFile(castedThis->m_exportedSampleName);
+	castedThis->m_exportedSampleName.clear();
+}
+
 
 } // namespace lmms

src/core/ThreadedExportManager.cpp

@@ -0,0 +1,113 @@
+/*
+ * ThreadedExportManager.cpp - exports files in .flac format on an other thread
+ *
+ * Copyright (c) 2024 - 2025 szeli1
+ *
+ * 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.
+ *
+ */
+
+#include "ThreadedExportManager.h"
+
+#include "FlacExporter.h"
+#include "SampleBuffer.h"
+
+namespace lmms
+{
+
+ThreadedExportManager::ThreadedExportManager() :
+	m_abortExport(false),
+	m_isThreadRunning(false),
+	m_readMutex(),
+	m_thread(nullptr)
+{}
+
+ThreadedExportManager::~ThreadedExportManager()
+{
+	stopExporting();
+}
+
+
+void ThreadedExportManager::startExporting(const QString& outputLocationAndName, std::shared_ptr<const SampleBuffer> buffer, callbackFn callbackFunction, void* callbackObject)
+{
+	m_readMutex.lock();
+	m_buffers.push_back(std::make_tuple(outputLocationAndName, buffer, callbackFunction, callbackObject));
+	m_readMutex.unlock();
+
+	if (m_isThreadRunning == false)
+	{
+		stopExporting();
+		m_isThreadRunning = true;
+		m_thread = new std::thread(&ThreadedExportManager::threadedExportFunction, this, &m_abortExport);
+	}
+}
+
+void ThreadedExportManager::stopExporting()
+{
+	if (m_thread != nullptr)
+	{
+		if (m_isThreadRunning == true)
+		{
+			m_abortExport = true;
+		}
+		m_thread->join();
+		delete m_thread;
+		m_thread = nullptr;
+		m_isThreadRunning = false;
+		m_abortExport = false;
+	}
+}
+
+
+void ThreadedExportManager::threadedExportFunction(ThreadedExportManager* thisExporter, volatile std::atomic<bool>* abortExport)
+{
+	thisExporter->m_isThreadRunning = true;
+
+	while (*abortExport == false)
+	{
+		std::tuple<QString, std::shared_ptr<const SampleBuffer>, callbackFn, void*> curBuffer = std::make_tuple(QString(""), nullptr, nullptr, nullptr);
+		thisExporter->m_readMutex.lock();
+		bool shouldExit = thisExporter->m_buffers.size() <= 0;
+		if (shouldExit == false)
+		{
+			curBuffer = thisExporter->m_buffers[thisExporter->m_buffers.size() - 1];
+			thisExporter->m_buffers.pop_back();
+		}
+		thisExporter->m_readMutex.unlock();
+		if (shouldExit) { break; }
+
+		// important new scope
+		{
+			FlacExporter flacExporter(std::get<1>(curBuffer)->sampleRate(), 24, std::get<0>(curBuffer));
+			if (flacExporter.getIsSuccesful())
+			{
+				flacExporter.writeThisBuffer(std::get<1>(curBuffer)->data(), std::get<1>(curBuffer)->size());
+			}
+		}
+
+		if (std::get<2>(curBuffer))
+		{
+			// calling callback funcion
+			std::get<2>(curBuffer)(std::get<3>(curBuffer));
+		}
+	}
+
+	thisExporter->m_isThreadRunning = false;
+}
+
+} // namespace lmms