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_CODEC_TYPE_HW),
 322   mEcoreWlWindow(nullptr),
 323   mEcoreSubVideoWindow(nullptr),
 324   mSyncActor(actor),
 325   mVideoSizePropertyIndex(Property::INVALID_INDEX),
 326   mSyncMode(syncMode),
 327   mIsInitForSyncMode(false),
 328   mIsMovedHandle(false)
 329 {
 330 }
 331
 332 TizenVideoPlayer::~TizenVideoPlayer()
 333 {
 334   DestroyConstraint();
 335   if(mEcoreSubVideoWindow)
 336   {
 337     ecore_wl2_subsurface_del(mEcoreSubVideoWindow);
 338     mEcoreSubVideoWindow = nullptr;
 339   }
 340
 341   DestroyPlayer();
 342 }
 343
 344 void TizenVideoPlayer::GetPlayerState(player_state_e* state) const
 345 {
 346   if(mPlayer != NULL && player_get_state(mPlayer, state) != PLAYER_ERROR_NONE)
 347   {
 348     DALI_LOG_ERROR("player_get_state error: Invalid parameter\n");
 349     *state = PLAYER_STATE_NONE;
 350   }
 351 }
 352
 353 void TizenVideoPlayer::SetUrl(const std::string& url)
 354 {
 355   int ret = 0;
 356   if(mUrl != url)
 357   {
 358     int error = PLAYER_ERROR_NONE;
 359
 360     mUrl = url;
 361
 362     GetPlayerState(&mPlayerState);
 363
 364     if(mPlayerState != PLAYER_STATE_NONE && mPlayerState != PLAYER_STATE_IDLE)
 365     {
 366       if(mNativeImageSourcePtr)
 367       {
 368         error = player_unset_media_packet_video_frame_decoded_cb(mPlayer);
 369         ret   = LogPlayerError(error);
 370         if(ret)
 371         {
 372           DALI_LOG_ERROR("SetUrl, player_unset_media_packet_video_frame_decoded_cb() is failed\n");
 373         }
 374       }
 375       Stop();
 376
 377       error = player_unprepare(mPlayer);
 378       ret   = LogPlayerError(error);
 379       if(ret)
 380       {
 381         DALI_LOG_ERROR("SetUrl, player_unprepare() is failed\n");
 382       }
 383
 384       if(mNativeImageSourcePtr)
 385       {
 386         error = player_set_media_packet_video_frame_decoded_cb(mPlayer, MediaPacketVideoDecodedCb, this);
 387         ret   = LogPlayerError(error);
 388         if(ret)
 389         {
 390           DALI_LOG_ERROR("SetUrl, player_set_media_packet_video_frame_decoded_cb() is failed\n");
 391         }
 392       }
 393       else
 394       {
 395         int                width, height;
 396         Ecore_Wl2_Display* wl2_display = ecore_wl2_connected_display_get(NULL);
 397         ecore_wl2_display_screen_size_get(wl2_display, &width, &height);
 398
 399         if(mSyncMode == Dali::VideoSyncMode::ENABLED)
 400         {
 401           if(mIsInitForSyncMode)
 402           {
 403             InitializeEnableSyncMode(mEcoreWlWindow);
 404           }
 405           else
 406           {
 407             if(!ecore_wl2_subsurface_video_surface_destination_set(mEcoreSubVideoWindow, 0, 0, width, height))
 408             {
 409               DALI_LOG_ERROR("SetUrl, ecore_wl2_subsurface_video_surface_destination_set() is failed\n");
 410             }
 411           }
 412         }
 413         else
 414         {
 415           error = player_set_ecore_wl_display(mPlayer, PLAYER_DISPLAY_TYPE_OVERLAY, mEcoreWlWindow, 0, 0, width, height);
 416           ret   = LogPlayerError(error);
 417           if(ret)
 418           {
 419             DALI_LOG_ERROR("SetUrl, player_set_ecore_wl_display() is failed\n");
 420           }
 421         }
 422       }
 423       GetPlayerState(&mPlayerState);
 424       ret = LogPlayerError(error);
 425       if(ret)
 426       {
 427         DALI_LOG_ERROR("SetUrl, GetPlayerState() is failed\n");
 428       }
 429     }
 430
 431     if(mPlayerState == PLAYER_STATE_IDLE)
 432     {
 433       error = player_set_uri(mPlayer, mUrl.c_str());
 434       ret   = LogPlayerError(error);
 435       if(ret)
 436       {
 437         DALI_LOG_ERROR("SetUrl, player_set_uri() is failed\n");
 438       }
 439
 440       error = player_prepare(mPlayer);
 441       ret   = LogPlayerError(error);
 442       if(ret)
 443       {
 444         DALI_LOG_ERROR("SetUrl, player_prepare() is failed\n");
 445       }
 446     }
 447   }
 448 }
 449
 450 std::string TizenVideoPlayer::GetUrl()
 451 {
 452   return mUrl;
 453 }
 454
 455 void TizenVideoPlayer::SetRenderingTarget(Any target)
 456 {
 457   DestroyPlayer();
 458
 459   mNativeImageSourcePtr = NULL;
 460
 461   if(target.GetType() == typeid(Dali::NativeImageSourcePtr))
 462   {
 463     if(mSyncMode == Dali::VideoSyncMode::ENABLED)
 464     {
 465       DestroyConstraint();
 466     }
 467     mTargetType = TizenVideoPlayer::NATIVE_IMAGE;
 468
 469     Dali::NativeImageSourcePtr nativeImageSourcePtr = AnyCast<Dali::NativeImageSourcePtr>(target);
 470
 471     InitializeTextureStreamMode(nativeImageSourcePtr);
 472   }
 473   else if(target.GetType() == typeid(Ecore_Wl2_Window*))
 474   {
 475     mTargetType = TizenVideoPlayer::WINDOW_SURFACE;
 476
 477     InitializeUnderlayMode(Dali::AnyCast<Ecore_Wl2_Window*>(target));
 478
 479     if(mSyncMode == Dali::VideoSyncMode::ENABLED)
 480     {
 481       CreateConstraint();
 482     }
 483   }
 484   else
 485   {
 486     DALI_LOG_ERROR("SetRenderingTarget, Video rendering target is unknown\n");
 487   }
 488 }
 489
 490 void TizenVideoPlayer::SetLooping(bool looping)
 491 {
 492   GetPlayerState(&mPlayerState);
 493
 494   if(mPlayerState != PLAYER_STATE_NONE)
 495   {
 496     int error = player_set_looping(mPlayer, looping);
 497     int ret   = LogPlayerError(error);
 498     if(ret)
 499     {
 500       DALI_LOG_ERROR("SetLooping, player_set_looping() is failed\n");
 501     }
 502   }
 503 }
 504
 505 bool TizenVideoPlayer::IsLooping()
 506 {
 507   GetPlayerState(&mPlayerState);
 508
 509   bool looping = false;
 510   if(mPlayerState != PLAYER_STATE_NONE)
 511   {
 512     int error = player_is_looping(mPlayer, &looping);
 513     int ret   = LogPlayerError(error);
 514     if(ret)
 515     {
 516       DALI_LOG_ERROR("IsLooping, player_is_looping() is failed\n");
 517     }
 518   }
 519
 520   return looping;
 521 }
 522
 523 void TizenVideoPlayer::Play()
 524 {
 525   GetPlayerState(&mPlayerState);
 526
 527   if(mPlayerState == PLAYER_STATE_READY || mPlayerState == PLAYER_STATE_PAUSED)
 528   {
 529     if(mNativeImageSourcePtr && mTimer)
 530     {
 531       mTimer.Start();
 532     }
 533
 534     int error = player_start(mPlayer);
 535     int ret   = LogPlayerError(error);
 536     if(ret)
 537     {
 538       DALI_LOG_ERROR("Play, player_start() is failed\n");
 539     }
 540   }
 541 }
 542
 543 void TizenVideoPlayer::Pause()
 544 {
 545   GetPlayerState(&mPlayerState);
 546   int ret = 0;
 547   if(mPlayerState == PLAYER_STATE_PLAYING)
 548   {
 549     int error = player_pause(mPlayer);
 550     ret       = LogPlayerError(error);
 551     if(ret)
 552     {
 553       DALI_LOG_ERROR("Pause, player_pause() is failed\n");
 554     }
 555
 556     if(mNativeImageSourcePtr && mTimer)
 557     {
 558       mTimer.Stop();
 559       DestroyPackets();
 560     }
 561   }
 562 }
 563
 564 void TizenVideoPlayer::Stop()
 565 {
 566   GetPlayerState(&mPlayerState);
 567
 568   if(mPlayerState == PLAYER_STATE_PLAYING || mPlayerState == PLAYER_STATE_PAUSED)
 569   {
 570     int error = player_stop(mPlayer);
 571     int ret   = LogPlayerError(error);
 572     if(ret)
 573     {
 574       DALI_LOG_ERROR("Stop, player_stop() is failed\n");
 575     }
 576
 577     if(mNativeImageSourcePtr && mTimer)
 578     {
 579       mTimer.Stop();
 580       DestroyPackets();
 581     }
 582   }
 583 }
 584
 585 void TizenVideoPlayer::SetMute(bool muted)
 586 {
 587   GetPlayerState(&mPlayerState);
 588
 589   if(mPlayerState == PLAYER_STATE_IDLE ||
 590      mPlayerState == PLAYER_STATE_READY ||
 591      mPlayerState == PLAYER_STATE_PLAYING ||
 592      mPlayerState == PLAYER_STATE_PAUSED)
 593   {
 594     int error = player_set_mute(mPlayer, muted);
 595     int ret   = LogPlayerError(error);
 596     if(ret)
 597     {
 598       DALI_LOG_ERROR("SetMute, player_set_mute() is failed\n");
 599     }
 600   }
 601 }
 602
 603 bool TizenVideoPlayer::IsMuted()
 604 {
 605   GetPlayerState(&mPlayerState);
 606   bool muted = false;
 607
 608   if(mPlayerState == PLAYER_STATE_IDLE ||
 609      mPlayerState == PLAYER_STATE_READY ||
 610      mPlayerState == PLAYER_STATE_PLAYING ||
 611      mPlayerState == PLAYER_STATE_PAUSED)
 612   {
 613     int error = player_is_muted(mPlayer, &muted);
 614     int ret   = LogPlayerError(error);
 615     if(ret)
 616     {
 617       DALI_LOG_ERROR("IsMuted, player_is_muted() is failed\n");
 618     }
 619   }
 620
 621   return muted;
 622 }
 623
 624 void TizenVideoPlayer::SetVolume(float left, float right)
 625 {
 626   GetPlayerState(&mPlayerState);
 627
 628   int error = player_set_volume(mPlayer, left, right);
 629   int ret   = LogPlayerError(error);
 630   if(ret)
 631   {
 632     DALI_LOG_ERROR("SetVolume, player_set_volume() is failed\n");
 633   }
 634 }
 635
 636 void TizenVideoPlayer::GetVolume(float& left, float& right)
 637 {
 638   GetPlayerState(&mPlayerState);
 639
 640   int error = player_get_volume(mPlayer, &left, &right);
 641   int ret   = LogPlayerError(error);
 642   if(ret)
 643   {
 644     DALI_LOG_ERROR("GetVolume, player_get_volume() is failed\n");
 645   }
 646 }
 647
 648 void TizenVideoPlayer::SetPlayPosition(int millisecond)
 649 {
 650   int error;
 651   int ret = 0;
 652
 653   GetPlayerState(&mPlayerState);
 654
 655   if(mPlayerState == PLAYER_STATE_IDLE)
 656   {
 657     error = player_prepare(mPlayer);
 658     ret   = LogPlayerError(error);
 659     if(ret)
 660     {
 661       DALI_LOG_ERROR("SetPlayPosition, player_prepare() is failed\n");
 662     }
 663
 664     GetPlayerState(&mPlayerState); // Check the status again.
 665   }
 666
 667   if(mPlayerState == PLAYER_STATE_READY ||
 668      mPlayerState == PLAYER_STATE_PLAYING ||
 669      mPlayerState == PLAYER_STATE_PAUSED)
 670   {
 671     error = player_set_play_position(mPlayer, millisecond, ACCURATE_PLAY_POSITION_SET, PlayerSeekCompletedCb, NULL);
 672     ret   = LogPlayerError(error);
 673     if(ret)
 674     {
 675       DALI_LOG_ERROR("SetPlayPosition, player_set_play_position() is failed\n");
 676     }
 677   }
 678 }
 679
 680 int TizenVideoPlayer::GetPlayPosition()
 681 {
 682   int error;
 683   int millisecond = 0;
 684
 685   GetPlayerState(&mPlayerState);
 686
 687   if(mPlayerState == PLAYER_STATE_IDLE ||
 688      mPlayerState == PLAYER_STATE_READY ||
 689      mPlayerState == PLAYER_STATE_PLAYING ||
 690      mPlayerState == PLAYER_STATE_PAUSED)
 691   {
 692     error   = player_get_play_position(mPlayer, &millisecond);
 693     int ret = LogPlayerError(error);
 694     if(ret)
 695     {
 696       DALI_LOG_ERROR("GetPlayPosition, player_get_play_position() is failed\n");
 697     }
 698   }
 699
 700   return millisecond;
 701 }
 702
 703 void TizenVideoPlayer::SetDisplayRotation(Dali::VideoPlayerPlugin::DisplayRotation rotation)
 704 {
 705   if(mNativeImageSourcePtr)
 706   {
 707     DALI_LOG_ERROR("SetDisplayRotation is only for window rendering target.\n");
 708     return;
 709   }
 710
 711   int error;
 712   if(mPlayerState != PLAYER_STATE_NONE)
 713   {
 714     error   = player_set_display_rotation(mPlayer, static_cast<player_display_rotation_e>(rotation));
 715     int ret = LogPlayerError(error);
 716     if(ret)
 717     {
 718       DALI_LOG_ERROR("SetDisplayRotation, player_set_display_rotation() is failed\n");
 719     }
 720   }
 721 }
 722
 723 Dali::VideoPlayerPlugin::DisplayRotation TizenVideoPlayer::GetDisplayRotation()
 724 {
 725   if(mNativeImageSourcePtr)
 726   {
 727     DALI_LOG_ERROR("GetDisplayRotation is only for window rendering target.\n");
 728     return Dali::VideoPlayerPlugin::ROTATION_NONE;
 729   }
 730
 731   int                       error;
 732   player_display_rotation_e rotation = PLAYER_DISPLAY_ROTATION_NONE;
 733   if(mPlayerState != PLAYER_STATE_NONE)
 734   {
 735     error   = player_get_display_rotation(mPlayer, &rotation);
 736     int ret = LogPlayerError(error);
 737     if(ret)
 738     {
 739       DALI_LOG_ERROR("GetDisplayRotation, player_get_display_rotation() is failed\n");
 740     }
 741   }
 742   return static_cast<Dali::VideoPlayerPlugin::DisplayRotation>(rotation);
 743 }
 744
 745 Dali::VideoPlayerPlugin::VideoPlayerSignalType& TizenVideoPlayer::FinishedSignal()
 746 {
 747   return mFinishedSignal;
 748 }
 749
 750 void TizenVideoPlayer::InitializeTextureStreamMode(Dali::NativeImageSourcePtr nativeImageSourcePtr)
 751 {
 752   int error;
 753   int ret = 0;
 754
 755   mNativeImageSourcePtr = nativeImageSourcePtr;
 756
 757   if(mPlayerState == PLAYER_STATE_NONE)
 758   {
 759     error = player_create(&mPlayer);
 760     ret   = LogPlayerError(error);
 761     if(ret)
 762     {
 763       DALI_LOG_ERROR("InitializeTextureStreamMode, player_create() is failed\n");
 764     }
 765   }
 766
 767   GetPlayerState(&mPlayerState);
 768
 769   if(mPlayerState == PLAYER_STATE_IDLE)
 770   {
 771     error = player_set_completed_cb(mPlayer, EmitPlaybackFinishedSignal, this);
 772     ret   = LogPlayerError(error);
 773     if(ret)
 774     {
 775       DALI_LOG_ERROR("InitializeTextureStreamMode, player_set_completed_cb() is failed\n");
 776     }
 777
 778     error = player_set_media_packet_video_frame_decoded_cb(mPlayer, MediaPacketVideoDecodedCb, this);
 779     ret   = LogPlayerError(error);
 780     if(ret)
 781     {
 782       DALI_LOG_ERROR("InitializeTextureStreamMode, player_set_media_packet_video_frame_decoded_cb() is failed\n");
 783     }
 784
 785     error = sound_manager_create_stream_information(mStreamType, NULL, NULL, &mStreamInfo);
 786     ret   = LogPlayerError(error);
 787     if(ret)
 788     {
 789       DALI_LOG_ERROR("InitializeTextureStreamMode, sound_manager_create_stream_information() is failed\n");
 790     }
 791
 792     error = player_set_sound_stream_info(mPlayer, mStreamInfo);
 793     ret   = LogPlayerError(error);
 794     if(ret)
 795     {
 796       DALI_LOG_ERROR("InitializeTextureStreamMode, player_set_sound_stream_info() is failed\n");
 797     }
 798
 799     error = player_set_display_mode(mPlayer, PLAYER_DISPLAY_MODE_FULL_SCREEN);
 800     ret   = LogPlayerError(error);
 801     if(ret)
 802     {
 803       DALI_LOG_ERROR("InitializeTextureStreamMode, player_set_display_mode() is failed\n");
 804     }
 805
 806     error = player_set_display(mPlayer, PLAYER_DISPLAY_TYPE_NONE, NULL);
 807     ret   = LogPlayerError(error);
 808     if(ret)
 809     {
 810       DALI_LOG_ERROR("InitializeTextureStreamMode, player_set_display() is failed\n");
 811     }
 812
 813     error = player_set_video_codec_type(mPlayer, mCodecType);
 814     ret   = LogPlayerError(error);
 815     if(ret)
 816     {
 817       DALI_LOG_ERROR("InitializeTextureStreamMode, player_set_video_codec_type() is failed\n");
 818     }
 819     error = player_set_display_visible(mPlayer, true);
 820     ret   = LogPlayerError(error);
 821     if(ret)
 822     {
 823       DALI_LOG_ERROR("InitializeTextureStreamMode, player_set_display_visible() is failed\n");
 824     }
 825
 826     mTimer = Dali::Timer::New(TIMER_INTERVAL);
 827     mTimer.TickSignal().Connect(this, &TizenVideoPlayer::Update);
 828   }
 829 }
 830
 831 void TizenVideoPlayer::InitializeEnableSyncMode(Ecore_Wl2_Window* ecoreWlWindow)
 832 {
 833   int error;
 834   int ret = 0;
 835
 836   if(mEcoreWlWindow != ecoreWlWindow)
 837   {
 838     mEcoreWlWindow = ecoreWlWindow;
 839     // check previous video subsurface and destroy
 840     if(mEcoreSubVideoWindow)
 841     {
 842       ecore_wl2_subsurface_del(mEcoreSubVideoWindow);
 843     }
 844
 845     // Crate ecore_wl2 sursurface
 846     mEcoreSubVideoWindow = ecore_wl2_subsurface_new(mEcoreWlWindow);
 847     if(!mEcoreSubVideoWindow)
 848     {
 849       DALI_LOG_ERROR("InitializeEnableSyncMode, ecore_wl2_subsurface_new() is failed\n");
 850       return;
 851     }
 852
 853     // ecore_wl2_subsurface_video_surface_prepare
 854     if(!ecore_wl2_subsurface_video_surface_prepare(mEcoreSubVideoWindow))
 855     {
 856       ecore_wl2_subsurface_del(mEcoreSubVideoWindow);
 857       DALI_LOG_ERROR("InitializeEnableSyncMode, : ecore_wl2_subsurface_video_surface_prepare() is failed\n");
 858       return;
 859     }
 860
 861     DALI_LOG_RELEASE_INFO("InitializeEnableSyncMode, desync VideoPlayer\n");
 862     ecore_wl2_subsurface_sync_set(mEcoreSubVideoWindow, EINA_FALSE);
 863   }
 864
 865   if(mPlayerState == PLAYER_STATE_NONE)
 866   {
 867     error = player_create(&mPlayer);
 868     ret   = LogPlayerError(error);
 869     if(ret)
 870     {
 871       DALI_LOG_ERROR("InitializeEnableSyncMode, player_create() is failed\n");
 872     }
 873   }
 874
 875   GetPlayerState(&mPlayerState);
 876   if(mPlayerState == PLAYER_STATE_IDLE)
 877   {
 878     error = player_set_completed_cb(mPlayer, EmitPlaybackFinishedSignal, this);
 879     ret   = LogPlayerError(error);
 880     if(ret)
 881     {
 882       DALI_LOG_ERROR("InitializeEnableSyncMode, player_set_completed_cb() is failed\n");
 883     }
 884
 885     error = sound_manager_create_stream_information(mStreamType, NULL, NULL, &mStreamInfo);
 886     ret   = LogPlayerError(error);
 887     if(ret)
 888     {
 889       DALI_LOG_ERROR("InitializeEnableSyncMode, sound_manager_create_stream_information() is failed\n");
 890     }
 891
 892     error = player_set_sound_stream_info(mPlayer, mStreamInfo);
 893     ret   = LogPlayerError(error);
 894     if(ret)
 895     {
 896       DALI_LOG_ERROR("InitializeEnableSyncMode, player_set_sound_stream_info() is failed\n");
 897     }
 898
 899     error = player_set_video_codec_type(mPlayer, mCodecType);
 900     ret   = LogPlayerError(error);
 901     if(ret)
 902     {
 903       DALI_LOG_ERROR("InitializeEnableSyncMode, player_set_video_codec_type() is failed\n");
 904     }
 905
 906     int                width, height;
 907     Ecore_Wl2_Display* wl2_display = ecore_wl2_connected_display_get(NULL);
 908     ecore_wl2_display_screen_size_get(wl2_display, &width, &height);
 909     ecore_wl2_window_alpha_set(mEcoreWlWindow, false);
 910
 911     if(!ecore_wl2_subsurface_video_surface_destination_set(mEcoreSubVideoWindow, 0, 0, width, height))
 912     {
 913       DALI_LOG_ERROR("InitializeEnableSyncMode, ecore_wl2_subsurface_video_surface_destination_set() is failed\n");
 914     }
 915     error = player_set_display(mPlayer, PLAYER_DISPLAY_TYPE_OVERLAY, mEcoreWlWindow);
 916     ret   = LogPlayerError(error);
 917     if(ret)
 918     {
 919       DALI_LOG_ERROR("InitializeEnableSyncMode, player_set_display() is failed\n");
 920     }
 921
 922     mIsInitForSyncMode = true;
 923   }
 924 }
 925
 926 void TizenVideoPlayer::InitializeUnderlayMode(Ecore_Wl2_Window* ecoreWlWindow)
 927 {
 928   int error;
 929   int ret = 0;
 930
 931   if(mSyncMode == Dali::VideoSyncMode::ENABLED)
 932   {
 933     DALI_LOG_RELEASE_INFO("InitializeUnderlayMode, \n");
 934     InitializeEnableSyncMode(ecoreWlWindow);
 935     return;
 936   }
 937
 938   mEcoreWlWindow = ecoreWlWindow;
 939
 940   if(mPlayerState == PLAYER_STATE_NONE)
 941   {
 942     error = player_create(&mPlayer);
 943     ret   = LogPlayerError(error);
 944     if(ret)
 945     {
 946       DALI_LOG_ERROR("InitializeUnderlayMode, player_create() is failed\n");
 947     }
 948   }
 949
 950   GetPlayerState(&mPlayerState);
 951   if(mPlayerState == PLAYER_STATE_IDLE)
 952   {
 953     error = player_set_completed_cb(mPlayer, EmitPlaybackFinishedSignal, this);
 954     ret   = LogPlayerError(error);
 955     if(ret)
 956     {
 957       DALI_LOG_ERROR("InitializeUnderlayMode, player_set_completed_cb() is failed\n");
 958     }
 959
 960     error = sound_manager_create_stream_information(mStreamType, NULL, NULL, &mStreamInfo);
 961     ret   = LogPlayerError(error);
 962     if(ret)
 963     {
 964       DALI_LOG_ERROR("InitializeUnderlayMode, sound_manager_create_stream_information() is failed\n");
 965     }
 966
 967     error = player_set_sound_stream_info(mPlayer, mStreamInfo);
 968     ret   = LogPlayerError(error);
 969     if(ret)
 970     {
 971       DALI_LOG_ERROR("InitializeUnderlayMode, player_set_sound_stream_info() is failed\n");
 972     }
 973
 974     error = player_set_video_codec_type(mPlayer, mCodecType);
 975     ret   = LogPlayerError(error);
 976     if(ret)
 977     {
 978       DALI_LOG_ERROR("InitializeUnderlayMode, player_set_video_codec_type() is failed\n");
 979     }
 980
 981     int                width, height;
 982     Ecore_Wl2_Display* wl2_display = ecore_wl2_connected_display_get(NULL);
 983     ecore_wl2_display_screen_size_get(wl2_display, &width, &height);
 984     ecore_wl2_window_alpha_set(mEcoreWlWindow, false);
 985
 986     error = player_set_display_mode(mPlayer, PLAYER_DISPLAY_MODE_DST_ROI);
 987     ret   = LogPlayerError(error);
 988     if(ret)
 989     {
 990       DALI_LOG_ERROR("InitializeUnderlayMode, player_set_display_mode() is failed\n");
 991     }
 992
 993     error = player_set_display_roi_area(mPlayer, 0, 0, 1, 1);
 994     ret   = LogPlayerError(error);
 995     if(ret)
 996     {
 997       DALI_LOG_ERROR("InitializeUnderlayMode, player_set_display_roi_area() is failed\n");
 998     }
 999
1000     error = player_set_ecore_wl_display(mPlayer, PLAYER_DISPLAY_TYPE_OVERLAY, mEcoreWlWindow, 0, 0, width, height);
1001     ret   = LogPlayerError(error);
1002     if(ret)
1003     {
1004       DALI_LOG_ERROR("InitializeUnderlayMode, player_set_ecore_wl_display() is failed\n");
1005     }
1006
1007     error = player_set_display_visible(mPlayer, true);
1008     ret   = LogPlayerError(error);
1009     if(ret)
1010     {
1011       DALI_LOG_ERROR("InitializeUnderlayMode, player_set_display_visible() is failed\n");
1012     }
1013   }
1014 }
1015
1016 bool TizenVideoPlayer::Update()
1017 {
1018   Dali::Mutex::ScopedLock lock(mPacketMutex);
1019
1020   int error;
1021
1022   if(mPacket != NULL)
1023   {
1024     error = media_packet_destroy(mPacket);
1025     if(error != MEDIA_PACKET_ERROR_NONE)
1026     {
1027       DALI_LOG_ERROR("Update, media_packet_destroy() is failed\n");
1028     }
1029     mPacket = NULL;
1030   }
1031
1032   if(!mPacketList.empty())
1033   {
1034     mPacket = static_cast< media_packet_h >( mPacketList.front() );
1035     mPacketList.pop_front();
1036   }
1037
1038   if(mPacket == NULL)
1039   {
1040     return true;
1041   }
1042
1043   error = media_packet_get_tbm_surface(mPacket, &mTbmSurface);
1044   if(error != MEDIA_PACKET_ERROR_NONE)
1045   {
1046     media_packet_destroy(mPacket);
1047     mPacket = NULL;
1048     DALI_LOG_ERROR(" error: %d\n", error);
1049     return true;
1050   }
1051
1052   Any source(mTbmSurface);
1053   mNativeImageSourcePtr->SetSource(source);
1054   Dali::Stage::GetCurrent().KeepRendering(0.0f);
1055
1056   return true;
1057 }
1058
1059 void TizenVideoPlayer::DestroyPackets()
1060 {
1061   int error;
1062   if(mPacket != NULL)
1063   {
1064     error = media_packet_destroy(mPacket);
1065     DALI_LOG_ERROR("Media packet destroy error: %d\n", error);
1066     mPacket = NULL;
1067   }
1068
1069   std::list<media_packet_h>::iterator iter = mPacketList.begin();
1070   for (; iter != mPacketList.end(); ++iter)
1071   {
1072     mPacket = *iter;
1073     error = media_packet_destroy( mPacket );
1074     DALI_LOG_ERROR( "Media packet destroy error: %d\n", error );
1075     mPacket = NULL;
1076   }
1077   mPacketList.clear();
1078 }
1079
1080 void TizenVideoPlayer::PushPacket(media_packet_h packet)
1081 {
1082   Dali::Mutex::ScopedLock lock(mPacketMutex);
1083   mPacketList.push_back(packet);
1084 }
1085
1086 void TizenVideoPlayer::SetDisplayArea(DisplayArea area)
1087 {
1088   int ret = 0;
1089   GetPlayerState(&mPlayerState);
1090
1091   if(mNativeImageSourcePtr)
1092   {
1093     DALI_LOG_ERROR("SetDisplayArea is only for window surface target.\n");
1094     return;
1095   }
1096
1097   if(mPlayerState == PLAYER_STATE_IDLE ||
1098      mPlayerState == PLAYER_STATE_READY ||
1099      mPlayerState == PLAYER_STATE_PLAYING ||
1100      mPlayerState == PLAYER_STATE_PAUSED)
1101   {
1102     area.x = (area.x < 0) ? 0 : area.x;
1103     area.y = (area.y < 0) ? 0 : area.y;
1104     if(mSyncMode == Dali::VideoSyncMode::ENABLED)
1105     {
1106       if(!ecore_wl2_subsurface_video_surface_destination_set(mEcoreSubVideoWindow, area.x, area.y, area.width, area.height))
1107       {
1108         DALI_LOG_ERROR("SetDisplayArea, ecore_wl2_subsurface_video_surface_destination_set() is failed\n");
1109       }
1110     }
1111     else
1112     {
1113       int error = player_set_display_roi_area(mPlayer, area.x, area.y, area.width, area.height);
1114       ret       = LogPlayerError(error);
1115       if(ret)
1116       {
1117         DALI_LOG_ERROR("SetDisplayArea, player_set_display_roi_area() is failed\n");
1118       }
1119     }
1120   }
1121 }
1122
1123 void TizenVideoPlayer::Forward(int millisecond)
1124 {
1125   int error;
1126   int ret = 0;
1127
1128   GetPlayerState(&mPlayerState);
1129
1130   if(mPlayerState == PLAYER_STATE_READY ||
1131      mPlayerState == PLAYER_STATE_PLAYING ||
1132      mPlayerState == PLAYER_STATE_PAUSED)
1133   {
1134     int currentPosition = 0;
1135     int nextPosition    = 0;
1136
1137     error = player_get_play_position(mPlayer, &currentPosition);
1138     ret   = LogPlayerError(error);
1139     if(ret)
1140     {
1141       DALI_LOG_ERROR("Forward, player_get_play_position() is failed\n");
1142     }
1143
1144     nextPosition = currentPosition + millisecond;
1145
1146     error = player_set_play_position(mPlayer, nextPosition, ACCURATE_PLAY_POSITION_SET, PlayerSeekCompletedCb, NULL);
1147     ret   = LogPlayerError(error);
1148     if(ret)
1149     {
1150       DALI_LOG_ERROR("Forward, player_set_play_position() is failed\n");
1151     }
1152   }
1153 }
1154
1155 void TizenVideoPlayer::Backward(int millisecond)
1156 {
1157   int error;
1158   int ret = 0;
1159
1160   GetPlayerState(&mPlayerState);
1161
1162   if(mPlayerState == PLAYER_STATE_READY ||
1163      mPlayerState == PLAYER_STATE_PLAYING ||
1164      mPlayerState == PLAYER_STATE_PAUSED)
1165   {
1166     int currentPosition = 0;
1167     int nextPosition    = 0;
1168
1169     error = player_get_play_position(mPlayer, &currentPosition);
1170     ret   = LogPlayerError(error);
1171     if(ret)
1172     {
1173       DALI_LOG_ERROR("Backward, player_get_play_position() is failed\n");
1174     }
1175
1176     nextPosition = currentPosition - millisecond;
1177     nextPosition = (nextPosition < 0) ? 0 : nextPosition;
1178
1179     error = player_set_play_position(mPlayer, nextPosition, ACCURATE_PLAY_POSITION_SET, PlayerSeekCompletedCb, NULL);
1180     ret   = LogPlayerError(error);
1181     if(ret)
1182     {
1183       DALI_LOG_ERROR("Backward, player_set_play_position() is failed\n");
1184     }
1185   }
1186 }
1187
1188 bool TizenVideoPlayer::IsVideoTextureSupported()
1189 {
1190   bool featureFlag = true;
1191   int  error       = SYSTEM_INFO_ERROR_NONE;
1192
1193   error = system_info_get_platform_bool("tizen.org/feature/multimedia.raw_video", &featureFlag);
1194
1195   if(error != SYSTEM_INFO_ERROR_NONE)
1196   {
1197     DALI_LOG_ERROR("Plugin can't check platform feature\n");
1198     return false;
1199   }
1200
1201   return featureFlag;
1202 }
1203
1204 void TizenVideoPlayer::DestroyPlayer()
1205 {
1206   mUrl    = "";
1207   int ret = 0;
1208
1209   int error;
1210   // If user take the handle, user must be responsible for its destruction.
1211   if(mPlayerState != PLAYER_STATE_NONE && !mIsMovedHandle)
1212   {
1213     GetPlayerState(&mPlayerState);
1214
1215     if(mPlayerState != PLAYER_STATE_IDLE)
1216     {
1217       Stop();
1218       error = player_unprepare(mPlayer);
1219       ret   = LogPlayerError(error);
1220       if(ret)
1221       {
1222         DALI_LOG_ERROR("DestroyPlayer, player_unprepare() is failed\n");
1223       }
1224     }
1225
1226     error = player_destroy(mPlayer);
1227     ret   = LogPlayerError(error);
1228     if(ret)
1229     {
1230       DALI_LOG_ERROR("DestroyPlayer, player_destroy() is failed\n");
1231     }
1232   }
1233
1234   error = sound_manager_destroy_stream_information(mStreamInfo);
1235   ret   = LogPlayerError(error);
1236   if(ret)
1237   {
1238     DALI_LOG_ERROR("DestroyPlayer, sound_manager_destroy_stream_information() is failed\n");
1239   }
1240
1241   mPlayerState = PLAYER_STATE_NONE;
1242   mPlayer      = NULL;
1243 }
1244
1245 void TizenVideoPlayer::SetCodecType(Dali::VideoPlayerPlugin::CodecType type)
1246 {
1247   int error;
1248   int ret = 0;
1249   switch(type)
1250   {
1251     case Dali::VideoPlayerPlugin::CodecType::HW:
1252     {
1253       mCodecType = PLAYER_CODEC_TYPE_HW;
1254       break;
1255     }
1256     case Dali::VideoPlayerPlugin::CodecType::SW:
1257     {
1258       mCodecType = PLAYER_CODEC_TYPE_SW;
1259       break;
1260     }
1261     default:
1262     {
1263       mCodecType = PLAYER_CODEC_TYPE_HW;
1264       break;
1265     }
1266   }
1267
1268   if(mPlayerState != PLAYER_STATE_NONE)
1269   {
1270     GetPlayerState(&mPlayerState);
1271
1272     if(mPlayerState == PLAYER_STATE_IDLE)
1273     {
1274       error = player_set_video_codec_type(mPlayer, mCodecType);
1275       ret   = LogPlayerError(error);
1276       if(ret)
1277       {
1278         DALI_LOG_ERROR("SetCodecType, player_set_video_codec_type() is failed\n");
1279       }
1280     }
1281   }
1282 }
1283
1284 Dali::VideoPlayerPlugin::CodecType TizenVideoPlayer::GetCodecType() const
1285 {
1286   Dali::VideoPlayerPlugin::CodecType type = Dali::VideoPlayerPlugin::CodecType::HW;
1287   int                                ret  = 0;
1288   if(mPlayerState != PLAYER_STATE_NONE)
1289   {
1290     player_codec_type_e codecType = PLAYER_CODEC_TYPE_HW;
1291     int                          error     = player_get_video_codec_type(mPlayer, &codecType);
1292     if(error != PLAYER_ERROR_NONE)
1293     {
1294       ret = LogPlayerError(error);
1295       if(ret)
1296       {
1297         DALI_LOG_ERROR("GetCodecType, player_get_video_codec_type() is failed\n");
1298       }
1299       return type;
1300     }
1301
1302     switch(codecType)
1303     {
1304       case PLAYER_CODEC_TYPE_HW:
1305       {
1306         type = Dali::VideoPlayerPlugin::CodecType::HW;
1307         break;
1308       }
1309       case PLAYER_CODEC_TYPE_SW:
1310       {
1311         type = Dali::VideoPlayerPlugin::CodecType::SW;
1312         break;
1313       }
1314       default:
1315       {
1316         type = Dali::VideoPlayerPlugin::CodecType::HW;
1317         break;
1318       }
1319     }
1320   }
1321   return type;
1322 }
1323
1324 void TizenVideoPlayer::SetDisplayMode(Dali::VideoPlayerPlugin::DisplayMode::Type mode)
1325 {
1326   int error;
1327   error   = player_set_display_mode(mPlayer, static_cast<player_display_mode_e>(mode));
1328   int ret = LogPlayerError(error);
1329   if(ret)
1330   {
1331     DALI_LOG_ERROR("SetDisplayMode, player_set_display_mode() is failed\n");
1332   }
1333 }
1334
1335 Dali::VideoPlayerPlugin::DisplayMode::Type TizenVideoPlayer::GetDisplayMode() const
1336 {
1337   player_display_mode_e mode;
1338   player_get_display_mode(mPlayer, &mode);
1339   return static_cast<Dali::VideoPlayerPlugin::DisplayMode::Type>(mode);
1340 }
1341
1342 Any TizenVideoPlayer::GetMediaPlayer()
1343 {
1344   mIsMovedHandle = true;
1345   return Any((void*)mPlayer);
1346 }
1347
1348 void TizenVideoPlayer::StartSynchronization()
1349 {
1350   DALI_LOG_RELEASE_INFO("sync VideoPlayer\n");
1351   ecore_wl2_subsurface_sync_set(mEcoreSubVideoWindow, EINA_TRUE);
1352 }
1353
1354 void TizenVideoPlayer::FinishSynchronization()
1355 {
1356   // Finish
1357   DALI_LOG_RELEASE_INFO("desync VideoPlayer\n");
1358   ecore_wl2_subsurface_sync_set(mEcoreSubVideoWindow, EINA_FALSE);
1359 }
1360
1361 void TizenVideoPlayer::CreateConstraint()
1362 {
1363   if(mVideoSizePropertyIndex == Property::INVALID_INDEX)
1364   {
1365     if(mVideoSizePropertyConstraint)
1366     {
1367       mVideoSizePropertyConstraint.Remove();
1368     }
1369
1370     Actor syncActor = mSyncActor.GetHandle();
1371     if(syncActor)
1372     {
1373       mVideoSizePropertyIndex = syncActor.RegisterProperty(VIDEO_PLAYER_SIZE_NAME, Vector3::ZERO);
1374
1375       int                width, height;
1376       Ecore_Wl2_Display* wl2_display = ecore_wl2_connected_display_get(NULL);
1377       ecore_wl2_display_screen_size_get(wl2_display, &width, &height);
1378
1379       mVideoSizePropertyConstraint = Constraint::New<Vector3>(syncActor,
1380                                                               mVideoSizePropertyIndex,
1381                                                               VideoPlayerSyncConstraint(mEcoreSubVideoWindow, width, height));
1382
1383       mVideoSizePropertyConstraint.AddSource(LocalSource(Actor::Property::SIZE));
1384       mVideoSizePropertyConstraint.AddSource(LocalSource(Actor::Property::WORLD_SCALE));
1385       mVideoSizePropertyConstraint.AddSource(LocalSource(Actor::Property::WORLD_POSITION));
1386
1387       mVideoSizePropertyConstraint.Apply();
1388     }
1389   }
1390 }
1391
1392 void TizenVideoPlayer::DestroyConstraint()
1393 {
1394   if(mVideoSizePropertyIndex != Property::INVALID_INDEX)
1395   {
1396     mVideoSizePropertyConstraint.Remove();
1397     mVideoSizePropertyIndex = Property::INVALID_INDEX;
1398   }
1399 }
1400
1401 void TizenVideoPlayer::RaiseAbove(Any videoSurface)
1402 {
1403   Ecore_Wl2_Subsurface* surface = AnyCast<Ecore_Wl2_Subsurface*>(videoSurface);
1404   ecore_wl2_subsurface_place_surface_above(mEcoreSubVideoWindow, surface);
1405 }
1406
1407 void TizenVideoPlayer::LowerBelow(Any videoSurface)
1408 {
1409   Ecore_Wl2_Subsurface* surface = AnyCast<Ecore_Wl2_Subsurface*>(videoSurface);
1410   ecore_wl2_subsurface_place_surface_below(mEcoreSubVideoWindow, surface);
1411 }
1412
1413 void TizenVideoPlayer::RaiseToTop()
1414 {
1415   ecore_wl2_subsurface_place_surface_above(mEcoreSubVideoWindow, NULL);
1416 }
1417
1418 void TizenVideoPlayer::LowerToBottom()
1419 {
1420   ecore_wl2_subsurface_place_surface_below(mEcoreSubVideoWindow, NULL);
1421 }
1422
1423 Any TizenVideoPlayer::GetVideoPlayerSurface()
1424 {
1425   return mEcoreSubVideoWindow;
1426 }
1427
1428 } // namespace Plugin
1429 } // namespace Dali