tizen_src/chromium_impl/content/renderer/media/efl/webmediaplayer_efl.h

   1 // Copyright 2015 Samsung Electronics Inc. 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_EFL_WEBMEDIAPLAYER_EFL_H_
   6 #define CONTENT_RENDERER_MEDIA_EFL_WEBMEDIAPLAYER_EFL_H_
   7
   8 #include <vector>
   9
  10 #include "base/message_loop/message_loop.h"
  11 #include "base/memory/shared_memory.h"
  12 #include "cc/layers/video_frame_provider_client_impl.h"
  13 #include "content/common/media/tizen/media_player_messages_enums_tizen.h"
  14 #include "content/renderer/media/efl/media_source_delegate_efl.h"
  15 #include "content/renderer/media/efl/renderer_media_player_manager_efl.h"
  16 #include "media/base/efl/media_player_efl.h"
  17 #include "media/blink/skcanvas_video_renderer.h"
  18 #include "media/blink/video_frame_compositor.h"
  19 #include "third_party/WebKit/public/platform/WebMediaPlayer.h"
  20
  21 #if defined(TIZEN_MULTIMEDIA_EME_SUPPORT)
  22 #include "media/blink/encrypted_media_player_support.h"
  23 #endif
  24
  25 namespace blink {
  26 class WebFrame;
  27 class WebMediaPlayerClient;
  28 }
  29
  30 namespace cc_blink {
  31 class WebLayerImpl;
  32 }
  33
  34 namespace media {
  35 class GpuVideoAcceleratorFactories;
  36 class MediaLog;
  37 class MediaPlayerEfl;
  38 class WebMediaPlayerDelegate;
  39 }
  40
  41 namespace content {
  42 class RendererMediaPlayerManager;
  43
  44 // This class implements blink::WebMediaPlayer by keeping the efl
  45 // media player in the browser process. It listens to all the status changes
  46 // sent from the browser process and sends playback controls to the media
  47 // player.
  48 class WebMediaPlayerEfl
  49     : public blink::WebMediaPlayer,
  50       public cc::VideoFrameProvider,
  51       public base::MessageLoop::DestructionObserver,
  52       public base::SupportsWeakPtr<WebMediaPlayerEfl> {
  53  public:
  54   // Construct a WebMediaPlayerEfl object. This class communicates
  55   // with the WebMediaPlayerEfl object in the browser process through
  56   // |proxy|.
  57   WebMediaPlayerEfl(
  58       RendererMediaPlayerManager* manager,
  59       blink::WebFrame* frame,
  60       blink::WebMediaPlayerClient* client,
  61       base::WeakPtr<media::WebMediaPlayerDelegate> delegate);
  62   ~WebMediaPlayerEfl() override;
  63
  64   // blink::WebMediaPlayer implementation.
  65   void load(LoadType load_type,
  66             const blink::WebURL& url,
  67             CORSMode cors_mode) override;
  68
  69   // Playback controls.
  70   void play() override;
  71   void pause() override;
  72   bool supportsSave() const override;
  73   void seek(double seconds) override;
  74   void setRate(double) override;
  75   void setVolume(double) override;
  76   blink::WebTimeRanges buffered() const override;
  77   blink::WebTimeRanges seekable() const override;
  78
  79   void paint(blink::WebCanvas*,
  80       const blink::WebRect&,
  81       unsigned char alpha,
  82       SkXfermode::Mode) override;
  83
  84   // True if the loaded media has a playable video/audio track.
  85   bool hasVideo() const override;
  86   bool hasAudio() const override;
  87
  88   // Dimension of the video.
  89   blink::WebSize naturalSize() const override;
  90
  91   // Getters of playback state.
  92   bool paused() const override;
  93   bool seeking() const override;
  94   double duration() const override;
  95   double currentTime() const override;
  96
  97   // Internal states of loading and network.
  98   NetworkState networkState() const override;
  99   ReadyState readyState() const override;
 100
 101   bool didLoadingProgress() override;
 102
 103   bool hasSingleSecurityOrigin() const override;
 104   bool didPassCORSAccessCheck() const override;
 105
 106   double mediaTimeForTimeValue(double timeValue) const override;
 107
 108   unsigned decodedFrameCount() const override;
 109   unsigned droppedFrameCount() const override;
 110   unsigned audioDecodedByteCount() const override;
 111   unsigned videoDecodedByteCount() const override;
 112
 113   // cc::VideoFrameProvider implementation.
 114   void SetVideoFrameProviderClient(
 115       cc::VideoFrameProvider::Client* client) override;
 116   scoped_refptr<media::VideoFrame> GetCurrentFrame() override;
 117   void PutCurrentFrame(
 118       const scoped_refptr<media::VideoFrame>& frame) override {};
 119
 120   // Method inherited from DestructionObserver.
 121   void WillDestroyCurrentMessageLoop() override {};
 122 #if defined(TIZEN_MULTIMEDIA_EME_SUPPORT)
 123   virtual MediaKeyException generateKeyRequest(
 124       const blink::WebString& key_system,
 125       const unsigned char* init_data,
 126       unsigned init_data_length);
 127
 128   virtual MediaKeyException addKey(const blink::WebString& key_system,
 129                                    const unsigned char* key,
 130                                    unsigned key_length,
 131                                    const unsigned char* init_data,
 132                                    unsigned init_data_length,
 133                                    const blink::WebString& session_id);
 134
 135   virtual MediaKeyException cancelKeyRequest(
 136       const blink::WebString& key_system,
 137       const blink::WebString& session_id);
 138
 139   // TODO(jrummell): Remove this method once Blink updated to use the other
 140   // method.
 141   virtual void setContentDecryptionModule(
 142       blink::WebContentDecryptionModule* cdm);
 143   virtual void setContentDecryptionModule(
 144       blink::WebContentDecryptionModule* cdm,
 145       blink::WebContentDecryptionModuleResult result);
 146 #endif
 147
 148   void SetReadyState(WebMediaPlayer::ReadyState state);
 149   void SetNetworkState(WebMediaPlayer::NetworkState state);
 150
 151   void OnNewFrameAvailable(base::SharedMemoryHandle foreign_memory_handle,
 152       uint32 length, base::TimeDelta timestamp);
 153
 154 #if defined(TIZEN_MULTIMEDIA_PIXMAP_SUPPORT)
 155   void OnPlatformSurfaceUpdated(int pixmap_id, base::TimeDelta timestamp);
 156 #endif
 157
 158   void OnMediaDataChange(int format, int height, int width, int media);
 159   void OnDurationChange(double duration);
 160   void OnTimeUpdate(double current_time);
 161   void OnBufferUpdate(
 162       std::vector<media::MediaPlayerEfl::TimeRanges> buffer_range);
 163   void OnTimeChanged();
 164   void OnPauseStateChange(bool state);
 165   void OnSeekStateChange(bool state);
 166   void OnRequestSeek(double seek_time);
 167
 168   void OnMediaSourceOpened(blink::WebMediaSource* web_media_source);
 169   void OnDemuxerSeekDone();
 170
 171   void RequestPause();
 172
 173  private:
 174   void OnNaturalSizeChanged(gfx::Size size);
 175   void OnOpacityChanged(bool opaque);
 176
 177   // Returns the current video frame from |compositor_|. Blocks until the
 178   // compositor can return the frame.
 179   scoped_refptr<media::VideoFrame> GetCurrentFrameFromCompositor();
 180
 181   // Called whenever there is new frame to be painted.
 182   void FrameReady(const scoped_refptr<media::VideoFrame>& frame);
 183
 184   blink::WebFrame* frame_;
 185
 186   blink::WebMediaPlayer::NetworkState network_state_;
 187   blink::WebMediaPlayer::ReadyState ready_state_;
 188
 189   // Message loops for posting tasks on Chrome's main thread. Also used
 190   // for DCHECKs so methods calls won't execute in the wrong thread.
 191   const scoped_refptr<base::MessageLoopProxy> main_loop_;
 192   scoped_refptr<base::SingleThreadTaskRunner> media_task_runner_;
 193
 194   // Manager for managing this object and for delegating method calls on
 195   // Render Thread.
 196   content::RendererMediaPlayerManager* manager_;
 197
 198   blink::WebMediaPlayerClient* client_;
 199
 200   scoped_refptr<media::MediaLog> media_log_;
 201
 202   base::WeakPtr<media::WebMediaPlayerDelegate> delegate_;
 203
 204   // The compositor layer for displaying the video content when using
 205   // composited playback.
 206   scoped_ptr<cc_blink::WebLayerImpl> video_weblayer_;
 207
 208   // Video rendering members.
 209   scoped_refptr<base::SingleThreadTaskRunner> compositor_task_runner_;
 210   media::VideoFrameCompositor* compositor_;
 211   media::SkCanvasVideoRenderer skcanvas_video_renderer_;
 212
 213   base::WeakPtrFactory<WebMediaPlayerEfl> weak_factory_;
 214   scoped_ptr<content::MediaSourceDelegateEfl> media_source_delegate_;
 215   MediaPlayerHostMsg_Initialize_Type player_type_;
 216
 217   // Player ID assigned by the |manager_|.
 218   int player_id_;
 219
 220   uint32 gst_video_format_;
 221   int gst_width_;
 222   int gst_height_;
 223
 224   bool audio_;
 225   bool video_;
 226
 227   double current_time_;
 228   double duration_;
 229   bool is_paused_;
 230
 231   bool is_seeking_;
 232   double seek_time_;
 233   bool pending_seek_;
 234   double pending_seek_time_;
 235
 236   // Whether the video is known to be opaque or not.
 237   bool opaque_;
 238
 239   gfx::Size natural_size_;
 240   blink::WebTimeRanges buffered_;
 241   mutable bool did_loading_progress_;
 242
 243   // Factories for supporting video accelerators. May be null.
 244   scoped_refptr<media::GpuVideoAcceleratorFactories> gpu_factories_;
 245 #if defined(TIZEN_MULTIMEDIA_EME_SUPPORT)
 246   scoped_ptr<media::EncryptedMediaPlayerSupport> encrypted_media_support_;
 247 #endif
 248
 249   DISALLOW_COPY_AND_ASSIGN(WebMediaPlayerEfl);
 250 };
 251
 252 }  // namespace content
 253
 254 #endif  // CONTENT_RENDERER_MEDIA_EFL_WEBMEDIAPLAYER_EFL_H_