ppapi/examples/audio_encode/audio_encode.cc

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