tizen_src/chromium_impl/media/filters/media_player_bridge_capi.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 MEDIA_FILTERS_MEDIA_PLAYER_BRIDGE_CAPI_H_
   6 #define MEDIA_FILTERS_MEDIA_PLAYER_BRIDGE_CAPI_H_
   7
   8 #include <player.h>
   9 #include <player_internal.h>
  10
  11 #include "base/location.h"
  12 #include "base/memory/weak_ptr.h"
  13 #include "base/timer/timer.h"
  14 #include "content/public/browser/browser_message_filter.h"
  15 #include "media/base/efl/media_player_util_efl.h"
  16 #include "media/base/ranges.h"
  17 #include "media/base/renderer_client.h"
  18 #include "media/base/video_frame.h"
  19 #include "third_party/blink/public/platform/web_media_player.h"
  20 #include "tizen_src/chromium_impl/media/filters/media_player_tizen.h"
  21
  22 #if defined(TIZEN_VIDEO_HOLE)
  23 #include "tizen_src/chromium_impl/media/base/tizen/video_plane_controller.h"
  24 #include "ui/gfx/geometry/rect_f.h"
  25 #endif
  26
  27 typedef struct media_packet_s* media_packet_h;
  28
  29 enum PlayerState {
  30   PLAYER_STATE_DELAYED_NULL,
  31   PLAYER_STATE_DELAYED_PLAY,
  32   PLAYER_STATE_DELAYED_PAUSE,
  33   PLAYER_STATE_DELAYED_SEEK,
  34 };
  35
  36 namespace media {
  37 class MediaPlayerTizenClient;
  38
  39 class MEDIA_EXPORT MediaPlayerBridgeCapi : public MediaPlayerTizen {
  40  public:
  41   enum PlayerState {
  42     PLAYER_STATE_DELAYED_NULL,
  43     PLAYER_STATE_DELAYED_PLAY,
  44     PLAYER_STATE_DELAYED_PAUSE,
  45     PLAYER_STATE_DELAYED_SEEK,
  46   };
  47
  48   typedef struct range {
  49     int64_t start;
  50     int64_t end;
  51   } TimeRanges;
  52
  53   typedef base::OnceCallback<void(const bool)> CompleteCB;
  54
  55   MediaPlayerBridgeCapi(const GURL& url,
  56                         const std::string& user_agent,
  57                         double volume);
  58   MediaPlayerBridgeCapi(const MediaPlayerBridgeCapi&) = delete;
  59   MediaPlayerBridgeCapi& operator=(const MediaPlayerBridgeCapi&) = delete;
  60   ~MediaPlayerBridgeCapi() override;
  61
  62   // MediaPlayerTizen implementation.
  63   bool CreatePlayer(int player_id) override;
  64   void Initialize(VideoRendererSink* sink) override;
  65   bool IsInitialized() override;
  66   bool IsPrepared() override;
  67   bool CanPrepare() override;
  68   void Flush(base::OnceClosure flush_cb) override;
  69   void Release() override;
  70   void Prepare() override;
  71   void Resume();
  72   void Suspend();
  73   bool Play() override;
  74   void Pause(bool is_media_related_action) override;
  75   void SetRate(double rate) override;
  76   void Seek(base::TimeDelta time, base::OnceClosure seek_cb) override;
  77   void SetVolume(double volume) override;
  78   void SetStreamInfo(DemuxerStream::Type type, DemuxerStream* stream) override {
  79   }
  80   base::TimeDelta GetCurrentTime() override;
  81   MediaTypeFlags GetMediaType() const override { return media_type_; }
  82   void SetMediaType(DemuxerStream::Type type) override;
  83   void SetMediaType(MediaTypeFlags type) { media_type_ = type; }
  84   void OnBufferUpdate(int player_id, std::vector<TimeRanges> buffer_range);
  85   PlayerRoleFlags GetRoles() const noexcept override;
  86   void SetTaskRunner(
  87       const scoped_refptr<base::SingleThreadTaskRunner>& task_runner) override;
  88   void SetMediaPlayerClient(MediaPlayerTizenClient* client) override {
  89     client_ = client;
  90   }
  91   void SetParentalRatingResult(bool is_pass) override{};
  92
  93 #if defined(TIZEN_VIDEO_HOLE)
  94   void SetVideoHole(bool is_video_hole) override;
  95   void SetMediaGeometry(const gfx::Rect& viewport_rect,
  96                         const gfx::RectF& rect) override;
  97 #endif
  98   void RequestSuspend(bool resource_conflicted) override;
  99
 100   void ExecuteDelayedPlayerState();
 101
 102   void OnPlaybackCompleteUpdate();
 103   void OnSeekCompleteUpdate();
 104   void OnPlayerPrepared();
 105   void OnHandleBufferingStatus(int percent);
 106   void OnHandlePlayerError(int player_error_code, const base::Location& loc);
 107   void OnResourceConflict();
 108   void OnResumeComplete(bool success);
 109   void OnMediaPacketUpdated(media_packet_h packet);
 110
 111   void OnDurationChange(int player_id, double duration);
 112   void OnTimeChanged(int player_id);
 113   void OnTimeUpdate(int player_id, base::TimeDelta current_time);
 114   void OnReadyStateChange(int player_id,
 115                           blink::WebMediaPlayer::ReadyState state);
 116   void OnNetworkStateChange(int player_id,
 117                             blink::WebMediaPlayer::NetworkState state);
 118   void OnMediaDataChange(int player_id, int width, int height, int media);
 119   bool IsPlayerSuspended() { return suspended_; }
 120   bool player_prepared_{false};
 121
 122  protected:
 123   void OnMediaError(MediaError error_type);
 124   void DeliverMediaPacket(ScopedMediaPacket packet);
 125 #if defined(TIZEN_TBM_SUPPORT)
 126   void DestroyMediaPacket(void* media_packet) override;
 127   void OnNewTbmBufferAvailable(int player_id,
 128                                gfx::TbmBufferHandle tbm_handle,
 129                                base::TimeDelta timestamp);
 130 #else
 131   void OnNewFrameAvailable(int player_id,
 132                            base::UnsafeSharedMemoryRegion shm_region,
 133                            uint32_t length,
 134                            base::TimeDelta timestamp);
 135 #endif
 136   MediaPlayerTizenClient* GetMediaPlayerClient() const override {
 137     return client_;
 138   }
 139   player_state_e GetPlayerState();
 140
 141   // Both used by Tizen TV and other platform
 142   bool SetPlayerPrepareAsync();
 143   virtual void PlayerPrepared();
 144   virtual void PlaybackCompleteUpdate();
 145   virtual bool PreloadIfNeeded(int& ret) { return false; };
 146   virtual void UpdateMediaType();
 147   virtual void UpdateDuration();
 148
 149   GURL url_;
 150   bool is_live_stream_{false};
 151   int player_id_ = 0;
 152   int delayed_player_state_;
 153   player_h player_ = nullptr;
 154
 155   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
 156   base::TimeDelta pending_seek_duration_{base::TimeDelta()};
 157   MediaTypeFlags media_type_{MediaType::Invalid};
 158   int width_{0};
 159   int height_{0};
 160
 161   base::TimeDelta duration_{base::TimeDelta()};
 162   bool is_preparing_{false};
 163   bool is_play_pending_{false};
 164   bool suspended_{false};
 165
 166  private:
 167   // |duration_update_timer_| related
 168   void OnCurrentTimeUpdateTimerFired();
 169   void StartCurrentTimeUpdateTimer();
 170   void StopCurrentTimeUpdateTimer();
 171
 172   // |buffering_update_timer_| related
 173   void OnBufferingUpdateTimerFired();
 174   void StartBufferingUpdateTimer();
 175   void StopBufferingUpdateTimer();
 176
 177   void OnTimeChanged();
 178   void UpdateSeekState(bool state);
 179
 180   void SeekCompleteUpdate();
 181   void HandleBufferingStatus(int percent);
 182
 183   void SeekInternal(base::TimeDelta time);
 184
 185   MediaPlayerTizenClient* client_ = nullptr;
 186
 187   bool is_end_reached_{false};
 188   bool is_file_url_{false};
 189   bool is_paused_{false};
 190   bool is_seeking_{false};
 191   bool is_set_playback_rate_delayed_{false};
 192
 193   double playback_rate_{1.0};
 194   double volume_{0.0};
 195
 196   base::OnceClosure seek_cb_;
 197   base::RepeatingTimer current_time_update_timer_;
 198   base::RepeatingTimer buffering_update_timer_;
 199   std::string user_agent_;
 200   base::TimeDelta playback_time_{base::TimeDelta()};
 201   base::TimeDelta seek_duration_{base::TimeDelta()};
 202
 203 #if defined(TIZEN_VIDEO_HOLE)
 204   bool is_video_hole_{false};
 205   gfx::Rect delayed_viewport_rect_;
 206   gfx::RectF delayed_rect_;
 207   std::unique_ptr<VideoPlaneController> video_plane_controller_;
 208 #endif
 209
 210   // NOTE: Weak pointers must be invalidated before all other member variables.
 211   base::WeakPtrFactory<MediaPlayerBridgeCapi> weak_factory_;
 212 };
 213
 214 }  // namespace media
 215
 216 #endif  // MEDIA_FILTERS_MEDIA_PLAYER_BRIDGE_CAPI_H_