| // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include <stddef.h> |
| #include <stdint.h> |
| #include <stdlib.h> |
| #include <string.h> |
| |
| #include <algorithm> |
| #include <limits> |
| #include <vector> |
| |
| #include "ppapi/cpp/audio_config.h" |
| #include "ppapi/cpp/dev/audio_input_dev.h" |
| #include "ppapi/cpp/dev/device_ref_dev.h" |
| #include "ppapi/cpp/graphics_2d.h" |
| #include "ppapi/cpp/image_data.h" |
| #include "ppapi/cpp/instance.h" |
| #include "ppapi/cpp/logging.h" |
| #include "ppapi/cpp/module.h" |
| #include "ppapi/cpp/rect.h" |
| #include "ppapi/cpp/size.h" |
| #include "ppapi/utility/completion_callback_factory.h" |
| #include "ppapi/utility/threading/lock.h" |
| |
| // When compiling natively on Windows, PostMessage can be #define-d to |
| // something else. |
| #ifdef PostMessage |
| #undef PostMessage |
| #endif |
| |
| namespace { |
| |
| // This sample frequency is guaranteed to work. |
| const PP_AudioSampleRate kSampleFrequency = PP_AUDIOSAMPLERATE_44100; |
| const uint32_t kSampleCount = 1024; |
| const uint32_t kChannelCount = 1; |
| const char* const kDelimiter = "#__#"; |
| |
| } // namespace |
| |
| class MyInstance : public pp::Instance { |
| public: |
| explicit MyInstance(PP_Instance instance) |
| : pp::Instance(instance), |
| callback_factory_(this), |
| sample_count_(0), |
| channel_count_(0), |
| samples_(NULL), |
| latency_(0), |
| timer_interval_(0), |
| pending_paint_(false), |
| waiting_for_flush_completion_(false) { |
| } |
| virtual ~MyInstance() { |
| device_detector_.MonitorDeviceChange(NULL, NULL); |
| audio_input_.Close(); |
| |
| // The audio input thread has exited before the previous call returned, so |
| // it is safe to do so now. |
| delete[] samples_; |
| } |
| |
| virtual bool Init(uint32_t argc, const char* argn[], const char* argv[]) { |
| sample_count_ = pp::AudioConfig::RecommendSampleFrameCount(this, |
| kSampleFrequency, |
| kSampleCount); |
| PP_DCHECK(sample_count_ > 0); |
| channel_count_ = kChannelCount; |
| samples_ = new int16_t[sample_count_ * channel_count_]; |
| memset(samples_, 0, sample_count_ * channel_count_ * sizeof(int16_t)); |
| |
| device_detector_ = pp::AudioInput_Dev(this); |
| |
| // Try to ensure that we pick up a new set of samples between each |
| // timer-generated repaint. |
| timer_interval_ = (sample_count_ * 1000) / kSampleFrequency + 5; |
| ScheduleNextTimer(); |
| |
| return true; |
| } |
| |
| virtual void DidChangeView(const pp::Rect& position, const pp::Rect& clip) { |
| if (position.size() == size_) |
| return; |
| |
| size_ = position.size(); |
| device_context_ = pp::Graphics2D(this, size_, false); |
| if (!BindGraphics(device_context_)) |
| return; |
| |
| Paint(); |
| } |
| |
| virtual void HandleMessage(const pp::Var& message_data) { |
| if (message_data.is_string()) { |
| std::string event = message_data.AsString(); |
| if (event == "PageInitialized") { |
| int32_t result = device_detector_.MonitorDeviceChange( |
| &MyInstance::MonitorDeviceChangeCallback, this); |
| if (result != PP_OK) |
| PostMessage(pp::Var("MonitorDeviceChangeFailed")); |
| |
| pp::CompletionCallbackWithOutput<std::vector<pp::DeviceRef_Dev> > |
| callback = callback_factory_.NewCallbackWithOutput( |
| &MyInstance::EnumerateDevicesFinished); |
| result = device_detector_.EnumerateDevices(callback); |
| if (result != PP_OK_COMPLETIONPENDING) |
| PostMessage(pp::Var("EnumerationFailed")); |
| } else if (event == "UseDefault") { |
| Open(pp::DeviceRef_Dev()); |
| } else if (event == "Stop") { |
| Stop(); |
| } else if (event == "Start") { |
| Start(); |
| } else if (event.find("Monitor:") == 0) { |
| std::string index_str = event.substr(strlen("Monitor:")); |
| int index = atoi(index_str.c_str()); |
| if (index >= 0 && index < static_cast<int>(monitor_devices_.size())) |
| Open(monitor_devices_[index]); |
| else |
| PP_NOTREACHED(); |
| } else if (event.find("Enumerate:") == 0) { |
| std::string index_str = event.substr(strlen("Enumerate:")); |
| int index = atoi(index_str.c_str()); |
| if (index >= 0 && index < static_cast<int>(enumerate_devices_.size())) |
| Open(enumerate_devices_[index]); |
| else |
| PP_NOTREACHED(); |
| } |
| } |
| } |
| |
| private: |
| void ScheduleNextTimer() { |
| PP_DCHECK(timer_interval_ > 0); |
| pp::Module::Get()->core()->CallOnMainThread( |
| timer_interval_, |
| callback_factory_.NewCallback(&MyInstance::OnTimer), |
| 0); |
| } |
| |
| void OnTimer(int32_t) { |
| ScheduleNextTimer(); |
| Paint(); |
| } |
| |
| void DidFlush(int32_t result) { |
| waiting_for_flush_completion_ = false; |
| if (pending_paint_) |
| Paint(); |
| } |
| |
| void Paint() { |
| if (waiting_for_flush_completion_) { |
| pending_paint_ = true; |
| return; |
| } |
| |
| pending_paint_ = false; |
| |
| if (size_.IsEmpty()) |
| return; // Nothing to do. |
| |
| pp::ImageData image = PaintImage(size_); |
| if (!image.is_null()) { |
| device_context_.ReplaceContents(&image); |
| waiting_for_flush_completion_ = true; |
| device_context_.Flush( |
| callback_factory_.NewCallback(&MyInstance::DidFlush)); |
| } |
| } |
| |
| pp::ImageData PaintImage(const pp::Size& size) { |
| pp::ImageData image(this, PP_IMAGEDATAFORMAT_BGRA_PREMUL, size, false); |
| if (image.is_null()) |
| return image; |
| |
| // Clear to dark grey. |
| for (int y = 0; y < size.height(); y++) { |
| for (int x = 0; x < size.width(); x++) |
| *image.GetAddr32(pp::Point(x, y)) = 0xff202020; |
| } |
| |
| int mid_height = size.height() / 2; |
| int max_amplitude = size.height() * 4 / 10; |
| |
| // Draw some lines. |
| for (int x = 0; x < size.width(); x++) { |
| *image.GetAddr32(pp::Point(x, mid_height)) = 0xff606060; |
| *image.GetAddr32(pp::Point(x, mid_height + max_amplitude)) = 0xff404040; |
| *image.GetAddr32(pp::Point(x, mid_height - max_amplitude)) = 0xff404040; |
| } |
| |
| { |
| pp::AutoLock auto_lock(lock_); |
| |
| // Draw the latency as a red bar at the bottom. |
| PP_DCHECK(latency_ >= 0); |
| int latency_bar_length = latency_ < 1 ? |
| static_cast<int>(size.width() * latency_) : size.width(); |
| for (int x = 0; x < latency_bar_length; ++x) { |
| *image.GetAddr32(pp::Point(x, mid_height + max_amplitude)) = 0xffff0000; |
| } |
| |
| // Draw our samples. |
| for (int x = 0, i = 0; |
| x < std::min(size.width(), static_cast<int>(sample_count_)); |
| x++, i += channel_count_) { |
| int y = samples_[i] * max_amplitude / |
| (std::numeric_limits<int16_t>::max() + 1) + mid_height; |
| *image.GetAddr32(pp::Point(x, y)) = 0xffffffff; |
| } |
| } |
| |
| return image; |
| } |
| |
| void Open(const pp::DeviceRef_Dev& device) { |
| audio_input_.Close(); |
| audio_input_ = pp::AudioInput_Dev(this); |
| |
| pp::AudioConfig config = pp::AudioConfig(this, |
| kSampleFrequency, |
| sample_count_); |
| pp::CompletionCallback callback = callback_factory_.NewCallback( |
| &MyInstance::OpenFinished); |
| int32_t result = audio_input_.Open(device, config, CaptureCallback, this, |
| callback); |
| if (result != PP_OK_COMPLETIONPENDING) |
| PostMessage(pp::Var("OpenFailed")); |
| } |
| |
| void Stop() { |
| if (!audio_input_.StopCapture()) |
| PostMessage(pp::Var("StopFailed")); |
| } |
| |
| void Start() { |
| if (!audio_input_.StartCapture()) |
| PostMessage(pp::Var("StartFailed")); |
| } |
| |
| void EnumerateDevicesFinished(int32_t result, |
| std::vector<pp::DeviceRef_Dev>& devices) { |
| if (result == PP_OK) { |
| enumerate_devices_.swap(devices); |
| std::string device_names = "Enumerate:"; |
| for (size_t index = 0; index < enumerate_devices_.size(); ++index) { |
| pp::Var name = enumerate_devices_[index].GetName(); |
| PP_DCHECK(name.is_string()); |
| |
| if (index != 0) |
| device_names += kDelimiter; |
| device_names += name.AsString(); |
| } |
| PostMessage(pp::Var(device_names)); |
| } else { |
| PostMessage(pp::Var("EnumerationFailed")); |
| } |
| } |
| |
| void OpenFinished(int32_t result) { |
| if (result == PP_OK) { |
| if (!audio_input_.StartCapture()) |
| PostMessage(pp::Var("StartFailed")); |
| } else { |
| PostMessage(pp::Var("OpenFailed")); |
| } |
| } |
| |
| static void CaptureCallback(const void* samples, |
| uint32_t num_bytes, |
| PP_TimeDelta latency, |
| void* ctx) { |
| MyInstance* thiz = static_cast<MyInstance*>(ctx); |
| pp::AutoLock auto_lock(thiz->lock_); |
| thiz->latency_ = latency; |
| uint32_t buffer_size = |
| thiz->sample_count_ * thiz->channel_count_ * sizeof(int16_t); |
| PP_DCHECK(num_bytes <= buffer_size); |
| PP_DCHECK(num_bytes % (thiz->channel_count_ * sizeof(int16_t)) == 0); |
| memcpy(thiz->samples_, samples, num_bytes); |
| memset(reinterpret_cast<char*>(thiz->samples_) + num_bytes, 0, |
| buffer_size - num_bytes); |
| } |
| |
| static void MonitorDeviceChangeCallback(void* user_data, |
| uint32_t device_count, |
| const PP_Resource devices[]) { |
| MyInstance* thiz = static_cast<MyInstance*>(user_data); |
| |
| std::string device_names = "Monitor:"; |
| thiz->monitor_devices_.clear(); |
| thiz->monitor_devices_.reserve(device_count); |
| for (size_t index = 0; index < device_count; ++index) { |
| thiz->monitor_devices_.push_back(pp::DeviceRef_Dev(devices[index])); |
| pp::Var name = thiz->monitor_devices_.back().GetName(); |
| PP_DCHECK(name.is_string()); |
| |
| if (index != 0) |
| device_names += kDelimiter; |
| device_names += name.AsString(); |
| } |
| thiz->PostMessage(pp::Var(device_names)); |
| } |
| |
| pp::CompletionCallbackFactory<MyInstance> callback_factory_; |
| |
| uint32_t sample_count_; |
| uint32_t channel_count_; |
| int16_t* samples_; |
| |
| PP_TimeDelta latency_; |
| |
| int32_t timer_interval_; |
| |
| // Painting stuff. |
| pp::Size size_; |
| pp::Graphics2D device_context_; |
| bool pending_paint_; |
| bool waiting_for_flush_completion_; |
| |
| // There is no need to have two resources to do capturing and device detecting |
| // separately. However, this makes the code of monitoring device change |
| // easier. |
| pp::AudioInput_Dev audio_input_; |
| pp::AudioInput_Dev device_detector_; |
| |
| std::vector<pp::DeviceRef_Dev> enumerate_devices_; |
| std::vector<pp::DeviceRef_Dev> monitor_devices_; |
| |
| // Protects |samples_| and |latency_|. |
| pp::Lock lock_; |
| }; |
| |
| class MyModule : public pp::Module { |
| public: |
| virtual pp::Instance* CreateInstance(PP_Instance instance) { |
| return new MyInstance(instance); |
| } |
| }; |
| |
| namespace pp { |
| |
| // Factory function for your specialization of the Module object. |
| Module* CreateModule() { |
| return new MyModule(); |
| } |
| |
| } // namespace pp |