OLD | NEW |
| (Empty) |
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 | |
OLD | NEW |