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 + sizeof(ppapi::MediaStreamBuffer::Audio);
+    total_buffer_size_ = total_buffer_size.ValueOrDie();
+    base::CheckedNumeric<size_t> total_memory_size = total_buffer_size_;
+    total_memory_size *= number_of_buffers;
+    shm_ = RenderThreadImpl::current()

[Tom Sepez, 2015/10/05 16:54:16]

you might want to call IsValid() and return false rather than dying.  It looks
like we return false in other conditions like failed shm.

[llandwerlin-old, 2015/10/05 17:16:31]

Done.

+               ->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 * buffer_size;

[Tom Sepez, 2015/10/05 16:54:16]

need to assign first, then multiply as you did above.  What this currently does
is to first do an unsafe multiplication, and then assign the possibly overflowed
result to the safe type.

[llandwerlin-old, 2015/10/05 17:16:31]

Sorry, missed this one.

+    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 * encode_parameters_.input_sample_size;

[Tom Sepez, 2015/10/05 16:54:16]

again, you need to do the multplications one at a time against buffer_size,
unless were positive that the unsafe multiplication 
 encode_parameters_.channels * encode_parameters_.input_sample_size
can't overflow before being promoted to the safe type

[llandwerlin-old, 2015/10/05 17:16:31]

Ok, left this one because the encode_parameters_ are supposed to be verified in
OnHostMsgInitialize(), but you're right.

+  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