third_party/blink/renderer/modules/webaudio/script_processor_node.cc - chromium/src - Git at Google

 /*
  * Copyright (C) 2010, Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1.  Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
  * DAMAGE.
  */

 #include "third_party/blink/renderer/modules/webaudio/script_processor_node.h"

 #include <memory>

 #include "third_party/blink/public/platform/platform.h"
 #include "third_party/blink/public/platform/task_type.h"
 #include "third_party/blink/renderer/core/execution_context/execution_context.h"
 #include "third_party/blink/renderer/core/frame/local_dom_window.h"
 #include "third_party/blink/renderer/core/inspector/console_message.h"
 #include "third_party/blink/renderer/modules/webaudio/audio_buffer.h"
 #include "third_party/blink/renderer/modules/webaudio/audio_node_input.h"
 #include "third_party/blink/renderer/modules/webaudio/audio_node_output.h"
 #include "third_party/blink/renderer/modules/webaudio/audio_processing_event.h"
 #include "third_party/blink/renderer/modules/webaudio/base_audio_context.h"
 #include "third_party/blink/renderer/modules/webaudio/realtime_audio_destination_node.h"
 #include "third_party/blink/renderer/platform/bindings/exception_state.h"
 #include "third_party/blink/renderer/platform/scheduler/public/post_cross_thread_task.h"
 #include "third_party/blink/renderer/platform/wtf/cross_thread_functional.h"

 namespace blink {

 namespace {

 bool IsAudioBufferDetached(AudioBuffer* buffer) {
   bool is_buffer_detached = false;
   for (unsigned channel = 0; channel < buffer->numberOfChannels(); ++channel) {
     if (buffer->getChannelData(channel)->buffer()->IsDetached()) {
       is_buffer_detached = true;
       break;
     }
   }

   return is_buffer_detached;
 }

 bool BufferTopologyMatches(AudioBuffer* buffer_1, AudioBuffer* buffer_2) {
   return (buffer_1->numberOfChannels() == buffer_2->numberOfChannels()) &&
          (buffer_1->length() == buffer_2->length()) &&
          (buffer_1->sampleRate() == buffer_2->sampleRate());
 }

 }  // namespace

 ScriptProcessorHandler::ScriptProcessorHandler(
     AudioNode& node,
     float sample_rate,
     uint32_t buffer_size,
     uint32_t number_of_input_channels,
     uint32_t number_of_output_channels,
     const HeapVector<Member<AudioBuffer>>& input_buffers,
     const HeapVector<Member<AudioBuffer>>& output_buffers)
     : AudioHandler(kNodeTypeScriptProcessor, node, sample_rate),
       double_buffer_index_(0),
       buffer_size_(buffer_size),
       buffer_read_write_index_(0),
       number_of_input_channels_(number_of_input_channels),
       number_of_output_channels_(number_of_output_channels),
       internal_input_bus_(
           AudioBus::Create(number_of_input_channels,
                            audio_utilities::kRenderQuantumFrames,
                            false)) {
   DCHECK_GE(buffer_size_, audio_utilities::kRenderQuantumFrames);
   DCHECK_LE(number_of_input_channels, BaseAudioContext::MaxNumberOfChannels());

   AddInput();
   AddOutput(number_of_output_channels);

   channel_count_ = number_of_input_channels;
   SetInternalChannelCountMode(kExplicit);

   if (Context()->GetExecutionContext()) {
     task_runner_ = Context()->GetExecutionContext()->GetTaskRunner(
         TaskType::kMediaElementEvent);
   }

   for (uint32_t i = 0; i < 2; ++i) {
     shared_input_buffers_.push_back(
         input_buffers[i] ? input_buffers[i]->CreateSharedAudioBuffer()
                          : nullptr);
     shared_output_buffers_.push_back(
         output_buffers[i] ? output_buffers[i]->CreateSharedAudioBuffer()
                           : nullptr);
   }

   Initialize();

   LocalDOMWindow* window = To<LocalDOMWindow>(Context()->GetExecutionContext());
   if (window) {
     window->AddConsoleMessage(MakeGarbageCollected<ConsoleMessage>(
           mojom::blink::ConsoleMessageSource::kDeprecation,
           mojom::blink::ConsoleMessageLevel::kWarning,
           "The ScriptProcessorNode is deprecated. Use AudioWorkletNode instead."
           " (https://bit.ly/audio-worklet)"));
   }
 }

 scoped_refptr<ScriptProcessorHandler> ScriptProcessorHandler::Create(
     AudioNode& node,
     float sample_rate,
     uint32_t buffer_size,
     uint32_t number_of_input_channels,
     uint32_t number_of_output_channels,
     const HeapVector<Member<AudioBuffer>>& input_buffers,
     const HeapVector<Member<AudioBuffer>>& output_buffers) {
   return base::AdoptRef(new ScriptProcessorHandler(
       node, sample_rate, buffer_size, number_of_input_channels,
       number_of_output_channels, input_buffers, output_buffers));
 }

 ScriptProcessorHandler::~ScriptProcessorHandler() {
   Uninitialize();
 }

 void ScriptProcessorHandler::Initialize() {
   if (IsInitialized())
     return;
   AudioHandler::Initialize();
 }

 void ScriptProcessorHandler::Process(uint32_t frames_to_process) {
   // The main thread might be accessing the shared buffers. If so, silience
   // the output and return.
   MutexTryLocker try_locker(process_event_lock_);
   if (!try_locker.Locked()) {
     Output(0).Bus()->Zero();
     return;
   }

   // Discussion about inputs and outputs:
   // As in other AudioNodes, ScriptProcessorNode uses an AudioBus for its input
   // and output (see inputBus and outputBus below).  Additionally, there is a
   // double-buffering for input and output which is exposed directly to
   // JavaScript (see inputBuffer and outputBuffer below).  This node is the
   // producer for inputBuffer and the consumer for outputBuffer.  The JavaScript
   // code is the consumer of inputBuffer and the producer for outputBuffer.

   // Get input and output busses.
   scoped_refptr<AudioBus> input_bus = Input(0).Bus();
   AudioBus* output_bus = Output(0).Bus();

   // Get input and output buffers. We double-buffer both the input and output
   // sides.
   uint32_t double_buffer_index = this->DoubleBufferIndex();
   DCHECK_LT(double_buffer_index, 2u);
   DCHECK_LT(double_buffer_index, shared_input_buffers_.size());
   DCHECK_LT(double_buffer_index, shared_output_buffers_.size());

   SharedAudioBuffer* shared_input_buffer =
       shared_input_buffers_.at(double_buffer_index).get();
   SharedAudioBuffer* shared_output_buffer =
       shared_output_buffers_.at(double_buffer_index).get();

   // Check the consistency of input and output buffers.
   uint32_t number_of_input_channels = internal_input_bus_->NumberOfChannels();
   bool buffers_are_good =
       shared_output_buffer && BufferSize() == shared_output_buffer->length() &&
       buffer_read_write_index_ + frames_to_process <= BufferSize();

   // If the number of input channels is zero, it's ok to have inputBuffer = 0.
   if (internal_input_bus_->NumberOfChannels()) {
     buffers_are_good = buffers_are_good && shared_input_buffer &&
                        BufferSize() == shared_input_buffer->length();
   }

   DCHECK(buffers_are_good);

   // We assume that bufferSize() is evenly divisible by framesToProcess - should
   // always be true, but we should still check.
   DCHECK_GT(frames_to_process, 0u);
   DCHECK_GE(BufferSize(), frames_to_process);
   DCHECK_EQ(BufferSize() % frames_to_process, 0u);

   uint32_t number_of_output_channels = output_bus->NumberOfChannels();

   DCHECK_EQ(number_of_input_channels, number_of_input_channels_);
   DCHECK_EQ(number_of_output_channels, number_of_output_channels_);

   for (uint32_t i = 0; i < number_of_input_channels; ++i)
     internal_input_bus_->SetChannelMemory(
         i,
         static_cast<float*>(shared_input_buffer->channels()[i].Data()) +
             buffer_read_write_index_,
         frames_to_process);

   if (number_of_input_channels)
     internal_input_bus_->CopyFrom(*input_bus);

   // Copy from the output buffer to the output.
   for (uint32_t i = 0; i < number_of_output_channels; ++i) {
     memcpy(output_bus->Channel(i)->MutableData(),
            static_cast<float*>(shared_output_buffer->channels()[i].Data()) +
                buffer_read_write_index_,
            sizeof(float) * frames_to_process);
   }

   // Update the buffering index.
   buffer_read_write_index_ =
       (buffer_read_write_index_ + frames_to_process) % BufferSize();

   // Fire an event and swap buffers when |buffer_read_write_index_| wraps back
   // around to 0. It means the current input and output buffers are full.
   if (!buffer_read_write_index_) {
     if (Context()->HasRealtimeConstraint()) {
       // For a realtime context, fire an event and do not wait.
       PostCrossThreadTask(
           *task_runner_, FROM_HERE,
           CrossThreadBindOnce(&ScriptProcessorHandler::FireProcessEvent,
                               AsWeakPtr(), double_buffer_index_));
     } else {
       // For an offline context, wait until the script execution is finished.
       std::unique_ptr<base::WaitableEvent> waitable_event =
           std::make_unique<base::WaitableEvent>();
       PostCrossThreadTask(
           *task_runner_, FROM_HERE,
           CrossThreadBindOnce(
               &ScriptProcessorHandler::FireProcessEventForOfflineAudioContext,
               AsWeakPtr(), double_buffer_index_,
               CrossThreadUnretained(waitable_event.get())));
       waitable_event->Wait();
     }

     SwapBuffers();
   }
 }

 void ScriptProcessorHandler::FireProcessEvent(uint32_t double_buffer_index) {
   DCHECK(IsMainThread());

   if (!Context() || !Context()->GetExecutionContext())
     return;

   DCHECK_LT(double_buffer_index, 2u);

   // Avoid firing the event if the document has already gone away.
   if (GetNode()) {
     // This synchronizes with process().
     MutexLocker process_locker(process_event_lock_);

     // Calculate a playbackTime with the buffersize which needs to be processed
     // each time onaudioprocess is called.  The outputBuffer being passed to JS
     // will be played after exhuasting previous outputBuffer by
     // double-buffering.
     double playback_time = (Context()->CurrentSampleFrame() + buffer_size_) /
                            static_cast<double>(Context()->sampleRate());
     static_cast<ScriptProcessorNode*>(GetNode())->DispatchEvent(
         playback_time, double_buffer_index);
   }
 }

 void ScriptProcessorHandler::FireProcessEventForOfflineAudioContext(
     uint32_t double_buffer_index,
     base::WaitableEvent* waitable_event) {
   DCHECK(IsMainThread());

   if (!Context() || !Context()->GetExecutionContext())
     return;

   DCHECK_LT(double_buffer_index, 2u);
   if (double_buffer_index > 1) {
     waitable_event->Signal();
     return;
   }

   if (GetNode()) {
     // We do not need a process lock here because the offline render thread
     // is locked by the waitable event.
     double playback_time = (Context()->CurrentSampleFrame() + buffer_size_) /
                            static_cast<double>(Context()->sampleRate());
     static_cast<ScriptProcessorNode*>(GetNode())->DispatchEvent(
         playback_time, double_buffer_index);
   }

   waitable_event->Signal();
 }

 bool ScriptProcessorHandler::RequiresTailProcessing() const {
   // Always return true since the tail and latency are never zero.
   return true;
 }

 double ScriptProcessorHandler::TailTime() const {
   return std::numeric_limits<double>::infinity();
 }

 double ScriptProcessorHandler::LatencyTime() const {
   return std::numeric_limits<double>::infinity();
 }

 void ScriptProcessorHandler::SetChannelCount(uint32_t channel_count,
                                              ExceptionState& exception_state) {
   DCHECK(IsMainThread());
   BaseAudioContext::GraphAutoLocker locker(Context());

   if (channel_count != channel_count_) {
     exception_state.ThrowDOMException(DOMExceptionCode::kNotSupportedError,
                                       "channelCount cannot be changed from " +
                                           String::Number(channel_count_) +
                                           " to " +
                                           String::Number(channel_count));
   }
 }

 void ScriptProcessorHandler::SetChannelCountMode(
     const String& mode,
     ExceptionState& exception_state) {
   DCHECK(IsMainThread());
   BaseAudioContext::GraphAutoLocker locker(Context());

   if ((mode == "max") || (mode == "clamped-max")) {
     exception_state.ThrowDOMException(
         DOMExceptionCode::kNotSupportedError,
         "channelCountMode cannot be changed from 'explicit' to '" + mode + "'");
   }
 }

 // ----------------------------------------------------------------

 ScriptProcessorNode::ScriptProcessorNode(BaseAudioContext& context,
                                          float sample_rate,
                                          uint32_t buffer_size,
                                          uint32_t number_of_input_channels,
                                          uint32_t number_of_output_channels)
     : AudioNode(context) {
   // Regardless of the allowed buffer sizes, we still need to process at the
   // granularity of the AudioNode.
   if (buffer_size < audio_utilities::kRenderQuantumFrames)
     buffer_size = audio_utilities::kRenderQuantumFrames;

   // Create double buffers on both the input and output sides.
   // These AudioBuffers will be directly accessed in the main thread by
   // JavaScript.
   for (uint32_t i = 0; i < 2; ++i) {
     AudioBuffer* input_buffer =
         number_of_input_channels ? AudioBuffer::Create(number_of_input_channels,
                                                        buffer_size, sample_rate)
                                  : nullptr;
     AudioBuffer* output_buffer =
         number_of_output_channels
             ? AudioBuffer::Create(number_of_output_channels, buffer_size,
                                   sample_rate)
             : nullptr;

     input_buffers_.push_back(input_buffer);
     output_buffers_.push_back(output_buffer);
   }

   external_input_buffer_ = AudioBuffer::Create(
       number_of_input_channels, buffer_size, sample_rate);
   external_output_buffer_ = AudioBuffer::Create(
       number_of_output_channels, buffer_size, sample_rate);

   SetHandler(ScriptProcessorHandler::Create(
       *this, sample_rate, buffer_size, number_of_input_channels,
       number_of_output_channels, input_buffers_, output_buffers_));
 }

 static uint32_t ChooseBufferSize(uint32_t callback_buffer_size) {
   // Choose a buffer size based on the audio hardware buffer size. Arbitarily
   // make it a power of two that is 4 times greater than the hardware buffer
   // size.
   // TODO(crbug.com/855758): What is the best way to choose this?
   uint32_t buffer_size =
       1 << static_cast<uint32_t>(log2(4 * callback_buffer_size) + 0.5);

   if (buffer_size < 256)
     return 256;
   if (buffer_size > 16384)
     return 16384;

   return buffer_size;
 }

 ScriptProcessorNode* ScriptProcessorNode::Create(
     BaseAudioContext& context,
     ExceptionState& exception_state) {
   DCHECK(IsMainThread());

   // Default buffer size is 0 (let WebAudio choose) with 2 inputs and 2
   // outputs.
   return Create(context, 0, 2, 2, exception_state);
 }

 ScriptProcessorNode* ScriptProcessorNode::Create(
     BaseAudioContext& context,
     uint32_t requested_buffer_size,
     ExceptionState& exception_state) {
   DCHECK(IsMainThread());

   // Default is 2 inputs and 2 outputs.
   return Create(context, requested_buffer_size, 2, 2, exception_state);
 }

 ScriptProcessorNode* ScriptProcessorNode::Create(
     BaseAudioContext& context,
     uint32_t requested_buffer_size,
     uint32_t number_of_input_channels,
     ExceptionState& exception_state) {
   DCHECK(IsMainThread());

   // Default is 2 outputs.
   return Create(context, requested_buffer_size, number_of_input_channels, 2,
                 exception_state);
 }

 ScriptProcessorNode* ScriptProcessorNode::Create(
     BaseAudioContext& context,
     uint32_t requested_buffer_size,
     uint32_t number_of_input_channels,
     uint32_t number_of_output_channels,
     ExceptionState& exception_state) {
   DCHECK(IsMainThread());

   if (number_of_input_channels == 0 && number_of_output_channels == 0) {
     exception_state.ThrowDOMException(
         DOMExceptionCode::kIndexSizeError,
         "number of input channels and output channels cannot both be zero.");
     return nullptr;
   }

   if (number_of_input_channels > BaseAudioContext::MaxNumberOfChannels()) {
     exception_state.ThrowDOMException(
         DOMExceptionCode::kIndexSizeError,
         "number of input channels (" +
             String::Number(number_of_input_channels) + ") exceeds maximum (" +
             String::Number(BaseAudioContext::MaxNumberOfChannels()) + ").");
     return nullptr;
   }

   if (number_of_output_channels > BaseAudioContext::MaxNumberOfChannels()) {
     exception_state.ThrowDOMException(
         DOMExceptionCode::kIndexSizeError,
         "number of output channels (" +
             String::Number(number_of_output_channels) + ") exceeds maximum (" +
             String::Number(BaseAudioContext::MaxNumberOfChannels()) + ").");
     return nullptr;
   }

   // Sanitize user-supplied buffer size.
   uint32_t buffer_size;
   switch (requested_buffer_size) {
     case 0:
       // Choose an appropriate size.  For an AudioContext, we need to
       // choose an appropriate size based on the callback buffer size.
       if (context.HasRealtimeConstraint()) {
         RealtimeAudioDestinationHandler& destination_handler =
             static_cast<RealtimeAudioDestinationHandler&>(
                 context.destination()->GetAudioDestinationHandler());
         buffer_size =
             ChooseBufferSize(destination_handler.GetCallbackBufferSize());
       } else {
         // For OfflineAudioContext, there's no callback buffer size, so
         // just use the minimum valid buffer size.
         buffer_size = 256;
       }
       break;
     case 256:
     case 512:
     case 1024:
     case 2048:
     case 4096:
     case 8192:
     case 16384:
       buffer_size = requested_buffer_size;
       break;
     default:
       exception_state.ThrowDOMException(
           DOMExceptionCode::kIndexSizeError,
           "buffer size (" + String::Number(requested_buffer_size) +
               ") must be 0 or a power of two between 256 and 16384.");
       return nullptr;
   }

   ScriptProcessorNode* node = MakeGarbageCollected<ScriptProcessorNode>(
       context, context.sampleRate(), buffer_size, number_of_input_channels,
       number_of_output_channels);

   if (!node)
     return nullptr;

   return node;
 }

 uint32_t ScriptProcessorNode::bufferSize() const {
   return static_cast<ScriptProcessorHandler&>(Handler()).BufferSize();
 }

 void ScriptProcessorNode::DispatchEvent(double playback_time,
                                         uint32_t double_buffer_index) {
   DCHECK(IsMainThread());

   AudioBuffer* backing_input_buffer =
       input_buffers_.at(double_buffer_index).Get();

   // The backing buffer can be nullptr, when the number of input channels is 0.
   if (backing_input_buffer) {
     // Also the author code might have transferred |external_input_buffer| to
     // other threads or replaced it with a different AudioBuffer object. Then
     // re-create a new buffer instance.
     if (IsAudioBufferDetached(external_input_buffer_) ||
         !BufferTopologyMatches(backing_input_buffer,
                                external_input_buffer_)) {
       external_input_buffer_ = AudioBuffer::Create(
           backing_input_buffer->numberOfChannels(),
           backing_input_buffer->length(),
           backing_input_buffer->sampleRate());
     }

     for (unsigned channel = 0;
          channel < backing_input_buffer->numberOfChannels(); ++channel) {
       const float* source = static_cast<float*>(
           backing_input_buffer->getChannelData(channel)->buffer()->Data());
       float* destination = static_cast<float*>(
           external_input_buffer_->getChannelData(channel)->buffer()->Data());
       memcpy(destination, source,
              backing_input_buffer->length() * sizeof(float));
     }
   }

   AudioNode::DispatchEvent(*AudioProcessingEvent::Create(
       external_input_buffer_, external_output_buffer_, playback_time));

   AudioBuffer* backing_output_buffer =
       output_buffers_.at(double_buffer_index).Get();

   if (backing_output_buffer) {
     if (IsAudioBufferDetached(external_output_buffer_) ||
         !BufferTopologyMatches(backing_output_buffer,
                                external_output_buffer_)) {
       external_output_buffer_ = AudioBuffer::Create(
           backing_output_buffer->numberOfChannels(),
           backing_output_buffer->length(),
           backing_output_buffer->sampleRate());
     }

     for (unsigned channel = 0;
          channel < backing_output_buffer->numberOfChannels(); ++channel) {
       const float* source = static_cast<float*>(
           external_output_buffer_->getChannelData(channel)->buffer()->Data());
       float* destination = static_cast<float*>(
           backing_output_buffer->getChannelData(channel)->buffer()->Data());
       memcpy(destination, source,
              backing_output_buffer->length() * sizeof(float));
     }
   }
 }

 bool ScriptProcessorNode::HasPendingActivity() const {
   // To prevent the node from leaking after the context is closed.
   if (context()->IsContextClosed())
     return false;

   // If |onaudioprocess| event handler is defined, the node should not be
   // GCed even if it is out of scope.
   if (HasEventListeners(event_type_names::kAudioprocess))
     return true;

   return false;
 }

 void ScriptProcessorNode::Trace(Visitor* visitor) const {
   visitor->Trace(input_buffers_);
   visitor->Trace(output_buffers_);
   visitor->Trace(external_input_buffer_);
   visitor->Trace(external_output_buffer_);
   AudioNode::Trace(visitor);
 }

 void ScriptProcessorNode::ReportDidCreate() {
   GraphTracer().DidCreateAudioNode(this);
 }

 void ScriptProcessorNode::ReportWillBeDestroyed() {
   GraphTracer().WillDestroyAudioNode(this);
 }

 }  // namespace blink
	/*
	* Copyright (C) 2010, Google Inc. All rights reserved.
	*
	* Redistribution and use in source and binary forms, with or without
	* modification, are permitted provided that the following conditions
	* are met:
	* 1. Redistributions of source code must retain the above copyright
	* notice, this list of conditions and the following disclaimer.
	* 2. Redistributions in binary form must reproduce the above copyright
	* notice, this list of conditions and the following disclaimer in the
	* documentation and/or other materials provided with the distribution.
	*
	* THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' AND
	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	* ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS BE LIABLE
	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
	* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
	* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
	* DAMAGE.
	*/

	#include "third_party/blink/renderer/modules/webaudio/script_processor_node.h"

	#include <memory>

	#include "third_party/blink/public/platform/platform.h"
	#include "third_party/blink/public/platform/task_type.h"
	#include "third_party/blink/renderer/core/execution_context/execution_context.h"
	#include "third_party/blink/renderer/core/frame/local_dom_window.h"
	#include "third_party/blink/renderer/core/inspector/console_message.h"
	#include "third_party/blink/renderer/modules/webaudio/audio_buffer.h"
	#include "third_party/blink/renderer/modules/webaudio/audio_node_input.h"
	#include "third_party/blink/renderer/modules/webaudio/audio_node_output.h"
	#include "third_party/blink/renderer/modules/webaudio/audio_processing_event.h"
	#include "third_party/blink/renderer/modules/webaudio/base_audio_context.h"
	#include "third_party/blink/renderer/modules/webaudio/realtime_audio_destination_node.h"
	#include "third_party/blink/renderer/platform/bindings/exception_state.h"
	#include "third_party/blink/renderer/platform/scheduler/public/post_cross_thread_task.h"
	#include "third_party/blink/renderer/platform/wtf/cross_thread_functional.h"

	namespace blink {

	namespace {

	bool IsAudioBufferDetached(AudioBuffer* buffer) {
	bool is_buffer_detached = false;
	for (unsigned channel = 0; channel < buffer->numberOfChannels(); ++channel) {
	if (buffer->getChannelData(channel)->buffer()->IsDetached()) {
	is_buffer_detached = true;
	break;
	}
	}

	return is_buffer_detached;
	}

	bool BufferTopologyMatches(AudioBuffer* buffer_1, AudioBuffer* buffer_2) {
	return (buffer_1->numberOfChannels() == buffer_2->numberOfChannels()) &&
	(buffer_1->length() == buffer_2->length()) &&
	(buffer_1->sampleRate() == buffer_2->sampleRate());
	}

	} // namespace

	ScriptProcessorHandler::ScriptProcessorHandler(
	AudioNode& node,
	float sample_rate,
	uint32_t buffer_size,
	uint32_t number_of_input_channels,
	uint32_t number_of_output_channels,
	const HeapVector<Member<AudioBuffer>>& input_buffers,
	const HeapVector<Member<AudioBuffer>>& output_buffers)
	: AudioHandler(kNodeTypeScriptProcessor, node, sample_rate),
	double_buffer_index_(0),
	buffer_size_(buffer_size),
	buffer_read_write_index_(0),
	number_of_input_channels_(number_of_input_channels),
	number_of_output_channels_(number_of_output_channels),
	internal_input_bus_(
	AudioBus::Create(number_of_input_channels,
	audio_utilities::kRenderQuantumFrames,
	false)) {
	DCHECK_GE(buffer_size_, audio_utilities::kRenderQuantumFrames);
	DCHECK_LE(number_of_input_channels, BaseAudioContext::MaxNumberOfChannels());

	AddInput();
	AddOutput(number_of_output_channels);

	channel_count_ = number_of_input_channels;
	SetInternalChannelCountMode(kExplicit);

	if (Context()->GetExecutionContext()) {
	task_runner_ = Context()->GetExecutionContext()->GetTaskRunner(
	TaskType::kMediaElementEvent);
	}

	for (uint32_t i = 0; i < 2; ++i) {
	shared_input_buffers_.push_back(
	input_buffers[i] ? input_buffers[i]->CreateSharedAudioBuffer()
	: nullptr);
	shared_output_buffers_.push_back(
	output_buffers[i] ? output_buffers[i]->CreateSharedAudioBuffer()
	: nullptr);
	}

	Initialize();

	LocalDOMWindow* window = To<LocalDOMWindow>(Context()->GetExecutionContext());
	if (window) {
	window->AddConsoleMessage(MakeGarbageCollected<ConsoleMessage>(
	mojom::blink::ConsoleMessageSource::kDeprecation,
	mojom::blink::ConsoleMessageLevel::kWarning,
	"The ScriptProcessorNode is deprecated. Use AudioWorkletNode instead."
	" (https://bit.ly/audio-worklet)"));
	}
	}

	scoped_refptr<ScriptProcessorHandler> ScriptProcessorHandler::Create(
	AudioNode& node,
	float sample_rate,
	uint32_t buffer_size,
	uint32_t number_of_input_channels,
	uint32_t number_of_output_channels,
	const HeapVector<Member<AudioBuffer>>& input_buffers,
	const HeapVector<Member<AudioBuffer>>& output_buffers) {
	return base::AdoptRef(new ScriptProcessorHandler(
	node, sample_rate, buffer_size, number_of_input_channels,
	number_of_output_channels, input_buffers, output_buffers));
	}

	ScriptProcessorHandler::~ScriptProcessorHandler() {
	Uninitialize();
	}

	void ScriptProcessorHandler::Initialize() {
	if (IsInitialized())
	return;
	AudioHandler::Initialize();
	}

	void ScriptProcessorHandler::Process(uint32_t frames_to_process) {
	// The main thread might be accessing the shared buffers. If so, silience
	// the output and return.
	MutexTryLocker try_locker(process_event_lock_);
	if (!try_locker.Locked()) {
	Output(0).Bus()->Zero();
	return;
	}

	// Discussion about inputs and outputs:
	// As in other AudioNodes, ScriptProcessorNode uses an AudioBus for its input
	// and output (see inputBus and outputBus below). Additionally, there is a
	// double-buffering for input and output which is exposed directly to
	// JavaScript (see inputBuffer and outputBuffer below). This node is the
	// producer for inputBuffer and the consumer for outputBuffer. The JavaScript
	// code is the consumer of inputBuffer and the producer for outputBuffer.

	// Get input and output busses.
	scoped_refptr<AudioBus> input_bus = Input(0).Bus();
	AudioBus* output_bus = Output(0).Bus();

	// Get input and output buffers. We double-buffer both the input and output
	// sides.
	uint32_t double_buffer_index = this->DoubleBufferIndex();
	DCHECK_LT(double_buffer_index, 2u);
	DCHECK_LT(double_buffer_index, shared_input_buffers_.size());
	DCHECK_LT(double_buffer_index, shared_output_buffers_.size());

	SharedAudioBuffer* shared_input_buffer =
	shared_input_buffers_.at(double_buffer_index).get();
	SharedAudioBuffer* shared_output_buffer =
	shared_output_buffers_.at(double_buffer_index).get();

	// Check the consistency of input and output buffers.
	uint32_t number_of_input_channels = internal_input_bus_->NumberOfChannels();
	bool buffers_are_good =
	shared_output_buffer && BufferSize() == shared_output_buffer->length() &&
	buffer_read_write_index_ + frames_to_process <= BufferSize();

	// If the number of input channels is zero, it's ok to have inputBuffer = 0.
	if (internal_input_bus_->NumberOfChannels()) {
	buffers_are_good = buffers_are_good && shared_input_buffer &&
	BufferSize() == shared_input_buffer->length();
	}

	DCHECK(buffers_are_good);

	// We assume that bufferSize() is evenly divisible by framesToProcess - should
	// always be true, but we should still check.
	DCHECK_GT(frames_to_process, 0u);
	DCHECK_GE(BufferSize(), frames_to_process);
	DCHECK_EQ(BufferSize() % frames_to_process, 0u);

	uint32_t number_of_output_channels = output_bus->NumberOfChannels();

	DCHECK_EQ(number_of_input_channels, number_of_input_channels_);
	DCHECK_EQ(number_of_output_channels, number_of_output_channels_);

	for (uint32_t i = 0; i < number_of_input_channels; ++i)
	internal_input_bus_->SetChannelMemory(
	i,
	static_cast<float*>(shared_input_buffer->channels()[i].Data()) +
	buffer_read_write_index_,
	frames_to_process);

	if (number_of_input_channels)
	internal_input_bus_->CopyFrom(*input_bus);

	// Copy from the output buffer to the output.
	for (uint32_t i = 0; i < number_of_output_channels; ++i) {
	memcpy(output_bus->Channel(i)->MutableData(),
	static_cast<float*>(shared_output_buffer->channels()[i].Data()) +
	buffer_read_write_index_,
	sizeof(float) * frames_to_process);
	}

	// Update the buffering index.
	buffer_read_write_index_ =
	(buffer_read_write_index_ + frames_to_process) % BufferSize();

	// Fire an event and swap buffers when \|buffer_read_write_index_\| wraps back
	// around to 0. It means the current input and output buffers are full.
	if (!buffer_read_write_index_) {
	if (Context()->HasRealtimeConstraint()) {
	// For a realtime context, fire an event and do not wait.
	PostCrossThreadTask(
	*task_runner_, FROM_HERE,
	CrossThreadBindOnce(&ScriptProcessorHandler::FireProcessEvent,
	AsWeakPtr(), double_buffer_index_));
	} else {
	// For an offline context, wait until the script execution is finished.
	std::unique_ptr<base::WaitableEvent> waitable_event =
	std::make_unique<base::WaitableEvent>();
	PostCrossThreadTask(
	*task_runner_, FROM_HERE,
	CrossThreadBindOnce(
	&ScriptProcessorHandler::FireProcessEventForOfflineAudioContext,
	AsWeakPtr(), double_buffer_index_,
	CrossThreadUnretained(waitable_event.get())));
	waitable_event->Wait();
	}

	SwapBuffers();
	}
	}

	void ScriptProcessorHandler::FireProcessEvent(uint32_t double_buffer_index) {
	DCHECK(IsMainThread());

	if (!Context() \|\| !Context()->GetExecutionContext())
	return;

	DCHECK_LT(double_buffer_index, 2u);

	// Avoid firing the event if the document has already gone away.
	if (GetNode()) {
	// This synchronizes with process().
	MutexLocker process_locker(process_event_lock_);

	// Calculate a playbackTime with the buffersize which needs to be processed
	// each time onaudioprocess is called. The outputBuffer being passed to JS
	// will be played after exhuasting previous outputBuffer by
	// double-buffering.
	double playback_time = (Context()->CurrentSampleFrame() + buffer_size_) /
	static_cast<double>(Context()->sampleRate());
	static_cast<ScriptProcessorNode*>(GetNode())->DispatchEvent(
	playback_time, double_buffer_index);
	}
	}

	void ScriptProcessorHandler::FireProcessEventForOfflineAudioContext(
	uint32_t double_buffer_index,
	base::WaitableEvent* waitable_event) {
	DCHECK(IsMainThread());

	if (!Context() \|\| !Context()->GetExecutionContext())
	return;

	DCHECK_LT(double_buffer_index, 2u);
	if (double_buffer_index > 1) {
	waitable_event->Signal();
	return;
	}

	if (GetNode()) {
	// We do not need a process lock here because the offline render thread
	// is locked by the waitable event.
	double playback_time = (Context()->CurrentSampleFrame() + buffer_size_) /
	static_cast<double>(Context()->sampleRate());
	static_cast<ScriptProcessorNode*>(GetNode())->DispatchEvent(
	playback_time, double_buffer_index);
	}

	waitable_event->Signal();
	}

	bool ScriptProcessorHandler::RequiresTailProcessing() const {
	// Always return true since the tail and latency are never zero.
	return true;
	}

	double ScriptProcessorHandler::TailTime() const {
	return std::numeric_limits<double>::infinity();
	}

	double ScriptProcessorHandler::LatencyTime() const {
	return std::numeric_limits<double>::infinity();
	}

	void ScriptProcessorHandler::SetChannelCount(uint32_t channel_count,
	ExceptionState& exception_state) {
	DCHECK(IsMainThread());
	BaseAudioContext::GraphAutoLocker locker(Context());

	if (channel_count != channel_count_) {
	exception_state.ThrowDOMException(DOMExceptionCode::kNotSupportedError,
	"channelCount cannot be changed from " +
	String::Number(channel_count_) +
	" to " +
	String::Number(channel_count));
	}
	}

	void ScriptProcessorHandler::SetChannelCountMode(
	const String& mode,
	ExceptionState& exception_state) {
	DCHECK(IsMainThread());
	BaseAudioContext::GraphAutoLocker locker(Context());

	if ((mode == "max") \|\| (mode == "clamped-max")) {
	exception_state.ThrowDOMException(
	DOMExceptionCode::kNotSupportedError,
	"channelCountMode cannot be changed from 'explicit' to '" + mode + "'");
	}
	}

	// ----------------------------------------------------------------

	ScriptProcessorNode::ScriptProcessorNode(BaseAudioContext& context,
	float sample_rate,
	uint32_t buffer_size,
	uint32_t number_of_input_channels,
	uint32_t number_of_output_channels)
	: AudioNode(context) {
	// Regardless of the allowed buffer sizes, we still need to process at the
	// granularity of the AudioNode.
	if (buffer_size < audio_utilities::kRenderQuantumFrames)
	buffer_size = audio_utilities::kRenderQuantumFrames;

	// Create double buffers on both the input and output sides.
	// These AudioBuffers will be directly accessed in the main thread by
	// JavaScript.
	for (uint32_t i = 0; i < 2; ++i) {
	AudioBuffer* input_buffer =
	number_of_input_channels ? AudioBuffer::Create(number_of_input_channels,
	buffer_size, sample_rate)
	: nullptr;
	AudioBuffer* output_buffer =
	number_of_output_channels
	? AudioBuffer::Create(number_of_output_channels, buffer_size,
	sample_rate)
	: nullptr;

	input_buffers_.push_back(input_buffer);
	output_buffers_.push_back(output_buffer);
	}

	external_input_buffer_ = AudioBuffer::Create(
	number_of_input_channels, buffer_size, sample_rate);
	external_output_buffer_ = AudioBuffer::Create(
	number_of_output_channels, buffer_size, sample_rate);

	SetHandler(ScriptProcessorHandler::Create(
	*this, sample_rate, buffer_size, number_of_input_channels,
	number_of_output_channels, input_buffers_, output_buffers_));
	}

	static uint32_t ChooseBufferSize(uint32_t callback_buffer_size) {
	// Choose a buffer size based on the audio hardware buffer size. Arbitarily
	// make it a power of two that is 4 times greater than the hardware buffer
	// size.
	// TODO(crbug.com/855758): What is the best way to choose this?
	uint32_t buffer_size =
	1 << static_cast<uint32_t>(log2(4 * callback_buffer_size) + 0.5);

	if (buffer_size < 256)
	return 256;
	if (buffer_size > 16384)
	return 16384;

	return buffer_size;
	}

	ScriptProcessorNode* ScriptProcessorNode::Create(
	BaseAudioContext& context,
	ExceptionState& exception_state) {
	DCHECK(IsMainThread());

	// Default buffer size is 0 (let WebAudio choose) with 2 inputs and 2
	// outputs.
	return Create(context, 0, 2, 2, exception_state);
	}

	ScriptProcessorNode* ScriptProcessorNode::Create(
	BaseAudioContext& context,
	uint32_t requested_buffer_size,
	ExceptionState& exception_state) {
	DCHECK(IsMainThread());

	// Default is 2 inputs and 2 outputs.
	return Create(context, requested_buffer_size, 2, 2, exception_state);
	}

	ScriptProcessorNode* ScriptProcessorNode::Create(
	BaseAudioContext& context,
	uint32_t requested_buffer_size,
	uint32_t number_of_input_channels,
	ExceptionState& exception_state) {
	DCHECK(IsMainThread());

	// Default is 2 outputs.
	return Create(context, requested_buffer_size, number_of_input_channels, 2,
	exception_state);
	}

	ScriptProcessorNode* ScriptProcessorNode::Create(
	BaseAudioContext& context,
	uint32_t requested_buffer_size,
	uint32_t number_of_input_channels,
	uint32_t number_of_output_channels,
	ExceptionState& exception_state) {
	DCHECK(IsMainThread());

	if (number_of_input_channels == 0 && number_of_output_channels == 0) {
	exception_state.ThrowDOMException(
	DOMExceptionCode::kIndexSizeError,
	"number of input channels and output channels cannot both be zero.");
	return nullptr;
	}

	if (number_of_input_channels > BaseAudioContext::MaxNumberOfChannels()) {
	exception_state.ThrowDOMException(
	DOMExceptionCode::kIndexSizeError,
	"number of input channels (" +
	String::Number(number_of_input_channels) + ") exceeds maximum (" +
	String::Number(BaseAudioContext::MaxNumberOfChannels()) + ").");
	return nullptr;
	}

	if (number_of_output_channels > BaseAudioContext::MaxNumberOfChannels()) {
	exception_state.ThrowDOMException(
	DOMExceptionCode::kIndexSizeError,
	"number of output channels (" +
	String::Number(number_of_output_channels) + ") exceeds maximum (" +
	String::Number(BaseAudioContext::MaxNumberOfChannels()) + ").");
	return nullptr;
	}

	// Sanitize user-supplied buffer size.
	uint32_t buffer_size;
	switch (requested_buffer_size) {
	case 0:
	// Choose an appropriate size. For an AudioContext, we need to
	// choose an appropriate size based on the callback buffer size.
	if (context.HasRealtimeConstraint()) {
	RealtimeAudioDestinationHandler& destination_handler =
	static_cast<RealtimeAudioDestinationHandler&>(
	context.destination()->GetAudioDestinationHandler());
	buffer_size =
	ChooseBufferSize(destination_handler.GetCallbackBufferSize());
	} else {
	// For OfflineAudioContext, there's no callback buffer size, so
	// just use the minimum valid buffer size.
	buffer_size = 256;
	}
	break;
	case 256:
	case 512:
	case 1024:
	case 2048:
	case 4096:
	case 8192:
	case 16384:
	buffer_size = requested_buffer_size;
	break;
	default:
	exception_state.ThrowDOMException(
	DOMExceptionCode::kIndexSizeError,
	"buffer size (" + String::Number(requested_buffer_size) +
	") must be 0 or a power of two between 256 and 16384.");
	return nullptr;
	}

	ScriptProcessorNode* node = MakeGarbageCollected<ScriptProcessorNode>(
	context, context.sampleRate(), buffer_size, number_of_input_channels,
	number_of_output_channels);

	if (!node)
	return nullptr;

	return node;
	}

	uint32_t ScriptProcessorNode::bufferSize() const {
	return static_cast<ScriptProcessorHandler&>(Handler()).BufferSize();
	}

	void ScriptProcessorNode::DispatchEvent(double playback_time,
	uint32_t double_buffer_index) {
	DCHECK(IsMainThread());

	AudioBuffer* backing_input_buffer =
	input_buffers_.at(double_buffer_index).Get();

	// The backing buffer can be nullptr, when the number of input channels is 0.
	if (backing_input_buffer) {
	// Also the author code might have transferred \|external_input_buffer\| to
	// other threads or replaced it with a different AudioBuffer object. Then
	// re-create a new buffer instance.
	if (IsAudioBufferDetached(external_input_buffer_) \|\|
	!BufferTopologyMatches(backing_input_buffer,
	external_input_buffer_)) {
	external_input_buffer_ = AudioBuffer::Create(
	backing_input_buffer->numberOfChannels(),
	backing_input_buffer->length(),
	backing_input_buffer->sampleRate());
	}

	for (unsigned channel = 0;
	channel < backing_input_buffer->numberOfChannels(); ++channel) {
	const float* source = static_cast<float*>(
	backing_input_buffer->getChannelData(channel)->buffer()->Data());
	float* destination = static_cast<float*>(
	external_input_buffer_->getChannelData(channel)->buffer()->Data());
	memcpy(destination, source,
	backing_input_buffer->length() * sizeof(float));
	}
	}

	AudioNode::DispatchEvent(*AudioProcessingEvent::Create(
	external_input_buffer_, external_output_buffer_, playback_time));

	AudioBuffer* backing_output_buffer =
	output_buffers_.at(double_buffer_index).Get();

	if (backing_output_buffer) {
	if (IsAudioBufferDetached(external_output_buffer_) \|\|
	!BufferTopologyMatches(backing_output_buffer,
	external_output_buffer_)) {
	external_output_buffer_ = AudioBuffer::Create(
	backing_output_buffer->numberOfChannels(),
	backing_output_buffer->length(),
	backing_output_buffer->sampleRate());
	}

	for (unsigned channel = 0;
	channel < backing_output_buffer->numberOfChannels(); ++channel) {
	const float* source = static_cast<float*>(
	external_output_buffer_->getChannelData(channel)->buffer()->Data());
	float* destination = static_cast<float*>(
	backing_output_buffer->getChannelData(channel)->buffer()->Data());
	memcpy(destination, source,
	backing_output_buffer->length() * sizeof(float));
	}
	}
	}

	bool ScriptProcessorNode::HasPendingActivity() const {
	// To prevent the node from leaking after the context is closed.
	if (context()->IsContextClosed())
	return false;

	// If \|onaudioprocess\| event handler is defined, the node should not be
	// GCed even if it is out of scope.
	if (HasEventListeners(event_type_names::kAudioprocess))
	return true;

	return false;
	}

	void ScriptProcessorNode::Trace(Visitor* visitor) const {
	visitor->Trace(input_buffers_);
	visitor->Trace(output_buffers_);
	visitor->Trace(external_input_buffer_);
	visitor->Trace(external_output_buffer_);
	AudioNode::Trace(visitor);
	}

	void ScriptProcessorNode::ReportDidCreate() {
	GraphTracer().DidCreateAudioNode(this);
	}

	void ScriptProcessorNode::ReportWillBeDestroyed() {
	GraphTracer().WillDestroyAudioNode(this);
	}

	} // namespace blink