automated-tests/src/dali-toolkit/utc-Dali-VideoView.cpp

   1 /*
   2  * Copyright (c) 2020 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 #include <iostream>
  19 #include <stdlib.h>
  20 #include <dali-toolkit-test-suite-utils.h>
  21 #include <dali-toolkit/dali-toolkit.h>
  22 #include <dali-toolkit/public-api/controls/video-view/video-view.h>
  23 #include <dali-toolkit/devel-api/controls/video-view/video-view-devel.h>
  24 #include <dali/devel-api/adaptor-framework/window-devel.h>
  25 #include <dali/devel-api/adaptor-framework/video-sync-mode.h>
  26
  27 using namespace Dali;
  28 using namespace Dali::Toolkit;
  29
  30 namespace
  31 {
  32 const char* const TEST_FILE( "test.mp4" );
  33 const char* const VOLUME_LEFT( "volumeLeft" );
  34 const char* const VOLUME_RIGHT( "volumeRight" );
  35 const char* const RENDERING_TYPE( "renderingTarget" );
  36 const char* const DUMMY_STRING( "dummy string" );
  37
  38 const char* VERTEX_SHADER = DALI_COMPOSE_SHADER(
  39   attribute mediump vec2 aPosition;\n
  40   varying mediump vec2 vTexCoord;\n
  41   uniform mediump mat4 uMvpMatrix;\n
  42   uniform mediump vec3 uSize;\n
  43   \n
  44   void main()\n
  45   {\n
  46     mediump vec4 vertexPosition = vec4(aPosition, 0.0, 1.0);\n
  47     vertexPosition.xyz *= uSize;\n
  48     vertexPosition = uMvpMatrix * vertexPosition;\n
  49     \n
  50     vTexCoord = aPosition + vec2(0.5);\n
  51     gl_Position = vertexPosition;\n
  52   }\n
  53 );
  54
  55 const char* fragmentShaderPrefix( "#extension GL_OES_EGL_image_external:require\n" );
  56 const char* FRAGMENT_SHADER = DALI_COMPOSE_SHADER(
  57   varying mediump vec2 vTexCoord;\n
  58   uniform samplerExternalOES sTexture;\n
  59   uniform lowp vec4 uColor;\n
  60   \n
  61   void main()\n
  62   {\n
  63     gl_FragColor = texture2D( sTexture, vTexCoord ) * uColor;\n
  64   }\n
  65 );
  66
  67 }
  68
  69 void video_view_startup(void)
  70 {
  71   test_return_value = TET_UNDEF;
  72 }
  73
  74 void video_view_cleanup(void)
  75 {
  76   test_return_value = TET_PASS;
  77 }
  78
  79 // Negative test case for a method
  80 int UtcDaliVideoViewUninitialized(void)
  81 {
  82   ToolkitTestApplication application;
  83   tet_infoline(" UtcDaliVideoViewUninitialized");
  84
  85   Toolkit::VideoView view;
  86
  87   try
  88   {
  89     // New() must be called to create a VideoView or it wont be valid.
  90     Actor a = Actor::New();
  91     view.Add( a );
  92     DALI_TEST_CHECK( false );
  93   }
  94   catch (Dali::DaliException& e)
  95   {
  96     // Tests that a negative test of an assertion succeeds
  97     DALI_TEST_PRINT_ASSERT( e );
  98     DALI_TEST_CHECK(!view);
  99   }
 100   END_TEST;
 101 }
 102
 103 // Positive test case for a method
 104 int UtcDaliVideoViewNew(void)
 105 {
 106   ToolkitTestApplication application;
 107   tet_infoline(" UtcDaliVideoViewNew");
 108
 109   Toolkit::VideoView view = Toolkit::VideoView::New();
 110   DALI_TEST_CHECK( view );
 111
 112   const std::string url( DUMMY_STRING );
 113   Toolkit::VideoView view2 = Toolkit::VideoView::New( url );
 114   DALI_TEST_CHECK( view2 );
 115   END_TEST;
 116 }
 117
 118 // Positive test case for a method
 119 int UtcDaliVideoViewDownCast(void)
 120 {
 121   ToolkitTestApplication application;
 122   tet_infoline(" UtcDaliVideoViewDownCast");
 123
 124   Toolkit::VideoView view = Toolkit::VideoView::New();
 125   BaseHandle handle(view);
 126
 127   Toolkit::VideoView view2 = Toolkit::VideoView::DownCast( handle );
 128   DALI_TEST_CHECK( view );
 129   DALI_TEST_CHECK( view2 );
 130   DALI_TEST_CHECK( view == view2 );
 131   END_TEST;
 132 }
 133
 134 // Positive test case for a method
 135 int UtcDaliVideoViewProperty1(void)
 136 {
 137   ToolkitTestApplication application;
 138   tet_infoline(" UtcDaliVideoViewProperty1");
 139
 140   Toolkit::VideoView view = Toolkit::VideoView::New();
 141   DALI_TEST_CHECK( view );
 142
 143   std::string file;
 144   view.SetProperty( VideoView::Property::VIDEO, TEST_FILE );
 145   Property::Value val = view.GetProperty( VideoView::Property::VIDEO );
 146   DALI_TEST_CHECK( val.Get( file ) );
 147   DALI_TEST_CHECK( file == TEST_FILE );
 148   END_TEST;
 149 }
 150
 151 // Positive test case for a method
 152 int UtcDaliVideoViewProperty1b(void)
 153 {
 154   ToolkitTestApplication application;
 155   tet_infoline(" UtcDaliVideoViewProperty1");
 156
 157   Toolkit::VideoView view = Toolkit::VideoView::New();
 158   DALI_TEST_CHECK( view );
 159   Integration::Scene stage = application.GetScene();
 160
 161   std::string file;
 162   Property::Map map;
 163
 164   view.SetProperty( VideoView::Property::VIDEO, Property::Map()
 165                     .Add("rendererType", "IMAGE")
 166                     .Add("url", "video.mpg") // Note, videoView doesn't use this url
 167                     .Add("RENDERING_TARGET", "windowSurfaceTarget" )
 168                     .Add("width", 100)
 169                     .Add("height", 100) );
 170
 171   stage.Add( view );
 172
 173   Property::Value val = view.GetProperty( VideoView::Property::VIDEO );
 174   Property::Map* resultMap = val.GetMap();
 175
 176   DALI_TEST_CHECK( resultMap );
 177   Property::Value* value = resultMap->Find("url");
 178   DALI_TEST_CHECK( value );
 179   DALI_TEST_EQUALS( value->Get<std::string>(), "video.mpg", TEST_LOCATION );
 180
 181   stage.Remove( view );
 182
 183   END_TEST;
 184 }
 185
 186 int UtcDaliVideoViewProperty2(void)
 187 {
 188   ToolkitTestApplication application;
 189   tet_infoline(" UtcDaliVideoViewProperty2");
 190
 191   Toolkit::VideoView view = Toolkit::VideoView::New();
 192   DALI_TEST_CHECK( view );
 193
 194   bool looping;
 195   Property::Value val = view.GetProperty( VideoView::Property::LOOPING );
 196   DALI_TEST_CHECK( val.Get( looping ) );
 197   DALI_TEST_CHECK( !looping );
 198
 199   view.SetProperty( VideoView::Property::LOOPING, true );
 200   val = view.GetProperty( VideoView::Property::LOOPING );
 201   DALI_TEST_CHECK( val.Get( looping ) );
 202   DALI_TEST_CHECK( looping );
 203   END_TEST;
 204 }
 205
 206 int UtcDaliVideoViewProperty3(void)
 207 {
 208   ToolkitTestApplication application;
 209   tet_infoline(" UtcDaliVideoViewProperty3");
 210
 211   Toolkit::VideoView view = Toolkit::VideoView::New();
 212   DALI_TEST_CHECK( view );
 213
 214   bool muted;
 215   Property::Value val = view.GetProperty( VideoView::Property::MUTED );
 216   DALI_TEST_CHECK( val.Get( muted ) );
 217   DALI_TEST_CHECK( !muted );
 218
 219   view.SetProperty( VideoView::Property::MUTED, true );
 220   val = view.GetProperty( VideoView::Property::MUTED );
 221   DALI_TEST_CHECK( val.Get( muted ) );
 222   DALI_TEST_CHECK( muted );
 223
 224   END_TEST;
 225 }
 226
 227 int UtcDaliVideoViewProperty4(void)
 228 {
 229   ToolkitTestApplication application;
 230   tet_infoline(" UtcDaliVideoViewProperty4");
 231
 232   Toolkit::VideoView view = Toolkit::VideoView::New();
 233   DALI_TEST_CHECK( view );
 234
 235   float left, right;
 236   left = right = 0.f;
 237
 238   Property::Map map;
 239   map.Insert( VOLUME_LEFT, 0.5f );
 240   map.Insert( VOLUME_RIGHT, 0.5f );
 241
 242   view.SetProperty( VideoView::Property::VOLUME, map );
 243   Property::Value val = view.GetProperty( VideoView::Property::VOLUME );
 244
 245   Property::Map map2;
 246   DALI_TEST_CHECK( val.Get( map2 ) );
 247
 248   Property::Value* volumeLeft = map2.Find( VOLUME_LEFT );
 249   Property::Value* volumeRight = map2.Find( VOLUME_RIGHT );
 250
 251   DALI_TEST_CHECK( volumeLeft && volumeLeft->Get( left ) );
 252   DALI_TEST_CHECK( volumeRight && volumeRight->Get( right ) );
 253   DALI_TEST_CHECK( left == 0.5f );
 254   DALI_TEST_CHECK( right == 0.5f );
 255
 256   END_TEST;
 257 }
 258
 259 int UtcDaliVideoViewCopyAndAssignment(void)
 260 {
 261   ToolkitTestApplication application;
 262
 263   VideoView view = Toolkit::VideoView::New();
 264   DALI_TEST_CHECK( view );
 265
 266   VideoView copy( view );
 267   DALI_TEST_CHECK( view == copy );
 268
 269   VideoView assign;
 270   DALI_TEST_CHECK( !assign );
 271
 272   assign = copy;
 273   DALI_TEST_CHECK( assign == view );
 274
 275   END_TEST;
 276 }
 277
 278 int UtcDaliVideoViewMoveConstructor(void)
 279 {
 280   ToolkitTestApplication application;
 281
 282   VideoView view = Toolkit::VideoView::New();
 283   DALI_TEST_EQUALS( 1, view.GetBaseObject().ReferenceCount(), TEST_LOCATION );
 284   view.SetProperty( VideoView::Property::LOOPING, true );
 285   DALI_TEST_CHECK( view.GetProperty<bool>( VideoView::Property::LOOPING ) );
 286
 287   VideoView moved = std::move( view );
 288   DALI_TEST_CHECK( moved );
 289   DALI_TEST_EQUALS( 1, moved.GetBaseObject().ReferenceCount(), TEST_LOCATION );
 290   DALI_TEST_CHECK( moved.GetProperty<bool>( VideoView::Property::LOOPING ) );
 291   DALI_TEST_CHECK( !view );
 292
 293   END_TEST;
 294 }
 295
 296 int UtcDaliVideoViewMoveAssignment(void)
 297 {
 298   ToolkitTestApplication application;
 299
 300   VideoView view = Toolkit::VideoView::New();
 301   DALI_TEST_EQUALS( 1, view.GetBaseObject().ReferenceCount(), TEST_LOCATION );
 302   view.SetProperty( VideoView::Property::LOOPING, true );
 303   DALI_TEST_CHECK( view.GetProperty<bool>( VideoView::Property::LOOPING ) );
 304
 305   VideoView moved;
 306   moved = std::move( view );
 307   DALI_TEST_CHECK( moved );
 308   DALI_TEST_EQUALS( 1, moved.GetBaseObject().ReferenceCount(), TEST_LOCATION );
 309   DALI_TEST_CHECK( moved.GetProperty<bool>( VideoView::Property::LOOPING ) );
 310   DALI_TEST_CHECK( !view );
 311
 312   END_TEST;
 313 }
 314
 315 int UtcDaliVideoViewTypeRegistry(void)
 316 {
 317   ToolkitTestApplication application;
 318
 319   TypeRegistry typeRegistry = TypeRegistry::Get();
 320   DALI_TEST_CHECK( typeRegistry );
 321
 322   TypeInfo typeInfo = typeRegistry.GetTypeInfo( "VideoView" );
 323   DALI_TEST_CHECK( typeInfo );
 324
 325   BaseHandle handle = typeInfo.CreateInstance();
 326   DALI_TEST_CHECK( handle );
 327
 328   VideoView view = VideoView::DownCast( handle );
 329   DALI_TEST_CHECK( view );
 330
 331   END_TEST;
 332 }
 333
 334 int UtcDaliVideoViewMethodsForCoverage(void)
 335 {
 336   ToolkitTestApplication application;
 337
 338   VideoView videoView = VideoView::New();
 339   DALI_TEST_CHECK( videoView );
 340
 341   videoView.Play();
 342   videoView.Pause();
 343   videoView.Stop();
 344   videoView.Forward(10);
 345   videoView.Backward(10);
 346
 347   Toolkit::DevelVideoView::GetMediaPlayer( videoView );
 348
 349   VideoView::VideoViewSignalType& signal = videoView.FinishedSignal();
 350   DALI_TEST_EQUALS( 0, signal.GetConnectionCount(), TEST_LOCATION );
 351
 352   END_TEST;
 353 }
 354
 355 int UtcDaliVideoViewMethodsForRenderType(void)
 356 {
 357   ToolkitTestApplication application;
 358   VideoView videoView = VideoView::New();
 359   DALI_TEST_CHECK( videoView );
 360
 361   Property::Map windowSurfaceTarget;
 362   Property::Map nativeImageTarget;
 363
 364   windowSurfaceTarget.Insert( RENDERING_TYPE, "windowSurfaceTarget" );
 365   nativeImageTarget.Insert( RENDERING_TYPE, "nativeImageTarget" );
 366
 367   Property::Map map;
 368   Property::Value value;
 369   videoView.SetProperty( VideoView::Property::VIDEO, windowSurfaceTarget );
 370
 371   value = videoView.GetProperty( VideoView::Property::VIDEO );
 372   DALI_TEST_CHECK( value.Get( map ) );
 373
 374   Property::Value* type = map.Find( RENDERING_TYPE );
 375   DALI_TEST_CHECK( type );
 376   DALI_TEST_EQUALS( "windowSurfaceTarget", type->Get<std::string>(), TEST_LOCATION );
 377
 378   videoView.SetProperty( VideoView::Property::VIDEO, nativeImageTarget );
 379
 380   value = videoView.GetProperty( VideoView::Property::VIDEO );
 381   DALI_TEST_CHECK( value.Get( map ) );
 382   type = map.Find( RENDERING_TYPE );
 383
 384   DALI_TEST_CHECK( type );
 385   DALI_TEST_EQUALS( "nativeImageTarget", type->Get<std::string>(), TEST_LOCATION );
 386
 387   END_TEST;
 388 }
 389
 390 int UtcDaliVideoViewCustomShaderForCoverage(void)
 391 {
 392   ToolkitTestApplication application;
 393   VideoView videoView = VideoView::New();
 394   DALI_TEST_CHECK( videoView );
 395
 396   ToolkitApplication::DECODED_IMAGES_SUPPORTED = true;
 397
 398   videoView.SetProperty( Toolkit::VideoView::Property::UNDERLAY, false );
 399   bool isUnderlay = videoView.GetProperty( Toolkit::VideoView::Property::UNDERLAY ).Get< bool >();
 400   DALI_TEST_CHECK( !isUnderlay );
 401
 402   application.GetScene().Add( videoView );
 403   videoView.SetProperty( VideoView::Property::VIDEO, "testvideo" );
 404
 405   Property::Map customShader;
 406   customShader.Insert( "vertexShader", VERTEX_SHADER );
 407   customShader.Insert( "fragmentShader", FRAGMENT_SHADER );
 408
 409   Property::Map map;
 410   map.Insert( "shader", customShader );
 411
 412   videoView.SetProperty( VideoView::Property::VIDEO, map );
 413
 414   Property::Map map2;
 415   Property::Value value = videoView.GetProperty( VideoView::Property::VIDEO );
 416
 417   DALI_TEST_CHECK( !value.Get( map2 ) );
 418   END_TEST;
 419 }
 420
 421 int UtcDaliVideoViewMethodsForCoverage2(void)
 422 {
 423   ToolkitTestApplication application;
 424   VideoView videoView = VideoView::New();
 425   DALI_TEST_CHECK( videoView );
 426
 427   Property::Map windowSurfaceTarget;
 428
 429   windowSurfaceTarget.Insert( RENDERING_TYPE, "windowSurfaceTarget" );
 430
 431   application.GetScene().Add( videoView );
 432
 433   application.SendNotification();
 434   application.Render();
 435
 436   Property::Map map;
 437   Property::Value value;
 438   videoView.SetProperty( VideoView::Property::VIDEO, windowSurfaceTarget );
 439
 440   value = videoView.GetProperty( VideoView::Property::VIDEO );
 441   DALI_TEST_CHECK( value.Get( map ) );
 442
 443   Property::Value* type = map.Find( RENDERING_TYPE );
 444   DALI_TEST_CHECK( type );
 445   DALI_TEST_EQUALS( "windowSurfaceTarget", type->Get<std::string>(), TEST_LOCATION );
 446
 447   Vector3 vector(100.0f, 100.0f, 0.0f);
 448
 449   DALI_TEST_CHECK(vector != videoView.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ));
 450   videoView.SetProperty( Actor::Property::SIZE, vector );
 451
 452   application.SendNotification();
 453   application.Render();
 454
 455   // Check the size in the new frame
 456   DALI_TEST_CHECK(vector == videoView.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ));
 457
 458   END_TEST;
 459 }
 460
 461 int UtcDaliVideoViewCustomShaderForCoverage3(void)
 462 {
 463   ToolkitTestApplication application;
 464   VideoView videoView = VideoView::New();
 465   DALI_TEST_CHECK( videoView );
 466
 467   ToolkitApplication::DECODED_IMAGES_SUPPORTED = true;
 468
 469   videoView.SetProperty( Toolkit::VideoView::Property::UNDERLAY, false );
 470   bool isUnderlay = videoView.GetProperty( Toolkit::VideoView::Property::UNDERLAY ).Get< bool >();
 471   DALI_TEST_CHECK( !isUnderlay );
 472
 473   application.GetScene().Add( videoView );
 474   videoView.SetProperty( VideoView::Property::VIDEO, "testvideo" );
 475
 476   Property::Map customShader;
 477   customShader.Insert( "vertexShader", VERTEX_SHADER );
 478
 479   Property::Map map;
 480   map.Insert( "shader", customShader );
 481
 482   videoView.SetProperty( VideoView::Property::VIDEO, map );
 483
 484   Property::Map map2;
 485   Property::Value value = videoView.GetProperty( VideoView::Property::VIDEO );
 486
 487   DALI_TEST_CHECK( !value.Get( map2 ) );
 488   END_TEST;
 489 }
 490
 491 int UtcDaliVideoViewPropertyUnderlay(void)
 492 {
 493   ToolkitTestApplication application;
 494   tet_infoline("UtcDaliVideoViewPropertyUnderlay");
 495   ToolkitApplication::DECODED_IMAGES_SUPPORTED = true;
 496
 497   VideoView view = VideoView::New();
 498   DALI_TEST_CHECK( view );
 499
 500   application.GetScene().Add( view );
 501   view.Play();
 502
 503   application.SendNotification();
 504   application.Render();
 505
 506   bool isUnderlay = view.GetProperty( Toolkit::VideoView::Property::UNDERLAY ).Get< bool >();
 507   DALI_TEST_CHECK( isUnderlay );
 508
 509   view.Play();
 510   view.SetProperty( Toolkit::VideoView::Property::UNDERLAY, false );
 511   isUnderlay = view.GetProperty( Toolkit::VideoView::Property::UNDERLAY ).Get< bool >();
 512   DALI_TEST_CHECK( !isUnderlay );
 513
 514   view.Play();
 515   view.SetProperty( Toolkit::VideoView::Property::UNDERLAY, true );
 516   isUnderlay = view.GetProperty( Toolkit::VideoView::Property::UNDERLAY ).Get< bool >();
 517   DALI_TEST_CHECK( isUnderlay );
 518
 519   // If platform api doesn't provide any API or feature for decoded images of video,
 520   // UNDERLAY should be true
 521   ToolkitApplication::DECODED_IMAGES_SUPPORTED = false;
 522
 523   view.SetProperty( Toolkit::VideoView::Property::UNDERLAY, false );
 524   isUnderlay = view.GetProperty( Toolkit::VideoView::Property::UNDERLAY ).Get< bool >();
 525   DALI_TEST_CHECK( isUnderlay );
 526
 527   // For coverage
 528   ToolkitApplication::DECODED_IMAGES_SUPPORTED = true;
 529
 530   view.SetProperty( Toolkit::VideoView::Property::UNDERLAY, true );
 531   view.SetProperty( Toolkit::VideoView::Property::UNDERLAY, false );
 532   isUnderlay = view.GetProperty( Toolkit::VideoView::Property::UNDERLAY ).Get< bool >();
 533   DALI_TEST_CHECK( !isUnderlay );
 534
 535   view.Stop();
 536
 537   END_TEST;
 538 }
 539
 540 int UtcDaliVideoViewPropertyPlayPosition(void)
 541 {
 542   ToolkitTestApplication application;
 543   tet_infoline("UtcDaliVideoViewPropertyPlayPosition");
 544
 545   VideoView view = VideoView::New();
 546   DALI_TEST_CHECK( view );
 547
 548   application.GetScene().Add( view );
 549   view.Play();
 550
 551   application.SendNotification();
 552   application.Render();
 553
 554   int playPos = view.GetProperty( Toolkit::VideoView::Property::PLAY_POSITION ).Get< int >();
 555   DALI_TEST_CHECK( playPos == 0 );
 556
 557   view.SetProperty( Toolkit::VideoView::Property::PLAY_POSITION, 10 );
 558   playPos = view.GetProperty( Toolkit::VideoView::Property::PLAY_POSITION ).Get< int >();
 559   // Actually setting play position will be async
 560   // Actual platform result may be different.
 561   DALI_TEST_CHECK( playPos == 10 );
 562
 563   END_TEST;
 564 }
 565
 566 // For coverage.
 567 int UtcDaliVideoViewNew2(void)
 568 {
 569   ToolkitTestApplication application;
 570   tet_infoline("UtcDaliVideoViewNew2");
 571
 572   VideoView view = VideoView::New( true );
 573   DALI_TEST_CHECK( view );
 574
 575   application.GetScene().Add( view );
 576   view.Play();
 577
 578   application.SendNotification();
 579   application.Render();
 580
 581   VideoView view2 = VideoView::New( "", false );
 582   DALI_TEST_CHECK( view2 );
 583
 584   application.GetScene().Add( view2 );
 585   view2.Play();
 586
 587   application.SendNotification();
 588   application.Render();
 589
 590   END_TEST;
 591 }
 592
 593 int UtcDaliVideoViewRaiseAboveLowerBelow(void)
 594 {
 595   ToolkitTestApplication application;
 596   tet_infoline("UtcDaliVideoViewRaiseAboveLowerBelow");
 597
 598   VideoView view = VideoView::New( true );
 599   DALI_TEST_CHECK( view );
 600
 601   application.GetScene().Add( view );
 602   view.Play();
 603
 604   application.SendNotification();
 605   application.Render();
 606
 607   VideoView view2 = VideoView::New( "", false );
 608   DALI_TEST_CHECK( view2 );
 609
 610   application.GetScene().Add( view2 );
 611   view2.Play();
 612
 613   application.SendNotification();
 614   application.Render();
 615
 616   view.RaiseAbove(view2);
 617   view.LowerBelow(view2);
 618
 619   END_TEST;
 620 }
 621
 622 int UtcDaliVideoViewRaiseTopLowerBottom(void)
 623 {
 624   ToolkitTestApplication application;
 625   tet_infoline("UtcDaliVideoViewRaiseTopLowerBottom");
 626
 627   VideoView view = VideoView::New( true );
 628   DALI_TEST_CHECK( view );
 629
 630   application.GetScene().Add( view );
 631   view.Play();
 632
 633   application.SendNotification();
 634   application.Render();
 635
 636   VideoView view2 = VideoView::New( "", false );
 637   DALI_TEST_CHECK( view2 );
 638
 639   application.GetScene().Add( view2 );
 640   view2.Play();
 641
 642   application.SendNotification();
 643   application.Render();
 644
 645   view.RaiseToTop();
 646   view.LowerToBottom();
 647
 648   END_TEST;
 649 }
 650
 651
 652 int UtcDaliVideoViewPropertyDisplayMode(void)
 653 {
 654   ToolkitTestApplication application;
 655   tet_infoline("UtcDaliVideoViewPropertyDisplayMode");
 656
 657   VideoView view = VideoView::New();
 658   DALI_TEST_CHECK( view );
 659
 660   application.GetScene().Add( view );
 661   view.Play();
 662
 663   application.SendNotification();
 664   application.Render();
 665
 666   view.SetProperty( Toolkit::VideoView::Property::DISPLAY_MODE, Toolkit::VideoView::DisplayMode::DST_ROI );
 667   int displayMode = view.GetProperty( Toolkit::VideoView::Property::DISPLAY_MODE ).Get< int >();
 668   DALI_TEST_CHECK( displayMode == Toolkit::VideoView::DisplayMode::DST_ROI );
 669
 670   END_TEST;
 671 }
 672
 673
 674 int UtcDaliVideoViewCustomShader(void)
 675 {
 676   ToolkitTestApplication application;
 677   tet_infoline( "VideoView with custom shader" );
 678
 679   VideoView view = VideoView::New( false );
 680   DALI_TEST_CHECK( view );
 681
 682   ToolkitApplication::DECODED_IMAGES_SUPPORTED = true;
 683
 684   view.SetProperty( Toolkit::VideoView::Property::UNDERLAY, false );
 685   bool isUnderlay = view.GetProperty( Toolkit::VideoView::Property::UNDERLAY ).Get< bool >();
 686   DALI_TEST_CHECK( !isUnderlay );
 687
 688   application.GetScene().Add( view );
 689   view.SetProperty( VideoView::Property::VIDEO, "testvideo" );
 690
 691   /* insert custom shader */
 692   Property::Map customShader;
 693   std::string fragmentShaderString;
 694   fragmentShaderString.reserve( strlen( fragmentShaderPrefix ) + strlen( FRAGMENT_SHADER ) );
 695   fragmentShaderString.append( fragmentShaderPrefix );
 696   fragmentShaderString.append( FRAGMENT_SHADER );
 697   customShader.Insert( "vertexShader", VERTEX_SHADER );
 698   customShader.Insert( "fragmentShader", fragmentShaderString );
 699
 700   Property::Map map;
 701   map.Insert( "shader", customShader );
 702
 703   view.SetProperty( VideoView::Property::VIDEO, map );
 704
 705   /* do render for check custom shader */
 706   application.GetScene().Add( view );
 707   view.Play();
 708
 709   application.SendNotification();
 710   application.Render();
 711
 712   /* get renderer */
 713   DALI_TEST_CHECK( view.GetRendererCount() == 1u );
 714   Renderer renderer = view.GetRendererAt( 0 );
 715   Shader shader = renderer.GetShader();
 716   DALI_TEST_CHECK( shader );
 717
 718   Property::Value value = shader.GetProperty(Shader::Property::PROGRAM);
 719   Property::Map* shaderMap = value.GetMap();
 720   DALI_TEST_CHECK( shaderMap );
 721
 722   Property::Value* fragment = shaderMap->Find( "fragment" ); // fragment key name from shader-impl.cpp
 723   DALI_TEST_EQUALS( fragmentShaderString, fragment->Get<std::string>(), TEST_LOCATION );
 724
 725   Property::Value* vertex = shaderMap->Find( "vertex" ); // vertex key name from shader-impl.cpp
 726   DALI_TEST_EQUALS( VERTEX_SHADER, vertex->Get<std::string>(), TEST_LOCATION );
 727
 728   END_TEST;
 729 }
 730
 731 // Functor to test whether a Finish signal is emitted
 732 struct AnimationFinishCheck
 733 {
 734   AnimationFinishCheck(bool& signalReceived)
 735   : mSignalReceived(signalReceived)
 736   {
 737   }
 738
 739   void operator()(Animation& animation)
 740   {
 741     mSignalReceived = true;
 742   }
 743
 744   void Reset()
 745   {
 746     mSignalReceived = false;
 747   }
 748
 749   void CheckSignalReceived()
 750   {
 751     if (!mSignalReceived)
 752     {
 753       tet_printf("Expected Finish signal was not received\n");
 754       tet_result(TET_FAIL);
 755     }
 756     else
 757     {
 758       tet_result(TET_PASS);
 759     }
 760   }
 761
 762   void CheckSignalNotReceived()
 763   {
 764     if (mSignalReceived)
 765     {
 766       tet_printf("Unexpected Finish signal was received\n");
 767       tet_result(TET_FAIL);
 768     }
 769     else
 770     {
 771       tet_result(TET_PASS);
 772     }
 773   }
 774
 775   bool& mSignalReceived; // owned by individual tests
 776 };
 777
 778 int UtcDaliVideoViewSyncAniamtionForCoverage(void)
 779 {
 780   ToolkitTestApplication application;
 781
 782   VideoView videoView = DevelVideoView::New( Dali::VideoSyncMode::ENABLED );
 783   DALI_TEST_CHECK( videoView );
 784
 785   application.GetScene().Add( videoView );
 786
 787   // Build the animation
 788   float durationSeconds(1.0f);
 789   Animation animation = Animation::New(durationSeconds);
 790
 791   // Start the animation
 792   Vector3 targetPosition(10.0f, 10.0f, 10.0f);
 793   animation.AnimateTo(Property(videoView, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
 794   DevelVideoView::PlayAnimation( videoView, animation );
 795
 796   bool signalReceived(false);
 797   AnimationFinishCheck finishCheck(signalReceived);
 798   animation.FinishedSignal().Connect(&application, finishCheck);
 799
 800   application.SendNotification();
 801   application.Render(static_cast<unsigned int>(durationSeconds*1000.0f) - 1u/*just less than the animation duration*/);
 802
 803   // We didn't expect the animation to finish yet
 804   application.SendNotification();
 805   finishCheck.CheckSignalNotReceived();
 806
 807   application.Render(2u/*just beyond the animation duration*/);
 808
 809   // We did expect the animation to finish
 810   application.SendNotification();
 811   finishCheck.CheckSignalReceived();
 812   DALI_TEST_EQUALS( targetPosition, videoView.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), TEST_LOCATION );
 813
 814   // Restart the animation, with a different duration
 815   finishCheck.Reset();
 816
 817   END_TEST;
 818 }
 819
 820 int UtcDaliVideoViewASyncAniamtionForCoverage(void)
 821 {
 822   ToolkitTestApplication application;
 823
 824   VideoView videoView = DevelVideoView::New( Dali::VideoSyncMode::DISABLED );
 825   DALI_TEST_CHECK( videoView );
 826
 827   application.GetScene().Add( videoView );
 828
 829   // Build the animation
 830   float durationSeconds(1.0f);
 831   Animation animation = Animation::New(durationSeconds);
 832
 833   // Start the animation
 834   Vector3 targetPosition(10.0f, 10.0f, 10.0f);
 835   animation.AnimateTo(Property(videoView, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
 836   DevelVideoView::PlayAnimation( videoView, animation );
 837
 838   bool signalReceived(false);
 839   AnimationFinishCheck finishCheck(signalReceived);
 840   animation.FinishedSignal().Connect(&application, finishCheck);
 841
 842   application.SendNotification();
 843   application.Render(static_cast<unsigned int>(durationSeconds*1000.0f) - 1u/*just less than the animation duration*/);
 844
 845   // We didn't expect the animation to finish yet
 846   application.SendNotification();
 847   finishCheck.CheckSignalNotReceived();
 848
 849   application.Render(2u/*just beyond the animation duration*/);
 850
 851   // We did expect the animation to finish
 852   application.SendNotification();
 853   finishCheck.CheckSignalReceived();
 854   DALI_TEST_EQUALS( targetPosition, videoView.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), TEST_LOCATION );
 855
 856   // Restart the animation, with a different duration
 857   finishCheck.Reset();
 858
 859   END_TEST;
 860 }
 861
 862 int UtcDaliVideoViewResizeWithSynchronization(void)
 863 {
 864   ToolkitTestApplication application;
 865   VideoView videoView = DevelVideoView::New( Dali::VideoSyncMode::ENABLED );
 866   DALI_TEST_CHECK( videoView );
 867
 868   application.GetScene().Add( videoView );
 869
 870   Vector3 vector(50.0f, 200.0f, 0.0f);
 871   videoView.SetProperty( Actor::Property::SIZE, vector );
 872
 873   application.SendNotification();
 874   application.Render();
 875
 876   DALI_TEST_CHECK(vector == videoView.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ));
 877
 878   END_TEST;
 879 }
 880
 881 // For coverage.
 882 int UtcDaliVideoViewSynchronizationForWindowRotation(void)
 883 {
 884   ToolkitTestApplication application;
 885   tet_infoline("UtcDaliVideoViewSynchronizationForWindowRotation");
 886
 887   Window window = Window::New(PositionSize(0,0,100,100) ,"", false);
 888   DALI_TEST_CHECK( window );
 889
 890   VideoView view = VideoView::New( true );
 891   DALI_TEST_CHECK( view );
 892
 893   window.Add( view );
 894
 895   view.Play();
 896
 897   DevelWindow::SetPositionSize(window,PositionSize(0,0,480, 240));
 898
 899   application.SendNotification();
 900   application.Render();
 901
 902   END_TEST;
 903 }