dali-toolkit/internal/visuals/animated-vector-image/vector-animation-task.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 // CLASS HEADER
  19 #include <dali-toolkit/internal/visuals/animated-vector-image/vector-animation-task.h>
  20
  21 // EXTERNAL INCLUDES
  22 #include <dali/integration-api/debug.h>
  23 #include <dali/public-api/object/property-array.h>
  24 #include <dali/public-api/math/math-utils.h>
  25
  26 // INTERNAL INCLUDES
  27 #include <dali-toolkit/internal/visuals/image-visual-shader-factory.h>
  28 #include <dali-toolkit/internal/visuals/animated-vector-image/vector-animation-thread.h>
  29
  30 namespace Dali
  31 {
  32
  33 namespace Toolkit
  34 {
  35
  36 namespace Internal
  37 {
  38
  39 namespace
  40 {
  41
  42 constexpr auto LOOP_FOREVER = -1;
  43 constexpr auto NANOSECONDS_PER_SECOND( 1e+9 );
  44
  45 #if defined(DEBUG_ENABLED)
  46 Debug::Filter* gVectorAnimationLogFilter = Debug::Filter::New( Debug::NoLogging, false, "LOG_VECTOR_ANIMATION" );
  47 #endif
  48
  49 } // unnamed namespace
  50
  51 VectorAnimationTask::VectorAnimationTask( VisualFactoryCache& factoryCache, const std::string& url )
  52 : mUrl( url ),
  53   mVectorRenderer(),
  54   mAnimationData(),
  55   mVectorAnimationThread( factoryCache.GetVectorAnimationThread() ),
  56   mConditionalWait(),
  57   mAnimationFinishedTrigger(),
  58   mPlayState( PlayState::STOPPED ),
  59   mStopBehavior( DevelImageVisual::StopBehavior::CURRENT_FRAME ),
  60   mLoopingMode( DevelImageVisual::LoopingMode::RESTART ),
  61   mNextFrameStartTime(),
  62   mFrameDurationNanoSeconds( 0 ),
  63   mFrameRate( 60.0f ),
  64   mCurrentFrame( 0 ),
  65   mTotalFrame( 0 ),
  66   mStartFrame( 0 ),
  67   mEndFrame( 0 ),
  68   mWidth( 0 ),
  69   mHeight( 0 ),
  70   mAnimationDataIndex( 0 ),
  71   mLoopCount( LOOP_FOREVER ),
  72   mCurrentLoop( 0 ),
  73   mResourceReady( false ),
  74   mForward( true ),
  75   mUpdateFrameNumber( false ),
  76   mNeedAnimationFinishedTrigger( true ),
  77   mAnimationDataUpdated( false )
  78 {
  79   Initialize();
  80 }
  81
  82 VectorAnimationTask::~VectorAnimationTask()
  83 {
  84   DALI_LOG_INFO( gVectorAnimationLogFilter, Debug::Verbose, "VectorAnimationTask::~VectorAnimationTask: destructor [%p]\n", this );
  85 }
  86
  87 void VectorAnimationTask::Finalize()
  88 {
  89   ConditionalWait::ScopedLock lock( mConditionalWait );
  90
  91   // Release some objects in the main thread
  92   if( mAnimationFinishedTrigger )
  93   {
  94     mAnimationFinishedTrigger.reset();
  95   }
  96
  97   mVectorRenderer.Finalize();
  98 }
  99
 100 void VectorAnimationTask::SetRenderer( Renderer renderer )
 101 {
 102   ConditionalWait::ScopedLock lock( mConditionalWait );
 103
 104   mVectorRenderer.SetRenderer( renderer );
 105
 106   DALI_LOG_INFO( gVectorAnimationLogFilter, Debug::Verbose, "VectorAnimationTask::SetRenderer [%p]\n", this );
 107 }
 108
 109 void VectorAnimationTask::SetAnimationData( const AnimationData& data )
 110 {
 111   ConditionalWait::ScopedLock lock( mConditionalWait );
 112
 113   DALI_LOG_INFO( gVectorAnimationLogFilter, Debug::Verbose, "VectorAnimationTask::SetAnimationData [%p]\n", this );
 114
 115   uint32_t index = mAnimationDataIndex == 0 ? 1 : 0;  // Use the other buffer
 116
 117   mAnimationData[index] = data;
 118   mAnimationDataUpdated = true;
 119
 120   if( data.resendFlag & VectorAnimationTask::RESEND_SIZE )
 121   {
 122     // The size should be changed in the main thread.
 123     SetSize( data.width, data.height );
 124   }
 125
 126   mVectorAnimationThread.AddTask( this );
 127 }
 128
 129 void VectorAnimationTask::SetSize( uint32_t width, uint32_t height )
 130 {
 131   if( mWidth != width || mHeight != height )
 132   {
 133     mVectorRenderer.SetSize( width, height );
 134
 135     mWidth = width;
 136     mHeight = height;
 137
 138     mResourceReady = false;
 139
 140     DALI_LOG_INFO( gVectorAnimationLogFilter, Debug::Verbose, "VectorAnimationTask::SetSize: width = %d, height = %d [%p]\n", width, height, this );
 141   }
 142 }
 143
 144 void VectorAnimationTask::PlayAnimation()
 145 {
 146   if( mPlayState != PlayState::PLAYING )
 147   {
 148     mUpdateFrameNumber = false;
 149     mPlayState = PlayState::PLAYING;
 150
 151     DALI_LOG_INFO( gVectorAnimationLogFilter, Debug::Verbose, "VectorAnimationTask::PlayAnimation: Play [%p]\n", this );
 152   }
 153 }
 154
 155 void VectorAnimationTask::StopAnimation()
 156 {
 157   if( mPlayState != PlayState::STOPPING )
 158   {
 159     mNeedAnimationFinishedTrigger = false;
 160     mPlayState = PlayState::STOPPING;
 161
 162     DALI_LOG_INFO( gVectorAnimationLogFilter, Debug::Verbose, "VectorAnimationTask::StopAnimation: Stop [%p]\n", this );
 163   }
 164 }
 165
 166 void VectorAnimationTask::PauseAnimation()
 167 {
 168   if( mPlayState == PlayState::PLAYING )
 169   {
 170     mPlayState = PlayState::PAUSED;
 171
 172     DALI_LOG_INFO( gVectorAnimationLogFilter, Debug::Verbose, "VectorAnimationTask::PauseAnimation: Pause [%p]\n", this );
 173   }
 174 }
 175
 176 void VectorAnimationTask::SetAnimationFinishedCallback( EventThreadCallback* callback )
 177 {
 178   ConditionalWait::ScopedLock lock( mConditionalWait );
 179   if( callback )
 180   {
 181     mAnimationFinishedTrigger = std::unique_ptr< EventThreadCallback >( callback );
 182   }
 183 }
 184
 185 void VectorAnimationTask::SetLoopCount( int32_t count )
 186 {
 187   if( mLoopCount != count )
 188   {
 189     mLoopCount = count;
 190     mCurrentLoop = 0;
 191
 192     DALI_LOG_INFO( gVectorAnimationLogFilter, Debug::Verbose, "VectorAnimationTask::SetLoopCount: [%d] [%p]\n", count, this );
 193   }
 194 }
 195
 196 void VectorAnimationTask::SetPlayRange( const Property::Array& playRange )
 197 {
 198   bool valid = false;
 199   uint32_t startFrame = 0, endFrame = 0;
 200   size_t count = playRange.Count();
 201
 202   if( count >= 2 )
 203   {
 204     int32_t start = 0, end = 0;
 205     if( playRange.GetElementAt( 0 ).Get( start ) && playRange.GetElementAt( 1 ).Get( end ) )
 206     {
 207       startFrame = static_cast< uint32_t >( start );
 208       endFrame = static_cast< uint32_t >( end );
 209       valid = true;
 210     }
 211     else
 212     {
 213       std::string startMarker, endMarker;
 214       if( playRange.GetElementAt( 0 ).Get( startMarker ) && playRange.GetElementAt( 1 ).Get( endMarker ) )
 215       {
 216         if( mVectorRenderer )
 217         {
 218           uint32_t frame;   // We don't use this later
 219           if( mVectorRenderer.GetMarkerInfo( startMarker, startFrame, frame ) && mVectorRenderer.GetMarkerInfo( endMarker, frame, endFrame ) )
 220           {
 221             valid = true;
 222           }
 223         }
 224       }
 225     }
 226   }
 227   else if( count == 1 )
 228   {
 229     std::string marker;
 230     if( playRange.GetElementAt( 0 ).Get( marker ) )
 231     {
 232       if( mVectorRenderer )
 233       {
 234         mVectorRenderer.GetMarkerInfo( marker, startFrame, endFrame );
 235         valid = true;
 236       }
 237     }
 238   }
 239
 240   if( !valid )
 241   {
 242     DALI_LOG_ERROR( "VectorAnimationTask::SetPlayRange: Invalid range [%p]\n", this );
 243     return;
 244   }
 245
 246   // Make sure the range specified is between 0 and the total frame number
 247   if( startFrame < mTotalFrame && endFrame < mTotalFrame )
 248   {
 249     // If the range is not in order swap values
 250     if( startFrame > endFrame )
 251     {
 252       uint32_t temp = startFrame;
 253       startFrame = endFrame;
 254       endFrame = temp;
 255     }
 256
 257     if( startFrame != mStartFrame || endFrame != mEndFrame )
 258     {
 259       mStartFrame = startFrame;
 260       mEndFrame = endFrame;
 261
 262       // If the current frame is out of the range, change the current frame also.
 263       if( mStartFrame > mCurrentFrame )
 264       {
 265         mCurrentFrame = mStartFrame;
 266         mResourceReady = false;
 267       }
 268       else if( mEndFrame < mCurrentFrame )
 269       {
 270         mCurrentFrame = mEndFrame;
 271         mResourceReady = false;
 272       }
 273
 274       DALI_LOG_INFO( gVectorAnimationLogFilter, Debug::Verbose, "VectorAnimationTask::SetPlayRange: [%d, %d] [%p]\n", mStartFrame, mEndFrame, this );
 275     }
 276   }
 277   else
 278   {
 279     DALI_LOG_ERROR( "VectorAnimationTask::SetPlayRange: Invalid range (%d, %d) [%p]\n", startFrame, endFrame, this );
 280     return;
 281   }
 282 }
 283
 284 void VectorAnimationTask::GetPlayRange( uint32_t& startFrame, uint32_t& endFrame )
 285 {
 286   startFrame = mStartFrame;
 287   endFrame = mEndFrame;
 288 }
 289
 290 void VectorAnimationTask::SetCurrentFrameNumber( uint32_t frameNumber )
 291 {
 292   if( mCurrentFrame == frameNumber )
 293   {
 294     DALI_LOG_INFO( gVectorAnimationLogFilter, Debug::Verbose, "VectorAnimationTask::SetCurrentFrameNumber: Set same frame [%d] [%p]\n", frameNumber, this );
 295     return;
 296   }
 297
 298   if( frameNumber >= mStartFrame && frameNumber <= mEndFrame )
 299   {
 300     mCurrentFrame = frameNumber;
 301     mUpdateFrameNumber = false;
 302     mResourceReady = false;
 303
 304     DALI_LOG_INFO( gVectorAnimationLogFilter, Debug::Verbose, "VectorAnimationTask::SetCurrentFrameNumber: frame number = %d [%p]\n", mCurrentFrame, this );
 305   }
 306   else
 307   {
 308     DALI_LOG_ERROR( "Invalid frame number [%d (%d, %d)]\n", frameNumber, mStartFrame, mEndFrame );
 309   }
 310 }
 311
 312 uint32_t VectorAnimationTask::GetCurrentFrameNumber() const
 313 {
 314   return mCurrentFrame;
 315 }
 316
 317 uint32_t VectorAnimationTask::GetTotalFrameNumber() const
 318 {
 319   return mTotalFrame;
 320 }
 321
 322 void VectorAnimationTask::GetDefaultSize( uint32_t& width, uint32_t& height ) const
 323 {
 324   mVectorRenderer.GetDefaultSize( width, height );
 325 }
 326
 327 void VectorAnimationTask::SetStopBehavior( DevelImageVisual::StopBehavior::Type stopBehavior )
 328 {
 329   mStopBehavior = stopBehavior;
 330
 331   DALI_LOG_INFO( gVectorAnimationLogFilter, Debug::Verbose, "VectorAnimationTask::SetStopBehavior: stop behavor = %d [%p]\n", mStopBehavior, this );
 332 }
 333
 334 void VectorAnimationTask::SetLoopingMode( DevelImageVisual::LoopingMode::Type loopingMode )
 335 {
 336   mLoopingMode = loopingMode;
 337
 338   DALI_LOG_INFO( gVectorAnimationLogFilter, Debug::Verbose, "VectorAnimationTask::SetLoopingMode: looping mode = %d [%p]\n", mLoopingMode, this );
 339 }
 340
 341 void VectorAnimationTask::GetLayerInfo( Property::Map& map ) const
 342 {
 343   mVectorRenderer.GetLayerInfo( map );
 344 }
 345
 346 VectorAnimationTask::UploadCompletedSignalType& VectorAnimationTask::UploadCompletedSignal()
 347 {
 348   return mVectorRenderer.UploadCompletedSignal();
 349 }
 350
 351 void VectorAnimationTask::Initialize()
 352 {
 353   mVectorRenderer = VectorAnimationRenderer::New( mUrl );
 354
 355   mTotalFrame = mVectorRenderer.GetTotalFrameNumber();
 356
 357   mEndFrame = mTotalFrame - 1;
 358
 359   mFrameRate = mVectorRenderer.GetFrameRate();
 360   mFrameDurationNanoSeconds = NANOSECONDS_PER_SECOND / mFrameRate;
 361
 362   uint32_t width, height;
 363   mVectorRenderer.GetDefaultSize( width, height );
 364
 365   SetSize( width, height );
 366
 367   DALI_LOG_INFO( gVectorAnimationLogFilter, Debug::Verbose, "VectorAnimationTask::Initialize: file = %s [%d frames, %f fps] [%p]\n", mUrl.c_str(), mTotalFrame, mFrameRate, this );
 368 }
 369
 370 bool VectorAnimationTask::Rasterize()
 371 {
 372   bool stopped = false;
 373   uint32_t currentFrame;
 374
 375   ApplyAnimationData();
 376
 377   if( mPlayState == PlayState::PLAYING && mUpdateFrameNumber )
 378   {
 379     mCurrentFrame = mForward ? mCurrentFrame + 1 : mCurrentFrame - 1;
 380     Dali::ClampInPlace( mCurrentFrame, mStartFrame, mEndFrame );
 381   }
 382
 383   currentFrame = mCurrentFrame;
 384
 385   // Reset values
 386   mResourceReady = true;
 387   mUpdateFrameNumber = true;
 388   mNeedAnimationFinishedTrigger = true;
 389
 390   if( mPlayState == PlayState::STOPPING )
 391   {
 392     mCurrentFrame = GetStoppedFrame( mStartFrame, mEndFrame, mCurrentFrame );
 393     currentFrame = mCurrentFrame;
 394     stopped = true;
 395   }
 396   else if( mPlayState == PlayState::PLAYING )
 397   {
 398     bool animationFinished = false;
 399
 400     if( currentFrame >= mEndFrame )  // last frame
 401     {
 402       if( mLoopingMode == DevelImageVisual::LoopingMode::AUTO_REVERSE )
 403       {
 404         mForward = false;
 405       }
 406       else
 407       {
 408         if( mLoopCount < 0 || ++mCurrentLoop < mLoopCount )   // repeat forever or before the last loop
 409         {
 410           mCurrentFrame = mStartFrame;
 411           mUpdateFrameNumber = false;
 412         }
 413         else
 414         {
 415           animationFinished = true;   // end of animation
 416         }
 417       }
 418     }
 419     else if( currentFrame == mStartFrame && !mForward )  // first frame
 420     {
 421       if( mLoopCount < 0 || ++mCurrentLoop < mLoopCount )   // repeat forever or before the last loop
 422       {
 423         mForward = true;
 424       }
 425       else
 426       {
 427         animationFinished = true;   // end of animation
 428       }
 429     }
 430
 431     if( animationFinished )
 432     {
 433       if( mStopBehavior == DevelImageVisual::StopBehavior::CURRENT_FRAME )
 434       {
 435         stopped = true;
 436       }
 437       else
 438       {
 439         mPlayState = PlayState::STOPPING;
 440       }
 441     }
 442   }
 443
 444   // Rasterize
 445   bool renderSuccess = false;
 446   if( mVectorRenderer )
 447   {
 448     renderSuccess = mVectorRenderer.Render( currentFrame );
 449     if( !renderSuccess )
 450     {
 451       DALI_LOG_INFO( gVectorAnimationLogFilter, Debug::Verbose, "VectorAnimationTask::Rasterize: Rendering failed. Try again later.[%d] [%p]\n", currentFrame, this );
 452       mUpdateFrameNumber = false;
 453
 454       if( !mResourceReady )
 455       {
 456         mResourceReady = false;
 457       }
 458     }
 459   }
 460
 461   if( stopped && renderSuccess )
 462   {
 463     mPlayState = PlayState::STOPPED;
 464     mForward = true;
 465     mCurrentLoop = 0;
 466
 467     // Animation is finished
 468     {
 469       ConditionalWait::ScopedLock lock( mConditionalWait );
 470       if( mNeedAnimationFinishedTrigger && mAnimationFinishedTrigger )
 471       {
 472         mAnimationFinishedTrigger->Trigger();
 473       }
 474     }
 475
 476     DALI_LOG_INFO( gVectorAnimationLogFilter, Debug::Verbose, "VectorAnimationTask::Rasterize: Animation is finished [current = %d] [%p]\n", currentFrame, this );
 477   }
 478
 479   bool keepAnimation = true;
 480   if( mPlayState == PlayState::PAUSED || mPlayState == PlayState::STOPPED )
 481   {
 482     keepAnimation = false;
 483   }
 484
 485   return keepAnimation;
 486 }
 487
 488 uint32_t VectorAnimationTask::GetStoppedFrame( uint32_t startFrame, uint32_t endFrame, uint32_t currentFrame )
 489 {
 490   uint32_t frame = currentFrame;
 491
 492   switch( mStopBehavior )
 493   {
 494     case DevelImageVisual::StopBehavior::FIRST_FRAME:
 495     {
 496       frame = startFrame;
 497       break;
 498     }
 499     case DevelImageVisual::StopBehavior::LAST_FRAME:
 500     {
 501       if( mLoopingMode == DevelImageVisual::LoopingMode::AUTO_REVERSE )
 502       {
 503         frame = startFrame;
 504       }
 505       else
 506       {
 507         frame = endFrame;
 508       }
 509       break;
 510     }
 511     case DevelImageVisual::StopBehavior::CURRENT_FRAME:
 512     {
 513       frame = currentFrame;
 514       break;
 515     }
 516   }
 517
 518   return frame;
 519 }
 520
 521 std::chrono::time_point< std::chrono::system_clock > VectorAnimationTask::CalculateNextFrameTime( bool renderNow )
 522 {
 523   // std::chrono::time_point template has second parameter duration which defaults to the std::chrono::system_clock supported
 524   // duration. In some C++11 implementations it is a milliseconds duration, so it fails to compile unless mNextFrameStartTime
 525   // is casted to use the default duration.
 526   mNextFrameStartTime =  std::chrono::time_point_cast< std::chrono::time_point< std::chrono::system_clock >::duration >(
 527       mNextFrameStartTime + std::chrono::nanoseconds( mFrameDurationNanoSeconds ) );
 528   auto current = std::chrono::system_clock::now();
 529   if( renderNow || mNextFrameStartTime < current )
 530   {
 531     mNextFrameStartTime = current;
 532   }
 533   return mNextFrameStartTime;
 534 }
 535
 536 std::chrono::time_point< std::chrono::system_clock > VectorAnimationTask::GetNextFrameTime()
 537 {
 538   return mNextFrameStartTime;
 539 }
 540
 541 void VectorAnimationTask::ApplyAnimationData()
 542 {
 543   uint32_t index;
 544
 545   {
 546     ConditionalWait::ScopedLock lock( mConditionalWait );
 547
 548     if( !mAnimationDataUpdated || mAnimationData[mAnimationDataIndex].resendFlag != 0 )
 549     {
 550       // Data is not updated or the previous data is not applied yet.
 551       return;
 552     }
 553
 554     mAnimationDataIndex = mAnimationDataIndex == 0 ? 1 : 0;  // Swap index
 555     mAnimationDataUpdated = false;
 556
 557     index = mAnimationDataIndex;
 558   }
 559
 560   if( mAnimationData[index].resendFlag & VectorAnimationTask::RESEND_LOOP_COUNT )
 561   {
 562     SetLoopCount( mAnimationData[index].loopCount );
 563   }
 564
 565   if( mAnimationData[index].resendFlag & VectorAnimationTask::RESEND_PLAY_RANGE )
 566   {
 567     SetPlayRange( mAnimationData[index].playRange );
 568   }
 569
 570   if( mAnimationData[index].resendFlag & VectorAnimationTask::RESEND_STOP_BEHAVIOR )
 571   {
 572     SetStopBehavior( mAnimationData[index].stopBehavior );
 573   }
 574
 575   if( mAnimationData[index].resendFlag & VectorAnimationTask::RESEND_LOOPING_MODE )
 576   {
 577     SetLoopingMode( mAnimationData[index].loopingMode );
 578   }
 579
 580   if( mAnimationData[index].resendFlag & VectorAnimationTask::RESEND_CURRENT_FRAME )
 581   {
 582     SetCurrentFrameNumber( mAnimationData[index].currentFrame );
 583   }
 584
 585   if( mAnimationData[index].resendFlag & VectorAnimationTask::RESEND_PLAY_STATE )
 586   {
 587     if( mAnimationData[index].playState == DevelImageVisual::PlayState::PLAYING )
 588     {
 589       PlayAnimation();
 590     }
 591     else if( mAnimationData[index].playState == DevelImageVisual::PlayState::PAUSED )
 592     {
 593       PauseAnimation();
 594     }
 595     else if( mAnimationData[index].playState == DevelImageVisual::PlayState::STOPPED )
 596     {
 597       StopAnimation();
 598     }
 599   }
 600
 601   mAnimationData[index].resendFlag = 0;
 602 }
 603
 604 } // namespace Internal
 605
 606 } // namespace Toolkit
 607
 608 } // namespace Dali