mirror of
https://repo.dactyloidae.xyz/Dactyloidae/UXP.git
synced 2026-09-28 19:37:32 +09:00
import FIREFOX_52_6_0esr_RELEASE from mozilla-esr52 hg repo
This commit is contained in:
Roy Tam
commit
dcd9973243
150858 changed files with 23884658 additions and 0 deletions
474
dom/media/webaudio/AudioEventTimeline.h
Normal file
474
dom/media/webaudio/AudioEventTimeline.h
Normal file
|
|
@ -0,0 +1,474 @@
|
|||
/* -*- 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/PodOperations.h"
|
||||
|
||||
#include "MainThreadUtils.h"
|
||||
#include "nsTArray.h"
|
||||
#include "math.h"
|
||||
#include "WebAudioUtils.h"
|
||||
|
||||
namespace mozilla {
|
||||
|
||||
class MediaStream;
|
||||
|
||||
namespace dom {
|
||||
|
||||
struct AudioTimelineEvent final
|
||||
{
|
||||
enum Type : uint32_t
|
||||
{
|
||||
SetValue,
|
||||
SetValueAtTime,
|
||||
LinearRamp,
|
||||
ExponentialRamp,
|
||||
SetTarget,
|
||||
SetValueCurve,
|
||||
Stream,
|
||||
Cancel
|
||||
};
|
||||
|
||||
AudioTimelineEvent(Type aType, double aTime, float aValue, double aTimeConstant = 0.0,
|
||||
double aDuration = 0.0, const float* aCurve = nullptr,
|
||||
uint32_t aCurveLength = 0)
|
||||
: mType(aType)
|
||||
, mCurve(nullptr)
|
||||
, mTimeConstant(aTimeConstant)
|
||||
, mDuration(aDuration)
|
||||
#ifdef DEBUG
|
||||
, mTimeIsInTicks(false)
|
||||
#endif
|
||||
{
|
||||
mTime = aTime;
|
||||
if (aType == AudioTimelineEvent::SetValueCurve) {
|
||||
SetCurveParams(aCurve, aCurveLength);
|
||||
} else {
|
||||
mValue = aValue;
|
||||
}
|
||||
}
|
||||
|
||||
explicit AudioTimelineEvent(MediaStream* aStream)
|
||||
: mType(Stream)
|
||||
, mCurve(nullptr)
|
||||
, mStream(aStream)
|
||||
, mTimeConstant(0.0)
|
||||
, mDuration(0.0)
|
||||
#ifdef DEBUG
|
||||
, mTimeIsInTicks(false)
|
||||
#endif
|
||||
{
|
||||
}
|
||||
|
||||
AudioTimelineEvent(const AudioTimelineEvent& rhs)
|
||||
{
|
||||
PodCopy(this, &rhs, 1);
|
||||
|
||||
if (rhs.mType == AudioTimelineEvent::SetValueCurve) {
|
||||
SetCurveParams(rhs.mCurve, rhs.mCurveLength);
|
||||
} else if (rhs.mType == AudioTimelineEvent::Stream) {
|
||||
new (&mStream) decltype(mStream)(rhs.mStream);
|
||||
}
|
||||
}
|
||||
|
||||
~AudioTimelineEvent()
|
||||
{
|
||||
if (mType == AudioTimelineEvent::SetValueCurve) {
|
||||
delete[] mCurve;
|
||||
}
|
||||
}
|
||||
|
||||
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;
|
||||
};
|
||||
// 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;
|
||||
RefPtr<MediaStream> mStream;
|
||||
double mTimeConstant;
|
||||
double mDuration;
|
||||
#ifdef DEBUG
|
||||
bool mTimeIsInTicks;
|
||||
#endif
|
||||
|
||||
private:
|
||||
// This member is accessed using the `Time` method, for safety.
|
||||
//
|
||||
// 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;
|
||||
};
|
||||
};
|
||||
|
||||
template <>
|
||||
inline double AudioTimelineEvent::Time<double>() const
|
||||
{
|
||||
MOZ_ASSERT(!mTimeIsInTicks);
|
||||
return mTime;
|
||||
}
|
||||
|
||||
template <>
|
||||
inline int64_t AudioTimelineEvent::Time<int64_t>() const
|
||||
{
|
||||
MOZ_ASSERT(!NS_IsMainThread());
|
||||
MOZ_ASSERT(mTimeIsInTicks);
|
||||
return mTimeInTicks;
|
||||
}
|
||||
|
||||
/**
|
||||
* Some methods in this class will be instantiated with different ErrorResult
|
||||
* 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.
|
||||
*/
|
||||
class AudioEventTimeline
|
||||
{
|
||||
public:
|
||||
explicit AudioEventTimeline(float aDefaultValue)
|
||||
: mValue(aDefaultValue),
|
||||
mComputedValue(aDefaultValue),
|
||||
mLastComputedValue(aDefaultValue)
|
||||
{ }
|
||||
|
||||
template <class ErrorResult>
|
||||
bool ValidateEvent(AudioTimelineEvent& aEvent, ErrorResult& aRv)
|
||||
{
|
||||
MOZ_ASSERT(NS_IsMainThread());
|
||||
|
||||
auto TimeOf = [](const AudioTimelineEvent& aEvent) -> double {
|
||||
return aEvent.template Time<double>();
|
||||
};
|
||||
|
||||
// Validate the event itself
|
||||
if (!WebAudioUtils::IsTimeValid(TimeOf(aEvent)) ||
|
||||
!WebAudioUtils::IsTimeValid(aEvent.mTimeConstant)) {
|
||||
aRv.Throw(NS_ERROR_DOM_SYNTAX_ERR);
|
||||
return false;
|
||||
}
|
||||
|
||||
if (aEvent.mType == AudioTimelineEvent::SetValueCurve) {
|
||||
if (!aEvent.mCurve || !aEvent.mCurveLength) {
|
||||
aRv.Throw(NS_ERROR_DOM_SYNTAX_ERR);
|
||||
return false;
|
||||
}
|
||||
for (uint32_t i = 0; i < aEvent.mCurveLength; ++i) {
|
||||
if (!IsValid(aEvent.mCurve[i])) {
|
||||
aRv.Throw(NS_ERROR_DOM_SYNTAX_ERR);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
bool timeAndValueValid = IsValid(aEvent.mValue) &&
|
||||
IsValid(aEvent.mDuration);
|
||||
if (!timeAndValueValid) {
|
||||
aRv.Throw(NS_ERROR_DOM_SYNTAX_ERR);
|
||||
return false;
|
||||
}
|
||||
|
||||
// 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 &&
|
||||
!(aEvent.mType == AudioTimelineEvent::SetValueCurve &&
|
||||
TimeOf(aEvent) == TimeOf(mEvents[i])) &&
|
||||
TimeOf(mEvents[i]) <= TimeOf(aEvent) &&
|
||||
TimeOf(mEvents[i]) + mEvents[i].mDuration >= TimeOf(aEvent)) {
|
||||
aRv.Throw(NS_ERROR_DOM_SYNTAX_ERR);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
// 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) {
|
||||
// In case we have two curve at the same time
|
||||
if (mEvents[i].mType == AudioTimelineEvent::SetValueCurve &&
|
||||
TimeOf(mEvents[i]) == TimeOf(aEvent)) {
|
||||
continue;
|
||||
}
|
||||
if (TimeOf(mEvents[i]) > TimeOf(aEvent) &&
|
||||
TimeOf(mEvents[i]) < TimeOf(aEvent) + aEvent.mDuration) {
|
||||
aRv.Throw(NS_ERROR_DOM_SYNTAX_ERR);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// 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 false;
|
||||
}
|
||||
const AudioTimelineEvent* previousEvent = GetPreviousEvent(TimeOf(aEvent));
|
||||
if (previousEvent) {
|
||||
if (previousEvent->mValue <= 0.f) {
|
||||
aRv.Throw(NS_ERROR_DOM_SYNTAX_ERR);
|
||||
return false;
|
||||
}
|
||||
} else {
|
||||
if (mValue <= 0.f) {
|
||||
aRv.Throw(NS_ERROR_DOM_SYNTAX_ERR);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
template<typename TimeType>
|
||||
void InsertEvent(const AudioTimelineEvent& aEvent)
|
||||
{
|
||||
for (unsigned i = 0; i < mEvents.Length(); ++i) {
|
||||
if (aEvent.template Time<TimeType>() == mEvents[i].template Time<TimeType>()) {
|
||||
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.template Time<TimeType>() == mEvents[i].template Time<TimeType>());
|
||||
mEvents.InsertElementAt(i, aEvent);
|
||||
}
|
||||
return;
|
||||
}
|
||||
// Otherwise, place the event right after the latest existing event
|
||||
if (aEvent.template Time<TimeType>() < mEvents[i].template Time<TimeType>()) {
|
||||
mEvents.InsertElementAt(i, aEvent);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
// If we couldn't find a place for the event, just append it to the list
|
||||
mEvents.AppendElement(aEvent);
|
||||
}
|
||||
|
||||
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;
|
||||
}
|
||||
}
|
||||
|
||||
template <class ErrorResult>
|
||||
void SetValueAtTime(float aValue, double aStartTime, ErrorResult& aRv)
|
||||
{
|
||||
AudioTimelineEvent event(AudioTimelineEvent::SetValueAtTime, aStartTime, aValue);
|
||||
|
||||
if (ValidateEvent(event, aRv)) {
|
||||
InsertEvent<double>(event);
|
||||
}
|
||||
}
|
||||
|
||||
template <class ErrorResult>
|
||||
void LinearRampToValueAtTime(float aValue, double aEndTime, ErrorResult& aRv)
|
||||
{
|
||||
AudioTimelineEvent event(AudioTimelineEvent::LinearRamp, aEndTime, aValue);
|
||||
|
||||
if (ValidateEvent(event, aRv)) {
|
||||
InsertEvent<double>(event);
|
||||
}
|
||||
}
|
||||
|
||||
template <class ErrorResult>
|
||||
void ExponentialRampToValueAtTime(float aValue, double aEndTime, ErrorResult& aRv)
|
||||
{
|
||||
AudioTimelineEvent event(AudioTimelineEvent::ExponentialRamp, aEndTime, aValue);
|
||||
|
||||
if (ValidateEvent(event, aRv)) {
|
||||
InsertEvent<double>(event);
|
||||
}
|
||||
}
|
||||
|
||||
template <class ErrorResult>
|
||||
void SetTargetAtTime(float aTarget, double aStartTime, double aTimeConstant, ErrorResult& aRv)
|
||||
{
|
||||
AudioTimelineEvent event(AudioTimelineEvent::SetTarget, aStartTime, aTarget, aTimeConstant);
|
||||
|
||||
if (ValidateEvent(event, aRv)) {
|
||||
InsertEvent<double>(event);
|
||||
}
|
||||
}
|
||||
|
||||
template <class ErrorResult>
|
||||
void SetValueCurveAtTime(const float* aValues, uint32_t aValuesLength, double aStartTime, double aDuration, ErrorResult& aRv)
|
||||
{
|
||||
AudioTimelineEvent event(AudioTimelineEvent::SetValueCurve, aStartTime, 0.0f, 0.0f, aDuration, aValues, aValuesLength);
|
||||
if (ValidateEvent(event, aRv)) {
|
||||
InsertEvent<double>(event);
|
||||
}
|
||||
}
|
||||
|
||||
template<typename TimeType>
|
||||
void CancelScheduledValues(TimeType aStartTime)
|
||||
{
|
||||
for (unsigned i = 0; i < mEvents.Length(); ++i) {
|
||||
if (mEvents[i].template Time<TimeType>() >= 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].template Time<TimeType>() >= 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)
|
||||
{
|
||||
float result;
|
||||
GetValuesAtTimeHelper(aTime, &result, 1);
|
||||
return result;
|
||||
}
|
||||
|
||||
template<class TimeType>
|
||||
void GetValuesAtTime(TimeType aTime, float* aBuffer, const size_t aSize)
|
||||
{
|
||||
MOZ_ASSERT(aBuffer);
|
||||
GetValuesAtTimeHelper(aTime, aBuffer, aSize);
|
||||
}
|
||||
|
||||
// Return the number of events scheduled
|
||||
uint32_t GetEventCount() const
|
||||
{
|
||||
return mEvents.Length();
|
||||
}
|
||||
|
||||
template<class TimeType>
|
||||
void CleanupEventsOlderThan(TimeType aTime)
|
||||
{
|
||||
while (mEvents.Length() > 1 &&
|
||||
aTime > mEvents[1].template Time<TimeType>()) {
|
||||
|
||||
if (mEvents[1].mType == AudioTimelineEvent::SetTarget) {
|
||||
mLastComputedValue = GetValuesAtTimeHelperInternal(
|
||||
mEvents[1].template Time<TimeType>(),
|
||||
&mEvents[0], nullptr);
|
||||
}
|
||||
|
||||
mEvents.RemoveElementAt(0);
|
||||
}
|
||||
}
|
||||
|
||||
private:
|
||||
template<class TimeType>
|
||||
void GetValuesAtTimeHelper(TimeType aTime, float* aBuffer, const size_t aSize);
|
||||
|
||||
template<class TimeType>
|
||||
float GetValueAtTimeOfEvent(const AudioTimelineEvent* aNext);
|
||||
|
||||
template<class TimeType>
|
||||
float GetValuesAtTimeHelperInternal(TimeType aTime,
|
||||
const AudioTimelineEvent* aPrevious,
|
||||
const AudioTimelineEvent* aNext);
|
||||
|
||||
const AudioTimelineEvent* GetPreviousEvent(double aTime) const;
|
||||
|
||||
static bool IsValid(double value)
|
||||
{
|
||||
return mozilla::IsFinite(value);
|
||||
}
|
||||
|
||||
// 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 tick.
|
||||
float mComputedValue;
|
||||
// This is the value of this AudioParam at the last tick of the previous event.
|
||||
float mLastComputedValue;
|
||||
};
|
||||
|
||||
} // namespace dom
|
||||
} // namespace mozilla
|
||||
|
||||
#endif
|
||||
Loading…
Add table
Add a link
Reference in a new issue