ImageVisual Load policy

[platform/core/uifw/dali-toolkit.git] / dali-toolkit / internal / visuals / image / image-visual.cpp

diff --git a/dali-toolkit/internal/visuals/image/image-visual.cpp b/dali-toolkit/internal/visuals/image/image-visual.cpp
index 7ce2f23..9522618 100644 (file)
--- a/dali-toolkit/internal/visuals/image/image-visual.cpp
+++ b/dali-toolkit/internal/visuals/image/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.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.


@@ -21,6 +21,7 @@
 // EXTERNAL HEADERS
 #include <cstring> // for strlen()
 #include <dali/public-api/actors/layer.h>
 // EXTERNAL HEADERS
 #include <cstring> // for strlen()
 #include <dali/public-api/actors/layer.h>

+#include <dali/public-api/common/stage.h>

 #include <dali/public-api/images/resource-image.h>
 #include <dali/public-api/images/native-image.h>
 #include <dali/devel-api/images/texture-set-image.h>
 #include <dali/public-api/images/resource-image.h>
 #include <dali/public-api/images/native-image.h>
 #include <dali/devel-api/images/texture-set-image.h>


@@ -31,9 +32,8 @@
 
 // INTERNAL HEADERS
 #include <dali-toolkit/public-api/visuals/image-visual-properties.h>
 
 // INTERNAL HEADERS
 #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/texture-manager.h>
+#include <dali-toolkit/public-api/visuals/visual-properties.h>
+#include <dali-toolkit/internal/visuals/texture-manager-impl.h>

 #include <dali-toolkit/internal/visuals/visual-string-constants.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-factory-impl.h>
 #include <dali-toolkit/internal/visuals/visual-factory-cache.h>


@@ -91,6 +91,19 @@ DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::WrapMode, REPEAT )
 DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::WrapMode, MIRRORED_REPEAT )
 DALI_ENUM_TO_STRING_TABLE_END( WRAP_MODE )
 
 DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::WrapMode, MIRRORED_REPEAT )
 DALI_ENUM_TO_STRING_TABLE_END( WRAP_MODE )
 

+// load policies
+DALI_ENUM_TO_STRING_TABLE_BEGIN( LOAD_POLICY )
+DALI_ENUM_TO_STRING_WITH_SCOPE( DevelImageVisual::LoadPolicy, IMMEDIATE )
+DALI_ENUM_TO_STRING_WITH_SCOPE( DevelImageVisual::LoadPolicy, ATTACHED )
+DALI_ENUM_TO_STRING_TABLE_END( LOAD_POLICY )
+
+// release policies
+DALI_ENUM_TO_STRING_TABLE_BEGIN( RELEASE_POLICY )
+DALI_ENUM_TO_STRING_WITH_SCOPE( DevelImageVisual::ReleasePolicy, DETACHED )
+DALI_ENUM_TO_STRING_WITH_SCOPE( DevelImageVisual::ReleasePolicy, DESTROYED )
+DALI_ENUM_TO_STRING_WITH_SCOPE( DevelImageVisual::ReleasePolicy, NEVER )
+DALI_ENUM_TO_STRING_TABLE_END( RELEASE_POLICY )
+

 const Vector4 FULL_TEXTURE_RECT(0.f, 0.f, 1.f, 1.f);
 
 const char* DEFAULT_SAMPLER_TYPENAME = "sampler2D";
 const Vector4 FULL_TEXTURE_RECT(0.f, 0.f, 1.f, 1.f);
 
 const char* DEFAULT_SAMPLER_TYPENAME = "sampler2D";


@@ -257,49 +270,64 @@ ImageVisual::ImageVisual( VisualFactoryCache& factoryCache,
                           Dali::SamplingMode::Type samplingMode )
 : Visual::Base( factoryCache ),
   mImage(),
                           Dali::SamplingMode::Type samplingMode )
 : Visual::Base( factoryCache ),
   mImage(),

-  mPixels(),

   mPixelArea( FULL_TEXTURE_RECT ),
   mPlacementActor(),
   mImageUrl( imageUrl ),
   mPixelArea( FULL_TEXTURE_RECT ),
   mPlacementActor(),
   mImageUrl( imageUrl ),

-  mAlphaMaskUrl(),
+  mMaskingData( ),

   mDesiredSize( size ),
   mTextureId( TextureManager::INVALID_TEXTURE_ID ),
   mDesiredSize( size ),
   mTextureId( TextureManager::INVALID_TEXTURE_ID ),

-  mAlphaMaskId( TextureManager::INVALID_TEXTURE_ID ),

   mFittingMode( fittingMode ),
   mSamplingMode( samplingMode ),
   mWrapModeU( WrapMode::DEFAULT ),
   mWrapModeV( WrapMode::DEFAULT ),
   mFittingMode( fittingMode ),
   mSamplingMode( samplingMode ),
   mWrapModeU( WrapMode::DEFAULT ),
   mWrapModeV( WrapMode::DEFAULT ),

+  mLoadPolicy( DevelImageVisual::LoadPolicy::ATTACHED ),
+  mReleasePolicy( DevelImageVisual::ReleasePolicy::DETACHED ),

   mAttemptAtlasing( false ),
   mAttemptAtlasing( false ),

-  mTextureLoading( false )
+  mLoading( false )

 {
 }
 
 ImageVisual::ImageVisual( VisualFactoryCache& factoryCache, const Image& image )
 : Visual::Base( factoryCache ),
   mImage( image ),
 {
 }
 
 ImageVisual::ImageVisual( VisualFactoryCache& factoryCache, const Image& image )
 : Visual::Base( factoryCache ),
   mImage( image ),

-  mPixels(),

   mPixelArea( FULL_TEXTURE_RECT ),
   mPlacementActor(),
   mImageUrl(),
   mPixelArea( FULL_TEXTURE_RECT ),
   mPlacementActor(),
   mImageUrl(),

-  mAlphaMaskUrl(),
+  mMaskingData( ),

   mDesiredSize(),
   mTextureId( TextureManager::INVALID_TEXTURE_ID ),
   mDesiredSize(),
   mTextureId( TextureManager::INVALID_TEXTURE_ID ),

-  mAlphaMaskId( TextureManager::INVALID_TEXTURE_ID ),

   mFittingMode( FittingMode::DEFAULT ),
   mSamplingMode( SamplingMode::DEFAULT ),
   mWrapModeU( WrapMode::DEFAULT ),
   mWrapModeV( WrapMode::DEFAULT ),
   mFittingMode( FittingMode::DEFAULT ),
   mSamplingMode( SamplingMode::DEFAULT ),
   mWrapModeU( WrapMode::DEFAULT ),
   mWrapModeV( WrapMode::DEFAULT ),

+  mLoadPolicy( DevelImageVisual::LoadPolicy::ATTACHED ),
+  mReleasePolicy( DevelImageVisual::ReleasePolicy::DESTROYED ),

   mAttemptAtlasing( false ),
   mAttemptAtlasing( false ),

-  mTextureLoading( false )
+  mLoading( false )

 {
 }
 
 ImageVisual::~ImageVisual()
 {
 {
 }
 
 ImageVisual::~ImageVisual()
 {

-  if( mAlphaMaskId != TextureManager::INVALID_TEXTURE_ID )
+  if( Stage::IsInstalled() )

   {
   {

-    TextureManager& textureManager = mFactoryCache.GetTextureManager();
-    textureManager.Remove( mAlphaMaskId );
+    if( mMaskingData )
+    {
+      // TextureManager could have been deleted before the actor that contains this
+      // ImageVisual is destroyed (e.g. due to stage shutdown). Ensure the stage
+      // is still valid before accessing texture manager.
+      if( mMaskingData->mAlphaMaskId != TextureManager::INVALID_TEXTURE_ID )
+      {
+        TextureManager& textureManager = mFactoryCache.GetTextureManager();
+        textureManager.Remove( mMaskingData->mAlphaMaskId );
+      }
+    }
+
+    // ImageVisual destroyed so remove texture unless ReleasePolicy is set to never release
+    if( ( mTextureId != TextureManager::INVALID_TEXTURE_ID  ) && ( mReleasePolicy != DevelImageVisual::ReleasePolicy::NEVER ) )
+    {
+      RemoveTexture();
+    }

   }
 }
 
   }
 }
 


@@ -347,31 +375,38 @@ void ImageVisual::DoSetProperties( const Property::Map& propertyMap )
       {
         DoSetProperty( Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING, keyValue.second );
       }
       {
         DoSetProperty( Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING, keyValue.second );
       }

-      else if ( keyValue.first == IMAGE_ATLASING )
+      else if( keyValue.first == IMAGE_ATLASING )
+      {
+        DoSetProperty( Toolkit::ImageVisual::Property::ATLASING, keyValue.second );
+      }
+      else if( keyValue.first == ALPHA_MASK_URL )
+      {
+        DoSetProperty( Toolkit::ImageVisual::Property::ALPHA_MASK_URL, keyValue.second );
+      }
+      else if( keyValue.first == MASK_CONTENT_SCALE_NAME )
+      {
+        DoSetProperty( Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE, keyValue.second );
+      }
+      else if( keyValue.first == CROP_TO_MASK_NAME )
+      {
+        DoSetProperty( Toolkit::ImageVisual::Property::CROP_TO_MASK, keyValue.second );
+      }
+      else if ( keyValue.first == LOAD_POLICY_NAME )

       {
       {

-        DoSetProperty( Toolkit::DevelImageVisual::Property::ATLASING, keyValue.second );
+        DoSetProperty( Toolkit::DevelImageVisual::Property::LOAD_POLICY, keyValue.second );

       }
       }

-      else if ( keyValue.first == ALPHA_MASK_URL )
+      else if( keyValue.first == RELEASE_POLICY_NAME )

       {
       {

-        DoSetProperty( Toolkit::DevelImageVisual::Property::ALPHA_MASK_URL, keyValue.second );
+        DoSetProperty( Toolkit::DevelImageVisual::Property::RELEASE_POLICY, keyValue.second );

       }
     }
   }
 
       }
     }
   }
 

-  if( mAlphaMaskUrl.IsValid() )
-  {
-    // Immediately trigger the alpha mask loading (it may just get a cached value)
-    TextureManager& textureManager = mFactoryCache.GetTextureManager();
-    mAlphaMaskId = textureManager.RequestMaskLoad( mAlphaMaskUrl );
-  }
-
-  if( ( mImpl->mFlags & Impl::IS_SYNCHRONOUS_RESOURCE_LOADING ) && mImageUrl.IsValid() )
+  // Load image immediately if LOAD_POLICY requires it
+  if ( mLoadPolicy == DevelImageVisual::LoadPolicy::IMMEDIATE )

   {
   {

-    // if sync loading is required, the loading should start
-    // immediately when new image url is set or the actor is off stage
-    // ( for on-stage actor with image url unchanged, resource loading
-    // is already finished )
-    LoadResourceSynchronously();
+    auto attemptAtlasing = mAttemptAtlasing;
+    LoadTexture( attemptAtlasing, mAtlasRect, mTextures );

   }
 }
 
   }
 }
 


@@ -466,22 +501,71 @@ void ImageVisual::DoSetProperty( Property::Index index, const Property::Value& v
       break;
     }
 
       break;
     }
 

-    case Toolkit::DevelImageVisual::Property::ATLASING:
+    case Toolkit::ImageVisual::Property::ATLASING:

     {
       bool atlasing = false;
       mAttemptAtlasing = value.Get( atlasing );
       break;
     }
 
     {
       bool atlasing = false;
       mAttemptAtlasing = value.Get( atlasing );
       break;
     }
 

-    case Toolkit::DevelImageVisual::Property::ALPHA_MASK_URL:
+    case Toolkit::ImageVisual::Property::ALPHA_MASK_URL:

     {
       std::string alphaUrl;
       if( value.Get( alphaUrl ) )
       {
     {
       std::string alphaUrl;
       if( value.Get( alphaUrl ) )
       {

-        mAlphaMaskUrl = VisualUrl( alphaUrl );
+        AllocateMaskData();
+        // Immediately trigger the alpha mask loading (it may just get a cached value)
+        mMaskingData->mAlphaMaskUrl = alphaUrl;
+        TextureManager& textureManager = mFactoryCache.GetTextureManager();
+        mMaskingData->mAlphaMaskId = textureManager.RequestMaskLoad( alphaUrl );
+      }
+      break;
+    }
+
+    case Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE:
+    {
+      float scale;
+      if( value.Get( scale ) )
+      {
+        AllocateMaskData();
+        mMaskingData->mContentScaleFactor = scale;
+      }
+      break;
+    }
+
+    case Toolkit::ImageVisual::Property::CROP_TO_MASK:
+    {
+      bool crop=false;
+      if( value.Get( crop ) )
+      {
+        AllocateMaskData();
+        mMaskingData->mCropToMask = crop;

       }
       break;
     }
       }
       break;
     }

+
+    case Toolkit::DevelImageVisual::Property::RELEASE_POLICY:
+    {
+      int releasePolicy;
+      Scripting::GetEnumerationProperty( value, RELEASE_POLICY_TABLE, RELEASE_POLICY_TABLE_COUNT, releasePolicy );
+      mReleasePolicy = DevelImageVisual::ReleasePolicy::Type( releasePolicy );
+      break;
+    }
+
+    case Toolkit::DevelImageVisual::Property::LOAD_POLICY:
+    {
+      int loadPolicy;
+      Scripting::GetEnumerationProperty( value, LOAD_POLICY_TABLE, LOAD_POLICY_TABLE_COUNT, loadPolicy );
+      mLoadPolicy = DevelImageVisual::LoadPolicy::Type( loadPolicy );
+    }
+  }
+}
+
+void ImageVisual::AllocateMaskData()
+{
+  if( !mMaskingData )
+  {
+    mMaskingData.reset(new TextureManager::MaskingData());

   }
 }
 
   }
 }
 


@@ -499,23 +583,50 @@ void ImageVisual::GetNaturalSize( Vector2& naturalSize )
     naturalSize.y = mDesiredSize.GetHeight();
     return;
   }
     naturalSize.y = mDesiredSize.GetHeight();
     return;
   }

-  else if( mImageUrl.IsValid() && mImageUrl.GetLocation() == VisualUrl::LOCAL )
+  else if( mImpl->mRenderer ) // Check if we have a loaded image

   {
   {

-    ImageDimensions dimensions = Dali::GetClosestImageSize( mImageUrl.GetUrl() );
+    auto textureSet = mImpl->mRenderer.GetTextures();
+
+    if( textureSet )
+    {
+      auto texture = textureSet.GetTexture(0);
+      naturalSize.x = texture.GetWidth();
+      naturalSize.y = texture.GetHeight();
+      return;
+    }
+  }

 
 

+  if( mMaskingData != NULL && mMaskingData->mAlphaMaskUrl.IsValid() &&
+           mMaskingData->mCropToMask )
+  {
+    ImageDimensions dimensions = Dali::GetClosestImageSize( mMaskingData->mAlphaMaskUrl.GetUrl() );

     if( dimensions != ImageDimensions( 0, 0 ) )
     {
       naturalSize.x = dimensions.GetWidth();
       naturalSize.y = dimensions.GetHeight();
     }
     if( dimensions != ImageDimensions( 0, 0 ) )
     {
       naturalSize.x = dimensions.GetWidth();
       naturalSize.y = dimensions.GetHeight();
     }

-    else
+    return;
+  }
+  else if( mImageUrl.IsValid() )
+  {
+    if( mImageUrl.GetProtocolType() == VisualUrl::LOCAL )

     {
     {

-      Image brokenImage = VisualFactoryCache::GetBrokenVisualImage();
+      ImageDimensions dimensions = Dali::GetClosestImageSize( mImageUrl.GetUrl() );

 
 

-      naturalSize.x = brokenImage.GetWidth();
-      naturalSize.y = brokenImage.GetWidth();
+      if( dimensions != ImageDimensions( 0, 0 ) )
+      {
+        naturalSize.x = dimensions.GetWidth();
+        naturalSize.y = dimensions.GetHeight();
+      }
+      else
+      {
+        Image brokenImage = VisualFactoryCache::GetBrokenVisualImage();
+
+        naturalSize.x = brokenImage.GetWidth();
+        naturalSize.y = brokenImage.GetWidth();
+      }
+      return;

     }
     }

-    return;

   }
 
   naturalSize = Vector2::ZERO;
   }
 
   naturalSize = Vector2::ZERO;


@@ -629,136 +740,67 @@ bool ImageVisual::IsSynchronousResourceLoading() const
   return mImpl->mFlags & Impl::IS_SYNCHRONOUS_RESOURCE_LOADING;
 }
 
   return mImpl->mFlags & Impl::IS_SYNCHRONOUS_RESOURCE_LOADING;
 }
 

-void ImageVisual::LoadResourceSynchronously()
+void ImageVisual::LoadTexture( bool& atlasing, Vector4& atlasRect, TextureSet& textures )

 {
 {

-  if( mImageUrl.IsValid() )
-  {
-    Devel::PixelBuffer pixelBuffer = LoadImageFromFile( mImageUrl.GetUrl(), mDesiredSize, mFittingMode, mSamplingMode );
+  TextureManager& textureManager = mFactoryCache.GetTextureManager();

 
 

-    if( pixelBuffer )
-    {
-      mPixels = Devel::PixelBuffer::Convert(pixelBuffer); // takes ownership of buffer
-    }
-    mTextureLoading = false;
+  ImageAtlasManagerPtr atlasManager = nullptr;
+  AtlasUploadObserver* atlasUploadObserver = nullptr;
+  auto textureObserver = this;
+
+  if( atlasing )
+  {
+    atlasManager = mFactoryCache.GetAtlasManager();
+    atlasUploadObserver = this;

   }
   }

+
+  textures = textureManager.LoadTexture( mImageUrl, mDesiredSize, mFittingMode, mSamplingMode,
+                                         mMaskingData, IsSynchronousResourceLoading(), mTextureId,
+                                         atlasRect, atlasing, mLoading, mWrapModeU,
+                                         mWrapModeV, textureObserver, atlasUploadObserver, atlasManager );

 }
 
 }
 

-TextureSet ImageVisual::CreateTextureSet( Vector4& textureRect, bool synchronousLoading, bool attemptAtlasing )
+void ImageVisual::InitializeRenderer()

 {
 {

-  TextureSet textureSet;
+  auto attemptAtlasing = ( ! mImpl->mCustomShader && mImageUrl.GetProtocolType() == VisualUrl::LOCAL && mAttemptAtlasing );

 
 

-  mTextureLoading = false;
+  // texture set has to be created first as we need to know if atlasing succeeded or not
+  // when selecting the shader

 
 

-  textureRect = FULL_TEXTURE_RECT;
-  if( synchronousLoading )
+  if( mTextureId == TextureManager::INVALID_TEXTURE_ID && ! mTextures ) // Only load the texture once

   {
   {

-    if( !mPixels )
-    {
-      // use broken image
-      textureSet = TextureSet::New();
-      TextureSetImage( textureSet, 0u, VisualFactoryCache::GetBrokenVisualImage() );
-    }
-    else
-    {
-      if( attemptAtlasing )
-      {
-        textureSet = mFactoryCache.GetAtlasManager()->Add(textureRect, mPixels );
-        mImpl->mFlags |= Impl::IS_ATLASING_APPLIED;
-      }
-      if( !textureSet ) // big image, no atlasing or atlasing failed
-      {
-        mImpl->mFlags &= ~Impl::IS_ATLASING_APPLIED;
-        Texture texture = Texture::New( Dali::TextureType::TEXTURE_2D, mPixels.GetPixelFormat(),
-                                        mPixels.GetWidth(), mPixels.GetHeight() );
-        texture.Upload( mPixels );
-        textureSet = TextureSet::New();
-        textureSet.SetTexture( 0u, texture );
-      }
-    }
+    LoadTexture( attemptAtlasing, mAtlasRect, mTextures );

   }
   }

-  else
-  {
-    if( attemptAtlasing )
-    {
-      textureSet = mFactoryCache.GetAtlasManager()->Add( textureRect, mImageUrl.GetUrl(), mDesiredSize, mFittingMode, true, this );
-      mImpl->mFlags |= Impl::IS_ATLASING_APPLIED;
-      mTextureLoading = true;
-    }
-    if( !textureSet ) // big image, no atlasing or atlasing failed
-    {
-      mImpl->mFlags &= ~Impl::IS_ATLASING_APPLIED;
-      TextureManager& textureManager = mFactoryCache.GetTextureManager();
-      if( mAlphaMaskId == TextureManager::INVALID_TEXTURE_ID )
-      {
-        mTextureId = textureManager.RequestLoad( mImageUrl, mDesiredSize, mFittingMode,
-                                                 mSamplingMode, TextureManager::NO_ATLAS, this );
-      }
-      else
-      {
-        mTextureId = textureManager.RequestLoad( mImageUrl, mAlphaMaskId, mDesiredSize,
-                                                 mFittingMode, mSamplingMode,
-                                                 TextureManager::NO_ATLAS, this );
-      }
-
-      TextureManager::LoadState loadState = textureManager.GetTextureState( mTextureId );

 
 

-      mTextureLoading = ( loadState == TextureManager::LOADING );
-
-      if( loadState == TextureManager::UPLOADED )
-      {
-        // UploadComplete has already been called - keep the same texture set
-        textureSet = textureManager.GetTextureSet(mTextureId);
-      }
-    }
+  if( attemptAtlasing ) // Flag needs to be set before creating renderer
+  {
+    mImpl->mFlags |= Impl::IS_ATLASING_APPLIED;

   }
   }

-
-  if( ! (mImpl->mFlags & Impl::IS_ATLASING_APPLIED) && textureSet )
+  else

   {
   {

-    Sampler sampler = Sampler::New();
-    sampler.SetWrapMode(  mWrapModeU, mWrapModeV  );
-    textureSet.SetSampler( 0u, sampler );
+    mImpl->mFlags &= ~Impl::IS_ATLASING_APPLIED;

   }
 
   }
 

-  return textureSet;
-}
-
-void ImageVisual::InitializeRenderer()
-{
-  mImpl->mFlags &= ~Impl::IS_ATLASING_APPLIED;
+  CreateRenderer( mTextures );
+  mTextures.Reset(); // Visual should not keep a handle to the texture after this point.

 
 

-  if( ! mImpl->mCustomShader && mImageUrl.GetLocation() == VisualUrl::LOCAL )
+  if( attemptAtlasing ) // the texture is packed inside atlas

   {
   {

-    bool defaultWrapMode = mWrapModeU <= WrapMode::CLAMP_TO_EDGE && mWrapModeV <= WrapMode::CLAMP_TO_EDGE;
+    mImpl->mRenderer.RegisterProperty( ATLAS_RECT_UNIFORM_NAME, mAtlasRect );

 
 

-    Vector4 atlasRect;
-    // texture set has to be created first as we need to know if atlasing succeeded or not
-    // when selecting the shader
-    TextureSet textures = CreateTextureSet( atlasRect, IsSynchronousResourceLoading(), mAttemptAtlasing );
-    CreateRenderer( textures );
+    bool defaultWrapMode = mWrapModeU <= WrapMode::CLAMP_TO_EDGE && mWrapModeV <= WrapMode::CLAMP_TO_EDGE;

 
 

-    if( mImpl->mFlags & Impl::IS_ATLASING_APPLIED ) // the texture is packed inside atlas
+    if( !defaultWrapMode ) // custom wrap mode

     {
     {

-      mImpl->mRenderer.RegisterProperty( ATLAS_RECT_UNIFORM_NAME, atlasRect );
-      if( !defaultWrapMode ) // custom wrap mode, renderer is not cached.
-      {
-        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 );
-      }
+      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 );

     }
   }
     }
   }

-  else
-  {
-    // for custom shader or remote image, atlas is not applied
-    Vector4 atlasRect; // ignored in this case
-    TextureSet textures = CreateTextureSet( atlasRect, IsSynchronousResourceLoading(), false );
-    CreateRenderer( textures );
-  }

 }
 
 void ImageVisual::InitializeRenderer( const Image& image )
 {
 }
 
 void ImageVisual::InitializeRenderer( const Image& image )
 {

-  // don't reuse CreateTextureSet

   TextureSet textures = TextureSet::New();
 
   NativeImage nativeImage = NativeImage::DownCast( image );
   TextureSet textures = TextureSet::New();
 
   NativeImage nativeImage = NativeImage::DownCast( image );


@@ -771,7 +813,7 @@ void ImageVisual::InitializeRenderer( const Image& image )
   else
   {
     // reuse existing code for regular images
   else
   {
     // reuse existing code for regular images

-    CreateRenderer( textures );
+    CreateRenderer( textures ); // Textures will be retreived from Image

   }
   ApplyImageToSampler( image );
 }
   }
   ApplyImageToSampler( image );
 }


@@ -782,12 +824,12 @@ void ImageVisual::DoSetOnStage( Actor& actor )
   {
     InitializeRenderer();
   }
   {
     InitializeRenderer();
   }

-  else if ( mImage )
+  else if( mImage )

   {
     InitializeRenderer( mImage );
   }
 
   {
     InitializeRenderer( mImage );
   }
 

-  if ( !mImpl->mRenderer )
+  if( !mImpl->mRenderer )

   {
     return;
   }
   {
     return;
   }


@@ -795,7 +837,7 @@ void ImageVisual::DoSetOnStage( Actor& actor )
   mPlacementActor = actor;
   // Search the Actor tree to find if Layer UI behaviour set.
   Layer layer = actor.GetLayer();
   mPlacementActor = actor;
   // Search the Actor tree to find if Layer UI behaviour set.
   Layer layer = actor.GetLayer();

-  if ( layer && layer.GetBehavior() == Layer::LAYER_3D )
+  if( layer && layer.GetBehavior() == Layer::LAYER_3D )

   {
      // Layer 3D set, do not align pixels
      mImpl->mRenderer.RegisterProperty( PIXEL_ALIGNED_UNIFORM_NAME, PIXEL_ALIGN_OFF );
   {
      // Layer 3D set, do not align pixels
      mImpl->mRenderer.RegisterProperty( PIXEL_ALIGNED_UNIFORM_NAME, PIXEL_ALIGN_OFF );


@@ -806,7 +848,7 @@ void ImageVisual::DoSetOnStage( Actor& actor )
     mImpl->mRenderer.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, mPixelArea );
   }
 
     mImpl->mRenderer.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, mPixelArea );
   }
 

-  if( mTextureLoading == false )
+  if( mLoading == false )

   {
     actor.AddRenderer( mImpl->mRenderer );
     mPlacementActor.Reset();
   {
     actor.AddRenderer( mImpl->mRenderer );
     mPlacementActor.Reset();


@@ -820,14 +862,19 @@ void ImageVisual::DoSetOffStage( Actor& actor )
 {
   // Visual::Base::SetOffStage only calls DoSetOffStage if mRenderer exists (is on onstage)
 
 {
   // Visual::Base::SetOffStage only calls DoSetOffStage if mRenderer exists (is on onstage)
 

-  //If we own the image then make sure we release it when we go off stage
+  // Image release is dependent on the ReleasePolicy, renderer is destroyed.

   actor.RemoveRenderer( mImpl->mRenderer);
   actor.RemoveRenderer( mImpl->mRenderer);

+  if( mReleasePolicy == DevelImageVisual::ReleasePolicy::DETACHED )
+  {
+    RemoveTexture(); // If INVALID_TEXTURE_ID then removal will be attempted on atlas
+  }
+

   if( mImageUrl.IsValid() )
   {
   if( mImageUrl.IsValid() )
   {

-    RemoveTexture( mImageUrl.GetUrl() );
+    // Legacy support for deprecated Dali::Image

     mImage.Reset();
   }
     mImage.Reset();
   }

-  mTextureLoading = false;
+  mLoading = false;

   mImpl->mRenderer.Reset();
   mPlacementActor.Reset();
 }
   mImpl->mRenderer.Reset();
   mPlacementActor.Reset();
 }


@@ -835,7 +882,7 @@ void ImageVisual::DoSetOffStage( Actor& actor )
 void ImageVisual::DoCreatePropertyMap( Property::Map& map ) const
 {
   map.Clear();
 void ImageVisual::DoCreatePropertyMap( Property::Map& map ) const
 {
   map.Clear();

-  map.Insert( Toolkit::DevelVisual::Property::TYPE, Toolkit::Visual::IMAGE );
+  map.Insert( Toolkit::Visual::Property::TYPE, Toolkit::Visual::IMAGE );

 
   bool sync = IsSynchronousResourceLoading();
   map.Insert( SYNCHRONOUS_LOADING, sync );
 
   bool sync = IsSynchronousResourceLoading();
   map.Insert( SYNCHRONOUS_LOADING, sync );


@@ -864,14 +911,23 @@ void ImageVisual::DoCreatePropertyMap( Property::Map& map ) const
   map.Insert( Toolkit::ImageVisual::Property::WRAP_MODE_U, mWrapModeU );
   map.Insert( Toolkit::ImageVisual::Property::WRAP_MODE_V, mWrapModeV );
 
   map.Insert( Toolkit::ImageVisual::Property::WRAP_MODE_U, mWrapModeU );
   map.Insert( Toolkit::ImageVisual::Property::WRAP_MODE_V, mWrapModeV );
 

-  map.Insert( Toolkit::DevelImageVisual::Property::ATLASING, mAttemptAtlasing );
-  map.Insert( Toolkit::DevelImageVisual::Property::ALPHA_MASK_URL, mAlphaMaskUrl.GetUrl() );
+  map.Insert( Toolkit::ImageVisual::Property::ATLASING, mAttemptAtlasing );
+  if( mMaskingData != NULL )
+  {
+    map.Insert( Toolkit::ImageVisual::Property::ALPHA_MASK_URL, mMaskingData->mAlphaMaskUrl.GetUrl() );
+    map.Insert( Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE, mMaskingData->mContentScaleFactor );
+    map.Insert( Toolkit::ImageVisual::Property::CROP_TO_MASK, mMaskingData->mCropToMask );
+  }
+
+  map.Insert( Toolkit::DevelImageVisual::Property::LOAD_POLICY, mLoadPolicy );
+  map.Insert( Toolkit::DevelImageVisual::Property::RELEASE_POLICY, mReleasePolicy );
+

 }
 
 void ImageVisual::DoCreateInstancePropertyMap( Property::Map& map ) const
 {
   map.Clear();
 }
 
 void ImageVisual::DoCreateInstancePropertyMap( Property::Map& map ) const
 {
   map.Clear();

-  map.Insert( Toolkit::DevelVisual::Property::TYPE, Toolkit::Visual::IMAGE );
+  map.Insert( Toolkit::Visual::Property::TYPE, Toolkit::Visual::IMAGE );

   if( mImageUrl.IsValid() )
   {
     map.Insert( Toolkit::ImageVisual::Property::DESIRED_WIDTH, mDesiredSize.GetWidth() );
   if( mImageUrl.IsValid() )
   {
     map.Insert( Toolkit::ImageVisual::Property::DESIRED_WIDTH, mDesiredSize.GetWidth() );


@@ -953,12 +1009,12 @@ void ImageVisual::UploadCompleted()
   Actor actor = mPlacementActor.GetHandle();
   if( actor )
   {
   Actor actor = mPlacementActor.GetHandle();
   if( actor )
   {

+    mImpl->mRenderer.RegisterProperty( ATLAS_RECT_UNIFORM_NAME, mAtlasRect );

     actor.AddRenderer( mImpl->mRenderer );
     actor.AddRenderer( mImpl->mRenderer );

-

     // reset the weak handle so that the renderer only get added to actor once
     mPlacementActor.Reset();
   }
     // reset the weak handle so that the renderer only get added to actor once
     mPlacementActor.Reset();
   }

-  mTextureLoading = false;
+  mLoading = false;

 }
 
 // From Texture Manager
 }
 
 // From Texture Manager


@@ -969,10 +1025,14 @@ void ImageVisual::UploadComplete( bool loadingSuccess, int32_t textureId, Textur
   {
     if( mImpl->mRenderer )
     {
   {
     if( mImpl->mRenderer )
     {

+      if( usingAtlas )
+      {
+        mImpl->mRenderer.RegisterProperty( ATLAS_RECT_UNIFORM_NAME, mAtlasRect );
+      }
+

       actor.AddRenderer( mImpl->mRenderer );
       // reset the weak handle so that the renderer only get added to actor once
       mPlacementActor.Reset();
       actor.AddRenderer( mImpl->mRenderer );
       // reset the weak handle so that the renderer only get added to actor once
       mPlacementActor.Reset();

-

       if( loadingSuccess )
       {
         Sampler sampler = Sampler::New();
       if( loadingSuccess )
       {
         Sampler sampler = Sampler::New();


@@ -993,10 +1053,10 @@ void ImageVisual::UploadComplete( bool loadingSuccess, int32_t textureId, Textur
       ResourceReady();
     }
   }
       ResourceReady();
     }
   }

-  mTextureLoading = false;
+  mLoading = false;

 }
 
 }
 

-void ImageVisual::RemoveTexture(const std::string& url)
+void ImageVisual::RemoveTexture()

 {
   if( mTextureId != TextureManager::INVALID_TEXTURE_ID )
   {
 {
   if( mTextureId != TextureManager::INVALID_TEXTURE_ID )
   {