Home | History | Annotate | Download | only in pepper 
      1 // Copyright 2014 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "content/renderer/pepper/pepper_media_stream_audio_track_host.h"
      6 
      7 #include <algorithm>
      8 
      9 #include "base/bind.h"
     10 #include "base/location.h"
     11 #include "base/logging.h"
     12 #include "base/macros.h"
     13 #include "base/message_loop/message_loop_proxy.h"
     14 #include "base/numerics/safe_math.h"
     15 #include "ppapi/c/pp_errors.h"
     16 #include "ppapi/c/ppb_audio_buffer.h"
     17 #include "ppapi/host/dispatch_host_message.h"
     18 #include "ppapi/host/host_message_context.h"
     19 #include "ppapi/host/ppapi_host.h"
     20 #include "ppapi/proxy/ppapi_messages.h"
     21 #include "ppapi/shared_impl/media_stream_audio_track_shared.h"
     22 #include "ppapi/shared_impl/media_stream_buffer.h"
     23 
     24 using media::AudioParameters;
     25 using ppapi::host::HostMessageContext;
     26 using ppapi::MediaStreamAudioTrackShared;
     27 
     28 namespace {
     29 
     30 // Audio buffer durations in milliseconds.
     31 const uint32_t kMinDuration = 10;
     32 const uint32_t kDefaultDuration = 10;
     33 
     34 const int32_t kDefaultNumberOfBuffers = 4;
     35 const int32_t kMaxNumberOfBuffers = 1000;  // 10 sec
     36 
     37 // Returns true if the |sample_rate| is supported in
     38 // |PP_AudioBuffer_SampleRate|, otherwise false.
     39 PP_AudioBuffer_SampleRate GetPPSampleRate(int sample_rate) {
     40   switch (sample_rate) {
     41     case 8000:
     42       return PP_AUDIOBUFFER_SAMPLERATE_8000;
     43     case 16000:
     44       return PP_AUDIOBUFFER_SAMPLERATE_16000;
     45     case 22050:
     46       return PP_AUDIOBUFFER_SAMPLERATE_22050;
     47     case 32000:
     48       return PP_AUDIOBUFFER_SAMPLERATE_32000;
     49     case 44100:
     50       return PP_AUDIOBUFFER_SAMPLERATE_44100;
     51     case 48000:
     52       return PP_AUDIOBUFFER_SAMPLERATE_48000;
     53     case 96000:
     54       return PP_AUDIOBUFFER_SAMPLERATE_96000;
     55     case 192000:
     56       return PP_AUDIOBUFFER_SAMPLERATE_192000;
     57     default:
     58       return PP_AUDIOBUFFER_SAMPLERATE_UNKNOWN;
     59   }
     60 }
     61 
     62 }  // namespace
     63 
     64 namespace content {
     65 
     66 PepperMediaStreamAudioTrackHost::AudioSink::AudioSink(
     67     PepperMediaStreamAudioTrackHost* host)
     68     : host_(host),
     69       buffer_data_size_(0),
     70       active_buffer_index_(-1),
     71       active_buffers_generation_(0),
     72       active_buffer_offset_(0),
     73       buffers_generation_(0),
     74       main_message_loop_proxy_(base::MessageLoopProxy::current()),
     75       number_of_buffers_(kDefaultNumberOfBuffers),
     76       bytes_per_second_(0),
     77       user_buffer_duration_(kDefaultDuration),
     78       weak_factory_(this) {}
     79 
     80 PepperMediaStreamAudioTrackHost::AudioSink::~AudioSink() {
     81   DCHECK_EQ(main_message_loop_proxy_, base::MessageLoopProxy::current());
     82 }
     83 
     84 void PepperMediaStreamAudioTrackHost::AudioSink::EnqueueBuffer(int32_t index) {
     85   DCHECK_EQ(main_message_loop_proxy_, base::MessageLoopProxy::current());
     86   DCHECK_GE(index, 0);
     87   DCHECK_LT(index, host_->buffer_manager()->number_of_buffers());
     88   base::AutoLock lock(lock_);
     89   buffers_.push_back(index);
     90 }
     91 
     92 int32_t PepperMediaStreamAudioTrackHost::AudioSink::Configure(
     93     int32_t number_of_buffers, int32_t duration,
     94     const ppapi::host::ReplyMessageContext& context) {
     95   DCHECK_EQ(main_message_loop_proxy_, base::MessageLoopProxy::current());
     96 
     97   if (pending_configure_reply_.is_valid()) {
     98     return PP_ERROR_INPROGRESS;
     99   }
    100   pending_configure_reply_ = context;
    101 
    102   bool changed = false;
    103   if (number_of_buffers != number_of_buffers_)
    104     changed = true;
    105   if (duration != 0 && duration != user_buffer_duration_) {
    106     user_buffer_duration_ = duration;
    107     changed = true;
    108   }
    109   number_of_buffers_ = number_of_buffers;
    110 
    111   if (changed) {
    112     // Initialize later in OnSetFormat if bytes_per_second_ is not known yet.
    113     if (bytes_per_second_ > 0 && bytes_per_frame_ > 0)
    114       InitBuffers();
    115   } else {
    116     SendConfigureReply(PP_OK);
    117   }
    118   return PP_OK_COMPLETIONPENDING;
    119 }
    120 
    121 void PepperMediaStreamAudioTrackHost::AudioSink::SendConfigureReply(
    122     int32_t result) {
    123   if (pending_configure_reply_.is_valid()) {
    124     pending_configure_reply_.params.set_result(result);
    125     host_->host()->SendReply(
    126         pending_configure_reply_,
    127         PpapiPluginMsg_MediaStreamAudioTrack_ConfigureReply());
    128     pending_configure_reply_ = ppapi::host::ReplyMessageContext();
    129   }
    130 }
    131 
    132 void PepperMediaStreamAudioTrackHost::AudioSink::SetFormatOnMainThread(
    133     int bytes_per_second, int bytes_per_frame) {
    134   bytes_per_second_ = bytes_per_second;
    135   bytes_per_frame_ = bytes_per_frame;
    136   InitBuffers();
    137 }
    138 
    139 void PepperMediaStreamAudioTrackHost::AudioSink::InitBuffers() {
    140   DCHECK_EQ(main_message_loop_proxy_, base::MessageLoopProxy::current());
    141   {
    142     base::AutoLock lock(lock_);
    143     // Clear |buffers_|, so the audio thread will drop all incoming audio data.
    144     buffers_.clear();
    145     buffers_generation_++;
    146   }
    147   int32_t frame_rate = bytes_per_second_ / bytes_per_frame_;
    148   base::CheckedNumeric<int32_t> frames_per_buffer = user_buffer_duration_;
    149   frames_per_buffer *= frame_rate;
    150   frames_per_buffer /= base::Time::kMillisecondsPerSecond;
    151   base::CheckedNumeric<int32_t> buffer_audio_size =
    152       frames_per_buffer * bytes_per_frame_;
    153   // The size is slightly bigger than necessary, because 8 extra bytes are
    154   // added into the struct. Also see |MediaStreamBuffer|. Also, the size of the
    155   // buffer may be larger than requested, since the size of each buffer will be
    156   // 4-byte aligned.
    157   base::CheckedNumeric<int32_t> buffer_size = buffer_audio_size;
    158   buffer_size += sizeof(ppapi::MediaStreamBuffer::Audio);
    159   DCHECK_GT(buffer_size.ValueOrDie(), 0);
    160 
    161   // We don't need to hold |lock_| during |host->InitBuffers()| call, because
    162   // we just cleared |buffers_| , so the audio thread will drop all incoming
    163   // audio data, and not use buffers in |host_|.
    164   bool result = host_->InitBuffers(number_of_buffers_,
    165                                    buffer_size.ValueOrDie(),
    166                                    kRead);
    167   if (!result) {
    168     SendConfigureReply(PP_ERROR_NOMEMORY);
    169     return;
    170   }
    171 
    172   // Fill the |buffers_|, so the audio thread can continue receiving audio data.
    173   base::AutoLock lock(lock_);
    174   output_buffer_size_ = buffer_audio_size.ValueOrDie();
    175   for (int32_t i = 0; i < number_of_buffers_; ++i) {
    176     int32_t index = host_->buffer_manager()->DequeueBuffer();
    177     DCHECK_GE(index, 0);
    178     buffers_.push_back(index);
    179   }
    180 
    181   SendConfigureReply(PP_OK);
    182 }
    183 
    184 void PepperMediaStreamAudioTrackHost::AudioSink::
    185     SendEnqueueBufferMessageOnMainThread(int32_t index,
    186                                          int32_t buffers_generation) {
    187   DCHECK_EQ(main_message_loop_proxy_, base::MessageLoopProxy::current());
    188   // If |InitBuffers()| is called after this task being posted from the audio
    189   // thread, the buffer should become invalid already. We should ignore it.
    190   // And because only the main thread modifies the |buffers_generation_|,
    191   // so we don't need to lock |lock_| here (main thread).
    192   if (buffers_generation == buffers_generation_)
    193     host_->SendEnqueueBufferMessageToPlugin(index);
    194 }
    195 
    196 void PepperMediaStreamAudioTrackHost::AudioSink::OnData(const int16* audio_data,
    197                                                         int sample_rate,
    198                                                         int number_of_channels,
    199                                                         int number_of_frames) {
    200   DCHECK(audio_thread_checker_.CalledOnValidThread());
    201   DCHECK(audio_data);
    202   DCHECK_EQ(sample_rate, audio_params_.sample_rate());
    203   DCHECK_EQ(number_of_channels, audio_params_.channels());
    204   // Here, |number_of_frames| and |audio_params_.frames_per_buffer()| refer to
    205   // the incomming audio buffer. However, this doesn't necessarily equal
    206   // |buffer->number_of_samples|, which is configured by the user when they set
    207   // buffer duration.
    208   DCHECK_EQ(number_of_frames, audio_params_.frames_per_buffer());
    209 
    210   const uint32_t bytes_per_frame = number_of_channels *
    211       audio_params_.bits_per_sample() / 8;
    212 
    213   int frames_remaining = number_of_frames;
    214   base::TimeDelta timestamp_offset;
    215 
    216   base::AutoLock lock(lock_);
    217   while (frames_remaining) {
    218     if (active_buffers_generation_ != buffers_generation_) {
    219       // Buffers have changed, so drop the active buffer.
    220       active_buffer_index_ = -1;
    221     }
    222     if (active_buffer_index_ == -1 && !buffers_.empty()) {
    223       active_buffers_generation_ = buffers_generation_;
    224       active_buffer_offset_ = 0;
    225       active_buffer_index_ = buffers_.front();
    226       buffers_.pop_front();
    227     }
    228     if (active_buffer_index_ == -1) {
    229       // Eek! We're dropping frames. Bad, bad, bad!
    230       break;
    231     }
    232 
    233     // TODO(penghuang): support re-sampling, etc.
    234     ppapi::MediaStreamBuffer::Audio* buffer =
    235         &(host_->buffer_manager()->GetBufferPointer(active_buffer_index_)
    236           ->audio);
    237     if (active_buffer_offset_ == 0) {
    238       // The active buffer is new, so initialise the header and metadata fields.
    239       buffer->header.size = host_->buffer_manager()->buffer_size();
    240       buffer->header.type = ppapi::MediaStreamBuffer::TYPE_AUDIO;
    241       buffer->timestamp = (timestamp_ + timestamp_offset).InMillisecondsF();
    242       buffer->sample_rate = static_cast<PP_AudioBuffer_SampleRate>(sample_rate);
    243       buffer->data_size = output_buffer_size_;
    244       buffer->number_of_channels = number_of_channels;
    245       buffer->number_of_samples = buffer->data_size * number_of_channels /
    246           bytes_per_frame;
    247     }
    248     uint32_t buffer_bytes_remaining =
    249         buffer->data_size - active_buffer_offset_;
    250     DCHECK_EQ(buffer_bytes_remaining % bytes_per_frame, 0U);
    251     uint32_t incoming_bytes_remaining = frames_remaining * bytes_per_frame;
    252     uint32_t bytes_to_copy = std::min(buffer_bytes_remaining,
    253                                       incoming_bytes_remaining);
    254     uint32_t frames_to_copy = bytes_to_copy / bytes_per_frame;
    255     DCHECK_EQ(bytes_to_copy % bytes_per_frame, 0U);
    256     memcpy(buffer->data + active_buffer_offset_,
    257            audio_data, bytes_to_copy);
    258     active_buffer_offset_ += bytes_to_copy;
    259     audio_data += bytes_to_copy / sizeof(*audio_data);
    260     frames_remaining -= frames_to_copy;
    261     timestamp_offset += base::TimeDelta::FromMilliseconds(
    262         frames_to_copy * base::Time::kMillisecondsPerSecond / sample_rate);
    263 
    264     DCHECK_LE(active_buffer_offset_, buffer->data_size);
    265     if (active_buffer_offset_ == buffer->data_size) {
    266       main_message_loop_proxy_->PostTask(
    267           FROM_HERE,
    268           base::Bind(&AudioSink::SendEnqueueBufferMessageOnMainThread,
    269                      weak_factory_.GetWeakPtr(),
    270                      active_buffer_index_,
    271                      buffers_generation_));
    272       active_buffer_index_ = -1;
    273     }
    274   }
    275   timestamp_ += buffer_duration_;
    276 }
    277 
    278 void PepperMediaStreamAudioTrackHost::AudioSink::OnSetFormat(
    279     const AudioParameters& params) {
    280   DCHECK(params.IsValid());
    281   // TODO(amistry): How do you handle the case where the user configures a
    282   // duration that's shorter than the received buffer duration? One option is to
    283   // double buffer, where the size of the intermediate ring buffer is at least
    284   // max(user requested duration, received buffer duration). There are other
    285   // ways of dealing with it, but which one is "correct"?
    286   DCHECK_LE(params.GetBufferDuration().InMilliseconds(), kMinDuration);
    287   DCHECK_EQ(params.bits_per_sample(), 16);
    288   DCHECK_NE(GetPPSampleRate(params.sample_rate()),
    289             PP_AUDIOBUFFER_SAMPLERATE_UNKNOWN);
    290 
    291   audio_params_ = params;
    292 
    293   // TODO(penghuang): support setting format more than once.
    294   buffer_duration_ = params.GetBufferDuration();
    295   buffer_data_size_ = params.GetBytesPerBuffer();
    296 
    297   if (original_audio_params_.IsValid()) {
    298     DCHECK_EQ(params.sample_rate(), original_audio_params_.sample_rate());
    299     DCHECK_EQ(params.bits_per_sample(),
    300               original_audio_params_.bits_per_sample());
    301     DCHECK_EQ(params.channels(), original_audio_params_.channels());
    302   } else {
    303     audio_thread_checker_.DetachFromThread();
    304     original_audio_params_ = params;
    305 
    306     int bytes_per_frame = params.channels() * params.bits_per_sample() / 8;
    307     main_message_loop_proxy_->PostTask(
    308         FROM_HERE,
    309         base::Bind(&AudioSink::SetFormatOnMainThread,
    310                    weak_factory_.GetWeakPtr(),
    311                    params.GetBytesPerSecond(),
    312                    bytes_per_frame));
    313   }
    314 }
    315 
    316 PepperMediaStreamAudioTrackHost::PepperMediaStreamAudioTrackHost(
    317     RendererPpapiHost* host,
    318     PP_Instance instance,
    319     PP_Resource resource,
    320     const blink::WebMediaStreamTrack& track)
    321     : PepperMediaStreamTrackHostBase(host, instance, resource),
    322       track_(track),
    323       connected_(false),
    324       audio_sink_(this) {
    325   DCHECK(!track_.isNull());
    326 }
    327 
    328 PepperMediaStreamAudioTrackHost::~PepperMediaStreamAudioTrackHost() {
    329   OnClose();
    330 }
    331 
    332 int32_t PepperMediaStreamAudioTrackHost::OnResourceMessageReceived(
    333     const IPC::Message& msg,
    334     HostMessageContext* context) {
    335   PPAPI_BEGIN_MESSAGE_MAP(PepperMediaStreamAudioTrackHost, msg)
    336     PPAPI_DISPATCH_HOST_RESOURCE_CALL(
    337         PpapiHostMsg_MediaStreamAudioTrack_Configure, OnHostMsgConfigure)
    338   PPAPI_END_MESSAGE_MAP()
    339   return PepperMediaStreamTrackHostBase::OnResourceMessageReceived(msg,
    340                                                                    context);
    341 }
    342 
    343 int32_t PepperMediaStreamAudioTrackHost::OnHostMsgConfigure(
    344     HostMessageContext* context,
    345     const MediaStreamAudioTrackShared::Attributes& attributes) {
    346   if (!MediaStreamAudioTrackShared::VerifyAttributes(attributes))
    347     return PP_ERROR_BADARGUMENT;
    348 
    349   int32_t buffers = attributes.buffers
    350                         ? std::min(kMaxNumberOfBuffers, attributes.buffers)
    351                         : kDefaultNumberOfBuffers;
    352   return audio_sink_.Configure(buffers, attributes.duration,
    353                                context->MakeReplyMessageContext());
    354 }
    355 
    356 void PepperMediaStreamAudioTrackHost::OnClose() {
    357   if (connected_) {
    358     MediaStreamAudioSink::RemoveFromAudioTrack(&audio_sink_, track_);
    359     connected_ = false;
    360   }
    361   audio_sink_.SendConfigureReply(PP_ERROR_ABORTED);
    362 }
    363 
    364 void PepperMediaStreamAudioTrackHost::OnNewBufferEnqueued() {
    365   int32_t index = buffer_manager()->DequeueBuffer();
    366   DCHECK_GE(index, 0);
    367   audio_sink_.EnqueueBuffer(index);
    368 }
    369 
    370 void PepperMediaStreamAudioTrackHost::DidConnectPendingHostToResource() {
    371   if (!connected_) {
    372     MediaStreamAudioSink::AddToAudioTrack(&audio_sink_, track_);
    373     connected_ = true;
    374   }
    375 }
    376 
    377 }  // namespace content
    378