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