ppapi/examples/audio_input/audio_input.cc - chromium/src - Git at Google

 // 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
	// 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