36a5e633ea07291b54835e3b8712d77de28c6340
[WebKit-https.git] / Source / WebCore / platform / audio / AudioBus.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 "AudioBus.h"
34
35 #if !PLATFORM(MAC)
36 #include "SincResampler.h"
37 #endif
38 #include "VectorMath.h"
39 #include <algorithm>
40 #include <assert.h>
41 #include <math.h>
42 #include <wtf/OwnPtr.h>
43 #include <wtf/PassOwnPtr.h>
44
45 namespace WebCore {
46
47 using namespace VectorMath;
48     
49 AudioBus::AudioBus(unsigned numberOfChannels, size_t length, bool allocate)
50     : m_length(length)
51     , m_busGain(1.0)
52     , m_isFirstTime(true)
53     , m_sampleRate(0.0)
54 {
55     m_channels.reserveInitialCapacity(numberOfChannels);
56
57     for (unsigned i = 0; i < numberOfChannels; ++i) {
58         PassOwnPtr<AudioChannel> channel = allocate ? adoptPtr(new AudioChannel(length)) : adoptPtr(new AudioChannel(0, length));
59         m_channels.append(channel);
60     }
61
62     m_layout = LayoutCanonical; // for now this is the only layout we define
63 }
64
65 void AudioBus::setChannelMemory(unsigned channelIndex, float* storage, size_t length)
66 {
67     if (channelIndex < m_channels.size()) {
68         channel(channelIndex)->set(storage, length);
69         m_length = length; // FIXME: verify that this length matches all the other channel lengths
70     }
71 }
72
73 void AudioBus::zero()
74 {
75     for (unsigned i = 0; i < m_channels.size(); ++i)
76         m_channels[i]->zero();
77 }
78
79 AudioChannel* AudioBus::channelByType(unsigned channelType)
80 {
81     // For now we only support canonical channel layouts...
82     if (m_layout != LayoutCanonical)
83         return 0;
84
85     switch (numberOfChannels()) {
86     case 1: // mono
87         if (channelType == ChannelMono || channelType == ChannelLeft)
88             return channel(0);
89         return 0;
90
91     case 2: // stereo
92         switch (channelType) {
93         case ChannelLeft: return channel(0);
94         case ChannelRight: return channel(1);
95         default: return 0;
96         }
97
98     case 4: // quad
99         switch (channelType) {
100         case ChannelLeft: return channel(0);
101         case ChannelRight: return channel(1);
102         case ChannelSurroundLeft: return channel(2);
103         case ChannelSurroundRight: return channel(3);
104         default: return 0;
105         }
106
107     case 5: // 5.0
108         switch (channelType) {
109         case ChannelLeft: return channel(0);
110         case ChannelRight: return channel(1);
111         case ChannelCenter: return channel(2);
112         case ChannelSurroundLeft: return channel(3);
113         case ChannelSurroundRight: return channel(4);
114         default: return 0;
115         }
116
117     case 6: // 5.1
118         switch (channelType) {
119         case ChannelLeft: return channel(0);
120         case ChannelRight: return channel(1);
121         case ChannelCenter: return channel(2);
122         case ChannelLFE: return channel(3);
123         case ChannelSurroundLeft: return channel(4);
124         case ChannelSurroundRight: return channel(5);
125         default: return 0;
126         }
127     }
128     
129     ASSERT_NOT_REACHED();
130     return 0;
131 }
132
133 // Returns true if the channel count and frame-size match.
134 bool AudioBus::topologyMatches(const AudioBus& bus) const
135 {
136     if (numberOfChannels() != bus.numberOfChannels())
137         return false; // channel mismatch
138
139     // Make sure source bus has enough frames.
140     if (length() > bus.length())
141         return false; // frame-size mismatch
142
143     return true;
144 }
145
146 PassOwnPtr<AudioBus> AudioBus::createBufferFromRange(AudioBus* sourceBuffer, unsigned startFrame, unsigned endFrame)
147 {
148     size_t numberOfSourceFrames = sourceBuffer->length();
149     unsigned numberOfChannels = sourceBuffer->numberOfChannels();
150
151     // Sanity checking
152     bool isRangeSafe = startFrame < endFrame && endFrame <= numberOfSourceFrames;
153     ASSERT(isRangeSafe);
154     if (!isRangeSafe)
155         return nullptr;
156
157     size_t rangeLength = endFrame - startFrame;
158
159     OwnPtr<AudioBus> audioBus = adoptPtr(new AudioBus(numberOfChannels, rangeLength));
160     audioBus->setSampleRate(sourceBuffer->sampleRate());
161
162     for (unsigned i = 0; i < numberOfChannels; ++i)
163         audioBus->channel(i)->copyFromRange(sourceBuffer->channel(i), startFrame, endFrame);
164
165     return audioBus.release();
166 }
167
168 float AudioBus::maxAbsValue() const
169 {
170     float max = 0.0f;
171     for (unsigned i = 0; i < numberOfChannels(); ++i) {
172         const AudioChannel* channel = this->channel(i);
173         max = std::max(max, channel->maxAbsValue());
174     }
175
176     return max;
177 }
178
179 void AudioBus::normalize()
180 {
181     float max = maxAbsValue();
182     if (max)
183         scale(1.0f / max);
184 }
185
186 void AudioBus::scale(double scale)
187 {
188     for (unsigned i = 0; i < numberOfChannels(); ++i)
189         channel(i)->scale(scale);
190 }
191
192 // Just copies the samples from the source bus to this one.
193 // This is just a simple copy if the number of channels match, otherwise a mixup or mixdown is done.
194 // For now, we just support a mixup from mono -> stereo.
195 void AudioBus::copyFrom(const AudioBus& sourceBus)
196 {
197     if (&sourceBus == this)
198         return;
199
200     if (numberOfChannels() == sourceBus.numberOfChannels()) {
201         for (unsigned i = 0; i < numberOfChannels(); ++i)
202             channel(i)->copyFrom(sourceBus.channel(i));
203     } else if (numberOfChannels() == 2 && sourceBus.numberOfChannels() == 1) {
204         // Handle mono -> stereo case (for now simply copy mono channel into both left and right)
205         // FIXME: Really we should apply an equal-power scaling factor here, since we're effectively panning center...
206         const AudioChannel* sourceChannel = sourceBus.channel(0);
207         channel(0)->copyFrom(sourceChannel);
208         channel(1)->copyFrom(sourceChannel);
209     } else {
210         // Case not handled
211         ASSERT_NOT_REACHED();
212     }
213 }
214
215 void AudioBus::sumFrom(const AudioBus &sourceBus)
216 {
217     if (numberOfChannels() == sourceBus.numberOfChannels()) {
218         for (unsigned i = 0; i < numberOfChannels(); ++i)
219             channel(i)->sumFrom(sourceBus.channel(i));
220     } else if (numberOfChannels() == 2 && sourceBus.numberOfChannels() == 1) {
221         // Handle mono -> stereo case (for now simply sum mono channel into both left and right)
222         // FIXME: Really we should apply an equal-power scaling factor here, since we're effectively panning center...
223         const AudioChannel* sourceChannel = sourceBus.channel(0);
224         channel(0)->sumFrom(sourceChannel);
225         channel(1)->sumFrom(sourceChannel);
226     } else {
227         // Case not handled
228         ASSERT_NOT_REACHED();
229     }
230 }
231
232 void AudioBus::processWithGainFromMonoStereo(const AudioBus &sourceBus, double* lastMixGain, double targetGain, bool sumToBus)
233 {
234     // We don't want to suddenly change the gain from mixing one time slice to the next,
235     // so we "de-zipper" by slowly changing the gain each sample-frame until we've achieved the target gain.
236
237     // FIXME: optimize this method (SSE, etc.)
238     // FIXME: Need fast path here when gain has converged on targetGain. In this case, de-zippering is no longer needed.
239     // FIXME: Need fast path when this==sourceBus && lastMixGain==targetGain==1.0 && sumToBus==false (this is a NOP)
240
241     // Take master bus gain into account as well as the targetGain.
242     double totalDesiredGain = m_busGain * targetGain;
243
244     // First time, snap directly to totalDesiredGain.
245     double gain = m_isFirstTime ? totalDesiredGain : *lastMixGain;
246     m_isFirstTime = false;
247
248     int numberOfSourceChannels = sourceBus.numberOfChannels();
249     int numberOfDestinationChannels = numberOfChannels();
250
251     AudioBus& sourceBusSafe = const_cast<AudioBus&>(sourceBus);
252     const float* sourceL = sourceBusSafe.channelByType(ChannelLeft)->data();
253     const float* sourceR = numberOfSourceChannels > 1 ? sourceBusSafe.channelByType(ChannelRight)->data() : 0;
254
255     float* destinationL = channelByType(ChannelLeft)->data();
256     float* destinationR = numberOfDestinationChannels > 1 ? channelByType(ChannelRight)->data() : 0;
257
258     const double DezipperRate = 0.005;
259     int framesToProcess = length();
260
261     if (sumToBus) {
262         // Sum to our bus
263         if (sourceR && destinationR) {
264             // Stereo
265             while (framesToProcess--) {
266                 float sampleL = *sourceL++;
267                 float sampleR = *sourceR++;
268                 *destinationL++ += static_cast<float>(gain * sampleL);
269                 *destinationR++ += static_cast<float>(gain * sampleR);
270
271                 // Slowly change gain to desired gain.
272                 gain += (totalDesiredGain - gain) * DezipperRate;
273             }
274         } else if (destinationR) {
275             // Mono -> stereo (mix equally into L and R)
276             // FIXME: Really we should apply an equal-power scaling factor here, since we're effectively panning center...
277             while (framesToProcess--) {
278                 float sample = *sourceL++;
279                 *destinationL++ += static_cast<float>(gain * sample);
280                 *destinationR++ += static_cast<float>(gain * sample);
281
282                 // Slowly change gain to desired gain.
283                 gain += (totalDesiredGain - gain) * DezipperRate;
284             }
285         } else {
286             // Mono
287             while (framesToProcess--) {
288                 float sampleL = *sourceL++;
289                 *destinationL++ += static_cast<float>(gain * sampleL);
290
291                 // Slowly change gain to desired gain.
292                 gain += (totalDesiredGain - gain) * DezipperRate;
293             }
294         }
295     } else {
296         // Process directly (without summing) to our bus
297         if (sourceR && destinationR) {
298             // Stereo
299             while (framesToProcess--) {
300                 float sampleL = *sourceL++;
301                 float sampleR = *sourceR++;
302                 *destinationL++ = static_cast<float>(gain * sampleL);
303                 *destinationR++ = static_cast<float>(gain * sampleR);
304
305                 // Slowly change gain to desired gain.
306                 gain += (totalDesiredGain - gain) * DezipperRate;
307             }
308         } else if (destinationR) {
309             // Mono -> stereo (mix equally into L and R)
310             // FIXME: Really we should apply an equal-power scaling factor here, since we're effectively panning center...
311             while (framesToProcess--) {
312                 float sample = *sourceL++;
313                 *destinationL++ = static_cast<float>(gain * sample);
314                 *destinationR++ = static_cast<float>(gain * sample);
315
316                 // Slowly change gain to desired gain.
317                 gain += (totalDesiredGain - gain) * DezipperRate;
318             }
319         } else {
320             // Mono
321             while (framesToProcess--) {
322                 float sampleL = *sourceL++;
323                 *destinationL++ = static_cast<float>(gain * sampleL);
324
325                 // Slowly change gain to desired gain.
326                 gain += (totalDesiredGain - gain) * DezipperRate;
327             }
328         }
329     }
330
331     // Save the target gain as the starting point for next time around.
332     *lastMixGain = gain;
333 }
334
335 void AudioBus::processWithGainFrom(const AudioBus &sourceBus, double* lastMixGain, double targetGain, bool sumToBus)
336 {
337     // Make sure we're summing from same type of bus.
338     // We *are* able to sum from mono -> stereo
339     if (sourceBus.numberOfChannels() != 1 && !topologyMatches(sourceBus))
340         return;
341
342     // Dispatch for different channel layouts
343     switch (numberOfChannels()) {
344     case 1: // mono
345     case 2: // stereo
346         processWithGainFromMonoStereo(sourceBus, lastMixGain, targetGain, sumToBus);
347         break;
348     case 4: // FIXME: implement quad
349     case 5: // FIXME: implement 5.0
350     default:
351         ASSERT_NOT_REACHED();
352         break;
353     }
354 }
355
356 void AudioBus::copyWithGainFrom(const AudioBus &sourceBus, double* lastMixGain, double targetGain)
357 {
358     processWithGainFrom(sourceBus, lastMixGain, targetGain, false);
359 }
360
361 void AudioBus::sumWithGainFrom(const AudioBus &sourceBus, double* lastMixGain, double targetGain)
362 {
363     processWithGainFrom(sourceBus, lastMixGain, targetGain, true);
364 }
365
366 #if !PLATFORM(MAC)
367 PassOwnPtr<AudioBus> AudioBus::createBySampleRateConverting(AudioBus* sourceBus, bool mixToMono, double newSampleRate)
368 {
369     // sourceBus's sample-rate must be known.
370     ASSERT(sourceBus && sourceBus->sampleRate());
371     if (!sourceBus || !sourceBus->sampleRate())
372         return nullptr;
373
374     double sourceSampleRate = sourceBus->sampleRate();
375     double destinationSampleRate = newSampleRate;
376     unsigned numberOfSourceChannels = sourceBus->numberOfChannels();
377
378     if (numberOfSourceChannels == 1)
379         mixToMono = false; // already mono
380         
381     if (sourceSampleRate == destinationSampleRate) {
382         // No sample-rate conversion is necessary.
383         if (mixToMono)
384             return AudioBus::createByMixingToMono(sourceBus);
385
386         // Return exact copy.
387         return AudioBus::createBufferFromRange(sourceBus, 0, sourceBus->length());
388     }
389     
390     // First, mix to mono (if necessary) then sample-rate convert.
391     AudioBus* resamplerSourceBus;
392     OwnPtr<AudioBus> mixedMonoBus;
393     if (mixToMono) {
394         mixedMonoBus = AudioBus::createByMixingToMono(sourceBus);
395         resamplerSourceBus = mixedMonoBus.get();
396     } else {
397         // Directly resample without down-mixing.
398         resamplerSourceBus = sourceBus;
399     }
400
401     // Calculate destination length based on the sample-rates.
402     double sampleRateRatio = sourceSampleRate / destinationSampleRate;
403     int sourceLength = resamplerSourceBus->length();
404     int destinationLength = sourceLength / sampleRateRatio;
405
406     // Create destination bus with same number of channels.
407     unsigned numberOfDestinationChannels = resamplerSourceBus->numberOfChannels();
408     OwnPtr<AudioBus> destinationBus(adoptPtr(new AudioBus(numberOfDestinationChannels, destinationLength)));
409
410     // Sample-rate convert each channel.
411     for (unsigned i = 0; i < numberOfDestinationChannels; ++i) {
412         float* source = resamplerSourceBus->channel(i)->data();
413         float* destination = destinationBus->channel(i)->data();
414
415         SincResampler resampler(sampleRateRatio);
416         resampler.process(source, destination, sourceLength);
417     }
418
419     destinationBus->setSampleRate(newSampleRate);    
420     return destinationBus.release();
421 }
422 #endif // !PLATFORM(MAC)
423
424 PassOwnPtr<AudioBus> AudioBus::createByMixingToMono(AudioBus* sourceBus)
425 {
426     switch (sourceBus->numberOfChannels()) {
427     case 1:
428         // Simply create an exact copy.
429         return AudioBus::createBufferFromRange(sourceBus, 0, sourceBus->length());
430     case 2:
431         {
432             unsigned n = sourceBus->length();
433             OwnPtr<AudioBus> destinationBus(adoptPtr(new AudioBus(1, n)));
434
435             float* sourceL = sourceBus->channel(0)->data();
436             float* sourceR = sourceBus->channel(1)->data();
437             float* destination = destinationBus->channel(0)->data();
438         
439             // Do the mono mixdown.
440             for (unsigned i = 0; i < n; ++i)
441                 destination[i] = 0.5 * (sourceL[i] + sourceR[i]);
442
443             destinationBus->setSampleRate(sourceBus->sampleRate());    
444             return destinationBus.release();
445         }
446     }
447
448     ASSERT_NOT_REACHED();
449     return nullptr;
450 }
451
452 } // WebCore
453
454 #endif // ENABLE(WEB_AUDIO)