ITAUPConvolution.h 8.14 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234
/*
 * ----------------------------------------------------------------
 *
 *		ITA core libs
 *		(c) Copyright Institute of Technical Acoustics (ITA)
 *		RWTH Aachen University, Germany, 2015-2017
 *
 * ----------------------------------------------------------------
 *				    ____  __________  _______
 *				   //  / //__   ___/ //  _   |
 *				  //  /    //  /    //  /_|  |
 *				 //  /    //  /    //  ___   |
 *				//__/    //__/    //__/   |__|
 *
 * ----------------------------------------------------------------
 *
 */

#ifndef INCLUDE_WATCHER_DSMBC_CONVOLVER
#define INCLUDE_WATCHER_DSMBC_CONVOLVER

#include <ITAConvolutionDefinitions.h>

#include <ITACriticalSection.h>
#include <ITAUncopyable.h>
#include <vector>
#include <ITAUPTrigger.h>

#include <tbb/concurrent_queue.h>

#include <atomic>

// Vorwürtsdeklarationen
class ITAUPFilter;
class ITAUPFilterPool;
class ITAFFT;

/**
 * Diese Klasse realisiert einen schnellen (einkanaligen) Falter (dynamic single-channel multi-block convolver),
 * welcher die effiziente Overlap-Save Blockfaltung zusammen mit einer frequency-domain delay-line (FDL)
 * benutzt um eine Impulsantwortet zu falten, welche in mehrere gleichlange Teile zerlegt wird.
 * Dieser Ansatz ermüglicht eine wesentlich grüüere Leistung als ein einfacher Blockfaltungsansatz,
 * bei welchem die komplette Impulsantwort mit einem Block gefaltet werden. Der Falter ist dynamisch,
 * d.h. er erlaubt den Austausch der Filter zur Laufzeit bzw. Streamingzeit. Der Austausch der Filter
 * geschieht entweder durch hartes Umschalten oder überblendung im Zeitbereich.
 *
 * Nebenlüufigkeit & Synchronisation:
 *
 * Folgende Methoden sind synchronisiert:
 *
 * - getFilterPool, setFilterPool, requestFilter, releaseFilter => Blocking aber leichtgewichtig, reentrant
 * - getFilterExchangeMode, setFilterExchangeMode, getFilterCrossfadeLength, setFilterCrossfadeLength,
 *   getActiveFilter, exchangeFilter => Non-blocking und wait-free, reentrant
 * - process => Non-blocking, wait-free aber NICHT REENTRANT (!!)
 *
 * Alle anderen Methoden sind nicht synchronisiert.
 *
 * Müchtest Du mehr zu den Details wissen? Frag mich! -> Frank.Wefers@akustik.rwth-aachen.de
 */

class ITA_CONVOLUTION_API ITAUPConvolution : public ITAUncopyable
{
public:
	//! Austausch-Modi
	enum
	{
		SWITCH = 0,					//!< Hartes Umschalten
		CROSSFADE_LINEAR,			//!< Lineare Kreuzblende
		CROSSFADE_COSINE_SQUARE		//!< Cosinus-Quadrat Kreuzblende
	};

	//! Ausgabe-Modi
	enum
	{
		OUTPUT_OVERWRITE = 0,		//!< Daten im Ausgabepuffer mit neuen Daten überschreiben
		OUTPUT_MIX,					//!< Neue Daten in den Ausgabepuffer einmischen
	};

	static const int AUTO = -1;

	//! Standard-Konstruktor
	/**
	 * Erzeugt einen Falter der seinen eigenen Filterpool betreibt
	 */
	ITAUPConvolution();

	//! Initialierungs-Konstruktor
	/**
	 * Erzeugt einen Falter.
	 *
	 * \param iBlocklength		Blocklänge [in Samples]
	 * \param iMaxFilterlength  Maximale Filterlänge [Anzahl Filterkoeffizienten]
	 */
	ITAUPConvolution( const int iBlocklength, const int iMaxFilterlength, ITAUPFilterPool* pFilterPool = NULL );

	//! Destruktor
	virtual ~ITAUPConvolution();

	//! Initialisieren
	/**
	 * Initialisiert einen Falter.
	 *
	 * \param iBlocklength		Blocklänge [in Samples]
	 * \param iMaxFilterlength  Maximale Filterlänge [Anzahl Filterkoeffizienten]
	 */
	void init( const int iBlocklength, const int iFilterLength );

	//! Blocklänge zurückgeben
	int getBlocklength() const;

	//! Maximale Filterlänge [Anzahl Filterkoeffizienten] zurückgeben
	int getMaxFilterlength() const;

	//! Trigger für den Filteraustausch zurückgeben (NULL falls keiner zugeordnet)
	const ITAUPTrigger* getFilterExchangeTrigger() const;

	//! Trigger für den Filteraustausch setzen
	void setFilterExchangeTrigger( const ITAUPTrigger* pTrigger );

	//! Filteraustausch-Modus zurückgeben
	int getFilterExchangeMode();

	//! Filteraustausch-Modus setzen
	void setFilterExchangeMode( const int iMode );

	//! überblendlänge [Samples] des Filteraustauschs zurückgeben
	int getFilterCrossfadeLength();

	//! überblendlänge [Samples] für den Filteraustausch setzen
	void setFilterCrossfadeLength( const int iLength );

	//! Verstärkung zurückgeben
	float getGain() const;

	//! Verstärkung setzen
	// Hinweis: Falls bSetImmediately==true gesetzt, wird die Verstärkung nicht
	// dynamisch angepasst, sondern hart auf den angegebenen Wert gesetzt.
	void setGain( const float fGain, const bool bSetImmediately = false );

	//! Filterpool zurückgeben
	ITAUPFilterPool* getFilterPool() const;

	//! Filterpool setzen
	/**
	 * NULL => Falter-eigenen Pool benutzen
	 */
	void setFilterPool( ITAUPFilterPool* pFilterPool );

	//! Freies Filter anfordern
	ITAUPFilter* requestFilter();

	//! Filter wieder zur anderweitigen Benutzung freigeben
	void releaseFilter( ITAUPFilter* pFilter );

	//! Aktives Filter zurückgeben
	/**
	 * Das aktive Filter ist jenes, welches der Falter momentan benutzt.
	 */
	ITAUPFilter* getActiveFilter();

	//! Filter austauschen
	/**
	 * Hinweis: Nullzeiger => Aktives Filter entfernen
	 */
	void exchangeFilter( ITAUPFilter* pNewFilter, const int iExchangeMode = AUTO, const int iCrossfadeLength = AUTO );

	//! Löscht alle internen Samplepuffer
	void clear();

	//! Faltungsmethode
	/**
	 * Nimmt einen neuen Block Eingangsdaten entgegen und faltet ihn mit der Impulsantwortet.
	 * Das (partielle) Ausgangssignal wird als Block im Zielarray gespeichert.
	 *
	 * \param pfInputData   Array der Eingangsdaten (Exakt soviele Elemente wie die Blocklänge ist)
	 * \param pfOutputData  Array der Ausgangsdaten (Exakt soviele Elemente wie die Blocklänge ist)
	 * \param iOutputMode   Ausgabemodus (überschreiben oder Einmischen)
	 */

	// TODO: Hier wird Austausch durchgeführt!
	void process( const float* pfInputData, float* pfOutputData, const int iOutputMode = OUTPUT_OVERWRITE );

	//! Faltungsmethode (Erweitert)
	/**
	 * Nimmt einen neuen Block Eingangsdaten entgegen und faltet ihn mit der Impulsantwortet.
	 * Das (partielle) Ausgangssignal wird als Block im Zielarray gespeichert.
	 *
	 * \param pfInputData   Array der Eingangsdaten
	 * \param iInputLength  Anzahl der Samples in den Eingangsdaten
	 * \param pfOutputData  Array der Ausgangsdaten (Exakt soviele Elemente wie die Blocklänge ist)
	 * \param iOutputLength Anzahl der Samples in den Ausgabedaten
	 * \param iOutputMode   Ausgabemodus (überschreiben oder Einmischen)
	 */

	void process( const float* pfInputData, const int iInputLength, float* pfOutputData, const int iOutputLength, const int iOutputMode = OUTPUT_OVERWRITE );

private:
	typedef struct
	{
		ITAUPFilter* pFilter;
		int iExchangeMode;
		int iCrossfadeLength;
	} FilterUpdate;

	int m_iBlocklength;
	int m_iMaxFilterlength;

	std::atomic< int > m_iExchangeMode;				// Austauschmodus
	std::atomic< int > m_iCrossfadeLength;			// überblendlänge
	std::atomic< float > m_fCurrentGain;				// Aktuelle Verstärkung
	std::atomic< float > m_fNewGain;					// Gewünschte Verstärkung
	std::atomic< ITAUPFilter* > m_pCurrentFilter;	// Aktives Filter
	tbb::strict_ppl::concurrent_queue<FilterUpdate> m_qExchangeFilters;	// Queue: Nächste Filter zum Austausch

	float *m_pfTimeInputBuffer;					// Eingangspuffer (Zeitbereich)
	float *m_pfTimeOutputBuffer1;				// Ausgangspuffer (Zeitbereich)
	float *m_pfTimeOutputBuffer2;				// Ausgangspuffer (Zeitbereich)
	float *m_pfFreqAuxBuffer;					// Hilfspuffer (Frequenz-bereich)
	float *m_pfFreqMixdownBuffer;				// Mischpuffer (Frequenz-bereich)
	int m_iFreqCoeffs;							// Anzahl DFT-Koeffizienten (Symetrien eingerechnet)
	std::vector< float* > m_vpfFreqDelayLine;		// Frequency-domain delay line (FDL)
	ITAFFT *m_pFFT, *m_pIFFT;					// FFT, IFFT der Daten
	ITACriticalSection m_csPool;				// Exklusiver Zugriff auf den Filterpool

	ITAUPFilterPool* m_pCurrentPool;			// Gesetzer Filterpool
	ITAUPFilterPool* m_pOwnPool;				// Falter-eigener Filterpool
	ITAUPTriggerWatch m_oTriggerWatch;			// TriggerWatch für den Filteraustausch


	void copyOutputApplyGain1( float* pfDest, const float* pfSrc, const int iNumSamples, const int iOutputMode );
	void copyOutputApplyGain2( float* pfDest, const float* pfSrc1, const float* pfSrc2, const int iOutputLength, const int iCrossfadeLength, const int iOutputMode );
};

#endif // INCLUDE_WATCHER_DSMBC_CONVOLVER