The Tor Browser: content/media/webaudio/PannerNode.cpp@97036ab72558 (annotated)

content/media/webaudio/PannerNode.cpp@97036ab72558 (annotated)

content/media/webaudio/PannerNode.cpp

Tue, 06 Jan 2015 21:39:09 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Tue, 06 Jan 2015 21:39:09 +0100
branch: TOR_BUG_9701
changeset 8: 97036ab72558
permissions: -rw-r--r--

Conditionally force memory storage according to privacy.thirdparty.isolate;
This solves Tor bug #9701, complying with disk avoidance documented in
https://www.torproject.org/projects/torbrowser/design/#disk-avoidance.

 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim:set ts=2 sw=2 sts=2 et cindent: */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 #include "PannerNode.h"
 #include "AudioNodeEngine.h"
 #include "AudioNodeStream.h"
 #include "AudioListener.h"
 #include "AudioBufferSourceNode.h"
 #include "PlayingRefChangeHandler.h"
 #include "blink/HRTFPanner.h"
 #include "blink/HRTFDatabaseLoader.h"
 using WebCore::HRTFDatabaseLoader;
 using WebCore::HRTFPanner;
 namespace mozilla {
 namespace dom {
 using namespace std;
 NS_IMPL_CYCLE_COLLECTION_CLASS(PannerNode)
 NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(PannerNode)
   if (tmp->Context()) {
     tmp->Context()->UnregisterPannerNode(tmp);
   }
 NS_IMPL_CYCLE_COLLECTION_UNLINK_END_INHERITED(AudioNode)
 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(PannerNode, AudioNode)
 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(PannerNode)
 NS_INTERFACE_MAP_END_INHERITING(AudioNode)
 NS_IMPL_ADDREF_INHERITED(PannerNode, AudioNode)
 NS_IMPL_RELEASE_INHERITED(PannerNode, AudioNode)
 class PannerNodeEngine : public AudioNodeEngine
 {
 public:
   explicit PannerNodeEngine(AudioNode* aNode)
     : AudioNodeEngine(aNode)
     // Please keep these default values consistent with PannerNode::PannerNode below.
     , mPanningModelFunction(&PannerNodeEngine::HRTFPanningFunction)
     , mDistanceModelFunction(&PannerNodeEngine::InverseGainFunction)
     , mPosition()
     , mOrientation(1., 0., 0.)
     , mVelocity()
     , mRefDistance(1.)
     , mMaxDistance(10000.)
     , mRolloffFactor(1.)
     , mConeInnerAngle(360.)
     , mConeOuterAngle(360.)
     , mConeOuterGain(0.)
     // These will be initialized when a PannerNode is created, so just initialize them
     // to some dummy values here.
     , mListenerDopplerFactor(0.)
     , mListenerSpeedOfSound(0.)
     , mLeftOverData(INT_MIN)
   {
     // HRTFDatabaseLoader needs to be fetched on the main thread.
     TemporaryRef<HRTFDatabaseLoader> loader =
       HRTFDatabaseLoader::createAndLoadAsynchronouslyIfNecessary(aNode->Context()->SampleRate());
     mHRTFPanner = new HRTFPanner(aNode->Context()->SampleRate(), loader);
   }
   virtual void SetInt32Parameter(uint32_t aIndex, int32_t aParam) MOZ_OVERRIDE
   {
     switch (aIndex) {
     case PannerNode::PANNING_MODEL:
       switch (PanningModelType(aParam)) {
         case PanningModelType::Equalpower:
           mPanningModelFunction = &PannerNodeEngine::EqualPowerPanningFunction;
           break;
         case PanningModelType::HRTF:
           mPanningModelFunction = &PannerNodeEngine::HRTFPanningFunction;
           break;
         default:
           NS_NOTREACHED("We should never see the alternate names here");
           break;
       }
       break;
     case PannerNode::DISTANCE_MODEL:
       switch (DistanceModelType(aParam)) {
         case DistanceModelType::Inverse:
           mDistanceModelFunction = &PannerNodeEngine::InverseGainFunction;
           break;
         case DistanceModelType::Linear:
           mDistanceModelFunction = &PannerNodeEngine::LinearGainFunction;
           break;
         case DistanceModelType::Exponential:
           mDistanceModelFunction = &PannerNodeEngine::ExponentialGainFunction;
           break;
         default:
           NS_NOTREACHED("We should never see the alternate names here");
           break;
       }
       break;
     default:
       NS_ERROR("Bad PannerNodeEngine Int32Parameter");
     }
   }
   virtual void SetThreeDPointParameter(uint32_t aIndex, const ThreeDPoint& aParam) MOZ_OVERRIDE
   {
     switch (aIndex) {
     case PannerNode::LISTENER_POSITION: mListenerPosition = aParam; break;
     case PannerNode::LISTENER_FRONT_VECTOR: mListenerFrontVector = aParam; break;
     case PannerNode::LISTENER_RIGHT_VECTOR: mListenerRightVector = aParam; break;
     case PannerNode::LISTENER_VELOCITY: mListenerVelocity = aParam; break;
     case PannerNode::POSITION: mPosition = aParam; break;
     case PannerNode::ORIENTATION: mOrientation = aParam; break;
     case PannerNode::VELOCITY: mVelocity = aParam; break;
     default:
       NS_ERROR("Bad PannerNodeEngine ThreeDPointParameter");
     }
   }
   virtual void SetDoubleParameter(uint32_t aIndex, double aParam) MOZ_OVERRIDE
   {
     switch (aIndex) {
     case PannerNode::LISTENER_DOPPLER_FACTOR: mListenerDopplerFactor = aParam; break;
     case PannerNode::LISTENER_SPEED_OF_SOUND: mListenerSpeedOfSound = aParam; break;
     case PannerNode::REF_DISTANCE: mRefDistance = aParam; break;
     case PannerNode::MAX_DISTANCE: mMaxDistance = aParam; break;
     case PannerNode::ROLLOFF_FACTOR: mRolloffFactor = aParam; break;
     case PannerNode::CONE_INNER_ANGLE: mConeInnerAngle = aParam; break;
     case PannerNode::CONE_OUTER_ANGLE: mConeOuterAngle = aParam; break;
     case PannerNode::CONE_OUTER_GAIN: mConeOuterGain = aParam; break;
     default:
       NS_ERROR("Bad PannerNodeEngine DoubleParameter");
     }
   }
   virtual void ProcessBlock(AudioNodeStream* aStream,
                             const AudioChunk& aInput,
                             AudioChunk* aOutput,
                             bool *aFinished) MOZ_OVERRIDE
   {
     if (aInput.IsNull()) {
       // mLeftOverData != INT_MIN means that the panning model was HRTF and a
       // tail-time reference was added.  Even if the model is now equalpower,
       // the reference will need to be removed.
       if (mLeftOverData > 0 &&
           mPanningModelFunction == &PannerNodeEngine::HRTFPanningFunction) {
         mLeftOverData -= WEBAUDIO_BLOCK_SIZE;
       } else {
         if (mLeftOverData != INT_MIN) {
           mLeftOverData = INT_MIN;
           mHRTFPanner->reset();
           nsRefPtr<PlayingRefChangeHandler> refchanged =
             new PlayingRefChangeHandler(aStream, PlayingRefChangeHandler::RELEASE);
           aStream->Graph()->
             DispatchToMainThreadAfterStreamStateUpdate(refchanged.forget());
         }
         *aOutput = aInput;
         return;
       }
     } else if (mPanningModelFunction == &PannerNodeEngine::HRTFPanningFunction) {
       if (mLeftOverData == INT_MIN) {
         nsRefPtr<PlayingRefChangeHandler> refchanged =
           new PlayingRefChangeHandler(aStream, PlayingRefChangeHandler::ADDREF);
         aStream->Graph()->
           DispatchToMainThreadAfterStreamStateUpdate(refchanged.forget());
       }
       mLeftOverData = mHRTFPanner->maxTailFrames();
     }
     (this->*mPanningModelFunction)(aInput, aOutput);
   }
   void ComputeAzimuthAndElevation(float& aAzimuth, float& aElevation);
   float ComputeConeGain();
   // Compute how much the distance contributes to the gain reduction.
   float ComputeDistanceGain();
   void GainMonoToStereo(const AudioChunk& aInput, AudioChunk* aOutput,
                         float aGainL, float aGainR);
   void GainStereoToStereo(const AudioChunk& aInput, AudioChunk* aOutput,
                           float aGainL, float aGainR, double aAzimuth);
   void EqualPowerPanningFunction(const AudioChunk& aInput, AudioChunk* aOutput);
   void HRTFPanningFunction(const AudioChunk& aInput, AudioChunk* aOutput);
   float LinearGainFunction(float aDistance);
   float InverseGainFunction(float aDistance);
   float ExponentialGainFunction(float aDistance);
   virtual size_t SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const MOZ_OVERRIDE
   {
     size_t amount = AudioNodeEngine::SizeOfExcludingThis(aMallocSizeOf);
     if (mHRTFPanner) {
       amount += mHRTFPanner->sizeOfIncludingThis(aMallocSizeOf);
     }
     return amount;
   }
   virtual size_t SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const MOZ_OVERRIDE
   {
     return aMallocSizeOf(this) + SizeOfExcludingThis(aMallocSizeOf);
   }
   nsAutoPtr<HRTFPanner> mHRTFPanner;
   typedef void (PannerNodeEngine::*PanningModelFunction)(const AudioChunk& aInput, AudioChunk* aOutput);
   PanningModelFunction mPanningModelFunction;
   typedef float (PannerNodeEngine::*DistanceModelFunction)(float aDistance);
   DistanceModelFunction mDistanceModelFunction;
   ThreeDPoint mPosition;
   ThreeDPoint mOrientation;
   ThreeDPoint mVelocity;
   double mRefDistance;
   double mMaxDistance;
   double mRolloffFactor;
   double mConeInnerAngle;
   double mConeOuterAngle;
   double mConeOuterGain;
   ThreeDPoint mListenerPosition;
   ThreeDPoint mListenerFrontVector;
   ThreeDPoint mListenerRightVector;
   ThreeDPoint mListenerVelocity;
   double mListenerDopplerFactor;
   double mListenerSpeedOfSound;
   int mLeftOverData;
 };
 PannerNode::PannerNode(AudioContext* aContext)
   : AudioNode(aContext,
 ,
               ChannelCountMode::Clamped_max,
               ChannelInterpretation::Speakers)
   // Please keep these default values consistent with PannerNodeEngine::PannerNodeEngine above.
   , mPanningModel(PanningModelType::HRTF)
   , mDistanceModel(DistanceModelType::Inverse)
   , mPosition()
   , mOrientation(1., 0., 0.)
   , mVelocity()
   , mRefDistance(1.)
   , mMaxDistance(10000.)
   , mRolloffFactor(1.)
   , mConeInnerAngle(360.)
   , mConeOuterAngle(360.)
   , mConeOuterGain(0.)
 {
   mStream = aContext->Graph()->CreateAudioNodeStream(new PannerNodeEngine(this),
                                                      MediaStreamGraph::INTERNAL_STREAM);
   // We should register once we have set up our stream and engine.
   Context()->Listener()->RegisterPannerNode(this);
 }
 PannerNode::~PannerNode()
 {
   if (Context()) {
     Context()->UnregisterPannerNode(this);
   }
 }
 size_t
 PannerNode::SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const
 {
   size_t amount = AudioNode::SizeOfExcludingThis(aMallocSizeOf);
   amount += mSources.SizeOfExcludingThis(aMallocSizeOf);
   return amount;
 }
 size_t
 PannerNode::SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const
 {
   return aMallocSizeOf(this) + SizeOfExcludingThis(aMallocSizeOf);
 }
 JSObject*
 PannerNode::WrapObject(JSContext* aCx)
 {
   return PannerNodeBinding::Wrap(aCx, this);
 }
 void PannerNode::DestroyMediaStream()
 {
   if (Context()) {
     Context()->UnregisterPannerNode(this);
   }
   AudioNode::DestroyMediaStream();
 }
 // Those three functions are described in the spec.
 float
 PannerNodeEngine::LinearGainFunction(float aDistance)
 {
   return 1 - mRolloffFactor * (aDistance - mRefDistance) / (mMaxDistance - mRefDistance);
 }
 float
 PannerNodeEngine::InverseGainFunction(float aDistance)
 {
   return mRefDistance / (mRefDistance + mRolloffFactor * (aDistance - mRefDistance));
 }
 float
 PannerNodeEngine::ExponentialGainFunction(float aDistance)
 {
   return pow(aDistance / mRefDistance, -mRolloffFactor);
 }
 void
 PannerNodeEngine::HRTFPanningFunction(const AudioChunk& aInput,
                                       AudioChunk* aOutput)
 {
   // The output of this node is always stereo, no matter what the inputs are.
   AllocateAudioBlock(2, aOutput);
   float azimuth, elevation;
   ComputeAzimuthAndElevation(azimuth, elevation);
   AudioChunk input = aInput;
   // Gain is applied before the delay and convolution of the HRTF
   input.mVolume *= ComputeConeGain() * ComputeDistanceGain();
   mHRTFPanner->pan(azimuth, elevation, &input, aOutput);
 }
 void
 PannerNodeEngine::EqualPowerPanningFunction(const AudioChunk& aInput,
                                             AudioChunk* aOutput)
 {
   float azimuth, elevation, gainL, gainR, normalizedAzimuth, distanceGain, coneGain;
   int inputChannels = aInput.mChannelData.Length();
   // If both the listener are in the same spot, and no cone gain is specified,
   // this node is noop.
   if (mListenerPosition == mPosition &&
       mConeInnerAngle == 360 &&
       mConeOuterAngle == 360) {
     *aOutput = aInput;
     return;
   }
   // The output of this node is always stereo, no matter what the inputs are.
   AllocateAudioBlock(2, aOutput);
   ComputeAzimuthAndElevation(azimuth, elevation);
   coneGain = ComputeConeGain();
   // The following algorithm is described in the spec.
   // Clamp azimuth in the [-90, 90] range.
   azimuth = min(180.f, max(-180.f, azimuth));
   // Wrap around
   if (azimuth < -90.f) {
     azimuth = -180.f - azimuth;
   } else if (azimuth > 90) {
     azimuth = 180.f - azimuth;
   }
   // Normalize the value in the [0, 1] range.
   if (inputChannels == 1) {
     normalizedAzimuth = (azimuth + 90.f) / 180.f;
   } else {
     if (azimuth <= 0) {
       normalizedAzimuth = (azimuth + 90.f) / 90.f;
     } else {
       normalizedAzimuth = azimuth / 90.f;
     }
   }
   distanceGain = ComputeDistanceGain();
   // Actually compute the left and right gain.
   gainL = cos(0.5 * M_PI * normalizedAzimuth);
   gainR = sin(0.5 * M_PI * normalizedAzimuth);
   // Compute the output.
   if (inputChannels == 1) {
     GainMonoToStereo(aInput, aOutput, gainL, gainR);
   } else {
     GainStereoToStereo(aInput, aOutput, gainL, gainR, azimuth);
   }
   aOutput->mVolume = aInput.mVolume * distanceGain * coneGain;
 }
 void
 PannerNodeEngine::GainMonoToStereo(const AudioChunk& aInput, AudioChunk* aOutput,
                                    float aGainL, float aGainR)
 {
   float* outputL = static_cast<float*>(const_cast<void*>(aOutput->mChannelData[0]));
   float* outputR = static_cast<float*>(const_cast<void*>(aOutput->mChannelData[1]));
   const float* input = static_cast<float*>(const_cast<void*>(aInput.mChannelData[0]));
   AudioBlockPanMonoToStereo(input, aGainL, aGainR, outputL, outputR);
 }
 void
 PannerNodeEngine::GainStereoToStereo(const AudioChunk& aInput, AudioChunk* aOutput,
                                      float aGainL, float aGainR, double aAzimuth)
 {
   float* outputL = static_cast<float*>(const_cast<void*>(aOutput->mChannelData[0]));
   float* outputR = static_cast<float*>(const_cast<void*>(aOutput->mChannelData[1]));
   const float* inputL = static_cast<float*>(const_cast<void*>(aInput.mChannelData[0]));
   const float* inputR = static_cast<float*>(const_cast<void*>(aInput.mChannelData[1]));
   AudioBlockPanStereoToStereo(inputL, inputR, aGainL, aGainR, aAzimuth <= 0, outputL, outputR);
 }
 // This algorithm is specified in the webaudio spec.
 void
 PannerNodeEngine::ComputeAzimuthAndElevation(float& aAzimuth, float& aElevation)
 {
   ThreeDPoint sourceListener = mPosition - mListenerPosition;
   if (sourceListener.IsZero()) {
     aAzimuth = 0.0;
     aElevation = 0.0;
     return;
   }
   sourceListener.Normalize();
   // Project the source-listener vector on the x-z plane.
   const ThreeDPoint& listenerFront = mListenerFrontVector;
   const ThreeDPoint& listenerRight = mListenerRightVector;
   ThreeDPoint up = listenerRight.CrossProduct(listenerFront);
   double upProjection = sourceListener.DotProduct(up);
   aElevation = 90 - 180 * acos(upProjection) / M_PI;
   if (aElevation > 90) {
     aElevation = 180 - aElevation;
   } else if (aElevation < -90) {
     aElevation = -180 - aElevation;
   }
   ThreeDPoint projectedSource = sourceListener - up * upProjection;
   if (projectedSource.IsZero()) {
     // source - listener direction is up or down.
     aAzimuth = 0.0;
     return;
   }
   projectedSource.Normalize();
   // Actually compute the angle, and convert to degrees
   double projection = projectedSource.DotProduct(listenerRight);
   aAzimuth = 180 * acos(projection) / M_PI;
   // Compute whether the source is in front or behind the listener.
   double frontBack = projectedSource.DotProduct(listenerFront);
   if (frontBack < 0) {
     aAzimuth = 360 - aAzimuth;
   }
   // Rotate the azimuth so it is relative to the listener front vector instead
   // of the right vector.
   if ((aAzimuth >= 0) && (aAzimuth <= 270)) {
     aAzimuth = 90 - aAzimuth;
   } else {
     aAzimuth = 450 - aAzimuth;
   }
 }
 // This algorithm is described in the WebAudio spec.
 float
 PannerNodeEngine::ComputeConeGain()
 {
   // Omnidirectional source
   if (mOrientation.IsZero() || ((mConeInnerAngle == 360) && (mConeOuterAngle == 360))) {
     return 1;
   }
   // Normalized source-listener vector
   ThreeDPoint sourceToListener = mListenerPosition - mPosition;
   sourceToListener.Normalize();
   // Angle between the source orientation vector and the source-listener vector
   double dotProduct = sourceToListener.DotProduct(mOrientation);
   double angle = 180 * acos(dotProduct) / M_PI;
   double absAngle = fabs(angle);
   // Divide by 2 here since API is entire angle (not half-angle)
   double absInnerAngle = fabs(mConeInnerAngle) / 2;
   double absOuterAngle = fabs(mConeOuterAngle) / 2;
   double gain = 1;
   if (absAngle <= absInnerAngle) {
     // No attenuation
     gain = 1;
   } else if (absAngle >= absOuterAngle) {
     // Max attenuation
     gain = mConeOuterGain;
   } else {
     // Between inner and outer cones
     // inner -> outer, x goes from 0 -> 1
     double x = (absAngle - absInnerAngle) / (absOuterAngle - absInnerAngle);
     gain = (1 - x) + mConeOuterGain * x;
   }
   return gain;
 }
 float
 PannerNodeEngine::ComputeDistanceGain()
 {
   ThreeDPoint distanceVec = mPosition - mListenerPosition;
   float distance = sqrt(distanceVec.DotProduct(distanceVec));
   return (this->*mDistanceModelFunction)(distance);
 }
 float
 PannerNode::ComputeDopplerShift()
 {
   double dopplerShift = 1.0; // Initialize to default value
   AudioListener* listener = Context()->Listener();
   if (listener->DopplerFactor() > 0) {
     // Don't bother if both source and listener have no velocity.
     if (!mVelocity.IsZero() || !listener->Velocity().IsZero()) {
       // Calculate the source to listener vector.
       ThreeDPoint sourceToListener = mPosition - listener->Velocity();
       double sourceListenerMagnitude = sourceToListener.Magnitude();
       double listenerProjection = sourceToListener.DotProduct(listener->Velocity()) / sourceListenerMagnitude;
       double sourceProjection = sourceToListener.DotProduct(mVelocity) / sourceListenerMagnitude;
       listenerProjection = -listenerProjection;
       sourceProjection = -sourceProjection;
       double scaledSpeedOfSound = listener->DopplerFactor() / listener->DopplerFactor();
       listenerProjection = min(listenerProjection, scaledSpeedOfSound);
       sourceProjection = min(sourceProjection, scaledSpeedOfSound);
       dopplerShift = ((listener->SpeedOfSound() - listener->DopplerFactor() * listenerProjection) / (listener->SpeedOfSound() - listener->DopplerFactor() * sourceProjection));
       WebAudioUtils::FixNaN(dopplerShift); // Avoid illegal values
       // Limit the pitch shifting to 4 octaves up and 3 octaves down.
       dopplerShift = min(dopplerShift, 16.);
       dopplerShift = max(dopplerShift, 0.125);
     }
   }
   return dopplerShift;
 }
 void
 PannerNode::FindConnectedSources()
 {
   mSources.Clear();
   std::set<AudioNode*> cycleSet;
   FindConnectedSources(this, mSources, cycleSet);
 }
 void
 PannerNode::FindConnectedSources(AudioNode* aNode,
                                  nsTArray<AudioBufferSourceNode*>& aSources,
                                  std::set<AudioNode*>& aNodesSeen)
 {
   if (!aNode) {
     return;
   }
   const nsTArray<InputNode>& inputNodes = aNode->InputNodes();
   for(unsigned i = 0; i < inputNodes.Length(); i++) {
     // Return if we find a node that we have seen already.
     if (aNodesSeen.find(inputNodes[i].mInputNode) != aNodesSeen.end()) {
       return;
     }
     aNodesSeen.insert(inputNodes[i].mInputNode);
     // Recurse
     FindConnectedSources(inputNodes[i].mInputNode, aSources, aNodesSeen);
     // Check if this node is an AudioBufferSourceNode
     AudioBufferSourceNode* node = inputNodes[i].mInputNode->AsAudioBufferSourceNode();
     if (node) {
       aSources.AppendElement(node);
     }
   }
 }
 void
 PannerNode::SendDopplerToSourcesIfNeeded()
 {
   // Don't bother sending the doppler shift if both the source and the listener
   // are not moving, because the doppler shift is going to be 1.0.
   if (!(Context()->Listener()->Velocity().IsZero() && mVelocity.IsZero())) {
     for(uint32_t i = 0; i < mSources.Length(); i++) {
       mSources[i]->SendDopplerShiftToStream(ComputeDopplerShift());
     }
   }
 }
 }
 }

The Tor Browser / annotate

content/media/webaudio/PannerNode.cpp@97036ab72558 (annotated)

content/media/webaudio/PannerNode.cpp