The Tor Browser: comparison content/media/webaudio/AudioParam.h

--1:000000000000
+:7f3dbcbf9c21
+/* -*- 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/. */
+#ifndef AudioParam_h_
+#define AudioParam_h_
+#include "AudioParamTimeline.h"
+#include "nsWrapperCache.h"
+#include "nsCycleCollectionParticipant.h"
+#include "nsAutoPtr.h"
+#include "AudioNode.h"
+#include "mozilla/dom/TypedArray.h"
+#include "WebAudioUtils.h"
+#include "js/TypeDecls.h"
+namespace mozilla {
+namespace dom {
+class AudioParam MOZ_FINAL : public nsWrapperCache,
+public AudioParamTimeline
+{
+public:
+typedef void (*CallbackType)(AudioNode*);
+AudioParam(AudioNode* aNode,
+CallbackType aCallback,
+float aDefaultValue);
+virtual ~AudioParam();
+NS_IMETHOD_(MozExternalRefCountType) AddRef(void);
+NS_IMETHOD_(MozExternalRefCountType) Release(void);
+NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_NATIVE_CLASS(AudioParam)
+AudioContext* GetParentObject() const
+{
+return mNode->Context();
+}
+double DOMTimeToStreamTime(double aTime) const
+{
+return mNode->Context()->DOMTimeToStreamTime(aTime);
+}
+virtual JSObject* WrapObject(JSContext* aCx) MOZ_OVERRIDE;
+// We override SetValueCurveAtTime to convert the Float32Array to the wrapper
+// object.
+void SetValueCurveAtTime(const Float32Array& aValues, double aStartTime, double aDuration, ErrorResult& aRv)
+{
+if (!WebAudioUtils::IsTimeValid(aStartTime)) {
+aRv.Throw(NS_ERROR_DOM_NOT_SUPPORTED_ERR);
+return;
+}
+aValues.ComputeLengthAndData();
+AudioParamTimeline::SetValueCurveAtTime(aValues.Data(), aValues.Length(),
+DOMTimeToStreamTime(aStartTime), aDuration, aRv);
+mCallback(mNode);
+}
+// We override the rest of the mutating AudioParamTimeline methods in order to make
+// sure that the callback is called every time that this object gets mutated.
+void SetValue(float aValue)
+{
+// Optimize away setting the same value on an AudioParam
+if (HasSimpleValue() &&
+WebAudioUtils::FuzzyEqual(GetValue(), aValue)) {
+return;
+}
+AudioParamTimeline::SetValue(aValue);
+mCallback(mNode);
+}
+void SetValueAtTime(float aValue, double aStartTime, ErrorResult& aRv)
+{
+if (!WebAudioUtils::IsTimeValid(aStartTime)) {
+aRv.Throw(NS_ERROR_DOM_NOT_SUPPORTED_ERR);
+return;
+}
+AudioParamTimeline::SetValueAtTime(aValue, DOMTimeToStreamTime(aStartTime), aRv);
+mCallback(mNode);
+}
+void LinearRampToValueAtTime(float aValue, double aEndTime, ErrorResult& aRv)
+{
+if (!WebAudioUtils::IsTimeValid(aEndTime)) {
+aRv.Throw(NS_ERROR_DOM_NOT_SUPPORTED_ERR);
+return;
+}
+AudioParamTimeline::LinearRampToValueAtTime(aValue, DOMTimeToStreamTime(aEndTime), aRv);
+mCallback(mNode);
+}
+void ExponentialRampToValueAtTime(float aValue, double aEndTime, ErrorResult& aRv)
+{
+if (!WebAudioUtils::IsTimeValid(aEndTime)) {
+aRv.Throw(NS_ERROR_DOM_NOT_SUPPORTED_ERR);
+return;
+}
+AudioParamTimeline::ExponentialRampToValueAtTime(aValue, DOMTimeToStreamTime(aEndTime), aRv);
+mCallback(mNode);
+}
+void SetTargetAtTime(float aTarget, double aStartTime, double aTimeConstant, ErrorResult& aRv)
+{
+if (!WebAudioUtils::IsTimeValid(aStartTime) ||
+!WebAudioUtils::IsTimeValid(aTimeConstant)) {
+aRv.Throw(NS_ERROR_DOM_NOT_SUPPORTED_ERR);
+return;
+}
+AudioParamTimeline::SetTargetAtTime(aTarget, DOMTimeToStreamTime(aStartTime), aTimeConstant, aRv);
+mCallback(mNode);
+}
+void CancelScheduledValues(double aStartTime, ErrorResult& aRv)
+{
+if (!WebAudioUtils::IsTimeValid(aStartTime)) {
+aRv.Throw(NS_ERROR_DOM_NOT_SUPPORTED_ERR);
+return;
+}
+AudioParamTimeline::CancelScheduledValues(DOMTimeToStreamTime(aStartTime));
+mCallback(mNode);
+}
+float DefaultValue() const
+{
+return mDefaultValue;
+}
+AudioNode* Node() const
+{
+return mNode;
+}
+const nsTArray<AudioNode::InputNode>& InputNodes() const
+{
+return mInputNodes;
+}
+void RemoveInputNode(uint32_t aIndex)
+{
+mInputNodes.RemoveElementAt(aIndex);
+}
+AudioNode::InputNode* AppendInputNode()
+{
+return mInputNodes.AppendElement();
+}
+void DisconnectFromGraphAndDestroyStream();
+// May create the stream if it doesn't exist
+MediaStream* Stream();
+virtual size_t SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const MOZ_OVERRIDE
+{
+size_t amount = AudioParamTimeline::SizeOfExcludingThis(aMallocSizeOf);
+// Not owned:
+// - mNode
+// Just count the array, actual nodes are counted in mNode.
+amount += mInputNodes.SizeOfExcludingThis(aMallocSizeOf);
+if (mNodeStreamPort) {
+amount += mNodeStreamPort->SizeOfIncludingThis(aMallocSizeOf);
+}
+return amount;
+}
+virtual size_t SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const MOZ_OVERRIDE
+{
+return aMallocSizeOf(this) + SizeOfExcludingThis(aMallocSizeOf);
+}
+protected:
+nsCycleCollectingAutoRefCnt mRefCnt;
+NS_DECL_OWNINGTHREAD
+private:
+nsRefPtr<AudioNode> mNode;
+// For every InputNode, there is a corresponding entry in mOutputParams of the
+// InputNode's mInputNode.
+nsTArray<AudioNode::InputNode> mInputNodes;
+CallbackType mCallback;
+const float mDefaultValue;
+// The input port used to connect the AudioParam's stream to its node's stream
+nsRefPtr<MediaInputPort> mNodeStreamPort;
+};
+}
+}
+#endif

The Tor Browser / file comparison

comparison: content/media/webaudio/AudioParam.h

content/media/webaudio/AudioParam.h