src/esplusplayer/include_internal/esplayer/esplayer.h

   1 //
   2 // @ Copyright [2018] <S/W Platform, Visual Display, Samsung Electronics>
   3 //
   4
   5 #ifndef __ESPLUSPLAYER_SRC_ESPLAYER_ESPLAYER__H__
   6 #define __ESPLUSPLAYER_SRC_ESPLAYER_ESPLAYER__H__
   7
   8 #include <IEME.h>
   9
  10 #include <boost/core/noncopyable.hpp>
  11 #include <future>
  12 #include <list>
  13 #include <map>
  14 #include <memory>
  15 #include <queue>
  16 #include <string>
  17 #include <utility>
  18 #include <vector>
  19
  20 #include "core/decoderinputbuffer.h"
  21 #ifndef TIZEN_FEATURE_PUBLIC
  22 #include "core/kpi.h"
  23 #endif
  24 #include "core/trackrendereradapter.h"
  25 #ifdef USE_MIXER
  26 #include "mixer/mixerticket.h"
  27 #include "mixer/mixerticket_eventlistener.h"
  28 #endif  // USE_MIXER
  29 #include "esplayer/espacket_logger.h"
  30 #include "esplayer/message.hpp"
  31 #include "esplayer/state_manager.hpp"
  32 #include "esplusplayer/drm.h"
  33 #include "esplusplayer/esplusplayer.h"
  34 #include "esplusplayer/track.h"
  35 #include "esplusplayer/types/buffer.h"
  36 #include "esplusplayer/types/display.h"
  37 #include "esplusplayer/types/error.h"
  38 #include "esplusplayer/types/stream.h"
  39
  40 namespace esplusplayer {
  41
  42 enum EosStatus {
  43   kNone = 0x0000,
  44   kAudioEos = 0x0010,
  45   kVideoEos = 0x0100,
  46   kAllEos = (kAudioEos | kVideoEos)
  47 };
  48
  49 static constexpr unsigned long kNeedDataMaskNone = 0x00;
  50 static constexpr unsigned long kNeedDataMaskBySeek = 0x01;
  51 static constexpr unsigned long kNeedDataMaskByPrepare = 0x02;
  52
  53 class EsPlayer : public EsPlusPlayer {
  54  public:
  55   EsPlayer();
  56   ~EsPlayer();
  57
  58   bool Open() override;
  59   bool Close() override;
  60   bool PrepareAsync() override;
  61   bool Deactivate(const StreamType type) override;
  62   bool Activate(const StreamType type) override;
  63   bool DeactivateAudio() override;
  64   bool ActivateAudio() override;
  65   bool Start() override;
  66   bool Stop() override;
  67   bool Pause() override;
  68   bool Resume() override;
  69   bool Seek(const uint64_t time) override;
  70   void SetAppInfo(const PlayerAppInfo& app_info) override;
  71   void SetAppInfoEx(const PlayerAppInfoEx& app_info) override;
  72   bool SetPlaybackRate(const double rate, const bool audio_mute) override;
  73   bool SetDisplay(const DisplayType& type, void* obj) override;
  74 #ifdef USE_MIXER
  75   bool SetDisplay(const DisplayType& type, MixerTicket* handle) override;
  76 #endif  // USE_MIXER
  77   bool SetDisplay(const DisplayType& type, void* ecore_wl2_window, const int x,
  78                   const int y, const int w, const int h) override;
  79   bool SetDisplaySubsurface(const DisplayType& type, void* ecore_wl2_subsurface,
  80                             const int x, const int y, const int w,
  81                             const int h) override;
  82   bool SetDisplay(const DisplayType& type, unsigned int surface_id, const int x,
  83                   const int y, const int w, const int h) override;
  84   bool SetDisplayMode(const DisplayMode& mode) override;
  85   bool SetStretchMode(const int& mode) override;
  86   bool SetDisplayRoi(const Geometry& roi) override;
  87   bool SetVideoRoi(const CropArea& area) override;
  88   bool ResizeRenderRect(const RenderRect& rect) override;
  89   bool SetDisplayRotate(const DisplayRotation& rotate) override;
  90   bool GetDisplayRotate(DisplayRotation* rotate) override;
  91   bool SetDisplayVisible(bool is_visible) override;
  92   bool SetTrustZoneUse(bool is_using_tz) override;
  93   bool SetSubmitDataType(SubmitDataType type) override;
  94   bool SetStream(const AudioStreamPtr& stream) override;
  95   bool SetStream(const VideoStreamPtr& stream) override;
  96   PacketSubmitStatus SubmitPacket(const EsPacketPtr& packet) override;
  97   PacketSubmitStatus SubmitTrustZonePacket(const EsPacketPtr& packet,
  98                                            uint32_t tz_handle = 0) override;
  99   PacketSubmitStatus SubmitEncryptedPacket(
 100       const EsPacketPtr& packet,
 101       const drm::EsPlayerEncryptedInfo& drm_info) override;
 102   EsState GetState() override;
 103   bool GetPlayingTime(uint64_t* time) override;
 104   bool SetAudioMute(bool is_mute) override;
 105   bool SetVideoFrameBufferType(DecodedVideoFrameBufferType type) override;
 106   bool SetVideoFrameBufferScaleResolution(
 107       const uint32_t& target_width, const uint32_t& target_height) override;
 108   bool SetDecodedVideoFrameRate(const Rational& request_framerate) override;
 109   void RegisterListener(EsEventListener* listener,
 110                         EsEventListener::UserData userdata) override;
 111   bool GetAdaptiveInfo(void* padaptive_info,
 112                        const PlayerAdaptiveInfo& adaptive_type) override;
 113   bool SetVolume(const int& volume) override;
 114   bool GetVolume(int* volume) override;
 115   bool Flush(const StreamType& type) override;
 116   bool SetBufferSize(const BufferOption& option, uint64_t size) override;
 117   bool SetLowLatencyMode(const PlayerLowLatencyMode& mode) override;
 118   bool SetVideoFramePeekMode() override;
 119   bool RenderVideoFrame() override;
 120   bool SetUnlimitedMaxBufferMode() override;
 121   ErrorType SetFmmMode() override;
 122   bool SetAudioCodecType(const PlayerAudioCodecType& type) override;
 123   bool SetVideoCodecType(const PlayerVideoCodecType& type) override;
 124   bool SetRenderTimeOffset(const StreamType type, int64_t offset) override;
 125   bool GetRenderTimeOffset(const StreamType type, int64_t* offset) override;
 126   bool SetAlternativeVideoResource(unsigned int rsc_type) override;
 127   bool SetAlternativeAudioResource(
 128       const PlayerAudioResourceType rsc_type) override;
 129   bool SwitchAudioStreamOnTheFly(const AudioStreamPtr& stream) override;
 130   bool SetAiFilter(void* aifilter) override;
 131   bool SetCatchUpSpeed(const CatchUpSpeed& level) override;
 132   bool GetVideoLatencyStatus(LatencyStatus* status) override;
 133   bool GetAudioLatencyStatus(LatencyStatus* status) override;
 134   bool SetVideoMidLatencyThreshold(const unsigned int threshold) override;
 135   bool SetAudioMidLatencyThreshold(const unsigned int threshold) override;
 136   bool SetVideoHighLatencyThreshold(const unsigned int threshold) override;
 137   bool SetAudioHighLatencyThreshold(const unsigned int threshold) override;
 138   bool GetLowLatencyPcmBufferSize(uint64_t* frame_count) override;
 139   bool GetLowLatencyPcmCurrentBufferLevel(uint64_t* frame_count) override;
 140   bool GetLowLatencyPcmUnderrunCount(uint64_t* underrun_count) override;
 141   bool InitAudioEasingInfo(const uint32_t init_volume,
 142                            const uint32_t init_elapsed_time,
 143                            const AudioEasingInfo& easing_info) override;
 144   bool UpdateAudioEasingInfo(const AudioEasingInfo& easing_info) override;
 145   bool GetAudioEasingInfo(uint32_t* current_volume, uint32_t* elapsed_time,
 146                           AudioEasingInfo* easing_info) override;
 147   bool StartAudioEasing() override;
 148   bool StopAudioEasing() override;
 149   bool GetVirtualRscId(const RscType type, int* virtual_id) override;
 150   bool SetAdvancedPictureQualityType(const AdvPictureQualityType type) override;
 151   bool SetResourceAllocatePolicy(const RscAllocPolicy policy) override;
 152   GetDecodedVideoFrameStatus GetDecodedPacket(
 153       DecodedVideoPacket& packet) override;
 154   bool ReturnDecodedPacket(const DecodedVideoPacket& packet) override;
 155   bool SetAudioPreloading() override;
 156   bool SetVideoScanType(const PlayerVideoScanType type) override;
 157   bool SetTimeUnitType(const PlayerTimeUnitType type) override;
 158   bool GetDecodingTime(StreamType type, int32_t* time_in_milliseconds) override;
 159   bool SetVideoStreamRotationInfo(const VideoRotation& rotation) override;
 160   bool GetVideoStreamRotationInfo(VideoRotation* rotation) override;
 161   bool SetSimpleMixOutBufferLevel(
 162       const PlayerSimpleMixOutBufferLevel level) override;
 163 #ifdef TIZEN_FEATURE_PUBLIC
 164   bool EnableVideoHole(bool value) override;
 165   bool SetSoundStreamInfo(const sound_stream_info_h stream_info) override;
 166 #endif  // TIZEN_FEATURE_PUBLIC
 167
 168  private:
 169   using SubmitPacketOperator =
 170       std::function<PacketSubmitStatus(GstBuffer* buffer)>;
 171
 172   struct NeedData {
 173     std::bitset<2> mask = kNeedDataMaskNone;
 174     uint64_t seek_offset = 0;
 175   };
 176
 177   struct ResumeTime {
 178     bool is_set = false;
 179     uint64_t time = 0;
 180   };
 181
 182   enum class MakeBufferStatus {
 183     kEos,          // eos packet
 184     kOutOfMemory,  // out of memory
 185     kSuccess       // success
 186   };
 187   struct SrcQueueSize {
 188     std::uint64_t kMaxByteOfVideoSrcQueue = 70 * 1024 * 1024;  // 70 MB
 189     std::uint64_t kMaxByteOfAudioSrcQueue = 10 * 1024 * 1024;  // 10 MB
 190     std::uint32_t kMinByteThresholdOfVideoSrcQueue = 0;
 191     std::uint32_t kMinByteThresholdOfAudioSrcQueue = 0;
 192
 193     std::uint64_t kMaxTimeOfVideoSrcQueue = 0;
 194     std::uint64_t kMaxTimeOfAudioSrcQueue = 0;
 195     std::uint32_t kMinTimeThresholdOfVideoSrcQueue = 0;
 196     std::uint32_t kMinTimeThresholdOfAudioSrcQueue = 0;
 197   };
 198
 199  private:
 200   void Init_();
 201   void MsgTask_();
 202   bool Prepare_();
 203   void PrepareTask_();
 204   void SetTrackRendererAttributes_();
 205   GstBuffer* GetGstBuffer_(const EsPacketPtr& packet, MakeBufferStatus* status);
 206   void UnsetTzQdata_(const DecoderInputBufferPtr& buffer);
 207   void MakeGstBufferForTzHandle_(GstBuffer* gstbuffer, const TrackType& type,
 208                                  const uint32_t& tz_handle,
 209                                  const uint32_t& packet_size);
 210   void MakeGstBufferForEncryptedPacket_(
 211       GstBuffer* gstbuffer, const EsPacketPtr& packet,
 212       const drm::EsPlayerEncryptedInfo& drm_info);
 213   PacketSubmitStatus SubmitPacketCommon_(const EsPacketPtr& packet,
 214                                          SubmitPacketOperator op);
 215   PacketSubmitStatus SubmitEosPacket_(const TrackType& type);
 216   PacketSubmitStatus SubmitDecoderInputBuffer_(
 217       const DecoderInputBufferPtr& buffer);
 218   bool SetTrack_(const Track& track);
 219   bool ChangeStream_(const Track& track);
 220   bool SetStream_(const Track& track);
 221   void ResetContextForClose_();
 222   void ResetContextForStop_();
 223   void GetSrcQueueCurrentSize_(const TrackType& type, uint64_t* byte_size,
 224                                uint64_t* time_size);
 225 #ifndef TIZEN_FEATURE_PUBLIC
 226   kpi::EsCodecLoggerKeys MakeKpiKeys_();
 227 #endif
 228 #ifdef USE_MIXER
 229   bool PrepareVideoMixingMode_(std::vector<Track>* tracks);
 230 #endif  // USE_MIXER
 231   void InitValuesFromIni_();
 232
 233  private:  // private types
 234   class TrackRendererEventListener
 235       : public TrackRendererAdapter::EventListener {
 236    public:
 237     explicit TrackRendererEventListener(EsPlayer* handler) : handler_(handler) {
 238       assert(handler);
 239     }
 240     void OnError(const ErrorType& error_code) override;
 241     void OnErrorMsg(const ErrorType& error_code, char* error_msg) override;
 242     void OnResourceConflicted() override;
 243     void OnEos() override;
 244     void OnSeekDone() override;
 245     void OnBufferStatus(const TrackType& type,
 246                         const BufferStatus& status) override;
 247     void OnSeekData(const TrackType& type, const uint64_t offset) override;
 248     void OnClosedCaptionData(const char* data, const int size) override;
 249     void OnFlushDone() override;
 250     void OnEvent(const EventType& event_type,
 251                  const EventMsg& msg_data) override;
 252     void OnFirstDecodingDone() override;
 253     void OnVideoDecoderUnderrun() override;
 254     void OnVideoLatencyStatus(const LatencyStatus& latency_status) override;
 255     void OnAudioLatencyStatus(const LatencyStatus& latency_status) override;
 256     void OnVideoHighLatency() override;
 257     void OnAudioHighLatency() override;
 258     void OnVideoFrameDropped(const uint64_t& count) override;
 259 #ifdef USE_MIXER
 260     void OnMediaPacketVideoRawDecoded(
 261         const DecodedVideoRawModePacket& packet) override;
 262 #endif  // USE_MIXER
 263
 264    private:
 265     void ReadyToPrepare_(const TrackType& type);
 266     void ReadyToSeek_(const TrackType& type);
 267     void BufferStatus_(const TrackType& type, const BufferStatus& status);
 268     void OnMediaPacketVideoDecoded(const DecodedVideoPacket& packet);
 269     void OnMediaPacketGetTbmBufPtr(void** ptr, bool is_scale_change);
 270     void OnDecoderInputBufferTime(const TrackType& type,
 271                                   const DecoderBufferTime& time);
 272     void OnDecoderOutputBufferTime(const TrackType& type,
 273                                    const DecoderBufferTime& time);
 274
 275    private:
 276     EsPlayer* handler_ = nullptr;
 277   };  // class TrackRendererEventListener
 278
 279 #ifdef USE_MIXER
 280   class MixerListener : public MixerTicketEventListener {
 281    public:
 282     explicit MixerListener(EsPlayer* handler) : handler_(handler) {
 283       assert(handler);
 284     }
 285     bool OnAudioFocusChanged(bool active) override;
 286     bool OnUpdateDisplayInfo(const DisplayInfo& cur_info,
 287                              DisplayInfo* new_info) override;
 288
 289    private:
 290     EsPlayer* handler_{nullptr};
 291   };
 292 #endif  // USE_MIXER
 293
 294  private:
 295   std::vector<Track> track_;
 296   NeedData need_data_[kTrackTypeMax];
 297   int eos_status_ = EosStatus::kAllEos;
 298   std::mutex eos_mutex_;
 299   EsEventListener* eventlistener_ = nullptr;
 300   EsEventListener::UserData eventlistener_userdata_ = nullptr;
 301   bool is_audio_stream_info_frozen_ = false;
 302
 303   EsStateManager state_manager_;
 304
 305   SubmitDataType submit_data_type_ = SubmitDataType::kCleanData;
 306   std::string key_system_;
 307   bool key_system_acquired_ = false;
 308   drm::Property drm_property_;
 309   std::uint32_t low_latency_mode_ = 0;
 310   std::uint32_t video_frame_peek_mode_ = 0;
 311   std::uint32_t unlimited_max_buffer_mode_ = 0;
 312   std::uint32_t accurate_seek_mode_ = 1;
 313   std::uint32_t video_pre_display_mode_ = 1;
 314   std::uint32_t fmm_mode_ = 0;
 315   PlayerAudioCodecType audio_codec_type_ = kPlayerAudioCodecTypeHW;
 316   PlayerVideoCodecType video_codec_type_ = kPlayerVideoCodecTypeHW;
 317   bool force_audio_swdecoder_use_ = false;
 318   bool force_video_swdecoder_use_ = false;
 319   std::uint32_t video_decoding_mode_ = 0x02;  // seamless mode
 320   std::uint32_t alternative_video_resource_ = 0;
 321   RscAllocPolicy resource_alloc_policy_ = RscAllocPolicy::kRscAllocExclusive;
 322   std::uint32_t set_video_progressive_ = 0;
 323   ResumeTime resume_time_;
 324
 325   bool is_msg_task_stop_ = false;
 326   std::mutex msg_task_mutex_;
 327   std::mutex submit_mutex_;
 328   std::condition_variable msg_task_cv_;
 329   std::queue<es_msg::Base::Ptr> msg_queue_;
 330   std::future<void> msg_handler_task_;
 331
 332   std::unique_ptr<TrackRendererEventListener> trackrenderer_event_listener_{
 333       new TrackRendererEventListener(this)};
 334 #ifdef USE_MIXER
 335   std::unique_ptr<MixerListener> mixer_event_listener_{new MixerListener(this)};
 336 #endif  // USE_MIXER
 337   std::unique_ptr<TrackRendererAdapter> trackrenderer_;
 338   std::future<void> preparetask_;
 339   PlayerAppInfo app_info_;
 340   double current_playback_rate_ = 1.0;
 341   bool current_audio_mute_ = false;
 342   bool is_resource_conflicted_ = false;
 343   bool is_stopped_ = false;
 344   bool is_preparing_ = false;
 345   bool is_seek_done_need_drop = false;
 346   SrcQueueSize src_queue_size_;
 347
 348   std::string caf_unique_number;
 349 #ifdef USE_MIXER
 350   std::unique_ptr<MixerTicket> mixer_ticket_;
 351   bool is_audio_focused_ = true;
 352   Geometry mixerticket_roi_;
 353   bool is_visible_ = true;
 354   std::mutex audio_focus_m_;
 355   bool enable_audio_pipeline_handle_ = true;
 356   bool enable_rsc_alloc_handle_ = true;
 357 #endif  // USE_MIXER
 358   DecodedVideoFrameBufferType vidoe_frame_buffer_type_ =
 359       DecodedVideoFrameBufferType::kNone;
 360   // for debugging
 361   EsPacketLogger es_packet_logger_;
 362   PlayerTimeUnitType time_unit_type = kPlayerTimeUnitTypeMs;
 363   VideoRotation video_rotate_ = VideoRotation::kVideoRotateNone;
 364 };
 365
 366 }  // namespace esplusplayer
 367 #endif  // __ESPLUSPLAYER_SRC_ESPLAYER_ESPLAYER__H__