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 TrackRendererDecodedVideoFrameBufferType ConvertToVideoFrameBufferType(
 479     const DecodedVideoFrameBufferType& type) {
 480   switch (type) {
 481     case DecodedVideoFrameBufferType::kCopy: {
 482       return kTrackRendererDecodedVideoFrameBufferCopy;
 483     }
 484     case DecodedVideoFrameBufferType::kReference: {
 485       return kTrackRendererDecodedVideoFrameBufferReference;
 486     }
 487     case DecodedVideoFrameBufferType::kScale: {
 488       return kTrackRendererDecodedVideoFrameBufferScale;
 489     }
 490     case DecodedVideoFrameBufferType::kNone: {
 491       return kTrackRendererDecodedVideoFrameBufferNone;
 492     }
 493     default:
 494       LOG_ERROR("wrong buffer type");
 495       return kTrackRendererDecodedVideoFrameBufferNone;
 496   }
 497 }
 498
 499 TrackRendererDisplayMode ConvertToTrackRendererDisplayMode(
 500     const DisplayMode& mode) {
 501   switch (mode) {
 502     case DisplayMode::kLetterBox: {
 503       return kTrackRendererDisplayModeLetterBox;
 504     }
 505     case DisplayMode::kOriginSize: {
 506       return kTrackRendererDisplayModeOriginSize;
 507     }
 508     case DisplayMode::kFullScreen: {
 509       return kTrackRendererDisplayModeFullScreen;
 510     }
 511     case DisplayMode::kCroppedFull: {
 512       return kTrackRendererDisplayModeCroppedFull;
 513     }
 514     case DisplayMode::kOriginOrLetter: {
 515       return kTrackRendererDisplayModeOriginOrLetter;
 516     }
 517     case DisplayMode::kDstRoi: {
 518       return kTrackRendererDisplayModeDstRoi;
 519     }
 520     case DisplayMode::kAutoAspectRatio: {
 521       return kTrackRendererDisplayModeAutoAspectRatio;
 522     }
 523     case DisplayMode::kMax: {
 524       return kTrackRendererDisplayModeDisplayMax;
 525     }
 526     default:
 527       LOG_ERROR("unknown displaymode");
 528       return kTrackRendererDisplayModeFullScreen;
 529   }
 530 }
 531
 532 TrackRendererDisplayRotate ConvertToTrackRendererDisplayRotate(
 533     const DisplayRotation& rotate) {
 534   switch (rotate) {
 535     case DisplayRotation::kNone: {
 536       return kTrackRendererDisplayRotateNone;
 537     }
 538     case DisplayRotation::kRotate90: {
 539       return kTrackRendererDisplayRotate90;
 540     }
 541     case DisplayRotation::kRotate180: {
 542       return kTrackRendererDisplayRotate180;
 543     }
 544     case DisplayRotation::kRotate270: {
 545       return kTrackRendererDisplayRotate270;
 546     }
 547     default:
 548       LOG_ERROR("unknown displayrotate");
 549       return kTrackRendererDisplayRotateNone;
 550   }
 551 }
 552
 553 TrackRendererDisplayType ConvertToTrackRendererDisplayType(
 554     const DisplayType& type) {
 555   switch (type) {
 556     case DisplayType::kNone: {
 557       return kTrackRendererDisplayTypeNone;
 558     }
 559     case DisplayType::kOverlay: {
 560       return kTrackRendererDisplayTypeOverlay;
 561     }
 562     case DisplayType::kEvas: {
 563       return kTrackRendererDisplayTypeEvas;
 564     }
 565     default:
 566       LOG_ERROR("unknown displaytype");
 567       return kTrackRendererDisplayTypeNone;
 568   }
 569 }
 570
 571 TrackRendererDrmType ConvertToTrackRendererDrmType(const drm::Type& drm_type) {
 572   switch (drm_type) {
 573     case drm::Type::kNone: {
 574       return kTrackRendererDrmTypeNone;
 575     }
 576     case drm::Type::kPlayready: {
 577       return kTrackRendererDrmTypePlayready;
 578     }
 579     case drm::Type::kMarlin: {
 580       return kTrackRendererDrmTypeMarlin;
 581     }
 582     case drm::Type::kVerimatrix: {
 583       return kTrackRendererDrmTypeVerimatrix;
 584     }
 585     case drm::Type::kWidevineClassic: {
 586       return kTrackRendererDrmTypeWidevineClassic;
 587     }
 588     case drm::Type::kSecuremedia: {
 589       return kTrackRendererDrmTypeSecuremedia;
 590     }
 591     case drm::Type::kSdrm: {
 592       return kTrackRendererDrmTypeSdrm;
 593     }
 594     case drm::Type::kWidevineCdm: {
 595       return kTrackRendererDrmTypeWidevineCdm;
 596     }
 597     case drm::Type::kClearkey: {
 598       return kTrackRendererDrmTypeClearkey;
 599     }
 600     case drm::Type::kMax: {
 601       return kTrackRendererDrmTypeDrmMax;
 602     }
 603     default:
 604       LOG_ERROR("unknown drmtype");
 605       return kTrackRendererDrmTypeNone;
 606   }
 607 }
 608
 609 TrackRendererStillMode ConvertToTrackRendererStillMode(
 610     const StillMode& still_mode) {
 611   switch (still_mode) {
 612     case StillMode::kNone: {
 613       return kTrackRendererStillModeNone;
 614     }
 615     case StillMode::kOff: {
 616       return kTrackRendererStillModeOff;
 617     }
 618     case StillMode::kOn: {
 619       return kTrackRendererStillModeOn;
 620     }
 621     default:
 622       LOG_ERROR("unknown stillmode");
 623       return kTrackRendererStillModeNone;
 624   }
 625 }
 626
 627 TrackRendererTrackType ConvertToTrackRendererTrackType(const TrackType& type) {
 628   switch (type) {
 629     case TrackType::kTrackTypeAudio: {
 630       return kTrackRendererTrackTypeAudio;
 631     }
 632     case TrackType::kTrackTypeVideo: {
 633       return kTrackRendererTrackTypeVideo;
 634     }
 635     case TrackType::kTrackTypeSubtitle: {
 636       return kTrackRendererTrackTypeSubtitle;
 637     }
 638     case TrackType::kTrackTypeMax: {
 639       return kTrackRendererTrackTypeMax;
 640     }
 641     default:
 642       LOG_ERROR("unknown tracktype");
 643       return kTrackRendererTrackTypeMax;
 644   }
 645 }
 646
 647 TrackRendererTrackType ConvertToTrackRendererTrackTypeFromStreamType(
 648     const StreamType& type) {
 649   switch (type) {
 650     case StreamType::kAudio: {
 651       return kTrackRendererTrackTypeAudio;
 652     }
 653     case StreamType::kVideo: {
 654       return kTrackRendererTrackTypeVideo;
 655     }
 656     case StreamType::kMax: {
 657       return kTrackRendererTrackTypeMax;
 658     }
 659     default:
 660       LOG_ERROR("unknown steamtype");
 661       return kTrackRendererTrackTypeMax;
 662   }
 663 }
 664
 665 #ifndef TRACKRENDERER_FEATURE_DEPRECATE_SUBTITLE_CB
 666 boost::any SetSubtitleAttrValue(const TrackRendererSubtitleAttr& attr) {
 667   boost::any any_value;
 668   switch (attr.type) {
 669     case kTrackRendererSubtitleAttrTypeRegionXPos:         // fall through
 670     case kTrackRendererSubtitleAttrTypeRegionYPos:         // fall through
 671     case kTrackRendererSubtitleAttrTypeRegionWidth:        // fall through
 672     case kTrackRendererSubtitleAttrTypeRegionHeight:       // fall through
 673     case kTrackRendererSubtitleAttrTypeWindowXPadding:     // fall through
 674     case kTrackRendererSubtitleAttrTypeWindowYPadding:     // fall through
 675     case kTrackRendererSubtitleAttrTypeWindowOpacity:      // fall through
 676     case kTrackRendererSubtitleAttrTypeWindowShowBg:       // fall through
 677     case kTrackRendererSubtitleAttrTypeFontSize:           // fall through
 678     case kTrackRendererSubtitleAttrTypeFontOpacity:        // fall through
 679     case kTrackRendererSubtitleAttrTypeFontBgOpacity:      // fall through
 680     case kTrackRendererSubtitleAttrTypeWebvttCueLine:      // fall through
 681     case kTrackRendererSubtitleAttrTypeWebvttCueSize:      // fall through
 682     case kTrackRendererSubtitleAttrTypeWebvttCuePosition:  // fall through
 683     case kTrackRendererSubtitleAttrTypeWebvttCueVertical: {
 684       if (attr.value.f) any_value = attr.value.f;
 685       break;
 686     }
 687     case kTrackRendererSubtitleAttrTypeWindowLeftMargin:      // fall through
 688     case kTrackRendererSubtitleAttrTypeWindowRightMargin:     // fall through
 689     case kTrackRendererSubtitleAttrTypeWindowTopMargin:       // fall through
 690     case kTrackRendererSubtitleAttrTypeWindowBottomMargin:    // fall through
 691     case kTrackRendererSubtitleAttrTypeWindowBgColor:         // fall through
 692     case kTrackRendererSubtitleAttrTypeFontWeight:            // fall through
 693     case kTrackRendererSubtitleAttrTypeFontStyle:             // fall through
 694     case kTrackRendererSubtitleAttrTypeFontColor:             // fall through
 695     case kTrackRendererSubtitleAttrTypeFontBgColor:           // fall through
 696     case kTrackRendererSubtitleAttrTypeFontTextOutlineColor:  // fall through
 697     case kTrackRendererSubtitleAttrTypeFontTextOutlineThickness:   // fall
 698                                                                    // through
 699     case kTrackRendererSubtitleAttrTypeFontTextOutlineBlurRadius:  // fall
 700                                                                    // through
 701     case kTrackRendererSubtitleAttrTypeFontVerticalAlign:    // fall through
 702     case kTrackRendererSubtitleAttrTypeFontHorizontalAlign:  // fall through
 703     case kTrackRendererSubtitleAttrTypeWebvttCueLineNum:     // fall through
 704     case kTrackRendererSubtitleAttrTypeWebvttCueLineAlign:   // fall through
 705     case kTrackRendererSubtitleAttrTypeWebvttCueAlign:       // fall through
 706     case kTrackRendererSubtitleAttrTypeWebvttCuePositionAlign: {
 707       if (attr.value.i32) any_value = attr.value.i32;
 708       break;
 709     }
 710     case kTrackRendererSubtitleAttrTypeFontFamily:  // fall through
 711     case kTrackRendererSubtitleAttrTypeRawSubtitle: {
 712       if (attr.value.str) any_value = std::string(attr.value.str);
 713       break;
 714     }
 715     case kTrackRendererSubtitleAttrTypeTimestamp:
 716     case kTrackRendererSubtitleAttrTypeExtsubIndex:
 717       break;
 718     default:
 719       LOG_ERROR("Unknown subtitle attr type");
 720   }
 721   return any_value;
 722 }
 723 #endif
 724
 725 BufferStatus ConvertToBufferStatus(const TrackRendererBufferStatus& status) {
 726   switch (status) {
 727     case kTrackRendererBufferStatusUnderrun: {
 728       return BufferStatus::kUnderrun;
 729     }
 730     case kTrackRendererBufferStatusOverrun: {
 731       return BufferStatus::kOverrun;
 732     }
 733   }
 734   LOG_ERROR("Unknown buffern status");
 735   return BufferStatus::kUnderrun;
 736 }
 737
 738 }  // namespace adapter_utils
 739
 740 }  // namespace plusplayer