Support SamplingMode type for high quality sampling + Remove FittingMode input for...

Let we make new enum for lanczos resize method, named SINC.

Also, remove some unused codes at material definition load images.
Since we use only desired size and sampling mode at metadata,
we don't need to give input for fitting mode and orientation corrections.

Change-Id: I4df1412540f4c75a869ffa47ff4b09425f622fe1
Signed-off-by: Eunki, Hong <eunkiki.hong@samsung.com>

diff --git a/dali-scene3d/internal/common/image-resource-loader.cpp b/dali-scene3d/internal/common/image-resource-loader.cpp
index 7b2f45fa040b7adaeac1e686333bd47eac97b855..a93005464191ed13c13b27e8f07987186a7b9098 100644 (file)
--- a/dali-scene3d/internal/common/image-resource-loader.cpp
+++ b/dali-scene3d/internal/common/image-resource-loader.cpp
@@ -90,28 +90,21 @@ struct ImageInformation
 {
   ImageInformation(const std::string           url,
                    const Dali::ImageDimensions dimensions,
-                   Dali::FittingMode::Type     fittingMode,
-                   Dali::SamplingMode::Type    samplingMode,
-                   bool                        orientationCorrection)
+                   Dali::SamplingMode::Type    samplingMode)
   : mUrl(url),
     mDimensions(dimensions),
-    mFittingMode(fittingMode),
-    mSamplingMode(samplingMode),
-    mOrientationCorrection(orientationCorrection)
+    mSamplingMode(samplingMode)
   {
   }
 
   bool operator==(const ImageInformation& rhs) const
   {
-    // Check url and orientation correction is enough.
-    return (mUrl == rhs.mUrl) && (mOrientationCorrection == rhs.mOrientationCorrection);
+    return (mUrl == rhs.mUrl) && (mDimensions == rhs.mDimensions) && (mSamplingMode == rhs.mSamplingMode);
   }
 
   std::string              mUrl;
   Dali::ImageDimensions    mDimensions;
-  Dali::FittingMode::Type  mFittingMode;
-  Dali::SamplingMode::Type mSamplingMode;
-  bool                     mOrientationCorrection;
+  Dali::SamplingMode::Type mSamplingMode : 5;
 };
 
 // Hash functor list
@@ -134,15 +127,8 @@ std::size_t GenerateHash(const ImageInformation& info)
     *hashTargetPtr++ = info.mDimensions.GetHeight() & 0xff;
     *hashTargetPtr++ = (info.mDimensions.GetHeight() >> 8u) & 0xff;
 
-    // Bit-pack the FittingMode, SamplingMode and orientation correction.
-    // FittingMode=2bits, SamplingMode=3bits, orientationCorrection=1bit
-    *hashTargetPtr = (info.mFittingMode << 4u) | (info.mSamplingMode << 1) | (info.mOrientationCorrection ? 1 : 0);
-  }
-  else
-  {
-    // We are not including sizing information, but we still need an extra byte for orientationCorrection.
-    hashTarget.resize(1u);
-    hashTarget[0u] = info.mOrientationCorrection ? 't' : 'f';
+    // Bit-pack the SamplingMode.
+    *hashTargetPtr = (info.mSamplingMode);
   }
 
   return Dali::CalculateHash(info.mUrl) ^ Dali::CalculateHash(hashTarget);
@@ -165,11 +151,11 @@ Dali::PixelData CreatePixelDataFromImageInfo(const ImageInformation& info, bool
     {
       oss << "d:" << info.mDimensions.GetWidth() << "x" << info.mDimensions.GetHeight() << " ";
     }
-    oss << "f:" << info.mFittingMode << " s:" << info.mSamplingMode << " c:" << info.mOrientationCorrection << " ";
+    oss << "s:" << info.mSamplingMode << " ";
     oss << "u:" << info.mUrl << "]";
   });
   // Load the image synchronously (block the thread here).
-  Dali::Devel::PixelBuffer pixelBuffer = Dali::LoadImageFromFile(info.mUrl, info.mDimensions, info.mFittingMode, info.mSamplingMode, info.mOrientationCorrection);
+  Dali::Devel::PixelBuffer pixelBuffer = Dali::LoadImageFromFile(info.mUrl, info.mDimensions, Dali::FittingMode::DEFAULT, info.mSamplingMode, true);
   if(pixelBuffer)
   {
     pixelData = Dali::Devel::PixelBuffer::Convert(pixelBuffer, releasePixelData);
@@ -663,16 +649,14 @@ Dali::PixelData GetDefaultBrdfPixelData()
 
 Dali::PixelData GetCachedPixelData(const std::string& url)
 {
-  return GetCachedPixelData(url, ImageDimensions(), FittingMode::DEFAULT, SamplingMode::BOX_THEN_LINEAR, true);
+  return GetCachedPixelData(url, ImageDimensions(), SamplingMode::BOX_THEN_LINEAR);
 }
 
 Dali::PixelData GetCachedPixelData(const std::string& url,
                                    ImageDimensions    dimensions,
-                                   FittingMode::Type  fittingMode,
-                                   SamplingMode::Type samplingMode,
-                                   bool               orientationCorrection)
+                                   SamplingMode::Type samplingMode)
 {
-  ImageInformation info(url, dimensions, fittingMode, samplingMode, orientationCorrection);
+  ImageInformation info(url, dimensions, samplingMode);
   if(gCacheImpl == nullptr)
   {
     DALI_LOG_INFO(gLogFilter, Debug::Verbose, "CacheImpl not prepared! load PixelData without cache.\n");

diff --git a/dali-scene3d/internal/common/image-resource-loader.h b/dali-scene3d/internal/common/image-resource-loader.h
index b498b30d4052dd89dcca7dc97e42ebbcae46569e..df5f02607a37440ba577dbe58301d2ef11d620e6 100644 (file)
--- a/dali-scene3d/internal/common/image-resource-loader.h
+++ b/dali-scene3d/internal/common/image-resource-loader.h
@@ -123,16 +123,12 @@ Dali::PixelData GetCachedPixelData(const std::string& url);
  * @note If cache handler is not created yet, or destroyed due to app terminated, it will load image synchronously without cache.
  * @param[in] url The URL of the image file to load
  * @param[in] dimensions The width and height to fit the loaded image to
- * @param[in] fittingMode The method used to fit the shape of the image before loading to the shape defined by the size parameter
  * @param[in] samplingMode The filtering method used when sampling pixels from the input image while fitting it to desired size
- * @param[in] orientationCorrection Reorient the image to respect any orientation metadata in its header
  * @return A PixelData object containing the image, or an invalid object on failure
  */
 Dali::PixelData GetCachedPixelData(const std::string& url,
                                    ImageDimensions    dimensions,
-                                   FittingMode::Type  fittingMode,
-                                   SamplingMode::Type samplingMode,
-                                   bool               orientationCorrection);
+                                   SamplingMode::Type samplingMode);
 } // namespace ImageResourceLoader
 
 } // namespace Internal

diff --git a/dali-scene3d/public-api/loader/load-scene-metadata.cpp b/dali-scene3d/public-api/loader/load-scene-metadata.cpp
index 826e7133fd29e9b411dbc39b385c1326b22a6745..5da6faf163020e8e4b3f489e20dc828f00cca956 100644 (file)
--- a/dali-scene3d/public-api/loader/load-scene-metadata.cpp
+++ b/dali-scene3d/public-api/loader/load-scene-metadata.cpp
@@ -1,5 +1,5 @@
 /*\r
- * Copyright (c) 2022 Samsung Electronics Co., Ltd.\r
+ * Copyright (c) 2024 Samsung Electronics Co., Ltd.\r
  *\r
  * Licensed under the Apache License, Version 2.0 (the "License");\r
  * you may not use this file except in compliance with the License.\r
@@ -41,7 +41,9 @@ struct ImageData
       BOX_THEN_NEAREST = Dali::SamplingMode::BOX_THEN_NEAREST,\r
       BOX_THEN_LINEAR  = Dali::SamplingMode::BOX_THEN_LINEAR,\r
       NO_FILTER        = Dali::SamplingMode::NO_FILTER,\r
-      DONT_CARE        = Dali::SamplingMode::DONT_CARE\r
+      DONT_CARE        = Dali::SamplingMode::DONT_CARE,\r
+      LANCZOS          = Dali::SamplingMode::LANCZOS,\r
+      BOX_THEN_LANCZOS = Dali::SamplingMode::BOX_THEN_LANCZOS,\r
     };\r
 \r
     static Type FromString(const char* s, size_t len);\r
@@ -64,6 +66,8 @@ const std::map<std::string_view, ImageData::SamplingMode::Type>& GetStringSampli
     ENUM_STRING_MAPPING(ImageData::SamplingMode, BOX_THEN_LINEAR),\r
     ENUM_STRING_MAPPING(ImageData::SamplingMode, NO_FILTER),\r
     ENUM_STRING_MAPPING(ImageData::SamplingMode, DONT_CARE),\r
+    ENUM_STRING_MAPPING(ImageData::SamplingMode, LANCZOS),\r
+    ENUM_STRING_MAPPING(ImageData::SamplingMode, BOX_THEN_LANCZOS),\r
   };\r
   return SAMPLING_MODE_TYPES;\r
 }\r
@@ -78,17 +82,17 @@ struct MetaData
 const js::Reader<ImageData>& GetImageMetaDataReader()\r
 {\r
   static const auto IMAGE_METADATA_READER = std::move(js::Reader<ImageData>()\r
-                                                         .Register(*js::MakeProperty("uri", js::Read::String, &ImageData::mImageUri))\r
-                                                         .Register(*js::MakeProperty("minWidth", js::Read::Number, &ImageData::mMinWidth))\r
-                                                         .Register(*js::MakeProperty("minHeight", js::Read::Number, &ImageData::mMinHeight))\r
-                                                         .Register(*js::MakeProperty("samplingMode", gt::ReadStringEnum<ImageData::SamplingMode>, &ImageData::mSamplingMode)));\r
+                                                        .Register(*js::MakeProperty("uri", js::Read::String, &ImageData::mImageUri))\r
+                                                        .Register(*js::MakeProperty("minWidth", js::Read::Number, &ImageData::mMinWidth))\r
+                                                        .Register(*js::MakeProperty("minHeight", js::Read::Number, &ImageData::mMinHeight))\r
+                                                        .Register(*js::MakeProperty("samplingMode", gt::ReadStringEnum<ImageData::SamplingMode>, &ImageData::mSamplingMode)));\r
   return IMAGE_METADATA_READER;\r
 }\r
 \r
 const js::Reader<MetaData>& GetMetaDataReader()\r
 {\r
   static const auto METADATA_READER = std::move(js::Reader<MetaData>()\r
-                                                   .Register(*js::MakeProperty("images", js::Read::Array<ImageData, js::ObjectReader<ImageData>::Read>, &MetaData::mImageData)));\r
+                                                  .Register(*js::MakeProperty("images", js::Read::Array<ImageData, js::ObjectReader<ImageData>::Read>, &MetaData::mImageData)));\r
   return METADATA_READER;\r
 }\r
 } // namespace\r

diff --git a/dali-scene3d/public-api/loader/material-definition.cpp b/dali-scene3d/public-api/loader/material-definition.cpp
index 27a460b394f32bc8432f419d3960586bcf18f5b4..83bd0aada5b780d3a1e5bd2852a6a1a1030343cc 100644 (file)
--- a/dali-scene3d/public-api/loader/material-definition.cpp
+++ b/dali-scene3d/public-api/loader/material-definition.cpp
@@ -86,22 +86,18 @@ static constexpr std::string_view EMBEDDED_DATA_IMAGE_MEDIA_TYPE     = "image/";
 static constexpr std::string_view EMBEDDED_DATA_BASE64_ENCODING_TYPE = "base64,";
 
 Dali::PixelData LoadImageResource(const std::string& resourcePath,
-                                  TextureDefinition& textureDefinition,
-                                  FittingMode::Type  fittingMode,
-                                  bool               orientationCorrection)
+                                  TextureDefinition& textureDefinition)
 {
   Dali::PixelData pixelData;
   if(!textureDefinition.mTextureBuffer.empty())
   {
-    DALI_TRACE_BEGIN_WITH_MESSAGE_GENERATOR(gTraceFilter, "DALI_MODEL_LOAD_IMAGE_FROM_BUFFER", [&](std::ostringstream& oss)
-                                            { oss << "[s:" << textureDefinition.mTextureBuffer.size() << "]"; });
-    Dali::Devel::PixelBuffer pixelBuffer = Dali::LoadImageFromBuffer(textureDefinition.mTextureBuffer.data(), textureDefinition.mTextureBuffer.size(), textureDefinition.mMinImageDimensions, fittingMode, textureDefinition.mSamplingMode, orientationCorrection);
+    DALI_TRACE_BEGIN_WITH_MESSAGE_GENERATOR(gTraceFilter, "DALI_MODEL_LOAD_IMAGE_FROM_BUFFER", [&](std::ostringstream& oss) { oss << "[s:" << textureDefinition.mTextureBuffer.size() << "]"; });
+    Dali::Devel::PixelBuffer pixelBuffer = Dali::LoadImageFromBuffer(textureDefinition.mTextureBuffer.data(), textureDefinition.mTextureBuffer.size(), textureDefinition.mMinImageDimensions, FittingMode::DEFAULT, textureDefinition.mSamplingMode, true);
     if(pixelBuffer)
     {
       pixelData = Devel::PixelBuffer::Convert(pixelBuffer);
     }
-    DALI_TRACE_END_WITH_MESSAGE_GENERATOR(gTraceFilter, "DALI_MODEL_LOAD_IMAGE_FROM_BUFFER", [&](std::ostringstream& oss)
-                                          {
+    DALI_TRACE_END_WITH_MESSAGE_GENERATOR(gTraceFilter, "DALI_MODEL_LOAD_IMAGE_FROM_BUFFER", [&](std::ostringstream& oss) {
       oss << "[";
       if(pixelData)
       {
@@ -120,15 +116,13 @@ Dali::PixelData LoadImageResource(const std::string& resourcePath,
       Dali::Toolkit::DecodeBase64FromString(data, buffer);
       uint32_t bufferSize = buffer.size();
 
-      DALI_TRACE_BEGIN_WITH_MESSAGE_GENERATOR(gTraceFilter, "DALI_MODEL_LOAD_IMAGE_FROM_BUFFER", [&](std::ostringstream& oss)
-                                              { oss << "[embedded s:" << bufferSize << "]"; });
-      Dali::Devel::PixelBuffer pixelBuffer = Dali::LoadImageFromBuffer(reinterpret_cast<uint8_t*>(buffer.data()), bufferSize, textureDefinition.mMinImageDimensions, fittingMode, textureDefinition.mSamplingMode, orientationCorrection);
+      DALI_TRACE_BEGIN_WITH_MESSAGE_GENERATOR(gTraceFilter, "DALI_MODEL_LOAD_IMAGE_FROM_BUFFER", [&](std::ostringstream& oss) { oss << "[embedded s:" << bufferSize << "]"; });
+      Dali::Devel::PixelBuffer pixelBuffer = Dali::LoadImageFromBuffer(reinterpret_cast<uint8_t*>(buffer.data()), bufferSize, textureDefinition.mMinImageDimensions, FittingMode::DEFAULT, textureDefinition.mSamplingMode, true);
       if(pixelBuffer)
       {
         pixelData = Dali::Devel::PixelBuffer::Convert(pixelBuffer, true);
       }
-      DALI_TRACE_END_WITH_MESSAGE_GENERATOR(gTraceFilter, "DALI_MODEL_LOAD_IMAGE_FROM_BUFFER", [&](std::ostringstream& oss)
-                                            {
+      DALI_TRACE_END_WITH_MESSAGE_GENERATOR(gTraceFilter, "DALI_MODEL_LOAD_IMAGE_FROM_BUFFER", [&](std::ostringstream& oss) {
         oss << "[";
         if(pixelData)
         {
@@ -140,7 +134,7 @@ Dali::PixelData LoadImageResource(const std::string& resourcePath,
   else
   {
     textureDefinition.mDirectoryPath = resourcePath;
-    pixelData                        = Internal::ImageResourceLoader::GetCachedPixelData(resourcePath + textureDefinition.mImageUri, textureDefinition.mMinImageDimensions, fittingMode, textureDefinition.mSamplingMode, orientationCorrection);
+    pixelData                        = Internal::ImageResourceLoader::GetCachedPixelData(resourcePath + textureDefinition.mImageUri, textureDefinition.mMinImageDimensions, textureDefinition.mSamplingMode);
   }
   return pixelData;
 }
@@ -225,20 +219,19 @@ MaterialDefinition::LoadRaw(const std::string& imagesPath)
 
   // Load textures
   auto iTexture   = mTextureStages.begin();
-  auto checkStage = [&](uint32_t flags)
-  {
+  auto checkStage = [&](uint32_t flags) {
     return iTexture != mTextureStages.end() && MaskMatch(iTexture->mSemantic, flags);
   };
 
   // Check for compulsory textures: Albedo, Metallic, Roughness, Normal
   if(checkStage(ALBEDO | METALLIC))
   {
-    raw.mTextures.push_back({LoadImageResource(imagesPath, iTexture->mTexture, FittingMode::DEFAULT, true), iTexture->mTexture.mSamplerFlags});
+    raw.mTextures.push_back({LoadImageResource(imagesPath, iTexture->mTexture), iTexture->mTexture.mSamplerFlags});
     ++iTexture;
 
     if(checkStage(NORMAL | ROUGHNESS))
     {
-      raw.mTextures.push_back({LoadImageResource(imagesPath, iTexture->mTexture, FittingMode::DEFAULT, true), iTexture->mTexture.mSamplerFlags});
+      raw.mTextures.push_back({LoadImageResource(imagesPath, iTexture->mTexture), iTexture->mTexture.mSamplerFlags});
       ++iTexture;
     }
     else // single value normal-roughness
@@ -250,7 +243,7 @@ MaterialDefinition::LoadRaw(const std::string& imagesPath)
   {
     if(checkStage(ALBEDO))
     {
-      raw.mTextures.push_back({LoadImageResource(imagesPath, iTexture->mTexture, FittingMode::DEFAULT, true), iTexture->mTexture.mSamplerFlags});
+      raw.mTextures.push_back({LoadImageResource(imagesPath, iTexture->mTexture), iTexture->mTexture.mSamplerFlags});
       ++iTexture;
     }
     else if(mNeedAlbedoTexture) // single value albedo, albedo-alpha or albedo-metallic
@@ -284,7 +277,7 @@ MaterialDefinition::LoadRaw(const std::string& imagesPath)
     const bool createMetallicRoughnessAndNormal = hasTransparency || std::distance(mTextureStages.begin(), iTexture) > 0;
     if(checkStage(METALLIC | ROUGHNESS))
     {
-      raw.mTextures.push_back({LoadImageResource(imagesPath, iTexture->mTexture, FittingMode::DEFAULT, true), iTexture->mTexture.mSamplerFlags});
+      raw.mTextures.push_back({LoadImageResource(imagesPath, iTexture->mTexture), iTexture->mTexture.mSamplerFlags});
       ++iTexture;
     }
     else if(createMetallicRoughnessAndNormal && mNeedMetallicRoughnessTexture)
@@ -296,7 +289,7 @@ MaterialDefinition::LoadRaw(const std::string& imagesPath)
 
     if(checkStage(NORMAL))
     {
-      raw.mTextures.push_back({LoadImageResource(imagesPath, iTexture->mTexture, FittingMode::DEFAULT, true), iTexture->mTexture.mSamplerFlags});
+      raw.mTextures.push_back({LoadImageResource(imagesPath, iTexture->mTexture), iTexture->mTexture.mSamplerFlags});
       ++iTexture;
     }
     else if(mNeedNormalTexture)
@@ -315,31 +308,31 @@ MaterialDefinition::LoadRaw(const std::string& imagesPath)
   // Extra textures.
   if(checkStage(SUBSURFACE))
   {
-    raw.mTextures.push_back({LoadImageResource(imagesPath, iTexture->mTexture, FittingMode::DEFAULT, true), iTexture->mTexture.mSamplerFlags});
+    raw.mTextures.push_back({LoadImageResource(imagesPath, iTexture->mTexture), iTexture->mTexture.mSamplerFlags});
     ++iTexture;
   }
 
   if(checkStage(OCCLUSION))
   {
-    raw.mTextures.push_back({LoadImageResource(imagesPath, iTexture->mTexture, FittingMode::DEFAULT, true), iTexture->mTexture.mSamplerFlags});
+    raw.mTextures.push_back({LoadImageResource(imagesPath, iTexture->mTexture), iTexture->mTexture.mSamplerFlags});
     ++iTexture;
   }
 
   if(checkStage(EMISSIVE))
   {
-    raw.mTextures.push_back({LoadImageResource(imagesPath, iTexture->mTexture, FittingMode::DEFAULT, true), iTexture->mTexture.mSamplerFlags});
+    raw.mTextures.push_back({LoadImageResource(imagesPath, iTexture->mTexture), iTexture->mTexture.mSamplerFlags});
     ++iTexture;
   }
 
   if(checkStage(SPECULAR))
   {
-    raw.mTextures.push_back({LoadImageResource(imagesPath, iTexture->mTexture, FittingMode::DEFAULT, true), iTexture->mTexture.mSamplerFlags});
+    raw.mTextures.push_back({LoadImageResource(imagesPath, iTexture->mTexture), iTexture->mTexture.mSamplerFlags});
     ++iTexture;
   }
 
   if(checkStage(SPECULAR_COLOR))
   {
-    raw.mTextures.push_back({LoadImageResource(imagesPath, iTexture->mTexture, FittingMode::DEFAULT, true), iTexture->mTexture.mSamplerFlags});
+    raw.mTextures.push_back({LoadImageResource(imagesPath, iTexture->mTexture), iTexture->mTexture.mSamplerFlags});
     ++iTexture;
   }
 
@@ -409,8 +402,7 @@ TextureSet MaterialDefinition::Load(const EnvironmentDefinition::Vector& environ
 
 bool MaterialDefinition::CheckTextures(uint32_t flags) const
 {
-  return std::find_if(mTextureStages.begin(), mTextureStages.end(), [flags](const TextureStage& ts)
-                      { return MaskMatch(ts.mSemantic, flags); }) != mTextureStages.end();
+  return std::find_if(mTextureStages.begin(), mTextureStages.end(), [flags](const TextureStage& ts) { return MaskMatch(ts.mSemantic, flags); }) != mTextureStages.end();
 }
 
 } // namespace Loader

diff --git a/dali-toolkit/internal/texture-manager/texture-cache-manager.cpp b/dali-toolkit/internal/texture-manager/texture-cache-manager.cpp
index 19c19bf318b4a5a5e7432826afb3ecf05120740c..0d8925704a2ea292c55b37b0badbef449a8ab59b 100644 (file)
--- a/dali-toolkit/internal/texture-manager/texture-cache-manager.cpp
+++ b/dali-toolkit/internal/texture-manager/texture-cache-manager.cpp
@@ -525,8 +525,8 @@ TextureCacheManager::TextureHash TextureCacheManager::GenerateHash(
     *hashTargetPtr++ = (size.GetHeight() >> 8u) & 0xff;
 
     // Bit-pack the FittingMode, SamplingMode.
-    // FittingMode=2bits, SamplingMode=3bits
-    *hashTargetPtr = (fittingMode << 3u) | (samplingMode);
+    // FittingMode=3bits, SamplingMode=4bits
+    *hashTargetPtr = (fittingMode << 4u) | (samplingMode);
   }
 
   // Append whether we will not correction orientation. We don't do additional job when it is true, the general cases.

diff --git a/dali-toolkit/internal/texture-manager/texture-manager-type.h b/dali-toolkit/internal/texture-manager/texture-manager-type.h
index 1f54fb7cbeeed95e3c56bc4165d9932a7f4159a2..10f0cec5de3ef216829aa43f6c93c98dedad3676 100644 (file)
--- a/dali-toolkit/internal/texture-manager/texture-manager-type.h
+++ b/dali-toolkit/internal/texture-manager/texture-manager-type.h
@@ -270,8 +270,8 @@ struct TextureInfo
   float                      scaleFactor;          ///< The scale factor to apply to the Texture when masking
   int32_t                    referenceCount;       ///< The reference count of clients using this Texture
   LoadState                  loadState;            ///< The load state showing the load progress of the Texture
-  Dali::FittingMode::Type    fittingMode : 3;      ///< The requested FittingMode
-  Dali::SamplingMode::Type   samplingMode : 3;     ///< The requested SamplingMode
+  Dali::FittingMode::Type    fittingMode : 4;      ///< The requested FittingMode
+  Dali::SamplingMode::Type   samplingMode : 5;     ///< The requested SamplingMode
   StorageType                storageType;          ///< CPU storage / GPU upload;
   Dali::AnimatedImageLoading animatedImageLoading; ///< AnimatedImageLoading that contains animated image information.
   uint32_t                   frameIndex;           ///< Frame index that be loaded, in case of animated image

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 4ccaa6641d431b7b7bfe33e948deaf11b288f155..a643e0153cdd4fb3950fabb422f92e829462eaa8 100644 (file)
--- a/dali-toolkit/internal/visuals/animated-image/animated-image-visual.cpp
+++ b/dali-toolkit/internal/visuals/animated-image/animated-image-visual.cpp
@@ -57,6 +57,7 @@ DALI_ENUM_TO_STRING_TABLE_BEGIN(FITTING_MODE)
   DALI_ENUM_TO_STRING_WITH_SCOPE(Dali::FittingMode, SCALE_TO_FILL)
   DALI_ENUM_TO_STRING_WITH_SCOPE(Dali::FittingMode, FIT_WIDTH)
   DALI_ENUM_TO_STRING_WITH_SCOPE(Dali::FittingMode, FIT_HEIGHT)
+  DALI_ENUM_TO_STRING_WITH_SCOPE(Dali::FittingMode, VISUAL_FITTING)
   DALI_ENUM_TO_STRING_WITH_SCOPE(Dali::FittingMode, DEFAULT)
 DALI_ENUM_TO_STRING_TABLE_END(FITTING_MODE)
 
@@ -69,6 +70,9 @@ DALI_ENUM_TO_STRING_TABLE_BEGIN(SAMPLING_MODE)
   DALI_ENUM_TO_STRING_WITH_SCOPE(Dali::SamplingMode, BOX_THEN_LINEAR)
   DALI_ENUM_TO_STRING_WITH_SCOPE(Dali::SamplingMode, NO_FILTER)
   DALI_ENUM_TO_STRING_WITH_SCOPE(Dali::SamplingMode, DONT_CARE)
+  DALI_ENUM_TO_STRING_WITH_SCOPE(Dali::SamplingMode, LANCZOS)
+  DALI_ENUM_TO_STRING_WITH_SCOPE(Dali::SamplingMode, BOX_THEN_LANCZOS)
+  DALI_ENUM_TO_STRING_WITH_SCOPE(Dali::SamplingMode, DEFAULT)
 DALI_ENUM_TO_STRING_TABLE_END(SAMPLING_MODE)
 
 // stop behavior
@@ -282,9 +286,9 @@ AnimatedImageVisual::AnimatedImageVisual(VisualFactoryCache& factoryCache, Image
   mActionStatus(DevelAnimatedImageVisual::Action::PLAY),
   mWrapModeU(WrapMode::DEFAULT),
   mWrapModeV(WrapMode::DEFAULT),
+  mStopBehavior(DevelImageVisual::StopBehavior::CURRENT_FRAME),
   mFittingMode(FittingMode::VISUAL_FITTING),
   mSamplingMode(SamplingMode::BOX_THEN_LINEAR),
-  mStopBehavior(DevelImageVisual::StopBehavior::CURRENT_FRAME),
   mStartFirstFrame(false),
   mIsJumpTo(false)
 {

diff --git a/dali-toolkit/internal/visuals/animated-image/animated-image-visual.h b/dali-toolkit/internal/visuals/animated-image/animated-image-visual.h
index 63e87aeb152bc39af1b84d9a8867e1362aaa13e1..e65cd7a14215ae65b55b95e557a37668a947cee0 100644 (file)
--- a/dali-toolkit/internal/visuals/animated-image/animated-image-visual.h
+++ b/dali-toolkit/internal/visuals/animated-image/animated-image-visual.h
@@ -314,9 +314,9 @@ private:
 
   Dali::WrapMode::Type                 mWrapModeU : 3;
   Dali::WrapMode::Type                 mWrapModeV : 3;
-  Dali::FittingMode::Type              mFittingMode : 3;
-  Dali::SamplingMode::Type             mSamplingMode : 4;
   DevelImageVisual::StopBehavior::Type mStopBehavior : 2;
+  Dali::FittingMode::Type              mFittingMode : 4;
+  Dali::SamplingMode::Type             mSamplingMode : 5;
   bool                                 mStartFirstFrame : 1;
   bool                                 mIsJumpTo : 1;
 };

diff --git a/dali-toolkit/internal/visuals/animated-image/image-cache.cpp b/dali-toolkit/internal/visuals/animated-image/image-cache.cpp
index ece9014ea7ff0f60423d0c7a43e2a71b30e91ea8..4574e01535f1dee76ef1ed435c8fa7d1f969e790 100644 (file)
--- a/dali-toolkit/internal/visuals/animated-image/image-cache.cpp
+++ b/dali-toolkit/internal/visuals/animated-image/image-cache.cpp
@@ -36,11 +36,11 @@ ImageCache::ImageCache(TextureManager&                     textureManager,
   mObserver(observer),
   mMaskingData(maskingData),
   mDesiredSize(size),
-  mFittingMode(fittingMode),
-  mSamplingMode(samplingMode),
   mBatchSize(batchSize),
   mInterval(interval),
   mLoadState(TextureManager::LoadState::NOT_STARTED),
+  mFittingMode(fittingMode),
+  mSamplingMode(samplingMode),
   mRequestingLoad(false),
   mPreMultiplyOnLoad(preMultiplyOnLoad)
 {

diff --git a/dali-toolkit/internal/visuals/animated-image/image-cache.h b/dali-toolkit/internal/visuals/animated-image/image-cache.h
index aee80b27514901a40392ffbeaf63cbfc0d78d5de..84c4d1e31118031de44ec588968de4dcaadbef27 100644 (file)
--- a/dali-toolkit/internal/visuals/animated-image/image-cache.h
+++ b/dali-toolkit/internal/visuals/animated-image/image-cache.h
@@ -144,11 +144,11 @@ protected:
   FrameReadyObserver&                 mObserver;
   TextureManager::MaskingDataPointer& mMaskingData;
   Dali::ImageDimensions               mDesiredSize;
-  Dali::FittingMode::Type             mFittingMode : 3;
-  Dali::SamplingMode::Type            mSamplingMode : 4;
   uint32_t                            mBatchSize;
   uint32_t                            mInterval;
   TextureManager::LoadState           mLoadState;
+  Dali::FittingMode::Type             mFittingMode : 4;
+  Dali::SamplingMode::Type            mSamplingMode : 5;
   bool                                mRequestingLoad : 1;
   bool                                mPreMultiplyOnLoad : 1;
 };

diff --git a/dali-toolkit/internal/visuals/image/image-visual.cpp b/dali-toolkit/internal/visuals/image/image-visual.cpp
index f299975907ec23ed49f7e6a1fd61a0e35927fce0..7c535bfbda182ed94d03d0dc3b6f6ac00f23a6a4 100644 (file)
--- a/dali-toolkit/internal/visuals/image/image-visual.cpp
+++ b/dali-toolkit/internal/visuals/image/image-visual.cpp
@@ -76,6 +76,9 @@ DALI_ENUM_TO_STRING_TABLE_BEGIN(SAMPLING_MODE)
   DALI_ENUM_TO_STRING_WITH_SCOPE(Dali::SamplingMode, BOX_THEN_LINEAR)
   DALI_ENUM_TO_STRING_WITH_SCOPE(Dali::SamplingMode, NO_FILTER)
   DALI_ENUM_TO_STRING_WITH_SCOPE(Dali::SamplingMode, DONT_CARE)
+  DALI_ENUM_TO_STRING_WITH_SCOPE(Dali::SamplingMode, LANCZOS)
+  DALI_ENUM_TO_STRING_WITH_SCOPE(Dali::SamplingMode, BOX_THEN_LANCZOS)
+  DALI_ENUM_TO_STRING_WITH_SCOPE(Dali::SamplingMode, DEFAULT)
 DALI_ENUM_TO_STRING_TABLE_END(SAMPLING_MODE)
 
 // wrap modes

diff --git a/dali-toolkit/internal/visuals/image/image-visual.h b/dali-toolkit/internal/visuals/image/image-visual.h
index 690624ce911cabefd000882e5578b993543d4e59..e5060af6859f98ef834c05d3bc931416d09db5db 100644 (file)
--- a/dali-toolkit/internal/visuals/image/image-visual.h
+++ b/dali-toolkit/internal/visuals/image/image-visual.h
@@ -95,6 +95,8 @@ typedef IntrusivePtr<ImageVisual> ImageVisualPtr;
  *   "BOX_THEN_LINEAR"
  *   "NO_FILTER"
  *   "DONT_CARE"
+ *   "LANCZOS"
+ *   "BOX_THEN_LANCZOS"
  *   "DEFAULT"
  *
  * where loadPolicy should be one of the following image loading modes
@@ -386,8 +388,8 @@ private:
 
   ImageVisualShaderFactory& mImageVisualShaderFactory;
 
-  Dali::FittingMode::Type                         mFittingMode : 3;
-  Dali::SamplingMode::Type                        mSamplingMode : 4;
+  Dali::FittingMode::Type                         mFittingMode : 4;
+  Dali::SamplingMode::Type                        mSamplingMode : 5;
   Dali::WrapMode::Type                            mWrapModeU : 3;
   Dali::WrapMode::Type                            mWrapModeV : 3;
   Dali::Toolkit::ImageVisual::LoadPolicy::Type    mLoadPolicy;