Prune unneeded header #includes
[WebKit-https.git] / Source / WebCore / platform / audio / HRTFElevation.cpp
1 /*
2  * Copyright (C) 2010 Google Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  *
8  * 1.  Redistributions of source code must retain the above copyright
9  *     notice, this list of conditions and the following disclaimer.
10  * 2.  Redistributions in binary form must reproduce the above copyright
11  *     notice, this list of conditions and the following disclaimer in the
12  *     documentation and/or other materials provided with the distribution.
13  * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
14  *     its contributors may be used to endorse or promote products derived
15  *     from this software without specific prior written permission.
16  *
17  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
18  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
19  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
20  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
21  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
22  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
23  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
24  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27  */
28
29 #include "config.h"
30
31 #if ENABLE(WEB_AUDIO)
32
33 #include "HRTFElevation.h"
34
35 #include "AudioBus.h"
36 #include "AudioFileReader.h"
37 #include "Biquad.h"
38 #include "FFTFrame.h"
39 #include "HRTFDatabaseLoader.h"
40 #include "HRTFPanner.h"
41 #include "PlatformMemoryInstrumentation.h"
42 #include <algorithm>
43 #include <math.h>
44 #include <wtf/MemoryInstrumentationVector.h>
45 #include <wtf/OwnPtr.h>
46
47 using namespace std;
48  
49 namespace WebCore {
50
51 const unsigned HRTFElevation::AzimuthSpacing = 15;
52 const unsigned HRTFElevation::NumberOfRawAzimuths = 360 / AzimuthSpacing;
53 const unsigned HRTFElevation::InterpolationFactor = 8;
54 const unsigned HRTFElevation::NumberOfTotalAzimuths = NumberOfRawAzimuths * InterpolationFactor;
55
56 // Total number of components of an HRTF database.
57 const size_t TotalNumberOfResponses = 240;
58
59 // Number of frames in an individual impulse response.
60 const size_t ResponseFrameSize = 256;
61
62 // Sample-rate of the spatialization impulse responses as stored in the resource file.
63 // The impulse responses may be resampled to a different sample-rate (depending on the audio hardware) when they are loaded.
64 const float ResponseSampleRate = 44100;
65
66 #if PLATFORM(MAC) || USE(WEBAUDIO_GSTREAMER)
67 #define USE_CONCATENATED_IMPULSE_RESPONSES
68 #endif
69
70 #ifdef USE_CONCATENATED_IMPULSE_RESPONSES
71 // Lazily load a concatenated HRTF database for given subject and store it in a
72 // local hash table to ensure quick efficient future retrievals.
73 static AudioBus* getConcatenatedImpulseResponsesForSubject(const String& subjectName)
74 {
75     typedef HashMap<String, AudioBus*> AudioBusMap;
76     DEFINE_STATIC_LOCAL(AudioBusMap, audioBusMap, ());
77
78     AudioBus* bus;
79     AudioBusMap::iterator iterator = audioBusMap.find(subjectName);
80     if (iterator == audioBusMap.end()) {
81         OwnPtr<AudioBus> concatenatedImpulseResponses = AudioBus::loadPlatformResource(subjectName.utf8().data(), ResponseSampleRate);
82         ASSERT(concatenatedImpulseResponses);
83         if (!concatenatedImpulseResponses)
84             return 0;
85
86         bus = concatenatedImpulseResponses.leakPtr();
87         audioBusMap.set(subjectName, bus);
88     } else
89         bus = iterator->value;
90
91     size_t responseLength = bus->length();
92     size_t expectedLength = static_cast<size_t>(TotalNumberOfResponses * ResponseFrameSize);
93
94     // Check number of channels and length. For now these are fixed and known.
95     bool isBusGood = responseLength == expectedLength && bus->numberOfChannels() == 2;
96     ASSERT(isBusGood);
97     if (!isBusGood)
98         return 0;
99
100     return bus;
101 }
102 #endif
103
104 // Takes advantage of the symmetry and creates a composite version of the two measured versions.  For example, we have both azimuth 30 and -30 degrees
105 // where the roles of left and right ears are reversed with respect to each other.
106 bool HRTFElevation::calculateSymmetricKernelsForAzimuthElevation(int azimuth, int elevation, float sampleRate, const String& subjectName,
107                                                                  RefPtr<HRTFKernel>& kernelL, RefPtr<HRTFKernel>& kernelR)
108 {
109     RefPtr<HRTFKernel> kernelL1;
110     RefPtr<HRTFKernel> kernelR1;
111     bool success = calculateKernelsForAzimuthElevation(azimuth, elevation, sampleRate, subjectName, kernelL1, kernelR1);
112     if (!success)
113         return false;
114         
115     // And symmetric version
116     int symmetricAzimuth = !azimuth ? 0 : 360 - azimuth;
117                                                               
118     RefPtr<HRTFKernel> kernelL2;
119     RefPtr<HRTFKernel> kernelR2;
120     success = calculateKernelsForAzimuthElevation(symmetricAzimuth, elevation, sampleRate, subjectName, kernelL2, kernelR2);
121     if (!success)
122         return false;
123         
124     // Notice L/R reversal in symmetric version.
125     kernelL = HRTFKernel::createInterpolatedKernel(kernelL1.get(), kernelR2.get(), 0.5f);
126     kernelR = HRTFKernel::createInterpolatedKernel(kernelR1.get(), kernelL2.get(), 0.5f);
127     
128     return true;
129 }
130
131 bool HRTFElevation::calculateKernelsForAzimuthElevation(int azimuth, int elevation, float sampleRate, const String& subjectName,
132                                                         RefPtr<HRTFKernel>& kernelL, RefPtr<HRTFKernel>& kernelR)
133 {
134     // Valid values for azimuth are 0 -> 345 in 15 degree increments.
135     // Valid values for elevation are -45 -> +90 in 15 degree increments.
136
137     bool isAzimuthGood = azimuth >= 0 && azimuth <= 345 && (azimuth / 15) * 15 == azimuth;
138     ASSERT(isAzimuthGood);
139     if (!isAzimuthGood)
140         return false;
141
142     bool isElevationGood = elevation >= -45 && elevation <= 90 && (elevation / 15) * 15 == elevation;
143     ASSERT(isElevationGood);
144     if (!isElevationGood)
145         return false;
146     
147     // Construct the resource name from the subject name, azimuth, and elevation, for example:
148     // "IRC_Composite_C_R0195_T015_P000"
149     // Note: the passed in subjectName is not a string passed in via JavaScript or the web.
150     // It's passed in as an internal ASCII identifier and is an implementation detail.
151     int positiveElevation = elevation < 0 ? elevation + 360 : elevation;
152
153 #ifdef USE_CONCATENATED_IMPULSE_RESPONSES
154     AudioBus* bus(getConcatenatedImpulseResponsesForSubject(subjectName));
155
156     if (!bus)
157         return false;
158
159     int elevationIndex = positiveElevation / AzimuthSpacing;
160     if (positiveElevation > 90)
161         elevationIndex -= AzimuthSpacing;
162
163     // The concatenated impulse response is a bus containing all
164     // the elevations per azimuth, for all azimuths by increasing
165     // order. So for a given azimuth and elevation we need to compute
166     // the index of the wanted audio frames in the concatenated table.
167     unsigned index = ((azimuth / AzimuthSpacing) * HRTFDatabase::NumberOfRawElevations) + elevationIndex;
168     bool isIndexGood = index < TotalNumberOfResponses;
169     ASSERT(isIndexGood);
170     if (!isIndexGood)
171         return false;
172
173     // Extract the individual impulse response from the concatenated
174     // responses and potentially sample-rate convert it to the desired
175     // (hardware) sample-rate.
176     unsigned startFrame = index * ResponseFrameSize;
177     unsigned stopFrame = startFrame + ResponseFrameSize;
178     OwnPtr<AudioBus> preSampleRateConvertedResponse = AudioBus::createBufferFromRange(bus, startFrame, stopFrame);
179     OwnPtr<AudioBus> response = AudioBus::createBySampleRateConverting(preSampleRateConvertedResponse.get(), false, sampleRate);
180     AudioChannel* leftEarImpulseResponse = response->channel(AudioBus::ChannelLeft);
181     AudioChannel* rightEarImpulseResponse = response->channel(AudioBus::ChannelRight);
182 #else
183     String resourceName = String::format("IRC_%s_C_R0195_T%03d_P%03d", subjectName.utf8().data(), azimuth, positiveElevation);
184
185     OwnPtr<AudioBus> impulseResponse(AudioBus::loadPlatformResource(resourceName.utf8().data(), sampleRate));
186
187     ASSERT(impulseResponse.get());
188     if (!impulseResponse.get())
189         return false;
190     
191     size_t responseLength = impulseResponse->length();
192     size_t expectedLength = static_cast<size_t>(256 * (sampleRate / 44100.0));
193
194     // Check number of channels and length.  For now these are fixed and known.
195     bool isBusGood = responseLength == expectedLength && impulseResponse->numberOfChannels() == 2;
196     ASSERT(isBusGood);
197     if (!isBusGood)
198         return false;
199     
200     AudioChannel* leftEarImpulseResponse = impulseResponse->channelByType(AudioBus::ChannelLeft);
201     AudioChannel* rightEarImpulseResponse = impulseResponse->channelByType(AudioBus::ChannelRight);
202 #endif
203
204     // Note that depending on the fftSize returned by the panner, we may be truncating the impulse response we just loaded in.
205     const size_t fftSize = HRTFPanner::fftSizeForSampleRate(sampleRate);
206     kernelL = HRTFKernel::create(leftEarImpulseResponse, fftSize, sampleRate);
207     kernelR = HRTFKernel::create(rightEarImpulseResponse, fftSize, sampleRate);
208     
209     return true;
210 }
211
212 // The range of elevations for the IRCAM impulse responses varies depending on azimuth, but the minimum elevation appears to always be -45.
213 //
214 // Here's how it goes:
215 static int maxElevations[] = {
216         //  Azimuth
217         //
218     90, // 0  
219     45, // 15 
220     60, // 30 
221     45, // 45 
222     75, // 60 
223     45, // 75 
224     60, // 90 
225     45, // 105 
226     75, // 120 
227     45, // 135 
228     60, // 150 
229     45, // 165 
230     75, // 180 
231     45, // 195 
232     60, // 210 
233     45, // 225 
234     75, // 240 
235     45, // 255 
236     60, // 270 
237     45, // 285 
238     75, // 300 
239     45, // 315 
240     60, // 330 
241     45 //  345 
242 };
243
244 PassOwnPtr<HRTFElevation> HRTFElevation::createForSubject(const String& subjectName, int elevation, float sampleRate)
245 {
246     bool isElevationGood = elevation >= -45 && elevation <= 90 && (elevation / 15) * 15 == elevation;
247     ASSERT(isElevationGood);
248     if (!isElevationGood)
249         return nullptr;
250         
251     OwnPtr<HRTFKernelList> kernelListL = adoptPtr(new HRTFKernelList(NumberOfTotalAzimuths));
252     OwnPtr<HRTFKernelList> kernelListR = adoptPtr(new HRTFKernelList(NumberOfTotalAzimuths));
253
254     // Load convolution kernels from HRTF files.
255     int interpolatedIndex = 0;
256     for (unsigned rawIndex = 0; rawIndex < NumberOfRawAzimuths; ++rawIndex) {
257         // Don't let elevation exceed maximum for this azimuth.
258         int maxElevation = maxElevations[rawIndex];
259         int actualElevation = min(elevation, maxElevation);
260
261         bool success = calculateKernelsForAzimuthElevation(rawIndex * AzimuthSpacing, actualElevation, sampleRate, subjectName, kernelListL->at(interpolatedIndex), kernelListR->at(interpolatedIndex));
262         if (!success)
263             return nullptr;
264             
265         interpolatedIndex += InterpolationFactor;
266     }
267
268     // Now go back and interpolate intermediate azimuth values.
269     for (unsigned i = 0; i < NumberOfTotalAzimuths; i += InterpolationFactor) {
270         int j = (i + InterpolationFactor) % NumberOfTotalAzimuths;
271
272         // Create the interpolated convolution kernels and delays.
273         for (unsigned jj = 1; jj < InterpolationFactor; ++jj) {
274             float x = float(jj) / float(InterpolationFactor); // interpolate from 0 -> 1
275
276             (*kernelListL)[i + jj] = HRTFKernel::createInterpolatedKernel(kernelListL->at(i).get(), kernelListL->at(j).get(), x);
277             (*kernelListR)[i + jj] = HRTFKernel::createInterpolatedKernel(kernelListR->at(i).get(), kernelListR->at(j).get(), x);
278         }
279     }
280     
281     OwnPtr<HRTFElevation> hrtfElevation = adoptPtr(new HRTFElevation(kernelListL.release(), kernelListR.release(), elevation, sampleRate));
282     return hrtfElevation.release();
283 }
284
285 PassOwnPtr<HRTFElevation> HRTFElevation::createByInterpolatingSlices(HRTFElevation* hrtfElevation1, HRTFElevation* hrtfElevation2, float x, float sampleRate)
286 {
287     ASSERT(hrtfElevation1 && hrtfElevation2);
288     if (!hrtfElevation1 || !hrtfElevation2)
289         return nullptr;
290         
291     ASSERT(x >= 0.0 && x < 1.0);
292     
293     OwnPtr<HRTFKernelList> kernelListL = adoptPtr(new HRTFKernelList(NumberOfTotalAzimuths));
294     OwnPtr<HRTFKernelList> kernelListR = adoptPtr(new HRTFKernelList(NumberOfTotalAzimuths));
295
296     HRTFKernelList* kernelListL1 = hrtfElevation1->kernelListL();
297     HRTFKernelList* kernelListR1 = hrtfElevation1->kernelListR();
298     HRTFKernelList* kernelListL2 = hrtfElevation2->kernelListL();
299     HRTFKernelList* kernelListR2 = hrtfElevation2->kernelListR();
300     
301     // Interpolate kernels of corresponding azimuths of the two elevations.
302     for (unsigned i = 0; i < NumberOfTotalAzimuths; ++i) {
303         (*kernelListL)[i] = HRTFKernel::createInterpolatedKernel(kernelListL1->at(i).get(), kernelListL2->at(i).get(), x);
304         (*kernelListR)[i] = HRTFKernel::createInterpolatedKernel(kernelListR1->at(i).get(), kernelListR2->at(i).get(), x);
305     }
306
307     // Interpolate elevation angle.
308     double angle = (1.0 - x) * hrtfElevation1->elevationAngle() + x * hrtfElevation2->elevationAngle();
309     
310     OwnPtr<HRTFElevation> hrtfElevation = adoptPtr(new HRTFElevation(kernelListL.release(), kernelListR.release(), static_cast<int>(angle), sampleRate));
311     return hrtfElevation.release();  
312 }
313
314 void HRTFElevation::getKernelsFromAzimuth(double azimuthBlend, unsigned azimuthIndex, HRTFKernel* &kernelL, HRTFKernel* &kernelR, double& frameDelayL, double& frameDelayR)
315 {
316     bool checkAzimuthBlend = azimuthBlend >= 0.0 && azimuthBlend < 1.0;
317     ASSERT(checkAzimuthBlend);
318     if (!checkAzimuthBlend)
319         azimuthBlend = 0.0;
320     
321     unsigned numKernels = m_kernelListL->size();
322
323     bool isIndexGood = azimuthIndex < numKernels;
324     ASSERT(isIndexGood);
325     if (!isIndexGood) {
326         kernelL = 0;
327         kernelR = 0;
328         return;
329     }
330     
331     // Return the left and right kernels.
332     kernelL = m_kernelListL->at(azimuthIndex).get();
333     kernelR = m_kernelListR->at(azimuthIndex).get();
334
335     frameDelayL = m_kernelListL->at(azimuthIndex)->frameDelay();
336     frameDelayR = m_kernelListR->at(azimuthIndex)->frameDelay();
337
338     int azimuthIndex2 = (azimuthIndex + 1) % numKernels;
339     double frameDelay2L = m_kernelListL->at(azimuthIndex2)->frameDelay();
340     double frameDelay2R = m_kernelListR->at(azimuthIndex2)->frameDelay();
341
342     // Linearly interpolate delays.
343     frameDelayL = (1.0 - azimuthBlend) * frameDelayL + azimuthBlend * frameDelay2L;
344     frameDelayR = (1.0 - azimuthBlend) * frameDelayR + azimuthBlend * frameDelay2R;
345 }
346
347 void HRTFElevation::reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
348 {
349     MemoryClassInfo info(memoryObjectInfo, this, PlatformMemoryTypes::AudioSharedData);
350     info.addMember(m_kernelListL, "kernelListL");
351     info.addMember(m_kernelListR, "kernelListR");
352 }
353
354 } // namespace WebCore
355
356 #endif // ENABLE(WEB_AUDIO)