From 6ecc4c026c8e398c1a13cba2584c62092f4cf014 Mon Sep 17 00:00:00 2001 From: Seungho Baek Date: Mon, 7 Dec 2020 17:10:34 +0900 Subject: [PATCH] Fix 2 animatedImageVisual issues - 1. Make animate image visual do not caching in texture-manager - If 2 visual those have same image url and play without sync, it makes caching error. - 2. Make NextFrame methods. - Currently, the visual requests to load specific frame with index. But, if the system getting slow(like so many agif/webp in playing), the request and the loading can not be synchronized. - The visual will request next frame index with identical timing, but because the loading is slow, the loading frame will be throwed away and start next frame of the index. - This make bottle neck and also make stop to play. - This patch adds NextFrame that returns prepared next frame. If the next frame is in loading, this method is not to increase index and returns current rendered frame again. Change-Id: Ia301ae654bcf8ee88167585bc4f4b1259a1e4e46 Signed-off-by: Seungho Baek --- .../dali-toolkit/utc-Dali-AnimatedImageVisual.cpp | 71 +++++++++++++++++ .../animated-image/animated-image-visual.cpp | 90 +++++++++++----------- .../visuals/animated-image/animated-image-visual.h | 2 +- .../visuals/animated-image/fixed-image-cache.cpp | 14 +++- .../visuals/animated-image/fixed-image-cache.h | 14 +++- .../internal/visuals/animated-image/image-cache.h | 14 +++- .../rolling-animated-image-cache.cpp | 56 +++++++++++--- .../animated-image/rolling-animated-image-cache.h | 15 +++- .../visuals/animated-image/rolling-image-cache.cpp | 31 +++++++- .../visuals/animated-image/rolling-image-cache.h | 14 +++- .../internal/visuals/texture-manager-impl.cpp | 32 ++------ .../internal/visuals/texture-manager-impl.h | 10 +-- 12 files changed, 270 insertions(+), 93 deletions(-) diff --git a/automated-tests/src/dali-toolkit/utc-Dali-AnimatedImageVisual.cpp b/automated-tests/src/dali-toolkit/utc-Dali-AnimatedImageVisual.cpp index a6d827e..90ee00e 100644 --- a/automated-tests/src/dali-toolkit/utc-Dali-AnimatedImageVisual.cpp +++ b/automated-tests/src/dali-toolkit/utc-Dali-AnimatedImageVisual.cpp @@ -392,6 +392,77 @@ int UtcDaliAnimatedImageVisualStopBehavior(void) } +int UtcDaliAnimatedImageVisualStopBehavior02(void) +{ + ToolkitTestApplication application; + TestGlAbstraction& gl = application.GetGlAbstraction(); + + Property::Array urls; + CopyUrlsIntoArray( urls ); + + { + Property::Map propertyMap; + propertyMap.Insert( Visual::Property::TYPE, Visual::IMAGE ); + propertyMap.Insert( ImageVisual::Property::URL, Property::Value(urls) ); + propertyMap.Insert( DevelImageVisual::Property::STOP_BEHAVIOR, DevelImageVisual::StopBehavior::LAST_FRAME); + propertyMap.Insert( ImageVisual::Property::BATCH_SIZE, 2); + propertyMap.Insert( ImageVisual::Property::CACHE_SIZE, 2); + propertyMap.Insert( ImageVisual::Property::FRAME_DELAY, 20); + + VisualFactory factory = VisualFactory::Get(); + Visual::Base visual = factory.CreateVisual( propertyMap ); + + // Expect that a batch of 4 textures has been requested. These will be serially loaded + // below. + + DummyControl dummyControl = DummyControl::New(true); + Impl::DummyControl& dummyImpl = static_cast(dummyControl.GetImplementation()); + dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual ); + + dummyControl.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS ); + application.GetScene().Add( dummyControl ); + + tet_infoline( "Ready the visual after the visual is on stage" ); + DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 2 ), true, TEST_LOCATION ); + + TraceCallStack& textureTrace = gl.GetTextureTrace(); + textureTrace.Enable(true); + + application.SendNotification(); + application.Render(20); + + DALI_TEST_EQUALS( gl.GetLastGenTextureId(), 2, TEST_LOCATION ); + + Test::EmitGlobalTimerSignal(); + + DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 1 ), true, TEST_LOCATION ); + + application.SendNotification(); + application.Render(20); + + DALI_TEST_EQUALS( gl.GetNumGeneratedTextures(), 2, TEST_LOCATION ); + + DevelControl::DoAction( dummyControl, DummyControl::Property::TEST_VISUAL, Dali::Toolkit::DevelAnimatedImageVisual::Action::STOP, Property::Map() ); + + tet_infoline( "Ready the visual after the visual is on stage" ); + DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 2 ), true, TEST_LOCATION ); + + application.SendNotification(); + application.Render(20); + + DALI_TEST_EQUALS( gl.GetNumGeneratedTextures(), 2, TEST_LOCATION ); + + dummyControl.Unparent(); + } + tet_infoline("Test that removing the visual from stage deletes all textures"); + application.SendNotification(); + application.Render(16); + DALI_TEST_EQUALS( gl.GetNumGeneratedTextures(), 0, TEST_LOCATION ); + + END_TEST; +} + + int UtcDaliAnimatedImageVisualAnimatedImage01(void) { ToolkitTestApplication application; diff --git a/dali-toolkit/internal/visuals/animated-image/animated-image-visual.cpp b/dali-toolkit/internal/visuals/animated-image/animated-image-visual.cpp index 456b89e..745c45c 100755 --- a/dali-toolkit/internal/visuals/animated-image/animated-image-visual.cpp +++ b/dali-toolkit/internal/visuals/animated-image/animated-image-visual.cpp @@ -174,7 +174,7 @@ AnimatedImageVisual::AnimatedImageVisual( VisualFactoryCache& factoryCache, Imag mPixelArea( FULL_TEXTURE_RECT ), mImageUrl(), mAnimatedImageLoading(), - mCurrentFrameIndex( 0 ), + mFrameIndexForJumpTo( 0 ), mImageUrls( NULL ), mImageCache( NULL ), mCacheSize( 2 ), @@ -302,7 +302,7 @@ void AnimatedImageVisual::OnDoAction( const Dali::Property::Index actionId, cons else { mIsJumpTo = true; - mCurrentFrameIndex = frameNumber; + mFrameIndexForJumpTo = frameNumber; if( IsOnScene() ) { DisplayNextFrame(); @@ -544,8 +544,6 @@ void AnimatedImageVisual::CreateRenderer() { mImpl->mRenderer.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, mPixelArea ); } - - mCurrentFrameIndex = 0; } void AnimatedImageVisual::LoadFirstBatch() @@ -618,14 +616,12 @@ void AnimatedImageVisual::StartFirstFrame( TextureSet& textureSet ) mPlacementActor.Reset(); } - mCurrentFrameIndex = 0; - if( mFrameCount > 1 ) { - int frameDelay = mFrameDelay; // from URL array - if( mAnimatedImageLoading && mImageCache ) + int frameDelay = mImageCache->GetFrameInterval( 0 ); + if( frameDelay == 0u ) { - frameDelay = mImageCache->GetFrameInterval( 0 ); + frameDelay = mFrameDelay; // from URL array } mFrameDelayTimer = Timer::New( frameDelay ); mFrameDelayTimer.TickSignal().Connect( this, &AnimatedImageVisual::DisplayNextFrame ); @@ -642,15 +638,11 @@ TextureSet AnimatedImageVisual::PrepareTextureSet() { textureSet = mImageCache->FirstFrame(); } + if( textureSet ) { SetImageSize( textureSet ); } - else - { - DALI_LOG_INFO( gAnimImgLogFilter, Debug::Concise, "ResourceReady(ResourceStatus::FAILED)\n" ); - ResourceReady( Toolkit::Visual::ResourceStatus::FAILED ); - } return textureSet; } @@ -670,26 +662,38 @@ void AnimatedImageVisual::SetImageSize( TextureSet& textureSet ) void AnimatedImageVisual::FrameReady( TextureSet textureSet ) { - SetImageSize( textureSet ); - - if( mStartFirstFrame ) + if(textureSet) { - StartFirstFrame( textureSet ); + SetImageSize(textureSet); + + if(mStartFirstFrame) + { + StartFirstFrame(textureSet); + } + else + { + if(mImpl->mRenderer) + { + mImpl->mRenderer.SetTextures(textureSet); + } + } } else { - if( mImpl->mRenderer ) - { - mImpl->mRenderer.SetTextures( textureSet ); - } + DALI_LOG_INFO( gAnimImgLogFilter, Debug::Concise, "ResourceReady(ResourceStatus::FAILED)\n" ); + ResourceReady( Toolkit::Visual::ResourceStatus::FAILED ); } } bool AnimatedImageVisual::DisplayNextFrame() { + bool nextFrame = false; + uint32_t frameIndex = mImageCache->GetCurrentFrameIndex(); + if( mIsJumpTo ) { mIsJumpTo = false; + frameIndex = mFrameIndexForJumpTo; } else if( mActionStatus == DevelAnimatedImageVisual::Action::PAUSE ) { @@ -697,14 +701,14 @@ bool AnimatedImageVisual::DisplayNextFrame() } else if( mActionStatus == DevelAnimatedImageVisual::Action::STOP ) { - mCurrentLoopIndex = 0; + frameIndex = 0; if( mStopBehavior == DevelImageVisual::StopBehavior::FIRST_FRAME ) { - mCurrentFrameIndex = 0; + frameIndex = 0; } else if( mStopBehavior == DevelImageVisual::StopBehavior::LAST_FRAME ) { - mCurrentFrameIndex = mFrameCount - 1; + frameIndex = mFrameCount - 1; } else { @@ -715,33 +719,25 @@ bool AnimatedImageVisual::DisplayNextFrame() { if( mFrameCount > 1 ) { - // Wrap the frame index - bool finished = false; - ++mCurrentFrameIndex; - if( mCurrentFrameIndex >= mFrameCount ) + nextFrame = true; + frameIndex++; + if( frameIndex >= mFrameCount ) { + frameIndex %= mFrameCount; ++mCurrentLoopIndex; - finished = true; } - if( mLoopCount < 0 || mCurrentLoopIndex < mLoopCount) - { - if( finished ) - { - mCurrentFrameIndex = 0; // Back to the first frame - } - } - else + if(mLoopCount >= 0 && mCurrentLoopIndex >= mLoopCount) { // This will stop timer mActionStatus = DevelAnimatedImageVisual::Action::STOP; return DisplayNextFrame(); } } - // TODO : newly added one. - if( mAnimatedImageLoading && mImageCache ) + + unsigned int delay = mImageCache->GetFrameInterval( frameIndex ); + if( delay > 0u ) { - unsigned int delay = mImageCache->GetFrameInterval( mCurrentFrameIndex ); if( mFrameDelayTimer.GetInterval() != delay ) { mFrameDelayTimer.SetInterval( delay ); @@ -749,12 +745,20 @@ bool AnimatedImageVisual::DisplayNextFrame() } } - DALI_LOG_INFO( gAnimImgLogFilter,Debug::Concise,"AnimatedImageVisual::DisplayNextFrame(this:%p) CurrentFrameIndex:%d\n", this, mCurrentFrameIndex); + DALI_LOG_INFO( gAnimImgLogFilter,Debug::Concise,"AnimatedImageVisual::DisplayNextFrame(this:%p) CurrentFrameIndex:%d\n", this, frameIndex); TextureSet textureSet; if( mImageCache ) { - textureSet = mImageCache->Frame( mCurrentFrameIndex ); + if(nextFrame) + { + textureSet = mImageCache->NextFrame(); + } + else + { + textureSet = mImageCache->Frame( frameIndex ); + } + if( textureSet ) { SetImageSize( textureSet ); diff --git a/dali-toolkit/internal/visuals/animated-image/animated-image-visual.h b/dali-toolkit/internal/visuals/animated-image/animated-image-visual.h index 8e91623..862dbb8 100644 --- a/dali-toolkit/internal/visuals/animated-image/animated-image-visual.h +++ b/dali-toolkit/internal/visuals/animated-image/animated-image-visual.h @@ -246,7 +246,7 @@ private: Vector4 mPixelArea; VisualUrl mImageUrl; Dali::AnimatedImageLoading mAnimatedImageLoading; // Only needed for animated image - uint32_t mCurrentFrameIndex; // Frame index into textureRects + uint32_t mFrameIndexForJumpTo; // Frame index into textureRects // Variables for Multi-Image player ImageCache::UrlList* mImageUrls; 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 726cd39..a90b31e 100644 --- a/dali-toolkit/internal/visuals/animated-image/fixed-image-cache.cpp +++ b/dali-toolkit/internal/visuals/animated-image/fixed-image-cache.cpp @@ -93,11 +93,23 @@ TextureSet FixedImageCache::FirstFrame() return textureSet; } -uint32_t FixedImageCache::GetFrameInterval( uint32_t frameIndex ) +TextureSet FixedImageCache::NextFrame() +{ + TextureSet textureSet = Frame((mFront + 1) % mImageUrls.size()); + + return textureSet; +} + +uint32_t FixedImageCache::GetFrameInterval( uint32_t frameIndex ) const { return 0u; } +int32_t FixedImageCache::GetCurrentFrameIndex() const +{ + return static_cast(mFront); +} + bool FixedImageCache::IsFrontReady() const { return ( mReadyFlags.size() > 0 && mReadyFlags[mFront] == true ); diff --git a/dali-toolkit/internal/visuals/animated-image/fixed-image-cache.h b/dali-toolkit/internal/visuals/animated-image/fixed-image-cache.h index ec7f419..bd232b4 100644 --- a/dali-toolkit/internal/visuals/animated-image/fixed-image-cache.h +++ b/dali-toolkit/internal/visuals/animated-image/fixed-image-cache.h @@ -61,9 +61,21 @@ public: TextureSet FirstFrame() override; /** + * Get the next frame. If it's not ready, this will trigger the + * sending of FrameReady() when the image becomes ready. + */ + TextureSet NextFrame() override; + + /** * Get the interval of Nth frame. */ - uint32_t GetFrameInterval( uint32_t frameIndex ) override; + uint32_t GetFrameInterval( uint32_t frameIndex ) const override; + + /** + * Get the current rendered frame index. + * If there isn't any loaded frame, returns -1. + */ + int32_t GetCurrentFrameIndex() const override; private: /** diff --git a/dali-toolkit/internal/visuals/animated-image/image-cache.h b/dali-toolkit/internal/visuals/animated-image/image-cache.h index 1d385c8..b16b94e 100644 --- a/dali-toolkit/internal/visuals/animated-image/image-cache.h +++ b/dali-toolkit/internal/visuals/animated-image/image-cache.h @@ -79,6 +79,12 @@ public: virtual TextureSet FirstFrame() = 0; /** + * Get the next frame. If it's not ready, this will trigger the + * sending of FrameReady() when the image becomes ready. + */ + virtual TextureSet NextFrame() = 0; + + /** * Get the Nth frame. If it's not ready, this will trigger the * sending of FrameReady() when the image becomes ready. */ @@ -87,7 +93,13 @@ public: /** * Get the interval of Nth frame. */ - virtual uint32_t GetFrameInterval( uint32_t frameIndex ) = 0; + virtual uint32_t GetFrameInterval( uint32_t frameIndex ) const = 0; + + /** + * Get the current rendered frame index. + * If there isn't any loaded frame, returns -1. + */ + virtual int32_t GetCurrentFrameIndex() const = 0; private: diff --git a/dali-toolkit/internal/visuals/animated-image/rolling-animated-image-cache.cpp b/dali-toolkit/internal/visuals/animated-image/rolling-animated-image-cache.cpp index 3992b08..2733d7a 100644 --- a/dali-toolkit/internal/visuals/animated-image/rolling-animated-image-cache.cpp +++ b/dali-toolkit/internal/visuals/animated-image/rolling-animated-image-cache.cpp @@ -65,6 +65,7 @@ RollingAnimatedImageCache::RollingAnimatedImageCache( mAnimatedImageLoading( animatedImageLoading ), mFrameCount( frameCount ), mFrameIndex( 0 ), + mCacheSize( cacheSize ), mQueue( cacheSize ), mIsSynchronousLoading( isSynchronousLoading ), mOnLoading( false ) @@ -114,10 +115,18 @@ TextureSet RollingAnimatedImageCache::Frame( uint32_t frameIndex ) // If the frame of frameIndex was already loaded, load batch from the last frame of queue if( !mQueue.IsEmpty() ) { - mFrameIndex = ( mQueue.Back().mFrameNumber + 1 ) % mFrameCount; + if(!mLoadWaitingQueue.empty()) + { + mFrameIndex = ( mLoadWaitingQueue.back() + 1 ) % mFrameCount; + } + else + { + mFrameIndex = ( mQueue.Back().mFrameNumber + 1 ) % mFrameCount; + } } else { + mOnLoading = false; // If the request is for the first frame or a jumped frame(JUMP_TO) remove current waiting queue. mLoadWaitingQueue.clear(); // If the queue is empty, and the frame of frameIndex is not loaded synchronously. load batch from the frame of frameIndex @@ -149,11 +158,40 @@ TextureSet RollingAnimatedImageCache::FirstFrame() return Frame( 0u ); } -uint32_t RollingAnimatedImageCache::GetFrameInterval( uint32_t frameIndex ) +TextureSet RollingAnimatedImageCache::NextFrame() +{ + TextureSet textureSet; + if(!mQueue.IsEmpty()) + { + uint32_t frameIndex = mQueue.Front().mFrameNumber; + if(IsFrontReady()) + { + frameIndex = (frameIndex + 1) % mFrameCount; + } + textureSet = Frame(frameIndex); + } + else + { + DALI_LOG_ERROR("Cache is empty."); + } + + return textureSet; +} + +uint32_t RollingAnimatedImageCache::GetFrameInterval( uint32_t frameIndex ) const { return mAnimatedImageLoading.GetFrameInterval( frameIndex ); } +int32_t RollingAnimatedImageCache::GetCurrentFrameIndex() const +{ + if(mQueue.IsEmpty()) + { + return -1; + } + return mQueue.Front().mFrameNumber; +} + bool RollingAnimatedImageCache::IsFrontReady() const { return ( !mQueue.IsEmpty() && mQueue.Front().mReady ); @@ -161,6 +199,12 @@ bool RollingAnimatedImageCache::IsFrontReady() const void RollingAnimatedImageCache::RequestFrameLoading( uint32_t frameIndex ) { + ImageFrame imageFrame; + imageFrame.mFrameNumber = frameIndex; + imageFrame.mReady = false; + + mQueue.PushBack(imageFrame); + mRequestingLoad = true; bool synchronousLoading = false; @@ -178,14 +222,8 @@ void RollingAnimatedImageCache::LoadBatch() // removed, and another frame is loaded bool frontFrameReady = IsFrontReady(); - for( unsigned int i=0; i< mBatchSize && !mQueue.IsFull(); ++i ) + for( unsigned int i=0; i< mBatchSize && mQueue.Count() + mLoadWaitingQueue.size() < static_cast(mCacheSize) && !mQueue.IsFull(); ++i ) { - ImageFrame imageFrame; - imageFrame.mFrameNumber = mFrameIndex; - imageFrame.mReady = false; - - mQueue.PushBack( imageFrame ); - if( !mOnLoading ) { mOnLoading = true; diff --git a/dali-toolkit/internal/visuals/animated-image/rolling-animated-image-cache.h b/dali-toolkit/internal/visuals/animated-image/rolling-animated-image-cache.h index 3a24eb6..db35741 100644 --- a/dali-toolkit/internal/visuals/animated-image/rolling-animated-image-cache.h +++ b/dali-toolkit/internal/visuals/animated-image/rolling-animated-image-cache.h @@ -79,9 +79,21 @@ public: TextureSet FirstFrame() override; /** + * Get the next frame. If it's not ready, this will trigger the + * sending of FrameReady() when the image becomes ready. + */ + TextureSet NextFrame() override; + + /** * Get the interval of Nth frame. */ - uint32_t GetFrameInterval( uint32_t frameIndex ) override; + uint32_t GetFrameInterval( uint32_t frameIndex ) const override; + + /** + * Get the current rendered frame index. + * If there isn't any loaded frame, returns -1. + */ + int32_t GetCurrentFrameIndex() const override; private: /** @@ -149,6 +161,7 @@ private: Dali::AnimatedImageLoading mAnimatedImageLoading; uint32_t mFrameCount; int mFrameIndex; + int mCacheSize; std::vector mImageUrls; std::vector mIntervals; std::vector mLoadWaitingQueue; diff --git a/dali-toolkit/internal/visuals/animated-image/rolling-image-cache.cpp b/dali-toolkit/internal/visuals/animated-image/rolling-image-cache.cpp index 2284778..e838060 100644 --- a/dali-toolkit/internal/visuals/animated-image/rolling-image-cache.cpp +++ b/dali-toolkit/internal/visuals/animated-image/rolling-image-cache.cpp @@ -131,11 +131,40 @@ TextureSet RollingImageCache::FirstFrame() return Frame( 0u ); } -uint32_t RollingImageCache::GetFrameInterval( uint32_t frameIndex ) +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."); + } + + return textureSet; +} + +uint32_t RollingImageCache::GetFrameInterval( uint32_t frameIndex ) const { return 0u; } +int32_t RollingImageCache::GetCurrentFrameIndex() const +{ + if(mQueue.IsEmpty()) + { + return -1; + } + return mQueue.Front().mUrlIndex; +} + bool RollingImageCache::IsFrontReady() const { return ( !mQueue.IsEmpty() && mQueue.Front().mReady ); diff --git a/dali-toolkit/internal/visuals/animated-image/rolling-image-cache.h b/dali-toolkit/internal/visuals/animated-image/rolling-image-cache.h index 5f4aa46..c20586f 100644 --- a/dali-toolkit/internal/visuals/animated-image/rolling-image-cache.h +++ b/dali-toolkit/internal/visuals/animated-image/rolling-image-cache.h @@ -72,9 +72,21 @@ public: TextureSet FirstFrame() override; /** + * Get the next frame. If it's not ready, this will trigger the + * sending of FrameReady() when the image becomes ready. + */ + TextureSet NextFrame() override; + + /** * Get the interval of Nth frame. */ - uint32_t GetFrameInterval( uint32_t frameIndex ) override; + uint32_t GetFrameInterval( uint32_t frameIndex ) const override; + + /** + * Get the current rendered frame index. + * If there isn't any loaded frame, returns -1. + */ + int32_t GetCurrentFrameIndex() const override; private: /** diff --git a/dali-toolkit/internal/visuals/texture-manager-impl.cpp b/dali-toolkit/internal/visuals/texture-manager-impl.cpp index 2d82b41..ea0abc1 100644 --- a/dali-toolkit/internal/visuals/texture-manager-impl.cpp +++ b/dali-toolkit/internal/visuals/texture-manager-impl.cpp @@ -458,16 +458,15 @@ TextureManager::TextureId TextureManager::RequestLoadInternal( TextureHash textureHash = INITIAL_CACHE_NUMBER; int cacheIndex = INVALID_CACHE_INDEX; - if(storageType != StorageType::RETURN_PIXEL_BUFFER) + if(storageType != StorageType::RETURN_PIXEL_BUFFER && !isAnimatedImage) { - textureHash = GenerateHash(url.GetUrl(), desiredSize, fittingMode, samplingMode, useAtlas, maskTextureId, isAnimatedImage, frameIndex); + textureHash = GenerateHash(url.GetUrl(), desiredSize, fittingMode, samplingMode, useAtlas, maskTextureId); // Look up the texture by hash. Note: The extra parameters are used in case of a hash collision. - cacheIndex = FindCachedTexture(textureHash, url.GetUrl(), desiredSize, fittingMode, samplingMode, useAtlas, maskTextureId, preMultiplyOnLoad, isAnimatedImage, frameIndex); + cacheIndex = FindCachedTexture(textureHash, url.GetUrl(), desiredSize, fittingMode, samplingMode, useAtlas, maskTextureId, preMultiplyOnLoad); } TextureManager::TextureId textureId = INVALID_TEXTURE_ID; - // Check if the requested Texture exists in the cache. if( cacheIndex != INVALID_CACHE_INDEX ) { @@ -1175,9 +1174,7 @@ TextureManager::TextureHash TextureManager::GenerateHash( const FittingMode::Type fittingMode, const Dali::SamplingMode::Type samplingMode, const UseAtlas useAtlas, - TextureId maskTextureId, - bool isAnimationImage, - uint32_t frameIndex ) + TextureId maskTextureId) { std::string hashTarget( url ); const size_t urlLength = hashTarget.length(); @@ -1222,19 +1219,6 @@ TextureManager::TextureHash TextureManager::GenerateHash( } } - if( isAnimationImage ) - { - auto textureIdIndex = hashTarget.length(); - hashTarget.resize( hashTarget.length() + sizeof( uint32_t ) ); - char* hashTargetPtr = &( hashTarget[ textureIdIndex ] ); - - for( size_t byteIter = 0; byteIter < sizeof( uint32_t ); ++byteIter ) - { - *hashTargetPtr++ = frameIndex & 0xff; - frameIndex >>= 8u; - } - } - if( maskTextureId != INVALID_TEXTURE_ID ) { auto textureIdIndex = hashTarget.length(); @@ -1261,9 +1245,7 @@ int TextureManager::FindCachedTexture( const Dali::SamplingMode::Type samplingMode, const bool useAtlas, TextureId maskTextureId, - TextureManager::MultiplyOnLoad preMultiplyOnLoad, - bool isAnimatedImage, - uint32_t frameIndex ) + TextureManager::MultiplyOnLoad preMultiplyOnLoad) { // Default to an invalid ID, in case we do not find a match. int cacheIndex = INVALID_CACHE_INDEX; @@ -1283,9 +1265,7 @@ int TextureManager::FindCachedTexture( ( size == textureInfo.desiredSize ) && ( ( size.GetWidth() == 0 && size.GetHeight() == 0 ) || ( fittingMode == textureInfo.fittingMode && - samplingMode == textureInfo.samplingMode ) ) && - ( isAnimatedImage == ( ( textureInfo.animatedImageLoading ) ? true : false ) ) && - ( frameIndex == textureInfo.frameIndex ) ) + samplingMode == textureInfo.samplingMode ) ) ) { // 1. If preMultiplyOnLoad is MULTIPLY_ON_LOAD, then textureInfo.preMultiplyOnLoad should be true. The premultiplication result can be different. // 2. If preMultiplyOnLoad is LOAD_WITHOUT_MULTIPLY, then textureInfo.preMultiplied should be false. diff --git a/dali-toolkit/internal/visuals/texture-manager-impl.h b/dali-toolkit/internal/visuals/texture-manager-impl.h index a3da3fc..28e0869 100644 --- a/dali-toolkit/internal/visuals/texture-manager-impl.h +++ b/dali-toolkit/internal/visuals/texture-manager-impl.h @@ -752,14 +752,12 @@ private: * @param[in] samplingMode The SamplingMode to use * @param[in] useAtlas True if atlased * @param[in] maskTextureId The masking texture id (or INVALID_TEXTURE_ID) - * @param[in] isAnimatedImage The boolean value to know whether the request is for animated image or not - * @param[in] frameIndex The frame index of a frame to be loaded frame * @return A hash of the provided data for caching. */ TextureHash GenerateHash( const std::string& url, const ImageDimensions size, const FittingMode::Type fittingMode, const Dali::SamplingMode::Type samplingMode, const UseAtlas useAtlas, - TextureId maskTextureId, bool isAnimatedImage, uint32_t frameIndex ); + TextureId maskTextureId ); /** * @brief Looks up a cached texture by its hash. @@ -772,8 +770,6 @@ private: * @param[in] useAtlas True if atlased * @param[in] maskTextureId Optional texture ID to use to mask this image * @param[in] preMultiplyOnLoad if the image's color should be multiplied by it's alpha. Set to OFF if there is no alpha. - * @param[in] isAnimatedImage The boolean value to know whether the request is for animated image or not - * @param[in] frameIndex The frame index of a frame to be loaded frame * @return A TextureId of a cached Texture if found. Or INVALID_TEXTURE_ID if not found. */ TextureManager::TextureId FindCachedTexture( @@ -784,9 +780,7 @@ private: const Dali::SamplingMode::Type samplingMode, const bool useAtlas, TextureId maskTextureId, - MultiplyOnLoad preMultiplyOnLoad, - bool isAnimatedImage, - uint32_t frameIndex ); + MultiplyOnLoad preMultiplyOnLoad); private: -- 2.7.4