mImpl->IgnoreSourceImage();
}
+bool NativeImageSourceQueue::CanDequeueBuffer()
+{
+ return mImpl->CanDequeueBuffer();
+}
+
+uint8_t* NativeImageSourceQueue::DequeueBuffer(uint32_t& width, uint32_t& height, uint32_t& stride)
+{
+ return mImpl->DequeueBuffer(width, height, stride);
+}
+
+bool NativeImageSourceQueue::EnqueueBuffer(uint8_t* buffer)
+{
+ return mImpl->EnqueueBuffer(buffer);
+}
+
bool NativeImageSourceQueue::CreateResource()
{
return mImpl->CreateResource();
void IgnoreSourceImage();
/**
+ * @brief Checks if the buffer can be got from the queue.
+ *
+ * Check the available buffer using this API before call DequeueBuffer()
+ * @return True if the buffer can be got from the queue.
+ */
+ bool CanDequeueBuffer();
+
+ /**
+ * @brief Dequeue buffer from the queue.
+ *
+ * Acquire buffer and information of the queue.
+ * it returns the information of the buffer.
+ * @param[out] width The width of buffer
+ * @param[out] height The height of buffer
+ * @param[out] stride The stride of buffer
+ * @return A pointer of buffer
+ */
+ uint8_t* DequeueBuffer(uint32_t& width, uint32_t& height, uint32_t& stride);
+
+ /**
+ * @brief Enqueue buffer to the queue.
+ *
+ * Enqueue buffer to the queue
+ * this requests the release of the buffer internally.
+ * @param[in] buffer A pointer of buffer
+ * @return True if success
+ */
+ bool EnqueueBuffer(uint8_t* buffer);
+
+ /**
* @copydoc Dali::NativeImageInterface::GetTextureTarget()
*/
int GetTextureTarget() const override;
{
}
+bool NativeImageSourceQueueAndroid::CanDequeueBuffer()
+{
+ return false;
+}
+
+uint8_t* NativeImageSourceQueueAndroid::DequeueBuffer(uint32_t& width, uint32_t& height, uint32_t& stride)
+{
+ return nullptr;
+}
+
+bool NativeImageSourceQueueAndroid::EnqueueBuffer(uint8_t* buffer)
+{
+ return false;
+}
+
bool NativeImageSourceQueueAndroid::CreateResource()
{
return true;
void IgnoreSourceImage() override;
/**
+ * @copydoc Dali::NativeImageSourceQueue::CanDequeueBuffer
+ */
+ bool CanDequeueBuffer() override;
+
+ /**
+ * @copydoc Dali::NativeImageSourceQueue::DequeueBuffer
+ */
+ uint8_t* DequeueBuffer(uint32_t& width, uint32_t& height, uint32_t& stride) override;
+
+ /**
+ * @copydoc Dali::NativeImageSourceQueue::EnqueueBuffer
+ */
+ bool EnqueueBuffer(uint8_t* buffer) override;
+
+ /**
* destructor
*/
~NativeImageSourceQueueAndroid() override;
virtual void IgnoreSourceImage() = 0;
/**
+ * @copydoc Dali::NativeImageSourceQueue::CanDequeueBuffer
+ */
+ virtual bool CanDequeueBuffer() = 0;
+
+ /**
+ * @copydoc Dali::NativeImageSourceQueue::DequeueBuffer
+ */
+ virtual uint8_t* DequeueBuffer(uint32_t& width, uint32_t& height, uint32_t& stride) = 0;
+
+ /**
+ * @copydoc Dali::NativeImageSourceQueue::EnqueueBuffer
+ */
+ virtual bool EnqueueBuffer(uint8_t* buffer) = 0;
+
+ /**
* destructor
*/
virtual ~NativeImageSourceQueue() = default;
mTbmQueue(NULL),
mConsumeSurface(NULL),
mEglImages(),
+ mBuffers(),
mEglGraphics(NULL),
mEglImageExtensions(NULL),
mOwnTbmQueue(false),
}
}
+bool NativeImageSourceQueueTizen::CanDequeueBuffer()
+{
+ Dali::Mutex::ScopedLock lock(mMutex);
+ if(tbm_surface_queue_can_dequeue(mTbmQueue, 0))
+ {
+ return true;
+ }
+ return false;
+}
+
+uint8_t* NativeImageSourceQueueTizen::DequeueBuffer(uint32_t& width, uint32_t& height, uint32_t& stride)
+{
+ Dali::Mutex::ScopedLock lock(mMutex);
+ if(mTbmQueue == NULL)
+ {
+ DALI_LOG_ERROR("TbmQueue is NULL");
+ return NULL;
+ }
+
+ tbm_surface_h tbmSurface;
+ if(tbm_surface_queue_dequeue(mTbmQueue, &tbmSurface) != TBM_SURFACE_QUEUE_ERROR_NONE)
+ {
+ DALI_LOG_ERROR("Failed to dequeue a tbm_surface [%p]\n", tbmSurface);
+ return NULL;
+ }
+
+ tbm_surface_info_s info;
+ int ret = tbm_surface_map(tbmSurface, TBM_OPTION_WRITE, &info);
+ if(ret != TBM_SURFACE_ERROR_NONE)
+ {
+ DALI_LOG_ERROR("tbm_surface_map is failed! [%d] [%p]\n", ret, tbmSurface);
+ tbm_surface_queue_cancel_dequeue(mTbmQueue, tbmSurface);
+ return NULL;
+ }
+
+ unsigned char* buffer = info.planes[0].ptr;
+ if(!buffer)
+ {
+ DALI_LOG_ERROR("tbm buffer pointer is null! [%p]\n", tbmSurface);
+ tbm_surface_unmap(tbmSurface);
+ tbm_surface_queue_cancel_dequeue(mTbmQueue, tbmSurface);
+ return NULL;
+ }
+
+ tbm_surface_internal_ref(tbmSurface);
+
+ stride = info.planes[0].stride;
+ width = mWidth;
+ height = mHeight;
+
+ // Push the buffer
+ mBuffers.push_back(BufferPair(tbmSurface, buffer));
+ return buffer;
+}
+
+bool NativeImageSourceQueueTizen::EnqueueBuffer(uint8_t* buffer)
+{
+ Dali::Mutex::ScopedLock lock(mMutex);
+ auto bufferInstance = std::find_if(mBuffers.begin(),
+ mBuffers.end(),
+ [buffer](BufferPair pair) { return (pair.second == buffer); });
+ if(bufferInstance != mBuffers.end())
+ {
+ tbm_surface_internal_unref((*bufferInstance).first);
+ tbm_surface_unmap((*bufferInstance).first);
+ tbm_surface_queue_enqueue(mTbmQueue, (*bufferInstance).first);
+ mBuffers.erase(bufferInstance);
+ return true;
+ }
+ return false;
+}
+
bool NativeImageSourceQueueTizen::CreateResource()
{
mEglImageExtensions = mEglGraphics->GetImageExtensions();
void IgnoreSourceImage() override;
/**
+ * @copydoc Dali::NativeImageSourceQueue::CanDequeueBuffer
+ */
+ bool CanDequeueBuffer() override;
+
+ /**
+ * @copydoc Dali::NativeImageSourceQueue::DequeueBuffer
+ */
+ uint8_t* DequeueBuffer(uint32_t& width, uint32_t& height, uint32_t& stride) override;
+
+ /**
+ * @copydoc Dali::NativeImageSourceQueue::EnqueueBuffer
+ */
+ bool EnqueueBuffer(uint8_t* buffer) override;
+
+ /**
* destructor
*/
~NativeImageSourceQueueTizen() override;
private:
typedef std::pair<tbm_surface_h, void*> EglImagePair;
-
- Dali::Mutex mMutex; ///< Mutex
- uint32_t mWidth; ///< image width
- uint32_t mHeight; ///< image height
- tbm_surface_queue_h mTbmQueue; ///< Tbm surface queue handle
- tbm_surface_h mConsumeSurface; ///< The current tbm surface
- std::vector<EglImagePair> mEglImages; ///< EGL Image vector
- EglGraphics* mEglGraphics; ///< EGL Graphics
- EglImageExtensions* mEglImageExtensions; ///< The EGL Image Extensions
- bool mOwnTbmQueue; ///< Whether we created tbm queue
- bool mBlendingRequired; ///< Whether blending is required
+ typedef std::pair<tbm_surface_h, void*> BufferPair;
+
+ Dali::Mutex mMutex; ///< Mutex
+ uint32_t mWidth; ///< image width
+ uint32_t mHeight; ///< image height
+ tbm_surface_queue_h mTbmQueue; ///< Tbm surface queue handle
+ tbm_surface_h mConsumeSurface; ///< The current tbm surface
+ std::vector<EglImagePair> mEglImages; ///< EGL Image vector
+ std::vector<BufferPair> mBuffers; ///< Buffer vector
+ EglGraphics* mEglGraphics; ///< EGL Graphics
+ EglImageExtensions* mEglImageExtensions; ///< The EGL Image Extensions
+ bool mOwnTbmQueue; ///< Whether we created tbm queue
+ bool mBlendingRequired; ///< Whether blending is required
};
} // namespace Adaptor
{
}
+bool NativeImageSourceQueueX::CanDequeueBuffer()
+{
+ return false;
+}
+
+uint8_t* NativeImageSourceQueueX::DequeueBuffer(uint32_t& width, uint32_t& height, uint32_t& stride)
+{
+ return nullptr;
+}
+
+bool NativeImageSourceQueueX::EnqueueBuffer(uint8_t* buffer)
+{
+ return false;
+}
+
bool NativeImageSourceQueueX::CreateResource()
{
return true;
void IgnoreSourceImage() override;
/**
+ * @copydoc Dali::NativeImageSourceQueue::CanDequeueBuffer
+ */
+ bool CanDequeueBuffer() override;
+
+ /**
+ * @copydoc Dali::NativeImageSourceQueue::DequeueBuffer
+ */
+ uint8_t* DequeueBuffer(uint32_t& width, uint32_t& height, uint32_t& stride) override;
+
+ /**
+ * @copydoc Dali::NativeImageSourceQueue::EnqueueBuffer
+ */
+ bool EnqueueBuffer(uint8_t* buffer) override;
+
+ /**
* destructor
*/
~NativeImageSourceQueueX() override;