src/esplusplayer/include_internal/esplayer/esplayer.h

   1 //
   2 // @ Copyright [2018] <S/W Platform, Visual Display, Samsung Electronics>
   3 //
   4
   5 #ifndef __PLUSPLAYER_SRC_ESPLAYER_ESPLAYER__H__
   6 #define __PLUSPLAYER_SRC_ESPLAYER_ESPLAYER__H__
   7
   8 #include <boost/core/noncopyable.hpp>
   9 #include <future>
  10 #include <list>
  11 #include <map>
  12 #include <memory>
  13 #include <queue>
  14 #include <string>
  15 #include <utility>
  16 #include <vector>
  17
  18 #include "core/decoderinputbuffer.h"
  19 #include "core/trackrendereradapter.h"
  20 #include "esplayer/espacket_logger.h"
  21 #include "esplayer/message.hpp"
  22 #include "esplayer/state_manager.hpp"
  23 #include "plusplayer/drm.h"
  24 #include "plusplayer/esplusplayer.h"
  25 #include "plusplayer/track.h"
  26
  27 #include "plusplayer/types/buffer.h"
  28 #include "plusplayer/types/display.h"
  29 #include "plusplayer/types/error.h"
  30 #include "plusplayer/types/stream.h"
  31
  32 namespace plusplayer {
  33
  34 enum EosStatus {
  35   kNone = 0x0000,
  36   kAudioEos = 0x0010,
  37   kVideoEos = 0x0100,
  38   kAllEos = (kAudioEos | kVideoEos)
  39 };
  40
  41 static constexpr unsigned long kNeedDataMaskNone = 0x00;
  42 static constexpr unsigned long kNeedDataMaskBySeek = 0x01;
  43 static constexpr unsigned long kNeedDataMaskByPrepare = 0x02;
  44
  45 class EsPlayer : public EsPlusPlayer {
  46  public:
  47   EsPlayer();
  48   ~EsPlayer();
  49
  50   bool Open() override;
  51   bool Close() override;
  52   bool PrepareAsync() override;
  53   bool Deactivate(const StreamType type) override;
  54   bool Activate(const StreamType type) override;
  55   bool Start() override;
  56   bool Stop() override;
  57   bool Pause() override;
  58   bool Resume() override;
  59   bool Seek(const uint64_t time_millisecond) override;
  60   bool SetPlaybackRate(const double rate, const bool audio_mute) override;
  61   bool SetDisplay(const DisplayType& type, void* obj) override;
  62   bool SetDisplay(const DisplayType& type, void* ecore_wl2_window, const int x,
  63                   const int y, const int w, const int h) override;
  64   bool SetDisplay(const DisplayType& type, unsigned int surface_id, const int x,
  65                   const int y, const int w, const int h) override;
  66   bool SetDisplayMode(const DisplayMode& mode) override;
  67   bool SetDisplayRoi(const Geometry& roi) override;
  68   bool SetVideoRoi(const CropArea& area) override;
  69   bool SetDisplayRotate(const DisplayRotation& rotate) override;
  70   bool GetDisplayRotate(DisplayRotation* rotate) override;
  71   bool SetDisplayVisible(bool is_visible) override;
  72   bool SetTrustZoneUse(bool is_using_tz) override;
  73   bool SetSubmitDataType(SubmitDataType type) override;
  74   bool SetStream(const AudioStreamPtr& stream) override;
  75   bool SetStream(const VideoStreamPtr& stream) override;
  76   PacketSubmitStatus SubmitPacket(const EsPacketPtr& packet) override;
  77   PacketSubmitStatus SubmitTrustZonePacket(const EsPacketPtr& packet,
  78                                            uint32_t tz_handle = 0) override;
  79   PacketSubmitStatus SubmitEncryptedPacket(
  80       const EsPacketPtr& packet,
  81       const drm::EsPlayerEncryptedInfo& drm_info) override;
  82   EsState GetState() override;
  83   bool GetPlayingTime(uint64_t* time_in_milliseconds) override;
  84   bool SetAudioMute(bool is_mute) override;
  85   bool SetVideoFrameBufferType(DecodedVideoFrameBufferType type) override;
  86   void RegisterListener(EsEventListener* listener,
  87                         EsEventListener::UserData userdata) override;
  88   bool GetAdaptiveInfo(void* padaptive_info,
  89                        const PlayerAdaptiveInfo& adaptive_type) override;
  90   bool SetVolume(const int& volume) override;
  91   bool GetVolume(int* volume) override;
  92   bool Flush(const StreamType& type) override;
  93   void SetBufferSize(const BufferOption& option, uint64_t size) override;
  94   bool SetLowLatencyMode(const PlayerLowLatencyMode& mode) override;
  95   bool SetUnlimitedMaxBufferMode() override;
  96   bool SetAudioCodecType(const PlayerAudioCodecType& type) override;
  97   bool SetVideoCodecType(const PlayerVideoCodecType& type) override;
  98   bool SetRenderTimeOffset(const StreamType type, int64_t offset) override;
  99   bool GetRenderTimeOffset(const StreamType type, int64_t* offset) override;
 100   GetDecodedVideoFrameStatus GetDecodedPacket(
 101       DecodedVideoPacket& packet) override;
 102   bool ReturnDecodedPacket(const DecodedVideoPacket& packet) override;
 103   bool EnableVideoHole(bool value) override;
 104
 105  private:
 106   using SubmitPacketOperator =
 107       std::function<PacketSubmitStatus(GstBuffer* buffer)>;
 108
 109   struct NeedData {
 110     std::bitset<2> mask = kNeedDataMaskNone;
 111     uint64_t seek_offset = 0;
 112   };
 113
 114   struct ResumeTime {
 115     bool is_set = false;
 116     uint64_t time = 0;
 117   };
 118
 119   enum class MakeBufferStatus {
 120     kEos,          // eos packet
 121     kOutOfMemory,  // out of memory
 122     kSuccess       // success
 123   };
 124   struct SrcQueueSize {
 125     std::uint64_t kMaxByteOfVideoSrcQueue = 70 * 1024 * 1024;  // 70 MB
 126     std::uint64_t kMaxByteOfAudioSrcQueue = 10 * 1024 * 1024;  // 10 MB
 127     std::uint32_t kMinByteThresholdOfVideoSrcQueue = 0;
 128     std::uint32_t kMinByteThresholdOfAudioSrcQueue = 0;
 129
 130     std::uint64_t kMaxTimeOfVideoSrcQueue = 0;
 131     std::uint64_t kMaxTimeOfAudioSrcQueue = 0;
 132     std::uint32_t kMinTimeThresholdOfVideoSrcQueue = 0;
 133     std::uint32_t kMinTimeThresholdOfAudioSrcQueue = 0;
 134
 135     std::uint64_t kMaxBufferOfVideoSrcQueue = 0;
 136     std::uint64_t kMaxBufferOfAudioSrcQueue = 0;
 137   };
 138
 139  private:
 140   void Init_();
 141   void MsgTask_();
 142   bool Prepare_();
 143   void PrepareTask_();
 144   void SetTrackRendererAttributes_();
 145   GstBuffer* GetGstBuffer_(const EsPacketPtr& packet, MakeBufferStatus* status);
 146   void UnsetTzQdata_(const DecoderInputBufferPtr& buffer);
 147   void MakeGstBufferForTzHandle_(GstBuffer* gstbuffer, const TrackType& type,
 148                                  const uint32_t& tz_handle,
 149                                  const uint32_t& packet_size);
 150   void MakeGstBufferForEncryptedPacket_(
 151       GstBuffer* gstbuffer, const EsPacketPtr& packet,
 152       const drm::EsPlayerEncryptedInfo& drm_info);
 153   PacketSubmitStatus SubmitPacketCommon_(const EsPacketPtr& packet,
 154                                          SubmitPacketOperator op);
 155   PacketSubmitStatus SubmitEosPacket_(const TrackType& type);
 156   PacketSubmitStatus SubmitDecoderInputBuffer_(
 157       const DecoderInputBufferPtr& buffer);
 158   bool SetTrack_(const Track& track);
 159   bool ChangeStream_(const Track& track);
 160   bool SetStream_(const Track& track);
 161   void ResetContextForClose_();
 162   void ResetContextForStop_();
 163   void GetSrcQueueCurrentSize_(const TrackType& type, uint64_t* byte_size,
 164                                uint64_t* time_size);
 165
 166  private:  // private types
 167   class TrackRendererEventListener
 168       : public TrackRendererAdapter::EventListener {
 169    public:
 170     explicit TrackRendererEventListener(EsPlayer* handler) : handler_(handler) {
 171       assert(handler);
 172     }
 173     void OnError(const ErrorType& error_code) override;
 174     void OnResourceConflicted() override;
 175     void OnEos() override;
 176     void OnSeekDone() override;
 177     void OnBufferStatus(const TrackType& type,
 178                         const BufferStatus& status) override;
 179     void OnSeekData(const TrackType& type, const uint64_t offset) override;
 180     void OnClosedCaptionData(const char* data, const int size) override;
 181     void OnFlushDone() override;
 182     void OnEvent(const EventType& event_type,
 183                  const EventMsg& msg_data) override;
 184     void OnFirstDecodingDone() override;
 185
 186    private:
 187     void ReadyToPrepare_(const TrackType& type);
 188     void ReadyToSeek_(const TrackType& type);
 189     void BufferStatus_(const TrackType& type, const BufferStatus& status);
 190     void OnMediaPacketVideoDecoded(const DecodedVideoPacket& packet);
 191
 192    private:
 193     EsPlayer* handler_ = nullptr;
 194   };  // class TrackRendererEventListener
 195
 196  private:
 197   std::vector<Track> track_;
 198   NeedData need_data_[kTrackTypeMax];
 199   int eos_status_ = EosStatus::kAllEos;
 200   std::mutex eos_mutex_;
 201   EsEventListener* eventlistener_ = nullptr;
 202   EsEventListener::UserData eventlistener_userdata_ = nullptr;
 203
 204   EsStateManager state_manager_;
 205
 206   SubmitDataType submit_data_type_ = SubmitDataType::kCleanData;
 207   drm::Property drm_property_;
 208   std::uint32_t low_latency_mode_ = 0;
 209   std::uint32_t unlimited_max_buffer_mode_ = 0;
 210   std::uint32_t accurate_seek_mode_ = 1;
 211   std::uint32_t video_pre_display_mode_ = 1;
 212   PlayerAudioCodecType audio_codec_type_ = kPlayerAudioCodecTypeHW;
 213   PlayerVideoCodecType video_codec_type_ = kPlayerVideoCodecTypeHW;
 214   bool force_audio_swdecoder_use_ = false;
 215   std::uint32_t video_decoding_mode_ = 0x02;  // seamless mode
 216   std::uint32_t alternative_video_resource_ = 0;
 217   ResumeTime resume_time_;
 218
 219   bool is_msg_task_stop_ = false;
 220   std::mutex msg_task_mutex_;
 221   std::mutex submit_mutex_;
 222   std::condition_variable msg_task_cv_;
 223   std::queue<es_msg::Base::Ptr> msg_queue_;
 224   std::future<void> msg_handler_task_;
 225
 226   std::unique_ptr<TrackRendererEventListener> trackrenderer_event_listener_{
 227       new TrackRendererEventListener(this)};
 228   std::unique_ptr<TrackRendererAdapter> trackrenderer_;
 229   std::future<void> preparetask_;
 230   double current_playback_rate_ = 1.0;
 231   bool current_audio_mute_ = false;
 232   bool is_resource_conflicted_ = false;
 233   bool is_stopped_ = false;
 234   bool is_preparing_ = false;
 235   bool is_seek_done_need_drop = false;
 236   SrcQueueSize src_queue_size_;
 237
 238   std::string caf_unique_number;
 239   DecodedVideoFrameBufferType vidoe_frame_buffer_type_ =
 240       DecodedVideoFrameBufferType::kNone;
 241   // for debugging
 242   EsPacketLogger es_packet_logger_;
 243 };
 244
 245 }  // namespace plusplayer
 246 #endif  // __PLUSPLAYER_SRC_ESPLAYER_ESPLAYER__H__