path: root/src/e2e.c

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <math.h>
#include "e2e.h"

static uint16_t u16le(const char *src)
{
	uint8_t bytes[2];

	memcpy(bytes, src, 2);

	return (uint16_t)bytes[0]
	       + (((uint16_t)bytes[1]) << 8);
}

static uint32_t u32le(const char *src)
{
	uint8_t bytes[4];

	memcpy(bytes, src, 4);

	return (uint32_t)bytes[0]
	       + (((uint32_t)bytes[1]) << 8)
	       + (((uint32_t)bytes[2]) << 16)
	       + (((uint32_t)bytes[3]) << 24);
}

static int make_pointer(const struct e2e_data *data, const char *pos,
                        const char **out)
{
	uint32_t offs;

	offs = u32le(pos);

	if (!offs)
		*out = NULL;
	else {
		if (offs > data->end - data->start)
			return 1;

		*out = data->start + offs;
	}

	return 0;
}

#define HEADER_END 36

#define DIRECTORY_NUM_ENTRIES   36
#define DIRECTORY_CURRENT       40
#define DIRECTORY_NEXT          44
#define DIRECTORY_END          52

#define ENTRY_POS          0
#define ENTRY_START        4 
#define ENTRY_SIZE         8
#define ENTRY_PATIENT_ID   16
#define ENTRY_STUDY_ID     20
#define ENTRY_SERIES_ID    24
#define ENTRY_SLICE_ID     28
#define ENTRY_TYPE         36
#define ENTRY_END          44

#define CHUNK_POS          20
#define CHUNK_SIZE         24
#define CHUNK_PATIENT_ID   32
#define CHUNK_STUDY_ID     36
#define CHUNK_SERIES_ID    40
#define CHUNK_SLICE_ID     44
#define CHUNK_IND          48
#define CHUNK_TYPE         52
#define CHUNK_HEADER_END   60

#define IMAGE_SIZE      0
#define IMAGE_TYPE      4
#define IMAGE_WIDTH     12
#define IMAGE_HEIGHT    16
#define IMAGE_IMAGE     20

#define UF16_MANTISSA_MASK  ((1 << 11) - 1)  // 10 most significant bits
#define UF16_EXP_OFFSET -38 // FIXME: pure guess

static int read_fundus(struct e2e_data *data, const char *cursor,
                       struct e2e_image *image)
{
	// This cast is _technically_ illegal, but I can't think of a way in
	// which this would cause problems in practice.
	image->fundus = (const uint8_t*)cursor;

	return 0;
}

static int read_tomogram(struct e2e_data *data, const char *cursor,
                         struct e2e_image *image)
{
	image->tomogram = calloc(image->width * image->height, sizeof(float));
	if (!image->tomogram)
		return ENOMEM;

	for (size_t y = 0; y < image->height; y++)
	for (size_t x = 0; x < image->width; x++) {
		size_t i = y * image->width + x;
		uint16_t raw;
		int exp, man;

		raw = u16le(cursor + i * 2);
		man = raw & UF16_MANTISSA_MASK;
		exp = (raw & ~UF16_MANTISSA_MASK) >> 10;
		image->tomogram[i] = ldexpf(man, exp2f(exp + UF16_EXP_OFFSET));
	}

	return 0;
}

static int read_image(struct e2e_data *data, const char *cursor,
                      struct e2e_image *image)
{
	if (cursor + IMAGE_IMAGE > data->end) {
		fprintf(stderr, "Image data at %td ends past the end of file.\n",
		        cursor - data->start);
		return 1;
	}

	image->size = u32le(cursor + IMAGE_SIZE);
	image->type = u32le(cursor + IMAGE_TYPE);
	image->width = u32le(cursor + IMAGE_WIDTH);
	image->height = u32le(cursor + IMAGE_HEIGHT);
	cursor += IMAGE_IMAGE;

	switch (image->type) {
	case IMAGE_FUNDUS:
		return read_fundus(data, cursor, image);

	case IMAGE_TOMOGRAM:
		return read_tomogram(data, cursor, image);
	}

	return 0;
}

static int read_entry(struct e2e_data *data, const char *cursor,
                      struct e2e_entry *entry)
{
	const char *pos;
	struct e2e_chunk *chunk;

	if (cursor + ENTRY_END > data->end) {
		fprintf(stderr, "Entry at %td data->ends past the data->end of file.\n",
		        cursor - data->start);
		return 1;
	}

	if (make_pointer(data, cursor + ENTRY_POS, &pos)) {
		fprintf(stderr, "Entry at %td has a bad 'pos' entry.\n",
		        cursor - data->start);
		return 1;
	}

	if (pos != cursor) {
		fprintf(stderr, "Entry at %td has a 'pos' entry that differs from the entry's actual position",
		        cursor - data->start);
		return 1;
	}

	if (make_pointer(data, cursor + ENTRY_START, &entry->start)) {
		fprintf(stderr, "Entry at %td has a bad 'data->start' entry.\n",
		        cursor - data->start);
		return 1;
	}

	entry->size = u32le(cursor + ENTRY_SIZE);
	entry->patient_id = u32le(cursor + ENTRY_PATIENT_ID);
	entry->study_id = u32le(cursor + ENTRY_STUDY_ID);
	entry->series_id = u32le(cursor + ENTRY_SERIES_ID);
	entry->slice_id = u32le(cursor + ENTRY_SLICE_ID);
	entry->type = u32le(cursor + ENTRY_TYPE);

	if (!entry->start || entry->start < data->start + HEADER_END)
		return 0;

	cursor = entry->start;
	chunk = &entry->chunk;
	entry->has_chunk = 1;

	chunk->entry = entry;
	chunk->origin = cursor;

	if (cursor + CHUNK_HEADER_END > data->end) {
		fprintf(stderr, "Chunk at %td ends past the end of file.\n",
		        cursor - data->start);
		return 1;
	}

	if (make_pointer(data, cursor + CHUNK_POS, &pos)) {
		fprintf(stderr, "Chunk at %td has a bad 'pos' entry.\n",
		        cursor - data->start);
		return 1;
	}

	if (pos != cursor) {
		fprintf(stderr, "Chunk at %td has a 'pos' entry that differs from the entry's actual position.\n",
		        cursor - data->start);
		return 1;
	}

	chunk->size = u32le(cursor + CHUNK_SIZE);
	chunk->patient_id = u32le(cursor + CHUNK_PATIENT_ID);
	chunk->study_id = u32le(cursor + CHUNK_STUDY_ID);
	chunk->series_id = u32le(cursor + CHUNK_SERIES_ID);
	chunk->slice_id = u32le(cursor + CHUNK_SLICE_ID);
	chunk->type = u32le(cursor + CHUNK_TYPE);
	cursor += CHUNK_HEADER_END;

	switch (chunk->type) {
	case CHUNK_IMAGE:
		return read_image(data, cursor, &chunk->image);
	}

	return 0;
}

static int read_directory(struct e2e_data *data, const char *cursor,
                          struct e2e_directory *dir)
{
	if (cursor + DIRECTORY_END > data->end) {
		fprintf(stderr, "Directory at %td data->ends past the data->end of file.\n",
		        cursor - data->start);
		return 1;
	}

	dir->num_entries = u32le(cursor + DIRECTORY_NUM_ENTRIES);

	if (make_pointer(data, cursor + DIRECTORY_CURRENT, &dir->current))  {
		fprintf(stderr, "Directory at %td contains a bad 'current' field.\n",
		        cursor - data->start);
		return 1;
	}

	if (make_pointer(data, cursor + DIRECTORY_NEXT, &dir->next))  {
		fprintf(stderr, "Directory at %td contains a bad 'current' field.\n",
		        cursor - data->start);
		return 1;
	}

	return 0;
}

// Because entries are a part of a larger array in e2e_data, they're freed
// all at once by e2e_destroy and not here.
void e2e_entry_destroy(struct e2e_entry *entry)
{
	if (entry->has_chunk
	    && entry->chunk.type == CHUNK_IMAGE
	    && entry->chunk.image.type == IMAGE_TOMOGRAM)
		free(entry->chunk.image.tomogram);
}

void e2e_destroy(struct e2e_data *data)
{
	struct e2e_directory *dir, *next;

	for (dir = data->dirs; dir; dir = next) {
		next = dir->data_list.next;

		for (size_t i = 0; i < dir->num_entries; i++)
			e2e_entry_destroy(dir->entries + i);
		free(dir->entries);
		free(dir);
	}
}

int e2e_read(struct e2e_data *data, const char *start, const char *end)
{
	int rv = 0;
	const char *cursor;

	data->start = start;
	data->end = end;
	data->dirs = NULL;

	if (start + HEADER_END > end) {
		fprintf(stderr, "File too short to be an E2E file.\n");
		return 1;
	}

	// TODO: verify the header

	cursor = start + HEADER_END;
	cursor += DIRECTORY_END; // skip the first directory (wtf?)

	while (cursor) {
		struct e2e_directory *dir;
		size_t i;

		dir = malloc(sizeof(struct e2e_directory));
		if (!dir) {
			rv = ENOMEM;
			goto error;
		}

		rv = read_directory(data, cursor, dir);
		if (rv)
			goto error_read_directory;

		dir->entries = calloc(dir->num_entries, sizeof(struct e2e_entry));
		if (!dir->entries) {
			rv = ENOMEM;
			goto error_alloc_entries;
		}

		for (i = 0; i < dir->num_entries; i++) {
			const char *entry_cursor;
			struct e2e_entry *entry = dir->entries + i;

			entry_cursor = cursor + DIRECTORY_END + i * ENTRY_END;
			rv = read_entry(data, entry_cursor, entry);
			if (rv)
				goto error_read_entry;
		}

		eli_append(&data->dirs, dir, data_list);
		cursor = dir->next;
		continue;


	error_read_entry:
		for (size_t j = 0; j < i; j++)
			e2e_entry_destroy(dir->entries + j);
		free(dir->entries);
	error_alloc_entries:
	error_read_directory:
		free(dir);
		goto error;
	}

	return 0;

error:
	e2e_destroy(data);
	return rv;
}