dali-toolkit/internal/visuals/animated-image/animated-image-visual.cpp

   1 /*
   2  * Copyright (c) 2023 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 // CLASS HEADER
  19 #include <dali-toolkit/internal/visuals/animated-image/animated-image-visual.h>
  20
  21 // EXTERNAL INCLUDES
  22 #include <dali/devel-api/adaptor-framework/image-loading.h>
  23 #include <dali/integration-api/debug.h>
  24 #include <dali/public-api/rendering/decorated-visual-renderer.h>
  25 #include <memory>
  26
  27 // INTERNAL INCLUDES
  28 #include <dali-toolkit/devel-api/image-loader/image-atlas.h>
  29 #include <dali-toolkit/devel-api/image-loader/texture-manager.h>
  30 #include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
  31 #include <dali-toolkit/internal/visuals/animated-image/fixed-image-cache.h>
  32 #include <dali-toolkit/internal/visuals/animated-image/rolling-animated-image-cache.h>
  33 #include <dali-toolkit/internal/visuals/animated-image/rolling-image-cache.h>
  34 #include <dali-toolkit/internal/visuals/image-visual-shader-factory.h>
  35 #include <dali-toolkit/internal/visuals/image-visual-shader-feature-builder.h>
  36 #include <dali-toolkit/internal/visuals/visual-base-data-impl.h>
  37 #include <dali-toolkit/internal/visuals/visual-factory-cache.h>
  38 #include <dali-toolkit/internal/visuals/visual-factory-impl.h>
  39 #include <dali-toolkit/internal/visuals/visual-string-constants.h>
  40 #include <dali-toolkit/public-api/visuals/image-visual-properties.h>
  41 #include <dali-toolkit/public-api/visuals/visual-properties.h>
  42
  43 namespace Dali
  44 {
  45 namespace Toolkit
  46 {
  47 namespace Internal
  48 {
  49 namespace
  50 {
  51 const int CUSTOM_PROPERTY_COUNT(5); // ltr, wrap, pixel area, crop to mask, mask texture ratio
  52
  53 // fitting modes
  54 DALI_ENUM_TO_STRING_TABLE_BEGIN(FITTING_MODE)
  55   DALI_ENUM_TO_STRING_WITH_SCOPE(Dali::FittingMode, SHRINK_TO_FIT)
  56   DALI_ENUM_TO_STRING_WITH_SCOPE(Dali::FittingMode, SCALE_TO_FILL)
  57   DALI_ENUM_TO_STRING_WITH_SCOPE(Dali::FittingMode, FIT_WIDTH)
  58   DALI_ENUM_TO_STRING_WITH_SCOPE(Dali::FittingMode, FIT_HEIGHT)
  59   DALI_ENUM_TO_STRING_WITH_SCOPE(Dali::FittingMode, DEFAULT)
  60 DALI_ENUM_TO_STRING_TABLE_END(FITTING_MODE)
  61
  62 // sampling modes
  63 DALI_ENUM_TO_STRING_TABLE_BEGIN(SAMPLING_MODE)
  64   DALI_ENUM_TO_STRING_WITH_SCOPE(Dali::SamplingMode, BOX)
  65   DALI_ENUM_TO_STRING_WITH_SCOPE(Dali::SamplingMode, NEAREST)
  66   DALI_ENUM_TO_STRING_WITH_SCOPE(Dali::SamplingMode, LINEAR)
  67   DALI_ENUM_TO_STRING_WITH_SCOPE(Dali::SamplingMode, BOX_THEN_NEAREST)
  68   DALI_ENUM_TO_STRING_WITH_SCOPE(Dali::SamplingMode, BOX_THEN_LINEAR)
  69   DALI_ENUM_TO_STRING_WITH_SCOPE(Dali::SamplingMode, NO_FILTER)
  70   DALI_ENUM_TO_STRING_WITH_SCOPE(Dali::SamplingMode, DONT_CARE)
  71 DALI_ENUM_TO_STRING_TABLE_END(SAMPLING_MODE)
  72
  73 // stop behavior
  74 DALI_ENUM_TO_STRING_TABLE_BEGIN(STOP_BEHAVIOR)
  75   DALI_ENUM_TO_STRING_WITH_SCOPE(Dali::Toolkit::DevelImageVisual::StopBehavior, CURRENT_FRAME)
  76   DALI_ENUM_TO_STRING_WITH_SCOPE(Dali::Toolkit::DevelImageVisual::StopBehavior, FIRST_FRAME)
  77   DALI_ENUM_TO_STRING_WITH_SCOPE(Dali::Toolkit::DevelImageVisual::StopBehavior, LAST_FRAME)
  78 DALI_ENUM_TO_STRING_TABLE_END(STOP_BEHAVIOR)
  79
  80 // wrap modes
  81 DALI_ENUM_TO_STRING_TABLE_BEGIN(WRAP_MODE)
  82   DALI_ENUM_TO_STRING_WITH_SCOPE(Dali::WrapMode, DEFAULT)
  83   DALI_ENUM_TO_STRING_WITH_SCOPE(Dali::WrapMode, CLAMP_TO_EDGE)
  84   DALI_ENUM_TO_STRING_WITH_SCOPE(Dali::WrapMode, REPEAT)
  85   DALI_ENUM_TO_STRING_WITH_SCOPE(Dali::WrapMode, MIRRORED_REPEAT)
  86 DALI_ENUM_TO_STRING_TABLE_END(WRAP_MODE)
  87
  88 // load policies
  89 DALI_ENUM_TO_STRING_TABLE_BEGIN(LOAD_POLICY)
  90   DALI_ENUM_TO_STRING_WITH_SCOPE(Dali::Toolkit::ImageVisual::LoadPolicy, IMMEDIATE)
  91   DALI_ENUM_TO_STRING_WITH_SCOPE(Dali::Toolkit::ImageVisual::LoadPolicy, ATTACHED)
  92 DALI_ENUM_TO_STRING_TABLE_END(LOAD_POLICY)
  93
  94 // release policies
  95 DALI_ENUM_TO_STRING_TABLE_BEGIN(RELEASE_POLICY)
  96   DALI_ENUM_TO_STRING_WITH_SCOPE(Dali::Toolkit::ImageVisual::ReleasePolicy, DETACHED)
  97   DALI_ENUM_TO_STRING_WITH_SCOPE(Dali::Toolkit::ImageVisual::ReleasePolicy, DESTROYED)
  98   DALI_ENUM_TO_STRING_WITH_SCOPE(Dali::Toolkit::ImageVisual::ReleasePolicy, NEVER)
  99 DALI_ENUM_TO_STRING_TABLE_END(RELEASE_POLICY)
 100
 101 static constexpr uint32_t SINGLE_IMAGE_COUNT = 1u;
 102 static constexpr uint32_t FIRST_FRAME_INDEX  = 0u;
 103 static constexpr uint16_t MINIMUM_CACHESIZE  = 1;
 104 static constexpr Vector4  FULL_TEXTURE_RECT(0.f, 0.f, 1.f, 1.f);
 105 static constexpr auto     LOOP_FOREVER = -1;
 106 static constexpr auto     FIRST_LOOP   = 0u;
 107
 108 constexpr uint32_t TEXTURE_COUNT_FOR_GPU_ALPHA_MASK = 2u;
 109
 110 #if defined(DEBUG_ENABLED)
 111 Debug::Filter* gAnimImgLogFilter = Debug::Filter::New(Debug::NoLogging, false, "LOG_ANIMATED_IMAGE");
 112 #endif
 113 } // namespace
 114
 115 /**
 116  * Multi-image  Flow of execution
 117  *
 118  *   | New
 119  *   |   DoSetProperties()
 120  *   |   OnInitialize()
 121  *   |     CreateImageCache()
 122  *   |
 123  *   | DoSetOnScene()
 124  *   |   PrepareTextureSet()
 125  *   |     cache->FirstFrame()
 126  *   |
 127  *   | FrameReady(textureSet)
 128  *   |   StartFirstFrame:
 129  *   |     actor.AddRenderer
 130  *   |     start timer
 131  *   |   mRenderer.SetTextures(textureSet)
 132  *   |
 133  *   | Timer ticks
 134  *   |   DisplayNextFrame()
 135  *   |     if front frame is ready,
 136  *   |       mRenderer.SetTextures( front frame's texture )
 137  *   |     else
 138  *   |       Waiting for frame ready.
 139  *   |
 140  *   | FrameReady(textureSet)
 141  *   |   mRenderer.SetTextures(textureSet)
 142  *   V
 143  *  Time
 144  */
 145
 146 AnimatedImageVisualPtr AnimatedImageVisual::New(VisualFactoryCache& factoryCache, ImageVisualShaderFactory& shaderFactory, const VisualUrl& imageUrl, const Property::Map& properties)
 147 {
 148   AnimatedImageVisualPtr visual(new AnimatedImageVisual(factoryCache, shaderFactory, ImageDimensions()));
 149   visual->InitializeAnimatedImage(imageUrl);
 150   visual->SetProperties(properties);
 151
 152   visual->Initialize();
 153
 154   return visual;
 155 }
 156
 157 AnimatedImageVisualPtr AnimatedImageVisual::New(VisualFactoryCache& factoryCache, ImageVisualShaderFactory& shaderFactory, const Property::Array& imageUrls, const Property::Map& properties)
 158 {
 159   AnimatedImageVisualPtr visual(new AnimatedImageVisual(factoryCache, shaderFactory, ImageDimensions()));
 160   visual->mImageUrls = new ImageCache::UrlList();
 161   visual->mImageUrls->reserve(imageUrls.Count());
 162
 163   for(unsigned int i = 0; i < imageUrls.Count(); ++i)
 164   {
 165     ImageCache::UrlStore urlStore;
 166     urlStore.mTextureId = TextureManager::INVALID_TEXTURE_ID;
 167     urlStore.mUrl       = imageUrls[i].Get<std::string>();
 168     visual->mImageUrls->push_back(urlStore);
 169   }
 170   visual->mFrameCount = imageUrls.Count();
 171   visual->SetProperties(properties);
 172
 173   visual->Initialize();
 174
 175   return visual;
 176 }
 177
 178 AnimatedImageVisualPtr AnimatedImageVisual::New(VisualFactoryCache& factoryCache, ImageVisualShaderFactory& shaderFactory, const VisualUrl& imageUrl, ImageDimensions size)
 179 {
 180   AnimatedImageVisualPtr visual(new AnimatedImageVisual(factoryCache, shaderFactory, size));
 181   visual->InitializeAnimatedImage(imageUrl);
 182
 183   visual->Initialize();
 184
 185   return visual;
 186 }
 187
 188 void AnimatedImageVisual::InitializeAnimatedImage(const VisualUrl& imageUrl)
 189 {
 190   mImageUrl             = imageUrl;
 191   mAnimatedImageLoading = AnimatedImageLoading::New(imageUrl.GetUrl(), imageUrl.IsLocalResource());
 192 }
 193
 194 void AnimatedImageVisual::CreateImageCache()
 195 {
 196   DALI_LOG_INFO(gAnimImgLogFilter, Debug::Concise, "AnimatedImageVisual::CreateImageCache()  batchSize:%d  cacheSize:%d\n", mBatchSize, mCacheSize);
 197
 198   TextureManager& textureManager = mFactoryCache.GetTextureManager();
 199
 200   if(mAnimatedImageLoading)
 201   {
 202     mImageCache = new RollingAnimatedImageCache(textureManager, mDesiredSize, mFittingMode, mSamplingMode, mAnimatedImageLoading, mMaskingData, *this, mCacheSize, mBatchSize, mWrapModeU, mWrapModeV, IsSynchronousLoadingRequired(), IsPreMultipliedAlphaEnabled());
 203   }
 204   else if(mImageUrls)
 205   {
 206     // Ensure the batch size and cache size are no bigger than the number of URLs,
 207     // and that the cache is at least as big as the batch size.
 208     uint16_t numUrls   = mImageUrls->size();
 209     uint16_t batchSize = std::max(std::min(mBatchSize, numUrls), MINIMUM_CACHESIZE);
 210     uint16_t cacheSize = std::max(std::min(std::max(batchSize, mCacheSize), numUrls), MINIMUM_CACHESIZE);
 211     if(cacheSize < numUrls)
 212     {
 213       mImageCache = new RollingImageCache(textureManager, mDesiredSize, mFittingMode, mSamplingMode, *mImageUrls, mMaskingData, *this, cacheSize, batchSize, mFrameDelay, IsPreMultipliedAlphaEnabled());
 214     }
 215     else
 216     {
 217       mImageCache = new FixedImageCache(textureManager, mDesiredSize, mFittingMode, mSamplingMode, *mImageUrls, mMaskingData, *this, batchSize, mFrameDelay, IsPreMultipliedAlphaEnabled());
 218     }
 219   }
 220
 221   if(!mImageCache)
 222   {
 223     DALI_LOG_ERROR("mImageCache is null\n");
 224   }
 225 }
 226
 227 AnimatedImageVisual::AnimatedImageVisual(VisualFactoryCache& factoryCache, ImageVisualShaderFactory& shaderFactory, ImageDimensions desiredSize)
 228 : Visual::Base(factoryCache, Visual::FittingMode::FILL, Toolkit::Visual::ANIMATED_IMAGE),
 229   mFrameDelayTimer(),
 230   mPlacementActor(),
 231   mImageVisualShaderFactory(shaderFactory),
 232   mPixelArea(FULL_TEXTURE_RECT),
 233   mImageUrl(),
 234   mAnimatedImageLoading(),
 235   mFrameIndexForJumpTo(0),
 236   mCurrentFrameIndex(FIRST_FRAME_INDEX),
 237   mImageUrls(NULL),
 238   mImageCache(NULL),
 239   mCacheSize(2),
 240   mBatchSize(2),
 241   mFrameDelay(100),
 242   mLoopCount(LOOP_FOREVER),
 243   mCurrentLoopIndex(FIRST_LOOP),
 244   mLoadPolicy(Toolkit::ImageVisual::LoadPolicy::ATTACHED),
 245   mReleasePolicy(Toolkit::ImageVisual::ReleasePolicy::DETACHED),
 246   mMaskingData(),
 247   mDesiredSize(desiredSize),
 248   mFrameCount(0),
 249   mImageSize(),
 250   mActionStatus(DevelAnimatedImageVisual::Action::PLAY),
 251   mWrapModeU(WrapMode::DEFAULT),
 252   mWrapModeV(WrapMode::DEFAULT),
 253   mFittingMode(FittingMode::SCALE_TO_FILL),
 254   mSamplingMode(SamplingMode::BOX_THEN_LINEAR),
 255   mStopBehavior(DevelImageVisual::StopBehavior::CURRENT_FRAME),
 256   mStartFirstFrame(false),
 257   mIsJumpTo(false)
 258 {
 259   EnablePreMultipliedAlpha(mFactoryCache.GetPreMultiplyOnLoad());
 260 }
 261
 262 AnimatedImageVisual::~AnimatedImageVisual()
 263 {
 264   // AnimatedImageVisual destroyed so remove texture unless ReleasePolicy is set to never release
 265   // If this is animated image, clear cache. Else if this is single frame image, this is affected be release policy.
 266   if(mFrameCount > SINGLE_IMAGE_COUNT || mReleasePolicy != Toolkit::ImageVisual::ReleasePolicy::NEVER)
 267   {
 268     mImageCache->ClearCache();
 269   }
 270   delete mImageCache;
 271   delete mImageUrls;
 272 }
 273
 274 void AnimatedImageVisual::GetNaturalSize(Vector2& naturalSize)
 275 {
 276   if(mDesiredSize.GetWidth() > 0 && mDesiredSize.GetHeight() > 0)
 277   {
 278     naturalSize.x = mDesiredSize.GetWidth();
 279     naturalSize.y = mDesiredSize.GetHeight();
 280     return;
 281   }
 282
 283   naturalSize = Vector2::ZERO;
 284   if(mImageSize.GetWidth() == 0 && mImageSize.GetHeight() == 0)
 285   {
 286     if(mMaskingData && mMaskingData->mAlphaMaskUrl.IsValid() &&
 287        mMaskingData->mCropToMask)
 288     {
 289       ImageDimensions dimensions = Dali::GetClosestImageSize(mMaskingData->mAlphaMaskUrl.GetUrl());
 290       if(dimensions != ImageDimensions(0, 0))
 291       {
 292         mImageSize    = dimensions;
 293         naturalSize.x = dimensions.GetWidth();
 294         naturalSize.y = dimensions.GetHeight();
 295         return;
 296       }
 297     }
 298
 299     if(mImageUrl.IsValid())
 300     {
 301       mImageSize = mAnimatedImageLoading.GetImageSize();
 302     }
 303     else if(mImageUrls && mImageUrls->size() > 0)
 304     {
 305       mImageSize = Dali::GetClosestImageSize((*mImageUrls)[0].mUrl.GetUrl());
 306     }
 307   }
 308
 309   naturalSize.width  = mImageSize.GetWidth();
 310   naturalSize.height = mImageSize.GetHeight();
 311 }
 312
 313 void AnimatedImageVisual::DoCreatePropertyMap(Property::Map& map) const
 314 {
 315   map.Clear();
 316
 317   bool sync = IsSynchronousLoadingRequired();
 318   map.Insert(Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING, sync);
 319
 320   map.Insert(Toolkit::Visual::Property::TYPE, Toolkit::Visual::ANIMATED_IMAGE);
 321
 322   if(mImageUrl.IsValid())
 323   {
 324     map.Insert(Toolkit::ImageVisual::Property::URL, mImageUrl.GetUrl());
 325   }
 326   if(mImageUrls != NULL && !mImageUrls->empty())
 327   {
 328     Property::Array urls;
 329     for(unsigned int i = 0; i < mImageUrls->size(); ++i)
 330     {
 331       urls.Add((*mImageUrls)[i].mUrl.GetUrl());
 332     }
 333     Property::Value value(const_cast<Property::Array&>(urls));
 334     map.Insert(Toolkit::ImageVisual::Property::URL, value);
 335   }
 336
 337   map.Insert(Toolkit::ImageVisual::Property::PIXEL_AREA, mPixelArea);
 338   map.Insert(Toolkit::ImageVisual::Property::WRAP_MODE_U, mWrapModeU);
 339   map.Insert(Toolkit::ImageVisual::Property::WRAP_MODE_V, mWrapModeV);
 340
 341   map.Insert(Toolkit::ImageVisual::Property::BATCH_SIZE, static_cast<int>(mBatchSize));
 342   map.Insert(Toolkit::ImageVisual::Property::CACHE_SIZE, static_cast<int>(mCacheSize));
 343   map.Insert(Toolkit::ImageVisual::Property::FRAME_DELAY, static_cast<int>(mFrameDelay));
 344   map.Insert(Toolkit::DevelImageVisual::Property::LOOP_COUNT, static_cast<int>(mLoopCount));
 345   map.Insert(Toolkit::DevelImageVisual::Property::CURRENT_FRAME_NUMBER, (mImageCache) ? static_cast<int32_t>(mImageCache->GetCurrentFrameIndex()) : -1);
 346   map.Insert(Toolkit::DevelImageVisual::Property::TOTAL_FRAME_NUMBER, (mImageCache) ? static_cast<int32_t>((mAnimatedImageLoading) ? mAnimatedImageLoading.GetImageCount() : mImageCache->GetTotalFrameCount()) : -1);
 347
 348   map.Insert(Toolkit::DevelImageVisual::Property::STOP_BEHAVIOR, mStopBehavior);
 349
 350   if(mMaskingData != nullptr)
 351   {
 352     map.Insert(Toolkit::ImageVisual::Property::ALPHA_MASK_URL, mMaskingData->mAlphaMaskUrl.GetUrl());
 353     map.Insert(Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE, mMaskingData->mContentScaleFactor);
 354     map.Insert(Toolkit::ImageVisual::Property::CROP_TO_MASK, mMaskingData->mCropToMask);
 355     map.Insert(Toolkit::DevelImageVisual::Property::MASKING_TYPE, mMaskingData->mPreappliedMasking ? DevelImageVisual::MaskingType::MASKING_ON_LOADING : DevelImageVisual::MaskingType::MASKING_ON_RENDERING);
 356   }
 357
 358   map.Insert(Toolkit::ImageVisual::Property::LOAD_POLICY, mLoadPolicy);
 359   map.Insert(Toolkit::ImageVisual::Property::RELEASE_POLICY, mReleasePolicy);
 360   map.Insert(Toolkit::ImageVisual::Property::FITTING_MODE, mFittingMode);
 361   map.Insert(Toolkit::ImageVisual::Property::SAMPLING_MODE, mSamplingMode);
 362   map.Insert(Toolkit::ImageVisual::Property::DESIRED_WIDTH, mDesiredSize.GetWidth());
 363   map.Insert(Toolkit::ImageVisual::Property::DESIRED_HEIGHT, mDesiredSize.GetHeight());
 364 }
 365
 366 void AnimatedImageVisual::DoCreateInstancePropertyMap(Property::Map& map) const
 367 {
 368   map.Clear();
 369   map.Insert(Toolkit::Visual::Property::TYPE, Toolkit::Visual::ANIMATED_IMAGE);
 370   if(mImageUrl.IsValid())
 371   {
 372     map.Insert(Toolkit::ImageVisual::Property::DESIRED_WIDTH, mDesiredSize.GetWidth());
 373     map.Insert(Toolkit::ImageVisual::Property::DESIRED_HEIGHT, mDesiredSize.GetHeight());
 374   }
 375 }
 376
 377 void AnimatedImageVisual::OnDoAction(const Dali::Property::Index actionId, const Dali::Property::Value& attributes)
 378 {
 379   // Make not set any action when the resource status is already failed.
 380   if(mImpl->mResourceStatus == Toolkit::Visual::ResourceStatus::FAILED)
 381   {
 382     return;
 383   }
 384
 385   // Check if action is valid for this visual type and perform action if possible
 386   switch(actionId)
 387   {
 388     case DevelAnimatedImageVisual::Action::PAUSE:
 389     {
 390       // Pause will be executed on next timer tick
 391       mActionStatus = DevelAnimatedImageVisual::Action::PAUSE;
 392       break;
 393     }
 394     case DevelAnimatedImageVisual::Action::PLAY:
 395     {
 396       if(mFrameDelayTimer && IsOnScene() && mActionStatus != DevelAnimatedImageVisual::Action::PLAY)
 397       {
 398         mFrameDelayTimer.Start();
 399       }
 400       mActionStatus = DevelAnimatedImageVisual::Action::PLAY;
 401       break;
 402     }
 403     case DevelAnimatedImageVisual::Action::STOP:
 404     {
 405       // STOP reset functionality will actually be done in a future change
 406       // Stop will be executed on next timer tick
 407       mActionStatus     = DevelAnimatedImageVisual::Action::STOP;
 408       mCurrentLoopIndex = FIRST_LOOP;
 409       if(IsOnScene())
 410       {
 411         DisplayNextFrame();
 412       }
 413       break;
 414     }
 415     case DevelAnimatedImageVisual::Action::JUMP_TO:
 416     {
 417       int32_t frameNumber;
 418       if(attributes.Get(frameNumber))
 419       {
 420         if(frameNumber < 0 || frameNumber >= static_cast<int32_t>(mFrameCount))
 421         {
 422           DALI_LOG_ERROR("Invalid frame index used.\n");
 423         }
 424         else
 425         {
 426           mIsJumpTo            = true;
 427           mFrameIndexForJumpTo = frameNumber;
 428           if(IsOnScene())
 429           {
 430             DisplayNextFrame();
 431           }
 432         }
 433       }
 434       break;
 435     }
 436   }
 437 }
 438
 439 void AnimatedImageVisual::DoSetProperties(const Property::Map& propertyMap)
 440 {
 441   // url[s] already passed in from constructor
 442   for(Property::Map::SizeType iter = 0; iter < propertyMap.Count(); ++iter)
 443   {
 444     KeyValuePair keyValue = propertyMap.GetKeyValue(iter);
 445     if(keyValue.first.type == Property::Key::INDEX)
 446     {
 447       DoSetProperty(keyValue.first.indexKey, keyValue.second);
 448     }
 449     else
 450     {
 451       if(keyValue.first == PIXEL_AREA_UNIFORM_NAME)
 452       {
 453         DoSetProperty(Toolkit::ImageVisual::Property::PIXEL_AREA, keyValue.second);
 454       }
 455       else if(keyValue.first == IMAGE_WRAP_MODE_U)
 456       {
 457         DoSetProperty(Toolkit::ImageVisual::Property::WRAP_MODE_U, keyValue.second);
 458       }
 459       else if(keyValue.first == IMAGE_WRAP_MODE_V)
 460       {
 461         DoSetProperty(Toolkit::ImageVisual::Property::WRAP_MODE_V, keyValue.second);
 462       }
 463       else if(keyValue.first == BATCH_SIZE_NAME)
 464       {
 465         DoSetProperty(Toolkit::ImageVisual::Property::BATCH_SIZE, keyValue.second);
 466       }
 467       else if(keyValue.first == CACHE_SIZE_NAME)
 468       {
 469         DoSetProperty(Toolkit::ImageVisual::Property::CACHE_SIZE, keyValue.second);
 470       }
 471       else if(keyValue.first == FRAME_DELAY_NAME)
 472       {
 473         DoSetProperty(Toolkit::ImageVisual::Property::FRAME_DELAY, keyValue.second);
 474       }
 475       else if(keyValue.first == LOOP_COUNT_NAME)
 476       {
 477         DoSetProperty(Toolkit::DevelImageVisual::Property::LOOP_COUNT, keyValue.second);
 478       }
 479       else if(keyValue.first == STOP_BEHAVIOR_NAME)
 480       {
 481         DoSetProperty(Toolkit::DevelImageVisual::Property::STOP_BEHAVIOR, keyValue.second);
 482       }
 483       else if(keyValue.first == ALPHA_MASK_URL)
 484       {
 485         DoSetProperty(Toolkit::ImageVisual::Property::ALPHA_MASK_URL, keyValue.second);
 486       }
 487       else if(keyValue.first == MASK_CONTENT_SCALE_NAME)
 488       {
 489         DoSetProperty(Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE, keyValue.second);
 490       }
 491       else if(keyValue.first == CROP_TO_MASK_NAME)
 492       {
 493         DoSetProperty(Toolkit::ImageVisual::Property::CROP_TO_MASK, keyValue.second);
 494       }
 495       else if(keyValue.first == MASKING_TYPE_NAME)
 496       {
 497         DoSetProperty(Toolkit::DevelImageVisual::Property::MASKING_TYPE, keyValue.second);
 498       }
 499       else if(keyValue.first == LOAD_POLICY_NAME)
 500       {
 501         DoSetProperty(Toolkit::ImageVisual::Property::LOAD_POLICY, keyValue.second);
 502       }
 503       else if(keyValue.first == RELEASE_POLICY_NAME)
 504       {
 505         DoSetProperty(Toolkit::ImageVisual::Property::RELEASE_POLICY, keyValue.second);
 506       }
 507       else if(keyValue.first == SYNCHRONOUS_LOADING)
 508       {
 509         DoSetProperty(Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING, keyValue.second);
 510       }
 511       else if(keyValue.first == IMAGE_FITTING_MODE)
 512       {
 513         DoSetProperty(Toolkit::ImageVisual::Property::FITTING_MODE, keyValue.second);
 514       }
 515       else if(keyValue.first == IMAGE_SAMPLING_MODE)
 516       {
 517         DoSetProperty(Toolkit::ImageVisual::Property::SAMPLING_MODE, keyValue.second);
 518       }
 519       else if(keyValue.first == IMAGE_DESIRED_WIDTH)
 520       {
 521         DoSetProperty(Toolkit::ImageVisual::Property::DESIRED_WIDTH, keyValue.second);
 522       }
 523       else if(keyValue.first == IMAGE_DESIRED_HEIGHT)
 524       {
 525         DoSetProperty(Toolkit::ImageVisual::Property::DESIRED_HEIGHT, keyValue.second);
 526       }
 527     }
 528   }
 529   // Load image immediately if LOAD_POLICY requires it
 530   if(mLoadPolicy == Toolkit::ImageVisual::LoadPolicy::IMMEDIATE)
 531   {
 532     PrepareTextureSet();
 533   }
 534 }
 535
 536 void AnimatedImageVisual::DoSetProperty(Property::Index        index,
 537                                         const Property::Value& value)
 538 {
 539   switch(index)
 540   {
 541     case Toolkit::ImageVisual::Property::PIXEL_AREA:
 542     {
 543       value.Get(mPixelArea);
 544       break;
 545     }
 546     case Toolkit::ImageVisual::Property::WRAP_MODE_U:
 547     {
 548       int wrapMode = 0;
 549       if(Scripting::GetEnumerationProperty(value, WRAP_MODE_TABLE, WRAP_MODE_TABLE_COUNT, wrapMode))
 550       {
 551         mWrapModeU = Dali::WrapMode::Type(wrapMode);
 552       }
 553       else
 554       {
 555         mWrapModeU = Dali::WrapMode::Type::DEFAULT;
 556       }
 557       break;
 558     }
 559     case Toolkit::ImageVisual::Property::WRAP_MODE_V:
 560     {
 561       int wrapMode = 0;
 562       if(Scripting::GetEnumerationProperty(value, WRAP_MODE_TABLE, WRAP_MODE_TABLE_COUNT, wrapMode))
 563       {
 564         mWrapModeV = Dali::WrapMode::Type(wrapMode);
 565       }
 566       else
 567       {
 568         mWrapModeV = Dali::WrapMode::Type::DEFAULT;
 569       }
 570       break;
 571     }
 572
 573     case Toolkit::ImageVisual::Property::BATCH_SIZE:
 574     {
 575       int batchSize;
 576       if(value.Get(batchSize))
 577       {
 578         if(batchSize < 2)
 579         {
 580           DALI_LOG_ERROR("The minimum value of batch size is 2.");
 581         }
 582         else
 583         {
 584           mBatchSize = batchSize;
 585         }
 586       }
 587       break;
 588     }
 589
 590     case Toolkit::ImageVisual::Property::CACHE_SIZE:
 591     {
 592       int cacheSize;
 593       if(value.Get(cacheSize))
 594       {
 595         if(cacheSize < 2)
 596         {
 597           DALI_LOG_ERROR("The minimum value of cache size is 2.");
 598         }
 599         else
 600         {
 601           mCacheSize = cacheSize;
 602         }
 603       }
 604       break;
 605     }
 606
 607     case Toolkit::ImageVisual::Property::FRAME_DELAY:
 608     {
 609       int frameDelay;
 610       if(value.Get(frameDelay))
 611       {
 612         mFrameDelay = frameDelay;
 613         if(mImageCache)
 614         {
 615           mImageCache->SetInterval(static_cast<uint32_t>(mFrameDelay));
 616         }
 617       }
 618       break;
 619     }
 620
 621     case Toolkit::DevelImageVisual::Property::LOOP_COUNT:
 622     {
 623       int loopCount;
 624       if(value.Get(loopCount))
 625       {
 626         mLoopCount = loopCount;
 627       }
 628       break;
 629     }
 630
 631     case Toolkit::DevelImageVisual::Property::STOP_BEHAVIOR:
 632     {
 633       int32_t stopBehavior = mStopBehavior;
 634       if(Scripting::GetEnumerationProperty(value, STOP_BEHAVIOR_TABLE, STOP_BEHAVIOR_TABLE_COUNT, stopBehavior))
 635       {
 636         mStopBehavior = DevelImageVisual::StopBehavior::Type(stopBehavior);
 637       }
 638       break;
 639     }
 640
 641     case Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING:
 642     {
 643       bool sync = false;
 644       value.Get(sync);
 645       if(sync)
 646       {
 647         mImpl->mFlags |= Visual::Base::Impl::IS_SYNCHRONOUS_RESOURCE_LOADING;
 648       }
 649       else
 650       {
 651         mImpl->mFlags &= ~Visual::Base::Impl::IS_SYNCHRONOUS_RESOURCE_LOADING;
 652       }
 653       break;
 654     }
 655
 656     case Toolkit::ImageVisual::Property::ALPHA_MASK_URL:
 657     {
 658       std::string alphaUrl = "";
 659       if(value.Get(alphaUrl))
 660       {
 661         AllocateMaskData();
 662         mMaskingData->mAlphaMaskUrl = alphaUrl;
 663       }
 664       break;
 665     }
 666
 667     case Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE:
 668     {
 669       float scale = 1.0f;
 670       if(value.Get(scale))
 671       {
 672         AllocateMaskData();
 673         mMaskingData->mContentScaleFactor = scale;
 674       }
 675       break;
 676     }
 677
 678     case Toolkit::ImageVisual::Property::CROP_TO_MASK:
 679     {
 680       bool crop = false;
 681       if(value.Get(crop))
 682       {
 683         AllocateMaskData();
 684         mMaskingData->mCropToMask = crop;
 685       }
 686       break;
 687     }
 688
 689     case Toolkit::DevelImageVisual::Property::MASKING_TYPE:
 690     {
 691       int maskingType = 0;
 692       if(value.Get(maskingType))
 693       {
 694         AllocateMaskData();
 695         mMaskingData->mPreappliedMasking = Toolkit::DevelImageVisual::MaskingType::Type(maskingType) == Toolkit::DevelImageVisual::MaskingType::MASKING_ON_LOADING ? true : false;
 696       }
 697       break;
 698     }
 699
 700     case Toolkit::ImageVisual::Property::RELEASE_POLICY:
 701     {
 702       int releasePolicy = 0;
 703       Scripting::GetEnumerationProperty(value, RELEASE_POLICY_TABLE, RELEASE_POLICY_TABLE_COUNT, releasePolicy);
 704       mReleasePolicy = Toolkit::ImageVisual::ReleasePolicy::Type(releasePolicy);
 705       break;
 706     }
 707
 708     case Toolkit::ImageVisual::Property::LOAD_POLICY:
 709     {
 710       int loadPolicy = 0;
 711       Scripting::GetEnumerationProperty(value, LOAD_POLICY_TABLE, LOAD_POLICY_TABLE_COUNT, loadPolicy);
 712       mLoadPolicy = Toolkit::ImageVisual::LoadPolicy::Type(loadPolicy);
 713       break;
 714     }
 715
 716     case Toolkit::ImageVisual::Property::FITTING_MODE:
 717     {
 718       int fittingMode = 0;
 719       Scripting::GetEnumerationProperty(value, FITTING_MODE_TABLE, FITTING_MODE_TABLE_COUNT, fittingMode);
 720       mFittingMode = Dali::FittingMode::Type(fittingMode);
 721       break;
 722     }
 723
 724     case Toolkit::ImageVisual::Property::SAMPLING_MODE:
 725     {
 726       int samplingMode = 0;
 727       Scripting::GetEnumerationProperty(value, SAMPLING_MODE_TABLE, SAMPLING_MODE_TABLE_COUNT, samplingMode);
 728       mSamplingMode = Dali::SamplingMode::Type(samplingMode);
 729       break;
 730     }
 731
 732     case Toolkit::ImageVisual::Property::DESIRED_WIDTH:
 733     {
 734       float desiredWidth = 0.0f;
 735       if(value.Get(desiredWidth))
 736       {
 737         mDesiredSize.SetWidth(desiredWidth);
 738       }
 739       else
 740       {
 741         DALI_LOG_ERROR("AnimatedImageVisual: desiredWidth property has incorrect type\n");
 742       }
 743       break;
 744     }
 745
 746     case Toolkit::ImageVisual::Property::DESIRED_HEIGHT:
 747     {
 748       float desiredHeight = 0.0f;
 749       if(value.Get(desiredHeight))
 750       {
 751         mDesiredSize.SetHeight(desiredHeight);
 752       }
 753       else
 754       {
 755         DALI_LOG_ERROR("AnimatedImageVisual: desiredHeight property has incorrect type\n");
 756       }
 757       break;
 758     }
 759   }
 760 }
 761
 762 void AnimatedImageVisual::DoSetOnScene(Actor& actor)
 763 {
 764   mStartFirstFrame = true;
 765   mPlacementActor  = actor;
 766   PrepareTextureSet();
 767 }
 768
 769 void AnimatedImageVisual::DoSetOffScene(Actor& actor)
 770 {
 771   DALI_ASSERT_DEBUG((bool)mImpl->mRenderer && "There should always be a renderer whilst on stage");
 772
 773   if(mFrameDelayTimer)
 774   {
 775     mFrameDelayTimer.Stop();
 776     mFrameDelayTimer.Reset();
 777   }
 778
 779   actor.RemoveRenderer(mImpl->mRenderer);
 780   if(mReleasePolicy == Toolkit::ImageVisual::ReleasePolicy::DETACHED)
 781   {
 782     mImageCache->ClearCache(); // If INVALID_TEXTURE_ID then removal will be attempted on atlas
 783     mImpl->mResourceStatus = Toolkit::Visual::ResourceStatus::PREPARING;
 784
 785     TextureSet textureSet = TextureSet::New();
 786     mImpl->mRenderer.SetTextures(textureSet);
 787   }
 788
 789   mPlacementActor.Reset();
 790   mStartFirstFrame   = false;
 791   mCurrentFrameIndex = FIRST_FRAME_INDEX;
 792   mCurrentLoopIndex  = FIRST_LOOP;
 793 }
 794
 795 void AnimatedImageVisual::OnSetTransform()
 796 {
 797   if(mImpl->mRenderer)
 798   {
 799     mImpl->mTransform.SetUniforms(mImpl->mRenderer, Direction::LEFT_TO_RIGHT);
 800   }
 801 }
 802
 803 void AnimatedImageVisual::UpdateShader()
 804 {
 805   if(mImpl->mRenderer)
 806   {
 807     Shader shader = GenerateShader();
 808     mImpl->mRenderer.SetShader(shader);
 809   }
 810 }
 811
 812 Shader AnimatedImageVisual::GenerateShader() const
 813 {
 814   bool   defaultWrapMode                 = mWrapModeU <= WrapMode::CLAMP_TO_EDGE && mWrapModeV <= WrapMode::CLAMP_TO_EDGE;
 815   bool   requiredAlphaMaskingOnRendering = (mMaskingData && !mMaskingData->mMaskImageLoadingFailed) ? !mMaskingData->mPreappliedMasking : false;
 816   Shader shader;
 817   shader = mImageVisualShaderFactory.GetShader(
 818     mFactoryCache,
 819     ImageVisualShaderFeatureBuilder()
 820       .ApplyDefaultTextureWrapMode(defaultWrapMode)
 821       .EnableRoundedCorner(IsRoundedCornerRequired())
 822       .EnableBorderline(IsBorderlineRequired())
 823       .EnableAlphaMaskingOnRendering(requiredAlphaMaskingOnRendering));
 824   return shader;
 825 }
 826
 827 void AnimatedImageVisual::OnInitialize()
 828 {
 829   CreateImageCache();
 830
 831   bool   defaultWrapMode = mWrapModeU <= WrapMode::CLAMP_TO_EDGE && mWrapModeV <= WrapMode::CLAMP_TO_EDGE;
 832   Shader shader          = GenerateShader();
 833
 834   Geometry geometry = mFactoryCache.GetGeometry(VisualFactoryCache::QUAD_GEOMETRY);
 835
 836   mImpl->mRenderer = DecoratedVisualRenderer::New(geometry, shader);
 837   mImpl->mRenderer.ReserveCustomProperties(CUSTOM_PROPERTY_COUNT);
 838
 839   // Register transform properties
 840   mImpl->mTransform.SetUniforms(mImpl->mRenderer, Direction::LEFT_TO_RIGHT);
 841
 842   if(!defaultWrapMode) // custom wrap mode
 843   {
 844     Vector2 wrapMode(mWrapModeU - WrapMode::CLAMP_TO_EDGE, mWrapModeV - WrapMode::CLAMP_TO_EDGE);
 845     wrapMode.Clamp(Vector2::ZERO, Vector2(2.f, 2.f));
 846     mImpl->mRenderer.RegisterProperty(WRAP_MODE_UNIFORM_NAME, wrapMode);
 847   }
 848
 849   if(mPixelArea != FULL_TEXTURE_RECT)
 850   {
 851     mImpl->mRenderer.RegisterProperty(PIXEL_AREA_UNIFORM_NAME, mPixelArea);
 852   }
 853
 854   if(mMaskingData)
 855   {
 856     mImpl->mRenderer.RegisterProperty(CROP_TO_MASK_NAME, static_cast<float>(mMaskingData->mCropToMask));
 857   }
 858
 859   // Enable PreMultipliedAlpha if it need premultiplied
 860   auto preMultiplyOnLoad = IsPreMultipliedAlphaEnabled() && !mImpl->mCustomShader
 861                              ? TextureManager::MultiplyOnLoad::MULTIPLY_ON_LOAD
 862                              : TextureManager::MultiplyOnLoad::LOAD_WITHOUT_MULTIPLY;
 863   EnablePreMultipliedAlpha(preMultiplyOnLoad == TextureManager::MultiplyOnLoad::MULTIPLY_ON_LOAD);
 864 }
 865
 866 void AnimatedImageVisual::StartFirstFrame(TextureSet& textureSet, uint32_t firstInterval)
 867 {
 868   DALI_LOG_INFO(gAnimImgLogFilter, Debug::Concise, "AnimatedImageVisual::StartFirstFrame()\n");
 869
 870   mStartFirstFrame = false;
 871   if(mImpl->mRenderer)
 872   {
 873     mImpl->mRenderer.SetTextures(textureSet);
 874     CheckMaskTexture();
 875
 876     Actor actor = mPlacementActor.GetHandle();
 877     if(actor)
 878     {
 879       actor.AddRenderer(mImpl->mRenderer);
 880       mPlacementActor.Reset();
 881     }
 882   }
 883
 884   if(mImpl->mResourceStatus != Toolkit::Visual::ResourceStatus::FAILED)
 885   {
 886     if(mFrameCount > SINGLE_IMAGE_COUNT)
 887     {
 888       mFrameDelayTimer = Timer::New(firstInterval);
 889       mFrameDelayTimer.TickSignal().Connect(this, &AnimatedImageVisual::DisplayNextFrame);
 890       mFrameDelayTimer.Start();
 891     }
 892
 893     DALI_LOG_INFO(gAnimImgLogFilter, Debug::Concise, "ResourceReady(ResourceStatus::READY)\n");
 894     ResourceReady(Toolkit::Visual::ResourceStatus::READY);
 895   }
 896
 897   mCurrentFrameIndex = FIRST_FRAME_INDEX;
 898 }
 899
 900 void AnimatedImageVisual::PrepareTextureSet()
 901 {
 902   TextureSet textureSet;
 903   if(mImageCache)
 904   {
 905     textureSet = mImageCache->FirstFrame();
 906   }
 907
 908   // Check whether synchronous loading is true or false for the first frame.
 909   if(textureSet)
 910   {
 911     SetImageSize(textureSet);
 912   }
 913 }
 914
 915 void AnimatedImageVisual::SetImageSize(TextureSet& textureSet)
 916 {
 917   if(textureSet)
 918   {
 919     Texture texture = textureSet.GetTexture(0);
 920     if(texture)
 921     {
 922       mImageSize.SetWidth(texture.GetWidth());
 923       mImageSize.SetHeight(texture.GetHeight());
 924     }
 925
 926     if(textureSet.GetTextureCount() > 1u && mMaskingData && mMaskingData->mCropToMask)
 927     {
 928       Texture maskTexture = textureSet.GetTexture(1);
 929       if(maskTexture)
 930       {
 931         mImageSize.SetWidth(std::min(static_cast<uint32_t>(mImageSize.GetWidth() * mMaskingData->mContentScaleFactor), maskTexture.GetWidth()));
 932         mImageSize.SetHeight(std::min(static_cast<uint32_t>(mImageSize.GetHeight() * mMaskingData->mContentScaleFactor), maskTexture.GetHeight()));
 933
 934         float   textureWidth  = std::max(static_cast<float>(texture.GetWidth() * mMaskingData->mContentScaleFactor), Dali::Math::MACHINE_EPSILON_1);
 935         float   textureHeight = std::max(static_cast<float>(texture.GetHeight() * mMaskingData->mContentScaleFactor), Dali::Math::MACHINE_EPSILON_1);
 936         Vector2 textureRatio(std::min(static_cast<float>(maskTexture.GetWidth()), textureWidth) / textureWidth,
 937                              std::min(static_cast<float>(maskTexture.GetHeight()), textureHeight) / textureHeight);
 938         mImpl->mRenderer.RegisterProperty(MASK_TEXTURE_RATIO_NAME, textureRatio);
 939       }
 940     }
 941   }
 942 }
 943
 944 void AnimatedImageVisual::FrameReady(TextureSet textureSet, uint32_t interval, bool preMultiplied)
 945 {
 946   EnablePreMultipliedAlpha(preMultiplied);
 947
 948   // When image visual requested to load new frame to mImageCache and it is failed.
 949   if(!mImageCache || !textureSet)
 950   {
 951     textureSet = SetLoadingFailed();
 952   }
 953   SetImageSize(textureSet);
 954
 955   if(mStartFirstFrame)
 956   {
 957     mFrameCount = mImageCache->GetTotalFrameCount();
 958     StartFirstFrame(textureSet, interval);
 959   }
 960   else
 961   {
 962     if(mImpl->mRenderer)
 963     {
 964       if(mFrameDelayTimer && interval > 0u)
 965       {
 966         mFrameDelayTimer.SetInterval(interval);
 967       }
 968       mImpl->mRenderer.SetTextures(textureSet);
 969       CheckMaskTexture();
 970     }
 971   }
 972 }
 973
 974 bool AnimatedImageVisual::DisplayNextFrame()
 975 {
 976   TextureSet textureSet;
 977   bool       continueTimer = false;
 978
 979   if(mImageCache)
 980   {
 981     uint32_t frameIndex = mImageCache->GetCurrentFrameIndex();
 982
 983     if(mIsJumpTo)
 984     {
 985       mIsJumpTo  = false;
 986       frameIndex = mFrameIndexForJumpTo;
 987     }
 988     else if(mActionStatus == DevelAnimatedImageVisual::Action::PAUSE)
 989     {
 990       return false;
 991     }
 992     else if(mActionStatus == DevelAnimatedImageVisual::Action::STOP)
 993     {
 994       mCurrentLoopIndex = FIRST_LOOP;
 995       if(mStopBehavior == DevelImageVisual::StopBehavior::FIRST_FRAME)
 996       {
 997         frameIndex = FIRST_FRAME_INDEX;
 998       }
 999       else if(mStopBehavior == DevelImageVisual::StopBehavior::LAST_FRAME)
1000       {
1001         frameIndex = mFrameCount - 1;
1002       }
1003       else
1004       {
1005         return false; // Do not draw already rendered scene twice.
1006       }
1007     }
1008     else
1009     {
1010       if(mFrameCount > SINGLE_IMAGE_COUNT)
1011       {
1012         frameIndex++;
1013         if(frameIndex >= mFrameCount)
1014         {
1015           frameIndex = FIRST_FRAME_INDEX;
1016           ++mCurrentLoopIndex;
1017         }
1018
1019         if(mLoopCount >= 0 && mCurrentLoopIndex >= mLoopCount)
1020         {
1021           // This will stop timer
1022           mActionStatus = DevelAnimatedImageVisual::Action::STOP;
1023           return DisplayNextFrame();
1024         }
1025       }
1026     }
1027
1028     DALI_LOG_INFO(gAnimImgLogFilter, Debug::Concise, "AnimatedImageVisual::DisplayNextFrame(this:%p) CurrentFrameIndex:%d\n", this, frameIndex);
1029
1030     textureSet = mImageCache->Frame(frameIndex);
1031
1032     if(textureSet)
1033     {
1034       SetImageSize(textureSet);
1035       if(mImpl->mRenderer)
1036       {
1037         mImpl->mRenderer.SetTextures(textureSet);
1038         CheckMaskTexture();
1039       }
1040       mFrameDelayTimer.SetInterval(mImageCache->GetFrameInterval(frameIndex));
1041     }
1042
1043     mCurrentFrameIndex = frameIndex;
1044     continueTimer      = (mActionStatus == DevelAnimatedImageVisual::Action::PLAY && textureSet) ? true : false;
1045   }
1046
1047   return continueTimer;
1048 }
1049
1050 TextureSet AnimatedImageVisual::SetLoadingFailed()
1051 {
1052   DALI_LOG_INFO(gAnimImgLogFilter, Debug::Concise, "ResourceReady(ResourceStatus::FAILED)\n");
1053   ResourceReady(Toolkit::Visual::ResourceStatus::FAILED);
1054
1055   Actor   actor     = mPlacementActor.GetHandle();
1056   Vector2 imageSize = Vector2::ZERO;
1057   if(actor)
1058   {
1059     imageSize = actor.GetProperty(Actor::Property::SIZE).Get<Vector2>();
1060   }
1061   mFactoryCache.UpdateBrokenImageRenderer(mImpl->mRenderer, imageSize);
1062   TextureSet textureSet = mImpl->mRenderer.GetTextures();
1063
1064   if(mFrameDelayTimer)
1065   {
1066     mFrameDelayTimer.Stop();
1067     mFrameDelayTimer.Reset();
1068   }
1069
1070   SetImageSize(textureSet);
1071
1072   return textureSet;
1073 }
1074
1075 void AnimatedImageVisual::AllocateMaskData()
1076 {
1077   if(!mMaskingData)
1078   {
1079     mMaskingData.reset(new TextureManager::MaskingData());
1080   }
1081 }
1082
1083 void AnimatedImageVisual::CheckMaskTexture()
1084 {
1085   if(mMaskingData && !mMaskingData->mPreappliedMasking)
1086   {
1087     bool       maskLoadFailed = true;
1088     TextureSet textures       = mImpl->mRenderer.GetTextures();
1089     if(textures && textures.GetTextureCount() >= TEXTURE_COUNT_FOR_GPU_ALPHA_MASK)
1090     {
1091       maskLoadFailed = false;
1092     }
1093     if(mMaskingData->mMaskImageLoadingFailed != maskLoadFailed)
1094     {
1095       mMaskingData->mMaskImageLoadingFailed = maskLoadFailed;
1096       UpdateShader();
1097     }
1098   }
1099 }
1100
1101 } // namespace Internal
1102
1103 } // namespace Toolkit
1104
1105 } // namespace Dali