int oyAddDisplayEffects ( oyOptions_s ** module_options ) { int error = 0; oyOptions_s * f_options = *module_options; int f_options_n, i; /* erase old display profile */ f_options_n = oyOptions_Count( f_options ); for(i = 0; i < f_options_n; ++i) { oyOption_s * o = oyOptions_Get(f_options, i); if(o && oyFilterRegistrationMatch( oyOption_GetRegistration(o), OY_STD "/icc_color/display.icc_profile.abstract.effect.automatic", 0 )) { if(oy_debug) oyMessageFunc_p( oyMSG_DBG, (oyStruct_s*)f_options, OY_DBG_FORMAT_"release: %s", OY_DBG_ARGS_, oyOption_GetRegistration(o)); oyOption_Release( &o ); oyOptions_ReleaseAt( f_options, i ); break; } oyOption_Release( &o ); } error = oyAddLinearDisplayEffect( module_options ); if( error > 0 || oy_debug ) oyMessageFunc_p( error > 0 ? oyMSG_WARN : oyMSG_DBG, (oyStruct_s*)f_options, OY_DBG_FORMAT_"display_white_point error: %d", OY_DBG_ARGS_, error ); return error; }
int oyAddMonitorEffects ( oyProfile_s * monitor_profile, oyOptions_s ** module_options ) { int error = 0; oyOptions_s * f_options = *module_options; int f_options_n, i, display_white_point = 0; oyOption_s * o = oyOptions_Find( f_options, "display_white_point", oyNAME_PATTERN ); if(o) { const char * value = oyOption_GetValueString(o,0); if(value) { int c = atoi( value ); if(c >= 0) display_white_point = c; } oyOption_Release( &o ); } if( oy_debug ) oyMessageFunc_p( oyMSG_DBG, (oyStruct_s*)f_options, OY_DBG_FORMAT_"display_white_point: %d", OY_DBG_ARGS_, display_white_point); /* erase old display profile */ f_options_n = oyOptions_Count( f_options ); for(i = 0; i < f_options_n; ++i) { oyOption_s * o = oyOptions_Get(f_options, i); if(o && oyFilterRegistrationMatch( oyOption_GetRegistration(o), OY_STD "/icc_color/display.icc_profile.abstract.white_point.automatic", 0 )) { if(oy_debug) oyMessageFunc_p( oyMSG_DBG, (oyStruct_s*)f_options, OY_DBG_FORMAT_"release: %s", OY_DBG_ARGS_, oyOption_GetRegistration(o)); oyOption_Release( &o ); oyOptions_ReleaseAt( f_options, i ); break; } oyOption_Release( &o ); } if(display_white_point) /* not "none" */ { error = oyProfileAddWhitePointEffect( monitor_profile, module_options ); if( error || oy_debug ) oyMessageFunc_p( oyMSG_WARN, (oyStruct_s*)f_options, OY_DBG_FORMAT_"display_white_point: %d %s", OY_DBG_ARGS_, display_white_point, oyProfile_GetText( monitor_profile, oyNAME_DESCRIPTION )); } return error; }
/** Function Configs_Modify * @brief oyCMMapi8_s SANE scanner manipulation * * @version Oyranos: 0.1.10 * @since 2009/01/19 (Oyranos: 0.1.10) * @date 2009/08/21 * * \todo { Test } */ int Configs_Modify(oyConfigs_s * devices, oyOptions_s * options) { oyOption_s *version_opt = NULL; oyOption_s *version_opt_dev = NULL; oyConfig_s *device = NULL; int num_devices, g_error = 0; int call_sane_exit = 0; const char *command_list = NULL, *command_properties = NULL; oyAlloc_f allocateFunc = malloc; printf(PRFX "Entering %s(). Options:\n%s", __func__, oyOptions_GetText(options, oyNAME_NICK)); /* "error handling" section */ if (!devices || !oyConfigs_Count(devices)) { SANE_msg(oyMSG_WARN, (oyStruct_s *) options, _DBG_FORMAT_ "\n " "No devices given! Options:\n%s", _DBG_ARGS_, oyOptions_GetText(options, oyNAME_NICK) ); return 1; } /* "help" call section */ if (oyOptions_FindString(options, "command", "help") || !options || !oyOptions_Count(options)) { /** oyMSG_WARN should make shure our message is visible. */ ConfigsFromPatternUsage((oyStruct_s *) options); return 0; } num_devices = oyConfigs_Count(devices); command_list = oyOptions_FindString(options, "command", "list"); command_properties = oyOptions_FindString(options, "command", "properties"); /* Now we get some options [IN], and we already have some devices with * possibly already assigned options. Those provided through the input * oyOptions_s should take presedence over ::data & ::backend_core ones. * OTOH, all device_* options have a 1-1 relationship meaning if * one changes, probably all other should. So the simplest [naive] approach * would be to ignore all device_* options [IN] that are already in device. * Except from driver_version which has a special meaning. */ /* Handle "driver_version" option [IN] */ /* Check the first device to see if a positive driver_version is provided. */ /* If not, consult the input options */ device = oyConfigs_Get(devices, 0); version_opt_dev = oyConfig_Find(device, "driver_version"); if (version_opt_dev && oyOption_GetValueInt(version_opt_dev, 0) > 0) call_sane_exit = 0; else check_driver_version(options, &version_opt, &call_sane_exit); oyConfig_Release(&device); oyOption_Release(&version_opt_dev); if (command_list) { /* "list" call section */ int i; for (i = 0; i < num_devices; ++i) { const SANE_Device *device_context = NULL; SANE_Status status = SANE_STATUS_INVAL; oyOption_s *name_opt_dev = NULL, *handle_opt_dev = NULL, *context_opt_dev = NULL; const char *sane_name = NULL, *sane_model = NULL; int error = 0; device = oyConfigs_Get(devices, i); if(oyOptions_Count(*oyConfig_GetOptions(device,"backend_core"))) printf(PRFX "Backend core:\n%s", oyOptions_GetText(*oyConfig_GetOptions(device,"backend_core"), oyNAME_NICK)); if(oyOptions_Count(*oyConfig_GetOptions(device,"data"))) printf(PRFX "Data:\n%s", oyOptions_GetText(*oyConfig_GetOptions(device,"data"), oyNAME_NICK)); /*Ignore device without a device_name*/ if (!oyOptions_FindString(*oyConfig_GetOptions(device,"backend_core"), "device_name", NULL)) { SANE_msg(oyMSG_WARN, (oyStruct_s *) options, _DBG_FORMAT_ ": %s\n", _DBG_ARGS_, "The \"device_name\" is missing from config object!"); oyConfig_Release(&device); g_error++; continue; } /*Handle "driver_version" option [OUT] */ version_opt_dev = oyConfig_Find(device, "driver_version"); if (!version_opt_dev && version_opt) oyOptions_MoveIn(*oyConfig_GetOptions(device,"backend_core"), &version_opt, -1); oyOption_Release(&version_opt_dev); /*Handle "device_context" option */ /*This is always provided by Configs_FromPattern() * [or should be alternatively by the user]. * Configs_Modify() will not scan for SANE devices * because it takes too long*/ context_opt_dev = oyConfig_Find(device, "device_context"); if (!context_opt_dev) { SANE_msg(oyMSG_WARN, (oyStruct_s *) options, _DBG_FORMAT_ ": %s\n", _DBG_ARGS_, "The \"device_context\" option is missing!"); error = g_error = 1; } if (!error) { device_context = (SANE_Device*)oyOption_GetData(context_opt_dev, NULL, allocateFunc); sane_name = device_context->name; sane_model = device_context->model; } /*Handle "oyNAME_NAME" option */ name_opt_dev = oyConfig_Find(device, "oyNAME_NAME"); if (!error && !name_opt_dev && oyOptions_Find(options, "oyNAME_NAME", oyNAME_PATTERN)) oyOptions_SetFromString(oyConfig_GetOptions(device,"backend_core"), CMM_BASE_REG OY_SLASH "oyNAME_NAME", sane_model, OY_CREATE_NEW); /*Handle "device_handle" option */ handle_opt_dev = oyConfig_Find(device, "device_handle"); if (!error && !handle_opt_dev) { oyPointer_s *handle_ptr = NULL; SANE_Handle h; status = sane_open(sane_name, &h); if (status == SANE_STATUS_GOOD) { handle_ptr = oyPointer_New(0); oyPointer_Set(handle_ptr, "SANE", "handle", (oyPointer)h, "sane_release_handle", sane_release_handle); oyOptions_MoveInStruct(oyConfig_GetOptions(device,"data"), CMM_BASE_REG OY_SLASH "device_handle", (oyStruct_s **) &handle_ptr, OY_CREATE_NEW); } else printf(PRFX "Unable to open sane device \"%s\": %s\n", sane_name, sane_strstatus(status)); } /*Create static rank_map, if not already there*/ if (!oyConfig_GetRankMap( device)) oyConfig_SetRankMap( device, _api8.rank_map ); /*Cleanup*/ oyConfig_Release(&device); oyOption_Release(&context_opt_dev); oyOption_Release(&name_opt_dev); oyOption_Release(&handle_opt_dev); } } else if (command_properties) { /* "properties" call section */ int i; /*Return a full list of scanner H/W & * SANE driver S/W color options * with the according rank map */ for (i = 0; i < num_devices; ++i) { SANE_Device *device_context = NULL; SANE_Status status = SANE_STATUS_INVAL; SANE_Handle device_handle; oyOption_s *name_opt_dev = NULL, *handle_opt_dev = NULL, *context_opt_dev = NULL; oyConfig_s *device_new = NULL; char *device_name = NULL; /* All previous device properties are considered obsolete * and a new device is created. Basic options are moved from * the old to new device */ device = oyConfigs_Get(devices, i); device_new = oyConfig_FromRegistration(CMM_BASE_REG, 0); printf(PRFX "Backend core:\n%s", oyOptions_GetText(*oyConfig_GetOptions(device,"backend_core"), oyNAME_NICK)); printf(PRFX "Data:\n%s", oyOptions_GetText(*oyConfig_GetOptions(device,"data"), oyNAME_NICK)); /*Ignore device without a device_name*/ if (!oyOptions_FindString(*oyConfig_GetOptions(device,"backend_core"), "device_name", NULL)) { SANE_msg(oyMSG_WARN, (oyStruct_s *) options, _DBG_FORMAT_ ": %s\n", _DBG_ARGS_, "The \"device_name\" is NULL, or missing from config object!"); oyConfig_Release(&device); oyConfig_Release(&device_new); g_error++; continue; } /*Handle "driver_version" option [OUT] */ if (version_opt) { oyOption_s *tmp = oyOption_Copy(version_opt, 0); oyOptions_MoveIn(*oyConfig_GetOptions(device_new,"backend_core"), &tmp, -1); } /* 1. Get the "device_name" from old device */ name_opt_dev = oyConfig_Find(device, "device_name"); device_name = oyOption_GetValueText(name_opt_dev, allocateFunc); oyOptions_MoveIn(*oyConfig_GetOptions(device_new,"backend_core"), &name_opt_dev, -1); /* 2. Get the "device_context" from old device */ /* It should be there, see "list" call above */ context_opt_dev = oyConfig_Find(device, "device_context"); if (context_opt_dev) { device_context = (SANE_Device*)oyOption_GetData(context_opt_dev, NULL, allocateFunc); if (device_context) { oyOptions_MoveIn(*oyConfig_GetOptions(device_new,"data"), &context_opt_dev, -1); } else { SANE_msg(oyMSG_WARN, (oyStruct_s *) options, _DBG_FORMAT_ ": %s\n", _DBG_ARGS_, "The \"device_context\" is NULL!"); oyOption_Release(&context_opt_dev); g_error++; } } else { SANE_msg(oyMSG_WARN, (oyStruct_s *) options, _DBG_FORMAT_ ": %s\n", _DBG_ARGS_, "The \"device_context\" option is missing!"); g_error++; } /* 3. Get the scanner H/W properties from old device */ /* FIXME: we only recompute them, just in case they are not in old device */ if (device_context) { DeviceInfoFromContext_(device_context, oyConfig_GetOptions(device_new,"backend_core")); } /* 4. Get the "device_handle" from old device */ /* If not there, get one from SANE */ handle_opt_dev = oyConfig_Find(device, "device_handle"); if (handle_opt_dev) { oyPointer_s * oy_struct = (oyPointer_s*)oyOption_GetStruct( handle_opt_dev, oyOBJECT_POINTER_S ); device_handle = (SANE_Handle)oyPointer_GetPointer(oy_struct); oyPointer_Release( &oy_struct ); oyOptions_MoveIn(*oyConfig_GetOptions(device_new,"data"), &handle_opt_dev, -1); } else { printf(PRFX "Opening sane device \"%s\"..", device_name); fflush(NULL); status = sane_open( device_name, &device_handle ); if (status != SANE_STATUS_GOOD) printf("[FAIL: %s]\n", sane_strstatus(status)); else printf("[OK]\n"); } if (handle_opt_dev || status == SANE_STATUS_GOOD) { /* Use the device_handle to get the device color options */ ColorInfoFromHandle(device_handle, oyConfig_GetOptions(device_new,"backend_core")); /*5. Set the rank map*/ oyConfig_SetRankMap( device_new, _api8.rank_map ); } /*Cleanup*/ /* Remove old, add new device */ oyConfig_Release(&device); oyConfigs_ReleaseAt(devices, i); oyConfigs_MoveIn(devices, &device_new, -1); /*If we had to open a SANE device, we'll have to close it*/ if (status == SANE_STATUS_GOOD) { printf(PRFX "sane_close(%s)\n", device_name); sane_close(device_handle); } free(device_context); free(device_name); } } else { /*unsupported, wrong or no command */ SANE_msg(oyMSG_WARN, (oyStruct_s *) options, _DBG_FORMAT_ "\n " "No supported commands in options:\n%s", _DBG_ARGS_, oyOptions_GetText(options, oyNAME_NICK) ); ConfigsFromPatternUsage((oyStruct_s *) options); g_error = 1; } /*Cleanup*/ if (call_sane_exit) { printf(PRFX "sane_exit()\n"); sane_exit(); } oyOption_Release(&version_opt); printf(PRFX "Leaving %s\n", __func__); return g_error; }
/** Function Configs_FromPattern * @brief CMM_NICK oyCMMapi8_s scanner devices * * @param[in] registration a string to compare ?????? * @param[in] options read what to do from the options object * @param[out] s Return a configuration for each device found * * @version Oyranos: 0.1.10 * @since 2009/01/19 (Oyranos: 0.1.10) * @date 2009/02/09 */ int Configs_FromPattern(const char *registration, oyOptions_s * options, oyConfigs_s ** s) { oyConfig_s *device = NULL; oyConfigs_s *devices = NULL; oyOption_s *context_opt = NULL, *handle_opt = NULL, *version_opt = NULL, *name_opt = NULL; int i, num_devices, g_error = 0, status, call_sane_exit = 0; const char *device_name = 0, *command_list = 0, *command_properties = 0; const SANE_Device **device_list = NULL; int rank; oyAlloc_f allocateFunc = malloc; printf(PRFX "Entering %s(). Options:\n%s", __func__, oyOptions_GetText(options, oyNAME_NICK)); rank = oyFilterRegistrationMatch(_api8.registration, registration, oyOBJECT_CMM_API8_S); command_list = oyOptions_FindString(options, "command", "list"); command_properties = oyOptions_FindString(options, "command", "properties"); device_name = oyOptions_FindString(options, "device_name", 0); /* "error handling" section */ if (rank == 0) { SANE_msg(oyMSG_WARN, (oyStruct_s *) options, _DBG_FORMAT_ "\n " "Registration match Failed. Options:\n%s", _DBG_ARGS_, oyOptions_GetText(options, oyNAME_NICK)); return 1; } if (s == NULL) { SANE_msg(oyMSG_WARN, (oyStruct_s *) options, _DBG_FORMAT_ "\n " "oyConfigs_s is NULL! Options:\n%s", _DBG_ARGS_, oyOptions_GetText(options, oyNAME_NICK)); return 1; } if (*s != NULL) { SANE_msg(oyMSG_WARN, (oyStruct_s *) options, _DBG_FORMAT_ "\n " "Devices struct already present! Options:\n%s", _DBG_ARGS_, oyOptions_GetText(options, oyNAME_NICK)); return 1; } if (!device_name && command_properties) { SANE_msg(oyMSG_WARN, (oyStruct_s *) options, _DBG_FORMAT_ "\n " "Device_name is mandatory for properties command:\n%s", _DBG_ARGS_, oyOptions_GetText(options, oyNAME_NICK)); return 1; } /* "help" call section */ if (oyOptions_FindString(options, "command", "help") || !options || !oyOptions_Count(options)) { /** oyMSG_WARN should make shure our message is visible. */ ConfigsFromPatternUsage((oyStruct_s *) options); return 0; } context_opt = oyOptions_Find(options, "device_context", oyNAME_PATTERN); handle_opt = oyOptions_Find(options, "device_handle", oyNAME_PATTERN); name_opt = oyOptions_Find(options, "oyNAME_NAME", oyNAME_PATTERN); /*Handle "driver_version" option [IN] */ check_driver_version(options, &version_opt, &call_sane_exit); devices = oyConfigs_New(0); if (command_list) { /* "list" call section */ if (device_name && /*If a user provides a device_name option,*/ !context_opt && /*and does not need the device_context data,*/ !name_opt /*or the oyNAME_NAME description*/ ) num_devices = 1; /*then we can get away without calling GetDevices()*/ else if (GetDevices(&device_list, &num_devices) != 0) { num_devices = 0; /*So that for loop will not run*/ ++g_error; } for (i = 0; i < num_devices; ++i) { int error = 0; const char *sane_name = NULL, *sane_model = NULL; if (device_list) { sane_name = device_list[i]->name; sane_model = device_list[i]->model; } else { sane_name = device_name; } /*Handle "device_name" option [IN] */ if (device_name && /*device_name is provided*/ sane_name && /*and sane_name has been retrieved*/ strcmp(device_name, sane_name) != 0) /*and they don't match,*/ continue; /*then try the next*/ device = oyConfig_FromRegistration(CMM_BASE_REG, 0); /*Handle "driver_version" option [OUT] */ if (version_opt) { oyOption_s * tmp = oyOption_Copy(version_opt, 0); oyOptions_MoveIn(*oyConfig_GetOptions(device,"backend_core"), &tmp, -1); } /*Handle "device_name" option [OUT] */ oyOptions_SetFromString(oyConfig_GetOptions(device,"backend_core"), CMM_BASE_REG OY_SLASH "device_name", sane_name, OY_CREATE_NEW); /*Handle "oyNAME_NAME" option */ if (name_opt) oyOptions_SetFromString(oyConfig_GetOptions(device,"backend_core"), CMM_BASE_REG OY_SLASH "oyNAME_NAME", sane_model, OY_CREATE_NEW); /*Handle "device_context" option */ /* SANE Backend protocol states that device_context is *always* returned * This is a slight variation: Only when GetDevices() is called will it be returned, * unless we call sane_exit*/ if (device_list && !call_sane_exit) { oyBlob_s *context_blob = oyBlob_New(NULL); oyOption_s *context_opt = oyOption_FromRegistration( CMM_BASE_REG OY_SLASH "device_context", 0); oyBlob_SetFromData(context_blob, (oyPointer) device_list[i], sizeof(SANE_Device), "sane"); oyOption_MoveInStruct(context_opt, (oyStruct_s **) & context_blob); oyOptions_MoveIn(*oyConfig_GetOptions(device,"data"), &context_opt, -1); } /*Handle "device_handle" option */ if (handle_opt && !call_sane_exit) { oyPointer_s *handle_ptr = NULL; SANE_Handle h; status = sane_open(sane_name, &h); if (status == SANE_STATUS_GOOD) { handle_ptr = oyPointer_New(0); oyPointer_Set(handle_ptr, "SANE", "handle", (oyPointer)h, "sane_release_handle", sane_release_handle); oyOptions_MoveInStruct(oyConfig_GetOptions(device,"data"), CMM_BASE_REG OY_SLASH "device_handle", (oyStruct_s **) &handle_ptr, OY_CREATE_NEW); } else printf(PRFX "Unable to open sane device \"%s\": %s\n", sane_name, sane_strstatus(status)); } oyConfig_SetRankMap( device, _api8.rank_map ); error = oyConfigs_MoveIn(devices, &device, -1); /*Cleanup*/ if (error) { oyConfig_Release(&device); ++g_error; } } *s = devices; } else if (command_properties) { /* "properties" call section */ const SANE_Device *device_context = NULL; SANE_Device *aux_context = NULL; SANE_Handle device_handle = NULL; /*Return a full list of scanner H/W & * SANE driver S/W color options * with the according rank map */ device = oyConfig_FromRegistration(CMM_BASE_REG, 0); /*Handle "driver_version" option [OUT] */ if (version_opt) { oyOption_s *tmp = oyOption_Copy(version_opt, 0); oyOptions_MoveIn(*oyConfig_GetOptions(device,"backend_core"), &tmp, -1); } /*1a. Get the "device_context"*/ if (!context_opt) { /*we'll have to get it ourselves*/ if (GetDevices(&device_list, &num_devices) == 0) { device_context = *device_list; while (device_context) { if(device_name && device_context->name && strcmp(device_name,device_context->name) == 0) break; device_context++; } if (!device_context) { printf(PRFX "device_name does not match any installed device.\n"); g_error++; } } else { g_error++; } } else { aux_context = (SANE_Device*)oyOption_GetData(context_opt, NULL, allocateFunc); device_context = aux_context; } /*1b. Use the "device_context"*/ if (device_context) DeviceInfoFromContext_(device_context, oyConfig_GetOptions(device,"backend_core")); /*2a. Get the "device_handle"*/ if (!handle_opt) { status = sane_open( device_name, &device_handle ); if (status != SANE_STATUS_GOOD) { printf(PRFX "Unable to open sane device \"%s\": %s\n", device_name, sane_strstatus(status)); g_error++; } } else { oyPointer_s * oy_struct = (oyPointer_s*) oyOption_GetStruct( handle_opt, oyOBJECT_POINTER_S ); device_handle = (SANE_Handle)oyPointer_GetPointer(oy_struct); oyPointer_Release( &oy_struct ); } if (device_handle) { /*2b. Use the "device_handle"*/ ColorInfoFromHandle(device_handle, oyConfig_GetOptions(device,"backend_core")); /*3. Set the rank map*/ oyConfig_SetRankMap( device, _api8.rank_map ); } oyConfigs_MoveIn(devices, &device, -1); /*Cleanup*/ free(aux_context); *s = devices; } else { /*unsupported, wrong or no command */ SANE_msg(oyMSG_WARN, (oyStruct_s *) options, _DBG_FORMAT_ "\n " "No supported commands in options:\n%s", _DBG_ARGS_, oyOptions_GetText(options, oyNAME_NICK) ); ConfigsFromPatternUsage((oyStruct_s *) options); g_error = 1; } /*Global Cleanup*/ if (call_sane_exit) { printf(PRFX "sane_exit()\n"); sane_exit(); } oyOption_Release(&context_opt); oyOption_Release(&handle_opt); oyOption_Release(&version_opt); oyOption_Release(&name_opt ); printf(PRFX "Leaving %s\n", __func__); return g_error; }
int updateOutputConfiguration( Display * display ) { int error = 0, i, n, update = 0; oyOptions_s * options = 0; oyConfigs_s * devices = 0; oyConfig_s * device = 0, * old_device = 0; /* allow Oyranos to see modifications made to the compiz Xlib context */ XFlush( display ); /* obtain device informations, including geometry and ICC profiles from the according Oyranos module */ error = oyOptions_SetFromText( &options, "//" OY_TYPE_STD "/config/command", "list", OY_CREATE_NEW ); if(error) WARNc2_S("%s %d", _("found issues"),error); error = oyOptions_SetFromText( &options, "//" OY_TYPE_STD "/config/device_rectangle", "true", OY_CREATE_NEW ); if(error) WARNc2_S("%s %d", _("found issues"),error); error = oyOptions_SetFromText( &options, "//" OY_TYPE_STD "/config/edid", "refresh", OY_CREATE_NEW ); error = oyDevicesGet( OY_TYPE_STD, "monitor", options, &devices ); if(error) WARNc2_S("%s %d", _("found issues"),error); n = oyOptions_Count( options ); oyOptions_Release( &options ); n = oyConfigs_Count( devices ); /* find out if monitors have changed at all * care only about EDID's and enumeration, no dimension */ if(n != oyConfigs_Count( old_devices )) update = 1; else for(i = 0; i < n; ++i) { const char * edid, * old_edid; device = oyConfigs_Get( devices, i ); old_device = oyConfigs_Get( old_devices, i ); edid = oyOptions_FindString( *oyConfig_GetOptions(device,"backend_core"),"EDID",0 ); old_edid = oyOptions_FindString( *oyConfig_GetOptions(old_device,"backend_core"),"EDID",0 ); if(edid && old_edid && strcmp(edid,old_edid)==0) update = 0; else update = 1; oyConfig_Release( &device ); oyConfig_Release( &old_device ); if(update) break; } if(!update) goto clean_update; cleanDisplay( display, n ); for(i = 0; i < n; ++i) { device = oyConfigs_Get( devices, i ); error = getDeviceProfile( display, device, i ); if(error) WARNc2_S("%s %d", _("found issues"),error); oyConfig_Release( &device ); } clean_update: oyConfigs_Release( &old_devices ); old_devices = devices; return 0; }