Add CURRENT_FRAME_NUMBER and TOTAL_FRAME_NUMBER properties to the AnimatedImageVisual
[platform/core/uifw/dali-toolkit.git] / dali-toolkit / internal / visuals / animated-image / rolling-image-cache.h
1 #ifndef DALI_TOOLKIT_INTERNAL_ROLLING_IMAGE_CACHE_H
2 #define DALI_TOOLKIT_INTERNAL_ROLLING_IMAGE_CACHE_H
3
4 /*
5  * Copyright (c) 2020 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
22 #include <dali/devel-api/common/circular-queue.h>
23 #include <dali-toolkit/internal/visuals/animated-image/image-cache.h>
24 #include <dali-toolkit/internal/visuals/texture-manager-impl.h>
25
26 namespace Dali
27 {
28 namespace Toolkit
29 {
30 namespace Internal
31 {
32
33 /**
34  * Class to manage a rolling cache of images, where the cache size
35  * is smaller than the total number of images.
36  */
37 class RollingImageCache : public ImageCache, public TextureUploadObserver
38 {
39 public:
40   /**
41    * Constructor.
42    * @param[in] textureManager The texture manager
43    * @param[in] urlList List of urls to cache
44    * @param[in] observer FrameReady observer
45    * @param[in] cacheSize The size of the cache
46    * @param[in] batchSize The size of a batch to load
47    *
48    * This will start loading textures immediately, according to the
49    * batch and cache sizes.
50    */
51   RollingImageCache( TextureManager&                 textureManager,
52                      UrlList&                        urlList,
53                      ImageCache::FrameReadyObserver& observer,
54                      uint16_t                        cacheSize,
55                      uint16_t                        batchSize );
56
57   /**
58    * Destructor
59    */
60   ~RollingImageCache() override;
61
62   /**
63    * Get the Nth frame. If it's not ready, this will trigger the
64    * sending of FrameReady() when the image becomes ready.
65    */
66   TextureSet Frame( uint32_t frameIndex ) override;
67
68   /**
69    * Get the first frame. If it's not ready, this will trigger the
70    * sending of FrameReady() when the image becomes ready.
71    */
72   TextureSet FirstFrame() override;
73
74   /**
75    * Get the next frame. If it's not ready, this will trigger the
76    * sending of FrameReady() when the image becomes ready.
77    */
78   TextureSet NextFrame() override;
79
80   /**
81    * Get the interval of Nth frame.
82    */
83   uint32_t GetFrameInterval( uint32_t frameIndex ) const override;
84
85   /**
86    * Get the current rendered frame index.
87    * If there isn't any loaded frame, returns -1.
88    */
89   int32_t GetCurrentFrameIndex() const override;
90
91   /**
92    * Get total frame count of the animated image file.
93    */
94   int32_t GetTotalFrameCount() const override;
95
96 private:
97   /**
98    * @return true if the front frame is ready
99    */
100   bool IsFrontReady() const;
101
102   /**
103    * Load the next batch of images
104    */
105   void LoadBatch();
106
107   /**
108    * Find the matching image frame, and set it to ready
109    */
110   void SetImageFrameReady( TextureManager::TextureId textureId );
111
112   /**
113    * Get the texture set of the front frame.
114    * @return the texture set
115    */
116   TextureSet GetFrontTextureSet() const;
117
118   /**
119    * Get the texture id of the given index
120    */
121   TextureManager::TextureId GetCachedTextureId( int index ) const;
122
123   /**
124    * Check if the front frame has become ready - if so, inform observer
125    * @param[in] wasReady Readiness before call.
126    */
127   void CheckFrontFrame( bool wasReady );
128
129 protected:
130   void UploadComplete(
131     bool           loadSuccess,
132     int32_t        textureId,
133     TextureSet     textureSet,
134     bool           useAtlasing,
135     const Vector4& atlasRect,
136     bool           preMultiplied ) override;
137
138   void LoadComplete(
139     bool loadSuccess,
140     Devel::PixelBuffer pixelBuffer,
141     const VisualUrl& url,
142     bool preMultiplied ) override;
143
144 private:
145   /**
146    * Secondary class to hold readiness and index into url
147    */
148   struct ImageFrame
149   {
150     unsigned int mUrlIndex = 0u;
151     bool mReady = false;
152   };
153
154   std::vector<UrlStore>& mImageUrls;
155   CircularQueue<ImageFrame> mQueue;
156 };
157
158 } // namespace Internal
159 } // namespace Toolkit
160 } // namespace Dali
161
162 #endif