#ifndef AudioContext_h
#define AudioContext_h
#include "ActiveDOMObject.h"
#include "AsyncAudioDecoder.h"
#include "AudioBus.h"
#include "AudioDestinationNode.h"
#include "EventListener.h"
#include "EventTarget.h"
#include "JSDOMPromise.h"
#include "MediaCanStartListener.h"
#include "MediaProducer.h"
#include "PlatformMediaSession.h"
#include <atomic>
#include <wtf/HashSet.h>
#include <wtf/MainThread.h>
#include <wtf/PassRefPtr.h>
#include <wtf/RefCounted.h>
#include <wtf/RefPtr.h>
#include <wtf/ThreadSafeRefCounted.h>
#include <wtf/Threading.h>
#include <wtf/Vector.h>
#include <wtf/text/AtomicStringHash.h>
namespace WebCore {
class AudioBuffer;
class AudioBufferCallback;
class AudioBufferSourceNode;
class MediaElementAudioSourceNode;
class MediaStreamAudioDestinationNode;
class MediaStreamAudioSourceNode;
class HRTFDatabaseLoader;
class HTMLMediaElement;
class ChannelMergerNode;
class ChannelSplitterNode;
class GainNode;
class GenericEventQueue;
class PannerNode;
class AudioListener;
class AudioSummingJunction;
class BiquadFilterNode;
class DelayNode;
class Document;
class ConvolverNode;
class DynamicsCompressorNode;
class AnalyserNode;
class WaveShaperNode;
class ScriptProcessorNode;
class OscillatorNode;
class PeriodicWave;
class AudioContext : public ActiveDOMObject, public ThreadSafeRefCounted<AudioContext>, public EventTargetWithInlineData, public MediaCanStartListener, public MediaProducer, private PlatformMediaSessionClient {
public:
static RefPtr<AudioContext> create(Document&, ExceptionCode&);
virtual ~AudioContext();
bool isInitialized() const;
bool isOfflineContext() { return m_isOfflineContext; }
Document* document() const;
const Document* hostingDocument() const override;
AudioDestinationNode* destination() { return m_destinationNode.get(); }
size_t currentSampleFrame() const { return m_destinationNode->currentSampleFrame(); }
double currentTime() const { return m_destinationNode->currentTime(); }
float sampleRate() const { return m_destinationNode->sampleRate(); }
unsigned long activeSourceCount() const { return static_cast<unsigned long>(m_activeSourceCount); }
void incrementActiveSourceCount();
void decrementActiveSourceCount();
PassRefPtr<AudioBuffer> createBuffer(unsigned numberOfChannels, size_t numberOfFrames, float sampleRate, ExceptionCode&);
PassRefPtr<AudioBuffer> createBuffer(ArrayBuffer*, bool mixToMono, ExceptionCode&);
void decodeAudioData(ArrayBuffer*, PassRefPtr<AudioBufferCallback>, PassRefPtr<AudioBufferCallback>, ExceptionCode& ec);
AudioListener* listener() { return m_listener.get(); }
using ActiveDOMObject::suspend;
using ActiveDOMObject::resume;
typedef DOMPromise<std::nullptr_t, ExceptionCode> Promise;
void suspend(Promise&&);
void resume(Promise&&);
void close(Promise&&);
const AtomicString& state() const;
PassRefPtr<AudioBufferSourceNode> createBufferSource();
#if ENABLE(VIDEO)
PassRefPtr<MediaElementAudioSourceNode> createMediaElementSource(HTMLMediaElement*, ExceptionCode&);
#endif
#if ENABLE(MEDIA_STREAM)
PassRefPtr<MediaStreamAudioSourceNode> createMediaStreamSource(MediaStream*, ExceptionCode&);
PassRefPtr<MediaStreamAudioDestinationNode> createMediaStreamDestination();
#endif
PassRefPtr<GainNode> createGain();
PassRefPtr<BiquadFilterNode> createBiquadFilter();
PassRefPtr<WaveShaperNode> createWaveShaper();
PassRefPtr<DelayNode> createDelay(ExceptionCode&);
PassRefPtr<DelayNode> createDelay(double maxDelayTime, ExceptionCode&);
PassRefPtr<PannerNode> createPanner();
PassRefPtr<ConvolverNode> createConvolver();
PassRefPtr<DynamicsCompressorNode> createDynamicsCompressor();
PassRefPtr<AnalyserNode> createAnalyser();
PassRefPtr<ScriptProcessorNode> createScriptProcessor(size_t bufferSize, ExceptionCode&);
PassRefPtr<ScriptProcessorNode> createScriptProcessor(size_t bufferSize, size_t numberOfInputChannels, ExceptionCode&);
PassRefPtr<ScriptProcessorNode> createScriptProcessor(size_t bufferSize, size_t numberOfInputChannels, size_t numberOfOutputChannels, ExceptionCode&);
PassRefPtr<ChannelSplitterNode> createChannelSplitter(ExceptionCode&);
PassRefPtr<ChannelSplitterNode> createChannelSplitter(size_t numberOfOutputs, ExceptionCode&);
PassRefPtr<ChannelMergerNode> createChannelMerger(ExceptionCode&);
PassRefPtr<ChannelMergerNode> createChannelMerger(size_t numberOfInputs, ExceptionCode&);
PassRefPtr<OscillatorNode> createOscillator();
PassRefPtr<PeriodicWave> createPeriodicWave(Float32Array* real, Float32Array* imag, ExceptionCode&);
void notifyNodeFinishedProcessing(AudioNode*);
void handlePreRenderTasks();
void handlePostRenderTasks();
void derefFinishedSourceNodes();
void markForDeletion(AudioNode*);
void deleteMarkedNodes();
void addAutomaticPullNode(AudioNode*);
void removeAutomaticPullNode(AudioNode*);
void processAutomaticPullNodes(size_t framesToProcess);
void incrementConnectionCount()
{
ASSERT(isMainThread());
m_connectionCount++;
}
unsigned connectionCount() const { return m_connectionCount; }
void setAudioThread(ThreadIdentifier thread) { m_audioThread = thread; } ThreadIdentifier audioThread() const { return m_audioThread; }
bool isAudioThread() const;
bool isAudioThreadFinished() { return m_isAudioThreadFinished; }
void lock(bool& mustReleaseLock);
bool tryLock(bool& mustReleaseLock);
void unlock();
bool isGraphOwner() const;
static unsigned maxNumberOfChannels() { return MaxNumberOfChannels;}
class AutoLocker {
public:
explicit AutoLocker(AudioContext& context)
: m_context(context)
{
m_context.lock(m_mustReleaseLock);
}
~AutoLocker()
{
if (m_mustReleaseLock)
m_context.unlock();
}
private:
AudioContext& m_context;
bool m_mustReleaseLock;
};
void addDeferredFinishDeref(AudioNode*);
void handleDeferredFinishDerefs();
void markSummingJunctionDirty(AudioSummingJunction*);
void markAudioNodeOutputDirty(AudioNodeOutput*);
void removeMarkedSummingJunction(AudioSummingJunction*);
virtual EventTargetInterface eventTargetInterface() const override final { return AudioContextEventTargetInterfaceType; }
virtual ScriptExecutionContext* scriptExecutionContext() const override final;
using ThreadSafeRefCounted<AudioContext>::ref;
using ThreadSafeRefCounted<AudioContext>::deref;
void startRendering();
void fireCompletionEvent();
static unsigned s_hardwareContextCount;
enum BehaviorRestrictionFlags {
NoRestrictions = 0,
RequireUserGestureForAudioStartRestriction = 1 << 0,
RequirePageConsentForAudioStartRestriction = 1 << 1,
};
typedef unsigned BehaviorRestrictions;
BehaviorRestrictions behaviorRestrictions() const { return m_restrictions; }
void addBehaviorRestriction(BehaviorRestrictions restriction) { m_restrictions |= restriction; }
void removeBehaviorRestriction(BehaviorRestrictions restriction) { m_restrictions &= ~restriction; }
void isPlayingAudioDidChange();
void nodeWillBeginPlayback();
protected:
explicit AudioContext(Document&);
AudioContext(Document&, unsigned numberOfChannels, size_t numberOfFrames, float sampleRate);
static bool isSampleRateRangeGood(float sampleRate);
private:
void constructCommon();
void lazyInitialize();
void uninitialize();
bool willBeginPlayback();
bool willPausePlayback();
bool userGestureRequiredForAudioStart() const { return m_restrictions & RequireUserGestureForAudioStartRestriction; }
bool pageConsentRequiredForAudioStart() const { return m_restrictions & RequirePageConsentForAudioStartRestriction; }
enum class State { Suspended, Running, Interrupted, Closed };
void setState(State);
void clear();
void scheduleNodeDeletion();
virtual void mediaCanStart() override;
virtual MediaProducer::MediaStateFlags mediaState() const override;
virtual void pageMutedStateDidChange() override;
void refNode(AudioNode*);
void derefNode(AudioNode*);
void stop() override;
bool canSuspendForPageCache() const override;
const char* activeDOMObjectName() const override;
void derefUnfinishedSourceNodes();
virtual PlatformMediaSession::MediaType mediaType() const override { return PlatformMediaSession::WebAudio; }
virtual PlatformMediaSession::MediaType presentationType() const override { return PlatformMediaSession::WebAudio; }
virtual void mayResumePlayback(bool shouldResume) override;
virtual void suspendPlayback() override;
virtual bool canReceiveRemoteControlCommands() const override { return false; }
virtual void didReceiveRemoteControlCommand(PlatformMediaSession::RemoteControlCommandType) override { }
virtual bool overrideBackgroundPlaybackRestriction() const override { return false; }
virtual void refEventTarget() override { ref(); }
virtual void derefEventTarget() override { deref(); }
void handleDirtyAudioSummingJunctions();
void handleDirtyAudioNodeOutputs();
void addReaction(State, Promise&&);
void updateAutomaticPullNodes();
Vector<AudioNode*> m_finishedNodes;
Vector<AudioNode*> m_referencedNodes;
Vector<AudioNode*> m_nodesMarkedForDeletion;
Vector<AudioNode*> m_nodesToDelete;
bool m_isDeletionScheduled { false };
bool m_isStopScheduled { false };
bool m_isInitialized { false };
bool m_isAudioThreadFinished { false };
bool m_automaticPullNodesNeedUpdating { false };
bool m_isOfflineContext { false };
HashSet<AudioSummingJunction*> m_dirtySummingJunctions;
HashSet<AudioNodeOutput*> m_dirtyAudioNodeOutputs;
HashSet<AudioNode*> m_automaticPullNodes;
Vector<AudioNode*> m_renderingAutomaticPullNodes;
Vector<AudioNode*> m_deferredFinishDerefList;
Vector<Vector<Promise>> m_stateReactions;
std::unique_ptr<PlatformMediaSession> m_mediaSession;
std::unique_ptr<GenericEventQueue> m_eventQueue;
RefPtr<AudioBuffer> m_renderTarget;
RefPtr<AudioDestinationNode> m_destinationNode;
RefPtr<AudioListener> m_listener;
unsigned m_connectionCount { 0 };
Mutex m_contextGraphMutex;
volatile ThreadIdentifier m_audioThread { 0 };
volatile ThreadIdentifier m_graphOwnerThread;
AsyncAudioDecoder m_audioDecoder;
enum { MaxNumberOfChannels = 32 };
std::atomic<int> m_activeSourceCount { 0 };
BehaviorRestrictions m_restrictions { NoRestrictions };
State m_state { State::Suspended };
};
}
#endif // AudioContext_h