GUAC-236: Split massive display code into more reasonable files.

src/guacenc/Makefile.am

@@ -38,6 +38,11 @@ noinst_HEADERS =   \
 guacenc_SOURCES =           \
     buffer.c                \
     display.c               \
+    display-buffers.c       \
+    display-image-streams.c \
+    display-flatten.c       \
+    display-layers.c        \
+    display-sync.c          \
     encode.c                \
     guacenc.c               \
     image-stream.c          \

src/guacenc/buffer.c

@@ -26,7 +26,6 @@
 #include <cairo/cairo.h>
 
 #include <assert.h>
-#include <stdbool.h>
 #include <stdlib.h>
 
 guacenc_buffer* guacenc_buffer_alloc() {

src/guacenc/display-buffers.c

@@ -0,0 +1,110 @@
+/*
+ * Copyright (C) 2016 Glyptodon, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "config.h"
+#include "display.h"
+#include "buffer.h"
+#include "layer.h"
+#include "log.h"
+
+#include <guacamole/client.h>
+
+#include <stdlib.h>
+
+guacenc_buffer* guacenc_display_get_buffer(guacenc_display* display,
+        int index) {
+
+    /* Transform index to buffer space */
+    int internal_index = -index - 1;
+
+    /* Do not lookup / allocate if index is invalid */
+    if (internal_index < 0 || internal_index > GUACENC_DISPLAY_MAX_BUFFERS) {
+        guacenc_log(GUAC_LOG_WARNING, "Buffer index out of bounds: %i", index);
+        return NULL;
+    }
+
+    /* Lookup buffer, allocating a new buffer if necessary */
+    guacenc_buffer* buffer = display->buffers[internal_index];
+    if (buffer == NULL) {
+
+        /* Attempt to allocate buffer */
+        buffer = guacenc_buffer_alloc();
+        if (buffer == NULL) {
+            guacenc_log(GUAC_LOG_WARNING, "Buffer allocation failed");
+            return NULL;
+        }
+
+        /* All non-layer buffers must autosize */
+        buffer->autosize = true;
+
+        /* Store buffer within display for future retrieval / management */
+        display->buffers[internal_index] = buffer;
+
+    }
+
+    return buffer;
+
+}
+
+int guacenc_display_free_buffer(guacenc_display* display,
+        int index) {
+
+    /* Transform index to buffer space */
+    int internal_index = -index - 1;
+
+    /* Do not lookup / allocate if index is invalid */
+    if (internal_index < 0 || internal_index > GUACENC_DISPLAY_MAX_BUFFERS) {
+        guacenc_log(GUAC_LOG_WARNING, "Buffer index out of bounds: %i", index);
+        return 1;
+    }
+
+    /* Free buffer (if allocated) */
+    guacenc_buffer_free(display->buffers[internal_index]);
+
+    /* Mark buffer as freed */
+    display->buffers[internal_index] = NULL;
+
+    return 0;
+
+}
+
+guacenc_buffer* guacenc_display_get_related_buffer(guacenc_display* display,
+        int index) {
+
+    /* Retrieve underlying buffer of layer if a layer is requested */
+    if (index >= 0) {
+
+        /* Retrieve / allocate layer (if possible */
+        guacenc_layer* layer = guacenc_display_get_layer(display, index);
+        if (layer == NULL)
+            return NULL;
+
+        /* Return underlying buffer */
+        return layer->buffer;
+
+    }
+
+    /* Otherwise retrieve buffer directly */
+    return guacenc_display_get_buffer(display, index);
+
+}
+

src/guacenc/display-flatten.c

@@ -0,0 +1,160 @@
+/*
+ * Copyright (C) 2016 Glyptodon, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "config.h"
+#include "display.h"
+#include "layer.h"
+
+#include <cairo/cairo.h>
+
+#include <stdlib.h>
+#include <string.h>
+
+/**
+ * The Guacamole video encoder display related to the current qsort()
+ * operation. As qsort() does not provide a means of passing arbitrary data to
+ * the comparitor, this value must be set prior to invoking qsort() with
+ * guacenc_display_layer_comparator.
+ */
+guacenc_display* __qsort_display;
+
+/**
+ * Comparator which orders layer pointers such that (1) NULL pointers are last,
+ * (2) layers with the same parent_index are adjacent, and (3) layers with the
+ * same parent_index are ordered by Z.
+ *
+ * @see qsort()
+ */
+static int guacenc_display_layer_comparator(const void* a, const void* b) {
+
+    guacenc_layer* layer_a = *((guacenc_layer**) a);
+    guacenc_layer* layer_b = *((guacenc_layer**) b);
+
+    /* If a is NULL, sort it to bottom */
+    if (layer_a == NULL) {
+
+        /* ... unless b is also NULL, in which case they are equal */
+        if (layer_b == NULL)
+            return 0;
+
+        return 1;
+    }
+
+    /* If b is NULL (and a is not NULL), sort it to bottom */
+    if (layer_b == NULL)
+        return -1;
+
+    /* Order such that the deepest layers are first */
+    int a_depth = guacenc_display_get_depth(__qsort_display, layer_a);
+    int b_depth = guacenc_display_get_depth(__qsort_display, layer_b);
+    if (b_depth != a_depth)
+        return b_depth - a_depth;
+
+    /* Order such that sibling layers are adjacent */
+    if (layer_b->parent_index != layer_a->parent_index)
+        return layer_b->parent_index - layer_a->parent_index;
+
+    /* Order sibling layers according to descending Z */
+    return layer_b->z - layer_a->z;
+
+}
+
+int guacenc_display_flatten(guacenc_display* display) {
+
+    int i;
+    guacenc_layer* render_order[GUACENC_DISPLAY_MAX_LAYERS];
+
+    /* Copy list of layers within display */
+    memcpy(render_order, display->layers, sizeof(render_order));
+
+    /* Sort layers by depth, parent, and Z */
+    __qsort_display = display;
+    qsort(render_order, GUACENC_DISPLAY_MAX_LAYERS, sizeof(guacenc_layer*),
+            guacenc_display_layer_comparator);
+
+    /* Reset layer frame buffers */
+    for (i = 0; i < GUACENC_DISPLAY_MAX_LAYERS; i++) {
+
+        /* Pull current layer, ignoring unallocated layers */
+        guacenc_layer* layer = render_order[i];
+        if (layer == NULL)
+            continue;
+
+        /* Get source buffer and destination frame buffer */
+        guacenc_buffer* buffer = layer->buffer;
+        guacenc_buffer* frame = layer->frame;
+
+        /* Reset frame contents */
+        guacenc_buffer_copy(frame, buffer);
+
+    }
+
+    /* Render each layer, in order */
+    for (i = 0; i < GUACENC_DISPLAY_MAX_LAYERS; i++) {
+
+        /* Pull current layer, ignoring unallocated layers */
+        guacenc_layer* layer = render_order[i];
+        if (layer == NULL)
+            continue;
+
+        /* Skip fully-transparent layers */
+        if (layer->opacity == 0)
+            continue;
+
+        /* Ignore layers without a parent */
+        int parent_index = layer->parent_index;
+        if (parent_index == GUACENC_LAYER_NO_PARENT)
+            continue;
+
+        /* Retrieve parent layer, ignoring layers with invalid parents */
+        guacenc_layer* parent = guacenc_display_get_layer(display, parent_index);
+        if (parent == NULL)
+            continue;
+
+        /* Get source and destination frame buffer */
+        guacenc_buffer* src = layer->frame;
+        guacenc_buffer* dst = parent->frame;
+
+        /* Ignore layers with empty buffers */
+        cairo_surface_t* surface = src->surface;
+        if (surface == NULL)
+            continue;
+
+        /* Ignore if parent has no pixels */
+        cairo_t* cairo = dst->cairo;
+        if (cairo == NULL)
+            continue;
+
+        /* Render buffer to layer */
+        cairo_reset_clip(cairo);
+        cairo_rectangle(cairo, layer->x, layer->y, src->width, src->height);
+        cairo_clip(cairo);
+
+        cairo_set_source_surface(cairo, surface, layer->x, layer->y);
+        cairo_paint_with_alpha(cairo, layer->opacity / 255.0);
+
+    }
+
+    return 0;
+
+}
+

src/guacenc/display-image-streams.c

@@ -0,0 +1,84 @@
+/*
+ * Copyright (C) 2016 Glyptodon, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "config.h"
+#include "display.h"
+#include "image-stream.h"
+#include "log.h"
+
+#include <guacamole/client.h>
+
+#include <stdlib.h>
+
+int guacenc_display_create_image_stream(guacenc_display* display, int index,
+        int mask, int layer_index, const char* mimetype, int x, int y) {
+
+    /* Do not lookup / allocate if index is invalid */
+    if (index < 0 || index > GUACENC_DISPLAY_MAX_STREAMS) {
+        guacenc_log(GUAC_LOG_WARNING, "Stream index out of bounds: %i", index);
+        return 1;
+    }
+
+    /* Free existing stream (if any) */
+    guacenc_image_stream_free(display->image_streams[index]);
+
+    /* Associate new stream */
+    guacenc_image_stream* stream = display->image_streams[index] =
+        guacenc_image_stream_alloc(mask, layer_index, mimetype, x, y);
+
+    /* Return zero only if stream is not NULL */
+    return stream == NULL;
+
+}
+
+guacenc_image_stream* guacenc_display_get_image_stream(
+        guacenc_display* display, int index) {
+
+    /* Do not lookup / allocate if index is invalid */
+    if (index < 0 || index > GUACENC_DISPLAY_MAX_STREAMS) {
+        guacenc_log(GUAC_LOG_WARNING, "Stream index out of bounds: %i", index);
+        return NULL;
+    }
+
+    /* Return existing stream (if any) */
+    return display->image_streams[index];
+
+}
+
+int guacenc_display_free_image_stream(guacenc_display* display, int index) {
+
+    /* Do not lookup / allocate if index is invalid */
+    if (index < 0 || index > GUACENC_DISPLAY_MAX_STREAMS) {
+        guacenc_log(GUAC_LOG_WARNING, "Stream index out of bounds: %i", index);
+        return 1;
+    }
+
+    /* Free stream (if allocated) */
+    guacenc_image_stream_free(display->image_streams[index]);
+
+    /* Mark stream as freed */
+    display->image_streams[index] = NULL;
+
+    return 0;
+
+}
+

src/guacenc/display-layers.c

@@ -0,0 +1,102 @@
+/*
+ * Copyright (C) 2016 Glyptodon, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "config.h"
+#include "display.h"
+#include "layer.h"
+#include "log.h"
+
+#include <guacamole/client.h>
+
+#include <stdlib.h>
+
+guacenc_layer* guacenc_display_get_layer(guacenc_display* display,
+        int index) {
+
+    /* Do not lookup / allocate if index is invalid */
+    if (index < 0 || index > GUACENC_DISPLAY_MAX_LAYERS) {
+        guacenc_log(GUAC_LOG_WARNING, "Layer index out of bounds: %i", index);
+        return NULL;
+    }
+
+    /* Lookup layer, allocating a new layer if necessary */
+    guacenc_layer* layer = display->layers[index];
+    if (layer == NULL) {
+
+        /* Attempt to allocate layer */
+        layer = guacenc_layer_alloc();
+        if (layer == NULL) {
+            guacenc_log(GUAC_LOG_WARNING, "Layer allocation failed");
+            return NULL;
+        }
+
+        /* The default layer has no parent */
+        if (index == 0)
+            layer->parent_index = GUACENC_LAYER_NO_PARENT;
+
+        /* Store layer within display for future retrieval / management */
+        display->layers[index] = layer;
+
+    }
+
+    return layer;
+
+}
+
+int guacenc_display_get_depth(guacenc_display* display, guacenc_layer* layer) {
+
+    /* Non-existent layers have a depth of 0 */
+    if (layer == NULL)
+        return 0;
+
+    /* Layers with no parent have a depth of 0 */
+    if (layer->parent_index == GUACENC_LAYER_NO_PARENT)
+        return 0;
+
+    /* Retrieve parent layer */
+    guacenc_layer* parent =
+        guacenc_display_get_layer(display, layer->parent_index);
+
+    /* Current layer depth is the depth of the parent + 1 */
+    return guacenc_display_get_depth(display, parent) + 1;
+
+}
+
+int guacenc_display_free_layer(guacenc_display* display,
+        int index) {
+
+    /* Do not lookup / allocate if index is invalid */
+    if (index < 0 || index > GUACENC_DISPLAY_MAX_LAYERS) {
+        guacenc_log(GUAC_LOG_WARNING, "Layer index out of bounds: %i", index);
+        return 1;
+    }
+
+    /* Free layer (if allocated) */
+    guacenc_layer_free(display->layers[index]);
+
+    /* Mark layer as freed */
+    display->layers[index] = NULL;
+
+    return 0;
+
+}
+

src/guacenc/display-sync.c

@@ -0,0 +1,66 @@
+/*
+ * Copyright (C) 2016 Glyptodon, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "config.h"
+#include "display.h"
+#include "layer.h"
+#include "log.h"
+
+#include <cairo/cairo.h>
+#include <guacamole/client.h>
+#include <guacamole/timestamp.h>
+
+#include <assert.h>
+#include <inttypes.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+int guacenc_display_sync(guacenc_display* display, guac_timestamp timestamp) {
+
+    /* Verify timestamp is not decreasing */
+    if (timestamp < display->last_sync) {
+        guacenc_log(GUAC_LOG_WARNING, "Decreasing sync timestamp");
+        return 1;
+    }
+
+    /* Update timestamp of display */
+    display->last_sync = timestamp;
+
+    /* Flatten display to default layer */
+    if (guacenc_display_flatten(display))
+        return 1;
+
+    /* Retrieve default layer (guaranteed to not be NULL) */
+    guacenc_layer* def_layer = guacenc_display_get_layer(display, 0);
+    assert(def_layer != NULL);
+
+    /* STUB: Write frame as PNG */
+    char filename[256];
+    sprintf(filename, "frame-%" PRId64 ".png", timestamp);
+    cairo_surface_t* surface = def_layer->frame->surface;
+    if (surface != NULL)
+        cairo_surface_write_to_png(surface, filename);
+
+    return 0;
+
+}
+

src/guacenc/display.c

@@ -22,371 +22,10 @@
 
 #include "config.h"
 #include "display.h"
-#include "layer.h"
-#include "log.h"
 
 #include <cairo/cairo.h>
-#include <guacamole/client.h>
-#include <guacamole/protocol.h>
-#include <guacamole/timestamp.h>
 
-#include <assert.h>
-#include <inttypes.h>
-#include <stdbool.h>
-#include <stdio.h>
 #include <stdlib.h>
-#include <string.h>
-
-/**
- * The Guacamole video encoder display related to the current qsort()
- * operation. As qsort() does not provide a means of passing arbitrary data to
- * the comparitor, this value must be set prior to invoking qsort() with
- * guacenc_display_layer_comparator.
- */
-guacenc_display* __qsort_display;
-
-/**
- * Comparator which orders layer pointers such that (1) NULL pointers are last,
- * (2) layers with the same parent_index are adjacent, and (3) layers with the
- * same parent_index are ordered by Z.
- *
- * @see qsort()
- */
-static int guacenc_display_layer_comparator(const void* a, const void* b) {
-
-    guacenc_layer* layer_a = *((guacenc_layer**) a);
-    guacenc_layer* layer_b = *((guacenc_layer**) b);
-
-    /* If a is NULL, sort it to bottom */
-    if (layer_a == NULL) {
-
-        /* ... unless b is also NULL, in which case they are equal */
-        if (layer_b == NULL)
-            return 0;
-
-        return 1;
-    }
-
-    /* If b is NULL (and a is not NULL), sort it to bottom */
-    if (layer_b == NULL)
-        return -1;
-
-    /* Order such that the deepest layers are first */
-    int a_depth = guacenc_display_get_depth(__qsort_display, layer_a);
-    int b_depth = guacenc_display_get_depth(__qsort_display, layer_b);
-    if (b_depth != a_depth)
-        return b_depth - a_depth;
-
-    /* Order such that sibling layers are adjacent */
-    if (layer_b->parent_index != layer_a->parent_index)
-        return layer_b->parent_index - layer_a->parent_index;
-
-    /* Order sibling layers according to descending Z */
-    return layer_b->z - layer_a->z;
-
-}
-
-int guacenc_display_sync(guacenc_display* display, guac_timestamp timestamp) {
-
-    /* Verify timestamp is not decreasing */
-    if (timestamp < display->last_sync) {
-        guacenc_log(GUAC_LOG_WARNING, "Decreasing sync timestamp");
-        return 1;
-    }
-
-    /* Update timestamp of display */
-    display->last_sync = timestamp;
-
-    int i;
-    guacenc_layer* render_order[GUACENC_DISPLAY_MAX_LAYERS];
-
-    /* Copy list of layers within display */
-    memcpy(render_order, display->layers, sizeof(render_order));
-
-    /* Sort layers by depth, parent, and Z */
-    __qsort_display = display;
-    qsort(render_order, GUACENC_DISPLAY_MAX_LAYERS, sizeof(guacenc_layer*),
-            guacenc_display_layer_comparator);
-
-    /* Reset layer frame buffers */
-    for (i = 0; i < GUACENC_DISPLAY_MAX_LAYERS; i++) {
-
-        /* Pull current layer, ignoring unallocated layers */
-        guacenc_layer* layer = render_order[i];
-        if (layer == NULL)
-            continue;
-
-        /* Get source buffer and destination frame buffer */
-        guacenc_buffer* buffer = layer->buffer;
-        guacenc_buffer* frame = layer->frame;
-
-        /* Reset frame contents */
-        guacenc_buffer_copy(frame, buffer);
-
-    }
-
-    /* Render each layer, in order */
-    for (i = 0; i < GUACENC_DISPLAY_MAX_LAYERS; i++) {
-
-        /* Pull current layer, ignoring unallocated layers */
-        guacenc_layer* layer = render_order[i];
-        if (layer == NULL)
-            continue;
-
-        /* Skip fully-transparent layers */
-        if (layer->opacity == 0)
-            continue;
-
-        /* Ignore layers without a parent */
-        int parent_index = layer->parent_index;
-        if (parent_index == GUACENC_LAYER_NO_PARENT)
-            continue;
-
-        /* Retrieve parent layer, ignoring layers with invalid parents */
-        guacenc_layer* parent = guacenc_display_get_layer(display, parent_index);
-        if (parent == NULL)
-            continue;
-
-        /* Get source and destination frame buffer */
-        guacenc_buffer* src = layer->frame;
-        guacenc_buffer* dst = parent->frame;
-
-        /* Ignore layers with empty buffers */
-        cairo_surface_t* surface = src->surface;
-        if (surface == NULL)
-            continue;
-
-        /* Ignore if parent has no pixels */
-        cairo_t* cairo = dst->cairo;
-        if (cairo == NULL)
-            continue;
-
-        /* Render buffer to layer */
-        cairo_reset_clip(cairo);
-        cairo_rectangle(cairo, layer->x, layer->y, src->width, src->height);
-        cairo_clip(cairo);
-
-        cairo_set_source_surface(cairo, surface, layer->x, layer->y);
-        cairo_paint_with_alpha(cairo, layer->opacity / 255.0);
-
-    }
-
-    /* Retrieve default layer (guaranteed to not be NULL) */
-    guacenc_layer* def_layer = guacenc_display_get_layer(display, 0);
-    assert(def_layer != NULL);
-
-    /* STUB: Write frame as PNG */
-    char filename[256];
-    sprintf(filename, "frame-%" PRId64 ".png", timestamp);
-    cairo_surface_t* surface = def_layer->frame->surface;
-    if (surface != NULL)
-        cairo_surface_write_to_png(surface, filename);
-
-    return 0;
-
-}
-
-guacenc_layer* guacenc_display_get_layer(guacenc_display* display,
-        int index) {
-
-    /* Do not lookup / allocate if index is invalid */
-    if (index < 0 || index > GUACENC_DISPLAY_MAX_LAYERS) {
-        guacenc_log(GUAC_LOG_WARNING, "Layer index out of bounds: %i", index);
-        return NULL;
-    }
-
-    /* Lookup layer, allocating a new layer if necessary */
-    guacenc_layer* layer = display->layers[index];
-    if (layer == NULL) {
-
-        /* Attempt to allocate layer */
-        layer = guacenc_layer_alloc();
-        if (layer == NULL) {
-            guacenc_log(GUAC_LOG_WARNING, "Layer allocation failed");
-            return NULL;
-        }
-
-        /* The default layer has no parent */
-        if (index == 0)
-            layer->parent_index = GUACENC_LAYER_NO_PARENT;
-
-        /* Store layer within display for future retrieval / management */
-        display->layers[index] = layer;
-
-    }
-
-    return layer;
-
-}
-
-int guacenc_display_get_depth(guacenc_display* display, guacenc_layer* layer) {
-
-    /* Non-existent layers have a depth of 0 */
-    if (layer == NULL)
-        return 0;
-
-    /* Layers with no parent have a depth of 0 */
-    if (layer->parent_index == GUACENC_LAYER_NO_PARENT)
-        return 0;
-
-    /* Retrieve parent layer */
-    guacenc_layer* parent =
-        guacenc_display_get_layer(display, layer->parent_index);
-
-    /* Current layer depth is the depth of the parent + 1 */
-    return guacenc_display_get_depth(display, parent) + 1;
-
-}
-
-int guacenc_display_free_layer(guacenc_display* display,
-        int index) {
-
-    /* Do not lookup / allocate if index is invalid */
-    if (index < 0 || index > GUACENC_DISPLAY_MAX_LAYERS) {
-        guacenc_log(GUAC_LOG_WARNING, "Layer index out of bounds: %i", index);
-        return 1;
-    }
-
-    /* Free layer (if allocated) */
-    guacenc_layer_free(display->layers[index]);
-
-    /* Mark layer as freed */
-    display->layers[index] = NULL;
-
-    return 0;
-
-}
-
-guacenc_buffer* guacenc_display_get_buffer(guacenc_display* display,
-        int index) {
-
-    /* Transform index to buffer space */
-    int internal_index = -index - 1;
-
-    /* Do not lookup / allocate if index is invalid */
-    if (internal_index < 0 || internal_index > GUACENC_DISPLAY_MAX_BUFFERS) {
-        guacenc_log(GUAC_LOG_WARNING, "Buffer index out of bounds: %i", index);
-        return NULL;
-    }
-
-    /* Lookup buffer, allocating a new buffer if necessary */
-    guacenc_buffer* buffer = display->buffers[internal_index];
-    if (buffer == NULL) {
-
-        /* Attempt to allocate buffer */
-        buffer = guacenc_buffer_alloc();
-        if (buffer == NULL) {
-            guacenc_log(GUAC_LOG_WARNING, "Buffer allocation failed");
-            return NULL;
-        }
-
-        /* All non-layer buffers must autosize */
-        buffer->autosize = true;
-
-        /* Store buffer within display for future retrieval / management */
-        display->buffers[internal_index] = buffer;
-
-    }
-
-    return buffer;
-
-}
-
-int guacenc_display_free_buffer(guacenc_display* display,
-        int index) {
-
-    /* Transform index to buffer space */
-    int internal_index = -index - 1;
-
-    /* Do not lookup / allocate if index is invalid */
-    if (internal_index < 0 || internal_index > GUACENC_DISPLAY_MAX_BUFFERS) {
-        guacenc_log(GUAC_LOG_WARNING, "Buffer index out of bounds: %i", index);
-        return 1;
-    }
-
-    /* Free buffer (if allocated) */
-    guacenc_buffer_free(display->buffers[internal_index]);
-
-    /* Mark buffer as freed */
-    display->buffers[internal_index] = NULL;
-
-    return 0;
-
-}
-
-guacenc_buffer* guacenc_display_get_related_buffer(guacenc_display* display,
-        int index) {
-
-    /* Retrieve underlying buffer of layer if a layer is requested */
-    if (index >= 0) {
-
-        /* Retrieve / allocate layer (if possible */
-        guacenc_layer* layer = guacenc_display_get_layer(display, index);
-        if (layer == NULL)
-            return NULL;
-
-        /* Return underlying buffer */
-        return layer->buffer;
-
-    }
-
-    /* Otherwise retrieve buffer directly */
-    return guacenc_display_get_buffer(display, index);
-
-}
-
-int guacenc_display_create_image_stream(guacenc_display* display, int index,
-        int mask, int layer_index, const char* mimetype, int x, int y) {
-
-    /* Do not lookup / allocate if index is invalid */
-    if (index < 0 || index > GUACENC_DISPLAY_MAX_STREAMS) {
-        guacenc_log(GUAC_LOG_WARNING, "Stream index out of bounds: %i", index);
-        return 1;
-    }
-
-    /* Free existing stream (if any) */
-    guacenc_image_stream_free(display->image_streams[index]);
-
-    /* Associate new stream */
-    guacenc_image_stream* stream = display->image_streams[index] =
-        guacenc_image_stream_alloc(mask, layer_index, mimetype, x, y);
-
-    /* Return zero only if stream is not NULL */
-    return stream == NULL;
-
-}
-
-guacenc_image_stream* guacenc_display_get_image_stream(
-        guacenc_display* display, int index) {
-
-    /* Do not lookup / allocate if index is invalid */
-    if (index < 0 || index > GUACENC_DISPLAY_MAX_STREAMS) {
-        guacenc_log(GUAC_LOG_WARNING, "Stream index out of bounds: %i", index);
-        return NULL;
-    }
-
-    /* Return existing stream (if any) */
-    return display->image_streams[index];
-
-}
-
-int guacenc_display_free_image_stream(guacenc_display* display, int index) {
-
-    /* Do not lookup / allocate if index is invalid */
-    if (index < 0 || index > GUACENC_DISPLAY_MAX_STREAMS) {
-        guacenc_log(GUAC_LOG_WARNING, "Stream index out of bounds: %i", index);
-        return 1;
-    }
-
-    /* Free stream (if allocated) */
-    guacenc_image_stream_free(display->image_streams[index]);
-
-    /* Mark stream as freed */
-    display->image_streams[index] = NULL;
-
-    return 0;
-
-}
 
 cairo_operator_t guacenc_display_cairo_operator(guac_composite_mode mask) {
 

src/guacenc/display.h

@@ -102,6 +102,22 @@ typedef struct guacenc_display {
  */
 int guacenc_display_sync(guacenc_display* display, guac_timestamp timestamp);
 
+/**
+ * Flattens the given display, rendering all child layers to the frame buffers
+ * of their parent layers. The frame buffer of the default layer of the display
+ * will thus contain the flattened, composited rendering of the entire display
+ * state after this function succeeds. The contents of the frame buffers of
+ * each layer are replaced by this function.
+ *
+ * @param display
+ *     The display to flatten.
+ *
+ * @return
+ *     Zero if the flatten operation succeeds, non-zero if an error occurs
+ *     preventing proper rendering.
+ */
+int guacenc_display_flatten(guacenc_display* display);
+
 /**
  * Allocates a new Guacamole video encoder display. This display serves as the
  * representation of encoding state, as well as the state of the Guacamole