X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali-toolkit%2Finternal%2Fvisuals%2Fanimated-image%2Ffixed-image-cache.cpp;h=7cb6ce334a2f08a7ad2dcdb75a8ca1483c323370;hb=ca51ee97baf5f41ecf741e22d865ff6c9e0bf769;hp=4593bc7b777a02866f6163435a5365dc38a644ce;hpb=2ca1c3856ce848a94f54444f1014a820e91ee207;p=platform%2Fcore%2Fuifw%2Fdali-toolkit.git diff --git a/dali-toolkit/internal/visuals/animated-image/fixed-image-cache.cpp b/dali-toolkit/internal/visuals/animated-image/fixed-image-cache.cpp index 4593bc7..7cb6ce3 100644 --- a/dali-toolkit/internal/visuals/animated-image/fixed-image-cache.cpp +++ b/dali-toolkit/internal/visuals/animated-image/fixed-image-cache.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021 Samsung Electronics Co., Ltd. + * Copyright (c) 2022 Samsung Electronics Co., Ltd. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -20,6 +20,9 @@ // INTERNAL HEADERS #include // For ImageAtlasManagerPtr +// EXTERNAL HEADERS +#include + namespace Dali { namespace Toolkit @@ -28,79 +31,64 @@ namespace Internal { namespace { -const bool ENABLE_ORIENTATION_CORRECTION(true); +constexpr bool ENABLE_ORIENTATION_CORRECTION(true); +constexpr uint32_t FIRST_FRAME_INDEX = 0u; } // namespace -FixedImageCache::FixedImageCache( - TextureManager& textureManager, UrlList& urlList, ImageCache::FrameReadyObserver& observer, unsigned int batchSize) -: ImageCache(textureManager, observer, batchSize), +FixedImageCache::FixedImageCache(TextureManager& textureManager, + UrlList& urlList, + TextureManager::MaskingDataPointer& maskingData, + ImageCache::FrameReadyObserver& observer, + uint32_t batchSize, + uint32_t interval) +: ImageCache(textureManager, maskingData, observer, batchSize, interval), mImageUrls(urlList), - mFront(0u) + mFront(FIRST_FRAME_INDEX) { mReadyFlags.reserve(mImageUrls.size()); - LoadBatch(); } FixedImageCache::~FixedImageCache() { - if(mTextureManagerAlive) - { - for(std::size_t i = 0; i < mImageUrls.size(); ++i) - { - mTextureManager.Remove(mImageUrls[i].mTextureId, this); - } - } + ClearCache(); } TextureSet FixedImageCache::Frame(uint32_t frameIndex) { - while(frameIndex > mFront) + TextureSet textureSet; + if(frameIndex >= mImageUrls.size()) + { + DALI_LOG_ERROR("Wrong frameIndex requested.\n"); + return textureSet; + } + + while(mReadyFlags.size() < mImageUrls.size() && + (frameIndex > mFront || mReadyFlags.empty())) { ++mFront; - if(mFront >= mImageUrls.size()) - { - mFront = 0; - } LoadBatch(); } mFront = frameIndex; - TextureSet textureSet; - if(IsFrontReady() == true) + if(IsFrontReady() && mLoadState != TextureManager::LoadState::LOAD_FAILED) { textureSet = GetFrontTextureSet(); } - else - { - mWaitingForReadyFrame = true; - } return textureSet; } TextureSet FixedImageCache::FirstFrame() { - TextureSet textureSet = GetFrontTextureSet(); - - if(!textureSet) - { - mWaitingForReadyFrame = true; - } - - return textureSet; -} - -TextureSet FixedImageCache::NextFrame() -{ - TextureSet textureSet = Frame((mFront + 1) % mImageUrls.size()); + TextureSet textureSet = Frame(FIRST_FRAME_INDEX); return textureSet; } uint32_t FixedImageCache::GetFrameInterval(uint32_t frameIndex) const { - return 0u; + return mInterval; } int32_t FixedImageCache::GetCurrentFrameIndex() const @@ -121,107 +109,102 @@ bool FixedImageCache::IsFrontReady() const void FixedImageCache::LoadBatch() { // Try and load up to mBatchSize images, until the cache is filled. - // Once the cache is filled, mUrlIndex exceeds mImageUrls size and - // no more images are loaded. - bool frontFrameReady = IsFrontReady(); - - for(unsigned int i = 0; i < mBatchSize && mUrlIndex < mImageUrls.size(); ++i) + // Once the cache is filled, no more images are loaded. + for(unsigned int i = 0; i < mBatchSize && mReadyFlags.size() < mImageUrls.size(); ++i) { - std::string& url = mImageUrls[mUrlIndex].mUrl; + uint32_t frameIndex = mReadyFlags.size(); + VisualUrl& url = mImageUrls[frameIndex].mUrl; mReadyFlags.push_back(false); - // Note, if the image is already loaded, then UploadComplete will get called + // 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 UploadComplete method using mRequestingLoad. + // need to account for this inside the LoadComplete method using mRequestingLoad. mRequestingLoad = true; - - 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[mUrlIndex].mTextureId, textureRect, textureRectSize, atlasingStatus, loadingStatus, Dali::WrapMode::Type::DEFAULT, Dali::WrapMode::Type::DEFAULT, this, atlasObserver, imageAtlasManager, ENABLE_ORIENTATION_CORRECTION, TextureManager::ReloadPolicy::CACHED, preMultiply); - - if(loadingStatus == false) // not loading, means it's already ready. - { - SetImageFrameReady(mImageUrls[mUrlIndex].mTextureId); - } + mLoadState = TextureManager::LoadState::LOADING; + + bool synchronousLoading = false; + bool atlasingStatus = false; + bool loadingStatus = false; + 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, mMaskingData, synchronousLoading, mImageUrls[frameIndex].mTextureId, textureRect, textureRectSize, atlasingStatus, loadingStatus, this, atlasObserver, imageAtlasManager, ENABLE_ORIENTATION_CORRECTION, TextureManager::ReloadPolicy::CACHED, preMultiply); mRequestingLoad = false; - ++mUrlIndex; } - - CheckFrontFrame(frontFrameReady); } -void FixedImageCache::SetImageFrameReady(TextureManager::TextureId textureId) +TextureSet FixedImageCache::GetFrontTextureSet() const { - for(std::size_t i = 0; i < mImageUrls.size(); ++i) + TextureSet textureSet = mTextureManager.GetTextureSet(mImageUrls[mFront].mTextureId); + if(textureSet) { - if(mImageUrls[i].mTextureId == textureId) - { - mReadyFlags[i] = true; - break; - } + Sampler sampler = Sampler::New(); + sampler.SetWrapMode(Dali::WrapMode::Type::DEFAULT, Dali::WrapMode::Type::DEFAULT); + textureSet.SetSampler(0u, sampler); } + return textureSet; } -TextureSet FixedImageCache::GetFrontTextureSet() const +void FixedImageCache::CheckFrontFrame(bool wasReady) { - return mTextureManager.GetTextureSet(mImageUrls[mFront].mTextureId); + if(wasReady == false && IsFrontReady()) + { + mObserver.FrameReady(GetFrontTextureSet(), mInterval); + } } -void FixedImageCache::CheckFrontFrame(bool wasReady) +void FixedImageCache::ClearCache() { - if(mWaitingForReadyFrame && wasReady == false && IsFrontReady()) + if(mTextureManagerAlive) { - mWaitingForReadyFrame = false; - mObserver.FrameReady(GetFrontTextureSet()); + for(std::size_t i = 0; i < mImageUrls.size(); ++i) + { + mTextureManager.Remove(mImageUrls[i].mTextureId, this); + mImageUrls[i].mTextureId = TextureManager::INVALID_TEXTURE_ID; + } + } + mReadyFlags.clear(); + mLoadState = TextureManager::LoadState::NOT_STARTED; + if(mMaskingData) + { + mMaskingData->mAlphaMaskId = TextureManager::INVALID_TEXTURE_ID; } } -void FixedImageCache::UploadComplete( - bool loadSuccess, - int32_t textureId, - TextureSet textureSet, - bool useAtlasing, - const Vector4& atlasRect, - bool preMultiplied) +void FixedImageCache::LoadComplete(bool loadSuccess, TextureInformation textureInformation) { - bool frontFrameReady = IsFrontReady(); - - if(!mRequestingLoad) + if(loadSuccess) { - SetImageFrameReady(textureId); - + mLoadState = TextureManager::LoadState::LOAD_FINISHED; + bool frontFrameReady = IsFrontReady(); + if(!mRequestingLoad) + { + for(std::size_t i = 0; i < mImageUrls.size(); ++i) + { + if(mImageUrls[i].mTextureId == textureInformation.textureId) + { + mReadyFlags[i] = true; + break; + } + } + } + else + { + mReadyFlags.back() = true; + } CheckFrontFrame(frontFrameReady); } else { - // UploadComplete 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) - mReadyFlags.back() = true; + mLoadState = TextureManager::LoadState::LOAD_FAILED; + mObserver.FrameReady(TextureSet(), 0); } } -void FixedImageCache::LoadComplete( - bool loadSuccess, - Devel::PixelBuffer pixelBuffer, - const VisualUrl& url, - bool preMultiplied) -{ - // LoadComplete is called if this TextureUploadObserver requested to load - // an image that will be returned as a type of PixelBuffer by using a method - // TextureManager::LoadPixelBuffer. -} - } //namespace Internal } //namespace Toolkit } //namespace Dali \ No newline at end of file