ecore-buffer: Add ecore_buffer library to EFL.

Summary:
Ecore_Buffer is abstraction of graphic buffer.
it supports backend of shm, x11_dri2 and x11_dri3 for now,
and this library also provides method to share buffers between processes.
Ecore_Buffer_Provider and Ecore_Buffer_Consumer is for this, sharing buffer.
provider draws something in to Ecore_Buffer, and consumer receives and displays it.
the binary, bq_mgr is a connection maker for buffer provider and consumer.
it can be included Enlightenment as a deamon later.

@feature

Test Plan:
1. Configure with --enable-ecore-buffer and --enable-always-build-examples to build examples.
2. Run bq_mgr, it connects consumer and provider.
3. Run ecore_buffer_provider_example and ecore_buffer_consumer_example

Reviewers: lsj119, gwanglim, cedric, zmike, jpeg, raster, devilhorns

Subscribers: cedric

Differential Revision: https://phab.enlightenment.org/D2197

1 files changed, 148 insertions, 0 deletions

diff --git a/src/lib/ecore_buffer/shared_buffer.c b/src/lib/ecore_buffer/shared_buffer.c
new file mode 100644
index 0000000000..82b4836b52
--- /dev/null
+++ b/src/lib/ecore_buffer/shared_buffer.c
@@ -0,0 +1,148 @@
+#include "shared_buffer.h"
+
+struct _Shared_Buffer
+{
+   Ecore_Buffer *buffer;
+   struct bq_buffer *resource;
+   const char *engine;
+   int w, h;
+   int format;
+   unsigned int flags;
+   Shared_Buffer_State state;
+};
+
+Shared_Buffer *
+_shared_buffer_new(const char *engine, struct bq_buffer *resource, int w, int h, int format, unsigned int flags)
+{
+   Shared_Buffer *sb;
+
+   sb = calloc(1, sizeof(Shared_Buffer));
+   if (!sb)
+     return NULL;
+
+   sb->engine = eina_stringshare_add(engine);
+   sb->resource = resource;
+   sb->w = w;
+   sb->h = h;
+   sb->format = format;
+   sb->flags = flags;
+   sb->state = SHARED_BUFFER_STATE_NEW;
+
+   return sb;
+}
+
+void
+_shared_buffer_free(Shared_Buffer *sb)
+{
+   EINA_SAFETY_ON_NULL_RETURN(sb);
+
+   if (sb->engine) eina_stringshare_del(sb->engine);
+   free(sb);
+}
+
+Eina_Bool
+_shared_buffer_info_get(Shared_Buffer *sb, const char **engine, int *w, int *h, int *format, unsigned int *flags)
+{
+   EINA_SAFETY_ON_NULL_RETURN_VAL(sb, EINA_FALSE);
+
+   if (engine) *engine = sb->engine;
+   if (w) *w = sb->w;
+   if (h) *h = sb->h;
+   if (format) *format = sb->format;
+   if (flags) *flags = sb->flags;
+
+   return EINA_TRUE;
+}
+
+Eina_Bool
+_shared_buffer_buffer_set(Shared_Buffer *sb, Ecore_Buffer *buffer)
+{
+   EINA_SAFETY_ON_NULL_RETURN_VAL(sb, EINA_FALSE);
+
+   if (sb->buffer)
+     {
+        ERR("Already exist buffer");
+        return EINA_FALSE;
+     }
+
+   sb->buffer = buffer;
+
+   return EINA_TRUE;
+}
+
+Ecore_Buffer *
+_shared_buffer_buffer_get(Shared_Buffer *sb)
+{
+   EINA_SAFETY_ON_NULL_RETURN_VAL(sb, NULL);
+
+   return sb->buffer;
+}
+
+Eina_Bool
+_shared_buffer_resource_set(Shared_Buffer *sb, struct bq_buffer *resource)
+{
+   EINA_SAFETY_ON_NULL_RETURN_VAL(sb, EINA_FALSE);
+
+   if (sb->resource)
+     {
+        ERR("Already exist resource");
+        return EINA_FALSE;
+     }
+
+   sb->resource = resource;
+
+   return EINA_TRUE;
+}
+
+struct bq_buffer *
+_shared_buffer_resource_get(Shared_Buffer *sb)
+{
+   EINA_SAFETY_ON_NULL_RETURN_VAL(sb, NULL);
+
+   return sb->resource;
+}
+
+void
+_shared_buffer_state_set(Shared_Buffer *sb, Shared_Buffer_State state)
+{
+   EINA_SAFETY_ON_NULL_RETURN(sb);
+
+   sb->state = state;
+}
+
+Shared_Buffer_State
+_shared_buffer_state_get(Shared_Buffer *sb)
+{
+   EINA_SAFETY_ON_NULL_RETURN_VAL(sb, SHARED_BUFFER_STATE_UNKNOWN);
+
+   return sb->state;
+}
+
+const char *
+_shared_buffer_state_string_get(Shared_Buffer *sb)
+{
+   EINA_SAFETY_ON_NULL_RETURN_VAL(sb, "INVAILD OBJECT");
+
+   switch (sb->state)
+     {
+      case SHARED_BUFFER_STATE_ENQUEUE:
+         return "SHARED_BUFFER_STATE_ENQUEUE";
+      case SHARED_BUFFER_STATE_SUBMIT:
+         return "SHARED_BUFFER_STATE_SUBMIT";
+      case SHARED_BUFFER_STATE_DEQUEUE:
+         return "SHARED_BUFFER_STATE_DEQUEUE";
+      case SHARED_BUFFER_STATE_ATTACH:
+         return "SHARED_BUFFER_STATE_ATTACH";
+      case SHARED_BUFFER_STATE_IMPORT:
+         return "SHARED_BUFFER_STATE_IMPORT";
+      case SHARED_BUFFER_STATE_DETACH:
+         return "SHARED_BUFFER_STATE_DETACH";
+      case SHARED_BUFFER_STATE_ACQUIRE:
+         return "SHARED_BUFFER_STATE_ACQUIRE";
+      case SHARED_BUFFER_STATE_RELEASE:
+         return "SHARED_BUFFER_STATE_RELEASE";
+      default:
+      case SHARED_BUFFER_STATE_UNKNOWN:
+         return "SHARED_BUFFER_STATE_UNKNOWN";
+     }
+}