ppapi/examples/audio_input/audio_input.cc

   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 = latency_ < 1 ?
 200           static_cast<int>(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