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  *   | DoSetOnStage()
  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   mCurrentFrameIndex( 0 ),
 178   mImageUrls( NULL ),
 179   mImageCache( NULL ),
 180   mCacheSize( 1 ),
 181   mBatchSize( 1 ),
 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   map.Insert( Toolkit::Visual::Property::TYPE, Toolkit::Visual::ANIMATED_IMAGE );
 225
 226   if( mImageUrl.IsValid() )
 227   {
 228     map.Insert( Toolkit::ImageVisual::Property::URL, mImageUrl.GetUrl() );
 229   }
 230   if( mImageUrls != NULL && ! mImageUrls->empty() )
 231   {
 232     Property::Array urls;
 233     for( unsigned int i=0; i<mImageUrls->size(); ++i)
 234     {
 235       urls.Add( (*mImageUrls)[i].mUrl );
 236     }
 237     Property::Value value( const_cast<Property::Array&>(urls) );
 238     map.Insert( Toolkit::ImageVisual::Property::URL, value );
 239   }
 240
 241   map.Insert( Toolkit::ImageVisual::Property::PIXEL_AREA, mPixelArea );
 242   map.Insert( Toolkit::ImageVisual::Property::WRAP_MODE_U, mWrapModeU );
 243   map.Insert( Toolkit::ImageVisual::Property::WRAP_MODE_V, mWrapModeV );
 244
 245   map.Insert( Toolkit::ImageVisual::Property::BATCH_SIZE, static_cast<int>(mBatchSize) );
 246   map.Insert( Toolkit::ImageVisual::Property::CACHE_SIZE, static_cast<int>(mCacheSize) );
 247   map.Insert( Toolkit::ImageVisual::Property::FRAME_DELAY, static_cast<int>(mFrameDelay) );
 248   map.Insert( Toolkit::DevelImageVisual::Property::LOOP_COUNT, static_cast<int>(mLoopCount) );
 249
 250   map.Insert( Toolkit::DevelImageVisual::Property::STOP_BEHAVIOR, mStopBehavior );
 251 }
 252
 253 void AnimatedImageVisual::DoCreateInstancePropertyMap( Property::Map& map ) const
 254 {
 255   // Do nothing
 256 }
 257
 258 void AnimatedImageVisual::OnDoAction( const Dali::Property::Index actionId, const Dali::Property::Value& attributes )
 259 {
 260   // Check if action is valid for this visual type and perform action if possible
 261
 262   switch ( actionId )
 263   {
 264     case DevelAnimatedImageVisual::Action::PAUSE:
 265     {
 266       // Pause will be executed on next timer tick
 267       mActionStatus = DevelAnimatedImageVisual::Action::PAUSE;
 268       break;
 269     }
 270     case DevelAnimatedImageVisual::Action::PLAY:
 271     {
 272       if( mFrameDelayTimer && IsOnStage() && mActionStatus != DevelAnimatedImageVisual::Action::PLAY )
 273       {
 274         mFrameDelayTimer.Start();
 275       }
 276       mActionStatus = DevelAnimatedImageVisual::Action::PLAY;
 277       break;
 278     }
 279     case DevelAnimatedImageVisual::Action::STOP:
 280     {
 281       // STOP reset functionality will actually be done in a future change
 282       // Stop will be executed on next timer tick
 283       mActionStatus = DevelAnimatedImageVisual::Action::STOP;
 284       if( IsOnStage() )
 285       {
 286         DisplayNextFrame();
 287       }
 288       break;
 289     }
 290     case DevelAnimatedImageVisual::Action::JUMP_TO:
 291     {
 292       int32_t frameNumber;
 293       if( attributes.Get( frameNumber ) )
 294       {
 295         if( frameNumber < 0 || frameNumber >= static_cast<int32_t>( mFrameCount ) )
 296         {
 297           DALI_LOG_ERROR( "Invalid frame index used.\n" );
 298         }
 299         else
 300         {
 301           mIsJumpTo = true;
 302           mCurrentFrameIndex = frameNumber;
 303           if( IsOnStage() )
 304           {
 305             DisplayNextFrame();
 306           }
 307         }
 308       }
 309       break;
 310     }
 311   }
 312 }
 313
 314 void AnimatedImageVisual::DoSetProperties( const Property::Map& propertyMap )
 315 {
 316   // url[s] already passed in from constructor
 317
 318   for( Property::Map::SizeType iter = 0; iter < propertyMap.Count(); ++iter )
 319   {
 320     KeyValuePair keyValue = propertyMap.GetKeyValue( iter );
 321     if( keyValue.first.type == Property::Key::INDEX )
 322     {
 323       DoSetProperty( keyValue.first.indexKey, keyValue.second );
 324     }
 325     else
 326     {
 327       if( keyValue.first == PIXEL_AREA_UNIFORM_NAME )
 328       {
 329         DoSetProperty( Toolkit::ImageVisual::Property::PIXEL_AREA, keyValue.second );
 330       }
 331       else if( keyValue.first == IMAGE_WRAP_MODE_U )
 332       {
 333         DoSetProperty( Toolkit::ImageVisual::Property::WRAP_MODE_U, keyValue.second );
 334       }
 335       else if( keyValue.first == IMAGE_WRAP_MODE_V )
 336       {
 337         DoSetProperty( Toolkit::ImageVisual::Property::WRAP_MODE_V, keyValue.second );
 338       }
 339       else if( keyValue.first == BATCH_SIZE_NAME )
 340       {
 341         DoSetProperty( Toolkit::ImageVisual::Property::BATCH_SIZE, keyValue.second );
 342       }
 343       else if( keyValue.first == CACHE_SIZE_NAME )
 344       {
 345         DoSetProperty( Toolkit::ImageVisual::Property::CACHE_SIZE, keyValue.second );
 346       }
 347       else if( keyValue.first == FRAME_DELAY_NAME )
 348       {
 349         DoSetProperty( Toolkit::ImageVisual::Property::FRAME_DELAY, keyValue.second );
 350       }
 351       else if( keyValue.first == LOOP_COUNT_NAME )
 352       {
 353         DoSetProperty( Toolkit::DevelImageVisual::Property::LOOP_COUNT, keyValue.second );
 354       }
 355       else if( keyValue.first == STOP_BEHAVIOR_NAME )
 356       {
 357          DoSetProperty( Toolkit::DevelImageVisual::Property::STOP_BEHAVIOR, keyValue.second );
 358       }
 359     }
 360   }
 361 }
 362
 363 void AnimatedImageVisual::DoSetProperty( Property::Index index,
 364                                          const Property::Value& value )
 365 {
 366   switch(index)
 367   {
 368     case Toolkit::ImageVisual::Property::PIXEL_AREA:
 369     {
 370       value.Get( mPixelArea );
 371       break;
 372     }
 373     case Toolkit::ImageVisual::Property::WRAP_MODE_U:
 374     {
 375       int wrapMode = 0;
 376       if(Scripting::GetEnumerationProperty( value, WRAP_MODE_TABLE, WRAP_MODE_TABLE_COUNT, wrapMode ))
 377       {
 378         mWrapModeU = Dali::WrapMode::Type(wrapMode);
 379       }
 380       else
 381       {
 382         mWrapModeU = Dali::WrapMode::Type::DEFAULT;
 383       }
 384       break;
 385     }
 386     case Toolkit::ImageVisual::Property::WRAP_MODE_V:
 387     {
 388       int wrapMode = 0;
 389       if(Scripting::GetEnumerationProperty( value, WRAP_MODE_TABLE, WRAP_MODE_TABLE_COUNT, wrapMode ))
 390       {
 391         mWrapModeV = Dali::WrapMode::Type(wrapMode);
 392       }
 393       else
 394       {
 395         mWrapModeV = Dali::WrapMode::Type::DEFAULT;
 396       }
 397       break;
 398     }
 399
 400     case Toolkit::ImageVisual::Property::BATCH_SIZE:
 401     {
 402       int batchSize;
 403       if( value.Get( batchSize ) )
 404       {
 405         mBatchSize = batchSize;
 406       }
 407       break;
 408     }
 409
 410     case Toolkit::ImageVisual::Property::CACHE_SIZE:
 411     {
 412       int cacheSize;
 413       if( value.Get( cacheSize ) )
 414       {
 415         mCacheSize = cacheSize;
 416       }
 417       break;
 418     }
 419
 420     case Toolkit::ImageVisual::Property::FRAME_DELAY:
 421     {
 422       int frameDelay;
 423       if( value.Get( frameDelay ) )
 424       {
 425         mFrameDelay = frameDelay;
 426       }
 427       break;
 428     }
 429
 430     case Toolkit::DevelImageVisual::Property::LOOP_COUNT:
 431     {
 432       int loopCount;
 433       if( value.Get( loopCount ) )
 434       {
 435         mLoopCount = loopCount;
 436       }
 437       break;
 438     }
 439
 440     case Toolkit::DevelImageVisual::Property::STOP_BEHAVIOR:
 441     {
 442       int32_t stopBehavior = mStopBehavior;
 443       if( Scripting::GetEnumerationProperty( value, STOP_BEHAVIOR_TABLE, STOP_BEHAVIOR_TABLE_COUNT, stopBehavior ) )
 444       {
 445         mStopBehavior = DevelImageVisual::StopBehavior::Type( stopBehavior );
 446       }
 447       break;
 448     }
 449   }
 450 }
 451
 452 void AnimatedImageVisual::DoSetOnStage( Actor& actor )
 453 {
 454   mPlacementActor = actor;
 455   TextureSet textureSet = PrepareTextureSet();
 456   CreateRenderer(); // Always create a renderer when on stage
 457
 458   if( textureSet ) // if the image loading is successful
 459   {
 460     StartFirstFrame( textureSet );
 461   }
 462   else
 463   {
 464     mStartFirstFrame = true;
 465   }
 466 }
 467
 468 void AnimatedImageVisual::DoSetOffStage( Actor& actor )
 469 {
 470   DALI_ASSERT_DEBUG( (bool)mImpl->mRenderer && "There should always be a renderer whilst on stage");
 471
 472   if( mFrameDelayTimer )
 473   {
 474     mFrameDelayTimer.Stop();
 475     mFrameDelayTimer.Reset();
 476   }
 477
 478   actor.RemoveRenderer( mImpl->mRenderer );
 479   mImpl->mRenderer.Reset();
 480   mPlacementActor.Reset();
 481 }
 482
 483 void AnimatedImageVisual::OnSetTransform()
 484 {
 485   if( mImpl->mRenderer )
 486   {
 487     mImpl->mTransform.RegisterUniforms( mImpl->mRenderer, Direction::LEFT_TO_RIGHT );
 488   }
 489 }
 490
 491 void AnimatedImageVisual::CreateRenderer()
 492 {
 493   bool defaultWrapMode = mWrapModeU <= WrapMode::CLAMP_TO_EDGE && mWrapModeV <= WrapMode::CLAMP_TO_EDGE;
 494   bool atlasing = false;
 495   Shader shader = mImageVisualShaderFactory.GetShader( mFactoryCache, atlasing, defaultWrapMode, IsRoundedCornerRequired() );
 496
 497   Geometry geometry = mFactoryCache.GetGeometry( VisualFactoryCache::QUAD_GEOMETRY );
 498
 499   mImpl->mRenderer = Renderer::New( geometry, shader );
 500
 501   // Register transform properties
 502   mImpl->mTransform.RegisterUniforms( mImpl->mRenderer, Direction::LEFT_TO_RIGHT );
 503
 504   if( !defaultWrapMode ) // custom wrap mode
 505   {
 506     Vector2 wrapMode(mWrapModeU-WrapMode::CLAMP_TO_EDGE, mWrapModeV-WrapMode::CLAMP_TO_EDGE);
 507     wrapMode.Clamp( Vector2::ZERO, Vector2( 2.f, 2.f ) );
 508     mImpl->mRenderer.RegisterProperty( WRAP_MODE_UNIFORM_NAME, wrapMode );
 509   }
 510
 511   if( mPixelArea != FULL_TEXTURE_RECT )
 512   {
 513     mImpl->mRenderer.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, mPixelArea );
 514   }
 515
 516   mCurrentFrameIndex = 0;
 517 }
 518
 519 void AnimatedImageVisual::LoadFirstBatch()
 520 {
 521   // Ensure the batch size and cache size are no bigger than the number of URLs,
 522   // and that the cache is at least as big as the batch size.
 523   uint16_t numUrls = 0;
 524   uint16_t batchSize = 1;
 525   uint16_t cacheSize = 1;
 526
 527   if( mImageUrls )
 528   {
 529     numUrls = mImageUrls->size();
 530   }
 531   else
 532   {
 533     numUrls = mFrameCount;
 534   }
 535
 536   batchSize = std::min( mBatchSize, numUrls );
 537   cacheSize = std::min( std::max( batchSize, mCacheSize ), numUrls );
 538
 539   DALI_LOG_INFO(gAnimImgLogFilter,Debug::Concise,"AnimatedImageVisual::LoadFirstBatch()  batchSize:%d  cacheSize:%d\n", batchSize, cacheSize);
 540
 541   mUrlIndex = 0;
 542   TextureManager& textureManager = mFactoryCache.GetTextureManager();
 543
 544   if( mAnimatedImageLoading )
 545   {
 546     mImageCache = new RollingAnimatedImageCache( textureManager, mAnimatedImageLoading, mFrameCount, *this, cacheSize, batchSize );
 547   }
 548   else if( mImageUrls )
 549   {
 550     if( batchSize > 0 && cacheSize > 0 )
 551     {
 552       if( cacheSize < numUrls )
 553       {
 554         mImageCache = new RollingImageCache( textureManager, *mImageUrls, *this, cacheSize, batchSize );
 555       }
 556       else
 557       {
 558         mImageCache = new FixedImageCache( textureManager, *mImageUrls, *this, batchSize );
 559       }
 560     }
 561     else
 562     {
 563       mImageCache = new RollingImageCache( textureManager, *mImageUrls, *this, 1, 1 );
 564     }
 565   }
 566
 567   if (!mImageCache)
 568   {
 569     DALI_LOG_ERROR("mImageCache is null\n");
 570   }
 571 }
 572
 573 void AnimatedImageVisual::StartFirstFrame( TextureSet& textureSet )
 574 {
 575   DALI_LOG_INFO(gAnimImgLogFilter,Debug::Concise,"AnimatedImageVisual::StartFirstFrame()\n");
 576
 577   mStartFirstFrame = false;
 578   if(mImpl->mRenderer)
 579   {
 580     mImpl->mRenderer.SetTextures( textureSet );
 581   }
 582   Actor actor = mPlacementActor.GetHandle();
 583   if( actor )
 584   {
 585     actor.AddRenderer( mImpl->mRenderer );
 586     mPlacementActor.Reset();
 587   }
 588
 589   mCurrentFrameIndex = 0;
 590
 591   if( mFrameCount > 1 )
 592   {
 593     int frameDelay = mFrameDelay; // from URL array
 594     if( mAnimatedImageLoading && mImageCache )
 595     {
 596       frameDelay = mImageCache->GetFrameInterval( 0 );
 597     }
 598     mFrameDelayTimer = Timer::New( frameDelay );
 599     mFrameDelayTimer.TickSignal().Connect( this, &AnimatedImageVisual::DisplayNextFrame );
 600     mFrameDelayTimer.Start();
 601   }
 602   DALI_LOG_INFO(gAnimImgLogFilter,Debug::Concise,"ResourceReady(ResourceStatus::READY)\n");
 603   ResourceReady( Toolkit::Visual::ResourceStatus::READY );
 604 }
 605
 606 TextureSet AnimatedImageVisual::PrepareTextureSet()
 607 {
 608   TextureSet textureSet;
 609   if (mImageCache)
 610     textureSet = mImageCache->FirstFrame();
 611   if( textureSet )
 612   {
 613     SetImageSize( textureSet );
 614   }
 615   else
 616   {
 617     DALI_LOG_INFO(gAnimImgLogFilter,Debug::Concise,"ResourceReady(ResourceStatus::FAILED)\n");
 618     ResourceReady( Toolkit::Visual::ResourceStatus::FAILED );
 619   }
 620
 621   return textureSet;
 622 }
 623
 624 void AnimatedImageVisual::SetImageSize( TextureSet& textureSet )
 625 {
 626   if( textureSet )
 627   {
 628     Texture texture = textureSet.GetTexture( 0 );
 629     if( texture )
 630     {
 631       mImageSize.SetWidth( texture.GetWidth() );
 632       mImageSize.SetHeight( texture.GetHeight() );
 633     }
 634   }
 635 }
 636
 637 void AnimatedImageVisual::FrameReady( TextureSet textureSet )
 638 {
 639   SetImageSize( textureSet );
 640
 641   if( mStartFirstFrame )
 642   {
 643     StartFirstFrame( textureSet );
 644   }
 645   else
 646   {
 647     if(mImpl->mRenderer)
 648     {
 649       mImpl->mRenderer.SetTextures( textureSet );
 650     }
 651   }
 652 }
 653
 654 bool AnimatedImageVisual::DisplayNextFrame()
 655 {
 656   if( mIsJumpTo )
 657   {
 658     mIsJumpTo = false;
 659   }
 660   else if( mActionStatus == DevelAnimatedImageVisual::Action::PAUSE )
 661   {
 662     return false;
 663   }
 664   else if( mActionStatus == DevelAnimatedImageVisual::Action::STOP )
 665   {
 666     mCurrentLoopIndex = 0;
 667     if( mStopBehavior == DevelImageVisual::StopBehavior::FIRST_FRAME )
 668     {
 669       mCurrentFrameIndex = 0;
 670     }
 671     else if( mStopBehavior == DevelImageVisual::StopBehavior::LAST_FRAME )
 672     {
 673       mCurrentFrameIndex = mFrameCount - 1;
 674     }
 675     else
 676     {
 677       return false; // Do not draw already rendered scene twice.
 678     }
 679   }
 680   else
 681   {
 682     if( mFrameCount > 1 )
 683     {
 684       // Wrap the frame index
 685       bool finished = false;
 686       ++mCurrentFrameIndex;
 687       if( mCurrentFrameIndex >= mFrameCount )
 688       {
 689         ++mCurrentLoopIndex;
 690         finished = true;
 691       }
 692
 693       if( mLoopCount < 0 || mCurrentLoopIndex < mLoopCount)
 694       {
 695         if( finished )
 696         {
 697           mCurrentFrameIndex = 0; // Back to the first frame
 698         }
 699       }
 700       else
 701       {
 702         // This will stop timer
 703         mActionStatus = DevelAnimatedImageVisual::Action::STOP;
 704         return DisplayNextFrame();
 705       }
 706     }
 707     // TODO : newly added one.
 708     if( mAnimatedImageLoading && mImageCache )
 709     {
 710       unsigned int delay = mImageCache->GetFrameInterval( mCurrentFrameIndex );
 711       if( mFrameDelayTimer.GetInterval() != delay )
 712       {
 713         mFrameDelayTimer.SetInterval( delay );
 714       }
 715     }
 716   }
 717
 718   DALI_LOG_INFO( gAnimImgLogFilter,Debug::Concise,"AnimatedImageVisual::DisplayNextFrame(this:%p) CurrentFrameIndex:%d\n", this, mCurrentFrameIndex);
 719
 720   TextureSet textureSet;
 721   if( mImageCache )
 722   {
 723     textureSet = mImageCache->Frame( mCurrentFrameIndex );
 724     if( textureSet )
 725     {
 726       SetImageSize( textureSet );
 727       mImpl->mRenderer.SetTextures( textureSet );
 728     }
 729   }
 730
 731   return ( mActionStatus == DevelAnimatedImageVisual::Action::PLAY ) ? true : false;
 732 }
 733
 734
 735 } // namespace Internal
 736
 737 } // namespace Toolkit
 738
 739 } // namespace Dali