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