Add logic to cache elements of panner node from calculation with own attributes and AudioListener

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 35 matching lines @@
         x = 0.0;
 }
 
 PannerNode::PannerNode(AudioContext* context, float sampleRate)
     : AudioNode(context, sampleRate)
     , m_panningModel(Panner::PanningModelHRTF)
     , m_distanceModel(DistanceEffect::ModelInverse)
     , 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_isAzimuthElevationDirty(true)
+    , m_isDistanceConeGainDirty(true)
+    , m_isDopplerRateDirty(true)
     , m_lastGain(-1.0)
     , m_cachedAzimuth(0)
     , m_cachedElevation(0)
     , m_cachedDistanceConeGain(1.0f)
     , 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_cachedListener = AudioListener::create();
-
     setNodeType(NodeTypePanner);
 
     initialize();
 }
 
 PannerNode::~PannerNode()
 {
     uninitialize();
 }
 
@@ skipping 25 matching lines @@
     }
 
     AudioBus* source = input(0)->bus();
     if (!source) {
         destination->zero();
         return;
     }
 
     // The audio thread can't block on this lock, so we call tryLock() instead.
     MutexTryLocker tryLocker(m_processLock);
-    if (tryLocker.locked()) {
+    MutexTryLocker tryListenerLocker(listener()->listenerLock());
+
+    if (tryLocker.locked() && tryListenerLocker.locked()) {
         // HRTFDatabase should be loaded before proceeding for offline audio context when the panning model is HRTF.
         if (m_panningModel == HRTF && !m_hrtfDatabaseLoader->isLoaded()) {
             if (context()->isOfflineContext()) {
                 m_hrtfDatabaseLoader->waitForLoaderThreadCompletion();
             } else {
                 destination->zero();
                 return;
             }
         }
 
         // Apply the panning effect.
         double azimuth;
         double elevation;
         azimuthElevation(&azimuth, &elevation);
 
         m_panner->pan(azimuth, elevation, source, destination, framesToProcess);
 
         // Get the distance and cone gain.
         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 panning model, the distance model, or the source's location information.
+        // We must be in the middle of changing the properties of the panner or the listener.
         destination->zero();
     }
 }
 
 void PannerNode::initialize()
 {
     if (isInitialized())
         return;
 
     m_panner = Panner::create(m_panningModel, sampleRate(), m_hrtfDatabaseLoader.get());
+    listener()->addPanner(this);
 
     AudioNode::initialize();
 }
 
 void PannerNode::uninitialize()
 {
     if (!isInitialized())
         return;
 
     m_panner.clear();
+    listener()->removePanner(this);
+
     AudioNode::uninitialize();
 }
 
 AudioListener* PannerNode::listener()
 {
     return context()->listener();
 }
 
 String PannerNode::panningModel() const
 {
     switch (m_panningModel) {
-    case EQUALPOWER:
+    case EqualPower:
         return "equalpower";
     case HRTF:
         return "HRTF";
     default:
         ASSERT_NOT_REACHED();
         return "HRTF";
     }
 }
 
 void PannerNode::setPanningModel(const String& model)
 {
     if (model == "equalpower")
-        setPanningModel(EQUALPOWER);
+        setPanningModel(EqualPower);
     else if (model == "HRTF")
         setPanningModel(HRTF);
 }
 
 bool PannerNode::setPanningModel(unsigned model)
 {
     switch (model) {
-    case EQUALPOWER:
+    case EqualPower:
     case HRTF:
         if (!m_panner.get() || model != m_panningModel) {
             // This synchronizes with process().
             MutexLocker processLocker(m_processLock);
-

[Raymond Toy, 2014/04/21 16:48:26]

Question:  If you didn't delete this line (and you shouldn't), can you keep the
original uppercase panning model enums?

[KhNo, 2014/04/21 17:29:01]

That was for making code consensus before calling mutex lock with others since
only here has empty line. If you want let empty line, I will.

As you know, I added new enum, but there is webkit style checker error. So it
also changed for code consensus. It can be changed if it is fine that new added
enum only has different style enum in header. If you want it, I will change back
to original uppercase style for two enum type, panningmodel and distancemodel.

[Raymond Toy, 2014/04/22 00:57:49]

I leave it up to you. It's just that I don't like CLs that change parts of the
code that aren't really related to the CL itself.

[KhNo, 2014/04/22 06:20:09]

Definitely, you're right. It is good for others. I will seperate it.

             OwnPtr<Panner> newPanner = Panner::create(model, sampleRate(), m_hrtfDatabaseLoader.get());
             m_panner = newPanner.release();
             m_panningModel = model;
         }
         break;
     default:
         return false;
     }
 
     return true;
 }
 
-void PannerNode::setPosition(float x, float y, float z)
-{
-    FloatPoint3D position = FloatPoint3D(x, y, z);
-
-    if (m_position == position)
-        return;
-
-    // This synchronizes with process().
-    MutexLocker processLocker(m_processLock);
-
-    m_position = position;
-}
-
-void PannerNode::setOrientation(float x, float y, float z)
-{
-    FloatPoint3D orientation = FloatPoint3D(x, y, z);
-
-    if (m_orientation == orientation)
-        return;
-
-    // This synchronizes with process().
-    MutexLocker processLocker(m_processLock);
-
-    m_orientation = orientation;
-}
-
-void PannerNode::setVelocity(float x, float y, float z)
-{
-    FloatPoint3D velocity = FloatPoint3D(x, y, z);
-
-    if (m_velocity == velocity)
-        return;
-
-    // This synchronizes with process().
-    MutexLocker processLocker(m_processLock);
-
-    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 25 matching lines @@
             m_distanceModel = model;
         }
         break;
     default:
         return false;
     }
 
     return true;
 }
 
+void PannerNode::setRefDistance(double distance)
+{
+    if (refDistance() == distance)
+        return;
+
+    // This synchronizes with process().
+    MutexLocker processLocker(m_processLock);
+    m_distanceEffect.setRefDistance(distance);
+    markPannerAsDirty(PannerNode::DistanceConeGainDirty);
+}
+
+void PannerNode::setMaxDistance(double distance)
+{
+    if (maxDistance() == distance)
+        return;
+
+    // This synchronizes with process().
+    MutexLocker processLocker(m_processLock);
+    m_distanceEffect.setMaxDistance(distance);
+    markPannerAsDirty(PannerNode::DistanceConeGainDirty);
+}
+
+void PannerNode::setRolloffFactor(double factor)
+{
+    if (rolloffFactor() == factor)
+        return;
+
+    // This synchronizes with process().
+    MutexLocker processLocker(m_processLock);
+    m_distanceEffect.setRolloffFactor(factor);
+    markPannerAsDirty(PannerNode::DistanceConeGainDirty);
+}
+
+void PannerNode::setConeInnerAngle(double angle)
+{
+    if (coneInnerAngle() == angle)
+        return;
+
+    // This synchronizes with process().
+    MutexLocker processLocker(m_processLock);
+    m_coneEffect.setInnerAngle(angle);
+    markPannerAsDirty(PannerNode::DistanceConeGainDirty);
+}
+
+void PannerNode::setConeOuterAngle(double angle)
+{
+    if (coneOuterAngle() == angle)
+        return;
+
+    // This synchronizes with process().
+    MutexLocker processLocker(m_processLock);
+    m_coneEffect.setOuterAngle(angle);
+    markPannerAsDirty(PannerNode::DistanceConeGainDirty);
+}
+
+void PannerNode::setConeOuterGain(double angle)
+{
+    if (coneOuterGain() == angle)
+        return;
+
+    // This synchronizes with process().
+    MutexLocker processLocker(m_processLock);
+    m_coneEffect.setOuterGain(angle);
+    markPannerAsDirty(PannerNode::DistanceConeGainDirty);
+}
+
+void PannerNode::setPosition(float x, float y, float z)
+{
+    FloatPoint3D position = FloatPoint3D(x, y, z);
+
+    if (m_position == position)
+        return;
+
+    // This synchronizes with process().
+    MutexLocker processLocker(m_processLock);
+    m_position = position;
+    markPannerAsDirty(PannerNode::AzimuthElevationDirty | PannerNode::DistanceConeGainDirty | PannerNode::DopplerRateDirty);
+}
+
+void PannerNode::setOrientation(float x, float y, float z)
+{
+    FloatPoint3D orientation = FloatPoint3D(x, y, z);
+
+    if (m_orientation == orientation)
+        return;
+
+    // This synchronizes with process().
+    MutexLocker processLocker(m_processLock);
+    m_orientation = orientation;
+    markPannerAsDirty(PannerNode::DistanceConeGainDirty);
+}
+
+void PannerNode::setVelocity(float x, float y, float z)
+{
+    FloatPoint3D velocity = FloatPoint3D(x, y, z);
+
+    if (m_velocity == velocity)
+        return;
+
+    // This synchronizes with process().
+    MutexLocker processLocker(m_processLock);
+    m_velocity = velocity;
+    markPannerAsDirty(PannerNode::DopplerRateDirty);
+}
+
 void PannerNode::calculateAzimuthElevation(double* outAzimuth, double* outElevation)
 {
     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
@@ skipping 103 matching lines @@
     double distanceGain = m_distanceEffect.gain(listenerDistance);
     double coneGain = m_coneEffect.gain(m_position, m_orientation, listenerPosition);
 
     return float(distanceGain * coneGain);
 }
 
 void PannerNode::azimuthElevation(double* outAzimuth, double* outElevation)
 {
     ASSERT(context()->isAudioThread());
 
-    if (isAzimuthElevationDirty())
+    if (isAzimuthElevationDirty()) {
         calculateAzimuthElevation(&m_cachedAzimuth, &m_cachedElevation);
+        m_isAzimuthElevationDirty = false;
+    }
 
     *outAzimuth = m_cachedAzimuth;
     *outElevation = m_cachedElevation;
 }
 
 double PannerNode::dopplerRate()
 {
     ASSERT(context()->isAudioThread());
 
-    if (isDopplerRateDirty())
+    if (isDopplerRateDirty()) {
         m_cachedDopplerRate = calculateDopplerRate();
+        m_isDopplerRateDirty = false;
+    }
 
     return m_cachedDopplerRate;
 }
 
 float PannerNode::distanceConeGain()
 {
     ASSERT(context()->isAudioThread());
 
-    if (isDistanceConeGainDirty())
+    if (isDistanceConeGainDirty()) {
         m_cachedDistanceConeGain = calculateDistanceConeGain();
+        m_isDistanceConeGainDirty = false;
+    }
 
     return m_cachedDistanceConeGain;
 }
 
-bool PannerNode::isAzimuthElevationDirty()
+void PannerNode::markPannerAsDirty(unsigned dirty)
 {
-    // Do a quick test and return if possible.
-    if (m_cachedPosition != m_position)
-        return true;
+    if (dirty & PannerNode::AzimuthElevationDirty)
+        m_isAzimuthElevationDirty = true;
 
-    if (m_cachedListener->position() != listener()->position()
-        || m_cachedListener->orientation() != listener()->orientation()
-        || m_cachedListener->upVector() != listener()->upVector())
-        return true;
+    if (dirty & PannerNode::DistanceConeGainDirty)
+        m_isDistanceConeGainDirty = true;
 
-    return false;
-}
-
-bool PannerNode::isDistanceConeGainDirty()
-{
-    // Do a quick test and return if possible.
-    if (m_cachedPosition != m_position || m_cachedOrientation != m_orientation)
-        return true;
-
-    if (m_cachedListener->position() != listener()->position())
-        return true;
-
-    return false;
-}
-
-bool PannerNode::isDopplerRateDirty()
-{
-    // Do a quick test and return if possible.
-    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;
+    if (dirty & PannerNode::DopplerRateDirty)
+        m_isDopplerRateDirty = true;
 }
 
 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) {
@@ skipping 14 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()
-{
-    ASSERT(context()->isAudioThread());
-
-    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()
-{
-    ASSERT(context()->isAudioThread());
-
-    m_cachedPosition = m_position;
-    m_cachedOrientation = m_orientation;
-    m_cachedVelocity = m_velocity;
-}
-
 } // namespace WebCore
 
 #endif // ENABLE(WEB_AUDIO)