X-Git-Url: http://review.tizen.org/git/?p=platform%2Fcore%2Fuifw%2Fdali-toolkit.git;a=blobdiff_plain;f=dali-toolkit%2Finternal%2Fvisuals%2Fanimated-image%2Fanimated-image-visual.cpp;h=d8d61d3136146bd34c45306fe2124e57824d5105;hp=9ac0b909751c209d1c65257f0a9a2fe3e5ad7f8a;hb=d2a6f4d721fbc03b51d4f1328a58b1fa65f90d43;hpb=2cdc15bcda53ce7feff32cd2358cc1f4d943cbfa 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 9ac0b90..d8d61d3 100644 --- a/dali-toolkit/internal/visuals/animated-image/animated-image-visual.cpp +++ b/dali-toolkit/internal/visuals/animated-image/animated-image-visual.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017 Samsung Electronics Co., Ltd. + * Copyright (c) 2021 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. @@ -19,58 +19,70 @@ #include "animated-image-visual.h" // EXTERNAL INCLUDES -#include #include #include +#include // INTERNAL INCLUDES -#include -#include -#include -#include -#include -#include +#include +#include +#include #include +#include #include -#include -#include +#include +#include +#include +#include +#include +#include +#include namespace Dali { - namespace Toolkit { - namespace Internal { - namespace { +// stop behavior +DALI_ENUM_TO_STRING_TABLE_BEGIN(STOP_BEHAVIOR) + DALI_ENUM_TO_STRING_WITH_SCOPE(Dali::Toolkit::DevelImageVisual::StopBehavior, CURRENT_FRAME) + DALI_ENUM_TO_STRING_WITH_SCOPE(Dali::Toolkit::DevelImageVisual::StopBehavior, FIRST_FRAME) + DALI_ENUM_TO_STRING_WITH_SCOPE(Dali::Toolkit::DevelImageVisual::StopBehavior, LAST_FRAME) +DALI_ENUM_TO_STRING_TABLE_END(STOP_BEHAVIOR) + // wrap modes -DALI_ENUM_TO_STRING_TABLE_BEGIN( WRAP_MODE ) -DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::WrapMode, DEFAULT ) -DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::WrapMode, CLAMP_TO_EDGE ) -DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::WrapMode, REPEAT ) -DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::WrapMode, MIRRORED_REPEAT ) -DALI_ENUM_TO_STRING_TABLE_END( WRAP_MODE ) +DALI_ENUM_TO_STRING_TABLE_BEGIN(WRAP_MODE) + DALI_ENUM_TO_STRING_WITH_SCOPE(Dali::WrapMode, DEFAULT) + DALI_ENUM_TO_STRING_WITH_SCOPE(Dali::WrapMode, CLAMP_TO_EDGE) + DALI_ENUM_TO_STRING_WITH_SCOPE(Dali::WrapMode, REPEAT) + DALI_ENUM_TO_STRING_WITH_SCOPE(Dali::WrapMode, MIRRORED_REPEAT) +DALI_ENUM_TO_STRING_TABLE_END(WRAP_MODE) -const Vector4 FULL_TEXTURE_RECT(0.f, 0.f, 1.f, 1.f); +const Vector4 FULL_TEXTURE_RECT(0.f, 0.f, 1.f, 1.f); +constexpr auto LOOP_FOREVER = -1; #if defined(DEBUG_ENABLED) Debug::Filter* gAnimImgLogFilter = Debug::Filter::New(Debug::NoLogging, false, "LOG_ANIMATED_IMAGE"); #endif -} - +} // namespace /** * Multi-image Flow of execution * - * | DoSetProperties() + * | New + * | DoSetProperties() * | LoadFirstBatch() - * | cache->LoadBatch() + * | new cache + * | cache->LoadBatch() * | - * | DoSetOnStage() + * | DoSetOnScene() + * | PrepareTextureSet() + * | cache->FirstFrame() * | CreateRenderer() (Doesn't become ready until first frame loads) + * | StartFirstFrame() * | * | FrameReady(textureSet) * | start first frame: @@ -92,60 +104,97 @@ Debug::Filter* gAnimImgLogFilter = Debug::Filter::New(Debug::NoLogging, false, " * Time */ -AnimatedImageVisualPtr AnimatedImageVisual::New( VisualFactoryCache& factoryCache, const VisualUrl& imageUrl, const Property::Map& properties ) +AnimatedImageVisualPtr AnimatedImageVisual::New(VisualFactoryCache& factoryCache, ImageVisualShaderFactory& shaderFactory, const VisualUrl& imageUrl, const Property::Map& properties) { - AnimatedImageVisual* visual = new AnimatedImageVisual( factoryCache ); - visual->mImageUrl = imageUrl; - visual->SetProperties( properties ); + AnimatedImageVisualPtr visual(new AnimatedImageVisual(factoryCache, shaderFactory)); + visual->InitializeAnimatedImage(imageUrl); + visual->SetProperties(properties); + + if(visual->mFrameCount > 0) + { + visual->LoadFirstBatch(); + } + + visual->Initialize(); return visual; } -AnimatedImageVisualPtr AnimatedImageVisual::New( VisualFactoryCache& factoryCache, const Property::Array& imageUrls, const Property::Map& properties ) +AnimatedImageVisualPtr AnimatedImageVisual::New(VisualFactoryCache& factoryCache, ImageVisualShaderFactory& shaderFactory, const Property::Array& imageUrls, const Property::Map& properties) { - AnimatedImageVisual* visual = new AnimatedImageVisual( factoryCache ); + AnimatedImageVisualPtr visual(new AnimatedImageVisual(factoryCache, shaderFactory)); visual->mImageUrls = new ImageCache::UrlList(); - visual->mImageUrls->reserve( imageUrls.Count() ); + visual->mImageUrls->reserve(imageUrls.Count()); - for( unsigned int i=0; i < imageUrls.Count(); ++i) + for(unsigned int i = 0; i < imageUrls.Count(); ++i) { ImageCache::UrlStore urlStore; urlStore.mTextureId = TextureManager::INVALID_TEXTURE_ID; - urlStore.mUrl = imageUrls[i].Get(); - visual->mImageUrls->push_back( urlStore ); + urlStore.mUrl = imageUrls[i].Get(); + visual->mImageUrls->push_back(urlStore); } + visual->mFrameCount = imageUrls.Count(); + visual->SetProperties(properties); + + if(visual->mFrameCount > 0) + { + visual->LoadFirstBatch(); + } + + visual->Initialize(); - visual->SetProperties( properties ); - // starts loading immediately return visual; } -AnimatedImageVisualPtr AnimatedImageVisual::New( VisualFactoryCache& factoryCache, const VisualUrl& imageUrl ) +AnimatedImageVisualPtr AnimatedImageVisual::New(VisualFactoryCache& factoryCache, ImageVisualShaderFactory& shaderFactory, const VisualUrl& imageUrl) { - AnimatedImageVisual* visual = new AnimatedImageVisual( factoryCache ); - visual->mImageUrl = imageUrl; + AnimatedImageVisualPtr visual(new AnimatedImageVisual(factoryCache, shaderFactory)); + visual->InitializeAnimatedImage(imageUrl); + + if(visual->mFrameCount > 0) + { + visual->LoadFirstBatch(); + } + + visual->Initialize(); return visual; } -AnimatedImageVisual::AnimatedImageVisual( VisualFactoryCache& factoryCache ) -: Visual::Base( factoryCache ), +void AnimatedImageVisual::InitializeAnimatedImage(const VisualUrl& imageUrl) +{ + mImageUrl = imageUrl; + mAnimatedImageLoading = AnimatedImageLoading::New(imageUrl.GetUrl(), imageUrl.IsLocalResource()); + mFrameCount = mAnimatedImageLoading.GetImageCount(); +} + +AnimatedImageVisual::AnimatedImageVisual(VisualFactoryCache& factoryCache, ImageVisualShaderFactory& shaderFactory) +: Visual::Base(factoryCache, Visual::FittingMode::FIT_KEEP_ASPECT_RATIO, Toolkit::Visual::ANIMATED_IMAGE), mFrameDelayTimer(), mPlacementActor(), - mPixelArea( FULL_TEXTURE_RECT ), + mImageVisualShaderFactory(shaderFactory), + mPixelArea(FULL_TEXTURE_RECT), mImageUrl(), - mCurrentFrameIndex( 0 ), - mImageUrls( NULL ), - mImageCache( NULL ), - mCacheSize( 1 ), - mBatchSize( 1 ), - mFrameDelay( 100 ), - mUrlIndex( 0 ), + mAnimatedImageLoading(), + mFrameIndexForJumpTo(0), + mImageUrls(NULL), + mImageCache(NULL), + mCacheSize(2), + mBatchSize(2), + mFrameDelay(100), + mLoopCount(LOOP_FOREVER), + mCurrentLoopIndex(0), + mUrlIndex(0), + mFrameCount(0), mImageSize(), - mWrapModeU( WrapMode::DEFAULT ), - mWrapModeV( WrapMode::DEFAULT ), - mStartFirstFrame(false) -{} + mActionStatus(DevelAnimatedImageVisual::Action::PLAY), + mWrapModeU(WrapMode::DEFAULT), + mWrapModeV(WrapMode::DEFAULT), + mStopBehavior(DevelImageVisual::StopBehavior::CURRENT_FRAME), + mStartFirstFrame(false), + mIsJumpTo(false) +{ +} AnimatedImageVisual::~AnimatedImageVisual() { @@ -153,119 +202,190 @@ AnimatedImageVisual::~AnimatedImageVisual() delete mImageUrls; } -void AnimatedImageVisual::GetNaturalSize( Vector2& naturalSize ) +void AnimatedImageVisual::GetNaturalSize(Vector2& naturalSize) { - if( mImageSize.GetWidth() == 0 && mImageSize.GetHeight() == 0) + if(mImageSize.GetWidth() == 0 && mImageSize.GetHeight() == 0) { - if( mImageUrl.IsValid() ) + if(mImageUrl.IsValid()) { - mImageSize = Dali::GetGifImageSize( mImageUrl.GetUrl() ); + mImageSize = mAnimatedImageLoading.GetImageSize(); } - else if( mImageUrls && mImageUrls->size() > 0 ) + else if(mImageUrls && mImageUrls->size() > 0) { - mImageSize = Dali::GetClosestImageSize( (*mImageUrls)[0].mUrl ); + mImageSize = Dali::GetClosestImageSize((*mImageUrls)[0].mUrl); } } - naturalSize.width = mImageSize.GetWidth(); + naturalSize.width = mImageSize.GetWidth(); naturalSize.height = mImageSize.GetHeight(); } -void AnimatedImageVisual::DoCreatePropertyMap( Property::Map& map ) const +void AnimatedImageVisual::DoCreatePropertyMap(Property::Map& map) const { map.Clear(); - map.Insert( Toolkit::Visual::Property::TYPE, Toolkit::Visual::ANIMATED_IMAGE ); + bool sync = IsSynchronousLoadingRequired(); + map.Insert(Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING, sync); - if( mImageUrl.IsValid() ) + map.Insert(Toolkit::Visual::Property::TYPE, Toolkit::Visual::ANIMATED_IMAGE); + + if(mImageUrl.IsValid()) { - map.Insert( Toolkit::ImageVisual::Property::URL, mImageUrl.GetUrl() ); + map.Insert(Toolkit::ImageVisual::Property::URL, mImageUrl.GetUrl()); } - if( mImageUrls != NULL && ! mImageUrls->empty() ) + if(mImageUrls != NULL && !mImageUrls->empty()) { Property::Array urls; - for( unsigned int i=0; isize(); ++i) + for(unsigned int i = 0; i < mImageUrls->size(); ++i) { - urls.Add( (*mImageUrls)[i].mUrl ); + urls.Add((*mImageUrls)[i].mUrl); } - Property::Value value( const_cast(urls) ); - map.Insert( Toolkit::ImageVisual::Property::URL, value ); + Property::Value value(const_cast(urls)); + map.Insert(Toolkit::ImageVisual::Property::URL, value); } - map.Insert( Toolkit::ImageVisual::Property::PIXEL_AREA, mPixelArea ); - map.Insert( Toolkit::ImageVisual::Property::WRAP_MODE_U, mWrapModeU ); - map.Insert( Toolkit::ImageVisual::Property::WRAP_MODE_V, mWrapModeV ); + map.Insert(Toolkit::ImageVisual::Property::PIXEL_AREA, mPixelArea); + map.Insert(Toolkit::ImageVisual::Property::WRAP_MODE_U, mWrapModeU); + map.Insert(Toolkit::ImageVisual::Property::WRAP_MODE_V, mWrapModeV); + + map.Insert(Toolkit::ImageVisual::Property::BATCH_SIZE, static_cast(mBatchSize)); + map.Insert(Toolkit::ImageVisual::Property::CACHE_SIZE, static_cast(mCacheSize)); + map.Insert(Toolkit::ImageVisual::Property::FRAME_DELAY, static_cast(mFrameDelay)); + map.Insert(Toolkit::DevelImageVisual::Property::LOOP_COUNT, static_cast(mLoopCount)); + map.Insert(Toolkit::DevelImageVisual::Property::CURRENT_FRAME_NUMBER, (mImageCache) ? static_cast(mImageCache->GetCurrentFrameIndex()) : -1); + map.Insert(Toolkit::DevelImageVisual::Property::TOTAL_FRAME_NUMBER, (mImageCache) ? static_cast(mImageCache->GetTotalFrameCount()) : -1); - map.Insert( Toolkit::ImageVisual::Property::BATCH_SIZE, static_cast(mBatchSize) ); - map.Insert( Toolkit::ImageVisual::Property::CACHE_SIZE, static_cast(mCacheSize) ); - map.Insert( Toolkit::ImageVisual::Property::FRAME_DELAY, static_cast(mFrameDelay) ); + map.Insert(Toolkit::DevelImageVisual::Property::STOP_BEHAVIOR, mStopBehavior); } -void AnimatedImageVisual::DoCreateInstancePropertyMap( Property::Map& map ) const +void AnimatedImageVisual::DoCreateInstancePropertyMap(Property::Map& map) const { // Do nothing } -void AnimatedImageVisual::DoSetProperties( const Property::Map& propertyMap ) +void AnimatedImageVisual::OnDoAction(const Dali::Property::Index actionId, const Dali::Property::Value& attributes) { - // url[s] already passed in from constructor + // Make not set any action when the resource status is already failed. + if(mImpl->mResourceStatus == Toolkit::Visual::ResourceStatus::FAILED) + { + return; + } + + // Check if action is valid for this visual type and perform action if possible + switch(actionId) + { + case DevelAnimatedImageVisual::Action::PAUSE: + { + // Pause will be executed on next timer tick + mActionStatus = DevelAnimatedImageVisual::Action::PAUSE; + break; + } + case DevelAnimatedImageVisual::Action::PLAY: + { + if(mFrameDelayTimer && IsOnScene() && mActionStatus != DevelAnimatedImageVisual::Action::PLAY) + { + mFrameDelayTimer.Start(); + } + mActionStatus = DevelAnimatedImageVisual::Action::PLAY; + break; + } + case DevelAnimatedImageVisual::Action::STOP: + { + // STOP reset functionality will actually be done in a future change + // Stop will be executed on next timer tick + mActionStatus = DevelAnimatedImageVisual::Action::STOP; + if(IsOnScene()) + { + DisplayNextFrame(); + } + break; + } + case DevelAnimatedImageVisual::Action::JUMP_TO: + { + int32_t frameNumber; + if(attributes.Get(frameNumber)) + { + if(frameNumber < 0 || frameNumber >= static_cast(mFrameCount)) + { + DALI_LOG_ERROR("Invalid frame index used.\n"); + } + else + { + mIsJumpTo = true; + mFrameIndexForJumpTo = frameNumber; + if(IsOnScene()) + { + DisplayNextFrame(); + } + } + } + break; + } + } +} - for( Property::Map::SizeType iter = 0; iter < propertyMap.Count(); ++iter ) +void AnimatedImageVisual::DoSetProperties(const Property::Map& propertyMap) +{ + // url[s] already passed in from constructor + for(Property::Map::SizeType iter = 0; iter < propertyMap.Count(); ++iter) { - KeyValuePair keyValue = propertyMap.GetKeyValue( iter ); - if( keyValue.first.type == Property::Key::INDEX ) + KeyValuePair keyValue = propertyMap.GetKeyValue(iter); + if(keyValue.first.type == Property::Key::INDEX) { - DoSetProperty( keyValue.first.indexKey, keyValue.second ); + DoSetProperty(keyValue.first.indexKey, keyValue.second); } else { - if( keyValue.first == PIXEL_AREA_UNIFORM_NAME ) + if(keyValue.first == PIXEL_AREA_UNIFORM_NAME) + { + DoSetProperty(Toolkit::ImageVisual::Property::PIXEL_AREA, keyValue.second); + } + else if(keyValue.first == IMAGE_WRAP_MODE_U) { - DoSetProperty( Toolkit::ImageVisual::Property::PIXEL_AREA, keyValue.second ); + DoSetProperty(Toolkit::ImageVisual::Property::WRAP_MODE_U, keyValue.second); } - else if( keyValue.first == IMAGE_WRAP_MODE_U ) + else if(keyValue.first == IMAGE_WRAP_MODE_V) { - DoSetProperty( Toolkit::ImageVisual::Property::WRAP_MODE_U, keyValue.second ); + DoSetProperty(Toolkit::ImageVisual::Property::WRAP_MODE_V, keyValue.second); } - else if( keyValue.first == IMAGE_WRAP_MODE_V ) + else if(keyValue.first == BATCH_SIZE_NAME) { - DoSetProperty( Toolkit::ImageVisual::Property::WRAP_MODE_V, keyValue.second ); + DoSetProperty(Toolkit::ImageVisual::Property::BATCH_SIZE, keyValue.second); } - else if( keyValue.first == BATCH_SIZE_NAME ) + else if(keyValue.first == CACHE_SIZE_NAME) { - DoSetProperty( Toolkit::ImageVisual::Property::BATCH_SIZE, keyValue.second ); + DoSetProperty(Toolkit::ImageVisual::Property::CACHE_SIZE, keyValue.second); } - else if( keyValue.first == CACHE_SIZE_NAME ) + else if(keyValue.first == FRAME_DELAY_NAME) { - DoSetProperty( Toolkit::ImageVisual::Property::CACHE_SIZE, keyValue.second ); + DoSetProperty(Toolkit::ImageVisual::Property::FRAME_DELAY, keyValue.second); } - else if( keyValue.first == FRAME_DELAY_NAME ) + else if(keyValue.first == LOOP_COUNT_NAME) { - DoSetProperty( Toolkit::ImageVisual::Property::FRAME_DELAY, keyValue.second ); + DoSetProperty(Toolkit::DevelImageVisual::Property::LOOP_COUNT, keyValue.second); + } + else if(keyValue.first == STOP_BEHAVIOR_NAME) + { + DoSetProperty(Toolkit::DevelImageVisual::Property::STOP_BEHAVIOR, keyValue.second); } } } - - if( mImageUrls && mImageUrls->size() > 0 ) - { - LoadFirstBatch(); - } } -void AnimatedImageVisual::DoSetProperty( Property::Index index, - const Property::Value& value ) +void AnimatedImageVisual::DoSetProperty(Property::Index index, + const Property::Value& value) { switch(index) { case Toolkit::ImageVisual::Property::PIXEL_AREA: { - value.Get( mPixelArea ); + value.Get(mPixelArea); break; } case Toolkit::ImageVisual::Property::WRAP_MODE_U: { - int wrapMode; - if(Scripting::GetEnumerationProperty( value, WRAP_MODE_TABLE, WRAP_MODE_TABLE_COUNT, wrapMode )) + int wrapMode = 0; + if(Scripting::GetEnumerationProperty(value, WRAP_MODE_TABLE, WRAP_MODE_TABLE_COUNT, wrapMode)) { mWrapModeU = Dali::WrapMode::Type(wrapMode); } @@ -277,8 +397,8 @@ void AnimatedImageVisual::DoSetProperty( Property::Index index, } case Toolkit::ImageVisual::Property::WRAP_MODE_V: { - int wrapMode; - if(Scripting::GetEnumerationProperty( value, WRAP_MODE_TABLE, WRAP_MODE_TABLE_COUNT, wrapMode )) + int wrapMode = 0; + if(Scripting::GetEnumerationProperty(value, WRAP_MODE_TABLE, WRAP_MODE_TABLE_COUNT, wrapMode)) { mWrapModeV = Dali::WrapMode::Type(wrapMode); } @@ -292,9 +412,16 @@ void AnimatedImageVisual::DoSetProperty( Property::Index index, case Toolkit::ImageVisual::Property::BATCH_SIZE: { int batchSize; - if( value.Get( batchSize ) ) + if(value.Get(batchSize)) { - mBatchSize = batchSize; + if(batchSize < 2) + { + DALI_LOG_ERROR("The minimum value of batch size is 2."); + } + else + { + mBatchSize = batchSize; + } } break; } @@ -302,9 +429,16 @@ void AnimatedImageVisual::DoSetProperty( Property::Index index, case Toolkit::ImageVisual::Property::CACHE_SIZE: { int cacheSize; - if( value.Get( cacheSize ) ) + if(value.Get(cacheSize)) { - mCacheSize = cacheSize; + if(cacheSize < 2) + { + DALI_LOG_ERROR("The minimum value of cache size is 2."); + } + else + { + mCacheSize = cacheSize; + } } break; } @@ -312,24 +446,65 @@ void AnimatedImageVisual::DoSetProperty( Property::Index index, case Toolkit::ImageVisual::Property::FRAME_DELAY: { int frameDelay; - if( value.Get( frameDelay ) ) + if(value.Get(frameDelay)) { mFrameDelay = frameDelay; } break; } + + case Toolkit::DevelImageVisual::Property::LOOP_COUNT: + { + int loopCount; + if(value.Get(loopCount)) + { + mLoopCount = loopCount; + } + break; + } + + case Toolkit::DevelImageVisual::Property::STOP_BEHAVIOR: + { + int32_t stopBehavior = mStopBehavior; + if(Scripting::GetEnumerationProperty(value, STOP_BEHAVIOR_TABLE, STOP_BEHAVIOR_TABLE_COUNT, stopBehavior)) + { + mStopBehavior = DevelImageVisual::StopBehavior::Type(stopBehavior); + } + break; + } + + case Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING: + { + bool sync = false; + value.Get(sync); + if(sync) + { + mImpl->mFlags |= Impl::IS_SYNCHRONOUS_RESOURCE_LOADING; + } + else + { + mImpl->mFlags &= ~Impl::IS_SYNCHRONOUS_RESOURCE_LOADING; + } + break; + } } } -void AnimatedImageVisual::DoSetOnStage( Actor& actor ) +void AnimatedImageVisual::DoSetOnScene(Actor& actor) { - mPlacementActor = actor; + mPlacementActor = actor; TextureSet textureSet = PrepareTextureSet(); - CreateRenderer(); // Always create a renderer when on stage - if( textureSet ) // if the image loading is successful + // Loading animated image file is failed. + if(!mImageCache || + (mAnimatedImageLoading && !mAnimatedImageLoading.HasLoadingSucceeded())) + { + textureSet = SetLoadingFailed(); + } + + if(textureSet) // if the image loading is successful { - StartFirstFrame( textureSet ); + StartFirstFrame(textureSet); } else { @@ -337,220 +512,333 @@ void AnimatedImageVisual::DoSetOnStage( Actor& actor ) } } -void AnimatedImageVisual::DoSetOffStage( Actor& actor ) +void AnimatedImageVisual::DoSetOffScene(Actor& actor) { - DALI_ASSERT_DEBUG( (bool)mImpl->mRenderer && "There should always be a renderer whilst on stage"); + DALI_ASSERT_DEBUG((bool)mImpl->mRenderer && "There should always be a renderer whilst on stage"); - if( mFrameDelayTimer ) + if(mFrameDelayTimer) { mFrameDelayTimer.Stop(); mFrameDelayTimer.Reset(); } - mTextureRectContainer.Clear(); - mFrameDelayContainer.Clear(); - - actor.RemoveRenderer( mImpl->mRenderer ); - mImpl->mRenderer.Reset(); + actor.RemoveRenderer(mImpl->mRenderer); mPlacementActor.Reset(); + mStartFirstFrame = false; } void AnimatedImageVisual::OnSetTransform() { - if( mImpl->mRenderer ) + if(mImpl->mRenderer) { - mImpl->mTransform.RegisterUniforms( mImpl->mRenderer, Direction::LEFT_TO_RIGHT ); + mImpl->mTransform.RegisterUniforms(mImpl->mRenderer, Direction::LEFT_TO_RIGHT); } } -void AnimatedImageVisual::CreateRenderer() +void AnimatedImageVisual::UpdateShader() { - bool defaultWrapMode = mWrapModeU <= WrapMode::CLAMP_TO_EDGE && mWrapModeV <= WrapMode::CLAMP_TO_EDGE; - bool atlasing = (mTextureRectContainer.Count() > 0) ; - Shader shader = ImageVisual::GetImageShader( mFactoryCache, atlasing, defaultWrapMode ); + if(mImpl->mRenderer) + { + Shader shader = GenerateShader(); + mImpl->mRenderer.SetShader(shader); + } +} - Geometry geometry = mFactoryCache.GetGeometry( VisualFactoryCache::QUAD_GEOMETRY ); +void AnimatedImageVisual::OnInitialize() +{ + bool defaultWrapMode = mWrapModeU <= WrapMode::CLAMP_TO_EDGE && mWrapModeV <= WrapMode::CLAMP_TO_EDGE; + Shader shader = GenerateShader(); - mImpl->mRenderer = Renderer::New( geometry, shader ); + Geometry geometry = mFactoryCache.GetGeometry(VisualFactoryCache::QUAD_GEOMETRY); - // Register transform properties - mImpl->mTransform.RegisterUniforms( mImpl->mRenderer, Direction::LEFT_TO_RIGHT ); + mImpl->mRenderer = Renderer::New(geometry, shader); - if( !defaultWrapMode ) // custom wrap mode - { - Vector2 wrapMode(mWrapModeU-WrapMode::CLAMP_TO_EDGE, mWrapModeV-WrapMode::CLAMP_TO_EDGE); - wrapMode.Clamp( Vector2::ZERO, Vector2( 2.f, 2.f ) ); - mImpl->mRenderer.RegisterProperty( WRAP_MODE_UNIFORM_NAME, wrapMode ); - } + // Register transform properties + mImpl->mTransform.RegisterUniforms(mImpl->mRenderer, Direction::LEFT_TO_RIGHT); - if( mPixelArea != FULL_TEXTURE_RECT ) + if(!defaultWrapMode) // custom wrap mode { - mImpl->mRenderer.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, mPixelArea ); + Vector2 wrapMode(mWrapModeU - WrapMode::CLAMP_TO_EDGE, mWrapModeV - WrapMode::CLAMP_TO_EDGE); + wrapMode.Clamp(Vector2::ZERO, Vector2(2.f, 2.f)); + mImpl->mRenderer.RegisterProperty(WRAP_MODE_UNIFORM_NAME, wrapMode); } - mCurrentFrameIndex = 0; - - if( mTextureRectContainer.Count() > 0 ) + if(mPixelArea != FULL_TEXTURE_RECT) { - mImpl->mRenderer.RegisterProperty( ATLAS_RECT_UNIFORM_NAME, mTextureRectContainer[mCurrentFrameIndex] ); + mImpl->mRenderer.RegisterProperty(PIXEL_AREA_UNIFORM_NAME, mPixelArea); } } void AnimatedImageVisual::LoadFirstBatch() { - DALI_LOG_INFO(gAnimImgLogFilter,Debug::Concise,"AnimatedImageVisual::LoadFirstBatch()\n"); - // Ensure the batch size and cache size are no bigger than the number of URLs, // and that the cache is at least as big as the batch size. - uint16_t numUrls = mImageUrls->size(); - uint16_t batchSize = std::min( mBatchSize, numUrls ); - uint16_t cacheSize = std::min( std::max( batchSize, mCacheSize ), numUrls ); + uint16_t numUrls = 0; + uint16_t batchSize = 1; + uint16_t cacheSize = 1; - mUrlIndex = 0; + if(mImageUrls) + { + numUrls = mImageUrls->size(); + } + else + { + numUrls = mFrameCount; + } + + batchSize = std::min(mBatchSize, numUrls); + cacheSize = std::min(std::max(batchSize, mCacheSize), numUrls); + + DALI_LOG_INFO(gAnimImgLogFilter, Debug::Concise, "AnimatedImageVisual::LoadFirstBatch() batchSize:%d cacheSize:%d\n", batchSize, cacheSize); + + mUrlIndex = 0; TextureManager& textureManager = mFactoryCache.GetTextureManager(); - if( batchSize > 0 && cacheSize > 0 ) + if(mAnimatedImageLoading) + { + mImageCache = new RollingAnimatedImageCache(textureManager, mAnimatedImageLoading, mFrameCount, *this, cacheSize, batchSize, IsSynchronousLoadingRequired()); + } + else if(mImageUrls) { - if( cacheSize < numUrls ) + if(batchSize > 0 && cacheSize > 0) { - mImageCache = new RollingImageCache( textureManager, *mImageUrls, *this, cacheSize, batchSize ); + if(cacheSize < numUrls) + { + mImageCache = new RollingImageCache(textureManager, *mImageUrls, *this, cacheSize, batchSize); + } + else + { + mImageCache = new FixedImageCache(textureManager, *mImageUrls, *this, batchSize); + } } else { - mImageCache = new FixedImageCache( textureManager, *mImageUrls, *this, batchSize ); + mImageCache = new RollingImageCache(textureManager, *mImageUrls, *this, 1, 1); } } - else + + if(!mImageCache) { - mImageCache = new RollingImageCache( textureManager, *mImageUrls, *this, 1, 1 ); + DALI_LOG_ERROR("mImageCache is null\n"); } } -void AnimatedImageVisual::StartFirstFrame( TextureSet& textureSet ) +void AnimatedImageVisual::StartFirstFrame(TextureSet& textureSet) { - DALI_LOG_INFO(gAnimImgLogFilter,Debug::Concise,"AnimatedImageVisual::StartFirstFrame()\n"); + DALI_LOG_INFO(gAnimImgLogFilter, Debug::Concise, "AnimatedImageVisual::StartFirstFrame()\n"); mStartFirstFrame = false; - mImpl->mRenderer.SetTextures( textureSet ); - Actor actor = mPlacementActor.GetHandle(); - if( actor ) + if(mImpl->mRenderer) { - actor.AddRenderer( mImpl->mRenderer ); - mPlacementActor.Reset(); + mImpl->mRenderer.SetTextures(textureSet); + + Actor actor = mPlacementActor.GetHandle(); + if(actor) + { + actor.AddRenderer(mImpl->mRenderer); + mPlacementActor.Reset(); + } } - int frameDelay = mFrameDelay; - if( mFrameDelayContainer.Count() > 1 ) + if(mFrameCount > 1) { - frameDelay = mFrameDelayContainer[0]; + int frameDelay = mImageCache->GetFrameInterval(0); + if(frameDelay == 0u) + { + frameDelay = mFrameDelay; // from URL array + } + mFrameDelayTimer = Timer::New(frameDelay); + mFrameDelayTimer.TickSignal().Connect(this, &AnimatedImageVisual::DisplayNextFrame); + mFrameDelayTimer.Start(); } - mFrameDelayTimer = Timer::New( frameDelay ); - mFrameDelayTimer.TickSignal().Connect( this, &AnimatedImageVisual::DisplayNextFrame ); - mFrameDelayTimer.Start(); - DALI_LOG_INFO(gAnimImgLogFilter,Debug::Concise,"ResourceReady()\n"); - ResourceReady( Toolkit::Visual::ResourceStatus::READY ); + if(mImpl->mResourceStatus != Toolkit::Visual::ResourceStatus::FAILED) + { + DALI_LOG_INFO(gAnimImgLogFilter, Debug::Concise, "ResourceReady(ResourceStatus::READY)\n"); + ResourceReady(Toolkit::Visual::ResourceStatus::READY); + } } TextureSet AnimatedImageVisual::PrepareTextureSet() { TextureSet textureSet; - if( mImageUrl.IsValid() ) - { - textureSet = PrepareAnimatedGifImage(); - } - else + if(mImageCache) { textureSet = mImageCache->FirstFrame(); - if( textureSet ) - { - SetImageSize( textureSet ); - } } - return textureSet; -} - -TextureSet AnimatedImageVisual::PrepareAnimatedGifImage() -{ - TextureSet textureSet; - - // load from image file - std::vector pixelDataList; - if( mImageUrl.IsLocalResource() ) + if(textureSet) { - if( Dali::LoadAnimatedGifFromFile( mImageUrl.GetUrl().c_str() , pixelDataList, mFrameDelayContainer ) ) - { - mImageSize.SetWidth( pixelDataList[0].GetWidth() ); - mImageSize.SetHeight( pixelDataList[0].GetHeight() ); - - Texture texture = Toolkit::ImageAtlas::PackToAtlas( pixelDataList, mTextureRectContainer ); - textureSet = TextureSet::New(); - textureSet.SetTexture( 0, texture ); - } + SetImageSize(textureSet); } return textureSet; } -void AnimatedImageVisual::SetImageSize( TextureSet& textureSet ) +void AnimatedImageVisual::SetImageSize(TextureSet& textureSet) { - if( textureSet ) + if(textureSet) { - Texture texture = textureSet.GetTexture( 0 ); - if( texture ) + Texture texture = textureSet.GetTexture(0); + if(texture) { - mImageSize.SetWidth( texture.GetWidth() ); - mImageSize.SetHeight( texture.GetHeight() ); + mImageSize.SetWidth(texture.GetWidth()); + mImageSize.SetHeight(texture.GetHeight()); } } } -void AnimatedImageVisual::FrameReady( TextureSet textureSet ) +void AnimatedImageVisual::FrameReady(TextureSet textureSet) { - SetImageSize( textureSet ); + // When image visual requested to load new frame to mImageCache and it is failed. + if(!textureSet) + { + textureSet = SetLoadingFailed(); + } + + SetImageSize(textureSet); - if( mStartFirstFrame ) + if(mStartFirstFrame) { - StartFirstFrame( textureSet ); + StartFirstFrame(textureSet); } else { - mImpl->mRenderer.SetTextures( textureSet ); + if(mImpl->mRenderer) + { + mImpl->mRenderer.SetTextures(textureSet); + } } } bool AnimatedImageVisual::DisplayNextFrame() { - DALI_LOG_INFO(gAnimImgLogFilter,Debug::Concise,"AnimatedImageVisual::DisplayNextFrame() start\n"); + TextureSet textureSet; + bool continueTimer = false; - if( mFrameDelayContainer.Count() > 0 ) + if(mImageCache) { - // Wrap the frame index - ++mCurrentFrameIndex; - mCurrentFrameIndex %= mFrameDelayContainer.Count(); + bool nextFrame = false; + uint32_t frameIndex = mImageCache->GetCurrentFrameIndex(); - mImpl->mRenderer.RegisterProperty( ATLAS_RECT_UNIFORM_NAME, mTextureRectContainer[mCurrentFrameIndex] ); + if(mIsJumpTo) + { + mIsJumpTo = false; + frameIndex = mFrameIndexForJumpTo; + } + else if(mActionStatus == DevelAnimatedImageVisual::Action::PAUSE) + { + return false; + } + else if(mActionStatus == DevelAnimatedImageVisual::Action::STOP) + { + frameIndex = 0; + if(mStopBehavior == DevelImageVisual::StopBehavior::FIRST_FRAME) + { + frameIndex = 0; + } + else if(mStopBehavior == DevelImageVisual::StopBehavior::LAST_FRAME) + { + frameIndex = mFrameCount - 1; + } + else + { + return false; // Do not draw already rendered scene twice. + } + } + else + { + if(mFrameCount > 1) + { + nextFrame = true; + frameIndex++; + if(frameIndex >= mFrameCount) + { + frameIndex %= mFrameCount; + ++mCurrentLoopIndex; + } + + if(mLoopCount >= 0 && mCurrentLoopIndex >= mLoopCount) + { + // This will stop timer + mActionStatus = DevelAnimatedImageVisual::Action::STOP; + return DisplayNextFrame(); + } + } - if( mFrameDelayTimer.GetInterval() != mFrameDelayContainer[mCurrentFrameIndex] ) + unsigned int delay = mImageCache->GetFrameInterval(frameIndex); + if(delay > 0u) + { + if(mFrameDelayTimer.GetInterval() != delay) + { + mFrameDelayTimer.SetInterval(delay); + } + } + } + + DALI_LOG_INFO(gAnimImgLogFilter, Debug::Concise, "AnimatedImageVisual::DisplayNextFrame(this:%p) CurrentFrameIndex:%d\n", this, frameIndex); + + if(nextFrame) + { + textureSet = mImageCache->NextFrame(); + } + else { - mFrameDelayTimer.SetInterval( mFrameDelayContainer[mCurrentFrameIndex] ); + textureSet = mImageCache->Frame(frameIndex); } + + continueTimer = (mActionStatus == DevelAnimatedImageVisual::Action::PLAY) ? true : false; } - else if( mImageCache ) + + if(textureSet) { - TextureSet textureSet = mImageCache->NextFrame(); - if( textureSet ) + SetImageSize(textureSet); + if(mImpl->mRenderer) { - SetImageSize( textureSet ); - mImpl->mRenderer.SetTextures( textureSet ); + mImpl->mRenderer.SetTextures(textureSet); } } - // Keep timer ticking - return true; + return continueTimer; +} + +TextureSet AnimatedImageVisual::SetLoadingFailed() +{ + DALI_LOG_INFO(gAnimImgLogFilter, Debug::Concise, "ResourceReady(ResourceStatus::FAILED)\n"); + ResourceReady(Toolkit::Visual::ResourceStatus::FAILED); + + Actor actor = mPlacementActor.GetHandle(); + Vector2 imageSize = Vector2::ZERO; + if(actor) + { + imageSize = actor.GetProperty(Actor::Property::SIZE).Get(); + } + mFactoryCache.UpdateBrokenImageRenderer(mImpl->mRenderer, imageSize); + TextureSet textureSet = mImpl->mRenderer.GetTextures(); + + if(mFrameDelayTimer) + { + mFrameDelayTimer.Stop(); + mFrameDelayTimer.Reset(); + } + + SetImageSize(textureSet); + + return textureSet; } +Shader AnimatedImageVisual::GenerateShader() const +{ + bool defaultWrapMode = mWrapModeU <= WrapMode::CLAMP_TO_EDGE && mWrapModeV <= WrapMode::CLAMP_TO_EDGE; + Shader shader; + shader = mImageVisualShaderFactory.GetShader( + mFactoryCache, + TextureAtlas::DISABLED, + defaultWrapMode ? DefaultTextureWrapMode::APPLY : DefaultTextureWrapMode::DO_NOT_APPLY, + IsRoundedCornerRequired() ? RoundedCorner::ENABLED : RoundedCorner::DISABLED, + IsBorderlineRequired() ? Borderline::ENABLED : Borderline::DISABLED); + return shader; +} } // namespace Internal