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 UtcDaliVideoViewPropertyUnderlay(void)
 462 {
 463   ToolkitTestApplication application;
 464   tet_infoline("UtcDaliVideoViewPropertyUnderlay");
 465   ToolkitApplication::DECODED_IMAGES_SUPPORTED = true;
 466
 467   VideoView view = VideoView::New();
 468   DALI_TEST_CHECK( view );
 469
 470   application.GetScene().Add( view );
 471   view.Play();
 472
 473   application.SendNotification();
 474   application.Render();
 475
 476   bool isUnderlay = view.GetProperty( Toolkit::VideoView::Property::UNDERLAY ).Get< bool >();
 477   DALI_TEST_CHECK( isUnderlay );
 478
 479   view.Play();
 480   view.SetProperty( Toolkit::VideoView::Property::UNDERLAY, false );
 481   isUnderlay = view.GetProperty( Toolkit::VideoView::Property::UNDERLAY ).Get< bool >();
 482   DALI_TEST_CHECK( !isUnderlay );
 483
 484   view.Play();
 485   view.SetProperty( Toolkit::VideoView::Property::UNDERLAY, true );
 486   isUnderlay = view.GetProperty( Toolkit::VideoView::Property::UNDERLAY ).Get< bool >();
 487   DALI_TEST_CHECK( isUnderlay );
 488
 489   // If platform api doesn't provide any API or feature for decoded images of video,
 490   // UNDERLAY should be true
 491   ToolkitApplication::DECODED_IMAGES_SUPPORTED = false;
 492
 493   view.SetProperty( Toolkit::VideoView::Property::UNDERLAY, false );
 494   isUnderlay = view.GetProperty( Toolkit::VideoView::Property::UNDERLAY ).Get< bool >();
 495   DALI_TEST_CHECK( isUnderlay );
 496
 497   // For coverage
 498   ToolkitApplication::DECODED_IMAGES_SUPPORTED = true;
 499
 500   view.SetProperty( Toolkit::VideoView::Property::UNDERLAY, true );
 501   view.SetProperty( Toolkit::VideoView::Property::UNDERLAY, false );
 502   isUnderlay = view.GetProperty( Toolkit::VideoView::Property::UNDERLAY ).Get< bool >();
 503   DALI_TEST_CHECK( !isUnderlay );
 504
 505   view.Stop();
 506
 507   END_TEST;
 508 }
 509
 510 int UtcDaliVideoViewPropertyPlayPosition(void)
 511 {
 512   ToolkitTestApplication application;
 513   tet_infoline("UtcDaliVideoViewPropertyPlayPosition");
 514
 515   VideoView view = VideoView::New();
 516   DALI_TEST_CHECK( view );
 517
 518   application.GetScene().Add( view );
 519   view.Play();
 520
 521   application.SendNotification();
 522   application.Render();
 523
 524   int playPos = view.GetProperty( Toolkit::VideoView::Property::PLAY_POSITION ).Get< int >();
 525   DALI_TEST_CHECK( playPos == 0 );
 526
 527   view.SetProperty( Toolkit::VideoView::Property::PLAY_POSITION, 10 );
 528   playPos = view.GetProperty( Toolkit::VideoView::Property::PLAY_POSITION ).Get< int >();
 529   // Actually setting play position will be async
 530   // Actual platform result may be different.
 531   DALI_TEST_CHECK( playPos == 10 );
 532
 533   END_TEST;
 534 }
 535
 536 // For coverage.
 537 int UtcDaliVideoViewNew2(void)
 538 {
 539   ToolkitTestApplication application;
 540   tet_infoline("UtcDaliVideoViewNew2");
 541
 542   VideoView view = VideoView::New( true );
 543   DALI_TEST_CHECK( view );
 544
 545   application.GetScene().Add( view );
 546   view.Play();
 547
 548   application.SendNotification();
 549   application.Render();
 550
 551   VideoView view2 = VideoView::New( "", false );
 552   DALI_TEST_CHECK( view2 );
 553
 554   application.GetScene().Add( view2 );
 555   view2.Play();
 556
 557   application.SendNotification();
 558   application.Render();
 559
 560   END_TEST;
 561 }
 562
 563 int UtcDaliVideoViewRaiseAboveLowerBelow(void)
 564 {
 565   ToolkitTestApplication application;
 566   tet_infoline("UtcDaliVideoViewRaiseAboveLowerBelow");
 567
 568   VideoView view = VideoView::New( true );
 569   DALI_TEST_CHECK( view );
 570
 571   application.GetScene().Add( view );
 572   view.Play();
 573
 574   application.SendNotification();
 575   application.Render();
 576
 577   VideoView view2 = VideoView::New( "", false );
 578   DALI_TEST_CHECK( view2 );
 579
 580   application.GetScene().Add( view2 );
 581   view2.Play();
 582
 583   application.SendNotification();
 584   application.Render();
 585
 586   view.RaiseAbove(view2);
 587   view.LowerBelow(view2);
 588
 589   END_TEST;
 590 }
 591
 592 int UtcDaliVideoViewRaiseTopLowerBottom(void)
 593 {
 594   ToolkitTestApplication application;
 595   tet_infoline("UtcDaliVideoViewRaiseTopLowerBottom");
 596
 597   VideoView view = VideoView::New( true );
 598   DALI_TEST_CHECK( view );
 599
 600   application.GetScene().Add( view );
 601   view.Play();
 602
 603   application.SendNotification();
 604   application.Render();
 605
 606   VideoView view2 = VideoView::New( "", false );
 607   DALI_TEST_CHECK( view2 );
 608
 609   application.GetScene().Add( view2 );
 610   view2.Play();
 611
 612   application.SendNotification();
 613   application.Render();
 614
 615   view.RaiseToTop();
 616   view.LowerToBottom();
 617
 618   END_TEST;
 619 }
 620
 621
 622 int UtcDaliVideoViewPropertyDisplayMode(void)
 623 {
 624   ToolkitTestApplication application;
 625   tet_infoline("UtcDaliVideoViewPropertyDisplayMode");
 626
 627   VideoView view = VideoView::New();
 628   DALI_TEST_CHECK( view );
 629
 630   application.GetScene().Add( view );
 631   view.Play();
 632
 633   application.SendNotification();
 634   application.Render();
 635
 636   view.SetProperty( Toolkit::VideoView::Property::DISPLAY_MODE, Toolkit::VideoView::DisplayMode::DST_ROI );
 637   int displayMode = view.GetProperty( Toolkit::VideoView::Property::DISPLAY_MODE ).Get< int >();
 638   DALI_TEST_CHECK( displayMode == Toolkit::VideoView::DisplayMode::DST_ROI );
 639
 640   END_TEST;
 641 }
 642
 643
 644 int UtcDaliVideoViewCustomShader(void)
 645 {
 646   ToolkitTestApplication application;
 647   tet_infoline( "VideoView with custom shader" );
 648
 649   VideoView view = VideoView::New( false );
 650   DALI_TEST_CHECK( view );
 651
 652   ToolkitApplication::DECODED_IMAGES_SUPPORTED = true;
 653
 654   view.SetProperty( Toolkit::VideoView::Property::UNDERLAY, false );
 655   bool isUnderlay = view.GetProperty( Toolkit::VideoView::Property::UNDERLAY ).Get< bool >();
 656   DALI_TEST_CHECK( !isUnderlay );
 657
 658   application.GetScene().Add( view );
 659   view.SetProperty( VideoView::Property::VIDEO, "testvideo" );
 660
 661   /* insert custom shader */
 662   Property::Map customShader;
 663   std::string fragmentShaderString;
 664   fragmentShaderString.reserve( strlen( fragmentShaderPrefix ) + strlen( FRAGMENT_SHADER ) );
 665   fragmentShaderString.append( fragmentShaderPrefix );
 666   fragmentShaderString.append( FRAGMENT_SHADER );
 667   customShader.Insert( "vertexShader", VERTEX_SHADER );
 668   customShader.Insert( "fragmentShader", fragmentShaderString );
 669
 670   Property::Map map;
 671   map.Insert( "shader", customShader );
 672
 673   view.SetProperty( VideoView::Property::VIDEO, map );
 674
 675   /* do render for check custom shader */
 676   application.GetScene().Add( view );
 677   view.Play();
 678
 679   application.SendNotification();
 680   application.Render();
 681
 682   /* get renderer */
 683   DALI_TEST_CHECK( view.GetRendererCount() == 1u );
 684   Renderer renderer = view.GetRendererAt( 0 );
 685   Shader shader = renderer.GetShader();
 686   DALI_TEST_CHECK( shader );
 687
 688   Property::Value value = shader.GetProperty(Shader::Property::PROGRAM);
 689   Property::Map* shaderMap = value.GetMap();
 690   DALI_TEST_CHECK( shaderMap );
 691
 692   Property::Value* fragment = shaderMap->Find( "fragment" ); // fragment key name from shader-impl.cpp
 693   DALI_TEST_EQUALS( fragmentShaderString, fragment->Get<std::string>(), TEST_LOCATION );
 694
 695   Property::Value* vertex = shaderMap->Find( "vertex" ); // vertex key name from shader-impl.cpp
 696   DALI_TEST_EQUALS( VERTEX_SHADER, vertex->Get<std::string>(), TEST_LOCATION );
 697
 698   END_TEST;
 699 }
 700
 701 // Functor to test whether a Finish signal is emitted
 702 struct AnimationFinishCheck
 703 {
 704   AnimationFinishCheck(bool& signalReceived)
 705   : mSignalReceived(signalReceived)
 706   {
 707   }
 708
 709   void operator()(Animation& animation)
 710   {
 711     mSignalReceived = true;
 712   }
 713
 714   void Reset()
 715   {
 716     mSignalReceived = false;
 717   }
 718
 719   void CheckSignalReceived()
 720   {
 721     if (!mSignalReceived)
 722     {
 723       tet_printf("Expected Finish signal was not received\n");
 724       tet_result(TET_FAIL);
 725     }
 726     else
 727     {
 728       tet_result(TET_PASS);
 729     }
 730   }
 731
 732   void CheckSignalNotReceived()
 733   {
 734     if (mSignalReceived)
 735     {
 736       tet_printf("Unexpected Finish signal was received\n");
 737       tet_result(TET_FAIL);
 738     }
 739     else
 740     {
 741       tet_result(TET_PASS);
 742     }
 743   }
 744
 745   bool& mSignalReceived; // owned by individual tests
 746 };
 747
 748 int UtcDaliVideoViewSyncAniamtionForCoverage(void)
 749 {
 750   ToolkitTestApplication application;
 751
 752   VideoView videoView = DevelVideoView::New( Dali::VideoSyncMode::ENABLED );
 753   DALI_TEST_CHECK( videoView );
 754
 755   application.GetScene().Add( videoView );
 756
 757   // Build the animation
 758   float durationSeconds(1.0f);
 759   Animation animation = Animation::New(durationSeconds);
 760
 761   // Start the animation
 762   Vector3 targetPosition(10.0f, 10.0f, 10.0f);
 763   animation.AnimateTo(Property(videoView, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
 764   DevelVideoView::PlayAnimation( videoView, animation );
 765
 766   bool signalReceived(false);
 767   AnimationFinishCheck finishCheck(signalReceived);
 768   animation.FinishedSignal().Connect(&application, finishCheck);
 769
 770   application.SendNotification();
 771   application.Render(static_cast<unsigned int>(durationSeconds*1000.0f) - 1u/*just less than the animation duration*/);
 772
 773   // We didn't expect the animation to finish yet
 774   application.SendNotification();
 775   finishCheck.CheckSignalNotReceived();
 776
 777   application.Render(2u/*just beyond the animation duration*/);
 778
 779   // We did expect the animation to finish
 780   application.SendNotification();
 781   finishCheck.CheckSignalReceived();
 782   DALI_TEST_EQUALS( targetPosition, videoView.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), TEST_LOCATION );
 783
 784   // Restart the animation, with a different duration
 785   finishCheck.Reset();
 786
 787   END_TEST;
 788 }
 789
 790 int UtcDaliVideoViewASyncAniamtionForCoverage(void)
 791 {
 792   ToolkitTestApplication application;
 793
 794   VideoView videoView = DevelVideoView::New( Dali::VideoSyncMode::DISABLED );
 795   DALI_TEST_CHECK( videoView );
 796
 797   application.GetScene().Add( videoView );
 798
 799   // Build the animation
 800   float durationSeconds(1.0f);
 801   Animation animation = Animation::New(durationSeconds);
 802
 803   // Start the animation
 804   Vector3 targetPosition(10.0f, 10.0f, 10.0f);
 805   animation.AnimateTo(Property(videoView, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
 806   DevelVideoView::PlayAnimation( videoView, animation );
 807
 808   bool signalReceived(false);
 809   AnimationFinishCheck finishCheck(signalReceived);
 810   animation.FinishedSignal().Connect(&application, finishCheck);
 811
 812   application.SendNotification();
 813   application.Render(static_cast<unsigned int>(durationSeconds*1000.0f) - 1u/*just less than the animation duration*/);
 814
 815   // We didn't expect the animation to finish yet
 816   application.SendNotification();
 817   finishCheck.CheckSignalNotReceived();
 818
 819   application.Render(2u/*just beyond the animation duration*/);
 820
 821   // We did expect the animation to finish
 822   application.SendNotification();
 823   finishCheck.CheckSignalReceived();
 824   DALI_TEST_EQUALS( targetPosition, videoView.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), TEST_LOCATION );
 825
 826   // Restart the animation, with a different duration
 827   finishCheck.Reset();
 828
 829   END_TEST;
 830 }
 831
 832 int UtcDaliVideoViewResizeWithSynchronization(void)
 833 {
 834   ToolkitTestApplication application;
 835   VideoView videoView = DevelVideoView::New( Dali::VideoSyncMode::ENABLED );
 836   DALI_TEST_CHECK( videoView );
 837
 838   application.GetScene().Add( videoView );
 839
 840   Vector3 vector(50.0f, 200.0f, 0.0f);
 841   videoView.SetProperty( Actor::Property::SIZE, vector );
 842
 843   application.SendNotification();
 844   application.Render();
 845
 846   DALI_TEST_CHECK(vector == videoView.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ));
 847
 848   END_TEST;
 849 }
 850
 851 // For coverage.
 852 int UtcDaliVideoViewSynchronizationForWindowRotation(void)
 853 {
 854   ToolkitTestApplication application;
 855   tet_infoline("UtcDaliVideoViewSynchronizationForWindowRotation");
 856
 857   Window window = Window::New(PositionSize(0,0,100,100) ,"", false);
 858   DALI_TEST_CHECK( window );
 859
 860   VideoView view = VideoView::New( true );
 861   DALI_TEST_CHECK( view );
 862
 863   window.Add( view );
 864
 865   view.Play();
 866
 867   DevelWindow::SetPositionSize(window,PositionSize(0,0,480, 240));
 868
 869   application.SendNotification();
 870   application.Render();
 871
 872   END_TEST;
 873 }