dali-toolkit/internal/visuals/animated-vector-image/vector-animation-task.cpp

   1 /*
   2  * Copyright (c) 2023 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/devel-api/adaptor-framework/file-loader.h>
  23 #include <dali/integration-api/debug.h>
  24 #include <dali/integration-api/trace.h>
  25 #include <dali/public-api/math/math-utils.h>
  26 #include <dali/public-api/object/property-array.h>
  27
  28 // INTERNAL INCLUDES
  29 #include <dali-toolkit/internal/visuals/animated-vector-image/vector-animation-manager.h>
  30 #include <dali-toolkit/internal/visuals/animated-vector-image/vector-animation-thread.h>
  31 #include <dali-toolkit/internal/visuals/image-visual-shader-factory.h>
  32
  33 #ifdef TRACE_ENABLED
  34 #include <sstream>
  35 #endif
  36
  37 namespace Dali
  38 {
  39 namespace Toolkit
  40 {
  41 namespace Internal
  42 {
  43 namespace
  44 {
  45 constexpr auto LOOP_FOREVER = -1;
  46 constexpr auto MICROSECONDS_PER_SECOND(1e+6);
  47
  48 #if defined(DEBUG_ENABLED)
  49 Debug::Filter* gVectorAnimationLogFilter = Debug::Filter::New(Debug::NoLogging, false, "LOG_VECTOR_ANIMATION");
  50 #endif
  51
  52 DALI_INIT_TRACE_FILTER(gTraceFilter, DALI_TRACE_IMAGE_PERFORMANCE_MARKER, false);
  53
  54 } // unnamed namespace
  55
  56 VectorAnimationTask::VectorAnimationTask(VisualFactoryCache& factoryCache)
  57 : AsyncTask(MakeCallback(this, &VectorAnimationTask::TaskCompleted), AsyncTask::PriorityType::HIGH, AsyncTask::ThreadType::WORKER_THREAD),
  58   mImageUrl(),
  59   mEncodedImageBuffer(),
  60   mVectorRenderer(VectorAnimationRenderer::New()),
  61   mAnimationData(),
  62   mVectorAnimationThread(factoryCache.GetVectorAnimationManager().GetVectorAnimationThread()),
  63   mConditionalWait(),
  64   mResourceReadySignal(),
  65   mLoadCompletedCallback(MakeCallback(this, &VectorAnimationTask::OnLoadCompleted)),
  66   mPlayState(PlayState::STOPPED),
  67   mStopBehavior(DevelImageVisual::StopBehavior::CURRENT_FRAME),
  68   mLoopingMode(DevelImageVisual::LoopingMode::RESTART),
  69   mNextFrameStartTime(),
  70   mFrameDurationMicroSeconds(MICROSECONDS_PER_SECOND / 60.0f),
  71   mFrameRate(60.0f),
  72   mCurrentFrame(0),
  73   mTotalFrame(0),
  74   mStartFrame(0),
  75   mEndFrame(0),
  76   mDroppedFrames(0),
  77   mWidth(0),
  78   mHeight(0),
  79   mAnimationDataIndex(0),
  80   mLoopCount(LOOP_FOREVER),
  81   mCurrentLoop(0),
  82   mForward(true),
  83   mUpdateFrameNumber(false),
  84   mNeedAnimationFinishedTrigger(true),
  85   mAnimationDataUpdated(false),
  86   mDestroyTask(false),
  87   mLoadRequest(false),
  88   mLoadFailed(false),
  89   mRasterized(false),
  90   mKeepAnimation(false)
  91 {
  92   mVectorRenderer.UploadCompletedSignal().Connect(this, &VectorAnimationTask::OnUploadCompleted);
  93 }
  94
  95 VectorAnimationTask::~VectorAnimationTask()
  96 {
  97   DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "VectorAnimationTask::~VectorAnimationTask: destructor [%p]\n", this);
  98 }
  99
 100 void VectorAnimationTask::Process()
 101 {
 102   mRasterized = Rasterize();
 103 }
 104
 105 bool VectorAnimationTask::IsReady()
 106 {
 107   return true;
 108 }
 109
 110 void VectorAnimationTask::Finalize()
 111 {
 112   ConditionalWait::ScopedLock lock(mConditionalWait);
 113
 114   // Release some objects in the main thread
 115   if(mAnimationFinishedCallback)
 116   {
 117     mVectorAnimationThread.RemoveEventTriggerCallback(mAnimationFinishedCallback.get());
 118     mAnimationFinishedCallback.reset();
 119   }
 120   if(mLoadCompletedCallback)
 121   {
 122     mVectorAnimationThread.RemoveEventTriggerCallback(mLoadCompletedCallback.get());
 123     mLoadCompletedCallback.reset();
 124   }
 125
 126   mVectorRenderer.Finalize();
 127
 128   mDestroyTask = true;
 129 }
 130
 131 void VectorAnimationTask::TaskCompleted(VectorAnimationTaskPtr task)
 132 {
 133   mVectorAnimationThread.OnTaskCompleted(task, task->IsRasterized(), task->IsAnimating());
 134 }
 135
 136 bool VectorAnimationTask::IsRasterized()
 137 {
 138   return mRasterized;
 139 }
 140
 141 bool VectorAnimationTask::IsAnimating()
 142 {
 143   return mKeepAnimation;
 144 }
 145
 146 bool VectorAnimationTask::Load(bool synchronousLoading)
 147 {
 148 #ifdef TRACE_ENABLED
 149   if(gTraceFilter && gTraceFilter->IsTraceEnabled())
 150   {
 151     std::ostringstream oss;
 152     oss << "[url:" << mImageUrl.GetUrl() << "]";
 153     // DALI_TRACE_BEGIN(gTraceFilter, "DALI_LOTTIE_LOADING_TASK"); ///< TODO : Open it if we can control trace log level
 154     DALI_LOG_RELEASE_INFO("BEGIN: DALI_LOTTIE_LOADING_TASK %s", oss.str().c_str());
 155   }
 156 #endif
 157
 158   if(mEncodedImageBuffer)
 159   {
 160     if(!mVectorRenderer.Load(mEncodedImageBuffer.GetRawBuffer()))
 161     {
 162       mLoadFailed = true;
 163     }
 164
 165     // We don't need to hold image buffer anymore.
 166     mEncodedImageBuffer.Reset();
 167   }
 168   else if(mImageUrl.IsLocalResource())
 169   {
 170     if(!mVectorRenderer.Load(mImageUrl.GetUrl()))
 171     {
 172       mLoadFailed = true;
 173     }
 174   }
 175   else
 176   {
 177     Dali::Vector<uint8_t> remoteData;
 178     if(!Dali::FileLoader::DownloadFileSynchronously(mImageUrl.GetUrl(), remoteData) || // Failed if we fail to download json file,
 179        !mVectorRenderer.Load(remoteData))                                              // or download data is not valid vector animation file.
 180     {
 181       mLoadFailed = true;
 182     }
 183   }
 184
 185   if(mLoadFailed)
 186   {
 187     DALI_LOG_ERROR("VectorAnimationTask::Load: Load failed [%s]\n", mImageUrl.GetUrl().c_str());
 188     mLoadRequest = false;
 189     if(!synchronousLoading && mLoadCompletedCallback)
 190     {
 191       mVectorAnimationThread.AddEventTriggerCallback(mLoadCompletedCallback.get());
 192     }
 193 #ifdef TRACE_ENABLED
 194     if(gTraceFilter && gTraceFilter->IsTraceEnabled())
 195     {
 196       std::ostringstream oss;
 197       oss << "[url:" << mImageUrl.GetUrl() << "]";
 198       // DALI_TRACE_END(gTraceFilter, "DALI_LOTTIE_LOADING_TASK"); ///< TODO : Open it if we can control trace log level
 199       DALI_LOG_RELEASE_INFO("END: DALI_LOTTIE_LOADING_TASK %s", oss.str().c_str());
 200     }
 201 #endif
 202     return false;
 203   }
 204
 205   mTotalFrame = mVectorRenderer.GetTotalFrameNumber();
 206
 207   mEndFrame = mTotalFrame - 1;
 208
 209   mFrameRate                 = mVectorRenderer.GetFrameRate();
 210   mFrameDurationMicroSeconds = MICROSECONDS_PER_SECOND / mFrameRate;
 211
 212   mLoadRequest = false;
 213   if(!synchronousLoading && mLoadCompletedCallback)
 214   {
 215     mVectorAnimationThread.AddEventTriggerCallback(mLoadCompletedCallback.get());
 216   }
 217
 218   DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "VectorAnimationTask::Load: file = %s [%d frames, %f fps] [%p]\n", mImageUrl.GetUrl().c_str(), mTotalFrame, mFrameRate, this);
 219
 220 #ifdef TRACE_ENABLED
 221   if(gTraceFilter && gTraceFilter->IsTraceEnabled())
 222   {
 223     std::ostringstream oss;
 224     oss << "[url:" << mImageUrl.GetUrl() << "]";
 225     // DALI_TRACE_END(gTraceFilter, "DALI_LOTTIE_LOADING_TASK"); ///< TODO : Open it if we can control trace log level
 226     DALI_LOG_RELEASE_INFO("END: DALI_LOTTIE_LOADING_TASK %s", oss.str().c_str());
 227   }
 228 #endif
 229
 230   return true;
 231 }
 232
 233 void VectorAnimationTask::SetRenderer(Renderer renderer)
 234 {
 235   ConditionalWait::ScopedLock lock(mConditionalWait);
 236
 237   mVectorRenderer.SetRenderer(renderer);
 238
 239   DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "VectorAnimationTask::SetRenderer [%p]\n", this);
 240 }
 241
 242 void VectorAnimationTask::RequestLoad(const VisualUrl& url, EncodedImageBuffer encodedImageBuffer, bool synchronousLoading)
 243 {
 244   mImageUrl           = url;
 245   mEncodedImageBuffer = encodedImageBuffer;
 246
 247   if(!synchronousLoading)
 248   {
 249     mLoadRequest = true;
 250
 251     mVectorAnimationThread.AddTask(this);
 252   }
 253   else
 254   {
 255     Load(true);
 256
 257     OnLoadCompleted();
 258   }
 259 }
 260
 261 bool VectorAnimationTask::IsLoadRequested() const
 262 {
 263   return mLoadRequest;
 264 }
 265
 266 void VectorAnimationTask::SetAnimationData(const AnimationData& data)
 267 {
 268   ConditionalWait::ScopedLock lock(mConditionalWait);
 269
 270   DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "VectorAnimationTask::SetAnimationData [%p]\n", this);
 271
 272   uint32_t index = mAnimationDataIndex == 0 ? 1 : 0; // Use the other buffer
 273
 274   mAnimationData[index].push_back(data);
 275   mAnimationDataUpdated = true;
 276
 277   if(data.resendFlag & VectorAnimationTask::RESEND_SIZE)
 278   {
 279     // The size should be changed in the main thread.
 280     SetSize(data.width, data.height);
 281   }
 282
 283   mVectorAnimationThread.AddTask(this);
 284 }
 285
 286 void VectorAnimationTask::SetSize(uint32_t width, uint32_t height)
 287 {
 288   if(mWidth != width || mHeight != height)
 289   {
 290     mVectorRenderer.SetSize(width, height);
 291
 292     mWidth  = width;
 293     mHeight = height;
 294
 295     DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "VectorAnimationTask::SetSize: width = %d, height = %d [%p]\n", width, height, this);
 296   }
 297 }
 298
 299 void VectorAnimationTask::PlayAnimation()
 300 {
 301   if(mPlayState != PlayState::PLAYING)
 302   {
 303     mNeedAnimationFinishedTrigger = true;
 304     mUpdateFrameNumber            = false;
 305     mPlayState                    = PlayState::PLAYING;
 306
 307     DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "VectorAnimationTask::PlayAnimation: Play [%p]\n", this);
 308   }
 309 }
 310
 311 void VectorAnimationTask::StopAnimation()
 312 {
 313   if(mPlayState != PlayState::STOPPING)
 314   {
 315     mNeedAnimationFinishedTrigger = false;
 316     mPlayState                    = PlayState::STOPPING;
 317
 318     DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "VectorAnimationTask::StopAnimation: Stop [%p]\n", this);
 319   }
 320 }
 321
 322 void VectorAnimationTask::PauseAnimation()
 323 {
 324   if(mPlayState == PlayState::PLAYING)
 325   {
 326     mPlayState = PlayState::PAUSED;
 327
 328     DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "VectorAnimationTask::PauseAnimation: Pause [%p]\n", this);
 329   }
 330 }
 331
 332 void VectorAnimationTask::SetAnimationFinishedCallback(CallbackBase* callback)
 333 {
 334   ConditionalWait::ScopedLock lock(mConditionalWait);
 335   mAnimationFinishedCallback = std::unique_ptr<CallbackBase>(callback);
 336 }
 337
 338 void VectorAnimationTask::SetLoopCount(int32_t count)
 339 {
 340   if(mLoopCount != count)
 341   {
 342     mLoopCount   = count;
 343     mCurrentLoop = 0;
 344
 345     DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "VectorAnimationTask::SetLoopCount: [%d] [%p]\n", count, this);
 346   }
 347 }
 348
 349 void VectorAnimationTask::SetPlayRange(const Property::Array& playRange)
 350 {
 351   bool     valid      = false;
 352   uint32_t startFrame = 0, endFrame = 0;
 353   size_t   count = playRange.Count();
 354
 355   if(count >= 2)
 356   {
 357     int32_t start = 0, end = 0;
 358     if(playRange.GetElementAt(0).Get(start) && playRange.GetElementAt(1).Get(end))
 359     {
 360       startFrame = static_cast<uint32_t>(start);
 361       endFrame   = static_cast<uint32_t>(end);
 362       valid      = true;
 363     }
 364     else
 365     {
 366       std::string startMarker, endMarker;
 367       if(playRange.GetElementAt(0).Get(startMarker) && playRange.GetElementAt(1).Get(endMarker))
 368       {
 369         if(mVectorRenderer)
 370         {
 371           uint32_t frame; // We don't use this later
 372           if(mVectorRenderer.GetMarkerInfo(startMarker, startFrame, frame) && mVectorRenderer.GetMarkerInfo(endMarker, frame, endFrame))
 373           {
 374             valid = true;
 375           }
 376         }
 377       }
 378     }
 379   }
 380   else if(count == 1)
 381   {
 382     std::string marker;
 383     if(playRange.GetElementAt(0).Get(marker))
 384     {
 385       if(mVectorRenderer && mVectorRenderer.GetMarkerInfo(marker, startFrame, endFrame))
 386       {
 387         valid = true;
 388       }
 389     }
 390   }
 391
 392   if(!valid)
 393   {
 394     DALI_LOG_ERROR("VectorAnimationTask::SetPlayRange: Invalid range [%p]\n", this);
 395     return;
 396   }
 397
 398   // Make sure the range specified is between 0 and the total frame number
 399   startFrame = std::min(startFrame, mTotalFrame - 1);
 400   endFrame   = std::min(endFrame, mTotalFrame - 1);
 401
 402   // If the range is not in order swap values
 403   if(startFrame > endFrame)
 404   {
 405     uint32_t temp = startFrame;
 406     startFrame    = endFrame;
 407     endFrame      = temp;
 408   }
 409
 410   if(startFrame != mStartFrame || endFrame != mEndFrame)
 411   {
 412     mStartFrame = startFrame;
 413     mEndFrame   = endFrame;
 414
 415     // If the current frame is out of the range, change the current frame also.
 416     if(mStartFrame > mCurrentFrame)
 417     {
 418       mCurrentFrame = mStartFrame;
 419     }
 420     else if(mEndFrame < mCurrentFrame)
 421     {
 422       mCurrentFrame = mEndFrame;
 423     }
 424
 425     DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "VectorAnimationTask::SetPlayRange: [%d, %d] [%s] [%p]\n", mStartFrame, mEndFrame, mImageUrl.GetUrl().c_str(), this);
 426   }
 427 }
 428
 429 void VectorAnimationTask::GetPlayRange(uint32_t& startFrame, uint32_t& endFrame)
 430 {
 431   startFrame = mStartFrame;
 432   endFrame   = mEndFrame;
 433 }
 434
 435 void VectorAnimationTask::SetCurrentFrameNumber(uint32_t frameNumber)
 436 {
 437   if(mCurrentFrame == frameNumber)
 438   {
 439     DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "VectorAnimationTask::SetCurrentFrameNumber: Set same frame [%d] [%p]\n", frameNumber, this);
 440     return;
 441   }
 442
 443   if(frameNumber >= mStartFrame && frameNumber <= mEndFrame)
 444   {
 445     mCurrentFrame      = frameNumber;
 446     mUpdateFrameNumber = false;
 447
 448     DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "VectorAnimationTask::SetCurrentFrameNumber: frame number = %d [%p]\n", mCurrentFrame, this);
 449   }
 450   else
 451   {
 452     DALI_LOG_ERROR("Invalid frame number [%d (%d, %d)] [%p]\n", frameNumber, mStartFrame, mEndFrame, this);
 453   }
 454 }
 455
 456 uint32_t VectorAnimationTask::GetCurrentFrameNumber() const
 457 {
 458   return mCurrentFrame;
 459 }
 460
 461 uint32_t VectorAnimationTask::GetTotalFrameNumber() const
 462 {
 463   return mTotalFrame;
 464 }
 465
 466 void VectorAnimationTask::GetDefaultSize(uint32_t& width, uint32_t& height) const
 467 {
 468   mVectorRenderer.GetDefaultSize(width, height);
 469 }
 470
 471 void VectorAnimationTask::SetStopBehavior(DevelImageVisual::StopBehavior::Type stopBehavior)
 472 {
 473   mStopBehavior = stopBehavior;
 474
 475   DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "VectorAnimationTask::SetStopBehavior: stop behavor = %d [%p]\n", mStopBehavior, this);
 476 }
 477
 478 void VectorAnimationTask::SetLoopingMode(DevelImageVisual::LoopingMode::Type loopingMode)
 479 {
 480   mLoopingMode = loopingMode;
 481
 482   DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "VectorAnimationTask::SetLoopingMode: looping mode = %d [%p]\n", mLoopingMode, this);
 483 }
 484
 485 void VectorAnimationTask::GetLayerInfo(Property::Map& map) const
 486 {
 487   mVectorRenderer.GetLayerInfo(map);
 488 }
 489
 490 void VectorAnimationTask::GetMarkerInfo(Property::Map& map) const
 491 {
 492   mVectorRenderer.GetMarkerInfo(map);
 493 }
 494
 495 VectorAnimationTask::ResourceReadySignalType& VectorAnimationTask::ResourceReadySignal()
 496 {
 497   return mResourceReadySignal;
 498 }
 499
 500 bool VectorAnimationTask::Rasterize()
 501 {
 502   bool     stopped = false;
 503   uint32_t currentFrame;
 504   mKeepAnimation = false;
 505
 506   {
 507     ConditionalWait::ScopedLock lock(mConditionalWait);
 508     if(mDestroyTask)
 509     {
 510       // The task will be destroyed. We don't need rasterization.
 511       return false;
 512     }
 513   }
 514
 515   if(mLoadRequest)
 516   {
 517     return Load(false);
 518   }
 519
 520   if(mLoadFailed)
 521   {
 522     return false;
 523   }
 524
 525 #ifdef TRACE_ENABLED
 526   if(gTraceFilter && gTraceFilter->IsTraceEnabled())
 527   {
 528     std::ostringstream oss;
 529     oss << "[size:" << mWidth << "x" << mHeight << " ";
 530     oss << "url:" << mImageUrl.GetUrl() << "]";
 531     DALI_TRACE_BEGIN_WITH_MESSAGE(gTraceFilter, "DALI_LOTTIE_RASTERIZE_TASK", oss.str().c_str());
 532   }
 533 #endif
 534
 535   ApplyAnimationData();
 536
 537   if(mPlayState == PlayState::PLAYING && mUpdateFrameNumber)
 538   {
 539     mCurrentFrame = mForward ? mCurrentFrame + mDroppedFrames + 1 : (mCurrentFrame > mDroppedFrames ? mCurrentFrame - mDroppedFrames - 1 : 0);
 540     Dali::ClampInPlace(mCurrentFrame, mStartFrame, mEndFrame);
 541   }
 542
 543   currentFrame = mCurrentFrame;
 544
 545   mUpdateFrameNumber = true;
 546
 547   if(mPlayState == PlayState::STOPPING)
 548   {
 549     mCurrentFrame = GetStoppedFrame(mStartFrame, mEndFrame, mCurrentFrame);
 550     currentFrame  = mCurrentFrame;
 551     stopped       = true;
 552   }
 553   else if(mPlayState == PlayState::PLAYING)
 554   {
 555     bool animationFinished = false;
 556
 557     if(currentFrame >= mEndFrame) // last frame
 558     {
 559       if(mLoopingMode == DevelImageVisual::LoopingMode::AUTO_REVERSE)
 560       {
 561         mForward = false;
 562       }
 563       else
 564       {
 565         if(mLoopCount < 0 || ++mCurrentLoop < mLoopCount) // repeat forever or before the last loop
 566         {
 567           mCurrentFrame      = mStartFrame;
 568           mUpdateFrameNumber = false;
 569         }
 570         else
 571         {
 572           animationFinished = true; // end of animation
 573         }
 574       }
 575     }
 576     else if(currentFrame == mStartFrame && !mForward) // first frame
 577     {
 578       if(mLoopCount < 0 || ++mCurrentLoop < mLoopCount) // repeat forever or before the last loop
 579       {
 580         mForward = true;
 581       }
 582       else
 583       {
 584         animationFinished = true; // end of animation
 585       }
 586     }
 587
 588     if(animationFinished)
 589     {
 590       if(mStopBehavior == DevelImageVisual::StopBehavior::CURRENT_FRAME)
 591       {
 592         stopped = true;
 593       }
 594       else
 595       {
 596         mPlayState = PlayState::STOPPING;
 597       }
 598     }
 599   }
 600
 601   // Rasterize
 602   bool renderSuccess = false;
 603   if(mVectorRenderer)
 604   {
 605     renderSuccess = mVectorRenderer.Render(currentFrame);
 606     if(!renderSuccess)
 607     {
 608       DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "VectorAnimationTask::Rasterize: Rendering failed. Try again later.[%d] [%p]\n", currentFrame, this);
 609       mUpdateFrameNumber = false;
 610     }
 611   }
 612
 613   if(stopped && renderSuccess)
 614   {
 615     mPlayState   = PlayState::STOPPED;
 616     mForward     = true;
 617     mCurrentLoop = 0;
 618
 619     if(mVectorRenderer)
 620     {
 621       // Notify the Renderer that rendering is stopped.
 622       mVectorRenderer.RenderStopped();
 623     }
 624
 625     // Animation is finished
 626     {
 627       ConditionalWait::ScopedLock lock(mConditionalWait);
 628       if(mNeedAnimationFinishedTrigger && mAnimationFinishedCallback)
 629       {
 630         mVectorAnimationThread.AddEventTriggerCallback(mAnimationFinishedCallback.get());
 631       }
 632     }
 633
 634     DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "VectorAnimationTask::Rasterize: Animation is finished [current = %d] [%p]\n", currentFrame, this);
 635   }
 636
 637   if(mPlayState != PlayState::PAUSED && mPlayState != PlayState::STOPPED)
 638   {
 639     mKeepAnimation = true;
 640   }
 641
 642 #ifdef TRACE_ENABLED
 643   if(gTraceFilter && gTraceFilter->IsTraceEnabled())
 644   {
 645     std::ostringstream oss;
 646     oss << "[size:" << mWidth << "x" << mHeight << " ";
 647     oss << "frame:" << mCurrentFrame << " ";
 648     oss << "loop:" << mCurrentLoop << " ";
 649     oss << "state:" << mPlayState << " ";
 650     oss << "url:" << mImageUrl.GetUrl() << "]";
 651     DALI_TRACE_END_WITH_MESSAGE(gTraceFilter, "DALI_LOTTIE_RASTERIZE_TASK", oss.str().c_str());
 652   }
 653 #endif
 654
 655   return true;
 656 }
 657
 658 uint32_t VectorAnimationTask::GetStoppedFrame(uint32_t startFrame, uint32_t endFrame, uint32_t currentFrame)
 659 {
 660   uint32_t frame = currentFrame;
 661
 662   switch(mStopBehavior)
 663   {
 664     case DevelImageVisual::StopBehavior::FIRST_FRAME:
 665     {
 666       frame = startFrame;
 667       break;
 668     }
 669     case DevelImageVisual::StopBehavior::LAST_FRAME:
 670     {
 671       if(mLoopingMode == DevelImageVisual::LoopingMode::AUTO_REVERSE)
 672       {
 673         frame = startFrame;
 674       }
 675       else
 676       {
 677         frame = endFrame;
 678       }
 679       break;
 680     }
 681     case DevelImageVisual::StopBehavior::CURRENT_FRAME:
 682     {
 683       frame = currentFrame;
 684       break;
 685     }
 686   }
 687
 688   return frame;
 689 }
 690
 691 VectorAnimationTask::TimePoint VectorAnimationTask::CalculateNextFrameTime(bool renderNow)
 692 {
 693   // std::chrono::time_point template has second parameter duration which defaults to the std::chrono::steady_clock supported
 694   // duration. In some C++11 implementations it is a milliseconds duration, so it fails to compile unless mNextFrameStartTime
 695   // is casted to use the default duration.
 696   mNextFrameStartTime = std::chrono::time_point_cast<TimePoint::duration>(mNextFrameStartTime + std::chrono::microseconds(mFrameDurationMicroSeconds));
 697   auto current        = std::chrono::steady_clock::now();
 698   mDroppedFrames      = 0;
 699
 700   if(renderNow)
 701   {
 702     mNextFrameStartTime = current;
 703   }
 704   else if(mNextFrameStartTime < current)
 705   {
 706     uint32_t droppedFrames = 0;
 707
 708     while(current > std::chrono::time_point_cast<TimePoint::duration>(mNextFrameStartTime + std::chrono::microseconds(mFrameDurationMicroSeconds)) && droppedFrames < mTotalFrame)
 709     {
 710       droppedFrames++;
 711       mNextFrameStartTime = std::chrono::time_point_cast<TimePoint::duration>(mNextFrameStartTime + std::chrono::microseconds(mFrameDurationMicroSeconds));
 712     }
 713
 714     mNextFrameStartTime = current;
 715     mDroppedFrames      = droppedFrames;
 716   }
 717
 718   return mNextFrameStartTime;
 719 }
 720
 721 VectorAnimationTask::TimePoint VectorAnimationTask::GetNextFrameTime()
 722 {
 723   return mNextFrameStartTime;
 724 }
 725
 726 void VectorAnimationTask::ApplyAnimationData()
 727 {
 728   uint32_t index;
 729
 730   {
 731     ConditionalWait::ScopedLock lock(mConditionalWait);
 732
 733     if(!mAnimationDataUpdated || mAnimationData[mAnimationDataIndex].size() != 0)
 734     {
 735       // Data is not updated or the previous data is not applied yet.
 736       return;
 737     }
 738
 739     mAnimationDataIndex   = mAnimationDataIndex == 0 ? 1 : 0; // Swap index
 740     mAnimationDataUpdated = false;
 741
 742     index = mAnimationDataIndex;
 743   }
 744
 745   for(const auto& animationData : mAnimationData[index])
 746   {
 747     if(animationData.resendFlag & VectorAnimationTask::RESEND_LOOP_COUNT)
 748     {
 749       SetLoopCount(animationData.loopCount);
 750     }
 751
 752     if(animationData.resendFlag & VectorAnimationTask::RESEND_PLAY_RANGE)
 753     {
 754       SetPlayRange(animationData.playRange);
 755     }
 756
 757     if(animationData.resendFlag & VectorAnimationTask::RESEND_STOP_BEHAVIOR)
 758     {
 759       SetStopBehavior(animationData.stopBehavior);
 760     }
 761
 762     if(animationData.resendFlag & VectorAnimationTask::RESEND_LOOPING_MODE)
 763     {
 764       SetLoopingMode(animationData.loopingMode);
 765     }
 766
 767     if(animationData.resendFlag & VectorAnimationTask::RESEND_CURRENT_FRAME)
 768     {
 769       SetCurrentFrameNumber(animationData.currentFrame);
 770     }
 771
 772     if(animationData.resendFlag & VectorAnimationTask::RESEND_NEED_RESOURCE_READY)
 773     {
 774       mVectorRenderer.InvalidateBuffer();
 775     }
 776
 777     if(animationData.resendFlag & VectorAnimationTask::RESEND_DYNAMIC_PROPERTY)
 778     {
 779       for(auto&& iter : animationData.dynamicProperties)
 780       {
 781         mVectorRenderer.AddPropertyValueCallback(iter.keyPath, static_cast<VectorAnimationRenderer::VectorProperty>(iter.property), iter.callback, iter.id);
 782       }
 783     }
 784
 785     if(animationData.resendFlag & VectorAnimationTask::RESEND_PLAY_STATE)
 786     {
 787       if(animationData.playState == DevelImageVisual::PlayState::PLAYING)
 788       {
 789         PlayAnimation();
 790       }
 791       else if(animationData.playState == DevelImageVisual::PlayState::PAUSED)
 792       {
 793         PauseAnimation();
 794       }
 795       else if(animationData.playState == DevelImageVisual::PlayState::STOPPED)
 796       {
 797         StopAnimation();
 798       }
 799     }
 800   }
 801
 802   // reset data list
 803   mAnimationData[index].clear();
 804 }
 805
 806 void VectorAnimationTask::OnUploadCompleted()
 807 {
 808   mResourceReadySignal.Emit(ResourceStatus::READY);
 809 }
 810
 811 void VectorAnimationTask::OnLoadCompleted()
 812 {
 813   if(!mLoadFailed)
 814   {
 815     mResourceReadySignal.Emit(ResourceStatus::LOADED);
 816   }
 817   else
 818   {
 819     mResourceReadySignal.Emit(ResourceStatus::FAILED);
 820   }
 821 }
 822 } // namespace Internal
 823
 824 } // namespace Toolkit
 825
 826 } // namespace Dali