#define DALI_TOOLKIT_TEXTURE_MANAGER_IMPL_H
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2019 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.
LOADING, ///< Loading has been started, but not finished.
LOAD_FINISHED, ///< Loading has finished. (for CPU storage only)
WAITING_FOR_MASK,///< Loading has finished, but waiting for mask image
+ MASK_APPLYING, ///< Loading has finished, Mask is applying
+ MASK_APPLIED, ///< Loading has finished, Mask is applyied by GPU
UPLOADED, ///< Uploaded and ready. (For GPU upload only)
CANCELLED, ///< Removed before loading completed
LOAD_FAILED ///< Async loading failed, e.g. connection problem
};
using MaskingDataPointer = std::unique_ptr<MaskingData>;
+
+ /**
+ * Class to provide lifecycle event on destruction of texture manager.
+ */
+ struct LifecycleObserver
+ {
+ /**
+ * Called shortly before the texture manager is destroyed.
+ */
+ virtual void TextureManagerDestroyed() = 0;
+ };
+
/**
* Constructor.
*/
/**
* Destructor.
*/
- ~TextureManager() = default;
-
+ ~TextureManager();
// TextureManager Main API:
* @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] maskInfo Mask info structure
+ * @param[in, out] maskInfo Mask info structure
* @param[in] synchronousLoading true if the URL should be loaded synchronously
* @param[out] textureId, The textureId of the URL
- * @param[out] textureRect The rectangle within the texture atlas that this URL occupies
+ * @param[out] textureRect The rectangle within the texture atlas that this URL occupies,
+ * this is the rectangle in normalized coordinates.
+ * @param[out] textureRectSize The rectangle within the texture atlas that this URL occupies,
+ * this is the same rectangle in pixels.
* @param[in,out] atlasingStatus Set to USE_ATLAS to attempt atlasing. If atlasing fails, the image will still
* be loaded, and marked successful, but this will be set to false.
* If atlasing succeeds, this will be set to true.
Dali::ImageDimensions desiredSize,
Dali::FittingMode::Type fittingMode,
Dali::SamplingMode::Type samplingMode,
- const MaskingDataPointer& maskInfo,
+ MaskingDataPointer& maskInfo,
bool synchronousLoading,
TextureManager::TextureId& textureId,
Vector4& textureRect,
+ Dali::ImageDimensions& textureRectSize,
bool& atlasingStatus,
bool& loadingStatus,
Dali::WrapMode::Type wrapModeU,
void Remove( const TextureManager::TextureId textureId );
/**
- * Get the visualUrl associated with the texture id
+ * @brief Get the visualUrl associated with the texture id.
+ * @param[in] textureId The texture Id to get
+ * @return The visual Url associated with the texture id.
*/
- const VisualUrl& GetVisualUrl( TextureId textureId );
+ VisualUrl GetVisualUrl( TextureId textureId );
/**
* @brief Get the current state of a texture
*/
TextureSet RemoveExternalTexture( const std::string& url );
+ /**
+ * Add an observer to the object.
+ * @param[in] observer The observer to add.
+ */
+ void AddObserver( TextureManager::LifecycleObserver& observer );
+
+ /**
+ * Remove an observer from the object
+ * @pre The observer has already been added.
+ * @param[in] observer The observer to remove.
+ */
+ void RemoveObserver( TextureManager::LifecycleObserver& observer );
+
+ /**
+ * @brief Set an image to be used when a visual has failed to correctly render
+ * @param[in] brokenImageUrl The broken image url.
+ */
+ void SetBrokenImageUrl(const std::string& brokenImageUrl);
+
private:
/**
typedef size_t TextureHash; ///< The type used to store the hash used for Texture caching.
+ // Structs:
+
/**
* @brief This struct is used to manage the life-cycle of Texture loading and caching.
*/
TextureManager::TextureHash hash; ///< The hash used to cache this Texture
float scaleFactor; ///< The scale factor to apply to the Texture when masking
int16_t referenceCount; ///< The reference count of clients using this Texture
- LoadState loadState:3; ///< The load state showing the load progress of the Texture
+ LoadState loadState:4; ///< The load state showing the load progress of the Texture
FittingMode::Type fittingMode:2; ///< The requested FittingMode
Dali::SamplingMode::Type samplingMode:3; ///< The requested SamplingMode
- StorageType storageType:1; ///< CPU storage / GPU upload;
+ StorageType storageType:2; ///< CPU storage / GPU upload;
bool loadSynchronously:1; ///< True if synchronous loading was requested
- UseAtlas useAtlas:1; ///< USE_ATLAS if an atlas was requested.
+ UseAtlas useAtlas:2; ///< USE_ATLAS if an atlas was requested.
///< This is updated to false if atlas is not used
bool cropToMask:1; ///< true if the image should be cropped to the mask size.
bool orientationCorrection:1; ///< true if the image should be rotated to match exif orientation data
bool preMultiplied:1; ///< true if the image's color was multiplied by it's alpha
};
- // Structs:
+ /**
+ * Structure to hold info about a texture load queued during NotifyObservers
+ */
+ struct LoadQueueElement
+ {
+ LoadQueueElement( TextureId textureId, TextureUploadObserver* observer )
+ : mTextureId( textureId ),
+ mObserver( observer )
+ {
+ }
+
+ TextureId mTextureId; ///< The texture id of the requested load.
+ TextureUploadObserver* mObserver; ///< Observer of texture load.
+ };
/**
* Struct to hold information about a requested Async load.
typedef std::vector<TextureInfo> TextureInfoContainerType; ///< The container type used to manage the life-cycle and caching of Textures
/**
+ * @brief Initiate a load or queue load if NotifyObservers is invoking callbacks
+ * @param[in] textureInfo The TextureInfo struct associated with the Texture
+ * @param[in] observer The observer wishing to observe the texture upload
+ */
+ void LoadOrQueueTexture( TextureInfo& textureInfo, TextureUploadObserver* observer );
+
+ /**
+ * @brief Queue a texture load to be subsequently handled by ProcessQueuedTextures.
+ * @param[in] textureInfo The TextureInfo struct associated with the Texture
+ * @param[in] observer The observer wishing to observe the texture upload
+ */
+ void QueueLoadTexture( TextureInfo& textureInfo, TextureUploadObserver* observer );
+
+ /**
* @brief Used internally to initiate a load.
* @param[in] textureInfo The TextureInfo struct associated with the Texture
- * @return True if the load was initiated
+ * @param[in] observer The observer wishing to observe the texture upload
+ */
+ void LoadTexture( TextureInfo& textureInfo, TextureUploadObserver* observer );
+
+ /**
+ * @brief Initiate load of textures queued whilst NotifyObservers invoking callbacks.
*/
- bool LoadTexture( TextureInfo& textureInfo );
+ void ProcessQueuedTextures();
/**
* Add the observer to the observer list
* @param[in] textureInfo The TextureInfo struct associated with the texture
- * observer The observer wishing to observe the texture upload
+ * @param[in] observer The observer wishing to observe the texture upload
*/
void ObserveTexture( TextureInfo & textureInfo, TextureUploadObserver* observer );
/**
* Apply the mask to the pixelBuffer.
- * @param[in] pixelBuffer The pixelBuffer to apply the mask to
+ * @param[in] textureInfo The information of texture to apply the mask to
* @param[in] maskTextureId The texture id of the mask.
- * @param[in] contentScale The factor to scale the content
- * @param[in] cropToMask Whether to crop the content to the mask size
*/
- void ApplyMask( Devel::PixelBuffer& pixelBuffer, TextureId maskTextureId,
- float contentScale, bool cropToMask );
+ void ApplyMask( TextureInfo& textureInfo, TextureId maskTextureId );
/**
* Upload the texture specified in pixelBuffer to the appropriate location
TextureHash GenerateHash( const std::string& url, const ImageDimensions size,
const FittingMode::Type fittingMode,
const Dali::SamplingMode::Type samplingMode, const UseAtlas useAtlas,
- TextureId maskTextureId,
- MultiplyOnLoad preMultiplyOnLoad);
+ TextureId maskTextureId );
+
/**
* @brief Looks up a cached texture by its hash.
* If found, the given parameters are used to check there is no hash-collision.
* @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] preMultiplyOnLoad if the image's color should be multiplied by it's alpha. Set to OFF if there is no alpha or if the image need to be applied alpha mask.
*/
void Load(TextureId textureId,
const VisualUrl& url,
ImageDimensions desiredSize,
FittingMode::Type fittingMode,
SamplingMode::Type samplingMode,
- bool orientationCorrection);
+ bool orientationCorrection,
+ DevelAsyncImageLoader::PreMultiplyOnLoad preMultiplyOnLoad);
+
+ /**
+ * @brief Apply mask
+ * @param [in] id of the texture
+ * @param [in] pixelBuffer of the to be masked image
+ * @param [in] maskPixelBuffer of the mask image
+ * @param [in] contentScale The factor to scale the content
+ * @param [in] cropToMask Whether to crop the content to the mask size
+ * @param [in] preMultiplyOnLoad if the image's color should be multiplied by it's alpha. Set to OFF if there is no alpha.
+ */
+ void ApplyMask( TextureId textureId,
+ Devel::PixelBuffer pixelBuffer,
+ Devel::PixelBuffer maskPixelBuffer,
+ float contentScale,
+ bool cropToMask,
+ DevelAsyncImageLoader::PreMultiplyOnLoad preMultiplyOnLoad );
public:
AsyncLoadingHelper(const AsyncLoadingHelper&) = delete;
/**
* @brief Main constructor that used by all other constructors
*/
- AsyncLoadingHelper(Toolkit::AsyncImageLoader loader,
- TextureManager& textureManager,
- AsyncLoadingInfoContainerType&& loadingInfoContainer);
+ AsyncLoadingHelper( Toolkit::AsyncImageLoader loader,
+ TextureManager& textureManager,
+ AsyncLoadingInfoContainerType&& loadingInfoContainer );
/**
* @brief Callback to be called when texture loading is complete, it passes the pixel buffer on to texture manager.
* @param[in] id Loader id
* @param[in] pixelBuffer Image data
*/
- void AsyncLoadComplete(uint32_t id, Devel::PixelBuffer pixelBuffer);
+ void AsyncLoadComplete( uint32_t id, Devel::PixelBuffer pixelBuffer );
private:
Toolkit::AsyncImageLoader mLoader;
RoundRobinContainerView< AsyncLoadingHelper > mAsyncLocalLoaders; ///< The Asynchronous image loaders used to provide all local async loads
RoundRobinContainerView< AsyncLoadingHelper > mAsyncRemoteLoaders; ///< The Asynchronous image loaders used to provide all remote async loads
std::vector< ExternalTextureInfo > mExternalTextures; ///< Externally provided textures
+ Dali::Vector<LifecycleObserver*> mLifecycleObservers; ///< Lifecycle observers of texture manager
+ Dali::Vector<LoadQueueElement> mLoadQueue; ///< Queue of textures to load after NotifyObservers
+ std::string mBrokenImageUrl; ///< Broken image url
TextureId mCurrentTextureId; ///< The current value used for the unique Texture Id generation
+ bool mQueueLoadFlag; ///< Flag that causes Load Textures to be queued.
};
projects / platform / core / uifw / dali-toolkit.git / blobdiff