webkit/media/webmediaplayer_impl.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 // Delegate calls from WebCore::MediaPlayerPrivate to Chrome's video player.
   6 // It contains Pipeline which is the actual media player pipeline, it glues
   7 // the media player pipeline, data source, audio renderer and renderer.
   8 // Pipeline would creates multiple threads and access some public methods
   9 // of this class, so we need to be extra careful about concurrent access of
  10 // methods and members.
  11 //
  12 // WebMediaPlayerImpl works with multiple objects, the most important ones are:
  13 //
  14 // media::Pipeline
  15 //   The media playback pipeline.
  16 //
  17 // VideoRendererBase
  18 //   Video renderer object.
  19 //
  20 // WebKit::WebMediaPlayerClient
  21 //   WebKit client of this media player object.
  22 //
  23 // The following diagram shows the relationship of these objects:
  24 //   (note: ref-counted reference is marked by a "r".)
  25 //
  26 // WebMediaPlayerClient (WebKit object)
  27 //    ^
  28 //    |
  29 // WebMediaPlayerImpl ---> Pipeline
  30 //    |        ^                  |
  31 //    |        |                  v r
  32 //    |        |        VideoRendererBase
  33 //    |        |          |       ^ r
  34 //    |   r    |          v r     |
  35 //    '---> WebMediaPlayerProxy --'
  36 //
  37 // Notice that WebMediaPlayerProxy and VideoRendererBase are referencing each
  38 // other. This interdependency has to be treated carefully.
  39 //
  40 // Other issues:
  41 // During tear down of the whole browser or a tab, the DOM tree may not be
  42 // destructed nicely, and there will be some dangling media threads trying to
  43 // the main thread, so we need this class to listen to destruction event of the
  44 // main thread and cleanup the media threads when the even is received. Also
  45 // at destruction of this class we will need to unhook it from destruction event
  46 // list of the main thread.
  47
  48 #ifndef WEBKIT_MEDIA_WEBMEDIAPLAYER_IMPL_H_
  49 #define WEBKIT_MEDIA_WEBMEDIAPLAYER_IMPL_H_
  50
  51 #include <string>
  52
  53 #include "base/memory/ref_counted.h"
  54 #include "base/memory/scoped_ptr.h"
  55 #include "base/memory/weak_ptr.h"
  56 #include "base/message_loop.h"
  57 #include "googleurl/src/gurl.h"
  58 #include "media/base/audio_renderer_sink.h"
  59 #include "media/base/decryptor.h"
  60 #include "media/base/filters.h"
  61 #include "media/base/message_loop_factory.h"
  62 #include "media/base/pipeline.h"
  63 #include "skia/ext/platform_canvas.h"
  64 #include "third_party/WebKit/Source/WebKit/chromium/public/WebAudioSourceProvider.h"
  65 #include "third_party/WebKit/Source/WebKit/chromium/public/WebMediaPlayer.h"
  66 #include "third_party/WebKit/Source/WebKit/chromium/public/WebMediaPlayerClient.h"
  67 #include "webkit/media/crypto/key_systems.h"
  68 #include "webkit/media/crypto/proxy_decryptor.h"
  69
  70 class RenderAudioSourceProvider;
  71
  72 namespace WebKit {
  73 class WebAudioSourceProvider;
  74 class WebFrame;
  75 }
  76
  77 namespace media {
  78 class AudioRendererSink;
  79 class MediaLog;
  80 }
  81
  82 namespace webkit_media {
  83
  84 class MediaStreamClient;
  85 class WebMediaPlayerDelegate;
  86 class WebMediaPlayerProxy;
  87
  88 class WebMediaPlayerImpl
  89     : public WebKit::WebMediaPlayer,
  90       public MessageLoop::DestructionObserver,
  91       public base::SupportsWeakPtr<WebMediaPlayerImpl> {
  92  public:
  93   // Construct a WebMediaPlayerImpl with reference to the client, and media
  94   // filter collection. By providing the filter collection the implementor can
  95   // provide more specific media filters that does resource loading and
  96   // rendering.
  97   //
  98   // WebMediaPlayerImpl comes packaged with the following media filters:
  99   //   - URL fetching
 100   //   - Demuxing
 101   //   - Software audio/video decoding
 102   //   - Video rendering
 103   //
 104   // Clients are expected to add their platform-specific audio rendering media
 105   // filter if they wish to hear any sound coming out the speakers, otherwise
 106   // audio data is discarded and media plays back based on wall clock time.
 107   //
 108   // When calling this, the |audio_source_provider| and
 109   // |audio_renderer_sink| arguments should be the same object.
 110   //
 111   // TODO(scherkus): Remove WebAudioSourceProvider parameter once we
 112   // refactor RenderAudioSourceProvider to live under webkit/media/
 113   // instead of content/renderer/, see http://crbug.com/136442
 114
 115   WebMediaPlayerImpl(WebKit::WebFrame* frame,
 116                      WebKit::WebMediaPlayerClient* client,
 117                      base::WeakPtr<WebMediaPlayerDelegate> delegate,
 118                      media::FilterCollection* collection,
 119                      WebKit::WebAudioSourceProvider* audio_source_provider,
 120                      media::AudioRendererSink* audio_renderer_sink,
 121                      media::MessageLoopFactory* message_loop_factory,
 122                      MediaStreamClient* media_stream_client,
 123                      media::MediaLog* media_log);
 124   virtual ~WebMediaPlayerImpl();
 125
 126   virtual void load(const WebKit::WebURL& url, CORSMode cors_mode);
 127   virtual void cancelLoad();
 128
 129   // Playback controls.
 130   virtual void play();
 131   virtual void pause();
 132   virtual bool supportsFullscreen() const;
 133   virtual bool supportsSave() const;
 134   virtual void seek(float seconds);
 135   virtual void setEndTime(float seconds);
 136   virtual void setRate(float rate);
 137   virtual void setVolume(float volume);
 138   virtual void setVisible(bool visible);
 139   virtual void setPreload(WebKit::WebMediaPlayer::Preload preload);
 140   virtual bool totalBytesKnown();
 141   virtual const WebKit::WebTimeRanges& buffered();
 142   virtual float maxTimeSeekable() const;
 143
 144   // Methods for painting.
 145   virtual void setSize(const WebKit::WebSize& size);
 146
 147   // This variant (without alpha) is just present during staging of this API
 148   // change. Later we will again only have one virtual paint().
 149   virtual void paint(WebKit::WebCanvas* canvas, const WebKit::WebRect& rect);
 150   virtual void paint(WebKit::WebCanvas* canvas,
 151                      const WebKit::WebRect& rect,
 152                      uint8_t alpha);
 153
 154   // True if the loaded media has a playable video/audio track.
 155   virtual bool hasVideo() const;
 156   virtual bool hasAudio() const;
 157
 158   // Dimensions of the video.
 159   virtual WebKit::WebSize naturalSize() const;
 160
 161   // Getters of playback state.
 162   virtual bool paused() const;
 163   virtual bool seeking() const;
 164   virtual float duration() const;
 165   virtual float currentTime() const;
 166
 167   // Get rate of loading the resource.
 168   virtual int32 dataRate() const;
 169
 170   // Internal states of loading and network.
 171   // TODO(hclam): Ask the pipeline about the state rather than having reading
 172   // them from members which would cause race conditions.
 173   virtual WebKit::WebMediaPlayer::NetworkState networkState() const;
 174   virtual WebKit::WebMediaPlayer::ReadyState readyState() const;
 175
 176   virtual bool didLoadingProgress() const;
 177   virtual unsigned long long totalBytes() const;
 178
 179   virtual bool hasSingleSecurityOrigin() const;
 180   virtual bool didPassCORSAccessCheck() const;
 181   virtual WebKit::WebMediaPlayer::MovieLoadType movieLoadType() const;
 182
 183   virtual float mediaTimeForTimeValue(float timeValue) const;
 184
 185   virtual unsigned decodedFrameCount() const;
 186   virtual unsigned droppedFrameCount() const;
 187   virtual unsigned audioDecodedByteCount() const;
 188   virtual unsigned videoDecodedByteCount() const;
 189
 190   virtual WebKit::WebVideoFrame* getCurrentFrame();
 191   virtual void putCurrentFrame(WebKit::WebVideoFrame* web_video_frame);
 192
 193   virtual WebKit::WebAudioSourceProvider* audioSourceProvider();
 194
 195   // TODO(acolwell): Remove once new sourceAddId() signature is checked into
 196   // WebKit.
 197   virtual AddIdStatus sourceAddId(const WebKit::WebString& id,
 198                                   const WebKit::WebString& type);
 199   virtual AddIdStatus sourceAddId(
 200       const WebKit::WebString& id,
 201       const WebKit::WebString& type,
 202       const WebKit::WebVector<WebKit::WebString>& codecs);
 203   virtual bool sourceRemoveId(const WebKit::WebString& id);
 204   virtual WebKit::WebTimeRanges sourceBuffered(const WebKit::WebString& id);
 205   // TODO(acolwell): Remove non-id version when http://webk.it/83788 fix lands.
 206   virtual bool sourceAppend(const unsigned char* data, unsigned length);
 207   virtual bool sourceAppend(const WebKit::WebString& id,
 208                             const unsigned char* data,
 209                             unsigned length);
 210   virtual bool sourceAbort(const WebKit::WebString& id);
 211   virtual void sourceEndOfStream(EndOfStreamStatus status);
 212
 213   virtual MediaKeyException generateKeyRequest(
 214       const WebKit::WebString& key_system,
 215       const unsigned char* init_data,
 216       unsigned init_data_length);
 217
 218   virtual MediaKeyException addKey(const WebKit::WebString& key_system,
 219                                    const unsigned char* key,
 220                                    unsigned key_length,
 221                                    const unsigned char* init_data,
 222                                    unsigned init_data_length,
 223                                    const WebKit::WebString& session_id);
 224
 225   virtual MediaKeyException cancelKeyRequest(
 226       const WebKit::WebString& key_system,
 227       const WebKit::WebString& session_id);
 228
 229   // As we are closing the tab or even the browser, |main_loop_| is destroyed
 230   // even before this object gets destructed, so we need to know when
 231   // |main_loop_| is being destroyed and we can stop posting repaint task
 232   // to it.
 233   virtual void WillDestroyCurrentMessageLoop() OVERRIDE;
 234
 235   void Repaint();
 236
 237   void OnPipelineInitialize(media::PipelineStatus status);
 238   void OnPipelineSeek(media::PipelineStatus status);
 239   void OnPipelineEnded(media::PipelineStatus status);
 240   void OnPipelineError(media::PipelineStatus error);
 241   void OnDemuxerOpened();
 242   void OnKeyAdded(const std::string& key_system, const std::string& session_id);
 243   void OnKeyError(const std::string& key_system,
 244                   const std::string& session_id,
 245                   media::Decryptor::KeyError error_code,
 246                   int system_code);
 247   void OnKeyMessage(const std::string& key_system,
 248                     const std::string& session_id,
 249                     scoped_array<uint8> message,
 250                     int message_length,
 251                     const std::string& default_url);
 252   void OnNeedKey(const std::string& key_system,
 253                  const std::string& session_id,
 254                  scoped_array<uint8> init_data,
 255                  int init_data_size);
 256   void SetOpaque(bool);
 257
 258  private:
 259   // Called after asynchronous initialization of a data source completed.
 260   void DataSourceInitialized(const GURL& gurl, media::PipelineStatus status);
 261
 262   // Called when the data source is downloading or paused.
 263   void NotifyDownloading(bool is_downloading);
 264
 265   // Finishes starting the pipeline due to a call to load().
 266   void StartPipeline();
 267
 268   // Helpers that set the network/ready state and notifies the client if
 269   // they've changed.
 270   void SetNetworkState(WebKit::WebMediaPlayer::NetworkState state);
 271   void SetReadyState(WebKit::WebMediaPlayer::ReadyState state);
 272
 273   // Destroy resources held.
 274   void Destroy();
 275
 276   // Getter method to |client_|.
 277   WebKit::WebMediaPlayerClient* GetClient();
 278
 279   // Lets V8 know that player uses extra resources not managed by V8.
 280   void IncrementExternallyAllocatedMemory();
 281
 282   WebKit::WebFrame* frame_;
 283
 284   // TODO(hclam): get rid of these members and read from the pipeline directly.
 285   WebKit::WebMediaPlayer::NetworkState network_state_;
 286   WebKit::WebMediaPlayer::ReadyState ready_state_;
 287
 288   // Keep a list of buffered time ranges.
 289   WebKit::WebTimeRanges buffered_;
 290
 291   // Message loops for posting tasks between Chrome's main thread. Also used
 292   // for DCHECKs so methods calls won't execute in the wrong thread.
 293   MessageLoop* main_loop_;
 294
 295   // A collection of filters.
 296   scoped_ptr<media::FilterCollection> filter_collection_;
 297
 298   // The media pipeline and a bool tracking whether we have started it yet.
 299   //
 300   // TODO(scherkus): replace |started_| with a pointer check for |pipeline_| and
 301   // have WebMediaPlayerImpl return the default values to WebKit instead of
 302   // relying on Pipeline to take care of default values.
 303   scoped_refptr<media::Pipeline> pipeline_;
 304   bool started_;
 305
 306   // The currently selected key system. Empty string means that no key system
 307   // has been selected.
 308   WebKit::WebString current_key_system_;
 309
 310   scoped_ptr<media::MessageLoopFactory> message_loop_factory_;
 311
 312   // Playback state.
 313   //
 314   // TODO(scherkus): we have these because Pipeline favours the simplicity of a
 315   // single "playback rate" over worrying about paused/stopped etc...  It forces
 316   // all clients to manage the pause+playback rate externally, but is that
 317   // really a bad thing?
 318   //
 319   // TODO(scherkus): since SetPlaybackRate(0) is asynchronous and we don't want
 320   // to hang the render thread during pause(), we record the time at the same
 321   // time we pause and then return that value in currentTime().  Otherwise our
 322   // clock can creep forward a little bit while the asynchronous
 323   // SetPlaybackRate(0) is being executed.
 324   bool paused_;
 325   bool seeking_;
 326   float playback_rate_;
 327   base::TimeDelta paused_time_;
 328
 329   // Seek gets pending if another seek is in progress. Only last pending seek
 330   // will have effect.
 331   bool pending_seek_;
 332   float pending_seek_seconds_;
 333
 334   WebKit::WebMediaPlayerClient* client_;
 335
 336   scoped_refptr<WebMediaPlayerProxy> proxy_;
 337
 338   base::WeakPtr<WebMediaPlayerDelegate> delegate_;
 339
 340   MediaStreamClient* media_stream_client_;
 341
 342   scoped_refptr<media::MediaLog> media_log_;
 343
 344   // Since accelerated compositing status is only known after the first layout,
 345   // we delay reporting it to UMA until that time.
 346   bool accelerated_compositing_reported_;
 347
 348   bool incremented_externally_allocated_memory_;
 349
 350   WebKit::WebAudioSourceProvider* audio_source_provider_;
 351
 352   scoped_refptr<media::AudioRendererSink> audio_renderer_sink_;
 353
 354   bool is_local_source_;
 355
 356   // The decryptor that manages decryption keys and decrypts encrypted frames.
 357   ProxyDecryptor decryptor_;
 358
 359   DISALLOW_COPY_AND_ASSIGN(WebMediaPlayerImpl);
 360 };
 361
 362 }  // namespace webkit_media
 363
 364 #endif  // WEBKIT_MEDIA_WEBMEDIAPLAYER_IMPL_H_