static gboolean update_refresh_rate(InfoEntry *entry)
{
CtkDisplayDevice *ctk_object = entry->ctk_object;
CtrlTarget *ctrl_target = ctk_object->ctrl_target;
ReturnStatus ret;
gint val;
gboolean hdmi3D;
char *str;
float fvalue;
ret = NvCtrlGetAttribute(ctrl_target, NV_CTRL_REFRESH_RATE, &val);
if (ret != NvCtrlSuccess) {
return FALSE;
}
ret = NvCtrlGetAttribute(ctrl_target, NV_CTRL_DPY_HDMI_3D, &hdmi3D);
if (ret != NvCtrlSuccess) {
return FALSE;
}
fvalue = ((float)(val)) / 100.0f;
if (hdmi3D) {
fvalue /= 2;
}
str = g_strdup_printf("%.2f Hz%s", fvalue, hdmi3D ? " (HDMI 3D)" : "");
gtk_label_set_text(GTK_LABEL(entry->txt), str);
g_free(str);
return TRUE;
}
GtkWidget* ctk_color_correction_page_new(CtrlTarget *ctrl_target,
CtkConfig *ctk_config,
ParsedAttribute *p,
CtkEvent *ctk_event)
{
CtkColorCorrectionPage *ctk_color_correction_page;
ReturnStatus ret;
GObject *object;
GtkWidget *banner;
GtkWidget *ctk_color_correction;
gint val;
/* check if the VidMode extension is present */
ret = NvCtrlGetAttribute(ctrl_target, NV_CTRL_ATTR_EXT_VM_PRESENT, &val);
if ((ret != NvCtrlSuccess) || (val == FALSE)) {
return NULL;
}
/* check if the noScanout mode enabled */
ret = NvCtrlGetAttribute(ctrl_target, NV_CTRL_NO_SCANOUT, &val);
if ((ret == NvCtrlSuccess) && (val == NV_CTRL_NO_SCANOUT_ENABLED)) {
return NULL;
}
/* allocate the color correction widget */
ctk_color_correction = ctk_color_correction_new(ctrl_target, ctk_config,
p, ctk_event);
if (ctk_color_correction == NULL) {
return NULL;
}
/* create the new page */
object = g_object_new(CTK_TYPE_COLOR_CORRECTION_PAGE, NULL);
ctk_color_correction_page = CTK_COLOR_CORRECTION_PAGE(object);
gtk_box_set_spacing(GTK_BOX(ctk_color_correction_page), 10);
/*
* pack the banner at the top of the page, followed by the color
* correction widget
*/
banner = ctk_banner_image_new(BANNER_ARTWORK_COLOR);
gtk_box_pack_start(GTK_BOX(ctk_color_correction_page),
banner, FALSE, FALSE, 0);
gtk_widget_show_all(GTK_WIDGET(object));
gtk_box_pack_start(GTK_BOX(ctk_color_correction_page),
ctk_color_correction, TRUE, TRUE, 0);
return GTK_WIDGET(object);
}
/****
*
* Updates widgets in relation to current overclocking state.
*
*/
static void overclocking_state_update_gui(CtkClocks *ctk_object)
{
ReturnStatus ret;
int value;
NVCTRLAttributeValidValuesRec range_detection;
gboolean probing_optimal = TRUE;
gboolean enabled;
/* We need to check the overclocking state status with
* the server every time someone tries to change the state
* because the set might have failed.
*/
ret = NvCtrlGetAttribute(ctk_object->handle,
NV_CTRL_GPU_OVERCLOCKING_STATE,
&value);
if ( ret != NvCtrlSuccess )
enabled = False;
else
enabled = (value==NV_CTRL_GPU_OVERCLOCKING_STATE_MANUAL)?True:False;
ctk_object->overclocking_enabled = enabled;
/* We need to also make sure the server is not busy probing
* for the optimal clocks.
*/
if ( enabled ) {
ret = NvCtrlGetValidAttributeValues(ctk_object->handle,
NV_CTRL_GPU_OPTIMAL_CLOCK_FREQS_DETECTION,
&range_detection);
if ( ret == NvCtrlSuccess ) {
ret = NvCtrlGetAttribute(ctk_object->handle,
NV_CTRL_GPU_OPTIMAL_CLOCK_FREQS_DETECTION_STATE,
&value);
if ( ret == NvCtrlSuccess ) {
probing_optimal =
(value == NV_CTRL_GPU_OPTIMAL_CLOCK_FREQS_DETECTION_STATE_BUSY);
}
ctk_object->probing_optimal = probing_optimal;
ctk_object->auto_detection_available = TRUE;
}
}
/* Sync the gui to be able to modify the clocks */
sync_gui_to_modify_clocks(ctk_object, ctk_object->clocks_being_modified);
/* Update the status bar */
ctk_config_statusbar_message(ctk_object->ctk_config,
"GPU overclocking %sabled.",
enabled?"en":"dis");
} /* overclocking_state_update_gui() */
/* NOTE: Link information is dependent on signal type, and this function
* assumes the signal type is queried first.
*/
static gboolean update_link_info(InfoEntry *entry)
{
CtkDisplayDevice *ctk_object = entry->ctk_object;
CtrlTarget *ctrl_target = ctk_object->ctrl_target;
ReturnStatus ret;
gint val;
const char *link;
char tmp[32];
ret = NvCtrlGetAttribute(ctrl_target, NV_CTRL_FLATPANEL_LINK, &val);
if (ret != NvCtrlSuccess) {
return FALSE;
}
if (ctk_object->signal_type == NV_CTRL_FLATPANEL_SIGNAL_DISPLAYPORT) {
int lanes;
lanes = val + 1;
ret = NvCtrlGetAttribute(ctrl_target, NV_CTRL_DISPLAYPORT_LINK_RATE,
&val);
if ((ret == NvCtrlSuccess) &&
(val == NV_CTRL_DISPLAYPORT_LINK_RATE_DISABLED)) {
link = "Disabled";
} else {
if (ret != NvCtrlSuccess) {
val = 0;
}
if (val > 0) {
snprintf(tmp, 32, "%d lane%s @ %.2f Gbps", lanes, lanes == 1 ? "" : "s",
val * 0.27);
} else {
snprintf(tmp, 32, "%d lane%s @ unknown bandwidth", lanes,
lanes == 1 ? "" : "s");
}
link = tmp;
}
} else {
// LVDS or TMDS
switch(val) {
case NV_CTRL_FLATPANEL_LINK_SINGLE:
link = "Single";
break;
case NV_CTRL_FLATPANEL_LINK_DUAL:
link = "Dual";
break;
default:
link = "Unknown";
break;
}
}
gtk_label_set_text(GTK_LABEL(entry->txt), link);
return TRUE;
}
static void tv_info_setup(CtkDisplayDeviceTv *ctk_display_device_tv)
{
ReturnStatus ret;
int val;
char *str;
/* NV_CTRL_STRING_TV_ENCODER_NAME */
ret = NvCtrlGetStringDisplayAttribute(ctk_display_device_tv->handle, 0,
NV_CTRL_STRING_TV_ENCODER_NAME,
&str);
if (ret == NvCtrlSuccess) {
gtk_label_set_text(GTK_LABEL(ctk_display_device_tv->txt_encoder_name),
str);
gtk_widget_show(ctk_display_device_tv->info_frame);
} else {
gtk_widget_hide(ctk_display_device_tv->info_frame);
}
/* NV_CTRL_REFRESH_RATE */
ret = NvCtrlGetAttribute(ctk_display_device_tv->handle,
NV_CTRL_REFRESH_RATE,
&val);
if (ret == NvCtrlSuccess) {
float fvalue = ((float)(val)) / 100.0f;
snprintf(str, 32, "%.2f Hz", fvalue);
gtk_label_set_text(GTK_LABEL(ctk_display_device_tv->txt_refresh_rate),
str);
} else {
gtk_label_set_text
(GTK_LABEL(ctk_display_device_tv->txt_refresh_rate),
"Unknown");
}
}
static void reset_slider(CtkDisplayDeviceTv *ctk_display_device_tv,
GtkWidget *scale)
{
GtkAdjustment *adj;
gint attribute;
ReturnStatus ret;
gint val;
adj = CTK_SCALE(scale)->gtk_adjustment;
if (!adj) return;
if (!get_scale_active(CTK_SCALE(scale))) return;
attribute = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(adj), "attribute"));
ret = NvCtrlGetAttribute(ctk_display_device_tv->handle, attribute, &val);
if (ret != NvCtrlSuccess) return;
g_signal_handlers_block_matched(adj, G_SIGNAL_MATCH_FUNC, 0, 0, NULL,
G_CALLBACK(adjustment_value_changed),
NULL);
gtk_adjustment_set_value(GTK_ADJUSTMENT(adj), val);
g_signal_handlers_unblock_matched(adj, G_SIGNAL_MATCH_FUNC, 0, 0, NULL,
G_CALLBACK(adjustment_value_changed),
NULL);
} /* reset_slider() */
ReturnStatus NvCtrlSetColorAttributes(NvCtrlAttributeHandle *handle,
float c[3],
float b[3],
float g[3],
unsigned int bitmask)
{
ReturnStatus status;
int val = 0;
NvCtrlAttributePrivateHandle *h = (NvCtrlAttributePrivateHandle *) handle;
status = NvCtrlGetAttribute(h, NV_CTRL_ATTR_RANDR_GAMMA_AVAILABLE, &val);
if (status == NvCtrlSuccess && val) {
switch (h->target_type) {
case NV_CTRL_TARGET_TYPE_X_SCREEN:
return NvCtrlVidModeSetColorAttributes(h, c, b, g, bitmask);
case NV_CTRL_TARGET_TYPE_DISPLAY:
return NvCtrlXrandrSetColorAttributes(h, c, b, g, bitmask);
default:
return NvCtrlBadHandle;
}
} else if ((status != NvCtrlSuccess || !val) &&
h->target_type == NV_CTRL_TARGET_TYPE_X_SCREEN) {
return NvCtrlVidModeSetColorAttributes(h, c, b, g, bitmask);
}
return NvCtrlError;
}
static gboolean update_chip_info(InfoEntry *entry)
{
CtkDisplayDevice *ctk_object = entry->ctk_object;
CtrlTarget *ctrl_target = ctk_object->ctrl_target;
ReturnStatus ret;
gint val;
const gchar *str;
ret = NvCtrlGetAttribute(ctrl_target,
NV_CTRL_FLATPANEL_CHIP_LOCATION, &val);
if (ret != NvCtrlSuccess) {
return FALSE;
}
switch (val) {
case NV_CTRL_FLATPANEL_CHIP_LOCATION_INTERNAL:
str = "Internal";
break;
case NV_CTRL_FLATPANEL_CHIP_LOCATION_EXTERNAL:
str = "External";
break;
default:
str = "Unknown";
break;
}
gtk_label_set_text(GTK_LABEL(entry->txt), str);
return TRUE;
}
static gboolean update_vrr_type_info(InfoEntry *entry)
{
CtkDisplayDevice *ctk_object = entry->ctk_object;
CtrlTarget *ctrl_target = ctk_object->ctrl_target;
ReturnStatus ret;
gint val;
const char *str;
ret = NvCtrlGetAttribute(ctrl_target,
NV_CTRL_DISPLAY_VRR_MODE, &val);
if (ret != NvCtrlSuccess) {
return FALSE;
}
switch (val) {
case NV_CTRL_DISPLAY_VRR_MODE_GSYNC:
str = "G-SYNC";
break;
case NV_CTRL_DISPLAY_VRR_MODE_GSYNC_COMPATIBLE:
str = "G-SYNC Compatible";
break;
case NV_CTRL_DISPLAY_VRR_MODE_GSYNC_COMPATIBLE_UNVALIDATED:
str = "G-SYNC Unvalidated";
break;
default:
case NV_CTRL_DISPLAY_VRR_MODE_NONE:
str = "None";
break;
}
gtk_label_set_text(GTK_LABEL(entry->txt), str);
return TRUE;
}
static gboolean update_signal_info(InfoEntry *entry)
{
CtkDisplayDevice *ctk_object = entry->ctk_object;
CtrlTarget *ctrl_target = ctk_object->ctrl_target;
ReturnStatus ret;
gint val;
const char *str;
ret = NvCtrlGetAttribute(ctrl_target, NV_CTRL_FLATPANEL_SIGNAL, &val);
if (ret != NvCtrlSuccess) {
return FALSE;
}
switch (val) {
case NV_CTRL_FLATPANEL_SIGNAL_LVDS:
str = "LVDS";
break;
case NV_CTRL_FLATPANEL_SIGNAL_TMDS:
str = "TMDS";
break;
case NV_CTRL_FLATPANEL_SIGNAL_DISPLAYPORT:
str = "DisplayPort";
break;
default:
str = "Unknown";
break;
}
gtk_label_set_text(GTK_LABEL(entry->txt), str);
ctk_object->signal_type = val;
return TRUE;
}
/*****
*
* Signal handler - User clicked the 'reset hardware defaults' button.
*
*/
static void reset_clocks_clicked(GtkWidget *widget, gpointer user_data)
{
CtkClocks *ctk_object = CTK_CLOCKS(user_data);
int clocks;
ReturnStatus ret;
/* Get the default clock frequencies */
ret = NvCtrlGetAttribute(ctk_object->handle,
(ctk_object->clocks_being_modified==CLOCKS_2D) ?
NV_CTRL_GPU_DEFAULT_2D_CLOCK_FREQS :
NV_CTRL_GPU_DEFAULT_3D_CLOCK_FREQS,
&clocks);
if ( ret != NvCtrlSuccess )
goto fail;
/* Set clock frequencies to use default values */
ret = NvCtrlSetAttribute(ctk_object->handle,
(ctk_object->clocks_being_modified==CLOCKS_2D) ?
NV_CTRL_GPU_2D_CLOCK_FREQS :
NV_CTRL_GPU_3D_CLOCK_FREQS,
clocks);
if ( ret != NvCtrlSuccess )
goto fail;
/* Set slider positions */
set_clocks_value(ctk_object, clocks, ctk_object->clocks_being_modified);
ctk_config_statusbar_message(ctk_object->ctk_config,
"Reset %s clock frequency "
"hardware defaults.",
(ctk_object->clocks_being_modified==CLOCKS_2D)?
"2D":"3D");
/* Disable the apply button */
gtk_widget_set_sensitive(ctk_object->apply_button, False);
/* Disable the reset button */
gtk_widget_set_sensitive(ctk_object->reset_button, False);
return;
fail:
ctk_config_statusbar_message(ctk_object->ctk_config,
"Failed to reset clock frequencies!");
return;
} /* reset_clocks_clicked() */
static void setup_scale(CtkDisplayDeviceTv *ctk_display_device_tv,
int attribute, GtkWidget *scale)
{
ReturnStatus ret0, ret1;
NVCTRLAttributeValidValuesRec valid;
NvCtrlAttributeHandle *handle = ctk_display_device_tv->handle;
int val;
GtkAdjustment *adj = CTK_SCALE(scale)->gtk_adjustment;
/* Read settings from X server */
ret0 = NvCtrlGetValidAttributeValues(handle, attribute, &valid);
ret1 = NvCtrlGetAttribute(handle, attribute, &val);
if ((ret0 == NvCtrlSuccess) && (ret1 == NvCtrlSuccess) &&
(valid.type == ATTRIBUTE_TYPE_RANGE)) {
g_signal_handlers_block_by_func(adj, adjustment_value_changed,
ctk_display_device_tv);
adj->lower = valid.u.range.min;
adj->upper = valid.u.range.max;
gtk_adjustment_changed(GTK_ADJUSTMENT(adj));
gtk_adjustment_set_value(GTK_ADJUSTMENT(adj), val);
g_signal_handlers_unblock_by_func(adj, adjustment_value_changed,
ctk_display_device_tv);
g_object_set_data(G_OBJECT(adj), "attribute active",
GINT_TO_POINTER(1));
gtk_widget_set_sensitive(scale, TRUE);
gtk_widget_show(scale);
} else {
g_object_set_data(G_OBJECT(adj), "attribute active",
GINT_TO_POINTER(0));
gtk_widget_set_sensitive(scale, FALSE);
gtk_widget_hide(scale);
}
} /* setup_scale() */
static gboolean update_vrr_enabled_info(InfoEntry *entry)
{
CtkDisplayDevice *ctk_object = entry->ctk_object;
CtrlTarget *ctrl_target = ctk_object->ctrl_target;
ReturnStatus ret;
gint val;
ret = NvCtrlGetAttribute(ctrl_target,
NV_CTRL_DISPLAY_VRR_ENABLED, &val);
if (ret != NvCtrlSuccess) {
return FALSE;
}
gtk_label_set_text(GTK_LABEL(entry->txt), val ? "Yes" : "No");
return TRUE;
}
static gboolean update_multistream_info(InfoEntry *entry)
{
CtkDisplayDevice *ctk_object = entry->ctk_object;
CtrlTarget *ctrl_target = ctk_object->ctrl_target;
ReturnStatus ret;
gint val;
ret = NvCtrlGetAttribute(ctrl_target, NV_CTRL_DISPLAYPORT_IS_MULTISTREAM,
&val);
if (ret != NvCtrlSuccess) {
return FALSE;
}
gtk_label_set_text(GTK_LABEL(entry->txt), val ? "Yes": "No");
return TRUE;
}
/*****
*
* Callback Function - This function gets called when the GPU Overclocking
* page gets selected from the tree view.
*
*/
void ctk_clocks_select(GtkWidget *widget)
{
CtkClocks *ctk_object = CTK_CLOCKS(widget);
ReturnStatus ret;
int value;
/* See if we're busy probing for optimal clocks so we can tell the user */
ret = NvCtrlGetAttribute(ctk_object->handle,
NV_CTRL_GPU_OPTIMAL_CLOCK_FREQS_DETECTION_STATE,
&value);
if ( ret == NvCtrlSuccess &&
value == NV_CTRL_GPU_OPTIMAL_CLOCK_FREQS_DETECTION_STATE_BUSY ) {
ctk_config_statusbar_message(ctk_object->ctk_config, "%s",
__detect_wait_msg);
}
}
static void init_composite_termination(CtkGvoSync *ctk_gvo_sync)
{
ReturnStatus ret;
gint val;
if (!ctk_gvo_sync->composite_termination_button) return;
ret = NvCtrlGetAttribute(ctk_gvo_sync->handle,
NV_CTRL_GVO_COMPOSITE_TERMINATION, &val);
if (ret != NvCtrlSuccess) {
val = NV_CTRL_GVO_COMPOSITE_TERMINATION_DISABLE;
}
gtk_toggle_button_set_active
(GTK_TOGGLE_BUTTON(ctk_gvo_sync->composite_termination_button),
val == NV_CTRL_GVO_COMPOSITE_TERMINATION_ENABLE);
} /* init_composite_termination() */
static GtkWidget *create_check_button(CtkXVideo *ctk_xvideo,
GtkWidget *vbox,
GtkWidget *button,
const gchar *name,
const char *help,
gint attribute,
unsigned int bit)
{
GtkWidget *check_button;
ReturnStatus ret;
int val;
/* get the attribute value */
ret = NvCtrlGetAttribute(ctk_xvideo->handle, attribute, &val);
if (ret != NvCtrlSuccess) return NULL;
check_button = gtk_check_button_new_with_label(name);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_button), val);
g_signal_connect(G_OBJECT(check_button), "toggled",
G_CALLBACK(check_button_toggled),
(gpointer) ctk_xvideo);
g_signal_connect_swapped(G_OBJECT(check_button), "toggled",
G_CALLBACK(set_button_sensitive),
(gpointer) button);
g_object_set_data(G_OBJECT(check_button), "xvideo_attribute",
GINT_TO_POINTER(attribute));
ctk_config_set_tooltip(ctk_xvideo->ctk_config, check_button, name);
gtk_box_pack_start(GTK_BOX(vbox), check_button, FALSE, FALSE, 0);
ctk_xvideo->active_attributes |= bit;
ctk_config_set_tooltip(ctk_xvideo->ctk_config, check_button, help);
return check_button;
} /* create_check_button() */
static void add_color_correction_tab(CtkDisplayDevice *ctk_object,
CtkConfig *ctk_config,
CtkEvent *ctk_event,
GtkWidget *notebook,
ParsedAttribute *p)
{
CtrlTarget *ctrl_target = ctk_object->ctrl_target;
ReturnStatus ret;
gint val;
GtkWidget *ctk_color_correction;
GtkWidget *box;
ret = NvCtrlGetAttribute(ctrl_target,
NV_CTRL_ATTR_RANDR_GAMMA_AVAILABLE, &val);
if (ret != NvCtrlSuccess) {
return;
}
if (val != 1) {
return;
}
ctk_color_correction = ctk_color_correction_new(ctrl_target,
ctk_config,
p,
ctk_event);
if (ctk_color_correction == NULL) {
return;
}
ctk_object->color_correction_available = TRUE;
box = gtk_hbox_new(FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER(box), FRAME_PADDING);
gtk_box_pack_start(GTK_BOX(box), ctk_color_correction, TRUE, TRUE, 0);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), box,
gtk_label_new("Color Correction"));
gtk_widget_show(box);
}
static void reset_check_button(CtkXVideo *ctk_xvideo,
GtkWidget *check_button,
gint attribute)
{
gint val;
if (!check_button) return;
NvCtrlGetAttribute(ctk_xvideo->handle, attribute, &val);
g_signal_handlers_block_matched
(G_OBJECT(check_button), G_SIGNAL_MATCH_FUNC, 0, 0, NULL,
G_CALLBACK(check_button_toggled), NULL);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_button), val);
g_signal_handlers_unblock_matched
(G_OBJECT(check_button), G_SIGNAL_MATCH_FUNC, 0, 0, NULL,
G_CALLBACK(check_button_toggled), NULL);
sensitize_radio_buttons(ctk_xvideo);
} /* reset_check_button() */
static void reset_default_config_button_clicked(GtkWidget *widget,
gpointer user_data)
{
gboolean status;
ReturnStatus ret;
CtkEcc *ctk_ecc = CTK_ECC(user_data);
CtrlTarget *ctrl_target = ctk_ecc->ctrl_target;
/* get default status and set it to ECC configuration */
ret = NvCtrlGetAttribute(ctrl_target,
NV_CTRL_GPU_ECC_DEFAULT_CONFIGURATION,
&status);
if (ret != NvCtrlSuccess) {
ctk_config_statusbar_message(ctk_ecc->ctk_config,
"Failed to get default configuration!");
return;
}
ret = NvCtrlSetAttribute(ctrl_target,
NV_CTRL_GPU_ECC_CONFIGURATION,
status);
if (ret != NvCtrlSuccess) {
ctk_config_statusbar_message(ctk_ecc->ctk_config,
"Failed to set default configuration!");
return;
}
ctk_ecc->ecc_configured = status;
/* update ECC configuration button status */
ecc_set_config_status(ctk_ecc);
/* show popup dialog*/
show_ecc_toggle_warning_dlg(ctk_ecc);
gtk_widget_set_sensitive(ctk_ecc->reset_default_config_button, FALSE);
ctk_config_statusbar_message(ctk_ecc->ctk_config,
"Set to default configuration.");
} /* reset_default_config_button_clicked() */
static void setup_scale(CtkImageSliders *ctk_image_sliders,
int attribute,
GtkWidget *scale)
{
CtrlTarget *ctrl_target = ctk_image_sliders->ctrl_target;
ReturnStatus ret0, ret1;
CtrlAttributeValidValues valid;
int val;
GtkAdjustment *adj = CTK_SCALE(scale)->gtk_adjustment;
/* Read settings from X server */
ret0 = NvCtrlGetValidAttributeValues(ctrl_target, attribute, &valid);
ret1 = NvCtrlGetAttribute(ctrl_target, attribute, &val);
if ((ret0 == NvCtrlSuccess) && (ret1 == NvCtrlSuccess) &&
(valid.valid_type == CTRL_ATTRIBUTE_VALID_TYPE_RANGE)) {
g_signal_handlers_block_by_func(adj, scale_value_changed,
ctk_image_sliders);
ctk_adjustment_set_lower(adj, valid.range.min);
ctk_adjustment_set_upper(adj, valid.range.max);
gtk_adjustment_changed(GTK_ADJUSTMENT(adj));
gtk_adjustment_set_value(GTK_ADJUSTMENT(adj), val);
g_signal_handlers_unblock_by_func(adj, scale_value_changed,
ctk_image_sliders);
gtk_widget_set_sensitive(scale, TRUE);
} else {
gtk_widget_set_sensitive(scale, FALSE);
}
} /* setup_scale() */
static void setup_scale(CtkImageSliders *ctk_image_sliders,
int attribute,
GtkWidget *scale)
{
ReturnStatus ret0, ret1;
NVCTRLAttributeValidValuesRec valid;
NvCtrlAttributeHandle *handle = ctk_image_sliders->handle;
int val;
GtkAdjustment *adj = CTK_SCALE(scale)->gtk_adjustment;
/* Read settings from X server */
ret0 = NvCtrlGetValidAttributeValues(handle, attribute, &valid);
ret1 = NvCtrlGetAttribute(handle, attribute, &val);
if ((ret0 == NvCtrlSuccess) && (ret1 == NvCtrlSuccess) &&
(valid.type == ATTRIBUTE_TYPE_RANGE)) {
g_signal_handlers_block_by_func(adj, scale_value_changed,
ctk_image_sliders);
adj->lower = valid.u.range.min;
adj->upper = valid.u.range.max;
gtk_adjustment_changed(GTK_ADJUSTMENT(adj));
gtk_adjustment_set_value(GTK_ADJUSTMENT(adj), val);
g_signal_handlers_unblock_by_func(adj, scale_value_changed,
ctk_image_sliders);
gtk_widget_set_sensitive(scale, TRUE);
} else {
gtk_widget_set_sensitive(scale, FALSE);
}
} /* setup_scale() */
static gboolean update_connector_type_info(InfoEntry *entry)
{
CtkDisplayDevice *ctk_object = entry->ctk_object;
CtrlTarget *ctrl_target = ctk_object->ctrl_target;
ReturnStatus ret;
gint val;
const char *str;
ret = NvCtrlGetAttribute(ctrl_target,
NV_CTRL_DISPLAYPORT_CONNECTOR_TYPE, &val);
if (ret != NvCtrlSuccess) {
return FALSE;
}
switch (val) {
case NV_CTRL_DISPLAYPORT_CONNECTOR_TYPE_DISPLAYPORT:
str = "DisplayPort";
break;
case NV_CTRL_DISPLAYPORT_CONNECTOR_TYPE_HDMI:
str = "HDMI";
break;
case NV_CTRL_DISPLAYPORT_CONNECTOR_TYPE_DVI:
str = "DVI";
break;
case NV_CTRL_DISPLAYPORT_CONNECTOR_TYPE_VGA:
str = "VGA";
break;
default:
case NV_CTRL_DISPLAYPORT_CONNECTOR_TYPE_UNKNOWN:
str = "Unknown";
break;
}
gtk_label_set_text(GTK_LABEL(entry->txt), str);
return TRUE;
}
static void reset_slider(CtkXVideo *ctk_xvideo,
GtkWidget *slider,
gint attribute)
{
GtkAdjustment *adjustment;
gint val;
if (!slider) return;
adjustment = CTK_SCALE(slider)->gtk_adjustment;
NvCtrlGetAttribute(ctk_xvideo->handle, attribute, &val);
g_signal_handlers_block_matched
(G_OBJECT(adjustment), G_SIGNAL_MATCH_FUNC, 0, 0, NULL,
G_CALLBACK(slider_changed), NULL);
gtk_adjustment_set_value(GTK_ADJUSTMENT(adjustment), val);
g_signal_handlers_unblock_matched
(G_OBJECT(adjustment), G_SIGNAL_MATCH_FUNC, 0, 0, NULL,
G_CALLBACK(slider_changed), NULL);
} /* reset_slider() */
GtkWidget* ctk_image_sliders_new(NvCtrlAttributeHandle *handle,
CtkConfig *ctk_config, CtkEvent *ctk_event,
GtkWidget *reset_button,
char *name)
{
CtkImageSliders *ctk_image_sliders;
GObject *object;
GtkWidget *frame;
GtkWidget *vbox;
ReturnStatus status;
gint val;
/*
* now that we know that we will have atleast one attribute,
* create the object
*/
object = g_object_new(CTK_TYPE_IMAGE_SLIDERS, NULL);
if (!object) return NULL;
ctk_image_sliders = CTK_IMAGE_SLIDERS(object);
ctk_image_sliders->handle = handle;
ctk_image_sliders->ctk_config = ctk_config;
ctk_image_sliders->ctk_event = ctk_event;
ctk_image_sliders->reset_button = reset_button;
ctk_image_sliders->name = name;
/* create the frame and vbox */
frame = gtk_frame_new(NULL);
vbox = gtk_vbox_new(FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER(vbox), FRAME_PADDING);
gtk_container_add(GTK_CONTAINER(frame), vbox);
gtk_box_pack_start(GTK_BOX(object), frame, FALSE, FALSE, 0);
ctk_image_sliders->frame = frame;
/* Digital Vibrance */
ctk_image_sliders->digital_vibrance =
add_scale(ctk_config,
NV_CTRL_DIGITAL_VIBRANCE, "Digital Vibrance",
__digital_vibrance_help, G_TYPE_INT,
0, /* default value */
ctk_image_sliders);
g_signal_connect(G_OBJECT(ctk_event),
CTK_EVENT_NAME(NV_CTRL_DIGITAL_VIBRANCE),
G_CALLBACK(scale_value_received),
(gpointer) ctk_image_sliders);
gtk_box_pack_start(GTK_BOX(vbox), ctk_image_sliders->digital_vibrance,
TRUE, TRUE, 0);
/* Image Sharpening */
status = NvCtrlGetAttribute(ctk_image_sliders->handle,
NV_CTRL_IMAGE_SHARPENING_DEFAULT,
&val);
if (status != NvCtrlSuccess) {
val = 0;
}
ctk_image_sliders->image_sharpening =
add_scale(ctk_config,
NV_CTRL_IMAGE_SHARPENING, "Image Sharpening",
__image_sharpening_help, G_TYPE_INT, val, ctk_image_sliders);
g_signal_connect(G_OBJECT(ctk_event),
CTK_EVENT_NAME(NV_CTRL_IMAGE_SHARPENING),
G_CALLBACK(scale_value_received),
(gpointer) ctk_image_sliders);
gtk_box_pack_start(GTK_BOX(vbox), ctk_image_sliders->image_sharpening,
TRUE, TRUE, 0);
gtk_widget_show_all(GTK_WIDGET(object));
/* update the GUI */
ctk_image_sliders_setup(ctk_image_sliders);
return GTK_WIDGET(object);
} /* ctk_image_sliders_new() */
GtkWidget* ctk_ecc_new(CtrlTarget *ctrl_target,
CtkConfig *ctk_config,
CtkEvent *ctk_event)
{
GObject *object;
CtkEcc *ctk_ecc;
GtkWidget *hbox, *hbox2, *vbox, *hsep, *hseparator, *table;
GtkWidget *banner, *label, *eventbox;
int64_t sbit_error;
int64_t aggregate_sbit_error;
int64_t dbit_error;
int64_t aggregate_dbit_error;
gint ecc_config_supported;
gint val, row = 0;
gboolean sbit_error_available;
gboolean aggregate_sbit_error_available;
gboolean dbit_error_available;
gboolean aggregate_dbit_error_available;
gboolean ecc_enabled;
gboolean ecc_default_status;
ReturnStatus ret;
gchar *ecc_enabled_string;
gchar *str = NULL;
/* make sure we have a handle */
g_return_val_if_fail((ctrl_target != NULL) &&
(ctrl_target->h != NULL), NULL);
/*
* check if ECC support available.
*/
ret = NvCtrlGetAttribute(ctrl_target,
NV_CTRL_GPU_ECC_SUPPORTED,
&val);
if (ret != NvCtrlSuccess || val != NV_CTRL_GPU_ECC_SUPPORTED_TRUE) {
return NULL;
}
/* create the CtkEcc object */
object = g_object_new(CTK_TYPE_ECC, NULL);
ctk_ecc = CTK_ECC(object);
ctk_ecc->ctrl_target = ctrl_target;
ctk_ecc->ctk_config = ctk_config;
ctk_ecc->ecc_toggle_warning_dlg_shown = FALSE;
sbit_error_available = TRUE;
dbit_error_available = TRUE;
aggregate_sbit_error_available = TRUE;
aggregate_dbit_error_available = TRUE;
sbit_error = 0;
dbit_error = 0;
aggregate_sbit_error = 0;
aggregate_dbit_error = 0;
/* Query ECC Status */
ret = NvCtrlGetAttribute(ctrl_target, NV_CTRL_GPU_ECC_STATUS,
&val);
if (ret != NvCtrlSuccess || val == NV_CTRL_GPU_ECC_STATUS_DISABLED) {
ecc_enabled = FALSE;
ecc_enabled_string = "Disabled";
} else {
ecc_enabled = TRUE;
ecc_enabled_string = "Enabled";
}
ctk_ecc->ecc_enabled = ecc_enabled;
/* Query ECC Configuration */
ret = NvCtrlGetAttribute(ctrl_target, NV_CTRL_GPU_ECC_CONFIGURATION,
&val);
if (ret != NvCtrlSuccess ||
val == NV_CTRL_GPU_ECC_CONFIGURATION_DISABLED) {
ctk_ecc->ecc_configured = FALSE;
} else {
ctk_ecc->ecc_configured = TRUE;
}
/* get default status */
ret = NvCtrlGetAttribute(ctrl_target,
NV_CTRL_GPU_ECC_DEFAULT_CONFIGURATION,
&val);
if (ret != NvCtrlSuccess ||
val == NV_CTRL_GPU_ECC_DEFAULT_CONFIGURATION_DISABLED) {
ecc_default_status = FALSE;
} else {
ecc_default_status = TRUE;
}
/* Query ECC errors */
ret = NvCtrlGetAttribute64(ctrl_target,
NV_CTRL_GPU_ECC_SINGLE_BIT_ERRORS,
&sbit_error);
if (ret != NvCtrlSuccess) {
sbit_error_available = FALSE;
}
ret = NvCtrlGetAttribute64(ctrl_target,
NV_CTRL_GPU_ECC_DOUBLE_BIT_ERRORS,
&dbit_error);
if (ret != NvCtrlSuccess) {
dbit_error_available = FALSE;
}
ret = NvCtrlGetAttribute64(ctrl_target,
NV_CTRL_GPU_ECC_AGGREGATE_SINGLE_BIT_ERRORS,
&aggregate_sbit_error);
if (ret != NvCtrlSuccess) {
aggregate_sbit_error_available = FALSE;
}
ret = NvCtrlGetAttribute64(ctrl_target,
NV_CTRL_GPU_ECC_AGGREGATE_DOUBLE_BIT_ERRORS,
&aggregate_dbit_error);
if (ret != NvCtrlSuccess) {
aggregate_dbit_error_available = FALSE;
}
ctk_ecc->sbit_error_available = sbit_error_available;
ctk_ecc->aggregate_sbit_error_available = aggregate_sbit_error_available;
ctk_ecc->dbit_error_available = dbit_error_available;
ctk_ecc->aggregate_dbit_error_available = aggregate_dbit_error_available;
/* Query ECC configuration supported */
ret = NvCtrlGetAttribute(ctrl_target,
NV_CTRL_GPU_ECC_CONFIGURATION_SUPPORTED,
&ecc_config_supported);
if (ret != NvCtrlSuccess) {
ecc_config_supported = 0;
}
/* set container properties for the CtkEcc widget */
gtk_box_set_spacing(GTK_BOX(ctk_ecc), 5);
/* banner */
banner = ctk_banner_image_new(BANNER_ARTWORK_GPU);
gtk_box_pack_start(GTK_BOX(object), banner, FALSE, FALSE, 0);
vbox = gtk_vbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX(object), vbox, TRUE, TRUE, 0);
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
label = gtk_label_new("ECC Status");
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
hseparator = gtk_hseparator_new();
gtk_box_pack_start(GTK_BOX(hbox), hseparator, TRUE, TRUE, 5);
table = gtk_table_new(1, 2, FALSE);
gtk_box_pack_start(GTK_BOX(vbox), table, FALSE, FALSE, 0);
gtk_table_set_row_spacings(GTK_TABLE(table), 3);
gtk_table_set_col_spacings(GTK_TABLE(table), 15);
gtk_container_set_border_width(GTK_CONTAINER(table), 5);
/* ECC Status */
hbox2 = gtk_hbox_new(FALSE, 0);
gtk_table_attach(GTK_TABLE(table), hbox2, 0, 1, row, row+1,
GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
label = gtk_label_new("ECC:");
gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
gtk_box_pack_start(GTK_BOX(hbox2), label, FALSE, FALSE, 0);
eventbox = gtk_event_box_new();
gtk_table_attach(GTK_TABLE(table), eventbox, 1, 2, row, row+1,
GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
label = gtk_label_new(ecc_enabled_string);
gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
gtk_container_add(GTK_CONTAINER(eventbox), label);
ctk_config_set_tooltip(ctk_config, eventbox, __ecc_status_help);
ctk_ecc->status = label;
row += 3;
/* Add ECC Errors */
if (sbit_error_available && dbit_error_available) {
ctk_ecc->sbit_error =
add_table_int_row(ctk_config, table, __sbit_error_help,
"Single-bit ECC Errors:", sbit_error,
row, ecc_enabled);
row += 1; // add vertical padding between rows
ctk_ecc->dbit_error =
add_table_int_row(ctk_config, table, __dbit_error_help,
"Double-bit ECC Errors:", dbit_error,
row, ecc_enabled);
row += 3; // add vertical padding between rows
}
if (aggregate_sbit_error_available && aggregate_dbit_error_available) {
ctk_ecc->aggregate_sbit_error =
add_table_int_row(ctk_config, table, __aggregate_sbit_error_help,
"Aggregate Single-bit ECC Errors:",
aggregate_sbit_error, row, ecc_enabled);
row += 1; // add vertical padding between rows
ctk_ecc->aggregate_dbit_error =
add_table_int_row(ctk_config, table, __aggregate_dbit_error_help,
"Aggregate Double-bit ECC Errors:",
aggregate_dbit_error, row, ecc_enabled);
}
/* ECC configuration settings */
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
label = gtk_label_new("ECC Configuration");
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
hsep = gtk_hseparator_new();
gtk_box_pack_start(GTK_BOX(hbox), hsep, TRUE, TRUE, 5);
hbox2 = gtk_hbox_new(FALSE, 0);
ctk_ecc->configuration_status =
gtk_check_button_new_with_label("Enable ECC");
gtk_box_pack_start(GTK_BOX(hbox2),
ctk_ecc->configuration_status, FALSE, FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER(hbox2), 5);
gtk_box_pack_start(GTK_BOX(vbox), hbox2, FALSE, FALSE, 0);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(ctk_ecc->configuration_status),
ctk_ecc->ecc_configured);
ctk_config_set_tooltip(ctk_config, ctk_ecc->configuration_status,
__configuration_status_help);
g_signal_connect(G_OBJECT(ctk_ecc->configuration_status), "clicked",
G_CALLBACK(ecc_config_button_toggled),
(gpointer) ctk_ecc);
g_signal_connect(G_OBJECT(ctk_event),
CTK_EVENT_NAME(NV_CTRL_GPU_ECC_CONFIGURATION),
G_CALLBACK(ecc_configuration_update_received),
(gpointer) ctk_ecc);
gtk_widget_set_sensitive(ctk_ecc->configuration_status, ecc_config_supported);
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(ctk_ecc), hbox, FALSE, FALSE, 0);
/* Add buttons */
if (sbit_error_available && dbit_error_available) {
ctk_ecc->clear_button = gtk_button_new_with_label("Clear ECC Errors");
gtk_box_pack_end(GTK_BOX(hbox), ctk_ecc->clear_button, FALSE, FALSE, 0);
ctk_config_set_tooltip(ctk_config, ctk_ecc->clear_button,
__clear_button_help);
gtk_widget_set_sensitive(ctk_ecc->clear_button, ecc_enabled);
g_signal_connect(G_OBJECT(ctk_ecc->clear_button), "clicked",
G_CALLBACK(clear_ecc_errors_button_clicked),
(gpointer) ctk_ecc);
}
if (aggregate_sbit_error_available && aggregate_dbit_error_available) {
ctk_ecc->clear_aggregate_button =
gtk_button_new_with_label("Clear Aggregate ECC Errors");
gtk_box_pack_end(GTK_BOX(hbox), ctk_ecc->clear_aggregate_button,
FALSE, FALSE, 0);
ctk_config_set_tooltip(ctk_config, ctk_ecc->clear_button,
__clear_aggregate_button_help);
gtk_widget_set_sensitive(ctk_ecc->clear_aggregate_button, ecc_enabled);
g_signal_connect(G_OBJECT(ctk_ecc->clear_aggregate_button),
"clicked",
G_CALLBACK(clear_aggregate_ecc_errors_button_clicked),
(gpointer) ctk_ecc);
}
ctk_ecc->reset_default_config_button =
gtk_button_new_with_label("Reset Default Configuration");
eventbox = gtk_event_box_new();
gtk_container_add(GTK_CONTAINER(eventbox),
ctk_ecc->reset_default_config_button);
gtk_box_pack_end(GTK_BOX(hbox), eventbox, FALSE, FALSE, 5);
ctk_config_set_tooltip(ctk_config, ctk_ecc->reset_default_config_button,
__reset_default_config_button_help);
gtk_widget_set_sensitive(ctk_ecc->reset_default_config_button,
ecc_config_supported &&
(ecc_enabled != ecc_default_status));
g_signal_connect(G_OBJECT(ctk_ecc->reset_default_config_button),
"clicked",
G_CALLBACK(reset_default_config_button_clicked),
(gpointer) ctk_ecc);
/* Register a timer callback to update Ecc status info */
str = g_strdup_printf("ECC Settings (GPU %d)",
NvCtrlGetTargetId(ctrl_target));
ctk_config_add_timer(ctk_ecc->ctk_config,
DEFAULT_UPDATE_ECC_STATUS_INFO_TIME_INTERVAL,
str,
(GSourceFunc) update_ecc_info,
(gpointer) ctk_ecc);
g_free(str);
gtk_widget_show_all(GTK_WIDGET(ctk_ecc));
update_ecc_info(ctk_ecc);
return GTK_WIDGET(ctk_ecc);
}
/*
* ctk_dithering_controls_setup() - Setup routine for dithering attributes. Used
* in DFP setup stage as well as for updating the GUI when there is change in
* dithering mode or config (enabled/disabled).
*/
void ctk_dithering_controls_setup(CtkDitheringControls *ctk_dithering_controls)
{
GtkWidget *menu, *menu_item = NULL;
gint val, i;
if (!ctk_dithering_controls) {
return;
}
/* dithering */
if (NvCtrlSuccess !=
NvCtrlGetAttribute(ctk_dithering_controls->handle,
NV_CTRL_DITHERING, &val)) {
val = NV_CTRL_DITHERING_AUTO;
}
g_signal_handlers_block_by_func
(G_OBJECT(ctk_dithering_controls->dithering_config_menu),
G_CALLBACK(dithering_config_menu_changed),
(gpointer) ctk_dithering_controls);
gtk_option_menu_set_history
(GTK_OPTION_MENU(ctk_dithering_controls->dithering_config_menu),
val);
g_signal_handlers_unblock_by_func
(G_OBJECT(ctk_dithering_controls->dithering_config_menu),
G_CALLBACK(dithering_config_menu_changed),
(gpointer) ctk_dithering_controls);
/* setup dithering modes */
build_dithering_mode_table(ctk_dithering_controls);
/* populate dropdown list for dithering modes */
menu = gtk_menu_new();
for (i = 0; i < ctk_dithering_controls->dithering_mode_table_size; i++) {
switch (ctk_dithering_controls->dithering_mode_table[i]) {
case NV_CTRL_DITHERING_MODE_DYNAMIC_2X2:
menu_item = gtk_menu_item_new_with_label("Dynamic 2x2");
break;
case NV_CTRL_DITHERING_MODE_STATIC_2X2:
menu_item = gtk_menu_item_new_with_label("Static 2x2");
break;
case NV_CTRL_DITHERING_MODE_TEMPORAL:
menu_item = gtk_menu_item_new_with_label("Temporal");
break;
default:
case NV_CTRL_DITHERING_MODE_AUTO:
menu_item = gtk_menu_item_new_with_label("Auto");
break;
}
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_item);
gtk_widget_show(menu_item);
}
g_signal_handlers_block_by_func
(G_OBJECT(ctk_dithering_controls->dithering_mode_menu),
G_CALLBACK(dithering_mode_menu_changed),
(gpointer) ctk_dithering_controls);
gtk_option_menu_set_menu
(GTK_OPTION_MENU(ctk_dithering_controls->dithering_mode_menu),
menu);
g_signal_handlers_unblock_by_func
(G_OBJECT(ctk_dithering_controls->dithering_mode_menu),
G_CALLBACK(dithering_mode_menu_changed),
(gpointer) ctk_dithering_controls);
if (!update_dithering_info((gpointer)ctk_dithering_controls)) {
gtk_widget_hide(ctk_dithering_controls->dithering_controls_box);
} else {
gtk_widget_show(ctk_dithering_controls->dithering_controls_box);
}
setup_reset_button(ctk_dithering_controls);
} /* ctk_dithering_controls_setup() */
static gboolean query_init_gvo_sync_state(CtkGvoSync *ctk_gvo_sync)
{
gint val;
ReturnStatus ret;
/* Check if this screen supports GVO */
ret = NvCtrlGetAttribute(ctk_gvo_sync->handle, NV_CTRL_GVO_SUPPORTED,
&val);
if ((ret != NvCtrlSuccess) || (val != NV_CTRL_GVO_SUPPORTED_TRUE)) {
/* GVO not available */
return FALSE;
}
/* Get this GVO device's capabilities */
ret = NvCtrlGetAttribute(ctk_gvo_sync->handle, NV_CTRL_GVO_CAPABILITIES,
&val);
if (ret != NvCtrlSuccess) return FALSE;
ctk_gvo_sync->caps = val;
/* Query the current input video formats */
ret = NvCtrlGetAttribute(ctk_gvo_sync->handle,
NV_CTRL_GVIO_DETECTED_VIDEO_FORMAT, &val);
if (ret != NvCtrlSuccess) {
val = NV_CTRL_GVIO_VIDEO_FORMAT_NONE;
}
ctk_gvo_sync->input_video_format = val;
/* Query the sync mode */
ret = NvCtrlGetAttribute(ctk_gvo_sync->handle, NV_CTRL_GVO_SYNC_MODE,
&val);
if (ret != NvCtrlSuccess) {
val = NV_CTRL_GVO_SYNC_MODE_FREE_RUNNING;
}
ctk_gvo_sync->sync_mode = val;
/* query COMPOSITE_SYNC_INPUT_DETECTED */
ret = NvCtrlGetAttribute(ctk_gvo_sync->handle,
NV_CTRL_GVO_COMPOSITE_SYNC_INPUT_DETECTED, &val);
if (ret != NvCtrlSuccess) {
val = NV_CTRL_GVO_COMPOSITE_SYNC_INPUT_DETECTED_FALSE;
}
ctk_gvo_sync->comp_sync_input_detected = val;
/* query COMPOSITE_SYNC_INPUT_DETECT_MODE */
ret = NvCtrlGetAttribute(ctk_gvo_sync->handle,
NV_CTRL_GVO_COMPOSITE_SYNC_INPUT_DETECT_MODE,
&val);
if (ret != NvCtrlSuccess) {
val = NV_CTRL_GVO_COMPOSITE_SYNC_INPUT_DETECT_MODE_AUTO;
}
ctk_gvo_sync->comp_mode = val;
/* query SDI_SYNC_INPUT_DETECTED */
ret = NvCtrlGetAttribute(ctk_gvo_sync->handle,
NV_CTRL_GVO_SDI_SYNC_INPUT_DETECTED, &val);
if (ret != NvCtrlSuccess) {
val = NV_CTRL_GVO_SDI_SYNC_INPUT_DETECTED_NONE;
}
ctk_gvo_sync->sdi_sync_input_detected = val;
/* query sync source */
ret = NvCtrlGetAttribute(ctk_gvo_sync->handle,
NV_CTRL_GVO_SYNC_SOURCE,
&val);
if (ret != NvCtrlSuccess) {
val = NV_CTRL_GVO_SYNC_SOURCE_SDI;
}
ctk_gvo_sync->sync_source = val;
/* Query framelock/genlock status */
ret = NvCtrlGetAttribute(ctk_gvo_sync->handle,
NV_CTRL_GVO_SYNC_LOCK_STATUS,
&val);
if (ret != NvCtrlSuccess) {
val = NV_CTRL_GVO_SYNC_LOCK_STATUS_UNLOCKED;
}
ctk_gvo_sync->sync_lock_status = val;
return TRUE;
} /* query_init_gvo_sync_state() */
GtkWidget* ctk_gvo_sync_new(NvCtrlAttributeHandle *handle,
GtkWidget *parent_window,
CtkConfig *ctk_config,
CtkEvent *ctk_event,
CtkGvo *gvo_parent)
{
GObject *object;
CtkGvoSync *ctk_gvo_sync;
GtkWidget *frame;
GtkWidget *hbox;
GtkWidget *label;
GtkWidget *alignment;
GtkWidget *button;
GtkWidget *table, *menu;
gint val, i;
NVCTRLAttributeValidValuesRec valid;
ReturnStatus ret;
gint row;
const char *help_text;
/* make sure we have a handle */
g_return_val_if_fail(handle != NULL, NULL);
/* create and initialize the object */
object = g_object_new(CTK_TYPE_GVO_SYNC, NULL);
ctk_gvo_sync = CTK_GVO_SYNC(object);
ctk_gvo_sync->handle = handle;
ctk_gvo_sync->parent_window = parent_window;
ctk_gvo_sync->ctk_config = ctk_config;
ctk_gvo_sync->ctk_event = ctk_event;
ctk_gvo_sync->gvo_parent = gvo_parent;
/* Query the current GVO state */
if ( !query_init_gvo_sync_state(ctk_gvo_sync) ) {
// Free the object
g_object_ref(object);
gtk_object_sink(GTK_OBJECT(object));
g_object_unref(object);
return NULL;
}
/* set container properties for the widget */
gtk_box_set_spacing(GTK_BOX(object), 10);
/* banner */
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(object), hbox, FALSE, FALSE, 0);
ctk_gvo_sync->banner_box = hbox;
/*
* Sync options
*/
frame = gtk_frame_new("Sync Options");
ctk_gvo_sync->frame = frame;
gtk_box_pack_start(GTK_BOX(object), frame, FALSE, FALSE, 0);
table = gtk_table_new(6, 2, FALSE);
gtk_table_set_row_spacings(GTK_TABLE(table), 0);
gtk_table_set_col_spacings(GTK_TABLE(table), 0);
gtk_container_add(GTK_CONTAINER(frame), table);
/* input video format */
label = gtk_label_new("Input Video Format: ");
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
gtk_table_attach(GTK_TABLE(table), label,
0, 1, 0, 1, GTK_FILL, GTK_FILL,
TABLE_PADDING, TABLE_PADDING);
hbox = gtk_hbox_new(FALSE, 5);
ctk_gvo_sync->input_video_format_text_entry = gtk_entry_new();
ctk_config_set_tooltip(ctk_config,
ctk_gvo_sync->input_video_format_text_entry,
__input_video_format_help);
gtk_entry_set_width_chars
(GTK_ENTRY(ctk_gvo_sync->input_video_format_text_entry),
max_input_video_format_text_entry_length());
gtk_widget_set_sensitive(ctk_gvo_sync->input_video_format_text_entry,
FALSE);
update_input_video_format_text_entry(ctk_gvo_sync);
gtk_box_pack_start(GTK_BOX(hbox),
ctk_gvo_sync->input_video_format_text_entry,
TRUE, TRUE, 0);
/* Input video format detect button */
button = gtk_toggle_button_new_with_label("Detect");
alignment = gtk_alignment_new(1, 1, 0, 0);
gtk_container_add(GTK_CONTAINER(alignment), button);
ctk_gvo_sync->input_video_format_detect_button = button;
ctk_config_set_tooltip(ctk_config, button,
__input_video_format_detect_help);
g_signal_connect(G_OBJECT(button), "toggled",
G_CALLBACK(detect_input_toggled), ctk_gvo_sync);
gtk_box_pack_start(GTK_BOX(hbox), alignment, FALSE, FALSE, 0);
gtk_table_attach(GTK_TABLE(table), hbox,
1, 2, 0, 1, GTK_FILL | GTK_EXPAND, GTK_FILL,
TABLE_PADDING, TABLE_PADDING);
/* Composite Termination */
if (ctk_gvo_sync->caps & NV_CTRL_GVO_CAPABILITIES_COMPOSITE_TERMINATION) {
button =
gtk_check_button_new_with_label("Enable Composite Termination");
ctk_config_set_tooltip(ctk_config, button,
__composite_termination_help);
alignment = gtk_alignment_new(1, 1, 0, 0);
gtk_container_add(GTK_CONTAINER(alignment), button);
gtk_table_attach(GTK_TABLE(table), alignment,
0, 2, 2, 3, GTK_FILL | GTK_EXPAND, GTK_FILL,
TABLE_PADDING, TABLE_PADDING);
ctk_gvo_sync->composite_termination_button = button;
init_composite_termination(ctk_gvo_sync);
g_signal_connect(G_OBJECT(button), "toggled",
G_CALLBACK(composite_termination_toggled),
ctk_gvo_sync);
row = 3;
} else {
ctk_gvo_sync->composite_termination_button = NULL;
row = 2;
}
/* Sync Mode */
menu = start_menu("Sync Mode: ", table, row);
ctk_drop_down_menu_append_item(CTK_DROP_DOWN_MENU(menu), "Free Running",
NV_CTRL_GVO_SYNC_MODE_FREE_RUNNING);
ctk_drop_down_menu_append_item(CTK_DROP_DOWN_MENU(menu), "GenLock",
NV_CTRL_GVO_SYNC_MODE_GENLOCK);
ctk_drop_down_menu_append_item(CTK_DROP_DOWN_MENU(menu), "FrameLock",
NV_CTRL_GVO_SYNC_MODE_FRAMELOCK);
finish_menu(menu, table, row);
row++;
ctk_gvo_sync->sync_mode_menu = menu;
ctk_drop_down_menu_set_tooltip(ctk_config, CTK_DROP_DOWN_MENU(menu),
__sync_mode_help);
ctk_drop_down_menu_set_current_value
(CTK_DROP_DOWN_MENU(ctk_gvo_sync->sync_mode_menu),
ctk_gvo_sync->sync_mode);
g_signal_connect(G_OBJECT(ctk_gvo_sync->sync_mode_menu), "changed",
G_CALLBACK(sync_mode_changed), (gpointer) ctk_gvo_sync);
/* Sync Format */
menu = start_menu("Sync Format: ", table, row);
for (i = 0; syncFormatNames[i].name; i++) {
ctk_drop_down_menu_append_item(CTK_DROP_DOWN_MENU(menu),
syncFormatNames[i].name,
syncFormatNames[i].format);
}
finish_menu(menu, table, row);
row++;
ctk_gvo_sync->sync_format_menu = menu;
ctk_drop_down_menu_set_tooltip(ctk_config, CTK_DROP_DOWN_MENU(menu),
__sync_format_help);
init_sync_format_menu(ctk_gvo_sync);
g_signal_connect(G_OBJECT(ctk_gvo_sync->sync_format_menu),
"changed", G_CALLBACK(sync_format_changed),
(gpointer) ctk_gvo_sync);
/* Sync Status */
label = gtk_label_new("Sync Status:");
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, row, row+1,
GTK_FILL, GTK_FILL, TABLE_PADDING, TABLE_PADDING);
ctk_gvo_sync->sync_lock_status_text = gtk_label_new("");
update_sync_lock_status_text(ctk_gvo_sync);
hbox = gtk_hbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX(hbox), ctk_gvo_sync->sync_lock_status_text,
FALSE, FALSE, 0);
gtk_table_attach(GTK_TABLE(table), hbox,
1, 2, row, row+1,
GTK_FILL /*| GTK_EXPAND*/, GTK_FILL,
TABLE_PADDING, TABLE_PADDING);
row++;
/*
* Synchronization Skew (Delay/Advance)
*/
/* NV_CTRL_GVO_SYNC_DELAY_PIXELS */
ret = NvCtrlGetValidAttributeValues(handle, NV_CTRL_GVO_SYNC_DELAY_PIXELS,
&valid);
if ((ret == NvCtrlSuccess) && (valid.type == ATTRIBUTE_TYPE_RANGE)) {
ret = NvCtrlGetAttribute(handle, NV_CTRL_GVO_SYNC_DELAY_PIXELS, &val);
if (ret != NvCtrlSuccess) val = 0;
if (ctk_gvo_sync->caps & NV_CTRL_GVO_CAPABILITIES_ADVANCE_SYNC_SKEW) {
label = gtk_label_new("HSync Advance:");
help_text = __hsync_advance_help;
} else {
label = gtk_label_new("HSync Delay:");
help_text = __hsync_delay_help;
}
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, row, row+1,
GTK_FILL, GTK_FILL, TABLE_PADDING, TABLE_PADDING);
ctk_gvo_sync->hsync_delay_spin_button =
gtk_spin_button_new_with_range(valid.u.range.min,
valid.u.range.max, 1);
ctk_config_set_tooltip(ctk_config,
ctk_gvo_sync->hsync_delay_spin_button,
help_text);
gtk_spin_button_set_value
(GTK_SPIN_BUTTON(ctk_gvo_sync->hsync_delay_spin_button), val);
g_signal_connect(G_OBJECT(ctk_gvo_sync->hsync_delay_spin_button),
"value-changed",
G_CALLBACK(hsync_delay_changed), ctk_gvo_sync);
hbox = gtk_hbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX(hbox),
ctk_gvo_sync->hsync_delay_spin_button,
FALSE, FALSE, 0);
label = gtk_label_new("(pixels)");
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
gtk_box_pack_start(GTK_BOX(hbox), label,
FALSE, FALSE, 0);
gtk_table_attach(GTK_TABLE(table), hbox,
1, 2, row, row+1,
GTK_FILL /*| GTK_EXPAND*/, GTK_FILL,
TABLE_PADDING, TABLE_PADDING);
row++;
}
/* NV_CTRL_GVO_SYNC_DELAY_LINES */
ret = NvCtrlGetValidAttributeValues(handle, NV_CTRL_GVO_SYNC_DELAY_LINES,
&valid);
if ((ret == NvCtrlSuccess) && (valid.type == ATTRIBUTE_TYPE_RANGE)) {
ret = NvCtrlGetAttribute(handle, NV_CTRL_GVO_SYNC_DELAY_LINES, &val);
if (ret != NvCtrlSuccess) val = 0;
if (ctk_gvo_sync->caps & NV_CTRL_GVO_CAPABILITIES_ADVANCE_SYNC_SKEW) {
label = gtk_label_new("VSync Advance:");
help_text = __vsync_advance_help;
} else {
label = gtk_label_new("VSync Delay:");
help_text = __vsync_delay_help;
}
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, row, row+1,
GTK_FILL, GTK_FILL, TABLE_PADDING, TABLE_PADDING);
ctk_gvo_sync->vsync_delay_spin_button =
gtk_spin_button_new_with_range(valid.u.range.min,
valid.u.range.max, 1);
ctk_config_set_tooltip(ctk_config,
ctk_gvo_sync->vsync_delay_spin_button,
help_text);
gtk_spin_button_set_value
(GTK_SPIN_BUTTON(ctk_gvo_sync->vsync_delay_spin_button), val);
g_signal_connect(G_OBJECT(ctk_gvo_sync->vsync_delay_spin_button),
"value-changed",
G_CALLBACK(vsync_delay_changed), ctk_gvo_sync);
hbox = gtk_hbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX(hbox),
ctk_gvo_sync->vsync_delay_spin_button,
FALSE, FALSE, 0);
label = gtk_label_new("(lines)");
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
gtk_box_pack_start(GTK_BOX(hbox), label,
FALSE, FALSE, 0);
gtk_table_attach(GTK_TABLE(table), hbox,
1, 2, row, row+1,
GTK_FILL /*| GTK_EXPAND*/, GTK_FILL,
TABLE_PADDING, TABLE_PADDING);
row++;
}
/* create the watch cursor (for use when the "Detect" button is toggled" */
ctk_gvo_sync->wait_cursor = gdk_cursor_new(GDK_WATCH);
/* Set UI sensitivity */
update_gvo_sync_sensitivity(ctk_gvo_sync);
/* Start listening for events */
register_for_gvo_sync_events(ctk_gvo_sync);
/* show the page */
gtk_widget_show_all(GTK_WIDGET(object));
return GTK_WIDGET(object);
} /* ctk_gvo_sync_new() */
static Bool update_dithering_info(gpointer user_data)
{
CtkDitheringControls *ctk_dithering_controls =
CTK_DITHERING_CONTROLS(user_data);
ReturnStatus ret;
gint val;
ret = NvCtrlGetAttribute(ctk_dithering_controls->handle,
NV_CTRL_DITHERING, &val);
if (ret != NvCtrlSuccess) {
/* Dithering is not currently available */
return FALSE;
}
if (val == NV_CTRL_DITHERING_ENABLED ||
val == NV_CTRL_DITHERING_AUTO) {
gtk_widget_set_sensitive(ctk_dithering_controls->dithering_mode_box,
TRUE);
gtk_widget_set_sensitive(ctk_dithering_controls->dithering_depth_box,
TRUE);
} else if (val == NV_CTRL_DITHERING_DISABLED) {
gtk_widget_set_sensitive(ctk_dithering_controls->dithering_mode_box,
FALSE);
gtk_widget_set_sensitive(ctk_dithering_controls->dithering_depth_box,
FALSE);
}
/* current dithering */
ret = NvCtrlGetAttribute(ctk_dithering_controls->handle,
NV_CTRL_CURRENT_DITHERING, &val);
if (ret != NvCtrlSuccess) {
val = NV_CTRL_CURRENT_DITHERING_DISABLED;
}
if (val == NV_CTRL_CURRENT_DITHERING_ENABLED) {
gtk_label_set_text(GTK_LABEL(ctk_dithering_controls->dithering_config_txt),
"Enabled");
} else {
gtk_label_set_text(GTK_LABEL(ctk_dithering_controls->dithering_config_txt),
"Disabled");
}
/* dithering mode */
ret = NvCtrlGetAttribute(ctk_dithering_controls->handle,
NV_CTRL_DITHERING_MODE, &val);
if (ret != NvCtrlSuccess) {
val = NV_CTRL_DITHERING_MODE_AUTO;
}
val = map_nvctrl_value_to_table(ctk_dithering_controls, val);
g_signal_handlers_block_by_func
(G_OBJECT(ctk_dithering_controls->dithering_mode_menu),
G_CALLBACK(dithering_mode_menu_changed),
(gpointer) ctk_dithering_controls);
gtk_option_menu_set_history
(GTK_OPTION_MENU(ctk_dithering_controls->dithering_mode_menu), val);
g_signal_handlers_unblock_by_func
(G_OBJECT(ctk_dithering_controls->dithering_mode_menu),
G_CALLBACK(dithering_mode_menu_changed),
(gpointer) ctk_dithering_controls);
/* current dithering mode */
ret = NvCtrlGetAttribute(ctk_dithering_controls->handle,
NV_CTRL_CURRENT_DITHERING_MODE, &val);
if (ret != NvCtrlSuccess) {
val = NV_CTRL_CURRENT_DITHERING_MODE_NONE;
}
switch (val) {
case NV_CTRL_CURRENT_DITHERING_MODE_DYNAMIC_2X2:
gtk_label_set_text(GTK_LABEL(ctk_dithering_controls->dithering_mode_txt),
"Dynamic 2x2");
break;
case NV_CTRL_CURRENT_DITHERING_MODE_STATIC_2X2:
gtk_label_set_text(GTK_LABEL(ctk_dithering_controls->dithering_mode_txt),
"Static 2x2");
break;
case NV_CTRL_CURRENT_DITHERING_MODE_TEMPORAL:
gtk_label_set_text(GTK_LABEL(ctk_dithering_controls->dithering_mode_txt),
"Temporal");
break;
default:
case NV_CTRL_CURRENT_DITHERING_MODE_NONE:
gtk_label_set_text(GTK_LABEL(ctk_dithering_controls->dithering_mode_txt),
"None");
break;
}
/* dithering depth */
ret = NvCtrlGetAttribute(ctk_dithering_controls->handle,
NV_CTRL_DITHERING_DEPTH, &val);
if (ret != NvCtrlSuccess) {
val = NV_CTRL_DITHERING_DEPTH_AUTO;
}
g_signal_handlers_block_by_func
(G_OBJECT(ctk_dithering_controls->dithering_depth_menu),
G_CALLBACK(dithering_depth_menu_changed),
(gpointer) ctk_dithering_controls);
gtk_option_menu_set_history
(GTK_OPTION_MENU(ctk_dithering_controls->dithering_depth_menu), val);
g_signal_handlers_unblock_by_func
(G_OBJECT(ctk_dithering_controls->dithering_depth_menu),
G_CALLBACK(dithering_depth_menu_changed),
(gpointer) ctk_dithering_controls);
/* current dithering depth */
ret = NvCtrlGetAttribute(ctk_dithering_controls->handle,
NV_CTRL_CURRENT_DITHERING_DEPTH, &val);
if (ret != NvCtrlSuccess) {
val = NV_CTRL_CURRENT_DITHERING_DEPTH_NONE;
}
switch (val) {
case NV_CTRL_CURRENT_DITHERING_DEPTH_6_BITS:
gtk_label_set_text(GTK_LABEL(ctk_dithering_controls->dithering_depth_txt),
"6 bpc");
break;
case NV_CTRL_CURRENT_DITHERING_DEPTH_8_BITS:
gtk_label_set_text(GTK_LABEL(ctk_dithering_controls->dithering_depth_txt),
"8 bpc");
break;
default:
case NV_CTRL_CURRENT_DITHERING_DEPTH_NONE:
gtk_label_set_text(GTK_LABEL(ctk_dithering_controls->dithering_depth_txt),
"None");
break;
}
return TRUE;
} /* update_dithering_info() */
