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