#include "texture-manager.h"
// EXTERNAL HEADERS
+#include <cstdlib>
+#include <dali/devel-api/adaptor-framework/environment-variable.h>
#include <dali/devel-api/common/hash.h>
#include <dali/devel-api/images/texture-set-image.h>
#include <dali/devel-api/adaptor-framework/pixel-buffer.h>
#include <dali/integration-api/debug.h>
// INTERNAL HEADERS
-#include <dali/integration-api/debug.h>
-#include <dali-toolkit/devel-api/image-loader/async-image-loader-devel.h>
#include <dali-toolkit/internal/image-loader/image-atlas-impl.h>
-#include <dali-toolkit/internal/image-loader/async-image-loader-impl.h>
#include <dali-toolkit/public-api/image-loader/sync-image-loader.h>
+namespace
+{
+
+constexpr auto DEFAULT_NUMBER_OF_LOCAL_LOADER_THREADS = size_t{4u};
+constexpr auto DEFAULT_NUMBER_OF_REMOTE_LOADER_THREADS = size_t{8u};
+
+constexpr auto NUMBER_OF_LOCAL_LOADER_THREADS_ENV = "DALI_TEXTURE_LOCAL_THREADS";
+constexpr auto NUMBER_OF_REMOTE_LOADER_THREADS_ENV = "DALI_TEXTURE_REMOTE_THREADS";
+
+size_t GetNumberOfThreads(const char* environmentVariable, size_t defaultValue)
+{
+ using Dali::EnvironmentVariable::GetEnvironmentVariable;
+ auto numberString = GetEnvironmentVariable(environmentVariable);
+ auto numberOfThreads = numberString ? std::strtol(numberString, nullptr, 10) : 0;
+ return (numberOfThreads > 0) ? numberOfThreads : defaultValue;
+}
+
+size_t GetNumberOfLocalLoaderThreads()
+{
+ return GetNumberOfThreads(NUMBER_OF_LOCAL_LOADER_THREADS_ENV, DEFAULT_NUMBER_OF_LOCAL_LOADER_THREADS);
+}
+
+size_t GetNumberOfRemoteLoaderThreads()
+{
+ return GetNumberOfThreads(NUMBER_OF_REMOTE_LOADER_THREADS_ENV, DEFAULT_NUMBER_OF_REMOTE_LOADER_THREADS);
+}
+
+} // namespace
namespace Dali
{
TextureManager::TextureManager()
-: mAsyncLocalLoader( Toolkit::AsyncImageLoader::New() ),
- mAsyncRemoteLoader( Toolkit::AsyncImageLoader::New() ),
- mCurrentTextureId( 0 )
+: mCurrentTextureId( 0 ),
+ mAsyncLocalLoaders( GetNumberOfLocalLoaderThreads(), [&]() { return AsyncLoadingHelper(*this); } ),
+ mAsyncRemoteLoaders( GetNumberOfRemoteLoaderThreads(), [&]() { return AsyncLoadingHelper(*this); } )
{
- DevelAsyncImageLoader::PixelBufferLoadedSignal(mAsyncLocalLoader).Connect( this, &TextureManager::AsyncLocalLoadComplete );
- DevelAsyncImageLoader::PixelBufferLoadedSignal(mAsyncRemoteLoader).Connect( this, &TextureManager::AsyncRemoteLoadComplete );
}
TextureManager::TextureId TextureManager::RequestLoad(
const UseAtlas useAtlas,
TextureUploadObserver* observer )
{
- return RequestLoadInternal( url, INVALID_TEXTURE_ID, desiredSize, fittingMode, samplingMode, useAtlas, UPLOAD_TO_TEXTURE, observer );
+ return RequestLoadInternal( url, INVALID_TEXTURE_ID, 1.0f, desiredSize, fittingMode, samplingMode, useAtlas, false, UPLOAD_TO_TEXTURE, observer );
}
TextureManager::TextureId TextureManager::RequestLoad(
const VisualUrl& url,
TextureId maskTextureId,
+ float contentScale,
const ImageDimensions desiredSize,
FittingMode::Type fittingMode,
Dali::SamplingMode::Type samplingMode,
const UseAtlas useAtlas,
+ bool cropToMask,
TextureUploadObserver* observer )
{
- return RequestLoadInternal( url, maskTextureId, desiredSize, fittingMode, samplingMode, useAtlas, UPLOAD_TO_TEXTURE, observer );
+ return RequestLoadInternal( url, maskTextureId, contentScale, desiredSize, fittingMode, samplingMode, useAtlas, cropToMask, UPLOAD_TO_TEXTURE, observer );
}
TextureManager::TextureId TextureManager::RequestMaskLoad( const VisualUrl& maskUrl )
{
// Use the normal load procedure to get the alpha mask.
- return RequestLoadInternal( maskUrl, INVALID_TEXTURE_ID, ImageDimensions(), FittingMode::SCALE_TO_FILL, SamplingMode::NO_FILTER, NO_ATLAS, KEEP_PIXEL_BUFFER, NULL );
+ return RequestLoadInternal( maskUrl, INVALID_TEXTURE_ID, 1.0f, ImageDimensions(), FittingMode::SCALE_TO_FILL, SamplingMode::NO_FILTER, NO_ATLAS, false, KEEP_PIXEL_BUFFER, NULL );
}
TextureManager::TextureId TextureManager::RequestLoadInternal(
const VisualUrl& url,
TextureId maskTextureId,
+ float contentScale,
const ImageDimensions desiredSize,
FittingMode::Type fittingMode,
Dali::SamplingMode::Type samplingMode,
UseAtlas useAtlas,
+ bool cropToMask,
StorageType storageType,
TextureUploadObserver* observer )
{
// We need a new Texture.
textureId = GenerateUniqueTextureId();
mTextureInfoContainer.push_back( TextureInfo( textureId, maskTextureId, url.GetUrl(),
- desiredSize, fittingMode, samplingMode,
- false, useAtlas, textureHash ) );
+ desiredSize, contentScale, fittingMode, samplingMode,
+ false, cropToMask, useAtlas, textureHash ) );
cacheIndex = mTextureInfoContainer.size() - 1u;
DALI_LOG_INFO( gTextureManagerLogFilter, Debug::Concise, "TextureManager::RequestLoad( url=%s observer=%p ) New texture, cacheIndex:%d, textureId=%d\n", url.GetUrl().c_str(), observer, cacheIndex, textureId );
{
// The Texture has already loaded. The other observers have already been notified.
// We need to send a "late" loaded notification for this observer.
- observer->UploadComplete( true,
- textureInfo.textureSet, textureInfo.useAtlas,
- textureInfo.atlasRect );
+ observer->UploadComplete( true, textureInfo.textureId, textureInfo.textureSet,
+ textureInfo.useAtlas, textureInfo.atlasRect );
}
break;
}
{
TextureInfo& textureInfo( mTextureInfoContainer[ textureInfoIndex ] );
-
DALI_LOG_INFO( gTextureManagerLogFilter, Debug::Concise, "TextureManager::Remove(%d) cacheIdx:%d loadState:%s\n",
textureId, textureInfoIndex,
textureInfo.loadState == TextureManager::NOT_STARTED ? "NOT_STARTED" :
if( !textureInfo.loadSynchronously )
{
- if( textureInfo.url.IsLocal() )
- {
- mAsyncLocalLoadingInfoContainer.push_back( AsyncLoadingInfo( textureInfo.textureId ) );
- mAsyncLocalLoadingInfoContainer.back().loadId =
- GetImplementation(mAsyncLocalLoader).Load( textureInfo.url, textureInfo.desiredSize,
- textureInfo.fittingMode,
- textureInfo.samplingMode, true );
- }
- else
- {
- mAsyncRemoteLoadingInfoContainer.push_back( AsyncLoadingInfo( textureInfo.textureId ) );
- mAsyncRemoteLoadingInfoContainer.back().loadId =
- GetImplementation(mAsyncRemoteLoader).Load( textureInfo.url, textureInfo.desiredSize,
- textureInfo.fittingMode,
- textureInfo.samplingMode, true );
- }
+ auto& loadersContainer = textureInfo.url.IsLocal() ? mAsyncLocalLoaders : mAsyncRemoteLoaders;
+ auto loadingHelperIt = loadersContainer.GetNext();
+ DALI_ASSERT_ALWAYS(loadingHelperIt != loadersContainer.End());
+ loadingHelperIt->Load(textureInfo.textureId, textureInfo.url,
+ textureInfo.desiredSize, textureInfo.fittingMode,
+ textureInfo.samplingMode, true);
}
}
}
}
-void TextureManager::AsyncLocalLoadComplete( uint32_t id, Devel::PixelBuffer pixelBuffer )
-{
- AsyncLoadComplete( mAsyncLocalLoadingInfoContainer, id, pixelBuffer );
-}
-
-void TextureManager::AsyncRemoteLoadComplete( uint32_t id, Devel::PixelBuffer pixelBuffer )
-{
- AsyncLoadComplete( mAsyncRemoteLoadingInfoContainer, id, pixelBuffer );
-}
-
void TextureManager::AsyncLoadComplete( AsyncLoadingInfoContainerType& loadingContainer, uint32_t id, Devel::PixelBuffer pixelBuffer )
{
DALI_LOG_INFO( gTextureManagerLogFilter, Debug::Concise, "TextureManager::AsyncLoadComplete( id:%d )\n", id );
}
else if( maskLoadState == LOAD_FINISHED )
{
- ApplyMask( pixelBuffer, textureInfo.maskTextureId );
+ ApplyMask( pixelBuffer, textureInfo.maskTextureId, textureInfo.scaleFactor, textureInfo.cropToMask );
UploadTexture( pixelBuffer, textureInfo );
NotifyObservers( textureInfo, true );
}
if( maskTextureInfo.loadState == LOAD_FINISHED )
{
- ApplyMask( pixelBuffer, maskTextureInfo.textureId );
+ ApplyMask( pixelBuffer, maskTextureInfo.textureId, textureInfo.scaleFactor, textureInfo.cropToMask );
UploadTexture( pixelBuffer, textureInfo );
NotifyObservers( textureInfo, true );
}
}
}
-void TextureManager::ApplyMask( Devel::PixelBuffer& pixelBuffer, TextureId maskTextureId )
+void TextureManager::ApplyMask(
+ Devel::PixelBuffer& pixelBuffer, TextureId maskTextureId,
+ float contentScale, bool cropToMask )
{
int maskCacheIndex = GetCacheIndexFromId( maskTextureId );
Devel::PixelBuffer maskPixelBuffer = mTextureInfoContainer[maskCacheIndex].pixelBuffer;
- pixelBuffer.ApplyMask( maskPixelBuffer );
+ pixelBuffer.ApplyMask( maskPixelBuffer, contentScale, cropToMask );
}
void TextureManager::UploadTexture( Devel::PixelBuffer& pixelBuffer, TextureInfo& textureInfo )
{
TextureId textureId = textureInfo.textureId;
- // If there is an observer: Notify the load is complete, whether successful or not:
- // And erase it from the list
+ // If there is an observer: Notify the load is complete, whether successful or not,
+ // and erase it from the list
unsigned int observerCount = textureInfo.observerList.Count();
TextureInfo* info = &textureInfo;
{
TextureUploadObserver* observer = info->observerList[0];
- // During UploadComplete() a Control ResourceReady() signal is emitted
- // During that signal the app may add remove /add Textures (e.g. via ImageViews).
- // At this point no more observers can be added to the observerList, because textureInfo.loadState = UPLOADED
- // However it is possible for observers to be removed, hence we check the observer list count every iteration
-
- // Also the reference to the textureInfo struct can become invalidated, because new load requests can modify
- // the mTextureInfoContainer list (e.g. if more requests are pushed_back it can cause the list to be resized
- // invalidating the reference to the TextureInfo ).
- observer->UploadComplete( success, info->textureSet, info->useAtlas, info->atlasRect );
+ // During UploadComplete() a Control ResourceReady() signal is emitted.
+ // During that signal the app may add remove /add Textures (e.g. via
+ // ImageViews). At this point no more observers can be added to the
+ // observerList, because textureInfo.loadState = UPLOADED. However it is
+ // possible for observers to be removed, hence we check the observer list
+ // count every iteration.
+
+ // The reference to the textureInfo struct can also become invalidated,
+ // because new load requests can modify the mTextureInfoContainer list
+ // (e.g. if more requests are pushed back it can cause the list to be
+ // resized invalidating the reference to the TextureInfo ).
+ observer->UploadComplete( success, info->textureId, info->textureSet, info->useAtlas, info->atlasRect );
observer->DestructionSignal().Disconnect( this, &TextureManager::ObserverDestroyed );
- // regrab the textureInfo from the container as it may have been invalidated, if textures have been removed
- // or added during the ResourceReady() signal emission (from UploadComplete() )
- int textureInfoIndex = GetCacheIndexFromId( textureId );
+ // Get the textureInfo from the container again as it may have been
+ // invalidated,
+ int textureInfoIndex = GetCacheIndexFromId( textureId );
if( textureInfoIndex == INVALID_CACHE_INDEX)
{
- // texture has been removed
- return;
+ return; // texture has been removed - can stop.
}
+
info = &mTextureInfoContainer[ textureInfoIndex ];
observerCount = info->observerList.Count();
if ( observerCount > 0 )
info->observerList.Erase( j );
observerCount--;
break;
- }
+ }
}
}
-
}
-
}
-
TextureManager::TextureId TextureManager::GenerateUniqueTextureId()
{
return mCurrentTextureId++;
for( unsigned int i = 0; i < count; ++i )
{
TextureInfo& textureInfo( mTextureInfoContainer[i] );
- for( TextureInfo::ObserverListType::Iterator j = textureInfo.observerList.Begin(); j != textureInfo.observerList.End(); ++j )
+ for( TextureInfo::ObserverListType::Iterator j = textureInfo.observerList.Begin(); j != textureInfo.observerList.End(); )
{
if( *j == observer )
{
- textureInfo.observerList.Erase( j );
- break;
+ j = textureInfo.observerList.Erase( j );
+ }
+ else
+ {
+ ++j;
}
}
}
TextureManager::~TextureManager()
{
- mTextureInfoContainer.clear();
- mAsyncLocalLoadingInfoContainer.clear();
- mAsyncRemoteLoadingInfoContainer.clear();
}
+TextureManager::AsyncLoadingHelper::AsyncLoadingHelper(TextureManager& textureManager)
+: AsyncLoadingHelper(Toolkit::AsyncImageLoader::New(), textureManager,
+ AsyncLoadingInfoContainerType())
+{
+}
+
+void TextureManager::AsyncLoadingHelper::Load(TextureId textureId,
+ const VisualUrl& url,
+ ImageDimensions desiredSize,
+ FittingMode::Type fittingMode,
+ SamplingMode::Type samplingMode,
+ bool orientationCorrection)
+{
+ mLoadingInfoContainer.push_back(AsyncLoadingInfo(textureId));
+ auto id = mLoader.Load(url.GetUrl(), desiredSize, fittingMode, samplingMode, orientationCorrection);
+ mLoadingInfoContainer.back().loadId = id;
+}
+
+TextureManager::AsyncLoadingHelper::AsyncLoadingHelper(AsyncLoadingHelper&& rhs)
+: AsyncLoadingHelper(rhs.mLoader, rhs.mTextureManager, std::move(rhs.mLoadingInfoContainer))
+{
+}
+TextureManager::AsyncLoadingHelper::AsyncLoadingHelper(
+ Toolkit::AsyncImageLoader loader,
+ TextureManager& textureManager,
+ AsyncLoadingInfoContainerType&& loadingInfoContainer)
+: mLoader(loader),
+ mTextureManager(textureManager),
+ mLoadingInfoContainer(std::move(loadingInfoContainer))
+{
+ DevelAsyncImageLoader::PixelBufferLoadedSignal(mLoader).Connect(
+ this, &AsyncLoadingHelper::AsyncLoadComplete);
+}
+void TextureManager::AsyncLoadingHelper::AsyncLoadComplete(uint32_t id,
+ Devel::PixelBuffer pixelBuffer)
+{
+ mTextureManager.AsyncLoadComplete(mLoadingInfoContainer, id, pixelBuffer);
+}
} // namespace Internal
projects / platform / core / uifw / dali-toolkit.git / blobdiff