1 // Copyright 2013 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_WEBMEDIAPLAYER_MS_H_ 6 #define CONTENT_RENDERER_MEDIA_WEBMEDIAPLAYER_MS_H_ 7 8 #include "base/memory/ref_counted.h" 9 #include "base/memory/scoped_ptr.h" 10 #include "base/memory/weak_ptr.h" 11 #include "base/synchronization/lock.h" 12 #include "base/threading/thread_checker.h" 13 #include "cc/layers/video_frame_provider.h" 14 #include "media/filters/skcanvas_video_renderer.h" 15 #include "skia/ext/platform_canvas.h" 16 #include "third_party/WebKit/public/platform/WebMediaPlayer.h" 17 #include "url/gurl.h" 18 19 namespace blink { 20 class WebFrame; 21 class WebMediaPlayerClient; 22 } 23 24 namespace media { 25 class MediaLog; 26 class WebMediaPlayerDelegate; 27 } 28 29 namespace cc_blink { 30 class WebLayerImpl; 31 } 32 33 namespace content { 34 class MediaStreamAudioRenderer; 35 class MediaStreamRendererFactory; 36 class VideoFrameProvider; 37 38 // WebMediaPlayerMS delegates calls from WebCore::MediaPlayerPrivate to 39 // Chrome's media player when "src" is from media stream. 40 // 41 // WebMediaPlayerMS works with multiple objects, the most important ones are: 42 // 43 // VideoFrameProvider 44 // provides video frames for rendering. 45 // 46 // TODO(wjia): add AudioPlayer. 47 // AudioPlayer 48 // plays audio streams. 49 // 50 // blink::WebMediaPlayerClient 51 // WebKit client of this media player object. 52 class WebMediaPlayerMS 53 : public blink::WebMediaPlayer, 54 public cc::VideoFrameProvider, 55 public base::SupportsWeakPtr<WebMediaPlayerMS> { 56 public: 57 // Construct a WebMediaPlayerMS with reference to the client, and 58 // a MediaStreamClient which provides VideoFrameProvider. 59 WebMediaPlayerMS(blink::WebFrame* frame, 60 blink::WebMediaPlayerClient* client, 61 base::WeakPtr<media::WebMediaPlayerDelegate> delegate, 62 media::MediaLog* media_log, 63 scoped_ptr<MediaStreamRendererFactory> factory); 64 virtual ~WebMediaPlayerMS(); 65 66 virtual void load(LoadType load_type, 67 const blink::WebURL& url, 68 CORSMode cors_mode); 69 70 // Playback controls. 71 virtual void play(); 72 virtual void pause(); 73 virtual bool supportsSave() const; 74 virtual void seek(double seconds); 75 virtual void setRate(double rate); 76 virtual void setVolume(double volume); 77 virtual void setPreload(blink::WebMediaPlayer::Preload preload); 78 virtual blink::WebTimeRanges buffered() const; 79 virtual double maxTimeSeekable() const; 80 81 // Methods for painting. 82 virtual void paint(blink::WebCanvas* canvas, 83 const blink::WebRect& rect, 84 unsigned char alpha, 85 SkXfermode::Mode mode); 86 // TODO(dshwang): remove it because above method replaces. crbug.com/401027 87 virtual void paint(blink::WebCanvas* canvas, 88 const blink::WebRect& rect, 89 unsigned char alpha); 90 91 // True if the loaded media has a playable video/audio track. 92 virtual bool hasVideo() const; 93 virtual bool hasAudio() const; 94 95 // Dimensions of the video. 96 virtual blink::WebSize naturalSize() const; 97 98 // Getters of playback state. 99 virtual bool paused() const; 100 virtual bool seeking() const; 101 virtual double duration() const; 102 virtual double currentTime() const; 103 104 // Internal states of loading and network. 105 virtual blink::WebMediaPlayer::NetworkState networkState() const; 106 virtual blink::WebMediaPlayer::ReadyState readyState() const; 107 108 virtual bool didLoadingProgress(); 109 110 virtual bool hasSingleSecurityOrigin() const; 111 virtual bool didPassCORSAccessCheck() const; 112 113 virtual double mediaTimeForTimeValue(double timeValue) const; 114 115 virtual unsigned decodedFrameCount() const; 116 virtual unsigned droppedFrameCount() const; 117 virtual unsigned audioDecodedByteCount() const; 118 virtual unsigned videoDecodedByteCount() const; 119 120 // VideoFrameProvider implementation. 121 virtual void SetVideoFrameProviderClient( 122 cc::VideoFrameProvider::Client* client) OVERRIDE; 123 virtual scoped_refptr<media::VideoFrame> GetCurrentFrame() OVERRIDE; 124 virtual void PutCurrentFrame(const scoped_refptr<media::VideoFrame>& frame) 125 OVERRIDE; 126 127 private: 128 // The callback for VideoFrameProvider to signal a new frame is available. 129 void OnFrameAvailable(const scoped_refptr<media::VideoFrame>& frame); 130 // Need repaint due to state change. 131 void RepaintInternal(); 132 133 // The callback for source to report error. 134 void OnSourceError(); 135 136 // Helpers that set the network/ready state and notifies the client if 137 // they've changed. 138 void SetNetworkState(blink::WebMediaPlayer::NetworkState state); 139 void SetReadyState(blink::WebMediaPlayer::ReadyState state); 140 141 // Getter method to |client_|. 142 blink::WebMediaPlayerClient* GetClient(); 143 144 blink::WebFrame* frame_; 145 146 blink::WebMediaPlayer::NetworkState network_state_; 147 blink::WebMediaPlayer::ReadyState ready_state_; 148 149 blink::WebTimeRanges buffered_; 150 151 float volume_; 152 153 // Used for DCHECKs to ensure methods calls executed in the correct thread. 154 base::ThreadChecker thread_checker_; 155 156 blink::WebMediaPlayerClient* client_; 157 158 base::WeakPtr<media::WebMediaPlayerDelegate> delegate_; 159 160 // Specify content:: to disambiguate from cc::. 161 scoped_refptr<content::VideoFrameProvider> video_frame_provider_; 162 bool paused_; 163 164 // |current_frame_| is updated only on main thread. The object it holds 165 // can be freed on the compositor thread if it is the last to hold a 166 // reference but media::VideoFrame is a thread-safe ref-pointer. It is 167 // however read on the compositing thread so locking is required around all 168 // modifications on the main thread, and all reads on the compositing thread. 169 scoped_refptr<media::VideoFrame> current_frame_; 170 // |current_frame_used_| is updated on both main and compositing thread. 171 // It's used to track whether |current_frame_| was painted for detecting 172 // when to increase |dropped_frame_count_|. 173 bool current_frame_used_; 174 // |current_frame_lock_| protects |current_frame_used_| and |current_frame_|. 175 base::Lock current_frame_lock_; 176 bool pending_repaint_; 177 178 scoped_ptr<cc_blink::WebLayerImpl> video_weblayer_; 179 180 // A pointer back to the compositor to inform it about state changes. This is 181 // not NULL while the compositor is actively using this webmediaplayer. 182 cc::VideoFrameProvider::Client* video_frame_provider_client_; 183 184 bool received_first_frame_; 185 base::TimeDelta current_time_; 186 unsigned total_frame_count_; 187 unsigned dropped_frame_count_; 188 media::SkCanvasVideoRenderer video_renderer_; 189 190 scoped_refptr<MediaStreamAudioRenderer> audio_renderer_; 191 192 scoped_refptr<media::MediaLog> media_log_; 193 194 scoped_ptr<MediaStreamRendererFactory> renderer_factory_; 195 196 DISALLOW_COPY_AND_ASSIGN(WebMediaPlayerMS); 197 }; 198 199 } // namespace content 200 201 #endif // CONTENT_RENDERER_MEDIA_WEBMEDIAPLAYER_MS_H_ 202
