modules/droste: implement a droste effect

5 files changed, 360 insertions, 0 deletions

diff --git a/src/Makefile.am b/src/Makefile.am
index d2fe42b..454d1ca 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -41,6 +41,7 @@ libtil_la_LIBADD =						\
 			modules/checkers/libcheckers.la		\
 			modules/compose/libcompose.la		\
 			modules/drizzle/libdrizzle.la		\
+			modules/droste/libdroste.la		\
 			modules/flow/libflow.la			\
 			modules/flui2d/libflui2d.la		\
 			modules/julia/libjulia.la		\
diff --git a/src/modules/Makefile.am b/src/modules/Makefile.am
index 825295d..74ec649 100644
--- a/src/modules/Makefile.am
+++ b/src/modules/Makefile.am
@@ -5,6 +5,7 @@ SUBDIRS =			\
 		checkers	\
 		compose		\
 		drizzle		\
+		droste		\
 		flow		\
 		flui2d		\
 		julia		\
diff --git a/src/modules/droste/Makefile.am b/src/modules/droste/Makefile.am
new file mode 100644
index 0000000..3285815
--- /dev/null
+++ b/src/modules/droste/Makefile.am
@@ -0,0 +1,3 @@
+noinst_LTLIBRARIES = libdroste.la
+libdroste_la_SOURCES = droste.c
+libdroste_la_CPPFLAGS = -I@top_srcdir@/src -I@top_srcdir@/src/libs
diff --git a/src/modules/droste/droste.c b/src/modules/droste/droste.c
new file mode 100644
index 0000000..9475df7
--- /dev/null
+++ b/src/modules/droste/droste.c
@@ -0,0 +1,353 @@
+/*
+ *  Copyright (C) 2024-2025 - Vito Caputo - <vcaputo@pengaru.com>
+ *
+ *  This program is free software: you can redistribute it and/or modify it
+ *  under the terms of the GNU General Public License version 2 as published
+ *  by the Free Software Foundation.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <stdint.h>
+
+#include "til.h"
+#include "til_fb.h"
+#include "til_module_context.h"
+
+/* This implements a "droste effect", also known as an infinity mirror:
+ * https://en.wikipedia.org/wiki/Droste_effect
+ * https://en.wikipedia.org/wiki/Infinity_mirror
+ */
+
+/* Some potential TODO items:
+ *
+ * - Fractional, or at least runtime-configurable scaling... though
+ *   exposing a tap for it would be fun
+ *
+ * - Runtime-configurable multisampled scaling (slow though)
+ *
+ * - The current implementation is very simple but relies on the
+ *   preservation of original contents in til_fb_fragment_snapshot(),
+ *   which causes a full copy.  This is wasteful since we only want
+ *   the unzoomed periphery preserved from the original.  Maybe there
+ *   should be a clip mask for the preservation in
+ *   til_fb_fragment_snapshot(), or just do the peripheral copy ourselves
+ *   and stop asking the snapshot code to do that for us.
+ *
+ * - The base module is currently always setup but conditionally used if
+ *   (!fragment->cleared).  It should probably be possible to specify
+ *   forcing the base module's render
+ *
+ */
+
+#define DROSTE_DEFAULT_BASE_MODULE	"blinds"
+
+typedef struct droste_context_t {
+	til_module_context_t	til_module_context;
+
+	til_module_context_t	*base_module_context;	/* a base module is used for non-overlay situations */
+	til_fb_fragment_t	*snapshot;
+} droste_context_t;
+
+typedef struct droste_setup_t {
+	til_setup_t		til_setup;
+
+	til_setup_t		*base_module_setup;
+} droste_setup_t;
+
+
+static til_module_context_t * droste_create_context(const til_module_t *module, til_stream_t *stream, unsigned seed, unsigned ticks, unsigned n_cpus, til_setup_t *setup)
+{
+	droste_context_t	*ctxt;
+
+	if (!((droste_setup_t *)setup)->base_module_setup)
+		return NULL;
+
+	ctxt = til_module_context_new(module, sizeof(droste_context_t), stream, seed, ticks, n_cpus, setup);
+	if (!ctxt)
+		return NULL;
+
+	{
+		const til_module_t	*module = ((droste_setup_t *)setup)->base_module_setup->creator;
+
+		if (til_module_create_contexts(module,
+					       stream,
+					       seed,
+					       ticks,
+					       n_cpus,
+					       ((droste_setup_t *)setup)->base_module_setup,
+					       1,
+					       &ctxt->base_module_context) < 0)
+			return til_module_context_free(&ctxt->til_module_context);
+	}
+
+	return &ctxt->til_module_context;
+}
+
+
+static void droste_destroy_context(til_module_context_t *context)
+{
+	droste_context_t	*ctxt = (droste_context_t *)context;
+
+	if (ctxt->snapshot)
+		ctxt->snapshot = til_fb_fragment_reclaim(ctxt->snapshot);
+
+	til_module_context_free(ctxt->base_module_context);
+	free(context);
+}
+
+
+/* derived from til_fragmenter_slice_per_cpu_x16(), but tweaked to only fragment the inset area */
+static int droste_fragmenter(til_module_context_t *context, const til_fb_fragment_t *fragment, unsigned number, til_fb_fragment_t *res_fragment)
+{
+	til_fb_fragment_t	inset = *fragment;
+	unsigned		slice, yoff;
+
+	assert(fragment);
+	assert(res_fragment);
+
+	inset.width = fragment->width >> 1;
+	inset.height = fragment->height >> 1;
+	inset.frame_width = inset.width;
+	inset.frame_height = inset.height;
+	inset.x = inset.y = 0;
+	inset.buf += inset.pitch * ((fragment->height - inset.height) >> 1) + ((fragment->width - inset.width) >> 1);
+	inset.stride += fragment->width >> 1;
+
+	slice = MAX(inset.height / context->n_cpus * 16, 1);
+	yoff = slice * number;
+
+	if (yoff >= inset.height)
+		return 0;
+
+	if (fragment->texture) {
+		til_fb_fragment_t	inset_texture;
+
+		inset_texture = *(fragment->texture);
+		inset.texture = &inset_texture;
+
+		/* TODO */
+
+		assert(res_fragment->texture);
+		assert(fragment->frame_width == fragment->texture->frame_width);
+		assert(fragment->frame_height == fragment->texture->frame_height);
+		assert(fragment->width == fragment->texture->width);
+		assert(fragment->height == fragment->texture->height);
+		assert(fragment->x == fragment->texture->x);
+		assert(fragment->y == fragment->texture->y);
+
+		*(res_fragment->texture) = (til_fb_fragment_t){
+				.buf = fragment->texture->buf + yoff * fragment->texture->pitch,
+				.x = fragment->x,
+				.y = fragment->y + yoff,
+				.width = fragment->width,
+				.height = MIN(fragment->height - yoff, slice),
+				.frame_width = fragment->frame_width,
+				.frame_height = fragment->frame_height,
+				.stride = fragment->texture->stride,
+				.pitch = fragment->texture->pitch,
+				.cleared = fragment->texture->cleared,
+		};
+
+	}
+
+	*res_fragment = (til_fb_fragment_t){
+				.texture = inset.texture ? res_fragment->texture : NULL,
+				.buf = inset.buf + yoff * inset.pitch,
+				.x = inset.x,
+				.y = inset.y + yoff,
+				.width = inset.width,
+				.height = MIN(inset.height - yoff, slice),
+				.frame_width = inset.frame_width,
+				.frame_height = inset.frame_height,
+				.stride = inset.stride,
+				.pitch = inset.pitch,
+				.number = number,
+				.cleared = inset.cleared,
+			};
+
+	return 1;
+
+}
+
+
+/* Prepare a frame for concurrent drawing of fragment using multiple fragments */
+static void droste_prepare_frame(til_module_context_t *context, til_stream_t *stream, unsigned ticks, til_fb_fragment_t **fragment_ptr, til_frame_plan_t *res_frame_plan)
+{
+	droste_context_t	*ctxt = (droste_context_t *)context;
+
+	if (!(*fragment_ptr)->cleared)
+		til_module_render(ctxt->base_module_context, stream, ticks, fragment_ptr);
+
+	*res_frame_plan = (til_frame_plan_t){ .fragmenter = droste_fragmenter };
+
+	{
+		til_fb_fragment_t	*fragment = *fragment_ptr;
+		til_fb_fragment_t	*snapshot = ctxt->snapshot;
+
+		if (!snapshot)
+			return;
+
+		if (fragment->frame_width != snapshot->frame_width ||
+		    fragment->frame_height != snapshot->frame_height ||
+		    fragment->height != snapshot->height ||
+		    fragment->width != snapshot->width) {
+
+			/* discard the snapshot which will prevent doing anything this frame,
+			 * since it doesn't match the incoming fragment (like a resize situation)
+			 */
+			ctxt->snapshot = til_fb_fragment_reclaim(ctxt->snapshot);
+
+			return;
+		}
+
+		/* TODO: if we're not used as an overlay, here'd be a good place to generate something or
+		 * just use another module as a base layer...  until we do something sensible here, we should
+		 * keep this as an experimental module so it doesn't get used by automation as a base layer..
+		 * it also needs something to show in montage.
+		 */
+	}
+}
+
+
+static void droste_render_fragment(til_module_context_t *context, til_stream_t *stream, unsigned ticks, unsigned cpu, til_fb_fragment_t **fragment_ptr)
+{
+	droste_context_t	*ctxt = (droste_context_t *)context;
+	til_fb_fragment_t	*fragment = *fragment_ptr;
+	til_fb_fragment_t	*snapshot = ctxt->snapshot;
+
+	if (!snapshot)
+		return;
+
+	for (unsigned y = fragment->y; y < fragment->y + fragment->height; y++) {
+		for (unsigned x = fragment->x; x < fragment->x + fragment->width; x++) {
+			uint32_t	color;
+
+			color = til_fb_fragment_get_pixel_clipped(snapshot, x << 1, y << 1);
+			til_fb_fragment_put_pixel_unchecked(fragment, 0, x, y, color);
+		}
+	}
+}
+
+
+static int droste_finish_frame(til_module_context_t *context, til_stream_t *stream, unsigned int ticks, til_fb_fragment_t **fragment_ptr)
+{
+	droste_context_t	*ctxt = (droste_context_t *)context;
+
+	/* if we have a stowed frame clean it up */
+	if (ctxt->snapshot)
+		ctxt->snapshot = til_fb_fragment_reclaim(ctxt->snapshot);
+
+	/* stow the new frame for the next time around to sample from */
+	ctxt->snapshot = til_fb_fragment_snapshot(fragment_ptr, 1);
+
+	return 0;
+}
+
+
+static void droste_setup_free(til_setup_t *setup)
+{
+	droste_setup_t	*s = (droste_setup_t *)setup;
+
+	til_setup_free(s->base_module_setup);
+	free(setup);
+}
+
+
+static int droste_base_module_setup(const til_settings_t *settings, til_setting_t **res_setting, const til_setting_desc_t **res_desc, til_setup_t **res_setup)
+{
+	return til_module_setup_full(settings,
+				     res_setting,
+				     res_desc,
+				     res_setup,
+				     "Base module name",
+				     DROSTE_DEFAULT_BASE_MODULE,
+				     (TIL_MODULE_EXPERIMENTAL | TIL_MODULE_HERMETIC | TIL_MODULE_AUDIO_ONLY),
+				     NULL);
+}
+
+
+static int droste_setup(const til_settings_t *settings, til_setting_t **res_setting, const til_setting_desc_t **res_desc, til_setup_t **res_setup);
+
+
+til_module_t	droste_module = {
+	.create_context = droste_create_context,
+	.destroy_context = droste_destroy_context,
+	.prepare_frame = droste_prepare_frame,
+	.render_fragment = droste_render_fragment,
+	.finish_frame = droste_finish_frame,
+	.setup = droste_setup,
+	.name = "droste",
+	.description = "Droste effect (threaded)",
+	.author = "Vito Caputo <vcaputo@pengaru.com>",
+	.flags = TIL_MODULE_OVERLAYABLE,
+};
+
+
+static int droste_setup(const til_settings_t *settings, til_setting_t **res_setting, const til_setting_desc_t **res_desc, til_setup_t **res_setup)
+{
+	til_setting_t		*base_module;
+	const til_settings_t	*base_module_settings;
+	const char		*base_module_values[] = {
+					"blinds",
+					"book",
+					"moire",
+					"plasma",
+					"plato",
+					"roto",
+					NULL
+				};
+	int			r;
+
+	r = til_settings_get_and_describe_setting(settings,
+						&(til_setting_spec_t){
+							.name = "Base module",
+							.key = "base_module",
+							.preferred = base_module_values[0],
+							.values = base_module_values,
+							.annotations = NULL,
+							.as_nested_settings = 1,
+						},
+						&base_module, /* XXX: this isn't really of direct use now that it's a potentially full-blown settings string, see base_module_settings */
+						res_setting,
+						res_desc);
+	if (r)
+		return r;
+
+	base_module_settings = base_module->value_as_nested_settings;
+	assert(base_module_settings);
+
+	r = droste_base_module_setup(base_module_settings,
+				   res_setting,
+				   res_desc,
+				   NULL); /* XXX: note no res_setup, must defer finalize */
+	if (r)
+		return r;
+
+	if (res_setup) {
+		droste_setup_t	*setup;
+
+		setup = til_setup_new(settings, sizeof(*setup), droste_setup_free, &droste_module);
+		if (!setup)
+			return -ENOMEM;
+
+		r = droste_base_module_setup(base_module_settings,
+					   res_setting,
+					   res_desc,
+					   &setup->base_module_setup); /* finalize! */
+		if (r < 0)
+			return til_setup_free_with_ret_err(&setup->til_setup, r);
+
+		assert(r == 0);
+
+		*res_setup = &setup->til_setup;
+	}
+
+	return 0;
+}
diff --git a/src/til.c b/src/til.c
index 4a77e6c..0ce7ebb 100644
--- a/src/til.c
+++ b/src/til.c
@@ -33,6 +33,7 @@ extern til_module_t	book_module;
 extern til_module_t	checkers_module;
 extern til_module_t	compose_module;
 extern til_module_t	drizzle_module;
+extern til_module_t	droste_module;
 extern til_module_t	flow_module;
 extern til_module_t	flui2d_module;
 extern til_module_t	julia_module;
@@ -77,6 +78,7 @@ static const til_module_t	*modules[] = {
 	&checkers_module,
 	&compose_module,
 	&drizzle_module,
+	&droste_module,
 	&flow_module,
 	&flui2d_module,
 	&julia_module,