path: root/src/cvt.c

#include "cvt.h"

#ifdef __cplusplus
extern "C" {
#endif

/*
 * Based on the cvt util:
 * http://www.uruk.org/projects/cvt/cvt.c
 */

#include <stdlib.h>
#include <string.h>
#include <math.h>

#define CLOCK_STEP        0.25  /* Clock steps in MHz */
#define MARGIN_PERCENT    1.8   /* % of active vertical image                */
#define H_SYNC_PER        8.0   /* sync % of horizontal image                */
#define CELL_GRAN         8.4999 /* assumed character cell granularity       */
#define CELL_GRAN_RND     8.0   /* assumed character cell granularity (round)*/
#define MIN_V_BPORCH      3.0   /* width of vsync in lines                   */
#define MIN_V_PORCH_RND   3.0   /* width of vsync in lines                   */
#define M                 600.0 /* blanking formula gradient                 */
#define C                 40.0  /* blanking formula offset                   */
#define K                 128.0 /* blanking formula scaling factor           */
#define J                 20.0  /* blanking formula scaling factor           */

/* Standard Timing Parameters */
#define MIN_VSYNC_BP      550.0 /* min time of vsync + back porch (us) */
#define H_SYNC_PERCENT    8.0   /* width of hsync as % of total line         */

/* Reduced Blanking defines */
#define RB_MIN_V_BPORCH   6.0   /* lines */
#define RB_V_FPORCH       3.0   /* lines */
#define RB_MIN_V_BLANK    460.0 /* us */
#define RB_H_SYNC         32.0  /* pixels */
#define RB_H_BLANK        160.0 /* pixels */

/* C' and M' are part of the Blanking Duty Cycle computation */

#define C_PRIME           (((C - J) * K/256.0) + J)
#define M_PRIME           (K/256.0 * M)

/* NOP out prints */
#define print_value(...) (void)0

typedef struct __options
{
	int x, y;
	int reduced_blank, interlaced;
	int xf86mode, fbmode;
	float v_freq;
} options;


/*
 * vert_refresh() - as defined by the CVT Timing Standard, compute the
 * Stage 1 Parameters using the vertical refresh frequency.  In other
 * words: input a desired resolution and desired refresh rate, and
 * output the CVT mode timings.
 *
 * XXX margin computations are implemented but not tested (nor used by
 * XFree86 of fbset mode descriptions, from what I can tell).
 */

mode *vert_refresh (int h_pixels, int v_lines, float freq,
					int interlaced, int reduced_blank, int margins)
{
	float h_pixels_rnd;
	float v_lines_rnd;
	float v_field_rate_rqd;
	float top_margin;
	float bot_margin;
	float interlace;
	float h_period_est;
	float v_sync_bp;
	float total_v_lines;
	float left_margin;
	float right_margin;
	float total_active_pixels;
	float ideal_duty_cycle;
	float h_blank;
	float total_pixels;

	float cur_duty_cycle;
	float v_sync;
	float v_sync_rnd, h_sync_rnd;
	float h_back_porch, v_front_porch, h_front_porch;

	float vbi_lines, act_vbi_lines, rb_min_vbi;
	float act_pixel_freq, act_h_freq;
	float act_field_rate, act_frame_rate;
	char *aspect_ratio;
	int stage;

	mode *m = (mode*) malloc (sizeof (mode));


	/*  1. Required Field Rate
	 *
	 *  This is slightly different from the spreadsheet because we use
	 *  a different result for interlaced video modes.  Simplifies this
	 *  to the input field rate.
	 *
	 *  [V FIELD RATE RQD] = [I/P FREQ RQD]
	 */

	v_field_rate_rqd = freq;

	print_value(1, "[V FIELD RATE RQD]", v_field_rate_rqd);


	/*  2. Horizontal Pixels
	 *
	 *  In order to give correct results, the number of horizontal
	 *  pixels requested is first processed to ensure that it is divisible
	 *  by the character size, by rounding it to the nearest character
	 *  cell boundary.
	 *
	 *  [H PIXELS RND] = ((ROUNDDOWN([H PIXELS]/[CELL GRAN RND],0))
	 *       *[CELLGRAN RND])
	 */

	h_pixels_rnd = floor((float) h_pixels / CELL_GRAN_RND) * CELL_GRAN_RND;

	print_value(2, "[H PIXELS RND]", h_pixels_rnd);


	/*  2.5th Calculation, aspect_ratio & v_sync_rnd
	 *
	 *  [ASPECT_RATIO] = IF(H_PIXELS_RND = CELL_GRAN_RND*ROUND((V_LINES*
	 *     4.0/3.0)/CELL_GRAN_RND),"4:3")
	 *     etc...
	 *  [V_SYNC] = [value from table based on aspect ratio]
	 *  [V_SYNC_RND] = ROUND(V_SYNC,0)  // Not needed in principle
	 */

	if (h_pixels_rnd == CELL_GRAN_RND * floor(((float)v_lines * 4.0 / 3.0)
		/ CELL_GRAN_RND)) {
	aspect_ratio = "4:3";
	v_sync = 4;
	} else if (h_pixels_rnd == CELL_GRAN_RND * floor(((float)v_lines * 16.0
		/ 9.0) / CELL_GRAN_RND)) {
	aspect_ratio = "16:9";
	v_sync = 5;
	} else if (h_pixels_rnd == CELL_GRAN_RND * floor(((float)v_lines * 16.0
		/ 10.0) / CELL_GRAN_RND)) {
	aspect_ratio = "16:10";
	v_sync = 6;
	} else if (h_pixels_rnd == CELL_GRAN_RND * floor(((float)v_lines * 5.0
		/ 4.0) / CELL_GRAN_RND)) {
	aspect_ratio = "5:4";
	v_sync = 7;
	} else if (h_pixels_rnd == CELL_GRAN_RND * floor(((float)v_lines * 15.0
		/ 9.0) / CELL_GRAN_RND)) {
	aspect_ratio = "15:9";
	v_sync = 7;
	} else {
	/* Default case of unknown aspect ratio */
	aspect_ratio = "Custom";
	v_sync = 10;
	}
	v_sync_rnd = v_sync;

	/*
	 *  3. Determine Left & Right Borders
	 *
	 *  Calculate the margins on the left and right side.
	 *
	 *  [LEFT MARGIN (PIXELS)] = (IF( [MARGINS RQD?]="Y",
	 *          (ROUNDDOWN( ([H PIXELS RND] * [MARGIN%] / 100 /
	 *                   [CELL GRAN RND]),0)) * [CELL GRAN RND],
	 *          0))
	 *  [RIGHT MARGIN (PIXELS)] = (IF( [MARGINS RQD?]="Y",
	 *          (ROUNDDOWN( ([H PIXELS RND] * [MARGIN%] / 100 /
	 *                   [CELL GRAN RND]),0)) * [CELL GRAN RND],
	 *          0))
	 */

	left_margin = margins ?
		floor(h_pixels_rnd * MARGIN_PERCENT / 100.0 / CELL_GRAN_RND)
		* CELL_GRAN_RND : 0.0;
	right_margin = left_margin;

	print_value(3, "[LEFT MARGIN (PIXELS)]", left_margin);
	print_value(3, "[RIGHT MARGIN (PIXELS)]", right_margin);


	/*  4. Find total active pixels.
	 *
	 *  Find total number of active pixels in image and left and right
	 *  margins.
	 *
	 *  [TOTAL ACTIVE PIXELS] = [H PIXELS RND] + [LEFT MARGIN (PIXELS)] +
	 *                          [RIGHT MARGIN (PIXELS)]
	 */

	total_active_pixels = h_pixels_rnd + left_margin + right_margin;

	print_value(4, "[TOTAL ACTIVE PIXELS]", total_active_pixels);


	/*  5. Find number of lines per field.
	 *
	 *  If interlace is requested, the number of vertical lines assumed
	 *  by the calculation must be halved, as the computation calculates
	 *  the number of vertical lines per field. In either case, the
	 *  number of lines is rounded to the nearest integer.
	 *
	 *  [V LINES RND] = IF([INT RQD?]="y", ROUNDDOWN([V LINES]/2,0),
	 *                                     ROUNDDOWN([V LINES],0))
	 */

	v_lines_rnd = interlaced ?
			floor((float) v_lines / 2.0) :
			floor((float) v_lines);

	print_value(5, "[V LINES RND]", v_lines_rnd);


	/*  6. Find Top and Bottom margins.
	 *
	 *  [TOP MARGIN (LINES)] = IF([MARGINS RQD?]="Y",
	 *          ROUNDDOWN(([MARGIN%]/100*[V LINES RND]),0),
	 *          0)
	 *  [BOT MARGIN (LINES)] = IF([MARGINS RQD?]="Y",
	 *          ROUNDDOWN(([MARGIN%]/100*[V LINES RND]),0),
	 *          0)
	 */

	top_margin = margins ? floor(MARGIN_PERCENT / 100.0 * v_lines_rnd) : (0.0);
	bot_margin = top_margin;

	print_value(6, "[TOP MARGIN (LINES)]", top_margin);
	print_value(6, "[BOT MARGIN (LINES)]", bot_margin);


	/*  7. If interlace is required, then set variable [INTERLACE]=0.5:
	 *
	 *  [INTERLACE]=(IF([INT RQD?]="y",0.5,0))
	 */

	interlace = interlaced ? 0.5 : 0.0;

	print_value(7, "[INTERLACE]", interlace);


	/*
	 *  Here it diverges for "reduced blanking" or normal blanking modes.
	 */

	if (reduced_blank) {
	h_blank = RB_H_BLANK;


	/*  8. Estimate Horiz. Period (us).
	 *
	 *  [H PERIOD EST] = ((1000000/V_FIELD_RATE_RQD)-RB_MIN_V_BLANK)/(V_LINES_RND+TOP_MARGIN+BOT_MARGIN)
	 */

	h_period_est = (1000000.0/v_field_rate_rqd - RB_MIN_V_BLANK)
		/ (v_lines_rnd + top_margin + bot_margin);

	print_value(8, "[H PERIOD EST]", h_period_est);


	/*  9. Find number of lines in vertical blanking.
	 *
	 *  [Actual VBI_LINES] = RB_MIN_V_BLANK/H_PERIOD_EST
	 *  [VBI_LINES] = ROUNDDOWN(RB_MIN_V_BLANK/H_PERIOD_EST,0) + 1
	 */

	vbi_lines = RB_MIN_V_BLANK/h_period_est;
	print_value(9, "[Actual VBI LINES]", vbi_lines);

	vbi_lines = floor(vbi_lines) + 1.0;
	print_value(9, "[VBI LINES]", vbi_lines);


	/*  10. Check Vertical Blanking is sufficient.
	 *
	 *  [RB MIN VBI] = RB_V_FPORCH+V_SYNC_RND+RB_MIN_V_BPORCH
	 *  [ACT VBI LINES] = IF(VBI_LINES<RB_MIN_VBI,RB_MIN_VBI,VBI_LINES)
	 */

	rb_min_vbi = RB_V_FPORCH + v_sync_rnd + RB_MIN_V_BPORCH;
	act_vbi_lines = (vbi_lines < rb_min_vbi) ? rb_min_vbi : vbi_lines;

	print_value(10, "[Minimum VBI Lines]", rb_min_vbi);
	print_value(10, "[ACT VBI LINES]", act_vbi_lines);


	/*  11. Find total number of lines in vertical field.
	 *
	 *  [TOTAL V LINES] = ACT_VBI_LINES+V_LINES_RND+TOP_MARGIN+BOT_MARGIN+INTERLACE
	 */

	total_v_lines = act_vbi_lines + v_lines_rnd + top_margin
		+ bot_margin + interlace;

	print_value(11, "[TOTAL V LINES]", total_v_lines);


	/*  12. Find total number of pixels in a line (pixels).
	 *
	 *  [TOTAL PIXELS] = RB_H_BLANK+TOTAL_ACTIVE_PIXELS
	 */

	total_pixels = total_active_pixels + RB_H_BLANK;

	print_value(12, "[TOTAL PIXELS]", total_pixels);


	/*  13. Find Pixel Clock Frequency (MHz).
	 *
	 *  [Non-rounded PIXEL_FREQ] = V_FIELD_RATE_RQD*TOTAL_V_LINES*TOTAL_PIXELS/1000000
	 *  [ACT PIXEL FREQ] = CLOCK_STEP * ROUND((V_FIELD_RATE_RQD*TOTAL_V_LINES*TOTAL_PIXELS/1000000)/CLOCK_STEP,0)
	 */

	act_pixel_freq = v_field_rate_rqd * total_v_lines
		* total_pixels / 1000000.0;
	print_value(13, "[Non-rounded PIXEL FREQ]", act_pixel_freq);

	act_pixel_freq = CLOCK_STEP * floor(act_pixel_freq / CLOCK_STEP);
	print_value(13, "[ACT PIXEL FREQ]", act_pixel_freq);


	stage = 14;

	} else {    /* Normal Blanking */

	/*  8. Estimate Horiz. Period (us).
	 *
	 *  [H PERIOD EST] = ((1/V_FIELD_RATE_RQD)-MIN_VSYNC_BP/1000000)/(V_LINES_RND+(2*TOP_MARGIN)+MIN_V_PORCH_RND+INTERLACE)*1000000
	 */

	h_period_est = ((1/v_field_rate_rqd) - MIN_VSYNC_BP/1000000.0)
		/ (v_lines_rnd + (2*top_margin) + MIN_V_PORCH_RND + interlace)
		* 1000000.0;

	print_value(8, "[H PERIOD EST]", h_period_est);


	/*  9. Find number of lines in (SYNC + BACK PORCH).
	 *
	 *  [Estimated V_SYNC_BP] = ROUNDDOWN((MIN_VSYNC_BP/H_PERIOD_EST),0)+1
	 *  [Actual V_SYNC_BP] = MIN_VSYNC_BP/H_PERIOD_EST
	 *  [V_SYNC_BP] = IF(Estimated V_SYNC_BP<(V_SYNC+MIN_V_BPORCH),
	 *       V_SYNC+MIN_V_BPORCH,Estimated V_SYNC_BP)
	 */

	v_sync_bp = MIN_VSYNC_BP/h_period_est;
	print_value(9, "[Actual V_SYNC_BP]", v_sync_bp);

	v_sync_bp = floor(v_sync_bp) + 1;
	print_value(9, "[Estimated V_SYNC_BP]", v_sync_bp);

	v_sync_bp = (v_sync_bp < v_sync + MIN_V_BPORCH) ?
		v_sync + MIN_V_BPORCH : v_sync_bp;
	print_value(9, "[V_SYNC_BP]", v_sync_bp);


	/*  10. Find number of lines in back porch (Lines).
	 *
	 *  [Back porch] = V_SYNC_BP - V_SYNC_RND;
	 */

	print_value(10, "[Back porch]", v_sync_bp - v_sync_rnd);


	/*  11. Find total number of lines in vertical field.
	 *
	 *  [TOTAL V LINES] = V_LINES_RND+TOP_MARGIN+BOT_MARGIN
	 *      +V_SYNC_BP+INTERLACE+MIN_V_PORCH_RND
	 */

	total_v_lines = v_lines_rnd + top_margin + bot_margin
		+ v_sync_bp + interlace + MIN_V_PORCH_RND;

	print_value(11, "[TOTAL V LINES]", total_v_lines);


	/*  12. Find ideal blanking duty cycle from formula (%):
	 *
	 *  [IDEAL DUTY CYCLE] = C_PRIME-(M_PRIME*H_PERIOD_EST/1000)
	 */

	ideal_duty_cycle = C_PRIME - (M_PRIME * h_period_est / 1000.0);

	print_value(12, "[IDEAL DUTY CYCLE]", ideal_duty_cycle);


	/*  13. Find blanking time to nearest cell (Pixels).
	 *
	 *  [H BLANK] = IF(IDEAL_DUTY_CYCLE<20,(ROUNDDOWN((TOTAL_ACTIVE_PIXELS*20/(100-20)/(2*CELL_GRAN_RND)),0))*(2*CELL_GRAN_RND),(ROUNDDOWN((TOTAL_ACTIVE_PIXELS*IDEAL_DUTY_CYCLE/(100-IDEAL_DUTY_CYCLE)/(2*CELL_GRAN_RND)),0))*(2*CELL_GRAN_RND))
	 */

	cur_duty_cycle = (ideal_duty_cycle < 20.0) ? 20.0 : ideal_duty_cycle;
	h_blank = floor((total_active_pixels * cur_duty_cycle/(100.0 - cur_duty_cycle)/(2.0*CELL_GRAN_RND))) * (2.0*CELL_GRAN_RND);

	print_value(13, "[H BLANK]", h_blank);


	/*  14. Find total number of pixels in a line (Pixels).
	 *
	 *  [TOTAL PIXELS] = TOTAL_ACTIVE_PIXELS + H_BLANK
	 */

	total_pixels = total_active_pixels + h_blank;

	print_value(14, "[TOTAL PIXELS]", total_pixels);


	/*  15. Find pixel clock frequency (MHz).
	 *
	 *  [Non-rounded PIXEL FREQ] = TOTAL_PIXELS / H_PERIOD_EST
	 *  [ACT PIXEL FREQ] = CLOCK_STEP * ROUNDDOWN(
	 */

	act_pixel_freq = total_pixels / h_period_est;
	print_value(15, "[Non-rounded PIXEL FREQ]", act_pixel_freq);

	act_pixel_freq = CLOCK_STEP * floor(act_pixel_freq / CLOCK_STEP);
	print_value(15, "[ACT PIXEL FREQ]", act_pixel_freq);


	stage = 16;
	}


	/*  14/16. Find actual horizontal frequency (kHz)
	 *
	 *  [ACT H FREQ] = 1000*ACT_PIXEL_FREQ/TOTAL_PIXELS
	 */

	act_h_freq = 1000 * act_pixel_freq / total_pixels;

	print_value(stage, "[ACT H FREQ]", act_h_freq);
	stage += 1;


	/*  15/17. Find actual field rate (Hz)
	 *
	 *  [ACT FIELD RATE] = 1000*ACT_H_FREQ/TOTAL_V_LINES
	 */

	act_field_rate = 1000 * act_h_freq / total_v_lines;

	print_value(stage, "[ACT FIELD RATE]", act_field_rate);
	stage += 1;


	/*  16/18. Find actual vertical frame frequency (Hz)
	 *
	 *  [ACT FRAME RATE] = IF(INT_RQD?=Y,ACT_FIELD_RATE/2,ACT_FIELD_RATE)
	 */

	act_frame_rate = interlace ?
		(act_field_rate / 2) : act_field_rate;

	print_value(stage, "[ACT FRAME RATE]", act_frame_rate);



	/*
	 *  Extra computations not numbered in the CVT spreadsheet.
	 */


	/*  20. Find Horizontal Back Porch.
	 *
	 *  [H BACK PORCH] = H_BLANK/2
	 */

	h_back_porch = h_blank/2;

	print_value(20, "[H BACK PORCH]", h_back_porch);


	/*  21. Find Horizontal Front Porch.
	 *
	 *  [H SYNC RND] = IF(RED_BLANK_RQD?="Y",RB_H_SYNC,(ROUNDDOWN((H_SYNC_PER/100*TOTAL_PIXELS/CELL_GRAN_RND),0))*CELL_GRAN_RND)
	 */

	if (reduced_blank) {
	h_sync_rnd = RB_H_SYNC;
	} else {
	h_sync_rnd = floor(H_SYNC_PER/100.0*total_pixels/CELL_GRAN_RND)
		* CELL_GRAN_RND;
	}

	print_value(21, "[H SYNC RND]", h_sync_rnd);


	/*  22. Find Horizontal Front Porch.
	 *
	 *  [H FRONT PORCH] = H_BLANK - H_BACK_PORCH - H_SYNC_RND
	 */

	h_front_porch = h_blank - h_back_porch - h_sync_rnd;

	print_value(22, "[H FRONT PORCH]", h_front_porch);


	/*  23. Find Vertical Front Porch.
	 *
	 *  [V FRONT PORCH] = IF(RED_BLANK_RQD?="y",RB_V_FPORCH,MIN_V_PORCH_RND)
	 */

	v_front_porch = reduced_blank ? RB_V_FPORCH : MIN_V_PORCH_RND;

	print_value(23, "[V FRONT PORCH]", v_front_porch);



	/* finally, pack the results in the mode struct */

	m->hr  = (int) (h_pixels_rnd);
	m->hss = (int) (h_pixels_rnd + h_front_porch);
	m->hse = (int) (h_pixels_rnd + h_front_porch + h_sync_rnd);
	m->hfl = (int) (total_pixels);

#if 0
	m->vr  = (int) (v_lines_rnd);
	m->vss = (int) (v_lines_rnd + v_front_porch);
	m->vse = (int) (v_lines_rnd + v_front_porch + v_sync_rnd);
	m->vfl = (int) (total_v_lines);
#else
	{
	int real_v_lines = v_lines;
	m->vr  = (int) (real_v_lines);
	m->vss = (int) (real_v_lines + v_front_porch);
	m->vse = (int) (real_v_lines + v_front_porch + v_sync_rnd);
	m->vfl = (int) (total_v_lines - v_lines_rnd + real_v_lines);
	}
#endif

	m->pclk   = act_pixel_freq;
	m->h_freq = act_h_freq;
	m->v_freq = freq;
	m->real_v_rate = act_field_rate;

	m->in = interlaced;
	m->rb = reduced_blank;

	return (m);

} // vert_refresh()

#ifdef __cplusplus
}
#endif