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

 // Copyright 2015 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 <stdint.h>
 #include <stdlib.h>
 #include <string.h>

 #include <map>
 #include <string>
 #include <vector>

 #include "ppapi/cpp/audio_buffer.h"
 #include "ppapi/cpp/audio_encoder.h"
 #include "ppapi/cpp/instance.h"
 #include "ppapi/cpp/logging.h"
 #include "ppapi/cpp/media_stream_audio_track.h"
 #include "ppapi/cpp/module.h"
 #include "ppapi/cpp/var_array_buffer.h"
 #include "ppapi/cpp/var_dictionary.h"
 #include "ppapi/utility/completion_callback_factory.h"

 // When compiling natively on Windows, PostMessage can be #define-d to
 // something else.
 #ifdef PostMessage
 #undef PostMessage
 #endif

 // This example demonstrates receiving audio samples from an audio
 // track and encoding them.

 namespace {

 class AudioEncoderInstance : public pp::Instance {
  public:
   explicit AudioEncoderInstance(PP_Instance instance);
   virtual ~AudioEncoderInstance();

  private:
   // pp::Instance implementation.
   virtual void HandleMessage(const pp::Var& var_message);

   std::string ProfileToString(PP_AudioProfile profile);

   void GetSupportedProfiles();
   void OnGetSupportedProfiles(
       int32_t result,
       const std::vector<PP_AudioProfileDescription> profiles);

   void StartAudioTrack(const pp::Resource& resource_track);
   void StopAudioTrack();
   void OnGetBuffer(int32_t result, pp::AudioBuffer buffer);

   void InitializeEncoder();
   void OnEncoderInitialized(int32_t result);
   void OnAudioTrackConfigured(int32_t result);
   void GetEncoderBuffer(const pp::AudioBuffer& track_buffer);
   void OnGetEncoderBuffer(int32_t result,
                           pp::AudioBuffer buffer,
                           pp::AudioBuffer track_buffer);
   void OnEncodeDone(int32_t result);
   void OnGetBitstreamBuffer(int32_t result,
                             const PP_AudioBitstreamBuffer& buffer);

   pp::VarDictionary NewCommand(const std::string& type);

   void Log(const std::string& message);
   void LogError(int32_t error, const std::string& message);

   void PostAudioFormat();
   void PostDataMessage(const void* data, uint32_t size);

   pp::CompletionCallbackFactory<AudioEncoderInstance> callback_factory_;

   // Set when the plugin is not performing any encoding and just passing the
   // uncompressed data directly to web page.
   bool no_encoding_;

   uint32_t channels_;
   uint32_t sample_rate_;
   uint32_t sample_size_;
   uint32_t samples_per_frame_;

   pp::MediaStreamAudioTrack audio_track_;
   pp::AudioEncoder audio_encoder_;
 };

 AudioEncoderInstance::AudioEncoderInstance(PP_Instance instance)
     : pp::Instance(instance),
       callback_factory_(this),
       no_encoding_(true),
       channels_(0),
       sample_rate_(0),
       sample_size_(0),
       samples_per_frame_(0),
       audio_encoder_(this) {
   GetSupportedProfiles();
 }

 AudioEncoderInstance::~AudioEncoderInstance() {}

 void AudioEncoderInstance::HandleMessage(const pp::Var& var_message) {
   if (!var_message.is_dictionary()) {
     LogError(PP_ERROR_FAILED,
              "Cannot handle incoming message, not a dictionary");
     return;
   }

   pp::VarDictionary dict_message(var_message);
   std::string command = dict_message.Get("command").AsString();

   if (command == "start") {
     pp::Var var_track = dict_message.Get("track");
     if (!var_track.is_resource()) {
       LogError(PP_ERROR_FAILED, "Given track is not a resource");
       return;
     }
     std::string profile = dict_message.Get("profile").AsString();
     if (profile == "wav") {
       no_encoding_ = true;
     } else {
       no_encoding_ = false;
     }
     StartAudioTrack(var_track.AsResource());
   } else if (command == "stop") {
     StopAudioTrack();
   } else {
     LogError(PP_ERROR_FAILED, "Invalid command");
   }
 }

 std::string AudioEncoderInstance::ProfileToString(PP_AudioProfile profile) {
   if (profile == PP_AUDIOPROFILE_OPUS)
     return "opus";
   return "unknown";
 }

 void AudioEncoderInstance::GetSupportedProfiles() {
   audio_encoder_.GetSupportedProfiles(callback_factory_.NewCallbackWithOutput(
       &AudioEncoderInstance::OnGetSupportedProfiles));
 }

 void AudioEncoderInstance::OnGetSupportedProfiles(
     int32_t result,
     const std::vector<PP_AudioProfileDescription> profiles) {
   pp::VarDictionary dictionary = NewCommand("supportedProfiles");
   pp::VarArray js_profiles;
   dictionary.Set(pp::Var("profiles"), js_profiles);

   if (result < 0) {
     LogError(result, "Cannot get supported profiles");
     PostMessage(dictionary);
   }

   int32_t idx = 0;
   for (std::vector<PP_AudioProfileDescription>::const_iterator it =
            profiles.begin();
        it != profiles.end(); ++it) {
     pp::VarDictionary js_profile;
     js_profile.Set(pp::Var("name"), pp::Var(ProfileToString(it->profile)));
     js_profile.Set(pp::Var("sample_size"),
                    pp::Var(static_cast<int32_t>(it->sample_size)));
     js_profile.Set(pp::Var("sample_rate"),
                    pp::Var(static_cast<int32_t>(it->sample_rate)));
     js_profiles.Set(idx++, js_profile);
   }
   PostMessage(dictionary);
 }

 void AudioEncoderInstance::StartAudioTrack(const pp::Resource& resource_track) {
   audio_track_ = pp::MediaStreamAudioTrack(resource_track);
   audio_track_.GetBuffer(callback_factory_.NewCallbackWithOutput(
       &AudioEncoderInstance::OnGetBuffer));
 }

 void AudioEncoderInstance::StopAudioTrack() {
   channels_ = 0;
   audio_track_.Close();
   audio_track_ = pp::MediaStreamAudioTrack();
   audio_encoder_.Close();
   audio_encoder_ = pp::AudioEncoder();
 }

 void AudioEncoderInstance::OnGetBuffer(int32_t result, pp::AudioBuffer buffer) {
   if (result == PP_ERROR_ABORTED)
     return;
   if (result != PP_OK) {
     LogError(result, "Cannot get audio track buffer");
     return;
   }

   // If this is the first buffer, then we need to initialize the encoder.
   if (channels_ == 0) {
     channels_ = buffer.GetNumberOfChannels();
     sample_rate_ = buffer.GetSampleRate();
     sample_size_ = buffer.GetSampleSize();
     samples_per_frame_ = buffer.GetNumberOfSamples();

     if (no_encoding_) {
       PostAudioFormat();
       PostDataMessage(buffer.GetDataBuffer(), buffer.GetDataBufferSize());
       audio_track_.GetBuffer(callback_factory_.NewCallbackWithOutput(
           &AudioEncoderInstance::OnGetBuffer));
     } else {
       InitializeEncoder();
     }

     // Given that once the encoder is initialized we might reconfigure the
     // media track, we discard the first buffer to keep this example a bit
     // simpler.
     audio_track_.RecycleBuffer(buffer);
   } else {
     if (no_encoding_) {
       PostDataMessage(buffer.GetDataBuffer(), buffer.GetDataBufferSize());
       audio_track_.RecycleBuffer(buffer);
     } else {
       GetEncoderBuffer(buffer);
     }

     audio_track_.GetBuffer(callback_factory_.NewCallbackWithOutput(
         &AudioEncoderInstance::OnGetBuffer));
   }
 }

 void AudioEncoderInstance::InitializeEncoder() {
   if (audio_encoder_.is_null())
     audio_encoder_ = pp::AudioEncoder(this);
   audio_encoder_.Initialize(
       channels_, static_cast<PP_AudioBuffer_SampleRate>(sample_rate_),
       static_cast<PP_AudioBuffer_SampleSize>(sample_size_),
       PP_AUDIOPROFILE_OPUS, 100000, PP_HARDWAREACCELERATION_WITHFALLBACK,
       callback_factory_.NewCallback(
           &AudioEncoderInstance::OnEncoderInitialized));
 }

 void AudioEncoderInstance::OnEncoderInitialized(int32_t result) {
   if (result == PP_ERROR_ABORTED)
     return;
   if (result != PP_OK) {
     LogError(result, "Cannot initialize encoder");
     return;
   }

   int32_t attribs[] = {
       // Duration in milliseconds.
       PP_MEDIASTREAMAUDIOTRACK_ATTRIB_DURATION,
       1000 / (sample_rate_ / audio_encoder_.GetNumberOfSamples()),
       PP_MEDIASTREAMAUDIOTRACK_ATTRIB_NONE};
   audio_track_.Configure(attribs,
                          callback_factory_.NewCallback(
                              &AudioEncoderInstance::OnAudioTrackConfigured));

   samples_per_frame_ = audio_encoder_.GetNumberOfSamples();
   PostAudioFormat();
 }

 void AudioEncoderInstance::OnAudioTrackConfigured(int32_t result) {
   if (result == PP_ERROR_ABORTED)
     return;
   if (result != PP_OK) {
     LogError(result, "Cannot configure audio track buffer duration");
     return;
   }

   audio_track_.GetBuffer(callback_factory_.NewCallbackWithOutput(
       &AudioEncoderInstance::OnGetBuffer));
   audio_encoder_.GetBitstreamBuffer(callback_factory_.NewCallbackWithOutput(
       &AudioEncoderInstance::OnGetBitstreamBuffer));
 }

 void AudioEncoderInstance::GetEncoderBuffer(
     const pp::AudioBuffer& track_buffer) {
   audio_encoder_.GetBuffer(callback_factory_.NewCallbackWithOutput(
       &AudioEncoderInstance::OnGetEncoderBuffer, track_buffer));
 }

 void AudioEncoderInstance::OnGetEncoderBuffer(int32_t result,
                                               pp::AudioBuffer buffer,
                                               pp::AudioBuffer track_buffer) {
   const char* error(nullptr);

   if (result != PP_OK)
     error = "Cannot get encoder buffer";
   if (buffer.GetDataBufferSize() != track_buffer.GetDataBufferSize()) {
     result = PP_ERROR_FAILED;
     error = "Invalid buffer size";
   }

   if (result == PP_OK) {
     memcpy(buffer.GetDataBuffer(), track_buffer.GetDataBuffer(),
            buffer.GetDataBufferSize());
     audio_encoder_.Encode(buffer, callback_factory_.NewCallback(
                                       &AudioEncoderInstance::OnEncodeDone));
   } else {
     LogError(result, error);
     StopAudioTrack();
   }
   audio_track_.RecycleBuffer(track_buffer);
 }

 void AudioEncoderInstance::OnEncodeDone(int32_t result) {}

 void AudioEncoderInstance::OnGetBitstreamBuffer(
     int32_t result,
     const PP_AudioBitstreamBuffer& buffer) {
   if (result == PP_ERROR_ABORTED)
     return;
   if (result != PP_OK) {
     LogError(result, "Cannot get bitstream buffer");
     return;
   }

   audio_encoder_.GetBitstreamBuffer(callback_factory_.NewCallbackWithOutput(
       &AudioEncoderInstance::OnGetBitstreamBuffer));

   PostDataMessage(buffer.buffer, buffer.size);
   audio_encoder_.RecycleBitstreamBuffer(buffer);
 }

 pp::VarDictionary AudioEncoderInstance::NewCommand(const std::string& type) {
   pp::VarDictionary dictionary;
   dictionary.Set(pp::Var("command"), pp::Var(type));
   return dictionary;
 }

 void AudioEncoderInstance::Log(const std::string& message) {
   pp::VarDictionary dictionary = NewCommand("log");
   dictionary.Set(pp::Var("message"), pp::Var(message));
   PostMessage(dictionary);
 }

 void AudioEncoderInstance::LogError(int32_t error, const std::string& message) {
   pp::VarDictionary dictionary = NewCommand("error");
   std::string msg("Error: ");
   msg.append(message);
   msg.append(" : ");
   msg.append(pp::Var(error).DebugString());
   dictionary.Set(pp::Var("message"), pp::Var(msg));
   PostMessage(dictionary);
 }

 void AudioEncoderInstance::PostAudioFormat() {
   pp::VarDictionary dictionary = NewCommand("format");
   dictionary.Set(pp::Var("channels"), pp::Var(static_cast<int32_t>(channels_)));
   dictionary.Set(pp::Var("sample_rate"),
                  pp::Var(static_cast<int32_t>(sample_rate_)));
   dictionary.Set(pp::Var("sample_size"),
                  pp::Var(static_cast<int32_t>(sample_size_)));
   dictionary.Set(pp::Var("sample_per_frame"),
                  pp::Var(static_cast<int32_t>(samples_per_frame_)));
   PostMessage(dictionary);
 }

 void AudioEncoderInstance::PostDataMessage(const void* data, uint32_t size) {
   pp::VarDictionary dictionary = NewCommand("data");
   uint8_t* buffer;

   pp::VarArrayBuffer array_buffer = pp::VarArrayBuffer(size);
   buffer = static_cast<uint8_t*>(array_buffer.Map());
   memcpy(buffer, data, size);
   array_buffer.Unmap();

   dictionary.Set(pp::Var("buffer"), array_buffer);

   PostMessage(dictionary);
 }

 class AudioEncoderModule : public pp::Module {
  public:
   virtual pp::Instance* CreateInstance(PP_Instance instance) {
     return new AudioEncoderInstance(instance);
   }
 };

 }  // namespace

 namespace pp {

 // Factory function for your specialization of the Module object.
 Module* CreateModule() {
   return new AudioEncoderModule();
 }

 }  // namespace pp
	// Copyright 2015 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 <stdint.h>
	#include <stdlib.h>
	#include <string.h>

	#include <map>
	#include <string>
	#include <vector>

	#include "ppapi/cpp/audio_buffer.h"
	#include "ppapi/cpp/audio_encoder.h"
	#include "ppapi/cpp/instance.h"
	#include "ppapi/cpp/logging.h"
	#include "ppapi/cpp/media_stream_audio_track.h"
	#include "ppapi/cpp/module.h"
	#include "ppapi/cpp/var_array_buffer.h"
	#include "ppapi/cpp/var_dictionary.h"
	#include "ppapi/utility/completion_callback_factory.h"

	// When compiling natively on Windows, PostMessage can be #define-d to
	// something else.
	#ifdef PostMessage
	#undef PostMessage
	#endif

	// This example demonstrates receiving audio samples from an audio
	// track and encoding them.

	namespace {

	class AudioEncoderInstance : public pp::Instance {
	public:
	explicit AudioEncoderInstance(PP_Instance instance);
	virtual ~AudioEncoderInstance();

	private:
	// pp::Instance implementation.
	virtual void HandleMessage(const pp::Var& var_message);

	std::string ProfileToString(PP_AudioProfile profile);

	void GetSupportedProfiles();
	void OnGetSupportedProfiles(
	int32_t result,
	const std::vector<PP_AudioProfileDescription> profiles);

	void StartAudioTrack(const pp::Resource& resource_track);
	void StopAudioTrack();
	void OnGetBuffer(int32_t result, pp::AudioBuffer buffer);

	void InitializeEncoder();
	void OnEncoderInitialized(int32_t result);
	void OnAudioTrackConfigured(int32_t result);
	void GetEncoderBuffer(const pp::AudioBuffer& track_buffer);
	void OnGetEncoderBuffer(int32_t result,
	pp::AudioBuffer buffer,
	pp::AudioBuffer track_buffer);
	void OnEncodeDone(int32_t result);
	void OnGetBitstreamBuffer(int32_t result,
	const PP_AudioBitstreamBuffer& buffer);

	pp::VarDictionary NewCommand(const std::string& type);

	void Log(const std::string& message);
	void LogError(int32_t error, const std::string& message);

	void PostAudioFormat();
	void PostDataMessage(const void* data, uint32_t size);

	pp::CompletionCallbackFactory<AudioEncoderInstance> callback_factory_;

	// Set when the plugin is not performing any encoding and just passing the
	// uncompressed data directly to web page.
	bool no_encoding_;

	uint32_t channels_;
	uint32_t sample_rate_;
	uint32_t sample_size_;
	uint32_t samples_per_frame_;

	pp::MediaStreamAudioTrack audio_track_;
	pp::AudioEncoder audio_encoder_;
	};

	AudioEncoderInstance::AudioEncoderInstance(PP_Instance instance)
	: pp::Instance(instance),
	callback_factory_(this),
	no_encoding_(true),
	channels_(0),
	sample_rate_(0),
	sample_size_(0),
	samples_per_frame_(0),
	audio_encoder_(this) {
	GetSupportedProfiles();
	}

	AudioEncoderInstance::~AudioEncoderInstance() {}

	void AudioEncoderInstance::HandleMessage(const pp::Var& var_message) {
	if (!var_message.is_dictionary()) {
	LogError(PP_ERROR_FAILED,
	"Cannot handle incoming message, not a dictionary");
	return;
	}

	pp::VarDictionary dict_message(var_message);
	std::string command = dict_message.Get("command").AsString();

	if (command == "start") {
	pp::Var var_track = dict_message.Get("track");
	if (!var_track.is_resource()) {
	LogError(PP_ERROR_FAILED, "Given track is not a resource");
	return;
	}
	std::string profile = dict_message.Get("profile").AsString();
	if (profile == "wav") {
	no_encoding_ = true;
	} else {
	no_encoding_ = false;
	}
	StartAudioTrack(var_track.AsResource());
	} else if (command == "stop") {
	StopAudioTrack();
	} else {
	LogError(PP_ERROR_FAILED, "Invalid command");
	}
	}

	std::string AudioEncoderInstance::ProfileToString(PP_AudioProfile profile) {
	if (profile == PP_AUDIOPROFILE_OPUS)
	return "opus";
	return "unknown";
	}

	void AudioEncoderInstance::GetSupportedProfiles() {
	audio_encoder_.GetSupportedProfiles(callback_factory_.NewCallbackWithOutput(
	&AudioEncoderInstance::OnGetSupportedProfiles));
	}

	void AudioEncoderInstance::OnGetSupportedProfiles(
	int32_t result,
	const std::vector<PP_AudioProfileDescription> profiles) {
	pp::VarDictionary dictionary = NewCommand("supportedProfiles");
	pp::VarArray js_profiles;
	dictionary.Set(pp::Var("profiles"), js_profiles);

	if (result < 0) {
	LogError(result, "Cannot get supported profiles");
	PostMessage(dictionary);
	}

	int32_t idx = 0;
	for (std::vector<PP_AudioProfileDescription>::const_iterator it =
	profiles.begin();
	it != profiles.end(); ++it) {
	pp::VarDictionary js_profile;
	js_profile.Set(pp::Var("name"), pp::Var(ProfileToString(it->profile)));
	js_profile.Set(pp::Var("sample_size"),
	pp::Var(static_cast<int32_t>(it->sample_size)));
	js_profile.Set(pp::Var("sample_rate"),
	pp::Var(static_cast<int32_t>(it->sample_rate)));
	js_profiles.Set(idx++, js_profile);
	}
	PostMessage(dictionary);
	}

	void AudioEncoderInstance::StartAudioTrack(const pp::Resource& resource_track) {
	audio_track_ = pp::MediaStreamAudioTrack(resource_track);
	audio_track_.GetBuffer(callback_factory_.NewCallbackWithOutput(
	&AudioEncoderInstance::OnGetBuffer));
	}

	void AudioEncoderInstance::StopAudioTrack() {
	channels_ = 0;
	audio_track_.Close();
	audio_track_ = pp::MediaStreamAudioTrack();
	audio_encoder_.Close();
	audio_encoder_ = pp::AudioEncoder();
	}

	void AudioEncoderInstance::OnGetBuffer(int32_t result, pp::AudioBuffer buffer) {
	if (result == PP_ERROR_ABORTED)
	return;
	if (result != PP_OK) {
	LogError(result, "Cannot get audio track buffer");
	return;
	}

	// If this is the first buffer, then we need to initialize the encoder.
	if (channels_ == 0) {
	channels_ = buffer.GetNumberOfChannels();
	sample_rate_ = buffer.GetSampleRate();
	sample_size_ = buffer.GetSampleSize();
	samples_per_frame_ = buffer.GetNumberOfSamples();

	if (no_encoding_) {
	PostAudioFormat();
	PostDataMessage(buffer.GetDataBuffer(), buffer.GetDataBufferSize());
	audio_track_.GetBuffer(callback_factory_.NewCallbackWithOutput(
	&AudioEncoderInstance::OnGetBuffer));
	} else {
	InitializeEncoder();
	}

	// Given that once the encoder is initialized we might reconfigure the
	// media track, we discard the first buffer to keep this example a bit
	// simpler.
	audio_track_.RecycleBuffer(buffer);
	} else {
	if (no_encoding_) {
	PostDataMessage(buffer.GetDataBuffer(), buffer.GetDataBufferSize());
	audio_track_.RecycleBuffer(buffer);
	} else {
	GetEncoderBuffer(buffer);
	}

	audio_track_.GetBuffer(callback_factory_.NewCallbackWithOutput(
	&AudioEncoderInstance::OnGetBuffer));
	}
	}

	void AudioEncoderInstance::InitializeEncoder() {
	if (audio_encoder_.is_null())
	audio_encoder_ = pp::AudioEncoder(this);
	audio_encoder_.Initialize(
	channels_, static_cast<PP_AudioBuffer_SampleRate>(sample_rate_),
	static_cast<PP_AudioBuffer_SampleSize>(sample_size_),
	PP_AUDIOPROFILE_OPUS, 100000, PP_HARDWAREACCELERATION_WITHFALLBACK,
	callback_factory_.NewCallback(
	&AudioEncoderInstance::OnEncoderInitialized));
	}

	void AudioEncoderInstance::OnEncoderInitialized(int32_t result) {
	if (result == PP_ERROR_ABORTED)
	return;
	if (result != PP_OK) {
	LogError(result, "Cannot initialize encoder");
	return;
	}

	int32_t attribs[] = {
	// Duration in milliseconds.
	PP_MEDIASTREAMAUDIOTRACK_ATTRIB_DURATION,
	1000 / (sample_rate_ / audio_encoder_.GetNumberOfSamples()),
	PP_MEDIASTREAMAUDIOTRACK_ATTRIB_NONE};
	audio_track_.Configure(attribs,
	callback_factory_.NewCallback(
	&AudioEncoderInstance::OnAudioTrackConfigured));

	samples_per_frame_ = audio_encoder_.GetNumberOfSamples();
	PostAudioFormat();
	}

	void AudioEncoderInstance::OnAudioTrackConfigured(int32_t result) {
	if (result == PP_ERROR_ABORTED)
	return;
	if (result != PP_OK) {
	LogError(result, "Cannot configure audio track buffer duration");
	return;
	}

	audio_track_.GetBuffer(callback_factory_.NewCallbackWithOutput(
	&AudioEncoderInstance::OnGetBuffer));
	audio_encoder_.GetBitstreamBuffer(callback_factory_.NewCallbackWithOutput(
	&AudioEncoderInstance::OnGetBitstreamBuffer));
	}

	void AudioEncoderInstance::GetEncoderBuffer(
	const pp::AudioBuffer& track_buffer) {
	audio_encoder_.GetBuffer(callback_factory_.NewCallbackWithOutput(
	&AudioEncoderInstance::OnGetEncoderBuffer, track_buffer));
	}

	void AudioEncoderInstance::OnGetEncoderBuffer(int32_t result,
	pp::AudioBuffer buffer,
	pp::AudioBuffer track_buffer) {
	const char* error(nullptr);

	if (result != PP_OK)
	error = "Cannot get encoder buffer";
	if (buffer.GetDataBufferSize() != track_buffer.GetDataBufferSize()) {
	result = PP_ERROR_FAILED;
	error = "Invalid buffer size";
	}

	if (result == PP_OK) {
	memcpy(buffer.GetDataBuffer(), track_buffer.GetDataBuffer(),
	buffer.GetDataBufferSize());
	audio_encoder_.Encode(buffer, callback_factory_.NewCallback(
	&AudioEncoderInstance::OnEncodeDone));
	} else {
	LogError(result, error);
	StopAudioTrack();
	}
	audio_track_.RecycleBuffer(track_buffer);
	}

	void AudioEncoderInstance::OnEncodeDone(int32_t result) {}

	void AudioEncoderInstance::OnGetBitstreamBuffer(
	int32_t result,
	const PP_AudioBitstreamBuffer& buffer) {
	if (result == PP_ERROR_ABORTED)
	return;
	if (result != PP_OK) {
	LogError(result, "Cannot get bitstream buffer");
	return;
	}

	audio_encoder_.GetBitstreamBuffer(callback_factory_.NewCallbackWithOutput(
	&AudioEncoderInstance::OnGetBitstreamBuffer));

	PostDataMessage(buffer.buffer, buffer.size);
	audio_encoder_.RecycleBitstreamBuffer(buffer);
	}

	pp::VarDictionary AudioEncoderInstance::NewCommand(const std::string& type) {
	pp::VarDictionary dictionary;
	dictionary.Set(pp::Var("command"), pp::Var(type));
	return dictionary;
	}

	void AudioEncoderInstance::Log(const std::string& message) {
	pp::VarDictionary dictionary = NewCommand("log");
	dictionary.Set(pp::Var("message"), pp::Var(message));
	PostMessage(dictionary);
	}

	void AudioEncoderInstance::LogError(int32_t error, const std::string& message) {
	pp::VarDictionary dictionary = NewCommand("error");
	std::string msg("Error: ");
	msg.append(message);
	msg.append(" : ");
	msg.append(pp::Var(error).DebugString());
	dictionary.Set(pp::Var("message"), pp::Var(msg));
	PostMessage(dictionary);
	}

	void AudioEncoderInstance::PostAudioFormat() {
	pp::VarDictionary dictionary = NewCommand("format");
	dictionary.Set(pp::Var("channels"), pp::Var(static_cast<int32_t>(channels_)));
	dictionary.Set(pp::Var("sample_rate"),
	pp::Var(static_cast<int32_t>(sample_rate_)));
	dictionary.Set(pp::Var("sample_size"),
	pp::Var(static_cast<int32_t>(sample_size_)));
	dictionary.Set(pp::Var("sample_per_frame"),
	pp::Var(static_cast<int32_t>(samples_per_frame_)));
	PostMessage(dictionary);
	}

	void AudioEncoderInstance::PostDataMessage(const void* data, uint32_t size) {
	pp::VarDictionary dictionary = NewCommand("data");
	uint8_t* buffer;

	pp::VarArrayBuffer array_buffer = pp::VarArrayBuffer(size);
	buffer = static_cast<uint8_t*>(array_buffer.Map());
	memcpy(buffer, data, size);
	array_buffer.Unmap();

	dictionary.Set(pp::Var("buffer"), array_buffer);

	PostMessage(dictionary);
	}

	class AudioEncoderModule : public pp::Module {
	public:
	virtual pp::Instance* CreateInstance(PP_Instance instance) {
	return new AudioEncoderInstance(instance);
	}
	};

	} // namespace

	namespace pp {

	// Factory function for your specialization of the Module object.
	Module* CreateModule() {
	return new AudioEncoderModule();
	}

	} // namespace pp