From 21946135375a4cdb019b6227cf98c304e8d8355f Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Sun, 3 Sep 2023 17:11:15 +0200
Subject: [PATCH 01/99] extremly basic slicer, note playback and gui works

---
 plugins/CMakeLists.txt        |   1 +
 plugins/Slicer/CMakeLists.txt |   5 +
 plugins/Slicer/SlicerT.cpp    | 201 ++++++++++++++++++++++++++++++++++
 plugins/Slicer/SlicerT.h      |  81 ++++++++++++++
 plugins/Slicer/SlicerTUI.cpp  | 111 +++++++++++++++++++
 plugins/Slicer/SlicerTUI.h    |  59 ++++++++++
 plugins/Slicer/WaveForm.cpp   |  57 ++++++++++
 plugins/Slicer/WaveForm.h     |  52 +++++++++
 plugins/Slicer/logo.png       | Bin 0 -> 1109 bytes
 9 files changed, 567 insertions(+)
 create mode 100644 plugins/Slicer/CMakeLists.txt
 create mode 100644 plugins/Slicer/SlicerT.cpp
 create mode 100644 plugins/Slicer/SlicerT.h
 create mode 100644 plugins/Slicer/SlicerTUI.cpp
 create mode 100644 plugins/Slicer/SlicerTUI.h
 create mode 100644 plugins/Slicer/WaveForm.cpp
 create mode 100644 plugins/Slicer/WaveForm.h
 create mode 100644 plugins/Slicer/logo.png

diff --git a/plugins/CMakeLists.txt b/plugins/CMakeLists.txt
index 9a71be4b823..9d083dfe1ab 100644
--- a/plugins/CMakeLists.txt
+++ b/plugins/CMakeLists.txt
@@ -18,3 +18,4 @@ INCLUDE_DIRECTORIES(
 FOREACH(PLUGIN ${PLUGIN_LIST})
 	ADD_SUBDIRECTORY(${PLUGIN})
 ENDFOREACH()
+ADD_SUBDIRECTORY("Slicer")
diff --git a/plugins/Slicer/CMakeLists.txt b/plugins/Slicer/CMakeLists.txt
new file mode 100644
index 00000000000..b93021e98f9
--- /dev/null
+++ b/plugins/Slicer/CMakeLists.txt
@@ -0,0 +1,5 @@
+INCLUDE(BuildPlugin)
+
+BUILD_PLUGIN(slicert SlicerT.cpp SlicerT.h SlicerTUI.cpp SlicerTUI.h WaveForm.cpp WaveForm.h MOCFILES SlicerT.h SlicerTUI.h WaveForm.h EMBEDDED_RESOURCES "${CMAKE_CURRENT_SOURCE_DIR}/*.png")
+
+
diff --git a/plugins/Slicer/SlicerT.cpp b/plugins/Slicer/SlicerT.cpp
new file mode 100644
index 00000000000..8d832f33259
--- /dev/null
+++ b/plugins/Slicer/SlicerT.cpp
@@ -0,0 +1,201 @@
+/*
+ * Slicer.cpp - instrument which uses a usereditable wavetable
+ *
+ * Copyright (c) 2006-2008 Andreas Brandmaier <andy/at/brandmaier/dot/de>
+ * 
+ * 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 <QDomElement>
+#include <stdio.h>
+#include "SlicerT.h"
+
+
+// #include "AudioEngine.h"
+// #include "base64.h"
+// #include "Engine.h"
+// #include "Graph.h"
+#include "InstrumentTrack.h"
+// #include "Knob.h"
+// #include "LedCheckBox.h"
+// #include "NotePlayHandle.h"
+// #include "PixmapButton.h"
+// #include "Song.h"
+// #include "interpolation.h"
+
+
+#include "embed.h"
+#include "plugin_export.h"
+
+
+
+
+namespace lmms
+{
+
+
+
+extern "C"
+{
+
+Plugin::Descriptor PLUGIN_EXPORT slicert_plugin_descriptor =
+{
+	LMMS_STRINGIFY( PLUGIN_NAME ),
+	"SlicerT",
+	QT_TRANSLATE_NOOP( "PluginBrowser",
+				"A cool testPlugin" ),
+	"Daniel Kauss Serna>",
+	0x0100,
+	Plugin::Type::Instrument,
+	new PluginPixmapLoader( "logo" ),
+	nullptr,
+	nullptr,
+} ;
+
+}
+
+
+
+SlicerT::SlicerT(InstrumentTrack * _instrument_track) : 
+	Instrument( _instrument_track, &slicert_plugin_descriptor ),
+	m_sampleBuffer(),
+	noteThreshold( 0.2f, 0.0f, 1.0f, 0.01f, this, tr( "Note Threshold" ) )
+{
+	// connect( &noteThreshold, SIGNAL( dataChanged() ), this, SLOT( updateParams() ) );
+	printf("Correctly loaded SlicerT!\n");
+}
+
+
+void SlicerT::findSlices() {
+	int c = 0;
+	float lastAvg = 0;
+	float currentAvg = 0;
+	slicePoints = {};
+	for (int i = 0; i<m_sampleBuffer.endFrame();i+=1) {
+		// combine left and right and absolute it
+		float sampleValue = abs(m_sampleBuffer.data()[i][0]) + abs(m_sampleBuffer.data()[i][1]) / 2;
+		currentAvg += sampleValue;
+
+		if (i%128==0) {
+			currentAvg /= 128.0f;
+			//printf("%i -> %f : %f\n", i, currentAvg, lastAvg);
+			if (abs(currentAvg- lastAvg) > noteThreshold.value()) {
+				c++;
+				slicePoints.push_back(i);
+			}
+			lastAvg = currentAvg;
+			currentAvg = 0;
+		}
+
+	}
+	// for (int i : slicePoints) {
+	// 	//printf("%i\n", i);
+	// }
+	
+	printf("Found %i notes\n", c);
+	emit dataChanged();
+}
+
+// void SlicerT::updateParams() {
+
+// }
+
+void SlicerT::playNote( NotePlayHandle * _n, sampleFrame * _working_buffer ) {
+	const fpp_t frames = _n->framesLeftForCurrentPeriod();
+	const f_cnt_t offset = _n->noteOffset();
+
+	// init NotePlayHandle data
+	if( !_n->m_pluginData )
+	{
+		frameCounter = 0;
+		_n->m_pluginData = new SampleBuffer::handleState( false, SRC_LINEAR );
+
+		findSlices();
+
+	}
+
+	// if play returns true (success I guess)
+	if( m_sampleBuffer.play( _working_buffer + offset,
+				(SampleBuffer::handleState *)_n->m_pluginData,
+				frames, _n->frequency(),
+				static_cast<SampleBuffer::LoopMode>( 0 ) ) )
+	{
+		frameCounter += frames + offset;
+		// for (int i = 0;i<256;i++) {
+		// 	printf(">  %f : %f", _working_buffer[i][0], _working_buffer[i][1]);
+		// 	printf("\n");
+		// }
+		// printf("%lu : %lu", sizeof(_working_buffer), sizeof(_working_buffer[0]));
+		// printf("\n");
+		// add the buffer, and then process ???? maybe
+		applyRelease( _working_buffer, _n );
+		instrumentTrack()->processAudioBuffer( _working_buffer,
+								frames + offset, _n );
+
+	}
+
+
+
+	// testing
+	// sampleFrame testFrame;
+	// printf("starting print");
+	// m_sampleBuffer.play(&testFrame, new SampleBuffer::handleState( false, SRC_LINEAR ), 2, _n->frequency(), static_cast<SampleBuffer::LoopMode>( 0 ));
+
+
+
+}
+
+void SlicerT::updateFile(QString file) {
+	printf("updated audio file");
+	m_sampleBuffer.setAudioFile(file);
+	findSlices();
+}
+
+
+void SlicerT::saveSettings(QDomDocument & _doc, QDomElement & _parent) {}
+void SlicerT::loadSettings( const QDomElement & _this ) {}
+
+QString SlicerT::nodeName() const
+{
+	return( slicert_plugin_descriptor.name );
+}
+
+gui::PluginView * SlicerT::instantiateView( QWidget * _parent )
+{
+	return( new gui::SlicerTUI( this, _parent ) );
+}
+
+
+
+extern "C"
+{
+
+// necessary for getting instance out of shared lib
+PLUGIN_EXPORT Plugin * lmms_plugin_main( Model *m, void * )
+{
+	
+	return( new SlicerT( static_cast<InstrumentTrack *>( m ) ) );
+}
+
+
+}
+
+
+} // namespace lmms
diff --git a/plugins/Slicer/SlicerT.h b/plugins/Slicer/SlicerT.h
new file mode 100644
index 00000000000..3c3b9e06ae8
--- /dev/null
+++ b/plugins/Slicer/SlicerT.h
@@ -0,0 +1,81 @@
+/*
+ * Slicer.h - declaration of class Slicer and BSynth which
+ *                         are a wavetable synthesizer
+ *
+ * Copyright (c) 2006-2008 Andreas Brandmaier <andy/at/brandmaier/dot/de>
+ * 
+ * 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 TEST_H
+#define TEST_H
+
+#include "AutomatableModel.h"
+#include "Instrument.h"
+#include "InstrumentView.h"
+#include "SampleBuffer.h"
+#include "SlicerTUI.h"
+
+// #include "Graph.h"
+// #include "MemoryManager.h"
+
+
+namespace lmms
+{
+
+class SlicerT : public Instrument{
+	Q_OBJECT
+	public:
+		SlicerT(InstrumentTrack * _instrument_track);
+		~SlicerT() override = default;
+
+		void playNote( NotePlayHandle * _n,
+						sampleFrame * _working_buffer ) override;
+
+
+		void saveSettings( QDomDocument & _doc,
+								QDomElement & _parent ) override;
+		void loadSettings( const QDomElement & _this ) override;
+
+		QString nodeName() const override;
+
+		gui::PluginView * instantiateView( QWidget * _parent ) override;
+
+	public slots:
+		void updateFile(QString file);
+		void updateParams();
+
+	private:
+		int frameCounter = 0;
+		SampleBuffer m_sampleBuffer;
+		FloatModel noteThreshold;
+
+		std::vector<int> slicePoints;
+
+		friend class gui::SlicerTUI;
+
+		void findSlices();
+		
+};
+
+
+}
+
+#endif
diff --git a/plugins/Slicer/SlicerTUI.cpp b/plugins/Slicer/SlicerTUI.cpp
new file mode 100644
index 00000000000..7ce620fc6ff
--- /dev/null
+++ b/plugins/Slicer/SlicerTUI.cpp
@@ -0,0 +1,111 @@
+#include "SlicerTUI.h"
+#include "SlicerT.h"
+// #include <QDomElement>
+#include <stdio.h>
+
+
+#include "StringPairDrag.h"
+#include "Clipboard.h"
+#include "Track.h"
+#include "DataFile.h"
+// #include "AudioEngine.h"
+// #include "base64.h"
+// #include "Engine.h"
+// #include "Graph.h"
+// #include "InstrumentTrack.h"
+// #include "Knob.h"
+// #include "LedCheckBox.h"
+// #include "NotePlayHandle.h"
+// #include "PixmapButton.h"
+// #include "Song.h"
+// #include "interpolation.h"
+
+// #include <QPainter>
+#include <QFileInfo>
+#include <QDropEvent>
+
+namespace lmms
+{
+
+
+namespace gui
+{
+SlicerTUI::SlicerTUI( SlicerT * _instrument,
+					QWidget * _parent ) :
+	InstrumentViewFixedSize( _instrument, _parent ),
+	noteThresholdKnob(KnobType::Bright26, this),
+	wf(200, 100, (_instrument->slicePoints), _parent)
+	
+{
+	setAcceptDrops( true );
+	wf.move(30, 30); 
+	noteThresholdKnob.move(30, 200);
+	noteThresholdKnob.setModel(&_instrument->noteThreshold);
+
+}
+
+void SlicerTUI::mousePressEvent( QMouseEvent * _me ) {
+	update();
+}
+
+// all the drag stuff is copied from AudioFileProcessor
+void SlicerTUI::dragEnterEvent( QDragEnterEvent * _dee )
+{
+		// For mimeType() and MimeType enum class
+	using namespace Clipboard;
+
+	if( _dee->mimeData()->hasFormat( mimeType( MimeType::StringPair ) ) )
+	{
+		QString txt = _dee->mimeData()->data(
+						mimeType( MimeType::StringPair ) );
+		if( txt.section( ':', 0, 0 ) == QString( "clip_%1" ).arg(
+							static_cast<int>(Track::Type::Sample) ) )
+		{
+			_dee->acceptProposedAction();
+		}
+		else if( txt.section( ':', 0, 0 ) == "samplefile" )
+		{
+			_dee->acceptProposedAction();
+		}
+		else
+		{
+			_dee->ignore();
+		}
+	}
+	else
+	{
+		_dee->ignore();
+	}
+
+}
+
+void SlicerTUI::dropEvent( QDropEvent * _de ) {
+	QString type = StringPairDrag::decodeKey( _de );
+	QString value = StringPairDrag::decodeValue( _de );
+	if( type == "samplefile" )
+	{
+		printf("type: samplefile\n");
+		castModel<SlicerT>()->updateFile( value );
+		wf.updateFile( value );
+		// castModel<AudioFileProcessor>()->setAudioFile( value );
+		// _de->accept();
+		// set wf wave file
+		return;
+	}
+	else if( type == QString( "clip_%1" ).arg( static_cast<int>(Track::Type::Sample) ) )
+	{
+		printf("type: clip file\n");
+		DataFile dataFile( value.toUtf8() );
+		castModel<SlicerT>()->updateFile( dataFile.content().firstChild().toElement().attribute( "src" ) );
+		_de->accept();
+		return;
+	}
+
+	_de->ignore();
+}
+
+
+}
+}
+
+
diff --git a/plugins/Slicer/SlicerTUI.h b/plugins/Slicer/SlicerTUI.h
new file mode 100644
index 00000000000..2e55acf9913
--- /dev/null
+++ b/plugins/Slicer/SlicerTUI.h
@@ -0,0 +1,59 @@
+#include <stdio.h>
+#include "WaveForm.h"
+// #include "AutomatableModel.h"
+#include "Instrument.h"
+#include "InstrumentView.h"
+#include "Knob.h"
+// #include "Graph.h"
+// #include "MemoryManager.h"
+
+
+
+#ifndef SLICER_UI_H
+#define SLICER_UI_H
+
+namespace lmms
+{
+
+// forward declaration, to be able to use SlicerT as a parameter
+class SlicerT;
+
+namespace gui
+{
+
+// class Knob;
+// class LedCheckBox;
+// class PixmapButton;
+
+
+class SlicerTUI : public InstrumentViewFixedSize
+{
+	Q_OBJECT
+public:
+	SlicerTUI( SlicerT * _instrument,
+					QWidget * _parent );
+	~SlicerTUI() override = default;
+
+// protected slots:
+	//void sampleSizeChanged( float _new_sample_length );
+
+protected:
+	virtual void dragEnterEvent( QDragEnterEvent * _dee );
+	virtual void dropEvent( QDropEvent * _de );
+	virtual void mousePressEvent( QMouseEvent * _me );
+
+
+private:
+	Knob noteThresholdKnob;
+
+	WaveForm wf;
+
+
+} ;
+
+
+} // namespace gui
+
+} // namespace lmms
+
+#endif
\ No newline at end of file
diff --git a/plugins/Slicer/WaveForm.cpp b/plugins/Slicer/WaveForm.cpp
new file mode 100644
index 00000000000..dd58eb44bed
--- /dev/null
+++ b/plugins/Slicer/WaveForm.cpp
@@ -0,0 +1,57 @@
+#include <stdio.h>
+
+#include "WaveForm.h"
+
+namespace lmms
+{
+
+
+namespace gui
+{
+    WaveForm::WaveForm(int _w, int _h, std::vector<int> & _slicePoints, QWidget * _parent) :
+        QWidget(_parent),
+        m_graph( QPixmap(_w, _h)),
+        currentSample(),
+        slicePoints(_slicePoints)
+        {
+            width = _w;
+            height = _h;
+            setFixedSize( width, height );
+
+            m_graph.fill(QColor(11, 11, 11));
+        }
+
+    void WaveForm::drawWaveForm() {
+        m_graph.fill(QColor(11, 11, 11));
+        QPainter brush(&m_graph);
+        brush.setPen(QColor(255, 0, 0));
+        currentSample.visualize(
+		brush,
+		QRect( 0, 0, m_graph.width(), m_graph.height() ),
+		0, currentSample.frames());
+        brush.setPen(QColor(0, 255, 0));
+
+        for (int i = 0;i<slicePoints.size();i++) {
+            // printf("%i\n", slicePoints[i]);
+            float xPos = (float)slicePoints[i] / (float)currentSample.frames() * (float)width;
+            printf("%i / %i * %i = %f\n", slicePoints[i] , currentSample.frames() , width, xPos);
+            brush.drawLine(xPos, 0, xPos, height);
+        }
+
+    }
+
+
+    void WaveForm::paintEvent( QPaintEvent * _pe) {
+        QPainter p( this );
+        drawWaveForm();
+        p.drawPixmap(0, 0, m_graph);
+    }
+
+    void WaveForm::updateFile(QString file) {
+        currentSample.setAudioFile(file);
+        drawWaveForm();
+        update();
+    }
+
+}
+}
\ No newline at end of file
diff --git a/plugins/Slicer/WaveForm.h b/plugins/Slicer/WaveForm.h
new file mode 100644
index 00000000000..52b54a311df
--- /dev/null
+++ b/plugins/Slicer/WaveForm.h
@@ -0,0 +1,52 @@
+#include <QApplication>
+#include <QFontMetrics>
+#include <QInputDialog>
+#include <QMouseEvent>
+#include <QPainter>
+#include "SampleBuffer.h"
+
+#ifndef WAVEFORM_H
+#define WAVEFORM_H
+
+namespace lmms
+{
+
+
+namespace gui
+{
+
+
+class WaveForm : public QWidget {
+    	Q_OBJECT
+    protected:
+        // virtual void enterEvent( QEvent * _e );
+        // virtual void leaveEvent( QEvent * _e );
+        // virtual void mousePressEvent( QMouseEvent * _me );
+        // virtual void mouseReleaseEvent( QMouseEvent * _me );
+        // virtual void mouseMoveEvent( QMouseEvent * _me );
+        // virtual void wheelEvent( QWheelEvent * _we );
+        virtual void paintEvent( QPaintEvent * _pe );
+
+
+    private:
+        
+        QPixmap m_graph;
+
+        SampleBuffer currentSample;
+        int width;
+        int height;
+
+        void drawWaveForm();
+
+    public:
+        WaveForm(int _w, int _h, std::vector<int> & _slicePoints, QWidget * _parent);
+        void updateFile(QString file);
+
+    private:
+        std::vector<int> & slicePoints;
+
+};
+}}
+
+
+#endif
\ No newline at end of file
diff --git a/plugins/Slicer/logo.png b/plugins/Slicer/logo.png
new file mode 100644
index 0000000000000000000000000000000000000000..2e84cba5a1377f9a65f4b1db243846c05b713dab
GIT binary patch
literal 1109
zcmeAS@N?(olHy`uVBq!ia0vp^1|ZDA3?vioaBc-sjKx9jP7LeL$-D$|I14-?iy0WW
zg+Z8+Vb&Z8pdfpRr>`sf4NgXJQJvX>d|!Zim;!u4T!B&}8T|kM|KEoPYk)xzQWE4B
z3=9-z7FITP4o)6kK7IiqVKH$DDQOv5Ie7&|WffI5bxkcDJ$(ZsV>5FbTRUercTX>G
zAOC>Bppe+Ogv8|3w9MSR{F2i0iptu$=C+QmNmCXqHI%PT1Dem6<n8VfI+<mMF#`ir
zj;D)bh{y50)3TFi8Hlv0DljQ8n>$-r|AKVTYt_};w_U!NXB7K(*S6We|JSFoOi<C-
zQ2X-dgQqRWlP697?z`|qmg13*{*{a!L53WjEKYTD9h+9YyucqDoGSR_DQjS(=;F+%
zX*W%@0&ey-q|`+-pC}M^-`yvosqx;vKjYpyN6TN~O)J7)99VLhgM-n7E9=6arLlpF
zg_@Q~mOOYZs_1g?|NIpf7yhigeqo930`tFT<n0e_?5^6W(zUechwdr;0&jgc2f<k~
z2Da;8bu9|Fd~o|hi^v9x2d9r;{?5++-p?|@bdy57qSTjoc{|=YlZDd-)ID@&ay^tW
zyYs`ZX)bf@Ql1CJ{p%*}=l}L1Z!X`Ty14tjFYG4FU1wS0_S{4H%-%caHzXgi_O0T)
zdal6g!)LMErY_Z<44cX_$}Ts`Z=Uz_n{Uhl1{Kk(IeR{roM{ma=`1t6_2zfwwiD0x
z2$maOo+^3Zi;}`2$>Xsz8FdcnrTOt2&-)|dIM-^*%*&JceQt?Pec4@e;H|XO%RORm
zJGWT2<jdtbKKt^7dC6grf;Gpk{bzFbR9HGaPH=<5YKEKcCP7kRj75x#m^tU3VS8q~
z>9Px>-t+FOzYLvO;^eNcK04<`;f1yG=XO=pJT7uNUR(9=-MyZ|evN<Ee9t^~coEdl
ze)E8(8MFV*UqUXNns)`GS(2}F%~`)BeD2EaH--1lvr&4kdQH4Gn00B<-r}wN6;Uz5
zhZ#7Z`%3X`{&jt!s_I-@f&OzxzE0Ctn>J5+=Dl~Z4JU&4-aUTUP}up-@@>18x9vZm
z`?`a3wX0b1{r8`b`8V%pdUGe>(P~!Sf0F`#aQn*cpRcO&&I6RsJzf1=);T3K0RVE&
BY2^R_

literal 0
HcmV?d00001


From 5941766b1aa39629710cf097d3c17e15137a1dac Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Sun, 3 Sep 2023 20:23:03 +0200
Subject: [PATCH 02/99] very simple peak detection working

---
 plugins/Slicer/SlicerT.cpp  | 34 +++++++++++++++++++---------------
 plugins/Slicer/WaveForm.cpp |  2 +-
 2 files changed, 20 insertions(+), 16 deletions(-)

diff --git a/plugins/Slicer/SlicerT.cpp b/plugins/Slicer/SlicerT.cpp
index 8d832f33259..5696325796b 100644
--- a/plugins/Slicer/SlicerT.cpp
+++ b/plugins/Slicer/SlicerT.cpp
@@ -76,7 +76,7 @@ Plugin::Descriptor PLUGIN_EXPORT slicert_plugin_descriptor =
 SlicerT::SlicerT(InstrumentTrack * _instrument_track) : 
 	Instrument( _instrument_track, &slicert_plugin_descriptor ),
 	m_sampleBuffer(),
-	noteThreshold( 0.2f, 0.0f, 1.0f, 0.01f, this, tr( "Note Threshold" ) )
+	noteThreshold( 0.6f, 0.0f, 2.0f, 0.01f, this, tr( "Note Threshold" ) )
 {
 	// connect( &noteThreshold, SIGNAL( dataChanged() ), this, SLOT( updateParams() ) );
 	printf("Correctly loaded SlicerT!\n");
@@ -85,29 +85,33 @@ SlicerT::SlicerT(InstrumentTrack * _instrument_track) :
 
 void SlicerT::findSlices() {
 	int c = 0;
-	float lastAvg = 0;
-	float currentAvg = 0;
-	slicePoints = {};
+	const int window = 1024;
+	int peakIndex = 0;
+	float lastPeak = 0;
+	float currentPeak = 0;
+	slicePoints = {0};
 	for (int i = 0; i<m_sampleBuffer.endFrame();i+=1) {
 		// combine left and right and absolute it
 		float sampleValue = abs(m_sampleBuffer.data()[i][0]) + abs(m_sampleBuffer.data()[i][1]) / 2;
-		currentAvg += sampleValue;
-
-		if (i%128==0) {
-			currentAvg /= 128.0f;
+		if (sampleValue > currentPeak) {
+			currentPeak = sampleValue;
+			peakIndex = i;
+		}
+		
+		if (i%window==0) {
 			//printf("%i -> %f : %f\n", i, currentAvg, lastAvg);
-			if (abs(currentAvg- lastAvg) > noteThreshold.value()) {
+			if (abs(currentPeak / lastPeak) > 1+noteThreshold.value()) {
 				c++;
-				slicePoints.push_back(i);
+				slicePoints.push_back(peakIndex);
 			}
-			lastAvg = currentAvg;
-			currentAvg = 0;
+			lastPeak = currentPeak;
+			currentPeak = 0;
 		}
 
 	}
-	// for (int i : slicePoints) {
-	// 	//printf("%i\n", i);
-	// }
+	for (int i : slicePoints) {
+		printf("%i\n", i);
+	}
 	
 	printf("Found %i notes\n", c);
 	emit dataChanged();
diff --git a/plugins/Slicer/WaveForm.cpp b/plugins/Slicer/WaveForm.cpp
index dd58eb44bed..a0bc53ce621 100644
--- a/plugins/Slicer/WaveForm.cpp
+++ b/plugins/Slicer/WaveForm.cpp
@@ -34,7 +34,7 @@ namespace gui
         for (int i = 0;i<slicePoints.size();i++) {
             // printf("%i\n", slicePoints[i]);
             float xPos = (float)slicePoints[i] / (float)currentSample.frames() * (float)width;
-            printf("%i / %i * %i = %f\n", slicePoints[i] , currentSample.frames() , width, xPos);
+            // printf("%i / %i * %i = %f\n", slicePoints[i] , currentSample.frames() , width, xPos);
             brush.drawLine(xPos, 0, xPos, height);
         }
 

From 4f91187cb376d254dd16de9c2849e16dcf7b2f91 Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Wed, 6 Sep 2023 03:18:36 +0200
Subject: [PATCH 03/99] basic phase vocoder implementation, no effects yet

---
 plugins/Slicer/SlicerT.cpp   | 389 ++++++++++++++++++++++++++++++++---
 plugins/Slicer/SlicerT.h     |  19 +-
 plugins/Slicer/SlicerTUI.cpp |  10 +-
 plugins/Slicer/SlicerTUI.h   |   2 +
 4 files changed, 382 insertions(+), 38 deletions(-)

diff --git a/plugins/Slicer/SlicerT.cpp b/plugins/Slicer/SlicerT.cpp
index 5696325796b..83c5b1b4a4d 100644
--- a/plugins/Slicer/SlicerT.cpp
+++ b/plugins/Slicer/SlicerT.cpp
@@ -22,23 +22,40 @@
  *
  */
 
+/*
+!! always work on the original sample for slicing and whatever,
+only use the sped up sample and slices in playNote(). This will keep things organized
+
+
+
+load file / slcies get updated
+find slices
+find bpm / if bpm gets updated
+update matchingSpeed sampleBuffer
+update matchingSlices vector
+
+the matchingSpeed buffer will always get initialzed freshly using a buffer, this seems to be the only way 
+give it the raw data
+*/
 
 // #include <QDomElement>
 #include <stdio.h>
 #include "SlicerT.h"
-
+#include "fft_helpers.h"
+#include <atomic>
 
 // #include "AudioEngine.h"
 // #include "base64.h"
-// #include "Engine.h"
+#include "Engine.h"
 // #include "Graph.h"
 #include "InstrumentTrack.h"
 // #include "Knob.h"
 // #include "LedCheckBox.h"
 // #include "NotePlayHandle.h"
 // #include "PixmapButton.h"
-// #include "Song.h"
+#include "Song.h"
 // #include "interpolation.h"
+#include <fftw3.h>
 
 
 #include "embed.h"
@@ -75,11 +92,13 @@ Plugin::Descriptor PLUGIN_EXPORT slicert_plugin_descriptor =
 
 SlicerT::SlicerT(InstrumentTrack * _instrument_track) : 
 	Instrument( _instrument_track, &slicert_plugin_descriptor ),
-	m_sampleBuffer(),
+	originalSample(),
+	timeShiftedSample(),
 	noteThreshold( 0.6f, 0.0f, 2.0f, 0.01f, this, tr( "Note Threshold" ) )
 {
 	// connect( &noteThreshold, SIGNAL( dataChanged() ), this, SLOT( updateParams() ) );
 	printf("Correctly loaded SlicerT!\n");
+	warmupFFT();
 }
 
 
@@ -89,31 +108,38 @@ void SlicerT::findSlices() {
 	int peakIndex = 0;
 	float lastPeak = 0;
 	float currentPeak = 0;
+	int minWindowsPassed = 0;
 	slicePoints = {0};
-	for (int i = 0; i<m_sampleBuffer.endFrame();i+=1) {
+	for (int i = 0; i<originalSample.frames();i+=1) {
 		// combine left and right and absolute it
-		float sampleValue = abs(m_sampleBuffer.data()[i][0]) + abs(m_sampleBuffer.data()[i][1]) / 2;
+		float sampleValue = abs(originalSample.data()[i][0]) + abs(originalSample.data()[i][1]) / 2;
 		if (sampleValue > currentPeak) {
 			currentPeak = sampleValue;
 			peakIndex = i;
 		}
 		
 		if (i%window==0) {
-			//printf("%i -> %f : %f\n", i, currentAvg, lastAvg);
-			if (abs(currentPeak / lastPeak) > 1+noteThreshold.value()) {
+								//printf("%i -> %f : %f\n", i, currentAvg, lastAvg);
+			if (abs(currentPeak / lastPeak) > 1+noteThreshold.value() && minWindowsPassed <= 0) {
 				c++;
 				slicePoints.push_back(peakIndex);
+				minWindowsPassed = 2; // wait at least one window for a new note
 			}
 			lastPeak = currentPeak;
 			currentPeak = 0;
+			
+			
+			minWindowsPassed--;
+
 		}
 
 	}
-	for (int i : slicePoints) {
-		printf("%i\n", i);
-	}
+	slicePoints.push_back(originalSample.frames());
+	// for (int i : slicePoints) {
+	// 	printf("%i\n", i);
+	// }
 	
-	printf("Found %i notes\n", c);
+	// printf("Found %i notes\n", c);
 	emit dataChanged();
 }
 
@@ -122,33 +148,42 @@ void SlicerT::findSlices() {
 // }
 
 void SlicerT::playNote( NotePlayHandle * _n, sampleFrame * _working_buffer ) {
+	
 	const fpp_t frames = _n->framesLeftForCurrentPeriod();
 	const f_cnt_t offset = _n->noteOffset();
 
+	// 0 at 440hz, or where the square thing is on the keyboard
+	
+
 	// init NotePlayHandle data
 	if( !_n->m_pluginData )
 	{
-		frameCounter = 0;
 		_n->m_pluginData = new SampleBuffer::handleState( false, SRC_LINEAR );
 
-		findSlices();
+		// 0th element is no sound, so play no sound when out of bounds
+		// int noteIndex = _n->key() - 68;
+		// if (noteIndex > slicePoints.size()-2 || noteIndex < 0) {
+		// 	noteIndex = 0;
+		// }
+
+		// int sliceStart = slicePoints[noteIndex];
+		// int sliceEnd = slicePoints[noteIndex+1];
+
+		// m_sampleBuffer.setAllPointFrames( sliceStart, sliceEnd, sliceStart, sliceEnd );
 
+		// printf("%i : %i -> %i\n", noteIndex, sliceStart, sliceEnd);
+		// printf("%i\n", _n->oldKey());
+
+	
 	}
 
 	// if play returns true (success I guess)
-	if( m_sampleBuffer.play( _working_buffer + offset,
+	if( timeShiftedSample.play( _working_buffer + offset,
 				(SampleBuffer::handleState *)_n->m_pluginData,
-				frames, _n->frequency(),
+				frames, 440,
 				static_cast<SampleBuffer::LoopMode>( 0 ) ) )
 	{
-		frameCounter += frames + offset;
-		// for (int i = 0;i<256;i++) {
-		// 	printf(">  %f : %f", _working_buffer[i][0], _working_buffer[i][1]);
-		// 	printf("\n");
-		// }
-		// printf("%lu : %lu", sizeof(_working_buffer), sizeof(_working_buffer[0]));
-		// printf("\n");
-		// add the buffer, and then process ???? maybe
+
 		applyRelease( _working_buffer, _n );
 		instrumentTrack()->processAudioBuffer( _working_buffer,
 								frames + offset, _n );
@@ -156,20 +191,236 @@ void SlicerT::playNote( NotePlayHandle * _n, sampleFrame * _working_buffer ) {
 	}
 
 
+}
+
+// create thimeshifted samplebuffer and timeshifted slicePoints
+// http://blogs.zynaptiq.com/bernsee/pitch-shifting-using-the-ft/
+void SlicerT::timeShiftSample() {
+
+	printf("starting sample timeshifting\n");
+
+	using std::vector;
+
+
+
+
+	bpm_t targetBPM = Engine::getSong()->getTempo();;
+	// nothing to do here
+	if (targetBPM == originalBPM) {
+		timeShiftedSample = SampleBuffer(originalSample.data(), originalSample.frames());
+		printf("BPM match for sample, finished timeshift\n");
+		return;
+	}
+
+
 
-	// testing
-	// sampleFrame testFrame;
-	// printf("starting print");
-	// m_sampleBuffer.play(&testFrame, new SampleBuffer::handleState( false, SRC_LINEAR ), 2, _n->frequency(), static_cast<SampleBuffer::LoopMode>( 0 ));
+	float sampleRate = originalSample.sampleRate();
+	float speedRatio = (double)targetBPM / originalBPM;
+	int originalFrames = originalSample.frames();
+	int targetFrames = originalFrames * speedRatio;
+	
 
 
+	vector<float> rawData(originalFrames, 0);
+	vector<float> outData(originalFrames, 0);
+	vector<sampleFrame> bufferData(originalFrames, sampleFrame());
+
+	for (int i = 0;i<originalFrames;i++) {
+		rawData[i] = (float)originalSample.data()[i][0];
+	}
+
+	phaseVocoder(rawData, outData, sampleRate, 1);
+
+	for (int i = 0;i<originalFrames;i++) {
+		bufferData.data()[i][0] = outData[i];
+		bufferData.data()[i][1] = outData[i];
+	}
+
+	timeShiftedSample = SampleBuffer(bufferData.data(), originalFrames);
+
+	printf("finished sample timeshifting\n");
 
 }
 
+
+void SlicerT::phaseVocoder(std::vector<float> &dataIn, std::vector<float> &dataOut, float sampleRate, float pitchScale) {
+	using std::vector;
+	// processing parameters, lower is faster
+	const int windowSize = 2048;
+	const int overSampling = 4;
+	
+	// values used
+	const int stepSize = windowSize / overSampling; 
+	const int windowLatency = windowSize - stepSize;
+	const float freqPerBin = sampleRate/windowSize; 
+	const float expectedPhase = 2.*M_PI*(float)stepSize/(float)windowSize;
+	
+
+	// audio data
+	int inFrames = dataIn.size();
+	int outFrames = dataOut.size();
+
+	// initialize buffers
+	fftwf_complex FFTSpectrum[windowSize];
+	vector<float> IFFTReconstruction(windowSize, 0);
+	vector<float> allMagnitudes(windowSize, 0);
+	vector<float> allFrequencies(windowSize, 0);
+	vector<float> lastPhase(windowSize, 0);
+	vector<float> sumPhase(windowSize, 0);
+
+	// declare vars
+	float real, imag, phase, prevPhase, magnitude, freq, deltaPhase = 0;
+
+	// fft plans
+	fftwf_plan fftPlan;
+	fftwf_plan ifftPlan;
+
+
+
+	for (int i = 0;i < inFrames - windowSize;i+=stepSize) {
+		// FFT
+		fftPlan = fftwf_plan_dft_r2c_1d(windowSize, dataIn.data() + i, FFTSpectrum, FFTW_MEASURE);
+		fftwf_execute(fftPlan);
+
+		// analysis step
+		for (int j = 0; j < windowSize; j++) {
+			
+			real = FFTSpectrum[j][0];
+			imag = FFTSpectrum[j][1];
+
+			// printf("freq: %3d %+9.5f %+9.5f I  original: %+9.5f \n", j, real, imag, dataIn.at(i+j));
+
+			magnitude = 2.*sqrt(real*real + imag*imag);
+			phase = atan2(imag,real); 
+
+			freq = phase - lastPhase[j]; // subtract prev pahse to get phase diference
+			lastPhase[j] = phase;
+
+			freq -= (float)j*expectedPhase; // subtract expected phase
+
+			// some black magic to get into +/- PI interval, revise later pls
+			long qpd = freq/M_PI;
+			if (qpd >= 0) qpd += qpd&1;
+			else qpd -= qpd&1;
+			freq -= M_PI*(float)qpd;
+			
+			freq = (float)overSampling*freq/(2.*M_PI); // idk
+
+			freq = (float)j*freqPerBin + freq*freqPerBin; // "compute the k-th partials' true frequency" ok i guess
+
+			allMagnitudes[j] = magnitude;
+			allFrequencies[j] = freq;
+
+		}
+		// effects go here
+
+
+		// synthesis, all the operations are the reverse of the analysis
+		for (int j = 0; j < windowSize; j++) {
+			magnitude = allMagnitudes[j];
+			freq = allFrequencies[j];
+
+			deltaPhase = freq - (float)j*freqPerBin;
+
+			deltaPhase /= freqPerBin;
+
+			deltaPhase = 2.*M_PI*deltaPhase/overSampling;;
+
+			deltaPhase += (float)j*expectedPhase;
+
+			sumPhase[j] += deltaPhase;
+			deltaPhase = sumPhase[j]; // this is the bin phase
+
+			FFTSpectrum[j][0] = magnitude*cos(deltaPhase);
+			FFTSpectrum[j][1] = magnitude*sin(deltaPhase);
+		}
+
+		// inverse fft
+		ifftPlan = fftwf_plan_dft_c2r_1d(windowSize, FFTSpectrum, IFFTReconstruction.data(), FFTW_MEASURE);
+		fftwf_execute(ifftPlan);
+
+		// windowing
+		for (int j = 0; j < windowSize; j++) {
+			
+			if (i+j < windowLatency) {
+				// calculate amount of windows overlapping
+				float windowIndex =  i + j;
+				int windowsOverlapping = windowIndex / windowSize * overSampling + 1;
+
+				
+				// since not all windows overlap, just take the average of the ones that do overlap
+				// this should be improved
+				// idk why the 4 is there but it works
+				dataOut[j+i] += 4/windowsOverlapping*IFFTReconstruction[j]/(windowSize/2.0f*overSampling);
+			} else {
+				// this computes the weight of the window on the final output
+				float window = -0.5f*cos(2.*M_PI*(float)j/(float)windowSize)+0.5f;
+				dataOut[j+i] += 2.0f*window*IFFTReconstruction[j]/(windowSize/2.0f*overSampling);
+			}
+
+
+		}
+
+
+	}
+
+	// normalize 	
+	float max = -1;
+	for (int i = 0;i<inFrames;i++) {
+		max = std::max(max, abs(dataOut[i]));
+		dataOut[i] = dataOut[i];
+	}
+
+	for (int i = 0;i<outFrames;i++) {
+		dataOut[i] = dataOut[i] / max;
+	}
+
+	fftwf_destroy_plan(fftPlan);
+	fftwf_destroy_plan(ifftPlan);
+
+
+	// fftwf_cleanup();
+
+}
+
+void SlicerT::normalizeSample(sampleFrame * data) {
+	float max = -1;
+	for (int i = 0;i<data->size();i++) {
+		max = std::max(max, abs(data[i][0]));
+		max = std::max(max, abs(data[i][1]));
+	}
+
+	printf("max: %f\n", max);
+
+	for (int i = 0;i<data->size();i++) {
+		data[i][0] = 0;
+		data[i][1] = 0;
+	}
+
+}
+
+void SlicerT::warmupFFT() {
+	const int dataPoints = 512;
+
+	std::vector<float> warmupData(dataPoints, sqrt(2));
+	fftwf_complex fftOut[dataPoints];
+	fftwf_plan p = fftwf_plan_dft_r2c_1d(dataPoints, warmupData.data(), fftOut, FFTW_MEASURE);
+	fftwf_execute(p);
+
+	fftwf_plan d = fftwf_plan_dft_c2r_1d(dataPoints, fftOut, warmupData.data(), FFTW_MEASURE);
+	fftwf_execute(d);
+
+	fftwf_destroy_plan(p);
+	fftwf_destroy_plan(d);
+}
+
 void SlicerT::updateFile(QString file) {
-	printf("updated audio file");
-	m_sampleBuffer.setAudioFile(file);
+	printf("updated audio file\n");
+	originalSample.setAudioFile(file);
 	findSlices();
+	// updateBPM()
+	timeShiftSample();
+	
 }
 
 
@@ -203,3 +454,81 @@ PLUGIN_EXPORT Plugin * lmms_plugin_main( Model *m, void * )
 
 
 } // namespace lmms
+
+
+
+/* Implementation of Robust peak detection algorithm
+Doesnt work that great, it is too sensitive 
+https://stackoverflow.com/questions/22583391/peak-signal-detection-in-realtime-timeseries-data/46998001#46998001
+void SlicerT::findSlices() {
+	int c = 0;
+	const int lag = 64;
+	const float influence = 1;
+	
+	float peak = 0;
+	float lastMean = 0;
+	float lastStd = 0;
+	int noteDuration = 0;
+	// init vector with the start of the sample
+	std::vector<float> lastValues = {};
+
+
+	slicePoints = {};
+	for (int i = 0; i<m_sampleBuffer.frames();i++) {
+		// combine left and right and absolute it
+		float sampleValue = abs(m_sampleBuffer.data()[i][0]) + abs(m_sampleBuffer.data()[i][1]) / 2;
+		peak = std::max(sampleValue, peak);
+
+		if (i%64==0) {
+
+			if (lastValues.size() < lag) {
+				lastValues.push_back(peak);
+				continue;
+			} 
+
+			if (abs(peak - lastMean) > noteThreshold.value()) {
+				if (noteDuration <= 0) {
+					printf("%f : %f : %f\n", peak, lastMean, lastStd);
+					// lastValues.push_back(influence*peak + (1-influence)* lastValues.back());
+					lastValues.push_back(peak);
+					lastValues.erase(lastValues.begin());
+					c++;
+					slicePoints.push_back(i);
+					noteDuration = 20;
+				}
+
+			} else {
+
+				lastValues.push_back(peak);
+				lastValues.erase(lastValues.begin());
+				
+			}
+			noteDuration--;
+
+			lastMean = 0;
+			for (float v : lastValues) {
+				lastMean += v;
+			}
+			lastMean /= lag;
+
+			lastStd = 0;
+			for (float v : lastValues) {
+				lastStd += pow(v - lastMean, 2);
+			}
+
+			lastStd = sqrt(lastStd / lag);
+			peak = 0;
+		}
+
+
+
+
+	}
+	// for (int i : slicePoints) {
+	// 	printf("%i\n", i);
+	// }
+	
+	printf("Found %i notes\n", c);
+	emit dataChanged();
+}
+*/
\ No newline at end of file
diff --git a/plugins/Slicer/SlicerT.h b/plugins/Slicer/SlicerT.h
index 3c3b9e06ae8..1301f7b0258 100644
--- a/plugins/Slicer/SlicerT.h
+++ b/plugins/Slicer/SlicerT.h
@@ -32,7 +32,7 @@
 #include "InstrumentView.h"
 #include "SampleBuffer.h"
 #include "SlicerTUI.h"
-
+#include <fftw3.h>
 // #include "Graph.h"
 // #include "MemoryManager.h"
 
@@ -63,15 +63,24 @@ class SlicerT : public Instrument{
 		void updateParams();
 
 	private:
-		int frameCounter = 0;
-		SampleBuffer m_sampleBuffer;
+	
+
 		FloatModel noteThreshold;
 
+		SampleBuffer originalSample;
+		SampleBuffer timeShiftedSample;
 		std::vector<int> slicePoints;
-
-		friend class gui::SlicerTUI;
+		std::vector<int> timeShiftedSlices;
+		
+		int originalBPM = 140;
 
 		void findSlices();
+		void timeShiftSample();
+		void phaseVocoder(std::vector<float> &in, std::vector<float> &out, float sampleRate, float pitchScale);
+		void normalizeSample(sampleFrame * data);
+		void warmupFFT(); // runs one fft cycle to generate wisdom
+
+		friend class gui::SlicerTUI;
 		
 };
 
diff --git a/plugins/Slicer/SlicerTUI.cpp b/plugins/Slicer/SlicerTUI.cpp
index 7ce620fc6ff..7137b52754c 100644
--- a/plugins/Slicer/SlicerTUI.cpp
+++ b/plugins/Slicer/SlicerTUI.cpp
@@ -34,17 +34,21 @@ SlicerTUI::SlicerTUI( SlicerT * _instrument,
 					QWidget * _parent ) :
 	InstrumentViewFixedSize( _instrument, _parent ),
 	noteThresholdKnob(KnobType::Bright26, this),
+	slicerTParent(_instrument),
 	wf(200, 100, (_instrument->slicePoints), _parent)
 	
 {
 	setAcceptDrops( true );
 	wf.move(30, 30); 
 	noteThresholdKnob.move(30, 200);
-	noteThresholdKnob.setModel(&_instrument->noteThreshold);
+	noteThresholdKnob.setModel(&slicerTParent->noteThreshold);
 
 }
 
 void SlicerTUI::mousePressEvent( QMouseEvent * _me ) {
+	slicerTParent->findSlices();
+	slicerTParent->timeShiftSample();
+
 	update();
 }
 
@@ -85,7 +89,7 @@ void SlicerTUI::dropEvent( QDropEvent * _de ) {
 	if( type == "samplefile" )
 	{
 		printf("type: samplefile\n");
-		castModel<SlicerT>()->updateFile( value );
+		slicerTParent->updateFile( value );
 		wf.updateFile( value );
 		// castModel<AudioFileProcessor>()->setAudioFile( value );
 		// _de->accept();
@@ -96,7 +100,7 @@ void SlicerTUI::dropEvent( QDropEvent * _de ) {
 	{
 		printf("type: clip file\n");
 		DataFile dataFile( value.toUtf8() );
-		castModel<SlicerT>()->updateFile( dataFile.content().firstChild().toElement().attribute( "src" ) );
+		slicerTParent->updateFile( dataFile.content().firstChild().toElement().attribute( "src" ) );
 		_de->accept();
 		return;
 	}
diff --git a/plugins/Slicer/SlicerTUI.h b/plugins/Slicer/SlicerTUI.h
index 2e55acf9913..7965dc32f94 100644
--- a/plugins/Slicer/SlicerTUI.h
+++ b/plugins/Slicer/SlicerTUI.h
@@ -44,6 +44,8 @@ class SlicerTUI : public InstrumentViewFixedSize
 
 
 private:
+	SlicerT * slicerTParent;
+
 	Knob noteThresholdKnob;
 
 	WaveForm wf;

From 1000e1a3960f5638098ea544a88e74b44bcacaf4 Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Wed, 6 Sep 2023 06:03:27 +0200
Subject: [PATCH 04/99] phase vocoder slight rewrite

---
 plugins/Slicer/SlicerT.cpp | 73 ++++++++++++++++++++++++++------------
 1 file changed, 51 insertions(+), 22 deletions(-)

diff --git a/plugins/Slicer/SlicerT.cpp b/plugins/Slicer/SlicerT.cpp
index 83c5b1b4a4d..8dfab8fdbda 100644
--- a/plugins/Slicer/SlicerT.cpp
+++ b/plugins/Slicer/SlicerT.cpp
@@ -98,7 +98,7 @@ SlicerT::SlicerT(InstrumentTrack * _instrument_track) :
 {
 	// connect( &noteThreshold, SIGNAL( dataChanged() ), this, SLOT( updateParams() ) );
 	printf("Correctly loaded SlicerT!\n");
-	warmupFFT();
+	// warmupFFT(); // maybe
 }
 
 
@@ -222,8 +222,8 @@ void SlicerT::timeShiftSample() {
 
 
 	vector<float> rawData(originalFrames, 0);
-	vector<float> outData(originalFrames, 0);
-	vector<sampleFrame> bufferData(originalFrames, sampleFrame());
+	vector<float> outData(originalFrames*2, 0);
+	vector<sampleFrame> bufferData(originalFrames*2, sampleFrame());
 
 	for (int i = 0;i<originalFrames;i++) {
 		rawData[i] = (float)originalSample.data()[i][0];
@@ -247,39 +247,60 @@ void SlicerT::phaseVocoder(std::vector<float> &dataIn, std::vector<float> &dataO
 	using std::vector;
 	// processing parameters, lower is faster
 	const int windowSize = 2048;
-	const int overSampling = 4;
+	const int overSampling = 16;
 	
+	// audio data
+	int inFrames = dataIn.size();
+	int outFrames = dataIn.size();
+
+	float lengthRatio = 1;// inFrames / outFrames;
+
 	// values used
 	const int stepSize = windowSize / overSampling; 
-	const int windowLatency = windowSize - stepSize;
+	const int numWindows = inFrames / stepSize;
+	const int outStepSize = lengthRatio * stepSize;
+	const int windowLatency = (overSampling-1)*outStepSize;
 	const float freqPerBin = sampleRate/windowSize; 
 	const float expectedPhase = 2.*M_PI*(float)stepSize/(float)windowSize;
-	
 
-	// audio data
-	int inFrames = dataIn.size();
-	int outFrames = dataOut.size();
+
+	printf("frames: %i ,step size: %i , out step size: %i , ratio: %f\n", inFrames, stepSize, outStepSize, lengthRatio);
+	printf("frames: %i , maxFrames: %i \n", inFrames, (numWindows-overSampling) * stepSize + windowSize);
+	printf("will drop %i\n", inFrames%(inFrames/numWindows));
+	printf("pitch shift: %f", noteThreshold.value());
 
 	// initialize buffers
+
 	fftwf_complex FFTSpectrum[windowSize];
+	vector<float> FFTInput(windowSize, 0);
 	vector<float> IFFTReconstruction(windowSize, 0);
 	vector<float> allMagnitudes(windowSize, 0);
 	vector<float> allFrequencies(windowSize, 0);
+	vector<float> processedFreq(windowSize, 0);
+	vector<float> processedMagn(windowSize, 0);
 	vector<float> lastPhase(windowSize, 0);
 	vector<float> sumPhase(windowSize, 0);
 
 	// declare vars
-	float real, imag, phase, prevPhase, magnitude, freq, deltaPhase = 0;
+	float real, imag, phase, magnitude, freq, deltaPhase = 0;
+	int inWindowIndex = 0;
+	int outWindowIndex = 0;
 
 	// fft plans
 	fftwf_plan fftPlan;
+	fftPlan = fftwf_plan_dft_r2c_1d(windowSize, FFTInput.data(), FFTSpectrum, FFTW_MEASURE);
 	fftwf_plan ifftPlan;
+	ifftPlan = fftwf_plan_dft_c2r_1d(windowSize, FFTSpectrum, IFFTReconstruction.data(), FFTW_MEASURE);
 
 
+	// remove oversampling, because the actual window is overSampling* bigger than stepsize
+	for (int i = 0;i < numWindows-overSampling;i++) {
+		inWindowIndex = i * stepSize;
+		outWindowIndex = i * outStepSize;
 
-	for (int i = 0;i < inFrames - windowSize;i+=stepSize) {
 		// FFT
-		fftPlan = fftwf_plan_dft_r2c_1d(windowSize, dataIn.data() + i, FFTSpectrum, FFTW_MEASURE);
+		memcpy(FFTInput.data(), dataIn.data() + inWindowIndex, windowSize*sizeof(float));
+
 		fftwf_execute(fftPlan);
 
 		// analysis step
@@ -312,8 +333,17 @@ void SlicerT::phaseVocoder(std::vector<float> &dataIn, std::vector<float> &dataO
 			allFrequencies[j] = freq;
 
 		}
-		// effects go here
+		// pitch shifting
+		// memset(processedFreq.data(), 0, processedFreq.size()*sizeof(float));
+		// memset(processedMagn.data(), 0, processedFreq.size()*sizeof(float));
+		// for (int j = 0; j < windowSize/2; j++) {
+		// 	int index = j*noteThreshold.value();
+		// 	if (index <= windowSize/2) {
+		// 		processedMagn[index] += allMagnitudes[j];
+		// 		processedFreq[index] = allFrequencies[j] * noteThreshold.value();
+		// 	}
 
+		// }
 
 		// synthesis, all the operations are the reverse of the analysis
 		for (int j = 0; j < windowSize; j++) {
@@ -336,26 +366,25 @@ void SlicerT::phaseVocoder(std::vector<float> &dataIn, std::vector<float> &dataO
 		}
 
 		// inverse fft
-		ifftPlan = fftwf_plan_dft_c2r_1d(windowSize, FFTSpectrum, IFFTReconstruction.data(), FFTW_MEASURE);
 		fftwf_execute(ifftPlan);
 
 		// windowing
 		for (int j = 0; j < windowSize; j++) {
 			
-			if (i+j < windowLatency) {
+			float windowIndex = outWindowIndex + j;
+			if (windowIndex < windowLatency) {
 				// calculate amount of windows overlapping
-				float windowIndex =  i + j;
+				
 				int windowsOverlapping = windowIndex / windowSize * overSampling + 1;
 
 				
 				// since not all windows overlap, just take the average of the ones that do overlap
-				// this should be improved
-				// idk why the 4 is there but it works
-				dataOut[j+i] += 4/windowsOverlapping*IFFTReconstruction[j]/(windowSize/2.0f*overSampling);
+				// this should be improved, at least simplyfiy the expression
+				dataOut[windowIndex] += overSampling/windowsOverlapping*IFFTReconstruction[j]/(windowSize/2.0f*overSampling);
 			} else {
 				// this computes the weight of the window on the final output
 				float window = -0.5f*cos(2.*M_PI*(float)j/(float)windowSize)+0.5f;
-				dataOut[j+i] += 2.0f*window*IFFTReconstruction[j]/(windowSize/2.0f*overSampling);
+				dataOut[windowIndex] += 2.0f*window*IFFTReconstruction[j]/(windowSize/2.0f*overSampling);
 			}
 
 
@@ -366,7 +395,7 @@ void SlicerT::phaseVocoder(std::vector<float> &dataIn, std::vector<float> &dataO
 
 	// normalize 	
 	float max = -1;
-	for (int i = 0;i<inFrames;i++) {
+	for (int i = 0;i<outFrames;i++) {
 		max = std::max(max, abs(dataOut[i]));
 		dataOut[i] = dataOut[i];
 	}
@@ -400,7 +429,7 @@ void SlicerT::normalizeSample(sampleFrame * data) {
 }
 
 void SlicerT::warmupFFT() {
-	const int dataPoints = 512;
+	const int dataPoints = 1024;
 
 	std::vector<float> warmupData(dataPoints, sqrt(2));
 	fftwf_complex fftOut[dataPoints];

From 85a6e361dc98d731c1f58d4c7e38f27a3ed78a3c Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Wed, 6 Sep 2023 06:37:22 +0200
Subject: [PATCH 05/99] pitch shifting works more or less

---
 plugins/Slicer/SlicerT.cpp | 27 ++++++++++++++-------------
 1 file changed, 14 insertions(+), 13 deletions(-)

diff --git a/plugins/Slicer/SlicerT.cpp b/plugins/Slicer/SlicerT.cpp
index 8dfab8fdbda..347b465c0b6 100644
--- a/plugins/Slicer/SlicerT.cpp
+++ b/plugins/Slicer/SlicerT.cpp
@@ -236,7 +236,7 @@ void SlicerT::timeShiftSample() {
 		bufferData.data()[i][1] = outData[i];
 	}
 
-	timeShiftedSample = SampleBuffer(bufferData.data(), originalFrames);
+	timeShiftedSample = *(SampleBuffer(bufferData.data(), originalFrames).resample(sampleRate , sampleRate * 1.1f));
 
 	printf("finished sample timeshifting\n");
 
@@ -247,7 +247,7 @@ void SlicerT::phaseVocoder(std::vector<float> &dataIn, std::vector<float> &dataO
 	using std::vector;
 	// processing parameters, lower is faster
 	const int windowSize = 2048;
-	const int overSampling = 16;
+	const int overSampling = 32;
 	
 	// audio data
 	int inFrames = dataIn.size();
@@ -334,21 +334,22 @@ void SlicerT::phaseVocoder(std::vector<float> &dataIn, std::vector<float> &dataO
 
 		}
 		// pitch shifting
-		// memset(processedFreq.data(), 0, processedFreq.size()*sizeof(float));
-		// memset(processedMagn.data(), 0, processedFreq.size()*sizeof(float));
-		// for (int j = 0; j < windowSize/2; j++) {
-		// 	int index = j*noteThreshold.value();
-		// 	if (index <= windowSize/2) {
-		// 		processedMagn[index] += allMagnitudes[j];
-		// 		processedFreq[index] = allFrequencies[j] * noteThreshold.value();
-		// 	}
+		memset(processedFreq.data(), 0, processedFreq.size()*sizeof(float));
+		memset(processedMagn.data(), 0, processedFreq.size()*sizeof(float));
+		for (int j = 0; j < windowSize/2; j++) {
+			int index = j*noteThreshold.value();
+			if (index <= windowSize/2) {
+				processedMagn[index] += allMagnitudes[j];
+				processedFreq[index] = allFrequencies[j]* noteThreshold.value();
+			}
+		}
+
 
-		// }
 
 		// synthesis, all the operations are the reverse of the analysis
 		for (int j = 0; j < windowSize; j++) {
-			magnitude = allMagnitudes[j];
-			freq = allFrequencies[j];
+			magnitude = processedMagn[j];
+			freq = processedFreq[j];
 
 			deltaPhase = freq - (float)j*freqPerBin;
 

From 7ca35af4de10bf077ada97e1e094ebde482a2af4 Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Wed, 6 Sep 2023 22:00:46 +0200
Subject: [PATCH 06/99] basic timeshift working

---
 plugins/Slicer/SlicerT.cpp | 104 +++++++++++++++++++++++++------------
 1 file changed, 70 insertions(+), 34 deletions(-)

diff --git a/plugins/Slicer/SlicerT.cpp b/plugins/Slicer/SlicerT.cpp
index 347b465c0b6..c45ad42f3a1 100644
--- a/plugins/Slicer/SlicerT.cpp
+++ b/plugins/Slicer/SlicerT.cpp
@@ -217,10 +217,7 @@ void SlicerT::timeShiftSample() {
 	float sampleRate = originalSample.sampleRate();
 	float speedRatio = (double)targetBPM / originalBPM;
 	int originalFrames = originalSample.frames();
-	int targetFrames = originalFrames * speedRatio;
 	
-
-
 	vector<float> rawData(originalFrames, 0);
 	vector<float> outData(originalFrames*2, 0);
 	vector<sampleFrame> bufferData(originalFrames*2, sampleFrame());
@@ -231,12 +228,13 @@ void SlicerT::timeShiftSample() {
 
 	phaseVocoder(rawData, outData, sampleRate, 1);
 
-	for (int i = 0;i<originalFrames;i++) {
+	for (int i = 0;i<bufferData.size();i++) {
 		bufferData.data()[i][0] = outData[i];
 		bufferData.data()[i][1] = outData[i];
 	}
 
-	timeShiftedSample = *(SampleBuffer(bufferData.data(), originalFrames).resample(sampleRate , sampleRate * 1.1f));
+	// timeShiftedSample = *(SampleBuffer(bufferData.data(), originalFrames).resample(sampleRate , sampleRate));
+	timeShiftedSample = SampleBuffer(bufferData.data(), bufferData.size());
 
 	printf("finished sample timeshifting\n");
 
@@ -251,23 +249,22 @@ void SlicerT::phaseVocoder(std::vector<float> &dataIn, std::vector<float> &dataO
 	
 	// audio data
 	int inFrames = dataIn.size();
-	int outFrames = dataIn.size();
+	int outFrames = dataOut.size();
 
-	float lengthRatio = 1;// inFrames / outFrames;
+	float lengthRatio = noteThreshold.value();// inFrames / outFrames;
 
 	// values used
 	const int stepSize = windowSize / overSampling; 
 	const int numWindows = inFrames / stepSize;
-	const int outStepSize = lengthRatio * stepSize;
-	const int windowLatency = (overSampling-1)*outStepSize;
+	const int windowLatency = (overSampling-1)*stepSize;
 	const float freqPerBin = sampleRate/windowSize; 
 	const float expectedPhase = 2.*M_PI*(float)stepSize/(float)windowSize;
 
 
-	printf("frames: %i ,step size: %i , out step size: %i , ratio: %f\n", inFrames, stepSize, outStepSize, lengthRatio);
+	printf("frames: %i , out frames: %i , ratio: %f\n", inFrames, outFrames, (float)outFrames / inFrames);
 	printf("frames: %i , maxFrames: %i \n", inFrames, (numWindows-overSampling) * stepSize + windowSize);
 	printf("will drop %i\n", inFrames%(inFrames/numWindows));
-	printf("pitch shift: %f", noteThreshold.value());
+	printf("pitch shift: %f\n", noteThreshold.value());
 
 	// initialize buffers
 
@@ -281,10 +278,11 @@ void SlicerT::phaseVocoder(std::vector<float> &dataIn, std::vector<float> &dataO
 	vector<float> lastPhase(windowSize, 0);
 	vector<float> sumPhase(windowSize, 0);
 
+	vector<float> outBuffer(inFrames, 0);
+
 	// declare vars
 	float real, imag, phase, magnitude, freq, deltaPhase = 0;
-	int inWindowIndex = 0;
-	int outWindowIndex = 0;
+	int windowIndex = 0;
 
 	// fft plans
 	fftwf_plan fftPlan;
@@ -295,11 +293,10 @@ void SlicerT::phaseVocoder(std::vector<float> &dataIn, std::vector<float> &dataO
 
 	// remove oversampling, because the actual window is overSampling* bigger than stepsize
 	for (int i = 0;i < numWindows-overSampling;i++) {
-		inWindowIndex = i * stepSize;
-		outWindowIndex = i * outStepSize;
+		windowIndex = i * stepSize;
 
 		// FFT
-		memcpy(FFTInput.data(), dataIn.data() + inWindowIndex, windowSize*sizeof(float));
+		memcpy(FFTInput.data(), dataIn.data() + windowIndex, windowSize*sizeof(float));
 
 		fftwf_execute(fftPlan);
 
@@ -333,14 +330,20 @@ void SlicerT::phaseVocoder(std::vector<float> &dataIn, std::vector<float> &dataO
 			allFrequencies[j] = freq;
 
 		}
+		
+		
 		// pitch shifting
+		// takes all the values that are below the nyquist frequency (representable with our samplerate)
+		// nyquist frequency = samplerate / 2
+		// and moves them to a different bin
+		// improve for larger pitch shift
 		memset(processedFreq.data(), 0, processedFreq.size()*sizeof(float));
 		memset(processedMagn.data(), 0, processedFreq.size()*sizeof(float));
 		for (int j = 0; j < windowSize/2; j++) {
-			int index = j*noteThreshold.value();
+			int index = (float)j * noteThreshold.value();
 			if (index <= windowSize/2) {
 				processedMagn[index] += allMagnitudes[j];
-				processedFreq[index] = allFrequencies[j]* noteThreshold.value();
+				processedFreq[index] = allFrequencies[j] * noteThreshold.value();
 			}
 		}
 
@@ -370,43 +373,76 @@ void SlicerT::phaseVocoder(std::vector<float> &dataIn, std::vector<float> &dataO
 		fftwf_execute(ifftPlan);
 
 		// windowing
+		// this is very bad, audible click at the beginning if we take the average,
+		// but else there is a windowSized delay...
+		// solution would be to take the average but blend it together better
+		// pls improve
 		for (int j = 0; j < windowSize; j++) {
 			
-			float windowIndex = outWindowIndex + j;
-			if (windowIndex < windowLatency) {
+			float outIndex = windowIndex + j;
+			if (outIndex < 0) {
 				// calculate amount of windows overlapping
-				
-				int windowsOverlapping = windowIndex / windowSize * overSampling + 1;
+				float windowsOverlapping =  outIndex / windowSize * overSampling + 1;
 
-				
 				// since not all windows overlap, just take the average of the ones that do overlap
-				// this should be improved, at least simplyfiy the expression
-				dataOut[windowIndex] += overSampling/windowsOverlapping*IFFTReconstruction[j]/(windowSize/2.0f*overSampling);
+				outBuffer[outIndex] += overSampling/windowsOverlapping*IFFTReconstruction[j]/(windowSize/2.0f*overSampling);
+
+				// no averaging, probably worse
+				// dataOut[outIndex] = overSampling*IFFTReconstruction[j]/(windowSize/2.0f*overSampling);
 			} else {
 				// this computes the weight of the window on the final output
 				float window = -0.5f*cos(2.*M_PI*(float)j/(float)windowSize)+0.5f;
-				dataOut[windowIndex] += 2.0f*window*IFFTReconstruction[j]/(windowSize/2.0f*overSampling);
-			}
 
+				outBuffer[outIndex] += 2.0f*window*IFFTReconstruction[j]/(windowSize/2.0f*overSampling);
+			}
 
 		}
 
 
 	}
 
+	fftwf_destroy_plan(fftPlan);
+	fftwf_destroy_plan(ifftPlan);
+
 	// normalize 	
 	float max = -1;
-	for (int i = 0;i<outFrames;i++) {
-		max = std::max(max, abs(dataOut[i]));
-		dataOut[i] = dataOut[i];
+	for (int i = 0;i<inFrames;i++) {
+		max = std::max(max, abs(outBuffer[i]));
 	}
 
-	for (int i = 0;i<outFrames;i++) {
-		dataOut[i] = dataOut[i] / max;
+	for (int i = 0;i<inFrames;i++) {
+		outBuffer[i] = outBuffer[i] / max;
 	}
 
-	fftwf_destroy_plan(fftPlan);
-	fftwf_destroy_plan(ifftPlan);
+	// memcpy(dataOut.data(), outBuffer.data(), inFrames*sizeof(float));
+
+	printf("finished pitch scaling sample\n");
+
+
+	// copied code from samplebuffer.resample()
+	int error;
+	SRC_STATE * state;
+	if ((state = src_new(SRC_SINC_BEST_QUALITY, 1, &error)) != nullptr)
+	{
+		SRC_DATA srcData;
+		// srcData.end_of_input = 1;
+		srcData.data_in = outBuffer.data();
+		srcData.data_out = dataOut.data();
+		srcData.input_frames = inFrames;
+		srcData.output_frames = outFrames;
+		srcData.src_ratio = noteThreshold.value();
+		if ((error = src_process(state, &srcData)))
+		{
+			printf("SlicerT: error while resampling: %s\n", src_strerror(error));
+		}
+		src_delete(state);
+	}
+	else
+	{
+		printf("Error: src_new() failed in SlicerT.cpp!\n");
+	}
+
+
 
 
 	// fftwf_cleanup();

From 89c67d9d7853fdf6991b018f108cea4400b060fc Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Thu, 7 Sep 2023 06:15:47 +0200
Subject: [PATCH 07/99] PV timeshift working (no pitch shift)

---
 plugins/Slicer/SlicerT.cpp | 85 +++++++++++++++-----------------------
 1 file changed, 33 insertions(+), 52 deletions(-)

diff --git a/plugins/Slicer/SlicerT.cpp b/plugins/Slicer/SlicerT.cpp
index c45ad42f3a1..c81951c1f82 100644
--- a/plugins/Slicer/SlicerT.cpp
+++ b/plugins/Slicer/SlicerT.cpp
@@ -240,25 +240,35 @@ void SlicerT::timeShiftSample() {
 
 }
 
-
+// basic phase vocoder implementation that time shifts without pitch change
+// a lot of stuff needs improvement, mostly the windowing and
+// the pitch shifting implemention
 void SlicerT::phaseVocoder(std::vector<float> &dataIn, std::vector<float> &dataOut, float sampleRate, float pitchScale) {
 	using std::vector;
 	// processing parameters, lower is faster
-	const int windowSize = 2048;
-	const int overSampling = 32;
+	// lower windows size seems to work better for time scaling,
+	// this is because the step site is scaled, but not the window size
+	// this causes slight timing differences between windows
+	// oversampling is better if higher always (probably)
+	const int windowSize = 512;
+	const int overSampling = 64;
 	
 	// audio data
 	int inFrames = dataIn.size();
 	int outFrames = dataOut.size();
 
-	float lengthRatio = noteThreshold.value();// inFrames / outFrames;
+	float lengthRatio = noteThreshold.value() + 0.001f;// inFrames / outFrames;
 
 	// values used
 	const int stepSize = windowSize / overSampling; 
+	const int outStepSize = stepSize * lengthRatio;
 	const int numWindows = inFrames / stepSize;
 	const int windowLatency = (overSampling-1)*stepSize;
 	const float freqPerBin = sampleRate/windowSize; 
-	const float expectedPhase = 2.*M_PI*(float)stepSize/(float)windowSize;
+	// very important
+	const float expectedPhaseIn = 2.*M_PI*(float)stepSize/(float)windowSize;
+	const float expectedPhaseOut = 2.*M_PI*(float)outStepSize/(float)windowSize;
+
 
 
 	printf("frames: %i , out frames: %i , ratio: %f\n", inFrames, outFrames, (float)outFrames / inFrames);
@@ -267,7 +277,6 @@ void SlicerT::phaseVocoder(std::vector<float> &dataIn, std::vector<float> &dataO
 	printf("pitch shift: %f\n", noteThreshold.value());
 
 	// initialize buffers
-
 	fftwf_complex FFTSpectrum[windowSize];
 	vector<float> FFTInput(windowSize, 0);
 	vector<float> IFFTReconstruction(windowSize, 0);
@@ -278,7 +287,7 @@ void SlicerT::phaseVocoder(std::vector<float> &dataIn, std::vector<float> &dataO
 	vector<float> lastPhase(windowSize, 0);
 	vector<float> sumPhase(windowSize, 0);
 
-	vector<float> outBuffer(inFrames, 0);
+	vector<float> outBuffer(outFrames, 0);
 
 	// declare vars
 	float real, imag, phase, magnitude, freq, deltaPhase = 0;
@@ -314,7 +323,7 @@ void SlicerT::phaseVocoder(std::vector<float> &dataIn, std::vector<float> &dataO
 			freq = phase - lastPhase[j]; // subtract prev pahse to get phase diference
 			lastPhase[j] = phase;
 
-			freq -= (float)j*expectedPhase; // subtract expected phase
+			freq -= (float)j*expectedPhaseIn; // subtract expected phase
 
 			// some black magic to get into +/- PI interval, revise later pls
 			long qpd = freq/M_PI;
@@ -337,22 +346,22 @@ void SlicerT::phaseVocoder(std::vector<float> &dataIn, std::vector<float> &dataO
 		// nyquist frequency = samplerate / 2
 		// and moves them to a different bin
 		// improve for larger pitch shift
-		memset(processedFreq.data(), 0, processedFreq.size()*sizeof(float));
-		memset(processedMagn.data(), 0, processedFreq.size()*sizeof(float));
-		for (int j = 0; j < windowSize/2; j++) {
-			int index = (float)j * noteThreshold.value();
-			if (index <= windowSize/2) {
-				processedMagn[index] += allMagnitudes[j];
-				processedFreq[index] = allFrequencies[j] * noteThreshold.value();
-			}
-		}
+		// memset(processedFreq.data(), 0, processedFreq.size()*sizeof(float));
+		// memset(processedMagn.data(), 0, processedFreq.size()*sizeof(float));
+		// for (int j = 0; j < windowSize/2; j++) {
+		// 	int index = (float)j;// * noteThreshold.value();
+		// 	if (index <= windowSize/2) {
+		// 		processedMagn[index] += allMagnitudes[j];
+		// 		processedFreq[index] = allFrequencies[j];// * noteThreshold.value();
+		// 	}
+		// }
 
 
 
 		// synthesis, all the operations are the reverse of the analysis
 		for (int j = 0; j < windowSize; j++) {
-			magnitude = processedMagn[j];
-			freq = processedFreq[j];
+			magnitude = allMagnitudes[j];
+			freq = allFrequencies[j];
 
 			deltaPhase = freq - (float)j*freqPerBin;
 
@@ -360,7 +369,7 @@ void SlicerT::phaseVocoder(std::vector<float> &dataIn, std::vector<float> &dataO
 
 			deltaPhase = 2.*M_PI*deltaPhase/overSampling;;
 
-			deltaPhase += (float)j*expectedPhase;
+			deltaPhase += (float)j*expectedPhaseOut;
 
 			sumPhase[j] += deltaPhase;
 			deltaPhase = sumPhase[j]; // this is the bin phase
@@ -379,7 +388,7 @@ void SlicerT::phaseVocoder(std::vector<float> &dataIn, std::vector<float> &dataO
 		// pls improve
 		for (int j = 0; j < windowSize; j++) {
 			
-			float outIndex = windowIndex + j;
+			float outIndex = i * outStepSize + j;
 			if (outIndex < 0) {
 				// calculate amount of windows overlapping
 				float windowsOverlapping =  outIndex / windowSize * overSampling + 1;
@@ -406,47 +415,19 @@ void SlicerT::phaseVocoder(std::vector<float> &dataIn, std::vector<float> &dataO
 
 	// normalize 	
 	float max = -1;
-	for (int i = 0;i<inFrames;i++) {
+	for (int i = 0;i<outFrames;i++) {
 		max = std::max(max, abs(outBuffer[i]));
 	}
 
-	for (int i = 0;i<inFrames;i++) {
+	for (int i = 0;i<outFrames;i++) {
 		outBuffer[i] = outBuffer[i] / max;
 	}
 
-	// memcpy(dataOut.data(), outBuffer.data(), inFrames*sizeof(float));
+	memcpy(dataOut.data(), outBuffer.data(), outFrames*sizeof(float));
 
 	printf("finished pitch scaling sample\n");
 
 
-	// copied code from samplebuffer.resample()
-	int error;
-	SRC_STATE * state;
-	if ((state = src_new(SRC_SINC_BEST_QUALITY, 1, &error)) != nullptr)
-	{
-		SRC_DATA srcData;
-		// srcData.end_of_input = 1;
-		srcData.data_in = outBuffer.data();
-		srcData.data_out = dataOut.data();
-		srcData.input_frames = inFrames;
-		srcData.output_frames = outFrames;
-		srcData.src_ratio = noteThreshold.value();
-		if ((error = src_process(state, &srcData)))
-		{
-			printf("SlicerT: error while resampling: %s\n", src_strerror(error));
-		}
-		src_delete(state);
-	}
-	else
-	{
-		printf("Error: src_new() failed in SlicerT.cpp!\n");
-	}
-
-
-
-
-	// fftwf_cleanup();
-
 }
 
 void SlicerT::normalizeSample(sampleFrame * data) {

From 30ff89a9d5324e203dcda10a65b6b5a398fa9d8b Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Fri, 8 Sep 2023 02:20:01 +0200
Subject: [PATCH 08/99] basic functions work (UI, editing, playback)

---
 plugins/Slicer/SlicerT.cpp   | 372 ++++++++++++++++-------------------
 plugins/Slicer/SlicerT.h     |  19 +-
 plugins/Slicer/SlicerTUI.cpp |  24 ++-
 plugins/Slicer/SlicerTUI.h   |   9 +-
 plugins/Slicer/WaveForm.cpp  | 194 ++++++++++++++++--
 plugins/Slicer/WaveForm.h    |  62 ++++--
 6 files changed, 437 insertions(+), 243 deletions(-)

diff --git a/plugins/Slicer/SlicerT.cpp b/plugins/Slicer/SlicerT.cpp
index c81951c1f82..f3756621896 100644
--- a/plugins/Slicer/SlicerT.cpp
+++ b/plugins/Slicer/SlicerT.cpp
@@ -38,26 +38,24 @@ the matchingSpeed buffer will always get initialzed freshly using a buffer, this
 give it the raw data
 */
 
+// TODO: add, remove slices; add gui values (fade out, window sizes?); fix timeshift lag (bpm change)
+// TODO: midi dragging, open file button
+// TODO: fix empty sample, small sample edge cases, general stability stuff
+
 // #include <QDomElement>
-#include <stdio.h>
 #include "SlicerT.h"
+#include <stdio.h>
+
 #include "fft_helpers.h"
 #include <atomic>
 
 // #include "AudioEngine.h"
 // #include "base64.h"
 #include "Engine.h"
-// #include "Graph.h"
 #include "InstrumentTrack.h"
-// #include "Knob.h"
-// #include "LedCheckBox.h"
-// #include "NotePlayHandle.h"
-// #include "PixmapButton.h"
 #include "Song.h"
-// #include "interpolation.h"
 #include <fftw3.h>
 
-
 #include "embed.h"
 #include "plugin_export.h"
 
@@ -68,7 +66,6 @@ namespace lmms
 {
 
 
-
 extern "C"
 {
 
@@ -94,11 +91,99 @@ SlicerT::SlicerT(InstrumentTrack * _instrument_track) :
 	Instrument( _instrument_track, &slicert_plugin_descriptor ),
 	originalSample(),
 	timeShiftedSample(),
-	noteThreshold( 0.6f, 0.0f, 2.0f, 0.01f, this, tr( "Note Threshold" ) )
+	noteThreshold( 0.6f, 0.0f, 2.0f, 0.01f, this, tr( "Note Threshold" ) ),
+	originalBPM(1, 1, 999, this, tr("original sample bpm"))
 {
-	// connect( &noteThreshold, SIGNAL( dataChanged() ), this, SLOT( updateParams() ) );
+	// connect( &noteThreshold, SIGNAL( dataChanged() ), this, SLOT( updateSlices() ) );
+	// TODO: either button to timeshift, threading or generating samples on the fly
+	connect( &originalBPM, SIGNAL( dataChanged() ), this, SLOT( updateTimeShift() ) );
+
 	printf("Correctly loaded SlicerT!\n");
-	// warmupFFT(); // maybe
+}
+
+void SlicerT::playNote( NotePlayHandle * _n, sampleFrame * _working_buffer ) {
+	const fpp_t frames = _n->framesLeftForCurrentPeriod();
+	const int playedFrames = _n->totalFramesPlayed();
+	const f_cnt_t offset = _n->noteOffset();
+	
+
+
+	int totalFrames = timeShiftedSample.frames();
+	int sliceStart = timeShiftedSample.startFrame();
+	int sliceEnd = timeShiftedSample.endFrame();
+	int sliceFrames = timeShiftedSample.endFrame() - timeShiftedSample.startFrame();
+	int noteFramesLeft = sliceFrames - playedFrames;
+
+	int fadeOutFrames = (float)sliceFrames/4;
+
+	// init NotePlayHandle data
+	if( !_n->m_pluginData )
+	{
+		_n->m_pluginData = new SampleBuffer::handleState( false, SRC_LINEAR );
+
+		float speedRatio = (float)originalBPM.value() / Engine::getSong()->getTempo() ;
+		int noteIndex = _n->key() - 69;
+		int sliceStart, sliceEnd;
+		
+		// 0th element is no sound, so play full sample
+		if (noteIndex > slicePoints.size()-2 || noteIndex < 0) {
+			sliceStart = 0;
+			sliceEnd = timeShiftedSample.frames();
+		} else {
+			sliceStart = slicePoints[noteIndex] * speedRatio;
+			sliceEnd = slicePoints[noteIndex+1] * speedRatio;
+		}
+
+
+		timeShiftedSample.setAllPointFrames( sliceStart, sliceEnd, sliceStart, sliceEnd );
+
+		printf("%i : %i -> %i\n", noteIndex, sliceStart, sliceEnd);
+		printf("%i\n", _n->oldKey());
+
+	
+	}
+
+
+	// if play returns true (success I guess)
+	if( ! _n->isFinished() ) {
+		if( timeShiftedSample.play( _working_buffer + offset,
+					(SampleBuffer::handleState *)_n->m_pluginData,
+					frames, 440,
+					static_cast<SampleBuffer::LoopMode>( 0 ) ) )
+		{
+
+			applyRelease( _working_buffer, _n );
+			instrumentTrack()->processAudioBuffer( _working_buffer,
+									frames + offset, _n );
+
+			// exponential fade out
+			if (noteFramesLeft < fadeOutFrames) {
+				// printf("fade out started. frames: %i, framesLeft: %i\n", frames, noteFramesLeft);
+				for (int i = 0;i<frames;i++) {
+					float fadeValue = (float)(noteFramesLeft-i) / fadeOutFrames;
+					// if the workingbuffer extends the sample
+					fadeValue = std::clamp(fadeValue, 0.0f, 1.0f);
+					fadeValue = pow(fadeValue, 2);
+
+					_working_buffer[i][0] *= fadeValue;
+					_working_buffer[i][1] *= fadeValue;
+				}
+			}
+
+			float absoluteCurrentNote = (float)(sliceStart + playedFrames) / totalFrames;
+			float absoluteStartNote = (float)sliceStart / totalFrames;
+			float abslouteEndNote = (float)sliceEnd / totalFrames;
+			emit isPlaying(absoluteCurrentNote, absoluteStartNote, abslouteEndNote);
+
+		} else {
+			emit isPlaying(0, 0, 0);			
+		}
+	} else {
+		emit isPlaying(0, 0, 0);
+	}
+
+	
+
 }
 
 
@@ -109,7 +194,7 @@ void SlicerT::findSlices() {
 	float lastPeak = 0;
 	float currentPeak = 0;
 	int minWindowsPassed = 0;
-	slicePoints = {0};
+	slicePoints = {};
 	for (int i = 0; i<originalSample.frames();i+=1) {
 		// combine left and right and absolute it
 		float sampleValue = abs(originalSample.data()[i][0]) + abs(originalSample.data()[i][1]) / 2;
@@ -122,7 +207,7 @@ void SlicerT::findSlices() {
 								//printf("%i -> %f : %f\n", i, currentAvg, lastAvg);
 			if (abs(currentPeak / lastPeak) > 1+noteThreshold.value() && minWindowsPassed <= 0) {
 				c++;
-				slicePoints.push_back(peakIndex);
+				slicePoints.push_back(std::max(0, peakIndex-window/2)); // slight offset
 				minWindowsPassed = 2; // wait at least one window for a new note
 			}
 			lastPeak = currentPeak;
@@ -135,11 +220,7 @@ void SlicerT::findSlices() {
 
 	}
 	slicePoints.push_back(originalSample.frames());
-	// for (int i : slicePoints) {
-	// 	printf("%i\n", i);
-	// }
-	
-	// printf("Found %i notes\n", c);
+
 	emit dataChanged();
 }
 
@@ -147,100 +228,100 @@ void SlicerT::findSlices() {
 
 // }
 
-void SlicerT::playNote( NotePlayHandle * _n, sampleFrame * _working_buffer ) {
-	
-	const fpp_t frames = _n->framesLeftForCurrentPeriod();
-	const f_cnt_t offset = _n->noteOffset();
+// find the bpm of the sample by assuming its in 4/4 time signature ,
+// and lies in the 100 - 200 bpm range
+void SlicerT::findBPM() {
+	int bpmSnap = 1;
 
-	// 0 at 440hz, or where the square thing is on the keyboard
-	
-
-	// init NotePlayHandle data
-	if( !_n->m_pluginData )
-	{
-		_n->m_pluginData = new SampleBuffer::handleState( false, SRC_LINEAR );
-
-		// 0th element is no sound, so play no sound when out of bounds
-		// int noteIndex = _n->key() - 68;
-		// if (noteIndex > slicePoints.size()-2 || noteIndex < 0) {
-		// 	noteIndex = 0;
-		// }
-
-		// int sliceStart = slicePoints[noteIndex];
-		// int sliceEnd = slicePoints[noteIndex+1];
-
-		// m_sampleBuffer.setAllPointFrames( sliceStart, sliceEnd, sliceStart, sliceEnd );
+	float sampleRate = originalSample.sampleRate();
+	float totalFrames = originalSample.frames();
+	float sampleLength = totalFrames / sampleRate;
 
-		// printf("%i : %i -> %i\n", noteIndex, sliceStart, sliceEnd);
-		// printf("%i\n", _n->oldKey());
+	// this assumes the sample has a time signature of x/4
+	float bpmEstimate = 240.0f / sampleLength;
 
-	
+	// deal with samlpes that are not 1 bar long
+	while (bpmEstimate < 100) {
+		bpmEstimate *= 2;
 	}
 
-	// if play returns true (success I guess)
-	if( timeShiftedSample.play( _working_buffer + offset,
-				(SampleBuffer::handleState *)_n->m_pluginData,
-				frames, 440,
-				static_cast<SampleBuffer::LoopMode>( 0 ) ) )
-	{
-
-		applyRelease( _working_buffer, _n );
-		instrumentTrack()->processAudioBuffer( _working_buffer,
-								frames + offset, _n );
-
+	while (bpmEstimate > 200) {
+		bpmEstimate /= 2;
 	}
 
+	// snap bpm
+	int bpm = bpmEstimate;
+	bpm += (float)bpmSnap / 2;
+	bpm -= bpm % bpmSnap;
 
-}
+	originalBPM.setValue(bpm);
+ }
 
 // create thimeshifted samplebuffer and timeshifted slicePoints
-// http://blogs.zynaptiq.com/bernsee/pitch-shifting-using-the-ft/
 void SlicerT::timeShiftSample() {
-
-	printf("starting sample timeshifting\n");
-
 	using std::vector;
+	printf("starting sample timeshifting\n");
 
+	// original sample data
+	float sampleRate = originalSample.sampleRate();
+	int originalFrames = originalSample.frames();
 
+	// target data TODO: fix this mess
+	bpm_t targetBPM = Engine::getSong()->getTempo();
+	float speedRatio = (float)originalBPM.value() / targetBPM ;
+	int samplesPerBeat = 60.0f / targetBPM * sampleRate;
+	int outFrames = speedRatio * originalFrames;
 
+	// snap to a beat, this should be in the UI
+	outFrames += (float)samplesPerBeat;
+	outFrames -= outFrames%samplesPerBeat;
 
-	bpm_t targetBPM = Engine::getSong()->getTempo();;
 	// nothing to do here
-	if (targetBPM == originalBPM) {
+	if (targetBPM == originalBPM.value()) {
 		timeShiftedSample = SampleBuffer(originalSample.data(), originalSample.frames());
 		printf("BPM match for sample, finished timeshift\n");
 		return;
 	}
 
-
-
-	float sampleRate = originalSample.sampleRate();
-	float speedRatio = (double)targetBPM / originalBPM;
-	int originalFrames = originalSample.frames();
-	
+	// buffers
 	vector<float> rawData(originalFrames, 0);
-	vector<float> outData(originalFrames*2, 0);
-	vector<sampleFrame> bufferData(originalFrames*2, sampleFrame());
+	vector<float> outData(outFrames, 0);
 
+	vector<sampleFrame> bufferData(outFrames, sampleFrame());
+
+	// copy channels for processing
 	for (int i = 0;i<originalFrames;i++) {
 		rawData[i] = (float)originalSample.data()[i][0];
 	}
-
+	printf("startign PV\n");
+	// process channels
 	phaseVocoder(rawData, outData, sampleRate, 1);
 
-	for (int i = 0;i<bufferData.size();i++) {
+	printf("starting buffer copy\n");
+	// write processed channels 
+	for (int i = 0;i<outFrames;i++) {
 		bufferData.data()[i][0] = outData[i];
 		bufferData.data()[i][1] = outData[i];
 	}
 
-	// timeShiftedSample = *(SampleBuffer(bufferData.data(), originalFrames).resample(sampleRate , sampleRate));
+	printf("creating timeshifted sample\n");
+	// new sample
 	timeShiftedSample = SampleBuffer(bufferData.data(), bufferData.size());
 
+
 	printf("finished sample timeshifting\n");
 
+
 }
 
+
 // basic phase vocoder implementation that time shifts without pitch change
+// resources:
+// http://blogs.zynaptiq.com/bernsee/pitch-shifting-using-the-ft/
+// https://sethares.engr.wisc.edu/vocoders/phasevocoder.html
+// https://dsp.stackexchange.com/questions/40101/audio-time-stretching-without-pitch-shifting/40367#40367
+// https://www.guitarpitchshifter.com/
+
 // a lot of stuff needs improvement, mostly the windowing and
 // the pitch shifting implemention
 void SlicerT::phaseVocoder(std::vector<float> &dataIn, std::vector<float> &dataOut, float sampleRate, float pitchScale) {
@@ -249,15 +330,17 @@ void SlicerT::phaseVocoder(std::vector<float> &dataIn, std::vector<float> &dataO
 	// lower windows size seems to work better for time scaling,
 	// this is because the step site is scaled, but not the window size
 	// this causes slight timing differences between windows
+	// sadly, lower windowsize also reduces audio quality in general
+	// TODO: find solution
 	// oversampling is better if higher always (probably)
 	const int windowSize = 512;
-	const int overSampling = 64;
+	const int overSampling = 32;
 	
 	// audio data
 	int inFrames = dataIn.size();
 	int outFrames = dataOut.size();
 
-	float lengthRatio = noteThreshold.value() + 0.001f;// inFrames / outFrames;
+	float lengthRatio = (float)outFrames / inFrames;
 
 	// values used
 	const int stepSize = windowSize / overSampling; 
@@ -270,11 +353,8 @@ void SlicerT::phaseVocoder(std::vector<float> &dataIn, std::vector<float> &dataO
 	const float expectedPhaseOut = 2.*M_PI*(float)outStepSize/(float)windowSize;
 
 
-
 	printf("frames: %i , out frames: %i , ratio: %f\n", inFrames, outFrames, (float)outFrames / inFrames);
-	printf("frames: %i , maxFrames: %i \n", inFrames, (numWindows-overSampling) * stepSize + windowSize);
 	printf("will drop %i\n", inFrames%(inFrames/numWindows));
-	printf("pitch shift: %f\n", noteThreshold.value());
 
 	// initialize buffers
 	fftwf_complex FFTSpectrum[windowSize];
@@ -299,14 +379,12 @@ void SlicerT::phaseVocoder(std::vector<float> &dataIn, std::vector<float> &dataO
 	fftwf_plan ifftPlan;
 	ifftPlan = fftwf_plan_dft_c2r_1d(windowSize, FFTSpectrum, IFFTReconstruction.data(), FFTW_MEASURE);
 
-
 	// remove oversampling, because the actual window is overSampling* bigger than stepsize
 	for (int i = 0;i < numWindows-overSampling;i++) {
 		windowIndex = i * stepSize;
 
 		// FFT
 		memcpy(FFTInput.data(), dataIn.data() + windowIndex, windowSize*sizeof(float));
-
 		fftwf_execute(fftPlan);
 
 		// analysis step
@@ -315,8 +393,6 @@ void SlicerT::phaseVocoder(std::vector<float> &dataIn, std::vector<float> &dataO
 			real = FFTSpectrum[j][0];
 			imag = FFTSpectrum[j][1];
 
-			// printf("freq: %3d %+9.5f %+9.5f I  original: %+9.5f \n", j, real, imag, dataIn.at(i+j));
-
 			magnitude = 2.*sqrt(real*real + imag*imag);
 			phase = atan2(imag,real); 
 
@@ -340,8 +416,7 @@ void SlicerT::phaseVocoder(std::vector<float> &dataIn, std::vector<float> &dataO
 
 		}
 		
-		
-		// pitch shifting
+		// TODO: pitch shifting
 		// takes all the values that are below the nyquist frequency (representable with our samplerate)
 		// nyquist frequency = samplerate / 2
 		// and moves them to a different bin
@@ -356,8 +431,6 @@ void SlicerT::phaseVocoder(std::vector<float> &dataIn, std::vector<float> &dataO
 		// 	}
 		// }
 
-
-
 		// synthesis, all the operations are the reverse of the analysis
 		for (int j = 0; j < windowSize; j++) {
 			magnitude = allMagnitudes[j];
@@ -385,11 +458,15 @@ void SlicerT::phaseVocoder(std::vector<float> &dataIn, std::vector<float> &dataO
 		// this is very bad, audible click at the beginning if we take the average,
 		// but else there is a windowSized delay...
 		// solution would be to take the average but blend it together better
-		// pls improve
+		// TODO: make better
 		for (int j = 0; j < windowSize; j++) {
-			
+
 			float outIndex = i * outStepSize + j;
-			if (outIndex < 0) {
+			if (outIndex > outFrames) {
+				printf("too long window size, breaking\n");
+				break;
+			}
+			if (outIndex < windowLatency) {
 				// calculate amount of windows overlapping
 				float windowsOverlapping =  outIndex / windowSize * overSampling + 1;
 
@@ -430,46 +507,24 @@ void SlicerT::phaseVocoder(std::vector<float> &dataIn, std::vector<float> &dataO
 
 }
 
-void SlicerT::normalizeSample(sampleFrame * data) {
-	float max = -1;
-	for (int i = 0;i<data->size();i++) {
-		max = std::max(max, abs(data[i][0]));
-		max = std::max(max, abs(data[i][1]));
-	}
-
-	printf("max: %f\n", max);
-
-	for (int i = 0;i<data->size();i++) {
-		data[i][0] = 0;
-		data[i][1] = 0;
-	}
-
-}
-
-void SlicerT::warmupFFT() {
-	const int dataPoints = 1024;
-
-	std::vector<float> warmupData(dataPoints, sqrt(2));
-	fftwf_complex fftOut[dataPoints];
-	fftwf_plan p = fftwf_plan_dft_r2c_1d(dataPoints, warmupData.data(), fftOut, FFTW_MEASURE);
-	fftwf_execute(p);
 
-	fftwf_plan d = fftwf_plan_dft_c2r_1d(dataPoints, fftOut, warmupData.data(), FFTW_MEASURE);
-	fftwf_execute(d);
-
-	fftwf_destroy_plan(p);
-	fftwf_destroy_plan(d);
-}
 
 void SlicerT::updateFile(QString file) {
 	printf("updated audio file\n");
 	originalSample.setAudioFile(file);
 	findSlices();
-	// updateBPM()
-	timeShiftSample();
+	findBPM(); // this also updates timeshift because bpm change
 	
 }
 
+void SlicerT::updateSlices() {
+	findSlices();
+}
+
+void SlicerT::updateTimeShift() {
+	timeShiftSample();
+}
+
 
 void SlicerT::saveSettings(QDomDocument & _doc, QDomElement & _parent) {}
 void SlicerT::loadSettings( const QDomElement & _this ) {}
@@ -502,80 +557,3 @@ PLUGIN_EXPORT Plugin * lmms_plugin_main( Model *m, void * )
 
 } // namespace lmms
 
-
-
-/* Implementation of Robust peak detection algorithm
-Doesnt work that great, it is too sensitive 
-https://stackoverflow.com/questions/22583391/peak-signal-detection-in-realtime-timeseries-data/46998001#46998001
-void SlicerT::findSlices() {
-	int c = 0;
-	const int lag = 64;
-	const float influence = 1;
-	
-	float peak = 0;
-	float lastMean = 0;
-	float lastStd = 0;
-	int noteDuration = 0;
-	// init vector with the start of the sample
-	std::vector<float> lastValues = {};
-
-
-	slicePoints = {};
-	for (int i = 0; i<m_sampleBuffer.frames();i++) {
-		// combine left and right and absolute it
-		float sampleValue = abs(m_sampleBuffer.data()[i][0]) + abs(m_sampleBuffer.data()[i][1]) / 2;
-		peak = std::max(sampleValue, peak);
-
-		if (i%64==0) {
-
-			if (lastValues.size() < lag) {
-				lastValues.push_back(peak);
-				continue;
-			} 
-
-			if (abs(peak - lastMean) > noteThreshold.value()) {
-				if (noteDuration <= 0) {
-					printf("%f : %f : %f\n", peak, lastMean, lastStd);
-					// lastValues.push_back(influence*peak + (1-influence)* lastValues.back());
-					lastValues.push_back(peak);
-					lastValues.erase(lastValues.begin());
-					c++;
-					slicePoints.push_back(i);
-					noteDuration = 20;
-				}
-
-			} else {
-
-				lastValues.push_back(peak);
-				lastValues.erase(lastValues.begin());
-				
-			}
-			noteDuration--;
-
-			lastMean = 0;
-			for (float v : lastValues) {
-				lastMean += v;
-			}
-			lastMean /= lag;
-
-			lastStd = 0;
-			for (float v : lastValues) {
-				lastStd += pow(v - lastMean, 2);
-			}
-
-			lastStd = sqrt(lastStd / lag);
-			peak = 0;
-		}
-
-
-
-
-	}
-	// for (int i : slicePoints) {
-	// 	printf("%i\n", i);
-	// }
-	
-	printf("Found %i notes\n", c);
-	emit dataChanged();
-}
-*/
\ No newline at end of file
diff --git a/plugins/Slicer/SlicerT.h b/plugins/Slicer/SlicerT.h
index 1301f7b0258..549464e21ab 100644
--- a/plugins/Slicer/SlicerT.h
+++ b/plugins/Slicer/SlicerT.h
@@ -24,8 +24,8 @@
  */
 
 
-#ifndef TEST_H
-#define TEST_H
+#ifndef SLICERT_H
+#define SLICERT_H
 
 #include "AutomatableModel.h"
 #include "Instrument.h"
@@ -60,27 +60,30 @@ class SlicerT : public Instrument{
 
 	public slots:
 		void updateFile(QString file);
-		void updateParams();
+		void updateTimeShift();
+		void updateSlices();
+
+	signals:
+		void isPlaying( float current, float start, float end );
 
 	private:
 	
 
 		FloatModel noteThreshold;
+		IntModel originalBPM = 140;
 
 		SampleBuffer originalSample;
 		SampleBuffer timeShiftedSample;
 		std::vector<int> slicePoints;
-		std::vector<int> timeShiftedSlices;
 		
-		int originalBPM = 140;
-
+	
 		void findSlices();
+		void findBPM();
 		void timeShiftSample();
 		void phaseVocoder(std::vector<float> &in, std::vector<float> &out, float sampleRate, float pitchScale);
-		void normalizeSample(sampleFrame * data);
-		void warmupFFT(); // runs one fft cycle to generate wisdom
 
 		friend class gui::SlicerTUI;
+		friend class gui::WaveForm;
 		
 };
 
diff --git a/plugins/Slicer/SlicerTUI.cpp b/plugins/Slicer/SlicerTUI.cpp
index 7137b52754c..7afd12dcd0c 100644
--- a/plugins/Slicer/SlicerTUI.cpp
+++ b/plugins/Slicer/SlicerTUI.cpp
@@ -23,6 +23,7 @@
 // #include <QPainter>
 #include <QFileInfo>
 #include <QDropEvent>
+#include "embed.h"
 
 namespace lmms
 {
@@ -35,19 +36,34 @@ SlicerTUI::SlicerTUI( SlicerT * _instrument,
 	InstrumentViewFixedSize( _instrument, _parent ),
 	noteThresholdKnob(KnobType::Bright26, this),
 	slicerTParent(_instrument),
-	wf(200, 100, (_instrument->slicePoints), _parent)
+	wf(245, 125, _instrument, this),
+	bpmBox(3, "21pink", this),
+	resetButton(embed::getIconPixmap("reload"), QString(), this)
 	
 {
 	setAcceptDrops( true );
-	wf.move(30, 30); 
+
+	wf.move(2, 5); 
+
+	resetButton.move(100, 150);
+	connect(&resetButton, SIGNAL( clicked() ), slicerTParent, SLOT( updateSlices() ));
+	connect(&resetButton, SIGNAL( clicked() ), &wf, SLOT( updateUI() ));
+
+	bpmBox.move(30, 150);
+	bpmBox.setToolTip(tr("original sample BPM"));
+	bpmBox.setLabel(tr("BPM"));
+	bpmBox.setModel(&slicerTParent->originalBPM);
+
 	noteThresholdKnob.move(30, 200);
 	noteThresholdKnob.setModel(&slicerTParent->noteThreshold);
 
 }
 
 void SlicerTUI::mousePressEvent( QMouseEvent * _me ) {
-	slicerTParent->findSlices();
-	slicerTParent->timeShiftSample();
+	printf("clicked on TUI\n");
+	// slicerTParent->findSlices();
+	// slicerTParent->findBPM();
+	// slicerTParent->timeShiftSample();
 
 	update();
 }
diff --git a/plugins/Slicer/SlicerTUI.h b/plugins/Slicer/SlicerTUI.h
index 7965dc32f94..0f28c05a2e9 100644
--- a/plugins/Slicer/SlicerTUI.h
+++ b/plugins/Slicer/SlicerTUI.h
@@ -4,13 +4,15 @@
 #include "Instrument.h"
 #include "InstrumentView.h"
 #include "Knob.h"
+#include "LcdSpinBox.h"
+#include <QPushButton>
 // #include "Graph.h"
 // #include "MemoryManager.h"
 
 
 
-#ifndef SLICER_UI_H
-#define SLICER_UI_H
+#ifndef SLICERT_UI_H
+#define SLICERT_UI_H
 
 namespace lmms
 {
@@ -47,6 +49,9 @@ class SlicerTUI : public InstrumentViewFixedSize
 	SlicerT * slicerTParent;
 
 	Knob noteThresholdKnob;
+	LcdSpinBox bpmBox;
+
+	QPushButton resetButton;
 
 	WaveForm wf;
 
diff --git a/plugins/Slicer/WaveForm.cpp b/plugins/Slicer/WaveForm.cpp
index a0bc53ce621..876b8713cd2 100644
--- a/plugins/Slicer/WaveForm.cpp
+++ b/plugins/Slicer/WaveForm.cpp
@@ -1,6 +1,8 @@
 #include <stdio.h>
 
 #include "WaveForm.h"
+#include "SlicerT.h"
+
 
 namespace lmms
 {
@@ -8,50 +10,202 @@ namespace lmms
 
 namespace gui
 {
-    WaveForm::WaveForm(int _w, int _h, std::vector<int> & _slicePoints, QWidget * _parent) :
+    WaveForm::WaveForm(int _w, int _h, SlicerT  * _instrument, QWidget * _parent) :
         QWidget(_parent),
-        m_graph( QPixmap(_w, _h)),
+        seeker(QPixmap(_w, _h*seekerRatio)),
+        sliceEditor(QPixmap(_w, _h*(1 - seekerRatio) - margin)),
         currentSample(),
-        slicePoints(_slicePoints)
+        slicePoints(_instrument->slicePoints)
         {
             width = _w;
             height = _h;
-            setFixedSize( width, height );
+            slicerTParent = _instrument;
+            setFixedSize(width, height);
+            setMouseTracking( true );
+            setAcceptDrops( true );
+
+            sliceEditor.fill(waveformBgColor);
+            seeker.fill(waveformBgColor);
 
-            m_graph.fill(QColor(11, 11, 11));
+            connect(slicerTParent, 
+                    SIGNAL(isPlaying(float, float, float)), 
+                    this, 
+                    SLOT(isPlaying(float, float, float)));
         }
 
-    void WaveForm::drawWaveForm() {
-        m_graph.fill(QColor(11, 11, 11));
-        QPainter brush(&m_graph);
-        brush.setPen(QColor(255, 0, 0));
+    void WaveForm::drawEditor() {
+        sliceEditor.fill(waveformBgColor);
+        QPainter brush(&sliceEditor);
+        brush.setPen(waveformColor);
+
+        float startFrame = seekerStart * currentSample.frames();
+        float endFrame = seekerEnd * currentSample.frames();
+
         currentSample.visualize(
 		brush,
-		QRect( 0, 0, m_graph.width(), m_graph.height() ),
+		QRect( 0, 0, sliceEditor.width(), sliceEditor.height() ),
+		startFrame, endFrame);
+
+
+        for (int i = 0;i<slicePoints.size();i++) {
+            int sliceIndex = slicePoints[i];
+            brush.setPen(QPen(sliceColor, 2));
+
+            if (sliceIndex >= startFrame && sliceIndex <= endFrame) {
+                float xPos = (float)(sliceIndex - startFrame) / (float)(endFrame - startFrame) * (float)width;
+                if (i == sliceSelected) {
+                    brush.setPen(QPen(selectedSliceColor, 2));
+                }
+
+                brush.drawLine(xPos, 0, xPos, height);
+            }
+
+        }
+
+    }
+
+    void WaveForm::drawSeeker() {
+        seeker.fill(waveformBgColor);
+        QPainter brush(&seeker);
+        brush.setPen(waveformColor);
+
+        currentSample.visualize(
+		brush,
+		QRect( 0, 0, seeker.width(), seeker.height() ),
 		0, currentSample.frames());
-        brush.setPen(QColor(0, 255, 0));
 
+        // draw slice points
+        brush.setPen(sliceColor);
         for (int i = 0;i<slicePoints.size();i++) {
-            // printf("%i\n", slicePoints[i]);
             float xPos = (float)slicePoints[i] / (float)currentSample.frames() * (float)width;
-            // printf("%i / %i * %i = %f\n", slicePoints[i] , currentSample.frames() , width, xPos);
             brush.drawLine(xPos, 0, xPos, height);
         }
 
-    }
+        // draw current playBack
+        brush.setPen(playColor);
+        // printf("noteplay index: %i\n", noteCurrent);
+        brush.drawLine(noteCurrent*width, 0, noteCurrent*width, height);
+        brush.fillRect(noteStart*width, 0, (noteEnd-noteStart)*width, height, playHighlighColor);
 
+        // draw seeker points
+        brush.setPen(QPen(seekerColor, 3));
+        brush.drawLine(seekerStart*width, 0, seekerStart*width, height);
+        brush.drawLine(seekerEnd*width, 0, seekerEnd*width, height);
 
-    void WaveForm::paintEvent( QPaintEvent * _pe) {
-        QPainter p( this );
-        drawWaveForm();
-        p.drawPixmap(0, 0, m_graph);
+        // shadow on not selected area
+        brush.fillRect(0, 0, seekerStart*width, height, seekerShadowColor);
+        brush.fillRect(seekerEnd*width, 0, width, height, seekerShadowColor);
+    }
+
+    void WaveForm::updateUI() {
+        drawSeeker();
+        drawEditor();
+        update();
     }
 
     void WaveForm::updateFile(QString file) {
         currentSample.setAudioFile(file);
-        drawWaveForm();
-        update();
+        updateUI();
+    }
+
+    void WaveForm::isPlaying(float current, float start, float end) {
+        noteCurrent = current;
+        noteStart = start;
+        noteEnd = end;
+        updateUI();
+    }
+
+    void WaveForm::mousePressEvent( QMouseEvent * _me ) {
+        isDragging = true;
+        float normalizedClick = (float)_me->x() / width;
+
+        if (_me->y() < height*seekerRatio) {
+            if (abs(normalizedClick - seekerStart) < 0.03) {
+                currentlyDragging = draggingTypes::seekerStart;
+            } else if (abs(normalizedClick - seekerEnd) < 0.03) {
+                currentlyDragging = draggingTypes::seekerEnd;
+            } else if (normalizedClick > seekerStart && normalizedClick < seekerEnd) {
+                currentlyDragging = draggingTypes::seekerMiddle;
+                seekerMiddle = normalizedClick;
+            }
+
+        } else {
+            float startFrame = seekerStart * currentSample.frames();
+            float endFrame = seekerEnd * currentSample.frames();
+            for (int i = 0;i<slicePoints.size();i++) {
+                int sliceIndex = slicePoints[i];
+                // if (sliceIndex >= startFrame && sliceIndex <= endFrame) {
+                    float xPos = (float)(sliceIndex - startFrame) / (float)(endFrame - startFrame);
+                    if (abs(xPos - normalizedClick) < 0.03) {
+                        currentlyDragging = draggingTypes::slicePoint;
+                        sliceSelected = i;
+                    // }
+                }
+            }
+        }
+
+    }
+
+    void WaveForm::enterEvent( QEvent * _e ) {}
+    void WaveForm::leaveEvent( QEvent * _e ) {}
+    void WaveForm::mouseReleaseEvent( QMouseEvent * _me ) {
+        isDragging = false;
+        currentlyDragging = draggingTypes::nothing;
+        sliceSelected = 0;
+        updateUI();
     }
+    void WaveForm::mouseMoveEvent( QMouseEvent * _me ) {
+        float normalizedClick = (float)_me->x() / width;
+        
+        // handle dragging events
+        if (isDragging) { 
+            // printf("drag type:%i , seekerStart: %f , seekerEnd: %f \n", currentlyDragging, seekerStart, seekerEnd);
+            if (currentlyDragging == draggingTypes::seekerStart) {
+                seekerStart = std::clamp(normalizedClick, 0.0f, seekerEnd - 0.13f);
+
+            } else if (currentlyDragging == draggingTypes::seekerEnd) {
+                seekerEnd = std::clamp(normalizedClick, seekerStart + 0.13f, 1.0f);;
+
+            } else if (currentlyDragging == draggingTypes::seekerMiddle) {
+                float distStart = seekerStart - seekerMiddle;
+                float distEnd = seekerEnd - seekerMiddle;
+
+                seekerMiddle = normalizedClick;
+
+                if (seekerMiddle + distStart > 0 && seekerMiddle + distEnd < 1) {
+                    seekerStart = seekerMiddle + distStart;
+                    seekerEnd = seekerMiddle + distEnd;
+                }
+
+            } else if (currentlyDragging == draggingTypes::slicePoint) {
+                float startFrame = seekerStart * currentSample.frames();
+                float endFrame = seekerEnd * currentSample.frames();
+
+                slicePoints[sliceSelected] = startFrame + normalizedClick * (endFrame - startFrame);
+
+                slicePoints[sliceSelected] = std::clamp(slicePoints[sliceSelected], 0, currentSample.frames());
+
+                std::sort(slicePoints.begin(), slicePoints.end());
+
+            }
+            updateUI();
+        } else {
+            
+        }
+
+        
+
+    }
+    void WaveForm::wheelEvent( QWheelEvent * _we ) {}
+
+
+    void WaveForm::paintEvent( QPaintEvent * _pe) {
+        QPainter p( this );
+        p.drawPixmap(0, height*0.3f + margin, sliceEditor);
+        p.drawPixmap(0, 0, seeker);
+    }
+
+
 
 }
 }
\ No newline at end of file
diff --git a/plugins/Slicer/WaveForm.h b/plugins/Slicer/WaveForm.h
index 52b54a311df..be66b455d26 100644
--- a/plugins/Slicer/WaveForm.h
+++ b/plugins/Slicer/WaveForm.h
@@ -11,6 +11,7 @@
 namespace lmms
 {
 
+class SlicerT;
 
 namespace gui
 {
@@ -19,30 +20,67 @@ namespace gui
 class WaveForm : public QWidget {
     	Q_OBJECT
     protected:
-        // virtual void enterEvent( QEvent * _e );
-        // virtual void leaveEvent( QEvent * _e );
-        // virtual void mousePressEvent( QMouseEvent * _me );
-        // virtual void mouseReleaseEvent( QMouseEvent * _me );
-        // virtual void mouseMoveEvent( QMouseEvent * _me );
-        // virtual void wheelEvent( QWheelEvent * _we );
+        virtual void enterEvent( QEvent * _e );
+        virtual void leaveEvent( QEvent * _e );
+        virtual void mousePressEvent( QMouseEvent * _me );
+        virtual void mouseReleaseEvent( QMouseEvent * _me );
+        virtual void mouseMoveEvent( QMouseEvent * _me );
+        virtual void wheelEvent( QWheelEvent * _we );
         virtual void paintEvent( QPaintEvent * _pe );
 
 
     private:
-        
-        QPixmap m_graph;
-
-        SampleBuffer currentSample;
         int width;
         int height;
+        float seekerRatio = 0.3f;
+        int margin = 5;
+        QColor waveformBgColor = QColor(11, 11, 11);
+        QColor waveformColor = QColor(124, 49, 214);
+        QColor playColor = QColor(255, 255, 255, 200);
+        QColor playHighlighColor = QColor(255, 255, 255, 70);
+        QColor sliceColor = QColor(49, 214, 124);
+        QColor selectedSliceColor = QColor(172, 236, 190);
+        QColor seekerColor = QColor(214, 124, 49);
+        QColor seekerShadowColor = QColor(0, 0, 0, 175);
+
+        enum class draggingTypes {
+            nothing,
+            seekerStart,
+            seekerEnd,
+            seekerMiddle,
+            slicePoint,
+        };
+        draggingTypes currentlyDragging;
+        bool isDragging = false;
+
+        float seekerStart = 0;
+        float seekerEnd = 1;
+        float seekerMiddle = 0.5f;
+        int sliceSelected = 0;
+
+        float noteCurrent;
+        float noteStart;
+        float noteEnd;
+
+        QPixmap sliceEditor;
+        QPixmap seeker;
+
+        SampleBuffer currentSample;
+
+        void drawEditor();
+        void drawSeeker();
+        
 
-        void drawWaveForm();
+    public slots:
+        void updateUI();
+        void isPlaying(float current, float start, float end);
 
     public:
-        WaveForm(int _w, int _h, std::vector<int> & _slicePoints, QWidget * _parent);
+        WaveForm(int _w, int _h, SlicerT * _instrument, QWidget * _parent);
         void updateFile(QString file);
 
     private:
+        SlicerT * slicerTParent;
         std::vector<int> & slicePoints;
 
 };

From 330cc1564a7e6f37c3867ca8dedd1a8e28d20e36 Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Fri, 8 Sep 2023 05:36:37 +0200
Subject: [PATCH 09/99] slice editor Ui working

---
 plugins/Slicer/SlicerT.cpp   | 12 +++----
 plugins/Slicer/SlicerTUI.cpp |  2 +-
 plugins/Slicer/WaveForm.cpp  | 69 ++++++++++++++++++++++++++++--------
 plugins/Slicer/WaveForm.h    |  8 ++---
 4 files changed, 65 insertions(+), 26 deletions(-)

diff --git a/plugins/Slicer/SlicerT.cpp b/plugins/Slicer/SlicerT.cpp
index f3756621896..8e8f0fb41e3 100644
--- a/plugins/Slicer/SlicerT.cpp
+++ b/plugins/Slicer/SlicerT.cpp
@@ -38,7 +38,7 @@ the matchingSpeed buffer will always get initialzed freshly using a buffer, this
 give it the raw data
 */
 
-// TODO: add, remove slices; add gui values (fade out, window sizes?); fix timeshift lag (bpm change)
+// TODO: add gui values (fade out, window sizes?); fix timeshift lag (bpm change)
 // TODO: midi dragging, open file button
 // TODO: fix empty sample, small sample edge cases, general stability stuff
 
@@ -137,8 +137,8 @@ void SlicerT::playNote( NotePlayHandle * _n, sampleFrame * _working_buffer ) {
 
 		timeShiftedSample.setAllPointFrames( sliceStart, sliceEnd, sliceStart, sliceEnd );
 
-		printf("%i : %i -> %i\n", noteIndex, sliceStart, sliceEnd);
-		printf("%i\n", _n->oldKey());
+		// printf("%i : %i -> %i\n", noteIndex, sliceStart, sliceEnd);
+		// printf("%i\n", _n->oldKey());
 
 	
 	}
@@ -173,13 +173,13 @@ void SlicerT::playNote( NotePlayHandle * _n, sampleFrame * _working_buffer ) {
 			float absoluteCurrentNote = (float)(sliceStart + playedFrames) / totalFrames;
 			float absoluteStartNote = (float)sliceStart / totalFrames;
 			float abslouteEndNote = (float)sliceEnd / totalFrames;
-			emit isPlaying(absoluteCurrentNote, absoluteStartNote, abslouteEndNote);
+			// emit isPlaying(absoluteCurrentNote, absoluteStartNote, abslouteEndNote);
 
 		} else {
-			emit isPlaying(0, 0, 0);			
+			// emit isPlaying(0, 0, 0);			
 		}
 	} else {
-		emit isPlaying(0, 0, 0);
+		// emit isPlaying(0, 0, 0);
 	}
 
 	
diff --git a/plugins/Slicer/SlicerTUI.cpp b/plugins/Slicer/SlicerTUI.cpp
index 7afd12dcd0c..40f123bc959 100644
--- a/plugins/Slicer/SlicerTUI.cpp
+++ b/plugins/Slicer/SlicerTUI.cpp
@@ -42,6 +42,7 @@ SlicerTUI::SlicerTUI( SlicerT * _instrument,
 	
 {
 	setAcceptDrops( true );
+	setFocusProxy(&wf);
 
 	wf.move(2, 5); 
 
@@ -64,7 +65,6 @@ void SlicerTUI::mousePressEvent( QMouseEvent * _me ) {
 	// slicerTParent->findSlices();
 	// slicerTParent->findBPM();
 	// slicerTParent->timeShiftSample();
-
 	update();
 }
 
diff --git a/plugins/Slicer/WaveForm.cpp b/plugins/Slicer/WaveForm.cpp
index 876b8713cd2..f2e33c0a5d3 100644
--- a/plugins/Slicer/WaveForm.cpp
+++ b/plugins/Slicer/WaveForm.cpp
@@ -23,6 +23,7 @@ namespace gui
             setFixedSize(width, height);
             setMouseTracking( true );
             setAcceptDrops( true );
+            setFocusPolicy(Qt::StrongFocus);
 
             sliceEditor.fill(waveformBgColor);
             seeker.fill(waveformBgColor);
@@ -59,9 +60,7 @@ namespace gui
 
                 brush.drawLine(xPos, 0, xPos, height);
             }
-
         }
-
     }
 
     void WaveForm::drawSeeker() {
@@ -116,44 +115,55 @@ namespace gui
     }
 
     void WaveForm::mousePressEvent( QMouseEvent * _me ) {
-        isDragging = true;
         float normalizedClick = (float)_me->x() / width;
-
+        
         if (_me->y() < height*seekerRatio) {
             if (abs(normalizedClick - seekerStart) < 0.03) {
                 currentlyDragging = draggingTypes::seekerStart;
+
             } else if (abs(normalizedClick - seekerEnd) < 0.03) {
                 currentlyDragging = draggingTypes::seekerEnd;
+
             } else if (normalizedClick > seekerStart && normalizedClick < seekerEnd) {
                 currentlyDragging = draggingTypes::seekerMiddle;
                 seekerMiddle = normalizedClick;
             }
 
         } else {
+            sliceSelected = -1;
             float startFrame = seekerStart * currentSample.frames();
             float endFrame = seekerEnd * currentSample.frames();
+            
             for (int i = 0;i<slicePoints.size();i++) {
                 int sliceIndex = slicePoints[i];
-                // if (sliceIndex >= startFrame && sliceIndex <= endFrame) {
-                    float xPos = (float)(sliceIndex - startFrame) / (float)(endFrame - startFrame);
-                    if (abs(xPos - normalizedClick) < 0.03) {
-                        currentlyDragging = draggingTypes::slicePoint;
-                        sliceSelected = i;
-                    // }
+                float xPos = (float)(sliceIndex - startFrame) / (float)(endFrame - startFrame);
+
+                if (abs(xPos - normalizedClick) < 0.03) {
+                    currentlyDragging = draggingTypes::slicePoint;
+                    sliceSelected = i;
+
                 }
             }
+        } 
+
+        if (_me->button() == Qt::MouseButton::LeftButton) {
+            isDragging = true;
+
+        } else if (_me->button() == Qt::MouseButton::RightButton) {
+            if (sliceSelected != -1 && slicePoints.size() > 2) {
+                slicePoints.erase(slicePoints.begin() + sliceSelected);
+                sliceSelected = -1;
+            }
         }
 
     }
 
-    void WaveForm::enterEvent( QEvent * _e ) {}
-    void WaveForm::leaveEvent( QEvent * _e ) {}
     void WaveForm::mouseReleaseEvent( QMouseEvent * _me ) {
         isDragging = false;
         currentlyDragging = draggingTypes::nothing;
-        sliceSelected = 0;
         updateUI();
     }
+
     void WaveForm::mouseMoveEvent( QMouseEvent * _me ) {
         float normalizedClick = (float)_me->x() / width;
         
@@ -190,14 +200,43 @@ namespace gui
             }
             updateUI();
         } else {
-            
+
         }
 
         
 
     }
-    void WaveForm::wheelEvent( QWheelEvent * _we ) {}
 
+    void WaveForm::mouseDoubleClickEvent(QMouseEvent * _me) {
+        float normalizedClick = (float)_me->x() / width;
+        float startFrame = seekerStart * currentSample.frames();
+        float endFrame = seekerEnd * currentSample.frames();
+
+        float slicePosition = startFrame + normalizedClick * (endFrame - startFrame);
+
+        for (int i = 0;i<slicePoints.size();i++) {
+            if (slicePoints[i] < slicePosition) {
+                slicePoints.insert(slicePoints.begin() + i, slicePosition);
+                break;
+            }
+        }
+
+        std::sort(slicePoints.begin(), slicePoints.end());
+        
+    }
+
+    // pianoView.cpp always claims focus while in plugin screen, so this doesnt work
+    void WaveForm::keyPressEvent(QKeyEvent * ke) {
+        int key = ke->key();
+        printf("key: %i\n", ke->key());
+        if ((key == 16777219 || key == 16777223) && // delete and backspace 
+            (sliceSelected != -1 && slicePoints.size() > 2)) {
+
+            slicePoints.erase(slicePoints.begin() + sliceSelected);
+        }
+        updateUI();
+
+    }
 
     void WaveForm::paintEvent( QPaintEvent * _pe) {
         QPainter p( this );
diff --git a/plugins/Slicer/WaveForm.h b/plugins/Slicer/WaveForm.h
index be66b455d26..844d6c84223 100644
--- a/plugins/Slicer/WaveForm.h
+++ b/plugins/Slicer/WaveForm.h
@@ -20,14 +20,14 @@ namespace gui
 class WaveForm : public QWidget {
     	Q_OBJECT
     protected:
-        virtual void enterEvent( QEvent * _e );
-        virtual void leaveEvent( QEvent * _e );
         virtual void mousePressEvent( QMouseEvent * _me );
         virtual void mouseReleaseEvent( QMouseEvent * _me );
         virtual void mouseMoveEvent( QMouseEvent * _me );
-        virtual void wheelEvent( QWheelEvent * _we );
-        virtual void paintEvent( QPaintEvent * _pe );
+        virtual void mouseDoubleClickEvent(QMouseEvent * _me);
 
+        virtual void keyPressEvent(QKeyEvent * ke);
+
+        virtual void paintEvent( QPaintEvent * _pe);
 
     private:
         int width;

From 9a2a83dcbfda4884e1bbeefd3436dd0976af4f8c Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Fri, 8 Sep 2023 17:51:45 +0200
Subject: [PATCH 10/99] fundamental  functionality done

---
 plugins/Slicer/SlicerT.cpp   | 148 +++++++++++++++++++++--------------
 plugins/Slicer/SlicerT.h     |  16 +++-
 plugins/Slicer/SlicerTUI.cpp |  92 +++++++++++++++-------
 plugins/Slicer/SlicerTUI.h   |  16 ++--
 plugins/Slicer/WaveForm.cpp  |  12 ++-
 plugins/Slicer/WaveForm.h    |   1 +
 6 files changed, 182 insertions(+), 103 deletions(-)

diff --git a/plugins/Slicer/SlicerT.cpp b/plugins/Slicer/SlicerT.cpp
index 8e8f0fb41e3..05c9b478a3a 100644
--- a/plugins/Slicer/SlicerT.cpp
+++ b/plugins/Slicer/SlicerT.cpp
@@ -22,39 +22,18 @@
  *
  */
 
-/*
-!! always work on the original sample for slicing and whatever,
-only use the sped up sample and slices in playNote(). This will keep things organized
-
-
-
-load file / slcies get updated
-find slices
-find bpm / if bpm gets updated
-update matchingSpeed sampleBuffer
-update matchingSlices vector
-
-the matchingSpeed buffer will always get initialzed freshly using a buffer, this seems to be the only way 
-give it the raw data
-*/
 
-// TODO: add gui values (fade out, window sizes?); fix timeshift lag (bpm change)
-// TODO: midi dragging, open file button
-// TODO: fix empty sample, small sample edge cases, general stability stuff
+// TODO: fadeIn
+// TODO: saving, loading
+// TODO: timeshift samples on notePlay and cache them
 
-// #include <QDomElement>
 #include "SlicerT.h"
 #include <stdio.h>
+#include <fftw3.h>
 
-#include "fft_helpers.h"
-#include <atomic>
-
-// #include "AudioEngine.h"
-// #include "base64.h"
 #include "Engine.h"
-#include "InstrumentTrack.h"
 #include "Song.h"
-#include <fftw3.h>
+#include "InstrumentTrack.h"
 
 #include "embed.h"
 #include "plugin_export.h"
@@ -89,33 +68,38 @@ Plugin::Descriptor PLUGIN_EXPORT slicert_plugin_descriptor =
 
 SlicerT::SlicerT(InstrumentTrack * _instrument_track) : 
 	Instrument( _instrument_track, &slicert_plugin_descriptor ),
+	noteThreshold(0.6f, 0.0f, 2.0f, 0.01f, this, tr( "Note threshold" ) ),
+	fadeOutFrames(2048.0f, 0.0f, 8192.0f, 4.0f, this, tr("FadeOut")),
+	originalBPM(1, 1, 999, this, tr("Original bpm")),
+
 	originalSample(),
-	timeShiftedSample(),
-	noteThreshold( 0.6f, 0.0f, 2.0f, 0.01f, this, tr( "Note Threshold" ) ),
-	originalBPM(1, 1, 999, this, tr("original sample bpm"))
+	timeShiftedSample()
+	
+	
+	
 {
 	// connect( &noteThreshold, SIGNAL( dataChanged() ), this, SLOT( updateSlices() ) );
 	// TODO: either button to timeshift, threading or generating samples on the fly
-	connect( &originalBPM, SIGNAL( dataChanged() ), this, SLOT( updateTimeShift() ) );
+	// connect( &originalBPM, SIGNAL( dataChanged() ), this, SLOT( updateTimeShift() ) );
 
 	printf("Correctly loaded SlicerT!\n");
 }
 
 void SlicerT::playNote( NotePlayHandle * _n, sampleFrame * _working_buffer ) {
+	if (originalSample.frames() < 2048) {
+		return;
+	}
+
 	const fpp_t frames = _n->framesLeftForCurrentPeriod();
 	const int playedFrames = _n->totalFramesPlayed();
 	const f_cnt_t offset = _n->noteOffset();
 	
-
-
 	int totalFrames = timeShiftedSample.frames();
 	int sliceStart = timeShiftedSample.startFrame();
 	int sliceEnd = timeShiftedSample.endFrame();
 	int sliceFrames = timeShiftedSample.endFrame() - timeShiftedSample.startFrame();
 	int noteFramesLeft = sliceFrames - playedFrames;
 
-	int fadeOutFrames = (float)sliceFrames/4;
-
 	// init NotePlayHandle data
 	if( !_n->m_pluginData )
 	{
@@ -137,8 +121,6 @@ void SlicerT::playNote( NotePlayHandle * _n, sampleFrame * _working_buffer ) {
 
 		timeShiftedSample.setAllPointFrames( sliceStart, sliceEnd, sliceStart, sliceEnd );
 
-		// printf("%i : %i -> %i\n", noteIndex, sliceStart, sliceEnd);
-		// printf("%i\n", _n->oldKey());
 
 	
 	}
@@ -157,10 +139,10 @@ void SlicerT::playNote( NotePlayHandle * _n, sampleFrame * _working_buffer ) {
 									frames + offset, _n );
 
 			// exponential fade out
-			if (noteFramesLeft < fadeOutFrames) {
+			if (noteFramesLeft < fadeOutFrames.value()) {
 				// printf("fade out started. frames: %i, framesLeft: %i\n", frames, noteFramesLeft);
 				for (int i = 0;i<frames;i++) {
-					float fadeValue = (float)(noteFramesLeft-i) / fadeOutFrames;
+					float fadeValue = (float)(noteFramesLeft-i) / fadeOutFrames.value();
 					// if the workingbuffer extends the sample
 					fadeValue = std::clamp(fadeValue, 0.0f, 1.0f);
 					fadeValue = pow(fadeValue, 2);
@@ -188,6 +170,9 @@ void SlicerT::playNote( NotePlayHandle * _n, sampleFrame * _working_buffer ) {
 
 
 void SlicerT::findSlices() {
+	if (originalSample.frames() < 2048) {
+		return;
+	}
 	int c = 0;
 	const int window = 1024;
 	int peakIndex = 0;
@@ -231,6 +216,9 @@ void SlicerT::findSlices() {
 // find the bpm of the sample by assuming its in 4/4 time signature ,
 // and lies in the 100 - 200 bpm range
 void SlicerT::findBPM() {
+	if (originalSample.frames() < 2048) {
+		return;
+	}
 	int bpmSnap = 1;
 
 	float sampleRate = originalSample.sampleRate();
@@ -255,10 +243,13 @@ void SlicerT::findBPM() {
 	bpm -= bpm % bpmSnap;
 
 	originalBPM.setValue(bpm);
- }
+}
 
 // create thimeshifted samplebuffer and timeshifted slicePoints
 void SlicerT::timeShiftSample() {
+	if (originalSample.frames() < 2048) {
+		return;
+	}
 	using std::vector;
 	printf("starting sample timeshifting\n");
 
@@ -269,17 +260,16 @@ void SlicerT::timeShiftSample() {
 	// target data TODO: fix this mess
 	bpm_t targetBPM = Engine::getSong()->getTempo();
 	float speedRatio = (float)originalBPM.value() / targetBPM ;
-	int samplesPerBeat = 60.0f / targetBPM * sampleRate;
 	int outFrames = speedRatio * originalFrames;
 
 	// snap to a beat, this should be in the UI
-	outFrames += (float)samplesPerBeat;
-	outFrames -= outFrames%samplesPerBeat;
+	// outFrames += (float)samplesPerBeat;
+	// outFrames -= outFrames%samplesPerBeat;
 
 	// nothing to do here
 	if (targetBPM == originalBPM.value()) {
 		timeShiftedSample = SampleBuffer(originalSample.data(), originalSample.frames());
-		printf("BPM match for sample, finished timeshift\n");
+		printf("BPM match for sample, finished timeshift. frames: %i\n", timeShiftedSample.frames());
 		return;
 	}
 
@@ -343,10 +333,10 @@ void SlicerT::phaseVocoder(std::vector<float> &dataIn, std::vector<float> &dataO
 	float lengthRatio = (float)outFrames / inFrames;
 
 	// values used
-	const int stepSize = windowSize / overSampling; 
-	const int outStepSize = stepSize * lengthRatio;
-	const int numWindows = inFrames / stepSize;
+	const int stepSize = (float)windowSize / overSampling; 
+	const int numWindows = (float)inFrames / stepSize;
 	const int windowLatency = (overSampling-1)*stepSize;
+	const float outStepSize = lengthRatio * (float)stepSize; // float, else inaccurate
 	const float freqPerBin = sampleRate/windowSize; 
 	// very important
 	const float expectedPhaseIn = 2.*M_PI*(float)stepSize/(float)windowSize;
@@ -354,6 +344,7 @@ void SlicerT::phaseVocoder(std::vector<float> &dataIn, std::vector<float> &dataO
 
 
 	printf("frames: %i , out frames: %i , ratio: %f\n", inFrames, outFrames, (float)outFrames / inFrames);
+	printf("stepSize: %i, outStepSize:%i, numWindows: %i", stepSize, outStepSize, numWindows);
 	printf("will drop %i\n", inFrames%(inFrames/numWindows));
 
 	// initialize buffers
@@ -466,21 +457,31 @@ void SlicerT::phaseVocoder(std::vector<float> &dataIn, std::vector<float> &dataO
 				printf("too long window size, breaking\n");
 				break;
 			}
-			if (outIndex < windowLatency) {
-				// calculate amount of windows overlapping
-				float windowsOverlapping =  outIndex / windowSize * overSampling + 1;
 
-				// since not all windows overlap, just take the average of the ones that do overlap
-				outBuffer[outIndex] += overSampling/windowsOverlapping*IFFTReconstruction[j]/(windowSize/2.0f*overSampling);
+			// calculate windows overlapping at index
+			float startWindowOverlap = ceil(outIndex / outStepSize + 0.00000001);
+			float endWindowOverlap = ceil((float)(-outIndex + outFrames) / outStepSize + 0.00000001);
+			float totalWindowOverlap = std::min(
+										std::min(startWindowOverlap, endWindowOverlap), 
+										(float)overSampling);
 
-				// no averaging, probably worse
-				// dataOut[outIndex] = overSampling*IFFTReconstruction[j]/(windowSize/2.0f*overSampling);
-			} else {
-				// this computes the weight of the window on the final output
-				float window = -0.5f*cos(2.*M_PI*(float)j/(float)windowSize)+0.5f;
 
-				outBuffer[outIndex] += 2.0f*window*IFFTReconstruction[j]/(windowSize/2.0f*overSampling);
-			}
+			// completly unsmooth, but ensures same magnitude across
+			outBuffer[outIndex] += (float)overSampling/totalWindowOverlap*IFFTReconstruction[j]/(windowSize/2.0f*overSampling);
+			// printf("%f	", outBuffer[outIndex]);
+			// if (outIndex < (float)outStepSize*overSampling) {
+			// 	printf("start: %f, end: %f, total:%f\n", startWindowOverlap, endWindowOverlap, totalWindowOverlap);
+			// 	// since not all windows overlap, just take the average of the ones that do overlap
+			// 	outBuffer[outIndex] += (float)overSampling/startWindowOverlap*IFFTReconstruction[j]/(windowSize/2.0f*overSampling);
+
+			// 	// no averaging, probably worse
+			// 	// outBuffer[outIndex] = overSampling*IFFTReconstruction[j]/(windowSize/2.0f*overSampling);
+			// } else {
+			// 	// this computes the weight of the window on the final output
+				// float window = -0.5f*cos(2.*M_PI*(float)j/(float)windowSize)+0.5f;
+
+				// outBuffer[outIndex] += 2.0f*window*IFFTReconstruction[j]/(windowSize/2.0f*overSampling);
+			// }
 
 		}
 
@@ -496,6 +497,8 @@ void SlicerT::phaseVocoder(std::vector<float> &dataIn, std::vector<float> &dataO
 		max = std::max(max, abs(outBuffer[i]));
 	}
 
+	printf("max: %f\n", max);
+
 	for (int i = 0;i<outFrames;i++) {
 		outBuffer[i] = outBuffer[i] / max;
 	}
@@ -507,13 +510,40 @@ void SlicerT::phaseVocoder(std::vector<float> &dataIn, std::vector<float> &dataO
 
 }
 
+void SlicerT::writeToMidi(std::vector<Note> * outClip) {
+	int ticksPerBar = DefaultTicksPerBar;
+	float sampleRate = timeShiftedSample.sampleRate();
+
+	float bpm = Engine::getSong()->getTempo();
+	float samplesPerBeat = 60.0f / bpm * sampleRate;
+	float beats = (float)timeShiftedSample.frames() / samplesPerBeat;
+
+	float barsInSample = beats / Engine::getSong()->getTimeSigModel().getDenominator();
+	float tickMult = ticksPerBar * barsInSample;
+
+	printf("beats: %f, bars: %f, tickMult: %f\n", beats, barsInSample, tickMult);
+
+	for (int i = 0;i<slicePoints.size()-1;i++) {
+		float sliceStart = (float)slicePoints[i] / originalSample.frames() * tickMult;
+		float sliceEnd = (float)slicePoints[i + 1] / originalSample.frames() * tickMult;
 
+		Note sliceNote = Note();
+		sliceNote.setKey(i + 69);
+		sliceNote.setPos(sliceStart);
+		sliceNote.setLength(sliceEnd - sliceStart);
+		outClip->push_back(sliceNote);
+	}
+}
 
 void SlicerT::updateFile(QString file) {
 	printf("updated audio file\n");
 	originalSample.setAudioFile(file);
+	if (originalSample.frames() < 2048) {
+		return;
+	}
 	findSlices();
-	findBPM(); // this also updates timeshift because bpm change
+	findBPM(); 
+	timeShiftSample();
 	
 }
 
diff --git a/plugins/Slicer/SlicerT.h b/plugins/Slicer/SlicerT.h
index 549464e21ab..004e4756f1e 100644
--- a/plugins/Slicer/SlicerT.h
+++ b/plugins/Slicer/SlicerT.h
@@ -27,12 +27,17 @@
 #ifndef SLICERT_H
 #define SLICERT_H
 
-#include "AutomatableModel.h"
+#include "SlicerTUI.h"
+
+#include <fftw3.h>
+
+#include "Note.h"
 #include "Instrument.h"
 #include "InstrumentView.h"
+#include "AutomatableModel.h"
 #include "SampleBuffer.h"
-#include "SlicerTUI.h"
-#include <fftw3.h>
+
+
 // #include "Graph.h"
 // #include "MemoryManager.h"
 
@@ -58,6 +63,8 @@ class SlicerT : public Instrument{
 
 		gui::PluginView * instantiateView( QWidget * _parent ) override;
 
+		void writeToMidi(std::vector<Note> * outClip);
+
 	public slots:
 		void updateFile(QString file);
 		void updateTimeShift();
@@ -70,7 +77,8 @@ class SlicerT : public Instrument{
 	
 
 		FloatModel noteThreshold;
-		IntModel originalBPM = 140;
+		FloatModel fadeOutFrames;
+		IntModel originalBPM;
 
 		SampleBuffer originalSample;
 		SampleBuffer timeShiftedSample;
diff --git a/plugins/Slicer/SlicerTUI.cpp b/plugins/Slicer/SlicerTUI.cpp
index 40f123bc959..d143123b10b 100644
--- a/plugins/Slicer/SlicerTUI.cpp
+++ b/plugins/Slicer/SlicerTUI.cpp
@@ -1,28 +1,19 @@
 #include "SlicerTUI.h"
 #include "SlicerT.h"
-// #include <QDomElement>
-#include <stdio.h>
 
+#include <stdio.h>
+#include <QFileInfo>
+#include <QDropEvent>
 
 #include "StringPairDrag.h"
 #include "Clipboard.h"
 #include "Track.h"
 #include "DataFile.h"
-// #include "AudioEngine.h"
-// #include "base64.h"
-// #include "Engine.h"
-// #include "Graph.h"
-// #include "InstrumentTrack.h"
-// #include "Knob.h"
-// #include "LedCheckBox.h"
-// #include "NotePlayHandle.h"
-// #include "PixmapButton.h"
-// #include "Song.h"
-// #include "interpolation.h"
-
-// #include <QPainter>
-#include <QFileInfo>
-#include <QDropEvent>
+
+#include "Engine.h"
+#include "Song.h"
+#include "InstrumentTrack.h"
+
 #include "embed.h"
 
 namespace lmms
@@ -34,30 +25,73 @@ namespace gui
 SlicerTUI::SlicerTUI( SlicerT * _instrument,
 					QWidget * _parent ) :
 	InstrumentViewFixedSize( _instrument, _parent ),
-	noteThresholdKnob(KnobType::Bright26, this),
 	slicerTParent(_instrument),
-	wf(245, 125, _instrument, this),
+	noteThresholdKnob(KnobType::Dark28, this),
+	fadeOutKnob(KnobType::Dark28, this),
 	bpmBox(3, "21pink", this),
-	resetButton(embed::getIconPixmap("reload"), QString(), this)
-	
+	resetButton(embed::getIconPixmap("reload"), QString(), this),
+	timeShiftButton(embed::getIconPixmap("max_length"), QString(), this),
+	midiExportButton(embed::getIconPixmap("midi_tab"), QString(), this),
+	wf(245, 125, _instrument, this)
 {
 	setAcceptDrops( true );
-	setFocusProxy(&wf);
 
 	wf.move(2, 5); 
 
-	resetButton.move(100, 150);
-	connect(&resetButton, SIGNAL( clicked() ), slicerTParent, SLOT( updateSlices() ));
-	connect(&resetButton, SIGNAL( clicked() ), &wf, SLOT( updateUI() ));
-
-	bpmBox.move(30, 150);
-	bpmBox.setToolTip(tr("original sample BPM"));
+	bpmBox.move(2, 150);
+	bpmBox.setToolTip(tr("Original sample BPM"));
 	bpmBox.setLabel(tr("BPM"));
 	bpmBox.setModel(&slicerTParent->originalBPM);
 
-	noteThresholdKnob.move(30, 200);
+	timeShiftButton.move(70, 150);
+	timeShiftButton.setToolTip(tr("Timeshift sample"));
+	connect(&timeShiftButton, SIGNAL( clicked() ), slicerTParent, SLOT( updateTimeShift() ));
+
+	fadeOutKnob.move(200, 150);
+	fadeOutKnob.setToolTip(tr("FadeOut for notes"));
+	fadeOutKnob.setLabel(tr("FadeOut"));
+	fadeOutKnob.setModel(&slicerTParent->fadeOutFrames);
+
+	midiExportButton.move(150, 150);
+	midiExportButton.setToolTip(tr("Copy midi pattern to clipboard"));
+	connect(&midiExportButton, SIGNAL( clicked() ), this, SLOT( exportMidi() ));
+
+	noteThresholdKnob.move(7, 200);
+	noteThresholdKnob.setToolTip(tr("Threshold used for slicing"));
+	noteThresholdKnob.setLabel(tr("Threshold"));
 	noteThresholdKnob.setModel(&slicerTParent->noteThreshold);
 
+	resetButton.move(70, 200);
+	resetButton.setToolTip(tr("Reset Slices"));
+	connect(&resetButton, SIGNAL( clicked() ), slicerTParent, SLOT( updateSlices() ));
+	connect(&resetButton, SIGNAL( clicked() ), &wf, SLOT( updateUI() ));
+
+
+
+}
+
+// copied from piano roll
+void SlicerTUI::exportMidi() {
+	using namespace Clipboard;
+
+	DataFile dataFile( DataFile::Type::ClipboardData );
+	QDomElement note_list = dataFile.createElement( "note-list" );
+	dataFile.content().appendChild( note_list );
+
+	std::vector<Note> notes;
+	slicerTParent->writeToMidi(&notes);
+
+
+	TimePos start_pos( notes.front().pos().getBar(), 0 );
+	for( Note note : notes )
+	{
+		Note clip_note( note );
+		clip_note.setPos( clip_note.pos( start_pos ) );
+		clip_note.saveState( dataFile, note_list );
+	}
+
+	copyString( dataFile.toString(), MimeType::Default );
+
 }
 
 void SlicerTUI::mousePressEvent( QMouseEvent * _me ) {
diff --git a/plugins/Slicer/SlicerTUI.h b/plugins/Slicer/SlicerTUI.h
index 0f28c05a2e9..b123223fb4f 100644
--- a/plugins/Slicer/SlicerTUI.h
+++ b/plugins/Slicer/SlicerTUI.h
@@ -1,14 +1,12 @@
-#include <stdio.h>
 #include "WaveForm.h"
-// #include "AutomatableModel.h"
+
+#include <stdio.h>
+#include <QPushButton>
+
 #include "Instrument.h"
 #include "InstrumentView.h"
 #include "Knob.h"
 #include "LcdSpinBox.h"
-#include <QPushButton>
-// #include "Graph.h"
-// #include "MemoryManager.h"
-
 
 
 #ifndef SLICERT_UI_H
@@ -36,7 +34,8 @@ class SlicerTUI : public InstrumentViewFixedSize
 					QWidget * _parent );
 	~SlicerTUI() override = default;
 
-// protected slots:
+protected slots:
+	void exportMidi();
 	//void sampleSizeChanged( float _new_sample_length );
 
 protected:
@@ -49,9 +48,12 @@ class SlicerTUI : public InstrumentViewFixedSize
 	SlicerT * slicerTParent;
 
 	Knob noteThresholdKnob;
+	Knob fadeOutKnob;
 	LcdSpinBox bpmBox;
 
 	QPushButton resetButton;
+	QPushButton timeShiftButton;
+	QPushButton midiExportButton;
 
 	WaveForm wf;
 
diff --git a/plugins/Slicer/WaveForm.cpp b/plugins/Slicer/WaveForm.cpp
index f2e33c0a5d3..9625172ab9a 100644
--- a/plugins/Slicer/WaveForm.cpp
+++ b/plugins/Slicer/WaveForm.cpp
@@ -1,8 +1,7 @@
-#include <stdio.h>
-
 #include "WaveForm.h"
 #include "SlicerT.h"
 
+#include <stdio.h>
 
 namespace lmms
 {
@@ -23,7 +22,6 @@ namespace gui
             setFixedSize(width, height);
             setMouseTracking( true );
             setAcceptDrops( true );
-            setFocusPolicy(Qt::StrongFocus);
 
             sliceEditor.fill(waveformBgColor);
             seeker.fill(waveformBgColor);
@@ -117,6 +115,12 @@ namespace gui
     void WaveForm::mousePressEvent( QMouseEvent * _me ) {
         float normalizedClick = (float)_me->x() / width;
         
+        if (_me->button() == Qt::MouseButton::MiddleButton) {
+            seekerStart = 0;
+            seekerEnd = 1;
+            return;
+        }
+
         if (_me->y() < height*seekerRatio) {
             if (abs(normalizedClick - seekerStart) < 0.03) {
                 currentlyDragging = draggingTypes::seekerStart;
@@ -154,7 +158,7 @@ namespace gui
                 slicePoints.erase(slicePoints.begin() + sliceSelected);
                 sliceSelected = -1;
             }
-        }
+        }  
 
     }
 
diff --git a/plugins/Slicer/WaveForm.h b/plugins/Slicer/WaveForm.h
index 844d6c84223..3806d6b2b33 100644
--- a/plugins/Slicer/WaveForm.h
+++ b/plugins/Slicer/WaveForm.h
@@ -3,6 +3,7 @@
 #include <QInputDialog>
 #include <QMouseEvent>
 #include <QPainter>
+
 #include "SampleBuffer.h"
 
 #ifndef WAVEFORM_H

From 76782c1bf3c8d32af515437ecdf7a95d851f10ee Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Fri, 8 Sep 2023 21:19:02 +0200
Subject: [PATCH 11/99] Everything basic works fully

---
 plugins/Slicer/SlicerT.cpp   | 89 ++++++++++++++++++++++++++++--------
 plugins/Slicer/SlicerTUI.cpp |  6 +--
 plugins/Slicer/WaveForm.cpp  | 20 +++++---
 plugins/Slicer/WaveForm.h    |  5 +-
 4 files changed, 88 insertions(+), 32 deletions(-)

diff --git a/plugins/Slicer/SlicerT.cpp b/plugins/Slicer/SlicerT.cpp
index 05c9b478a3a..6b74511e031 100644
--- a/plugins/Slicer/SlicerT.cpp
+++ b/plugins/Slicer/SlicerT.cpp
@@ -24,17 +24,19 @@
 
 
 // TODO: fadeIn
-// TODO: saving, loading
+// TODO: fix lag multiple notes
 // TODO: timeshift samples on notePlay and cache them
 
 #include "SlicerT.h"
 #include <stdio.h>
 #include <fftw3.h>
+#include <QDomElement>
 
 #include "Engine.h"
 #include "Song.h"
 #include "InstrumentTrack.h"
 
+#include "PathUtil.h"
 #include "embed.h"
 #include "plugin_export.h"
 
@@ -74,14 +76,7 @@ SlicerT::SlicerT(InstrumentTrack * _instrument_track) :
 
 	originalSample(),
 	timeShiftedSample()
-	
-	
-	
 {
-	// connect( &noteThreshold, SIGNAL( dataChanged() ), this, SLOT( updateSlices() ) );
-	// TODO: either button to timeshift, threading or generating samples on the fly
-	// connect( &originalBPM, SIGNAL( dataChanged() ), this, SLOT( updateTimeShift() ) );
-
 	printf("Correctly loaded SlicerT!\n");
 }
 
@@ -133,12 +128,7 @@ void SlicerT::playNote( NotePlayHandle * _n, sampleFrame * _working_buffer ) {
 					frames, 440,
 					static_cast<SampleBuffer::LoopMode>( 0 ) ) )
 		{
-
-			applyRelease( _working_buffer, _n );
-			instrumentTrack()->processAudioBuffer( _working_buffer,
-									frames + offset, _n );
-
-			// exponential fade out
+			// exponential fade out, applyRelease kinda sucks
 			if (noteFramesLeft < fadeOutFrames.value()) {
 				// printf("fade out started. frames: %i, framesLeft: %i\n", frames, noteFramesLeft);
 				for (int i = 0;i<frames;i++) {
@@ -152,16 +142,20 @@ void SlicerT::playNote( NotePlayHandle * _n, sampleFrame * _working_buffer ) {
 				}
 			}
 
+			instrumentTrack()->processAudioBuffer( _working_buffer,
+									frames + offset, _n );
+
+
 			float absoluteCurrentNote = (float)(sliceStart + playedFrames) / totalFrames;
 			float absoluteStartNote = (float)sliceStart / totalFrames;
 			float abslouteEndNote = (float)sliceEnd / totalFrames;
-			// emit isPlaying(absoluteCurrentNote, absoluteStartNote, abslouteEndNote);
+			emit isPlaying(absoluteCurrentNote, absoluteStartNote, abslouteEndNote);
 
 		} else {
-			// emit isPlaying(0, 0, 0);			
+			emit isPlaying(0, 0, 0);			
 		}
 	} else {
-		// emit isPlaying(0, 0, 0);
+		emit isPlaying(0, 0, 0);
 	}
 
 	
@@ -243,6 +237,7 @@ void SlicerT::findBPM() {
 	bpm -= bpm % bpmSnap;
 
 	originalBPM.setValue(bpm);
+	originalBPM.setInitValue(bpm);
 }
 
 // create thimeshifted samplebuffer and timeshifted slicePoints
@@ -511,6 +506,9 @@ void SlicerT::phaseVocoder(std::vector<float> &dataIn, std::vector<float> &dataO
 }
 
 void SlicerT::writeToMidi(std::vector<Note> * outClip) {
+	if (originalSample.frames() < 2048) {
+		return;
+	}
 	int ticksPerBar = DefaultTicksPerBar;
 	float sampleRate = timeShiftedSample.sampleRate();
 
@@ -545,6 +543,7 @@ void SlicerT::updateFile(QString file) {
 	findBPM(); 
 	timeShiftSample();
 	
+	emit dataChanged();
 }
 
 void SlicerT::updateSlices() {
@@ -556,8 +555,60 @@ void SlicerT::updateTimeShift() {
 }
 
 
-void SlicerT::saveSettings(QDomDocument & _doc, QDomElement & _parent) {}
-void SlicerT::loadSettings( const QDomElement & _this ) {}
+void SlicerT::saveSettings(QDomDocument & doc, QDomElement & elem) {
+	elem.setAttribute("src", originalSample.audioFile());
+	if (originalSample.audioFile().isEmpty())
+	{
+		QString s;
+		elem.setAttribute("sampledata", originalSample.toBase64(s));
+	}
+
+	elem.setAttribute("totalSlices", (int)slicePoints.size());
+
+	for (int i = 0;i<slicePoints.size();i++) {
+		elem.setAttribute(tr("slice_%1").arg(i), slicePoints[i]);
+	}
+
+	fadeOutFrames.saveSettings(doc, elem, "fadeOut");
+	noteThreshold.saveSettings(doc, elem, "threshold");
+	originalBPM.saveSettings(doc, elem, "origBPM");
+
+}
+void SlicerT::loadSettings( const QDomElement & elem ) {
+	if (!elem.attribute("src").isEmpty())
+	{
+		originalSample.setAudioFile(elem.attribute("src"));
+
+		QString absolutePath = PathUtil::toAbsolute(originalSample.audioFile());
+		if (!QFileInfo(absolutePath).exists())
+		{
+			QString message = tr("Sample not found: %1").arg(originalSample.audioFile());
+			Engine::getSong()->collectError(message);
+		}
+	}
+	else if (!elem.attribute("sampledata").isEmpty())
+	{
+		originalSample.loadFromBase64(elem.attribute("srcdata"));
+	}
+
+	if (!elem.attribute("totalSlices").isEmpty()) {
+		int totalSlices = elem.attribute("totalSlices").toInt();
+		slicePoints = {};
+		for (int i = 0;i<totalSlices;i++) {
+			
+			slicePoints.push_back(elem.attribute(tr("slice_%1").arg(i)).toInt());
+		}
+	}
+
+	fadeOutFrames.loadSettings(elem, "fadeOut");
+	noteThreshold.loadSettings(elem, "threshold");
+	originalBPM.loadSettings(elem, "origBPM");
+
+	timeShiftSample();
+
+	emit dataChanged();
+
+}
 
 QString SlicerT::nodeName() const
 {
diff --git a/plugins/Slicer/SlicerTUI.cpp b/plugins/Slicer/SlicerTUI.cpp
index d143123b10b..823cb162028 100644
--- a/plugins/Slicer/SlicerTUI.cpp
+++ b/plugins/Slicer/SlicerTUI.cpp
@@ -64,7 +64,6 @@ SlicerTUI::SlicerTUI( SlicerT * _instrument,
 	resetButton.move(70, 200);
 	resetButton.setToolTip(tr("Reset Slices"));
 	connect(&resetButton, SIGNAL( clicked() ), slicerTParent, SLOT( updateSlices() ));
-	connect(&resetButton, SIGNAL( clicked() ), &wf, SLOT( updateUI() ));
 
 
 
@@ -80,7 +79,9 @@ void SlicerTUI::exportMidi() {
 
 	std::vector<Note> notes;
 	slicerTParent->writeToMidi(&notes);
-
+	if (notes.size() == 0) {
+		return;
+	}
 
 	TimePos start_pos( notes.front().pos().getBar(), 0 );
 	for( Note note : notes )
@@ -140,7 +141,6 @@ void SlicerTUI::dropEvent( QDropEvent * _de ) {
 	{
 		printf("type: samplefile\n");
 		slicerTParent->updateFile( value );
-		wf.updateFile( value );
 		// castModel<AudioFileProcessor>()->setAudioFile( value );
 		// _de->accept();
 		// set wf wave file
diff --git a/plugins/Slicer/WaveForm.cpp b/plugins/Slicer/WaveForm.cpp
index 9625172ab9a..84a3d249f3f 100644
--- a/plugins/Slicer/WaveForm.cpp
+++ b/plugins/Slicer/WaveForm.cpp
@@ -13,9 +13,11 @@ namespace gui
         QWidget(_parent),
         seeker(QPixmap(_w, _h*seekerRatio)),
         sliceEditor(QPixmap(_w, _h*(1 - seekerRatio) - margin)),
-        currentSample(),
+        currentSample(_instrument->originalSample.data(), _instrument->originalSample.frames()),
         slicePoints(_instrument->slicePoints)
         {
+            
+
             width = _w;
             height = _h;
             slicerTParent = _instrument;
@@ -30,6 +32,10 @@ namespace gui
                     SIGNAL(isPlaying(float, float, float)), 
                     this, 
                     SLOT(isPlaying(float, float, float)));
+
+            connect(slicerTParent, SIGNAL(dataChanged()), this, SLOT(updateData()));
+
+            updateUI();
         }
 
     void WaveForm::drawEditor() {
@@ -100,16 +106,19 @@ namespace gui
         update();
     }
 
-    void WaveForm::updateFile(QString file) {
-        currentSample.setAudioFile(file);
+    void WaveForm::updateData() {
+        printf("main data changed, updating sample and UI\n");
+        currentSample = SampleBuffer(slicerTParent->originalSample.data(), slicerTParent->originalSample.frames());
         updateUI();
     }
 
+
     void WaveForm::isPlaying(float current, float start, float end) {
         noteCurrent = current;
         noteStart = start;
         noteEnd = end;
-        updateUI();
+        drawSeeker();
+        update();
     }
 
     void WaveForm::mousePressEvent( QMouseEvent * _me ) {
@@ -247,8 +256,5 @@ namespace gui
         p.drawPixmap(0, height*0.3f + margin, sliceEditor);
         p.drawPixmap(0, 0, seeker);
     }
-
-
-
 }
 }
\ No newline at end of file
diff --git a/plugins/Slicer/WaveForm.h b/plugins/Slicer/WaveForm.h
index 3806d6b2b33..a63110c5e8a 100644
--- a/plugins/Slicer/WaveForm.h
+++ b/plugins/Slicer/WaveForm.h
@@ -70,15 +70,14 @@ class WaveForm : public QWidget {
 
         void drawEditor();
         void drawSeeker();
-        
+        void updateUI();
 
     public slots:
-        void updateUI();
+        void updateData();
         void isPlaying(float current, float start, float end);
 
     public:
         WaveForm(int _w, int _h, SlicerT * _instrument, QWidget * _parent);
-        void updateFile(QString file);
 
     private:
         SlicerT * slicerTParent;

From 126672b7837c662a18770d3e3f9f68d666bb33eb Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Fri, 8 Sep 2023 22:57:24 +0200
Subject: [PATCH 12/99] cleanup and code guidelines

---
 plugins/CMakeLists.txt         |   2 +-
 plugins/SlicerT/CMakeLists.txt |   5 +
 plugins/SlicerT/SlicerT.cpp    | 555 +++++++++++++++++++++++++++++++++
 plugins/SlicerT/SlicerT.h      |  85 +++++
 plugins/SlicerT/SlicerTUI.cpp  | 154 +++++++++
 plugins/SlicerT/SlicerTUI.h    |  61 ++++
 plugins/SlicerT/WaveForm.cpp   | 247 +++++++++++++++
 plugins/SlicerT/WaveForm.h     |  88 ++++++
 plugins/SlicerT/logo.png       | Bin 0 -> 39244 bytes
 9 files changed, 1196 insertions(+), 1 deletion(-)
 create mode 100644 plugins/SlicerT/CMakeLists.txt
 create mode 100644 plugins/SlicerT/SlicerT.cpp
 create mode 100644 plugins/SlicerT/SlicerT.h
 create mode 100644 plugins/SlicerT/SlicerTUI.cpp
 create mode 100644 plugins/SlicerT/SlicerTUI.h
 create mode 100644 plugins/SlicerT/WaveForm.cpp
 create mode 100644 plugins/SlicerT/WaveForm.h
 create mode 100644 plugins/SlicerT/logo.png

diff --git a/plugins/CMakeLists.txt b/plugins/CMakeLists.txt
index 9d083dfe1ab..aaa92089a70 100644
--- a/plugins/CMakeLists.txt
+++ b/plugins/CMakeLists.txt
@@ -18,4 +18,4 @@ INCLUDE_DIRECTORIES(
 FOREACH(PLUGIN ${PLUGIN_LIST})
 	ADD_SUBDIRECTORY(${PLUGIN})
 ENDFOREACH()
-ADD_SUBDIRECTORY("Slicer")
+ADD_SUBDIRECTORY("SlicerT")
diff --git a/plugins/SlicerT/CMakeLists.txt b/plugins/SlicerT/CMakeLists.txt
new file mode 100644
index 00000000000..b93021e98f9
--- /dev/null
+++ b/plugins/SlicerT/CMakeLists.txt
@@ -0,0 +1,5 @@
+INCLUDE(BuildPlugin)
+
+BUILD_PLUGIN(slicert SlicerT.cpp SlicerT.h SlicerTUI.cpp SlicerTUI.h WaveForm.cpp WaveForm.h MOCFILES SlicerT.h SlicerTUI.h WaveForm.h EMBEDDED_RESOURCES "${CMAKE_CURRENT_SOURCE_DIR}/*.png")
+
+
diff --git a/plugins/SlicerT/SlicerT.cpp b/plugins/SlicerT/SlicerT.cpp
new file mode 100644
index 00000000000..1a510bc034c
--- /dev/null
+++ b/plugins/SlicerT/SlicerT.cpp
@@ -0,0 +1,555 @@
+/*
+ * SlicerT.cpp - simple slicer plugin
+ *
+ * Copyright (c) 2006-2008 Andreas Brandmaier <andy/at/brandmaier/dot/de>
+ * 
+ * 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 "SlicerT.h"
+#include <stdio.h>
+#include <fftw3.h>
+#include <QDomElement>
+
+#include "Engine.h"
+#include "Song.h"
+#include "InstrumentTrack.h"
+
+#include "PathUtil.h"
+#include "embed.h"
+#include "plugin_export.h"
+
+
+namespace lmms
+{
+
+extern "C"
+{
+Plugin::Descriptor PLUGIN_EXPORT slicert_plugin_descriptor =
+{
+	LMMS_STRINGIFY( PLUGINhandleAME ),
+	"SlicerT",
+	QT_TRANSLATE_NOOP( "PluginBrowser",
+				"Basic Slicer" ),
+	"Daniel Kauss Serna",
+	0x0100,
+	Plugin::Type::Instrument,
+	new PluginPixmapLoader( "logo" ),
+	nullptr,
+	nullptr,
+} ;
+} // end extern
+
+SlicerT::SlicerT(InstrumentTrack * instrumentTrack) : 
+	Instrument( instrumentTrack, &slicert_plugin_descriptor ),
+	m_noteThreshold(0.6f, 0.0f, 2.0f, 0.01f, this, tr( "Note threshold" ) ),
+	m_fadeOutFrames(0.0f, 0.0f, 8192.0f, 4.0f, this, tr("FadeOut")),
+	m_originalBPM(1, 1, 999, this, tr("Original bpm")),
+
+	m_originalSample(),
+	m_timeShiftedSample()
+{}
+
+
+void SlicerT::playNote( NotePlayHandle * handle, sampleFrame * workingBuffer ) {
+	if (m_originalSample.frames() < 2048) {
+		return;
+	}
+
+	const fpp_t frames = handle->framesLeftForCurrentPeriod();
+	const int playedFrames = handle->totalFramesPlayed();
+	const f_cnt_t offset = handle->noteOffset();
+	
+	int totalFrames = m_timeShiftedSample.frames();
+	int sliceStart = m_timeShiftedSample.startFrame();
+	int sliceEnd = m_timeShiftedSample.endFrame();
+	int sliceFrames = m_timeShiftedSample.endFrame() - m_timeShiftedSample.startFrame();
+	int noteFramesLeft = sliceFrames - playedFrames;
+
+	// init NotePlayHandle data
+	if( !handle->m_pluginData )
+	{
+		handle->m_pluginData = new SampleBuffer::handleState( false, SRC_LINEAR );
+
+		float speedRatio = (float)m_originalBPM.value() / Engine::getSong()->getTempo() ;
+		int noteIndex = handle->key() - 69;
+		int sliceStart, sliceEnd;
+		
+		// 0th element is no sound, so play full sample
+		if (noteIndex > m_slicePoints.size()-2 || noteIndex < 0) {
+			sliceStart = 0;
+			sliceEnd = m_timeShiftedSample.frames();
+		} else {
+			sliceStart = m_slicePoints[noteIndex] * speedRatio;
+			sliceEnd = m_slicePoints[noteIndex+1] * speedRatio;
+		}
+
+		m_timeShiftedSample.setAllPointFrames( sliceStart, sliceEnd, sliceStart, sliceEnd );
+	}
+
+	if( ! handle->isFinished() ) {
+		if( m_timeShiftedSample.play( workingBuffer + offset,
+					(SampleBuffer::handleState *)handle->m_pluginData,
+					frames, 440,
+					static_cast<SampleBuffer::LoopMode>( 0 ) ) )
+		{
+			// exponential fade out, applyRelease kinda sucks
+			if (noteFramesLeft < m_fadeOutFrames.value()) {
+				for (int i = 0;i<frames;i++) {
+					float fadeValue = (float)(noteFramesLeft-i) / m_fadeOutFrames.value();
+					// if the workingbuffer extends the sample
+					fadeValue = std::clamp(fadeValue, 0.0f, 1.0f);
+					fadeValue = pow(fadeValue, 2);
+
+					workingBuffer[i][0] *= fadeValue;
+					workingBuffer[i][1] *= fadeValue;
+				}
+			}
+
+			instrumentTrack()->processAudioBuffer( workingBuffer,
+									frames + offset, handle );
+
+
+			float absoluteCurrentNote = (float)(sliceStart + playedFrames) / totalFrames;
+			float absoluteStartNote = (float)sliceStart / totalFrames;
+			float abslouteEndNote = (float)sliceEnd / totalFrames;
+			emit isPlaying(absoluteCurrentNote, absoluteStartNote, abslouteEndNote);
+
+		} else {
+			emit isPlaying(0, 0, 0);			
+		}
+	} else {
+		emit isPlaying(0, 0, 0);
+	}
+}
+
+
+void SlicerT::findSlices() {
+	if (m_originalSample.frames() < 2048) {
+		return;
+	}
+	m_slicePoints = {};
+
+	const int window = 1024;
+	int minWindowsPassed = 0;
+	int peakIndex = 0;
+
+	float lastPeak = 0;
+	float currentPeak = 0;
+	
+	for (int i = 0; i<m_originalSample.frames();i+=1) {
+		float sampleValue = abs(m_originalSample.data()[i][0]) + abs(m_originalSample.data()[i][1]) / 2;
+
+		if (sampleValue > currentPeak) {
+			currentPeak = sampleValue;
+			peakIndex = i;
+		}
+		
+		if (i%window==0) {
+			if (abs(currentPeak / lastPeak) > 1+m_noteThreshold.value() && minWindowsPassed <= 0) {
+				m_slicePoints.push_back(std::max(0, peakIndex-window/2)); // slight offset
+				minWindowsPassed = 2; // wait at least one window for a new note
+			}
+			lastPeak = currentPeak;
+			currentPeak = 0;
+			minWindowsPassed--;
+		}
+	}
+	m_slicePoints.push_back(m_originalSample.frames());
+
+	emit dataChanged();
+}
+
+// find the bpm of the sample by assuming its in 4/4 time signature ,
+// and lies in the 100 - 200 bpm range
+void SlicerT::findBPM() {
+	if (m_originalSample.frames() < 2048) {
+		return;
+	}
+	int bpmSnap = 1;
+
+	float sampleRate = m_originalSample.sampleRate();
+	float totalFrames = m_originalSample.frames();
+	float sampleLength = totalFrames / sampleRate;
+
+	// this assumes the sample has a time signature of x/4
+	float bpmEstimate = 240.0f / sampleLength;
+
+	// deal with samlpes that are not 1 bar long
+	while (bpmEstimate < 100) {
+		bpmEstimate *= 2;
+	}
+
+	while (bpmEstimate > 200) {
+		bpmEstimate /= 2;
+	}
+
+	// snap bpm
+	int bpm = bpmEstimate;
+	bpm += (float)bpmSnap / 2;
+	bpm -= bpm % bpmSnap;
+
+	m_originalBPM.setValue(bpm);
+	m_originalBPM.setInitValue(bpm);
+}
+
+// create timeshifted samplebuffer and timeshifted m_slicePoints
+void SlicerT::timeShiftSample() {
+	if (m_originalSample.frames() < 2048) {
+		return;
+	}
+	using std::vector;
+
+	// original sample data
+	float sampleRate = m_originalSample.sampleRate();
+	int originalFrames = m_originalSample.frames();
+
+	// target data TODO: fix this mess
+	bpm_t targetBPM = Engine::getSong()->getTempo();
+	float speedRatio = (float)m_originalBPM.value() / targetBPM ;
+	int outFrames = speedRatio * originalFrames;
+
+	// nothing to do here
+	if (targetBPM == m_originalBPM.value()) {
+		m_timeShiftedSample = SampleBuffer(m_originalSample.data(), m_originalSample.frames());
+		return;
+	}
+
+	// buffers
+	vector<float> rawDataL(originalFrames, 0);
+	vector<float> rawDataR(originalFrames, 0);
+	vector<float> outDataL(outFrames, 0);
+	vector<float> outDataR(outFrames, 0);
+
+	vector<sampleFrame> bufferData(outFrames, sampleFrame());
+
+	// copy channels for processing
+	for (int i = 0;i<originalFrames;i++) {
+		rawDataL[i] = (float)m_originalSample.data()[i][0];
+		rawDataR[i] = (float)m_originalSample.data()[i][1];
+	}
+	// process channels
+	phaseVocoder(rawDataL, outDataL, sampleRate, 1);
+	phaseVocoder(rawDataR, outDataR, sampleRate, 1);
+
+	// write processed channels 
+	for (int i = 0;i<outFrames;i++) {
+		bufferData.data()[i][0] = outDataL[i];
+		bufferData.data()[i][1] = outDataR[i];
+	}
+
+	// new sample
+	m_timeShiftedSample = SampleBuffer(bufferData.data(), bufferData.size());
+}
+
+// basic phase vocoder implementation that time shifts without pitch change
+// resources:
+// http://blogs.zynaptiq.com/bernsee/pitch-shifting-using-the-ft/
+// https://sethares.engr.wisc.edu/vocoders/phasevocoder.html
+// https://dsp.stackexchange.com/questions/40101/audio-time-stretching-without-pitch-shifting/40367#40367
+// https://www.guitarpitchshifter.com/
+void SlicerT::phaseVocoder(std::vector<float> &dataIn, std::vector<float> &dataOut, float sampleRate, float pitchScale) {
+	using std::vector;
+	// processing parameters, lower is faster
+	// lower windows size seems to work better for time scaling,
+	// this is because the step site is scaled, but not the window size
+	// this causes slight timing differences between windows
+	// sadly, lower windowsize also reduces audio quality in general
+	// TODO: find solution
+	// oversampling is better if higher always (probably)
+	const int windowSize = 512;
+	const int overSampling = 32;
+	
+	// audio data
+	int inFrames = dataIn.size();
+	int outFrames = dataOut.size();
+
+	float lengthRatio = (float)outFrames / inFrames;
+
+	// values used
+	const int stepSize = (float)windowSize / overSampling; 
+	const int numWindows = (float)inFrames / stepSize;
+	const float outStepSize = lengthRatio * (float)stepSize; // float, else inaccurate
+	const float freqPerBin = sampleRate/windowSize; 
+	// very important
+	const float expectedPhaseIn = 2.*M_PI*(float)stepSize/(float)windowSize;
+	const float expectedPhaseOut = 2.*M_PI*(float)outStepSize/(float)windowSize;
+
+	// initialize buffers
+	fftwf_complex FFTSpectrum[windowSize];
+	vector<float> FFTInput(windowSize, 0);
+	vector<float> IFFTReconstruction(windowSize, 0);
+	vector<float> allMagnitudes(windowSize, 0);
+	vector<float> allFrequencies(windowSize, 0);
+	vector<float> processedFreq(windowSize, 0);
+	vector<float> processedMagn(windowSize, 0);
+	vector<float> lastPhase(windowSize, 0);
+	vector<float> sumPhase(windowSize, 0);
+
+	vector<float> outBuffer(outFrames, 0);
+
+	// declare vars
+	float real, imag, phase, magnitude, freq, deltaPhase = 0;
+	int windowIndex = 0;
+
+	// fft plans
+	fftwf_plan fftPlan;
+	fftPlan = fftwf_plan_dft_r2c_1d(windowSize, FFTInput.data(), FFTSpectrum, FFTW_MEASURE);
+	fftwf_plan ifftPlan;
+	ifftPlan = fftwf_plan_dft_c2r_1d(windowSize, FFTSpectrum, IFFTReconstruction.data(), FFTW_MEASURE);
+
+	// remove oversampling, because the actual window is overSampling* bigger than stepsize
+	for (int i = 0;i < numWindows-overSampling;i++) {
+		windowIndex = i * stepSize;
+
+		// FFT
+		memcpy(FFTInput.data(), dataIn.data() + windowIndex, windowSize*sizeof(float));
+		fftwf_execute(fftPlan);
+
+		// analysis step
+		for (int j = 0; j < windowSize; j++) {
+			
+			real = FFTSpectrum[j][0];
+			imag = FFTSpectrum[j][1];
+
+			magnitude = 2.*sqrt(real*real + imag*imag);
+			phase = atan2(imag,real); 
+
+			freq = phase - lastPhase[j]; // subtract prev pahse to get phase diference
+			lastPhase[j] = phase;
+
+			freq -= (float)j*expectedPhaseIn; // subtract expected phase
+
+			// some black magic to get into +/- PI interval, revise later pls
+			long qpd = freq/M_PI;
+			if (qpd >= 0) qpd += qpd&1;
+			else qpd -= qpd&1;
+			freq -= M_PI*(float)qpd;
+			
+			freq = (float)overSampling*freq/(2.*M_PI); // idk
+
+			freq = (float)j*freqPerBin + freq*freqPerBin; // "compute the k-th partials' true frequency" ok i guess
+
+			allMagnitudes[j] = magnitude;
+			allFrequencies[j] = freq;
+
+		}
+		
+		// pitch shifting
+		// takes all the values that are below the nyquist frequency (representable with our samplerate)
+		// nyquist frequency = samplerate / 2
+		// and moves them to a different bin
+		// improve for larger pitch shift
+		// memset(processedFreq.data(), 0, processedFreq.size()*sizeof(float));
+		// memset(processedMagn.data(), 0, processedFreq.size()*sizeof(float));
+		// for (int j = 0; j < windowSize/2; j++) {
+		// 	int index = (float)j;// * m_noteThreshold.value();
+		// 	if (index <= windowSize/2) {
+		// 		processedMagn[index] += allMagnitudes[j];
+		// 		processedFreq[index] = allFrequencies[j];// * m_noteThreshold.value();
+		// 	}
+		// }
+
+		// synthesis, all the operations are the reverse of the analysis
+		for (int j = 0; j < windowSize; j++) {
+			magnitude = allMagnitudes[j];
+			freq = allFrequencies[j];
+
+			deltaPhase = freq - (float)j*freqPerBin;
+
+			deltaPhase /= freqPerBin;
+
+			deltaPhase = 2.*M_PI*deltaPhase/overSampling;;
+
+			deltaPhase += (float)j*expectedPhaseOut;
+
+			sumPhase[j] += deltaPhase;
+			deltaPhase = sumPhase[j]; // this is the bin phase
+
+			FFTSpectrum[j][0] = magnitude*cos(deltaPhase);
+			FFTSpectrum[j][1] = magnitude*sin(deltaPhase);
+		}
+
+		// inverse fft
+		fftwf_execute(ifftPlan);
+
+		// windowing
+		for (int j = 0; j < windowSize; j++) {
+
+			float outIndex = i * outStepSize + j;
+			if (outIndex > outFrames) {
+				break;
+			}
+
+			// calculate windows overlapping at index
+			float startWindowOverlap = ceil(outIndex / outStepSize + 0.00000001f);
+			float endWindowOverlap = ceil((float)(-outIndex + outFrames) / outStepSize + 0.00000001f);
+			float totalWindowOverlap = std::min(
+										std::min(startWindowOverlap, endWindowOverlap), 
+										(float)overSampling);
+
+			// discrete windowing
+			outBuffer[outIndex] += (float)overSampling/totalWindowOverlap*IFFTReconstruction[j]/(windowSize/2.0f*overSampling);
+
+			// continuos windowing
+			// float window = -0.5f*cos(2.*M_PI*(float)j/(float)windowSize)+0.5f;
+			// outBuffer[outIndex] += 2.0f*window*IFFTReconstruction[j]/(windowSize/2.0f*overSampling);
+		}
+	}
+
+	fftwf_destroy_plan(fftPlan);
+	fftwf_destroy_plan(ifftPlan);
+
+	// normalize 	
+	float max = -1;
+	for (int i = 0;i<outFrames;i++) {
+		max = std::max(max, abs(outBuffer[i]));
+	}
+
+	for (int i = 0;i<outFrames;i++) {
+		outBuffer[i] = outBuffer[i] / max;
+	}
+
+	memcpy(dataOut.data(), outBuffer.data(), outFrames*sizeof(float));
+}
+
+void SlicerT::writeToMidi(std::vector<Note> * outClip) {
+	if (m_originalSample.frames() < 2048) {
+		return;
+	}
+	int ticksPerBar = DefaultTicksPerBar;
+	float sampleRate = m_timeShiftedSample.sampleRate();
+
+	float bpm = Engine::getSong()->getTempo();
+	float samplesPerBeat = 60.0f / bpm * sampleRate;
+	float beats = (float)m_timeShiftedSample.frames() / samplesPerBeat;
+
+	float barsInSample = beats / Engine::getSong()->getTimeSigModel().getDenominator();
+	float totalTicks = ticksPerBar * barsInSample;
+
+	for (int i = 0;i<m_slicePoints.size()-1;i++) {
+		float sliceStart = (float)m_slicePoints[i] / m_originalSample.frames() * totalTicks;
+		float sliceEnd = (float)m_slicePoints[i + 1] / m_originalSample.frames() * totalTicks;
+
+		Note sliceNote = Note();
+		sliceNote.setKey(i + 69);
+		sliceNote.setPos(sliceStart);
+		sliceNote.setLength(sliceEnd - sliceStart);
+		outClip->push_back(sliceNote);
+	}
+}
+
+void SlicerT::updateFile(QString file) {
+	m_originalSample.setAudioFile(file);
+	if (m_originalSample.frames() < 2048) {
+		return;
+	}
+	findSlices();
+	findBPM(); 
+	timeShiftSample();
+	
+	emit dataChanged();
+}
+
+void SlicerT::updateSlices() {
+	findSlices();
+}
+
+void SlicerT::updateTimeShift() {
+	timeShiftSample();
+}
+
+
+void SlicerT::saveSettings(QDomDocument & document, QDomElement & element) {
+	element.setAttribute("src", m_originalSample.audioFile());
+	if (m_originalSample.audioFile().isEmpty())
+	{
+		QString s;
+		element.setAttribute("sampledata", m_originalSample.toBase64(s));
+	}
+
+	element.setAttribute("totalSlices", (int)m_slicePoints.size());
+
+	for (int i = 0;i<m_slicePoints.size();i++) {
+		element.setAttribute(tr("slice_%1").arg(i), m_slicePoints[i]);
+	}
+
+	m_fadeOutFrames.saveSettings(document, element, "fadeOut");
+	m_noteThreshold.saveSettings(document, element, "threshold");
+	m_originalBPM.saveSettings(document, element, "origBPM");
+
+}
+void SlicerT::loadSettings( const QDomElement & element ) {
+	if (!element.attribute("src").isEmpty())
+	{
+		m_originalSample.setAudioFile(element.attribute("src"));
+
+		QString absolutePath = PathUtil::toAbsolute(m_originalSample.audioFile());
+		if (!QFileInfo(absolutePath).exists())
+		{
+			QString message = tr("Sample not found: %1").arg(m_originalSample.audioFile());
+			Engine::getSong()->collectError(message);
+		}
+	}
+	else if (!element.attribute("sampledata").isEmpty())
+	{
+		m_originalSample.loadFromBase64(element.attribute("srcdata"));
+	}
+
+	if (!element.attribute("totalSlices").isEmpty()) {
+		int totalSlices = element.attribute("totalSlices").toInt();
+		m_slicePoints = {};
+		for (int i = 0;i<totalSlices;i++) {
+			
+			m_slicePoints.push_back(element.attribute(tr("slice_%1").arg(i)).toInt());
+		}
+	}
+
+	m_fadeOutFrames.loadSettings(element, "fadeOut");
+	m_noteThreshold.loadSettings(element, "threshold");
+	m_originalBPM.loadSettings(element, "origBPM");
+
+	timeShiftSample();
+
+	emit dataChanged();
+
+}
+
+QString SlicerT::nodeName() const
+{
+	return( slicert_plugin_descriptor.name );
+}
+
+gui::PluginView * SlicerT::instantiateView( QWidget * parent )
+{
+	return( new gui::SlicerTUI( this, parent ) );
+}
+
+
+extern "C"
+{
+
+// necessary for getting instance out of shared lib
+PLUGIN_EXPORT Plugin * lmms_plugin_main( Model *m, void * )
+{
+	return( new SlicerT( static_cast<InstrumentTrack *>( m ) ) );
+}
+} // extern
+} // namespace lmms
+
diff --git a/plugins/SlicerT/SlicerT.h b/plugins/SlicerT/SlicerT.h
new file mode 100644
index 00000000000..745a1e44843
--- /dev/null
+++ b/plugins/SlicerT/SlicerT.h
@@ -0,0 +1,85 @@
+/*
+ * SlicerT.h - declaration of class SlicerT 
+ *
+ * Copyright (c) 2006-2008 Andreas Brandmaier <andy/at/brandmaier/dot/de>
+ * 
+ * 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 SLICERT_H
+#define SLICERT_H
+
+#include "SlicerTUI.h"
+
+#include <fftw3.h>
+
+#include "Note.h"
+#include "Instrument.h"
+#include "InstrumentView.h"
+#include "AutomatableModel.h"
+#include "SampleBuffer.h"
+
+
+namespace lmms
+{
+
+class SlicerT : public Instrument{
+	Q_OBJECT
+	public:
+		SlicerT(InstrumentTrack * instrumentTrack);
+		~SlicerT() override = default;
+
+		void playNote( NotePlayHandle * handle, sampleFrame * workingBuffer ) override;
+
+		void saveSettings( QDomDocument & document, QDomElement & element ) override;
+		void loadSettings( const QDomElement & element ) override;
+
+		QString nodeName() const override;
+		gui::PluginView * instantiateView( QWidget * parent ) override;
+
+		void writeToMidi(std::vector<Note> * outClip);
+
+	public slots:
+		void updateFile(QString file);
+		void updateTimeShift();
+		void updateSlices();
+
+	signals:
+		void isPlaying(float current, float start, float end);
+
+	private:
+		FloatModel m_noteThreshold;
+		FloatModel m_fadeOutFrames;
+		IntModel m_originalBPM;
+
+		SampleBuffer m_originalSample;
+		SampleBuffer m_timeShiftedSample;
+		std::vector<int> m_slicePoints;
+		
+		void findSlices();
+		void findBPM();
+		void timeShiftSample();
+		void phaseVocoder(std::vector<float> &in, std::vector<float> &out, float sampleRate, float pitchScale);
+
+		friend class gui::SlicerTUI;
+		friend class gui::WaveForm;
+};
+}
+
+#endif
diff --git a/plugins/SlicerT/SlicerTUI.cpp b/plugins/SlicerT/SlicerTUI.cpp
new file mode 100644
index 00000000000..8ee2e79b28d
--- /dev/null
+++ b/plugins/SlicerT/SlicerTUI.cpp
@@ -0,0 +1,154 @@
+#include "SlicerTUI.h"
+#include "SlicerT.h"
+
+#include <stdio.h>
+#include <QFileInfo>
+#include <QDropEvent>
+
+#include "StringPairDrag.h"
+#include "Clipboard.h"
+#include "Track.h"
+#include "DataFile.h"
+
+#include "Engine.h"
+#include "Song.h"
+#include "InstrumentTrack.h"
+
+#include "embed.h"
+
+namespace lmms
+{
+
+
+namespace gui
+{
+
+SlicerTUI::SlicerTUI( SlicerT * instrument,
+					QWidget * parent ) :
+	InstrumentViewFixedSize( instrument, parent ),
+	m_slicerTParent(instrument),
+	m_noteThresholdKnob(KnobType::Dark28, this),
+	m_fadeOutKnob(KnobType::Dark28, this),
+	m_bpmBox(3, "21pink", this),
+	m_resetButton(embed::getIconPixmap("reload"), QString(), this),
+	m_timeShiftButton(embed::getIconPixmap("max_length"), QString(), this),
+	m_midiExportButton(embed::getIconPixmap("midi_tab"), QString(), this),
+	m_wf(245, 125, instrument, this)
+{
+	setAcceptDrops( true );
+
+	m_wf.move(2, 5); 
+
+	m_bpmBox.move(2, 150);
+	m_bpmBox.setToolTip(tr("Original sample BPM"));
+	m_bpmBox.setLabel(tr("BPM"));
+	m_bpmBox.setModel(&m_slicerTParent->m_originalBPM);
+
+	m_timeShiftButton.move(70, 150);
+	m_timeShiftButton.setToolTip(tr("Timeshift sample"));
+	connect(&m_timeShiftButton, SIGNAL( clicked() ), m_slicerTParent, SLOT( updateTimeShift() ));
+
+	m_fadeOutKnob.move(200, 150);
+	m_fadeOutKnob.setToolTip(tr("FadeOut for notes"));
+	m_fadeOutKnob.setLabel(tr("FadeOut"));
+	m_fadeOutKnob.setModel(&m_slicerTParent->m_fadeOutFrames);
+
+	m_midiExportButton.move(150, 150);
+	m_midiExportButton.setToolTip(tr("Copy midi pattern to clipboard"));
+	connect(&m_midiExportButton, SIGNAL( clicked() ), this, SLOT( exportMidi() ));
+
+	m_noteThresholdKnob.move(7, 200);
+	m_noteThresholdKnob.setToolTip(tr("Threshold used for slicing"));
+	m_noteThresholdKnob.setLabel(tr("Threshold"));
+	m_noteThresholdKnob.setModel(&m_slicerTParent->m_noteThreshold);
+
+	m_resetButton.move(70, 200);
+	m_resetButton.setToolTip(tr("Reset Slices"));
+	connect(&m_resetButton, SIGNAL( clicked() ), m_slicerTParent, SLOT( updateSlices() ));
+
+
+
+}
+
+// copied from piano roll
+void SlicerTUI::exportMidi() {
+	using namespace Clipboard;
+
+	DataFile dataFile( DataFile::Type::ClipboardData );
+	QDomElement note_list = dataFile.createElement( "note-list" );
+	dataFile.content().appendChild( note_list );
+
+	std::vector<Note> notes;
+	m_slicerTParent->writeToMidi(&notes);
+	if (notes.size() == 0) {
+		return;
+	}
+
+	TimePos start_pos( notes.front().pos().getBar(), 0 );
+	for( Note note : notes )
+	{
+		Note clip_note( note );
+		clip_note.setPos( clip_note.pos( start_pos ) );
+		clip_note.saveState( dataFile, note_list );
+	}
+
+	copyString( dataFile.toString(), MimeType::Default );
+
+}
+
+// all the drag stuff is copied from AudioFileProcessor
+void SlicerTUI::dragEnterEvent( QDragEnterEvent * dee )
+{
+		// For mimeType() and MimeType enum class
+	using namespace Clipboard;
+
+	if( dee->mimeData()->hasFormat( mimeType( MimeType::StringPair ) ) )
+	{
+		QString txt = dee->mimeData()->data(
+						mimeType( MimeType::StringPair ) );
+		if( txt.section( ':', 0, 0 ) == QString( "clip_%1" ).arg(
+							static_cast<int>(Track::Type::Sample) ) )
+		{
+			dee->acceptProposedAction();
+		}
+		else if( txt.section( ':', 0, 0 ) == "samplefile" )
+		{
+			dee->acceptProposedAction();
+		}
+		else
+		{
+			dee->ignore();
+		}
+	}
+	else
+	{
+		dee->ignore();
+	}
+
+}
+
+void SlicerTUI::dropEvent( QDropEvent * de ) {
+	QString type = StringPairDrag::decodeKey( de );
+	QString value = StringPairDrag::decodeValue( de );
+	if( type == "samplefile" )
+	{
+		m_slicerTParent->updateFile( value );
+		// castModel<AudioFileProcessor>()->setAudioFile( value );
+		// de->accept();
+		// set m_wf wave file
+		return;
+	}
+	else if( type == QString( "clip_%1" ).arg( static_cast<int>(Track::Type::Sample) ) )
+	{
+		DataFile dataFile( value.toUtf8() );
+		m_slicerTParent->updateFile( dataFile.content().firstChild().toElement().attribute( "src" ) );
+		de->accept();
+		return;
+	}
+
+	de->ignore();
+}
+}
+}
+
+
diff --git a/plugins/SlicerT/SlicerTUI.h b/plugins/SlicerT/SlicerTUI.h
new file mode 100644
index 00000000000..4bd77ba5267
--- /dev/null
+++ b/plugins/SlicerT/SlicerTUI.h
@@ -0,0 +1,61 @@
+#include "WaveForm.h"
+
+#include <stdio.h>
+#include <QPushButton>
+
+#include "Instrument.h"
+#include "InstrumentView.h"
+#include "Knob.h"
+#include "LcdSpinBox.h"
+
+
+#ifndef SLICERT_UI_H
+#define SLICERT_UI_H
+
+namespace lmms
+{
+
+class SlicerT;
+
+namespace gui
+{
+
+
+class SlicerTUI : public InstrumentViewFixedSize
+{
+	Q_OBJECT
+public:
+	SlicerTUI( SlicerT * instrument,
+					QWidget * parent );
+	~SlicerTUI() override = default;
+
+protected slots:
+	void exportMidi();
+	//void sampleSizeChanged( float _new_sample_length );
+
+protected:
+	virtual void dragEnterEvent( QDragEnterEvent * _dee );
+	virtual void dropEvent( QDropEvent * _de );
+
+private:
+	SlicerT * m_slicerTParent;
+
+	Knob m_noteThresholdKnob;
+	Knob m_fadeOutKnob;
+	LcdSpinBox m_bpmBox;
+
+	QPushButton m_resetButton;
+	QPushButton m_timeShiftButton;
+	QPushButton m_midiExportButton;
+
+	WaveForm m_wf;
+
+
+} ;
+
+
+} // namespace gui
+
+} // namespace lmms
+
+#endif
\ No newline at end of file
diff --git a/plugins/SlicerT/WaveForm.cpp b/plugins/SlicerT/WaveForm.cpp
new file mode 100644
index 00000000000..9257cd9bccf
--- /dev/null
+++ b/plugins/SlicerT/WaveForm.cpp
@@ -0,0 +1,247 @@
+#include "WaveForm.h"
+#include "SlicerT.h"
+
+#include <stdio.h>
+
+namespace lmms
+{
+
+
+namespace gui
+{
+    WaveForm::WaveForm(int w, int h, SlicerT  * instrument, QWidget * parent) :
+        QWidget(parent),
+        m_sliceEditor(QPixmap(w, h*(1 - m_m_seekerRatio) - m_margin)),
+        m_seeker(QPixmap(w, h*m_m_seekerRatio)),
+        m_currentSample(instrument->m_originalSample.data(), instrument->m_originalSample.frames()),
+        m_slicePoints(instrument->m_slicePoints)
+        {
+            
+
+            m_width = w;
+            m_height = h;
+            m_slicerTParent = instrument;
+            setFixedSize(m_width, m_height);
+            setMouseTracking( true );
+            setAcceptDrops( true );
+
+            m_sliceEditor.fill(m_waveformBgColor);
+            m_seeker.fill(m_waveformBgColor);
+
+            connect(m_slicerTParent, 
+                    SIGNAL(isPlaying(float, float, float)), 
+                    this, 
+                    SLOT(isPlaying(float, float, float)));
+
+            connect(m_slicerTParent, SIGNAL(dataChanged()), this, SLOT(updateData()));
+
+            updateUI();
+        }
+
+    void WaveForm::drawEditor() {
+        m_sliceEditor.fill(m_waveformBgColor);
+        QPainter brush(&m_sliceEditor);
+        brush.setPen(m_waveformColor);
+
+        float startFrame = m_seekerStart * m_currentSample.frames();
+        float endFrame = m_seekerEnd * m_currentSample.frames();
+
+        m_currentSample.visualize(
+		brush,
+		QRect( 0, 0, m_sliceEditor.width(), m_sliceEditor.height() ),
+		startFrame, endFrame);
+
+
+        for (int i = 0;i<m_slicePoints.size();i++) {
+            int sliceIndex = m_slicePoints[i];
+            brush.setPen(QPen(m_sliceColor, 2));
+
+            if (sliceIndex >= startFrame && sliceIndex <= endFrame) {
+                float xPos = (float)(sliceIndex - startFrame) / (float)(endFrame - startFrame) * (float)m_width;
+                if (i == m_sliceSelected) {
+                    brush.setPen(QPen(m_selectedSliceColor, 2));
+                }
+
+                brush.drawLine(xPos, 0, xPos, m_height);
+            }
+        }
+    }
+
+    void WaveForm::drawSeeker() {
+        m_seeker.fill(m_waveformBgColor);
+        QPainter brush(&m_seeker);
+        brush.setPen(m_waveformColor);
+
+        m_currentSample.visualize(
+		brush,
+		QRect( 0, 0, m_seeker.width(), m_seeker.height() ),
+		0, m_currentSample.frames());
+
+        // draw slice points
+        brush.setPen(m_sliceColor);
+        for (int i = 0;i<m_slicePoints.size();i++) {
+            float xPos = (float)m_slicePoints[i] / (float)m_currentSample.frames() * (float)m_width;
+            brush.drawLine(xPos, 0, xPos, m_height);
+        }
+
+        // draw current playBack
+        brush.setPen(m_playColor);
+        // printf("noteplay index: %i\n", m_noteCurrent);
+        brush.drawLine(m_noteCurrent*m_width, 0, m_noteCurrent*m_width, m_height);
+        brush.fillRect(m_noteStart*m_width, 0, (m_noteEnd-m_noteStart)*m_width, m_height, m_playHighlighColor);
+
+        // draw m_seeker points
+        brush.setPen(QPen(m_seekerColor, 3));
+        brush.drawLine(m_seekerStart*m_width, 0, m_seekerStart*m_width, m_height);
+        brush.drawLine(m_seekerEnd*m_width, 0, m_seekerEnd*m_width, m_height);
+
+        // shadow on not selected area
+        brush.fillRect(0, 0, m_seekerStart*m_width, m_height, m_seekerShadowColor);
+        brush.fillRect(m_seekerEnd*m_width, 0, m_width, m_height, m_seekerShadowColor);
+    }
+
+    void WaveForm::updateUI() {
+        drawSeeker();
+        drawEditor();
+        update();
+    }
+
+    void WaveForm::updateData() {
+        printf("main data changed, updating sample and UI\n");
+        m_currentSample = SampleBuffer(m_slicerTParent->m_originalSample.data(), m_slicerTParent->m_originalSample.frames());
+        updateUI();
+    }
+
+
+    void WaveForm::isPlaying(float current, float start, float end) {
+        m_noteCurrent = current;
+        m_noteStart = start;
+        m_noteEnd = end;
+        drawSeeker();
+        update();
+    }
+
+    void WaveForm::mousePressEvent( QMouseEvent * me ) {
+        float normalizedClick = (float)me->x() / m_width;
+        
+        if (me->button() == Qt::MouseButton::MiddleButton) {
+            m_seekerStart = 0;
+            m_seekerEnd = 1;
+            return;
+        }
+
+        if (me->y() < m_height*m_m_seekerRatio) {
+            if (abs(normalizedClick - m_seekerStart) < 0.03) {
+                m_currentlyDragging = m_draggingTypes::m_seekerStart;
+
+            } else if (abs(normalizedClick - m_seekerEnd) < 0.03) {
+                m_currentlyDragging = m_draggingTypes::m_seekerEnd;
+
+            } else if (normalizedClick > m_seekerStart && normalizedClick < m_seekerEnd) {
+                m_currentlyDragging = m_draggingTypes::m_seekerMiddle;
+                m_seekerMiddle = normalizedClick;
+            }
+
+        } else {
+            m_sliceSelected = -1;
+            float startFrame = m_seekerStart * m_currentSample.frames();
+            float endFrame = m_seekerEnd * m_currentSample.frames();
+            
+            for (int i = 0;i<m_slicePoints.size();i++) {
+                int sliceIndex = m_slicePoints[i];
+                float xPos = (float)(sliceIndex - startFrame) / (float)(endFrame - startFrame);
+
+                if (abs(xPos - normalizedClick) < 0.03) {
+                    m_currentlyDragging = m_draggingTypes::slicePoint;
+                    m_sliceSelected = i;
+
+                }
+            }
+        } 
+
+        if (me->button() == Qt::MouseButton::LeftButton) {
+            m_isDragging = true;
+
+        } else if (me->button() == Qt::MouseButton::RightButton) {
+            if (m_sliceSelected != -1 && m_slicePoints.size() > 2) {
+                m_slicePoints.erase(m_slicePoints.begin() + m_sliceSelected);
+                m_sliceSelected = -1;
+            }
+        }  
+
+    }
+
+    void WaveForm::mouseReleaseEvent( QMouseEvent * me ) {
+        m_isDragging = false;
+        m_currentlyDragging = m_draggingTypes::nothing;
+        updateUI();
+    }
+
+    void WaveForm::mouseMoveEvent( QMouseEvent * me ) {
+        float normalizedClick = (float)me->x() / m_width;
+        
+        // handle dragging events
+        if (m_isDragging) { 
+            // printf("drag type:%i , m_seekerStart: %f , m_seekerEnd: %f \n", m_currentlyDragging, m_seekerStart, m_seekerEnd);
+            if (m_currentlyDragging == m_draggingTypes::m_seekerStart) {
+                m_seekerStart = std::clamp(normalizedClick, 0.0f, m_seekerEnd - 0.13f);
+
+            } else if (m_currentlyDragging == m_draggingTypes::m_seekerEnd) {
+                m_seekerEnd = std::clamp(normalizedClick, m_seekerStart + 0.13f, 1.0f);;
+
+            } else if (m_currentlyDragging == m_draggingTypes::m_seekerMiddle) {
+                float distStart = m_seekerStart - m_seekerMiddle;
+                float distEnd = m_seekerEnd - m_seekerMiddle;
+
+                m_seekerMiddle = normalizedClick;
+
+                if (m_seekerMiddle + distStart > 0 && m_seekerMiddle + distEnd < 1) {
+                    m_seekerStart = m_seekerMiddle + distStart;
+                    m_seekerEnd = m_seekerMiddle + distEnd;
+                }
+
+            } else if (m_currentlyDragging == m_draggingTypes::slicePoint) {
+                float startFrame = m_seekerStart * m_currentSample.frames();
+                float endFrame = m_seekerEnd * m_currentSample.frames();
+
+                m_slicePoints[m_sliceSelected] = startFrame + normalizedClick * (endFrame - startFrame);
+
+                m_slicePoints[m_sliceSelected] = std::clamp(m_slicePoints[m_sliceSelected], 0, m_currentSample.frames());
+
+                std::sort(m_slicePoints.begin(), m_slicePoints.end());
+
+            }
+            updateUI();
+        } else {
+
+        }
+
+        
+
+    }
+
+    void WaveForm::mouseDoubleClickEvent(QMouseEvent * me) {
+        float normalizedClick = (float)me->x() / m_width;
+        float startFrame = m_seekerStart * m_currentSample.frames();
+        float endFrame = m_seekerEnd * m_currentSample.frames();
+
+        float slicePosition = startFrame + normalizedClick * (endFrame - startFrame);
+
+        for (int i = 0;i<m_slicePoints.size();i++) {
+            if (m_slicePoints[i] < slicePosition) {
+                m_slicePoints.insert(m_slicePoints.begin() + i, slicePosition);
+                break;
+            }
+        }
+
+        std::sort(m_slicePoints.begin(), m_slicePoints.end());
+        
+    }
+
+    void WaveForm::paintEvent( QPaintEvent * pe) {
+        QPainter p( this );
+        p.drawPixmap(0, m_height*0.3f + m_margin, m_sliceEditor);
+        p.drawPixmap(0, 0, m_seeker);
+    }
+}
+}
\ No newline at end of file
diff --git a/plugins/SlicerT/WaveForm.h b/plugins/SlicerT/WaveForm.h
new file mode 100644
index 00000000000..dd448025a8a
--- /dev/null
+++ b/plugins/SlicerT/WaveForm.h
@@ -0,0 +1,88 @@
+#include <QApplication>
+#include <QFontMetrics>
+#include <QInputDialog>
+#include <QMouseEvent>
+#include <QPainter>
+
+#include "SampleBuffer.h"
+
+#ifndef WAVEFORM_H
+#define WAVEFORM_H
+
+namespace lmms
+{
+
+class SlicerT;
+
+namespace gui
+{
+
+
+class WaveForm : public QWidget {
+    	Q_OBJECT
+    protected:
+        virtual void mousePressEvent(QMouseEvent * me);
+        virtual void mouseReleaseEvent(QMouseEvent * me);
+        virtual void mouseMoveEvent(QMouseEvent * me);
+        virtual void mouseDoubleClickEvent(QMouseEvent * me);
+
+        virtual void paintEvent(QPaintEvent * pe);
+
+    private:
+        int m_width;
+        int m_height;
+        float m_m_seekerRatio = 0.3f;
+        int m_margin = 5;
+        QColor m_waveformBgColor = QColor(11, 11, 11);
+        QColor m_waveformColor = QColor(124, 49, 214);
+        QColor m_playColor = QColor(255, 255, 255, 200);
+        QColor m_playHighlighColor = QColor(255, 255, 255, 70);
+        QColor m_sliceColor = QColor(49, 214, 124);
+        QColor m_selectedSliceColor = QColor(172, 236, 190);
+        QColor m_seekerColor = QColor(214, 124, 49);
+        QColor m_seekerShadowColor = QColor(0, 0, 0, 175);
+
+        enum class m_draggingTypes {
+            nothing,
+            m_seekerStart,
+            m_seekerEnd,
+            m_seekerMiddle,
+            slicePoint,
+        };
+        m_draggingTypes m_currentlyDragging;
+        bool m_isDragging = false;
+
+        float m_seekerStart = 0;
+        float m_seekerEnd = 1;
+        float m_seekerMiddle = 0.5f;
+        int m_sliceSelected = 0;
+
+        float m_noteCurrent;
+        float m_noteStart;
+        float m_noteEnd;
+
+        QPixmap m_sliceEditor;
+        QPixmap m_seeker;
+
+        SampleBuffer m_currentSample;
+
+        void drawEditor();
+        void drawSeeker();
+        void updateUI();
+
+    public slots:
+        void updateData();
+        void isPlaying(float current, float start, float end);
+
+    public:
+        WaveForm(int w, int h, SlicerT * instrument, QWidget * parent);
+
+    private:
+        SlicerT * m_slicerTParent;
+        std::vector<int> & m_slicePoints;
+
+};
+}}
+
+
+#endif
\ No newline at end of file
diff --git a/plugins/SlicerT/logo.png b/plugins/SlicerT/logo.png
new file mode 100644
index 0000000000000000000000000000000000000000..aead03f79a8a4d5b6be99c7b70d15a1f96022482
GIT binary patch
literal 39244
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

literal 0
HcmV?d00001


From 62697af9c483bac5b7ff9e7c58ded783484a0a97 Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Fri, 8 Sep 2023 23:08:40 +0200
Subject: [PATCH 13/99] more file cleanup

---
 plugins/Slicer/CMakeLists.txt |   5 -
 plugins/Slicer/SlicerT.cpp    | 640 ----------------------------------
 plugins/Slicer/SlicerT.h      | 101 ------
 plugins/Slicer/SlicerTUI.cpp  | 165 ---------
 plugins/Slicer/SlicerTUI.h    |  68 ----
 plugins/Slicer/WaveForm.cpp   | 260 --------------
 plugins/Slicer/WaveForm.h     |  90 -----
 plugins/Slicer/logo.png       | Bin 1109 -> 0 bytes
 8 files changed, 1329 deletions(-)
 delete mode 100644 plugins/Slicer/CMakeLists.txt
 delete mode 100644 plugins/Slicer/SlicerT.cpp
 delete mode 100644 plugins/Slicer/SlicerT.h
 delete mode 100644 plugins/Slicer/SlicerTUI.cpp
 delete mode 100644 plugins/Slicer/SlicerTUI.h
 delete mode 100644 plugins/Slicer/WaveForm.cpp
 delete mode 100644 plugins/Slicer/WaveForm.h
 delete mode 100644 plugins/Slicer/logo.png

diff --git a/plugins/Slicer/CMakeLists.txt b/plugins/Slicer/CMakeLists.txt
deleted file mode 100644
index b93021e98f9..00000000000
--- a/plugins/Slicer/CMakeLists.txt
+++ /dev/null
@@ -1,5 +0,0 @@
-INCLUDE(BuildPlugin)
-
-BUILD_PLUGIN(slicert SlicerT.cpp SlicerT.h SlicerTUI.cpp SlicerTUI.h WaveForm.cpp WaveForm.h MOCFILES SlicerT.h SlicerTUI.h WaveForm.h EMBEDDED_RESOURCES "${CMAKE_CURRENT_SOURCE_DIR}/*.png")
-
-
diff --git a/plugins/Slicer/SlicerT.cpp b/plugins/Slicer/SlicerT.cpp
deleted file mode 100644
index 6b74511e031..00000000000
--- a/plugins/Slicer/SlicerT.cpp
+++ /dev/null
@@ -1,640 +0,0 @@
-/*
- * Slicer.cpp - instrument which uses a usereditable wavetable
- *
- * Copyright (c) 2006-2008 Andreas Brandmaier <andy/at/brandmaier/dot/de>
- * 
- * 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.
- *
- */
-
-
-// TODO: fadeIn
-// TODO: fix lag multiple notes
-// TODO: timeshift samples on notePlay and cache them
-
-#include "SlicerT.h"
-#include <stdio.h>
-#include <fftw3.h>
-#include <QDomElement>
-
-#include "Engine.h"
-#include "Song.h"
-#include "InstrumentTrack.h"
-
-#include "PathUtil.h"
-#include "embed.h"
-#include "plugin_export.h"
-
-
-
-
-namespace lmms
-{
-
-
-extern "C"
-{
-
-Plugin::Descriptor PLUGIN_EXPORT slicert_plugin_descriptor =
-{
-	LMMS_STRINGIFY( PLUGIN_NAME ),
-	"SlicerT",
-	QT_TRANSLATE_NOOP( "PluginBrowser",
-				"A cool testPlugin" ),
-	"Daniel Kauss Serna>",
-	0x0100,
-	Plugin::Type::Instrument,
-	new PluginPixmapLoader( "logo" ),
-	nullptr,
-	nullptr,
-} ;
-
-}
-
-
-
-SlicerT::SlicerT(InstrumentTrack * _instrument_track) : 
-	Instrument( _instrument_track, &slicert_plugin_descriptor ),
-	noteThreshold(0.6f, 0.0f, 2.0f, 0.01f, this, tr( "Note threshold" ) ),
-	fadeOutFrames(2048.0f, 0.0f, 8192.0f, 4.0f, this, tr("FadeOut")),
-	originalBPM(1, 1, 999, this, tr("Original bpm")),
-
-	originalSample(),
-	timeShiftedSample()
-{
-	printf("Correctly loaded SlicerT!\n");
-}
-
-void SlicerT::playNote( NotePlayHandle * _n, sampleFrame * _working_buffer ) {
-	if (originalSample.frames() < 2048) {
-		return;
-	}
-
-	const fpp_t frames = _n->framesLeftForCurrentPeriod();
-	const int playedFrames = _n->totalFramesPlayed();
-	const f_cnt_t offset = _n->noteOffset();
-	
-	int totalFrames = timeShiftedSample.frames();
-	int sliceStart = timeShiftedSample.startFrame();
-	int sliceEnd = timeShiftedSample.endFrame();
-	int sliceFrames = timeShiftedSample.endFrame() - timeShiftedSample.startFrame();
-	int noteFramesLeft = sliceFrames - playedFrames;
-
-	// init NotePlayHandle data
-	if( !_n->m_pluginData )
-	{
-		_n->m_pluginData = new SampleBuffer::handleState( false, SRC_LINEAR );
-
-		float speedRatio = (float)originalBPM.value() / Engine::getSong()->getTempo() ;
-		int noteIndex = _n->key() - 69;
-		int sliceStart, sliceEnd;
-		
-		// 0th element is no sound, so play full sample
-		if (noteIndex > slicePoints.size()-2 || noteIndex < 0) {
-			sliceStart = 0;
-			sliceEnd = timeShiftedSample.frames();
-		} else {
-			sliceStart = slicePoints[noteIndex] * speedRatio;
-			sliceEnd = slicePoints[noteIndex+1] * speedRatio;
-		}
-
-
-		timeShiftedSample.setAllPointFrames( sliceStart, sliceEnd, sliceStart, sliceEnd );
-
-
-	
-	}
-
-
-	// if play returns true (success I guess)
-	if( ! _n->isFinished() ) {
-		if( timeShiftedSample.play( _working_buffer + offset,
-					(SampleBuffer::handleState *)_n->m_pluginData,
-					frames, 440,
-					static_cast<SampleBuffer::LoopMode>( 0 ) ) )
-		{
-			// exponential fade out, applyRelease kinda sucks
-			if (noteFramesLeft < fadeOutFrames.value()) {
-				// printf("fade out started. frames: %i, framesLeft: %i\n", frames, noteFramesLeft);
-				for (int i = 0;i<frames;i++) {
-					float fadeValue = (float)(noteFramesLeft-i) / fadeOutFrames.value();
-					// if the workingbuffer extends the sample
-					fadeValue = std::clamp(fadeValue, 0.0f, 1.0f);
-					fadeValue = pow(fadeValue, 2);
-
-					_working_buffer[i][0] *= fadeValue;
-					_working_buffer[i][1] *= fadeValue;
-				}
-			}
-
-			instrumentTrack()->processAudioBuffer( _working_buffer,
-									frames + offset, _n );
-
-
-			float absoluteCurrentNote = (float)(sliceStart + playedFrames) / totalFrames;
-			float absoluteStartNote = (float)sliceStart / totalFrames;
-			float abslouteEndNote = (float)sliceEnd / totalFrames;
-			emit isPlaying(absoluteCurrentNote, absoluteStartNote, abslouteEndNote);
-
-		} else {
-			emit isPlaying(0, 0, 0);			
-		}
-	} else {
-		emit isPlaying(0, 0, 0);
-	}
-
-	
-
-}
-
-
-void SlicerT::findSlices() {
-	if (originalSample.frames() < 2048) {
-		return;
-	}
-	int c = 0;
-	const int window = 1024;
-	int peakIndex = 0;
-	float lastPeak = 0;
-	float currentPeak = 0;
-	int minWindowsPassed = 0;
-	slicePoints = {};
-	for (int i = 0; i<originalSample.frames();i+=1) {
-		// combine left and right and absolute it
-		float sampleValue = abs(originalSample.data()[i][0]) + abs(originalSample.data()[i][1]) / 2;
-		if (sampleValue > currentPeak) {
-			currentPeak = sampleValue;
-			peakIndex = i;
-		}
-		
-		if (i%window==0) {
-								//printf("%i -> %f : %f\n", i, currentAvg, lastAvg);
-			if (abs(currentPeak / lastPeak) > 1+noteThreshold.value() && minWindowsPassed <= 0) {
-				c++;
-				slicePoints.push_back(std::max(0, peakIndex-window/2)); // slight offset
-				minWindowsPassed = 2; // wait at least one window for a new note
-			}
-			lastPeak = currentPeak;
-			currentPeak = 0;
-			
-			
-			minWindowsPassed--;
-
-		}
-
-	}
-	slicePoints.push_back(originalSample.frames());
-
-	emit dataChanged();
-}
-
-// void SlicerT::updateParams() {
-
-// }
-
-// find the bpm of the sample by assuming its in 4/4 time signature ,
-// and lies in the 100 - 200 bpm range
-void SlicerT::findBPM() {
-	if (originalSample.frames() < 2048) {
-		return;
-	}
-	int bpmSnap = 1;
-
-	float sampleRate = originalSample.sampleRate();
-	float totalFrames = originalSample.frames();
-	float sampleLength = totalFrames / sampleRate;
-
-	// this assumes the sample has a time signature of x/4
-	float bpmEstimate = 240.0f / sampleLength;
-
-	// deal with samlpes that are not 1 bar long
-	while (bpmEstimate < 100) {
-		bpmEstimate *= 2;
-	}
-
-	while (bpmEstimate > 200) {
-		bpmEstimate /= 2;
-	}
-
-	// snap bpm
-	int bpm = bpmEstimate;
-	bpm += (float)bpmSnap / 2;
-	bpm -= bpm % bpmSnap;
-
-	originalBPM.setValue(bpm);
-	originalBPM.setInitValue(bpm);
-}
-
-// create thimeshifted samplebuffer and timeshifted slicePoints
-void SlicerT::timeShiftSample() {
-	if (originalSample.frames() < 2048) {
-		return;
-	}
-	using std::vector;
-	printf("starting sample timeshifting\n");
-
-	// original sample data
-	float sampleRate = originalSample.sampleRate();
-	int originalFrames = originalSample.frames();
-
-	// target data TODO: fix this mess
-	bpm_t targetBPM = Engine::getSong()->getTempo();
-	float speedRatio = (float)originalBPM.value() / targetBPM ;
-	int outFrames = speedRatio * originalFrames;
-
-	// snap to a beat, this should be in the UI
-	// outFrames += (float)samplesPerBeat;
-	// outFrames -= outFrames%samplesPerBeat;
-
-	// nothing to do here
-	if (targetBPM == originalBPM.value()) {
-		timeShiftedSample = SampleBuffer(originalSample.data(), originalSample.frames());
-		printf("BPM match for sample, finished timeshift. frames: %i\n", timeShiftedSample.frames());
-		return;
-	}
-
-	// buffers
-	vector<float> rawData(originalFrames, 0);
-	vector<float> outData(outFrames, 0);
-
-	vector<sampleFrame> bufferData(outFrames, sampleFrame());
-
-	// copy channels for processing
-	for (int i = 0;i<originalFrames;i++) {
-		rawData[i] = (float)originalSample.data()[i][0];
-	}
-	printf("startign PV\n");
-	// process channels
-	phaseVocoder(rawData, outData, sampleRate, 1);
-
-	printf("starting buffer copy\n");
-	// write processed channels 
-	for (int i = 0;i<outFrames;i++) {
-		bufferData.data()[i][0] = outData[i];
-		bufferData.data()[i][1] = outData[i];
-	}
-
-	printf("creating timeshifted sample\n");
-	// new sample
-	timeShiftedSample = SampleBuffer(bufferData.data(), bufferData.size());
-
-
-	printf("finished sample timeshifting\n");
-
-
-}
-
-
-// basic phase vocoder implementation that time shifts without pitch change
-// resources:
-// http://blogs.zynaptiq.com/bernsee/pitch-shifting-using-the-ft/
-// https://sethares.engr.wisc.edu/vocoders/phasevocoder.html
-// https://dsp.stackexchange.com/questions/40101/audio-time-stretching-without-pitch-shifting/40367#40367
-// https://www.guitarpitchshifter.com/
-
-// a lot of stuff needs improvement, mostly the windowing and
-// the pitch shifting implemention
-void SlicerT::phaseVocoder(std::vector<float> &dataIn, std::vector<float> &dataOut, float sampleRate, float pitchScale) {
-	using std::vector;
-	// processing parameters, lower is faster
-	// lower windows size seems to work better for time scaling,
-	// this is because the step site is scaled, but not the window size
-	// this causes slight timing differences between windows
-	// sadly, lower windowsize also reduces audio quality in general
-	// TODO: find solution
-	// oversampling is better if higher always (probably)
-	const int windowSize = 512;
-	const int overSampling = 32;
-	
-	// audio data
-	int inFrames = dataIn.size();
-	int outFrames = dataOut.size();
-
-	float lengthRatio = (float)outFrames / inFrames;
-
-	// values used
-	const int stepSize = (float)windowSize / overSampling; 
-	const int numWindows = (float)inFrames / stepSize;
-	const int windowLatency = (overSampling-1)*stepSize;
-	const float outStepSize = lengthRatio * (float)stepSize; // float, else inaccurate
-	const float freqPerBin = sampleRate/windowSize; 
-	// very important
-	const float expectedPhaseIn = 2.*M_PI*(float)stepSize/(float)windowSize;
-	const float expectedPhaseOut = 2.*M_PI*(float)outStepSize/(float)windowSize;
-
-
-	printf("frames: %i , out frames: %i , ratio: %f\n", inFrames, outFrames, (float)outFrames / inFrames);
-	printf("stepSize: %i, outStepSize:%i, numWindows: %i", stepSize, outStepSize, numWindows);
-	printf("will drop %i\n", inFrames%(inFrames/numWindows));
-
-	// initialize buffers
-	fftwf_complex FFTSpectrum[windowSize];
-	vector<float> FFTInput(windowSize, 0);
-	vector<float> IFFTReconstruction(windowSize, 0);
-	vector<float> allMagnitudes(windowSize, 0);
-	vector<float> allFrequencies(windowSize, 0);
-	vector<float> processedFreq(windowSize, 0);
-	vector<float> processedMagn(windowSize, 0);
-	vector<float> lastPhase(windowSize, 0);
-	vector<float> sumPhase(windowSize, 0);
-
-	vector<float> outBuffer(outFrames, 0);
-
-	// declare vars
-	float real, imag, phase, magnitude, freq, deltaPhase = 0;
-	int windowIndex = 0;
-
-	// fft plans
-	fftwf_plan fftPlan;
-	fftPlan = fftwf_plan_dft_r2c_1d(windowSize, FFTInput.data(), FFTSpectrum, FFTW_MEASURE);
-	fftwf_plan ifftPlan;
-	ifftPlan = fftwf_plan_dft_c2r_1d(windowSize, FFTSpectrum, IFFTReconstruction.data(), FFTW_MEASURE);
-
-	// remove oversampling, because the actual window is overSampling* bigger than stepsize
-	for (int i = 0;i < numWindows-overSampling;i++) {
-		windowIndex = i * stepSize;
-
-		// FFT
-		memcpy(FFTInput.data(), dataIn.data() + windowIndex, windowSize*sizeof(float));
-		fftwf_execute(fftPlan);
-
-		// analysis step
-		for (int j = 0; j < windowSize; j++) {
-			
-			real = FFTSpectrum[j][0];
-			imag = FFTSpectrum[j][1];
-
-			magnitude = 2.*sqrt(real*real + imag*imag);
-			phase = atan2(imag,real); 
-
-			freq = phase - lastPhase[j]; // subtract prev pahse to get phase diference
-			lastPhase[j] = phase;
-
-			freq -= (float)j*expectedPhaseIn; // subtract expected phase
-
-			// some black magic to get into +/- PI interval, revise later pls
-			long qpd = freq/M_PI;
-			if (qpd >= 0) qpd += qpd&1;
-			else qpd -= qpd&1;
-			freq -= M_PI*(float)qpd;
-			
-			freq = (float)overSampling*freq/(2.*M_PI); // idk
-
-			freq = (float)j*freqPerBin + freq*freqPerBin; // "compute the k-th partials' true frequency" ok i guess
-
-			allMagnitudes[j] = magnitude;
-			allFrequencies[j] = freq;
-
-		}
-		
-		// TODO: pitch shifting
-		// takes all the values that are below the nyquist frequency (representable with our samplerate)
-		// nyquist frequency = samplerate / 2
-		// and moves them to a different bin
-		// improve for larger pitch shift
-		// memset(processedFreq.data(), 0, processedFreq.size()*sizeof(float));
-		// memset(processedMagn.data(), 0, processedFreq.size()*sizeof(float));
-		// for (int j = 0; j < windowSize/2; j++) {
-		// 	int index = (float)j;// * noteThreshold.value();
-		// 	if (index <= windowSize/2) {
-		// 		processedMagn[index] += allMagnitudes[j];
-		// 		processedFreq[index] = allFrequencies[j];// * noteThreshold.value();
-		// 	}
-		// }
-
-		// synthesis, all the operations are the reverse of the analysis
-		for (int j = 0; j < windowSize; j++) {
-			magnitude = allMagnitudes[j];
-			freq = allFrequencies[j];
-
-			deltaPhase = freq - (float)j*freqPerBin;
-
-			deltaPhase /= freqPerBin;
-
-			deltaPhase = 2.*M_PI*deltaPhase/overSampling;;
-
-			deltaPhase += (float)j*expectedPhaseOut;
-
-			sumPhase[j] += deltaPhase;
-			deltaPhase = sumPhase[j]; // this is the bin phase
-
-			FFTSpectrum[j][0] = magnitude*cos(deltaPhase);
-			FFTSpectrum[j][1] = magnitude*sin(deltaPhase);
-		}
-
-		// inverse fft
-		fftwf_execute(ifftPlan);
-
-		// windowing
-		// this is very bad, audible click at the beginning if we take the average,
-		// but else there is a windowSized delay...
-		// solution would be to take the average but blend it together better
-		// TODO: make better
-		for (int j = 0; j < windowSize; j++) {
-
-			float outIndex = i * outStepSize + j;
-			if (outIndex > outFrames) {
-				printf("too long window size, breaking\n");
-				break;
-			}
-
-			// calculate windows overlapping at index
-			float startWindowOverlap = ceil(outIndex / outStepSize + 0.00000001);
-			float endWindowOverlap = ceil((float)(-outIndex + outFrames) / outStepSize + 0.00000001);
-			float totalWindowOverlap = std::min(
-										std::min(startWindowOverlap, endWindowOverlap), 
-										(float)overSampling);
-
-
-			// completly unsmooth, but ensures same magnitude across
-			outBuffer[outIndex] += (float)overSampling/totalWindowOverlap*IFFTReconstruction[j]/(windowSize/2.0f*overSampling);
-			// printf("%f	", outBuffer[outIndex]);
-			// if (outIndex < (float)outStepSize*overSampling) {
-			// 	printf("start: %f, end: %f, total:%f\n", startWindowOverlap, endWindowOverlap, totalWindowOverlap);
-			// 	// since not all windows overlap, just take the average of the ones that do overlap
-			// 	outBuffer[outIndex] += (float)overSampling/startWindowOverlap*IFFTReconstruction[j]/(windowSize/2.0f*overSampling);
-
-			// 	// no averaging, probably worse
-			// 	// outBuffer[outIndex] = overSampling*IFFTReconstruction[j]/(windowSize/2.0f*overSampling);
-			// } else {
-			// 	// this computes the weight of the window on the final output
-				// float window = -0.5f*cos(2.*M_PI*(float)j/(float)windowSize)+0.5f;
-
-				// outBuffer[outIndex] += 2.0f*window*IFFTReconstruction[j]/(windowSize/2.0f*overSampling);
-			// }
-
-		}
-
-
-	}
-
-	fftwf_destroy_plan(fftPlan);
-	fftwf_destroy_plan(ifftPlan);
-
-	// normalize 	
-	float max = -1;
-	for (int i = 0;i<outFrames;i++) {
-		max = std::max(max, abs(outBuffer[i]));
-	}
-
-	printf("max: %f\n", max);
-
-	for (int i = 0;i<outFrames;i++) {
-		outBuffer[i] = outBuffer[i] / max;
-	}
-
-	memcpy(dataOut.data(), outBuffer.data(), outFrames*sizeof(float));
-
-	printf("finished pitch scaling sample\n");
-
-
-}
-
-void SlicerT::writeToMidi(std::vector<Note> * outClip) {
-	if (originalSample.frames() < 2048) {
-		return;
-	}
-	int ticksPerBar = DefaultTicksPerBar;
-	float sampleRate = timeShiftedSample.sampleRate();
-
-	float bpm = Engine::getSong()->getTempo();
-	float samplesPerBeat = 60.0f / bpm * sampleRate;
-	float beats = (float)timeShiftedSample.frames() / samplesPerBeat;
-
-	float barsInSample = beats / Engine::getSong()->getTimeSigModel().getDenominator();
-	float tickMult = ticksPerBar * barsInSample;
-
-	printf("beats: %f, bars: %f, tickMult: %f\n", beats, barsInSample, tickMult);
-
-	for (int i = 0;i<slicePoints.size()-1;i++) {
-		float sliceStart = (float)slicePoints[i] / originalSample.frames() * tickMult;
-		float sliceEnd = (float)slicePoints[i + 1] / originalSample.frames() * tickMult;
-
-		Note sliceNote = Note();
-		sliceNote.setKey(i + 69);
-		sliceNote.setPos(sliceStart);
-		sliceNote.setLength(sliceEnd - sliceStart);
-		outClip->push_back(sliceNote);
-	}
-}
-
-void SlicerT::updateFile(QString file) {
-	printf("updated audio file\n");
-	originalSample.setAudioFile(file);
-	if (originalSample.frames() < 2048) {
-		return;
-	}
-	findSlices();
-	findBPM(); 
-	timeShiftSample();
-	
-	emit dataChanged();
-}
-
-void SlicerT::updateSlices() {
-	findSlices();
-}
-
-void SlicerT::updateTimeShift() {
-	timeShiftSample();
-}
-
-
-void SlicerT::saveSettings(QDomDocument & doc, QDomElement & elem) {
-	elem.setAttribute("src", originalSample.audioFile());
-	if (originalSample.audioFile().isEmpty())
-	{
-		QString s;
-		elem.setAttribute("sampledata", originalSample.toBase64(s));
-	}
-
-	elem.setAttribute("totalSlices", (int)slicePoints.size());
-
-	for (int i = 0;i<slicePoints.size();i++) {
-		elem.setAttribute(tr("slice_%1").arg(i), slicePoints[i]);
-	}
-
-	fadeOutFrames.saveSettings(doc, elem, "fadeOut");
-	noteThreshold.saveSettings(doc, elem, "threshold");
-	originalBPM.saveSettings(doc, elem, "origBPM");
-
-}
-void SlicerT::loadSettings( const QDomElement & elem ) {
-	if (!elem.attribute("src").isEmpty())
-	{
-		originalSample.setAudioFile(elem.attribute("src"));
-
-		QString absolutePath = PathUtil::toAbsolute(originalSample.audioFile());
-		if (!QFileInfo(absolutePath).exists())
-		{
-			QString message = tr("Sample not found: %1").arg(originalSample.audioFile());
-			Engine::getSong()->collectError(message);
-		}
-	}
-	else if (!elem.attribute("sampledata").isEmpty())
-	{
-		originalSample.loadFromBase64(elem.attribute("srcdata"));
-	}
-
-	if (!elem.attribute("totalSlices").isEmpty()) {
-		int totalSlices = elem.attribute("totalSlices").toInt();
-		slicePoints = {};
-		for (int i = 0;i<totalSlices;i++) {
-			
-			slicePoints.push_back(elem.attribute(tr("slice_%1").arg(i)).toInt());
-		}
-	}
-
-	fadeOutFrames.loadSettings(elem, "fadeOut");
-	noteThreshold.loadSettings(elem, "threshold");
-	originalBPM.loadSettings(elem, "origBPM");
-
-	timeShiftSample();
-
-	emit dataChanged();
-
-}
-
-QString SlicerT::nodeName() const
-{
-	return( slicert_plugin_descriptor.name );
-}
-
-gui::PluginView * SlicerT::instantiateView( QWidget * _parent )
-{
-	return( new gui::SlicerTUI( this, _parent ) );
-}
-
-
-
-extern "C"
-{
-
-// necessary for getting instance out of shared lib
-PLUGIN_EXPORT Plugin * lmms_plugin_main( Model *m, void * )
-{
-	
-	return( new SlicerT( static_cast<InstrumentTrack *>( m ) ) );
-}
-
-
-}
-
-
-} // namespace lmms
-
diff --git a/plugins/Slicer/SlicerT.h b/plugins/Slicer/SlicerT.h
deleted file mode 100644
index 004e4756f1e..00000000000
--- a/plugins/Slicer/SlicerT.h
+++ /dev/null
@@ -1,101 +0,0 @@
-/*
- * Slicer.h - declaration of class Slicer and BSynth which
- *                         are a wavetable synthesizer
- *
- * Copyright (c) 2006-2008 Andreas Brandmaier <andy/at/brandmaier/dot/de>
- * 
- * 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 SLICERT_H
-#define SLICERT_H
-
-#include "SlicerTUI.h"
-
-#include <fftw3.h>
-
-#include "Note.h"
-#include "Instrument.h"
-#include "InstrumentView.h"
-#include "AutomatableModel.h"
-#include "SampleBuffer.h"
-
-
-// #include "Graph.h"
-// #include "MemoryManager.h"
-
-
-namespace lmms
-{
-
-class SlicerT : public Instrument{
-	Q_OBJECT
-	public:
-		SlicerT(InstrumentTrack * _instrument_track);
-		~SlicerT() override = default;
-
-		void playNote( NotePlayHandle * _n,
-						sampleFrame * _working_buffer ) override;
-
-
-		void saveSettings( QDomDocument & _doc,
-								QDomElement & _parent ) override;
-		void loadSettings( const QDomElement & _this ) override;
-
-		QString nodeName() const override;
-
-		gui::PluginView * instantiateView( QWidget * _parent ) override;
-
-		void writeToMidi(std::vector<Note> * outClip);
-
-	public slots:
-		void updateFile(QString file);
-		void updateTimeShift();
-		void updateSlices();
-
-	signals:
-		void isPlaying( float current, float start, float end );
-
-	private:
-	
-
-		FloatModel noteThreshold;
-		FloatModel fadeOutFrames;
-		IntModel originalBPM;
-
-		SampleBuffer originalSample;
-		SampleBuffer timeShiftedSample;
-		std::vector<int> slicePoints;
-		
-	
-		void findSlices();
-		void findBPM();
-		void timeShiftSample();
-		void phaseVocoder(std::vector<float> &in, std::vector<float> &out, float sampleRate, float pitchScale);
-
-		friend class gui::SlicerTUI;
-		friend class gui::WaveForm;
-		
-};
-
-
-}
-
-#endif
diff --git a/plugins/Slicer/SlicerTUI.cpp b/plugins/Slicer/SlicerTUI.cpp
deleted file mode 100644
index 823cb162028..00000000000
--- a/plugins/Slicer/SlicerTUI.cpp
+++ /dev/null
@@ -1,165 +0,0 @@
-#include "SlicerTUI.h"
-#include "SlicerT.h"
-
-#include <stdio.h>
-#include <QFileInfo>
-#include <QDropEvent>
-
-#include "StringPairDrag.h"
-#include "Clipboard.h"
-#include "Track.h"
-#include "DataFile.h"
-
-#include "Engine.h"
-#include "Song.h"
-#include "InstrumentTrack.h"
-
-#include "embed.h"
-
-namespace lmms
-{
-
-
-namespace gui
-{
-SlicerTUI::SlicerTUI( SlicerT * _instrument,
-					QWidget * _parent ) :
-	InstrumentViewFixedSize( _instrument, _parent ),
-	slicerTParent(_instrument),
-	noteThresholdKnob(KnobType::Dark28, this),
-	fadeOutKnob(KnobType::Dark28, this),
-	bpmBox(3, "21pink", this),
-	resetButton(embed::getIconPixmap("reload"), QString(), this),
-	timeShiftButton(embed::getIconPixmap("max_length"), QString(), this),
-	midiExportButton(embed::getIconPixmap("midi_tab"), QString(), this),
-	wf(245, 125, _instrument, this)
-{
-	setAcceptDrops( true );
-
-	wf.move(2, 5); 
-
-	bpmBox.move(2, 150);
-	bpmBox.setToolTip(tr("Original sample BPM"));
-	bpmBox.setLabel(tr("BPM"));
-	bpmBox.setModel(&slicerTParent->originalBPM);
-
-	timeShiftButton.move(70, 150);
-	timeShiftButton.setToolTip(tr("Timeshift sample"));
-	connect(&timeShiftButton, SIGNAL( clicked() ), slicerTParent, SLOT( updateTimeShift() ));
-
-	fadeOutKnob.move(200, 150);
-	fadeOutKnob.setToolTip(tr("FadeOut for notes"));
-	fadeOutKnob.setLabel(tr("FadeOut"));
-	fadeOutKnob.setModel(&slicerTParent->fadeOutFrames);
-
-	midiExportButton.move(150, 150);
-	midiExportButton.setToolTip(tr("Copy midi pattern to clipboard"));
-	connect(&midiExportButton, SIGNAL( clicked() ), this, SLOT( exportMidi() ));
-
-	noteThresholdKnob.move(7, 200);
-	noteThresholdKnob.setToolTip(tr("Threshold used for slicing"));
-	noteThresholdKnob.setLabel(tr("Threshold"));
-	noteThresholdKnob.setModel(&slicerTParent->noteThreshold);
-
-	resetButton.move(70, 200);
-	resetButton.setToolTip(tr("Reset Slices"));
-	connect(&resetButton, SIGNAL( clicked() ), slicerTParent, SLOT( updateSlices() ));
-
-
-
-}
-
-// copied from piano roll
-void SlicerTUI::exportMidi() {
-	using namespace Clipboard;
-
-	DataFile dataFile( DataFile::Type::ClipboardData );
-	QDomElement note_list = dataFile.createElement( "note-list" );
-	dataFile.content().appendChild( note_list );
-
-	std::vector<Note> notes;
-	slicerTParent->writeToMidi(&notes);
-	if (notes.size() == 0) {
-		return;
-	}
-
-	TimePos start_pos( notes.front().pos().getBar(), 0 );
-	for( Note note : notes )
-	{
-		Note clip_note( note );
-		clip_note.setPos( clip_note.pos( start_pos ) );
-		clip_note.saveState( dataFile, note_list );
-	}
-
-	copyString( dataFile.toString(), MimeType::Default );
-
-}
-
-void SlicerTUI::mousePressEvent( QMouseEvent * _me ) {
-	printf("clicked on TUI\n");
-	// slicerTParent->findSlices();
-	// slicerTParent->findBPM();
-	// slicerTParent->timeShiftSample();
-	update();
-}
-
-// all the drag stuff is copied from AudioFileProcessor
-void SlicerTUI::dragEnterEvent( QDragEnterEvent * _dee )
-{
-		// For mimeType() and MimeType enum class
-	using namespace Clipboard;
-
-	if( _dee->mimeData()->hasFormat( mimeType( MimeType::StringPair ) ) )
-	{
-		QString txt = _dee->mimeData()->data(
-						mimeType( MimeType::StringPair ) );
-		if( txt.section( ':', 0, 0 ) == QString( "clip_%1" ).arg(
-							static_cast<int>(Track::Type::Sample) ) )
-		{
-			_dee->acceptProposedAction();
-		}
-		else if( txt.section( ':', 0, 0 ) == "samplefile" )
-		{
-			_dee->acceptProposedAction();
-		}
-		else
-		{
-			_dee->ignore();
-		}
-	}
-	else
-	{
-		_dee->ignore();
-	}
-
-}
-
-void SlicerTUI::dropEvent( QDropEvent * _de ) {
-	QString type = StringPairDrag::decodeKey( _de );
-	QString value = StringPairDrag::decodeValue( _de );
-	if( type == "samplefile" )
-	{
-		printf("type: samplefile\n");
-		slicerTParent->updateFile( value );
-		// castModel<AudioFileProcessor>()->setAudioFile( value );
-		// _de->accept();
-		// set wf wave file
-		return;
-	}
-	else if( type == QString( "clip_%1" ).arg( static_cast<int>(Track::Type::Sample) ) )
-	{
-		printf("type: clip file\n");
-		DataFile dataFile( value.toUtf8() );
-		slicerTParent->updateFile( dataFile.content().firstChild().toElement().attribute( "src" ) );
-		_de->accept();
-		return;
-	}
-
-	_de->ignore();
-}
-
-
-}
-}
-
-
diff --git a/plugins/Slicer/SlicerTUI.h b/plugins/Slicer/SlicerTUI.h
deleted file mode 100644
index b123223fb4f..00000000000
--- a/plugins/Slicer/SlicerTUI.h
+++ /dev/null
@@ -1,68 +0,0 @@
-#include "WaveForm.h"
-
-#include <stdio.h>
-#include <QPushButton>
-
-#include "Instrument.h"
-#include "InstrumentView.h"
-#include "Knob.h"
-#include "LcdSpinBox.h"
-
-
-#ifndef SLICERT_UI_H
-#define SLICERT_UI_H
-
-namespace lmms
-{
-
-// forward declaration, to be able to use SlicerT as a parameter
-class SlicerT;
-
-namespace gui
-{
-
-// class Knob;
-// class LedCheckBox;
-// class PixmapButton;
-
-
-class SlicerTUI : public InstrumentViewFixedSize
-{
-	Q_OBJECT
-public:
-	SlicerTUI( SlicerT * _instrument,
-					QWidget * _parent );
-	~SlicerTUI() override = default;
-
-protected slots:
-	void exportMidi();
-	//void sampleSizeChanged( float _new_sample_length );
-
-protected:
-	virtual void dragEnterEvent( QDragEnterEvent * _dee );
-	virtual void dropEvent( QDropEvent * _de );
-	virtual void mousePressEvent( QMouseEvent * _me );
-
-
-private:
-	SlicerT * slicerTParent;
-
-	Knob noteThresholdKnob;
-	Knob fadeOutKnob;
-	LcdSpinBox bpmBox;
-
-	QPushButton resetButton;
-	QPushButton timeShiftButton;
-	QPushButton midiExportButton;
-
-	WaveForm wf;
-
-
-} ;
-
-
-} // namespace gui
-
-} // namespace lmms
-
-#endif
\ No newline at end of file
diff --git a/plugins/Slicer/WaveForm.cpp b/plugins/Slicer/WaveForm.cpp
deleted file mode 100644
index 84a3d249f3f..00000000000
--- a/plugins/Slicer/WaveForm.cpp
+++ /dev/null
@@ -1,260 +0,0 @@
-#include "WaveForm.h"
-#include "SlicerT.h"
-
-#include <stdio.h>
-
-namespace lmms
-{
-
-
-namespace gui
-{
-    WaveForm::WaveForm(int _w, int _h, SlicerT  * _instrument, QWidget * _parent) :
-        QWidget(_parent),
-        seeker(QPixmap(_w, _h*seekerRatio)),
-        sliceEditor(QPixmap(_w, _h*(1 - seekerRatio) - margin)),
-        currentSample(_instrument->originalSample.data(), _instrument->originalSample.frames()),
-        slicePoints(_instrument->slicePoints)
-        {
-            
-
-            width = _w;
-            height = _h;
-            slicerTParent = _instrument;
-            setFixedSize(width, height);
-            setMouseTracking( true );
-            setAcceptDrops( true );
-
-            sliceEditor.fill(waveformBgColor);
-            seeker.fill(waveformBgColor);
-
-            connect(slicerTParent, 
-                    SIGNAL(isPlaying(float, float, float)), 
-                    this, 
-                    SLOT(isPlaying(float, float, float)));
-
-            connect(slicerTParent, SIGNAL(dataChanged()), this, SLOT(updateData()));
-
-            updateUI();
-        }
-
-    void WaveForm::drawEditor() {
-        sliceEditor.fill(waveformBgColor);
-        QPainter brush(&sliceEditor);
-        brush.setPen(waveformColor);
-
-        float startFrame = seekerStart * currentSample.frames();
-        float endFrame = seekerEnd * currentSample.frames();
-
-        currentSample.visualize(
-		brush,
-		QRect( 0, 0, sliceEditor.width(), sliceEditor.height() ),
-		startFrame, endFrame);
-
-
-        for (int i = 0;i<slicePoints.size();i++) {
-            int sliceIndex = slicePoints[i];
-            brush.setPen(QPen(sliceColor, 2));
-
-            if (sliceIndex >= startFrame && sliceIndex <= endFrame) {
-                float xPos = (float)(sliceIndex - startFrame) / (float)(endFrame - startFrame) * (float)width;
-                if (i == sliceSelected) {
-                    brush.setPen(QPen(selectedSliceColor, 2));
-                }
-
-                brush.drawLine(xPos, 0, xPos, height);
-            }
-        }
-    }
-
-    void WaveForm::drawSeeker() {
-        seeker.fill(waveformBgColor);
-        QPainter brush(&seeker);
-        brush.setPen(waveformColor);
-
-        currentSample.visualize(
-		brush,
-		QRect( 0, 0, seeker.width(), seeker.height() ),
-		0, currentSample.frames());
-
-        // draw slice points
-        brush.setPen(sliceColor);
-        for (int i = 0;i<slicePoints.size();i++) {
-            float xPos = (float)slicePoints[i] / (float)currentSample.frames() * (float)width;
-            brush.drawLine(xPos, 0, xPos, height);
-        }
-
-        // draw current playBack
-        brush.setPen(playColor);
-        // printf("noteplay index: %i\n", noteCurrent);
-        brush.drawLine(noteCurrent*width, 0, noteCurrent*width, height);
-        brush.fillRect(noteStart*width, 0, (noteEnd-noteStart)*width, height, playHighlighColor);
-
-        // draw seeker points
-        brush.setPen(QPen(seekerColor, 3));
-        brush.drawLine(seekerStart*width, 0, seekerStart*width, height);
-        brush.drawLine(seekerEnd*width, 0, seekerEnd*width, height);
-
-        // shadow on not selected area
-        brush.fillRect(0, 0, seekerStart*width, height, seekerShadowColor);
-        brush.fillRect(seekerEnd*width, 0, width, height, seekerShadowColor);
-    }
-
-    void WaveForm::updateUI() {
-        drawSeeker();
-        drawEditor();
-        update();
-    }
-
-    void WaveForm::updateData() {
-        printf("main data changed, updating sample and UI\n");
-        currentSample = SampleBuffer(slicerTParent->originalSample.data(), slicerTParent->originalSample.frames());
-        updateUI();
-    }
-
-
-    void WaveForm::isPlaying(float current, float start, float end) {
-        noteCurrent = current;
-        noteStart = start;
-        noteEnd = end;
-        drawSeeker();
-        update();
-    }
-
-    void WaveForm::mousePressEvent( QMouseEvent * _me ) {
-        float normalizedClick = (float)_me->x() / width;
-        
-        if (_me->button() == Qt::MouseButton::MiddleButton) {
-            seekerStart = 0;
-            seekerEnd = 1;
-            return;
-        }
-
-        if (_me->y() < height*seekerRatio) {
-            if (abs(normalizedClick - seekerStart) < 0.03) {
-                currentlyDragging = draggingTypes::seekerStart;
-
-            } else if (abs(normalizedClick - seekerEnd) < 0.03) {
-                currentlyDragging = draggingTypes::seekerEnd;
-
-            } else if (normalizedClick > seekerStart && normalizedClick < seekerEnd) {
-                currentlyDragging = draggingTypes::seekerMiddle;
-                seekerMiddle = normalizedClick;
-            }
-
-        } else {
-            sliceSelected = -1;
-            float startFrame = seekerStart * currentSample.frames();
-            float endFrame = seekerEnd * currentSample.frames();
-            
-            for (int i = 0;i<slicePoints.size();i++) {
-                int sliceIndex = slicePoints[i];
-                float xPos = (float)(sliceIndex - startFrame) / (float)(endFrame - startFrame);
-
-                if (abs(xPos - normalizedClick) < 0.03) {
-                    currentlyDragging = draggingTypes::slicePoint;
-                    sliceSelected = i;
-
-                }
-            }
-        } 
-
-        if (_me->button() == Qt::MouseButton::LeftButton) {
-            isDragging = true;
-
-        } else if (_me->button() == Qt::MouseButton::RightButton) {
-            if (sliceSelected != -1 && slicePoints.size() > 2) {
-                slicePoints.erase(slicePoints.begin() + sliceSelected);
-                sliceSelected = -1;
-            }
-        }  
-
-    }
-
-    void WaveForm::mouseReleaseEvent( QMouseEvent * _me ) {
-        isDragging = false;
-        currentlyDragging = draggingTypes::nothing;
-        updateUI();
-    }
-
-    void WaveForm::mouseMoveEvent( QMouseEvent * _me ) {
-        float normalizedClick = (float)_me->x() / width;
-        
-        // handle dragging events
-        if (isDragging) { 
-            // printf("drag type:%i , seekerStart: %f , seekerEnd: %f \n", currentlyDragging, seekerStart, seekerEnd);
-            if (currentlyDragging == draggingTypes::seekerStart) {
-                seekerStart = std::clamp(normalizedClick, 0.0f, seekerEnd - 0.13f);
-
-            } else if (currentlyDragging == draggingTypes::seekerEnd) {
-                seekerEnd = std::clamp(normalizedClick, seekerStart + 0.13f, 1.0f);;
-
-            } else if (currentlyDragging == draggingTypes::seekerMiddle) {
-                float distStart = seekerStart - seekerMiddle;
-                float distEnd = seekerEnd - seekerMiddle;
-
-                seekerMiddle = normalizedClick;
-
-                if (seekerMiddle + distStart > 0 && seekerMiddle + distEnd < 1) {
-                    seekerStart = seekerMiddle + distStart;
-                    seekerEnd = seekerMiddle + distEnd;
-                }
-
-            } else if (currentlyDragging == draggingTypes::slicePoint) {
-                float startFrame = seekerStart * currentSample.frames();
-                float endFrame = seekerEnd * currentSample.frames();
-
-                slicePoints[sliceSelected] = startFrame + normalizedClick * (endFrame - startFrame);
-
-                slicePoints[sliceSelected] = std::clamp(slicePoints[sliceSelected], 0, currentSample.frames());
-
-                std::sort(slicePoints.begin(), slicePoints.end());
-
-            }
-            updateUI();
-        } else {
-
-        }
-
-        
-
-    }
-
-    void WaveForm::mouseDoubleClickEvent(QMouseEvent * _me) {
-        float normalizedClick = (float)_me->x() / width;
-        float startFrame = seekerStart * currentSample.frames();
-        float endFrame = seekerEnd * currentSample.frames();
-
-        float slicePosition = startFrame + normalizedClick * (endFrame - startFrame);
-
-        for (int i = 0;i<slicePoints.size();i++) {
-            if (slicePoints[i] < slicePosition) {
-                slicePoints.insert(slicePoints.begin() + i, slicePosition);
-                break;
-            }
-        }
-
-        std::sort(slicePoints.begin(), slicePoints.end());
-        
-    }
-
-    // pianoView.cpp always claims focus while in plugin screen, so this doesnt work
-    void WaveForm::keyPressEvent(QKeyEvent * ke) {
-        int key = ke->key();
-        printf("key: %i\n", ke->key());
-        if ((key == 16777219 || key == 16777223) && // delete and backspace 
-            (sliceSelected != -1 && slicePoints.size() > 2)) {
-
-            slicePoints.erase(slicePoints.begin() + sliceSelected);
-        }
-        updateUI();
-
-    }
-
-    void WaveForm::paintEvent( QPaintEvent * _pe) {
-        QPainter p( this );
-        p.drawPixmap(0, height*0.3f + margin, sliceEditor);
-        p.drawPixmap(0, 0, seeker);
-    }
-}
-}
\ No newline at end of file
diff --git a/plugins/Slicer/WaveForm.h b/plugins/Slicer/WaveForm.h
deleted file mode 100644
index a63110c5e8a..00000000000
--- a/plugins/Slicer/WaveForm.h
+++ /dev/null
@@ -1,90 +0,0 @@
-#include <QApplication>
-#include <QFontMetrics>
-#include <QInputDialog>
-#include <QMouseEvent>
-#include <QPainter>
-
-#include "SampleBuffer.h"
-
-#ifndef WAVEFORM_H
-#define WAVEFORM_H
-
-namespace lmms
-{
-
-class SlicerT;
-
-namespace gui
-{
-
-
-class WaveForm : public QWidget {
-    	Q_OBJECT
-    protected:
-        virtual void mousePressEvent( QMouseEvent * _me );
-        virtual void mouseReleaseEvent( QMouseEvent * _me );
-        virtual void mouseMoveEvent( QMouseEvent * _me );
-        virtual void mouseDoubleClickEvent(QMouseEvent * _me);
-
-        virtual void keyPressEvent(QKeyEvent * ke);
-
-        virtual void paintEvent( QPaintEvent * _pe);
-
-    private:
-        int width;
-        int height;
-        float seekerRatio = 0.3f;
-        int margin = 5;
-        QColor waveformBgColor = QColor(11, 11, 11);
-        QColor waveformColor = QColor(124, 49, 214);
-        QColor playColor = QColor(255, 255, 255, 200);
-        QColor playHighlighColor = QColor(255, 255, 255, 70);
-        QColor sliceColor = QColor(49, 214, 124);
-        QColor selectedSliceColor = QColor(172, 236, 190);
-        QColor seekerColor = QColor(214, 124, 49);
-        QColor seekerShadowColor = QColor(0, 0, 0, 175);
-
-        enum class draggingTypes {
-            nothing,
-            seekerStart,
-            seekerEnd,
-            seekerMiddle,
-            slicePoint,
-        };
-        draggingTypes currentlyDragging;
-        bool isDragging = false;
-
-        float seekerStart = 0;
-        float seekerEnd = 1;
-        float seekerMiddle = 0.5f;
-        int sliceSelected = 0;
-
-        float noteCurrent;
-        float noteStart;
-        float noteEnd;
-
-        QPixmap sliceEditor;
-        QPixmap seeker;
-
-        SampleBuffer currentSample;
-
-        void drawEditor();
-        void drawSeeker();
-        void updateUI();
-
-    public slots:
-        void updateData();
-        void isPlaying(float current, float start, float end);
-
-    public:
-        WaveForm(int _w, int _h, SlicerT * _instrument, QWidget * _parent);
-
-    private:
-        SlicerT * slicerTParent;
-        std::vector<int> & slicePoints;
-
-};
-}}
-
-
-#endif
\ No newline at end of file
diff --git a/plugins/Slicer/logo.png b/plugins/Slicer/logo.png
deleted file mode 100644
index 2e84cba5a1377f9a65f4b1db243846c05b713dab..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1109
zcmeAS@N?(olHy`uVBq!ia0vp^1|ZDA3?vioaBc-sjKx9jP7LeL$-D$|I14-?iy0WW
zg+Z8+Vb&Z8pdfpRr>`sf4NgXJQJvX>d|!Zim;!u4T!B&}8T|kM|KEoPYk)xzQWE4B
z3=9-z7FITP4o)6kK7IiqVKH$DDQOv5Ie7&|WffI5bxkcDJ$(ZsV>5FbTRUercTX>G
zAOC>Bppe+Ogv8|3w9MSR{F2i0iptu$=C+QmNmCXqHI%PT1Dem6<n8VfI+<mMF#`ir
zj;D)bh{y50)3TFi8Hlv0DljQ8n>$-r|AKVTYt_};w_U!NXB7K(*S6We|JSFoOi<C-
zQ2X-dgQqRWlP697?z`|qmg13*{*{a!L53WjEKYTD9h+9YyucqDoGSR_DQjS(=;F+%
zX*W%@0&ey-q|`+-pC}M^-`yvosqx;vKjYpyN6TN~O)J7)99VLhgM-n7E9=6arLlpF
zg_@Q~mOOYZs_1g?|NIpf7yhigeqo930`tFT<n0e_?5^6W(zUechwdr;0&jgc2f<k~
z2Da;8bu9|Fd~o|hi^v9x2d9r;{?5++-p?|@bdy57qSTjoc{|=YlZDd-)ID@&ay^tW
zyYs`ZX)bf@Ql1CJ{p%*}=l}L1Z!X`Ty14tjFYG4FU1wS0_S{4H%-%caHzXgi_O0T)
zdal6g!)LMErY_Z<44cX_$}Ts`Z=Uz_n{Uhl1{Kk(IeR{roM{ma=`1t6_2zfwwiD0x
z2$maOo+^3Zi;}`2$>Xsz8FdcnrTOt2&-)|dIM-^*%*&JceQt?Pec4@e;H|XO%RORm
zJGWT2<jdtbKKt^7dC6grf;Gpk{bzFbR9HGaPH=<5YKEKcCP7kRj75x#m^tU3VS8q~
z>9Px>-t+FOzYLvO;^eNcK04<`;f1yG=XO=pJT7uNUR(9=-MyZ|evN<Ee9t^~coEdl
ze)E8(8MFV*UqUXNns)`GS(2}F%~`)BeD2EaH--1lvr&4kdQH4Gn00B<-r}wN6;Uz5
zhZ#7Z`%3X`{&jt!s_I-@f&OzxzE0Ctn>J5+=Dl~Z4JU&4-aUTUP}up-@@>18x9vZm
z`?`a3wX0b1{r8`b`8V%pdUGe>(P~!Sf0F`#aQn*cpRcO&&I6RsJzf1=);T3K0RVE&
BY2^R_


From efe1a7ec5ca39cbd67480ab5b5f2315624972539 Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Sat, 9 Sep 2023 08:33:39 +0200
Subject: [PATCH 14/99] Tried fixing multi slice playback (still broken)

---
 plugins/SlicerT/SlicerT.cpp | 41 ++++++++++++++++++-------------------
 1 file changed, 20 insertions(+), 21 deletions(-)

diff --git a/plugins/SlicerT/SlicerT.cpp b/plugins/SlicerT/SlicerT.cpp
index 1a510bc034c..1da5d4a1cc5 100644
--- a/plugins/SlicerT/SlicerT.cpp
+++ b/plugins/SlicerT/SlicerT.cpp
@@ -47,7 +47,7 @@ Plugin::Descriptor PLUGIN_EXPORT slicert_plugin_descriptor =
 	"SlicerT",
 	QT_TRANSLATE_NOOP( "PluginBrowser",
 				"Basic Slicer" ),
-	"Daniel Kauss Serna",
+	"Daniel Kauss Serna <daniel.kauss.serna/at/gmail.com>",
 	0x0100,
 	Plugin::Type::Instrument,
 	new PluginPixmapLoader( "logo" ),
@@ -71,36 +71,35 @@ void SlicerT::playNote( NotePlayHandle * handle, sampleFrame * workingBuffer ) {
 	if (m_originalSample.frames() < 2048) {
 		return;
 	}
-
 	const fpp_t frames = handle->framesLeftForCurrentPeriod();
 	const int playedFrames = handle->totalFramesPlayed();
 	const f_cnt_t offset = handle->noteOffset();
+	const int totalFrames = m_timeShiftedSample.frames();
+	
+	int sliceStart, sliceEnd;
+	float speedRatio = (float)m_originalBPM.value() / Engine::getSong()->getTempo() ;
+	int noteIndex = handle->key() - 69;
+	
+	// 0th element is no sound, so play full sample
+	if (noteIndex > m_slicePoints.size()-2 || noteIndex < 0) {
+		sliceStart = 0;
+		sliceEnd = totalFrames;
+	} else {
+		sliceStart = m_slicePoints[noteIndex] * speedRatio;
+		sliceEnd = m_slicePoints[noteIndex+1] * speedRatio;
+	}
 	
-	int totalFrames = m_timeShiftedSample.frames();
-	int sliceStart = m_timeShiftedSample.startFrame();
-	int sliceEnd = m_timeShiftedSample.endFrame();
-	int sliceFrames = m_timeShiftedSample.endFrame() - m_timeShiftedSample.startFrame();
+	int sliceFrames = sliceEnd - sliceStart;
 	int noteFramesLeft = sliceFrames - playedFrames;
 
+	// pretty sure this causes issues when playing multipple slices at once
+	m_timeShiftedSample.setAllPointFrames( sliceStart, sliceEnd, sliceStart, sliceEnd );
+
 	// init NotePlayHandle data
 	if( !handle->m_pluginData )
 	{
 		handle->m_pluginData = new SampleBuffer::handleState( false, SRC_LINEAR );
-
-		float speedRatio = (float)m_originalBPM.value() / Engine::getSong()->getTempo() ;
-		int noteIndex = handle->key() - 69;
-		int sliceStart, sliceEnd;
-		
-		// 0th element is no sound, so play full sample
-		if (noteIndex > m_slicePoints.size()-2 || noteIndex < 0) {
-			sliceStart = 0;
-			sliceEnd = m_timeShiftedSample.frames();
-		} else {
-			sliceStart = m_slicePoints[noteIndex] * speedRatio;
-			sliceEnd = m_slicePoints[noteIndex+1] * speedRatio;
-		}
-
-		m_timeShiftedSample.setAllPointFrames( sliceStart, sliceEnd, sliceStart, sliceEnd );
+		((SampleBuffer::handleState *)handle->m_pluginData)->setFrameIndex( sliceStart );
 	}
 
 	if( ! handle->isFinished() ) {

From 6bda6dfcf228ac7d629287ab03f012b3d0f78815 Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Sat, 9 Sep 2023 08:39:47 +0200
Subject: [PATCH 15/99] remove includes, add license

---
 plugins/SlicerT/SlicerT.cpp   |  2 +-
 plugins/SlicerT/SlicerTUI.cpp | 25 ++++++++++++++++++++++++-
 plugins/SlicerT/SlicerTUI.h   | 25 ++++++++++++++++++++++++-
 plugins/SlicerT/WaveForm.cpp  | 28 ++++++++++++++++++++++++----
 plugins/SlicerT/WaveForm.h    | 24 ++++++++++++++++++++++++
 5 files changed, 97 insertions(+), 7 deletions(-)

diff --git a/plugins/SlicerT/SlicerT.cpp b/plugins/SlicerT/SlicerT.cpp
index 1da5d4a1cc5..f7d33eb7ccf 100644
--- a/plugins/SlicerT/SlicerT.cpp
+++ b/plugins/SlicerT/SlicerT.cpp
@@ -23,7 +23,7 @@
  */
 
 #include "SlicerT.h"
-#include <stdio.h>
+
 #include <fftw3.h>
 #include <QDomElement>
 
diff --git a/plugins/SlicerT/SlicerTUI.cpp b/plugins/SlicerT/SlicerTUI.cpp
index 8ee2e79b28d..ba3e1c59df9 100644
--- a/plugins/SlicerT/SlicerTUI.cpp
+++ b/plugins/SlicerT/SlicerTUI.cpp
@@ -1,7 +1,30 @@
+/*
+ * SlicerTUI.cpp - controls the UI for slicerT
+ *
+ * Copyright (c) 2006-2008 Andreas Brandmaier <andy/at/brandmaier/dot/de>
+ * 
+ * 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 "SlicerTUI.h"
 #include "SlicerT.h"
 
-#include <stdio.h>
 #include <QFileInfo>
 #include <QDropEvent>
 
diff --git a/plugins/SlicerT/SlicerTUI.h b/plugins/SlicerT/SlicerTUI.h
index 4bd77ba5267..a0234cf096a 100644
--- a/plugins/SlicerT/SlicerTUI.h
+++ b/plugins/SlicerT/SlicerTUI.h
@@ -1,6 +1,29 @@
+/*
+ * SlicerTUI.h - declaration of class SlicerTUI
+ *
+ * Copyright (c) 2006-2008 Andreas Brandmaier <andy/at/brandmaier/dot/de>
+ * 
+ * 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 "WaveForm.h"
 
-#include <stdio.h>
 #include <QPushButton>
 
 #include "Instrument.h"
diff --git a/plugins/SlicerT/WaveForm.cpp b/plugins/SlicerT/WaveForm.cpp
index 9257cd9bccf..e72b737a6da 100644
--- a/plugins/SlicerT/WaveForm.cpp
+++ b/plugins/SlicerT/WaveForm.cpp
@@ -1,7 +1,30 @@
+/*
+ * WaveForm.cpp - slice editor for SlicerT
+ *
+ * Copyright (c) 2006-2008 Andreas Brandmaier <andy/at/brandmaier/dot/de>
+ * 
+ * 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 "WaveForm.h"
 #include "SlicerT.h"
 
-#include <stdio.h>
 
 namespace lmms
 {
@@ -86,7 +109,6 @@ namespace gui
 
         // draw current playBack
         brush.setPen(m_playColor);
-        // printf("noteplay index: %i\n", m_noteCurrent);
         brush.drawLine(m_noteCurrent*m_width, 0, m_noteCurrent*m_width, m_height);
         brush.fillRect(m_noteStart*m_width, 0, (m_noteEnd-m_noteStart)*m_width, m_height, m_playHighlighColor);
 
@@ -107,7 +129,6 @@ namespace gui
     }
 
     void WaveForm::updateData() {
-        printf("main data changed, updating sample and UI\n");
         m_currentSample = SampleBuffer(m_slicerTParent->m_originalSample.data(), m_slicerTParent->m_originalSample.frames());
         updateUI();
     }
@@ -182,7 +203,6 @@ namespace gui
         
         // handle dragging events
         if (m_isDragging) { 
-            // printf("drag type:%i , m_seekerStart: %f , m_seekerEnd: %f \n", m_currentlyDragging, m_seekerStart, m_seekerEnd);
             if (m_currentlyDragging == m_draggingTypes::m_seekerStart) {
                 m_seekerStart = std::clamp(normalizedClick, 0.0f, m_seekerEnd - 0.13f);
 
diff --git a/plugins/SlicerT/WaveForm.h b/plugins/SlicerT/WaveForm.h
index dd448025a8a..34e0120a945 100644
--- a/plugins/SlicerT/WaveForm.h
+++ b/plugins/SlicerT/WaveForm.h
@@ -1,3 +1,27 @@
+/*
+ * WaveForm.h - declaration of class WaveForm
+ *
+ * Copyright (c) 2006-2008 Andreas Brandmaier <andy/at/brandmaier/dot/de>
+ * 
+ * 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 <QApplication>
 #include <QFontMetrics>
 #include <QInputDialog>

From d13ca1a0b70e608798c28d0b22f2d456ee61ba43 Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Sat, 9 Sep 2023 09:17:47 +0200
Subject: [PATCH 16/99] code factoring issues

---
 plugins/SlicerT/SlicerT.cpp   | 8 +-------
 plugins/SlicerT/SlicerTUI.cpp | 2 --
 plugins/SlicerT/SlicerTUI.h   | 5 ++---
 plugins/SlicerT/WaveForm.cpp  | 8 --------
 plugins/SlicerT/WaveForm.h    | 2 +-
 5 files changed, 4 insertions(+), 21 deletions(-)

diff --git a/plugins/SlicerT/SlicerT.cpp b/plugins/SlicerT/SlicerT.cpp
index f7d33eb7ccf..7cd28ad961e 100644
--- a/plugins/SlicerT/SlicerT.cpp
+++ b/plugins/SlicerT/SlicerT.cpp
@@ -323,7 +323,6 @@ void SlicerT::phaseVocoder(std::vector<float> &dataIn, std::vector<float> &dataO
 
 		// analysis step
 		for (int j = 0; j < windowSize; j++) {
-			
 			real = FFTSpectrum[j][0];
 			imag = FFTSpectrum[j][1];
 
@@ -347,9 +346,7 @@ void SlicerT::phaseVocoder(std::vector<float> &dataIn, std::vector<float> &dataO
 
 			allMagnitudes[j] = magnitude;
 			allFrequencies[j] = freq;
-
 		}
-		
 		// pitch shifting
 		// takes all the values that are below the nyquist frequency (representable with our samplerate)
 		// nyquist frequency = samplerate / 2
@@ -390,7 +387,6 @@ void SlicerT::phaseVocoder(std::vector<float> &dataIn, std::vector<float> &dataO
 
 		// windowing
 		for (int j = 0; j < windowSize; j++) {
-
 			float outIndex = i * outStepSize + j;
 			if (outIndex > outFrames) {
 				break;
@@ -492,8 +488,8 @@ void SlicerT::saveSettings(QDomDocument & document, QDomElement & element) {
 	m_fadeOutFrames.saveSettings(document, element, "fadeOut");
 	m_noteThreshold.saveSettings(document, element, "threshold");
 	m_originalBPM.saveSettings(document, element, "origBPM");
-
 }
+
 void SlicerT::loadSettings( const QDomElement & element ) {
 	if (!element.attribute("src").isEmpty())
 	{
@@ -515,7 +511,6 @@ void SlicerT::loadSettings( const QDomElement & element ) {
 		int totalSlices = element.attribute("totalSlices").toInt();
 		m_slicePoints = {};
 		for (int i = 0;i<totalSlices;i++) {
-			
 			m_slicePoints.push_back(element.attribute(tr("slice_%1").arg(i)).toInt());
 		}
 	}
@@ -543,7 +538,6 @@ gui::PluginView * SlicerT::instantiateView( QWidget * parent )
 
 extern "C"
 {
-
 // necessary for getting instance out of shared lib
 PLUGIN_EXPORT Plugin * lmms_plugin_main( Model *m, void * )
 {
diff --git a/plugins/SlicerT/SlicerTUI.cpp b/plugins/SlicerT/SlicerTUI.cpp
index ba3e1c59df9..c83d7cfa262 100644
--- a/plugins/SlicerT/SlicerTUI.cpp
+++ b/plugins/SlicerT/SlicerTUI.cpp
@@ -116,7 +116,6 @@ void SlicerTUI::exportMidi() {
 	}
 
 	copyString( dataFile.toString(), MimeType::Default );
-
 }
 
 // all the drag stuff is copied from AudioFileProcessor
@@ -147,7 +146,6 @@ void SlicerTUI::dragEnterEvent( QDragEnterEvent * dee )
 	{
 		dee->ignore();
 	}
-
 }
 
 void SlicerTUI::dropEvent( QDropEvent * de ) {
diff --git a/plugins/SlicerT/SlicerTUI.h b/plugins/SlicerT/SlicerTUI.h
index a0234cf096a..ed4689325dc 100644
--- a/plugins/SlicerT/SlicerTUI.h
+++ b/plugins/SlicerT/SlicerTUI.h
@@ -47,6 +47,7 @@ namespace gui
 class SlicerTUI : public InstrumentViewFixedSize
 {
 	Q_OBJECT
+	
 public:
 	SlicerTUI( SlicerT * instrument,
 					QWidget * parent );
@@ -72,9 +73,7 @@ protected slots:
 	QPushButton m_midiExportButton;
 
 	WaveForm m_wf;
-
-
-} ;
+};
 
 
 } // namespace gui
diff --git a/plugins/SlicerT/WaveForm.cpp b/plugins/SlicerT/WaveForm.cpp
index e72b737a6da..6a6fcde6c24 100644
--- a/plugins/SlicerT/WaveForm.cpp
+++ b/plugins/SlicerT/WaveForm.cpp
@@ -175,7 +175,6 @@ namespace gui
                 if (abs(xPos - normalizedClick) < 0.03) {
                     m_currentlyDragging = m_draggingTypes::slicePoint;
                     m_sliceSelected = i;
-
                 }
             }
         } 
@@ -229,15 +228,9 @@ namespace gui
                 m_slicePoints[m_sliceSelected] = std::clamp(m_slicePoints[m_sliceSelected], 0, m_currentSample.frames());
 
                 std::sort(m_slicePoints.begin(), m_slicePoints.end());
-
             }
             updateUI();
-        } else {
-
         }
-
-        
-
     }
 
     void WaveForm::mouseDoubleClickEvent(QMouseEvent * me) {
@@ -255,7 +248,6 @@ namespace gui
         }
 
         std::sort(m_slicePoints.begin(), m_slicePoints.end());
-        
     }
 
     void WaveForm::paintEvent( QPaintEvent * pe) {
diff --git a/plugins/SlicerT/WaveForm.h b/plugins/SlicerT/WaveForm.h
index 34e0120a945..611e7b463e4 100644
--- a/plugins/SlicerT/WaveForm.h
+++ b/plugins/SlicerT/WaveForm.h
@@ -44,6 +44,7 @@ namespace gui
 
 class WaveForm : public QWidget {
     	Q_OBJECT
+
     protected:
         virtual void mousePressEvent(QMouseEvent * me);
         virtual void mouseReleaseEvent(QMouseEvent * me);
@@ -104,7 +105,6 @@ class WaveForm : public QWidget {
     private:
         SlicerT * m_slicerTParent;
         std::vector<int> & m_slicePoints;
-
 };
 }}
 

From 6482c16636091b42e3105581a8df27fbf0d02106 Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Sat, 9 Sep 2023 09:21:13 +0200
Subject: [PATCH 17/99] more code factoring

---
 plugins/SlicerT/SlicerT.h     | 1 +
 plugins/SlicerT/SlicerTUI.cpp | 3 ---
 plugins/SlicerT/WaveForm.cpp  | 3 ---
 3 files changed, 1 insertion(+), 6 deletions(-)

diff --git a/plugins/SlicerT/SlicerT.h b/plugins/SlicerT/SlicerT.h
index 745a1e44843..41fe486eaf8 100644
--- a/plugins/SlicerT/SlicerT.h
+++ b/plugins/SlicerT/SlicerT.h
@@ -41,6 +41,7 @@ namespace lmms
 
 class SlicerT : public Instrument{
 	Q_OBJECT
+	
 	public:
 		SlicerT(InstrumentTrack * instrumentTrack);
 		~SlicerT() override = default;
diff --git a/plugins/SlicerT/SlicerTUI.cpp b/plugins/SlicerT/SlicerTUI.cpp
index c83d7cfa262..88d44fa81eb 100644
--- a/plugins/SlicerT/SlicerTUI.cpp
+++ b/plugins/SlicerT/SlicerTUI.cpp
@@ -88,9 +88,6 @@ SlicerTUI::SlicerTUI( SlicerT * instrument,
 	m_resetButton.move(70, 200);
 	m_resetButton.setToolTip(tr("Reset Slices"));
 	connect(&m_resetButton, SIGNAL( clicked() ), m_slicerTParent, SLOT( updateSlices() ));
-
-
-
 }
 
 // copied from piano roll
diff --git a/plugins/SlicerT/WaveForm.cpp b/plugins/SlicerT/WaveForm.cpp
index 6a6fcde6c24..dfed512ae9f 100644
--- a/plugins/SlicerT/WaveForm.cpp
+++ b/plugins/SlicerT/WaveForm.cpp
@@ -39,8 +39,6 @@ namespace gui
         m_currentSample(instrument->m_originalSample.data(), instrument->m_originalSample.frames()),
         m_slicePoints(instrument->m_slicePoints)
         {
-            
-
             m_width = w;
             m_height = h;
             m_slicerTParent = instrument;
@@ -178,7 +176,6 @@ namespace gui
                 }
             }
         } 
-
         if (me->button() == Qt::MouseButton::LeftButton) {
             m_isDragging = true;
 

From 5df2b894cde36cf4da3b5bee25e89512f4ed5171 Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Sun, 10 Sep 2023 13:46:32 +0200
Subject: [PATCH 18/99] fixed multinote playback and bpm check

---
 plugins/SlicerT/SlicerT.cpp   | 132 +++++++++++++++++-----------------
 plugins/SlicerT/SlicerT.h     |  38 ++++++++--
 plugins/SlicerT/SlicerTUI.cpp |   9 ++-
 plugins/SlicerT/SlicerTUI.h   |  12 ++--
 plugins/SlicerT/WaveForm.cpp  |   4 +-
 plugins/SlicerT/WaveForm.h    |  12 ++--
 6 files changed, 116 insertions(+), 91 deletions(-)

diff --git a/plugins/SlicerT/SlicerT.cpp b/plugins/SlicerT/SlicerT.cpp
index 7cd28ad961e..e0217ce3dff 100644
--- a/plugins/SlicerT/SlicerT.cpp
+++ b/plugins/SlicerT/SlicerT.cpp
@@ -22,6 +22,9 @@
  *
  */
 
+// TODO: add fft cache, maybe this is overkill but whatever
+// TODO: optimize waveform a LOT, mostly during playback
+
 #include "SlicerT.h"
 
 #include <fftw3.h>
@@ -56,14 +59,13 @@ Plugin::Descriptor PLUGIN_EXPORT slicert_plugin_descriptor =
 } ;
 } // end extern
 
+
 SlicerT::SlicerT(InstrumentTrack * instrumentTrack) : 
 	Instrument( instrumentTrack, &slicert_plugin_descriptor ),
 	m_noteThreshold(0.6f, 0.0f, 2.0f, 0.01f, this, tr( "Note threshold" ) ),
 	m_fadeOutFrames(0.0f, 0.0f, 8192.0f, 4.0f, this, tr("FadeOut")),
 	m_originalBPM(1, 1, 999, this, tr("Original bpm")),
-
-	m_originalSample(),
-	m_timeShiftedSample()
+	m_originalSample()
 {}
 
 
@@ -71,16 +73,18 @@ void SlicerT::playNote( NotePlayHandle * handle, sampleFrame * workingBuffer ) {
 	if (m_originalSample.frames() < 2048) {
 		return;
 	}
+	const float speedRatio = (float)m_originalBPM.value() / Engine::getSong()->getTempo() ;
+	const int noteIndex = handle->key() - 69;
 	const fpp_t frames = handle->framesLeftForCurrentPeriod();
-	const int playedFrames = handle->totalFramesPlayed();
 	const f_cnt_t offset = handle->noteOffset();
+	const int playedFrames = handle->totalFramesPlayed();
+
+	if (m_currentSpeedRatio != speedRatio) {
+		timeShiftSample();
+	}
 	const int totalFrames = m_timeShiftedSample.frames();
-	
+
 	int sliceStart, sliceEnd;
-	float speedRatio = (float)m_originalBPM.value() / Engine::getSong()->getTempo() ;
-	int noteIndex = handle->key() - 69;
-	
-	// 0th element is no sound, so play full sample
 	if (noteIndex > m_slicePoints.size()-2 || noteIndex < 0) {
 		sliceStart = 0;
 		sliceEnd = totalFrames;
@@ -90,51 +94,37 @@ void SlicerT::playNote( NotePlayHandle * handle, sampleFrame * workingBuffer ) {
 	}
 	
 	int sliceFrames = sliceEnd - sliceStart;
+	int currentNoteFrame = sliceStart + playedFrames;
 	int noteFramesLeft = sliceFrames - playedFrames;
 
-	// pretty sure this causes issues when playing multipple slices at once
-	m_timeShiftedSample.setAllPointFrames( sliceStart, sliceEnd, sliceStart, sliceEnd );
 
-	// init NotePlayHandle data
-	if( !handle->m_pluginData )
-	{
-		handle->m_pluginData = new SampleBuffer::handleState( false, SRC_LINEAR );
-		((SampleBuffer::handleState *)handle->m_pluginData)->setFrameIndex( sliceStart );
-	}
-
-	if( ! handle->isFinished() ) {
-		if( m_timeShiftedSample.play( workingBuffer + offset,
-					(SampleBuffer::handleState *)handle->m_pluginData,
-					frames, 440,
-					static_cast<SampleBuffer::LoopMode>( 0 ) ) )
-		{
-			// exponential fade out, applyRelease kinda sucks
-			if (noteFramesLeft < m_fadeOutFrames.value()) {
-				for (int i = 0;i<frames;i++) {
-					float fadeValue = (float)(noteFramesLeft-i) / m_fadeOutFrames.value();
-					// if the workingbuffer extends the sample
-					fadeValue = std::clamp(fadeValue, 0.0f, 1.0f);
-					fadeValue = pow(fadeValue, 2);
-
-					workingBuffer[i][0] *= fadeValue;
-					workingBuffer[i][1] *= fadeValue;
-				}
-			}
+	if( noteFramesLeft > 0) {
+		int bufferSize = frames * BYTES_PER_FRAME;
+		memcpy(workingBuffer + offset, m_timeShiftedSample.data() + currentNoteFrame, bufferSize);
 
-			instrumentTrack()->processAudioBuffer( workingBuffer,
-									frames + offset, handle );
+		// exponential fade out, applyRelease kinda sucks
+		if (noteFramesLeft < m_fadeOutFrames.value()) {
+			for (int i = 0;i<frames;i++) {
+				float fadeValue = (float)(noteFramesLeft-i) / m_fadeOutFrames.value();
+				// if the workingbuffer extends the sample
+				fadeValue = std::clamp(fadeValue, 0.0f, 1.0f);
+				fadeValue = pow(fadeValue, 2);
 
+				workingBuffer[i][0] *= fadeValue;
+				workingBuffer[i][1] *= fadeValue;
+			}
+		}
 
-			float absoluteCurrentNote = (float)(sliceStart + playedFrames) / totalFrames;
-			float absoluteStartNote = (float)sliceStart / totalFrames;
-			float abslouteEndNote = (float)sliceEnd / totalFrames;
-			emit isPlaying(absoluteCurrentNote, absoluteStartNote, abslouteEndNote);
+		instrumentTrack()->processAudioBuffer( workingBuffer, frames + offset, handle );
 
-		} else {
-			emit isPlaying(0, 0, 0);			
-		}
+		// !! disabled until it is optimized, because it lags the whole ui
+		// calculate absolute for the waveform
+		// float absoluteCurrentNote = (float)currentNoteFrame / totalFrames;
+		// float absoluteStartNote = (float)sliceStart / totalFrames;
+		// float abslouteEndNote = (float)sliceEnd / totalFrames;
+		// emit isPlaying(absoluteCurrentNote, absoluteStartNote, abslouteEndNote);
 	} else {
-		emit isPlaying(0, 0, 0);
+		// emit isPlaying(0, 0, 0);
 	}
 }
 
@@ -146,7 +136,7 @@ void SlicerT::findSlices() {
 	m_slicePoints = {};
 
 	const int window = 1024;
-	int minWindowsPassed = 0;
+	int minWindowsPassed = 1;
 	int peakIndex = 0;
 
 	float lastPeak = 0;
@@ -181,7 +171,7 @@ void SlicerT::findBPM() {
 	if (m_originalSample.frames() < 2048) {
 		return;
 	}
-	int bpmSnap = 1;
+	int bpmSnap = 1; // 1 = disabled
 
 	float sampleRate = m_originalSample.sampleRate();
 	float totalFrames = m_originalSample.frames();
@@ -210,23 +200,29 @@ void SlicerT::findBPM() {
 
 // create timeshifted samplebuffer and timeshifted m_slicePoints
 void SlicerT::timeShiftSample() {
+	using std::vector;
+	// initial checks
 	if (m_originalSample.frames() < 2048) {
 		return;
 	}
-	using std::vector;
+	if (m_timeshiftLock) { // needed
+		return;
+	}
+	m_timeshiftLock = true;
+	
 
 	// original sample data
 	float sampleRate = m_originalSample.sampleRate();
 	int originalFrames = m_originalSample.frames();
 
-	// target data TODO: fix this mess
 	bpm_t targetBPM = Engine::getSong()->getTempo();
-	float speedRatio = (float)m_originalBPM.value() / targetBPM ;
-	int outFrames = speedRatio * originalFrames;
+	m_currentSpeedRatio = (float)m_originalBPM.value() / targetBPM ;
+	int outFrames = m_currentSpeedRatio * originalFrames;
 
 	// nothing to do here
 	if (targetBPM == m_originalBPM.value()) {
-		m_timeShiftedSample = SampleBuffer(m_originalSample.data(), m_originalSample.frames());
+		m_timeShiftedSample.setData(m_originalSample.data(), m_originalSample.frames());
+		m_timeshiftLock = false;
 		return;
 	}
 
@@ -243,18 +239,15 @@ void SlicerT::timeShiftSample() {
 		rawDataL[i] = (float)m_originalSample.data()[i][0];
 		rawDataR[i] = (float)m_originalSample.data()[i][1];
 	}
+
 	// process channels
 	phaseVocoder(rawDataL, outDataL, sampleRate, 1);
 	phaseVocoder(rawDataR, outDataR, sampleRate, 1);
 
 	// write processed channels 
-	for (int i = 0;i<outFrames;i++) {
-		bufferData.data()[i][0] = outDataL[i];
-		bufferData.data()[i][1] = outDataR[i];
-	}
+	m_timeShiftedSample.setData(outDataL, outDataR);
 
-	// new sample
-	m_timeShiftedSample = SampleBuffer(bufferData.data(), bufferData.size());
+	m_timeshiftLock = false;
 }
 
 // basic phase vocoder implementation that time shifts without pitch change
@@ -317,8 +310,12 @@ void SlicerT::phaseVocoder(std::vector<float> &dataIn, std::vector<float> &dataO
 	for (int i = 0;i < numWindows-overSampling;i++) {
 		windowIndex = i * stepSize;
 
-		// FFT
 		memcpy(FFTInput.data(), dataIn.data() + windowIndex, windowSize*sizeof(float));
+
+		// int hash = hashFttWindow(FFTInput);
+		// printf("%i\n", hash);
+
+		// FFT
 		fftwf_execute(fftPlan);
 
 		// analysis step
@@ -424,12 +421,20 @@ void SlicerT::phaseVocoder(std::vector<float> &dataIn, std::vector<float> &dataO
 	memcpy(dataOut.data(), outBuffer.data(), outFrames*sizeof(float));
 }
 
+int SlicerT::hashFttWindow(std::vector<float> & in) {
+	int hash = 0;
+	for (float value : in) {
+		hash += (324723947 + (int)(value * 10689354)) ^ 93485734985;;
+	}
+	return hash;
+}
+
 void SlicerT::writeToMidi(std::vector<Note> * outClip) {
 	if (m_originalSample.frames() < 2048) {
 		return;
 	}
 	int ticksPerBar = DefaultTicksPerBar;
-	float sampleRate = m_timeShiftedSample.sampleRate();
+	float sampleRate = m_originalSample.sampleRate();
 
 	float bpm = Engine::getSong()->getTempo();
 	float samplesPerBeat = 60.0f / bpm * sampleRate;
@@ -466,11 +471,6 @@ void SlicerT::updateSlices() {
 	findSlices();
 }
 
-void SlicerT::updateTimeShift() {
-	timeShiftSample();
-}
-
-
 void SlicerT::saveSettings(QDomDocument & document, QDomElement & element) {
 	element.setAttribute("src", m_originalSample.audioFile());
 	if (m_originalSample.audioFile().isEmpty())
diff --git a/plugins/SlicerT/SlicerT.h b/plugins/SlicerT/SlicerT.h
index 41fe486eaf8..a6e6f36bbfa 100644
--- a/plugins/SlicerT/SlicerT.h
+++ b/plugins/SlicerT/SlicerT.h
@@ -39,6 +39,32 @@
 namespace lmms
 {
 
+// small helper class, since SampleBuffer is inadequate (not thread safe, no dinamic startpoint)
+class PlaybackBuffer {
+	public:
+		std::vector<sampleFrame> mainBuffer;
+
+		int frames() { return mainBuffer.size(); };
+		sampleFrame * data() { return mainBuffer.data(); };
+
+		void setData(const sampleFrame * data, int newFrames) 
+		{
+			mainBuffer = {};
+			mainBuffer.resize(newFrames); 
+			memcpy(mainBuffer.data(), data, newFrames * sizeof(sampleFrame));
+		};
+		void setData(std::vector<float> & leftData, std::vector<float> & rightData) {
+			int newFrames = std::min(leftData.size(), rightData.size());
+			mainBuffer = {};
+			mainBuffer.resize(newFrames);
+
+			for (int i = 0;i < newFrames;i++) {
+				mainBuffer[i][0] = leftData[i];
+				mainBuffer[i][1] = rightData[i];
+			}
+		}
+};
+
 class SlicerT : public Instrument{
 	Q_OBJECT
 	
@@ -70,17 +96,21 @@ class SlicerT : public Instrument{
 		IntModel m_originalBPM;
 
 		SampleBuffer m_originalSample;
-		SampleBuffer m_timeShiftedSample;
+		PlaybackBuffer m_timeShiftedSample;
 		std::vector<int> m_slicePoints;
 		
+		float m_currentSpeedRatio = 0;
+		bool m_timeshiftLock; // dont run timeshifting at the same time, instant crash
+		// std::unordered_map<int, std::vector<float> > m_fftWindowCache;
+
 		void findSlices();
 		void findBPM();
 		void timeShiftSample();
 		void phaseVocoder(std::vector<float> &in, std::vector<float> &out, float sampleRate, float pitchScale);
+		int hashFttWindow(std::vector<float> & in);
 
 		friend class gui::SlicerTUI;
 		friend class gui::WaveForm;
 };
-}
-
-#endif
+} // namespace lmms
+#endif // SLICERT_H
diff --git a/plugins/SlicerT/SlicerTUI.cpp b/plugins/SlicerT/SlicerTUI.cpp
index 88d44fa81eb..1602e847f86 100644
--- a/plugins/SlicerT/SlicerTUI.cpp
+++ b/plugins/SlicerT/SlicerTUI.cpp
@@ -66,10 +66,11 @@ SlicerTUI::SlicerTUI( SlicerT * instrument,
 	m_bpmBox.setToolTip(tr("Original sample BPM"));
 	m_bpmBox.setLabel(tr("BPM"));
 	m_bpmBox.setModel(&m_slicerTParent->m_originalBPM);
+	// connect(&m_bpmBox, SIGNAL( manualChange() ), m_slicerTParent, SLOT( updateTimeShift() ), Qt::QueuedConnection);
 
 	m_timeShiftButton.move(70, 150);
 	m_timeShiftButton.setToolTip(tr("Timeshift sample"));
-	connect(&m_timeShiftButton, SIGNAL( clicked() ), m_slicerTParent, SLOT( updateTimeShift() ));
+	// connect(&m_timeShiftButton, SIGNAL( clicked() ), m_slicerTParent, SLOT( updateTimeShift() ), Qt::QueuedConnection);
 
 	m_fadeOutKnob.move(200, 150);
 	m_fadeOutKnob.setToolTip(tr("FadeOut for notes"));
@@ -166,7 +167,5 @@ void SlicerTUI::dropEvent( QDropEvent * de ) {
 
 	de->ignore();
 }
-}
-}
-
-
+} // namespace gui
+} // namespace lmms
\ No newline at end of file
diff --git a/plugins/SlicerT/SlicerTUI.h b/plugins/SlicerT/SlicerTUI.h
index ed4689325dc..11a238ac01f 100644
--- a/plugins/SlicerT/SlicerTUI.h
+++ b/plugins/SlicerT/SlicerTUI.h
@@ -22,6 +22,9 @@
  *
  */
 
+#ifndef SLICERT_UI_H
+#define SLICERT_UI_H
+
 #include "WaveForm.h"
 
 #include <QPushButton>
@@ -32,9 +35,6 @@
 #include "LcdSpinBox.h"
 
 
-#ifndef SLICERT_UI_H
-#define SLICERT_UI_H
-
 namespace lmms
 {
 
@@ -74,10 +74,6 @@ protected slots:
 
 	WaveForm m_wf;
 };
-
-
 } // namespace gui
-
 } // namespace lmms
-
-#endif
\ No newline at end of file
+#endif // SLICERT_UI_H
\ No newline at end of file
diff --git a/plugins/SlicerT/WaveForm.cpp b/plugins/SlicerT/WaveForm.cpp
index dfed512ae9f..d5bdc261ac1 100644
--- a/plugins/SlicerT/WaveForm.cpp
+++ b/plugins/SlicerT/WaveForm.cpp
@@ -252,5 +252,5 @@ namespace gui
         p.drawPixmap(0, m_height*0.3f + m_margin, m_sliceEditor);
         p.drawPixmap(0, 0, m_seeker);
     }
-}
-}
\ No newline at end of file
+} // namespace gui
+} // namespace lmms
\ No newline at end of file
diff --git a/plugins/SlicerT/WaveForm.h b/plugins/SlicerT/WaveForm.h
index 611e7b463e4..46bba6e6b2a 100644
--- a/plugins/SlicerT/WaveForm.h
+++ b/plugins/SlicerT/WaveForm.h
@@ -22,6 +22,9 @@
  *
  */
 
+#ifndef WAVEFORM_H
+#define WAVEFORM_H
+
 #include <QApplication>
 #include <QFontMetrics>
 #include <QInputDialog>
@@ -30,8 +33,6 @@
 
 #include "SampleBuffer.h"
 
-#ifndef WAVEFORM_H
-#define WAVEFORM_H
 
 namespace lmms
 {
@@ -106,7 +107,6 @@ class WaveForm : public QWidget {
         SlicerT * m_slicerTParent;
         std::vector<int> & m_slicePoints;
 };
-}}
-
-
-#endif
\ No newline at end of file
+} // namespace gui
+} // namespace lmms
+#endif // WAVEFORM_H
\ No newline at end of file

From 6b7e442039772cb0aebe7601cf913ef72128f698 Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Sun, 10 Sep 2023 18:06:22 +0200
Subject: [PATCH 19/99] UI performance improvments + code style

---
 plugins/SlicerT/SlicerT.cpp   | 126 ++++++++++++++++++----------------
 plugins/SlicerT/SlicerT.h     |  18 ++---
 plugins/SlicerT/SlicerTUI.cpp |  15 ++--
 plugins/SlicerT/SlicerTUI.h   |   5 +-
 plugins/SlicerT/WaveForm.cpp  | 111 +++++++++++++++++++-----------
 plugins/SlicerT/WaveForm.h    |   8 ++-
 6 files changed, 159 insertions(+), 124 deletions(-)

diff --git a/plugins/SlicerT/SlicerT.cpp b/plugins/SlicerT/SlicerT.cpp
index e0217ce3dff..d93be93da3d 100644
--- a/plugins/SlicerT/SlicerT.cpp
+++ b/plugins/SlicerT/SlicerT.cpp
@@ -2,7 +2,7 @@
  * SlicerT.cpp - simple slicer plugin
  *
  * Copyright (c) 2006-2008 Andreas Brandmaier <andy/at/brandmaier/dot/de>
- * 
+ *
  * This file is part of LMMS - https://lmms.io
  *
  * This program is free software; you can redistribute it and/or
@@ -22,8 +22,9 @@
  *
  */
 
+// TODO: fade in mode
+// TODO: general UI improvements, maybe open folders button
 // TODO: add fft cache, maybe this is overkill but whatever
-// TODO: optimize waveform a LOT, mostly during playback
 
 #include "SlicerT.h"
 
@@ -60,7 +61,7 @@ Plugin::Descriptor PLUGIN_EXPORT slicert_plugin_descriptor =
 } // end extern
 
 
-SlicerT::SlicerT(InstrumentTrack * instrumentTrack) : 
+SlicerT::SlicerT(InstrumentTrack * instrumentTrack) :
 	Instrument( instrumentTrack, &slicert_plugin_descriptor ),
 	m_noteThreshold(0.6f, 0.0f, 2.0f, 0.01f, this, tr( "Note threshold" ) ),
 	m_fadeOutFrames(0.0f, 0.0f, 8192.0f, 4.0f, this, tr("FadeOut")),
@@ -70,35 +71,37 @@ SlicerT::SlicerT(InstrumentTrack * instrumentTrack) :
 
 
 void SlicerT::playNote( NotePlayHandle * handle, sampleFrame * workingBuffer ) {
-	if (m_originalSample.frames() < 2048) {
-		return;
-	}
+	if (m_originalSample.frames() < 2048) { return; }
+
 	const float speedRatio = (float)m_originalBPM.value() / Engine::getSong()->getTempo() ;
 	const int noteIndex = handle->key() - 69;
 	const fpp_t frames = handle->framesLeftForCurrentPeriod();
 	const f_cnt_t offset = handle->noteOffset();
 	const int playedFrames = handle->totalFramesPlayed();
 
-	if (m_currentSpeedRatio != speedRatio) {
+	if (m_currentSpeedRatio != speedRatio)
+	{
 		timeShiftSample();
 	}
 	const int totalFrames = m_timeShiftedSample.frames();
 
 	int sliceStart, sliceEnd;
-	if (noteIndex > m_slicePoints.size()-2 || noteIndex < 0) {
+	if (noteIndex > m_slicePoints.size()-2 || noteIndex < 0)
+	{
 		sliceStart = 0;
 		sliceEnd = totalFrames;
 	} else {
 		sliceStart = m_slicePoints[noteIndex] * speedRatio;
 		sliceEnd = m_slicePoints[noteIndex+1] * speedRatio;
 	}
-	
+
 	int sliceFrames = sliceEnd - sliceStart;
 	int currentNoteFrame = sliceStart + playedFrames;
 	int noteFramesLeft = sliceFrames - playedFrames;
 
 
-	if( noteFramesLeft > 0) {
+	if( noteFramesLeft > 0)
+	{
 		int bufferSize = frames * BYTES_PER_FRAME;
 		memcpy(workingBuffer + offset, m_timeShiftedSample.data() + currentNoteFrame, bufferSize);
 
@@ -119,20 +122,18 @@ void SlicerT::playNote( NotePlayHandle * handle, sampleFrame * workingBuffer ) {
 
 		// !! disabled until it is optimized, because it lags the whole ui
 		// calculate absolute for the waveform
-		// float absoluteCurrentNote = (float)currentNoteFrame / totalFrames;
-		// float absoluteStartNote = (float)sliceStart / totalFrames;
-		// float abslouteEndNote = (float)sliceEnd / totalFrames;
-		// emit isPlaying(absoluteCurrentNote, absoluteStartNote, abslouteEndNote);
+		float absoluteCurrentNote = (float)currentNoteFrame / totalFrames;
+		float absoluteStartNote = (float)sliceStart / totalFrames;
+		float abslouteEndNote = (float)sliceEnd / totalFrames;
+		emit isPlaying(absoluteCurrentNote, absoluteStartNote, abslouteEndNote);
 	} else {
-		// emit isPlaying(0, 0, 0);
+		emit isPlaying(0, 0, 0);
 	}
 }
 
 
 void SlicerT::findSlices() {
-	if (m_originalSample.frames() < 2048) {
-		return;
-	}
+	if (m_originalSample.frames() < 2048) { return; }
 	m_slicePoints = {};
 
 	const int window = 1024;
@@ -141,17 +142,20 @@ void SlicerT::findSlices() {
 
 	float lastPeak = 0;
 	float currentPeak = 0;
-	
+
 	for (int i = 0; i<m_originalSample.frames();i+=1) {
 		float sampleValue = abs(m_originalSample.data()[i][0]) + abs(m_originalSample.data()[i][1]) / 2;
 
-		if (sampleValue > currentPeak) {
+		if (sampleValue > currentPeak)
+		{
 			currentPeak = sampleValue;
 			peakIndex = i;
 		}
-		
-		if (i%window==0) {
-			if (abs(currentPeak / lastPeak) > 1+m_noteThreshold.value() && minWindowsPassed <= 0) {
+
+		if (i%window==0)
+		{
+			if (abs(currentPeak / lastPeak) > 1+m_noteThreshold.value() && minWindowsPassed <= 0)
+			{
 				m_slicePoints.push_back(std::max(0, peakIndex-window/2)); // slight offset
 				minWindowsPassed = 2; // wait at least one window for a new note
 			}
@@ -168,9 +172,7 @@ void SlicerT::findSlices() {
 // find the bpm of the sample by assuming its in 4/4 time signature ,
 // and lies in the 100 - 200 bpm range
 void SlicerT::findBPM() {
-	if (m_originalSample.frames() < 2048) {
-		return;
-	}
+	if (m_originalSample.frames() < 2048) { return; }
 	int bpmSnap = 1; // 1 = disabled
 
 	float sampleRate = m_originalSample.sampleRate();
@@ -181,11 +183,13 @@ void SlicerT::findBPM() {
 	float bpmEstimate = 240.0f / sampleLength;
 
 	// deal with samlpes that are not 1 bar long
-	while (bpmEstimate < 100) {
+	while (bpmEstimate < 100)
+	{
 		bpmEstimate *= 2;
 	}
 
-	while (bpmEstimate > 200) {
+	while (bpmEstimate > 200)
+	{
 		bpmEstimate /= 2;
 	}
 
@@ -202,14 +206,11 @@ void SlicerT::findBPM() {
 void SlicerT::timeShiftSample() {
 	using std::vector;
 	// initial checks
-	if (m_originalSample.frames() < 2048) {
-		return;
-	}
-	if (m_timeshiftLock) { // needed
-		return;
-	}
+	if (m_originalSample.frames() < 2048) { return; }
+
+	if (m_timeshiftLock) { return; }
 	m_timeshiftLock = true;
-	
+
 
 	// original sample data
 	float sampleRate = m_originalSample.sampleRate();
@@ -220,7 +221,8 @@ void SlicerT::timeShiftSample() {
 	int outFrames = m_currentSpeedRatio * originalFrames;
 
 	// nothing to do here
-	if (targetBPM == m_originalBPM.value()) {
+	if (targetBPM == m_originalBPM.value())
+	{
 		m_timeShiftedSample.setData(m_originalSample.data(), m_originalSample.frames());
 		m_timeshiftLock = false;
 		return;
@@ -235,7 +237,8 @@ void SlicerT::timeShiftSample() {
 	vector<sampleFrame> bufferData(outFrames, sampleFrame());
 
 	// copy channels for processing
-	for (int i = 0;i<originalFrames;i++) {
+	for (int i = 0;i<originalFrames;i++)
+	{
 		rawDataL[i] = (float)m_originalSample.data()[i][0];
 		rawDataR[i] = (float)m_originalSample.data()[i][1];
 	}
@@ -244,7 +247,7 @@ void SlicerT::timeShiftSample() {
 	phaseVocoder(rawDataL, outDataL, sampleRate, 1);
 	phaseVocoder(rawDataR, outDataR, sampleRate, 1);
 
-	// write processed channels 
+	// write processed channels
 	m_timeShiftedSample.setData(outDataL, outDataR);
 
 	m_timeshiftLock = false;
@@ -267,7 +270,7 @@ void SlicerT::phaseVocoder(std::vector<float> &dataIn, std::vector<float> &dataO
 	// oversampling is better if higher always (probably)
 	const int windowSize = 512;
 	const int overSampling = 32;
-	
+
 	// audio data
 	int inFrames = dataIn.size();
 	int outFrames = dataOut.size();
@@ -275,10 +278,10 @@ void SlicerT::phaseVocoder(std::vector<float> &dataIn, std::vector<float> &dataO
 	float lengthRatio = (float)outFrames / inFrames;
 
 	// values used
-	const int stepSize = (float)windowSize / overSampling; 
+	const int stepSize = (float)windowSize / overSampling;
 	const int numWindows = (float)inFrames / stepSize;
 	const float outStepSize = lengthRatio * (float)stepSize; // float, else inaccurate
-	const float freqPerBin = sampleRate/windowSize; 
+	const float freqPerBin = sampleRate/windowSize;
 	// very important
 	const float expectedPhaseIn = 2.*M_PI*(float)stepSize/(float)windowSize;
 	const float expectedPhaseOut = 2.*M_PI*(float)outStepSize/(float)windowSize;
@@ -307,7 +310,8 @@ void SlicerT::phaseVocoder(std::vector<float> &dataIn, std::vector<float> &dataO
 	ifftPlan = fftwf_plan_dft_c2r_1d(windowSize, FFTSpectrum, IFFTReconstruction.data(), FFTW_MEASURE);
 
 	// remove oversampling, because the actual window is overSampling* bigger than stepsize
-	for (int i = 0;i < numWindows-overSampling;i++) {
+	for (int i = 0;i < numWindows-overSampling;i++)
+	{
 		windowIndex = i * stepSize;
 
 		memcpy(FFTInput.data(), dataIn.data() + windowIndex, windowSize*sizeof(float));
@@ -324,7 +328,7 @@ void SlicerT::phaseVocoder(std::vector<float> &dataIn, std::vector<float> &dataO
 			imag = FFTSpectrum[j][1];
 
 			magnitude = 2.*sqrt(real*real + imag*imag);
-			phase = atan2(imag,real); 
+			phase = atan2(imag,real);
 
 			freq = phase - lastPhase[j]; // subtract prev pahse to get phase diference
 			lastPhase[j] = phase;
@@ -336,7 +340,7 @@ void SlicerT::phaseVocoder(std::vector<float> &dataIn, std::vector<float> &dataO
 			if (qpd >= 0) qpd += qpd&1;
 			else qpd -= qpd&1;
 			freq -= M_PI*(float)qpd;
-			
+
 			freq = (float)overSampling*freq/(2.*M_PI); // idk
 
 			freq = (float)j*freqPerBin + freq*freqPerBin; // "compute the k-th partials' true frequency" ok i guess
@@ -385,15 +389,13 @@ void SlicerT::phaseVocoder(std::vector<float> &dataIn, std::vector<float> &dataO
 		// windowing
 		for (int j = 0; j < windowSize; j++) {
 			float outIndex = i * outStepSize + j;
-			if (outIndex > outFrames) {
-				break;
-			}
+			if (outIndex > outFrames) { break; }
 
 			// calculate windows overlapping at index
 			float startWindowOverlap = ceil(outIndex / outStepSize + 0.00000001f);
 			float endWindowOverlap = ceil((float)(-outIndex + outFrames) / outStepSize + 0.00000001f);
 			float totalWindowOverlap = std::min(
-										std::min(startWindowOverlap, endWindowOverlap), 
+										std::min(startWindowOverlap, endWindowOverlap),
 										(float)overSampling);
 
 			// discrete windowing
@@ -408,13 +410,15 @@ void SlicerT::phaseVocoder(std::vector<float> &dataIn, std::vector<float> &dataO
 	fftwf_destroy_plan(fftPlan);
 	fftwf_destroy_plan(ifftPlan);
 
-	// normalize 	
+	// normalize
 	float max = -1;
-	for (int i = 0;i<outFrames;i++) {
+	for (int i = 0;i<outFrames;i++)
+	{
 		max = std::max(max, abs(outBuffer[i]));
 	}
 
-	for (int i = 0;i<outFrames;i++) {
+	for (int i = 0;i<outFrames;i++)
+	{
 		outBuffer[i] = outBuffer[i] / max;
 	}
 
@@ -423,16 +427,16 @@ void SlicerT::phaseVocoder(std::vector<float> &dataIn, std::vector<float> &dataO
 
 int SlicerT::hashFttWindow(std::vector<float> & in) {
 	int hash = 0;
-	for (float value : in) {
+	for (float value : in)
+	{
 		hash += (324723947 + (int)(value * 10689354)) ^ 93485734985;;
 	}
 	return hash;
 }
 
 void SlicerT::writeToMidi(std::vector<Note> * outClip) {
-	if (m_originalSample.frames() < 2048) {
-		return;
-	}
+	if (m_originalSample.frames() < 2048) { return; }
+
 	int ticksPerBar = DefaultTicksPerBar;
 	float sampleRate = m_originalSample.sampleRate();
 
@@ -457,13 +461,12 @@ void SlicerT::writeToMidi(std::vector<Note> * outClip) {
 
 void SlicerT::updateFile(QString file) {
 	m_originalSample.setAudioFile(file);
-	if (m_originalSample.frames() < 2048) {
-		return;
-	}
+	if (m_originalSample.frames() < 2048) { return; }
+
 	findSlices();
-	findBPM(); 
+	findBPM();
 	timeShiftSample();
-	
+
 	emit dataChanged();
 }
 
@@ -507,7 +510,8 @@ void SlicerT::loadSettings( const QDomElement & element ) {
 		m_originalSample.loadFromBase64(element.attribute("srcdata"));
 	}
 
-	if (!element.attribute("totalSlices").isEmpty()) {
+	if (!element.attribute("totalSlices").isEmpty())
+	{
 		int totalSlices = element.attribute("totalSlices").toInt();
 		m_slicePoints = {};
 		for (int i = 0;i<totalSlices;i++) {
diff --git a/plugins/SlicerT/SlicerT.h b/plugins/SlicerT/SlicerT.h
index a6e6f36bbfa..9f80575091c 100644
--- a/plugins/SlicerT/SlicerT.h
+++ b/plugins/SlicerT/SlicerT.h
@@ -1,8 +1,8 @@
 /*
- * SlicerT.h - declaration of class SlicerT 
+ * SlicerT.h - declaration of class SlicerT
  *
  * Copyright (c) 2006-2008 Andreas Brandmaier <andy/at/brandmaier/dot/de>
- * 
+ *
  * This file is part of LMMS - https://lmms.io
  *
  * This program is free software; you can redistribute it and/or
@@ -47,18 +47,20 @@ class PlaybackBuffer {
 		int frames() { return mainBuffer.size(); };
 		sampleFrame * data() { return mainBuffer.data(); };
 
-		void setData(const sampleFrame * data, int newFrames) 
+		void setData(const sampleFrame * data, int newFrames)
 		{
 			mainBuffer = {};
-			mainBuffer.resize(newFrames); 
+			mainBuffer.resize(newFrames);
 			memcpy(mainBuffer.data(), data, newFrames * sizeof(sampleFrame));
 		};
-		void setData(std::vector<float> & leftData, std::vector<float> & rightData) {
+		void setData(std::vector<float> & leftData, std::vector<float> & rightData)
+		{
 			int newFrames = std::min(leftData.size(), rightData.size());
 			mainBuffer = {};
 			mainBuffer.resize(newFrames);
 
-			for (int i = 0;i < newFrames;i++) {
+			for (int i = 0;i < newFrames;i++)
+			{
 				mainBuffer[i][0] = leftData[i];
 				mainBuffer[i][1] = rightData[i];
 			}
@@ -67,7 +69,7 @@ class PlaybackBuffer {
 
 class SlicerT : public Instrument{
 	Q_OBJECT
-	
+
 	public:
 		SlicerT(InstrumentTrack * instrumentTrack);
 		~SlicerT() override = default;
@@ -98,7 +100,7 @@ class SlicerT : public Instrument{
 		SampleBuffer m_originalSample;
 		PlaybackBuffer m_timeShiftedSample;
 		std::vector<int> m_slicePoints;
-		
+
 		float m_currentSpeedRatio = 0;
 		bool m_timeshiftLock; // dont run timeshifting at the same time, instant crash
 		// std::unordered_map<int, std::vector<float> > m_fftWindowCache;
diff --git a/plugins/SlicerT/SlicerTUI.cpp b/plugins/SlicerT/SlicerTUI.cpp
index 1602e847f86..ccbdea7c674 100644
--- a/plugins/SlicerT/SlicerTUI.cpp
+++ b/plugins/SlicerT/SlicerTUI.cpp
@@ -2,7 +2,7 @@
  * SlicerTUI.cpp - controls the UI for slicerT
  *
  * Copyright (c) 2006-2008 Andreas Brandmaier <andy/at/brandmaier/dot/de>
- * 
+ *
  * This file is part of LMMS - https://lmms.io
  *
  * This program is free software; you can redistribute it and/or
@@ -54,30 +54,24 @@ SlicerTUI::SlicerTUI( SlicerT * instrument,
 	m_fadeOutKnob(KnobType::Dark28, this),
 	m_bpmBox(3, "21pink", this),
 	m_resetButton(embed::getIconPixmap("reload"), QString(), this),
-	m_timeShiftButton(embed::getIconPixmap("max_length"), QString(), this),
 	m_midiExportButton(embed::getIconPixmap("midi_tab"), QString(), this),
 	m_wf(245, 125, instrument, this)
 {
 	setAcceptDrops( true );
 
-	m_wf.move(2, 5); 
+	m_wf.move(2, 5);
 
 	m_bpmBox.move(2, 150);
 	m_bpmBox.setToolTip(tr("Original sample BPM"));
 	m_bpmBox.setLabel(tr("BPM"));
 	m_bpmBox.setModel(&m_slicerTParent->m_originalBPM);
-	// connect(&m_bpmBox, SIGNAL( manualChange() ), m_slicerTParent, SLOT( updateTimeShift() ), Qt::QueuedConnection);
-
-	m_timeShiftButton.move(70, 150);
-	m_timeShiftButton.setToolTip(tr("Timeshift sample"));
-	// connect(&m_timeShiftButton, SIGNAL( clicked() ), m_slicerTParent, SLOT( updateTimeShift() ), Qt::QueuedConnection);
 
 	m_fadeOutKnob.move(200, 150);
 	m_fadeOutKnob.setToolTip(tr("FadeOut for notes"));
 	m_fadeOutKnob.setLabel(tr("FadeOut"));
 	m_fadeOutKnob.setModel(&m_slicerTParent->m_fadeOutFrames);
 
-	m_midiExportButton.move(150, 150);
+	m_midiExportButton.move(150, 200);
 	m_midiExportButton.setToolTip(tr("Copy midi pattern to clipboard"));
 	connect(&m_midiExportButton, SIGNAL( clicked() ), this, SLOT( exportMidi() ));
 
@@ -101,7 +95,8 @@ void SlicerTUI::exportMidi() {
 
 	std::vector<Note> notes;
 	m_slicerTParent->writeToMidi(&notes);
-	if (notes.size() == 0) {
+	if (notes.size() == 0)
+	{
 		return;
 	}
 
diff --git a/plugins/SlicerT/SlicerTUI.h b/plugins/SlicerT/SlicerTUI.h
index 11a238ac01f..1a0837bffe7 100644
--- a/plugins/SlicerT/SlicerTUI.h
+++ b/plugins/SlicerT/SlicerTUI.h
@@ -2,7 +2,7 @@
  * SlicerTUI.h - declaration of class SlicerTUI
  *
  * Copyright (c) 2006-2008 Andreas Brandmaier <andy/at/brandmaier/dot/de>
- * 
+ *
  * This file is part of LMMS - https://lmms.io
  *
  * This program is free software; you can redistribute it and/or
@@ -47,7 +47,7 @@ namespace gui
 class SlicerTUI : public InstrumentViewFixedSize
 {
 	Q_OBJECT
-	
+
 public:
 	SlicerTUI( SlicerT * instrument,
 					QWidget * parent );
@@ -69,7 +69,6 @@ protected slots:
 	LcdSpinBox m_bpmBox;
 
 	QPushButton m_resetButton;
-	QPushButton m_timeShiftButton;
 	QPushButton m_midiExportButton;
 
 	WaveForm m_wf;
diff --git a/plugins/SlicerT/WaveForm.cpp b/plugins/SlicerT/WaveForm.cpp
index d5bdc261ac1..eae9a5e9e80 100644
--- a/plugins/SlicerT/WaveForm.cpp
+++ b/plugins/SlicerT/WaveForm.cpp
@@ -2,7 +2,7 @@
  * WaveForm.cpp - slice editor for SlicerT
  *
  * Copyright (c) 2006-2008 Andreas Brandmaier <andy/at/brandmaier/dot/de>
- * 
+ *
  * This file is part of LMMS - https://lmms.io
  *
  * This program is free software; you can redistribute it and/or
@@ -36,6 +36,7 @@ namespace gui
         QWidget(parent),
         m_sliceEditor(QPixmap(w, h*(1 - m_m_seekerRatio) - m_margin)),
         m_seeker(QPixmap(w, h*m_m_seekerRatio)),
+        m_seekerWaveform(QPixmap(w, h*m_m_seekerRatio)),
         m_currentSample(instrument->m_originalSample.data(), instrument->m_originalSample.frames()),
         m_slicePoints(instrument->m_slicePoints)
         {
@@ -44,14 +45,13 @@ namespace gui
             m_slicerTParent = instrument;
             setFixedSize(m_width, m_height);
             setMouseTracking( true );
-            setAcceptDrops( true );
 
             m_sliceEditor.fill(m_waveformBgColor);
-            m_seeker.fill(m_waveformBgColor);
+            m_seekerWaveform.fill(m_waveformBgColor);
 
-            connect(m_slicerTParent, 
-                    SIGNAL(isPlaying(float, float, float)), 
-                    this, 
+            connect(m_slicerTParent,
+                    SIGNAL(isPlaying(float, float, float)),
+                    this,
                     SLOT(isPlaying(float, float, float)));
 
             connect(m_slicerTParent, SIGNAL(dataChanged()), this, SLOT(updateData()));
@@ -62,11 +62,14 @@ namespace gui
     void WaveForm::drawEditor() {
         m_sliceEditor.fill(m_waveformBgColor);
         QPainter brush(&m_sliceEditor);
-        brush.setPen(m_waveformColor);
 
         float startFrame = m_seekerStart * m_currentSample.frames();
         float endFrame = m_seekerEnd * m_currentSample.frames();
 
+        brush.setPen(m_playHighlighColor);
+        brush.drawLine(0, m_sliceEditor.height()/2, m_sliceEditor.width(), m_sliceEditor.height()/2);
+
+        brush.setPen(m_waveformColor);
         m_currentSample.visualize(
 		brush,
 		QRect( 0, 0, m_sliceEditor.width(), m_sliceEditor.height() ),
@@ -77,9 +80,11 @@ namespace gui
             int sliceIndex = m_slicePoints[i];
             brush.setPen(QPen(m_sliceColor, 2));
 
-            if (sliceIndex >= startFrame && sliceIndex <= endFrame) {
+            if (sliceIndex >= startFrame && sliceIndex <= endFrame)
+            {
                 float xPos = (float)(sliceIndex - startFrame) / (float)(endFrame - startFrame) * (float)m_width;
-                if (i == m_sliceSelected) {
+                if (i == m_sliceSelected)
+                {
                     brush.setPen(QPen(m_selectedSliceColor, 2));
                 }
 
@@ -88,19 +93,26 @@ namespace gui
         }
     }
 
-    void WaveForm::drawSeeker() {
-        m_seeker.fill(m_waveformBgColor);
-        QPainter brush(&m_seeker);
+    void WaveForm::drawSeekerWaveform() {
+        QPainter brush(&m_seekerWaveform);
         brush.setPen(m_waveformColor);
 
+        m_seekerWaveform.fill(m_waveformBgColor);
         m_currentSample.visualize(
 		brush,
-		QRect( 0, 0, m_seeker.width(), m_seeker.height() ),
+		QRect( 0, 0, m_seekerWaveform.width(), m_seekerWaveform.height() ),
 		0, m_currentSample.frames());
+    }
+
+    void WaveForm::drawSeeker() {
+        m_seeker.fill(QColor(0, 0, 0, 0));
+        QPainter brush(&m_seeker);
+        brush.setPen(m_waveformColor);
 
         // draw slice points
         brush.setPen(m_sliceColor);
-        for (int i = 0;i<m_slicePoints.size();i++) {
+        for (int i = 0;i<m_slicePoints.size();i++)
+        {
             float xPos = (float)m_slicePoints[i] / (float)m_currentSample.frames() * (float)m_width;
             brush.drawLine(xPos, 0, xPos, m_height);
         }
@@ -121,6 +133,7 @@ namespace gui
     }
 
     void WaveForm::updateUI() {
+        drawSeekerWaveform();
         drawSeeker();
         drawEditor();
         update();
@@ -131,32 +144,36 @@ namespace gui
         updateUI();
     }
 
-
     void WaveForm::isPlaying(float current, float start, float end) {
         m_noteCurrent = current;
         m_noteStart = start;
         m_noteEnd = end;
-        drawSeeker();
+        drawSeeker(); // only update seeker, else horrible performance
         update();
     }
 
     void WaveForm::mousePressEvent( QMouseEvent * me ) {
         float normalizedClick = (float)me->x() / m_width;
-        
-        if (me->button() == Qt::MouseButton::MiddleButton) {
+
+        if (me->button() == Qt::MouseButton::MiddleButton)
+        {
             m_seekerStart = 0;
             m_seekerEnd = 1;
             return;
         }
 
-        if (me->y() < m_height*m_m_seekerRatio) {
-            if (abs(normalizedClick - m_seekerStart) < 0.03) {
+        if (me->y() < m_height*m_m_seekerRatio)
+        {
+            if (abs(normalizedClick - m_seekerStart) < 0.03)
+            {
                 m_currentlyDragging = m_draggingTypes::m_seekerStart;
 
-            } else if (abs(normalizedClick - m_seekerEnd) < 0.03) {
+            } else if (abs(normalizedClick - m_seekerEnd) < 0.03)
+            {
                 m_currentlyDragging = m_draggingTypes::m_seekerEnd;
 
-            } else if (normalizedClick > m_seekerStart && normalizedClick < m_seekerEnd) {
+            } else if (normalizedClick > m_seekerStart && normalizedClick < m_seekerEnd)
+            {
                 m_currentlyDragging = m_draggingTypes::m_seekerMiddle;
                 m_seekerMiddle = normalizedClick;
             }
@@ -165,26 +182,31 @@ namespace gui
             m_sliceSelected = -1;
             float startFrame = m_seekerStart * m_currentSample.frames();
             float endFrame = m_seekerEnd * m_currentSample.frames();
-            
-            for (int i = 0;i<m_slicePoints.size();i++) {
+
+            for (int i = 0;i<m_slicePoints.size();i++)
+            {
                 int sliceIndex = m_slicePoints[i];
                 float xPos = (float)(sliceIndex - startFrame) / (float)(endFrame - startFrame);
 
-                if (abs(xPos - normalizedClick) < 0.03) {
+                if (abs(xPos - normalizedClick) < 0.03)
+                {
                     m_currentlyDragging = m_draggingTypes::slicePoint;
                     m_sliceSelected = i;
                 }
             }
-        } 
-        if (me->button() == Qt::MouseButton::LeftButton) {
+        }
+        if (me->button() == Qt::MouseButton::LeftButton)
+        {
             m_isDragging = true;
 
-        } else if (me->button() == Qt::MouseButton::RightButton) {
-            if (m_sliceSelected != -1 && m_slicePoints.size() > 2) {
+        } else if (me->button() == Qt::MouseButton::RightButton)
+        {
+            if (m_sliceSelected != -1 && m_slicePoints.size() > 2)
+            {
                 m_slicePoints.erase(m_slicePoints.begin() + m_sliceSelected);
                 m_sliceSelected = -1;
             }
-        }  
+        }
 
     }
 
@@ -196,27 +218,32 @@ namespace gui
 
     void WaveForm::mouseMoveEvent( QMouseEvent * me ) {
         float normalizedClick = (float)me->x() / m_width;
-        
+
         // handle dragging events
-        if (m_isDragging) { 
-            if (m_currentlyDragging == m_draggingTypes::m_seekerStart) {
+        if (m_isDragging) {
+            if (m_currentlyDragging == m_draggingTypes::m_seekerStart)
+            {
                 m_seekerStart = std::clamp(normalizedClick, 0.0f, m_seekerEnd - 0.13f);
 
-            } else if (m_currentlyDragging == m_draggingTypes::m_seekerEnd) {
+            } else if (m_currentlyDragging == m_draggingTypes::m_seekerEnd)
+            {
                 m_seekerEnd = std::clamp(normalizedClick, m_seekerStart + 0.13f, 1.0f);;
 
-            } else if (m_currentlyDragging == m_draggingTypes::m_seekerMiddle) {
+            } else if (m_currentlyDragging == m_draggingTypes::m_seekerMiddle)
+            {
                 float distStart = m_seekerStart - m_seekerMiddle;
                 float distEnd = m_seekerEnd - m_seekerMiddle;
 
                 m_seekerMiddle = normalizedClick;
 
-                if (m_seekerMiddle + distStart > 0 && m_seekerMiddle + distEnd < 1) {
+                if (m_seekerMiddle + distStart > 0 && m_seekerMiddle + distEnd < 1)
+                {
                     m_seekerStart = m_seekerMiddle + distStart;
                     m_seekerEnd = m_seekerMiddle + distEnd;
                 }
 
-            } else if (m_currentlyDragging == m_draggingTypes::slicePoint) {
+            } else if (m_currentlyDragging == m_draggingTypes::slicePoint)
+            {
                 float startFrame = m_seekerStart * m_currentSample.frames();
                 float endFrame = m_seekerEnd * m_currentSample.frames();
 
@@ -237,8 +264,10 @@ namespace gui
 
         float slicePosition = startFrame + normalizedClick * (endFrame - startFrame);
 
-        for (int i = 0;i<m_slicePoints.size();i++) {
-            if (m_slicePoints[i] < slicePosition) {
+        for (int i = 0;i<m_slicePoints.size();i++)
+        {
+            if (m_slicePoints[i] < slicePosition)
+            {
                 m_slicePoints.insert(m_slicePoints.begin() + i, slicePosition);
                 break;
             }
@@ -249,8 +278,10 @@ namespace gui
 
     void WaveForm::paintEvent( QPaintEvent * pe) {
         QPainter p( this );
-        p.drawPixmap(0, m_height*0.3f + m_margin, m_sliceEditor);
+        p.drawPixmap(0, 0 ,m_seekerWaveform);
         p.drawPixmap(0, 0, m_seeker);
+        p.drawPixmap(0, m_height*0.3f + m_margin, m_sliceEditor);
+
     }
 } // namespace gui
 } // namespace lmms
\ No newline at end of file
diff --git a/plugins/SlicerT/WaveForm.h b/plugins/SlicerT/WaveForm.h
index 46bba6e6b2a..de41c13f164 100644
--- a/plugins/SlicerT/WaveForm.h
+++ b/plugins/SlicerT/WaveForm.h
@@ -2,7 +2,7 @@
  * WaveForm.h - declaration of class WaveForm
  *
  * Copyright (c) 2006-2008 Andreas Brandmaier <andy/at/brandmaier/dot/de>
- * 
+ *
  * This file is part of LMMS - https://lmms.io
  *
  * This program is free software; you can redistribute it and/or
@@ -68,13 +68,15 @@ class WaveForm : public QWidget {
         QColor m_seekerColor = QColor(214, 124, 49);
         QColor m_seekerShadowColor = QColor(0, 0, 0, 175);
 
-        enum class m_draggingTypes {
+        enum class m_draggingTypes
+        {
             nothing,
             m_seekerStart,
             m_seekerEnd,
             m_seekerMiddle,
             slicePoint,
         };
+
         m_draggingTypes m_currentlyDragging;
         bool m_isDragging = false;
 
@@ -89,10 +91,12 @@ class WaveForm : public QWidget {
 
         QPixmap m_sliceEditor;
         QPixmap m_seeker;
+        QPixmap m_seekerWaveform;
 
         SampleBuffer m_currentSample;
 
         void drawEditor();
+        void drawSeekerWaveform();
         void drawSeeker();
         void updateUI();
 

From d94046c0b68cdf77c86ead730f40ece82b6b5a53 Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Mon, 11 Sep 2023 00:08:08 +0200
Subject: [PATCH 20/99] initial UI changes + more code style

---
 plugins/SlicerT/SlicerT.cpp   |  63 ++++--
 plugins/SlicerT/SlicerTUI.cpp |  21 +-
 plugins/SlicerT/SlicerTUI.h   |   3 +
 plugins/SlicerT/WaveForm.cpp  | 389 ++++++++++++++++++----------------
 plugins/SlicerT/WaveForm.h    |   3 +-
 plugins/SlicerT/artwork.png   | Bin 0 -> 10943 bytes
 6 files changed, 263 insertions(+), 216 deletions(-)
 create mode 100644 plugins/SlicerT/artwork.png

diff --git a/plugins/SlicerT/SlicerT.cpp b/plugins/SlicerT/SlicerT.cpp
index d93be93da3d..0b7cc6ea7e3 100644
--- a/plugins/SlicerT/SlicerT.cpp
+++ b/plugins/SlicerT/SlicerT.cpp
@@ -47,7 +47,7 @@ extern "C"
 {
 Plugin::Descriptor PLUGIN_EXPORT slicert_plugin_descriptor =
 {
-	LMMS_STRINGIFY( PLUGINhandleAME ),
+	LMMS_STRINGIFY( PLUGIN_NAME ),
 	"SlicerT",
 	QT_TRANSLATE_NOOP( "PluginBrowser",
 				"Basic Slicer" ),
@@ -70,7 +70,8 @@ SlicerT::SlicerT(InstrumentTrack * instrumentTrack) :
 {}
 
 
-void SlicerT::playNote( NotePlayHandle * handle, sampleFrame * workingBuffer ) {
+void SlicerT::playNote( NotePlayHandle * handle, sampleFrame * workingBuffer )
+{
 	if (m_originalSample.frames() < 2048) { return; }
 
 	const float speedRatio = (float)m_originalBPM.value() / Engine::getSong()->getTempo() ;
@@ -106,8 +107,10 @@ void SlicerT::playNote( NotePlayHandle * handle, sampleFrame * workingBuffer ) {
 		memcpy(workingBuffer + offset, m_timeShiftedSample.data() + currentNoteFrame, bufferSize);
 
 		// exponential fade out, applyRelease kinda sucks
-		if (noteFramesLeft < m_fadeOutFrames.value()) {
-			for (int i = 0;i<frames;i++) {
+		if (noteFramesLeft < m_fadeOutFrames.value())
+		{
+			for (int i = 0;i<frames;i++)
+			{
 				float fadeValue = (float)(noteFramesLeft-i) / m_fadeOutFrames.value();
 				// if the workingbuffer extends the sample
 				fadeValue = std::clamp(fadeValue, 0.0f, 1.0f);
@@ -120,7 +123,6 @@ void SlicerT::playNote( NotePlayHandle * handle, sampleFrame * workingBuffer ) {
 
 		instrumentTrack()->processAudioBuffer( workingBuffer, frames + offset, handle );
 
-		// !! disabled until it is optimized, because it lags the whole ui
 		// calculate absolute for the waveform
 		float absoluteCurrentNote = (float)currentNoteFrame / totalFrames;
 		float absoluteStartNote = (float)sliceStart / totalFrames;
@@ -132,7 +134,8 @@ void SlicerT::playNote( NotePlayHandle * handle, sampleFrame * workingBuffer ) {
 }
 
 
-void SlicerT::findSlices() {
+void SlicerT::findSlices()
+{
 	if (m_originalSample.frames() < 2048) { return; }
 	m_slicePoints = {};
 
@@ -143,7 +146,8 @@ void SlicerT::findSlices() {
 	float lastPeak = 0;
 	float currentPeak = 0;
 
-	for (int i = 0; i<m_originalSample.frames();i+=1) {
+	for (int i = 0; i<m_originalSample.frames();i+=1)
+	{
 		float sampleValue = abs(m_originalSample.data()[i][0]) + abs(m_originalSample.data()[i][1]) / 2;
 
 		if (sampleValue > currentPeak)
@@ -171,7 +175,8 @@ void SlicerT::findSlices() {
 
 // find the bpm of the sample by assuming its in 4/4 time signature ,
 // and lies in the 100 - 200 bpm range
-void SlicerT::findBPM() {
+void SlicerT::findBPM()
+{
 	if (m_originalSample.frames() < 2048) { return; }
 	int bpmSnap = 1; // 1 = disabled
 
@@ -203,7 +208,8 @@ void SlicerT::findBPM() {
 }
 
 // create timeshifted samplebuffer and timeshifted m_slicePoints
-void SlicerT::timeShiftSample() {
+void SlicerT::timeShiftSample()
+{
 	using std::vector;
 	// initial checks
 	if (m_originalSample.frames() < 2048) { return; }
@@ -259,7 +265,8 @@ void SlicerT::timeShiftSample() {
 // https://sethares.engr.wisc.edu/vocoders/phasevocoder.html
 // https://dsp.stackexchange.com/questions/40101/audio-time-stretching-without-pitch-shifting/40367#40367
 // https://www.guitarpitchshifter.com/
-void SlicerT::phaseVocoder(std::vector<float> &dataIn, std::vector<float> &dataOut, float sampleRate, float pitchScale) {
+void SlicerT::phaseVocoder(std::vector<float> &dataIn, std::vector<float> &dataOut, float sampleRate, float pitchScale)
+{
 	using std::vector;
 	// processing parameters, lower is faster
 	// lower windows size seems to work better for time scaling,
@@ -323,7 +330,8 @@ void SlicerT::phaseVocoder(std::vector<float> &dataIn, std::vector<float> &dataO
 		fftwf_execute(fftPlan);
 
 		// analysis step
-		for (int j = 0; j < windowSize; j++) {
+		for (int j = 0; j < windowSize; j++)
+		{
 			real = FFTSpectrum[j][0];
 			imag = FFTSpectrum[j][1];
 
@@ -364,7 +372,8 @@ void SlicerT::phaseVocoder(std::vector<float> &dataIn, std::vector<float> &dataO
 		// }
 
 		// synthesis, all the operations are the reverse of the analysis
-		for (int j = 0; j < windowSize; j++) {
+		for (int j = 0; j < windowSize; j++)
+		{
 			magnitude = allMagnitudes[j];
 			freq = allFrequencies[j];
 
@@ -387,7 +396,8 @@ void SlicerT::phaseVocoder(std::vector<float> &dataIn, std::vector<float> &dataO
 		fftwf_execute(ifftPlan);
 
 		// windowing
-		for (int j = 0; j < windowSize; j++) {
+		for (int j = 0; j < windowSize; j++)
+		{
 			float outIndex = i * outStepSize + j;
 			if (outIndex > outFrames) { break; }
 
@@ -425,7 +435,8 @@ void SlicerT::phaseVocoder(std::vector<float> &dataIn, std::vector<float> &dataO
 	memcpy(dataOut.data(), outBuffer.data(), outFrames*sizeof(float));
 }
 
-int SlicerT::hashFttWindow(std::vector<float> & in) {
+int SlicerT::hashFttWindow(std::vector<float> & in)
+{
 	int hash = 0;
 	for (float value : in)
 	{
@@ -434,7 +445,8 @@ int SlicerT::hashFttWindow(std::vector<float> & in) {
 	return hash;
 }
 
-void SlicerT::writeToMidi(std::vector<Note> * outClip) {
+void SlicerT::writeToMidi(std::vector<Note> * outClip)
+{
 	if (m_originalSample.frames() < 2048) { return; }
 
 	int ticksPerBar = DefaultTicksPerBar;
@@ -447,7 +459,8 @@ void SlicerT::writeToMidi(std::vector<Note> * outClip) {
 	float barsInSample = beats / Engine::getSong()->getTimeSigModel().getDenominator();
 	float totalTicks = ticksPerBar * barsInSample;
 
-	for (int i = 0;i<m_slicePoints.size()-1;i++) {
+	for (int i = 0;i<m_slicePoints.size()-1;i++)
+	{
 		float sliceStart = (float)m_slicePoints[i] / m_originalSample.frames() * totalTicks;
 		float sliceEnd = (float)m_slicePoints[i + 1] / m_originalSample.frames() * totalTicks;
 
@@ -459,7 +472,8 @@ void SlicerT::writeToMidi(std::vector<Note> * outClip) {
 	}
 }
 
-void SlicerT::updateFile(QString file) {
+void SlicerT::updateFile(QString file)
+{
 	m_originalSample.setAudioFile(file);
 	if (m_originalSample.frames() < 2048) { return; }
 
@@ -470,11 +484,13 @@ void SlicerT::updateFile(QString file) {
 	emit dataChanged();
 }
 
-void SlicerT::updateSlices() {
+void SlicerT::updateSlices()
+{
 	findSlices();
 }
 
-void SlicerT::saveSettings(QDomDocument & document, QDomElement & element) {
+void SlicerT::saveSettings(QDomDocument & document, QDomElement & element)
+{
 	element.setAttribute("src", m_originalSample.audioFile());
 	if (m_originalSample.audioFile().isEmpty())
 	{
@@ -484,7 +500,8 @@ void SlicerT::saveSettings(QDomDocument & document, QDomElement & element) {
 
 	element.setAttribute("totalSlices", (int)m_slicePoints.size());
 
-	for (int i = 0;i<m_slicePoints.size();i++) {
+	for (int i = 0;i<m_slicePoints.size();i++)
+	{
 		element.setAttribute(tr("slice_%1").arg(i), m_slicePoints[i]);
 	}
 
@@ -493,7 +510,8 @@ void SlicerT::saveSettings(QDomDocument & document, QDomElement & element) {
 	m_originalBPM.saveSettings(document, element, "origBPM");
 }
 
-void SlicerT::loadSettings( const QDomElement & element ) {
+void SlicerT::loadSettings( const QDomElement & element )
+{
 	if (!element.attribute("src").isEmpty())
 	{
 		m_originalSample.setAudioFile(element.attribute("src"));
@@ -514,7 +532,8 @@ void SlicerT::loadSettings( const QDomElement & element ) {
 	{
 		int totalSlices = element.attribute("totalSlices").toInt();
 		m_slicePoints = {};
-		for (int i = 0;i<totalSlices;i++) {
+		for (int i = 0;i<totalSlices;i++)
+		{
 			m_slicePoints.push_back(element.attribute(tr("slice_%1").arg(i)).toInt());
 		}
 	}
diff --git a/plugins/SlicerT/SlicerTUI.cpp b/plugins/SlicerT/SlicerTUI.cpp
index ccbdea7c674..dfeb154f4d6 100644
--- a/plugins/SlicerT/SlicerTUI.cpp
+++ b/plugins/SlicerT/SlicerTUI.cpp
@@ -50,16 +50,18 @@ SlicerTUI::SlicerTUI( SlicerT * instrument,
 					QWidget * parent ) :
 	InstrumentViewFixedSize( instrument, parent ),
 	m_slicerTParent(instrument),
+	m_backgroundImage(PLUGIN_NAME::getIconPixmap(
+								"artwork" )),
 	m_noteThresholdKnob(KnobType::Dark28, this),
 	m_fadeOutKnob(KnobType::Dark28, this),
-	m_bpmBox(3, "21pink", this),
+	m_bpmBox(3, "19green", this),
 	m_resetButton(embed::getIconPixmap("reload"), QString(), this),
 	m_midiExportButton(embed::getIconPixmap("midi_tab"), QString(), this),
-	m_wf(245, 125, instrument, this)
+	m_wf(244, 125, instrument, this)
 {
 	setAcceptDrops( true );
 
-	m_wf.move(2, 5);
+	m_wf.move(3, 5);
 
 	m_bpmBox.move(2, 150);
 	m_bpmBox.setToolTip(tr("Original sample BPM"));
@@ -86,7 +88,8 @@ SlicerTUI::SlicerTUI( SlicerT * instrument,
 }
 
 // copied from piano roll
-void SlicerTUI::exportMidi() {
+void SlicerTUI::exportMidi()
+{
 	using namespace Clipboard;
 
 	DataFile dataFile( DataFile::Type::ClipboardData );
@@ -141,7 +144,8 @@ void SlicerTUI::dragEnterEvent( QDragEnterEvent * dee )
 	}
 }
 
-void SlicerTUI::dropEvent( QDropEvent * de ) {
+void SlicerTUI::dropEvent( QDropEvent * de )
+{
 	QString type = StringPairDrag::decodeKey( de );
 	QString value = StringPairDrag::decodeValue( de );
 	if( type == "samplefile" )
@@ -162,5 +166,12 @@ void SlicerTUI::dropEvent( QDropEvent * de ) {
 
 	de->ignore();
 }
+
+void SlicerTUI::paintEvent(QPaintEvent * pe)
+{
+	QPainter p( this );
+	p.drawPixmap(0, 0, m_backgroundImage);
+}
+
 } // namespace gui
 } // namespace lmms
\ No newline at end of file
diff --git a/plugins/SlicerT/SlicerTUI.h b/plugins/SlicerT/SlicerTUI.h
index 1a0837bffe7..13cf132fd57 100644
--- a/plugins/SlicerT/SlicerTUI.h
+++ b/plugins/SlicerT/SlicerTUI.h
@@ -61,8 +61,11 @@ protected slots:
 	virtual void dragEnterEvent( QDragEnterEvent * _dee );
 	virtual void dropEvent( QDropEvent * _de );
 
+	virtual void paintEvent(QPaintEvent * pe);
+
 private:
 	SlicerT * m_slicerTParent;
+	QPixmap m_backgroundImage;
 
 	Knob m_noteThresholdKnob;
 	Knob m_fadeOutKnob;
diff --git a/plugins/SlicerT/WaveForm.cpp b/plugins/SlicerT/WaveForm.cpp
index eae9a5e9e80..66c168d947e 100644
--- a/plugins/SlicerT/WaveForm.cpp
+++ b/plugins/SlicerT/WaveForm.cpp
@@ -32,256 +32,269 @@ namespace lmms
 
 namespace gui
 {
-    WaveForm::WaveForm(int w, int h, SlicerT  * instrument, QWidget * parent) :
-        QWidget(parent),
-        m_sliceEditor(QPixmap(w, h*(1 - m_m_seekerRatio) - m_margin)),
-        m_seeker(QPixmap(w, h*m_m_seekerRatio)),
-        m_seekerWaveform(QPixmap(w, h*m_m_seekerRatio)),
-        m_currentSample(instrument->m_originalSample.data(), instrument->m_originalSample.frames()),
-        m_slicePoints(instrument->m_slicePoints)
-        {
-            m_width = w;
-            m_height = h;
-            m_slicerTParent = instrument;
-            setFixedSize(m_width, m_height);
-            setMouseTracking( true );
+WaveForm::WaveForm(int w, int h, SlicerT  * instrument, QWidget * parent) :
+    QWidget(parent),
+    m_sliceEditor(QPixmap(w, h*(1 - m_m_seekerRatio) - m_margin)),
+    m_seeker(QPixmap(w, h*m_m_seekerRatio)),
+    m_seekerWaveform(QPixmap(w, h*m_m_seekerRatio)),
+    m_currentSample(instrument->m_originalSample.data(), instrument->m_originalSample.frames()),
+    m_slicePoints(instrument->m_slicePoints)
+    {
+        m_width = w;
+        m_height = h;
+        m_slicerTParent = instrument;
+        setFixedSize(m_width, m_height);
+        setMouseTracking( true );
 
-            m_sliceEditor.fill(m_waveformBgColor);
-            m_seekerWaveform.fill(m_waveformBgColor);
+        m_sliceEditor.fill(m_waveformBgColor);
+        m_seekerWaveform.fill(m_waveformBgColor);
 
-            connect(m_slicerTParent,
-                    SIGNAL(isPlaying(float, float, float)),
-                    this,
-                    SLOT(isPlaying(float, float, float)));
+        connect(m_slicerTParent,
+                SIGNAL(isPlaying(float, float, float)),
+                this,
+                SLOT(isPlaying(float, float, float)));
 
-            connect(m_slicerTParent, SIGNAL(dataChanged()), this, SLOT(updateData()));
+        connect(m_slicerTParent, SIGNAL(dataChanged()), this, SLOT(updateData()));
 
-            updateUI();
-        }
+        updateUI();
+    }
 
-    void WaveForm::drawEditor() {
-        m_sliceEditor.fill(m_waveformBgColor);
-        QPainter brush(&m_sliceEditor);
+void WaveForm::drawEditor()
+{
+    m_sliceEditor.fill(m_waveformBgColor);
+    QPainter brush(&m_sliceEditor);
 
-        float startFrame = m_seekerStart * m_currentSample.frames();
-        float endFrame = m_seekerEnd * m_currentSample.frames();
+    float startFrame = m_seekerStart * m_currentSample.frames();
+    float endFrame = m_seekerEnd * m_currentSample.frames();
 
-        brush.setPen(m_playHighlighColor);
-        brush.drawLine(0, m_sliceEditor.height()/2, m_sliceEditor.width(), m_sliceEditor.height()/2);
+    brush.setPen(m_playHighlighColor);
+    brush.drawLine(0, m_sliceEditor.height()/2, m_sliceEditor.width(), m_sliceEditor.height()/2);
 
-        brush.setPen(m_waveformColor);
-        m_currentSample.visualize(
-		brush,
-		QRect( 0, 0, m_sliceEditor.width(), m_sliceEditor.height() ),
-		startFrame, endFrame);
+    brush.setPen(m_waveformColor);
+    m_currentSample.visualize(
+    brush,
+    QRect( 0, 0, m_sliceEditor.width(), m_sliceEditor.height() ),
+    startFrame, endFrame);
 
 
-        for (int i = 0;i<m_slicePoints.size();i++) {
-            int sliceIndex = m_slicePoints[i];
-            brush.setPen(QPen(m_sliceColor, 2));
+    for (int i = 0;i<m_slicePoints.size();i++)
+    {
+        int sliceIndex = m_slicePoints[i];
+        brush.setPen(QPen(m_sliceColor, 2));
 
-            if (sliceIndex >= startFrame && sliceIndex <= endFrame)
+        if (sliceIndex >= startFrame && sliceIndex <= endFrame)
+        {
+            float xPos = (float)(sliceIndex - startFrame) / (float)(endFrame - startFrame) * (float)m_width;
+            if (i == m_sliceSelected)
             {
-                float xPos = (float)(sliceIndex - startFrame) / (float)(endFrame - startFrame) * (float)m_width;
-                if (i == m_sliceSelected)
-                {
-                    brush.setPen(QPen(m_selectedSliceColor, 2));
-                }
-
-                brush.drawLine(xPos, 0, xPos, m_height);
+                brush.setPen(QPen(m_selectedSliceColor, 2));
             }
+
+            brush.drawLine(xPos, 0, xPos, m_height);
         }
     }
+}
+
+void WaveForm::drawSeekerWaveform()
+{
+    QPainter brush(&m_seekerWaveform);
+    brush.setPen(m_waveformColor);
 
-    void WaveForm::drawSeekerWaveform() {
-        QPainter brush(&m_seekerWaveform);
-        brush.setPen(m_waveformColor);
+    m_seekerWaveform.fill(m_waveformBgColor);
+    m_currentSample.visualize(
+    brush,
+    QRect( 0, 0, m_seekerWaveform.width(), m_seekerWaveform.height() ),
+    0, m_currentSample.frames());
+}
 
-        m_seekerWaveform.fill(m_waveformBgColor);
-        m_currentSample.visualize(
-		brush,
-		QRect( 0, 0, m_seekerWaveform.width(), m_seekerWaveform.height() ),
-		0, m_currentSample.frames());
+void WaveForm::drawSeeker()
+{
+    m_seeker.fill(QColor(0, 0, 0, 0));
+    QPainter brush(&m_seeker);
+    brush.setPen(m_waveformColor);
+
+    // draw slice points
+    brush.setPen(m_sliceColor);
+    for (int i = 0;i<m_slicePoints.size();i++)
+    {
+        float xPos = (float)m_slicePoints[i] / (float)m_currentSample.frames() * (float)m_width;
+        brush.drawLine(xPos, 0, xPos, m_height);
     }
 
-    void WaveForm::drawSeeker() {
-        m_seeker.fill(QColor(0, 0, 0, 0));
-        QPainter brush(&m_seeker);
-        brush.setPen(m_waveformColor);
+    // draw current playBack
+    brush.setPen(m_playColor);
+    brush.drawLine(m_noteCurrent*m_width, 0, m_noteCurrent*m_width, m_height);
+    brush.fillRect(m_noteStart*m_width, 0, (m_noteEnd-m_noteStart)*m_width, m_height, m_playHighlighColor);
 
-        // draw slice points
-        brush.setPen(m_sliceColor);
-        for (int i = 0;i<m_slicePoints.size();i++)
-        {
-            float xPos = (float)m_slicePoints[i] / (float)m_currentSample.frames() * (float)m_width;
-            brush.drawLine(xPos, 0, xPos, m_height);
-        }
-
-        // draw current playBack
-        brush.setPen(m_playColor);
-        brush.drawLine(m_noteCurrent*m_width, 0, m_noteCurrent*m_width, m_height);
-        brush.fillRect(m_noteStart*m_width, 0, (m_noteEnd-m_noteStart)*m_width, m_height, m_playHighlighColor);
+    // draw m_seeker points
+    brush.setPen(QPen(m_seekerColor, 3));
+    brush.drawLine(m_seekerStart*m_width, 0, m_seekerStart*m_width, m_height);
+    brush.drawLine(m_seekerEnd*m_width, 0, m_seekerEnd*m_width, m_height);
 
-        // draw m_seeker points
-        brush.setPen(QPen(m_seekerColor, 3));
-        brush.drawLine(m_seekerStart*m_width, 0, m_seekerStart*m_width, m_height);
-        brush.drawLine(m_seekerEnd*m_width, 0, m_seekerEnd*m_width, m_height);
+    // shadow on not selected area
+    brush.fillRect(0, 0, m_seekerStart*m_width, m_height, m_seekerShadowColor);
+    brush.fillRect(m_seekerEnd*m_width, 0, m_width, m_height, m_seekerShadowColor);
+}
 
-        // shadow on not selected area
-        brush.fillRect(0, 0, m_seekerStart*m_width, m_height, m_seekerShadowColor);
-        brush.fillRect(m_seekerEnd*m_width, 0, m_width, m_height, m_seekerShadowColor);
-    }
+void WaveForm::updateUI()
+{
+    drawSeekerWaveform();
+    drawSeeker();
+    drawEditor();
+    update();
+}
 
-    void WaveForm::updateUI() {
-        drawSeekerWaveform();
-        drawSeeker();
-        drawEditor();
-        update();
-    }
+void WaveForm::updateData()
+{
+    m_currentSample = SampleBuffer(m_slicerTParent->m_originalSample.data(), m_slicerTParent->m_originalSample.frames());
+    updateUI();
+}
 
-    void WaveForm::updateData() {
-        m_currentSample = SampleBuffer(m_slicerTParent->m_originalSample.data(), m_slicerTParent->m_originalSample.frames());
-        updateUI();
-    }
+void WaveForm::isPlaying(float current, float start, float end)
+{
+    m_noteCurrent = current;
+    m_noteStart = start;
+    m_noteEnd = end;
+    drawSeeker(); // only update seeker, else horrible performance
+    update();
+}
+
+void WaveForm::mousePressEvent( QMouseEvent * me )
+{
+    float normalizedClick = (float)me->x() / m_width;
 
-    void WaveForm::isPlaying(float current, float start, float end) {
-        m_noteCurrent = current;
-        m_noteStart = start;
-        m_noteEnd = end;
-        drawSeeker(); // only update seeker, else horrible performance
-        update();
+    if (me->button() == Qt::MouseButton::MiddleButton)
+    {
+        m_seekerStart = 0;
+        m_seekerEnd = 1;
+        return;
     }
 
-    void WaveForm::mousePressEvent( QMouseEvent * me ) {
-        float normalizedClick = (float)me->x() / m_width;
-
-        if (me->button() == Qt::MouseButton::MiddleButton)
+    if (me->y() < m_height*m_m_seekerRatio)
+    {
+        if (abs(normalizedClick - m_seekerStart) < 0.03)
         {
-            m_seekerStart = 0;
-            m_seekerEnd = 1;
-            return;
-        }
+            m_currentlyDragging = m_draggingTypes::m_seekerStart;
 
-        if (me->y() < m_height*m_m_seekerRatio)
+        } else if (abs(normalizedClick - m_seekerEnd) < 0.03)
         {
-            if (abs(normalizedClick - m_seekerStart) < 0.03)
-            {
-                m_currentlyDragging = m_draggingTypes::m_seekerStart;
+            m_currentlyDragging = m_draggingTypes::m_seekerEnd;
 
-            } else if (abs(normalizedClick - m_seekerEnd) < 0.03)
-            {
-                m_currentlyDragging = m_draggingTypes::m_seekerEnd;
+        } else if (normalizedClick > m_seekerStart && normalizedClick < m_seekerEnd)
+        {
+            m_currentlyDragging = m_draggingTypes::m_seekerMiddle;
+            m_seekerMiddle = normalizedClick;
+        }
 
-            } else if (normalizedClick > m_seekerStart && normalizedClick < m_seekerEnd)
-            {
-                m_currentlyDragging = m_draggingTypes::m_seekerMiddle;
-                m_seekerMiddle = normalizedClick;
-            }
+    } else {
+        m_sliceSelected = -1;
+        float startFrame = m_seekerStart * m_currentSample.frames();
+        float endFrame = m_seekerEnd * m_currentSample.frames();
 
-        } else {
-            m_sliceSelected = -1;
-            float startFrame = m_seekerStart * m_currentSample.frames();
-            float endFrame = m_seekerEnd * m_currentSample.frames();
+        for (int i = 0;i<m_slicePoints.size();i++)
+        {
+            int sliceIndex = m_slicePoints[i];
+            float xPos = (float)(sliceIndex - startFrame) / (float)(endFrame - startFrame);
 
-            for (int i = 0;i<m_slicePoints.size();i++)
+            if (abs(xPos - normalizedClick) < 0.03)
             {
-                int sliceIndex = m_slicePoints[i];
-                float xPos = (float)(sliceIndex - startFrame) / (float)(endFrame - startFrame);
-
-                if (abs(xPos - normalizedClick) < 0.03)
-                {
-                    m_currentlyDragging = m_draggingTypes::slicePoint;
-                    m_sliceSelected = i;
-                }
+                m_currentlyDragging = m_draggingTypes::slicePoint;
+                m_sliceSelected = i;
             }
         }
-        if (me->button() == Qt::MouseButton::LeftButton)
-        {
-            m_isDragging = true;
+    }
+    if (me->button() == Qt::MouseButton::LeftButton)
+    {
+        m_isDragging = true;
 
-        } else if (me->button() == Qt::MouseButton::RightButton)
+    } else if (me->button() == Qt::MouseButton::RightButton)
+    {
+        if (m_sliceSelected != -1 && m_slicePoints.size() > 2)
         {
-            if (m_sliceSelected != -1 && m_slicePoints.size() > 2)
-            {
-                m_slicePoints.erase(m_slicePoints.begin() + m_sliceSelected);
-                m_sliceSelected = -1;
-            }
+            m_slicePoints.erase(m_slicePoints.begin() + m_sliceSelected);
+            m_sliceSelected = -1;
         }
-
     }
 
-    void WaveForm::mouseReleaseEvent( QMouseEvent * me ) {
-        m_isDragging = false;
-        m_currentlyDragging = m_draggingTypes::nothing;
-        updateUI();
-    }
+}
 
-    void WaveForm::mouseMoveEvent( QMouseEvent * me ) {
-        float normalizedClick = (float)me->x() / m_width;
+void WaveForm::mouseReleaseEvent( QMouseEvent * me )
+{
+    m_isDragging = false;
+    m_currentlyDragging = m_draggingTypes::nothing;
+    updateUI();
+}
 
-        // handle dragging events
-        if (m_isDragging) {
-            if (m_currentlyDragging == m_draggingTypes::m_seekerStart)
-            {
-                m_seekerStart = std::clamp(normalizedClick, 0.0f, m_seekerEnd - 0.13f);
+void WaveForm::mouseMoveEvent( QMouseEvent * me )
+{
+    float normalizedClick = (float)me->x() / m_width;
 
-            } else if (m_currentlyDragging == m_draggingTypes::m_seekerEnd)
-            {
-                m_seekerEnd = std::clamp(normalizedClick, m_seekerStart + 0.13f, 1.0f);;
+    // handle dragging events
+    if (m_isDragging)
+    {
+        if (m_currentlyDragging == m_draggingTypes::m_seekerStart)
+        {
+            m_seekerStart = std::clamp(normalizedClick, 0.0f, m_seekerEnd - 0.13f);
 
-            } else if (m_currentlyDragging == m_draggingTypes::m_seekerMiddle)
-            {
-                float distStart = m_seekerStart - m_seekerMiddle;
-                float distEnd = m_seekerEnd - m_seekerMiddle;
+        } else if (m_currentlyDragging == m_draggingTypes::m_seekerEnd)
+        {
+            m_seekerEnd = std::clamp(normalizedClick, m_seekerStart + 0.13f, 1.0f);;
 
-                m_seekerMiddle = normalizedClick;
+        } else if (m_currentlyDragging == m_draggingTypes::m_seekerMiddle)
+        {
+            float distStart = m_seekerStart - m_seekerMiddle;
+            float distEnd = m_seekerEnd - m_seekerMiddle;
 
-                if (m_seekerMiddle + distStart > 0 && m_seekerMiddle + distEnd < 1)
-                {
-                    m_seekerStart = m_seekerMiddle + distStart;
-                    m_seekerEnd = m_seekerMiddle + distEnd;
-                }
+            m_seekerMiddle = normalizedClick;
 
-            } else if (m_currentlyDragging == m_draggingTypes::slicePoint)
+            if (m_seekerMiddle + distStart > 0 && m_seekerMiddle + distEnd < 1)
             {
-                float startFrame = m_seekerStart * m_currentSample.frames();
-                float endFrame = m_seekerEnd * m_currentSample.frames();
+                m_seekerStart = m_seekerMiddle + distStart;
+                m_seekerEnd = m_seekerMiddle + distEnd;
+            }
+
+        } else if (m_currentlyDragging == m_draggingTypes::slicePoint)
+        {
+            float startFrame = m_seekerStart * m_currentSample.frames();
+            float endFrame = m_seekerEnd * m_currentSample.frames();
 
-                m_slicePoints[m_sliceSelected] = startFrame + normalizedClick * (endFrame - startFrame);
+            m_slicePoints[m_sliceSelected] = startFrame + normalizedClick * (endFrame - startFrame);
 
-                m_slicePoints[m_sliceSelected] = std::clamp(m_slicePoints[m_sliceSelected], 0, m_currentSample.frames());
+            m_slicePoints[m_sliceSelected] = std::clamp(m_slicePoints[m_sliceSelected], 0, m_currentSample.frames());
 
-                std::sort(m_slicePoints.begin(), m_slicePoints.end());
-            }
-            updateUI();
+            std::sort(m_slicePoints.begin(), m_slicePoints.end());
         }
+        updateUI();
     }
+}
 
-    void WaveForm::mouseDoubleClickEvent(QMouseEvent * me) {
-        float normalizedClick = (float)me->x() / m_width;
-        float startFrame = m_seekerStart * m_currentSample.frames();
-        float endFrame = m_seekerEnd * m_currentSample.frames();
+void WaveForm::mouseDoubleClickEvent(QMouseEvent * me)
+{
+    float normalizedClick = (float)me->x() / m_width;
+    float startFrame = m_seekerStart * m_currentSample.frames();
+    float endFrame = m_seekerEnd * m_currentSample.frames();
 
-        float slicePosition = startFrame + normalizedClick * (endFrame - startFrame);
+    float slicePosition = startFrame + normalizedClick * (endFrame - startFrame);
 
-        for (int i = 0;i<m_slicePoints.size();i++)
+    for (int i = 0;i<m_slicePoints.size();i++)
+    {
+        if (m_slicePoints[i] < slicePosition)
         {
-            if (m_slicePoints[i] < slicePosition)
-            {
-                m_slicePoints.insert(m_slicePoints.begin() + i, slicePosition);
-                break;
-            }
+            m_slicePoints.insert(m_slicePoints.begin() + i, slicePosition);
+            break;
         }
-
-        std::sort(m_slicePoints.begin(), m_slicePoints.end());
     }
 
-    void WaveForm::paintEvent( QPaintEvent * pe) {
-        QPainter p( this );
-        p.drawPixmap(0, 0 ,m_seekerWaveform);
-        p.drawPixmap(0, 0, m_seeker);
-        p.drawPixmap(0, m_height*0.3f + m_margin, m_sliceEditor);
+    std::sort(m_slicePoints.begin(), m_slicePoints.end());
+}
 
-    }
+void WaveForm::paintEvent( QPaintEvent * pe)
+{
+    QPainter p( this );
+    p.drawPixmap(0, 0 ,m_seekerWaveform);
+    p.drawPixmap(0, 0, m_seeker);
+    p.drawPixmap(0, m_height*0.3f + m_margin, m_sliceEditor);
+
+}
 } // namespace gui
 } // namespace lmms
\ No newline at end of file
diff --git a/plugins/SlicerT/WaveForm.h b/plugins/SlicerT/WaveForm.h
index de41c13f164..114655f1a67 100644
--- a/plugins/SlicerT/WaveForm.h
+++ b/plugins/SlicerT/WaveForm.h
@@ -60,7 +60,8 @@ class WaveForm : public QWidget {
         float m_m_seekerRatio = 0.3f;
         int m_margin = 5;
         QColor m_waveformBgColor = QColor(11, 11, 11);
-        QColor m_waveformColor = QColor(124, 49, 214);
+        QColor m_waveformColor = QColor(113, 0, 177);
+        // QColor m_waveformColor = QColor(255, 161, 247); // logo color
         QColor m_playColor = QColor(255, 255, 255, 200);
         QColor m_playHighlighColor = QColor(255, 255, 255, 70);
         QColor m_sliceColor = QColor(49, 214, 124);
diff --git a/plugins/SlicerT/artwork.png b/plugins/SlicerT/artwork.png
new file mode 100644
index 0000000000000000000000000000000000000000..a617f3c6ab3dd7a00de261fce9438cb4fd91130d
GIT binary patch
literal 10943
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

literal 0
HcmV?d00001


From 7391d6ddfe3bce3636d55aa405773dd90708f3d8 Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Fri, 15 Sep 2023 17:27:51 +0200
Subject: [PATCH 21/99] threadsafe(maybe) + UI finished

---
 plugins/SlicerT/CopyMidiBtn.png | Bin 0 -> 749 bytes
 plugins/SlicerT/ResetBtn.png    | Bin 0 -> 14573 bytes
 plugins/SlicerT/SlicerT.cpp     |  18 +++++------
 plugins/SlicerT/SlicerT.h       |  18 +++++++----
 plugins/SlicerT/SlicerTUI.cpp   |  51 +++++++++++++++++++++-----------
 plugins/SlicerT/SlicerTUI.h     |  25 ++++++++++++----
 plugins/SlicerT/WaveForm.cpp    |   1 -
 plugins/SlicerT/WaveForm.h      |   2 +-
 plugins/SlicerT/artwork.png     | Bin 10943 -> 11467 bytes
 9 files changed, 75 insertions(+), 40 deletions(-)
 create mode 100644 plugins/SlicerT/CopyMidiBtn.png
 create mode 100644 plugins/SlicerT/ResetBtn.png

diff --git a/plugins/SlicerT/CopyMidiBtn.png b/plugins/SlicerT/CopyMidiBtn.png
new file mode 100644
index 0000000000000000000000000000000000000000..8687fb29b44a5a3c213d0eeee6c75d8c8ad3cc92
GIT binary patch
literal 749
zcmV<J0uud+P)<h;3K|Lk000e1NJLTq000{R001lq1^@s6l&ix)0004mX+uL$Nkc;*
zaB^>EX>4Tx04R}tkv&MmKpe$iQ>7}^4t5Z62w0u$q9Ts93Pq?8YK2xEOfLO`CJjl8
zi=*ILaPVWX>fqw6tAnc`2!4RLx;QDiNQwVT3N2zhIPS;0dyl(!fY2y2&FYE)nqD<i
ziMW`_u8M(I^df`-L@+8d%b1g-Bs|C0J$!t<i}Eb*bAOJ0HD@uvClbe)VOEJZh-Wsd
z2Iqa^Fe}O`@j3B?Nf#u3<htVW8|Q+<0?!Pa>C`-Nm{=@yu+qV-XllgM#1U1~DPPFA
zta9Gstd(o5bx;1nU`}6I<~q$0B(R7jND!f*h7!uCB1)@HiiH&I$36VRj$a~|Laq`R
zITlcX2HEk0|H1EWt^Cxan-q)#-7mKNF$M&7fo9#dzmILZc>?&Kfh)c3uQY(!Ptxmc
zEph~ewt<W5wx;X>mpj1FlOdb3Bl&3x`8@D`M&FbL25*7BHMh6cK29HiG<B7{0S*p<
z@d9P9d%U}+v$ucGwEFu2tABF6mzSZP00006VoOIv0RI600RN!9r;`8x010qNS#tmY
zE+YT{E+YYWr9XB6000McNliru=LruF1r`t)^^^br02y>eSad^gZEa<4bO1wgWnpw>
zWFU8GbZ8()Nlj2!fese{006~FL_t(o!|j(r4ul{KMX7Nyr}S<!mz>#sH<DChp=hg_
z(5{3wJllQ<P}&UdFVY!XUWtfE6FMaW1AyCLTA&$B12l!Tfab6o&;=#|-C##RS6B(0
zFR%9bsYBf}dki+$&b(cjq;V}~m@)>;S&gMCrLi;@J-feW9S3ZbF<@bX8c7#Q?VHQ(
zeRVlA0BB{we}>0O)i_!c0Ge5qem>Uv^7qJhkh5YSqFlb*zll$JLA&-@uNt}EY`^v@
f`Tqq{3M1PJL7j|s^ABO~00000NkvXXu0mjf@~%XQ

literal 0
HcmV?d00001

diff --git a/plugins/SlicerT/ResetBtn.png b/plugins/SlicerT/ResetBtn.png
new file mode 100644
index 0000000000000000000000000000000000000000..0d9713132ae8e4d87411f355efa0c83058eafdb5
GIT binary patch
literal 14573
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

literal 0
HcmV?d00001

diff --git a/plugins/SlicerT/SlicerT.cpp b/plugins/SlicerT/SlicerT.cpp
index 0b7cc6ea7e3..b88e77a57eb 100644
--- a/plugins/SlicerT/SlicerT.cpp
+++ b/plugins/SlicerT/SlicerT.cpp
@@ -103,8 +103,9 @@ void SlicerT::playNote( NotePlayHandle * handle, sampleFrame * workingBuffer )
 
 	if( noteFramesLeft > 0)
 	{
-		int bufferSize = frames * BYTES_PER_FRAME;
-		memcpy(workingBuffer + offset, m_timeShiftedSample.data() + currentNoteFrame, bufferSize);
+		// int bufferSize = frames * BYTES_PER_FRAME;
+		int framesToCopy = std::min((int)frames, noteFramesLeft);
+		m_timeShiftedSample.copyFrames(workingBuffer + offset, currentNoteFrame, framesToCopy);
 
 		// exponential fade out, applyRelease kinda sucks
 		if (noteFramesLeft < m_fadeOutFrames.value())
@@ -129,7 +130,7 @@ void SlicerT::playNote( NotePlayHandle * handle, sampleFrame * workingBuffer )
 		float abslouteEndNote = (float)sliceEnd / totalFrames;
 		emit isPlaying(absoluteCurrentNote, absoluteStartNote, abslouteEndNote);
 	} else {
-		emit isPlaying(0, 0, 0);
+		emit isPlaying(-1, 0, 0);
 	}
 }
 
@@ -213,10 +214,7 @@ void SlicerT::timeShiftSample()
 	using std::vector;
 	// initial checks
 	if (m_originalSample.frames() < 2048) { return; }
-
-	if (m_timeshiftLock) { return; }
-	m_timeshiftLock = true;
-
+	m_timeshiftLock.lock();
 
 	// original sample data
 	float sampleRate = m_originalSample.sampleRate();
@@ -230,7 +228,7 @@ void SlicerT::timeShiftSample()
 	if (targetBPM == m_originalBPM.value())
 	{
 		m_timeShiftedSample.setData(m_originalSample.data(), m_originalSample.frames());
-		m_timeshiftLock = false;
+		m_timeshiftLock.unlock();
 		return;
 	}
 
@@ -256,7 +254,7 @@ void SlicerT::timeShiftSample()
 	// write processed channels
 	m_timeShiftedSample.setData(outDataL, outDataR);
 
-	m_timeshiftLock = false;
+	m_timeshiftLock.unlock();
 }
 
 // basic phase vocoder implementation that time shifts without pitch change
@@ -399,7 +397,7 @@ void SlicerT::phaseVocoder(std::vector<float> &dataIn, std::vector<float> &dataO
 		for (int j = 0; j < windowSize; j++)
 		{
 			float outIndex = i * outStepSize + j;
-			if (outIndex > outFrames) { break; }
+			if (outIndex >= outFrames) { break; }
 
 			// calculate windows overlapping at index
 			float startWindowOverlap = ceil(outIndex / outStepSize + 0.00000001f);
diff --git a/plugins/SlicerT/SlicerT.h b/plugins/SlicerT/SlicerT.h
index 9f80575091c..34fb6bd4b46 100644
--- a/plugins/SlicerT/SlicerT.h
+++ b/plugins/SlicerT/SlicerT.h
@@ -42,19 +42,27 @@ namespace lmms
 // small helper class, since SampleBuffer is inadequate (not thread safe, no dinamic startpoint)
 class PlaybackBuffer {
 	public:
+		QMutex dataLock;
 		std::vector<sampleFrame> mainBuffer;
 
-		int frames() { return mainBuffer.size(); };
-		sampleFrame * data() { return mainBuffer.data(); };
-
+		int frames() { return mainBuffer.size(); }; // not thread safe yet, but shouldnt be a big issue
+		sampleFrame * data() {  return mainBuffer.data(); };
+		void copyFrames(sampleFrame * outData, int start, int framesToCopy) {
+			dataLock.lock();
+			memcpy(outData, mainBuffer.data() + start, framesToCopy * sizeof(sampleFrame));
+			dataLock.unlock();
+		}
 		void setData(const sampleFrame * data, int newFrames)
 		{
+			dataLock.lock();
 			mainBuffer = {};
 			mainBuffer.resize(newFrames);
 			memcpy(mainBuffer.data(), data, newFrames * sizeof(sampleFrame));
+			dataLock.unlock();
 		};
 		void setData(std::vector<float> & leftData, std::vector<float> & rightData)
 		{
+			dataLock.lock();
 			int newFrames = std::min(leftData.size(), rightData.size());
 			mainBuffer = {};
 			mainBuffer.resize(newFrames);
@@ -64,6 +72,7 @@ class PlaybackBuffer {
 				mainBuffer[i][0] = leftData[i];
 				mainBuffer[i][1] = rightData[i];
 			}
+			dataLock.unlock();
 		}
 };
 
@@ -86,7 +95,6 @@ class SlicerT : public Instrument{
 
 	public slots:
 		void updateFile(QString file);
-		void updateTimeShift();
 		void updateSlices();
 
 	signals:
@@ -102,7 +110,7 @@ class SlicerT : public Instrument{
 		std::vector<int> m_slicePoints;
 
 		float m_currentSpeedRatio = 0;
-		bool m_timeshiftLock; // dont run timeshifting at the same time, instant crash
+		QMutex m_timeshiftLock; // should be unecesaty since playbackBuffer is safe
 		// std::unordered_map<int, std::vector<float> > m_fftWindowCache;
 
 		void findSlices();
diff --git a/plugins/SlicerT/SlicerTUI.cpp b/plugins/SlicerT/SlicerTUI.cpp
index dfeb154f4d6..137b764a7aa 100644
--- a/plugins/SlicerT/SlicerTUI.cpp
+++ b/plugins/SlicerT/SlicerTUI.cpp
@@ -46,43 +46,59 @@ namespace lmms
 namespace gui
 {
 
+
 SlicerTUI::SlicerTUI( SlicerT * instrument,
 					QWidget * parent ) :
 	InstrumentViewFixedSize( instrument, parent ),
 	m_slicerTParent(instrument),
-	m_backgroundImage(PLUGIN_NAME::getIconPixmap(
-								"artwork" )),
-	m_noteThresholdKnob(KnobType::Dark28, this),
-	m_fadeOutKnob(KnobType::Dark28, this),
+	m_noteThresholdKnob(this),
+	m_fadeOutKnob(this),
 	m_bpmBox(3, "19green", this),
-	m_resetButton(embed::getIconPixmap("reload"), QString(), this),
-	m_midiExportButton(embed::getIconPixmap("midi_tab"), QString(), this),
+	m_resetButton(this, nullptr),
+	m_midiExportButton(this, nullptr),
 	m_wf(244, 125, instrument, this)
 {
 	setAcceptDrops( true );
+	setAutoFillBackground( true );
+
+	QPalette pal;
+	pal.setBrush( backgroundRole(), PLUGIN_NAME::getIconPixmap( "artwork" ) );
+	pal.setColor(QPalette::All, QPalette::ColorRole::Foreground, Qt::red);
+	pal.setColor(QPalette::All, QPalette::ColorRole::Button, Qt::red);
+	pal.setColor(QPalette::All, QPalette::ColorRole::Base, Qt::red);
+	pal.setColor(QPalette::All, QPalette::ColorRole::Highlight, Qt::red);
+	setPalette( pal );
 
 	m_wf.move(3, 5);
 
-	m_bpmBox.move(2, 150);
+	m_bpmBox.move(7, 153);
 	m_bpmBox.setToolTip(tr("Original sample BPM"));
 	m_bpmBox.setLabel(tr("BPM"));
 	m_bpmBox.setModel(&m_slicerTParent->m_originalBPM);
 
-	m_fadeOutKnob.move(200, 150);
+	m_noteThresholdKnob.move(7, 200);
+	m_noteThresholdKnob.setToolTip(tr("Threshold used for slicing"));
+	// m_noteThresholdKnob.setLabel(tr("Threshold"));
+	m_noteThresholdKnob.setModel(&m_slicerTParent->m_noteThreshold);
+
+	m_fadeOutKnob.move(200, 200);
 	m_fadeOutKnob.setToolTip(tr("FadeOut for notes"));
-	m_fadeOutKnob.setLabel(tr("FadeOut"));
+	// m_fadeOutKnob.setLabel(tr("FadeOut"));
 	m_fadeOutKnob.setModel(&m_slicerTParent->m_fadeOutFrames);
 
-	m_midiExportButton.move(150, 200);
+	m_midiExportButton.move(145, 198);
+	m_midiExportButton.setActiveGraphic(
+						PLUGIN_NAME::getIconPixmap( "CopyMidiBtn" ) );
+	m_midiExportButton.setInactiveGraphic(
+						PLUGIN_NAME::getIconPixmap( "CopyMidiBtn" ) );
 	m_midiExportButton.setToolTip(tr("Copy midi pattern to clipboard"));
 	connect(&m_midiExportButton, SIGNAL( clicked() ), this, SLOT( exportMidi() ));
 
-	m_noteThresholdKnob.move(7, 200);
-	m_noteThresholdKnob.setToolTip(tr("Threshold used for slicing"));
-	m_noteThresholdKnob.setLabel(tr("Threshold"));
-	m_noteThresholdKnob.setModel(&m_slicerTParent->m_noteThreshold);
-
-	m_resetButton.move(70, 200);
+	m_resetButton.move(80, 198);
+	m_resetButton.setActiveGraphic(
+						PLUGIN_NAME::getIconPixmap( "ResetBtn" ) );
+	m_resetButton.setInactiveGraphic(
+						PLUGIN_NAME::getIconPixmap( "ResetBtn" ) );
 	m_resetButton.setToolTip(tr("Reset Slices"));
 	connect(&m_resetButton, SIGNAL( clicked() ), m_slicerTParent, SLOT( updateSlices() ));
 }
@@ -97,6 +113,7 @@ void SlicerTUI::exportMidi()
 	dataFile.content().appendChild( note_list );
 
 	std::vector<Note> notes;
+	m_slicerTParent->timeShiftSample();
 	m_slicerTParent->writeToMidi(&notes);
 	if (notes.size() == 0)
 	{
@@ -169,8 +186,6 @@ void SlicerTUI::dropEvent( QDropEvent * de )
 
 void SlicerTUI::paintEvent(QPaintEvent * pe)
 {
-	QPainter p( this );
-	p.drawPixmap(0, 0, m_backgroundImage);
 }
 
 } // namespace gui
diff --git a/plugins/SlicerT/SlicerTUI.h b/plugins/SlicerT/SlicerTUI.h
index 13cf132fd57..c9be4e2aeeb 100644
--- a/plugins/SlicerT/SlicerTUI.h
+++ b/plugins/SlicerT/SlicerTUI.h
@@ -32,6 +32,7 @@
 #include "Instrument.h"
 #include "InstrumentView.h"
 #include "Knob.h"
+#include "PixmapButton.h"
 #include "LcdSpinBox.h"
 
 
@@ -43,6 +44,21 @@ class SlicerT;
 namespace gui
 {
 
+class SlicerTKnob : public Knob {
+	public:
+		SlicerTKnob( QWidget * _parent ) :
+				Knob( KnobType::Styled, _parent )
+		{
+		setFixedSize( 46, 40 );
+		setCenterPointX( 23.0 );
+		setCenterPointY( 15.0 );
+		setInnerRadius( 8 );
+		setOuterRadius( 11 );
+		// setTotalAngle( 270.0 );
+		setLineWidth( 3 );
+		setOuterColor( QColor(255, 161, 247) );
+		}
+};
 
 class SlicerTUI : public InstrumentViewFixedSize
 {
@@ -65,14 +81,13 @@ protected slots:
 
 private:
 	SlicerT * m_slicerTParent;
-	QPixmap m_backgroundImage;
 
-	Knob m_noteThresholdKnob;
-	Knob m_fadeOutKnob;
+	SlicerTKnob m_noteThresholdKnob;
+	SlicerTKnob m_fadeOutKnob;
 	LcdSpinBox m_bpmBox;
 
-	QPushButton m_resetButton;
-	QPushButton m_midiExportButton;
+	PixmapButton m_resetButton;
+	PixmapButton m_midiExportButton;
 
 	WaveForm m_wf;
 };
diff --git a/plugins/SlicerT/WaveForm.cpp b/plugins/SlicerT/WaveForm.cpp
index 66c168d947e..b6749776d00 100644
--- a/plugins/SlicerT/WaveForm.cpp
+++ b/plugins/SlicerT/WaveForm.cpp
@@ -294,7 +294,6 @@ void WaveForm::paintEvent( QPaintEvent * pe)
     p.drawPixmap(0, 0 ,m_seekerWaveform);
     p.drawPixmap(0, 0, m_seeker);
     p.drawPixmap(0, m_height*0.3f + m_margin, m_sliceEditor);
-
 }
 } // namespace gui
 } // namespace lmms
\ No newline at end of file
diff --git a/plugins/SlicerT/WaveForm.h b/plugins/SlicerT/WaveForm.h
index 114655f1a67..6b78989b049 100644
--- a/plugins/SlicerT/WaveForm.h
+++ b/plugins/SlicerT/WaveForm.h
@@ -59,7 +59,7 @@ class WaveForm : public QWidget {
         int m_height;
         float m_m_seekerRatio = 0.3f;
         int m_margin = 5;
-        QColor m_waveformBgColor = QColor(11, 11, 11);
+        QColor m_waveformBgColor = QColor(11, 11, 11, 200);
         QColor m_waveformColor = QColor(113, 0, 177);
         // QColor m_waveformColor = QColor(255, 161, 247); // logo color
         QColor m_playColor = QColor(255, 255, 255, 200);
diff --git a/plugins/SlicerT/artwork.png b/plugins/SlicerT/artwork.png
index a617f3c6ab3dd7a00de261fce9438cb4fd91130d..d3a44cc9e5ae9720cdb65a2168a485b82e4d667b 100644
GIT binary patch
delta 11425
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

delta 10924
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
O002n`MNUMnLSTYnPGSrI


From c9ac279ab33607fd1e84979b78a41b3a37d61947 Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Sat, 16 Sep 2023 20:52:38 +0200
Subject: [PATCH 22/99] preparing for dinamic timeshifting

---
 plugins/SlicerT/SlicerT.cpp | 97 ++++++++++++++++++-------------------
 plugins/SlicerT/SlicerT.h   | 32 +++++++++++-
 2 files changed, 77 insertions(+), 52 deletions(-)

diff --git a/plugins/SlicerT/SlicerT.cpp b/plugins/SlicerT/SlicerT.cpp
index b88e77a57eb..333025dfac1 100644
--- a/plugins/SlicerT/SlicerT.cpp
+++ b/plugins/SlicerT/SlicerT.cpp
@@ -22,9 +22,8 @@
  *
  */
 
-// TODO: fade in mode
-// TODO: general UI improvements, maybe open folders button
-// TODO: add fft cache, maybe this is overkill but whatever
+// write in frames to outputBuffer
+// store the stuff that has to be reused in a fullsized buffer
 
 #include "SlicerT.h"
 
@@ -66,15 +65,39 @@ SlicerT::SlicerT(InstrumentTrack * instrumentTrack) :
 	m_noteThreshold(0.6f, 0.0f, 2.0f, 0.01f, this, tr( "Note threshold" ) ),
 	m_fadeOutFrames(0.0f, 0.0f, 8192.0f, 4.0f, this, tr("FadeOut")),
 	m_originalBPM(1, 1, 999, this, tr("Original bpm")),
-	m_originalSample()
+	m_originalSample(),
+
+	FFTInput(windowSize, 0),
+	IFFTReconstruction(windowSize, 0),
+	allMagnitudes(windowSize, 0),
+	allFrequencies(windowSize, 0),
+	processedFreq(windowSize, 0),
+	processedMagn(windowSize, 0)
 {}
 
+void SlicerT::updateParams(float newRatio) {
+	stepSize = (float)windowSize / overSampling;
+	numWindows = (float)m_originalSample.frames() / stepSize;
+	outStepSize = newRatio * (float)stepSize; // float, else inaccurate
+	freqPerBin = m_originalSample.sampleRate()/windowSize;
+	expectedPhaseIn = 2.*M_PI*(float)stepSize/(float)windowSize;
+	expectedPhaseOut = 2.*M_PI*(float)outStepSize/(float)windowSize;
+
+	// resize all the buffers that rely on the final size
+	m_timeshiftedBufferL = {};
+	m_timeshiftedBufferL.resize(newRatio*m_originalSample.frames());
+	lastPhase = {};
+	lastPhase.resize(numWindows*windowSize);
+	sumPhase = {};
+	sumPhase.resize(numWindows*windowSize);
+}
 
 void SlicerT::playNote( NotePlayHandle * handle, sampleFrame * workingBuffer )
 {
 	if (m_originalSample.frames() < 2048) { return; }
 
 	const float speedRatio = (float)m_originalBPM.value() / Engine::getSong()->getTempo() ;
+	// const float lengthRatio = 1.0f / speedRatio; // inverse, because longer is slower
 	const int noteIndex = handle->key() - 69;
 	const fpp_t frames = handle->framesLeftForCurrentPeriod();
 	const f_cnt_t offset = handle->noteOffset();
@@ -82,6 +105,7 @@ void SlicerT::playNote( NotePlayHandle * handle, sampleFrame * workingBuffer )
 
 	if (m_currentSpeedRatio != speedRatio)
 	{
+		updateParams(speedRatio);
 		timeShiftSample();
 	}
 	const int totalFrames = m_timeShiftedSample.frames();
@@ -248,8 +272,8 @@ void SlicerT::timeShiftSample()
 	}
 
 	// process channels
-	phaseVocoder(rawDataL, outDataL, sampleRate, 1);
-	phaseVocoder(rawDataR, outDataR, sampleRate, 1);
+	phaseVocoder(rawDataL, outDataL);
+	phaseVocoder(rawDataR, outDataR);
 
 	// write processed channels
 	m_timeShiftedSample.setData(outDataL, outDataR);
@@ -263,50 +287,18 @@ void SlicerT::timeShiftSample()
 // https://sethares.engr.wisc.edu/vocoders/phasevocoder.html
 // https://dsp.stackexchange.com/questions/40101/audio-time-stretching-without-pitch-shifting/40367#40367
 // https://www.guitarpitchshifter.com/
-void SlicerT::phaseVocoder(std::vector<float> &dataIn, std::vector<float> &dataOut, float sampleRate, float pitchScale)
+void SlicerT::phaseVocoder(std::vector<float> &dataIn, std::vector<float> &dataOut)
 {
-	using std::vector;
-	// processing parameters, lower is faster
-	// lower windows size seems to work better for time scaling,
-	// this is because the step site is scaled, but not the window size
-	// this causes slight timing differences between windows
-	// sadly, lower windowsize also reduces audio quality in general
-	// TODO: find solution
-	// oversampling is better if higher always (probably)
-	const int windowSize = 512;
-	const int overSampling = 32;
-
-	// audio data
-	int inFrames = dataIn.size();
+	memset(lastPhase.data(), 0, numWindows*windowSize*sizeof(float));
+	memset(sumPhase.data(), 0, numWindows*windowSize*sizeof(float));
+
 	int outFrames = dataOut.size();
 
-	float lengthRatio = (float)outFrames / inFrames;
-
-	// values used
-	const int stepSize = (float)windowSize / overSampling;
-	const int numWindows = (float)inFrames / stepSize;
-	const float outStepSize = lengthRatio * (float)stepSize; // float, else inaccurate
-	const float freqPerBin = sampleRate/windowSize;
-	// very important
-	const float expectedPhaseIn = 2.*M_PI*(float)stepSize/(float)windowSize;
-	const float expectedPhaseOut = 2.*M_PI*(float)outStepSize/(float)windowSize;
-
-	// initialize buffers
-	fftwf_complex FFTSpectrum[windowSize];
-	vector<float> FFTInput(windowSize, 0);
-	vector<float> IFFTReconstruction(windowSize, 0);
-	vector<float> allMagnitudes(windowSize, 0);
-	vector<float> allFrequencies(windowSize, 0);
-	vector<float> processedFreq(windowSize, 0);
-	vector<float> processedMagn(windowSize, 0);
-	vector<float> lastPhase(windowSize, 0);
-	vector<float> sumPhase(windowSize, 0);
-
-	vector<float> outBuffer(outFrames, 0);
+	std::vector<float> outBuffer(outFrames, 0);
 
 	// declare vars
 	float real, imag, phase, magnitude, freq, deltaPhase = 0;
-	int windowIndex = 0;
+		int windowIndex = 0;
 
 	// fft plans
 	fftwf_plan fftPlan;
@@ -322,7 +314,7 @@ void SlicerT::phaseVocoder(std::vector<float> &dataIn, std::vector<float> &dataO
 		memcpy(FFTInput.data(), dataIn.data() + windowIndex, windowSize*sizeof(float));
 
 		// int hash = hashFttWindow(FFTInput);
-		// printf("%i\n", hash);
+			// printf("%i\n", hash);
 
 		// FFT
 		fftwf_execute(fftPlan);
@@ -330,14 +322,16 @@ void SlicerT::phaseVocoder(std::vector<float> &dataIn, std::vector<float> &dataO
 		// analysis step
 		for (int j = 0; j < windowSize; j++)
 		{
+			int windowIndex = (float)i*windowSize;
+
 			real = FFTSpectrum[j][0];
 			imag = FFTSpectrum[j][1];
 
 			magnitude = 2.*sqrt(real*real + imag*imag);
 			phase = atan2(imag,real);
 
-			freq = phase - lastPhase[j]; // subtract prev pahse to get phase diference
-			lastPhase[j] = phase;
+			freq = phase - lastPhase[std::max(0, windowIndex + j - windowSize)]; // subtract prev pahse to get phase diference
+			lastPhase[windowIndex + j] = phase;
 
 			freq -= (float)j*expectedPhaseIn; // subtract expected phase
 
@@ -372,6 +366,8 @@ void SlicerT::phaseVocoder(std::vector<float> &dataIn, std::vector<float> &dataO
 		// synthesis, all the operations are the reverse of the analysis
 		for (int j = 0; j < windowSize; j++)
 		{
+			int windowIndex = (float)i*windowSize;
+
 			magnitude = allMagnitudes[j];
 			freq = allFrequencies[j];
 
@@ -383,8 +379,9 @@ void SlicerT::phaseVocoder(std::vector<float> &dataIn, std::vector<float> &dataO
 
 			deltaPhase += (float)j*expectedPhaseOut;
 
-			sumPhase[j] += deltaPhase;
-			deltaPhase = sumPhase[j]; // this is the bin phase
+			sumPhase[windowIndex + j] += deltaPhase;
+			deltaPhase = sumPhase[windowIndex + j]; // this is the bin phase
+			sumPhase[windowIndex + j + windowSize] = deltaPhase; // copy into the next window for accurate sum
 
 			FFTSpectrum[j][0] = magnitude*cos(deltaPhase);
 			FFTSpectrum[j][1] = magnitude*sin(deltaPhase);
@@ -430,7 +427,7 @@ void SlicerT::phaseVocoder(std::vector<float> &dataIn, std::vector<float> &dataO
 		outBuffer[i] = outBuffer[i] / max;
 	}
 
-	memcpy(dataOut.data(), outBuffer.data(), outFrames*sizeof(float));
+memcpy(dataOut.data(), outBuffer.data(), outFrames*sizeof(float));
 }
 
 int SlicerT::hashFttWindow(std::vector<float> & in)
diff --git a/plugins/SlicerT/SlicerT.h b/plugins/SlicerT/SlicerT.h
index 34fb6bd4b46..e064bc5dde4 100644
--- a/plugins/SlicerT/SlicerT.h
+++ b/plugins/SlicerT/SlicerT.h
@@ -106,19 +106,47 @@ class SlicerT : public Instrument{
 		IntModel m_originalBPM;
 
 		SampleBuffer m_originalSample;
+
 		PlaybackBuffer m_timeShiftedSample;
+		std::vector<float> m_timeshiftedBufferL;
+		std::vector<float> m_timeshiftedBufferR;
+
+
 		std::vector<int> m_slicePoints;
 
-		float m_currentSpeedRatio = 0;
+		float m_currentSpeedRatio = -1;
 		QMutex m_timeshiftLock; // should be unecesaty since playbackBuffer is safe
 		// std::unordered_map<int, std::vector<float> > m_fftWindowCache;
 
+		void updateParams(float newRatio);
 		void findSlices();
 		void findBPM();
 		void timeShiftSample();
-		void phaseVocoder(std::vector<float> &in, std::vector<float> &out, float sampleRate, float pitchScale);
+		void phaseVocoder(std::vector<float> &in, std::vector<float> &out);
 		int hashFttWindow(std::vector<float> & in);
 
+		// timeshift stuff
+		static const int windowSize = 512;
+		static const int overSampling = 32;
+
+		int stepSize = 0;
+		int numWindows = 0;
+		float outStepSize = 0;
+		float freqPerBin = 0;
+		// very important
+		float expectedPhaseIn = 0;
+		float expectedPhaseOut = 0;
+
+		fftwf_complex FFTSpectrum[windowSize];
+		std::vector<float> FFTInput;
+		std::vector<float> IFFTReconstruction;
+		std::vector<float> allMagnitudes;
+		std::vector<float> allFrequencies;
+		std::vector<float> processedFreq;
+		std::vector<float> processedMagn;
+		std::vector<float> lastPhase;
+		std::vector<float> sumPhase;
+
 		friend class gui::SlicerTUI;
 		friend class gui::WaveForm;
 };

From 1a09f5f1dff040931c553801b5d0f9008d9c07bb Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Sun, 17 Sep 2023 13:14:23 +0200
Subject: [PATCH 23/99] dynamic timeshifting start

---
 plugins/SlicerT/SlicerT.cpp   | 158 ++++++++++++++++++----------------
 plugins/SlicerT/SlicerT.h     |  38 ++++++--
 plugins/SlicerT/SlicerTUI.cpp |   2 +-
 3 files changed, 118 insertions(+), 80 deletions(-)

diff --git a/plugins/SlicerT/SlicerT.cpp b/plugins/SlicerT/SlicerT.cpp
index 333025dfac1..6aa7b36e595 100644
--- a/plugins/SlicerT/SlicerT.cpp
+++ b/plugins/SlicerT/SlicerT.cpp
@@ -22,8 +22,9 @@
  *
  */
 
-// write in frames to outputBuffer
-// store the stuff that has to be reused in a fullsized buffer
+// TODO: deinterlace only once, always work with seperated buffers
+// TODO: start working from the start of the note
+// TODO: create a seperate class for phaseVocoder, that handles all the sampleData
 
 #include "SlicerT.h"
 
@@ -73,19 +74,31 @@ SlicerT::SlicerT(InstrumentTrack * instrumentTrack) :
 	allFrequencies(windowSize, 0),
 	processedFreq(windowSize, 0),
 	processedMagn(windowSize, 0)
-{}
+{
+	fftPlan = fftwf_plan_dft_r2c_1d(windowSize, FFTInput.data(), FFTSpectrum, FFTW_MEASURE);
+	ifftPlan = fftwf_plan_dft_c2r_1d(windowSize, FFTSpectrum, IFFTReconstruction.data(), FFTW_MEASURE);
+
+}
+
+void SlicerT::updateParams() {
+	float speedRatio = (float)m_originalBPM.value() / Engine::getSong()->getTempo() ;
 
-void SlicerT::updateParams(float newRatio) {
 	stepSize = (float)windowSize / overSampling;
 	numWindows = (float)m_originalSample.frames() / stepSize;
-	outStepSize = newRatio * (float)stepSize; // float, else inaccurate
+	outStepSize = speedRatio * (float)stepSize; // float, else inaccurate
 	freqPerBin = m_originalSample.sampleRate()/windowSize;
 	expectedPhaseIn = 2.*M_PI*(float)stepSize/(float)windowSize;
 	expectedPhaseOut = 2.*M_PI*(float)outStepSize/(float)windowSize;
 
 	// resize all the buffers that rely on the final size
+	// is there a better way for this? probably
 	m_timeshiftedBufferL = {};
-	m_timeshiftedBufferL.resize(newRatio*m_originalSample.frames());
+	m_timeshiftedBufferL.resize(speedRatio*m_originalSample.frames());
+	m_processedFrames = {};
+	m_processedFrames.resize(numWindows);
+	for (bool b : m_processedFrames) {
+		b = false;
+	}
 	lastPhase = {};
 	lastPhase.resize(numWindows*windowSize);
 	sumPhase = {};
@@ -105,10 +118,11 @@ void SlicerT::playNote( NotePlayHandle * handle, sampleFrame * workingBuffer )
 
 	if (m_currentSpeedRatio != speedRatio)
 	{
-		updateParams(speedRatio);
-		timeShiftSample();
+		updateParams();
+		// timeShiftSample(16);
+		m_currentSpeedRatio = speedRatio;
 	}
-	const int totalFrames = m_timeShiftedSample.frames();
+	const int totalFrames = m_timeshiftedBufferL.size();
 
 	int sliceStart, sliceEnd;
 	if (noteIndex > m_slicePoints.size()-2 || noteIndex < 0)
@@ -127,9 +141,23 @@ void SlicerT::playNote( NotePlayHandle * handle, sampleFrame * workingBuffer )
 
 	if( noteFramesLeft > 0)
 	{
+		std::vector<float> originalBuffer(m_originalSample.frames());
+		for (int i = 0;i<m_originalSample.frames();i++) {
+			originalBuffer[i] = m_originalSample.data()[i][0];
+		}
 		// int bufferSize = frames * BYTES_PER_FRAME;
 		int framesToCopy = std::min((int)frames, noteFramesLeft);
-		m_timeShiftedSample.copyFrames(workingBuffer + offset, currentNoteFrame, framesToCopy);
+
+		// phaseVocoder(originalBuffer, m_timeshiftedBufferL, (float)currentNoteFrame/stepSize, 17);
+		timeShiftSample(overSampling/2);
+
+		for (int i = 0;i<frames;i++) {
+			// printf("output: %f, original: %f\n", m_timeshiftedBufferL[currentNoteFrame + i], originalBuffer[(currentNoteFrame + i) / speedRatio]);
+			workingBuffer[i][0] = m_timeshiftedBufferL[currentNoteFrame + i];
+			workingBuffer[i][1] = m_timeshiftedBufferL[currentNoteFrame + i];
+		}
+
+		// m_timeShiftedSample.copyFrames(workingBuffer + offset, currentNoteFrame, framesToCopy);
 
 		// exponential fade out, applyRelease kinda sucks
 		if (noteFramesLeft < m_fadeOutFrames.value())
@@ -233,36 +261,18 @@ void SlicerT::findBPM()
 }
 
 // create timeshifted samplebuffer and timeshifted m_slicePoints
-void SlicerT::timeShiftSample()
+void SlicerT::timeShiftSample(int windowsToProcess)
 {
-	using std::vector;
 	// initial checks
 	if (m_originalSample.frames() < 2048) { return; }
 	m_timeshiftLock.lock();
 
 	// original sample data
-	float sampleRate = m_originalSample.sampleRate();
 	int originalFrames = m_originalSample.frames();
 
-	bpm_t targetBPM = Engine::getSong()->getTempo();
-	m_currentSpeedRatio = (float)m_originalBPM.value() / targetBPM ;
-	int outFrames = m_currentSpeedRatio * originalFrames;
-
-	// nothing to do here
-	if (targetBPM == m_originalBPM.value())
-	{
-		m_timeShiftedSample.setData(m_originalSample.data(), m_originalSample.frames());
-		m_timeshiftLock.unlock();
-		return;
-	}
-
 	// buffers
-	vector<float> rawDataL(originalFrames, 0);
-	vector<float> rawDataR(originalFrames, 0);
-	vector<float> outDataL(outFrames, 0);
-	vector<float> outDataR(outFrames, 0);
-
-	vector<sampleFrame> bufferData(outFrames, sampleFrame());
+	std::vector<float> rawDataL(originalFrames, 0);
+	std::vector<float> rawDataR(originalFrames, 0);
 
 	// copy channels for processing
 	for (int i = 0;i<originalFrames;i++)
@@ -271,12 +281,18 @@ void SlicerT::timeShiftSample()
 		rawDataR[i] = (float)m_originalSample.data()[i][1];
 	}
 
-	// process channels
-	phaseVocoder(rawDataL, outDataL);
-	phaseVocoder(rawDataR, outDataR);
+	int windowsProcessed = 0;
 
-	// write processed channels
-	m_timeShiftedSample.setData(outDataL, outDataR);
+	for (int i = 0;i<numWindows;i++) {
+		if (!m_processedFrames[i]) {
+			// process channels
+			phaseVocoder(rawDataL, m_timeshiftedBufferL, i, 1);
+			// phaseVocoder(rawDataR, m_timeshiftedBufferR, i, 1);
+			windowsProcessed++;
+		}
+		m_processedFrames[i] = true;
+		if (windowsProcessed >= windowsToProcess) { break; }
+	}
 
 	m_timeshiftLock.unlock();
 }
@@ -287,31 +303,28 @@ void SlicerT::timeShiftSample()
 // https://sethares.engr.wisc.edu/vocoders/phasevocoder.html
 // https://dsp.stackexchange.com/questions/40101/audio-time-stretching-without-pitch-shifting/40367#40367
 // https://www.guitarpitchshifter.com/
-void SlicerT::phaseVocoder(std::vector<float> &dataIn, std::vector<float> &dataOut)
+void SlicerT::phaseVocoder(std::vector<float> &dataIn, std::vector<float> &dataOut, int start, int steps)
 {
-	memset(lastPhase.data(), 0, numWindows*windowSize*sizeof(float));
-	memset(sumPhase.data(), 0, numWindows*windowSize*sizeof(float));
-
-	int outFrames = dataOut.size();
+	// memset(lastPhase.data(), 0, numWindows*windowSize*sizeof(float));
+	// memset(sumPhase.data(), 0, numWindows*windowSize*sizeof(float));
 
-	std::vector<float> outBuffer(outFrames, 0);
 
 	// declare vars
 	float real, imag, phase, magnitude, freq, deltaPhase = 0;
-		int windowIndex = 0;
+	int windowStart = 0;
 
 	// fft plans
-	fftwf_plan fftPlan;
-	fftPlan = fftwf_plan_dft_r2c_1d(windowSize, FFTInput.data(), FFTSpectrum, FFTW_MEASURE);
-	fftwf_plan ifftPlan;
-	ifftPlan = fftwf_plan_dft_c2r_1d(windowSize, FFTSpectrum, IFFTReconstruction.data(), FFTW_MEASURE);
+	// fftwf_plan fftPlan;
+	// fftPlan = fftwf_plan_dft_r2c_1d(windowSize, FFTInput.data(), FFTSpectrum, FFTW_MEASURE);
+	// fftwf_plan ifftPlan;
+	// ifftPlan = fftwf_plan_dft_c2r_1d(windowSize, FFTSpectrum, IFFTReconstruction.data(), FFTW_MEASURE);
 
 	// remove oversampling, because the actual window is overSampling* bigger than stepsize
-	for (int i = 0;i < numWindows-overSampling;i++)
+	for (int i = start;i < start + steps;i++)
 	{
-		windowIndex = i * stepSize;
-
-		memcpy(FFTInput.data(), dataIn.data() + windowIndex, windowSize*sizeof(float));
+		printf("%i\n", i);
+		windowStart = i * stepSize;
+		memcpy(FFTInput.data(), dataIn.data() + windowStart, windowSize*sizeof(float));
 
 		// int hash = hashFttWindow(FFTInput);
 			// printf("%i\n", hash);
@@ -394,40 +407,37 @@ void SlicerT::phaseVocoder(std::vector<float> &dataIn, std::vector<float> &dataO
 		for (int j = 0; j < windowSize; j++)
 		{
 			float outIndex = i * outStepSize + j;
-			if (outIndex >= outFrames) { break; }
+			if (outIndex >= dataOut.size()) { break; }
 
 			// calculate windows overlapping at index
 			float startWindowOverlap = ceil(outIndex / outStepSize + 0.00000001f);
-			float endWindowOverlap = ceil((float)(-outIndex + outFrames) / outStepSize + 0.00000001f);
+			float endWindowOverlap = ceil((float)(-outIndex + dataOut.size()) / outStepSize + 0.00000001f);
 			float totalWindowOverlap = std::min(
 										std::min(startWindowOverlap, endWindowOverlap),
 										(float)overSampling);
 
 			// discrete windowing
-			outBuffer[outIndex] += (float)overSampling/totalWindowOverlap*IFFTReconstruction[j]/(windowSize/2.0f*overSampling);
-
+			dataOut[outIndex] += (float)overSampling/totalWindowOverlap*IFFTReconstruction[j]/(windowSize/2.0f*overSampling);
+			// printf("timeshifted in phase: %f\n", m_timeshiftedBufferL[outIndex]);
 			// continuos windowing
 			// float window = -0.5f*cos(2.*M_PI*(float)j/(float)windowSize)+0.5f;
 			// outBuffer[outIndex] += 2.0f*window*IFFTReconstruction[j]/(windowSize/2.0f*overSampling);
 		}
 	}
 
-	fftwf_destroy_plan(fftPlan);
-	fftwf_destroy_plan(ifftPlan);
-
 	// normalize
-	float max = -1;
-	for (int i = 0;i<outFrames;i++)
-	{
-		max = std::max(max, abs(outBuffer[i]));
-	}
-
-	for (int i = 0;i<outFrames;i++)
-	{
-		outBuffer[i] = outBuffer[i] / max;
-	}
-
-memcpy(dataOut.data(), outBuffer.data(), outFrames*sizeof(float));
+	// float max = -1;
+	// for (int i = 0;i<outFrames;i++)
+	// {
+	// 	max = std::max(max, abs(dataOut[i]));
+	// }
+
+	// for (int i = 0;i<outFrames;i++)
+	// {
+	// 	dataOut[i] = dataOut[i] / max;
+	// }
+
+// memcpy(dataOut.data(), outBuffer.data(), outFrames*sizeof(float));
 }
 
 int SlicerT::hashFttWindow(std::vector<float> & in)
@@ -467,6 +477,10 @@ void SlicerT::writeToMidi(std::vector<Note> * outClip)
 	}
 }
 
+void SlicerT::extractOriginalData() {
+
+}
+
 void SlicerT::updateFile(QString file)
 {
 	m_originalSample.setAudioFile(file);
@@ -474,7 +488,7 @@ void SlicerT::updateFile(QString file)
 
 	findSlices();
 	findBPM();
-	timeShiftSample();
+	updateParams();
 
 	emit dataChanged();
 }
@@ -537,7 +551,7 @@ void SlicerT::loadSettings( const QDomElement & element )
 	m_noteThreshold.loadSettings(element, "threshold");
 	m_originalBPM.loadSettings(element, "origBPM");
 
-	timeShiftSample();
+	updateParams();
 
 	emit dataChanged();
 
diff --git a/plugins/SlicerT/SlicerT.h b/plugins/SlicerT/SlicerT.h
index e064bc5dde4..6838c4eeeba 100644
--- a/plugins/SlicerT/SlicerT.h
+++ b/plugins/SlicerT/SlicerT.h
@@ -44,6 +44,9 @@ class PlaybackBuffer {
 	public:
 		QMutex dataLock;
 		std::vector<sampleFrame> mainBuffer;
+		std::vector<float> leftBuffer;
+		std::vector<float> rightBuffer;
+		float sampleMax = -1;
 
 		int frames() { return mainBuffer.size(); }; // not thread safe yet, but shouldnt be a big issue
 		sampleFrame * data() {  return mainBuffer.data(); };
@@ -52,15 +55,28 @@ class PlaybackBuffer {
 			memcpy(outData, mainBuffer.data() + start, framesToCopy * sizeof(sampleFrame));
 			dataLock.unlock();
 		}
-		void setData(const sampleFrame * data, int newFrames)
-		{
-			dataLock.lock();
+		void resetAndResize(int newFrames) {
 			mainBuffer = {};
 			mainBuffer.resize(newFrames);
+			leftBuffer = {};
+			leftBuffer.resize(newFrames);
+			rightBuffer = {};
+			rightBuffer.resize(newFrames);
+		}
+		void loadSample(const sampleFrame * data, int newFrames)
+		{
+			dataLock.lock();
+			resetAndResize(newFrames);
 			memcpy(mainBuffer.data(), data, newFrames * sizeof(sampleFrame));
+			for (int i = 0;i<newFrames;i++) {
+				leftBuffer[i] = mainBuffer[i][0];
+				sampleMax = std::max(sampleMax, leftBuffer[i]);
+				rightBuffer[i] = mainBuffer[i][1];
+				sampleMax = std::max(sampleMax, rightBuffer[i]);
+			}
 			dataLock.unlock();
 		};
-		void setData(std::vector<float> & leftData, std::vector<float> & rightData)
+		void setFrames(std::vector<float> & leftData, std::vector<float> & rightData)
 		{
 			dataLock.lock();
 			int newFrames = std::min(leftData.size(), rightData.size());
@@ -106,10 +122,14 @@ class SlicerT : public Instrument{
 		IntModel m_originalBPM;
 
 		SampleBuffer m_originalSample;
+		std::vector<float> m_originalBufferL;
+		std::vector<float> m_originalBufferR;
+		int originalMax; // for later rescaling
 
 		PlaybackBuffer m_timeShiftedSample;
 		std::vector<float> m_timeshiftedBufferL;
 		std::vector<float> m_timeshiftedBufferR;
+		std::vector<bool> m_processedFrames; // check if a frame is processed
 
 
 		std::vector<int> m_slicePoints;
@@ -118,11 +138,12 @@ class SlicerT : public Instrument{
 		QMutex m_timeshiftLock; // should be unecesaty since playbackBuffer is safe
 		// std::unordered_map<int, std::vector<float> > m_fftWindowCache;
 
-		void updateParams(float newRatio);
+		void updateParams();
+		void extractOriginalData();
 		void findSlices();
 		void findBPM();
-		void timeShiftSample();
-		void phaseVocoder(std::vector<float> &in, std::vector<float> &out);
+		void timeShiftSample(int windowsToProcess);
+		void phaseVocoder(std::vector<float> &in, std::vector<float> &out, int start, int steps);
 		int hashFttWindow(std::vector<float> & in);
 
 		// timeshift stuff
@@ -147,6 +168,9 @@ class SlicerT : public Instrument{
 		std::vector<float> lastPhase;
 		std::vector<float> sumPhase;
 
+		fftwf_plan fftPlan;
+		fftwf_plan ifftPlan;
+
 		friend class gui::SlicerTUI;
 		friend class gui::WaveForm;
 };
diff --git a/plugins/SlicerT/SlicerTUI.cpp b/plugins/SlicerT/SlicerTUI.cpp
index 137b764a7aa..fe3d0da0f8d 100644
--- a/plugins/SlicerT/SlicerTUI.cpp
+++ b/plugins/SlicerT/SlicerTUI.cpp
@@ -113,7 +113,7 @@ void SlicerTUI::exportMidi()
 	dataFile.content().appendChild( note_list );
 
 	std::vector<Note> notes;
-	m_slicerTParent->timeShiftSample();
+	m_slicerTParent->timeShiftSample(-1);
 	m_slicerTParent->writeToMidi(&notes);
 	if (notes.size() == 0)
 	{

From 382f73b388950a7f6b12d2e25240004185657852 Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Sun, 17 Sep 2023 21:03:27 +0200
Subject: [PATCH 24/99] realtime time scaling (no stereo)

---
 plugins/SlicerT/SlicerT.cpp   | 475 ++++++++++++++++------------------
 plugins/SlicerT/SlicerT.h     | 140 ++++------
 plugins/SlicerT/SlicerTUI.cpp |   1 -
 plugins/SlicerT/WaveForm.cpp  |   5 +-
 plugins/SlicerT/WaveForm.h    |   2 +-
 5 files changed, 282 insertions(+), 341 deletions(-)

diff --git a/plugins/SlicerT/SlicerT.cpp b/plugins/SlicerT/SlicerT.cpp
index 6aa7b36e595..3a237c2c3a1 100644
--- a/plugins/SlicerT/SlicerT.cpp
+++ b/plugins/SlicerT/SlicerT.cpp
@@ -22,9 +22,8 @@
  *
  */
 
-// TODO: deinterlace only once, always work with seperated buffers
-// TODO: start working from the start of the note
-// TODO: create a seperate class for phaseVocoder, that handles all the sampleData
+// TODO: rewrite PhaseVocoder for only one channel, interlace in playNote
+// maybe cleaner, maybe not
 
 #include "SlicerT.h"
 
@@ -61,13 +60,7 @@ Plugin::Descriptor PLUGIN_EXPORT slicert_plugin_descriptor =
 } // end extern
 
 
-SlicerT::SlicerT(InstrumentTrack * instrumentTrack) :
-	Instrument( instrumentTrack, &slicert_plugin_descriptor ),
-	m_noteThreshold(0.6f, 0.0f, 2.0f, 0.01f, this, tr( "Note threshold" ) ),
-	m_fadeOutFrames(0.0f, 0.0f, 8192.0f, 4.0f, this, tr("FadeOut")),
-	m_originalBPM(1, 1, 999, this, tr("Original bpm")),
-	m_originalSample(),
-
+PhaseVocoder::PhaseVocoder() :
 	FFTInput(windowSize, 0),
 	IFFTReconstruction(windowSize, 0),
 	allMagnitudes(windowSize, 0),
@@ -77,52 +70,240 @@ SlicerT::SlicerT(InstrumentTrack * instrumentTrack) :
 {
 	fftPlan = fftwf_plan_dft_r2c_1d(windowSize, FFTInput.data(), FFTSpectrum, FFTW_MEASURE);
 	ifftPlan = fftwf_plan_dft_c2r_1d(windowSize, FFTSpectrum, IFFTReconstruction.data(), FFTW_MEASURE);
+	// loadSample(originalData, frames, sampleRate);
+}
 
+PhaseVocoder::~PhaseVocoder() {
+	fftwf_destroy_plan(fftPlan);
+	fftwf_destroy_plan(ifftPlan);
 }
 
-void SlicerT::updateParams() {
-	float speedRatio = (float)m_originalBPM.value() / Engine::getSong()->getTempo() ;
+void PhaseVocoder::loadSample(const sampleFrame * originalData, int frames, int sampleRate, float newRatio) {
+	originalBufferL.resize(frames);
+	originalBufferR.resize(frames);
+
+	for (int i = 0;i<frames;i++) {
+		originalBufferL[i] = originalData[i][0];
+		originalBufferR[i] = originalData[i][1];
+	}
+
+	originalSampleRate = sampleRate;
+	scaleRatio = -1; // force update, kinda hacky
+
+	updateParams(newRatio);
+
+	for (int i = 0;i<numWindows;i++) {
+		if (!m_processedWindows[i]) {
+			generateWindow(originalBufferL, leftBuffer, i);
+			m_processedWindows[i] = true;
+		}
+	}
+}
+
+void PhaseVocoder::getFrames(sampleFrame * outData, int start, int frames) {
+	if (originalBufferL.size() < 2048) { return; }
+	dataLock.lock();
+
+	int windowMargin = overSampling / 2; // numbers of windows before full quality
+	int startWindow = std::max(0.0f, (float)start / outStepSize - windowMargin);
+	int endWindow = std::min((float)numWindows, (float)(start + frames) / outStepSize + windowMargin);
+	// this encompases the minimum windows needed to get full quality,
+	// which must be computed
+	for (int i = startWindow;i<endWindow;i++) {
+		if (!m_processedWindows[i]) {
+			generateWindow(originalBufferL, leftBuffer, i);
+			m_processedWindows[i] = true;
+		}
+	}
+
+	for (int i = 0;i<frames;i++) {
+		outData[i][0] = leftBuffer[start + i];
+		outData[i][1] = leftBuffer[start + i];
+	}
 
+	dataLock.unlock();
+}
+
+void PhaseVocoder::updateParams(float newRatio) {
+	if (originalBufferL.size() < 2048) { return; }
+	if (newRatio == scaleRatio) { return; }
+	dataLock.lock();
+
+	scaleRatio = newRatio;
 	stepSize = (float)windowSize / overSampling;
-	numWindows = (float)m_originalSample.frames() / stepSize;
-	outStepSize = speedRatio * (float)stepSize; // float, else inaccurate
-	freqPerBin = m_originalSample.sampleRate()/windowSize;
+	numWindows = (float)originalBufferL.size() / stepSize - overSampling - 1;
+	outStepSize = scaleRatio * (float)stepSize; // float, else inaccurate
+	freqPerBin = originalSampleRate/windowSize;
 	expectedPhaseIn = 2.*M_PI*(float)stepSize/(float)windowSize;
 	expectedPhaseOut = 2.*M_PI*(float)outStepSize/(float)windowSize;
 
-	// resize all the buffers that rely on the final size
-	// is there a better way for this? probably
-	m_timeshiftedBufferL = {};
-	m_timeshiftedBufferL.resize(speedRatio*m_originalSample.frames());
-	m_processedFrames = {};
-	m_processedFrames.resize(numWindows);
-	for (bool b : m_processedFrames) {
-		b = false;
-	}
+	// clear all buffers
+	leftBuffer = {};
+	rightBuffer = {};
+	m_processedWindows = {};
 	lastPhase = {};
-	lastPhase.resize(numWindows*windowSize);
 	sumPhase = {};
-	sumPhase.resize(numWindows*windowSize);
+
+	// resize all buffers
+	leftBuffer.resize(scaleRatio*originalBufferL.size(), 0);
+	rightBuffer.resize(scaleRatio*originalBufferL.size(), 0);
+	lastPhase.resize(numWindows*windowSize, 0);
+	sumPhase.resize(numWindows*windowSize, 0);
+	m_processedWindows.resize(numWindows, false);
+
+	dataLock.unlock();
+}
+
+// basic phase vocoder implementation that time shifts without pitch change
+// resources:
+// http://blogs.zynaptiq.com/bernsee/pitch-shifting-using-the-ft/
+// https://sethares.engr.wisc.edu/vocoders/phasevocoder.html
+// https://dsp.stackexchange.com/questions/40101/audio-time-stretching-without-pitch-shifting/40367#40367
+// https://www.guitarpitchshifter.com/
+void PhaseVocoder::generateWindow(std::vector<float> &dataIn, std::vector<float> &dataOut, int start)
+{
+	// declare vars
+	float real, imag, phase, magnitude, freq, deltaPhase = 0;
+	int windowStart = (float)start*stepSize;
+	int windowIndex = (float)start*windowSize;
+
+	memcpy(FFTInput.data(), dataIn.data() + windowStart, windowSize*sizeof(float));
+
+	// FFT
+	fftwf_execute(fftPlan);
+
+	// analysis step
+	for (int j = 0; j < windowSize; j++)
+	{
+		real = FFTSpectrum[j][0];
+		imag = FFTSpectrum[j][1];
+
+		magnitude = 2.*sqrt(real*real + imag*imag);
+		phase = atan2(imag,real);
+
+		freq = phase;
+		freq = phase - lastPhase[std::max(0, windowIndex + j - windowSize)]; // subtract prev pahse to get phase diference
+		lastPhase[windowIndex + j] = phase;
+
+		freq -= (float)j*expectedPhaseIn; // subtract expected phase
+
+		// some black magic to get into +/- PI interval, revise later pls
+		long qpd = freq/M_PI;
+		if (qpd >= 0) qpd += qpd&1;
+		else qpd -= qpd&1;
+		freq -= M_PI*(float)qpd;
+
+		freq = (float)overSampling*freq/(2.*M_PI); // idk
+
+		freq = (float)j*freqPerBin + freq*freqPerBin; // "compute the k-th partials' true frequency" ok i guess
+
+		allMagnitudes[j] = magnitude;
+		allFrequencies[j] = freq;
+	}
+
+
+	// pitch shifting
+	// takes all the values that are below the nyquist frequency (representable with our samplerate)
+	// nyquist frequency = samplerate / 2
+	// and moves them to a different bin
+	// improve for larger pitch shift
+	// memset(processedFreq.data(), 0, processedFreq.size()*sizeof(float));
+	// memset(processedMagn.data(), 0, processedFreq.size()*sizeof(float));
+	// for (int j = 0; j < windowSize/2; j++) {
+	// 	int index = (float)j;// * m_noteThreshold.value();
+	// 	if (index <= windowSize/2) {
+	// 		processedMagn[index] += allMagnitudes[j];
+	// 		processedFreq[index] = allFrequencies[j];// * m_noteThreshold.value();
+	// 	}
+	// }
+
+	// synthesis, all the operations are the reverse of the analysis
+	for (int j = 0; j < windowSize; j++)
+	{
+		magnitude = allMagnitudes[j];
+		freq = allFrequencies[j];
+
+		deltaPhase = freq - (float)j*freqPerBin;
+
+		deltaPhase /= freqPerBin;
+
+		deltaPhase = 2.*M_PI*deltaPhase/overSampling;;
+
+		deltaPhase += (float)j*expectedPhaseOut;
+
+		sumPhase[windowIndex + j] += deltaPhase;
+		deltaPhase = sumPhase[windowIndex + j]; // this is the bin phase
+		if (windowIndex + j + windowSize < sumPhase.size()) { // only if not last window
+			sumPhase[windowIndex + j + windowSize] = deltaPhase; // copy to the next
+		}
+
+		FFTSpectrum[j][0] = magnitude*cos(deltaPhase);
+		FFTSpectrum[j][1] = magnitude*sin(deltaPhase);
+	}
+
+	// inverse fft
+	fftwf_execute(ifftPlan);
+
+	// windowing
+	for (int j = 0; j < windowSize; j++)
+	{
+		float outIndex = start * outStepSize + j;
+		if (outIndex >= dataOut.size()) { break; }
+
+		// calculate windows overlapping at index
+		// float startWindowOverlap = ceil(outIndex / outStepSize + 0.00000001f);
+		// float endWindowOverlap = ceil((float)(-outIndex + dataOut.size()) / outStepSize + 0.00000001f);
+		// float totalWindowOverlap = std::min(
+		// 							std::min(startWindowOverlap, endWindowOverlap),
+		// 							(float)overSampling);
+
+		// discrete windowing
+		// dataOut[outIndex] += (float)overSampling/totalWindowOverlap*IFFTReconstruction[j]/(windowSize/2.0f*overSampling);
+		// printf("timeshifted in phase: %f\n", m_timeshiftedBufferL[outIndex]);
+		// continuos windowing
+		float window = -0.5f*cos(2.*M_PI*(float)j/(float)windowSize)+0.5f;
+		dataOut[outIndex] += 2.0f*window*IFFTReconstruction[j]/(windowSize/2.0f*overSampling);
+	}
+
+}
+
+int PhaseVocoder::hashFttWindow(std::vector<float> & in)
+{
+	int hash = 0;
+	for (float value : in)
+	{
+		hash += (324723947 + (int)(value * 10689354)) ^ 93485734985;;
+	}
+	return hash;
+}
+
+// ################################# SlicerT ####################################
+
+SlicerT::SlicerT(InstrumentTrack * instrumentTrack) :
+	Instrument( instrumentTrack, &slicert_plugin_descriptor ),
+	m_noteThreshold(0.6f, 0.0f, 2.0f, 0.01f, this, tr( "Note threshold" ) ),
+	m_fadeOutFrames(0.0f, 0.0f, 8192.0f, 4.0f, this, tr("FadeOut")),
+	m_originalBPM(1, 1, 999, this, tr("Original bpm")),
+	m_originalSample(),
+	m_phaseVocoder()
+{
 }
 
+
+
 void SlicerT::playNote( NotePlayHandle * handle, sampleFrame * workingBuffer )
 {
 	if (m_originalSample.frames() < 2048) { return; }
 
 	const float speedRatio = (float)m_originalBPM.value() / Engine::getSong()->getTempo() ;
-	// const float lengthRatio = 1.0f / speedRatio; // inverse, because longer is slower
+
 	const int noteIndex = handle->key() - 69;
 	const fpp_t frames = handle->framesLeftForCurrentPeriod();
 	const f_cnt_t offset = handle->noteOffset();
 	const int playedFrames = handle->totalFramesPlayed();
+	m_phaseVocoder.setScaleRatio(speedRatio);
 
-	if (m_currentSpeedRatio != speedRatio)
-	{
-		updateParams();
-		// timeShiftSample(16);
-		m_currentSpeedRatio = speedRatio;
-	}
-	const int totalFrames = m_timeshiftedBufferL.size();
+	const int totalFrames = m_phaseVocoder.frames();
 
 	int sliceStart, sliceEnd;
 	if (noteIndex > m_slicePoints.size()-2 || noteIndex < 0)
@@ -141,23 +322,8 @@ void SlicerT::playNote( NotePlayHandle * handle, sampleFrame * workingBuffer )
 
 	if( noteFramesLeft > 0)
 	{
-		std::vector<float> originalBuffer(m_originalSample.frames());
-		for (int i = 0;i<m_originalSample.frames();i++) {
-			originalBuffer[i] = m_originalSample.data()[i][0];
-		}
-		// int bufferSize = frames * BYTES_PER_FRAME;
 		int framesToCopy = std::min((int)frames, noteFramesLeft);
-
-		// phaseVocoder(originalBuffer, m_timeshiftedBufferL, (float)currentNoteFrame/stepSize, 17);
-		timeShiftSample(overSampling/2);
-
-		for (int i = 0;i<frames;i++) {
-			// printf("output: %f, original: %f\n", m_timeshiftedBufferL[currentNoteFrame + i], originalBuffer[(currentNoteFrame + i) / speedRatio]);
-			workingBuffer[i][0] = m_timeshiftedBufferL[currentNoteFrame + i];
-			workingBuffer[i][1] = m_timeshiftedBufferL[currentNoteFrame + i];
-		}
-
-		// m_timeShiftedSample.copyFrames(workingBuffer + offset, currentNoteFrame, framesToCopy);
+		m_phaseVocoder.getFrames(workingBuffer + offset, currentNoteFrame, framesToCopy);
 
 		// exponential fade out, applyRelease kinda sucks
 		if (noteFramesLeft < m_fadeOutFrames.value())
@@ -260,196 +426,6 @@ void SlicerT::findBPM()
 	m_originalBPM.setInitValue(bpm);
 }
 
-// create timeshifted samplebuffer and timeshifted m_slicePoints
-void SlicerT::timeShiftSample(int windowsToProcess)
-{
-	// initial checks
-	if (m_originalSample.frames() < 2048) { return; }
-	m_timeshiftLock.lock();
-
-	// original sample data
-	int originalFrames = m_originalSample.frames();
-
-	// buffers
-	std::vector<float> rawDataL(originalFrames, 0);
-	std::vector<float> rawDataR(originalFrames, 0);
-
-	// copy channels for processing
-	for (int i = 0;i<originalFrames;i++)
-	{
-		rawDataL[i] = (float)m_originalSample.data()[i][0];
-		rawDataR[i] = (float)m_originalSample.data()[i][1];
-	}
-
-	int windowsProcessed = 0;
-
-	for (int i = 0;i<numWindows;i++) {
-		if (!m_processedFrames[i]) {
-			// process channels
-			phaseVocoder(rawDataL, m_timeshiftedBufferL, i, 1);
-			// phaseVocoder(rawDataR, m_timeshiftedBufferR, i, 1);
-			windowsProcessed++;
-		}
-		m_processedFrames[i] = true;
-		if (windowsProcessed >= windowsToProcess) { break; }
-	}
-
-	m_timeshiftLock.unlock();
-}
-
-// basic phase vocoder implementation that time shifts without pitch change
-// resources:
-// http://blogs.zynaptiq.com/bernsee/pitch-shifting-using-the-ft/
-// https://sethares.engr.wisc.edu/vocoders/phasevocoder.html
-// https://dsp.stackexchange.com/questions/40101/audio-time-stretching-without-pitch-shifting/40367#40367
-// https://www.guitarpitchshifter.com/
-void SlicerT::phaseVocoder(std::vector<float> &dataIn, std::vector<float> &dataOut, int start, int steps)
-{
-	// memset(lastPhase.data(), 0, numWindows*windowSize*sizeof(float));
-	// memset(sumPhase.data(), 0, numWindows*windowSize*sizeof(float));
-
-
-	// declare vars
-	float real, imag, phase, magnitude, freq, deltaPhase = 0;
-	int windowStart = 0;
-
-	// fft plans
-	// fftwf_plan fftPlan;
-	// fftPlan = fftwf_plan_dft_r2c_1d(windowSize, FFTInput.data(), FFTSpectrum, FFTW_MEASURE);
-	// fftwf_plan ifftPlan;
-	// ifftPlan = fftwf_plan_dft_c2r_1d(windowSize, FFTSpectrum, IFFTReconstruction.data(), FFTW_MEASURE);
-
-	// remove oversampling, because the actual window is overSampling* bigger than stepsize
-	for (int i = start;i < start + steps;i++)
-	{
-		printf("%i\n", i);
-		windowStart = i * stepSize;
-		memcpy(FFTInput.data(), dataIn.data() + windowStart, windowSize*sizeof(float));
-
-		// int hash = hashFttWindow(FFTInput);
-			// printf("%i\n", hash);
-
-		// FFT
-		fftwf_execute(fftPlan);
-
-		// analysis step
-		for (int j = 0; j < windowSize; j++)
-		{
-			int windowIndex = (float)i*windowSize;
-
-			real = FFTSpectrum[j][0];
-			imag = FFTSpectrum[j][1];
-
-			magnitude = 2.*sqrt(real*real + imag*imag);
-			phase = atan2(imag,real);
-
-			freq = phase - lastPhase[std::max(0, windowIndex + j - windowSize)]; // subtract prev pahse to get phase diference
-			lastPhase[windowIndex + j] = phase;
-
-			freq -= (float)j*expectedPhaseIn; // subtract expected phase
-
-			// some black magic to get into +/- PI interval, revise later pls
-			long qpd = freq/M_PI;
-			if (qpd >= 0) qpd += qpd&1;
-			else qpd -= qpd&1;
-			freq -= M_PI*(float)qpd;
-
-			freq = (float)overSampling*freq/(2.*M_PI); // idk
-
-			freq = (float)j*freqPerBin + freq*freqPerBin; // "compute the k-th partials' true frequency" ok i guess
-
-			allMagnitudes[j] = magnitude;
-			allFrequencies[j] = freq;
-		}
-		// pitch shifting
-		// takes all the values that are below the nyquist frequency (representable with our samplerate)
-		// nyquist frequency = samplerate / 2
-		// and moves them to a different bin
-		// improve for larger pitch shift
-		// memset(processedFreq.data(), 0, processedFreq.size()*sizeof(float));
-		// memset(processedMagn.data(), 0, processedFreq.size()*sizeof(float));
-		// for (int j = 0; j < windowSize/2; j++) {
-		// 	int index = (float)j;// * m_noteThreshold.value();
-		// 	if (index <= windowSize/2) {
-		// 		processedMagn[index] += allMagnitudes[j];
-		// 		processedFreq[index] = allFrequencies[j];// * m_noteThreshold.value();
-		// 	}
-		// }
-
-		// synthesis, all the operations are the reverse of the analysis
-		for (int j = 0; j < windowSize; j++)
-		{
-			int windowIndex = (float)i*windowSize;
-
-			magnitude = allMagnitudes[j];
-			freq = allFrequencies[j];
-
-			deltaPhase = freq - (float)j*freqPerBin;
-
-			deltaPhase /= freqPerBin;
-
-			deltaPhase = 2.*M_PI*deltaPhase/overSampling;;
-
-			deltaPhase += (float)j*expectedPhaseOut;
-
-			sumPhase[windowIndex + j] += deltaPhase;
-			deltaPhase = sumPhase[windowIndex + j]; // this is the bin phase
-			sumPhase[windowIndex + j + windowSize] = deltaPhase; // copy into the next window for accurate sum
-
-			FFTSpectrum[j][0] = magnitude*cos(deltaPhase);
-			FFTSpectrum[j][1] = magnitude*sin(deltaPhase);
-		}
-
-		// inverse fft
-		fftwf_execute(ifftPlan);
-
-		// windowing
-		for (int j = 0; j < windowSize; j++)
-		{
-			float outIndex = i * outStepSize + j;
-			if (outIndex >= dataOut.size()) { break; }
-
-			// calculate windows overlapping at index
-			float startWindowOverlap = ceil(outIndex / outStepSize + 0.00000001f);
-			float endWindowOverlap = ceil((float)(-outIndex + dataOut.size()) / outStepSize + 0.00000001f);
-			float totalWindowOverlap = std::min(
-										std::min(startWindowOverlap, endWindowOverlap),
-										(float)overSampling);
-
-			// discrete windowing
-			dataOut[outIndex] += (float)overSampling/totalWindowOverlap*IFFTReconstruction[j]/(windowSize/2.0f*overSampling);
-			// printf("timeshifted in phase: %f\n", m_timeshiftedBufferL[outIndex]);
-			// continuos windowing
-			// float window = -0.5f*cos(2.*M_PI*(float)j/(float)windowSize)+0.5f;
-			// outBuffer[outIndex] += 2.0f*window*IFFTReconstruction[j]/(windowSize/2.0f*overSampling);
-		}
-	}
-
-	// normalize
-	// float max = -1;
-	// for (int i = 0;i<outFrames;i++)
-	// {
-	// 	max = std::max(max, abs(dataOut[i]));
-	// }
-
-	// for (int i = 0;i<outFrames;i++)
-	// {
-	// 	dataOut[i] = dataOut[i] / max;
-	// }
-
-// memcpy(dataOut.data(), outBuffer.data(), outFrames*sizeof(float));
-}
-
-int SlicerT::hashFttWindow(std::vector<float> & in)
-{
-	int hash = 0;
-	for (float value : in)
-	{
-		hash += (324723947 + (int)(value * 10689354)) ^ 93485734985;;
-	}
-	return hash;
-}
-
 void SlicerT::writeToMidi(std::vector<Note> * outClip)
 {
 	if (m_originalSample.frames() < 2048) { return; }
@@ -459,7 +435,7 @@ void SlicerT::writeToMidi(std::vector<Note> * outClip)
 
 	float bpm = Engine::getSong()->getTempo();
 	float samplesPerBeat = 60.0f / bpm * sampleRate;
-	float beats = (float)m_timeShiftedSample.frames() / samplesPerBeat;
+	float beats = (float)m_phaseVocoder.frames() / samplesPerBeat;
 
 	float barsInSample = beats / Engine::getSong()->getTimeSigModel().getDenominator();
 	float totalTicks = ticksPerBar * barsInSample;
@@ -477,10 +453,6 @@ void SlicerT::writeToMidi(std::vector<Note> * outClip)
 	}
 }
 
-void SlicerT::extractOriginalData() {
-
-}
-
 void SlicerT::updateFile(QString file)
 {
 	m_originalSample.setAudioFile(file);
@@ -488,7 +460,12 @@ void SlicerT::updateFile(QString file)
 
 	findSlices();
 	findBPM();
-	updateParams();
+
+	float speedRatio = (float)m_originalBPM.value() / Engine::getSong()->getTempo() ;
+	m_phaseVocoder.loadSample(m_originalSample.data(),
+							m_originalSample.frames(),
+							m_originalSample.sampleRate(),
+							speedRatio);
 
 	emit dataChanged();
 }
@@ -551,7 +528,11 @@ void SlicerT::loadSettings( const QDomElement & element )
 	m_noteThreshold.loadSettings(element, "threshold");
 	m_originalBPM.loadSettings(element, "origBPM");
 
-	updateParams();
+	float speedRatio = (float)m_originalBPM.value() / Engine::getSong()->getTempo() ;
+	m_phaseVocoder.loadSample(m_originalSample.data(),
+							m_originalSample.frames(),
+							m_originalSample.sampleRate(),
+							speedRatio);
 
 	emit dataChanged();
 
diff --git a/plugins/SlicerT/SlicerT.h b/plugins/SlicerT/SlicerT.h
index 6838c4eeeba..5c4fdb1c985 100644
--- a/plugins/SlicerT/SlicerT.h
+++ b/plugins/SlicerT/SlicerT.h
@@ -39,57 +39,59 @@
 namespace lmms
 {
 
-// small helper class, since SampleBuffer is inadequate (not thread safe, no dinamic startpoint)
-class PlaybackBuffer {
+// main class that handles everything audio related
+class PhaseVocoder {
 	public:
+		PhaseVocoder();
+		~PhaseVocoder();
+		void loadSample(const sampleFrame* originalData, int frames, int sampleRate, float newRatio);
+		void setScaleRatio(float newRatio) { updateParams(newRatio); }
+		void getFrames(sampleFrame * outData, int start, int frames);
+		int frames() { return leftBuffer.size(); }
+	private:
 		QMutex dataLock;
-		std::vector<sampleFrame> mainBuffer;
+		// original data
+		std::vector<float> originalBufferL;
+		std::vector<float> originalBufferR;
+		int originalSampleRate = 0;
+
+		float scaleRatio = -1; // to force on fisrt load
+
+		// output data
 		std::vector<float> leftBuffer;
 		std::vector<float> rightBuffer;
-		float sampleMax = -1;
-
-		int frames() { return mainBuffer.size(); }; // not thread safe yet, but shouldnt be a big issue
-		sampleFrame * data() {  return mainBuffer.data(); };
-		void copyFrames(sampleFrame * outData, int start, int framesToCopy) {
-			dataLock.lock();
-			memcpy(outData, mainBuffer.data() + start, framesToCopy * sizeof(sampleFrame));
-			dataLock.unlock();
-		}
-		void resetAndResize(int newFrames) {
-			mainBuffer = {};
-			mainBuffer.resize(newFrames);
-			leftBuffer = {};
-			leftBuffer.resize(newFrames);
-			rightBuffer = {};
-			rightBuffer.resize(newFrames);
-		}
-		void loadSample(const sampleFrame * data, int newFrames)
-		{
-			dataLock.lock();
-			resetAndResize(newFrames);
-			memcpy(mainBuffer.data(), data, newFrames * sizeof(sampleFrame));
-			for (int i = 0;i<newFrames;i++) {
-				leftBuffer[i] = mainBuffer[i][0];
-				sampleMax = std::max(sampleMax, leftBuffer[i]);
-				rightBuffer[i] = mainBuffer[i][1];
-				sampleMax = std::max(sampleMax, rightBuffer[i]);
-			}
-			dataLock.unlock();
-		};
-		void setFrames(std::vector<float> & leftData, std::vector<float> & rightData)
-		{
-			dataLock.lock();
-			int newFrames = std::min(leftData.size(), rightData.size());
-			mainBuffer = {};
-			mainBuffer.resize(newFrames);
-
-			for (int i = 0;i < newFrames;i++)
-			{
-				mainBuffer[i][0] = leftData[i];
-				mainBuffer[i][1] = rightData[i];
-			}
-			dataLock.unlock();
-		}
+		std::vector<bool> m_processedWindows; // marks a window processed
+
+		// timeshift stuff
+		static const int windowSize = 512;
+		static const int overSampling = 32;
+
+		// depending on scaleRatio
+		int stepSize = 0;
+		int numWindows = 0;
+		float outStepSize = 0;
+		float freqPerBin = 0;
+		float expectedPhaseIn = 0;
+		float expectedPhaseOut = 0;
+
+		// buffers
+		fftwf_complex FFTSpectrum[windowSize];
+		std::vector<float> FFTInput;
+		std::vector<float> IFFTReconstruction;
+		std::vector<float> allMagnitudes;
+		std::vector<float> allFrequencies;
+		std::vector<float> processedFreq;
+		std::vector<float> processedMagn;
+		std::vector<float> lastPhase;
+		std::vector<float> sumPhase;
+
+		// fftw plans
+		fftwf_plan fftPlan;
+		fftwf_plan ifftPlan;
+
+		void updateParams(float newRatio);
+		void generateWindow(std::vector<float> &in, std::vector<float> &out, int start);
+		int hashFttWindow(std::vector<float> & in);
 };
 
 class SlicerT : public Instrument{
@@ -122,54 +124,12 @@ class SlicerT : public Instrument{
 		IntModel m_originalBPM;
 
 		SampleBuffer m_originalSample;
-		std::vector<float> m_originalBufferL;
-		std::vector<float> m_originalBufferR;
-		int originalMax; // for later rescaling
-
-		PlaybackBuffer m_timeShiftedSample;
-		std::vector<float> m_timeshiftedBufferL;
-		std::vector<float> m_timeshiftedBufferR;
-		std::vector<bool> m_processedFrames; // check if a frame is processed
-
+		PhaseVocoder m_phaseVocoder;
 
 		std::vector<int> m_slicePoints;
 
-		float m_currentSpeedRatio = -1;
-		QMutex m_timeshiftLock; // should be unecesaty since playbackBuffer is safe
-		// std::unordered_map<int, std::vector<float> > m_fftWindowCache;
-
-		void updateParams();
-		void extractOriginalData();
 		void findSlices();
 		void findBPM();
-		void timeShiftSample(int windowsToProcess);
-		void phaseVocoder(std::vector<float> &in, std::vector<float> &out, int start, int steps);
-		int hashFttWindow(std::vector<float> & in);
-
-		// timeshift stuff
-		static const int windowSize = 512;
-		static const int overSampling = 32;
-
-		int stepSize = 0;
-		int numWindows = 0;
-		float outStepSize = 0;
-		float freqPerBin = 0;
-		// very important
-		float expectedPhaseIn = 0;
-		float expectedPhaseOut = 0;
-
-		fftwf_complex FFTSpectrum[windowSize];
-		std::vector<float> FFTInput;
-		std::vector<float> IFFTReconstruction;
-		std::vector<float> allMagnitudes;
-		std::vector<float> allFrequencies;
-		std::vector<float> processedFreq;
-		std::vector<float> processedMagn;
-		std::vector<float> lastPhase;
-		std::vector<float> sumPhase;
-
-		fftwf_plan fftPlan;
-		fftwf_plan ifftPlan;
 
 		friend class gui::SlicerTUI;
 		friend class gui::WaveForm;
diff --git a/plugins/SlicerT/SlicerTUI.cpp b/plugins/SlicerT/SlicerTUI.cpp
index fe3d0da0f8d..d251f30ad91 100644
--- a/plugins/SlicerT/SlicerTUI.cpp
+++ b/plugins/SlicerT/SlicerTUI.cpp
@@ -113,7 +113,6 @@ void SlicerTUI::exportMidi()
 	dataFile.content().appendChild( note_list );
 
 	std::vector<Note> notes;
-	m_slicerTParent->timeShiftSample(-1);
 	m_slicerTParent->writeToMidi(&notes);
 	if (notes.size() == 0)
 	{
diff --git a/plugins/SlicerT/WaveForm.cpp b/plugins/SlicerT/WaveForm.cpp
index b6749776d00..86c67831245 100644
--- a/plugins/SlicerT/WaveForm.cpp
+++ b/plugins/SlicerT/WaveForm.cpp
@@ -37,7 +37,7 @@ WaveForm::WaveForm(int w, int h, SlicerT  * instrument, QWidget * parent) :
     m_sliceEditor(QPixmap(w, h*(1 - m_m_seekerRatio) - m_margin)),
     m_seeker(QPixmap(w, h*m_m_seekerRatio)),
     m_seekerWaveform(QPixmap(w, h*m_m_seekerRatio)),
-    m_currentSample(instrument->m_originalSample.data(), instrument->m_originalSample.frames()),
+    m_currentSample(instrument->m_originalSample),
     m_slicePoints(instrument->m_slicePoints)
     {
         m_width = w;
@@ -146,7 +146,8 @@ void WaveForm::updateUI()
 
 void WaveForm::updateData()
 {
-    m_currentSample = SampleBuffer(m_slicerTParent->m_originalSample.data(), m_slicerTParent->m_originalSample.frames());
+    // I hate SampleBuffer, fot whatever reason this crashes sometimes
+    // m_currentSample = SampleBuffer(m_slicerTParent->m_originalSample.data(), m_slicerTParent->m_originalSample.frames());
     updateUI();
 }
 
diff --git a/plugins/SlicerT/WaveForm.h b/plugins/SlicerT/WaveForm.h
index 6b78989b049..d5169e1fab7 100644
--- a/plugins/SlicerT/WaveForm.h
+++ b/plugins/SlicerT/WaveForm.h
@@ -94,7 +94,7 @@ class WaveForm : public QWidget {
         QPixmap m_seeker;
         QPixmap m_seekerWaveform;
 
-        SampleBuffer m_currentSample;
+        SampleBuffer & m_currentSample;
 
         void drawEditor();
         void drawSeekerWaveform();

From d88b8708ecc4e7a6a28a0fb286fe06a9b10b68d2 Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Sun, 17 Sep 2023 23:59:35 +0200
Subject: [PATCH 25/99] stereo added, very slow

---
 plugins/SlicerT/SlicerT.cpp | 46 +++++++++++++++---------------
 plugins/SlicerT/SlicerT.h   | 56 +++++++++++++++++++++++++++++++------
 2 files changed, 69 insertions(+), 33 deletions(-)

diff --git a/plugins/SlicerT/SlicerT.cpp b/plugins/SlicerT/SlicerT.cpp
index 3a237c2c3a1..da3ce8fa28f 100644
--- a/plugins/SlicerT/SlicerT.cpp
+++ b/plugins/SlicerT/SlicerT.cpp
@@ -22,8 +22,15 @@
  *
  */
 
-// TODO: rewrite PhaseVocoder for only one channel, interlace in playNote
-// maybe cleaner, maybe not
+// TODO: fix changing sample while playing broken
+// TODO: add cache to PhaseVocoder
+// TODO: cleaup loading, saving
+// TODO: maybe add grace period while changing velocity, there are artifacts when changing bpm repetedly
+// TODO: general performance, set frames from getFrames to fixed, reduce vector creation as much as posible
+// TODO: switch to arrayVector
+// TODO: volume normalizazion, atm just reduce by x amount
+// TODO: cleaunp UI classes
+// TODO: implment roxas new UI
 
 #include "SlicerT.h"
 
@@ -78,30 +85,22 @@ PhaseVocoder::~PhaseVocoder() {
 	fftwf_destroy_plan(ifftPlan);
 }
 
-void PhaseVocoder::loadSample(const sampleFrame * originalData, int frames, int sampleRate, float newRatio) {
-	originalBufferL.resize(frames);
-	originalBufferR.resize(frames);
-
-	for (int i = 0;i<frames;i++) {
-		originalBufferL[i] = originalData[i][0];
-		originalBufferR[i] = originalData[i][1];
-	}
-
+void PhaseVocoder::loadData(std::vector<float> originalData, int sampleRate, float newRatio) {
+	originalBuffer = originalData;
 	originalSampleRate = sampleRate;
 	scaleRatio = -1; // force update, kinda hacky
-
 	updateParams(newRatio);
 
 	for (int i = 0;i<numWindows;i++) {
 		if (!m_processedWindows[i]) {
-			generateWindow(originalBufferL, leftBuffer, i);
+			generateWindow(originalBuffer, processedBuffer, i);
 			m_processedWindows[i] = true;
 		}
 	}
 }
 
-void PhaseVocoder::getFrames(sampleFrame * outData, int start, int frames) {
-	if (originalBufferL.size() < 2048) { return; }
+void PhaseVocoder::getFrames(std::vector<float> & outData, int start, int frames) {
+	if (originalBuffer.size() < 2048) { return; }
 	dataLock.lock();
 
 	int windowMargin = overSampling / 2; // numbers of windows before full quality
@@ -111,42 +110,41 @@ void PhaseVocoder::getFrames(sampleFrame * outData, int start, int frames) {
 	// which must be computed
 	for (int i = startWindow;i<endWindow;i++) {
 		if (!m_processedWindows[i]) {
-			generateWindow(originalBufferL, leftBuffer, i);
+			generateWindow(originalBuffer, processedBuffer, i);
 			m_processedWindows[i] = true;
 		}
 	}
 
 	for (int i = 0;i<frames;i++) {
-		outData[i][0] = leftBuffer[start + i];
-		outData[i][1] = leftBuffer[start + i];
+		outData[i] = processedBuffer[start + i];
 	}
 
 	dataLock.unlock();
 }
 
 void PhaseVocoder::updateParams(float newRatio) {
-	if (originalBufferL.size() < 2048) { return; }
+	if (originalBuffer.size() < 2048) { return; }
 	if (newRatio == scaleRatio) { return; }
 	dataLock.lock();
 
+	printf("ratio: %f\n", newRatio);
+
 	scaleRatio = newRatio;
 	stepSize = (float)windowSize / overSampling;
-	numWindows = (float)originalBufferL.size() / stepSize - overSampling - 1;
+	numWindows = (float)originalBuffer.size() / stepSize - overSampling - 1;
 	outStepSize = scaleRatio * (float)stepSize; // float, else inaccurate
 	freqPerBin = originalSampleRate/windowSize;
 	expectedPhaseIn = 2.*M_PI*(float)stepSize/(float)windowSize;
 	expectedPhaseOut = 2.*M_PI*(float)outStepSize/(float)windowSize;
 
 	// clear all buffers
-	leftBuffer = {};
-	rightBuffer = {};
+	processedBuffer = {};
 	m_processedWindows = {};
 	lastPhase = {};
 	sumPhase = {};
 
 	// resize all buffers
-	leftBuffer.resize(scaleRatio*originalBufferL.size(), 0);
-	rightBuffer.resize(scaleRatio*originalBufferL.size(), 0);
+	processedBuffer.resize(scaleRatio*originalBuffer.size(), 0);
 	lastPhase.resize(numWindows*windowSize, 0);
 	sumPhase.resize(numWindows*windowSize, 0);
 	m_processedWindows.resize(numWindows, false);
diff --git a/plugins/SlicerT/SlicerT.h b/plugins/SlicerT/SlicerT.h
index 5c4fdb1c985..df7f920abb0 100644
--- a/plugins/SlicerT/SlicerT.h
+++ b/plugins/SlicerT/SlicerT.h
@@ -39,27 +39,25 @@
 namespace lmms
 {
 
-// main class that handles everything audio related
+// takes one audio-channel and timeshifts it
 class PhaseVocoder {
 	public:
 		PhaseVocoder();
 		~PhaseVocoder();
-		void loadSample(const sampleFrame* originalData, int frames, int sampleRate, float newRatio);
+		void loadData(std::vector<float> originalData, int sampleRate, float newRatio);
 		void setScaleRatio(float newRatio) { updateParams(newRatio); }
-		void getFrames(sampleFrame * outData, int start, int frames);
-		int frames() { return leftBuffer.size(); }
+		void getFrames(std::vector<float> & outData, int start, int frames);
+		int frames() { return processedBuffer.size(); }
 	private:
 		QMutex dataLock;
 		// original data
-		std::vector<float> originalBufferL;
-		std::vector<float> originalBufferR;
+		std::vector<float> originalBuffer;
 		int originalSampleRate = 0;
 
 		float scaleRatio = -1; // to force on fisrt load
 
 		// output data
-		std::vector<float> leftBuffer;
-		std::vector<float> rightBuffer;
+		std::vector<float> processedBuffer;
 		std::vector<bool> m_processedWindows; // marks a window processed
 
 		// timeshift stuff
@@ -94,6 +92,46 @@ class PhaseVocoder {
 		int hashFttWindow(std::vector<float> & in);
 };
 
+// simple helper class that handles the different audio channels
+class dinamicPlaybackBuffer {
+	public:
+		dinamicPlaybackBuffer() :
+			leftChannel(),
+			rightChannel()
+		{}
+		void loadSample(const sampleFrame * outData, int frames, int sampleRate, float newRatio) {
+			std::vector<float> leftData(frames, 0);
+			std::vector<float> rightData(frames, 0);
+			for (int i = 0;i<frames;i++) {
+				leftData[i] = outData[i][0];
+				rightData[i] = outData[i][1];
+			}
+			leftChannel.loadData(leftData, sampleRate, newRatio);
+			rightChannel.loadData(rightData, sampleRate, newRatio);
+		}
+		void getFrames(sampleFrame * outData, int startFrame, int frames) {
+			std::vector<float> leftOut(frames, 0);
+			std::vector<float> rightOut(frames, 0);
+
+			leftChannel.getFrames(leftOut, startFrame, frames);
+			rightChannel.getFrames(rightOut, startFrame, frames);
+
+			for (int i = 0;i<frames;i++) {
+				outData[i][0] = leftOut[i];
+				outData[i][1] = rightOut[i];
+			}
+		}
+		int frames() { return leftChannel.frames(); }
+		void setScaleRatio(float newRatio) {
+			leftChannel.setScaleRatio(newRatio);
+			rightChannel.setScaleRatio(newRatio);
+		}
+	private:
+		float scaleRatio;
+		PhaseVocoder leftChannel;
+		PhaseVocoder rightChannel;
+};
+
 class SlicerT : public Instrument{
 	Q_OBJECT
 
@@ -124,7 +162,7 @@ class SlicerT : public Instrument{
 		IntModel m_originalBPM;
 
 		SampleBuffer m_originalSample;
-		PhaseVocoder m_phaseVocoder;
+		dinamicPlaybackBuffer m_phaseVocoder;
 
 		std::vector<int> m_slicePoints;
 

From 248fe741e8e7d33edeaa16e4b8e80c6ace0adae7 Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Mon, 18 Sep 2023 17:22:25 +0200
Subject: [PATCH 26/99] playback performance improvments

---
 plugins/SlicerT/SlicerT.cpp | 141 +++++++++++++++++-------------------
 plugins/SlicerT/SlicerT.h   |  11 ++-
 2 files changed, 72 insertions(+), 80 deletions(-)

diff --git a/plugins/SlicerT/SlicerT.cpp b/plugins/SlicerT/SlicerT.cpp
index da3ce8fa28f..3dfd3f3cf3b 100644
--- a/plugins/SlicerT/SlicerT.cpp
+++ b/plugins/SlicerT/SlicerT.cpp
@@ -22,15 +22,11 @@
  *
  */
 
-// TODO: fix changing sample while playing broken
-// TODO: add cache to PhaseVocoder
-// TODO: cleaup loading, saving
-// TODO: maybe add grace period while changing velocity, there are artifacts when changing bpm repetedly
-// TODO: general performance, set frames from getFrames to fixed, reduce vector creation as much as posible
-// TODO: switch to arrayVector
-// TODO: volume normalizazion, atm just reduce by x amount
+// better ounset detection + bpm cleanup
+// TODO: switch to arrayVector (maybe)
 // TODO: cleaunp UI classes
 // TODO: implment roxas new UI
+// TODO: code cleaunp, style and test
 
 #include "SlicerT.h"
 
@@ -77,7 +73,6 @@ PhaseVocoder::PhaseVocoder() :
 {
 	fftPlan = fftwf_plan_dft_r2c_1d(windowSize, FFTInput.data(), FFTSpectrum, FFTW_MEASURE);
 	ifftPlan = fftwf_plan_dft_c2r_1d(windowSize, FFTSpectrum, IFFTReconstruction.data(), FFTW_MEASURE);
-	// loadSample(originalData, frames, sampleRate);
 }
 
 PhaseVocoder::~PhaseVocoder() {
@@ -89,14 +84,26 @@ void PhaseVocoder::loadData(std::vector<float> originalData, int sampleRate, flo
 	originalBuffer = originalData;
 	originalSampleRate = sampleRate;
 	scaleRatio = -1; // force update, kinda hacky
+
 	updateParams(newRatio);
 
+	dataLock.lock();
+
+	// set buffer size
+	m_processedWindows.resize(numWindows, false);
+	lastPhase.resize(numWindows*windowSize, 0);
+	sumPhase.resize(numWindows*windowSize, 0);
+	freqCache.resize(numWindows*windowSize, 0);
+	magCache.resize(numWindows*windowSize, 0);
+
 	for (int i = 0;i<numWindows;i++) {
 		if (!m_processedWindows[i]) {
-			generateWindow(originalBuffer, processedBuffer, i);
+			generateWindow(i, false);
 			m_processedWindows[i] = true;
 		}
 	}
+
+	dataLock.unlock();
 }
 
 void PhaseVocoder::getFrames(std::vector<float> & outData, int start, int frames) {
@@ -110,7 +117,7 @@ void PhaseVocoder::getFrames(std::vector<float> & outData, int start, int frames
 	// which must be computed
 	for (int i = startWindow;i<endWindow;i++) {
 		if (!m_processedWindows[i]) {
-			generateWindow(originalBuffer, processedBuffer, i);
+			generateWindow(i, true);
 			m_processedWindows[i] = true;
 		}
 	}
@@ -122,13 +129,13 @@ void PhaseVocoder::getFrames(std::vector<float> & outData, int start, int frames
 	dataLock.unlock();
 }
 
+// adjust pv params and reset buffers
 void PhaseVocoder::updateParams(float newRatio) {
 	if (originalBuffer.size() < 2048) { return; }
 	if (newRatio == scaleRatio) { return; }
 	dataLock.lock();
 
-	printf("ratio: %f\n", newRatio);
-
+	// TODO: remove static stuff from here, like stepsize
 	scaleRatio = newRatio;
 	stepSize = (float)windowSize / overSampling;
 	numWindows = (float)originalBuffer.size() / stepSize - overSampling - 1;
@@ -137,84 +144,75 @@ void PhaseVocoder::updateParams(float newRatio) {
 	expectedPhaseIn = 2.*M_PI*(float)stepSize/(float)windowSize;
 	expectedPhaseOut = 2.*M_PI*(float)outStepSize/(float)windowSize;
 
-	// clear all buffers
-	processedBuffer = {};
-	m_processedWindows = {};
-	lastPhase = {};
-	sumPhase = {};
-
-	// resize all buffers
 	processedBuffer.resize(scaleRatio*originalBuffer.size(), 0);
-	lastPhase.resize(numWindows*windowSize, 0);
-	sumPhase.resize(numWindows*windowSize, 0);
-	m_processedWindows.resize(numWindows, false);
+
+	// very slow :(
+	std::fill(m_processedWindows.begin(), m_processedWindows.end(), false);
+	std::fill(processedBuffer.begin(), processedBuffer.end(), 0);
+	// somehow this works if this is commented, idk why but its faster
+	// std::fill(lastPhase.begin(), lastPhase.end(), 0);
+	// std::fill(sumPhase.begin(), sumPhase.end(), 0);
 
 	dataLock.unlock();
 }
 
-// basic phase vocoder implementation that time shifts without pitch change
+// time shifts one window from originalBuffer and writes to processedBuffer
 // resources:
 // http://blogs.zynaptiq.com/bernsee/pitch-shifting-using-the-ft/
 // https://sethares.engr.wisc.edu/vocoders/phasevocoder.html
 // https://dsp.stackexchange.com/questions/40101/audio-time-stretching-without-pitch-shifting/40367#40367
 // https://www.guitarpitchshifter.com/
-void PhaseVocoder::generateWindow(std::vector<float> &dataIn, std::vector<float> &dataOut, int start)
+void PhaseVocoder::generateWindow(int windowNum, bool useCache)
 {
 	// declare vars
 	float real, imag, phase, magnitude, freq, deltaPhase = 0;
-	int windowStart = (float)start*stepSize;
-	int windowIndex = (float)start*windowSize;
+	int windowStart = (float)windowNum*stepSize;
+	int windowIndex = (float)windowNum*windowSize;
 
-	memcpy(FFTInput.data(), dataIn.data() + windowStart, windowSize*sizeof(float));
+	if (!useCache) { // normal stuff
+		memcpy(FFTInput.data(), originalBuffer.data() + windowStart, windowSize*sizeof(float));
 
-	// FFT
-	fftwf_execute(fftPlan);
+		// FFT
+		fftwf_execute(fftPlan);
 
-	// analysis step
-	for (int j = 0; j < windowSize; j++)
-	{
-		real = FFTSpectrum[j][0];
-		imag = FFTSpectrum[j][1];
+		// analysis step
+		for (int j = 0; j < windowSize; j++)
+		{
+			real = FFTSpectrum[j][0];
+			imag = FFTSpectrum[j][1];
 
-		magnitude = 2.*sqrt(real*real + imag*imag);
-		phase = atan2(imag,real);
+			magnitude = 2.*sqrt(real*real + imag*imag);
+			phase = atan2(imag,real);
 
-		freq = phase;
-		freq = phase - lastPhase[std::max(0, windowIndex + j - windowSize)]; // subtract prev pahse to get phase diference
-		lastPhase[windowIndex + j] = phase;
+			freq = phase;
+			freq = phase - lastPhase[std::max(0, windowIndex + j - windowSize)]; // subtract prev pahse to get phase diference
+			lastPhase[windowIndex + j] = phase;
 
-		freq -= (float)j*expectedPhaseIn; // subtract expected phase
+			freq -= (float)j*expectedPhaseIn; // subtract expected phase
 
-		// some black magic to get into +/- PI interval, revise later pls
-		long qpd = freq/M_PI;
-		if (qpd >= 0) qpd += qpd&1;
-		else qpd -= qpd&1;
-		freq -= M_PI*(float)qpd;
+			// some black magic to get into +/- PI interval, revise later pls
+			long qpd = freq/M_PI;
+			if (qpd >= 0) qpd += qpd&1;
+			else qpd -= qpd&1;
+			freq -= M_PI*(float)qpd;
 
-		freq = (float)overSampling*freq/(2.*M_PI); // idk
+			freq = (float)overSampling*freq/(2.*M_PI); // idk
 
-		freq = (float)j*freqPerBin + freq*freqPerBin; // "compute the k-th partials' true frequency" ok i guess
+			freq = (float)j*freqPerBin + freq*freqPerBin; // "compute the k-th partials' true frequency" ok i guess
 
-		allMagnitudes[j] = magnitude;
-		allFrequencies[j] = freq;
+			allMagnitudes[j] = magnitude;
+			allFrequencies[j] = freq;
+		}
+		// write cache
+		memcpy(freqCache.data() + windowIndex, allFrequencies.data(), windowSize*sizeof(float));
+		memcpy(magCache.data() + windowIndex, allMagnitudes.data(),  windowSize*sizeof(float));
+	} else {
+		// read cache
+		memcpy(allFrequencies.data(), freqCache.data() + windowIndex, windowSize*sizeof(float));
+		memcpy(allMagnitudes.data(), magCache.data() + windowIndex, windowSize*sizeof(float));
 	}
 
 
-	// pitch shifting
-	// takes all the values that are below the nyquist frequency (representable with our samplerate)
-	// nyquist frequency = samplerate / 2
-	// and moves them to a different bin
-	// improve for larger pitch shift
-	// memset(processedFreq.data(), 0, processedFreq.size()*sizeof(float));
-	// memset(processedMagn.data(), 0, processedFreq.size()*sizeof(float));
-	// for (int j = 0; j < windowSize/2; j++) {
-	// 	int index = (float)j;// * m_noteThreshold.value();
-	// 	if (index <= windowSize/2) {
-	// 		processedMagn[index] += allMagnitudes[j];
-	// 		processedFreq[index] = allFrequencies[j];// * m_noteThreshold.value();
-	// 	}
-	// }
-
 	// synthesis, all the operations are the reverse of the analysis
 	for (int j = 0; j < windowSize; j++)
 	{
@@ -245,8 +243,8 @@ void PhaseVocoder::generateWindow(std::vector<float> &dataIn, std::vector<float>
 	// windowing
 	for (int j = 0; j < windowSize; j++)
 	{
-		float outIndex = start * outStepSize + j;
-		if (outIndex >= dataOut.size()) { break; }
+		float outIndex = windowNum * outStepSize + j;
+		if (outIndex >= frames()) { break; }
 
 		// calculate windows overlapping at index
 		// float startWindowOverlap = ceil(outIndex / outStepSize + 0.00000001f);
@@ -260,20 +258,11 @@ void PhaseVocoder::generateWindow(std::vector<float> &dataIn, std::vector<float>
 		// printf("timeshifted in phase: %f\n", m_timeshiftedBufferL[outIndex]);
 		// continuos windowing
 		float window = -0.5f*cos(2.*M_PI*(float)j/(float)windowSize)+0.5f;
-		dataOut[outIndex] += 2.0f*window*IFFTReconstruction[j]/(windowSize/2.0f*overSampling);
+		processedBuffer[outIndex] += window*IFFTReconstruction[j]/(windowSize/2.0f*overSampling);
 	}
 
 }
 
-int PhaseVocoder::hashFttWindow(std::vector<float> & in)
-{
-	int hash = 0;
-	for (float value : in)
-	{
-		hash += (324723947 + (int)(value * 10689354)) ^ 93485734985;;
-	}
-	return hash;
-}
 
 // ################################# SlicerT ####################################
 
diff --git a/plugins/SlicerT/SlicerT.h b/plugins/SlicerT/SlicerT.h
index df7f920abb0..3f4dc482cad 100644
--- a/plugins/SlicerT/SlicerT.h
+++ b/plugins/SlicerT/SlicerT.h
@@ -62,7 +62,7 @@ class PhaseVocoder {
 
 		// timeshift stuff
 		static const int windowSize = 512;
-		static const int overSampling = 32;
+		static const int overSampling = 64;
 
 		// depending on scaleRatio
 		int stepSize = 0;
@@ -83,13 +83,16 @@ class PhaseVocoder {
 		std::vector<float> lastPhase;
 		std::vector<float> sumPhase;
 
+		// cache
+		std::vector<float> freqCache;
+		std::vector<float> magCache;
+
 		// fftw plans
 		fftwf_plan fftPlan;
 		fftwf_plan ifftPlan;
 
 		void updateParams(float newRatio);
-		void generateWindow(std::vector<float> &in, std::vector<float> &out, int start);
-		int hashFttWindow(std::vector<float> & in);
+		void generateWindow(int windowNum, bool useCache);
 };
 
 // simple helper class that handles the different audio channels
@@ -110,7 +113,7 @@ class dinamicPlaybackBuffer {
 			rightChannel.loadData(rightData, sampleRate, newRatio);
 		}
 		void getFrames(sampleFrame * outData, int startFrame, int frames) {
-			std::vector<float> leftOut(frames, 0);
+			std::vector<float> leftOut(frames, 0); // not a huge performance issue
 			std::vector<float> rightOut(frames, 0);
 
 			leftChannel.getFrames(leftOut, startFrame, frames);

From b1cfb3cdb4d6e09a126bda30c11b5b64ae7d8775 Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Thu, 21 Sep 2023 17:08:55 +0200
Subject: [PATCH 27/99] Roxas new UI start

---
 plugins/SlicerT/CopyMidiBtn.png           | Bin 749 -> 0 bytes
 plugins/SlicerT/ResetBtn.png              | Bin 14573 -> 0 bytes
 plugins/SlicerT/SlicerT.cpp               |   4 +-
 plugins/SlicerT/SlicerTUI.cpp             |  18 ++++-----
 plugins/SlicerT/SlicerTUI.h               |   4 +-
 plugins/SlicerT/WaveForm.cpp              |  44 +++++++++++++---------
 plugins/SlicerT/WaveForm.h                |  12 +++---
 plugins/SlicerT/artwork.png               | Bin 11467 -> 0 bytes
 plugins/SlicerT/bg.png                    | Bin 0 -> 19736 bytes
 plugins/SlicerT/bg_no_logo.png            | Bin 0 -> 16125 bytes
 plugins/SlicerT/icon.png                  | Bin 0 -> 759 bytes
 plugins/SlicerT/knob_center.png           | Bin 0 -> 6455 bytes
 plugins/SlicerT/logo.png                  | Bin 39244 -> 11243 bytes
 plugins/SlicerT/slide_indicator_arrow.png | Bin 0 -> 234 bytes
 plugins/SlicerT/slide_indicator_bar.png   | Bin 0 -> 197 bytes
 plugins/SlicerT/slide_indicator_full.png  | Bin 0 -> 290 bytes
 16 files changed, 45 insertions(+), 37 deletions(-)
 delete mode 100644 plugins/SlicerT/CopyMidiBtn.png
 delete mode 100644 plugins/SlicerT/ResetBtn.png
 delete mode 100644 plugins/SlicerT/artwork.png
 create mode 100644 plugins/SlicerT/bg.png
 create mode 100644 plugins/SlicerT/bg_no_logo.png
 create mode 100644 plugins/SlicerT/icon.png
 create mode 100644 plugins/SlicerT/knob_center.png
 create mode 100644 plugins/SlicerT/slide_indicator_arrow.png
 create mode 100644 plugins/SlicerT/slide_indicator_bar.png
 create mode 100644 plugins/SlicerT/slide_indicator_full.png

diff --git a/plugins/SlicerT/CopyMidiBtn.png b/plugins/SlicerT/CopyMidiBtn.png
deleted file mode 100644
index 8687fb29b44a5a3c213d0eeee6c75d8c8ad3cc92..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 749
zcmV<J0uud+P)<h;3K|Lk000e1NJLTq000{R001lq1^@s6l&ix)0004mX+uL$Nkc;*
zaB^>EX>4Tx04R}tkv&MmKpe$iQ>7}^4t5Z62w0u$q9Ts93Pq?8YK2xEOfLO`CJjl8
zi=*ILaPVWX>fqw6tAnc`2!4RLx;QDiNQwVT3N2zhIPS;0dyl(!fY2y2&FYE)nqD<i
ziMW`_u8M(I^df`-L@+8d%b1g-Bs|C0J$!t<i}Eb*bAOJ0HD@uvClbe)VOEJZh-Wsd
z2Iqa^Fe}O`@j3B?Nf#u3<htVW8|Q+<0?!Pa>C`-Nm{=@yu+qV-XllgM#1U1~DPPFA
zta9Gstd(o5bx;1nU`}6I<~q$0B(R7jND!f*h7!uCB1)@HiiH&I$36VRj$a~|Laq`R
zITlcX2HEk0|H1EWt^Cxan-q)#-7mKNF$M&7fo9#dzmILZc>?&Kfh)c3uQY(!Ptxmc
zEph~ewt<W5wx;X>mpj1FlOdb3Bl&3x`8@D`M&FbL25*7BHMh6cK29HiG<B7{0S*p<
z@d9P9d%U}+v$ucGwEFu2tABF6mzSZP00006VoOIv0RI600RN!9r;`8x010qNS#tmY
zE+YT{E+YYWr9XB6000McNliru=LruF1r`t)^^^br02y>eSad^gZEa<4bO1wgWnpw>
zWFU8GbZ8()Nlj2!fese{006~FL_t(o!|j(r4ul{KMX7Nyr}S<!mz>#sH<DChp=hg_
z(5{3wJllQ<P}&UdFVY!XUWtfE6FMaW1AyCLTA&$B12l!Tfab6o&;=#|-C##RS6B(0
zFR%9bsYBf}dki+$&b(cjq;V}~m@)>;S&gMCrLi;@J-feW9S3ZbF<@bX8c7#Q?VHQ(
zeRVlA0BB{we}>0O)i_!c0Ge5qem>Uv^7qJhkh5YSqFlb*zll$JLA&-@uNt}EY`^v@
f`Tqq{3M1PJL7j|s^ABO~00000NkvXXu0mjf@~%XQ

diff --git a/plugins/SlicerT/ResetBtn.png b/plugins/SlicerT/ResetBtn.png
deleted file mode 100644
index 0d9713132ae8e4d87411f355efa0c83058eafdb5..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 14573
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

diff --git a/plugins/SlicerT/SlicerT.cpp b/plugins/SlicerT/SlicerT.cpp
index 3dfd3f3cf3b..d60764b6459 100644
--- a/plugins/SlicerT/SlicerT.cpp
+++ b/plugins/SlicerT/SlicerT.cpp
@@ -22,7 +22,7 @@
  *
  */
 
-// better ounset detection + bpm cleanup
+// TODO: better onset detection + bpm cleanup
 // TODO: switch to arrayVector (maybe)
 // TODO: cleaunp UI classes
 // TODO: implment roxas new UI
@@ -56,7 +56,7 @@ Plugin::Descriptor PLUGIN_EXPORT slicert_plugin_descriptor =
 	"Daniel Kauss Serna <daniel.kauss.serna/at/gmail.com>",
 	0x0100,
 	Plugin::Type::Instrument,
-	new PluginPixmapLoader( "logo" ),
+	new PluginPixmapLoader( "icon" ),
 	nullptr,
 	nullptr,
 } ;
diff --git a/plugins/SlicerT/SlicerTUI.cpp b/plugins/SlicerT/SlicerTUI.cpp
index d251f30ad91..711470bf7c7 100644
--- a/plugins/SlicerT/SlicerTUI.cpp
+++ b/plugins/SlicerT/SlicerTUI.cpp
@@ -56,20 +56,16 @@ SlicerTUI::SlicerTUI( SlicerT * instrument,
 	m_bpmBox(3, "19green", this),
 	m_resetButton(this, nullptr),
 	m_midiExportButton(this, nullptr),
-	m_wf(244, 125, instrument, this)
+	m_wf(248, 132, instrument, this)
 {
 	setAcceptDrops( true );
 	setAutoFillBackground( true );
 
 	QPalette pal;
-	pal.setBrush( backgroundRole(), PLUGIN_NAME::getIconPixmap( "artwork" ) );
-	pal.setColor(QPalette::All, QPalette::ColorRole::Foreground, Qt::red);
-	pal.setColor(QPalette::All, QPalette::ColorRole::Button, Qt::red);
-	pal.setColor(QPalette::All, QPalette::ColorRole::Base, Qt::red);
-	pal.setColor(QPalette::All, QPalette::ColorRole::Highlight, Qt::red);
+	pal.setBrush( backgroundRole(), PLUGIN_NAME::getIconPixmap( "bg" ) );
 	setPalette( pal );
 
-	m_wf.move(3, 5);
+	m_wf.move(2, 2);
 
 	m_bpmBox.move(7, 153);
 	m_bpmBox.setToolTip(tr("Original sample BPM"));
@@ -88,17 +84,17 @@ SlicerTUI::SlicerTUI( SlicerT * instrument,
 
 	m_midiExportButton.move(145, 198);
 	m_midiExportButton.setActiveGraphic(
-						PLUGIN_NAME::getIconPixmap( "CopyMidiBtn" ) );
+						embed::getIconPixmap("midi_tab") );
 	m_midiExportButton.setInactiveGraphic(
-						PLUGIN_NAME::getIconPixmap( "CopyMidiBtn" ) );
+						embed::getIconPixmap("midi_tab"));
 	m_midiExportButton.setToolTip(tr("Copy midi pattern to clipboard"));
 	connect(&m_midiExportButton, SIGNAL( clicked() ), this, SLOT( exportMidi() ));
 
 	m_resetButton.move(80, 198);
 	m_resetButton.setActiveGraphic(
-						PLUGIN_NAME::getIconPixmap( "ResetBtn" ) );
+						embed::getIconPixmap("reload") );
 	m_resetButton.setInactiveGraphic(
-						PLUGIN_NAME::getIconPixmap( "ResetBtn" ) );
+						embed::getIconPixmap("reload") );
 	m_resetButton.setToolTip(tr("Reset Slices"));
 	connect(&m_resetButton, SIGNAL( clicked() ), m_slicerTParent, SLOT( updateSlices() ));
 }
diff --git a/plugins/SlicerT/SlicerTUI.h b/plugins/SlicerT/SlicerTUI.h
index c9be4e2aeeb..40ac38cbbe5 100644
--- a/plugins/SlicerT/SlicerTUI.h
+++ b/plugins/SlicerT/SlicerTUI.h
@@ -52,11 +52,11 @@ class SlicerTKnob : public Knob {
 		setFixedSize( 46, 40 );
 		setCenterPointX( 23.0 );
 		setCenterPointY( 15.0 );
-		setInnerRadius( 8 );
+		setInnerRadius( 3 );
 		setOuterRadius( 11 );
 		// setTotalAngle( 270.0 );
 		setLineWidth( 3 );
-		setOuterColor( QColor(255, 161, 247) );
+		setOuterColor( QColor(178, 115, 255) );
 		}
 };
 
diff --git a/plugins/SlicerT/WaveForm.cpp b/plugins/SlicerT/WaveForm.cpp
index 86c67831245..115e24c258e 100644
--- a/plugins/SlicerT/WaveForm.cpp
+++ b/plugins/SlicerT/WaveForm.cpp
@@ -34,14 +34,16 @@ namespace gui
 {
 WaveForm::WaveForm(int w, int h, SlicerT  * instrument, QWidget * parent) :
     QWidget(parent),
-    m_sliceEditor(QPixmap(w, h*(1 - m_m_seekerRatio) - m_margin)),
-    m_seeker(QPixmap(w, h*m_m_seekerRatio)),
-    m_seekerWaveform(QPixmap(w, h*m_m_seekerRatio)),
+    m_sliceEditor(QPixmap(w, h - m_seekerHeight - m_margin)),
+    m_seeker(QPixmap(w, m_seekerHeight)),
+    m_seekerWaveform(QPixmap(w, m_seekerHeight)),
     m_currentSample(instrument->m_originalSample),
     m_slicePoints(instrument->m_slicePoints)
     {
         m_width = w;
         m_height = h;
+        m_editorHeight = h - m_seekerHeight - m_margin;
+
         m_slicerTParent = instrument;
         setFixedSize(m_width, m_height);
         setMouseTracking( true );
@@ -68,12 +70,12 @@ void WaveForm::drawEditor()
     float endFrame = m_seekerEnd * m_currentSample.frames();
 
     brush.setPen(m_playHighlighColor);
-    brush.drawLine(0, m_sliceEditor.height()/2, m_sliceEditor.width(), m_sliceEditor.height()/2);
+    brush.drawLine(0, m_editorHeight/2, m_width, m_editorHeight/2);
 
     brush.setPen(m_waveformColor);
     m_currentSample.visualize(
     brush,
-    QRect( 0, 0, m_sliceEditor.width(), m_sliceEditor.height() ),
+    QRect( 0, 0, m_width, m_editorHeight ),
     startFrame, endFrame);
 
 
@@ -90,7 +92,7 @@ void WaveForm::drawEditor()
                 brush.setPen(QPen(m_selectedSliceColor, 2));
             }
 
-            brush.drawLine(xPos, 0, xPos, m_height);
+            brush.drawLine(xPos, 0, xPos, m_editorHeight);
         }
     }
 }
@@ -118,22 +120,30 @@ void WaveForm::drawSeeker()
     for (int i = 0;i<m_slicePoints.size();i++)
     {
         float xPos = (float)m_slicePoints[i] / (float)m_currentSample.frames() * (float)m_width;
-        brush.drawLine(xPos, 0, xPos, m_height);
+        brush.drawLine(xPos, 0, xPos, m_seekerHeight);
     }
 
     // draw current playBack
     brush.setPen(m_playColor);
-    brush.drawLine(m_noteCurrent*m_width, 0, m_noteCurrent*m_width, m_height);
-    brush.fillRect(m_noteStart*m_width, 0, (m_noteEnd-m_noteStart)*m_width, m_height, m_playHighlighColor);
+    brush.drawLine(m_noteCurrent*m_width, 0, m_noteCurrent*m_width, m_seekerHeight);
+    brush.fillRect(m_noteStart*m_width, 0, (m_noteEnd-m_noteStart)*m_width, m_seekerHeight, m_playHighlighColor);
 
     // draw m_seeker points
-    brush.setPen(QPen(m_seekerColor, 3));
-    brush.drawLine(m_seekerStart*m_width, 0, m_seekerStart*m_width, m_height);
-    brush.drawLine(m_seekerEnd*m_width, 0, m_seekerEnd*m_width, m_height);
+    // brush.setPen(QPen(m_seekerColor, 3));
+    // brush.drawLine(m_seekerStart*m_width, 0, m_seekerStart*m_width, m_seekerHeight);
+    // brush.drawLine(m_seekerEnd*m_width, 0, m_seekerEnd*m_width, m_seekerHeight);
+
+
+    // highlight on selecte area
+    brush.fillRect(m_seekerStart*m_width, 0, (m_seekerEnd-m_seekerStart)*m_width, m_seekerHeight, m_seekerHighlightColor);
 
     // shadow on not selected area
-    brush.fillRect(0, 0, m_seekerStart*m_width, m_height, m_seekerShadowColor);
-    brush.fillRect(m_seekerEnd*m_width, 0, m_width, m_height, m_seekerShadowColor);
+    brush.fillRect(0, 0, m_seekerStart*m_width, m_seekerHeight, m_seekerShadowColor);
+    brush.fillRect(m_seekerEnd*m_width+1, 0, m_width+1, m_seekerHeight, m_seekerShadowColor);
+
+    brush.setPen(QPen(m_seekerColor, 1));
+    brush.drawRoundedRect(m_seekerStart*m_width, 0, (m_seekerEnd-m_seekerStart)*m_width-1, m_seekerHeight-1, 4, 4); // -1 needed
+
 }
 
 void WaveForm::updateUI()
@@ -171,7 +181,7 @@ void WaveForm::mousePressEvent( QMouseEvent * me )
         return;
     }
 
-    if (me->y() < m_height*m_m_seekerRatio)
+    if (me->y() < m_seekerHeight)
     {
         if (abs(normalizedClick - m_seekerStart) < 0.03)
         {
@@ -248,7 +258,7 @@ void WaveForm::mouseMoveEvent( QMouseEvent * me )
 
             m_seekerMiddle = normalizedClick;
 
-            if (m_seekerMiddle + distStart > 0 && m_seekerMiddle + distEnd < 1)
+            if (m_seekerMiddle + distStart >= 0 && m_seekerMiddle + distEnd <= 1)
             {
                 m_seekerStart = m_seekerMiddle + distStart;
                 m_seekerEnd = m_seekerMiddle + distEnd;
@@ -294,7 +304,7 @@ void WaveForm::paintEvent( QPaintEvent * pe)
     QPainter p( this );
     p.drawPixmap(0, 0 ,m_seekerWaveform);
     p.drawPixmap(0, 0, m_seeker);
-    p.drawPixmap(0, m_height*0.3f + m_margin, m_sliceEditor);
+    p.drawPixmap(0, m_seekerHeight + m_margin, m_sliceEditor);
 }
 } // namespace gui
 } // namespace lmms
\ No newline at end of file
diff --git a/plugins/SlicerT/WaveForm.h b/plugins/SlicerT/WaveForm.h
index d5169e1fab7..4c85c19d1b7 100644
--- a/plugins/SlicerT/WaveForm.h
+++ b/plugins/SlicerT/WaveForm.h
@@ -57,16 +57,18 @@ class WaveForm : public QWidget {
     private:
         int m_width;
         int m_height;
-        float m_m_seekerRatio = 0.3f;
+        int m_seekerHeight = 46;
+        int m_editorHeight;
         int m_margin = 5;
-        QColor m_waveformBgColor = QColor(11, 11, 11, 200);
-        QColor m_waveformColor = QColor(113, 0, 177);
+        QColor m_waveformBgColor = QColor(255, 255, 255, 0);
+        QColor m_waveformColor = QColor(123, 49, 212);
         // QColor m_waveformColor = QColor(255, 161, 247); // logo color
         QColor m_playColor = QColor(255, 255, 255, 200);
         QColor m_playHighlighColor = QColor(255, 255, 255, 70);
-        QColor m_sliceColor = QColor(49, 214, 124);
+        QColor m_sliceColor = QColor(218, 193, 255);
         QColor m_selectedSliceColor = QColor(172, 236, 190);
-        QColor m_seekerColor = QColor(214, 124, 49);
+        QColor m_seekerColor = QColor(178, 115, 255);
+        QColor m_seekerHighlightColor = QColor(178, 115, 255, 100);
         QColor m_seekerShadowColor = QColor(0, 0, 0, 175);
 
         enum class m_draggingTypes
diff --git a/plugins/SlicerT/artwork.png b/plugins/SlicerT/artwork.png
deleted file mode 100644
index d3a44cc9e5ae9720cdb65a2168a485b82e4d667b..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 11467
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

diff --git a/plugins/SlicerT/bg.png b/plugins/SlicerT/bg.png
new file mode 100644
index 0000000000000000000000000000000000000000..8ad07941fe5eb75f9286839aa60b27729f618bf4
GIT binary patch
literal 19736
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

literal 0
HcmV?d00001

diff --git a/plugins/SlicerT/bg_no_logo.png b/plugins/SlicerT/bg_no_logo.png
new file mode 100644
index 0000000000000000000000000000000000000000..b017cc9f28f88c8dec2d517f970c800efbff5596
GIT binary patch
literal 16125
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
aMsaqnwE353-F&44O+`UdzF5}s<^KY@cnlB#

literal 0
HcmV?d00001

diff --git a/plugins/SlicerT/icon.png b/plugins/SlicerT/icon.png
new file mode 100644
index 0000000000000000000000000000000000000000..f2c4fabf14facdba53038995a70700bd9a14ad06
GIT binary patch
literal 759
zcmV<T0to$yP)<h;3K|Lk000e1NJLTq001%o001%w1^@s69zTe&00006VoOIv01p5U
z01x2sb^-tZ010qNS#tmYE+YT{E+YYWr9XB6000McNliru=Lr!K0xP2kKg|FD02y>e
zSad^gZEa<4bO1wgWnpw>WFU8GbZ8()Nlj2!fese{00Li0L_t(&-tC%AXcJKsM$g1(
zO9)OEDF{*!@h3D0y3#C^P!MVnbfa{kM07J11ee)}h%SO|G*S&!Qlp?kMT=Teiedz@
zRTo975~bCGDYOPFQwfc2(sA<|CJka2NjtC1x4iS1`3`sPeRqbZghMe_f}8-M@bQwM
zs;awyAP@k&7V(+_l0aP7^#SvRa43dj;c8V?uLJ#nW+4cK7Y*na9!um{0Fe-jtu9S?
zEe8>l%@UPGvpF*kQ%z_R*0?6T7c&x+xM2m&AOVR%0%j1e#30_Xt|hZ<5KE3I%eoo(
zPU7Es00pHaUYN^suDhkOAgwJLr-ElH3h?dw7uv72vvc$QG6-p2t)IVs5b3x`lkW(t
z98NiFWIC7SO6LW3Z#+uPYL}eFUMS@0?253(wHMXpk+;|%Kf6!giv;ePH~(F07;}{e
z>3j8v(Xru0-LP@f4o)0CT@uUvnPzzO6CdBE$z(^!WJi{#{Z39zFz|k2Q8!%YSzi|W
z{B?-Cce>cqc!<P@t8#9L<C!sHw{H;ewc=2!_qeKp{LW5s`Q~|=yvJDMtd(;_nVp@X
z<K88<dk*5Rt&?-sG7N(UiCfg=wo$*fLEfS9`RgZiKYhrCdY`=0Z)S3wvynDD?go}p
z6$g1Y^b!C?QRD`h$>;13D;vZHu|aGQ8^i{&L2M8k#G0zwf33lE4}<BRCC^Ao;$)=E
zAW4Zql4g*&#31n^h&bC3l@KC2e=eoiwRBx?19~Nb=oOyJ+pn(c`y|OsRCxXOJ|Zan
p0?10;EG0bo&6${&vQiG7{RQV)un|g9zOVoQ002ovPDHLkV1h;yMs5HA

literal 0
HcmV?d00001

diff --git a/plugins/SlicerT/knob_center.png b/plugins/SlicerT/knob_center.png
new file mode 100644
index 0000000000000000000000000000000000000000..f74e202309025859bc4de2bd7498f0f20154d9c2
GIT binary patch
literal 6455
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

literal 0
HcmV?d00001

diff --git a/plugins/SlicerT/logo.png b/plugins/SlicerT/logo.png
index aead03f79a8a4d5b6be99c7b70d15a1f96022482..08eb67b128186b67fcc509ee7f55d803bfc0b992 100644
GIT binary patch
delta 8359
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

delta 36542
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

diff --git a/plugins/SlicerT/slide_indicator_arrow.png b/plugins/SlicerT/slide_indicator_arrow.png
new file mode 100644
index 0000000000000000000000000000000000000000..1f60fc3bfcc85a43cc42cb0137d9f5da04b3e999
GIT binary patch
literal 234
zcmeAS@N?(olHy`uVBq!ia0vp^96-#<!3HENCaw(yQfx`y?k)`cAo$=z852;1v%n*=
zn1Ml08H5=tmfDvA1=&kHeO=j~a|()but}EB-3}CzEOCt}an8@pP0cG|a4t$sEJ;mK
zD9<d(P;mG34G3@K69*~^@^o<w;kcf>CCT&G`<3$!H1Ou^vFmQ^Y-C8V`j#&Dcq033
zLlwSz_YV|2yD#LX#>U3hHaC8^<oZ1}Y}5Drc_eXoUVd$l#4e#F%l`ULnDtFQl851D
XjP%-TYc~4=O=s|Q^>bP0l+XkKOgTya

literal 0
HcmV?d00001

diff --git a/plugins/SlicerT/slide_indicator_bar.png b/plugins/SlicerT/slide_indicator_bar.png
new file mode 100644
index 0000000000000000000000000000000000000000..b17a644e8209f839c61ff3c99b33338ef541eef5
GIT binary patch
literal 197
zcmeAS@N?(olHy`uVBq!ia0vp^OhD|<!3HD`7Kls(Qfx`y?k)`cAo$=z8AzJ5z$3Dl
zfk96hgc&QA+Lr+Z*-JcqUD=;=3W{>*=^Qfk1qw-)xJHyX=jZ08=9Mrw7o{eaq^2m8
zXO?6rxO@5rgg5eu0~P6dx;TbtoKJqUV#fFRjg1fGg_)U|ohPI#2@5le^ccBGHqSYD
i=)i#w`FFql<YAa_iNktn(nArTMg~t;KbLh*2~7YJnKobm

literal 0
HcmV?d00001

diff --git a/plugins/SlicerT/slide_indicator_full.png b/plugins/SlicerT/slide_indicator_full.png
new file mode 100644
index 0000000000000000000000000000000000000000..aa8a24844482bd4326c7f869161837eb5e8243cd
GIT binary patch
literal 290
zcmeAS@N?(olHy`uVBq!ia0vp^96%hx!3HGvJD0HoDYhhUcNYeJ5Pa~Vj0q^hS>O>_
z%)p?h48n{ROYO^mg6t)pzOL-gIR!;I6i!!3cmahZOI#yLobz*YQ}ap~oQqNuOHxx5
z$}>wc6x=<11Hv2m#DR*sJY5_^JdP)CN%H*le&xIa4ZJyf?7AB}8yOO;zNO1Op2$Ai
zP=)W_{R0Kh?hCo8v9YnW&5hqJxqgog+w?tu9!VUYmtWf>u}f&lvcLWlW_^>7>|vd`
zSn&A40|yR#=wHZulJ~_jmP)ln9fIGEu4oEmUCiYs+M^{AYOpFH<lu^?gR2@?d;jO(
e{q|FXi9vpWQnLNFh7O>s7(8A5T-G@yGywo1mt=?l

literal 0
HcmV?d00001


From f2410fd28a643e2e3d235a6a72568ff80b5d8589 Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Thu, 21 Sep 2023 17:17:50 +0200
Subject: [PATCH 28/99] fixed cmake

---
 cmake/modules/PluginList.cmake | 1 +
 plugins/CMakeLists.txt         | 1 -
 2 files changed, 1 insertion(+), 1 deletion(-)

diff --git a/cmake/modules/PluginList.cmake b/cmake/modules/PluginList.cmake
index 0a4686fb2c6..fe2e03eee24 100644
--- a/cmake/modules/PluginList.cmake
+++ b/cmake/modules/PluginList.cmake
@@ -59,6 +59,7 @@ SET(LMMS_PLUGIN_LIST
 	Sf2Player
 	Sfxr
 	Sid
+	SlicerT
 	SpectrumAnalyzer
 	StereoEnhancer
 	StereoMatrix
diff --git a/plugins/CMakeLists.txt b/plugins/CMakeLists.txt
index aaa92089a70..9a71be4b823 100644
--- a/plugins/CMakeLists.txt
+++ b/plugins/CMakeLists.txt
@@ -18,4 +18,3 @@ INCLUDE_DIRECTORIES(
 FOREACH(PLUGIN ${PLUGIN_LIST})
 	ADD_SUBDIRECTORY(${PLUGIN})
 ENDFOREACH()
-ADD_SUBDIRECTORY("SlicerT")

From 81977f359736464c619241ccb9f2cd5f20ae4643 Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Fri, 22 Sep 2023 23:32:04 +0200
Subject: [PATCH 29/99] Waveform UI finished

---
 plugins/SlicerT/SlicerT.h     |   2 +-
 plugins/SlicerT/SlicerTUI.cpp |  18 +--
 plugins/SlicerT/SlicerTUI.h   |  18 +--
 plugins/SlicerT/WaveForm.cpp  | 241 +++++++++++++++++-----------------
 plugins/SlicerT/WaveForm.h    |  39 ++++--
 plugins/SlicerT/bg.png        | Bin 19736 -> 20842 bytes
 6 files changed, 164 insertions(+), 154 deletions(-)

diff --git a/plugins/SlicerT/SlicerT.h b/plugins/SlicerT/SlicerT.h
index 3f4dc482cad..8c0a10a3be9 100644
--- a/plugins/SlicerT/SlicerT.h
+++ b/plugins/SlicerT/SlicerT.h
@@ -62,7 +62,7 @@ class PhaseVocoder {
 
 		// timeshift stuff
 		static const int windowSize = 512;
-		static const int overSampling = 64;
+		static const int overSampling = 32;
 
 		// depending on scaleRatio
 		int stepSize = 0;
diff --git a/plugins/SlicerT/SlicerTUI.cpp b/plugins/SlicerT/SlicerTUI.cpp
index 711470bf7c7..c2115a735bf 100644
--- a/plugins/SlicerT/SlicerTUI.cpp
+++ b/plugins/SlicerT/SlicerTUI.cpp
@@ -56,7 +56,7 @@ SlicerTUI::SlicerTUI( SlicerT * instrument,
 	m_bpmBox(3, "19green", this),
 	m_resetButton(this, nullptr),
 	m_midiExportButton(this, nullptr),
-	m_wf(248, 132, instrument, this)
+	m_wf(248, 128, instrument, this)
 {
 	setAcceptDrops( true );
 	setAutoFillBackground( true );
@@ -65,24 +65,24 @@ SlicerTUI::SlicerTUI( SlicerT * instrument,
 	pal.setBrush( backgroundRole(), PLUGIN_NAME::getIconPixmap( "bg" ) );
 	setPalette( pal );
 
-	m_wf.move(2, 2);
+	m_wf.move(2, 6);
 
-	m_bpmBox.move(7, 153);
+	m_bpmBox.move(115, 200);
 	m_bpmBox.setToolTip(tr("Original sample BPM"));
 	m_bpmBox.setLabel(tr("BPM"));
 	m_bpmBox.setModel(&m_slicerTParent->m_originalBPM);
 
-	m_noteThresholdKnob.move(7, 200);
+	m_noteThresholdKnob.move(15, 200);
 	m_noteThresholdKnob.setToolTip(tr("Threshold used for slicing"));
-	// m_noteThresholdKnob.setLabel(tr("Threshold"));
+	m_noteThresholdKnob.setLabel(tr("Threshold"));
 	m_noteThresholdKnob.setModel(&m_slicerTParent->m_noteThreshold);
 
-	m_fadeOutKnob.move(200, 200);
+	m_fadeOutKnob.move(65, 200);
 	m_fadeOutKnob.setToolTip(tr("FadeOut for notes"));
-	// m_fadeOutKnob.setLabel(tr("FadeOut"));
+	m_fadeOutKnob.setLabel(tr("FadeOut"));
 	m_fadeOutKnob.setModel(&m_slicerTParent->m_fadeOutFrames);
 
-	m_midiExportButton.move(145, 198);
+	m_midiExportButton.move(185, 200);
 	m_midiExportButton.setActiveGraphic(
 						embed::getIconPixmap("midi_tab") );
 	m_midiExportButton.setInactiveGraphic(
@@ -90,7 +90,7 @@ SlicerTUI::SlicerTUI( SlicerT * instrument,
 	m_midiExportButton.setToolTip(tr("Copy midi pattern to clipboard"));
 	connect(&m_midiExportButton, SIGNAL( clicked() ), this, SLOT( exportMidi() ));
 
-	m_resetButton.move(80, 198);
+	m_resetButton.move(225, 200);
 	m_resetButton.setActiveGraphic(
 						embed::getIconPixmap("reload") );
 	m_resetButton.setInactiveGraphic(
diff --git a/plugins/SlicerT/SlicerTUI.h b/plugins/SlicerT/SlicerTUI.h
index 40ac38cbbe5..118d9682b57 100644
--- a/plugins/SlicerT/SlicerTUI.h
+++ b/plugins/SlicerT/SlicerTUI.h
@@ -47,16 +47,16 @@ namespace gui
 class SlicerTKnob : public Knob {
 	public:
 		SlicerTKnob( QWidget * _parent ) :
-				Knob( KnobType::Styled, _parent )
+				Knob( KnobType::Bright26, _parent )
 		{
-		setFixedSize( 46, 40 );
-		setCenterPointX( 23.0 );
-		setCenterPointY( 15.0 );
-		setInnerRadius( 3 );
-		setOuterRadius( 11 );
-		// setTotalAngle( 270.0 );
-		setLineWidth( 3 );
-		setOuterColor( QColor(178, 115, 255) );
+		// setFixedSize( 46, 40 );
+		// setCenterPointX( 23.0 );
+		// setCenterPointY( 15.0 );
+		// setInnerRadius( 3 );
+		// setOuterRadius( 11 );
+		// // setTotalAngle( 270.0 );
+		// setLineWidth( 3 );
+		// setOuterColor( QColor(178, 115, 255) );
 		}
 };
 
diff --git a/plugins/SlicerT/WaveForm.cpp b/plugins/SlicerT/WaveForm.cpp
index 115e24c258e..d59acc8cfdf 100644
--- a/plugins/SlicerT/WaveForm.cpp
+++ b/plugins/SlicerT/WaveForm.cpp
@@ -25,6 +25,7 @@
 #include "WaveForm.h"
 #include "SlicerT.h"
 
+#include "embed.h"
 
 namespace lmms
 {
@@ -34,17 +35,24 @@ namespace gui
 {
 WaveForm::WaveForm(int w, int h, SlicerT  * instrument, QWidget * parent) :
     QWidget(parent),
-    m_sliceEditor(QPixmap(w, h - m_seekerHeight - m_margin)),
-    m_seeker(QPixmap(w, m_seekerHeight)),
-    m_seekerWaveform(QPixmap(w, m_seekerHeight)),
+    // calculate sizes
+    m_width(w),
+    m_height(h),
+    m_seekerWidth(w - m_seekerHorMargin * 2),
+    m_editorHeight(h - m_seekerHeight - m_middleMargin),
+    m_editorWidth(w),
+
+    // create pixmaps
+    m_sliceArrow(PLUGIN_NAME::getIconPixmap( "slide_indicator_arrow" )),
+    m_seeker(QPixmap(m_seekerWidth, m_seekerHeight)),
+    m_seekerWaveform(QPixmap(m_seekerWidth, m_seekerHeight)),
+    m_sliceEditor(QPixmap(w, m_editorHeight)),
+
+    // references to instrument vars
+    m_slicerTParent(instrument),
     m_currentSample(instrument->m_originalSample),
     m_slicePoints(instrument->m_slicePoints)
     {
-        m_width = w;
-        m_height = h;
-        m_editorHeight = h - m_seekerHeight - m_margin;
-
-        m_slicerTParent = instrument;
         setFixedSize(m_width, m_height);
         setMouseTracking( true );
 
@@ -55,54 +63,18 @@ WaveForm::WaveForm(int w, int h, SlicerT  * instrument, QWidget * parent) :
                 SIGNAL(isPlaying(float, float, float)),
                 this,
                 SLOT(isPlaying(float, float, float)));
-
-        connect(m_slicerTParent, SIGNAL(dataChanged()), this, SLOT(updateData()));
+        connect(m_slicerTParent, SIGNAL(dataChanged()), this, SLOT(updateUI()));
 
         updateUI();
     }
 
-void WaveForm::drawEditor()
-{
-    m_sliceEditor.fill(m_waveformBgColor);
-    QPainter brush(&m_sliceEditor);
-
-    float startFrame = m_seekerStart * m_currentSample.frames();
-    float endFrame = m_seekerEnd * m_currentSample.frames();
-
-    brush.setPen(m_playHighlighColor);
-    brush.drawLine(0, m_editorHeight/2, m_width, m_editorHeight/2);
-
-    brush.setPen(m_waveformColor);
-    m_currentSample.visualize(
-    brush,
-    QRect( 0, 0, m_width, m_editorHeight ),
-    startFrame, endFrame);
-
-
-    for (int i = 0;i<m_slicePoints.size();i++)
-    {
-        int sliceIndex = m_slicePoints[i];
-        brush.setPen(QPen(m_sliceColor, 2));
-
-        if (sliceIndex >= startFrame && sliceIndex <= endFrame)
-        {
-            float xPos = (float)(sliceIndex - startFrame) / (float)(endFrame - startFrame) * (float)m_width;
-            if (i == m_sliceSelected)
-            {
-                brush.setPen(QPen(m_selectedSliceColor, 2));
-            }
-
-            brush.drawLine(xPos, 0, xPos, m_editorHeight);
-        }
-    }
-}
-
+// graphics
 void WaveForm::drawSeekerWaveform()
 {
+    m_seekerWaveform.fill(m_waveformBgColor);
     QPainter brush(&m_seekerWaveform);
     brush.setPen(m_waveformColor);
 
-    m_seekerWaveform.fill(m_waveformBgColor);
     m_currentSample.visualize(
     brush,
     QRect( 0, 0, m_seekerWaveform.width(), m_seekerWaveform.height() ),
@@ -111,41 +83,74 @@ void WaveForm::drawSeekerWaveform()
 
 void WaveForm::drawSeeker()
 {
-    m_seeker.fill(QColor(0, 0, 0, 0));
+    m_seeker.fill(m_waveformBgColor);
     QPainter brush(&m_seeker);
-    brush.setPen(m_waveformColor);
-
     // draw slice points
     brush.setPen(m_sliceColor);
     for (int i = 0;i<m_slicePoints.size();i++)
     {
-        float xPos = (float)m_slicePoints[i] / (float)m_currentSample.frames() * (float)m_width;
+        float xPos = (float)m_slicePoints[i] / m_currentSample.frames() * m_seekerWidth;
         brush.drawLine(xPos, 0, xPos, m_seekerHeight);
     }
 
+    // this is a complete mess
     // draw current playBack
     brush.setPen(m_playColor);
-    brush.drawLine(m_noteCurrent*m_width, 0, m_noteCurrent*m_width, m_seekerHeight);
-    brush.fillRect(m_noteStart*m_width, 0, (m_noteEnd-m_noteStart)*m_width, m_seekerHeight, m_playHighlighColor);
-
-    // draw m_seeker points
-    // brush.setPen(QPen(m_seekerColor, 3));
-    // brush.drawLine(m_seekerStart*m_width, 0, m_seekerStart*m_width, m_seekerHeight);
-    // brush.drawLine(m_seekerEnd*m_width, 0, m_seekerEnd*m_width, m_seekerHeight);
-
+    brush.drawLine(m_noteCurrent*m_seekerWidth, 0, m_noteCurrent*m_seekerWidth, m_seekerHeight);
+    brush.fillRect(m_noteStart*m_seekerWidth, 0, (m_noteEnd-m_noteStart)*m_seekerWidth, m_seekerHeight, m_playHighlighColor);
 
-    // highlight on selecte area
-    brush.fillRect(m_seekerStart*m_width, 0, (m_seekerEnd-m_seekerStart)*m_width, m_seekerHeight, m_seekerHighlightColor);
+    // highlight on selected area
+    brush.fillRect(m_seekerStart*m_seekerWidth, 0, (m_seekerEnd-m_seekerStart)*m_seekerWidth, m_seekerHeight, m_seekerHighlightColor);
 
     // shadow on not selected area
-    brush.fillRect(0, 0, m_seekerStart*m_width, m_seekerHeight, m_seekerShadowColor);
-    brush.fillRect(m_seekerEnd*m_width+1, 0, m_width+1, m_seekerHeight, m_seekerShadowColor);
+    brush.fillRect(0, 0, m_seekerStart*m_seekerWidth, m_seekerHeight, m_seekerShadowColor);
+    brush.fillRect(m_seekerEnd*m_seekerWidth+1, 0, m_seekerWidth+1, m_seekerHeight, m_seekerShadowColor);
 
+    // draw border around selection
     brush.setPen(QPen(m_seekerColor, 1));
-    brush.drawRoundedRect(m_seekerStart*m_width, 0, (m_seekerEnd-m_seekerStart)*m_width-1, m_seekerHeight-1, 4, 4); // -1 needed
+    brush.drawRoundedRect(m_seekerStart*m_seekerWidth, 0, (m_seekerEnd-m_seekerStart)*m_seekerWidth-1, m_seekerHeight-1, 4, 4); // -1 needed
+}
+
+void WaveForm::drawEditor()
+{
+    m_sliceEditor.fill(m_waveformBgColor);
+    QPainter brush(&m_sliceEditor);
+
+    float startFrame = m_seekerStart * m_currentSample.frames();
+    float endFrame = m_seekerEnd * m_currentSample.frames();
+    float numFramesToDraw = endFrame - startFrame;
+
+    // 0 centered line
+    brush.setPen(m_playHighlighColor);
+    brush.drawLine(0, m_editorHeight/2, m_editorWidth, m_editorHeight/2);
 
+    // draw waveform
+    brush.setPen(m_waveformColor);
+    m_currentSample.visualize(
+    brush,
+    QRect( 0, 0, m_editorWidth, m_editorHeight ),
+    startFrame, endFrame);
+
+    // draw slicepoints
+    brush.setPen(QPen(m_sliceColor, 2));
+    for (int i = 0;i<m_slicePoints.size();i++)
+    {
+        float xPos = (float)(m_slicePoints[i] - startFrame) / numFramesToDraw * m_editorWidth;
+
+        if (i == m_sliceSelected)
+        {
+            brush.setPen(QPen(m_selectedSliceColor, 2));
+        } else
+        {
+            brush.setPen(QPen(m_sliceColor, 2));
+        }
+
+        brush.drawLine(xPos, 0, xPos, m_editorHeight);
+        brush.drawPixmap(xPos - (float)m_sliceArrow.width()/2, 0, m_sliceArrow);
+    }
 }
 
+// slots
 void WaveForm::updateUI()
 {
     drawSeekerWaveform();
@@ -154,13 +159,6 @@ void WaveForm::updateUI()
     update();
 }
 
-void WaveForm::updateData()
-{
-    // I hate SampleBuffer, fot whatever reason this crashes sometimes
-    // m_currentSample = SampleBuffer(m_slicerTParent->m_originalSample.data(), m_slicerTParent->m_originalSample.frames());
-    updateUI();
-}
-
 void WaveForm::isPlaying(float current, float start, float end)
 {
     m_noteCurrent = current;
@@ -170,10 +168,12 @@ void WaveForm::isPlaying(float current, float start, float end)
     update();
 }
 
+// events
 void WaveForm::mousePressEvent( QMouseEvent * me )
 {
-    float normalizedClick = (float)me->x() / m_width;
-
+    float normalizedClickSeeker = (float)(me->x() - m_seekerHorMargin) / m_seekerWidth;
+    float normalizedClickEditor = (float)(me->x()) / m_editorWidth;
+    // reset seeker on middle click
     if (me->button() == Qt::MouseButton::MiddleButton)
     {
         m_seekerStart = 0;
@@ -181,44 +181,39 @@ void WaveForm::mousePressEvent( QMouseEvent * me )
         return;
     }
 
-    if (me->y() < m_seekerHeight)
+    if (me->y() < m_seekerHeight) // seeker click
     {
-        if (abs(normalizedClick - m_seekerStart) < 0.03)
+        if (abs(normalizedClickSeeker - m_seekerStart) < distanceForClick) // dragging start
         {
             m_currentlyDragging = m_draggingTypes::m_seekerStart;
-
-        } else if (abs(normalizedClick - m_seekerEnd) < 0.03)
+        } else if (abs(normalizedClickSeeker - m_seekerEnd) < distanceForClick) // dragging end
         {
             m_currentlyDragging = m_draggingTypes::m_seekerEnd;
 
-        } else if (normalizedClick > m_seekerStart && normalizedClick < m_seekerEnd)
+        } else if (normalizedClickSeeker > m_seekerStart && normalizedClickSeeker < m_seekerEnd) // dragging middle
         {
             m_currentlyDragging = m_draggingTypes::m_seekerMiddle;
-            m_seekerMiddle = normalizedClick;
+            m_seekerMiddle = normalizedClickSeeker;
         }
-
-    } else {
+    } else { // editor click
         m_sliceSelected = -1;
         float startFrame = m_seekerStart * m_currentSample.frames();
         float endFrame = m_seekerEnd * m_currentSample.frames();
-
+        // select slice
         for (int i = 0;i<m_slicePoints.size();i++)
         {
             int sliceIndex = m_slicePoints[i];
             float xPos = (float)(sliceIndex - startFrame) / (float)(endFrame - startFrame);
 
-            if (abs(xPos - normalizedClick) < 0.03)
+            if (abs(xPos - normalizedClickEditor) < distanceForClick)
             {
-                m_currentlyDragging = m_draggingTypes::slicePoint;
+                m_currentlyDragging = m_draggingTypes::m_slicePoint;
                 m_sliceSelected = i;
             }
         }
     }
-    if (me->button() == Qt::MouseButton::LeftButton)
-    {
-        m_isDragging = true;
 
-    } else if (me->button() == Qt::MouseButton::RightButton)
+    if (me->button() == Qt::MouseButton::RightButton) // erase selected slice
     {
         if (m_sliceSelected != -1 && m_slicePoints.size() > 2)
         {
@@ -226,66 +221,66 @@ void WaveForm::mousePressEvent( QMouseEvent * me )
             m_sliceSelected = -1;
         }
     }
-
+    updateUI();
 }
 
 void WaveForm::mouseReleaseEvent( QMouseEvent * me )
 {
-    m_isDragging = false;
     m_currentlyDragging = m_draggingTypes::nothing;
     updateUI();
 }
 
 void WaveForm::mouseMoveEvent( QMouseEvent * me )
 {
-    float normalizedClick = (float)me->x() / m_width;
+    float normalizedClickSeeker = (float)(me->x() - m_seekerHorMargin) / m_seekerWidth;
+    float normalizedClickEditor = (float)(me->x()) / m_editorWidth;
+
+    float distStart = m_seekerStart - m_seekerMiddle;
+    float distEnd = m_seekerEnd - m_seekerMiddle;
+    float startFrame = m_seekerStart * m_currentSample.frames();
+    float endFrame = m_seekerEnd * m_currentSample.frames();
 
     // handle dragging events
-    if (m_isDragging)
+    switch (m_currentlyDragging)
     {
-        if (m_currentlyDragging == m_draggingTypes::m_seekerStart)
-        {
-            m_seekerStart = std::clamp(normalizedClick, 0.0f, m_seekerEnd - 0.13f);
+    case m_draggingTypes::m_seekerStart:
+        m_seekerStart = std::clamp(normalizedClickSeeker, 0.0f, m_seekerEnd - minSeekerDistance);
+        break;
 
-        } else if (m_currentlyDragging == m_draggingTypes::m_seekerEnd)
-        {
-            m_seekerEnd = std::clamp(normalizedClick, m_seekerStart + 0.13f, 1.0f);;
-
-        } else if (m_currentlyDragging == m_draggingTypes::m_seekerMiddle)
-        {
-            float distStart = m_seekerStart - m_seekerMiddle;
-            float distEnd = m_seekerEnd - m_seekerMiddle;
+    case m_draggingTypes::m_seekerEnd:
+        m_seekerEnd = std::clamp(normalizedClickSeeker, m_seekerStart + minSeekerDistance, 1.0f);
+        break;
 
-            m_seekerMiddle = normalizedClick;
-
-            if (m_seekerMiddle + distStart >= 0 && m_seekerMiddle + distEnd <= 1)
-            {
-                m_seekerStart = m_seekerMiddle + distStart;
-                m_seekerEnd = m_seekerMiddle + distEnd;
-            }
+    case m_draggingTypes::m_seekerMiddle:
+        m_seekerMiddle = normalizedClickSeeker;
 
-        } else if (m_currentlyDragging == m_draggingTypes::slicePoint)
+        if (m_seekerMiddle + distStart >= 0 && m_seekerMiddle + distEnd <= 1)
         {
-            float startFrame = m_seekerStart * m_currentSample.frames();
-            float endFrame = m_seekerEnd * m_currentSample.frames();
+            m_seekerStart = m_seekerMiddle + distStart;
+            m_seekerEnd = m_seekerMiddle + distEnd;
+        }
+        break;
 
-            m_slicePoints[m_sliceSelected] = startFrame + normalizedClick * (endFrame - startFrame);
+    case m_draggingTypes::m_slicePoint: // TODO: fix this
+        m_slicePoints[m_sliceSelected] = startFrame + normalizedClickEditor * (endFrame - startFrame);
 
-            m_slicePoints[m_sliceSelected] = std::clamp(m_slicePoints[m_sliceSelected], 0, m_currentSample.frames());
+        m_slicePoints[m_sliceSelected] = std::clamp(m_slicePoints[m_sliceSelected], 0, m_currentSample.frames());
 
-            std::sort(m_slicePoints.begin(), m_slicePoints.end());
-        }
-        updateUI();
+        std::sort(m_slicePoints.begin(), m_slicePoints.end());
+        break;
+    case m_draggingTypes::nothing:
+        break;
     }
+    updateUI();
 }
 
 void WaveForm::mouseDoubleClickEvent(QMouseEvent * me)
 {
-    float normalizedClick = (float)me->x() / m_width;
+    float normalizedClickEditor = (float)(me->x()) / m_editorWidth;
     float startFrame = m_seekerStart * m_currentSample.frames();
     float endFrame = m_seekerEnd * m_currentSample.frames();
 
-    float slicePosition = startFrame + normalizedClick * (endFrame - startFrame);
+    float slicePosition = startFrame + normalizedClickEditor * (endFrame - startFrame);
 
     for (int i = 0;i<m_slicePoints.size();i++)
     {
@@ -302,9 +297,9 @@ void WaveForm::mouseDoubleClickEvent(QMouseEvent * me)
 void WaveForm::paintEvent( QPaintEvent * pe)
 {
     QPainter p( this );
-    p.drawPixmap(0, 0 ,m_seekerWaveform);
-    p.drawPixmap(0, 0, m_seeker);
-    p.drawPixmap(0, m_seekerHeight + m_margin, m_sliceEditor);
+    p.drawPixmap(m_seekerHorMargin, 0 ,m_seekerWaveform);
+    p.drawPixmap(m_seekerHorMargin, 0, m_seeker);
+    p.drawPixmap(0, m_seekerHeight + m_middleMargin, m_sliceEditor);
 }
 } // namespace gui
 } // namespace lmms
\ No newline at end of file
diff --git a/plugins/SlicerT/WaveForm.h b/plugins/SlicerT/WaveForm.h
index 4c85c19d1b7..cf78042ad20 100644
--- a/plugins/SlicerT/WaveForm.h
+++ b/plugins/SlicerT/WaveForm.h
@@ -55,56 +55,71 @@ class WaveForm : public QWidget {
         virtual void paintEvent(QPaintEvent * pe);
 
     private:
+        // vars used to control structure and colors
         int m_width;
         int m_height;
-        int m_seekerHeight = 46;
+
+        int m_seekerHorMargin = 5;
+        int m_seekerHeight = 38; // used to calcualte all hor sizes
+        int m_seekerWidth;
+
+        int m_middleMargin = 6;
         int m_editorHeight;
-        int m_margin = 5;
+        int m_editorWidth;
+
+
         QColor m_waveformBgColor = QColor(255, 255, 255, 0);
         QColor m_waveformColor = QColor(123, 49, 212);
+        // QColor m_waveformColorDark = QColor(39, 15, 67);
+
         // QColor m_waveformColor = QColor(255, 161, 247); // logo color
         QColor m_playColor = QColor(255, 255, 255, 200);
         QColor m_playHighlighColor = QColor(255, 255, 255, 70);
         QColor m_sliceColor = QColor(218, 193, 255);
-        QColor m_selectedSliceColor = QColor(172, 236, 190);
+        QColor m_selectedSliceColor = QColor(178, 153, 215);
         QColor m_seekerColor = QColor(178, 115, 255);
         QColor m_seekerHighlightColor = QColor(178, 115, 255, 100);
-        QColor m_seekerShadowColor = QColor(0, 0, 0, 175);
+        QColor m_seekerShadowColor = QColor(0, 0, 0, 120);
+
+        // interaction vars
+        float distanceForClick = 0.03f;
+        float minSeekerDistance = 0.13f;
 
+        // dragging vars
         enum class m_draggingTypes
         {
             nothing,
             m_seekerStart,
             m_seekerEnd,
             m_seekerMiddle,
-            slicePoint,
+            m_slicePoint,
         };
-
         m_draggingTypes m_currentlyDragging;
-        bool m_isDragging = false;
 
+        // seeker vars
         float m_seekerStart = 0;
         float m_seekerEnd = 1;
         float m_seekerMiddle = 0.5f;
         int m_sliceSelected = 0;
 
+        // playback highlight vars
         float m_noteCurrent;
         float m_noteStart;
         float m_noteEnd;
 
-        QPixmap m_sliceEditor;
+        // pixmaps
+        QPixmap m_sliceArrow;
         QPixmap m_seeker;
-        QPixmap m_seekerWaveform;
+        QPixmap m_seekerWaveform; // only stores waveform graphic
+        QPixmap m_sliceEditor;
 
         SampleBuffer & m_currentSample;
 
         void drawEditor();
         void drawSeekerWaveform();
         void drawSeeker();
-        void updateUI();
-
     public slots:
-        void updateData();
+        void updateUI();
         void isPlaying(float current, float start, float end);
 
     public:
diff --git a/plugins/SlicerT/bg.png b/plugins/SlicerT/bg.png
index 8ad07941fe5eb75f9286839aa60b27729f618bf4..d87224f890c91457ea6a2b1f947101e572171b9d 100644
GIT binary patch
delta 16537
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

delta 15495
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


From 5ba792be87c42bb2f89cdf59253862cab920ced0 Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Sat, 23 Sep 2023 12:41:51 +0200
Subject: [PATCH 30/99] Roxas UI knobs + layout

---
 plugins/SlicerT/SlicerT.cpp   |  27 +++++++++++++++++----------
 plugins/SlicerT/SlicerT.h     |   5 +++--
 plugins/SlicerT/SlicerTUI.cpp |  12 ++++++------
 plugins/SlicerT/SlicerTUI.h   |  17 ++++++++---------
 plugins/SlicerT/bg.png        | Bin 20842 -> 23763 bytes
 5 files changed, 34 insertions(+), 27 deletions(-)

diff --git a/plugins/SlicerT/SlicerT.cpp b/plugins/SlicerT/SlicerT.cpp
index d60764b6459..d8f5fdd8fe7 100644
--- a/plugins/SlicerT/SlicerT.cpp
+++ b/plugins/SlicerT/SlicerT.cpp
@@ -25,7 +25,8 @@
 // TODO: better onset detection + bpm cleanup
 // TODO: switch to arrayVector (maybe)
 // TODO: cleaunp UI classes
-// TODO: implment roxas new UI
+// TODO: add text when no sample loaded
+// TODO: better buttons
 // TODO: code cleaunp, style and test
 
 #include "SlicerT.h"
@@ -83,13 +84,13 @@ PhaseVocoder::~PhaseVocoder() {
 void PhaseVocoder::loadData(std::vector<float> originalData, int sampleRate, float newRatio) {
 	originalBuffer = originalData;
 	originalSampleRate = sampleRate;
-	scaleRatio = -1; // force update, kinda hacky
+	m_scaleRatio = -1; // force update, kinda hacky
 
 	updateParams(newRatio);
 
 	dataLock.lock();
 
-	// set buffer size
+	// set buffer sizes
 	m_processedWindows.resize(numWindows, false);
 	lastPhase.resize(numWindows*windowSize, 0);
 	sumPhase.resize(numWindows*windowSize, 0);
@@ -132,19 +133,19 @@ void PhaseVocoder::getFrames(std::vector<float> & outData, int start, int frames
 // adjust pv params and reset buffers
 void PhaseVocoder::updateParams(float newRatio) {
 	if (originalBuffer.size() < 2048) { return; }
-	if (newRatio == scaleRatio) { return; }
+	if (newRatio == m_scaleRatio) { return; }
 	dataLock.lock();
 
 	// TODO: remove static stuff from here, like stepsize
-	scaleRatio = newRatio;
+	m_scaleRatio = newRatio;
 	stepSize = (float)windowSize / overSampling;
 	numWindows = (float)originalBuffer.size() / stepSize - overSampling - 1;
-	outStepSize = scaleRatio * (float)stepSize; // float, else inaccurate
+	outStepSize = m_scaleRatio * (float)stepSize; // float, else inaccurate
 	freqPerBin = originalSampleRate/windowSize;
 	expectedPhaseIn = 2.*M_PI*(float)stepSize/(float)windowSize;
 	expectedPhaseOut = 2.*M_PI*(float)outStepSize/(float)windowSize;
 
-	processedBuffer.resize(scaleRatio*originalBuffer.size(), 0);
+	processedBuffer.resize(m_scaleRatio*originalBuffer.size(), 0);
 
 	// very slow :(
 	std::fill(m_processedWindows.begin(), m_processedWindows.end(), false);
@@ -269,7 +270,7 @@ void PhaseVocoder::generateWindow(int windowNum, bool useCache)
 SlicerT::SlicerT(InstrumentTrack * instrumentTrack) :
 	Instrument( instrumentTrack, &slicert_plugin_descriptor ),
 	m_noteThreshold(0.6f, 0.0f, 2.0f, 0.01f, this, tr( "Note threshold" ) ),
-	m_fadeOutFrames(0.0f, 0.0f, 8192.0f, 4.0f, this, tr("FadeOut")),
+	m_fadeOutFrames(400.0f, 0.0f, 8192.0f, 1.0f, this, tr("FadeOut")),
 	m_originalBPM(1, 1, 999, this, tr("Original bpm")),
 	m_originalSample(),
 	m_phaseVocoder()
@@ -386,6 +387,7 @@ void SlicerT::findBPM()
 	if (m_originalSample.frames() < 2048) { return; }
 	int bpmSnap = 1; // 1 = disabled
 
+	// caclulate length of sample
 	float sampleRate = m_originalSample.sampleRate();
 	float totalFrames = m_originalSample.frames();
 	float sampleLength = totalFrames / sampleRate;
@@ -417,13 +419,18 @@ void SlicerT::writeToMidi(std::vector<Note> * outClip)
 {
 	if (m_originalSample.frames() < 2048) { return; }
 
-	int ticksPerBar = DefaultTicksPerBar;
-	float sampleRate = m_originalSample.sampleRate();
+	// update incase bpm changed
+	const float speedRatio = (float)m_originalBPM.value() / Engine::getSong()->getTempo();
+	m_phaseVocoder.setScaleRatio(speedRatio);
 
+	// calculate how many "beats" are in the sample
+	float ticksPerBar = DefaultTicksPerBar;
+	float sampleRate = m_originalSample.sampleRate();
 	float bpm = Engine::getSong()->getTempo();
 	float samplesPerBeat = 60.0f / bpm * sampleRate;
 	float beats = (float)m_phaseVocoder.frames() / samplesPerBeat;
 
+	// calculate how many ticks in sample
 	float barsInSample = beats / Engine::getSong()->getTimeSigModel().getDenominator();
 	float totalTicks = ticksPerBar * barsInSample;
 
diff --git a/plugins/SlicerT/SlicerT.h b/plugins/SlicerT/SlicerT.h
index 8c0a10a3be9..25142f41118 100644
--- a/plugins/SlicerT/SlicerT.h
+++ b/plugins/SlicerT/SlicerT.h
@@ -48,13 +48,14 @@ class PhaseVocoder {
 		void setScaleRatio(float newRatio) { updateParams(newRatio); }
 		void getFrames(std::vector<float> & outData, int start, int frames);
 		int frames() { return processedBuffer.size(); }
+		float scaleRatio() { return m_scaleRatio; }
 	private:
 		QMutex dataLock;
 		// original data
 		std::vector<float> originalBuffer;
 		int originalSampleRate = 0;
 
-		float scaleRatio = -1; // to force on fisrt load
+		float m_scaleRatio = -1; // to force on fisrt load
 
 		// output data
 		std::vector<float> processedBuffer;
@@ -125,12 +126,12 @@ class dinamicPlaybackBuffer {
 			}
 		}
 		int frames() { return leftChannel.frames(); }
+		float scaleRatio() { return leftChannel.scaleRatio(); }
 		void setScaleRatio(float newRatio) {
 			leftChannel.setScaleRatio(newRatio);
 			rightChannel.setScaleRatio(newRatio);
 		}
 	private:
-		float scaleRatio;
 		PhaseVocoder leftChannel;
 		PhaseVocoder rightChannel;
 };
diff --git a/plugins/SlicerT/SlicerTUI.cpp b/plugins/SlicerT/SlicerTUI.cpp
index c2115a735bf..e1af70c2847 100644
--- a/plugins/SlicerT/SlicerTUI.cpp
+++ b/plugins/SlicerT/SlicerTUI.cpp
@@ -53,7 +53,7 @@ SlicerTUI::SlicerTUI( SlicerT * instrument,
 	m_slicerTParent(instrument),
 	m_noteThresholdKnob(this),
 	m_fadeOutKnob(this),
-	m_bpmBox(3, "19green", this),
+	m_bpmBox(3, "21pink", this),
 	m_resetButton(this, nullptr),
 	m_midiExportButton(this, nullptr),
 	m_wf(248, 128, instrument, this)
@@ -67,22 +67,22 @@ SlicerTUI::SlicerTUI( SlicerT * instrument,
 
 	m_wf.move(2, 6);
 
-	m_bpmBox.move(115, 200);
+	m_bpmBox.move(135, 200);
 	m_bpmBox.setToolTip(tr("Original sample BPM"));
 	m_bpmBox.setLabel(tr("BPM"));
 	m_bpmBox.setModel(&m_slicerTParent->m_originalBPM);
 
-	m_noteThresholdKnob.move(15, 200);
+	m_noteThresholdKnob.move(14, 195);
 	m_noteThresholdKnob.setToolTip(tr("Threshold used for slicing"));
 	m_noteThresholdKnob.setLabel(tr("Threshold"));
 	m_noteThresholdKnob.setModel(&m_slicerTParent->m_noteThreshold);
 
-	m_fadeOutKnob.move(65, 200);
+	m_fadeOutKnob.move(80, 195);
 	m_fadeOutKnob.setToolTip(tr("FadeOut for notes"));
 	m_fadeOutKnob.setLabel(tr("FadeOut"));
 	m_fadeOutKnob.setModel(&m_slicerTParent->m_fadeOutFrames);
 
-	m_midiExportButton.move(185, 200);
+	m_midiExportButton.move(190, 200);
 	m_midiExportButton.setActiveGraphic(
 						embed::getIconPixmap("midi_tab") );
 	m_midiExportButton.setInactiveGraphic(
@@ -90,7 +90,7 @@ SlicerTUI::SlicerTUI( SlicerT * instrument,
 	m_midiExportButton.setToolTip(tr("Copy midi pattern to clipboard"));
 	connect(&m_midiExportButton, SIGNAL( clicked() ), this, SLOT( exportMidi() ));
 
-	m_resetButton.move(225, 200);
+	m_resetButton.move(215, 200);
 	m_resetButton.setActiveGraphic(
 						embed::getIconPixmap("reload") );
 	m_resetButton.setInactiveGraphic(
diff --git a/plugins/SlicerT/SlicerTUI.h b/plugins/SlicerT/SlicerTUI.h
index 118d9682b57..425e4e7669e 100644
--- a/plugins/SlicerT/SlicerTUI.h
+++ b/plugins/SlicerT/SlicerTUI.h
@@ -47,16 +47,15 @@ namespace gui
 class SlicerTKnob : public Knob {
 	public:
 		SlicerTKnob( QWidget * _parent ) :
-				Knob( KnobType::Bright26, _parent )
+				Knob( KnobType::Styled, _parent )
 		{
-		// setFixedSize( 46, 40 );
-		// setCenterPointX( 23.0 );
-		// setCenterPointY( 15.0 );
-		// setInnerRadius( 3 );
-		// setOuterRadius( 11 );
-		// // setTotalAngle( 270.0 );
-		// setLineWidth( 3 );
-		// setOuterColor( QColor(178, 115, 255) );
+		setFixedSize( 46, 40 );
+		setCenterPointX( 23.0 );
+		setCenterPointY( 15.0 );
+		setInnerRadius( 3 );
+		setOuterRadius( 11 );
+		setLineWidth( 3 );
+		setOuterColor( QColor(178, 115, 255) );
 		}
 };
 
diff --git a/plugins/SlicerT/bg.png b/plugins/SlicerT/bg.png
index d87224f890c91457ea6a2b1f947101e572171b9d..a9d1c82733c280ac39f31ae30938e18e134f27c4 100644
GIT binary patch
delta 14835
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
M#N<V*g$)D$4<PYve*gdg

delta 12111
zcmYkhWmFx(5-z&2V8J1{ySrNm?hXkO+})iaxNc<Q8r<DIf#B}$?iyTP&bjy8^?vkP
z(_KAZ)mJ@JRlRDa73w$-DvlBw`z4-w4vB+|gF}FwOMr_F0t=N7?TA%h3T2B9VE>}a
zgK&Ww!XmA_KPWN=kXVWJvC#E>0*zrC$3=n=3-Thr5TP)0WYb5}<wY7QA{1s63b2P1
zjZFuTl~NKPvk#Td8mhpQ<VAkK#z?38iJ;HsS)`dBG1Kx>!c|ogM5#)uep_Ju^(m)N
z9_no6NU_i*+K++bc4iWOKm99`ppmf^y`Ff~jI$y(RQhK+{8CUKMYMWZ0-ma@yaF@?
zyFmrUNml7Xk{qS*Lm)jJ)NL7u)z8`ZkB#ifkalcEKoVO8N?Ef&RZWu$N)lW1<3A%o
z{~6+v%+zE^3TjiILvPE`<5m6^4q<<6Zt<RVMz<!)(MjN5n-9SCgpM1e|Bfl3A%QWU
zigrUU)T@veK-@BI`ZTTj84g=b1$tUlk_<}u`#VU^u(%p1L^H&vI3Sga!Ykh&cZppc
znE{?d(`_w8ulo(2H)jtilIZZu4GeSMJV)L^z66f7nZO7>a1kWS1?R{vuO-sw^bQg-
zdk1x)kQ%qVgR(i^K^q^c4$Zt71{SMC52Cy8f9IcSlivIXZORqSS|{gJ{T(#%9|-w7
z#@NRl*4IlbeW>q|wf~y|md`i?FIOpV4_xN~)w1gquaP_dSG%~G=>HK^1yoCZea3zV
z{TFxoH4^wQkYyWmCyvSgQ};hat2HQ{3NiUR`ghQO4JtKmO!Mxg{f}bMi-sMZb<R-A
zo9EDf_z9%}z(I7*{qJH|j;J1Kx#&QF`IPv7FD7#U8z1s*WC`EC{&yowuu5J<W8zxw
zf9%|-)dT)ZNt)xo2K<kq^kVV<T#_`2b68Gl{69a6^!;BZ|EOnYy(O{!&soLH7@0ew
zttrL#D7c@2_a!7A5oJgQt|Jg^B`&TaD=tpv=<Hx_Worfkd1m^>3(E9<ChG4llJnCb
z`be=Imm3+Rukoi=D;ELhOXXx)kk>7oB0&N+uJrH5%}tZq<IU}g@}P1u1d-2r`kC1J
z1%KYDLq4&S5Z&*zKZ~4q!L)dPo2mfg{XA+)llv2*;I4_#nMWA3ITZys$<{{mt19$(
z_^wg@ns28YxfZ=YI8=8@hK7aRPBl*Dx%zN5T4cwzPP?C!SAdy=rJU+2wk=&WLekC7
z(lT1Bu&z+NAK_)3JK66{$SA2!nN0&ONmqK*>o-Zd`eah6r<s0l%KGu(Hp#4LhDZ!L
z>T4hZ6h|3d?ngpZ9XB<AslZb7e23Kim7>+uIq7Gd2^5ZHoSx_+>C5^2u(G1J>=xhT
z<2D~@{%1>E%UPm>=S3$1+RvBxEz`Pha>S{xRGstF6w;sHc^sYArgw!mo#FAkIjGc~
z3&|8&a^Tk|4m0Y0{bHW1-~T(mI&cINS5%e2`|CG3o7T@$w;T@-?8f`Mi!^gUG@Z)1
zsp5Dc9|S_xuFt@agr?$V=iuY#<u+#KF*Y`4<}zjDW;W*HGiT=I<2T}GW9MKu;V^^9
z62&32bMo+UaB%Q)akE2qi6W6WH2z=w@+7AE|4r+Qh%ce)y~qp^U_Zrxze3jNI1oNz
zqcUu5!s<bA>Dd9FL^DmVgNv1WS2t}<j~PYL!w+`oS$tUmcoOW#gJgK&1OxEloGnCf
zuvx+1Waovp33ggAwfk|XzxDnZL_)&|3ZOxVG{?}RX(K~-{D^?z1j4X{BRKWY*4Ey5
z9V0zhb-5F<$T?U$SXH0fKr1_$uWUQ0op?LDXzh+w65Rn7@S%TGfH(&>qzynp_=fXS
z_q&~k>irl95}^1%wIN*9hxWo~5UA_D6VM54mfGKO>&o$O(YS1X+1XRX9QG|c<#Yq<
z`kr<?Gm4sD{Y}h?wSM!PvefWtTJx`ZvltOkZrpc<+;rb2{#Bu%g$*o3BX9dmCV`6p
z`^ELg=NeWz^u*WSZ?Dg0iLim$CO4xIW7KVNdSqXT9v<J|GcfdJSkRe>>!M;<(1|{v
z=OIIC8F3*hOo;ymEX0n16y|d{3nYMv26_Y?BF2RGZy63S!SXXVmy(hu`zo<0<YLSj
z!D5Pw@JVzCii}S1*EY2ve)ZsE*K6D1MI`v(X=PWq%&~)JfLX+S{WXcS{=s{ALYn)%
z%aW^1c*R~+`@P;Qr&!0Ob?LEB3Ks#@fl!|e9bpO%`Um>Ihg(D_5ZeuA2e*3%CIYH-
z1zLm%FE1CZ2|0TBF$+3E@FDb%pYJ?R)s^pY(ZQc<Ot0tyx6lki;qMGs|LtK?&Ajcs
zk#xgF_#*}R%!L2XcoqnlfgJLa=_>?aK>7HO+y4PU*AIo%{uBISfP)M&vHeE~31avJ
zFhRr0-_H+Tku<y7Rym#vIrdI4Ycc(O-ecdl@LBkB5-SkeJnazJ8UIiB!jRK}yY>R7
z?AzTLJLZ<rtJ`E-%z)#Ql&5S(v&O@pV`ke#0iF1!&nOlce@%_4?mtU}Q2sUy;3ttc
ze~*px=EW*sW#rAwuu};T0|kb_JokD4o~~XEmJxPJNY1O$o`67ls@_g~oZHKbN&St-
zo_g`p!HY5yw5lf{F{EuSO93s-sc(Z~j>3a*A^B8TMf(Ccn_#ayaJl3yc-`}-8`x7)
z1O87yQNC9d1}K=@W?sBh>~=B_zW?gF>#!u7H#&mpz<WDPAy7THs-~ooED|`6OO*6H
zsiL4CA&S`z-<|S!Ux4Vr7(u%vEMX!dinb{1;~sk1O$+H@BdW+5@d*X%3mPCqbU8YP
z2O-}ePH|^=ujZ-FNWYh58h&Z%LfJvokshK@`!ID=;EhIglgi*j*N2lxL04!zT|5v3
zWhopyFYsbaoDeAd9SsA!^b&XuztkU>Rib*3d0;>JW4dL`JT^<DpI*Gsnm~{ecNlD@
z4g(4XDd3@UH<*763zr$69L3U3ImXEPnYT5=U+2d4K+wi9h4o`Ryh!(@+7Fdy_MT>)
z=@@FM*P<#BJjx$P@qy6?+G)_)avo1g!h(3Md*Igxj38O@_&_b#xjld_Mg|<;j~Sn-
z>Lq3p7Ob4jt(!=?;cjt)PPtAhzy+I%j!q}UjTO$Fis*g&hp)jB7kMsikU)lain0*`
z$tgcVCQ|Y)k?4c_#sOAGs{^V|tg-ZhepURE3!={?93qoW$DmEf<n~G0pO2#p{O~jH
zgkt}$P{4%=`%40?K`p>A(P&Ns;xH#9B=|{BAcUTcr9R_J0`+++h${GzlK}QJC;oZ4
z$V&D%Uig$~nEJ;o#@MWVm0?R7^ja|&xyq#|^^jQp0{ovc<>~|lba!WLpm_ov>1ibw
zrmGHX*8ZOm;~EkxBI5W}vSyM;(iVHuA8Mw`Hb7HDaVEaLE*7wz7z4*>L_;Mc$%xh$
zyd`yA>cUH;Nr=ahX>Gfz>*hu1&HkG~72^CB$q=K{EtPCC(2APkM_hJ!)hM;C5IeXQ
zN~Js^43>gOAzR9uXnl6xcS>TB)A!*S9iji*g|X#=z5GiN28VSc>c?r5OAtee>d=}N
zavgpw1qm$6RX(6a?IlX>Q!;dPs1@TR-*Ub{!-_`%ZYX}>hP+3lN;_|Kg%P2l7T=2b
zWP{1KI3+B`mA>`ToX{@OC-2W`nne=HX*?hGMNzxt4X7<`uulJ68HC#VI*W<8F=;d_
zA%HQ^RnRAY%@FJn-%Y-SRhpP`(uFr@UtE_c?_vN=!vWZQ4U$PS`KDfW&t1$>sOIeN
zSyEqar0W-^T)ZkF^If{f!ps*7kraCc`<13WYf=oQNQJYPkz9~=i-y75b}lmlLgV3`
z;6y`}_y889^l`0otPp1o+Jx+;k`0X@#%hqz;wuMO7wE(9X&h57(VL}tkoI%T2;0@I
zKw-J}&jHUAWBm7}D{8?+%Urxvg4`W)6H5FfW^G3#aY8wlwiwIYFy$B`CC=Oa@oOqe
zL(+LafI0}ffN39pnf^gL_(?tUr3hCL@VIX#>E~?%I^YPGzK7Edw8stNT7SN~+U{M?
zbj}xg4c~<A8I80$&04{w(fw;oJdTByS-y)~3fzj#LGEHsDdCB@lj&f8c8OPEF6A2*
z*=e_q?{(c}<h%;ob{#m>J~sMP-Z#JQxS}Mu@GsE~;Qu+2Wa!k05x?6%er{3Xmkd5C
zwW2Fz>oooli7-;EWw>OBBuD>Z`#j_6e}F7}n^92M@%-rAudeJCv5s4(-jAYvUs2Q$
z156*iK!j<K^G-vAEc8W0o*^5*E*v^w7-KgOL5t6a1it6R4kQ_?5~Z|qO+P6ukmA!K
zO+%?p;`}=B)fVWB!`bSMKh-mui%EQCZ-oABh@UvjTIRZY>?Ta@JzpayN<aQ^qS+A!
z{_Vy%s*rtZDtp5Yo+7g<B3R;IckBCU3Xqe}(!3PE9gRKg#&3M!yexfQpH)DiUG#Z!
zrht9i`8*zyoP|34iP{IO&XPQC9gw!inIvoX<%ArSL?FC4#}6|KCeeA+%)&SoMl1r+
z>rYushwq~tk<R3#xQ2p-!X9+-ork&&FK)tWXKBHBW`uJ?{uuLVZ5Oyv^@rhwCqOA@
zXL@-gK~*g9UBdpW7u%7>d>!qO63%p1^;vOZ1OXipdplCOxt4f*&-LESSFNZ?g0N6z
zL-SEmp#XBUT8H=Vr>pIRIyOusE%ir>UmayJW&>($mq0f+J{j}TCpvY-Bcjp3EtM5b
zt*?mh&|}MHAe!M!k>b~8d*Tm4VnC&d|1M>B$b`Z30vX8Q`ROm;%_t`b<gxCBJO1?d
zem40q<@G}Jmn5z}0?6~UcEIVHQON`Id86~hwd4KuqIbUXoxo<Hs_*u;p<W<5;_=ao
zsB<gjx1sM|x%PJSp$^n$_>u_}y8D?=-n3iS4)MX}ipOeH_4<?737;k#FTfjiw$f~}
z(v-8+PuLx8Q{9FyM_-Yi*7q6Za$KFIPaf<oxpUBA^X~5ZxUOupu_|)9)D7QTq9WB&
z`Khw-qDkyn$VbR7u?;<1ylZ?&sVl*xE~oSECS_;UWujE^TqibksAlP=heFTj<Clum
zZ=tMja|WBYyq$<*Y?h8$dVrVja?kB8SCj2hAhT}M=B&Cw(9GMIRm&+_b+Fpj>&L*W
zY<SL{G~Db6=lLm<1eY-j4Z}|LJNgeh3Dtge>P$agPgllJ_uxe??K54*+dJbrEPF80
zGK`3HqvgUs#X><b7Nu-~9X6t|l=yz%uM&9BaA}Vv^$2dfy4(6Z9RLs4jljv-vTedm
zu<SVhMNPA+N8cJub!>}W-E-A2#@0U?V(7u*wKX*Xg!U~^8!!83i?t@wl{-QYlaz31
zyeGNi_7;ktxM?xyY9*^%@0_D{;n7I`cy!(9zih&zZD+S%^sRS3BUQVVgegTh-LH8J
zR8NSU@G`F5zizy%0{iqEe)qx;5Ya9oiC{yvkk4>RF58E=q#+9(ciLCU%~>H!OOxXM
z<6alPaNn=XK>>j00}ZS-|Ng;&qoKbDi?$@Jp65O-J5B`%w0hUcSZg<65+Tmj({pJU
zxx0!n<i&KPXNO<7>alp8TT|V3ewL6m8Oo(xb((4d25)o%7hTVeSJdx~X0h}fsQh^q
zHy>FJ@B?Nhe7VPcU5t@MZ$|4M9tK2zbhlnzSX<!{S!7Uu{rXjA(EA{$5YuyRl&L7_
zTZO1KbvR~>3>yA~Xk+!QK=#Ac#AVjXMPK*JNbkcR(l<2Ful=zMw)Xg|*JuCC>ZO8D
zF|9#9HGUH_!2D}kLZ&V?zlYLcTa?143-mLsAiu2(fK5uga@%sgSX)o++|Dqh_QjE*
z8dczF4G#B3nn|~bDRH!yT;x$2(976$Ym_Yf5_><KrunZz>YL?Ch8r=~^}gk8J+3D)
z-co4^C*tFSujIZPKl@!Zxbr$_7Q2}cs~0eq!3zTd)*t#84luLS)qHNv6BsfQ{W#S1
zUgK6{kF$zhpF4Xbs^Gh58yxDIDaWKWkgE@mikpr8T|htq5G8Lo9y^^Ni|i};hn9rW
zBO5YPd3^0f=jV~`x;eE*hlg#uMq)=<PcA_Y=?cA&9|VT(-exSN<xDi~cjp1~1U~!j
zCJXC;KAv?Jp-r)6JTb;=%MO@1dnmE9x`nD<bEgt<$m`Ujox*L4*pU%)jdzJY?9|^(
z0JQ4Z8^d?jz-w%6jl}9b6?NJ9eBPt%e+`RDtV0*4LNFov4&7w85^5s?5R-TxUU8(Q
zmIjK`8>{ybe<S3v4L5k-`~iOwpNXZ0PG13hYeh0$e1pN+TpSyK0g1TuktUK{kzTaH
z^XmB#q7r3BA=`(d)`)v<A1Eg(c=D`DM<+2_>}<Rk51?ZAZRo3Uv8*FBY25p=fOn3H
zq7h|q_MPvuf6RxU$DZ!kiB~$_(k1)vpltlIDqah}nRrJ-2n3xhR1ZA;Jz*q0^1A>8
zNe!N+Q!WL&pG9x1l$MAB=-k@x&J>lEX~8w{{wlI(+4}4-h1ljr+FvlfsR<~n<vcB`
z%f-H)x=d`w=ZHWD<Wj=ta3ecUNAq(dzn$S1|0lR!O~k$&Vo0C6Uq$bat~>9xExdZS
zA->YH^yKTAbB(%PB%IpGx$ug-Yyt0~J{O(1xCXxLVE%o}3jOvb=N7xa$8#-*c~O^>
z;-Y^vwKozuaS+n}tXblIQgMLvJMu+W+r?3osv$92Xc_O_4zu~#TEiv7sVCJBfDGR@
zp+ud7F-c*ADnvOQ{w}OLQi!}BDI5JeEKrTz3eW08p~I))ug-BoV5+aM4!|+N%^u!K
z>Mp->{+@lA;-C_-%+2j)uz|M04UV4Qm^Oo-^-K}B=YimQs66W{GZFA|_0NSVdd}=s
zZBIqMbHWpg(cPNmB<&6xU8&gBzI(DQH(+>zc<)^@PR;XN5o}q@e;HthK)FICirn{7
z{9rRdUL?^ccxegWcD02a=pr@mALHFn)0v3X4^%j4TxP&zjEbM!6G;U}WYhS34Q3+u
zS)aYTuyWXzpzq<FIQ?@_^}s0f_Mq%|QppR0(EG(};dI#&Pd*1pEenCqyLU>Z;PO^o
zw0F7DhBB`k(?)Ae>x*Sf$QJZ3ThEUBei8@Wz5QhqX*kruzb6Y@z#i*+VI*>FKXdbH
zWbEr(F*4JWZ~O9j^cSVAS`7sKJJ;zsSb^hM5dvelIG#bUV}_A6ZD`ia`USkx^Tt|8
zYb(Ekva-ooIyan47*X}vrzY#4Y=XjsUL6+fDnG6eL%7SqAJ47<e{|ZeZEX;!xZ_FF
zvo{04@mRl__)v-l82i70xNJ_>x^dg@FaDkFtp<Og^)i#BQkV6FgOL#w>FeQu<KBTi
z1J@4HD}POWC%wmN3QfzV#oU@1RbjyyIu^dRS=i5#y_2gg8U71lhlnf_7Z;bLM)X4L
z`6`_tT++W3wo46g@75!%TYCfceaVUgTd6Uu{pp(0Iug9VRS4r7LA(1Is@?66o{N{1
z_h88Pdo^31bJ>@NA=0hdVv@d@3E>#Km1d)bb$!`vP^@6g@j?IlQI1}On{>xV8*SoP
zZbpMZO7qyL?zf3OfW%;>&TPbSD}?mdQ%pI75bppdWkBK-(ex9c&NY>CM(&ZO@ZsGT
z+o5qH_fRLGyyZ-Us2<ek#LAEKFR)eqeN0QU>Ucw`?v=#-j^5qu_k0s?@cX-H5ZSMC
z0~hF`KpZmYz~9avH4F<I(ib0lNJb}^O*LlLd_2C?_jeuKZMU)Ng~`9)IKY6w0@jo)
z&-L#i&7H5Lj_<E%n^l4rzt7iv<Z#yE-!Agg?mq+prgE9LWht5jQKX_T>Z4}{j%DYy
zjNm%d%UHi#&czxhnDyuN8xTmh*}jk2pdHHLHO8gZW<ameZJ94cjlmiR?k6vGu7LZW
zy%x&AA^lX<z_`U$bB{t3J^x3utK?}X#}&I~qqSqVufp{N!!q!GXEw@x&2L@aY9j{U
zolr!8=QLJBJ|WY^>*(Sfc{L%?t6I_CD^_6=2fq_t5NITYbzsRNC!~Htq<s26Ik)y|
zFvVgWcs((|?S4D==+->?dI7w{JDqI2bk5+X++xwvZn3srcANBuqVVlR*VOb!&}Ikd
zcDW0$JI{NK_w|0lPZY>OI)F?&tyK0#oB~y4oy=wDde>%gY1g(__Lk>Z_iN9>tFCir
zeC{(>U)#O?Djl`@zY~w|lv?EU#G&C}oo*OJo>V<k?C<Y;A5;*fnQ4$)KU6gv1Uz4K
zi@rVXLX`U}oAnJ`7f1U^BXyV<cYIzvf_q8INMvtL8+JW3-$s-u1^c+Wn_ZDz9RNM%
z)LNGTC84Kxl3tvgPNZ&+E7CbRjK3ipuV>1e`WHfI2JcUHp4UUgHUA>as8kY*%sGLy
zoZ7ow%KUxTL6GOm6;=D?f66w8Re!&TtZZ-I<0FzgH&Vl&*fJPx_T?h7(t1_6W`E02
zr07c-ynfqjtGDs#r@=O+!`7Je0Zo_+C569@*g_{qRV4U~-Ek5L{uD-PG3ET$VAD+d
zmEY397_9lKs@fsQI7D6242tP$cUfXw^x|K!7ztOx_FhiPV~eMqo(c0tsKl>m%pH!c
zXTwS)$YK=A(YHwXy=)sd*iVyEDCbI?B!k>LuacYZzBCJhKe&&vy%mbk2mBJ2LXJzW
zH)vNlP%NNNjYGPkP?rU35g3cit?ib>u@rytv61e3Ui_<i+wadp=M{PP)RJAC*d@w3
z9McF?JGJ`vtuj(o^TTBu_`aDb`6g~ixRX<v)T;~+$sws!^kjMv7Y0iqk4@LF*qyha
zCyGwyy-M8;9mD=vRSUA41_<AIj(E-HNo?A%7^(h>jgC!--Jtv2UGyXS_(N4Ts$Qy6
zZwNEVXkjXjCATh7#Lgv$Ry55UsymsFFjp+s>|BqCh)|n``K=c~q!JB^xf-<Maca4S
zz9%0N{;54vjauzTWh`raY8itHWF*qiNL>#x6AMs0;V~L3Yn&gi00h*Qss2tjeuG)6
zEEe&=3TxfUtN^IhI@d{D+?BvZRLZa|%yyJXf2xI)v*5v5fP|`n5J&+Q4hJIq@$i`X
zG`>0!T0YA_&bzu*@xhgS#Tv_b4dbN7{cqcF({1)^`&CqD_pjWoTqIpGHL5WBAz`pV
z8M~M&iLY?d+8!z~&@9eiHYhEnoYFAO171eWw{_p@SBX>*caIltuuMT(TDr=Lj93o|
z{M||=9ePYDpG|!1`?kB<4xnjGko?$FXWUjKw1@xZd8!(7&)_mu;2}upKxgLSG`kgn
zB*@l2{6#Z<dwrQ~Ab}@g-}KD*nrcY>SWt37De-~_m2kNj7!(Nz3<YODZqxcQP=f0;
z(4Hi(E80<$O*cn1++^=x;rA~!X5CEQHhsTh*92?q<43hc(@g7WCNS;9;`dFAQP0gV
z2)dB`zHuvclCghUogQbmpF*@q$dId!Co<K>L*EXJHyf|$I}JaHJJiGDtv0^L(t9mj
zoz~|xv48svR3iSN7GAtQbGClv-#_~{p}o{<di$EZUw39Em!Q!h@6wD_waosp4g&on
z7hmP-@JLerjzRD|s7gDVrp%aPMUx?(rkYGlS24Hlz0rk5ZY`gDF0FFRp(&-af`Gn}
zO=LIjJUi|C6ry(8sXX0_`O?8?tKdb@IpVr)UaQUnKm!-CSeCwS%W+`w7QY3{p?T+?
zm7-<RAW=q`q;oAZ-g+PK372L@#37#=*NZ)A(Au;cyT^fYCZCVDiZkN8mxRkslmkbb
z@?7uTSI_E4EtMQDL%XDVQ?Fg99|^8F)8dz9_jhOY#=A}sk5i8(`SUbFw`R33uB#Kd
zKQ*EmFs#DvwCzZhQV;GIG2vzKNvlL<WYL$pb}ww{Z2dE8bI&}MA+RMk)CJq);0{Ws
z6}#n;Ij>te(`1f6ui9P8Q~UC*onvA|B<)Nkzb`sEugq%?vYfI#&mm{Z`}5K?``NK4
zDe|MmgQDbCbKjS{2$@@J6qwg|;oG0!!7+0_pf=F8x#zR0l`&_<LTgH==^jlDPPWo|
zu~I=xM$FNJmxjqN!lnGZ#$2qbItUAm;7@Mby8F0GHx}B|)lxr(>!GEHQDQyBrFu;Z
zed@xYGTwFMBx1V7b!7OVQbGS-a1K`5n>*{$85{4gO1b|B+$F@wXky1sN}o1Y4cdSC
zKY#g5{>C>9YhZ}liP>j+^bck6%*c5=`?sVua6)hVvbEBiEYla7-#ZQ3*Pf?Dv_u$<
z%I-+_fF%#*nV<9YocuMSud<wLrGS9h^C9!N?XTU$iS<2YvYPnmrR3r9Bsvma6a~Lf
z=e9a`{`K=30x#i^PU6O>zLDrg#uAxyz-FxTX3)i|6|q|4V0)e)OJ(0~D3gY(@N~JO
z<fesPx9T!LPG;QwnAMwWxaldIm{BycJ-+)h@o^Yj?cG~^r>~M1nfJ`>y#3kT>13QZ
zztW&7k9ffck?`w82^RZ{l=#ipYiMc__FgFI>^b+KRXhHz;lXTDn;hSV%5y6i04P3X
zD40=5noyq`3){QqpaKh3anqc-KH@y{)Gcgz7nmN=K=3c7#)aDlgYOZ%;gwp{>JIvs
zX^H*I&%+5JhyH51?PNaW-xQCmPC-%PF5`B9mzZEmFDt8ij=pV6z~VTqp=MrMoWUQ2
z@_1Zl>H)=BcR618GxrZ>#%B-!wR>*E4mVm9-H*EUOmBxvtSs70!rfeM=_$0Hj#4*@
z5X!76%W>vYSCLC?`xP(e*0d3K&H)>-uRXCH^nN7u5-p+sPP(~1+j!)^HU%!0Ncn9-
zeTIzI6>pJlVzM0nzd{@j*_MB0@ko>|`PjBf(x^x;ESOgA+2qB0cyJo{RKi*{5Plj(
z{lddDg-bbv66oYk+phU14xvPKj7O_A!bQ`gy-7YEyExKX5dYrP!95q1+Q&A>2dSJ|
ziBFDu`E(pnyU#wy^&!Tk%ZI|-qqNe0$c`sDK#*6cith|eppoa-5P;6VW@}iSU%5(F
z=2EOtg44ixR0_AlpS%kQpS7_)Uh4XD_OVBFr4HMhikr*M1h^W1T(ZlhD=$fD>1EQ~
zDC7CayA_2y+J=>3_^IenDx{g%tjl-X&*eWqv}upS*zk9_xriBy0bK?N6UnZvkt}1>
zT6#(1$t}H{1G%$|mdkG$FDR2CdH*O`_uQWL=EA4gockd}Z8_i$F?gdz%wJOFEY4Q&
z`x8^A389`YrZ9OubTrACrn`?S;!qun=+1IDCt>Spc$R@?J2KAta`G|zS!2$>PvNy_
z<}yQHpv>D}TE%|j&Q4QN-l2ZBcI|MA2u5nLAD4{oOIbNmjIi*T$FwZ($8x%$dNmtG
z+D!?K2V4K=t!*H<+|-+|#{mZEIrkB{yHH*_hI;Bbby>&M$0kfd`P)vieyKo7ZvPUF
z=zRH&z;wcno2bS^$HU{+ZZPA${x5ug_4R-JIauVV+k`bO^LDE!I+t1>O{lyy6fV!*
zeW-EHIZP)s2kAK9{8YErR@8=iq3b*|9W_6d^Yl7s$^+7xWZtA|y8P{$^%~yw5R&*h
z)EW8JH3Ct!UH&<ZM2-~;$ik6eiTEs!=0k^FX;=<c6~odBQaAUbt%|*un#Jz8_E=OQ
z?|~&*?l6hK2DaNbYMKeLu$DiVg-lNsS?d~Y&BZ;qcJjpco>60n+99W1y$;d)-#f{G
zKzHd&TVNob!Z`y;K{aBhBe`G0knowdwXka-`(f6=w4ej+=v+C3x6!41j_8s64^?x1
zlajl|gB>Wu2&T?uM~g!&O(>_qgjw;}Ik2~BBp-?;dDqSYq6!ZFpr9?puEyi5esr!I
zLR;*oMB?4_O{s;Ne1w>jqj_qlM(Uxml@b*M4UFUcofT+hjub5PAa)j%L0x%FX7z7L
z@^Otd`=a4N7L$O&q13aGbl#=usol8X<cnJxk{^`r*y%W3IQX6RrQZab;;4dJou^b1
zW?bT5-2bv?iY89D<|=4+oarLU#DSP|HOZTFesosB-H0n)oLDQ(MLCv2qb*P;0Rka^
z2V^D0G+L2|&Mj}h?iP&Lo0j5B)0(^|clUd07ButlcsnW{Wtl(-lXU0)$bN5Fn>~L~
z!uJtrIO<P1mu-zHV(_Kt7;;&*(MdO%3Y{g0Uz<8)-=Lf@xv5KPJO8#KsO(*g8`7_(
zf^x7@Ad{VZ>?OFP*m@z~7MtIL6~{uz4Y*5Xs_OHu5#xl#nzEvGx3=x@*hFJIP<i;P
zMKvwAfoVI}-1)ax-MFXBk>|X-T;Q~S)>1`NuMIs2)^FIl;jAlIlUwsum9CKRm-?Ou
z=-Qfkgl*(a8A{U(;r+h<1^@emsxeymoC)WP_lmpM+|c2|#&_1*kj-_%RQ=Hx8Q@+b
zq*}{@g+1d;D$JyK9gll+?6j@-x6(uwN@8j@5>k4oRxb89ReYn|?LK{}2%>#yVyi5>
z+j)eLN>^y`sM|13N`f`b+JO4j*y>%sRkf59ndHhHDlM&^)T?=OzMaHv4Ie!|W+r1I
zBv+wb1%fR0cceTg;W%g2{$QoW9q`H<2N$oo*4{0ooS(y$rX%Ip>A@Lbt~nkvbJG%O
z*W`2d>w0s3TJnRfyyt%<8$1&$41Oxi(CJr}wKJ*9K+P(XWw)Dx479-e;8&KT%|gx<
zH6I!*d|xuXbkkXtX!ZO!2rp{<qQ6qr#Z&cXav_hgWo6!2-Ud<NeJ{Hd1*DN|3F%9j
z<A^jN#!uV9<xfjxiKNnP+S*%{5B!fqcK7<BWo7~?RJFS=iQ@a=Q?;*IZ+bG9s+ciN
zpRjE*@X0;m8|K{2<XziME2|S{n+DfY3h@3lOlB85IjUTh2bI8byj69oB5j2U-}Lfm
zmH3oomxrg9c43Nr;0tWpfu%0Ikx@4$B+3LAomAbG{?Zzh7Wy}6aIXP*ANR@EKxHZJ
zYV#Cj5&BT!RaF7Bnxm}Q`17NB^%q-xhK|Pk=zjTJ#gs@LY*R3QmY*GDY3srC-b;}_
zi<u|!7<SMq0V{nr9AVLU9c>52)gPksQgZq#7kQQ2w31}$S%L5w&^*d^8<s2&5=SAL
z5%EYYjdfYlb?k|eH!m);lR2(%<?-xk(%PkPq50HPCAev8{IONN?3nB`)mU%hYze^!
zWgYK!YB3<ec=2SdP&&PXs8*q^cnBPgbkS{#jbD{$uGGSlX;@S+PFX+ly;)cHATz6c
zoIsjTC01RqM##Sw@EbprXZ9eKWjDJ{q*>p`2S;-5sC4DIl8)(7FmeWt_J2zDQ;Mky
zj^3*ncAq^TvgPY>21DdESh;G~HY|;lK3FB?DpTF3V5?WLM$0p7JOy^QyU5<FW;bSO
z4aFlVV>~kZ)I^Z7Xi^I~_264Gxkz%v{;MV^UHX5_S7B-ca@RcQx8lOA9$k$lDbMkl
z{-@7n^tB=dK4lG>a&BB}ff8fUR_=~#qdCm#CVoB*J1P9g^7oaocFxUb??{vK5Au;|
z!4mdLlFcY*3xq1B?JHpZl-<%i*(H5vJ)(VupA#?o$)h`74OV%kED1Z0YMIf;P$DdR
zhulL`%>{VC!mZT>)9iM_cH(*eZ2gxCy}bFhB6h+7!*<E}64Ot*5ft{csc5n88?Kre
zyGv`K=ZYg8v*Gr98{RtfMV);pStU+QuDmvLX7m&3zk?jBxm5q25Xc%=HYSZ*$<dFO
z9DW-*9mro}O{ZMIl?w5}OF^G{{z_luW3?V)%UeDJfCo{<^@%iv$qU(upd&G>y}0ve
zmq8!T$hMmFv1@hV7kBr;`uXwJYORlY2><RzBD8%CtY&sd;O^oomL>h~hq?1)+n(L7
zHz5qmjMBD}cb-F-gs8;K6ExLQ&Y_yu^`B@1MdCXQWZCzEZBGVQ(=;p&;NrGa#2ZFp
zR5%3zaI|Dbg13t-Ih-BedQGtE>9=A6IJJQNh-opPWJXDCbUSXpDY%gq(QTfZ<&|q1
zT)jwd;C2KatW1QCkG$9B45NlDF6Q>xay4xhez~NeU$@KCnnX))&cLouHEbEu$-K~O
zSxsLsT27W_=46Q9?T=MOIx|EUHZZr;BAW)j^~4JO<<jzMSpT+r&hWN2er9+*lkRPp
zqP+pLo~73uCGe!a(fY?TZ<V@OO_N|p+q|lS0;ikZ@H0JJr5npu@6$mP<n;8mLK(b^
zMdO_!%Pumggq6wHHU3?~d0~FQw)5S)UqX#x`Pf|kqd7GFFm;DHG2um&d|NxFQ9muf
z|81}P6Ux+cB6cqht!*<2@;iO4dznqy0n>2Vq`5HsTtBrwA~g%C<j3uj-P)kbNmz*_
zt?AsBF2QwQi0|se%`WxRRwA}~$}tOLC;iq^YobQ1b==fVUq`}rStHxO#@g!_4kWVl
z;NqGle)fhBKk*d=6jqNad&i|8D)fZ`wwg7gwUxcF_M6JcMv-iV1HEEhVXO!>ZS{RY
zwn(j1C&5Ko-q8qVQq1hn46gGS7>Uz()^*3!w^5h=Jr-_9x<aINF<sE@h@H@42j3f5
zlR7tK*=Ml=i|0H<&1IJ@t<CB4R=*cp?@xr^QuYk&Me}2W(tEv1=g@UHzut!dmzumq
z4-15w6*$_)`4Ii6NbFw%E{-|wUhfd&(KK<a0`D1OJH2CEe87ffp>AQ!!a(BT@{aD5
zP3~h~E<rVyk<7<)#H}dd6E35L%AiBUtq)U-D8kmO_6^Hs%2>^@vg|x=Pa3Yh8k^-$
zdVca(6hRal{1y&I)&5HAm9c`rI413@g*?KB<i{={-}&lCELm3^6sy^xc#v^qXU>-U
zmn^6LSy8JTi1GEEjyfxe=HGt}B5SV4+41Wv7y53IInuGXOQH!vEn6mcmL5WO&j$Qt
z8(QD_BCc2}@4SvM4QZl-k0XdyY>d+Nq2}YwT}yiqSw1@k!6<AG79v03eJ7K~hfr2}
zi-O&o#VdH>&!j5tblhbov+{XmlkSGhcv3$fTe3<<a=~vEjIG|c{Rjbr#xBi`1mnmL
z3~P`I1JjA8jn?VIX3=pC!)o<XyYF7I^yD4Wu!;;6zS!WXyO~(!2mjy+J$#f982Mc?
z@BKVYPcj005!;fRIXySvwF(>J7wxXsqMWSNIqI>&<CRsKl4fDLKu+5r?FknOMwr0Z
z;_j#RZQiOE5XjEhKR-dtlt$!59We724-5ZrL+0(>7U(*$y!R>}Sz7k#UOvV`n)Q~e
zwY0u(*si+Rr!D@1b07UXelV??D$(}=VOXz%G%c0L$X*LbQ~wf>^(lk0IB+y05y9zM
zj3EGTS><4dfkH~tQP)nRc6j~00PkGl1NbZ<DhEX{`>Y@j4_uW^OlRL3Y!Rv!fugK3
zS+L`7B4jPt|LC)&NG>Ielv7A4VTz3=OG}eh4Wm9rQ6IqDPGahMljym#RI_IHEuRTK
zGctVRLTWKWw+;a6gskg6_ccB27X4(ml8V8mSKWYk4W2QDa3TGc4kis*4gVZ87`gy!
z9z!0s@r|>ta7B+DRj!dU)7KdH;L(_F>;PlRD$#_9m;&;BEUi$WbhC8Zn%uCxY_FtV
z8ZRfzDCa)vOQx#7CRz#w5^??{HL`}X_hh`RGisC^rUeloQF$by8n!rTLVA`<3#X<U
zd1jfCNe~+KLn*eg+~H;Sxuu=B&(z@)2W+$27OEIJCFlz`yx6Xuv{rh`3M<1*9EKFI
zk1_RJT2sH1{_LHlk=nY>h!af5wSa)ooabVLxpoBGP?4#^g2sofRv^Bje?x|;Hpmqb
zAZ~OazxD-S@p;St%d<=c>$qs@^xl;fe=Z&)lMoleJp2=v!Az4n9Cysk`I!7(JZp6L
zgCtUc#zR*6y#rws9vIB(#9w~+EQ9PAUq%W$p?jyw^waW>e9UH2wZM`L$LAe6zqy{f
uz+R+T+IAjVybcXU^?v^Z6~FiQ#S*D3w!pDd5D0__l9g1FsQO|U`2PWvAJxJD


From 648d6b7e4e4d0143016659b6e3b9a2936564abaf Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Sun, 24 Sep 2023 19:28:24 +0200
Subject: [PATCH 31/99] Spectral flux onset detection

---
 plugins/SlicerT/SlicerT.cpp | 74 ++++++++++++++++++++++++-------------
 1 file changed, 48 insertions(+), 26 deletions(-)

diff --git a/plugins/SlicerT/SlicerT.cpp b/plugins/SlicerT/SlicerT.cpp
index d8f5fdd8fe7..36bab44818e 100644
--- a/plugins/SlicerT/SlicerT.cpp
+++ b/plugins/SlicerT/SlicerT.cpp
@@ -22,7 +22,8 @@
  *
  */
 
-// TODO: better onset detection + bpm cleanup
+// TODO: fix some PV bugs
+// TODO: onset detection find valleys
 // TODO: switch to arrayVector (maybe)
 // TODO: cleaunp UI classes
 // TODO: add text when no sample loaded
@@ -269,7 +270,7 @@ void PhaseVocoder::generateWindow(int windowNum, bool useCache)
 
 SlicerT::SlicerT(InstrumentTrack * instrumentTrack) :
 	Instrument( instrumentTrack, &slicert_plugin_descriptor ),
-	m_noteThreshold(0.6f, 0.0f, 2.0f, 0.01f, this, tr( "Note threshold" ) ),
+	m_noteThreshold(0.3f, 0.0f, 2.0f, 0.01f, this, tr( "Note threshold" ) ),
 	m_fadeOutFrames(400.0f, 0.0f, 8192.0f, 1.0f, this, tr("FadeOut")),
 	m_originalBPM(1, 1, 999, this, tr("Original bpm")),
 	m_originalSample(),
@@ -340,41 +341,58 @@ void SlicerT::playNote( NotePlayHandle * handle, sampleFrame * workingBuffer )
 	}
 }
 
-
+// uses the spectral flux to determine the change in magnitude
+// resources:
+// http://www.iro.umontreal.ca/~pift6080/H09/documents/papers/bello_onset_tutorial.pdf
 void SlicerT::findSlices()
 {
 	if (m_originalSample.frames() < 2048) { return; }
 	m_slicePoints = {};
+	const int windowSize = 1024;
+	const int minDist = 2048;
 
-	const int window = 1024;
-	int minWindowsPassed = 1;
-	int peakIndex = 0;
+	std::vector<float> leftChannel(m_originalSample.frames(), 0);
 
-	float lastPeak = 0;
-	float currentPeak = 0;
+	for (int i = 0;i<m_originalSample.frames();i++) {
+		leftChannel[i] = m_originalSample.data()[i][0];
+	}
 
-	for (int i = 0; i<m_originalSample.frames();i+=1)
-	{
-		float sampleValue = abs(m_originalSample.data()[i][0]) + abs(m_originalSample.data()[i][1]) / 2;
+	std::vector<float> prevMags(windowSize, 0);
+	std::vector<float> fftIn(windowSize, 0);
+	fftwf_complex fftOut[windowSize];
 
-		if (sampleValue > currentPeak)
-		{
-			currentPeak = sampleValue;
-			peakIndex = i;
+	fftwf_plan fftPlan = fftwf_plan_dft_r2c_1d(windowSize, fftIn.data(), fftOut, FFTW_MEASURE);
+
+	int lastPoint = -minDist - 1;
+	float spectralFlux = 0;
+	float prevFlux = 0;
+	float real, imag, magnitude, diff;
+
+	for (int i = 0;i<leftChannel.size()-windowSize;i+=windowSize) {
+		memcpy(fftIn.data(), leftChannel.data() + i, windowSize*sizeof(float));
+		fftwf_execute(fftPlan);
+
+		for (int j = 0;j<windowSize/2;j++) { // only use niquistic frequencies
+			real = fftOut[j][0];
+			imag = fftOut[j][1];
+			magnitude = sqrt(real*real + imag*imag);
+
+			diff = sqrt(pow(magnitude - prevMags[j], 2));
+			spectralFlux += diff;
+
+			prevMags[j] = magnitude;
 		}
 
-		if (i%window==0)
-		{
-			if (abs(currentPeak / lastPeak) > 1+m_noteThreshold.value() && minWindowsPassed <= 0)
-			{
-				m_slicePoints.push_back(std::max(0, peakIndex-window/2)); // slight offset
-				minWindowsPassed = 2; // wait at least one window for a new note
-			}
-			lastPeak = currentPeak;
-			currentPeak = 0;
-			minWindowsPassed--;
+		if (spectralFlux / prevFlux > 1.0f+m_noteThreshold.value() && i - lastPoint > minDist) {
+			m_slicePoints.push_back(i);
+			lastPoint = i;
 		}
+
+		prevFlux = spectralFlux;
+		spectralFlux = 0;
+
 	}
+
 	m_slicePoints.push_back(m_originalSample.frames());
 
 	emit dataChanged();
@@ -434,9 +452,11 @@ void SlicerT::writeToMidi(std::vector<Note> * outClip)
 	float barsInSample = beats / Engine::getSong()->getTimeSigModel().getDenominator();
 	float totalTicks = ticksPerBar * barsInSample;
 
+	float lastEnd = 0;
+
 	for (int i = 0;i<m_slicePoints.size()-1;i++)
 	{
-		float sliceStart = (float)m_slicePoints[i] / m_originalSample.frames() * totalTicks;
+		float sliceStart = lastEnd;
 		float sliceEnd = (float)m_slicePoints[i + 1] / m_originalSample.frames() * totalTicks;
 
 		Note sliceNote = Note();
@@ -444,6 +464,8 @@ void SlicerT::writeToMidi(std::vector<Note> * outClip)
 		sliceNote.setPos(sliceStart);
 		sliceNote.setLength(sliceEnd - sliceStart);
 		outClip->push_back(sliceNote);
+
+		lastEnd = sliceEnd;
 	}
 }
 

From 4d183f2aa698209d54d85b3c07ec3db3e1dee291 Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Fri, 29 Sep 2023 16:32:46 +0200
Subject: [PATCH 32/99] build + PV fixes

---
 plugins/SlicerT/CMakeLists.txt |  4 +++-
 plugins/SlicerT/SlicerT.cpp    | 15 +++++++--------
 plugins/SlicerT/WaveForm.cpp   |  3 ++-
 plugins/SlicerT/WaveForm.h     |  7 +++----
 4 files changed, 15 insertions(+), 14 deletions(-)

diff --git a/plugins/SlicerT/CMakeLists.txt b/plugins/SlicerT/CMakeLists.txt
index b93021e98f9..365a6042537 100644
--- a/plugins/SlicerT/CMakeLists.txt
+++ b/plugins/SlicerT/CMakeLists.txt
@@ -1,5 +1,7 @@
 INCLUDE(BuildPlugin)
 
-BUILD_PLUGIN(slicert SlicerT.cpp SlicerT.h SlicerTUI.cpp SlicerTUI.h WaveForm.cpp WaveForm.h MOCFILES SlicerT.h SlicerTUI.h WaveForm.h EMBEDDED_RESOURCES "${CMAKE_CURRENT_SOURCE_DIR}/*.png")
+INCLUDE_DIRECTORIES(${FFTW3F_INCLUDE_DIRS})
 
+LINK_LIBRARIES(${FFTW3F_LIBRARIES})
 
+BUILD_PLUGIN(slicert SlicerT.cpp SlicerT.h SlicerTUI.cpp SlicerTUI.h WaveForm.cpp WaveForm.h MOCFILES SlicerT.h SlicerTUI.h WaveForm.h EMBEDDED_RESOURCES "${CMAKE_CURRENT_SOURCE_DIR}/*.png")
\ No newline at end of file
diff --git a/plugins/SlicerT/SlicerT.cpp b/plugins/SlicerT/SlicerT.cpp
index 36bab44818e..9cb87fa4043 100644
--- a/plugins/SlicerT/SlicerT.cpp
+++ b/plugins/SlicerT/SlicerT.cpp
@@ -23,6 +23,8 @@
  */
 
 // TODO: fix some PV bugs
+// make fft size and windowsize seperate, pad window to fit into fft with 0
+// this should produce better quality hopefully
 // TODO: onset detection find valleys
 // TODO: switch to arrayVector (maybe)
 // TODO: cleaunp UI classes
@@ -178,7 +180,7 @@ void PhaseVocoder::generateWindow(int windowNum, bool useCache)
 		fftwf_execute(fftPlan);
 
 		// analysis step
-		for (int j = 0; j < windowSize; j++)
+		for (int j = 0; j < windowSize/2; j++) // only process nyquistic frequency
 		{
 			real = FFTSpectrum[j][0];
 			imag = FFTSpectrum[j][1];
@@ -192,11 +194,8 @@ void PhaseVocoder::generateWindow(int windowNum, bool useCache)
 
 			freq -= (float)j*expectedPhaseIn; // subtract expected phase
 
-			// some black magic to get into +/- PI interval, revise later pls
-			long qpd = freq/M_PI;
-			if (qpd >= 0) qpd += qpd&1;
-			else qpd -= qpd&1;
-			freq -= M_PI*(float)qpd;
+			// this puts freq in 0-2pi
+			freq = fmod(freq + M_PI, -2.0f * M_PI) + M_PI;
 
 			freq = (float)overSampling*freq/(2.*M_PI); // idk
 
@@ -216,7 +215,7 @@ void PhaseVocoder::generateWindow(int windowNum, bool useCache)
 
 
 	// synthesis, all the operations are the reverse of the analysis
-	for (int j = 0; j < windowSize; j++)
+	for (int j = 0; j < windowSize/2; j++)
 	{
 		magnitude = allMagnitudes[j];
 		freq = allFrequencies[j];
@@ -225,7 +224,7 @@ void PhaseVocoder::generateWindow(int windowNum, bool useCache)
 
 		deltaPhase /= freqPerBin;
 
-		deltaPhase = 2.*M_PI*deltaPhase/overSampling;;
+		deltaPhase = 2.*M_PI*deltaPhase/overSampling;
 
 		deltaPhase += (float)j*expectedPhaseOut;
 
diff --git a/plugins/SlicerT/WaveForm.cpp b/plugins/SlicerT/WaveForm.cpp
index d59acc8cfdf..e6ac38b4bc5 100644
--- a/plugins/SlicerT/WaveForm.cpp
+++ b/plugins/SlicerT/WaveForm.cpp
@@ -49,9 +49,10 @@ WaveForm::WaveForm(int w, int h, SlicerT  * instrument, QWidget * parent) :
     m_sliceEditor(QPixmap(w, m_editorHeight)),
 
     // references to instrument vars
-    m_slicerTParent(instrument),
     m_currentSample(instrument->m_originalSample),
+    m_slicerTParent(instrument),
     m_slicePoints(instrument->m_slicePoints)
+
     {
         setFixedSize(m_width, m_height);
         setMouseTracking( true );
diff --git a/plugins/SlicerT/WaveForm.h b/plugins/SlicerT/WaveForm.h
index cf78042ad20..461bc99601a 100644
--- a/plugins/SlicerT/WaveForm.h
+++ b/plugins/SlicerT/WaveForm.h
@@ -115,6 +115,9 @@ class WaveForm : public QWidget {
 
         SampleBuffer & m_currentSample;
 
+        SlicerT * m_slicerTParent;
+        std::vector<int> & m_slicePoints;
+
         void drawEditor();
         void drawSeekerWaveform();
         void drawSeeker();
@@ -124,10 +127,6 @@ class WaveForm : public QWidget {
 
     public:
         WaveForm(int w, int h, SlicerT * instrument, QWidget * parent);
-
-    private:
-        SlicerT * m_slicerTParent;
-        std::vector<int> & m_slicePoints;
 };
 } // namespace gui
 } // namespace lmms

From 35bb114505888decfb5b5b65ac98c962853a34fd Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Fri, 29 Sep 2023 17:24:24 +0200
Subject: [PATCH 33/99] clang-format formatting

---
 plugins/SlicerT/SlicerT.cpp   | 245 +++++++++---------
 plugins/SlicerT/SlicerT.h     | 252 +++++++++---------
 plugins/SlicerT/SlicerTUI.cpp | 131 ++++------
 plugins/SlicerT/SlicerTUI.h   |  52 ++--
 plugins/SlicerT/WaveForm.cpp  | 463 +++++++++++++++++-----------------
 plugins/SlicerT/WaveForm.h    | 176 +++++++------
 6 files changed, 642 insertions(+), 677 deletions(-)

diff --git a/plugins/SlicerT/SlicerT.cpp b/plugins/SlicerT/SlicerT.cpp
index 9cb87fa4043..891edb55550 100644
--- a/plugins/SlicerT/SlicerT.cpp
+++ b/plugins/SlicerT/SlicerT.cpp
@@ -30,61 +30,55 @@
 // TODO: cleaunp UI classes
 // TODO: add text when no sample loaded
 // TODO: better buttons
-// TODO: code cleaunp, style and test
 
 #include "SlicerT.h"
 
-#include <fftw3.h>
 #include <QDomElement>
+#include <fftw3.h>
 
 #include "Engine.h"
-#include "Song.h"
 #include "InstrumentTrack.h"
-
 #include "PathUtil.h"
+#include "Song.h"
 #include "embed.h"
 #include "plugin_export.h"
 
+namespace lmms {
 
-namespace lmms
-{
-
-extern "C"
-{
-Plugin::Descriptor PLUGIN_EXPORT slicert_plugin_descriptor =
-{
-	LMMS_STRINGIFY( PLUGIN_NAME ),
+extern "C" {
+Plugin::Descriptor PLUGIN_EXPORT slicert_plugin_descriptor = {
+	LMMS_STRINGIFY(PLUGIN_NAME),
 	"SlicerT",
-	QT_TRANSLATE_NOOP( "PluginBrowser",
-				"Basic Slicer" ),
+	QT_TRANSLATE_NOOP("PluginBrowser", "Basic Slicer"),
 	"Daniel Kauss Serna <daniel.kauss.serna/at/gmail.com>",
 	0x0100,
 	Plugin::Type::Instrument,
-	new PluginPixmapLoader( "icon" ),
+	new PluginPixmapLoader("icon"),
 	nullptr,
 	nullptr,
-} ;
+};
 } // end extern
 
-
-PhaseVocoder::PhaseVocoder() :
-	FFTInput(windowSize, 0),
-	IFFTReconstruction(windowSize, 0),
-	allMagnitudes(windowSize, 0),
-	allFrequencies(windowSize, 0),
-	processedFreq(windowSize, 0),
-	processedMagn(windowSize, 0)
+PhaseVocoder::PhaseVocoder()
+	: FFTInput(windowSize, 0)
+	, IFFTReconstruction(windowSize, 0)
+	, allMagnitudes(windowSize, 0)
+	, allFrequencies(windowSize, 0)
+	, processedFreq(windowSize, 0)
+	, processedMagn(windowSize, 0)
 {
 	fftPlan = fftwf_plan_dft_r2c_1d(windowSize, FFTInput.data(), FFTSpectrum, FFTW_MEASURE);
 	ifftPlan = fftwf_plan_dft_c2r_1d(windowSize, FFTSpectrum, IFFTReconstruction.data(), FFTW_MEASURE);
 }
 
-PhaseVocoder::~PhaseVocoder() {
+PhaseVocoder::~PhaseVocoder()
+{
 	fftwf_destroy_plan(fftPlan);
 	fftwf_destroy_plan(ifftPlan);
 }
 
-void PhaseVocoder::loadData(std::vector<float> originalData, int sampleRate, float newRatio) {
+void PhaseVocoder::loadData(std::vector<float> originalData, int sampleRate, float newRatio)
+{
 	originalBuffer = originalData;
 	originalSampleRate = sampleRate;
 	m_scaleRatio = -1; // force update, kinda hacky
@@ -95,13 +89,15 @@ void PhaseVocoder::loadData(std::vector<float> originalData, int sampleRate, flo
 
 	// set buffer sizes
 	m_processedWindows.resize(numWindows, false);
-	lastPhase.resize(numWindows*windowSize, 0);
-	sumPhase.resize(numWindows*windowSize, 0);
-	freqCache.resize(numWindows*windowSize, 0);
-	magCache.resize(numWindows*windowSize, 0);
+	lastPhase.resize(numWindows * windowSize, 0);
+	sumPhase.resize(numWindows * windowSize, 0);
+	freqCache.resize(numWindows * windowSize, 0);
+	magCache.resize(numWindows * windowSize, 0);
 
-	for (int i = 0;i<numWindows;i++) {
-		if (!m_processedWindows[i]) {
+	for (int i = 0; i < numWindows; i++)
+	{
+		if (!m_processedWindows[i])
+		{
 			generateWindow(i, false);
 			m_processedWindows[i] = true;
 		}
@@ -110,7 +106,8 @@ void PhaseVocoder::loadData(std::vector<float> originalData, int sampleRate, flo
 	dataLock.unlock();
 }
 
-void PhaseVocoder::getFrames(std::vector<float> & outData, int start, int frames) {
+void PhaseVocoder::getFrames(std::vector<float>& outData, int start, int frames)
+{
 	if (originalBuffer.size() < 2048) { return; }
 	dataLock.lock();
 
@@ -119,14 +116,17 @@ void PhaseVocoder::getFrames(std::vector<float> & outData, int start, int frames
 	int endWindow = std::min((float)numWindows, (float)(start + frames) / outStepSize + windowMargin);
 	// this encompases the minimum windows needed to get full quality,
 	// which must be computed
-	for (int i = startWindow;i<endWindow;i++) {
-		if (!m_processedWindows[i]) {
+	for (int i = startWindow; i < endWindow; i++)
+	{
+		if (!m_processedWindows[i])
+		{
 			generateWindow(i, true);
 			m_processedWindows[i] = true;
 		}
 	}
 
-	for (int i = 0;i<frames;i++) {
+	for (int i = 0; i < frames; i++)
+	{
 		outData[i] = processedBuffer[start + i];
 	}
 
@@ -134,7 +134,8 @@ void PhaseVocoder::getFrames(std::vector<float> & outData, int start, int frames
 }
 
 // adjust pv params and reset buffers
-void PhaseVocoder::updateParams(float newRatio) {
+void PhaseVocoder::updateParams(float newRatio)
+{
 	if (originalBuffer.size() < 2048) { return; }
 	if (newRatio == m_scaleRatio) { return; }
 	dataLock.lock();
@@ -144,11 +145,11 @@ void PhaseVocoder::updateParams(float newRatio) {
 	stepSize = (float)windowSize / overSampling;
 	numWindows = (float)originalBuffer.size() / stepSize - overSampling - 1;
 	outStepSize = m_scaleRatio * (float)stepSize; // float, else inaccurate
-	freqPerBin = originalSampleRate/windowSize;
-	expectedPhaseIn = 2.*M_PI*(float)stepSize/(float)windowSize;
-	expectedPhaseOut = 2.*M_PI*(float)outStepSize/(float)windowSize;
+	freqPerBin = originalSampleRate / windowSize;
+	expectedPhaseIn = 2. * M_PI * (float)stepSize / (float)windowSize;
+	expectedPhaseOut = 2. * M_PI * (float)outStepSize / (float)windowSize;
 
-	processedBuffer.resize(m_scaleRatio*originalBuffer.size(), 0);
+	processedBuffer.resize(m_scaleRatio * originalBuffer.size(), 0);
 
 	// very slow :(
 	std::fill(m_processedWindows.begin(), m_processedWindows.end(), false);
@@ -170,72 +171,76 @@ void PhaseVocoder::generateWindow(int windowNum, bool useCache)
 {
 	// declare vars
 	float real, imag, phase, magnitude, freq, deltaPhase = 0;
-	int windowStart = (float)windowNum*stepSize;
-	int windowIndex = (float)windowNum*windowSize;
+	int windowStart = (float)windowNum * stepSize;
+	int windowIndex = (float)windowNum * windowSize;
 
-	if (!useCache) { // normal stuff
-		memcpy(FFTInput.data(), originalBuffer.data() + windowStart, windowSize*sizeof(float));
+	if (!useCache)
+	{ // normal stuff
+		memcpy(FFTInput.data(), originalBuffer.data() + windowStart, windowSize * sizeof(float));
 
 		// FFT
 		fftwf_execute(fftPlan);
 
 		// analysis step
-		for (int j = 0; j < windowSize/2; j++) // only process nyquistic frequency
+		for (int j = 0; j < windowSize / 2; j++) // only process nyquistic frequency
 		{
 			real = FFTSpectrum[j][0];
 			imag = FFTSpectrum[j][1];
 
-			magnitude = 2.*sqrt(real*real + imag*imag);
-			phase = atan2(imag,real);
+			magnitude = 2. * sqrt(real * real + imag * imag);
+			phase = atan2(imag, real);
 
 			freq = phase;
-			freq = phase - lastPhase[std::max(0, windowIndex + j - windowSize)]; // subtract prev pahse to get phase diference
+			freq = phase
+				- lastPhase[std::max(0, windowIndex + j - windowSize)]; // subtract prev pahse to get phase diference
 			lastPhase[windowIndex + j] = phase;
 
-			freq -= (float)j*expectedPhaseIn; // subtract expected phase
+			freq -= (float)j * expectedPhaseIn; // subtract expected phase
 
 			// this puts freq in 0-2pi
 			freq = fmod(freq + M_PI, -2.0f * M_PI) + M_PI;
 
-			freq = (float)overSampling*freq/(2.*M_PI); // idk
+			freq = (float)overSampling * freq / (2. * M_PI); // idk
 
-			freq = (float)j*freqPerBin + freq*freqPerBin; // "compute the k-th partials' true frequency" ok i guess
+			freq = (float)j * freqPerBin + freq * freqPerBin; // "compute the k-th partials' true frequency" ok i guess
 
 			allMagnitudes[j] = magnitude;
 			allFrequencies[j] = freq;
 		}
 		// write cache
-		memcpy(freqCache.data() + windowIndex, allFrequencies.data(), windowSize*sizeof(float));
-		memcpy(magCache.data() + windowIndex, allMagnitudes.data(),  windowSize*sizeof(float));
-	} else {
+		memcpy(freqCache.data() + windowIndex, allFrequencies.data(), windowSize * sizeof(float));
+		memcpy(magCache.data() + windowIndex, allMagnitudes.data(), windowSize * sizeof(float));
+	}
+	else
+	{
 		// read cache
-		memcpy(allFrequencies.data(), freqCache.data() + windowIndex, windowSize*sizeof(float));
-		memcpy(allMagnitudes.data(), magCache.data() + windowIndex, windowSize*sizeof(float));
+		memcpy(allFrequencies.data(), freqCache.data() + windowIndex, windowSize * sizeof(float));
+		memcpy(allMagnitudes.data(), magCache.data() + windowIndex, windowSize * sizeof(float));
 	}
 
-
 	// synthesis, all the operations are the reverse of the analysis
-	for (int j = 0; j < windowSize/2; j++)
+	for (int j = 0; j < windowSize / 2; j++)
 	{
 		magnitude = allMagnitudes[j];
 		freq = allFrequencies[j];
 
-		deltaPhase = freq - (float)j*freqPerBin;
+		deltaPhase = freq - (float)j * freqPerBin;
 
 		deltaPhase /= freqPerBin;
 
-		deltaPhase = 2.*M_PI*deltaPhase/overSampling;
+		deltaPhase = 2. * M_PI * deltaPhase / overSampling;
 
-		deltaPhase += (float)j*expectedPhaseOut;
+		deltaPhase += (float)j * expectedPhaseOut;
 
 		sumPhase[windowIndex + j] += deltaPhase;
 		deltaPhase = sumPhase[windowIndex + j]; // this is the bin phase
-		if (windowIndex + j + windowSize < sumPhase.size()) { // only if not last window
+		if (windowIndex + j + windowSize < sumPhase.size())
+		{														 // only if not last window
 			sumPhase[windowIndex + j + windowSize] = deltaPhase; // copy to the next
 		}
 
-		FFTSpectrum[j][0] = magnitude*cos(deltaPhase);
-		FFTSpectrum[j][1] = magnitude*sin(deltaPhase);
+		FFTSpectrum[j][0] = magnitude * cos(deltaPhase);
+		FFTSpectrum[j][1] = magnitude * sin(deltaPhase);
 	}
 
 	// inverse fft
@@ -255,35 +260,32 @@ void PhaseVocoder::generateWindow(int windowNum, bool useCache)
 		// 							(float)overSampling);
 
 		// discrete windowing
-		// dataOut[outIndex] += (float)overSampling/totalWindowOverlap*IFFTReconstruction[j]/(windowSize/2.0f*overSampling);
+		// dataOut[outIndex] +=
+		// (float)overSampling/totalWindowOverlap*IFFTReconstruction[j]/(windowSize/2.0f*overSampling);
 		// printf("timeshifted in phase: %f\n", m_timeshiftedBufferL[outIndex]);
 		// continuos windowing
-		float window = -0.5f*cos(2.*M_PI*(float)j/(float)windowSize)+0.5f;
-		processedBuffer[outIndex] += window*IFFTReconstruction[j]/(windowSize/2.0f*overSampling);
+		float window = -0.5f * cos(2. * M_PI * (float)j / (float)windowSize) + 0.5f;
+		processedBuffer[outIndex] += window * IFFTReconstruction[j] / (windowSize / 2.0f * overSampling);
 	}
-
 }
 
-
 // ################################# SlicerT ####################################
 
-SlicerT::SlicerT(InstrumentTrack * instrumentTrack) :
-	Instrument( instrumentTrack, &slicert_plugin_descriptor ),
-	m_noteThreshold(0.3f, 0.0f, 2.0f, 0.01f, this, tr( "Note threshold" ) ),
-	m_fadeOutFrames(400.0f, 0.0f, 8192.0f, 1.0f, this, tr("FadeOut")),
-	m_originalBPM(1, 1, 999, this, tr("Original bpm")),
-	m_originalSample(),
-	m_phaseVocoder()
+SlicerT::SlicerT(InstrumentTrack* instrumentTrack)
+	: Instrument(instrumentTrack, &slicert_plugin_descriptor)
+	, m_noteThreshold(0.3f, 0.0f, 2.0f, 0.01f, this, tr("Note threshold"))
+	, m_fadeOutFrames(400.0f, 0.0f, 8192.0f, 1.0f, this, tr("FadeOut"))
+	, m_originalBPM(1, 1, 999, this, tr("Original bpm"))
+	, m_originalSample()
+	, m_phaseVocoder()
 {
 }
 
-
-
-void SlicerT::playNote( NotePlayHandle * handle, sampleFrame * workingBuffer )
+void SlicerT::playNote(NotePlayHandle* handle, sampleFrame* workingBuffer)
 {
 	if (m_originalSample.frames() < 2048) { return; }
 
-	const float speedRatio = (float)m_originalBPM.value() / Engine::getSong()->getTempo() ;
+	const float speedRatio = (float)m_originalBPM.value() / Engine::getSong()->getTempo();
 
 	const int noteIndex = handle->key() - 69;
 	const fpp_t frames = handle->framesLeftForCurrentPeriod();
@@ -294,21 +296,22 @@ void SlicerT::playNote( NotePlayHandle * handle, sampleFrame * workingBuffer )
 	const int totalFrames = m_phaseVocoder.frames();
 
 	int sliceStart, sliceEnd;
-	if (noteIndex > m_slicePoints.size()-2 || noteIndex < 0)
+	if (noteIndex > m_slicePoints.size() - 2 || noteIndex < 0)
 	{
 		sliceStart = 0;
 		sliceEnd = totalFrames;
-	} else {
+	}
+	else
+	{
 		sliceStart = m_slicePoints[noteIndex] * speedRatio;
-		sliceEnd = m_slicePoints[noteIndex+1] * speedRatio;
+		sliceEnd = m_slicePoints[noteIndex + 1] * speedRatio;
 	}
 
 	int sliceFrames = sliceEnd - sliceStart;
 	int currentNoteFrame = sliceStart + playedFrames;
 	int noteFramesLeft = sliceFrames - playedFrames;
 
-
-	if( noteFramesLeft > 0)
+	if (noteFramesLeft > 0)
 	{
 		int framesToCopy = std::min((int)frames, noteFramesLeft);
 		m_phaseVocoder.getFrames(workingBuffer + offset, currentNoteFrame, framesToCopy);
@@ -316,9 +319,9 @@ void SlicerT::playNote( NotePlayHandle * handle, sampleFrame * workingBuffer )
 		// exponential fade out, applyRelease kinda sucks
 		if (noteFramesLeft < m_fadeOutFrames.value())
 		{
-			for (int i = 0;i<frames;i++)
+			for (int i = 0; i < frames; i++)
 			{
-				float fadeValue = (float)(noteFramesLeft-i) / m_fadeOutFrames.value();
+				float fadeValue = (float)(noteFramesLeft - i) / m_fadeOutFrames.value();
 				// if the workingbuffer extends the sample
 				fadeValue = std::clamp(fadeValue, 0.0f, 1.0f);
 				fadeValue = pow(fadeValue, 2);
@@ -328,16 +331,15 @@ void SlicerT::playNote( NotePlayHandle * handle, sampleFrame * workingBuffer )
 			}
 		}
 
-		instrumentTrack()->processAudioBuffer( workingBuffer, frames + offset, handle );
+		instrumentTrack()->processAudioBuffer(workingBuffer, frames + offset, handle);
 
 		// calculate absolute for the waveform
 		float absoluteCurrentNote = (float)currentNoteFrame / totalFrames;
 		float absoluteStartNote = (float)sliceStart / totalFrames;
 		float abslouteEndNote = (float)sliceEnd / totalFrames;
 		emit isPlaying(absoluteCurrentNote, absoluteStartNote, abslouteEndNote);
-	} else {
-		emit isPlaying(-1, 0, 0);
 	}
+	else { emit isPlaying(-1, 0, 0); }
 }
 
 // uses the spectral flux to determine the change in magnitude
@@ -352,7 +354,8 @@ void SlicerT::findSlices()
 
 	std::vector<float> leftChannel(m_originalSample.frames(), 0);
 
-	for (int i = 0;i<m_originalSample.frames();i++) {
+	for (int i = 0; i < m_originalSample.frames(); i++)
+	{
 		leftChannel[i] = m_originalSample.data()[i][0];
 	}
 
@@ -367,14 +370,16 @@ void SlicerT::findSlices()
 	float prevFlux = 0;
 	float real, imag, magnitude, diff;
 
-	for (int i = 0;i<leftChannel.size()-windowSize;i+=windowSize) {
-		memcpy(fftIn.data(), leftChannel.data() + i, windowSize*sizeof(float));
+	for (int i = 0; i < leftChannel.size() - windowSize; i += windowSize)
+	{
+		memcpy(fftIn.data(), leftChannel.data() + i, windowSize * sizeof(float));
 		fftwf_execute(fftPlan);
 
-		for (int j = 0;j<windowSize/2;j++) { // only use niquistic frequencies
+		for (int j = 0; j < windowSize / 2; j++)
+		{ // only use niquistic frequencies
 			real = fftOut[j][0];
 			imag = fftOut[j][1];
-			magnitude = sqrt(real*real + imag*imag);
+			magnitude = sqrt(real * real + imag * imag);
 
 			diff = sqrt(pow(magnitude - prevMags[j], 2));
 			spectralFlux += diff;
@@ -382,14 +387,14 @@ void SlicerT::findSlices()
 			prevMags[j] = magnitude;
 		}
 
-		if (spectralFlux / prevFlux > 1.0f+m_noteThreshold.value() && i - lastPoint > minDist) {
+		if (spectralFlux / prevFlux > 1.0f + m_noteThreshold.value() && i - lastPoint > minDist)
+		{
 			m_slicePoints.push_back(i);
 			lastPoint = i;
 		}
 
 		prevFlux = spectralFlux;
 		spectralFlux = 0;
-
 	}
 
 	m_slicePoints.push_back(m_originalSample.frames());
@@ -432,7 +437,7 @@ void SlicerT::findBPM()
 	m_originalBPM.setInitValue(bpm);
 }
 
-void SlicerT::writeToMidi(std::vector<Note> * outClip)
+void SlicerT::writeToMidi(std::vector<Note>* outClip)
 {
 	if (m_originalSample.frames() < 2048) { return; }
 
@@ -453,7 +458,7 @@ void SlicerT::writeToMidi(std::vector<Note> * outClip)
 
 	float lastEnd = 0;
 
-	for (int i = 0;i<m_slicePoints.size()-1;i++)
+	for (int i = 0; i < m_slicePoints.size() - 1; i++)
 	{
 		float sliceStart = lastEnd;
 		float sliceEnd = (float)m_slicePoints[i + 1] / m_originalSample.frames() * totalTicks;
@@ -476,11 +481,9 @@ void SlicerT::updateFile(QString file)
 	findSlices();
 	findBPM();
 
-	float speedRatio = (float)m_originalBPM.value() / Engine::getSong()->getTempo() ;
-	m_phaseVocoder.loadSample(m_originalSample.data(),
-							m_originalSample.frames(),
-							m_originalSample.sampleRate(),
-							speedRatio);
+	float speedRatio = (float)m_originalBPM.value() / Engine::getSong()->getTempo();
+	m_phaseVocoder.loadSample(
+		m_originalSample.data(), m_originalSample.frames(), m_originalSample.sampleRate(), speedRatio);
 
 	emit dataChanged();
 }
@@ -490,7 +493,7 @@ void SlicerT::updateSlices()
 	findSlices();
 }
 
-void SlicerT::saveSettings(QDomDocument & document, QDomElement & element)
+void SlicerT::saveSettings(QDomDocument& document, QDomElement& element)
 {
 	element.setAttribute("src", m_originalSample.audioFile());
 	if (m_originalSample.audioFile().isEmpty())
@@ -501,7 +504,7 @@ void SlicerT::saveSettings(QDomDocument & document, QDomElement & element)
 
 	element.setAttribute("totalSlices", (int)m_slicePoints.size());
 
-	for (int i = 0;i<m_slicePoints.size();i++)
+	for (int i = 0; i < m_slicePoints.size(); i++)
 	{
 		element.setAttribute(tr("slice_%1").arg(i), m_slicePoints[i]);
 	}
@@ -511,7 +514,7 @@ void SlicerT::saveSettings(QDomDocument & document, QDomElement & element)
 	m_originalBPM.saveSettings(document, element, "origBPM");
 }
 
-void SlicerT::loadSettings( const QDomElement & element )
+void SlicerT::loadSettings(const QDomElement& element)
 {
 	if (!element.attribute("src").isEmpty())
 	{
@@ -533,7 +536,7 @@ void SlicerT::loadSettings( const QDomElement & element )
 	{
 		int totalSlices = element.attribute("totalSlices").toInt();
 		m_slicePoints = {};
-		for (int i = 0;i<totalSlices;i++)
+		for (int i = 0; i < totalSlices; i++)
 		{
 			m_slicePoints.push_back(element.attribute(tr("slice_%1").arg(i)).toInt());
 		}
@@ -543,34 +546,28 @@ void SlicerT::loadSettings( const QDomElement & element )
 	m_noteThreshold.loadSettings(element, "threshold");
 	m_originalBPM.loadSettings(element, "origBPM");
 
-	float speedRatio = (float)m_originalBPM.value() / Engine::getSong()->getTempo() ;
-	m_phaseVocoder.loadSample(m_originalSample.data(),
-							m_originalSample.frames(),
-							m_originalSample.sampleRate(),
-							speedRatio);
+	float speedRatio = (float)m_originalBPM.value() / Engine::getSong()->getTempo();
+	m_phaseVocoder.loadSample(
+		m_originalSample.data(), m_originalSample.frames(), m_originalSample.sampleRate(), speedRatio);
 
 	emit dataChanged();
-
 }
 
 QString SlicerT::nodeName() const
 {
-	return( slicert_plugin_descriptor.name );
+	return (slicert_plugin_descriptor.name);
 }
 
-gui::PluginView * SlicerT::instantiateView( QWidget * parent )
+gui::PluginView* SlicerT::instantiateView(QWidget* parent)
 {
-	return( new gui::SlicerTUI( this, parent ) );
+	return (new gui::SlicerTUI(this, parent));
 }
 
-
-extern "C"
-{
+extern "C" {
 // necessary for getting instance out of shared lib
-PLUGIN_EXPORT Plugin * lmms_plugin_main( Model *m, void * )
+PLUGIN_EXPORT Plugin* lmms_plugin_main(Model* m, void*)
 {
-	return( new SlicerT( static_cast<InstrumentTrack *>( m ) ) );
+	return (new SlicerT(static_cast<InstrumentTrack*>(m)));
 }
 } // extern
 } // namespace lmms
-
diff --git a/plugins/SlicerT/SlicerT.h b/plugins/SlicerT/SlicerT.h
index 25142f41118..ebb0fee0f61 100644
--- a/plugins/SlicerT/SlicerT.h
+++ b/plugins/SlicerT/SlicerT.h
@@ -25,156 +25,164 @@
 #ifndef SLICERT_H
 #define SLICERT_H
 
-#include "SlicerTUI.h"
-
 #include <fftw3.h>
 
-#include "Note.h"
+#include "AutomatableModel.h"
 #include "Instrument.h"
 #include "InstrumentView.h"
-#include "AutomatableModel.h"
+#include "Note.h"
 #include "SampleBuffer.h"
+#include "SlicerTUI.h"
 
-
-namespace lmms
-{
+namespace lmms {
 
 // takes one audio-channel and timeshifts it
-class PhaseVocoder {
-	public:
-		PhaseVocoder();
-		~PhaseVocoder();
-		void loadData(std::vector<float> originalData, int sampleRate, float newRatio);
-		void setScaleRatio(float newRatio) { updateParams(newRatio); }
-		void getFrames(std::vector<float> & outData, int start, int frames);
-		int frames() { return processedBuffer.size(); }
-		float scaleRatio() { return m_scaleRatio; }
-	private:
-		QMutex dataLock;
-		// original data
-		std::vector<float> originalBuffer;
-		int originalSampleRate = 0;
-
-		float m_scaleRatio = -1; // to force on fisrt load
-
-		// output data
-		std::vector<float> processedBuffer;
-		std::vector<bool> m_processedWindows; // marks a window processed
-
-		// timeshift stuff
-		static const int windowSize = 512;
-		static const int overSampling = 32;
-
-		// depending on scaleRatio
-		int stepSize = 0;
-		int numWindows = 0;
-		float outStepSize = 0;
-		float freqPerBin = 0;
-		float expectedPhaseIn = 0;
-		float expectedPhaseOut = 0;
-
-		// buffers
-		fftwf_complex FFTSpectrum[windowSize];
-		std::vector<float> FFTInput;
-		std::vector<float> IFFTReconstruction;
-		std::vector<float> allMagnitudes;
-		std::vector<float> allFrequencies;
-		std::vector<float> processedFreq;
-		std::vector<float> processedMagn;
-		std::vector<float> lastPhase;
-		std::vector<float> sumPhase;
-
-		// cache
-		std::vector<float> freqCache;
-		std::vector<float> magCache;
-
-		// fftw plans
-		fftwf_plan fftPlan;
-		fftwf_plan ifftPlan;
-
-		void updateParams(float newRatio);
-		void generateWindow(int windowNum, bool useCache);
+class PhaseVocoder
+{
+public:
+	PhaseVocoder();
+	~PhaseVocoder();
+	void loadData(std::vector<float> originalData, int sampleRate, float newRatio);
+	void setScaleRatio(float newRatio) { updateParams(newRatio); }
+	void getFrames(std::vector<float>& outData, int start, int frames);
+	int frames() { return processedBuffer.size(); }
+	float scaleRatio() { return m_scaleRatio; }
+
+private:
+	QMutex dataLock;
+	// original data
+	std::vector<float> originalBuffer;
+	int originalSampleRate = 0;
+
+	float m_scaleRatio = -1; // to force on fisrt load
+
+	// output data
+	std::vector<float> processedBuffer;
+	std::vector<bool> m_processedWindows; // marks a window processed
+
+	// timeshift stuff
+	static const int windowSize = 512;
+	static const int overSampling = 32;
+
+	// depending on scaleRatio
+	int stepSize = 0;
+	int numWindows = 0;
+	float outStepSize = 0;
+	float freqPerBin = 0;
+	float expectedPhaseIn = 0;
+	float expectedPhaseOut = 0;
+
+	// buffers
+	fftwf_complex FFTSpectrum[windowSize];
+	std::vector<float> FFTInput;
+	std::vector<float> IFFTReconstruction;
+	std::vector<float> allMagnitudes;
+	std::vector<float> allFrequencies;
+	std::vector<float> processedFreq;
+	std::vector<float> processedMagn;
+	std::vector<float> lastPhase;
+	std::vector<float> sumPhase;
+
+	// cache
+	std::vector<float> freqCache;
+	std::vector<float> magCache;
+
+	// fftw plans
+	fftwf_plan fftPlan;
+	fftwf_plan ifftPlan;
+
+	void updateParams(float newRatio);
+	void generateWindow(int windowNum, bool useCache);
 };
 
 // simple helper class that handles the different audio channels
-class dinamicPlaybackBuffer {
-	public:
-		dinamicPlaybackBuffer() :
-			leftChannel(),
-			rightChannel()
-		{}
-		void loadSample(const sampleFrame * outData, int frames, int sampleRate, float newRatio) {
-			std::vector<float> leftData(frames, 0);
-			std::vector<float> rightData(frames, 0);
-			for (int i = 0;i<frames;i++) {
-				leftData[i] = outData[i][0];
-				rightData[i] = outData[i][1];
-			}
-			leftChannel.loadData(leftData, sampleRate, newRatio);
-			rightChannel.loadData(rightData, sampleRate, newRatio);
-		}
-		void getFrames(sampleFrame * outData, int startFrame, int frames) {
-			std::vector<float> leftOut(frames, 0); // not a huge performance issue
-			std::vector<float> rightOut(frames, 0);
-
-			leftChannel.getFrames(leftOut, startFrame, frames);
-			rightChannel.getFrames(rightOut, startFrame, frames);
-
-			for (int i = 0;i<frames;i++) {
-				outData[i][0] = leftOut[i];
-				outData[i][1] = rightOut[i];
-			}
+class dinamicPlaybackBuffer
+{
+public:
+	dinamicPlaybackBuffer()
+		: leftChannel()
+		, rightChannel()
+	{
+	}
+	void loadSample(const sampleFrame* outData, int frames, int sampleRate, float newRatio)
+	{
+		std::vector<float> leftData(frames, 0);
+		std::vector<float> rightData(frames, 0);
+		for (int i = 0; i < frames; i++)
+		{
+			leftData[i] = outData[i][0];
+			rightData[i] = outData[i][1];
 		}
-		int frames() { return leftChannel.frames(); }
-		float scaleRatio() { return leftChannel.scaleRatio(); }
-		void setScaleRatio(float newRatio) {
-			leftChannel.setScaleRatio(newRatio);
-			rightChannel.setScaleRatio(newRatio);
+		leftChannel.loadData(leftData, sampleRate, newRatio);
+		rightChannel.loadData(rightData, sampleRate, newRatio);
+	}
+	void getFrames(sampleFrame* outData, int startFrame, int frames)
+	{
+		std::vector<float> leftOut(frames, 0); // not a huge performance issue
+		std::vector<float> rightOut(frames, 0);
+
+		leftChannel.getFrames(leftOut, startFrame, frames);
+		rightChannel.getFrames(rightOut, startFrame, frames);
+
+		for (int i = 0; i < frames; i++)
+		{
+			outData[i][0] = leftOut[i];
+			outData[i][1] = rightOut[i];
 		}
-	private:
-		PhaseVocoder leftChannel;
-		PhaseVocoder rightChannel;
+	}
+	int frames() { return leftChannel.frames(); }
+	float scaleRatio() { return leftChannel.scaleRatio(); }
+	void setScaleRatio(float newRatio)
+	{
+		leftChannel.setScaleRatio(newRatio);
+		rightChannel.setScaleRatio(newRatio);
+	}
+
+private:
+	PhaseVocoder leftChannel;
+	PhaseVocoder rightChannel;
 };
 
-class SlicerT : public Instrument{
+class SlicerT : public Instrument
+{
 	Q_OBJECT
 
-	public:
-		SlicerT(InstrumentTrack * instrumentTrack);
-		~SlicerT() override = default;
+public:
+	SlicerT(InstrumentTrack* instrumentTrack);
+	~SlicerT() override = default;
 
-		void playNote( NotePlayHandle * handle, sampleFrame * workingBuffer ) override;
+	void playNote(NotePlayHandle* handle, sampleFrame* workingBuffer) override;
 
-		void saveSettings( QDomDocument & document, QDomElement & element ) override;
-		void loadSettings( const QDomElement & element ) override;
+	void saveSettings(QDomDocument& document, QDomElement& element) override;
+	void loadSettings(const QDomElement& element) override;
 
-		QString nodeName() const override;
-		gui::PluginView * instantiateView( QWidget * parent ) override;
+	QString nodeName() const override;
+	gui::PluginView* instantiateView(QWidget* parent) override;
 
-		void writeToMidi(std::vector<Note> * outClip);
+	void writeToMidi(std::vector<Note>* outClip);
 
-	public slots:
-		void updateFile(QString file);
-		void updateSlices();
+public slots:
+	void updateFile(QString file);
+	void updateSlices();
 
-	signals:
-		void isPlaying(float current, float start, float end);
+signals:
+	void isPlaying(float current, float start, float end);
 
-	private:
-		FloatModel m_noteThreshold;
-		FloatModel m_fadeOutFrames;
-		IntModel m_originalBPM;
+private:
+	FloatModel m_noteThreshold;
+	FloatModel m_fadeOutFrames;
+	IntModel m_originalBPM;
 
-		SampleBuffer m_originalSample;
-		dinamicPlaybackBuffer m_phaseVocoder;
+	SampleBuffer m_originalSample;
+	dinamicPlaybackBuffer m_phaseVocoder;
 
-		std::vector<int> m_slicePoints;
+	std::vector<int> m_slicePoints;
 
-		void findSlices();
-		void findBPM();
+	void findSlices();
+	void findBPM();
 
-		friend class gui::SlicerTUI;
-		friend class gui::WaveForm;
+	friend class gui::SlicerTUI;
+	friend class gui::WaveForm;
 };
 } // namespace lmms
 #endif // SLICERT_H
diff --git a/plugins/SlicerT/SlicerTUI.cpp b/plugins/SlicerT/SlicerTUI.cpp
index e1af70c2847..c0d79ae8e0e 100644
--- a/plugins/SlicerT/SlicerTUI.cpp
+++ b/plugins/SlicerT/SlicerTUI.cpp
@@ -23,47 +23,40 @@
  */
 
 #include "SlicerTUI.h"
-#include "SlicerT.h"
 
-#include <QFileInfo>
 #include <QDropEvent>
+#include <QFileInfo>
 
-#include "StringPairDrag.h"
 #include "Clipboard.h"
-#include "Track.h"
 #include "DataFile.h"
-
 #include "Engine.h"
-#include "Song.h"
 #include "InstrumentTrack.h"
-
+#include "SlicerT.h"
+#include "Song.h"
+#include "StringPairDrag.h"
+#include "Track.h"
 #include "embed.h"
 
-namespace lmms
-{
-
-
-namespace gui
-{
+namespace lmms {
 
+namespace gui {
 
-SlicerTUI::SlicerTUI( SlicerT * instrument,
-					QWidget * parent ) :
-	InstrumentViewFixedSize( instrument, parent ),
-	m_slicerTParent(instrument),
-	m_noteThresholdKnob(this),
-	m_fadeOutKnob(this),
-	m_bpmBox(3, "21pink", this),
-	m_resetButton(this, nullptr),
-	m_midiExportButton(this, nullptr),
-	m_wf(248, 128, instrument, this)
+SlicerTUI::SlicerTUI(SlicerT* instrument, QWidget* parent)
+	: InstrumentViewFixedSize(instrument, parent)
+	, m_slicerTParent(instrument)
+	, m_noteThresholdKnob(this)
+	, m_fadeOutKnob(this)
+	, m_bpmBox(3, "21pink", this)
+	, m_resetButton(this, nullptr)
+	, m_midiExportButton(this, nullptr)
+	, m_wf(248, 128, instrument, this)
 {
-	setAcceptDrops( true );
-	setAutoFillBackground( true );
+	setAcceptDrops(true);
+	setAutoFillBackground(true);
 
 	QPalette pal;
-	pal.setBrush( backgroundRole(), PLUGIN_NAME::getIconPixmap( "bg" ) );
-	setPalette( pal );
+	pal.setBrush(backgroundRole(), PLUGIN_NAME::getIconPixmap("bg"));
+	setPalette(pal);
 
 	m_wf.move(2, 6);
 
@@ -83,20 +76,16 @@ SlicerTUI::SlicerTUI( SlicerT * instrument,
 	m_fadeOutKnob.setModel(&m_slicerTParent->m_fadeOutFrames);
 
 	m_midiExportButton.move(190, 200);
-	m_midiExportButton.setActiveGraphic(
-						embed::getIconPixmap("midi_tab") );
-	m_midiExportButton.setInactiveGraphic(
-						embed::getIconPixmap("midi_tab"));
+	m_midiExportButton.setActiveGraphic(embed::getIconPixmap("midi_tab"));
+	m_midiExportButton.setInactiveGraphic(embed::getIconPixmap("midi_tab"));
 	m_midiExportButton.setToolTip(tr("Copy midi pattern to clipboard"));
-	connect(&m_midiExportButton, SIGNAL( clicked() ), this, SLOT( exportMidi() ));
+	connect(&m_midiExportButton, SIGNAL(clicked()), this, SLOT(exportMidi()));
 
 	m_resetButton.move(215, 200);
-	m_resetButton.setActiveGraphic(
-						embed::getIconPixmap("reload") );
-	m_resetButton.setInactiveGraphic(
-						embed::getIconPixmap("reload") );
+	m_resetButton.setActiveGraphic(embed::getIconPixmap("reload"));
+	m_resetButton.setInactiveGraphic(embed::getIconPixmap("reload"));
 	m_resetButton.setToolTip(tr("Reset Slices"));
-	connect(&m_resetButton, SIGNAL( clicked() ), m_slicerTParent, SLOT( updateSlices() ));
+	connect(&m_resetButton, SIGNAL(clicked()), m_slicerTParent, SLOT(updateSlices()));
 }
 
 // copied from piano roll
@@ -104,74 +93,60 @@ void SlicerTUI::exportMidi()
 {
 	using namespace Clipboard;
 
-	DataFile dataFile( DataFile::Type::ClipboardData );
-	QDomElement note_list = dataFile.createElement( "note-list" );
-	dataFile.content().appendChild( note_list );
+	DataFile dataFile(DataFile::Type::ClipboardData);
+	QDomElement note_list = dataFile.createElement("note-list");
+	dataFile.content().appendChild(note_list);
 
 	std::vector<Note> notes;
 	m_slicerTParent->writeToMidi(&notes);
-	if (notes.size() == 0)
-	{
-		return;
-	}
+	if (notes.size() == 0) { return; }
 
-	TimePos start_pos( notes.front().pos().getBar(), 0 );
-	for( Note note : notes )
+	TimePos start_pos(notes.front().pos().getBar(), 0);
+	for (Note note : notes)
 	{
-		Note clip_note( note );
-		clip_note.setPos( clip_note.pos( start_pos ) );
-		clip_note.saveState( dataFile, note_list );
+		Note clip_note(note);
+		clip_note.setPos(clip_note.pos(start_pos));
+		clip_note.saveState(dataFile, note_list);
 	}
 
-	copyString( dataFile.toString(), MimeType::Default );
+	copyString(dataFile.toString(), MimeType::Default);
 }
 
 // all the drag stuff is copied from AudioFileProcessor
-void SlicerTUI::dragEnterEvent( QDragEnterEvent * dee )
+void SlicerTUI::dragEnterEvent(QDragEnterEvent* dee)
 {
-		// For mimeType() and MimeType enum class
+	// For mimeType() and MimeType enum class
 	using namespace Clipboard;
 
-	if( dee->mimeData()->hasFormat( mimeType( MimeType::StringPair ) ) )
+	if (dee->mimeData()->hasFormat(mimeType(MimeType::StringPair)))
 	{
-		QString txt = dee->mimeData()->data(
-						mimeType( MimeType::StringPair ) );
-		if( txt.section( ':', 0, 0 ) == QString( "clip_%1" ).arg(
-							static_cast<int>(Track::Type::Sample) ) )
+		QString txt = dee->mimeData()->data(mimeType(MimeType::StringPair));
+		if (txt.section(':', 0, 0) == QString("clip_%1").arg(static_cast<int>(Track::Type::Sample)))
 		{
 			dee->acceptProposedAction();
 		}
-		else if( txt.section( ':', 0, 0 ) == "samplefile" )
-		{
-			dee->acceptProposedAction();
-		}
-		else
-		{
-			dee->ignore();
-		}
-	}
-	else
-	{
-		dee->ignore();
+		else if (txt.section(':', 0, 0) == "samplefile") { dee->acceptProposedAction(); }
+		else { dee->ignore(); }
 	}
+	else { dee->ignore(); }
 }
 
-void SlicerTUI::dropEvent( QDropEvent * de )
+void SlicerTUI::dropEvent(QDropEvent* de)
 {
-	QString type = StringPairDrag::decodeKey( de );
-	QString value = StringPairDrag::decodeValue( de );
-	if( type == "samplefile" )
+	QString type = StringPairDrag::decodeKey(de);
+	QString value = StringPairDrag::decodeValue(de);
+	if (type == "samplefile")
 	{
-		m_slicerTParent->updateFile( value );
+		m_slicerTParent->updateFile(value);
 		// castModel<AudioFileProcessor>()->setAudioFile( value );
 		// de->accept();
 		// set m_wf wave file
 		return;
 	}
-	else if( type == QString( "clip_%1" ).arg( static_cast<int>(Track::Type::Sample) ) )
+	else if (type == QString("clip_%1").arg(static_cast<int>(Track::Type::Sample)))
 	{
-		DataFile dataFile( value.toUtf8() );
-		m_slicerTParent->updateFile( dataFile.content().firstChild().toElement().attribute( "src" ) );
+		DataFile dataFile(value.toUtf8());
+		m_slicerTParent->updateFile(dataFile.content().firstChild().toElement().attribute("src"));
 		de->accept();
 		return;
 	}
@@ -179,7 +154,7 @@ void SlicerTUI::dropEvent( QDropEvent * de )
 	de->ignore();
 }
 
-void SlicerTUI::paintEvent(QPaintEvent * pe)
+void SlicerTUI::paintEvent(QPaintEvent* pe)
 {
 }
 
diff --git a/plugins/SlicerT/SlicerTUI.h b/plugins/SlicerT/SlicerTUI.h
index 425e4e7669e..d83f679932f 100644
--- a/plugins/SlicerT/SlicerTUI.h
+++ b/plugins/SlicerT/SlicerTUI.h
@@ -25,38 +25,35 @@
 #ifndef SLICERT_UI_H
 #define SLICERT_UI_H
 
-#include "WaveForm.h"
-
 #include <QPushButton>
 
 #include "Instrument.h"
 #include "InstrumentView.h"
 #include "Knob.h"
-#include "PixmapButton.h"
 #include "LcdSpinBox.h"
+#include "PixmapButton.h"
+#include "WaveForm.h"
 
-
-namespace lmms
-{
+namespace lmms {
 
 class SlicerT;
 
-namespace gui
-{
+namespace gui {
 
-class SlicerTKnob : public Knob {
-	public:
-		SlicerTKnob( QWidget * _parent ) :
-				Knob( KnobType::Styled, _parent )
-		{
-		setFixedSize( 46, 40 );
-		setCenterPointX( 23.0 );
-		setCenterPointY( 15.0 );
-		setInnerRadius( 3 );
-		setOuterRadius( 11 );
-		setLineWidth( 3 );
-		setOuterColor( QColor(178, 115, 255) );
-		}
+class SlicerTKnob : public Knob
+{
+public:
+	SlicerTKnob(QWidget* _parent)
+		: Knob(KnobType::Styled, _parent)
+	{
+		setFixedSize(46, 40);
+		setCenterPointX(23.0);
+		setCenterPointY(15.0);
+		setInnerRadius(3);
+		setOuterRadius(11);
+		setLineWidth(3);
+		setOuterColor(QColor(178, 115, 255));
+	}
 };
 
 class SlicerTUI : public InstrumentViewFixedSize
@@ -64,22 +61,21 @@ class SlicerTUI : public InstrumentViewFixedSize
 	Q_OBJECT
 
 public:
-	SlicerTUI( SlicerT * instrument,
-					QWidget * parent );
+	SlicerTUI(SlicerT* instrument, QWidget* parent);
 	~SlicerTUI() override = default;
 
 protected slots:
 	void exportMidi();
-	//void sampleSizeChanged( float _new_sample_length );
+	// void sampleSizeChanged( float _new_sample_length );
 
 protected:
-	virtual void dragEnterEvent( QDragEnterEvent * _dee );
-	virtual void dropEvent( QDropEvent * _de );
+	virtual void dragEnterEvent(QDragEnterEvent* _dee);
+	virtual void dropEvent(QDropEvent* _de);
 
-	virtual void paintEvent(QPaintEvent * pe);
+	virtual void paintEvent(QPaintEvent* pe);
 
 private:
-	SlicerT * m_slicerTParent;
+	SlicerT* m_slicerTParent;
 
 	SlicerTKnob m_noteThresholdKnob;
 	SlicerTKnob m_fadeOutKnob;
diff --git a/plugins/SlicerT/WaveForm.cpp b/plugins/SlicerT/WaveForm.cpp
index e6ac38b4bc5..28e568de3fa 100644
--- a/plugins/SlicerT/WaveForm.cpp
+++ b/plugins/SlicerT/WaveForm.cpp
@@ -23,284 +23,277 @@
  */
 
 #include "WaveForm.h"
-#include "SlicerT.h"
 
+#include "SlicerT.h"
 #include "embed.h"
 
-namespace lmms
+namespace lmms {
+
+namespace gui {
+WaveForm::WaveForm(int w, int h, SlicerT* instrument, QWidget* parent)
+	: QWidget(parent)
+	,
+	// calculate sizes
+	m_width(w)
+	, m_height(h)
+	, m_seekerWidth(w - m_seekerHorMargin * 2)
+	, m_editorHeight(h - m_seekerHeight - m_middleMargin)
+	, m_editorWidth(w)
+	,
+
+	// create pixmaps
+	m_sliceArrow(PLUGIN_NAME::getIconPixmap("slide_indicator_arrow"))
+	, m_seeker(QPixmap(m_seekerWidth, m_seekerHeight))
+	, m_seekerWaveform(QPixmap(m_seekerWidth, m_seekerHeight))
+	, m_sliceEditor(QPixmap(w, m_editorHeight))
+	,
+
+	// references to instrument vars
+	m_currentSample(instrument->m_originalSample)
+	, m_slicerTParent(instrument)
+	, m_slicePoints(instrument->m_slicePoints)
+
 {
+	setFixedSize(m_width, m_height);
+	setMouseTracking(true);
 
+	m_sliceEditor.fill(m_waveformBgColor);
+	m_seekerWaveform.fill(m_waveformBgColor);
 
-namespace gui
-{
-WaveForm::WaveForm(int w, int h, SlicerT  * instrument, QWidget * parent) :
-    QWidget(parent),
-    // calculate sizes
-    m_width(w),
-    m_height(h),
-    m_seekerWidth(w - m_seekerHorMargin * 2),
-    m_editorHeight(h - m_seekerHeight - m_middleMargin),
-    m_editorWidth(w),
-
-    // create pixmaps
-    m_sliceArrow(PLUGIN_NAME::getIconPixmap( "slide_indicator_arrow" )),
-    m_seeker(QPixmap(m_seekerWidth, m_seekerHeight)),
-    m_seekerWaveform(QPixmap(m_seekerWidth, m_seekerHeight)),
-    m_sliceEditor(QPixmap(w, m_editorHeight)),
-
-    // references to instrument vars
-    m_currentSample(instrument->m_originalSample),
-    m_slicerTParent(instrument),
-    m_slicePoints(instrument->m_slicePoints)
-
-    {
-        setFixedSize(m_width, m_height);
-        setMouseTracking( true );
-
-        m_sliceEditor.fill(m_waveformBgColor);
-        m_seekerWaveform.fill(m_waveformBgColor);
-
-        connect(m_slicerTParent,
-                SIGNAL(isPlaying(float, float, float)),
-                this,
-                SLOT(isPlaying(float, float, float)));
-        connect(m_slicerTParent, SIGNAL(dataChanged()), this, SLOT(updateUI()));
-
-        updateUI();
-    }
+	connect(m_slicerTParent, SIGNAL(isPlaying(float, float, float)), this, SLOT(isPlaying(float, float, float)));
+	connect(m_slicerTParent, SIGNAL(dataChanged()), this, SLOT(updateUI()));
+
+	updateUI();
+}
 
 // graphics
 void WaveForm::drawSeekerWaveform()
 {
-    m_seekerWaveform.fill(m_waveformBgColor);
-    QPainter brush(&m_seekerWaveform);
-    brush.setPen(m_waveformColor);
-
-    m_currentSample.visualize(
-    brush,
-    QRect( 0, 0, m_seekerWaveform.width(), m_seekerWaveform.height() ),
-    0, m_currentSample.frames());
+	m_seekerWaveform.fill(m_waveformBgColor);
+	QPainter brush(&m_seekerWaveform);
+	brush.setPen(m_waveformColor);
+
+	m_currentSample.visualize(
+		brush, QRect(0, 0, m_seekerWaveform.width(), m_seekerWaveform.height()), 0, m_currentSample.frames());
 }
 
 void WaveForm::drawSeeker()
 {
-    m_seeker.fill(m_waveformBgColor);
-    QPainter brush(&m_seeker);
-    // draw slice points
-    brush.setPen(m_sliceColor);
-    for (int i = 0;i<m_slicePoints.size();i++)
-    {
-        float xPos = (float)m_slicePoints[i] / m_currentSample.frames() * m_seekerWidth;
-        brush.drawLine(xPos, 0, xPos, m_seekerHeight);
-    }
-
-    // this is a complete mess
-    // draw current playBack
-    brush.setPen(m_playColor);
-    brush.drawLine(m_noteCurrent*m_seekerWidth, 0, m_noteCurrent*m_seekerWidth, m_seekerHeight);
-    brush.fillRect(m_noteStart*m_seekerWidth, 0, (m_noteEnd-m_noteStart)*m_seekerWidth, m_seekerHeight, m_playHighlighColor);
-
-    // highlight on selected area
-    brush.fillRect(m_seekerStart*m_seekerWidth, 0, (m_seekerEnd-m_seekerStart)*m_seekerWidth, m_seekerHeight, m_seekerHighlightColor);
-
-    // shadow on not selected area
-    brush.fillRect(0, 0, m_seekerStart*m_seekerWidth, m_seekerHeight, m_seekerShadowColor);
-    brush.fillRect(m_seekerEnd*m_seekerWidth+1, 0, m_seekerWidth+1, m_seekerHeight, m_seekerShadowColor);
-
-    // draw border around selection
-    brush.setPen(QPen(m_seekerColor, 1));
-    brush.drawRoundedRect(m_seekerStart*m_seekerWidth, 0, (m_seekerEnd-m_seekerStart)*m_seekerWidth-1, m_seekerHeight-1, 4, 4); // -1 needed
+	m_seeker.fill(m_waveformBgColor);
+	QPainter brush(&m_seeker);
+	// draw slice points
+	brush.setPen(m_sliceColor);
+	for (int i = 0; i < m_slicePoints.size(); i++)
+	{
+		float xPos = (float)m_slicePoints[i] / m_currentSample.frames() * m_seekerWidth;
+		brush.drawLine(xPos, 0, xPos, m_seekerHeight);
+	}
+
+	// this is a complete mess, TODO: cleanup
+	// draw current playBack
+	brush.setPen(m_playColor);
+	brush.drawLine(m_noteCurrent * m_seekerWidth, 0, m_noteCurrent * m_seekerWidth, m_seekerHeight);
+	brush.fillRect(
+		m_noteStart * m_seekerWidth, 0, (m_noteEnd - m_noteStart) * m_seekerWidth, m_seekerHeight, m_playHighlighColor);
+
+	// highlight on selected area
+	brush.fillRect(m_seekerStart * m_seekerWidth, 0, (m_seekerEnd - m_seekerStart) * m_seekerWidth, m_seekerHeight,
+		m_seekerHighlightColor);
+
+	// shadow on not selected area
+	brush.fillRect(0, 0, m_seekerStart * m_seekerWidth, m_seekerHeight, m_seekerShadowColor);
+	brush.fillRect(m_seekerEnd * m_seekerWidth + 1, 0, m_seekerWidth + 1, m_seekerHeight, m_seekerShadowColor);
+
+	// draw border around selection
+	brush.setPen(QPen(m_seekerColor, 1));
+	brush.drawRoundedRect(m_seekerStart * m_seekerWidth, 0, (m_seekerEnd - m_seekerStart) * m_seekerWidth - 1,
+		m_seekerHeight - 1, 4, 4); // -1 needed
 }
 
 void WaveForm::drawEditor()
 {
-    m_sliceEditor.fill(m_waveformBgColor);
-    QPainter brush(&m_sliceEditor);
-
-    float startFrame = m_seekerStart * m_currentSample.frames();
-    float endFrame = m_seekerEnd * m_currentSample.frames();
-    float numFramesToDraw = endFrame - startFrame;
-
-    // 0 centered line
-    brush.setPen(m_playHighlighColor);
-    brush.drawLine(0, m_editorHeight/2, m_editorWidth, m_editorHeight/2);
-
-    // draw waveform
-    brush.setPen(m_waveformColor);
-    m_currentSample.visualize(
-    brush,
-    QRect( 0, 0, m_editorWidth, m_editorHeight ),
-    startFrame, endFrame);
-
-    // draw slicepoints
-    brush.setPen(QPen(m_sliceColor, 2));
-    for (int i = 0;i<m_slicePoints.size();i++)
-    {
-        float xPos = (float)(m_slicePoints[i] - startFrame) / numFramesToDraw * m_editorWidth;
-
-        if (i == m_sliceSelected)
-        {
-            brush.setPen(QPen(m_selectedSliceColor, 2));
-        } else
-        {
-            brush.setPen(QPen(m_sliceColor, 2));
-        }
-
-        brush.drawLine(xPos, 0, xPos, m_editorHeight);
-        brush.drawPixmap(xPos - (float)m_sliceArrow.width()/2, 0, m_sliceArrow);
-    }
+	m_sliceEditor.fill(m_waveformBgColor);
+	QPainter brush(&m_sliceEditor);
+
+	float startFrame = m_seekerStart * m_currentSample.frames();
+	float endFrame = m_seekerEnd * m_currentSample.frames();
+	float numFramesToDraw = endFrame - startFrame;
+
+	// 0 centered line
+	brush.setPen(m_playHighlighColor);
+	brush.drawLine(0, m_editorHeight / 2, m_editorWidth, m_editorHeight / 2);
+
+	// draw waveform
+	brush.setPen(m_waveformColor);
+	m_currentSample.visualize(brush, QRect(0, 0, m_editorWidth, m_editorHeight), startFrame, endFrame);
+
+	// draw slicepoints
+	brush.setPen(QPen(m_sliceColor, 2));
+	for (int i = 0; i < m_slicePoints.size(); i++)
+	{
+		float xPos = (float)(m_slicePoints[i] - startFrame) / numFramesToDraw * m_editorWidth;
+
+		if (i == m_sliceSelected) { brush.setPen(QPen(m_selectedSliceColor, 2)); }
+		else { brush.setPen(QPen(m_sliceColor, 2)); }
+
+		brush.drawLine(xPos, 0, xPos, m_editorHeight);
+		brush.drawPixmap(xPos - (float)m_sliceArrow.width() / 2, 0, m_sliceArrow);
+	}
 }
 
 // slots
 void WaveForm::updateUI()
 {
-    drawSeekerWaveform();
-    drawSeeker();
-    drawEditor();
-    update();
+	drawSeekerWaveform();
+	drawSeeker();
+	drawEditor();
+	update();
 }
 
 void WaveForm::isPlaying(float current, float start, float end)
 {
-    m_noteCurrent = current;
-    m_noteStart = start;
-    m_noteEnd = end;
-    drawSeeker(); // only update seeker, else horrible performance
-    update();
+	m_noteCurrent = current;
+	m_noteStart = start;
+	m_noteEnd = end;
+	drawSeeker(); // only update seeker, else horrible performance
+	update();
 }
 
 // events
-void WaveForm::mousePressEvent( QMouseEvent * me )
+void WaveForm::mousePressEvent(QMouseEvent* me)
 {
-    float normalizedClickSeeker = (float)(me->x() - m_seekerHorMargin) / m_seekerWidth;
-    float normalizedClickEditor = (float)(me->x()) / m_editorWidth;
-    // reset seeker on middle click
-    if (me->button() == Qt::MouseButton::MiddleButton)
-    {
-        m_seekerStart = 0;
-        m_seekerEnd = 1;
-        return;
-    }
-
-    if (me->y() < m_seekerHeight) // seeker click
-    {
-        if (abs(normalizedClickSeeker - m_seekerStart) < distanceForClick) // dragging start
-        {
-            m_currentlyDragging = m_draggingTypes::m_seekerStart;
-        } else if (abs(normalizedClickSeeker - m_seekerEnd) < distanceForClick) // dragging end
-        {
-            m_currentlyDragging = m_draggingTypes::m_seekerEnd;
-
-        } else if (normalizedClickSeeker > m_seekerStart && normalizedClickSeeker < m_seekerEnd) // dragging middle
-        {
-            m_currentlyDragging = m_draggingTypes::m_seekerMiddle;
-            m_seekerMiddle = normalizedClickSeeker;
-        }
-    } else { // editor click
-        m_sliceSelected = -1;
-        float startFrame = m_seekerStart * m_currentSample.frames();
-        float endFrame = m_seekerEnd * m_currentSample.frames();
-        // select slice
-        for (int i = 0;i<m_slicePoints.size();i++)
-        {
-            int sliceIndex = m_slicePoints[i];
-            float xPos = (float)(sliceIndex - startFrame) / (float)(endFrame - startFrame);
-
-            if (abs(xPos - normalizedClickEditor) < distanceForClick)
-            {
-                m_currentlyDragging = m_draggingTypes::m_slicePoint;
-                m_sliceSelected = i;
-            }
-        }
-    }
-
-    if (me->button() == Qt::MouseButton::RightButton) // erase selected slice
-    {
-        if (m_sliceSelected != -1 && m_slicePoints.size() > 2)
-        {
-            m_slicePoints.erase(m_slicePoints.begin() + m_sliceSelected);
-            m_sliceSelected = -1;
-        }
-    }
-    updateUI();
+	float normalizedClickSeeker = (float)(me->x() - m_seekerHorMargin) / m_seekerWidth;
+	float normalizedClickEditor = (float)(me->x()) / m_editorWidth;
+	// reset seeker on middle click
+	if (me->button() == Qt::MouseButton::MiddleButton)
+	{
+		m_seekerStart = 0;
+		m_seekerEnd = 1;
+		return;
+	}
+
+	if (me->y() < m_seekerHeight) // seeker click
+	{
+		if (abs(normalizedClickSeeker - m_seekerStart) < distanceForClick) // dragging start
+		{
+			m_currentlyDragging = m_draggingTypes::m_seekerStart;
+		}
+		else if (abs(normalizedClickSeeker - m_seekerEnd) < distanceForClick) // dragging end
+		{
+			m_currentlyDragging = m_draggingTypes::m_seekerEnd;
+		}
+		else if (normalizedClickSeeker > m_seekerStart && normalizedClickSeeker < m_seekerEnd) // dragging middle
+		{
+			m_currentlyDragging = m_draggingTypes::m_seekerMiddle;
+			m_seekerMiddle = normalizedClickSeeker;
+		}
+	}
+	else
+	{ // editor click
+		m_sliceSelected = -1;
+		float startFrame = m_seekerStart * m_currentSample.frames();
+		float endFrame = m_seekerEnd * m_currentSample.frames();
+		// select slice
+		for (int i = 0; i < m_slicePoints.size(); i++)
+		{
+			int sliceIndex = m_slicePoints[i];
+			float xPos = (float)(sliceIndex - startFrame) / (float)(endFrame - startFrame);
+
+			if (abs(xPos - normalizedClickEditor) < distanceForClick)
+			{
+				m_currentlyDragging = m_draggingTypes::m_slicePoint;
+				m_sliceSelected = i;
+			}
+		}
+	}
+
+	if (me->button() == Qt::MouseButton::RightButton) // erase selected slice
+	{
+		if (m_sliceSelected != -1 && m_slicePoints.size() > 2)
+		{
+			m_slicePoints.erase(m_slicePoints.begin() + m_sliceSelected);
+			m_sliceSelected = -1;
+		}
+	}
+	updateUI();
 }
 
-void WaveForm::mouseReleaseEvent( QMouseEvent * me )
+void WaveForm::mouseReleaseEvent(QMouseEvent* me)
 {
-    m_currentlyDragging = m_draggingTypes::nothing;
-    updateUI();
+	m_currentlyDragging = m_draggingTypes::nothing;
+	updateUI();
 }
 
-void WaveForm::mouseMoveEvent( QMouseEvent * me )
+void WaveForm::mouseMoveEvent(QMouseEvent* me)
 {
-    float normalizedClickSeeker = (float)(me->x() - m_seekerHorMargin) / m_seekerWidth;
-    float normalizedClickEditor = (float)(me->x()) / m_editorWidth;
-
-    float distStart = m_seekerStart - m_seekerMiddle;
-    float distEnd = m_seekerEnd - m_seekerMiddle;
-    float startFrame = m_seekerStart * m_currentSample.frames();
-    float endFrame = m_seekerEnd * m_currentSample.frames();
-
-    // handle dragging events
-    switch (m_currentlyDragging)
-    {
-    case m_draggingTypes::m_seekerStart:
-        m_seekerStart = std::clamp(normalizedClickSeeker, 0.0f, m_seekerEnd - minSeekerDistance);
-        break;
-
-    case m_draggingTypes::m_seekerEnd:
-        m_seekerEnd = std::clamp(normalizedClickSeeker, m_seekerStart + minSeekerDistance, 1.0f);
-        break;
-
-    case m_draggingTypes::m_seekerMiddle:
-        m_seekerMiddle = normalizedClickSeeker;
-
-        if (m_seekerMiddle + distStart >= 0 && m_seekerMiddle + distEnd <= 1)
-        {
-            m_seekerStart = m_seekerMiddle + distStart;
-            m_seekerEnd = m_seekerMiddle + distEnd;
-        }
-        break;
-
-    case m_draggingTypes::m_slicePoint: // TODO: fix this
-        m_slicePoints[m_sliceSelected] = startFrame + normalizedClickEditor * (endFrame - startFrame);
-
-        m_slicePoints[m_sliceSelected] = std::clamp(m_slicePoints[m_sliceSelected], 0, m_currentSample.frames());
-
-        std::sort(m_slicePoints.begin(), m_slicePoints.end());
-        break;
-    case m_draggingTypes::nothing:
-        break;
-    }
-    updateUI();
+	float normalizedClickSeeker = (float)(me->x() - m_seekerHorMargin) / m_seekerWidth;
+	float normalizedClickEditor = (float)(me->x()) / m_editorWidth;
+
+	float distStart = m_seekerStart - m_seekerMiddle;
+	float distEnd = m_seekerEnd - m_seekerMiddle;
+	float startFrame = m_seekerStart * m_currentSample.frames();
+	float endFrame = m_seekerEnd * m_currentSample.frames();
+
+	// handle dragging events
+	switch (m_currentlyDragging)
+	{
+	case m_draggingTypes::m_seekerStart:
+		m_seekerStart = std::clamp(normalizedClickSeeker, 0.0f, m_seekerEnd - minSeekerDistance);
+		break;
+
+	case m_draggingTypes::m_seekerEnd:
+		m_seekerEnd = std::clamp(normalizedClickSeeker, m_seekerStart + minSeekerDistance, 1.0f);
+		break;
+
+	case m_draggingTypes::m_seekerMiddle:
+		m_seekerMiddle = normalizedClickSeeker;
+
+		if (m_seekerMiddle + distStart >= 0 && m_seekerMiddle + distEnd <= 1)
+		{
+			m_seekerStart = m_seekerMiddle + distStart;
+			m_seekerEnd = m_seekerMiddle + distEnd;
+		}
+		break;
+
+	case m_draggingTypes::m_slicePoint: // TODO: fix this
+		m_slicePoints[m_sliceSelected] = startFrame + normalizedClickEditor * (endFrame - startFrame);
+
+		m_slicePoints[m_sliceSelected] = std::clamp(m_slicePoints[m_sliceSelected], 0, m_currentSample.frames());
+
+		std::sort(m_slicePoints.begin(), m_slicePoints.end());
+		break;
+	case m_draggingTypes::nothing:
+		break;
+	}
+	updateUI();
 }
 
-void WaveForm::mouseDoubleClickEvent(QMouseEvent * me)
+void WaveForm::mouseDoubleClickEvent(QMouseEvent* me)
 {
-    float normalizedClickEditor = (float)(me->x()) / m_editorWidth;
-    float startFrame = m_seekerStart * m_currentSample.frames();
-    float endFrame = m_seekerEnd * m_currentSample.frames();
-
-    float slicePosition = startFrame + normalizedClickEditor * (endFrame - startFrame);
-
-    for (int i = 0;i<m_slicePoints.size();i++)
-    {
-        if (m_slicePoints[i] < slicePosition)
-        {
-            m_slicePoints.insert(m_slicePoints.begin() + i, slicePosition);
-            break;
-        }
-    }
-
-    std::sort(m_slicePoints.begin(), m_slicePoints.end());
+	float normalizedClickEditor = (float)(me->x()) / m_editorWidth;
+	float startFrame = m_seekerStart * m_currentSample.frames();
+	float endFrame = m_seekerEnd * m_currentSample.frames();
+
+	float slicePosition = startFrame + normalizedClickEditor * (endFrame - startFrame);
+
+	for (int i = 0; i < m_slicePoints.size(); i++)
+	{
+		if (m_slicePoints[i] < slicePosition)
+		{
+			m_slicePoints.insert(m_slicePoints.begin() + i, slicePosition);
+			break;
+		}
+	}
+
+	std::sort(m_slicePoints.begin(), m_slicePoints.end());
 }
 
-void WaveForm::paintEvent( QPaintEvent * pe)
+void WaveForm::paintEvent(QPaintEvent* pe)
 {
-    QPainter p( this );
-    p.drawPixmap(m_seekerHorMargin, 0 ,m_seekerWaveform);
-    p.drawPixmap(m_seekerHorMargin, 0, m_seeker);
-    p.drawPixmap(0, m_seekerHeight + m_middleMargin, m_sliceEditor);
+	QPainter p(this);
+	p.drawPixmap(m_seekerHorMargin, 0, m_seekerWaveform);
+	p.drawPixmap(m_seekerHorMargin, 0, m_seeker);
+	p.drawPixmap(0, m_seekerHeight + m_middleMargin, m_sliceEditor);
 }
 } // namespace gui
 } // namespace lmms
\ No newline at end of file
diff --git a/plugins/SlicerT/WaveForm.h b/plugins/SlicerT/WaveForm.h
index 461bc99601a..79bd236dbae 100644
--- a/plugins/SlicerT/WaveForm.h
+++ b/plugins/SlicerT/WaveForm.h
@@ -33,100 +33,96 @@
 
 #include "SampleBuffer.h"
 
-
-namespace lmms
-{
+namespace lmms {
 
 class SlicerT;
 
-namespace gui
-{
+namespace gui {
 
-
-class WaveForm : public QWidget {
-    	Q_OBJECT
-
-    protected:
-        virtual void mousePressEvent(QMouseEvent * me);
-        virtual void mouseReleaseEvent(QMouseEvent * me);
-        virtual void mouseMoveEvent(QMouseEvent * me);
-        virtual void mouseDoubleClickEvent(QMouseEvent * me);
-
-        virtual void paintEvent(QPaintEvent * pe);
-
-    private:
-        // vars used to control structure and colors
-        int m_width;
-        int m_height;
-
-        int m_seekerHorMargin = 5;
-        int m_seekerHeight = 38; // used to calcualte all hor sizes
-        int m_seekerWidth;
-
-        int m_middleMargin = 6;
-        int m_editorHeight;
-        int m_editorWidth;
-
-
-        QColor m_waveformBgColor = QColor(255, 255, 255, 0);
-        QColor m_waveformColor = QColor(123, 49, 212);
-        // QColor m_waveformColorDark = QColor(39, 15, 67);
-
-        // QColor m_waveformColor = QColor(255, 161, 247); // logo color
-        QColor m_playColor = QColor(255, 255, 255, 200);
-        QColor m_playHighlighColor = QColor(255, 255, 255, 70);
-        QColor m_sliceColor = QColor(218, 193, 255);
-        QColor m_selectedSliceColor = QColor(178, 153, 215);
-        QColor m_seekerColor = QColor(178, 115, 255);
-        QColor m_seekerHighlightColor = QColor(178, 115, 255, 100);
-        QColor m_seekerShadowColor = QColor(0, 0, 0, 120);
-
-        // interaction vars
-        float distanceForClick = 0.03f;
-        float minSeekerDistance = 0.13f;
-
-        // dragging vars
-        enum class m_draggingTypes
-        {
-            nothing,
-            m_seekerStart,
-            m_seekerEnd,
-            m_seekerMiddle,
-            m_slicePoint,
-        };
-        m_draggingTypes m_currentlyDragging;
-
-        // seeker vars
-        float m_seekerStart = 0;
-        float m_seekerEnd = 1;
-        float m_seekerMiddle = 0.5f;
-        int m_sliceSelected = 0;
-
-        // playback highlight vars
-        float m_noteCurrent;
-        float m_noteStart;
-        float m_noteEnd;
-
-        // pixmaps
-        QPixmap m_sliceArrow;
-        QPixmap m_seeker;
-        QPixmap m_seekerWaveform; // only stores waveform graphic
-        QPixmap m_sliceEditor;
-
-        SampleBuffer & m_currentSample;
-
-        SlicerT * m_slicerTParent;
-        std::vector<int> & m_slicePoints;
-
-        void drawEditor();
-        void drawSeekerWaveform();
-        void drawSeeker();
-    public slots:
-        void updateUI();
-        void isPlaying(float current, float start, float end);
-
-    public:
-        WaveForm(int w, int h, SlicerT * instrument, QWidget * parent);
+class WaveForm : public QWidget
+{
+	Q_OBJECT
+
+protected:
+	virtual void mousePressEvent(QMouseEvent* me);
+	virtual void mouseReleaseEvent(QMouseEvent* me);
+	virtual void mouseMoveEvent(QMouseEvent* me);
+	virtual void mouseDoubleClickEvent(QMouseEvent* me);
+
+	virtual void paintEvent(QPaintEvent* pe);
+
+private:
+	// vars used to control structure and colors
+	int m_width;
+	int m_height;
+
+	int m_seekerHorMargin = 5;
+	int m_seekerHeight = 38; // used to calcualte all hor sizes
+	int m_seekerWidth;
+
+	int m_middleMargin = 6;
+	int m_editorHeight;
+	int m_editorWidth;
+
+	QColor m_waveformBgColor = QColor(255, 255, 255, 0);
+	QColor m_waveformColor = QColor(123, 49, 212);
+	// QColor m_waveformColorDark = QColor(39, 15, 67);
+
+	// QColor m_waveformColor = QColor(255, 161, 247); // logo color
+	QColor m_playColor = QColor(255, 255, 255, 200);
+	QColor m_playHighlighColor = QColor(255, 255, 255, 70);
+	QColor m_sliceColor = QColor(218, 193, 255);
+	QColor m_selectedSliceColor = QColor(178, 153, 215);
+	QColor m_seekerColor = QColor(178, 115, 255);
+	QColor m_seekerHighlightColor = QColor(178, 115, 255, 100);
+	QColor m_seekerShadowColor = QColor(0, 0, 0, 120);
+
+	// interaction vars
+	float distanceForClick = 0.03f;
+	float minSeekerDistance = 0.13f;
+
+	// dragging vars
+	enum class m_draggingTypes
+	{
+		nothing,
+		m_seekerStart,
+		m_seekerEnd,
+		m_seekerMiddle,
+		m_slicePoint,
+	};
+	m_draggingTypes m_currentlyDragging;
+
+	// seeker vars
+	float m_seekerStart = 0;
+	float m_seekerEnd = 1;
+	float m_seekerMiddle = 0.5f;
+	int m_sliceSelected = 0;
+
+	// playback highlight vars
+	float m_noteCurrent;
+	float m_noteStart;
+	float m_noteEnd;
+
+	// pixmaps
+	QPixmap m_sliceArrow;
+	QPixmap m_seeker;
+	QPixmap m_seekerWaveform; // only stores waveform graphic
+	QPixmap m_sliceEditor;
+
+	SampleBuffer& m_currentSample;
+
+	SlicerT* m_slicerTParent;
+	std::vector<int>& m_slicePoints;
+
+	void drawEditor();
+	void drawSeekerWaveform();
+	void drawSeeker();
+public slots:
+	void updateUI();
+	void isPlaying(float current, float start, float end);
+
+public:
+	WaveForm(int w, int h, SlicerT* instrument, QWidget* parent);
 };
 } // namespace gui
 } // namespace lmms

From 0077806788214aea6b26738402e44c108960f187 Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Sat, 30 Sep 2023 17:42:14 +0200
Subject: [PATCH 34/99] slice snap + better defaults

---
 plugins/SlicerT/SlicerT.cpp   | 59 +++++++++++++++++++++++++----------
 plugins/SlicerT/SlicerT.h     |  1 +
 plugins/SlicerT/SlicerTUI.cpp |  5 +++
 plugins/SlicerT/SlicerTUI.h   |  2 ++
 plugins/SlicerT/WaveForm.cpp  | 10 ++++++
 5 files changed, 61 insertions(+), 16 deletions(-)

diff --git a/plugins/SlicerT/SlicerT.cpp b/plugins/SlicerT/SlicerT.cpp
index 891edb55550..ff497288c7c 100644
--- a/plugins/SlicerT/SlicerT.cpp
+++ b/plugins/SlicerT/SlicerT.cpp
@@ -25,10 +25,8 @@
 // TODO: fix some PV bugs
 // make fft size and windowsize seperate, pad window to fit into fft with 0
 // this should produce better quality hopefully
-// TODO: onset detection find valleys
 // TODO: switch to arrayVector (maybe)
 // TODO: cleaunp UI classes
-// TODO: add text when no sample loaded
 // TODO: better buttons
 
 #include "SlicerT.h"
@@ -273,12 +271,21 @@ void PhaseVocoder::generateWindow(int windowNum, bool useCache)
 
 SlicerT::SlicerT(InstrumentTrack* instrumentTrack)
 	: Instrument(instrumentTrack, &slicert_plugin_descriptor)
-	, m_noteThreshold(0.3f, 0.0f, 2.0f, 0.01f, this, tr("Note threshold"))
+	, m_noteThreshold(0.6f, 0.0f, 2.0f, 0.01f, this, tr("Note threshold"))
 	, m_fadeOutFrames(400.0f, 0.0f, 8192.0f, 1.0f, this, tr("FadeOut"))
 	, m_originalBPM(1, 1, 999, this, tr("Original bpm"))
+	, m_sliceSnap(this, tr("Slice snap"))
 	, m_originalSample()
 	, m_phaseVocoder()
 {
+	m_sliceSnap.addItem("None");
+	m_sliceSnap.addItem("1/1");
+	m_sliceSnap.addItem("1/2");
+	m_sliceSnap.addItem("1/4");
+	m_sliceSnap.addItem("1/8");
+	m_sliceSnap.addItem("1/16");
+	m_sliceSnap.addItem("1/32");
+	m_sliceSnap.setValue(0);
 }
 
 void SlicerT::playNote(NotePlayHandle* handle, sampleFrame* workingBuffer)
@@ -291,8 +298,8 @@ void SlicerT::playNote(NotePlayHandle* handle, sampleFrame* workingBuffer)
 	const fpp_t frames = handle->framesLeftForCurrentPeriod();
 	const f_cnt_t offset = handle->noteOffset();
 	const int playedFrames = handle->totalFramesPlayed();
-	m_phaseVocoder.setScaleRatio(speedRatio);
 
+	m_phaseVocoder.setScaleRatio(speedRatio); // check if bpm changed
 	const int totalFrames = m_phaseVocoder.frames();
 
 	int sliceStart, sliceEnd;
@@ -349,34 +356,35 @@ void SlicerT::findSlices()
 {
 	if (m_originalSample.frames() < 2048) { return; }
 	m_slicePoints = {};
-	const int windowSize = 1024;
-	const int minDist = 2048;
 
-	std::vector<float> leftChannel(m_originalSample.frames(), 0);
+	const int windowSize = 512;
+	const int minDist = 2048; // this value should probably be calculated through samplerate or something
+
+	std::vector<float> singleChannel(m_originalSample.frames(), 0);
 
 	for (int i = 0; i < m_originalSample.frames(); i++)
 	{
-		leftChannel[i] = m_originalSample.data()[i][0];
+		singleChannel[i] = (m_originalSample.data()[i][0] + m_originalSample.data()[i][1]) / 2;
 	}
 
-	std::vector<float> prevMags(windowSize, 0);
+	std::vector<float> prevMags(windowSize / 2, 0);
 	std::vector<float> fftIn(windowSize, 0);
 	fftwf_complex fftOut[windowSize];
 
 	fftwf_plan fftPlan = fftwf_plan_dft_r2c_1d(windowSize, fftIn.data(), fftOut, FFTW_MEASURE);
 
-	int lastPoint = -minDist - 1;
+	int lastPoint = -minDist - 1; // to always store 0 first
 	float spectralFlux = 0;
 	float prevFlux = 0;
 	float real, imag, magnitude, diff;
 
-	for (int i = 0; i < leftChannel.size() - windowSize; i += windowSize)
+	for (int i = 0; i < singleChannel.size() - windowSize; i += windowSize)
 	{
-		memcpy(fftIn.data(), leftChannel.data() + i, windowSize * sizeof(float));
+		memcpy(fftIn.data(), singleChannel.data() + i, windowSize * sizeof(float));
 		fftwf_execute(fftPlan);
 
-		for (int j = 0; j < windowSize / 2; j++)
-		{ // only use niquistic frequencies
+		for (int j = 0; j < windowSize / 2; j++) // only use niquistic frequencies
+		{
 			real = fftOut[j][0];
 			imag = fftOut[j][1];
 			magnitude = sqrt(real * real + imag * imag);
@@ -399,6 +407,25 @@ void SlicerT::findSlices()
 
 	m_slicePoints.push_back(m_originalSample.frames());
 
+	int noteLock = m_sliceSnap.value(); // 1 / notelock; is to which note is locked
+	int timeSignature = Engine::getSong()->getTimeSigModel().getNumerator();
+	int samplesPerBar = 60.0f * timeSignature / m_originalBPM.value() * m_originalSample.sampleRate();
+	int sliceLock = samplesPerBar / pow(2, noteLock + 1);
+	if (noteLock == 0) { sliceLock = 1; } // disable notelock
+
+	for (int i = 0; i < m_slicePoints.size(); i++)
+	{
+		m_slicePoints[i] += sliceLock / 2;
+		m_slicePoints[i] -= m_slicePoints[i] % sliceLock;
+	}
+
+	// set to fit
+	m_slicePoints[0] = 0;
+	m_slicePoints[m_slicePoints.size()] = m_originalSample.frames();
+
+	// remove duplicates
+	m_slicePoints.erase(std::unique(m_slicePoints.begin(), m_slicePoints.end()), m_slicePoints.end());
+
 	emit dataChanged();
 }
 
@@ -466,7 +493,7 @@ void SlicerT::writeToMidi(std::vector<Note>* outClip)
 		Note sliceNote = Note();
 		sliceNote.setKey(i + 69);
 		sliceNote.setPos(sliceStart);
-		sliceNote.setLength(sliceEnd - sliceStart);
+		sliceNote.setLength(sliceEnd - sliceStart + 1); // + 1 needed for whatever reason
 		outClip->push_back(sliceNote);
 
 		lastEnd = sliceEnd;
@@ -478,8 +505,8 @@ void SlicerT::updateFile(QString file)
 	m_originalSample.setAudioFile(file);
 	if (m_originalSample.frames() < 2048) { return; }
 
-	findSlices();
 	findBPM();
+	findSlices();
 
 	float speedRatio = (float)m_originalBPM.value() / Engine::getSong()->getTempo();
 	m_phaseVocoder.loadSample(
diff --git a/plugins/SlicerT/SlicerT.h b/plugins/SlicerT/SlicerT.h
index ebb0fee0f61..e276cacbd3a 100644
--- a/plugins/SlicerT/SlicerT.h
+++ b/plugins/SlicerT/SlicerT.h
@@ -172,6 +172,7 @@ public slots:
 	FloatModel m_noteThreshold;
 	FloatModel m_fadeOutFrames;
 	IntModel m_originalBPM;
+	ComboBoxModel m_sliceSnap;
 
 	SampleBuffer m_originalSample;
 	dinamicPlaybackBuffer m_phaseVocoder;
diff --git a/plugins/SlicerT/SlicerTUI.cpp b/plugins/SlicerT/SlicerTUI.cpp
index c0d79ae8e0e..12fccdd638e 100644
--- a/plugins/SlicerT/SlicerTUI.cpp
+++ b/plugins/SlicerT/SlicerTUI.cpp
@@ -47,6 +47,7 @@ SlicerTUI::SlicerTUI(SlicerT* instrument, QWidget* parent)
 	, m_noteThresholdKnob(this)
 	, m_fadeOutKnob(this)
 	, m_bpmBox(3, "21pink", this)
+	, m_snapSetting(this, "Slice snap")
 	, m_resetButton(this, nullptr)
 	, m_midiExportButton(this, nullptr)
 	, m_wf(248, 128, instrument, this)
@@ -60,6 +61,10 @@ SlicerTUI::SlicerTUI(SlicerT* instrument, QWidget* parent)
 
 	m_wf.move(2, 6);
 
+	m_snapSetting.setGeometry(14, 150, 55, ComboBox::DEFAULT_HEIGHT);
+	m_snapSetting.setToolTip(tr("Set slice snapping for detection"));
+	m_snapSetting.setModel(&m_slicerTParent->m_sliceSnap);
+
 	m_bpmBox.move(135, 200);
 	m_bpmBox.setToolTip(tr("Original sample BPM"));
 	m_bpmBox.setLabel(tr("BPM"));
diff --git a/plugins/SlicerT/SlicerTUI.h b/plugins/SlicerT/SlicerTUI.h
index d83f679932f..b028fc7c2de 100644
--- a/plugins/SlicerT/SlicerTUI.h
+++ b/plugins/SlicerT/SlicerTUI.h
@@ -27,6 +27,7 @@
 
 #include <QPushButton>
 
+#include "ComboBox.h"
 #include "Instrument.h"
 #include "InstrumentView.h"
 #include "Knob.h"
@@ -80,6 +81,7 @@ protected slots:
 	SlicerTKnob m_noteThresholdKnob;
 	SlicerTKnob m_fadeOutKnob;
 	LcdSpinBox m_bpmBox;
+	ComboBox m_snapSetting;
 
 	PixmapButton m_resetButton;
 	PixmapButton m_midiExportButton;
diff --git a/plugins/SlicerT/WaveForm.cpp b/plugins/SlicerT/WaveForm.cpp
index 28e568de3fa..275e7c11d9f 100644
--- a/plugins/SlicerT/WaveForm.cpp
+++ b/plugins/SlicerT/WaveForm.cpp
@@ -81,6 +81,8 @@ void WaveForm::drawSeeker()
 {
 	m_seeker.fill(m_waveformBgColor);
 	QPainter brush(&m_seeker);
+
+	// if (m_currentSample.frames() < 2048) { return; }
 	// draw slice points
 	brush.setPen(m_sliceColor);
 	for (int i = 0; i < m_slicePoints.size(); i++)
@@ -115,6 +117,14 @@ void WaveForm::drawEditor()
 	m_sliceEditor.fill(m_waveformBgColor);
 	QPainter brush(&m_sliceEditor);
 
+	if (m_currentSample.frames() < 2048)
+	{
+		brush.setPen(m_playHighlighColor);
+		brush.drawText(
+			m_editorWidth / 2 - 100, m_editorHeight / 2 - 100, 200, 200, Qt::AlignCenter, tr("Drag sample to load"));
+		return;
+	}
+
 	float startFrame = m_seekerStart * m_currentSample.frames();
 	float endFrame = m_seekerEnd * m_currentSample.frames();
 	float numFramesToDraw = endFrame - startFrame;

From 0ed6237de1a808e07ecdc4d0c73e36fbb3024ec8 Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Sat, 30 Sep 2023 17:46:36 +0200
Subject: [PATCH 35/99] windows build fixes

---
 include/Clipboard.h         | 59 +++++++++++++++++++------------------
 plugins/SlicerT/SlicerT.cpp | 14 +++++----
 2 files changed, 38 insertions(+), 35 deletions(-)

diff --git a/include/Clipboard.h b/include/Clipboard.h
index c6ae66ee873..03793fa2ce4 100644
--- a/include/Clipboard.h
+++ b/include/Clipboard.h
@@ -25,46 +25,47 @@
 #ifndef LMMS_CLIPBOARD_H
 #define LMMS_CLIPBOARD_H
 
-#include <QMap>
 #include <QDomElement>
+#include <QMap>
+
+#include "lmms_export.h"
 
 class QMimeData;
 
-namespace lmms::Clipboard
-{
+namespace lmms::Clipboard {
 
-	enum class MimeType
-	{
-		StringPair,
-		Default
-	};
+enum class MimeType
+{
+	StringPair,
+	Default
+};
 
-	// Convenience Methods
-	const QMimeData * getMimeData();
-	bool hasFormat( MimeType mT );
+// Convenience Methods
+const QMimeData* getMimeData();
+bool hasFormat(MimeType mT);
 
-	// Helper methods for String data
-	void copyString( const QString & str, MimeType mT );
-	QString getString( MimeType mT );
+// Helper methods for String data
+void copyString(const QString& str, MimeType mT);
+QString getString(MimeType mT);
 
-	// Helper methods for String Pair data
-	void copyStringPair( const QString & key, const QString & value );
-	QString decodeKey( const QMimeData * mimeData );
-	QString decodeValue( const QMimeData * mimeData );
+// Helper methods for String Pair data
+void copyStringPair(const QString& key, const QString& value);
+QString decodeKey(const QMimeData* mimeData);
+QString decodeValue(const QMimeData* mimeData);
 
-	inline const char * mimeType( MimeType type )
+inline const char* mimeType(MimeType type)
+{
+	switch (type)
 	{
-		switch( type )
-		{
-			case MimeType::StringPair:
-				return "application/x-lmms-stringpair";
-			break;
-			case MimeType::Default:
-			default:
-				return "application/x-lmms-clipboard";
-				break;
-		}
+	case MimeType::StringPair:
+		return "application/x-lmms-stringpair";
+		break;
+	case MimeType::Default:
+	default:
+		return "application/x-lmms-clipboard";
+		break;
 	}
+}
 
 } // namespace lmms::Clipboard
 
diff --git a/plugins/SlicerT/SlicerT.cpp b/plugins/SlicerT/SlicerT.cpp
index ff497288c7c..442facadd00 100644
--- a/plugins/SlicerT/SlicerT.cpp
+++ b/plugins/SlicerT/SlicerT.cpp
@@ -33,12 +33,14 @@
 
 #include <QDomElement>
 #include <fftw3.h>
+#include <math.h>
 
 #include "Engine.h"
 #include "InstrumentTrack.h"
 #include "PathUtil.h"
 #include "Song.h"
 #include "embed.h"
+#include "lmms_constants.h"
 #include "plugin_export.h"
 
 namespace lmms {
@@ -144,8 +146,8 @@ void PhaseVocoder::updateParams(float newRatio)
 	numWindows = (float)originalBuffer.size() / stepSize - overSampling - 1;
 	outStepSize = m_scaleRatio * (float)stepSize; // float, else inaccurate
 	freqPerBin = originalSampleRate / windowSize;
-	expectedPhaseIn = 2. * M_PI * (float)stepSize / (float)windowSize;
-	expectedPhaseOut = 2. * M_PI * (float)outStepSize / (float)windowSize;
+	expectedPhaseIn = 2. * F_PI * (float)stepSize / (float)windowSize;
+	expectedPhaseOut = 2. * F_PI * (float)outStepSize / (float)windowSize;
 
 	processedBuffer.resize(m_scaleRatio * originalBuffer.size(), 0);
 
@@ -196,9 +198,9 @@ void PhaseVocoder::generateWindow(int windowNum, bool useCache)
 			freq -= (float)j * expectedPhaseIn; // subtract expected phase
 
 			// this puts freq in 0-2pi
-			freq = fmod(freq + M_PI, -2.0f * M_PI) + M_PI;
+			freq = fmod(freq + F_PI, -2.0f * F_PI) + F_PI;
 
-			freq = (float)overSampling * freq / (2. * M_PI); // idk
+			freq = (float)overSampling * freq / (2. * F_PI); // idk
 
 			freq = (float)j * freqPerBin + freq * freqPerBin; // "compute the k-th partials' true frequency" ok i guess
 
@@ -226,7 +228,7 @@ void PhaseVocoder::generateWindow(int windowNum, bool useCache)
 
 		deltaPhase /= freqPerBin;
 
-		deltaPhase = 2. * M_PI * deltaPhase / overSampling;
+		deltaPhase = 2. * F_PI * deltaPhase / overSampling;
 
 		deltaPhase += (float)j * expectedPhaseOut;
 
@@ -262,7 +264,7 @@ void PhaseVocoder::generateWindow(int windowNum, bool useCache)
 		// (float)overSampling/totalWindowOverlap*IFFTReconstruction[j]/(windowSize/2.0f*overSampling);
 		// printf("timeshifted in phase: %f\n", m_timeshiftedBufferL[outIndex]);
 		// continuos windowing
-		float window = -0.5f * cos(2. * M_PI * (float)j / (float)windowSize) + 0.5f;
+		float window = -0.5f * cos(2. * F_PI * (float)j / (float)windowSize) + 0.5f;
 		processedBuffer[outIndex] += window * IFFTReconstruction[j] / (windowSize / 2.0f * overSampling);
 	}
 }

From c91e4a42a1074c736574973b1cacaab00c930491 Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Sun, 1 Oct 2023 01:05:06 +0200
Subject: [PATCH 36/99] windows build fixes part 2

---
 include/Clipboard.h | 55 +++++++++++++++++++++++----------------------
 1 file changed, 28 insertions(+), 27 deletions(-)

diff --git a/include/Clipboard.h b/include/Clipboard.h
index 03793fa2ce4..491f8ebf748 100644
--- a/include/Clipboard.h
+++ b/include/Clipboard.h
@@ -32,40 +32,41 @@
 
 class QMimeData;
 
-namespace lmms::Clipboard {
-
-enum class MimeType
+namespace lmms::Clipboard
 {
-	StringPair,
-	Default
-};
 
-// Convenience Methods
-const QMimeData* getMimeData();
-bool hasFormat(MimeType mT);
+	enum class MimeType
+	{
+		StringPair,
+		Default
+	};
+
+	// Convenience Methods
+	const QMimeData * getMimeData();
+	bool hasFormat( MimeType mT );
 
-// Helper methods for String data
-void copyString(const QString& str, MimeType mT);
-QString getString(MimeType mT);
+	// Helper methods for String data
+	void LMMS_EXPORT copyString( const QString & str, MimeType mT );
+	QString getString( MimeType mT );
 
-// Helper methods for String Pair data
-void copyStringPair(const QString& key, const QString& value);
-QString decodeKey(const QMimeData* mimeData);
-QString decodeValue(const QMimeData* mimeData);
+	// Helper methods for String Pair data
+	void copyStringPair( const QString & key, const QString & value );
+	QString decodeKey( const QMimeData * mimeData );
+	QString decodeValue( const QMimeData * mimeData );
 
-inline const char* mimeType(MimeType type)
-{
-	switch (type)
+	inline const char * mimeType( MimeType type )
 	{
-	case MimeType::StringPair:
-		return "application/x-lmms-stringpair";
-		break;
-	case MimeType::Default:
-	default:
-		return "application/x-lmms-clipboard";
-		break;
+		switch( type )
+		{
+			case MimeType::StringPair:
+				return "application/x-lmms-stringpair";
+			break;
+			case MimeType::Default:
+			default:
+				return "application/x-lmms-clipboard";
+				break;
+		}
 	}
-}
 
 } // namespace lmms::Clipboard
 

From 7f6d7fd391af41958e0664d15f174d92effd3cc3 Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Sun, 1 Oct 2023 20:29:56 +0200
Subject: [PATCH 37/99] Fixed slice bug + Waveform code cleanup

---
 plugins/SlicerT/SlicerT.cpp  | 20 +++++++++++---------
 plugins/SlicerT/WaveForm.cpp | 29 +++++++++++++++++------------
 2 files changed, 28 insertions(+), 21 deletions(-)

diff --git a/plugins/SlicerT/SlicerT.cpp b/plugins/SlicerT/SlicerT.cpp
index 442facadd00..6e70e649268 100644
--- a/plugins/SlicerT/SlicerT.cpp
+++ b/plugins/SlicerT/SlicerT.cpp
@@ -22,11 +22,6 @@
  *
  */
 
-// TODO: fix some PV bugs
-// make fft size and windowsize seperate, pad window to fit into fft with 0
-// this should produce better quality hopefully
-// TODO: switch to arrayVector (maybe)
-// TODO: cleaunp UI classes
 // TODO: better buttons
 
 #include "SlicerT.h"
@@ -421,13 +416,20 @@ void SlicerT::findSlices()
 		m_slicePoints[i] -= m_slicePoints[i] % sliceLock;
 	}
 
-	// set to fit
-	m_slicePoints[0] = 0;
-	m_slicePoints[m_slicePoints.size()] = m_originalSample.frames();
-
 	// remove duplicates
 	m_slicePoints.erase(std::unique(m_slicePoints.begin(), m_slicePoints.end()), m_slicePoints.end());
 
+	// fit to sample size
+	m_slicePoints[0] = 0;
+	m_slicePoints[m_slicePoints.size()-1] = m_originalSample.frames();
+
+	for (int i = 0; i < m_slicePoints.size(); i++) {
+		printf("%i \n", m_slicePoints[i]);
+	}
+
+
+	printf("total frames: %i\n", m_originalSample.frames());
+
 	emit dataChanged();
 }
 
diff --git a/plugins/SlicerT/WaveForm.cpp b/plugins/SlicerT/WaveForm.cpp
index 275e7c11d9f..3f74bfb1dc5 100644
--- a/plugins/SlicerT/WaveForm.cpp
+++ b/plugins/SlicerT/WaveForm.cpp
@@ -91,25 +91,31 @@ void WaveForm::drawSeeker()
 		brush.drawLine(xPos, 0, xPos, m_seekerHeight);
 	}
 
-	// this is a complete mess, TODO: cleanup
+	// seeker vars
+	float seekerStartPosX = m_seekerStart * m_seekerWidth;
+	float seekerEndPosX = m_seekerEnd * m_seekerWidth;
+	float seekerMiddleWidth = (m_seekerEnd - m_seekerStart) * m_seekerWidth;
+
+	// note playback vars
+	float noteCurrentPosX = m_noteCurrent * m_seekerWidth;
+	float noteStartPosX = m_noteStart * m_seekerWidth;
+	float noteEndPosX = (m_noteEnd - m_noteStart) * m_seekerWidth;
+
 	// draw current playBack
 	brush.setPen(m_playColor);
-	brush.drawLine(m_noteCurrent * m_seekerWidth, 0, m_noteCurrent * m_seekerWidth, m_seekerHeight);
-	brush.fillRect(
-		m_noteStart * m_seekerWidth, 0, (m_noteEnd - m_noteStart) * m_seekerWidth, m_seekerHeight, m_playHighlighColor);
+	brush.drawLine(noteCurrentPosX, 0, noteCurrentPosX, m_seekerHeight);
+	brush.fillRect(noteStartPosX, 0, noteEndPosX, m_seekerHeight, m_playHighlighColor);
 
 	// highlight on selected area
-	brush.fillRect(m_seekerStart * m_seekerWidth, 0, (m_seekerEnd - m_seekerStart) * m_seekerWidth, m_seekerHeight,
-		m_seekerHighlightColor);
+	brush.fillRect(seekerStartPosX, 0, seekerMiddleWidth, m_seekerHeight, m_seekerHighlightColor);
 
 	// shadow on not selected area
-	brush.fillRect(0, 0, m_seekerStart * m_seekerWidth, m_seekerHeight, m_seekerShadowColor);
-	brush.fillRect(m_seekerEnd * m_seekerWidth + 1, 0, m_seekerWidth + 1, m_seekerHeight, m_seekerShadowColor);
+	brush.fillRect(0, 0, seekerStartPosX, m_seekerHeight, m_seekerShadowColor);
+	brush.fillRect(seekerEndPosX + 1, 0, m_seekerWidth + 1, m_seekerHeight, m_seekerShadowColor);
 
 	// draw border around selection
 	brush.setPen(QPen(m_seekerColor, 1));
-	brush.drawRoundedRect(m_seekerStart * m_seekerWidth, 0, (m_seekerEnd - m_seekerStart) * m_seekerWidth - 1,
-		m_seekerHeight - 1, 4, 4); // -1 needed
+	brush.drawRoundedRect(seekerStartPosX, 0, seekerMiddleWidth - 1, m_seekerHeight - 1, 4, 4); // -1 needed
 }
 
 void WaveForm::drawEditor()
@@ -231,6 +237,7 @@ void WaveForm::mousePressEvent(QMouseEvent* me)
 void WaveForm::mouseReleaseEvent(QMouseEvent* me)
 {
 	m_currentlyDragging = m_draggingTypes::nothing;
+	std::sort(m_slicePoints.begin(), m_slicePoints.end());
 	updateUI();
 }
 
@@ -269,8 +276,6 @@ void WaveForm::mouseMoveEvent(QMouseEvent* me)
 		m_slicePoints[m_sliceSelected] = startFrame + normalizedClickEditor * (endFrame - startFrame);
 
 		m_slicePoints[m_sliceSelected] = std::clamp(m_slicePoints[m_sliceSelected], 0, m_currentSample.frames());
-
-		std::sort(m_slicePoints.begin(), m_slicePoints.end());
 		break;
 	case m_draggingTypes::nothing:
 		break;

From ea75dccd0407223a48c05908419366513c4613f0 Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Sun, 1 Oct 2023 21:48:40 +0200
Subject: [PATCH 38/99] UI button text + reorder + file cleanup

---
 plugins/SlicerT/SlicerT.cpp              |   2 --
 plugins/SlicerT/SlicerTUI.cpp            |  22 ++++++++++++++--------
 plugins/SlicerT/WaveForm.cpp             |   1 +
 plugins/SlicerT/bg_no_logo.png           | Bin 16125 -> 0 bytes
 plugins/SlicerT/copyMidi.png             | Bin 0 -> 4249 bytes
 plugins/SlicerT/knob_center.png          | Bin 6455 -> 0 bytes
 plugins/SlicerT/resetSlices.png          | Bin 0 -> 493 bytes
 plugins/SlicerT/slide_indicator_bar.png  | Bin 197 -> 0 bytes
 plugins/SlicerT/slide_indicator_full.png | Bin 290 -> 0 bytes
 9 files changed, 15 insertions(+), 10 deletions(-)
 delete mode 100644 plugins/SlicerT/bg_no_logo.png
 create mode 100644 plugins/SlicerT/copyMidi.png
 delete mode 100644 plugins/SlicerT/knob_center.png
 create mode 100644 plugins/SlicerT/resetSlices.png
 delete mode 100644 plugins/SlicerT/slide_indicator_bar.png
 delete mode 100644 plugins/SlicerT/slide_indicator_full.png

diff --git a/plugins/SlicerT/SlicerT.cpp b/plugins/SlicerT/SlicerT.cpp
index 6e70e649268..4f46f12653a 100644
--- a/plugins/SlicerT/SlicerT.cpp
+++ b/plugins/SlicerT/SlicerT.cpp
@@ -22,8 +22,6 @@
  *
  */
 
-// TODO: better buttons
-
 #include "SlicerT.h"
 
 #include <QDomElement>
diff --git a/plugins/SlicerT/SlicerTUI.cpp b/plugins/SlicerT/SlicerTUI.cpp
index 12fccdd638e..e91953dbb78 100644
--- a/plugins/SlicerT/SlicerTUI.cpp
+++ b/plugins/SlicerT/SlicerTUI.cpp
@@ -61,11 +61,11 @@ SlicerTUI::SlicerTUI(SlicerT* instrument, QWidget* parent)
 
 	m_wf.move(2, 6);
 
-	m_snapSetting.setGeometry(14, 150, 55, ComboBox::DEFAULT_HEIGHT);
+	m_snapSetting.setGeometry(190, 200, 55, ComboBox::DEFAULT_HEIGHT);
 	m_snapSetting.setToolTip(tr("Set slice snapping for detection"));
 	m_snapSetting.setModel(&m_slicerTParent->m_sliceSnap);
 
-	m_bpmBox.move(135, 200);
+	m_bpmBox.move(135, 203);
 	m_bpmBox.setToolTip(tr("Original sample BPM"));
 	m_bpmBox.setLabel(tr("BPM"));
 	m_bpmBox.setModel(&m_slicerTParent->m_originalBPM);
@@ -80,15 +80,15 @@ SlicerTUI::SlicerTUI(SlicerT* instrument, QWidget* parent)
 	m_fadeOutKnob.setLabel(tr("FadeOut"));
 	m_fadeOutKnob.setModel(&m_slicerTParent->m_fadeOutFrames);
 
-	m_midiExportButton.move(190, 200);
-	m_midiExportButton.setActiveGraphic(embed::getIconPixmap("midi_tab"));
-	m_midiExportButton.setInactiveGraphic(embed::getIconPixmap("midi_tab"));
+	m_midiExportButton.move(205, 155);
+	m_midiExportButton.setActiveGraphic(PLUGIN_NAME::getIconPixmap("copyMidi"));
+	m_midiExportButton.setInactiveGraphic(PLUGIN_NAME::getIconPixmap("copyMidi"));
 	m_midiExportButton.setToolTip(tr("Copy midi pattern to clipboard"));
 	connect(&m_midiExportButton, SIGNAL(clicked()), this, SLOT(exportMidi()));
 
-	m_resetButton.move(215, 200);
-	m_resetButton.setActiveGraphic(embed::getIconPixmap("reload"));
-	m_resetButton.setInactiveGraphic(embed::getIconPixmap("reload"));
+	m_resetButton.move(25, 155);
+	m_resetButton.setActiveGraphic(PLUGIN_NAME::getIconPixmap("resetSlices"));
+	m_resetButton.setInactiveGraphic(PLUGIN_NAME::getIconPixmap("resetSlices"));
 	m_resetButton.setToolTip(tr("Reset Slices"));
 	connect(&m_resetButton, SIGNAL(clicked()), m_slicerTParent, SLOT(updateSlices()));
 }
@@ -161,6 +161,12 @@ void SlicerTUI::dropEvent(QDropEvent* de)
 
 void SlicerTUI::paintEvent(QPaintEvent* pe)
 {
+	QPainter brush(this);
+	brush.setPen(QColor(255, 255, 255));
+	brush.setFont(QFont(brush.font().family(), 7.5f, -1, false));
+	brush.drawText(205, 170, 20, 20, Qt::AlignCenter, tr("Midi"));
+	brush.drawText(22, 170, 25, 20, Qt::AlignCenter, tr("Reset"));
+	brush.drawText(190, 217, 55, 20, Qt::AlignCenter, tr("Snap"));
 }
 
 } // namespace gui
diff --git a/plugins/SlicerT/WaveForm.cpp b/plugins/SlicerT/WaveForm.cpp
index 3f74bfb1dc5..934756f306e 100644
--- a/plugins/SlicerT/WaveForm.cpp
+++ b/plugins/SlicerT/WaveForm.cpp
@@ -126,6 +126,7 @@ void WaveForm::drawEditor()
 	if (m_currentSample.frames() < 2048)
 	{
 		brush.setPen(m_playHighlighColor);
+		brush.setFont(QFont(brush.font().family(), 9.0f, -1, false));
 		brush.drawText(
 			m_editorWidth / 2 - 100, m_editorHeight / 2 - 100, 200, 200, Qt::AlignCenter, tr("Drag sample to load"));
 		return;
diff --git a/plugins/SlicerT/bg_no_logo.png b/plugins/SlicerT/bg_no_logo.png
deleted file mode 100644
index b017cc9f28f88c8dec2d517f970c800efbff5596..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 16125
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
aMsaqnwE353-F&44O+`UdzF5}s<^KY@cnlB#

diff --git a/plugins/SlicerT/copyMidi.png b/plugins/SlicerT/copyMidi.png
new file mode 100644
index 0000000000000000000000000000000000000000..e2ef15199bc9cf6d1c16938d9187bb18f23770a2
GIT binary patch
literal 4249
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

literal 0
HcmV?d00001

diff --git a/plugins/SlicerT/knob_center.png b/plugins/SlicerT/knob_center.png
deleted file mode 100644
index f74e202309025859bc4de2bd7498f0f20154d9c2..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 6455
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

diff --git a/plugins/SlicerT/resetSlices.png b/plugins/SlicerT/resetSlices.png
new file mode 100644
index 0000000000000000000000000000000000000000..15de6cdc18fccc8bc7b0e7e01fe4b44dea8be677
GIT binary patch
literal 493
zcmV<J0TTX+P)<h;3K|Lk000e1NJLTq000yK000yS1^@s6jfou%00004b3#c}2nYxW
zd<bNS00009a7bBm000fw000fw0YWI7cmMzZ8FWQhbW?9;ba!ELWdL_~cP?peYja~^
zaAhuUa%Y?FJQ@H10cuG^K~y-6t(2io13?gmziVnL@IBKrT^x!&KrskJ4T1m(hAK?a
zAh?7CMS>-vmXaVUnmzyy0|Ltik~Q2Lw1U7OI!%|$-36MPWU}Jl{r2D8nGNcVCS^vY
zR2opt6B1`vfjwYd6X02M5Ju+Jn;VCbi2<lLn!i#+0uebDk%{ETMCSw|5{rn;*H=@n
z0$>bm0Rr3rBXxy3?Eqci3OE8x(UE%!`vCUC$ULO<F)&V?9q2|Tr7s>u@9aXIWx@Pt
z11njA|H`{S4d@ra5@%!JEKm23+|qGW;0%4uI8XN-`lYdSlwR0A&@YWYMdIvc;;baj
zK4t-*bnN`Y(1DJ_EZ`k51-gl|?LWBN0Cs@yOrZAW2@n9cMbO0A7I4q3N>0Pbyv?=1
z|GqL>ug{|OzJN7#b*N^BVPv-b&4ToQsL&p>uBqjioC4>-Wf+;yLZAmue_s{gMe{n0
j%zM_lT;Q@%dSU+nYpk5`^k80=00000NkvXXu0mjf#CFZh

literal 0
HcmV?d00001

diff --git a/plugins/SlicerT/slide_indicator_bar.png b/plugins/SlicerT/slide_indicator_bar.png
deleted file mode 100644
index b17a644e8209f839c61ff3c99b33338ef541eef5..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 197
zcmeAS@N?(olHy`uVBq!ia0vp^OhD|<!3HD`7Kls(Qfx`y?k)`cAo$=z8AzJ5z$3Dl
zfk96hgc&QA+Lr+Z*-JcqUD=;=3W{>*=^Qfk1qw-)xJHyX=jZ08=9Mrw7o{eaq^2m8
zXO?6rxO@5rgg5eu0~P6dx;TbtoKJqUV#fFRjg1fGg_)U|ohPI#2@5le^ccBGHqSYD
i=)i#w`FFql<YAa_iNktn(nArTMg~t;KbLh*2~7YJnKobm

diff --git a/plugins/SlicerT/slide_indicator_full.png b/plugins/SlicerT/slide_indicator_full.png
deleted file mode 100644
index aa8a24844482bd4326c7f869161837eb5e8243cd..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 290
zcmeAS@N?(olHy`uVBq!ia0vp^96%hx!3HGvJD0HoDYhhUcNYeJ5Pa~Vj0q^hS>O>_
z%)p?h48n{ROYO^mg6t)pzOL-gIR!;I6i!!3cmahZOI#yLobz*YQ}ap~oQqNuOHxx5
z$}>wc6x=<11Hv2m#DR*sJY5_^JdP)CN%H*le&xIa4ZJyf?7AB}8yOO;zNO1Op2$Ai
zP=)W_{R0Kh?hCo8v9YnW&5hqJxqgog+w?tu9!VUYmtWf>u}f&lvcLWlW_^>7>|vd`
zSn&A40|yR#=wHZulJ~_jmP)ln9fIGEu4oEmUCiYs+M^{AYOpFH<lu^?gR2@?d;jO(
e{q|FXi9vpWQnLNFh7O>s7(8A5T-G@yGywo1mt=?l


From dd60d6953d433a17a66fa58d65a78c9f74efd837 Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Sun, 1 Oct 2023 23:21:01 +0200
Subject: [PATCH 39/99] Added knob colors

---
 data/themes/default/style.css | 8 ++++++++
 plugins/SlicerT/SlicerT.cpp   | 2 +-
 plugins/SlicerT/SlicerTUI.h   | 4 ----
 3 files changed, 9 insertions(+), 5 deletions(-)

diff --git a/data/themes/default/style.css b/data/themes/default/style.css
index 092332eee65..2b875f47ebe 100644
--- a/data/themes/default/style.css
+++ b/data/themes/default/style.css
@@ -946,6 +946,14 @@ lmms--gui--SidInstrumentView lmms--gui--Knob {
 	qproperty-lineWidth: 2;
 }
 
+lmms--gui--SlicerTUI lmms--gui--Knob {
+	color: rgb(162, 128, 226);
+	qproperty-outerColor: rgb( 162, 128, 226 );
+	qproperty-innerRadius: 1;
+	qproperty-outerRadius: 11;
+	qproperty-lineWidth: 3;
+}
+
 lmms--gui--WatsynView lmms--gui--Knob {
 	qproperty-innerRadius: 1;
 	qproperty-outerRadius: 7;
diff --git a/plugins/SlicerT/SlicerT.cpp b/plugins/SlicerT/SlicerT.cpp
index 4f46f12653a..2830c63d5d6 100644
--- a/plugins/SlicerT/SlicerT.cpp
+++ b/plugins/SlicerT/SlicerT.cpp
@@ -273,7 +273,7 @@ SlicerT::SlicerT(InstrumentTrack* instrumentTrack)
 	, m_originalSample()
 	, m_phaseVocoder()
 {
-	m_sliceSnap.addItem("None");
+	m_sliceSnap.addItem("Off");
 	m_sliceSnap.addItem("1/1");
 	m_sliceSnap.addItem("1/2");
 	m_sliceSnap.addItem("1/4");
diff --git a/plugins/SlicerT/SlicerTUI.h b/plugins/SlicerT/SlicerTUI.h
index b028fc7c2de..7bced0b2e04 100644
--- a/plugins/SlicerT/SlicerTUI.h
+++ b/plugins/SlicerT/SlicerTUI.h
@@ -50,10 +50,6 @@ class SlicerTKnob : public Knob
 		setFixedSize(46, 40);
 		setCenterPointX(23.0);
 		setCenterPointY(15.0);
-		setInnerRadius(3);
-		setOuterRadius(11);
-		setLineWidth(3);
-		setOuterColor(QColor(178, 115, 255));
 	}
 };
 

From 79d6f47c3e739c1ba2662a3b97993d820a2ec4c6 Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Mon, 2 Oct 2023 22:43:57 +0200
Subject: [PATCH 40/99] comments + code cleanup

---
 plugins/SlicerT/SlicerT.cpp   | 101 ++++++++++++++++++----------------
 plugins/SlicerT/SlicerT.h     |   9 ++-
 plugins/SlicerT/SlicerTUI.cpp |  10 ++++
 plugins/SlicerT/SlicerTUI.h   |   5 +-
 plugins/SlicerT/WaveForm.cpp  |  18 +++---
 plugins/SlicerT/WaveForm.h    |  10 ++--
 6 files changed, 89 insertions(+), 64 deletions(-)

diff --git a/plugins/SlicerT/SlicerT.cpp b/plugins/SlicerT/SlicerT.cpp
index 2830c63d5d6..6dc5edc674f 100644
--- a/plugins/SlicerT/SlicerT.cpp
+++ b/plugins/SlicerT/SlicerT.cpp
@@ -87,11 +87,12 @@ void PhaseVocoder::loadData(std::vector<float> originalData, int sampleRate, flo
 	freqCache.resize(numWindows * windowSize, 0);
 	magCache.resize(numWindows * windowSize, 0);
 
+	// maybe limit this to a set amount of windows to reduce initial lag spikes
 	for (int i = 0; i < numWindows; i++)
 	{
 		if (!m_processedWindows[i])
 		{
-			generateWindow(i, false);
+			generateWindow(i, false); // first pass, no cache
 			m_processedWindows[i] = true;
 		}
 	}
@@ -113,7 +114,7 @@ void PhaseVocoder::getFrames(std::vector<float>& outData, int start, int frames)
 	{
 		if (!m_processedWindows[i])
 		{
-			generateWindow(i, true);
+			generateWindow(i, true); // theses should use the cache
 			m_processedWindows[i] = true;
 		}
 	}
@@ -126,14 +127,13 @@ void PhaseVocoder::getFrames(std::vector<float>& outData, int start, int frames)
 	dataLock.unlock();
 }
 
-// adjust pv params and reset buffers
+// adjust pv params buffers to a new scale ratio
 void PhaseVocoder::updateParams(float newRatio)
 {
 	if (originalBuffer.size() < 2048) { return; }
-	if (newRatio == m_scaleRatio) { return; }
+	if (newRatio == m_scaleRatio) { return; } // nothing changed
 	dataLock.lock();
 
-	// TODO: remove static stuff from here, like stepsize
 	m_scaleRatio = newRatio;
 	stepSize = (float)windowSize / overSampling;
 	numWindows = (float)originalBuffer.size() / stepSize - overSampling - 1;
@@ -147,7 +147,8 @@ void PhaseVocoder::updateParams(float newRatio)
 	// very slow :(
 	std::fill(m_processedWindows.begin(), m_processedWindows.end(), false);
 	std::fill(processedBuffer.begin(), processedBuffer.end(), 0);
-	// somehow this works if this is commented, idk why but its faster
+	// this can be commented, since the start phase is not importante to the PV
+	// and the sum phase will grow linearly anyway
 	// std::fill(lastPhase.begin(), lastPhase.end(), 0);
 	// std::fill(sumPhase.begin(), sumPhase.end(), 0);
 
@@ -183,19 +184,25 @@ void PhaseVocoder::generateWindow(int windowNum, bool useCache)
 			magnitude = 2. * sqrt(real * real + imag * imag);
 			phase = atan2(imag, real);
 
+			// calculate difference in phase with prev window
 			freq = phase;
 			freq = phase
 				- lastPhase[std::max(0, windowIndex + j - windowSize)]; // subtract prev pahse to get phase diference
 			lastPhase[windowIndex + j] = phase;
 
 			freq -= (float)j * expectedPhaseIn; // subtract expected phase
+			// at this point, freq is the difference in phase
+			// between the last phase, having removed the expected phase at this point in the sample
 
-			// this puts freq in 0-2pi
+			// this puts freq in 0-2pi. Since the phase difference is proportional to the deviation in bin frequency,
+			// with this we can better estimate the true frequency
 			freq = fmod(freq + F_PI, -2.0f * F_PI) + F_PI;
 
-			freq = (float)overSampling * freq / (2. * F_PI); // idk
+			// convert phase difference into bin freq mulitplier
+			freq = (float)overSampling * freq / (2. * F_PI);
 
-			freq = (float)j * freqPerBin + freq * freqPerBin; // "compute the k-th partials' true frequency" ok i guess
+			// add to the expected freq the change in freq calculated from the phase diff
+			freq = (float)j * freqPerBin + freq * freqPerBin;
 
 			allMagnitudes[j] = magnitude;
 			allFrequencies[j] = freq;
@@ -217,14 +224,19 @@ void PhaseVocoder::generateWindow(int windowNum, bool useCache)
 		magnitude = allMagnitudes[j];
 		freq = allFrequencies[j];
 
+		// difference in freq
 		deltaPhase = freq - (float)j * freqPerBin;
 
+		// scaled to 1
 		deltaPhase /= freqPerBin;
 
+		// difference in phase
 		deltaPhase = 2. * F_PI * deltaPhase / overSampling;
 
+		// add the expected phase
 		deltaPhase += (float)j * expectedPhaseOut;
 
+		// sum this phase to the total, to keep track of the out phase along the sample
 		sumPhase[windowIndex + j] += deltaPhase;
 		deltaPhase = sumPhase[windowIndex + j]; // this is the bin phase
 		if (windowIndex + j + windowSize < sumPhase.size())
@@ -245,18 +257,7 @@ void PhaseVocoder::generateWindow(int windowNum, bool useCache)
 		float outIndex = windowNum * outStepSize + j;
 		if (outIndex >= frames()) { break; }
 
-		// calculate windows overlapping at index
-		// float startWindowOverlap = ceil(outIndex / outStepSize + 0.00000001f);
-		// float endWindowOverlap = ceil((float)(-outIndex + dataOut.size()) / outStepSize + 0.00000001f);
-		// float totalWindowOverlap = std::min(
-		// 							std::min(startWindowOverlap, endWindowOverlap),
-		// 							(float)overSampling);
-
-		// discrete windowing
-		// dataOut[outIndex] +=
-		// (float)overSampling/totalWindowOverlap*IFFTReconstruction[j]/(windowSize/2.0f*overSampling);
-		// printf("timeshifted in phase: %f\n", m_timeshiftedBufferL[outIndex]);
-		// continuos windowing
+		// hann windowing
 		float window = -0.5f * cos(2. * F_PI * (float)j / (float)windowSize) + 0.5f;
 		processedBuffer[outIndex] += window * IFFTReconstruction[j] / (windowSize / 2.0f * overSampling);
 	}
@@ -280,25 +281,26 @@ SlicerT::SlicerT(InstrumentTrack* instrumentTrack)
 	m_sliceSnap.addItem("1/8");
 	m_sliceSnap.addItem("1/16");
 	m_sliceSnap.addItem("1/32");
-	m_sliceSnap.setValue(0);
+	m_sliceSnap.setValue(0); // no snap by default
 }
 
 void SlicerT::playNote(NotePlayHandle* handle, sampleFrame* workingBuffer)
 {
 	if (m_originalSample.frames() < 2048) { return; }
 
+	// update current speed ratio, in case bpm changed
 	const float speedRatio = (float)m_originalBPM.value() / Engine::getSong()->getTempo();
+	m_phaseVocoder.setScaleRatio(speedRatio);
 
+	// current playback status
+	const int totalFrames = m_phaseVocoder.frames();
 	const int noteIndex = handle->key() - 69;
 	const fpp_t frames = handle->framesLeftForCurrentPeriod();
 	const f_cnt_t offset = handle->noteOffset();
 	const int playedFrames = handle->totalFramesPlayed();
 
-	m_phaseVocoder.setScaleRatio(speedRatio); // check if bpm changed
-	const int totalFrames = m_phaseVocoder.frames();
-
 	int sliceStart, sliceEnd;
-	if (noteIndex > m_slicePoints.size() - 2 || noteIndex < 0)
+	if (noteIndex > m_slicePoints.size() - 2 || noteIndex < 0) // full sample if ouside range
 	{
 		sliceStart = 0;
 		sliceEnd = totalFrames;
@@ -309,6 +311,7 @@ void SlicerT::playNote(NotePlayHandle* handle, sampleFrame* workingBuffer)
 		sliceEnd = m_slicePoints[noteIndex + 1] * speedRatio;
 	}
 
+	// slice vars
 	int sliceFrames = sliceEnd - sliceStart;
 	int currentNoteFrame = sliceStart + playedFrames;
 	int noteFramesLeft = sliceFrames - playedFrames;
@@ -352,16 +355,18 @@ void SlicerT::findSlices()
 	if (m_originalSample.frames() < 2048) { return; }
 	m_slicePoints = {};
 
+	// computacion params
 	const int windowSize = 512;
-	const int minDist = 2048; // this value should probably be calculated through samplerate or something
+	const int minDist = 2048;
 
+	// copy vector into one vector, averaging channels
 	std::vector<float> singleChannel(m_originalSample.frames(), 0);
-
 	for (int i = 0; i < m_originalSample.frames(); i++)
 	{
 		singleChannel[i] = (m_originalSample.data()[i][0] + m_originalSample.data()[i][1]) / 2;
 	}
 
+	// buffers
 	std::vector<float> prevMags(windowSize / 2, 0);
 	std::vector<float> fftIn(windowSize, 0);
 	fftwf_complex fftOut[windowSize];
@@ -375,21 +380,25 @@ void SlicerT::findSlices()
 
 	for (int i = 0; i < singleChannel.size() - windowSize; i += windowSize)
 	{
+		// fft
 		memcpy(fftIn.data(), singleChannel.data() + i, windowSize * sizeof(float));
 		fftwf_execute(fftPlan);
 
+		// calculate spectral flux in regard to last window
 		for (int j = 0; j < windowSize / 2; j++) // only use niquistic frequencies
 		{
 			real = fftOut[j][0];
 			imag = fftOut[j][1];
 			magnitude = sqrt(real * real + imag * imag);
 
+			// using L2-norm (euclidean distance)
 			diff = sqrt(pow(magnitude - prevMags[j], 2));
 			spectralFlux += diff;
 
 			prevMags[j] = magnitude;
 		}
 
+		// detect increases in flux
 		if (spectralFlux / prevFlux > 1.0f + m_noteThreshold.value() && i - lastPoint > minDist)
 		{
 			m_slicePoints.push_back(i);
@@ -402,11 +411,12 @@ void SlicerT::findSlices()
 
 	m_slicePoints.push_back(m_originalSample.frames());
 
-	int noteLock = m_sliceSnap.value(); // 1 / notelock; is to which note is locked
+	// snap slices to notes
+	int noteSnap = m_sliceSnap.value();
 	int timeSignature = Engine::getSong()->getTimeSigModel().getNumerator();
 	int samplesPerBar = 60.0f * timeSignature / m_originalBPM.value() * m_originalSample.sampleRate();
-	int sliceLock = samplesPerBar / pow(2, noteLock + 1);
-	if (noteLock == 0) { sliceLock = 1; } // disable notelock
+	int sliceLock = samplesPerBar / pow(2, noteSnap + 1); // lock to note: 1 / noteSnap²
+	if (noteSnap == 0) { sliceLock = 1; }				  // disable noteSnap
 
 	for (int i = 0; i < m_slicePoints.size(); i++)
 	{
@@ -421,13 +431,7 @@ void SlicerT::findSlices()
 	m_slicePoints[0] = 0;
 	m_slicePoints[m_slicePoints.size()-1] = m_originalSample.frames();
 
-	for (int i = 0; i < m_slicePoints.size(); i++) {
-		printf("%i \n", m_slicePoints[i]);
-	}
-
-
-	printf("total frames: %i\n", m_originalSample.frames());
-
+	// update UI
 	emit dataChanged();
 }
 
@@ -436,7 +440,6 @@ void SlicerT::findSlices()
 void SlicerT::findBPM()
 {
 	if (m_originalSample.frames() < 2048) { return; }
-	int bpmSnap = 1; // 1 = disabled
 
 	// caclulate length of sample
 	float sampleRate = m_originalSample.sampleRate();
@@ -446,7 +449,7 @@ void SlicerT::findBPM()
 	// this assumes the sample has a time signature of x/4
 	float bpmEstimate = 240.0f / sampleLength;
 
-	// deal with samlpes that are not 1 bar long
+	// get into 100 - 200 range
 	while (bpmEstimate < 100)
 	{
 		bpmEstimate *= 2;
@@ -457,13 +460,8 @@ void SlicerT::findBPM()
 		bpmEstimate /= 2;
 	}
 
-	// snap bpm
-	int bpm = bpmEstimate;
-	bpm += (float)bpmSnap / 2;
-	bpm -= bpm % bpmSnap;
-
-	m_originalBPM.setValue(bpm);
-	m_originalBPM.setInitValue(bpm);
+	m_originalBPM.setValue(bpmEstimate);
+	m_originalBPM.setInitValue(bpmEstimate);
 }
 
 void SlicerT::writeToMidi(std::vector<Note>* outClip)
@@ -487,6 +485,7 @@ void SlicerT::writeToMidi(std::vector<Note>* outClip)
 
 	float lastEnd = 0;
 
+	// write to midi
 	for (int i = 0; i < m_slicePoints.size() - 1; i++)
 	{
 		float sliceStart = lastEnd;
@@ -524,6 +523,7 @@ void SlicerT::updateSlices()
 
 void SlicerT::saveSettings(QDomDocument& document, QDomElement& element)
 {
+	// save sample
 	element.setAttribute("src", m_originalSample.audioFile());
 	if (m_originalSample.audioFile().isEmpty())
 	{
@@ -531,13 +531,14 @@ void SlicerT::saveSettings(QDomDocument& document, QDomElement& element)
 		element.setAttribute("sampledata", m_originalSample.toBase64(s));
 	}
 
+	// save slice points
 	element.setAttribute("totalSlices", (int)m_slicePoints.size());
-
 	for (int i = 0; i < m_slicePoints.size(); i++)
 	{
 		element.setAttribute(tr("slice_%1").arg(i), m_slicePoints[i]);
 	}
 
+	// save knobs
 	m_fadeOutFrames.saveSettings(document, element, "fadeOut");
 	m_noteThreshold.saveSettings(document, element, "threshold");
 	m_originalBPM.saveSettings(document, element, "origBPM");
@@ -545,6 +546,7 @@ void SlicerT::saveSettings(QDomDocument& document, QDomElement& element)
 
 void SlicerT::loadSettings(const QDomElement& element)
 {
+	// load sample
 	if (!element.attribute("src").isEmpty())
 	{
 		m_originalSample.setAudioFile(element.attribute("src"));
@@ -561,6 +563,7 @@ void SlicerT::loadSettings(const QDomElement& element)
 		m_originalSample.loadFromBase64(element.attribute("srcdata"));
 	}
 
+	// load slices
 	if (!element.attribute("totalSlices").isEmpty())
 	{
 		int totalSlices = element.attribute("totalSlices").toInt();
@@ -571,10 +574,12 @@ void SlicerT::loadSettings(const QDomElement& element)
 		}
 	}
 
+	// load knobs
 	m_fadeOutFrames.loadSettings(element, "fadeOut");
 	m_noteThreshold.loadSettings(element, "threshold");
 	m_originalBPM.loadSettings(element, "origBPM");
 
+	// create dinamic buffer
 	float speedRatio = (float)m_originalBPM.value() / Engine::getSong()->getTempo();
 	m_phaseVocoder.loadSample(
 		m_originalSample.data(), m_originalSample.frames(), m_originalSample.sampleRate(), speedRatio);
diff --git a/plugins/SlicerT/SlicerT.h b/plugins/SlicerT/SlicerT.h
index e276cacbd3a..fc860ad3968 100644
--- a/plugins/SlicerT/SlicerT.h
+++ b/plugins/SlicerT/SlicerT.h
@@ -42,9 +42,12 @@ class PhaseVocoder
 public:
 	PhaseVocoder();
 	~PhaseVocoder();
+
 	void loadData(std::vector<float> originalData, int sampleRate, float newRatio);
 	void setScaleRatio(float newRatio) { updateParams(newRatio); }
+
 	void getFrames(std::vector<float>& outData, int start, int frames);
+
 	int frames() { return processedBuffer.size(); }
 	float scaleRatio() { return m_scaleRatio; }
 
@@ -54,10 +57,10 @@ class PhaseVocoder
 	std::vector<float> originalBuffer;
 	int originalSampleRate = 0;
 
-	float m_scaleRatio = -1; // to force on fisrt load
+	float m_scaleRatio = -1; // to force on first load
 
 	// output data
-	std::vector<float> processedBuffer;
+	std::vector<float> processedBuffer; // final output
 	std::vector<bool> m_processedWindows; // marks a window processed
 
 	// timeshift stuff
@@ -169,11 +172,13 @@ public slots:
 	void isPlaying(float current, float start, float end);
 
 private:
+	// models
 	FloatModel m_noteThreshold;
 	FloatModel m_fadeOutFrames;
 	IntModel m_originalBPM;
 	ComboBoxModel m_sliceSnap;
 
+	// sample buffers
 	SampleBuffer m_originalSample;
 	dinamicPlaybackBuffer m_phaseVocoder;
 
diff --git a/plugins/SlicerT/SlicerTUI.cpp b/plugins/SlicerT/SlicerTUI.cpp
index e91953dbb78..0f5fe93a7ba 100644
--- a/plugins/SlicerT/SlicerTUI.cpp
+++ b/plugins/SlicerT/SlicerTUI.cpp
@@ -52,40 +52,49 @@ SlicerTUI::SlicerTUI(SlicerT* instrument, QWidget* parent)
 	, m_midiExportButton(this, nullptr)
 	, m_wf(248, 128, instrument, this)
 {
+	// window settings
 	setAcceptDrops(true);
 	setAutoFillBackground(true);
 
+	// render background
 	QPalette pal;
 	pal.setBrush(backgroundRole(), PLUGIN_NAME::getIconPixmap("bg"));
 	setPalette(pal);
 
+	// move editor and seeker
 	m_wf.move(2, 6);
 
+	// snap combo box
 	m_snapSetting.setGeometry(190, 200, 55, ComboBox::DEFAULT_HEIGHT);
 	m_snapSetting.setToolTip(tr("Set slice snapping for detection"));
 	m_snapSetting.setModel(&m_slicerTParent->m_sliceSnap);
 
+	// bpm spin box
 	m_bpmBox.move(135, 203);
 	m_bpmBox.setToolTip(tr("Original sample BPM"));
 	m_bpmBox.setLabel(tr("BPM"));
 	m_bpmBox.setModel(&m_slicerTParent->m_originalBPM);
 
+	// threshold knob
 	m_noteThresholdKnob.move(14, 195);
 	m_noteThresholdKnob.setToolTip(tr("Threshold used for slicing"));
 	m_noteThresholdKnob.setLabel(tr("Threshold"));
 	m_noteThresholdKnob.setModel(&m_slicerTParent->m_noteThreshold);
 
+	// fadeout knob
 	m_fadeOutKnob.move(80, 195);
 	m_fadeOutKnob.setToolTip(tr("FadeOut for notes"));
 	m_fadeOutKnob.setLabel(tr("FadeOut"));
 	m_fadeOutKnob.setModel(&m_slicerTParent->m_fadeOutFrames);
 
+	// midi copy button
 	m_midiExportButton.move(205, 155);
 	m_midiExportButton.setActiveGraphic(PLUGIN_NAME::getIconPixmap("copyMidi"));
 	m_midiExportButton.setInactiveGraphic(PLUGIN_NAME::getIconPixmap("copyMidi"));
 	m_midiExportButton.setToolTip(tr("Copy midi pattern to clipboard"));
 	connect(&m_midiExportButton, SIGNAL(clicked()), this, SLOT(exportMidi()));
 
+	// slcie reset button
 	m_resetButton.move(25, 155);
 	m_resetButton.setActiveGraphic(PLUGIN_NAME::getIconPixmap("resetSlices"));
 	m_resetButton.setInactiveGraphic(PLUGIN_NAME::getIconPixmap("resetSlices"));
@@ -159,6 +168,7 @@ void SlicerTUI::dropEvent(QDropEvent* de)
 	de->ignore();
 }
 
+// display button text
 void SlicerTUI::paintEvent(QPaintEvent* pe)
 {
 	QPainter brush(this);
diff --git a/plugins/SlicerT/SlicerTUI.h b/plugins/SlicerT/SlicerTUI.h
index 7bced0b2e04..adcc1d0ef2b 100644
--- a/plugins/SlicerT/SlicerTUI.h
+++ b/plugins/SlicerT/SlicerTUI.h
@@ -41,6 +41,7 @@ class SlicerT;
 
 namespace gui {
 
+// style knob, defined in data/themes/default/style.css#L949
 class SlicerTKnob : public Knob
 {
 public:
@@ -59,11 +60,9 @@ class SlicerTUI : public InstrumentViewFixedSize
 
 public:
 	SlicerTUI(SlicerT* instrument, QWidget* parent);
-	~SlicerTUI() override = default;
 
 protected slots:
 	void exportMidi();
-	// void sampleSizeChanged( float _new_sample_length );
 
 protected:
 	virtual void dragEnterEvent(QDragEnterEvent* _dee);
@@ -74,11 +73,13 @@ protected slots:
 private:
 	SlicerT* m_slicerTParent;
 
+	// lmms UI
 	SlicerTKnob m_noteThresholdKnob;
 	SlicerTKnob m_fadeOutKnob;
 	LcdSpinBox m_bpmBox;
 	ComboBox m_snapSetting;
 
+	// buttons
 	PixmapButton m_resetButton;
 	PixmapButton m_midiExportButton;
 
diff --git a/plugins/SlicerT/WaveForm.cpp b/plugins/SlicerT/WaveForm.cpp
index 934756f306e..9a6fc7072aa 100644
--- a/plugins/SlicerT/WaveForm.cpp
+++ b/plugins/SlicerT/WaveForm.cpp
@@ -54,19 +54,21 @@ WaveForm::WaveForm(int w, int h, SlicerT* instrument, QWidget* parent)
 	, m_slicePoints(instrument->m_slicePoints)
 
 {
+	// window config
 	setFixedSize(m_width, m_height);
 	setMouseTracking(true);
 
+	// draw backgrounds
 	m_sliceEditor.fill(m_waveformBgColor);
 	m_seekerWaveform.fill(m_waveformBgColor);
 
+	// connect to playback
 	connect(m_slicerTParent, SIGNAL(isPlaying(float, float, float)), this, SLOT(isPlaying(float, float, float)));
 	connect(m_slicerTParent, SIGNAL(dataChanged()), this, SLOT(updateUI()));
 
 	updateUI();
 }
 
-// graphics
 void WaveForm::drawSeekerWaveform()
 {
 	m_seekerWaveform.fill(m_waveformBgColor);
@@ -82,7 +84,6 @@ void WaveForm::drawSeeker()
 	m_seeker.fill(m_waveformBgColor);
 	QPainter brush(&m_seeker);
 
-	// if (m_currentSample.frames() < 2048) { return; }
 	// draw slice points
 	brush.setPen(m_sliceColor);
 	for (int i = 0; i < m_slicePoints.size(); i++)
@@ -123,6 +124,7 @@ void WaveForm::drawEditor()
 	m_sliceEditor.fill(m_waveformBgColor);
 	QPainter brush(&m_sliceEditor);
 
+	// draw text if no sample loaded
 	if (m_currentSample.frames() < 2048)
 	{
 		brush.setPen(m_playHighlighColor);
@@ -132,6 +134,7 @@ void WaveForm::drawEditor()
 		return;
 	}
 
+	// editor boundaries
 	float startFrame = m_seekerStart * m_currentSample.frames();
 	float endFrame = m_seekerEnd * m_currentSample.frames();
 	float numFramesToDraw = endFrame - startFrame;
@@ -158,7 +161,6 @@ void WaveForm::drawEditor()
 	}
 }
 
-// slots
 void WaveForm::updateUI()
 {
 	drawSeekerWaveform();
@@ -172,7 +174,7 @@ void WaveForm::isPlaying(float current, float start, float end)
 	m_noteCurrent = current;
 	m_noteStart = start;
 	m_noteEnd = end;
-	drawSeeker(); // only update seeker, else horrible performance
+	drawSeeker(); // only update seeker, else horrible performance because of waveform redraw
 	update();
 }
 
@@ -205,8 +207,8 @@ void WaveForm::mousePressEvent(QMouseEvent* me)
 			m_seekerMiddle = normalizedClickSeeker;
 		}
 	}
-	else
-	{ // editor click
+	else // editor click
+	{
 		m_sliceSelected = -1;
 		float startFrame = m_seekerStart * m_currentSample.frames();
 		float endFrame = m_seekerEnd * m_currentSample.frames();
@@ -239,6 +241,7 @@ void WaveForm::mouseReleaseEvent(QMouseEvent* me)
 {
 	m_currentlyDragging = m_draggingTypes::nothing;
 	std::sort(m_slicePoints.begin(), m_slicePoints.end());
+
 	updateUI();
 }
 
@@ -273,9 +276,8 @@ void WaveForm::mouseMoveEvent(QMouseEvent* me)
 		}
 		break;
 
-	case m_draggingTypes::m_slicePoint: // TODO: fix this
+	case m_draggingTypes::m_slicePoint:
 		m_slicePoints[m_sliceSelected] = startFrame + normalizedClickEditor * (endFrame - startFrame);
-
 		m_slicePoints[m_sliceSelected] = std::clamp(m_slicePoints[m_sliceSelected], 0, m_currentSample.frames());
 		break;
 	case m_draggingTypes::nothing:
diff --git a/plugins/SlicerT/WaveForm.h b/plugins/SlicerT/WaveForm.h
index 79bd236dbae..ede26749d52 100644
--- a/plugins/SlicerT/WaveForm.h
+++ b/plugins/SlicerT/WaveForm.h
@@ -52,27 +52,28 @@ class WaveForm : public QWidget
 	virtual void paintEvent(QPaintEvent* pe);
 
 private:
-	// vars used to control structure and colors
+	// sizes
 	int m_width;
 	int m_height;
 
 	int m_seekerHorMargin = 5;
-	int m_seekerHeight = 38; // used to calcualte all hor sizes
+	int m_seekerHeight = 38; // used to calcualte all vertical sizes
 	int m_seekerWidth;
 
 	int m_middleMargin = 6;
 	int m_editorHeight;
 	int m_editorWidth;
 
+	// colors
 	QColor m_waveformBgColor = QColor(255, 255, 255, 0);
 	QColor m_waveformColor = QColor(123, 49, 212);
-	// QColor m_waveformColorDark = QColor(39, 15, 67);
 
-	// QColor m_waveformColor = QColor(255, 161, 247); // logo color
 	QColor m_playColor = QColor(255, 255, 255, 200);
 	QColor m_playHighlighColor = QColor(255, 255, 255, 70);
+
 	QColor m_sliceColor = QColor(218, 193, 255);
 	QColor m_selectedSliceColor = QColor(178, 153, 215);
+
 	QColor m_seekerColor = QColor(178, 115, 255);
 	QColor m_seekerHighlightColor = QColor(178, 115, 255, 100);
 	QColor m_seekerShadowColor = QColor(0, 0, 0, 120);
@@ -117,6 +118,7 @@ class WaveForm : public QWidget
 	void drawEditor();
 	void drawSeekerWaveform();
 	void drawSeeker();
+
 public slots:
 	void updateUI();
 	void isPlaying(float current, float start, float end);

From 2a06101726c1eb78f5814337dfc6a3be622135ad Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Mon, 2 Oct 2023 23:02:05 +0200
Subject: [PATCH 41/99] var names fit convention

---
 plugins/SlicerT/SlicerT.cpp  | 150 +++++++++++++++++------------------
 plugins/SlicerT/SlicerT.h    |  76 +++++++++---------
 plugins/SlicerT/WaveForm.cpp |  10 +--
 plugins/SlicerT/WaveForm.h   |   4 +-
 4 files changed, 120 insertions(+), 120 deletions(-)

diff --git a/plugins/SlicerT/SlicerT.cpp b/plugins/SlicerT/SlicerT.cpp
index 6dc5edc674f..9ce4f499232 100644
--- a/plugins/SlicerT/SlicerT.cpp
+++ b/plugins/SlicerT/SlicerT.cpp
@@ -53,42 +53,42 @@ Plugin::Descriptor PLUGIN_EXPORT slicert_plugin_descriptor = {
 } // end extern
 
 PhaseVocoder::PhaseVocoder()
-	: FFTInput(windowSize, 0)
-	, IFFTReconstruction(windowSize, 0)
-	, allMagnitudes(windowSize, 0)
-	, allFrequencies(windowSize, 0)
-	, processedFreq(windowSize, 0)
-	, processedMagn(windowSize, 0)
+	: m_FFTInput(s_windowSize, 0)
+	, m_IFFTReconstruction(s_windowSize, 0)
+	, m_allMagnitudes(s_windowSize, 0)
+	, m_allFrequencies(s_windowSize, 0)
+	, m_processedFreq(s_windowSize, 0)
+	, m_processedMagn(s_windowSize, 0)
 {
-	fftPlan = fftwf_plan_dft_r2c_1d(windowSize, FFTInput.data(), FFTSpectrum, FFTW_MEASURE);
-	ifftPlan = fftwf_plan_dft_c2r_1d(windowSize, FFTSpectrum, IFFTReconstruction.data(), FFTW_MEASURE);
+	m_fftPlan = fftwf_plan_dft_r2c_1d(s_windowSize, m_FFTInput.data(), m_FFTSpectrum, FFTW_MEASURE);
+	m_ifftPlan = fftwf_plan_dft_c2r_1d(s_windowSize, m_FFTSpectrum, m_IFFTReconstruction.data(), FFTW_MEASURE);
 }
 
 PhaseVocoder::~PhaseVocoder()
 {
-	fftwf_destroy_plan(fftPlan);
-	fftwf_destroy_plan(ifftPlan);
+	fftwf_destroy_plan(m_fftPlan);
+	fftwf_destroy_plan(m_ifftPlan);
 }
 
 void PhaseVocoder::loadData(std::vector<float> originalData, int sampleRate, float newRatio)
 {
-	originalBuffer = originalData;
-	originalSampleRate = sampleRate;
+	m_originalBuffer = originalData;
+	m_originalSampleRate = sampleRate;
 	m_scaleRatio = -1; // force update, kinda hacky
 
 	updateParams(newRatio);
 
-	dataLock.lock();
+	m_dataLock.lock();
 
 	// set buffer sizes
-	m_processedWindows.resize(numWindows, false);
-	lastPhase.resize(numWindows * windowSize, 0);
-	sumPhase.resize(numWindows * windowSize, 0);
-	freqCache.resize(numWindows * windowSize, 0);
-	magCache.resize(numWindows * windowSize, 0);
+	m_processedWindows.resize(m_numWindows, false);
+	m_lastPhase.resize(m_numWindows * s_windowSize, 0);
+	m_sumPhase.resize(m_numWindows * s_windowSize, 0);
+	m_freqCache.resize(m_numWindows * s_windowSize, 0);
+	m_magCache.resize(m_numWindows * s_windowSize, 0);
 
 	// maybe limit this to a set amount of windows to reduce initial lag spikes
-	for (int i = 0; i < numWindows; i++)
+	for (int i = 0; i < m_numWindows; i++)
 	{
 		if (!m_processedWindows[i])
 		{
@@ -97,17 +97,17 @@ void PhaseVocoder::loadData(std::vector<float> originalData, int sampleRate, flo
 		}
 	}
 
-	dataLock.unlock();
+	m_dataLock.unlock();
 }
 
 void PhaseVocoder::getFrames(std::vector<float>& outData, int start, int frames)
 {
-	if (originalBuffer.size() < 2048) { return; }
-	dataLock.lock();
+	if (m_originalBuffer.size() < 2048) { return; }
+	m_dataLock.lock();
 
-	int windowMargin = overSampling / 2; // numbers of windows before full quality
-	int startWindow = std::max(0.0f, (float)start / outStepSize - windowMargin);
-	int endWindow = std::min((float)numWindows, (float)(start + frames) / outStepSize + windowMargin);
+	int windowMargin = s_overSampling / 2; // numbers of windows before full quality
+	int startWindow = std::max(0.0f, (float)start / m_outStepSize - windowMargin);
+	int endWindow = std::min((float)m_numWindows, (float)(start + frames) / m_outStepSize + windowMargin);
 	// this encompases the minimum windows needed to get full quality,
 	// which must be computed
 	for (int i = startWindow; i < endWindow; i++)
@@ -121,41 +121,41 @@ void PhaseVocoder::getFrames(std::vector<float>& outData, int start, int frames)
 
 	for (int i = 0; i < frames; i++)
 	{
-		outData[i] = processedBuffer[start + i];
+		outData[i] = m_processedBuffer[start + i];
 	}
 
-	dataLock.unlock();
+	m_dataLock.unlock();
 }
 
 // adjust pv params buffers to a new scale ratio
 void PhaseVocoder::updateParams(float newRatio)
 {
-	if (originalBuffer.size() < 2048) { return; }
+	if (m_originalBuffer.size() < 2048) { return; }
 	if (newRatio == m_scaleRatio) { return; } // nothing changed
-	dataLock.lock();
+	m_dataLock.lock();
 
 	m_scaleRatio = newRatio;
-	stepSize = (float)windowSize / overSampling;
-	numWindows = (float)originalBuffer.size() / stepSize - overSampling - 1;
-	outStepSize = m_scaleRatio * (float)stepSize; // float, else inaccurate
-	freqPerBin = originalSampleRate / windowSize;
-	expectedPhaseIn = 2. * F_PI * (float)stepSize / (float)windowSize;
-	expectedPhaseOut = 2. * F_PI * (float)outStepSize / (float)windowSize;
+	m_stepSize = (float)s_windowSize / s_overSampling;
+	m_numWindows = (float)m_originalBuffer.size() / m_stepSize - s_overSampling - 1;
+	m_outStepSize = m_scaleRatio * (float)m_stepSize; // float, else inaccurate
+	m_freqPerBin = m_originalSampleRate / s_windowSize;
+	m_expectedPhaseIn = 2. * F_PI * (float)m_stepSize / (float)s_windowSize;
+	m_expectedPhaseOut = 2. * F_PI * (float)m_outStepSize / (float)s_windowSize;
 
-	processedBuffer.resize(m_scaleRatio * originalBuffer.size(), 0);
+	m_processedBuffer.resize(m_scaleRatio * m_originalBuffer.size(), 0);
 
 	// very slow :(
 	std::fill(m_processedWindows.begin(), m_processedWindows.end(), false);
-	std::fill(processedBuffer.begin(), processedBuffer.end(), 0);
+	std::fill(m_processedBuffer.begin(), m_processedBuffer.end(), 0);
 	// this can be commented, since the start phase is not importante to the PV
 	// and the sum phase will grow linearly anyway
 	// std::fill(lastPhase.begin(), lastPhase.end(), 0);
 	// std::fill(sumPhase.begin(), sumPhase.end(), 0);
 
-	dataLock.unlock();
+	m_dataLock.unlock();
 }
 
-// time shifts one window from originalBuffer and writes to processedBuffer
+// time shifts one window from originalBuffer and writes to m_processedBuffer
 // resources:
 // http://blogs.zynaptiq.com/bernsee/pitch-shifting-using-the-ft/
 // https://sethares.engr.wisc.edu/vocoders/phasevocoder.html
@@ -165,21 +165,21 @@ void PhaseVocoder::generateWindow(int windowNum, bool useCache)
 {
 	// declare vars
 	float real, imag, phase, magnitude, freq, deltaPhase = 0;
-	int windowStart = (float)windowNum * stepSize;
-	int windowIndex = (float)windowNum * windowSize;
+	int windowStart = (float)windowNum * m_stepSize;
+	int windowIndex = (float)windowNum * s_windowSize;
 
 	if (!useCache)
 	{ // normal stuff
-		memcpy(FFTInput.data(), originalBuffer.data() + windowStart, windowSize * sizeof(float));
+		memcpy(m_FFTInput.data(), m_originalBuffer.data() + windowStart, s_windowSize * sizeof(float));
 
 		// FFT
-		fftwf_execute(fftPlan);
+		fftwf_execute(m_fftPlan);
 
 		// analysis step
-		for (int j = 0; j < windowSize / 2; j++) // only process nyquistic frequency
+		for (int j = 0; j < s_windowSize / 2; j++) // only process nyquistic frequency
 		{
-			real = FFTSpectrum[j][0];
-			imag = FFTSpectrum[j][1];
+			real = m_FFTSpectrum[j][0];
+			imag = m_FFTSpectrum[j][1];
 
 			magnitude = 2. * sqrt(real * real + imag * imag);
 			phase = atan2(imag, real);
@@ -187,10 +187,10 @@ void PhaseVocoder::generateWindow(int windowNum, bool useCache)
 			// calculate difference in phase with prev window
 			freq = phase;
 			freq = phase
-				- lastPhase[std::max(0, windowIndex + j - windowSize)]; // subtract prev pahse to get phase diference
-			lastPhase[windowIndex + j] = phase;
+				- m_lastPhase[std::max(0, windowIndex + j - s_windowSize)]; // subtract prev pahse to get phase diference
+			m_lastPhase[windowIndex + j] = phase;
 
-			freq -= (float)j * expectedPhaseIn; // subtract expected phase
+			freq -= (float)j * m_expectedPhaseIn; // subtract expected phase
 			// at this point, freq is the difference in phase
 			// between the last phase, having removed the expected phase at this point in the sample
 
@@ -199,67 +199,67 @@ void PhaseVocoder::generateWindow(int windowNum, bool useCache)
 			freq = fmod(freq + F_PI, -2.0f * F_PI) + F_PI;
 
 			// convert phase difference into bin freq mulitplier
-			freq = (float)overSampling * freq / (2. * F_PI);
+			freq = (float)s_overSampling * freq / (2. * F_PI);
 
 			// add to the expected freq the change in freq calculated from the phase diff
-			freq = (float)j * freqPerBin + freq * freqPerBin;
+			freq = (float)j * m_freqPerBin + freq * m_freqPerBin;
 
-			allMagnitudes[j] = magnitude;
-			allFrequencies[j] = freq;
+			m_allMagnitudes[j] = magnitude;
+			m_allFrequencies[j] = freq;
 		}
 		// write cache
-		memcpy(freqCache.data() + windowIndex, allFrequencies.data(), windowSize * sizeof(float));
-		memcpy(magCache.data() + windowIndex, allMagnitudes.data(), windowSize * sizeof(float));
+		memcpy(m_freqCache.data() + windowIndex, m_allFrequencies.data(), s_windowSize * sizeof(float));
+		memcpy(m_magCache.data() + windowIndex, m_allMagnitudes.data(), s_windowSize * sizeof(float));
 	}
 	else
 	{
 		// read cache
-		memcpy(allFrequencies.data(), freqCache.data() + windowIndex, windowSize * sizeof(float));
-		memcpy(allMagnitudes.data(), magCache.data() + windowIndex, windowSize * sizeof(float));
+		memcpy(m_allFrequencies.data(), m_freqCache.data() + windowIndex, s_windowSize * sizeof(float));
+		memcpy(m_allMagnitudes.data(), m_magCache.data() + windowIndex, s_windowSize * sizeof(float));
 	}
 
 	// synthesis, all the operations are the reverse of the analysis
-	for (int j = 0; j < windowSize / 2; j++)
+	for (int j = 0; j < s_windowSize / 2; j++)
 	{
-		magnitude = allMagnitudes[j];
-		freq = allFrequencies[j];
+		magnitude = m_allMagnitudes[j];
+		freq = m_allFrequencies[j];
 
 		// difference in freq
-		deltaPhase = freq - (float)j * freqPerBin;
+		deltaPhase = freq - (float)j * m_freqPerBin;
 
 		// scaled to 1
-		deltaPhase /= freqPerBin;
+		deltaPhase /= m_freqPerBin;
 
 		// difference in phase
-		deltaPhase = 2. * F_PI * deltaPhase / overSampling;
+		deltaPhase = 2. * F_PI * deltaPhase / s_overSampling;
 
 		// add the expected phase
-		deltaPhase += (float)j * expectedPhaseOut;
+		deltaPhase += (float)j * m_expectedPhaseOut;
 
 		// sum this phase to the total, to keep track of the out phase along the sample
-		sumPhase[windowIndex + j] += deltaPhase;
-		deltaPhase = sumPhase[windowIndex + j]; // this is the bin phase
-		if (windowIndex + j + windowSize < sumPhase.size())
+		m_sumPhase[windowIndex + j] += deltaPhase;
+		deltaPhase = m_sumPhase[windowIndex + j]; // this is the bin phase
+		if (windowIndex + j + s_windowSize < m_sumPhase.size())
 		{														 // only if not last window
-			sumPhase[windowIndex + j + windowSize] = deltaPhase; // copy to the next
+			m_sumPhase[windowIndex + j + s_windowSize] = deltaPhase; // copy to the next
 		}
 
-		FFTSpectrum[j][0] = magnitude * cos(deltaPhase);
-		FFTSpectrum[j][1] = magnitude * sin(deltaPhase);
+		m_FFTSpectrum[j][0] = magnitude * cos(deltaPhase);
+		m_FFTSpectrum[j][1] = magnitude * sin(deltaPhase);
 	}
 
 	// inverse fft
-	fftwf_execute(ifftPlan);
+	fftwf_execute(m_ifftPlan);
 
 	// windowing
-	for (int j = 0; j < windowSize; j++)
+	for (int j = 0; j < s_windowSize; j++)
 	{
-		float outIndex = windowNum * outStepSize + j;
+		float outIndex = windowNum * m_outStepSize + j;
 		if (outIndex >= frames()) { break; }
 
 		// hann windowing
-		float window = -0.5f * cos(2. * F_PI * (float)j / (float)windowSize) + 0.5f;
-		processedBuffer[outIndex] += window * IFFTReconstruction[j] / (windowSize / 2.0f * overSampling);
+		float window = -0.5f * cos(2. * F_PI * (float)j / (float)s_windowSize) + 0.5f;
+		m_processedBuffer[outIndex] += window * m_IFFTReconstruction[j] / (s_windowSize / 2.0f * s_overSampling);
 	}
 }
 
diff --git a/plugins/SlicerT/SlicerT.h b/plugins/SlicerT/SlicerT.h
index fc860ad3968..46d9093a129 100644
--- a/plugins/SlicerT/SlicerT.h
+++ b/plugins/SlicerT/SlicerT.h
@@ -48,51 +48,51 @@ class PhaseVocoder
 
 	void getFrames(std::vector<float>& outData, int start, int frames);
 
-	int frames() { return processedBuffer.size(); }
+	int frames() { return m_processedBuffer.size(); }
 	float scaleRatio() { return m_scaleRatio; }
 
 private:
-	QMutex dataLock;
+	QMutex m_dataLock;
 	// original data
-	std::vector<float> originalBuffer;
-	int originalSampleRate = 0;
+	std::vector<float> m_originalBuffer;
+	int m_originalSampleRate = 0;
 
 	float m_scaleRatio = -1; // to force on first load
 
 	// output data
-	std::vector<float> processedBuffer; // final output
+	std::vector<float> m_processedBuffer; // final output
 	std::vector<bool> m_processedWindows; // marks a window processed
 
 	// timeshift stuff
-	static const int windowSize = 512;
-	static const int overSampling = 32;
+	static const int s_windowSize = 512;
+	static const int s_overSampling = 32;
 
 	// depending on scaleRatio
-	int stepSize = 0;
-	int numWindows = 0;
-	float outStepSize = 0;
-	float freqPerBin = 0;
-	float expectedPhaseIn = 0;
-	float expectedPhaseOut = 0;
+	int m_stepSize = 0;
+	int m_numWindows = 0;
+	float m_outStepSize = 0;
+	float m_freqPerBin = 0;
+	float m_expectedPhaseIn = 0;
+	float m_expectedPhaseOut = 0;
 
 	// buffers
-	fftwf_complex FFTSpectrum[windowSize];
-	std::vector<float> FFTInput;
-	std::vector<float> IFFTReconstruction;
-	std::vector<float> allMagnitudes;
-	std::vector<float> allFrequencies;
-	std::vector<float> processedFreq;
-	std::vector<float> processedMagn;
-	std::vector<float> lastPhase;
-	std::vector<float> sumPhase;
+	fftwf_complex m_FFTSpectrum[s_windowSize];
+	std::vector<float> m_FFTInput;
+	std::vector<float> m_IFFTReconstruction;
+	std::vector<float> m_allMagnitudes;
+	std::vector<float> m_allFrequencies;
+	std::vector<float> m_processedFreq;
+	std::vector<float> m_processedMagn;
+	std::vector<float> m_lastPhase;
+	std::vector<float> m_sumPhase;
 
 	// cache
-	std::vector<float> freqCache;
-	std::vector<float> magCache;
+	std::vector<float> m_freqCache;
+	std::vector<float> m_magCache;
 
 	// fftw plans
-	fftwf_plan fftPlan;
-	fftwf_plan ifftPlan;
+	fftwf_plan m_fftPlan;
+	fftwf_plan m_ifftPlan;
 
 	void updateParams(float newRatio);
 	void generateWindow(int windowNum, bool useCache);
@@ -103,8 +103,8 @@ class dinamicPlaybackBuffer
 {
 public:
 	dinamicPlaybackBuffer()
-		: leftChannel()
-		, rightChannel()
+		: m_leftChannel()
+		, m_rightChannel()
 	{
 	}
 	void loadSample(const sampleFrame* outData, int frames, int sampleRate, float newRatio)
@@ -116,16 +116,16 @@ class dinamicPlaybackBuffer
 			leftData[i] = outData[i][0];
 			rightData[i] = outData[i][1];
 		}
-		leftChannel.loadData(leftData, sampleRate, newRatio);
-		rightChannel.loadData(rightData, sampleRate, newRatio);
+		m_leftChannel.loadData(leftData, sampleRate, newRatio);
+		m_rightChannel.loadData(rightData, sampleRate, newRatio);
 	}
 	void getFrames(sampleFrame* outData, int startFrame, int frames)
 	{
 		std::vector<float> leftOut(frames, 0); // not a huge performance issue
 		std::vector<float> rightOut(frames, 0);
 
-		leftChannel.getFrames(leftOut, startFrame, frames);
-		rightChannel.getFrames(rightOut, startFrame, frames);
+		m_leftChannel.getFrames(leftOut, startFrame, frames);
+		m_rightChannel.getFrames(rightOut, startFrame, frames);
 
 		for (int i = 0; i < frames; i++)
 		{
@@ -133,17 +133,17 @@ class dinamicPlaybackBuffer
 			outData[i][1] = rightOut[i];
 		}
 	}
-	int frames() { return leftChannel.frames(); }
-	float scaleRatio() { return leftChannel.scaleRatio(); }
+	int frames() { return m_leftChannel.frames(); }
+	float scaleRatio() { return m_leftChannel.scaleRatio(); }
 	void setScaleRatio(float newRatio)
 	{
-		leftChannel.setScaleRatio(newRatio);
-		rightChannel.setScaleRatio(newRatio);
+		m_leftChannel.setScaleRatio(newRatio);
+		m_rightChannel.setScaleRatio(newRatio);
 	}
 
 private:
-	PhaseVocoder leftChannel;
-	PhaseVocoder rightChannel;
+	PhaseVocoder m_leftChannel;
+	PhaseVocoder m_rightChannel;
 };
 
 class SlicerT : public Instrument
diff --git a/plugins/SlicerT/WaveForm.cpp b/plugins/SlicerT/WaveForm.cpp
index 9a6fc7072aa..db5f6815710 100644
--- a/plugins/SlicerT/WaveForm.cpp
+++ b/plugins/SlicerT/WaveForm.cpp
@@ -193,11 +193,11 @@ void WaveForm::mousePressEvent(QMouseEvent* me)
 
 	if (me->y() < m_seekerHeight) // seeker click
 	{
-		if (abs(normalizedClickSeeker - m_seekerStart) < distanceForClick) // dragging start
+		if (abs(normalizedClickSeeker - m_seekerStart) < m_distanceForClick) // dragging start
 		{
 			m_currentlyDragging = m_draggingTypes::m_seekerStart;
 		}
-		else if (abs(normalizedClickSeeker - m_seekerEnd) < distanceForClick) // dragging end
+		else if (abs(normalizedClickSeeker - m_seekerEnd) < m_distanceForClick) // dragging end
 		{
 			m_currentlyDragging = m_draggingTypes::m_seekerEnd;
 		}
@@ -218,7 +218,7 @@ void WaveForm::mousePressEvent(QMouseEvent* me)
 			int sliceIndex = m_slicePoints[i];
 			float xPos = (float)(sliceIndex - startFrame) / (float)(endFrame - startFrame);
 
-			if (abs(xPos - normalizedClickEditor) < distanceForClick)
+			if (abs(xPos - normalizedClickEditor) < m_distanceForClick)
 			{
 				m_currentlyDragging = m_draggingTypes::m_slicePoint;
 				m_sliceSelected = i;
@@ -259,11 +259,11 @@ void WaveForm::mouseMoveEvent(QMouseEvent* me)
 	switch (m_currentlyDragging)
 	{
 	case m_draggingTypes::m_seekerStart:
-		m_seekerStart = std::clamp(normalizedClickSeeker, 0.0f, m_seekerEnd - minSeekerDistance);
+		m_seekerStart = std::clamp(normalizedClickSeeker, 0.0f, m_seekerEnd - m_minSeekerDistance);
 		break;
 
 	case m_draggingTypes::m_seekerEnd:
-		m_seekerEnd = std::clamp(normalizedClickSeeker, m_seekerStart + minSeekerDistance, 1.0f);
+		m_seekerEnd = std::clamp(normalizedClickSeeker, m_seekerStart + m_minSeekerDistance, 1.0f);
 		break;
 
 	case m_draggingTypes::m_seekerMiddle:
diff --git a/plugins/SlicerT/WaveForm.h b/plugins/SlicerT/WaveForm.h
index ede26749d52..4d858523756 100644
--- a/plugins/SlicerT/WaveForm.h
+++ b/plugins/SlicerT/WaveForm.h
@@ -79,8 +79,8 @@ class WaveForm : public QWidget
 	QColor m_seekerShadowColor = QColor(0, 0, 0, 120);
 
 	// interaction vars
-	float distanceForClick = 0.03f;
-	float minSeekerDistance = 0.13f;
+	float m_distanceForClick = 0.03f;
+	float m_minSeekerDistance = 0.13f;
 
 	// dragging vars
 	enum class m_draggingTypes

From c2948c0bc50774c7babf4b5ee4c696cde61465be Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Wed, 4 Oct 2023 21:46:45 +0200
Subject: [PATCH 42/99] PV better windowing

---
 plugins/SlicerT/SlicerT.cpp | 15 ++++++++++++---
 1 file changed, 12 insertions(+), 3 deletions(-)

diff --git a/plugins/SlicerT/SlicerT.cpp b/plugins/SlicerT/SlicerT.cpp
index 9ce4f499232..5d82a6b7a2d 100644
--- a/plugins/SlicerT/SlicerT.cpp
+++ b/plugins/SlicerT/SlicerT.cpp
@@ -161,6 +161,7 @@ void PhaseVocoder::updateParams(float newRatio)
 // https://sethares.engr.wisc.edu/vocoders/phasevocoder.html
 // https://dsp.stackexchange.com/questions/40101/audio-time-stretching-without-pitch-shifting/40367#40367
 // https://www.guitarpitchshifter.com/
+// https://en.wikipedia.org/wiki/Window_function
 void PhaseVocoder::generateWindow(int windowNum, bool useCache)
 {
 	// declare vars
@@ -257,9 +258,17 @@ void PhaseVocoder::generateWindow(int windowNum, bool useCache)
 		float outIndex = windowNum * m_outStepSize + j;
 		if (outIndex >= frames()) { break; }
 
-		// hann windowing
-		float window = -0.5f * cos(2. * F_PI * (float)j / (float)s_windowSize) + 0.5f;
-		m_processedBuffer[outIndex] += window * m_IFFTReconstruction[j] / (s_windowSize / 2.0f * s_overSampling);
+		// blackman-harris window
+		float a0 = 0.35875f;
+		float a1 = 0.48829f;
+		float a2 = 0.14128f;
+		float a3 = 0.01168f;
+
+		float piN2 = 2.0f * F_PI * j;
+		float window = a0 - (a1 * cos(piN2 / s_windowSize)) + (a2 * cos(2.0f * piN2 / s_windowSize)) - (a3 * cos(3.0f * piN2));
+
+		// inverse fft magnitudes are windowsSize times bigger
+		m_processedBuffer[outIndex] += window * (m_IFFTReconstruction[j] / s_windowSize / s_overSampling);
 	}
 }
 

From 8457d9682a2838fa12a11df6aa0b109f76886f0e Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Wed, 4 Oct 2023 23:29:05 +0200
Subject: [PATCH 43/99] waveform zoom

---
 plugins/SlicerT/WaveForm.cpp | 15 ++++++++++++++-
 plugins/SlicerT/WaveForm.h   |  5 +++++
 2 files changed, 19 insertions(+), 1 deletion(-)

diff --git a/plugins/SlicerT/WaveForm.cpp b/plugins/SlicerT/WaveForm.cpp
index db5f6815710..7073ab51839 100644
--- a/plugins/SlicerT/WaveForm.cpp
+++ b/plugins/SlicerT/WaveForm.cpp
@@ -145,7 +145,9 @@ void WaveForm::drawEditor()
 
 	// draw waveform
 	brush.setPen(m_waveformColor);
-	m_currentSample.visualize(brush, QRect(0, 0, m_editorWidth, m_editorHeight), startFrame, endFrame);
+	float zoomOffset = ((float)m_editorHeight - m_zoomLevel * m_editorHeight) / 2;
+	m_currentSample.visualize(
+		brush, QRect(0, zoomOffset, m_editorWidth, m_zoomLevel * m_editorHeight), startFrame, endFrame);
 
 	// draw slicepoints
 	brush.setPen(QPen(m_sliceColor, 2));
@@ -188,6 +190,7 @@ void WaveForm::mousePressEvent(QMouseEvent* me)
 	{
 		m_seekerStart = 0;
 		m_seekerEnd = 1;
+		m_zoomLevel = 1;
 		return;
 	}
 
@@ -306,6 +309,16 @@ void WaveForm::mouseDoubleClickEvent(QMouseEvent* me)
 	std::sort(m_slicePoints.begin(), m_slicePoints.end());
 }
 
+void WaveForm::wheelEvent(QWheelEvent* _we)
+{
+	// m_zoomLevel = _we-> / 360.0f * 2.0f;
+	m_zoomLevel += _we->angleDelta().y() / 360.0f * m_zoomSensitivity;
+	m_zoomLevel = std::max(0.0f, m_zoomLevel);
+
+	drawEditor();
+	update();
+}
+
 void WaveForm::paintEvent(QPaintEvent* pe)
 {
 	QPainter p(this);
diff --git a/plugins/SlicerT/WaveForm.h b/plugins/SlicerT/WaveForm.h
index 4d858523756..3e74b995f9e 100644
--- a/plugins/SlicerT/WaveForm.h
+++ b/plugins/SlicerT/WaveForm.h
@@ -48,6 +48,7 @@ class WaveForm : public QWidget
 	virtual void mouseReleaseEvent(QMouseEvent* me);
 	virtual void mouseMoveEvent(QMouseEvent* me);
 	virtual void mouseDoubleClickEvent(QMouseEvent* me);
+	virtual void wheelEvent(QWheelEvent* _we);
 
 	virtual void paintEvent(QPaintEvent* pe);
 
@@ -81,6 +82,7 @@ class WaveForm : public QWidget
 	// interaction vars
 	float m_distanceForClick = 0.03f;
 	float m_minSeekerDistance = 0.13f;
+	float m_zoomSensitivity = 0.5f;
 
 	// dragging vars
 	enum class m_draggingTypes
@@ -104,6 +106,9 @@ class WaveForm : public QWidget
 	float m_noteStart;
 	float m_noteEnd;
 
+	// editor vars
+	float m_zoomLevel = 1.0f;
+
 	// pixmaps
 	QPixmap m_sliceArrow;
 	QPixmap m_seeker;

From b2cd8085720a4e2b5ffad63461607caae6dc0bca Mon Sep 17 00:00:00 2001
From: Katherine Pratt <consolegrl@gmail.com>
Date: Thu, 5 Oct 2023 01:09:36 -0400
Subject: [PATCH 44/99] Minor style fixes.

---
 plugins/SlicerT/SlicerT.cpp   |  2 +-
 plugins/SlicerT/SlicerT.h     | 13 ++++++++-----
 plugins/SlicerT/SlicerTUI.cpp | 18 +++++++++++-------
 plugins/SlicerT/WaveForm.cpp  |  3 ++-
 4 files changed, 22 insertions(+), 14 deletions(-)

diff --git a/plugins/SlicerT/SlicerT.cpp b/plugins/SlicerT/SlicerT.cpp
index 5d82a6b7a2d..fc43af4ca21 100644
--- a/plugins/SlicerT/SlicerT.cpp
+++ b/plugins/SlicerT/SlicerT.cpp
@@ -588,7 +588,7 @@ void SlicerT::loadSettings(const QDomElement& element)
 	m_noteThreshold.loadSettings(element, "threshold");
 	m_originalBPM.loadSettings(element, "origBPM");
 
-	// create dinamic buffer
+	// create dynamic buffer
 	float speedRatio = (float)m_originalBPM.value() / Engine::getSong()->getTempo();
 	m_phaseVocoder.loadSample(
 		m_originalSample.data(), m_originalSample.frames(), m_originalSample.sampleRate(), speedRatio);
diff --git a/plugins/SlicerT/SlicerT.h b/plugins/SlicerT/SlicerT.h
index 46d9093a129..7543821bc60 100644
--- a/plugins/SlicerT/SlicerT.h
+++ b/plugins/SlicerT/SlicerT.h
@@ -99,14 +99,14 @@ class PhaseVocoder
 };
 
 // simple helper class that handles the different audio channels
-class dinamicPlaybackBuffer
+class DynamicPlaybackBuffer
 {
 public:
-	dinamicPlaybackBuffer()
+	DynamicPlaybackBuffer()
 		: m_leftChannel()
 		, m_rightChannel()
-	{
-	}
+	{}
+	
 	void loadSample(const sampleFrame* outData, int frames, int sampleRate, float newRatio)
 	{
 		std::vector<float> leftData(frames, 0);
@@ -119,6 +119,7 @@ class dinamicPlaybackBuffer
 		m_leftChannel.loadData(leftData, sampleRate, newRatio);
 		m_rightChannel.loadData(rightData, sampleRate, newRatio);
 	}
+
 	void getFrames(sampleFrame* outData, int startFrame, int frames)
 	{
 		std::vector<float> leftOut(frames, 0); // not a huge performance issue
@@ -133,8 +134,10 @@ class dinamicPlaybackBuffer
 			outData[i][1] = rightOut[i];
 		}
 	}
+
 	int frames() { return m_leftChannel.frames(); }
 	float scaleRatio() { return m_leftChannel.scaleRatio(); }
+
 	void setScaleRatio(float newRatio)
 	{
 		m_leftChannel.setScaleRatio(newRatio);
@@ -180,7 +183,7 @@ public slots:
 
 	// sample buffers
 	SampleBuffer m_originalSample;
-	dinamicPlaybackBuffer m_phaseVocoder;
+	DynamicPlaybackBuffer m_phaseVocoder;
 
 	std::vector<int> m_slicePoints;
 
diff --git a/plugins/SlicerT/SlicerTUI.cpp b/plugins/SlicerT/SlicerTUI.cpp
index 0f5fe93a7ba..6f601552c77 100644
--- a/plugins/SlicerT/SlicerTUI.cpp
+++ b/plugins/SlicerT/SlicerTUI.cpp
@@ -94,7 +94,7 @@ SlicerTUI::SlicerTUI(SlicerT* instrument, QWidget* parent)
 	m_midiExportButton.setToolTip(tr("Copy midi pattern to clipboard"));
 	connect(&m_midiExportButton, SIGNAL(clicked()), this, SLOT(exportMidi()));
 
-	// slcie reset button
+	// slice reset button
 	m_resetButton.move(25, 155);
 	m_resetButton.setActiveGraphic(PLUGIN_NAME::getIconPixmap("resetSlices"));
 	m_resetButton.setInactiveGraphic(PLUGIN_NAME::getIconPixmap("resetSlices"));
@@ -139,8 +139,14 @@ void SlicerTUI::dragEnterEvent(QDragEnterEvent* dee)
 		{
 			dee->acceptProposedAction();
 		}
-		else if (txt.section(':', 0, 0) == "samplefile") { dee->acceptProposedAction(); }
-		else { dee->ignore(); }
+		else if (txt.section(':', 0, 0) == "samplefile")
+		{
+			dee->acceptProposedAction();
+		}
+		else
+		{
+			dee->ignore();
+		}
 	}
 	else { dee->ignore(); }
 }
@@ -151,10 +157,8 @@ void SlicerTUI::dropEvent(QDropEvent* de)
 	QString value = StringPairDrag::decodeValue(de);
 	if (type == "samplefile")
 	{
-		m_slicerTParent->updateFile(value);
-		// castModel<AudioFileProcessor>()->setAudioFile( value );
-		// de->accept();
 		// set m_wf wave file
+		m_slicerTParent->updateFile(value);
 		return;
 	}
 	else if (type == QString("clip_%1").arg(static_cast<int>(Track::Type::Sample)))
@@ -180,4 +184,4 @@ void SlicerTUI::paintEvent(QPaintEvent* pe)
 }
 
 } // namespace gui
-} // namespace lmms
\ No newline at end of file
+} // namespace lmms
diff --git a/plugins/SlicerT/WaveForm.cpp b/plugins/SlicerT/WaveForm.cpp
index 7073ab51839..c6f8ad72177 100644
--- a/plugins/SlicerT/WaveForm.cpp
+++ b/plugins/SlicerT/WaveForm.cpp
@@ -30,6 +30,7 @@
 namespace lmms {
 
 namespace gui {
+
 WaveForm::WaveForm(int w, int h, SlicerT* instrument, QWidget* parent)
 	: QWidget(parent)
 	,
@@ -327,4 +328,4 @@ void WaveForm::paintEvent(QPaintEvent* pe)
 	p.drawPixmap(0, m_seekerHeight + m_middleMargin, m_sliceEditor);
 }
 } // namespace gui
-} // namespace lmms
\ No newline at end of file
+} // namespace lmms

From b7c7def78fed86d2bd69d8c45597f2e2f147afb4 Mon Sep 17 00:00:00 2001
From: Katherine Pratt <consolegrl@gmail.com>
Date: Thu, 5 Oct 2023 02:49:43 -0400
Subject: [PATCH 45/99] Initial artistic rebalancing of the plugin artwork.

---
 plugins/SlicerT/SlicerTUI.cpp |  22 +++++++++++-----------
 plugins/SlicerT/SlicerTUI.h   |   6 +++---
 plugins/SlicerT/bg.png        | Bin 23763 -> 28021 bytes
 plugins/SlicerT/bg.xcf        | Bin 0 -> 92565 bytes
 4 files changed, 14 insertions(+), 14 deletions(-)
 create mode 100644 plugins/SlicerT/bg.xcf

diff --git a/plugins/SlicerT/SlicerTUI.cpp b/plugins/SlicerT/SlicerTUI.cpp
index 6f601552c77..6fe9159a4e9 100644
--- a/plugins/SlicerT/SlicerTUI.cpp
+++ b/plugins/SlicerT/SlicerTUI.cpp
@@ -65,37 +65,37 @@ SlicerTUI::SlicerTUI(SlicerT* instrument, QWidget* parent)
 	m_wf.move(2, 6);
 
 	// snap combo box
-	m_snapSetting.setGeometry(190, 200, 55, ComboBox::DEFAULT_HEIGHT);
+	m_snapSetting.setGeometry(185, 200, 55, ComboBox::DEFAULT_HEIGHT);
 	m_snapSetting.setToolTip(tr("Set slice snapping for detection"));
 	m_snapSetting.setModel(&m_slicerTParent->m_sliceSnap);
 
 	// bpm spin box
-	m_bpmBox.move(135, 203);
+	m_bpmBox.move(130, 203);
 	m_bpmBox.setToolTip(tr("Original sample BPM"));
 	m_bpmBox.setLabel(tr("BPM"));
 	m_bpmBox.setModel(&m_slicerTParent->m_originalBPM);
 
 	// threshold knob
-	m_noteThresholdKnob.move(14, 195);
+	m_noteThresholdKnob.move(9, 195);
 	m_noteThresholdKnob.setToolTip(tr("Threshold used for slicing"));
 	m_noteThresholdKnob.setLabel(tr("Threshold"));
 	m_noteThresholdKnob.setModel(&m_slicerTParent->m_noteThreshold);
 
 	// fadeout knob
-	m_fadeOutKnob.move(80, 195);
-	m_fadeOutKnob.setToolTip(tr("FadeOut for notes"));
-	m_fadeOutKnob.setLabel(tr("FadeOut"));
+	m_fadeOutKnob.move(75, 195);
+	m_fadeOutKnob.setToolTip(tr("Fade Out for notes"));
+	m_fadeOutKnob.setLabel(tr("Fade Out"));
 	m_fadeOutKnob.setModel(&m_slicerTParent->m_fadeOutFrames);
 
 	// midi copy button
-	m_midiExportButton.move(205, 155);
+	m_midiExportButton.move(215, 150);
 	m_midiExportButton.setActiveGraphic(PLUGIN_NAME::getIconPixmap("copyMidi"));
 	m_midiExportButton.setInactiveGraphic(PLUGIN_NAME::getIconPixmap("copyMidi"));
 	m_midiExportButton.setToolTip(tr("Copy midi pattern to clipboard"));
 	connect(&m_midiExportButton, SIGNAL(clicked()), this, SLOT(exportMidi()));
 
 	// slice reset button
-	m_resetButton.move(25, 155);
+	m_resetButton.move(19, 150);
 	m_resetButton.setActiveGraphic(PLUGIN_NAME::getIconPixmap("resetSlices"));
 	m_resetButton.setInactiveGraphic(PLUGIN_NAME::getIconPixmap("resetSlices"));
 	m_resetButton.setToolTip(tr("Reset Slices"));
@@ -178,9 +178,9 @@ void SlicerTUI::paintEvent(QPaintEvent* pe)
 	QPainter brush(this);
 	brush.setPen(QColor(255, 255, 255));
 	brush.setFont(QFont(brush.font().family(), 7.5f, -1, false));
-	brush.drawText(205, 170, 20, 20, Qt::AlignCenter, tr("Midi"));
-	brush.drawText(22, 170, 25, 20, Qt::AlignCenter, tr("Reset"));
-	brush.drawText(190, 217, 55, 20, Qt::AlignCenter, tr("Snap"));
+	brush.drawText(212, 165, 25, 20, Qt::AlignCenter, tr("Midi"));
+	brush.drawText(14, 165, 30, 20, Qt::AlignCenter, tr("Reset"));
+	brush.drawText(185, 217, 55, 20, Qt::AlignCenter, tr("Snap"));
 }
 
 } // namespace gui
diff --git a/plugins/SlicerT/SlicerTUI.h b/plugins/SlicerT/SlicerTUI.h
index adcc1d0ef2b..4b914507049 100644
--- a/plugins/SlicerT/SlicerTUI.h
+++ b/plugins/SlicerT/SlicerTUI.h
@@ -48,8 +48,8 @@ class SlicerTKnob : public Knob
 	SlicerTKnob(QWidget* _parent)
 		: Knob(KnobType::Styled, _parent)
 	{
-		setFixedSize(46, 40);
-		setCenterPointX(23.0);
+		setFixedSize(50, 40);
+		setCenterPointX(24.0);
 		setCenterPointY(15.0);
 	}
 };
@@ -87,4 +87,4 @@ protected slots:
 };
 } // namespace gui
 } // namespace lmms
-#endif // SLICERT_UI_H
\ No newline at end of file
+#endif // SLICERT_UI_H
diff --git a/plugins/SlicerT/bg.png b/plugins/SlicerT/bg.png
index a9d1c82733c280ac39f31ae30938e18e134f27c4..0e00e4c17d3cd942aaf10549a2d2650d44facee9 100644
GIT binary patch
delta 24063
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

literal 23763
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
SPY<>L0000<MNUMnLSTXyo(7Qs

diff --git a/plugins/SlicerT/bg.xcf b/plugins/SlicerT/bg.xcf
new file mode 100644
index 0000000000000000000000000000000000000000..63cd2e12f50071c764f3f15005df8b9d7ff18497
GIT binary patch
literal 92565
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

literal 0
HcmV?d00001


From 9a0bd878b8ec3c3f268268c90a2dacc9a7e6d1f7 Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Thu, 5 Oct 2023 18:12:53 +0200
Subject: [PATCH 46/99] PV phase ghosting fix

---
 plugins/SlicerT/SlicerT.cpp | 31 ++++++++++++++++++-------------
 1 file changed, 18 insertions(+), 13 deletions(-)

diff --git a/plugins/SlicerT/SlicerT.cpp b/plugins/SlicerT/SlicerT.cpp
index 5d82a6b7a2d..a39707b86d6 100644
--- a/plugins/SlicerT/SlicerT.cpp
+++ b/plugins/SlicerT/SlicerT.cpp
@@ -83,10 +83,14 @@ void PhaseVocoder::loadData(std::vector<float> originalData, int sampleRate, flo
 	// set buffer sizes
 	m_processedWindows.resize(m_numWindows, false);
 	m_lastPhase.resize(m_numWindows * s_windowSize, 0);
-	m_sumPhase.resize(m_numWindows * s_windowSize, 0);
+	m_sumPhase.resize((m_numWindows + 1) * s_windowSize, 0);
 	m_freqCache.resize(m_numWindows * s_windowSize, 0);
 	m_magCache.resize(m_numWindows * s_windowSize, 0);
 
+	// clear phase buffers
+	std::fill(m_lastPhase.begin(), m_lastPhase.end(), 0);
+	std::fill(m_sumPhase.begin(), m_sumPhase.end(), 0);
+
 	// maybe limit this to a set amount of windows to reduce initial lag spikes
 	for (int i = 0; i < m_numWindows; i++)
 	{
@@ -108,6 +112,13 @@ void PhaseVocoder::getFrames(std::vector<float>& outData, int start, int frames)
 	int windowMargin = s_overSampling / 2; // numbers of windows before full quality
 	int startWindow = std::max(0.0f, (float)start / m_outStepSize - windowMargin);
 	int endWindow = std::min((float)m_numWindows, (float)(start + frames) / m_outStepSize + windowMargin);
+
+	// discard previous phaseSum if not processed
+	if (!m_processedWindows[startWindow])
+	{
+		std::fill_n(m_sumPhase.data() + startWindow * s_windowSize, s_windowSize, 0);
+	}
+
 	// this encompases the minimum windows needed to get full quality,
 	// which must be computed
 	for (int i = startWindow; i < endWindow; i++)
@@ -147,10 +158,6 @@ void PhaseVocoder::updateParams(float newRatio)
 	// very slow :(
 	std::fill(m_processedWindows.begin(), m_processedWindows.end(), false);
 	std::fill(m_processedBuffer.begin(), m_processedBuffer.end(), 0);
-	// this can be commented, since the start phase is not importante to the PV
-	// and the sum phase will grow linearly anyway
-	// std::fill(lastPhase.begin(), lastPhase.end(), 0);
-	// std::fill(sumPhase.begin(), sumPhase.end(), 0);
 
 	m_dataLock.unlock();
 }
@@ -225,10 +232,10 @@ void PhaseVocoder::generateWindow(int windowNum, bool useCache)
 		magnitude = m_allMagnitudes[j];
 		freq = m_allFrequencies[j];
 
-		// difference in freq
+		// difference to bin freq mulitplier
 		deltaPhase = freq - (float)j * m_freqPerBin;
 
-		// scaled to 1
+		// convert to phase difference
 		deltaPhase /= m_freqPerBin;
 
 		// difference in phase
@@ -239,11 +246,10 @@ void PhaseVocoder::generateWindow(int windowNum, bool useCache)
 
 		// sum this phase to the total, to keep track of the out phase along the sample
 		m_sumPhase[windowIndex + j] += deltaPhase;
-		deltaPhase = m_sumPhase[windowIndex + j]; // this is the bin phase
-		if (windowIndex + j + s_windowSize < m_sumPhase.size())
-		{														 // only if not last window
-			m_sumPhase[windowIndex + j + s_windowSize] = deltaPhase; // copy to the next
-		}
+		deltaPhase = m_sumPhase[windowIndex + j]; // final bin phase
+
+		m_sumPhase[windowIndex + j + s_windowSize] = deltaPhase; // copy to the next
+
 
 		m_FFTSpectrum[j][0] = magnitude * cos(deltaPhase);
 		m_FFTSpectrum[j][1] = magnitude * sin(deltaPhase);
@@ -256,7 +262,6 @@ void PhaseVocoder::generateWindow(int windowNum, bool useCache)
 	for (int j = 0; j < s_windowSize; j++)
 	{
 		float outIndex = windowNum * m_outStepSize + j;
-		if (outIndex >= frames()) { break; }
 
 		// blackman-harris window
 		float a0 = 0.35875f;

From 1080e5c54fac97759037a242fb9e8aaf91881e52 Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Thu, 5 Oct 2023 18:18:45 +0200
Subject: [PATCH 47/99] Use base note as keyboard slice start

---
 plugins/SlicerT/SlicerT.cpp | 5 +++--
 plugins/SlicerT/SlicerT.h   | 2 ++
 2 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/plugins/SlicerT/SlicerT.cpp b/plugins/SlicerT/SlicerT.cpp
index a39707b86d6..01e3f5254cf 100644
--- a/plugins/SlicerT/SlicerT.cpp
+++ b/plugins/SlicerT/SlicerT.cpp
@@ -287,6 +287,7 @@ SlicerT::SlicerT(InstrumentTrack* instrumentTrack)
 	, m_sliceSnap(this, tr("Slice snap"))
 	, m_originalSample()
 	, m_phaseVocoder()
+	, m_parentTrack(instrumentTrack)
 {
 	m_sliceSnap.addItem("Off");
 	m_sliceSnap.addItem("1/1");
@@ -308,7 +309,7 @@ void SlicerT::playNote(NotePlayHandle* handle, sampleFrame* workingBuffer)
 
 	// current playback status
 	const int totalFrames = m_phaseVocoder.frames();
-	const int noteIndex = handle->key() - 69;
+	const int noteIndex = handle->key() - m_parentTrack->baseNote();
 	const fpp_t frames = handle->framesLeftForCurrentPeriod();
 	const f_cnt_t offset = handle->noteOffset();
 	const int playedFrames = handle->totalFramesPlayed();
@@ -506,7 +507,7 @@ void SlicerT::writeToMidi(std::vector<Note>* outClip)
 		float sliceEnd = (float)m_slicePoints[i + 1] / m_originalSample.frames() * totalTicks;
 
 		Note sliceNote = Note();
-		sliceNote.setKey(i + 69);
+		sliceNote.setKey(i + m_parentTrack->baseNote());
 		sliceNote.setPos(sliceStart);
 		sliceNote.setLength(sliceEnd - sliceStart + 1); // + 1 needed for whatever reason
 		outClip->push_back(sliceNote);
diff --git a/plugins/SlicerT/SlicerT.h b/plugins/SlicerT/SlicerT.h
index 46d9093a129..3e1b8d4992a 100644
--- a/plugins/SlicerT/SlicerT.h
+++ b/plugins/SlicerT/SlicerT.h
@@ -184,6 +184,8 @@ public slots:
 
 	std::vector<int> m_slicePoints;
 
+	InstrumentTrack* m_parentTrack;
+
 	void findSlices();
 	void findBPM();
 

From 290ef8d5774490201d3ed4dcc9c9a6a024c7fd00 Mon Sep 17 00:00:00 2001
From: Katherine Pratt <consolegrl@gmail.com>
Date: Thu, 5 Oct 2023 16:58:52 -0400
Subject: [PATCH 48/99] Good draft of Artwork, renamed bg to artwork

---
 plugins/SlicerT/SlicerTUI.cpp           |   2 +-
 plugins/SlicerT/artwork.png             | Bin 0 -> 23467 bytes
 plugins/SlicerT/{bg.xcf => artwork.xcf} | Bin
 plugins/SlicerT/bg.png                  | Bin 28021 -> 0 bytes
 4 files changed, 1 insertion(+), 1 deletion(-)
 create mode 100644 plugins/SlicerT/artwork.png
 rename plugins/SlicerT/{bg.xcf => artwork.xcf} (100%)
 delete mode 100644 plugins/SlicerT/bg.png

diff --git a/plugins/SlicerT/SlicerTUI.cpp b/plugins/SlicerT/SlicerTUI.cpp
index 6fe9159a4e9..2f4a1dc0b9d 100644
--- a/plugins/SlicerT/SlicerTUI.cpp
+++ b/plugins/SlicerT/SlicerTUI.cpp
@@ -58,7 +58,7 @@ SlicerTUI::SlicerTUI(SlicerT* instrument, QWidget* parent)
 
 	// render background
 	QPalette pal;
-	pal.setBrush(backgroundRole(), PLUGIN_NAME::getIconPixmap("bg"));
+	pal.setBrush(backgroundRole(), PLUGIN_NAME::getIconPixmap("artwork"));
 	setPalette(pal);
 
 	// move editor and seeker
diff --git a/plugins/SlicerT/artwork.png b/plugins/SlicerT/artwork.png
new file mode 100644
index 0000000000000000000000000000000000000000..82a80897b2294502197ce840c02b63c65ecfc767
GIT binary patch
literal 23467
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

literal 0
HcmV?d00001

diff --git a/plugins/SlicerT/bg.xcf b/plugins/SlicerT/artwork.xcf
similarity index 100%
rename from plugins/SlicerT/bg.xcf
rename to plugins/SlicerT/artwork.xcf
diff --git a/plugins/SlicerT/bg.png b/plugins/SlicerT/bg.png
deleted file mode 100644
index 0e00e4c17d3cd942aaf10549a2d2650d44facee9..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 28021
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
Eg1(VEumAu6


From 611884a01f935b2ff2aa8e7570e166384d200903 Mon Sep 17 00:00:00 2001
From: Katherine Pratt <consolegrl@gmail.com>
Date: Fri, 6 Oct 2023 17:20:38 -0400
Subject: [PATCH 49/99] Removed soft glow.

---
 plugins/SlicerT/artwork.png | Bin 23467 -> 14209 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)

diff --git a/plugins/SlicerT/artwork.png b/plugins/SlicerT/artwork.png
index 82a80897b2294502197ce840c02b63c65ecfc767..76dfbc5c5cd0bdb45e5ee85051f7b2898bb3a1cc 100644
GIT binary patch
literal 14209
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
Z(^kQ6`rgX%^G_^*l$g9|rLbY({{fBd#svTX

literal 23467
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


From 2d22249379ea9c449e0c5be1c618376588c8ecc2 Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Sat, 7 Oct 2023 12:57:55 +0200
Subject: [PATCH 50/99] Fixed load crashes + findSlices cleanup

---
 plugins/SlicerT/SlicerT.cpp | 17 +++++++++++++++--
 1 file changed, 15 insertions(+), 2 deletions(-)

diff --git a/plugins/SlicerT/SlicerT.cpp b/plugins/SlicerT/SlicerT.cpp
index 01e3f5254cf..c30d2b00ca1 100644
--- a/plugins/SlicerT/SlicerT.cpp
+++ b/plugins/SlicerT/SlicerT.cpp
@@ -72,12 +72,14 @@ PhaseVocoder::~PhaseVocoder()
 
 void PhaseVocoder::loadData(std::vector<float> originalData, int sampleRate, float newRatio)
 {
+	m_dataLock.lock();
+
 	m_originalBuffer = originalData;
 	m_originalSampleRate = sampleRate;
 	m_scaleRatio = -1; // force update, kinda hacky
 
+	m_dataLock.unlock(); // stupid, but QRecursiveMutex is too expensive to have in updateParas and getFrames
 	updateParams(newRatio);
-
 	m_dataLock.lock();
 
 	// set buffer sizes
@@ -372,13 +374,24 @@ void SlicerT::findSlices()
 
 	// computacion params
 	const int windowSize = 512;
-	const int minDist = 2048;
+	const float minBeatLength = 0.05f; // in seconds, ~ 1/4 length at 220 bpm
+
+	int sampleRate = m_originalSample.sampleRate();
+	int minDist = sampleRate * minBeatLength;
 
 	// copy vector into one vector, averaging channels
+	float maxMag = -1;
 	std::vector<float> singleChannel(m_originalSample.frames(), 0);
 	for (int i = 0; i < m_originalSample.frames(); i++)
 	{
 		singleChannel[i] = (m_originalSample.data()[i][0] + m_originalSample.data()[i][1]) / 2;
+		maxMag = std::max(maxMag, singleChannel[i]);
+	}
+
+	// normalize
+	for (int i = 0; i < singleChannel.size(); i++)
+	{
+		singleChannel[i] /= maxMag;
 	}
 
 	// buffers

From 3e0419f20cdad0b5a0ec578f189804ed18701656 Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Sat, 7 Oct 2023 15:21:31 +0200
Subject: [PATCH 51/99] Added sync button

---
 plugins/SlicerT/SlicerT.cpp   | 12 ++++++++++--
 plugins/SlicerT/SlicerT.h     |  1 +
 plugins/SlicerT/SlicerTUI.cpp |  6 ++++++
 plugins/SlicerT/SlicerTUI.h   |  2 ++
 4 files changed, 19 insertions(+), 2 deletions(-)

diff --git a/plugins/SlicerT/SlicerT.cpp b/plugins/SlicerT/SlicerT.cpp
index c30d2b00ca1..dbd47cf56f2 100644
--- a/plugins/SlicerT/SlicerT.cpp
+++ b/plugins/SlicerT/SlicerT.cpp
@@ -111,6 +111,12 @@ void PhaseVocoder::getFrames(std::vector<float>& outData, int start, int frames)
 	if (m_originalBuffer.size() < 2048) { return; }
 	m_dataLock.lock();
 
+	if (m_scaleRatio == 1) { // directly copy original data
+		memcpy(outData.data(), m_originalBuffer.data() + start, frames*sizeof(float));
+		m_dataLock.unlock();
+		return;
+	}
+
 	int windowMargin = s_overSampling / 2; // numbers of windows before full quality
 	int startWindow = std::max(0.0f, (float)start / m_outStepSize - windowMargin);
 	int endWindow = std::min((float)m_numWindows, (float)(start + frames) / m_outStepSize + windowMargin);
@@ -287,6 +293,7 @@ SlicerT::SlicerT(InstrumentTrack* instrumentTrack)
 	, m_fadeOutFrames(400.0f, 0.0f, 8192.0f, 1.0f, this, tr("FadeOut"))
 	, m_originalBPM(1, 1, 999, this, tr("Original bpm"))
 	, m_sliceSnap(this, tr("Slice snap"))
+	, m_enableSync(true, this, tr("BPM sync"))
 	, m_originalSample()
 	, m_phaseVocoder()
 	, m_parentTrack(instrumentTrack)
@@ -306,7 +313,8 @@ void SlicerT::playNote(NotePlayHandle* handle, sampleFrame* workingBuffer)
 	if (m_originalSample.frames() < 2048) { return; }
 
 	// update current speed ratio, in case bpm changed
-	const float speedRatio = (float)m_originalBPM.value() / Engine::getSong()->getTempo();
+	float speedRatio = (float)m_originalBPM.value() / Engine::getSong()->getTempo();
+	if (!m_enableSync.value()) { speedRatio = 1; } // disable timeshift
 	m_phaseVocoder.setScaleRatio(speedRatio);
 
 	// current playback status
@@ -497,7 +505,7 @@ void SlicerT::writeToMidi(std::vector<Note>* outClip)
 	if (m_originalSample.frames() < 2048) { return; }
 
 	// update incase bpm changed
-	const float speedRatio = (float)m_originalBPM.value() / Engine::getSong()->getTempo();
+	float speedRatio = (float)m_originalBPM.value() / Engine::getSong()->getTempo();
 	m_phaseVocoder.setScaleRatio(speedRatio);
 
 	// calculate how many "beats" are in the sample
diff --git a/plugins/SlicerT/SlicerT.h b/plugins/SlicerT/SlicerT.h
index 3e1b8d4992a..871a7e80bc6 100644
--- a/plugins/SlicerT/SlicerT.h
+++ b/plugins/SlicerT/SlicerT.h
@@ -177,6 +177,7 @@ public slots:
 	FloatModel m_fadeOutFrames;
 	IntModel m_originalBPM;
 	ComboBoxModel m_sliceSnap;
+	BoolModel m_enableSync;
 
 	// sample buffers
 	SampleBuffer m_originalSample;
diff --git a/plugins/SlicerT/SlicerTUI.cpp b/plugins/SlicerT/SlicerTUI.cpp
index 0f5fe93a7ba..bf305cb3084 100644
--- a/plugins/SlicerT/SlicerTUI.cpp
+++ b/plugins/SlicerT/SlicerTUI.cpp
@@ -48,6 +48,7 @@ SlicerTUI::SlicerTUI(SlicerT* instrument, QWidget* parent)
 	, m_fadeOutKnob(this)
 	, m_bpmBox(3, "21pink", this)
 	, m_snapSetting(this, "Slice snap")
+	, m_syncToggle("Sync", this, "SyncToggle", LedCheckBox::LedColor::Green)
 	, m_resetButton(this, nullptr)
 	, m_midiExportButton(this, nullptr)
 	, m_wf(248, 128, instrument, this)
@@ -69,6 +70,11 @@ SlicerTUI::SlicerTUI(SlicerT* instrument, QWidget* parent)
 	m_snapSetting.setToolTip(tr("Set slice snapping for detection"));
 	m_snapSetting.setModel(&m_slicerTParent->m_sliceSnap);
 
+	// sync toggle
+	m_syncToggle.move(135, 187);
+	m_syncToggle.setToolTip(tr("Enable BPM sync"));
+	m_syncToggle.setModel(&m_slicerTParent->m_enableSync);
+
 	// bpm spin box
 	m_bpmBox.move(135, 203);
 	m_bpmBox.setToolTip(tr("Original sample BPM"));
diff --git a/plugins/SlicerT/SlicerTUI.h b/plugins/SlicerT/SlicerTUI.h
index adcc1d0ef2b..1bd180adb0d 100644
--- a/plugins/SlicerT/SlicerTUI.h
+++ b/plugins/SlicerT/SlicerTUI.h
@@ -32,6 +32,7 @@
 #include "InstrumentView.h"
 #include "Knob.h"
 #include "LcdSpinBox.h"
+#include "LedCheckBox.h"
 #include "PixmapButton.h"
 #include "WaveForm.h"
 
@@ -78,6 +79,7 @@ protected slots:
 	SlicerTKnob m_fadeOutKnob;
 	LcdSpinBox m_bpmBox;
 	ComboBox m_snapSetting;
+	LedCheckBox m_syncToggle;
 
 	// buttons
 	PixmapButton m_resetButton;

From 6990944ec5bac854a4bb1afb9cb629fc48532463 Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Tue, 10 Oct 2023 22:49:18 +0200
Subject: [PATCH 52/99] added pitch shifting, sometimes crashes

---
 plugins/SlicerT/SlicerT.cpp | 41 ++++++++++++++++++++++++++++---------
 plugins/SlicerT/SlicerT.h   |  2 +-
 2 files changed, 32 insertions(+), 11 deletions(-)

diff --git a/plugins/SlicerT/SlicerT.cpp b/plugins/SlicerT/SlicerT.cpp
index 43f677e0c4f..994bf5bc570 100644
--- a/plugins/SlicerT/SlicerT.cpp
+++ b/plugins/SlicerT/SlicerT.cpp
@@ -312,18 +312,23 @@ void SlicerT::playNote(NotePlayHandle* handle, sampleFrame* workingBuffer)
 {
 	if (m_originalSample.frames() < 2048) { return; }
 
-	// update current speed ratio, in case bpm changed
-	float speedRatio = (float)m_originalBPM.value() / Engine::getSong()->getTempo();
-	if (!m_enableSync.value()) { speedRatio = 1; } // disable timeshift
-	m_phaseVocoder.setScaleRatio(speedRatio);
-
-	// current playback status
-	const int totalFrames = m_phaseVocoder.frames();
+	// playback parameters
+	// const float freq = handle->frequency();
+	const float pitchRatio = pow(2, m_parentTrack->pitchModel()->value() / 1200);
+	const float inversePitchRatio = 1.0f / pitchRatio;
 	const int noteIndex = handle->key() - m_parentTrack->baseNote();
+	const int playedFrames = handle->totalFramesPlayed();
 	const fpp_t frames = handle->framesLeftForCurrentPeriod();
 	const f_cnt_t offset = handle->noteOffset();
-	const int playedFrames = handle->totalFramesPlayed();
+	const int bpm = Engine::getSong()->getTempo();
 
+	// update scaling parameters
+	float speedRatio = (float)m_originalBPM.value() / bpm;
+	if (!m_enableSync.value()) { speedRatio = 1; } // disable timeshift
+	m_phaseVocoder.setScaleRatio(speedRatio);
+	speedRatio *= inversePitchRatio; // adjust for pitch bend
+
+	int totalFrames = inversePitchRatio * m_phaseVocoder.frames(); // adjust frames played with regards to pitch
 	int sliceStart, sliceEnd;
 	if (noteIndex > m_slicePoints.size() - 2 || noteIndex < 0) // full sample if ouside range
 	{
@@ -343,8 +348,23 @@ void SlicerT::playNote(NotePlayHandle* handle, sampleFrame* workingBuffer)
 
 	if (noteFramesLeft > 0)
 	{
-		int framesToCopy = std::min((int)frames, noteFramesLeft);
-		m_phaseVocoder.getFrames(workingBuffer + offset, currentNoteFrame, framesToCopy);
+		// load sample segmengt, with regards to pitch settings
+		// TODO: THIS CRASHES OFTEN
+		std::vector<sampleFrame> prePitchBuffer(pitchRatio * frames + 1, {0.0f, 0.0f}); // round the frames up
+		int framesToCopy = std::min((int)(pitchRatio * frames) + 1, noteFramesLeft);	// same here
+		int framesIndex = std::min((int)(pitchRatio * currentNoteFrame), m_phaseVocoder.frames() - framesToCopy);
+		m_phaseVocoder.getFrames(prePitchBuffer.data(), framesIndex, framesToCopy);
+
+		// resample for pitch bend
+		SRC_DATA resamplerData;
+
+		resamplerData.data_in = (float*)prePitchBuffer.data();	 // wtf
+		resamplerData.data_out = (float*)workingBuffer + offset; // wtf is this
+		resamplerData.input_frames = prePitchBuffer.size();
+		resamplerData.output_frames = frames;
+		resamplerData.src_ratio = inversePitchRatio;
+
+		src_simple(&resamplerData, SRC_SINC_MEDIUM_QUALITY, 2); // only 2 channels
 
 		// exponential fade out, applyRelease kinda sucks
 		if (noteFramesLeft < m_fadeOutFrames.value())
@@ -367,6 +387,7 @@ void SlicerT::playNote(NotePlayHandle* handle, sampleFrame* workingBuffer)
 		float absoluteCurrentNote = (float)currentNoteFrame / totalFrames;
 		float absoluteStartNote = (float)sliceStart / totalFrames;
 		float abslouteEndNote = (float)sliceEnd / totalFrames;
+		printf("curr: %f, start: %f, end: %f\n", absoluteCurrentNote, absoluteStartNote, abslouteEndNote);
 		emit isPlaying(absoluteCurrentNote, absoluteStartNote, abslouteEndNote);
 	}
 	else { emit isPlaying(-1, 0, 0); }
diff --git a/plugins/SlicerT/SlicerT.h b/plugins/SlicerT/SlicerT.h
index 312d911484c..3b207d4f1b4 100644
--- a/plugins/SlicerT/SlicerT.h
+++ b/plugins/SlicerT/SlicerT.h
@@ -106,7 +106,7 @@ class DynamicPlaybackBuffer
 		: m_leftChannel()
 		, m_rightChannel()
 	{}
-	
+
 	void loadSample(const sampleFrame* outData, int frames, int sampleRate, float newRatio)
 	{
 		std::vector<float> leftData(frames, 0);

From 0cc28bd713984ccc2db8ba53a1dc29a6657dc357 Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Wed, 11 Oct 2023 18:59:31 +0200
Subject: [PATCH 53/99] pitch fixes

---
 plugins/SlicerT/SlicerT.cpp | 19 +++++++++++--------
 1 file changed, 11 insertions(+), 8 deletions(-)

diff --git a/plugins/SlicerT/SlicerT.cpp b/plugins/SlicerT/SlicerT.cpp
index 994bf5bc570..4edad0f54f1 100644
--- a/plugins/SlicerT/SlicerT.cpp
+++ b/plugins/SlicerT/SlicerT.cpp
@@ -313,14 +313,13 @@ void SlicerT::playNote(NotePlayHandle* handle, sampleFrame* workingBuffer)
 	if (m_originalSample.frames() < 2048) { return; }
 
 	// playback parameters
-	// const float freq = handle->frequency();
-	const float pitchRatio = pow(2, m_parentTrack->pitchModel()->value() / 1200);
-	const float inversePitchRatio = 1.0f / pitchRatio;
 	const int noteIndex = handle->key() - m_parentTrack->baseNote();
 	const int playedFrames = handle->totalFramesPlayed();
 	const fpp_t frames = handle->framesLeftForCurrentPeriod();
 	const f_cnt_t offset = handle->noteOffset();
 	const int bpm = Engine::getSong()->getTempo();
+	const float pitchRatio = pow(2, m_parentTrack->pitchModel()->value() / 1200);
+	const float inversePitchRatio = 1.0f / pitchRatio;
 
 	// update scaling parameters
 	float speedRatio = (float)m_originalBPM.value() / bpm;
@@ -348,11 +347,13 @@ void SlicerT::playNote(NotePlayHandle* handle, sampleFrame* workingBuffer)
 
 	if (noteFramesLeft > 0)
 	{
-		// load sample segmengt, with regards to pitch settings
-		// TODO: THIS CRASHES OFTEN
-		std::vector<sampleFrame> prePitchBuffer(pitchRatio * frames + 1, {0.0f, 0.0f}); // round the frames up
-		int framesToCopy = std::min((int)(pitchRatio * frames) + 1, noteFramesLeft);	// same here
+		// round the frames up, the more there are the less artyfacts are on each window end
+		// but its also more expensive, so just deal with it if you pitch shift
+		int framesToCopy = pitchRatio * frames + 1;
 		int framesIndex = std::min((int)(pitchRatio * currentNoteFrame), m_phaseVocoder.frames() - framesToCopy);
+
+		// load sample segmengt, with regards to pitch settings
+		std::vector<sampleFrame> prePitchBuffer(framesToCopy, {0.0f, 0.0f});
 		m_phaseVocoder.getFrames(prePitchBuffer.data(), framesIndex, framesToCopy);
 
 		// resample for pitch bend
@@ -364,7 +365,9 @@ void SlicerT::playNote(NotePlayHandle* handle, sampleFrame* workingBuffer)
 		resamplerData.output_frames = frames;
 		resamplerData.src_ratio = inversePitchRatio;
 
-		src_simple(&resamplerData, SRC_SINC_MEDIUM_QUALITY, 2); // only 2 channels
+		// if pitch is changed, interpolate, else just copy
+		if (pitchRatio != 1.0f) { src_simple(&resamplerData, SRC_SINC_MEDIUM_QUALITY, 2); }
+		else { memcpy(workingBuffer + offset, prePitchBuffer.data(), frames * sizeof(sampleFrame)); }
 
 		// exponential fade out, applyRelease kinda sucks
 		if (noteFramesLeft < m_fadeOutFrames.value())

From 5a56aea2d09713cac58d071c9fb007b653450b3d Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Wed, 11 Oct 2023 20:33:25 +0200
Subject: [PATCH 54/99] MacOs build fixes

---
 plugins/SlicerT/CMakeLists.txt |  5 ++++-
 plugins/SlicerT/SlicerT.cpp    | 26 +++++++++++++-------------
 2 files changed, 17 insertions(+), 14 deletions(-)

diff --git a/plugins/SlicerT/CMakeLists.txt b/plugins/SlicerT/CMakeLists.txt
index 365a6042537..00a425ac69b 100644
--- a/plugins/SlicerT/CMakeLists.txt
+++ b/plugins/SlicerT/CMakeLists.txt
@@ -1,7 +1,10 @@
 INCLUDE(BuildPlugin)
 
 INCLUDE_DIRECTORIES(${FFTW3F_INCLUDE_DIRS})
-
 LINK_LIBRARIES(${FFTW3F_LIBRARIES})
 
+INCLUDE_DIRECTORIES(${SAMPLERATE_INCLUDE_DIRS})
+LINK_DIRECTORIES(${SAMPLERATE_LIBRARY_DIRS})
+LINK_LIBRARIES(${SAMPLERATE_LIBRARIES})
+
 BUILD_PLUGIN(slicert SlicerT.cpp SlicerT.h SlicerTUI.cpp SlicerTUI.h WaveForm.cpp WaveForm.h MOCFILES SlicerT.h SlicerTUI.h WaveForm.h EMBEDDED_RESOURCES "${CMAKE_CURRENT_SOURCE_DIR}/*.png")
\ No newline at end of file
diff --git a/plugins/SlicerT/SlicerT.cpp b/plugins/SlicerT/SlicerT.cpp
index 4edad0f54f1..02297f87fe1 100644
--- a/plugins/SlicerT/SlicerT.cpp
+++ b/plugins/SlicerT/SlicerT.cpp
@@ -349,24 +349,25 @@ void SlicerT::playNote(NotePlayHandle* handle, sampleFrame* workingBuffer)
 	{
 		// round the frames up, the more there are the less artyfacts are on each window end
 		// but its also more expensive, so just deal with it if you pitch shift
-		int framesToCopy = pitchRatio * frames + 1;
+		int framesToCopy = pitchRatio * frames + 128;
 		int framesIndex = std::min((int)(pitchRatio * currentNoteFrame), m_phaseVocoder.frames() - framesToCopy);
 
 		// load sample segmengt, with regards to pitch settings
 		std::vector<sampleFrame> prePitchBuffer(framesToCopy, {0.0f, 0.0f});
 		m_phaseVocoder.getFrames(prePitchBuffer.data(), framesIndex, framesToCopy);
 
-		// resample for pitch bend
-		SRC_DATA resamplerData;
-
-		resamplerData.data_in = (float*)prePitchBuffer.data();	 // wtf
-		resamplerData.data_out = (float*)workingBuffer + offset; // wtf is this
-		resamplerData.input_frames = prePitchBuffer.size();
-		resamplerData.output_frames = frames;
-		resamplerData.src_ratio = inversePitchRatio;
-
-		// if pitch is changed, interpolate, else just copy
-		if (pitchRatio != 1.0f) { src_simple(&resamplerData, SRC_SINC_MEDIUM_QUALITY, 2); }
+		// if pitch is changed, resample, else just copy
+		if (pitchRatio != 1.0f)
+		{ // resample for pitch bend
+			SRC_DATA resamplerData;
+
+			resamplerData.data_in = (float*)prePitchBuffer.data();	 // wtf
+			resamplerData.data_out = (float*)workingBuffer + offset; // wtf is this
+			resamplerData.input_frames = prePitchBuffer.size();
+			resamplerData.output_frames = frames;
+			resamplerData.src_ratio = inversePitchRatio;
+			src_simple(&resamplerData, SRC_SINC_MEDIUM_QUALITY, 2);
+		}
 		else { memcpy(workingBuffer + offset, prePitchBuffer.data(), frames * sizeof(sampleFrame)); }
 
 		// exponential fade out, applyRelease kinda sucks
@@ -390,7 +391,6 @@ void SlicerT::playNote(NotePlayHandle* handle, sampleFrame* workingBuffer)
 		float absoluteCurrentNote = (float)currentNoteFrame / totalFrames;
 		float absoluteStartNote = (float)sliceStart / totalFrames;
 		float abslouteEndNote = (float)sliceEnd / totalFrames;
-		printf("curr: %f, start: %f, end: %f\n", absoluteCurrentNote, absoluteStartNote, abslouteEndNote);
 		emit isPlaying(absoluteCurrentNote, absoluteStartNote, abslouteEndNote);
 	}
 	else { emit isPlaying(-1, 0, 0); }

From 441052c516af95b97a5cf9fb4ec4a418e0b78622 Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Wed, 11 Oct 2023 22:19:33 +0200
Subject: [PATCH 55/99] use linear interpolation

---
 plugins/SlicerT/SlicerT.cpp | 13 ++++++-------
 1 file changed, 6 insertions(+), 7 deletions(-)

diff --git a/plugins/SlicerT/SlicerT.cpp b/plugins/SlicerT/SlicerT.cpp
index 02297f87fe1..e503ce97be8 100644
--- a/plugins/SlicerT/SlicerT.cpp
+++ b/plugins/SlicerT/SlicerT.cpp
@@ -347,9 +347,7 @@ void SlicerT::playNote(NotePlayHandle* handle, sampleFrame* workingBuffer)
 
 	if (noteFramesLeft > 0)
 	{
-		// round the frames up, the more there are the less artyfacts are on each window end
-		// but its also more expensive, so just deal with it if you pitch shift
-		int framesToCopy = pitchRatio * frames + 128;
+		int framesToCopy = pitchRatio * frames + 1; // just in case
 		int framesIndex = std::min((int)(pitchRatio * currentNoteFrame), m_phaseVocoder.frames() - framesToCopy);
 
 		// load sample segmengt, with regards to pitch settings
@@ -358,15 +356,16 @@ void SlicerT::playNote(NotePlayHandle* handle, sampleFrame* workingBuffer)
 
 		// if pitch is changed, resample, else just copy
 		if (pitchRatio != 1.0f)
-		{ // resample for pitch bend
+		{
 			SRC_DATA resamplerData;
 
-			resamplerData.data_in = (float*)prePitchBuffer.data();	 // wtf
-			resamplerData.data_out = (float*)workingBuffer + offset; // wtf is this
+			resamplerData.data_in = (float*)prePitchBuffer.data();	   // wtf
+			resamplerData.data_out = (float*)(workingBuffer + offset); // wtf is this
 			resamplerData.input_frames = prePitchBuffer.size();
 			resamplerData.output_frames = frames;
 			resamplerData.src_ratio = inversePitchRatio;
-			src_simple(&resamplerData, SRC_SINC_MEDIUM_QUALITY, 2);
+
+			src_simple(&resamplerData, SRC_LINEAR, 2);
 		}
 		else { memcpy(workingBuffer + offset, prePitchBuffer.data(), frames * sizeof(sampleFrame)); }
 

From 9185d2d6d10b3aaf212e534cc1ba5ec7747672c2 Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Thu, 12 Oct 2023 15:07:55 +0200
Subject: [PATCH 56/99] copyright + div by 0 fixes

---
 plugins/SlicerT/SlicerT.cpp   | 8 ++++----
 plugins/SlicerT/SlicerT.h     | 2 +-
 plugins/SlicerT/SlicerTUI.cpp | 2 +-
 plugins/SlicerT/SlicerTUI.h   | 2 +-
 plugins/SlicerT/WaveForm.cpp  | 4 +++-
 plugins/SlicerT/WaveForm.h    | 2 +-
 6 files changed, 11 insertions(+), 9 deletions(-)

diff --git a/plugins/SlicerT/SlicerT.cpp b/plugins/SlicerT/SlicerT.cpp
index e503ce97be8..8ec3f5616e7 100644
--- a/plugins/SlicerT/SlicerT.cpp
+++ b/plugins/SlicerT/SlicerT.cpp
@@ -1,7 +1,7 @@
 /*
  * SlicerT.cpp - simple slicer plugin
  *
- * Copyright (c) 2006-2008 Andreas Brandmaier <andy/at/brandmaier/dot/de>
+ * Copyright (c) 2006-2008 Daniel Kauss Serna <daniel.kauss.serna@gmail.com>
  *
  * This file is part of LMMS - https://lmms.io
  *
@@ -43,7 +43,7 @@ Plugin::Descriptor PLUGIN_EXPORT slicert_plugin_descriptor = {
 	LMMS_STRINGIFY(PLUGIN_NAME),
 	"SlicerT",
 	QT_TRANSLATE_NOOP("PluginBrowser", "Basic Slicer"),
-	"Daniel Kauss Serna <daniel.kauss.serna/at/gmail.com>",
+	"Daniel Kauss Serna <daniel.kauss.serna@gmail.com>",
 	0x0100,
 	Plugin::Type::Instrument,
 	new PluginPixmapLoader("icon"),
@@ -434,7 +434,7 @@ void SlicerT::findSlices()
 
 	int lastPoint = -minDist - 1; // to always store 0 first
 	float spectralFlux = 0;
-	float prevFlux = 0;
+	float prevFlux = 1E-10; // small value, no divison by zero
 	float real, imag, magnitude, diff;
 
 	for (int i = 0; i < singleChannel.size() - windowSize; i += windowSize)
@@ -465,7 +465,7 @@ void SlicerT::findSlices()
 		}
 
 		prevFlux = spectralFlux;
-		spectralFlux = 0;
+		spectralFlux = 1E-10; // again for no divison by zero
 	}
 
 	m_slicePoints.push_back(m_originalSample.frames());
diff --git a/plugins/SlicerT/SlicerT.h b/plugins/SlicerT/SlicerT.h
index 3b207d4f1b4..350cda7bbf9 100644
--- a/plugins/SlicerT/SlicerT.h
+++ b/plugins/SlicerT/SlicerT.h
@@ -1,7 +1,7 @@
 /*
  * SlicerT.h - declaration of class SlicerT
  *
- * Copyright (c) 2006-2008 Andreas Brandmaier <andy/at/brandmaier/dot/de>
+ * Copyright (c) 2006-2008 Daniel Kauss Serna <daniel.kauss.serna@gmail.com>
  *
  * This file is part of LMMS - https://lmms.io
  *
diff --git a/plugins/SlicerT/SlicerTUI.cpp b/plugins/SlicerT/SlicerTUI.cpp
index 8795437cf22..8bea9eb5f6b 100644
--- a/plugins/SlicerT/SlicerTUI.cpp
+++ b/plugins/SlicerT/SlicerTUI.cpp
@@ -1,7 +1,7 @@
 /*
  * SlicerTUI.cpp - controls the UI for slicerT
  *
- * Copyright (c) 2006-2008 Andreas Brandmaier <andy/at/brandmaier/dot/de>
+ * Copyright (c) 2006-2008 Daniel Kauss Serna <daniel.kauss.serna@gmail.com>
  *
  * This file is part of LMMS - https://lmms.io
  *
diff --git a/plugins/SlicerT/SlicerTUI.h b/plugins/SlicerT/SlicerTUI.h
index bf84bc4d67b..8fc0493b23f 100644
--- a/plugins/SlicerT/SlicerTUI.h
+++ b/plugins/SlicerT/SlicerTUI.h
@@ -1,7 +1,7 @@
 /*
  * SlicerTUI.h - declaration of class SlicerTUI
  *
- * Copyright (c) 2006-2008 Andreas Brandmaier <andy/at/brandmaier/dot/de>
+ * Copyright (c) 2006-2008 Daniel Kauss Serna <daniel.kauss.serna@gmail.com>
  *
  * This file is part of LMMS - https://lmms.io
  *
diff --git a/plugins/SlicerT/WaveForm.cpp b/plugins/SlicerT/WaveForm.cpp
index c6f8ad72177..23966583926 100644
--- a/plugins/SlicerT/WaveForm.cpp
+++ b/plugins/SlicerT/WaveForm.cpp
@@ -1,7 +1,7 @@
 /*
  * WaveForm.cpp - slice editor for SlicerT
  *
- * Copyright (c) 2006-2008 Andreas Brandmaier <andy/at/brandmaier/dot/de>
+ * Copyright (c) 2006-2008 Daniel Kauss Serna <daniel.kauss.serna@gmail.com>
  *
  * This file is part of LMMS - https://lmms.io
  *
@@ -73,6 +73,7 @@ WaveForm::WaveForm(int w, int h, SlicerT* instrument, QWidget* parent)
 void WaveForm::drawSeekerWaveform()
 {
 	m_seekerWaveform.fill(m_waveformBgColor);
+	if (m_currentSample.frames() < 2048) { return; }
 	QPainter brush(&m_seekerWaveform);
 	brush.setPen(m_waveformColor);
 
@@ -83,6 +84,7 @@ void WaveForm::drawSeekerWaveform()
 void WaveForm::drawSeeker()
 {
 	m_seeker.fill(m_waveformBgColor);
+	if (m_currentSample.frames() < 2048) { return; }
 	QPainter brush(&m_seeker);
 
 	// draw slice points
diff --git a/plugins/SlicerT/WaveForm.h b/plugins/SlicerT/WaveForm.h
index 3e74b995f9e..2183ceca021 100644
--- a/plugins/SlicerT/WaveForm.h
+++ b/plugins/SlicerT/WaveForm.h
@@ -1,7 +1,7 @@
 /*
  * WaveForm.h - declaration of class WaveForm
  *
- * Copyright (c) 2006-2008 Andreas Brandmaier <andy/at/brandmaier/dot/de>
+ * Copyright (c) 2006-2008 Daniel Kauss Serna <daniel.kauss.serna@gmail.com>
  *
  * This file is part of LMMS - https://lmms.io
  *

From fbbe9f04cf92941338a4c54ebab34f63f487e55a Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Fri, 13 Oct 2023 13:29:13 +0200
Subject: [PATCH 57/99] Fixed rare crash + name changes + license

---
 data/themes/classic/style.css                 |  8 ++++
 plugins/SlicerT/CMakeLists.txt                |  2 +-
 plugins/SlicerT/SlicerT.cpp                   | 15 ++++---
 plugins/SlicerT/SlicerT.h                     |  6 +--
 .../{SlicerTUI.cpp => SlicerTView.cpp}        | 26 +++++-------
 .../SlicerT/{SlicerTUI.h => SlicerTView.h}    |  8 ++--
 plugins/SlicerT/WaveForm.cpp                  | 40 +++++++++----------
 plugins/SlicerT/WaveForm.h                    | 20 +++++-----
 8 files changed, 65 insertions(+), 60 deletions(-)
 rename plugins/SlicerT/{SlicerTUI.cpp => SlicerTView.cpp} (91%)
 rename plugins/SlicerT/{SlicerTUI.h => SlicerTView.h} (89%)

diff --git a/data/themes/classic/style.css b/data/themes/classic/style.css
index ac22a14ec21..6e39fbcc310 100644
--- a/data/themes/classic/style.css
+++ b/data/themes/classic/style.css
@@ -902,6 +902,14 @@ lmms--gui--SidInstrumentView lmms--gui--Knob {
 	qproperty-lineWidth: 2;
 }
 
+lmms--gui--SlicerTUI lmms--gui--Knob {
+	color: rgb(162, 128, 226);
+	qproperty-outerColor: rgb( 162, 128, 226 );
+	qproperty-innerRadius: 1;
+	qproperty-outerRadius: 11;
+	qproperty-lineWidth: 3;
+}
+
 lmms--gui--WatsynView lmms--gui--Knob {
 	qproperty-innerRadius: 1;
 	qproperty-outerRadius: 7;
diff --git a/plugins/SlicerT/CMakeLists.txt b/plugins/SlicerT/CMakeLists.txt
index 00a425ac69b..8bec64edaff 100644
--- a/plugins/SlicerT/CMakeLists.txt
+++ b/plugins/SlicerT/CMakeLists.txt
@@ -7,4 +7,4 @@ INCLUDE_DIRECTORIES(${SAMPLERATE_INCLUDE_DIRS})
 LINK_DIRECTORIES(${SAMPLERATE_LIBRARY_DIRS})
 LINK_LIBRARIES(${SAMPLERATE_LIBRARIES})
 
-BUILD_PLUGIN(slicert SlicerT.cpp SlicerT.h SlicerTUI.cpp SlicerTUI.h WaveForm.cpp WaveForm.h MOCFILES SlicerT.h SlicerTUI.h WaveForm.h EMBEDDED_RESOURCES "${CMAKE_CURRENT_SOURCE_DIR}/*.png")
\ No newline at end of file
+BUILD_PLUGIN(slicert SlicerT.cpp SlicerT.h SlicerTView.cpp SlicerTView.h WaveForm.cpp WaveForm.h MOCFILES SlicerT.h SlicerTView.h WaveForm.h EMBEDDED_RESOURCES "${CMAKE_CURRENT_SOURCE_DIR}/*.png")
\ No newline at end of file
diff --git a/plugins/SlicerT/SlicerT.cpp b/plugins/SlicerT/SlicerT.cpp
index 8ec3f5616e7..a2abe65e08c 100644
--- a/plugins/SlicerT/SlicerT.cpp
+++ b/plugins/SlicerT/SlicerT.cpp
@@ -1,7 +1,7 @@
 /*
  * SlicerT.cpp - simple slicer plugin
  *
- * Copyright (c) 2006-2008 Daniel Kauss Serna <daniel.kauss.serna@gmail.com>
+ * Copyright (c) 2023 Daniel Kauss Serna <daniel.kauss.serna@gmail.com>
  *
  * This file is part of LMMS - https://lmms.io
  *
@@ -118,8 +118,11 @@ void PhaseVocoder::getFrames(std::vector<float>& outData, int start, int frames)
 	}
 
 	int windowMargin = s_overSampling / 2; // numbers of windows before full quality
-	int startWindow = std::max(0.0f, (float)start / m_outStepSize - windowMargin);
-	int endWindow = std::min((float)m_numWindows, (float)(start + frames) / m_outStepSize + windowMargin);
+	int startWindow = (float)start / m_outStepSize - windowMargin;
+	int endWindow = (float)(start + frames) / m_outStepSize + windowMargin;
+
+	startWindow = std::clamp(startWindow, 0, m_numWindows - 1);
+	endWindow = std::clamp(endWindow, 0, m_numWindows - 1);
 
 	// discard previous phaseSum if not processed
 	if (!m_processedWindows[startWindow])
@@ -379,8 +382,8 @@ void SlicerT::playNote(NotePlayHandle* handle, sampleFrame* workingBuffer)
 				fadeValue = std::clamp(fadeValue, 0.0f, 1.0f);
 				fadeValue = pow(fadeValue, 2);
 
-				workingBuffer[i][0] *= fadeValue;
-				workingBuffer[i][1] *= fadeValue;
+				workingBuffer[i + offset][0] *= fadeValue;
+				workingBuffer[i + offset][1] *= fadeValue;
 			}
 		}
 
@@ -653,7 +656,7 @@ QString SlicerT::nodeName() const
 
 gui::PluginView* SlicerT::instantiateView(QWidget* parent)
 {
-	return (new gui::SlicerTUI(this, parent));
+	return (new gui::SlicerTView(this, parent));
 }
 
 extern "C" {
diff --git a/plugins/SlicerT/SlicerT.h b/plugins/SlicerT/SlicerT.h
index 350cda7bbf9..04babfc5371 100644
--- a/plugins/SlicerT/SlicerT.h
+++ b/plugins/SlicerT/SlicerT.h
@@ -1,7 +1,7 @@
 /*
  * SlicerT.h - declaration of class SlicerT
  *
- * Copyright (c) 2006-2008 Daniel Kauss Serna <daniel.kauss.serna@gmail.com>
+ * Copyright (c) 2023 Daniel Kauss Serna <daniel.kauss.serna@gmail.com>
  *
  * This file is part of LMMS - https://lmms.io
  *
@@ -32,7 +32,7 @@
 #include "InstrumentView.h"
 #include "Note.h"
 #include "SampleBuffer.h"
-#include "SlicerTUI.h"
+#include "SlicerTView.h"
 
 namespace lmms {
 
@@ -193,7 +193,7 @@ public slots:
 	void findSlices();
 	void findBPM();
 
-	friend class gui::SlicerTUI;
+	friend class gui::SlicerTView;
 	friend class gui::WaveForm;
 };
 } // namespace lmms
diff --git a/plugins/SlicerT/SlicerTUI.cpp b/plugins/SlicerT/SlicerTView.cpp
similarity index 91%
rename from plugins/SlicerT/SlicerTUI.cpp
rename to plugins/SlicerT/SlicerTView.cpp
index 8bea9eb5f6b..8ba28f631da 100644
--- a/plugins/SlicerT/SlicerTUI.cpp
+++ b/plugins/SlicerT/SlicerTView.cpp
@@ -1,7 +1,7 @@
 /*
- * SlicerTUI.cpp - controls the UI for slicerT
+ * SlicerTView.cpp - controls the UI for slicerT
  *
- * Copyright (c) 2006-2008 Daniel Kauss Serna <daniel.kauss.serna@gmail.com>
+ * Copyright (c) 2023 Daniel Kauss Serna <daniel.kauss.serna@gmail.com>
  *
  * This file is part of LMMS - https://lmms.io
  *
@@ -22,7 +22,7 @@
  *
  */
 
-#include "SlicerTUI.h"
+#include "SlicerTView.h"
 
 #include <QDropEvent>
 #include <QFileInfo>
@@ -41,7 +41,7 @@ namespace lmms {
 
 namespace gui {
 
-SlicerTUI::SlicerTUI(SlicerT* instrument, QWidget* parent)
+SlicerTView::SlicerTView(SlicerT* instrument, QWidget* parent)
 	: InstrumentViewFixedSize(instrument, parent)
 	, m_slicerTParent(instrument)
 	, m_noteThresholdKnob(this)
@@ -109,7 +109,7 @@ SlicerTUI::SlicerTUI(SlicerT* instrument, QWidget* parent)
 }
 
 // copied from piano roll
-void SlicerTUI::exportMidi()
+void SlicerTView::exportMidi()
 {
 	using namespace Clipboard;
 
@@ -133,7 +133,7 @@ void SlicerTUI::exportMidi()
 }
 
 // all the drag stuff is copied from AudioFileProcessor
-void SlicerTUI::dragEnterEvent(QDragEnterEvent* dee)
+void SlicerTView::dragEnterEvent(QDragEnterEvent* dee)
 {
 	// For mimeType() and MimeType enum class
 	using namespace Clipboard;
@@ -145,19 +145,13 @@ void SlicerTUI::dragEnterEvent(QDragEnterEvent* dee)
 		{
 			dee->acceptProposedAction();
 		}
-		else if (txt.section(':', 0, 0) == "samplefile")
-		{
-			dee->acceptProposedAction();
-		}
-		else
-		{
-			dee->ignore();
-		}
+		else if (txt.section(':', 0, 0) == "samplefile") { dee->acceptProposedAction(); }
+		else { dee->ignore(); }
 	}
 	else { dee->ignore(); }
 }
 
-void SlicerTUI::dropEvent(QDropEvent* de)
+void SlicerTView::dropEvent(QDropEvent* de)
 {
 	QString type = StringPairDrag::decodeKey(de);
 	QString value = StringPairDrag::decodeValue(de);
@@ -179,7 +173,7 @@ void SlicerTUI::dropEvent(QDropEvent* de)
 }
 
 // display button text
-void SlicerTUI::paintEvent(QPaintEvent* pe)
+void SlicerTView::paintEvent(QPaintEvent* pe)
 {
 	QPainter brush(this);
 	brush.setPen(QColor(255, 255, 255));
diff --git a/plugins/SlicerT/SlicerTUI.h b/plugins/SlicerT/SlicerTView.h
similarity index 89%
rename from plugins/SlicerT/SlicerTUI.h
rename to plugins/SlicerT/SlicerTView.h
index 8fc0493b23f..c624dc68708 100644
--- a/plugins/SlicerT/SlicerTUI.h
+++ b/plugins/SlicerT/SlicerTView.h
@@ -1,7 +1,7 @@
 /*
- * SlicerTUI.h - declaration of class SlicerTUI
+ * SlicerTView.h - declaration of class SlicerTView
  *
- * Copyright (c) 2006-2008 Daniel Kauss Serna <daniel.kauss.serna@gmail.com>
+ * Copyright (c) 2023 Daniel Kauss Serna <daniel.kauss.serna@gmail.com>
  *
  * This file is part of LMMS - https://lmms.io
  *
@@ -55,12 +55,12 @@ class SlicerTKnob : public Knob
 	}
 };
 
-class SlicerTUI : public InstrumentViewFixedSize
+class SlicerTView : public InstrumentViewFixedSize
 {
 	Q_OBJECT
 
 public:
-	SlicerTUI(SlicerT* instrument, QWidget* parent);
+	SlicerTView(SlicerT* instrument, QWidget* parent);
 
 protected slots:
 	void exportMidi();
diff --git a/plugins/SlicerT/WaveForm.cpp b/plugins/SlicerT/WaveForm.cpp
index 23966583926..7bcc70f337c 100644
--- a/plugins/SlicerT/WaveForm.cpp
+++ b/plugins/SlicerT/WaveForm.cpp
@@ -1,7 +1,7 @@
 /*
  * WaveForm.cpp - slice editor for SlicerT
  *
- * Copyright (c) 2006-2008 Daniel Kauss Serna <daniel.kauss.serna@gmail.com>
+ * Copyright (c) 2023 Daniel Kauss Serna <daniel.kauss.serna@gmail.com>
  *
  * This file is part of LMMS - https://lmms.io
  *
@@ -60,8 +60,8 @@ WaveForm::WaveForm(int w, int h, SlicerT* instrument, QWidget* parent)
 	setMouseTracking(true);
 
 	// draw backgrounds
-	m_sliceEditor.fill(m_waveformBgColor);
-	m_seekerWaveform.fill(m_waveformBgColor);
+	m_sliceEditor.fill(s_waveformBgColor);
+	m_seekerWaveform.fill(s_waveformBgColor);
 
 	// connect to playback
 	connect(m_slicerTParent, SIGNAL(isPlaying(float, float, float)), this, SLOT(isPlaying(float, float, float)));
@@ -72,10 +72,10 @@ WaveForm::WaveForm(int w, int h, SlicerT* instrument, QWidget* parent)
 
 void WaveForm::drawSeekerWaveform()
 {
-	m_seekerWaveform.fill(m_waveformBgColor);
+	m_seekerWaveform.fill(s_waveformBgColor);
 	if (m_currentSample.frames() < 2048) { return; }
 	QPainter brush(&m_seekerWaveform);
-	brush.setPen(m_waveformColor);
+	brush.setPen(s_waveformColor);
 
 	m_currentSample.visualize(
 		brush, QRect(0, 0, m_seekerWaveform.width(), m_seekerWaveform.height()), 0, m_currentSample.frames());
@@ -83,12 +83,12 @@ void WaveForm::drawSeekerWaveform()
 
 void WaveForm::drawSeeker()
 {
-	m_seeker.fill(m_waveformBgColor);
+	m_seeker.fill(s_waveformBgColor);
 	if (m_currentSample.frames() < 2048) { return; }
 	QPainter brush(&m_seeker);
 
 	// draw slice points
-	brush.setPen(m_sliceColor);
+	brush.setPen(s_sliceColor);
 	for (int i = 0; i < m_slicePoints.size(); i++)
 	{
 		float xPos = (float)m_slicePoints[i] / m_currentSample.frames() * m_seekerWidth;
@@ -106,31 +106,31 @@ void WaveForm::drawSeeker()
 	float noteEndPosX = (m_noteEnd - m_noteStart) * m_seekerWidth;
 
 	// draw current playBack
-	brush.setPen(m_playColor);
+	brush.setPen(s_playColor);
 	brush.drawLine(noteCurrentPosX, 0, noteCurrentPosX, m_seekerHeight);
-	brush.fillRect(noteStartPosX, 0, noteEndPosX, m_seekerHeight, m_playHighlighColor);
+	brush.fillRect(noteStartPosX, 0, noteEndPosX, m_seekerHeight, s_playHighlighColor);
 
 	// highlight on selected area
-	brush.fillRect(seekerStartPosX, 0, seekerMiddleWidth, m_seekerHeight, m_seekerHighlightColor);
+	brush.fillRect(seekerStartPosX, 0, seekerMiddleWidth, m_seekerHeight, s_seekerHighlightColor);
 
 	// shadow on not selected area
-	brush.fillRect(0, 0, seekerStartPosX, m_seekerHeight, m_seekerShadowColor);
-	brush.fillRect(seekerEndPosX + 1, 0, m_seekerWidth + 1, m_seekerHeight, m_seekerShadowColor);
+	brush.fillRect(0, 0, seekerStartPosX, m_seekerHeight, s_seekerShadowColor);
+	brush.fillRect(seekerEndPosX + 1, 0, m_seekerWidth + 1, m_seekerHeight, s_seekerShadowColor);
 
 	// draw border around selection
-	brush.setPen(QPen(m_seekerColor, 1));
+	brush.setPen(QPen(s_seekerColor, 1));
 	brush.drawRoundedRect(seekerStartPosX, 0, seekerMiddleWidth - 1, m_seekerHeight - 1, 4, 4); // -1 needed
 }
 
 void WaveForm::drawEditor()
 {
-	m_sliceEditor.fill(m_waveformBgColor);
+	m_sliceEditor.fill(s_waveformBgColor);
 	QPainter brush(&m_sliceEditor);
 
 	// draw text if no sample loaded
 	if (m_currentSample.frames() < 2048)
 	{
-		brush.setPen(m_playHighlighColor);
+		brush.setPen(s_playHighlighColor);
 		brush.setFont(QFont(brush.font().family(), 9.0f, -1, false));
 		brush.drawText(
 			m_editorWidth / 2 - 100, m_editorHeight / 2 - 100, 200, 200, Qt::AlignCenter, tr("Drag sample to load"));
@@ -143,23 +143,23 @@ void WaveForm::drawEditor()
 	float numFramesToDraw = endFrame - startFrame;
 
 	// 0 centered line
-	brush.setPen(m_playHighlighColor);
+	brush.setPen(s_playHighlighColor);
 	brush.drawLine(0, m_editorHeight / 2, m_editorWidth, m_editorHeight / 2);
 
 	// draw waveform
-	brush.setPen(m_waveformColor);
+	brush.setPen(s_waveformColor);
 	float zoomOffset = ((float)m_editorHeight - m_zoomLevel * m_editorHeight) / 2;
 	m_currentSample.visualize(
 		brush, QRect(0, zoomOffset, m_editorWidth, m_zoomLevel * m_editorHeight), startFrame, endFrame);
 
 	// draw slicepoints
-	brush.setPen(QPen(m_sliceColor, 2));
+	brush.setPen(QPen(s_sliceColor, 2));
 	for (int i = 0; i < m_slicePoints.size(); i++)
 	{
 		float xPos = (float)(m_slicePoints[i] - startFrame) / numFramesToDraw * m_editorWidth;
 
-		if (i == m_sliceSelected) { brush.setPen(QPen(m_selectedSliceColor, 2)); }
-		else { brush.setPen(QPen(m_sliceColor, 2)); }
+		if (i == m_sliceSelected) { brush.setPen(QPen(s_selectedSliceColor, 2)); }
+		else { brush.setPen(QPen(s_sliceColor, 2)); }
 
 		brush.drawLine(xPos, 0, xPos, m_editorHeight);
 		brush.drawPixmap(xPos - (float)m_sliceArrow.width() / 2, 0, m_sliceArrow);
diff --git a/plugins/SlicerT/WaveForm.h b/plugins/SlicerT/WaveForm.h
index 2183ceca021..5301fbed7ca 100644
--- a/plugins/SlicerT/WaveForm.h
+++ b/plugins/SlicerT/WaveForm.h
@@ -1,7 +1,7 @@
 /*
  * WaveForm.h - declaration of class WaveForm
  *
- * Copyright (c) 2006-2008 Daniel Kauss Serna <daniel.kauss.serna@gmail.com>
+ * Copyright (c) 2023 Daniel Kauss Serna <daniel.kauss.serna@gmail.com>
  *
  * This file is part of LMMS - https://lmms.io
  *
@@ -66,18 +66,18 @@ class WaveForm : public QWidget
 	int m_editorWidth;
 
 	// colors
-	QColor m_waveformBgColor = QColor(255, 255, 255, 0);
-	QColor m_waveformColor = QColor(123, 49, 212);
+	static constexpr QColor s_waveformBgColor = QColor(255, 255, 255, 0);
+	static constexpr QColor s_waveformColor = QColor(123, 49, 212);
 
-	QColor m_playColor = QColor(255, 255, 255, 200);
-	QColor m_playHighlighColor = QColor(255, 255, 255, 70);
+	static constexpr QColor s_playColor = QColor(255, 255, 255, 200);
+	static constexpr QColor s_playHighlighColor = QColor(255, 255, 255, 70);
 
-	QColor m_sliceColor = QColor(218, 193, 255);
-	QColor m_selectedSliceColor = QColor(178, 153, 215);
+	static constexpr QColor s_sliceColor = QColor(218, 193, 255);
+	static constexpr QColor s_selectedSliceColor = QColor(178, 153, 215);
 
-	QColor m_seekerColor = QColor(178, 115, 255);
-	QColor m_seekerHighlightColor = QColor(178, 115, 255, 100);
-	QColor m_seekerShadowColor = QColor(0, 0, 0, 120);
+	static constexpr QColor s_seekerColor = QColor(178, 115, 255);
+	static constexpr QColor s_seekerHighlightColor = QColor(178, 115, 255, 100);
+	static constexpr QColor s_seekerShadowColor = QColor(0, 0, 0, 120);
 
 	// interaction vars
 	float m_distanceForClick = 0.03f;

From ae50fd9ad4c1129967bbf6a0c69d10a3357a69d4 Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Fri, 13 Oct 2023 15:59:10 +0200
Subject: [PATCH 58/99] review: memcpy, no array, LMMS header, name change

---
 include/Clipboard.h                           |  2 +-
 plugins/SlicerT/CMakeLists.txt                |  2 +-
 plugins/SlicerT/SlicerT.cpp                   | 27 ++++---
 plugins/SlicerT/SlicerT.h                     | 26 +++---
 plugins/SlicerT/SlicerTView.cpp               |  4 +-
 plugins/SlicerT/SlicerTView.h                 | 16 ++--
 .../{WaveForm.cpp => SlicerTWaveform.cpp}     | 79 +++++++++----------
 .../SlicerT/{WaveForm.h => SlicerTWaveform.h} | 51 ++++++------
 8 files changed, 104 insertions(+), 103 deletions(-)
 rename plugins/SlicerT/{WaveForm.cpp => SlicerTWaveform.cpp} (81%)
 rename plugins/SlicerT/{WaveForm.h => SlicerTWaveform.h} (81%)

diff --git a/include/Clipboard.h b/include/Clipboard.h
index 491f8ebf748..cee40b33ae4 100644
--- a/include/Clipboard.h
+++ b/include/Clipboard.h
@@ -46,7 +46,7 @@ namespace lmms::Clipboard
 	bool hasFormat( MimeType mT );
 
 	// Helper methods for String data
-	void LMMS_EXPORT copyString( const QString & str, MimeType mT );
+	void LMMS_EXPORT copyString(const QString& str, MimeType mT);
 	QString getString( MimeType mT );
 
 	// Helper methods for String Pair data
diff --git a/plugins/SlicerT/CMakeLists.txt b/plugins/SlicerT/CMakeLists.txt
index 8bec64edaff..49a80ca03aa 100644
--- a/plugins/SlicerT/CMakeLists.txt
+++ b/plugins/SlicerT/CMakeLists.txt
@@ -7,4 +7,4 @@ INCLUDE_DIRECTORIES(${SAMPLERATE_INCLUDE_DIRS})
 LINK_DIRECTORIES(${SAMPLERATE_LIBRARY_DIRS})
 LINK_LIBRARIES(${SAMPLERATE_LIBRARIES})
 
-BUILD_PLUGIN(slicert SlicerT.cpp SlicerT.h SlicerTView.cpp SlicerTView.h WaveForm.cpp WaveForm.h MOCFILES SlicerT.h SlicerTView.h WaveForm.h EMBEDDED_RESOURCES "${CMAKE_CURRENT_SOURCE_DIR}/*.png")
\ No newline at end of file
+BUILD_PLUGIN(slicert SlicerT.cpp SlicerT.h SlicerTView.cpp SlicerTView.h SlicerTWaveform.cpp SlicerTWaveform.h MOCFILES SlicerT.h SlicerTView.h SlicerTWaveform.h EMBEDDED_RESOURCES "${CMAKE_CURRENT_SOURCE_DIR}/*.png")
\ No newline at end of file
diff --git a/plugins/SlicerT/SlicerT.cpp b/plugins/SlicerT/SlicerT.cpp
index a2abe65e08c..a9f5b76a9c4 100644
--- a/plugins/SlicerT/SlicerT.cpp
+++ b/plugins/SlicerT/SlicerT.cpp
@@ -53,15 +53,16 @@ Plugin::Descriptor PLUGIN_EXPORT slicert_plugin_descriptor = {
 } // end extern
 
 PhaseVocoder::PhaseVocoder()
-	: m_FFTInput(s_windowSize, 0)
+	: m_FFTSpectrum(s_windowSize)
+	, m_FFTInput(s_windowSize, 0)
 	, m_IFFTReconstruction(s_windowSize, 0)
 	, m_allMagnitudes(s_windowSize, 0)
 	, m_allFrequencies(s_windowSize, 0)
 	, m_processedFreq(s_windowSize, 0)
 	, m_processedMagn(s_windowSize, 0)
 {
-	m_fftPlan = fftwf_plan_dft_r2c_1d(s_windowSize, m_FFTInput.data(), m_FFTSpectrum, FFTW_MEASURE);
-	m_ifftPlan = fftwf_plan_dft_c2r_1d(s_windowSize, m_FFTSpectrum, m_IFFTReconstruction.data(), FFTW_MEASURE);
+	m_fftPlan = fftwf_plan_dft_r2c_1d(s_windowSize, m_FFTInput.data(), m_FFTSpectrum.data(), FFTW_MEASURE);
+	m_ifftPlan = fftwf_plan_dft_c2r_1d(s_windowSize, m_FFTSpectrum.data(), m_IFFTReconstruction.data(), FFTW_MEASURE);
 }
 
 PhaseVocoder::~PhaseVocoder()
@@ -112,7 +113,7 @@ void PhaseVocoder::getFrames(std::vector<float>& outData, int start, int frames)
 	m_dataLock.lock();
 
 	if (m_scaleRatio == 1) { // directly copy original data
-		memcpy(outData.data(), m_originalBuffer.data() + start, frames*sizeof(float));
+		std::copy_n(m_originalBuffer.data() + start, frames, outData.data());
 		m_dataLock.unlock();
 		return;
 	}
@@ -189,7 +190,7 @@ void PhaseVocoder::generateWindow(int windowNum, bool useCache)
 
 	if (!useCache)
 	{ // normal stuff
-		memcpy(m_FFTInput.data(), m_originalBuffer.data() + windowStart, s_windowSize * sizeof(float));
+		std::copy_n(m_originalBuffer.data() + windowStart, s_windowSize, m_FFTInput.data());
 
 		// FFT
 		fftwf_execute(m_fftPlan);
@@ -227,14 +228,14 @@ void PhaseVocoder::generateWindow(int windowNum, bool useCache)
 			m_allFrequencies[j] = freq;
 		}
 		// write cache
-		memcpy(m_freqCache.data() + windowIndex, m_allFrequencies.data(), s_windowSize * sizeof(float));
-		memcpy(m_magCache.data() + windowIndex, m_allMagnitudes.data(), s_windowSize * sizeof(float));
+		std::copy_n(m_allFrequencies.data(), s_windowSize, m_freqCache.data() + windowIndex);
+		std::copy_n(m_allMagnitudes.data(), s_windowSize, m_magCache.data() + windowIndex);
 	}
 	else
 	{
 		// read cache
-		memcpy(m_allFrequencies.data(), m_freqCache.data() + windowIndex, s_windowSize * sizeof(float));
-		memcpy(m_allMagnitudes.data(), m_magCache.data() + windowIndex, s_windowSize * sizeof(float));
+		std::copy_n(m_freqCache.data() + windowIndex, s_windowSize, m_allFrequencies.data());
+		std::copy_n(m_magCache.data() + windowIndex, s_windowSize, m_allMagnitudes.data());
 	}
 
 	// synthesis, all the operations are the reverse of the analysis
@@ -389,7 +390,7 @@ void SlicerT::playNote(NotePlayHandle* handle, sampleFrame* workingBuffer)
 
 		instrumentTrack()->processAudioBuffer(workingBuffer, frames + offset, handle);
 
-		// calculate absolute for the waveform
+		// calculate absolute for the SlicerTWaveform
 		float absoluteCurrentNote = (float)currentNoteFrame / totalFrames;
 		float absoluteStartNote = (float)sliceStart / totalFrames;
 		float abslouteEndNote = (float)sliceEnd / totalFrames;
@@ -431,9 +432,9 @@ void SlicerT::findSlices()
 	// buffers
 	std::vector<float> prevMags(windowSize / 2, 0);
 	std::vector<float> fftIn(windowSize, 0);
-	fftwf_complex fftOut[windowSize];
+	std::vector<fftwf_complex> fftOut(windowSize);
 
-	fftwf_plan fftPlan = fftwf_plan_dft_r2c_1d(windowSize, fftIn.data(), fftOut, FFTW_MEASURE);
+	fftwf_plan fftPlan = fftwf_plan_dft_r2c_1d(windowSize, fftIn.data(), fftOut.data(), FFTW_MEASURE);
 
 	int lastPoint = -minDist - 1; // to always store 0 first
 	float spectralFlux = 0;
@@ -443,7 +444,7 @@ void SlicerT::findSlices()
 	for (int i = 0; i < singleChannel.size() - windowSize; i += windowSize)
 	{
 		// fft
-		memcpy(fftIn.data(), singleChannel.data() + i, windowSize * sizeof(float));
+		std::copy_n(singleChannel.data() + i, windowSize, fftIn.data());
 		fftwf_execute(fftPlan);
 
 		// calculate spectral flux in regard to last window
diff --git a/plugins/SlicerT/SlicerT.h b/plugins/SlicerT/SlicerT.h
index 04babfc5371..5c641bdfa29 100644
--- a/plugins/SlicerT/SlicerT.h
+++ b/plugins/SlicerT/SlicerT.h
@@ -76,7 +76,7 @@ class PhaseVocoder
 	float m_expectedPhaseOut = 0;
 
 	// buffers
-	fftwf_complex m_FFTSpectrum[s_windowSize];
+	std::vector<fftwf_complex> m_FFTSpectrum;
 	std::vector<float> m_FFTInput;
 	std::vector<float> m_IFFTReconstruction;
 	std::vector<float> m_allMagnitudes;
@@ -153,6 +153,13 @@ class SlicerT : public Instrument
 {
 	Q_OBJECT
 
+public slots:
+	void updateFile(QString file);
+	void updateSlices();
+
+signals:
+	void isPlaying(float current, float start, float end);
+
 public:
 	SlicerT(InstrumentTrack* instrumentTrack);
 	~SlicerT() override = default;
@@ -162,18 +169,14 @@ class SlicerT : public Instrument
 	void saveSettings(QDomDocument& document, QDomElement& element) override;
 	void loadSettings(const QDomElement& element) override;
 
+	void findSlices();
+	void findBPM();
+
 	QString nodeName() const override;
 	gui::PluginView* instantiateView(QWidget* parent) override;
 
 	void writeToMidi(std::vector<Note>* outClip);
 
-public slots:
-	void updateFile(QString file);
-	void updateSlices();
-
-signals:
-	void isPlaying(float current, float start, float end);
-
 private:
 	// models
 	FloatModel m_noteThreshold;
@@ -190,11 +193,8 @@ public slots:
 
 	InstrumentTrack* m_parentTrack;
 
-	void findSlices();
-	void findBPM();
-
 	friend class gui::SlicerTView;
-	friend class gui::WaveForm;
+	friend class gui::SlicerTWaveform;
 };
 } // namespace lmms
-#endif // SLICERT_H
+#endif // LMMS_SLICERT_H
diff --git a/plugins/SlicerT/SlicerTView.cpp b/plugins/SlicerT/SlicerTView.cpp
index 8ba28f631da..dde522adc95 100644
--- a/plugins/SlicerT/SlicerTView.cpp
+++ b/plugins/SlicerT/SlicerTView.cpp
@@ -47,8 +47,8 @@ SlicerTView::SlicerTView(SlicerT* instrument, QWidget* parent)
 	, m_noteThresholdKnob(this)
 	, m_fadeOutKnob(this)
 	, m_bpmBox(3, "21pink", this)
-	, m_snapSetting(this, "Slice snap")
-	, m_syncToggle("Sync", this, "SyncToggle", LedCheckBox::LedColor::Green)
+	, m_snapSetting(this, tr("Slice snap"))
+	, m_syncToggle("Sync", this, tr("SyncToggle"), LedCheckBox::LedColor::Green)
 	, m_resetButton(this, nullptr)
 	, m_midiExportButton(this, nullptr)
 	, m_wf(248, 128, instrument, this)
diff --git a/plugins/SlicerT/SlicerTView.h b/plugins/SlicerT/SlicerTView.h
index c624dc68708..71dcad46976 100644
--- a/plugins/SlicerT/SlicerTView.h
+++ b/plugins/SlicerT/SlicerTView.h
@@ -22,8 +22,8 @@
  *
  */
 
-#ifndef SLICERT_UI_H
-#define SLICERT_UI_H
+#ifndef LMMS_SLICERT_VIEW_H
+#define LMMS_SLICERT_VIEW_H
 
 #include <QPushButton>
 
@@ -34,7 +34,7 @@
 #include "LcdSpinBox.h"
 #include "LedCheckBox.h"
 #include "PixmapButton.h"
-#include "WaveForm.h"
+#include "SlicerTWaveform.h"
 
 namespace lmms {
 
@@ -59,12 +59,12 @@ class SlicerTView : public InstrumentViewFixedSize
 {
 	Q_OBJECT
 
-public:
-	SlicerTView(SlicerT* instrument, QWidget* parent);
-
 protected slots:
 	void exportMidi();
 
+public:
+	SlicerTView(SlicerT* instrument, QWidget* parent);
+
 protected:
 	virtual void dragEnterEvent(QDragEnterEvent* _dee);
 	virtual void dropEvent(QDropEvent* _de);
@@ -85,8 +85,8 @@ protected slots:
 	PixmapButton m_resetButton;
 	PixmapButton m_midiExportButton;
 
-	WaveForm m_wf;
+	SlicerTWaveform m_wf;
 };
 } // namespace gui
 } // namespace lmms
-#endif // SLICERT_UI_H
+#endif // LMMS_SLICERT_VIEW_H
diff --git a/plugins/SlicerT/WaveForm.cpp b/plugins/SlicerT/SlicerTWaveform.cpp
similarity index 81%
rename from plugins/SlicerT/WaveForm.cpp
rename to plugins/SlicerT/SlicerTWaveform.cpp
index 7bcc70f337c..889ad001bb9 100644
--- a/plugins/SlicerT/WaveForm.cpp
+++ b/plugins/SlicerT/SlicerTWaveform.cpp
@@ -1,5 +1,5 @@
 /*
- * WaveForm.cpp - slice editor for SlicerT
+ * SlicerTWaveform.cpp - slice editor for SlicerT
  *
  * Copyright (c) 2023 Daniel Kauss Serna <daniel.kauss.serna@gmail.com>
  *
@@ -22,16 +22,15 @@
  *
  */
 
-#include "WaveForm.h"
-
 #include "SlicerT.h"
+#include "SlicerTWaveform.h"
 #include "embed.h"
 
 namespace lmms {
 
 namespace gui {
 
-WaveForm::WaveForm(int w, int h, SlicerT* instrument, QWidget* parent)
+SlicerTWaveform::SlicerTWaveform(int w, int h, SlicerT* instrument, QWidget* parent)
 	: QWidget(parent)
 	,
 	// calculate sizes
@@ -45,7 +44,7 @@ WaveForm::WaveForm(int w, int h, SlicerT* instrument, QWidget* parent)
 	// create pixmaps
 	m_sliceArrow(PLUGIN_NAME::getIconPixmap("slide_indicator_arrow"))
 	, m_seeker(QPixmap(m_seekerWidth, m_seekerHeight))
-	, m_seekerWaveform(QPixmap(m_seekerWidth, m_seekerHeight))
+	, m_seekerSlicerTWaveform(QPixmap(m_seekerWidth, m_seekerHeight))
 	, m_sliceEditor(QPixmap(w, m_editorHeight))
 	,
 
@@ -60,8 +59,8 @@ WaveForm::WaveForm(int w, int h, SlicerT* instrument, QWidget* parent)
 	setMouseTracking(true);
 
 	// draw backgrounds
-	m_sliceEditor.fill(s_waveformBgColor);
-	m_seekerWaveform.fill(s_waveformBgColor);
+	m_sliceEditor.fill(s_SlicerTWaveformBgColor);
+	m_seekerSlicerTWaveform.fill(s_SlicerTWaveformBgColor);
 
 	// connect to playback
 	connect(m_slicerTParent, SIGNAL(isPlaying(float, float, float)), this, SLOT(isPlaying(float, float, float)));
@@ -70,20 +69,20 @@ WaveForm::WaveForm(int w, int h, SlicerT* instrument, QWidget* parent)
 	updateUI();
 }
 
-void WaveForm::drawSeekerWaveform()
+void SlicerTWaveform::drawSeekerSlicerTWaveform()
 {
-	m_seekerWaveform.fill(s_waveformBgColor);
+	m_seekerSlicerTWaveform.fill(s_SlicerTWaveformBgColor);
 	if (m_currentSample.frames() < 2048) { return; }
-	QPainter brush(&m_seekerWaveform);
-	brush.setPen(s_waveformColor);
+	QPainter brush(&m_seekerSlicerTWaveform);
+	brush.setPen(s_SlicerTWaveformColor);
 
-	m_currentSample.visualize(
-		brush, QRect(0, 0, m_seekerWaveform.width(), m_seekerWaveform.height()), 0, m_currentSample.frames());
+	m_currentSample.visualize(brush, QRect(0, 0, m_seekerSlicerTWaveform.width(), m_seekerSlicerTWaveform.height()), 0,
+		m_currentSample.frames());
 }
 
-void WaveForm::drawSeeker()
+void SlicerTWaveform::drawSeeker()
 {
-	m_seeker.fill(s_waveformBgColor);
+	m_seeker.fill(s_SlicerTWaveformBgColor);
 	if (m_currentSample.frames() < 2048) { return; }
 	QPainter brush(&m_seeker);
 
@@ -122,9 +121,9 @@ void WaveForm::drawSeeker()
 	brush.drawRoundedRect(seekerStartPosX, 0, seekerMiddleWidth - 1, m_seekerHeight - 1, 4, 4); // -1 needed
 }
 
-void WaveForm::drawEditor()
+void SlicerTWaveform::drawEditor()
 {
-	m_sliceEditor.fill(s_waveformBgColor);
+	m_sliceEditor.fill(s_SlicerTWaveformBgColor);
 	QPainter brush(&m_sliceEditor);
 
 	// draw text if no sample loaded
@@ -146,8 +145,8 @@ void WaveForm::drawEditor()
 	brush.setPen(s_playHighlighColor);
 	brush.drawLine(0, m_editorHeight / 2, m_editorWidth, m_editorHeight / 2);
 
-	// draw waveform
-	brush.setPen(s_waveformColor);
+	// draw SlicerTWaveform
+	brush.setPen(s_SlicerTWaveformColor);
 	float zoomOffset = ((float)m_editorHeight - m_zoomLevel * m_editorHeight) / 2;
 	m_currentSample.visualize(
 		brush, QRect(0, zoomOffset, m_editorWidth, m_zoomLevel * m_editorHeight), startFrame, endFrame);
@@ -166,25 +165,25 @@ void WaveForm::drawEditor()
 	}
 }
 
-void WaveForm::updateUI()
+void SlicerTWaveform::updateUI()
 {
-	drawSeekerWaveform();
+	drawSeekerSlicerTWaveform();
 	drawSeeker();
 	drawEditor();
 	update();
 }
 
-void WaveForm::isPlaying(float current, float start, float end)
+void SlicerTWaveform::isPlaying(float current, float start, float end)
 {
 	m_noteCurrent = current;
 	m_noteStart = start;
 	m_noteEnd = end;
-	drawSeeker(); // only update seeker, else horrible performance because of waveform redraw
+	drawSeeker(); // only update seeker, else horrible performance because of SlicerTWaveform redraw
 	update();
 }
 
 // events
-void WaveForm::mousePressEvent(QMouseEvent* me)
+void SlicerTWaveform::mousePressEvent(QMouseEvent* me)
 {
 	float normalizedClickSeeker = (float)(me->x() - m_seekerHorMargin) / m_seekerWidth;
 	float normalizedClickEditor = (float)(me->x()) / m_editorWidth;
@@ -201,15 +200,15 @@ void WaveForm::mousePressEvent(QMouseEvent* me)
 	{
 		if (abs(normalizedClickSeeker - m_seekerStart) < m_distanceForClick) // dragging start
 		{
-			m_currentlyDragging = m_draggingTypes::m_seekerStart;
+			m_currentlyDragging = DraggingTypes::SeekerStart;
 		}
 		else if (abs(normalizedClickSeeker - m_seekerEnd) < m_distanceForClick) // dragging end
 		{
-			m_currentlyDragging = m_draggingTypes::m_seekerEnd;
+			m_currentlyDragging = DraggingTypes::SeekerEnd;
 		}
 		else if (normalizedClickSeeker > m_seekerStart && normalizedClickSeeker < m_seekerEnd) // dragging middle
 		{
-			m_currentlyDragging = m_draggingTypes::m_seekerMiddle;
+			m_currentlyDragging = DraggingTypes::SeekerMiddle;
 			m_seekerMiddle = normalizedClickSeeker;
 		}
 	}
@@ -226,7 +225,7 @@ void WaveForm::mousePressEvent(QMouseEvent* me)
 
 			if (abs(xPos - normalizedClickEditor) < m_distanceForClick)
 			{
-				m_currentlyDragging = m_draggingTypes::m_slicePoint;
+				m_currentlyDragging = DraggingTypes::SlicePoint;
 				m_sliceSelected = i;
 			}
 		}
@@ -243,15 +242,15 @@ void WaveForm::mousePressEvent(QMouseEvent* me)
 	updateUI();
 }
 
-void WaveForm::mouseReleaseEvent(QMouseEvent* me)
+void SlicerTWaveform::mouseReleaseEvent(QMouseEvent* me)
 {
-	m_currentlyDragging = m_draggingTypes::nothing;
+	m_currentlyDragging = DraggingTypes::Nothing;
 	std::sort(m_slicePoints.begin(), m_slicePoints.end());
 
 	updateUI();
 }
 
-void WaveForm::mouseMoveEvent(QMouseEvent* me)
+void SlicerTWaveform::mouseMoveEvent(QMouseEvent* me)
 {
 	float normalizedClickSeeker = (float)(me->x() - m_seekerHorMargin) / m_seekerWidth;
 	float normalizedClickEditor = (float)(me->x()) / m_editorWidth;
@@ -264,15 +263,15 @@ void WaveForm::mouseMoveEvent(QMouseEvent* me)
 	// handle dragging events
 	switch (m_currentlyDragging)
 	{
-	case m_draggingTypes::m_seekerStart:
+	case DraggingTypes::SeekerStart:
 		m_seekerStart = std::clamp(normalizedClickSeeker, 0.0f, m_seekerEnd - m_minSeekerDistance);
 		break;
 
-	case m_draggingTypes::m_seekerEnd:
+	case DraggingTypes::SeekerEnd:
 		m_seekerEnd = std::clamp(normalizedClickSeeker, m_seekerStart + m_minSeekerDistance, 1.0f);
 		break;
 
-	case m_draggingTypes::m_seekerMiddle:
+	case DraggingTypes::SeekerMiddle:
 		m_seekerMiddle = normalizedClickSeeker;
 
 		if (m_seekerMiddle + distStart >= 0 && m_seekerMiddle + distEnd <= 1)
@@ -282,17 +281,17 @@ void WaveForm::mouseMoveEvent(QMouseEvent* me)
 		}
 		break;
 
-	case m_draggingTypes::m_slicePoint:
+	case DraggingTypes::SlicePoint:
 		m_slicePoints[m_sliceSelected] = startFrame + normalizedClickEditor * (endFrame - startFrame);
 		m_slicePoints[m_sliceSelected] = std::clamp(m_slicePoints[m_sliceSelected], 0, m_currentSample.frames());
 		break;
-	case m_draggingTypes::nothing:
+	case DraggingTypes::Nothing:
 		break;
 	}
 	updateUI();
 }
 
-void WaveForm::mouseDoubleClickEvent(QMouseEvent* me)
+void SlicerTWaveform::mouseDoubleClickEvent(QMouseEvent* me)
 {
 	float normalizedClickEditor = (float)(me->x()) / m_editorWidth;
 	float startFrame = m_seekerStart * m_currentSample.frames();
@@ -312,7 +311,7 @@ void WaveForm::mouseDoubleClickEvent(QMouseEvent* me)
 	std::sort(m_slicePoints.begin(), m_slicePoints.end());
 }
 
-void WaveForm::wheelEvent(QWheelEvent* _we)
+void SlicerTWaveform::wheelEvent(QWheelEvent* _we)
 {
 	// m_zoomLevel = _we-> / 360.0f * 2.0f;
 	m_zoomLevel += _we->angleDelta().y() / 360.0f * m_zoomSensitivity;
@@ -322,10 +321,10 @@ void WaveForm::wheelEvent(QWheelEvent* _we)
 	update();
 }
 
-void WaveForm::paintEvent(QPaintEvent* pe)
+void SlicerTWaveform::paintEvent(QPaintEvent* pe)
 {
 	QPainter p(this);
-	p.drawPixmap(m_seekerHorMargin, 0, m_seekerWaveform);
+	p.drawPixmap(m_seekerHorMargin, 0, m_seekerSlicerTWaveform);
 	p.drawPixmap(m_seekerHorMargin, 0, m_seeker);
 	p.drawPixmap(0, m_seekerHeight + m_middleMargin, m_sliceEditor);
 }
diff --git a/plugins/SlicerT/WaveForm.h b/plugins/SlicerT/SlicerTWaveform.h
similarity index 81%
rename from plugins/SlicerT/WaveForm.h
rename to plugins/SlicerT/SlicerTWaveform.h
index 5301fbed7ca..266fd7162eb 100644
--- a/plugins/SlicerT/WaveForm.h
+++ b/plugins/SlicerT/SlicerTWaveform.h
@@ -1,5 +1,5 @@
 /*
- * WaveForm.h - declaration of class WaveForm
+ * SlicerTWaveform.h - declaration of class SlicerTWaveform
  *
  * Copyright (c) 2023 Daniel Kauss Serna <daniel.kauss.serna@gmail.com>
  *
@@ -22,8 +22,8 @@
  *
  */
 
-#ifndef WAVEFORM_H
-#define WAVEFORM_H
+#ifndef LMMS_SlicerT_Waveform_H
+#define LMMS_SlicerT_Waveform_H
 
 #include <QApplication>
 #include <QFontMetrics>
@@ -39,10 +39,26 @@ class SlicerT;
 
 namespace gui {
 
-class WaveForm : public QWidget
+class SlicerTWaveform : public QWidget
 {
 	Q_OBJECT
 
+public slots:
+	void updateUI();
+	void isPlaying(float current, float start, float end);
+
+public:
+	SlicerTWaveform(int w, int h, SlicerT* instrument, QWidget* parent);
+
+	enum class DraggingTypes
+	{
+		Nothing,
+		SeekerStart,
+		SeekerEnd,
+		SeekerMiddle,
+		SlicePoint,
+	};
+
 protected:
 	virtual void mousePressEvent(QMouseEvent* me);
 	virtual void mouseReleaseEvent(QMouseEvent* me);
@@ -66,8 +82,8 @@ class WaveForm : public QWidget
 	int m_editorWidth;
 
 	// colors
-	static constexpr QColor s_waveformBgColor = QColor(255, 255, 255, 0);
-	static constexpr QColor s_waveformColor = QColor(123, 49, 212);
+	static constexpr QColor s_SlicerTWaveformBgColor = QColor(255, 255, 255, 0);
+	static constexpr QColor s_SlicerTWaveformColor = QColor(123, 49, 212);
 
 	static constexpr QColor s_playColor = QColor(255, 255, 255, 200);
 	static constexpr QColor s_playHighlighColor = QColor(255, 255, 255, 70);
@@ -85,15 +101,7 @@ class WaveForm : public QWidget
 	float m_zoomSensitivity = 0.5f;
 
 	// dragging vars
-	enum class m_draggingTypes
-	{
-		nothing,
-		m_seekerStart,
-		m_seekerEnd,
-		m_seekerMiddle,
-		m_slicePoint,
-	};
-	m_draggingTypes m_currentlyDragging;
+	DraggingTypes m_currentlyDragging;
 
 	// seeker vars
 	float m_seekerStart = 0;
@@ -112,7 +120,7 @@ class WaveForm : public QWidget
 	// pixmaps
 	QPixmap m_sliceArrow;
 	QPixmap m_seeker;
-	QPixmap m_seekerWaveform; // only stores waveform graphic
+	QPixmap m_seekerSlicerTWaveform; // only stores SlicerTWaveform graphic
 	QPixmap m_sliceEditor;
 
 	SampleBuffer& m_currentSample;
@@ -121,16 +129,9 @@ class WaveForm : public QWidget
 	std::vector<int>& m_slicePoints;
 
 	void drawEditor();
-	void drawSeekerWaveform();
+	void drawSeekerSlicerTWaveform();
 	void drawSeeker();
-
-public slots:
-	void updateUI();
-	void isPlaying(float current, float start, float end);
-
-public:
-	WaveForm(int w, int h, SlicerT* instrument, QWidget* parent);
 };
 } // namespace gui
 } // namespace lmms
-#endif // WAVEFORM_H
\ No newline at end of file
+#endif // LMMS_SlicerT_Waveform_H
\ No newline at end of file

From 2d55539828a6b5f995d2989cbd3b02813d79464e Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Fri, 13 Oct 2023 16:04:47 +0200
Subject: [PATCH 59/99] static constexpr added

---
 plugins/SlicerT/SlicerT.h         |  4 ++--
 plugins/SlicerT/SlicerTWaveform.h | 16 +++++++++-------
 2 files changed, 11 insertions(+), 9 deletions(-)

diff --git a/plugins/SlicerT/SlicerT.h b/plugins/SlicerT/SlicerT.h
index 5c641bdfa29..22f65cb45c0 100644
--- a/plugins/SlicerT/SlicerT.h
+++ b/plugins/SlicerT/SlicerT.h
@@ -64,8 +64,8 @@ class PhaseVocoder
 	std::vector<bool> m_processedWindows; // marks a window processed
 
 	// timeshift stuff
-	static const int s_windowSize = 512;
-	static const int s_overSampling = 32;
+	static constexpr int s_windowSize = 512;
+	static constexpr int s_overSampling = 32;
 
 	// depending on scaleRatio
 	int m_stepSize = 0;
diff --git a/plugins/SlicerT/SlicerTWaveform.h b/plugins/SlicerT/SlicerTWaveform.h
index 266fd7162eb..fc10cd1314d 100644
--- a/plugins/SlicerT/SlicerTWaveform.h
+++ b/plugins/SlicerT/SlicerTWaveform.h
@@ -73,11 +73,13 @@ public slots:
 	int m_width;
 	int m_height;
 
-	int m_seekerHorMargin = 5;
-	int m_seekerHeight = 38; // used to calcualte all vertical sizes
-	int m_seekerWidth;
+	// predefined sizes
+	static constexpr int m_seekerHorMargin = 5;
+	static constexpr int m_seekerHeight = 38; // used to calcualte all vertical sizes
+	static constexpr int m_middleMargin = 6;
 
-	int m_middleMargin = 6;
+	// later calculated
+	int m_seekerWidth;
 	int m_editorHeight;
 	int m_editorWidth;
 
@@ -96,9 +98,9 @@ public slots:
 	static constexpr QColor s_seekerShadowColor = QColor(0, 0, 0, 120);
 
 	// interaction vars
-	float m_distanceForClick = 0.03f;
-	float m_minSeekerDistance = 0.13f;
-	float m_zoomSensitivity = 0.5f;
+	static constexpr float m_distanceForClick = 0.03f;
+	static constexpr float m_minSeekerDistance = 0.13f;
+	static constexpr float m_zoomSensitivity = 0.5f;
 
 	// dragging vars
 	DraggingTypes m_currentlyDragging;

From a44c42e722c9559c25649cbbbca11f7ccb504434 Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Fri, 13 Oct 2023 16:15:46 +0200
Subject: [PATCH 60/99] static vars to public + LMMS guards

---
 plugins/SlicerT/SlicerT.h         | 12 ++++----
 plugins/SlicerT/SlicerTWaveform.h | 48 +++++++++++++++----------------
 2 files changed, 30 insertions(+), 30 deletions(-)

diff --git a/plugins/SlicerT/SlicerT.h b/plugins/SlicerT/SlicerT.h
index 22f65cb45c0..d73f1ca9729 100644
--- a/plugins/SlicerT/SlicerT.h
+++ b/plugins/SlicerT/SlicerT.h
@@ -22,8 +22,8 @@
  *
  */
 
-#ifndef SLICERT_H
-#define SLICERT_H
+#ifndef LMMS_SLICERT_H
+#define LMMS_SLICERT_H
 
 #include <fftw3.h>
 
@@ -51,6 +51,10 @@ class PhaseVocoder
 	int frames() { return m_processedBuffer.size(); }
 	float scaleRatio() { return m_scaleRatio; }
 
+	// timeshift config
+	static constexpr int s_windowSize = 512;
+	static constexpr int s_overSampling = 32;
+
 private:
 	QMutex m_dataLock;
 	// original data
@@ -63,10 +67,6 @@ class PhaseVocoder
 	std::vector<float> m_processedBuffer; // final output
 	std::vector<bool> m_processedWindows; // marks a window processed
 
-	// timeshift stuff
-	static constexpr int s_windowSize = 512;
-	static constexpr int s_overSampling = 32;
-
 	// depending on scaleRatio
 	int m_stepSize = 0;
 	int m_numWindows = 0;
diff --git a/plugins/SlicerT/SlicerTWaveform.h b/plugins/SlicerT/SlicerTWaveform.h
index fc10cd1314d..34accb9bdec 100644
--- a/plugins/SlicerT/SlicerTWaveform.h
+++ b/plugins/SlicerT/SlicerTWaveform.h
@@ -50,6 +50,30 @@ public slots:
 public:
 	SlicerTWaveform(int w, int h, SlicerT* instrument, QWidget* parent);
 
+	// predefined sizes
+	static constexpr int m_seekerHorMargin = 5;
+	static constexpr int m_seekerHeight = 38; // used to calcualte all vertical sizes
+	static constexpr int m_middleMargin = 6;
+
+	// colors
+	static constexpr QColor s_SlicerTWaveformBgColor = QColor(255, 255, 255, 0);
+	static constexpr QColor s_SlicerTWaveformColor = QColor(123, 49, 212);
+
+	static constexpr QColor s_playColor = QColor(255, 255, 255, 200);
+	static constexpr QColor s_playHighlighColor = QColor(255, 255, 255, 70);
+
+	static constexpr QColor s_sliceColor = QColor(218, 193, 255);
+	static constexpr QColor s_selectedSliceColor = QColor(178, 153, 215);
+
+	static constexpr QColor s_seekerColor = QColor(178, 115, 255);
+	static constexpr QColor s_seekerHighlightColor = QColor(178, 115, 255, 100);
+	static constexpr QColor s_seekerShadowColor = QColor(0, 0, 0, 120);
+
+	// interaction vars
+	static constexpr float m_distanceForClick = 0.03f;
+	static constexpr float m_minSeekerDistance = 0.13f;
+	static constexpr float m_zoomSensitivity = 0.5f;
+
 	enum class DraggingTypes
 	{
 		Nothing,
@@ -73,35 +97,11 @@ public slots:
 	int m_width;
 	int m_height;
 
-	// predefined sizes
-	static constexpr int m_seekerHorMargin = 5;
-	static constexpr int m_seekerHeight = 38; // used to calcualte all vertical sizes
-	static constexpr int m_middleMargin = 6;
-
 	// later calculated
 	int m_seekerWidth;
 	int m_editorHeight;
 	int m_editorWidth;
 
-	// colors
-	static constexpr QColor s_SlicerTWaveformBgColor = QColor(255, 255, 255, 0);
-	static constexpr QColor s_SlicerTWaveformColor = QColor(123, 49, 212);
-
-	static constexpr QColor s_playColor = QColor(255, 255, 255, 200);
-	static constexpr QColor s_playHighlighColor = QColor(255, 255, 255, 70);
-
-	static constexpr QColor s_sliceColor = QColor(218, 193, 255);
-	static constexpr QColor s_selectedSliceColor = QColor(178, 153, 215);
-
-	static constexpr QColor s_seekerColor = QColor(178, 115, 255);
-	static constexpr QColor s_seekerHighlightColor = QColor(178, 115, 255, 100);
-	static constexpr QColor s_seekerShadowColor = QColor(0, 0, 0, 120);
-
-	// interaction vars
-	static constexpr float m_distanceForClick = 0.03f;
-	static constexpr float m_minSeekerDistance = 0.13f;
-	static constexpr float m_zoomSensitivity = 0.5f;
-
 	// dragging vars
 	DraggingTypes m_currentlyDragging;
 

From 7e7d42c4476723eed7c74e762d63c3830e618d1a Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Fri, 13 Oct 2023 16:43:30 +0200
Subject: [PATCH 61/99] remove references in classes

---
 plugins/SlicerT/SlicerTWaveform.cpp | 69 +++++++++++++++--------------
 plugins/SlicerT/SlicerTWaveform.h   |  5 +--
 2 files changed, 37 insertions(+), 37 deletions(-)

diff --git a/plugins/SlicerT/SlicerTWaveform.cpp b/plugins/SlicerT/SlicerTWaveform.cpp
index 889ad001bb9..9c8d191b5e5 100644
--- a/plugins/SlicerT/SlicerTWaveform.cpp
+++ b/plugins/SlicerT/SlicerTWaveform.cpp
@@ -22,8 +22,10 @@
  *
  */
 
-#include "SlicerT.h"
 #include "SlicerTWaveform.h"
+
+#include "SlicerT.h"
+#include "SlicerTView.h"
 #include "embed.h"
 
 namespace lmms {
@@ -46,13 +48,11 @@ SlicerTWaveform::SlicerTWaveform(int w, int h, SlicerT* instrument, QWidget* par
 	, m_seeker(QPixmap(m_seekerWidth, m_seekerHeight))
 	, m_seekerSlicerTWaveform(QPixmap(m_seekerWidth, m_seekerHeight))
 	, m_sliceEditor(QPixmap(w, m_editorHeight))
-	,
 
 	// references to instrument vars
-	m_currentSample(instrument->m_originalSample)
 	, m_slicerTParent(instrument)
-	, m_slicePoints(instrument->m_slicePoints)
-
+	, m_currentSample(&instrument->m_originalSample)
+	, m_slicePoints(&instrument->m_slicePoints)
 {
 	// window config
 	setFixedSize(m_width, m_height);
@@ -72,25 +72,25 @@ SlicerTWaveform::SlicerTWaveform(int w, int h, SlicerT* instrument, QWidget* par
 void SlicerTWaveform::drawSeekerSlicerTWaveform()
 {
 	m_seekerSlicerTWaveform.fill(s_SlicerTWaveformBgColor);
-	if (m_currentSample.frames() < 2048) { return; }
+	if (m_currentSample->frames() < 2048) { return; }
 	QPainter brush(&m_seekerSlicerTWaveform);
 	brush.setPen(s_SlicerTWaveformColor);
 
-	m_currentSample.visualize(brush, QRect(0, 0, m_seekerSlicerTWaveform.width(), m_seekerSlicerTWaveform.height()), 0,
-		m_currentSample.frames());
+	m_currentSample->visualize(brush, QRect(0, 0, m_seekerSlicerTWaveform.width(), m_seekerSlicerTWaveform.height()), 0,
+		m_currentSample->frames());
 }
 
 void SlicerTWaveform::drawSeeker()
 {
 	m_seeker.fill(s_SlicerTWaveformBgColor);
-	if (m_currentSample.frames() < 2048) { return; }
+	if (m_currentSample->frames() < 2048) { return; }
 	QPainter brush(&m_seeker);
 
 	// draw slice points
 	brush.setPen(s_sliceColor);
-	for (int i = 0; i < m_slicePoints.size(); i++)
+	for (int i = 0; i < m_slicePoints->size(); i++)
 	{
-		float xPos = (float)m_slicePoints[i] / m_currentSample.frames() * m_seekerWidth;
+		float xPos = (float)m_slicePoints->at(i) / m_currentSample->frames() * m_seekerWidth;
 		brush.drawLine(xPos, 0, xPos, m_seekerHeight);
 	}
 
@@ -127,7 +127,7 @@ void SlicerTWaveform::drawEditor()
 	QPainter brush(&m_sliceEditor);
 
 	// draw text if no sample loaded
-	if (m_currentSample.frames() < 2048)
+	if (m_currentSample->frames() < 2048)
 	{
 		brush.setPen(s_playHighlighColor);
 		brush.setFont(QFont(brush.font().family(), 9.0f, -1, false));
@@ -137,8 +137,8 @@ void SlicerTWaveform::drawEditor()
 	}
 
 	// editor boundaries
-	float startFrame = m_seekerStart * m_currentSample.frames();
-	float endFrame = m_seekerEnd * m_currentSample.frames();
+	float startFrame = m_seekerStart * m_currentSample->frames();
+	float endFrame = m_seekerEnd * m_currentSample->frames();
 	float numFramesToDraw = endFrame - startFrame;
 
 	// 0 centered line
@@ -148,14 +148,14 @@ void SlicerTWaveform::drawEditor()
 	// draw SlicerTWaveform
 	brush.setPen(s_SlicerTWaveformColor);
 	float zoomOffset = ((float)m_editorHeight - m_zoomLevel * m_editorHeight) / 2;
-	m_currentSample.visualize(
+	m_currentSample->visualize(
 		brush, QRect(0, zoomOffset, m_editorWidth, m_zoomLevel * m_editorHeight), startFrame, endFrame);
 
 	// draw slicepoints
 	brush.setPen(QPen(s_sliceColor, 2));
-	for (int i = 0; i < m_slicePoints.size(); i++)
+	for (int i = 0; i < m_slicePoints->size(); i++)
 	{
-		float xPos = (float)(m_slicePoints[i] - startFrame) / numFramesToDraw * m_editorWidth;
+		float xPos = (float)(m_slicePoints->at(i) - startFrame) / numFramesToDraw * m_editorWidth;
 
 		if (i == m_sliceSelected) { brush.setPen(QPen(s_selectedSliceColor, 2)); }
 		else { brush.setPen(QPen(s_sliceColor, 2)); }
@@ -215,12 +215,12 @@ void SlicerTWaveform::mousePressEvent(QMouseEvent* me)
 	else // editor click
 	{
 		m_sliceSelected = -1;
-		float startFrame = m_seekerStart * m_currentSample.frames();
-		float endFrame = m_seekerEnd * m_currentSample.frames();
+		float startFrame = m_seekerStart * m_currentSample->frames();
+		float endFrame = m_seekerEnd * m_currentSample->frames();
 		// select slice
-		for (int i = 0; i < m_slicePoints.size(); i++)
+		for (int i = 0; i < m_slicePoints->size(); i++)
 		{
-			int sliceIndex = m_slicePoints[i];
+			int sliceIndex = m_slicePoints->at(i);
 			float xPos = (float)(sliceIndex - startFrame) / (float)(endFrame - startFrame);
 
 			if (abs(xPos - normalizedClickEditor) < m_distanceForClick)
@@ -233,9 +233,9 @@ void SlicerTWaveform::mousePressEvent(QMouseEvent* me)
 
 	if (me->button() == Qt::MouseButton::RightButton) // erase selected slice
 	{
-		if (m_sliceSelected != -1 && m_slicePoints.size() > 2)
+		if (m_sliceSelected != -1 && m_slicePoints->size() > 2)
 		{
-			m_slicePoints.erase(m_slicePoints.begin() + m_sliceSelected);
+			m_slicePoints->erase(m_slicePoints->begin() + m_sliceSelected);
 			m_sliceSelected = -1;
 		}
 	}
@@ -245,7 +245,7 @@ void SlicerTWaveform::mousePressEvent(QMouseEvent* me)
 void SlicerTWaveform::mouseReleaseEvent(QMouseEvent* me)
 {
 	m_currentlyDragging = DraggingTypes::Nothing;
-	std::sort(m_slicePoints.begin(), m_slicePoints.end());
+	std::sort(m_slicePoints->begin(), m_slicePoints->end());
 
 	updateUI();
 }
@@ -257,8 +257,8 @@ void SlicerTWaveform::mouseMoveEvent(QMouseEvent* me)
 
 	float distStart = m_seekerStart - m_seekerMiddle;
 	float distEnd = m_seekerEnd - m_seekerMiddle;
-	float startFrame = m_seekerStart * m_currentSample.frames();
-	float endFrame = m_seekerEnd * m_currentSample.frames();
+	float startFrame = m_seekerStart * m_currentSample->frames();
+	float endFrame = m_seekerEnd * m_currentSample->frames();
 
 	// handle dragging events
 	switch (m_currentlyDragging)
@@ -282,8 +282,9 @@ void SlicerTWaveform::mouseMoveEvent(QMouseEvent* me)
 		break;
 
 	case DraggingTypes::SlicePoint:
-		m_slicePoints[m_sliceSelected] = startFrame + normalizedClickEditor * (endFrame - startFrame);
-		m_slicePoints[m_sliceSelected] = std::clamp(m_slicePoints[m_sliceSelected], 0, m_currentSample.frames());
+		m_slicePoints->at(m_sliceSelected) = startFrame + normalizedClickEditor * (endFrame - startFrame);
+		m_slicePoints->at(m_sliceSelected)
+			= std::clamp(m_slicePoints->at(m_sliceSelected), 0, m_currentSample->frames());
 		break;
 	case DraggingTypes::Nothing:
 		break;
@@ -294,21 +295,21 @@ void SlicerTWaveform::mouseMoveEvent(QMouseEvent* me)
 void SlicerTWaveform::mouseDoubleClickEvent(QMouseEvent* me)
 {
 	float normalizedClickEditor = (float)(me->x()) / m_editorWidth;
-	float startFrame = m_seekerStart * m_currentSample.frames();
-	float endFrame = m_seekerEnd * m_currentSample.frames();
+	float startFrame = m_seekerStart * m_currentSample->frames();
+	float endFrame = m_seekerEnd * m_currentSample->frames();
 
 	float slicePosition = startFrame + normalizedClickEditor * (endFrame - startFrame);
 
-	for (int i = 0; i < m_slicePoints.size(); i++)
+	for (int i = 0; i < m_slicePoints->size(); i++)
 	{
-		if (m_slicePoints[i] < slicePosition)
+		if (m_slicePoints->at(i) < slicePosition)
 		{
-			m_slicePoints.insert(m_slicePoints.begin() + i, slicePosition);
+			m_slicePoints->insert(m_slicePoints->begin() + i, slicePosition);
 			break;
 		}
 	}
 
-	std::sort(m_slicePoints.begin(), m_slicePoints.end());
+	std::sort(m_slicePoints->begin(), m_slicePoints->end());
 }
 
 void SlicerTWaveform::wheelEvent(QWheelEvent* _we)
diff --git a/plugins/SlicerT/SlicerTWaveform.h b/plugins/SlicerT/SlicerTWaveform.h
index 34accb9bdec..f86a4c515d1 100644
--- a/plugins/SlicerT/SlicerTWaveform.h
+++ b/plugins/SlicerT/SlicerTWaveform.h
@@ -125,10 +125,9 @@ public slots:
 	QPixmap m_seekerSlicerTWaveform; // only stores SlicerTWaveform graphic
 	QPixmap m_sliceEditor;
 
-	SampleBuffer& m_currentSample;
-
 	SlicerT* m_slicerTParent;
-	std::vector<int>& m_slicePoints;
+	SampleBuffer* m_currentSample;
+	std::vector<int>* m_slicePoints;
 
 	void drawEditor();
 	void drawSeekerSlicerTWaveform();

From be19d9b1b77acdcea2541f15753e2c575fc9dc44 Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Sat, 14 Oct 2023 00:45:41 +0200
Subject: [PATCH 62/99] remove constexpr and parent pointer in waveform

---
 plugins/SlicerT/SlicerT.cpp         |  2 +-
 plugins/SlicerT/SlicerT.h           |  4 ++--
 plugins/SlicerT/SlicerTWaveform.cpp |  5 ++---
 plugins/SlicerT/SlicerTWaveform.h   | 31 ++++++++++++++---------------
 4 files changed, 20 insertions(+), 22 deletions(-)

diff --git a/plugins/SlicerT/SlicerT.cpp b/plugins/SlicerT/SlicerT.cpp
index a9f5b76a9c4..0af69bbb3e6 100644
--- a/plugins/SlicerT/SlicerT.cpp
+++ b/plugins/SlicerT/SlicerT.cpp
@@ -664,7 +664,7 @@ extern "C" {
 // necessary for getting instance out of shared lib
 PLUGIN_EXPORT Plugin* lmms_plugin_main(Model* m, void*)
 {
-	return (new SlicerT(static_cast<InstrumentTrack*>(m)));
+	return new SlicerT(static_cast<InstrumentTrack*>(m));
 }
 } // extern
 } // namespace lmms
diff --git a/plugins/SlicerT/SlicerT.h b/plugins/SlicerT/SlicerT.h
index d73f1ca9729..a134e0db248 100644
--- a/plugins/SlicerT/SlicerT.h
+++ b/plugins/SlicerT/SlicerT.h
@@ -52,8 +52,8 @@ class PhaseVocoder
 	float scaleRatio() { return m_scaleRatio; }
 
 	// timeshift config
-	static constexpr int s_windowSize = 512;
-	static constexpr int s_overSampling = 32;
+	const int s_windowSize = 512;
+	const int s_overSampling = 32;
 
 private:
 	QMutex m_dataLock;
diff --git a/plugins/SlicerT/SlicerTWaveform.cpp b/plugins/SlicerT/SlicerTWaveform.cpp
index 9c8d191b5e5..79469602d91 100644
--- a/plugins/SlicerT/SlicerTWaveform.cpp
+++ b/plugins/SlicerT/SlicerTWaveform.cpp
@@ -50,7 +50,6 @@ SlicerTWaveform::SlicerTWaveform(int w, int h, SlicerT* instrument, QWidget* par
 	, m_sliceEditor(QPixmap(w, m_editorHeight))
 
 	// references to instrument vars
-	, m_slicerTParent(instrument)
 	, m_currentSample(&instrument->m_originalSample)
 	, m_slicePoints(&instrument->m_slicePoints)
 {
@@ -63,8 +62,8 @@ SlicerTWaveform::SlicerTWaveform(int w, int h, SlicerT* instrument, QWidget* par
 	m_seekerSlicerTWaveform.fill(s_SlicerTWaveformBgColor);
 
 	// connect to playback
-	connect(m_slicerTParent, SIGNAL(isPlaying(float, float, float)), this, SLOT(isPlaying(float, float, float)));
-	connect(m_slicerTParent, SIGNAL(dataChanged()), this, SLOT(updateUI()));
+	connect(instrument, SIGNAL(isPlaying(float, float, float)), this, SLOT(isPlaying(float, float, float)));
+	connect(instrument, SIGNAL(dataChanged()), this, SLOT(updateUI()));
 
 	updateUI();
 }
diff --git a/plugins/SlicerT/SlicerTWaveform.h b/plugins/SlicerT/SlicerTWaveform.h
index f86a4c515d1..fb20a758c8d 100644
--- a/plugins/SlicerT/SlicerTWaveform.h
+++ b/plugins/SlicerT/SlicerTWaveform.h
@@ -51,28 +51,28 @@ public slots:
 	SlicerTWaveform(int w, int h, SlicerT* instrument, QWidget* parent);
 
 	// predefined sizes
-	static constexpr int m_seekerHorMargin = 5;
-	static constexpr int m_seekerHeight = 38; // used to calcualte all vertical sizes
-	static constexpr int m_middleMargin = 6;
+	const int m_seekerHorMargin = 5;
+	const int m_seekerHeight = 38; // used to calcualte all vertical sizes
+	const int m_middleMargin = 6;
 
 	// colors
-	static constexpr QColor s_SlicerTWaveformBgColor = QColor(255, 255, 255, 0);
-	static constexpr QColor s_SlicerTWaveformColor = QColor(123, 49, 212);
+	const QColor s_SlicerTWaveformBgColor = QColor(255, 255, 255, 0);
+	const QColor s_SlicerTWaveformColor = QColor(123, 49, 212);
 
-	static constexpr QColor s_playColor = QColor(255, 255, 255, 200);
-	static constexpr QColor s_playHighlighColor = QColor(255, 255, 255, 70);
+	const QColor s_playColor = QColor(255, 255, 255, 200);
+	const QColor s_playHighlighColor = QColor(255, 255, 255, 70);
 
-	static constexpr QColor s_sliceColor = QColor(218, 193, 255);
-	static constexpr QColor s_selectedSliceColor = QColor(178, 153, 215);
+	const QColor s_sliceColor = QColor(218, 193, 255);
+	const QColor s_selectedSliceColor = QColor(178, 153, 215);
 
-	static constexpr QColor s_seekerColor = QColor(178, 115, 255);
-	static constexpr QColor s_seekerHighlightColor = QColor(178, 115, 255, 100);
-	static constexpr QColor s_seekerShadowColor = QColor(0, 0, 0, 120);
+	const QColor s_seekerColor = QColor(178, 115, 255);
+	const QColor s_seekerHighlightColor = QColor(178, 115, 255, 100);
+	const QColor s_seekerShadowColor = QColor(0, 0, 0, 120);
 
 	// interaction vars
-	static constexpr float m_distanceForClick = 0.03f;
-	static constexpr float m_minSeekerDistance = 0.13f;
-	static constexpr float m_zoomSensitivity = 0.5f;
+	const float m_distanceForClick = 0.03f;
+	const float m_minSeekerDistance = 0.13f;
+	const float m_zoomSensitivity = 0.5f;
 
 	enum class DraggingTypes
 	{
@@ -125,7 +125,6 @@ public slots:
 	QPixmap m_seekerSlicerTWaveform; // only stores SlicerTWaveform graphic
 	QPixmap m_sliceEditor;
 
-	SlicerT* m_slicerTParent;
 	SampleBuffer* m_currentSample;
 	std::vector<int>* m_slicePoints;
 

From 0511e747e14efe50ab8b595c923179ece7c954b5 Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Sat, 14 Oct 2023 01:27:09 +0200
Subject: [PATCH 63/99] std::array for fft

---
 plugins/SlicerT/SlicerT.cpp | 5 ++---
 plugins/SlicerT/SlicerT.h   | 6 +++---
 2 files changed, 5 insertions(+), 6 deletions(-)

diff --git a/plugins/SlicerT/SlicerT.cpp b/plugins/SlicerT/SlicerT.cpp
index 0af69bbb3e6..4d5b4b34b21 100644
--- a/plugins/SlicerT/SlicerT.cpp
+++ b/plugins/SlicerT/SlicerT.cpp
@@ -53,8 +53,7 @@ Plugin::Descriptor PLUGIN_EXPORT slicert_plugin_descriptor = {
 } // end extern
 
 PhaseVocoder::PhaseVocoder()
-	: m_FFTSpectrum(s_windowSize)
-	, m_FFTInput(s_windowSize, 0)
+	: m_FFTInput(s_windowSize, 0)
 	, m_IFFTReconstruction(s_windowSize, 0)
 	, m_allMagnitudes(s_windowSize, 0)
 	, m_allFrequencies(s_windowSize, 0)
@@ -432,7 +431,7 @@ void SlicerT::findSlices()
 	// buffers
 	std::vector<float> prevMags(windowSize / 2, 0);
 	std::vector<float> fftIn(windowSize, 0);
-	std::vector<fftwf_complex> fftOut(windowSize);
+	std::array<fftwf_complex, windowSize> fftOut;
 
 	fftwf_plan fftPlan = fftwf_plan_dft_r2c_1d(windowSize, fftIn.data(), fftOut.data(), FFTW_MEASURE);
 
diff --git a/plugins/SlicerT/SlicerT.h b/plugins/SlicerT/SlicerT.h
index a134e0db248..3eff4ead1a2 100644
--- a/plugins/SlicerT/SlicerT.h
+++ b/plugins/SlicerT/SlicerT.h
@@ -52,8 +52,8 @@ class PhaseVocoder
 	float scaleRatio() { return m_scaleRatio; }
 
 	// timeshift config
-	const int s_windowSize = 512;
-	const int s_overSampling = 32;
+	static const int s_windowSize = 512;
+	static const int s_overSampling = 32;
 
 private:
 	QMutex m_dataLock;
@@ -76,7 +76,7 @@ class PhaseVocoder
 	float m_expectedPhaseOut = 0;
 
 	// buffers
-	std::vector<fftwf_complex> m_FFTSpectrum;
+	std::array<fftwf_complex, s_windowSize> m_FFTSpectrum;
 	std::vector<float> m_FFTInput;
 	std::vector<float> m_IFFTReconstruction;
 	std::vector<float> m_allMagnitudes;

From 9a9ca506cb4aa424676c115a11b8a6447289ffdd Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Sat, 14 Oct 2023 01:29:59 +0200
Subject: [PATCH 64/99] fixed wrong name in style

---
 data/themes/classic/style.css | 2 +-
 data/themes/default/style.css | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/data/themes/classic/style.css b/data/themes/classic/style.css
index 6e39fbcc310..ad60c227dbb 100644
--- a/data/themes/classic/style.css
+++ b/data/themes/classic/style.css
@@ -902,7 +902,7 @@ lmms--gui--SidInstrumentView lmms--gui--Knob {
 	qproperty-lineWidth: 2;
 }
 
-lmms--gui--SlicerTUI lmms--gui--Knob {
+lmms--gui--SlicerTView lmms--gui--Knob {
 	color: rgb(162, 128, 226);
 	qproperty-outerColor: rgb( 162, 128, 226 );
 	qproperty-innerRadius: 1;
diff --git a/data/themes/default/style.css b/data/themes/default/style.css
index 2b875f47ebe..c4c968eb652 100644
--- a/data/themes/default/style.css
+++ b/data/themes/default/style.css
@@ -946,7 +946,7 @@ lmms--gui--SidInstrumentView lmms--gui--Knob {
 	qproperty-lineWidth: 2;
 }
 
-lmms--gui--SlicerTUI lmms--gui--Knob {
+lmms--gui--SlicerTView lmms--gui--Knob {
 	color: rgb(162, 128, 226);
 	qproperty-outerColor: rgb( 162, 128, 226 );
 	qproperty-innerRadius: 1;

From ef81ac5e5b476a6ca7efd7545b6881269f8fa5d1 Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Sat, 14 Oct 2023 13:44:24 +0200
Subject: [PATCH 65/99] remove c style casts

---
 plugins/SlicerT/SlicerT.cpp         | 53 +++++++++++++++--------------
 plugins/SlicerT/SlicerTWaveform.cpp | 20 +++++------
 2 files changed, 37 insertions(+), 36 deletions(-)

diff --git a/plugins/SlicerT/SlicerT.cpp b/plugins/SlicerT/SlicerT.cpp
index 4d5b4b34b21..e68600bda52 100644
--- a/plugins/SlicerT/SlicerT.cpp
+++ b/plugins/SlicerT/SlicerT.cpp
@@ -118,8 +118,8 @@ void PhaseVocoder::getFrames(std::vector<float>& outData, int start, int frames)
 	}
 
 	int windowMargin = s_overSampling / 2; // numbers of windows before full quality
-	int startWindow = (float)start / m_outStepSize - windowMargin;
-	int endWindow = (float)(start + frames) / m_outStepSize + windowMargin;
+	int startWindow = static_cast<float>(start) / m_outStepSize - windowMargin;
+	int endWindow = static_cast<float>((start + frames)) / m_outStepSize + windowMargin;
 
 	startWindow = std::clamp(startWindow, 0, m_numWindows - 1);
 	endWindow = std::clamp(endWindow, 0, m_numWindows - 1);
@@ -157,12 +157,12 @@ void PhaseVocoder::updateParams(float newRatio)
 	m_dataLock.lock();
 
 	m_scaleRatio = newRatio;
-	m_stepSize = (float)s_windowSize / s_overSampling;
-	m_numWindows = (float)m_originalBuffer.size() / m_stepSize - s_overSampling - 1;
-	m_outStepSize = m_scaleRatio * (float)m_stepSize; // float, else inaccurate
+	m_stepSize = static_cast<float>(s_windowSize) / s_overSampling;
+	m_numWindows = static_cast<float>(m_originalBuffer.size()) / m_stepSize - s_overSampling - 1;
+	m_outStepSize = m_scaleRatio * m_stepSize; // float, else inaccurate
 	m_freqPerBin = m_originalSampleRate / s_windowSize;
-	m_expectedPhaseIn = 2. * F_PI * (float)m_stepSize / (float)s_windowSize;
-	m_expectedPhaseOut = 2. * F_PI * (float)m_outStepSize / (float)s_windowSize;
+	m_expectedPhaseIn = 2. * F_PI * m_stepSize / s_windowSize;
+	m_expectedPhaseOut = 2. * F_PI * m_outStepSize / s_windowSize;
 
 	m_processedBuffer.resize(m_scaleRatio * m_originalBuffer.size(), 0);
 
@@ -184,8 +184,8 @@ void PhaseVocoder::generateWindow(int windowNum, bool useCache)
 {
 	// declare vars
 	float real, imag, phase, magnitude, freq, deltaPhase = 0;
-	int windowStart = (float)windowNum * m_stepSize;
-	int windowIndex = (float)windowNum * s_windowSize;
+	int windowStart = static_cast<float>(windowNum) * m_stepSize;
+	int windowIndex = static_cast<float>(windowNum) * s_windowSize;
 
 	if (!useCache)
 	{ // normal stuff
@@ -209,7 +209,7 @@ void PhaseVocoder::generateWindow(int windowNum, bool useCache)
 				- m_lastPhase[std::max(0, windowIndex + j - s_windowSize)]; // subtract prev pahse to get phase diference
 			m_lastPhase[windowIndex + j] = phase;
 
-			freq -= (float)j * m_expectedPhaseIn; // subtract expected phase
+			freq -= m_expectedPhaseIn * j; // subtract expected phase
 			// at this point, freq is the difference in phase
 			// between the last phase, having removed the expected phase at this point in the sample
 
@@ -218,10 +218,10 @@ void PhaseVocoder::generateWindow(int windowNum, bool useCache)
 			freq = fmod(freq + F_PI, -2.0f * F_PI) + F_PI;
 
 			// convert phase difference into bin freq mulitplier
-			freq = (float)s_overSampling * freq / (2. * F_PI);
+			freq = freq * s_overSampling / (2. * F_PI);
 
 			// add to the expected freq the change in freq calculated from the phase diff
-			freq = (float)j * m_freqPerBin + freq * m_freqPerBin;
+			freq = m_freqPerBin * j + m_freqPerBin * freq;
 
 			m_allMagnitudes[j] = magnitude;
 			m_allFrequencies[j] = freq;
@@ -244,7 +244,7 @@ void PhaseVocoder::generateWindow(int windowNum, bool useCache)
 		freq = m_allFrequencies[j];
 
 		// difference to bin freq mulitplier
-		deltaPhase = freq - (float)j * m_freqPerBin;
+		deltaPhase = freq - m_freqPerBin * j;
 
 		// convert to phase difference
 		deltaPhase /= m_freqPerBin;
@@ -253,7 +253,7 @@ void PhaseVocoder::generateWindow(int windowNum, bool useCache)
 		deltaPhase = 2. * F_PI * deltaPhase / s_overSampling;
 
 		// add the expected phase
-		deltaPhase += (float)j * m_expectedPhaseOut;
+		deltaPhase += m_expectedPhaseOut * j;
 
 		// sum this phase to the total, to keep track of the out phase along the sample
 		m_sumPhase[windowIndex + j] += deltaPhase;
@@ -325,7 +325,7 @@ void SlicerT::playNote(NotePlayHandle* handle, sampleFrame* workingBuffer)
 	const float inversePitchRatio = 1.0f / pitchRatio;
 
 	// update scaling parameters
-	float speedRatio = (float)m_originalBPM.value() / bpm;
+	float speedRatio = static_cast<float>(m_originalBPM.value()) / bpm;
 	if (!m_enableSync.value()) { speedRatio = 1; } // disable timeshift
 	m_phaseVocoder.setScaleRatio(speedRatio);
 	speedRatio *= inversePitchRatio; // adjust for pitch bend
@@ -351,7 +351,8 @@ void SlicerT::playNote(NotePlayHandle* handle, sampleFrame* workingBuffer)
 	if (noteFramesLeft > 0)
 	{
 		int framesToCopy = pitchRatio * frames + 1; // just in case
-		int framesIndex = std::min((int)(pitchRatio * currentNoteFrame), m_phaseVocoder.frames() - framesToCopy);
+		int framesIndex = pitchRatio * currentNoteFrame;
+		framesIndex = std::min(framesIndex, m_phaseVocoder.frames() - framesToCopy);
 
 		// load sample segmengt, with regards to pitch settings
 		std::vector<sampleFrame> prePitchBuffer(framesToCopy, {0.0f, 0.0f});
@@ -377,7 +378,7 @@ void SlicerT::playNote(NotePlayHandle* handle, sampleFrame* workingBuffer)
 		{
 			for (int i = 0; i < frames; i++)
 			{
-				float fadeValue = (float)(noteFramesLeft - i) / m_fadeOutFrames.value();
+				float fadeValue = static_cast<float>(noteFramesLeft - i) / m_fadeOutFrames.value();
 				// if the workingbuffer extends the sample
 				fadeValue = std::clamp(fadeValue, 0.0f, 1.0f);
 				fadeValue = pow(fadeValue, 2);
@@ -390,9 +391,9 @@ void SlicerT::playNote(NotePlayHandle* handle, sampleFrame* workingBuffer)
 		instrumentTrack()->processAudioBuffer(workingBuffer, frames + offset, handle);
 
 		// calculate absolute for the SlicerTWaveform
-		float absoluteCurrentNote = (float)currentNoteFrame / totalFrames;
-		float absoluteStartNote = (float)sliceStart / totalFrames;
-		float abslouteEndNote = (float)sliceEnd / totalFrames;
+		float absoluteCurrentNote = static_cast<float>(currentNoteFrame) / totalFrames;
+		float absoluteStartNote = static_cast<float>(sliceStart) / totalFrames;
+		float abslouteEndNote = static_cast<float>(sliceEnd) / totalFrames;
 		emit isPlaying(absoluteCurrentNote, absoluteStartNote, abslouteEndNote);
 	}
 	else { emit isPlaying(-1, 0, 0); }
@@ -531,7 +532,7 @@ void SlicerT::writeToMidi(std::vector<Note>* outClip)
 	if (m_originalSample.frames() < 2048) { return; }
 
 	// update incase bpm changed
-	float speedRatio = (float)m_originalBPM.value() / Engine::getSong()->getTempo();
+	float speedRatio = static_cast<float>(m_originalBPM.value()) / Engine::getSong()->getTempo();
 	m_phaseVocoder.setScaleRatio(speedRatio);
 
 	// calculate how many "beats" are in the sample
@@ -539,7 +540,7 @@ void SlicerT::writeToMidi(std::vector<Note>* outClip)
 	float sampleRate = m_originalSample.sampleRate();
 	float bpm = Engine::getSong()->getTempo();
 	float samplesPerBeat = 60.0f / bpm * sampleRate;
-	float beats = (float)m_phaseVocoder.frames() / samplesPerBeat;
+	float beats = m_phaseVocoder.frames() / samplesPerBeat;
 
 	// calculate how many ticks in sample
 	float barsInSample = beats / Engine::getSong()->getTimeSigModel().getDenominator();
@@ -551,7 +552,7 @@ void SlicerT::writeToMidi(std::vector<Note>* outClip)
 	for (int i = 0; i < m_slicePoints.size() - 1; i++)
 	{
 		float sliceStart = lastEnd;
-		float sliceEnd = (float)m_slicePoints[i + 1] / m_originalSample.frames() * totalTicks;
+		float sliceEnd = totalTicks * m_slicePoints[i + 1] / m_originalSample.frames();
 
 		Note sliceNote = Note();
 		sliceNote.setKey(i + m_parentTrack->baseNote());
@@ -571,7 +572,7 @@ void SlicerT::updateFile(QString file)
 	findBPM();
 	findSlices();
 
-	float speedRatio = (float)m_originalBPM.value() / Engine::getSong()->getTempo();
+	float speedRatio = static_cast<float>(m_originalBPM.value()) / Engine::getSong()->getTempo();
 	m_phaseVocoder.loadSample(
 		m_originalSample.data(), m_originalSample.frames(), m_originalSample.sampleRate(), speedRatio);
 
@@ -594,7 +595,7 @@ void SlicerT::saveSettings(QDomDocument& document, QDomElement& element)
 	}
 
 	// save slice points
-	element.setAttribute("totalSlices", (int)m_slicePoints.size());
+	element.setAttribute("totalSlices", static_cast<int>(m_slicePoints.size()));
 	for (int i = 0; i < m_slicePoints.size(); i++)
 	{
 		element.setAttribute(tr("slice_%1").arg(i), m_slicePoints[i]);
@@ -642,7 +643,7 @@ void SlicerT::loadSettings(const QDomElement& element)
 	m_originalBPM.loadSettings(element, "origBPM");
 
 	// create dynamic buffer
-	float speedRatio = (float)m_originalBPM.value() / Engine::getSong()->getTempo();
+	float speedRatio = static_cast<float>(m_originalBPM.value()) / Engine::getSong()->getTempo();
 	m_phaseVocoder.loadSample(
 		m_originalSample.data(), m_originalSample.frames(), m_originalSample.sampleRate(), speedRatio);
 
diff --git a/plugins/SlicerT/SlicerTWaveform.cpp b/plugins/SlicerT/SlicerTWaveform.cpp
index 79469602d91..f14cd3a01ad 100644
--- a/plugins/SlicerT/SlicerTWaveform.cpp
+++ b/plugins/SlicerT/SlicerTWaveform.cpp
@@ -89,7 +89,7 @@ void SlicerTWaveform::drawSeeker()
 	brush.setPen(s_sliceColor);
 	for (int i = 0; i < m_slicePoints->size(); i++)
 	{
-		float xPos = (float)m_slicePoints->at(i) / m_currentSample->frames() * m_seekerWidth;
+		float xPos = static_cast<float>(m_slicePoints->at(i)) / m_currentSample->frames() * m_seekerWidth;
 		brush.drawLine(xPos, 0, xPos, m_seekerHeight);
 	}
 
@@ -146,7 +146,7 @@ void SlicerTWaveform::drawEditor()
 
 	// draw SlicerTWaveform
 	brush.setPen(s_SlicerTWaveformColor);
-	float zoomOffset = ((float)m_editorHeight - m_zoomLevel * m_editorHeight) / 2;
+	float zoomOffset = (m_editorHeight - m_zoomLevel * m_editorHeight) / 2;
 	m_currentSample->visualize(
 		brush, QRect(0, zoomOffset, m_editorWidth, m_zoomLevel * m_editorHeight), startFrame, endFrame);
 
@@ -154,13 +154,13 @@ void SlicerTWaveform::drawEditor()
 	brush.setPen(QPen(s_sliceColor, 2));
 	for (int i = 0; i < m_slicePoints->size(); i++)
 	{
-		float xPos = (float)(m_slicePoints->at(i) - startFrame) / numFramesToDraw * m_editorWidth;
+		float xPos = (m_slicePoints->at(i) - startFrame) / numFramesToDraw * m_editorWidth;
 
 		if (i == m_sliceSelected) { brush.setPen(QPen(s_selectedSliceColor, 2)); }
 		else { brush.setPen(QPen(s_sliceColor, 2)); }
 
 		brush.drawLine(xPos, 0, xPos, m_editorHeight);
-		brush.drawPixmap(xPos - (float)m_sliceArrow.width() / 2, 0, m_sliceArrow);
+		brush.drawPixmap(xPos - m_sliceArrow.width() / 2.0f, 0, m_sliceArrow);
 	}
 }
 
@@ -184,8 +184,8 @@ void SlicerTWaveform::isPlaying(float current, float start, float end)
 // events
 void SlicerTWaveform::mousePressEvent(QMouseEvent* me)
 {
-	float normalizedClickSeeker = (float)(me->x() - m_seekerHorMargin) / m_seekerWidth;
-	float normalizedClickEditor = (float)(me->x()) / m_editorWidth;
+	float normalizedClickSeeker = static_cast<float>(me->x() - m_seekerHorMargin) / m_seekerWidth;
+	float normalizedClickEditor = static_cast<float>(me->x()) / m_editorWidth;
 	// reset seeker on middle click
 	if (me->button() == Qt::MouseButton::MiddleButton)
 	{
@@ -220,7 +220,7 @@ void SlicerTWaveform::mousePressEvent(QMouseEvent* me)
 		for (int i = 0; i < m_slicePoints->size(); i++)
 		{
 			int sliceIndex = m_slicePoints->at(i);
-			float xPos = (float)(sliceIndex - startFrame) / (float)(endFrame - startFrame);
+			float xPos = (sliceIndex - startFrame) / (endFrame - startFrame);
 
 			if (abs(xPos - normalizedClickEditor) < m_distanceForClick)
 			{
@@ -251,8 +251,8 @@ void SlicerTWaveform::mouseReleaseEvent(QMouseEvent* me)
 
 void SlicerTWaveform::mouseMoveEvent(QMouseEvent* me)
 {
-	float normalizedClickSeeker = (float)(me->x() - m_seekerHorMargin) / m_seekerWidth;
-	float normalizedClickEditor = (float)(me->x()) / m_editorWidth;
+	float normalizedClickSeeker = static_cast<float>(me->x() - m_seekerHorMargin) / m_seekerWidth;
+	float normalizedClickEditor = static_cast<float>(me->x()) / m_editorWidth;
 
 	float distStart = m_seekerStart - m_seekerMiddle;
 	float distEnd = m_seekerEnd - m_seekerMiddle;
@@ -293,7 +293,7 @@ void SlicerTWaveform::mouseMoveEvent(QMouseEvent* me)
 
 void SlicerTWaveform::mouseDoubleClickEvent(QMouseEvent* me)
 {
-	float normalizedClickEditor = (float)(me->x()) / m_editorWidth;
+	float normalizedClickEditor = static_cast<float>(me->x()) / m_editorWidth;
 	float startFrame = m_seekerStart * m_currentSample->frames();
 	float endFrame = m_seekerEnd * m_currentSample->frames();
 

From 44e712dbdd65cee388e13fe766f5dd29029a8a30 Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Sat, 14 Oct 2023 15:33:03 +0200
Subject: [PATCH 66/99] use src_process

---
 plugins/SlicerT/SlicerT.cpp | 16 +++++++++++++---
 plugins/SlicerT/SlicerT.h   |  4 +++-
 2 files changed, 16 insertions(+), 4 deletions(-)

diff --git a/plugins/SlicerT/SlicerT.cpp b/plugins/SlicerT/SlicerT.cpp
index e68600bda52..47fa0d1ff2b 100644
--- a/plugins/SlicerT/SlicerT.cpp
+++ b/plugins/SlicerT/SlicerT.cpp
@@ -111,7 +111,8 @@ void PhaseVocoder::getFrames(std::vector<float>& outData, int start, int frames)
 	if (m_originalBuffer.size() < 2048) { return; }
 	m_dataLock.lock();
 
-	if (m_scaleRatio == 1) { // directly copy original data
+	if (typeInfo<float>::isEqual(m_scaleRatio, 1.0f))
+	{ // directly copy original data
 		std::copy_n(m_originalBuffer.data() + start, frames, outData.data());
 		m_dataLock.unlock();
 		return;
@@ -309,6 +310,13 @@ SlicerT::SlicerT(InstrumentTrack* instrumentTrack)
 	m_sliceSnap.addItem("1/16");
 	m_sliceSnap.addItem("1/32");
 	m_sliceSnap.setValue(0); // no snap by default
+
+	m_resamplerState = src_new(SRC_SINC_MEDIUM_QUALITY, 2, nullptr); // no error
+}
+
+SlicerT::~SlicerT()
+{
+	src_delete(m_resamplerState);
 }
 
 void SlicerT::playNote(NotePlayHandle* handle, sampleFrame* workingBuffer)
@@ -359,7 +367,7 @@ void SlicerT::playNote(NotePlayHandle* handle, sampleFrame* workingBuffer)
 		m_phaseVocoder.getFrames(prePitchBuffer.data(), framesIndex, framesToCopy);
 
 		// if pitch is changed, resample, else just copy
-		if (pitchRatio != 1.0f)
+		if (!typeInfo<float>::isEqual(pitchRatio, 1.0f))
 		{
 			SRC_DATA resamplerData;
 
@@ -369,7 +377,7 @@ void SlicerT::playNote(NotePlayHandle* handle, sampleFrame* workingBuffer)
 			resamplerData.output_frames = frames;
 			resamplerData.src_ratio = inversePitchRatio;
 
-			src_simple(&resamplerData, SRC_LINEAR, 2);
+			src_process(m_resamplerState, &resamplerData);
 		}
 		else { memcpy(workingBuffer + offset, prePitchBuffer.data(), frames * sizeof(sampleFrame)); }
 
@@ -576,6 +584,8 @@ void SlicerT::updateFile(QString file)
 	m_phaseVocoder.loadSample(
 		m_originalSample.data(), m_originalSample.frames(), m_originalSample.sampleRate(), speedRatio);
 
+	src_reset(m_resamplerState);
+
 	emit dataChanged();
 }
 
diff --git a/plugins/SlicerT/SlicerT.h b/plugins/SlicerT/SlicerT.h
index 3eff4ead1a2..19ded228d0c 100644
--- a/plugins/SlicerT/SlicerT.h
+++ b/plugins/SlicerT/SlicerT.h
@@ -162,7 +162,7 @@ public slots:
 
 public:
 	SlicerT(InstrumentTrack* instrumentTrack);
-	~SlicerT() override = default;
+	~SlicerT();
 
 	void playNote(NotePlayHandle* handle, sampleFrame* workingBuffer) override;
 
@@ -189,6 +189,8 @@ public slots:
 	SampleBuffer m_originalSample;
 	DynamicPlaybackBuffer m_phaseVocoder;
 
+	SRC_STATE* m_resamplerState;
+
 	std::vector<int> m_slicePoints;
 
 	InstrumentTrack* m_parentTrack;

From d74ad4ae91f1003a7a9ab965d971ed1a1ba5001a Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Sun, 15 Oct 2023 02:46:47 +0200
Subject: [PATCH 67/99] use note vector for return

---
 plugins/SlicerT/SlicerT.cpp     | 8 +++++---
 plugins/SlicerT/SlicerT.h       | 2 +-
 plugins/SlicerT/SlicerTView.cpp | 3 +--
 3 files changed, 7 insertions(+), 6 deletions(-)

diff --git a/plugins/SlicerT/SlicerT.cpp b/plugins/SlicerT/SlicerT.cpp
index 47fa0d1ff2b..8d9902c1bbf 100644
--- a/plugins/SlicerT/SlicerT.cpp
+++ b/plugins/SlicerT/SlicerT.cpp
@@ -535,9 +535,9 @@ void SlicerT::findBPM()
 	m_originalBPM.setInitValue(bpmEstimate);
 }
 
-void SlicerT::writeToMidi(std::vector<Note>* outClip)
+std::vector<Note> SlicerT::getMidi()
 {
-	if (m_originalSample.frames() < 2048) { return; }
+	std::vector<Note> outputNotes;
 
 	// update incase bpm changed
 	float speedRatio = static_cast<float>(m_originalBPM.value()) / Engine::getSong()->getTempo();
@@ -566,10 +566,12 @@ void SlicerT::writeToMidi(std::vector<Note>* outClip)
 		sliceNote.setKey(i + m_parentTrack->baseNote());
 		sliceNote.setPos(sliceStart);
 		sliceNote.setLength(sliceEnd - sliceStart + 1); // + 1 needed for whatever reason
-		outClip->push_back(sliceNote);
+		outputNotes.push_back(sliceNote);
 
 		lastEnd = sliceEnd;
 	}
+
+	return outputNotes;
 }
 
 void SlicerT::updateFile(QString file)
diff --git a/plugins/SlicerT/SlicerT.h b/plugins/SlicerT/SlicerT.h
index 19ded228d0c..035573c75ee 100644
--- a/plugins/SlicerT/SlicerT.h
+++ b/plugins/SlicerT/SlicerT.h
@@ -175,7 +175,7 @@ public slots:
 	QString nodeName() const override;
 	gui::PluginView* instantiateView(QWidget* parent) override;
 
-	void writeToMidi(std::vector<Note>* outClip);
+	std::vector<Note> getMidi();
 
 private:
 	// models
diff --git a/plugins/SlicerT/SlicerTView.cpp b/plugins/SlicerT/SlicerTView.cpp
index dde522adc95..db5ecca6a33 100644
--- a/plugins/SlicerT/SlicerTView.cpp
+++ b/plugins/SlicerT/SlicerTView.cpp
@@ -117,8 +117,7 @@ void SlicerTView::exportMidi()
 	QDomElement note_list = dataFile.createElement("note-list");
 	dataFile.content().appendChild(note_list);
 
-	std::vector<Note> notes;
-	m_slicerTParent->writeToMidi(&notes);
+	std::vector<Note> notes = m_slicerTParent->getMidi();
 	if (notes.size() == 0) { return; }
 
 	TimePos start_pos(notes.front().pos().getBar(), 0);

From f745af6d300cd382f285e9f82352c350c92eb7b0 Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Sun, 15 Oct 2023 14:26:07 +0200
Subject: [PATCH 68/99] Moved PhaseVocoder into core

---
 include/PhaseVocoder.h    | 108 +++++++++++++++
 src/core/PhaseVocoder.cpp | 272 ++++++++++++++++++++++++++++++++++++++
 2 files changed, 380 insertions(+)
 create mode 100644 include/PhaseVocoder.h
 create mode 100644 src/core/PhaseVocoder.cpp

diff --git a/include/PhaseVocoder.h b/include/PhaseVocoder.h
new file mode 100644
index 00000000000..6971d0888c4
--- /dev/null
+++ b/include/PhaseVocoder.h
@@ -0,0 +1,108 @@
+/*
+ * PhaseVocoder.h - declaration of the PhaseVocoder class
+ *
+ * Copyright (c) 2023 Daniel Kauss Serna <daniel.kauss.serna@gmail.com>
+ *
+ * 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_PHASEVOCODER_H
+#define LMMS_PHASEVOCODER_H
+
+#include <QMutex>
+#include <array>
+#include <fftw3.h>
+#include <math.h>
+#include <vector>
+
+#include "lmms_export.h"
+
+namespace lmms {
+
+/**
+	Dynamically timeshifts one audio channel by a changable ratio
+	Allows access to the timeshifted data in a threadsafe and realtime maner 
+*/
+class LMMS_EXPORT PhaseVocoder
+{
+public:
+	PhaseVocoder();
+	~PhaseVocoder();
+
+	//! Loads a new sample, and precomputes the analysis cache
+	void loadData(std::vector<float> originalData, int sampleRate, float newRatio);
+	//! Change the output timeshift ratio
+	void setScaleRatio(float newRatio) { updateParams(newRatio); }
+
+	//! Copy a number of frames from a startpoint into an out buffer. 
+	//! This is NOT relative to the original sample
+	void getFrames(std::vector<float>& outData, int start, int frames);
+
+	//! Get total number of frames for the timeshifted sample, NOT the original
+	int frames() { return m_processedBuffer.size(); }
+	//! Get the current scaleRatio
+	float scaleRatio() { return m_scaleRatio; }
+
+	// timeshift config
+	static const int s_windowSize = 512;
+	static const int s_overSampling = 32;
+
+private:
+	QMutex m_dataLock;
+	// original data
+	std::vector<float> m_originalBuffer;
+	int m_originalSampleRate = 0;
+
+	float m_scaleRatio = -1; // to force on first load
+
+	// output data
+	std::vector<float> m_processedBuffer; // final output
+	std::vector<bool> m_processedWindows; // marks a window processed
+
+	// depending on scaleRatio
+	int m_stepSize = 0;
+	int m_numWindows = 0;
+	float m_outStepSize = 0;
+	float m_freqPerBin = 0;
+	float m_expectedPhaseIn = 0;
+	float m_expectedPhaseOut = 0;
+
+	// buffers
+	std::array<fftwf_complex, s_windowSize> m_FFTSpectrum;
+	std::vector<float> m_FFTInput;
+	std::vector<float> m_IFFTReconstruction;
+	std::vector<float> m_allMagnitudes;
+	std::vector<float> m_allFrequencies;
+	std::vector<float> m_processedFreq;
+	std::vector<float> m_processedMagn;
+	std::vector<float> m_lastPhase;
+	std::vector<float> m_sumPhase;
+
+	// cache
+	std::vector<float> m_freqCache;
+	std::vector<float> m_magCache;
+
+	// fftw plans
+	fftwf_plan m_fftPlan;
+	fftwf_plan m_ifftPlan;
+
+	void updateParams(float newRatio);
+	void generateWindow(int windowNum, bool useCache);
+};
+} // namespace lmms
+#endif // LMMS_PHASEVOCODER_H
diff --git a/src/core/PhaseVocoder.cpp b/src/core/PhaseVocoder.cpp
new file mode 100644
index 00000000000..33211f82298
--- /dev/null
+++ b/src/core/PhaseVocoder.cpp
@@ -0,0 +1,272 @@
+/*
+ * PhaseVocoder.cpp - Implementation of the PhaseVocoder class
+ *
+ * Copyright (c) 2023 Daniel Kauss Serna <daniel.kauss.serna@gmail.com>
+ *
+ * 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 "PhaseVocoder.h"
+
+#include <cstdio>
+#include <fftw3.h>
+#include <math.h>
+#include <typeinfo>
+
+#include "lmms_basics.h"
+#include "lmms_constants.h"
+
+namespace lmms {
+
+PhaseVocoder::PhaseVocoder()
+	: m_FFTInput(s_windowSize, 0)
+	, m_IFFTReconstruction(s_windowSize, 0)
+	, m_allMagnitudes(s_windowSize, 0)
+	, m_allFrequencies(s_windowSize, 0)
+	, m_processedFreq(s_windowSize, 0)
+	, m_processedMagn(s_windowSize, 0)
+{
+	m_fftPlan = fftwf_plan_dft_r2c_1d(s_windowSize, m_FFTInput.data(), m_FFTSpectrum.data(), FFTW_MEASURE);
+	m_ifftPlan = fftwf_plan_dft_c2r_1d(s_windowSize, m_FFTSpectrum.data(), m_IFFTReconstruction.data(), FFTW_MEASURE);
+}
+
+PhaseVocoder::~PhaseVocoder()
+{
+	fftwf_destroy_plan(m_fftPlan);
+	fftwf_destroy_plan(m_ifftPlan);
+}
+
+void PhaseVocoder::loadData(std::vector<float> originalData, int sampleRate, float newRatio)
+{
+	m_dataLock.lock();
+
+	m_originalBuffer = originalData;
+	m_originalSampleRate = sampleRate;
+	m_scaleRatio = -1; // force update, kinda hacky
+
+	m_dataLock.unlock(); // stupid, but QRecursiveMutex is too expensive to have in updateParas and getFrames
+	updateParams(newRatio);
+	m_dataLock.lock();
+
+	// set buffer sizes
+	m_processedWindows.resize(m_numWindows, false);
+	m_lastPhase.resize(m_numWindows * s_windowSize, 0);
+	m_sumPhase.resize((m_numWindows + 1) * s_windowSize, 0);
+	m_freqCache.resize(m_numWindows * s_windowSize, 0);
+	m_magCache.resize(m_numWindows * s_windowSize, 0);
+
+	// clear phase buffers
+	std::fill(m_lastPhase.begin(), m_lastPhase.end(), 0);
+	std::fill(m_sumPhase.begin(), m_sumPhase.end(), 0);
+
+	// maybe limit this to a set amount of windows to reduce initial lag spikes
+	for (int i = 0; i < m_numWindows; i++)
+	{
+		if (!m_processedWindows[i])
+		{
+			generateWindow(i, false); // first pass, no cache
+			m_processedWindows[i] = true;
+		}
+	}
+
+	m_dataLock.unlock();
+}
+
+void PhaseVocoder::getFrames(std::vector<float>& outData, int start, int frames)
+{
+	if (m_originalBuffer.size() < 2048) { return; }
+	m_dataLock.lock();
+
+	if (typeInfo<float>::isEqual(m_scaleRatio, 1.0f))
+	{ // directly copy original data
+		std::copy_n(m_originalBuffer.data() + start, frames, outData.data());
+		m_dataLock.unlock();
+		return;
+	}
+
+	int windowMargin = s_overSampling / 2; // numbers of windows before full quality
+	int startWindow = static_cast<float>(start) / m_outStepSize - windowMargin;
+	int endWindow = static_cast<float>((start + frames)) / m_outStepSize + windowMargin;
+
+	startWindow = std::clamp(startWindow, 0, m_numWindows - 1);
+	endWindow = std::clamp(endWindow, 0, m_numWindows - 1);
+
+	// discard previous phaseSum if not processed
+	if (!m_processedWindows[startWindow])
+	{
+		std::fill_n(m_sumPhase.data() + startWindow * s_windowSize, s_windowSize, 0);
+	}
+
+	// this encompases the minimum windows needed to get full quality,
+	// which must be computed
+	for (int i = startWindow; i < endWindow; i++)
+	{
+		if (!m_processedWindows[i])
+		{
+			generateWindow(i, true); // theses should use the cache
+			m_processedWindows[i] = true;
+		}
+	}
+
+	for (int i = 0; i < frames; i++)
+	{
+		outData[i] = m_processedBuffer[start + i];
+	}
+
+	m_dataLock.unlock();
+}
+
+// adjust pv params buffers to a new scale ratio
+void PhaseVocoder::updateParams(float newRatio)
+{
+	if (m_originalBuffer.size() < 2048) { return; }
+	if (newRatio == m_scaleRatio) { return; } // nothing changed
+	m_dataLock.lock();
+
+	m_scaleRatio = newRatio;
+	m_stepSize = static_cast<float>(s_windowSize) / s_overSampling;
+	m_numWindows = static_cast<float>(m_originalBuffer.size()) / m_stepSize - s_overSampling - 1;
+	m_outStepSize = m_scaleRatio * m_stepSize; // float, else inaccurate
+	m_freqPerBin = m_originalSampleRate / s_windowSize;
+	m_expectedPhaseIn = 2. * F_PI * m_stepSize / s_windowSize;
+	m_expectedPhaseOut = 2. * F_PI * m_outStepSize / s_windowSize;
+
+	m_processedBuffer.resize(m_scaleRatio * m_originalBuffer.size(), 0);
+
+	// very slow :(
+	std::fill(m_processedWindows.begin(), m_processedWindows.end(), false);
+	std::fill(m_processedBuffer.begin(), m_processedBuffer.end(), 0);
+
+	m_dataLock.unlock();
+}
+
+// time shifts one window from originalBuffer and writes to m_processedBuffer
+// resources:
+// http://blogs.zynaptiq.com/bernsee/pitch-shifting-using-the-ft/
+// https://sethares.engr.wisc.edu/vocoders/phasevocoder.html
+// https://dsp.stackexchange.com/questions/40101/audio-time-stretching-without-pitch-shifting/40367#40367
+// https://www.guitarpitchshifter.com/
+// https://en.wikipedia.org/wiki/Window_function
+void PhaseVocoder::generateWindow(int windowNum, bool useCache)
+{
+	// declare vars
+	float real, imag, phase, magnitude, freq, deltaPhase = 0;
+	int windowStart = static_cast<float>(windowNum) * m_stepSize;
+	int windowIndex = static_cast<float>(windowNum) * s_windowSize;
+
+	if (!useCache)
+	{ // normal stuff
+		std::copy_n(m_originalBuffer.data() + windowStart, s_windowSize, m_FFTInput.data());
+
+		// FFT
+		fftwf_execute(m_fftPlan);
+
+		// analysis step
+		for (int j = 0; j < s_windowSize / 2; j++) // only process nyquistic frequency
+		{
+			real = m_FFTSpectrum[j][0];
+			imag = m_FFTSpectrum[j][1];
+
+			magnitude = 2. * sqrt(real * real + imag * imag);
+			phase = atan2(imag, real);
+
+			// calculate difference in phase with prev window
+			freq = phase;
+			freq = phase - m_lastPhase[std::max(0, windowIndex + j - s_windowSize)]; // subtract prev pahse to get phase
+																					 // diference
+			m_lastPhase[windowIndex + j] = phase;
+
+			freq -= m_expectedPhaseIn * j; // subtract expected phase
+			// at this point, freq is the difference in phase
+			// between the last phase, having removed the expected phase at this point in the sample
+
+			// this puts freq in 0-2pi. Since the phase difference is proportional to the deviation in bin frequency,
+			// with this we can better estimate the true frequency
+			freq = fmod(freq + F_PI, -2.0f * F_PI) + F_PI;
+
+			// convert phase difference into bin freq mulitplier
+			freq = freq * s_overSampling / (2. * F_PI);
+
+			// add to the expected freq the change in freq calculated from the phase diff
+			freq = m_freqPerBin * j + m_freqPerBin * freq;
+
+			m_allMagnitudes[j] = magnitude;
+			m_allFrequencies[j] = freq;
+		}
+		// write cache
+		std::copy_n(m_allFrequencies.data(), s_windowSize, m_freqCache.data() + windowIndex);
+		std::copy_n(m_allMagnitudes.data(), s_windowSize, m_magCache.data() + windowIndex);
+	}
+	else
+	{
+		// read cache
+		std::copy_n(m_freqCache.data() + windowIndex, s_windowSize, m_allFrequencies.data());
+		std::copy_n(m_magCache.data() + windowIndex, s_windowSize, m_allMagnitudes.data());
+	}
+
+	// synthesis, all the operations are the reverse of the analysis
+	for (int j = 0; j < s_windowSize / 2; j++)
+	{
+		magnitude = m_allMagnitudes[j];
+		freq = m_allFrequencies[j];
+
+		// difference to bin freq mulitplier
+		deltaPhase = freq - m_freqPerBin * j;
+
+		// convert to phase difference
+		deltaPhase /= m_freqPerBin;
+
+		// difference in phase
+		deltaPhase = 2. * F_PI * deltaPhase / s_overSampling;
+
+		// add the expected phase
+		deltaPhase += m_expectedPhaseOut * j;
+
+		// sum this phase to the total, to keep track of the out phase along the sample
+		m_sumPhase[windowIndex + j] += deltaPhase;
+		deltaPhase = m_sumPhase[windowIndex + j]; // final bin phase
+
+		m_sumPhase[windowIndex + j + s_windowSize] = deltaPhase; // copy to the next
+
+		m_FFTSpectrum[j][0] = magnitude * cos(deltaPhase);
+		m_FFTSpectrum[j][1] = magnitude * sin(deltaPhase);
+	}
+
+	// inverse fft
+	fftwf_execute(m_ifftPlan);
+
+	// windowing
+	for (int j = 0; j < s_windowSize; j++)
+	{
+		float outIndex = windowNum * m_outStepSize + j;
+
+		// blackman-harris window
+		float a0 = 0.35875f;
+		float a1 = 0.48829f;
+		float a2 = 0.14128f;
+		float a3 = 0.01168f;
+
+		float piN2 = 2.0f * F_PI * j;
+		float window
+			= a0 - (a1 * cos(piN2 / s_windowSize)) + (a2 * cos(2.0f * piN2 / s_windowSize)) - (a3 * cos(3.0f * piN2));
+
+		// inverse fft magnitudes are windowsSize times bigger
+		m_processedBuffer[outIndex] += window * (m_IFFTReconstruction[j] / s_windowSize / s_overSampling);
+	}
+}
+} // namespace lmms

From efd9c61de59241a35df41896462ad4278b23e2b6 Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Sun, 15 Oct 2023 14:28:51 +0200
Subject: [PATCH 69/99] removed PV from plugin

---
 plugins/SlicerT/SlicerT.cpp | 236 ------------------------------------
 plugins/SlicerT/SlicerT.h   |  65 +---------
 src/core/CMakeLists.txt     |   1 +
 3 files changed, 3 insertions(+), 299 deletions(-)

diff --git a/plugins/SlicerT/SlicerT.cpp b/plugins/SlicerT/SlicerT.cpp
index 8d9902c1bbf..55fd5148e9c 100644
--- a/plugins/SlicerT/SlicerT.cpp
+++ b/plugins/SlicerT/SlicerT.cpp
@@ -52,242 +52,6 @@ Plugin::Descriptor PLUGIN_EXPORT slicert_plugin_descriptor = {
 };
 } // end extern
 
-PhaseVocoder::PhaseVocoder()
-	: m_FFTInput(s_windowSize, 0)
-	, m_IFFTReconstruction(s_windowSize, 0)
-	, m_allMagnitudes(s_windowSize, 0)
-	, m_allFrequencies(s_windowSize, 0)
-	, m_processedFreq(s_windowSize, 0)
-	, m_processedMagn(s_windowSize, 0)
-{
-	m_fftPlan = fftwf_plan_dft_r2c_1d(s_windowSize, m_FFTInput.data(), m_FFTSpectrum.data(), FFTW_MEASURE);
-	m_ifftPlan = fftwf_plan_dft_c2r_1d(s_windowSize, m_FFTSpectrum.data(), m_IFFTReconstruction.data(), FFTW_MEASURE);
-}
-
-PhaseVocoder::~PhaseVocoder()
-{
-	fftwf_destroy_plan(m_fftPlan);
-	fftwf_destroy_plan(m_ifftPlan);
-}
-
-void PhaseVocoder::loadData(std::vector<float> originalData, int sampleRate, float newRatio)
-{
-	m_dataLock.lock();
-
-	m_originalBuffer = originalData;
-	m_originalSampleRate = sampleRate;
-	m_scaleRatio = -1; // force update, kinda hacky
-
-	m_dataLock.unlock(); // stupid, but QRecursiveMutex is too expensive to have in updateParas and getFrames
-	updateParams(newRatio);
-	m_dataLock.lock();
-
-	// set buffer sizes
-	m_processedWindows.resize(m_numWindows, false);
-	m_lastPhase.resize(m_numWindows * s_windowSize, 0);
-	m_sumPhase.resize((m_numWindows + 1) * s_windowSize, 0);
-	m_freqCache.resize(m_numWindows * s_windowSize, 0);
-	m_magCache.resize(m_numWindows * s_windowSize, 0);
-
-	// clear phase buffers
-	std::fill(m_lastPhase.begin(), m_lastPhase.end(), 0);
-	std::fill(m_sumPhase.begin(), m_sumPhase.end(), 0);
-
-	// maybe limit this to a set amount of windows to reduce initial lag spikes
-	for (int i = 0; i < m_numWindows; i++)
-	{
-		if (!m_processedWindows[i])
-		{
-			generateWindow(i, false); // first pass, no cache
-			m_processedWindows[i] = true;
-		}
-	}
-
-	m_dataLock.unlock();
-}
-
-void PhaseVocoder::getFrames(std::vector<float>& outData, int start, int frames)
-{
-	if (m_originalBuffer.size() < 2048) { return; }
-	m_dataLock.lock();
-
-	if (typeInfo<float>::isEqual(m_scaleRatio, 1.0f))
-	{ // directly copy original data
-		std::copy_n(m_originalBuffer.data() + start, frames, outData.data());
-		m_dataLock.unlock();
-		return;
-	}
-
-	int windowMargin = s_overSampling / 2; // numbers of windows before full quality
-	int startWindow = static_cast<float>(start) / m_outStepSize - windowMargin;
-	int endWindow = static_cast<float>((start + frames)) / m_outStepSize + windowMargin;
-
-	startWindow = std::clamp(startWindow, 0, m_numWindows - 1);
-	endWindow = std::clamp(endWindow, 0, m_numWindows - 1);
-
-	// discard previous phaseSum if not processed
-	if (!m_processedWindows[startWindow])
-	{
-		std::fill_n(m_sumPhase.data() + startWindow * s_windowSize, s_windowSize, 0);
-	}
-
-	// this encompases the minimum windows needed to get full quality,
-	// which must be computed
-	for (int i = startWindow; i < endWindow; i++)
-	{
-		if (!m_processedWindows[i])
-		{
-			generateWindow(i, true); // theses should use the cache
-			m_processedWindows[i] = true;
-		}
-	}
-
-	for (int i = 0; i < frames; i++)
-	{
-		outData[i] = m_processedBuffer[start + i];
-	}
-
-	m_dataLock.unlock();
-}
-
-// adjust pv params buffers to a new scale ratio
-void PhaseVocoder::updateParams(float newRatio)
-{
-	if (m_originalBuffer.size() < 2048) { return; }
-	if (newRatio == m_scaleRatio) { return; } // nothing changed
-	m_dataLock.lock();
-
-	m_scaleRatio = newRatio;
-	m_stepSize = static_cast<float>(s_windowSize) / s_overSampling;
-	m_numWindows = static_cast<float>(m_originalBuffer.size()) / m_stepSize - s_overSampling - 1;
-	m_outStepSize = m_scaleRatio * m_stepSize; // float, else inaccurate
-	m_freqPerBin = m_originalSampleRate / s_windowSize;
-	m_expectedPhaseIn = 2. * F_PI * m_stepSize / s_windowSize;
-	m_expectedPhaseOut = 2. * F_PI * m_outStepSize / s_windowSize;
-
-	m_processedBuffer.resize(m_scaleRatio * m_originalBuffer.size(), 0);
-
-	// very slow :(
-	std::fill(m_processedWindows.begin(), m_processedWindows.end(), false);
-	std::fill(m_processedBuffer.begin(), m_processedBuffer.end(), 0);
-
-	m_dataLock.unlock();
-}
-
-// time shifts one window from originalBuffer and writes to m_processedBuffer
-// resources:
-// http://blogs.zynaptiq.com/bernsee/pitch-shifting-using-the-ft/
-// https://sethares.engr.wisc.edu/vocoders/phasevocoder.html
-// https://dsp.stackexchange.com/questions/40101/audio-time-stretching-without-pitch-shifting/40367#40367
-// https://www.guitarpitchshifter.com/
-// https://en.wikipedia.org/wiki/Window_function
-void PhaseVocoder::generateWindow(int windowNum, bool useCache)
-{
-	// declare vars
-	float real, imag, phase, magnitude, freq, deltaPhase = 0;
-	int windowStart = static_cast<float>(windowNum) * m_stepSize;
-	int windowIndex = static_cast<float>(windowNum) * s_windowSize;
-
-	if (!useCache)
-	{ // normal stuff
-		std::copy_n(m_originalBuffer.data() + windowStart, s_windowSize, m_FFTInput.data());
-
-		// FFT
-		fftwf_execute(m_fftPlan);
-
-		// analysis step
-		for (int j = 0; j < s_windowSize / 2; j++) // only process nyquistic frequency
-		{
-			real = m_FFTSpectrum[j][0];
-			imag = m_FFTSpectrum[j][1];
-
-			magnitude = 2. * sqrt(real * real + imag * imag);
-			phase = atan2(imag, real);
-
-			// calculate difference in phase with prev window
-			freq = phase;
-			freq = phase
-				- m_lastPhase[std::max(0, windowIndex + j - s_windowSize)]; // subtract prev pahse to get phase diference
-			m_lastPhase[windowIndex + j] = phase;
-
-			freq -= m_expectedPhaseIn * j; // subtract expected phase
-			// at this point, freq is the difference in phase
-			// between the last phase, having removed the expected phase at this point in the sample
-
-			// this puts freq in 0-2pi. Since the phase difference is proportional to the deviation in bin frequency,
-			// with this we can better estimate the true frequency
-			freq = fmod(freq + F_PI, -2.0f * F_PI) + F_PI;
-
-			// convert phase difference into bin freq mulitplier
-			freq = freq * s_overSampling / (2. * F_PI);
-
-			// add to the expected freq the change in freq calculated from the phase diff
-			freq = m_freqPerBin * j + m_freqPerBin * freq;
-
-			m_allMagnitudes[j] = magnitude;
-			m_allFrequencies[j] = freq;
-		}
-		// write cache
-		std::copy_n(m_allFrequencies.data(), s_windowSize, m_freqCache.data() + windowIndex);
-		std::copy_n(m_allMagnitudes.data(), s_windowSize, m_magCache.data() + windowIndex);
-	}
-	else
-	{
-		// read cache
-		std::copy_n(m_freqCache.data() + windowIndex, s_windowSize, m_allFrequencies.data());
-		std::copy_n(m_magCache.data() + windowIndex, s_windowSize, m_allMagnitudes.data());
-	}
-
-	// synthesis, all the operations are the reverse of the analysis
-	for (int j = 0; j < s_windowSize / 2; j++)
-	{
-		magnitude = m_allMagnitudes[j];
-		freq = m_allFrequencies[j];
-
-		// difference to bin freq mulitplier
-		deltaPhase = freq - m_freqPerBin * j;
-
-		// convert to phase difference
-		deltaPhase /= m_freqPerBin;
-
-		// difference in phase
-		deltaPhase = 2. * F_PI * deltaPhase / s_overSampling;
-
-		// add the expected phase
-		deltaPhase += m_expectedPhaseOut * j;
-
-		// sum this phase to the total, to keep track of the out phase along the sample
-		m_sumPhase[windowIndex + j] += deltaPhase;
-		deltaPhase = m_sumPhase[windowIndex + j]; // final bin phase
-
-		m_sumPhase[windowIndex + j + s_windowSize] = deltaPhase; // copy to the next
-
-
-		m_FFTSpectrum[j][0] = magnitude * cos(deltaPhase);
-		m_FFTSpectrum[j][1] = magnitude * sin(deltaPhase);
-	}
-
-	// inverse fft
-	fftwf_execute(m_ifftPlan);
-
-	// windowing
-	for (int j = 0; j < s_windowSize; j++)
-	{
-		float outIndex = windowNum * m_outStepSize + j;
-
-		// blackman-harris window
-		float a0 = 0.35875f;
-		float a1 = 0.48829f;
-		float a2 = 0.14128f;
-		float a3 = 0.01168f;
-
-		float piN2 = 2.0f * F_PI * j;
-		float window = a0 - (a1 * cos(piN2 / s_windowSize)) + (a2 * cos(2.0f * piN2 / s_windowSize)) - (a3 * cos(3.0f * piN2));
-
-		// inverse fft magnitudes are windowsSize times bigger
-		m_processedBuffer[outIndex] += window * (m_IFFTReconstruction[j] / s_windowSize / s_overSampling);
-	}
-}
 
 // ################################# SlicerT ####################################
 
diff --git a/plugins/SlicerT/SlicerT.h b/plugins/SlicerT/SlicerT.h
index 035573c75ee..0811db47f49 100644
--- a/plugins/SlicerT/SlicerT.h
+++ b/plugins/SlicerT/SlicerT.h
@@ -27,6 +27,7 @@
 
 #include <fftw3.h>
 
+#include "PhaseVocoder.h"
 #include "AutomatableModel.h"
 #include "Instrument.h"
 #include "InstrumentView.h"
@@ -36,68 +37,6 @@
 
 namespace lmms {
 
-// takes one audio-channel and timeshifts it
-class PhaseVocoder
-{
-public:
-	PhaseVocoder();
-	~PhaseVocoder();
-
-	void loadData(std::vector<float> originalData, int sampleRate, float newRatio);
-	void setScaleRatio(float newRatio) { updateParams(newRatio); }
-
-	void getFrames(std::vector<float>& outData, int start, int frames);
-
-	int frames() { return m_processedBuffer.size(); }
-	float scaleRatio() { return m_scaleRatio; }
-
-	// timeshift config
-	static const int s_windowSize = 512;
-	static const int s_overSampling = 32;
-
-private:
-	QMutex m_dataLock;
-	// original data
-	std::vector<float> m_originalBuffer;
-	int m_originalSampleRate = 0;
-
-	float m_scaleRatio = -1; // to force on first load
-
-	// output data
-	std::vector<float> m_processedBuffer; // final output
-	std::vector<bool> m_processedWindows; // marks a window processed
-
-	// depending on scaleRatio
-	int m_stepSize = 0;
-	int m_numWindows = 0;
-	float m_outStepSize = 0;
-	float m_freqPerBin = 0;
-	float m_expectedPhaseIn = 0;
-	float m_expectedPhaseOut = 0;
-
-	// buffers
-	std::array<fftwf_complex, s_windowSize> m_FFTSpectrum;
-	std::vector<float> m_FFTInput;
-	std::vector<float> m_IFFTReconstruction;
-	std::vector<float> m_allMagnitudes;
-	std::vector<float> m_allFrequencies;
-	std::vector<float> m_processedFreq;
-	std::vector<float> m_processedMagn;
-	std::vector<float> m_lastPhase;
-	std::vector<float> m_sumPhase;
-
-	// cache
-	std::vector<float> m_freqCache;
-	std::vector<float> m_magCache;
-
-	// fftw plans
-	fftwf_plan m_fftPlan;
-	fftwf_plan m_ifftPlan;
-
-	void updateParams(float newRatio);
-	void generateWindow(int windowNum, bool useCache);
-};
-
 // simple helper class that handles the different audio channels
 class DynamicPlaybackBuffer
 {
@@ -162,7 +101,7 @@ public slots:
 
 public:
 	SlicerT(InstrumentTrack* instrumentTrack);
-	~SlicerT();
+	~SlicerT() override;
 
 	void playNote(NotePlayHandle* handle, sampleFrame* workingBuffer) override;
 
diff --git a/src/core/CMakeLists.txt b/src/core/CMakeLists.txt
index 319882af2f9..b72ab0565c5 100644
--- a/src/core/CMakeLists.txt
+++ b/src/core/CMakeLists.txt
@@ -53,6 +53,7 @@ set(LMMS_SRCS
 	core/PatternStore.cpp
 	core/PeakController.cpp
 	core/PerfLog.cpp
+	core/PhaseVocoder.cpp
 	core/Piano.cpp
 	core/PlayHandle.cpp
 	core/Plugin.cpp

From 525d29bb6f018a2ed4f110bebbcbe1c43f7dab74 Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Sun, 15 Oct 2023 17:59:07 +0200
Subject: [PATCH 70/99] remove pointers in waveform

---
 plugins/SlicerT/SlicerTWaveform.cpp | 67 +++++++++++++++--------------
 plugins/SlicerT/SlicerTWaveform.h   |  6 +--
 2 files changed, 38 insertions(+), 35 deletions(-)

diff --git a/plugins/SlicerT/SlicerTWaveform.cpp b/plugins/SlicerT/SlicerTWaveform.cpp
index f14cd3a01ad..75d8402e57a 100644
--- a/plugins/SlicerT/SlicerTWaveform.cpp
+++ b/plugins/SlicerT/SlicerTWaveform.cpp
@@ -50,8 +50,7 @@ SlicerTWaveform::SlicerTWaveform(int w, int h, SlicerT* instrument, QWidget* par
 	, m_sliceEditor(QPixmap(w, m_editorHeight))
 
 	// references to instrument vars
-	, m_currentSample(&instrument->m_originalSample)
-	, m_slicePoints(&instrument->m_slicePoints)
+	, m_slicerTParent(instrument)
 {
 	// window config
 	setFixedSize(m_width, m_height);
@@ -71,25 +70,27 @@ SlicerTWaveform::SlicerTWaveform(int w, int h, SlicerT* instrument, QWidget* par
 void SlicerTWaveform::drawSeekerSlicerTWaveform()
 {
 	m_seekerSlicerTWaveform.fill(s_SlicerTWaveformBgColor);
-	if (m_currentSample->frames() < 2048) { return; }
+	if (m_slicerTParent->m_originalSample.frames() < 2048) { return; }
 	QPainter brush(&m_seekerSlicerTWaveform);
 	brush.setPen(s_SlicerTWaveformColor);
 
-	m_currentSample->visualize(brush, QRect(0, 0, m_seekerSlicerTWaveform.width(), m_seekerSlicerTWaveform.height()), 0,
-		m_currentSample->frames());
+	m_slicerTParent->m_originalSample.visualize(brush,
+		QRect(0, 0, m_seekerSlicerTWaveform.width(), m_seekerSlicerTWaveform.height()), 0,
+		m_slicerTParent->m_originalSample.frames());
 }
 
 void SlicerTWaveform::drawSeeker()
 {
 	m_seeker.fill(s_SlicerTWaveformBgColor);
-	if (m_currentSample->frames() < 2048) { return; }
+	if (m_slicerTParent->m_originalSample.frames() < 2048) { return; }
 	QPainter brush(&m_seeker);
 
 	// draw slice points
 	brush.setPen(s_sliceColor);
-	for (int i = 0; i < m_slicePoints->size(); i++)
+	for (int i = 0; i < m_slicerTParent->m_slicePoints.size(); i++)
 	{
-		float xPos = static_cast<float>(m_slicePoints->at(i)) / m_currentSample->frames() * m_seekerWidth;
+		float xPos = static_cast<float>(m_slicerTParent->m_slicePoints.at(i))
+			/ m_slicerTParent->m_originalSample.frames() * m_seekerWidth;
 		brush.drawLine(xPos, 0, xPos, m_seekerHeight);
 	}
 
@@ -126,7 +127,7 @@ void SlicerTWaveform::drawEditor()
 	QPainter brush(&m_sliceEditor);
 
 	// draw text if no sample loaded
-	if (m_currentSample->frames() < 2048)
+	if (m_slicerTParent->m_originalSample.frames() < 2048)
 	{
 		brush.setPen(s_playHighlighColor);
 		brush.setFont(QFont(brush.font().family(), 9.0f, -1, false));
@@ -136,8 +137,8 @@ void SlicerTWaveform::drawEditor()
 	}
 
 	// editor boundaries
-	float startFrame = m_seekerStart * m_currentSample->frames();
-	float endFrame = m_seekerEnd * m_currentSample->frames();
+	float startFrame = m_seekerStart * m_slicerTParent->m_originalSample.frames();
+	float endFrame = m_seekerEnd * m_slicerTParent->m_originalSample.frames();
 	float numFramesToDraw = endFrame - startFrame;
 
 	// 0 centered line
@@ -147,14 +148,14 @@ void SlicerTWaveform::drawEditor()
 	// draw SlicerTWaveform
 	brush.setPen(s_SlicerTWaveformColor);
 	float zoomOffset = (m_editorHeight - m_zoomLevel * m_editorHeight) / 2;
-	m_currentSample->visualize(
+	m_slicerTParent->m_originalSample.visualize(
 		brush, QRect(0, zoomOffset, m_editorWidth, m_zoomLevel * m_editorHeight), startFrame, endFrame);
 
 	// draw slicepoints
 	brush.setPen(QPen(s_sliceColor, 2));
-	for (int i = 0; i < m_slicePoints->size(); i++)
+	for (int i = 0; i < m_slicerTParent->m_slicePoints.size(); i++)
 	{
-		float xPos = (m_slicePoints->at(i) - startFrame) / numFramesToDraw * m_editorWidth;
+		float xPos = (m_slicerTParent->m_slicePoints.at(i) - startFrame) / numFramesToDraw * m_editorWidth;
 
 		if (i == m_sliceSelected) { brush.setPen(QPen(s_selectedSliceColor, 2)); }
 		else { brush.setPen(QPen(s_sliceColor, 2)); }
@@ -214,12 +215,12 @@ void SlicerTWaveform::mousePressEvent(QMouseEvent* me)
 	else // editor click
 	{
 		m_sliceSelected = -1;
-		float startFrame = m_seekerStart * m_currentSample->frames();
-		float endFrame = m_seekerEnd * m_currentSample->frames();
+		float startFrame = m_seekerStart * m_slicerTParent->m_originalSample.frames();
+		float endFrame = m_seekerEnd * m_slicerTParent->m_originalSample.frames();
 		// select slice
-		for (int i = 0; i < m_slicePoints->size(); i++)
+		for (int i = 0; i < m_slicerTParent->m_slicePoints.size(); i++)
 		{
-			int sliceIndex = m_slicePoints->at(i);
+			int sliceIndex = m_slicerTParent->m_slicePoints.at(i);
 			float xPos = (sliceIndex - startFrame) / (endFrame - startFrame);
 
 			if (abs(xPos - normalizedClickEditor) < m_distanceForClick)
@@ -232,9 +233,9 @@ void SlicerTWaveform::mousePressEvent(QMouseEvent* me)
 
 	if (me->button() == Qt::MouseButton::RightButton) // erase selected slice
 	{
-		if (m_sliceSelected != -1 && m_slicePoints->size() > 2)
+		if (m_sliceSelected != -1 && m_slicerTParent->m_slicePoints.size() > 2)
 		{
-			m_slicePoints->erase(m_slicePoints->begin() + m_sliceSelected);
+			m_slicerTParent->m_slicePoints.erase(m_slicerTParent->m_slicePoints.begin() + m_sliceSelected);
 			m_sliceSelected = -1;
 		}
 	}
@@ -244,7 +245,7 @@ void SlicerTWaveform::mousePressEvent(QMouseEvent* me)
 void SlicerTWaveform::mouseReleaseEvent(QMouseEvent* me)
 {
 	m_currentlyDragging = DraggingTypes::Nothing;
-	std::sort(m_slicePoints->begin(), m_slicePoints->end());
+	std::sort(m_slicerTParent->m_slicePoints.begin(), m_slicerTParent->m_slicePoints.end());
 
 	updateUI();
 }
@@ -256,8 +257,8 @@ void SlicerTWaveform::mouseMoveEvent(QMouseEvent* me)
 
 	float distStart = m_seekerStart - m_seekerMiddle;
 	float distEnd = m_seekerEnd - m_seekerMiddle;
-	float startFrame = m_seekerStart * m_currentSample->frames();
-	float endFrame = m_seekerEnd * m_currentSample->frames();
+	float startFrame = m_seekerStart * m_slicerTParent->m_originalSample.frames();
+	float endFrame = m_seekerEnd * m_slicerTParent->m_originalSample.frames();
 
 	// handle dragging events
 	switch (m_currentlyDragging)
@@ -281,9 +282,11 @@ void SlicerTWaveform::mouseMoveEvent(QMouseEvent* me)
 		break;
 
 	case DraggingTypes::SlicePoint:
-		m_slicePoints->at(m_sliceSelected) = startFrame + normalizedClickEditor * (endFrame - startFrame);
-		m_slicePoints->at(m_sliceSelected)
-			= std::clamp(m_slicePoints->at(m_sliceSelected), 0, m_currentSample->frames());
+		if (m_sliceSelected == -1) {break;}
+		m_slicerTParent->m_slicePoints.at(m_sliceSelected)
+			= startFrame + normalizedClickEditor * (endFrame - startFrame);
+		m_slicerTParent->m_slicePoints.at(m_sliceSelected) = std::clamp(
+			m_slicerTParent->m_slicePoints.at(m_sliceSelected), 0, m_slicerTParent->m_originalSample.frames());
 		break;
 	case DraggingTypes::Nothing:
 		break;
@@ -294,21 +297,21 @@ void SlicerTWaveform::mouseMoveEvent(QMouseEvent* me)
 void SlicerTWaveform::mouseDoubleClickEvent(QMouseEvent* me)
 {
 	float normalizedClickEditor = static_cast<float>(me->x()) / m_editorWidth;
-	float startFrame = m_seekerStart * m_currentSample->frames();
-	float endFrame = m_seekerEnd * m_currentSample->frames();
+	float startFrame = m_seekerStart * m_slicerTParent->m_originalSample.frames();
+	float endFrame = m_seekerEnd * m_slicerTParent->m_originalSample.frames();
 
 	float slicePosition = startFrame + normalizedClickEditor * (endFrame - startFrame);
 
-	for (int i = 0; i < m_slicePoints->size(); i++)
+	for (int i = 0; i < m_slicerTParent->m_slicePoints.size(); i++)
 	{
-		if (m_slicePoints->at(i) < slicePosition)
+		if (m_slicerTParent->m_slicePoints.at(i) < slicePosition)
 		{
-			m_slicePoints->insert(m_slicePoints->begin() + i, slicePosition);
+			m_slicerTParent->m_slicePoints.insert(m_slicerTParent->m_slicePoints.begin() + i, slicePosition);
 			break;
 		}
 	}
 
-	std::sort(m_slicePoints->begin(), m_slicePoints->end());
+	std::sort(m_slicerTParent->m_slicePoints.begin(), m_slicerTParent->m_slicePoints.end());
 }
 
 void SlicerTWaveform::wheelEvent(QWheelEvent* _we)
diff --git a/plugins/SlicerT/SlicerTWaveform.h b/plugins/SlicerT/SlicerTWaveform.h
index fb20a758c8d..0051051adc0 100644
--- a/plugins/SlicerT/SlicerTWaveform.h
+++ b/plugins/SlicerT/SlicerTWaveform.h
@@ -31,6 +31,7 @@
 #include <QMouseEvent>
 #include <QPainter>
 
+#include "Instrument.h"
 #include "SampleBuffer.h"
 
 namespace lmms {
@@ -125,8 +126,7 @@ public slots:
 	QPixmap m_seekerSlicerTWaveform; // only stores SlicerTWaveform graphic
 	QPixmap m_sliceEditor;
 
-	SampleBuffer* m_currentSample;
-	std::vector<int>* m_slicePoints;
+	SlicerT* m_slicerTParent;
 
 	void drawEditor();
 	void drawSeekerSlicerTWaveform();
@@ -134,4 +134,4 @@ public slots:
 };
 } // namespace gui
 } // namespace lmms
-#endif // LMMS_SlicerT_Waveform_H
\ No newline at end of file
+#endif // LMMS_SlicerT_Waveform_H

From 669cdd240e58df2124a21a6546379d5a5671c01f Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Sun, 15 Oct 2023 19:18:40 +0200
Subject: [PATCH 71/99] clang-format again

---
 include/PhaseVocoder.h              | 4 ++--
 plugins/SlicerT/SlicerT.cpp         | 3 +--
 plugins/SlicerT/SlicerT.h           | 5 +++--
 plugins/SlicerT/SlicerTWaveform.cpp | 2 +-
 4 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/include/PhaseVocoder.h b/include/PhaseVocoder.h
index 6971d0888c4..f419f69b400 100644
--- a/include/PhaseVocoder.h
+++ b/include/PhaseVocoder.h
@@ -36,7 +36,7 @@ namespace lmms {
 
 /**
 	Dynamically timeshifts one audio channel by a changable ratio
-	Allows access to the timeshifted data in a threadsafe and realtime maner 
+	Allows access to the timeshifted data in a threadsafe and realtime maner
 */
 class LMMS_EXPORT PhaseVocoder
 {
@@ -49,7 +49,7 @@ class LMMS_EXPORT PhaseVocoder
 	//! Change the output timeshift ratio
 	void setScaleRatio(float newRatio) { updateParams(newRatio); }
 
-	//! Copy a number of frames from a startpoint into an out buffer. 
+	//! Copy a number of frames from a startpoint into an out buffer.
 	//! This is NOT relative to the original sample
 	void getFrames(std::vector<float>& outData, int start, int frames);
 
diff --git a/plugins/SlicerT/SlicerT.cpp b/plugins/SlicerT/SlicerT.cpp
index 55fd5148e9c..d7d55fb3c52 100644
--- a/plugins/SlicerT/SlicerT.cpp
+++ b/plugins/SlicerT/SlicerT.cpp
@@ -52,7 +52,6 @@ Plugin::Descriptor PLUGIN_EXPORT slicert_plugin_descriptor = {
 };
 } // end extern
 
-
 // ################################# SlicerT ####################################
 
 SlicerT::SlicerT(InstrumentTrack* instrumentTrack)
@@ -264,7 +263,7 @@ void SlicerT::findSlices()
 
 	// fit to sample size
 	m_slicePoints[0] = 0;
-	m_slicePoints[m_slicePoints.size()-1] = m_originalSample.frames();
+	m_slicePoints[m_slicePoints.size() - 1] = m_originalSample.frames();
 
 	// update UI
 	emit dataChanged();
diff --git a/plugins/SlicerT/SlicerT.h b/plugins/SlicerT/SlicerT.h
index 0811db47f49..934b61fb290 100644
--- a/plugins/SlicerT/SlicerT.h
+++ b/plugins/SlicerT/SlicerT.h
@@ -27,11 +27,11 @@
 
 #include <fftw3.h>
 
-#include "PhaseVocoder.h"
 #include "AutomatableModel.h"
 #include "Instrument.h"
 #include "InstrumentView.h"
 #include "Note.h"
+#include "PhaseVocoder.h"
 #include "SampleBuffer.h"
 #include "SlicerTView.h"
 
@@ -44,7 +44,8 @@ class DynamicPlaybackBuffer
 	DynamicPlaybackBuffer()
 		: m_leftChannel()
 		, m_rightChannel()
-	{}
+	{
+	}
 
 	void loadSample(const sampleFrame* outData, int frames, int sampleRate, float newRatio)
 	{
diff --git a/plugins/SlicerT/SlicerTWaveform.cpp b/plugins/SlicerT/SlicerTWaveform.cpp
index 75d8402e57a..1024a588a6a 100644
--- a/plugins/SlicerT/SlicerTWaveform.cpp
+++ b/plugins/SlicerT/SlicerTWaveform.cpp
@@ -282,7 +282,7 @@ void SlicerTWaveform::mouseMoveEvent(QMouseEvent* me)
 		break;
 
 	case DraggingTypes::SlicePoint:
-		if (m_sliceSelected == -1) {break;}
+		if (m_sliceSelected == -1) { break; }
 		m_slicerTParent->m_slicePoints.at(m_sliceSelected)
 			= startFrame + normalizedClickEditor * (endFrame - startFrame);
 		m_slicerTParent->m_slicePoints.at(m_sliceSelected) = std::clamp(

From 95eee6dc29514fb7b62d2ec72c718cd28477e288 Mon Sep 17 00:00:00 2001
From: DanielKauss <47889291+DanielKauss@users.noreply.github.com>
Date: Sun, 15 Oct 2023 21:17:43 +0200
Subject: [PATCH 72/99] Use std:: + review suggestions

Co-authored-by: Dalton Messmer <33463986+messmerd@users.noreply.github.com>
Co-authored-by: saker <sakertooth@gmail.com>
---
 include/PhaseVocoder.h              |  2 +-
 plugins/SlicerT/SlicerT.cpp         | 12 ++++++------
 plugins/SlicerT/SlicerTWaveform.cpp | 12 +++++-------
 plugins/SlicerT/SlicerTWaveform.h   | 24 ++++++++++++------------
 src/core/PhaseVocoder.cpp           | 12 ++++++------
 5 files changed, 30 insertions(+), 32 deletions(-)

diff --git a/include/PhaseVocoder.h b/include/PhaseVocoder.h
index f419f69b400..8d51d2c1e45 100644
--- a/include/PhaseVocoder.h
+++ b/include/PhaseVocoder.h
@@ -27,7 +27,7 @@
 #include <QMutex>
 #include <array>
 #include <fftw3.h>
-#include <math.h>
+#include <cmath>
 #include <vector>
 
 #include "lmms_export.h"
diff --git a/plugins/SlicerT/SlicerT.cpp b/plugins/SlicerT/SlicerT.cpp
index d7d55fb3c52..7896b0f703f 100644
--- a/plugins/SlicerT/SlicerT.cpp
+++ b/plugins/SlicerT/SlicerT.cpp
@@ -152,7 +152,7 @@ void SlicerT::playNote(NotePlayHandle* handle, sampleFrame* workingBuffer)
 				float fadeValue = static_cast<float>(noteFramesLeft - i) / m_fadeOutFrames.value();
 				// if the workingbuffer extends the sample
 				fadeValue = std::clamp(fadeValue, 0.0f, 1.0f);
-				fadeValue = pow(fadeValue, 2);
+				fadeValue = std::pow(fadeValue, 2);
 
 				workingBuffer[i + offset][0] *= fadeValue;
 				workingBuffer[i + offset][1] *= fadeValue;
@@ -223,10 +223,10 @@ void SlicerT::findSlices()
 		{
 			real = fftOut[j][0];
 			imag = fftOut[j][1];
-			magnitude = sqrt(real * real + imag * imag);
+			magnitude = std::sqrt(real * real + imag * imag);
 
 			// using L2-norm (euclidean distance)
-			diff = sqrt(pow(magnitude - prevMags[j], 2));
+			diff = std::sqrt(std::pow(magnitude - prevMags[j], 2));
 			spectralFlux += diff;
 
 			prevMags[j] = magnitude;
@@ -249,7 +249,7 @@ void SlicerT::findSlices()
 	int noteSnap = m_sliceSnap.value();
 	int timeSignature = Engine::getSong()->getTimeSigModel().getNumerator();
 	int samplesPerBar = 60.0f * timeSignature / m_originalBPM.value() * m_originalSample.sampleRate();
-	int sliceLock = samplesPerBar / pow(2, noteSnap + 1); // lock to note: 1 / noteSnap²
+	int sliceLock = samplesPerBar / std::pow(2, noteSnap + 1); // lock to note: 1 / noteSnap²
 	if (noteSnap == 0) { sliceLock = 1; }				  // disable noteSnap
 
 	for (int i = 0; i < m_slicePoints.size(); i++)
@@ -427,12 +427,12 @@ void SlicerT::loadSettings(const QDomElement& element)
 
 QString SlicerT::nodeName() const
 {
-	return (slicert_plugin_descriptor.name);
+	return slicert_plugin_descriptor.name;
 }
 
 gui::PluginView* SlicerT::instantiateView(QWidget* parent)
 {
-	return (new gui::SlicerTView(this, parent));
+	return new gui::SlicerTView(this, parent);
 }
 
 extern "C" {
diff --git a/plugins/SlicerT/SlicerTWaveform.cpp b/plugins/SlicerT/SlicerTWaveform.cpp
index 1024a588a6a..4d2382332ae 100644
--- a/plugins/SlicerT/SlicerTWaveform.cpp
+++ b/plugins/SlicerT/SlicerTWaveform.cpp
@@ -34,17 +34,15 @@ namespace gui {
 
 SlicerTWaveform::SlicerTWaveform(int w, int h, SlicerT* instrument, QWidget* parent)
 	: QWidget(parent)
-	,
 	// calculate sizes
-	m_width(w)
+	, m_width(w)
 	, m_height(h)
 	, m_seekerWidth(w - m_seekerHorMargin * 2)
 	, m_editorHeight(h - m_seekerHeight - m_middleMargin)
 	, m_editorWidth(w)
-	,
 
 	// create pixmaps
-	m_sliceArrow(PLUGIN_NAME::getIconPixmap("slide_indicator_arrow"))
+	, m_sliceArrow(PLUGIN_NAME::getIconPixmap("slide_indicator_arrow"))
 	, m_seeker(QPixmap(m_seekerWidth, m_seekerHeight))
 	, m_seekerSlicerTWaveform(QPixmap(m_seekerWidth, m_seekerHeight))
 	, m_sliceEditor(QPixmap(w, m_editorHeight))
@@ -198,11 +196,11 @@ void SlicerTWaveform::mousePressEvent(QMouseEvent* me)
 
 	if (me->y() < m_seekerHeight) // seeker click
 	{
-		if (abs(normalizedClickSeeker - m_seekerStart) < m_distanceForClick) // dragging start
+		if (std::abs(normalizedClickSeeker - m_seekerStart) < m_distanceForClick) // dragging start
 		{
 			m_currentlyDragging = DraggingTypes::SeekerStart;
 		}
-		else if (abs(normalizedClickSeeker - m_seekerEnd) < m_distanceForClick) // dragging end
+		else if (std::abs(normalizedClickSeeker - m_seekerEnd) < m_distanceForClick) // dragging end
 		{
 			m_currentlyDragging = DraggingTypes::SeekerEnd;
 		}
@@ -223,7 +221,7 @@ void SlicerTWaveform::mousePressEvent(QMouseEvent* me)
 			int sliceIndex = m_slicerTParent->m_slicePoints.at(i);
 			float xPos = (sliceIndex - startFrame) / (endFrame - startFrame);
 
-			if (abs(xPos - normalizedClickEditor) < m_distanceForClick)
+			if (std::abs(xPos - normalizedClickEditor) < m_distanceForClick)
 			{
 				m_currentlyDragging = DraggingTypes::SlicePoint;
 				m_sliceSelected = i;
diff --git a/plugins/SlicerT/SlicerTWaveform.h b/plugins/SlicerT/SlicerTWaveform.h
index 0051051adc0..4d3272a1f9a 100644
--- a/plugins/SlicerT/SlicerTWaveform.h
+++ b/plugins/SlicerT/SlicerTWaveform.h
@@ -22,8 +22,8 @@
  *
  */
 
-#ifndef LMMS_SlicerT_Waveform_H
-#define LMMS_SlicerT_Waveform_H
+#ifndef LMMS_SLICERT_WAVEFORM_H
+#define LMMS_SLICERT_WAVEFORM_H
 
 #include <QApplication>
 #include <QFontMetrics>
@@ -71,9 +71,9 @@ public slots:
 	const QColor s_seekerShadowColor = QColor(0, 0, 0, 120);
 
 	// interaction vars
-	const float m_distanceForClick = 0.03f;
-	const float m_minSeekerDistance = 0.13f;
-	const float m_zoomSensitivity = 0.5f;
+	static constexpr float s_distanceForClick = 0.03f;
+	static constexpr float s_minSeekerDistance = 0.13f;
+	static constexpr float s_zoomSensitivity = 0.5f;
 
 	enum class DraggingTypes
 	{
@@ -85,13 +85,13 @@ public slots:
 	};
 
 protected:
-	virtual void mousePressEvent(QMouseEvent* me);
-	virtual void mouseReleaseEvent(QMouseEvent* me);
-	virtual void mouseMoveEvent(QMouseEvent* me);
-	virtual void mouseDoubleClickEvent(QMouseEvent* me);
-	virtual void wheelEvent(QWheelEvent* _we);
+	void mousePressEvent(QMouseEvent* me) override;
+	void mouseReleaseEvent(QMouseEvent* me) override;
+	void mouseMoveEvent(QMouseEvent* me) override;
+	void mouseDoubleClickEvent(QMouseEvent* me) override;
+	void wheelEvent(QWheelEvent* we) override;
 
-	virtual void paintEvent(QPaintEvent* pe);
+	void paintEvent(QPaintEvent* pe) override;
 
 private:
 	// sizes
@@ -134,4 +134,4 @@ public slots:
 };
 } // namespace gui
 } // namespace lmms
-#endif // LMMS_SlicerT_Waveform_H
+#endif // LMMS_SLICERT_WAVEFORM_T
diff --git a/src/core/PhaseVocoder.cpp b/src/core/PhaseVocoder.cpp
index 33211f82298..964ec4610e1 100644
--- a/src/core/PhaseVocoder.cpp
+++ b/src/core/PhaseVocoder.cpp
@@ -182,8 +182,8 @@ void PhaseVocoder::generateWindow(int windowNum, bool useCache)
 			real = m_FFTSpectrum[j][0];
 			imag = m_FFTSpectrum[j][1];
 
-			magnitude = 2. * sqrt(real * real + imag * imag);
-			phase = atan2(imag, real);
+			magnitude = 2. * std::sqrt(real * real + imag * imag);
+			phase = std::atan2(imag, real);
 
 			// calculate difference in phase with prev window
 			freq = phase;
@@ -197,7 +197,7 @@ void PhaseVocoder::generateWindow(int windowNum, bool useCache)
 
 			// this puts freq in 0-2pi. Since the phase difference is proportional to the deviation in bin frequency,
 			// with this we can better estimate the true frequency
-			freq = fmod(freq + F_PI, -2.0f * F_PI) + F_PI;
+			freq = std::fmod(freq + F_PI, -2.0f * F_PI) + F_PI;
 
 			// convert phase difference into bin freq mulitplier
 			freq = freq * s_overSampling / (2. * F_PI);
@@ -243,8 +243,8 @@ void PhaseVocoder::generateWindow(int windowNum, bool useCache)
 
 		m_sumPhase[windowIndex + j + s_windowSize] = deltaPhase; // copy to the next
 
-		m_FFTSpectrum[j][0] = magnitude * cos(deltaPhase);
-		m_FFTSpectrum[j][1] = magnitude * sin(deltaPhase);
+		m_FFTSpectrum[j][0] = magnitude * std::cos(deltaPhase);
+		m_FFTSpectrum[j][1] = magnitude * std::sin(deltaPhase);
 	}
 
 	// inverse fft
@@ -263,7 +263,7 @@ void PhaseVocoder::generateWindow(int windowNum, bool useCache)
 
 		float piN2 = 2.0f * F_PI * j;
 		float window
-			= a0 - (a1 * cos(piN2 / s_windowSize)) + (a2 * cos(2.0f * piN2 / s_windowSize)) - (a3 * cos(3.0f * piN2));
+			= a0 - (a1 * std::cos(piN2 / s_windowSize)) + (a2 * std::cos(2.0f * piN2 / s_windowSize)) - (a3 * std::cos(3.0f * piN2));
 
 		// inverse fft magnitudes are windowsSize times bigger
 		m_processedBuffer[outIndex] += window * (m_IFFTReconstruction[j] / s_windowSize / s_overSampling);

From eb5cfdb9e848e08f3b6d5795de7faa88a9229a85 Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Sun, 15 Oct 2023 21:26:56 +0200
Subject: [PATCH 73/99] More review changes

---
 plugins/SlicerT/SlicerT.cpp         |  2 +-
 plugins/SlicerT/SlicerT.h           |  6 +++---
 plugins/SlicerT/SlicerTWaveform.cpp | 12 ++++++------
 src/core/PhaseVocoder.cpp           |  2 +-
 4 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/plugins/SlicerT/SlicerT.cpp b/plugins/SlicerT/SlicerT.cpp
index 7896b0f703f..1a3cb132715 100644
--- a/plugins/SlicerT/SlicerT.cpp
+++ b/plugins/SlicerT/SlicerT.cpp
@@ -142,7 +142,7 @@ void SlicerT::playNote(NotePlayHandle* handle, sampleFrame* workingBuffer)
 
 			src_process(m_resamplerState, &resamplerData);
 		}
-		else { memcpy(workingBuffer + offset, prePitchBuffer.data(), frames * sizeof(sampleFrame)); }
+		else { std::copy_n(prePitchBuffer.data(), frames, workingBuffer + offset); }
 
 		// exponential fade out, applyRelease kinda sucks
 		if (noteFramesLeft < m_fadeOutFrames.value())
diff --git a/plugins/SlicerT/SlicerT.h b/plugins/SlicerT/SlicerT.h
index 934b61fb290..66fda24727e 100644
--- a/plugins/SlicerT/SlicerT.h
+++ b/plugins/SlicerT/SlicerT.h
@@ -47,14 +47,14 @@ class DynamicPlaybackBuffer
 	{
 	}
 
-	void loadSample(const sampleFrame* outData, int frames, int sampleRate, float newRatio)
+	void loadSample(const sampleFrame* inData, int frames, int sampleRate, float newRatio)
 	{
 		std::vector<float> leftData(frames, 0);
 		std::vector<float> rightData(frames, 0);
 		for (int i = 0; i < frames; i++)
 		{
-			leftData[i] = outData[i][0];
-			rightData[i] = outData[i][1];
+			leftData[i] = inData[i][0];
+			rightData[i] = inData[i][1];
 		}
 		m_leftChannel.loadData(leftData, sampleRate, newRatio);
 		m_rightChannel.loadData(rightData, sampleRate, newRatio);
diff --git a/plugins/SlicerT/SlicerTWaveform.cpp b/plugins/SlicerT/SlicerTWaveform.cpp
index 4d2382332ae..d941c096bd0 100644
--- a/plugins/SlicerT/SlicerTWaveform.cpp
+++ b/plugins/SlicerT/SlicerTWaveform.cpp
@@ -196,11 +196,11 @@ void SlicerTWaveform::mousePressEvent(QMouseEvent* me)
 
 	if (me->y() < m_seekerHeight) // seeker click
 	{
-		if (std::abs(normalizedClickSeeker - m_seekerStart) < m_distanceForClick) // dragging start
+		if (std::abs(normalizedClickSeeker - m_seekerStart) < s_distanceForClick) // dragging start
 		{
 			m_currentlyDragging = DraggingTypes::SeekerStart;
 		}
-		else if (std::abs(normalizedClickSeeker - m_seekerEnd) < m_distanceForClick) // dragging end
+		else if (std::abs(normalizedClickSeeker - m_seekerEnd) < s_distanceForClick) // dragging end
 		{
 			m_currentlyDragging = DraggingTypes::SeekerEnd;
 		}
@@ -221,7 +221,7 @@ void SlicerTWaveform::mousePressEvent(QMouseEvent* me)
 			int sliceIndex = m_slicerTParent->m_slicePoints.at(i);
 			float xPos = (sliceIndex - startFrame) / (endFrame - startFrame);
 
-			if (std::abs(xPos - normalizedClickEditor) < m_distanceForClick)
+			if (std::abs(xPos - normalizedClickEditor) < s_distanceForClick)
 			{
 				m_currentlyDragging = DraggingTypes::SlicePoint;
 				m_sliceSelected = i;
@@ -262,11 +262,11 @@ void SlicerTWaveform::mouseMoveEvent(QMouseEvent* me)
 	switch (m_currentlyDragging)
 	{
 	case DraggingTypes::SeekerStart:
-		m_seekerStart = std::clamp(normalizedClickSeeker, 0.0f, m_seekerEnd - m_minSeekerDistance);
+		m_seekerStart = std::clamp(normalizedClickSeeker, 0.0f, m_seekerEnd - s_minSeekerDistance);
 		break;
 
 	case DraggingTypes::SeekerEnd:
-		m_seekerEnd = std::clamp(normalizedClickSeeker, m_seekerStart + m_minSeekerDistance, 1.0f);
+		m_seekerEnd = std::clamp(normalizedClickSeeker, m_seekerStart + s_minSeekerDistance, 1.0f);
 		break;
 
 	case DraggingTypes::SeekerMiddle:
@@ -315,7 +315,7 @@ void SlicerTWaveform::mouseDoubleClickEvent(QMouseEvent* me)
 void SlicerTWaveform::wheelEvent(QWheelEvent* _we)
 {
 	// m_zoomLevel = _we-> / 360.0f * 2.0f;
-	m_zoomLevel += _we->angleDelta().y() / 360.0f * m_zoomSensitivity;
+	m_zoomLevel += _we->angleDelta().y() / 360.0f * s_zoomSensitivity;
 	m_zoomLevel = std::max(0.0f, m_zoomLevel);
 
 	drawEditor();
diff --git a/src/core/PhaseVocoder.cpp b/src/core/PhaseVocoder.cpp
index 964ec4610e1..492d309b3df 100644
--- a/src/core/PhaseVocoder.cpp
+++ b/src/core/PhaseVocoder.cpp
@@ -165,7 +165,7 @@ void PhaseVocoder::updateParams(float newRatio)
 void PhaseVocoder::generateWindow(int windowNum, bool useCache)
 {
 	// declare vars
-	float real, imag, phase, magnitude, freq, deltaPhase = 0;
+	float real, imag, phase, magnitude, freq, deltaPhase;
 	int windowStart = static_cast<float>(windowNum) * m_stepSize;
 	int windowIndex = static_cast<float>(windowNum) * s_windowSize;
 

From ae4df116ad516dada88217af62f67c533e658b4d Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Sun, 15 Oct 2023 22:33:26 +0200
Subject: [PATCH 74/99] new signal slot + more review

---
 include/PhaseVocoder.h              | 2 +-
 plugins/SlicerT/SlicerTView.cpp     | 4 ++--
 plugins/SlicerT/SlicerTWaveform.cpp | 4 ++--
 plugins/SlicerT/SlicerTWaveform.h   | 2 +-
 src/core/PhaseVocoder.cpp           | 4 ++--
 5 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/include/PhaseVocoder.h b/include/PhaseVocoder.h
index 8d51d2c1e45..13a41421b93 100644
--- a/include/PhaseVocoder.h
+++ b/include/PhaseVocoder.h
@@ -45,7 +45,7 @@ class LMMS_EXPORT PhaseVocoder
 	~PhaseVocoder();
 
 	//! Loads a new sample, and precomputes the analysis cache
-	void loadData(std::vector<float> originalData, int sampleRate, float newRatio);
+	void loadData(const std::vector<float>& originalData, int sampleRate, float newRatio);
 	//! Change the output timeshift ratio
 	void setScaleRatio(float newRatio) { updateParams(newRatio); }
 
diff --git a/plugins/SlicerT/SlicerTView.cpp b/plugins/SlicerT/SlicerTView.cpp
index db5ecca6a33..797e4c1c725 100644
--- a/plugins/SlicerT/SlicerTView.cpp
+++ b/plugins/SlicerT/SlicerTView.cpp
@@ -98,14 +98,14 @@ SlicerTView::SlicerTView(SlicerT* instrument, QWidget* parent)
 	m_midiExportButton.setActiveGraphic(PLUGIN_NAME::getIconPixmap("copyMidi"));
 	m_midiExportButton.setInactiveGraphic(PLUGIN_NAME::getIconPixmap("copyMidi"));
 	m_midiExportButton.setToolTip(tr("Copy midi pattern to clipboard"));
-	connect(&m_midiExportButton, SIGNAL(clicked()), this, SLOT(exportMidi()));
+	connect(&m_midiExportButton, &PixmapButton::clicked, this, &SlicerTView::exportMidi);
 
 	// slice reset button
 	m_resetButton.move(19, 150);
 	m_resetButton.setActiveGraphic(PLUGIN_NAME::getIconPixmap("resetSlices"));
 	m_resetButton.setInactiveGraphic(PLUGIN_NAME::getIconPixmap("resetSlices"));
 	m_resetButton.setToolTip(tr("Reset Slices"));
-	connect(&m_resetButton, SIGNAL(clicked()), m_slicerTParent, SLOT(updateSlices()));
+	connect(&m_resetButton, &PixmapButton::clicked, m_slicerTParent, &SlicerT::updateSlices);
 }
 
 // copied from piano roll
diff --git a/plugins/SlicerT/SlicerTWaveform.cpp b/plugins/SlicerT/SlicerTWaveform.cpp
index d941c096bd0..ec97bff95bb 100644
--- a/plugins/SlicerT/SlicerTWaveform.cpp
+++ b/plugins/SlicerT/SlicerTWaveform.cpp
@@ -59,8 +59,8 @@ SlicerTWaveform::SlicerTWaveform(int w, int h, SlicerT* instrument, QWidget* par
 	m_seekerSlicerTWaveform.fill(s_SlicerTWaveformBgColor);
 
 	// connect to playback
-	connect(instrument, SIGNAL(isPlaying(float, float, float)), this, SLOT(isPlaying(float, float, float)));
-	connect(instrument, SIGNAL(dataChanged()), this, SLOT(updateUI()));
+	connect(instrument, &SlicerT::isPlaying, this, &SlicerTWaveform::isPlaying);
+	connect(instrument, &SlicerT::dataChanged, this, &SlicerTWaveform::updateUI);
 
 	updateUI();
 }
diff --git a/plugins/SlicerT/SlicerTWaveform.h b/plugins/SlicerT/SlicerTWaveform.h
index 4d3272a1f9a..41a06e727c4 100644
--- a/plugins/SlicerT/SlicerTWaveform.h
+++ b/plugins/SlicerT/SlicerTWaveform.h
@@ -134,4 +134,4 @@ public slots:
 };
 } // namespace gui
 } // namespace lmms
-#endif // LMMS_SLICERT_WAVEFORM_T
+#endif // LMMS_SLICERT_WAVEFORM_H
diff --git a/src/core/PhaseVocoder.cpp b/src/core/PhaseVocoder.cpp
index 492d309b3df..e287b87b250 100644
--- a/src/core/PhaseVocoder.cpp
+++ b/src/core/PhaseVocoder.cpp
@@ -51,7 +51,7 @@ PhaseVocoder::~PhaseVocoder()
 	fftwf_destroy_plan(m_ifftPlan);
 }
 
-void PhaseVocoder::loadData(std::vector<float> originalData, int sampleRate, float newRatio)
+void PhaseVocoder::loadData(const std::vector<float>& originalData, int sampleRate, float newRatio)
 {
 	m_dataLock.lock();
 
@@ -165,7 +165,7 @@ void PhaseVocoder::updateParams(float newRatio)
 void PhaseVocoder::generateWindow(int windowNum, bool useCache)
 {
 	// declare vars
-	float real, imag, phase, magnitude, freq, deltaPhase;
+	float real, imag, phase, magnitude, freq, deltaPhase = 0;
 	int windowStart = static_cast<float>(windowNum) * m_stepSize;
 	int windowIndex = static_cast<float>(windowNum) * s_windowSize;
 

From 34ba2dc98bc2abb834b48071409e5fa2167dbc3a Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Wed, 18 Oct 2023 18:42:25 +0200
Subject: [PATCH 75/99] Fixed pitch shifting

---
 plugins/SlicerT/SlicerT.cpp | 17 ++++++-----------
 plugins/SlicerT/SlicerT.h   |  1 -
 2 files changed, 6 insertions(+), 12 deletions(-)

diff --git a/plugins/SlicerT/SlicerT.cpp b/plugins/SlicerT/SlicerT.cpp
index 1a3cb132715..74c522caeca 100644
--- a/plugins/SlicerT/SlicerT.cpp
+++ b/plugins/SlicerT/SlicerT.cpp
@@ -73,19 +73,16 @@ SlicerT::SlicerT(InstrumentTrack* instrumentTrack)
 	m_sliceSnap.addItem("1/16");
 	m_sliceSnap.addItem("1/32");
 	m_sliceSnap.setValue(0); // no snap by default
-
-	m_resamplerState = src_new(SRC_SINC_MEDIUM_QUALITY, 2, nullptr); // no error
-}
-
-SlicerT::~SlicerT()
-{
-	src_delete(m_resamplerState);
 }
 
 void SlicerT::playNote(NotePlayHandle* handle, sampleFrame* workingBuffer)
 {
 	if (m_originalSample.frames() < 2048) { return; }
 
+	if (!handle->m_pluginData)  {
+		handle->m_pluginData = src_new(SRC_SINC_MEDIUM_QUALITY, 2, nullptr);
+	}
+
 	// playback parameters
 	const int noteIndex = handle->key() - m_parentTrack->baseNote();
 	const int playedFrames = handle->totalFramesPlayed();
@@ -140,12 +137,12 @@ void SlicerT::playNote(NotePlayHandle* handle, sampleFrame* workingBuffer)
 			resamplerData.output_frames = frames;
 			resamplerData.src_ratio = inversePitchRatio;
 
-			src_process(m_resamplerState, &resamplerData);
+			src_process((SRC_STATE*)(handle->m_pluginData), &resamplerData);
 		}
 		else { std::copy_n(prePitchBuffer.data(), frames, workingBuffer + offset); }
 
 		// exponential fade out, applyRelease kinda sucks
-		if (noteFramesLeft < m_fadeOutFrames.value())
+		if (noteFramesLeft * pitchRatio < m_fadeOutFrames.value())
 		{
 			for (int i = 0; i < frames; i++)
 			{
@@ -349,8 +346,6 @@ void SlicerT::updateFile(QString file)
 	m_phaseVocoder.loadSample(
 		m_originalSample.data(), m_originalSample.frames(), m_originalSample.sampleRate(), speedRatio);
 
-	src_reset(m_resamplerState);
-
 	emit dataChanged();
 }
 
diff --git a/plugins/SlicerT/SlicerT.h b/plugins/SlicerT/SlicerT.h
index 66fda24727e..4d279fb054c 100644
--- a/plugins/SlicerT/SlicerT.h
+++ b/plugins/SlicerT/SlicerT.h
@@ -102,7 +102,6 @@ public slots:
 
 public:
 	SlicerT(InstrumentTrack* instrumentTrack);
-	~SlicerT() override;
 
 	void playNote(NotePlayHandle* handle, sampleFrame* workingBuffer) override;
 

From eb11366d813e3130261036f422c4c1eebdb5e5b6 Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Sun, 22 Oct 2023 14:10:32 +0200
Subject: [PATCH 76/99] Fixed buffer overflow in PV

---
 plugins/SlicerT/SlicerT.h           | 13 +++++----
 plugins/SlicerT/SlicerTWaveform.cpp |  4 +--
 plugins/SlicerT/SlicerTWaveform.h   |  6 ++--
 src/core/PhaseVocoder.cpp           | 45 +++++++++++++++--------------
 4 files changed, 35 insertions(+), 33 deletions(-)

diff --git a/plugins/SlicerT/SlicerT.h b/plugins/SlicerT/SlicerT.h
index 4d279fb054c..9ef393986d2 100644
--- a/plugins/SlicerT/SlicerT.h
+++ b/plugins/SlicerT/SlicerT.h
@@ -25,6 +25,7 @@
 #ifndef LMMS_SLICERT_H
 #define LMMS_SLICERT_H
 
+#include <algorithm>
 #include <fftw3.h>
 
 #include "AutomatableModel.h"
@@ -53,11 +54,11 @@ class DynamicPlaybackBuffer
 		std::vector<float> rightData(frames, 0);
 		for (int i = 0; i < frames; i++)
 		{
-			leftData[i] = inData[i][0];
-			rightData[i] = inData[i][1];
+			leftData.at(i) = inData[i][0];
+			rightData.at(i) = inData[i][1];
 		}
-		m_leftChannel.loadData(leftData, sampleRate, newRatio);
-		m_rightChannel.loadData(rightData, sampleRate, newRatio);
+		m_leftChannel.loadData(std::move(leftData), sampleRate, newRatio);
+		m_rightChannel.loadData(std::move(rightData), sampleRate, newRatio);
 	}
 
 	void getFrames(sampleFrame* outData, int startFrame, int frames)
@@ -70,8 +71,8 @@ class DynamicPlaybackBuffer
 
 		for (int i = 0; i < frames; i++)
 		{
-			outData[i][0] = leftOut[i];
-			outData[i][1] = rightOut[i];
+			outData[i][0] = leftOut.at(i);
+			outData[i][1] = rightOut.at(i);
 		}
 	}
 
diff --git a/plugins/SlicerT/SlicerTWaveform.cpp b/plugins/SlicerT/SlicerTWaveform.cpp
index ec97bff95bb..47b3628d73e 100644
--- a/plugins/SlicerT/SlicerTWaveform.cpp
+++ b/plugins/SlicerT/SlicerTWaveform.cpp
@@ -112,11 +112,11 @@ void SlicerTWaveform::drawSeeker()
 
 	// shadow on not selected area
 	brush.fillRect(0, 0, seekerStartPosX, m_seekerHeight, s_seekerShadowColor);
-	brush.fillRect(seekerEndPosX + 1, 0, m_seekerWidth + 1, m_seekerHeight, s_seekerShadowColor);
+	brush.fillRect(seekerEndPosX, 0, m_seekerWidth, m_seekerHeight, s_seekerShadowColor);
 
 	// draw border around selection
 	brush.setPen(QPen(s_seekerColor, 1));
-	brush.drawRoundedRect(seekerStartPosX, 0, seekerMiddleWidth - 1, m_seekerHeight - 1, 4, 4); // -1 needed
+	brush.drawRoundedRect(seekerStartPosX, 0, seekerMiddleWidth - 1, m_seekerHeight - 1, 0, 0); // -1 needed
 }
 
 void SlicerTWaveform::drawEditor()
diff --git a/plugins/SlicerT/SlicerTWaveform.h b/plugins/SlicerT/SlicerTWaveform.h
index 41a06e727c4..d744a532dc1 100644
--- a/plugins/SlicerT/SlicerTWaveform.h
+++ b/plugins/SlicerT/SlicerTWaveform.h
@@ -52,9 +52,9 @@ public slots:
 	SlicerTWaveform(int w, int h, SlicerT* instrument, QWidget* parent);
 
 	// predefined sizes
-	const int m_seekerHorMargin = 5;
-	const int m_seekerHeight = 38; // used to calcualte all vertical sizes
-	const int m_middleMargin = 6;
+	static constexpr int m_seekerHorMargin = 5;
+	static constexpr int m_seekerHeight = 38; // used to calcualte all vertical sizes
+	static constexpr int m_middleMargin = 6;
 
 	// colors
 	const QColor s_SlicerTWaveformBgColor = QColor(255, 255, 255, 0);
diff --git a/src/core/PhaseVocoder.cpp b/src/core/PhaseVocoder.cpp
index e287b87b250..06e91288381 100644
--- a/src/core/PhaseVocoder.cpp
+++ b/src/core/PhaseVocoder.cpp
@@ -23,6 +23,7 @@
  */
 #include "PhaseVocoder.h"
 
+#include <algorithm>
 #include <cstdio>
 #include <fftw3.h>
 #include <math.h>
@@ -55,7 +56,7 @@ void PhaseVocoder::loadData(const std::vector<float>& originalData, int sampleRa
 {
 	m_dataLock.lock();
 
-	m_originalBuffer = originalData;
+	m_originalBuffer = std::move(originalData);
 	m_originalSampleRate = sampleRate;
 	m_scaleRatio = -1; // force update, kinda hacky
 
@@ -77,10 +78,10 @@ void PhaseVocoder::loadData(const std::vector<float>& originalData, int sampleRa
 	// maybe limit this to a set amount of windows to reduce initial lag spikes
 	for (int i = 0; i < m_numWindows; i++)
 	{
-		if (!m_processedWindows[i])
+		if (!m_processedWindows.at(i))
 		{
 			generateWindow(i, false); // first pass, no cache
-			m_processedWindows[i] = true;
+			m_processedWindows.at(i) = true;
 		}
 	}
 
@@ -116,16 +117,16 @@ void PhaseVocoder::getFrames(std::vector<float>& outData, int start, int frames)
 	// which must be computed
 	for (int i = startWindow; i < endWindow; i++)
 	{
-		if (!m_processedWindows[i])
+		if (!m_processedWindows.at(i))
 		{
 			generateWindow(i, true); // theses should use the cache
-			m_processedWindows[i] = true;
+			m_processedWindows.at(i) = true;
 		}
 	}
 
 	for (int i = 0; i < frames; i++)
 	{
-		outData[i] = m_processedBuffer[start + i];
+		outData.at(i) = m_processedBuffer[start + i];
 	}
 
 	m_dataLock.unlock();
@@ -146,7 +147,7 @@ void PhaseVocoder::updateParams(float newRatio)
 	m_expectedPhaseIn = 2. * F_PI * m_stepSize / s_windowSize;
 	m_expectedPhaseOut = 2. * F_PI * m_outStepSize / s_windowSize;
 
-	m_processedBuffer.resize(m_scaleRatio * m_originalBuffer.size(), 0);
+	m_processedBuffer.resize(m_numWindows * m_outStepSize + s_windowSize, 0);
 
 	// very slow :(
 	std::fill(m_processedWindows.begin(), m_processedWindows.end(), false);
@@ -165,7 +166,7 @@ void PhaseVocoder::updateParams(float newRatio)
 void PhaseVocoder::generateWindow(int windowNum, bool useCache)
 {
 	// declare vars
-	float real, imag, phase, magnitude, freq, deltaPhase = 0;
+	float real, imag, phase, magnitude, freq, deltaPhase;
 	int windowStart = static_cast<float>(windowNum) * m_stepSize;
 	int windowIndex = static_cast<float>(windowNum) * s_windowSize;
 
@@ -179,17 +180,17 @@ void PhaseVocoder::generateWindow(int windowNum, bool useCache)
 		// analysis step
 		for (int j = 0; j < s_windowSize / 2; j++) // only process nyquistic frequency
 		{
-			real = m_FFTSpectrum[j][0];
-			imag = m_FFTSpectrum[j][1];
+			real = m_FFTSpectrum.at(j)[0];
+			imag = m_FFTSpectrum.at(j)[1];
 
 			magnitude = 2. * std::sqrt(real * real + imag * imag);
 			phase = std::atan2(imag, real);
 
 			// calculate difference in phase with prev window
 			freq = phase;
-			freq = phase - m_lastPhase[std::max(0, windowIndex + j - s_windowSize)]; // subtract prev pahse to get phase
+			freq = phase - m_lastPhase.at(std::max(0, windowIndex + j - s_windowSize)); // subtract prev pahse to get phase
 																					 // diference
-			m_lastPhase[windowIndex + j] = phase;
+			m_lastPhase.at(windowIndex + j) = phase;
 
 			freq -= m_expectedPhaseIn * j; // subtract expected phase
 			// at this point, freq is the difference in phase
@@ -205,8 +206,8 @@ void PhaseVocoder::generateWindow(int windowNum, bool useCache)
 			// add to the expected freq the change in freq calculated from the phase diff
 			freq = m_freqPerBin * j + m_freqPerBin * freq;
 
-			m_allMagnitudes[j] = magnitude;
-			m_allFrequencies[j] = freq;
+			m_allMagnitudes.at(j) = magnitude;
+			m_allFrequencies.at(j) = freq;
 		}
 		// write cache
 		std::copy_n(m_allFrequencies.data(), s_windowSize, m_freqCache.data() + windowIndex);
@@ -222,8 +223,8 @@ void PhaseVocoder::generateWindow(int windowNum, bool useCache)
 	// synthesis, all the operations are the reverse of the analysis
 	for (int j = 0; j < s_windowSize / 2; j++)
 	{
-		magnitude = m_allMagnitudes[j];
-		freq = m_allFrequencies[j];
+		magnitude = m_allMagnitudes.at(j);
+		freq = m_allFrequencies.at(j);
 
 		// difference to bin freq mulitplier
 		deltaPhase = freq - m_freqPerBin * j;
@@ -238,13 +239,13 @@ void PhaseVocoder::generateWindow(int windowNum, bool useCache)
 		deltaPhase += m_expectedPhaseOut * j;
 
 		// sum this phase to the total, to keep track of the out phase along the sample
-		m_sumPhase[windowIndex + j] += deltaPhase;
-		deltaPhase = m_sumPhase[windowIndex + j]; // final bin phase
+		m_sumPhase.at(windowIndex + j) += deltaPhase;
+		deltaPhase = m_sumPhase.at(windowIndex + j); // final bin phase
 
-		m_sumPhase[windowIndex + j + s_windowSize] = deltaPhase; // copy to the next
+		m_sumPhase.at(windowIndex + j + s_windowSize) = deltaPhase; // copy to the next
 
-		m_FFTSpectrum[j][0] = magnitude * std::cos(deltaPhase);
-		m_FFTSpectrum[j][1] = magnitude * std::sin(deltaPhase);
+		m_FFTSpectrum.at(j)[0] = magnitude * std::cos(deltaPhase);
+		m_FFTSpectrum.at(j)[1] = magnitude * std::sin(deltaPhase);
 	}
 
 	// inverse fft
@@ -266,7 +267,7 @@ void PhaseVocoder::generateWindow(int windowNum, bool useCache)
 			= a0 - (a1 * std::cos(piN2 / s_windowSize)) + (a2 * std::cos(2.0f * piN2 / s_windowSize)) - (a3 * std::cos(3.0f * piN2));
 
 		// inverse fft magnitudes are windowsSize times bigger
-		m_processedBuffer[outIndex] += window * (m_IFFTReconstruction[j] / s_windowSize / s_overSampling);
+		m_processedBuffer.at(outIndex) += window * (m_IFFTReconstruction.at(j) / s_windowSize / s_overSampling);
 	}
 }
 } // namespace lmms

From e4e680a7616c84553ebe2c4e7307ff946d65bbd4 Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Sun, 22 Oct 2023 17:47:44 +0200
Subject: [PATCH 77/99] Fixed mouse bug + better empty screen

---
 plugins/SlicerT/SlicerTView.cpp     |  1 +
 plugins/SlicerT/SlicerTWaveform.cpp | 21 +++++++++++++++++++--
 plugins/SlicerT/SlicerTWaveform.h   |  1 +
 3 files changed, 21 insertions(+), 2 deletions(-)

diff --git a/plugins/SlicerT/SlicerTView.cpp b/plugins/SlicerT/SlicerTView.cpp
index 797e4c1c725..452f9aa5526 100644
--- a/plugins/SlicerT/SlicerTView.cpp
+++ b/plugins/SlicerT/SlicerTView.cpp
@@ -112,6 +112,7 @@ SlicerTView::SlicerTView(SlicerT* instrument, QWidget* parent)
 void SlicerTView::exportMidi()
 {
 	using namespace Clipboard;
+	if (m_slicerTParent->m_originalSample.frames() < 2048) { return; }
 
 	DataFile dataFile(DataFile::Type::ClipboardData);
 	QDomElement note_list = dataFile.createElement("note-list");
diff --git a/plugins/SlicerT/SlicerTWaveform.cpp b/plugins/SlicerT/SlicerTWaveform.cpp
index 47b3628d73e..f8b6a00e36c 100644
--- a/plugins/SlicerT/SlicerTWaveform.cpp
+++ b/plugins/SlicerT/SlicerTWaveform.cpp
@@ -22,8 +22,12 @@
  *
  */
 
+// TODO: restructure most of the interaction code into mouseMoveEvent
+
 #include "SlicerTWaveform.h"
 
+#include <QBitmap>
+
 #include "SlicerT.h"
 #include "SlicerTView.h"
 #include "embed.h"
@@ -46,6 +50,7 @@ SlicerTWaveform::SlicerTWaveform(int w, int h, SlicerT* instrument, QWidget* par
 	, m_seeker(QPixmap(m_seekerWidth, m_seekerHeight))
 	, m_seekerSlicerTWaveform(QPixmap(m_seekerWidth, m_seekerHeight))
 	, m_sliceEditor(QPixmap(w, m_editorHeight))
+	, m_emptySampleIcon(embed::getIconPixmap("sample_track.png"))
 
 	// references to instrument vars
 	, m_slicerTParent(instrument)
@@ -62,6 +67,9 @@ SlicerTWaveform::SlicerTWaveform(int w, int h, SlicerT* instrument, QWidget* par
 	connect(instrument, &SlicerT::isPlaying, this, &SlicerTWaveform::isPlaying);
 	connect(instrument, &SlicerT::dataChanged, this, &SlicerTWaveform::updateUI);
 
+	// preprocess icons
+	m_emptySampleIcon = m_emptySampleIcon.createMaskFromColor(QColor(255, 255, 255), Qt::MaskMode::MaskOutColor);
+	
 	updateUI();
 }
 
@@ -130,7 +138,10 @@ void SlicerTWaveform::drawEditor()
 		brush.setPen(s_playHighlighColor);
 		brush.setFont(QFont(brush.font().family(), 9.0f, -1, false));
 		brush.drawText(
-			m_editorWidth / 2 - 100, m_editorHeight / 2 - 100, 200, 200, Qt::AlignCenter, tr("Drag sample to load"));
+			m_editorWidth / 2 - 100, m_editorHeight / 2 - 110, 200, 200, Qt::AlignCenter, tr("Drag sample to load"));
+		int iconOffsetX = m_emptySampleIcon.width() / 2.0f;
+		int iconOffsetY = m_emptySampleIcon.height() / 2.0f - 13;
+		brush.drawPixmap(m_editorWidth / 2.0f - iconOffsetX, m_editorHeight / 2.0f - iconOffsetY, m_emptySampleIcon);
 		return;
 	}
 
@@ -250,6 +261,13 @@ void SlicerTWaveform::mouseReleaseEvent(QMouseEvent* me)
 
 void SlicerTWaveform::mouseMoveEvent(QMouseEvent* me)
 {
+	// Do nothing if no button pressed
+	if (me->buttons() == Qt::MouseButton::NoButton) 
+	{ 
+		m_currentlyDragging = DraggingTypes::Nothing;
+
+	}
+
 	float normalizedClickSeeker = static_cast<float>(me->x() - m_seekerHorMargin) / m_seekerWidth;
 	float normalizedClickEditor = static_cast<float>(me->x()) / m_editorWidth;
 
@@ -314,7 +332,6 @@ void SlicerTWaveform::mouseDoubleClickEvent(QMouseEvent* me)
 
 void SlicerTWaveform::wheelEvent(QWheelEvent* _we)
 {
-	// m_zoomLevel = _we-> / 360.0f * 2.0f;
 	m_zoomLevel += _we->angleDelta().y() / 360.0f * s_zoomSensitivity;
 	m_zoomLevel = std::max(0.0f, m_zoomLevel);
 
diff --git a/plugins/SlicerT/SlicerTWaveform.h b/plugins/SlicerT/SlicerTWaveform.h
index d744a532dc1..230a2dcd2a7 100644
--- a/plugins/SlicerT/SlicerTWaveform.h
+++ b/plugins/SlicerT/SlicerTWaveform.h
@@ -125,6 +125,7 @@ public slots:
 	QPixmap m_seeker;
 	QPixmap m_seekerSlicerTWaveform; // only stores SlicerTWaveform graphic
 	QPixmap m_sliceEditor;
+	QPixmap m_emptySampleIcon;
 
 	SlicerT* m_slicerTParent;
 

From a3b601cbc62bb0503195b8b698c99311d07e7eb6 Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Sat, 28 Oct 2023 14:15:02 +0200
Subject: [PATCH 78/99] Small editor refactor + improvments

---
 plugins/SlicerT/SlicerTWaveform.cpp | 147 +++++++++++++++++-----------
 plugins/SlicerT/SlicerTWaveform.h   |  15 ++-
 2 files changed, 98 insertions(+), 64 deletions(-)

diff --git a/plugins/SlicerT/SlicerTWaveform.cpp b/plugins/SlicerT/SlicerTWaveform.cpp
index f8b6a00e36c..3ee09a65af5 100644
--- a/plugins/SlicerT/SlicerTWaveform.cpp
+++ b/plugins/SlicerT/SlicerTWaveform.cpp
@@ -22,8 +22,6 @@
  *
  */
 
-// TODO: restructure most of the interaction code into mouseMoveEvent
-
 #include "SlicerTWaveform.h"
 
 #include <QBitmap>
@@ -69,7 +67,7 @@ SlicerTWaveform::SlicerTWaveform(int w, int h, SlicerT* instrument, QWidget* par
 
 	// preprocess icons
 	m_emptySampleIcon = m_emptySampleIcon.createMaskFromColor(QColor(255, 255, 255), Qt::MaskMode::MaskOutColor);
-	
+
 	updateUI();
 }
 
@@ -116,15 +114,15 @@ void SlicerTWaveform::drawSeeker()
 	brush.fillRect(noteStartPosX, 0, noteEndPosX, m_seekerHeight, s_playHighlighColor);
 
 	// highlight on selected area
-	brush.fillRect(seekerStartPosX, 0, seekerMiddleWidth, m_seekerHeight, s_seekerHighlightColor);
+	brush.fillRect(seekerStartPosX, 0, seekerMiddleWidth - 1, m_seekerHeight, s_seekerHighlightColor);
 
 	// shadow on not selected area
 	brush.fillRect(0, 0, seekerStartPosX, m_seekerHeight, s_seekerShadowColor);
-	brush.fillRect(seekerEndPosX, 0, m_seekerWidth, m_seekerHeight, s_seekerShadowColor);
+	brush.fillRect(seekerEndPosX - 1, 0, m_seekerWidth, m_seekerHeight, s_seekerShadowColor);
 
 	// draw border around selection
 	brush.setPen(QPen(s_seekerColor, 1));
-	brush.drawRoundedRect(seekerStartPosX, 0, seekerMiddleWidth - 1, m_seekerHeight - 1, 0, 0); // -1 needed
+	brush.drawRect(seekerStartPosX, 0, seekerMiddleWidth - 1, m_seekerHeight - 1); // -1 needed
 }
 
 void SlicerTWaveform::drawEditor()
@@ -166,7 +164,7 @@ void SlicerTWaveform::drawEditor()
 	{
 		float xPos = (m_slicerTParent->m_slicePoints.at(i) - startFrame) / numFramesToDraw * m_editorWidth;
 
-		if (i == m_sliceSelected) { brush.setPen(QPen(s_selectedSliceColor, 2)); }
+		if (i == m_closestSlice) { brush.setPen(QPen(s_selectedSliceColor, 2)); }
 		else { brush.setPen(QPen(s_sliceColor, 2)); }
 
 		brush.drawLine(xPos, 0, xPos, m_editorHeight);
@@ -174,14 +172,6 @@ void SlicerTWaveform::drawEditor()
 	}
 }
 
-void SlicerTWaveform::updateUI()
-{
-	drawSeekerSlicerTWaveform();
-	drawSeeker();
-	drawEditor();
-	update();
-}
-
 void SlicerTWaveform::isPlaying(float current, float start, float end)
 {
 	m_noteCurrent = current;
@@ -191,39 +181,41 @@ void SlicerTWaveform::isPlaying(float current, float start, float end)
 	update();
 }
 
-// events
-void SlicerTWaveform::mousePressEvent(QMouseEvent* me)
+void SlicerTWaveform::updateUI()
+{
+	drawSeekerSlicerTWaveform();
+	drawSeeker();
+	drawEditor();
+	update();
+}
+
+// updates the closest object and changes the cursor respectivly
+void SlicerTWaveform::updateClosest(QMouseEvent* me)
 {
 	float normalizedClickSeeker = static_cast<float>(me->x() - m_seekerHorMargin) / m_seekerWidth;
 	float normalizedClickEditor = static_cast<float>(me->x()) / m_editorWidth;
-	// reset seeker on middle click
-	if (me->button() == Qt::MouseButton::MiddleButton)
-	{
-		m_seekerStart = 0;
-		m_seekerEnd = 1;
-		m_zoomLevel = 1;
-		return;
-	}
+
+	m_closestObject = DraggingTypes::Nothing;
+	m_closestSlice = -1;
 
 	if (me->y() < m_seekerHeight) // seeker click
 	{
 		if (std::abs(normalizedClickSeeker - m_seekerStart) < s_distanceForClick) // dragging start
 		{
-			m_currentlyDragging = DraggingTypes::SeekerStart;
+			m_closestObject = DraggingTypes::SeekerStart;
 		}
 		else if (std::abs(normalizedClickSeeker - m_seekerEnd) < s_distanceForClick) // dragging end
 		{
-			m_currentlyDragging = DraggingTypes::SeekerEnd;
+			m_closestObject = DraggingTypes::SeekerEnd;
 		}
 		else if (normalizedClickSeeker > m_seekerStart && normalizedClickSeeker < m_seekerEnd) // dragging middle
 		{
-			m_currentlyDragging = DraggingTypes::SeekerMiddle;
-			m_seekerMiddle = normalizedClickSeeker;
+			m_closestObject = DraggingTypes::SeekerMiddle;
 		}
 	}
 	else // editor click
 	{
-		m_sliceSelected = -1;
+		m_closestSlice = -1;
 		float startFrame = m_seekerStart * m_slicerTParent->m_originalSample.frames();
 		float endFrame = m_seekerEnd * m_slicerTParent->m_originalSample.frames();
 		// select slice
@@ -234,38 +226,82 @@ void SlicerTWaveform::mousePressEvent(QMouseEvent* me)
 
 			if (std::abs(xPos - normalizedClickEditor) < s_distanceForClick)
 			{
-				m_currentlyDragging = DraggingTypes::SlicePoint;
-				m_sliceSelected = i;
+				m_closestObject = DraggingTypes::SlicePoint;
+				m_closestSlice = i;
 			}
 		}
 	}
+	updateCursor();
+}
 
-	if (me->button() == Qt::MouseButton::RightButton) // erase selected slice
+void SlicerTWaveform::updateCursor()
+{
+	if (m_closestObject == DraggingTypes::SlicePoint || m_closestObject == DraggingTypes::SeekerStart
+		|| m_closestObject == DraggingTypes::SeekerEnd)
 	{
-		if (m_sliceSelected != -1 && m_slicerTParent->m_slicePoints.size() > 2)
-		{
-			m_slicerTParent->m_slicePoints.erase(m_slicerTParent->m_slicePoints.begin() + m_sliceSelected);
-			m_sliceSelected = -1;
-		}
+		setCursor(Qt::SizeHorCursor);
+	}
+	else if (m_closestObject == DraggingTypes::SeekerMiddle && m_seekerEnd - m_seekerStart != 1.0f)
+	{
+		setCursor(Qt::SizeAllCursor);
+	}
+	else { setCursor(Qt::ArrowCursor); }
+}
+
+// handles reset, deletion and sets what to drag
+void SlicerTWaveform::mousePressEvent(QMouseEvent* me)
+{
+
+	updateClosest(me);
+
+	// reset seeker on middle click
+	if (me->button() == Qt::MouseButton::MiddleButton)
+	{
+		m_seekerStart = 0;
+		m_seekerEnd = 1;
+		m_zoomLevel = 1;
+		return;
+	}
+
+	if (me->button() == Qt::MouseButton::LeftButton)
+	{
+		m_draggedObject = m_closestObject;
+		m_sliceDragged = m_closestSlice;
+		// update seeker middle for correct movement
+		m_seekerMiddle = static_cast<float>(me->x() - m_seekerHorMargin) / m_seekerWidth;
+	}
+
+	// delete closesd slice to mouse
+	if (me->button() == Qt::MouseButton::RightButton && m_slicerTParent->m_slicePoints.size() > 2
+		&& m_closestObject == DraggingTypes::SlicePoint)
+	{
+		m_slicerTParent->m_slicePoints.erase(m_slicerTParent->m_slicePoints.begin() + m_closestSlice);
+		updateClosest(me);
 	}
 	updateUI();
 }
 
+// sort slices after moving and remove draggable object
 void SlicerTWaveform::mouseReleaseEvent(QMouseEvent* me)
 {
-	m_currentlyDragging = DraggingTypes::Nothing;
+	updateClosest(me);
+	m_draggedObject = DraggingTypes::Nothing;
 	std::sort(m_slicerTParent->m_slicePoints.begin(), m_slicerTParent->m_slicePoints.end());
-
 	updateUI();
 }
 
+// this handles dragging and mouse cursor changes
+// what is being dragged is determined in mousePressEvent
 void SlicerTWaveform::mouseMoveEvent(QMouseEvent* me)
 {
-	// Do nothing if no button pressed
-	if (me->buttons() == Qt::MouseButton::NoButton) 
-	{ 
-		m_currentlyDragging = DraggingTypes::Nothing;
+	// update for mouse changes
+	updateClosest(me);
 
+	// Do nothing if no button pressed
+	if (me->buttons() == Qt::MouseButton::NoButton)
+	{
+		updateUI();
+		return;
 	}
 
 	float normalizedClickSeeker = static_cast<float>(me->x() - m_seekerHorMargin) / m_seekerWidth;
@@ -277,7 +313,7 @@ void SlicerTWaveform::mouseMoveEvent(QMouseEvent* me)
 	float endFrame = m_seekerEnd * m_slicerTParent->m_originalSample.frames();
 
 	// handle dragging events
-	switch (m_currentlyDragging)
+	switch (m_draggedObject)
 	{
 	case DraggingTypes::SeekerStart:
 		m_seekerStart = std::clamp(normalizedClickSeeker, 0.0f, m_seekerEnd - s_minSeekerDistance);
@@ -298,11 +334,11 @@ void SlicerTWaveform::mouseMoveEvent(QMouseEvent* me)
 		break;
 
 	case DraggingTypes::SlicePoint:
-		if (m_sliceSelected == -1) { break; }
-		m_slicerTParent->m_slicePoints.at(m_sliceSelected)
+		if (m_sliceDragged == -1) { break; }
+		m_slicerTParent->m_slicePoints.at(m_sliceDragged)
 			= startFrame + normalizedClickEditor * (endFrame - startFrame);
-		m_slicerTParent->m_slicePoints.at(m_sliceSelected) = std::clamp(
-			m_slicerTParent->m_slicePoints.at(m_sliceSelected), 0, m_slicerTParent->m_originalSample.frames());
+		m_slicerTParent->m_slicePoints.at(m_sliceDragged) = std::clamp(
+			m_slicerTParent->m_slicePoints.at(m_sliceDragged), 0, m_slicerTParent->m_originalSample.frames());
 		break;
 	case DraggingTypes::Nothing:
 		break;
@@ -312,21 +348,14 @@ void SlicerTWaveform::mouseMoveEvent(QMouseEvent* me)
 
 void SlicerTWaveform::mouseDoubleClickEvent(QMouseEvent* me)
 {
+	if (me->button() != Qt::MouseButton::LeftButton) { return; }
+
 	float normalizedClickEditor = static_cast<float>(me->x()) / m_editorWidth;
 	float startFrame = m_seekerStart * m_slicerTParent->m_originalSample.frames();
 	float endFrame = m_seekerEnd * m_slicerTParent->m_originalSample.frames();
-
 	float slicePosition = startFrame + normalizedClickEditor * (endFrame - startFrame);
 
-	for (int i = 0; i < m_slicerTParent->m_slicePoints.size(); i++)
-	{
-		if (m_slicerTParent->m_slicePoints.at(i) < slicePosition)
-		{
-			m_slicerTParent->m_slicePoints.insert(m_slicerTParent->m_slicePoints.begin() + i, slicePosition);
-			break;
-		}
-	}
-
+	m_slicerTParent->m_slicePoints.insert(m_slicerTParent->m_slicePoints.begin(), slicePosition);
 	std::sort(m_slicerTParent->m_slicePoints.begin(), m_slicerTParent->m_slicePoints.end());
 }
 
diff --git a/plugins/SlicerT/SlicerTWaveform.h b/plugins/SlicerT/SlicerTWaveform.h
index 230a2dcd2a7..ec13385d529 100644
--- a/plugins/SlicerT/SlicerTWaveform.h
+++ b/plugins/SlicerT/SlicerTWaveform.h
@@ -70,8 +70,8 @@ public slots:
 	const QColor s_seekerHighlightColor = QColor(178, 115, 255, 100);
 	const QColor s_seekerShadowColor = QColor(0, 0, 0, 120);
 
-	// interaction vars
-	static constexpr float s_distanceForClick = 0.03f;
+	// interaction behavior values
+	static constexpr float s_distanceForClick = 0.02f;
 	static constexpr float s_minSeekerDistance = 0.13f;
 	static constexpr float s_zoomSensitivity = 0.5f;
 
@@ -103,14 +103,16 @@ public slots:
 	int m_editorHeight;
 	int m_editorWidth;
 
-	// dragging vars
-	DraggingTypes m_currentlyDragging;
+	// interaction vars
+	DraggingTypes m_draggedObject;
+	DraggingTypes m_closestObject;
+	int m_closestSlice = -1;
+	int m_sliceDragged = -1;
 
 	// seeker vars
 	float m_seekerStart = 0;
 	float m_seekerEnd = 1;
 	float m_seekerMiddle = 0.5f;
-	int m_sliceSelected = 0;
 
 	// playback highlight vars
 	float m_noteCurrent;
@@ -132,6 +134,9 @@ public slots:
 	void drawEditor();
 	void drawSeekerSlicerTWaveform();
 	void drawSeeker();
+
+	void updateClosest(QMouseEvent* me);
+	void updateCursor();
 };
 } // namespace gui
 } // namespace lmms

From 965850e3ddf6ad08cc125f5b8f8d9020d989bd38 Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Sat, 28 Oct 2023 17:06:27 +0200
Subject: [PATCH 79/99] Editor playback visual + small fixes

---
 plugins/SlicerT/SlicerTWaveform.cpp | 159 +++++++++++++++++-----------
 plugins/SlicerT/SlicerTWaveform.h   |  26 +++--
 2 files changed, 111 insertions(+), 74 deletions(-)

diff --git a/plugins/SlicerT/SlicerTWaveform.cpp b/plugins/SlicerT/SlicerTWaveform.cpp
index 3ee09a65af5..9a4fc61a6e7 100644
--- a/plugins/SlicerT/SlicerTWaveform.cpp
+++ b/plugins/SlicerT/SlicerTWaveform.cpp
@@ -46,7 +46,8 @@ SlicerTWaveform::SlicerTWaveform(int w, int h, SlicerT* instrument, QWidget* par
 	// create pixmaps
 	, m_sliceArrow(PLUGIN_NAME::getIconPixmap("slide_indicator_arrow"))
 	, m_seeker(QPixmap(m_seekerWidth, m_seekerHeight))
-	, m_seekerSlicerTWaveform(QPixmap(m_seekerWidth, m_seekerHeight))
+	, m_seekerWaveform(QPixmap(m_seekerWidth, m_seekerHeight))
+	, m_editorWaveform(QPixmap(m_editorWidth, m_editorHeight))
 	, m_sliceEditor(QPixmap(w, m_editorHeight))
 	, m_emptySampleIcon(embed::getIconPixmap("sample_track.png"))
 
@@ -58,8 +59,8 @@ SlicerTWaveform::SlicerTWaveform(int w, int h, SlicerT* instrument, QWidget* par
 	setMouseTracking(true);
 
 	// draw backgrounds
-	m_sliceEditor.fill(s_SlicerTWaveformBgColor);
-	m_seekerSlicerTWaveform.fill(s_SlicerTWaveformBgColor);
+	m_seekerWaveform.fill(s_waveformBgColor);
+	m_editorWaveform.fill(s_waveformBgColor);
 
 	// connect to playback
 	connect(instrument, &SlicerT::isPlaying, this, &SlicerTWaveform::isPlaying);
@@ -71,21 +72,20 @@ SlicerTWaveform::SlicerTWaveform(int w, int h, SlicerT* instrument, QWidget* par
 	updateUI();
 }
 
-void SlicerTWaveform::drawSeekerSlicerTWaveform()
+void SlicerTWaveform::drawSeekerWaveform()
 {
-	m_seekerSlicerTWaveform.fill(s_SlicerTWaveformBgColor);
+	m_seekerWaveform.fill(s_waveformBgColor);
 	if (m_slicerTParent->m_originalSample.frames() < 2048) { return; }
-	QPainter brush(&m_seekerSlicerTWaveform);
-	brush.setPen(s_SlicerTWaveformColor);
+	QPainter brush(&m_seekerWaveform);
+	brush.setPen(s_waveformColor);
 
-	m_slicerTParent->m_originalSample.visualize(brush,
-		QRect(0, 0, m_seekerSlicerTWaveform.width(), m_seekerSlicerTWaveform.height()), 0,
-		m_slicerTParent->m_originalSample.frames());
+	m_slicerTParent->m_originalSample.visualize(brush, QRect(0, 0, m_seekerWaveform.width(), m_seekerWaveform.height()),
+		0, m_slicerTParent->m_originalSample.frames());
 }
 
 void SlicerTWaveform::drawSeeker()
 {
-	m_seeker.fill(s_SlicerTWaveformBgColor);
+	m_seeker.fill(s_emptyColor);
 	if (m_slicerTParent->m_originalSample.frames() < 2048) { return; }
 	QPainter brush(&m_seeker);
 
@@ -111,7 +111,7 @@ void SlicerTWaveform::drawSeeker()
 	// draw current playBack
 	brush.setPen(s_playColor);
 	brush.drawLine(noteCurrentPosX, 0, noteCurrentPosX, m_seekerHeight);
-	brush.fillRect(noteStartPosX, 0, noteEndPosX, m_seekerHeight, s_playHighlighColor);
+	brush.fillRect(noteStartPosX, 0, noteEndPosX, m_seekerHeight, s_playHighlightColor);
 
 	// highlight on selected area
 	brush.fillRect(seekerStartPosX, 0, seekerMiddleWidth - 1, m_seekerHeight, s_seekerHighlightColor);
@@ -125,15 +125,31 @@ void SlicerTWaveform::drawSeeker()
 	brush.drawRect(seekerStartPosX, 0, seekerMiddleWidth - 1, m_seekerHeight - 1); // -1 needed
 }
 
+void SlicerTWaveform::drawEditorWaveform()
+{
+	m_editorWaveform.fill(s_emptyColor);
+	if (m_slicerTParent->m_originalSample.frames() < 2048) { return; }
+
+	// draw SlicerTWaveform
+	QPainter brush(&m_editorWaveform);
+	float startFrame = m_seekerStart * m_slicerTParent->m_originalSample.frames();
+	float endFrame = m_seekerEnd * m_slicerTParent->m_originalSample.frames();
+
+	brush.setPen(s_waveformColor);
+	float zoomOffset = (m_editorHeight - m_zoomLevel * m_editorHeight) / 2;
+	m_slicerTParent->m_originalSample.visualize(
+		brush, QRect(0, zoomOffset, m_editorWidth, m_zoomLevel * m_editorHeight), startFrame, endFrame);
+}
+
 void SlicerTWaveform::drawEditor()
 {
-	m_sliceEditor.fill(s_SlicerTWaveformBgColor);
+	m_sliceEditor.fill(s_waveformBgColor);
 	QPainter brush(&m_sliceEditor);
 
 	// draw text if no sample loaded
 	if (m_slicerTParent->m_originalSample.frames() < 2048)
 	{
-		brush.setPen(s_playHighlighColor);
+		brush.setPen(s_playHighlightColor);
 		brush.setFont(QFont(brush.font().family(), 9.0f, -1, false));
 		brush.drawText(
 			m_editorWidth / 2 - 100, m_editorHeight / 2 - 110, 200, 200, Qt::AlignCenter, tr("Drag sample to load"));
@@ -144,31 +160,50 @@ void SlicerTWaveform::drawEditor()
 	}
 
 	// editor boundaries
-	float startFrame = m_seekerStart * m_slicerTParent->m_originalSample.frames();
-	float endFrame = m_seekerEnd * m_slicerTParent->m_originalSample.frames();
+	float totalFrames = m_slicerTParent->m_originalSample.frames();
+	float startFrame = m_seekerStart * totalFrames;
+	float endFrame = m_seekerEnd * totalFrames;
 	float numFramesToDraw = endFrame - startFrame;
 
+	// playback state
+	float noteCurrentPos = (m_noteCurrent - m_seekerStart) / (m_seekerEnd - m_seekerStart) * m_editorWidth;
+	float noteStartPos = (m_noteStart - m_seekerStart) / (m_seekerEnd - m_seekerStart) * m_editorWidth;
+	float noteLength = (m_noteEnd - m_noteStart) / (m_seekerEnd - m_seekerStart) * m_editorWidth;
+
 	// 0 centered line
-	brush.setPen(s_playHighlighColor);
+	brush.setPen(s_playHighlightColor);
 	brush.drawLine(0, m_editorHeight / 2, m_editorWidth, m_editorHeight / 2);
 
-	// draw SlicerTWaveform
-	brush.setPen(s_SlicerTWaveformColor);
-	float zoomOffset = (m_editorHeight - m_zoomLevel * m_editorHeight) / 2;
-	m_slicerTParent->m_originalSample.visualize(
-		brush, QRect(0, zoomOffset, m_editorWidth, m_zoomLevel * m_editorHeight), startFrame, endFrame);
+	// draw waveform from pixmap
+	brush.drawPixmap(0, 0, m_editorWaveform);
+
+	// draw currently playing
+	brush.setPen(s_playColor);
+	brush.drawLine(noteCurrentPos, 0, noteCurrentPos, m_editorHeight);
+	brush.fillRect(noteStartPos, 0, noteLength, m_editorHeight, s_playHighlightColor);
 
 	// draw slicepoints
 	brush.setPen(QPen(s_sliceColor, 2));
+
 	for (int i = 0; i < m_slicerTParent->m_slicePoints.size(); i++)
 	{
 		float xPos = (m_slicerTParent->m_slicePoints.at(i) - startFrame) / numFramesToDraw * m_editorWidth;
 
-		if (i == m_closestSlice) { brush.setPen(QPen(s_selectedSliceColor, 2)); }
-		else { brush.setPen(QPen(s_sliceColor, 2)); }
-
-		brush.drawLine(xPos, 0, xPos, m_editorHeight);
-		brush.drawPixmap(xPos - m_sliceArrow.width() / 2.0f, 0, m_sliceArrow);
+		if (i == m_closestSlice)
+		{
+			brush.setPen(QPen(s_sliceHighlightColor, 2));
+			brush.drawLine(xPos, 0, xPos, m_editorHeight);
+			brush.drawPixmap(xPos - m_sliceArrow.width() / 2.0f, 0, m_sliceArrow);
+			continue;
+		}
+		else
+		{
+			brush.setPen(QPen(s_sliceShadowColor, 1));
+			brush.drawLine(xPos - 1, 0, xPos - 1, m_editorHeight);
+			brush.setPen(QPen(s_sliceColor, 1));
+			brush.drawLine(xPos, 0, xPos, m_editorHeight);
+			brush.drawPixmap(xPos - m_sliceArrow.width() / 2.0f, 0, m_sliceArrow);
+		}
 	}
 }
 
@@ -177,13 +212,15 @@ void SlicerTWaveform::isPlaying(float current, float start, float end)
 	m_noteCurrent = current;
 	m_noteStart = start;
 	m_noteEnd = end;
-	drawSeeker(); // only update seeker, else horrible performance because of SlicerTWaveform redraw
+	drawSeeker();
+	drawEditor();
 	update();
 }
 
 void SlicerTWaveform::updateUI()
 {
-	drawSeekerSlicerTWaveform();
+	drawSeekerWaveform();
+	drawEditorWaveform();
 	drawSeeker();
 	drawEditor();
 	update();
@@ -195,22 +232,22 @@ void SlicerTWaveform::updateClosest(QMouseEvent* me)
 	float normalizedClickSeeker = static_cast<float>(me->x() - m_seekerHorMargin) / m_seekerWidth;
 	float normalizedClickEditor = static_cast<float>(me->x()) / m_editorWidth;
 
-	m_closestObject = DraggingTypes::Nothing;
+	m_closestObject = UIObjects::Nothing;
 	m_closestSlice = -1;
 
 	if (me->y() < m_seekerHeight) // seeker click
 	{
 		if (std::abs(normalizedClickSeeker - m_seekerStart) < s_distanceForClick) // dragging start
 		{
-			m_closestObject = DraggingTypes::SeekerStart;
+			m_closestObject = UIObjects::SeekerStart;
 		}
 		else if (std::abs(normalizedClickSeeker - m_seekerEnd) < s_distanceForClick) // dragging end
 		{
-			m_closestObject = DraggingTypes::SeekerEnd;
+			m_closestObject = UIObjects::SeekerEnd;
 		}
 		else if (normalizedClickSeeker > m_seekerStart && normalizedClickSeeker < m_seekerEnd) // dragging middle
 		{
-			m_closestObject = DraggingTypes::SeekerMiddle;
+			m_closestObject = UIObjects::SeekerMiddle;
 		}
 	}
 	else // editor click
@@ -226,33 +263,33 @@ void SlicerTWaveform::updateClosest(QMouseEvent* me)
 
 			if (std::abs(xPos - normalizedClickEditor) < s_distanceForClick)
 			{
-				m_closestObject = DraggingTypes::SlicePoint;
+				m_closestObject = UIObjects::SlicePoint;
 				m_closestSlice = i;
 			}
 		}
 	}
 	updateCursor();
+	updateUI();
 }
 
 void SlicerTWaveform::updateCursor()
 {
-	if (m_closestObject == DraggingTypes::SlicePoint || m_closestObject == DraggingTypes::SeekerStart
-		|| m_closestObject == DraggingTypes::SeekerEnd)
+	if (m_closestObject == UIObjects::SlicePoint || m_closestObject == UIObjects::SeekerStart
+		|| m_closestObject == UIObjects::SeekerEnd)
 	{
 		setCursor(Qt::SizeHorCursor);
 	}
-	else if (m_closestObject == DraggingTypes::SeekerMiddle && m_seekerEnd - m_seekerStart != 1.0f)
+	else if (m_closestObject == UIObjects::SeekerMiddle && m_seekerEnd - m_seekerStart != 1.0f)
 	{
 		setCursor(Qt::SizeAllCursor);
 	}
 	else { setCursor(Qt::ArrowCursor); }
 }
 
-// handles reset, deletion and sets what to drag
+// handles deletion, reset and middles seeker
 void SlicerTWaveform::mousePressEvent(QMouseEvent* me)
 {
-
-	updateClosest(me);
+	/* updateClosest(me); */
 
 	// reset seeker on middle click
 	if (me->button() == Qt::MouseButton::MiddleButton)
@@ -265,42 +302,34 @@ void SlicerTWaveform::mousePressEvent(QMouseEvent* me)
 
 	if (me->button() == Qt::MouseButton::LeftButton)
 	{
-		m_draggedObject = m_closestObject;
-		m_sliceDragged = m_closestSlice;
 		// update seeker middle for correct movement
 		m_seekerMiddle = static_cast<float>(me->x() - m_seekerHorMargin) / m_seekerWidth;
 	}
 
 	// delete closesd slice to mouse
 	if (me->button() == Qt::MouseButton::RightButton && m_slicerTParent->m_slicePoints.size() > 2
-		&& m_closestObject == DraggingTypes::SlicePoint)
+		&& m_closestObject == UIObjects::SlicePoint)
 	{
 		m_slicerTParent->m_slicePoints.erase(m_slicerTParent->m_slicePoints.begin() + m_closestSlice);
-		updateClosest(me);
 	}
-	updateUI();
+	updateClosest(me);
 }
 
 // sort slices after moving and remove draggable object
 void SlicerTWaveform::mouseReleaseEvent(QMouseEvent* me)
 {
-	updateClosest(me);
-	m_draggedObject = DraggingTypes::Nothing;
 	std::sort(m_slicerTParent->m_slicePoints.begin(), m_slicerTParent->m_slicePoints.end());
-	updateUI();
+	updateClosest(me);
 }
 
 // this handles dragging and mouse cursor changes
 // what is being dragged is determined in mousePressEvent
 void SlicerTWaveform::mouseMoveEvent(QMouseEvent* me)
 {
-	// update for mouse changes
-	updateClosest(me);
-
-	// Do nothing if no button pressed
+	// if no button pressed, update closest and cursor
 	if (me->buttons() == Qt::MouseButton::NoButton)
 	{
-		updateUI();
+		updateClosest(me);
 		return;
 	}
 
@@ -313,17 +342,17 @@ void SlicerTWaveform::mouseMoveEvent(QMouseEvent* me)
 	float endFrame = m_seekerEnd * m_slicerTParent->m_originalSample.frames();
 
 	// handle dragging events
-	switch (m_draggedObject)
+	switch (m_closestObject)
 	{
-	case DraggingTypes::SeekerStart:
+	case UIObjects::SeekerStart:
 		m_seekerStart = std::clamp(normalizedClickSeeker, 0.0f, m_seekerEnd - s_minSeekerDistance);
 		break;
 
-	case DraggingTypes::SeekerEnd:
+	case UIObjects::SeekerEnd:
 		m_seekerEnd = std::clamp(normalizedClickSeeker, m_seekerStart + s_minSeekerDistance, 1.0f);
 		break;
 
-	case DraggingTypes::SeekerMiddle:
+	case UIObjects::SeekerMiddle:
 		m_seekerMiddle = normalizedClickSeeker;
 
 		if (m_seekerMiddle + distStart >= 0 && m_seekerMiddle + distEnd <= 1)
@@ -333,16 +362,18 @@ void SlicerTWaveform::mouseMoveEvent(QMouseEvent* me)
 		}
 		break;
 
-	case DraggingTypes::SlicePoint:
-		if (m_sliceDragged == -1) { break; }
-		m_slicerTParent->m_slicePoints.at(m_sliceDragged)
+	case UIObjects::SlicePoint:
+		if (m_closestSlice == -1) { break; }
+		m_slicerTParent->m_slicePoints.at(m_closestSlice)
 			= startFrame + normalizedClickEditor * (endFrame - startFrame);
-		m_slicerTParent->m_slicePoints.at(m_sliceDragged) = std::clamp(
-			m_slicerTParent->m_slicePoints.at(m_sliceDragged), 0, m_slicerTParent->m_originalSample.frames());
+		m_slicerTParent->m_slicePoints.at(m_closestSlice) = std::clamp(
+			m_slicerTParent->m_slicePoints.at(m_closestSlice), 0, m_slicerTParent->m_originalSample.frames());
 		break;
-	case DraggingTypes::Nothing:
+	case UIObjects::Nothing:
 		break;
 	}
+	// dont update closest, and update seeker waveform
+	drawEditorWaveform();
 	updateUI();
 }
 
@@ -371,7 +402,7 @@ void SlicerTWaveform::wheelEvent(QWheelEvent* _we)
 void SlicerTWaveform::paintEvent(QPaintEvent* pe)
 {
 	QPainter p(this);
-	p.drawPixmap(m_seekerHorMargin, 0, m_seekerSlicerTWaveform);
+	p.drawPixmap(m_seekerHorMargin, 0, m_seekerWaveform);
 	p.drawPixmap(m_seekerHorMargin, 0, m_seeker);
 	p.drawPixmap(0, m_seekerHeight + m_middleMargin, m_sliceEditor);
 }
diff --git a/plugins/SlicerT/SlicerTWaveform.h b/plugins/SlicerT/SlicerTWaveform.h
index ec13385d529..4bbfe08b83b 100644
--- a/plugins/SlicerT/SlicerTWaveform.h
+++ b/plugins/SlicerT/SlicerTWaveform.h
@@ -57,14 +57,17 @@ public slots:
 	static constexpr int m_middleMargin = 6;
 
 	// colors
-	const QColor s_SlicerTWaveformBgColor = QColor(255, 255, 255, 0);
-	const QColor s_SlicerTWaveformColor = QColor(123, 49, 212);
+	const QColor s_emptyColor = QColor(0, 0, 0, 0);
+	
+	const QColor s_waveformColor = QColor(123, 49, 212);
+	const QColor s_waveformBgColor = QColor(255, 255, 255, 0);
 
 	const QColor s_playColor = QColor(255, 255, 255, 200);
-	const QColor s_playHighlighColor = QColor(255, 255, 255, 70);
+	const QColor s_playHighlightColor = QColor(255, 255, 255, 70);
 
 	const QColor s_sliceColor = QColor(218, 193, 255);
-	const QColor s_selectedSliceColor = QColor(178, 153, 215);
+	const QColor s_sliceShadowColor = QColor(136, 120, 158);
+	const QColor s_sliceHighlightColor = QColor(255, 255, 255);
 
 	const QColor s_seekerColor = QColor(178, 115, 255);
 	const QColor s_seekerHighlightColor = QColor(178, 115, 255, 100);
@@ -75,7 +78,7 @@ public slots:
 	static constexpr float s_minSeekerDistance = 0.13f;
 	static constexpr float s_zoomSensitivity = 0.5f;
 
-	enum class DraggingTypes
+	enum class UIObjects
 	{
 		Nothing,
 		SeekerStart,
@@ -104,10 +107,11 @@ public slots:
 	int m_editorWidth;
 
 	// interaction vars
-	DraggingTypes m_draggedObject;
-	DraggingTypes m_closestObject;
+	UIObjects m_draggedObject;
+	UIObjects m_closestObject;
 	int m_closestSlice = -1;
 	int m_sliceDragged = -1;
+	bool m_currentlyDragging = false;
 
 	// seeker vars
 	float m_seekerStart = 0;
@@ -125,15 +129,17 @@ public slots:
 	// pixmaps
 	QPixmap m_sliceArrow;
 	QPixmap m_seeker;
-	QPixmap m_seekerSlicerTWaveform; // only stores SlicerTWaveform graphic
+	QPixmap m_seekerWaveform; // only stores SlicerTWaveform graphic
+	QPixmap m_editorWaveform;
 	QPixmap m_sliceEditor;
 	QPixmap m_emptySampleIcon;
 
 	SlicerT* m_slicerTParent;
 
-	void drawEditor();
-	void drawSeekerSlicerTWaveform();
+	void drawSeekerWaveform();
 	void drawSeeker();
+	void drawEditorWaveform();
+	void drawEditor();
 
 	void updateClosest(QMouseEvent* me);
 	void updateCursor();

From 57e90fdd883efa5ceea4347b355954ca285c7ac7 Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Sun, 29 Oct 2023 12:43:02 +0100
Subject: [PATCH 80/99] Roxas UI improvments

---
 data/themes/default/lcd_19purple.png     | Bin 0 -> 9764 bytes
 data/themes/default/lcd_19purple_dot.png | Bin 0 -> 5403 bytes
 plugins/SlicerT/SlicerTView.cpp          |  65 ++++++++++++++---------
 plugins/SlicerT/SlicerTView.h            |  28 ++++------
 plugins/SlicerT/SlicerTWaveform.cpp      |  10 ++++
 plugins/SlicerT/SlicerTWaveform.h        |   4 +-
 plugins/SlicerT/artwork.png              | Bin 14209 -> 13791 bytes
 7 files changed, 64 insertions(+), 43 deletions(-)
 create mode 100644 data/themes/default/lcd_19purple.png
 create mode 100644 data/themes/default/lcd_19purple_dot.png

diff --git a/data/themes/default/lcd_19purple.png b/data/themes/default/lcd_19purple.png
new file mode 100644
index 0000000000000000000000000000000000000000..35ecc4ace0e094e7702bb744acc17df00cf726e5
GIT binary patch
literal 9764
zcmeHrcT|&G({JcSs`Or^NDB~p??pkHN)^(8&;lfcE+B*=qJn^k^p1c?6BH@Zk=~Im
zMLJk0K~QhdbIyCty5CxNy=&d?zmu#dd7jxbzdiGt*^}%YXJ%?ZP03CP005|s40SE=
z-w*JY5IHIS^SgIX9RR>M5M*VIwgCI{dix@s5gu?}bf7n!7ao9c1^@zP3e#;;?G;c_
zi&d0T1YcipQpKU(5J@dM=G+At8PR?lU~YUWH+KQ1-xZ!z^YdhX`$xP+XZMybqUpY^
zTG*E!0n^)?Kfby&@4sC?{{DUQ_|zWv-G^oSIIc%0E_?GddVl3Z_sWNL5_JusmJ~<H
z@#EvT!&3%<u*$`s4a3L!Mq+o*e4AO=7cUgz0{KIvfEu%3{0@$`nNve=-(LJFN)(pa
zT*31obwB<m&fm*w-^{{`MFP8el4bEjoOcuHi`a@g4*k^j@N&yK2zP4~_dM#(nM3C7
zA0Pbo+)7W7jt6!(Z~r(lsQ*&WxHsgrh6^?Nmfv%@KGYIAhy8Nw5Lo#0aPa%7-P!lg
zNjhic8xOX&_nV3r>s>I?sKW8X#!?=;ke1J{J0;NDd)Bsx2`$(wwa0R}t(+ht>`J|3
z$SzR3KulrPyNya=`t()1bDUCoe1aonPP&OK*v+RSbG)Uz(i@r|BkY&{M#J;k=XKk*
z#@$b|O^tqgA%s#15%DAoUn*PXT0+~K*s*k0S8RFIzbBY?I<swMG=G&*zPMLkvc`n#
zp2`jzpVB3Ze^yS<#)t`(tTM)F2pLw6#IZ2nz8%gob8;)3#Amw=qMb*CmMFOB_DQ0P
znGm}Ja;-i{^R-9wCSRnDzo%4aj0_sD2)uG(zpzS|8>33|WF)RFSuUtOd89n!0uJ#i
zGS|kUw=mh(b`zd#V>wVaZfnORI+$vUsi>W?-S(_~Z#mR-Fk`nLdZ4sy_|TcnuXd!H
z73DkBn<BiQ^~PzC>85QUQ~j1(S!LBnQgxO6>TR#a{i^jiVJ_Ut_?W52%GC>`$>MfZ
zZUe8WpR$z9uX;7FP0o6?tPEy5oW4Aia{QU+{$aKbr(DSLGTUKgWb(E>f2`@<ApQ2d
zzKHt@bpTC+!~WxkD692xS&f_)EB<)#t@jjLtX%!fkXIiJ_U+HmR+*<^hXZwIc8kkl
zGfKsi-}?r?*CE5E>IB$kDxuk;R_39QZ(jHM9J3Sj4#xcR_Abb8-gx)ktD@@t;5=%t
zug~B9bR1Jrg~JTZZ`z88y*Pb1xVi}N9*6pM00lYUvT`Xrb?{7?3dV#sy!Q&7&hnXC
zp5kPb&yu@iZns$e!m{gY8nuYWP*ijlYVNh_YhR-$o!qa{T?41XkC;TvS>^WJs_I2j
z#?t#TV*2W?Z#8iNY`wrrD?C}5=+=gPNUOvyxDU5}nGSd<TVZ6w+7<I|W(Pblc5JD3
zrGbf<q&Tw{vs3<va6hY*=Ia_`P?bb^ul%(^Y9z44l6^L$I9GvjhWlu~>L}&8O3_-@
zt8Mm6{qUNT8VpzNAo1L{1D{dyNU)B=k}+5Oy2e7dh^Bsy9Ame}%@temmV3c55vmTa
z9VkcNQ#WnH&5uHj>rzY_^TNuwCg0fU0XSIF&vt}o<)9w2)@<WsfMO1VdRY+@>h@8}
z*JHK5gX;Dn(&0=Z$L2Z}?a~YA!c}_t9?{arPFs9*&2p`zl^eDz5A>kw>V3E4^<fiH
zYi9jHf><#Z=9<gwPvxVyr~ts>@Mvkp!T@IFn*+2jPda87*76HtE(}CcuHUxY<`%DF
z&<}XQGX9vdL-qL*>sucUUNPr*=p;=xpu>x?%AS@N*;%|tH+0L!@I59iKZHOUt0cb?
zmvH#pvY1O5^F{xM=#Pf*^8C^FvM-*S*bU_9j=OMmRbyvUnG-ykl7@?5_a-K`4jSk}
zc~!#~{loLVWG)n{S4dM2_w6$2Nx}!}J}_ynJ{g4t18Ii=3qZdc6nO@XVOQ%<l@^xR
zJZQqa9xK`A^c^*myl$AdO!f6fZ}p|0nZ_{`^Uk$(nlGNqoUv$Fq#aq;vl9UVIaFuc
zLBlLi?ARpb)e9m!4D+F$$dxN<3Q`6NQ@hB*TtFYkz!oG-6Kt(FTPS>$DQlOVE^1C$
za_c35Ry**sRZTRsy)2FI+Z^C*dW*q9B$jA0NS>AZxck$-8b~Hv&y|Aqn#N@K&|u0Q
z%S6Fws^uwo;CngyE&nH&qqPW+@abaS^pE04-wf!vMcQ{JcIz`4=&LEKY7D#Jv>6;N
zQRvdKGNQYrp1k2}hr2&)E*($eP}qv7AwmO7>St7UDxWZOH(&(r(Pb2qmJDVP2^*oJ
zo-L~jFgWtCKEVnP>uIIGwY_@Ucx+5{P=F@tHVzYJ$LOrd4|CKuJtxvei_SkSaPk;K
z57^||;hqz|jU3}vjnQE(rF{^v+e4i;bTOAR*1v1-DjHl%TCK04Fx1&>vQ>P6uYrD4
zkJwU@e62Pv{hn-^53%ar+>uAjrqm_q3!xt93p27TcPMo-qhtVO%12QmCVe^9;dhf}
zz@S9^jikxIj>5g{hvuWsFJ)A;I%u`>YVMJ*bw)fkWHnNGZTtR{%42VG@A6Mf9x`MV
z2@tpjnLSaX98#RzmoEWO_VklM3bl->yXMb;Y*bFn4SUTPv;JlbPrSoKf`yE;+0{(h
zkYqZwc8U?o*tm$6&U;6zJwdB-J#n*Io5Ody__G~s@5@~YhO`QY%j&yeQ&goM-=Nj&
z_h2j|L6FU2drJJVd@c?<9FckvVjnf>qt##BY6Nnv@h=l*-Iu<|Mp~O4$d4-*ueN}@
z<V=4mZSlTIRQA-u{s`C54P}y{N#GZ(ReVwX$gCmKb;OLDv3lzcw<-FbqbKtjUuD0D
z8?nRzMel>9jFN={k#>>(WT~ir0ECZP{tf>Tc+FGp)pyV~<y(kiB|k*52RULEY+e50
zCe18@#Ih}O!&x*ypzDEyi@<2YL$1d(eBpFNH6?H6LGNsV{Uy-_-ZgdB#B^N)-w!Cv
z&ImZv%$Q5s8-~9?D;>1GrhD%yyoUm=S<yeOd2GKh)jQ#(0yK=<pr1@(YDi`f&B2Tt
zKF(`1scu6jTz~RaStqs@;5&5SL`c+6m*IV^Uh$#*qeK5-3Kl$_YR7lwr6#-NDIswP
z`C07!o()}PbX7J&vOF?kw+Rr|X$nr(-0awEefE*-7U!aR7MCXcPC*<(OWwL*Eq>ZQ
z{BB-M!>f27%Y#hk1aHZ2VyLJX|5{mSitHGOibpMRtQEjllTDH?zRqP3L-551oZ6nA
z2y8VU>`8l+TEFeT)_R$bkC(PI_odo9t7-=yVLNQod$oEEMTZ?}PR<5$ArL)Cthb)g
z|EY!X#x&EGsm*6YvLgdRNPZWYU{1nQvBXn^<lqLKgsD_)gPeZad<9@ayP15x4UAki
zniqL*qj`bm19C!oyl9d2dgK|OtGMj3u2=9q7N0?0r`O6$rWY;grrzOub>gt0WJW`V
zcz1W&MM#ck-?R$(3BNapxR<M>AEBsZAf<50$nr+O`}eF}dVNue4=@S1Xpz&CsO{Sx
zjjBdEb*}2Ok$gtfK*2ZNy3mokz5(U?9@so~m0NC(t||o&cuovi2&A=odl+UMC4DmU
zxckkB?9#?*mc;Aco(Y)J$w|iH$a%$3;p+nzR9wgvs`YBM*gH?Uup2#q<xlQGD*P!)
z#;#m)WmNNfOg09i!KT1ME<xJ3G76VG&A9p$Bg`^6!$guu$bI0g?q->v)4Shxvdqlb
zN04;M@^g&aHFpv-<fT2m>FCpr9Bngl6sF5QWzgI<BNN(LYVd2kf6ayjx9x>xwB8Tb
zhz{XuD|KBK7FF^4$kuI@S~V<4^fc}n^-H03?xLINA&ugYk3SYz-3b!yDGS*>*9p+n
zVl_-I(}p_o3CqTLbo+B>&N_<MIiFS%zb9c!x+oAqVO~_5CIYZd^hjdq5q1a=@^|Xc
z!a$v|Zo>{zQ)P(gr#{j)9(1_)3Qt%{p(S@0Mq2>aY{K}eul-uJMP{w)RFF{8snA|&
z`-JSMift4TpT@@vlI3FgeC{JtAC0Y=r?ljsy<1c0bROZQzDr6#%;-unJ9T8E&yRhv
zW8%{7)IJ~Dsl7Y@>B4uCKKVq`dn62`&9nL_8^+J1LbfoBBxp$_gL5@}rdp8G!GnXT
zJNZ=&S|13*DQrc5JGQ6gj7^nHiasKB$!XtSj&-uP7EvfCyRq#Q8!I<@tKNnX!oi`(
zm)2K_l#l1IOYksZ4xymVBUb3QcnsYse#`5T4-uOZpT0E1lPvzi4HX%#ABS;lmepA>
z+wFX6p-PF&6U(_{y7cB^4Uxk~le`YS8`=Xx-sT)>K1C4N9$OXA?=+MA$+U;yX^%5R
zK>4vc`${j&)I;eAbcpRyG0O;4$TwDPWJ0m^#&1q2c&<9-O?5G1`RElJdaN$INggop
z6<3b%#@$!bZ=f#XR-|nVU-n4zoMMpC7Vuzn12cl?ujKEIp#<}mu2L1K?mz6$EO^Ao
z|5eMyOh`yY97bFQL?7LwPCD(2v#&NKf|v;RB*qnISWuj)NDmW0+cTK2&B3{?{W1_4
zsT@}xwOza%!3t3;Q%j~kE!c}S#BjyhBUn08$r0+ZR}AUDRn#U3X(yQvexb9{OwKqP
z*`zZy8c5hb!#eA8Wstc=si<EGS^ZFX+M{JaV^3&6eEGT<7v)l%cJyR1tm_H~-Ap(i
zxFf%CEr$>PtMZ&Yk43g^z}zd7jgM5wj6OL>Fppe5!gl6ij7!Dp!L2Jr85ne%y598_
zKwKaJ_hfWwt##~vW{!I@tpO~zO{64gM|6P{{^5&as2SRv9{1p-B!=~^NDxo{W2Wgx
z*3FEBUrsvw%?=qowOVi9zQfVxDyX+)&NV`U(Nju<2gG5&2Hl{Wff!TLur7DVVXA}s
zjY(Mj_Oz?t`nO^AtT<AGZN{MM-edb4i9I%cq&W8e1CJu(*aXN{tjON7r&(|wWg^X&
z@H5$-=iXmL?&gJFe86km&~@wiSsi(lc`2avo)$f7YsV?)C$=Dhbh|$cSoY4K!Bv^`
zF?&=ExhC-*xsPj1LEg7gK_{LAA3Ca$t+dhg)V-nL)QbGFSkG&%*-GtQ;h3}(PxHlm
zl%j5sJpXhuvE+lVZ1)GKq9hHjs`K7Sm5z6EM|!O4hLva9Xc*lmBpT2hIor^eemT|P
z0;E1!1b8AeEayX;I^8oYmM$u4X_bP7hJylF$d7rso)B02@G8pR&zZ$MAWQnr8}VjS
z?zVq&o*gr1c*HH^x4^9W>OsoqrU<i)n{*@vOTb~vb*W5|Z_6hS3)js_zE-n7yfj36
z{mkzkok~aoj4@hQap04Fs3<_@w(FWCSN*g!0H>U8WR@G6wj3u%>J#u<`=ho5z_f?q
zCdU4Fp0&lu^;$FdI<q>D<!I}-aZ%{Zh9p7R#~UD(rSfg-lPS|-vf{vZ?|S!jpJ9p3
z?gF2!l!M-`Gc8xy?$ijd^h@7p+|H5C{J!;EMpGczk&wXw!bnQ~AQ5*5mE+-2Mu@ZJ
zkz<dJ<bM>WfvN3e@p(ZY8X(*#MTboI30uhmFAqevrdoD2V-HTe5lEYh4Lr|;Xdgbl
zHAEK%S1j&V2~i~YFbw9nS*T+b_dQ>{TKl26m!D-GUs>H{n}>8rYe~b@lDON!-D@cX
z4`)@tz&FZsl;zXxzOj>D?!%YV4P2fCaaG@68pajSUj3-Dq%teo-8Q~IOwVOi5)=9E
zOhmmB*Sr)g8F$E5Eh^OFYd$5^N4VV(zpdu#Yn+YBlV-EB|J)kZLzQ;*+KdVdwc0X8
z&s$56C{4;$4dItAiuzn)Daf(FFk5<O6>QPiMs=1pZ8e#81Qjq;F{KwurKHZ1wL#ci
z*ow`ucsH{Kq2LHV(Ptwo-y6>D?1$|%D+gU3yDY10&?KnG-!@L5l)E5oanx&Z`B{e9
z^HNkh6VUu>f7|utZs6T6uLKpz@=`6iLU3PV``Zw33Hi&9%;w<XnUi<%W)(LbGlm*f
zCb@_qA8H@pLI<=?)_f_aDfJG<k%-&-1eo<S=N9!VNalQ~_+Ujf{%o3z&n|m8nW5e~
z9u`Y*M88XjbP8AKARbUw_3cf=3~?2*k`Ey7(yI`aL!09=C8?LQ4nuLdSAmfuKeX8q
zrew2^>nc816WsWc>37Tc?v{A9{n7}VC6xX1@a#^Ts4~u-Cq1~>;v;+R<09@B(#{Az
zx0szO8H4OYr+{L1F8EyPJF=<!^M3ELAJ0Ls9L!q;ReDz?^^x>Ry#{#;ce-tv#s?|%
zWO2)?7&Z2%dqh749~p51?1y_s;xbpFOD@h9nXCrNM=(At_9DN^`rK!G10teL#vey>
zB&$y<aF;y~LnoTN)yqFjW%Mw-xJL7GJZd|MOvcpNhCpAy{U>#0AB`XBo#Nck<3Zi#
z%1=K|)3vxsr4^nbBMMTsc0~Ar3CD(svFT}ZZe6H1#XO_*mlew2VKyU+o-=5bwj-ig
zTq8&FiW|yh6$DfS#Cg(hZar*Z=_h*A#H9}Kidb(nk+);gZH=d)I!L5o(UlPDzrU&Y
zrA+zi#Vn(aD5^XHIk2Gp!QJ9Z@HNgZe}zb&S=Is|BZHHWo>r=cPeuQ<RiRO$b&0mT
zrao((lPNb#;HEz7RIyF(%F_iG9?=(qp}HLoUvzx{_OXlUlR0_oQ`dC2#mOZ2J5O&$
z;PkkM8M#7oCQ20FJF^fHQ&P#{8V#vkIZCmbYvqX5H#q@1VXw_EY(ARVEXNME$vAY2
zMV?ZTC?)Z{DS>*E6NvJ?S=%7AS4B0xt0ecVGmoTEWHus>t<JtDL&L~77z)YY;xJn3
z%`5)`&p71d&@PRfE{ZCkh2utrA&ShGJcx2$!;+1L3DiLo_hK79QyG3t!MYIK&pq16
zvn~1gB)Yiy=An6!R^)&^i<0oY+KYWrEA)O`Ui}$uxBFso9+@mZzR@UcRt(uDzTi~n
zna2_>?w;kb9OqCZJ?h?l8Fy0G;K5TdQ5_!hgBFzc9x|vycE|ol@)6bbZ}L3(R)?wi
zM93Y{Dv&tp)yQcGx-smwrQ`7Se&_e`mtolzhM2AhX$GG>)#O0><%7iP^ysp)nD{G^
zeKfg|%ZL3@Q0+j5ycI3n5?F)`t6d1BPFrj_IGKfY@$|X9dfO9~_Tih}7GY;ewna*P
zYRefFrSD!C!J=>mKg8JT8vsBMiO|t8Gt$xd^I#KyoS6}tsAkx%$=T^>*=cc^W|w#Q
zVJ@aR{;p!`W#+fq2(j8NC*MsL5W>*Ho|9ziP9#tKbutzg2QGUOtxrT96P-pQdd6pt
z7OwOw_~V6z`QW)Gq9{ye=|@dMGr7K=q9jOe!)2N#{#YPkEWt(DL$sGP?a*gGS{}#!
zW!1jZxooJl=o6|>aUB#z9L%3dKkpP3q85bjzj#(am(6gE9j&!&@Vrm5#pk)A_^1BZ
z#Gye3gV;`Ep1#ojXVJ#0I-J+7624&X^ii%$47xS-zCK=+qDrYv;haL;7r<UBNQ@w7
zGZ{CF!75g;iwafOW*>Zdp!9?470h>{wWlha)XMNa&l&A)fA`el;<*B|i>x74yALRw
zTv;}1Jx))jU#bX)|72?z4f>(ak#;KBG%=QE(Ap#K?K3~Ns<z}y#u_?$Nyk@E!z9<9
zbYW=Y>0M16Gx_sZO@7Bd-vFznWosNuOLVc<MS|y7<|BSA{7@U)-6!)W^eqWTn|t8T
zpD_shIkUCNRb?pBQxXhALg11Cp5FL#XaGP}BfuLBb%&#QA#fLjmm2?mV+%ho0;a})
zQ_civ;;jRBMHmM8!YzYLt)M~fP$d|@hB~EcfHEGy6OIP+26%dSp_BvE_<!Ll<L}SK
zQvAHXRM75f{MIIBygEo<I4?*NBngzz3qW9G_|++SRefR3$`-o%e?Z`$)c9S|Xm4dH
zDSv-|Nq<>Mq_2yVw33pN6i`M=Mn(d!A%P0?LW2V&yifw?5Wg{W;V7st!W)f1dhwoP
zf+0vhv>HD@ew_DD|2(}-O#XuRLjA!4o)4)2u(y=7Bv8uJQ|j*)D6}315AugY|Dy%U
z3V&QLWdTPa{d}QtJq+9nE%0{;81yfDZ$Dp;U*W)@Qg9ErCtekWpH=!FQyLhVnEhpO
zPJs);)BBedp6q{Uq7lyjA?qK$osawq=kJc-&HuvvhxVVb|5C<lnV2Z+BB6fg?iuN-
z@t@DH3`0T@Fy&vjvQTLd2qXiQ0D|OT5+HeLs02jX86*L72FfXc;9waT2>drFBQF#h
z>;;9NL*c<C5qKPsEKosK9t4wsz`$}6AP@{B0d@ufC1hZDaG;zlObHDC8^kqV1imW4
z9)I`h914bqQdERH%P2x*C7?3S3KAeNNLoTsUP(>@3Q+=rWMrT)Ief96*8mKvtdI2d
z1mn|*@C3WSrM$gdehr)xuB>Hdq{c5J3H*=5%ma*e#v9<*0KyA~^hf<?$O_>Jw?u=_
z`IMGdQc#dl00Mz>@*o+xzuDh_`=ao*c#bL!l#~ViGCxm@GCmwUwcztg#RL43<D*g5
z@r8rYNM9=?(nF2^+$r93%fE(A@CynCMuT<1XgD4eC?l&Z4OEs^vXYip1}Q1aDTx7P
zl!1TKN5T-!f&VY<^X0><`a9`{2o!$)z+a-@YswPt^ZV)dqX**GV&difwJemu(BC1T
zz!>;%j`3K(hoG)tFBdqzfBaFff65X6LovV=fnXVkjDiFZt^|<)L7f#Pl)%z3d>Vm3
zC0SVod7z@wFBbknM<Jcj{$O9YmJ6OoJXiPv{lyip$RDW^{inXaEBrhUc*-QCffBzd
zlLMZUCG|(JQs*7x&uCSp{x3dMe<}Q}#o+CJ%kZrW-wCDuYK4FBh4=M;^Yup_{x_%K
z<^6Y(|BBy#>H3$h|B8YCO8MXF`j@W%ih=)1`QPgL|3(+(e>PKaFZ@3sfBaU7#y{E>
zzs(|rTrtoE{5*f>G!;L>ODMbzZBPIJO~?5~kRnFIfftgYjZE~&)+rfiWB?*AtkU?c
zbhnYNmQ}#aZhEe%t~8yVOK&tCan_J#t0Nup#aEP(*lU1zExttZHplQK*-v8Re1bXY
zJMz1;rp1}{fl3C8Z)(Rjcjs0IbXTtdE>GtYYkmz^LD46kcFyX5m{^I6josPja+a%S
zk#e^k@OQ6OxaN{y3BI~JY(w1KtTADmK^BrByti@PS0T6HN~CN-?Pq_vne?YgGj@CO
zsjlvmWu=ve;=aLSu0GsOPNeB%Mao}Y7n(168mhA!kLtU7sye#Xrl%jyJoTe49l!fE
zJo~HbXuQj4m0-<6X^(Bpt<te1!9PvazXq7%K6BVV>VL`ixz5zCY0D`S>CNr>?kbLr
z%9}eUF#IDyI+>H=vuqwmB%^xEVq9#`-WhM1lG<zgF}G&B{Lt?KtfACUx0pfxPhT6Y
z+<mw|`D8WZ-|U@_N|K}=d^p;*IN|E<W$cE0HEW$$VN+SuJXzDTYm(m?7#_jq%AK~=
zpC5Q?T+4UjDq_S@QTI6{cf`$Y(j7S|S70GFNOXHJ-$*LUs5_}YsF>fKE2z-)N>axk
zrr-Kkls<GLy-j3hqdTUQJrAEn`Zd1|%n?0{rc|WGeWfi3mEK10oStVHV5DcN`&`@U
G&i?^69IRjf

literal 0
HcmV?d00001

diff --git a/data/themes/default/lcd_19purple_dot.png b/data/themes/default/lcd_19purple_dot.png
new file mode 100644
index 0000000000000000000000000000000000000000..6582d8c201c6857700cd7f7471a7aad972a49b9c
GIT binary patch
literal 5403
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

literal 0
HcmV?d00001

diff --git a/plugins/SlicerT/SlicerTView.cpp b/plugins/SlicerT/SlicerTView.cpp
index 452f9aa5526..b61092bead8 100644
--- a/plugins/SlicerT/SlicerTView.cpp
+++ b/plugins/SlicerT/SlicerTView.cpp
@@ -44,13 +44,11 @@ namespace gui {
 SlicerTView::SlicerTView(SlicerT* instrument, QWidget* parent)
 	: InstrumentViewFixedSize(instrument, parent)
 	, m_slicerTParent(instrument)
-	, m_noteThresholdKnob(this)
-	, m_fadeOutKnob(this)
-	, m_bpmBox(3, "21pink", this)
+	, m_bpmBox(3, "19purple", this)
 	, m_snapSetting(this, tr("Slice snap"))
 	, m_syncToggle("Sync", this, tr("SyncToggle"), LedCheckBox::LedColor::Green)
-	, m_resetButton(this, nullptr)
-	, m_midiExportButton(this, nullptr)
+	, m_resetButton(this)
+	, m_midiExportButton(this)
 	, m_wf(248, 128, instrument, this)
 {
 	// window settings
@@ -76,38 +74,48 @@ SlicerTView::SlicerTView(SlicerT* instrument, QWidget* parent)
 	m_syncToggle.setModel(&m_slicerTParent->m_enableSync);
 
 	// bpm spin box
-	m_bpmBox.move(130, 203);
+	m_bpmBox.move(130, 201);
 	m_bpmBox.setToolTip(tr("Original sample BPM"));
-	m_bpmBox.setLabel(tr("BPM"));
+	/* m_bpmBox.setLabel(tr("BPM")); */
 	m_bpmBox.setModel(&m_slicerTParent->m_originalBPM);
 
 	// threshold knob
-	m_noteThresholdKnob.move(9, 195);
-	m_noteThresholdKnob.setToolTip(tr("Threshold used for slicing"));
-	m_noteThresholdKnob.setLabel(tr("Threshold"));
-	m_noteThresholdKnob.setModel(&m_slicerTParent->m_noteThreshold);
+	m_noteThresholdKnob = createStyledKnob();
+	m_noteThresholdKnob->move(10, 197);
+	m_noteThresholdKnob->setToolTip(tr("Threshold used for slicing"));
+	/* m_noteThresholdKnob->setLabel(tr("Threshold")); */
+	m_noteThresholdKnob->setModel(&m_slicerTParent->m_noteThreshold);
 
 	// fadeout knob
-	m_fadeOutKnob.move(75, 195);
-	m_fadeOutKnob.setToolTip(tr("Fade Out for notes"));
-	m_fadeOutKnob.setLabel(tr("Fade Out"));
-	m_fadeOutKnob.setModel(&m_slicerTParent->m_fadeOutFrames);
+	m_fadeOutKnob = createStyledKnob();
+	m_fadeOutKnob->move(64, 197);
+	m_fadeOutKnob->setToolTip(tr("Fade Out for notes"));
+	/* m_fadeOutKnob->setLabel(tr("Fade Out")); */
+	m_fadeOutKnob->setModel(&m_slicerTParent->m_fadeOutFrames);
 
 	// midi copy button
-	m_midiExportButton.move(215, 150);
-	m_midiExportButton.setActiveGraphic(PLUGIN_NAME::getIconPixmap("copyMidi"));
-	m_midiExportButton.setInactiveGraphic(PLUGIN_NAME::getIconPixmap("copyMidi"));
+	m_midiExportButton.move(199, 150);
+	m_midiExportButton.setIcon(PLUGIN_NAME::getIconPixmap("copyMidi"));
 	m_midiExportButton.setToolTip(tr("Copy midi pattern to clipboard"));
 	connect(&m_midiExportButton, &PixmapButton::clicked, this, &SlicerTView::exportMidi);
 
 	// slice reset button
-	m_resetButton.move(19, 150);
-	m_resetButton.setActiveGraphic(PLUGIN_NAME::getIconPixmap("resetSlices"));
-	m_resetButton.setInactiveGraphic(PLUGIN_NAME::getIconPixmap("resetSlices"));
+	m_resetButton.move(18, 150);
+	m_resetButton.setIcon(PLUGIN_NAME::getIconPixmap("resetSlices"));
 	m_resetButton.setToolTip(tr("Reset Slices"));
 	connect(&m_resetButton, &PixmapButton::clicked, m_slicerTParent, &SlicerT::updateSlices);
 }
 
+// style knob, defined in data/themes/default/style.css#L949
+Knob* SlicerTView::createStyledKnob()
+{
+	Knob* newKnob = new Knob(KnobType::Styled, this);
+	newKnob->setFixedSize(50, 40);
+	newKnob->setCenterPointX(24.0);
+	newKnob->setCenterPointY(15.0);
+	return newKnob;
+}
+
 // copied from piano roll
 void SlicerTView::exportMidi()
 {
@@ -177,10 +185,17 @@ void SlicerTView::paintEvent(QPaintEvent* pe)
 {
 	QPainter brush(this);
 	brush.setPen(QColor(255, 255, 255));
-	brush.setFont(QFont(brush.font().family(), 7.5f, -1, false));
-	brush.drawText(212, 165, 25, 20, Qt::AlignCenter, tr("Midi"));
-	brush.drawText(14, 165, 30, 20, Qt::AlignCenter, tr("Reset"));
-	brush.drawText(185, 217, 55, 20, Qt::AlignCenter, tr("Snap"));
+	brush.setFont(QFont(brush.font().family(), 7, -1, false));
+
+	// top text
+	brush.drawText(8, topTextY, textBoxWidth, textBoxHeight, Qt::AlignCenter, tr("Reset"));
+	brush.drawText(188, topTextY, textBoxWidth, textBoxHeight, Qt::AlignCenter, tr("Midi"));
+
+	// bottom text
+	brush.drawText(8, bottomTextY, textBoxWidth, textBoxHeight, Qt::AlignCenter, tr("Threshold"));
+	brush.drawText(63, bottomTextY, textBoxWidth, textBoxHeight, Qt::AlignCenter, tr("Fade Out"));
+	brush.drawText(127, bottomTextY, textBoxWidth, textBoxHeight, Qt::AlignCenter, tr("BPM"));
+	brush.drawText(188, bottomTextY, textBoxWidth, textBoxHeight, Qt::AlignCenter, tr("Snap"));
 }
 
 } // namespace gui
diff --git a/plugins/SlicerT/SlicerTView.h b/plugins/SlicerT/SlicerTView.h
index 71dcad46976..64be819c845 100644
--- a/plugins/SlicerT/SlicerTView.h
+++ b/plugins/SlicerT/SlicerTView.h
@@ -42,19 +42,6 @@ class SlicerT;
 
 namespace gui {
 
-// style knob, defined in data/themes/default/style.css#L949
-class SlicerTKnob : public Knob
-{
-public:
-	SlicerTKnob(QWidget* _parent)
-		: Knob(KnobType::Styled, _parent)
-	{
-		setFixedSize(50, 40);
-		setCenterPointX(24.0);
-		setCenterPointY(15.0);
-	}
-};
-
 class SlicerTView : public InstrumentViewFixedSize
 {
 	Q_OBJECT
@@ -65,6 +52,11 @@ protected slots:
 public:
 	SlicerTView(SlicerT* instrument, QWidget* parent);
 
+	static constexpr int textBoxHeight = 20;
+	static constexpr int textBoxWidth = 50;
+	static constexpr int topTextY = 170;
+	static constexpr int bottomTextY = 220;
+
 protected:
 	virtual void dragEnterEvent(QDragEnterEvent* _dee);
 	virtual void dropEvent(QDropEvent* _de);
@@ -75,17 +67,19 @@ protected slots:
 	SlicerT* m_slicerTParent;
 
 	// lmms UI
-	SlicerTKnob m_noteThresholdKnob;
-	SlicerTKnob m_fadeOutKnob;
+	Knob* m_noteThresholdKnob;
+	Knob* m_fadeOutKnob;
 	LcdSpinBox m_bpmBox;
 	ComboBox m_snapSetting;
 	LedCheckBox m_syncToggle;
 
 	// buttons
-	PixmapButton m_resetButton;
-	PixmapButton m_midiExportButton;
+	QPushButton m_resetButton;
+	QPushButton m_midiExportButton;
 
 	SlicerTWaveform m_wf;
+
+	Knob* createStyledKnob();
 };
 } // namespace gui
 } // namespace lmms
diff --git a/plugins/SlicerT/SlicerTWaveform.cpp b/plugins/SlicerT/SlicerTWaveform.cpp
index 9a4fc61a6e7..506a5e494bc 100644
--- a/plugins/SlicerT/SlicerTWaveform.cpp
+++ b/plugins/SlicerT/SlicerTWaveform.cpp
@@ -81,6 +81,11 @@ void SlicerTWaveform::drawSeekerWaveform()
 
 	m_slicerTParent->m_originalSample.visualize(brush, QRect(0, 0, m_seekerWaveform.width(), m_seekerWaveform.height()),
 		0, m_slicerTParent->m_originalSample.frames());
+
+	// increase brightness in inner color
+	QBitmap innerMask = m_seekerWaveform.createMaskFromColor(s_waveformMaskColor, Qt::MaskMode::MaskOutColor);
+	brush.setPen(s_waveformInnerColor);
+	brush.drawPixmap(0, 0, innerMask);
 }
 
 void SlicerTWaveform::drawSeeker()
@@ -139,6 +144,11 @@ void SlicerTWaveform::drawEditorWaveform()
 	float zoomOffset = (m_editorHeight - m_zoomLevel * m_editorHeight) / 2;
 	m_slicerTParent->m_originalSample.visualize(
 		brush, QRect(0, zoomOffset, m_editorWidth, m_zoomLevel * m_editorHeight), startFrame, endFrame);
+
+	// increase brightness in inner color
+	QBitmap innerMask = m_editorWaveform.createMaskFromColor(s_waveformMaskColor, Qt::MaskMode::MaskOutColor);
+	brush.setPen(s_waveformInnerColor);
+	brush.drawPixmap(0, 0, innerMask);
 }
 
 void SlicerTWaveform::drawEditor()
diff --git a/plugins/SlicerT/SlicerTWaveform.h b/plugins/SlicerT/SlicerTWaveform.h
index 4bbfe08b83b..0403cc46f0e 100644
--- a/plugins/SlicerT/SlicerTWaveform.h
+++ b/plugins/SlicerT/SlicerTWaveform.h
@@ -58,9 +58,11 @@ public slots:
 
 	// colors
 	const QColor s_emptyColor = QColor(0, 0, 0, 0);
-	
+
 	const QColor s_waveformColor = QColor(123, 49, 212);
 	const QColor s_waveformBgColor = QColor(255, 255, 255, 0);
+	const QColor s_waveformMaskColor = QColor(151, 65, 255); // update this if s_waveformColor changes
+	const QColor s_waveformInnerColor = QColor(183, 124, 255);
 
 	const QColor s_playColor = QColor(255, 255, 255, 200);
 	const QColor s_playHighlightColor = QColor(255, 255, 255, 70);
diff --git a/plugins/SlicerT/artwork.png b/plugins/SlicerT/artwork.png
index 76dfbc5c5cd0bdb45e5ee85051f7b2898bb3a1cc..e166273c705362e4e07b907a853492b138c566d8 100644
GIT binary patch
delta 13396
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

delta 13818
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%0DyB>zbkJ3^n!0x^W9FP<gh-Y9LkfcwWS?v
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


From b9e1605e10af162a9d76801cc7e069445a9df60e Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Sat, 4 Nov 2023 00:50:43 +0100
Subject: [PATCH 81/99] initial timeshift removing

---
 plugins/SlicerT/SlicerT.cpp | 65 +++++++++++++------------------------
 plugins/SlicerT/SlicerT.h   | 55 ++-----------------------------
 2 files changed, 25 insertions(+), 95 deletions(-)

diff --git a/plugins/SlicerT/SlicerT.cpp b/plugins/SlicerT/SlicerT.cpp
index 74c522caeca..0c8d6033627 100644
--- a/plugins/SlicerT/SlicerT.cpp
+++ b/plugins/SlicerT/SlicerT.cpp
@@ -60,9 +60,8 @@ SlicerT::SlicerT(InstrumentTrack* instrumentTrack)
 	, m_fadeOutFrames(400.0f, 0.0f, 8192.0f, 1.0f, this, tr("FadeOut"))
 	, m_originalBPM(1, 1, 999, this, tr("Original bpm"))
 	, m_sliceSnap(this, tr("Slice snap"))
-	, m_enableSync(true, this, tr("BPM sync"))
+	, m_enableSync(false, this, tr("BPM sync"))
 	, m_originalSample()
-	, m_phaseVocoder()
 	, m_parentTrack(instrumentTrack)
 {
 	m_sliceSnap.addItem("Off");
@@ -79,26 +78,32 @@ void SlicerT::playNote(NotePlayHandle* handle, sampleFrame* workingBuffer)
 {
 	if (m_originalSample.frames() < 2048) { return; }
 
-	if (!handle->m_pluginData)  {
-		handle->m_pluginData = src_new(SRC_SINC_MEDIUM_QUALITY, 2, nullptr);
-	}
-
 	// playback parameters
 	const int noteIndex = handle->key() - m_parentTrack->baseNote();
 	const int playedFrames = handle->totalFramesPlayed();
 	const fpp_t frames = handle->framesLeftForCurrentPeriod();
 	const f_cnt_t offset = handle->noteOffset();
 	const int bpm = Engine::getSong()->getTempo();
-	const float pitchRatio = pow(2, m_parentTrack->pitchModel()->value() / 1200);
-	const float inversePitchRatio = 1.0f / pitchRatio;
+	const float pitchRatio = 1 / pow(2, m_parentTrack->pitchModel()->value() / 1200);
 
 	// update scaling parameters
 	float speedRatio = static_cast<float>(m_originalBPM.value()) / bpm;
 	if (!m_enableSync.value()) { speedRatio = 1; } // disable timeshift
-	m_phaseVocoder.setScaleRatio(speedRatio);
-	speedRatio *= inversePitchRatio; // adjust for pitch bend
+	speedRatio *= pitchRatio; // adjust for pitch bend
+
+	int totalFrames = m_originalSample.frames() * speedRatio;
+	if (m_playBackBuffer.size() != totalFrames) {
+		m_playBackBuffer.resize(totalFrames);
+		SRC_DATA resampleRate;
+		resampleRate.data_in = (float*)m_originalSample.data();
+		resampleRate.data_out = (float*)m_playBackBuffer.data();
+		resampleRate.input_frames = m_originalSample.frames();
+		resampleRate.output_frames = totalFrames;
+		resampleRate.src_ratio = speedRatio;
+
+		src_simple(&resampleRate, SRC_LINEAR, 2);
+	}
 
-	int totalFrames = inversePitchRatio * m_phaseVocoder.frames(); // adjust frames played with regards to pitch
 	int sliceStart, sliceEnd;
 	if (noteIndex > m_slicePoints.size() - 2 || noteIndex < 0) // full sample if ouside range
 	{
@@ -118,31 +123,10 @@ void SlicerT::playNote(NotePlayHandle* handle, sampleFrame* workingBuffer)
 
 	if (noteFramesLeft > 0)
 	{
-		int framesToCopy = pitchRatio * frames + 1; // just in case
-		int framesIndex = pitchRatio * currentNoteFrame;
-		framesIndex = std::min(framesIndex, m_phaseVocoder.frames() - framesToCopy);
-
-		// load sample segmengt, with regards to pitch settings
-		std::vector<sampleFrame> prePitchBuffer(framesToCopy, {0.0f, 0.0f});
-		m_phaseVocoder.getFrames(prePitchBuffer.data(), framesIndex, framesToCopy);
-
-		// if pitch is changed, resample, else just copy
-		if (!typeInfo<float>::isEqual(pitchRatio, 1.0f))
-		{
-			SRC_DATA resamplerData;
-
-			resamplerData.data_in = (float*)prePitchBuffer.data();	   // wtf
-			resamplerData.data_out = (float*)(workingBuffer + offset); // wtf is this
-			resamplerData.input_frames = prePitchBuffer.size();
-			resamplerData.output_frames = frames;
-			resamplerData.src_ratio = inversePitchRatio;
-
-			src_process((SRC_STATE*)(handle->m_pluginData), &resamplerData);
-		}
-		else { std::copy_n(prePitchBuffer.data(), frames, workingBuffer + offset); }
+		std::copy_n(m_playBackBuffer.data() + currentNoteFrame, frames, workingBuffer + offset);
 
 		// exponential fade out, applyRelease kinda sucks
-		if (noteFramesLeft * pitchRatio < m_fadeOutFrames.value())
+		if (noteFramesLeft < m_fadeOutFrames.value())
 		{
 			for (int i = 0; i < frames; i++)
 			{
@@ -301,14 +285,13 @@ std::vector<Note> SlicerT::getMidi()
 
 	// update incase bpm changed
 	float speedRatio = static_cast<float>(m_originalBPM.value()) / Engine::getSong()->getTempo();
-	m_phaseVocoder.setScaleRatio(speedRatio);
 
 	// calculate how many "beats" are in the sample
 	float ticksPerBar = DefaultTicksPerBar;
 	float sampleRate = m_originalSample.sampleRate();
 	float bpm = Engine::getSong()->getTempo();
 	float samplesPerBeat = 60.0f / bpm * sampleRate;
-	float beats = m_phaseVocoder.frames() / samplesPerBeat;
+	float beats = m_originalSample.frames() * speedRatio / samplesPerBeat;
 
 	// calculate how many ticks in sample
 	float barsInSample = beats / Engine::getSong()->getTimeSigModel().getDenominator();
@@ -342,9 +325,8 @@ void SlicerT::updateFile(QString file)
 	findBPM();
 	findSlices();
 
-	float speedRatio = static_cast<float>(m_originalBPM.value()) / Engine::getSong()->getTempo();
-	m_phaseVocoder.loadSample(
-		m_originalSample.data(), m_originalSample.frames(), m_originalSample.sampleRate(), speedRatio);
+	m_playBackBuffer.resize(m_originalSample.frames());
+	std::copy_n(m_originalSample.data(), m_originalSample.frames(), m_playBackBuffer.data());
 
 	emit dataChanged();
 }
@@ -413,9 +395,8 @@ void SlicerT::loadSettings(const QDomElement& element)
 	m_originalBPM.loadSettings(element, "origBPM");
 
 	// create dynamic buffer
-	float speedRatio = static_cast<float>(m_originalBPM.value()) / Engine::getSong()->getTempo();
-	m_phaseVocoder.loadSample(
-		m_originalSample.data(), m_originalSample.frames(), m_originalSample.sampleRate(), speedRatio);
+	m_playBackBuffer.resize(m_originalSample.frames());
+	std::copy_n(m_originalSample.data(), m_originalSample.frames(), m_playBackBuffer.data());
 
 	emit dataChanged();
 }
diff --git a/plugins/SlicerT/SlicerT.h b/plugins/SlicerT/SlicerT.h
index 9ef393986d2..327808e6293 100644
--- a/plugins/SlicerT/SlicerT.h
+++ b/plugins/SlicerT/SlicerT.h
@@ -35,61 +35,10 @@
 #include "PhaseVocoder.h"
 #include "SampleBuffer.h"
 #include "SlicerTView.h"
+#include "lmms_basics.h"
 
 namespace lmms {
 
-// simple helper class that handles the different audio channels
-class DynamicPlaybackBuffer
-{
-public:
-	DynamicPlaybackBuffer()
-		: m_leftChannel()
-		, m_rightChannel()
-	{
-	}
-
-	void loadSample(const sampleFrame* inData, int frames, int sampleRate, float newRatio)
-	{
-		std::vector<float> leftData(frames, 0);
-		std::vector<float> rightData(frames, 0);
-		for (int i = 0; i < frames; i++)
-		{
-			leftData.at(i) = inData[i][0];
-			rightData.at(i) = inData[i][1];
-		}
-		m_leftChannel.loadData(std::move(leftData), sampleRate, newRatio);
-		m_rightChannel.loadData(std::move(rightData), sampleRate, newRatio);
-	}
-
-	void getFrames(sampleFrame* outData, int startFrame, int frames)
-	{
-		std::vector<float> leftOut(frames, 0); // not a huge performance issue
-		std::vector<float> rightOut(frames, 0);
-
-		m_leftChannel.getFrames(leftOut, startFrame, frames);
-		m_rightChannel.getFrames(rightOut, startFrame, frames);
-
-		for (int i = 0; i < frames; i++)
-		{
-			outData[i][0] = leftOut.at(i);
-			outData[i][1] = rightOut.at(i);
-		}
-	}
-
-	int frames() { return m_leftChannel.frames(); }
-	float scaleRatio() { return m_leftChannel.scaleRatio(); }
-
-	void setScaleRatio(float newRatio)
-	{
-		m_leftChannel.setScaleRatio(newRatio);
-		m_rightChannel.setScaleRatio(newRatio);
-	}
-
-private:
-	PhaseVocoder m_leftChannel;
-	PhaseVocoder m_rightChannel;
-};
-
 class SlicerT : public Instrument
 {
 	Q_OBJECT
@@ -127,7 +76,7 @@ public slots:
 
 	// sample buffers
 	SampleBuffer m_originalSample;
-	DynamicPlaybackBuffer m_phaseVocoder;
+	std::vector<sampleFrame> m_playBackBuffer;
 
 	SRC_STATE* m_resamplerState;
 

From b23f2dc68ab5d8a8554148234785ec9ce70a34e1 Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Sat, 4 Nov 2023 14:50:02 +0100
Subject: [PATCH 82/99] Remove timeshift + slice refactor

---
 plugins/SlicerT/SlicerT.cpp         | 106 +++++++++++++---------------
 plugins/SlicerT/SlicerT.h           |  23 ++++--
 plugins/SlicerT/SlicerTWaveform.cpp |  23 +++---
 3 files changed, 79 insertions(+), 73 deletions(-)

diff --git a/plugins/SlicerT/SlicerT.cpp b/plugins/SlicerT/SlicerT.cpp
index 0c8d6033627..95cd8eccce5 100644
--- a/plugins/SlicerT/SlicerT.cpp
+++ b/plugins/SlicerT/SlicerT.cpp
@@ -80,52 +80,56 @@ void SlicerT::playNote(NotePlayHandle* handle, sampleFrame* workingBuffer)
 
 	// playback parameters
 	const int noteIndex = handle->key() - m_parentTrack->baseNote();
-	const int playedFrames = handle->totalFramesPlayed();
 	const fpp_t frames = handle->framesLeftForCurrentPeriod();
 	const f_cnt_t offset = handle->noteOffset();
 	const int bpm = Engine::getSong()->getTempo();
 	const float pitchRatio = 1 / pow(2, m_parentTrack->pitchModel()->value() / 1200);
 
-	// update scaling parameters
+	// update sync parameter
 	float speedRatio = static_cast<float>(m_originalBPM.value()) / bpm;
 	if (!m_enableSync.value()) { speedRatio = 1; } // disable timeshift
-	speedRatio *= pitchRatio; // adjust for pitch bend
-
-	int totalFrames = m_originalSample.frames() * speedRatio;
-	if (m_playBackBuffer.size() != totalFrames) {
-		m_playBackBuffer.resize(totalFrames);
-		SRC_DATA resampleRate;
-		resampleRate.data_in = (float*)m_originalSample.data();
-		resampleRate.data_out = (float*)m_playBackBuffer.data();
-		resampleRate.input_frames = m_originalSample.frames();
-		resampleRate.output_frames = totalFrames;
-		resampleRate.src_ratio = speedRatio;
-
-		src_simple(&resampleRate, SRC_LINEAR, 2);
-	}
+	speedRatio *= pitchRatio;					   // adjust for pitch bend
 
-	int sliceStart, sliceEnd;
+	// set start and end points
+	float sliceStart, sliceEnd;
 	if (noteIndex > m_slicePoints.size() - 2 || noteIndex < 0) // full sample if ouside range
 	{
 		sliceStart = 0;
-		sliceEnd = totalFrames;
+		sliceEnd = 1;
 	}
 	else
 	{
-		sliceStart = m_slicePoints[noteIndex] * speedRatio;
-		sliceEnd = m_slicePoints[noteIndex + 1] * speedRatio;
+		sliceStart = m_slicePoints[noteIndex];
+		sliceEnd = m_slicePoints[noteIndex + 1];
 	}
 
+	// initliazize handle
+	if (!handle->m_pluginData) { handle->m_pluginData = new PlayBackState(sliceStart); }
+
 	// slice vars
-	int sliceFrames = sliceEnd - sliceStart;
-	int currentNoteFrame = sliceStart + playedFrames;
-	int noteFramesLeft = sliceFrames - playedFrames;
+	float noteDone = ((PlayBackState*)handle->m_pluginData)->getNoteDone();
+	float noteLeft = sliceEnd - noteDone;
 
-	if (noteFramesLeft > 0)
+	if (noteLeft > 0)
 	{
-		std::copy_n(m_playBackBuffer.data() + currentNoteFrame, frames, workingBuffer + offset);
+		// resample in chunks
+		int noteFrame = noteDone * m_originalSample.frames();
+
+		SRC_STATE* resampleState = ((PlayBackState*)handle->m_pluginData)->getResampleState();
+		SRC_DATA resampleData;
+		resampleData.data_in = (float*)(m_originalSample.data() + noteFrame);
+		resampleData.data_out = (float*)(workingBuffer + offset);
+		resampleData.input_frames = noteLeft * m_originalSample.frames();
+		resampleData.output_frames = frames;
+		resampleData.src_ratio = speedRatio;
+
+		src_process(resampleState, &resampleData);
+
+		float nextNoteDone = noteDone + frames * (1.0f / speedRatio) / m_originalSample.frames();
+		((PlayBackState*)handle->m_pluginData)->setNoteDone(nextNoteDone);
 
 		// exponential fade out, applyRelease kinda sucks
+		int noteFramesLeft = noteLeft * m_originalSample.frames();
 		if (noteFramesLeft < m_fadeOutFrames.value())
 		{
 			for (int i = 0; i < frames; i++)
@@ -142,11 +146,7 @@ void SlicerT::playNote(NotePlayHandle* handle, sampleFrame* workingBuffer)
 
 		instrumentTrack()->processAudioBuffer(workingBuffer, frames + offset, handle);
 
-		// calculate absolute for the SlicerTWaveform
-		float absoluteCurrentNote = static_cast<float>(currentNoteFrame) / totalFrames;
-		float absoluteStartNote = static_cast<float>(sliceStart) / totalFrames;
-		float abslouteEndNote = static_cast<float>(sliceEnd) / totalFrames;
-		emit isPlaying(absoluteCurrentNote, absoluteStartNote, abslouteEndNote);
+		emit isPlaying(noteDone, sliceStart, sliceEnd);
 	}
 	else { emit isPlaying(-1, 0, 0); }
 }
@@ -227,24 +227,30 @@ void SlicerT::findSlices()
 	m_slicePoints.push_back(m_originalSample.frames());
 
 	// snap slices to notes
+	float beatsPerMin = m_originalBPM.value() / 60.0f;
+	float samplesPerBeat = m_originalSample.sampleRate() / beatsPerMin * 4.0f;
 	int noteSnap = m_sliceSnap.value();
-	int timeSignature = Engine::getSong()->getTimeSigModel().getNumerator();
-	int samplesPerBar = 60.0f * timeSignature / m_originalBPM.value() * m_originalSample.sampleRate();
-	int sliceLock = samplesPerBar / std::pow(2, noteSnap + 1); // lock to note: 1 / noteSnap²
-	if (noteSnap == 0) { sliceLock = 1; }				  // disable noteSnap
+	int sliceLock = samplesPerBeat / std::pow(2, noteSnap + 1); // lock to note: 1 / noteSnap²
+	if (noteSnap == 0) { sliceLock = 1; }						// disable noteSnap
 
 	for (int i = 0; i < m_slicePoints.size(); i++)
 	{
 		m_slicePoints[i] += sliceLock / 2;
-		m_slicePoints[i] -= m_slicePoints[i] % sliceLock;
+		m_slicePoints[i] -= static_cast<int>(m_slicePoints[i]) % sliceLock;
 	}
 
 	// remove duplicates
 	m_slicePoints.erase(std::unique(m_slicePoints.begin(), m_slicePoints.end()), m_slicePoints.end());
 
+	// scale between 0 and 1
+	for (float& sliceIndex : m_slicePoints)
+	{
+		sliceIndex /= m_originalSample.frames();
+	}
+
 	// fit to sample size
 	m_slicePoints[0] = 0;
-	m_slicePoints[m_slicePoints.size() - 1] = m_originalSample.frames();
+	m_slicePoints[m_slicePoints.size() - 1] = 1;
 
 	// update UI
 	emit dataChanged();
@@ -283,27 +289,18 @@ std::vector<Note> SlicerT::getMidi()
 {
 	std::vector<Note> outputNotes;
 
-	// update incase bpm changed
 	float speedRatio = static_cast<float>(m_originalBPM.value()) / Engine::getSong()->getTempo();
+	float outFrames = m_originalSample.frames() * speedRatio;
 
-	// calculate how many "beats" are in the sample
-	float ticksPerBar = DefaultTicksPerBar;
-	float sampleRate = m_originalSample.sampleRate();
-	float bpm = Engine::getSong()->getTempo();
-	float samplesPerBeat = 60.0f / bpm * sampleRate;
-	float beats = m_originalSample.frames() * speedRatio / samplesPerBeat;
-
-	// calculate how many ticks in sample
-	float barsInSample = beats / Engine::getSong()->getTimeSigModel().getDenominator();
-	float totalTicks = ticksPerBar * barsInSample;
-
+	float framesPerTick = Engine::framesPerTick();
+	float totalTicks = outFrames / framesPerTick;
 	float lastEnd = 0;
 
 	// write to midi
 	for (int i = 0; i < m_slicePoints.size() - 1; i++)
 	{
 		float sliceStart = lastEnd;
-		float sliceEnd = totalTicks * m_slicePoints[i + 1] / m_originalSample.frames();
+		float sliceEnd = totalTicks * m_slicePoints[i + 1];
 
 		Note sliceNote = Note();
 		sliceNote.setKey(i + m_parentTrack->baseNote());
@@ -325,9 +322,6 @@ void SlicerT::updateFile(QString file)
 	findBPM();
 	findSlices();
 
-	m_playBackBuffer.resize(m_originalSample.frames());
-	std::copy_n(m_originalSample.data(), m_originalSample.frames(), m_playBackBuffer.data());
-
 	emit dataChanged();
 }
 
@@ -357,6 +351,7 @@ void SlicerT::saveSettings(QDomDocument& document, QDomElement& element)
 	m_fadeOutFrames.saveSettings(document, element, "fadeOut");
 	m_noteThreshold.saveSettings(document, element, "threshold");
 	m_originalBPM.saveSettings(document, element, "origBPM");
+	m_enableSync.saveSettings(document, element, "syncEnable");
 }
 
 void SlicerT::loadSettings(const QDomElement& element)
@@ -385,7 +380,7 @@ void SlicerT::loadSettings(const QDomElement& element)
 		m_slicePoints = {};
 		for (int i = 0; i < totalSlices; i++)
 		{
-			m_slicePoints.push_back(element.attribute(tr("slice_%1").arg(i)).toInt());
+			m_slicePoints.push_back(element.attribute(tr("slice_%1").arg(i)).toFloat());
 		}
 	}
 
@@ -393,10 +388,7 @@ void SlicerT::loadSettings(const QDomElement& element)
 	m_fadeOutFrames.loadSettings(element, "fadeOut");
 	m_noteThreshold.loadSettings(element, "threshold");
 	m_originalBPM.loadSettings(element, "origBPM");
-
-	// create dynamic buffer
-	m_playBackBuffer.resize(m_originalSample.frames());
-	std::copy_n(m_originalSample.data(), m_originalSample.frames(), m_playBackBuffer.data());
+	m_enableSync.loadSettings(element, "syncEnable");
 
 	emit dataChanged();
 }
diff --git a/plugins/SlicerT/SlicerT.h b/plugins/SlicerT/SlicerT.h
index 327808e6293..5ed3367f4f6 100644
--- a/plugins/SlicerT/SlicerT.h
+++ b/plugins/SlicerT/SlicerT.h
@@ -39,6 +39,24 @@
 
 namespace lmms {
 
+class PlayBackState
+{
+public:
+	PlayBackState(float startFrame)
+		: currentNote(startFrame)
+	{
+		resamplingState = src_new(SRC_LINEAR, 2, nullptr);
+	}
+	~PlayBackState() { src_delete(resamplingState); }
+	float getNoteDone() { return currentNote; }
+	void setNoteDone(float newDone) { currentNote = newDone; }
+	SRC_STATE* getResampleState() { return resamplingState; }
+
+private:
+	float currentNote; // these are all absoute floats
+	SRC_STATE* resamplingState;
+};
+
 class SlicerT : public Instrument
 {
 	Q_OBJECT
@@ -76,11 +94,8 @@ public slots:
 
 	// sample buffers
 	SampleBuffer m_originalSample;
-	std::vector<sampleFrame> m_playBackBuffer;
-
-	SRC_STATE* m_resamplerState;
 
-	std::vector<int> m_slicePoints;
+	std::vector<float> m_slicePoints;
 
 	InstrumentTrack* m_parentTrack;
 
diff --git a/plugins/SlicerT/SlicerTWaveform.cpp b/plugins/SlicerT/SlicerTWaveform.cpp
index 506a5e494bc..edd92948864 100644
--- a/plugins/SlicerT/SlicerTWaveform.cpp
+++ b/plugins/SlicerT/SlicerTWaveform.cpp
@@ -99,7 +99,7 @@ void SlicerTWaveform::drawSeeker()
 	for (int i = 0; i < m_slicerTParent->m_slicePoints.size(); i++)
 	{
 		float xPos = static_cast<float>(m_slicerTParent->m_slicePoints.at(i))
-			/ m_slicerTParent->m_originalSample.frames() * m_seekerWidth;
+			 * m_seekerWidth;
 		brush.drawLine(xPos, 0, xPos, m_seekerHeight);
 	}
 
@@ -170,9 +170,8 @@ void SlicerTWaveform::drawEditor()
 	}
 
 	// editor boundaries
-	float totalFrames = m_slicerTParent->m_originalSample.frames();
-	float startFrame = m_seekerStart * totalFrames;
-	float endFrame = m_seekerEnd * totalFrames;
+	float startFrame = m_seekerStart;
+	float endFrame = m_seekerEnd;
 	float numFramesToDraw = endFrame - startFrame;
 
 	// playback state
@@ -263,12 +262,12 @@ void SlicerTWaveform::updateClosest(QMouseEvent* me)
 	else // editor click
 	{
 		m_closestSlice = -1;
-		float startFrame = m_seekerStart * m_slicerTParent->m_originalSample.frames();
-		float endFrame = m_seekerEnd * m_slicerTParent->m_originalSample.frames();
+		float startFrame = m_seekerStart;
+		float endFrame = m_seekerEnd;
 		// select slice
 		for (int i = 0; i < m_slicerTParent->m_slicePoints.size(); i++)
 		{
-			int sliceIndex = m_slicerTParent->m_slicePoints.at(i);
+			float sliceIndex = m_slicerTParent->m_slicePoints.at(i);
 			float xPos = (sliceIndex - startFrame) / (endFrame - startFrame);
 
 			if (std::abs(xPos - normalizedClickEditor) < s_distanceForClick)
@@ -348,8 +347,8 @@ void SlicerTWaveform::mouseMoveEvent(QMouseEvent* me)
 
 	float distStart = m_seekerStart - m_seekerMiddle;
 	float distEnd = m_seekerEnd - m_seekerMiddle;
-	float startFrame = m_seekerStart * m_slicerTParent->m_originalSample.frames();
-	float endFrame = m_seekerEnd * m_slicerTParent->m_originalSample.frames();
+	float startFrame = m_seekerStart;
+	float endFrame = m_seekerEnd;
 
 	// handle dragging events
 	switch (m_closestObject)
@@ -377,7 +376,7 @@ void SlicerTWaveform::mouseMoveEvent(QMouseEvent* me)
 		m_slicerTParent->m_slicePoints.at(m_closestSlice)
 			= startFrame + normalizedClickEditor * (endFrame - startFrame);
 		m_slicerTParent->m_slicePoints.at(m_closestSlice) = std::clamp(
-			m_slicerTParent->m_slicePoints.at(m_closestSlice), 0, m_slicerTParent->m_originalSample.frames());
+			m_slicerTParent->m_slicePoints.at(m_closestSlice), 0.0f, 1.0f);
 		break;
 	case UIObjects::Nothing:
 		break;
@@ -392,8 +391,8 @@ void SlicerTWaveform::mouseDoubleClickEvent(QMouseEvent* me)
 	if (me->button() != Qt::MouseButton::LeftButton) { return; }
 
 	float normalizedClickEditor = static_cast<float>(me->x()) / m_editorWidth;
-	float startFrame = m_seekerStart * m_slicerTParent->m_originalSample.frames();
-	float endFrame = m_seekerEnd * m_slicerTParent->m_originalSample.frames();
+	float startFrame = m_seekerStart;
+	float endFrame = m_seekerEnd;
 	float slicePosition = startFrame + normalizedClickEditor * (endFrame - startFrame);
 
 	m_slicerTParent->m_slicePoints.insert(m_slicerTParent->m_slicePoints.begin(), slicePosition);

From 33c08f320f87ba56a6ea688500a5e0655e49fd2b Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Sat, 4 Nov 2023 15:23:54 +0100
Subject: [PATCH 83/99] Removed unused files

---
 include/PhaseVocoder.h                        | 108 -------
 plugins/SlicerT/SlicerT.h                     |   1 -
 plugins/SlicerT/SlicerTWaveform.cpp           |   2 +-
 plugins/SlicerT/artwork.xcf                   | Bin 92565 -> 0 bytes
 plugins/SlicerT/logo.png                      | Bin 11243 -> 0 bytes
 ...or_arrow.png => slice_indicator_arrow.png} | Bin
 src/core/CMakeLists.txt                       |   1 -
 src/core/PhaseVocoder.cpp                     | 273 ------------------
 8 files changed, 1 insertion(+), 384 deletions(-)
 delete mode 100644 include/PhaseVocoder.h
 delete mode 100644 plugins/SlicerT/artwork.xcf
 delete mode 100644 plugins/SlicerT/logo.png
 rename plugins/SlicerT/{slide_indicator_arrow.png => slice_indicator_arrow.png} (100%)
 delete mode 100644 src/core/PhaseVocoder.cpp

diff --git a/include/PhaseVocoder.h b/include/PhaseVocoder.h
deleted file mode 100644
index 13a41421b93..00000000000
--- a/include/PhaseVocoder.h
+++ /dev/null
@@ -1,108 +0,0 @@
-/*
- * PhaseVocoder.h - declaration of the PhaseVocoder class
- *
- * Copyright (c) 2023 Daniel Kauss Serna <daniel.kauss.serna@gmail.com>
- *
- * 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_PHASEVOCODER_H
-#define LMMS_PHASEVOCODER_H
-
-#include <QMutex>
-#include <array>
-#include <fftw3.h>
-#include <cmath>
-#include <vector>
-
-#include "lmms_export.h"
-
-namespace lmms {
-
-/**
-	Dynamically timeshifts one audio channel by a changable ratio
-	Allows access to the timeshifted data in a threadsafe and realtime maner
-*/
-class LMMS_EXPORT PhaseVocoder
-{
-public:
-	PhaseVocoder();
-	~PhaseVocoder();
-
-	//! Loads a new sample, and precomputes the analysis cache
-	void loadData(const std::vector<float>& originalData, int sampleRate, float newRatio);
-	//! Change the output timeshift ratio
-	void setScaleRatio(float newRatio) { updateParams(newRatio); }
-
-	//! Copy a number of frames from a startpoint into an out buffer.
-	//! This is NOT relative to the original sample
-	void getFrames(std::vector<float>& outData, int start, int frames);
-
-	//! Get total number of frames for the timeshifted sample, NOT the original
-	int frames() { return m_processedBuffer.size(); }
-	//! Get the current scaleRatio
-	float scaleRatio() { return m_scaleRatio; }
-
-	// timeshift config
-	static const int s_windowSize = 512;
-	static const int s_overSampling = 32;
-
-private:
-	QMutex m_dataLock;
-	// original data
-	std::vector<float> m_originalBuffer;
-	int m_originalSampleRate = 0;
-
-	float m_scaleRatio = -1; // to force on first load
-
-	// output data
-	std::vector<float> m_processedBuffer; // final output
-	std::vector<bool> m_processedWindows; // marks a window processed
-
-	// depending on scaleRatio
-	int m_stepSize = 0;
-	int m_numWindows = 0;
-	float m_outStepSize = 0;
-	float m_freqPerBin = 0;
-	float m_expectedPhaseIn = 0;
-	float m_expectedPhaseOut = 0;
-
-	// buffers
-	std::array<fftwf_complex, s_windowSize> m_FFTSpectrum;
-	std::vector<float> m_FFTInput;
-	std::vector<float> m_IFFTReconstruction;
-	std::vector<float> m_allMagnitudes;
-	std::vector<float> m_allFrequencies;
-	std::vector<float> m_processedFreq;
-	std::vector<float> m_processedMagn;
-	std::vector<float> m_lastPhase;
-	std::vector<float> m_sumPhase;
-
-	// cache
-	std::vector<float> m_freqCache;
-	std::vector<float> m_magCache;
-
-	// fftw plans
-	fftwf_plan m_fftPlan;
-	fftwf_plan m_ifftPlan;
-
-	void updateParams(float newRatio);
-	void generateWindow(int windowNum, bool useCache);
-};
-} // namespace lmms
-#endif // LMMS_PHASEVOCODER_H
diff --git a/plugins/SlicerT/SlicerT.h b/plugins/SlicerT/SlicerT.h
index 5ed3367f4f6..4acdfee1b35 100644
--- a/plugins/SlicerT/SlicerT.h
+++ b/plugins/SlicerT/SlicerT.h
@@ -32,7 +32,6 @@
 #include "Instrument.h"
 #include "InstrumentView.h"
 #include "Note.h"
-#include "PhaseVocoder.h"
 #include "SampleBuffer.h"
 #include "SlicerTView.h"
 #include "lmms_basics.h"
diff --git a/plugins/SlicerT/SlicerTWaveform.cpp b/plugins/SlicerT/SlicerTWaveform.cpp
index edd92948864..e01e3902575 100644
--- a/plugins/SlicerT/SlicerTWaveform.cpp
+++ b/plugins/SlicerT/SlicerTWaveform.cpp
@@ -44,7 +44,7 @@ SlicerTWaveform::SlicerTWaveform(int w, int h, SlicerT* instrument, QWidget* par
 	, m_editorWidth(w)
 
 	// create pixmaps
-	, m_sliceArrow(PLUGIN_NAME::getIconPixmap("slide_indicator_arrow"))
+	, m_sliceArrow(PLUGIN_NAME::getIconPixmap("slice_indicator_arrow"))
 	, m_seeker(QPixmap(m_seekerWidth, m_seekerHeight))
 	, m_seekerWaveform(QPixmap(m_seekerWidth, m_seekerHeight))
 	, m_editorWaveform(QPixmap(m_editorWidth, m_editorHeight))
diff --git a/plugins/SlicerT/artwork.xcf b/plugins/SlicerT/artwork.xcf
deleted file mode 100644
index 63cd2e12f50071c764f3f15005df8b9d7ff18497..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 92565
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

diff --git a/plugins/SlicerT/logo.png b/plugins/SlicerT/logo.png
deleted file mode 100644
index 08eb67b128186b67fcc509ee7f55d803bfc0b992..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 11243
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

diff --git a/plugins/SlicerT/slide_indicator_arrow.png b/plugins/SlicerT/slice_indicator_arrow.png
similarity index 100%
rename from plugins/SlicerT/slide_indicator_arrow.png
rename to plugins/SlicerT/slice_indicator_arrow.png
diff --git a/src/core/CMakeLists.txt b/src/core/CMakeLists.txt
index b72ab0565c5..319882af2f9 100644
--- a/src/core/CMakeLists.txt
+++ b/src/core/CMakeLists.txt
@@ -53,7 +53,6 @@ set(LMMS_SRCS
 	core/PatternStore.cpp
 	core/PeakController.cpp
 	core/PerfLog.cpp
-	core/PhaseVocoder.cpp
 	core/Piano.cpp
 	core/PlayHandle.cpp
 	core/Plugin.cpp
diff --git a/src/core/PhaseVocoder.cpp b/src/core/PhaseVocoder.cpp
deleted file mode 100644
index 06e91288381..00000000000
--- a/src/core/PhaseVocoder.cpp
+++ /dev/null
@@ -1,273 +0,0 @@
-/*
- * PhaseVocoder.cpp - Implementation of the PhaseVocoder class
- *
- * Copyright (c) 2023 Daniel Kauss Serna <daniel.kauss.serna@gmail.com>
- *
- * 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 "PhaseVocoder.h"
-
-#include <algorithm>
-#include <cstdio>
-#include <fftw3.h>
-#include <math.h>
-#include <typeinfo>
-
-#include "lmms_basics.h"
-#include "lmms_constants.h"
-
-namespace lmms {
-
-PhaseVocoder::PhaseVocoder()
-	: m_FFTInput(s_windowSize, 0)
-	, m_IFFTReconstruction(s_windowSize, 0)
-	, m_allMagnitudes(s_windowSize, 0)
-	, m_allFrequencies(s_windowSize, 0)
-	, m_processedFreq(s_windowSize, 0)
-	, m_processedMagn(s_windowSize, 0)
-{
-	m_fftPlan = fftwf_plan_dft_r2c_1d(s_windowSize, m_FFTInput.data(), m_FFTSpectrum.data(), FFTW_MEASURE);
-	m_ifftPlan = fftwf_plan_dft_c2r_1d(s_windowSize, m_FFTSpectrum.data(), m_IFFTReconstruction.data(), FFTW_MEASURE);
-}
-
-PhaseVocoder::~PhaseVocoder()
-{
-	fftwf_destroy_plan(m_fftPlan);
-	fftwf_destroy_plan(m_ifftPlan);
-}
-
-void PhaseVocoder::loadData(const std::vector<float>& originalData, int sampleRate, float newRatio)
-{
-	m_dataLock.lock();
-
-	m_originalBuffer = std::move(originalData);
-	m_originalSampleRate = sampleRate;
-	m_scaleRatio = -1; // force update, kinda hacky
-
-	m_dataLock.unlock(); // stupid, but QRecursiveMutex is too expensive to have in updateParas and getFrames
-	updateParams(newRatio);
-	m_dataLock.lock();
-
-	// set buffer sizes
-	m_processedWindows.resize(m_numWindows, false);
-	m_lastPhase.resize(m_numWindows * s_windowSize, 0);
-	m_sumPhase.resize((m_numWindows + 1) * s_windowSize, 0);
-	m_freqCache.resize(m_numWindows * s_windowSize, 0);
-	m_magCache.resize(m_numWindows * s_windowSize, 0);
-
-	// clear phase buffers
-	std::fill(m_lastPhase.begin(), m_lastPhase.end(), 0);
-	std::fill(m_sumPhase.begin(), m_sumPhase.end(), 0);
-
-	// maybe limit this to a set amount of windows to reduce initial lag spikes
-	for (int i = 0; i < m_numWindows; i++)
-	{
-		if (!m_processedWindows.at(i))
-		{
-			generateWindow(i, false); // first pass, no cache
-			m_processedWindows.at(i) = true;
-		}
-	}
-
-	m_dataLock.unlock();
-}
-
-void PhaseVocoder::getFrames(std::vector<float>& outData, int start, int frames)
-{
-	if (m_originalBuffer.size() < 2048) { return; }
-	m_dataLock.lock();
-
-	if (typeInfo<float>::isEqual(m_scaleRatio, 1.0f))
-	{ // directly copy original data
-		std::copy_n(m_originalBuffer.data() + start, frames, outData.data());
-		m_dataLock.unlock();
-		return;
-	}
-
-	int windowMargin = s_overSampling / 2; // numbers of windows before full quality
-	int startWindow = static_cast<float>(start) / m_outStepSize - windowMargin;
-	int endWindow = static_cast<float>((start + frames)) / m_outStepSize + windowMargin;
-
-	startWindow = std::clamp(startWindow, 0, m_numWindows - 1);
-	endWindow = std::clamp(endWindow, 0, m_numWindows - 1);
-
-	// discard previous phaseSum if not processed
-	if (!m_processedWindows[startWindow])
-	{
-		std::fill_n(m_sumPhase.data() + startWindow * s_windowSize, s_windowSize, 0);
-	}
-
-	// this encompases the minimum windows needed to get full quality,
-	// which must be computed
-	for (int i = startWindow; i < endWindow; i++)
-	{
-		if (!m_processedWindows.at(i))
-		{
-			generateWindow(i, true); // theses should use the cache
-			m_processedWindows.at(i) = true;
-		}
-	}
-
-	for (int i = 0; i < frames; i++)
-	{
-		outData.at(i) = m_processedBuffer[start + i];
-	}
-
-	m_dataLock.unlock();
-}
-
-// adjust pv params buffers to a new scale ratio
-void PhaseVocoder::updateParams(float newRatio)
-{
-	if (m_originalBuffer.size() < 2048) { return; }
-	if (newRatio == m_scaleRatio) { return; } // nothing changed
-	m_dataLock.lock();
-
-	m_scaleRatio = newRatio;
-	m_stepSize = static_cast<float>(s_windowSize) / s_overSampling;
-	m_numWindows = static_cast<float>(m_originalBuffer.size()) / m_stepSize - s_overSampling - 1;
-	m_outStepSize = m_scaleRatio * m_stepSize; // float, else inaccurate
-	m_freqPerBin = m_originalSampleRate / s_windowSize;
-	m_expectedPhaseIn = 2. * F_PI * m_stepSize / s_windowSize;
-	m_expectedPhaseOut = 2. * F_PI * m_outStepSize / s_windowSize;
-
-	m_processedBuffer.resize(m_numWindows * m_outStepSize + s_windowSize, 0);
-
-	// very slow :(
-	std::fill(m_processedWindows.begin(), m_processedWindows.end(), false);
-	std::fill(m_processedBuffer.begin(), m_processedBuffer.end(), 0);
-
-	m_dataLock.unlock();
-}
-
-// time shifts one window from originalBuffer and writes to m_processedBuffer
-// resources:
-// http://blogs.zynaptiq.com/bernsee/pitch-shifting-using-the-ft/
-// https://sethares.engr.wisc.edu/vocoders/phasevocoder.html
-// https://dsp.stackexchange.com/questions/40101/audio-time-stretching-without-pitch-shifting/40367#40367
-// https://www.guitarpitchshifter.com/
-// https://en.wikipedia.org/wiki/Window_function
-void PhaseVocoder::generateWindow(int windowNum, bool useCache)
-{
-	// declare vars
-	float real, imag, phase, magnitude, freq, deltaPhase;
-	int windowStart = static_cast<float>(windowNum) * m_stepSize;
-	int windowIndex = static_cast<float>(windowNum) * s_windowSize;
-
-	if (!useCache)
-	{ // normal stuff
-		std::copy_n(m_originalBuffer.data() + windowStart, s_windowSize, m_FFTInput.data());
-
-		// FFT
-		fftwf_execute(m_fftPlan);
-
-		// analysis step
-		for (int j = 0; j < s_windowSize / 2; j++) // only process nyquistic frequency
-		{
-			real = m_FFTSpectrum.at(j)[0];
-			imag = m_FFTSpectrum.at(j)[1];
-
-			magnitude = 2. * std::sqrt(real * real + imag * imag);
-			phase = std::atan2(imag, real);
-
-			// calculate difference in phase with prev window
-			freq = phase;
-			freq = phase - m_lastPhase.at(std::max(0, windowIndex + j - s_windowSize)); // subtract prev pahse to get phase
-																					 // diference
-			m_lastPhase.at(windowIndex + j) = phase;
-
-			freq -= m_expectedPhaseIn * j; // subtract expected phase
-			// at this point, freq is the difference in phase
-			// between the last phase, having removed the expected phase at this point in the sample
-
-			// this puts freq in 0-2pi. Since the phase difference is proportional to the deviation in bin frequency,
-			// with this we can better estimate the true frequency
-			freq = std::fmod(freq + F_PI, -2.0f * F_PI) + F_PI;
-
-			// convert phase difference into bin freq mulitplier
-			freq = freq * s_overSampling / (2. * F_PI);
-
-			// add to the expected freq the change in freq calculated from the phase diff
-			freq = m_freqPerBin * j + m_freqPerBin * freq;
-
-			m_allMagnitudes.at(j) = magnitude;
-			m_allFrequencies.at(j) = freq;
-		}
-		// write cache
-		std::copy_n(m_allFrequencies.data(), s_windowSize, m_freqCache.data() + windowIndex);
-		std::copy_n(m_allMagnitudes.data(), s_windowSize, m_magCache.data() + windowIndex);
-	}
-	else
-	{
-		// read cache
-		std::copy_n(m_freqCache.data() + windowIndex, s_windowSize, m_allFrequencies.data());
-		std::copy_n(m_magCache.data() + windowIndex, s_windowSize, m_allMagnitudes.data());
-	}
-
-	// synthesis, all the operations are the reverse of the analysis
-	for (int j = 0; j < s_windowSize / 2; j++)
-	{
-		magnitude = m_allMagnitudes.at(j);
-		freq = m_allFrequencies.at(j);
-
-		// difference to bin freq mulitplier
-		deltaPhase = freq - m_freqPerBin * j;
-
-		// convert to phase difference
-		deltaPhase /= m_freqPerBin;
-
-		// difference in phase
-		deltaPhase = 2. * F_PI * deltaPhase / s_overSampling;
-
-		// add the expected phase
-		deltaPhase += m_expectedPhaseOut * j;
-
-		// sum this phase to the total, to keep track of the out phase along the sample
-		m_sumPhase.at(windowIndex + j) += deltaPhase;
-		deltaPhase = m_sumPhase.at(windowIndex + j); // final bin phase
-
-		m_sumPhase.at(windowIndex + j + s_windowSize) = deltaPhase; // copy to the next
-
-		m_FFTSpectrum.at(j)[0] = magnitude * std::cos(deltaPhase);
-		m_FFTSpectrum.at(j)[1] = magnitude * std::sin(deltaPhase);
-	}
-
-	// inverse fft
-	fftwf_execute(m_ifftPlan);
-
-	// windowing
-	for (int j = 0; j < s_windowSize; j++)
-	{
-		float outIndex = windowNum * m_outStepSize + j;
-
-		// blackman-harris window
-		float a0 = 0.35875f;
-		float a1 = 0.48829f;
-		float a2 = 0.14128f;
-		float a3 = 0.01168f;
-
-		float piN2 = 2.0f * F_PI * j;
-		float window
-			= a0 - (a1 * std::cos(piN2 / s_windowSize)) + (a2 * std::cos(2.0f * piN2 / s_windowSize)) - (a3 * std::cos(3.0f * piN2));
-
-		// inverse fft magnitudes are windowsSize times bigger
-		m_processedBuffer.at(outIndex) += window * (m_IFFTReconstruction.at(j) / s_windowSize / s_overSampling);
-	}
-}
-} // namespace lmms

From efde89d90fe09bc5a0dd891fc2027749ee49b61e Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Sat, 4 Nov 2023 15:36:11 +0100
Subject: [PATCH 84/99] Fix export bug

---
 plugins/SlicerT/SlicerT.cpp | 1 +
 plugins/SlicerT/SlicerT.h   | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/plugins/SlicerT/SlicerT.cpp b/plugins/SlicerT/SlicerT.cpp
index 95cd8eccce5..adac39c7295 100644
--- a/plugins/SlicerT/SlicerT.cpp
+++ b/plugins/SlicerT/SlicerT.cpp
@@ -89,6 +89,7 @@ void SlicerT::playNote(NotePlayHandle* handle, sampleFrame* workingBuffer)
 	float speedRatio = static_cast<float>(m_originalBPM.value()) / bpm;
 	if (!m_enableSync.value()) { speedRatio = 1; } // disable timeshift
 	speedRatio *= pitchRatio;					   // adjust for pitch bend
+	speedRatio *= Engine::audioEngine()->processingSampleRate() / static_cast<float>(m_originalSample.sampleRate()) ;
 
 	// set start and end points
 	float sliceStart, sliceEnd;
diff --git a/plugins/SlicerT/SlicerT.h b/plugins/SlicerT/SlicerT.h
index 4acdfee1b35..902f7cda34c 100644
--- a/plugins/SlicerT/SlicerT.h
+++ b/plugins/SlicerT/SlicerT.h
@@ -44,7 +44,7 @@ class PlayBackState
 	PlayBackState(float startFrame)
 		: currentNote(startFrame)
 	{
-		resamplingState = src_new(SRC_LINEAR, 2, nullptr);
+		resamplingState = src_new(SRC_SINC_MEDIUM_QUALITY, 2, nullptr);
 	}
 	~PlayBackState() { src_delete(resamplingState); }
 	float getNoteDone() { return currentNote; }

From adb81481dc6d2ace3faee72bc69f9c3ac9834b32 Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Sat, 4 Nov 2023 15:53:20 +0100
Subject: [PATCH 85/99] Fix zoom bug

---
 plugins/SlicerT/SlicerTWaveform.cpp | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/plugins/SlicerT/SlicerTWaveform.cpp b/plugins/SlicerT/SlicerTWaveform.cpp
index e01e3902575..15f42497a5e 100644
--- a/plugins/SlicerT/SlicerTWaveform.cpp
+++ b/plugins/SlicerT/SlicerTWaveform.cpp
@@ -404,8 +404,7 @@ void SlicerTWaveform::wheelEvent(QWheelEvent* _we)
 	m_zoomLevel += _we->angleDelta().y() / 360.0f * s_zoomSensitivity;
 	m_zoomLevel = std::max(0.0f, m_zoomLevel);
 
-	drawEditor();
-	update();
+	updateUI();
 }
 
 void SlicerTWaveform::paintEvent(QPaintEvent* pe)

From a4ab2b478e0ea36e505c6f8ad637f389724d9ce1 Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Sun, 5 Nov 2023 03:02:37 +0100
Subject: [PATCH 86/99] Review changes SakerTooth#2

---
 plugins/SlicerT/SlicerT.cpp         | 21 +++++------
 plugins/SlicerT/SlicerT.h           |  2 +-
 plugins/SlicerT/SlicerTView.cpp     | 57 ++++++++++++++--------------
 plugins/SlicerT/SlicerTView.h       | 12 +++---
 plugins/SlicerT/SlicerTWaveform.cpp | 58 ++++++++++++++---------------
 plugins/SlicerT/SlicerTWaveform.h   |  2 +-
 6 files changed, 74 insertions(+), 78 deletions(-)

diff --git a/plugins/SlicerT/SlicerT.cpp b/plugins/SlicerT/SlicerT.cpp
index adac39c7295..ad44cf7a0f7 100644
--- a/plugins/SlicerT/SlicerT.cpp
+++ b/plugins/SlicerT/SlicerT.cpp
@@ -26,7 +26,7 @@
 
 #include <QDomElement>
 #include <fftw3.h>
-#include <math.h>
+#include <cmath>
 
 #include "Engine.h"
 #include "InstrumentTrack.h"
@@ -76,7 +76,7 @@ SlicerT::SlicerT(InstrumentTrack* instrumentTrack)
 
 void SlicerT::playNote(NotePlayHandle* handle, sampleFrame* workingBuffer)
 {
-	if (m_originalSample.frames() < 2048) { return; }
+	if (m_originalSample.frames() <= 1) { return; }
 
 	// playback parameters
 	const int noteIndex = handle->key() - m_parentTrack->baseNote();
@@ -89,7 +89,7 @@ void SlicerT::playNote(NotePlayHandle* handle, sampleFrame* workingBuffer)
 	float speedRatio = static_cast<float>(m_originalBPM.value()) / bpm;
 	if (!m_enableSync.value()) { speedRatio = 1; } // disable timeshift
 	speedRatio *= pitchRatio;					   // adjust for pitch bend
-	speedRatio *= Engine::audioEngine()->processingSampleRate() / static_cast<float>(m_originalSample.sampleRate()) ;
+	speedRatio *= Engine::audioEngine()->processingSampleRate() / static_cast<float>(m_originalSample.sampleRate());
 
 	// set start and end points
 	float sliceStart, sliceEnd;
@@ -157,7 +157,7 @@ void SlicerT::playNote(NotePlayHandle* handle, sampleFrame* workingBuffer)
 // http://www.iro.umontreal.ca/~pift6080/H09/documents/papers/bello_onset_tutorial.pdf
 void SlicerT::findSlices()
 {
-	if (m_originalSample.frames() < 2048) { return; }
+	if (m_originalSample.frames() <= 1) { return; }
 	m_slicePoints = {};
 
 	// computacion params
@@ -177,9 +177,9 @@ void SlicerT::findSlices()
 	}
 
 	// normalize
-	for (int i = 0; i < singleChannel.size(); i++)
+	for (float& channelValue : singleChannel)
 	{
-		singleChannel[i] /= maxMag;
+		channelValue /= maxMag;
 	}
 
 	// buffers
@@ -234,10 +234,10 @@ void SlicerT::findSlices()
 	int sliceLock = samplesPerBeat / std::pow(2, noteSnap + 1); // lock to note: 1 / noteSnap²
 	if (noteSnap == 0) { sliceLock = 1; }						// disable noteSnap
 
-	for (int i = 0; i < m_slicePoints.size(); i++)
+	for (float& sliceValue : m_slicePoints)
 	{
-		m_slicePoints[i] += sliceLock / 2;
-		m_slicePoints[i] -= static_cast<int>(m_slicePoints[i]) % sliceLock;
+		sliceValue += sliceLock / 2;
+		sliceValue -= static_cast<int>(sliceValue) % sliceLock;
 	}
 
 	// remove duplicates
@@ -261,7 +261,7 @@ void SlicerT::findSlices()
 // and lies in the 100 - 200 bpm range
 void SlicerT::findBPM()
 {
-	if (m_originalSample.frames() < 2048) { return; }
+	if (m_originalSample.frames() <= 1) { return; }
 
 	// caclulate length of sample
 	float sampleRate = m_originalSample.sampleRate();
@@ -318,7 +318,6 @@ std::vector<Note> SlicerT::getMidi()
 void SlicerT::updateFile(QString file)
 {
 	m_originalSample.setAudioFile(file);
-	if (m_originalSample.frames() < 2048) { return; }
 
 	findBPM();
 	findSlices();
diff --git a/plugins/SlicerT/SlicerT.h b/plugins/SlicerT/SlicerT.h
index 902f7cda34c..c2ca265555a 100644
--- a/plugins/SlicerT/SlicerT.h
+++ b/plugins/SlicerT/SlicerT.h
@@ -43,8 +43,8 @@ class PlayBackState
 public:
 	PlayBackState(float startFrame)
 		: currentNote(startFrame)
+		, resamplingState(src_new(SRC_LINEAR, 2, nullptr))
 	{
-		resamplingState = src_new(SRC_SINC_MEDIUM_QUALITY, 2, nullptr);
 	}
 	~PlayBackState() { src_delete(resamplingState); }
 	float getNoteDone() { return currentNote; }
diff --git a/plugins/SlicerT/SlicerTView.cpp b/plugins/SlicerT/SlicerTView.cpp
index b61092bead8..350f0f5ff70 100644
--- a/plugins/SlicerT/SlicerTView.cpp
+++ b/plugins/SlicerT/SlicerTView.cpp
@@ -44,12 +44,6 @@ namespace gui {
 SlicerTView::SlicerTView(SlicerT* instrument, QWidget* parent)
 	: InstrumentViewFixedSize(instrument, parent)
 	, m_slicerTParent(instrument)
-	, m_bpmBox(3, "19purple", this)
-	, m_snapSetting(this, tr("Slice snap"))
-	, m_syncToggle("Sync", this, tr("SyncToggle"), LedCheckBox::LedColor::Green)
-	, m_resetButton(this)
-	, m_midiExportButton(this)
-	, m_wf(248, 128, instrument, this)
 {
 	// window settings
 	setAcceptDrops(true);
@@ -61,23 +55,26 @@ SlicerTView::SlicerTView(SlicerT* instrument, QWidget* parent)
 	setPalette(pal);
 
 	// move editor and seeker
-	m_wf.move(2, 6);
+	m_wf = new SlicerTWaveform(248, 128, instrument, this);
+	m_wf->move(2, 6);
 
 	// snap combo box
-	m_snapSetting.setGeometry(185, 200, 55, ComboBox::DEFAULT_HEIGHT);
-	m_snapSetting.setToolTip(tr("Set slice snapping for detection"));
-	m_snapSetting.setModel(&m_slicerTParent->m_sliceSnap);
+	m_snapSetting = new ComboBox(this, tr("Slice snap"));
+	m_snapSetting->setGeometry(185, 200, 55, ComboBox::DEFAULT_HEIGHT);
+	m_snapSetting->setToolTip(tr("Set slice snapping for detection"));
+	m_snapSetting->setModel(&m_slicerTParent->m_sliceSnap);
 
 	// sync toggle
-	m_syncToggle.move(135, 187);
-	m_syncToggle.setToolTip(tr("Enable BPM sync"));
-	m_syncToggle.setModel(&m_slicerTParent->m_enableSync);
+	m_syncToggle = new LedCheckBox("Sync", this, tr("SyncToggle"), LedCheckBox::LedColor::Green);
+	m_syncToggle->move(135, 187);
+	m_syncToggle->setToolTip(tr("Enable BPM sync"));
+	m_syncToggle->setModel(&m_slicerTParent->m_enableSync);
 
 	// bpm spin box
-	m_bpmBox.move(130, 201);
-	m_bpmBox.setToolTip(tr("Original sample BPM"));
-	/* m_bpmBox.setLabel(tr("BPM")); */
-	m_bpmBox.setModel(&m_slicerTParent->m_originalBPM);
+	m_bpmBox = new LcdSpinBox(3, "19purple", this);
+	m_bpmBox->move(130, 201);
+	m_bpmBox->setToolTip(tr("Original sample BPM"));
+	m_bpmBox->setModel(&m_slicerTParent->m_originalBPM);
 
 	// threshold knob
 	m_noteThresholdKnob = createStyledKnob();
@@ -94,19 +91,20 @@ SlicerTView::SlicerTView(SlicerT* instrument, QWidget* parent)
 	m_fadeOutKnob->setModel(&m_slicerTParent->m_fadeOutFrames);
 
 	// midi copy button
-	m_midiExportButton.move(199, 150);
-	m_midiExportButton.setIcon(PLUGIN_NAME::getIconPixmap("copyMidi"));
-	m_midiExportButton.setToolTip(tr("Copy midi pattern to clipboard"));
-	connect(&m_midiExportButton, &PixmapButton::clicked, this, &SlicerTView::exportMidi);
+	m_midiExportButton = new QPushButton(this);
+	m_midiExportButton->move(199, 150);
+	m_midiExportButton->setIcon(PLUGIN_NAME::getIconPixmap("copyMidi"));
+	m_midiExportButton->setToolTip(tr("Copy midi pattern to clipboard"));
+	connect(m_midiExportButton, &PixmapButton::clicked, this, &SlicerTView::exportMidi);
 
 	// slice reset button
-	m_resetButton.move(18, 150);
-	m_resetButton.setIcon(PLUGIN_NAME::getIconPixmap("resetSlices"));
-	m_resetButton.setToolTip(tr("Reset Slices"));
-	connect(&m_resetButton, &PixmapButton::clicked, m_slicerTParent, &SlicerT::updateSlices);
+	m_resetButton = new QPushButton(this);
+	m_resetButton->move(18, 150);
+	m_resetButton->setIcon(PLUGIN_NAME::getIconPixmap("resetSlices"));
+	m_resetButton->setToolTip(tr("Reset Slices"));
+	connect(m_resetButton, &PixmapButton::clicked, m_slicerTParent, &SlicerT::updateSlices);
 }
 
-// style knob, defined in data/themes/default/style.css#L949
 Knob* SlicerTView::createStyledKnob()
 {
 	Knob* newKnob = new Knob(KnobType::Styled, this);
@@ -120,7 +118,7 @@ Knob* SlicerTView::createStyledKnob()
 void SlicerTView::exportMidi()
 {
 	using namespace Clipboard;
-	if (m_slicerTParent->m_originalSample.frames() < 2048) { return; }
+	if (m_slicerTParent->m_originalSample.frames() <= 1) { return; }
 
 	DataFile dataFile(DataFile::Type::ClipboardData);
 	QDomElement note_list = dataFile.createElement("note-list");
@@ -132,9 +130,8 @@ void SlicerTView::exportMidi()
 	TimePos start_pos(notes.front().pos().getBar(), 0);
 	for (Note note : notes)
 	{
-		Note clip_note(note);
-		clip_note.setPos(clip_note.pos(start_pos));
-		clip_note.saveState(dataFile, note_list);
+		note.setPos(note.pos(start_pos));
+		note.saveState(dataFile, note_list);
 	}
 
 	copyString(dataFile.toString(), MimeType::Default);
diff --git a/plugins/SlicerT/SlicerTView.h b/plugins/SlicerT/SlicerTView.h
index 64be819c845..b1b1d4158d2 100644
--- a/plugins/SlicerT/SlicerTView.h
+++ b/plugins/SlicerT/SlicerTView.h
@@ -69,15 +69,15 @@ protected slots:
 	// lmms UI
 	Knob* m_noteThresholdKnob;
 	Knob* m_fadeOutKnob;
-	LcdSpinBox m_bpmBox;
-	ComboBox m_snapSetting;
-	LedCheckBox m_syncToggle;
+	LcdSpinBox* m_bpmBox;
+	ComboBox* m_snapSetting;
+	LedCheckBox* m_syncToggle;
 
 	// buttons
-	QPushButton m_resetButton;
-	QPushButton m_midiExportButton;
+	QPushButton* m_resetButton;
+	QPushButton* m_midiExportButton;
 
-	SlicerTWaveform m_wf;
+	SlicerTWaveform* m_wf;
 
 	Knob* createStyledKnob();
 };
diff --git a/plugins/SlicerT/SlicerTWaveform.cpp b/plugins/SlicerT/SlicerTWaveform.cpp
index 15f42497a5e..2a8823e3048 100644
--- a/plugins/SlicerT/SlicerTWaveform.cpp
+++ b/plugins/SlicerT/SlicerTWaveform.cpp
@@ -34,22 +34,22 @@ namespace lmms {
 
 namespace gui {
 
-SlicerTWaveform::SlicerTWaveform(int w, int h, SlicerT* instrument, QWidget* parent)
+SlicerTWaveform::SlicerTWaveform(int totalWidth, int totalHeight, SlicerT* instrument, QWidget* parent)
 	: QWidget(parent)
 	// calculate sizes
-	, m_width(w)
-	, m_height(h)
-	, m_seekerWidth(w - m_seekerHorMargin * 2)
-	, m_editorHeight(h - m_seekerHeight - m_middleMargin)
-	, m_editorWidth(w)
+	, m_width(totalWidth)
+	, m_height(totalHeight)
+	, m_seekerWidth(totalWidth - m_seekerHorMargin * 2)
+	, m_editorHeight(totalHeight - m_seekerHeight - m_middleMargin)
+	, m_editorWidth(totalWidth)
 
 	// create pixmaps
 	, m_sliceArrow(PLUGIN_NAME::getIconPixmap("slice_indicator_arrow"))
 	, m_seeker(QPixmap(m_seekerWidth, m_seekerHeight))
 	, m_seekerWaveform(QPixmap(m_seekerWidth, m_seekerHeight))
 	, m_editorWaveform(QPixmap(m_editorWidth, m_editorHeight))
-	, m_sliceEditor(QPixmap(w, m_editorHeight))
-	, m_emptySampleIcon(embed::getIconPixmap("sample_track.png"))
+	, m_sliceEditor(QPixmap(totalWidth, m_editorHeight))
+	, m_emptySampleIcon(embed::getIconPixmap("sample_track"))
 
 	// references to instrument vars
 	, m_slicerTParent(instrument)
@@ -75,7 +75,7 @@ SlicerTWaveform::SlicerTWaveform(int w, int h, SlicerT* instrument, QWidget* par
 void SlicerTWaveform::drawSeekerWaveform()
 {
 	m_seekerWaveform.fill(s_waveformBgColor);
-	if (m_slicerTParent->m_originalSample.frames() < 2048) { return; }
+	if (m_slicerTParent->m_originalSample.frames() <= 1) { return; }
 	QPainter brush(&m_seekerWaveform);
 	brush.setPen(s_waveformColor);
 
@@ -91,15 +91,14 @@ void SlicerTWaveform::drawSeekerWaveform()
 void SlicerTWaveform::drawSeeker()
 {
 	m_seeker.fill(s_emptyColor);
-	if (m_slicerTParent->m_originalSample.frames() < 2048) { return; }
+	if (m_slicerTParent->m_originalSample.frames() <= 1) { return; }
 	QPainter brush(&m_seeker);
 
 	// draw slice points
 	brush.setPen(s_sliceColor);
-	for (int i = 0; i < m_slicerTParent->m_slicePoints.size(); i++)
+	for (float sliceValue: m_slicerTParent->m_slicePoints)
 	{
-		float xPos = static_cast<float>(m_slicerTParent->m_slicePoints.at(i))
-			 * m_seekerWidth;
+		float xPos = sliceValue * m_seekerWidth;
 		brush.drawLine(xPos, 0, xPos, m_seekerHeight);
 	}
 
@@ -133,7 +132,7 @@ void SlicerTWaveform::drawSeeker()
 void SlicerTWaveform::drawEditorWaveform()
 {
 	m_editorWaveform.fill(s_emptyColor);
-	if (m_slicerTParent->m_originalSample.frames() < 2048) { return; }
+	if (m_slicerTParent->m_originalSample.frames() <= 1) { return; }
 
 	// draw SlicerTWaveform
 	QPainter brush(&m_editorWaveform);
@@ -157,7 +156,7 @@ void SlicerTWaveform::drawEditor()
 	QPainter brush(&m_sliceEditor);
 
 	// draw text if no sample loaded
-	if (m_slicerTParent->m_originalSample.frames() < 2048)
+	if (m_slicerTParent->m_originalSample.frames() <= 1)
 	{
 		brush.setPen(s_playHighlightColor);
 		brush.setFont(QFont(brush.font().family(), 9.0f, -1, false));
@@ -301,25 +300,26 @@ void SlicerTWaveform::mousePressEvent(QMouseEvent* me)
 	/* updateClosest(me); */
 
 	// reset seeker on middle click
-	if (me->button() == Qt::MouseButton::MiddleButton)
+	switch (me->button())
 	{
+	case Qt::MouseButton::MiddleButton:
 		m_seekerStart = 0;
 		m_seekerEnd = 1;
 		m_zoomLevel = 1;
-		return;
-	}
-
-	if (me->button() == Qt::MouseButton::LeftButton)
-	{
+		break;
+	case Qt::MouseButton::LeftButton:
 		// update seeker middle for correct movement
 		m_seekerMiddle = static_cast<float>(me->x() - m_seekerHorMargin) / m_seekerWidth;
-	}
-
+		break;
 	// delete closesd slice to mouse
-	if (me->button() == Qt::MouseButton::RightButton && m_slicerTParent->m_slicePoints.size() > 2
-		&& m_closestObject == UIObjects::SlicePoint)
-	{
-		m_slicerTParent->m_slicePoints.erase(m_slicerTParent->m_slicePoints.begin() + m_closestSlice);
+	case Qt::MouseButton::RightButton:
+		if (m_slicerTParent->m_slicePoints.size() > 2 && m_closestObject == UIObjects::SlicePoint)
+		{
+			m_slicerTParent->m_slicePoints.erase(m_slicerTParent->m_slicePoints.begin() + m_closestSlice);
+		}
+		break;
+	default:
+		;	
 	}
 	updateClosest(me);
 }
@@ -375,8 +375,8 @@ void SlicerTWaveform::mouseMoveEvent(QMouseEvent* me)
 		if (m_closestSlice == -1) { break; }
 		m_slicerTParent->m_slicePoints.at(m_closestSlice)
 			= startFrame + normalizedClickEditor * (endFrame - startFrame);
-		m_slicerTParent->m_slicePoints.at(m_closestSlice) = std::clamp(
-			m_slicerTParent->m_slicePoints.at(m_closestSlice), 0.0f, 1.0f);
+		m_slicerTParent->m_slicePoints.at(m_closestSlice)
+			= std::clamp(m_slicerTParent->m_slicePoints.at(m_closestSlice), 0.0f, 1.0f);
 		break;
 	case UIObjects::Nothing:
 		break;
diff --git a/plugins/SlicerT/SlicerTWaveform.h b/plugins/SlicerT/SlicerTWaveform.h
index 0403cc46f0e..7643dee1b85 100644
--- a/plugins/SlicerT/SlicerTWaveform.h
+++ b/plugins/SlicerT/SlicerTWaveform.h
@@ -49,7 +49,7 @@ public slots:
 	void isPlaying(float current, float start, float end);
 
 public:
-	SlicerTWaveform(int w, int h, SlicerT* instrument, QWidget* parent);
+	SlicerTWaveform(int totalWidth, int totalHeight, SlicerT* instrument, QWidget* parent);
 
 	// predefined sizes
 	static constexpr int m_seekerHorMargin = 5;

From 4a2236be5b98f076f768595246b1697fc5b3c602 Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Sun, 5 Nov 2023 13:02:53 +0100
Subject: [PATCH 87/99] Remove most comments

---
 plugins/SlicerT/SlicerT.cpp         | 45 ++++-----------------
 plugins/SlicerT/SlicerT.h           |  4 +-
 plugins/SlicerT/SlicerTView.cpp     | 13 ------
 plugins/SlicerT/SlicerTView.h       |  4 +-
 plugins/SlicerT/SlicerTWaveform.cpp | 62 ++++++++++++-----------------
 plugins/SlicerT/SlicerTWaveform.h   | 30 +-------------
 6 files changed, 36 insertions(+), 122 deletions(-)

diff --git a/plugins/SlicerT/SlicerT.cpp b/plugins/SlicerT/SlicerT.cpp
index ad44cf7a0f7..b2819e58dff 100644
--- a/plugins/SlicerT/SlicerT.cpp
+++ b/plugins/SlicerT/SlicerT.cpp
@@ -25,8 +25,8 @@
 #include "SlicerT.h"
 
 #include <QDomElement>
-#include <fftw3.h>
 #include <cmath>
+#include <fftw3.h>
 
 #include "Engine.h"
 #include "InstrumentTrack.h"
@@ -71,27 +71,24 @@ SlicerT::SlicerT(InstrumentTrack* instrumentTrack)
 	m_sliceSnap.addItem("1/8");
 	m_sliceSnap.addItem("1/16");
 	m_sliceSnap.addItem("1/32");
-	m_sliceSnap.setValue(0); // no snap by default
+	m_sliceSnap.setValue(0);
 }
 
 void SlicerT::playNote(NotePlayHandle* handle, sampleFrame* workingBuffer)
 {
 	if (m_originalSample.frames() <= 1) { return; }
 
-	// playback parameters
 	const int noteIndex = handle->key() - m_parentTrack->baseNote();
 	const fpp_t frames = handle->framesLeftForCurrentPeriod();
 	const f_cnt_t offset = handle->noteOffset();
 	const int bpm = Engine::getSong()->getTempo();
 	const float pitchRatio = 1 / pow(2, m_parentTrack->pitchModel()->value() / 1200);
 
-	// update sync parameter
 	float speedRatio = static_cast<float>(m_originalBPM.value()) / bpm;
-	if (!m_enableSync.value()) { speedRatio = 1; } // disable timeshift
-	speedRatio *= pitchRatio;					   // adjust for pitch bend
+	if (!m_enableSync.value()) { speedRatio = 1; }
+	speedRatio *= pitchRatio;
 	speedRatio *= Engine::audioEngine()->processingSampleRate() / static_cast<float>(m_originalSample.sampleRate());
 
-	// set start and end points
 	float sliceStart, sliceEnd;
 	if (noteIndex > m_slicePoints.size() - 2 || noteIndex < 0) // full sample if ouside range
 	{
@@ -104,16 +101,13 @@ void SlicerT::playNote(NotePlayHandle* handle, sampleFrame* workingBuffer)
 		sliceEnd = m_slicePoints[noteIndex + 1];
 	}
 
-	// initliazize handle
 	if (!handle->m_pluginData) { handle->m_pluginData = new PlayBackState(sliceStart); }
 
-	// slice vars
 	float noteDone = ((PlayBackState*)handle->m_pluginData)->getNoteDone();
 	float noteLeft = sliceEnd - noteDone;
 
 	if (noteLeft > 0)
 	{
-		// resample in chunks
 		int noteFrame = noteDone * m_originalSample.frames();
 
 		SRC_STATE* resampleState = ((PlayBackState*)handle->m_pluginData)->getResampleState();
@@ -129,14 +123,13 @@ void SlicerT::playNote(NotePlayHandle* handle, sampleFrame* workingBuffer)
 		float nextNoteDone = noteDone + frames * (1.0f / speedRatio) / m_originalSample.frames();
 		((PlayBackState*)handle->m_pluginData)->setNoteDone(nextNoteDone);
 
-		// exponential fade out, applyRelease kinda sucks
+		// exponential fade out, applyRelease() not used since it extends the note length
 		int noteFramesLeft = noteLeft * m_originalSample.frames();
 		if (noteFramesLeft < m_fadeOutFrames.value())
 		{
 			for (int i = 0; i < frames; i++)
 			{
 				float fadeValue = static_cast<float>(noteFramesLeft - i) / m_fadeOutFrames.value();
-				// if the workingbuffer extends the sample
 				fadeValue = std::clamp(fadeValue, 0.0f, 1.0f);
 				fadeValue = std::pow(fadeValue, 2);
 
@@ -160,14 +153,12 @@ void SlicerT::findSlices()
 	if (m_originalSample.frames() <= 1) { return; }
 	m_slicePoints = {};
 
-	// computacion params
 	const int windowSize = 512;
 	const float minBeatLength = 0.05f; // in seconds, ~ 1/4 length at 220 bpm
 
 	int sampleRate = m_originalSample.sampleRate();
 	int minDist = sampleRate * minBeatLength;
 
-	// copy vector into one vector, averaging channels
 	float maxMag = -1;
 	std::vector<float> singleChannel(m_originalSample.frames(), 0);
 	for (int i = 0; i < m_originalSample.frames(); i++)
@@ -176,13 +167,11 @@ void SlicerT::findSlices()
 		maxMag = std::max(maxMag, singleChannel[i]);
 	}
 
-	// normalize
 	for (float& channelValue : singleChannel)
 	{
 		channelValue /= maxMag;
 	}
 
-	// buffers
 	std::vector<float> prevMags(windowSize / 2, 0);
 	std::vector<float> fftIn(windowSize, 0);
 	std::array<fftwf_complex, windowSize> fftOut;
@@ -214,7 +203,6 @@ void SlicerT::findSlices()
 			prevMags[j] = magnitude;
 		}
 
-		// detect increases in flux
 		if (spectralFlux / prevFlux > 1.0f + m_noteThreshold.value() && i - lastPoint > minDist)
 		{
 			m_slicePoints.push_back(i);
@@ -227,33 +215,27 @@ void SlicerT::findSlices()
 
 	m_slicePoints.push_back(m_originalSample.frames());
 
-	// snap slices to notes
 	float beatsPerMin = m_originalBPM.value() / 60.0f;
 	float samplesPerBeat = m_originalSample.sampleRate() / beatsPerMin * 4.0f;
 	int noteSnap = m_sliceSnap.value();
-	int sliceLock = samplesPerBeat / std::pow(2, noteSnap + 1); // lock to note: 1 / noteSnap²
-	if (noteSnap == 0) { sliceLock = 1; }						// disable noteSnap
-
+	int sliceLock = samplesPerBeat / std::pow(2, noteSnap + 1);
+	if (noteSnap == 0) { sliceLock = 1; }
 	for (float& sliceValue : m_slicePoints)
 	{
 		sliceValue += sliceLock / 2;
 		sliceValue -= static_cast<int>(sliceValue) % sliceLock;
 	}
 
-	// remove duplicates
 	m_slicePoints.erase(std::unique(m_slicePoints.begin(), m_slicePoints.end()), m_slicePoints.end());
 
-	// scale between 0 and 1
 	for (float& sliceIndex : m_slicePoints)
 	{
 		sliceIndex /= m_originalSample.frames();
 	}
 
-	// fit to sample size
 	m_slicePoints[0] = 0;
 	m_slicePoints[m_slicePoints.size() - 1] = 1;
 
-	// update UI
 	emit dataChanged();
 }
 
@@ -263,15 +245,12 @@ void SlicerT::findBPM()
 {
 	if (m_originalSample.frames() <= 1) { return; }
 
-	// caclulate length of sample
 	float sampleRate = m_originalSample.sampleRate();
 	float totalFrames = m_originalSample.frames();
 	float sampleLength = totalFrames / sampleRate;
 
-	// this assumes the sample has a time signature of x/4
 	float bpmEstimate = 240.0f / sampleLength;
 
-	// get into 100 - 200 range
 	while (bpmEstimate < 100)
 	{
 		bpmEstimate *= 2;
@@ -297,7 +276,6 @@ std::vector<Note> SlicerT::getMidi()
 	float totalTicks = outFrames / framesPerTick;
 	float lastEnd = 0;
 
-	// write to midi
 	for (int i = 0; i < m_slicePoints.size() - 1; i++)
 	{
 		float sliceStart = lastEnd;
@@ -306,7 +284,7 @@ std::vector<Note> SlicerT::getMidi()
 		Note sliceNote = Note();
 		sliceNote.setKey(i + m_parentTrack->baseNote());
 		sliceNote.setPos(sliceStart);
-		sliceNote.setLength(sliceEnd - sliceStart + 1); // + 1 needed for whatever reason
+		sliceNote.setLength(sliceEnd - sliceStart + 1); // + 1 so that the notes allign
 		outputNotes.push_back(sliceNote);
 
 		lastEnd = sliceEnd;
@@ -332,7 +310,6 @@ void SlicerT::updateSlices()
 
 void SlicerT::saveSettings(QDomDocument& document, QDomElement& element)
 {
-	// save sample
 	element.setAttribute("src", m_originalSample.audioFile());
 	if (m_originalSample.audioFile().isEmpty())
 	{
@@ -340,14 +317,12 @@ void SlicerT::saveSettings(QDomDocument& document, QDomElement& element)
 		element.setAttribute("sampledata", m_originalSample.toBase64(s));
 	}
 
-	// save slice points
 	element.setAttribute("totalSlices", static_cast<int>(m_slicePoints.size()));
 	for (int i = 0; i < m_slicePoints.size(); i++)
 	{
 		element.setAttribute(tr("slice_%1").arg(i), m_slicePoints[i]);
 	}
 
-	// save knobs
 	m_fadeOutFrames.saveSettings(document, element, "fadeOut");
 	m_noteThreshold.saveSettings(document, element, "threshold");
 	m_originalBPM.saveSettings(document, element, "origBPM");
@@ -356,7 +331,6 @@ void SlicerT::saveSettings(QDomDocument& document, QDomElement& element)
 
 void SlicerT::loadSettings(const QDomElement& element)
 {
-	// load sample
 	if (!element.attribute("src").isEmpty())
 	{
 		m_originalSample.setAudioFile(element.attribute("src"));
@@ -373,7 +347,6 @@ void SlicerT::loadSettings(const QDomElement& element)
 		m_originalSample.loadFromBase64(element.attribute("srcdata"));
 	}
 
-	// load slices
 	if (!element.attribute("totalSlices").isEmpty())
 	{
 		int totalSlices = element.attribute("totalSlices").toInt();
@@ -384,7 +357,6 @@ void SlicerT::loadSettings(const QDomElement& element)
 		}
 	}
 
-	// load knobs
 	m_fadeOutFrames.loadSettings(element, "fadeOut");
 	m_noteThreshold.loadSettings(element, "threshold");
 	m_originalBPM.loadSettings(element, "origBPM");
@@ -404,7 +376,6 @@ gui::PluginView* SlicerT::instantiateView(QWidget* parent)
 }
 
 extern "C" {
-// necessary for getting instance out of shared lib
 PLUGIN_EXPORT Plugin* lmms_plugin_main(Model* m, void*)
 {
 	return new SlicerT(static_cast<InstrumentTrack*>(m));
diff --git a/plugins/SlicerT/SlicerT.h b/plugins/SlicerT/SlicerT.h
index c2ca265555a..771aa1da99e 100644
--- a/plugins/SlicerT/SlicerT.h
+++ b/plugins/SlicerT/SlicerT.h
@@ -52,7 +52,7 @@ class PlayBackState
 	SRC_STATE* getResampleState() { return resamplingState; }
 
 private:
-	float currentNote; // these are all absoute floats
+	float currentNote;
 	SRC_STATE* resamplingState;
 };
 
@@ -84,14 +84,12 @@ public slots:
 	std::vector<Note> getMidi();
 
 private:
-	// models
 	FloatModel m_noteThreshold;
 	FloatModel m_fadeOutFrames;
 	IntModel m_originalBPM;
 	ComboBoxModel m_sliceSnap;
 	BoolModel m_enableSync;
 
-	// sample buffers
 	SampleBuffer m_originalSample;
 
 	std::vector<float> m_slicePoints;
diff --git a/plugins/SlicerT/SlicerTView.cpp b/plugins/SlicerT/SlicerTView.cpp
index 350f0f5ff70..d18e32327cb 100644
--- a/plugins/SlicerT/SlicerTView.cpp
+++ b/plugins/SlicerT/SlicerTView.cpp
@@ -54,50 +54,40 @@ SlicerTView::SlicerTView(SlicerT* instrument, QWidget* parent)
 	pal.setBrush(backgroundRole(), PLUGIN_NAME::getIconPixmap("artwork"));
 	setPalette(pal);
 
-	// move editor and seeker
 	m_wf = new SlicerTWaveform(248, 128, instrument, this);
 	m_wf->move(2, 6);
 
-	// snap combo box
 	m_snapSetting = new ComboBox(this, tr("Slice snap"));
 	m_snapSetting->setGeometry(185, 200, 55, ComboBox::DEFAULT_HEIGHT);
 	m_snapSetting->setToolTip(tr("Set slice snapping for detection"));
 	m_snapSetting->setModel(&m_slicerTParent->m_sliceSnap);
 
-	// sync toggle
 	m_syncToggle = new LedCheckBox("Sync", this, tr("SyncToggle"), LedCheckBox::LedColor::Green);
 	m_syncToggle->move(135, 187);
 	m_syncToggle->setToolTip(tr("Enable BPM sync"));
 	m_syncToggle->setModel(&m_slicerTParent->m_enableSync);
 
-	// bpm spin box
 	m_bpmBox = new LcdSpinBox(3, "19purple", this);
 	m_bpmBox->move(130, 201);
 	m_bpmBox->setToolTip(tr("Original sample BPM"));
 	m_bpmBox->setModel(&m_slicerTParent->m_originalBPM);
 
-	// threshold knob
 	m_noteThresholdKnob = createStyledKnob();
 	m_noteThresholdKnob->move(10, 197);
 	m_noteThresholdKnob->setToolTip(tr("Threshold used for slicing"));
-	/* m_noteThresholdKnob->setLabel(tr("Threshold")); */
 	m_noteThresholdKnob->setModel(&m_slicerTParent->m_noteThreshold);
 
-	// fadeout knob
 	m_fadeOutKnob = createStyledKnob();
 	m_fadeOutKnob->move(64, 197);
 	m_fadeOutKnob->setToolTip(tr("Fade Out for notes"));
-	/* m_fadeOutKnob->setLabel(tr("Fade Out")); */
 	m_fadeOutKnob->setModel(&m_slicerTParent->m_fadeOutFrames);
 
-	// midi copy button
 	m_midiExportButton = new QPushButton(this);
 	m_midiExportButton->move(199, 150);
 	m_midiExportButton->setIcon(PLUGIN_NAME::getIconPixmap("copyMidi"));
 	m_midiExportButton->setToolTip(tr("Copy midi pattern to clipboard"));
 	connect(m_midiExportButton, &PixmapButton::clicked, this, &SlicerTView::exportMidi);
 
-	// slice reset button
 	m_resetButton = new QPushButton(this);
 	m_resetButton->move(18, 150);
 	m_resetButton->setIcon(PLUGIN_NAME::getIconPixmap("resetSlices"));
@@ -177,18 +167,15 @@ void SlicerTView::dropEvent(QDropEvent* de)
 	de->ignore();
 }
 
-// display button text
 void SlicerTView::paintEvent(QPaintEvent* pe)
 {
 	QPainter brush(this);
 	brush.setPen(QColor(255, 255, 255));
 	brush.setFont(QFont(brush.font().family(), 7, -1, false));
 
-	// top text
 	brush.drawText(8, topTextY, textBoxWidth, textBoxHeight, Qt::AlignCenter, tr("Reset"));
 	brush.drawText(188, topTextY, textBoxWidth, textBoxHeight, Qt::AlignCenter, tr("Midi"));
 
-	// bottom text
 	brush.drawText(8, bottomTextY, textBoxWidth, textBoxHeight, Qt::AlignCenter, tr("Threshold"));
 	brush.drawText(63, bottomTextY, textBoxWidth, textBoxHeight, Qt::AlignCenter, tr("Fade Out"));
 	brush.drawText(127, bottomTextY, textBoxWidth, textBoxHeight, Qt::AlignCenter, tr("BPM"));
diff --git a/plugins/SlicerT/SlicerTView.h b/plugins/SlicerT/SlicerTView.h
index b1b1d4158d2..690fc9a0e36 100644
--- a/plugins/SlicerT/SlicerTView.h
+++ b/plugins/SlicerT/SlicerTView.h
@@ -46,7 +46,7 @@ class SlicerTView : public InstrumentViewFixedSize
 {
 	Q_OBJECT
 
-protected slots:
+public slots:
 	void exportMidi();
 
 public:
@@ -66,14 +66,12 @@ protected slots:
 private:
 	SlicerT* m_slicerTParent;
 
-	// lmms UI
 	Knob* m_noteThresholdKnob;
 	Knob* m_fadeOutKnob;
 	LcdSpinBox* m_bpmBox;
 	ComboBox* m_snapSetting;
 	LedCheckBox* m_syncToggle;
 
-	// buttons
 	QPushButton* m_resetButton;
 	QPushButton* m_midiExportButton;
 
diff --git a/plugins/SlicerT/SlicerTWaveform.cpp b/plugins/SlicerT/SlicerTWaveform.cpp
index 2a8823e3048..a43aafc5917 100644
--- a/plugins/SlicerT/SlicerTWaveform.cpp
+++ b/plugins/SlicerT/SlicerTWaveform.cpp
@@ -34,39 +34,47 @@ namespace lmms {
 
 namespace gui {
 
+static QColor s_emptyColor = QColor(0, 0, 0, 0);
+static QColor s_waveformColor = QColor(123, 49, 212);
+static QColor s_waveformBgColor = QColor(255, 255, 255, 0);
+static QColor s_waveformMaskColor = QColor(151, 65, 255); // update this if s_waveformColor changes
+static QColor s_waveformInnerColor = QColor(183, 124, 255);
+
+static QColor s_playColor = QColor(255, 255, 255, 200);
+static QColor s_playHighlightColor = QColor(255, 255, 255, 70);
+
+static QColor s_sliceColor = QColor(218, 193, 255);
+static QColor s_sliceShadowColor = QColor(136, 120, 158);
+static QColor s_sliceHighlightColor = QColor(255, 255, 255);
+
+static QColor s_seekerColor = QColor(178, 115, 255);
+static QColor s_seekerHighlightColor = QColor(178, 115, 255, 100);
+static QColor s_seekerShadowColor = QColor(0, 0, 0, 120);
+
 SlicerTWaveform::SlicerTWaveform(int totalWidth, int totalHeight, SlicerT* instrument, QWidget* parent)
 	: QWidget(parent)
-	// calculate sizes
 	, m_width(totalWidth)
 	, m_height(totalHeight)
 	, m_seekerWidth(totalWidth - m_seekerHorMargin * 2)
 	, m_editorHeight(totalHeight - m_seekerHeight - m_middleMargin)
 	, m_editorWidth(totalWidth)
-
-	// create pixmaps
 	, m_sliceArrow(PLUGIN_NAME::getIconPixmap("slice_indicator_arrow"))
 	, m_seeker(QPixmap(m_seekerWidth, m_seekerHeight))
 	, m_seekerWaveform(QPixmap(m_seekerWidth, m_seekerHeight))
 	, m_editorWaveform(QPixmap(m_editorWidth, m_editorHeight))
 	, m_sliceEditor(QPixmap(totalWidth, m_editorHeight))
 	, m_emptySampleIcon(embed::getIconPixmap("sample_track"))
-
-	// references to instrument vars
 	, m_slicerTParent(instrument)
 {
-	// window config
 	setFixedSize(m_width, m_height);
 	setMouseTracking(true);
 
-	// draw backgrounds
 	m_seekerWaveform.fill(s_waveformBgColor);
 	m_editorWaveform.fill(s_waveformBgColor);
 
-	// connect to playback
 	connect(instrument, &SlicerT::isPlaying, this, &SlicerTWaveform::isPlaying);
 	connect(instrument, &SlicerT::dataChanged, this, &SlicerTWaveform::updateUI);
 
-	// preprocess icons
 	m_emptySampleIcon = m_emptySampleIcon.createMaskFromColor(QColor(255, 255, 255), Qt::MaskMode::MaskOutColor);
 
 	updateUI();
@@ -94,37 +102,30 @@ void SlicerTWaveform::drawSeeker()
 	if (m_slicerTParent->m_originalSample.frames() <= 1) { return; }
 	QPainter brush(&m_seeker);
 
-	// draw slice points
 	brush.setPen(s_sliceColor);
-	for (float sliceValue: m_slicerTParent->m_slicePoints)
+	for (float sliceValue : m_slicerTParent->m_slicePoints)
 	{
 		float xPos = sliceValue * m_seekerWidth;
 		brush.drawLine(xPos, 0, xPos, m_seekerHeight);
 	}
 
-	// seeker vars
 	float seekerStartPosX = m_seekerStart * m_seekerWidth;
 	float seekerEndPosX = m_seekerEnd * m_seekerWidth;
 	float seekerMiddleWidth = (m_seekerEnd - m_seekerStart) * m_seekerWidth;
 
-	// note playback vars
 	float noteCurrentPosX = m_noteCurrent * m_seekerWidth;
 	float noteStartPosX = m_noteStart * m_seekerWidth;
 	float noteEndPosX = (m_noteEnd - m_noteStart) * m_seekerWidth;
 
-	// draw current playBack
 	brush.setPen(s_playColor);
 	brush.drawLine(noteCurrentPosX, 0, noteCurrentPosX, m_seekerHeight);
 	brush.fillRect(noteStartPosX, 0, noteEndPosX, m_seekerHeight, s_playHighlightColor);
 
-	// highlight on selected area
 	brush.fillRect(seekerStartPosX, 0, seekerMiddleWidth - 1, m_seekerHeight, s_seekerHighlightColor);
 
-	// shadow on not selected area
 	brush.fillRect(0, 0, seekerStartPosX, m_seekerHeight, s_seekerShadowColor);
 	brush.fillRect(seekerEndPosX - 1, 0, m_seekerWidth, m_seekerHeight, s_seekerShadowColor);
 
-	// draw border around selection
 	brush.setPen(QPen(s_seekerColor, 1));
 	brush.drawRect(seekerStartPosX, 0, seekerMiddleWidth - 1, m_seekerHeight - 1); // -1 needed
 }
@@ -134,7 +135,6 @@ void SlicerTWaveform::drawEditorWaveform()
 	m_editorWaveform.fill(s_emptyColor);
 	if (m_slicerTParent->m_originalSample.frames() <= 1) { return; }
 
-	// draw SlicerTWaveform
 	QPainter brush(&m_editorWaveform);
 	float startFrame = m_seekerStart * m_slicerTParent->m_originalSample.frames();
 	float endFrame = m_seekerEnd * m_slicerTParent->m_originalSample.frames();
@@ -155,7 +155,7 @@ void SlicerTWaveform::drawEditor()
 	m_sliceEditor.fill(s_waveformBgColor);
 	QPainter brush(&m_sliceEditor);
 
-	// draw text if no sample loaded
+	// No sample loaded
 	if (m_slicerTParent->m_originalSample.frames() <= 1)
 	{
 		brush.setPen(s_playHighlightColor);
@@ -168,7 +168,6 @@ void SlicerTWaveform::drawEditor()
 		return;
 	}
 
-	// editor boundaries
 	float startFrame = m_seekerStart;
 	float endFrame = m_seekerEnd;
 	float numFramesToDraw = endFrame - startFrame;
@@ -178,19 +177,15 @@ void SlicerTWaveform::drawEditor()
 	float noteStartPos = (m_noteStart - m_seekerStart) / (m_seekerEnd - m_seekerStart) * m_editorWidth;
 	float noteLength = (m_noteEnd - m_noteStart) / (m_seekerEnd - m_seekerStart) * m_editorWidth;
 
-	// 0 centered line
 	brush.setPen(s_playHighlightColor);
 	brush.drawLine(0, m_editorHeight / 2, m_editorWidth, m_editorHeight / 2);
 
-	// draw waveform from pixmap
 	brush.drawPixmap(0, 0, m_editorWaveform);
 
-	// draw currently playing
 	brush.setPen(s_playColor);
 	brush.drawLine(noteCurrentPos, 0, noteCurrentPos, m_editorHeight);
 	brush.fillRect(noteStartPos, 0, noteLength, m_editorHeight, s_playHighlightColor);
 
-	// draw slicepoints
 	brush.setPen(QPen(s_sliceColor, 2));
 
 	for (int i = 0; i < m_slicerTParent->m_slicePoints.size(); i++)
@@ -243,27 +238,26 @@ void SlicerTWaveform::updateClosest(QMouseEvent* me)
 	m_closestObject = UIObjects::Nothing;
 	m_closestSlice = -1;
 
-	if (me->y() < m_seekerHeight) // seeker click
+	if (me->y() < m_seekerHeight)
 	{
-		if (std::abs(normalizedClickSeeker - m_seekerStart) < s_distanceForClick) // dragging start
+		if (std::abs(normalizedClickSeeker - m_seekerStart) < s_distanceForClick)
 		{
 			m_closestObject = UIObjects::SeekerStart;
 		}
-		else if (std::abs(normalizedClickSeeker - m_seekerEnd) < s_distanceForClick) // dragging end
+		else if (std::abs(normalizedClickSeeker - m_seekerEnd) < s_distanceForClick)
 		{
 			m_closestObject = UIObjects::SeekerEnd;
 		}
-		else if (normalizedClickSeeker > m_seekerStart && normalizedClickSeeker < m_seekerEnd) // dragging middle
+		else if (normalizedClickSeeker > m_seekerStart && normalizedClickSeeker < m_seekerEnd)
 		{
 			m_closestObject = UIObjects::SeekerMiddle;
 		}
 	}
-	else // editor click
+	else
 	{
 		m_closestSlice = -1;
 		float startFrame = m_seekerStart;
 		float endFrame = m_seekerEnd;
-		// select slice
 		for (int i = 0; i < m_slicerTParent->m_slicePoints.size(); i++)
 		{
 			float sliceIndex = m_slicerTParent->m_slicePoints.at(i);
@@ -297,9 +291,6 @@ void SlicerTWaveform::updateCursor()
 // handles deletion, reset and middles seeker
 void SlicerTWaveform::mousePressEvent(QMouseEvent* me)
 {
-	/* updateClosest(me); */
-
-	// reset seeker on middle click
 	switch (me->button())
 	{
 	case Qt::MouseButton::MiddleButton:
@@ -311,15 +302,13 @@ void SlicerTWaveform::mousePressEvent(QMouseEvent* me)
 		// update seeker middle for correct movement
 		m_seekerMiddle = static_cast<float>(me->x() - m_seekerHorMargin) / m_seekerWidth;
 		break;
-	// delete closesd slice to mouse
 	case Qt::MouseButton::RightButton:
 		if (m_slicerTParent->m_slicePoints.size() > 2 && m_closestObject == UIObjects::SlicePoint)
 		{
 			m_slicerTParent->m_slicePoints.erase(m_slicerTParent->m_slicePoints.begin() + m_closestSlice);
 		}
 		break;
-	default:
-		;	
+	default:;
 	}
 	updateClosest(me);
 }
@@ -350,7 +339,6 @@ void SlicerTWaveform::mouseMoveEvent(QMouseEvent* me)
 	float startFrame = m_seekerStart;
 	float endFrame = m_seekerEnd;
 
-	// handle dragging events
 	switch (m_closestObject)
 	{
 	case UIObjects::SeekerStart:
diff --git a/plugins/SlicerT/SlicerTWaveform.h b/plugins/SlicerT/SlicerTWaveform.h
index 7643dee1b85..01947289bd7 100644
--- a/plugins/SlicerT/SlicerTWaveform.h
+++ b/plugins/SlicerT/SlicerTWaveform.h
@@ -56,24 +56,6 @@ public slots:
 	static constexpr int m_seekerHeight = 38; // used to calcualte all vertical sizes
 	static constexpr int m_middleMargin = 6;
 
-	// colors
-	const QColor s_emptyColor = QColor(0, 0, 0, 0);
-
-	const QColor s_waveformColor = QColor(123, 49, 212);
-	const QColor s_waveformBgColor = QColor(255, 255, 255, 0);
-	const QColor s_waveformMaskColor = QColor(151, 65, 255); // update this if s_waveformColor changes
-	const QColor s_waveformInnerColor = QColor(183, 124, 255);
-
-	const QColor s_playColor = QColor(255, 255, 255, 200);
-	const QColor s_playHighlightColor = QColor(255, 255, 255, 70);
-
-	const QColor s_sliceColor = QColor(218, 193, 255);
-	const QColor s_sliceShadowColor = QColor(136, 120, 158);
-	const QColor s_sliceHighlightColor = QColor(255, 255, 255);
-
-	const QColor s_seekerColor = QColor(178, 115, 255);
-	const QColor s_seekerHighlightColor = QColor(178, 115, 255, 100);
-	const QColor s_seekerShadowColor = QColor(0, 0, 0, 120);
 
 	// interaction behavior values
 	static constexpr float s_distanceForClick = 0.02f;
@@ -99,39 +81,29 @@ public slots:
 	void paintEvent(QPaintEvent* pe) override;
 
 private:
-	// sizes
 	int m_width;
 	int m_height;
 
-	// later calculated
 	int m_seekerWidth;
 	int m_editorHeight;
 	int m_editorWidth;
 
-	// interaction vars
-	UIObjects m_draggedObject;
 	UIObjects m_closestObject;
 	int m_closestSlice = -1;
-	int m_sliceDragged = -1;
-	bool m_currentlyDragging = false;
 
-	// seeker vars
 	float m_seekerStart = 0;
 	float m_seekerEnd = 1;
 	float m_seekerMiddle = 0.5f;
 
-	// playback highlight vars
 	float m_noteCurrent;
 	float m_noteStart;
 	float m_noteEnd;
 
-	// editor vars
 	float m_zoomLevel = 1.0f;
 
-	// pixmaps
 	QPixmap m_sliceArrow;
 	QPixmap m_seeker;
-	QPixmap m_seekerWaveform; // only stores SlicerTWaveform graphic
+	QPixmap m_seekerWaveform;
 	QPixmap m_editorWaveform;
 	QPixmap m_sliceEditor;
 	QPixmap m_emptySampleIcon;

From f44fa4d1f7e597baadf8ff3eee074e5c90da38ee Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Sun, 5 Nov 2023 14:35:48 +0100
Subject: [PATCH 88/99] Performance + click to load

---
 plugins/SlicerT/SlicerT.cpp         |  1 +
 plugins/SlicerT/SlicerTView.cpp     |  6 ++++++
 plugins/SlicerT/SlicerTView.h       |  1 +
 plugins/SlicerT/SlicerTWaveform.cpp | 17 ++++++++++++++---
 plugins/SlicerT/SlicerTWaveform.h   |  3 +++
 5 files changed, 25 insertions(+), 3 deletions(-)

diff --git a/plugins/SlicerT/SlicerT.cpp b/plugins/SlicerT/SlicerT.cpp
index b2819e58dff..adbf5172b7b 100644
--- a/plugins/SlicerT/SlicerT.cpp
+++ b/plugins/SlicerT/SlicerT.cpp
@@ -207,6 +207,7 @@ void SlicerT::findSlices()
 		{
 			m_slicePoints.push_back(i);
 			lastPoint = i;
+			if (m_slicePoints.size() > 128) { break; } // no more keys on the keyboard
 		}
 
 		prevFlux = spectralFlux;
diff --git a/plugins/SlicerT/SlicerTView.cpp b/plugins/SlicerT/SlicerTView.cpp
index d18e32327cb..75463d3a681 100644
--- a/plugins/SlicerT/SlicerTView.cpp
+++ b/plugins/SlicerT/SlicerTView.cpp
@@ -127,6 +127,12 @@ void SlicerTView::exportMidi()
 	copyString(dataFile.toString(), MimeType::Default);
 }
 
+void SlicerTView::openFiles() {
+	QString audioFile = m_slicerTParent->m_originalSample.openAudioFile();
+	if (audioFile.isEmpty()) { return; }
+	m_slicerTParent->updateFile(audioFile);
+}
+
 // all the drag stuff is copied from AudioFileProcessor
 void SlicerTView::dragEnterEvent(QDragEnterEvent* dee)
 {
diff --git a/plugins/SlicerT/SlicerTView.h b/plugins/SlicerT/SlicerTView.h
index 690fc9a0e36..d9cbdfae4d1 100644
--- a/plugins/SlicerT/SlicerTView.h
+++ b/plugins/SlicerT/SlicerTView.h
@@ -48,6 +48,7 @@ class SlicerTView : public InstrumentViewFixedSize
 
 public slots:
 	void exportMidi();
+	void openFiles();
 
 public:
 	SlicerTView(SlicerT* instrument, QWidget* parent);
diff --git a/plugins/SlicerT/SlicerTWaveform.cpp b/plugins/SlicerT/SlicerTWaveform.cpp
index a43aafc5917..976610a6811 100644
--- a/plugins/SlicerT/SlicerTWaveform.cpp
+++ b/plugins/SlicerT/SlicerTWaveform.cpp
@@ -77,6 +77,7 @@ SlicerTWaveform::SlicerTWaveform(int totalWidth, int totalHeight, SlicerT* instr
 
 	m_emptySampleIcon = m_emptySampleIcon.createMaskFromColor(QColor(255, 255, 255), Qt::MaskMode::MaskOutColor);
 
+	m_updateTimer.start();
 	updateUI();
 }
 
@@ -161,7 +162,7 @@ void SlicerTWaveform::drawEditor()
 		brush.setPen(s_playHighlightColor);
 		brush.setFont(QFont(brush.font().family(), 9.0f, -1, false));
 		brush.drawText(
-			m_editorWidth / 2 - 100, m_editorHeight / 2 - 110, 200, 200, Qt::AlignCenter, tr("Drag sample to load"));
+			m_editorWidth / 2 - 100, m_editorHeight / 2 - 110, 200, 200, Qt::AlignCenter, tr("Click to load sample"));
 		int iconOffsetX = m_emptySampleIcon.width() / 2.0f;
 		int iconOffsetY = m_emptySampleIcon.height() / 2.0f - 13;
 		brush.drawPixmap(m_editorWidth / 2.0f - iconOffsetX, m_editorHeight / 2.0f - iconOffsetY, m_emptySampleIcon);
@@ -212,14 +213,17 @@ void SlicerTWaveform::drawEditor()
 
 void SlicerTWaveform::isPlaying(float current, float start, float end)
 {
+	if (!m_updateTimer.hasExpired(s_minMilisPassed)) {return;}
 	m_noteCurrent = current;
 	m_noteStart = start;
 	m_noteEnd = end;
 	drawSeeker();
 	drawEditor();
 	update();
+	m_updateTimer.restart();
 }
 
+// this should only be called if one of the waveforms has to update
 void SlicerTWaveform::updateUI()
 {
 	drawSeekerWaveform();
@@ -271,7 +275,9 @@ void SlicerTWaveform::updateClosest(QMouseEvent* me)
 		}
 	}
 	updateCursor();
-	updateUI();
+	drawSeeker();
+	drawEditor();
+	update();
 }
 
 void SlicerTWaveform::updateCursor()
@@ -299,6 +305,9 @@ void SlicerTWaveform::mousePressEvent(QMouseEvent* me)
 		m_zoomLevel = 1;
 		break;
 	case Qt::MouseButton::LeftButton:
+		if (m_slicerTParent->m_originalSample.frames() <= 1) {
+			static_cast<SlicerTView*>(parent())->openFiles();
+		}
 		// update seeker middle for correct movement
 		m_seekerMiddle = static_cast<float>(me->x() - m_seekerHorMargin) / m_seekerWidth;
 		break;
@@ -371,7 +380,9 @@ void SlicerTWaveform::mouseMoveEvent(QMouseEvent* me)
 	}
 	// dont update closest, and update seeker waveform
 	drawEditorWaveform();
-	updateUI();
+	drawSeeker();
+	drawEditor();
+	update();
 }
 
 void SlicerTWaveform::mouseDoubleClickEvent(QMouseEvent* me)
diff --git a/plugins/SlicerT/SlicerTWaveform.h b/plugins/SlicerT/SlicerTWaveform.h
index 01947289bd7..59e4a1aafcc 100644
--- a/plugins/SlicerT/SlicerTWaveform.h
+++ b/plugins/SlicerT/SlicerTWaveform.h
@@ -30,6 +30,7 @@
 #include <QInputDialog>
 #include <QMouseEvent>
 #include <QPainter>
+#include <QElapsedTimer>
 
 #include "Instrument.h"
 #include "SampleBuffer.h"
@@ -61,6 +62,7 @@ public slots:
 	static constexpr float s_distanceForClick = 0.02f;
 	static constexpr float s_minSeekerDistance = 0.13f;
 	static constexpr float s_zoomSensitivity = 0.5f;
+	static constexpr int s_minMilisPassed = 10;
 
 	enum class UIObjects
 	{
@@ -110,6 +112,7 @@ public slots:
 
 	SlicerT* m_slicerTParent;
 
+	QElapsedTimer m_updateTimer;
 	void drawSeekerWaveform();
 	void drawSeeker();
 	void drawEditorWaveform();

From cdf45fc56f10e441eab97711d46b3394a718683b Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Sun, 5 Nov 2023 17:33:00 +0100
Subject: [PATCH 89/99] update PlaybackState + zerocross snapping

---
 plugins/SlicerT/SlicerT.cpp         | 29 +++++++++++++++++++++++------
 plugins/SlicerT/SlicerT.h           | 23 +++++++++++++----------
 plugins/SlicerT/SlicerTWaveform.cpp |  5 ++++-
 3 files changed, 40 insertions(+), 17 deletions(-)

diff --git a/plugins/SlicerT/SlicerT.cpp b/plugins/SlicerT/SlicerT.cpp
index adbf5172b7b..264dbaf777a 100644
--- a/plugins/SlicerT/SlicerT.cpp
+++ b/plugins/SlicerT/SlicerT.cpp
@@ -101,16 +101,16 @@ void SlicerT::playNote(NotePlayHandle* handle, sampleFrame* workingBuffer)
 		sliceEnd = m_slicePoints[noteIndex + 1];
 	}
 
-	if (!handle->m_pluginData) { handle->m_pluginData = new PlayBackState(sliceStart); }
+	if (!handle->m_pluginData) { handle->m_pluginData = new PlaybackState(sliceStart); }
 
-	float noteDone = ((PlayBackState*)handle->m_pluginData)->getNoteDone();
+	float noteDone = ((PlaybackState*)handle->m_pluginData)->noteDone();
 	float noteLeft = sliceEnd - noteDone;
 
 	if (noteLeft > 0)
 	{
 		int noteFrame = noteDone * m_originalSample.frames();
 
-		SRC_STATE* resampleState = ((PlayBackState*)handle->m_pluginData)->getResampleState();
+		SRC_STATE* resampleState = ((PlaybackState*)handle->m_pluginData)->resamplingState();
 		SRC_DATA resampleData;
 		resampleData.data_in = (float*)(m_originalSample.data() + noteFrame);
 		resampleData.data_out = (float*)(workingBuffer + offset);
@@ -121,7 +121,7 @@ void SlicerT::playNote(NotePlayHandle* handle, sampleFrame* workingBuffer)
 		src_process(resampleState, &resampleData);
 
 		float nextNoteDone = noteDone + frames * (1.0f / speedRatio) / m_originalSample.frames();
-		((PlayBackState*)handle->m_pluginData)->setNoteDone(nextNoteDone);
+		((PlaybackState*)handle->m_pluginData)->setNoteDone(nextNoteDone);
 
 		// exponential fade out, applyRelease() not used since it extends the note length
 		int noteFramesLeft = noteLeft * m_originalSample.frames();
@@ -167,9 +167,17 @@ void SlicerT::findSlices()
 		maxMag = std::max(maxMag, singleChannel[i]);
 	}
 
-	for (float& channelValue : singleChannel)
+	// normalize and find 0 crossings
+	std::vector<int> zeroCrossings;
+	float lastValue = 1;
+	for (int i = 0; i < singleChannel.size(); i++)
 	{
-		channelValue /= maxMag;
+		singleChannel[i] /= maxMag;
+		if (sign(lastValue) != sign(singleChannel[i]))
+		{
+			zeroCrossings.push_back(i);
+			lastValue = singleChannel[i];
+		}
 	}
 
 	std::vector<float> prevMags(windowSize / 2, 0);
@@ -216,6 +224,15 @@ void SlicerT::findSlices()
 
 	m_slicePoints.push_back(m_originalSample.frames());
 
+	for (float& sliceValue : m_slicePoints)
+	{
+		int closestZeroCrossing = *std::lower_bound(zeroCrossings.begin(), zeroCrossings.end(), sliceValue);
+		if (abs(sliceValue - closestZeroCrossing) < windowSize)
+		{
+			sliceValue = *std::lower_bound(zeroCrossings.begin(), zeroCrossings.end(), sliceValue);
+		}
+	}
+
 	float beatsPerMin = m_originalBPM.value() / 60.0f;
 	float samplesPerBeat = m_originalSample.sampleRate() / beatsPerMin * 4.0f;
 	int noteSnap = m_sliceSnap.value();
diff --git a/plugins/SlicerT/SlicerT.h b/plugins/SlicerT/SlicerT.h
index 771aa1da99e..aafe834656b 100644
--- a/plugins/SlicerT/SlicerT.h
+++ b/plugins/SlicerT/SlicerT.h
@@ -38,22 +38,25 @@
 
 namespace lmms {
 
-class PlayBackState
+class PlaybackState
 {
 public:
-	PlayBackState(float startFrame)
-		: currentNote(startFrame)
-		, resamplingState(src_new(SRC_LINEAR, 2, nullptr))
+	explicit PlaybackState(float startFrame)
+		: m_currentNoteDone(startFrame)
+		, m_resamplingState(src_new(SRC_LINEAR, DEFAULT_CHANNELS, nullptr))
 	{
+		if (!m_resamplingState) { throw std::runtime_error{"Failed to create sample rate converter object"}; }
 	}
-	~PlayBackState() { src_delete(resamplingState); }
-	float getNoteDone() { return currentNote; }
-	void setNoteDone(float newDone) { currentNote = newDone; }
-	SRC_STATE* getResampleState() { return resamplingState; }
+	~PlaybackState() noexcept { src_delete(m_resamplingState); }
+
+	float noteDone() const { return m_currentNoteDone; }
+	void setNoteDone(float newNoteDone) { m_currentNoteDone = newNoteDone; }
+
+	SRC_STATE* resamplingState() const { return m_resamplingState; }
 
 private:
-	float currentNote;
-	SRC_STATE* resamplingState;
+	float m_currentNoteDone;
+	SRC_STATE* m_resamplingState;
 };
 
 class SlicerT : public Instrument
diff --git a/plugins/SlicerT/SlicerTWaveform.cpp b/plugins/SlicerT/SlicerTWaveform.cpp
index 976610a6811..89d224a55a4 100644
--- a/plugins/SlicerT/SlicerTWaveform.cpp
+++ b/plugins/SlicerT/SlicerTWaveform.cpp
@@ -303,6 +303,7 @@ void SlicerTWaveform::mousePressEvent(QMouseEvent* me)
 		m_seekerStart = 0;
 		m_seekerEnd = 1;
 		m_zoomLevel = 1;
+		drawEditorWaveform();
 		break;
 	case Qt::MouseButton::LeftButton:
 		if (m_slicerTParent->m_originalSample.frames() <= 1) {
@@ -352,10 +353,12 @@ void SlicerTWaveform::mouseMoveEvent(QMouseEvent* me)
 	{
 	case UIObjects::SeekerStart:
 		m_seekerStart = std::clamp(normalizedClickSeeker, 0.0f, m_seekerEnd - s_minSeekerDistance);
+		drawEditorWaveform();
 		break;
 
 	case UIObjects::SeekerEnd:
 		m_seekerEnd = std::clamp(normalizedClickSeeker, m_seekerStart + s_minSeekerDistance, 1.0f);
+		drawEditorWaveform();
 		break;
 
 	case UIObjects::SeekerMiddle:
@@ -366,6 +369,7 @@ void SlicerTWaveform::mouseMoveEvent(QMouseEvent* me)
 			m_seekerStart = m_seekerMiddle + distStart;
 			m_seekerEnd = m_seekerMiddle + distEnd;
 		}
+		drawEditorWaveform();
 		break;
 
 	case UIObjects::SlicePoint:
@@ -379,7 +383,6 @@ void SlicerTWaveform::mouseMoveEvent(QMouseEvent* me)
 		break;
 	}
 	// dont update closest, and update seeker waveform
-	drawEditorWaveform();
 	drawSeeker();
 	drawEditor();
 	update();

From faeeaef1e93bbb6d7b71d43ff818c112b2b0231e Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Mon, 6 Nov 2023 00:36:08 +0100
Subject: [PATCH 90/99] Fix windows build issue

---
 plugins/SlicerT/SlicerT.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/plugins/SlicerT/SlicerT.h b/plugins/SlicerT/SlicerT.h
index aafe834656b..73c4e9b5c6c 100644
--- a/plugins/SlicerT/SlicerT.h
+++ b/plugins/SlicerT/SlicerT.h
@@ -27,6 +27,7 @@
 
 #include <algorithm>
 #include <fftw3.h>
+#include <stdexcept>
 
 #include "AutomatableModel.h"
 #include "Instrument.h"

From 24738bb54f3fedae685727196731e1551041cbb9 Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Wed, 8 Nov 2023 20:31:05 +0100
Subject: [PATCH 91/99] Review + version

---
 plugins/SlicerT/SlicerT.cpp     | 11 ++++++-----
 plugins/SlicerT/SlicerTView.cpp |  5 +++--
 2 files changed, 9 insertions(+), 7 deletions(-)

diff --git a/plugins/SlicerT/SlicerT.cpp b/plugins/SlicerT/SlicerT.cpp
index 264dbaf777a..4601dd6225f 100644
--- a/plugins/SlicerT/SlicerT.cpp
+++ b/plugins/SlicerT/SlicerT.cpp
@@ -110,10 +110,10 @@ void SlicerT::playNote(NotePlayHandle* handle, sampleFrame* workingBuffer)
 	{
 		int noteFrame = noteDone * m_originalSample.frames();
 
-		SRC_STATE* resampleState = ((PlaybackState*)handle->m_pluginData)->resamplingState();
+		SRC_STATE* resampleState = static_cast<PlaybackState*>(handle->m_pluginData)->resamplingState();
 		SRC_DATA resampleData;
-		resampleData.data_in = (float*)(m_originalSample.data() + noteFrame);
-		resampleData.data_out = (float*)(workingBuffer + offset);
+		resampleData.data_in = &(m_originalSample.data() + noteFrame)[0][0];
+		resampleData.data_out = &(workingBuffer + offset)[0][0];
 		resampleData.input_frames = noteLeft * m_originalSample.frames();
 		resampleData.output_frames = frames;
 		resampleData.src_ratio = speedRatio;
@@ -227,9 +227,9 @@ void SlicerT::findSlices()
 	for (float& sliceValue : m_slicePoints)
 	{
 		int closestZeroCrossing = *std::lower_bound(zeroCrossings.begin(), zeroCrossings.end(), sliceValue);
-		if (abs(sliceValue - closestZeroCrossing) < windowSize)
+		if (std::abs(sliceValue - closestZeroCrossing) < windowSize)
 		{
-			sliceValue = *std::lower_bound(zeroCrossings.begin(), zeroCrossings.end(), sliceValue);
+			sliceValue = closestZeroCrossing;
 		}
 	}
 
@@ -328,6 +328,7 @@ void SlicerT::updateSlices()
 
 void SlicerT::saveSettings(QDomDocument& document, QDomElement& element)
 {
+	element.setAttribute("version", "1");
 	element.setAttribute("src", m_originalSample.audioFile());
 	if (m_originalSample.audioFile().isEmpty())
 	{
diff --git a/plugins/SlicerT/SlicerTView.cpp b/plugins/SlicerT/SlicerTView.cpp
index 75463d3a681..200b2c9099a 100644
--- a/plugins/SlicerT/SlicerTView.cpp
+++ b/plugins/SlicerT/SlicerTView.cpp
@@ -118,7 +118,7 @@ void SlicerTView::exportMidi()
 	if (notes.size() == 0) { return; }
 
 	TimePos start_pos(notes.front().pos().getBar(), 0);
-	for (Note note : notes)
+	for (Note& note : notes)
 	{
 		note.setPos(note.pos(start_pos));
 		note.saveState(dataFile, note_list);
@@ -127,7 +127,8 @@ void SlicerTView::exportMidi()
 	copyString(dataFile.toString(), MimeType::Default);
 }
 
-void SlicerTView::openFiles() {
+void SlicerTView::openFiles()
+{
 	QString audioFile = m_slicerTParent->m_originalSample.openAudioFile();
 	if (audioFile.isEmpty()) { return; }
 	m_slicerTParent->updateFile(audioFile);

From df8b90feaff1e729f21e2c214f5f079dc5a8b6f7 Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Wed, 8 Nov 2023 20:57:13 +0100
Subject: [PATCH 92/99] Fixed fade out bug

---
 plugins/SlicerT/SlicerT.cpp     | 33 ++++++++++++++-------------------
 plugins/SlicerT/SlicerTView.cpp |  2 +-
 2 files changed, 15 insertions(+), 20 deletions(-)

diff --git a/plugins/SlicerT/SlicerT.cpp b/plugins/SlicerT/SlicerT.cpp
index 4601dd6225f..b296e9b25f5 100644
--- a/plugins/SlicerT/SlicerT.cpp
+++ b/plugins/SlicerT/SlicerT.cpp
@@ -57,7 +57,7 @@ Plugin::Descriptor PLUGIN_EXPORT slicert_plugin_descriptor = {
 SlicerT::SlicerT(InstrumentTrack* instrumentTrack)
 	: Instrument(instrumentTrack, &slicert_plugin_descriptor)
 	, m_noteThreshold(0.6f, 0.0f, 2.0f, 0.01f, this, tr("Note threshold"))
-	, m_fadeOutFrames(400.0f, 0.0f, 8192.0f, 1.0f, this, tr("FadeOut"))
+	, m_fadeOutFrames(10.0f, 0.0f, 100.0f, 0.1f, this, tr("FadeOut"))
 	, m_originalBPM(1, 1, 999, this, tr("Original bpm"))
 	, m_sliceSnap(this, tr("Slice snap"))
 	, m_enableSync(false, this, tr("BPM sync"))
@@ -112,8 +112,8 @@ void SlicerT::playNote(NotePlayHandle* handle, sampleFrame* workingBuffer)
 
 		SRC_STATE* resampleState = static_cast<PlaybackState*>(handle->m_pluginData)->resamplingState();
 		SRC_DATA resampleData;
-		resampleData.data_in = &(m_originalSample.data() + noteFrame)[0][0];
-		resampleData.data_out = &(workingBuffer + offset)[0][0];
+		resampleData.data_in = (m_originalSample.data() + noteFrame)->data();
+		resampleData.data_out = (workingBuffer + offset)->data();
 		resampleData.input_frames = noteLeft * m_originalSample.frames();
 		resampleData.output_frames = frames;
 		resampleData.src_ratio = speedRatio;
@@ -121,21 +121,19 @@ void SlicerT::playNote(NotePlayHandle* handle, sampleFrame* workingBuffer)
 		src_process(resampleState, &resampleData);
 
 		float nextNoteDone = noteDone + frames * (1.0f / speedRatio) / m_originalSample.frames();
-		((PlaybackState*)handle->m_pluginData)->setNoteDone(nextNoteDone);
+		static_cast<PlaybackState*>(handle->m_pluginData)->setNoteDone(nextNoteDone);
 
 		// exponential fade out, applyRelease() not used since it extends the note length
-		int noteFramesLeft = noteLeft * m_originalSample.frames();
-		if (noteFramesLeft < m_fadeOutFrames.value())
+		int fadeOutFrames = m_fadeOutFrames.value() / 1000.0f * Engine::audioEngine()->processingSampleRate();
+		int noteFramesLeft = noteLeft * m_originalSample.frames() * speedRatio;
+		for (int i = 0; i < frames; i++)
 		{
-			for (int i = 0; i < frames; i++)
-			{
-				float fadeValue = static_cast<float>(noteFramesLeft - i) / m_fadeOutFrames.value();
-				fadeValue = std::clamp(fadeValue, 0.0f, 1.0f);
-				fadeValue = std::pow(fadeValue, 2);
-
-				workingBuffer[i + offset][0] *= fadeValue;
-				workingBuffer[i + offset][1] *= fadeValue;
-			}
+			float fadeValue = static_cast<float>(noteFramesLeft - i) / fadeOutFrames;
+			fadeValue = std::clamp(fadeValue, 0.0f, 1.0f);
+			fadeValue = std::pow(fadeValue, 2);
+
+			workingBuffer[i + offset][0] *= fadeValue;
+			workingBuffer[i + offset][1] *= fadeValue;
 		}
 
 		instrumentTrack()->processAudioBuffer(workingBuffer, frames + offset, handle);
@@ -227,10 +225,7 @@ void SlicerT::findSlices()
 	for (float& sliceValue : m_slicePoints)
 	{
 		int closestZeroCrossing = *std::lower_bound(zeroCrossings.begin(), zeroCrossings.end(), sliceValue);
-		if (std::abs(sliceValue - closestZeroCrossing) < windowSize)
-		{
-			sliceValue = closestZeroCrossing;
-		}
+		if (std::abs(sliceValue - closestZeroCrossing) < windowSize) { sliceValue = closestZeroCrossing; }
 	}
 
 	float beatsPerMin = m_originalBPM.value() / 60.0f;
diff --git a/plugins/SlicerT/SlicerTView.cpp b/plugins/SlicerT/SlicerTView.cpp
index 200b2c9099a..33b83fc69bf 100644
--- a/plugins/SlicerT/SlicerTView.cpp
+++ b/plugins/SlicerT/SlicerTView.cpp
@@ -79,7 +79,7 @@ SlicerTView::SlicerTView(SlicerT* instrument, QWidget* parent)
 
 	m_fadeOutKnob = createStyledKnob();
 	m_fadeOutKnob->move(64, 197);
-	m_fadeOutKnob->setToolTip(tr("Fade Out for notes"));
+	m_fadeOutKnob->setToolTip(tr("Fade Out per note in milliseconds"));
 	m_fadeOutKnob->setModel(&m_slicerTParent->m_fadeOutFrames);
 
 	m_midiExportButton = new QPushButton(this);

From b2e7f11a32a4dc62d05d63e0130ff3a7ea73c3a4 Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Wed, 8 Nov 2023 21:26:07 +0100
Subject: [PATCH 93/99] Use cosine interpolation

---
 plugins/SlicerT/SlicerT.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/plugins/SlicerT/SlicerT.cpp b/plugins/SlicerT/SlicerT.cpp
index b296e9b25f5..5097723e4e6 100644
--- a/plugins/SlicerT/SlicerT.cpp
+++ b/plugins/SlicerT/SlicerT.cpp
@@ -130,7 +130,7 @@ void SlicerT::playNote(NotePlayHandle* handle, sampleFrame* workingBuffer)
 		{
 			float fadeValue = static_cast<float>(noteFramesLeft - i) / fadeOutFrames;
 			fadeValue = std::clamp(fadeValue, 0.0f, 1.0f);
-			fadeValue = std::pow(fadeValue, 2);
+			fadeValue = cosinusInterpolate(0, 1, fadeValue);
 
 			workingBuffer[i + offset][0] *= fadeValue;
 			workingBuffer[i + offset][1] *= fadeValue;

From 1f5c4946427835465a36cc5ee32139f85cd545c3 Mon Sep 17 00:00:00 2001
From: DanielKauss <daniel.kauss.serna@gmail.com>
Date: Wed, 8 Nov 2023 23:58:53 +0100
Subject: [PATCH 94/99] Apply suggestions from code review

Co-authored-by: Dalton Messmer <33463986+messmerd@users.noreply.github.com>
---
 plugins/SlicerT/SlicerT.cpp         |  6 +++---
 plugins/SlicerT/SlicerTView.cpp     | 14 +++++++-------
 plugins/SlicerT/SlicerTView.h       | 10 +++++-----
 plugins/SlicerT/SlicerTWaveform.cpp |  6 +++---
 plugins/SlicerT/SlicerTWaveform.h   |  6 +++---
 5 files changed, 21 insertions(+), 21 deletions(-)

diff --git a/plugins/SlicerT/SlicerT.cpp b/plugins/SlicerT/SlicerT.cpp
index 5097723e4e6..0fa888ec81f 100644
--- a/plugins/SlicerT/SlicerT.cpp
+++ b/plugins/SlicerT/SlicerT.cpp
@@ -82,7 +82,7 @@ void SlicerT::playNote(NotePlayHandle* handle, sampleFrame* workingBuffer)
 	const fpp_t frames = handle->framesLeftForCurrentPeriod();
 	const f_cnt_t offset = handle->noteOffset();
 	const int bpm = Engine::getSong()->getTempo();
-	const float pitchRatio = 1 / pow(2, m_parentTrack->pitchModel()->value() / 1200);
+	const float pitchRatio = 1 / std::exp2(m_parentTrack->pitchModel()->value() / 1200);
 
 	float speedRatio = static_cast<float>(m_originalBPM.value()) / bpm;
 	if (!m_enableSync.value()) { speedRatio = 1; }
@@ -171,7 +171,7 @@ void SlicerT::findSlices()
 	for (int i = 0; i < singleChannel.size(); i++)
 	{
 		singleChannel[i] /= maxMag;
-		if (sign(lastValue) != sign(singleChannel[i]))
+		if (std::sign(lastValue) != std::sign(singleChannel[i]))
 		{
 			zeroCrossings.push_back(i);
 			lastValue = singleChannel[i];
@@ -231,7 +231,7 @@ void SlicerT::findSlices()
 	float beatsPerMin = m_originalBPM.value() / 60.0f;
 	float samplesPerBeat = m_originalSample.sampleRate() / beatsPerMin * 4.0f;
 	int noteSnap = m_sliceSnap.value();
-	int sliceLock = samplesPerBeat / std::pow(2, noteSnap + 1);
+	int sliceLock = samplesPerBeat / std::exp2(noteSnap + 1);
 	if (noteSnap == 0) { sliceLock = 1; }
 	for (float& sliceValue : m_slicePoints)
 	{
diff --git a/plugins/SlicerT/SlicerTView.cpp b/plugins/SlicerT/SlicerTView.cpp
index 33b83fc69bf..95977a1a3c9 100644
--- a/plugins/SlicerT/SlicerTView.cpp
+++ b/plugins/SlicerT/SlicerTView.cpp
@@ -111,17 +111,17 @@ void SlicerTView::exportMidi()
 	if (m_slicerTParent->m_originalSample.frames() <= 1) { return; }
 
 	DataFile dataFile(DataFile::Type::ClipboardData);
-	QDomElement note_list = dataFile.createElement("note-list");
-	dataFile.content().appendChild(note_list);
+	QDomElement noteList = dataFile.createElement("note-list");
+	dataFile.content().appendChild(noteList);
 
-	std::vector<Note> notes = m_slicerTParent->getMidi();
-	if (notes.size() == 0) { return; }
+	auto notes = m_slicerTParent->getMidi();
+	if (notes.empty()) { return; }
 
-	TimePos start_pos(notes.front().pos().getBar(), 0);
+	TimePos startPos(notes.front().pos().getBar(), 0);
 	for (Note& note : notes)
 	{
-		note.setPos(note.pos(start_pos));
-		note.saveState(dataFile, note_list);
+		note.setPos(note.pos(startPos));
+		note.saveState(dataFile, noteList);
 	}
 
 	copyString(dataFile.toString(), MimeType::Default);
diff --git a/plugins/SlicerT/SlicerTView.h b/plugins/SlicerT/SlicerTView.h
index d9cbdfae4d1..fbed046c613 100644
--- a/plugins/SlicerT/SlicerTView.h
+++ b/plugins/SlicerT/SlicerTView.h
@@ -22,8 +22,8 @@
  *
  */
 
-#ifndef LMMS_SLICERT_VIEW_H
-#define LMMS_SLICERT_VIEW_H
+#ifndef LMMS_GUI_SLICERT_VIEW_H
+#define LMMS_GUI_SLICERT_VIEW_H
 
 #include <QPushButton>
 
@@ -59,8 +59,8 @@ public slots:
 	static constexpr int bottomTextY = 220;
 
 protected:
-	virtual void dragEnterEvent(QDragEnterEvent* _dee);
-	virtual void dropEvent(QDropEvent* _de);
+	virtual void dragEnterEvent(QDragEnterEvent* dee);
+	virtual void dropEvent(QDropEvent* de);
 
 	virtual void paintEvent(QPaintEvent* pe);
 
@@ -82,4 +82,4 @@ public slots:
 };
 } // namespace gui
 } // namespace lmms
-#endif // LMMS_SLICERT_VIEW_H
+#endif // LMMS_GUI_SLICERT_VIEW_H
diff --git a/plugins/SlicerT/SlicerTWaveform.cpp b/plugins/SlicerT/SlicerTWaveform.cpp
index 89d224a55a4..2e8a88ed4ec 100644
--- a/plugins/SlicerT/SlicerTWaveform.cpp
+++ b/plugins/SlicerT/SlicerTWaveform.cpp
@@ -213,7 +213,7 @@ void SlicerTWaveform::drawEditor()
 
 void SlicerTWaveform::isPlaying(float current, float start, float end)
 {
-	if (!m_updateTimer.hasExpired(s_minMilisPassed)) {return;}
+	if (!m_updateTimer.hasExpired(s_minMilisPassed)) { return; }
 	m_noteCurrent = current;
 	m_noteStart = start;
 	m_noteEnd = end;
@@ -401,9 +401,9 @@ void SlicerTWaveform::mouseDoubleClickEvent(QMouseEvent* me)
 	std::sort(m_slicerTParent->m_slicePoints.begin(), m_slicerTParent->m_slicePoints.end());
 }
 
-void SlicerTWaveform::wheelEvent(QWheelEvent* _we)
+void SlicerTWaveform::wheelEvent(QWheelEvent* we)
 {
-	m_zoomLevel += _we->angleDelta().y() / 360.0f * s_zoomSensitivity;
+	m_zoomLevel += we->angleDelta().y() / 360.0f * s_zoomSensitivity;
 	m_zoomLevel = std::max(0.0f, m_zoomLevel);
 
 	updateUI();
diff --git a/plugins/SlicerT/SlicerTWaveform.h b/plugins/SlicerT/SlicerTWaveform.h
index 59e4a1aafcc..b714ad93261 100644
--- a/plugins/SlicerT/SlicerTWaveform.h
+++ b/plugins/SlicerT/SlicerTWaveform.h
@@ -22,8 +22,8 @@
  *
  */
 
-#ifndef LMMS_SLICERT_WAVEFORM_H
-#define LMMS_SLICERT_WAVEFORM_H
+#ifndef LMMS_GUI_SLICERT_WAVEFORM_H
+#define LMMS_GUI_SLICERT_WAVEFORM_H
 
 #include <QApplication>
 #include <QFontMetrics>
@@ -123,4 +123,4 @@ public slots:
 };
 } // namespace gui
 } // namespace lmms
-#endif // LMMS_SLICERT_WAVEFORM_H
+#endif // LMMS_GUI_SLICERT_WAVEFORM_H

From d2734c9862e6fcf222459fe54710b3661c328e83 Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Thu, 9 Nov 2023 00:08:03 +0100
Subject: [PATCH 95/99] More review changes

---
 plugins/SlicerT/SlicerT.cpp         |  2 +-
 plugins/SlicerT/SlicerTView.cpp     | 12 +++++-----
 plugins/SlicerT/SlicerTView.h       |  8 +++----
 plugins/SlicerT/SlicerTWaveform.cpp | 36 ++++++++++++++---------------
 plugins/SlicerT/SlicerTWaveform.h   |  6 ++---
 5 files changed, 32 insertions(+), 32 deletions(-)

diff --git a/plugins/SlicerT/SlicerT.cpp b/plugins/SlicerT/SlicerT.cpp
index 0fa888ec81f..7e03f2e0629 100644
--- a/plugins/SlicerT/SlicerT.cpp
+++ b/plugins/SlicerT/SlicerT.cpp
@@ -171,7 +171,7 @@ void SlicerT::findSlices()
 	for (int i = 0; i < singleChannel.size(); i++)
 	{
 		singleChannel[i] /= maxMag;
-		if (std::sign(lastValue) != std::sign(singleChannel[i]))
+		if (sign(lastValue) != sign(singleChannel[i]))
 		{
 			zeroCrossings.push_back(i);
 			lastValue = singleChannel[i];
diff --git a/plugins/SlicerT/SlicerTView.cpp b/plugins/SlicerT/SlicerTView.cpp
index 95977a1a3c9..ae1b7c96dc3 100644
--- a/plugins/SlicerT/SlicerTView.cpp
+++ b/plugins/SlicerT/SlicerTView.cpp
@@ -180,13 +180,13 @@ void SlicerTView::paintEvent(QPaintEvent* pe)
 	brush.setPen(QColor(255, 255, 255));
 	brush.setFont(QFont(brush.font().family(), 7, -1, false));
 
-	brush.drawText(8, topTextY, textBoxWidth, textBoxHeight, Qt::AlignCenter, tr("Reset"));
-	brush.drawText(188, topTextY, textBoxWidth, textBoxHeight, Qt::AlignCenter, tr("Midi"));
+	brush.drawText(8, s_topTextY, s_textBoxWidth, s_textBoxHeight, Qt::AlignCenter, tr("Reset"));
+	brush.drawText(188, s_topTextY, s_textBoxWidth, s_textBoxHeight, Qt::AlignCenter, tr("Midi"));
 
-	brush.drawText(8, bottomTextY, textBoxWidth, textBoxHeight, Qt::AlignCenter, tr("Threshold"));
-	brush.drawText(63, bottomTextY, textBoxWidth, textBoxHeight, Qt::AlignCenter, tr("Fade Out"));
-	brush.drawText(127, bottomTextY, textBoxWidth, textBoxHeight, Qt::AlignCenter, tr("BPM"));
-	brush.drawText(188, bottomTextY, textBoxWidth, textBoxHeight, Qt::AlignCenter, tr("Snap"));
+	brush.drawText(8, s_bottomTextY, s_textBoxWidth, s_textBoxHeight, Qt::AlignCenter, tr("Threshold"));
+	brush.drawText(63, s_bottomTextY, s_textBoxWidth, s_textBoxHeight, Qt::AlignCenter, tr("Fade Out"));
+	brush.drawText(127, s_bottomTextY, s_textBoxWidth, s_textBoxHeight, Qt::AlignCenter, tr("BPM"));
+	brush.drawText(188, s_bottomTextY, s_textBoxWidth, s_textBoxHeight, Qt::AlignCenter, tr("Snap"));
 }
 
 } // namespace gui
diff --git a/plugins/SlicerT/SlicerTView.h b/plugins/SlicerT/SlicerTView.h
index fbed046c613..ea2b979fc42 100644
--- a/plugins/SlicerT/SlicerTView.h
+++ b/plugins/SlicerT/SlicerTView.h
@@ -53,10 +53,10 @@ public slots:
 public:
 	SlicerTView(SlicerT* instrument, QWidget* parent);
 
-	static constexpr int textBoxHeight = 20;
-	static constexpr int textBoxWidth = 50;
-	static constexpr int topTextY = 170;
-	static constexpr int bottomTextY = 220;
+	static constexpr int s_textBoxHeight = 20;
+	static constexpr int s_textBoxWidth = 50;
+	static constexpr int s_topTextY = 170;
+	static constexpr int s_bottomTextY = 220;
 
 protected:
 	virtual void dragEnterEvent(QDragEnterEvent* dee);
diff --git a/plugins/SlicerT/SlicerTWaveform.cpp b/plugins/SlicerT/SlicerTWaveform.cpp
index 2e8a88ed4ec..1c2d85079d7 100644
--- a/plugins/SlicerT/SlicerTWaveform.cpp
+++ b/plugins/SlicerT/SlicerTWaveform.cpp
@@ -55,12 +55,12 @@ SlicerTWaveform::SlicerTWaveform(int totalWidth, int totalHeight, SlicerT* instr
 	: QWidget(parent)
 	, m_width(totalWidth)
 	, m_height(totalHeight)
-	, m_seekerWidth(totalWidth - m_seekerHorMargin * 2)
-	, m_editorHeight(totalHeight - m_seekerHeight - m_middleMargin)
+	, m_seekerWidth(totalWidth - s_seekerHorMargin * 2)
+	, m_editorHeight(totalHeight - s_seekerHeight - s_middleMargin)
 	, m_editorWidth(totalWidth)
 	, m_sliceArrow(PLUGIN_NAME::getIconPixmap("slice_indicator_arrow"))
-	, m_seeker(QPixmap(m_seekerWidth, m_seekerHeight))
-	, m_seekerWaveform(QPixmap(m_seekerWidth, m_seekerHeight))
+	, m_seeker(QPixmap(m_seekerWidth, s_seekerHeight))
+	, m_seekerWaveform(QPixmap(m_seekerWidth, s_seekerHeight))
 	, m_editorWaveform(QPixmap(m_editorWidth, m_editorHeight))
 	, m_sliceEditor(QPixmap(totalWidth, m_editorHeight))
 	, m_emptySampleIcon(embed::getIconPixmap("sample_track"))
@@ -107,7 +107,7 @@ void SlicerTWaveform::drawSeeker()
 	for (float sliceValue : m_slicerTParent->m_slicePoints)
 	{
 		float xPos = sliceValue * m_seekerWidth;
-		brush.drawLine(xPos, 0, xPos, m_seekerHeight);
+		brush.drawLine(xPos, 0, xPos, s_seekerHeight);
 	}
 
 	float seekerStartPosX = m_seekerStart * m_seekerWidth;
@@ -119,16 +119,16 @@ void SlicerTWaveform::drawSeeker()
 	float noteEndPosX = (m_noteEnd - m_noteStart) * m_seekerWidth;
 
 	brush.setPen(s_playColor);
-	brush.drawLine(noteCurrentPosX, 0, noteCurrentPosX, m_seekerHeight);
-	brush.fillRect(noteStartPosX, 0, noteEndPosX, m_seekerHeight, s_playHighlightColor);
+	brush.drawLine(noteCurrentPosX, 0, noteCurrentPosX, s_seekerHeight);
+	brush.fillRect(noteStartPosX, 0, noteEndPosX, s_seekerHeight, s_playHighlightColor);
 
-	brush.fillRect(seekerStartPosX, 0, seekerMiddleWidth - 1, m_seekerHeight, s_seekerHighlightColor);
+	brush.fillRect(seekerStartPosX, 0, seekerMiddleWidth - 1, s_seekerHeight, s_seekerHighlightColor);
 
-	brush.fillRect(0, 0, seekerStartPosX, m_seekerHeight, s_seekerShadowColor);
-	brush.fillRect(seekerEndPosX - 1, 0, m_seekerWidth, m_seekerHeight, s_seekerShadowColor);
+	brush.fillRect(0, 0, seekerStartPosX, s_seekerHeight, s_seekerShadowColor);
+	brush.fillRect(seekerEndPosX - 1, 0, m_seekerWidth, s_seekerHeight, s_seekerShadowColor);
 
 	brush.setPen(QPen(s_seekerColor, 1));
-	brush.drawRect(seekerStartPosX, 0, seekerMiddleWidth - 1, m_seekerHeight - 1); // -1 needed
+	brush.drawRect(seekerStartPosX, 0, seekerMiddleWidth - 1, s_seekerHeight - 1); // -1 needed
 }
 
 void SlicerTWaveform::drawEditorWaveform()
@@ -236,13 +236,13 @@ void SlicerTWaveform::updateUI()
 // updates the closest object and changes the cursor respectivly
 void SlicerTWaveform::updateClosest(QMouseEvent* me)
 {
-	float normalizedClickSeeker = static_cast<float>(me->x() - m_seekerHorMargin) / m_seekerWidth;
+	float normalizedClickSeeker = static_cast<float>(me->x() - s_seekerHorMargin) / m_seekerWidth;
 	float normalizedClickEditor = static_cast<float>(me->x()) / m_editorWidth;
 
 	m_closestObject = UIObjects::Nothing;
 	m_closestSlice = -1;
 
-	if (me->y() < m_seekerHeight)
+	if (me->y() < s_seekerHeight)
 	{
 		if (std::abs(normalizedClickSeeker - m_seekerStart) < s_distanceForClick)
 		{
@@ -310,7 +310,7 @@ void SlicerTWaveform::mousePressEvent(QMouseEvent* me)
 			static_cast<SlicerTView*>(parent())->openFiles();
 		}
 		// update seeker middle for correct movement
-		m_seekerMiddle = static_cast<float>(me->x() - m_seekerHorMargin) / m_seekerWidth;
+		m_seekerMiddle = static_cast<float>(me->x() - s_seekerHorMargin) / m_seekerWidth;
 		break;
 	case Qt::MouseButton::RightButton:
 		if (m_slicerTParent->m_slicePoints.size() > 2 && m_closestObject == UIObjects::SlicePoint)
@@ -341,7 +341,7 @@ void SlicerTWaveform::mouseMoveEvent(QMouseEvent* me)
 		return;
 	}
 
-	float normalizedClickSeeker = static_cast<float>(me->x() - m_seekerHorMargin) / m_seekerWidth;
+	float normalizedClickSeeker = static_cast<float>(me->x() - s_seekerHorMargin) / m_seekerWidth;
 	float normalizedClickEditor = static_cast<float>(me->x()) / m_editorWidth;
 
 	float distStart = m_seekerStart - m_seekerMiddle;
@@ -412,9 +412,9 @@ void SlicerTWaveform::wheelEvent(QWheelEvent* we)
 void SlicerTWaveform::paintEvent(QPaintEvent* pe)
 {
 	QPainter p(this);
-	p.drawPixmap(m_seekerHorMargin, 0, m_seekerWaveform);
-	p.drawPixmap(m_seekerHorMargin, 0, m_seeker);
-	p.drawPixmap(0, m_seekerHeight + m_middleMargin, m_sliceEditor);
+	p.drawPixmap(s_seekerHorMargin, 0, m_seekerWaveform);
+	p.drawPixmap(s_seekerHorMargin, 0, m_seeker);
+	p.drawPixmap(0, s_seekerHeight + s_middleMargin, m_sliceEditor);
 }
 } // namespace gui
 } // namespace lmms
diff --git a/plugins/SlicerT/SlicerTWaveform.h b/plugins/SlicerT/SlicerTWaveform.h
index b714ad93261..44c7528ef72 100644
--- a/plugins/SlicerT/SlicerTWaveform.h
+++ b/plugins/SlicerT/SlicerTWaveform.h
@@ -53,9 +53,9 @@ public slots:
 	SlicerTWaveform(int totalWidth, int totalHeight, SlicerT* instrument, QWidget* parent);
 
 	// predefined sizes
-	static constexpr int m_seekerHorMargin = 5;
-	static constexpr int m_seekerHeight = 38; // used to calcualte all vertical sizes
-	static constexpr int m_middleMargin = 6;
+	static constexpr int s_seekerHorMargin = 5;
+	static constexpr int s_seekerHeight = 38; // used to calcualte all vertical sizes
+	static constexpr int s_middleMargin = 6;
 
 
 	// interaction behavior values

From b4b64b1eebc20af64dd47354012a3d9da1c1d6d4 Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Fri, 10 Nov 2023 17:22:42 +0100
Subject: [PATCH 96/99] Renamed files

---
 plugins/SlicerT/SlicerT.cpp                         |   2 +-
 plugins/SlicerT/SlicerTView.cpp                     |   4 ++--
 plugins/SlicerT/{copyMidi.png => copy_midi.png}     | Bin
 plugins/SlicerT/{icon.png => logo.png}              | Bin
 .../SlicerT/{resetSlices.png => reset_slices.png}   | Bin
 5 files changed, 3 insertions(+), 3 deletions(-)
 rename plugins/SlicerT/{copyMidi.png => copy_midi.png} (100%)
 rename plugins/SlicerT/{icon.png => logo.png} (100%)
 rename plugins/SlicerT/{resetSlices.png => reset_slices.png} (100%)

diff --git a/plugins/SlicerT/SlicerT.cpp b/plugins/SlicerT/SlicerT.cpp
index 7e03f2e0629..04f2b05593e 100644
--- a/plugins/SlicerT/SlicerT.cpp
+++ b/plugins/SlicerT/SlicerT.cpp
@@ -46,7 +46,7 @@ Plugin::Descriptor PLUGIN_EXPORT slicert_plugin_descriptor = {
 	"Daniel Kauss Serna <daniel.kauss.serna@gmail.com>",
 	0x0100,
 	Plugin::Type::Instrument,
-	new PluginPixmapLoader("icon"),
+	new PluginPixmapLoader("logo"),
 	nullptr,
 	nullptr,
 };
diff --git a/plugins/SlicerT/SlicerTView.cpp b/plugins/SlicerT/SlicerTView.cpp
index ae1b7c96dc3..833d4b434af 100644
--- a/plugins/SlicerT/SlicerTView.cpp
+++ b/plugins/SlicerT/SlicerTView.cpp
@@ -84,13 +84,13 @@ SlicerTView::SlicerTView(SlicerT* instrument, QWidget* parent)
 
 	m_midiExportButton = new QPushButton(this);
 	m_midiExportButton->move(199, 150);
-	m_midiExportButton->setIcon(PLUGIN_NAME::getIconPixmap("copyMidi"));
+	m_midiExportButton->setIcon(PLUGIN_NAME::getIconPixmap("copy_midi"));
 	m_midiExportButton->setToolTip(tr("Copy midi pattern to clipboard"));
 	connect(m_midiExportButton, &PixmapButton::clicked, this, &SlicerTView::exportMidi);
 
 	m_resetButton = new QPushButton(this);
 	m_resetButton->move(18, 150);
-	m_resetButton->setIcon(PLUGIN_NAME::getIconPixmap("resetSlices"));
+	m_resetButton->setIcon(PLUGIN_NAME::getIconPixmap("reset_slices"));
 	m_resetButton->setToolTip(tr("Reset Slices"));
 	connect(m_resetButton, &PixmapButton::clicked, m_slicerTParent, &SlicerT::updateSlices);
 }
diff --git a/plugins/SlicerT/copyMidi.png b/plugins/SlicerT/copy_midi.png
similarity index 100%
rename from plugins/SlicerT/copyMidi.png
rename to plugins/SlicerT/copy_midi.png
diff --git a/plugins/SlicerT/icon.png b/plugins/SlicerT/logo.png
similarity index 100%
rename from plugins/SlicerT/icon.png
rename to plugins/SlicerT/logo.png
diff --git a/plugins/SlicerT/resetSlices.png b/plugins/SlicerT/reset_slices.png
similarity index 100%
rename from plugins/SlicerT/resetSlices.png
rename to plugins/SlicerT/reset_slices.png

From 1fb46183b932892eb1c7ef3aed7362850ea80a6c Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Sat, 11 Nov 2023 16:33:59 +0100
Subject: [PATCH 97/99] Full sample only at base note

---
 plugins/SlicerT/SlicerT.cpp | 14 ++++++++++----
 1 file changed, 10 insertions(+), 4 deletions(-)

diff --git a/plugins/SlicerT/SlicerT.cpp b/plugins/SlicerT/SlicerT.cpp
index 04f2b05593e..569ecd961df 100644
--- a/plugins/SlicerT/SlicerT.cpp
+++ b/plugins/SlicerT/SlicerT.cpp
@@ -78,7 +78,7 @@ void SlicerT::playNote(NotePlayHandle* handle, sampleFrame* workingBuffer)
 {
 	if (m_originalSample.frames() <= 1) { return; }
 
-	const int noteIndex = handle->key() - m_parentTrack->baseNote();
+	int noteIndex = handle->key() - m_parentTrack->baseNote();
 	const fpp_t frames = handle->framesLeftForCurrentPeriod();
 	const f_cnt_t offset = handle->noteOffset();
 	const int bpm = Engine::getSong()->getTempo();
@@ -90,16 +90,22 @@ void SlicerT::playNote(NotePlayHandle* handle, sampleFrame* workingBuffer)
 	speedRatio *= Engine::audioEngine()->processingSampleRate() / static_cast<float>(m_originalSample.sampleRate());
 
 	float sliceStart, sliceEnd;
-	if (noteIndex > m_slicePoints.size() - 2 || noteIndex < 0) // full sample if ouside range
+	if (noteIndex == 0) // full sample at base note
 	{
 		sliceStart = 0;
 		sliceEnd = 1;
 	}
-	else
+	else if (noteIndex > 0 && noteIndex < m_slicePoints.size())
 	{
+		noteIndex -= 1;
 		sliceStart = m_slicePoints[noteIndex];
 		sliceEnd = m_slicePoints[noteIndex + 1];
 	}
+	else
+	{
+		emit isPlaying(-1, 0, 0);
+		return;
+	}
 
 	if (!handle->m_pluginData) { handle->m_pluginData = new PlaybackState(sliceStart); }
 
@@ -295,7 +301,7 @@ std::vector<Note> SlicerT::getMidi()
 		float sliceEnd = totalTicks * m_slicePoints[i + 1];
 
 		Note sliceNote = Note();
-		sliceNote.setKey(i + m_parentTrack->baseNote());
+		sliceNote.setKey(i + m_parentTrack->baseNote() + 1);
 		sliceNote.setPos(sliceStart);
 		sliceNote.setLength(sliceEnd - sliceStart + 1); // + 1 so that the notes allign
 		outputNotes.push_back(sliceNote);

From bf7bdc418623b7310359d4c671d40fb1449ccb4c Mon Sep 17 00:00:00 2001
From: DanielKauss <daniel.kauss.serna@gmail.com>
Date: Sat, 11 Nov 2023 23:40:51 +0100
Subject: [PATCH 98/99] Fix memory leak

Co-authored-by: Dalton Messmer <33463986+messmerd@users.noreply.github.com>
---
 plugins/SlicerT/SlicerT.cpp | 12 +++++++++---
 plugins/SlicerT/SlicerT.h   |  1 +
 2 files changed, 10 insertions(+), 3 deletions(-)

diff --git a/plugins/SlicerT/SlicerT.cpp b/plugins/SlicerT/SlicerT.cpp
index 569ecd961df..2918265cead 100644
--- a/plugins/SlicerT/SlicerT.cpp
+++ b/plugins/SlicerT/SlicerT.cpp
@@ -108,15 +108,16 @@ void SlicerT::playNote(NotePlayHandle* handle, sampleFrame* workingBuffer)
 	}
 
 	if (!handle->m_pluginData) { handle->m_pluginData = new PlaybackState(sliceStart); }
+	auto playbackState = static_cast<PlaybackState*>(handle->m_pluginData);
 
-	float noteDone = ((PlaybackState*)handle->m_pluginData)->noteDone();
+	float noteDone = playbackState->noteDone();
 	float noteLeft = sliceEnd - noteDone;
 
 	if (noteLeft > 0)
 	{
 		int noteFrame = noteDone * m_originalSample.frames();
 
-		SRC_STATE* resampleState = static_cast<PlaybackState*>(handle->m_pluginData)->resamplingState();
+		SRC_STATE* resampleState = playbackState->resamplingState();
 		SRC_DATA resampleData;
 		resampleData.data_in = (m_originalSample.data() + noteFrame)->data();
 		resampleData.data_out = (workingBuffer + offset)->data();
@@ -127,7 +128,7 @@ void SlicerT::playNote(NotePlayHandle* handle, sampleFrame* workingBuffer)
 		src_process(resampleState, &resampleData);
 
 		float nextNoteDone = noteDone + frames * (1.0f / speedRatio) / m_originalSample.frames();
-		static_cast<PlaybackState*>(handle->m_pluginData)->setNoteDone(nextNoteDone);
+		playbackState->setNoteDone(nextNoteDone);
 
 		// exponential fade out, applyRelease() not used since it extends the note length
 		int fadeOutFrames = m_fadeOutFrames.value() / 1000.0f * Engine::audioEngine()->processingSampleRate();
@@ -149,6 +150,11 @@ void SlicerT::playNote(NotePlayHandle* handle, sampleFrame* workingBuffer)
 	else { emit isPlaying(-1, 0, 0); }
 }
 
+void SlicerT::deleteNotePluginData(NotePlayHandle* handle)
+{
+	delete static_cast<PlaybackState*>(handle->m_pluginData);
+}
+
 // uses the spectral flux to determine the change in magnitude
 // resources:
 // http://www.iro.umontreal.ca/~pift6080/H09/documents/papers/bello_onset_tutorial.pdf
diff --git a/plugins/SlicerT/SlicerT.h b/plugins/SlicerT/SlicerT.h
index 73c4e9b5c6c..6ca10349c72 100644
--- a/plugins/SlicerT/SlicerT.h
+++ b/plugins/SlicerT/SlicerT.h
@@ -75,6 +75,7 @@ public slots:
 	SlicerT(InstrumentTrack* instrumentTrack);
 
 	void playNote(NotePlayHandle* handle, sampleFrame* workingBuffer) override;
+void deleteNotePluginData(NotePlayHandle* handle) override;
 
 	void saveSettings(QDomDocument& document, QDomElement& element) override;
 	void loadSettings(const QDomElement& element) override;

From 4894e9541de440610d5ce975d800671861cac40b Mon Sep 17 00:00:00 2001
From: Daniel Kauss <manuel.eckol2001@gmail.com>
Date: Sat, 11 Nov 2023 23:46:08 +0100
Subject: [PATCH 99/99] Style fixes

---
 plugins/SlicerT/SlicerT.h           | 2 +-
 plugins/SlicerT/SlicerTWaveform.cpp | 4 +---
 plugins/SlicerT/SlicerTWaveform.h   | 3 +--
 3 files changed, 3 insertions(+), 6 deletions(-)

diff --git a/plugins/SlicerT/SlicerT.h b/plugins/SlicerT/SlicerT.h
index 6ca10349c72..8671eecd1f8 100644
--- a/plugins/SlicerT/SlicerT.h
+++ b/plugins/SlicerT/SlicerT.h
@@ -75,7 +75,7 @@ public slots:
 	SlicerT(InstrumentTrack* instrumentTrack);
 
 	void playNote(NotePlayHandle* handle, sampleFrame* workingBuffer) override;
-void deleteNotePluginData(NotePlayHandle* handle) override;
+	void deleteNotePluginData(NotePlayHandle* handle) override;
 
 	void saveSettings(QDomDocument& document, QDomElement& element) override;
 	void loadSettings(const QDomElement& element) override;
diff --git a/plugins/SlicerT/SlicerTWaveform.cpp b/plugins/SlicerT/SlicerTWaveform.cpp
index 1c2d85079d7..6685f4f8cec 100644
--- a/plugins/SlicerT/SlicerTWaveform.cpp
+++ b/plugins/SlicerT/SlicerTWaveform.cpp
@@ -306,9 +306,7 @@ void SlicerTWaveform::mousePressEvent(QMouseEvent* me)
 		drawEditorWaveform();
 		break;
 	case Qt::MouseButton::LeftButton:
-		if (m_slicerTParent->m_originalSample.frames() <= 1) {
-			static_cast<SlicerTView*>(parent())->openFiles();
-		}
+		if (m_slicerTParent->m_originalSample.frames() <= 1) { static_cast<SlicerTView*>(parent())->openFiles(); }
 		// update seeker middle for correct movement
 		m_seekerMiddle = static_cast<float>(me->x() - s_seekerHorMargin) / m_seekerWidth;
 		break;
diff --git a/plugins/SlicerT/SlicerTWaveform.h b/plugins/SlicerT/SlicerTWaveform.h
index 44c7528ef72..6478e7f8684 100644
--- a/plugins/SlicerT/SlicerTWaveform.h
+++ b/plugins/SlicerT/SlicerTWaveform.h
@@ -26,11 +26,11 @@
 #define LMMS_GUI_SLICERT_WAVEFORM_H
 
 #include <QApplication>
+#include <QElapsedTimer>
 #include <QFontMetrics>
 #include <QInputDialog>
 #include <QMouseEvent>
 #include <QPainter>
-#include <QElapsedTimer>
 
 #include "Instrument.h"
 #include "SampleBuffer.h"
@@ -57,7 +57,6 @@ public slots:
 	static constexpr int s_seekerHeight = 38; // used to calcualte all vertical sizes
 	static constexpr int s_middleMargin = 6;
 
-
 	// interaction behavior values
 	static constexpr float s_distanceForClick = 0.02f;
 	static constexpr float s_minSeekerDistance = 0.13f;