mandelbrot

main.c (9921B)

---

 #define _XOPEN_SOURCE 700
 
 #include "mandelbrot.h"
 
 #include <sys/socket.h>
 #include <netdb.h>
 
 #include <fcntl.h>
 
 #include <getopt.h>
 
 enum palette_type {
 	PALETTE_BASIC,
 	PALETTE_MONOCHROME,
 	PALETTE_GRAYSCALE,
 	PALETTE_HISTOGRAM,
 	PALETTE_SMOOTH,
 };
 
 struct opts {
 	int verbose;
 	char *server_host;
 	char *server_port;
 	uint64_t xres, yres;
 	uint64_t max_iters;
 	enum palette_type palette;
 	char *outfile;
 } opts = {
 	.verbose = 0,
 	.server_host = NULL,
 	.server_port = NULL,
 	.xres = 800, .yres = 600,
 	.max_iters = 100,
 	.palette = PALETTE_SMOOTH,
 	.outfile = "/tmp/mandelbrot.bmp",
 };
 
 #define OPTSTR "hvS:r:i:p:o:"
 
 static void
 usage(char *prog)
 {
 	fprintf(stderr, "Usage: %s [-hv] [-S <servaddr>] "
 			"[-r <xres>x<yres> ] [-i <maxiters>] "
 			"[-p basic|mono|gray|hist|smooth ] [-o <out.bmp>]\n",
 			prog);
 
 	fprintf(stderr, "\t-h : display help information\n");
 	fprintf(stderr, "\t-v : enable verbose logging\n");
 	fprintf(stderr, "\t-S : attempt to connect to the given server addr\n");
 	fprintf(stderr, "\t-r : set output resolution (default: 800x600)\n");
 	fprintf(stderr, "\t-i : set maximum iterations per pixel (default: 100)\n");
 	fprintf(stderr, "\t-p : set colour palette (default: smooth)\n");
 	fprintf(stderr, "\t-o : set output filename (default: /tmp/mandelbrot.bmp)\n");
 }
 
 static int
 parse_opts(int argc, char **argv, struct opts *opts)
 {
 	int opt;
 	while ((opt = getopt(argc, argv, OPTSTR)) > 0) {
 		switch (opt) {
 		case 'v':
 			opts->verbose = 1;
 			break;
 
 		case 'S': {
 			char *split = strrchr(optarg, ':');
 			if (!split) {
 				fprintf(stderr, "Failed to parse server addr: %s\n", optarg);
 				return -1;
 			}
 
 			*split = '\0';
 
 			opts->server_host = optarg;
 			opts->server_port = ++split;
 		} break;
 
 		case 'r': {
 			char *saveptr;
 			char *xres = strtok_r(optarg, "x", &saveptr);
 			char *yres = strtok_r(NULL,   "x", &saveptr);
 
 			if (!xres || !yres) {
 				fprintf(stderr, "Must provide resolution in format: <xres>x<yres>\n");
 				return -1;
 			}
 
 			if ((opts->xres = strtoull(xres, NULL, 10)) == 0) {
 				fprintf(stderr, "Failed to parse x-resolution: %s\n", xres);
 				return -1;
 			}
 
 			if ((opts->yres = strtoull(yres, NULL, 10)) == 0) {
 				fprintf(stderr, "Failed to parse y-resolution: %s\n", yres);
 				return -1;
 			}
 		} break;
 
 		case 'i':
 			  if ((opts->max_iters = strtoull(optarg, NULL, 10)) == 0) {
 				  fprintf(stderr, "Failed to parse max iters: %s\n", optarg);
 				  return -1;
 			  }
 			  break;
 
 		case 'p':
 			  if (strcmp(optarg, "basic") == 0) {
 				  opts->palette = PALETTE_BASIC;
 			  } else if (strcmp(optarg, "mono") == 0) {
 				  opts->palette = PALETTE_MONOCHROME;
 			  } else if (strcmp(optarg, "gray") == 0) {
 				  opts->palette = PALETTE_GRAYSCALE;
 			  } else if (strcmp(optarg, "hist") == 0) {
 				  opts->palette = PALETTE_HISTOGRAM;
 			  } else if (strcmp(optarg, "smooth") == 0) {
 				  opts->palette = PALETTE_SMOOTH;
 			  } else {
 				  fprintf(stderr, "Unknown palette: %s\n", optarg);
 				  return -1;
 			  }
 			  break;
 
 		case 'o':
 			opts->outfile = optarg;
 			break;
 
 		default:
 			return -1;
 		}
 	}
 
 	return 0;
 }
 
 static inline uint32_t
 hsv_to_rgb(float hue, float sat, float val)
 {
 	float h = fmodf(hue, 360.0);
 
 	float hp = h / 60.0;
 	float c = val * sat;
 	float x = c * (1 - fabsf(fmodf(hp, 2.0) - 1));
 
 	float rgb[3] = {0};
 
 	if (0 <= hp && hp < 1)      { rgb[0] = c; rgb[1] = x; }
 	else if (1 <= hp && hp < 2) { rgb[0] = x; rgb[1] = c; }
 	else if (2 <= hp && hp < 3) { rgb[1] = c; rgb[2] = x; }
 	else if (3 <= hp && hp < 4) { rgb[1] = x; rgb[2] = c; }
 	else if (4 <= hp && hp < 5) { rgb[0] = x; rgb[2] = c; }
 	else if (5 <= hp && hp < 6) { rgb[0] = c; rgb[2] = x; }
 
 	float m = val - c;
 	rgb[0] += m;
 	rgb[1] += m;
 	rgb[2] += m;
 
 	return pixel(rgb[0] * 255, rgb[1] * 255, rgb[2] * 255, 255);
 }
 
 static inline uint32_t
 palette(float abs2, uint32_t iters, uint32_t max_iters, enum palette_type type)
 {
 	switch (type) {
 	case PALETTE_BASIC:
 		return (iters == max_iters) ? pixel(0, 0, 0, 255)
 					    : pixel(255, 255, 255, 255);
 
 	case PALETTE_MONOCHROME: {
 		float f = (float) iters / max_iters;
 		return (iters == max_iters) ? pixel(0, 0, 0, 255)
 					    : pixel(f * 255, f * 255, f * 255, 255);
 	} break;
 
 	case PALETTE_GRAYSCALE: {
 		float smooth_iters = (iters + 1) - (logf(logf(sqrtf(abs2))) / M_LN2);
 		float sf = CLAMP(smooth_iters / max_iters, 0.0f, 1.0f);
 		float v = 255 * (1 - sf);
 
 		return (iters == max_iters) ? pixel(0, 0, 0, 255) : pixel(v, v, v, 255);
 	} break;
 
 	case PALETTE_HISTOGRAM: {
 		float f = (float) iters / max_iters;
 		// TODO: actually implement histogram colouring
 		return (iters == max_iters) ? pixel(0, 0, 0, 255)
 					    : pixel(f * 255, f * 255, f * 255, 255);
 	} break;
 
 	case PALETTE_SMOOTH: {
 		float smooth_iters = (iters + 1) - (logf(logf(sqrtf(abs2))) / M_LN2);
 		float hue = 0.95 + 20 * smooth_iters;
 		return (iters == max_iters) ? pixel(0, 0, 0, 255)
 					    : hsv_to_rgb(hue, 0.8, 1.0);
 	} break;
 	}
 }
 
 static void
 paint_region(struct render_region *region, uint32_t *pixbuf, uint32_t *iterbuf, float *abs2buf,
 	     enum palette_type palette_type)
 {
 	size_t pixels = region->xres * region->yres;
 
 	for (size_t i = 0; i < pixels; i++)
 		pixbuf[i] = palette(abs2buf[i], iterbuf[i], region->max_iters,
 				    palette_type);
 }
 
 static void
 render_networked_mandelbrot(char const *host, char const *port,
 			    uint32_t *pixbuf, uint32_t *iterbuf, float *abs2buf,
 			    size_t width, size_t height, size_t max_iters,
 			    enum palette_type palette_type)
 {
 	struct addrinfo hints = {
 		.ai_family = AF_UNSPEC,
 		.ai_socktype = SOCK_STREAM,
 		.ai_protocol = IPPROTO_TCP,
 		.ai_flags = AI_NUMERICSERV,
 	}, *addrinfo, *ptr;
 
 	int res;
 	if ((res = getaddrinfo(host, port, &hints, &addrinfo))) {
 		fprintf(stderr, "getaddrinfo(): %s\n", gai_strerror(res));
 		exit(EXIT_FAILURE);
 	}
 
 	int fd;
 	for (ptr = addrinfo; ptr; ptr = ptr->ai_next) {
 		fd = socket(ptr->ai_family, ptr->ai_socktype, ptr->ai_protocol);
 		if (fd < 0)
 			continue;
 
 		if (connect(fd, ptr->ai_addr, ptr->ai_addrlen) < 0) {
 			close(fd);
 			continue;
 		}
 
 		break;
 	}
 
 	freeaddrinfo(addrinfo);
 
 	if (!ptr) {
 		fprintf(stderr, "Failed to connect to server\n");
 		exit(EXIT_FAILURE);
 	}
 
 	struct render_region region = {
 		.xres = width, .yres = height,
 		.escape_val = 2,
 		.max_iters = max_iters,
 		.x0 = -2.0, .y0 = -1.5, .x1 = 0.5, .y1 = 1.5,
 	};
 
 	// TODO: assemble request packet as fixed point
 	int nbytes_send = sendall(fd, &region, sizeof region);
 	printf("sent: %d bytes\n", nbytes_send);
 
 	// TODO: actually wait on a number of render results
 	size_t pixels = width * height;
 	int nbytes_recv = 0;
 	nbytes_recv += recvall(fd, iterbuf, pixels * sizeof *iterbuf);
 	nbytes_recv += recvall(fd, abs2buf, pixels * sizeof *abs2buf);
 	printf("received: %d bytes\n", nbytes_recv);
 
 	paint_region(&region, pixbuf, iterbuf, abs2buf, palette_type);
 
 	close(fd);
 }
 
 static void
 render_mandelbrot(uint32_t *pixbuf, uint32_t *iterbuf, float *abs2buf,
 		  size_t width, size_t height, size_t max_iters,
 		  enum palette_type palette_type)
 {
 	struct render_region region = {
 		.xres = width, .yres = height,
 		.escape_val = 2,
 		.max_iters = max_iters,
 		.x0 = -2.0, .y0 = -1.5, .x1 = 0.5, .y1 = 1.5,
 	};
 
 	render_region(&region, iterbuf, abs2buf);
 	paint_region(&region, pixbuf, iterbuf, abs2buf, palette_type);
 }
 
 static void
 write_bitmap(int fd, uint32_t const *buf, size_t width, size_t height)
 {
 	uint32_t pixels = width * height;
 	uint16_t pixel_size = 8 * sizeof *buf;
 	uint32_t pixel_bytes = pixels * sizeof *buf;
 
 	uint32_t dib_header_size = 40;
 	uint32_t bitmap_header_size = 14;
 	uint32_t header_size = bitmap_header_size + dib_header_size;
 
 	uint32_t file_size = header_size + pixel_bytes;
 	uint32_t reserved = 0;
 
 	int32_t xres = width, yres = -height;
 	uint16_t planes = 0;
 	uint32_t compression = 0;
 	uint32_t xdpi = 0, ydpi = 0;
 	uint32_t palette = 0, important = 0;
 
 	// bitmap header
 	write(fd, "BM", 2);
 	write(fd, &file_size, sizeof file_size);
 	write(fd, &reserved, sizeof reserved);
 	write(fd, &header_size, sizeof header_size);
 
 	// dib header: BITMAPINFOHEADER
 	write(fd, &dib_header_size, sizeof dib_header_size);
 	write(fd, &xres, sizeof xres);
 	write(fd, &yres, sizeof yres);
 	write(fd, &planes, sizeof planes);
 	write(fd, &pixel_size, sizeof pixel_size);
 	write(fd, &compression, sizeof compression);
 	write(fd, &pixel_bytes, sizeof pixel_bytes);
 	write(fd, &xdpi, sizeof xdpi);
 	write(fd, &ydpi, sizeof ydpi);
 	write(fd, &palette, sizeof palette);
 	write(fd, &important, sizeof important);
 
 	// pixel data
 	write(fd, buf, pixel_bytes);
 }
 
 int
 main(int argc, char **argv)
 {
 	if (parse_opts(argc, argv, &opts) < 0) {
 		usage(argv[0]);
 		exit(EXIT_FAILURE);
 	}
 
 	if (opts.verbose) {
 		fprintf(stderr, "info: verbose: %d\n", opts.verbose);
 		if (opts.server_host && opts.server_port) {
 			fprintf(stderr, "info: server: %s:%s\n",
 					opts.server_host, opts.server_port);
 		}
 		fprintf(stderr, "info: resolution: %" PRIu64 "x%" PRIu64 "\n",
 				opts.xres, opts.yres);
 		fprintf(stderr, "info: max iters: %" PRIu64 "\n", opts.max_iters);
 		fprintf(stderr, "info: palette: %d\n", opts.palette);
 		fprintf(stderr, "info: output: %s\n", opts.outfile);
 	}
 
 	size_t pixels = opts.xres * opts.yres;
 
 	uint32_t *pixbuf = malloc(pixels * sizeof *pixbuf);
 	assert(pixbuf);
 
 	uint32_t *iterbuf = malloc(pixels * sizeof *iterbuf);
 	assert(iterbuf);
 
 	float *abs2buf = malloc(pixels * sizeof *abs2buf);
 	assert(abs2buf);
 
 	if (opts.server_host && opts.server_port) {
 		render_networked_mandelbrot(opts.server_host, opts.server_port,
 					    pixbuf, iterbuf, abs2buf,
 					    opts.xres, opts.yres, opts.max_iters,
 					    opts.palette);
 	} else {
 		render_mandelbrot(pixbuf, iterbuf, abs2buf,
 				  opts.xres, opts.yres, opts.max_iters,
 				  opts.palette);
 	}
 
 	int fd = creat(opts.outfile, 0644);
 	assert(fd > 0);
 
 	write_bitmap(fd, pixbuf, opts.xres, opts.yres);
 
 	close(fd);
 
 	exit(EXIT_SUCCESS);
 }