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

   1 /*
   2  * Copyright (c) 2015 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
  24 using namespace Dali;
  25 using namespace Dali::Toolkit;
  26
  27 namespace
  28 {
  29 const char* const TEST_FILE( "test.mp4" );
  30 const char* const VOLUME_LEFT( "volumeLeft" );
  31 const char* const VOLUME_RIGHT( "volumeRight" );
  32 const char* const RENDERING_TYPE( "renderingTarget" );
  33
  34 const char* VERTEX_SHADER = DALI_COMPOSE_SHADER(
  35   attribute mediump vec2 aPosition;\n
  36   varying mediump vec2 vTexCoord;\n
  37   uniform mediump mat4 uMvpMatrix;\n
  38   uniform mediump vec3 uSize;\n
  39   \n
  40   void main()\n
  41   {\n
  42     mediump vec4 vertexPosition = vec4(aPosition, 0.0, 1.0);\n
  43     vertexPosition.xyz *= uSize;\n
  44     vertexPosition = uMvpMatrix * vertexPosition;\n
  45     \n
  46     vTexCoord = aPosition + vec2(0.5);\n
  47     gl_Position = vertexPosition;\n
  48   }\n
  49 );
  50
  51 const char* fragmentShaderPrefix( "#extension GL_OES_EGL_image_external:require\n" );
  52 const char* FRAGMENT_SHADER = DALI_COMPOSE_SHADER(
  53   varying mediump vec2 vTexCoord;\n
  54   uniform samplerExternalOES sTexture;\n
  55   uniform lowp vec4 uColor;\n
  56   \n
  57   void main()\n
  58   {\n
  59     gl_FragColor = texture2D( sTexture, vTexCoord ) * uColor;\n
  60   }\n
  61 );
  62
  63 }
  64
  65 void video_view_startup(void)
  66 {
  67   test_return_value = TET_UNDEF;
  68 }
  69
  70 void video_view_cleanup(void)
  71 {
  72   test_return_value = TET_PASS;
  73 }
  74
  75 // Negative test case for a method
  76 int UtcDaliVideoViewUninitialized(void)
  77 {
  78   ToolkitTestApplication application;
  79   tet_infoline(" UtcDaliVideoViewUninitialized");
  80
  81   Toolkit::VideoView view;
  82
  83   try
  84   {
  85     // New() must be called to create a VideoView or it wont be valid.
  86     Actor a = Actor::New();
  87     view.Add( a );
  88     DALI_TEST_CHECK( false );
  89   }
  90   catch (Dali::DaliException& e)
  91   {
  92     // Tests that a negative test of an assertion succeeds
  93     DALI_TEST_PRINT_ASSERT( e );
  94     DALI_TEST_CHECK(!view);
  95   }
  96   END_TEST;
  97 }
  98
  99 // Positive test case for a method
 100 int UtcDaliVideoViewNew(void)
 101 {
 102   ToolkitTestApplication application;
 103   tet_infoline(" UtcDaliVideoViewNew");
 104
 105   Toolkit::VideoView view = Toolkit::VideoView::New();
 106   DALI_TEST_CHECK( view );
 107
 108   Toolkit::VideoView view2 = Toolkit::VideoView::New( "" );
 109   DALI_TEST_CHECK( view2 );
 110   END_TEST;
 111 }
 112
 113 // Positive test case for a method
 114 int UtcDaliVideoViewDownCast(void)
 115 {
 116   ToolkitTestApplication application;
 117   tet_infoline(" UtcDaliVideoViewDownCast");
 118
 119   Toolkit::VideoView view = Toolkit::VideoView::New();
 120   BaseHandle handle(view);
 121
 122   Toolkit::VideoView view2 = Toolkit::VideoView::DownCast( handle );
 123   DALI_TEST_CHECK( view );
 124   DALI_TEST_CHECK( view2 );
 125   DALI_TEST_CHECK( view == view2 );
 126   END_TEST;
 127 }
 128
 129 // Positive test case for a method
 130 int UtcDaliVideoViewProperty1(void)
 131 {
 132   ToolkitTestApplication application;
 133   tet_infoline(" UtcDaliVideoViewProperty1");
 134
 135   Toolkit::VideoView view = Toolkit::VideoView::New();
 136   DALI_TEST_CHECK( view );
 137
 138   std::string file;
 139   view.SetProperty( VideoView::Property::VIDEO, TEST_FILE );
 140   Property::Value val = view.GetProperty( VideoView::Property::VIDEO );
 141   DALI_TEST_CHECK( val.Get( file ) );
 142   DALI_TEST_CHECK( file == TEST_FILE );
 143   END_TEST;
 144 }
 145
 146 // Positive test case for a method
 147 int UtcDaliVideoViewProperty1b(void)
 148 {
 149   ToolkitTestApplication application;
 150   tet_infoline(" UtcDaliVideoViewProperty1");
 151
 152   Toolkit::VideoView view = Toolkit::VideoView::New();
 153   DALI_TEST_CHECK( view );
 154   Stage stage = Stage::GetCurrent();
 155
 156   std::string file;
 157   Property::Map map;
 158
 159   view.SetProperty( VideoView::Property::VIDEO, Property::Map()
 160                     .Add("rendererType", "IMAGE")
 161                     .Add("url", "video.mpg") // Note, videoView doesn't use this url
 162                     .Add("RENDERING_TARGET", "windowSurfaceTarget" )
 163                     .Add("width", 100)
 164                     .Add("height", 100) );
 165
 166   stage.Add( view );
 167
 168   Property::Value val = view.GetProperty( VideoView::Property::VIDEO );
 169   Property::Map* resultMap = val.GetMap();
 170
 171   DALI_TEST_CHECK( resultMap );
 172   Property::Value* value = resultMap->Find("url");
 173   DALI_TEST_CHECK( value );
 174   DALI_TEST_EQUALS( value->Get<std::string>(), "video.mpg", TEST_LOCATION );
 175
 176   stage.Remove( view );
 177
 178   END_TEST;
 179 }
 180
 181 int UtcDaliVideoViewProperty2(void)
 182 {
 183   ToolkitTestApplication application;
 184   tet_infoline(" UtcDaliVideoViewProperty2");
 185
 186   Toolkit::VideoView view = Toolkit::VideoView::New();
 187   DALI_TEST_CHECK( view );
 188
 189   bool looping;
 190   Property::Value val = view.GetProperty( VideoView::Property::LOOPING );
 191   DALI_TEST_CHECK( val.Get( looping ) );
 192   DALI_TEST_CHECK( !looping );
 193
 194   view.SetProperty( VideoView::Property::LOOPING, true );
 195   val = view.GetProperty( VideoView::Property::LOOPING );
 196   DALI_TEST_CHECK( val.Get( looping ) );
 197   DALI_TEST_CHECK( looping );
 198   END_TEST;
 199 }
 200
 201 int UtcDaliVideoViewProperty3(void)
 202 {
 203   ToolkitTestApplication application;
 204   tet_infoline(" UtcDaliVideoViewProperty3");
 205
 206   Toolkit::VideoView view = Toolkit::VideoView::New();
 207   DALI_TEST_CHECK( view );
 208
 209   bool muted;
 210   Property::Value val = view.GetProperty( VideoView::Property::MUTED );
 211   DALI_TEST_CHECK( val.Get( muted ) );
 212   DALI_TEST_CHECK( !muted );
 213
 214   view.SetProperty( VideoView::Property::MUTED, true );
 215   val = view.GetProperty( VideoView::Property::MUTED );
 216   DALI_TEST_CHECK( val.Get( muted ) );
 217   DALI_TEST_CHECK( muted );
 218
 219   END_TEST;
 220 }
 221
 222 int UtcDaliVideoViewProperty4(void)
 223 {
 224   ToolkitTestApplication application;
 225   tet_infoline(" UtcDaliVideoViewProperty4");
 226
 227   Toolkit::VideoView view = Toolkit::VideoView::New();
 228   DALI_TEST_CHECK( view );
 229
 230   float left, right;
 231   left = right = 0.f;
 232
 233   Property::Map map;
 234   map.Insert( VOLUME_LEFT, 0.5f );
 235   map.Insert( VOLUME_RIGHT, 0.5f );
 236
 237   view.SetProperty( VideoView::Property::VOLUME, map );
 238   Property::Value val = view.GetProperty( VideoView::Property::VOLUME );
 239
 240   Property::Map map2;
 241   DALI_TEST_CHECK( val.Get( map2 ) );
 242
 243   Property::Value* volumeLeft = map2.Find( VOLUME_LEFT );
 244   Property::Value* volumeRight = map2.Find( VOLUME_RIGHT );
 245
 246   DALI_TEST_CHECK( volumeLeft && volumeLeft->Get( left ) );
 247   DALI_TEST_CHECK( volumeRight && volumeRight->Get( right ) );
 248   DALI_TEST_CHECK( left == 0.5f );
 249   DALI_TEST_CHECK( right == 0.5f );
 250
 251   END_TEST;
 252 }
 253
 254 int UtcDaliVideoViewCopyAndAssignment(void)
 255 {
 256   ToolkitTestApplication application;
 257
 258   VideoView view = Toolkit::VideoView::New();
 259   DALI_TEST_CHECK( view );
 260
 261   VideoView copy( view );
 262   DALI_TEST_CHECK( view == copy );
 263
 264   VideoView assign;
 265   DALI_TEST_CHECK( !assign );
 266
 267   assign = copy;
 268   DALI_TEST_CHECK( assign == view );
 269
 270   END_TEST;
 271 }
 272
 273 int UtcDaliVideoViewTypeRegistry(void)
 274 {
 275   ToolkitTestApplication application;
 276
 277   TypeRegistry typeRegistry = TypeRegistry::Get();
 278   DALI_TEST_CHECK( typeRegistry );
 279
 280   TypeInfo typeInfo = typeRegistry.GetTypeInfo( "VideoView" );
 281   DALI_TEST_CHECK( typeInfo );
 282
 283   BaseHandle handle = typeInfo.CreateInstance();
 284   DALI_TEST_CHECK( handle );
 285
 286   VideoView view = VideoView::DownCast( handle );
 287   DALI_TEST_CHECK( view );
 288
 289   END_TEST;
 290 }
 291
 292 int UtcDaliVideoViewMethodsForCoverage(void)
 293 {
 294   ToolkitTestApplication application;
 295
 296   VideoView videoView = VideoView::New();
 297   DALI_TEST_CHECK( videoView );
 298
 299   videoView.Play();
 300   videoView.Pause();
 301   videoView.Stop();
 302   videoView.Forward(10);
 303   videoView.Backward(10);
 304   VideoView::VideoViewSignalType& signal = videoView.FinishedSignal();
 305   DALI_TEST_EQUALS( 0, signal.GetConnectionCount(), TEST_LOCATION );
 306
 307   END_TEST;
 308 }
 309
 310 int UtcDaliVideoViewMethodsForRenderType(void)
 311 {
 312   ToolkitTestApplication application;
 313   VideoView videoView = VideoView::New();
 314   DALI_TEST_CHECK( videoView );
 315
 316   Property::Map windowSurfaceTarget;
 317   Property::Map nativeImageTarget;
 318
 319   windowSurfaceTarget.Insert( RENDERING_TYPE, "windowSurfaceTarget" );
 320   nativeImageTarget.Insert( RENDERING_TYPE, "nativeImageTarget" );
 321
 322   Property::Map map;
 323   Property::Value value;
 324   videoView.SetProperty( VideoView::Property::VIDEO, windowSurfaceTarget );
 325
 326   value = videoView.GetProperty( VideoView::Property::VIDEO );
 327   DALI_TEST_CHECK( value.Get( map ) );
 328
 329   Property::Value* type = map.Find( RENDERING_TYPE );
 330   DALI_TEST_CHECK( type );
 331   DALI_TEST_EQUALS( "windowSurfaceTarget", type->Get<std::string>(), TEST_LOCATION );
 332
 333   videoView.SetProperty( VideoView::Property::VIDEO, nativeImageTarget );
 334
 335   value = videoView.GetProperty( VideoView::Property::VIDEO );
 336   DALI_TEST_CHECK( value.Get( map ) );
 337   type = map.Find( RENDERING_TYPE );
 338
 339   DALI_TEST_CHECK( type );
 340   DALI_TEST_EQUALS( "nativeImageTarget", type->Get<std::string>(), TEST_LOCATION );
 341
 342   END_TEST;
 343 }
 344
 345 int UtcDaliVideoViewCustomShaderForCoverage(void)
 346 {
 347   ToolkitTestApplication application;
 348   VideoView videoView = VideoView::New();
 349   DALI_TEST_CHECK( videoView );
 350
 351   ToolkitApplication::DECODED_IMAGES_SUPPORTED = true;
 352
 353   videoView.SetProperty( Toolkit::VideoView::Property::UNDERLAY, false );
 354   bool isUnderlay = videoView.GetProperty( Toolkit::VideoView::Property::UNDERLAY ).Get< bool >();
 355   DALI_TEST_CHECK( !isUnderlay );
 356
 357   Stage::GetCurrent().Add( videoView );
 358   videoView.SetProperty( VideoView::Property::VIDEO, "testvideo" );
 359
 360   Property::Map customShader;
 361   customShader.Insert( "vertexShader", VERTEX_SHADER );
 362   customShader.Insert( "fragmentShader", FRAGMENT_SHADER );
 363
 364   Property::Map map;
 365   map.Insert( "shader", customShader );
 366
 367   videoView.SetProperty( VideoView::Property::VIDEO, map );
 368
 369   Property::Map map2;
 370   Property::Value value = videoView.GetProperty( VideoView::Property::VIDEO );
 371
 372   DALI_TEST_CHECK( !value.Get( map2 ) );
 373   END_TEST;
 374 }
 375
 376 int UtcDaliVideoViewMethodsForCoverage2(void)
 377 {
 378   ToolkitTestApplication application;
 379   VideoView videoView = VideoView::New();
 380   DALI_TEST_CHECK( videoView );
 381
 382   Property::Map windowSurfaceTarget;
 383
 384   windowSurfaceTarget.Insert( RENDERING_TYPE, "windowSurfaceTarget" );
 385
 386   Stage::GetCurrent().Add( videoView );
 387
 388   application.SendNotification();
 389   application.Render();
 390
 391   Property::Map map;
 392   Property::Value value;
 393   videoView.SetProperty( VideoView::Property::VIDEO, windowSurfaceTarget );
 394
 395   value = videoView.GetProperty( VideoView::Property::VIDEO );
 396   DALI_TEST_CHECK( value.Get( map ) );
 397
 398   Property::Value* type = map.Find( RENDERING_TYPE );
 399   DALI_TEST_CHECK( type );
 400   DALI_TEST_EQUALS( "windowSurfaceTarget", type->Get<std::string>(), TEST_LOCATION );
 401
 402   Vector3 vector(100.0f, 100.0f, 0.0f);
 403
 404   DALI_TEST_CHECK(vector != videoView.GetCurrentSize());
 405   videoView.SetSize( vector );
 406
 407   application.SendNotification();
 408   application.Render();
 409
 410   // Check the size in the new frame
 411   DALI_TEST_CHECK(vector == videoView.GetCurrentSize());
 412
 413   END_TEST;
 414 }
 415
 416 int UtcDaliVideoViewPropertyUnderlay(void)
 417 {
 418   ToolkitTestApplication application;
 419   tet_infoline("UtcDaliVideoViewPropertyUnderlay");
 420   ToolkitApplication::DECODED_IMAGES_SUPPORTED = true;
 421
 422   VideoView view = VideoView::New();
 423   DALI_TEST_CHECK( view );
 424
 425   Stage::GetCurrent().Add( view );
 426   view.Play();
 427
 428   application.SendNotification();
 429   application.Render();
 430
 431   bool isUnderlay = view.GetProperty( Toolkit::VideoView::Property::UNDERLAY ).Get< bool >();
 432   DALI_TEST_CHECK( isUnderlay );
 433
 434   view.Play();
 435   view.SetProperty( Toolkit::VideoView::Property::UNDERLAY, false );
 436   isUnderlay = view.GetProperty( Toolkit::VideoView::Property::UNDERLAY ).Get< bool >();
 437   DALI_TEST_CHECK( !isUnderlay );
 438
 439   view.Play();
 440   view.SetProperty( Toolkit::VideoView::Property::UNDERLAY, true );
 441   isUnderlay = view.GetProperty( Toolkit::VideoView::Property::UNDERLAY ).Get< bool >();
 442   DALI_TEST_CHECK( isUnderlay );
 443
 444   // If platform api doesn't provide any API or feature for decoded images of video,
 445   // UNDERLAY should be true
 446   ToolkitApplication::DECODED_IMAGES_SUPPORTED = false;
 447
 448   view.SetProperty( Toolkit::VideoView::Property::UNDERLAY, false );
 449   isUnderlay = view.GetProperty( Toolkit::VideoView::Property::UNDERLAY ).Get< bool >();
 450   DALI_TEST_CHECK( isUnderlay );
 451
 452   // For coverage
 453   ToolkitApplication::DECODED_IMAGES_SUPPORTED = true;
 454
 455   view.SetProperty( Toolkit::VideoView::Property::UNDERLAY, true );
 456   view.SetProperty( Toolkit::VideoView::Property::UNDERLAY, false );
 457   isUnderlay = view.GetProperty( Toolkit::VideoView::Property::UNDERLAY ).Get< bool >();
 458   DALI_TEST_CHECK( !isUnderlay );
 459
 460   view.Stop();
 461
 462   END_TEST;
 463 }
 464
 465 int UtcDaliVideoViewPropertyPlayPosition(void)
 466 {
 467   ToolkitTestApplication application;
 468   tet_infoline("UtcDaliVideoViewPropertyPlayPosition");
 469
 470   VideoView view = VideoView::New();
 471   DALI_TEST_CHECK( view );
 472
 473   Stage::GetCurrent().Add( view );
 474   view.Play();
 475
 476   application.SendNotification();
 477   application.Render();
 478
 479   int playPos = view.GetProperty( Toolkit::VideoView::Property::PLAY_POSITION ).Get< int >();
 480   DALI_TEST_CHECK( playPos == 0 );
 481
 482   view.SetProperty( Toolkit::VideoView::Property::PLAY_POSITION, 10 );
 483   playPos = view.GetProperty( Toolkit::VideoView::Property::PLAY_POSITION ).Get< int >();
 484   // Actually setting play position will be async
 485   // Actual platform result may be different.
 486   DALI_TEST_CHECK( playPos == 10 );
 487
 488   END_TEST;
 489 }
 490
 491 // For coverage.
 492 int UtcDaliVideoViewNew2(void)
 493 {
 494   ToolkitTestApplication application;
 495   tet_infoline("UtcDaliVideoViewNew2");
 496
 497   VideoView view = VideoView::New( true );
 498   DALI_TEST_CHECK( view );
 499
 500   Stage::GetCurrent().Add( view );
 501   view.Play();
 502
 503   application.SendNotification();
 504   application.Render();
 505
 506   VideoView view2 = VideoView::New( "", false );
 507   DALI_TEST_CHECK( view2 );
 508
 509   Stage::GetCurrent().Add( view2 );
 510   view2.Play();
 511
 512   application.SendNotification();
 513   application.Render();
 514
 515   END_TEST;
 516 }
 517
 518 int UtcDaliVideoViewPropertyDisplayMode(void)
 519 {
 520   ToolkitTestApplication application;
 521   tet_infoline("UtcDaliVideoViewPropertyDisplayMode");
 522
 523   VideoView view = VideoView::New();
 524   DALI_TEST_CHECK( view );
 525
 526   Stage::GetCurrent().Add( view );
 527   view.Play();
 528
 529   application.SendNotification();
 530   application.Render();
 531
 532   view.SetProperty( Toolkit::VideoView::Property::DISPLAY_MODE, Toolkit::VideoView::DisplayMode::DST_ROI );
 533   int displayMode = view.GetProperty( Toolkit::VideoView::Property::DISPLAY_MODE ).Get< int >();
 534   DALI_TEST_CHECK( displayMode == Toolkit::VideoView::DisplayMode::DST_ROI );
 535
 536   END_TEST;
 537 }
 538
 539
 540 int UtcDaliVideoViewCustomShader(void)
 541 {
 542   ToolkitTestApplication application;
 543   tet_infoline( "VideoView with custom shader" );
 544
 545   VideoView view = VideoView::New();
 546   DALI_TEST_CHECK( view );
 547
 548   ToolkitApplication::DECODED_IMAGES_SUPPORTED = true;
 549
 550   view.SetProperty( Toolkit::VideoView::Property::UNDERLAY, false );
 551   bool isUnderlay = view.GetProperty( Toolkit::VideoView::Property::UNDERLAY ).Get< bool >();
 552   DALI_TEST_CHECK( !isUnderlay );
 553
 554   Stage::GetCurrent().Add( view );
 555   view.SetProperty( VideoView::Property::VIDEO, "testvideo" );
 556
 557   /* insert custom shader */
 558   Property::Map customShader;
 559   std::string fragmentShaderString;
 560   fragmentShaderString.reserve( strlen( fragmentShaderPrefix ) + strlen( FRAGMENT_SHADER ) );
 561   fragmentShaderString.append( fragmentShaderPrefix );
 562   fragmentShaderString.append( FRAGMENT_SHADER );
 563   customShader.Insert( "vertexShader", VERTEX_SHADER );
 564   customShader.Insert( "fragmentShader", fragmentShaderString );
 565
 566   Property::Map map;
 567   map.Insert( "shader", customShader );
 568
 569   view.SetProperty( VideoView::Property::VIDEO, map );
 570
 571   /* do render for check custom shader */
 572   Stage::GetCurrent().Add( view );
 573   view.Play();
 574
 575   application.SendNotification();
 576   application.Render();
 577
 578   /* get renderer */
 579   DALI_TEST_CHECK( view.GetRendererCount() == 1u );
 580   Renderer renderer = view.GetRendererAt( 0 );
 581   Shader shader = renderer.GetShader();
 582   DALI_TEST_CHECK( shader );
 583
 584   Property::Value value = shader.GetProperty(Shader::Property::PROGRAM);
 585   Property::Map* shaderMap = value.GetMap();
 586   DALI_TEST_CHECK( shaderMap );
 587
 588   Property::Value* fragment = shaderMap->Find( "fragment" ); // fragment key name from shader-impl.cpp
 589   DALI_TEST_EQUALS( fragmentShaderString, fragment->Get<std::string>(), TEST_LOCATION );
 590
 591   Property::Value* vertex = shaderMap->Find( "vertex" ); // vertex key name from shader-impl.cpp
 592   DALI_TEST_EQUALS( VERTEX_SHADER, vertex->Get<std::string>(), TEST_LOCATION );
 593
 594   END_TEST;
 595 }