/* * Copyright (C) 2012, 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/media_stream_audio_destination_node.h" #include "third_party/blink/renderer/bindings/modules/v8/v8_audio_node_options.h" #include "third_party/blink/renderer/modules/mediastream/media_stream_utils.h" #include "third_party/blink/renderer/modules/webaudio/audio_context.h" #include "third_party/blink/renderer/modules/webaudio/audio_node_input.h" #include "third_party/blink/renderer/modules/webaudio/base_audio_context.h" #include "third_party/blink/renderer/platform/bindings/exception_messages.h" #include "third_party/blink/renderer/platform/bindings/exception_state.h" #include "third_party/blink/renderer/platform/heap/heap.h" #include "third_party/blink/renderer/platform/heap/persistent.h" #include "third_party/blink/renderer/platform/instrumentation/tracing/trace_event.h" #include "third_party/blink/renderer/platform/wtf/uuid.h" namespace blink { namespace { void DidCreateMediaStreamAndTracks(MediaStreamDescriptor* stream) { for (uint32_t i = 0; i < stream->NumberOfAudioComponents(); ++i) MediaStreamUtils::DidCreateMediaStreamTrack(stream->AudioComponent(i)); for (uint32_t i = 0; i < stream->NumberOfVideoComponents(); ++i) MediaStreamUtils::DidCreateMediaStreamTrack(stream->VideoComponent(i)); } } // namespace // WebAudioCapturerSource ignores the channel count beyond 8, so we set the // block here to avoid anything can cause the crash. static const uint32_t kMaxChannelCount = 8; MediaStreamAudioDestinationHandler::MediaStreamAudioDestinationHandler( AudioNode& node, uint32_t number_of_channels) : AudioBasicInspectorHandler(kNodeTypeMediaStreamAudioDestination, node, node.context()->sampleRate()), source_(static_cast(node).source()), mix_bus_(AudioBus::Create(number_of_channels, audio_utilities::kRenderQuantumFrames)) { source_.Lock()->SetAudioFormat(number_of_channels, node.context()->sampleRate()); SetInternalChannelCountMode(kExplicit); Initialize(); } scoped_refptr MediaStreamAudioDestinationHandler::Create(AudioNode& node, uint32_t number_of_channels) { return base::AdoptRef( new MediaStreamAudioDestinationHandler(node, number_of_channels)); } MediaStreamAudioDestinationHandler::~MediaStreamAudioDestinationHandler() { Uninitialize(); } void MediaStreamAudioDestinationHandler::Process(uint32_t number_of_frames) { TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("webaudio.audionode"), "MediaStreamAudioDestinationHandler::Process"); // Conform the input bus into the internal mix bus, which represents // MediaStreamDestination's channel count. // Synchronize with possible dynamic changes to the channel count. MutexTryLocker try_locker(process_lock_); auto source = source_.Lock(); // If we can get the lock, we can process normally by updating the // mix bus to a new channel count, if needed. If not, just use the // old mix bus to do the mixing; we'll update the bus next time // around. if (try_locker.Locked()) { unsigned count = ChannelCount(); if (count != mix_bus_->NumberOfChannels()) { mix_bus_ = AudioBus::Create(count, audio_utilities::kRenderQuantumFrames); // setAudioFormat has an internal lock. This can cause audio to // glitch. This is outside of our control. source->SetAudioFormat(count, Context()->sampleRate()); } } mix_bus_->CopyFrom(*Input(0).Bus()); // consumeAudio has an internal lock (also used by setAudioFormat). // This can cause audio to glitch. This is outside of our control. source->ConsumeAudio(mix_bus_.get(), number_of_frames); } void MediaStreamAudioDestinationHandler::SetChannelCount( unsigned channel_count, ExceptionState& exception_state) { DCHECK(IsMainThread()); // Currently the maximum channel count supported for this node is 8, // which is constrained by m_source (WebAudioCapturereSource). Although // it has its own safety check for the excessive channels, throwing an // exception here is useful to developers. if (channel_count < 1 || channel_count > MaxChannelCount()) { exception_state.ThrowDOMException( DOMExceptionCode::kNotSupportedError, ExceptionMessages::IndexOutsideRange( "channel count", channel_count, 1, ExceptionMessages::kInclusiveBound, MaxChannelCount(), ExceptionMessages::kInclusiveBound)); return; } // Synchronize changes in the channel count with process() which // needs to update m_mixBus. MutexLocker locker(process_lock_); AudioHandler::SetChannelCount(channel_count, exception_state); } uint32_t MediaStreamAudioDestinationHandler::MaxChannelCount() const { return kMaxChannelCount; } void MediaStreamAudioDestinationHandler::PullInputs( uint32_t frames_to_process) { DCHECK_EQ(NumberOfOutputs(), 0u); // Just render the input; there's no output for this node. Input(0).Pull(nullptr, frames_to_process); } void MediaStreamAudioDestinationHandler::CheckNumberOfChannelsForInput( AudioNodeInput* input) { DCHECK(Context()->IsAudioThread()); Context()->AssertGraphOwner(); DCHECK_EQ(input, &this->Input(0)); AudioHandler::CheckNumberOfChannelsForInput(input); UpdatePullStatusIfNeeded(); } void MediaStreamAudioDestinationHandler::UpdatePullStatusIfNeeded() { Context()->AssertGraphOwner(); unsigned number_of_input_connections = Input(0).NumberOfRenderingConnections(); if (number_of_input_connections && !need_automatic_pull_) { // When an AudioBasicInspectorNode is not connected to any downstream node // while still connected from upstream node(s), add it to the context's // automatic pull list. Context()->GetDeferredTaskHandler().AddAutomaticPullNode(this); need_automatic_pull_ = true; } else if (!number_of_input_connections && need_automatic_pull_) { // The AudioBasicInspectorNode is connected to nothing and is // not an AnalyserNode, remove it from the context's automatic // pull list. AnalyserNode's need to be pulled even with no // inputs so that the internal state gets updated to hold the // right time and FFT data. Context()->GetDeferredTaskHandler().RemoveAutomaticPullNode(this); need_automatic_pull_ = false; } } // ---------------------------------------------------------------- MediaStreamAudioDestinationNode::MediaStreamAudioDestinationNode( AudioContext& context, uint32_t number_of_channels) : AudioBasicInspectorNode(context), source_(MakeGarbageCollected( "WebAudio-" + WTF::CreateCanonicalUUIDString(), MediaStreamSource::kTypeAudio, "MediaStreamAudioDestinationNode", false, MediaStreamSource::kReadyStateLive, true)), stream_(MediaStream::Create(context.GetExecutionContext(), MakeGarbageCollected( MediaStreamSourceVector({source_.Get()}), MediaStreamSourceVector()))) { DidCreateMediaStreamAndTracks(stream_->Descriptor()); SetHandler( MediaStreamAudioDestinationHandler::Create(*this, number_of_channels)); } MediaStreamAudioDestinationNode* MediaStreamAudioDestinationNode::Create( AudioContext& context, uint32_t number_of_channels, ExceptionState& exception_state) { DCHECK(IsMainThread()); // TODO(crbug.com/1055983): Remove this when the execution context validity // check is not required in the AudioNode factory methods. if (!context.CheckExecutionContextAndThrowIfNecessary(exception_state)) return nullptr; return MakeGarbageCollected( context, number_of_channels); } MediaStreamAudioDestinationNode* MediaStreamAudioDestinationNode::Create( AudioContext* context, const AudioNodeOptions* options, ExceptionState& exception_state) { DCHECK(IsMainThread()); if (!context->CheckExecutionContextAndThrowIfNecessary(exception_state)) return nullptr; // Default to stereo; |options| will update it appropriately if needed. MediaStreamAudioDestinationNode* node = MakeGarbageCollected(*context, 2); // Need to handle channelCount here ourselves because the upper // limit is different from the normal AudioNode::setChannelCount // limit of 32. Error messages will sometimes show the wrong // limits. if (options->hasChannelCount()) node->setChannelCount(options->channelCount(), exception_state); node->HandleChannelOptions(options, exception_state); return node; } void MediaStreamAudioDestinationNode::Trace(Visitor* visitor) const { visitor->Trace(stream_); visitor->Trace(source_); AudioBasicInspectorNode::Trace(visitor); } void MediaStreamAudioDestinationNode::ReportDidCreate() { GraphTracer().DidCreateAudioNode(this); } void MediaStreamAudioDestinationNode::ReportWillBeDestroyed() { GraphTracer().WillDestroyAudioNode(this); } } // namespace blink