The Tor Browser: comparison content/media/AudioEventTimeline.h

--1:000000000000
+:fc203dc92350
+/* -*- 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 AudioEventTimeline_h_
+#define AudioEventTimeline_h_
+#include <algorithm>
+#include "mozilla/Assertions.h"
+#include "mozilla/FloatingPoint.h"
+#include "mozilla/TypedEnum.h"
+#include "mozilla/PodOperations.h"
+#include "nsTArray.h"
+#include "math.h"
+namespace mozilla {
+namespace dom {
+// This is an internal helper class and should not be used outside of this header.
+struct AudioTimelineEvent {
+enum Type MOZ_ENUM_TYPE(uint32_t) {
+SetValue,
+LinearRamp,
+ExponentialRamp,
+SetTarget,
+SetValueCurve
+};
+AudioTimelineEvent(Type aType, double aTime, float aValue, double aTimeConstant = 0.0,
+float aDuration = 0.0, const float* aCurve = nullptr, uint32_t aCurveLength = 0)
+: mType(aType)
+, mTimeConstant(aTimeConstant)
+, mDuration(aDuration)
+#ifdef DEBUG
+, mTimeIsInTicks(false)
+#endif
+{
+mTime = aTime;
+if (aType == AudioTimelineEvent::SetValueCurve) {
+SetCurveParams(aCurve, aCurveLength);
+} else {
+mValue = aValue;
+}
+}
+AudioTimelineEvent(const AudioTimelineEvent& rhs)
+{
+PodCopy(this, &rhs, 1);
+if (rhs.mType == AudioTimelineEvent::SetValueCurve) {
+SetCurveParams(rhs.mCurve, rhs.mCurveLength);
+}
+}
+~AudioTimelineEvent()
+{
+if (mType == AudioTimelineEvent::SetValueCurve) {
+delete[] mCurve;
+}
+}
+bool IsValid() const
+{
+if (mType == AudioTimelineEvent::SetValueCurve) {
+if (!mCurve || !mCurveLength) {
+return false;
+}
+for (uint32_t i = 0; i < mCurveLength; ++i) {
+if (!IsValid(mCurve[i])) {
+return false;
+}
+}
+}
+return IsValid(mTime) &&
+IsValid(mValue) &&
+IsValid(mTimeConstant) &&
+IsValid(mDuration);
+}
+template <class TimeType>
+TimeType Time() const;
+void SetTimeInTicks(int64_t aTimeInTicks)
+{
+mTimeInTicks = aTimeInTicks;
+#ifdef DEBUG
+mTimeIsInTicks = true;
+#endif
+}
+void SetCurveParams(const float* aCurve, uint32_t aCurveLength) {
+mCurveLength = aCurveLength;
+if (aCurveLength) {
+mCurve = new float[aCurveLength];
+PodCopy(mCurve, aCurve, aCurveLength);
+} else {
+mCurve = nullptr;
+}
+}
+Type mType;
+union {
+float mValue;
+uint32_t mCurveLength;
+};
+// The time for an event can either be in absolute value or in ticks.
+// Initially the time of the event is always in absolute value.
+// In order to convert it to ticks, call SetTimeInTicks.  Once this
+// method has been called for an event, the time cannot be converted
+// back to absolute value.
+union {
+double mTime;
+int64_t mTimeInTicks;
+};
+// mCurve contains a buffer of SetValueCurve samples.  We sample the
+// values in the buffer depending on how far along we are in time.
+// If we're at time T and the event has started as time T0 and has a
+// duration of D, we sample the buffer at floor(mCurveLength*(T-T0)/D)
+// if T<T0+D, and just take the last sample in the buffer otherwise.
+float* mCurve;
+double mTimeConstant;
+double mDuration;
+#ifdef DEBUG
+bool mTimeIsInTicks;
+#endif
+private:
+static bool IsValid(double value)
+{
+return mozilla::IsFinite(value);
+}
+};
+template <>
+inline double AudioTimelineEvent::Time<double>() const
+{
+MOZ_ASSERT(!mTimeIsInTicks);
+return mTime;
+}
+template <>
+inline int64_t AudioTimelineEvent::Time<int64_t>() const
+{
+MOZ_ASSERT(mTimeIsInTicks);
+return mTimeInTicks;
+}
+/**
+* This class will be instantiated with different template arguments for testing and
+* production code.
+*
+* ErrorResult is a type which satisfies the following:
+*  - Implements a Throw() method taking an nsresult argument, representing an error code.
+*/
+template <class ErrorResult>
+class AudioEventTimeline
+{
+public:
+explicit AudioEventTimeline(float aDefaultValue)
+: mValue(aDefaultValue),
+mComputedValue(aDefaultValue),
+mLastComputedValue(aDefaultValue)
+{
+}
+bool HasSimpleValue() const
+{
+return mEvents.IsEmpty();
+}
+float GetValue() const
+{
+// This method should only be called if HasSimpleValue() returns true
+MOZ_ASSERT(HasSimpleValue());
+return mValue;
+}
+float Value() const
+{
+// TODO: Return the current value based on the timeline of the AudioContext
+return mValue;
+}
+void SetValue(float aValue)
+{
+// Silently don't change anything if there are any events
+if (mEvents.IsEmpty()) {
+mLastComputedValue = mComputedValue = mValue = aValue;
+}
+}
+void SetValueAtTime(float aValue, double aStartTime, ErrorResult& aRv)
+{
+InsertEvent(AudioTimelineEvent(AudioTimelineEvent::SetValue, aStartTime, aValue), aRv);
+}
+void LinearRampToValueAtTime(float aValue, double aEndTime, ErrorResult& aRv)
+{
+InsertEvent(AudioTimelineEvent(AudioTimelineEvent::LinearRamp, aEndTime, aValue), aRv);
+}
+void ExponentialRampToValueAtTime(float aValue, double aEndTime, ErrorResult& aRv)
+{
+InsertEvent(AudioTimelineEvent(AudioTimelineEvent::ExponentialRamp, aEndTime, aValue), aRv);
+}
+void SetTargetAtTime(float aTarget, double aStartTime, double aTimeConstant, ErrorResult& aRv)
+{
+InsertEvent(AudioTimelineEvent(AudioTimelineEvent::SetTarget, aStartTime, aTarget, aTimeConstant), aRv);
+}
+void SetValueCurveAtTime(const float* aValues, uint32_t aValuesLength, double aStartTime, double aDuration, ErrorResult& aRv)
+{
+InsertEvent(AudioTimelineEvent(AudioTimelineEvent::SetValueCurve, aStartTime, 0.0f, 0.0f, aDuration, aValues, aValuesLength), aRv);
+}
+void CancelScheduledValues(double aStartTime)
+{
+for (unsigned i = 0; i < mEvents.Length(); ++i) {
+if (mEvents[i].mTime >= aStartTime) {
+#ifdef DEBUG
+// Sanity check: the array should be sorted, so all of the following
+// events should have a time greater than aStartTime too.
+for (unsigned j = i + 1; j < mEvents.Length(); ++j) {
+MOZ_ASSERT(mEvents[j].mTime >= aStartTime);
+}
+#endif
+mEvents.TruncateLength(i);
+break;
+}
+}
+}
+void CancelAllEvents()
+{
+mEvents.Clear();
+}
+static bool TimesEqual(int64_t aLhs, int64_t aRhs)
+{
+return aLhs == aRhs;
+}
+// Since we are going to accumulate error by adding 0.01 multiple time in a
+// loop, we want to fuzz the equality check in GetValueAtTime.
+static bool TimesEqual(double aLhs, double aRhs)
+{
+const float kEpsilon = 0.0000000001f;
+return fabs(aLhs - aRhs) < kEpsilon;
+}
+template<class TimeType>
+float GetValueAtTime(TimeType aTime)
+{
+mComputedValue = GetValueAtTimeHelper(aTime);
+return mComputedValue;
+}
+// This method computes the AudioParam value at a given time based on the event timeline
+template<class TimeType>
+float GetValueAtTimeHelper(TimeType aTime)
+{
+const AudioTimelineEvent* previous = nullptr;
+const AudioTimelineEvent* next = nullptr;
+bool bailOut = false;
+for (unsigned i = 0; !bailOut && i < mEvents.Length(); ++i) {
+switch (mEvents[i].mType) {
+case AudioTimelineEvent::SetValue:
+case AudioTimelineEvent::SetTarget:
+case AudioTimelineEvent::LinearRamp:
+case AudioTimelineEvent::ExponentialRamp:
+case AudioTimelineEvent::SetValueCurve:
+if (TimesEqual(aTime, mEvents[i].template Time<TimeType>())) {
+mLastComputedValue = mComputedValue;
+// Find the last event with the same time
+do {
+++i;
+} while (i < mEvents.Length() &&
+aTime == mEvents[i].template Time<TimeType>());
+// SetTarget nodes can be handled no matter what their next node is (if they have one)
+if (mEvents[i - 1].mType == AudioTimelineEvent::SetTarget) {
+// Follow the curve, without regard to the next event, starting at
+// the last value of the last event.
+return ExponentialApproach(mEvents[i - 1].template Time<TimeType>(),
+mLastComputedValue, mEvents[i - 1].mValue,
+mEvents[i - 1].mTimeConstant, aTime);
+}
+// SetValueCurve events can be handled no matter what their event node is (if they have one)
+if (mEvents[i - 1].mType == AudioTimelineEvent::SetValueCurve) {
+return ExtractValueFromCurve(mEvents[i - 1].template Time<TimeType>(),
+mEvents[i - 1].mCurve,
+mEvents[i - 1].mCurveLength,
+mEvents[i - 1].mDuration, aTime);
+}
+// For other event types
+return mEvents[i - 1].mValue;
+}
+previous = next;
+next = &mEvents[i];
+if (aTime < mEvents[i].template Time<TimeType>()) {
+bailOut = true;
+}
+break;
+default:
+MOZ_ASSERT(false, "unreached");
+}
+}
+// Handle the case where the time is past all of the events
+if (!bailOut) {
+previous = next;
+next = nullptr;
+}
+// Just return the default value if we did not find anything
+if (!previous && !next) {
+return mValue;
+}
+// If the requested time is before all of the existing events
+if (!previous) {
+return mValue;
+}
+// SetTarget nodes can be handled no matter what their next node is (if they have one)
+if (previous->mType == AudioTimelineEvent::SetTarget) {
+return ExponentialApproach(previous->template Time<TimeType>(),
+mLastComputedValue, previous->mValue,
+previous->mTimeConstant, aTime);
+}
+// SetValueCurve events can be handled no mattar what their next node is (if they have one)
+if (previous->mType == AudioTimelineEvent::SetValueCurve) {
+return ExtractValueFromCurve(previous->template Time<TimeType>(),
+previous->mCurve, previous->mCurveLength,
+previous->mDuration, aTime);
+}
+// If the requested time is after all of the existing events
+if (!next) {
+switch (previous->mType) {
+case AudioTimelineEvent::SetValue:
+case AudioTimelineEvent::LinearRamp:
+case AudioTimelineEvent::ExponentialRamp:
+// The value will be constant after the last event
+return previous->mValue;
+case AudioTimelineEvent::SetValueCurve:
+return ExtractValueFromCurve(previous->template Time<TimeType>(),
+previous->mCurve, previous->mCurveLength,
+previous->mDuration, aTime);
+case AudioTimelineEvent::SetTarget:
+MOZ_ASSERT(false, "unreached");
+}
+MOZ_ASSERT(false, "unreached");
+}
+// Finally, handle the case where we have both a previous and a next event
+// First, handle the case where our range ends up in a ramp event
+switch (next->mType) {
+case AudioTimelineEvent::LinearRamp:
+return LinearInterpolate(previous->template Time<TimeType>(), previous->mValue, next->template Time<TimeType>(), next->mValue, aTime);
+case AudioTimelineEvent::ExponentialRamp:
+return ExponentialInterpolate(previous->template Time<TimeType>(), previous->mValue, next->template Time<TimeType>(), next->mValue, aTime);
+case AudioTimelineEvent::SetValue:
+case AudioTimelineEvent::SetTarget:
+case AudioTimelineEvent::SetValueCurve:
+break;
+}
+// Now handle all other cases
+switch (previous->mType) {
+case AudioTimelineEvent::SetValue:
+case AudioTimelineEvent::LinearRamp:
+case AudioTimelineEvent::ExponentialRamp:
+// If the next event type is neither linear or exponential ramp, the
+// value is constant.
+return previous->mValue;
+case AudioTimelineEvent::SetValueCurve:
+return ExtractValueFromCurve(previous->template Time<TimeType>(),
+previous->mCurve, previous->mCurveLength,
+previous->mDuration, aTime);
+case AudioTimelineEvent::SetTarget:
+MOZ_ASSERT(false, "unreached");
+}
+MOZ_ASSERT(false, "unreached");
+return 0.0f;
+}
+// Return the number of events scheduled
+uint32_t GetEventCount() const
+{
+return mEvents.Length();
+}
+static float LinearInterpolate(double t0, float v0, double t1, float v1, double t)
+{
+return v0 + (v1 - v0) * ((t - t0) / (t1 - t0));
+}
+static float ExponentialInterpolate(double t0, float v0, double t1, float v1, double t)
+{
+return v0 * powf(v1 / v0, (t - t0) / (t1 - t0));
+}
+static float ExponentialApproach(double t0, double v0, float v1, double timeConstant, double t)
+{
+return v1 + (v0 - v1) * expf(-(t - t0) / timeConstant);
+}
+static float ExtractValueFromCurve(double startTime, float* aCurve, uint32_t aCurveLength, double duration, double t)
+{
+if (t >= startTime + duration) {
+// After the duration, return the last curve value
+return aCurve[aCurveLength - 1];
+}
+double ratio = std::max((t - startTime) / duration, 0.0);
+if (ratio >= 1.0) {
+return aCurve[aCurveLength - 1];
+}
+return aCurve[uint32_t(aCurveLength * ratio)];
+}
+void ConvertEventTimesToTicks(int64_t (*aConvertor)(double aTime, void* aClosure), void* aClosure,
+int32_t aSampleRate)
+{
+for (unsigned i = 0; i < mEvents.Length(); ++i) {
+mEvents[i].SetTimeInTicks(aConvertor(mEvents[i].template Time<double>(), aClosure));
+mEvents[i].mTimeConstant *= aSampleRate;
+mEvents[i].mDuration *= aSampleRate;
+}
+}
+private:
+const AudioTimelineEvent* GetPreviousEvent(double aTime) const
+{
+const AudioTimelineEvent* previous = nullptr;
+const AudioTimelineEvent* next = nullptr;
+bool bailOut = false;
+for (unsigned i = 0; !bailOut && i < mEvents.Length(); ++i) {
+switch (mEvents[i].mType) {
+case AudioTimelineEvent::SetValue:
+case AudioTimelineEvent::SetTarget:
+case AudioTimelineEvent::LinearRamp:
+case AudioTimelineEvent::ExponentialRamp:
+case AudioTimelineEvent::SetValueCurve:
+if (aTime == mEvents[i].mTime) {
+// Find the last event with the same time
+do {
+++i;
+} while (i < mEvents.Length() &&
+aTime == mEvents[i].mTime);
+return &mEvents[i - 1];
+}
+previous = next;
+next = &mEvents[i];
+if (aTime < mEvents[i].mTime) {
+bailOut = true;
+}
+break;
+default:
+MOZ_ASSERT(false, "unreached");
+}
+}
+// Handle the case where the time is past all of the events
+if (!bailOut) {
+previous = next;
+}
+return previous;
+}
+void InsertEvent(const AudioTimelineEvent& aEvent, ErrorResult& aRv)
+{
+if (!aEvent.IsValid()) {
+aRv.Throw(NS_ERROR_DOM_SYNTAX_ERR);
+return;
+}
+// Make sure that non-curve events don't fall within the duration of a
+// curve event.
+for (unsigned i = 0; i < mEvents.Length(); ++i) {
+if (mEvents[i].mType == AudioTimelineEvent::SetValueCurve &&
+mEvents[i].mTime <= aEvent.mTime &&
+(mEvents[i].mTime + mEvents[i].mDuration) >= aEvent.mTime) {
+aRv.Throw(NS_ERROR_DOM_SYNTAX_ERR);
+return;
+}
+}
+// Make sure that curve events don't fall in a range which includes other
+// events.
+if (aEvent.mType == AudioTimelineEvent::SetValueCurve) {
+for (unsigned i = 0; i < mEvents.Length(); ++i) {
+if (mEvents[i].mTime > aEvent.mTime &&
+mEvents[i].mTime < (aEvent.mTime + aEvent.mDuration)) {
+aRv.Throw(NS_ERROR_DOM_SYNTAX_ERR);
+return;
+}
+}
+}
+// Make sure that invalid values are not used for exponential curves
+if (aEvent.mType == AudioTimelineEvent::ExponentialRamp) {
+if (aEvent.mValue <= 0.f) {
+aRv.Throw(NS_ERROR_DOM_SYNTAX_ERR);
+return;
+}
+const AudioTimelineEvent* previousEvent = GetPreviousEvent(aEvent.mTime);
+if (previousEvent) {
+if (previousEvent->mValue <= 0.f) {
+aRv.Throw(NS_ERROR_DOM_SYNTAX_ERR);
+return;
+}
+} else {
+if (mValue <= 0.f) {
+aRv.Throw(NS_ERROR_DOM_SYNTAX_ERR);
+return;
+}
+}
+}
+for (unsigned i = 0; i < mEvents.Length(); ++i) {
+if (aEvent.mTime == mEvents[i].mTime) {
+if (aEvent.mType == mEvents[i].mType) {
+// If times and types are equal, replace the event
+mEvents.ReplaceElementAt(i, aEvent);
+} else {
+// Otherwise, place the element after the last event of another type
+do {
+++i;
+} while (i < mEvents.Length() &&
+aEvent.mType != mEvents[i].mType &&
+aEvent.mTime == mEvents[i].mTime);
+mEvents.InsertElementAt(i, aEvent);
+}
+return;
+}
+// Otherwise, place the event right after the latest existing event
+if (aEvent.mTime < mEvents[i].mTime) {
+mEvents.InsertElementAt(i, aEvent);
+return;
+}
+}
+// If we couldn't find a place for the event, just append it to the list
+mEvents.AppendElement(aEvent);
+}
+private:
+// This is a sorted array of the events in the timeline.  Queries of this
+// data structure should probably be more frequent than modifications to it,
+// and that is the reason why we're using a simple array as the data structure.
+// We can optimize this in the future if the performance of the array ends up
+// being a bottleneck.
+nsTArray<AudioTimelineEvent> mEvents;
+float mValue;
+// This is the value of this AudioParam we computed at the last call.
+float mComputedValue;
+// This is the value of this AudioParam at the last tick of the previous event.
+float mLastComputedValue;
+};
+}
+}
+#endif

The Tor Browser / file comparison

comparison: content/media/AudioEventTimeline.h

content/media/AudioEventTimeline.h