dali-toolkit/internal/visuals/animated-image/rolling-gif-image-cache.cpp

   1 /*
   2  * Copyright (c) 2020 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 // CLASS HEADER
  18 #include "rolling-gif-image-cache.h"
  19
  20 // EXTERNAL HEADERS
  21
  22 // INTERNAL HEADERS
  23 #include <dali-toolkit/devel-api/image-loader/texture-manager.h>
  24 #include <dali-toolkit/internal/visuals/image-atlas-manager.h> // For ImageAtlasManagerPtr
  25 #include <dali/integration-api/debug.h>
  26
  27 namespace
  28 {
  29 #if defined(DEBUG_ENABLED)
  30 Debug::Filter* gAnimImgLogFilter = Debug::Filter::New(Debug::NoLogging, false, "LOG_ANIMATED_IMAGE");
  31
  32 #define LOG_CACHE                                                       \
  33   {                                                                     \
  34     std::ostringstream oss;                                             \
  35     oss<<"Size:"<<mQueue.Count()<<" [ ";                                \
  36     for(std::size_t _i=0; _i<mQueue.Count(); ++_i)                      \
  37     {                                                                   \
  38       oss<<_i<<                                                         \
  39         "={ frm#: " << mQueue[_i].mFrameNumber <<                        \
  40            " tex: " << mImageUrls[mQueue[_i].mFrameNumber].mTextureId<<"}, ";  \
  41     }                                                                   \
  42     oss<<" ]"<<std::endl;                                               \
  43     DALI_LOG_INFO(gAnimImgLogFilter,Debug::Concise,"%s",oss.str().c_str()); \
  44   }
  45
  46 #else
  47   #define LOG_CACHE
  48 #endif
  49
  50 const bool ENABLE_ORIENTATION_CORRECTION( true );
  51
  52 }
  53
  54 namespace Dali
  55 {
  56 namespace Toolkit
  57 {
  58 namespace Internal
  59 {
  60
  61 RollingGifImageCache::RollingGifImageCache(
  62   TextureManager& textureManager, GifLoading& gifLoading, uint32_t frameCount, ImageCache::FrameReadyObserver& observer,
  63   uint16_t cacheSize, uint16_t batchSize )
  64 : ImageCache( textureManager, observer, batchSize ),
  65   mGifLoading( gifLoading ),
  66   mFrameCount( frameCount ),
  67   mFrameIndex( 0 ),
  68   mCacheSize( cacheSize ),
  69   mQueue( cacheSize )
  70 {
  71   mImageUrls.resize( mFrameCount );
  72   LoadBatch();
  73 }
  74
  75 RollingGifImageCache::~RollingGifImageCache()
  76 {
  77   if( mTextureManagerAlive )
  78   {
  79     while( !mQueue.IsEmpty() )
  80     {
  81       ImageFrame imageFrame = mQueue.PopFront();
  82       Dali::Toolkit::TextureManager::RemoveTexture( mImageUrls[ imageFrame.mFrameNumber ].mUrl );
  83     }
  84   }
  85 }
  86
  87 TextureSet RollingGifImageCache::Frame( uint32_t frameIndex )
  88 {
  89   // If a frame of frameIndex is not loaded, clear the queue and remove all loaded textures.
  90   if( mImageUrls[ frameIndex ].mTextureId == TextureManager::INVALID_TEXTURE_ID )
  91   {
  92     mFrameIndex = frameIndex;
  93     while( !mQueue.IsEmpty() )
  94     {
  95       ImageFrame imageFrame = mQueue.PopFront();
  96       Dali::Toolkit::TextureManager::RemoveTexture( mImageUrls[ imageFrame.mFrameNumber ].mUrl );
  97       mImageUrls[ imageFrame.mFrameNumber ].mTextureId = TextureManager::INVALID_TEXTURE_ID;
  98     }
  99     LoadBatch();
 100   }
 101   // If the frame is already loaded, remove previous frames of the frame in the queue
 102   // and load new frames amount of removed frames.
 103   else
 104   {
 105     bool popExist = false;
 106     while( !mQueue.IsEmpty() && mQueue.Front().mFrameNumber != frameIndex )
 107     {
 108       ImageFrame imageFrame = mQueue.PopFront();
 109       Dali::Toolkit::TextureManager::RemoveTexture( mImageUrls[ imageFrame.mFrameNumber ].mUrl );
 110       mImageUrls[ imageFrame.mFrameNumber ].mTextureId = TextureManager::INVALID_TEXTURE_ID;
 111       popExist = true;
 112     }
 113     if( popExist )
 114     {
 115       mFrameIndex = ( mQueue.Back().mFrameNumber + 1 ) % mFrameCount;
 116       LoadBatch();
 117     }
 118   }
 119
 120   return GetFrontTextureSet();
 121 }
 122
 123 TextureSet RollingGifImageCache::FirstFrame()
 124 {
 125   return Frame( 0u );
 126 }
 127
 128 TextureSet RollingGifImageCache::NextFrame()
 129 {
 130   ImageFrame imageFrame = mQueue.PopFront();
 131   Dali::Toolkit::TextureManager::RemoveTexture( mImageUrls[ imageFrame.mFrameNumber ].mUrl );
 132   mImageUrls[ imageFrame.mFrameNumber ].mTextureId = TextureManager::INVALID_TEXTURE_ID;
 133
 134   LoadBatch();
 135
 136   return GetFrontTextureSet();
 137 }
 138
 139 bool RollingGifImageCache::IsFrontReady() const
 140 {
 141   return ( !mQueue.IsEmpty() );
 142 }
 143
 144 void RollingGifImageCache::LoadBatch()
 145 {
 146   // Try and load up to mBatchSize images, until the cache is filled.
 147   // Once the cache is filled, as frames progress, the old frame is
 148   // removed, and another frame is loaded
 149
 150   std::vector<Dali::PixelData> pixelDataList;
 151
 152   // Get the smallest number of frames we need to load
 153   int batchSize = std::min( std::size_t(mBatchSize), mCacheSize - mQueue.Count() );
 154   DALI_LOG_INFO( gAnimImgLogFilter, Debug::Concise, "RollingGifImageCache::LoadBatch() mFrameIndex:%d  batchSize:%d\n", mFrameIndex, batchSize );
 155
 156   if( mGifLoading.LoadNextNFrames( mFrameIndex, batchSize, pixelDataList) )
 157   {
 158     unsigned int pixelDataListCount = pixelDataList.size();
 159
 160     for( unsigned int i = 0; i < pixelDataListCount && !mQueue.IsFull(); ++i )
 161     {
 162       ImageFrame imageFrame;
 163
 164       // create the texture for uploading the pixel data
 165       Texture texture = Texture::New( Dali::TextureType::TEXTURE_2D,
 166                                       pixelDataList[i].GetPixelFormat(),
 167                                       pixelDataList[i].GetWidth(),
 168                                       pixelDataList[i].GetHeight() );
 169
 170       texture.Upload( pixelDataList[i] );
 171
 172       mImageUrls[ mUrlIndex ].mUrl = Dali::Toolkit::TextureManager::AddTexture(texture);
 173       imageFrame.mFrameNumber = mUrlIndex;
 174
 175       ++mUrlIndex;
 176       mUrlIndex %= mImageUrls.size();
 177
 178       mQueue.PushBack( imageFrame );
 179
 180       bool synchronousLoading = false;
 181       bool atlasingStatus = false;
 182       bool loadingStatus = false;
 183       TextureManager::MaskingDataPointer maskInfo = nullptr;
 184       AtlasUploadObserver* atlasObserver = nullptr;
 185       ImageAtlasManagerPtr imageAtlasManager = nullptr;
 186       Vector4 textureRect;
 187       Dali::ImageDimensions textureRectSize;
 188       auto preMultiply = TextureManager::MultiplyOnLoad::LOAD_WITHOUT_MULTIPLY;
 189
 190       mTextureManager.LoadTexture(
 191         mImageUrls[ imageFrame.mFrameNumber ].mUrl, ImageDimensions(), FittingMode::SCALE_TO_FILL,
 192         SamplingMode::BOX_THEN_LINEAR, maskInfo,
 193         synchronousLoading, mImageUrls[ imageFrame.mFrameNumber ].mTextureId, textureRect, textureRectSize,
 194         atlasingStatus, loadingStatus, Dali::WrapMode::Type::DEFAULT,
 195         Dali::WrapMode::Type::DEFAULT, NULL,
 196         atlasObserver, imageAtlasManager, ENABLE_ORIENTATION_CORRECTION, TextureManager::ReloadPolicy::CACHED, preMultiply );
 197     }
 198
 199     mFrameIndex += batchSize;
 200     mFrameIndex %= mFrameCount;
 201   }
 202
 203   LOG_CACHE;
 204 }
 205
 206 TextureSet RollingGifImageCache::GetFrontTextureSet() const
 207 {
 208   DALI_LOG_INFO( gAnimImgLogFilter, Debug::Concise, "RollingGifImageCache::GetFrontTextureSet() FrameNumber:%d\n", mQueue[ 0 ].mFrameNumber );
 209
 210   TextureManager::TextureId textureId = GetCachedTextureId( 0 );
 211   return mTextureManager.GetTextureSet( textureId );
 212 }
 213
 214 TextureManager::TextureId RollingGifImageCache::GetCachedTextureId( int index ) const
 215 {
 216   return mImageUrls[ mQueue[ index ].mFrameNumber ].mTextureId;
 217 }
 218
 219 } //namespace Internal
 220 } //namespace Toolkit
 221 } //namespace Dali