return graphicsProgram->GetParameter(parameterId, outData);
}
+Graphics::Texture* TestGraphicsController::CreateTextureByResourceId(uint32_t resourceId, const Graphics::TextureCreateInfo& createInfo)
+{
+ Graphics::Texture* ret = nullptr;
+ Graphics::UniquePtr<Graphics::Texture> texture;
+ TraceCallStack::NamedParams namedParams;
+ namedParams["resourceId"] << resourceId;
+
+ auto iter = mTextureUploadBindMapper.find(resourceId);
+ DALI_ASSERT_ALWAYS(iter == mTextureUploadBindMapper.end());
+
+ // Create new graphics texture.
+ texture = CreateTexture(createInfo, std::move(texture));
+ ret = texture.get();
+
+ mTextureUploadBindMapper.insert(std::make_pair(resourceId, std::move(texture)));
+
+ mCallStack.PushCall("CreateTextureByResourceId", "", namedParams);
+ return ret;
+}
+
+void TestGraphicsController::DiscardTextureFromResourceId(uint32_t resourceId)
+{
+ TraceCallStack::NamedParams namedParams;
+ namedParams["resourceId"] << resourceId;
+
+ mTextureUploadBindMapper.erase(resourceId);
+
+ mCallStack.PushCall("DiscardTextureFromResourceId", "", namedParams);
+}
+
+Graphics::Texture* TestGraphicsController::GetTextureFromResourceId(uint32_t resourceId)
+{
+ TraceCallStack::NamedParams namedParams;
+ namedParams["resourceId"] << resourceId;
+
+ Graphics::Texture* ret = nullptr;
+
+ auto iter = mTextureUploadBindMapper.find(resourceId);
+ if(iter != mTextureUploadBindMapper.end())
+ {
+ ret = iter->second.get();
+ }
+
+ mCallStack.PushCall("GetTextureFromResourceId", "", namedParams);
+
+ return ret;
+}
+
+Graphics::UniquePtr<Graphics::Texture> TestGraphicsController::ReleaseTextureFromResourceId(uint32_t resourceId)
+{
+ TraceCallStack::NamedParams namedParams;
+ namedParams["resourceId"] << resourceId;
+
+ Graphics::UniquePtr<Graphics::Texture> texture;
+
+ auto iter = mTextureUploadBindMapper.find(resourceId);
+ if(iter != mTextureUploadBindMapper.end())
+ {
+ texture = std::move(iter->second);
+ mTextureUploadBindMapper.erase(iter);
+ }
+
+ mCallStack.PushCall("ReleaseTextureFromResourceId", "", namedParams);
+
+ return texture;
+}
+
} // namespace Dali
*/
#include <dali/graphics-api/graphics-controller.h>
+#include <unordered_map>
#include "test-gl-abstraction.h"
#include "test-gl-context-helper-abstraction.h"
#include "test-graphics-command-buffer.h"
*/
bool PipelineEquals(const Graphics::Pipeline& pipeline0, const Graphics::Pipeline& pipeline1) const override;
+ /**
+ * @brief Retrieves program parameters
+ *
+ * This function can be used to retrieve data from internal implementation
+ *
+ * @param[in] program Valid program object
+ * @param[in] parameterId Integer parameter id
+ * @param[out] outData Pointer to output memory
+ * @return True on success
+ */
+ bool GetProgramParameter(Graphics::Program& program, uint32_t parameterId, void* outData) override;
+
+public: // ResourceId relative API.
+ /**
+ * @brief Create Graphics::Texture as resourceId.
+ * The ownership of Graphics::Texture will be hold on this controller.
+ * @note If some Graphics::Texture already created before, assert.
+ * @post DiscardTextureFromResourceId() or ReleaseTextureFromResourceId() should be called when we don't use resourceId texture anymore.
+ *
+ * @param[in] resourceId The unique id of resouces.
+ * @return Pointer of Graphics::Texture, or nullptr if we fail to create.
+ */
+ Graphics::Texture* CreateTextureByResourceId(uint32_t resourceId, const Graphics::TextureCreateInfo& createInfo) override;
+
+ /**
+ * @brief Discard Graphics::Texture as resourceId.
+ *
+ * @param[in] resourceId The unique id of resouces.
+ */
+ void DiscardTextureFromResourceId(uint32_t resourceId) override;
+
+ /**
+ * @brief Get the Graphics::Texture as resourceId.
+ *
+ * @param[in] resourceId The unique id of resouces.
+ * @return Pointer of Graphics::Texture, or nullptr if there is no valid objects.
+ */
+ Graphics::Texture* GetTextureFromResourceId(uint32_t resourceId) override;
+
+ /**
+ * @brief Get the ownership of Graphics::Texture as resourceId.
+ *
+ * @param[in] resourceId The unique id of resouces.
+ * @return Pointer of Graphics::Texture.
+ */
+ Graphics::UniquePtr<Graphics::Texture> ReleaseTextureFromResourceId(uint32_t resourceId) override;
+
public: // Test Functions
void SetVertexFormats(Property::Array& vfs)
{
mSubmitStack.clear();
}
- /**
- * @brief Retrieves program parameters
- *
- * This function can be used to retrieve data from internal implementation
- *
- * @param[in] program Valid program object
- * @param[in] parameterId Integer parameter id
- * @param[out] outData Pointer to output memory
- * @return True on success
- */
- bool GetProgramParameter(Graphics::Program& program, uint32_t parameterId, void* outData) override;
-
void ProcessCommandBuffer(TestGraphicsCommandBuffer& commandBuffer);
void BindPipeline(TestGraphicsPipeline* pipeline);
std::vector<TestGraphicsBuffer*> mAllocatedBuffers;
+ std::unordered_map<uint32_t, Graphics::UniquePtr<Graphics::Texture>> mTextureUploadBindMapper;
+
struct PipelineCache
{
};
--- /dev/null
+/*
+ * 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// CLASS HEADER
+#include <dali/devel-api/adaptor-framework/texture-upload-manager.h>
+
+// INTERNAL INCLUDES
+#include <dali/internal/system/common/texture-upload-manager-impl.h>
+
+namespace Dali::Devel
+{
+// Called by main thread
+
+TextureUploadManager::TextureUploadManager() = default;
+
+TextureUploadManager::~TextureUploadManager() = default;
+
+TextureUploadManager TextureUploadManager::Get()
+{
+ return Internal::Adaptor::TextureUploadManager::Get();
+}
+
+Dali::Texture TextureUploadManager::GenerateTexture2D()
+{
+ return GetImplementation(*this).GenerateTexture2D();
+}
+
+TextureUploadManager::TextureUploadManager(Internal::Adaptor::TextureUploadManager* impl)
+: BaseHandle(impl)
+{
+}
+
+// Called by update thread
+
+bool TextureUploadManager::ResourceUpload()
+{
+ return GetImplementation(*this).ResourceUpload();
+}
+
+// Called by worker thread
+
+void TextureUploadManager::RequestUpload(ResourceId resourceId, PixelData pixelData)
+{
+ GetImplementation(*this).RequestUpload(resourceId, pixelData);
+}
+
+} // namespace Dali::Devel
--- /dev/null
+#ifndef DALI_DEVEL_TEXTURE_UPLOAD_MANAGER_H
+#define DALI_DEVEL_TEXTURE_UPLOAD_MANAGER_H
+
+/*
+ * 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// EXTERNAL INCLUDES
+#include <dali/public-api/common/intrusive-ptr.h>
+#include <dali/public-api/images/pixel-data.h>
+#include <dali/public-api/object/base-handle.h>
+#include <dali/public-api/rendering/texture.h>
+#include <stdint.h> ///< For uint32_t
+
+// INTERNAL INCLUDES
+#include <dali/public-api/dali-adaptor-common.h>
+
+namespace Dali
+{
+namespace Internal DALI_INTERNAL
+{
+namespace Adaptor DALI_INTERNAL
+{
+class TextureUploadManager;
+} // namespace DALI_INTERNAL
+} // namespace DALI_INTERNAL
+
+namespace Devel
+{
+/**
+ * The manager that make we can upload resource into texture from the worker thread.
+ * @code
+ * (Event Thread)
+ * someAsyncTask.mUploadManager = TextureUploadManager::Get();
+ * someAsyncTask.mTexture = someAsyncTask.mUploadManager.GenerateTexture2D();
+ * someAsyncTask.mResourceId = Integration::GetTextureResourceId(someAsyncTask.mTexture);
+ * AsyncTaskManager::Get().AddTask(someAsyncTask);
+ *
+ * (Worker Thread)
+ * SomeAsyncTask::Process()
+ * {
+ * PixelData pixelData = LoadImage();
+ * ...
+ * mUploadManager.RequestUpload(mResourceId, pixelData); // Upload to Graphics::Texture paired by UploadResourceId.
+ * }
+ * @endcode
+ *
+ * @SINCE_2_2.37
+ */
+class DALI_ADAPTOR_API TextureUploadManager : public BaseHandle
+{
+public:
+ using ResourceId = uint32_t;
+ constexpr static ResourceId INVALID_RESOURCE_ID = 0u;
+
+public: // Callbed by main thread.
+ /**
+ * Constructor.
+ * @SINCE_2_2.37
+ */
+ TextureUploadManager();
+
+ /**
+ * Destructor.
+ * @SINCE_2_2.37
+ */
+ ~TextureUploadManager();
+
+ /**
+ * @brief Gets the singleton of TextureUploadManager object.
+ *
+ * @SINCE_2_2.37
+ * @return A handle to the TextureUploadManager
+ */
+ static TextureUploadManager Get();
+
+ /**
+ * @brief Generate the texture 2d that hold unique id for upload resources, called by main thread.
+ *
+ * @SINCE_2_2.37
+ * @return The texture that hold unique id of upload resource.
+ */
+ Dali::Texture GenerateTexture2D();
+
+public: // Called by update thread.
+ /**
+ * @brief Upload all requested resources by RequestUpload.
+ *
+ * @SINCE_2_2.37
+ * @return True if there was at least 1 resources uploaded.
+ */
+ bool ResourceUpload();
+
+public: // Can be callbed by worker thread.
+ /**
+ * @brief Request upload PixelData to given ResourceId.
+ * @note We should not request invalid resouceId.
+ * @note We should not request mutiple times into same resourceId.
+ *
+ * @SINCE_2_2.37
+ * @param[in] resourceId The id of resource.
+ * @param[in] pixelData The buffer of resource.
+ */
+ void RequestUpload(ResourceId resourceId, PixelData pixelData);
+
+public:
+ /// @cond internal
+ /**
+ * @brief Allows the creation of a TextureUploadManager handle from an internal pointer.
+ *
+ * @note Not intended for application developers
+ * @SINCE_2_2.37
+ * @param[in] impl A pointer to the object
+ */
+ explicit DALI_INTERNAL TextureUploadManager(Internal::Adaptor::TextureUploadManager* impl);
+ /// @endcond
+};
+} // namespace Devel
+
+} // namespace Dali
+
+#endif
${adaptor_devel_api_dir}/adaptor-framework/pixel-buffer.cpp
${adaptor_devel_api_dir}/adaptor-framework/sound-player.cpp
${adaptor_devel_api_dir}/adaptor-framework/style-monitor.cpp
+ ${adaptor_devel_api_dir}/adaptor-framework/texture-upload-manager.cpp
${adaptor_devel_api_dir}/adaptor-framework/tilt-sensor.cpp
${adaptor_devel_api_dir}/adaptor-framework/lifecycle-controller.cpp
${adaptor_devel_api_dir}/adaptor-framework/vector-animation-renderer.cpp
${adaptor_devel_api_dir}/adaptor-framework/proxy-accessible.h
${adaptor_devel_api_dir}/adaptor-framework/sound-player.h
${adaptor_devel_api_dir}/adaptor-framework/style-monitor.h
+ ${adaptor_devel_api_dir}/adaptor-framework/texture-upload-manager.h
${adaptor_devel_api_dir}/adaptor-framework/tilt-sensor.h
${adaptor_devel_api_dir}/adaptor-framework/vector-animation-renderer.h
${adaptor_devel_api_dir}/adaptor-framework/vector-animation-renderer-plugin.h
mGraphics->GetStencilBufferRequired(),
mGraphics->GetPartialUpdateRequired());
+ // Create TextureUploadManager after mCore created
+ mTextureUploadManager = Dali::Devel::TextureUploadManager::Get();
+
defaultWindow->SetAdaptor(Get());
Dali::Integration::SceneHolder defaultSceneHolder(defaultWindow);
windows = mWindows;
}
+Devel::TextureUploadManager& Adaptor::GetTextureUploadManager()
+{
+ return mTextureUploadManager;
+}
+
void Adaptor::DestroyTtsPlayer(Dali::TtsPlayer::Mode mode)
{
if(mTtsPlayers[mode])
mPerformanceInterface(nullptr),
mKernelTracer(),
mSystemTracer(),
+ mTextureUploadManager(),
mObjectProfiler(nullptr),
mMemoryPoolTimerSlotDelegate(this),
mSocketFactory(),
*/
void SceneCreated();
+ /**
+ * Get the application package name
+ */
static std::string GetApplicationPackageName();
public: // AdaptorInternalServices implementation
void GetWindowContainerInterface(WindowContainer& windows) override;
/**
+ * copydoc Dali::Internal::Adaptor::AdaptorInternalServices::GetTextureUploadManager()
+ */
+ Devel::TextureUploadManager& GetTextureUploadManager() override;
+
+ /**
* @brief Get the configuration manager
* @return The configuration manager, or null if it hasn't been created yet
*/
PerformanceInterface* mPerformanceInterface; ///< Performance interface
KernelTrace mKernelTracer; ///< Kernel tracer
SystemTrace mSystemTracer; ///< System tracer
+ Devel::TextureUploadManager mTextureUploadManager; ///< TextureUploadManager
ObjectProfiler* mObjectProfiler; ///< Tracks object lifetime for profiling
Dali::Timer mMemoryPoolTimer; ///< Logs memory pool capacity
SlotDelegate<Adaptor> mMemoryPoolTimerSlotDelegate;
#define DALI_INTERNAL_ADAPTOR_INTERNAL_SERVICES_H
/*
- * Copyright (c) 2021 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/integration-api/gl-abstraction.h>
// INTERNAL INCLUDES
+#include <dali/devel-api/adaptor-framework/texture-upload-manager.h>
#include <dali/integration-api/adaptor-framework/render-surface-interface.h>
#include <dali/integration-api/adaptor-framework/trigger-event-interface.h>
#include <dali/internal/graphics/common/graphics-interface.h>
virtual TraceInterface& GetSystemTraceInterface() = 0;
/**
+ * @return texture upload manager
+ */
+ virtual Devel::TextureUploadManager& GetTextureUploadManager() = 0;
+
+ /**
* Used to access the list of windows from the Render thread
* @param[out] windows The list of created windows
*/
#include <dali/internal/graphics/common/graphics-interface.h>
#include <dali/internal/graphics/gles/egl-graphics.h>
#include <dali/internal/system/common/environment-options.h>
+#include <dali/internal/system/common/texture-upload-manager-impl.h>
#include <dali/internal/system/common/time-service.h>
#include <dali/internal/thread/common/thread-settings-impl.h>
#include <dali/internal/window-system/common/window-impl.h>
mNotificationTrigger(adaptorInterfaces.GetProcessCoreEventsTrigger()),
mSleepTrigger(NULL),
mPreRenderCallback(NULL),
+ mTextureUploadManager(adaptorInterfaces.GetTextureUploadManager()),
mUpdateRenderThread(NULL),
mDefaultFrameDelta(0.0f),
mDefaultFrameDurationMilliseconds(0u),
Dali::DisplayConnection& displayConnection = mAdaptorInterfaces.GetDisplayConnectionInterface();
displayConnection.Initialize(); //@todo Move InitializeGraphics code into graphics implementation
+ // Setup graphics controller into upload manager.
+ GetImplementation(mTextureUploadManager).InitalizeGraphicsController(graphics.GetController());
+
NotifyGraphicsInitialised();
//@todo Vk swaps this around, but we need to support surfaceless context for multi-window
SurfaceReplaced();
}
+ //////////////////////////////
+ // TextureUploadRequest
+ //////////////////////////////
+
+ // Upload requested resources after resource context activated.
+ graphics.ActivateResourceContext();
+
+ const bool textureUploaded = mTextureUploadManager.ResourceUpload();
+
+ // Update & Render forcely if there exist some uploaded texture.
+ uploadOnly = textureUploaded ? false : uploadOnly;
+
const bool isRenderingToFbo = renderToFboEnabled && ((0u == frameCount) || (0u != frameCount % renderToFboInterval));
++frameCount;
#define DALI_INTERNAL_COMBINED_UPDATE_RENDER_CONTROLLER_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 <atomic>
// INTERNAL INCLUDES
+#include <dali/devel-api/adaptor-framework/texture-upload-manager.h>
#include <dali/integration-api/adaptor-framework/thread-synchronization-interface.h>
#include <dali/internal/adaptor/common/thread-controller-interface.h>
#include <dali/internal/system/common/fps-tracker.h>
TriggerEventInterface* mSleepTrigger; ///< Used by the update-render thread to trigger the event thread when it no longer needs to do any updates
CallbackBase* mPreRenderCallback; ///< Used by Update/Render thread when PreRender is about to be called on graphics.
+ Dali::Devel::TextureUploadManager& mTextureUploadManager; ///< TextureUploadManager
+
pthread_t* mUpdateRenderThread; ///< The Update/Render thread.
float mDefaultFrameDelta; ///< Default time delta between each frame (used for animations). Not protected by lock, but written to rarely so not worth adding a lock when reading.
return *mPipelineCache;
}
+Graphics::Texture* EglGraphicsController::CreateTextureByResourceId(uint32_t resourceId, const Graphics::TextureCreateInfo& createInfo)
+{
+ Graphics::Texture* ret = nullptr;
+ Graphics::UniquePtr<Graphics::Texture> texture;
+
+ auto iter = mExternalTextureResources.find(resourceId);
+ DALI_ASSERT_ALWAYS(iter == mExternalTextureResources.end());
+
+ texture = CreateTexture(createInfo, std::move(texture));
+
+ ret = texture.get();
+
+ mExternalTextureResources.insert(std::make_pair(resourceId, std::move(texture)));
+
+ return ret;
+}
+
+void EglGraphicsController::DiscardTextureFromResourceId(uint32_t resourceId)
+{
+ auto iter = mExternalTextureResources.find(resourceId);
+ if(iter != mExternalTextureResources.end())
+ {
+ mExternalTextureResources.erase(iter);
+ }
+}
+
+Graphics::Texture* EglGraphicsController::GetTextureFromResourceId(uint32_t resourceId)
+{
+ Graphics::Texture* ret = nullptr;
+
+ auto iter = mExternalTextureResources.find(resourceId);
+ if(iter != mExternalTextureResources.end())
+ {
+ ret = iter->second.get();
+ }
+
+ return ret;
+}
+
+Graphics::UniquePtr<Graphics::Texture> EglGraphicsController::ReleaseTextureFromResourceId(uint32_t resourceId)
+{
+ Graphics::UniquePtr<Graphics::Texture> texture;
+
+ auto iter = mExternalTextureResources.find(resourceId);
+ if(iter != mExternalTextureResources.end())
+ {
+ texture = std::move(iter->second);
+ mExternalTextureResources.erase(iter);
+ }
+
+ return texture;
+}
+
} // namespace Dali::Graphics
*/
// EXTERNAL INCLUDES
+#include <dali/devel-api/common/map-wrapper.h>
#include <dali/graphics-api/graphics-controller.h>
#include <queue>
+#include <unordered_map>
// INTERNAL INCLUDES
#include <dali/integration-api/graphics-sync-abstraction.h>
return {};
}
+public: // ResourceId relative API.
+ /**
+ * @copydoc Dali::Graphics::CreateTextureByResourceId()
+ */
+ Graphics::Texture* CreateTextureByResourceId(uint32_t resourceId, const Graphics::TextureCreateInfo& createInfo) override;
+
+ /**
+ * @copydoc Dali::Graphics::DiscardTextureFromResourceId()
+ */
+ void DiscardTextureFromResourceId(uint32_t resourceId) override;
+
+ /**
+ * @copydoc Dali::Graphics::GetTextureFromResourceId()
+ */
+ Graphics::Texture* GetTextureFromResourceId(uint32_t resourceId) override;
+
+ /**
+ * @copydoc Dali::Graphics::ReleaseTextureFromResourceId()
+ */
+ Graphics::UniquePtr<Graphics::Texture> ReleaseTextureFromResourceId(uint32_t resourceId) override;
+
+public:
[[nodiscard]] Integration::GlAbstraction* GetGL() const
{
if(mIsShuttingDown)
using TextureUpdateRequest = std::pair<TextureUpdateInfo, TextureUpdateSourceInfo>;
std::queue<TextureUpdateRequest> mTextureUpdateRequests;
+ std::unordered_map<uint32_t, Graphics::UniquePtr<Graphics::Texture>> mExternalTextureResources; ///< Used for ResourceId.
+
std::queue<const GLES::Texture*> mTextureMipmapGenerationRequests; ///< Queue for texture mipmap generation requests
GLES::Context* mCurrentContext{nullptr}; ///< The current context
--- /dev/null
+/*
+ * 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include <dali/internal/system/common/texture-upload-manager-impl.h>
+
+// EXTERNAL INCLUDES
+#include <dali/devel-api/common/singleton-service.h>
+#include <dali/graphics-api/graphics-texture-upload-helper.h> ///< for Dali::Graphics::ConvertPixelFormat
+#include <dali/integration-api/adaptor-framework/adaptor.h>
+#include <dali/integration-api/debug.h>
+#include <dali/integration-api/pixel-data-integ.h>
+#include <dali/integration-api/texture-integ.h>
+#include <dali/integration-api/trace.h>
+
+// INTERNAL INCLUDES
+#include <dali/internal/adaptor/common/adaptor-impl.h>
+
+namespace Dali
+{
+namespace Internal
+{
+namespace Adaptor
+{
+namespace
+{
+Dali::Devel::TextureUploadManager::ResourceId gUniqueResourceId = 0;
+
+DALI_INIT_TRACE_FILTER(gTraceFilter, DALI_TRACE_PERFORMANCE_MARKER, false);
+
+#if defined(DEBUG_ENABLED)
+Debug::Filter* gTextureUploadManagerLogFilter = Debug::Filter::New(Debug::NoLogging, false, "LOG_TEXTURE_UPLOAD_MANAGER");
+#endif
+
+} // unnamed namespace
+
+// Called by main thread
+
+Dali::Devel::TextureUploadManager TextureUploadManager::Get()
+{
+ Dali::Devel::TextureUploadManager manager;
+ SingletonService singletonService(SingletonService::Get());
+ if(singletonService)
+ {
+ // Check whether the texture upload manager is already created
+ Dali::BaseHandle handle = singletonService.GetSingleton(typeid(Dali::Devel::TextureUploadManager));
+ if(handle)
+ {
+ // If so, downcast the handle of singleton
+ manager = Dali::Devel::TextureUploadManager(dynamic_cast<Internal::Adaptor::TextureUploadManager*>(handle.GetObjectPtr()));
+ }
+
+ if(!manager)
+ {
+ // If not, create the texture upload manager and register it as a singleton
+ Internal::Adaptor::TextureUploadManager* internalTextureUploadManager = new Internal::Adaptor::TextureUploadManager();
+ manager = Dali::Devel::TextureUploadManager(internalTextureUploadManager);
+ singletonService.Register(typeid(manager), manager);
+ }
+ }
+ return manager;
+}
+
+TextureUploadManager::TextureUploadManager()
+: mGraphicsController{nullptr},
+ mRenderTrigger(new EventThreadCallback(MakeCallback(this, &TextureUploadManager::RequestUpdateOnce)))
+{
+}
+
+TextureUploadManager::~TextureUploadManager()
+{
+}
+
+Dali::Texture TextureUploadManager::GenerateTexture2D()
+{
+ ResourceId resourceId = GenerateUploadResourceId();
+
+ Dali::Texture ret = Dali::Integration::NewTextureWithResourceId(Dali::TextureType::TEXTURE_2D, resourceId);
+
+ return ret;
+}
+
+Dali::Devel::TextureUploadManager::ResourceId TextureUploadManager::GenerateUploadResourceId()
+{
+ auto id = ++gUniqueResourceId;
+
+ // Jump overflow case so we can assume that resource id always valid.
+ if(DALI_UNLIKELY(gUniqueResourceId == Dali::Devel::TextureUploadManager::INVALID_RESOURCE_ID))
+ {
+ ++gUniqueResourceId;
+ }
+
+ return id;
+}
+
+void TextureUploadManager::RequestUpdateOnce()
+{
+ if(Dali::Adaptor::IsAvailable())
+ {
+ DALI_LOG_INFO(gTextureUploadManagerLogFilter, Debug::Concise, "RenderOnce requested\n");
+ Dali::Adaptor::Get().RenderOnce();
+ }
+}
+
+// Called by update thread
+
+bool TextureUploadManager::ResourceUpload()
+{
+ DALI_ASSERT_DEBUG(mGraphicsController && "GraphicsController is not prepared!");
+
+ // Copy queue first.
+ RequestUploadQueue copiedRequestUploadQueue;
+
+ {
+ Dali::Mutex::ScopedLock lock(mRequestMutex);
+ copiedRequestUploadQueue = std::move(mRequestUploadQueue);
+ }
+
+ // Upload.
+ bool uploaded = ProcessUploadQueue(std::move(copiedRequestUploadQueue));
+
+ return uploaded;
+}
+
+void TextureUploadManager::InitalizeGraphicsController(Dali::Graphics::Controller& graphicsController)
+{
+ mGraphicsController = &graphicsController;
+}
+
+bool TextureUploadManager::ProcessUploadQueue(RequestUploadQueue&& queue)
+{
+ bool uploaded = false;
+
+ if(!queue.empty())
+ {
+#ifdef TRACE_ENABLED
+ if(gTraceFilter && gTraceFilter->IsTraceEnabled())
+ {
+ std::ostringstream stream;
+ stream << "[upload request \'" << queue.size() << "\' images]";
+ DALI_TRACE_BEGIN_WITH_MESSAGE(gTraceFilter, "DALI_WORKER_THREAD_RESOURCE_UPLOAD", stream.str().c_str());
+ }
+ uint32_t uploadedCount = 0u;
+ uint32_t canceledCount = 0u;
+#endif
+
+ DALI_LOG_INFO(gTextureUploadManagerLogFilter, Debug::Concise, "Upload request %zu images\n", queue.size());
+ for(auto& requests : queue)
+ {
+ auto& resourceId = requests.first;
+ auto& pixelData = requests.second;
+
+ Graphics::Texture* graphicsTexture = nullptr;
+
+ // TODO : Could we detect TEXTURE_2D or TEXTURE_CUBE case in future?
+ {
+ // We always need to create new one
+ auto createInfo = Graphics::TextureCreateInfo();
+ createInfo
+ .SetTextureType(Dali::Graphics::ConvertTextureType(Dali::TextureType::TEXTURE_2D))
+ .SetUsageFlags(static_cast<Graphics::TextureUsageFlags>(Graphics::TextureUsageFlagBits::SAMPLE))
+ .SetFormat(Dali::Graphics::ConvertPixelFormat(pixelData.GetPixelFormat()))
+ .SetSize({pixelData.GetWidth(), pixelData.GetHeight()})
+ .SetLayout(Graphics::TextureLayout::LINEAR)
+ .SetData(nullptr)
+ .SetDataSize(0u)
+ .SetNativeImage(nullptr)
+ .SetMipMapFlag(Graphics::TextureMipMapFlag::DISABLED);
+
+ graphicsTexture = mGraphicsController->CreateTextureByResourceId(resourceId, createInfo);
+ }
+
+ if(graphicsTexture)
+ {
+ Graphics::TextureUpdateInfo info{};
+
+ info.dstTexture = graphicsTexture;
+ info.dstOffset2D = {0u, 0u};
+ info.layer = 0u;
+ info.level = 0u;
+ info.srcReference = 0;
+ info.srcExtent2D = {pixelData.GetWidth(), pixelData.GetHeight()};
+ info.srcOffset = 0;
+ info.srcSize = Dali::Integration::GetPixelDataBuffer(pixelData).bufferSize;
+ info.srcStride = pixelData.GetStride();
+ info.srcFormat = Dali::Graphics::ConvertPixelFormat(pixelData.GetPixelFormat());
+
+ Graphics::TextureUpdateSourceInfo updateSourceInfo{};
+ updateSourceInfo.sourceType = Graphics::TextureUpdateSourceInfo::Type::PIXEL_DATA;
+ updateSourceInfo.pixelDataSource.pixelData = pixelData;
+
+ mGraphicsController->UpdateTextures({info}, {updateSourceInfo});
+
+ uploaded = true;
+#ifdef TRACE_ENABLED
+ ++uploadedCount;
+#endif
+ }
+ else
+ {
+ // Invalidate resouce id! ignore.
+#ifdef TRACE_ENABLED
+ ++canceledCount;
+#endif
+ }
+ }
+
+ if(uploaded)
+ {
+ // Flush here
+ Graphics::SubmitInfo submitInfo;
+ submitInfo.cmdBuffer.clear(); // Only flush
+ submitInfo.flags = 0 | Graphics::SubmitFlagBits::FLUSH;
+ mGraphicsController->SubmitCommandBuffers(submitInfo);
+ }
+#ifdef TRACE_ENABLED
+ if(gTraceFilter && gTraceFilter->IsTraceEnabled())
+ {
+ std::ostringstream stream;
+ stream << "[upload : \'" << uploadedCount << "\', cancel : \'" << canceledCount << "\']";
+ DALI_TRACE_END_WITH_MESSAGE(gTraceFilter, "DALI_WORKER_THREAD_RESOURCE_UPLOAD", stream.str().c_str());
+ }
+#endif
+ }
+
+ return uploaded;
+}
+
+// Called by worker thread
+
+void TextureUploadManager::RequestUpload(Dali::Devel::TextureUploadManager::ResourceId resourceId, Dali::PixelData pixelData)
+{
+ DALI_ASSERT_ALWAYS(resourceId != Dali::Devel::TextureUploadManager::INVALID_RESOURCE_ID && "Invalid resource id generated!");
+ DALI_ASSERT_ALWAYS(pixelData && "Invalid pixelData!");
+
+ {
+ Dali::Mutex::ScopedLock lock(mRequestMutex); // Worker-Update thread mutex
+
+ mRequestUploadQueue.push_back(std::move(UploadRequestItem(resourceId, pixelData)));
+ }
+
+ // wake up the main thread
+ // TODO : Is there any way to request upload once without main thread dependency?
+ mRenderTrigger->Trigger();
+}
+
+} // namespace Adaptor
+
+} // namespace Internal
+
+} // namespace Dali
--- /dev/null
+#ifndef DALI_INTERNAL_TEXTURE_UPLOAD_MANAGER_IMPL_H
+#define DALI_INTERNAL_TEXTURE_UPLOAD_MANAGER_IMPL_H
+
+/*
+ * 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// EXTERNAL INCLUDES
+#include <dali/devel-api/adaptor-framework/event-thread-callback.h>
+#include <dali/devel-api/threading/mutex.h>
+#include <dali/graphics-api/graphics-controller.h>
+#include <dali/graphics-api/graphics-texture.h>
+#include <dali/public-api/common/vector-wrapper.h>
+#include <dali/public-api/object/base-object.h>
+#include <utility> ///< for std::pair
+
+// INTERNAL INCLUDES
+#include <dali/devel-api/adaptor-framework/texture-upload-manager.h>
+
+namespace Dali
+{
+namespace Internal
+{
+namespace Adaptor
+{
+/**
+ * The manager for texture upload
+ */
+class TextureUploadManager : public Dali::BaseObject
+{
+public:
+ using ResourceId = Dali::Devel::TextureUploadManager::ResourceId;
+
+public: // Main thread called method
+ /**
+ * Singleton access
+ *
+ * @return The TextureUploadManager object
+ */
+ static Dali::Devel::TextureUploadManager Get();
+
+ /**
+ * Constructor.
+ */
+ TextureUploadManager();
+
+ /**
+ * Destructor.
+ */
+ ~TextureUploadManager() override;
+
+ /**
+ * @copydoc Dali::Devel::TextureUploadManager::GenerateTexture2D()
+ */
+ Dali::Texture GenerateTexture2D();
+
+private: // Main thread called method
+ /**
+ * @brief Get the unique id for upload resources, called by main thread.
+ *
+ * @return The unique id of upload resource.
+ */
+ ResourceId GenerateUploadResourceId();
+
+ /**
+ * @brief Reqeust update thread once
+ */
+ void RequestUpdateOnce();
+
+public: // Update thread called method
+ /**
+ * @copydoc Dali::Devel::TextureUploadManager::ResourceUpload()
+ */
+ bool ResourceUpload();
+
+ /**
+ * @brief Install graphics controller to be used when upload.
+ * @note Please use this API internal side only.
+ * @note This API will be removed after toolkit UTC code fixed.
+ *
+ * @param[in] graphicsController The graphics controller.
+ */
+ void InitalizeGraphicsController(Dali::Graphics::Controller& graphicsController);
+
+private: // Update thread called method
+ using UploadRequestItem = std::pair<ResourceId, Dali::PixelData>;
+ using RequestUploadQueue = std::vector<UploadRequestItem>;
+
+ /**
+ * @brief Process queue of upload.
+ *
+ * @param queue The requested upload queue.
+ * @return True if there was at least 1 resources uploaded.
+ */
+ bool ProcessUploadQueue(RequestUploadQueue&& queue);
+
+public: // Worker thread called method
+ /**
+ * @copydoc Dali::Devel::TextureUploadManager::RequestUpload()
+ */
+ void RequestUpload(ResourceId id, Dali::PixelData pixelData);
+
+private:
+ // Undefined
+ TextureUploadManager(const TextureUploadManager& manager);
+
+ // Undefined
+ TextureUploadManager& operator=(const TextureUploadManager& manager);
+
+private:
+ Dali::Graphics::Controller* mGraphicsController;
+
+ std::unique_ptr<EventThreadCallback> mRenderTrigger; ///< Trigger to update/render once for worker thread.
+
+ Dali::Mutex mRequestMutex; ///< For worker thread
+ RequestUploadQueue mRequestUploadQueue{};
+};
+
+} // namespace Adaptor
+
+} // namespace Internal
+
+inline Internal::Adaptor::TextureUploadManager& GetImplementation(Dali::Devel::TextureUploadManager& obj)
+{
+ DALI_ASSERT_ALWAYS(obj && "TextureUploadManager is empty");
+
+ Dali::BaseObject& handle = obj.GetBaseObject();
+
+ return static_cast<Internal::Adaptor::TextureUploadManager&>(handle);
+}
+
+inline const Internal::Adaptor::TextureUploadManager& GetImplementation(const Dali::Devel::TextureUploadManager& obj)
+{
+ DALI_ASSERT_ALWAYS(obj && "TextureUploadManager is empty");
+
+ const Dali::BaseObject& handle = obj.GetBaseObject();
+
+ return static_cast<const Internal::Adaptor::TextureUploadManager&>(handle);
+}
+
+} // namespace Dali
+
+#endif
${adaptor_system_dir}/common/update-status-logger.cpp
${adaptor_system_dir}/common/widget-application-impl.cpp
${adaptor_system_dir}/common/async-task-manager-impl.cpp
+ ${adaptor_system_dir}/common/texture-upload-manager-impl.cpp
)
# module: system, backend: linux
projects / platform / core / uifw / dali-adaptor.git / commitdiff