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