Implement ConstantSourceNode

third_party/WebKit/Source/modules/webaudio/ConstantSourceNode.cpp

+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "modules/webaudio/ConstantSourceNode.h"
+
+#include "bindings/core/v8/ExceptionMessages.h"
+#include "bindings/core/v8/ExceptionState.h"
+#include "core/dom/ExceptionCode.h"
+#include "modules/webaudio/AudioNodeOutput.h"
+#include "modules/webaudio/ConstantSourceOptions.h"
+#include "platform/audio/AudioUtilities.h"
+#include "wtf/MathExtras.h"
+#include "wtf/StdLibExtras.h"
+#include <algorithm>
+
+namespace blink {
+
+ConstantSourceHandler::ConstantSourceHandler(
+    AudioNode& node,
+    float sampleRate,
+    AudioParamHandler& offset)
+    : AudioScheduledSourceHandler(NodeTypeConstantSource, node, sampleRate)
+    , m_offset(offset)
+    , m_sampleAccurateValues(ProcessingSizeInFrames)
+{
+    // A ConstantSource is always mono.
+    addOutput(1);
+
+    initialize();
+}
+
+PassRefPtr<ConstantSourceHandler> ConstantSourceHandler::create(
+    AudioNode& node,
+    float sampleRate,
+    AudioParamHandler& offset)
+{
+    return adoptRef(new ConstantSourceHandler(node, sampleRate, offset));
+}
+
+ConstantSourceHandler::~ConstantSourceHandler()
+{
+    uninitialize();
+}
+
+void ConstantSourceHandler::process(size_t framesToProcess)
+{
+    AudioBus* outputBus = output(0).bus();
+    DCHECK(outputBus);
+
+    if (!isInitialized() || !outputBus->numberOfChannels()) {
+        outputBus->zero();
+        return;
+    }
+
+    // The audio thread can't block on this lock, so we call tryLock() instead.
+    MutexTryLocker tryLocker(m_processLock);
+    if (!tryLocker.locked()) {
+        // Too bad - the tryLock() failed.
+        outputBus->zero();
+        return;
+    }
+
+    size_t quantumFrameOffset;
+    size_t nonSilentFramesToProcess;
+
+    // Figure out where in the current rendering quantum that the source is
+    // active and for how many frames.
+    updateSchedulingInfo(framesToProcess, outputBus, quantumFrameOffset, nonSilentFramesToProcess);
+
+    if (!nonSilentFramesToProcess) {
+        outputBus->zero();
+        return;
+    }
+
+    if (m_offset->hasSampleAccurateValues()) {
+        DCHECK_LE(framesToProcess, m_sampleAccurateValues.size());
+        if (framesToProcess <= m_sampleAccurateValues.size()) {
+            float* offsets = m_sampleAccurateValues.data();
+            m_offset->calculateSampleAccurateValues(offsets, framesToProcess);
+            if (nonSilentFramesToProcess > 0) {
+                memcpy(
+                    outputBus->channel(0)->mutableData() + quantumFrameOffset,
+                    offsets + quantumFrameOffset,
+                    nonSilentFramesToProcess * sizeof(*offsets));
+                outputBus->clearSilentFlag();
+            } else {
+                outputBus->zero();
+            }
+        }
+    } else {
+        float value = m_offset->value();
+
+        if (value == 0) {
+            outputBus->zero();
+        } else {
+            float* dest = outputBus->channel(0)->mutableData();
+            dest += quantumFrameOffset;
+            for (unsigned k = 0; k < nonSilentFramesToProcess; ++k) {
+                dest[k] = value;
+            }
+            outputBus->clearSilentFlag();
+        }
+    }
+}
+
+bool ConstantSourceHandler::propagatesSilence() const
+{
+    return !isPlayingOrScheduled() || hasFinished();
+}
+
+// ----------------------------------------------------------------
+ConstantSourceNode::ConstantSourceNode(BaseAudioContext& context)
+    : AudioScheduledSourceNode(context)
+    , m_offset(AudioParam::create(context, ParamTypeConstantSourceValue, 1))
+{
+    setHandler(
+        ConstantSourceHandler::create(
+            *this,
+            context.sampleRate(),
+            m_offset->handler()));
+}
+
+ConstantSourceNode* ConstantSourceNode::create(
+    BaseAudioContext& context,
+    ExceptionState& exceptionState)
+{
+    DCHECK(isMainThread());
+
+    if (context.isContextClosed()) {
+        context.throwExceptionForClosedState(exceptionState);
+        return nullptr;
+    }
+
+    return new ConstantSourceNode(context);
+}
+
+ConstantSourceNode* ConstantSourceNode::create(
+    BaseAudioContext* context,
+    const ConstantSourceOptions& options,
+    ExceptionState& exceptionState)
+{
+    DCHECK(isMainThread());
+
+    ConstantSourceNode* node = create(*context, exceptionState);
+
+    if (!node)
+        return nullptr;
+
+    node->offset()->setValue(options.offset());
+
+    return node;
+}
+
+DEFINE_TRACE(ConstantSourceNode)
+{
+    visitor->trace(m_offset);
+    AudioScheduledSourceNode::trace(visitor);
+}
+
+ConstantSourceHandler& ConstantSourceNode::constantSourceHandler() const
+{
+    return static_cast<ConstantSourceHandler&>(handler());
+}
+
+AudioParam* ConstantSourceNode::offset()
+{
+    return m_offset;
+}
+
+} // namespace blink