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

   1 #ifndef DALI_TOOLKIT_VECTOR_ANIMATION_TASK_H
   2 #define DALI_TOOLKIT_VECTOR_ANIMATION_TASK_H
   3
   4 /*
   5  * Copyright (c) 2024 Samsung Electronics Co., Ltd.
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  * http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  */
  19
  20 // EXTERNAL INCLUDES
  21 #include <dali/devel-api/adaptor-framework/event-thread-callback.h>
  22 #include <dali/devel-api/adaptor-framework/vector-animation-renderer.h>
  23 #include <dali/devel-api/threading/mutex.h>
  24 #include <dali/public-api/adaptor-framework/async-task-manager.h>
  25 #include <dali/public-api/adaptor-framework/encoded-image-buffer.h>
  26 #include <dali/public-api/common/vector-wrapper.h>
  27 #include <dali/public-api/object/property-array.h>
  28 #include <chrono>
  29 #include <memory>
  30
  31 // INTERNAL INCLUDES
  32 #include <dali-toolkit/devel-api/visuals/animated-vector-image-visual-actions-devel.h>
  33 #include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
  34 #include <dali-toolkit/internal/visuals/visual-url.h>
  35
  36 namespace Dali
  37 {
  38 namespace Toolkit
  39 {
  40 namespace Internal
  41 {
  42 class VisualFactoryCache;
  43 class VectorAnimationThread;
  44 class VectorAnimationTask;
  45 typedef IntrusivePtr<VectorAnimationTask> VectorAnimationTaskPtr;
  46
  47 /**
  48  * The task of the vector animation.
  49  */
  50 class VectorAnimationTask : public AsyncTask, public ConnectionTracker
  51 {
  52 public:
  53   enum class ResourceStatus
  54   {
  55     LOADED, /// Resource is loaded
  56     READY,  /// Resource is ready
  57     FAILED  /// Resource is fail to load
  58   };
  59
  60   using ResourceReadySignalType = Signal<void(ResourceStatus)>;
  61
  62   using TimePoint           = std::chrono::time_point<std::chrono::steady_clock>;
  63   using DynamicPropertyType = std::vector<DevelAnimatedVectorImageVisual::DynamicPropertyInfo>;
  64
  65   /**
  66    * Flags for re-sending data to the vector animation thread
  67    */
  68   enum ResendFlags
  69   {
  70     RESEND_PLAY_RANGE          = 1 << 0,
  71     RESEND_LOOP_COUNT          = 1 << 1,
  72     RESEND_STOP_BEHAVIOR       = 1 << 2,
  73     RESEND_LOOPING_MODE        = 1 << 3,
  74     RESEND_CURRENT_FRAME       = 1 << 4,
  75     RESEND_SIZE                = 1 << 5,
  76     RESEND_PLAY_STATE          = 1 << 6,
  77     RESEND_NEED_RESOURCE_READY = 1 << 7,
  78     RESEND_DYNAMIC_PROPERTY    = 1 << 8
  79   };
  80
  81   /**
  82    * @brief Structure used to pass parameters to the vector animation task
  83    */
  84   struct AnimationData
  85   {
  86     AnimationData()
  87     : resendFlag(0),
  88       playRange(),
  89       dynamicProperties(),
  90       playState(),
  91       stopBehavior(DevelImageVisual::StopBehavior::CURRENT_FRAME),
  92       loopingMode(DevelImageVisual::LoopingMode::RESTART),
  93       currentFrame(0),
  94       width(0),
  95       height(0),
  96       loopCount(-1),
  97       playStateId(0)
  98     {
  99     }
 100
 101     AnimationData& operator=(const AnimationData& rhs)
 102     {
 103       resendFlag |= rhs.resendFlag; // OR resend flag
 104       playRange    = rhs.playRange;
 105       playState    = rhs.playState;
 106       stopBehavior = rhs.stopBehavior;
 107       loopingMode  = rhs.loopingMode;
 108       currentFrame = rhs.currentFrame;
 109       width        = rhs.width;
 110       height       = rhs.height;
 111       loopCount    = rhs.loopCount;
 112       playStateId  = rhs.playStateId;
 113       dynamicProperties.insert(dynamicProperties.end(), rhs.dynamicProperties.begin(), rhs.dynamicProperties.end());
 114       return *this;
 115     }
 116
 117     uint32_t                             resendFlag;
 118     Property::Array                      playRange;
 119     DynamicPropertyType                  dynamicProperties;
 120     DevelImageVisual::PlayState::Type    playState;
 121     DevelImageVisual::StopBehavior::Type stopBehavior;
 122     DevelImageVisual::LoopingMode::Type  loopingMode;
 123     uint32_t                             currentFrame;
 124     uint32_t                             width;
 125     uint32_t                             height;
 126     int32_t                              loopCount;
 127     uint32_t                             playStateId;
 128   };
 129
 130   /**
 131    * @brief Constructor.
 132    *
 133    * @param[in] factoryCache A pointer pointing to the VisualFactoryCache object
 134    */
 135   VectorAnimationTask(VisualFactoryCache& factoryCache);
 136
 137   /**
 138    * @brief Destructor.
 139    */
 140   ~VectorAnimationTask() override;
 141
 142   /**
 143    * @brief Finalizes the task.
 144    */
 145   void Finalize();
 146
 147   /**
 148    * @brief Sets the renderer used to display the result image.
 149    *
 150    * @param[in] renderer The renderer used to display the result image
 151    */
 152   void SetRenderer(Renderer renderer);
 153
 154   /**
 155    * @brief Requests to load the animation file.
 156    *
 157    * @param[in] url The url of the vector animation file
 158    * @param[in] encodedImageBuffer The resource buffer if required.
 159    * @param[in] synchronousLoading True if the url should be loaded synchronously
 160    */
 161   void RequestLoad(const VisualUrl& url, EncodedImageBuffer encodedImageBuffer, bool synchronousLoading);
 162
 163   /**
 164    * @brief Queries whether loading is requested.
 165    * @return True if loading is requested.
 166    */
 167   bool IsLoadRequested() const;
 168
 169   /**
 170    * @brief Sets data to specify animation playback.
 171    * @param[in] data The animation data
 172    */
 173   void SetAnimationData(const AnimationData& data);
 174
 175   /**
 176    * @brief This callback is called after the animation is finished.
 177    * @param[in] callback The animation finished callback
 178    */
 179   void SetAnimationFinishedCallback(CallbackBase* callback);
 180
 181   /**
 182    * @brief Gets the playing range in frame number.
 183    * @param[out] startFrame The frame number to specify minimum progress.
 184    * @param[out] endFrame The frame number to specify maximum progress.
 185    */
 186   void GetPlayRange(uint32_t& startFrame, uint32_t& endFrame);
 187
 188   /**
 189    * @brief Retrieves the current frame number of the animation.
 190    * @return The current frame number
 191    */
 192   uint32_t GetCurrentFrameNumber() const;
 193
 194   /**
 195    * @brief Retrieves the total frame number of the animation.
 196    * @return The total frame number
 197    */
 198   uint32_t GetTotalFrameNumber() const;
 199
 200   /**
 201    * @brief Gets the default size of the file,.
 202    * @return The default size of the file
 203    */
 204   void GetDefaultSize(uint32_t& width, uint32_t& height) const;
 205
 206   /**
 207    * @brief Gets the layer information of all the child layers.
 208    * @param[out] map The layer information
 209    */
 210   void GetLayerInfo(Property::Map& map) const;
 211
 212   /**
 213    * @brief Gets the all marker information.
 214    * @param[out] map The marker information
 215    */
 216   void GetMarkerInfo(Property::Map& map) const;
 217
 218   /**
 219    * @brief Connect to this signal to be notified when the resource is ready.
 220    * @return The signal to connect to.
 221    */
 222   ResourceReadySignalType& ResourceReadySignal();
 223
 224   /**
 225    * @brief Rasterizes the current frame.
 226    * @return true if the rasterization succeeded, false otherwise.
 227    */
 228   bool Rasterize();
 229
 230   /**
 231    * @brief Calculates the time for the next frame rasterization.
 232    * @return The time for the next frame rasterization.
 233    */
 234   TimePoint CalculateNextFrameTime(bool renderNow);
 235
 236   /**
 237    * @brief Gets the time for the next frame rasterization.
 238    * @return The time for the next frame rasterization.
 239    */
 240   TimePoint GetNextFrameTime();
 241
 242   /**
 243    * @brief Called when the rasterization is completed from the asyncTaskManager
 244    * @param[in] task The completed task
 245    */
 246   void TaskCompleted(VectorAnimationTaskPtr task);
 247
 248   /**
 249    * @brief Check the rasterization succeeded
 250    * @return true if the rasterization succeeded, false otherwise.
 251    */
 252   bool IsRasterized();
 253
 254   /**
 255    * @brief Check the animation is running
 256    * @return true if the animation is running, false otherwise.
 257    */
 258   bool IsAnimating();
 259
 260 public: // Implementation of AsyncTask
 261   /**
 262    * @copydoc Dali::AsyncTask::Process()
 263    */
 264   void Process() override;
 265
 266   /**
 267    * @copydoc Dali::AsyncTask::IsReady()
 268    */
 269   bool IsReady() override;
 270
 271   /**
 272    * @copydoc Dali::AsyncTask::GetTaskName()
 273    */
 274   std::string_view GetTaskName() const override
 275   {
 276     return "VectorAnimationTask";
 277   }
 278
 279   void KeepRasterizedBuffer(bool enableFrameCache)
 280   {
 281     mEnableFrameCache = enableFrameCache;
 282   }
 283
 284   bool IsKeptRasterizedBuffer()
 285   {
 286     return mEnableFrameCache;
 287   }
 288
 289 private:
 290   /**
 291    * @brief Loads the animation file.
 292    *
 293    * @param[in] synchronousLoading True if loading is requested synchronously
 294    * @return True if loading succeeded, false otherwise.
 295    */
 296   bool Load(bool synchronousLoading);
 297
 298   /**
 299    * @brief Play the vector animation.
 300    */
 301   void PlayAnimation();
 302
 303   /**
 304    * @brief Stop the vector animation.
 305    */
 306   void StopAnimation();
 307
 308   /**
 309    * @brief Pause the vector animation.
 310    */
 311   void PauseAnimation();
 312
 313   /**
 314    * @brief Sets the target image size.
 315    *
 316    * @param[in] width The target image width
 317    * @param[in] height The target image height
 318    */
 319   void SetSize(uint32_t width, uint32_t height);
 320
 321   /**
 322    * @brief Enable looping for 'count' repeats. -1 means to repeat forever.
 323    * @param[in] count The number of times to loop
 324    */
 325   void SetLoopCount(int32_t count);
 326
 327   /**
 328    * @brief Set the playing range in frame number.
 329    * @param[in] playRange The array to specify minimum and maximum progress.
 330    * The animation will play between those values.
 331    */
 332   void SetPlayRange(const Property::Array& playRange);
 333
 334   /**
 335    * @brief Sets the current frame number of the animation.
 336    * @param[in] frameNumber The new frame number between [0, the maximum frame number] or between the play range if specified.
 337    */
 338   void SetCurrentFrameNumber(uint32_t frameNumber);
 339
 340   /**
 341    * @brief Sets the stop behavior of the animation. This is performed when the animation is stopped.
 342    * @param[in] stopBehavior The stop behavior
 343    */
 344   void SetStopBehavior(DevelImageVisual::StopBehavior::Type stopBehavior);
 345
 346   /**
 347    * @brief Sets the looping mode.
 348    * Animation plays forwards and then restarts from the beginning or runs backwards again.
 349    * @param[in] loopingMode The looping mode
 350    */
 351   void SetLoopingMode(DevelImageVisual::LoopingMode::Type loopingMode);
 352
 353   /**
 354    * @brief Gets the frame number when the animation is stopped according to the stop behavior.
 355    */
 356   uint32_t GetStoppedFrame(uint32_t startFrame, uint32_t endFrame, uint32_t currentFrame);
 357
 358   /**
 359    * @brief Applies the animation data set by the main thread.
 360    */
 361   void ApplyAnimationData();
 362
 363   /**
 364    * @brief Called when the texture upload is completed.
 365    */
 366   void OnUploadCompleted();
 367
 368   /**
 369    * @brief Event callback from rasterize thread. This is called when the file loading is completed.
 370    */
 371   void OnLoadCompleted(uint32_t argument);
 372
 373   // Undefined
 374   VectorAnimationTask(const VectorAnimationTask& task) = delete;
 375
 376   // Undefined
 377   VectorAnimationTask& operator=(const VectorAnimationTask& task) = delete;
 378
 379 private:
 380   enum class PlayState
 381   {
 382     STOPPING, ///< The animation is stopping
 383     STOPPED,  ///< The animation has stopped
 384     PLAYING,  ///< The animation is playing
 385     PAUSED    ///< The animation is paused
 386   };
 387
 388   VisualUrl                            mImageUrl;
 389   EncodedImageBuffer                   mEncodedImageBuffer;
 390   VectorAnimationRenderer              mVectorRenderer;
 391   std::vector<AnimationData>           mAnimationData[2];
 392   VectorAnimationThread&               mVectorAnimationThread;
 393   Mutex                                mMutex;
 394   ResourceReadySignalType              mResourceReadySignal;
 395   std::unique_ptr<CallbackBase>        mAnimationFinishedCallback{};
 396   std::unique_ptr<CallbackBase>        mLoadCompletedCallback{};
 397   mutable Property::Map                mCachedLayerInfo;
 398   mutable Property::Map                mCachedMarkerInfo;
 399   PlayState                            mPlayState;
 400   DevelImageVisual::StopBehavior::Type mStopBehavior;
 401   DevelImageVisual::LoopingMode::Type  mLoopingMode;
 402   TimePoint                            mNextFrameStartTime;
 403   int64_t                              mFrameDurationMicroSeconds;
 404   float                                mFrameRate;
 405   uint32_t                             mCurrentFrame;
 406   uint32_t                             mTotalFrame;
 407   uint32_t                             mStartFrame;
 408   uint32_t                             mEndFrame;
 409   uint32_t                             mDroppedFrames;
 410   uint32_t                             mWidth;
 411   uint32_t                             mHeight;
 412   uint32_t                             mAnimationDataIndex;
 413   uint32_t                             mAppliedPlayStateId;
 414   int32_t                              mLoopCount;
 415   int32_t                              mCurrentLoop;
 416   bool                                 mForward : 1;
 417   bool                                 mUpdateFrameNumber : 1;
 418   bool                                 mNeedAnimationFinishedTrigger : 1;
 419   bool                                 mAnimationDataUpdated : 1;
 420   bool                                 mDestroyTask : 1;
 421   bool                                 mLoadRequest : 1;
 422   bool                                 mLoadFailed : 1;
 423   bool                                 mRasterized : 1;
 424   bool                                 mKeepAnimation : 1;
 425   mutable bool                         mLayerInfoCached : 1;
 426   mutable bool                         mMarkerInfoCached : 1;
 427   bool                                 mEnableFrameCache : 1;
 428   bool                                 mSizeUpdated : 1;
 429 };
 430
 431 } // namespace Internal
 432
 433 } // namespace Toolkit
 434
 435 } // namespace Dali
 436
 437 #endif // DALI_TOOLKIT_VECTOR_ANIMATION_TASK_H