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

   1 // Copyright 2016 Samsung Electronics. 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_BROWSER_RENDERER_HOST_PEPPER_MEDIA_PLAYER_TIZEN_PEPPER_MEDIA_PLAYER_PRIVATE_TIZEN_H_
   6 #define CONTENT_BROWSER_RENDERER_HOST_PEPPER_MEDIA_PLAYER_TIZEN_PEPPER_MEDIA_PLAYER_PRIVATE_TIZEN_H_
   7
   8 #include <memory>
   9 #include <string>
  10 #include <vector>
  11
  12 #include <Evas.h>
  13
  14 #include "base/timer/timer.h"
  15 #include "base/single_thread_task_runner.h"
  16 #include "content/browser/renderer_host/pepper/media_player/pepper_media_player_private.h"
  17 #include "content/browser/renderer_host/pepper/media_player/pepper_media_data_source_private.h"
  18 #include "content/browser/renderer_host/pepper/media_player/tizen/pepper_tizen_drm_manager.h"
  19 #include "content/browser/renderer_host/pepper/media_player/tizen/pepper_tizen_player_dispatcher.h"
  20 #include "content/browser/renderer_host/pepper/media_player/tizen/pepper_player_adapter_interface.h"
  21 #include "ppapi/c/pp_errors.h"
  22 #include "ppapi/c/samsung/pp_media_player_samsung.h"
  23
  24 namespace tracked_objects {
  25 class Location;
  26 }  // namespace tracked_objects
  27
  28 namespace content {
  29
  30 class PepperMediaDataSourcePrivate;
  31
  32 class PepperMediaPlayerPrivateTizen : public PepperMediaPlayerPrivate {
  33  public:
  34   static scoped_refptr<PepperMediaPlayerPrivateTizen> Create(
  35       std::unique_ptr<PepperPlayerAdapterInterface> player);
  36
  37   // PepperMediaPlayerPrivate
  38   void SetBufferingListener(std::unique_ptr<BufferingListenerPrivate>) override;
  39   void SetDRMListener(std::unique_ptr<DRMListenerPrivate>) override;
  40   void SetMediaEventsListener(
  41       std::unique_ptr<MediaEventsListenerPrivate>) override;
  42   void SetSubtitleListener(std::unique_ptr<SubtitleListenerPrivate>) override;
  43
  44   void AttachDataSource(const scoped_refptr<PepperMediaDataSourcePrivate>&,
  45                         const base::Callback<void(int32_t)>& callback) override;
  46   void DetachDataSource();
  47
  48   void Play(const base::Callback<void(int32_t)>& callback) override;
  49   void Pause(const base::Callback<void(int32_t)>& callback) override;
  50   void Stop(const base::Callback<void(int32_t)>& callback) override;
  51   void Seek(PP_TimeTicks,
  52             const base::Callback<void(int32_t)>& callback) override;
  53
  54   void SetPlaybackRate(double rate,
  55                        const base::Callback<void(int32_t)>& callback) override;
  56   void GetDuration(
  57       const base::Callback<void(int32_t, PP_TimeDelta)>& callback) override;
  58   void GetCurrentTime(
  59       const base::Callback<void(int32_t, PP_TimeTicks)>& callback) override;
  60
  61   void GetPlayerState(const base::Callback<void(int32_t, PP_MediaPlayerState)>&
  62                           callback) override;
  63
  64   void GetVideoTracksList(const base::Callback<
  65                           void(int32_t, const std::vector<PP_VideoTrackInfo>&)>&
  66                               callback) override;
  67   void GetCurrentVideoTrackInfo(
  68       const base::Callback<void(int32_t, const PP_VideoTrackInfo&)>& callback)
  69       override;
  70
  71   void GetAudioTracksList(const base::Callback<
  72                           void(int32_t, const std::vector<PP_AudioTrackInfo>&)>&
  73                               callback) override;
  74   void GetCurrentAudioTrackInfo(
  75       const base::Callback<void(int32_t, const PP_AudioTrackInfo&)>& callback)
  76       override;
  77
  78   void GetTextTracksList(
  79       const base::Callback<void(int32_t, const std::vector<PP_TextTrackInfo>&)>&
  80           callback) override;
  81   void GetCurrentTextTrackInfo(
  82       const base::Callback<void(int32_t, const PP_TextTrackInfo&)>& callback)
  83       override;
  84
  85   void SelectTrack(PP_ElementaryStream_Type_Samsung,
  86                    uint32_t track_index,
  87                    const base::Callback<void(int32_t)>& callback) override;
  88
  89   void AddExternalSubtitles(
  90       const std::string& file_path,
  91       const std::string& encoding,
  92       const base::Callback<void(int32_t, const PP_TextTrackInfo&)>& callback)
  93       override;
  94   void SetSubtitlesDelay(
  95       PP_TimeDelta delay,
  96       const base::Callback<void(int32_t)>& callback) override;
  97
  98   void SetDisplayRect(const PP_Rect& display_rect,
  99                       const PP_FloatRect& crop_ratio_rect,
 100                       const base::Callback<void(int32_t)>& callback) override;
 101
 102   void SetDRMSpecificData(
 103       PP_MediaPlayerDRMType,
 104       PP_MediaPlayerDRMOperation,
 105       const void*,
 106       size_t,
 107       const base::Callback<void(int32_t)>& callback) override;
 108
 109   // Listeners
 110   void OnLicenseRequest(const std::vector<uint8_t>& request);
 111
 112   void OnErrorEvent(PP_MediaPlayerError error_code);
 113   void OnSeekCompleted();
 114   void OnDRMEvent(int event_type, void* msg_data);
 115
 116  private:
 117   friend class base::RefCountedThreadSafe<PepperMediaPlayerPrivateTizen>;
 118   explicit PepperMediaPlayerPrivateTizen(
 119       std::unique_ptr<PepperPlayerAdapterInterface> player);
 120   ~PepperMediaPlayerPrivateTizen() override;
 121
 122   // Aborts all pending callbacks.
 123   void AbortCallbacks(int32_t reason);
 124
 125   // Invalidates player's dispatcher when it can't be reused in further calls.
 126   // This can happen eg. when muse-server has crashed
 127   void InvalidatePlayer();
 128
 129   void StartCurrentTimeNotifier();
 130   void StopCurrentTimeNotifier();
 131
 132   // Executes and resets a given callback. Logs on_cb_empty_message if
 133   // callback is not set, or skips printing if it's nullptr.
 134   // Please note callbacks must only be executed on the main thread.
 135   void ExecuteCallback(int32_t result,
 136                        base::Callback<void(int32_t)>* callback,
 137                        const char* on_cb_empty_message = nullptr);
 138   // dispatcher call helpers
 139
 140   // Returns false if there is no need to fail (i.e. data source is attached)
 141   // or runs a callback with an error and then returns true.
 142   template <typename Functor, typename... Args>
 143   bool FailIfNotAttached(const tracked_objects::Location& from_here,
 144                          const Functor& callback,
 145                          const Args&... args) {
 146     if (data_source_)
 147       return false;
 148
 149     base::MessageLoop::current()->task_runner()->PostTask(
 150         from_here,
 151         base::Bind(callback, static_cast<int32_t>(PP_ERROR_FAILED), args...));
 152     return true;
 153   }
 154
 155   // Player operations
 156
 157   void UpdateDisplayRect(const base::Callback<void(int32_t)>&);
 158
 159   void OnDataSourceAttached(int32_t result);
 160
 161   void SeekOnPlayerThread(PP_TimeTicks, PepperPlayerAdapterInterface*);
 162
 163   void GetAudioTracksListOnPlayerThread(
 164       const base::Callback<void(int32_t,
 165                                 const std::vector<PP_AudioTrackInfo>&)>&,
 166       PepperPlayerAdapterInterface*);
 167   void GetCurrentAudioTrackInfoOnPlayerThread(
 168       const base::Callback<void(int32_t, const PP_AudioTrackInfo&)>&,
 169       PepperPlayerAdapterInterface*);
 170   void GetTextTracksListOnPlayerThread(
 171       const base::Callback<void(int32_t,
 172                                 const std::vector<PP_TextTrackInfo>&)>&,
 173       PepperPlayerAdapterInterface*);
 174   void GetCurrentTextTrackInfoOnPlayerThread(
 175       const base::Callback<void(int32_t, const PP_TextTrackInfo&)>&,
 176       PepperPlayerAdapterInterface*);
 177   void InitializeDisplayOnPlayerThread(PepperPlayerAdapterInterface* player);
 178   void SetDisplayCropRatioOnPlayerThread(
 179       const PP_FloatRect&,
 180       const base::Callback<void(int32_t)>& callback,
 181       PepperPlayerAdapterInterface*);
 182
 183   int32_t SetExternalSubtitlePathOnPlayerThread(const std::string& path,
 184                                                 const std::string& encoding,
 185                                                 PepperPlayerAdapterInterface*,
 186                                                 PP_TextTrackInfo*);
 187
 188   void SetSubtitleEncodingOnPlayerThread(PepperPlayerAdapterInterface* player);
 189
 190   void OnTimeNeedsUpdate();
 191
 192   void OnStoppedReply(int32_t result);
 193
 194   std::unique_ptr<PepperTizenPlayerDispatcher> dispatcher_;
 195   scoped_refptr<PepperMediaDataSourcePrivate> data_source_;
 196
 197   std::unique_ptr<DRMListenerPrivate> drm_listener_;
 198
 199   base::RepeatingTimer time_update_timer_;
 200
 201   base::Callback<void(int32_t)> attach_callback_;
 202   base::Callback<void(int32_t)> stop_callback_;
 203   base::Callback<void(int32_t)> seek_callback_;
 204   scoped_refptr<base::SingleThreadTaskRunner> main_cb_runner_;
 205
 206   PP_Rect display_rect_;
 207   PP_FloatRect crop_ratio_rect_;
 208
 209   PP_TimeTicks current_time_;
 210
 211   std::string player_subtitle_encoding_;
 212
 213   base::WeakPtrFactory<PepperMediaPlayerPrivateTizen> weak_ptr_factory_;
 214
 215   PepperTizenDRMManager drm_manager_;
 216
 217   Evas_Object* video_window_;
 218 };
 219
 220 }  // namespace content
 221
 222 #endif  // CONTENT_BROWSER_RENDERER_HOST_PEPPER_MEDIA_PLAYER_TIZEN_PEPPER_MEDIA_PLAYER_PRIVATE_TIZEN_H_