Source/WebCore/Modules/webaudio/PannerNode.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  * 1.  Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2.  Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' AND ANY
  14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  15  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  16  * DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY
  17  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  18  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  19  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
  20  * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  21  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  22  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  23  */
  24
  25 #include "config.h"
  26
  27 #if ENABLE(WEB_AUDIO)
  28
  29 #include "PannerNode.h"
  30
  31 #include "AudioBufferSourceNode.h"
  32 #include "AudioBus.h"
  33 #include "AudioContext.h"
  34 #include "AudioNodeInput.h"
  35 #include "AudioNodeOutput.h"
  36 #include "ExceptionCode.h"
  37 #include "HRTFPanner.h"
  38 #include "ScriptExecutionContext.h"
  39 #include <wtf/MathExtras.h>
  40
  41 using namespace std;
  42
  43 namespace WebCore {
  44
  45 static void fixNANs(double &x)
  46 {
  47     if (isnan(x) || isinf(x))
  48         x = 0.0;
  49 }
  50
  51 PannerNode::PannerNode(AudioContext* context, float sampleRate)
  52     : AudioNode(context, sampleRate)
  53     , m_panningModel(Panner::PanningModelHRTF)
  54     , m_lastGain(-1.0)
  55     , m_connectionCount(0)
  56 {
  57     addInput(adoptPtr(new AudioNodeInput(this)));
  58     addOutput(adoptPtr(new AudioNodeOutput(this, 2)));
  59
  60     m_distanceGain = AudioGain::create(context, "distanceGain", 1.0, 0.0, 1.0);
  61     m_coneGain = AudioGain::create(context, "coneGain", 1.0, 0.0, 1.0);
  62
  63     m_position = FloatPoint3D(0, 0, 0);
  64     m_orientation = FloatPoint3D(1, 0, 0);
  65     m_velocity = FloatPoint3D(0, 0, 0);
  66
  67     setNodeType(NodeTypePanner);
  68
  69     initialize();
  70 }
  71
  72 PannerNode::~PannerNode()
  73 {
  74     uninitialize();
  75 }
  76
  77 void PannerNode::pullInputs(size_t framesToProcess)
  78 {
  79     // We override pullInputs(), so we can detect new AudioSourceNodes which have connected to us when new connections are made.
  80     // These AudioSourceNodes need to be made aware of our existence in order to handle doppler shift pitch changes.
  81     if (m_connectionCount != context()->connectionCount()) {
  82         m_connectionCount = context()->connectionCount();
  83
  84         // Recursively go through all nodes connected to us.
  85         notifyAudioSourcesConnectedToNode(this);
  86     }
  87
  88     AudioNode::pullInputs(framesToProcess);
  89 }
  90
  91 void PannerNode::process(size_t framesToProcess)
  92 {
  93     AudioBus* destination = output(0)->bus();
  94
  95     if (!isInitialized() || !input(0)->isConnected() || !m_panner.get()) {
  96         destination->zero();
  97         return;
  98     }
  99
 100     AudioBus* source = input(0)->bus();
 101
 102     if (!source) {
 103         destination->zero();
 104         return;
 105     }
 106
 107     // Apply the panning effect.
 108     double azimuth;
 109     double elevation;
 110     getAzimuthElevation(&azimuth, &elevation);
 111     m_panner->pan(azimuth, elevation, source, destination, framesToProcess);
 112
 113     // Get the distance and cone gain.
 114     double totalGain = distanceConeGain();
 115
 116     // Snap to desired gain at the beginning.
 117     if (m_lastGain == -1.0)
 118         m_lastGain = totalGain;
 119
 120     // Apply gain in-place with de-zippering.
 121     destination->copyWithGainFrom(*destination, &m_lastGain, totalGain);
 122 }
 123
 124 void PannerNode::reset()
 125 {
 126     m_lastGain = -1.0; // force to snap to initial gain
 127     if (m_panner.get())
 128         m_panner->reset();
 129 }
 130
 131 void PannerNode::initialize()
 132 {
 133     if (isInitialized())
 134         return;
 135
 136     m_panner = Panner::create(m_panningModel, sampleRate());
 137
 138     AudioNode::initialize();
 139 }
 140
 141 void PannerNode::uninitialize()
 142 {
 143     if (!isInitialized())
 144         return;
 145
 146     m_panner.clear();
 147     AudioNode::uninitialize();
 148 }
 149
 150 AudioListener* PannerNode::listener()
 151 {
 152     return context()->listener();
 153 }
 154
 155 String PannerNode::panningModel() const
 156 {
 157     switch (m_panningModel) {
 158     case EQUALPOWER:
 159         return "equalpower";
 160     case HRTF:
 161         return "HRTF";
 162     case SOUNDFIELD:
 163         return "soundfield";
 164     default:
 165         ASSERT_NOT_REACHED();
 166         return "HRTF";
 167     }
 168 }
 169
 170 void PannerNode::setPanningModel(const String& model)
 171 {
 172     if (model == "equalpower")
 173         setPanningModel(EQUALPOWER);
 174     else if (model == "HRTF")
 175         setPanningModel(HRTF);
 176     else if (model == "soundfield")
 177         setPanningModel(SOUNDFIELD);
 178     else
 179         ASSERT_NOT_REACHED();
 180 }
 181
 182 bool PannerNode::setPanningModel(unsigned model)
 183 {
 184     switch (model) {
 185     case EQUALPOWER:
 186     case HRTF:
 187         if (!m_panner.get() || model != m_panningModel) {
 188             OwnPtr<Panner> newPanner = Panner::create(model, sampleRate());
 189             m_panner = newPanner.release();
 190             m_panningModel = model;
 191         }
 192         break;
 193     case SOUNDFIELD:
 194         // FIXME: Implement sound field model. See // https://bugs.webkit.org/show_bug.cgi?id=77367.
 195         context()->scriptExecutionContext()->addConsoleMessage(JSMessageSource, WarningMessageLevel, "'soundfield' panning model not implemented.");
 196         break;
 197     default:
 198         return false;
 199     }
 200
 201     return true;
 202 }
 203
 204 String PannerNode::distanceModel() const
 205 {
 206     switch (const_cast<PannerNode*>(this)->m_distanceEffect.model()) {
 207     case DistanceEffect::ModelLinear:
 208         return "linear";
 209     case DistanceEffect::ModelInverse:
 210         return "inverse";
 211     case DistanceEffect::ModelExponential:
 212         return "exponential";
 213     default:
 214         ASSERT_NOT_REACHED();
 215         return "inverse";
 216     }
 217 }
 218
 219 void PannerNode::setDistanceModel(const String& model)
 220 {
 221     if (model == "linear")
 222         setDistanceModel(DistanceEffect::ModelLinear);
 223     else if (model == "inverse")
 224         setDistanceModel(DistanceEffect::ModelInverse);
 225     else if (model == "exponential")
 226         setDistanceModel(DistanceEffect::ModelExponential);
 227     else
 228         ASSERT_NOT_REACHED();
 229 }
 230
 231 bool PannerNode::setDistanceModel(unsigned model)
 232 {
 233     switch (model) {
 234     case DistanceEffect::ModelLinear:
 235     case DistanceEffect::ModelInverse:
 236     case DistanceEffect::ModelExponential:
 237         m_distanceEffect.setModel(static_cast<DistanceEffect::ModelType>(model), true);
 238         break;
 239     default:
 240         return false;
 241     }
 242
 243     return true;
 244 }
 245
 246 void PannerNode::getAzimuthElevation(double* outAzimuth, double* outElevation)
 247 {
 248     // FIXME: we should cache azimuth and elevation (if possible), so we only re-calculate if a change has been made.
 249
 250     double azimuth = 0.0;
 251
 252     // Calculate the source-listener vector
 253     FloatPoint3D listenerPosition = listener()->position();
 254     FloatPoint3D sourceListener = m_position - listenerPosition;
 255
 256     if (sourceListener.isZero()) {
 257         // degenerate case if source and listener are at the same point
 258         *outAzimuth = 0.0;
 259         *outElevation = 0.0;
 260         return;
 261     }
 262
 263     sourceListener.normalize();
 264
 265     // Align axes
 266     FloatPoint3D listenerFront = listener()->orientation();
 267     FloatPoint3D listenerUp = listener()->upVector();
 268     FloatPoint3D listenerRight = listenerFront.cross(listenerUp);
 269     listenerRight.normalize();
 270
 271     FloatPoint3D listenerFrontNorm = listenerFront;
 272     listenerFrontNorm.normalize();
 273
 274     FloatPoint3D up = listenerRight.cross(listenerFrontNorm);
 275
 276     float upProjection = sourceListener.dot(up);
 277
 278     FloatPoint3D projectedSource = sourceListener - upProjection * up;
 279     projectedSource.normalize();
 280
 281     azimuth = 180.0 * acos(projectedSource.dot(listenerRight)) / piDouble;
 282     fixNANs(azimuth); // avoid illegal values
 283
 284     // Source  in front or behind the listener
 285     double frontBack = projectedSource.dot(listenerFrontNorm);
 286     if (frontBack < 0.0)
 287         azimuth = 360.0 - azimuth;
 288
 289     // Make azimuth relative to "front" and not "right" listener vector
 290     if ((azimuth >= 0.0) && (azimuth <= 270.0))
 291         azimuth = 90.0 - azimuth;
 292     else
 293         azimuth = 450.0 - azimuth;
 294
 295     // Elevation
 296     double elevation = 90.0 - 180.0 * acos(sourceListener.dot(up)) / piDouble;
 297     fixNANs(elevation); // avoid illegal values
 298
 299     if (elevation > 90.0)
 300         elevation = 180.0 - elevation;
 301     else if (elevation < -90.0)
 302         elevation = -180.0 - elevation;
 303
 304     if (outAzimuth)
 305         *outAzimuth = azimuth;
 306     if (outElevation)
 307         *outElevation = elevation;
 308 }
 309
 310 float PannerNode::dopplerRate()
 311 {
 312     double dopplerShift = 1.0;
 313
 314     // FIXME: optimize for case when neither source nor listener has changed...
 315     double dopplerFactor = listener()->dopplerFactor();
 316
 317     if (dopplerFactor > 0.0) {
 318         double speedOfSound = listener()->speedOfSound();
 319
 320         const FloatPoint3D &sourceVelocity = m_velocity;
 321         const FloatPoint3D &listenerVelocity = listener()->velocity();
 322
 323         // Don't bother if both source and listener have no velocity
 324         bool sourceHasVelocity = !sourceVelocity.isZero();
 325         bool listenerHasVelocity = !listenerVelocity.isZero();
 326
 327         if (sourceHasVelocity || listenerHasVelocity) {
 328             // Calculate the source to listener vector
 329             FloatPoint3D listenerPosition = listener()->position();
 330             FloatPoint3D sourceToListener = m_position - listenerPosition;
 331
 332             double sourceListenerMagnitude = sourceToListener.length();
 333
 334             double listenerProjection = sourceToListener.dot(listenerVelocity) / sourceListenerMagnitude;
 335             double sourceProjection = sourceToListener.dot(sourceVelocity) / sourceListenerMagnitude;
 336
 337             listenerProjection = -listenerProjection;
 338             sourceProjection = -sourceProjection;
 339
 340             double scaledSpeedOfSound = speedOfSound / dopplerFactor;
 341             listenerProjection = min(listenerProjection, scaledSpeedOfSound);
 342             sourceProjection = min(sourceProjection, scaledSpeedOfSound);
 343
 344             dopplerShift = ((speedOfSound - dopplerFactor * listenerProjection) / (speedOfSound - dopplerFactor * sourceProjection));
 345             fixNANs(dopplerShift); // avoid illegal values
 346
 347             // Limit the pitch shifting to 4 octaves up and 3 octaves down.
 348             if (dopplerShift > 16.0)
 349                 dopplerShift = 16.0;
 350             else if (dopplerShift < 0.125)
 351                 dopplerShift = 0.125;
 352         }
 353     }
 354
 355     return static_cast<float>(dopplerShift);
 356 }
 357
 358 float PannerNode::distanceConeGain()
 359 {
 360     FloatPoint3D listenerPosition = listener()->position();
 361
 362     double listenerDistance = m_position.distanceTo(listenerPosition);
 363     double distanceGain = m_distanceEffect.gain(listenerDistance);
 364
 365     m_distanceGain->setValue(static_cast<float>(distanceGain));
 366
 367     // FIXME: could optimize by caching coneGain
 368     double coneGain = m_coneEffect.gain(m_position, m_orientation, listenerPosition);
 369
 370     m_coneGain->setValue(static_cast<float>(coneGain));
 371
 372     return float(distanceGain * coneGain);
 373 }
 374
 375 void PannerNode::notifyAudioSourcesConnectedToNode(AudioNode* node)
 376 {
 377     ASSERT(node);
 378     if (!node)
 379         return;
 380
 381     // First check if this node is an AudioBufferSourceNode. If so, let it know about us so that doppler shift pitch can be taken into account.
 382     if (node->nodeType() == NodeTypeAudioBufferSource) {
 383         AudioBufferSourceNode* bufferSourceNode = reinterpret_cast<AudioBufferSourceNode*>(node);
 384         bufferSourceNode->setPannerNode(this);
 385     } else {
 386         // Go through all inputs to this node.
 387         for (unsigned i = 0; i < node->numberOfInputs(); ++i) {
 388             AudioNodeInput* input = node->input(i);
 389
 390             // For each input, go through all of its connections, looking for AudioBufferSourceNodes.
 391             for (unsigned j = 0; j < input->numberOfRenderingConnections(); ++j) {
 392                 AudioNodeOutput* connectedOutput = input->renderingOutput(j);
 393                 AudioNode* connectedNode = connectedOutput->node();
 394                 notifyAudioSourcesConnectedToNode(connectedNode); // recurse
 395             }
 396         }
 397     }
 398 }
 399
 400 } // namespace WebCore
 401
 402 #endif // ENABLE(WEB_AUDIO)