if HAVE_WAYLAND
ENLIGHTENMENTHEADERS += \
+src/bin/e_drm_buffer_pool.h \
+src/bin/e_drm_buffer_pool_server_protocol.h \
src/bin/e_uuid_store.h \
src/bin/e_comp_wl_data.h \
src/bin/e_comp_wl_input.h \
if HAVE_WAYLAND
enlightenment_src += \
+src/bin/e_drm_buffer_pool.c \
+src/bin/e_drm_buffer_pool_server_protocol.c \
src/bin/e_uuid_store.c \
src/bin/e_comp_wl_data.c \
src/bin/e_comp_wl_input.c \
EAPI int E_EVENT_CLIENT_ROTATION_CHANGE_END = -1;
#endif
EAPI int E_EVENT_CLIENT_VISIBILITY_CHANGE = -1;
+#ifdef HAVE_WAYLAND_ONLY
+EAPI int E_EVENT_CLIENT_BUFFER_CHANGE = -1;
+#endif
static Eina_Hash *clients_hash = NULL; // pixmap->client
E_EVENT_CLIENT_ROTATION_CHANGE_END = ecore_event_type_new();
#endif
E_EVENT_CLIENT_VISIBILITY_CHANGE = ecore_event_type_new();
+#ifdef HAVE_WAYLAND_ONLY
+ E_EVENT_CLIENT_BUFFER_CHANGE = ecore_event_type_new();
+#endif
return (!!clients_hash);
}
EAPI extern int E_EVENT_CLIENT_ROTATION_CHANGE_END;
#endif
EAPI extern int E_EVENT_CLIENT_VISIBILITY_CHANGE;
+#ifdef HAVE_WAYLAND_ONLY
+EAPI extern int E_EVENT_CLIENT_BUFFER_CHANGE;
+#endif
EINTERN void e_client_idler_before(void);
EINTERN Eina_Bool e_client_init(void);
E_Comp_Wl_Subsurf_Data *sdata;
Evas_Map *map;
int x1, y1, x2, y2, x, y;
+ int dx, dy;
sdata = ec->comp_data->sub.data;
- EINA_SAFETY_ON_NULL_RETURN(sdata);
+ if (sdata)
+ {
+ dx = sdata->parent->x + sdata->position.x;
+ dy = sdata->parent->y + sdata->position.y;
+ }
+ else
+ {
+ dx = ec->x;
+ dy = ec->y;
+ }
map = evas_map_new(4);
return ret;
}
+static void
+e_comp_wl_surface_event_simple_free(void *d EINA_UNUSED, E_Event_Client *ev)
+{
+ e_object_unref(E_OBJECT(ev->ec));
+ free(ev);
+}
+
EINTERN void
e_comp_wl_surface_attach(E_Client *ec, E_Comp_Wl_Buffer *buffer)
{
+ E_Event_Client *ev;
+
e_comp_wl_buffer_reference(&ec->comp_data->buffer_ref, buffer);
/* set usable early because shell module checks this */
_e_comp_wl_surface_state_size_update(ec, &ec->comp_data->pending);
_e_comp_wl_map_size_cal_from_buffer(ec);
+
+ ev = E_NEW(E_Event_Client, 1);
+ ev->ec = ec;
+ e_object_ref(E_OBJECT(ec));
+ ecore_event_add(E_EVENT_CLIENT_BUFFER_CHANGE, ev,
+ (Ecore_End_Cb)e_comp_wl_surface_event_simple_free, NULL);
}
EINTERN Eina_Bool
return EINA_TRUE;
}
-EINTERN void
+EAPI void
e_comp_wl_buffer_reference(E_Comp_Wl_Buffer_Ref *ref, E_Comp_Wl_Buffer *buffer)
{
if ((ref->buffer) && (buffer != ref->buffer))
if (ref->buffer->busy == 0)
{
if (!wl_resource_get_client(ref->buffer->resource)) return;
- wl_resource_queue_event(ref->buffer->resource, WL_BUFFER_RELEASE);
+ wl_buffer_send_release(ref->buffer->resource);
}
wl_list_remove(&ref->destroy_listener.link);
}
struct wl_shm_buffer *shmbuff;
E_Comp_Data *cdata;
Eina_Bool res;
+ E_Drm_Buffer *drm_buffer;
listener =
wl_resource_get_destroy_listener(resource, _e_comp_wl_buffer_cb_destroy);
buffer->w = wl_shm_buffer_get_width(shmbuff);
buffer->h = wl_shm_buffer_get_height(shmbuff);
}
+ else if ((drm_buffer = e_drm_buffer_get(resource)))
+ {
+ buffer->type = E_COMP_WL_BUFFER_TYPE_DRM;
+ buffer->w = drm_buffer->width;
+ buffer->h = drm_buffer->height;
+ }
else
{
cdata = e_comp->wl_comp_data;
{
E_COMP_WL_BUFFER_TYPE_NONE = 0,
E_COMP_WL_BUFFER_TYPE_SHM = 1,
- E_COMP_WL_BUFFER_TYPE_NATIVE = 2
+ E_COMP_WL_BUFFER_TYPE_NATIVE = 2,
+ E_COMP_WL_BUFFER_TYPE_DRM = 3
} E_Comp_Wl_Buffer_Type;
struct _E_Comp_Wl_Buffer
EINTERN void e_comp_wl_surface_attach(E_Client *ec, E_Comp_Wl_Buffer *buffer);
EINTERN Eina_Bool e_comp_wl_surface_commit(E_Client *ec);
EINTERN Eina_Bool e_comp_wl_subsurface_commit(E_Client *ec);
-EINTERN void e_comp_wl_buffer_reference(E_Comp_Wl_Buffer_Ref *ref, E_Comp_Wl_Buffer *buffer);
+EAPI void e_comp_wl_buffer_reference(E_Comp_Wl_Buffer_Ref *ref, E_Comp_Wl_Buffer *buffer);
EAPI E_Comp_Wl_Buffer *e_comp_wl_buffer_get(struct wl_resource *resource);
EAPI struct wl_signal e_comp_wl_surface_create_signal_get(E_Comp *comp);
--- /dev/null
+/*
+ * Copyright © 2011 Kristian Høgsberg
+ * Copyright © 2011 Benjamin Franzke
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ * Authors:
+ * Kristian Høgsberg <krh@bitplanet.net>
+ * Benjamin Franzke <benjaminfranzke@googlemail.com>
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stddef.h>
+#include <unistd.h>
+
+#include <Ecore_Drm.h>
+#include "e.h"
+#include "e_drm_buffer_pool.h"
+#include "e_drm_buffer_pool_server_protocol.h"
+
+#undef MIN
+#define MIN(x,y) (((x)<(y))?(x):(y))
+
+struct _E_Drm_Buffer_Pool
+{
+ struct wl_display *display;
+ E_Drm_Buffer_Callbacks *callbacks;
+ void *user_data;
+
+ Eina_List *format_list;
+ struct wl_global *wl_global;
+};
+
+/* TODO: what's better way to get device_name? */
+static const char*
+get_device_name(void)
+{
+ Eina_List *devs = ecore_drm_devices_get();
+ Ecore_Drm_Device *dev;
+
+ if (!devs)
+ return NULL;
+
+ dev = eina_list_nth(devs, 0);
+
+ return ecore_drm_device_name_get(dev);
+}
+
+static void
+destroy_drm_buffer(struct wl_resource *resource)
+{
+ E_Drm_Buffer *buffer = wl_resource_get_user_data(resource);
+ E_Drm_Buffer_Pool *pool = buffer->pool;
+
+ pool->callbacks->release_buffer(pool->user_data, buffer);
+ free(buffer);
+}
+
+static void
+_e_drm_buffer_cb_destroy(struct wl_client *client, struct wl_resource *resource)
+{
+ wl_resource_destroy(resource);
+}
+
+static const struct wl_buffer_interface _e_drm_buffer_interface = {
+ _e_drm_buffer_cb_destroy
+};
+
+static void
+create_drm_buffer(struct wl_client *client, struct wl_resource *resource, uint32_t id,
+ int32_t width, int32_t height, uint32_t format,
+ uint32_t name0, int32_t offset0, int32_t stride0,
+ uint32_t name1, int32_t offset1, int32_t stride1,
+ uint32_t name2, int32_t offset2, int32_t stride2)
+{
+ E_Drm_Buffer_Pool *pool = wl_resource_get_user_data(resource);
+ E_Drm_Buffer *buffer;
+ void *fmt;
+ Eina_List *f;
+ Eina_Bool found = EINA_FALSE;
+
+ EINA_LIST_FOREACH(pool->format_list, f, fmt)
+ {
+ if (format == (uint)(uintptr_t)fmt)
+ {
+ found = EINA_TRUE;
+ break;
+ }
+ }
+
+ if (!found)
+ {
+ wl_resource_post_error(resource, TIZEN_BUFFER_POOL_ERROR_INVALID_FORMAT, "invalid format");
+ return;
+ }
+
+ buffer = calloc(1, sizeof *buffer);
+ if (buffer == NULL)
+ {
+ wl_resource_post_no_memory(resource);
+ return;
+ }
+
+ buffer->width = width;
+ buffer->height = height;
+ buffer->format = format;
+ buffer->name[0] = name0;
+ buffer->offset[0] = offset0;
+ buffer->stride[0] = stride0;
+ buffer->name[1] = name1;
+ buffer->offset[1] = offset1;
+ buffer->stride[1] = stride1;
+ buffer->name[2] = name2;
+ buffer->offset[2] = offset2;
+ buffer->stride[2] = stride2;
+ buffer->pool = pool;
+
+ pool->callbacks->reference_buffer(pool->user_data, buffer);
+ if (buffer->driver_buffer == NULL)
+ {
+ wl_resource_post_error(resource, TIZEN_BUFFER_POOL_ERROR_INVALID_NAME, "invalid name");
+ free(buffer);
+ return;
+ }
+
+ buffer->resource = wl_resource_create(client, &wl_buffer_interface, 1, id);
+ if (!buffer->resource)
+ {
+ wl_resource_post_no_memory(resource);
+ pool->callbacks->release_buffer(pool->user_data, buffer);
+ free(buffer);
+ return;
+ }
+
+ wl_resource_set_implementation(buffer->resource, &_e_drm_buffer_interface,
+ buffer, destroy_drm_buffer);
+}
+
+static void
+_e_drm_buffer_pool_authenticate(struct wl_client *client, struct wl_resource *resource, uint32_t id)
+{
+ tizen_buffer_pool_send_authenticated(resource);
+}
+
+static void
+_e_drm_buffer_pool_create_buffer(struct wl_client *client,
+ struct wl_resource *resource, uint32_t id, uint32_t name,
+ int32_t width, int32_t height, uint32_t stride, uint32_t format)
+{
+ create_drm_buffer(client, resource, id, width, height, format, name, 0, stride,
+ 0, 0, 0, 0, 0, 0);
+}
+
+static void
+_e_drm_buffer_pool_create_planar_buffer(struct wl_client *client,
+ struct wl_resource *resource, uint32_t id,
+ int32_t width, int32_t height, uint32_t format,
+ uint32_t name0, int32_t offset0, int32_t stride0,
+ uint32_t name1, int32_t offset1, int32_t stride1,
+ uint32_t name2, int32_t offset2, int32_t stride2)
+{
+ create_drm_buffer(client, resource, id, width, height, format, name0, offset0, stride0,
+ name1, offset1, stride1, name2, offset2, stride2);
+}
+
+static const struct tizen_buffer_pool_interface _e_drm_buffer_pool_interface =
+{
+ _e_drm_buffer_pool_authenticate,
+ _e_drm_buffer_pool_create_buffer,
+ _e_drm_buffer_pool_create_planar_buffer
+};
+
+static void
+_e_drm_buffer_pool_cb_bind(struct wl_client *client, void *data, uint32_t version, uint32_t id)
+{
+ E_Drm_Buffer_Pool *pool = data;
+ struct wl_resource *res;
+ const char *device_name = get_device_name();
+ uint caps = 0;
+ int i, fmt_cnt = 0;
+ uint *fmts;
+
+ if (!(res = wl_resource_create(client, &tizen_buffer_pool_interface, MIN(version, 1), id)))
+ {
+ ERR("Could not create tizen_screenshooter resource: %m");
+ wl_client_post_no_memory(client);
+ return;
+ }
+
+ wl_resource_set_implementation(res, &_e_drm_buffer_pool_interface, pool, NULL);
+
+ if (pool->callbacks->get_capbilities)
+ caps = pool->callbacks->get_capbilities(pool->user_data);
+
+ fmts = pool->callbacks->get_formats(pool->user_data, &fmt_cnt);
+
+ tizen_buffer_pool_send_device(res, device_name ? device_name : "unkown");
+ tizen_buffer_pool_send_capabilities(res, caps);
+ for (i = 0; i < fmt_cnt; i++)
+ {
+ pool->format_list = eina_list_append(pool->format_list, (void*)(uintptr_t)fmts[i]);
+ tizen_buffer_pool_send_format(res, fmts[i]);
+ }
+ free(fmts);
+}
+
+EAPI int
+e_drm_buffer_pool_init(struct wl_display *display, E_Drm_Buffer_Callbacks *callbacks, void *user_data)
+{
+ E_Drm_Buffer_Pool *pool;
+
+ EINA_SAFETY_ON_NULL_RETURN_VAL(display, 0);
+ EINA_SAFETY_ON_NULL_RETURN_VAL(callbacks, 0);
+ EINA_SAFETY_ON_NULL_RETURN_VAL(callbacks->get_formats, 0);
+ EINA_SAFETY_ON_NULL_RETURN_VAL(callbacks->reference_buffer, 0);
+ EINA_SAFETY_ON_NULL_RETURN_VAL(callbacks->release_buffer, 0);
+
+ pool = malloc(sizeof *pool);
+ EINA_SAFETY_ON_NULL_RETURN_VAL(pool, 0);
+
+ pool->display = display;
+ pool->callbacks = callbacks;
+ pool->user_data = user_data;
+
+ pool->format_list = NULL;
+ pool->wl_global = wl_global_create(display, &tizen_buffer_pool_interface, 1,
+ pool, _e_drm_buffer_pool_cb_bind);
+ if (!pool->wl_global)
+ {
+ free (pool);
+ return 0;
+ }
+
+ return 1;
+}
+
+EAPI E_Drm_Buffer*
+e_drm_buffer_get(struct wl_resource *resource)
+{
+ if (resource == NULL)
+ return NULL;
+
+ if (wl_resource_instance_of(resource, &wl_buffer_interface, &_e_drm_buffer_interface))
+ return wl_resource_get_user_data(resource);
+ else
+ return NULL;
+}
--- /dev/null
+#ifdef E_TYPEDEFS
+
+#else
+#ifndef E_BUFFER_POOL_H
+#define E_BUFFER_POOL_H
+
+#include <wayland-server.h>
+
+typedef struct _E_Drm_Buffer_Pool E_Drm_Buffer_Pool;
+
+typedef struct _E_Drm_Buffer
+{
+ int width, height;
+ uint format;
+ uint name[3];
+ int offset[3];
+ int stride[3];
+
+ E_Drm_Buffer_Pool *pool;
+ struct wl_resource *resource;
+ void *driver_buffer;
+} E_Drm_Buffer;
+
+typedef struct _E_Drm_Buffer_Callbacks
+{
+ uint (*get_capbilities)(void *user_data);
+ uint* (*get_formats)(void *user_data, int *format_cnt);
+ void (*reference_buffer)(void *user_data, E_Drm_Buffer *buffer);
+ void (*release_buffer)(void *user_data, E_Drm_Buffer *buffer);
+} E_Drm_Buffer_Callbacks;
+
+EAPI int e_drm_buffer_pool_init(struct wl_display *display,
+ E_Drm_Buffer_Callbacks *callbacks,
+ void *user_data);
+
+EAPI E_Drm_Buffer *e_drm_buffer_get(struct wl_resource *resource);
+
+#endif
+#endif
--- /dev/null
+#include <stdlib.h>
+#include <stdint.h>
+#include "wayland-util.h"
+
+extern const struct wl_interface wl_buffer_interface;
+
+static const struct wl_interface *types[] = {
+ NULL,
+ &wl_buffer_interface,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ &wl_buffer_interface,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+};
+
+static const struct wl_message tizen_buffer_pool_requests[] = {
+ { "authenticate", "u", types + 0 },
+ { "create_buffer", "nuiiuu", types + 1 },
+ { "create_planar_buffer", "niiuuiiuiiuii", types + 7 },
+};
+
+static const struct wl_message tizen_buffer_pool_events[] = {
+ { "device", "s", types + 0 },
+ { "authenticated", "", types + 0 },
+ { "capabilities", "u", types + 0 },
+ { "format", "u", types + 0 },
+};
+
+WL_EXPORT const struct wl_interface tizen_buffer_pool_interface = {
+ "tizen_buffer_pool", 1,
+ 3, tizen_buffer_pool_requests,
+ 4, tizen_buffer_pool_events,
+};
--- /dev/null
+#ifndef TIZEN_BUFFER_POOL_SERVER_PROTOCOL_H
+#define TIZEN_BUFFER_POOL_SERVER_PROTOCOL_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+#include <stddef.h>
+#include "wayland-server.h"
+
+struct wl_client;
+struct wl_resource;
+
+struct tizen_buffer_pool;
+
+extern const struct wl_interface tizen_buffer_pool_interface;
+
+#ifndef TIZEN_BUFFER_POOL_ERROR_ENUM
+#define TIZEN_BUFFER_POOL_ERROR_ENUM
+enum tizen_buffer_pool_error {
+ TIZEN_BUFFER_POOL_ERROR_INVALID_FORMAT = 0,
+ TIZEN_BUFFER_POOL_ERROR_INVALID_NAME = 1,
+};
+#endif /* TIZEN_BUFFER_POOL_ERROR_ENUM */
+
+#ifndef TIZEN_BUFFER_POOL_CAPABILITY_ENUM
+#define TIZEN_BUFFER_POOL_CAPABILITY_ENUM
+enum tizen_buffer_pool_capability {
+ TIZEN_BUFFER_POOL_CAPABILITY_DEFAULT = 0,
+ TIZEN_BUFFER_POOL_CAPABILITY_VIDEO = 0x1,
+ TIZEN_BUFFER_POOL_CAPABILITY_SCREENMIRROR = 0x2,
+};
+#endif /* TIZEN_BUFFER_POOL_CAPABILITY_ENUM */
+
+#ifndef TIZEN_BUFFER_POOL_FORMAT_ENUM
+#define TIZEN_BUFFER_POOL_FORMAT_ENUM
+enum tizen_buffer_pool_format {
+ TIZEN_BUFFER_POOL_FORMAT_C8 = 0x20203843,
+ TIZEN_BUFFER_POOL_FORMAT_RGB332 = 0x38424752,
+ TIZEN_BUFFER_POOL_FORMAT_BGR233 = 0x38524742,
+ TIZEN_BUFFER_POOL_FORMAT_XRGB4444 = 0x32315258,
+ TIZEN_BUFFER_POOL_FORMAT_XBGR4444 = 0x32314258,
+ TIZEN_BUFFER_POOL_FORMAT_RGBX4444 = 0x32315852,
+ TIZEN_BUFFER_POOL_FORMAT_BGRX4444 = 0x32315842,
+ TIZEN_BUFFER_POOL_FORMAT_ARGB4444 = 0x32315241,
+ TIZEN_BUFFER_POOL_FORMAT_ABGR4444 = 0x32314241,
+ TIZEN_BUFFER_POOL_FORMAT_RGBA4444 = 0x32314152,
+ TIZEN_BUFFER_POOL_FORMAT_BGRA4444 = 0x32314142,
+ TIZEN_BUFFER_POOL_FORMAT_XRGB1555 = 0x35315258,
+ TIZEN_BUFFER_POOL_FORMAT_XBGR1555 = 0x35314258,
+ TIZEN_BUFFER_POOL_FORMAT_RGBX5551 = 0x35315852,
+ TIZEN_BUFFER_POOL_FORMAT_BGRX5551 = 0x35315842,
+ TIZEN_BUFFER_POOL_FORMAT_ARGB1555 = 0x35315241,
+ TIZEN_BUFFER_POOL_FORMAT_ABGR1555 = 0x35314241,
+ TIZEN_BUFFER_POOL_FORMAT_RGBA5551 = 0x35314152,
+ TIZEN_BUFFER_POOL_FORMAT_BGRA5551 = 0x35314142,
+ TIZEN_BUFFER_POOL_FORMAT_RGB565 = 0x36314752,
+ TIZEN_BUFFER_POOL_FORMAT_BGR565 = 0x36314742,
+ TIZEN_BUFFER_POOL_FORMAT_RGB888 = 0x34324752,
+ TIZEN_BUFFER_POOL_FORMAT_BGR888 = 0x34324742,
+ TIZEN_BUFFER_POOL_FORMAT_XRGB8888 = 0x34325258,
+ TIZEN_BUFFER_POOL_FORMAT_XBGR8888 = 0x34324258,
+ TIZEN_BUFFER_POOL_FORMAT_RGBX8888 = 0x34325852,
+ TIZEN_BUFFER_POOL_FORMAT_BGRX8888 = 0x34325842,
+ TIZEN_BUFFER_POOL_FORMAT_ARGB8888 = 0x34325241,
+ TIZEN_BUFFER_POOL_FORMAT_ABGR8888 = 0x34324241,
+ TIZEN_BUFFER_POOL_FORMAT_RGBA8888 = 0x34324152,
+ TIZEN_BUFFER_POOL_FORMAT_BGRA8888 = 0x34324142,
+ TIZEN_BUFFER_POOL_FORMAT_XRGB2101010 = 0x30335258,
+ TIZEN_BUFFER_POOL_FORMAT_XBGR2101010 = 0x30334258,
+ TIZEN_BUFFER_POOL_FORMAT_RGBX1010102 = 0x30335852,
+ TIZEN_BUFFER_POOL_FORMAT_BGRX1010102 = 0x30335842,
+ TIZEN_BUFFER_POOL_FORMAT_ARGB2101010 = 0x30335241,
+ TIZEN_BUFFER_POOL_FORMAT_ABGR2101010 = 0x30334241,
+ TIZEN_BUFFER_POOL_FORMAT_RGBA1010102 = 0x30334152,
+ TIZEN_BUFFER_POOL_FORMAT_BGRA1010102 = 0x30334142,
+ TIZEN_BUFFER_POOL_FORMAT_YUYV = 0x56595559,
+ TIZEN_BUFFER_POOL_FORMAT_YVYU = 0x55595659,
+ TIZEN_BUFFER_POOL_FORMAT_UYVY = 0x59565955,
+ TIZEN_BUFFER_POOL_FORMAT_VYUY = 0x59555956,
+ TIZEN_BUFFER_POOL_FORMAT_AYUV = 0x56555941,
+ TIZEN_BUFFER_POOL_FORMAT_NV12 = 0x3231564e,
+ TIZEN_BUFFER_POOL_FORMAT_NV21 = 0x3132564e,
+ TIZEN_BUFFER_POOL_FORMAT_NV16 = 0x3631564e,
+ TIZEN_BUFFER_POOL_FORMAT_NV61 = 0x3136564e,
+ TIZEN_BUFFER_POOL_FORMAT_YUV410 = 0x39565559,
+ TIZEN_BUFFER_POOL_FORMAT_YVU410 = 0x39555659,
+ TIZEN_BUFFER_POOL_FORMAT_YUV411 = 0x31315559,
+ TIZEN_BUFFER_POOL_FORMAT_YVU411 = 0x31315659,
+ TIZEN_BUFFER_POOL_FORMAT_YUV420 = 0x32315559,
+ TIZEN_BUFFER_POOL_FORMAT_YVU420 = 0x32315659,
+ TIZEN_BUFFER_POOL_FORMAT_YUV422 = 0x36315559,
+ TIZEN_BUFFER_POOL_FORMAT_YVU422 = 0x36315659,
+ TIZEN_BUFFER_POOL_FORMAT_YUV444 = 0x34325559,
+ TIZEN_BUFFER_POOL_FORMAT_YVU444 = 0x34325659,
+ TIZEN_BUFFER_POOL_FORMAT_ST12 = 0x32315453,
+};
+#endif /* TIZEN_BUFFER_POOL_FORMAT_ENUM */
+
+struct tizen_buffer_pool_interface {
+ /**
+ * authenticate - (none)
+ * @id: (none)
+ */
+ void (*authenticate)(struct wl_client *client,
+ struct wl_resource *resource,
+ uint32_t id);
+ /**
+ * create_buffer - (none)
+ * @id: (none)
+ * @name: (none)
+ * @width: (none)
+ * @height: (none)
+ * @stride: (none)
+ * @format: (none)
+ */
+ void (*create_buffer)(struct wl_client *client,
+ struct wl_resource *resource,
+ uint32_t id,
+ uint32_t name,
+ int32_t width,
+ int32_t height,
+ uint32_t stride,
+ uint32_t format);
+ /**
+ * create_planar_buffer - (none)
+ * @id: (none)
+ * @width: (none)
+ * @height: (none)
+ * @format: (none)
+ * @name0: (none)
+ * @offset0: (none)
+ * @stride0: (none)
+ * @name1: (none)
+ * @offset1: (none)
+ * @stride1: (none)
+ * @name2: (none)
+ * @offset2: (none)
+ * @stride2: (none)
+ */
+ void (*create_planar_buffer)(struct wl_client *client,
+ struct wl_resource *resource,
+ uint32_t id,
+ int32_t width,
+ int32_t height,
+ uint32_t format,
+ uint32_t name0,
+ int32_t offset0,
+ int32_t stride0,
+ uint32_t name1,
+ int32_t offset1,
+ int32_t stride1,
+ uint32_t name2,
+ int32_t offset2,
+ int32_t stride2);
+};
+
+#define TIZEN_BUFFER_POOL_DEVICE 0
+#define TIZEN_BUFFER_POOL_AUTHENTICATED 1
+#define TIZEN_BUFFER_POOL_CAPABILITIES 2
+#define TIZEN_BUFFER_POOL_FORMAT 3
+
+#define TIZEN_BUFFER_POOL_DEVICE_SINCE_VERSION 1
+#define TIZEN_BUFFER_POOL_AUTHENTICATED_SINCE_VERSION 1
+#define TIZEN_BUFFER_POOL_CAPABILITIES_SINCE_VERSION 1
+#define TIZEN_BUFFER_POOL_FORMAT_SINCE_VERSION 1
+
+static inline void
+tizen_buffer_pool_send_device(struct wl_resource *resource_, const char *name)
+{
+ wl_resource_post_event(resource_, TIZEN_BUFFER_POOL_DEVICE, name);
+}
+
+static inline void
+tizen_buffer_pool_send_authenticated(struct wl_resource *resource_)
+{
+ wl_resource_post_event(resource_, TIZEN_BUFFER_POOL_AUTHENTICATED);
+}
+
+static inline void
+tizen_buffer_pool_send_capabilities(struct wl_resource *resource_, uint32_t value)
+{
+ wl_resource_post_event(resource_, TIZEN_BUFFER_POOL_CAPABILITIES, value);
+}
+
+static inline void
+tizen_buffer_pool_send_format(struct wl_resource *resource_, uint32_t format)
+{
+ wl_resource_post_event(resource_, TIZEN_BUFFER_POOL_FORMAT, format);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
# include "e_comp_wl_data.h"
# include "e_comp_wl_input.h"
# include "e_uuid_store.h"
+# include "e_drm_buffer_pool.h"
#endif
# include "e_comp_x.h"
#endif
+#include "e_drm_buffer_pool_server_protocol.h"
+
static Eina_Hash *pixmaps[2] = {NULL};
static Eina_Hash *res_ids = NULL;
static uint32_t res_id = 0;
}
}
+ else if (buffer->type == E_COMP_WL_BUFFER_TYPE_DRM)
+ {
+ E_Drm_Buffer *drm_buffer = e_drm_buffer_get(buffer->resource);
+ buffer->shm_buffer = NULL;
+ cp->w = buffer->w;
+ cp->h = buffer->h;
+ switch (drm_buffer->format)
+ {
+ case TIZEN_BUFFER_POOL_FORMAT_ARGB8888:
+ cp->image_argb = EINA_TRUE;
+ break;
+ default:
+ cp->image_argb = EINA_FALSE;
+ break;
+ }
+ cp->data = NULL;
+ }
else
{
ERR("Invalid resource:%u", wl_resource_get_id(buffer->resource));
projects / platform / upstream / enlightenment.git / commitdiff