Add API for NativeImageQueue

When the application uses several buffers in NativeImageQueue,
the application can get buffer directly using these APIs.

Change-Id: If350caeb80867549d908611c43dfa4b35faff8e0

diff --git a/dali/devel-api/adaptor-framework/native-image-source-queue.cpp b/dali/devel-api/adaptor-framework/native-image-source-queue.cpp
index f7d202e..ca80056 100644 (file)
--- a/dali/devel-api/adaptor-framework/native-image-source-queue.cpp
+++ b/dali/devel-api/adaptor-framework/native-image-source-queue.cpp
@@ -60,6 +60,21 @@ void NativeImageSourceQueue::IgnoreSourceImage()
   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();

diff --git a/dali/devel-api/adaptor-framework/native-image-source-queue.h b/dali/devel-api/adaptor-framework/native-image-source-queue.h
index 1c90b81..45f8a16 100644 (file)
--- a/dali/devel-api/adaptor-framework/native-image-source-queue.h
+++ b/dali/devel-api/adaptor-framework/native-image-source-queue.h
@@ -111,6 +111,36 @@ public:
   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;

diff --git a/dali/internal/imaging/android/native-image-source-queue-impl-android.cpp b/dali/internal/imaging/android/native-image-source-queue-impl-android.cpp
index 436fdd3..15cc9f2 100644 (file)
--- a/dali/internal/imaging/android/native-image-source-queue-impl-android.cpp
+++ b/dali/internal/imaging/android/native-image-source-queue-impl-android.cpp
@@ -66,6 +66,21 @@ void NativeImageSourceQueueAndroid::IgnoreSourceImage()
 {
 }
 
+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;

diff --git a/dali/internal/imaging/android/native-image-source-queue-impl-android.h b/dali/internal/imaging/android/native-image-source-queue-impl-android.h
index 7e96038..aadde09 100644 (file)
--- a/dali/internal/imaging/android/native-image-source-queue-impl-android.h
+++ b/dali/internal/imaging/android/native-image-source-queue-impl-android.h
@@ -65,6 +65,21 @@ public:
   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;

diff --git a/dali/internal/imaging/common/native-image-source-queue-impl.h b/dali/internal/imaging/common/native-image-source-queue-impl.h
index 612d49d..f393b82 100644 (file)
--- a/dali/internal/imaging/common/native-image-source-queue-impl.h
+++ b/dali/internal/imaging/common/native-image-source-queue-impl.h
@@ -54,6 +54,21 @@ public:
   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;

diff --git a/dali/internal/imaging/tizen/native-image-source-queue-impl-tizen.cpp b/dali/internal/imaging/tizen/native-image-source-queue-impl-tizen.cpp
index e16fbc2..35d4458 100644 (file)
--- a/dali/internal/imaging/tizen/native-image-source-queue-impl-tizen.cpp
+++ b/dali/internal/imaging/tizen/native-image-source-queue-impl-tizen.cpp
@@ -79,6 +79,7 @@ NativeImageSourceQueueTizen::NativeImageSourceQueueTizen(uint32_t width, uint32_
   mTbmQueue(NULL),
   mConsumeSurface(NULL),
   mEglImages(),
+  mBuffers(),
   mEglGraphics(NULL),
   mEglImageExtensions(NULL),
   mOwnTbmQueue(false),
@@ -208,6 +209,78 @@ void NativeImageSourceQueueTizen::IgnoreSourceImage()
   }
 }
 
+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();

diff --git a/dali/internal/imaging/tizen/native-image-source-queue-impl-tizen.h b/dali/internal/imaging/tizen/native-image-source-queue-impl-tizen.h
index ae2bf8d..b837d96 100644 (file)
--- a/dali/internal/imaging/tizen/native-image-source-queue-impl-tizen.h
+++ b/dali/internal/imaging/tizen/native-image-source-queue-impl-tizen.h
@@ -69,6 +69,21 @@ public:
   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;
@@ -175,17 +190,19 @@ private:
 
 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

diff --git a/dali/internal/imaging/ubuntu-x11/native-image-source-queue-impl-x.cpp b/dali/internal/imaging/ubuntu-x11/native-image-source-queue-impl-x.cpp
index e7d77fb..25fbea7 100644 (file)
--- a/dali/internal/imaging/ubuntu-x11/native-image-source-queue-impl-x.cpp
+++ b/dali/internal/imaging/ubuntu-x11/native-image-source-queue-impl-x.cpp
@@ -70,6 +70,21 @@ void NativeImageSourceQueueX::IgnoreSourceImage()
 {
 }
 
+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;

diff --git a/dali/internal/imaging/ubuntu-x11/native-image-source-queue-impl-x.h b/dali/internal/imaging/ubuntu-x11/native-image-source-queue-impl-x.h
index b119cb0..db5f8e2 100644 (file)
--- a/dali/internal/imaging/ubuntu-x11/native-image-source-queue-impl-x.h
+++ b/dali/internal/imaging/ubuntu-x11/native-image-source-queue-impl-x.h
@@ -65,6 +65,21 @@ public:
   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;