Cache values for panning and spatialization effects to enhance performance on pannerNode.

Source/modules/webaudio/PannerNode.cpp

 /*
  * Copyright (C) 2010, Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1.  Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 31 matching lines @@
 
 static void fixNANs(double &x)
 {
     if (std::isnan(x) || std::isinf(x))
         x = 0.0;
 }
 
 PannerNode::PannerNode(AudioContext* context, float sampleRate)
     : AudioNode(context, sampleRate)
     , m_panningModel(Panner::PanningModelHRTF)
+    , m_position(0, 0, 0)
+    , m_orientation(1, 0, 0)
+    , m_velocity(0, 0, 0)
+    , m_cachedPosition(0, 0, 0)
+    , m_cachedOrientation(1, 0, 0)
+    , m_cachedVelocity(0, 0, 0)
     , m_lastGain(-1.0)
+    , m_cachedAzimuth(0)
+    , m_cachedElevation(0)
+    , m_cachedDistanceConeGain(0)
+    , m_cachedDopplerRate(1)
     , m_connectionCount(0)
 {
     // Load the HRTF database asynchronously so we don't block the Javascript thread while creating the HRTF database.
     // The HRTF panner will return zeroes until the database is loaded.
     m_hrtfDatabaseLoader = HRTFDatabaseLoader::createAndLoadAsynchronouslyIfNecessary(context->sampleRate());
 
     ScriptWrappable::init(this);
     addInput(adoptPtr(new AudioNodeInput(this)));
     addOutput(adoptPtr(new AudioNodeOutput(this, 2)));
 
     // Node-specific default mixing rules.
     m_channelCount = 2;
     m_channelCountMode = ClampedMax;
     m_channelInterpretation = AudioBus::Speakers;
 
     m_distanceGain = AudioParam::create(context, "distanceGain", 1.0, 0.0, 1.0);
     m_coneGain = AudioParam::create(context, "coneGain", 1.0, 0.0, 1.0);
 
-    m_position = FloatPoint3D(0, 0, 0);
-    m_orientation = FloatPoint3D(1, 0, 0);
-    m_velocity = FloatPoint3D(0, 0, 0);
+    m_cachedListener = AudioListener::create();
 
     setNodeType(NodeTypePanner);
 
     initialize();
 }
 
 PannerNode::~PannerNode()
 {
     uninitialize();
 }
@@ skipping 40 matching lines @@
             return;
         }
     }
 
     // The audio thread can't block on this lock, so we call tryLock() instead.
     MutexTryLocker tryLocker(m_pannerLock);
     if (tryLocker.locked()) {
         // Apply the panning effect.
         double azimuth;
         double elevation;
-        getAzimuthElevation(&azimuth, &elevation);
+        azimuthElevation(&azimuth, &elevation);
+
         m_panner->pan(azimuth, elevation, source, destination, framesToProcess);
 
         // Get the distance and cone gain.
-        double totalGain = distanceConeGain();
+        float totalGain = distanceConeGain();
 
         // Snap to desired gain at the beginning.
         if (m_lastGain == -1.0)
             m_lastGain = totalGain;
 
         // Apply gain in-place with de-zippering.
         destination->copyWithGainFrom(*destination, &m_lastGain, totalGain);
+
+        // Update the cached listener in case listener has moved.
+        updateCachedListener();
+        // Now update the cached source location in case the source has changed.
+        updateCachedSourceLocationInfo();
     } else {
         // Too bad - The tryLock() failed. We must be in the middle of changing the panner.
         destination->zero();
     }
 }
 
 void PannerNode::initialize()
 {
     if (isInitialized())
         return;
@@ skipping 54 matching lines @@
             m_panningModel = model;
         }
         break;
     default:
         return false;
     }
 
     return true;
 }
 
+void PannerNode::setPosition(float x, float y, float z)
+{
+    // FIXME : consider thread safety about m_position in audio thread.
+    // See http://crbugs.com/350583.
+    FloatPoint3D position = FloatPoint3D(x, y, z);
+
+    if (m_position == position)
+        return;
+
+    m_position = position;
+}
+
+void PannerNode::setOrientation(float x, float y, float z)
+{
+    // FIXME : consider thread safety about m_orientation in audio thread.
+    // See http://crbugs.com/350583.
+    FloatPoint3D orientation = FloatPoint3D(x, y, z);
+
+    if (m_orientation == orientation)
+        return;
+
+    m_orientation = orientation;
+}
+
+void PannerNode::setVelocity(float x, float y, float z)
+{
+    // FIXME : consider thread safety about m_velocity in audio thread.
+    // See http://crbugs.com/350583.
+    FloatPoint3D velocity = FloatPoint3D(x, y, z);
+
+    if (m_velocity == velocity)
+        return;
+
+    m_velocity = velocity;
+}
+
 String PannerNode::distanceModel() const
 {
     switch (const_cast<PannerNode*>(this)->m_distanceEffect.model()) {
     case DistanceEffect::ModelLinear:
         return "linear";
     case DistanceEffect::ModelInverse:
         return "inverse";
     case DistanceEffect::ModelExponential:
         return "exponential";
     default:
@@ skipping 22 matching lines @@
     case DistanceEffect::ModelExponential:
         m_distanceEffect.setModel(static_cast<DistanceEffect::ModelType>(model), true);
         break;
     default:
         return false;
     }
 
     return true;
 }
 
-void PannerNode::getAzimuthElevation(double* outAzimuth, double* outElevation)
+void PannerNode::calculateAzimuthElevation(double* outAzimuth, double* outElevation)
 {
-    // FIXME: we should cache azimuth and elevation (if possible), so we only re-calculate if a change has been made.
-
     double azimuth = 0.0;
 
     // Calculate the source-listener vector
     FloatPoint3D listenerPosition = listener()->position();
     FloatPoint3D sourceListener = m_position - listenerPosition;
 
     if (sourceListener.isZero()) {
         // degenerate case if source and listener are at the same point
         *outAzimuth = 0.0;
         *outElevation = 0.0;
@@ skipping 40 matching lines @@
         elevation = 180.0 - elevation;
     else if (elevation < -90.0)
         elevation = -180.0 - elevation;
 
     if (outAzimuth)
         *outAzimuth = azimuth;
     if (outElevation)
         *outElevation = elevation;
 }
 
-float PannerNode::dopplerRate()
+
+double PannerNode::calculateDopplerRate()
 {
     double dopplerShift = 1.0;
-
-    // FIXME: optimize for case when neither source nor listener has changed...
     double dopplerFactor = listener()->dopplerFactor();
 
     if (dopplerFactor > 0.0) {
         double speedOfSound = listener()->speedOfSound();
 
         const FloatPoint3D &sourceVelocity = m_velocity;
         const FloatPoint3D &listenerVelocity = listener()->velocity();
 
         // Don't bother if both source and listener have no velocity
         bool sourceHasVelocity = !sourceVelocity.isZero();
@@ skipping 20 matching lines @@
             fixNANs(dopplerShift); // avoid illegal values
 
             // Limit the pitch shifting to 4 octaves up and 3 octaves down.
             if (dopplerShift > 16.0)
                 dopplerShift = 16.0;
             else if (dopplerShift < 0.125)
                 dopplerShift = 0.125;
         }
     }
 
-    return static_cast<float>(dopplerShift);
+    return dopplerShift;
 }
 
-float PannerNode::distanceConeGain()
+float PannerNode::calculateDistanceConeGain()
 {
     FloatPoint3D listenerPosition = listener()->position();
 
     double listenerDistance = m_position.distanceTo(listenerPosition);
     double distanceGain = m_distanceEffect.gain(listenerDistance);
 
     m_distanceGain->setValue(static_cast<float>(distanceGain));
 
-    // FIXME: could optimize by caching coneGain
     double coneGain = m_coneEffect.gain(m_position, m_orientation, listenerPosition);
 
     m_coneGain->setValue(static_cast<float>(coneGain));
 
     return float(distanceGain * coneGain);
 }
 
+void PannerNode::azimuthElevation(double* outAzimuth, double* outElevation)
+{
+    if (isAzimuthElevationDirty())
+        calculateAzimuthElevation(&m_cachedAzimuth, &m_cachedElevation);
+
+    *outAzimuth = m_cachedAzimuth;
+    *outElevation = m_cachedElevation;
+}
+
+double PannerNode::dopplerRate()
+{
+    if (isDopplerRateDirty())
+        m_cachedDopplerRate = calculateDopplerRate();
+
+    return m_cachedDopplerRate;
+}
+
+float PannerNode::distanceConeGain()
+{
+    if (isDistanceConeGainDirty())
+        m_cachedDistanceConeGain = calculateDistanceConeGain();
+
+    return m_cachedDistanceConeGain;
+}
+
+bool PannerNode::isAzimuthElevationDirty()
+{
+    if (m_cachedPosition != m_position)

[Raymond Toy, 2014/03/10 20:47:20]

Nit:  Add comment:

// Do a quick test and return if possible.

Add similar comment to isDistanceConeGainDirty and isDopplerDirty. Since the
original discussion of this is gone, a comment here is useful so future
developers don't combine them into one.

Recall that boolean operations shortcut, so you could combine the two if
statements into one big if statement and there's no loss in speed.

[KhNo, 2014/03/11 05:32:12]

Done.

+        return true;
+
+    if (m_cachedListener->position() != listener()->position()
+        || m_cachedListener->orientation() != listener()->orientation()
+        || m_cachedListener->upVector() != listener()->upVector())
+        return true;
+
+    return false;
+}
+
+bool PannerNode::isDistanceConeGainDirty()
+{
+    if (m_cachedPosition != m_position || m_cachedOrientation != m_orientation)
+        return true;
+
+    if (m_cachedListener->position() != listener()->position())
+        return true;
+
+    return false;
+}
+
+bool PannerNode::isDopplerRateDirty()
+{
+    if (m_cachedPosition != m_position || m_cachedVelocity != m_velocity)
+        return true;
+
+    if (m_cachedListener->position() != listener()->position()
+        || m_cachedListener->velocity() != listener()->velocity()
+        || m_cachedListener->dopplerFactor() != listener()->dopplerFactor()
+        || m_cachedListener->speedOfSound() != listener()->speedOfSound())
+        return true;
+
+    return false;
+}
+
 void PannerNode::notifyAudioSourcesConnectedToNode(AudioNode* node, HashMap<AudioNode*, bool>& visitedNodes)
 {
     ASSERT(node);
     if (!node)
         return;
 
     // 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.
     if (node->nodeType() == NodeTypeAudioBufferSource) {
         AudioBufferSourceNode* bufferSourceNode = static_cast<AudioBufferSourceNode*>(node);
         bufferSourceNode->setPannerNode(this);
@@ skipping 12 matching lines @@
                 // mark it as visited and recurse through the node looking for sources.
                 if (iterator == visitedNodes.end()) {
                     visitedNodes.set(connectedNode, true);
                     notifyAudioSourcesConnectedToNode(connectedNode, visitedNodes); // recurse
                 }
             }
         }
     }
 }
 
+void PannerNode::updateCachedListener()
+{
+    m_cachedListener->setPosition(listener()->position());
+    m_cachedListener->setOrientation(listener()->orientation());
+    m_cachedListener->setUpVector(listener()->upVector());
+    m_cachedListener->setVelocity(listener()->velocity());
+    m_cachedListener->setDopplerFactor(listener()->dopplerFactor());
+    m_cachedListener->setSpeedOfSound(listener()->speedOfSound());
+}
+
+void PannerNode::updateCachedSourceLocationInfo()
+{
+    m_cachedPosition = m_position;
+    m_cachedOrientation = m_orientation;
+    m_cachedVelocity = m_velocity;
+}
+
 } // namespace WebCore
 
 #endif // ENABLE(WEB_AUDIO)