ppapi: implement PPB_AudioEncoder

content/renderer/pepper/pepper_audio_encoder_host.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 "base/bind.h"
+#include "base/memory/shared_memory.h"
+#include "base/numerics/safe_math.h"
+#include "content/public/renderer/renderer_ppapi_host.h"
+#include "content/renderer/pepper/audio_encoder_shim.h"
+#include "content/renderer/pepper/host_globals.h"
+#include "content/renderer/pepper/pepper_audio_encoder_host.h"
+#include "content/renderer/render_thread_impl.h"
+#include "media/base/bind_to_current_loop.h"
+#include "ppapi/c/pp_codecs.h"
+#include "ppapi/c/pp_errors.h"
+#include "ppapi/host/dispatch_host_message.h"
+#include "ppapi/host/ppapi_host.h"
+#include "ppapi/proxy/ppapi_messages.h"
+#include "ppapi/shared_impl/media_stream_buffer.h"
+
+using ppapi::proxy::SerializedHandle;
+
+namespace content {
+
+namespace {
+
+// Number of input audio buffers (150ms at 10ms per frame).
+const uint32_t kDefaultNumberOfAudioFrames = 15;
+
+// Number of bitstream buffers.
+const uint32_t kDefaultNumberOfBitstreamBuffers = 8;
+
+// Default bitstream buffers size.
+// TODO(llandwerlin): Would having this a multiple of the audio frame
+// size would make more sense?
+const size_t kDefaultBitstreamBufferSize = 100000;
+
+bool PP_HardwareAccelerationCompatible(bool accelerated,
+                                       PP_HardwareAcceleration requested) {
+  switch (requested) {
+    case PP_HARDWAREACCELERATION_ONLY:
+      return accelerated;
+    case PP_HARDWAREACCELERATION_NONE:
+      return !accelerated;
+    case PP_HARDWAREACCELERATION_WITHFALLBACK:
+      return true;
+      // No default case, to catch unhandled PP_HardwareAcceleration values.
+  }
+  return false;
+}
+
+}  // namespace
+
+class PepperAudioEncoderHost::BufferManager
+    : public base::RefCountedThreadSafe<BufferManager> {
+ public:
+  uint32_t number_of_buffers() const { return number_of_buffers_; }
+  size_t buffer_size() const { return buffer_size_; }
+
+  virtual bool Initialize(uint32_t number_of_buffers, size_t buffer_size) {
+    number_of_buffers_ = number_of_buffers;
+    buffer_size_ = buffer_size;
+    return true;
+  }
+
+  virtual uint8_t* GetBuffer(uint32_t id) = 0;
+  virtual base::SharedMemory* GetSharedMemory() = 0;
+
+  uint32_t DequeueBuffer() {
+    DCHECK(!enqueued_buffers_.empty());
+    uint32_t id = enqueued_buffers_.front();
+    enqueued_buffers_.pop_front();
+    buffers_.erase(id);
+    return id;
+  }
+  void EnqueueBuffer(uint32_t id) {
+    DCHECK(!IsBufferQueued(id));
+    enqueued_buffers_.push_back(id);
+    buffers_.insert(id);
+  }
+  bool HasAvailableBuffer() { return !enqueued_buffers_.empty(); }
+  bool IsBufferQueued(uint32_t id) {
+    return buffers_.find(id) != buffers_.end();
+  }
+
+ protected:
+  friend class base::RefCountedThreadSafe<BufferManager>;
+  BufferManager() : number_of_buffers_(0), buffer_size_(0) {}
+  virtual ~BufferManager() {}
+
+ private:
+  uint32_t number_of_buffers_;
+  size_t buffer_size_;
+  std::deque<uint32_t> enqueued_buffers_;
+  std::set<uint32_t> buffers_;
+
+  DISALLOW_COPY_AND_ASSIGN(BufferManager);
+};
+
+class PepperAudioEncoderHost::PcmBufferManager : public BufferManager {
+ public:
+  PcmBufferManager(const ppapi::proxy::PPB_AudioEncodeParameters& parameters,
+                   uint32_t number_of_samples)
+      : encode_parameters_(parameters),
+        number_of_samples_(number_of_samples),
+        total_buffer_size_(0) {}
+
+ private:
+  ~PcmBufferManager() override {}
+
+  // PepperAudioEncoderHost::BufferManager:
+  bool Initialize(uint32_t number_of_buffers, size_t buffer_size) override {
+    base::CheckedNumeric<size_t> total_buffer_size = buffer_size;
+    total_buffer_size += sizeof(ppapi::MediaStreamBuffer::Audio);
+    if (!total_buffer_size.IsValid())
+      return false;
+    total_buffer_size_ = total_buffer_size.ValueOrDie();
+    base::CheckedNumeric<size_t> total_memory_size = total_buffer_size_;
+    total_memory_size *= number_of_buffers;
+    if (!total_memory_size.IsValid())
+      return false;
+    shm_ = RenderThreadImpl::current()
+               ->HostAllocateSharedMemoryBuffer(total_memory_size.ValueOrDie())
+               .Pass();
+    if (!shm_ || !shm_->Map(total_memory_size.ValueOrDie()))
+      return false;
+
+    for (uint32_t i = 0; i < number_of_buffers; ++i) {
+      uint8_t* mem =
+          static_cast<uint8_t*>(shm_->memory()) + total_buffer_size_ * i;
+      ppapi::MediaStreamBuffer::Audio* buffer =
+          reinterpret_cast<ppapi::MediaStreamBuffer::Audio*>(mem);
+      buffer->header.size = total_buffer_size_;
+      buffer->header.type = ppapi::MediaStreamBuffer::TYPE_AUDIO;
+      buffer->sample_rate = static_cast<PP_AudioBuffer_SampleRate>(
+          encode_parameters_.input_sample_rate);
+      buffer->number_of_channels = encode_parameters_.channels;
+      buffer->number_of_samples = number_of_samples_;
+      buffer->data_size = buffer_size;
+    }
+
+    return BufferManager::Initialize(number_of_buffers, buffer_size);
+  }
+  uint8_t* GetBuffer(uint32_t id) override {
+    if (id >= number_of_buffers())
+      return nullptr;
+    uint8_t* mem =
+        static_cast<uint8_t*>(shm_->memory()) + total_buffer_size_ * id;
+    return static_cast<uint8_t*>(
+        reinterpret_cast<ppapi::MediaStreamBuffer::Audio*>(mem)->data);
+  }
+  base::SharedMemory* GetSharedMemory() override { return shm_.get(); }
+
+  scoped_ptr<base::SharedMemory> shm_;
+  ppapi::proxy::PPB_AudioEncodeParameters encode_parameters_;
+  uint32_t number_of_samples_;
+  size_t total_buffer_size_;
+};
+
+class PepperAudioEncoderHost::BitstreamBufferManager : public BufferManager {
+ public:
+  BitstreamBufferManager() {}
+
+ private:
+  ~BitstreamBufferManager() override {}
+
+  // PepperAudioEncoderHost::BufferManager:
+  bool Initialize(uint32_t number_of_buffers, size_t buffer_size) override {
+    base::CheckedNumeric<size_t> total_size = number_of_buffers;
+    total_size *= buffer_size;
+    shm_ = RenderThreadImpl::current()
+               ->HostAllocateSharedMemoryBuffer(total_size.ValueOrDie())
+               .Pass();
+    if (!shm_ || !shm_->Map(total_size.ValueOrDie()))
+      return false;
+
+    for (uint32_t i = 0; i < number_of_buffers; ++i)
+      EnqueueBuffer(i);
+
+    return BufferManager::Initialize(number_of_buffers, buffer_size);
+  }
+  uint8_t* GetBuffer(uint32_t id) override {
+    if (id >= number_of_buffers())
+      return nullptr;
+    return static_cast<uint8_t*>(shm_->memory()) + (id * buffer_size());
+  }
+  base::SharedMemory* GetSharedMemory() override { return shm_.get(); }
+
+  scoped_ptr<base::SharedMemory> shm_;
+};
+
+class PepperAudioEncoderHost::AudioData : public AudioEncoderShim::AudioData {
+ public:
+  AudioData(int32_t id, const scoped_refptr<BufferManager>& buffer_manager)
+      : id_(id), buffer_manager_(buffer_manager) {}
+
+  int32_t id() const { return id_; }
+
+ private:
+  ~AudioData() override {}
+
+  // AudioEncoderShim::AudioData:
+  uint8_t* GetData() override { return buffer_manager_->GetBuffer(id_); }
+  size_t GetSize() override { return buffer_manager_->buffer_size(); }
+
+  int32_t id_;
+  scoped_refptr<BufferManager> buffer_manager_;
+
+  DISALLOW_COPY_AND_ASSIGN(AudioData);
+};
+
+PepperAudioEncoderHost::PepperAudioEncoderHost(RendererPpapiHost* host,
+                                               PP_Instance instance,
+                                               PP_Resource resource)
+    : ResourceHost(host->GetPpapiHost(), instance, resource),
+      renderer_ppapi_host_(host),
+      initialized_(false),
+      encoder_last_error_(PP_ERROR_FAILED),
+      weak_ptr_factory_(this) {}
+
+PepperAudioEncoderHost::~PepperAudioEncoderHost() {
+  Close();
+}
+
+int32_t PepperAudioEncoderHost::OnResourceMessageReceived(
+    const IPC::Message& msg,
+    ppapi::host::HostMessageContext* context) {
+  PPAPI_BEGIN_MESSAGE_MAP(PepperAudioEncoderHost, msg)
+    PPAPI_DISPATCH_HOST_RESOURCE_CALL_0(
+        PpapiHostMsg_AudioEncoder_GetSupportedProfiles,
+        OnHostMsgGetSupportedProfiles)
+    PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_AudioEncoder_Initialize,
+                                      OnHostMsgInitialize)
+    PPAPI_DISPATCH_HOST_RESOURCE_CALL_0(
+        PpapiHostMsg_AudioEncoder_GetAudioFrames, OnHostMsgGetAudioFrames)
+    PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_AudioEncoder_Encode,
+                                      OnHostMsgEncode)
+    PPAPI_DISPATCH_HOST_RESOURCE_CALL(
+        PpapiHostMsg_AudioEncoder_RecycleBitstreamBuffer,
+        OnHostMsgRecycleBitstreamBuffer)
+    PPAPI_DISPATCH_HOST_RESOURCE_CALL(
+        PpapiHostMsg_AudioEncoder_RequestBitrateChange,
+        OnHostMsgRequestBitrateChange)
+    PPAPI_DISPATCH_HOST_RESOURCE_CALL_0(PpapiHostMsg_AudioEncoder_Close,
+                                        OnHostMsgClose)
+  PPAPI_END_MESSAGE_MAP()
+  return PP_ERROR_FAILED;
+}
+
+int32_t PepperAudioEncoderHost::OnHostMsgGetSupportedProfiles(
+    ppapi::host::HostMessageContext* context) {
+  std::vector<PP_AudioProfileDescription> profiles;
+  GetSupportedProfiles(&profiles);
+
+  host()->SendReply(
+      context->MakeReplyMessageContext(),
+      PpapiPluginMsg_AudioEncoder_GetSupportedProfilesReply(profiles));
+
+  return PP_OK_COMPLETIONPENDING;
+}
+
+int32_t PepperAudioEncoderHost::OnHostMsgInitialize(
+    ppapi::host::HostMessageContext* context,
+    const ppapi::proxy::PPB_AudioEncodeParameters& parameters) {
+  if (initialized_)
+    return PP_ERROR_FAILED;
+
+  if (!IsInitializationValid(parameters))
+    return PP_ERROR_NOTSUPPORTED;
+
+  encode_parameters_ = parameters;
+  initialize_reply_context_ = context->MakeReplyMessageContext();
+
+  int32_t error = PP_ERROR_FAILED;
+  if (parameters.acceleration == PP_HARDWAREACCELERATION_NONE ||
+      parameters.acceleration == PP_HARDWAREACCELERATION_WITHFALLBACK) {
+    encoder_.reset(new AudioEncoderShim);
+    if (encoder_->Initialize(parameters)) {
+      if (AllocateBitstreamBuffers(kDefaultBitstreamBufferSize)) {
+        encoder_last_error_ = PP_OK;
+        return PP_OK_COMPLETIONPENDING;
+      }
+      error = PP_ERROR_NOMEMORY;
+    } else
+      error = PP_ERROR_FAILED;
+  }
+
+  initialize_reply_context_ = ppapi::host::ReplyMessageContext();
+  encoder_ = nullptr;
+
+  return error;
+}
+
+int32_t PepperAudioEncoderHost::OnHostMsgGetAudioFrames(
+    ppapi::host::HostMessageContext* context) {
+  if (encoder_last_error_)
+    return encoder_last_error_;
+
+  get_audio_frames_reply_context_ = context->MakeReplyMessageContext();
+  if (!AllocateAudioFrames(encoder_->GetNumberOfSamplesPerFrame()))
+    return PP_ERROR_NOMEMORY;
+
+  return PP_OK_COMPLETIONPENDING;
+}
+
+int32_t PepperAudioEncoderHost::OnHostMsgEncode(
+    ppapi::host::HostMessageContext* context,
+    uint32_t buffer_id) {
+  if (encoder_last_error_)
+    return encoder_last_error_;
+
+  if (buffer_id >= audio_buffer_manager_->number_of_buffers() ||
+      audio_buffer_manager_->IsBufferQueued(buffer_id))
+    return PP_ERROR_BADARGUMENT;
+
+  audio_buffer_manager_->EnqueueBuffer(buffer_id);
+
+  DoEncode();
+
+  return PP_OK_COMPLETIONPENDING;
+}
+
+int32_t PepperAudioEncoderHost::OnHostMsgRecycleBitstreamBuffer(
+    ppapi::host::HostMessageContext* context,
+    uint32_t buffer_id) {
+  if (encoder_last_error_)
+    return encoder_last_error_;
+
+  if (buffer_id >= bitstream_buffer_manager_->number_of_buffers() ||
+      bitstream_buffer_manager_->IsBufferQueued(buffer_id))
+    return PP_ERROR_BADARGUMENT;
+
+  bitstream_buffer_manager_->EnqueueBuffer(buffer_id);
+
+  DoEncode();
+
+  return PP_OK;
+}
+
+int32_t PepperAudioEncoderHost::OnHostMsgRequestBitrateChange(
+    ppapi::host::HostMessageContext* context,
+    uint32_t bitrate) {
+  if (encoder_last_error_)
+    return encoder_last_error_;
+
+  encoder_->RequestBitrateChange(bitrate);
+
+  return PP_OK;
+}
+
+int32_t PepperAudioEncoderHost::OnHostMsgClose(
+    ppapi::host::HostMessageContext* context) {
+  encoder_last_error_ = PP_ERROR_FAILED;
+  Close();
+
+  return PP_OK;
+}
+
+void PepperAudioEncoderHost::GetSupportedProfiles(
+    std::vector<PP_AudioProfileDescription>* profiles) {
+  DCHECK(RenderThreadImpl::current());
+
+  AudioEncoderShim software_encoder;
+  *profiles = software_encoder.GetSupportedProfiles();
+}
+
+bool PepperAudioEncoderHost::IsInitializationValid(
+    const ppapi::proxy::PPB_AudioEncodeParameters& parameters) {
+  DCHECK(RenderThreadImpl::current());
+
+  std::vector<PP_AudioProfileDescription> profiles;
+  GetSupportedProfiles(&profiles);
+
+  for (const PP_AudioProfileDescription& profile : profiles) {
+    if (parameters.output_profile == profile.profile &&
+        parameters.input_sample_size == profile.sample_size &&
+        parameters.input_sample_rate == profile.sample_rate &&
+        parameters.channels <= profile.max_channels &&
+        PP_HardwareAccelerationCompatible(
+            profile.hardware_accelerated == PP_TRUE ? true : false,
+            parameters.acceleration))
+      return true;
+  }
+
+  return false;
+}
+
+bool PepperAudioEncoderHost::AllocateAudioFrames(uint32_t number_of_samples) {
+  DCHECK(RenderThreadImpl::current());
+  DCHECK(initialized_);
+  DCHECK(get_audio_frames_reply_context_.is_valid());
+
+  // Frames have already been allocated.
+  if (audio_buffer_manager_)
+    return false;
+
+  scoped_refptr<BufferManager> buffer_manager(
+      new PcmBufferManager(encode_parameters_, number_of_samples));
+  base::CheckedNumeric<size_t> buffer_size = number_of_samples;
+  buffer_size *= encode_parameters_.channels;
+  buffer_size *= encode_parameters_.input_sample_size;
+  if (!buffer_manager->Initialize(kDefaultNumberOfAudioFrames,
+                                  buffer_size.ValueOrDie())) {
+    get_audio_frames_reply_context_ = ppapi::host::ReplyMessageContext();
+    return false;
+  }
+
+  get_audio_frames_reply_context_.params.AppendHandle(
+      SerializedHandle(renderer_ppapi_host_->ShareSharedMemoryHandleWithRemote(
+                           buffer_manager->GetSharedMemory()->handle()),
+                       buffer_manager->GetSharedMemory()->mapped_size()));
+
+  host()->SendReply(
+      get_audio_frames_reply_context_,
+      PpapiPluginMsg_AudioEncoder_GetAudioFramesReply(
+          buffer_manager->number_of_buffers(), buffer_manager->buffer_size()));
+
+  audio_buffer_manager_ = buffer_manager;
+  get_audio_frames_reply_context_ = ppapi::host::ReplyMessageContext();
+
+  return true;
+}
+
+bool PepperAudioEncoderHost::AllocateBitstreamBuffers(size_t buffer_size) {
+  DCHECK(RenderThreadImpl::current());
+  // We assume RequireBitstreamBuffers is only called once.
+  DCHECK(!initialized_);
+  DCHECK(initialize_reply_context_.is_valid());
+
+  scoped_refptr<BufferManager> buffer_manager(new BitstreamBufferManager);
+  if (!buffer_manager->Initialize(kDefaultNumberOfBitstreamBuffers,
+                                  buffer_size)) {
+    initialize_reply_context_ = ppapi::host::ReplyMessageContext();
+    return false;
+  }
+
+  initialize_reply_context_.params.AppendHandle(
+      SerializedHandle(renderer_ppapi_host_->ShareSharedMemoryHandleWithRemote(
+                           buffer_manager->GetSharedMemory()->handle()),
+                       buffer_manager->GetSharedMemory()->mapped_size()));
+
+  host()->SendReply(
+      initialize_reply_context_,
+      PpapiPluginMsg_AudioEncoder_InitializeReply(
+          encoder_->GetNumberOfSamplesPerFrame(),
+          buffer_manager->number_of_buffers(), buffer_manager->buffer_size()));
+
+  bitstream_buffer_manager_ = buffer_manager;
+  initialize_reply_context_ = ppapi::host::ReplyMessageContext();
+
+  return true;
+}
+
+scoped_refptr<PepperAudioEncoderHost::AudioData>
+PepperAudioEncoderHost::GetAudioData(
+    const scoped_refptr<BufferManager>& buffer_manager) {
+  if (!buffer_manager->HasAvailableBuffer())
+    return scoped_refptr<AudioData>();
+  return make_scoped_refptr(
+      new AudioData(buffer_manager->DequeueBuffer(), buffer_manager));
+}
+
+void PepperAudioEncoderHost::DoEncode() {
+  if (!audio_buffer_manager_->HasAvailableBuffer() ||
+      !bitstream_buffer_manager_->HasAvailableBuffer())
+    return;
+
+  scoped_refptr<AudioData> input(GetAudioData(audio_buffer_manager_));
+  encoder_->Encode(input, GetAudioData(bitstream_buffer_manager_),
+                   base::Bind(&PepperAudioEncoderHost::BitstreamBufferReady,
+                              weak_ptr_factory_.GetWeakPtr(), input->id()));
+}
+
+void PepperAudioEncoderHost::BitstreamBufferReady(
+    uint32_t audio_buffer_id,
+    const scoped_refptr<AudioEncoderShim::AudioData>& output,
+    size_t size) {
+  DCHECK(RenderThreadImpl::current());
+
+  if (encoder_last_error_)
+    return;
+
+  host()->SendUnsolicitedReply(
+      pp_resource(), PpapiPluginMsg_AudioEncoder_EncodeReply(audio_buffer_id));
+
+  if (size < 0) {
+    NotifyPepperError(PP_ERROR_FAILED);
+    return;
+  }
+
+  host()->SendUnsolicitedReply(
+      pp_resource(), PpapiPluginMsg_AudioEncoder_BitstreamBufferReady(
+                         static_cast<AudioData*>(output.get())->id(), size));
+}
+
+void PepperAudioEncoderHost::NotifyPepperError(int32_t error) {
+  DCHECK(RenderThreadImpl::current());
+
+  encoder_last_error_ = error;
+  Close();
+  host()->SendUnsolicitedReply(
+      pp_resource(),
+      PpapiPluginMsg_AudioEncoder_NotifyError(encoder_last_error_));
+}
+
+void PepperAudioEncoderHost::Close() {
+  DCHECK(RenderThreadImpl::current());
+
+  encoder_ = nullptr;
+  audio_buffer_manager_ = nullptr;
+  bitstream_buffer_manager_ = nullptr;
+}
+
+}  // namespace content