#define LOG_CACHE
#endif
-const bool ENABLE_ORIENTATION_CORRECTION(true);
+static constexpr bool ENABLE_ORIENTATION_CORRECTION(true);
+
+static constexpr uint32_t FIRST_FRAME_INDEX = 0u;
} // namespace
{
namespace Internal
{
-RollingImageCache::RollingImageCache(
- TextureManager& textureManager, UrlList& urlList, ImageCache::FrameReadyObserver& observer, uint16_t cacheSize, uint16_t batchSize)
-: ImageCache(textureManager, observer, batchSize),
+RollingImageCache::RollingImageCache(TextureManager& textureManager,
+ UrlList& urlList,
+ TextureManager::MaskingDataPointer& maskingData,
+ ImageCache::FrameReadyObserver& observer,
+ uint16_t cacheSize,
+ uint16_t batchSize,
+ uint32_t interval)
+: ImageCache(textureManager, maskingData, observer, batchSize, interval),
mImageUrls(urlList),
mQueue(cacheSize)
{
- LoadBatch();
}
RollingImageCache::~RollingImageCache()
{
- if(mTextureManagerAlive)
- {
- while(!mQueue.IsEmpty())
- {
- ImageFrame imageFrame = mQueue.PopFront();
- mTextureManager.Remove(mImageUrls[imageFrame.mUrlIndex].mTextureId, this);
- }
- }
+ ClearCache();
}
TextureSet RollingImageCache::Frame(uint32_t frameIndex)
{
- // If a frame of frameIndex is not loaded, clear the queue and remove all loaded textures.
- if(mImageUrls[frameIndex].mTextureId == TextureManager::INVALID_TEXTURE_ID)
+ // Pop frames until the frame of frameIndex become front frame.
+ bool popExist = false;
+ while(!mQueue.IsEmpty() && mQueue.Front().mUrlIndex != frameIndex)
{
- mUrlIndex = frameIndex;
- while(!mQueue.IsEmpty())
- {
- ImageFrame imageFrame = mQueue.PopFront();
- mTextureManager.Remove(mImageUrls[imageFrame.mUrlIndex].mTextureId, this);
- mImageUrls[imageFrame.mUrlIndex].mTextureId = TextureManager::INVALID_TEXTURE_ID;
- }
- LoadBatch();
+ PopFrontCache();
+ popExist = true;
}
- // If the frame is already loaded, remove previous frames of the frame in the queue
- // and load new frames amount of removed frames.
- else
+
+ // TODO: synchronous loading of first frame.
+ if(popExist || mQueue.IsEmpty())
{
- bool popExist = false;
- while(!mQueue.IsEmpty() && mQueue.Front().mUrlIndex != frameIndex)
- {
- ImageFrame imageFrame = mQueue.PopFront();
- mTextureManager.Remove(mImageUrls[imageFrame.mUrlIndex].mTextureId, this);
- mImageUrls[imageFrame.mUrlIndex].mTextureId = TextureManager::INVALID_TEXTURE_ID;
- popExist = true;
- }
- if(popExist)
+ uint32_t batchFrameIndex = frameIndex;
+ // If the frame of frameIndex was already loaded, load batch from the last frame of queue
+ if(!mQueue.IsEmpty())
{
- mUrlIndex = (mQueue.Back().mUrlIndex + 1) % mImageUrls.size();
- LoadBatch();
+ batchFrameIndex = (mQueue.Back().mUrlIndex + 1) % mImageUrls.size();
}
+ LoadBatch(batchFrameIndex);
}
TextureSet textureSet;
- if(IsFrontReady() == true)
+ if(IsFrontReady() == true && mLoadState != TextureManager::LoadState::LOAD_FAILED)
{
textureSet = GetFrontTextureSet();
}
- else
- {
- mWaitingForReadyFrame = true;
- }
return textureSet;
}
TextureSet RollingImageCache::FirstFrame()
{
- return Frame(0u);
-}
-
-TextureSet RollingImageCache::NextFrame()
-{
- TextureSet textureSet;
- if(!mQueue.IsEmpty())
- {
- uint32_t frameIndex = mQueue.Front().mUrlIndex;
- if(IsFrontReady())
- {
- frameIndex = (frameIndex + 1) % mImageUrls.size();
- }
- textureSet = Frame(frameIndex);
- }
- else
- {
- DALI_LOG_ERROR("Cache is empty.");
- }
-
+ TextureSet textureSet = Frame(FIRST_FRAME_INDEX);
return textureSet;
}
uint32_t RollingImageCache::GetFrameInterval(uint32_t frameIndex) const
{
- return 0u;
+ return mInterval;
}
int32_t RollingImageCache::GetCurrentFrameIndex() const
return (!mQueue.IsEmpty() && mQueue.Front().mReady);
}
-void RollingImageCache::LoadBatch()
+void RollingImageCache::LoadBatch(uint32_t frameIndex)
{
// Try and load up to mBatchSize images, until the cache is filled.
// Once the cache is filled, as frames progress, the old frame is
// cleared, but not erased, and another image is loaded
- bool frontFrameReady = IsFrontReady();
-
for(unsigned int i = 0; i < mBatchSize && !mQueue.IsFull(); ++i)
{
ImageFrame imageFrame;
- std::string& url = mImageUrls[mUrlIndex].mUrl;
- imageFrame.mUrlIndex = mUrlIndex;
+ std::string& url = mImageUrls[frameIndex].mUrl;
+ imageFrame.mUrlIndex = frameIndex;
imageFrame.mReady = false;
- ++mUrlIndex;
- mUrlIndex %= mImageUrls.size();
-
mQueue.PushBack(imageFrame);
// Note, if the image is already loaded, then LoadComplete will get called
// from within this method. This means it won't yet have a texture id, so we
// need to account for this inside the LoadComplete method using mRequestingLoad.
mRequestingLoad = true;
+ mLoadState = TextureManager::LoadState::LOADING;
bool synchronousLoading = false;
bool atlasingStatus = false;
bool loadingStatus = false;
- TextureManager::MaskingDataPointer maskInfo = nullptr;
AtlasUploadObserver* atlasObserver = nullptr;
ImageAtlasManagerPtr imageAtlasManager = nullptr;
Vector4 textureRect;
Dali::ImageDimensions textureRectSize;
auto preMultiply = TextureManager::MultiplyOnLoad::LOAD_WITHOUT_MULTIPLY;
- mTextureManager.LoadTexture(
- url, ImageDimensions(), FittingMode::SCALE_TO_FILL, SamplingMode::BOX_THEN_LINEAR, maskInfo, synchronousLoading, mImageUrls[imageFrame.mUrlIndex].mTextureId, textureRect, textureRectSize, atlasingStatus, loadingStatus, Dali::WrapMode::Type::DEFAULT, Dali::WrapMode::Type::DEFAULT, this, atlasObserver, imageAtlasManager, ENABLE_ORIENTATION_CORRECTION, TextureManager::ReloadPolicy::CACHED, preMultiply);
+ TextureManager::TextureId loadTextureId = TextureManager::INVALID_TEXTURE_ID;
+ TextureSet textureSet = mTextureManager.LoadTexture(
+ url, ImageDimensions(), FittingMode::SCALE_TO_FILL, SamplingMode::BOX_THEN_LINEAR, mMaskingData, synchronousLoading, loadTextureId, textureRect, textureRectSize, atlasingStatus, loadingStatus, Dali::WrapMode::Type::DEFAULT, Dali::WrapMode::Type::DEFAULT, this, atlasObserver, imageAtlasManager, ENABLE_ORIENTATION_CORRECTION, TextureManager::ReloadPolicy::CACHED, preMultiply);
+ mImageUrls[imageFrame.mUrlIndex].mTextureId = loadTextureId;
mRequestingLoad = false;
- }
- CheckFrontFrame(frontFrameReady);
-}
-
-void RollingImageCache::SetImageFrameReady(TextureManager::TextureId textureId)
-{
- for(std::size_t i = 0; i < mQueue.Count(); ++i)
- {
- if(GetCachedTextureId(i) == textureId)
- {
- mQueue[i].mReady = true;
- break;
- }
+ ++frameIndex;
+ frameIndex %= mImageUrls.size();
}
}
return mImageUrls[mQueue[index].mUrlIndex].mTextureId;
}
-void RollingImageCache::CheckFrontFrame(bool wasReady)
+void RollingImageCache::PopFrontCache()
{
- if(mWaitingForReadyFrame && wasReady == false && IsFrontReady())
+ ImageFrame imageFrame = mQueue.PopFront();
+ mTextureManager.Remove(mImageUrls[imageFrame.mUrlIndex].mTextureId, this);
+ mImageUrls[imageFrame.mUrlIndex].mTextureId = TextureManager::INVALID_TEXTURE_ID;
+
+ if(mMaskingData && mMaskingData->mAlphaMaskId != TextureManager::INVALID_TEXTURE_ID)
{
- mWaitingForReadyFrame = false;
- mObserver.FrameReady(GetFrontTextureSet());
+ mTextureManager.Remove(mMaskingData->mAlphaMaskId, this);
+ if(mQueue.IsEmpty())
+ {
+ mMaskingData->mAlphaMaskId = TextureManager::INVALID_TEXTURE_ID;
+ }
}
}
+void RollingImageCache::ClearCache()
+{
+ while(mTextureManagerAlive && !mQueue.IsEmpty())
+ {
+ PopFrontCache();
+ }
+ mLoadState = TextureManager::LoadState::NOT_STARTED;
+}
+
void RollingImageCache::LoadComplete(bool loadSuccess, TextureInformation textureInformation)
{
DALI_LOG_INFO(gAnimImgLogFilter, Debug::Concise, "AnimatedImageVisual::LoadComplete(textureId:%d) start\n", textureInformation.textureId);
LOG_CACHE;
- bool frontFrameReady = IsFrontReady();
-
- if(!mRequestingLoad)
+ if(loadSuccess)
{
- SetImageFrameReady(textureInformation.textureId);
+ mLoadState = TextureManager::LoadState::LOAD_FINISHED;
+ bool frontFrameReady = IsFrontReady();
+ if(!mRequestingLoad)
+ {
+ for(std::size_t i = 0; i < mQueue.Count(); ++i)
+ {
+ if(GetCachedTextureId(i) == textureInformation.textureId)
+ {
+ mQueue[i].mReady = true;
+ break;
+ }
+ }
+ }
+ else
+ {
+ // LoadComplete has been called from within RequestLoad. TextureManager must
+ // therefore already have the texture cached, so make the texture ready.
+ // (Use the last texture, as the texture id hasn't been assigned yet)
+ mQueue.Back().mReady = true;
+ }
- CheckFrontFrame(frontFrameReady);
+ if(!frontFrameReady && IsFrontReady())
+ {
+ mObserver.FrameReady(mTextureManager.GetTextureSet(textureInformation.textureId), mInterval);
+ }
}
else
{
- // LoadComplete has been called from within RequestLoad. TextureManager must
- // therefore already have the texture cached, so make the texture ready.
- // (Use the last texture, as the texture id hasn't been assigned yet)
- mQueue.Back().mReady = true;
+ mLoadState = TextureManager::LoadState::LOAD_FAILED;
+ mObserver.FrameReady(TextureSet(), 0);
}
LOG_CACHE;
projects / platform / core / uifw / dali-toolkit.git / blobdiff