X-Git-Url: http://review.tizen.org/git/?p=platform%2Fcore%2Fuifw%2Fdali-toolkit.git;a=blobdiff_plain;f=dali-toolkit%2Finternal%2Fvisuals%2Ftexture-manager-impl.h;h=a3da3fcd582ad522fb79fcd3dfbb6a339f486a3a;hp=d2c55fd768c59384317895e4e26b490b45d0b8ce;hb=f27c332dcf251d50ddfe3b2ab15ec2eaff5296b1;hpb=b70dd2c05e10d3bdf7d39b11fdd6f2688191fddb diff --git a/dali-toolkit/internal/visuals/texture-manager-impl.h b/dali-toolkit/internal/visuals/texture-manager-impl.h old mode 100755 new mode 100644 index d2c55fd..a3da3fc --- a/dali-toolkit/internal/visuals/texture-manager-impl.h +++ b/dali-toolkit/internal/visuals/texture-manager-impl.h @@ -2,7 +2,7 @@ #define DALI_TOOLKIT_TEXTURE_MANAGER_IMPL_H /* - * Copyright (c) 2019 Samsung Electronics Co., Ltd. + * Copyright (c) 2020 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. @@ -27,6 +27,7 @@ #include #include #include +#include // INTERNAL INCLUDES #include @@ -73,18 +74,19 @@ public: }; /** - * Whether the pixel data should be kept in TextureManager, or uploaded for rendering + * Whether the pixel data should be kept in TextureManager, returned with pixelBuffer or uploaded for rendering */ - enum StorageType + enum class StorageType: uint8_t { KEEP_PIXEL_BUFFER, + RETURN_PIXEL_BUFFER, UPLOAD_TO_TEXTURE }; /** * Whether the texture should be loaded synchronously or asynchronously. */ - enum LoadType + enum class LoadType: uint8_t { LOAD_ASYNCHRONOUSLY, LOAD_SYNCHRONOUSLY @@ -93,7 +95,7 @@ public: /** * @brief The LoadState Enumeration represents the current state of a particular Texture's life-cycle. */ - enum LoadState + enum class LoadState: uint8_t { NOT_STARTED, ///< Default LOADING, ///< Loading has been started, but not finished. @@ -158,11 +160,68 @@ public: /** * Destructor. */ - ~TextureManager(); + ~TextureManager() override; // TextureManager Main API: /** + * @brief Requests an frame of animated image load. + * + * 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). + * + * @return The texture set containing the frame of animated image, or empty if still loading. + */ + + TextureSet LoadAnimatedImageTexture( Dali::AnimatedImageLoading animatedImageLoading, + uint32_t frameIndex, + Dali::SamplingMode::Type samplingMode, + bool synchronousLoading, + TextureManager::TextureId& textureId, + Dali::WrapMode::Type wrapModeU, Dali::WrapMode::Type wrapModeV, + TextureUploadObserver* textureObserver ); + + /** + * @brief Requests an image load of the given URL to get PixelBuffer. + * + * The parameters are used to specify how the image is loaded. + * The observer has the LoadComplete method called when the load is ready. + * + * @param[in] url The URL of the image to load + * @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 URL should be loaded synchronously + * @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] 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 + * image has no alpha channel + * + * @return The pixel buffer containing the image, or empty if still loading. + */ + + Devel::PixelBuffer LoadPixelBuffer( const VisualUrl& url, + Dali::ImageDimensions desiredSize, + Dali::FittingMode::Type fittingMode, + Dali::SamplingMode::Type samplingMode, + bool synchronousLoading, + TextureUploadObserver* textureObserver, + bool orientationCorrection, + TextureManager::MultiplyOnLoad& preMultiplyOnLoad ); + + + /** * @brief Requests an image load of the given URL. * * The parameters are used to specify how the image is loaded. @@ -174,7 +233,7 @@ public: * @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, @@ -204,7 +263,7 @@ public: Dali::ImageDimensions desiredSize, Dali::FittingMode::Type fittingMode, Dali::SamplingMode::Type samplingMode, - const MaskingDataPointer& maskInfo, + MaskingDataPointer& maskInfo, bool synchronousLoading, TextureManager::TextureId& textureId, Vector4& textureRect, @@ -309,8 +368,9 @@ public: * occurrence of a Texture will cause its removal internally. * * @param[in] textureId The ID of the Texture to remove. + * @param[in] textureObserver The texture observer. */ - void Remove( const TextureManager::TextureId textureId ); + void Remove( const TextureManager::TextureId textureId, TextureUploadObserver* textureObserver ); /** * @brief Get the visualUrl associated with the texture id. @@ -367,6 +427,21 @@ public: */ void SetBrokenImageUrl(const std::string& brokenImageUrl); + /** + * @brief Get an image to be used when a visual has failed to correctly render + * @return Returns The broken image url. + */ + const std::string GetBrokenImageUrl(); + + /** + * @brief Returns the geometry associated with texture. + * @param[in] textureId Id of the texture + * @param[out] frontElements number of front elements + * @param[out] backElements number of back elements + * @return Returns valid geometry object + */ + Geometry GetRenderGeometry(TextureId textureId, uint32_t& frontElements, uint32_t& backElements ); + private: /** @@ -399,6 +474,8 @@ private: * @param[in] reloadPolicy Forces a reload of the texture even if already cached * @param[in] preMultiplyOnLoad True if the image color should be multiplied by it's alpha. Set to false if * there is no alpha + * @param[in] animatedImageLoading The AnimatedImageLoading to load animated image + * @param[in] frameIndex The frame index of a frame to be loaded frame * @return A TextureId to use as a handle to reference this Texture */ TextureId RequestLoadInternal( @@ -414,7 +491,9 @@ private: TextureUploadObserver* observer, bool orientationCorrection, TextureManager::ReloadPolicy reloadPolicy, - MultiplyOnLoad& preMultiplyOnLoad ); + MultiplyOnLoad& preMultiplyOnLoad, + Dali::AnimatedImageLoading animatedImageLoading, + uint32_t frameIndex ); /** * @brief Get the current state of a texture @@ -445,7 +524,9 @@ private: UseAtlas useAtlas, TextureManager::TextureHash hash, bool orientationCorrection, - bool preMultiplyOnLoad ) + bool preMultiplyOnLoad, + Dali::AnimatedImageLoading animatedImageLoading, + uint32_t frameIndex ) : url( url ), desiredSize( desiredSize ), useSize( desiredSize ), @@ -455,10 +536,12 @@ private: hash( hash ), scaleFactor( scaleFactor ), referenceCount( 1u ), - loadState( NOT_STARTED ), + loadState( LoadState::NOT_STARTED ), fittingMode( fittingMode ), samplingMode( samplingMode ), - storageType( UPLOAD_TO_TEXTURE ), + storageType( StorageType::UPLOAD_TO_TEXTURE ), + animatedImageLoading( animatedImageLoading ), + frameIndex( frameIndex ), loadSynchronously( loadSynchronously ), useAtlas( useAtlas ), cropToMask( cropToMask ), @@ -486,10 +569,12 @@ private: 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:4; ///< The load state showing the load progress of the Texture - FittingMode::Type fittingMode:2; ///< The requested FittingMode + LoadState loadState; ///< The load state showing the load progress of the Texture + FittingMode::Type fittingMode:3; ///< The requested FittingMode Dali::SamplingMode::Type samplingMode:3; ///< The requested SamplingMode - StorageType storageType:2; ///< CPU storage / GPU upload; + 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 bool loadSynchronously:1; ///< True if synchronous loading was requested UseAtlas useAtlas:2; ///< USE_ATLAS if an atlas was requested. ///< This is updated to false if atlas is not used @@ -587,9 +672,8 @@ private: * @param[in] container The Async loading container * @param[in] id This is the async image loaders Id * @param[in] pixelBuffer The loaded image data - * @param[in] isMaskTask whether this task is for mask or not */ - void AsyncLoadComplete( AsyncLoadingInfoContainerType& container, uint32_t id, Devel::PixelBuffer pixelBuffer, bool isMaskTask ); + void AsyncLoadComplete( AsyncLoadingInfoContainerType& container, uint32_t id, Devel::PixelBuffer pixelBuffer ); /** * @brief Performs Post-Load steps including atlasing. @@ -622,6 +706,14 @@ private: void UploadTexture( Devel::PixelBuffer& pixelBuffer, TextureInfo& textureInfo ); /** + * Creates tiled geometry of for the texture which separates fully-opaque + * tiles from ones which use transparency. + * @param pixelBuffer + * @param textureInfo + */ + bool CreateTiledGeometry( const Devel::PixelBuffer& pixelBuffer, TextureInfo& textureInfo ); + + /** * Mark the texture as complete, and inform observers * @param[in] textureInfo The struct associated with this Texture */ @@ -654,30 +746,35 @@ private: * Only applies size, fitting mode andsampling mode if the size is specified. * Only applies maskTextureId if it isn't INVALID_TEXTURE_ID * Always applies useAtlas. - * @param[in] url The URL of the image to load - * @param[in] size The image size - * @param[in] fittingMode The FittingMode to use - * @param[in] samplingMode The SamplingMode to use - * @param[in] useAtlas True if atlased - * @param[in] maskTextureId The masking texture id (or INVALID_TEXTURE_ID) - * @return A hash of the provided data for caching. + * @param[in] url The URL of the image to load + * @param[in] size The image size + * @param[in] fittingMode The FittingMode to use + * @param[in] samplingMode The SamplingMode to use + * @param[in] useAtlas True if atlased + * @param[in] maskTextureId The masking texture id (or INVALID_TEXTURE_ID) + * @param[in] isAnimatedImage The boolean value to know whether the request is for animated image or not + * @param[in] frameIndex The frame index of a frame to be loaded frame + * @return A hash of the provided data for caching. */ TextureHash GenerateHash( const std::string& url, const ImageDimensions size, const FittingMode::Type fittingMode, const Dali::SamplingMode::Type samplingMode, const UseAtlas useAtlas, - TextureId maskTextureId ); + TextureId maskTextureId, bool isAnimatedImage, uint32_t frameIndex ); /** * @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] hash The hash to look up - * @param[in] url The URL of the image to load - * @param[in] size The image size - * @param[in] fittingMode The FittingMode to use - * @param[in] samplingMode The SamplingMode to use - * @param[in] useAtlas True if atlased - * @param[in] maskTextureId Optional texture ID to use to mask this image - * @return A TextureId of a cached Texture if found. Or INVALID_TEXTURE_ID if not found. + * @param[in] hash The hash to look up + * @param[in] url The URL of the image to load + * @param[in] size The image size + * @param[in] fittingMode The FittingMode to use + * @param[in] samplingMode The SamplingMode to use + * @param[in] useAtlas True if atlased + * @param[in] maskTextureId Optional texture ID to use to mask this image + * @param[in] preMultiplyOnLoad if the image's color should be multiplied by it's alpha. Set to OFF if there is no alpha. + * @param[in] isAnimatedImage The boolean value to know whether the request is for animated image or not + * @param[in] frameIndex The frame index of a frame to be loaded frame + * @return A TextureId of a cached Texture if found. Or INVALID_TEXTURE_ID if not found. */ TextureManager::TextureId FindCachedTexture( const TextureManager::TextureHash hash, @@ -687,7 +784,9 @@ private: const Dali::SamplingMode::Type samplingMode, const bool useAtlas, TextureId maskTextureId, - MultiplyOnLoad preMultiplyOnLoad); + MultiplyOnLoad preMultiplyOnLoad, + bool isAnimatedImage, + uint32_t frameIndex ); private: @@ -704,6 +803,16 @@ private: AsyncLoadingHelper(TextureManager& textureManager); /** + * @brief Load a new frame of animated image + * @param[in] textureId TextureId to reference the texture that will be loaded + * @param[in] animatedImageLoading The AnimatedImageLoading to load animated image + * @param[in] frameIndex The frame index of a frame to be loaded frame + */ + void LoadAnimatedImage( TextureId textureId, + Dali::AnimatedImageLoading animatedImageLoading, + uint32_t frameIndex); + + /** * @brief Load a new texture. * @param[in] textureId TextureId to reference the texture that will be loaded * @param[in] url The URL of the image to load @@ -713,7 +822,7 @@ private: * @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. + * @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, @@ -730,12 +839,14 @@ private: * @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 ); + bool cropToMask, + DevelAsyncImageLoader::PreMultiplyOnLoad preMultiplyOnLoad ); public: AsyncLoadingHelper(const AsyncLoadingHelper&) = delete; @@ -748,17 +859,16 @@ private: /** * @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 - * @param[in] isMaskTask whether this task is for mask or not */ - void AsyncLoadComplete(uint32_t id, Devel::PixelBuffer pixelBuffer, bool isMaskTask); + void AsyncLoadComplete( uint32_t id, Devel::PixelBuffer pixelBuffer ); private: Toolkit::AsyncImageLoader mLoader;