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

   1 /*
   2  * Copyright (c) 2018 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 "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 <memory>
  25
  26 // INTERNAL INCLUDES
  27 #include <dali-toolkit/public-api/visuals/image-visual-properties.h>
  28 #include <dali-toolkit/public-api/visuals/visual-properties.h>
  29 #include <dali-toolkit/internal/visuals/visual-factory-impl.h>
  30 #include <dali-toolkit/internal/visuals/visual-factory-cache.h>
  31 #include <dali-toolkit/internal/visuals/visual-string-constants.h>
  32 #include <dali-toolkit/internal/visuals/visual-base-data-impl.h>
  33 #include <dali-toolkit/internal/visuals/image-visual-shader-factory.h>
  34 #include <dali-toolkit/internal/visuals/animated-image/fixed-image-cache.h>
  35 #include <dali-toolkit/internal/visuals/animated-image/rolling-image-cache.h>
  36 #include <dali-toolkit/internal/visuals/animated-image/rolling-gif-image-cache.h>
  37 #include <dali-toolkit/devel-api/image-loader/image-atlas.h>
  38 #include <dali-toolkit/devel-api/image-loader/texture-manager.h>
  39 #include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
  40
  41 namespace Dali
  42 {
  43
  44 namespace Toolkit
  45 {
  46
  47 namespace Internal
  48 {
  49
  50 namespace
  51 {
  52 // wrap modes
  53 DALI_ENUM_TO_STRING_TABLE_BEGIN( WRAP_MODE )
  54 DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::WrapMode, DEFAULT )
  55 DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::WrapMode, CLAMP_TO_EDGE )
  56 DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::WrapMode, REPEAT )
  57 DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::WrapMode, MIRRORED_REPEAT )
  58 DALI_ENUM_TO_STRING_TABLE_END( WRAP_MODE )
  59
  60 const Vector4 FULL_TEXTURE_RECT(0.f, 0.f, 1.f, 1.f);
  61 constexpr auto LOOP_FOREVER = -1;
  62
  63 #if defined(DEBUG_ENABLED)
  64 Debug::Filter* gAnimImgLogFilter = Debug::Filter::New(Debug::NoLogging, false, "LOG_ANIMATED_IMAGE");
  65 #endif
  66 }
  67
  68
  69 /**
  70  * Multi-image  Flow of execution
  71  *
  72  *   | New
  73  *   |   DoSetProperties()
  74  *   |   LoadFirstBatch()
  75  *   |     new cache
  76  *   |       cache->LoadBatch()
  77  *   |
  78  *   | DoSetOnStage()
  79  *   |   PrepareTextureSet()
  80  *   |     cache->FirstFrame()
  81  *   |   CreateRenderer()    (Doesn't become ready until first frame loads)
  82  *   |   StartFirstFrame()
  83  *   |
  84  *   | FrameReady(textureSet)
  85  *   |   start first frame:
  86  *   |     actor.AddRenderer
  87  *   |     start timer
  88  *   |   mRenderer.SetTextures(textureSet)
  89  *   |
  90  *   | Timer ticks
  91  *   |   DisplayNextFrame()
  92  *   |     if front frame is ready,
  93  *   |       mRenderer.SetTextures( front frame's texture )
  94  *   |     else
  95  *   |       mWaitingForTexture=true
  96  *   |     cache->LoadBatch()
  97  *   |
  98  *   | FrameReady(textureSet)
  99  *   |   mRenderer.SetTextures(textureSet)
 100  *   V
 101  *  Time
 102  */
 103
 104 AnimatedImageVisualPtr AnimatedImageVisual::New( VisualFactoryCache& factoryCache, ImageVisualShaderFactory& shaderFactory, const VisualUrl& imageUrl, const Property::Map& properties )
 105 {
 106   AnimatedImageVisualPtr visual( new AnimatedImageVisual( factoryCache, shaderFactory ) );
 107   visual->InitializeGif( imageUrl );
 108   visual->SetProperties( properties );
 109
 110   if( visual->mFrameCount > 0 )
 111   {
 112     visual->LoadFirstBatch();
 113   }
 114
 115   return visual;
 116 }
 117
 118 AnimatedImageVisualPtr AnimatedImageVisual::New( VisualFactoryCache& factoryCache, ImageVisualShaderFactory& shaderFactory, const Property::Array& imageUrls, const Property::Map& properties )
 119 {
 120   AnimatedImageVisualPtr visual( new AnimatedImageVisual( factoryCache, shaderFactory ) );
 121   visual->mImageUrls = new ImageCache::UrlList();
 122   visual->mImageUrls->reserve( imageUrls.Count() );
 123
 124   for( unsigned int i=0; i < imageUrls.Count(); ++i)
 125   {
 126     ImageCache::UrlStore urlStore;
 127     urlStore.mTextureId = TextureManager::INVALID_TEXTURE_ID;
 128     urlStore.mUrl = imageUrls[i].Get<std::string>();
 129     visual->mImageUrls->push_back( urlStore );
 130   }
 131   visual->mFrameCount = imageUrls.Count();
 132   visual->SetProperties( properties );
 133
 134   if( visual->mFrameCount > 0 )
 135   {
 136     visual->LoadFirstBatch();
 137   }
 138
 139   return visual;
 140 }
 141
 142 AnimatedImageVisualPtr AnimatedImageVisual::New( VisualFactoryCache& factoryCache, ImageVisualShaderFactory& shaderFactory, const VisualUrl& imageUrl )
 143 {
 144   AnimatedImageVisualPtr visual( new AnimatedImageVisual( factoryCache, shaderFactory ) );
 145   visual->InitializeGif( imageUrl );
 146
 147   if( visual->mFrameCount > 0 )
 148   {
 149     visual->LoadFirstBatch();
 150   }
 151
 152   return visual;
 153 }
 154
 155 void AnimatedImageVisual::InitializeGif( const VisualUrl& imageUrl )
 156 {
 157   mImageUrl = imageUrl;
 158   mGifLoading = GifLoading::New( imageUrl.GetUrl(), imageUrl.IsLocalResource() );
 159   mFrameCount = mGifLoading->GetImageCount();
 160   mGifLoading->LoadFrameDelays( mFrameDelayContainer );
 161 }
 162
 163 AnimatedImageVisual::AnimatedImageVisual( VisualFactoryCache& factoryCache, ImageVisualShaderFactory& shaderFactory )
 164 : Visual::Base( factoryCache, Visual::FittingMode::FIT_KEEP_ASPECT_RATIO ),
 165   mFrameDelayTimer(),
 166   mPlacementActor(),
 167   mImageVisualShaderFactory( shaderFactory ),
 168   mPixelArea( FULL_TEXTURE_RECT ),
 169   mImageUrl(),
 170   mGifLoading( nullptr ),
 171   mCurrentFrameIndex( 0 ),
 172   mImageUrls( NULL ),
 173   mImageCache( NULL ),
 174   mCacheSize( 1 ),
 175   mBatchSize( 1 ),
 176   mFrameDelay( 100 ),
 177   mLoopCount( LOOP_FOREVER ),
 178   mCurrentLoopIndex( 0 ),
 179   mUrlIndex( 0 ),
 180   mFrameCount( 0 ),
 181   mImageSize(),
 182   mWrapModeU( WrapMode::DEFAULT ),
 183   mWrapModeV( WrapMode::DEFAULT ),
 184   mActionStatus( DevelAnimatedImageVisual::Action::PLAY ),
 185   mStartFirstFrame(false)
 186 {}
 187
 188 AnimatedImageVisual::~AnimatedImageVisual()
 189 {
 190   delete mImageCache;
 191   delete mImageUrls;
 192 }
 193
 194 void AnimatedImageVisual::GetNaturalSize( Vector2& naturalSize )
 195 {
 196   if( mImageSize.GetWidth() == 0 &&  mImageSize.GetHeight() == 0)
 197   {
 198     if( mImageUrl.IsValid() )
 199     {
 200       mImageSize = mGifLoading->GetImageSize();
 201     }
 202     else if( mImageUrls && mImageUrls->size() > 0 )
 203     {
 204       mImageSize = Dali::GetClosestImageSize( (*mImageUrls)[0].mUrl );
 205     }
 206   }
 207
 208   naturalSize.width = mImageSize.GetWidth();
 209   naturalSize.height = mImageSize.GetHeight();
 210 }
 211
 212 void AnimatedImageVisual::DoCreatePropertyMap( Property::Map& map ) const
 213 {
 214   map.Clear();
 215
 216   map.Insert( Toolkit::Visual::Property::TYPE, Toolkit::Visual::ANIMATED_IMAGE );
 217
 218   if( mImageUrl.IsValid() )
 219   {
 220     map.Insert( Toolkit::ImageVisual::Property::URL, mImageUrl.GetUrl() );
 221   }
 222   if( mImageUrls != NULL && ! mImageUrls->empty() )
 223   {
 224     Property::Array urls;
 225     for( unsigned int i=0; i<mImageUrls->size(); ++i)
 226     {
 227       urls.Add( (*mImageUrls)[i].mUrl );
 228     }
 229     Property::Value value( const_cast<Property::Array&>(urls) );
 230     map.Insert( Toolkit::ImageVisual::Property::URL, value );
 231   }
 232
 233   map.Insert( Toolkit::ImageVisual::Property::PIXEL_AREA, mPixelArea );
 234   map.Insert( Toolkit::ImageVisual::Property::WRAP_MODE_U, mWrapModeU );
 235   map.Insert( Toolkit::ImageVisual::Property::WRAP_MODE_V, mWrapModeV );
 236
 237   map.Insert( Toolkit::ImageVisual::Property::BATCH_SIZE, static_cast<int>(mBatchSize) );
 238   map.Insert( Toolkit::ImageVisual::Property::CACHE_SIZE, static_cast<int>(mCacheSize) );
 239   map.Insert( Toolkit::ImageVisual::Property::FRAME_DELAY, static_cast<int>(mFrameDelay) );
 240   map.Insert( Toolkit::DevelImageVisual::Property::LOOP_COUNT, static_cast<int>(mLoopCount) );
 241 }
 242
 243 void AnimatedImageVisual::DoCreateInstancePropertyMap( Property::Map& map ) const
 244 {
 245   // Do nothing
 246 }
 247
 248 void AnimatedImageVisual::OnDoAction( const Dali::Property::Index actionId, const Dali::Property::Value& attributes )
 249 {
 250   // Check if action is valid for this visual type and perform action if possible
 251
 252   switch ( actionId )
 253   {
 254     case DevelAnimatedImageVisual::Action::PAUSE:
 255     {
 256       // Pause will be executed on next timer tick
 257       mActionStatus = DevelAnimatedImageVisual::Action::PAUSE;
 258       break;
 259     }
 260     case DevelAnimatedImageVisual::Action::PLAY:
 261     {
 262       if( IsOnStage() && mActionStatus != DevelAnimatedImageVisual::Action::PLAY )
 263       {
 264         mFrameDelayTimer.Start();
 265       }
 266       mActionStatus = DevelAnimatedImageVisual::Action::PLAY;
 267       break;
 268     }
 269     case DevelAnimatedImageVisual::Action::STOP:
 270     {
 271       // STOP reset functionality will actually be done in a future change
 272       // Stop will be executed on next timer tick
 273       mCurrentFrameIndex = 0;
 274       mActionStatus = DevelAnimatedImageVisual::Action::STOP;
 275       break;
 276     }
 277   }
 278 }
 279
 280 void AnimatedImageVisual::DoSetProperties( const Property::Map& propertyMap )
 281 {
 282   // url[s] already passed in from constructor
 283
 284   for( Property::Map::SizeType iter = 0; iter < propertyMap.Count(); ++iter )
 285   {
 286     KeyValuePair keyValue = propertyMap.GetKeyValue( iter );
 287     if( keyValue.first.type == Property::Key::INDEX )
 288     {
 289       DoSetProperty( keyValue.first.indexKey, keyValue.second );
 290     }
 291     else
 292     {
 293       if( keyValue.first == PIXEL_AREA_UNIFORM_NAME )
 294       {
 295         DoSetProperty( Toolkit::ImageVisual::Property::PIXEL_AREA, keyValue.second );
 296       }
 297       else if( keyValue.first == IMAGE_WRAP_MODE_U )
 298       {
 299         DoSetProperty( Toolkit::ImageVisual::Property::WRAP_MODE_U, keyValue.second );
 300       }
 301       else if( keyValue.first == IMAGE_WRAP_MODE_V )
 302       {
 303         DoSetProperty( Toolkit::ImageVisual::Property::WRAP_MODE_V, keyValue.second );
 304       }
 305       else if( keyValue.first == BATCH_SIZE_NAME )
 306       {
 307         DoSetProperty( Toolkit::ImageVisual::Property::BATCH_SIZE, keyValue.second );
 308       }
 309       else if( keyValue.first == CACHE_SIZE_NAME )
 310       {
 311         DoSetProperty( Toolkit::ImageVisual::Property::CACHE_SIZE, keyValue.second );
 312       }
 313       else if( keyValue.first == FRAME_DELAY_NAME )
 314       {
 315         DoSetProperty( Toolkit::ImageVisual::Property::FRAME_DELAY, keyValue.second );
 316       }
 317       else if( keyValue.first == LOOP_COUNT_NAME )
 318       {
 319         DoSetProperty( Toolkit::DevelImageVisual::Property::LOOP_COUNT, keyValue.second );
 320       }
 321     }
 322   }
 323 }
 324
 325 void AnimatedImageVisual::DoSetProperty( Property::Index index,
 326                                          const Property::Value& value )
 327 {
 328   switch(index)
 329   {
 330     case Toolkit::ImageVisual::Property::PIXEL_AREA:
 331     {
 332       value.Get( mPixelArea );
 333       break;
 334     }
 335     case Toolkit::ImageVisual::Property::WRAP_MODE_U:
 336     {
 337       int wrapMode = 0;
 338       if(Scripting::GetEnumerationProperty( value, WRAP_MODE_TABLE, WRAP_MODE_TABLE_COUNT, wrapMode ))
 339       {
 340         mWrapModeU = Dali::WrapMode::Type(wrapMode);
 341       }
 342       else
 343       {
 344         mWrapModeU = Dali::WrapMode::Type::DEFAULT;
 345       }
 346       break;
 347     }
 348     case Toolkit::ImageVisual::Property::WRAP_MODE_V:
 349     {
 350       int wrapMode = 0;
 351       if(Scripting::GetEnumerationProperty( value, WRAP_MODE_TABLE, WRAP_MODE_TABLE_COUNT, wrapMode ))
 352       {
 353         mWrapModeV = Dali::WrapMode::Type(wrapMode);
 354       }
 355       else
 356       {
 357         mWrapModeV = Dali::WrapMode::Type::DEFAULT;
 358       }
 359       break;
 360     }
 361
 362     case Toolkit::ImageVisual::Property::BATCH_SIZE:
 363     {
 364       int batchSize;
 365       if( value.Get( batchSize ) )
 366       {
 367         mBatchSize = batchSize;
 368       }
 369       break;
 370     }
 371
 372     case Toolkit::ImageVisual::Property::CACHE_SIZE:
 373     {
 374       int cacheSize;
 375       if( value.Get( cacheSize ) )
 376       {
 377         mCacheSize = cacheSize;
 378       }
 379       break;
 380     }
 381
 382     case Toolkit::ImageVisual::Property::FRAME_DELAY:
 383     {
 384       int frameDelay;
 385       if( value.Get( frameDelay ) )
 386       {
 387         mFrameDelay = frameDelay;
 388       }
 389       break;
 390     }
 391
 392     case Toolkit::DevelImageVisual::Property::LOOP_COUNT:
 393     {
 394       int loopCount;
 395       if( value.Get( loopCount ) )
 396       {
 397         mLoopCount = loopCount;
 398       }
 399       break;
 400     }
 401   }
 402 }
 403
 404 void AnimatedImageVisual::DoSetOnStage( Actor& actor )
 405 {
 406   mPlacementActor = actor;
 407   TextureSet textureSet = PrepareTextureSet();
 408   CreateRenderer(); // Always create a renderer when on stage
 409
 410   if( textureSet ) // if the image loading is successful
 411   {
 412     StartFirstFrame( textureSet );
 413   }
 414   else
 415   {
 416     mStartFirstFrame = true;
 417   }
 418 }
 419
 420 void AnimatedImageVisual::DoSetOffStage( Actor& actor )
 421 {
 422   DALI_ASSERT_DEBUG( (bool)mImpl->mRenderer && "There should always be a renderer whilst on stage");
 423
 424   if( mFrameDelayTimer )
 425   {
 426     mFrameDelayTimer.Stop();
 427     mFrameDelayTimer.Reset();
 428   }
 429
 430   actor.RemoveRenderer( mImpl->mRenderer );
 431   mImpl->mRenderer.Reset();
 432   mPlacementActor.Reset();
 433 }
 434
 435 void AnimatedImageVisual::OnSetTransform()
 436 {
 437   if( mImpl->mRenderer )
 438   {
 439     mImpl->mTransform.RegisterUniforms( mImpl->mRenderer, Direction::LEFT_TO_RIGHT );
 440   }
 441 }
 442
 443 void AnimatedImageVisual::CreateRenderer()
 444 {
 445   bool defaultWrapMode = mWrapModeU <= WrapMode::CLAMP_TO_EDGE && mWrapModeV <= WrapMode::CLAMP_TO_EDGE;
 446   bool atlasing = false;
 447   Shader shader = mImageVisualShaderFactory.GetShader( mFactoryCache, atlasing, defaultWrapMode );
 448
 449   Geometry geometry = mFactoryCache.GetGeometry( VisualFactoryCache::QUAD_GEOMETRY );
 450
 451   mImpl->mRenderer = Renderer::New( geometry, shader );
 452
 453   // Register transform properties
 454   mImpl->mTransform.RegisterUniforms( mImpl->mRenderer, Direction::LEFT_TO_RIGHT );
 455
 456   if( !defaultWrapMode ) // custom wrap mode
 457   {
 458     Vector2 wrapMode(mWrapModeU-WrapMode::CLAMP_TO_EDGE, mWrapModeV-WrapMode::CLAMP_TO_EDGE);
 459     wrapMode.Clamp( Vector2::ZERO, Vector2( 2.f, 2.f ) );
 460     mImpl->mRenderer.RegisterProperty( WRAP_MODE_UNIFORM_NAME, wrapMode );
 461   }
 462
 463   if( mPixelArea != FULL_TEXTURE_RECT )
 464   {
 465     mImpl->mRenderer.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, mPixelArea );
 466   }
 467
 468   mCurrentFrameIndex = 0;
 469 }
 470
 471 void AnimatedImageVisual::LoadFirstBatch()
 472 {
 473   // Ensure the batch size and cache size are no bigger than the number of URLs,
 474   // and that the cache is at least as big as the batch size.
 475   uint16_t numUrls = 0;
 476   uint16_t batchSize = 1;
 477   uint16_t cacheSize = 1;
 478
 479   if( mImageUrls )
 480   {
 481     numUrls = mImageUrls->size();
 482   }
 483   else
 484   {
 485     numUrls = mFrameCount;
 486   }
 487
 488   batchSize = std::min( mBatchSize, numUrls );
 489   cacheSize = std::min( std::max( batchSize, mCacheSize ), numUrls );
 490
 491   DALI_LOG_INFO(gAnimImgLogFilter,Debug::Concise,"AnimatedImageVisual::LoadFirstBatch()  batchSize:%d  cacheSize:%d\n", batchSize, cacheSize);
 492
 493   mUrlIndex = 0;
 494   TextureManager& textureManager = mFactoryCache.GetTextureManager();
 495
 496   if( mGifLoading != nullptr )
 497   {
 498     mImageCache = new RollingGifImageCache( textureManager, *mGifLoading, mFrameCount, *this, cacheSize, batchSize );
 499   }
 500   else if( mImageUrls )
 501   {
 502     if( batchSize > 0 && cacheSize > 0 )
 503     {
 504       if( cacheSize < numUrls )
 505       {
 506         mImageCache = new RollingImageCache( textureManager, *mImageUrls, *this, cacheSize, batchSize );
 507       }
 508       else
 509       {
 510         mImageCache = new FixedImageCache( textureManager, *mImageUrls, *this, batchSize );
 511       }
 512     }
 513     else
 514     {
 515       mImageCache = new RollingImageCache( textureManager, *mImageUrls, *this, 1, 1 );
 516     }
 517   }
 518
 519   if (!mImageCache)
 520   {
 521     DALI_LOG_ERROR("mImageCache is null");
 522   }
 523 }
 524
 525 void AnimatedImageVisual::StartFirstFrame( TextureSet& textureSet )
 526 {
 527   DALI_LOG_INFO(gAnimImgLogFilter,Debug::Concise,"AnimatedImageVisual::StartFirstFrame()\n");
 528
 529   mStartFirstFrame = false;
 530   if(mImpl->mRenderer)
 531   {
 532     mImpl->mRenderer.SetTextures( textureSet );
 533   }
 534   Actor actor = mPlacementActor.GetHandle();
 535   if( actor )
 536   {
 537     actor.AddRenderer( mImpl->mRenderer );
 538     mPlacementActor.Reset();
 539   }
 540
 541   mCurrentFrameIndex = 0;
 542
 543   if( mFrameCount > 1 )
 544   {
 545     int frameDelay = mFrameDelay; // from URL array
 546     if( mFrameDelayContainer.Count() > 0 ) // from GIF
 547     {
 548       frameDelay = mFrameDelayContainer[0];
 549     }
 550
 551     mFrameDelayTimer = Timer::New( frameDelay );
 552     mFrameDelayTimer.TickSignal().Connect( this, &AnimatedImageVisual::DisplayNextFrame );
 553     mFrameDelayTimer.Start();
 554   }
 555   DALI_LOG_INFO(gAnimImgLogFilter,Debug::Concise,"ResourceReady(ResourceStatus::READY)\n");
 556   ResourceReady( Toolkit::Visual::ResourceStatus::READY );
 557 }
 558
 559 TextureSet AnimatedImageVisual::PrepareTextureSet()
 560 {
 561   TextureSet textureSet;
 562   if (mImageCache)
 563     textureSet = mImageCache->FirstFrame();
 564   if( textureSet )
 565   {
 566     SetImageSize( textureSet );
 567   }
 568   else
 569   {
 570     DALI_LOG_INFO(gAnimImgLogFilter,Debug::Concise,"ResourceReady(ResourceStatus::FAILED)\n");
 571     ResourceReady( Toolkit::Visual::ResourceStatus::FAILED );
 572   }
 573
 574   return textureSet;
 575 }
 576
 577 void AnimatedImageVisual::SetImageSize( TextureSet& textureSet )
 578 {
 579   if( textureSet )
 580   {
 581     Texture texture = textureSet.GetTexture( 0 );
 582     if( texture )
 583     {
 584       mImageSize.SetWidth( texture.GetWidth() );
 585       mImageSize.SetHeight( texture.GetHeight() );
 586     }
 587   }
 588 }
 589
 590 void AnimatedImageVisual::FrameReady( TextureSet textureSet )
 591 {
 592   SetImageSize( textureSet );
 593
 594   if( mStartFirstFrame )
 595   {
 596     StartFirstFrame( textureSet );
 597   }
 598   else
 599   {
 600     if(mImpl->mRenderer)
 601     {
 602       mImpl->mRenderer.SetTextures( textureSet );
 603     }
 604   }
 605 }
 606
 607 bool AnimatedImageVisual::DisplayNextFrame()
 608 {
 609   if( mActionStatus == DevelAnimatedImageVisual::Action::STOP || mActionStatus == DevelAnimatedImageVisual::Action::PAUSE )
 610   {
 611     return false;
 612   }
 613   if( mFrameCount > 1 )
 614   {
 615     // Wrap the frame index
 616     ++mCurrentFrameIndex;
 617
 618     if( mLoopCount < 0 || mCurrentLoopIndex <= mLoopCount)
 619     {
 620       mCurrentFrameIndex %= mFrameCount;
 621       if( mCurrentFrameIndex == 0 )
 622       {
 623         ++mCurrentLoopIndex;
 624       }
 625     }
 626     else
 627     {
 628       // This will stop timer
 629       return false;
 630     }
 631   }
 632   DALI_LOG_INFO( gAnimImgLogFilter,Debug::Concise,"AnimatedImageVisual::DisplayNextFrame(this:%p) FrameCount:%d\n", this, mCurrentFrameIndex);
 633
 634   if( mFrameDelayContainer.Count() > 0 )
 635   {
 636     unsigned int delay = mFrameDelayContainer[mCurrentFrameIndex];
 637
 638     if( mFrameDelayTimer.GetInterval() != delay )
 639     {
 640       mFrameDelayTimer.SetInterval( delay );
 641     }
 642   }
 643
 644   TextureSet textureSet;
 645   if( mImageCache )
 646   {
 647     textureSet = mImageCache->NextFrame();
 648     if( textureSet )
 649     {
 650       SetImageSize( textureSet );
 651       mImpl->mRenderer.SetTextures( textureSet );
 652     }
 653   }
 654
 655   // Keep timer ticking
 656   return true;
 657 }
 658
 659
 660 } // namespace Internal
 661
 662 } // namespace Toolkit
 663
 664 } // namespace Dali