⚠ Archived content — this site is no longer maintained.   Current WebKit documentation is at docs.webkit.org.

Changeset 242734 in webkit


Ignore:
Timestamp:
Mar 11, 2019, 1:19:49 PM (7 years ago)
Author:
eric.carlson@apple.com
Message:

Add web audio release logging
​https://bugs.webkit.org/show_bug.cgi?id=195554
<rdar://problem/48767211>

Reviewed by Jer Noble.

No new tests, no functional change.

  • Modules/webaudio/AudioBasicInspectorNode.cpp:

(WebCore::AudioBasicInspectorNode::AudioBasicInspectorNode):

  • Modules/webaudio/AudioBufferSourceNode.cpp:

(WebCore::AudioBufferSourceNode::setBuffer):
(WebCore::AudioBufferSourceNode::startPlaying):

  • Modules/webaudio/AudioContext.cpp:

(WebCore::nextLogIdentifier):
(WebCore::AudioContext::AudioContext):
(WebCore::AudioContext::uninitialize):
(WebCore::AudioContext::stop):
(WebCore::AudioContext::createBufferSource):
(WebCore::AudioContext::createMediaElementSource):
(WebCore::AudioContext::createMediaStreamSource):
(WebCore::AudioContext::createScriptProcessor):
(WebCore::AudioContext::createBiquadFilter):
(WebCore::AudioContext::createWaveShaper):
(WebCore::AudioContext::createPanner):
(WebCore::AudioContext::createConvolver):
(WebCore::AudioContext::createDynamicsCompressor):
(WebCore::AudioContext::createAnalyser):
(WebCore::AudioContext::createGain):
(WebCore::AudioContext::createDelay):
(WebCore::AudioContext::createChannelSplitter):
(WebCore::AudioContext::createChannelMerger):
(WebCore::AudioContext::createOscillator):
(WebCore::AudioContext::createPeriodicWave):
(WebCore::AudioContext::willBeginPlayback):
(WebCore::AudioContext::startRendering):
(WebCore::AudioContext::fireCompletionEvent):
(WebCore::AudioContext::logChannel const):

  • Modules/webaudio/AudioContext.h:

(WebCore::AudioContext::nextAudioNodeLogIdentifier):
(WebCore::AudioContext::nextAudioParameterLogIdentifier):

  • Modules/webaudio/AudioDestinationNode.cpp:

(WebCore::AudioDestinationNode::AudioDestinationNode):

  • Modules/webaudio/AudioNode.cpp:

(WebCore::convertEnumerationToString):
(WebCore::AudioNode::AudioNode):
(WebCore::AudioNode::~AudioNode):
(WebCore::AudioNode::setNodeType):
(WebCore::AudioNode::addInput):
(WebCore::AudioNode::addOutput):
(WebCore::AudioNode::connect):
(WebCore::AudioNode::disconnect):
(WebCore::AudioNode::setChannelCount):
(WebCore::AudioNode::setChannelCountMode):
(WebCore::AudioNode::setChannelInterpretation):
(WebCore::AudioNode::logChannel const):

  • Modules/webaudio/AudioNode.h:

(WTF::LogArgument<WebCore::AudioNode::NodeType>::toString):

  • Modules/webaudio/AudioParam.cpp:

(WebCore::AudioParam::AudioParam):
(WebCore::AudioParam::setValue):
(WebCore::AudioParam::connect):
(WebCore::AudioParam::disconnect):
(WebCore::AudioParam::logChannel const):

  • Modules/webaudio/AudioParam.h:
  • Modules/webaudio/AudioScheduledSourceNode.cpp:

(WebCore::AudioScheduledSourceNode::start):
(WebCore::AudioScheduledSourceNode::stop):

  • Modules/webaudio/BiquadFilterNode.cpp:

(WebCore::BiquadFilterNode::BiquadFilterNode):

  • Modules/webaudio/ChannelMergerNode.cpp:

(WebCore::ChannelMergerNode::ChannelMergerNode):

  • Modules/webaudio/ChannelSplitterNode.cpp:

(WebCore::ChannelSplitterNode::ChannelSplitterNode):

  • Modules/webaudio/ConvolverNode.cpp:

(WebCore::ConvolverNode::ConvolverNode):

  • Modules/webaudio/DefaultAudioDestinationNode.cpp:

(WebCore::DefaultAudioDestinationNode::initialize):
(WebCore::DefaultAudioDestinationNode::uninitialize):
(WebCore::DefaultAudioDestinationNode::enableInput):
(WebCore::DefaultAudioDestinationNode::setChannelCount):

  • Modules/webaudio/DelayNode.cpp:

(WebCore::DelayNode::DelayNode):

  • Modules/webaudio/DynamicsCompressorNode.cpp:

(WebCore::DynamicsCompressorNode::DynamicsCompressorNode):

  • Modules/webaudio/GainNode.cpp:

(WebCore::GainNode::GainNode):

  • Modules/webaudio/MediaElementAudioSourceNode.cpp:

(WebCore::MediaElementAudioSourceNode::MediaElementAudioSourceNode):

  • Modules/webaudio/MediaStreamAudioSourceNode.cpp:

(WebCore::MediaStreamAudioSourceNode::MediaStreamAudioSourceNode):

  • Modules/webaudio/OfflineAudioDestinationNode.cpp:

(WebCore::OfflineAudioDestinationNode::startRendering):

  • Modules/webaudio/OscillatorNode.cpp:

(WebCore::OscillatorNode::setType):
(WebCore::OscillatorNode::setPeriodicWave):

  • Modules/webaudio/OscillatorNode.h:

(WTF::LogArgument<WebCore::OscillatorNode::Type>::toString):

  • Modules/webaudio/PannerNode.cpp:

(WebCore::PannerNode::PannerNode):

  • Modules/webaudio/ScriptProcessorNode.cpp:

(WebCore::ScriptProcessorNode::ScriptProcessorNode):

  • Modules/webaudio/WaveShaperNode.cpp:

(WebCore::WaveShaperNode::WaveShaperNode):
(WebCore::WaveShaperNode::setCurve):
(WebCore::WaveShaperNode::setOversample):

  • Modules/webaudio/WaveShaperNode.h:

(WTF::LogArgument<WebCore::WaveShaperNode::OverSampleType>::toString):

Location:
trunk/Source/WebCore
Files:
28 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r242729 r242734  
     12019-03-11  Eric Carlson  <eric.carlson@apple.com>
     2
     3        Add web audio release logging
     4        https://bugs.webkit.org/show_bug.cgi?id=195554
     5        <rdar://problem/48767211>
     6
     7        Reviewed by Jer Noble.
     8
     9        No new tests, no functional change.
     10
     11        * Modules/webaudio/AudioBasicInspectorNode.cpp:
     12        (WebCore::AudioBasicInspectorNode::AudioBasicInspectorNode):
     13        * Modules/webaudio/AudioBufferSourceNode.cpp:
     14        (WebCore::AudioBufferSourceNode::setBuffer):
     15        (WebCore::AudioBufferSourceNode::startPlaying):
     16        * Modules/webaudio/AudioContext.cpp:
     17        (WebCore::nextLogIdentifier):
     18        (WebCore::AudioContext::AudioContext):
     19        (WebCore::AudioContext::uninitialize):
     20        (WebCore::AudioContext::stop):
     21        (WebCore::AudioContext::createBufferSource):
     22        (WebCore::AudioContext::createMediaElementSource):
     23        (WebCore::AudioContext::createMediaStreamSource):
     24        (WebCore::AudioContext::createScriptProcessor):
     25        (WebCore::AudioContext::createBiquadFilter):
     26        (WebCore::AudioContext::createWaveShaper):
     27        (WebCore::AudioContext::createPanner):
     28        (WebCore::AudioContext::createConvolver):
     29        (WebCore::AudioContext::createDynamicsCompressor):
     30        (WebCore::AudioContext::createAnalyser):
     31        (WebCore::AudioContext::createGain):
     32        (WebCore::AudioContext::createDelay):
     33        (WebCore::AudioContext::createChannelSplitter):
     34        (WebCore::AudioContext::createChannelMerger):
     35        (WebCore::AudioContext::createOscillator):
     36        (WebCore::AudioContext::createPeriodicWave):
     37        (WebCore::AudioContext::willBeginPlayback):
     38        (WebCore::AudioContext::startRendering):
     39        (WebCore::AudioContext::fireCompletionEvent):
     40        (WebCore::AudioContext::logChannel const):
     41        * Modules/webaudio/AudioContext.h:
     42        (WebCore::AudioContext::nextAudioNodeLogIdentifier):
     43        (WebCore::AudioContext::nextAudioParameterLogIdentifier):
     44        * Modules/webaudio/AudioDestinationNode.cpp:
     45        (WebCore::AudioDestinationNode::AudioDestinationNode):
     46        * Modules/webaudio/AudioNode.cpp:
     47        (WebCore::convertEnumerationToString):
     48        (WebCore::AudioNode::AudioNode):
     49        (WebCore::AudioNode::~AudioNode):
     50        (WebCore::AudioNode::setNodeType):
     51        (WebCore::AudioNode::addInput):
     52        (WebCore::AudioNode::addOutput):
     53        (WebCore::AudioNode::connect):
     54        (WebCore::AudioNode::disconnect):
     55        (WebCore::AudioNode::setChannelCount):
     56        (WebCore::AudioNode::setChannelCountMode):
     57        (WebCore::AudioNode::setChannelInterpretation):
     58        (WebCore::AudioNode::logChannel const):
     59        * Modules/webaudio/AudioNode.h:
     60        (WTF::LogArgument<WebCore::AudioNode::NodeType>::toString):
     61        * Modules/webaudio/AudioParam.cpp:
     62        (WebCore::AudioParam::AudioParam):
     63        (WebCore::AudioParam::setValue):
     64        (WebCore::AudioParam::connect):
     65        (WebCore::AudioParam::disconnect):
     66        (WebCore::AudioParam::logChannel const):
     67        * Modules/webaudio/AudioParam.h:
     68        * Modules/webaudio/AudioScheduledSourceNode.cpp:
     69        (WebCore::AudioScheduledSourceNode::start):
     70        (WebCore::AudioScheduledSourceNode::stop):
     71        * Modules/webaudio/BiquadFilterNode.cpp:
     72        (WebCore::BiquadFilterNode::BiquadFilterNode):
     73        * Modules/webaudio/ChannelMergerNode.cpp:
     74        (WebCore::ChannelMergerNode::ChannelMergerNode):
     75        * Modules/webaudio/ChannelSplitterNode.cpp:
     76        (WebCore::ChannelSplitterNode::ChannelSplitterNode):
     77        * Modules/webaudio/ConvolverNode.cpp:
     78        (WebCore::ConvolverNode::ConvolverNode):
     79        * Modules/webaudio/DefaultAudioDestinationNode.cpp:
     80        (WebCore::DefaultAudioDestinationNode::initialize):
     81        (WebCore::DefaultAudioDestinationNode::uninitialize):
     82        (WebCore::DefaultAudioDestinationNode::enableInput):
     83        (WebCore::DefaultAudioDestinationNode::setChannelCount):
     84        * Modules/webaudio/DelayNode.cpp:
     85        (WebCore::DelayNode::DelayNode):
     86        * Modules/webaudio/DynamicsCompressorNode.cpp:
     87        (WebCore::DynamicsCompressorNode::DynamicsCompressorNode):
     88        * Modules/webaudio/GainNode.cpp:
     89        (WebCore::GainNode::GainNode):
     90        * Modules/webaudio/MediaElementAudioSourceNode.cpp:
     91        (WebCore::MediaElementAudioSourceNode::MediaElementAudioSourceNode):
     92        * Modules/webaudio/MediaStreamAudioSourceNode.cpp:
     93        (WebCore::MediaStreamAudioSourceNode::MediaStreamAudioSourceNode):
     94        * Modules/webaudio/OfflineAudioDestinationNode.cpp:
     95        (WebCore::OfflineAudioDestinationNode::startRendering):
     96        * Modules/webaudio/OscillatorNode.cpp:
     97        (WebCore::OscillatorNode::setType):
     98        (WebCore::OscillatorNode::setPeriodicWave):
     99        * Modules/webaudio/OscillatorNode.h:
     100        (WTF::LogArgument<WebCore::OscillatorNode::Type>::toString):
     101        * Modules/webaudio/PannerNode.cpp:
     102        (WebCore::PannerNode::PannerNode):
     103        * Modules/webaudio/ScriptProcessorNode.cpp:
     104        (WebCore::ScriptProcessorNode::ScriptProcessorNode):
     105        * Modules/webaudio/WaveShaperNode.cpp:
     106        (WebCore::WaveShaperNode::WaveShaperNode):
     107        (WebCore::WaveShaperNode::setCurve):
     108        (WebCore::WaveShaperNode::setOversample):
     109        * Modules/webaudio/WaveShaperNode.h:
     110        (WTF::LogArgument<WebCore::WaveShaperNode::OverSampleType>::toString):
     111
    11122019-03-11  Youenn Fablet  <youenn@apple.com>
    2113

  • trunk/Source/WebCore/Modules/webaudio/AudioBasicInspectorNode.cpp

    r240237 r242734  
    3737    : AudioNode(context, sampleRate)
    3838{
     39    setNodeType(NodeTypeBasicInspector);
    3940    addInput(std::make_unique<AudioNodeInput>(this));
    4041    addOutput(std::make_unique<AudioNodeOutput>(this, outputChannelCount));

  • trunk/Source/WebCore/Modules/webaudio/AudioBufferSourceNode.cpp

    r239427 r242734  
    408408{
    409409    ASSERT(isMainThread());
    410    
     410    DEBUG_LOG(LOGIDENTIFIER);
     411
    411412    // The context must be locked since changing the buffer can re-configure the number of channels that are output.
    412413    AudioContext::AutoLocker contextLocker(context());
    … …  
    452453{
    453454    ASSERT(isMainThread());
     455    ALWAYS_LOG(LOGIDENTIFIER, "when = ", when, ", offset = ", grainOffset, ", duration = ", grainDuration);
    454456
    455457    context().nodeWillBeginPlayback();

  • trunk/Source/WebCore/Modules/webaudio/AudioContext.cpp

    r241130 r242734  
    107107#define RELEASE_LOG_IF_ALLOWED(fmt, ...) RELEASE_LOG_IF(document()->page() && document()->page()->isAlwaysOnLoggingAllowed(), Media, "%p - AudioContext::" fmt, this, ##__VA_ARGS__)
    108108   
     109#if !RELEASE_LOG_DISABLED
     110static const void* nextLogIdentifier()
     111{
     112    static uint64_t logIdentifier = cryptographicallyRandomNumber();
     113    return reinterpret_cast<const void*>(++logIdentifier);
     114}
     115#endif
     116
    109117bool AudioContext::isSampleRateRangeGood(float sampleRate)
    110118{
    … …  
    132140AudioContext::AudioContext(Document& document)
    133141    : ActiveDOMObject(document)
     142#if !RELEASE_LOG_DISABLED
     143    , m_logger(document.logger())
     144    , m_logIdentifier(nextLogIdentifier())
     145#endif
    134146    , m_mediaSession(PlatformMediaSession::create(*this))
    135147    , m_eventQueue(std::make_unique<GenericEventQueue>(*this))
    … …  
    146158AudioContext::AudioContext(Document& document, unsigned numberOfChannels, size_t numberOfFrames, float sampleRate)
    147159    : ActiveDOMObject(document)
     160#if !RELEASE_LOG_DISABLED
     161    , m_logger(document.logger())
     162    , m_logIdentifier(nextLogIdentifier())
     163#endif
    148164    , m_isOfflineContext(true)
    149165    , m_mediaSession(PlatformMediaSession::create(*this))
    … …  
    241257void AudioContext::uninitialize()
    242258{
     259    ALWAYS_LOG(LOGIDENTIFIER);
     260   
    243261    ASSERT(isMainThread());
    244262
    … …  
    304322void AudioContext::stop()
    305323{
     324    ALWAYS_LOG(LOGIDENTIFIER);
     325   
    306326    ASSERT(isMainThread());
    307327
    … …  
    414434Ref<AudioBufferSourceNode> AudioContext::createBufferSource()
    415435{
     436    ALWAYS_LOG(LOGIDENTIFIER);
     437   
    416438    ASSERT(isMainThread());
    417439    lazyInitialize();
    … …  
    429451ExceptionOr<Ref<MediaElementAudioSourceNode>> AudioContext::createMediaElementSource(HTMLMediaElement& mediaElement)
    430452{
     453    ALWAYS_LOG(LOGIDENTIFIER);
     454   
    431455    ASSERT(isMainThread());
    432456    lazyInitialize();
    … …  
    449473ExceptionOr<Ref<MediaStreamAudioSourceNode>> AudioContext::createMediaStreamSource(MediaStream& mediaStream)
    450474{
     475    ALWAYS_LOG(LOGIDENTIFIER);
     476   
    451477    ASSERT(isMainThread());
    452478
    … …  
    485511ExceptionOr<Ref<ScriptProcessorNode>> AudioContext::createScriptProcessor(size_t bufferSize, size_t numberOfInputChannels, size_t numberOfOutputChannels)
    486512{
     513    ALWAYS_LOG(LOGIDENTIFIER);
     514   
    487515    ASSERT(isMainThread());
    488516    lazyInitialize();
    … …  
    543571Ref<BiquadFilterNode> AudioContext::createBiquadFilter()
    544572{
     573    ALWAYS_LOG(LOGIDENTIFIER);
     574   
    545575    ASSERT(isMainThread());
    546576    lazyInitialize();
    … …  
    550580Ref<WaveShaperNode> AudioContext::createWaveShaper()
    551581{
     582    ALWAYS_LOG(LOGIDENTIFIER);
     583   
    552584    ASSERT(isMainThread());
    553585    lazyInitialize();
    … …  
    557589Ref<PannerNode> AudioContext::createPanner()
    558590{
     591    ALWAYS_LOG(LOGIDENTIFIER);
     592   
    559593    ASSERT(isMainThread());
    560594    lazyInitialize();
    … …  
    564598Ref<ConvolverNode> AudioContext::createConvolver()
    565599{
     600    ALWAYS_LOG(LOGIDENTIFIER);
     601   
    566602    ASSERT(isMainThread());
    567603    lazyInitialize();
    … …  
    571607Ref<DynamicsCompressorNode> AudioContext::createDynamicsCompressor()
    572608{
     609    ALWAYS_LOG(LOGIDENTIFIER);
     610   
    573611    ASSERT(isMainThread());
    574612    lazyInitialize();
    … …  
    578616Ref<AnalyserNode> AudioContext::createAnalyser()
    579617{
     618    ALWAYS_LOG(LOGIDENTIFIER);
     619   
    580620    ASSERT(isMainThread());
    581621    lazyInitialize();
    … …  
    585625Ref<GainNode> AudioContext::createGain()
    586626{
     627    ALWAYS_LOG(LOGIDENTIFIER);
     628   
    587629    ASSERT(isMainThread());
    588630    lazyInitialize();
    … …  
    592634ExceptionOr<Ref<DelayNode>> AudioContext::createDelay(double maxDelayTime)
    593635{
     636    ALWAYS_LOG(LOGIDENTIFIER);
     637   
    594638    ASSERT(isMainThread());
    595639    lazyInitialize();
    … …  
    599643ExceptionOr<Ref<ChannelSplitterNode>> AudioContext::createChannelSplitter(size_t numberOfOutputs)
    600644{
     645    ALWAYS_LOG(LOGIDENTIFIER);
     646   
    601647    ASSERT(isMainThread());
    602648    lazyInitialize();
    … …  
    609655ExceptionOr<Ref<ChannelMergerNode>> AudioContext::createChannelMerger(size_t numberOfInputs)
    610656{
     657    ALWAYS_LOG(LOGIDENTIFIER);
     658   
    611659    ASSERT(isMainThread());
    612660    lazyInitialize();
    … …  
    619667Ref<OscillatorNode> AudioContext::createOscillator()
    620668{
     669    ALWAYS_LOG(LOGIDENTIFIER);
     670   
    621671    ASSERT(isMainThread());
    622672    lazyInitialize();
    … …  
    633683ExceptionOr<Ref<PeriodicWave>> AudioContext::createPeriodicWave(Float32Array& real, Float32Array& imaginary)
    634684{
     685    ALWAYS_LOG(LOGIDENTIFIER);
     686   
    635687    ASSERT(isMainThread());
    636688    if (real.length() != imaginary.length() || (real.length() > MaxPeriodicWaveLength) || !real.length())
    … …  
    9821034{
    9831035    if (userGestureRequiredForAudioStart()) {
    984         if (!processingUserGestureForMedia() && !document()->isCapturing())
     1036        if (!processingUserGestureForMedia() && !document()->isCapturing()) {
     1037            ALWAYS_LOG(LOGIDENTIFIER, "returning false, not processing user gesture or capturing");
     1038            return false;
     1039        }
     1040        removeBehaviorRestriction(AudioContext::RequireUserGestureForAudioStartRestriction);
     1041    }
     1042
     1043    if (pageConsentRequiredForAudioStart()) {
     1044        Page* page = document()->page();
     1045        if (page && !page->canStartMedia()) {
     1046            document()->addMediaCanStartListener(*this);
     1047            ALWAYS_LOG(LOGIDENTIFIER, "returning false, page doesn't allow media to start");
     1048            return false;
     1049        }
     1050        removeBehaviorRestriction(AudioContext::RequirePageConsentForAudioStartRestriction);
     1051    }
     1052   
     1053    auto willBegin = m_mediaSession->clientWillBeginPlayback();
     1054    ALWAYS_LOG(LOGIDENTIFIER, "returning ", willBegin);
     1055   
     1056    return willBegin;
     1057}
     1058
     1059bool AudioContext::willPausePlayback()
     1060{
     1061    if (userGestureRequiredForAudioStart()) {
     1062        if (!processingUserGestureForMedia())
    9851063            return false;
    9861064        removeBehaviorRestriction(AudioContext::RequireUserGestureForAudioStartRestriction);
    … …  
    9951073        removeBehaviorRestriction(AudioContext::RequirePageConsentForAudioStartRestriction);
    9961074    }
    997 
    998     return m_mediaSession->clientWillBeginPlayback();
    999 }
    1000 
    1001 bool AudioContext::willPausePlayback()
    1002 {
    1003     if (userGestureRequiredForAudioStart()) {
    1004         if (!processingUserGestureForMedia())
    1005             return false;
    1006         removeBehaviorRestriction(AudioContext::RequireUserGestureForAudioStartRestriction);
    1007     }
    1008 
    1009     if (pageConsentRequiredForAudioStart()) {
    1010         Page* page = document()->page();
    1011         if (page && !page->canStartMedia()) {
    1012             document()->addMediaCanStartListener(*this);
    1013             return false;
    1014         }
    1015         removeBehaviorRestriction(AudioContext::RequirePageConsentForAudioStartRestriction);
    1016     }
    10171075   
    10181076    return m_mediaSession->clientWillPausePlayback();
    … …  
    10211079void AudioContext::startRendering()
    10221080{
     1081    ALWAYS_LOG(LOGIDENTIFIER);
    10231082    if (!willBeginPlayback())
    10241083        return;
    … …  
    10641123    if (!isMainThread())
    10651124        return;
    1066        
     1125
     1126    ALWAYS_LOG(LOGIDENTIFIER);
     1127   
    10671128    AudioBuffer* renderedBuffer = m_renderTarget.get();
    10681129    setState(State::Closed);
    … …  
    12091270}
    12101271
     1272#if !RELEASE_LOG_DISABLED
     1273WTFLogChannel& AudioContext::logChannel() const
     1274{
     1275    return LogMedia;
     1276}
     1277#endif
    12111278
    12121279} // namespace WebCore

  • trunk/Source/WebCore/Modules/webaudio/AudioContext.h

    r240237 r242734  
    11/*
    22 * Copyright (C) 2010 Google Inc. All rights reserved.
    3  * Copyright (C) 2016 Apple Inc. All rights reserved.
     3 * Copyright (C) 2016-2019 Apple Inc. All rights reserved.
    44 *
    55 * Redistribution and use in source and binary forms, with or without
    … …  
    3939#include <atomic>
    4040#include <wtf/HashSet.h>
     41#include <wtf/LoggerHelper.h>
    4142#include <wtf/MainThread.h>
    4243#include <wtf/RefPtr.h>
    … …  
    7778// For thread safety between the audio thread and the main thread, it has a rendering graph locking mechanism.
    7879
    79 class AudioContext : public ActiveDOMObject, public ThreadSafeRefCounted<AudioContext>, public EventTargetWithInlineData, public MediaCanStartListener, public MediaProducer, private PlatformMediaSessionClient, private VisibilityChangeClient {
     80class AudioContext
     81    : public ActiveDOMObject
     82    , public ThreadSafeRefCounted<AudioContext>
     83    , public EventTargetWithInlineData
     84    , public MediaCanStartListener
     85    , public MediaProducer
     86    , private PlatformMediaSessionClient
     87    , private VisibilityChangeClient
     88#if !RELEASE_LOG_DISABLED
     89    , private LoggerHelper
     90#endif
     91{
    8092public:
    8193    // Create an AudioContext for rendering to the audio hardware.
    … …  
    264276    void nodeWillBeginPlayback();
    265277
     278#if !RELEASE_LOG_DISABLED
     279    const Logger& logger() const final { return m_logger.get(); }
     280    const void* logIdentifier() const final { return m_logIdentifier; }
     281    WTFLogChannel& logChannel() const final;
     282    const void* nextAudioNodeLogIdentifier() { return childLogIdentifier(++m_nextAudioNodeIdentifier); }
     283    const void* nextAudioParameterLogIdentifier() { return childLogIdentifier(++m_nextAudioParameterIdentifier); }
     284#endif
     285
    266286protected:
    267287    explicit AudioContext(Document&);
    … …  
    337357    void updateAutomaticPullNodes();
    338358
     359#if !RELEASE_LOG_DISABLED
     360    const char* logClassName() const final { return "AudioContext"; }
     361
     362    Ref<Logger> m_logger;
     363    const void* m_logIdentifier;
     364    uint64_t m_nextAudioNodeIdentifier { 0 };
     365    uint64_t m_nextAudioParameterIdentifier { 0 };
     366#endif
     367
    339368    // Only accessed in the audio thread.
    340369    Vector<AudioNode*> m_finishedNodes;

  • trunk/Source/WebCore/Modules/webaudio/AudioDestinationNode.cpp

    r225470 r242734  
    4444    , m_muted(false)
    4545{
     46    setNodeType(NodeTypeDestination);
    4647    addInput(std::make_unique<AudioNodeInput>(this));
    47    
    48     setNodeType(NodeTypeDestination);
    4948}
    5049

  • trunk/Source/WebCore/Modules/webaudio/AudioNode.cpp

    r240237 r242734  
    3333#include "AudioNodeOutput.h"
    3434#include "AudioParam.h"
     35#include "Logging.h"
    3536#include <wtf/Atomics.h>
    3637#include <wtf/MainThread.h>
    … …  
    4142
    4243namespace WebCore {
     44
     45String convertEnumerationToString(AudioNode::NodeType enumerationValue)
     46{
     47    static const NeverDestroyed<String> values[] = {
     48        MAKE_STATIC_STRING_IMPL("NodeTypeUnknown"),
     49        MAKE_STATIC_STRING_IMPL("NodeTypeDestination"),
     50        MAKE_STATIC_STRING_IMPL("NodeTypeOscillator"),
     51        MAKE_STATIC_STRING_IMPL("NodeTypeAudioBufferSource"),
     52        MAKE_STATIC_STRING_IMPL("NodeTypeMediaElementAudioSource"),
     53        MAKE_STATIC_STRING_IMPL("NodeTypeMediaStreamAudioDestination"),
     54        MAKE_STATIC_STRING_IMPL("NodeTypeMediaStreamAudioSource"),
     55        MAKE_STATIC_STRING_IMPL("NodeTypeJavaScript"),
     56        MAKE_STATIC_STRING_IMPL("NodeTypeBiquadFilter"),
     57        MAKE_STATIC_STRING_IMPL("NodeTypePanner"),
     58        MAKE_STATIC_STRING_IMPL("NodeTypeConvolver"),
     59        MAKE_STATIC_STRING_IMPL("NodeTypeDelay"),
     60        MAKE_STATIC_STRING_IMPL("NodeTypeGain"),
     61        MAKE_STATIC_STRING_IMPL("NodeTypeChannelSplitter"),
     62        MAKE_STATIC_STRING_IMPL("NodeTypeChannelMerger"),
     63        MAKE_STATIC_STRING_IMPL("NodeTypeAnalyser"),
     64        MAKE_STATIC_STRING_IMPL("NodeTypeDynamicsCompressor"),
     65        MAKE_STATIC_STRING_IMPL("NodeTypeWaveShaper"),
     66        MAKE_STATIC_STRING_IMPL("NodeTypeBasicInspector"),
     67        MAKE_STATIC_STRING_IMPL("NodeTypeEnd"),
     68    };
     69    static_assert(static_cast<size_t>(AudioNode::NodeTypeUnknown) == 0, "AudioNode::NodeTypeUnknown is not 0 as expected");
     70    static_assert(static_cast<size_t>(AudioNode::NodeTypeDestination) == 1, "AudioNode::NodeTypeDestination is not 1 as expected");
     71    static_assert(static_cast<size_t>(AudioNode::NodeTypeOscillator) == 2, "AudioNode::NodeTypeOscillator is not 2 as expected");
     72    static_assert(static_cast<size_t>(AudioNode::NodeTypeAudioBufferSource) == 3, "AudioNode::NodeTypeAudioBufferSource is not 3 as expected");
     73    static_assert(static_cast<size_t>(AudioNode::NodeTypeMediaElementAudioSource) == 4, "AudioNode::NodeTypeMediaElementAudioSource is not 4 as expected");
     74    static_assert(static_cast<size_t>(AudioNode::NodeTypeMediaStreamAudioDestination) == 5, "AudioNode::NodeTypeMediaStreamAudioDestination is not 5 as expected");
     75    static_assert(static_cast<size_t>(AudioNode::NodeTypeMediaStreamAudioSource) == 6, "AudioNode::NodeTypeMediaStreamAudioSource is not 6 as expected");
     76    static_assert(static_cast<size_t>(AudioNode::NodeTypeJavaScript) == 7, "AudioNode::NodeTypeJavaScript is not 7 as expected");
     77    static_assert(static_cast<size_t>(AudioNode::NodeTypeBiquadFilter) == 8, "AudioNode::NodeTypeBiquadFilter is not 8 as expected");
     78    static_assert(static_cast<size_t>(AudioNode::NodeTypePanner) == 9, "AudioNode::NodeTypePanner is not 9 as expected");
     79    static_assert(static_cast<size_t>(AudioNode::NodeTypeConvolver) == 10, "AudioNode::NodeTypeConvolver is not 10 as expected");
     80    static_assert(static_cast<size_t>(AudioNode::NodeTypeDelay) == 11, "AudioNode::NodeTypeDelay is not 11 as expected");
     81    static_assert(static_cast<size_t>(AudioNode::NodeTypeGain) == 12, "AudioNode::NodeTypeGain is not 12 as expected");
     82    static_assert(static_cast<size_t>(AudioNode::NodeTypeChannelSplitter) == 13, "AudioNode::NodeTypeChannelSplitter is not 13 as expected");
     83    static_assert(static_cast<size_t>(AudioNode::NodeTypeChannelMerger) == 14, "AudioNode::NodeTypeChannelMerger is not 14 as expected");
     84    static_assert(static_cast<size_t>(AudioNode::NodeTypeAnalyser) == 15, "AudioNode::NodeTypeAnalyser is not 15 as expected");
     85    static_assert(static_cast<size_t>(AudioNode::NodeTypeDynamicsCompressor) == 16, "AudioNode::NodeTypeDynamicsCompressor is not 16 as expected");
     86    static_assert(static_cast<size_t>(AudioNode::NodeTypeWaveShaper) == 17, "AudioNode::NodeTypeWaveShaper is not 17 as expected");
     87    static_assert(static_cast<size_t>(AudioNode::NodeTypeBasicInspector) == 18, "AudioNode::NodeTypeBasicInspector is not 18 as expected");
     88    static_assert(static_cast<size_t>(AudioNode::NodeTypeEnd) == 19, "AudioNode::NodeTypeEnd is not 19 as expected");
     89
     90    ASSERT(static_cast<size_t>(enumerationValue) < WTF_ARRAY_LENGTH(values));
     91   
     92    return values[static_cast<size_t>(enumerationValue)];
     93}
    4394
    4495AudioNode::AudioNode(AudioContext& context, float sampleRate)
    … …  
    53104    , m_isMarkedForDeletion(false)
    54105    , m_isDisabled(false)
     106#if !RELEASE_LOG_DISABLED
     107    , m_logger(context.logger())
     108    , m_logIdentifier(context.nextAudioNodeLogIdentifier())
     109#endif
    55110    , m_channelCount(2)
    56111    , m_channelCountMode(Max)
    57112    , m_channelInterpretation(AudioBus::Speakers)
    58113{
     114    ALWAYS_LOG(LOGIDENTIFIER);
     115   
    59116#if DEBUG_AUDIONODE_REFERENCES
    60117    if (!s_isNodeCountInitialized) {
    … …  
    67124AudioNode::~AudioNode()
    68125{
     126    ALWAYS_LOG(LOGIDENTIFIER);
     127
    69128    ASSERT(isMainThread());
    70129#if DEBUG_AUDIONODE_REFERENCES
    … …  
    86145void AudioNode::setNodeType(NodeType type)
    87146{
     147    ASSERT(isMainThread());
     148    ALWAYS_LOG(LOGIDENTIFIER, type);
     149
    88150    m_nodeType = type;
    89151
    … …  
    101163void AudioNode::addInput(std::unique_ptr<AudioNodeInput> input)
    102164{
     165    ASSERT(isMainThread());
     166    DEBUG_LOG(LOGIDENTIFIER, input->node()->nodeType());
    103167    m_inputs.append(WTFMove(input));
    104168}
    … …  
    106170void AudioNode::addOutput(std::unique_ptr<AudioNodeOutput> output)
    107171{
     172    ASSERT(isMainThread());
     173    DEBUG_LOG(LOGIDENTIFIER, output->node()->nodeType());
    108174    m_outputs.append(WTFMove(output));
    109175}
    … …  
    125191ExceptionOr<void> AudioNode::connect(AudioNode& destination, unsigned outputIndex, unsigned inputIndex)
    126192{
    127     ASSERT(isMainThread()); 
     193    ASSERT(isMainThread());
    128194    AudioContext::AutoLocker locker(context());
    129195
     196    ALWAYS_LOG(LOGIDENTIFIER, destination.nodeType(), ", output = ", outputIndex, ", input = ", inputIndex);
     197   
    130198    // Sanity check input and output indices.
    131199    if (outputIndex >= numberOfOutputs())
    … …  
    150218ExceptionOr<void> AudioNode::connect(AudioParam& param, unsigned outputIndex)
    151219{
    152     ASSERT(isMainThread());
    153220    AudioContext::AutoLocker locker(context());
     221
     222    ASSERT(isMainThread());
     223
     224    DEBUG_LOG(LOGIDENTIFIER, param.name(), ", output = ", outputIndex);
    154225
    155226    if (outputIndex >= numberOfOutputs())
    … …  
    175246
    176247    auto* output = this->output(outputIndex);
     248    DEBUG_LOG(LOGIDENTIFIER, output->node()->nodeType());
     249
    177250    output->disconnectAll();
    178251
    … …  
    190263    AudioContext::AutoLocker locker(context());
    191264
     265    ALWAYS_LOG(LOGIDENTIFIER, channelCount);
     266   
    192267    if (!(channelCount > 0 && channelCount <= AudioContext::maxNumberOfChannels()))
    193268        return Exception { InvalidStateError };
    … …  
    221296    AudioContext::AutoLocker locker(context());
    222297
     298    ALWAYS_LOG(LOGIDENTIFIER, mode);
     299   
    223300    ChannelCountMode oldMode = m_channelCountMode;
    224301
    … …  
    255332    AudioContext::AutoLocker locker(context());
    256333
     334    ALWAYS_LOG(LOGIDENTIFIER, interpretation);
     335   
    257336    if (interpretation == "speakers")
    258337        m_channelInterpretation = AudioBus::Speakers;
    … …  
    506585#endif // DEBUG_AUDIONODE_REFERENCES
    507586
     587#if !RELEASE_LOG_DISABLED
     588WTFLogChannel& AudioNode::logChannel() const
     589{
     590    return LogMedia;
     591}
     592#endif
     593
    508594} // namespace WebCore
    509595

  • trunk/Source/WebCore/Modules/webaudio/AudioNode.h

    r236831 r242734  
    2929#include "ExceptionOr.h"
    3030#include <wtf/Forward.h>
     31#include <wtf/LoggerHelper.h>
    3132
    3233#define DEBUG_AUDIONODE_REFERENCES 0
    … …  
    4546// Most processing nodes such as filters will have one input and one output, although multiple inputs and outputs are possible.
    4647
    47 class AudioNode : public EventTargetWithInlineData {
     48class AudioNode
     49    : public EventTargetWithInlineData
     50#if !RELEASE_LOG_DISABLED
     51    , private LoggerHelper
     52#endif
     53{
    4854    WTF_MAKE_NONCOPYABLE(AudioNode);
    4955    WTF_MAKE_FAST_ALLOCATED;
    … …  
    7682        NodeTypeDynamicsCompressor,
    7783        NodeTypeWaveShaper,
     84        NodeTypeBasicInspector,
    7885        NodeTypeEnd
    7986    };
    … …  
    192199    void updateChannelsForInputs();
    193200
     201#if !RELEASE_LOG_DISABLED
     202    const Logger& logger() const final { return m_logger.get(); }
     203    const void* logIdentifier() const final { return m_logIdentifier; }
     204    const char* logClassName() const final { return "AudioNode"; }
     205    WTFLogChannel& logChannel() const final;
     206#endif
     207
    194208private:
    195209    volatile bool m_isInitialized;
    … …  
    218232    void derefEventTarget() override { deref(); }
    219233
     234#if !RELEASE_LOG_DISABLED
     235    mutable Ref<const Logger> m_logger;
     236    const void* m_logIdentifier;
     237#endif
     238
    220239protected:
    221240    unsigned m_channelCount;
    … …  
    224243};
    225244
     245String convertEnumerationToString(AudioNode::NodeType);
     246
    226247} // namespace WebCore
     248
     249namespace WTF {
     250   
     251template<> struct LogArgument<WebCore::AudioNode::NodeType> {
     252    static String toString(WebCore::AudioNode::NodeType type) { return convertEnumerationToString(type); }
     253};
     254
     255} // namespace WTF

  • trunk/Source/WebCore/Modules/webaudio/AudioParam.cpp

    r239535 r242734  
    3434#include "AudioUtilities.h"
    3535#include "FloatConversion.h"
     36#include "Logging.h"
    3637#include <wtf/MathExtras.h>
    3738
    … …  
    4041const double AudioParam::DefaultSmoothingConstant = 0.05;
    4142const double AudioParam::SnapThreshold = 0.001;
     43
     44AudioParam::AudioParam(AudioContext& context, const String& name, double defaultValue, double minValue, double maxValue, unsigned units)
     45    : AudioSummingJunction(context)
     46    , m_name(name)
     47    , m_value(defaultValue)
     48    , m_defaultValue(defaultValue)
     49    , m_minValue(minValue)
     50    , m_maxValue(maxValue)
     51    , m_units(units)
     52    , m_smoothedValue(defaultValue)
     53    , m_smoothingConstant(DefaultSmoothingConstant)
     54#if !RELEASE_LOG_DISABLED
     55    , m_logger(context.logger())
     56    , m_logIdentifier(context.nextAudioParameterLogIdentifier())
     57#endif
     58{
     59    ALWAYS_LOG(LOGIDENTIFIER, "name = ", m_name, ", value = ", m_value, ", default = ", m_defaultValue, ", min = ", m_minValue, ", max = ", m_maxValue, ", units = ", m_units);
     60}
    4261
    4362float AudioParam::value()
    … …  
    5776void AudioParam::setValue(float value)
    5877{
     78    DEBUG_LOG(LOGIDENTIFIER, value);
     79
    5980    // Check against JavaScript giving us bogus floating-point values.
    6081    // Don't ASSERT, since this can happen if somebody writes bad JS.
    … …  
    174195        return;
    175196
     197    DEBUG_LOG(LOGIDENTIFIER, output->node()->nodeType());
     198
    176199    output->addParam(this);
    177200    changedOutputs();
    … …  
    185208    if (!output)
    186209        return;
     210
     211    DEBUG_LOG(LOGIDENTIFIER, output->node()->nodeType());
    187212
    188213    if (m_outputs.remove(output)) {
    … …  
    192217}
    193218
     219#if !RELEASE_LOG_DISABLED
     220WTFLogChannel& AudioParam::logChannel() const
     221{
     222    return LogMedia;
     223}
     224#endif
     225   
     226
    194227} // namespace WebCore
    195228

  • trunk/Source/WebCore/Modules/webaudio/AudioParam.h

    r233650 r242734  
    3434#include <JavaScriptCore/Float32Array.h>
    3535#include <sys/types.h>
     36#include <wtf/LoggerHelper.h>
    3637#include <wtf/RefCounted.h>
    3738#include <wtf/text/WTFString.h>
    … …  
    4142class AudioNodeOutput;
    4243
    43 class AudioParam final : public AudioSummingJunction, public RefCounted<AudioParam> {
     44class AudioParam final
     45    : public AudioSummingJunction
     46    , public RefCounted<AudioParam>
     47#if !RELEASE_LOG_DISABLED
     48    , private LoggerHelper
     49#endif
     50{
    4451public:
    4552    static const double DefaultSmoothingConstant;
    … …  
    102109
    103110protected:
    104     AudioParam(AudioContext& context, const String& name, double defaultValue, double minValue, double maxValue, unsigned units = 0)
    105         : AudioSummingJunction(context)
    106         , m_name(name)
    107         , m_value(defaultValue)
    108         , m_defaultValue(defaultValue)
    109         , m_minValue(minValue)
    110         , m_maxValue(maxValue)
    111         , m_units(units)
    112         , m_smoothedValue(defaultValue)
    113         , m_smoothingConstant(DefaultSmoothingConstant)
    114     {
    115     }
     111    AudioParam(AudioContext&, const String&, double defaultValue, double minValue, double maxValue, unsigned units = 0);
    116112
    117113private:
    … …  
    120116    void calculateTimelineValues(float* values, unsigned numberOfValues);
    121117
     118#if !RELEASE_LOG_DISABLED
     119    const Logger& logger() const final { return m_logger.get(); }
     120    const void* logIdentifier() const final { return m_logIdentifier; }
     121    const char* logClassName() const final { return "AudioParam"; }
     122    WTFLogChannel& logChannel() const final;
     123#endif
     124   
    122125    String m_name;
    123126    double m_value;
    … …  
    132135   
    133136    AudioParamTimeline m_timeline;
     137
     138#if !RELEASE_LOG_DISABLED
     139    mutable Ref<const Logger> m_logger;
     140    const void* m_logIdentifier;
     141#endif
    134142};
    135143

  • trunk/Source/WebCore/Modules/webaudio/AudioScheduledSourceNode.cpp

    r238291 r242734  
    133133{
    134134    ASSERT(isMainThread());
     135    ALWAYS_LOG(LOGIDENTIFIER, when);
    135136
    136137    context().nodeWillBeginPlayback();
    … …  
    150151{
    151152    ASSERT(isMainThread());
     153    ALWAYS_LOG(LOGIDENTIFIER, when);
    152154
    153155    if (m_playbackState == UNSCHEDULED_STATE || m_endTime != UnknownTime)

  • trunk/Source/WebCore/Modules/webaudio/BiquadFilterNode.cpp

    r208688 r242734  
    3434    : AudioBasicProcessorNode(context, sampleRate)
    3535{
     36    setNodeType(NodeTypeBiquadFilter);
     37
    3638    // Initially setup as lowpass filter.
    3739    m_processor = std::make_unique<BiquadProcessor>(context, sampleRate, 1, false);
    38     setNodeType(NodeTypeBiquadFilter);
    3940}
    4041

  • trunk/Source/WebCore/Modules/webaudio/ChannelMergerNode.cpp

    r196603 r242734  
    5353    , m_desiredNumberOfOutputChannels(DefaultNumberOfOutputChannels)
    5454{
     55    setNodeType(NodeTypeChannelMerger);
     56
    5557    // Create the requested number of inputs.
    5658    for (unsigned i = 0; i < numberOfInputs; ++i)
    … …  
    5860
    5961    addOutput(std::make_unique<AudioNodeOutput>(this, 1));
    60    
    61     setNodeType(NodeTypeChannelMerger);
    6262   
    6363    initialize();

  • trunk/Source/WebCore/Modules/webaudio/ChannelSplitterNode.cpp

    r196603 r242734  
    4646    : AudioNode(context, sampleRate)
    4747{
     48    setNodeType(NodeTypeChannelSplitter);
     49
    4850    addInput(std::make_unique<AudioNodeInput>(this));
    4951
    … …  
    5153    for (unsigned i = 0; i < numberOfOutputs; ++i)
    5254        addOutput(std::make_unique<AudioNodeOutput>(this, 1));
    53    
    54     setNodeType(NodeTypeChannelSplitter);
    5555   
    5656    initialize();

  • trunk/Source/WebCore/Modules/webaudio/ConvolverNode.cpp

    r219856 r242734  
    4848    : AudioNode(context, sampleRate)
    4949{
     50    setNodeType(NodeTypeConvolver);
     51
    5052    addInput(std::make_unique<AudioNodeInput>(this));
    5153    addOutput(std::make_unique<AudioNodeOutput>(this, 2));
    … …  
    5557    m_channelCountMode = ClampedMax;
    5658    m_channelInterpretation = AudioBus::Speakers;
    57 
    58     setNodeType(NodeTypeConvolver);
    5959   
    6060    initialize();

  • trunk/Source/WebCore/Modules/webaudio/DefaultAudioDestinationNode.cpp

    r240143 r242734  
    5858    if (isInitialized())
    5959        return;
     60    ALWAYS_LOG(LOGIDENTIFIER);
    6061
    6162    createDestination();
    … …  
    6970        return;
    7071
     72    ALWAYS_LOG(LOGIDENTIFIER);
    7173    m_destination->stop();
    7274    m_destination = nullptr;
    … …  
    8688void DefaultAudioDestinationNode::enableInput(const String& inputDeviceId)
    8789{
     90    ALWAYS_LOG(LOGIDENTIFIER);
     91
    8892    ASSERT(isMainThread());
    8993    if (m_numberOfInputChannels != EnabledInputChannels) {
    … …  
    145149
    146150    ASSERT(isMainThread());
     151    ALWAYS_LOG(LOGIDENTIFIER, channelCount);
    147152
    148153    if (!maxChannelCount() || channelCount > maxChannelCount())

  • trunk/Source/WebCore/Modules/webaudio/DelayNode.cpp

    r219856 r242734  
    3838    : AudioBasicProcessorNode(context, sampleRate)
    3939{
     40    setNodeType(NodeTypeDelay);
    4041    m_processor = std::make_unique<DelayProcessor>(context, sampleRate, 1, maxDelayTime);
    41     setNodeType(NodeTypeDelay);
    4242}
    4343

  • trunk/Source/WebCore/Modules/webaudio/DynamicsCompressorNode.cpp

    r196603 r242734  
    4242    : AudioNode(context, sampleRate)
    4343{
     44    setNodeType(NodeTypeDynamicsCompressor);
     45
    4446    addInput(std::make_unique<AudioNodeInput>(this));
    4547    addOutput(std::make_unique<AudioNodeOutput>(this, defaultNumberOfOutputChannels));
    46 
    47     setNodeType(NodeTypeDynamicsCompressor);
    4848
    4949    m_threshold = AudioParam::create(context, "threshold", -24, -100, 0);

  • trunk/Source/WebCore/Modules/webaudio/GainNode.cpp

    r214505 r242734  
    4040    , m_sampleAccurateGainValues(AudioNode::ProcessingSizeInFrames) // FIXME: can probably share temp buffer in context
    4141{
     42    setNodeType(NodeTypeGain);
     43
    4244    m_gain = AudioParam::create(context, "gain", 1.0, 0.0, 1.0);
    4345
    4446    addInput(std::make_unique<AudioNodeInput>(this));
    4547    addOutput(std::make_unique<AudioNodeOutput>(this, 1));
    46 
    47     setNodeType(NodeTypeGain);
    4848
    4949    initialize();

  • trunk/Source/WebCore/Modules/webaudio/MediaElementAudioSourceNode.cpp

    r234055 r242734  
    5252    , m_sourceSampleRate(0)
    5353{
     54    setNodeType(NodeTypeMediaElementAudioSource);
     55
    5456    // Default to stereo. This could change depending on what the media element .src is set to.
    5557    addOutput(std::make_unique<AudioNodeOutput>(this, 2));
    56 
    57     setNodeType(NodeTypeMediaElementAudioSource);
    5858
    5959    initialize();

  • trunk/Source/WebCore/Modules/webaudio/MediaStreamAudioSourceNode.cpp

    r213080 r242734  
    4646    , m_audioTrack(audioTrack)
    4747{
     48    setNodeType(NodeTypeMediaStreamAudioSource);
     49   
    4850    AudioSourceProvider* audioSourceProvider = m_audioTrack->audioSourceProvider();
    4951    ASSERT(audioSourceProvider);
    … …  
    5355    // Default to stereo. This could change depending on the format of the MediaStream's audio track.
    5456    addOutput(std::make_unique<AudioNodeOutput>(this, 2));
    55 
    56     setNodeType(NodeTypeMediaStreamAudioSource);
    5757
    5858    initialize();

  • trunk/Source/WebCore/Modules/webaudio/OfflineAudioDestinationNode.cpp

    r218816 r242734  
    7575void OfflineAudioDestinationNode::startRendering()
    7676{
     77    ALWAYS_LOG(LOGIDENTIFIER);
     78
    7779    ASSERT(isMainThread());
    7880    ASSERT(m_renderTarget.get());

  • trunk/Source/WebCore/Modules/webaudio/OscillatorNode.cpp

    r238291 r242734  
    7979{
    8080    PeriodicWave* periodicWave = nullptr;
     81
     82    ALWAYS_LOG(LOGIDENTIFIER, type);
    8183
    8284    switch (type) {
    … …  
    298300void OscillatorNode::setPeriodicWave(PeriodicWave* periodicWave)
    299301{
     302    ALWAYS_LOG(LOGIDENTIFIER, "sample rate = ", periodicWave ? periodicWave->sampleRate() : 0, ", wave size = ", periodicWave ? periodicWave->periodicWaveSize() : 0, ", rate scale = ", periodicWave ? periodicWave->rateScale() : 0);
    300303    ASSERT(isMainThread());
    301 
     304   
    302305    // This synchronizes with process().
    303306    std::lock_guard<Lock> lock(m_processMutex);

  • trunk/Source/WebCore/Modules/webaudio/OscillatorNode.h

    r207050 r242734  
    102102};
    103103
     104String convertEnumerationToString(OscillatorNode::Type); // In JSOscillatorNode.cpp
     105
    104106} // namespace WebCore
     107
     108namespace WTF {
     109
     110template<> struct LogArgument<WebCore::OscillatorNode::Type> {
     111    static String toString(WebCore::OscillatorNode::Type type) { return convertEnumerationToString(type); }
     112};
     113
     114} // namespace WTF

  • trunk/Source/WebCore/Modules/webaudio/PannerNode.cpp

    r208688 r242734  
    5151    , m_connectionCount(0)
    5252{
     53    setNodeType(NodeTypePanner);
     54   
    5355    // Load the HRTF database asynchronously so we don't block the Javascript thread while creating the HRTF database.
    5456    m_hrtfDatabaseLoader = HRTFDatabaseLoader::createAndLoadAsynchronouslyIfNecessary(context.sampleRate());
    … …  
    6870    m_orientation = FloatPoint3D(1, 0, 0);
    6971    m_velocity = FloatPoint3D(0, 0, 0);
    70 
    71     setNodeType(NodeTypePanner);
    7272
    7373    initialize();

  • trunk/Source/WebCore/Modules/webaudio/ScriptProcessorNode.cpp

    r239535 r242734  
    6565    ASSERT(numberOfInputChannels <= AudioContext::maxNumberOfChannels());
    6666
     67    setNodeType(NodeTypeJavaScript);
    6768    addInput(std::make_unique<AudioNodeInput>(this));
    6869    addOutput(std::make_unique<AudioNodeOutput>(this, numberOfOutputChannels));
    69 
    70     setNodeType(NodeTypeJavaScript);
    7170
    7271    initialize();

  • trunk/Source/WebCore/Modules/webaudio/WaveShaperNode.cpp

    r209153 r242734  
    3333namespace WebCore {
    3434
     35
    3536WaveShaperNode::WaveShaperNode(AudioContext& context)
    3637    : AudioBasicProcessorNode(context, context.sampleRate())
    3738{
     39    setNodeType(NodeTypeWaveShaper);
    3840    m_processor = std::make_unique<WaveShaperProcessor>(context.sampleRate(), 1);
    39     setNodeType(NodeTypeWaveShaper);
    4041
    4142    initialize();
    … …  
    4546{
    4647    ASSERT(isMainThread());
     48    DEBUG_LOG(LOGIDENTIFIER);
    4749    waveShaperProcessor()->setCurve(&curve);
    4850}
    … …  
    7072{
    7173    ASSERT(isMainThread());
     74    DEBUG_LOG(LOGIDENTIFIER, type);
    7275
    7376    // Synchronize with any graph changes or changes to channel configuration.

  • trunk/Source/WebCore/Modules/webaudio/WaveShaperNode.h

    r209153 r242734  
    5454};
    5555
     56String convertEnumerationToString(WebCore::WaveShaperNode::OverSampleType); // in JSWaveShaperNode.cpp
     57
    5658} // namespace WebCore
     59
     60namespace WTF {
     61   
     62template<> struct LogArgument<WebCore::WaveShaperNode::OverSampleType> {
     63    static String toString(WebCore::WaveShaperNode::OverSampleType type) { return convertEnumerationToString(type); }
     64};
     65   
     66} // namespace WTF
Note: See TracChangeset for help on using the changeset viewer.