src/plusplayer-core/src/trackrendereradapter.cpp

   1 //
   2 // @ Copyright [2017] <S/W Platform, Visual Display, Samsung Electronics>
   3 //
   4
   5 #include "core/trackrendereradapter.h"
   6
   7 #include <cstring>
   8
   9 #include "core/trackrendereradapter_utils.h"
  10 #include "core/utils/plusplayer_log.h"
  11 #include "trackrenderer_capi/trackrenderer_internal.h"
  12
  13 namespace plusplayer {
  14
  15 TrackRendererAdapter::Ptr TrackRendererAdapter::Create() {
  16   LOG_INFO("Trackrenderer adapter is created");
  17   return Ptr(new TrackRendererAdapter);
  18 }
  19
  20 TrackRendererAdapter::TrackRendererAdapter() { trackrenderer_create(&handle_); }
  21
  22 TrackRendererAdapter::~TrackRendererAdapter() {
  23   if (handle_) {
  24     trackrenderer_destroy(handle_);
  25     handle_ = nullptr;
  26   }
  27 }
  28
  29 bool TrackRendererAdapter::Start() {
  30   if (trackrenderer_start(handle_) == kFailed) {
  31     return false;
  32   }
  33   return true;
  34 }
  35
  36 bool TrackRendererAdapter::Stop() {
  37   if (trackrenderer_stop(handle_) == kFailed) {
  38     return false;
  39   }
  40   return true;
  41 }
  42
  43 bool TrackRendererAdapter::Prepare() {
  44   if (trackrenderer_prepare(handle_) == kFailed) {
  45     return false;
  46   }
  47   return true;
  48 }
  49
  50 bool TrackRendererAdapter::Pause() {
  51   if (trackrenderer_pause(handle_) == kFailed) {
  52     return false;
  53   }
  54   return true;
  55 }
  56
  57 bool TrackRendererAdapter::Resume() {
  58   if (trackrenderer_resume(handle_) == kFailed) {
  59     return false;
  60   }
  61   return true;
  62 }
  63
  64 constexpr int kTrackRendererMaxStreamNumber = 3;
  65 bool TrackRendererAdapter::SetTrack(const std::vector<Track>& trackinfo) {
  66   int size = trackinfo.size();
  67   if (size <= 0 || size > kTrackRendererMaxStreamNumber) return false;
  68
  69   TrackRendererTrack tracks[size];
  70   int index = 0;
  71   for (const auto& track : trackinfo) {
  72     adapter_utils::MakeTrackRendererTrack(&tracks[index], track);
  73     index++;
  74   }
  75
  76   if (trackrenderer_set_track(handle_, tracks, size) == kFailed) {
  77     return false;
  78   }
  79   return true;
  80 }
  81
  82 void TrackRendererAdapter::SetIniProperty(
  83     const std::map<std::string, bool>& properties) {
  84   const int size = properties.size();
  85   if (size <= 0) return;
  86   TrackRendererIniProperty trackrenderer_iniproperty[size];
  87   int index = 0;
  88   for (const auto& pair : properties) {
  89     trackrenderer_iniproperty[index].key = pair.first.c_str();
  90     trackrenderer_iniproperty[index].value = pair.second;
  91     index++;
  92   }
  93   trackrenderer_set_ini_property(handle_, trackrenderer_iniproperty, size);
  94 }
  95
  96 void TrackRendererAdapter::SetIniElement(
  97     const std::map<std::string, std::string>& elements) {
  98   const int size = elements.size();
  99   if (size <= 0) return;
 100   TrackRendererIniElement trackrenderer_inielement[size];
 101   int index = 0;
 102   for (const auto& pair : elements) {
 103     trackrenderer_inielement[index].key = pair.first.c_str();
 104     trackrenderer_inielement[index].value = pair.second.c_str();
 105     index++;
 106   }
 107   trackrenderer_set_ini_element(handle_, trackrenderer_inielement, size);
 108 }
 109
 110 bool TrackRendererAdapter::Seek(uint64_t time_millisecond,
 111                                 double playback_rate) {
 112   if (trackrenderer_seek(handle_, time_millisecond, playback_rate) == kFailed) {
 113     return false;
 114   }
 115   return true;
 116 }
 117
 118 bool TrackRendererAdapter::Seek(uint64_t time_millisecond, double playback_rate,
 119                                 bool audio_mute) {
 120   if (trackrenderer_seek2(handle_, time_millisecond, playback_rate,
 121                           audio_mute) == kFailed) {
 122     return false;
 123   }
 124   return true;
 125 }
 126
 127 bool TrackRendererAdapter::SetPlaybackRate(double playback_rate,
 128                                            bool audio_mute) {
 129   if (trackrenderer_set_playback_rate(handle_, playback_rate, audio_mute) ==
 130       kFailed) {
 131     return false;
 132   }
 133   return true;
 134 }
 135
 136 bool TrackRendererAdapter::GetPlayingTime(uint64_t* time_millisecond) {
 137   if (trackrenderer_get_playing_time(handle_, time_millisecond) == kFailed) {
 138     return false;
 139   }
 140   return true;
 141 }
 142
 143 bool TrackRendererAdapter::GetDroppedFrames(void* counts) {
 144   if (trackrenderer_get_dropped_frames(handle_, counts) == kFailed) {
 145     return false;
 146   }
 147   return true;
 148 }
 149
 150 bool TrackRendererAdapter::GetDroppedFramesForCatchup(TrackType type,
 151                                                       void* counts) {
 152   if (trackrenderer_get_dropped_frames_for_catchup(
 153           handle_, adapter_utils::ConvertToTrackRendererTrackType(type),
 154           counts) == kFailed) {
 155     return false;
 156   }
 157   return true;
 158 }
 159
 160 bool TrackRendererAdapter::Deactivate(TrackType type) {
 161   if (trackrenderer_deactivate(
 162           handle_, adapter_utils::ConvertToTrackRendererTrackType(type)) ==
 163       kFailed) {
 164     return false;
 165   }
 166   return true;
 167 }
 168
 169 bool TrackRendererAdapter::Activate(TrackType type, const Track& trackinfo) {
 170   TrackRendererTrack track;
 171   adapter_utils::MakeTrackRendererTrack(&track, trackinfo);
 172
 173   if (trackrenderer_activate(
 174           handle_, adapter_utils::ConvertToTrackRendererTrackType(type),
 175           &track) == kFailed) {
 176     return false;
 177   }
 178   return true;
 179 }
 180
 181 bool TrackRendererAdapter::SubmitPacket(const DecoderInputBufferPtr& data) {
 182 #ifdef TRACKRENDERER_GST_DEPENDENCY_REMOVAL
 183   TrackRendererDecoderInputBuffer decoderinputbuffer{
 184       adapter_utils::ConvertToTrackRendererTrackType(data->GetType()),
 185       data->GetIndex(),
 186       static_cast<void*>(const_cast<GstBuffer*>(data->Get())),
 187       static_cast<void*>(const_cast<GstCaps*>(data->GetCaps()))};
 188 #else
 189   TrackRendererDecoderInputBuffer decoderinputbuffer{
 190       adapter_utils::ConvertToTrackRendererTrackType(data->GetType()),
 191       data->GetIndex(), const_cast<GstBuffer*>(data->Get()),
 192       const_cast<GstCaps*>(data->GetCaps())};
 193 #endif
 194   if (trackrenderer_submit_packet(handle_, &decoderinputbuffer, nullptr) ==
 195       kFailed) {
 196     return false;
 197   }
 198   return true;
 199 }
 200
 201 namespace adapter_utils {
 202
 203 TrackRendererAdapter::SubmitStatus ConvertToAdapterSubmitStatus(
 204     TrackRendererSubmitStatus status) {
 205   switch (status) {
 206     case kTrackRendererSubmitStatusNotPrepared: {
 207       return TrackRendererAdapter::SubmitStatus::kNotPrepared;
 208     }
 209     case kTrackRendererSubmitStatusHold: {
 210       return TrackRendererAdapter::SubmitStatus::kHold;
 211     }
 212     case kTrackRendererSubmitStatusFull: {
 213       return TrackRendererAdapter::SubmitStatus::kFull;
 214     }
 215     case kTrackRendererSubmitStatusSuccess: {
 216       return TrackRendererAdapter::SubmitStatus::kSuccess;
 217     }
 218     case kTrackRendererSubmitStatusDrop: {
 219       return TrackRendererAdapter::SubmitStatus::kDrop;
 220     }
 221     case kTrackRendererSubmitStatusFailed: {
 222       return TrackRendererAdapter::SubmitStatus::kFailed;
 223     }
 224     default:
 225       LOG_ERROR("unknown submitstatus");
 226       return TrackRendererAdapter::SubmitStatus::kFailed;
 227   }
 228 }
 229
 230 }  // namespace adapter_utils
 231
 232 bool TrackRendererAdapter::SubmitPacket(const DecoderInputBufferPtr& data,
 233                                         SubmitStatus* status) {
 234 #ifdef TRACKRENDERER_GST_DEPENDENCY_REMOVAL
 235   TrackRendererDecoderInputBuffer decoderinputbuffer{
 236       adapter_utils::ConvertToTrackRendererTrackType(data->GetType()),
 237       data->GetIndex(),
 238       static_cast<void*>(const_cast<GstBuffer*>(data->Get())),
 239       static_cast<void*>(const_cast<GstCaps*>(data->GetCaps()))};
 240 #else
 241   TrackRendererDecoderInputBuffer decoderinputbuffer{
 242       adapter_utils::ConvertToTrackRendererTrackType(data->GetType()),
 243       data->GetIndex(), const_cast<GstBuffer*>(data->Get()),
 244       const_cast<GstCaps*>(data->GetCaps())};
 245 #endif
 246   TrackRendererSubmitStatus submitstatus;
 247   if (trackrenderer_submit_packet(handle_, &decoderinputbuffer,
 248                                   &submitstatus) == kFailed) {
 249     if (status) *status = TrackRendererAdapter::SubmitStatus::kFailed;
 250     return false;
 251   }
 252   if (status)
 253     *status = adapter_utils::ConvertToAdapterSubmitStatus(submitstatus);
 254   return true;
 255 }
 256
 257 bool TrackRendererAdapter::SubmitPacket2(const DecoderInputBufferPtr& data,
 258                                          SubmitStatus* status) {
 259 #ifdef TRACKRENDERER_GST_DEPENDENCY_REMOVAL
 260   TrackRendererDecoderInputBuffer decoderinputbuffer{
 261       adapter_utils::ConvertToTrackRendererTrackType(data->GetType()),
 262       data->GetIndex(),
 263       static_cast<void*>(const_cast<GstBuffer*>(data->Get())),
 264       static_cast<void*>(const_cast<GstCaps*>(data->GetCaps()))};
 265 #else
 266   TrackRendererDecoderInputBuffer decoderinputbuffer{
 267       adapter_utils::ConvertToTrackRendererTrackType(data->GetType()),
 268       data->GetIndex(), const_cast<GstBuffer*>(data->Get()),
 269       const_cast<GstCaps*>(data->GetCaps())};
 270 #endif
 271   TrackRendererSubmitStatus submitstatus;
 272   if (trackrenderer_submit_packet2(handle_, &decoderinputbuffer,
 273                                    &submitstatus) == kFailed) {
 274     if (status)
 275       *status = adapter_utils::ConvertToAdapterSubmitStatus(submitstatus);
 276     return false;
 277   }
 278
 279   if (status)
 280     *status = adapter_utils::ConvertToAdapterSubmitStatus(submitstatus);
 281
 282   if (submitstatus == kTrackRendererSubmitStatusDrop) return true;
 283
 284   data->Release();
 285   return true;
 286 }
 287
 288 void TrackRendererAdapter::SetDrm(const drm::Property& drm_property) {
 289   TrackRendererDrmProperty trackrenderer_drm_property{kTrackRendererDrmTypeNone,
 290                                                       0, 0, nullptr, nullptr};
 291   adapter_utils::MakeTrackRendererDrmProperty(&trackrenderer_drm_property,
 292                                               drm_property);
 293   trackrenderer_set_drm(handle_, &trackrenderer_drm_property);
 294 }
 295
 296 void TrackRendererAdapter::DrmLicenseAcquiredDone(TrackType type) {
 297   trackrenderer_drm_license_acquired_done(
 298       handle_, adapter_utils::ConvertToTrackRendererTrackType(type));
 299 }
 300
 301 void TrackRendererAdapter::SetDrmLicenseKey(TrackType type, const std::string& key) {
 302   trackrenderer_set_drm_license_key(
 303       handle_, adapter_utils::ConvertToTrackRendererTrackType(type),
 304       key.c_str());
 305 }
 306 bool TrackRendererAdapter::SetDisplayMode(const DisplayMode& mode) {
 307   if (trackrenderer_set_display_mode(
 308           handle_, adapter_utils::ConvertToTrackRendererDisplayMode(mode)) ==
 309       kFailed) {
 310     return false;
 311   }
 312   return true;
 313 }
 314
 315 bool TrackRendererAdapter::SetDisplay(const DisplayType& type,
 316                                       uint32_t surface_id, long x, long y,
 317                                       long w, long h) {
 318   if (trackrenderer_set_display_surface(
 319           handle_, adapter_utils::ConvertToTrackRendererDisplayType(type),
 320           surface_id, x, y, w, h) == kFailed) {
 321     return false;
 322   }
 323   return true;
 324 }
 325
 326 bool TrackRendererAdapter::SetDisplay(const DisplayType& type, void* obj) {
 327   if (trackrenderer_set_display(
 328           handle_, adapter_utils::ConvertToTrackRendererDisplayType(type),
 329           obj) == kFailed) {
 330     return false;
 331   }
 332   return true;
 333 }
 334
 335 bool TrackRendererAdapter::SetDisplay(const DisplayType& type,
 336                                       void* ecore_wl2_window, int x, int y,
 337                                       int w, int h) {
 338   if (trackrenderer_set_display_ecore_wl2_window(
 339           handle_, adapter_utils::ConvertToTrackRendererDisplayType(type),
 340           ecore_wl2_window, x, y, w, h) == kFailed) {
 341     return false;
 342   }
 343   return true;
 344 }
 345
 346 void TrackRendererAdapter::GetDisplay(DisplayType* type, Geometry* area) {
 347   TrackRendererGeometry geometry = {0, 0, 1920, 1080};
 348   TrackRendererDisplayType display_type = kTrackRendererDisplayTypeNone;
 349   trackrenderer_get_display(handle_, &display_type, &geometry);
 350   adapter_utils::MakeGeometry(area, geometry);
 351   *type = adapter_utils::ConvertToDisplayType(display_type);
 352 }
 353
 354 bool TrackRendererAdapter::SetDisplayRoi(const Geometry& roi) {
 355   TrackRendererGeometry geometry = {0, 0, 1920, 1080};
 356   adapter_utils::MakeTrackRendererGeometry(&geometry, roi);
 357   if (trackrenderer_set_display_roi(handle_, &geometry) == kFailed) {
 358     return false;
 359   }
 360   return true;
 361 }
 362
 363 bool TrackRendererAdapter::SetVideoRoi(const CropArea& area) {
 364   TrackRendererCropArea croparea = {0.0, 0.0, 1.0, 1.0};
 365   adapter_utils::MakeTrackRendererCropArea(&croparea, area);
 366   if (trackrenderer_set_video_roi(handle_, &croparea) == kFailed) {
 367     return false;
 368   }
 369   return true;
 370 }
 371
 372 bool TrackRendererAdapter::SetDisplayRotate(const DisplayRotation& rotate) {
 373   if (trackrenderer_set_display_rotate(
 374           handle_, adapter_utils::ConvertToTrackRendererDisplayRotate(
 375                        rotate)) == kFailed) {
 376     return false;
 377   }
 378   return true;
 379 }
 380
 381 bool TrackRendererAdapter::GetDisplayRotate(DisplayRotation* rotate) {
 382   TrackRendererDisplayRotate display_rotate = kTrackRendererDisplayRotateNone;
 383   if (trackrenderer_get_display_rotate(handle_, &display_rotate) == kFailed) {
 384     return false;
 385   }
 386   *rotate = adapter_utils::ConvertToDisplayRotation(display_rotate);
 387   return true;
 388 }
 389
 390 bool TrackRendererAdapter::SetDisplayVisible(bool is_visible) {
 391   if (trackrenderer_set_display_visible(handle_, is_visible) == kFailed) {
 392     return false;
 393   }
 394   return true;
 395 }
 396
 397 void TrackRendererAdapter::GetDisplayMode(DisplayMode* mode) {
 398   // TODO: sy0207.ju
 399   TrackRendererDisplayMode display_mode = kTrackRendererDisplayModeDisplayMax;
 400   trackrenderer_get_display_mode(handle_, &display_mode);
 401   *mode = adapter_utils::ConvertToDisplayMode(display_mode);
 402 }
 403
 404 bool TrackRendererAdapter::SetAudioMute(bool is_mute) {
 405   if (trackrenderer_set_audio_mute(handle_, is_mute) == kFailed) {
 406     return false;
 407   }
 408   return true;
 409 }
 410
 411 void TrackRendererAdapter::SetVideoStillMode(const StillMode& type) {
 412   trackrenderer_set_video_still_mode(
 413       handle_, adapter_utils::ConvertToTrackRendererStillMode(type));
 414 }
 415
 416 bool TrackRendererAdapter::SetVolume(const int& volume) {
 417   if (trackrenderer_set_volume(handle_, volume) == kFailed) {
 418     return false;
 419   }
 420   return true;
 421 }
 422
 423 bool TrackRendererAdapter::GetVolume(int* volume) {
 424   if (trackrenderer_get_volume(handle_, volume) == kFailed) {
 425     return false;
 426   }
 427   return true;
 428 }
 429
 430 bool TrackRendererAdapter::Flush(const StreamType& type) {
 431   if (trackrenderer_flush(
 432           handle_, adapter_utils::ConvertToTrackRendererTrackTypeFromStreamType(
 433                        type)) == kFailed) {
 434     return false;
 435   }
 436   return true;
 437 }
 438
 439 bool TrackRendererAdapter::Flush(const TrackType& type) {
 440   if (trackrenderer_flush(
 441           handle_, adapter_utils::ConvertToTrackRendererTrackType(type)) ==
 442       kFailed) {
 443     return false;
 444   }
 445   return true;
 446 }
 447
 448 namespace adapter_utils {
 449
 450 enum class ValueType {
 451   kUnknown,
 452   kInt32,
 453   kUInt32,
 454   kInt64,
 455   kUInt64,
 456   kMax,
 457 };
 458 struct AttrInfo {
 459   const ValueType value_type;
 460   const std::string name;
 461 };
 462 static const std::map<TrackRendererAdapter::Attribute, AttrInfo>
 463     kPluginPropertyInfoTable = {
 464         {TrackRendererAdapter::Attribute::kVideoQueueMaxByte,
 465          {ValueType::kUInt64, "video-queue-max-byte"}},
 466         {TrackRendererAdapter::Attribute::kAudioQueueMaxByte,
 467          {ValueType::kUInt64, "audio-queue-max-byte"}},
 468         {TrackRendererAdapter::Attribute::kVideoQueueCurrentLevelByte,
 469          {ValueType::kUInt64, "video-current-level-byte"}},
 470         {TrackRendererAdapter::Attribute::kAudioQueueCurrentLevelByte,
 471          {ValueType::kUInt64, "audio-current-level-byte"}},
 472         {TrackRendererAdapter::Attribute::kVideoMinByteThreshold,
 473          {ValueType::kUInt32, "video-min-byte-percent"}},
 474         {TrackRendererAdapter::Attribute::kAudioMinByteThreshold,
 475          {ValueType::kUInt32, "audio-min-byte-percent"}},
 476         {TrackRendererAdapter::Attribute::kVideoQueueMaxBuffer,
 477          {ValueType::kUInt64, "video-queue-max-buffer"}},
 478         {TrackRendererAdapter::Attribute::kAudioQueueMaxBuffer,
 479          {ValueType::kUInt64, "audio-queue-max-buffer"}},
 480         {TrackRendererAdapter::Attribute::kVideoRenderTimeOffset,
 481          {ValueType::kInt64, "video-render-time-offset"}},
 482         {TrackRendererAdapter::Attribute::kAudioRenderTimeOffset,
 483          {ValueType::kInt64, "audio-render-time-offset"}}
 484         };
 485
 486 static const std::map<TrackRendererAdapter::Attribute, AttrInfo>
 487     kConfigInfoTable = {
 488         {TrackRendererAdapter::Attribute::kAccurateSeekMode,
 489          {ValueType::kUInt32, "accurate-seek-mode"}},
 490         {TrackRendererAdapter::Attribute::kLowLatencyMode,
 491          {ValueType::kUInt32, "low-latency-mode"}},
 492         {TrackRendererAdapter::Attribute::kUnlimitedMaxBufferMode,
 493          {ValueType::kUInt32, "unlimited-max-buffer-mode"}},
 494         {TrackRendererAdapter::Attribute::kVideoPreDisplayMode,
 495          {ValueType::kUInt32, "video-pre-display-mode"}},
 496         {TrackRendererAdapter::Attribute::kStartRenderingTime,
 497          {ValueType::kUInt64, "start-rendering-time"}},
 498         };
 499 }  // namespace adapter_utils
 500
 501 void TrackRendererAdapter::SetAttribute(
 502     const TrackRendererAdapter::Attribute& attr, const boost::any& value) {
 503   if (adapter_utils::kPluginPropertyInfoTable.count(attr) > 0) {
 504     const adapter_utils::AttrInfo& info =
 505         adapter_utils::kPluginPropertyInfoTable.at(attr);
 506     LOG_DEBUG("attribute [%d] : %s", static_cast<int>(attr), info.name.c_str());
 507     switch (info.value_type) {
 508       case adapter_utils::ValueType::kInt32: {
 509         std::int32_t _value = boost::any_cast<std::int32_t>(value);
 510         trackrenderer_set_attribute(handle_, info.name.c_str(), _value,
 511                                     nullptr);
 512       } break;
 513       case adapter_utils::ValueType::kUInt32: {
 514         std::uint32_t _value = boost::any_cast<std::uint32_t>(value);
 515         trackrenderer_set_attribute(handle_, info.name.c_str(), _value,
 516                                     nullptr);
 517       } break;
 518       case adapter_utils::ValueType::kInt64: {
 519         std::int64_t _value = boost::any_cast<std::int64_t>(value);
 520         trackrenderer_set_attribute(handle_, info.name.c_str(), _value,
 521                                     nullptr);
 522       } break;
 523       case adapter_utils::ValueType::kUInt64: {
 524         std::uint64_t _value = boost::any_cast<std::uint64_t>(value);
 525         trackrenderer_set_attribute(handle_, info.name.c_str(), _value,
 526                                     nullptr);
 527       } break;
 528       default:
 529         LOG_ERROR("unknown attribute ...");
 530         break;
 531     }
 532     return;
 533   } else if (adapter_utils::kConfigInfoTable.count(attr) > 0) {
 534     const adapter_utils::AttrInfo& info =
 535         adapter_utils::kConfigInfoTable.at(attr);
 536     switch (info.value_type) {
 537       case adapter_utils::ValueType::kUInt32: {
 538         std::uint32_t _value = boost::any_cast<std::uint32_t>(value);
 539         trackrenderer_set_attribute(handle_, info.name.c_str(), _value,
 540                                     nullptr);
 541       } break;
 542       case adapter_utils::ValueType::kUInt64: {
 543         std::uint64_t _value = boost::any_cast<std::uint64_t>(value);
 544         trackrenderer_set_attribute(handle_, info.name.c_str(), _value,
 545                                     nullptr);
 546       } break;
 547       default:
 548         LOG_ERROR("unknown attribute ...");
 549         break;
 550     }
 551     return;
 552   } else {
 553     LOG_ERROR("unknown attribute");
 554     return;
 555   }
 556 }
 557
 558 void TrackRendererAdapter::GetAttribute(
 559     const TrackRendererAdapter::Attribute& attr, boost::any* value) {
 560   if (adapter_utils::kPluginPropertyInfoTable.count(attr) == 0) {
 561     LOG_ERROR("unknown attribute");
 562     return;
 563   }
 564   const adapter_utils::AttrInfo& info =
 565       adapter_utils::kPluginPropertyInfoTable.at(attr);
 566
 567   switch (info.value_type) {
 568     case adapter_utils::ValueType::kInt32: {
 569       std::int32_t _value = 0;
 570       trackrenderer_get_attribute(handle_, info.name.c_str(), &_value, nullptr);
 571       *value = _value;
 572     } break;
 573     case adapter_utils::ValueType::kUInt32: {
 574       std::uint32_t _value = 0;
 575       trackrenderer_get_attribute(handle_, info.name.c_str(), &_value, nullptr);
 576       *value = _value;
 577     } break;
 578     case adapter_utils::ValueType::kInt64: {
 579       std::int64_t _value = 0;
 580       trackrenderer_get_attribute(handle_, info.name.c_str(), &_value, nullptr);
 581       *value = _value;
 582     } break;
 583     case adapter_utils::ValueType::kUInt64: {
 584       std::uint64_t _value = 0;
 585       trackrenderer_get_attribute(handle_, info.name.c_str(), &_value, nullptr);
 586       *value = _value;
 587     } break;
 588     default:
 589       LOG_ERROR("unknown attribute ...");
 590       break;
 591   }
 592   return;
 593 }
 594
 595 void TrackRendererAdapter::RegisterListener(EventListener* listener) {
 596   eventlistener_ = listener;
 597   trackrenderer_set_error_cb(handle_, ErrorCb_, (void*)this);
 598   trackrenderer_set_resourceconflict_cb(handle_, ResourceConflictCb_,
 599                                         (void*)this);
 600   trackrenderer_set_seekdone_cb(handle_, SeekDoneCb_, (void*)this);
 601   trackrenderer_set_eos_cb(handle_, EosCb_, (void*)this);
 602   trackrenderer_set_subtitle_rawdata_cb(handle_, SubtitleRawDataCb_,
 603                                         (void*)this);
 604   trackrenderer_set_closedcaption_cb(handle_, ClosedCaptionDataCb_,
 605                                      (void*)this);
 606   trackrenderer_set_drminitdata_cb(handle_, DrmInitDataCb_, (void*)this);
 607 }
 608
 609 void TrackRendererAdapter::RegisterListenerForEsplayer(
 610     EventListener* listener) {
 611   eventlistener_ = listener;
 612   trackrenderer_set_error_cb(handle_, ErrorCb_, (void*)this);
 613   trackrenderer_set_resourceconflict_cb(handle_, ResourceConflictCb_,
 614                                         (void*)this);
 615   trackrenderer_set_seekdone_cb(handle_, SeekDoneCb_, (void*)this);
 616   trackrenderer_set_flushdone_cb(handle_, FlushDoneCb_, (void*)this);
 617   trackrenderer_set_eos_cb(handle_, EosCb_, (void*)this);
 618   trackrenderer_set_event_cb(handle_, EventCb_, (void*)this);
 619   trackrenderer_set_bufferstatus_cb(handle_, BufferStatusCb_, (void*)this);
 620   trackrenderer_set_seekdata_cb(handle_, SeekDataCb_, (void*)this);
 621   trackrenderer_set_closedcaption_cb(handle_, ClosedCaptionDataCb_,
 622                                      (void*)this);
 623   trackrenderer_set_media_packet_video_decoded_cb(
 624       handle_, MediaPacketVideoDecodedCb_, (void*)this);
 625 }
 626
 627 TrackRendererState TrackRendererAdapter::GetState() {
 628   return trackrenderer_get_state(handle_);
 629 }
 630
 631 bool TrackRendererAdapter::SetMatroskaColorInfo(const std::string& color_info) {
 632   if (trackrenderer_set_matroska_color_info(handle_, color_info.c_str()) ==
 633       kFailed) {
 634     return false;
 635   }
 636   return true;
 637 }
 638
 639 void TrackRendererAdapter::SetVideoFrameBufferType(
 640     const DecodedVideoFrameBufferType& type) {
 641   trackrenderer_set_video_frame_buffer_type(
 642       handle_, adapter_utils::ConvertToVideoFrameBufferType(type));
 643 }
 644
 645 GetDecodedVideoFrameStatus TrackRendererAdapter::GetDecodedPacket(
 646     DecodedVideoPacket& packet) {
 647   TrackRendererDecodedVideoPacket _packet;
 648   TrackRendererGetDecodedVideoFrameState state;
 649   trackrenderer_get_decoded_video_frame(handle_, &_packet, &state);
 650   packet = adapter_utils::ConvertToDecodedVideoPacket(&_packet);
 651   return adapter_utils::ConvertToGetDecodedVideoFrameStatus(state);
 652 }
 653
 654 bool TrackRendererAdapter::ReturnDecodedPacket(
 655     const DecodedVideoPacket& packet) {
 656   auto _packet = adapter_utils::ConvertToDecodedVideoPacket(packet);
 657   if (trackrenderer_return_decoded_video_frame(handle_, &_packet) == kFailed) {
 658     return false;
 659   }
 660   return true;
 661 }
 662
 663 bool TrackRendererAdapter::EnableVideoHole(bool value) {
 664   return (trackrenderer_enable_video_hole(handle_, value) != kFailed);
 665 }
 666
 667 /////////////////////////////////////////////
 668 /////////////// Callbacks ///////////////////
 669 /////////////////////////////////////////////
 670 void TrackRendererAdapter::ErrorCb_(const TrackRendererErrorType error_code,
 671                                     UserData userdata) {
 672   auto adapter = static_cast<TrackRendererAdapter*>(userdata);
 673   if (!adapter) return;
 674   adapter->eventlistener_->OnError(
 675       adapter_utils::ConvertToErrorType(error_code));
 676 }
 677
 678 void TrackRendererAdapter::ResourceConflictCb_(UserData userdata) {
 679   auto adapter = static_cast<TrackRendererAdapter*>(userdata);
 680   if (!adapter) return;
 681   adapter->eventlistener_->OnResourceConflicted();
 682 }
 683
 684 void TrackRendererAdapter::SeekDoneCb_(UserData userdata) {
 685   auto adapter = static_cast<TrackRendererAdapter*>(userdata);
 686   if (!adapter) return;
 687   adapter->eventlistener_->OnSeekDone();
 688 }
 689
 690 void TrackRendererAdapter::FlushDoneCb_(UserData userdata) {
 691   auto adapter = static_cast<TrackRendererAdapter*>(userdata);
 692   if (!adapter) return;
 693   adapter->eventlistener_->OnFlushDone();
 694 }
 695
 696 void TrackRendererAdapter::EosCb_(UserData userdata) {
 697   auto adapter = static_cast<TrackRendererAdapter*>(userdata);
 698   if (!adapter) return;
 699   adapter->eventlistener_->OnEos();
 700 }
 701
 702 void TrackRendererAdapter::EventCb_(const TrackRendererEventType event_type,
 703                                     const TrackrendererEventMsg msg_data,
 704                                     UserData userdata) {
 705   auto adapter = static_cast<TrackRendererAdapter*>(userdata);
 706   if (!adapter) return;
 707   EventMsg event_msg;
 708   event_msg.data = msg_data.data;
 709   event_msg.len = msg_data.len;
 710   adapter->eventlistener_->OnEvent(static_cast<EventType>(event_type),
 711                                    event_msg);
 712 }
 713
 714 void TrackRendererAdapter::FirstDecodingDoneCb_(UserData userdata) {
 715   auto adapter = static_cast<TrackRendererAdapter*>(userdata);
 716   if (!adapter) return;
 717   adapter->eventlistener_->OnFirstDecodingDone();
 718 }
 719
 720 void TrackRendererAdapter::SubtitleRawDataCb_(
 721     TrackRendererDecoderInputBuffer* buf, const TrackRendererSubtitleType type,
 722     UserData userdata) {
 723   auto adapter = static_cast<TrackRendererAdapter*>(userdata);
 724   if (!adapter || !buf) return;
 725
 726 #ifdef TRACKRENDERER_GST_DEPENDENCY_REMOVAL
 727   auto buffer = DecoderInputBuffer::Create(
 728       adapter_utils::ConvertToTrackType(buf->type), buf->index,
 729       static_cast<GstBuffer*>(buf->buffer));
 730 #else
 731   auto buffer = DecoderInputBuffer::Create(
 732       adapter_utils::ConvertToTrackType(buf->type), buf->index, buf->buffer);
 733 #endif
 734   adapter->eventlistener_->OnSubtitleData(
 735       std::move(buffer), adapter_utils::ConvertToSubtitleType(type));
 736 }
 737
 738 #ifndef TRACKRENDERER_FEATURE_DEPRECATE_SUBTITLE_CB
 739 void TrackRendererAdapter::SubtitleDataCb_(const char* data, const int size,
 740                                            const TrackRendererSubtitleType type,
 741                                            const uint64_t duration,
 742                                            TrackRendererSubtitleAttr* attr_list,
 743                                            int attr_list_size,
 744                                            UserData userdata) {
 745   auto adapter = static_cast<TrackRendererAdapter*>(userdata);
 746   if (!adapter) return;
 747
 748   SubtitleAttrList list;
 749   int index = 0;
 750   for (index = 0; index < attr_list_size; index++) {
 751     SubtitleAttr attr{
 752         adapter_utils::ConvertToSubtitleAttrType(attr_list[index].type),
 753         attr_list[index].start_time, attr_list[index].stop_time,
 754         adapter_utils::SetSubtitleAttrValue(attr_list[index]),
 755         attr_list[index].extsub_index};
 756     list.push_back(std::move(attr));
 757   }
 758   auto new_list = SubtitleAttrListPtr(new SubtitleAttrList(std::move(list)));
 759
 760   adapter->eventlistener_->OnSubtitleData(
 761       data, size, adapter_utils::ConvertToSubtitleType(type), duration,
 762       std::move(new_list));
 763 }
 764 #endif
 765
 766 void TrackRendererAdapter::ClosedCaptionDataCb_(const char* data,
 767                                                 const int size,
 768                                                 UserData userdata) {
 769   auto adapter = static_cast<TrackRendererAdapter*>(userdata);
 770   if (!adapter) return;
 771   adapter->eventlistener_->OnClosedCaptionData(data, size);
 772 }
 773
 774 void TrackRendererAdapter::DrmInitDataCb_(int* drmhandle, unsigned int len,
 775                                           unsigned char* psshdata,
 776                                           TrackRendererTrackType type,
 777                                           UserData userdata) {
 778   auto adapter = static_cast<TrackRendererAdapter*>(userdata);
 779   if (!adapter) return;
 780   adapter->eventlistener_->OnDrmInitData(
 781       drmhandle, len, psshdata, adapter_utils::ConvertToTrackType(type));
 782 }
 783
 784 void TrackRendererAdapter::BufferStatusCb_(
 785     const TrackRendererTrackType type, const TrackRendererBufferStatus status,
 786     UserData userdata) {
 787   auto adapter = static_cast<TrackRendererAdapter*>(userdata);
 788   if (!adapter) return;
 789   adapter->eventlistener_->OnBufferStatus(
 790       adapter_utils::ConvertToTrackType(type),
 791       adapter_utils::ConvertToBufferStatus(status));
 792 }
 793
 794 void TrackRendererAdapter::SeekDataCb_(const TrackRendererTrackType type,
 795                                        const uint64_t offset,
 796                                        UserData userdata) {
 797   auto adapter = static_cast<TrackRendererAdapter*>(userdata);
 798   if (!adapter) return;
 799   adapter->eventlistener_->OnSeekData(adapter_utils::ConvertToTrackType(type),
 800                                       offset);
 801 }
 802
 803 void TrackRendererAdapter::MediaPacketVideoDecodedCb_(
 804     const TrackRendererDecodedVideoPacket* packet, UserData userdata) {
 805   auto adapter = static_cast<TrackRendererAdapter*>(userdata);
 806   if (!adapter) return;
 807   DecodedVideoPacket _packet =
 808       adapter_utils::ConvertToDecodedVideoPacket(packet);
 809   adapter->eventlistener_->OnMediaPacketVideoDecoded(_packet);
 810 }
 811
 812 }  // namespace plusplayer