| ' + saturation.toFixed(1) + '% | ');
}
contents += ('' + name + ' | ' + encoding + ' | ' + SI(pixel_clock, 'Hz', {p: ['M0', 'G3']}) + ' | ' + SI(datarate, 'bit/s', 2) + ' | ' + SI(bandwidth, 'bit/s', 2) + ' |
');
}
table.html(contents);
return;
}
else if (type == "Maximum Refresh Frequency") {
return;
}
return;
}
function input_ok() {
// This checks to make sure all the necessary fields are filled in, and their contents are valid, before allowing the Calculation function to proceed.
var val;
var checklist = ['HRES', 'VRES', 'FREQ'];
for (var i = 0; i < checklist.length; i++) {
val = Global_InputVars[checklist[i]];
if (!(isPositive(val))) {
DEBUG('Calculation aborted. ' + checklist[i] + ' contains an empty or non-numeric string.', val);
return false;
}
}
if ($('input[name=COLOR_DEPTH_SLCT]:checked').val() == 'Custom') {
val = Global_InputVars['COLOR_DEPTH'];
if (!(isPositive(val))) {
DEBUG('Calculation aborted. COLOR_DEPTH_SLCT is set to Custom, but CUSTOM_COLOR_DEPTH contains an empty or non-numeric string, or 0.', val);
return false;
}
}
if (Global_InputVars['TIMING_STD'] == 'Custom') {
checklist = ['V_FP', 'V_BP', 'V_SW', 'H_FP', 'H_BP', 'H_SW'];
var abort = false;
for (var i = 0; i < checklist.length; i++) {
val = Global_InputVars[checklist[i]];
if (!(isPositiveZ(val))) {
abort = true;
}
}
if (abort == true) {
DEBUG('Calculation aborted. TIMING_DROP is set to Custom, but one or more timing parameter fields contains an empty or non-numeric string.', Global_InputVars);
return false;
}
}
if ($('input[name=MARGINS_SLCT]:checked').val() == 'y') {
val = Global_InputVars['MARGINS'];
if (!(isPositiveZ(val))) {
DEBUG('Calculation aborted. MARGINS_SLCT is set to Yes, but CUSTOM_MARGINS contains an empty or non-numeric string.', val);
return false;
}
}
return true;
}
function calcMain() {
if (!input_ok()) { clearResults(); return; }
var hres = Global_InputVars['HRES'];
var vres = Global_InputVars['VRES'];
var freq = Global_InputVars['FREQ'];
var color_depth = Global_InputVars['COLOR_DEPTH'];
var px_format = Global_InputVars['PIXEL_FORMAT'];
var comp = Global_InputVars['COMP'];
var scan = Global_InputVars['SCAN'];
var timing_standard = Global_InputVars['TIMING_STD'];
// Get timing parameters
Timing = getTiming(timing_standard);
DEBUG('Timing:', Timing);
var results = {
hres: hres,
vres: vres,
freq: freq,
px_bits: color_depth,
px_format: px_format,
comp: comp,
scan: scan,
Timing: Timing,
// Calculate results
// Resolution with blanking intervals
h_eff: Timing['H_EFF'],
v_eff: Timing['V_EFF'],
// Aspect ratio
ratio_num: hres / vres,
ratio_str: (hres / GCD(hres, vres)) + ':' + (vres / GCD(hres, vres)),
// Total pixel count of image
px_per_frame: hres * vres,
px_per_frame_eff: (Timing['H_EFF']) * (Timing['V_EFF']),
// Size (bits) of one frame
bits_per_frame: hres * vres * color_depth,
bits_per_frame_eff: (Timing['H_EFF']) * (Timing['V_EFF']) * color_depth,
// Pixel clock
px_per_sec: hres * vres * Timing['F_ACTUAL'],
px_per_sec_eff: (Timing['H_EFF']) * (Timing['V_EFF']) * Timing['F_ACTUAL'],
// Raw bit rate
bits_per_sec_eff: (Timing['H_EFF']) * (Timing['V_EFF']) * color_depth * Timing['F_ACTUAL'],
};
DEBUG('Results:', SI(results['bits_per_sec_eff'], 'bit/s', 2), results);
updateDisplay(results);
}
function getTiming(timing_standard) {
// Just a traffic control function
// Actual parameters are calculated in dedicated functions for each standard
if (!(isPositiveZ(Global_InputVars['HRES']) && isPositiveZ(Global_InputVars['VRES']) && isPositiveZ(Global_InputVars['FREQ']))) {
DEBUG('Timing calculation aborted, HRES, VRES, or FREQ contains invalid input.', Global_InputVars['HRES'], Global_InputVars['VRES'], Global_InputVars['FREQ']);
return {
'V_FP': '',
'V_BP': '',
'V_SW': '',
'H_FP': '',
'H_BP': '',
'H_SW': '',
'V_BL': '',
'H_BL': '',
'F_ACTUAL': Global_InputVars['FREQ'],
};
}
if (timing_standard != 'Custom') {
if (timing_standard == 'CVT-R2') {
Timing = CVT_R(2);
}
else if (timing_standard == 'CVT-RB') {
Timing = CVT_R(1);
}
else if (timing_standard == 'CVT') {
Timing = CVT();
}
else if (timing_standard == 'GTF') {
Timing = GTF();
}
else if (timing_standard == 'DMT') {
Timing = DMT();
}
else if (timing_standard == 'CTA-861') {
Timing = CTA();
}
else if (timing_standard == 'None') {
Timing = {
'V_FP': 0,
'V_BP': 0,
'V_SW': 0,
'H_FP': 0,
'H_BP': 0,
'H_SW': 0,
'V_FP_ODD': 0,
'V_BP_ODD': 0,
'V_SW_ODD': 0,
'V_BL': 0,
'H_BL': 0,
'F_ACTUAL': Global_InputVars['FREQ'],
}
}
// Update UI timing parameter fields with the newly generated timings
submitVar('V_FP', Timing['V_FP']);
submitVar('V_BP', Timing['V_BP']);
submitVar('V_SW', Timing['V_SW']);
submitVar('H_FP', Timing['H_FP']);
submitVar('H_BP', Timing['H_BP']);
submitVar('H_SW', Timing['H_SW']);
submitVar('V_FP_ODD', Timing['V_FP_ODD']);
submitVar('V_SW_ODD', Timing['V_SW_ODD']);
submitVar('V_BP_ODD', Timing['V_BP_ODD']);
}
else if (timing_standard == 'Custom') {
// Read the timing from the UI
submitVar('V_FP', $('#V_FP').val());
submitVar('V_BP', $('#V_BP').val());
submitVar('V_SW', $('#V_SW').val());
submitVar('H_FP', $('#H_FP').val());
submitVar('H_BP', $('#H_BP').val());
submitVar('H_SW', $('#H_SW').val());
submitVar('V_FP_ODD', Global_InputVars['V_FP'] + 0.5);
submitVar('V_SW_ODD', Global_InputVars['V_SW']);
submitVar('V_BP_ODD', Global_InputVars['V_BP'] + 0.5);
Timing = {
'V_FP': Global_InputVars['V_FP'],
'V_BP': Global_InputVars['V_BP'],
'V_SW': Global_InputVars['V_SW'],
'H_FP': Global_InputVars['H_FP'],
'H_BP': Global_InputVars['H_BP'],
'H_SW': Global_InputVars['H_SW'],
'V_FP_ODD': Global_InputVars['V_FP_ODD'],
'V_BP_ODD': Global_InputVars['V_BP_ODD'],
'V_SW_ODD': Global_InputVars['V_SW_ODD'],
'V_BL': Global_InputVars['V_FP'] + Global_InputVars['V_BP'] + Global_InputVars['V_SW'],
'H_BL': Global_InputVars['H_FP'] + Global_InputVars['H_BP'] + Global_InputVars['H_SW'],
'F_ACTUAL': Global_InputVars['FREQ'],
}
}
$('#V_BLANK').html(Timing['V_BL']);
$('#H_BLANK').html(Timing['H_BL']);
return Timing;
}
function CVT_R(R) { // Variable R is an integer representing the reduced blanking revision to use, version 1 or version 2.
var H = Global_InputVars['HRES']; // Horizontal active pixels
var V = Global_InputVars['VRES']; // Vertical active pixels
var F = Global_InputVars['FREQ']; // Nominal vertical refresh frequency
var S = Global_InputVars['SCAN']; // 1 for progressive scan, 2 for interlaced
var M = Global_InputVars['MARGINS']; // Margins (%)
// Declaring variables for all results
var V_FP; // Vertical front porch
var V_SW; // Vertical sync width
var V_BP; // Vertical back porch
var H_FP; // Horizontal front porch
var H_SW; // Horizontal sync width
var H_BP; // Horizontal back porch
var V_BLANK; // Total vertical blanking (V_FP + V_SW + V_BP)
var H_BLANK; // Total horizontal blanking (H_FP + H_SW + H_BP)
var V_EFF; // V + V_Blank + V_Margins
var H_EFF; // H + H_Blank + H_Margins
var F_ACTUAL; // Actual vertical refresh frequency (after pixel clock rounding)
var F_HOR; // Horizontal refresh frequency
// Common constants
var V_PER_MIN = 0.00046; /* Minimum vertical blanking period for reduced blank timing (in seconds), defined by VESA CVT 1.2 standard */
var V_LINES = Math.floor(V / S) // If progressive scan, S = 1 and V_LINES = V. If interlaced, V_LINES = floor(V / 2).
if (R == 1) {
// CVT-RB constants
H_BLANK = 160;
H_FP = 48;
H_BP = 80;
H_SW = 32;
V_FP = 3;
var V_BP_MIN = 6;
// All H timings are defined, as well as V_FP. Only V_SW and V_BP remain (and V_BLANK, the sum of all 3 V parameters)
// Determine vertical sync width (V_SW) from table of magic numbers defined in VESA CVT standard
var V_SYNC_TABLE = [
[4/3, 4],
[16/9, 5],
[8/5, 6],
[5/3, 7],
[5/4, 7],
]
V_SW = 10; // default value defined in standard
for (var i = 0; i < V_SYNC_TABLE.length; i++) {
if ((H / V) - V_SYNC_TABLE[i][0] < 0.05) { // Check if aspect ratio of image (H/V) matches an aspect ratio defined in table, within 0.05
V_SW = V_SYNC_TABLE[i][1];
}
}
// V_BP is determined in reverse, by calculating V_BLANK first (the sum of V_FP, V_SW, and V_BP) and subtracting out V_FP and V_SW.
var CellGran = 8; // Cell granularity constant defined by CVT standard
var H_RND = Math.floor(H / CellGran) * CellGran; // Round down horizontal resolution to be a multiple 8
var V_MARGIN = Math.floor(M / 100) * V_LINES; // If margins percent (M) is 0, this result is 0
var H_MARGIN = Math.floor(H_RND * M / 100 / CellGran) * CellGran; // If margins percent (M) is 0, this result is 0
var H_PER_EST = ((1 / F) - V_PER_MIN) / (V_LINES + (2 * V_MARGIN)); // Horizontal blanking period estimate
V_BLANK = Math.floor((V_PER_MIN / H_PER_EST) + 1);
var V_BLANK_MIN = V_FP + V_SW + V_BP_MIN;
if (V_BLANK < V_BLANK_MIN) { V_BLANK = V_BLANK_MIN; } // Enforce minimum value for V_blank
V_BP = V_BLANK - (V_FP + V_SW);
V_EFF = V_LINES + V_BLANK + V_MARGIN + ((S - 1)/2); // (S-1)/2 = 0 for progressive, 0.5 for interlaced
H_EFF = H_RND + H_BLANK + H_MARGIN;
// Calculate pixel clock, to enforce pixel clock rounding to the nearest 250 kHz, as required by the CVT standard
var CLK = F * (V_EFF) * (H_EFF); // Pixel clock (Hz)
CLK = Math.floor(CLK / 250000) * 250000; // Pixel clock (Hz) rounded down to the next multiple of 0.25 MHz (250 kHz, 250000 Hz)
F_HOR = CLK / (H_EFF); // Horizontal refresh frequency (Hz)
F_ACTUAL = F_HOR / (V_EFF); // Pixel clock rounding is enforced via lowering the vertical refresh frequency to adjust pixel clock
}
else if (R == 2) {
// CVT-R2 constants defined by CVT standard
H_BLANK = 80;
H_FP = 8;
H_BP = 40;
H_SW = 32;
V_BP = 6;
V_SW = 8;
var V_FP_MIN = 1;
// All parameters are defined as constant except V_FP
// V_FP is determined in reverse, by calculating V_BLANK first (the sum of V_FP, V_SW, and V_BP) and subtracting V_SW and V_BP out.
var V_MARGIN = Math.floor(M / 100) * V_LINES; // If margins percent (M) is 0, this result is 0
var H_MARGIN = Math.floor(H * M / 100); // If margins percent (M) is 0, this result is 0
var H_PER_EST = ((1 / F) - V_PER_MIN) / (V_LINES + (2 * V_MARGIN)); // Horizontal blanking period estimate
V_BLANK = Math.floor((V_PER_MIN / H_PER_EST) + 1);
var V_BLANK_MIN = V_FP_MIN + V_SW + V_BP;
if (V_BLANK < V_BLANK_MIN) { V_BLANK = V_BLANK_MIN; } // Enforce minimum value for V_blank
V_FP = V_BLANK - (V_BP + V_SW);
V_EFF = V_LINES + V_BLANK + V_MARGIN + ((S - 1)/2); // (S-1)/2 = 0 for progressive, 0.5 for interlaced
H_EFF = H + H_BLANK + H_MARGIN;
// Calculate pixel clock, to enforce pixel clock rounding to the nearest 1 kHz, as required by the CVT standard
var CLK = F * (V_EFF) * (H_EFF); // Pixel clock (Hz)
CLK = Math.floor(CLK / 1000) * 1000; // Pixel clock (Hz) rounded down to the next multiple of 0.001 MHz (1 kHz, 1000 Hz)
F_HOR = CLK / (H_EFF); // Horizontal refresh frequency (Hz)
F_ACTUAL = F_HOR / (V_EFF);
}
//DEBUG('CLK', CLK);
//DEBUG('F_HOR', F_HOR);
//DEBUG('F_ACTUAL', F_ACTUAL);
//DEBUG(V_BLANK);
return {
V_FP: V_FP, // For interlaced, these vertical timing are used for the even fields
V_BP: V_BP,
V_SW: V_SW,
H_FP: H_FP,
H_BP: H_BP,
H_SW: H_SW,
V_FP_ODD: V_FP + 0.5, // For interlaced, V_FP and V_BP are 0.5 higher for odd fields (V_SW is same)
V_SW_ODD: V_SW,
V_BP_ODD: V_BP + 0.5,
V_BL: V_BLANK,
H_BL: H_BLANK,
V_EFF: V_EFF,
H_EFF: H_EFF,
F_ACTUAL: F_ACTUAL,
};
}
function CVT() {
return;
}
function CTA() {
return;
}
function updateDisplay() {
return;
}
function clearResults() {
return;
}
function timingUIChange() {
// Controls the enabled/disabled state of the custom timing format input fields
var timing_params = [
$('#V_FP'),
$('#V_BP'),
$('#V_SW'),
$('#H_FP'),
$('#H_BP'),
$('#H_SW'),
];
value = $('#TIMING_DROP').val();
if (value == 'Custom') {
for (var i = 0; i < timing_params.length; i++) {
param = timing_params[i];
param.prop('disabled', false);
//if (field.prop('oldvalue') != '') {
// field.val(field.prop('oldvalue'));
//}
}
}
else {
for (var i = 0; i < timing_params.length; i++) {
param = timing_params[i];
param.prop('disabled', true);
//field.prop('oldvalue', field.val());
//field.val('');
}
}
value = $('input[name=SCAN_SLCT]:checked').val();
if (value == 'i') {
$('#V_BLANK_ODD_LABEL').css('display', 'table-cell');
$('#V_FP_ODD_CONTAINER').css('display', 'table-cell');
$('#V_BP_ODD_CONTAINER').css('display', 'table-cell');
$('#V_SW_ODD_CONTAINER').css('display', 'table-cell');
$('#V_BLANK_ODD_CONTAINER').css('display', 'table-cell');
$('#V_BLANK_EVEN_LABEL').html('(Even) V