1 // Copyright (c) 2012 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 <stdlib.h> 6 #include <string.h> 7 8 #include <algorithm> 9 #include <limits> 10 #include <vector> 11 12 #include "ppapi/cpp/audio_config.h" 13 #include "ppapi/cpp/dev/audio_input_dev.h" 14 #include "ppapi/cpp/dev/device_ref_dev.h" 15 #include "ppapi/cpp/graphics_2d.h" 16 #include "ppapi/cpp/image_data.h" 17 #include "ppapi/cpp/instance.h" 18 #include "ppapi/cpp/logging.h" 19 #include "ppapi/cpp/module.h" 20 #include "ppapi/cpp/rect.h" 21 #include "ppapi/cpp/size.h" 22 #include "ppapi/utility/completion_callback_factory.h" 23 #include "ppapi/utility/threading/lock.h" 24 25 // When compiling natively on Windows, PostMessage can be #define-d to 26 // something else. 27 #ifdef PostMessage 28 #undef PostMessage 29 #endif 30 31 namespace { 32 33 // This sample frequency is guaranteed to work. 34 const PP_AudioSampleRate kSampleFrequency = PP_AUDIOSAMPLERATE_44100; 35 const uint32_t kSampleCount = 1024; 36 const uint32_t kChannelCount = 1; 37 const char* const kDelimiter = "#__#"; 38 39 } // namespace 40 41 class MyInstance : public pp::Instance { 42 public: 43 explicit MyInstance(PP_Instance instance) 44 : pp::Instance(instance), 45 callback_factory_(this), 46 sample_count_(0), 47 channel_count_(0), 48 samples_(NULL), 49 latency_(0), 50 timer_interval_(0), 51 pending_paint_(false), 52 waiting_for_flush_completion_(false) { 53 } 54 virtual ~MyInstance() { 55 device_detector_.MonitorDeviceChange(NULL, NULL); 56 audio_input_.Close(); 57 58 // The audio input thread has exited before the previous call returned, so 59 // it is safe to do so now. 60 delete[] samples_; 61 } 62 63 virtual bool Init(uint32_t argc, const char* argn[], const char* argv[]) { 64 sample_count_ = pp::AudioConfig::RecommendSampleFrameCount(this, 65 kSampleFrequency, 66 kSampleCount); 67 PP_DCHECK(sample_count_ > 0); 68 channel_count_ = kChannelCount; 69 samples_ = new int16_t[sample_count_ * channel_count_]; 70 memset(samples_, 0, sample_count_ * channel_count_ * sizeof(int16_t)); 71 72 device_detector_ = pp::AudioInput_Dev(this); 73 74 // Try to ensure that we pick up a new set of samples between each 75 // timer-generated repaint. 76 timer_interval_ = (sample_count_ * 1000) / kSampleFrequency + 5; 77 ScheduleNextTimer(); 78 79 return true; 80 } 81 82 virtual void DidChangeView(const pp::Rect& position, const pp::Rect& clip) { 83 if (position.size() == size_) 84 return; 85 86 size_ = position.size(); 87 device_context_ = pp::Graphics2D(this, size_, false); 88 if (!BindGraphics(device_context_)) 89 return; 90 91 Paint(); 92 } 93 94 virtual void HandleMessage(const pp::Var& message_data) { 95 if (message_data.is_string()) { 96 std::string event = message_data.AsString(); 97 if (event == "PageInitialized") { 98 int32_t result = device_detector_.MonitorDeviceChange( 99 &MyInstance::MonitorDeviceChangeCallback, this); 100 if (result != PP_OK) 101 PostMessage(pp::Var("MonitorDeviceChangeFailed")); 102 103 pp::CompletionCallbackWithOutput<std::vector<pp::DeviceRef_Dev> > 104 callback = callback_factory_.NewCallbackWithOutput( 105 &MyInstance::EnumerateDevicesFinished); 106 result = device_detector_.EnumerateDevices(callback); 107 if (result != PP_OK_COMPLETIONPENDING) 108 PostMessage(pp::Var("EnumerationFailed")); 109 } else if (event == "UseDefault") { 110 Open(pp::DeviceRef_Dev()); 111 } else if (event == "Stop") { 112 Stop(); 113 } else if (event == "Start") { 114 Start(); 115 } else if (event.find("Monitor:") == 0) { 116 std::string index_str = event.substr(strlen("Monitor:")); 117 int index = atoi(index_str.c_str()); 118 if (index >= 0 && index < static_cast<int>(monitor_devices_.size())) 119 Open(monitor_devices_[index]); 120 else 121 PP_NOTREACHED(); 122 } else if (event.find("Enumerate:") == 0) { 123 std::string index_str = event.substr(strlen("Enumerate:")); 124 int index = atoi(index_str.c_str()); 125 if (index >= 0 && index < static_cast<int>(enumerate_devices_.size())) 126 Open(enumerate_devices_[index]); 127 else 128 PP_NOTREACHED(); 129 } 130 } 131 } 132 133 private: 134 void ScheduleNextTimer() { 135 PP_DCHECK(timer_interval_ > 0); 136 pp::Module::Get()->core()->CallOnMainThread( 137 timer_interval_, 138 callback_factory_.NewCallback(&MyInstance::OnTimer), 139 0); 140 } 141 142 void OnTimer(int32_t) { 143 ScheduleNextTimer(); 144 Paint(); 145 } 146 147 void DidFlush(int32_t result) { 148 waiting_for_flush_completion_ = false; 149 if (pending_paint_) 150 Paint(); 151 } 152 153 void Paint() { 154 if (waiting_for_flush_completion_) { 155 pending_paint_ = true; 156 return; 157 } 158 159 pending_paint_ = false; 160 161 if (size_.IsEmpty()) 162 return; // Nothing to do. 163 164 pp::ImageData image = PaintImage(size_); 165 if (!image.is_null()) { 166 device_context_.ReplaceContents(&image); 167 waiting_for_flush_completion_ = true; 168 device_context_.Flush( 169 callback_factory_.NewCallback(&MyInstance::DidFlush)); 170 } 171 } 172 173 pp::ImageData PaintImage(const pp::Size& size) { 174 pp::ImageData image(this, PP_IMAGEDATAFORMAT_BGRA_PREMUL, size, false); 175 if (image.is_null()) 176 return image; 177 178 // Clear to dark grey. 179 for (int y = 0; y < size.height(); y++) { 180 for (int x = 0; x < size.width(); x++) 181 *image.GetAddr32(pp::Point(x, y)) = 0xff202020; 182 } 183 184 int mid_height = size.height() / 2; 185 int max_amplitude = size.height() * 4 / 10; 186 187 // Draw some lines. 188 for (int x = 0; x < size.width(); x++) { 189 *image.GetAddr32(pp::Point(x, mid_height)) = 0xff606060; 190 *image.GetAddr32(pp::Point(x, mid_height + max_amplitude)) = 0xff404040; 191 *image.GetAddr32(pp::Point(x, mid_height - max_amplitude)) = 0xff404040; 192 } 193 194 { 195 pp::AutoLock auto_lock(lock_); 196 197 // Draw the latency as a red bar at the bottom. 198 PP_DCHECK(latency_ >= 0); 199 int latency_bar_length = 200 latency_ < 1 ? size.width() * latency_ : size.width(); 201 for (int x = 0; x < latency_bar_length; ++x) { 202 *image.GetAddr32(pp::Point(x, mid_height + max_amplitude)) = 0xffff0000; 203 } 204 205 // Draw our samples. 206 for (int x = 0, i = 0; 207 x < std::min(size.width(), static_cast<int>(sample_count_)); 208 x++, i += channel_count_) { 209 int y = samples_[i] * max_amplitude / 210 (std::numeric_limits<int16_t>::max() + 1) + mid_height; 211 *image.GetAddr32(pp::Point(x, y)) = 0xffffffff; 212 } 213 } 214 215 return image; 216 } 217 218 void Open(const pp::DeviceRef_Dev& device) { 219 audio_input_.Close(); 220 audio_input_ = pp::AudioInput_Dev(this); 221 222 pp::AudioConfig config = pp::AudioConfig(this, 223 kSampleFrequency, 224 sample_count_); 225 pp::CompletionCallback callback = callback_factory_.NewCallback( 226 &MyInstance::OpenFinished); 227 int32_t result = audio_input_.Open(device, config, CaptureCallback, this, 228 callback); 229 if (result != PP_OK_COMPLETIONPENDING) 230 PostMessage(pp::Var("OpenFailed")); 231 } 232 233 void Stop() { 234 if (!audio_input_.StopCapture()) 235 PostMessage(pp::Var("StopFailed")); 236 } 237 238 void Start() { 239 if (!audio_input_.StartCapture()) 240 PostMessage(pp::Var("StartFailed")); 241 } 242 243 void EnumerateDevicesFinished(int32_t result, 244 std::vector<pp::DeviceRef_Dev>& devices) { 245 if (result == PP_OK) { 246 enumerate_devices_.swap(devices); 247 std::string device_names = "Enumerate:"; 248 for (size_t index = 0; index < enumerate_devices_.size(); ++index) { 249 pp::Var name = enumerate_devices_[index].GetName(); 250 PP_DCHECK(name.is_string()); 251 252 if (index != 0) 253 device_names += kDelimiter; 254 device_names += name.AsString(); 255 } 256 PostMessage(pp::Var(device_names)); 257 } else { 258 PostMessage(pp::Var("EnumerationFailed")); 259 } 260 } 261 262 void OpenFinished(int32_t result) { 263 if (result == PP_OK) { 264 if (!audio_input_.StartCapture()) 265 PostMessage(pp::Var("StartFailed")); 266 } else { 267 PostMessage(pp::Var("OpenFailed")); 268 } 269 } 270 271 static void CaptureCallback(const void* samples, 272 uint32_t num_bytes, 273 PP_TimeDelta latency, 274 void* ctx) { 275 MyInstance* thiz = static_cast<MyInstance*>(ctx); 276 pp::AutoLock auto_lock(thiz->lock_); 277 thiz->latency_ = latency; 278 uint32_t buffer_size = 279 thiz->sample_count_ * thiz->channel_count_ * sizeof(int16_t); 280 PP_DCHECK(num_bytes <= buffer_size); 281 PP_DCHECK(num_bytes % (thiz->channel_count_ * sizeof(int16_t)) == 0); 282 memcpy(thiz->samples_, samples, num_bytes); 283 memset(reinterpret_cast<char*>(thiz->samples_) + num_bytes, 0, 284 buffer_size - num_bytes); 285 } 286 287 static void MonitorDeviceChangeCallback(void* user_data, 288 uint32_t device_count, 289 const PP_Resource devices[]) { 290 MyInstance* thiz = static_cast<MyInstance*>(user_data); 291 292 std::string device_names = "Monitor:"; 293 thiz->monitor_devices_.clear(); 294 thiz->monitor_devices_.reserve(device_count); 295 for (size_t index = 0; index < device_count; ++index) { 296 thiz->monitor_devices_.push_back(pp::DeviceRef_Dev(devices[index])); 297 pp::Var name = thiz->monitor_devices_.back().GetName(); 298 PP_DCHECK(name.is_string()); 299 300 if (index != 0) 301 device_names += kDelimiter; 302 device_names += name.AsString(); 303 } 304 thiz->PostMessage(pp::Var(device_names)); 305 } 306 307 pp::CompletionCallbackFactory<MyInstance> callback_factory_; 308 309 uint32_t sample_count_; 310 uint32_t channel_count_; 311 int16_t* samples_; 312 313 PP_TimeDelta latency_; 314 315 int32_t timer_interval_; 316 317 // Painting stuff. 318 pp::Size size_; 319 pp::Graphics2D device_context_; 320 bool pending_paint_; 321 bool waiting_for_flush_completion_; 322 323 // There is no need to have two resources to do capturing and device detecting 324 // separately. However, this makes the code of monitoring device change 325 // easier. 326 pp::AudioInput_Dev audio_input_; 327 pp::AudioInput_Dev device_detector_; 328 329 std::vector<pp::DeviceRef_Dev> enumerate_devices_; 330 std::vector<pp::DeviceRef_Dev> monitor_devices_; 331 332 // Protects |samples_| and |latency_|. 333 pp::Lock lock_; 334 }; 335 336 class MyModule : public pp::Module { 337 public: 338 virtual pp::Instance* CreateInstance(PP_Instance instance) { 339 return new MyInstance(instance); 340 } 341 }; 342 343 namespace pp { 344 345 // Factory function for your specialization of the Module object. 346 Module* CreateModule() { 347 return new MyModule(); 348 } 349 350 } // namespace pp 351