content/renderer/media/webrtc_local_audio_renderer.h

   1 // Copyright (c) 2012 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_MEDIA_WEBRTC_LOCAL_AUDIO_RENDERER_H_
   6 #define CONTENT_RENDERER_MEDIA_WEBRTC_LOCAL_AUDIO_RENDERER_H_
   7
   8 #include <string>
   9 #include <vector>
  10
  11 #include "base/callback.h"
  12 #include "base/memory/ref_counted.h"
  13 #include "base/single_thread_task_runner.h"
  14 #include "base/synchronization/lock.h"
  15 #include "base/threading/thread_checker.h"
  16 #include "content/common/content_export.h"
  17 #include "content/public/renderer/media_stream_audio_renderer.h"
  18 #include "content/public/renderer/media_stream_audio_sink.h"
  19 #include "content/renderer/media/webrtc_audio_device_impl.h"
  20 #include "content/renderer/media/webrtc_local_audio_track.h"
  21 #include "third_party/WebKit/public/platform/WebMediaStreamTrack.h"
  22
  23 namespace media {
  24 class AudioBus;
  25 class AudioShifter;
  26 class AudioOutputDevice;
  27 class AudioParameters;
  28 }
  29
  30 namespace content {
  31
  32 class WebRtcAudioCapturer;
  33
  34 // WebRtcLocalAudioRenderer is a MediaStreamAudioRenderer designed for rendering
  35 // local audio media stream tracks,
  36 // http://dev.w3.org/2011/webrtc/editor/getusermedia.html#mediastreamtrack
  37 // It also implements media::AudioRendererSink::RenderCallback to render audio
  38 // data provided from a WebRtcLocalAudioTrack source.
  39 // When the audio layer in the browser process asks for data to render, this
  40 // class provides the data by implementing the MediaStreamAudioSink
  41 // interface, i.e., we are a sink seen from the WebRtcAudioCapturer perspective.
  42 // TODO(henrika): improve by using similar principles as in RTCVideoRenderer
  43 // which register itself to the video track when the provider is started and
  44 // deregisters itself when it is stopped.
  45 // Tracking this at http://crbug.com/164813.
  46 class CONTENT_EXPORT WebRtcLocalAudioRenderer
  47     : NON_EXPORTED_BASE(public MediaStreamAudioRenderer),
  48       NON_EXPORTED_BASE(public MediaStreamAudioSink),
  49       NON_EXPORTED_BASE(public media::AudioRendererSink::RenderCallback) {
  50  public:
  51   // Creates a local renderer and registers a capturing |source| object.
  52   // The |source| is owned by the WebRtcAudioDeviceImpl.
  53   // Called on the main thread.
  54   WebRtcLocalAudioRenderer(const blink::WebMediaStreamTrack& audio_track,
  55                            int source_render_frame_id,
  56                            int session_id,
  57                            int frames_per_buffer);
  58
  59   // MediaStreamAudioRenderer implementation.
  60   // Called on the main thread.
  61   void Start() override;
  62   void Stop() override;
  63   void Play() override;
  64   void Pause() override;
  65   void SetVolume(float volume) override;
  66   void SwitchOutputDevice(const std::string& device_id,
  67                           const GURL& security_origin,
  68                           const media::SwitchOutputDeviceCB& callback) override;
  69   base::TimeDelta GetCurrentRenderTime() const override;
  70   bool IsLocalRenderer() const override;
  71
  72   const base::TimeDelta& total_render_time() const {
  73     return total_render_time_;
  74   }
  75
  76  protected:
  77   ~WebRtcLocalAudioRenderer() override;
  78
  79  private:
  80   // MediaStreamAudioSink implementation.
  81
  82   // Called on the AudioInputDevice worker thread.
  83   void OnData(const media::AudioBus& audio_bus,
  84               base::TimeTicks estimated_capture_time) override;
  85
  86   // Called on the AudioInputDevice worker thread.
  87   void OnSetFormat(const media::AudioParameters& params) override;
  88
  89   // media::AudioRendererSink::RenderCallback implementation.
  90   // Render() is called on the AudioOutputDevice thread and OnRenderError()
  91   // on the IO thread.
  92   int Render(media::AudioBus* audio_bus, int audio_delay_milliseconds) override;
  93   void OnRenderError() override;
  94
  95   // Initializes and starts the |sink_| if
  96   //  we have received valid |source_params_| &&
  97   //  |playing_| has been set to true &&
  98   //  |volume_| is not zero.
  99   void MaybeStartSink();
 100
 101   // Sets new |source_params_| and then re-initializes and restarts |sink_|.
 102   void ReconfigureSink(const media::AudioParameters& params);
 103
 104   // The audio track which provides data to render. Given that this class
 105   // implements local loopback, the audio track is getting data from a capture
 106   // instance like a selected microphone and forwards the recorded data to its
 107   // sinks. The recorded data is stored in a FIFO and consumed
 108   // by this class when the sink asks for new data.
 109   // This class is calling MediaStreamAudioSink::AddToAudioTrack() and
 110   // MediaStreamAudioSink::RemoveFromAudioTrack() to connect and disconnect
 111   // with the audio track.
 112   blink::WebMediaStreamTrack audio_track_;
 113
 114   // The render view and frame in which the audio is rendered into |sink_|.
 115   const int source_render_frame_id_;
 116   const int session_id_;
 117
 118   // MessageLoop associated with the single thread that performs all control
 119   // tasks.  Set to the MessageLoop that invoked the ctor.
 120   const scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
 121
 122   // The sink (destination) for rendered audio.
 123   scoped_refptr<media::AudioOutputDevice> sink_;
 124
 125   // This does all the synchronization/resampling/smoothing.
 126   scoped_ptr<media::AudioShifter> audio_shifter_;
 127
 128   // Stores last time a render callback was received. The time difference
 129   // between a new time stamp and this value can be used to derive the
 130   // total render time.
 131   base::TimeTicks last_render_time_;
 132
 133   // Keeps track of total time audio has been rendered.
 134   base::TimeDelta total_render_time_;
 135
 136   // The audio parameters of the capture source.
 137   // Must only be touched on the main thread.
 138   media::AudioParameters source_params_;
 139
 140   // The audio parameters used by the sink.
 141   // Must only be touched on the main thread.
 142   media::AudioParameters sink_params_;
 143
 144   // Set when playing, cleared when paused.
 145   bool playing_;
 146
 147   // Protects |audio_shifter_|, |playing_| and |sink_|.
 148   mutable base::Lock thread_lock_;
 149
 150   // The preferred buffer size provided via the ctor.
 151   const int frames_per_buffer_;
 152
 153   // The preferred device id of the output device or empty for the default
 154   // output device.
 155   const std::string output_device_id_;
 156
 157   // Cache value for the volume.
 158   float volume_;
 159
 160   // Flag to indicate whether |sink_| has been started yet.
 161   bool sink_started_;
 162
 163   // Used to DCHECK that some methods are called on the capture audio thread.
 164   base::ThreadChecker capture_thread_checker_;
 165
 166   DISALLOW_COPY_AND_ASSIGN(WebRtcLocalAudioRenderer);
 167 };
 168
 169 }  // namespace content
 170
 171 #endif  // CONTENT_RENDERER_MEDIA_WEBRTC_LOCAL_AUDIO_RENDERER_H_