Implement Automations for PannerNode and AutioListener

third_party/WebKit/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 24 matching lines @@
 #include "wtf/MathExtras.h"
 
 namespace blink {
 
 static void fixNANs(double& x)
 {
     if (std::isnan(x) || std::isinf(x))
         x = 0.0;
 }
 
-PannerHandler::PannerHandler(AudioNode& node, float sampleRate)
+PannerHandler::PannerHandler(
+    AudioNode& node, float sampleRate,
+    AudioParamHandler& positionX,
+    AudioParamHandler& positionY,
+    AudioParamHandler& positionZ,
+    AudioParamHandler& orientationX,
+    AudioParamHandler& orientationY,
+    AudioParamHandler& orientationZ)
     : AudioHandler(NodeTypePanner, node, sampleRate)
     , m_listener(node.context()->listener())
     , m_panningModel(Panner::PanningModelEqualPower)
     , m_distanceModel(DistanceEffect::ModelInverse)
-    , m_position(0, 0, 0)
-    , m_orientation(1, 0, 0)
     , m_isAzimuthElevationDirty(true)
     , m_isDistanceConeGainDirty(true)
     , m_lastGain(-1.0)
     , m_cachedAzimuth(0)
     , m_cachedElevation(0)
     , m_cachedDistanceConeGain(1.0f)
+    , m_positionX(positionX)
+    , m_positionY(positionY)
+    , m_positionZ(positionZ)
+    , m_orientationX(orientationX)
+    , m_orientationY(orientationY)
+    , m_orientationZ(orientationZ)
 {
     // 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.
     listener()->createAndLoadHRTFDatabaseLoader(node.context()->sampleRate());
 
     addInput();
     addOutput(2);
 
     // Node-specific default mixing rules.
     m_channelCount = 2;
     m_channelCountMode = ClampedMax;
     m_channelInterpretation = AudioBus::Speakers;
 
     initialize();
 }
 
-PassRefPtr<PannerHandler> PannerHandler::create(AudioNode& node, float sampleRate)
+PassRefPtr<PannerHandler> PannerHandler::create(
+    AudioNode& node, float sampleRate,
+    AudioParamHandler& positionX,
+    AudioParamHandler& positionY,
+    AudioParamHandler& positionZ,
+    AudioParamHandler& orientationX,
+    AudioParamHandler& orientationY,
+    AudioParamHandler& orientationZ)
 {
-    return adoptRef(new PannerHandler(node, sampleRate));
+    return adoptRef(new PannerHandler(
+        node,
+        sampleRate,
+        positionX,
+        positionY,
+        positionZ,
+        orientationX,
+        orientationY,
+        orientationZ));
 }
 
 PannerHandler::~PannerHandler()
 {
     uninitialize();
 }
 
 void PannerHandler::process(size_t framesToProcess)
 {
     AudioBus* destination = output(0).bus();
@@ skipping 18 matching lines @@
         if (m_panningModel == Panner::PanningModelHRTF && !listener()->isHRTFDatabaseLoaded()) {
             if (context()->hasRealtimeConstraint()) {
                 // Some AbstractAudioContexts cannot block on the HRTFDatabase loader.
                 destination->zero();
                 return;
             }
 
             listener()->waitForHRTFDatabaseLoaderThreadCompletion();
         }
 
-        // Apply the panning effect.
-        double azimuth;
-        double elevation;
-        azimuthElevation(&azimuth, &elevation);
+        if (hasSampleAccurateValues() || listener()->hasSampleAccurateValues()) {
+            // It's tempting to skip sample-accurate processing if isAzimuthElevationDirty() and
+            // isDistanceConeGain() both return false.  But in general we can't because something
+            // may scheduled to start in the middle of the rendering quantum.  On the other hand,
+            // the audible effect may be small enough that we can afford to do this optimization.
+            processSampleAccurateValues(destination, source, framesToProcess);
+        } else {
+            // Apply the panning effect.
+            double azimuth;
+            double elevation;
+            azimuthElevation(&azimuth, &elevation);
 
-        m_panner->pan(azimuth, elevation, source, destination, framesToProcess);
+            m_panner->pan(azimuth, elevation, source, destination, framesToProcess);
 
-        // Get the distance and cone gain.
-        float totalGain = distanceConeGain();
+            // 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);
+            // Apply gain in-place with de-zippering.
+            destination->copyWithGainFrom(*destination, &m_lastGain, totalGain);
+        }
     } else {
         // Too bad - The tryLock() failed.
         // We must be in the middle of changing the properties of the panner or the listener.
         destination->zero();
     }
 }
 
+void PannerHandler::processSampleAccurateValues(AudioBus* destination, const AudioBus* source, size_t framesToProcess)
+{
+    RELEASE_ASSERT(framesToProcess <= ProcessingSizeInFrames);
+
+    // Get the sample accurate values from all of the AudioParams, including the values from the
+    // AudioListener.
+    float pannerX[ProcessingSizeInFrames];
+    float pannerY[ProcessingSizeInFrames];
+    float pannerZ[ProcessingSizeInFrames];
+
+    float orientationX[ProcessingSizeInFrames];
+    float orientationY[ProcessingSizeInFrames];
+    float orientationZ[ProcessingSizeInFrames];
+
+    m_positionX->calculateSampleAccurateValues(pannerX, framesToProcess);
+    m_positionY->calculateSampleAccurateValues(pannerY, framesToProcess);
+    m_positionZ->calculateSampleAccurateValues(pannerZ, framesToProcess);
+    m_orientationX->calculateSampleAccurateValues(orientationX, framesToProcess);
+    m_orientationY->calculateSampleAccurateValues(orientationY, framesToProcess);
+    m_orientationZ->calculateSampleAccurateValues(orientationZ, framesToProcess);
+
+    // Get the automation values from the listener.
+    const float* listenerX = listener()->getPositionXValues(ProcessingSizeInFrames);
+    const float* listenerY = listener()->getPositionYValues(ProcessingSizeInFrames);
+    const float* listenerZ = listener()->getPositionZValues(ProcessingSizeInFrames);
+
+    const float* forwardX = listener()->getForwardXValues(ProcessingSizeInFrames);
+    const float* forwardY = listener()->getForwardYValues(ProcessingSizeInFrames);
+    const float* forwardZ = listener()->getForwardZValues(ProcessingSizeInFrames);
+
+    const float* upX = listener()->getUpXValues(ProcessingSizeInFrames);
+    const float* upY = listener()->getUpYValues(ProcessingSizeInFrames);
+    const float* upZ = listener()->getUpZValues(ProcessingSizeInFrames);
+
+    // Compute the azimuth, elevation, and total gains for each position.
+    double azimuth[ProcessingSizeInFrames];
+    double elevation[ProcessingSizeInFrames];
+    float totalGain[ProcessingSizeInFrames];
+
+    for (unsigned k = 0; k < framesToProcess; ++k) {
+        FloatPoint3D pannerPosition(pannerX[k], pannerY[k], pannerZ[k]);
+        FloatPoint3D orientation(orientationX[k], orientationY[k], orientationZ[k]);
+        FloatPoint3D listenerPosition(listenerX[k], listenerY[k], listenerZ[k]);
+        FloatPoint3D listenerForward(forwardX[k], forwardY[k], forwardZ[k]);
+        FloatPoint3D listenerUp(upX[k], upY[k], upZ[k]);
+
+        calculateAzimuthElevation(&azimuth[k], &elevation[k],
+            pannerPosition, listenerPosition, listenerForward, listenerUp);
+
+        // Get distance and cone gain
+        totalGain[k] = calculateDistanceConeGain(pannerPosition, orientation, listenerPosition);
+    }
+
+    m_panner->panWithSampleAccurateValues(azimuth, elevation, source, destination, framesToProcess);
+    destination->copyWithSampleAccurateGainValuesFrom(*destination, totalGain, framesToProcess);
+}
+
 void PannerHandler::initialize()
 {
     if (isInitialized())
         return;
 
     m_panner = Panner::create(m_panningModel, sampleRate(), listener()->hrtfDatabaseLoader());
     listener()->addPanner(*this);
 
+    // Set the cached values to the current values to start things off.  The panner is already
+    // marked as dirty, so this won't matter.
+    m_lastPosition = position();
+    m_lastOrientation = orientation();
+
     AudioHandler::initialize();
 }
 
 void PannerHandler::uninitialize()
 {
     if (!isInitialized())
         return;
 
     m_panner.clear();
     listener()->removePanner(*this);
@@ skipping 154 matching lines @@
         return;
 
     // This synchronizes with process().
     MutexLocker processLocker(m_processLock);
     m_coneEffect.setOuterGain(angle);
     markPannerAsDirty(PannerHandler::DistanceConeGainDirty);
 }
 
 void PannerHandler::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;
+
+    m_positionX->setValue(x);
+    m_positionY->setValue(y);
+    m_positionZ->setValue(z);
+
     markPannerAsDirty(PannerHandler::AzimuthElevationDirty | PannerHandler::DistanceConeGainDirty);
 }
 
 void PannerHandler::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;
+
+    m_orientationX->setValue(x);
+    m_orientationY->setValue(y);
+    m_orientationZ->setValue(z);
+
     markPannerAsDirty(PannerHandler::DistanceConeGainDirty);
 }
 
-void PannerHandler::calculateAzimuthElevation(double* outAzimuth, double* outElevation)
+void PannerHandler::calculateAzimuthElevation(
+    double* outAzimuth,
+    double* outElevation,
+    const FloatPoint3D& position,
+    const FloatPoint3D& listenerPosition,
+    const FloatPoint3D& listenerForward,
+    const FloatPoint3D& listenerUp)
 {
     double azimuth = 0.0;
 
     // Calculate the source-listener vector
-    FloatPoint3D listenerPosition = listener()->position();
-    FloatPoint3D sourceListener = m_position - listenerPosition;
+    FloatPoint3D sourceListener = position - listenerPosition;
 
     // normalize() does nothing if the length of |sourceListener| is zero.
     sourceListener.normalize();
 
     // Align axes
-    FloatPoint3D listenerFront = listener()->orientation();
-    FloatPoint3D listenerUp = listener()->upVector();
-    FloatPoint3D listenerRight = listenerFront.cross(listenerUp);
+    FloatPoint3D listenerRight = listenerForward.cross(listenerUp);
     listenerRight.normalize();
 
-    FloatPoint3D listenerFrontNorm = listenerFront;
-    listenerFrontNorm.normalize();
+    FloatPoint3D listenerForwardNorm = listenerForward;
+    listenerForwardNorm.normalize();
 
-    FloatPoint3D up = listenerRight.cross(listenerFrontNorm);
+    FloatPoint3D up = listenerRight.cross(listenerForwardNorm);
 
     float upProjection = sourceListener.dot(up);
 
     FloatPoint3D projectedSource = sourceListener - upProjection * up;
 
     azimuth = rad2deg(projectedSource.angleBetween(listenerRight));
     fixNANs(azimuth); // avoid illegal values
 
     // Source  in front or behind the listener
-    double frontBack = projectedSource.dot(listenerFrontNorm);
+    double frontBack = projectedSource.dot(listenerForwardNorm);
     if (frontBack < 0.0)
         azimuth = 360.0 - azimuth;
 
     // Make azimuth relative to "front" and not "right" listener vector
     if ((azimuth >= 0.0) && (azimuth <= 270.0))
         azimuth = 90.0 - azimuth;
     else
         azimuth = 450.0 - azimuth;
 
     // Elevation
     double elevation = 90 - rad2deg(sourceListener.angleBetween(up));
     fixNANs(elevation); // avoid illegal values
 
     if (elevation > 90.0)
         elevation = 180.0 - elevation;
     else if (elevation < -90.0)
         elevation = -180.0 - elevation;
 
     if (outAzimuth)
         *outAzimuth = azimuth;
     if (outElevation)
         *outElevation = elevation;
 }
 
-float PannerHandler::calculateDistanceConeGain()
+float PannerHandler::calculateDistanceConeGain(
+    const FloatPoint3D& position,
+    const FloatPoint3D& orientation,
+    const FloatPoint3D& listenerPosition)
 {
-    FloatPoint3D listenerPosition = listener()->position();
-
-    double listenerDistance = m_position.distanceTo(listenerPosition);
+    double listenerDistance = position.distanceTo(listenerPosition);
     double distanceGain = m_distanceEffect.gain(listenerDistance);
-    double coneGain = m_coneEffect.gain(m_position, m_orientation, listenerPosition);
+    double coneGain = m_coneEffect.gain(position, orientation, listenerPosition);
 
     return float(distanceGain * coneGain);
 }
 
 void PannerHandler::azimuthElevation(double* outAzimuth, double* outElevation)
 {
     ASSERT(context()->isAudioThread());
 
     if (isAzimuthElevationDirty()) {
-        calculateAzimuthElevation(&m_cachedAzimuth, &m_cachedElevation);
+        calculateAzimuthElevation(
+            &m_cachedAzimuth,
+            &m_cachedElevation,
+            position(),
+            listener()->position(),
+            listener()->orientation(),
+            listener()->upVector());
         m_isAzimuthElevationDirty = false;
     }
 
     *outAzimuth = m_cachedAzimuth;
     *outElevation = m_cachedElevation;
 }
 
 float PannerHandler::distanceConeGain()
 {
     ASSERT(context()->isAudioThread());
 
     if (isDistanceConeGainDirty()) {
-        m_cachedDistanceConeGain = calculateDistanceConeGain();
+        m_cachedDistanceConeGain = calculateDistanceConeGain(position(), orientation(), listener()->position());
         m_isDistanceConeGainDirty = false;
     }
 
     return m_cachedDistanceConeGain;
 }
 
 void PannerHandler::markPannerAsDirty(unsigned dirty)
 {
     if (dirty & PannerHandler::AzimuthElevationDirty)
         m_isAzimuthElevationDirty = true;
@@ skipping 46 matching lines @@
         m_newChannelCountMode = oldMode;
     } else {
         // Do nothing for other invalid values.
         m_newChannelCountMode = oldMode;
     }
 
     if (m_newChannelCountMode != oldMode)
         context()->deferredTaskHandler().addChangedChannelCountMode(this);
 }
 
+bool PannerHandler::hasSampleAccurateValues() const
+{
+    return m_positionX->hasSampleAccurateValues()
+        || m_positionY->hasSampleAccurateValues()
+        || m_positionZ->hasSampleAccurateValues()
+        || m_orientationX->hasSampleAccurateValues()
+        || m_orientationY->hasSampleAccurateValues()
+        || m_orientationZ->hasSampleAccurateValues();
+}
+
+void PannerHandler::updateDirtyState()
+{
+    FloatPoint3D currentPosition = position();
+    FloatPoint3D currentOrientation = orientation();
+
+    bool hasMoved = currentPosition != m_lastPosition
+        || currentOrientation != m_lastOrientation;
+
+    if (hasMoved) {
+        m_lastPosition = currentPosition;
+        m_lastOrientation = currentOrientation;
+
+        markPannerAsDirty(PannerHandler::AzimuthElevationDirty | PannerHandler::DistanceConeGainDirty);
+    }
+}
 // ----------------------------------------------------------------
 
-PannerNode::PannerNode(AbstractAudioContext& context, float sampelRate)
+PannerNode::PannerNode(AbstractAudioContext& context, float sampleRate)
     : AudioNode(context)
+    , m_positionX(AudioParam::create(context, ParamTypePannerPositionX, 0.0))
+    , m_positionY(AudioParam::create(context, ParamTypePannerPositionY, 0.0))
+    , m_positionZ(AudioParam::create(context, ParamTypePannerPositionZ, 0.0))
+    , m_orientationX(AudioParam::create(context, ParamTypePannerOrientationX, 1.0))
+    , m_orientationY(AudioParam::create(context, ParamTypePannerOrientationY, 0.0))
+    , m_orientationZ(AudioParam::create(context, ParamTypePannerOrientationZ, 0.0))
 {
-    setHandler(PannerHandler::create(*this, sampelRate));
+    setHandler(PannerHandler::create(
+        *this,
+        sampleRate,
+        m_positionX->handler(),
+        m_positionY->handler(),
+        m_positionZ->handler(),
+        m_orientationX->handler(),
+        m_orientationY->handler(),
+        m_orientationZ->handler()));
 }
 
 PannerNode* PannerNode::create(AbstractAudioContext& context, float sampleRate)
 {
     return new PannerNode(context, sampleRate);
 }
 
 PannerHandler& PannerNode::pannerHandler() const
 {
     return static_cast<PannerHandler&>(handler());
@@ skipping 88 matching lines @@
 double PannerNode::coneOuterGain() const
 {
     return pannerHandler().coneOuterGain();
 }
 
 void PannerNode::setConeOuterGain(double gain)
 {
     pannerHandler().setConeOuterGain(gain);
 }
 
+DEFINE_TRACE(PannerNode)
+{
+    visitor->trace(m_positionX);
+    visitor->trace(m_positionY);
+    visitor->trace(m_positionZ);
+
+    visitor->trace(m_orientationX);
+    visitor->trace(m_orientationY);
+    visitor->trace(m_orientationZ);
+
+    AudioNode::trace(visitor);
+}
+
 } // namespace blink