Integrate HTMLMediaElement with Web Audio API's MediaElementAudioSourceNode

content/renderer/media/audio_renderer_impl.h

 // Copyright (c) 2011 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.
 //
 // Audio rendering unit utilizing AudioDevice.
 //
 // This class lives inside three threads during it's lifetime, namely:
 // 1. Render thread.
 //    This object is created on the render thread.
 // 2. Pipeline thread
 //    OnInitialize() is called here with the audio format.
 //    Play/Pause/Seek also happens here.
 // 3. Audio thread created by the AudioDevice.
 //    Render() is called here where audio data is decoded into raw PCM data.
 
 #ifndef CONTENT_RENDERER_MEDIA_AUDIO_RENDERER_IMPL_H_
 #define CONTENT_RENDERER_MEDIA_AUDIO_RENDERER_IMPL_H_
 #pragma once
 
 #include <vector>
 
 #include "base/gtest_prod_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/synchronization/lock.h"
 #include "content/renderer/media/audio_device.h"
 #include "media/audio/audio_io.h"
 #include "media/audio/audio_parameters.h"
 #include "media/filters/audio_renderer_base.h"
+#include "media/filters/audio_renderer_sink.h"
 
 class AudioMessageFilter;
 
 class CONTENT_EXPORT AudioRendererImpl
     : public media::AudioRendererBase,
       public AudioDevice::RenderCallback {
  public:
   // Methods called on Render thread ------------------------------------------
   AudioRendererImpl();
   virtual ~AudioRendererImpl();
@@ skipping 28 matching lines @@
   // Helper methods.
   // Convert number of bytes to duration of time using information about the
   // number of channels, sample rate and sample bits.
   base::TimeDelta ConvertToDuration(int bytes);
 
   // Methods called on pipeline thread ----------------------------------------
   void DoPlay();
   void DoPause();
   void DoSeek();
 
-  // AudioDevice::RenderCallback implementation.
+  // media::AudioRendererSink::RenderCallback implementation.
   virtual void Render(const std::vector<float*>& audio_data,
                       size_t number_of_frames,
                       size_t audio_delay_milliseconds) OVERRIDE;
 
+  // Detach from normal playback with AudioDevice and use the given sink.
+  // Passing in NULL means to use the default sink which is the AudioDevice.

[tommi (sloooow) - chröme, 2011/12/19 15:26:24]

should this documentation perhaps rather be in the interface?

[Chris Rogers, 2011/12/19 21:40:35]

I think you're right given that it's part of the interface.  But, looking closer
I think it would make a lot more sense to just simplify the AudioRendererSink::
RenderCallback interface by removing the method from there, and instead just
make this be a method on AudioRendererImpl.  This method really isn't something
I meant to generalize in the abstract interface.  What do you think?

On 2011/12/19 15:26:24, tommi wrote:

[tommi (sloooow) - chröme, 2011/12/20 15:05:46]

That sounds reasonable to me.

+  virtual void SetAudioRendererSink(media::AudioRendererSink* sink) OVERRIDE;
+
   // Accessors used by tests.
   base::Time earliest_end_time() const {
     return earliest_end_time_;
   }
 
   void set_earliest_end_time(const base::Time& earliest_end_time) {
     earliest_end_time_ = earliest_end_time;
   }
 
   uint32 bytes_per_second() const {
     return bytes_per_second_;
   }
 
   // Estimate earliest time when current buffer can stop playing.
   void UpdateEarliestEndTime(int bytes_filled,
                              base::TimeDelta request_delay,
                              base::Time time_now);
 
   // Used to calculate audio delay given bytes.
   uint32 bytes_per_second_;
 
   // A flag that indicates this filter is called to stop.
   bool stopped_;
 
-  // audio_device_ is the sink (destination) for rendered audio.
+  // sink_ is the sink (destination) for rendered audio.
+  media::AudioRendererSink* sink_;
+
+  // Protects access to sink_
+  base::Lock sink_lock_;
+
+  // audio_device_ is the default sink.
   scoped_refptr<AudioDevice> audio_device_;
 
+  // Set to true when OnInitialize() is called.
+  bool is_initialized_;
+
   // We're supposed to know amount of audio data OS or hardware buffered, but
   // that is not always so -- on my Linux box
   // AudioBuffersState::hardware_delay_bytes never reaches 0.
   //
   // As a result we cannot use it to find when stream ends. If we just ignore
   // buffered data we will notify host that stream ended before it is actually
   // did so, I've seen it done ~140ms too early when playing ~150ms file.
   //
   // Instead of trying to invent OS-specific solution for each and every OS we
   // are supporting, use simple workaround: every time we fill the buffer we
   // remember when it should stop playing, and do not assume that buffer is
   // empty till that time. Workaround is not bulletproof, as we don't exactly
   // know when that particular data would start playing, but it is much better
   // than nothing.
   base::Time earliest_end_time_;
 
   AudioParameters audio_parameters_;
 
   DISALLOW_COPY_AND_ASSIGN(AudioRendererImpl);
 };
 
 #endif  // CONTENT_RENDERER_MEDIA_AUDIO_RENDERER_IMPL_H_