src/plusplayer-core/src/trackrendereradapter_utils.cpp

   1 //
   2 // @ Copyright [2017] <S/W Platform, Visual Display, Samsung Electronics>
   3 //
   4
   5 #include "core/trackrendereradapter_utils.h"
   6
   7 #include <typeinfo>
   8
   9 #include "core/utils/plusplayer_log.h"
  10
  11 namespace esplusplayer {
  12
  13 namespace adapter_utils {
  14
  15 void InitTrack(TrackRendererTrack* track) {
  16 #ifdef TIZEN_FEATURE_PUBLIC
  17   memset(track, 0x00, sizeof(TrackRendererTrack));
  18 #endif
  19   track->index = kTrackRendererInvalidTrackIndex;  // int index
  20   track->id = 0;                                   // int id
  21   track->mimetype = nullptr;                       // const char* mimetype
  22   track->streamtype = nullptr;                     // const char* streamtype
  23   track->type = kTrackRendererTrackTypeMax;        // int type
  24   track->codec_data = nullptr;                     // char* codec_data
  25   track->codec_data_len = 0;                       // int codec_data_len
  26   track->width = 0;                                // int width
  27   track->height = 0;                               // int height
  28   track->maxwidth = 0;                             // int maxwidth
  29   track->maxheight = 0;                            // int maxheight
  30   track->framerate_num = 0;                        // int framerate_num
  31   track->framerate_den = 0;                        // int framerate_den
  32   track->sample_rate = 0;                          // int sample_rate
  33   track->sample_format = 0;                        // int sample_format
  34   track->channels = 0;                             // int channels
  35   track->version = 0;                              // int version
  36   track->layer = 0;                                // int layer
  37   track->bits_per_sample = 0;                      // int bit_per_sample
  38   track->block_align = 0;                          // int block_align
  39   track->bitrate = 0;                              // int bitrate
  40   track->endianness = 1234;                        // int endianness
  41   track->is_signed = 0;                            // int is_signed
  42   track->active = 0;                               // int active
  43   track->use_swdecoder = 0;                        // int use_swdecoder
  44   track->language_code = nullptr;                  // const char* language_code
  45   track->subtitle_format = nullptr;  // const char* subtitle_format
  46 }
  47
  48 void MakeGeometry(Geometry* roi, const TrackRendererGeometry& geometry) {
  49   roi->x = geometry.x;
  50   roi->y = geometry.y;
  51   roi->w = geometry.w;
  52   roi->h = geometry.h;
  53 }
  54
  55 void MakeTrackRendererDrmProperty(
  56 #if DRM_MAPI_AARCH_64
  57     TrackRendererDrmProperty_64bit* trackrenderer_drm_property,
  58 #else
  59     TrackRendererDrmProperty* trackrenderer_drm_property,
  60 #endif
  61     const drm::Property& drm_property) {
  62   trackrenderer_drm_property->type =
  63       ConvertToTrackRendererDrmType(drm_property.type);
  64 #if DRM_MAPI_AARCH_64
  65   trackrenderer_drm_property->handle =
  66       static_cast<unsigned long>(drm_property.handle);
  67 #else
  68   trackrenderer_drm_property->handle = static_cast<int>(drm_property.handle);
  69 #endif
  70   trackrenderer_drm_property->external_decryption =
  71       static_cast<bool>(drm_property.external_decryption);
  72   trackrenderer_drm_property->license_acquired_cb =
  73       static_cast<void*>(drm_property.license_acquired_cb);
  74   trackrenderer_drm_property->license_acquired_userdata =
  75       static_cast<void*>(drm_property.license_acquired_userdata);
  76 }
  77
  78 void MakeTrackRendererGeometry(TrackRendererGeometry* geometry,
  79                                const Geometry& roi) {
  80   geometry->x = roi.x;
  81   geometry->y = roi.y;
  82   geometry->w = roi.w;
  83   geometry->h = roi.h;
  84 }
  85
  86 void MakeTrackRendererCropArea(TrackRendererCropArea* crop,
  87                                const CropArea& area) {
  88   crop->scale_x = area.scale_x;
  89   crop->scale_y = area.scale_y;
  90   crop->scale_w = area.scale_w;
  91   crop->scale_h = area.scale_h;
  92 }
  93
  94 void MakeTrackRendererRenderRect(TrackRendererRenderRect* output,
  95                                  const RenderRect& input) {
  96   output->x = input.x;
  97   output->y = input.y;
  98   output->w = input.w;
  99   output->h = input.h;
 100 }
 101
 102 void MakeTrackRendererTrack(TrackRendererTrack* track, const Track& trackinfo) {
 103   InitTrack(track);
 104   track->index = trackinfo.index;
 105   track->id = trackinfo.id;
 106   track->mimetype = trackinfo.mimetype.c_str();
 107   track->streamtype = trackinfo.streamtype.c_str();
 108   track->type = ConvertToTrackRendererTrackType(trackinfo.type);
 109   track->codec_data = trackinfo.codec_data.get();
 110   track->codec_data_len = trackinfo.codec_data_len;
 111   track->width = trackinfo.width;
 112   track->height = trackinfo.height;
 113   track->maxwidth = trackinfo.maxwidth;
 114   track->maxheight = trackinfo.maxheight;
 115   track->framerate_num = trackinfo.framerate_num;
 116   track->framerate_den = trackinfo.framerate_den;
 117   track->sample_rate = trackinfo.sample_rate;
 118   track->sample_format = trackinfo.sample_format;
 119   track->channels = trackinfo.channels;
 120   track->version = trackinfo.version;
 121   track->layer = trackinfo.layer;
 122   track->bits_per_sample = trackinfo.bits_per_sample;
 123   track->block_align = trackinfo.block_align;
 124   track->bitrate = trackinfo.bitrate;
 125   track->endianness = trackinfo.endianness;
 126   track->is_signed = trackinfo.is_signed;
 127   track->active = trackinfo.active;
 128   track->use_swdecoder = trackinfo.use_swdecoder;
 129   track->language_code = trackinfo.language_code.c_str();
 130   track->subtitle_format = trackinfo.subtitle_format.c_str();
 131 }
 132
 133 void MakeTrackRendererAppInfo(TrackRendererAppInfo* app_attr,
 134                               const PlayerAppInfo& app_info) {
 135   app_attr->id = const_cast<char*>(app_info.id.c_str());
 136   app_attr->version = const_cast<char*>(app_info.version.c_str());
 137   app_attr->type = const_cast<char*>(app_info.type.c_str());
 138 }
 139
 140 void MakeTrackRendererAppInfoEx(TrackRendererAppInfoEx* app_attr,
 141                                 const PlayerAppInfoEx& app_info) {
 142   app_attr->id = const_cast<char*>(app_info.id.c_str());
 143   app_attr->version = const_cast<char*>(app_info.version.c_str());
 144   app_attr->type = const_cast<char*>(app_info.type.c_str());
 145   app_attr->runtitle = const_cast<char*>(app_info.runtitle.c_str());
 146 }
 147
 148 void MakeAudioEasingInfo(AudioEasingInfo* easing_info,
 149                          const TrackRendererAudioEasingInfo& easing_attr) {
 150   easing_info->target_volume = easing_attr.target_volume;
 151   easing_info->duration = easing_attr.duration;
 152   easing_info->type = ConvertToAudioEasingType(easing_attr.type);
 153 }
 154
 155 void MakeTrackRendererAudioEasingInfo(TrackRendererAudioEasingInfo* easing_attr,
 156                                       const AudioEasingInfo& easing_info) {
 157   easing_attr->target_volume = easing_info.target_volume;
 158   easing_attr->duration = easing_info.duration;
 159   easing_attr->type = ConvertToTrackRendererAudioEasingType(easing_info.type);
 160 }
 161
 162 void MakeTrackRendererRational(TrackRendererRational* rational_attr,
 163                                const Rational& rational_info) {
 164   if (!rational_attr) return;
 165   rational_attr->num = rational_info.num;
 166   rational_attr->den = rational_info.den;
 167 }
 168
 169 DisplayMode ConvertToDisplayMode(TrackRendererDisplayMode typevalue) {
 170   switch (typevalue) {
 171     case kTrackRendererDisplayModeLetterBox: {
 172       return DisplayMode::kLetterBox;
 173     }
 174     case kTrackRendererDisplayModeOriginSize: {
 175       return DisplayMode::kOriginSize;
 176     }
 177     case kTrackRendererDisplayModeFullScreen: {
 178       return DisplayMode::kFullScreen;
 179     }
 180     case kTrackRendererDisplayModeCroppedFull: {
 181       return DisplayMode::kCroppedFull;
 182     }
 183     case kTrackRendererDisplayModeOriginOrLetter: {
 184       return DisplayMode::kOriginOrLetter;
 185     }
 186     case kTrackRendererDisplayModeDstRoi: {
 187       return DisplayMode::kDstRoi;
 188     }
 189     case kTrackRendererDisplayModeAutoAspectRatio: {
 190       return DisplayMode::kAutoAspectRatio;
 191     }
 192     case kTrackRendererDisplayModeDisplayMax: {
 193       return DisplayMode::kMax;
 194     }
 195     default:
 196       LOG_ERROR("unknown DisplayMode");
 197       return DisplayMode::kFullScreen;
 198   }
 199 }
 200 DisplayRotation ConvertToDisplayRotation(
 201     const TrackRendererDisplayRotate rotate_value) {
 202   switch (rotate_value) {
 203     case kTrackRendererDisplayRotateNone: {
 204       return DisplayRotation::kNone;
 205     }
 206     case kTrackRendererDisplayRotate90: {
 207       return DisplayRotation::kRotate90;
 208     }
 209     case kTrackRendererDisplayRotate180: {
 210       return DisplayRotation::kRotate180;
 211     }
 212     case kTrackRendererDisplayRotate270: {
 213       return DisplayRotation::kRotate270;
 214     }
 215     default:
 216       return DisplayRotation::kNone;
 217   }
 218 }
 219
 220 DisplayType ConvertToDisplayType(const TrackRendererDisplayType typevalue) {
 221   switch (typevalue) {
 222     case kTrackRendererDisplayTypeNone: {
 223       return DisplayType::kNone;
 224     }
 225     case kTrackRendererDisplayTypeOverlay: {
 226       return DisplayType::kOverlay;
 227     }
 228     case kTrackRendererDisplayTypeEvas: {
 229       return DisplayType::kEvas;
 230     }
 231     default:
 232       LOG_ERROR("unknown DisplayType");
 233       return DisplayType::kNone;
 234   }
 235 }
 236
 237 ErrorType ConvertToErrorType(const TrackRendererErrorType type) {
 238   switch (type) {
 239     case kTrackRendererErrorTypeErrorNone: {
 240       return ErrorType::kNone;
 241     }
 242     case kTrackRendererErrorTypeOutOfMemory: {
 243       return ErrorType::kOutOfMemory;
 244     }
 245     case kTrackRendererErrorTypeInvalidParameter: {
 246       return ErrorType::kInvalidParameter;
 247     }
 248     case kTrackRendererErrorTypeNoSuchFile: {
 249       return ErrorType::kNoSuchFile;
 250     }
 251     case kTrackRendererErrorTypeInvalidOperation: {
 252       return ErrorType::kInvalidOperation;
 253     }
 254     case kTrackRendererErrorTypeFileNoSpaceOnDevice: {
 255       return ErrorType::kFileNoSpaceOnDevice;
 256     }
 257     case kTrackRendererErrorTypeFeatureNotSupportedOnDevice: {
 258       return ErrorType::kFeatureNotSupportedOnDevice;
 259     }
 260     case kTrackRendererErrorTypeSeekFailed: {
 261       return ErrorType::kSeekFailed;
 262     }
 263     case kTrackRendererErrorTypeInvalidState: {
 264       return ErrorType::kInvalidState;
 265     }
 266     case kTrackRendererErrorTypeNotSupportedFile: {
 267       return ErrorType::kNotSupportedFile;
 268     }
 269     case kTrackRendererErrorTypeInvalidUri: {
 270       return ErrorType::kInvalidUri;
 271     }
 272     case kTrackRendererErrorTypeSoundPolicy: {
 273       return ErrorType::kSoundPolicy;
 274     }
 275     case kTrackRendererErrorTypeConnectionFailed: {
 276       return ErrorType::kConnectionFailed;
 277     }
 278     case kTrackRendererErrorTypeVideoCaptureFailed: {
 279       return ErrorType::kVideoCaptureFailed;
 280     }
 281     case kTrackRendererErrorTypeDrmExpired: {
 282       return ErrorType::kDrmExpired;
 283     }
 284     case kTrackRendererErrorTypeDrmNoLicense: {
 285       return ErrorType::kDrmNoLicense;
 286     }
 287     case kTrackRendererErrorTypeDrmFutureUse: {
 288       return ErrorType::kDrmFutureUse;
 289     }
 290     case kTrackRendererErrorTypeDrmNotPermitted: {
 291       return ErrorType::kDrmNotPermitted;
 292     }
 293     case kTrackRendererErrorTypeResourceLimit: {
 294       return ErrorType::kResourceLimit;
 295     }
 296     case kTrackRendererErrorTypePermissionDenied: {
 297       return ErrorType::kPermissionDenied;
 298     }
 299     case kTrackRendererErrorTypeServiceDisconnected: {
 300       return ErrorType::kServiceDisconnected;
 301     }
 302     case kTrackRendererErrorTypeBufferSpace: {
 303       return ErrorType::kBufferSpace;
 304     }
 305     case kTrackRendererErrorTypeNotSupportedAudioCodec: {
 306       return ErrorType::kNotSupportedAudioCodec;
 307     }
 308     case kTrackRendererErrorTypeNotSupportedVideoCodec: {
 309       return ErrorType::kNotSupportedVideoCodec;
 310     }
 311     case kTrackRendererErrorTypeNotSupportedSubtitle: {
 312       return ErrorType::kNotSupportedSubtitle;
 313     }
 314     case kTrackRendererErrorTypeDrmInfo: {
 315       return ErrorType::kDrmInfo;
 316     }
 317     case kTrackRendererErrorTypeNotSupportedFormat: {
 318       return ErrorType::kNotSupportedFormat;
 319     }
 320     case kTrackRendererErrorTypeStreamingPlayer: {
 321       return ErrorType::kStreamingPlayer;
 322     }
 323     case kTrackRendererErrorTypeDtcpFsk: {
 324       return ErrorType::kDtcpFsk;
 325     }
 326     case kTrackRendererErrorTypePreLoadingTimeOut: {
 327       return ErrorType::kPreLoadingTimeOut;
 328     }
 329     case kTrackRendererErrorTypeNetworkError: {
 330       return ErrorType::kNetworkError;
 331     }
 332     case kTrackRendererErrorTypeChannelSurfingFailed: {
 333       return ErrorType::kChannelSurfingFailed;
 334     }
 335     case kTrackRendererErrorTypeUnknown: {
 336       return ErrorType::kUnknown;
 337     }
 338     default:
 339       LOG_ERROR("unknown errortype");
 340       return ErrorType::kUnknown;
 341   }
 342 }
 343
 344 // LCOV_EXCL_START
 345 #ifndef TRACKRENDERER_FEATURE_DEPRECATE_SUBTITLE_CB
 346 SubtitleAttrType ConvertToSubtitleAttrType(
 347     const TrackRendererSubtitleAttrType& type) {
 348   switch (type) {
 349     case kTrackRendererSubtitleAttrTypeRegionXPos: {
 350       return SubtitleAttrType::kSubAttrRegionXPos;
 351     }
 352     case kTrackRendererSubtitleAttrTypeRegionYPos: {
 353       return SubtitleAttrType::kSubAttrRegionYPos;
 354     }
 355     case kTrackRendererSubtitleAttrTypeRegionWidth: {
 356       return SubtitleAttrType::kSubAttrRegionWidth;
 357     }
 358     case kTrackRendererSubtitleAttrTypeRegionHeight: {
 359       return SubtitleAttrType::kSubAttrRegionHeight;
 360     }
 361     case kTrackRendererSubtitleAttrTypeWindowXPadding: {
 362       return SubtitleAttrType::kSubAttrWindowXPadding;
 363     }
 364     case kTrackRendererSubtitleAttrTypeWindowYPadding: {
 365       return SubtitleAttrType::kSubAttrWindowYPadding;
 366     }
 367     case kTrackRendererSubtitleAttrTypeWindowLeftMargin: {
 368       return SubtitleAttrType::kSubAttrWindowLeftMargin;
 369     }
 370     case kTrackRendererSubtitleAttrTypeWindowRightMargin: {
 371       return SubtitleAttrType::kSubAttrWindowRightMargin;
 372     }
 373     case kTrackRendererSubtitleAttrTypeWindowTopMargin: {
 374       return SubtitleAttrType::kSubAttrWindowTopMargin;
 375     }
 376     case kTrackRendererSubtitleAttrTypeWindowBottomMargin: {
 377       return SubtitleAttrType::kSubAttrWindowBottomMargin;
 378     }
 379     case kTrackRendererSubtitleAttrTypeWindowBgColor: {
 380       return SubtitleAttrType::kSubAttrWindowBgColor;
 381     }
 382     case kTrackRendererSubtitleAttrTypeWindowOpacity: {
 383       return SubtitleAttrType::kSubAttrWindowOpacity;
 384     }
 385     case kTrackRendererSubtitleAttrTypeWindowShowBg: {
 386       return SubtitleAttrType::kSubAttrWindowShowBg;
 387     }
 388     case kTrackRendererSubtitleAttrTypeFontFamily: {
 389       return SubtitleAttrType::kSubAttrFontFamily;
 390     }
 391     case kTrackRendererSubtitleAttrTypeFontSize: {
 392       return SubtitleAttrType::kSubAttrFontSize;
 393     }
 394     case kTrackRendererSubtitleAttrTypeFontWeight: {
 395       return SubtitleAttrType::kSubAttrFontWeight;
 396     }
 397     case kTrackRendererSubtitleAttrTypeFontStyle: {
 398       return SubtitleAttrType::kSubAttrFontStyle;
 399     }
 400     case kTrackRendererSubtitleAttrTypeFontColor: {
 401       return SubtitleAttrType::kSubAttrFontColor;
 402     }
 403     case kTrackRendererSubtitleAttrTypeFontBgColor: {
 404       return SubtitleAttrType::kSubAttrFontBgColor;
 405     }
 406     case kTrackRendererSubtitleAttrTypeFontOpacity: {
 407       return SubtitleAttrType::kSubAttrFontOpacity;
 408     }
 409     case kTrackRendererSubtitleAttrTypeFontBgOpacity: {
 410       return SubtitleAttrType::kSubAttrFontBgOpacity;
 411     }
 412     case kTrackRendererSubtitleAttrTypeFontTextOutlineColor: {
 413       return SubtitleAttrType::kSubAttrFontTextOutlineColor;
 414     }
 415     case kTrackRendererSubtitleAttrTypeFontTextOutlineThickness: {
 416       return SubtitleAttrType::kSubAttrFontTextOutlineThickness;
 417     }
 418     case kTrackRendererSubtitleAttrTypeFontTextOutlineBlurRadius: {
 419       return SubtitleAttrType::kSubAttrFontTextOutlineBlurRadius;
 420     }
 421     case kTrackRendererSubtitleAttrTypeFontVerticalAlign: {
 422       return SubtitleAttrType::kSubAttrFontVerticalAlign;
 423     }
 424     case kTrackRendererSubtitleAttrTypeFontHorizontalAlign: {
 425       return SubtitleAttrType::kSubAttrFontHorizontalAlign;
 426     }
 427     case kTrackRendererSubtitleAttrTypeRawSubtitle: {
 428       return SubtitleAttrType::kSubAttrRawSubtitle;
 429     }
 430     case kTrackRendererSubtitleAttrTypeWebvttCueLine: {
 431       return SubtitleAttrType::kSubAttrWebvttCueLine;
 432     }
 433     case kTrackRendererSubtitleAttrTypeWebvttCueLineNum: {
 434       return SubtitleAttrType::kSubAttrWebvttCueLineNum;
 435     }
 436     case kTrackRendererSubtitleAttrTypeWebvttCueLineAlign: {
 437       return SubtitleAttrType::kSubAttrWebvttCueLineAlign;
 438     }
 439     case kTrackRendererSubtitleAttrTypeWebvttCueAlign: {
 440       return SubtitleAttrType::kSubAttrWebvttCueAlign;
 441     }
 442     case kTrackRendererSubtitleAttrTypeWebvttCueSize: {
 443       return SubtitleAttrType::kSubAttrWebvttCueSize;
 444     }
 445     case kTrackRendererSubtitleAttrTypeWebvttCuePosition: {
 446       return SubtitleAttrType::kSubAttrWebvttCuePosition;
 447     }
 448     case kTrackRendererSubtitleAttrTypeWebvttCuePositionAlign: {
 449       return SubtitleAttrType::kSubAttrWebvttCuePositionAlign;
 450     }
 451     case kTrackRendererSubtitleAttrTypeWebvttCueVertical: {
 452       return SubtitleAttrType::kSubAttrWebvttCueVertical;
 453     }
 454     case kTrackRendererSubtitleAttrTypeTimestamp: {
 455       return SubtitleAttrType::kSubAttrTimestamp;
 456     }
 457     case kTrackRendererSubtitleAttrTypeExtsubIndex: {
 458       return SubtitleAttrType::kSubAttrExtsubIndex;
 459     }
 460     case kTrackRendererSubtitleAttrTypeTypeNone: {
 461       return SubtitleAttrType::kSubAttrTypeNone;
 462     }
 463     default:
 464       LOG_ERROR("unknown subtitle attr tracktype");
 465       return SubtitleAttrType::kSubAttrTypeNone;
 466   }
 467 }
 468 #endif
 469 // LCOV_EXCL_STOP
 470
 471 SubtitleType ConvertToSubtitleType(const TrackRendererSubtitleType& type) {
 472   switch (type) {
 473     case kTrackRendererSubtitleTypeText: {
 474       return SubtitleType::kText;
 475     }
 476     case kTrackRendererSubtitleTypePicture: {
 477       return SubtitleType::kPicture;
 478     }
 479     case kTrackRendererSubtitleTypeInvalid: {
 480       return SubtitleType::kInvalid;
 481     }
 482     default:
 483       LOG_ERROR("unknown subtitletype");
 484       return SubtitleType::kInvalid;
 485   }
 486 }
 487
 488 TrackType ConvertToTrackType(TrackRendererTrackType typevalue) {
 489   switch (typevalue) {
 490     case kTrackRendererTrackTypeAudio: {
 491       return TrackType::kTrackTypeAudio;
 492     }
 493     case kTrackRendererTrackTypeVideo: {
 494       return TrackType::kTrackTypeVideo;
 495     }
 496     case kTrackRendererTrackTypeSubtitle: {
 497       return TrackType::kTrackTypeSubtitle;
 498     }
 499     case kTrackRendererTrackTypeMax: {
 500       return TrackType::kTrackTypeMax;
 501     }
 502     default:
 503       LOG_ERROR("unknown tracktype");
 504       return TrackType::kTrackTypeMax;
 505   }
 506 }
 507
 508 DecodedVideoPacket ConvertToDecodedVideoPacket(
 509     const TrackRendererDecodedVideoPacket* packet) {
 510   DecodedVideoPacket _packet;
 511   _packet.pts = packet->pts;
 512   _packet.duration = packet->duration;
 513   _packet.surface_data = static_cast<tbm_surface_h>(packet->surface_data);
 514 #ifdef TIZEN_FEATURE_PUBLIC
 515   _packet.buffer_addr = packet->buffer_addr;
 516 #else
 517   _packet.scaler_index = packet->scaler_index;
 518 #endif
 519   return _packet;
 520 }
 521
 522 TrackRendererDecodedVideoPacket ConvertToDecodedVideoPacket(
 523     const DecodedVideoPacket& packet) {
 524   TrackRendererDecodedVideoPacket _packet;
 525   _packet.pts = packet.pts;
 526   _packet.duration = packet.duration;
 527   _packet.surface_data = static_cast<tbm_surface_h>(packet.surface_data);
 528 #ifdef TIZEN_FEATURE_PUBLIC
 529   _packet.buffer_addr = packet.buffer_addr;
 530 #else
 531   _packet.scaler_index = packet.scaler_index;
 532 #endif
 533   return _packet;
 534 }
 535
 536 TrackRendererDecodedVideoFrameBufferType ConvertToVideoFrameBufferType(
 537     const DecodedVideoFrameBufferType& type) {
 538   switch (type) {
 539     case DecodedVideoFrameBufferType::kCopy: {
 540       return kTrackRendererDecodedVideoFrameBufferCopy;
 541     }
 542     case DecodedVideoFrameBufferType::kReference: {
 543       return kTrackRendererDecodedVideoFrameBufferReference;
 544     }
 545     case DecodedVideoFrameBufferType::kScale: {
 546       return kTrackRendererDecodedVideoFrameBufferScale;
 547     }
 548     case DecodedVideoFrameBufferType::kManualCopy: {
 549       return kTrackRendererDecodedVideoFrameBufferManualCopy;
 550     }
 551     case DecodedVideoFrameBufferType::kNone: {
 552       return kTrackRendererDecodedVideoFrameBufferNone;
 553     }
 554     default:
 555       LOG_ERROR("wrong buffer type");
 556       return kTrackRendererDecodedVideoFrameBufferNone;
 557   }
 558 }
 559
 560 GetDecodedVideoFrameStatus ConvertToGetDecodedVideoFrameStatus(
 561     const TrackRendererGetDecodedVideoFrameState state) {
 562   switch (state) {
 563     case TrackRendererGetDecodedVideoFrameStateErrorNone: {
 564       return GetDecodedVideoFrameStatus::kSuccess;
 565     }
 566     case TrackRendererGetDecodedVideoFrameStateNoRemainingBufferError: {
 567       return GetDecodedVideoFrameStatus::kNoRemainingBuffer;
 568     }
 569     case TrackRendererGetDecodedVideoFrameStateNoFilledBufferError: {
 570       return GetDecodedVideoFrameStatus::kNoFilledBuffer;
 571     }
 572     case TrackRendererGetDecodedVideoFrameStateUnknownError: {
 573       return GetDecodedVideoFrameStatus::kUnknown;
 574     }
 575     default:
 576       LOG_ERROR("wrong state type");
 577       return GetDecodedVideoFrameStatus::kUnknown;
 578   }
 579 }
 580
 581 TrackRendererDisplayMode ConvertToTrackRendererDisplayMode(
 582     const DisplayMode& mode) {
 583   switch (mode) {
 584     case DisplayMode::kLetterBox: {
 585       return kTrackRendererDisplayModeLetterBox;
 586     }
 587     case DisplayMode::kOriginSize: {
 588       return kTrackRendererDisplayModeOriginSize;
 589     }
 590     case DisplayMode::kFullScreen: {
 591       return kTrackRendererDisplayModeFullScreen;
 592     }
 593     case DisplayMode::kCroppedFull: {
 594       return kTrackRendererDisplayModeCroppedFull;
 595     }
 596     case DisplayMode::kOriginOrLetter: {
 597       return kTrackRendererDisplayModeOriginOrLetter;
 598     }
 599     case DisplayMode::kDstRoi: {
 600       return kTrackRendererDisplayModeDstRoi;
 601     }
 602     case DisplayMode::kAutoAspectRatio: {
 603       return kTrackRendererDisplayModeAutoAspectRatio;
 604     }
 605     case DisplayMode::kMax: {
 606       return kTrackRendererDisplayModeDisplayMax;
 607     }
 608     default:
 609       LOG_ERROR("unknown displaymode");
 610       return kTrackRendererDisplayModeFullScreen;
 611   }
 612 }
 613
 614 TrackRendererDisplayRotate ConvertToTrackRendererDisplayRotate(
 615     const DisplayRotation& rotate) {
 616   switch (rotate) {
 617     case DisplayRotation::kNone: {
 618       return kTrackRendererDisplayRotateNone;
 619     }
 620     case DisplayRotation::kRotate90: {
 621       return kTrackRendererDisplayRotate90;
 622     }
 623     case DisplayRotation::kRotate180: {
 624       return kTrackRendererDisplayRotate180;
 625     }
 626     case DisplayRotation::kRotate270: {
 627       return kTrackRendererDisplayRotate270;
 628     }
 629     default:
 630       LOG_ERROR("unknown displayrotate");
 631       return kTrackRendererDisplayRotateNone;
 632   }
 633 }
 634
 635 TrackRendererDisplayType ConvertToTrackRendererDisplayType(
 636     const DisplayType& type) {
 637   switch (type) {
 638     case DisplayType::kNone: {
 639       return kTrackRendererDisplayTypeNone;
 640     }
 641     case DisplayType::kOverlay: {
 642       return kTrackRendererDisplayTypeOverlay;
 643     }
 644     case DisplayType::kEvas: {
 645       return kTrackRendererDisplayTypeEvas;
 646     }
 647     default:
 648       LOG_ERROR("unknown displaytype");
 649       return kTrackRendererDisplayTypeNone;
 650   }
 651 }
 652
 653 TrackRendererDrmType ConvertToTrackRendererDrmType(const drm::Type& drm_type) {
 654   switch (drm_type) {
 655     case drm::Type::kNone: {
 656       return kTrackRendererDrmTypeNone;
 657     }
 658     case drm::Type::kPlayready: {
 659       return kTrackRendererDrmTypePlayready;
 660     }
 661     case drm::Type::kMarlin: {
 662       return kTrackRendererDrmTypeMarlin;
 663     }
 664     case drm::Type::kVerimatrix: {
 665       return kTrackRendererDrmTypeVerimatrix;
 666     }
 667     case drm::Type::kWidevineClassic: {
 668       return kTrackRendererDrmTypeWidevineClassic;
 669     }
 670     case drm::Type::kSecuremedia: {
 671       return kTrackRendererDrmTypeSecuremedia;
 672     }
 673     case drm::Type::kSdrm: {
 674       return kTrackRendererDrmTypeSdrm;
 675     }
 676     case drm::Type::kWidevineCdm: {
 677       return kTrackRendererDrmTypeWidevineCdm;
 678     }
 679     case drm::Type::kMax: {
 680       return kTrackRendererDrmTypeDrmMax;
 681     }
 682     default:
 683       LOG_ERROR("unknown drmtype");
 684       return kTrackRendererDrmTypeNone;
 685   }
 686 }
 687
 688 TrackRendererStillMode ConvertToTrackRendererStillMode(
 689     const StillMode& still_mode) {
 690   switch (still_mode) {
 691     case StillMode::kNone: {
 692       return kTrackRendererStillModeNone;
 693     }
 694     case StillMode::kOff: {
 695       return kTrackRendererStillModeOff;
 696     }
 697     case StillMode::kOn: {
 698       return kTrackRendererStillModeOn;
 699     }
 700     default:
 701       LOG_ERROR("unknown stillmode");
 702       return kTrackRendererStillModeNone;
 703   }
 704 }
 705
 706 TrackRendererTrackType ConvertToTrackRendererTrackType(const TrackType& type) {
 707   switch (type) {
 708     case TrackType::kTrackTypeAudio: {
 709       return kTrackRendererTrackTypeAudio;
 710     }
 711     case TrackType::kTrackTypeVideo: {
 712       return kTrackRendererTrackTypeVideo;
 713     }
 714     case TrackType::kTrackTypeSubtitle: {
 715       return kTrackRendererTrackTypeSubtitle;
 716     }
 717     case TrackType::kTrackTypeMax: {
 718       return kTrackRendererTrackTypeMax;
 719     }
 720     default:
 721       LOG_ERROR("unknown tracktype");
 722       return kTrackRendererTrackTypeMax;
 723   }
 724 }
 725
 726 TrackRendererTrackType ConvertToTrackRendererTrackTypeFromStreamType(
 727     const StreamType& type) {
 728   switch (type) {
 729     case StreamType::kAudio: {
 730       return kTrackRendererTrackTypeAudio;
 731     }
 732     case StreamType::kVideo: {
 733       return kTrackRendererTrackTypeVideo;
 734     }
 735     case StreamType::kMax: {
 736       return kTrackRendererTrackTypeMax;
 737     }
 738     default:
 739       LOG_ERROR("unknown steamtype");
 740       return kTrackRendererTrackTypeMax;
 741   }
 742 }
 743
 744 TrackRendererVideoStreamRotation ConvertToTrackRendererVideoStreamRotation(
 745     const VideoRotation& rotation) {
 746   switch (rotation) {
 747     case VideoRotation::kVideoRotateNone: {
 748       return kTrackRendererVideoStreamRotationNone;
 749     }
 750     case VideoRotation::kVideoRotate90: {
 751       return kTrackRendererVideoStreamRotation90;
 752     }
 753     case VideoRotation::kVideoRotate180: {
 754       return kTrackRendererVideoStreamRotation180;
 755     }
 756     case VideoRotation::kVideoRotate270: {
 757       return kTrackRendererVideoStreamRotation270;
 758     }
 759     default:
 760       LOG_ERROR("unknown rotation type");
 761       return kTrackRendererVideoStreamRotationNone;
 762   }
 763 }
 764
 765 // LCOV_EXCL_START
 766 #ifndef TRACKRENDERER_FEATURE_DEPRECATE_SUBTITLE_CB
 767 boost::any SetSubtitleAttrValue(const TrackRendererSubtitleAttr& attr) {
 768   boost::any any_value;
 769   switch (attr.type) {
 770     case kTrackRendererSubtitleAttrTypeRegionXPos:         // fall through
 771     case kTrackRendererSubtitleAttrTypeRegionYPos:         // fall through
 772     case kTrackRendererSubtitleAttrTypeRegionWidth:        // fall through
 773     case kTrackRendererSubtitleAttrTypeRegionHeight:       // fall through
 774     case kTrackRendererSubtitleAttrTypeWindowXPadding:     // fall through
 775     case kTrackRendererSubtitleAttrTypeWindowYPadding:     // fall through
 776     case kTrackRendererSubtitleAttrTypeWindowOpacity:      // fall through
 777     case kTrackRendererSubtitleAttrTypeWindowShowBg:       // fall through
 778     case kTrackRendererSubtitleAttrTypeFontSize:           // fall through
 779     case kTrackRendererSubtitleAttrTypeFontOpacity:        // fall through
 780     case kTrackRendererSubtitleAttrTypeFontBgOpacity:      // fall through
 781     case kTrackRendererSubtitleAttrTypeWebvttCueLine:      // fall through
 782     case kTrackRendererSubtitleAttrTypeWebvttCueSize:      // fall through
 783     case kTrackRendererSubtitleAttrTypeWebvttCuePosition:  // fall through
 784     case kTrackRendererSubtitleAttrTypeWebvttCueVertical: {
 785       if (attr.value.f) any_value = attr.value.f;
 786       break;
 787     }
 788     case kTrackRendererSubtitleAttrTypeWindowLeftMargin:      // fall through
 789     case kTrackRendererSubtitleAttrTypeWindowRightMargin:     // fall through
 790     case kTrackRendererSubtitleAttrTypeWindowTopMargin:       // fall through
 791     case kTrackRendererSubtitleAttrTypeWindowBottomMargin:    // fall through
 792     case kTrackRendererSubtitleAttrTypeWindowBgColor:         // fall through
 793     case kTrackRendererSubtitleAttrTypeFontWeight:            // fall through
 794     case kTrackRendererSubtitleAttrTypeFontStyle:             // fall through
 795     case kTrackRendererSubtitleAttrTypeFontColor:             // fall through
 796     case kTrackRendererSubtitleAttrTypeFontBgColor:           // fall through
 797     case kTrackRendererSubtitleAttrTypeFontTextOutlineColor:  // fall through
 798     case kTrackRendererSubtitleAttrTypeFontTextOutlineThickness:   // fall
 799                                                                    // through
 800     case kTrackRendererSubtitleAttrTypeFontTextOutlineBlurRadius:  // fall
 801                                                                    // through
 802     case kTrackRendererSubtitleAttrTypeFontVerticalAlign:    // fall through
 803     case kTrackRendererSubtitleAttrTypeFontHorizontalAlign:  // fall through
 804     case kTrackRendererSubtitleAttrTypeWebvttCueLineNum:     // fall through
 805     case kTrackRendererSubtitleAttrTypeWebvttCueLineAlign:   // fall through
 806     case kTrackRendererSubtitleAttrTypeWebvttCueAlign:       // fall through
 807     case kTrackRendererSubtitleAttrTypeWebvttCuePositionAlign: {
 808       if (attr.value.i32) any_value = attr.value.i32;
 809       break;
 810     }
 811     case kTrackRendererSubtitleAttrTypeFontFamily:  // fall through
 812     case kTrackRendererSubtitleAttrTypeRawSubtitle: {
 813       if (attr.value.str) any_value = std::string(attr.value.str);
 814       break;
 815     }
 816     case kTrackRendererSubtitleAttrTypeTimestamp:
 817     case kTrackRendererSubtitleAttrTypeExtsubIndex:
 818       break;
 819     default:
 820       LOG_ERROR("Unknown subtitle attr type");
 821   }
 822   return any_value;
 823 }
 824 #endif
 825 // LCOV_EXCL_STOP
 826
 827 BufferStatus ConvertToBufferStatus(const TrackRendererBufferStatus& status) {
 828   switch (status) {
 829     case kTrackRendererBufferStatusUnderrun: {
 830       return BufferStatus::kUnderrun;
 831     }
 832     case kTrackRendererBufferStatusOverrun: {
 833       return BufferStatus::kOverrun;
 834     }
 835   }
 836   LOG_ERROR("Unknown buffern status");
 837   return BufferStatus::kUnderrun;
 838 }
 839
 840 TrackRendererCatchUpSpeed ConvertToTrackRendererCatchUpSpeed(
 841     const CatchUpSpeed& level) {
 842   switch (level) {
 843     case CatchUpSpeed::kNone: {
 844       return kTrackRendererCatchUpSpeedNone;
 845     }
 846     case CatchUpSpeed::kSlow: {
 847       return kTrackRendererCatchUpSpeedSlow;
 848     }
 849     case CatchUpSpeed::kNormal: {
 850       return kTrackRendererCatchUpSpeedNormal;
 851     }
 852     case CatchUpSpeed::kFast: {
 853       return kTrackRendererCatchUpSpeedFast;
 854     }
 855   }
 856   LOG_ERROR("Unknown catch up speed");
 857   return kTrackRendererCatchUpSpeedNone;
 858 }
 859
 860 LatencyStatus ConvertToLatencyStatus(const TrackRendererLatencyStatus& status) {
 861   switch (status) {
 862     case kTrackRendererLatencyStatusLow: {
 863       return LatencyStatus::kLow;
 864     }
 865     case kTrackRendererLatencyStatusMid: {
 866       return LatencyStatus::kMid;
 867     }
 868     case kTrackRendererLatencyStatusHigh: {
 869       return LatencyStatus::kHigh;
 870     }
 871   }
 872   LOG_ERROR("Unknown status");
 873   return LatencyStatus::kLow;
 874 }
 875
 876 AudioEasingType ConvertToAudioEasingType(
 877     const TrackRendererAudioEasingType& type) {
 878   switch (type) {
 879     case TrackRendererAudioEasingType::kTrackRendererAudioEasingLinear: {
 880       return AudioEasingType::kAudioEasingLinear;
 881     }
 882     case TrackRendererAudioEasingType::kTrackRendererAudioEasingIncubic: {
 883       return AudioEasingType::kAudioEasingIncubic;
 884     }
 885     case TrackRendererAudioEasingType::kTrackRendererAudioEasingOutcubic: {
 886       return AudioEasingType::kAudioEasingOutcubic;
 887     }
 888     default:
 889       LOG_ERROR("Unknown audio easing type");
 890       return AudioEasingType::kAudioEasingNone;
 891   }
 892 }
 893
 894 TrackRendererAudioEasingType ConvertToTrackRendererAudioEasingType(
 895     const AudioEasingType& type) {
 896   switch (type) {
 897     case AudioEasingType::kAudioEasingLinear: {
 898       return TrackRendererAudioEasingType::kTrackRendererAudioEasingLinear;
 899     }
 900     case AudioEasingType::kAudioEasingIncubic: {
 901       return TrackRendererAudioEasingType::kTrackRendererAudioEasingIncubic;
 902     }
 903     case AudioEasingType::kAudioEasingOutcubic: {
 904       return TrackRendererAudioEasingType::kTrackRendererAudioEasingOutcubic;
 905     }
 906     default:
 907       LOG_ERROR("Unknown audio easing type");
 908       return TrackRendererAudioEasingType::kTrackRendererAudioEasingNone;
 909   }
 910 }
 911
 912 bool ConvertToTrackRendererRscType(const RscType& typevalue,
 913                                    TrackRendererRscType* type) {
 914   switch (typevalue) {
 915     case RscType::kVideoRenderer: {
 916       *type = kTrackRendererRscTypeVideoRenderer;
 917       return true;
 918     }
 919     default:
 920       LOG_ERROR("unknown resource type");
 921       return false;
 922   }
 923 }
 924
 925 bool ConvertToTrackRendererAdvPictureQualityType(
 926     const AdvPictureQualityType& typevalue,
 927     TrackRendererAdvPictureQualityType* type) {
 928   switch (typevalue) {
 929     case AdvPictureQualityType::kVideoCall: {
 930       *type = kTrackRendererAdvPictureQualityTypeVideoCall;
 931       return true;
 932     }
 933     case AdvPictureQualityType::kUsbCamera: {
 934       *type = kTrackRendererAdvPictureQualityTypeUsbCamera;
 935       return true;
 936     }
 937     case AdvPictureQualityType::kAirplayMirroring: {
 938       *type = kTrackRendererAdvPictuerQualityTypeAirplayMirroring;
 939       return true;
 940     }
 941     default:
 942       LOG_ERROR("unknown resource type");
 943       return false;
 944   }
 945 }
 946
 947 bool ConvertToTrackRendererRscAllocPolicy(const RscAllocPolicy& policyvalue,
 948                                           TrackRendererRscAllocPolicy* policy) {
 949   switch (policyvalue) {
 950     case RscAllocPolicy::kRscAllocExclusive: {
 951       *policy = kTrackRendererRscAllocExclusive;
 952       return true;
 953     }
 954     case RscAllocPolicy::kRscAllocConditional: {
 955       *policy = kTrackRendererRscAllocConditional;
 956       return true;
 957     }
 958     case RscAllocPolicy::kRscAllocExclusiveNoExplicit: {
 959       *policy = kTrackRendererRscAllocExclusiveNoExplicit;
 960       return true;
 961     }
 962     default:
 963       LOG_ERROR("unknown policy");
 964       return false;
 965   }
 966 }
 967
 968 bool ConvertToTrackRendererAlternativeAudioResource(
 969     const PlayerAudioResourceType& typevalue, unsigned int* type) {
 970   switch (typevalue) {
 971     case kPlayerAudioResourceTypeMain:
 972       *type = 0;
 973       return true;
 974     case kPlayerAudioResourceTypeSubDecoder:
 975       *type = 1;
 976       return true;
 977     case kPlayerAudioResourceTypeSimpleMixOut:
 978       *type = 3;
 979       return true;
 980     default:
 981       LOG_ERROR("unkown type");
 982       return false;
 983   }
 984 }
 985
 986 }  // namespace adapter_utils
 987
 988 }  // namespace esplusplayer