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) 2022 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-toolkit/internal/texture-manager/texture-manager-impl.h>
  22 #include <dali-toolkit/internal/visuals/animated-image/image-cache.h>
  23 #include <dali/devel-api/common/circular-queue.h>
  24
  25 namespace Dali
  26 {
  27 namespace Toolkit
  28 {
  29 namespace Internal
  30 {
  31 /**
  32  * Class to manage a rolling cache of images, where the cache size
  33  * is smaller than the total number of images.
  34  */
  35 class RollingImageCache : public ImageCache, public TextureUploadObserver
  36 {
  37 public:
  38   /**
  39    * Constructor.
  40    * @param[in] textureManager The texture manager
  41    * @param[in] size           The width and height to fit the loaded image to.
  42    * @param[in] fittingMode    The FittingMode of the resource to load
  43    * @param[in] samplingMode   The SamplingMode of the resource to load
  44    * @param[in] urlList        List of urls to cache
  45    * @param[in] maskingData    Masking data to be applied.
  46    * @param[in] observer       FrameReady observer
  47    * @param[in] cacheSize      The size of the cache
  48    * @param[in] batchSize      The size of a batch to load
  49    * @param[in] interval       Time interval between each frame
  50    *
  51    * This will start loading textures immediately, according to the
  52    * batch and cache sizes.
  53    */
  54   RollingImageCache(TextureManager&                     textureManager,
  55                     ImageDimensions                     size,
  56                     Dali::FittingMode::Type             fittingMode,
  57                     Dali::SamplingMode::Type            samplingMode,
  58                     UrlList&                            urlList,
  59                     TextureManager::MaskingDataPointer& maskingData,
  60                     ImageCache::FrameReadyObserver&     observer,
  61                     uint16_t                            cacheSize,
  62                     uint16_t                            batchSize,
  63                     uint32_t                            interval);
  64
  65   /**
  66    * Destructor
  67    */
  68   ~RollingImageCache() override;
  69
  70   /**
  71    * @copydoc Internal::ImageCache::Frame()
  72    */
  73   TextureSet Frame(uint32_t frameIndex) override;
  74
  75   /**
  76    * @copydoc Internal::ImageCache::FirstFrame()
  77    */
  78   TextureSet FirstFrame() override;
  79
  80   /**
  81    * @copydoc Internal::ImageCache::GetFrameInterval()
  82    */
  83   uint32_t GetFrameInterval(uint32_t frameIndex) const override;
  84
  85   /**
  86    * @copydoc Internal::ImageCache::GetCurrentFrameIndex()
  87    */
  88   int32_t GetCurrentFrameIndex() const override;
  89
  90   /**
  91    * @copydoc Internal::ImageCache::GetTotalFrameCount()
  92    */
  93   int32_t GetTotalFrameCount() const override;
  94
  95   /**
  96    * @copydoc Internal::ImageCache::ClearCache()
  97    */
  98   void ClearCache() override;
  99
 100 private:
 101   /**
 102    * @brief Check whether the front frame is ready or not.
 103    *
 104    * @return true if the front frame is ready
 105    */
 106   bool IsFrontReady() const;
 107
 108   /**
 109    * @brief Load the next batch of images
 110    *
 111    * @param[in] frameIndex starting frame index of batch to be loaded.
 112    */
 113   void LoadBatch(uint32_t frameIndex);
 114
 115   /**
 116    * @brief Get the texture set of the front frame.
 117    *
 118    * @return the texture set of the front of Cache.
 119    */
 120   TextureSet GetFrontTextureSet() const;
 121
 122   /**
 123    * @brief Get the texture id of the given index
 124    *
 125    * @param[in] index index of the queue.
 126    */
 127   TextureManager::TextureId GetCachedTextureId(int index) const;
 128
 129   /**
 130    * @brief Pop front entity of Cache.
 131    */
 132   void PopFrontCache();
 133
 134 protected:
 135   /**
 136    * @copydoc Toolkit::TextureUploadObserver::LoadComplete()
 137    */
 138   void LoadComplete(bool loadSuccess, TextureInformation textureInformation) override;
 139
 140 private:
 141   /**
 142    * Secondary class to hold readiness and index into url
 143    */
 144   struct ImageFrame
 145   {
 146     unsigned int mUrlIndex = 0u;
 147     bool         mReady    = false;
 148   };
 149
 150   std::vector<UrlStore>&    mImageUrls;
 151   CircularQueue<ImageFrame> mQueue;
 152 };
 153
 154 } // namespace Internal
 155 } // namespace Toolkit
 156 } // namespace Dali
 157
 158 #endif