diff options
Diffstat (limited to 'extern/audaspace/src/fx/BinauralReader.cpp')
-rw-r--r-- | extern/audaspace/src/fx/BinauralReader.cpp | 255 |
1 files changed, 255 insertions, 0 deletions
diff --git a/extern/audaspace/src/fx/BinauralReader.cpp b/extern/audaspace/src/fx/BinauralReader.cpp new file mode 100644 index 00000000000..2792adada8a --- /dev/null +++ b/extern/audaspace/src/fx/BinauralReader.cpp @@ -0,0 +1,255 @@ +/******************************************************************************* +* Copyright 2015-2016 Juan Francisco Crespo Galán +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +******************************************************************************/ + +#include "fx/BinauralReader.h" +#include "Exception.h" + +#include <cstring> +#include <cstdlib> +#include <algorithm> + +#define NUM_OUTCHANNELS 2 +#define NUM_CONVOLVERS 4 +#define CROSSFADE_SAMPLES 1024 + +AUD_NAMESPACE_BEGIN +BinauralReader::BinauralReader(std::shared_ptr<IReader> reader, std::shared_ptr<HRTF> hrtfs, std::shared_ptr<Source> source, std::shared_ptr<ThreadPool> threadPool, std::shared_ptr<FFTPlan> plan) : + m_reader(reader), m_hrtfs(hrtfs), m_source(source), m_N(plan->getSize()), m_threadPool(threadPool), m_position(0), m_eosReader(false), m_eosTail(false), m_transition(false), m_transPos(CROSSFADE_SAMPLES*NUM_OUTCHANNELS) +{ + if(m_hrtfs->isEmpty()) + AUD_THROW(StateException, "The provided HRTF object is empty"); + if(m_reader->getSpecs().channels != 1) + AUD_THROW(StateException, "The sound must have only one channel"); + if(m_reader->getSpecs().rate != m_hrtfs->getSpecs().rate) + AUD_THROW(StateException, "The sound and the HRTFs must have the same rate"); + m_M = m_L = m_N / 2; + + m_RealAzimuth = m_Azimuth = m_source->getAzimuth(); + m_RealElevation = m_Elevation = m_source->getElevation(); + auto irs = m_hrtfs->getImpulseResponse(m_RealAzimuth, m_RealElevation); + for(unsigned int i = 0; i < NUM_CONVOLVERS; i++) + if(i%NUM_OUTCHANNELS==0) + m_convolvers.push_back(std::unique_ptr<Convolver>(new Convolver(irs.first->getChannel(0), irs.first->getLength(), m_threadPool, plan))); + else + m_convolvers.push_back(std::unique_ptr<Convolver>(new Convolver(irs.second->getChannel(0), irs.second->getLength(), m_threadPool, plan))); + m_futures.resize(NUM_CONVOLVERS); + + m_outBuffer = (sample_t*)std::malloc(m_L*NUM_OUTCHANNELS*sizeof(sample_t)); + m_eOutBufLen = m_outBufLen = m_outBufferPos = m_L * NUM_OUTCHANNELS; + m_inBuffer = (sample_t*)std::malloc(m_L * sizeof(sample_t)); + for(int i = 0; i < NUM_CONVOLVERS; i++) + m_vecOut.push_back((sample_t*)std::calloc(m_L, sizeof(sample_t))); +} + +BinauralReader::~BinauralReader() +{ + std::free(m_outBuffer); + std::free(m_inBuffer); + for(int i = 0; i < m_vecOut.size(); i++) + std::free(m_vecOut[i]); +} + +bool BinauralReader::isSeekable() const +{ + return m_reader->isSeekable(); +} + +void BinauralReader::seek(int position) +{ + m_position = position; + m_reader->seek(position); + for(int i = 0; i < NUM_CONVOLVERS; i++) + m_convolvers[i]->reset(); + m_eosTail = false; + m_eosReader = false; + m_outBufferPos = m_eOutBufLen = m_outBufLen; + m_transition = false; + m_transPos = CROSSFADE_SAMPLES*NUM_OUTCHANNELS; +} + +int BinauralReader::getLength() const +{ + return m_reader->getLength(); +} + +int BinauralReader::getPosition() const +{ + return m_position; +} + +Specs BinauralReader::getSpecs() const +{ + Specs specs = m_reader->getSpecs(); + specs.channels = CHANNELS_STEREO; + return specs; +} + +void BinauralReader::read(int& length, bool& eos, sample_t* buffer) +{ + int samples = 0; + int iteration = 0; + if(length <= 0) + { + length = 0; + eos = (m_eosTail && m_outBufferPos >= m_eOutBufLen); + return; + } + + eos = false; + int writePos = 0; + do + { + int bufRest = m_eOutBufLen - m_outBufferPos; + int writeLength = std::min((length*NUM_OUTCHANNELS) - writePos, m_eOutBufLen + bufRest); + if(bufRest < writeLength || (m_eOutBufLen == 0 && m_eosTail)) + { + if(bufRest > 0) + std::memcpy(buffer + writePos, m_outBuffer + m_outBufferPos, bufRest*sizeof(sample_t)); + if(!m_eosTail) + { + int n = NUM_OUTCHANNELS; + if(m_transition) + n = NUM_CONVOLVERS; + else if(checkSource()) + n = NUM_CONVOLVERS; + loadBuffer(n); + + int len = std::min(std::abs(writeLength - bufRest), m_eOutBufLen); + std::memcpy(buffer + writePos + bufRest, m_outBuffer, len*sizeof(sample_t)); + samples += len; + m_outBufferPos = len; + writeLength = std::min((length*NUM_OUTCHANNELS) - writePos, m_eOutBufLen + bufRest); + } + else + { + m_outBufferPos += bufRest; + length = (writePos+bufRest) / NUM_OUTCHANNELS; + eos = true; + return; + } + } + else + { + std::memcpy(buffer + writePos, m_outBuffer + m_outBufferPos, writeLength*sizeof(sample_t)); + m_outBufferPos += writeLength; + } + writePos += writeLength; + iteration++; + } while(writePos < length*NUM_OUTCHANNELS); + m_position += length; +} + +bool BinauralReader::checkSource() +{ + if((m_Azimuth != m_source->getAzimuth() || m_Elevation != m_source->getElevation()) && (!m_eosReader && !m_eosTail)) + { + float az = m_Azimuth = m_source->getAzimuth(); + float el = m_Elevation = m_source->getElevation(); + auto irs = m_hrtfs->getImpulseResponse(az, el); + if(az != m_RealAzimuth || el != m_RealElevation) + { + m_RealAzimuth = az; + m_RealElevation = el; + for(int i = 0; i < NUM_OUTCHANNELS; i++) + { + auto temp = std::move(m_convolvers[i]); + m_convolvers[i] = std::move(m_convolvers[i + NUM_OUTCHANNELS]); + m_convolvers[i + NUM_OUTCHANNELS] = std::move(temp); + } + for(int i = 0; i < NUM_OUTCHANNELS; i++) + if(i%NUM_OUTCHANNELS == 0) + m_convolvers[i]->setImpulseResponse(irs.first->getChannel(0)); + else + m_convolvers[i]->setImpulseResponse(irs.second->getChannel(0)); + + m_transPos = CROSSFADE_SAMPLES*NUM_OUTCHANNELS; + m_transition = true; + return true; + } + } + return false; +} + +void BinauralReader::loadBuffer(int nConvolvers) +{ + m_lastLengthIn = m_L; + m_reader->read(m_lastLengthIn, m_eosReader, m_inBuffer); + if(!m_eosReader || m_lastLengthIn > 0) + { + int len = m_lastLengthIn; + for(int i = 0; i < nConvolvers; i++) + m_futures[i] = m_threadPool->enqueue(&BinauralReader::threadFunction, this, i, true); + for(int i = 0; i < nConvolvers; i++) + len = m_futures[i].get(); + + joinByChannel(0, len, nConvolvers); + m_eOutBufLen = len*NUM_OUTCHANNELS; + } + else if(!m_eosTail) + { + int len = m_lastLengthIn = m_L; + for(int i = 0; i < nConvolvers; i++) + m_futures[i] = m_threadPool->enqueue(&BinauralReader::threadFunction, this, i, false); + for(int i = 0; i < nConvolvers; i++) + len = m_futures[i].get(); + + joinByChannel(0, len, nConvolvers); + m_eOutBufLen = len*NUM_OUTCHANNELS; + } +} + +void BinauralReader::joinByChannel(int start, int len, int nConvolvers) +{ + int k = 0; + float vol = 0; + const int l = CROSSFADE_SAMPLES*NUM_OUTCHANNELS; + for(int i = 0; i < len*NUM_OUTCHANNELS; i += NUM_OUTCHANNELS) + { + if(m_transition) + { + vol = (m_transPos - i) / (float)l; + if(vol > 1.0f) + vol = 1.0f; + else if(vol < 0.0f) + vol = 0.0f; + } + + for(int j = 0; j < NUM_OUTCHANNELS; j++) + m_outBuffer[i + j + start] = ((m_vecOut[j][k] * (1.0f - vol)) + (m_vecOut[j + NUM_OUTCHANNELS][k] * vol))*m_source->getVolume(); + k++; + } + if(m_transition) + { + m_transPos -= len*NUM_OUTCHANNELS; + if(m_transPos <= 0) + { + m_transition = false; + m_transPos = l; + } + } +} + +int BinauralReader::threadFunction(int id, bool input) +{ + int l = m_lastLengthIn; + if(input) + m_convolvers[id]->getNext(m_inBuffer, m_vecOut[id], l, m_eosTail); + else + m_convolvers[id]->getNext(nullptr, m_vecOut[id], l, m_eosTail); + return l; +} + +AUD_NAMESPACE_END |