#include <assert.h>
#include <stdlib.h>
+
#include <wayland-server.h>
#include "libds/log.h"
#include <stdlib.h>
#include <sys/mman.h>
#include <unistd.h>
+
#include <drm_fourcc.h>
#include <wayland-server.h>
int width, int height, uint32_t format)
{
struct ds_shm_buffer *buffer;
+ int bytes_per_pixel, stride;
buffer = calloc(1, sizeof *buffer);
if (!buffer)
ds_buffer_init(&buffer->base, &shm_buffer_interface, width, height);
// FIXME
- int bytes_per_pixel = 4;
- int stride = width * bytes_per_pixel;
+ bytes_per_pixel = 4;
+ stride = width * bytes_per_pixel;
buffer->size = stride * height;
buffer->shm.fd = allocate_shm_file(buffer->size);
if (buffer->shm.fd < 0) {
return &buffer->base;
}
-static const struct ds_allocator_interface shm_allocator_iface = {
+static const struct ds_allocator_interface shm_allocator_iface =
+{
.destroy = shm_allocator_destroy,
.create_buffer = shm_allocator_create_buffer,
};
#include <assert.h>
#include <stdlib.h>
+
#include <drm_fourcc.h>
#include <wayland-server.h>
-
#include <tbm_bufmgr.h>
#include <tbm_surface.h>
.end_data_ptr_access = tbm_buffer_end_data_ptr_access,
};
-
static void
tbm_allocator_destroy(struct ds_allocator *ds_allocator)
{
return &buffer->base;
}
-static const struct ds_allocator_interface tbm_allocator_iface = {
+static const struct ds_allocator_interface tbm_allocator_iface =
+{
.destroy = tbm_allocator_destroy,
.create_buffer = tbm_allocator_create_buffer,
};
#include <stdlib.h>
+
#include <wayland-server.h>
#include "libds/interfaces/backend.h"
}
void
-ds_backend_init(struct ds_backend *backend, const struct ds_backend_interface *iface)
+ds_backend_init(struct ds_backend *backend,
+ const struct ds_backend_interface *iface)
{
backend->iface = iface;
wl_signal_init(&backend->events.destroy);
#include <stdlib.h>
#include "libds/log.h"
+
#include "tdm.h"
static const struct ds_backend_interface tdm_backend_iface;
+
static void tdm_backend_handle_display_destroy(struct wl_listener *listener,
void *data);
static void tdm_backend_destroy(struct ds_tdm_backend *tdm);
struct ds_tdm_output *output, *tmp_output;
struct ds_tdm_buffer *buffer, *tmp_buffer;
- wl_list_for_each_safe(output, tmp_output, &tdm->outputs, link) {
+ wl_list_for_each_safe(output, tmp_output, &tdm->outputs, link)
ds_output_destroy(&output->base);
- }
- wl_list_for_each_safe(buffer, tmp_buffer, &tdm->buffers, link) {
+ wl_list_for_each_safe(buffer, tmp_buffer, &tdm->buffers, link)
destroy_tdm_buffer(buffer);
- }
wl_list_remove(&tdm->display_destroy.link);
wl_event_source_remove(tdm->tdm_event);
tdm_backend_destroy(tdm);
}
-static const struct ds_backend_interface tdm_backend_iface = {
+static const struct ds_backend_interface tdm_backend_iface =
+{
.start = tdm_backend_iface_start,
.destroy = tdm_backend_iface_destroy,
.get_drm_fd = NULL,
static int
tdm_backend_handle_tdm_event(int fd, uint32_t mask, void *data)
{
- struct ds_tdm_backend *tdm;
+ struct ds_tdm_backend *tdm = data;
- tdm = data;
tdm_display_handle_events(tdm->tdm_display);
return 0;
#include <assert.h>
#include <stdlib.h>
+#include <tbm_surface.h>
+
#include "libds/log.h"
#include "libds/allocator/tbm.h"
+
#include "tdm.h"
-#include <tbm_surface.h>
static const struct ds_output_interface tdm_output_iface;
static bool output_init_modes(struct ds_tdm_output *output);
}
buffer = calloc(1, sizeof *buffer);
- if (!buffer) {
+ if (!buffer)
return NULL;
- }
buffer->surface = surface;
buffer->buffer = ds_buffer_lock(ds_buffer);
return false;
}
- ds_inf("Detected modes:");
+ ds_dbg("Detected modes:");
for (i = 0; i < num_modes; i++) {
tdm_mode = &tdm_modes[i];
output_hwc_commit_handler(tdm_hwc *hwc, unsigned int sequence,
unsigned int tv_sec, unsigned int tv_usec, void *user_data)
{
- struct ds_tdm_output *output;
-
- output = user_data;
+ struct ds_tdm_output *output = user_data;
output_update_front_buffer(output);
#define DS_BACKEND_TDM_H
#include <time.h>
+
#include <tdm.h>
#include "libds/interfaces/backend.h"
#include <assert.h>
#include <stdbool.h>
#include <stdlib.h>
+
#include <wayland-server.h>
#include <wayland-client.h>
-#include "backend.h"
#include "libds/log.h"
#include "libds/output.h"
-
#include "xdg-shell-client-protocol.h"
+#include "backend.h"
+
static const struct ds_backend_interface wl_backend_interface;
static void wl_backend_handle_display_destroy(struct wl_listener *listener,
void *data);
ds_dbg("Destroy wayland backend(%p)", backend);
- wl_list_for_each_safe(output, tmp_output, &backend->outputs, link) {
+ wl_list_for_each_safe(output, tmp_output, &backend->outputs, link)
ds_output_destroy(&output->base);
- }
- wl_list_for_each_safe(buffer, tmp_buffer, &backend->buffers, link) {
+ wl_list_for_each_safe(buffer, tmp_buffer, &backend->buffers, link)
destroy_wl_buffer(buffer);
- }
ds_backend_finish(&backend->base);
wl_backend_destroy(wl_backend);
}
-static const struct ds_backend_interface wl_backend_interface = {
+static const struct ds_backend_interface wl_backend_interface =
+{
.start = NULL,
.destroy = wl_backend_iface_destroy,
.get_drm_fd = NULL,
// TODO
}
-static const struct wl_registry_listener registry_listener = {
+static const struct wl_registry_listener registry_listener =
+{
.global = registry_handle_global,
.global_remove = registry_handle_global_remove,
};
#include <assert.h>
#include <stdlib.h>
+
#include <wayland-client.h>
-#include "backend.h"
#include "libds/log.h"
#include "libds/output.h"
-
#include "xdg-shell-client-protocol.h"
+#include "backend.h"
+
const struct ds_output_interface wl_output_iface;
static const struct xdg_surface_listener wl_output_xdg_surface_listener;
static const struct xdg_toplevel_listener wl_output_xdg_toplevel_listener;
ds_buffer_unlock(buffer->buffer);
}
-static const struct wl_buffer_listener buffer_listener = {
+static const struct wl_buffer_listener buffer_listener =
+{
.release = buffer_handle_release,
};
wl_signal_emit(&output->base.events.frame, &output->base);
}
-static const struct wl_callback_listener frame_listener = {
+static const struct wl_callback_listener frame_listener =
+{
.done = surface_frame_callback
};
#include <assert.h>
#include <stdlib.h>
-#include "buffer.h"
-#include "client_buffer.h"
#include "libds/log.h"
#include "libds/interfaces/buffer.h"
+#include "buffer.h"
+#include "client_buffer.h"
+
static struct wl_array buffer_resource_interfaces = {0};
static void buffer_consider_destroy(struct ds_buffer *buffer);
get_buffer_resource_iface(struct wl_resource *resource);
WL_EXPORT void
-ds_buffer_init(struct ds_buffer *buffer, const struct ds_buffer_interface *iface,
- int width, int height)
+ds_buffer_init(struct ds_buffer *buffer,
+ const struct ds_buffer_interface *iface, int width, int height)
{
buffer->iface = iface;
buffer->width = width;
assert(!buffer->accessing_data_ptr);
if (!buffer->iface->begin_data_ptr_access)
return false;
- if (!buffer->iface->begin_data_ptr_access(buffer, flags, data, format, stride))
+ if (!buffer->iface->begin_data_ptr_access(buffer,
+ flags, data, format, stride))
return false;
buffer->accessing_data_ptr = true;
return true;
#include <wayland-server.h>
-#include "util.h"
#include "libds/buffer.h"
#include "libds/interfaces/buffer.h"
+#include "util.h"
+
struct ds_shm_client_buffer
{
struct ds_buffer base;
#include <assert.h>
#include <stdlib.h>
+
#include <drm_fourcc.h>
+#include "libds/log.h"
+
#include "pixel_format.h"
#include "buffer.h"
-#include "libds/log.h"
#include "client_buffer.h"
static void
struct ds_shm_client_buffer *buffer;
buffer = wl_container_of(listener, buffer, listener.resource_destroy);
-
buffer->resource = NULL;
buffer->shm_buffer = NULL;
wl_list_remove(&buffer->listener.resource_destroy.link);
*data = wl_shm_buffer_get_data(buffer->shm_buffer);
wl_shm_buffer_begin_access(buffer->shm_buffer);
}
- else
+ else {
return false;
+ }
return true;
}
wl_shm_buffer_end_access(buffer->shm_buffer);
}
-static const struct ds_buffer_interface shm_client_buffer_iface = {
+static const struct ds_buffer_interface shm_client_buffer_iface =
+{
.destroy = shm_client_buffer_destroy,
.begin_data_ptr_access = shm_client_buffer_begin_data_ptr_access,
.end_data_ptr_access = shm_client_buffer_end_data_ptr_access,
#include <stdlib.h>
#include "libds/log.h"
+
#include "subcompositor.h"
#include "surface.h"
#include "region.h"
compositor_handle_create_surface(struct wl_client *client,
struct wl_resource *resource, uint32_t id)
{
- struct ds_compositor *compositor = wl_resource_get_user_data(resource);
+ struct ds_compositor *compositor;
struct ds_surface *surface;
+ compositor = wl_resource_get_user_data(resource);
surface = ds_surface_create(client,
wl_resource_get_version(resource), id);
if (!surface) {
ds_region_add(client, wl_resource_get_version(resource), id);
}
-static const struct wl_compositor_interface compositor_impl = {
+static const struct wl_compositor_interface compositor_impl =
+{
.create_surface = compositor_handle_create_surface,
.create_region = compositor_handle_create_region,
};
static void
compositor_handle_display_destroy(struct wl_listener *listener, void *data)
{
- struct ds_compositor *compositor =
- wl_container_of(listener, compositor, display_destroy);
+ struct ds_compositor *compositor;
+
+ compositor = wl_container_of(listener, compositor, display_destroy);
ds_dbg("Destroy compositor(%p)", compositor);
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
+
#include <wayland-server.h>
#include "libds/log.h"
_ds_log(enum ds_log_level level, const char *fmt, ...)
{
va_list args;
+
va_start(args, fmt);
log_callback(level, fmt, args);
va_end(args);
log_stderr(enum ds_log_level level, const char *fmt, va_list args)
{
bool colored_tty = false;
+ unsigned c;
if (level > log_level)
return;
- unsigned c = (level < DS_LOG_LEVEL_LAST) ? level : DS_LOG_LEVEL_LAST - 1;
+ c = (level < DS_LOG_LEVEL_LAST) ? level : DS_LOG_LEVEL_LAST - 1;
colored_tty = colored && isatty(STDERR_FILENO);
if (colored_tty)
log_wl(const char *fmt, va_list args)
{
static char ds_fmt[1024];
- int n = snprintf(ds_fmt, sizeof(ds_fmt), "[wayland] %s", fmt);
+ int n;
+
+ n = snprintf(ds_fmt, sizeof(ds_fmt), "[wayland] %s", fmt);
if (n > 0 && ds_fmt[n - 1] == '\n')
ds_fmt[n - 1] = '\0';
_ds_vlog(DS_INF, ds_fmt, args);
#include <drm_fourcc.h>
+
#include "pixel_format.h"
uint32_t
+// TODO
+
#include "libds-private.h"
#include "presentation-time-protocol.h"
uint32_t psf_flags;
};
-
-
static void presentation_bind(struct wl_client *client, void *data,
uint32_t version, uint32_t id);
static void handle_display_destroy(struct wl_listener *listener, void *data);
surface = ds_surface_from_resource(surface_resource);
}
-static const struct wp_presentation_interface presentation_impl = {
+static const struct wp_presentation_interface presentation_impl =
+{
.destroy = presentation_handle_destroy,
.feedback = presentation_handle_feedback,
};
#include <math.h>
#include <pixman.h>
-#include "region.h"
#include "libds/log.h"
+#include "region.h"
+
static const struct wl_region_interface region_impl;
static void region_handle_resource_destroy(struct wl_resource *resource);
pixman_box32_t *src_rects, *dst_rects;
int nrects, i;
- if (scale_x == 1.0 && scale_y == 1.0) {
+ if (scale_x == 1.0 && scale_y == 1.0)
pixman_region32_copy(dst, src);
- }
src_rects = pixman_region32_rectangles(src, &nrects);
dst_rects = malloc(nrects * sizeof *dst_rects);
pixman_region32_fini(&rect);
}
-static const struct wl_region_interface region_impl = {
+static const struct wl_region_interface region_impl =
+{
.destroy = region_destroy,
.add = region_add,
.subtract = region_subtract,
+#include "libds/log.h"
+
#include "subcompositor.h"
#include "surface.h"
-#include "libds/log.h"
#define SUBCOMPOSITOR_VERSION 1
struct wl_resource *surface_resource,
struct wl_resource *parent_resource)
{
- struct ds_surface *surface = ds_surface_from_resource(surface_resource);
- struct ds_surface *parent = ds_surface_from_resource(parent_resource);
+ struct ds_surface *surface, *parent;
+ surface = ds_surface_from_resource(surface_resource);
+ parent = ds_surface_from_resource(parent_resource);
if (surface == parent) {
ds_inf("ds_surface(%p) cannot be its own parent", surface);
wl_resource_post_error(resource,
wl_resource_get_version(resource), id);
}
-static const struct wl_subcompositor_interface subcompositor_impl = {
+static const struct wl_subcompositor_interface subcompositor_impl =
+{
.destroy = subcompositor_handle_destroy,
.get_subsurface = subcompositor_handle_get_subsurface,
};
#include "libds/log.h"
#include "libds/surface.h"
+
#include "surface-private.h"
static const struct wl_subsurface_interface subsurface_impl;
return subsurface->parent;
}
-static const struct ds_surface_role subsurface_role = {
+static const struct ds_surface_role subsurface_role =
+{
.name = "wl_subsurface",
};
}
}
-static const struct wl_subsurface_interface subsurface_impl = {
+static const struct wl_subsurface_interface subsurface_impl =
+{
.destroy = subsurface_handle_destroy,
.set_position = subsurface_handle_set_position,
.place_above = subsurface_handle_place_above,
#define DS_SURFACE_PRIVATE_H
#include <stdint.h>
+
#include <pixman.h>
#include <wayland-server.h>
#include <assert.h>
#include <stdlib.h>
-#include "surface-private.h"
-#include "region.h"
-#include "util.h"
-
#include "libds/log.h"
#include "libds/surface.h"
+#include "region.h"
+#include "util.h"
+#include "surface-private.h"
+
#define CALLBACK_VERSION 1
static const struct wl_surface_interface surface_impl;
surface_handle_set_input_region(struct wl_client *client,
struct wl_resource *resource, struct wl_resource *region_resource)
{
- struct ds_surface *surface = wl_resource_get_user_data(resource);
+ struct ds_surface *surface;
pixman_region32_t *region;
+ surface = wl_resource_get_user_data(resource);
+
ds_dbg("ds_surface(%p) set input region", surface);
surface->pending.committed |= DS_SURFACE_STATE_INPUT_REGION;
surface_handle_set_buffer_transform(struct wl_client *client,
struct wl_resource *resource, int32_t transform)
{
- struct ds_surface *surface = wl_resource_get_user_data(resource);
+ struct ds_surface *surface;
+
+ surface = wl_resource_get_user_data(resource);
ds_dbg("ds_surface(%p) set buffer transform(%d)", surface, transform);
surface_handle_set_buffer_scale(struct wl_client *client,
struct wl_resource *resource, int32_t scale)
{
- struct ds_surface *surface = wl_resource_get_user_data(resource);
+ struct ds_surface *surface;
+
+ surface = wl_resource_get_user_data(resource);
ds_dbg("ds_surface(%p) set buffer scale(%d)", surface, scale);
struct wl_resource *resource,
int32_t x, int32_t y, int32_t width, int32_t height)
{
- struct ds_surface *surface = wl_resource_get_user_data(resource);
+ struct ds_surface *surface;
+
+ surface = wl_resource_get_user_data(resource);
ds_dbg("ds_surface(%p) damage: x %d y %d width %d height %d",
surface, x, y, width, height);
x, y, width, height);
}
-static const struct wl_surface_interface surface_impl = {
+static const struct wl_surface_interface surface_impl =
+{
.destroy = surface_handle_destroy,
.attach = surface_handle_attach,
.damage = surface_handle_damage,
static void
surface_handle_resource_destroy(struct wl_resource *resource)
{
- struct ds_surface *surface = wl_resource_get_user_data(resource);
+ struct ds_surface *surface;
+
+ surface = wl_resource_get_user_data(resource);
ds_inf("Destroy ds_surface %p (res %p)", surface, surface->resource);
ds_swapchain_create(struct ds_allocator *alloc, int width, int height,
uint32_t format)
{
- struct ds_swapchain *swapchain = NULL;
+ struct ds_swapchain *swapchain;
swapchain = calloc(1, sizeof *swapchain);
if (!swapchain)
#include <stdint.h>
#include <time.h>
-int64_t timespec_to_msec(const struct timespec *a) {
+int64_t
+timespec_to_msec(const struct timespec *a)
+{
return (int64_t)a->tv_sec * 1000 + a->tv_nsec / 1000000;
}
#include <stdint.h>
#include <stdlib.h>
-#include "xdg_shell.h"
#include "libds/log.h"
#include "libds/xdg_shell.h"
+#include "xdg_shell.h"
+
#define XDG_WM_BASE_VERSION 2
#define XDG_SHELL_PING_TIMEOUT 10000
-static void xdg_shell_handle_display_destroy(struct wl_listener *listener, void *data);
+static void xdg_shell_handle_display_destroy(struct wl_listener *listener,
+ void *data);
static void xdg_shell_bind(struct wl_client *wl_client, void *data,
uint32_t verison, uint32_t id);
client->ping_serial = 0;
}
-static const struct xdg_wm_base_interface xdg_shell_impl = {
+static const struct xdg_wm_base_interface xdg_shell_impl =
+{
.destroy = xdg_shell_handle_destroy,
.create_positioner = xdg_shell_handle_create_positioner,
.get_xdg_surface = xdg_shell_handle_get_xdg_surface,
static int
xdg_client_handle_ping_timeout(void *user_data)
{
- struct ds_xdg_client *client;
+ struct ds_xdg_client *client = user_data;
struct ds_xdg_surface *surface;
- client = user_data;
-
wl_list_for_each(surface, &client->surfaces, link)
wl_signal_emit(&surface->events.ping_timeout, surface);
xdg_shell_bind(struct wl_client *wl_client, void *data, uint32_t version,
uint32_t id)
{
- struct ds_xdg_shell *shell;
+ struct ds_xdg_shell *shell = data;
struct ds_xdg_client *client;
- shell = data;
-
client = calloc(1, sizeof *client);
if (client == NULL) {
wl_client_post_no_memory(wl_client);
#include <wayland-server.h>
+#include "libds/output.h"
#include "xdg-shell-server-protocol.h"
#include "surface.h"
-#include "libds/output.h"
enum ds_xdg_surface_role
{
#include <assert.h>
#include <stdlib.h>
-#include "xdg_shell.h"
#include "libds/log.h"
+#include "xdg_shell.h"
+
static const struct xdg_surface_interface xdg_surface_impl;
+
static void xdg_surface_handle_surface_destroy(struct wl_listener *listener,
void *data);
static void xdg_surface_handle_surface_commit(struct wl_listener *listener,
#include "xdg_shell.h"
-const struct ds_surface_role xdg_toplevel_surface_role = {
+static const struct ds_surface_role xdg_toplevel_surface_role =
+{
.name = "xdg_toplevel",
.commit = handle_xdg_surface_commit,
};
create_xdg_toplevel(struct ds_xdg_surface *surface, uint32_t id)
{
if (!ds_surface_set_role(surface->ds_surface, &xdg_toplevel_surface_role,
- surface, surface->resource, XDG_WM_BASE_ERROR_ROLE)) {
+ surface, surface->resource, XDG_WM_BASE_ERROR_ROLE))
return;
- }
if (surface->role != DS_XDG_SURFACE_ROLE_NONE) {
wl_resource_post_error(surface->resource,
struct ds_xdg_surface_configure *configure)
{
struct wl_array states;
+ uint32_t width, height;
configure->toplevel_configure =
malloc(sizeof *configure->toplevel_configure);
// TODO
}
- uint32_t width = surface->toplevel->scheduled.width;
- uint32_t height = surface->toplevel->scheduled.height;
+ width = surface->toplevel->scheduled.width;
+ height = surface->toplevel->scheduled.height;
xdg_toplevel_send_configure(surface->toplevel->resource, width, height,
&states);
wl_signal_emit(&surface->toplevel->events.request_maximize, surface);
}
-static const struct xdg_toplevel_interface xdg_toplevel_impl = {
+static const struct xdg_toplevel_interface xdg_toplevel_impl =
+{
xdg_toplevel_handle_destroy,
xdg_toplevel_handle_set_parent,
xdg_toplevel_handle_set_title,