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

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