1 // Copyright 2013 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "content/renderer/media/webaudiosourceprovider_impl.h" 6 7 #include <vector> 8 9 #include "base/bind.h" 10 #include "base/callback_helpers.h" 11 #include "base/logging.h" 12 #include "media/base/bind_to_current_loop.h" 13 #include "third_party/WebKit/public/platform/WebAudioSourceProviderClient.h" 14 15 using blink::WebVector; 16 17 namespace content { 18 19 namespace { 20 21 // Simple helper class for Try() locks. Lock is Try()'d on construction and 22 // must be checked via the locked() attribute. If acquisition was successful 23 // the lock will be released upon destruction. 24 // TODO(dalecurtis): This should probably move to base/ if others start using 25 // this pattern. 26 class AutoTryLock { 27 public: 28 explicit AutoTryLock(base::Lock& lock) 29 : lock_(lock), 30 acquired_(lock_.Try()) {} 31 32 bool locked() const { return acquired_; } 33 34 ~AutoTryLock() { 35 if (acquired_) { 36 lock_.AssertAcquired(); 37 lock_.Release(); 38 } 39 } 40 41 private: 42 base::Lock& lock_; 43 const bool acquired_; 44 DISALLOW_COPY_AND_ASSIGN(AutoTryLock); 45 }; 46 47 } // namespace 48 49 WebAudioSourceProviderImpl::WebAudioSourceProviderImpl( 50 const scoped_refptr<media::AudioRendererSink>& sink) 51 : channels_(0), 52 sample_rate_(0), 53 volume_(1.0), 54 state_(kStopped), 55 renderer_(NULL), 56 client_(NULL), 57 sink_(sink), 58 weak_factory_(this) {} 59 60 WebAudioSourceProviderImpl::~WebAudioSourceProviderImpl() { 61 } 62 63 void WebAudioSourceProviderImpl::setClient( 64 blink::WebAudioSourceProviderClient* client) { 65 base::AutoLock auto_lock(sink_lock_); 66 if (client && client != client_) { 67 // Detach the audio renderer from normal playback. 68 sink_->Stop(); 69 70 // The client will now take control by calling provideInput() periodically. 71 client_ = client; 72 73 set_format_cb_ = media::BindToCurrentLoop(base::Bind( 74 &WebAudioSourceProviderImpl::OnSetFormat, weak_factory_.GetWeakPtr())); 75 76 // If |renderer_| is set, then run |set_format_cb_| to send |client_| 77 // the current format info. If |renderer_| is not set, then |set_format_cb_| 78 // will get called when Initialize() is called. 79 // Note: Always using |set_format_cb_| ensures we have the same 80 // locking order when calling into |client_|. 81 if (renderer_) 82 base::ResetAndReturn(&set_format_cb_).Run(); 83 } else if (!client && client_) { 84 // Restore normal playback. 85 client_ = NULL; 86 sink_->SetVolume(volume_); 87 if (state_ >= kStarted) 88 sink_->Start(); 89 if (state_ >= kPlaying) 90 sink_->Play(); 91 } 92 } 93 94 void WebAudioSourceProviderImpl::provideInput( 95 const WebVector<float*>& audio_data, size_t number_of_frames) { 96 if (!bus_wrapper_ || 97 static_cast<size_t>(bus_wrapper_->channels()) != audio_data.size()) { 98 bus_wrapper_ = media::AudioBus::CreateWrapper(audio_data.size()); 99 } 100 101 bus_wrapper_->set_frames(number_of_frames); 102 for (size_t i = 0; i < audio_data.size(); ++i) 103 bus_wrapper_->SetChannelData(i, audio_data[i]); 104 105 // Use a try lock to avoid contention in the real-time audio thread. 106 AutoTryLock auto_try_lock(sink_lock_); 107 if (!auto_try_lock.locked() || state_ != kPlaying) { 108 // Provide silence if we failed to acquire the lock or the source is not 109 // running. 110 bus_wrapper_->Zero(); 111 return; 112 } 113 114 DCHECK(renderer_); 115 DCHECK(client_); 116 DCHECK_EQ(channels_, bus_wrapper_->channels()); 117 const size_t frames = renderer_->Render(bus_wrapper_.get(), 0); 118 if (frames < number_of_frames) 119 bus_wrapper_->ZeroFramesPartial(frames, number_of_frames - frames); 120 bus_wrapper_->Scale(volume_); 121 } 122 123 void WebAudioSourceProviderImpl::Start() { 124 base::AutoLock auto_lock(sink_lock_); 125 DCHECK_EQ(state_, kStopped); 126 state_ = kStarted; 127 if (!client_) 128 sink_->Start(); 129 } 130 131 void WebAudioSourceProviderImpl::Stop() { 132 base::AutoLock auto_lock(sink_lock_); 133 state_ = kStopped; 134 if (!client_) 135 sink_->Stop(); 136 } 137 138 void WebAudioSourceProviderImpl::Play() { 139 base::AutoLock auto_lock(sink_lock_); 140 DCHECK_EQ(state_, kStarted); 141 state_ = kPlaying; 142 if (!client_) 143 sink_->Play(); 144 } 145 146 void WebAudioSourceProviderImpl::Pause() { 147 base::AutoLock auto_lock(sink_lock_); 148 DCHECK(state_ == kPlaying || state_ == kStarted); 149 state_ = kStarted; 150 if (!client_) 151 sink_->Pause(); 152 } 153 154 bool WebAudioSourceProviderImpl::SetVolume(double volume) { 155 base::AutoLock auto_lock(sink_lock_); 156 volume_ = volume; 157 if (!client_) 158 sink_->SetVolume(volume); 159 return true; 160 } 161 162 void WebAudioSourceProviderImpl::Initialize( 163 const media::AudioParameters& params, 164 RenderCallback* renderer) { 165 base::AutoLock auto_lock(sink_lock_); 166 CHECK(!renderer_); 167 renderer_ = renderer; 168 169 DCHECK_EQ(state_, kStopped); 170 sink_->Initialize(params, renderer); 171 172 // Keep track of the format in case the client hasn't yet been set. 173 channels_ = params.channels(); 174 sample_rate_ = params.sample_rate(); 175 176 if (!set_format_cb_.is_null()) 177 base::ResetAndReturn(&set_format_cb_).Run(); 178 } 179 180 void WebAudioSourceProviderImpl::OnSetFormat() { 181 base::AutoLock auto_lock(sink_lock_); 182 if (!client_) 183 return; 184 185 // Inform Blink about the audio stream format. 186 client_->setFormat(channels_, sample_rate_); 187 } 188 189 } // namespace content 190
