X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?a=blobdiff_plain;f=src%2Flibsystemd-terminal%2Fgrdev.c;h=3b3cf2737bbf59a6538c218cd2627722912037be;hb=a9944163fe5600bce85898dae78cd68442a6ff7c;hp=e34112ee7cb248e923f21b3ff2a20d687a364f77;hpb=f2a15d86ccd0729e1442f40679cd393417e1e177;p=elogind.git

diff --git a/src/libsystemd-terminal/grdev.c b/src/libsystemd-terminal/grdev.c
index e34112ee7..3b3cf2737 100644
--- a/src/libsystemd-terminal/grdev.c
+++ b/src/libsystemd-terminal/grdev.c
@@ -54,10 +54,10 @@ static inline grdev_tile *tile_leftmost(grdev_tile *tile) {
 }
 
 #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;
@@ -73,8 +73,8 @@ static void tile_link(grdev_tile *tile, grdev_tile *parent) {
 
         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) {
@@ -105,10 +105,10 @@ static void tile_unlink(grdev_tile *tile) {
 
         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) {
@@ -127,14 +127,14 @@ static void tile_unlink(grdev_tile *tile) {
          * 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);
 }
 
@@ -158,6 +158,7 @@ int grdev_tile_new_leaf(grdev_tile **out, grdev_pipe *pipe) {
         _cleanup_(grdev_tile_freep) grdev_tile *tile = NULL;
         int r;
 
+        assert_return(out, -EINVAL);
         assert_return(pipe, -EINVAL);
         assert_return(!pipe->tile, -EINVAL);
 
@@ -207,7 +208,7 @@ grdev_tile *grdev_tile_free(grdev_tile *tile) {
         case GRDEV_TILE_NODE:
                 assert(!tile->parent);
                 assert(!tile->display);
-                assert(tile->node.n_childs == 0);
+                assert(tile->node.n_children == 0);
 
                 break;
         }
@@ -300,6 +301,18 @@ const char *grdev_display_get_name(grdev_display *display) {
         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;
 }
@@ -330,7 +343,7 @@ void grdev_display_disable(grdev_display *display) {
         }
 }
 
-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;
 
@@ -345,7 +358,7 @@ const grdev_display_target *grdev_display_next_target(grdev_display *display, co
                 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;
         }
@@ -361,52 +374,38 @@ const grdev_display_target *grdev_display_next_target(grdev_display *display, co
                 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;
 }
 
@@ -472,10 +471,10 @@ static void display_cache_targets(grdev_display *display) {
 
         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;
 
@@ -504,7 +503,7 @@ static void display_cache_targets(grdev_display *display) {
                 } 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. */
@@ -512,7 +511,7 @@ static void display_cache_targets(grdev_display *display) {
                         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)
@@ -571,13 +570,15 @@ static bool display_cache(grdev_display *display) {
         }
 
         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;
 }
 
@@ -707,7 +708,7 @@ void grdev_pipe_ready(grdev_pipe *pipe, bool running) {
 
         /* grdev_pipe_ready() is used by backends to notify about pipe state
          * changed. If a pipe is ready, it can be fully used by us (available,
-         * enabled and accessable). Backends can disable pipes at any time
+         * enabled and accessible). Backends can disable pipes at any time
          * (like for async revocation), but can only enable them from parent
          * context. Otherwise, we might call user-callbacks recursively. */
 
@@ -771,8 +772,8 @@ void grdev_pipe_schedule(grdev_pipe *pipe, uint64_t frames) {
         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);
 }
 
 /*
@@ -1175,8 +1176,8 @@ void grdev_session_add_drm(grdev_session *session, struct udev_device *ud) {
 
         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;
         }
 
@@ -1268,8 +1269,8 @@ static void session_configure(grdev_session *session) {
                         } 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;
                                 }
                         }