#define DALI_TOOLKIT_TEXTURE_MANAGER_IMPL_H
/*
- * Copyright (c) 2022 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2023 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.
#include <dali/devel-api/adaptor-framework/animated-image-loading.h>
#include <dali/devel-api/adaptor-framework/pixel-buffer.h>
#include <dali/public-api/adaptor-framework/encoded-image-buffer.h>
+#include <dali/public-api/adaptor-framework/round-robin-container-view.h>
#include <dali/public-api/common/dali-vector.h>
#include <dali/public-api/rendering/geometry.h>
// INTERNAL INCLUDES
#include <dali-toolkit/devel-api/image-loader/image-atlas.h>
-#include <dali-toolkit/internal/helpers/round-robin-container-view.h>
#include <dali-toolkit/internal/texture-manager/texture-cache-manager.h>
#include <dali-toolkit/internal/texture-manager/texture-manager-type.h>
#include <dali-toolkit/internal/texture-manager/texture-upload-observer.h>
TextureManager::TextureId mAlphaMaskId;
float mContentScaleFactor;
bool mCropToMask;
+ bool mPreappliedMasking;
+ bool mMaskImageLoadingFailed;
};
using MaskingDataPointer = std::unique_ptr<MaskingData>;
* The parameters are used to specify how the animated image is loaded.
* The observer has the LoadComplete method called when the load is ready.
*
- * @param[in] animatedImageLoading The AnimatedImageLoading that contain the animated image information
- * @param[in] frameIndex The frame index to load.
- * @param[in] samplingMode The SamplingMode to use
- * @param[in] synchronousLoading true if the frame should be loaded synchronously
- * @param[out] textureId The textureId of the frame
- * @param[in] wrapModeU Horizontal Wrap mode
- * @param[in] wrapModeV Vertical Wrap mode
- * @param[in] textureObserver The client object should inherit from this and provide the "UploadCompleted" virtual.
- * This is called when an image load completes (or fails).
+ * @param[in] url The URL of the image to load
+ * @param[in] animatedImageLoading The AnimatedImageLoading that contain the animated image information
+ * @param[in] frameIndex The frame index to load.
+ * @param[out] textureId The textureId of the frame
+ * @param[in, out] maskInfo Mask info structure
+ * @param[in] desiredSize The size the image is likely to appear at. This can be set to 0, 0 for automatic
+ * @param[in] fittingMode The FittingMode to use
+ * @param[in] samplingMode The SamplingMode to use
+ * @param[in] synchronousLoading true if the frame should be loaded synchronously
+ * @param[in] textureObserver The client object should inherit from this and provide the "LoadCompleted" virtual.
+ * This is called when an image load completes (or fails).
+ * @param[in,out] preMultiplyOnLoad True if the image color should be multiplied by it's alpha. Set to false if the
+ * image has no alpha channel
*
- * @return The texture set containing the frame of animated image, or empty if still loading.
+ * @return The texture set containing the frame of animated image, or empty if still loading.
*/
- TextureSet LoadAnimatedImageTexture(
- Dali::AnimatedImageLoading animatedImageLoading,
- const std::uint32_t& frameIndex,
- const Dali::SamplingMode::Type& samplingMode,
- const bool& synchronousLoading,
- TextureManager::TextureId& textureId,
- const Dali::WrapMode::Type& wrapModeU,
- const Dali::WrapMode::Type& wrapModeV,
- TextureUploadObserver* textureObserver);
+ TextureSet LoadAnimatedImageTexture(const VisualUrl& url,
+ Dali::AnimatedImageLoading animatedImageLoading,
+ const uint32_t& frameIndex,
+ TextureManager::TextureId& textureId,
+ MaskingDataPointer& maskInfo,
+ const Dali::ImageDimensions& desiredSize,
+ const Dali::FittingMode::Type& fittingMode,
+ const Dali::SamplingMode::Type& samplingMode,
+ const bool& synchronousLoading,
+ TextureUploadObserver* textureObserver,
+ TextureManager::MultiplyOnLoad& preMultiplyOnLoad);
/**
* @brief Requests an image load of the given URL to get PixelBuffer.
* @param[in] fittingMode The FittingMode to use
* @param[in] samplingMode The SamplingMode to use
* @param[in] synchronousLoading true if the URL should be loaded synchronously
- * @param[in] textureObserver The client object should inherit from this and provide the "UploadCompleted" virtual.
+ * @param[in] textureObserver The client object should inherit from this and provide the "LoadCompleted" virtual.
* This is called when an image load completes (or fails).
* @param[in] orientationCorrection Whether to rotate image to match embedded orientation data
* @param[in,out] preMultiplyOnLoad True if the image color should be multiplied by it's alpha. Set to false if the
* be loaded, and marked successful, but this will be set to false.
* If atlasing succeeds, this will be set to true.
* @param[out] loadingStatus The loading status of the texture
- * @param[in] wrapModeU Horizontal Wrap mode
- * @param[in] wrapModeV Vertical Wrap mode
- * @param[in] textureObserver The client object should inherit from this and provide the "UploadCompleted" virtual.
+ * @param[in] textureObserver The client object should inherit from this and provide the "LoadCompleted" virtual.
* This is called when an image load completes (or fails).
* @param[in] atlasObserver This is used if the texture is atlased, and will be called instead of
- * textureObserver.UploadCompleted
+ * textureObserver.LoadCompleted
* @param[in] imageAtlasManager The atlas manager to use for atlasing textures
* @param[in] orientationCorrection Whether to rotate image to match embedded orientation data
* @param[in] reloadPolicy Forces a reload of the texture even if already cached
Dali::ImageDimensions& textureRectSize,
bool& atlasingStatus,
bool& loadingStatus,
- const Dali::WrapMode::Type& wrapModeU,
- const Dali::WrapMode::Type& wrapModeV,
TextureUploadObserver* textureObserver,
AtlasUploadObserver* atlasObserver,
ImageAtlasManagerPtr imageAtlasManager,
*/
Geometry GetRenderGeometry(const TextureManager::TextureId& textureId, std::uint32_t& frontElements, std::uint32_t& backElements);
+ /**
+ * @brief Returns the textureSet in texture manager.
+ * @param[in] textureId Id of the texture
+ * @return The textureSet in texture manager. These textures include YUV textures or images and masks.
+ */
+ TextureSet GetTextureSet(const TextureManager::TextureId& textureId);
+
+ /**
+ * @brief Returns the textureSet in texture manager.
+ * @param[in] textureInfo the information of the texture
+ * @return The textureSet in texture manager. These textures include YUV textures or images and masks.
+ */
+ TextureSet GetTextureSet(const TextureManager::TextureInfo& textureInfo);
+
public:
// API list that need to access TextureCacheManager.
}
/**
- * @copydoc TextureCacheManager::GetTextureSet
+ * @copydoc TextureCacheManager::GetTexture
*/
- inline TextureSet GetTextureSet(const TextureManager::TextureId& textureId)
+ inline Texture GetTexture(const TextureManager::TextureId& textureId)
{
- return mTextureCacheManager.GetTextureSet(textureId);
+ return mTextureCacheManager.GetTexture(textureId);
}
/**
}
/**
- * @copydoc TextureCacheManager::RemoveExternalEncodedImageBuffer
+ * @copydoc TextureCacheManager::RemoveEncodedImageBuffer
*/
- inline EncodedImageBuffer RemoveExternalEncodedImageBuffer(const std::string& url)
+ inline EncodedImageBuffer RemoveEncodedImageBuffer(const std::string& url)
{
- return mTextureCacheManager.RemoveExternalEncodedImageBuffer(url);
+ return mTextureCacheManager.RemoveEncodedImageBuffer(url);
}
/**
/**
* @copydoc TextureCacheManager::AddExternalTexture
*/
- inline std::string AddExternalTexture(const TextureSet& texture)
+ inline std::string AddExternalTexture(const TextureSet& texture, bool preMultiplied = false)
{
- return mTextureCacheManager.AddExternalTexture(texture);
+ return mTextureCacheManager.AddExternalTexture(texture, preMultiplied);
}
/**
- * @copydoc TextureCacheManager::AddExternalEncodedImageBuffer
+ * @copydoc TextureCacheManager::AddEncodedImageBuffer
*/
- inline std::string AddExternalEncodedImageBuffer(const EncodedImageBuffer& encodedImageBuffer)
+ inline std::string AddEncodedImageBuffer(const EncodedImageBuffer& encodedImageBuffer)
{
- return mTextureCacheManager.AddExternalEncodedImageBuffer(encodedImageBuffer);
+ return mTextureCacheManager.AddEncodedImageBuffer(encodedImageBuffer);
}
public: // Load Request API
* @param[in] fittingMode The FittingMode to use
* @param[in] samplingMode The SamplingMode to use
* @param[in] useAtlasing Set to USE_ATLAS to attempt atlasing. If atlasing fails, the image will still be loaded, and marked successful,
- * but "useAtlasing" will be set to false in the "UploadCompleted" callback from the TextureManagerUploadObserver.
- * @param[in] observer The client object should inherit from this and provide the "UploadCompleted" virtual.
+ * but "useAtlasing" will be set to false in the "LoadCompleted" callback from the TextureManagerUploadObserver.
+ * @param[in] observer The client object should inherit from this and provide the "LoadCompleted" virtual.
* This is called when an image load completes (or fails).
* @param[in] orientationCorrection Whether to rotate image to match embedded orientation data
* @param[in] reloadPolicy Forces a reload of the texture even if already cached
* default is false.
* @return A TextureId to use as a handle to reference this Texture
*/
- TextureManager::TextureId RequestLoad(
+ TextureId RequestLoad(
const VisualUrl& url,
const ImageDimensions& desiredSize,
const Dali::FittingMode::Type& fittingMode,
* @param[in] samplingMode The SamplingMode to use
* @param[in] useAtlasing Set to USE_ATLAS to attempt atlasing. If atlasing fails, the image will still
* be loaded, and marked successful,
- * but "useAtlasing" will be set to false in the "UploadCompleted" callback from
+ * but "useAtlasing" will be set to false in the "LoadCompleted" callback from
* the TextureManagerUploadObserver.
* @param[in] cropToMask Only used with masking, this will crop the scaled image to the mask size.
* If false, then the mask will be scaled to fit the image before being applied.
- * @param[in] observer The client object should inherit from this and provide the "UploadCompleted"
+ * @param[in] observer The client object should inherit from this and provide the "LoadCompleted"
* virtual.
* This is called when an image load completes (or fails).
* @param[in] orientationCorrection Whether to rotate image to match embedded orientation data
* default is false.
* @return A TextureId to use as a handle to reference this Texture
*/
- TextureManager::TextureId RequestLoad(
+ TextureId RequestLoad(
const VisualUrl& url,
const TextureManager::TextureId& maskTextureId,
const float& contentScale,
* @brief Requests a masking image to be loaded. This mask is not uploaded to GL,
* instead, it is stored in CPU memory, and can be used for CPU blending.
* @param[in] maskUrl The URL of the mask image to load
+ * @param[in] storageType, Whether the pixel data is stored in the cache or uploaded to the GPU
* @param[in] synchronousLoading True if the frame should be loaded synchronously. If you skip this parameter,
* default is false.
* @return A TextureId to use as a handle to reference this mask Texture
*/
- TextureManager::TextureId RequestMaskLoad(
+ TextureId RequestMaskLoad(
const VisualUrl& maskUrl,
+ StorageType storageType,
const bool& synchronousLoading = false);
private:
* @param[in] samplingMode The SamplingMode to use
* @param[in] useAtlasing Set to USE_ATLAS to attempt atlasing. If atlasing fails, the image will still be
* loaded, and marked successful, but "useAtlasing" will be set to false in the
- * "UploadCompleted" callback from the TextureManagerUploadObserver.
+ * "LoadCompleted" callback from the TextureManagerUploadObserver.
* @param[in] cropToMask Whether to crop the target after masking, or scale the mask to the image before
* masking.
* @param[in] storageType, Whether the pixel data is stored in the cache or uploaded to the GPU
- * @param[in] observer The client object should inherit from this and provide the "UploadCompleted"
+ * @param[in] observer The client object should inherit from this and provide the "LoadCompleted"
* virtual.
* This is called when an image load completes (or fails).
* @param[in] orientationCorrection Whether to rotate image to match embedded orientation data
* default is false.
* @return A TextureId to use as a handle to reference this Texture
*/
- TextureManager::TextureId RequestLoadInternal(
+ TextureId RequestLoadInternal(
const VisualUrl& url,
const TextureManager::TextureId& maskTextureId,
const float& contentScale,
* @param[in] samplingMode The SamplingMode to use
* @param[in] orientationCorrection Whether to use image metadata to rotate or flip the image,
* e.g., from portrait to landscape
+ * @param[in] loadYuvPlanes True if the image should be loaded as yuv planes
+ * @param[out] pixelBuffers The image pixelBuffer
* @return PixelBuffer of loaded image.
*/
- Devel::PixelBuffer LoadImageSynchronously(
- const VisualUrl& url,
- const Dali::ImageDimensions& desiredSize,
- const Dali::FittingMode::Type& fittingMode,
- const Dali::SamplingMode::Type& samplingMode,
- const bool& orientationCorrection);
+ void LoadImageSynchronously(
+ const VisualUrl& url,
+ const Dali::ImageDimensions& desiredSize,
+ const Dali::FittingMode::Type& fittingMode,
+ const Dali::SamplingMode::Type& samplingMode,
+ const bool& orientationCorrection,
+ const bool& loadYuvPlanes,
+ std::vector<Devel::PixelBuffer>& pixelBuffers);
private:
// Load and queue
/**
* Structure to hold info about a texture load queued during NotifyObservers
*/
- struct LoadQueueElement
+ struct QueueElement
{
- LoadQueueElement(TextureManager::TextureId textureId, TextureUploadObserver* observer)
+ QueueElement(TextureManager::TextureId textureId, TextureUploadObserver* observer)
: mTextureId(textureId),
mObserver(observer)
{
/**
* @brief Initiate load of textures queued whilst NotifyObservers invoking callbacks.
*/
- void ProcessQueuedTextures();
+ void ProcessLoadQueue();
+
+ /**
+ * @brief Initiate remove of texture queued whilst NotifyObservers invoking callbacks.
+ */
+ void ProcessRemoveQueue();
/**
* Add the observer to the observer list
/**
* @brief Performs Post-Load steps including atlasing.
- * @param[in] textureInfo The struct associated with this Texture
- * @param[in] pixelBuffer The image pixelBuffer
+ * @param[in] textureInfo The struct associated with this Texture
+ * @param[in] pixelBuffers The image pixelBuffer
* @return True if successful
*/
- void PostLoad(TextureManager::TextureInfo& textureInfo, Devel::PixelBuffer& pixelBuffer);
+ void PostLoad(TextureManager::TextureInfo& textureInfo, std::vector<Devel::PixelBuffer>& pixelBuffers);
/**
* Check if there is a texture waiting to be masked. If there
/**
* Upload the texture specified in pixelBuffer to the appropriate location
- * @param[in] pixelBuffer The image data to upload
- * @param[in] textureInfo The texture info containing the location to
- * store the data to.
+ * @param[in] pixelBuffers The image data to upload
+ * @param[in] textureInfo The texture info containing the location to store the data to.
*/
- void UploadTexture(Devel::PixelBuffer& pixelBuffer, TextureManager::TextureInfo& textureInfo);
+ void UploadTextures(std::vector<Devel::PixelBuffer>& pixelBuffers, TextureManager::TextureInfo& textureInfo);
/**
* Notify the current observers that the texture upload is complete,
*/
void NotifyObservers(TextureManager::TextureInfo& textureInfo, const bool& success);
+ /**
+ * Call LoadComplete to the observer.
+ * @param[in] observer The client object should inherit from this and provide the "LoadCompleted"
+ * @param[in] textureInfo The struct associated with this Texture
+ * @param[in] success If the pixel data was retrieved successfully and uploaded to GPU
+ */
+ void EmitLoadComplete(TextureUploadObserver* observer, TextureManager::TextureInfo& textureInfo, const bool& success);
+
+ /**
+ * @brief Remove observer in textureInfo
+ *
+ * @param textureInfo The struct associated with this Texture.
+ * @param observer The observer wishing to remove.
+ */
+ void RemoveTextureObserver(TextureManager::TextureInfo& textureInfo, TextureUploadObserver* observer);
+
public:
/**
* @brief Common method to handle loading completion.
* TextureAsyncLoadingHelper will call this API After async loading finished.
- * @param[in] textureId The ID of the texture load complete.
- * @param[in] pixelBuffer The loaded image data
+ * @param[in] textureId The ID of the texture load complete.
+ * @param[in] pixelBuffers The loaded image data
*/
- void AsyncLoadComplete(const TextureManager::TextureId& textureId, Devel::PixelBuffer pixelBuffer);
+ void AsyncLoadComplete(const TextureManager::TextureId& textureId, std::vector<Devel::PixelBuffer>& pixelBuffers);
private:
/**
*/
void ObserverDestroyed(TextureUploadObserver* observer);
-private: // Member Variables:
- TextureCacheManager mTextureCacheManager; ///< Manager the life-cycle and caching of Textures
-
- RoundRobinContainerView<TextureAsyncLoadingHelper> mAsyncLocalLoaders; ///< The Asynchronous image loaders used to provide all local async loads
- RoundRobinContainerView<TextureAsyncLoadingHelper> mAsyncRemoteLoaders; ///< The Asynchronous image loaders used to provide all remote async loads
-
- Dali::Vector<LifecycleObserver*> mLifecycleObservers; ///< Lifecycle observers of texture manager
- Dali::Vector<LoadQueueElement> mLoadQueue; ///< Queue of textures to load after NotifyObservers
- bool mQueueLoadFlag; ///< Flag that causes Load Textures to be queued.
+private: // Member Variables:
+ TextureCacheManager mTextureCacheManager; ///< Manager the life-cycle and caching of Textures
+ std::unique_ptr<TextureAsyncLoadingHelper> mAsyncLoader; ///< The Asynchronous image loader used to provide all local async loads
+ Dali::Vector<LifecycleObserver*> mLifecycleObservers; ///< Lifecycle observers of texture manager
+ Dali::Vector<QueueElement> mLoadQueue; ///< Queue of textures to load after NotifyObservers
+ Dali::Vector<QueueElement> mRemoveQueue; ///< Queue of textures to remove after NotifyObservers
+ TextureManager::TextureId mLoadingQueueTextureId; ///< TextureId when it is loading. it causes Load Textures to be queued.
+ bool mLoadYuvPlanes; ///< A global flag to specify if the image should be loaded as yuv planes
};
} // namespace Internal
projects / platform / core / uifw / dali-toolkit.git / blobdiff