content/renderer/pepper/pepper_media_stream_audio_track_host.h

   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 #ifndef CONTENT_RENDERER_PEPPER_PEPPER_MEDIA_STREAM_AUDIO_TRACK_HOST_H_
   6 #define CONTENT_RENDERER_PEPPER_PEPPER_MEDIA_STREAM_AUDIO_TRACK_HOST_H_
   7
   8 #include <deque>
   9
  10 #include "base/compiler_specific.h"
  11 #include "base/memory/scoped_ptr.h"
  12 #include "base/memory/weak_ptr.h"
  13 #include "base/synchronization/lock.h"
  14 #include "base/threading/thread_checker.h"
  15 #include "content/public/renderer/media_stream_audio_sink.h"
  16 #include "content/renderer/pepper/pepper_media_stream_track_host_base.h"
  17 #include "media/audio/audio_parameters.h"
  18 #include "ppapi/host/host_message_context.h"
  19 #include "ppapi/shared_impl/media_stream_audio_track_shared.h"
  20 #include "third_party/WebKit/public/platform/WebMediaStreamTrack.h"
  21
  22 namespace base {
  23 class MessageLoopProxy;
  24 }  // namespace base
  25
  26 namespace content {
  27
  28 class PepperMediaStreamAudioTrackHost : public PepperMediaStreamTrackHostBase {
  29  public:
  30   PepperMediaStreamAudioTrackHost(RendererPpapiHost* host,
  31                                   PP_Instance instance,
  32                                   PP_Resource resource,
  33                                   const blink::WebMediaStreamTrack& track);
  34
  35  private:
  36   // A helper class for receiving audio samples in the audio thread.
  37   // This class is created and destroyed on the renderer main thread.
  38   class AudioSink : public MediaStreamAudioSink {
  39    public:
  40     explicit AudioSink(PepperMediaStreamAudioTrackHost* host);
  41     virtual ~AudioSink();
  42
  43     // Enqueues a free buffer index into |buffers_| which will be used for
  44     // sending audio samples to plugin.
  45     // This function is called on the main thread.
  46     void EnqueueBuffer(int32_t index);
  47
  48     // This function is called on the main thread.
  49     int32_t Configure(int32_t number_of_buffers, int32_t duration,
  50                       const ppapi::host::ReplyMessageContext& context);
  51
  52     // Send a reply to the currently pending |Configure()| request.
  53     void SendConfigureReply(int32_t result);
  54
  55    private:
  56     // Initializes buffers on the main thread.
  57     void SetFormatOnMainThread(int bytes_per_second, int bytes_per_frame);
  58
  59     void InitBuffers();
  60
  61     // Send enqueue buffer message on the main thread.
  62     void SendEnqueueBufferMessageOnMainThread(int32_t index,
  63                                               int32_t buffers_generation);
  64
  65     // MediaStreamAudioSink overrides:
  66     // These two functions should be called on the audio thread.
  67     virtual void OnData(const int16* audio_data,
  68                         int sample_rate,
  69                         int number_of_channels,
  70                         int number_of_frames) OVERRIDE;
  71     virtual void OnSetFormat(const media::AudioParameters& params) OVERRIDE;
  72
  73     // Unowned host which is available during the AudioSink's lifespan.
  74     // It is mainly used in the main thread. But the audio thread will use
  75     // host_->buffer_manager() to read some buffer properties. It is safe
  76     // because the buffer_manager()'s properties will not be changed after
  77     // initialization.
  78     PepperMediaStreamAudioTrackHost* host_;
  79
  80     // Timestamp of the next received audio buffer.
  81     // Access only on the audio thread.
  82     base::TimeDelta timestamp_;
  83
  84     // Duration of one audio buffer.
  85     // Access only on the audio thread.
  86     base::TimeDelta buffer_duration_;
  87
  88     // The current audio parameters.
  89     // Access only on the audio thread.
  90     media::AudioParameters audio_params_;
  91
  92     // The original audio parameters which is set in the first time of
  93     // OnSetFormat being called.
  94     // Access only on the audio thread.
  95     media::AudioParameters original_audio_params_;
  96
  97     // The audio data size of one audio buffer in bytes.
  98     // Access only on the audio thread.
  99     uint32_t buffer_data_size_;
 100
 101     // Index of the currently active buffer.
 102     // Access only on the audio thread.
 103     int active_buffer_index_;
 104
 105     // Generation of buffers corresponding to the currently active
 106     // buffer. Used to make sure the active buffer is still valid.
 107     // Access only on the audio thread.
 108     int32_t active_buffers_generation_;
 109
 110     // Current offset, in bytes, within the currently active buffer.
 111     // Access only on the audio thread.
 112     uint32_t active_buffer_offset_;
 113
 114     // A lock to protect the index queue |buffers_|, |buffers_generation_|,
 115     // buffers in |host_->buffer_manager()|, and |output_buffer_size_|.
 116     base::Lock lock_;
 117
 118     // A queue for free buffer indices.
 119     std::deque<int32_t> buffers_;
 120
 121     // Generation of buffers. It is increased by every |InitBuffers()| call.
 122     int32_t buffers_generation_;
 123
 124     // Intended size of each output buffer.
 125     int32_t output_buffer_size_;
 126
 127     scoped_refptr<base::MessageLoopProxy> main_message_loop_proxy_;
 128
 129     base::ThreadChecker audio_thread_checker_;
 130
 131     base::WeakPtrFactory<AudioSink> weak_factory_;
 132
 133     // Number of buffers.
 134     int32_t number_of_buffers_;
 135
 136     // Number of bytes per second.
 137     int bytes_per_second_;
 138
 139     // Number of bytes per frame = channels * bytes per sample.
 140     int bytes_per_frame_;
 141
 142     // User-configured buffer duration, in milliseconds.
 143     int32_t user_buffer_duration_;
 144
 145     // Pending |Configure()| reply context.
 146     ppapi::host::ReplyMessageContext pending_configure_reply_;
 147
 148     DISALLOW_COPY_AND_ASSIGN(AudioSink);
 149   };
 150
 151   virtual ~PepperMediaStreamAudioTrackHost();
 152
 153   // ResourceMessageHandler overrides:
 154   virtual int32_t OnResourceMessageReceived(
 155       const IPC::Message& msg,
 156       ppapi::host::HostMessageContext* context) OVERRIDE;
 157
 158   // Message handlers:
 159   int32_t OnHostMsgConfigure(
 160       ppapi::host::HostMessageContext* context,
 161       const ppapi::MediaStreamAudioTrackShared::Attributes& attributes);
 162
 163   // PepperMediaStreamTrackHostBase overrides:
 164   virtual void OnClose() OVERRIDE;
 165
 166   // MediaStreamBufferManager::Delegate overrides:
 167   virtual void OnNewBufferEnqueued() OVERRIDE;
 168
 169   // ResourceHost overrides:
 170   virtual void DidConnectPendingHostToResource() OVERRIDE;
 171
 172   blink::WebMediaStreamTrack track_;
 173
 174   // True if |audio_sink_| has been added to |blink::WebMediaStreamTrack|
 175   // as a sink.
 176   bool connected_;
 177
 178   AudioSink audio_sink_;
 179
 180   DISALLOW_COPY_AND_ASSIGN(PepperMediaStreamAudioTrackHost);
 181 };
 182
 183 }  // namespace content
 184
 185 #endif  // CONTENT_RENDERER_PEPPER_PEPPER_MEDIA_STREAM_AUDIO_TRACK_HOST_H_