#include "HrtfData.h"
#include "Endianness.h"
#include <algorithm>
#include <cassert>
#include <cmath>

typedef struct {
	uint8_t bytes[3];
} sample_int24_t;

const double pi = 3.1415926535897932385;

template <typename T>
void read_stream(std::istream& stream, T& value) {
	stream.read(reinterpret_cast<std::istream::char_type*>(&value), sizeof(value));
	from_little_endian_inplace(value);
}

HrtfData::HrtfData(std::istream& stream) {
	const char required_magic00[] = { 'M', 'i', 'n', 'P', 'H', 'R', '0', '0' };
	const char required_magic01[] = { 'M', 'i', 'n', 'P', 'H', 'R', '0', '1' };
	const char required_magic02[] = { 'M', 'i', 'n', 'P', 'H', 'R', '0', '2' };
	const char required_magic03[] = { 'M', 'i', 'n', 'P', 'H', 'R', '0', '3' };
	char actual_magic[sizeof(required_magic03) / sizeof(required_magic03[0])];

	stream.read(actual_magic, sizeof(actual_magic));
	if(std::equal(std::begin(required_magic03), std::end(required_magic03), std::begin(actual_magic), std::end(actual_magic))) {
		LoadHrtf03(stream);
	} else if(std::equal(std::begin(required_magic02), std::end(required_magic02), std::begin(actual_magic), std::end(actual_magic))) {
		LoadHrtf02(stream);
	} else if(std::equal(std::begin(required_magic01), std::end(required_magic01), std::begin(actual_magic), std::end(actual_magic))) {
		LoadHrtf01(stream);
	} else if(std::equal(std::begin(required_magic00), std::end(required_magic00), std::begin(actual_magic), std::end(actual_magic))) {
		LoadHrtf00(stream);
	} else {
		throw std::logic_error("Bad file format.");
	}
}

void HrtfData::LoadHrtf03(std::istream& stream) {
	// const uint8_t ChanType_LeftOnly{0};
	const uint8_t ChanType_LeftRight{ 1 };

	uint32_t sample_rate;
	uint8_t channel_type;
	uint8_t impulse_response_length;
	uint8_t distances_count;

	read_stream(stream, sample_rate);
	read_stream(stream, channel_type);
	read_stream(stream, impulse_response_length);
	read_stream(stream, distances_count);

	if(!stream || stream.eof()) {
		throw std::logic_error("Failed reading file.");
	}

	if(channel_type > ChanType_LeftRight) {
		throw std::logic_error("Invalid channel format.");
	}

	int channel_count = channel_type == ChanType_LeftRight ? 2 : 1;

	std::vector<DistanceData> distances(distances_count);

	for(uint8_t i = 0; i < distances_count; i++) {
		uint16_t distance;
		read_stream(stream, distance);
		distances[i].distance = float(distance) / 1000.0f;

		uint8_t elevations_count;
		read_stream(stream, elevations_count);
		distances[i].elevations.resize(elevations_count);

		if(!stream || stream.eof()) {
			throw std::logic_error("Failed reading file.");
		}

		for(uint8_t j = 0; j < elevations_count; j++) {
			uint8_t azimuth_count;
			read_stream(stream, azimuth_count);
			distances[i].elevations[j].azimuths.resize(azimuth_count);
		}

		if(!stream || stream.eof()) {
			throw std::logic_error("Failed reading file.");
		}
	}

	const float normalization_factor = 1.0f / 8388608.0f;

	for(auto& distance : distances) {
		for(auto& elevation : distance.elevations) {
			for(auto& azimuth : elevation.azimuths) {
				azimuth.impulse_response.resize(impulse_response_length * channel_count);
				for(auto& sample : azimuth.impulse_response) {
					union {
						sample_int24_t sample;
						int32_t sample_int;
					} sample_union;
					sample_union.sample_int = 0;
					read_stream(stream, sample_union.sample);
					sample_union.sample_int <<= 8;
					sample_union.sample_int >>= 8;
					sample = sample_union.sample_int * normalization_factor;
				}
			}
		}
	}

	if(!stream || stream.eof()) {
		throw std::logic_error("Failed reading file.");
	}

	uint8_t longest_delay = 0;
	for(auto& distance : distances) {
		for(auto& elevation : distance.elevations) {
			for(auto& azimuth : elevation.azimuths) {
				uint8_t delay;
				read_stream(stream, delay);
				azimuth.delay = delay;
				longest_delay = std::max(longest_delay, delay);
				if(channel_type == ChanType_LeftRight) {
					read_stream(stream, delay);
					azimuth.delay_right = delay;
					longest_delay = std::max(longest_delay, delay);
				}
			}
		}
	}

	if(!stream || stream.eof()) {
		throw std::logic_error("Failed reading file.");
	}

	std::sort(distances.begin(), distances.end(),
	          [](const DistanceData& lhs, const DistanceData& rhs) noexcept { return lhs.distance > rhs.distance; });

	m_distances = std::move(distances);
	m_channel_count = channel_count;
	m_response_length = impulse_response_length;
	m_sample_rate = sample_rate;
	m_longest_delay = longest_delay;
}

void HrtfData::LoadHrtf02(std::istream& stream) {
	// const uint8_t SampleType_S16{0};
	const uint8_t SampleType_S24{ 1 };
	// const uint8_t ChanType_LeftOnly{0};
	const uint8_t ChanType_LeftRight{ 1 };

	uint32_t sample_rate;
	uint8_t sample_type;
	uint8_t channel_type;
	uint8_t impulse_response_length;
	uint8_t distances_count;

	read_stream(stream, sample_rate);
	read_stream(stream, sample_type);
	read_stream(stream, channel_type);
	read_stream(stream, impulse_response_length);
	read_stream(stream, distances_count);

	if(!stream || stream.eof()) {
		throw std::logic_error("Failed reading file.");
	}

	if(sample_type > SampleType_S24) {
		throw std::logic_error("Invalid sample type.");
	}

	if(channel_type > ChanType_LeftRight) {
		throw std::logic_error("Invalid channel format.");
	}

	int channel_count = channel_type == ChanType_LeftRight ? 2 : 1;

	std::vector<DistanceData> distances(distances_count);

	for(uint8_t i = 0; i < distances_count; i++) {
		uint16_t distance;
		read_stream(stream, distance);
		distances[i].distance = float(distance) / 1000.0f;

		uint8_t elevations_count;
		read_stream(stream, elevations_count);
		distances[i].elevations.resize(elevations_count);

		if(!stream || stream.eof()) {
			throw std::logic_error("Failed reading file.");
		}

		for(uint8_t j = 0; j < elevations_count; j++) {
			uint8_t azimuth_count;
			read_stream(stream, azimuth_count);
			distances[i].elevations[j].azimuths.resize(azimuth_count);
		}

		if(!stream || stream.eof()) {
			throw std::logic_error("Failed reading file.");
		}
	}

	const float normalization_factor = (sample_type == SampleType_S24) ? 1.0f / 8388608.0f : 1.0f / 32768.0f;

	for(auto& distance : distances) {
		for(auto& elevation : distance.elevations) {
			for(auto& azimuth : elevation.azimuths) {
				azimuth.impulse_response.resize(impulse_response_length * channel_count);
				if(sample_type == SampleType_S24) {
					for(auto& sample : azimuth.impulse_response) {
						union {
							sample_int24_t sample;
							int32_t sample_int;
						} sample_union;
						sample_union.sample_int = 0;
						read_stream(stream, sample_union.sample);
						sample_union.sample_int <<= 8;
						sample_union.sample_int >>= 8;
						sample = sample_union.sample_int * normalization_factor;
					}
				} else {
					for(auto& sample : azimuth.impulse_response) {
						int16_t sample_from_file;
						read_stream(stream, sample_from_file);
						sample = sample_from_file * normalization_factor;
					}
				}
			}
		}
	}

	if(!stream || stream.eof()) {
		throw std::logic_error("Failed reading file.");
	}

	uint8_t longest_delay = 0;
	for(auto& distance : distances) {
		for(auto& elevation : distance.elevations) {
			for(auto& azimuth : elevation.azimuths) {
				uint8_t delay;
				read_stream(stream, delay);
				azimuth.delay = delay;
				longest_delay = std::max(longest_delay, delay);
				if(channel_type == ChanType_LeftRight) {
					read_stream(stream, delay);
					azimuth.delay_right = delay;
					longest_delay = std::max(longest_delay, delay);
				}
			}
		}
	}

	if(!stream || stream.eof()) {
		throw std::logic_error("Failed reading file.");
	}

	std::sort(distances.begin(), distances.end(),
	          [](const DistanceData& lhs, const DistanceData& rhs) noexcept { return lhs.distance > rhs.distance; });

	m_distances = std::move(distances);
	m_channel_count = channel_count;
	m_response_length = impulse_response_length;
	m_sample_rate = sample_rate;
	m_longest_delay = longest_delay;
}

void HrtfData::LoadHrtf01(std::istream& stream) {
	uint32_t sample_rate;
	uint8_t impulse_response_length;

	read_stream(stream, sample_rate);
	read_stream(stream, impulse_response_length);

	if(!stream || stream.eof()) {
		throw std::logic_error("Failed reading file.");
	}

	std::vector<DistanceData> distances(1);

	distances[0].distance = 1.0;

	uint8_t elevations_count;
	read_stream(stream, elevations_count);
	distances[0].elevations.resize(elevations_count);

	if(!stream || stream.eof()) {
		throw std::logic_error("Failed reading file.");
	}

	for(uint8_t i = 0; i < elevations_count; i++) {
		uint8_t azimuth_count;
		read_stream(stream, azimuth_count);
		distances[0].elevations[i].azimuths.resize(azimuth_count);
	}

	if(!stream || stream.eof()) {
		throw std::logic_error("Failed reading file.");
	}

	const float normalization_factor = 1.0f / 32768.0f;

	for(auto& elevation : distances[0].elevations) {
		for(auto& azimuth : elevation.azimuths) {
			azimuth.impulse_response.resize(impulse_response_length);
			for(auto& sample : azimuth.impulse_response) {
				int16_t sample_from_file;
				read_stream(stream, sample_from_file);
				sample = sample_from_file * normalization_factor;
			}
		}
	}

	if(!stream || stream.eof()) {
		throw std::logic_error("Failed reading file.");
	}

	uint8_t longest_delay = 0;
	for(auto& elevation : distances[0].elevations) {
		for(auto& azimuth : elevation.azimuths) {
			uint8_t delay;
			read_stream(stream, delay);
			delay <<= 2;
			azimuth.delay = delay;
			longest_delay = std::max(longest_delay, delay);
		}
	}

	if(!stream || stream.eof()) {
		throw std::logic_error("Failed reading file.");
	}

	m_distances = std::move(distances);
	m_channel_count = 1;
	m_response_length = impulse_response_length;
	m_sample_rate = sample_rate;
	m_longest_delay = longest_delay;
}

void HrtfData::LoadHrtf00(std::istream& stream) {
	uint32_t sample_rate;
	uint16_t impulse_response_count;
	uint16_t impulse_response_length;

	read_stream(stream, sample_rate);
	read_stream(stream, impulse_response_count);
	read_stream(stream, impulse_response_length);

	if(!stream || stream.eof()) {
		throw std::logic_error("Failed reading file.");
	}

	std::vector<DistanceData> distances(1);

	distances[0].distance = 1.0;

	uint8_t elevations_count;
	read_stream(stream, elevations_count);
	distances[0].elevations.resize(elevations_count);

	if(!stream || stream.eof()) {
		throw std::logic_error("Failed reading file.");
	}

	std::vector<uint16_t> irOffsets(elevations_count);

	for(uint8_t i = 0; i < elevations_count; i++) {
		read_stream(stream, irOffsets[i]);
	}

	if(!stream || stream.eof()) {
		throw std::logic_error("Failed reading file.");
	}

	for(size_t i = 1; i < elevations_count; i++) {
		if(irOffsets[i] <= irOffsets[i - 1]) {
			throw std::logic_error("Invalid elevation offset.");
		}
	}
	if(impulse_response_count <= irOffsets[elevations_count - 1]) {
		throw std::logic_error("Invalid elevation offset.");
	}

	for(size_t i = 1; i < elevations_count; i++) {
		distances[0].elevations[i - 1].azimuths.resize(irOffsets[i] - irOffsets[i - 1]);
	}
	distances[0].elevations[elevations_count - 1].azimuths.resize(impulse_response_count - irOffsets[elevations_count - 1]);

	const float normalization_factor = 1.0f / 32768.0f;

	for(auto& elevation : distances[0].elevations) {
		for(auto& azimuth : elevation.azimuths) {
			azimuth.impulse_response.resize(impulse_response_length);
			for(auto& sample : azimuth.impulse_response) {
				int16_t sample_from_file;
				read_stream(stream, sample_from_file);
				sample = sample_from_file * normalization_factor;
			}
		}
	}

	if(!stream || stream.eof()) {
		throw std::logic_error("Failed reading file.");
	}

	uint8_t longest_delay = 0;
	for(auto& elevation : distances[0].elevations) {
		for(auto& azimuth : elevation.azimuths) {
			uint8_t delay;
			read_stream(stream, delay);
			delay <<= 2;
			azimuth.delay = delay;
			longest_delay = std::max(longest_delay, delay);
		}
	}

	if(!stream || stream.eof()) {
		throw std::logic_error("Failed reading file.");
	}

	m_distances = std::move(distances);
	m_channel_count = 1;
	m_response_length = impulse_response_length;
	m_sample_rate = sample_rate;
	m_longest_delay = longest_delay;
}

void HrtfData::get_direction_data(angle_t elevation, angle_t azimuth, distance_t distance, uint32_t channel, DirectionData& ref_data) const {
	assert(elevation >= -angle_t(pi * 0.5));
	assert(elevation <= angle_t(pi * 0.5));
	assert(azimuth >= -angle_t(2.0 * pi));
	assert(azimuth <= angle_t(2.0 * pi));

	const float azimuth_mod = std::fmod(azimuth + angle_t(pi * 2.0), angle_t(pi * 2.0));

	size_t distance_index0 = 0;
	while(distance_index0 < m_distances.size() - 1 &&
	      m_distances[distance_index0].distance > distance) {
		distance_index0++;
	}
	const size_t distance_index1 = std::min(distance_index0 + 1, m_distances.size() - 1);
	const distance_t distance0 = m_distances[distance_index0].distance;
	const distance_t distance1 = m_distances[distance_index1].distance;
	const distance_t distance_delta = distance0 - distance1;
	const float distance_fractional_part = distance_delta ? (distance - distance1) / distance_delta : 0;

	const auto& elevations0 = m_distances[distance_index0].elevations;
	const auto& elevations1 = m_distances[distance_index1].elevations;

	const angle_t elevation_scaled0 = (elevation + angle_t(pi * 0.5)) * (elevations0.size() - 1) / angle_t(pi);
	const angle_t elevation_scaled1 = (elevation + angle_t(pi * 0.5)) * (elevations1.size() - 1) / angle_t(pi);
	const size_t elevation_index00 = static_cast<size_t>(elevation_scaled0);
	const size_t elevation_index10 = static_cast<size_t>(elevation_scaled1);
	const size_t elevation_index01 = std::min(elevation_index00 + 1, elevations0.size() - 1);
	const size_t elevation_index11 = std::min(elevation_index10 + 1, elevations1.size() - 1);

	const float elevation_fractional_part0 = std::fmod(elevation_scaled0, 1.0);
	const float elevation_fractional_part1 = std::fmod(elevation_scaled1, 1.0);

	const angle_t azimuth_scaled00 = azimuth_mod * elevations0[elevation_index00].azimuths.size() / angle_t(2 * pi);
	const size_t azimuth_index000 = static_cast<size_t>(azimuth_scaled00) % elevations0[elevation_index00].azimuths.size();
	const size_t azimuth_index001 = static_cast<size_t>(azimuth_scaled00 + 1) % elevations0[elevation_index00].azimuths.size();
	const float azimuth_fractional_part00 = std::fmod(azimuth_scaled00, 1.0);

	const angle_t azimuth_scaled10 = azimuth_mod * elevations1[elevation_index10].azimuths.size() / angle_t(2 * pi);
	const size_t azimuth_index100 = static_cast<size_t>(azimuth_scaled10) % elevations1[elevation_index10].azimuths.size();
	const size_t azimuth_index101 = static_cast<size_t>(azimuth_scaled10 + 1) % elevations1[elevation_index10].azimuths.size();
	const float azimuth_fractional_part10 = std::fmod(azimuth_scaled10, 1.0);

	const angle_t azimuth_scaled01 = azimuth_mod * elevations0[elevation_index01].azimuths.size() / angle_t(2 * pi);
	const size_t azimuth_index010 = static_cast<size_t>(azimuth_scaled01) % elevations0[elevation_index01].azimuths.size();
	const size_t azimuth_index011 = static_cast<size_t>(azimuth_scaled01 + 1) % elevations0[elevation_index01].azimuths.size();
	const float azimuth_fractional_part01 = std::fmod(azimuth_scaled01, 1.0);

	const angle_t azimuth_scaled11 = azimuth_mod * elevations1[elevation_index11].azimuths.size() / angle_t(2 * pi);
	const size_t azimuth_index110 = static_cast<size_t>(azimuth_scaled11) % elevations1[elevation_index11].azimuths.size();
	const size_t azimuth_index111 = static_cast<size_t>(azimuth_scaled11 + 1) % elevations1[elevation_index11].azimuths.size();
	const float azimuth_fractional_part11 = std::fmod(azimuth_scaled11, 1.0);

	const float blend_factor_000 = (1.0f - elevation_fractional_part0) * (1.0f - azimuth_fractional_part00) * distance_fractional_part;
	const float blend_factor_001 = (1.0f - elevation_fractional_part0) * azimuth_fractional_part00 * distance_fractional_part;
	const float blend_factor_010 = elevation_fractional_part0 * (1.0f - azimuth_fractional_part01) * distance_fractional_part;
	const float blend_factor_011 = elevation_fractional_part0 * azimuth_fractional_part01 * distance_fractional_part;

	const float blend_factor_100 = (1.0f - elevation_fractional_part1) * (1.0f - azimuth_fractional_part10) * (1.0f - distance_fractional_part);
	const float blend_factor_101 = (1.0f - elevation_fractional_part1) * azimuth_fractional_part10 * (1.0f - distance_fractional_part);
	const float blend_factor_110 = elevation_fractional_part1 * (1.0f - azimuth_fractional_part11) * (1.0f - distance_fractional_part);
	const float blend_factor_111 = elevation_fractional_part1 * azimuth_fractional_part11 * (1.0f - distance_fractional_part);

	delay_t delay0;
	delay_t delay1;

	if(channel == 0) {
		delay0 =
		elevations0[elevation_index00].azimuths[azimuth_index000].delay * blend_factor_000 + elevations0[elevation_index00].azimuths[azimuth_index001].delay * blend_factor_001 + elevations0[elevation_index01].azimuths[azimuth_index010].delay * blend_factor_010 + elevations0[elevation_index01].azimuths[azimuth_index011].delay * blend_factor_011;

		delay1 =
		elevations1[elevation_index10].azimuths[azimuth_index100].delay * blend_factor_100 + elevations1[elevation_index10].azimuths[azimuth_index101].delay * blend_factor_101 + elevations1[elevation_index11].azimuths[azimuth_index110].delay * blend_factor_110 + elevations1[elevation_index11].azimuths[azimuth_index111].delay * blend_factor_111;
	} else {
		delay0 =
		elevations0[elevation_index00].azimuths[azimuth_index000].delay_right * blend_factor_000 + elevations0[elevation_index00].azimuths[azimuth_index001].delay_right * blend_factor_001 + elevations0[elevation_index01].azimuths[azimuth_index010].delay_right * blend_factor_010 + elevations0[elevation_index01].azimuths[azimuth_index011].delay_right * blend_factor_011;

		delay1 =
		elevations1[elevation_index10].azimuths[azimuth_index100].delay_right * blend_factor_100 + elevations1[elevation_index10].azimuths[azimuth_index101].delay_right * blend_factor_101 + elevations1[elevation_index11].azimuths[azimuth_index110].delay_right * blend_factor_110 + elevations1[elevation_index11].azimuths[azimuth_index111].delay_right * blend_factor_111;
	}

	ref_data.delay = delay0 + delay1;

	if(ref_data.impulse_response.size() < m_response_length)
		ref_data.impulse_response.resize(m_response_length);

	for(size_t i = 0, j = channel; i < m_response_length; i++, j += m_channel_count) {
		float sample0 =
		elevations0[elevation_index00].azimuths[azimuth_index000].impulse_response[j] * blend_factor_000 + elevations0[elevation_index00].azimuths[azimuth_index001].impulse_response[j] * blend_factor_001 + elevations0[elevation_index01].azimuths[azimuth_index010].impulse_response[j] * blend_factor_010 + elevations0[elevation_index01].azimuths[azimuth_index011].impulse_response[j] * blend_factor_011;
		float sample1 =
		elevations1[elevation_index10].azimuths[azimuth_index100].impulse_response[j] * blend_factor_100 + elevations1[elevation_index10].azimuths[azimuth_index101].impulse_response[j] * blend_factor_101 + elevations1[elevation_index11].azimuths[azimuth_index110].impulse_response[j] * blend_factor_110 + elevations1[elevation_index11].azimuths[azimuth_index111].impulse_response[j] * blend_factor_111;

		ref_data.impulse_response[i] = sample0 + sample1;
	}
}

void HrtfData::get_direction_data(angle_t elevation, angle_t azimuth, distance_t distance, DirectionData& ref_data_left, DirectionData& ref_data_right) const {
	assert(elevation >= -angle_t(pi * 0.5));
	assert(elevation <= angle_t(pi * 0.5));
	assert(azimuth >= -angle_t(2.0 * pi));
	assert(azimuth <= angle_t(2.0 * pi));

	get_direction_data(elevation, azimuth, distance, 0, ref_data_left);
	if(m_channel_count == 1) {
		get_direction_data(elevation, -azimuth, distance, 0, ref_data_right);
	} else {
		get_direction_data(elevation, azimuth, distance, 1, ref_data_right);
	}
}

void HrtfData::sample_direction(angle_t elevation, angle_t azimuth, distance_t distance, uint32_t sample, uint32_t channel, float& value, float& delay) const {
	assert(elevation >= -angle_t(pi * 0.5));
	assert(elevation <= angle_t(pi * 0.5));
	assert(azimuth >= -angle_t(2.0 * pi));
	assert(azimuth <= angle_t(2.0 * pi));

	size_t distance_index0 = 0;
	while(distance_index0 < m_distances.size() - 1 &&
	      m_distances[distance_index0].distance > distance) {
		distance_index0++;
	}
	const size_t distance_index1 = std::min(distance_index0 + 1, m_distances.size() - 1);
	const distance_t distance0 = m_distances[distance_index0].distance;
	const distance_t distance1 = m_distances[distance_index1].distance;
	const distance_t distance_delta = distance0 - distance1;
	const float distance_fractional_part = distance_delta ? (distance - distance1) / distance_delta : 0;

	const auto& elevations0 = m_distances[distance_index0].elevations;
	const auto& elevations1 = m_distances[distance_index1].elevations;

	const float azimuth_mod = std::fmod(azimuth + angle_t(pi * 2.0), angle_t(pi * 2.0));

	const angle_t elevation_scaled0 = (elevation + angle_t(pi * 0.5)) * (elevations0.size() - 1) / angle_t(pi);
	const angle_t elevation_scaled1 = (elevation + angle_t(pi * 0.5)) * (elevations1.size() - 1) / angle_t(pi);
	const size_t elevation_index00 = static_cast<size_t>(elevation_scaled0);
	const size_t elevation_index10 = static_cast<size_t>(elevation_scaled1);
	const size_t elevation_index01 = std::min(elevation_index00 + 1, elevations0.size() - 1);
	const size_t elevation_index11 = std::min(elevation_index10 + 1, elevations1.size() - 1);

	const float elevation_fractional_part0 = std::fmod(elevation_scaled0, 1.0);
	const float elevation_fractional_part1 = std::fmod(elevation_scaled1, 1.0);

	const angle_t azimuth_scaled00 = azimuth_mod * elevations0[elevation_index00].azimuths.size() / angle_t(2 * pi);
	const size_t azimuth_index000 = static_cast<size_t>(azimuth_scaled00) % elevations0[elevation_index00].azimuths.size();
	const size_t azimuth_index001 = static_cast<size_t>(azimuth_scaled00 + 1) % elevations0[elevation_index00].azimuths.size();
	const float azimuth_fractional_part00 = std::fmod(azimuth_scaled00, 1.0);

	const angle_t azimuth_scaled10 = azimuth_mod * elevations1[elevation_index10].azimuths.size() / angle_t(2 * pi);
	const size_t azimuth_index100 = static_cast<size_t>(azimuth_scaled10) % elevations1[elevation_index10].azimuths.size();
	const size_t azimuth_index101 = static_cast<size_t>(azimuth_scaled10 + 1) % elevations1[elevation_index10].azimuths.size();
	const float azimuth_fractional_part10 = std::fmod(azimuth_scaled10, 1.0);

	const angle_t azimuth_scaled01 = azimuth_mod * elevations0[elevation_index01].azimuths.size() / angle_t(2 * pi);
	const size_t azimuth_index010 = static_cast<size_t>(azimuth_scaled01) % elevations0[elevation_index01].azimuths.size();
	const size_t azimuth_index011 = static_cast<size_t>(azimuth_scaled01 + 1) % elevations0[elevation_index01].azimuths.size();
	const float azimuth_fractional_part01 = std::fmod(azimuth_scaled01, 1.0);

	const angle_t azimuth_scaled11 = azimuth_mod * elevations1[elevation_index11].azimuths.size() / angle_t(2 * pi);
	const size_t azimuth_index110 = static_cast<size_t>(azimuth_scaled11) % elevations1[elevation_index11].azimuths.size();
	const size_t azimuth_index111 = static_cast<size_t>(azimuth_scaled11 + 1) % elevations1[elevation_index11].azimuths.size();
	const float azimuth_fractional_part11 = std::fmod(azimuth_scaled11, 1.0);

	const float blend_factor_000 = (1.0f - elevation_fractional_part0) * (1.0f - azimuth_fractional_part00) * distance_fractional_part;
	const float blend_factor_001 = (1.0f - elevation_fractional_part0) * azimuth_fractional_part00 * distance_fractional_part;
	const float blend_factor_010 = elevation_fractional_part0 * (1.0f - azimuth_fractional_part01) * distance_fractional_part;
	const float blend_factor_011 = elevation_fractional_part0 * azimuth_fractional_part01 * distance_fractional_part;

	const float blend_factor_100 = (1.0f - elevation_fractional_part1) * (1.0f - azimuth_fractional_part10) * (1.0f - distance_fractional_part);
	const float blend_factor_101 = (1.0f - elevation_fractional_part1) * azimuth_fractional_part10 * (1.0f - distance_fractional_part);
	const float blend_factor_110 = elevation_fractional_part1 * (1.0f - azimuth_fractional_part11) * (1.0f - distance_fractional_part);
	const float blend_factor_111 = elevation_fractional_part1 * azimuth_fractional_part11 * (1.0f - distance_fractional_part);

	float delay0;
	float delay1;

	if(channel == 0) {
		delay0 =
		elevations0[elevation_index00].azimuths[azimuth_index000].delay * blend_factor_000 + elevations0[elevation_index00].azimuths[azimuth_index001].delay * blend_factor_001 + elevations0[elevation_index01].azimuths[azimuth_index010].delay * blend_factor_010 + elevations0[elevation_index01].azimuths[azimuth_index011].delay * blend_factor_011;

		delay1 =
		elevations1[elevation_index10].azimuths[azimuth_index100].delay * blend_factor_100 + elevations1[elevation_index10].azimuths[azimuth_index101].delay * blend_factor_101 + elevations1[elevation_index11].azimuths[azimuth_index110].delay * blend_factor_110 + elevations1[elevation_index11].azimuths[azimuth_index111].delay * blend_factor_111;
	} else {
		delay0 =
		elevations0[elevation_index00].azimuths[azimuth_index000].delay_right * blend_factor_000 + elevations0[elevation_index00].azimuths[azimuth_index001].delay_right * blend_factor_001 + elevations0[elevation_index01].azimuths[azimuth_index010].delay_right * blend_factor_010 + elevations0[elevation_index01].azimuths[azimuth_index011].delay_right * blend_factor_011;

		delay1 =
		elevations1[elevation_index10].azimuths[azimuth_index100].delay_right * blend_factor_100 + elevations1[elevation_index10].azimuths[azimuth_index101].delay_right * blend_factor_101 + elevations1[elevation_index11].azimuths[azimuth_index110].delay_right * blend_factor_110 + elevations1[elevation_index11].azimuths[azimuth_index111].delay_right * blend_factor_111;
	}

	delay = delay0 + delay1;

	sample = sample * m_channel_count + channel;

	float value0 =
	elevations0[elevation_index00].azimuths[azimuth_index000].impulse_response[sample] * blend_factor_000 + elevations0[elevation_index00].azimuths[azimuth_index001].impulse_response[sample] * blend_factor_001 + elevations0[elevation_index01].azimuths[azimuth_index010].impulse_response[sample] * blend_factor_010 + elevations0[elevation_index01].azimuths[azimuth_index011].impulse_response[sample] * blend_factor_011;

	float value1 =
	elevations1[elevation_index10].azimuths[azimuth_index100].impulse_response[sample] * blend_factor_100 + elevations1[elevation_index10].azimuths[azimuth_index101].impulse_response[sample] * blend_factor_101 + elevations1[elevation_index11].azimuths[azimuth_index110].impulse_response[sample] * blend_factor_110 + elevations1[elevation_index11].azimuths[azimuth_index111].impulse_response[sample] * blend_factor_111;

	value = value0 + value1;
}

void HrtfData::sample_direction(angle_t elevation, angle_t azimuth, distance_t distance, uint32_t sample, float& value_left, float& delay_left, float& value_right, float& delay_right) const {
	assert(elevation >= -angle_t(pi * 0.5));
	assert(elevation <= angle_t(pi * 0.5));
	assert(azimuth >= -angle_t(2.0 * pi));
	assert(azimuth <= angle_t(2.0 * pi));

	sample_direction(elevation, azimuth, distance, sample, 0, value_left, delay_left);
	if(m_channel_count == 1) {
		sample_direction(elevation, -azimuth, distance, sample, 0, value_right, delay_right);
	} else {
		sample_direction(elevation, azimuth, distance, sample, 1, value_right, delay_right);
	}
}