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 plusplayer {
  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   track->stream_format = nullptr;
  44   track->alignment = nullptr;
  45   track->original_media_type = nullptr;
  46   track->protection_system = nullptr;
  47 }
  48
  49 void MakeGeometry(Geometry* roi, const TrackRendererGeometry& geometry) {
  50   roi->x = geometry.x;
  51   roi->y = geometry.y;
  52   roi->w = geometry.w;
  53   roi->h = geometry.h;
  54 }
  55
  56 void MakeTrackRendererDrmProperty(
  57     TrackRendererDrmProperty* trackrenderer_drm_property,
  58     const drm::Property& drm_property) {
  59   trackrenderer_drm_property->type =
  60       ConvertToTrackRendererDrmType(drm_property.type);
  61   trackrenderer_drm_property->handle = static_cast<int>(drm_property.handle);
  62   trackrenderer_drm_property->external_decryption =
  63       static_cast<bool>(drm_property.external_decryption);
  64   trackrenderer_drm_property->license_acquired_cb =
  65       static_cast<void*>(drm_property.license_acquired_cb);
  66   trackrenderer_drm_property->license_acquired_userdata =
  67       static_cast<void*>(drm_property.license_acquired_userdata);
  68 }
  69
  70 void MakeTrackRendererGeometry(TrackRendererGeometry* geometry,
  71                                const Geometry& roi) {
  72   geometry->x = roi.x;
  73   geometry->y = roi.y;
  74   geometry->w = roi.w;
  75   geometry->h = roi.h;
  76 }
  77
  78 void MakeTrackRendererCropArea(TrackRendererCropArea* crop,
  79                                const CropArea& area) {
  80   crop->scale_x = area.scale_x;
  81   crop->scale_y = area.scale_y;
  82   crop->scale_w = area.scale_w;
  83   crop->scale_h = area.scale_h;
  84 }
  85
  86 #if 0
  87 void MakeTrackRendererRenderRect(TrackRendererRenderRect* output,
  88                                  const RenderRect& input) {
  89   output->x = input.x;
  90   output->y = input.y;
  91   output->w = input.w;
  92   output->h = input.h;
  93 }
  94 #endif
  95
  96 void MakeTrackRendererTrack(TrackRendererTrack* track, const Track& trackinfo) {
  97   InitTrack(track);
  98   track->index = trackinfo.index;
  99   track->id = trackinfo.id;
 100   track->mimetype = trackinfo.mimetype.c_str();
 101   track->streamtype = trackinfo.streamtype.c_str();
 102   track->type = ConvertToTrackRendererTrackType(trackinfo.type);
 103   track->codec_data = trackinfo.codec_data.get();
 104   track->codec_data_len = trackinfo.codec_data_len;
 105   track->width = trackinfo.width;
 106   track->height = trackinfo.height;
 107   track->maxwidth = trackinfo.maxwidth;
 108   track->maxheight = trackinfo.maxheight;
 109   track->framerate_num = trackinfo.framerate_num;
 110   track->framerate_den = trackinfo.framerate_den;
 111   track->sample_rate = trackinfo.sample_rate;
 112   track->sample_format = trackinfo.sample_format;
 113   track->channels = trackinfo.channels;
 114   track->version = trackinfo.version;
 115   track->layer = trackinfo.layer;
 116   track->bits_per_sample = trackinfo.bits_per_sample;
 117   track->block_align = trackinfo.block_align;
 118   track->bitrate = trackinfo.bitrate;
 119   track->endianness = trackinfo.endianness;
 120   track->is_signed = trackinfo.is_signed;
 121   track->active = trackinfo.active;
 122   track->use_swdecoder = trackinfo.use_swdecoder;
 123   track->language_code = trackinfo.language_code.c_str();
 124   track->subtitle_format = trackinfo.subtitle_format.c_str();
 125   track->stream_format = trackinfo.stream_format.c_str();
 126   track->alignment = trackinfo.alignment.c_str();
 127   track->original_media_type = trackinfo.original_media_type.c_str();
 128   track->protection_system = trackinfo.protection_system.c_str();
 129 }
 130
 131 DisplayMode ConvertToDisplayMode(TrackRendererDisplayMode typevalue) {
 132   switch (typevalue) {
 133     case kTrackRendererDisplayModeLetterBox: {
 134       return DisplayMode::kLetterBox;
 135     }
 136     case kTrackRendererDisplayModeOriginSize: {
 137       return DisplayMode::kOriginSize;
 138     }
 139     case kTrackRendererDisplayModeFullScreen: {
 140       return DisplayMode::kFullScreen;
 141     }
 142     case kTrackRendererDisplayModeCroppedFull: {
 143       return DisplayMode::kCroppedFull;
 144     }
 145     case kTrackRendererDisplayModeOriginOrLetter: {
 146       return DisplayMode::kOriginOrLetter;
 147     }
 148     case kTrackRendererDisplayModeDstRoi: {
 149       return DisplayMode::kDstRoi;
 150     }
 151     case kTrackRendererDisplayModeAutoAspectRatio: {
 152       return DisplayMode::kAutoAspectRatio;
 153     }
 154     case kTrackRendererDisplayModeDisplayMax: {
 155       return DisplayMode::kMax;
 156     }
 157     default:
 158       LOG_ERROR("unknown DisplayMode");
 159       return DisplayMode::kFullScreen;
 160   }
 161 }
 162 DisplayRotation ConvertToDisplayRotation(
 163     const TrackRendererDisplayRotate rotate_value) {
 164   switch (rotate_value) {
 165     case kTrackRendererDisplayRotateNone: {
 166       return DisplayRotation::kNone;
 167     }
 168     case kTrackRendererDisplayRotate90: {
 169       return DisplayRotation::kRotate90;
 170     }
 171     case kTrackRendererDisplayRotate180: {
 172       return DisplayRotation::kRotate180;
 173     }
 174     case kTrackRendererDisplayRotate270: {
 175       return DisplayRotation::kRotate270;
 176     }
 177     default:
 178       return DisplayRotation::kNone;
 179   }
 180 }
 181
 182 DisplayType ConvertToDisplayType(const TrackRendererDisplayType typevalue) {
 183   switch (typevalue) {
 184     case kTrackRendererDisplayTypeNone: {
 185       return DisplayType::kNone;
 186     }
 187     case kTrackRendererDisplayTypeOverlay: {
 188       return DisplayType::kOverlay;
 189     }
 190     case kTrackRendererDisplayTypeEvas: {
 191       return DisplayType::kEvas;
 192     }
 193     default:
 194       LOG_ERROR("unknown DisplayType");
 195       return DisplayType::kNone;
 196   }
 197 }
 198
 199 ErrorType ConvertToErrorType(const TrackRendererErrorType type) {
 200   switch (type) {
 201     case kTrackRendererErrorTypeErrorNone: {
 202       return ErrorType::kNone;
 203     }
 204     case kTrackRendererErrorTypeOutOfMemory: {
 205       return ErrorType::kOutOfMemory;
 206     }
 207     case kTrackRendererErrorTypeInvalidParameter: {
 208       return ErrorType::kInvalidParameter;
 209     }
 210     case kTrackRendererErrorTypeNoSuchFile: {
 211       return ErrorType::kNoSuchFile;
 212     }
 213     case kTrackRendererErrorTypeInvalidOperation: {
 214       return ErrorType::kInvalidOperation;
 215     }
 216     case kTrackRendererErrorTypeFileNoSpaceOnDevice: {
 217       return ErrorType::kFileNoSpaceOnDevice;
 218     }
 219     case kTrackRendererErrorTypeFeatureNotSupportedOnDevice: {
 220       return ErrorType::kFeatureNotSupportedOnDevice;
 221     }
 222     case kTrackRendererErrorTypeSeekFailed: {
 223       return ErrorType::kSeekFailed;
 224     }
 225     case kTrackRendererErrorTypeInvalidState: {
 226       return ErrorType::kInvalidState;
 227     }
 228     case kTrackRendererErrorTypeNotSupportedFile: {
 229       return ErrorType::kNotSupportedFile;
 230     }
 231     case kTrackRendererErrorTypeInvalidUri: {
 232       return ErrorType::kInvalidUri;
 233     }
 234     case kTrackRendererErrorTypeSoundPolicy: {
 235       return ErrorType::kSoundPolicy;
 236     }
 237     case kTrackRendererErrorTypeConnectionFailed: {
 238       return ErrorType::kConnectionFailed;
 239     }
 240     case kTrackRendererErrorTypeVideoCaptureFailed: {
 241       return ErrorType::kVideoCaptureFailed;
 242     }
 243     case kTrackRendererErrorTypeDrmExpired: {
 244       return ErrorType::kDrmExpired;
 245     }
 246     case kTrackRendererErrorTypeDrmNoLicense: {
 247       return ErrorType::kDrmNoLicense;
 248     }
 249     case kTrackRendererErrorTypeDrmFutureUse: {
 250       return ErrorType::kDrmFutureUse;
 251     }
 252     case kTrackRendererErrorTypeDrmNotPermitted: {
 253       return ErrorType::kDrmNotPermitted;
 254     }
 255     case kTrackRendererErrorTypeResourceLimit: {
 256       return ErrorType::kResourceLimit;
 257     }
 258     case kTrackRendererErrorTypePermissionDenied: {
 259       return ErrorType::kPermissionDenied;
 260     }
 261     case kTrackRendererErrorTypeServiceDisconnected: {
 262       return ErrorType::kServiceDisconnected;
 263     }
 264     case kTrackRendererErrorTypeBufferSpace: {
 265       return ErrorType::kBufferSpace;
 266     }
 267     case kTrackRendererErrorTypeNotSupportedAudioCodec: {
 268       return ErrorType::kNotSupportedAudioCodec;
 269     }
 270     case kTrackRendererErrorTypeNotSupportedVideoCodec: {
 271       return ErrorType::kNotSupportedVideoCodec;
 272     }
 273     case kTrackRendererErrorTypeNotSupportedSubtitle: {
 274       return ErrorType::kNotSupportedSubtitle;
 275     }
 276     case kTrackRendererErrorTypeDrmInfo: {
 277       return ErrorType::kDrmInfo;
 278     }
 279     case kTrackRendererErrorTypeNotSupportedFormat: {
 280       return ErrorType::kNotSupportedFormat;
 281     }
 282     case kTrackRendererErrorTypeStreamingPlayer: {
 283       return ErrorType::kStreamingPlayer;
 284     }
 285     case kTrackRendererErrorTypeDtcpFsk: {
 286       return ErrorType::kDtcpFsk;
 287     }
 288     case kTrackRendererErrorTypePreLoadingTimeOut: {
 289       return ErrorType::kPreLoadingTimeOut;
 290     }
 291     case kTrackRendererErrorTypeNetworkError: {
 292       return ErrorType::kNetworkError;
 293     }
 294     case kTrackRendererErrorTypeChannelSurfingFailed: {
 295       return ErrorType::kChannelSurfingFailed;
 296     }
 297     case kTrackRendererErrorTypeUnknown: {
 298       return ErrorType::kUnknown;
 299     }
 300     default:
 301       LOG_ERROR("unknown errortype");
 302       return ErrorType::kUnknown;
 303   }
 304 }
 305
 306 #ifndef TRACKRENDERER_FEATURE_DEPRECATE_SUBTITLE_CB
 307 SubtitleAttrType ConvertToSubtitleAttrType(
 308     const TrackRendererSubtitleAttrType& type) {
 309   switch (type) {
 310     case kTrackRendererSubtitleAttrTypeRegionXPos: {
 311       return SubtitleAttrType::kSubAttrRegionXPos;
 312     }
 313     case kTrackRendererSubtitleAttrTypeRegionYPos: {
 314       return SubtitleAttrType::kSubAttrRegionYPos;
 315     }
 316     case kTrackRendererSubtitleAttrTypeRegionWidth: {
 317       return SubtitleAttrType::kSubAttrRegionWidth;
 318     }
 319     case kTrackRendererSubtitleAttrTypeRegionHeight: {
 320       return SubtitleAttrType::kSubAttrRegionHeight;
 321     }
 322     case kTrackRendererSubtitleAttrTypeWindowXPadding: {
 323       return SubtitleAttrType::kSubAttrWindowXPadding;
 324     }
 325     case kTrackRendererSubtitleAttrTypeWindowYPadding: {
 326       return SubtitleAttrType::kSubAttrWindowYPadding;
 327     }
 328     case kTrackRendererSubtitleAttrTypeWindowLeftMargin: {
 329       return SubtitleAttrType::kSubAttrWindowLeftMargin;
 330     }
 331     case kTrackRendererSubtitleAttrTypeWindowRightMargin: {
 332       return SubtitleAttrType::kSubAttrWindowRightMargin;
 333     }
 334     case kTrackRendererSubtitleAttrTypeWindowTopMargin: {
 335       return SubtitleAttrType::kSubAttrWindowTopMargin;
 336     }
 337     case kTrackRendererSubtitleAttrTypeWindowBottomMargin: {
 338       return SubtitleAttrType::kSubAttrWindowBottomMargin;
 339     }
 340     case kTrackRendererSubtitleAttrTypeWindowBgColor: {
 341       return SubtitleAttrType::kSubAttrWindowBgColor;
 342     }
 343     case kTrackRendererSubtitleAttrTypeWindowOpacity: {
 344       return SubtitleAttrType::kSubAttrWindowOpacity;
 345     }
 346     case kTrackRendererSubtitleAttrTypeWindowShowBg: {
 347       return SubtitleAttrType::kSubAttrWindowShowBg;
 348     }
 349     case kTrackRendererSubtitleAttrTypeFontFamily: {
 350       return SubtitleAttrType::kSubAttrFontFamily;
 351     }
 352     case kTrackRendererSubtitleAttrTypeFontSize: {
 353       return SubtitleAttrType::kSubAttrFontSize;
 354     }
 355     case kTrackRendererSubtitleAttrTypeFontWeight: {
 356       return SubtitleAttrType::kSubAttrFontWeight;
 357     }
 358     case kTrackRendererSubtitleAttrTypeFontStyle: {
 359       return SubtitleAttrType::kSubAttrFontStyle;
 360     }
 361     case kTrackRendererSubtitleAttrTypeFontColor: {
 362       return SubtitleAttrType::kSubAttrFontColor;
 363     }
 364     case kTrackRendererSubtitleAttrTypeFontBgColor: {
 365       return SubtitleAttrType::kSubAttrFontBgColor;
 366     }
 367     case kTrackRendererSubtitleAttrTypeFontOpacity: {
 368       return SubtitleAttrType::kSubAttrFontOpacity;
 369     }
 370     case kTrackRendererSubtitleAttrTypeFontBgOpacity: {
 371       return SubtitleAttrType::kSubAttrFontBgOpacity;
 372     }
 373     case kTrackRendererSubtitleAttrTypeFontTextOutlineColor: {
 374       return SubtitleAttrType::kSubAttrFontTextOutlineColor;
 375     }
 376     case kTrackRendererSubtitleAttrTypeFontTextOutlineThickness: {
 377       return SubtitleAttrType::kSubAttrFontTextOutlineThickness;
 378     }
 379     case kTrackRendererSubtitleAttrTypeFontTextOutlineBlurRadius: {
 380       return SubtitleAttrType::kSubAttrFontTextOutlineBlurRadius;
 381     }
 382     case kTrackRendererSubtitleAttrTypeFontVerticalAlign: {
 383       return SubtitleAttrType::kSubAttrFontVerticalAlign;
 384     }
 385     case kTrackRendererSubtitleAttrTypeFontHorizontalAlign: {
 386       return SubtitleAttrType::kSubAttrFontHorizontalAlign;
 387     }
 388     case kTrackRendererSubtitleAttrTypeRawSubtitle: {
 389       return SubtitleAttrType::kSubAttrRawSubtitle;
 390     }
 391     case kTrackRendererSubtitleAttrTypeWebvttCueLine: {
 392       return SubtitleAttrType::kSubAttrWebvttCueLine;
 393     }
 394     case kTrackRendererSubtitleAttrTypeWebvttCueLineNum: {
 395       return SubtitleAttrType::kSubAttrWebvttCueLineNum;
 396     }
 397     case kTrackRendererSubtitleAttrTypeWebvttCueLineAlign: {
 398       return SubtitleAttrType::kSubAttrWebvttCueLineAlign;
 399     }
 400     case kTrackRendererSubtitleAttrTypeWebvttCueAlign: {
 401       return SubtitleAttrType::kSubAttrWebvttCueAlign;
 402     }
 403     case kTrackRendererSubtitleAttrTypeWebvttCueSize: {
 404       return SubtitleAttrType::kSubAttrWebvttCueSize;
 405     }
 406     case kTrackRendererSubtitleAttrTypeWebvttCuePosition: {
 407       return SubtitleAttrType::kSubAttrWebvttCuePosition;
 408     }
 409     case kTrackRendererSubtitleAttrTypeWebvttCuePositionAlign: {
 410       return SubtitleAttrType::kSubAttrWebvttCuePositionAlign;
 411     }
 412     case kTrackRendererSubtitleAttrTypeWebvttCueVertical: {
 413       return SubtitleAttrType::kSubAttrWebvttCueVertical;
 414     }
 415     case kTrackRendererSubtitleAttrTypeTimestamp: {
 416       return SubtitleAttrType::kSubAttrTimestamp;
 417     }
 418     case kTrackRendererSubtitleAttrTypeExtsubIndex: {
 419       return SubtitleAttrType::kSubAttrExtsubIndex;
 420     }
 421     case kTrackRendererSubtitleAttrTypeTypeNone: {
 422       return SubtitleAttrType::kSubAttrTypeNone;
 423     }
 424     default:
 425       LOG_ERROR("unknown subtitle attr tracktype");
 426       return SubtitleAttrType::kSubAttrTypeNone;
 427   }
 428 }
 429 #endif
 430
 431 SubtitleType ConvertToSubtitleType(const TrackRendererSubtitleType& type) {
 432   switch (type) {
 433     case kTrackRendererSubtitleTypeText: {
 434       return SubtitleType::kText;
 435     }
 436     case kTrackRendererSubtitleTypePicture: {
 437       return SubtitleType::kPicture;
 438     }
 439     case kTrackRendererSubtitleTypeInvalid: {
 440       return SubtitleType::kInvalid;
 441     }
 442     default:
 443       LOG_ERROR("unknown subtitletype");
 444       return SubtitleType::kInvalid;
 445   }
 446 }
 447
 448 TrackType ConvertToTrackType(TrackRendererTrackType typevalue) {
 449   switch (typevalue) {
 450     case kTrackRendererTrackTypeAudio: {
 451       return TrackType::kTrackTypeAudio;
 452     }
 453     case kTrackRendererTrackTypeVideo: {
 454       return TrackType::kTrackTypeVideo;
 455     }
 456     case kTrackRendererTrackTypeSubtitle: {
 457       return TrackType::kTrackTypeSubtitle;
 458     }
 459     case kTrackRendererTrackTypeMax: {
 460       return TrackType::kTrackTypeMax;
 461     }
 462     default:
 463       LOG_ERROR("unknown tracktype");
 464       return TrackType::kTrackTypeMax;
 465   }
 466 }
 467
 468 DecodedVideoPacket ConvertToDecodedVideoPacket(
 469     const TrackRendererDecodedVideoPacket* packet) {
 470   DecodedVideoPacket _packet;
 471   _packet.pts = packet->pts;
 472   _packet.duration = packet->duration;
 473   _packet.surface_data = static_cast<tbm_surface_h>(packet->surface_data);
 474   _packet.buffer_addr = packet->buffer_addr;
 475   return _packet;
 476 }
 477
 478 TrackRendererDecodedVideoPacket ConvertToDecodedVideoPacket(
 479     const DecodedVideoPacket& packet) {
 480   TrackRendererDecodedVideoPacket _packet;
 481   _packet.pts = packet.pts;
 482   _packet.duration = packet.duration;
 483   _packet.surface_data = static_cast<tbm_surface_h>(packet.surface_data);
 484   _packet.buffer_addr = packet.buffer_addr;
 485   return _packet;
 486 }
 487
 488 TrackRendererDecodedVideoFrameBufferType ConvertToVideoFrameBufferType(
 489     const DecodedVideoFrameBufferType& type) {
 490   switch (type) {
 491     case DecodedVideoFrameBufferType::kCopy: {
 492       return kTrackRendererDecodedVideoFrameBufferCopy;
 493     }
 494     case DecodedVideoFrameBufferType::kReference: {
 495       return kTrackRendererDecodedVideoFrameBufferReference;
 496     }
 497     case DecodedVideoFrameBufferType::kScale: {
 498       return kTrackRendererDecodedVideoFrameBufferScale;
 499     }
 500     case DecodedVideoFrameBufferType::kNone: {
 501       return kTrackRendererDecodedVideoFrameBufferNone;
 502     }
 503     default:
 504       LOG_ERROR("wrong buffer type");
 505       return kTrackRendererDecodedVideoFrameBufferNone;
 506   }
 507 }
 508
 509 GetDecodedVideoFrameStatus ConvertToGetDecodedVideoFrameStatus(
 510     const TrackRendererGetDecodedVideoFrameState state) {
 511   switch (state) {
 512     case TrackRendererGetDecodedVideoFrameStateErrorNone: {
 513       return GetDecodedVideoFrameStatus::kSuccess;
 514     }
 515     case TrackRendererGetDecodedVideoFrameStateNoRemainingBufferError: {
 516       return GetDecodedVideoFrameStatus::kNoRemainingBuffer;
 517     }
 518     case TrackRendererGetDecodedVideoFrameStateNoFilledBufferError: {
 519       return GetDecodedVideoFrameStatus::kNoFilledBuffer;
 520     }
 521     case TrackRendererGetDecodedVideoFrameStateUnknownError: {
 522       return GetDecodedVideoFrameStatus::kUnknown;
 523     }
 524     default:
 525       LOG_ERROR("wrong state type");
 526       return GetDecodedVideoFrameStatus::kUnknown;
 527   }
 528 }
 529
 530 TrackRendererDisplayMode ConvertToTrackRendererDisplayMode(
 531     const DisplayMode& mode) {
 532   switch (mode) {
 533     case DisplayMode::kLetterBox: {
 534       return kTrackRendererDisplayModeLetterBox;
 535     }
 536     case DisplayMode::kOriginSize: {
 537       return kTrackRendererDisplayModeOriginSize;
 538     }
 539     case DisplayMode::kFullScreen: {
 540       return kTrackRendererDisplayModeFullScreen;
 541     }
 542     case DisplayMode::kCroppedFull: {
 543       return kTrackRendererDisplayModeCroppedFull;
 544     }
 545     case DisplayMode::kOriginOrLetter: {
 546       return kTrackRendererDisplayModeOriginOrLetter;
 547     }
 548     case DisplayMode::kDstRoi: {
 549       return kTrackRendererDisplayModeDstRoi;
 550     }
 551     case DisplayMode::kAutoAspectRatio: {
 552       return kTrackRendererDisplayModeAutoAspectRatio;
 553     }
 554     case DisplayMode::kMax: {
 555       return kTrackRendererDisplayModeDisplayMax;
 556     }
 557     default:
 558       LOG_ERROR("unknown displaymode");
 559       return kTrackRendererDisplayModeFullScreen;
 560   }
 561 }
 562
 563 TrackRendererDisplayRotate ConvertToTrackRendererDisplayRotate(
 564     const DisplayRotation& rotate) {
 565   switch (rotate) {
 566     case DisplayRotation::kNone: {
 567       return kTrackRendererDisplayRotateNone;
 568     }
 569     case DisplayRotation::kRotate90: {
 570       return kTrackRendererDisplayRotate90;
 571     }
 572     case DisplayRotation::kRotate180: {
 573       return kTrackRendererDisplayRotate180;
 574     }
 575     case DisplayRotation::kRotate270: {
 576       return kTrackRendererDisplayRotate270;
 577     }
 578     default:
 579       LOG_ERROR("unknown displayrotate");
 580       return kTrackRendererDisplayRotateNone;
 581   }
 582 }
 583
 584 TrackRendererDisplayType ConvertToTrackRendererDisplayType(
 585     const DisplayType& type) {
 586   switch (type) {
 587     case DisplayType::kNone: {
 588       return kTrackRendererDisplayTypeNone;
 589     }
 590     case DisplayType::kOverlay: {
 591       return kTrackRendererDisplayTypeOverlay;
 592     }
 593     case DisplayType::kEvas: {
 594       return kTrackRendererDisplayTypeEvas;
 595     }
 596     default:
 597       LOG_ERROR("unknown displaytype");
 598       return kTrackRendererDisplayTypeNone;
 599   }
 600 }
 601
 602 TrackRendererDrmType ConvertToTrackRendererDrmType(const drm::Type& drm_type) {
 603   switch (drm_type) {
 604     case drm::Type::kNone: {
 605       return kTrackRendererDrmTypeNone;
 606     }
 607     case drm::Type::kPlayready: {
 608       return kTrackRendererDrmTypePlayready;
 609     }
 610     case drm::Type::kMarlin: {
 611       return kTrackRendererDrmTypeMarlin;
 612     }
 613     case drm::Type::kVerimatrix: {
 614       return kTrackRendererDrmTypeVerimatrix;
 615     }
 616     case drm::Type::kWidevineClassic: {
 617       return kTrackRendererDrmTypeWidevineClassic;
 618     }
 619     case drm::Type::kSecuremedia: {
 620       return kTrackRendererDrmTypeSecuremedia;
 621     }
 622     case drm::Type::kSdrm: {
 623       return kTrackRendererDrmTypeSdrm;
 624     }
 625     case drm::Type::kWidevineCdm: {
 626       return kTrackRendererDrmTypeWidevineCdm;
 627     }
 628     case drm::Type::kClearkey: {
 629       return kTrackRendererDrmTypeClearkey;
 630     }
 631     case drm::Type::kMax: {
 632       return kTrackRendererDrmTypeDrmMax;
 633     }
 634     default:
 635       LOG_ERROR("unknown drmtype");
 636       return kTrackRendererDrmTypeNone;
 637   }
 638 }
 639
 640 TrackRendererStillMode ConvertToTrackRendererStillMode(
 641     const StillMode& still_mode) {
 642   switch (still_mode) {
 643     case StillMode::kNone: {
 644       return kTrackRendererStillModeNone;
 645     }
 646     case StillMode::kOff: {
 647       return kTrackRendererStillModeOff;
 648     }
 649     case StillMode::kOn: {
 650       return kTrackRendererStillModeOn;
 651     }
 652     default:
 653       LOG_ERROR("unknown stillmode");
 654       return kTrackRendererStillModeNone;
 655   }
 656 }
 657
 658 TrackRendererTrackType ConvertToTrackRendererTrackType(const TrackType& type) {
 659   switch (type) {
 660     case TrackType::kTrackTypeAudio: {
 661       return kTrackRendererTrackTypeAudio;
 662     }
 663     case TrackType::kTrackTypeVideo: {
 664       return kTrackRendererTrackTypeVideo;
 665     }
 666     case TrackType::kTrackTypeSubtitle: {
 667       return kTrackRendererTrackTypeSubtitle;
 668     }
 669     case TrackType::kTrackTypeMax: {
 670       return kTrackRendererTrackTypeMax;
 671     }
 672     default:
 673       LOG_ERROR("unknown tracktype");
 674       return kTrackRendererTrackTypeMax;
 675   }
 676 }
 677
 678 TrackRendererTrackType ConvertToTrackRendererTrackTypeFromStreamType(
 679     const StreamType& type) {
 680   switch (type) {
 681     case StreamType::kAudio: {
 682       return kTrackRendererTrackTypeAudio;
 683     }
 684     case StreamType::kVideo: {
 685       return kTrackRendererTrackTypeVideo;
 686     }
 687     case StreamType::kMax: {
 688       return kTrackRendererTrackTypeMax;
 689     }
 690     default:
 691       LOG_ERROR("unknown steamtype");
 692       return kTrackRendererTrackTypeMax;
 693   }
 694 }
 695
 696 #ifndef TRACKRENDERER_FEATURE_DEPRECATE_SUBTITLE_CB
 697 boost::any SetSubtitleAttrValue(const TrackRendererSubtitleAttr& attr) {
 698   boost::any any_value;
 699   switch (attr.type) {
 700     case kTrackRendererSubtitleAttrTypeRegionXPos:         // fall through
 701     case kTrackRendererSubtitleAttrTypeRegionYPos:         // fall through
 702     case kTrackRendererSubtitleAttrTypeRegionWidth:        // fall through
 703     case kTrackRendererSubtitleAttrTypeRegionHeight:       // fall through
 704     case kTrackRendererSubtitleAttrTypeWindowXPadding:     // fall through
 705     case kTrackRendererSubtitleAttrTypeWindowYPadding:     // fall through
 706     case kTrackRendererSubtitleAttrTypeWindowOpacity:      // fall through
 707     case kTrackRendererSubtitleAttrTypeWindowShowBg:       // fall through
 708     case kTrackRendererSubtitleAttrTypeFontSize:           // fall through
 709     case kTrackRendererSubtitleAttrTypeFontOpacity:        // fall through
 710     case kTrackRendererSubtitleAttrTypeFontBgOpacity:      // fall through
 711     case kTrackRendererSubtitleAttrTypeWebvttCueLine:      // fall through
 712     case kTrackRendererSubtitleAttrTypeWebvttCueSize:      // fall through
 713     case kTrackRendererSubtitleAttrTypeWebvttCuePosition:  // fall through
 714     case kTrackRendererSubtitleAttrTypeWebvttCueVertical: {
 715       if (attr.value.f) any_value = attr.value.f;
 716       break;
 717     }
 718     case kTrackRendererSubtitleAttrTypeWindowLeftMargin:      // fall through
 719     case kTrackRendererSubtitleAttrTypeWindowRightMargin:     // fall through
 720     case kTrackRendererSubtitleAttrTypeWindowTopMargin:       // fall through
 721     case kTrackRendererSubtitleAttrTypeWindowBottomMargin:    // fall through
 722     case kTrackRendererSubtitleAttrTypeWindowBgColor:         // fall through
 723     case kTrackRendererSubtitleAttrTypeFontWeight:            // fall through
 724     case kTrackRendererSubtitleAttrTypeFontStyle:             // fall through
 725     case kTrackRendererSubtitleAttrTypeFontColor:             // fall through
 726     case kTrackRendererSubtitleAttrTypeFontBgColor:           // fall through
 727     case kTrackRendererSubtitleAttrTypeFontTextOutlineColor:  // fall through
 728     case kTrackRendererSubtitleAttrTypeFontTextOutlineThickness:   // fall
 729                                                                    // through
 730     case kTrackRendererSubtitleAttrTypeFontTextOutlineBlurRadius:  // fall
 731                                                                    // through
 732     case kTrackRendererSubtitleAttrTypeFontVerticalAlign:    // fall through
 733     case kTrackRendererSubtitleAttrTypeFontHorizontalAlign:  // fall through
 734     case kTrackRendererSubtitleAttrTypeWebvttCueLineNum:     // fall through
 735     case kTrackRendererSubtitleAttrTypeWebvttCueLineAlign:   // fall through
 736     case kTrackRendererSubtitleAttrTypeWebvttCueAlign:       // fall through
 737     case kTrackRendererSubtitleAttrTypeWebvttCuePositionAlign: {
 738       if (attr.value.i32) any_value = attr.value.i32;
 739       break;
 740     }
 741     case kTrackRendererSubtitleAttrTypeFontFamily:  // fall through
 742     case kTrackRendererSubtitleAttrTypeRawSubtitle: {
 743       if (attr.value.str) any_value = std::string(attr.value.str);
 744       break;
 745     }
 746     case kTrackRendererSubtitleAttrTypeTimestamp:
 747     case kTrackRendererSubtitleAttrTypeExtsubIndex:
 748       break;
 749     default:
 750       LOG_ERROR("Unknown subtitle attr type");
 751   }
 752   return any_value;
 753 }
 754 #endif
 755
 756 BufferStatus ConvertToBufferStatus(const TrackRendererBufferStatus& status) {
 757   switch (status) {
 758     case kTrackRendererBufferStatusUnderrun: {
 759       return BufferStatus::kUnderrun;
 760     }
 761     case kTrackRendererBufferStatusOverrun: {
 762       return BufferStatus::kOverrun;
 763     }
 764   }
 765   LOG_ERROR("Unknown buffern status");
 766   return BufferStatus::kUnderrun;
 767 }
 768
 769 }  // namespace adapter_utils
 770
 771 }  // namespace plusplayer