blob: bf563e8126d125c0878cabbc8674bbfcffdb0ed9 [file] [log] [blame]
// Copyright 2013 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.
#include "base/memory/ref_counted.h"
#include "base/memory/scoped_ptr.h"
#include "base/memory/weak_ptr.h"
#include "base/synchronization/lock.h"
#include "base/threading/thread_checker.h"
#include "cc/layers/video_frame_provider.h"
#include "media/filters/skcanvas_video_renderer.h"
#include "skia/ext/platform_canvas.h"
#include "third_party/WebKit/public/platform/WebMediaPlayer.h"
#include "url/gurl.h"
namespace blink {
class WebFrame;
class WebMediaPlayerClient;
namespace media {
class MediaLog;
namespace content {
class MediaStreamAudioRenderer;
class MediaStreamRendererFactory;
class VideoFrameProvider;
class WebLayerImpl;
class WebMediaPlayerDelegate;
// WebMediaPlayerMS delegates calls from WebCore::MediaPlayerPrivate to
// Chrome's media player when "src" is from media stream.
// WebMediaPlayerMS works with multiple objects, the most important ones are:
// VideoFrameProvider
// provides video frames for rendering.
// TODO(wjia): add AudioPlayer.
// AudioPlayer
// plays audio streams.
// blink::WebMediaPlayerClient
// WebKit client of this media player object.
class WebMediaPlayerMS
: public blink::WebMediaPlayer,
public cc::VideoFrameProvider,
public base::SupportsWeakPtr<WebMediaPlayerMS> {
// Construct a WebMediaPlayerMS with reference to the client, and
// a MediaStreamClient which provides VideoFrameProvider.
WebMediaPlayerMS(blink::WebFrame* frame,
blink::WebMediaPlayerClient* client,
base::WeakPtr<WebMediaPlayerDelegate> delegate,
media::MediaLog* media_log,
scoped_ptr<MediaStreamRendererFactory> factory);
virtual ~WebMediaPlayerMS();
virtual void load(LoadType load_type,
const blink::WebURL& url,
CORSMode cors_mode);
// Playback controls.
virtual void play();
virtual void pause();
virtual bool supportsSave() const;
virtual void seek(double seconds);
virtual void setRate(double rate);
virtual void setVolume(double volume);
virtual void setPreload(blink::WebMediaPlayer::Preload preload);
virtual blink::WebTimeRanges buffered() const;
virtual double maxTimeSeekable() const;
// Methods for painting.
virtual void paint(blink::WebCanvas* canvas,
const blink::WebRect& rect,
unsigned char alpha,
SkXfermode::Mode mode);
// TODO(dshwang): remove it because above method replaces.
virtual void paint(blink::WebCanvas* canvas,
const blink::WebRect& rect,
unsigned char alpha);
// True if the loaded media has a playable video/audio track.
virtual bool hasVideo() const;
virtual bool hasAudio() const;
// Dimensions of the video.
virtual blink::WebSize naturalSize() const;
// Getters of playback state.
virtual bool paused() const;
virtual bool seeking() const;
virtual double duration() const;
virtual double currentTime() const;
// Internal states of loading and network.
virtual blink::WebMediaPlayer::NetworkState networkState() const;
virtual blink::WebMediaPlayer::ReadyState readyState() const;
virtual bool didLoadingProgress();
virtual bool hasSingleSecurityOrigin() const;
virtual bool didPassCORSAccessCheck() const;
virtual double mediaTimeForTimeValue(double timeValue) const;
virtual unsigned decodedFrameCount() const;
virtual unsigned droppedFrameCount() const;
virtual unsigned audioDecodedByteCount() const;
virtual unsigned videoDecodedByteCount() const;
// VideoFrameProvider implementation.
virtual void SetVideoFrameProviderClient(
cc::VideoFrameProvider::Client* client) OVERRIDE;
virtual scoped_refptr<media::VideoFrame> GetCurrentFrame() OVERRIDE;
virtual void PutCurrentFrame(const scoped_refptr<media::VideoFrame>& frame)
// The callback for VideoFrameProvider to signal a new frame is available.
void OnFrameAvailable(const scoped_refptr<media::VideoFrame>& frame);
// Need repaint due to state change.
void RepaintInternal();
// The callback for source to report error.
void OnSourceError();
// Helpers that set the network/ready state and notifies the client if
// they've changed.
void SetNetworkState(blink::WebMediaPlayer::NetworkState state);
void SetReadyState(blink::WebMediaPlayer::ReadyState state);
// Getter method to |client_|.
blink::WebMediaPlayerClient* GetClient();
blink::WebFrame* frame_;
blink::WebMediaPlayer::NetworkState network_state_;
blink::WebMediaPlayer::ReadyState ready_state_;
blink::WebTimeRanges buffered_;
float volume_;
// Used for DCHECKs to ensure methods calls executed in the correct thread.
base::ThreadChecker thread_checker_;
blink::WebMediaPlayerClient* client_;
base::WeakPtr<WebMediaPlayerDelegate> delegate_;
// Specify content:: to disambiguate from cc::.
scoped_refptr<content::VideoFrameProvider> video_frame_provider_;
bool paused_;
// |current_frame_| is updated only on main thread. The object it holds
// can be freed on the compositor thread if it is the last to hold a
// reference but media::VideoFrame is a thread-safe ref-pointer. It is
// however read on the compositing thread so locking is required around all
// modifications on the main thread, and all reads on the compositing thread.
scoped_refptr<media::VideoFrame> current_frame_;
// |current_frame_used_| is updated on both main and compositing thread.
// It's used to track whether |current_frame_| was painted for detecting
// when to increase |dropped_frame_count_|.
bool current_frame_used_;
// |current_frame_lock_| protects |current_frame_used_| and |current_frame_|.
base::Lock current_frame_lock_;
bool pending_repaint_;
scoped_ptr<WebLayerImpl> video_weblayer_;
// A pointer back to the compositor to inform it about state changes. This is
// not NULL while the compositor is actively using this webmediaplayer.
cc::VideoFrameProvider::Client* video_frame_provider_client_;
bool received_first_frame_;
base::TimeDelta current_time_;
unsigned total_frame_count_;
unsigned dropped_frame_count_;
media::SkCanvasVideoRenderer video_renderer_;
scoped_refptr<MediaStreamAudioRenderer> audio_renderer_;
scoped_refptr<media::MediaLog> media_log_;
scoped_ptr<MediaStreamRendererFactory> renderer_factory_;
} // namespace content