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/devel-api/visuals/image-visual-properties-devel.h>
  29 #include <dali-toolkit/devel-api/visuals/visual-properties-devel.h>
  30 #include <dali-toolkit/internal/visuals/visual-factory-impl.h>
  31 #include <dali-toolkit/internal/visuals/visual-factory-cache.h>
  32 #include <dali-toolkit/internal/visuals/visual-string-constants.h>
  33 #include <dali-toolkit/internal/visuals/visual-base-data-impl.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/image/image-visual.h>
  37 #include <dali-toolkit/devel-api/image-loader/image-atlas.h>
  38
  39 namespace Dali
  40 {
  41
  42 namespace Toolkit
  43 {
  44
  45 namespace Internal
  46 {
  47
  48 namespace
  49 {
  50 // wrap modes
  51 DALI_ENUM_TO_STRING_TABLE_BEGIN( WRAP_MODE )
  52 DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::WrapMode, DEFAULT )
  53 DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::WrapMode, CLAMP_TO_EDGE )
  54 DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::WrapMode, REPEAT )
  55 DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::WrapMode, MIRRORED_REPEAT )
  56 DALI_ENUM_TO_STRING_TABLE_END( WRAP_MODE )
  57
  58 const Vector4 FULL_TEXTURE_RECT(0.f, 0.f, 1.f, 1.f);
  59
  60 #if defined(DEBUG_ENABLED)
  61 Debug::Filter* gAnimImgLogFilter = Debug::Filter::New(Debug::NoLogging, false, "LOG_ANIMATED_IMAGE");
  62 #endif
  63 }
  64
  65
  66 /**
  67  * Multi-image  Flow of execution
  68  *
  69  *   | DoSetProperties()
  70  *   |   LoadFirstBatch()
  71  *   |     cache->LoadBatch()
  72  *   |
  73  *   | DoSetOnStage()
  74  *   |   CreateRenderer()    (Doesn't become ready until first frame loads)
  75  *   |
  76  *   | FrameReady(textureSet)
  77  *   |   start first frame:
  78  *   |     actor.AddRenderer
  79  *   |     start timer
  80  *   |   mRenderer.SetTextures(textureSet)
  81  *   |
  82  *   | Timer ticks
  83  *   |   DisplayNextFrame()
  84  *   |     if front frame is ready,
  85  *   |       mRenderer.SetTextures( front frame's texture )
  86  *   |     else
  87  *   |       mWaitingForTexture=true
  88  *   |     cache->LoadBatch()
  89  *   |
  90  *   | FrameReady(textureSet)
  91  *   |   mRenderer.SetTextures(textureSet)
  92  *   V
  93  *  Time
  94  */
  95
  96 AnimatedImageVisualPtr AnimatedImageVisual::New( VisualFactoryCache& factoryCache, const VisualUrl& imageUrl, const Property::Map& properties )
  97 {
  98   AnimatedImageVisual* visual = new AnimatedImageVisual( factoryCache );
  99   visual->mImageUrl = imageUrl;
 100   visual->SetProperties( properties );
 101
 102   return visual;
 103 }
 104
 105 AnimatedImageVisualPtr AnimatedImageVisual::New( VisualFactoryCache& factoryCache, const Property::Array& imageUrls, const Property::Map& properties )
 106 {
 107   AnimatedImageVisual* visual = new AnimatedImageVisual( factoryCache );
 108   visual->mImageUrls = new ImageCache::UrlList();
 109   visual->mImageUrls->reserve( imageUrls.Count() );
 110
 111   for( unsigned int i=0; i < imageUrls.Count(); ++i)
 112   {
 113     ImageCache::UrlStore urlStore;
 114     urlStore.mTextureId = TextureManager::INVALID_TEXTURE_ID;
 115     urlStore.mUrl = imageUrls[i].Get<std::string>();
 116     visual->mImageUrls->push_back( urlStore );
 117   }
 118
 119   visual->SetProperties( properties );
 120   // starts loading immediately
 121   return visual;
 122 }
 123
 124 AnimatedImageVisualPtr AnimatedImageVisual::New( VisualFactoryCache& factoryCache, const VisualUrl& imageUrl )
 125 {
 126   AnimatedImageVisual* visual = new AnimatedImageVisual( factoryCache );
 127   visual->mImageUrl = imageUrl;
 128
 129   return visual;
 130 }
 131
 132 AnimatedImageVisual::AnimatedImageVisual( VisualFactoryCache& factoryCache )
 133 : Visual::Base( factoryCache ),
 134   mFrameDelayTimer(),
 135   mPlacementActor(),
 136   mPixelArea( FULL_TEXTURE_RECT ),
 137   mImageUrl(),
 138   mCurrentFrameIndex( 0 ),
 139   mImageUrls( NULL ),
 140   mImageCache( NULL ),
 141   mCacheSize( 1 ),
 142   mBatchSize( 1 ),
 143   mFrameDelay( 100 ),
 144   mUrlIndex( 0 ),
 145   mImageSize(),
 146   mWrapModeU( WrapMode::DEFAULT ),
 147   mWrapModeV( WrapMode::DEFAULT ),
 148   mStartFirstFrame(false)
 149 {}
 150
 151 AnimatedImageVisual::~AnimatedImageVisual()
 152 {
 153   delete mImageCache;
 154   delete mImageUrls;
 155 }
 156
 157 void AnimatedImageVisual::GetNaturalSize( Vector2& naturalSize )
 158 {
 159   if( mImageSize.GetWidth() == 0 &&  mImageSize.GetHeight() == 0)
 160   {
 161     if( mImageUrl.IsValid() )
 162     {
 163       mImageSize = Dali::GetGifImageSize( mImageUrl.GetUrl() );
 164     }
 165     else if( mImageUrls && mImageUrls->size() > 0 )
 166     {
 167       mImageSize = Dali::GetClosestImageSize( (*mImageUrls)[0].mUrl );
 168     }
 169   }
 170
 171   naturalSize.width = mImageSize.GetWidth();
 172   naturalSize.height = mImageSize.GetHeight();
 173 }
 174
 175 void AnimatedImageVisual::DoCreatePropertyMap( Property::Map& map ) const
 176 {
 177   map.Clear();
 178
 179   map.Insert( Toolkit::DevelVisual::Property::TYPE, Toolkit::DevelVisual::ANIMATED_IMAGE );
 180
 181   if( mImageUrl.IsValid() )
 182   {
 183     map.Insert( Toolkit::ImageVisual::Property::URL, mImageUrl.GetUrl() );
 184   }
 185   if( mImageUrls != NULL && ! mImageUrls->empty() )
 186   {
 187     Property::Array urls;
 188     for( unsigned int i=0; i<mImageUrls->size(); ++i)
 189     {
 190       urls.Add( (*mImageUrls)[i].mUrl );
 191     }
 192     Property::Value value( const_cast<Property::Array&>(urls) );
 193     map.Insert( Toolkit::ImageVisual::Property::URL, value );
 194   }
 195
 196   map.Insert( Toolkit::ImageVisual::Property::PIXEL_AREA, mPixelArea );
 197   map.Insert( Toolkit::ImageVisual::Property::WRAP_MODE_U, mWrapModeU );
 198   map.Insert( Toolkit::ImageVisual::Property::WRAP_MODE_V, mWrapModeV );
 199
 200   map.Insert( Toolkit::DevelImageVisual::Property::BATCH_SIZE, static_cast<int>(mBatchSize) );
 201   map.Insert( Toolkit::DevelImageVisual::Property::CACHE_SIZE, static_cast<int>(mCacheSize) );
 202   map.Insert( Toolkit::DevelImageVisual::Property::FRAME_DELAY, static_cast<int>(mFrameDelay) );
 203 }
 204
 205 void AnimatedImageVisual::DoCreateInstancePropertyMap( Property::Map& map ) const
 206 {
 207   // Do nothing
 208 }
 209
 210 void AnimatedImageVisual::DoSetProperties( const Property::Map& propertyMap )
 211 {
 212   // url[s] already passed in from constructor
 213
 214   for( Property::Map::SizeType iter = 0; iter < propertyMap.Count(); ++iter )
 215   {
 216     KeyValuePair keyValue = propertyMap.GetKeyValue( iter );
 217     if( keyValue.first.type == Property::Key::INDEX )
 218     {
 219       DoSetProperty( keyValue.first.indexKey, keyValue.second );
 220     }
 221     else
 222     {
 223       if( keyValue.first == PIXEL_AREA_UNIFORM_NAME )
 224       {
 225         DoSetProperty( Toolkit::ImageVisual::Property::PIXEL_AREA, keyValue.second );
 226       }
 227       else if( keyValue.first == IMAGE_WRAP_MODE_U )
 228       {
 229         DoSetProperty( Toolkit::ImageVisual::Property::WRAP_MODE_U, keyValue.second );
 230       }
 231       else if( keyValue.first == IMAGE_WRAP_MODE_V )
 232       {
 233         DoSetProperty( Toolkit::ImageVisual::Property::WRAP_MODE_V, keyValue.second );
 234       }
 235       else if( keyValue.first == BATCH_SIZE_NAME )
 236       {
 237         DoSetProperty( Toolkit::DevelImageVisual::Property::BATCH_SIZE, keyValue.second );
 238       }
 239       else if( keyValue.first == CACHE_SIZE_NAME )
 240       {
 241         DoSetProperty( Toolkit::DevelImageVisual::Property::CACHE_SIZE, keyValue.second );
 242       }
 243       else if( keyValue.first == FRAME_DELAY_NAME )
 244       {
 245         DoSetProperty( Toolkit::DevelImageVisual::Property::FRAME_DELAY, keyValue.second );
 246       }
 247     }
 248   }
 249
 250   if( mImageUrls && mImageUrls->size() > 0 )
 251   {
 252     LoadFirstBatch();
 253   }
 254 }
 255
 256 void AnimatedImageVisual::DoSetProperty( Property::Index index,
 257                                          const Property::Value& value )
 258 {
 259   switch(index)
 260   {
 261     case Toolkit::ImageVisual::Property::PIXEL_AREA:
 262     {
 263       value.Get( mPixelArea );
 264       break;
 265     }
 266     case Toolkit::ImageVisual::Property::WRAP_MODE_U:
 267     {
 268       int wrapMode;
 269       if(Scripting::GetEnumerationProperty( value, WRAP_MODE_TABLE, WRAP_MODE_TABLE_COUNT, wrapMode ))
 270       {
 271         mWrapModeU = Dali::WrapMode::Type(wrapMode);
 272       }
 273       else
 274       {
 275         mWrapModeU = Dali::WrapMode::Type::DEFAULT;
 276       }
 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::DevelImageVisual::Property::BATCH_SIZE:
 293     {
 294       int batchSize;
 295       if( value.Get( batchSize ) )
 296       {
 297         mBatchSize = batchSize;
 298       }
 299       break;
 300     }
 301
 302     case Toolkit::DevelImageVisual::Property::CACHE_SIZE:
 303     {
 304       int cacheSize;
 305       if( value.Get( cacheSize ) )
 306       {
 307         mCacheSize = cacheSize;
 308       }
 309       break;
 310     }
 311
 312     case Toolkit::DevelImageVisual::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.IsLocal() )
 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