tizen_src/impl/media/base/tizen/webmediaplayer_tizen.h

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