Commit 24de9ee3 authored by Dipl.-Ing. Jonas Stienen's avatar Dipl.-Ing. Jonas Stienen
Browse files

Cleanup, removing unused files

parent 3fd15fa0
#include "VAAudiostreamVariableDelayLine.h"
#include <cassert>
CVAAudiostreamVariableDelayLine::CVAAudiostreamVariableDelayLine(double dSamplerate,
int iBlocklength,
float fReservedMaxDelaySamples,
int iAlgorithm)
: CVAVariableDelayLine(dSamplerate, iBlocklength, fReservedMaxDelaySamples, iAlgorithm),
ITADatasourceRealization( 1, dSamplerate, (unsigned int) iBlocklength )
{ }
CVAAudiostreamVariableDelayLine::~CVAAudiostreamVariableDelayLine();
void CVAAudiostreamVariableDelayLine::SetInput(ITADatasource* pdsInput) {
}
void CVAAudiostreamVariableDelayLine::ProcessStream();
void CVAAudiostreamVariableDelayLine::PostIncrementBlockPointer();
CVAAudiostreamJoin::CVAAudiostreamJoin(double dSamplerate, int iChannels, int iBlocklength)
: ITADatasourceRealization( (unsigned int) iChannels, dSamplerate, (unsigned int) iBlocklength )
{ }
CVAAudiostreamJoin::~CVAAudiostreamJoin() { }
void CVAAudiostreamJoin::AddInput(ITADatasource* pdsInput) {
assert( pdsInput != NULL );
assert( pdsInput->GetSamplerate() == m_dSamplerate );
assert( pdsInput->GetNumberOfChannels() == m_uiChannels );
assert( pdsInput->GetBlocklength() == m_uiBlocklength );
m_csInputs.enter();
m_spInputsNew.insert( pdsInput );
m_csInputs.leave();
}
void CVAAudiostreamJoin::RemoveInput(ITADatasource* pdsInput) {
m_csInputs.enter();
m_spInputsCur.erase( pdsInput );
m_csInputs.leave();
}
void CVAAudiostreamJoin::ProcessStream() {
m_csInputs.enter();
// Neue Quellen bernehmen
for (std::set<ITADatasource*>::const_iterator cit=m_spInputsNew.begin();
cit!=m_spInputsNew.end(); ++cit)
m_spInputsCur.insert( *cit );
m_spInputsNew.clear();
// Signale aufaddieren
for (unsigned int c=0; c<m_uiChannels; c++) {
float* pfOutputData = GetWritePointer(c);
fm_zero(pfOutputData, m_uiBlocklength);
// ber die Eingnge iterieren
for (std::set<ITADatasource*>::iterator it=m_spInputsCur.begin();
it!=m_spInputsCur.end(); ++it) {
const float* pfInputData = (*it)->GetBlockPointer(c);
fm_add(pfOutputData, pfInputData, m_uiBlocklength);
}
}
m_csInputs.leave();
}
void CVAAudiostreamJoin::PostIncrementBlockPointer() {
m_csInputs.enter();
for (std::set<ITADatasource*>::iterator it=m_spInputsCur.begin();
it!=m_spInputsCur.end(); ++it)
(*it)->IncrementBlockPointer();
m_csInputs.leave();
}
/*
*
* VVV VVV A
* VVV VVV AAA Virtual Acoustics
* VVV VVV AAA Real-time auralisation for virtual reality
* VVV VVV AAA
* VVVVVV AAA (c) Copyright Institut fr Technische Akustik (ITA)
* VVVV AAA RWTH Aachen (http://www.akustik.rwth-aachen.de)
*
* ---------------------------------------------------------------------------------
*
* Datei: VAAudiostreamVariableDelayLine.h
*
* Zweck: Audiostreamnig-Adapter fr variable delay-lines (VDL)
*
* Autor(en): Frank Wefers (Frank.Wefers@akustik.rwth-aachen.de
*
* ---------------------------------------------------------------------------------
*/
// $Id: VAAudiostreamVariableDelayLine.h 2729 2012-06-26 13:23:36Z fwefers $
#ifndef __VA_AUDIOSTREAM_VARIABLEDELAYLINE__
#define __VA_AUDIOSTREAM_VARIABLEDELAYLINE__
#include "VAVariableDelayLine.h"
#include <ITADataSourceRealization.h>
/*
* Kleidet die Implementierung der Klasse CVAVariableDelayLine
* in das Audiostreaming-Kostm der ITADatasources ein (per inheritance)
*/
class CVAAudiostreamVariableDelayLine
: public CVAVariableDelayLine, public ITADatasourceRealization {
public:
CVAAudiostreamVariableDelayLine(double dSamplerate,
int iBlocklength,
float fReservedMaxDelaySamples,
int iAlgorithm);
virtual ~CVAAudiostreamVariableDelayLine();
// Eingang setzen
void SetInput(ITADatasource* pdsInput);
// -= Redefinierte Methoden der Klasse "ITADatasourceRealization" =-
void ProcessStream();
void PostIncrementBlockPointer();
private:
};
#endif // __VA_AUDIOSTREAM_JOIN__
/*
*
* VVV VVV A
* VVV VVV AAA Virtual Acoustics
* VVV VVV AAA Real-time auralisation for virtual reality
* VVV VVV AAA
* VVVVVV AAA (c) Copyright Institut fr Technische Akustik (ITA)
* VVVV AAA RWTH Aachen (http://www.akustik.rwth-aachen.de)
*
* ---------------------------------------------------------------------------------
*
* Datei: VAFilter.cpp
*
* Zweck: Klasse fr Filter Impulsantworten
*
* Autor(en): Frank Wefers (Frank.Wefers@akustik.rwth-aachen.de
*
* ---------------------------------------------------------------------------------
*/
// $Id: VAFilter.cpp 2729 2012-06-26 13:23:36Z fwefers $
#include "VAFilter.h"
/*
*
* VVV VVV A
* VVV VVV AAA Virtual Acoustics
* VVV VVV AAA Real-time auralisation for virtual reality
* VVV VVV AAA
* VVVVVV AAA (c) Copyright Institut fr Technische Akustik (ITA)
* VVVV AAA RWTH Aachen (http://www.akustik.rwth-aachen.de)
*
* ---------------------------------------------------------------------------------
*
* Datei: VAFilter.h
*
* Zweck: Klasse fr Filter Impulsantworten
*
* Autor(en): Frank Wefers (Frank.Wefers@akustik.rwth-aachen.de
*
* ---------------------------------------------------------------------------------
*/
// $Id: VAFilter.h 2729 2012-06-26 13:23:36Z fwefers $
#ifndef __VA_FILTER__
#define __VA_FILTER__
#include <ITASampleFrame.h>
/**
* ...
*/
class CVAFilter {
public:
ITASampleFrame sfFilter; // Filterkoeffizienten
double dSamplerate; // Abtastrate [Hz]
float fDelay; // Verzgerung [Samples]
};
#endif // __VA_FILTER__
This diff is collapsed.
/*
*
* VVV VVV A
* VVV VVV AAA Virtual Acoustics
* VVV VVV AAA Real-time auralisation for virtual reality
* VVV VVV AAA
* VVVVVV AAA (c) Copyright Institut fr Technische Akustik (ITA)
* VVVV AAA RWTH Aachen (http://www.akustik.rwth-aachen.de)
*
* ---------------------------------------------------------------------------------
*
* Datei: VAFreefieldAudiostreamProcessor.h
*
* Zweck: Freifeld-Verarbeiter einer Streaming-Kette
*
* Autor(en): Frank Wefers (Frank.Wefers@akustik.rwth-aachen.de)
*
* ---------------------------------------------------------------------------------
*/
// $Id: VAFreefieldAudiostreamProcessor.h 3369 2013-07-04 15:45:10Z stienen $
#ifndef __VA_FREEFIELDAUDIOSTREAMPROCESSOR__
#define __VA_FREEFIELDAUDIOSTREAMPROCESSOR__
#include <VAObjectPool.h>
#include <VAReferenceableObject.h>
#include "../VACoreBuildConfig.h"
#include "../VACoreConfig.h"
#include "../Motion/VAMotionModelBase.h"
#include "VAAtmosphere.h"
#include "VATemporalVariations.h"
#include "VAThirdOctaveFIRFilterGenerator.h"
#include "VAThirdOctaveFilterbank.h"
#include "../Scene/VAScene.h"
#include <ITAAtomicPrimitives.h>
#include <ITAClock.h>
#include <ITACriticalSection.h>
#include <ITADatasourceRealization.h>
#include <ITASampleBuffer.h>
#include <ITAStopwatch.h>
#include <cassert>
#include <fstream>
#include <iomanip>
#include <set>
#include <VistaInterProcComm/Concurrency/VistaThreadEvent.h>
#include <tbb/atomic.h>
#include <tbb/concurrent_queue.h>
class CVAAudioDriverConfig;
class CVAAudiostreamTracker;
class CVACoreImpl;
class CVAVariableDelayLine;
class CVAAudioSignalSourceManager;
class CVASceneManager;
class CVASceneState;
class CVASoundSourceDesc;
class DSMBCConvolver;
class ITABufferedAudiofileWriter;
class IVAObjectPool;
//! Datenklasse fr Positions- und Geschwindigkeitsdaten zu einem bestimmten Zeitpunkt
class CVAPositionVelocityKey {
public:
double t; //!< Zeit [s]
RG_Vector p; //!< Positionsvektor [m]
RG_Vector v; //!< Geschwindigkeitsvektor [m/s]
//! Konstruktor
CVAPositionVelocityKey() {
}
//! Initialisierungskonstruktor [Source]
/**
* Setzt interne Daten durch Abgreifen aus dem Quellen-Status
* \param pState Status der Quelle (Zeit-Schnappschuss)
*/
CVAPositionVelocityKey(const CVASoundSourceState* pState) {
RG_Vector dummy;
t = pState->GetModificationTime();
pState->GetMotionState()->GetPositionOrientationVelocityVU(p, dummy, dummy, v);
}
//! Initialisierungskonstruktor [Listener]
/**
* Setzt interne Daten durch Abgreifen aus dem Hrer-Status
* \param pState Status des Hrers (Zeit-Schnappschuss)
*/
CVAPositionVelocityKey(const CVAListenerState* pState) {
RG_Vector dummy;
t = pState->GetModificationTime();
pState->GetMotionState()->GetPositionOrientationVelocityVU(p, dummy, dummy, v);
}
//! Extrapolate a position (assuming constant motion)
/**
* Fhrt eine Schtzung der Position aufgrund einer
* linearen Bewegung durch mit Hilfe der internen
* Informationen ber Position und Bewegung durch.
* \param te Angeforderte Zeit [s] (muss in der Zukunft liegen)
* \param pe Extrapolierte Position [m] (Call-by-Reference)
*/
void ExtrapolatePosition(const double te, RG_Vector& pe) {
assert( te >= t );
// Linear extrapolation
double dt = te-t;
pe.x = p.x + (float) (dt*v.x);
pe.y = p.y + (float) (dt*v.y);
pe.z = p.z + (float) (dt*v.z);
}
};
//! Hilfsklasse fr das Datenlogging
class Logger {
public:
//! Datenstruktur einer Logger-Zeile
typedef struct {
int iIndex; // 1
double dStreamTime; // 2
double dSysTime; // 3
double dPosX; // 4
double dPosY; // 5
double dPosZ; // 6
double dDist; // 7
} Data;
std::ofstream oDebugOut;
int iDebugCnt;
std::vector<Data> vData;
bool bActive;
Logger() : bActive(false) {
}
Logger(const std::string& sFilename) : bActive(true) {
oDebugOut.open(sFilename);
iDebugCnt = 0;
vData.reserve(10000);
}
~Logger() {
if (bActive) {
oDebugOut << "# [0] Stream time (s), [1] Sys time (s), [2] x (m), [3] y (m), [3] z (m), [4] dist (m)" << std::endl;
for (std::vector<Data>::const_iterator cit=vData.begin(); cit!=vData.end(); ++cit)
oDebugOut << cit->iIndex << "\t"
<< std::setprecision(12) << cit->dStreamTime << "\t"
<< std::setprecision(12) << cit->dSysTime << "\t"
<< std::setprecision(12) << cit->dPosX << "\t"
<< std::setprecision(12) << cit->dPosY << "\t"
<< std::setprecision(12) << cit->dPosZ << "\t"
<< std::setprecision(12) << cit->dDist << "\n";
oDebugOut.close();
}
}
void log(Data& oData) {
if (!bActive) return;
oData.iIndex = ++iDebugCnt;
vData.push_back(oData);
}
};
//! Datenklasse einer Freifeld-Streaming-Kette
/**
* Datenklasse welche die Elemente (Eingabepuffer, Falter, VDL)
* einer Streaming-Kette fr einen einzigen Schallpfad beschreibt
*/
class CVAFreefieldAudiostreamChain : public CVAPoolObject {
public:
CVASoundSourceDesc* pSoundSourceDesc; //!< Statische Beschreibung der Quelle
CVAThirdOctaveFilterbank* pTOFilterBank; //!< Terzfilterbank
DSMBCConvolver* pConvolverHRIRCh0; //!< HRTF Kanal 0
DSMBCConvolver* pConvolverHRIRCh1; //!< HRTF Kanal 1
CVAVariableDelayLine* pVDL; //!< Variable Verzgerungsleitung
#if (VACORE_WITH_RAVEN==1)
DSMBCConvolver* pConvolverReverberationCh0; //!< Nachhallfilter Kanal 0
DSMBCConvolver* pConvolverReverberationCh1; //!< Nachhallfilter Kanal 1
#endif // VACORE_WITH_RAVEN
#if (VACORE_RENDER_GROUND_REFLECTION==1)
//! Struktur zur Umsetzung der Bodenreflexion [Fluglrm]
struct {
CVAThirdOctaveFilterbank* pTOFilterBank;
DSMBCConvolver* pConvolverHRIRCh0;
DSMBCConvolver* pConvolverHRIRCh1;
CVAVariableDelayLine* pVDL;
} xGroundRefl;
#endif // VACORE_GROUND_REFLECTION
CVAPositionVelocityKey oCurSourceKey; //!< Aktuelle Position der Quelle aus Sicht des Empfngers (retardierte Quelle)
CVAPositionVelocityKey oCurListenerKey; //!< Aktuelle Position des Empfngers
ITAAtomicFloat oSourceVolume; //!< Quelllautstrke
ITAAtomicBool* pSourceMuted; //!< Muting flag
ITAAtomicBool* pSourcePOInit; //!< Pos./Orient. init flag
tbb::concurrent_queue<CVAPositionVelocityKey> qNewSourceKeys; //!< Liste an vorangegangenen Quellenpositionen und -geschwindigkeiten
tbb::concurrent_queue<CVAPositionVelocityKey> qNewListenerKeys; //!< Liste an vorangegangenen Hrerpositionen und -geschwindigkeiten
CVABasicMotionModel oSourceMotion; //!< Bewegungsmodell fr die Quelle
CVABasicMotionModel oListenerMotion; //!< Bewegungsmodell fr den Hrer
tbb::atomic<int> iAuralizationMode; //!< Modus der Auralisierung
tbb::concurrent_queue<CVAThirdOctaveMagnitudes> qNewTOGains; //!< Queue mit neuen Terzbandkoeffizienten
CVAThirdOctaveMagnitudes oCurTOGains; //!< Aktuelle Terzbandkoeffizienten
int iSourceID;
int iListenerID;
//! Desktruktor
virtual ~CVAFreefieldAudiostreamChain();
void PreRequest()
{
oSourceMotion.Reset();
oListenerMotion.Reset();
}
//! Initialisiert den Prozessor
/**
* Erstellt alle ntigen Instanzen, damit das Audiostream-Processing starten kann
*
* \param pSoundSourceDesc Beschreibung der Schallquelle
* \param pSourceMuteFlag Quelle zunchst stumm geschaltet?
* \param pSourcePOInitFlag bernehmen der Position und Orientierung fr die Quelle?
*/
void Initialize(int iSourceID, int iListenerID, CVASoundSourceDesc* pSoundSourceDesc,
ITAAtomicBool* pSourceMuteFlag,
ITAAtomicBool* pSourcePOInitFlag);
//! Finalisiert den Prozessor
void Finalize();
private:
//! Standard-Konstruktor deaktivieren
CVAFreefieldAudiostreamChain();
//! Konstruktor
CVAFreefieldAudiostreamChain(double dSamplerate,
int iBlocklength,
int iHRIRFilterLength,
int iDirFilterLength,
int iReverbFilterLength);
friend class CVAFreefieldAudiostreamChainFactory;
};
//! Factory fr Ketten
class CVAFreefieldAudiostreamChainFactory : public IVAPoolObjectFactory {
public:
//! Konstruktor
CVAFreefieldAudiostreamChainFactory(double dSamplerate,
int iBlocklength,
int iHRIRFilterLength,
int iDirFilterLength,
int iReverbFilterLength)
: m_dSamplerate(dSamplerate),
m_iBlocklength(iBlocklength),
m_iHRIRFilterLength(iHRIRFilterLength),
m_iDirFilterLength(iDirFilterLength),
m_iReverbFilterLength(iReverbFilterLength)
{}
//! Erstellt eine Streaming-Kette fr den Objekt-Pool
CVAPoolObject* CreatePoolObject() {
return new CVAFreefieldAudiostreamChain(m_dSamplerate, m_iBlocklength, m_iHRIRFilterLength, m_iDirFilterLength, m_iReverbFilterLength);
}
private:
double m_dSamplerate; //!< Abtastrate
int m_iBlocklength; //!< Blocklnge
int m_iHRIRFilterLength; //!< Filterlnge der HRIR
int m_iDirFilterLength; //!< Filterlnge der Richtcharakteristik
int m_iReverbFilterLength; //!< Filterlnge des Nachhalls
};
//! Datenklasse zur Verwaltung und Verarbeitung beliebig vieler Freifeld-Streaming-Ketten
/**
* Datenklasse, welche die zugehrigen Freifeld-Streaming-Ketten verwaltet
* und verarbeiten lsst.
*/
class CVAFreefieldAudiostreamProcessor : public ITADatasourceRealization {
public:
//! Konstruktor der Prozessors
/**
* \param pCoreConfig Zeiger zur Konfigurationsklasse des VACores
* \param pSceneManager Zeiger zum Szenen-Verwalter
* \param pSignalSourceManager Zeiger zur Verwaltungsinstanz der Quellen
*/
CVAFreefieldAudiostreamProcessor(CVACoreImpl* pParentCore,
CVASceneManager* pSceneManager,
CVAAudioSignalSourceManager* pSignalSourceManager);
//! Destruktor
~CVAFreefieldAudiostreamProcessor();
//! Setter fr den Audiostream-Tracker (Informationen ber den Stream)
void SetStreamTracker(CVAAudiostreamTracker* pAudiostreamTracker);
//! Neue Filterkette erzeugen
/**
* Erstellt alle Objekte, die zur Erzeugung einer Filterkette bentigt werden.
*
* \param iSourceID ID der Quelle
* \param iListenerID ID des Hrers
*
* \return Zeiger auf die Instanz der Filterkette
*/
CVAFreefieldAudiostreamChain* CreateFilterChain(int iSourceID, int iListenerID);
//! Zurcksetzen. Lscht smtliche Filterketten.
void Reset();
//! Filterkette hinzufgen
void AddFilterChain(CVAFreefieldAudiostreamChain* pChain);
//! Filterkette entfernen
void RemoveFilterChain(CVAFreefieldAudiostreamChain* pChain);
//! Warten bis im Streaming-Kontext die nderung an den Ketten bernommen wurde [blocking]
void SyncFilterChains();
//! Ausnutzung des Stream-Processing-Timebudget [%] zurckgeben
float GetDSPLoad() const;
// -= Redefinierte Methoden der Klasse "ITADatasourceRealization" =-
//! Process-Verarbeitungsschritt, die pro Zyklus aufgerufen wird
void ProcessStream(const ITAStreamInfo* pStreamInfo);
//! Methode, die nach Erhhung des Blockpointers aufgerufen wird
void PostIncrementBlockPointer();
private:
CVACoreImpl* m_pParentCore;
const CVACoreConfig* m_pCoreConfig; //!< Core-Konfigurationsdaten
CVAAudiostreamTracker* m_pAudiostreamTracker; //!< Audiostream-Tracker
CVASceneManager* m_pSceneMan; //!< Szenen-Verwalter
CVAAudioSignalSourceManager* m_pSignalSourceMan; //!< Quellen-Verwalter
ITASampleBuffer m_sbTempBuf1;
ITASampleBuffer m_sbTempBuf2;
ITASampleBuffer m_sbZeros;
ITAAtomicFloat m_fOutputGain; //!< Ausgabelautstrke
ITAAtomicFloat m_fDSPLoad; //!< Auslastung des Prozessorss
//VistaThreadEvent m_evChainsUpdated;
CVAAtmosphericTemporalVariantions m_oTemporalNoise; //!< Temporale Verfrbungen
CVAThirdOctaveMagnitudes m_oTOTempNoise; //!< Terzband-Daten der Temporalen Verfrbung
int m_iTemporalNoiseCount;
int m_iTemporalNoiseCycle;
CVAFreefieldAudiostreamChainFactory* m_pChainFactory;
IVAObjectPool* m_pChainPool;
std::set<CVAFreefieldAudiostreamChain*> m_spChainsExt; //!< External chain container
std::set<CVAFreefieldAudiostreamChain*> m_spChainsInt; //!< Audio thread internal chain container
tbb::concurrent_queue<CVAFreefieldAudiostreamChain*> m_qpNewChains; //!< Lock-free queue: New chains
tbb::concurrent_queue<CVAFreefieldAudiostreamChain*> m_qpDelReqChains; //!< Lock-free queue: Request delete chains
ITAAtomicBool m_bResetChains; //!< Flag for audio thread to remove all chains at once
ITAAtomicInt m_iStreamCounter; //!< Counts the number of processed stream blocks
VistaThreadEvent m_evStreamCounterInc; //!< Event: Stream counter incremented
ITABufferedAudiofileWriter* m_pInputWriter; //!< Schreibt den Eingangsdatenstrom in eine Datei
// Debug stuff
ITAStopwatch m_swProcessStream, m_swProcessStreamChain, m_swProbe, m_swProcessStreamPreps,
m_swProcessStreamChainMotion, m_swProcessStreamChainGain, m_swProcessStreamChainVDL,
m_swProcessStreamChainTO, m_swProcessStreamChainHRIRConv;
int m_iStreamDropouts;
//Logger m_oLogger;
};
#endif // __VA_FREEFIELDAUDIOSTREAMPROCESSOR__
This diff is collapsed.
/*
*
* VVV VVV A
* VVV VVV AAA Virtual Acoustics
* VVV VVV AAA Real-time auralisation for virtual reality
* VVV VVV AAA
* VVVVVV AAA (c) Copyright Institut fr Technische Akustik (ITA)
* VVVV AAA RWTH Aachen (http://www.akustik.rwth-aachen.de)
*
* ---------------------------------------------------------------------------------
*
* Datei: VAFreefieldFilterGenerator.h
*
* Zweck: Filtergenerator fr Freifeld-Auralisation
*
* Autor(en): Frank Wefers (Frank.Wefers@akustik.rwth-aachen.de)
*
* ---------------------------------------------------------------------------------
*/
// $Id: VAFreefieldFilterGenerator.h 3369 2013-07-04 15:45:10Z stienen $