The Tor Browser: content/media/webaudio/WaveShaperNode.cpp@b8a032363ba2 (annotated)

content/media/webaudio/WaveShaperNode.cpp@b8a032363ba2 (annotated)

content/media/webaudio/WaveShaperNode.cpp

Thu, 22 Jan 2015 13:21:57 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 22 Jan 2015 13:21:57 +0100
branch: TOR_BUG_9701
changeset 15: b8a032363ba2
permissions: -rw-r--r--

Incorporate requested changes from Mozilla in review:
https://bugzilla.mozilla.org/show_bug.cgi?id=1123480#c6

 /* -*- 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 "WaveShaperNode.h"
 #include "mozilla/dom/WaveShaperNodeBinding.h"
 #include "AudioNode.h"
 #include "AudioNodeEngine.h"
 #include "AudioNodeStream.h"
 #include "mozilla/PodOperations.h"
 #include "speex/speex_resampler.h"
 namespace mozilla {
 namespace dom {
 NS_IMPL_CYCLE_COLLECTION_CLASS(WaveShaperNode)
 NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(WaveShaperNode, AudioNode)
   NS_IMPL_CYCLE_COLLECTION_UNLINK_PRESERVED_WRAPPER
   tmp->ClearCurve();
 NS_IMPL_CYCLE_COLLECTION_UNLINK_END
 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(WaveShaperNode, AudioNode)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE_SCRIPT_OBJECTS
 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
 NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN(WaveShaperNode)
   NS_IMPL_CYCLE_COLLECTION_TRACE_PRESERVED_WRAPPER
   NS_IMPL_CYCLE_COLLECTION_TRACE_JS_MEMBER_CALLBACK(mCurve)
 NS_IMPL_CYCLE_COLLECTION_TRACE_END
 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(WaveShaperNode)
 NS_INTERFACE_MAP_END_INHERITING(AudioNode)
 NS_IMPL_ADDREF_INHERITED(WaveShaperNode, AudioNode)
 NS_IMPL_RELEASE_INHERITED(WaveShaperNode, AudioNode)
 static uint32_t ValueOf(OverSampleType aType)
 {
   switch (aType) {
   case OverSampleType::None: return 1;
   case OverSampleType::_2x:  return 2;
   case OverSampleType::_4x:  return 4;
   default:
     NS_NOTREACHED("We should never reach here");
     return 1;
   }
 }
 class Resampler
 {
 public:
   Resampler()
     : mType(OverSampleType::None)
     , mUpSampler(nullptr)
     , mDownSampler(nullptr)
     , mChannels(0)
     , mSampleRate(0)
   {
   }
   ~Resampler()
   {
     Destroy();
   }
   void Reset(uint32_t aChannels, TrackRate aSampleRate, OverSampleType aType)
   {
     if (aChannels == mChannels &&
         aSampleRate == mSampleRate &&
         aType == mType) {
       return;
     }
     mChannels = aChannels;
     mSampleRate = aSampleRate;
     mType = aType;
     Destroy();
     if (aType == OverSampleType::None) {
       mBuffer.Clear();
       return;
     }
     mUpSampler = speex_resampler_init(aChannels,
                                       aSampleRate,
                                       aSampleRate * ValueOf(aType),
                                       SPEEX_RESAMPLER_QUALITY_DEFAULT,
                                       nullptr);
     mDownSampler = speex_resampler_init(aChannels,
                                         aSampleRate * ValueOf(aType),
                                         aSampleRate,
                                         SPEEX_RESAMPLER_QUALITY_DEFAULT,
                                         nullptr);
     mBuffer.SetLength(WEBAUDIO_BLOCK_SIZE*ValueOf(aType));
   }
   float* UpSample(uint32_t aChannel, const float* aInputData, uint32_t aBlocks)
   {
     uint32_t inSamples = WEBAUDIO_BLOCK_SIZE;
     uint32_t outSamples = WEBAUDIO_BLOCK_SIZE*aBlocks;
     float* outputData = mBuffer.Elements();
     MOZ_ASSERT(mBuffer.Length() == outSamples);
     WebAudioUtils::SpeexResamplerProcess(mUpSampler, aChannel,
                                          aInputData, &inSamples,
                                          outputData, &outSamples);
     MOZ_ASSERT(inSamples == WEBAUDIO_BLOCK_SIZE && outSamples == WEBAUDIO_BLOCK_SIZE*aBlocks);
     return outputData;
   }
   void DownSample(uint32_t aChannel, float* aOutputData, uint32_t aBlocks)
   {
     uint32_t inSamples = WEBAUDIO_BLOCK_SIZE*aBlocks;
     uint32_t outSamples = WEBAUDIO_BLOCK_SIZE;
     const float* inputData = mBuffer.Elements();
     MOZ_ASSERT(mBuffer.Length() == inSamples);
     WebAudioUtils::SpeexResamplerProcess(mDownSampler, aChannel,
                                          inputData, &inSamples,
                                          aOutputData, &outSamples);
     MOZ_ASSERT(inSamples == WEBAUDIO_BLOCK_SIZE*aBlocks && outSamples == WEBAUDIO_BLOCK_SIZE);
   }
   size_t SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const
   {
     size_t amount = 0;
     // Future: properly measure speex memory
     amount += aMallocSizeOf(mUpSampler);
     amount += aMallocSizeOf(mDownSampler);
     amount += mBuffer.SizeOfExcludingThis(aMallocSizeOf);
     return amount;
   }
 private:
   void Destroy()
   {
     if (mUpSampler) {
       speex_resampler_destroy(mUpSampler);
       mUpSampler = nullptr;
     }
     if (mDownSampler) {
       speex_resampler_destroy(mDownSampler);
       mDownSampler = nullptr;
     }
   }
 private:
   OverSampleType mType;
   SpeexResamplerState* mUpSampler;
   SpeexResamplerState* mDownSampler;
   uint32_t mChannels;
   TrackRate mSampleRate;
   nsTArray<float> mBuffer;
 };
 class WaveShaperNodeEngine : public AudioNodeEngine
 {
 public:
   explicit WaveShaperNodeEngine(AudioNode* aNode)
     : AudioNodeEngine(aNode)
     , mType(OverSampleType::None)
   {
   }
   enum Parameteres {
     TYPE
   };
   virtual void SetRawArrayData(nsTArray<float>& aCurve) MOZ_OVERRIDE
   {
     mCurve.SwapElements(aCurve);
   }
   virtual void SetInt32Parameter(uint32_t aIndex, int32_t aValue) MOZ_OVERRIDE
   {
     switch (aIndex) {
     case TYPE:
       mType = static_cast<OverSampleType>(aValue);
       break;
     default:
       NS_ERROR("Bad WaveShaperNode Int32Parameter");
     }
   }
   template <uint32_t blocks>
   void ProcessCurve(const float* aInputBuffer, float* aOutputBuffer)
   {
     for (uint32_t j = 0; j < WEBAUDIO_BLOCK_SIZE*blocks; ++j) {
       // Index into the curve array based on the amplitude of the
       // incoming signal by clamping the amplitude to [-1, 1] and
       // performing a linear interpolation of the neighbor values.
       float index = std::max(0.0f, std::min(float(mCurve.Length() - 1),
                                             mCurve.Length() * (aInputBuffer[j] + 1) / 2));
       uint32_t indexLower = uint32_t(index);
       uint32_t indexHigher = uint32_t(index + 1.0f);
       if (indexHigher == mCurve.Length()) {
         aOutputBuffer[j] = mCurve[indexLower];
       } else {
         float interpolationFactor = index - indexLower;
         aOutputBuffer[j] = (1.0f - interpolationFactor) * mCurve[indexLower] +
                                    interpolationFactor  * mCurve[indexHigher];
       }
     }
   }
   virtual void ProcessBlock(AudioNodeStream* aStream,
                             const AudioChunk& aInput,
                             AudioChunk* aOutput,
                             bool* aFinished)
   {
     uint32_t channelCount = aInput.mChannelData.Length();
     if (!mCurve.Length() || !channelCount) {
       // Optimize the case where we don't have a curve buffer,
       // or the input is null.
       *aOutput = aInput;
       return;
     }
     AllocateAudioBlock(channelCount, aOutput);
     for (uint32_t i = 0; i < channelCount; ++i) {
       const float* inputBuffer = static_cast<const float*>(aInput.mChannelData[i]);
       float* outputBuffer = const_cast<float*> (static_cast<const float*>(aOutput->mChannelData[i]));
       float* sampleBuffer;
       switch (mType) {
       case OverSampleType::None:
         mResampler.Reset(channelCount, aStream->SampleRate(), OverSampleType::None);
         ProcessCurve<1>(inputBuffer, outputBuffer);
         break;
       case OverSampleType::_2x:
         mResampler.Reset(channelCount, aStream->SampleRate(), OverSampleType::_2x);
         sampleBuffer = mResampler.UpSample(i, inputBuffer, 2);
         ProcessCurve<2>(sampleBuffer, sampleBuffer);
         mResampler.DownSample(i, outputBuffer, 2);
         break;
       case OverSampleType::_4x:
         mResampler.Reset(channelCount, aStream->SampleRate(), OverSampleType::_4x);
         sampleBuffer = mResampler.UpSample(i, inputBuffer, 4);
         ProcessCurve<4>(sampleBuffer, sampleBuffer);
         mResampler.DownSample(i, outputBuffer, 4);
         break;
       default:
         NS_NOTREACHED("We should never reach here");
       }
     }
   }
   virtual size_t SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const MOZ_OVERRIDE
   {
     size_t amount = AudioNodeEngine::SizeOfExcludingThis(aMallocSizeOf);
     amount += mCurve.SizeOfExcludingThis(aMallocSizeOf);
     amount += mResampler.SizeOfExcludingThis(aMallocSizeOf);
     return amount;
   }
   virtual size_t SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const MOZ_OVERRIDE
   {
     return aMallocSizeOf(this) + SizeOfExcludingThis(aMallocSizeOf);
   }
 private:
   nsTArray<float> mCurve;
   OverSampleType mType;
   Resampler mResampler;
 };
 WaveShaperNode::WaveShaperNode(AudioContext* aContext)
   : AudioNode(aContext,
 ,
               ChannelCountMode::Max,
               ChannelInterpretation::Speakers)
   , mCurve(nullptr)
   , mType(OverSampleType::None)
 {
   mozilla::HoldJSObjects(this);
   WaveShaperNodeEngine* engine = new WaveShaperNodeEngine(this);
   mStream = aContext->Graph()->CreateAudioNodeStream(engine, MediaStreamGraph::INTERNAL_STREAM);
 }
 WaveShaperNode::~WaveShaperNode()
 {
   ClearCurve();
 }
 void
 WaveShaperNode::ClearCurve()
 {
   mCurve = nullptr;
   mozilla::DropJSObjects(this);
 }
 JSObject*
 WaveShaperNode::WrapObject(JSContext *aCx)
 {
   return WaveShaperNodeBinding::Wrap(aCx, this);
 }
 void
 WaveShaperNode::SetCurve(const Nullable<Float32Array>& aCurve)
 {
   nsTArray<float> curve;
   if (!aCurve.IsNull()) {
     const Float32Array& floats = aCurve.Value();
     mCurve = floats.Obj();
     floats.ComputeLengthAndData();
     curve.SetLength(floats.Length());
     PodCopy(curve.Elements(), floats.Data(), floats.Length());
   } else {
     mCurve = nullptr;
   }
   AudioNodeStream* ns = static_cast<AudioNodeStream*>(mStream.get());
   MOZ_ASSERT(ns, "Why don't we have a stream here?");
   ns->SetRawArrayData(curve);
 }
 void
 WaveShaperNode::SetOversample(OverSampleType aType)
 {
   mType = aType;
   SendInt32ParameterToStream(WaveShaperNodeEngine::TYPE, static_cast<int32_t>(aType));
 }
 }
 }

The Tor Browser / annotate

content/media/webaudio/WaveShaperNode.cpp@b8a032363ba2 (annotated)

content/media/webaudio/WaveShaperNode.cpp