review.tizen.org Git - platform/framework/web/crosswalk-tizen.git/blob

   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 MEDIA_BASE_TIZEN_MEDIA_SOURCE_PLAYER_CAPI_H_
   6 #define MEDIA_BASE_TIZEN_MEDIA_SOURCE_PLAYER_CAPI_H_
   7
   8 #include <player.h>
   9
  10 #include "base/cancelable_callback.h"
  11 #include "base/threading/thread.h"
  12 #include "base/time/default_tick_clock.h"
  13 #include "base/timer/timer.h"
  14 #include "media/base/decoder_buffer.h"
  15 #include "media/base/tizen/demuxer_efl.h"
  16 #include "media/base/tizen/media_player_efl.h"
  17 #include "media/base/tizen/media_player_util_efl.h"
  18 #include "third_party/WebKit/public/platform/WebMediaPlayer.h"
  19
  20
  21 #if defined(OS_TIZEN_TV_PRODUCT)
  22 #include <player_product.h>
  23 #endif
  24
  25 #if defined(TIZEN_VIDEO_HOLE)
  26 #include "ui/gfx/geometry/rect_f.h"
  27 #endif
  28
  29 namespace media {
  30
  31 using player_buffer_size_t = unsigned long long;
  32 const size_t kCapiPlayerChannelCount = 2;
  33
  34 class MediaPacket {
  35  public:
  36   MediaPacket(base::TimeDelta timestamp,
  37               base::TimeDelta time_duration,
  38               media_format_s* format,
  39               media::DemuxerStream::Type type);
  40
  41   virtual ~MediaPacket();
  42
  43   media_packet_h PrepareAndGet();
  44   media_packet_h Get() const;
  45   virtual std::string ToString() const;
  46
  47  protected:
  48   virtual bool Prepare(ScopedMediaPacket& packet);
  49   void SetMediaPacket(ScopedMediaPacket packet);
  50   static bool SetPts(media_packet_h packet, base::TimeDelta timestamp);
  51   static bool SetDuration(media_packet_h packet, base::TimeDelta time_duration);
  52
  53   bool is_prepared_ = false;
  54   ScopedMediaPacket media_packet_;
  55   base::TimeDelta timestamp_;
  56   base::TimeDelta time_duration_;
  57   media_format_s* format_;
  58   media::DemuxerStream::Type type_;
  59 };
  60
  61 class BufferObserver;
  62 class VideoPlaneManagerTizen;
  63
  64 // This class handles media source extensions for CAPI port.
  65 class MEDIA_EXPORT MediaSourcePlayerCapi
  66     : public MediaPlayerEfl, public DemuxerEflClient {
  67  public:
  68   typedef base::Callback<void(const bool)> CompleteCB;
  69   typedef std::queue<scoped_refptr<DecoderBuffer>> BufferQueue;
  70
  71   // Player Buffer:          0% ---------------- 100%
  72   // Buffer Status: UNDERRUN | MIN | NORMAL | MAX | OVERFLOW
  73   // . BUFFER_NONE: Initial state.
  74   // . BUFFER_EOS: EOS reached.
  75   enum BufferStatus {
  76     BUFFER_NONE,
  77     BUFFER_UNDERRUN,
  78     BUFFER_MIN_THRESHOLD,
  79     BUFFER_NORMAL,
  80     BUFFER_MAX_THRESHOLD,
  81     BUFFER_OVERFLOW,
  82     BUFFER_EOS,
  83   };
  84
  85   enum SendMediaPacketResult {
  86     SUCCESS,
  87     FAILURE,
  88     BUFFER_SPACE,
  89   };
  90
  91   MediaSourcePlayerCapi(int player_id,
  92                         std::unique_ptr<DemuxerEfl> demuxer,
  93                         MediaPlayerManager* manager,
  94                         bool video_hole);
  95
  96   ~MediaSourcePlayerCapi() override;
  97
  98   // MediaPlayerEfl implementation.
  99   void Play() override;
 100   void Pause(bool is_media_related_action) override;
 101   void SetRate(double rate) override;
 102   void Seek(base::TimeDelta time) override;
 103   void SetVolume(double volume) override;
 104   base::TimeDelta GetCurrentTime() override;
 105   void Initialize() override;
 106
 107   // DemuxerEflClient implementation.
 108   void OnDemuxerConfigsAvailable(
 109       const DemuxerConfigs& params) override;
 110 #if defined(OS_TIZEN_TV_PRODUCT)
 111   void OnDemuxerStateChanged(const DemuxerConfigs& params) override;
 112 #endif
 113   void OnDemuxerDataAvailable(
 114       base::SharedMemoryHandle foreign_memory_handle,
 115       const media::DemuxedBufferMetaData& meta_data) override;
 116   void OnDemuxerSeekDone(
 117       const base::TimeDelta& actual_browser_seek_time) override;
 118   void OnDemuxerDurationChanged(base::TimeDelta duration) override;
 119 #if defined(TIZEN_VIDEO_HOLE)
 120   void SetGeometry(const gfx::RectF&) override;
 121   void OnWebViewMoved() override;
 122 #endif
 123   void ConfirmStateChange();
 124
 125   void EnteredFullscreen() override;
 126   void ExitedFullscreen() override;
 127
 128   bool HasConfigs() const override;
 129
 130 #if defined(TIZEN_MULTIMEDIA_SUPPORT)
 131   void LaunchSystemVolumeController() override;
 132 #endif
 133
 134  protected:
 135   void Release() override;
 136   void OnMediaError(MediaError error_type) override;
 137
 138  private:
 139   struct ChannelData {
 140     bool is_eos_ = false;
 141     bool should_feed_ = false;
 142     ScopedMediaFormat media_format_;
 143     BufferQueue buffer_queue_;
 144   };
 145
 146   player_state_e GetPlayerState();
 147   void HandlePrepareComplete();
 148
 149   // For internal seeks.
 150   void SeekInternal();
 151   void UpdateSeekState(MediaSeekState state);
 152   void HandleSeekComplete();
 153   void SeekDone();
 154   void ReadDemuxedDataIfNeed(media::DemuxerStream::Type type);
 155
 156   void HandleBufferingStatusChanged(media::DemuxerStream::Type type,
 157                                     BufferStatus status);
 158   void OnResumeComplete(bool success);
 159   void OnInitComplete(bool success);
 160   void HandlePlaybackComplete();
 161   void SendEosToCapi(const media::DemuxedBufferMetaData& meta_data);
 162   void HandlePlayerError(int player_error_code,
 163                          const tracked_objects::Location& loc);
 164
 165   // |current_time_update_timer_| related
 166   void OnCurrentTimeUpdateTimerFired();
 167   void StartCurrentTimeUpdateTimer();
 168   void StopCurrentTimeUpdateTimer();
 169
 170   ChannelData& GetChannelData(DemuxerStream::Type type);
 171   const ChannelData& GetChannelData(DemuxerStream::Type type) const;
 172   bool IsEos(DemuxerStream::Type type) const;
 173   void SetEos(DemuxerStream::Type type, bool value);
 174   bool ShouldFeed(DemuxerStream::Type type) const;
 175   void SetShouldFeed(DemuxerStream::Type type, bool value);
 176   media_format_s* GetMediaFormat(DemuxerStream::Type type) const;
 177   void SetMediaFormat(media_format_s* format, DemuxerStream::Type type);
 178   BufferQueue& GetBufferQueue(DemuxerStream::Type type);
 179   void ClearBufferQueue(DemuxerStream::Type type);
 180
 181   void ReadFromQueueIfNeeded(DemuxerStream::Type type);
 182   bool ReadFromQueue(DemuxerStream::Type type);
 183
 184   std::unique_ptr<MediaPacket> CreateEosMediaPacket(DemuxerStream::Type type);
 185   std::unique_ptr<MediaPacket> CreateMediaPacket(
 186       scoped_refptr<DecoderBuffer> buffer,
 187       DemuxerStream::Type type);
 188   std::unique_ptr<MediaPacket> CreateMediaPacket(
 189       base::SharedMemoryHandle foreign_memory_handle,
 190       const media::DemuxedBufferMetaData& meta_data);
 191   SendMediaPacketResult PushMediaPacket(MediaPacket& media_packet);
 192
 193   void SaveDecoderBuffer(
 194       base::SharedMemoryHandle foreign_memory_handle,
 195       const media::DemuxedBufferMetaData& meta_data);
 196
 197   // Returns Max buffer size for audio / video
 198   player_buffer_size_t GetMaxBufferSize(media::DemuxerStream::Type type,
 199                                         const DemuxerConfigs& configs);
 200
 201   void UpdateVideoBufferSize(player_buffer_size_t buffer_size_in_bytes);
 202   void Suspend() override;
 203   void Resume() override;
 204   bool Prepare(CompleteCB cb);
 205   bool SetAudioStreamInfo();
 206   bool SetVideoStreamInfo();
 207
 208   // Set |media_type_| based on Demuxer configs
 209   void SetMediaType(const DemuxerConfigs& configs);
 210   void RunCompleteCB(bool success, const tracked_objects::Location& from);
 211
 212   static void OnPrepareComplete(void* user_data);
 213   static void OnSeekComplete(void* user_data);
 214   static void OnMediaPacketUpdated(media_packet_h packet, void* user_data);
 215   static void OnPlaybackComplete(void* user_data);
 216   static void OnPlayerError(int error_code, void* user_data);
 217   static void OnInterrupted(player_interrupted_code_e code, void* user_data);
 218
 219 #if defined(OS_TIZEN_TV_PRODUCT)
 220   void UpdateResolution(int width, int height, int media_type);
 221 #endif
 222
 223 #if defined(TIZEN_MULTIMEDIA_SUPPORT)
 224   int GetSystemMediaVolume();
 225   void UpdateSystemMediaVolume();
 226 #endif
 227
 228   // CAPI player state handling APIs.
 229   void ExecuteDelayedPlayerState();
 230   void SetDelayedPlayerState(player_state_e state);
 231   bool ChangePlayerState(player_state_e state);
 232
 233   bool ShouldDestroyMediaPacket() const {
 234     return is_video_hole_ && is_fullscreen_;
 235   }
 236
 237   std::unique_ptr<DemuxerEfl> demuxer_;
 238   std::unique_ptr<BufferObserver> buffer_observer_;
 239   player_buffer_size_t max_audio_buffer_size_;
 240   player_buffer_size_t max_video_buffer_size_;
 241   const scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
 242
 243   base::TimeDelta duration_;
 244   double playback_rate_;
 245
 246   bool player_prepared_;
 247   bool paused_by_buffering_logic_;
 248
 249   bool pending_seek_;
 250   bool pending_seek_on_player_;
 251   base::TimeDelta pending_demuxer_seek_position_;
 252   base::TimeDelta pending_seek_offset_;
 253   // To track CAPI player state change. Will be reset once player state
 254   // change is success.
 255   player_state_e player_new_state_;
 256
 257   // To handle state change requests that has to be executed after completing
 258   // current task.
 259   player_state_e delayed_player_state_;
 260
 261   base::TimeDelta seek_offset_;
 262   MediaSeekState seek_state_;
 263
 264   bool is_fullscreen_;
 265   bool is_video_hole_;
 266   double volume_;
 267 #if defined(TIZEN_VIDEO_HOLE)
 268   std::unique_ptr<VideoPlaneManagerTizen> video_plane_manager_;
 269 #endif
 270
 271 #if defined(OS_TIZEN_TV_PRODUCT)
 272   player_media_stream_audio_extra_info_s audio_extra_info_;
 273   player_media_stream_video_extra_info_s video_extra_info_;
 274   std::vector<uint8_t> video_codec_extra_data_;
 275   std::vector<uint8_t> audio_codec_extra_data_;
 276   std::string hdr_info_;
 277   bool is_demuxer_state_reported_;
 278   base::TimeDelta cached_current_time_;
 279 #endif
 280
 281   std::array<ChannelData, kCapiPlayerChannelCount> channel_data_;
 282
 283   CompleteCB complete_callback_;
 284
 285   base::RepeatingTimer current_time_update_timer_;
 286   base::WeakPtrFactory<MediaSourcePlayerCapi> weak_factory_;
 287
 288 #if defined(TIZEN_MULTIMEDIA_SUPPORT)
 289   int system_media_volume_;
 290 #endif
 291
 292   DISALLOW_COPY_AND_ASSIGN(MediaSourcePlayerCapi);
 293 };
 294
 295 }  // namespace media
 296
 297 #endif  // MEDIA_BASE_TIZEN_MEDIA_SOURCE_PLAYER_CAPI_H_