automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-vector-animation-renderer.cpp

   1 /*
   2  * Copyright (c) 2021 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 #include <dali/devel-api/adaptor-framework/vector-animation-renderer.h>
  19 #include <dali/public-api/object/base-object.h>
  20 #include <toolkit-application.h>
  21 #include <toolkit-vector-animation-renderer.h>
  22 #include <toolkit-event-thread-callback.h>
  23 #include <memory>
  24 #include <thread>
  25 #include <chrono>
  26
  27 namespace Dali
  28 {
  29
  30 namespace Internal
  31 {
  32
  33 namespace Adaptor
  34 {
  35
  36 namespace
  37 {
  38 Dali::Internal::Adaptor::VectorAnimationRenderer* gVectorAnimationRenderer = nullptr;
  39 }
  40
  41 class VectorAnimationRenderer: public Dali::BaseObject
  42 {
  43 public:
  44
  45   VectorAnimationRenderer()
  46   : mUrl(),
  47     mRenderer(),
  48     mWidth( 0 ),
  49     mHeight( 0 ),
  50     mTotalFrameNumber(VECTOR_ANIMATION_TOTAL_FRAME_NUMBER),
  51     mPreviousFrame( 0 ),
  52     mDelayTime(0),
  53     mDroppedFrames(0),
  54     mFrameRate( 60.0f ),
  55     mTestFrameDrop(false),
  56     mNeedDroppedFrames(false),
  57     mEventThreadCallback( new EventThreadCallback( MakeCallback( this, &VectorAnimationRenderer::OnTriggered ) ) )
  58   {
  59     mCount++;
  60
  61     if( mCount == 2 )
  62     {
  63       mFrameRate = 0.1f;
  64     }
  65   }
  66
  67   ~VectorAnimationRenderer()
  68   {
  69     mCount--;
  70   }
  71
  72   bool Load(const std::string& url)
  73   {
  74     mUrl = url;
  75     if(mUrl == "invalid.json")
  76     {
  77       return false;
  78     }
  79     else if(mUrl == "framedrop.json")
  80     {
  81       // Change total frame number for test
  82       mTotalFrameNumber = 200;
  83       mTestFrameDrop = true;
  84     }
  85     return true;
  86   }
  87
  88   void SetRenderer( Dali::Renderer renderer )
  89   {
  90     mRenderer = renderer;
  91
  92     if( mWidth != 0 && mHeight != 0 )
  93     {
  94       Dali::TextureSet textureSet = mRenderer.GetTextures();
  95       Dali::Texture texture = Dali::Texture::New( TextureType::TEXTURE_2D, Pixel::RGBA8888, mWidth, mHeight );
  96       textureSet.SetTexture( 0, texture );
  97       mUploadCompletedSignal.Emit();
  98     }
  99   }
 100
 101   void SetSize( uint32_t width, uint32_t height )
 102   {
 103     mWidth = width;
 104     mHeight = height;
 105
 106     if( mRenderer )
 107     {
 108       Dali::TextureSet textureSet = mRenderer.GetTextures();
 109       Dali::Texture texture = Dali::Texture::New( TextureType::TEXTURE_2D, Pixel::RGBA8888, mWidth, mHeight );
 110       textureSet.SetTexture( 0, texture );
 111       mUploadCompletedSignal.Emit();
 112     }
 113   }
 114
 115   bool Render( uint32_t frameNumber )
 116   {
 117     if(mTestFrameDrop)
 118     {
 119       std::this_thread::sleep_for(std::chrono::milliseconds(static_cast<int32_t>(mDelayTime)));
 120       mTestFrameDrop = false;
 121       mNeedDroppedFrames = true;
 122     }
 123     else if(mNeedDroppedFrames)
 124     {
 125       mDroppedFrames = (frameNumber > mPreviousFrame) ? frameNumber - mPreviousFrame - 1: frameNumber + (mTotalFrameNumber - mPreviousFrame) - 1;
 126       mNeedTrigger = true;
 127       mNeedDroppedFrames = false;
 128     }
 129
 130     if( mNeedTrigger )
 131     {
 132       mEventThreadCallback->Trigger();
 133       mNeedTrigger = false;
 134     }
 135
 136     if( frameNumber == 1 && mPreviousFrame != frameNumber )
 137     {
 138       mPreviousFrame = frameNumber;
 139       // For test corverage
 140       return false;
 141     }
 142     mPreviousFrame = frameNumber;
 143     return true;
 144   }
 145
 146   uint32_t GetTotalFrameNumber() const
 147   {
 148     return mTotalFrameNumber;
 149   }
 150
 151   float GetFrameRate() const
 152   {
 153     return mFrameRate;
 154   }
 155
 156   void GetDefaultSize( uint32_t& width, uint32_t& height ) const
 157   {
 158     width = 100;
 159     height = 100;
 160   }
 161
 162   bool GetMarkerInfo( const std::string& marker, uint32_t& startFrame, uint32_t& endFrame ) const
 163   {
 164     if( marker.compare( VECTOR_ANIMATION_MARKER_NAME_1 ) == 0 )
 165     {
 166       startFrame = VECTOR_ANIMATION_MARKER_START_FRAME_1;
 167       endFrame = VECTOR_ANIMATION_MARKER_END_FRAME_1;
 168     }
 169     else if( marker.compare( VECTOR_ANIMATION_MARKER_NAME_2 ) == 0 )
 170     {
 171       startFrame = VECTOR_ANIMATION_MARKER_START_FRAME_2;
 172       endFrame = VECTOR_ANIMATION_MARKER_END_FRAME_2;
 173     }
 174     else
 175     {
 176       return false;
 177     }
 178     return true;
 179   }
 180
 181   Dali::VectorAnimationRenderer::UploadCompletedSignalType& UploadCompletedSignal()
 182   {
 183     return mUploadCompletedSignal;
 184   }
 185
 186   void OnTriggered()
 187   {
 188   }
 189
 190 public:
 191
 192   static uint32_t mCount;
 193   static bool mNeedTrigger;
 194
 195   std::string mUrl;
 196   Dali::Renderer mRenderer;
 197   uint32_t mWidth;
 198   uint32_t mHeight;
 199   uint32_t mTotalFrameNumber;
 200   uint32_t mPreviousFrame;
 201   uint32_t mDelayTime;
 202   uint32_t mDroppedFrames;
 203   float mFrameRate;
 204   bool mTestFrameDrop;
 205   bool mNeedDroppedFrames;
 206   Dali::VectorAnimationRenderer::UploadCompletedSignalType mUploadCompletedSignal;
 207   std::unique_ptr< EventThreadCallback > mEventThreadCallback;
 208 };
 209
 210 uint32_t VectorAnimationRenderer::mCount = 0;
 211 bool VectorAnimationRenderer::mNeedTrigger = true;
 212
 213 inline VectorAnimationRenderer& GetImplementation( Dali::VectorAnimationRenderer& renderer )
 214 {
 215   DALI_ASSERT_ALWAYS( renderer && "VectorAnimationRenderer handle is empty." );
 216   BaseObject& handle = renderer.GetBaseObject();
 217   return static_cast< Internal::Adaptor::VectorAnimationRenderer& >( handle );
 218 }
 219
 220 inline const VectorAnimationRenderer& GetImplementation( const Dali::VectorAnimationRenderer& renderer )
 221 {
 222   DALI_ASSERT_ALWAYS( renderer && "VectorAnimationRenderer handle is empty." );
 223   const BaseObject& handle = renderer.GetBaseObject();
 224   return static_cast< const Internal::Adaptor::VectorAnimationRenderer& >( handle );
 225 }
 226
 227 } // namespace Adaptor
 228
 229 } // namespace Internal
 230
 231
 232 /********************************************************************************/
 233 /*********************************  PUBLIC CLASS  *******************************/
 234 /********************************************************************************/
 235
 236 VectorAnimationRenderer VectorAnimationRenderer::New()
 237 {
 238   Internal::Adaptor::VectorAnimationRenderer* animationRenderer = new Internal::Adaptor::VectorAnimationRenderer();
 239
 240   Internal::Adaptor::gVectorAnimationRenderer = animationRenderer;
 241
 242   return VectorAnimationRenderer( animationRenderer );
 243 }
 244
 245 VectorAnimationRenderer::VectorAnimationRenderer()
 246 {
 247 }
 248
 249 VectorAnimationRenderer::~VectorAnimationRenderer()
 250 {
 251 }
 252
 253 VectorAnimationRenderer::VectorAnimationRenderer( Internal::Adaptor::VectorAnimationRenderer* internal )
 254 : BaseHandle( internal )
 255 {
 256 }
 257
 258 VectorAnimationRenderer::VectorAnimationRenderer( const VectorAnimationRenderer& handle )
 259 : BaseHandle( handle )
 260 {
 261 }
 262
 263 VectorAnimationRenderer& VectorAnimationRenderer::operator=( const VectorAnimationRenderer& rhs )
 264 {
 265   BaseHandle::operator=( rhs );
 266   return *this;
 267 }
 268
 269 void VectorAnimationRenderer::Finalize()
 270 {
 271 }
 272
 273 bool VectorAnimationRenderer::Load(const std::string& url)
 274 {
 275   return Internal::Adaptor::GetImplementation( *this ).Load(url);
 276 }
 277
 278 void VectorAnimationRenderer::SetRenderer( Renderer renderer )
 279 {
 280   Internal::Adaptor::GetImplementation( *this ).SetRenderer( renderer );
 281 }
 282
 283 void VectorAnimationRenderer::SetSize( uint32_t width, uint32_t height )
 284 {
 285   Internal::Adaptor::GetImplementation( *this ).SetSize( width, height );
 286 }
 287
 288 bool VectorAnimationRenderer::Render( uint32_t frameNumber )
 289 {
 290   return Internal::Adaptor::GetImplementation( *this ).Render( frameNumber );
 291 }
 292
 293 uint32_t VectorAnimationRenderer::GetTotalFrameNumber() const
 294 {
 295   return Internal::Adaptor::GetImplementation( *this ).GetTotalFrameNumber();
 296 }
 297
 298 float VectorAnimationRenderer::GetFrameRate() const
 299 {
 300   return Internal::Adaptor::GetImplementation( *this ).GetFrameRate();
 301 }
 302
 303 void VectorAnimationRenderer::GetDefaultSize( uint32_t& width, uint32_t& height ) const
 304 {
 305   Internal::Adaptor::GetImplementation( *this ).GetDefaultSize( width, height );
 306 }
 307
 308 void VectorAnimationRenderer::GetLayerInfo( Property::Map& map ) const
 309 {
 310 }
 311
 312 bool VectorAnimationRenderer::GetMarkerInfo( const std::string& marker, uint32_t& startFrame, uint32_t& endFrame ) const
 313 {
 314   return Internal::Adaptor::GetImplementation( *this ).GetMarkerInfo( marker, startFrame, endFrame );
 315 }
 316
 317 VectorAnimationRenderer::UploadCompletedSignalType& VectorAnimationRenderer::UploadCompletedSignal()
 318 {
 319   return Internal::Adaptor::GetImplementation( *this ).UploadCompletedSignal();
 320 }
 321
 322 } // namespace Dali
 323
 324 namespace Test
 325 {
 326 namespace VectorAnimationRenderer
 327 {
 328
 329 void RequestTrigger()
 330 {
 331   Dali::Internal::Adaptor::VectorAnimationRenderer::mNeedTrigger = true;
 332 }
 333
 334 void DelayRendering(uint32_t delay)
 335 {
 336   Dali::Internal::Adaptor::gVectorAnimationRenderer->mDelayTime = delay;
 337 }
 338
 339 uint32_t GetDroppedFrames()
 340 {
 341   return Dali::Internal::Adaptor::gVectorAnimationRenderer->mDroppedFrames;
 342 }
 343
 344 } // VectorAnimationRenderer
 345 } // Test
 346