1 /*******************************************************************************
2 * Copyright 2015-2016 Juan Francisco Crespo Galán
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 ******************************************************************************/
16
17 #include "fx/Convolver.h"
18
19 #include <cmath>
20 #include <cstdlib>
21 #include <algorithm>
22 #include <cstring>
23
24 AUD_NAMESPACE_BEGIN
Convolver(std::shared_ptr<std::vector<std::shared_ptr<std::vector<std::complex<sample_t>>>>> ir,int irLength,std::shared_ptr<ThreadPool> threadPool,std::shared_ptr<FFTPlan> plan)25 Convolver::Convolver(std::shared_ptr<std::vector<std::shared_ptr<std::vector<std::complex<sample_t>>>>> ir, int irLength, std::shared_ptr<ThreadPool> threadPool, std::shared_ptr<FFTPlan> plan) :
26 m_N(plan->getSize()), m_M(plan->getSize()/2), m_L(plan->getSize()/2), m_irBuffers(ir), m_irLength(irLength), m_threadPool(threadPool), m_numThreads(std::min(threadPool->getNumOfThreads(), static_cast<unsigned int>(m_irBuffers->size() - 1))), m_tailCounter(0), m_eos(false)
27
28 {
29 m_resetFlag = false;
30 m_futures.resize(m_numThreads);
31 for(int i = 0; i < m_irBuffers->size(); i++)
32 {
33 m_fftConvolvers.push_back(std::unique_ptr<FFTConvolver>(new FFTConvolver((*m_irBuffers)[i], plan)));
34 m_delayLine.push_front((fftwf_complex*)std::calloc((m_N / 2) + 1, sizeof(fftwf_complex)));
35 }
36
37 m_accBuffer = (fftwf_complex*)std::calloc((m_N / 2) + 1, sizeof(fftwf_complex));
38 for(int i = 0; i < m_numThreads; i++)
39 m_threadAccBuffers.push_back((fftwf_complex*)std::calloc((m_N / 2) + 1, sizeof(fftwf_complex)));
40 }
41
~Convolver()42 Convolver::~Convolver()
43 {
44 m_resetFlag = true;
45 for(auto &fut : m_futures)
46 if(fut.valid())
47 fut.get();
48
49 std::free(m_accBuffer);
50 for(auto buf : m_threadAccBuffers)
51 std::free(buf);
52 while(!m_delayLine.empty())
53 {
54 std::free(m_delayLine.front());
55 m_delayLine.pop_front();
56 }
57 }
58
getNext(sample_t * inBuffer,sample_t * outBuffer,int & length,bool & eos)59 void Convolver::getNext(sample_t* inBuffer, sample_t* outBuffer, int& length, bool& eos)
60 {
61 if(length > m_L)
62 {
63 length = 0;
64 eos = m_eos;
65 return;
66 }
67 if(m_eos)
68 {
69 eos = m_eos;
70 length = 0;
71 return;
72 }
73
74 eos = false;
75 for(auto &fut : m_futures)
76 if(fut.valid())
77 fut.get();
78
79 if(inBuffer != nullptr)
80 m_fftConvolvers[0]->getNextFDL(inBuffer, reinterpret_cast<std::complex<sample_t>*>(m_accBuffer), length, m_delayLine[0]);
81 else
82 {
83 m_tailCounter++;
84 std::memset(outBuffer, 0, m_L*sizeof(sample_t));
85 m_fftConvolvers[0]->getNextFDL(outBuffer, reinterpret_cast<std::complex<sample_t>*>(m_accBuffer), length, m_delayLine[0]);
86 }
87 m_delayLine.push_front(m_delayLine.back());
88 m_delayLine.pop_back();
89 length = m_L;
90 m_fftConvolvers[0]->IFFT_FDL(m_accBuffer, outBuffer, length);
91 std::memset(m_accBuffer, 0, ((m_N / 2) + 1)*sizeof(fftwf_complex));
92
93 if(m_tailCounter >= m_delayLine.size() && inBuffer == nullptr)
94 {
95 eos = m_eos = true;
96 length = m_irLength%m_M;
97 if(length == 0)
98 length = m_M;
99 }
100 else
101 for(int i = 0; i < m_futures.size(); i++)
102 m_futures[i] = m_threadPool->enqueue(&Convolver::threadFunction, this, i);
103 }
104
reset()105 void Convolver::reset()
106 {
107 m_resetFlag = true;
108 for(auto &fut : m_futures)
109 if(fut.valid())
110 fut.get();
111
112 for(int i = 0; i < m_delayLine.size();i++)
113 std::memset(m_delayLine[i], 0, ((m_N / 2) + 1)*sizeof(fftwf_complex));
114 for(int i = 0; i < m_fftConvolvers.size(); i++)
115 m_fftConvolvers[i]->clear();
116 std::memset(m_accBuffer, 0, ((m_N / 2) + 1)*sizeof(fftwf_complex));
117 m_tailCounter = 0;
118 m_eos = false;
119 m_resetFlag = false;
120 }
121
getImpulseResponse()122 std::shared_ptr<std::vector<std::shared_ptr<std::vector<std::complex<sample_t>>>>> Convolver::getImpulseResponse()
123 {
124 return m_irBuffers;
125 }
126
setImpulseResponse(std::shared_ptr<std::vector<std::shared_ptr<std::vector<std::complex<sample_t>>>>> ir)127 void Convolver::setImpulseResponse(std::shared_ptr<std::vector<std::shared_ptr<std::vector<std::complex<sample_t>>>>> ir)
128 {
129 reset();
130 m_irBuffers = ir;
131 for(int i = 0; i < m_irBuffers->size(); i++)
132 m_fftConvolvers[i]->setImpulseResponse((*m_irBuffers)[i]);
133 }
134
threadFunction(int id)135 bool Convolver::threadFunction(int id)
136 {
137 int total = m_irBuffers->size();
138 int share = std::ceil(((float)total - 1) / (float)m_numThreads);
139 int start = id*share + 1;
140 int end = std::min(start + share, total);
141
142 std::memset(m_threadAccBuffers[id], 0, ((m_N / 2) + 1)*sizeof(fftwf_complex));
143
144 for(int i = start; i < end && !m_resetFlag; i++)
145 m_fftConvolvers[i]->getNextFDL(reinterpret_cast<std::complex<sample_t>*>(m_delayLine[i]), reinterpret_cast<std::complex<sample_t>*>(m_threadAccBuffers[id]));
146
147 m_sumMutex.lock();
148 for(int i = 0; (i < m_N / 2 + 1) && !m_resetFlag; i++)
149 {
150 m_accBuffer[i][0] += m_threadAccBuffers[id][i][0];
151 m_accBuffer[i][1] += m_threadAccBuffers[id][i][1];
152 }
153 m_sumMutex.unlock();
154 return true;
155 }
156 AUD_NAMESPACE_END
157