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) 2023 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/conditional-wait.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     {
  98     }
  99
 100     AnimationData& operator=(const AnimationData& rhs)
 101     {
 102       resendFlag |= rhs.resendFlag; // OR resend flag
 103       playRange    = rhs.playRange;
 104       playState    = rhs.playState;
 105       stopBehavior = rhs.stopBehavior;
 106       loopingMode  = rhs.loopingMode;
 107       currentFrame = rhs.currentFrame;
 108       width        = rhs.width;
 109       height       = rhs.height;
 110       loopCount    = rhs.loopCount;
 111       dynamicProperties.insert(dynamicProperties.end(), rhs.dynamicProperties.begin(), rhs.dynamicProperties.end());
 112       return *this;
 113     }
 114
 115     uint32_t                             resendFlag;
 116     Property::Array                      playRange;
 117     DynamicPropertyType                  dynamicProperties;
 118     DevelImageVisual::PlayState::Type    playState;
 119     DevelImageVisual::StopBehavior::Type stopBehavior;
 120     DevelImageVisual::LoopingMode::Type  loopingMode;
 121     uint32_t                             currentFrame;
 122     uint32_t                             width;
 123     uint32_t                             height;
 124     int32_t                              loopCount;
 125   };
 126
 127   /**
 128    * @brief Constructor.
 129    *
 130    * @param[in] factoryCache A pointer pointing to the VisualFactoryCache object
 131    */
 132   VectorAnimationTask(VisualFactoryCache& factoryCache);
 133
 134   /**
 135    * @brief Destructor.
 136    */
 137   ~VectorAnimationTask() override;
 138
 139   /**
 140    * @brief Finalizes the task.
 141    */
 142   void Finalize();
 143
 144   /**
 145    * @brief Sets the renderer used to display the result image.
 146    *
 147    * @param[in] renderer The renderer used to display the result image
 148    */
 149   void SetRenderer(Renderer renderer);
 150
 151   /**
 152    * @brief Requests to load the animation file.
 153    *
 154    * @param[in] url The url of the vector animation file
 155    * @param[in] encodedImageBuffer The resource buffer if required.
 156    * @param[in] synchronousLoading True if the url should be loaded synchronously
 157    */
 158   void RequestLoad(const VisualUrl& url, EncodedImageBuffer encodedImageBuffer, bool synchronousLoading);
 159
 160   /**
 161    * @brief Queries whether loading is requested.
 162    * @return True if loading is requested.
 163    */
 164   bool IsLoadRequested() const;
 165
 166   /**
 167    * @brief Sets data to specify animation playback.
 168    * @param[in] data The animation data
 169    */
 170   void SetAnimationData(const AnimationData& data);
 171
 172   /**
 173    * @brief This callback is called after the animation is finished.
 174    * @param[in] callback The animation finished callback
 175    */
 176   void SetAnimationFinishedCallback(CallbackBase* callback);
 177
 178   /**
 179    * @brief Gets the playing range in frame number.
 180    * @param[out] startFrame The frame number to specify minimum progress.
 181    * @param[out] endFrame The frame number to specify maximum progress.
 182    */
 183   void GetPlayRange(uint32_t& startFrame, uint32_t& endFrame);
 184
 185   /**
 186    * @brief Retrieves the current frame number of the animation.
 187    * @return The current frame number
 188    */
 189   uint32_t GetCurrentFrameNumber() const;
 190
 191   /**
 192    * @brief Retrieves the total frame number of the animation.
 193    * @return The total frame number
 194    */
 195   uint32_t GetTotalFrameNumber() const;
 196
 197   /**
 198    * @brief Gets the default size of the file,.
 199    * @return The default size of the file
 200    */
 201   void GetDefaultSize(uint32_t& width, uint32_t& height) const;
 202
 203   /**
 204    * @brief Gets the layer information of all the child layers.
 205    * @param[out] map The layer information
 206    */
 207   void GetLayerInfo(Property::Map& map) const;
 208
 209   /**
 210    * @brief Gets the all marker information.
 211    * @param[out] map The marker information
 212    */
 213   void GetMarkerInfo(Property::Map& map) const;
 214
 215   /**
 216    * @brief Connect to this signal to be notified when the resource is ready.
 217    * @return The signal to connect to.
 218    */
 219   ResourceReadySignalType& ResourceReadySignal();
 220
 221   /**
 222    * @brief Rasterizes the current frame.
 223    * @return true if the rasterization succeeded, false otherwise.
 224    */
 225   bool Rasterize();
 226
 227   /**
 228    * @brief Calculates the time for the next frame rasterization.
 229    * @return The time for the next frame rasterization.
 230    */
 231   TimePoint CalculateNextFrameTime(bool renderNow);
 232
 233   /**
 234    * @brief Gets the time for the next frame rasterization.
 235    * @return The time for the next frame rasterization.
 236    */
 237   TimePoint GetNextFrameTime();
 238
 239   /**
 240    * @brief Called when the rasterization is completed from the asyncTaskManager
 241    * @param[in] task The completed task
 242    */
 243   void TaskCompleted(VectorAnimationTaskPtr task);
 244
 245   /**
 246    * @brief Check the rasterization succeeded
 247    * @return true if the rasterization succeeded, false otherwise.
 248    */
 249   bool IsRasterized();
 250
 251   /**
 252    * @brief Check the animation is running
 253    * @return true if the animation is running, false otherwise.
 254    */
 255   bool IsAnimating();
 256
 257 public: // Implementation of AsyncTask
 258   /**
 259    * @copydoc Dali::AsyncTask::Process()
 260    */
 261   void Process() override;
 262
 263   /**
 264    * @copydoc Dali::AsyncTask::IsReady()
 265    */
 266   bool IsReady() override;
 267
 268   /**
 269    * @copydoc Dali::AsyncTask::GetTaskName()
 270    */
 271   std::string_view GetTaskName() const override
 272   {
 273     return "VectorAnimationTask";
 274   }
 275
 276 private:
 277   /**
 278    * @brief Loads the animation file.
 279    *
 280    * @param[in] synchronousLoading True if loading is requested synchronously
 281    * @return True if loading succeeded, false otherwise.
 282    */
 283   bool Load(bool synchronousLoading);
 284
 285   /**
 286    * @brief Play the vector animation.
 287    */
 288   void PlayAnimation();
 289
 290   /**
 291    * @brief Stop the vector animation.
 292    */
 293   void StopAnimation();
 294
 295   /**
 296    * @brief Pause the vector animation.
 297    */
 298   void PauseAnimation();
 299
 300   /**
 301    * @brief Sets the target image size.
 302    *
 303    * @param[in] width The target image width
 304    * @param[in] height The target image height
 305    */
 306   void SetSize(uint32_t width, uint32_t height);
 307
 308   /**
 309    * @brief Enable looping for 'count' repeats. -1 means to repeat forever.
 310    * @param[in] count The number of times to loop
 311    */
 312   void SetLoopCount(int32_t count);
 313
 314   /**
 315    * @brief Set the playing range in frame number.
 316    * @param[in] playRange The array to specify minimum and maximum progress.
 317    * The animation will play between those values.
 318    */
 319   void SetPlayRange(const Property::Array& playRange);
 320
 321   /**
 322    * @brief Sets the current frame number of the animation.
 323    * @param[in] frameNumber The new frame number between [0, the maximum frame number] or between the play range if specified.
 324    */
 325   void SetCurrentFrameNumber(uint32_t frameNumber);
 326
 327   /**
 328    * @brief Sets the stop behavior of the animation. This is performed when the animation is stopped.
 329    * @param[in] stopBehavior The stop behavior
 330    */
 331   void SetStopBehavior(DevelImageVisual::StopBehavior::Type stopBehavior);
 332
 333   /**
 334    * @brief Sets the looping mode.
 335    * Animation plays forwards and then restarts from the beginning or runs backwards again.
 336    * @param[in] loopingMode The looping mode
 337    */
 338   void SetLoopingMode(DevelImageVisual::LoopingMode::Type loopingMode);
 339
 340   /**
 341    * @brief Gets the frame number when the animation is stopped according to the stop behavior.
 342    */
 343   uint32_t GetStoppedFrame(uint32_t startFrame, uint32_t endFrame, uint32_t currentFrame);
 344
 345   /**
 346    * @brief Applies the animation data set by the main thread.
 347    */
 348   void ApplyAnimationData();
 349
 350   /**
 351    * @brief Called when the texture upload is completed.
 352    */
 353   void OnUploadCompleted();
 354
 355   /**
 356    * @brief Event callback from rasterize thread. This is called when the file loading is completed.
 357    */
 358   void OnLoadCompleted();
 359
 360   // Undefined
 361   VectorAnimationTask(const VectorAnimationTask& task) = delete;
 362
 363   // Undefined
 364   VectorAnimationTask& operator=(const VectorAnimationTask& task) = delete;
 365
 366 private:
 367   enum class PlayState
 368   {
 369     STOPPING, ///< The animation is stopping
 370     STOPPED,  ///< The animation has stopped
 371     PLAYING,  ///< The animation is playing
 372     PAUSED    ///< The animation is paused
 373   };
 374
 375   VisualUrl                            mImageUrl;
 376   EncodedImageBuffer                   mEncodedImageBuffer;
 377   VectorAnimationRenderer              mVectorRenderer;
 378   std::vector<AnimationData>           mAnimationData[2];
 379   VectorAnimationThread&               mVectorAnimationThread;
 380   ConditionalWait                      mConditionalWait;
 381   ResourceReadySignalType              mResourceReadySignal;
 382   std::unique_ptr<CallbackBase>        mAnimationFinishedCallback{};
 383   std::unique_ptr<CallbackBase>        mLoadCompletedCallback{};
 384   mutable Property::Map                mCachedLayerInfo;
 385   mutable Property::Map                mCachedMarkerInfo;
 386   PlayState                            mPlayState;
 387   DevelImageVisual::StopBehavior::Type mStopBehavior;
 388   DevelImageVisual::LoopingMode::Type  mLoopingMode;
 389   TimePoint                            mNextFrameStartTime;
 390   int64_t                              mFrameDurationMicroSeconds;
 391   float                                mFrameRate;
 392   uint32_t                             mCurrentFrame;
 393   uint32_t                             mTotalFrame;
 394   uint32_t                             mStartFrame;
 395   uint32_t                             mEndFrame;
 396   uint32_t                             mDroppedFrames;
 397   uint32_t                             mWidth;
 398   uint32_t                             mHeight;
 399   uint32_t                             mAnimationDataIndex;
 400   int32_t                              mLoopCount;
 401   int32_t                              mCurrentLoop;
 402   bool                                 mForward : 1;
 403   bool                                 mUpdateFrameNumber : 1;
 404   bool                                 mNeedAnimationFinishedTrigger : 1;
 405   bool                                 mAnimationDataUpdated : 1;
 406   bool                                 mDestroyTask : 1;
 407   bool                                 mLoadRequest : 1;
 408   bool                                 mLoadFailed : 1;
 409   bool                                 mRasterized : 1;
 410   bool                                 mKeepAnimation : 1;
 411   mutable bool                         mLayerInfoCached : 1;
 412   mutable bool                         mMarkerInfoCached : 1;
 413 };
 414
 415 } // namespace Internal
 416
 417 } // namespace Toolkit
 418
 419 } // namespace Dali
 420
 421 #endif // DALI_TOOLKIT_VECTOR_ANIMATION_TASK_H