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=b704d34928914eea71d9084b47fdfe2d83489bd8;hp=6b7adf3059d2e2afdf14f2e22e9b3bd75c780c64;hb=4464c30c30e68c6eee56cda1a201b22eb164fd20;hpb=d51cf112336be005eec7a543b5665bfb7480918c diff --git a/dali-toolkit/internal/visuals/animated-image/animated-image-visual.cpp b/dali-toolkit/internal/visuals/animated-image/animated-image-visual.cpp old mode 100755 new mode 100644 index 6b7adf3..b704d34 --- 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) 2020 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. @@ -24,72 +24,84 @@ #include // INTERNAL INCLUDES -#include -#include -#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 { +const int CUSTOM_PROPERTY_COUNT(3); // ltr, wrap, pixel area, + // 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 ) +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 ) - -const Vector4 FULL_TEXTURE_RECT(0.f, 0.f, 1.f, 1.f); -constexpr auto LOOP_FOREVER = -1; +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) + +// load policies +DALI_ENUM_TO_STRING_TABLE_BEGIN(LOAD_POLICY) + DALI_ENUM_TO_STRING_WITH_SCOPE(Dali::Toolkit::ImageVisual::LoadPolicy, IMMEDIATE) + DALI_ENUM_TO_STRING_WITH_SCOPE(Dali::Toolkit::ImageVisual::LoadPolicy, ATTACHED) +DALI_ENUM_TO_STRING_TABLE_END(LOAD_POLICY) + +// release policies +DALI_ENUM_TO_STRING_TABLE_BEGIN(RELEASE_POLICY) + DALI_ENUM_TO_STRING_WITH_SCOPE(Dali::Toolkit::ImageVisual::ReleasePolicy, DETACHED) + DALI_ENUM_TO_STRING_WITH_SCOPE(Dali::Toolkit::ImageVisual::ReleasePolicy, DESTROYED) + DALI_ENUM_TO_STRING_WITH_SCOPE(Dali::Toolkit::ImageVisual::ReleasePolicy, NEVER) +DALI_ENUM_TO_STRING_TABLE_END(RELEASE_POLICY) + +static constexpr uint32_t SINGLE_IMAGE_COUNT = 1u; +static constexpr uint32_t FIRST_FRAME_INDEX = 0u; +static constexpr uint16_t MINIMUM_CACHESIZE = 1; +static constexpr Vector4 FULL_TEXTURE_RECT(0.f, 0.f, 1.f, 1.f); +static constexpr auto LOOP_FOREVER = -1; +static constexpr auto FIRST_LOOP = 0u; #if defined(DEBUG_ENABLED) Debug::Filter* gAnimImgLogFilter = Debug::Filter::New(Debug::NoLogging, false, "LOG_ANIMATED_IMAGE"); #endif -} - +} // namespace /** * Multi-image Flow of execution * * | New * | DoSetProperties() - * | LoadFirstBatch() - * | new cache - * | cache->LoadBatch() + * | OnInitialize() + * | CreateImageCache() * | - * | DoSetOnStage() + * | DoSetOnScene() * | PrepareTextureSet() * | cache->FirstFrame() - * | CreateRenderer() (Doesn't become ready until first frame loads) - * | StartFirstFrame() * | * | FrameReady(textureSet) - * | start first frame: + * | StartFirstFrame: * | actor.AddRenderer * | start timer * | mRenderer.SetTextures(textureSet) @@ -99,8 +111,7 @@ Debug::Filter* gAnimImgLogFilter = Debug::Filter::New(Debug::NoLogging, false, " * | if front frame is ready, * | mRenderer.SetTextures( front frame's texture ) * | else - * | mWaitingForTexture=true - * | cache->LoadBatch() + * | Waiting for frame ready. * | * | FrameReady(textureSet) * | mRenderer.SetTextures(textureSet) @@ -108,161 +119,225 @@ Debug::Filter* gAnimImgLogFilter = Debug::Filter::New(Debug::NoLogging, false, " * Time */ -AnimatedImageVisualPtr AnimatedImageVisual::New( VisualFactoryCache& factoryCache, ImageVisualShaderFactory& shaderFactory, const VisualUrl& imageUrl, const Property::Map& properties ) +AnimatedImageVisualPtr AnimatedImageVisual::New(VisualFactoryCache& factoryCache, ImageVisualShaderFactory& shaderFactory, const VisualUrl& imageUrl, const Property::Map& properties) { - AnimatedImageVisualPtr visual( new AnimatedImageVisual( factoryCache, shaderFactory ) ); - visual->InitializeAnimatedImage( 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, ImageVisualShaderFactory& shaderFactory, const Property::Array& imageUrls, const Property::Map& properties ) +AnimatedImageVisualPtr AnimatedImageVisual::New(VisualFactoryCache& factoryCache, ImageVisualShaderFactory& shaderFactory, const Property::Array& imageUrls, const Property::Map& properties) { - AnimatedImageVisualPtr visual( new AnimatedImageVisual( factoryCache, shaderFactory ) ); + 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 ); + visual->SetProperties(properties); - if( visual->mFrameCount > 0 ) - { - visual->LoadFirstBatch(); - } + visual->Initialize(); return visual; } -AnimatedImageVisualPtr AnimatedImageVisual::New( VisualFactoryCache& factoryCache, ImageVisualShaderFactory& shaderFactory, const VisualUrl& imageUrl ) +AnimatedImageVisualPtr AnimatedImageVisual::New(VisualFactoryCache& factoryCache, ImageVisualShaderFactory& shaderFactory, const VisualUrl& imageUrl) { - AnimatedImageVisualPtr visual( new AnimatedImageVisual( factoryCache, shaderFactory ) ); - visual->InitializeAnimatedImage( imageUrl ); + AnimatedImageVisualPtr visual(new AnimatedImageVisual(factoryCache, shaderFactory)); + visual->InitializeAnimatedImage(imageUrl); - if( visual->mFrameCount > 0 ) - { - visual->LoadFirstBatch(); - } + visual->Initialize(); return visual; } -void AnimatedImageVisual::InitializeAnimatedImage( const VisualUrl& imageUrl ) +void AnimatedImageVisual::InitializeAnimatedImage(const VisualUrl& imageUrl) { mImageUrl = imageUrl; - mAnimatedImageLoading = AnimatedImageLoading::New( imageUrl.GetUrl(), imageUrl.IsLocalResource() ); - mFrameCount = mAnimatedImageLoading.GetImageCount(); + mAnimatedImageLoading = AnimatedImageLoading::New(imageUrl.GetUrl(), imageUrl.IsLocalResource()); } -AnimatedImageVisual::AnimatedImageVisual( VisualFactoryCache& factoryCache, ImageVisualShaderFactory& shaderFactory ) -: Visual::Base( factoryCache, Visual::FittingMode::FIT_KEEP_ASPECT_RATIO, Toolkit::Visual::ANIMATED_IMAGE ), +void AnimatedImageVisual::CreateImageCache() +{ + DALI_LOG_INFO(gAnimImgLogFilter, Debug::Concise, "AnimatedImageVisual::CreateImageCache() batchSize:%d cacheSize:%d\n", mBatchSize, mCacheSize); + + TextureManager& textureManager = mFactoryCache.GetTextureManager(); + + if(mAnimatedImageLoading) + { + mImageCache = new RollingAnimatedImageCache(textureManager, mAnimatedImageLoading, mMaskingData, *this, mCacheSize, mBatchSize, IsSynchronousLoadingRequired()); + } + else if(mImageUrls) + { + // 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::max(std::min(mBatchSize, numUrls), MINIMUM_CACHESIZE); + uint16_t cacheSize = std::max(std::min(std::max(batchSize, mCacheSize), numUrls), MINIMUM_CACHESIZE); + if(cacheSize < numUrls) + { + mImageCache = new RollingImageCache(textureManager, *mImageUrls, mMaskingData, *this, cacheSize, batchSize, mFrameDelay); + } + else + { + mImageCache = new FixedImageCache(textureManager, *mImageUrls, mMaskingData, *this, batchSize, mFrameDelay); + } + } + + if(!mImageCache) + { + DALI_LOG_ERROR("mImageCache is null\n"); + } +} + +AnimatedImageVisual::AnimatedImageVisual(VisualFactoryCache& factoryCache, ImageVisualShaderFactory& shaderFactory) +: Visual::Base(factoryCache, Visual::FittingMode::FILL, Toolkit::Visual::ANIMATED_IMAGE), mFrameDelayTimer(), mPlacementActor(), - mImageVisualShaderFactory( shaderFactory ), - mPixelArea( FULL_TEXTURE_RECT ), + mImageVisualShaderFactory(shaderFactory), + mPixelArea(FULL_TEXTURE_RECT), mImageUrl(), mAnimatedImageLoading(), - mCurrentFrameIndex( 0 ), - mImageUrls( NULL ), - mImageCache( NULL ), - mCacheSize( 2 ), - mBatchSize( 2 ), - mFrameDelay( 100 ), - mLoopCount( LOOP_FOREVER ), - mCurrentLoopIndex( 0 ), - mUrlIndex( 0 ), - mFrameCount( 0 ), + mFrameIndexForJumpTo(0), + mCurrentFrameIndex(FIRST_FRAME_INDEX), + mImageUrls(NULL), + mImageCache(NULL), + mCacheSize(2), + mBatchSize(2), + mFrameDelay(100), + mLoopCount(LOOP_FOREVER), + mCurrentLoopIndex(FIRST_LOOP), + mLoadPolicy(Toolkit::ImageVisual::LoadPolicy::ATTACHED), + mReleasePolicy(Toolkit::ImageVisual::ReleasePolicy::DETACHED), + mMaskingData(), + mFrameCount(0), mImageSize(), - mWrapModeU( WrapMode::DEFAULT ), - mWrapModeV( WrapMode::DEFAULT ), - mActionStatus( DevelAnimatedImageVisual::Action::PLAY ), - mStopBehavior( DevelImageVisual::StopBehavior::CURRENT_FRAME ), + mActionStatus(DevelAnimatedImageVisual::Action::PLAY), + mWrapModeU(WrapMode::DEFAULT), + mWrapModeV(WrapMode::DEFAULT), + mStopBehavior(DevelImageVisual::StopBehavior::CURRENT_FRAME), mStartFirstFrame(false), - mIsJumpTo( false ) -{} + mIsJumpTo(false) +{ +} AnimatedImageVisual::~AnimatedImageVisual() { + // AnimatedImageVisual destroyed so remove texture unless ReleasePolicy is set to never release + // If this is animated image, clear cache. Else if this is single frame image, this is affected be release policy. + if(mFrameCount > SINGLE_IMAGE_COUNT || mReleasePolicy != Toolkit::ImageVisual::ReleasePolicy::NEVER) + { + mImageCache->ClearCache(); + } delete mImageCache; 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(mMaskingData && mMaskingData->mAlphaMaskUrl.IsValid() && + mMaskingData->mCropToMask) + { + ImageDimensions dimensions = Dali::GetClosestImageSize(mMaskingData->mAlphaMaskUrl.GetUrl()); + if(dimensions != ImageDimensions(0, 0)) + { + mImageSize = dimensions; + naturalSize.x = dimensions.GetWidth(); + naturalSize.y = dimensions.GetHeight(); + return; + } + } + + if(mImageUrl.IsValid()) { 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(); bool sync = IsSynchronousLoadingRequired(); - map.Insert( Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING, sync ); + map.Insert(Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING, sync); - map.Insert( Toolkit::Visual::Property::TYPE, Toolkit::Visual::ANIMATED_IMAGE ); + map.Insert(Toolkit::Visual::Property::TYPE, Toolkit::Visual::ANIMATED_IMAGE); - if( mImageUrl.IsValid() ) + 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((mAnimatedImageLoading) ? mAnimatedImageLoading.GetImageCount() : + 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::LOOP_COUNT, static_cast(mLoopCount) ); + map.Insert(Toolkit::DevelImageVisual::Property::STOP_BEHAVIOR, mStopBehavior); - map.Insert( Toolkit::DevelImageVisual::Property::STOP_BEHAVIOR, mStopBehavior ); + if(mMaskingData != nullptr) + { + map.Insert(Toolkit::ImageVisual::Property::ALPHA_MASK_URL, mMaskingData->mAlphaMaskUrl.GetUrl()); + map.Insert(Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE, mMaskingData->mContentScaleFactor); + map.Insert(Toolkit::ImageVisual::Property::CROP_TO_MASK, mMaskingData->mCropToMask); + } + + map.Insert(Toolkit::ImageVisual::Property::LOAD_POLICY, mLoadPolicy); + map.Insert(Toolkit::ImageVisual::Property::RELEASE_POLICY, mReleasePolicy); } -void AnimatedImageVisual::DoCreateInstancePropertyMap( Property::Map& map ) const +void AnimatedImageVisual::DoCreateInstancePropertyMap(Property::Map& map) const { // Do nothing } -void AnimatedImageVisual::OnDoAction( const Dali::Property::Index actionId, const Dali::Property::Value& attributes ) +void AnimatedImageVisual::OnDoAction(const Dali::Property::Index actionId, const Dali::Property::Value& attributes) { - // Check if action is valid for this visual type and perform action if possible + // Make not set any action when the resource status is already failed. + if(mImpl->mResourceStatus == Toolkit::Visual::ResourceStatus::FAILED) + { + return; + } - switch ( actionId ) + // Check if action is valid for this visual type and perform action if possible + switch(actionId) { case DevelAnimatedImageVisual::Action::PAUSE: { @@ -272,7 +347,7 @@ void AnimatedImageVisual::OnDoAction( const Dali::Property::Index actionId, cons } case DevelAnimatedImageVisual::Action::PLAY: { - if( mFrameDelayTimer && IsOnStage() && mActionStatus != DevelAnimatedImageVisual::Action::PLAY ) + if(mFrameDelayTimer && IsOnScene() && mActionStatus != DevelAnimatedImageVisual::Action::PLAY) { mFrameDelayTimer.Start(); } @@ -284,7 +359,8 @@ void AnimatedImageVisual::OnDoAction( const Dali::Property::Index actionId, cons // STOP reset functionality will actually be done in a future change // Stop will be executed on next timer tick mActionStatus = DevelAnimatedImageVisual::Action::STOP; - if( IsOnStage() ) + mCurrentLoopIndex = FIRST_LOOP; + if(IsOnScene()) { DisplayNextFrame(); } @@ -293,17 +369,17 @@ void AnimatedImageVisual::OnDoAction( const Dali::Property::Index actionId, cons case DevelAnimatedImageVisual::Action::JUMP_TO: { int32_t frameNumber; - if( attributes.Get( frameNumber ) ) + if(attributes.Get(frameNumber)) { - if( frameNumber < 0 || frameNumber >= static_cast( mFrameCount ) ) + if(frameNumber < 0 || frameNumber >= static_cast(mFrameCount)) { - DALI_LOG_ERROR( "Invalid frame index used.\n" ); + DALI_LOG_ERROR("Invalid frame index used.\n"); } else { - mIsJumpTo = true; - mCurrentFrameIndex = frameNumber; - if( IsOnStage() ) + mIsJumpTo = true; + mFrameIndexForJumpTo = frameNumber; + if(IsOnScene()) { DisplayNextFrame(); } @@ -314,69 +390,97 @@ void AnimatedImageVisual::OnDoAction( const Dali::Property::Index actionId, cons } } -void AnimatedImageVisual::DoSetProperties( const Property::Map& propertyMap ) +void AnimatedImageVisual::DoSetProperties(const Property::Map& propertyMap) { // url[s] already passed in from constructor - - for( Property::Map::SizeType iter = 0; iter < propertyMap.Count(); ++iter ) + 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::WRAP_MODE_U, keyValue.second); + } + else if(keyValue.first == IMAGE_WRAP_MODE_V) + { + DoSetProperty(Toolkit::ImageVisual::Property::WRAP_MODE_V, keyValue.second); + } + else if(keyValue.first == BATCH_SIZE_NAME) { - DoSetProperty( Toolkit::ImageVisual::Property::PIXEL_AREA, keyValue.second ); + DoSetProperty(Toolkit::ImageVisual::Property::BATCH_SIZE, keyValue.second); } - else if( keyValue.first == IMAGE_WRAP_MODE_U ) + else if(keyValue.first == CACHE_SIZE_NAME) { - DoSetProperty( Toolkit::ImageVisual::Property::WRAP_MODE_U, keyValue.second ); + DoSetProperty(Toolkit::ImageVisual::Property::CACHE_SIZE, keyValue.second); } - else if( keyValue.first == IMAGE_WRAP_MODE_V ) + else if(keyValue.first == FRAME_DELAY_NAME) { - DoSetProperty( Toolkit::ImageVisual::Property::WRAP_MODE_V, keyValue.second ); + DoSetProperty(Toolkit::ImageVisual::Property::FRAME_DELAY, keyValue.second); } - else if( keyValue.first == BATCH_SIZE_NAME ) + else if(keyValue.first == LOOP_COUNT_NAME) { - DoSetProperty( Toolkit::ImageVisual::Property::BATCH_SIZE, keyValue.second ); + DoSetProperty(Toolkit::DevelImageVisual::Property::LOOP_COUNT, keyValue.second); } - else if( keyValue.first == CACHE_SIZE_NAME ) + else if(keyValue.first == STOP_BEHAVIOR_NAME) { - DoSetProperty( Toolkit::ImageVisual::Property::CACHE_SIZE, keyValue.second ); + DoSetProperty(Toolkit::DevelImageVisual::Property::STOP_BEHAVIOR, keyValue.second); } - else if( keyValue.first == FRAME_DELAY_NAME ) + else if(keyValue.first == ALPHA_MASK_URL) { - DoSetProperty( Toolkit::ImageVisual::Property::FRAME_DELAY, keyValue.second ); + DoSetProperty(Toolkit::ImageVisual::Property::ALPHA_MASK_URL, keyValue.second); } - else if( keyValue.first == LOOP_COUNT_NAME ) + else if(keyValue.first == MASK_CONTENT_SCALE_NAME) { - DoSetProperty( Toolkit::DevelImageVisual::Property::LOOP_COUNT, keyValue.second ); + DoSetProperty(Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE, keyValue.second); } - else if( keyValue.first == STOP_BEHAVIOR_NAME ) + else if(keyValue.first == CROP_TO_MASK_NAME) { - DoSetProperty( Toolkit::DevelImageVisual::Property::STOP_BEHAVIOR, keyValue.second ); + DoSetProperty(Toolkit::ImageVisual::Property::CROP_TO_MASK, keyValue.second); + } + else if(keyValue.first == LOAD_POLICY_NAME) + { + DoSetProperty(Toolkit::ImageVisual::Property::LOAD_POLICY, keyValue.second); + } + else if(keyValue.first == RELEASE_POLICY_NAME) + { + DoSetProperty(Toolkit::ImageVisual::Property::RELEASE_POLICY, keyValue.second); + } + else if(keyValue.first == SYNCHRONOUS_LOADING) + { + DoSetProperty(Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING, keyValue.second); } } } + // Load image immediately if LOAD_POLICY requires it + if(mLoadPolicy == Toolkit::ImageVisual::LoadPolicy::IMMEDIATE) + { + PrepareTextureSet(); + } } -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 = 0; - if(Scripting::GetEnumerationProperty( value, WRAP_MODE_TABLE, WRAP_MODE_TABLE_COUNT, wrapMode )) + if(Scripting::GetEnumerationProperty(value, WRAP_MODE_TABLE, WRAP_MODE_TABLE_COUNT, wrapMode)) { mWrapModeU = Dali::WrapMode::Type(wrapMode); } @@ -389,7 +493,7 @@ void AnimatedImageVisual::DoSetProperty( Property::Index index, case Toolkit::ImageVisual::Property::WRAP_MODE_V: { int wrapMode = 0; - if(Scripting::GetEnumerationProperty( value, WRAP_MODE_TABLE, WRAP_MODE_TABLE_COUNT, wrapMode )) + if(Scripting::GetEnumerationProperty(value, WRAP_MODE_TABLE, WRAP_MODE_TABLE_COUNT, wrapMode)) { mWrapModeV = Dali::WrapMode::Type(wrapMode); } @@ -403,11 +507,11 @@ void AnimatedImageVisual::DoSetProperty( Property::Index index, case Toolkit::ImageVisual::Property::BATCH_SIZE: { int batchSize; - if( value.Get( batchSize ) ) + if(value.Get(batchSize)) { - if( batchSize < 2 ) + if(batchSize < 2) { - DALI_LOG_ERROR( "The minimum value of batch size is 2." ); + DALI_LOG_ERROR("The minimum value of batch size is 2."); } else { @@ -420,11 +524,11 @@ void AnimatedImageVisual::DoSetProperty( Property::Index index, case Toolkit::ImageVisual::Property::CACHE_SIZE: { int cacheSize; - if( value.Get( cacheSize ) ) + if(value.Get(cacheSize)) { - if( cacheSize < 2 ) + if(cacheSize < 2) { - DALI_LOG_ERROR( "The minimum value of cache size is 2." ); + DALI_LOG_ERROR("The minimum value of cache size is 2."); } else { @@ -437,9 +541,13 @@ void AnimatedImageVisual::DoSetProperty( Property::Index index, case Toolkit::ImageVisual::Property::FRAME_DELAY: { int frameDelay; - if( value.Get( frameDelay ) ) + if(value.Get(frameDelay)) { mFrameDelay = frameDelay; + if(mImageCache) + { + mImageCache->SetInterval(static_cast(mFrameDelay)); + } } break; } @@ -447,7 +555,7 @@ void AnimatedImageVisual::DoSetProperty( Property::Index index, case Toolkit::DevelImageVisual::Property::LOOP_COUNT: { int loopCount; - if( value.Get( loopCount ) ) + if(value.Get(loopCount)) { mLoopCount = loopCount; } @@ -457,9 +565,9 @@ void AnimatedImageVisual::DoSetProperty( Property::Index index, case Toolkit::DevelImageVisual::Property::STOP_BEHAVIOR: { int32_t stopBehavior = mStopBehavior; - if( Scripting::GetEnumerationProperty( value, STOP_BEHAVIOR_TABLE, STOP_BEHAVIOR_TABLE_COUNT, stopBehavior ) ) + if(Scripting::GetEnumerationProperty(value, STOP_BEHAVIOR_TABLE, STOP_BEHAVIOR_TABLE_COUNT, stopBehavior)) { - mStopBehavior = DevelImageVisual::StopBehavior::Type( stopBehavior ); + mStopBehavior = DevelImageVisual::StopBehavior::Type(stopBehavior); } break; } @@ -467,8 +575,8 @@ void AnimatedImageVisual::DoSetProperty( Property::Index index, case Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING: { bool sync = false; - value.Get( sync ); - if( sync ) + value.Get(sync); + if(sync) { mImpl->mFlags |= Impl::IS_SYNCHRONOUS_RESOURCE_LOADING; } @@ -478,293 +586,344 @@ void AnimatedImageVisual::DoSetProperty( Property::Index index, } break; } + + case Toolkit::ImageVisual::Property::ALPHA_MASK_URL: + { + std::string alphaUrl = ""; + if(value.Get(alphaUrl)) + { + AllocateMaskData(); + mMaskingData->mAlphaMaskUrl = alphaUrl; + } + break; + } + + case Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE: + { + float scale = 1.0f; + if(value.Get(scale)) + { + AllocateMaskData(); + mMaskingData->mContentScaleFactor = scale; + } + break; + } + + case Toolkit::ImageVisual::Property::CROP_TO_MASK: + { + bool crop = false; + if(value.Get(crop)) + { + AllocateMaskData(); + mMaskingData->mCropToMask = crop; + } + break; + } + + case Toolkit::ImageVisual::Property::RELEASE_POLICY: + { + int releasePolicy = 0; + Scripting::GetEnumerationProperty(value, RELEASE_POLICY_TABLE, RELEASE_POLICY_TABLE_COUNT, releasePolicy); + mReleasePolicy = Toolkit::ImageVisual::ReleasePolicy::Type(releasePolicy); + break; + } + + case Toolkit::ImageVisual::Property::LOAD_POLICY: + { + int loadPolicy = 0; + Scripting::GetEnumerationProperty(value, LOAD_POLICY_TABLE, LOAD_POLICY_TABLE_COUNT, loadPolicy); + mLoadPolicy = Toolkit::ImageVisual::LoadPolicy::Type(loadPolicy); + break; + } } } -void AnimatedImageVisual::DoSetOnStage( Actor& actor ) +void AnimatedImageVisual::DoSetOnScene(Actor& actor) { - mPlacementActor = actor; - TextureSet textureSet = PrepareTextureSet(); - CreateRenderer(); // Always create a renderer when on stage - - if( textureSet ) // if the image loading is successful - { - StartFirstFrame( textureSet ); - } - else - { - mStartFirstFrame = true; - } + mStartFirstFrame = true; + mPlacementActor = actor; + PrepareTextureSet(); } -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(); } - actor.RemoveRenderer( mImpl->mRenderer ); - mImpl->mRenderer.Reset(); + actor.RemoveRenderer(mImpl->mRenderer); + if(mReleasePolicy == Toolkit::ImageVisual::ReleasePolicy::DETACHED) + { + mImageCache->ClearCache(); // If INVALID_TEXTURE_ID then removal will be attempted on atlas + mImpl->mResourceStatus = Toolkit::Visual::ResourceStatus::PREPARING; + + TextureSet textureSet = TextureSet::New(); + mImpl->mRenderer.SetTextures(textureSet); + } + mPlacementActor.Reset(); + mStartFirstFrame = false; + mCurrentFrameIndex = FIRST_FRAME_INDEX; + mCurrentLoopIndex = FIRST_LOOP; } void AnimatedImageVisual::OnSetTransform() { - if( mImpl->mRenderer ) + if(mImpl->mRenderer) { - mImpl->mTransform.RegisterUniforms( mImpl->mRenderer, Direction::LEFT_TO_RIGHT ); + mImpl->mTransform.SetUniforms(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 = false; - Shader shader = mImageVisualShaderFactory.GetShader( mFactoryCache, atlasing, defaultWrapMode, IsRoundedCornerRequired() ); - - Geometry geometry = mFactoryCache.GetGeometry( VisualFactoryCache::QUAD_GEOMETRY ); - - mImpl->mRenderer = Renderer::New( geometry, shader ); - - // Register transform properties - mImpl->mTransform.RegisterUniforms( mImpl->mRenderer, Direction::LEFT_TO_RIGHT ); - - 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 ); - } - - if( mPixelArea != FULL_TEXTURE_RECT ) + if(mImpl->mRenderer) { - mImpl->mRenderer.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, mPixelArea ); + Shader shader = GenerateShader(); + mImpl->mRenderer.SetShader(shader); } +} - mCurrentFrameIndex = 0; +Shader AnimatedImageVisual::GenerateShader() const +{ + bool defaultWrapMode = mWrapModeU <= WrapMode::CLAMP_TO_EDGE && mWrapModeV <= WrapMode::CLAMP_TO_EDGE; + Shader shader; + shader = mImageVisualShaderFactory.GetShader( + mFactoryCache, + ImageVisualShaderFeature::FeatureBuilder() + .ApplyDefaultTextureWrapMode(defaultWrapMode) + .EnableRoundedCorner(IsRoundedCornerRequired()) + .EnableBorderline(IsBorderlineRequired())); + return shader; } -void AnimatedImageVisual::LoadFirstBatch() +void AnimatedImageVisual::OnInitialize() { - // 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 = 0; - uint16_t batchSize = 1; - uint16_t cacheSize = 1; + CreateImageCache(); - if( mImageUrls ) - { - numUrls = mImageUrls->size(); - } - else - { - numUrls = mFrameCount; - } + bool defaultWrapMode = mWrapModeU <= WrapMode::CLAMP_TO_EDGE && mWrapModeV <= WrapMode::CLAMP_TO_EDGE; + Shader shader = GenerateShader(); - batchSize = std::min( mBatchSize, numUrls ); - cacheSize = std::min( std::max( batchSize, mCacheSize ), numUrls ); + Geometry geometry = mFactoryCache.GetGeometry(VisualFactoryCache::QUAD_GEOMETRY); - DALI_LOG_INFO(gAnimImgLogFilter,Debug::Concise,"AnimatedImageVisual::LoadFirstBatch() batchSize:%d cacheSize:%d\n", batchSize, cacheSize); + mImpl->mRenderer = VisualRenderer::New(geometry, shader); + mImpl->mRenderer.ReserveCustomProperties(CUSTOM_PROPERTY_COUNT); - mUrlIndex = 0; - TextureManager& textureManager = mFactoryCache.GetTextureManager(); + // Register transform properties + mImpl->mTransform.SetUniforms(mImpl->mRenderer, Direction::LEFT_TO_RIGHT); - if( mAnimatedImageLoading ) + if(!defaultWrapMode) // custom wrap mode { - mImageCache = new RollingAnimatedImageCache( textureManager, mAnimatedImageLoading, mFrameCount, *this, cacheSize, batchSize, IsSynchronousLoadingRequired() ); - } - else if( mImageUrls ) - { - if( batchSize > 0 && cacheSize > 0 ) - { - if( cacheSize < numUrls ) - { - mImageCache = new RollingImageCache( textureManager, *mImageUrls, *this, cacheSize, batchSize ); - } - else - { - mImageCache = new FixedImageCache( textureManager, *mImageUrls, *this, batchSize ); - } - } - else - { - mImageCache = new RollingImageCache( textureManager, *mImageUrls, *this, 1, 1 ); - } + 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); } - if (!mImageCache) + if(mPixelArea != FULL_TEXTURE_RECT) { - DALI_LOG_ERROR("mImageCache is null\n"); + mImpl->mRenderer.RegisterProperty(PIXEL_AREA_UNIFORM_NAME, mPixelArea); } } -void AnimatedImageVisual::StartFirstFrame( TextureSet& textureSet ) +void AnimatedImageVisual::StartFirstFrame(TextureSet& textureSet, uint32_t firstInterval) { - DALI_LOG_INFO(gAnimImgLogFilter,Debug::Concise,"AnimatedImageVisual::StartFirstFrame()\n"); + DALI_LOG_INFO(gAnimImgLogFilter, Debug::Concise, "AnimatedImageVisual::StartFirstFrame()\n"); mStartFirstFrame = false; if(mImpl->mRenderer) { - mImpl->mRenderer.SetTextures( textureSet ); - } - Actor actor = mPlacementActor.GetHandle(); - if( actor ) - { - actor.AddRenderer( mImpl->mRenderer ); - mPlacementActor.Reset(); - } + mImpl->mRenderer.SetTextures(textureSet); - mCurrentFrameIndex = 0; + Actor actor = mPlacementActor.GetHandle(); + if(actor) + { + actor.AddRenderer(mImpl->mRenderer); + mPlacementActor.Reset(); + } + } - if( mFrameCount > 1 ) + if(mImpl->mResourceStatus != Toolkit::Visual::ResourceStatus::FAILED) { - int frameDelay = mFrameDelay; // from URL array - if( mAnimatedImageLoading && mImageCache ) + if(mFrameCount > SINGLE_IMAGE_COUNT) { - frameDelay = mImageCache->GetFrameInterval( 0 ); + mFrameDelayTimer = Timer::New(firstInterval); + 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(ResourceStatus::READY)\n"); + ResourceReady(Toolkit::Visual::ResourceStatus::READY); } - DALI_LOG_INFO(gAnimImgLogFilter,Debug::Concise,"ResourceReady(ResourceStatus::READY)\n"); - ResourceReady( Toolkit::Visual::ResourceStatus::READY ); + + mCurrentFrameIndex = FIRST_FRAME_INDEX; } -TextureSet AnimatedImageVisual::PrepareTextureSet() +void AnimatedImageVisual::PrepareTextureSet() { TextureSet textureSet; - if (mImageCache) + if(mImageCache) { textureSet = mImageCache->FirstFrame(); } - if( textureSet ) - { - SetImageSize( textureSet ); - } - else + + // Check whether synchronous loading is true or false for the first frame. + if(textureSet) { - DALI_LOG_INFO( gAnimImgLogFilter, Debug::Concise, "ResourceReady(ResourceStatus::FAILED)\n" ); - ResourceReady( Toolkit::Visual::ResourceStatus::FAILED ); + 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, uint32_t interval) { - SetImageSize( textureSet ); + // When image visual requested to load new frame to mImageCache and it is failed. + if(!mImageCache || !textureSet) + { + textureSet = SetLoadingFailed(); + } + SetImageSize(textureSet); - if( mStartFirstFrame ) + if(mStartFirstFrame) { - StartFirstFrame( textureSet ); + mFrameCount = mImageCache->GetTotalFrameCount(); + StartFirstFrame(textureSet, interval); } else { - if( mImpl->mRenderer ) + if(mImpl->mRenderer) { - mImpl->mRenderer.SetTextures( textureSet ); + if(mFrameDelayTimer && interval > 0u) + { + mFrameDelayTimer.SetInterval(interval); + } + mImpl->mRenderer.SetTextures(textureSet); } } } bool AnimatedImageVisual::DisplayNextFrame() { - if( mIsJumpTo ) - { - mIsJumpTo = false; - } - else if( mActionStatus == DevelAnimatedImageVisual::Action::PAUSE ) - { - return false; - } - else if( mActionStatus == DevelAnimatedImageVisual::Action::STOP ) + TextureSet textureSet; + bool continueTimer = false; + + if(mImageCache) { - mCurrentLoopIndex = 0; - if( mStopBehavior == DevelImageVisual::StopBehavior::FIRST_FRAME ) - { - mCurrentFrameIndex = 0; - } - else if( mStopBehavior == DevelImageVisual::StopBehavior::LAST_FRAME ) + uint32_t frameIndex = mImageCache->GetCurrentFrameIndex(); + + if(mIsJumpTo) { - mCurrentFrameIndex = mFrameCount - 1; + mIsJumpTo = false; + frameIndex = mFrameIndexForJumpTo; } - else + else if(mActionStatus == DevelAnimatedImageVisual::Action::PAUSE) { - return false; // Do not draw already rendered scene twice. + return false; } - } - else - { - if( mFrameCount > 1 ) + else if(mActionStatus == DevelAnimatedImageVisual::Action::STOP) { - // Wrap the frame index - bool finished = false; - ++mCurrentFrameIndex; - if( mCurrentFrameIndex >= mFrameCount ) + mCurrentLoopIndex = FIRST_LOOP; + if(mStopBehavior == DevelImageVisual::StopBehavior::FIRST_FRAME) { - ++mCurrentLoopIndex; - finished = true; + frameIndex = FIRST_FRAME_INDEX; } - - if( mLoopCount < 0 || mCurrentLoopIndex < mLoopCount) + else if(mStopBehavior == DevelImageVisual::StopBehavior::LAST_FRAME) { - if( finished ) - { - mCurrentFrameIndex = 0; // Back to the first frame - } + frameIndex = mFrameCount - 1; } else { - // This will stop timer - mActionStatus = DevelAnimatedImageVisual::Action::STOP; - return DisplayNextFrame(); + return false; // Do not draw already rendered scene twice. } } - // TODO : newly added one. - if( mAnimatedImageLoading && mImageCache ) + else { - unsigned int delay = mImageCache->GetFrameInterval( mCurrentFrameIndex ); - if( mFrameDelayTimer.GetInterval() != delay ) + if(mFrameCount > SINGLE_IMAGE_COUNT) { - mFrameDelayTimer.SetInterval( delay ); + frameIndex++; + if(frameIndex >= mFrameCount) + { + frameIndex = FIRST_FRAME_INDEX; + ++mCurrentLoopIndex; + } + + if(mLoopCount >= 0 && mCurrentLoopIndex >= mLoopCount) + { + // This will stop timer + mActionStatus = DevelAnimatedImageVisual::Action::STOP; + return 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( textureSet ) + textureSet = mImageCache->Frame(frameIndex); + + if(textureSet) { - SetImageSize( textureSet ); - mImpl->mRenderer.SetTextures( textureSet ); + SetImageSize(textureSet); + if(mImpl->mRenderer) + { + mImpl->mRenderer.SetTextures(textureSet); + } + mFrameDelayTimer.SetInterval(mImageCache->GetFrameInterval(frameIndex)); } + + mCurrentFrameIndex = frameIndex; + continueTimer = (mActionStatus == DevelAnimatedImageVisual::Action::PLAY && textureSet) ? true : false; } - return ( mActionStatus == DevelAnimatedImageVisual::Action::PLAY ) ? true : false; + 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; +} + +void AnimatedImageVisual::AllocateMaskData() +{ + if(!mMaskingData) + { + mMaskingData.reset(new TextureManager::MaskingData()); + } +} } // namespace Internal