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 && mVectorRenderer.GetMarkerInfo(marker, startFrame, endFrame))
 258       {
 259         valid = true;
 260       }
 261     }
 262   }
 263
 264   if(!valid)
 265   {
 266     DALI_LOG_ERROR("VectorAnimationTask::SetPlayRange: Invalid range [%p]\n", this);
 267     return;
 268   }
 269
 270   // Make sure the range specified is between 0 and the total frame number
 271   if(startFrame < mTotalFrame && endFrame < mTotalFrame)
 272   {
 273     // If the range is not in order swap values
 274     if(startFrame > endFrame)
 275     {
 276       uint32_t temp = startFrame;
 277       startFrame    = endFrame;
 278       endFrame      = temp;
 279     }
 280
 281     if(startFrame != mStartFrame || endFrame != mEndFrame)
 282     {
 283       mStartFrame = startFrame;
 284       mEndFrame   = endFrame;
 285
 286       // If the current frame is out of the range, change the current frame also.
 287       if(mStartFrame > mCurrentFrame)
 288       {
 289         mCurrentFrame = mStartFrame;
 290       }
 291       else if(mEndFrame < mCurrentFrame)
 292       {
 293         mCurrentFrame = mEndFrame;
 294       }
 295
 296       DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "VectorAnimationTask::SetPlayRange: [%d, %d] [%p]\n", mStartFrame, mEndFrame, this);
 297     }
 298   }
 299   else
 300   {
 301     DALI_LOG_ERROR("VectorAnimationTask::SetPlayRange: Invalid range (%d, %d) [%p]\n", startFrame, endFrame, this);
 302     return;
 303   }
 304 }
 305
 306 void VectorAnimationTask::GetPlayRange(uint32_t& startFrame, uint32_t& endFrame)
 307 {
 308   startFrame = mStartFrame;
 309   endFrame   = mEndFrame;
 310 }
 311
 312 void VectorAnimationTask::SetCurrentFrameNumber(uint32_t frameNumber)
 313 {
 314   if(mCurrentFrame == frameNumber)
 315   {
 316     DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "VectorAnimationTask::SetCurrentFrameNumber: Set same frame [%d] [%p]\n", frameNumber, this);
 317     return;
 318   }
 319
 320   if(frameNumber >= mStartFrame && frameNumber <= mEndFrame)
 321   {
 322     mCurrentFrame      = frameNumber;
 323     mUpdateFrameNumber = false;
 324
 325     DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "VectorAnimationTask::SetCurrentFrameNumber: frame number = %d [%p]\n", mCurrentFrame, this);
 326   }
 327   else
 328   {
 329     DALI_LOG_ERROR("Invalid frame number [%d (%d, %d)]\n", frameNumber, mStartFrame, mEndFrame);
 330   }
 331 }
 332
 333 uint32_t VectorAnimationTask::GetCurrentFrameNumber() const
 334 {
 335   return mCurrentFrame;
 336 }
 337
 338 uint32_t VectorAnimationTask::GetTotalFrameNumber() const
 339 {
 340   return mTotalFrame;
 341 }
 342
 343 void VectorAnimationTask::GetDefaultSize(uint32_t& width, uint32_t& height) const
 344 {
 345   mVectorRenderer.GetDefaultSize(width, height);
 346 }
 347
 348 void VectorAnimationTask::SetStopBehavior(DevelImageVisual::StopBehavior::Type stopBehavior)
 349 {
 350   mStopBehavior = stopBehavior;
 351
 352   DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "VectorAnimationTask::SetStopBehavior: stop behavor = %d [%p]\n", mStopBehavior, this);
 353 }
 354
 355 void VectorAnimationTask::SetLoopingMode(DevelImageVisual::LoopingMode::Type loopingMode)
 356 {
 357   mLoopingMode = loopingMode;
 358
 359   DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "VectorAnimationTask::SetLoopingMode: looping mode = %d [%p]\n", mLoopingMode, this);
 360 }
 361
 362 void VectorAnimationTask::GetLayerInfo(Property::Map& map) const
 363 {
 364   mVectorRenderer.GetLayerInfo(map);
 365 }
 366
 367 VectorAnimationTask::UploadCompletedSignalType& VectorAnimationTask::UploadCompletedSignal()
 368 {
 369   return mVectorRenderer.UploadCompletedSignal();
 370 }
 371
 372 bool VectorAnimationTask::Rasterize()
 373 {
 374   bool     stopped = false;
 375   uint32_t currentFrame;
 376
 377   {
 378     ConditionalWait::ScopedLock lock(mConditionalWait);
 379     if(mDestroyTask)
 380     {
 381       // The task will be destroyed. We don't need rasterization.
 382       return false;
 383     }
 384   }
 385
 386   ApplyAnimationData();
 387
 388   if(mPlayState == PlayState::PLAYING && mUpdateFrameNumber)
 389   {
 390     mCurrentFrame = mForward ? mCurrentFrame + mDroppedFrames + 1 : mCurrentFrame - mDroppedFrames - 1;
 391     Dali::ClampInPlace(mCurrentFrame, mStartFrame, mEndFrame);
 392   }
 393
 394   currentFrame = mCurrentFrame;
 395
 396   mUpdateFrameNumber = true;
 397
 398   if(mPlayState == PlayState::STOPPING)
 399   {
 400     mCurrentFrame = GetStoppedFrame(mStartFrame, mEndFrame, mCurrentFrame);
 401     currentFrame  = mCurrentFrame;
 402     stopped       = true;
 403   }
 404   else if(mPlayState == PlayState::PLAYING)
 405   {
 406     bool animationFinished = false;
 407
 408     if(currentFrame >= mEndFrame) // last frame
 409     {
 410       if(mLoopingMode == DevelImageVisual::LoopingMode::AUTO_REVERSE)
 411       {
 412         mForward = false;
 413       }
 414       else
 415       {
 416         if(mLoopCount < 0 || ++mCurrentLoop < mLoopCount) // repeat forever or before the last loop
 417         {
 418           mCurrentFrame      = mStartFrame;
 419           mUpdateFrameNumber = false;
 420         }
 421         else
 422         {
 423           animationFinished = true; // end of animation
 424         }
 425       }
 426     }
 427     else if(currentFrame == mStartFrame && !mForward) // first frame
 428     {
 429       if(mLoopCount < 0 || ++mCurrentLoop < mLoopCount) // repeat forever or before the last loop
 430       {
 431         mForward = true;
 432       }
 433       else
 434       {
 435         animationFinished = true; // end of animation
 436       }
 437     }
 438
 439     if(animationFinished)
 440     {
 441       if(mStopBehavior == DevelImageVisual::StopBehavior::CURRENT_FRAME)
 442       {
 443         stopped = true;
 444       }
 445       else
 446       {
 447         mPlayState = PlayState::STOPPING;
 448       }
 449     }
 450   }
 451
 452   // Rasterize
 453   bool renderSuccess = false;
 454   if(mVectorRenderer)
 455   {
 456     renderSuccess = mVectorRenderer.Render(currentFrame);
 457     if(!renderSuccess)
 458     {
 459       DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "VectorAnimationTask::Rasterize: Rendering failed. Try again later.[%d] [%p]\n", currentFrame, this);
 460       mUpdateFrameNumber = false;
 461     }
 462   }
 463
 464   if(stopped && renderSuccess)
 465   {
 466     mPlayState   = PlayState::STOPPED;
 467     mForward     = true;
 468     mCurrentLoop = 0;
 469
 470     // Animation is finished
 471     {
 472       ConditionalWait::ScopedLock lock(mConditionalWait);
 473       if(mNeedAnimationFinishedTrigger && mAnimationFinishedTrigger)
 474       {
 475         mAnimationFinishedTrigger->Trigger();
 476       }
 477     }
 478
 479     DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "VectorAnimationTask::Rasterize: Animation is finished [current = %d] [%p]\n", currentFrame, this);
 480   }
 481
 482   bool keepAnimation = true;
 483   if(mPlayState == PlayState::PAUSED || mPlayState == PlayState::STOPPED)
 484   {
 485     keepAnimation = false;
 486   }
 487
 488   return keepAnimation;
 489 }
 490
 491 uint32_t VectorAnimationTask::GetStoppedFrame(uint32_t startFrame, uint32_t endFrame, uint32_t currentFrame)
 492 {
 493   uint32_t frame = currentFrame;
 494
 495   switch(mStopBehavior)
 496   {
 497     case DevelImageVisual::StopBehavior::FIRST_FRAME:
 498     {
 499       frame = startFrame;
 500       break;
 501     }
 502     case DevelImageVisual::StopBehavior::LAST_FRAME:
 503     {
 504       if(mLoopingMode == DevelImageVisual::LoopingMode::AUTO_REVERSE)
 505       {
 506         frame = startFrame;
 507       }
 508       else
 509       {
 510         frame = endFrame;
 511       }
 512       break;
 513     }
 514     case DevelImageVisual::StopBehavior::CURRENT_FRAME:
 515     {
 516       frame = currentFrame;
 517       break;
 518     }
 519   }
 520
 521   return frame;
 522 }
 523
 524 VectorAnimationTask::TimePoint VectorAnimationTask::CalculateNextFrameTime(bool renderNow)
 525 {
 526   // std::chrono::time_point template has second parameter duration which defaults to the std::chrono::steady_clock supported
 527   // duration. In some C++11 implementations it is a milliseconds duration, so it fails to compile unless mNextFrameStartTime
 528   // is casted to use the default duration.
 529   mNextFrameStartTime = std::chrono::time_point_cast<TimePoint::duration>(mNextFrameStartTime + std::chrono::microseconds(mFrameDurationMicroSeconds));
 530   auto current        = std::chrono::steady_clock::now();
 531   if(renderNow)
 532   {
 533     mNextFrameStartTime = current;
 534     mDroppedFrames      = 0;
 535   }
 536   else if(mNextFrameStartTime < current)
 537   {
 538     uint32_t droppedFrames = 0;
 539
 540     while(current > std::chrono::time_point_cast<TimePoint::duration>(mNextFrameStartTime + std::chrono::microseconds(mFrameDurationMicroSeconds)) && droppedFrames < mTotalFrame)
 541     {
 542       droppedFrames++;
 543       mNextFrameStartTime = std::chrono::time_point_cast<TimePoint::duration>(mNextFrameStartTime + std::chrono::microseconds(mFrameDurationMicroSeconds));
 544     }
 545
 546     mNextFrameStartTime = current;
 547     mDroppedFrames      = droppedFrames;
 548   }
 549
 550   return mNextFrameStartTime;
 551 }
 552
 553 VectorAnimationTask::TimePoint VectorAnimationTask::GetNextFrameTime()
 554 {
 555   return mNextFrameStartTime;
 556 }
 557
 558 void VectorAnimationTask::ApplyAnimationData()
 559 {
 560   uint32_t index;
 561
 562   {
 563     ConditionalWait::ScopedLock lock(mConditionalWait);
 564
 565     if(!mAnimationDataUpdated || mAnimationData[mAnimationDataIndex].resendFlag != 0)
 566     {
 567       // Data is not updated or the previous data is not applied yet.
 568       return;
 569     }
 570
 571     mAnimationDataIndex   = mAnimationDataIndex == 0 ? 1 : 0; // Swap index
 572     mAnimationDataUpdated = false;
 573
 574     index = mAnimationDataIndex;
 575   }
 576
 577   if(mAnimationData[index].resendFlag & VectorAnimationTask::RESEND_LOOP_COUNT)
 578   {
 579     SetLoopCount(mAnimationData[index].loopCount);
 580   }
 581
 582   if(mAnimationData[index].resendFlag & VectorAnimationTask::RESEND_PLAY_RANGE)
 583   {
 584     SetPlayRange(mAnimationData[index].playRange);
 585   }
 586
 587   if(mAnimationData[index].resendFlag & VectorAnimationTask::RESEND_STOP_BEHAVIOR)
 588   {
 589     SetStopBehavior(mAnimationData[index].stopBehavior);
 590   }
 591
 592   if(mAnimationData[index].resendFlag & VectorAnimationTask::RESEND_LOOPING_MODE)
 593   {
 594     SetLoopingMode(mAnimationData[index].loopingMode);
 595   }
 596
 597   if(mAnimationData[index].resendFlag & VectorAnimationTask::RESEND_CURRENT_FRAME)
 598   {
 599     SetCurrentFrameNumber(mAnimationData[index].currentFrame);
 600   }
 601
 602   if(mAnimationData[index].resendFlag & VectorAnimationTask::RESEND_PLAY_STATE)
 603   {
 604     if(mAnimationData[index].playState == DevelImageVisual::PlayState::PLAYING)
 605     {
 606       PlayAnimation();
 607     }
 608     else if(mAnimationData[index].playState == DevelImageVisual::PlayState::PAUSED)
 609     {
 610       PauseAnimation();
 611     }
 612     else if(mAnimationData[index].playState == DevelImageVisual::PlayState::STOPPED)
 613     {
 614       StopAnimation();
 615     }
 616   }
 617
 618   mAnimationData[index].resendFlag = 0;
 619 }
 620
 621 } // namespace Internal
 622
 623 } // namespace Toolkit
 624
 625 } // namespace Dali