src/plusplayer-core/include_internal/core/trackrendereradapter.h

   1 //
   2 // @ Copyright [2017] <S/W Platform, Visual Display, Samsung Electronics>
   3 //
   4
   5 #ifndef __PLUSPLAYER_SRC_PLAYER_TRACKRENDERERADAPTER_H__
   6 #define __PLUSPLAYER_SRC_PLAYER_TRACKRENDERERADAPTER_H__
   7
   8 #include <trackrenderer_capi/trackrenderer_capi.h>
   9 #include <trackrenderer_capi/trackrenderer_internal.h>
  10
  11 #include <map>
  12 #include <memory>
  13 #include <vector>
  14
  15 #include "core/decoderinputbuffer.h"
  16 #include "plusplayer/drm.h"
  17 #include "plusplayer/track.h"
  18 #include "plusplayer/types/buffer.h"
  19 #include "plusplayer/types/display.h"
  20 #include "plusplayer/types/error.h"
  21 #include "plusplayer/types/event.h"
  22 #include "plusplayer/types/stream.h"
  23
  24 namespace plusplayer {
  25
  26 class TrackRendererAdapter {
  27  public:
  28   enum RetVal { kSuccess = 0, kFailed = -1 };
  29   enum class SubmitStatus {
  30     kNotPrepared,  // not prepared to get data
  31     kHold,         // valid data, hold this packet
  32     kFull,         // buffer already full
  33     kSuccess,      // submit succeeded
  34     kDrop,         // invalid data , drop this packet
  35     kFailed,
  36   };
  37
  38   enum class Attribute {
  39     /*attributes for gst plugin property*/
  40     kVideoQueueMaxByte,           // std::uint64_t
  41     kAudioQueueMaxByte,           // std::uint64_t
  42     kVideoQueueCurrentLevelByte,  // std::uint64_t
  43     kAudioQueueCurrentLevelByte,  // std::uint64_t
  44     kVideoMinByteThreshold,       // std::uint32_t
  45     kAudioMinByteThreshold,       // std::uint32_t
  46     kVideoQueueMaxBuffer,         // std::uint64_t
  47     kAudioQueueMaxBuffer,         // std::uint64_t
  48     kVideoRenderTimeOffset,       // std::int64_t
  49     kAudioRenderTimeOffset,       // std::int64_t
  50
  51     /*attributes for trackrenderer configures*/
  52     kAccurateSeekMode,          // std::uint32_t
  53     kLowLatencyMode,            // std::uint32_t
  54     kUnlimitedMaxBufferMode,    // std::uint32_t
  55     kVideoPreDisplayMode,       // std::uint32_t
  56     kStartRenderingTime,        // std::uint64_t
  57   };
  58
  59   // TODO(js4716.chun):CHECK POINTS
  60   // - duplicated TrackRenderer::EventListener
  61   class EventListener {
  62    public:
  63     virtual ~EventListener() {}
  64     virtual void OnError(const ErrorType& err_code) {}
  65     virtual void OnResourceConflicted() {}
  66     virtual void OnSeekDone() {}
  67     virtual void OnEos() {}
  68     virtual void OnEvent(const EventType& event, const EventMsg& msg_data) {}
  69     virtual void OnSubtitleData(const DecoderInputBufferPtr& buf,
  70                                 const SubtitleType& type) {}
  71 #ifndef TRACKRENDERER_FEATURE_DEPRECATE_SUBTITLE_CB
  72     virtual void OnSubtitleData(const char* data, const int size,
  73                                 const SubtitleType& type,
  74                                 const uint64_t duration,
  75                                 SubtitleAttrListPtr attr_list) {}
  76 #endif
  77     virtual void OnClosedCaptionData(const char* data, const int size) {}
  78     virtual void OnDrmInitData(int* drmhandle, unsigned int len,
  79                                unsigned char* psshdata, TrackType type) {}
  80     virtual void OnBufferStatus(const TrackType& type,
  81                                 const BufferStatus& status) {}
  82     virtual void OnSeekData(const TrackType& type, const uint64_t offset) {}
  83     virtual void OnMediaPacketVideoDecoded(const DecodedVideoPacket& packet) {}
  84     virtual void OnFlushDone() {}
  85     virtual void OnFirstDecodingDone() {}
  86   };
  87
  88  public:
  89   using Ptr = std::unique_ptr<TrackRendererAdapter>;
  90   static Ptr Create();
  91
  92   ~TrackRendererAdapter();
  93
  94   bool Start();
  95   bool Stop();
  96   bool Prepare();
  97   bool Pause();
  98   bool Resume();
  99   bool SetTrack(const std::vector<Track>& trackinfo);
 100   void SetIniProperty(const std::map<std::string, bool>& Properties);
 101   void SetIniElement(const std::map<std::string, std::string>& elements);
 102   bool Seek(uint64_t time_millisecond, double playback_rate);
 103   bool Seek(uint64_t time_millisecond, double playback_rate, bool audio_mute);
 104   bool SetPlaybackRate(double playback_rate, bool audio_mute);
 105   bool GetPlayingTime(uint64_t* curtime_in_msec);
 106   bool GetDroppedFrames(void* counts);
 107   bool GetDroppedFramesForCatchup(TrackType type, void* counts);
 108   bool Deactivate(TrackType type);
 109   bool Activate(TrackType type, const Track& track);
 110   bool SubmitPacket(const DecoderInputBufferPtr& data);
 111   bool SubmitPacket(const DecoderInputBufferPtr& data, SubmitStatus* status);
 112   bool SubmitPacket2(const DecoderInputBufferPtr& data, SubmitStatus* status);
 113   void SetDrm(const drm::Property& drm_property);
 114   void DrmLicenseAcquiredDone(TrackType type);
 115   void SetDrmLicenseKey(TrackType type, const std::string& key);
 116   bool SetDisplayMode(const DisplayMode& mode);
 117   bool SetDisplayRotate(const DisplayRotation& rotate);
 118   bool GetDisplayRotate(DisplayRotation* rotate);
 119   bool SetDisplay(const DisplayType& type, uint32_t surface_id, long x, long y,
 120                   long w, long h);
 121   bool SetDisplay(const DisplayType& type, void* obj);
 122   bool SetDisplay(const DisplayType& type, void* ecore_wl2_window, int x, int y,
 123                   int w, int h);
 124   bool SetDisplayRoi(const Geometry& roi);
 125   bool SetVideoRoi(const CropArea& area);
 126   bool SetDisplayVisible(bool is_visible);
 127   void GetDisplay(DisplayType* type, Geometry* area);
 128   void GetDisplayMode(DisplayMode* mode);
 129   bool SetAudioMute(bool is_mute);
 130   bool SetVolume(const int& volume);
 131   bool GetVolume(int* volume);
 132
 133   void RegisterListener(EventListener* listener);
 134   void RegisterListenerForEsplayer(EventListener* listener);
 135   void SetVideoStillMode(const StillMode& type);
 136   void SetAttribute(const Attribute& attr, const boost::any& value);
 137   TrackRendererState GetState();
 138   bool SetMatroskaColorInfo(const std::string& color_info);
 139   void SetVideoFrameBufferType(const DecodedVideoFrameBufferType& type);
 140   bool Flush(const StreamType& type);
 141   bool Flush(const TrackType& type);
 142   void GetAttribute(const Attribute& attr, boost::any* value);
 143   bool EnableVideoHole(bool value);
 144
 145  private:
 146   TrackRendererAdapter();
 147   using UserData = void*;
 148   static void ErrorCb_(const TrackRendererErrorType error_code,
 149                        UserData userdata);
 150   static void ResourceConflictCb_(UserData userdata);
 151
 152   static void SeekDoneCb_(UserData userdata);
 153
 154   static void FlushDoneCb_(UserData userdata);
 155
 156   static void EosCb_(UserData userdata);
 157
 158   static void EventCb_(const TrackRendererEventType event_type,
 159                        const TrackrendererEventMsg msg_data, UserData userdata);
 160
 161   static void FirstDecodingDoneCb_(UserData userdata);
 162
 163   static void SubtitleRawDataCb_(TrackRendererDecoderInputBuffer* buf,
 164                                  const TrackRendererSubtitleType type,
 165                                  UserData userdata);
 166
 167 #ifndef TRACKRENDERER_FEATURE_DEPRECATE_SUBTITLE_CB
 168   static void SubtitleDataCb_(const char* data, const int size,
 169                               const TrackRendererSubtitleType type,
 170                               const uint64_t duration,
 171                               TrackRendererSubtitleAttr* attr_list,
 172                               int attr_list_size, UserData userdata);
 173 #endif
 174
 175   static void ClosedCaptionDataCb_(const char* data, const int size,
 176                                    UserData userdata);
 177
 178   static void DrmInitDataCb_(int* drmhandle, unsigned int len,
 179                              unsigned char* psshdata,
 180                              TrackRendererTrackType type, UserData userdata);
 181
 182   static void BufferStatusCb_(const TrackRendererTrackType type,
 183                               const TrackRendererBufferStatus status,
 184                               UserData userdata);
 185
 186   static void SeekDataCb_(const TrackRendererTrackType type,
 187                           const uint64_t offset, UserData userdata);
 188
 189   static void MediaPacketVideoDecodedCb_(
 190       const TrackRendererDecodedVideoPacket* packet, UserData userdata);
 191
 192  private:
 193   using TrackRendererHandle = void*;
 194   TrackRendererHandle handle_ = nullptr;
 195   EventListener* eventlistener_{nullptr};
 196 };  // class TrackRendererAdapter
 197
 198 }  // namespace plusplayer
 199
 200 #endif  // __PLUSPLAYER_SRC_PLAYER_TRACKRENDERERADAPTER_H__