ntrop

ntrop.c (11911B)

#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))

enum { PRESS = 1, HOLD };

const char *file_path;
uint8_t *file_data;
ssize_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 *entropy_colors;

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_value;

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: ntrop [-c CTX] FILE\n");
	exit(0);
}

uint8_t *
read_file(const char *path, ssize_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
init_entropy_colors(Color *data_colors)
{
	ssize_t i, k, pos, uniq;
	uint8_t *vals;
	size_t *counts;
	size_t ctx_count;
	double entropy;
	Color c;

	vals = malloc(entropy_ctx * 2 + 1);
	if (!vals) err(1, "malloc");

	counts = malloc(sizeof(size_t) * (entropy_ctx * 2 + 1));
	if (!counts) err(1, "malloc");

	c.a = 255;
	for (pos = 0; pos < data_len; pos++) {
		uniq = 0;
		ctx_count = 0;
		for (i = -entropy_ctx; i <= entropy_ctx; i++) {
			if (pos + i < 0 || pos + i > data_len)
				continue;
			for (k = 0; k < uniq; k++) {
				if (vals[k] == file_data[pos + i]) {
					counts[k] += 1;
					break;
				}
			}
			if (k == uniq) {
				counts[uniq] = 1;
				vals[uniq] = file_data[pos + i];
				uniq += 1;
			}
			ctx_count++;
		}
		entropy = 0;
		for (k = 0; k < uniq; k++) {
			entropy += - 1.F * counts[k] / ctx_count
				* log2(1.F * counts[k] / ctx_count);
		}
		entropy /= - 1.F * log2(1.F / ctx_count);
		entropy *= 255;
		c.r = file_data[pos];
		c.g = 0;
		c.b = entropy;
		data_colors[pos] = c;
	}

	free(vals);
	free(counts);
}

int
key_press_hold(int cnt, ...)
{
	va_list ap;
	int i, key;

	va_start(ap, cnt);
	for (i = 0; i < cnt; i++) {
		key = va_arg(ap, int);

		if (!IsKeyDown(key)) {
			hold_times[key] = 0;
			continue;
		}

		if (IsKeyPressed(key))
			return PRESS;

		hold_times[key] += 1;
		if (hold_times[key] > 10)
			return HOLD;
	}

	return 0;
}

void
update_data_window_start(void)
{
	ssize_t len;

	len = data_len - data_window_len;
	if (len % data_width)
		len += data_width - (len % data_width);
	data_window_start = MAX(0, MIN(len, data_window_start));
}

void
update_data_window_len(void)
{
	update_data_window_start();
	data_window_len = MIN(data_len - data_window_start, data_window_len);
	data_window_len = MAX(0, data_window_len);
	data_height = data_window_len / data_width;

	zoom_y = (data_height - 1.F * window_height / zoom) / 2.F;
}

void
update_data_width(void)
{

	data_width = MAX(1, data_width);
	update_data_window_len();

	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;
	}
}

void
vis(void)
{
	Color *data_colors;
	Image window_image;
	int window_init_frames;
	ssize_t pos, len;
	double mouse_move;
	ssize_t data_x, data_y;
	ssize_t data_pos;
	ssize_t x, y;
	int b;

	data_colors = value_colors;
	show_value = true;

	window_title = malloc(1024);
	if (!window_title) err(1, "malloc");
	snprintf(window_title, 1024, "ntrop %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_window_start = 0;
	data_window_len = data_len;

	show_pos = false;

	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_width = MAX(1, MIN(data_len,
					(window_width - bar_width) / zoom / 2));
				data_window_len = MIN(data_len,
					MAX(window_width / 2 / zoom
						* window_height / 2 / zoom, 200));
				data_height = data_window_len / data_width
					+ !!(data_window_len % data_width);
			}
			if (IsKeyPressed(KEY_G))
				zoom = 2;
			update_data_width();
			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 = MAX(0, MIN(data_len - bar_width
				* window_height * bar_zoom, bar_start));

			data_window_start = bar_start + (mouse_y * bar_width + mouse_x) * bar_zoom;
			data_window_start = MAX(0, MIN(data_len - data_window_len,
				data_window_start - data_window_len / 2));
			update_data_window_start();
		} 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 (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_SHIFT)) {
			if ((b = key_press_hold(2, KEY_LEFT, KEY_A))) {
				data_width -= IsKeyDown(KEY_LEFT_ALT) ? 5 : 1;
				update_data_width();
			} else if ((b = key_press_hold(2, KEY_RIGHT, KEY_D))) {
				data_width += IsKeyDown(KEY_LEFT_ALT) ? 5 : 1;
				update_data_width();
			}
		} else if (IsKeyDown(KEY_LEFT_ALT)) {
			if ((b = key_press_hold(2, KEY_LEFT, KEY_A))) {
				data_window_start -= data_width
					* (b == HOLD ? 8 : 1);
				update_data_window_start();
			} else if ((b = key_press_hold(2, KEY_RIGHT, KEY_D))) {
				data_window_start += data_width
					* (b == HOLD ? 8 : 1);
				update_data_window_start();
			}
			if ((b = key_press_hold(2, KEY_UP, KEY_W))) {
				data_window_len -= data_width
					* (b == HOLD ? 8 : 1);
				update_data_window_len();
			} else if ((b = key_press_hold(2, KEY_DOWN, KEY_S))) {
				data_window_len += data_width
					* (b == HOLD ? 8 : 1);
				update_data_window_len();
			}
		} else {
			if (key_press_hold(2, KEY_LEFT, KEY_A)) {
				zoom_x -= 20.F / zoom;
			} else if (key_press_hold(2, KEY_RIGHT, KEY_D)) {
				zoom_x += 20.F / zoom;
			}

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

		
		if (IsKeyPressed(KEY_P)) {
			show_value = !show_value;
			if (show_value)
				data_colors = value_colors;
			else
				data_colors = entropy_colors;
		}

		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;
				data_pos += data_window_start;
				len = data_window_start + data_window_len;
				if (len % window_width)
					len += window_width - (len % window_width);
				if (data_pos < len && data_pos < data_len) {
					ImageDrawPixel(&window_image,
						x, y, data_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) {
			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) {
				pos = data_window_start + data_y * data_width + data_x;
				snprintf(fmtbuf, sizeof(fmtbuf), "%08lx", pos);
				len = MeasureText(fmtbuf, 20) + 10;
				ImageDrawRectangle(&window_image,
					window_width - len - 9, 0,
					len + 9, 19, WHITE);
				ImageDrawText(&window_image,
					fmtbuf, window_width - len - 6,
					0, 20, BLACK);
				if (pos < data_len) {
					snprintf(fmtbuf, sizeof(fmtbuf), "%02x",
						file_data[pos]);
					len = MeasureText(fmtbuf, 20);
					ImageDrawRectangle(&window_image,
						window_width - len - 6, 19,
						len + 6, 19, WHITE);
					ImageDrawText(&window_image,
						fmtbuf, window_width - len - 3,
						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 = 32;
	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);

	entropy_colors = malloc(sizeof(Color) * data_len);
	if (!entropy_colors) err(1, "malloc");
	init_entropy_colors(entropy_colors);

	vis();

	free(value_colors);
	free(entropy_colors);

	free(file_data);
}