X-Git-Url: http://review.tizen.org/git/?p=platform%2Fcore%2Fuifw%2Fdali-toolkit.git;a=blobdiff_plain;f=dali-toolkit%2Finternal%2Fvisuals%2Fanimated-image%2Fanimated-image-visual.cpp;h=7c933ce5c7c64caded05539793fe9bdb31c22bcb;hp=0ba78331f546c8623061d95d3de37cf944663d64;hb=5280d715c0311735599fc9ef14bdd8b4efa293eb;hpb=6fa08daf440e496896babb230e404aae7e77a5bb

diff --git a/dali-toolkit/internal/visuals/animated-image/animated-image-visual.cpp b/dali-toolkit/internal/visuals/animated-image/animated-image-visual.cpp
index 0ba7833..7c933ce 100644
--- a/dali-toolkit/internal/visuals/animated-image/animated-image-visual.cpp
+++ b/dali-toolkit/internal/visuals/animated-image/animated-image-visual.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2017 Samsung Electronics Co., Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -20,14 +20,19 @@
 
 // EXTERNAL INCLUDES
 #include <dali/devel-api/adaptor-framework/gif-loading.h>
+#include <dali/devel-api/adaptor-framework/image-loading.h>
+#include <dali/integration-api/debug.h>
 
 // INTERNAL INCLUDES
 #include <dali-toolkit/public-api/visuals/image-visual-properties.h>
+#include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
 #include <dali-toolkit/devel-api/visuals/visual-properties-devel.h>
 #include <dali-toolkit/internal/visuals/visual-factory-impl.h>
 #include <dali-toolkit/internal/visuals/visual-factory-cache.h>
 #include <dali-toolkit/internal/visuals/visual-string-constants.h>
 #include <dali-toolkit/internal/visuals/visual-base-data-impl.h>
+#include <dali-toolkit/internal/visuals/animated-image/fixed-image-cache.h>
+#include <dali-toolkit/internal/visuals/animated-image/rolling-image-cache.h>
 #include <dali-toolkit/internal/visuals/image/image-visual.h>
 #include <dali-toolkit/devel-api/image-loader/image-atlas.h>
 
@@ -52,8 +57,42 @@ DALI_ENUM_TO_STRING_TABLE_END( WRAP_MODE )
 
 const Vector4 FULL_TEXTURE_RECT(0.f, 0.f, 1.f, 1.f);
 
+#if defined(DEBUG_ENABLED)
+Debug::Filter* gAnimImgLogFilter = Debug::Filter::New(Debug::NoLogging, false, "LOG_ANIMATED_IMAGE");
+#endif
 }
 
+
+/**
+ * Multi-image  Flow of execution
+ *
+ *   | DoSetProperties()
+ *   |   LoadFirstBatch()
+ *   |     cache->LoadBatch()
+ *   |
+ *   | DoSetOnStage()
+ *   |   CreateRenderer()    (Doesn't become ready until first frame loads)
+ *   |
+ *   | FrameReady(textureSet)
+ *   |   start first frame:
+ *   |     actor.AddRenderer
+ *   |     start timer
+ *   |   mRenderer.SetTextures(textureSet)
+ *   |
+ *   | Timer ticks
+ *   |   DisplayNextFrame()
+ *   |     if front frame is ready,
+ *   |       mRenderer.SetTextures( front frame's texture )
+ *   |     else
+ *   |       mWaitingForTexture=true
+ *   |     cache->LoadBatch()
+ *   |
+ *   | FrameReady(textureSet)
+ *   |   mRenderer.SetTextures(textureSet)
+ *   V
+ *  Time
+ */
+
 AnimatedImageVisualPtr AnimatedImageVisual::New( VisualFactoryCache& factoryCache, const VisualUrl& imageUrl, const Property::Map& properties )
 {
   AnimatedImageVisual* visual = new AnimatedImageVisual( factoryCache );
@@ -63,6 +102,25 @@ AnimatedImageVisualPtr AnimatedImageVisual::New( VisualFactoryCache& factoryCach
   return visual;
 }
 
+AnimatedImageVisualPtr AnimatedImageVisual::New( VisualFactoryCache& factoryCache, const Property::Array& imageUrls, const Property::Map& properties )
+{
+  AnimatedImageVisual* visual = new AnimatedImageVisual( factoryCache );
+  visual->mImageUrls = new ImageCache::UrlList();
+  visual->mImageUrls->reserve( imageUrls.Count() );
+
+  for( unsigned int i=0; i < imageUrls.Count(); ++i)
+  {
+    ImageCache::UrlStore urlStore;
+    urlStore.mTextureId = TextureManager::INVALID_TEXTURE_ID;
+    urlStore.mUrl = imageUrls[i].Get<std::string>();
+    visual->mImageUrls->push_back( urlStore );
+  }
+
+  visual->SetProperties( properties );
+  // starts loading immediately
+  return visual;
+}
+
 AnimatedImageVisualPtr AnimatedImageVisual::New( VisualFactoryCache& factoryCache, const VisualUrl& imageUrl )
 {
   AnimatedImageVisual* visual = new AnimatedImageVisual( factoryCache );
@@ -74,23 +132,40 @@ AnimatedImageVisualPtr AnimatedImageVisual::New( VisualFactoryCache& factoryCach
 AnimatedImageVisual::AnimatedImageVisual( VisualFactoryCache& factoryCache )
 : Visual::Base( factoryCache ),
   mFrameDelayTimer(),
+  mPlacementActor(),
   mPixelArea( FULL_TEXTURE_RECT ),
   mImageUrl(),
-  mImageSize(),
   mCurrentFrameIndex( 0 ),
+  mImageUrls( NULL ),
+  mImageCache( NULL ),
+  mCacheSize( 1 ),
+  mBatchSize( 1 ),
+  mFrameDelay( 100 ),
+  mUrlIndex( 0 ),
+  mImageSize(),
   mWrapModeU( WrapMode::DEFAULT ),
-  mWrapModeV( WrapMode::DEFAULT )
+  mWrapModeV( WrapMode::DEFAULT ),
+  mStartFirstFrame(false)
 {}
 
 AnimatedImageVisual::~AnimatedImageVisual()
 {
+  delete mImageCache;
+  delete mImageUrls;
 }
 
 void AnimatedImageVisual::GetNaturalSize( Vector2& naturalSize )
 {
   if( mImageSize.GetWidth() == 0 &&  mImageSize.GetHeight() == 0)
   {
-    mImageSize = Dali::GetGifImageSize( mImageUrl.GetUrl() );
+    if( mImageUrl.IsValid() )
+    {
+      mImageSize = Dali::GetGifImageSize( mImageUrl.GetUrl() );
+    }
+    else if( mImageUrls && mImageUrls->size() > 0 )
+    {
+      mImageSize = Dali::GetClosestImageSize( (*mImageUrls)[0].mUrl );
+    }
   }
 
   naturalSize.width = mImageSize.GetWidth();
@@ -107,10 +182,24 @@ void AnimatedImageVisual::DoCreatePropertyMap( Property::Map& map ) const
   {
     map.Insert( Toolkit::ImageVisual::Property::URL, mImageUrl.GetUrl() );
   }
+  if( mImageUrls != NULL && ! mImageUrls->empty() )
+  {
+    Property::Array urls;
+    for( unsigned int i=0; i<mImageUrls->size(); ++i)
+    {
+      urls.Add( (*mImageUrls)[i].mUrl );
+    }
+    Property::Value value( const_cast<Property::Array&>(urls) );
+    map.Insert( Toolkit::ImageVisual::Property::URL, value );
+  }
 
   map.Insert( Toolkit::ImageVisual::Property::PIXEL_AREA, mPixelArea );
   map.Insert( Toolkit::ImageVisual::Property::WRAP_MODE_U, mWrapModeU );
   map.Insert( Toolkit::ImageVisual::Property::WRAP_MODE_V, mWrapModeV );
+
+  map.Insert( Toolkit::DevelImageVisual::Property::BATCH_SIZE, static_cast<int>(mBatchSize) );
+  map.Insert( Toolkit::DevelImageVisual::Property::CACHE_SIZE, static_cast<int>(mCacheSize) );
+  map.Insert( Toolkit::DevelImageVisual::Property::FRAME_DELAY, static_cast<int>(mFrameDelay) );
 }
 
 void AnimatedImageVisual::DoCreateInstancePropertyMap( Property::Map& map ) const
@@ -120,84 +209,137 @@ void AnimatedImageVisual::DoCreateInstancePropertyMap( Property::Map& map ) cons
 
 void AnimatedImageVisual::DoSetProperties( const Property::Map& propertyMap )
 {
-  // url already passed in from constructor
+  // url[s] already passed in from constructor
 
-  Property::Value* pixelAreaValue = propertyMap.Find( Toolkit::ImageVisual::Property::PIXEL_AREA, PIXEL_AREA_UNIFORM_NAME );
-  if( pixelAreaValue )
+  for( Property::Map::SizeType iter = 0; iter < propertyMap.Count(); ++iter )
   {
-    pixelAreaValue->Get( mPixelArea );
-  }
-
-  Property::Value* wrapModeValueU = propertyMap.Find( Toolkit::ImageVisual::Property::WRAP_MODE_U, IMAGE_WRAP_MODE_U );
-  if( wrapModeValueU )
-  {
-    int value;
-    Scripting::GetEnumerationProperty( *wrapModeValueU, WRAP_MODE_TABLE, WRAP_MODE_TABLE_COUNT, value );
-    mWrapModeU = Dali::WrapMode::Type( value );
+    KeyValuePair keyValue = propertyMap.GetKeyValue( iter );
+    if( keyValue.first.type == Property::Key::INDEX )
+    {
+      DoSetProperty( keyValue.first.indexKey, keyValue.second );
+    }
+    else
+    {
+      if( keyValue.first == PIXEL_AREA_UNIFORM_NAME )
+      {
+        DoSetProperty( Toolkit::ImageVisual::Property::PIXEL_AREA, keyValue.second );
+      }
+      else if( keyValue.first == IMAGE_WRAP_MODE_U )
+      {
+        DoSetProperty( Toolkit::ImageVisual::Property::WRAP_MODE_U, keyValue.second );
+      }
+      else if( keyValue.first == IMAGE_WRAP_MODE_V )
+      {
+        DoSetProperty( Toolkit::ImageVisual::Property::WRAP_MODE_V, keyValue.second );
+      }
+      else if( keyValue.first == BATCH_SIZE_NAME )
+      {
+        DoSetProperty( Toolkit::DevelImageVisual::Property::BATCH_SIZE, keyValue.second );
+      }
+      else if( keyValue.first == CACHE_SIZE_NAME )
+      {
+        DoSetProperty( Toolkit::DevelImageVisual::Property::CACHE_SIZE, keyValue.second );
+      }
+      else if( keyValue.first == FRAME_DELAY_NAME )
+      {
+        DoSetProperty( Toolkit::DevelImageVisual::Property::FRAME_DELAY, keyValue.second );
+      }
+    }
   }
 
-  Property::Value* wrapModeValueV = propertyMap.Find( Toolkit::ImageVisual::Property::WRAP_MODE_V, IMAGE_WRAP_MODE_V );
-  if( wrapModeValueV )
+  if( mImageUrls && mImageUrls->size() > 0 )
   {
-    int value;
-    Scripting::GetEnumerationProperty( *wrapModeValueV, WRAP_MODE_TABLE, WRAP_MODE_TABLE_COUNT, value );
-    mWrapModeV = Dali::WrapMode::Type( value );
+    LoadFirstBatch();
   }
 }
 
-void AnimatedImageVisual::DoSetOnStage( Actor& actor )
+void AnimatedImageVisual::DoSetProperty( Property::Index index,
+                                         const Property::Value& value )
 {
-  Texture texture = PrepareAnimatedImage();
-  if( texture ) // if the image loading is successful
+  switch(index)
   {
-    bool defaultWrapMode = mWrapModeU <= WrapMode::CLAMP_TO_EDGE && mWrapModeV <= WrapMode::CLAMP_TO_EDGE;
-    Shader shader = ImageVisual::GetImageShader( mFactoryCache, true, defaultWrapMode );
-
-    Geometry geometry = mFactoryCache.GetGeometry( VisualFactoryCache::QUAD_GEOMETRY );
-
-    TextureSet textureSet = TextureSet::New();
-    textureSet.SetTexture( 0u, texture );
-
-    mImpl->mRenderer = Renderer::New( geometry, shader );
-    mImpl->mRenderer.SetTextures( textureSet );
-
-    // Register transform properties
-    mImpl->mTransform.RegisterUniforms( mImpl->mRenderer, Direction::LEFT_TO_RIGHT );
+    case Toolkit::ImageVisual::Property::PIXEL_AREA:
+    {
+      value.Get( mPixelArea );
+      break;
+    }
+    case Toolkit::ImageVisual::Property::WRAP_MODE_U:
+    {
+      int wrapMode;
+      if(Scripting::GetEnumerationProperty( value, WRAP_MODE_TABLE, WRAP_MODE_TABLE_COUNT, wrapMode ))
+      {
+        mWrapModeU = Dali::WrapMode::Type(wrapMode);
+      }
+      else
+      {
+        mWrapModeU = Dali::WrapMode::Type::DEFAULT;
+      }
+    }
+    case Toolkit::ImageVisual::Property::WRAP_MODE_V:
+    {
+      int wrapMode;
+      if(Scripting::GetEnumerationProperty( value, WRAP_MODE_TABLE, WRAP_MODE_TABLE_COUNT, wrapMode ))
+      {
+        mWrapModeV = Dali::WrapMode::Type(wrapMode);
+      }
+      else
+      {
+        mWrapModeV = Dali::WrapMode::Type::DEFAULT;
+      }
+      break;
+    }
 
-    if( !defaultWrapMode ) // custom wrap mode
+    case Toolkit::DevelImageVisual::Property::BATCH_SIZE:
     {
-      Vector2 wrapMode(mWrapModeU-WrapMode::CLAMP_TO_EDGE, mWrapModeV-WrapMode::CLAMP_TO_EDGE);
-      wrapMode.Clamp( Vector2::ZERO, Vector2( 2.f, 2.f ) );
-      mImpl->mRenderer.RegisterProperty( WRAP_MODE_UNIFORM_NAME, wrapMode );
+      int batchSize;
+      if( value.Get( batchSize ) )
+      {
+        mBatchSize = batchSize;
+      }
+      break;
     }
 
-    if( mPixelArea != FULL_TEXTURE_RECT )
+    case Toolkit::DevelImageVisual::Property::CACHE_SIZE:
     {
-      mImpl->mRenderer.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, mPixelArea );
+      int cacheSize;
+      if( value.Get( cacheSize ) )
+      {
+        mCacheSize = cacheSize;
+      }
+      break;
     }
 
-    mCurrentFrameIndex = 0;
-    mImpl->mRenderer.RegisterProperty( ATLAS_RECT_UNIFORM_NAME, mTextureRectContainer[mCurrentFrameIndex] );
-    if( mFrameDelayContainer.Count() > 1 )
+    case Toolkit::DevelImageVisual::Property::FRAME_DELAY:
     {
-      mFrameDelayTimer = Timer::New( mFrameDelayContainer[0] );
-      mFrameDelayTimer.TickSignal().Connect( this, &AnimatedImageVisual::DisplayNextFrame );
-      mFrameDelayTimer.Start();
+      int frameDelay;
+      if( value.Get( frameDelay ) )
+      {
+        mFrameDelay = frameDelay;
+      }
+      break;
     }
+  }
+}
 
-    actor.AddRenderer( mImpl->mRenderer );
+void AnimatedImageVisual::DoSetOnStage( Actor& actor )
+{
+  mPlacementActor = actor;
+  TextureSet textureSet = PrepareTextureSet();
+  CreateRenderer(); // Always create a renderer when on stage
 
-    // Animated Image loaded and ready to display
-    ResourceReady();
+  if( textureSet ) // if the image loading is successful
+  {
+    StartFirstFrame( textureSet );
+  }
+  else
+  {
+    mStartFirstFrame = true;
   }
 }
 
 void AnimatedImageVisual::DoSetOffStage( Actor& actor )
 {
-  if( !mImpl->mRenderer )
-  {
-    return;
-  }
+  DALI_ASSERT_DEBUG( (bool)mImpl->mRenderer && "There should always be a renderer whilst on stage");
 
   if( mFrameDelayTimer )
   {
@@ -210,6 +352,7 @@ void AnimatedImageVisual::DoSetOffStage( Actor& actor )
 
   actor.RemoveRenderer( mImpl->mRenderer );
   mImpl->mRenderer.Reset();
+  mPlacementActor.Reset();
 }
 
 void AnimatedImageVisual::OnSetTransform()
@@ -220,8 +363,117 @@ void AnimatedImageVisual::OnSetTransform()
   }
 }
 
-Texture AnimatedImageVisual::PrepareAnimatedImage()
+void AnimatedImageVisual::CreateRenderer()
 {
+  bool defaultWrapMode = mWrapModeU <= WrapMode::CLAMP_TO_EDGE && mWrapModeV <= WrapMode::CLAMP_TO_EDGE;
+  bool atlasing = (mTextureRectContainer.Count() > 0) ;
+  Shader shader = ImageVisual::GetImageShader( mFactoryCache, atlasing, defaultWrapMode );
+
+  Geometry geometry = mFactoryCache.GetGeometry( VisualFactoryCache::QUAD_GEOMETRY );
+
+  mImpl->mRenderer = Renderer::New( geometry, shader );
+
+  // Register transform properties
+  mImpl->mTransform.RegisterUniforms( mImpl->mRenderer, Direction::LEFT_TO_RIGHT );
+
+  if( !defaultWrapMode ) // custom wrap mode
+  {
+    Vector2 wrapMode(mWrapModeU-WrapMode::CLAMP_TO_EDGE, mWrapModeV-WrapMode::CLAMP_TO_EDGE);
+    wrapMode.Clamp( Vector2::ZERO, Vector2( 2.f, 2.f ) );
+    mImpl->mRenderer.RegisterProperty( WRAP_MODE_UNIFORM_NAME, wrapMode );
+  }
+
+  if( mPixelArea != FULL_TEXTURE_RECT )
+  {
+    mImpl->mRenderer.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, mPixelArea );
+  }
+
+  mCurrentFrameIndex = 0;
+
+  if( mTextureRectContainer.Count() > 0 )
+  {
+    mImpl->mRenderer.RegisterProperty( ATLAS_RECT_UNIFORM_NAME, mTextureRectContainer[mCurrentFrameIndex] );
+  }
+}
+
+void AnimatedImageVisual::LoadFirstBatch()
+{
+  DALI_LOG_INFO(gAnimImgLogFilter,Debug::Concise,"AnimatedImageVisual::LoadFirstBatch()\n");
+
+  // Ensure the batch size and cache size are no bigger than the number of URLs,
+  // and that the cache is at least as big as the batch size.
+  uint16_t numUrls = mImageUrls->size();
+  uint16_t batchSize = std::min( mBatchSize, numUrls );
+  uint16_t cacheSize = std::min( std::max( batchSize, mCacheSize ), numUrls );
+
+  mUrlIndex = 0;
+  TextureManager& textureManager = mFactoryCache.GetTextureManager();
+
+  if( batchSize > 0 && cacheSize > 0 )
+  {
+    if( cacheSize < numUrls )
+    {
+      mImageCache = new RollingImageCache( textureManager, *mImageUrls, *this, cacheSize, batchSize );
+    }
+    else
+    {
+      mImageCache = new FixedImageCache( textureManager, *mImageUrls, *this, batchSize );
+    }
+  }
+  else
+  {
+    mImageCache = new RollingImageCache( textureManager, *mImageUrls, *this, 1, 1 );
+  }
+}
+
+void AnimatedImageVisual::StartFirstFrame( TextureSet& textureSet )
+{
+  DALI_LOG_INFO(gAnimImgLogFilter,Debug::Concise,"AnimatedImageVisual::StartFirstFrame()\n");
+
+  mStartFirstFrame = false;
+  mImpl->mRenderer.SetTextures( textureSet );
+  Actor actor = mPlacementActor.GetHandle();
+  if( actor )
+  {
+    actor.AddRenderer( mImpl->mRenderer );
+    mPlacementActor.Reset();
+  }
+
+  int frameDelay = mFrameDelay;
+  if( mFrameDelayContainer.Count() > 1 )
+  {
+    frameDelay = mFrameDelayContainer[0];
+  }
+  mFrameDelayTimer = Timer::New( frameDelay );
+  mFrameDelayTimer.TickSignal().Connect( this, &AnimatedImageVisual::DisplayNextFrame );
+  mFrameDelayTimer.Start();
+
+  DALI_LOG_INFO(gAnimImgLogFilter,Debug::Concise,"ResourceReady()\n");
+  ResourceReady();
+}
+
+TextureSet AnimatedImageVisual::PrepareTextureSet()
+{
+  TextureSet textureSet;
+  if( mImageUrl.IsValid() )
+  {
+    textureSet = PrepareAnimatedGifImage();
+  }
+  else
+  {
+    textureSet = mImageCache->FirstFrame();
+    if( textureSet )
+    {
+      SetImageSize( textureSet );
+    }
+  }
+  return textureSet;
+}
+
+TextureSet AnimatedImageVisual::PrepareAnimatedGifImage()
+{
+  TextureSet textureSet;
+
   // load from image file
   std::vector<Dali::PixelData> pixelDataList;
 
@@ -232,22 +484,70 @@ Texture AnimatedImageVisual::PrepareAnimatedImage()
       mImageSize.SetWidth( pixelDataList[0].GetWidth() );
       mImageSize.SetHeight( pixelDataList[0].GetHeight() );
 
-      return Toolkit::ImageAtlas::PackToAtlas( pixelDataList, mTextureRectContainer );
+      Texture texture = Toolkit::ImageAtlas::PackToAtlas( pixelDataList, mTextureRectContainer );
+      textureSet = TextureSet::New();
+      textureSet.SetTexture( 0, texture );
     }
   }
 
-  return Texture();
+  return textureSet;
+}
+
+void AnimatedImageVisual::SetImageSize( TextureSet& textureSet )
+{
+  if( textureSet )
+  {
+    Texture texture = textureSet.GetTexture( 0 );
+    if( texture )
+    {
+      mImageSize.SetWidth( texture.GetWidth() );
+      mImageSize.SetHeight( texture.GetHeight() );
+    }
+  }
+}
+
+void AnimatedImageVisual::FrameReady( TextureSet textureSet )
+{
+  SetImageSize( textureSet );
+
+  if( mStartFirstFrame )
+  {
+    StartFirstFrame( textureSet );
+  }
+  else
+  {
+    mImpl->mRenderer.SetTextures( textureSet );
+  }
 }
 
 bool AnimatedImageVisual::DisplayNextFrame()
 {
-  mCurrentFrameIndex = (mCurrentFrameIndex+1) % mFrameDelayContainer.Count();
-  mImpl->mRenderer.RegisterProperty( ATLAS_RECT_UNIFORM_NAME, mTextureRectContainer[mCurrentFrameIndex] );
-  if( mFrameDelayTimer.GetInterval() != mFrameDelayContainer[mCurrentFrameIndex] )
+  DALI_LOG_INFO(gAnimImgLogFilter,Debug::Concise,"AnimatedImageVisual::DisplayNextFrame() start\n");
+
+  if( mFrameDelayContainer.Count() > 0 )
+  {
+    // Wrap the frame index
+    ++mCurrentFrameIndex;
+    mCurrentFrameIndex %= mFrameDelayContainer.Count();
+
+    mImpl->mRenderer.RegisterProperty( ATLAS_RECT_UNIFORM_NAME, mTextureRectContainer[mCurrentFrameIndex] );
+
+    if( mFrameDelayTimer.GetInterval() != mFrameDelayContainer[mCurrentFrameIndex] )
+    {
+      mFrameDelayTimer.SetInterval( mFrameDelayContainer[mCurrentFrameIndex] );
+    }
+  }
+  else if( mImageCache )
   {
-    mFrameDelayTimer.SetInterval( mFrameDelayContainer[mCurrentFrameIndex] );
+    TextureSet textureSet = mImageCache->NextFrame();
+    if( textureSet )
+    {
+      SetImageSize( textureSet );
+      mImpl->mRenderer.SetTextures( textureSet );
+    }
   }
 
+  // Keep timer ticking
   return true;
 }