Implement surface copy request, use it for egl gears.

egl-compositor.c

@@ -149,8 +149,8 @@ notify_surface_attach(struct wl_compositor *compositor,
 	/* FIXME: We need to use a single buffer config without depth
 	 * or stencil buffers here to keep egl from creating auxillary
 	 * buffers for the pixmap here. */
-	sd->surface = eglCreatePixmapForName(ec->display, ec->config,
+	sd->surface = eglCreateSurfaceForName(ec->display, ec->config,
-					     name, width, height, stride, NULL);
+					      name, width, height, stride, NULL);
 
 	glBindTexture(GL_TEXTURE_2D, sd->texture);
 	glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
@@ -185,15 +185,29 @@ notify_surface_copy(struct wl_compositor *compositor,
 		    uint32_t name, uint32_t stride,
 		    int32_t x, int32_t y, int32_t width, int32_t height)
 {
-	/* FIXME: Eek, how do we do this... extend the DRI CopyBuffer
+	struct egl_compositor *ec = (struct egl_compositor *) compositor;
-	 * extension and expose it in eagle?  Make the surface the
+	EGLSurface src;
-	 * draw buffer and the named buffer the read buffer and use
+	struct surface_data *sd;
-	 * glCopyPixels? */
+
+	sd = wl_surface_get_data(surface);
+
+	/* FIXME: glCopyPixels should work, but then we'll have to
+	 * call eglMakeCurrent to set up the src and dest surfaces
+	 * first.  This seems cheaper, but maybe there's a better way
+	 * to accomplish this. */
+
+	src = eglCreateSurfaceForName(ec->display, ec->config,
+				      name, x + width, y + height, stride, NULL);
+
+	eglCopyNativeBuffers(ec->display, sd->surface, GL_FRONT_LEFT, dst_x, dst_y,
+			     src, GL_FRONT_LEFT, x, y, width, height);
+	schedule_repaint(ec);
 }
 
 static void
 notify_surface_damage(struct wl_compositor *compositor,
-		      struct wl_surface *surface)
+		      struct wl_surface *surface,
+		      int32_t x, int32_t y, int32_t width, int32_t height)
 {
 	struct egl_compositor *ec = (struct egl_compositor *) compositor;
 

gears.c

@@ -125,7 +125,8 @@ gear(GLfloat inner_radius, GLfloat outer_radius, GLfloat width,
 }
 
 struct gears *
-gears_create(void)
+gears_create(GLfloat clear_red, GLfloat clear_green,
+	     GLfloat clear_blue, GLfloat clear_alpha)
 {
 	static GLfloat red[4] = {0.8, 0.1, 0.0, 1.0};
 	static GLfloat green[4] = {0.0, 0.8, 0.2, 1.0};
@@ -166,6 +167,14 @@ gears_create(void)
 	glEnable(GL_LIGHT0);
 	glEnable(GL_DEPTH_TEST);
 
+	/* We're generating premultiplied alpha so multiply in the
+	 * alpha.  The gears are solid color and doesn't have
+	 * anti-aliased edges, they're ok. */
+	glClearColor(clear_red * clear_alpha,
+		     clear_green * clear_alpha,
+		     clear_blue * clear_alpha,
+		     clear_alpha);
+
 	return gears;
 }
 
@@ -174,7 +183,7 @@ gears_draw(struct gears *gears, GLfloat angle)
 {
 	GLfloat view_rotx = 20.0, view_roty = 30.0, view_rotz = 0.0;
 
-	glClear(GL_DEPTH_BUFFER_BIT);
+	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
 	glPushMatrix();
 

gears.h

@@ -3,7 +3,7 @@
 
 struct gears;
 
-struct gears *gears_create(void);
+struct gears *gears_create(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
 
 void gears_draw(struct gears *gears, GLfloat angle);
 

wayland.h

@@ -139,7 +139,6 @@ struct wl_compositor_interface {
 				      struct wl_surface *surface,
 				      int32_t x, int32_t y,
 				      int32_t width, int32_t height);
-
 };
 
 void wl_display_set_compositor(struct wl_display *display,

window.c

@@ -27,65 +27,115 @@ static void die(const char *msg)
 	exit(EXIT_FAILURE);
 }
 
-static uint32_t name_cairo_surface(int fd, cairo_surface_t *surface)
+struct buffer {
+	int width, height, stride;
+	uint32_t name, handle;
+};
+
+static struct buffer *
+buffer_create(int fd, int width, int height, int stride)
 {
+	struct buffer *buffer;
 	struct drm_i915_gem_create create;
 	struct drm_gem_flink flink;
-	struct drm_i915_gem_pwrite pwrite;
-	int32_t width, height, stride;
-	void *data;
 
-	width = cairo_image_surface_get_width(surface);
+	buffer = malloc(sizeof *buffer);
-	height = cairo_image_surface_get_height(surface);
+	buffer->width = width;
-	stride = cairo_image_surface_get_stride(surface);
+	buffer->height = height;
-	data = cairo_image_surface_get_data(surface);
+	buffer->stride = stride;
 
 	memset(&create, 0, sizeof(create));
 	create.size = height * stride;
 
 	if (ioctl(fd, DRM_IOCTL_I915_GEM_CREATE, &create) != 0) {
 		fprintf(stderr, "gem create failed: %m\n");
-		return 0;
+		free(buffer);
-	}
+		return NULL;
-
-	pwrite.handle = create.handle;
-	pwrite.offset = 0;
-	pwrite.size = height * stride;
-	pwrite.data_ptr = (uint64_t) (uintptr_t) data;
-	if (ioctl(fd, DRM_IOCTL_I915_GEM_PWRITE, &pwrite) < 0) {
-		fprintf(stderr, "gem pwrite failed: %m\n");
-		return 0;
 	}
 
 	flink.handle = create.handle;
 	if (ioctl(fd, DRM_IOCTL_GEM_FLINK, &flink) != 0) {
 		fprintf(stderr, "gem flink failed: %m\n");
+		free(buffer);
 		return 0;
 	}
 
-#if 0
+	buffer->handle = flink.handle;
-	/* We need to hold on to the handle until the server has received
+	buffer->name = flink.name;
-	 * the attach request... we probably need a confirmation event.
+
-	 * I guess the breadcrumb idea will suffice. */
+	return buffer;
+}
+
+static int
+buffer_destroy(struct buffer *buffer, int fd)
+{
 	struct drm_gem_close close;
-	close.handle = create.handle;
+
+	close.handle = buffer->handle;
 	if (ioctl(fd, DRM_IOCTL_GEM_CLOSE, &close) < 0) {
 		fprintf(stderr, "gem close failed: %m\n");
-		return 0;
+		return -1;
+	}
+	
+	free(buffer);
+
+	return 0;
+}
+
+static int
+buffer_data(struct buffer *buffer, int fd, void *data)
+{
+	struct drm_i915_gem_pwrite pwrite;
+
+	pwrite.handle = buffer->handle;
+	pwrite.offset = 0;
+	pwrite.size = buffer->height * buffer->stride;
+	pwrite.data_ptr = (uint64_t) (uintptr_t) data;
+
+	if (ioctl(fd, DRM_IOCTL_I915_GEM_PWRITE, &pwrite) < 0) {
+		fprintf(stderr, "gem pwrite failed: %m\n");
+		return -1;
+	}
+
+	return 0;
+}
+
+static struct buffer *
+buffer_create_from_cairo_surface(int fd, cairo_surface_t *surface)
+{
+	struct buffer *buffer;
+	int32_t width, height, stride;
+	void *data;
+
+	width = cairo_image_surface_get_width(surface);
+	height = cairo_image_surface_get_height(surface);
+	stride = cairo_image_surface_get_stride(surface);
+	data = cairo_image_surface_get_data(surface);
+
+	buffer = buffer_create(fd, width, height, stride);
+	if (buffer == NULL)
+		return NULL;
+
+	if (buffer_data(buffer, fd, data) < 0) {
+		buffer_destroy(buffer, fd);
+		return NULL;
 	}			
-#endif
 
-	return flink.name;
+	return buffer;
 }
 
 struct window {
 	struct wl_surface *surface;
-	int x, y, width, height, stride;
+	int x, y, width, height;
 	int drag_x, drag_y, last_x, last_y;
 	int state;
 	uint32_t name;
 	int fd;
 	int redraw_scheduled;
+	cairo_pattern_t *background;
+
+	struct buffer *buffer;
+	struct buffer *egl_buffer;
 
 	GLfloat gears_angle;
 	struct gears *gears;
@@ -104,11 +154,11 @@ draw_window(void *data)
 	int border = 2, radius = 5, h;
 	int margin = (border + 1) / 2;
 	cairo_text_extents_t extents;
+	struct buffer *buffer;
 	const static char title[] = "Wayland First Post";
 
 	surface = cairo_image_surface_create(CAIRO_FORMAT_RGB24,
-					     window->width,
+					     window->width, window->height);
-					     window->height);
 
 	cr = cairo_create(surface);
 	cairo_set_line_width (cr, border);
@@ -122,7 +172,7 @@ draw_window(void *data)
 		      window->height - margin);
 	cairo_line_to(cr, margin, window->height - margin);
 	cairo_close_path(cr);
-	cairo_set_source_rgba(cr, 0.2, 0.2, 0.2, 0.9);
+	cairo_set_source(cr, window->background);
 	cairo_fill_preserve(cr);
 	cairo_set_source_rgba(cr, 0, 0, 0, 1);
 	cairo_set_font_size(cr, 14);
@@ -137,39 +187,27 @@ draw_window(void *data)
 
 	cairo_destroy(cr);
 
-	window->stride = cairo_image_surface_get_stride(surface);
+	if (window->buffer != NULL)
+		buffer_destroy(window->buffer, window->fd);
+	buffer = buffer_create_from_cairo_surface(window->fd, surface);
+	window->buffer = buffer;
 
-	window->name = name_cairo_surface(window->fd, surface);
 	cairo_surface_destroy(surface);
 
-	wl_surface_attach(window->surface, window->name,
+	wl_surface_attach(window->surface, buffer->name,
-			  window->width, window->height, window->stride);
+			  buffer->width, buffer->height, buffer->stride);
-			  
-	wl_surface_map(window->surface, 
-		       window->x, window->y,
-		       window->width, window->height);
-
-	if (window->egl_surface != EGL_NO_SURFACE)
-		eglDestroySurface(window->display, window->egl_surface);
-
-	/* FIXME: We need to get the stride right here in a chipset
-	 * independent way.  Maybe do it in name_cairo_surface(). */
-	window->egl_surface = eglCreatePixmapForName(window->display,
-						     window->config, window->name,
-						     window->width, window->height,
-						     window->stride, NULL);
-
-	if (surface == NULL)
-		die("failed to create surface\n");
 			  
-	if (!eglMakeCurrent(window->display,
+	/* FIXME: Free window->buffer when we receive the ack event. */
-			    window->egl_surface, window->egl_surface, window->context))
-		die("failed to make context current\n");
 
-	glViewport(border, window->height - h - margin - 300, 300, 300);
+	buffer = window->egl_buffer;
+	gears_draw(window->gears, window->gears_angle);
+	wl_surface_copy(window->surface, 20, 50,
+			buffer->name, buffer->stride,
+			0, 0, buffer->width, buffer->height);
 
-	if (window->gears != NULL)
+	wl_surface_map(window->surface, 
-		gears_draw(window->gears, window->gears_angle);
+		       window->x, window->y,
+		       buffer->width, buffer->height);
 
 	window->redraw_scheduled = 0;
 
@@ -215,6 +253,10 @@ void event_handler(struct wl_display *display,
 		case WINDOW_RESIZING_LOWER_RIGHT:
 			window->width = window->drag_x + arg1;
 			window->height = window->drag_y + arg2;
+			if (window->width < 400)
+				window->width = 400;
+			if (window->height < 400)
+				window->height = 400;
 			if (!window->redraw_scheduled) {
 				window->redraw_scheduled = 1;
 				g_idle_add(draw_window, window);
@@ -264,11 +306,14 @@ window_create(struct wl_display *display, int fd)
 	EGLint major, minor, count;
 	EGLConfig configs[64];
 	struct window *window;
+	struct buffer *buffer;
+	const GLfloat red = 0.3, green = 0.3, blue = 0.3, alpha = 0.9;
 
 	window = malloc(sizeof *window);
 	if (window == NULL)
 		return NULL;
 
+	memset(window, 0, sizeof *window);
 	window->surface = wl_display_create_surface(display);
 	window->x = 200;
 	window->y = 200;
@@ -276,7 +321,7 @@ window_create(struct wl_display *display, int fd)
 	window->height = 500;
 	window->state = WINDOW_STABLE;
 	window->fd = fd;
-	window->gears = NULL;
+	window->background = cairo_pattern_create_rgba (red, green, blue, alpha);
 
 	window->display = eglCreateDisplayNative("/dev/dri/card0", "i965");
 	if (window->display == NULL)
@@ -293,13 +338,29 @@ window_create(struct wl_display *display, int fd)
 	if (window->context == NULL)
 		die("failed to create context\n");
 
-	window->egl_surface = EGL_NO_SURFACE;
+	/* FIXME: We need to get the stride right here in a chipset
+	 * independent way.  Maybe do it in name_cairo_surface(). */
+	buffer = buffer_create(window->fd, 300, 300, (300 * 4 + 15) & ~15);
+	window->egl_buffer = buffer;
+	window->egl_surface = eglCreateSurfaceForName(window->display,
+						      window->config, buffer->name,
+						      buffer->width, buffer->height,
+						      buffer->stride, NULL);
 
-	draw_window(window);
+	if (window->egl_surface == NULL)
+		die("failed to create egl surface\n");
+
+	if (!eglMakeCurrent(window->display,
+			    window->egl_surface, window->egl_surface, window->context))
+		die("failed to make context current\n");
 
-	window->gears = gears_create();
+	glViewport(0, 0, 300, 300);
+
+	window->gears = gears_create(red, green, blue, alpha);
 	window->gears_angle = 0.0;
 
+	draw_window(window);
+
 	return window;
 }
 
@@ -307,10 +368,15 @@ static gboolean
 draw(gpointer data)
 {
 	struct window *window = data;
+	struct buffer *buffer;
 
 	gears_draw(window->gears, window->gears_angle);
-	wl_surface_damage(window->surface, 0, 0,
+
-			  window->width, window->height);
+	buffer = window->egl_buffer;
+	wl_surface_copy(window->surface, 20, 50,
+			buffer->name, buffer->stride,
+			0, 0, buffer->width, buffer->height);
+
 	window->gears_angle += 1;
 
 	return TRUE;