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