bingram

bingram.c (11554B)

#include "raylib.h"

#include <err.h>
#include <math.h>
#include <string.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>

#define CHUNK_SIZE 4096
#define ZOOM_MAX 64

#define MAX(a, b) ((a) > (b) ? (a) : (b))
#define MIN(a, b) ((a) > (b) ? (b) : (a))

const char *file_path;
uint8_t *file_data;
size_t data_len;
ssize_t data_width;
ssize_t data_height;

ssize_t data_window_start;
ssize_t data_window_len;

Color *value_colors;

Color *bigram_colors;
size_t *bigram_counts;

Color *trigram_colors;
size_t *trigram_counts;

int entropy_ctx;

int zoom;
double zoom_x, zoom_y;

int bar_width;
int bar_zoom;
ssize_t bar_start;
bool show_bar;

int window_width;
int window_height;
char *window_title;
bool show_pos;
bool show_trigram;

int mouse_x, mouse_y;

int  drag_mouse_x, drag_mouse_y;
double drag_zoom_x, drag_zoom_y;
bool drag;

uint64_t hold_times[337] = { 0 };

char fmtbuf[256];

void
usage(void)
{
	printf("Usage: bingram FILE\n");
	exit(0);
}

uint8_t *
read_file(const char *path, size_t *len)
{
	FILE *file;
	char *chunk;
	uint8_t *data;
	ssize_t nread;
	size_t cap;

	chunk = malloc(CHUNK_SIZE);
	if (!chunk) err(1, "malloc");

	file = fopen(file_path, "r");
	if (!file) err(1, "fopen");

	cap = 16 * 1024;
	data = malloc(cap);
	if (!data) err(1, "malloc");

	*len = 0;
	while ((nread = fread(chunk, 1, CHUNK_SIZE, file)) > 0) {
		if (*len + nread > cap) {
			cap *= 2;
			data = realloc(data, cap);
			if (!data) err(1, "realloc");
		}
		memcpy(data + *len, chunk, nread);
		*len += nread;
	}

	fclose(file);

	return data;
}

void
init_value_colors(Color *data_colors)
{
	size_t pos;
	Color c;

	c.a = 255;
	for (pos = 0; pos < data_len; pos++) {
		c.r = file_data[pos];
		c.g = file_data[pos];
		c.b = file_data[pos];
		data_colors[pos] = c;
	}
}

void
update_bigram_colors(void)
{
	ssize_t i, k, x, y;
	ssize_t max;
	double freq;
	Color c;

	max = -1;
	memset(bigram_counts, 0, sizeof(size_t) * 256 * 256);
	for (i = data_window_start; i < data_window_start + data_window_len - 1; i++) {
		x = file_data[i];
		y = file_data[i+1];
		bigram_counts[y * 256 + x] += 1;
		if (bigram_counts[y * 256 + x] > max || max == -1)
			max = bigram_counts[y * 256 + x];
	}

	c.a = 255;
	for (y = 0; y < 256; y++) {
		for (x = 0; x < 256; x++) {
			freq = MIN(bigram_counts[y * 256 + x] * 255.F / 4, 255);
			c.r = freq;
			c.g = freq;
			c.b = freq;
			bigram_colors[y * 256 + x] = c;
		}
	}
}

void
update_trigram_colors(void)
{
	memset(trigram_counts, 0, sizeof(size_t) * 256 * 256 * 256);
	memset(trigram_colors, 0, sizeof(Color) * 256 * 256 * 256);
}

void
center_zoom(void)
{
	if (show_bar) {
		zoom_x = -1.F * bar_width / zoom
			- (1.F * (window_width - bar_width)
				/ zoom - data_width) / 2.F;
	} else {
		zoom_x = -(1.F * window_width / zoom - data_width) / 2.F;
	}
	zoom_y = -(1.F * window_height / zoom - data_height) / 2.F;
}

bool
key_press_hold(int key)
{
	if (!IsKeyDown(key)) {
		hold_times[key] = 0;
		return false;
	}

	if (IsKeyPressed(key))
		return true;
	hold_times[key] += 1;

	return hold_times[key] > 10;
}

void
vis(void)
{
	Image window_image;
	int window_init_frames;
	size_t pos, len;
	double mouse_move;
	ssize_t data_x, data_y;
	size_t data_pos;
	bool data_update;
	size_t x, y;

	show_trigram = true;

	window_title = malloc(1024);
	if (!window_title) err(1, "malloc");
	snprintf(window_title, 1024, "bingram %s", file_path);

	SetConfigFlags(FLAG_WINDOW_RESIZABLE);
	SetTargetFPS(60);

	SetTraceLogLevel(LOG_NONE);

	InitWindow(800, 600, window_title);

	window_image = GenImageColor(800, 600, (Color) { 0 });

	zoom = 2;
	bar_zoom = 4;
	bar_start = 0;
	bar_width = MAX(80, window_width / 7);
	show_bar = true;

	data_width = 256;
	data_height = 256;
	data_window_start = 0;
	data_window_len = data_len;

	show_pos = false;

	show_trigram = false;
	data_update = true;
	window_init_frames = 2;
	while (!WindowShouldClose()) {
		if (IsKeyPressed(KEY_Q))
			break;

		if (window_init_frames || IsWindowResized() || IsKeyPressed(KEY_G)) {
			window_width = GetScreenWidth();
			window_height = GetScreenHeight();
			bar_width = MAX(80, window_width / 7);
			if (window_init_frames > 0) {
				data_window_len = MIN(data_len,
					MAX(window_width / 2 / zoom
						* window_height / 2 / zoom, 200));
				data_update = true;
			}
			if (IsKeyPressed(KEY_G))
				zoom = 2;
			center_zoom();
			ImageResize(&window_image, window_width, window_height);
			if (window_init_frames)
				window_init_frames -= 1;
		}

		mouse_x = MIN(MAX(0, GetMouseX()), window_width);
		mouse_y = MIN(MAX(0, GetMouseY()), window_height);

		if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) {
			drag_mouse_x = mouse_x;
			drag_mouse_y = mouse_y;
			drag_zoom_x = zoom_x;
			drag_zoom_y = zoom_y;
			drag = true;
		}else if (!IsMouseButtonDown(MOUSE_BUTTON_LEFT)) {
			drag = false;
		}

		if (drag && show_bar && drag_mouse_x < bar_width) {
			if (mouse_y > window_height - 20) {
				bar_start += bar_zoom * bar_width * 20;
			} else if (mouse_y < 20) {
				bar_start -= bar_zoom * bar_width * 20;
			}
			bar_start = MIN((ssize_t) data_len
				- bar_width * window_height * bar_zoom, bar_start);
			bar_start = MAX(0, bar_start);

			data_window_start = bar_start + (mouse_y * bar_width + mouse_x) * bar_zoom;
			data_window_start = MAX(0, MIN(
				(ssize_t) data_len - data_window_len,
				data_window_start - data_window_len / 2));
		} else if (drag) {
			zoom_x = drag_zoom_x - (mouse_x - drag_mouse_x) * 1.F / zoom;
			zoom_y = drag_zoom_y - (mouse_y - drag_mouse_y) * 1.F / zoom;
		}

		mouse_move = GetMouseWheelMove();
		if (show_bar && mouse_x < bar_width) {
			if (mouse_move > 0 && bar_zoom < ZOOM_MAX)
				bar_zoom *= 2;
			else if (mouse_move < 0 && bar_zoom > 1)
				bar_zoom /= 2;
		} else {
			if (mouse_move > 0 && zoom < ZOOM_MAX) {
				zoom_x += (1.F * window_width / zoom / 2)
					* (1.F * mouse_x / window_width);
				zoom_y += (1.F * window_height / zoom / 2)
					* (1.F * mouse_y / window_height);
				zoom *= 2;
			} else if (mouse_move < 0 && zoom > 1) {
				zoom_x -= (1.F * window_width / zoom)
					* (1.F * mouse_x / window_width);
				zoom_y -= (1.F * window_height / zoom)
					* (1.F * mouse_y / window_height);
				zoom /= 2;
			}
		}

		show_pos ^= IsKeyPressed(KEY_T);
		show_bar ^= IsKeyPressed(KEY_B);

		if (IsKeyDown(KEY_LEFT_CONTROL)) {
			if (key_press_hold(KEY_LEFT) || key_press_hold(KEY_A)) {
				data_window_start -= 4;
				data_update = true;
			} else if (key_press_hold(KEY_RIGHT) || key_press_hold(KEY_D)) {
				data_window_start += 4;
				data_update = true;
			}
			data_window_start = MAX(0, data_window_start);
		} else if (IsKeyDown(KEY_LEFT_ALT)) {
			len = MIN(data_window_len, bar_zoom * bar_width * 4);
			if (len % bar_width * bar_zoom)
				len += bar_width * bar_zoom - (len % bar_width * bar_zoom);
			if (key_press_hold(KEY_LEFT) || key_press_hold(KEY_A)) {
				data_window_start -= len;
				data_update = true;
			} else if (key_press_hold(KEY_RIGHT) || key_press_hold(KEY_D)) {
				data_window_start += len;
				data_update = true;
			}
			data_window_start = MIN(data_len - data_window_len,
				MAX(0, data_window_start));
			if (key_press_hold(KEY_UP) || key_press_hold(KEY_W)) {
				data_window_len -= len;
				data_update = true;
			} else if (key_press_hold(KEY_DOWN) || key_press_hold(KEY_S)) {
				data_window_len += len;
				data_update = true;
			}
			data_window_len = MIN(data_len - data_window_start,
				MAX(1, data_window_len));
		} else {
			if (key_press_hold(KEY_LEFT) || key_press_hold(KEY_A)) {
				zoom_x -= 20.F / zoom;
			} else if (key_press_hold(KEY_RIGHT) || key_press_hold(KEY_D)) {
				zoom_x += 20.F / zoom;
			}

			if (key_press_hold(KEY_UP) || key_press_hold(KEY_W)) {
				zoom_y -= 20.F / zoom;
			} else if (key_press_hold(KEY_DOWN) || key_press_hold(KEY_S)) {
				zoom_y += 20.F / zoom;
			}
		}

		if (IsKeyPressed(KEY_P))
			show_trigram = !show_trigram;

		if (data_update) {
			if (show_trigram)
				update_trigram_colors();
			else
				update_bigram_colors();
			data_update = false;
		}

		ImageClearBackground(&window_image, BLACK);

		for (y = 0; y < window_height; y++) {
			data_y = (ssize_t) (zoom_y) + (y / zoom);
			if (data_y < 0 || data_y >= data_height)
				continue;

			for (x = 0; x < window_width; x++) {
				data_x = (ssize_t) (zoom_x) + (x / zoom);
				if (data_x < 0 || data_x >= data_width)
					continue;

				data_pos = data_y * data_width + data_x;
				ImageDrawPixel(&window_image,
					x, y, bigram_colors[data_pos]);
			}
		}

		if (show_bar) {
			ImageDrawRectangle(&window_image,
				0, 0, bar_width, window_height, BLACK);
			ImageDrawRectangle(&window_image, bar_width, 0,
				3, window_height, BLACK);
			ImageDrawLine(&window_image, bar_width + 1, 0,
				bar_width + 1, window_height, GRAY);

			for (y = 0; y < window_height; y++) {
				for (x = 0; x < bar_width; x++) {
					data_pos = bar_start + (y * bar_width + x) * bar_zoom;
					if (data_pos < data_len) {
						ImageDrawPixel(&window_image,
							x, y, value_colors[data_pos]);
					}
				}
			}

			pos = (data_window_start - bar_start) / bar_width / bar_zoom;
			ImageDrawLine(&window_image, 0, pos,
				bar_width, pos, WHITE);

			pos = MIN(data_len, data_window_start + data_window_len);
			pos = (pos - bar_start) / bar_width / bar_zoom;
			ImageDrawLine(&window_image, 0, pos,
				bar_width, pos, WHITE);
		}

		if (show_pos) {
			snprintf(fmtbuf, sizeof(fmtbuf),
				"%08lx > %08lx", data_window_start,
				data_window_start + data_window_len);
			len = MeasureText(fmtbuf, 20) + 20;
			ImageDrawRectangle(&window_image,
				window_width - len - 9, 0,
				len + 9, 19, WHITE);
			ImageDrawText(&window_image,
				fmtbuf, window_width - len - 6,
				0, 20, BLACK);

			data_x = (ssize_t) zoom_x + (mouse_x / zoom);
			data_y = (ssize_t) zoom_y + (mouse_y / zoom);
			if (data_x >= 0 && data_x < data_width
					&& data_y >= 0 && data_y < data_height) {
				snprintf(fmtbuf, sizeof(fmtbuf),
					"%02lx > %02lx", data_x, data_y);
				len = MeasureText(fmtbuf, 20);
				ImageDrawRectangle(&window_image,
					window_width - len - 4, 19,
					len + 4, 19, WHITE);
				ImageDrawText(&window_image,
					fmtbuf, window_width - len - 1,
					20, 19, BLACK);
			}
		}

		Texture2D tex = LoadTextureFromImage(window_image);

		BeginDrawing();

		ClearBackground(BLACK);

		DrawTexture(tex, 0, 0, WHITE);

		EndDrawing();

		UnloadTexture(tex);
	}

	UnloadImage(window_image);

	CloseWindow();

	free(window_title);
}

int
main(int argc, const char **argv)
{
	const char **arg;

	file_path = NULL;
	entropy_ctx = 1;
	for (arg = argv + 1; *arg; arg++) {
		if (!strcmp("-c", *arg)) {
			arg += 1;
			if (!arg) usage();
			entropy_ctx = atoi(*arg);
			if (entropy_ctx <= 0) usage();
		} else if (!file_path) {
			file_path = *arg;
		} else {
			usage();
		}
	}

	if (!file_path)
		usage();

	if (!strcmp(file_path, "-"))
		file_path = "/dev/stdin";

	file_data = read_file(file_path, &data_len);

	value_colors = malloc(sizeof(Color) * data_len);
	if (!value_colors) err(1, "malloc");
	init_value_colors(value_colors);

	bigram_colors = malloc(sizeof(Color) * 256 * 256);
	if (!bigram_colors) err(1, "malloc");
	bigram_counts = malloc(sizeof(size_t) * 256 * 256);
	if (!bigram_counts) err(1, "malloc");

	trigram_colors = malloc(sizeof(Color) * 256 * 256 * 256);
	if (!trigram_colors) err(1, "malloc");
	trigram_counts = malloc(sizeof(size_t) * 256 * 256 * 256);
	if (!trigram_counts) err(1, "malloc");

	vis();

	free(trigram_counts);
	free(trigram_colors);

	free(bigram_counts);
	free(bigram_colors);

	free(value_colors);

	free(file_data);
}