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

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