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) 2021 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/object/property-array.h>
  25 #include <chrono>
  26 #include <memory>
  27
  28 // INTERNAL INCLUDES
  29 #include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
  30
  31 namespace Dali
  32 {
  33 namespace Toolkit
  34 {
  35 namespace Internal
  36 {
  37 class VisualFactoryCache;
  38 class VectorAnimationThread;
  39 class VectorAnimationTask;
  40 typedef IntrusivePtr<VectorAnimationTask> VectorAnimationTaskPtr;
  41
  42 /**
  43  * The task of the vector animation.
  44  */
  45 class VectorAnimationTask : public RefObject
  46 {
  47 public:
  48   using UploadCompletedSignalType = Dali::VectorAnimationRenderer::UploadCompletedSignalType;
  49
  50   using TimePoint = std::chrono::time_point<std::chrono::steady_clock>;
  51
  52   /**
  53    * Flags for re-sending data to the vector animation thread
  54    */
  55   enum ResendFlags
  56   {
  57     RESEND_PLAY_RANGE    = 1 << 0,
  58     RESEND_LOOP_COUNT    = 1 << 1,
  59     RESEND_STOP_BEHAVIOR = 1 << 2,
  60     RESEND_LOOPING_MODE  = 1 << 3,
  61     RESEND_CURRENT_FRAME = 1 << 4,
  62     RESEND_SIZE          = 1 << 5,
  63     RESEND_PLAY_STATE    = 1 << 6
  64   };
  65
  66   /**
  67    * @brief Structure used to pass parameters to the vector animation task
  68    */
  69   struct AnimationData
  70   {
  71     AnimationData()
  72     : resendFlag(0),
  73       playRange(),
  74       playState(),
  75       stopBehavior(DevelImageVisual::StopBehavior::CURRENT_FRAME),
  76       loopingMode(DevelImageVisual::LoopingMode::RESTART),
  77       currentFrame(0),
  78       width(0),
  79       height(0),
  80       loopCount(-1)
  81     {
  82     }
  83
  84     AnimationData& operator=(const AnimationData& rhs)
  85     {
  86       resendFlag |= rhs.resendFlag; // OR resend flag
  87       playRange    = rhs.playRange;
  88       playState    = rhs.playState;
  89       stopBehavior = rhs.stopBehavior;
  90       loopingMode  = rhs.loopingMode;
  91       currentFrame = rhs.currentFrame;
  92       width        = rhs.width;
  93       height       = rhs.height;
  94       loopCount    = rhs.loopCount;
  95       return *this;
  96     }
  97
  98     uint32_t                             resendFlag;
  99     Property::Array                      playRange;
 100     DevelImageVisual::PlayState::Type    playState;
 101     DevelImageVisual::StopBehavior::Type stopBehavior;
 102     DevelImageVisual::LoopingMode::Type  loopingMode;
 103     uint32_t                             currentFrame;
 104     uint32_t                             width;
 105     uint32_t                             height;
 106     int32_t                              loopCount;
 107   };
 108
 109   /**
 110    * @brief Constructor.
 111    *
 112    * @param[in] factoryCache A pointer pointing to the VisualFactoryCache object
 113    */
 114   VectorAnimationTask(VisualFactoryCache& factoryCache);
 115
 116   /**
 117    * @brief Destructor.
 118    */
 119   ~VectorAnimationTask() override;
 120
 121   /**
 122    * @brief Finalizes the task.
 123    */
 124   void Finalize();
 125
 126   /**
 127    * @brief Loads the animation file.
 128    *
 129    * @param[in] url The url of the vector animation file
 130    * @return True if loading success, false otherwise.
 131    */
 132   bool Load(const std::string& url);
 133
 134   /**
 135    * @brief Sets the renderer used to display the result image.
 136    *
 137    * @param[in] renderer The renderer used to display the result image
 138    */
 139   void SetRenderer(Renderer renderer);
 140
 141   /**
 142    * @brief Sets data to specify animation playback.
 143    * @param[in] data The animation data
 144    */
 145   void SetAnimationData(const AnimationData& data);
 146
 147   /**
 148    * @brief This callback is called after the animation is finished.
 149    * @param[in] callback The animation finished callback
 150    */
 151   void SetAnimationFinishedCallback(EventThreadCallback* callback);
 152
 153   /**
 154    * @brief Gets the playing range in frame number.
 155    * @param[out] startFrame The frame number to specify minimum progress.
 156    * @param[out] endFrame The frame number to specify maximum progress.
 157    */
 158   void GetPlayRange(uint32_t& startFrame, uint32_t& endFrame);
 159
 160   /**
 161    * @brief Retrieves the current frame number of the animation.
 162    * @return The current frame number
 163    */
 164   uint32_t GetCurrentFrameNumber() const;
 165
 166   /**
 167    * @brief Retrieves the total frame number of the animation.
 168    * @return The total frame number
 169    */
 170   uint32_t GetTotalFrameNumber() const;
 171
 172   /**
 173    * @brief Gets the default size of the file,.
 174    * @return The default size of the file
 175    */
 176   void GetDefaultSize(uint32_t& width, uint32_t& height) const;
 177
 178   /**
 179    * @brief Gets the layer information of all the child layers.
 180    * @param[out] map The layer information
 181    */
 182   void GetLayerInfo(Property::Map& map) const;
 183
 184   /**
 185    * @brief Connect to this signal to be notified when the texture upload is completed.
 186    * @return The signal to connect to.
 187    */
 188   UploadCompletedSignalType& UploadCompletedSignal();
 189
 190   /**
 191    * @brief Rasterizes the current frame.
 192    * @return true if the animation is running, false otherwise.
 193    */
 194   bool Rasterize();
 195
 196   /**
 197    * @brief Calculates the time for the next frame rasterization.
 198    * @return The time for the next frame rasterization.
 199    */
 200   TimePoint CalculateNextFrameTime(bool renderNow);
 201
 202   /**
 203    * @brief Gets the time for the next frame rasterization.
 204    * @return The time for the next frame rasterization.
 205    */
 206   TimePoint GetNextFrameTime();
 207
 208 private:
 209   /**
 210    * @brief Play the vector animation.
 211    */
 212   void PlayAnimation();
 213
 214   /**
 215    * @brief Stop the vector animation.
 216    */
 217   void StopAnimation();
 218
 219   /**
 220    * @brief Pause the vector animation.
 221    */
 222   void PauseAnimation();
 223
 224   /**
 225    * @brief Sets the target image size.
 226    *
 227    * @param[in] width The target image width
 228    * @param[in] height The target image height
 229    */
 230   void SetSize(uint32_t width, uint32_t height);
 231
 232   /**
 233    * @brief Enable looping for 'count' repeats. -1 means to repeat forever.
 234    * @param[in] count The number of times to loop
 235    */
 236   void SetLoopCount(int32_t count);
 237
 238   /**
 239    * @brief Set the playing range in frame number.
 240    * @param[in] playRange The array to specify minimum and maximum progress.
 241    * The animation will play between those values.
 242    */
 243   void SetPlayRange(const Property::Array& playRange);
 244
 245   /**
 246    * @brief Sets the current frame number of the animation.
 247    * @param[in] frameNumber The new frame number between [0, the maximum frame number] or between the play range if specified.
 248    */
 249   void SetCurrentFrameNumber(uint32_t frameNumber);
 250
 251   /**
 252    * @brief Sets the stop behavior of the animation. This is performed when the animation is stopped.
 253    * @param[in] stopBehavior The stop behavior
 254    */
 255   void SetStopBehavior(DevelImageVisual::StopBehavior::Type stopBehavior);
 256
 257   /**
 258    * @brief Sets the looping mode.
 259    * Animation plays forwards and then restarts from the beginning or runs backwards again.
 260    * @param[in] loopingMode The looping mode
 261    */
 262   void SetLoopingMode(DevelImageVisual::LoopingMode::Type loopingMode);
 263
 264   /**
 265    * @brief Gets the frame number when the animation is stopped according to the stop behavior.
 266    */
 267   uint32_t GetStoppedFrame(uint32_t startFrame, uint32_t endFrame, uint32_t currentFrame);
 268
 269   /**
 270    * @brief Applies the animation data set by the main thread.
 271    */
 272   void ApplyAnimationData();
 273
 274   // Undefined
 275   VectorAnimationTask(const VectorAnimationTask& task) = delete;
 276
 277   // Undefined
 278   VectorAnimationTask& operator=(const VectorAnimationTask& task) = delete;
 279
 280 private:
 281   enum class PlayState
 282   {
 283     STOPPING, ///< The animation is stopping
 284     STOPPED,  ///< The animation has stopped
 285     PLAYING,  ///< The animation is playing
 286     PAUSED    ///< The animation is paused
 287   };
 288
 289   std::string                          mUrl;
 290   VectorAnimationRenderer              mVectorRenderer;
 291   AnimationData                        mAnimationData[2];
 292   VectorAnimationThread&               mVectorAnimationThread;
 293   ConditionalWait                      mConditionalWait;
 294   std::unique_ptr<EventThreadCallback> mAnimationFinishedTrigger;
 295   PlayState                            mPlayState;
 296   DevelImageVisual::StopBehavior::Type mStopBehavior;
 297   DevelImageVisual::LoopingMode::Type  mLoopingMode;
 298   TimePoint                            mNextFrameStartTime;
 299   int64_t                              mFrameDurationMicroSeconds;
 300   float                                mFrameRate;
 301   uint32_t                             mCurrentFrame;
 302   uint32_t                             mTotalFrame;
 303   uint32_t                             mStartFrame;
 304   uint32_t                             mEndFrame;
 305   uint32_t                             mDroppedFrames;
 306   uint32_t                             mWidth;
 307   uint32_t                             mHeight;
 308   uint32_t                             mAnimationDataIndex;
 309   int32_t                              mLoopCount;
 310   int32_t                              mCurrentLoop;
 311   bool                                 mForward;
 312   bool                                 mUpdateFrameNumber;
 313   bool                                 mNeedAnimationFinishedTrigger;
 314   bool                                 mAnimationDataUpdated;
 315   bool                                 mDestroyTask;
 316 };
 317
 318 } // namespace Internal
 319
 320 } // namespace Toolkit
 321
 322 } // namespace Dali
 323
 324 #endif // DALI_TOOLKIT_VECTOR_ANIMATION_TASK_H