/*
 * Copyright 2011, Axel Dörfler, axeld@pinc-software.de.
 * Distributed under the terms of the MIT License.
 */


#include <validate_display_mode.h>

#include <string.h>


//#define TRACE_VALIDATION
#ifdef TRACE_VALIDATION
#ifdef __cplusplus
extern "C" 
#endif
void _sPrintf(const char *format, ...);
#   define TRACE(x...) _sPrintf("accelerant common: " x)
#else
#   define TRACE(x...) ;
#endif

#define ERROR(x...) _sPrintf("accelerant common: " x)


static uint16
round(uint16 value, uint16 resolution)
{
	return value / resolution * resolution;
}


static void
sanitize_timing(uint16& display, uint16& syncStart, uint16& syncEnd,
	uint16& total, const timing_constraints& constraints)
{
	if (syncStart < display + constraints.min_before_sync) {
		TRACE("%s: syncStart(%" B_PRIu16 ") < display(%" B_PRIu16 ")"
			" + min_before_sync(%" B_PRIu16 ")\n", __func__, syncStart,
			display, constraints.min_before_sync);
		syncStart = display + constraints.min_before_sync;
	} else if (syncStart > constraints.max_sync_start) {
		TRACE("%s: syncStart(%" B_PRIu16 ") > max_sync_start(%" B_PRIu16 ")\n",
			__func__, syncStart, constraints.max_sync_start);
		syncStart = constraints.max_sync_start;
	}

	uint32 syncLength = syncEnd - syncStart;
	if (syncLength < constraints.min_sync_length) {
		TRACE("%s: syncLength(%" B_PRIu16 ")"
			" < min_sync_length(%" B_PRIu16 ")\n",
			__func__, syncLength, constraints.min_sync_length);
		syncLength = constraints.min_sync_length;
	} else if (syncLength > constraints.max_sync_length) {
		TRACE("%s: syncLength(%" B_PRIu16 ")"
			" > max_sync_length(%" B_PRIu16 ")\n",
			__func__, syncLength, constraints.max_sync_length);
		syncLength = constraints.max_sync_length;
	}

	if (total < syncStart + syncLength + constraints.min_after_sync) {
		TRACE("%s: total(%" B_PRIu16 ")"
			" < syncStart(%" B_PRIu16 ")"
			" + syncLength(%" B_PRIu16 ")"
			" + min_after_sync(%" B_PRIu16 ")\n",
			__func__, total, syncStart, syncLength, constraints.min_after_sync);
		total = syncStart + syncLength + constraints.min_after_sync;
	}

	if (total > constraints.max_total) {
		TRACE("%s: total(%" B_PRIu16 ") > max_total(%" B_PRIu16 ")\n",
			__func__, total, constraints.max_total);
		total = constraints.max_total;
		syncLength = min_c(syncLength, uint16(total - syncStart));
	}

	syncEnd = round(syncStart + syncLength, constraints.resolution);
	syncStart = round(syncStart, constraints.resolution);
	display = round(display, constraints.resolution);
	total = round(total, constraints.resolution);
}


/*! Makes sure the passed in \a mode fulfills the specified \a constraints.
	Returns whether or not the mode had to be changed.
*/
bool
sanitize_display_mode(display_mode& mode,
	const display_constraints& constraints, const edid1_info* edid)
{
	display_mode originalMode = mode;

	// size

	if (mode.timing.h_display < constraints.min_h_display) {
		TRACE("%s: h_display(%" B_PRIu16 ") < min_h_display(%" B_PRIu16 ")\n",
			__func__, mode.timing.h_display, constraints.min_h_display);
		mode.timing.h_display = constraints.min_h_display;
	} else if (mode.timing.h_display > constraints.max_h_display) {
		TRACE("%s: h_display(%" B_PRIu16 ") > max_h_display(%" B_PRIu16 ")\n",
			__func__, mode.timing.h_display, constraints.max_h_display);
		mode.timing.h_display = constraints.max_h_display;
	}

	if (mode.timing.v_display < constraints.min_v_display) {
		TRACE("%s: v_display(%" B_PRIu16 ") < min_v_display(%" B_PRIu16 ")\n",
			__func__, mode.timing.v_display, constraints.min_v_display);
		mode.timing.v_display = constraints.min_v_display;
	} else if (mode.timing.v_display > constraints.max_v_display) {
		TRACE("%s: v_display(%" B_PRIu16 ") > max_v_display(%" B_PRIu16 ")\n",
			__func__, mode.timing.v_display, constraints.max_v_display);
		mode.timing.v_display = constraints.max_v_display;
	}

	// horizontal timing

	sanitize_timing(mode.timing.h_display, mode.timing.h_sync_start,
		mode.timing.h_sync_end, mode.timing.h_total,
		constraints.horizontal_timing);

	// vertical timing

	sanitize_timing(mode.timing.v_display, mode.timing.v_sync_start,
		mode.timing.v_sync_end, mode.timing.v_total,
		constraints.vertical_timing);

	// TODO: take EDID and pixel clock into account!

	return memcmp(&mode, &originalMode, sizeof(display_mode)) != 0;
}


bool
is_display_mode_within_bounds(display_mode& mode, const display_mode& low,
	const display_mode& high)
{
	// Check horizontal timing
	if (mode.timing.h_display < low.timing.h_display
		|| mode.timing.h_display > high.timing.h_display
		|| mode.timing.h_sync_start < low.timing.h_sync_start
		|| mode.timing.h_sync_start > high.timing.h_sync_start
		|| mode.timing.h_sync_end < low.timing.h_sync_end
		|| mode.timing.h_sync_end > high.timing.h_sync_end
		|| mode.timing.h_total < low.timing.h_total
		|| mode.timing.h_total > high.timing.h_total)
		return false;

	// Check vertical timing
	if (mode.timing.v_display < low.timing.v_display
		|| mode.timing.v_display > high.timing.v_display
		|| mode.timing.v_sync_start < low.timing.v_sync_start
		|| mode.timing.v_sync_start > high.timing.v_sync_start
		|| mode.timing.v_sync_end < low.timing.v_sync_end
		|| mode.timing.v_sync_end > high.timing.v_sync_end
		|| mode.timing.v_total < low.timing.v_total
		|| mode.timing.v_total > high.timing.v_total)
		return false;

	// Check pixel clock
	if (mode.timing.pixel_clock > high.timing.pixel_clock
		|| mode.timing.pixel_clock < low.timing.pixel_clock)
		return false;

	// Check horizontal size
	if (mode.virtual_width > high.virtual_width
		|| mode.virtual_width < low.virtual_width)
		return false;

	// Check vertical size
	if (mode.virtual_height > high.virtual_height
		|| mode.virtual_height < low.virtual_height)
		return false;

	return true;
}