dali-extension/video-player/ecore-wl2/tizen-video-player-ecore-wl2.cpp

   1 /*
   2  * Copyright (c) 2021 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 // CLASS HEADER
  19 #include <tizen-video-player.h>
  20
  21 // EXTERNAL INCLUDES
  22 #include <dali/devel-api/common/stage.h>
  23 #include <dali/devel-api/threading/mutex.h>
  24 #include <dali/integration-api/debug.h>
  25 #include <system_info.h>
  26
  27 // INTERNAL INCLUDES
  28
  29 // The plugin factories
  30 extern "C" DALI_EXPORT_API Dali::VideoPlayerPlugin* CreateVideoPlayerPlugin(Dali::Actor actor, Dali::VideoSyncMode syncMode)
  31 {
  32   return new Dali::Plugin::TizenVideoPlayer(actor, syncMode);
  33 }
  34
  35 extern "C" DALI_EXPORT_API void DestroyVideoPlayerPlugin(Dali::VideoPlayerPlugin* plugin)
  36 {
  37   if(plugin != NULL)
  38   {
  39     delete plugin;
  40   }
  41 }
  42
  43 namespace Dali
  44 {
  45 namespace Plugin
  46 {
  47 namespace
  48 {
  49 const int TIMER_INTERVAL(20);
  50
  51 static void MediaPacketVideoDecodedCb(media_packet_h packet, void* user_data)
  52 {
  53   TizenVideoPlayer* player = static_cast<TizenVideoPlayer*>(user_data);
  54
  55   if(player == NULL)
  56   {
  57     DALI_LOG_ERROR("Decoded callback got Null pointer as user_data.\n");
  58     return;
  59   }
  60
  61   player->PushPacket(packet);
  62 }
  63
  64 static GMainContext* GetTizenGlibContext()
  65 {
  66   static GMainContext* context = nullptr;
  67
  68   if(!context)
  69   {
  70     const char* env = getenv("TIZEN_GLIB_CONTEXT");
  71     if(env)
  72     {
  73       context = (GMainContext*)strtoul(env, nullptr, 10);
  74     }
  75   }
  76
  77   return context;
  78 }
  79
  80 static void EmitPlaybackFinishedSignal(void* user_data)
  81 {
  82   TizenVideoPlayer* player = static_cast<TizenVideoPlayer*>(user_data);
  83
  84   if(player == NULL)
  85   {
  86     DALI_LOG_ERROR("Decoded callback got Null pointer as user_data.\n");
  87     return;
  88   }
  89
  90   if(!player->mFinishedSignal.Empty())
  91   {
  92     DALI_LOG_ERROR("EmitPlaybackFinishedSignal.\n");
  93
  94     // This function is invoked on the main thread from MMFW.
  95     // So the FinishedSignal has to be posted to UIThread when UIThread is enabled.
  96     // If not, it causes an assertion in the timer.
  97     // The timer has to run on the same thread as the adaptor's
  98     GMainContext* context = GetTizenGlibContext();
  99     if(context)
 100     {
 101       GSource* source = g_idle_source_new();
 102       g_source_set_callback(
 103         source,
 104         [](gpointer userData) -> gboolean
 105         {
 106           auto* player = static_cast<TizenVideoPlayer*>(userData);
 107           player->mFinishedSignal.Emit();
 108           player->Stop();
 109           return G_SOURCE_REMOVE;
 110         },
 111         player,
 112         nullptr);
 113       g_source_attach(source, context);
 114       g_source_unref(source);
 115     }
 116     else
 117     {
 118       player->mFinishedSignal.Emit();
 119       player->Stop();
 120     }
 121   }
 122 }
 123
 124 // ToDo: VD player_set_play_position() doesn't work when callback pointer is NULL.
 125 // We should check whether this callback is needed in platform.
 126 static void PlayerSeekCompletedCb(void* data)
 127 {
 128 }
 129
 130 int LogPlayerError(int error)
 131 {
 132   int ret = 0;
 133   if(error != PLAYER_ERROR_NONE)
 134   {
 135     ret = error;
 136     switch(error)
 137     {
 138       case PLAYER_ERROR_OUT_OF_MEMORY:
 139       {
 140         DALI_LOG_ERROR("Player error: Out of memory\n");
 141       }
 142       break;
 143       case PLAYER_ERROR_INVALID_PARAMETER:
 144       {
 145         DALI_LOG_ERROR("Player error: Invalid parameter\n");
 146       }
 147       break;
 148       case PLAYER_ERROR_NO_SUCH_FILE:
 149       {
 150         DALI_LOG_ERROR("Player error: No such file\n");
 151       }
 152       break;
 153       case PLAYER_ERROR_INVALID_OPERATION:
 154       {
 155         DALI_LOG_ERROR("Player error: Invalid operation\n");
 156       }
 157       break;
 158       case PLAYER_ERROR_FILE_NO_SPACE_ON_DEVICE:
 159       {
 160         DALI_LOG_ERROR("Player error: No space on device\n");
 161       }
 162       break;
 163       case PLAYER_ERROR_FEATURE_NOT_SUPPORTED_ON_DEVICE:
 164       {
 165         DALI_LOG_ERROR("Player error: Not supported feature on device\n");
 166       }
 167       break;
 168       case PLAYER_ERROR_SEEK_FAILED:
 169       {
 170         DALI_LOG_ERROR("Player error: Seek failed\n");
 171       }
 172       break;
 173       case PLAYER_ERROR_INVALID_STATE:
 174       {
 175         DALI_LOG_ERROR("Player error: Invalid state\n");
 176       }
 177       break;
 178       case PLAYER_ERROR_NOT_SUPPORTED_FILE:
 179       {
 180         DALI_LOG_ERROR("Player error: Not supported file\n");
 181       }
 182       break;
 183       case PLAYER_ERROR_INVALID_URI:
 184       {
 185         DALI_LOG_ERROR("Player error: Invalid uri\n");
 186       }
 187       break;
 188       case PLAYER_ERROR_SOUND_POLICY:
 189       {
 190         DALI_LOG_ERROR("Player error: Sound policy\n");
 191       }
 192       break;
 193       case PLAYER_ERROR_CONNECTION_FAILED:
 194       {
 195         DALI_LOG_ERROR("Player error: Connection failed\n");
 196       }
 197       break;
 198       case PLAYER_ERROR_VIDEO_CAPTURE_FAILED:
 199       {
 200         DALI_LOG_ERROR("Player error: Video capture failed\n");
 201       }
 202       break;
 203       case PLAYER_ERROR_DRM_EXPIRED:
 204       {
 205         DALI_LOG_ERROR("Player error: DRM expired\n");
 206       }
 207       break;
 208       case PLAYER_ERROR_DRM_NO_LICENSE:
 209       {
 210         DALI_LOG_ERROR("Player error: No license\n");
 211       }
 212       break;
 213       case PLAYER_ERROR_DRM_FUTURE_USE:
 214       {
 215         DALI_LOG_ERROR("Player error: License for future use\n");
 216       }
 217       break;
 218       case PLAYER_ERROR_DRM_NOT_PERMITTED:
 219       {
 220         DALI_LOG_ERROR("Player error: Format not permitted\n");
 221       }
 222       break;
 223       case PLAYER_ERROR_RESOURCE_LIMIT:
 224       {
 225         DALI_LOG_ERROR("Player error: Resource limit\n");
 226       }
 227       break;
 228       case PLAYER_ERROR_PERMISSION_DENIED:
 229       {
 230         DALI_LOG_ERROR("Player error: Permission denied\n");
 231       }
 232       break;
 233       case PLAYER_ERROR_SERVICE_DISCONNECTED:
 234       {
 235         DALI_LOG_ERROR("Player error: Service disconnected\n");
 236       }
 237       break;
 238       case PLAYER_ERROR_BUFFER_SPACE:
 239       {
 240         DALI_LOG_ERROR("Player error: Buffer space\n");
 241       }
 242       break;
 243       case PLAYER_ERROR_NOT_SUPPORTED_VIDEO_CODEC:
 244       {
 245         DALI_LOG_ERROR("Player error: The target should not support the codec type\n");
 246       }
 247       break;
 248       default:
 249       {
 250         DALI_LOG_ERROR("Player error: Unknown error code ( %d ) \n", error);
 251       }
 252       break;
 253     }
 254   }
 255   return ret;
 256 }
 257
 258 const char* const VIDEO_PLAYER_SIZE_NAME("videoPlayerSize");
 259
 260 struct VideoPlayerSyncConstraint
 261 {
 262 public:
 263   VideoPlayerSyncConstraint(Ecore_Wl2_Subsurface* ecoreSubVideoWindow, int screenWidth, int screenHeight)
 264   {
 265     mEcoreSubVideoWindow = ecoreSubVideoWindow;
 266     mHalfScreenWidth     = static_cast<float>(screenWidth) / 2;
 267     mHalfScreenHeight    = static_cast<float>(screenHeight) / 2;
 268   }
 269
 270   void operator()(Vector3& current, const PropertyInputContainer& inputs)
 271   {
 272     const Vector3& size          = inputs[0]->GetVector3();
 273     const Vector3& worldScale    = inputs[1]->GetVector3();
 274     const Vector3& worldPosition = inputs[2]->GetVector3();
 275
 276     Vector3 actorSize = size * worldScale;
 277     Vector2 screenPosition(mHalfScreenWidth + worldPosition.x, mHalfScreenHeight + worldPosition.y);
 278
 279     DisplayArea area;
 280     area.x      = screenPosition.x - actorSize.x / 2;
 281     area.y      = screenPosition.y - actorSize.y / 2;
 282     area.width  = actorSize.x;
 283     area.height = actorSize.y;
 284
 285     if(mEcoreSubVideoWindow)
 286     {
 287       ecore_wl2_subsurface_video_surface_destination_set(mEcoreSubVideoWindow, area.x, area.y, area.width, area.height);
 288     }
 289   }
 290
 291 private:
 292   Ecore_Wl2_Subsurface* mEcoreSubVideoWindow;
 293   float                 mHalfScreenWidth;
 294   float                 mHalfScreenHeight;
 295 };
 296
 297 /**
 298  * @brief Whether set play positoin accurately or not.
 299  *  If true, we set play position to the nearest frame position. but this might be considerably slow, accurately.
 300  *  If false, we set play position to the nearest key frame position. this might be faster but less accurate.
 301  * see player_set_play_position()
 302  */
 303 constexpr bool ACCURATE_PLAY_POSITION_SET = true;
 304
 305 } // unnamed namespace
 306
 307 TizenVideoPlayer::TizenVideoPlayer(Dali::Actor actor, Dali::VideoSyncMode syncMode)
 308 : mUrl(),
 309   mPlayer(NULL),
 310   mPlayerState(PLAYER_STATE_NONE),
 311   mTbmSurface(NULL),
 312   mPacket(NULL),
 313   mNativeImageSourcePtr(NULL),
 314   mTimer(),
 315   mBackgroundColor(Dali::Vector4(1.0f, 1.0f, 1.0f, 0.0f)),
 316   mTargetType(NATIVE_IMAGE),
 317   mPacketMutex(),
 318   mPacketList(),
 319   mStreamInfo(NULL),
 320   mStreamType(SOUND_STREAM_TYPE_MEDIA),
 321   mCodecType(PLAYER_VIDEO_CODEC_TYPE_EX_DEFAULT),
 322   mEcoreWlWindow(nullptr),
 323   mEcoreSubVideoWindow(nullptr),
 324   mSyncActor(actor),
 325   mVideoSizePropertyIndex(Property::INVALID_INDEX),
 326   mSyncMode(syncMode),
 327   mIsInitForSyncMode(false)
 328 {
 329 }
 330
 331 TizenVideoPlayer::~TizenVideoPlayer()
 332 {
 333   DestroyConstraint();
 334   if(mEcoreSubVideoWindow)
 335   {
 336     ecore_wl2_subsurface_del(mEcoreSubVideoWindow);
 337     mEcoreSubVideoWindow = nullptr;
 338   }
 339
 340   DestroyPlayer();
 341 }
 342
 343 void TizenVideoPlayer::GetPlayerState(player_state_e* state) const
 344 {
 345   if(mPlayer != NULL && player_get_state(mPlayer, state) != PLAYER_ERROR_NONE)
 346   {
 347     DALI_LOG_ERROR("player_get_state error: Invalid parameter\n");
 348     *state = PLAYER_STATE_NONE;
 349   }
 350 }
 351
 352 void TizenVideoPlayer::SetUrl(const std::string& url)
 353 {
 354   int ret = 0;
 355   if(mUrl != url)
 356   {
 357     int error = PLAYER_ERROR_NONE;
 358
 359     mUrl = url;
 360
 361     GetPlayerState(&mPlayerState);
 362
 363     if(mPlayerState != PLAYER_STATE_NONE && mPlayerState != PLAYER_STATE_IDLE)
 364     {
 365       if(mNativeImageSourcePtr)
 366       {
 367         error = player_unset_media_packet_video_frame_decoded_cb(mPlayer);
 368         ret   = LogPlayerError(error);
 369         if(ret)
 370         {
 371           DALI_LOG_ERROR("SetUrl, player_unset_media_packet_video_frame_decoded_cb() is failed\n");
 372         }
 373       }
 374       Stop();
 375
 376       error = player_unprepare(mPlayer);
 377       ret   = LogPlayerError(error);
 378       if(ret)
 379       {
 380         DALI_LOG_ERROR("SetUrl, player_unprepare() is failed\n");
 381       }
 382
 383       if(mNativeImageSourcePtr)
 384       {
 385         error = player_set_media_packet_video_frame_decoded_cb(mPlayer, MediaPacketVideoDecodedCb, this);
 386         ret   = LogPlayerError(error);
 387         if(ret)
 388         {
 389           DALI_LOG_ERROR("SetUrl, player_set_media_packet_video_frame_decoded_cb() is failed\n");
 390         }
 391       }
 392       else
 393       {
 394         int                width, height;
 395         Ecore_Wl2_Display* wl2_display = ecore_wl2_connected_display_get(NULL);
 396         ecore_wl2_display_screen_size_get(wl2_display, &width, &height);
 397
 398         if(mSyncMode == Dali::VideoSyncMode::ENABLED)
 399         {
 400           if(mIsInitForSyncMode)
 401           {
 402             InitializeEnableSyncMode(mEcoreWlWindow);
 403           }
 404           else
 405           {
 406             if(!ecore_wl2_subsurface_video_surface_destination_set(mEcoreSubVideoWindow, 0, 0, width, height))
 407             {
 408               DALI_LOG_ERROR("SetUrl, ecore_wl2_subsurface_video_surface_destination_set() is failed\n");
 409             }
 410           }
 411         }
 412         else
 413         {
 414           error = player_set_ecore_wl_display(mPlayer, PLAYER_DISPLAY_TYPE_OVERLAY, mEcoreWlWindow, 0, 0, width, height);
 415           ret   = LogPlayerError(error);
 416           if(ret)
 417           {
 418             DALI_LOG_ERROR("SetUrl, player_set_ecore_wl_display() is failed\n");
 419           }
 420         }
 421       }
 422       GetPlayerState(&mPlayerState);
 423       ret = LogPlayerError(error);
 424       if(ret)
 425       {
 426         DALI_LOG_ERROR("SetUrl, GetPlayerState() is failed\n");
 427       }
 428     }
 429
 430     if(mPlayerState == PLAYER_STATE_IDLE)
 431     {
 432       error = player_set_uri(mPlayer, mUrl.c_str());
 433       ret   = LogPlayerError(error);
 434       if(ret)
 435       {
 436         DALI_LOG_ERROR("SetUrl, player_set_uri() is failed\n");
 437       }
 438
 439       error = player_prepare(mPlayer);
 440       ret   = LogPlayerError(error);
 441       if(ret)
 442       {
 443         DALI_LOG_ERROR("SetUrl, player_prepare() is failed\n");
 444       }
 445     }
 446   }
 447 }
 448
 449 std::string TizenVideoPlayer::GetUrl()
 450 {
 451   return mUrl;
 452 }
 453
 454 void TizenVideoPlayer::SetRenderingTarget(Any target)
 455 {
 456   DestroyPlayer();
 457
 458   mNativeImageSourcePtr = NULL;
 459
 460   if(target.GetType() == typeid(Dali::NativeImageSourcePtr))
 461   {
 462     if(mSyncMode == Dali::VideoSyncMode::ENABLED)
 463     {
 464       DestroyConstraint();
 465     }
 466     mTargetType = TizenVideoPlayer::NATIVE_IMAGE;
 467
 468     Dali::NativeImageSourcePtr nativeImageSourcePtr = AnyCast<Dali::NativeImageSourcePtr>(target);
 469
 470     InitializeTextureStreamMode(nativeImageSourcePtr);
 471   }
 472   else if(target.GetType() == typeid(Ecore_Wl2_Window*))
 473   {
 474     mTargetType = TizenVideoPlayer::WINDOW_SURFACE;
 475
 476     InitializeUnderlayMode(Dali::AnyCast<Ecore_Wl2_Window*>(target));
 477
 478     if(mSyncMode == Dali::VideoSyncMode::ENABLED)
 479     {
 480       CreateConstraint();
 481     }
 482   }
 483   else
 484   {
 485     DALI_LOG_ERROR("SetRenderingTarget, Video rendering target is unknown\n");
 486   }
 487 }
 488
 489 void TizenVideoPlayer::SetLooping(bool looping)
 490 {
 491   GetPlayerState(&mPlayerState);
 492
 493   if(mPlayerState != PLAYER_STATE_NONE)
 494   {
 495     int error = player_set_looping(mPlayer, looping);
 496     int ret   = LogPlayerError(error);
 497     if(ret)
 498     {
 499       DALI_LOG_ERROR("SetLooping, player_set_looping() is failed\n");
 500     }
 501   }
 502 }
 503
 504 bool TizenVideoPlayer::IsLooping()
 505 {
 506   GetPlayerState(&mPlayerState);
 507
 508   bool looping = false;
 509   if(mPlayerState != PLAYER_STATE_NONE)
 510   {
 511     int error = player_is_looping(mPlayer, &looping);
 512     int ret   = LogPlayerError(error);
 513     if(ret)
 514     {
 515       DALI_LOG_ERROR("IsLooping, player_is_looping() is failed\n");
 516     }
 517   }
 518
 519   return looping;
 520 }
 521
 522 void TizenVideoPlayer::Play()
 523 {
 524   GetPlayerState(&mPlayerState);
 525
 526   if(mPlayerState == PLAYER_STATE_READY || mPlayerState == PLAYER_STATE_PAUSED)
 527   {
 528     if(mNativeImageSourcePtr && mTimer)
 529     {
 530       mTimer.Start();
 531     }
 532
 533     int error = player_start(mPlayer);
 534     int ret   = LogPlayerError(error);
 535     if(ret)
 536     {
 537       DALI_LOG_ERROR("Play, player_start() is failed\n");
 538     }
 539   }
 540 }
 541
 542 void TizenVideoPlayer::Pause()
 543 {
 544   GetPlayerState(&mPlayerState);
 545   int ret = 0;
 546   if(mPlayerState == PLAYER_STATE_PLAYING)
 547   {
 548     int error = player_pause(mPlayer);
 549     ret       = LogPlayerError(error);
 550     if(ret)
 551     {
 552       DALI_LOG_ERROR("Pause, player_pause() is failed\n");
 553     }
 554
 555     if(mNativeImageSourcePtr && mTimer)
 556     {
 557       mTimer.Stop();
 558       DestroyPackets();
 559     }
 560   }
 561 }
 562
 563 void TizenVideoPlayer::Stop()
 564 {
 565   GetPlayerState(&mPlayerState);
 566
 567   if(mPlayerState == PLAYER_STATE_PLAYING || mPlayerState == PLAYER_STATE_PAUSED)
 568   {
 569     int error = player_stop(mPlayer);
 570     int ret   = LogPlayerError(error);
 571     if(ret)
 572     {
 573       DALI_LOG_ERROR("Stop, player_stop() is failed\n");
 574     }
 575
 576     if(mNativeImageSourcePtr && mTimer)
 577     {
 578       mTimer.Stop();
 579       DestroyPackets();
 580     }
 581   }
 582 }
 583
 584 void TizenVideoPlayer::SetMute(bool muted)
 585 {
 586   GetPlayerState(&mPlayerState);
 587
 588   if(mPlayerState == PLAYER_STATE_IDLE ||
 589      mPlayerState == PLAYER_STATE_READY ||
 590      mPlayerState == PLAYER_STATE_PLAYING ||
 591      mPlayerState == PLAYER_STATE_PAUSED)
 592   {
 593     int error = player_set_mute(mPlayer, muted);
 594     int ret   = LogPlayerError(error);
 595     if(ret)
 596     {
 597       DALI_LOG_ERROR("SetMute, player_set_mute() is failed\n");
 598     }
 599   }
 600 }
 601
 602 bool TizenVideoPlayer::IsMuted()
 603 {
 604   GetPlayerState(&mPlayerState);
 605   bool muted = false;
 606
 607   if(mPlayerState == PLAYER_STATE_IDLE ||
 608      mPlayerState == PLAYER_STATE_READY ||
 609      mPlayerState == PLAYER_STATE_PLAYING ||
 610      mPlayerState == PLAYER_STATE_PAUSED)
 611   {
 612     int error = player_is_muted(mPlayer, &muted);
 613     int ret   = LogPlayerError(error);
 614     if(ret)
 615     {
 616       DALI_LOG_ERROR("IsMuted, player_is_muted() is failed\n");
 617     }
 618   }
 619
 620   return muted;
 621 }
 622
 623 void TizenVideoPlayer::SetVolume(float left, float right)
 624 {
 625   GetPlayerState(&mPlayerState);
 626
 627   int error = player_set_volume(mPlayer, left, right);
 628   int ret   = LogPlayerError(error);
 629   if(ret)
 630   {
 631     DALI_LOG_ERROR("SetVolume, player_set_volume() is failed\n");
 632   }
 633 }
 634
 635 void TizenVideoPlayer::GetVolume(float& left, float& right)
 636 {
 637   GetPlayerState(&mPlayerState);
 638
 639   int error = player_get_volume(mPlayer, &left, &right);
 640   int ret   = LogPlayerError(error);
 641   if(ret)
 642   {
 643     DALI_LOG_ERROR("GetVolume, player_get_volume() is failed\n");
 644   }
 645 }
 646
 647 void TizenVideoPlayer::SetPlayPosition(int millisecond)
 648 {
 649   int error;
 650   int ret = 0;
 651
 652   GetPlayerState(&mPlayerState);
 653
 654   if(mPlayerState == PLAYER_STATE_IDLE)
 655   {
 656     error = player_prepare(mPlayer);
 657     ret   = LogPlayerError(error);
 658     if(ret)
 659     {
 660       DALI_LOG_ERROR("SetPlayPosition, player_prepare() is failed\n");
 661     }
 662
 663     GetPlayerState(&mPlayerState); // Check the status again.
 664   }
 665
 666   if(mPlayerState == PLAYER_STATE_READY ||
 667      mPlayerState == PLAYER_STATE_PLAYING ||
 668      mPlayerState == PLAYER_STATE_PAUSED)
 669   {
 670     error = player_set_play_position(mPlayer, millisecond, ACCURATE_PLAY_POSITION_SET, PlayerSeekCompletedCb, NULL);
 671     ret   = LogPlayerError(error);
 672     if(ret)
 673     {
 674       DALI_LOG_ERROR("SetPlayPosition, player_set_play_position() is failed\n");
 675     }
 676   }
 677 }
 678
 679 int TizenVideoPlayer::GetPlayPosition()
 680 {
 681   int error;
 682   int millisecond = 0;
 683
 684   GetPlayerState(&mPlayerState);
 685
 686   if(mPlayerState == PLAYER_STATE_IDLE ||
 687      mPlayerState == PLAYER_STATE_READY ||
 688      mPlayerState == PLAYER_STATE_PLAYING ||
 689      mPlayerState == PLAYER_STATE_PAUSED)
 690   {
 691     error   = player_get_play_position(mPlayer, &millisecond);
 692     int ret = LogPlayerError(error);
 693     if(ret)
 694     {
 695       DALI_LOG_ERROR("GetPlayPosition, player_get_play_position() is failed\n");
 696     }
 697   }
 698
 699   return millisecond;
 700 }
 701
 702 void TizenVideoPlayer::SetDisplayRotation(Dali::VideoPlayerPlugin::DisplayRotation rotation)
 703 {
 704   if(mNativeImageSourcePtr)
 705   {
 706     DALI_LOG_ERROR("SetDisplayRotation is only for window rendering target.\n");
 707     return;
 708   }
 709
 710   int error;
 711   if(mPlayerState != PLAYER_STATE_NONE)
 712   {
 713     error   = player_set_display_rotation(mPlayer, static_cast<player_display_rotation_e>(rotation));
 714     int ret = LogPlayerError(error);
 715     if(ret)
 716     {
 717       DALI_LOG_ERROR("SetDisplayRotation, player_set_display_rotation() is failed\n");
 718     }
 719   }
 720 }
 721
 722 Dali::VideoPlayerPlugin::DisplayRotation TizenVideoPlayer::GetDisplayRotation()
 723 {
 724   if(mNativeImageSourcePtr)
 725   {
 726     DALI_LOG_ERROR("GetDisplayRotation is only for window rendering target.\n");
 727     return Dali::VideoPlayerPlugin::ROTATION_NONE;
 728   }
 729
 730   int                       error;
 731   player_display_rotation_e rotation = PLAYER_DISPLAY_ROTATION_NONE;
 732   if(mPlayerState != PLAYER_STATE_NONE)
 733   {
 734     error   = player_get_display_rotation(mPlayer, &rotation);
 735     int ret = LogPlayerError(error);
 736     if(ret)
 737     {
 738       DALI_LOG_ERROR("GetDisplayRotation, player_get_display_rotation() is failed\n");
 739     }
 740   }
 741   return static_cast<Dali::VideoPlayerPlugin::DisplayRotation>(rotation);
 742 }
 743
 744 Dali::VideoPlayerPlugin::VideoPlayerSignalType& TizenVideoPlayer::FinishedSignal()
 745 {
 746   return mFinishedSignal;
 747 }
 748
 749 void TizenVideoPlayer::InitializeTextureStreamMode(Dali::NativeImageSourcePtr nativeImageSourcePtr)
 750 {
 751   int error;
 752   int ret = 0;
 753
 754   mNativeImageSourcePtr = nativeImageSourcePtr;
 755
 756   if(mPlayerState == PLAYER_STATE_NONE)
 757   {
 758     error = player_create(&mPlayer);
 759     ret   = LogPlayerError(error);
 760     if(ret)
 761     {
 762       DALI_LOG_ERROR("InitializeTextureStreamMode, player_create() is failed\n");
 763     }
 764   }
 765
 766   GetPlayerState(&mPlayerState);
 767
 768   if(mPlayerState == PLAYER_STATE_IDLE)
 769   {
 770     error = player_set_completed_cb(mPlayer, EmitPlaybackFinishedSignal, this);
 771     ret   = LogPlayerError(error);
 772     if(ret)
 773     {
 774       DALI_LOG_ERROR("InitializeTextureStreamMode, player_set_completed_cb() is failed\n");
 775     }
 776
 777     error = player_set_media_packet_video_frame_decoded_cb(mPlayer, MediaPacketVideoDecodedCb, this);
 778     ret   = LogPlayerError(error);
 779     if(ret)
 780     {
 781       DALI_LOG_ERROR("InitializeTextureStreamMode, player_set_media_packet_video_frame_decoded_cb() is failed\n");
 782     }
 783
 784     error = sound_manager_create_stream_information(mStreamType, NULL, NULL, &mStreamInfo);
 785     ret   = LogPlayerError(error);
 786     if(ret)
 787     {
 788       DALI_LOG_ERROR("InitializeTextureStreamMode, sound_manager_create_stream_information() is failed\n");
 789     }
 790
 791     error = player_set_sound_stream_info(mPlayer, mStreamInfo);
 792     ret   = LogPlayerError(error);
 793     if(ret)
 794     {
 795       DALI_LOG_ERROR("InitializeTextureStreamMode, player_set_sound_stream_info() is failed\n");
 796     }
 797
 798     error = player_set_display_mode(mPlayer, PLAYER_DISPLAY_MODE_FULL_SCREEN);
 799     ret   = LogPlayerError(error);
 800     if(ret)
 801     {
 802       DALI_LOG_ERROR("InitializeTextureStreamMode, player_set_display_mode() is failed\n");
 803     }
 804
 805     error = player_set_display(mPlayer, PLAYER_DISPLAY_TYPE_NONE, NULL);
 806     ret   = LogPlayerError(error);
 807     if(ret)
 808     {
 809       DALI_LOG_ERROR("InitializeTextureStreamMode, player_set_display() is failed\n");
 810     }
 811
 812     error = player_set_video_codec_type_ex(mPlayer, mCodecType);
 813     ret   = LogPlayerError(error);
 814     if(ret)
 815     {
 816       DALI_LOG_ERROR("InitializeTextureStreamMode, player_set_video_codec_type_ex() is failed\n");
 817     }
 818     error = player_set_display_visible(mPlayer, true);
 819     ret   = LogPlayerError(error);
 820     if(ret)
 821     {
 822       DALI_LOG_ERROR("InitializeTextureStreamMode, player_set_display_visible() is failed\n");
 823     }
 824
 825     mTimer = Dali::Timer::New(TIMER_INTERVAL);
 826     mTimer.TickSignal().Connect(this, &TizenVideoPlayer::Update);
 827   }
 828 }
 829
 830 void TizenVideoPlayer::InitializeEnableSyncMode(Ecore_Wl2_Window* ecoreWlWindow)
 831 {
 832   int error;
 833   int ret = 0;
 834
 835   if(mEcoreWlWindow != ecoreWlWindow)
 836   {
 837     mEcoreWlWindow = ecoreWlWindow;
 838     // check previous video subsurface and destroy
 839     if(mEcoreSubVideoWindow)
 840     {
 841       ecore_wl2_subsurface_del(mEcoreSubVideoWindow);
 842     }
 843
 844     // Crate ecore_wl2 sursurface
 845     mEcoreSubVideoWindow = ecore_wl2_subsurface_new(mEcoreWlWindow);
 846     if(!mEcoreSubVideoWindow)
 847     {
 848       DALI_LOG_ERROR("InitializeEnableSyncMode, ecore_wl2_subsurface_new() is failed\n");
 849       return;
 850     }
 851
 852     // ecore_wl2_subsurface_video_surface_prepare
 853     if(!ecore_wl2_subsurface_video_surface_prepare(mEcoreSubVideoWindow))
 854     {
 855       ecore_wl2_subsurface_del(mEcoreSubVideoWindow);
 856       DALI_LOG_ERROR("InitializeEnableSyncMode, : ecore_wl2_subsurface_video_surface_prepare() is failed\n");
 857       return;
 858     }
 859
 860     DALI_LOG_RELEASE_INFO("InitializeEnableSyncMode, desync VideoPlayer\n");
 861     ecore_wl2_subsurface_sync_set(mEcoreSubVideoWindow, EINA_FALSE);
 862   }
 863
 864   if(mPlayerState == PLAYER_STATE_NONE)
 865   {
 866     error = player_create(&mPlayer);
 867     ret   = LogPlayerError(error);
 868     if(ret)
 869     {
 870       DALI_LOG_ERROR("InitializeEnableSyncMode, player_create() is failed\n");
 871     }
 872   }
 873
 874   GetPlayerState(&mPlayerState);
 875   if(mPlayerState == PLAYER_STATE_IDLE)
 876   {
 877     error = player_set_completed_cb(mPlayer, EmitPlaybackFinishedSignal, this);
 878     ret   = LogPlayerError(error);
 879     if(ret)
 880     {
 881       DALI_LOG_ERROR("InitializeEnableSyncMode, player_set_completed_cb() is failed\n");
 882     }
 883
 884     error = sound_manager_create_stream_information(mStreamType, NULL, NULL, &mStreamInfo);
 885     ret   = LogPlayerError(error);
 886     if(ret)
 887     {
 888       DALI_LOG_ERROR("InitializeEnableSyncMode, sound_manager_create_stream_information() is failed\n");
 889     }
 890
 891     error = player_set_sound_stream_info(mPlayer, mStreamInfo);
 892     ret   = LogPlayerError(error);
 893     if(ret)
 894     {
 895       DALI_LOG_ERROR("InitializeEnableSyncMode, player_set_sound_stream_info() is failed\n");
 896     }
 897
 898     error = player_set_video_codec_type_ex(mPlayer, mCodecType);
 899     ret   = LogPlayerError(error);
 900     if(ret)
 901     {
 902       DALI_LOG_ERROR("InitializeEnableSyncMode, player_set_video_codec_type_ex() is failed\n");
 903     }
 904
 905     int                width, height;
 906     Ecore_Wl2_Display* wl2_display = ecore_wl2_connected_display_get(NULL);
 907     ecore_wl2_display_screen_size_get(wl2_display, &width, &height);
 908     ecore_wl2_window_alpha_set(mEcoreWlWindow, false);
 909
 910     if(!ecore_wl2_subsurface_video_surface_destination_set(mEcoreSubVideoWindow, 0, 0, width, height))
 911     {
 912       DALI_LOG_ERROR("InitializeEnableSyncMode, ecore_wl2_subsurface_video_surface_destination_set() is failed\n");
 913     }
 914     error = player_set_display(mPlayer, PLAYER_DISPLAY_TYPE_OVERLAY, mEcoreWlWindow);
 915     ret   = LogPlayerError(error);
 916     if(ret)
 917     {
 918       DALI_LOG_ERROR("InitializeEnableSyncMode, player_set_display() is failed\n");
 919     }
 920
 921     mIsInitForSyncMode = true;
 922   }
 923 }
 924
 925 void TizenVideoPlayer::InitializeUnderlayMode(Ecore_Wl2_Window* ecoreWlWindow)
 926 {
 927   int error;
 928   int ret = 0;
 929
 930   if(mSyncMode == Dali::VideoSyncMode::ENABLED)
 931   {
 932     DALI_LOG_RELEASE_INFO("InitializeUnderlayMode, \n");
 933     InitializeEnableSyncMode(ecoreWlWindow);
 934     return;
 935   }
 936
 937   mEcoreWlWindow = ecoreWlWindow;
 938
 939   if(mPlayerState == PLAYER_STATE_NONE)
 940   {
 941     error = player_create(&mPlayer);
 942     ret   = LogPlayerError(error);
 943     if(ret)
 944     {
 945       DALI_LOG_ERROR("InitializeUnderlayMode, player_create() is failed\n");
 946     }
 947   }
 948
 949   GetPlayerState(&mPlayerState);
 950   if(mPlayerState == PLAYER_STATE_IDLE)
 951   {
 952     error = player_set_completed_cb(mPlayer, EmitPlaybackFinishedSignal, this);
 953     ret   = LogPlayerError(error);
 954     if(ret)
 955     {
 956       DALI_LOG_ERROR("InitializeUnderlayMode, player_set_completed_cb() is failed\n");
 957     }
 958
 959     error = sound_manager_create_stream_information(mStreamType, NULL, NULL, &mStreamInfo);
 960     ret   = LogPlayerError(error);
 961     if(ret)
 962     {
 963       DALI_LOG_ERROR("InitializeUnderlayMode, sound_manager_create_stream_information() is failed\n");
 964     }
 965
 966     error = player_set_sound_stream_info(mPlayer, mStreamInfo);
 967     ret   = LogPlayerError(error);
 968     if(ret)
 969     {
 970       DALI_LOG_ERROR("InitializeUnderlayMode, player_set_sound_stream_info() is failed\n");
 971     }
 972
 973     error = player_set_video_codec_type_ex(mPlayer, mCodecType);
 974     ret   = LogPlayerError(error);
 975     if(ret)
 976     {
 977       DALI_LOG_ERROR("InitializeUnderlayMode, player_set_video_codec_type_ex() is failed\n");
 978     }
 979
 980     int                width, height;
 981     Ecore_Wl2_Display* wl2_display = ecore_wl2_connected_display_get(NULL);
 982     ecore_wl2_display_screen_size_get(wl2_display, &width, &height);
 983     ecore_wl2_window_alpha_set(mEcoreWlWindow, false);
 984
 985     error = player_set_display_mode(mPlayer, PLAYER_DISPLAY_MODE_DST_ROI);
 986     ret   = LogPlayerError(error);
 987     if(ret)
 988     {
 989       DALI_LOG_ERROR("InitializeUnderlayMode, player_set_display_mode() is failed\n");
 990     }
 991
 992     error = player_set_display_roi_area(mPlayer, 0, 0, 1, 1);
 993     ret   = LogPlayerError(error);
 994     if(ret)
 995     {
 996       DALI_LOG_ERROR("InitializeUnderlayMode, player_set_display_roi_area() is failed\n");
 997     }
 998
 999     error = player_set_ecore_wl_display(mPlayer, PLAYER_DISPLAY_TYPE_OVERLAY, mEcoreWlWindow, 0, 0, width, height);
1000     ret   = LogPlayerError(error);
1001     if(ret)
1002     {
1003       DALI_LOG_ERROR("InitializeUnderlayMode, player_set_ecore_wl_display() is failed\n");
1004     }
1005
1006     error = player_set_display_visible(mPlayer, true);
1007     ret   = LogPlayerError(error);
1008     if(ret)
1009     {
1010       DALI_LOG_ERROR("InitializeUnderlayMode, player_set_display_visible() is failed\n");
1011     }
1012   }
1013 }
1014
1015 bool TizenVideoPlayer::Update()
1016 {
1017   Dali::Mutex::ScopedLock lock(mPacketMutex);
1018
1019   int error;
1020
1021   if(mPacket != NULL)
1022   {
1023     error = media_packet_destroy(mPacket);
1024     if(error != MEDIA_PACKET_ERROR_NONE)
1025     {
1026       DALI_LOG_ERROR("Update, media_packet_destroy() is failed\n");
1027     }
1028     mPacket = NULL;
1029   }
1030
1031   if(!mPacketList.empty())
1032   {
1033     mPacket = static_cast< media_packet_h >( mPacketList.front() );
1034     mPacketList.pop_front();
1035   }
1036
1037   if(mPacket == NULL)
1038   {
1039     return true;
1040   }
1041
1042   error = media_packet_get_tbm_surface(mPacket, &mTbmSurface);
1043   if(error != MEDIA_PACKET_ERROR_NONE)
1044   {
1045     media_packet_destroy(mPacket);
1046     mPacket = NULL;
1047     DALI_LOG_ERROR(" error: %d\n", error);
1048     return true;
1049   }
1050
1051   Any source(mTbmSurface);
1052   mNativeImageSourcePtr->SetSource(source);
1053   Dali::Stage::GetCurrent().KeepRendering(0.0f);
1054
1055   return true;
1056 }
1057
1058 void TizenVideoPlayer::DestroyPackets()
1059 {
1060   int error;
1061   if(mPacket != NULL)
1062   {
1063     error = media_packet_destroy(mPacket);
1064     DALI_LOG_ERROR("Media packet destroy error: %d\n", error);
1065     mPacket = NULL;
1066   }
1067
1068   std::list<media_packet_h>::iterator iter = mPacketList.begin();
1069   for (; iter != mPacketList.end(); ++iter)
1070   {
1071     mPacket = *iter;
1072     error = media_packet_destroy( mPacket );
1073     DALI_LOG_ERROR( "Media packet destroy error: %d\n", error );
1074     mPacket = NULL;
1075   }
1076   mPacketList.clear();
1077 }
1078
1079 void TizenVideoPlayer::PushPacket(media_packet_h packet)
1080 {
1081   Dali::Mutex::ScopedLock lock(mPacketMutex);
1082   mPacketList.push_back(packet);
1083 }
1084
1085 void TizenVideoPlayer::SetDisplayArea(DisplayArea area)
1086 {
1087   int ret = 0;
1088   GetPlayerState(&mPlayerState);
1089
1090   if(mNativeImageSourcePtr)
1091   {
1092     DALI_LOG_ERROR("SetDisplayArea is only for window surface target.\n");
1093     return;
1094   }
1095
1096   if(mPlayerState == PLAYER_STATE_IDLE ||
1097      mPlayerState == PLAYER_STATE_READY ||
1098      mPlayerState == PLAYER_STATE_PLAYING ||
1099      mPlayerState == PLAYER_STATE_PAUSED)
1100   {
1101     area.x = (area.x < 0) ? 0 : area.x;
1102     area.y = (area.y < 0) ? 0 : area.y;
1103     if(mSyncMode == Dali::VideoSyncMode::ENABLED)
1104     {
1105       if(!ecore_wl2_subsurface_video_surface_destination_set(mEcoreSubVideoWindow, area.x, area.y, area.width, area.height))
1106       {
1107         DALI_LOG_ERROR("SetDisplayArea, ecore_wl2_subsurface_video_surface_destination_set() is failed\n");
1108       }
1109     }
1110     else
1111     {
1112       int error = player_set_display_roi_area(mPlayer, area.x, area.y, area.width, area.height);
1113       ret       = LogPlayerError(error);
1114       if(ret)
1115       {
1116         DALI_LOG_ERROR("SetDisplayArea, player_set_display_roi_area() is failed\n");
1117       }
1118     }
1119   }
1120 }
1121
1122 void TizenVideoPlayer::Forward(int millisecond)
1123 {
1124   int error;
1125   int ret = 0;
1126
1127   GetPlayerState(&mPlayerState);
1128
1129   if(mPlayerState == PLAYER_STATE_READY ||
1130      mPlayerState == PLAYER_STATE_PLAYING ||
1131      mPlayerState == PLAYER_STATE_PAUSED)
1132   {
1133     int currentPosition = 0;
1134     int nextPosition    = 0;
1135
1136     error = player_get_play_position(mPlayer, &currentPosition);
1137     ret   = LogPlayerError(error);
1138     if(ret)
1139     {
1140       DALI_LOG_ERROR("Forward, player_get_play_position() is failed\n");
1141     }
1142
1143     nextPosition = currentPosition + millisecond;
1144
1145     error = player_set_play_position(mPlayer, nextPosition, ACCURATE_PLAY_POSITION_SET, PlayerSeekCompletedCb, NULL);
1146     ret   = LogPlayerError(error);
1147     if(ret)
1148     {
1149       DALI_LOG_ERROR("Forward, player_set_play_position() is failed\n");
1150     }
1151   }
1152 }
1153
1154 void TizenVideoPlayer::Backward(int millisecond)
1155 {
1156   int error;
1157   int ret = 0;
1158
1159   GetPlayerState(&mPlayerState);
1160
1161   if(mPlayerState == PLAYER_STATE_READY ||
1162      mPlayerState == PLAYER_STATE_PLAYING ||
1163      mPlayerState == PLAYER_STATE_PAUSED)
1164   {
1165     int currentPosition = 0;
1166     int nextPosition    = 0;
1167
1168     error = player_get_play_position(mPlayer, &currentPosition);
1169     ret   = LogPlayerError(error);
1170     if(ret)
1171     {
1172       DALI_LOG_ERROR("Backward, player_get_play_position() is failed\n");
1173     }
1174
1175     nextPosition = currentPosition - millisecond;
1176     nextPosition = (nextPosition < 0) ? 0 : nextPosition;
1177
1178     error = player_set_play_position(mPlayer, nextPosition, ACCURATE_PLAY_POSITION_SET, PlayerSeekCompletedCb, NULL);
1179     ret   = LogPlayerError(error);
1180     if(ret)
1181     {
1182       DALI_LOG_ERROR("Backward, player_set_play_position() is failed\n");
1183     }
1184   }
1185 }
1186
1187 bool TizenVideoPlayer::IsVideoTextureSupported()
1188 {
1189   bool featureFlag = true;
1190   int  error       = SYSTEM_INFO_ERROR_NONE;
1191
1192   error = system_info_get_platform_bool("tizen.org/feature/multimedia.raw_video", &featureFlag);
1193
1194   if(error != SYSTEM_INFO_ERROR_NONE)
1195   {
1196     DALI_LOG_ERROR("Plugin can't check platform feature\n");
1197     return false;
1198   }
1199
1200   return featureFlag;
1201 }
1202
1203 void TizenVideoPlayer::DestroyPlayer()
1204 {
1205   mUrl    = "";
1206   int ret = 0;
1207
1208   int error;
1209   if(mPlayerState != PLAYER_STATE_NONE)
1210   {
1211     GetPlayerState(&mPlayerState);
1212
1213     if(mPlayerState != PLAYER_STATE_IDLE)
1214     {
1215       Stop();
1216       error = player_unprepare(mPlayer);
1217       ret   = LogPlayerError(error);
1218       if(ret)
1219       {
1220         DALI_LOG_ERROR("DestroyPlayer, player_unprepare() is failed\n");
1221       }
1222     }
1223
1224     error = player_destroy(mPlayer);
1225     ret   = LogPlayerError(error);
1226     if(ret)
1227     {
1228       DALI_LOG_ERROR("DestroyPlayer, player_destroy() is failed\n");
1229     }
1230
1231     error = sound_manager_destroy_stream_information(mStreamInfo);
1232     ret   = LogPlayerError(error);
1233     if(ret)
1234     {
1235       DALI_LOG_ERROR("DestroyPlayer, sound_manager_destroy_stream_information() is failed\n");
1236     }
1237
1238     mPlayerState = PLAYER_STATE_NONE;
1239     mPlayer      = NULL;
1240   }
1241 }
1242
1243 void TizenVideoPlayer::SetCodecType(Dali::VideoPlayerPlugin::CodecType type)
1244 {
1245   int error;
1246   int ret = 0;
1247   switch(type)
1248   {
1249     case Dali::VideoPlayerPlugin::CodecType::DEFAULT:
1250     {
1251       mCodecType = PLAYER_VIDEO_CODEC_TYPE_EX_DEFAULT;
1252       break;
1253     }
1254     case Dali::VideoPlayerPlugin::CodecType::HW:
1255     {
1256       mCodecType = PLAYER_VIDEO_CODEC_TYPE_EX_HW;
1257       break;
1258     }
1259     case Dali::VideoPlayerPlugin::CodecType::SW:
1260     {
1261       mCodecType = PLAYER_VIDEO_CODEC_TYPE_EX_SW;
1262       break;
1263     }
1264   }
1265
1266   if(mPlayerState != PLAYER_STATE_NONE)
1267   {
1268     GetPlayerState(&mPlayerState);
1269
1270     if(mPlayerState == PLAYER_STATE_IDLE)
1271     {
1272       error = player_set_video_codec_type_ex(mPlayer, mCodecType);
1273       ret   = LogPlayerError(error);
1274       if(ret)
1275       {
1276         DALI_LOG_ERROR("SetCodecType, player_set_video_codec_type_ex() is failed\n");
1277       }
1278     }
1279   }
1280 }
1281
1282 Dali::VideoPlayerPlugin::CodecType TizenVideoPlayer::GetCodecType() const
1283 {
1284   Dali::VideoPlayerPlugin::CodecType type = Dali::VideoPlayerPlugin::CodecType::DEFAULT;
1285   int                                ret  = 0;
1286   if(mPlayerState != PLAYER_STATE_NONE)
1287   {
1288     player_video_codec_type_ex_e codecType = PLAYER_VIDEO_CODEC_TYPE_EX_DEFAULT;
1289     int                          error     = player_get_video_codec_type_ex(mPlayer, &codecType);
1290     if(error != PLAYER_ERROR_NONE)
1291     {
1292       ret = LogPlayerError(error);
1293       if(ret)
1294       {
1295         DALI_LOG_ERROR("GetCodecType, player_get_video_codec_type_ex() is failed\n");
1296       }
1297       return type;
1298     }
1299
1300     switch(codecType)
1301     {
1302       case PLAYER_VIDEO_CODEC_TYPE_EX_DEFAULT:
1303       {
1304         type = Dali::VideoPlayerPlugin::CodecType::DEFAULT;
1305         break;
1306       }
1307       case PLAYER_VIDEO_CODEC_TYPE_EX_HW:
1308       {
1309         type = Dali::VideoPlayerPlugin::CodecType::HW;
1310         break;
1311       }
1312       case PLAYER_VIDEO_CODEC_TYPE_EX_SW:
1313       {
1314         type = Dali::VideoPlayerPlugin::CodecType::SW;
1315         break;
1316       }
1317     }
1318   }
1319   return type;
1320 }
1321
1322 void TizenVideoPlayer::SetDisplayMode(Dali::VideoPlayerPlugin::DisplayMode::Type mode)
1323 {
1324   int error;
1325   error   = player_set_display_mode(mPlayer, static_cast<player_display_mode_e>(mode));
1326   int ret = LogPlayerError(error);
1327   if(ret)
1328   {
1329     DALI_LOG_ERROR("SetDisplayMode, player_set_display_mode() is failed\n");
1330   }
1331 }
1332
1333 Dali::VideoPlayerPlugin::DisplayMode::Type TizenVideoPlayer::GetDisplayMode() const
1334 {
1335   player_display_mode_e mode;
1336   player_get_display_mode(mPlayer, &mode);
1337   return static_cast<Dali::VideoPlayerPlugin::DisplayMode::Type>(mode);
1338 }
1339
1340 Any TizenVideoPlayer::GetMediaPlayer()
1341 {
1342   return Any((void*)mPlayer);
1343 }
1344
1345 void TizenVideoPlayer::StartSynchronization()
1346 {
1347   DALI_LOG_RELEASE_INFO("sync VideoPlayer\n");
1348   ecore_wl2_subsurface_sync_set(mEcoreSubVideoWindow, EINA_TRUE);
1349 }
1350
1351 void TizenVideoPlayer::FinishSynchronization()
1352 {
1353   // Finish
1354   DALI_LOG_RELEASE_INFO("desync VideoPlayer\n");
1355   ecore_wl2_subsurface_sync_set(mEcoreSubVideoWindow, EINA_FALSE);
1356 }
1357
1358 void TizenVideoPlayer::CreateConstraint()
1359 {
1360   if(mVideoSizePropertyIndex == Property::INVALID_INDEX)
1361   {
1362     if(mVideoSizePropertyConstraint)
1363     {
1364       mVideoSizePropertyConstraint.Remove();
1365     }
1366
1367     Actor syncActor = mSyncActor.GetHandle();
1368     if(syncActor)
1369     {
1370       mVideoSizePropertyIndex = syncActor.RegisterProperty(VIDEO_PLAYER_SIZE_NAME, Vector3::ZERO);
1371
1372       int                width, height;
1373       Ecore_Wl2_Display* wl2_display = ecore_wl2_connected_display_get(NULL);
1374       ecore_wl2_display_screen_size_get(wl2_display, &width, &height);
1375
1376       mVideoSizePropertyConstraint = Constraint::New<Vector3>(syncActor,
1377                                                               mVideoSizePropertyIndex,
1378                                                               VideoPlayerSyncConstraint(mEcoreSubVideoWindow, width, height));
1379
1380       mVideoSizePropertyConstraint.AddSource(LocalSource(Actor::Property::SIZE));
1381       mVideoSizePropertyConstraint.AddSource(LocalSource(Actor::Property::WORLD_SCALE));
1382       mVideoSizePropertyConstraint.AddSource(LocalSource(Actor::Property::WORLD_POSITION));
1383
1384       mVideoSizePropertyConstraint.Apply();
1385     }
1386   }
1387 }
1388
1389 void TizenVideoPlayer::DestroyConstraint()
1390 {
1391   if(mVideoSizePropertyIndex != Property::INVALID_INDEX)
1392   {
1393     mVideoSizePropertyConstraint.Remove();
1394     mVideoSizePropertyIndex = Property::INVALID_INDEX;
1395   }
1396 }
1397
1398 void TizenVideoPlayer::RaiseAbove(Any videoSurface)
1399 {
1400   Ecore_Wl2_Subsurface* surface = AnyCast<Ecore_Wl2_Subsurface*>(videoSurface);
1401   ecore_wl2_subsurface_place_surface_above(mEcoreSubVideoWindow, surface);
1402 }
1403
1404 void TizenVideoPlayer::LowerBelow(Any videoSurface)
1405 {
1406   Ecore_Wl2_Subsurface* surface = AnyCast<Ecore_Wl2_Subsurface*>(videoSurface);
1407   ecore_wl2_subsurface_place_surface_below(mEcoreSubVideoWindow, surface);
1408 }
1409
1410 void TizenVideoPlayer::RaiseToTop()
1411 {
1412   ecore_wl2_subsurface_place_surface_above(mEcoreSubVideoWindow, NULL);
1413 }
1414
1415 void TizenVideoPlayer::LowerToBottom()
1416 {
1417   ecore_wl2_subsurface_place_surface_below(mEcoreSubVideoWindow, NULL);
1418 }
1419
1420 Any TizenVideoPlayer::GetVideoPlayerSurface()
1421 {
1422   return mEcoreSubVideoWindow;
1423 }
1424
1425 } // namespace Plugin
1426 } // namespace Dali