/* * Copyright © 2010-2011 Intel Corporation * Copyright © 2008-2011 Kristian Høgsberg * * Permission to use, copy, modify, distribute, and sell this software and * its documentation for any purpose is hereby granted without fee, provided * that the above copyright notice appear in all copies and that both that * copyright notice and this permission notice appear in supporting * documentation, and that the name of the copyright holders not be used in * advertising or publicity pertaining to distribution of the software * without specific, written prior permission. The copyright holders make * no representations about the suitability of this software for any * purpose. It is provided "as is" without express or implied warranty. * * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF * CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ #define _GNU_SOURCE #include "config.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "compositor.h" static const char *option_socket_name = NULL; static struct wl_list child_process_list; static int sigchld_handler(int signal_number, void *data) { struct wlsc_process *p; int status; pid_t pid; pid = wait(&status); wl_list_for_each(p, &child_process_list, link) { if (p->pid == pid) break; } if (&p->link == &child_process_list) { fprintf(stderr, "unknown child process exited\n"); return 1; } wl_list_remove(&p->link); p->cleanup(p, status); return 1; } WL_EXPORT void wlsc_watch_process(struct wlsc_process *process) { wl_list_insert(&child_process_list, &process->link); } static void child_client_exec(int sockfd, const char *path) { int clientfd; char s[32]; sigset_t allsigs; /* do not give our signal mask to the new process */ sigfillset(&allsigs); sigprocmask(SIG_UNBLOCK, &allsigs, NULL); /* SOCK_CLOEXEC closes both ends, so we dup the fd to get a * non-CLOEXEC fd to pass through exec. */ clientfd = dup(sockfd); if (clientfd == -1) { fprintf(stderr, "compositor: dup failed: %m\n"); return; } snprintf(s, sizeof s, "%d", clientfd); setenv("WAYLAND_SOCKET", s, 1); if (execl(path, path, NULL) < 0) fprintf(stderr, "compositor: executing '%s' failed: %m\n", path); } WL_EXPORT struct wl_client * wlsc_client_launch(struct wlsc_compositor *compositor, struct wlsc_process *proc, const char *path, wlsc_process_cleanup_func_t cleanup) { int sv[2]; pid_t pid; struct wl_client *client; if (socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0, sv) < 0) { fprintf(stderr, "wlsc_client_launch: " "socketpair failed while launching '%s': %m\n", path); return NULL; } pid = fork(); if (pid == -1) { close(sv[0]); close(sv[1]); fprintf(stderr, "wlsc_client_launch: " "fork failed while launching '%s': %m\n", path); return NULL; } if (pid == 0) { child_client_exec(sv[1], path); exit(-1); } close(sv[1]); client = wl_client_create(compositor->wl_display, sv[0]); if (!client) { close(sv[0]); fprintf(stderr, "wlsc_client_launch: " "wl_client_create failed while launching '%s'.\n", path); return NULL; } proc->pid = pid; proc->cleanup = cleanup; wlsc_watch_process(proc); return client; } static void surface_handle_buffer_destroy(struct wl_listener *listener, struct wl_resource *resource, uint32_t time) { struct wlsc_surface *es = container_of(listener, struct wlsc_surface, buffer_destroy_listener); es->buffer = NULL; } static void output_handle_scanout_buffer_destroy(struct wl_listener *listener, struct wl_resource *resource, uint32_t time) { struct wlsc_output *output = container_of(listener, struct wlsc_output, scanout_buffer_destroy_listener); output->scanout_buffer = NULL; if (!output->pending_scanout_buffer) wlsc_compositor_schedule_repaint(output->compositor); } static void output_handle_pending_scanout_buffer_destroy(struct wl_listener *listener, struct wl_resource *resource, uint32_t time) { struct wlsc_output *output = container_of(listener, struct wlsc_output, pending_scanout_buffer_destroy_listener); output->pending_scanout_buffer = NULL; wlsc_compositor_schedule_repaint(output->compositor); } WL_EXPORT struct wlsc_surface * wlsc_surface_create(struct wlsc_compositor *compositor, int32_t x, int32_t y, int32_t width, int32_t height) { struct wlsc_surface *surface; surface = calloc(1, sizeof *surface); if (surface == NULL) return NULL; wl_list_init(&surface->link); wl_list_init(&surface->buffer_link); glGenTextures(1, &surface->texture); glBindTexture(GL_TEXTURE_2D, surface->texture); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); surface->surface.resource.client = NULL; surface->compositor = compositor; surface->visual = WLSC_NONE_VISUAL; surface->image = EGL_NO_IMAGE_KHR; surface->saved_texture = 0; surface->x = x; surface->y = y; surface->width = width; surface->height = height; surface->alpha = 255; surface->fullscreen_output = NULL; surface->buffer = NULL; surface->output = NULL; pixman_region32_init(&surface->damage); pixman_region32_init(&surface->opaque); wl_list_init(&surface->frame_callback_list); surface->buffer_destroy_listener.func = surface_handle_buffer_destroy; surface->transform = NULL; return surface; } WL_EXPORT void wlsc_surface_damage_rectangle(struct wlsc_surface *surface, int32_t x, int32_t y, int32_t width, int32_t height) { struct wlsc_compositor *compositor = surface->compositor; pixman_region32_union_rect(&surface->damage, &surface->damage, surface->x + x, surface->y + y, width, height); wlsc_compositor_schedule_repaint(compositor); } WL_EXPORT void wlsc_surface_damage(struct wlsc_surface *surface) { wlsc_surface_damage_rectangle(surface, 0, 0, surface->width, surface->height); } WL_EXPORT void wlsc_surface_damage_below(struct wlsc_surface *surface) { struct wlsc_surface *below; if (surface->output == NULL) return; if (surface->link.next == &surface->compositor->surface_list) return; below = container_of(surface->link.next, struct wlsc_surface, link); pixman_region32_union_rect(&below->damage, &below->damage, surface->x, surface->y, surface->width, surface->height); wlsc_compositor_schedule_repaint(surface->compositor); } WL_EXPORT void wlsc_surface_configure(struct wlsc_surface *surface, int x, int y, int width, int height) { wlsc_surface_damage_below(surface); surface->x = x; surface->y = y; surface->width = width; surface->height = height; wlsc_surface_assign_output(surface); wlsc_surface_damage(surface); pixman_region32_fini(&surface->opaque); if (surface->visual == WLSC_RGB_VISUAL) pixman_region32_init_rect(&surface->opaque, surface->x, surface->y, surface->width, surface->height); else pixman_region32_init(&surface->opaque); } WL_EXPORT uint32_t wlsc_compositor_get_time(void) { struct timeval tv; gettimeofday(&tv, NULL); return tv.tv_sec * 1000 + tv.tv_usec / 1000; } WL_EXPORT void wlsc_compositor_repick(struct wlsc_compositor *compositor) { struct wlsc_input_device *device; struct wlsc_surface *surface; int32_t sx, sy; uint32_t time; if (!compositor->focus) return; time = wlsc_compositor_get_time(); wl_list_for_each(device, &compositor->input_device_list, link) { if (device->input_device.grab) continue; surface = pick_surface(&device->input_device, &sx, &sy); wl_input_device_set_pointer_focus(&device->input_device, &surface->surface, time, device->input_device.x, device->input_device.y, sx, sy); } } static void destroy_surface(struct wl_resource *resource) { struct wlsc_surface *surface = container_of(resource, struct wlsc_surface, surface.resource); struct wlsc_compositor *compositor = surface->compositor; wlsc_surface_damage_below(surface); wl_list_remove(&surface->link); wlsc_compositor_repick(compositor); if (surface->saved_texture == 0) glDeleteTextures(1, &surface->texture); else glDeleteTextures(1, &surface->saved_texture); if (surface->buffer) wl_list_remove(&surface->buffer_destroy_listener.link); if (surface->image != EGL_NO_IMAGE_KHR) compositor->destroy_image(compositor->display, surface->image); wl_list_remove(&surface->buffer_link); free(surface); } static void wlsc_buffer_attach(struct wl_buffer *buffer, struct wl_surface *surface) { struct wlsc_surface *es = (struct wlsc_surface *) surface; struct wlsc_compositor *ec = es->compositor; struct wl_list *surfaces_attached_to; if (es->saved_texture != 0) es->texture = es->saved_texture; glBindTexture(GL_TEXTURE_2D, es->texture); if (wl_buffer_is_shm(buffer)) { /* Unbind any EGLImage texture that may be bound, so we don't * overwrite it.*/ glTexImage2D(GL_TEXTURE_2D, 0, GL_BGRA_EXT, 0, 0, 0, GL_BGRA_EXT, GL_UNSIGNED_BYTE, NULL); es->pitch = wl_shm_buffer_get_stride(buffer) / 4; glTexImage2D(GL_TEXTURE_2D, 0, GL_BGRA_EXT, es->pitch, buffer->height, 0, GL_BGRA_EXT, GL_UNSIGNED_BYTE, wl_shm_buffer_get_data(buffer)); switch (wl_shm_buffer_get_format(buffer)) { case WL_SHM_FORMAT_ARGB32: es->visual = WLSC_ARGB_VISUAL; break; case WL_SHM_FORMAT_PREMULTIPLIED_ARGB32: es->visual = WLSC_PREMUL_ARGB_VISUAL; break; case WL_SHM_FORMAT_XRGB32: es->visual = WLSC_RGB_VISUAL; break; } surfaces_attached_to = buffer->user_data; wl_list_remove(&es->buffer_link); wl_list_insert(surfaces_attached_to, &es->buffer_link); } else { if (es->image != EGL_NO_IMAGE_KHR) ec->destroy_image(ec->display, es->image); es->image = ec->create_image(ec->display, NULL, EGL_WAYLAND_BUFFER_WL, buffer, NULL); ec->image_target_texture_2d(GL_TEXTURE_2D, es->image); /* FIXME: we need to get the visual from the wl_buffer */ es->visual = WLSC_PREMUL_ARGB_VISUAL; es->pitch = es->width; } } static int texture_region(struct wlsc_surface *es, pixman_region32_t *region) { struct wlsc_compositor *ec = es->compositor; GLfloat *v, inv_width, inv_height; pixman_box32_t *rectangles; unsigned int *p; int i, n; rectangles = pixman_region32_rectangles(region, &n); v = wl_array_add(&ec->vertices, n * 16 * sizeof *v); p = wl_array_add(&ec->indices, n * 6 * sizeof *p); inv_width = 1.0 / es->pitch; inv_height = 1.0 / es->height; for (i = 0; i < n; i++, v += 16, p += 6) { v[ 0] = rectangles[i].x1; v[ 1] = rectangles[i].y1; v[ 2] = (GLfloat) (rectangles[i].x1 - es->x) * inv_width; v[ 3] = (GLfloat) (rectangles[i].y1 - es->y) * inv_height; v[ 4] = rectangles[i].x1; v[ 5] = rectangles[i].y2; v[ 6] = v[ 2]; v[ 7] = (GLfloat) (rectangles[i].y2 - es->y) * inv_height; v[ 8] = rectangles[i].x2; v[ 9] = rectangles[i].y1; v[10] = (GLfloat) (rectangles[i].x2 - es->x) * inv_width; v[11] = v[ 3]; v[12] = rectangles[i].x2; v[13] = rectangles[i].y2; v[14] = v[10]; v[15] = v[ 7]; p[0] = i * 4 + 0; p[1] = i * 4 + 1; p[2] = i * 4 + 2; p[3] = i * 4 + 2; p[4] = i * 4 + 1; p[5] = i * 4 + 3; } return n; } static void transform_vertex(struct wlsc_surface *surface, GLfloat x, GLfloat y, GLfloat u, GLfloat v, GLfloat *r) { struct wlsc_vector t; t.f[0] = x; t.f[1] = y; t.f[2] = 0.0; t.f[3] = 1.0; wlsc_matrix_transform(&surface->transform->matrix, &t); r[ 0] = t.f[0]; r[ 1] = t.f[1]; r[ 2] = u; r[ 3] = v; } static int texture_transformed_surface(struct wlsc_surface *es) { struct wlsc_compositor *ec = es->compositor; GLfloat *v; unsigned int *p; v = wl_array_add(&ec->vertices, 16 * sizeof *v); p = wl_array_add(&ec->indices, 6 * sizeof *p); transform_vertex(es, es->x, es->y, 0.0, 0.0, &v[0]); transform_vertex(es, es->x, es->y + es->height, 0.0, 1.0, &v[4]); transform_vertex(es, es->x + es->width, es->y, 1.0, 0.0, &v[8]); transform_vertex(es, es->x + es->width, es->y + es->height, 1.0, 1.0, &v[12]); p[0] = 0; p[1] = 1; p[2] = 2; p[3] = 2; p[4] = 1; p[5] = 3; return 1; } static void wlsc_surface_draw(struct wlsc_surface *es, struct wlsc_output *output, pixman_region32_t *clip) { struct wlsc_compositor *ec = es->compositor; GLfloat *v; pixman_region32_t repaint; GLint filter; int n; pixman_region32_init_rect(&repaint, es->x, es->y, es->width, es->height); pixman_region32_intersect(&repaint, &repaint, clip); if (!pixman_region32_not_empty(&repaint)) return; switch (es->visual) { case WLSC_ARGB_VISUAL: glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glEnable(GL_BLEND); break; case WLSC_PREMUL_ARGB_VISUAL: glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA); glEnable(GL_BLEND); break; case WLSC_RGB_VISUAL: glDisable(GL_BLEND); break; default: fprintf(stderr, "bogus visual\n"); break; } if (es->alpha != ec->current_alpha) { glUniform1f(ec->texture_shader.alpha_uniform, es->alpha / 255.0); ec->current_alpha = es->alpha; } if (es->transform == NULL) { filter = GL_NEAREST; n = texture_region(es, &repaint); } else { filter = GL_LINEAR; n = texture_transformed_surface(es); } glBindTexture(GL_TEXTURE_2D, es->texture); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filter); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filter); v = ec->vertices.data; glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 4 * sizeof *v, &v[0]); glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 4 * sizeof *v, &v[2]); glEnableVertexAttribArray(0); glEnableVertexAttribArray(1); glDrawElements(GL_TRIANGLES, n * 6, GL_UNSIGNED_INT, ec->indices.data); ec->vertices.size = 0; ec->indices.size = 0; pixman_region32_fini(&repaint); } static void wlsc_surface_raise(struct wlsc_surface *surface) { struct wlsc_compositor *compositor = surface->compositor; wl_list_remove(&surface->link); wl_list_insert(&compositor->surface_list, &surface->link); wlsc_compositor_repick(compositor); wlsc_surface_damage(surface); } WL_EXPORT void wlsc_compositor_damage_all(struct wlsc_compositor *compositor) { struct wlsc_output *output; wl_list_for_each(output, &compositor->output_list, link) wlsc_output_damage(output); } static inline void wlsc_buffer_post_release(struct wl_buffer *buffer) { if (--buffer->busy_count > 0) return; assert(buffer->resource.client != NULL); wl_resource_queue_event(&buffer->resource, WL_BUFFER_RELEASE); } WL_EXPORT void wlsc_output_damage(struct wlsc_output *output) { struct wlsc_compositor *compositor = output->compositor; struct wlsc_surface *es; if (wl_list_empty(&compositor->surface_list)) return; es = container_of(compositor->surface_list.next, struct wlsc_surface, link); pixman_region32_union(&es->damage, &es->damage, &output->region); wlsc_compositor_schedule_repaint(compositor); } static void fade_frame(struct wlsc_animation *animation, struct wlsc_output *output, uint32_t msecs) { struct wlsc_compositor *compositor = container_of(animation, struct wlsc_compositor, fade.animation); wlsc_spring_update(&compositor->fade.spring, msecs); if (wlsc_spring_done(&compositor->fade.spring)) { compositor->fade.spring.current = compositor->fade.spring.target; wl_list_remove(&animation->link); wl_list_init(&animation->link); if (compositor->fade.spring.current > 0.999) { compositor->state = WLSC_COMPOSITOR_SLEEPING; compositor->shell->lock(compositor->shell); } } wlsc_output_damage(output); } static void fade_output(struct wlsc_output *output, GLfloat tint, pixman_region32_t *region) { struct wlsc_compositor *compositor = output->compositor; struct wlsc_surface surface; GLfloat color[4] = { 0.0, 0.0, 0.0, tint }; surface.compositor = compositor; surface.x = output->x; surface.y = output->y; surface.pitch = output->current->width; surface.width = output->current->width; surface.height = output->current->height; surface.texture = GL_NONE; surface.transform = NULL; surface.alpha = compositor->current_alpha; if (tint <= 1.0) surface.visual = WLSC_PREMUL_ARGB_VISUAL; else surface.visual = WLSC_RGB_VISUAL; glUseProgram(compositor->solid_shader.program); glUniformMatrix4fv(compositor->solid_shader.proj_uniform, 1, GL_FALSE, output->matrix.d); glUniform4fv(compositor->solid_shader.color_uniform, 1, color); wlsc_surface_draw(&surface, output, region); } static void wlsc_output_set_cursor(struct wlsc_output *output, struct wl_input_device *dev, int force_sw) { struct wlsc_compositor *ec = output->compositor; struct wlsc_input_device *device = (struct wlsc_input_device *) dev; pixman_region32_t cursor_region; int use_hardware_cursor = 1, prior_was_hardware; if (device->sprite == NULL) return; pixman_region32_init_rect(&cursor_region, device->sprite->x, device->sprite->y, device->sprite->width, device->sprite->height); pixman_region32_intersect(&cursor_region, &cursor_region, &output->region); if (!pixman_region32_not_empty(&cursor_region)) { output->set_hardware_cursor(output, NULL); goto out; } prior_was_hardware = wl_list_empty(&device->sprite->link); if (force_sw || output->set_hardware_cursor(output, device) < 0) { if (prior_was_hardware) { wlsc_surface_damage(device->sprite); output->set_hardware_cursor(output, NULL); } use_hardware_cursor = 0; } else if (!prior_was_hardware) { wlsc_surface_damage_below(device->sprite); } /* Remove always to be on top. */ wl_list_remove(&device->sprite->link); if (!use_hardware_cursor && ec->focus) { wl_list_insert(&ec->surface_list, &device->sprite->link); device->sprite->output = output; } else { wl_list_init(&device->sprite->link); device->sprite->output = NULL; } out: pixman_region32_fini(&cursor_region); } static int setup_scanout_surface(struct wlsc_output *output, struct wlsc_surface *es) { if (es->visual != WLSC_RGB_VISUAL || output->prepare_scanout_surface(output, es) != 0) return -1; /* assert output->pending_scanout_buffer == NULL */ output->pending_scanout_buffer = es->buffer; output->pending_scanout_buffer->busy_count++; wl_list_insert(output->pending_scanout_buffer->resource.destroy_listener_list.prev, &output->pending_scanout_buffer_destroy_listener.link); return 0; } static void wlsc_output_repaint(struct wlsc_output *output) { struct wlsc_compositor *ec = output->compositor; struct wlsc_surface *es; pixman_region32_t opaque, new_damage, total_damage, repaint; output->prepare_render(output); glViewport(0, 0, output->current->width, output->current->height); glUseProgram(ec->texture_shader.program); glUniformMatrix4fv(ec->texture_shader.proj_uniform, 1, GL_FALSE, output->matrix.d); glUniform1i(ec->texture_shader.tex_uniform, 0); wlsc_output_set_cursor(output, ec->input_device, ec->fade.spring.current >= 0.001); pixman_region32_init(&new_damage); pixman_region32_init(&opaque); wl_list_for_each(es, &ec->surface_list, link) { pixman_region32_subtract(&es->damage, &es->damage, &opaque); pixman_region32_union(&new_damage, &new_damage, &es->damage); pixman_region32_union(&opaque, &opaque, &es->opaque); } pixman_region32_init(&total_damage); pixman_region32_union(&total_damage, &new_damage, &output->previous_damage); pixman_region32_intersect(&output->previous_damage, &new_damage, &output->region); pixman_region32_fini(&opaque); pixman_region32_fini(&new_damage); es = container_of(ec->surface_list.next, struct wlsc_surface, link); if (setup_scanout_surface(output, es) == 0) /* We're drawing nothing, just let the damage accumulate */ return; if (es->fullscreen_output == output) { if (es->width < output->current->width || es->height < output->current->height) glClear(GL_COLOR_BUFFER_BIT); wlsc_surface_draw(es, output, &total_damage); } else { wl_list_for_each(es, &ec->surface_list, link) { pixman_region32_copy(&es->damage, &total_damage); pixman_region32_subtract(&total_damage, &total_damage, &es->opaque); } wl_list_for_each_reverse(es, &ec->surface_list, link) { pixman_region32_init(&repaint); pixman_region32_intersect(&repaint, &output->region, &es->damage); wlsc_surface_draw(es, output, &repaint); pixman_region32_subtract(&es->damage, &es->damage, &output->region); } } if (ec->fade.spring.current > 0.001) fade_output(output, ec->fade.spring.current, &total_damage); } struct wlsc_frame_callback { struct wl_resource resource; struct wl_list link; }; static void repaint(void *data, int msecs) { struct wlsc_output *output = data; struct wlsc_compositor *compositor = output->compositor; struct wlsc_animation *animation, *next; struct wlsc_frame_callback *cb, *cnext; wlsc_output_repaint(output); output->repaint_needed = 0; output->repaint_scheduled = 1; output->present(output); wl_list_for_each_safe(cb, cnext, &output->frame_callback_list, link) { wl_resource_post_event(&cb->resource, WL_CALLBACK_DONE, msecs); wl_resource_destroy(&cb->resource, 0); } wl_list_for_each_safe(animation, next, &compositor->animation_list, link) animation->frame(animation, output, msecs); } static void idle_repaint(void *data) { repaint(data, wlsc_compositor_get_time()); } WL_EXPORT void wlsc_output_finish_frame(struct wlsc_output *output, int msecs) { if (output->scanout_buffer) { wlsc_buffer_post_release(output->scanout_buffer); wl_list_remove(&output->scanout_buffer_destroy_listener.link); output->scanout_buffer = NULL; } if (output->pending_scanout_buffer) { output->scanout_buffer = output->pending_scanout_buffer; wl_list_remove(&output->pending_scanout_buffer_destroy_listener.link); wl_list_insert(output->scanout_buffer->resource.destroy_listener_list.prev, &output->scanout_buffer_destroy_listener.link); output->pending_scanout_buffer = NULL; } if (output->repaint_needed) repaint(output, msecs); else output->repaint_scheduled = 0; } WL_EXPORT void wlsc_compositor_schedule_repaint(struct wlsc_compositor *compositor) { struct wlsc_output *output; struct wl_event_loop *loop; if (compositor->state == WLSC_COMPOSITOR_SLEEPING) return; loop = wl_display_get_event_loop(compositor->wl_display); wl_list_for_each(output, &compositor->output_list, link) { output->repaint_needed = 1; if (output->repaint_scheduled) continue; wl_event_loop_add_idle(loop, idle_repaint, output); output->repaint_scheduled = 1; } } WL_EXPORT void wlsc_compositor_fade(struct wlsc_compositor *compositor, float tint) { int done; done = wlsc_spring_done(&compositor->fade.spring); compositor->fade.spring.target = tint; if (wlsc_spring_done(&compositor->fade.spring)) return; if (done) compositor->fade.spring.timestamp = wlsc_compositor_get_time(); wlsc_compositor_damage_all(compositor); if (wl_list_empty(&compositor->fade.animation.link)) wl_list_insert(compositor->animation_list.prev, &compositor->fade.animation.link); } static void surface_destroy(struct wl_client *client, struct wl_resource *resource) { wl_resource_destroy(resource, wlsc_compositor_get_time()); } WL_EXPORT void wlsc_surface_assign_output(struct wlsc_surface *es) { struct wlsc_compositor *ec = es->compositor; struct wlsc_output *output, *new_output; pixman_region32_t region; uint32_t max, area; pixman_box32_t *e; new_output = NULL; max = 0; wl_list_for_each(output, &ec->output_list, link) { pixman_region32_init_rect(®ion, es->x, es->y, es->width, es->height); pixman_region32_intersect(®ion, ®ion, &output->region); e = pixman_region32_extents(®ion); area = (e->x2 - e->x1) * (e->y2 - e->y1); if (area >= max) { new_output = output; max = area; } } es->output = new_output; if (!wl_list_empty(&es->frame_callback_list)) { wl_list_insert_list(new_output->frame_callback_list.prev, &es->frame_callback_list); wl_list_init(&es->frame_callback_list); } } static void surface_attach(struct wl_client *client, struct wl_resource *resource, struct wl_resource *buffer_resource, int32_t x, int32_t y) { struct wlsc_surface *es = resource->data; struct wlsc_shell *shell = es->compositor->shell; struct wl_buffer *buffer = buffer_resource->data; if (es->buffer) { wlsc_buffer_post_release(es->buffer); wl_list_remove(&es->buffer_destroy_listener.link); } buffer->busy_count++; es->buffer = buffer; wl_list_insert(es->buffer->resource.destroy_listener_list.prev, &es->buffer_destroy_listener.link); if (es->visual == WLSC_NONE_VISUAL) { shell->map(shell, es, buffer->width, buffer->height); } else if (x != 0 || y != 0 || es->width != buffer->width || es->height != buffer->height) { shell->configure(shell, es, es->x + x, es->y + y, buffer->width, buffer->height); } wlsc_buffer_attach(buffer, &es->surface); } static void surface_damage(struct wl_client *client, struct wl_resource *resource, int32_t x, int32_t y, int32_t width, int32_t height) { struct wlsc_surface *es = resource->data; wlsc_surface_damage_rectangle(es, x, y, width, height); } static void destroy_frame_callback(struct wl_resource *resource) { struct wlsc_frame_callback *cb = resource->data; wl_list_remove(&cb->link); free(cb); } static void surface_frame(struct wl_client *client, struct wl_resource *resource, uint32_t callback) { struct wlsc_frame_callback *cb; struct wlsc_surface *es = resource->data; cb = malloc(sizeof *cb); if (cb == NULL) { wl_resource_post_no_memory(resource); return; } cb->resource.object.interface = &wl_callback_interface; cb->resource.object.id = callback; cb->resource.destroy = destroy_frame_callback; cb->resource.client = client; cb->resource.data = cb; wl_client_add_resource(client, &cb->resource); if (es->output) { wl_list_insert(es->output->frame_callback_list.prev, &cb->link); } else { wl_list_insert(es->frame_callback_list.prev, &cb->link); } } const static struct wl_surface_interface surface_interface = { surface_destroy, surface_attach, surface_damage, surface_frame }; static void compositor_create_surface(struct wl_client *client, struct wl_resource *resource, uint32_t id) { struct wlsc_compositor *ec = resource->data; struct wlsc_surface *surface; surface = wlsc_surface_create(ec, 0, 0, 0, 0); if (surface == NULL) { wl_resource_post_no_memory(resource); return; } surface->surface.resource.destroy = destroy_surface; surface->surface.resource.object.id = id; surface->surface.resource.object.interface = &wl_surface_interface; surface->surface.resource.object.implementation = (void (**)(void)) &surface_interface; surface->surface.resource.data = surface; wl_client_add_resource(client, &surface->surface.resource); } const static struct wl_compositor_interface compositor_interface = { compositor_create_surface, }; static void wlsc_surface_transform(struct wlsc_surface *surface, int32_t x, int32_t y, int32_t *sx, int32_t *sy) { *sx = x - surface->x; *sy = y - surface->y; } static struct wlsc_surface * wlsc_compositor_pick_surface(struct wlsc_compositor *compositor, int32_t x, int32_t y, int32_t *sx, int32_t *sy) { struct wlsc_surface *surface; wl_list_for_each(surface, &compositor->surface_list, link) { if (surface->surface.resource.client == NULL) continue; wlsc_surface_transform(surface, x, y, sx, sy); if (0 <= *sx && *sx < surface->width && 0 <= *sy && *sy < surface->height) return surface; } return NULL; } WL_EXPORT struct wlsc_surface * pick_surface(struct wl_input_device *device, int32_t *sx, int32_t *sy) { struct wlsc_input_device *wd = (struct wlsc_input_device *) device; return wlsc_compositor_pick_surface(wd->compositor, device->x, device->y, sx, sy); } static void implicit_grab_motion(struct wl_grab *grab, uint32_t time, int32_t x, int32_t y) { struct wlsc_input_device *device = (struct wlsc_input_device *) grab->input_device; struct wlsc_surface *es = (struct wlsc_surface *) device->input_device.pointer_focus; int32_t sx, sy; struct wl_resource *resource; resource = grab->input_device->pointer_focus_resource; if (resource) { wlsc_surface_transform(es, x, y, &sx, &sy); wl_resource_post_event(resource, WL_INPUT_DEVICE_MOTION, time, x, y, sx, sy); } } static void implicit_grab_button(struct wl_grab *grab, uint32_t time, int32_t button, int32_t state) { struct wl_resource *resource; resource = grab->input_device->pointer_focus_resource; if (resource) wl_resource_post_event(resource, WL_INPUT_DEVICE_BUTTON, time, button, state); } static void implicit_grab_end(struct wl_grab *grab, uint32_t time) { } static const struct wl_grab_interface implicit_grab_interface = { implicit_grab_motion, implicit_grab_button, implicit_grab_end }; WL_EXPORT void wlsc_compositor_wake(struct wlsc_compositor *compositor) { compositor->state = WLSC_COMPOSITOR_ACTIVE; wlsc_compositor_fade(compositor, 0.0); wl_event_source_timer_update(compositor->idle_source, compositor->idle_time * 1000); } WL_EXPORT void wlsc_compositor_activity(struct wlsc_compositor *compositor) { if (compositor->state == WLSC_COMPOSITOR_ACTIVE) { wlsc_compositor_wake(compositor); } else { compositor->shell->unlock(compositor->shell); } } static void wlsc_compositor_idle_inhibit(struct wlsc_compositor *compositor) { wlsc_compositor_activity(compositor); compositor->idle_inhibit++; } static void wlsc_compositor_idle_release(struct wlsc_compositor *compositor) { compositor->idle_inhibit--; wlsc_compositor_activity(compositor); } static int idle_handler(void *data) { struct wlsc_compositor *compositor = data; if (compositor->idle_inhibit) return 1; wlsc_compositor_fade(compositor, 1.0); return 1; } WL_EXPORT void notify_motion(struct wl_input_device *device, uint32_t time, int x, int y) { struct wlsc_surface *es; struct wlsc_output *output; const struct wl_grab_interface *interface; struct wlsc_input_device *wd = (struct wlsc_input_device *) device; struct wlsc_compositor *ec = wd->compositor; int32_t sx, sy; int x_valid = 0, y_valid = 0; int min_x = INT_MAX, min_y = INT_MAX, max_x = INT_MIN, max_y = INT_MIN; wlsc_compositor_activity(ec); wl_list_for_each(output, &ec->output_list, link) { if (output->x <= x && x <= output->x + output->current->width) x_valid = 1; if (output->y <= y && y <= output->y + output->current->height) y_valid = 1; /* FIXME: calculate this only on output addition/deletion */ if (output->x < min_x) min_x = output->x; if (output->y < min_y) min_y = output->y; if (output->x + output->current->width > max_x) max_x = output->x + output->current->width; if (output->y + output->current->height > max_y) max_y = output->y + output->current->height; } if (!x_valid) { if (x < min_x) x = min_x; else if (x >= max_x) x = max_x; } if (!y_valid) { if (y < min_y) y = min_y; else if (y >= max_y) y = max_y; } device->x = x; device->y = y; if (device->grab) { interface = device->grab->interface; interface->motion(device->grab, time, x, y); } else { es = pick_surface(device, &sx, &sy); wl_input_device_set_pointer_focus(device, &es->surface, time, x, y, sx, sy); if (device->pointer_focus_resource) wl_resource_post_event(device->pointer_focus_resource, WL_INPUT_DEVICE_MOTION, time, x, y, sx, sy); } if (wd->sprite) { wlsc_surface_damage_below(wd->sprite); wd->sprite->x = device->x - wd->hotspot_x; wd->sprite->y = device->y - wd->hotspot_y; wlsc_surface_damage(wd->sprite); } } WL_EXPORT void wlsc_surface_activate(struct wlsc_surface *surface, struct wlsc_input_device *device, uint32_t time) { wlsc_surface_raise(surface); wl_input_device_set_keyboard_focus(&device->input_device, &surface->surface, time); wlsc_data_device_set_keyboard_focus(device); } WL_EXPORT void notify_button(struct wl_input_device *device, uint32_t time, int32_t button, int32_t state) { struct wlsc_input_device *wd = (struct wlsc_input_device *) device; struct wlsc_compositor *compositor = wd->compositor; struct wlsc_surface *surface = (struct wlsc_surface *) device->pointer_focus; int32_t sx, sy; if (state) wlsc_compositor_idle_inhibit(compositor); else wlsc_compositor_idle_release(compositor); wlsc_compositor_run_binding(compositor, wd, time, 0, button, state); if (state && surface && device->grab == NULL) { wl_input_device_start_grab(device, &device->implicit_grab, button, time); } if (device->grab) device->grab->interface->button(device->grab, time, button, state); if (!state && device->grab && device->grab_button == button) { wl_input_device_end_grab(device, time); surface = pick_surface(device, &sx, &sy); wl_input_device_set_pointer_focus(device, &surface->surface, time, device->x, device->y, sx, sy); } } static void update_modifier_state(struct wlsc_input_device *device, uint32_t key, uint32_t state) { uint32_t modifier; switch (key) { case KEY_LEFTCTRL: case KEY_RIGHTCTRL: modifier = MODIFIER_CTRL; break; case KEY_LEFTALT: case KEY_RIGHTALT: modifier = MODIFIER_ALT; break; case KEY_LEFTMETA: case KEY_RIGHTMETA: modifier = MODIFIER_SUPER; break; default: modifier = 0; break; } if (state) device->modifier_state |= modifier; else device->modifier_state &= ~modifier; } WL_EXPORT void notify_key(struct wl_input_device *device, uint32_t time, uint32_t key, uint32_t state) { struct wlsc_input_device *wd = (struct wlsc_input_device *) device; struct wlsc_compositor *compositor = wd->compositor; uint32_t *k, *end; if (state) wlsc_compositor_idle_inhibit(compositor); else wlsc_compositor_idle_release(compositor); wlsc_compositor_run_binding(compositor, wd, time, key, 0, state); update_modifier_state(wd, key, state); end = device->keys.data + device->keys.size; for (k = device->keys.data; k < end; k++) { if (*k == key) *k = *--end; } device->keys.size = (void *) end - device->keys.data; if (state) { k = wl_array_add(&device->keys, sizeof *k); *k = key; } if (device->keyboard_focus_resource) wl_resource_post_event(device->keyboard_focus_resource, WL_INPUT_DEVICE_KEY, time, key, state); } WL_EXPORT void notify_pointer_focus(struct wl_input_device *device, uint32_t time, struct wlsc_output *output, int32_t x, int32_t y) { struct wlsc_input_device *wd = (struct wlsc_input_device *) device; struct wlsc_compositor *compositor = wd->compositor; struct wlsc_surface *es; int32_t sx, sy; if (output) { device->x = x; device->y = y; es = pick_surface(device, &sx, &sy); wl_input_device_set_pointer_focus(device, &es->surface, time, x, y, sx, sy); compositor->focus = 1; } else { wl_input_device_set_pointer_focus(device, NULL, time, 0, 0, 0, 0); compositor->focus = 0; } } WL_EXPORT void notify_keyboard_focus(struct wl_input_device *device, uint32_t time, struct wlsc_output *output, struct wl_array *keys) { struct wlsc_input_device *wd = (struct wlsc_input_device *) device; struct wlsc_compositor *compositor = wd->compositor; struct wlsc_surface *es; uint32_t *k, *end; if (!wl_list_empty(&compositor->surface_list)) es = container_of(compositor->surface_list.next, struct wlsc_surface, link); else es = NULL; if (output) { wl_array_copy(&wd->input_device.keys, keys); wd->modifier_state = 0; end = device->keys.data + device->keys.size; for (k = device->keys.data; k < end; k++) { wlsc_compositor_idle_inhibit(compositor); update_modifier_state(wd, *k, 1); } if (es && es->surface.resource.client) wl_input_device_set_keyboard_focus(&wd->input_device, &es->surface, time); } else { end = device->keys.data + device->keys.size; for (k = device->keys.data; k < end; k++) wlsc_compositor_idle_release(compositor); wd->modifier_state = 0; wl_input_device_set_keyboard_focus(&wd->input_device, NULL, time); } } /* TODO: share this function with wayland-server.c */ static struct wl_resource * find_resource_for_surface(struct wl_list *list, struct wl_surface *surface) { struct wl_resource *r; if (!surface) return NULL; wl_list_for_each(r, list, link) { if (r->client == surface->resource.client) return r; } return NULL; } static void lose_touch_focus_resource(struct wl_listener *listener, struct wl_resource *resource, uint32_t time) { struct wlsc_input_device *device = container_of(listener, struct wlsc_input_device, touch_focus_resource_listener); device->touch_focus_resource = NULL; } static void lose_touch_focus(struct wl_listener *listener, struct wl_resource *resource, uint32_t time) { struct wlsc_input_device *device = container_of(listener, struct wlsc_input_device, touch_focus_listener); device->touch_focus = NULL; } static void touch_set_focus(struct wlsc_input_device *device, struct wl_surface *surface, uint32_t time) { struct wl_input_device *input_device = &device->input_device; struct wl_resource *resource; if (device->touch_focus == surface) return; if (surface) { resource = find_resource_for_surface(&input_device->resource_list, surface); if (!resource) { fprintf(stderr, "couldn't find resource\n"); return; } device->touch_focus_resource_listener.func = lose_touch_focus_resource; wl_list_insert(resource->destroy_listener_list.prev, &device->touch_focus_resource_listener.link); device->touch_focus_listener.func = lose_touch_focus; wl_list_insert(surface->resource.destroy_listener_list.prev, &device->touch_focus_listener.link); device->touch_focus = surface; device->touch_focus_resource = resource; } else { if (device->touch_focus) wl_list_remove(&device->touch_focus_listener.link); if (device->touch_focus_resource) wl_list_remove(&device->touch_focus_resource_listener.link); device->touch_focus = NULL; device->touch_focus_resource = NULL; } } /** * notify_touch - emulates button touches and notifies surfaces accordingly. * * It assumes always the correct cycle sequence until it gets here: touch_down * → touch_update → ... → touch_update → touch_end. The driver is responsible * for sending along such order. * */ WL_EXPORT void notify_touch(struct wl_input_device *device, uint32_t time, int touch_id, int x, int y, int touch_type) { struct wlsc_input_device *wd = (struct wlsc_input_device *) device; struct wlsc_compositor *ec = wd->compositor; struct wlsc_surface *es; int32_t sx, sy; switch (touch_type) { case WL_INPUT_DEVICE_TOUCH_DOWN: wlsc_compositor_idle_inhibit(ec); wd->num_tp++; /* the first finger down picks the surface, and all further go * to that surface for the remainder of the touch session i.e. * until all touch points are up again. */ if (wd->num_tp == 1) { es = wlsc_compositor_pick_surface(ec, x, y, &sx, &sy); touch_set_focus(wd, &es->surface, time); } else if (wd->touch_focus) { es = (struct wlsc_surface *) wd->touch_focus; wlsc_surface_transform(es, x, y, &sx, &sy); } if (wd->touch_focus_resource && wd->touch_focus) wl_resource_post_event(wd->touch_focus_resource, touch_type, time, wd->touch_focus, touch_id, sx, sy); break; case WL_INPUT_DEVICE_TOUCH_MOTION: es = (struct wlsc_surface *) wd->touch_focus; if (!es) break; wlsc_surface_transform(es, x, y, &sx, &sy); if (wd->touch_focus_resource) wl_resource_post_event(wd->touch_focus_resource, touch_type, time, touch_id, sx, sy); break; case WL_INPUT_DEVICE_TOUCH_UP: wlsc_compositor_idle_release(ec); wd->num_tp--; if (wd->touch_focus_resource) wl_resource_post_event(wd->touch_focus_resource, touch_type, time, touch_id); if (wd->num_tp == 0) touch_set_focus(wd, NULL, time); break; } } static void input_device_attach(struct wl_client *client, struct wl_resource *resource, uint32_t time, struct wl_resource *buffer_resource, int32_t x, int32_t y) { struct wlsc_input_device *device = resource->data; struct wlsc_compositor *compositor = device->compositor; struct wl_buffer *buffer; if (time < device->input_device.pointer_focus_time) return; if (device->input_device.pointer_focus == NULL) return; if (device->input_device.pointer_focus->resource.client != client) return; if (device->sprite) wlsc_surface_damage_below(device->sprite); if (!buffer_resource) { destroy_surface(&device->sprite->surface.resource); device->sprite = NULL; return; } if (!device->sprite) { device->sprite = wlsc_surface_create(compositor, device->input_device.x, device->input_device.y, 32, 32); wl_list_init(&device->sprite->link); } buffer = buffer_resource->data; wlsc_buffer_attach(buffer, &device->sprite->surface); device->hotspot_x = x; device->hotspot_y = y; device->sprite->width = buffer->width; device->sprite->height = buffer->height; device->sprite->x = device->input_device.x - device->hotspot_x; device->sprite->y = device->input_device.y - device->hotspot_y; wlsc_surface_damage(device->sprite); } const static struct wl_input_device_interface input_device_interface = { input_device_attach, }; static void unbind_input_device(struct wl_resource *resource) { wl_list_remove(&resource->link); free(resource); } static void bind_input_device(struct wl_client *client, void *data, uint32_t version, uint32_t id) { struct wl_input_device *device = data; struct wl_resource *resource; resource = wl_client_add_object(client, &wl_input_device_interface, &input_device_interface, id, data); wl_list_insert(&device->resource_list, &resource->link); resource->destroy = unbind_input_device; } WL_EXPORT void wlsc_input_device_init(struct wlsc_input_device *device, struct wlsc_compositor *ec) { wl_input_device_init(&device->input_device); wl_list_init(&device->drag_resource_list); wl_display_add_global(ec->wl_display, &wl_input_device_interface, device, bind_input_device); device->sprite = NULL; device->compositor = ec; device->hotspot_x = 16; device->hotspot_y = 16; device->modifier_state = 0; device->num_tp = 0; device->input_device.implicit_grab.interface = &implicit_grab_interface; wl_list_insert(ec->input_device_list.prev, &device->link); device->selection_data_source = NULL; } static void bind_output(struct wl_client *client, void *data, uint32_t version, uint32_t id) { struct wlsc_output *output = data; struct wlsc_mode *mode; struct wl_resource *resource; resource = wl_client_add_object(client, &wl_output_interface, NULL, id, data); wl_resource_post_event(resource, WL_OUTPUT_GEOMETRY, output->x, output->y, output->mm_width, output->mm_height, output->subpixel, output->make, output->model); wl_list_for_each (mode, &output->mode_list, link) { wl_resource_post_event(resource, WL_OUTPUT_MODE, mode->flags, mode->width, mode->height, mode->refresh); } } static const char vertex_shader[] = "uniform mat4 proj;\n" "attribute vec2 position;\n" "attribute vec2 texcoord;\n" "varying vec2 v_texcoord;\n" "void main()\n" "{\n" " gl_Position = proj * vec4(position, 0.0, 1.0);\n" " v_texcoord = texcoord;\n" "}\n"; static const char texture_fragment_shader[] = "precision mediump float;\n" "varying vec2 v_texcoord;\n" "uniform sampler2D tex;\n" "uniform float alpha;\n" "void main()\n" "{\n" " gl_FragColor = texture2D(tex, v_texcoord)\n;" " gl_FragColor = alpha * gl_FragColor;\n" "}\n"; static const char solid_fragment_shader[] = "precision mediump float;\n" "uniform vec4 color;\n" "void main()\n" "{\n" " gl_FragColor = color\n;" "}\n"; static int compile_shader(GLenum type, const char *source) { GLuint s; char msg[512]; GLint status; s = glCreateShader(type); glShaderSource(s, 1, &source, NULL); glCompileShader(s); glGetShaderiv(s, GL_COMPILE_STATUS, &status); if (!status) { glGetShaderInfoLog(s, sizeof msg, NULL, msg); fprintf(stderr, "shader info: %s\n", msg); return GL_NONE; } return s; } static int wlsc_shader_init(struct wlsc_shader *shader, const char *vertex_source, const char *fragment_source) { char msg[512]; GLint status; shader->vertex_shader = compile_shader(GL_VERTEX_SHADER, vertex_source); shader->fragment_shader = compile_shader(GL_FRAGMENT_SHADER, fragment_source); shader->program = glCreateProgram(); glAttachShader(shader->program, shader->vertex_shader); glAttachShader(shader->program, shader->fragment_shader); glBindAttribLocation(shader->program, 0, "position"); glBindAttribLocation(shader->program, 1, "texcoord"); glLinkProgram(shader->program); glGetProgramiv(shader->program, GL_LINK_STATUS, &status); if (!status) { glGetProgramInfoLog(shader->program, sizeof msg, NULL, msg); fprintf(stderr, "link info: %s\n", msg); return -1; } shader->proj_uniform = glGetUniformLocation(shader->program, "proj"); shader->tex_uniform = glGetUniformLocation(shader->program, "tex"); shader->alpha_uniform = glGetUniformLocation(shader->program, "alpha"); return 0; } static int init_solid_shader(struct wlsc_shader *shader, GLuint vertex_shader, const char *fragment_source) { GLint status; char msg[512]; shader->vertex_shader = vertex_shader; shader->fragment_shader = compile_shader(GL_FRAGMENT_SHADER, fragment_source); shader->program = glCreateProgram(); glAttachShader(shader->program, shader->vertex_shader); glAttachShader(shader->program, shader->fragment_shader); glBindAttribLocation(shader->program, 0, "position"); glBindAttribLocation(shader->program, 1, "texcoord"); glLinkProgram(shader->program); glGetProgramiv(shader->program, GL_LINK_STATUS, &status); if (!status) { glGetProgramInfoLog(shader->program, sizeof msg, NULL, msg); fprintf(stderr, "link info: %s\n", msg); return -1; } shader->proj_uniform = glGetUniformLocation(shader->program, "proj"); shader->color_uniform = glGetUniformLocation(shader->program, "color"); return 0; } WL_EXPORT void wlsc_output_destroy(struct wlsc_output *output) { pixman_region32_fini(&output->region); pixman_region32_fini(&output->previous_damage); } WL_EXPORT void wlsc_output_move(struct wlsc_output *output, int x, int y) { int flip; output->x = x; output->y = y; pixman_region32_init(&output->previous_damage); pixman_region32_init_rect(&output->region, x, y, output->current->width, output->current->height); wlsc_matrix_init(&output->matrix); wlsc_matrix_translate(&output->matrix, -output->x - output->current->width / 2.0, -output->y - output->current->height / 2.0, 0); flip = (output->flags & WL_OUTPUT_FLIPPED) ? -1 : 1; wlsc_matrix_scale(&output->matrix, 2.0 / output->current->width, flip * 2.0 / output->current->height, 1); wlsc_output_damage(output); } WL_EXPORT void wlsc_output_init(struct wlsc_output *output, struct wlsc_compositor *c, int x, int y, int width, int height, uint32_t flags) { output->compositor = c; output->x = x; output->y = y; output->mm_width = width; output->mm_height = height; output->flags = flags; wlsc_output_move(output, x, y); output->scanout_buffer_destroy_listener.func = output_handle_scanout_buffer_destroy; output->pending_scanout_buffer_destroy_listener.func = output_handle_pending_scanout_buffer_destroy; wl_list_init(&output->frame_callback_list); wl_display_add_global(c->wl_display, &wl_output_interface, output, bind_output); } static void shm_buffer_created(struct wl_buffer *buffer) { struct wl_list *surfaces_attached_to; surfaces_attached_to = malloc(sizeof *surfaces_attached_to); if (!surfaces_attached_to) { buffer->user_data = NULL; return; } wl_list_init(surfaces_attached_to); buffer->user_data = surfaces_attached_to; } static void shm_buffer_damaged(struct wl_buffer *buffer, int32_t x, int32_t y, int32_t width, int32_t height) { struct wl_list *surfaces_attached_to = buffer->user_data; struct wlsc_surface *es; GLsizei tex_width = wl_shm_buffer_get_stride(buffer) / 4; wl_list_for_each(es, surfaces_attached_to, buffer_link) { glBindTexture(GL_TEXTURE_2D, es->texture); glTexImage2D(GL_TEXTURE_2D, 0, GL_BGRA_EXT, tex_width, buffer->height, 0, GL_BGRA_EXT, GL_UNSIGNED_BYTE, wl_shm_buffer_get_data(buffer)); /* Hmm, should use glTexSubImage2D() here but GLES2 doesn't * support any unpack attributes except GL_UNPACK_ALIGNMENT. */ } } static void shm_buffer_destroyed(struct wl_buffer *buffer) { struct wl_list *surfaces_attached_to = buffer->user_data; struct wlsc_surface *es, *next; wl_list_for_each_safe(es, next, surfaces_attached_to, buffer_link) { wl_list_remove(&es->buffer_link); wl_list_init(&es->buffer_link); } free(surfaces_attached_to); } const static struct wl_shm_callbacks shm_callbacks = { shm_buffer_created, shm_buffer_damaged, shm_buffer_destroyed }; static void compositor_bind(struct wl_client *client, void *data, uint32_t version, uint32_t id) { struct wlsc_compositor *compositor = data; wl_client_add_object(client, &wl_compositor_interface, &compositor_interface, id, compositor); } WL_EXPORT int wlsc_compositor_init(struct wlsc_compositor *ec, struct wl_display *display) { struct wl_event_loop *loop; const char *extensions; ec->wl_display = display; if (!wl_display_add_global(display, &wl_compositor_interface, ec, compositor_bind)) return -1; ec->shm = wl_shm_init(display, &shm_callbacks); ec->image_target_texture_2d = (void *) eglGetProcAddress("glEGLImageTargetTexture2DOES"); ec->image_target_renderbuffer_storage = (void *) eglGetProcAddress("glEGLImageTargetRenderbufferStorageOES"); ec->create_image = (void *) eglGetProcAddress("eglCreateImageKHR"); ec->destroy_image = (void *) eglGetProcAddress("eglDestroyImageKHR"); ec->bind_display = (void *) eglGetProcAddress("eglBindWaylandDisplayWL"); ec->unbind_display = (void *) eglGetProcAddress("eglUnbindWaylandDisplayWL"); extensions = (const char *) glGetString(GL_EXTENSIONS); if (!strstr(extensions, "GL_EXT_texture_format_BGRA8888")) { fprintf(stderr, "GL_EXT_texture_format_BGRA8888 not available\n"); return -1; } extensions = (const char *) eglQueryString(ec->display, EGL_EXTENSIONS); if (strstr(extensions, "EGL_WL_bind_wayland_display")) ec->has_bind_display = 1; if (ec->has_bind_display) ec->bind_display(ec->display, ec->wl_display); wl_list_init(&ec->surface_list); wl_list_init(&ec->input_device_list); wl_list_init(&ec->output_list); wl_list_init(&ec->binding_list); wl_list_init(&ec->animation_list); wlsc_spring_init(&ec->fade.spring, 30.0, 1.0, 1.0); ec->fade.animation.frame = fade_frame; wl_list_init(&ec->fade.animation.link); screenshooter_create(ec); wlsc_data_device_manager_init(ec); glActiveTexture(GL_TEXTURE0); if (wlsc_shader_init(&ec->texture_shader, vertex_shader, texture_fragment_shader) < 0) return -1; if (init_solid_shader(&ec->solid_shader, ec->texture_shader.vertex_shader, solid_fragment_shader) < 0) return -1; loop = wl_display_get_event_loop(ec->wl_display); ec->idle_source = wl_event_loop_add_timer(loop, idle_handler, ec); wl_event_source_timer_update(ec->idle_source, ec->idle_time * 1000); wlsc_compositor_schedule_repaint(ec); return 0; } WL_EXPORT void wlsc_compositor_shutdown(struct wlsc_compositor *ec) { struct wlsc_output *output, *next; /* Destroy all outputs associated with this compositor */ wl_list_for_each_safe(output, next, &ec->output_list, link) output->destroy(output); } static int on_term_signal(int signal_number, void *data) { struct wl_display *display = data; fprintf(stderr, "caught signal %d\n", signal_number); wl_display_terminate(display); return 1; } static void * load_module(const char *name, const char *entrypoint, void **handle) { char path[PATH_MAX]; void *module, *init; if (name[0] != '/') snprintf(path, sizeof path, MODULEDIR "/%s", name); else snprintf(path, sizeof path, "%s", name); module = dlopen(path, RTLD_LAZY); if (!module) { fprintf(stderr, "failed to load module: %s\n", dlerror()); return NULL; } init = dlsym(module, entrypoint); if (!init) { fprintf(stderr, "failed to lookup init function: %s\n", dlerror()); return NULL; } return init; } int main(int argc, char *argv[]) { struct wl_display *display; struct wlsc_compositor *ec; struct wl_event_loop *loop; int o, xserver = 0; void *shell_module, *backend_module; int (*shell_init)(struct wlsc_compositor *ec); struct wlsc_compositor *(*backend_init)(struct wl_display *display, char *options); char *backend = NULL; char *backend_options = ""; char *shell = NULL; char *p; int option_idle_time = 300; static const char opts[] = "B:b:o:S:i:s:x"; static const struct option longopts[ ] = { { "backend", 1, NULL, 'B' }, { "backend-options", 1, NULL, 'o' }, { "socket", 1, NULL, 'S' }, { "idle-time", 1, NULL, 'i' }, { "shell", 1, NULL, 's' }, { "xserver", 0, NULL, 'x' }, { NULL, } }; while (o = getopt_long(argc, argv, opts, longopts, &o), o > 0) { switch (o) { case 'B': backend = optarg; break; case 'o': backend_options = optarg; break; case 'S': option_socket_name = optarg; break; case 'i': option_idle_time = strtol(optarg, &p, 0); if (*p != '\0') { fprintf(stderr, "invalid idle time option: %s\n", optarg); exit(EXIT_FAILURE); } break; case 's': shell = optarg; break; case 'x': xserver = 1; break; } } display = wl_display_create(); loop = wl_display_get_event_loop(display); wl_event_loop_add_signal(loop, SIGTERM, on_term_signal, display); wl_event_loop_add_signal(loop, SIGINT, on_term_signal, display); wl_event_loop_add_signal(loop, SIGQUIT, on_term_signal, display); wl_list_init(&child_process_list); wl_event_loop_add_signal(loop, SIGCHLD, sigchld_handler, NULL); if (!backend) { if (getenv("WAYLAND_DISPLAY")) backend = "wayland-backend.so"; else if (getenv("DISPLAY")) backend = "x11-backend.so"; else if (getenv("OPENWFD")) backend = "openwfd-backend.so"; else backend = "drm-backend.so"; } if (!shell) shell = "desktop-shell.so"; backend_init = load_module(backend, "backend_init", &backend_module); if (!backend_init) exit(EXIT_FAILURE); shell_init = load_module(shell, "shell_init", &shell_module); if (!shell_init) exit(EXIT_FAILURE); ec = backend_init(display, backend_options); if (ec == NULL) { fprintf(stderr, "failed to create compositor\n"); exit(EXIT_FAILURE); } ec->option_idle_time = option_idle_time; ec->idle_time = option_idle_time; if (shell_init(ec) < 0) exit(EXIT_FAILURE); if (xserver) wlsc_xserver_init(ec); if (wl_display_add_socket(display, option_socket_name)) { fprintf(stderr, "failed to add socket: %m\n"); exit(EXIT_FAILURE); } wl_display_run(display); if (xserver) wlsc_xserver_destroy(ec); if (ec->has_bind_display) ec->unbind_display(ec->display, display); ec->destroy(ec); wl_display_destroy(display); return 0; }