}
#define TILE_FOREACH(_root, _i) \
- for (_i = tile_leftmost(_root); _i; _i = tile_leftmost(_i->childs_by_node_next) ? : _i->parent)
+ for (_i = tile_leftmost(_root); _i; _i = tile_leftmost(_i->children_by_node_next) ? : _i->parent)
#define TILE_FOREACH_SAFE(_root, _i, _next) \
- for (_i = tile_leftmost(_root); _i && ((_next = tile_leftmost(_i->childs_by_node_next) ? : _i->parent), true); _i = _next)
+ for (_i = tile_leftmost(_root); _i && ((_next = tile_leftmost(_i->children_by_node_next) ? : _i->parent), true); _i = _next)
static void tile_link(grdev_tile *tile, grdev_tile *parent) {
grdev_display *display;
assert(!display || !display->enabled);
- ++parent->node.n_childs;
- LIST_PREPEND(childs_by_node, parent->node.child_list, tile);
+ ++parent->node.n_children;
+ LIST_PREPEND(children_by_node, parent->node.child_list, tile);
tile->parent = parent;
if (display) {
assert(parent->type == GRDEV_TILE_NODE);
assert(parent->display == display);
- assert(parent->node.n_childs > 0);
+ assert(parent->node.n_children > 0);
- --parent->node.n_childs;
- LIST_REMOVE(childs_by_node, parent->node.child_list, tile);
+ --parent->node.n_children;
+ LIST_REMOVE(children_by_node, parent->node.child_list, tile);
tile->parent = NULL;
if (display) {
* we must take care to not leave them around. Therefore, whenever we
* unlink any part of a tree, we also destroy the parent, in case it's
* now stale.
- * Parents are stale if they have no childs and either have no display
+ * Parents are stale if they have no children and either have no display
* or if they are intermediate nodes (i.e, they have a parent).
* This means, you can easily create trees, but you can never partially
* move or destruct them so far. They're always reduced to minimal form
* if you cut them. This might change later, but so far we didn't need
* partial destruction or the ability to move whole trees. */
- if (parent->node.n_childs < 1 && (parent->parent || !parent->display))
+ if (parent->node.n_children < 1 && (parent->parent || !parent->display))
grdev_tile_free(parent);
}
_cleanup_(grdev_tile_freep) grdev_tile *tile = NULL;
int r;
+ assert_return(out, -EINVAL);
assert_return(pipe, -EINVAL);
assert_return(!pipe->tile, -EINVAL);
case GRDEV_TILE_NODE:
assert(!tile->parent);
assert(!tile->display);
- assert(tile->node.n_childs == 0);
+ assert(tile->node.n_children == 0);
break;
}
return display->name;
}
+uint32_t grdev_display_get_width(grdev_display *display) {
+ assert_return(display, 0);
+
+ return display->width;
+}
+
+uint32_t grdev_display_get_height(grdev_display *display) {
+ assert_return(display, 0);
+
+ return display->height;
+}
+
bool grdev_display_is_enabled(grdev_display *display) {
return display && display->enabled;
}
}
}
-const grdev_display_target *grdev_display_next_target(grdev_display *display, const grdev_display_target *prev, uint64_t minage) {
+const grdev_display_target *grdev_display_next_target(grdev_display *display, const grdev_display_target *prev) {
grdev_display_cache *cache;
size_t idx;
assert(cache->pipe->tile->display == display);
assert(display->pipes >= cache);
- idx = (cache - display->pipes) / sizeof(*cache) + 1;
+ idx = cache - display->pipes + 1;
} else {
idx = 0;
}
if (!pipe->running || !pipe->enabled)
continue;
- /* if front-buffer is up-to-date, there's nothing to do */
- if (minage > 0 && pipe->front && pipe->front->age >= minage)
- continue;
-
/* find suitable back-buffer */
- if (!(fb = pipe->back)) {
- if (!pipe->vtable->target || !(fb = pipe->vtable->target(pipe)))
+ if (!pipe->back) {
+ if (!pipe->vtable->target)
+ continue;
+ if (!(fb = pipe->vtable->target(pipe)))
continue;
- }
- /* if back-buffer is up-to-date, schedule flip */
- if (minage > 0 && fb->age >= minage) {
- grdev_display_flip_target(display, target, fb->age);
- continue;
+ assert(fb == pipe->back);
}
- /* we have an out-of-date back-buffer; return for redraw */
- target->fb = fb;
+ target->front = pipe->front;
+ target->back = pipe->back;
+
return target;
}
return NULL;
}
-void grdev_display_flip_target(grdev_display *display, const grdev_display_target *target, uint64_t age) {
+void grdev_display_flip_target(grdev_display *display, const grdev_display_target *target) {
grdev_display_cache *cache;
- size_t i;
assert(display);
assert(!display->modified);
assert(display->enabled);
assert(target);
- assert(target->fb);
cache = container_of(target, grdev_display_cache, target);
assert(cache->pipe);
assert(cache->pipe->tile->display == display);
- /* reset age of all FB on overflow */
- if (age < target->fb->age)
- for (i = 0; i < cache->pipe->max_fbs; ++i)
- if (cache->pipe->fbs[i])
- cache->pipe->fbs[i]->age = 0;
-
- ((grdev_fb*)target->fb)->age = age;
cache->pipe->flip = true;
}
assert(display);
- /* depth-first with childs before parent */
+ /* depth-first with children before parent */
for (tile = tile_leftmost(display->tile);
tile;
- tile = tile_leftmost(tile->childs_by_node_next) ? : tile->parent) {
+ tile = tile_leftmost(tile->children_by_node_next) ? : tile->parent) {
if (tile->type == GRDEV_TILE_LEAF) {
grdev_pipe *p;
} else {
grdev_tile *child, *l;
- /* We're now at a node with all it's childs already
+ /* We're now at a node with all its children already
* computed (depth-first, child before parent). We
* first need to know the size of our tile, then we
* recurse into all leafs and update their cache. */
tile->cache_w = 0;
tile->cache_h = 0;
- LIST_FOREACH(childs_by_node, child, tile->node.child_list) {
+ LIST_FOREACH(children_by_node, child, tile->node.child_list) {
if (child->x + child->cache_w > tile->cache_w)
tile->cache_w = child->x + child->cache_w;
if (child->y + child->cache_h > tile->cache_h)
}
display_cache_targets(display);
+ display->width = display->tile->cache_w;
+ display->height = display->tile->cache_h;
r = 0;
out:
if (r < 0)
- log_debug("grdev: %s/%s: cannot cache pipes: %s",
- display->session->name, display->name, strerror(-r));
+ log_debug_errno(r, "grdev: %s/%s: cannot cache pipes: %m",
+ display->session->name, display->name);
return true;
}
return;
error:
- log_debug("grdev: %s/%s/%s: cannot schedule vsync timer: %s",
- pipe->card->session->name, pipe->card->name, pipe->name, strerror(-r));
+ log_debug_errno(r, "grdev: %s/%s/%s: cannot schedule vsync timer: %m",
+ pipe->card->session->name, pipe->card->name, pipe->name);
}
/*
r = grdev_drm_card_new(&card, session, ud);
if (r < 0) {
- log_debug("grdev: %s: cannot add DRM device for %s: %s",
- session->name, udev_device_get_syspath(ud), strerror(-r));
+ log_debug_errno(r, "grdev: %s: cannot add DRM device for %s: %m",
+ session->name, udev_device_get_syspath(ud));
return;
}
} else if (!display) {
r = grdev_display_new(&display, session, pipe->name);
if (r < 0) {
- log_debug("grdev: %s/%s: cannot create display for pipe %s: %s",
- session->name, card->name, pipe->name, strerror(-r));
+ log_debug_errno(r, "grdev: %s/%s: cannot create display for pipe %s: %m",
+ session->name, card->name, pipe->name);
continue;
}
}