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)
  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   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 }
  77
  78 VectorAnimationTask::~VectorAnimationTask()
  79 {
  80   DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "VectorAnimationTask::~VectorAnimationTask: destructor [%p]\n", this);
  81 }
  82
  83 void VectorAnimationTask::Finalize()
  84 {
  85   ConditionalWait::ScopedLock lock(mConditionalWait);
  86
  87   // Release some objects in the main thread
  88   if(mAnimationFinishedTrigger)
  89   {
  90     mAnimationFinishedTrigger.reset();
  91   }
  92
  93   mVectorRenderer.Finalize();
  94
  95   mDestroyTask = true;
  96 }
  97
  98 bool VectorAnimationTask::Load(const std::string& url)
  99 {
 100   mUrl = url;
 101
 102   if(!mVectorRenderer.Load(mUrl))
 103   {
 104     DALI_LOG_ERROR("VectorAnimationTask::Load: Load failed [%s]\n", mUrl.c_str());
 105     return false;
 106   }
 107
 108   mTotalFrame = mVectorRenderer.GetTotalFrameNumber();
 109
 110   mEndFrame = mTotalFrame - 1;
 111
 112   mFrameRate                = mVectorRenderer.GetFrameRate();
 113   mFrameDurationNanoSeconds = NANOSECONDS_PER_SECOND / mFrameRate;
 114
 115   uint32_t width, height;
 116   mVectorRenderer.GetDefaultSize(width, height);
 117
 118   SetSize(width, height);
 119
 120   DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "VectorAnimationTask::Load: file = %s [%d frames, %f fps] [%p]\n", mUrl.c_str(), mTotalFrame, mFrameRate, this);
 121
 122   return true;
 123 }
 124
 125 void VectorAnimationTask::SetRenderer(Renderer renderer)
 126 {
 127   ConditionalWait::ScopedLock lock(mConditionalWait);
 128
 129   mVectorRenderer.SetRenderer(renderer);
 130
 131   DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "VectorAnimationTask::SetRenderer [%p]\n", this);
 132 }
 133
 134 void VectorAnimationTask::SetAnimationData(const AnimationData& data)
 135 {
 136   ConditionalWait::ScopedLock lock(mConditionalWait);
 137
 138   DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "VectorAnimationTask::SetAnimationData [%p]\n", this);
 139
 140   uint32_t index = mAnimationDataIndex == 0 ? 1 : 0; // Use the other buffer
 141
 142   mAnimationData[index] = data;
 143   mAnimationDataUpdated = true;
 144
 145   if(data.resendFlag & VectorAnimationTask::RESEND_SIZE)
 146   {
 147     // The size should be changed in the main thread.
 148     SetSize(data.width, data.height);
 149   }
 150
 151   mVectorAnimationThread.AddTask(this);
 152 }
 153
 154 void VectorAnimationTask::SetSize(uint32_t width, uint32_t height)
 155 {
 156   if(mWidth != width || mHeight != height)
 157   {
 158     mVectorRenderer.SetSize(width, height);
 159
 160     mWidth  = width;
 161     mHeight = height;
 162
 163     DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "VectorAnimationTask::SetSize: width = %d, height = %d [%p]\n", width, height, this);
 164   }
 165 }
 166
 167 void VectorAnimationTask::PlayAnimation()
 168 {
 169   if(mPlayState != PlayState::PLAYING)
 170   {
 171     mNeedAnimationFinishedTrigger = true;
 172     mUpdateFrameNumber            = false;
 173     mPlayState                    = PlayState::PLAYING;
 174
 175     DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "VectorAnimationTask::PlayAnimation: Play [%p]\n", this);
 176   }
 177 }
 178
 179 void VectorAnimationTask::StopAnimation()
 180 {
 181   if(mPlayState != PlayState::STOPPING)
 182   {
 183     mNeedAnimationFinishedTrigger = false;
 184     mPlayState                    = PlayState::STOPPING;
 185
 186     DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "VectorAnimationTask::StopAnimation: Stop [%p]\n", this);
 187   }
 188 }
 189
 190 void VectorAnimationTask::PauseAnimation()
 191 {
 192   if(mPlayState == PlayState::PLAYING)
 193   {
 194     mPlayState = PlayState::PAUSED;
 195
 196     DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "VectorAnimationTask::PauseAnimation: Pause [%p]\n", this);
 197   }
 198 }
 199
 200 void VectorAnimationTask::SetAnimationFinishedCallback(EventThreadCallback* callback)
 201 {
 202   ConditionalWait::ScopedLock lock(mConditionalWait);
 203   if(callback)
 204   {
 205     mAnimationFinishedTrigger = std::unique_ptr<EventThreadCallback>(callback);
 206   }
 207 }
 208
 209 void VectorAnimationTask::SetLoopCount(int32_t count)
 210 {
 211   if(mLoopCount != count)
 212   {
 213     mLoopCount   = count;
 214     mCurrentLoop = 0;
 215
 216     DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "VectorAnimationTask::SetLoopCount: [%d] [%p]\n", count, this);
 217   }
 218 }
 219
 220 void VectorAnimationTask::SetPlayRange(const Property::Array& playRange)
 221 {
 222   bool     valid      = false;
 223   uint32_t startFrame = 0, endFrame = 0;
 224   size_t   count = playRange.Count();
 225
 226   if(count >= 2)
 227   {
 228     int32_t start = 0, end = 0;
 229     if(playRange.GetElementAt(0).Get(start) && playRange.GetElementAt(1).Get(end))
 230     {
 231       startFrame = static_cast<uint32_t>(start);
 232       endFrame   = static_cast<uint32_t>(end);
 233       valid      = true;
 234     }
 235     else
 236     {
 237       std::string startMarker, endMarker;
 238       if(playRange.GetElementAt(0).Get(startMarker) && playRange.GetElementAt(1).Get(endMarker))
 239       {
 240         if(mVectorRenderer)
 241         {
 242           uint32_t frame; // We don't use this later
 243           if(mVectorRenderer.GetMarkerInfo(startMarker, startFrame, frame) && mVectorRenderer.GetMarkerInfo(endMarker, frame, endFrame))
 244           {
 245             valid = true;
 246           }
 247         }
 248       }
 249     }
 250   }
 251   else if(count == 1)
 252   {
 253     std::string marker;
 254     if(playRange.GetElementAt(0).Get(marker))
 255     {
 256       if(mVectorRenderer)
 257       {
 258         mVectorRenderer.GetMarkerInfo(marker, startFrame, endFrame);
 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 + 1 : mCurrentFrame - 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 std::chrono::time_point<std::chrono::system_clock> VectorAnimationTask::CalculateNextFrameTime(bool renderNow)
 525 {
 526   // std::chrono::time_point template has second parameter duration which defaults to the std::chrono::system_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<std::chrono::time_point<std::chrono::system_clock>::duration>(
 530     mNextFrameStartTime + std::chrono::nanoseconds(mFrameDurationNanoSeconds));
 531   auto current = std::chrono::system_clock::now();
 532   if(renderNow || mNextFrameStartTime < current)
 533   {
 534     mNextFrameStartTime = current;
 535   }
 536   return mNextFrameStartTime;
 537 }
 538
 539 std::chrono::time_point<std::chrono::system_clock> VectorAnimationTask::GetNextFrameTime()
 540 {
 541   return mNextFrameStartTime;
 542 }
 543
 544 void VectorAnimationTask::ApplyAnimationData()
 545 {
 546   uint32_t index;
 547
 548   {
 549     ConditionalWait::ScopedLock lock(mConditionalWait);
 550
 551     if(!mAnimationDataUpdated || mAnimationData[mAnimationDataIndex].resendFlag != 0)
 552     {
 553       // Data is not updated or the previous data is not applied yet.
 554       return;
 555     }
 556
 557     mAnimationDataIndex   = mAnimationDataIndex == 0 ? 1 : 0; // Swap index
 558     mAnimationDataUpdated = false;
 559
 560     index = mAnimationDataIndex;
 561   }
 562
 563   if(mAnimationData[index].resendFlag & VectorAnimationTask::RESEND_LOOP_COUNT)
 564   {
 565     SetLoopCount(mAnimationData[index].loopCount);
 566   }
 567
 568   if(mAnimationData[index].resendFlag & VectorAnimationTask::RESEND_PLAY_RANGE)
 569   {
 570     SetPlayRange(mAnimationData[index].playRange);
 571   }
 572
 573   if(mAnimationData[index].resendFlag & VectorAnimationTask::RESEND_STOP_BEHAVIOR)
 574   {
 575     SetStopBehavior(mAnimationData[index].stopBehavior);
 576   }
 577
 578   if(mAnimationData[index].resendFlag & VectorAnimationTask::RESEND_LOOPING_MODE)
 579   {
 580     SetLoopingMode(mAnimationData[index].loopingMode);
 581   }
 582
 583   if(mAnimationData[index].resendFlag & VectorAnimationTask::RESEND_CURRENT_FRAME)
 584   {
 585     SetCurrentFrameNumber(mAnimationData[index].currentFrame);
 586   }
 587
 588   if(mAnimationData[index].resendFlag & VectorAnimationTask::RESEND_PLAY_STATE)
 589   {
 590     if(mAnimationData[index].playState == DevelImageVisual::PlayState::PLAYING)
 591     {
 592       PlayAnimation();
 593     }
 594     else if(mAnimationData[index].playState == DevelImageVisual::PlayState::PAUSED)
 595     {
 596       PauseAnimation();
 597     }
 598     else if(mAnimationData[index].playState == DevelImageVisual::PlayState::STOPPED)
 599     {
 600       StopAnimation();
 601     }
 602   }
 603
 604   mAnimationData[index].resendFlag = 0;
 605 }
 606
 607 } // namespace Internal
 608
 609 } // namespace Toolkit
 610
 611 } // namespace Dali