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