static int screensaver_idle_handler(gpointer user_data) {
ScreenSaver *self = SCREENSAVER(user_data);
iterative_map_calculate_motion(ITERATIVE_MAP(self->frame_renders[self->current_frame]), 100000,
TRUE, PARAMETER_INTERPOLATOR(parameter_holder_interpolate_linear),
&self->frame_parameters[self->current_frame]);
if (GTK_WIDGET_DRAWABLE(self->view)) {
histogram_view_set_imager(HISTOGRAM_VIEW(self->view),
HISTOGRAM_IMAGER(self->frame_renders[self->current_frame]));
histogram_view_update(HISTOGRAM_VIEW(self->view));
self->current_frame += self->direction;
if (self->current_frame >= self->num_frames) {
self->current_frame = self->num_frames-2;
self->direction = -1;
}
if (self->current_frame < 0) {
self->current_frame = 1;
self->direction = 1;
}
}
return 1;
}
Explorer* explorer_new(IterativeMap *map, Animation *animation) {
Explorer *self = EXPLORER(g_object_new(explorer_get_type(), NULL));
GtkWidget *editor, *window, *scroll;
GtkRequisition win_req;
self->animation = ANIMATION(g_object_ref(animation));
self->map = ITERATIVE_MAP(g_object_ref(map));
/* Create the parameter editor */
editor = parameter_editor_new(PARAMETER_HOLDER(map));
gtk_box_pack_start(GTK_BOX(glade_xml_get_widget(self->xml, "parameter_editor_box")),
editor, FALSE, FALSE, 0);
gtk_widget_show_all(editor);
/* Create the view */
self->view = histogram_view_new(HISTOGRAM_IMAGER(map));
gtk_container_add(GTK_CONTAINER(glade_xml_get_widget(self->xml, "drawing_area_viewport")), self->view);
gtk_widget_show_all(self->view);
/* Set the initial render time */
on_render_time_changed(glade_xml_get_widget(self->xml, "render_time"), self);
explorer_init_history(self);
explorer_init_animation(self);
explorer_init_tools(self);
explorer_init_cluster(self);
explorer_init_about(self);
/* Start the iterative map rendering in the background, and get a callback every time a block
* of calculations finish so we can update the GUI.
*/
iterative_map_start_calculation(self->map);
g_signal_connect(G_OBJECT(self->map), "calculation-finished",
G_CALLBACK(on_calculation_finished), self);
/* Set the window's default size to include our default image size.
* The cleanest way I know of to do this is to set the scrolled window's scrollbar policies
* to 'never' and get the window's size requests, set them back to automatic, then set the
* default size to that size request.
*/
window = glade_xml_get_widget(self->xml, "explorer_window");
scroll = glade_xml_get_widget(self->xml, "main_scrolledwindow");
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), GTK_POLICY_NEVER, GTK_POLICY_NEVER);
gtk_widget_size_request(window, &win_req);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_window_set_default_size(GTK_WINDOW(window), win_req.width, win_req.height);
gtk_widget_show(window);
return self;
}
ScreenSaver* screensaver_new(IterativeMap *map, Animation *animation) {
ScreenSaver *self = SCREENSAVER(g_object_new(screensaver_get_type(), NULL));
int i;
AnimationIter iter;
gchar* common_parameters;
self->animation = ANIMATION(g_object_ref(animation));
self->map = ITERATIVE_MAP(g_object_ref(map));
self->view = g_object_ref(histogram_view_new(HISTOGRAM_IMAGER(self->map)));
/* Allocate and interpolate all frames */
self->framerate = 10;
self->num_frames = animation_get_length(self->animation) * self->framerate;
self->frame_renders = g_new0(IterativeMap*, self->num_frames);
self->frame_parameters = g_new0(ParameterHolderPair, self->num_frames);
self->current_frame = 0;
common_parameters = parameter_holder_save_string(PARAMETER_HOLDER(map));
animation_iter_seek(animation, &iter, 0);
for (i=0; i<self->num_frames; i++) {
self->frame_renders[i] = ITERATIVE_MAP(de_jong_new());
parameter_holder_load_string(PARAMETER_HOLDER(self->frame_renders[i]), common_parameters);
self->frame_parameters[i].a = PARAMETER_HOLDER(de_jong_new());
animation_iter_load(animation, &iter, self->frame_parameters[i].a);
animation_iter_seek_relative(animation, &iter, 1/self->framerate);
}
for (i=0; i<self->num_frames-1; i++)
self->frame_parameters[i].b = self->frame_parameters[i+1].a;
self->frame_parameters[self->num_frames-1].b = self->frame_parameters[self->num_frames-1].a;
g_free(common_parameters);
self->direction = 1;
screensaver_start(self);
return self;
}
static void animation_render_ui_init(AnimationRenderUi *self) {
if (g_file_test (FYRE_DATADIR "/animation-render.glade", G_FILE_TEST_EXISTS))
self->xml = glade_xml_new(FYRE_DATADIR "/animation-render.glade", NULL, NULL);
if (!self->xml)
self->xml = glade_xml_new(BR_DATADIR("/fyre/animation-render.glade"), NULL, NULL);
fyre_set_icon_later(glade_xml_get_widget(self->xml, "window"));
glade_xml_signal_connect_data(self->xml, "on_ok_clicked", G_CALLBACK(on_ok_clicked), self);
glade_xml_signal_connect_data(self->xml, "on_cancel_clicked", G_CALLBACK(on_cancel_clicked), self);
glade_xml_signal_connect_data(self->xml, "on_select_output_file_clicked", G_CALLBACK(on_select_output_file_clicked), self);
glade_xml_signal_connect_data(self->xml, "on_delete_event", G_CALLBACK(on_delete_event), self);
self->map = ITERATIVE_MAP(de_jong_new());
self->frame.a = PARAMETER_HOLDER(de_jong_new());
self->frame.b = PARAMETER_HOLDER(de_jong_new());
}
static void status_merge_callback (RemoteClient* self,
RemoteResponse* response,
gpointer user_data)
{
IterativeMap *dest = ITERATIVE_MAP(user_data);
double iters, iter_delta;
long density;
double elapsed;
sscanf(response->message, "iterations=%lf density=%ld", &iters, &density);
/* FIXME: Since we don't know which parameters affect calculation, we don't
* know when the node's iteration counter gets reset. We currently
* assume that if it's value decreases, it's been reset.
*/
if (iters >= self->prev_iterations) {
iter_delta = iters - self->prev_iterations;
}
else {
/* Assume it started at zero */
iter_delta = iters;
}
self->prev_iterations = iters;
if (self->pending_param_changes)
return;
if (!iter_delta)
return;
/* Merge this iteration count in */
dest->iterations += iter_delta;
/* Update our iteration speed */
self->iter_accumulator += iter_delta;
elapsed = g_timer_elapsed(self->status_speed_timer, NULL);
if (elapsed > MINIMUM_SPEED_WINDOW) {
g_timer_start(self->status_speed_timer);
self->iters_per_sec = self->iter_accumulator / elapsed;
self->iter_accumulator = 0;
if (self->speed_callback)
self->speed_callback(self, self->iters_per_sec, self->bytes_per_sec,
self->speed_callback_user_data);
}
}
static void remote_server_connect (GServer* gserver,
GConn* gconn,
gpointer user_data)
{
RemoteServerConn* self = g_new0(RemoteServerConn, 1);
self->server = (RemoteServer*) user_data;
self->gconn = gconn;
self->map = ITERATIVE_MAP(de_jong_new());
gnet_conn_set_callback(gconn, remote_server_callback, self);
gnet_conn_set_watch_error(gconn, TRUE);
gnet_conn_readline(gconn);
remote_server_send_response(self, FYRE_RESPONSE_READY,
"Fyre rendering server ready");
if (self->server->verbose)
printf("[%s:%d] Connected\n", gconn->hostname, gconn->port);
}
int main(int argc, char ** argv) {
IterativeMap* map;
Animation* animation;
gboolean animate = FALSE;
gboolean have_gtk;
gboolean verbose = FALSE;
gboolean hidden = FALSE;
enum {INTERACTIVE, RENDER, SCREENSAVER, REMOTE} mode = INTERACTIVE;
const gchar *outputFile = NULL;
const gchar *pidfile = NULL;
int c, option_index=0;
double quality = 1.0;
#ifdef HAVE_GNET
int port_number = FYRE_DEFAULT_PORT;
#endif
GError *error = NULL;
math_init();
g_type_init();
have_gtk = gtk_init_check(&argc, &argv);
#ifdef HAVE_GNET
gnet_init();
# ifdef WIN32
gnet_ipv6_set_policy(GIPV6_POLICY_IPV4_ONLY);
# endif
#endif
map = ITERATIVE_MAP(de_jong_new());
animation = animation_new();
while (1) {
static struct option long_options[] = {
{"help", 0, NULL, 'h'},
{"read", 1, NULL, 'i'},
{"animate", 1, NULL, 'n'},
{"output", 1, NULL, 'o'},
{"param", 1, NULL, 'p'},
{"size", 1, NULL, 's'},
{"oversample", 1, NULL, 'S'},
{"quality", 1, NULL, 'q'},
{"remote", 0, NULL, 'r'},
{"verbose", 0, NULL, 'v'},
{"port", 1, NULL, 'P'},
{"cluster", 1, NULL, 'c'},
{"auto-cluster", 0, NULL, 'C'},
{"screensaver", 0, NULL, 1000}, /* Undocumented, still experimental */
{"hidden", 0, NULL, 1001},
{"chdir", 1, NULL, 1002}, /* Undocumented, used by win32 file associations */
{"pidfile", 1, NULL, 1003},
{"version", 0, NULL, 1004},
{NULL},
};
c = getopt_long(argc, argv, "hi:n:o:p:s:S:q:rvP:c:C",
long_options, &option_index);
if (c == -1)
break;
switch (c) {
case 'i':
{
histogram_imager_load_image_file(HISTOGRAM_IMAGER(map), optarg, &error);
break;
}
case 'n':
{
GtkTreeIter iter;
animation_load_file(animation, optarg);
animate = TRUE;
gtk_tree_model_get_iter_first(GTK_TREE_MODEL(animation->model), &iter);
animation_keyframe_load(animation, &iter, PARAMETER_HOLDER(map));
break;
}
case 'o':
mode = RENDER;
outputFile = optarg;
break;
case 'p':
parameter_holder_load_string(PARAMETER_HOLDER(map), optarg);
break;
case 's':
parameter_holder_set(PARAMETER_HOLDER(map), "size" , optarg);
break;
case 'S':
parameter_holder_set(PARAMETER_HOLDER(map), "oversample", optarg);
break;
case 'q':
quality = atof(optarg);
break;
case 'v':
verbose = TRUE;
break;
#ifdef HAVE_GNET
case 'c':
{
ClusterModel *cluster = cluster_model_get(map, TRUE);
cluster_model_add_nodes(cluster, optarg);
}
break;
case 'C':
{
ClusterModel *cluster = cluster_model_get(map, TRUE);
cluster_model_enable_discovery(cluster);
}
break;
case 'r':
mode = REMOTE;
break;
case 'P':
port_number = atol(optarg);
break;
#else
case 'c':
case 'C':
case 'P':
fprintf(stderr,
"This Fyre binary was compiled without gnet support.\n"
"Cluster support is not available.\n");
break;
case 'r':
fprintf(stderr,
"This Fyre binary was compiled without gnet support.\n"
"Cluster support is not available.\n");
exit(1);
break;
#endif
case 1000: /* --screensaver */
mode = SCREENSAVER;
break;
case 1001: /* --hidden */
hidden = TRUE;
break;
case 1002: /* --chdir */
chdir(optarg);
break;
case 1003: /* --pidfile */
pidfile = optarg;
break;
case 1004: /* --version */
printf("%s\n", VERSION);
return 0;
case 'h':
default:
usage(argv);
return 1;
}
}
if (optind + 1 < argc) {
usage(argv);
return 1;
}
if (optind != argc) {
char *ext = strrchr (argv[optind], '.');
if (ext) {
if (g_strcasecmp(ext, ".png") == 0) {
histogram_imager_load_image_file(HISTOGRAM_IMAGER(map), argv[optind], &error);
} else if (g_strcasecmp(ext, ".fa") == 0) {
GtkTreeIter iter;
animation_load_file(animation, argv[optind]);
animate = TRUE;
gtk_tree_model_get_iter_first(GTK_TREE_MODEL(animation->model), &iter);
animation_keyframe_load(animation, &iter, PARAMETER_HOLDER(map));
} else {
usage(argv);
return 1;
}
} else {
usage(argv);
return 1;
}
}
switch (mode) {
case INTERACTIVE: {
Explorer *explorer;
if (!have_gtk) {
fprintf(stderr, "GTK intiailization failed, can't start in interactive mode\n");
return 1;
}
explorer = explorer_new (map, animation);
if (error) {
GtkWidget *dialog, *label;
gchar *text;
dialog = glade_xml_get_widget (explorer->xml, "error dialog");
label = glade_xml_get_widget (explorer->xml, "error label");
text = g_strdup_printf ("<span weight=\"bold\" size=\"larger\">Error!</span>\n\n%s", error->message);
gtk_label_set_markup (GTK_LABEL (label), text);
g_free (text);
g_error_free (error);
gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_hide (dialog);
}
gtk_main();
break;
}
case RENDER: {
acquire_console();
if (error) {
g_print ("Error: %s\n", error->message);
g_error_free (error);
}
if (animate)
animation_render_main (map, animation, outputFile, quality);
else
batch_image_render (map, outputFile, quality);
break;
}
case REMOTE: {
#ifdef HAVE_GNET
if (verbose) {
acquire_console();
}
else {
daemonize_to_pidfile(pidfile);
}
if (!hidden)
discovery_server_new(FYRE_DEFAULT_SERVICE, port_number);
remote_server_main_loop(port_number, have_gtk, verbose);
#else
fprintf(stderr,
"This Fyre binary was compiled without gnet support.\n"
"Remote control mode is not available.\n");
#endif
break;
}
case SCREENSAVER: {
ScreenSaver* screensaver;
GtkWidget* window;
if (!have_gtk) {
fprintf(stderr, "GTK intiailization failed, can't start in screensaver mode\n");
return 1;
}
screensaver = screensaver_new(map, animation);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
fyre_set_icon_later(window);
gtk_window_set_resizable(GTK_WINDOW(window), FALSE);
gtk_window_set_title(GTK_WINDOW(window), "Fyre Screensaver");
gtk_container_add(GTK_CONTAINER(window), screensaver->view);
gtk_widget_show_all(window);
gtk_main();
break;
}
}
return 0;
}
static void animation_render_ui_run_timed_calculation(AnimationRenderUi *self) {
iterative_map_calculate_motion_timed(ITERATIVE_MAP(self->map),
0.025, self->continuation,
PARAMETER_INTERPOLATOR(parameter_holder_interpolate_linear),
&self->frame);
}
