1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
|
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include "til.h"
#include "til_fb.h"
#include "til_module_context.h"
#include "til_settings.h"
#include "til_util.h"
#include "txt/txt.h"
/* Copyright (C) 2023 - Vito Caputo <vcaputo@pengaru.com> */
/* This implements a rudimentary sequencing module varying
* "tapped" variables of other modules on a timeline via
* GNU Rocket.
*/
typedef struct rocket_context_t {
til_module_context_t til_module_context;
const til_module_t *module;
til_module_context_t *module_ctxt;
char *module_settings;
} rocket_context_t;
typedef struct rocket_setup_t {
til_setup_t til_setup;
const char *module;
} rocket_setup_t;
static rocket_setup_t rocket_default_setup = { .module = "rtv" };
static til_module_context_t * rocket_create_context(til_stream_t *stream, unsigned seed, unsigned ticks, unsigned n_cpus, char *path, til_setup_t *setup)
{
rocket_context_t *ctxt;
const til_module_t *module;
if (!setup)
setup = &rocket_default_setup.til_setup;
module = til_lookup_module(((rocket_setup_t *)setup)->module);
if (!module)
return NULL;
ctxt = til_module_context_new(stream, sizeof(rocket_context_t), seed, ticks, n_cpus, path);
if (!ctxt)
return NULL;
ctxt->module = module;
{
til_setup_t *module_setup = NULL;
(void) til_module_randomize_setup(ctxt->module, rand_r(&seed), &module_setup, NULL);
(void) til_module_create_context(ctxt->module, stream, rand_r(&seed), ticks, 0, path, module_setup, &ctxt->module_ctxt);
til_setup_free(module_setup);
}
return &ctxt->til_module_context;
}
static void rocket_destroy_context(til_module_context_t *context)
{
rocket_context_t *ctxt = (rocket_context_t *)context;
til_module_context_free(ctxt->module_ctxt);
free(context);
}
static void rocket_render_fragment(til_module_context_t *context, til_stream_t *stream, unsigned ticks, unsigned cpu, til_fb_fragment_t **fragment_ptr)
{
rocket_context_t *ctxt = (rocket_context_t *)context;
til_module_render(ctxt->module_ctxt, stream, ticks, fragment_ptr);
}
static int rocket_setup(const til_settings_t *settings, til_setting_t **res_setting, const til_setting_desc_t **res_desc, til_setup_t **res_setup)
{
const char *module;
int r;
r = til_settings_get_and_describe_value(settings,
&(til_setting_desc_t){
.name = "Module to sequence",
.key = "module",
.preferred = "rtv",
.annotations = NULL,
},
&module,
res_setting,
res_desc);
if (r)
return r;
/* turn layers colon-separated list into a null-terminated array of strings */
if (res_setup) {
const til_module_t *til_module;
rocket_setup_t *setup;
if (!strcmp(module, "rocket"))
return -EINVAL;
til_module = til_lookup_module(module);
if (!til_module)
return -ENOENT;
if (til_module->flags & (TIL_MODULE_HERMETIC | TIL_MODULE_EXPERIMENTAL))
return -EINVAL;
setup = til_setup_new(sizeof(*setup), (void(*)(til_setup_t *))free);
if (!setup)
return -ENOMEM;
setup->module = til_module->name;
*res_setup = &setup->til_setup;
}
return 0;
}
til_module_t rocket_module = {
.create_context = rocket_create_context,
.destroy_context = rocket_destroy_context,
.render_fragment = rocket_render_fragment,
.name = "rocket",
.description = "GNU Rocket module sequencer",
.setup = rocket_setup,
.flags = TIL_MODULE_HERMETIC | TIL_MODULE_EXPERIMENTAL,
};
|
