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