G_MODULE_EXPORT void
gnome_scan_module_finalize (GnomeScanModule *module)
{
/* TODO: backend and scanners */
gsane_option_manager_destroy(gsane_option_manager);
sane_exit();
}
static PyObject *deInit (PyObject * self, PyObject * args)
{
if (!PyArg_ParseTuple (args, ""))
raiseError("Invalid arguments");
sane_exit ();
Py_INCREF (Py_None);
return Py_None;
}
static void
sane_idadone(void *data)
{
struct sane_state *h = data;
sane_cancel(h->sane);
sane_close(h->sane);
sane_exit();
free(h->buf);
free(h);
}
static void
build_menu(Widget widget, XtPointer clientdata, XtPointer call_data)
{
WidgetList children,wlist;
Cardinal nchildren;
const SANE_Device **list;
Widget push;
XmString str;
char action[256];
int rc,i;
/* del old */
XtVaGetValues(widget,
XtNchildren,&children,
XtNnumChildren,&nchildren,
NULL);
wlist = malloc(sizeof(Widget*)*nchildren);
memcpy(wlist,children,sizeof(Widget*)*nchildren);
for (i = 0; i < nchildren; i++)
XtDestroyWidget(wlist[i]);
free(wlist);
/* create new */
if (SANE_STATUS_GOOD != (rc = sane_init(NULL,NULL))) {
fprintf(stderr,"sane_init: %s\n",sane_strstatus(rc));
goto done;
}
sane_get_devices(&list,0);
if (NULL == list[0])
goto done;
for (i = 0; list[i] != NULL; i++) {
if (debug)
fprintf(stderr,"sane dev: %s | %s | %s | %s\n",
list[i]->name, list[i]->vendor,
list[i]->model, list[i]->type);
str = XmStringGenerate((char*)list[i]->model,
NULL, XmMULTIBYTE_TEXT, NULL);
push = XtVaCreateManagedWidget(list[i]->name,
xmPushButtonWidgetClass,widget,
XmNlabelString,str,
NULL);
XmStringFree(str);
sprintf(action,"Scan(%s)",list[i]->name);
XtAddCallback(push,XmNactivateCallback,action_cb,strdup(action));
}
done:
sane_exit();
}
void
sane_menu(Widget menu)
{
Widget submenu;
int rc;
if (SANE_STATUS_GOOD != (rc = sane_init(NULL,NULL))) {
fprintf(stderr,"sane_init: %s\n",sane_strstatus(rc));
goto done;
}
submenu = XmCreatePulldownMenu(menu,"scanM",NULL,0);
XtVaCreateManagedWidget("scan",xmCascadeButtonWidgetClass,menu,
XmNsubMenuId,submenu,NULL);
XtAddCallback(submenu, XmNmapCallback, build_menu, NULL);
done:
sane_exit();
}
int
main (int argc, char *argv[])
{
if (argc != 2 && argc != 3)
{
fprintf (stderr, "Usage: %s devicename [hostname]\n", argv[0]);
exit (0);
}
if (argc == 3)
{
char envbuf[1024];
sprintf (envbuf, "SANE_NET_HOST=%s", argv[2]);
putenv (envbuf);
}
fprintf (stderr, "This is a SANE test application.\n"
"Now connecting to device %s.\n", argv[1]);
testsane (argv[1]);
sane_exit ();
return 0;
}
void sane_worker( char *command, char *param ) {
char *response;
if( SANE_STATUS_GOOD != sane_init(NULL, NULL) ) {
o_log( ERROR, "Could not start sane");
}
// Get a list of scanners
if ( command && 0 == strcmp(command, "internalGetScannerList") ) {
response = internalGetScannerList( param );
}
// Get scanner details (attributes)
else if ( command && 0 == strcmp(command, "internalGetScannerDetails") ) {
char *deviceid = strtok(o_strdup(param), ","); // device
char *lang = strtok( NULL, ","); // lang
response = internalGetScannerDetails( deviceid, lang );
free( deviceid );
}
// Scan a page
else if ( command && 0 == strcmp(command, "internalDoScanningOperation") ) {
char *uuid = strtok(o_strdup(param), ","); // uuid
char *lang = strtok( NULL, ","); // lang
response = internalDoScanningOperation( uuid, lang );
free( uuid );
}
else {
o_log( ERROR, "Unknown Command");
response = o_strdup("ERROR");
}
sane_exit();
// POST RESPONSE ON STDOUT
printf("%s", response);
free(response);
}
/** 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;
}
static void*
sane_idainit(FILE *fp, char *filename, unsigned int page, struct ida_image_info *info,
int thumbnail)
{
const SANE_Option_Descriptor *opt;
SANE_Int flags, count;
struct sane_state *h;
int rc,i,value,dpi = 0;
h = malloc(sizeof(*h));
memset(h,0,sizeof(*h));
if (SANE_STATUS_GOOD != (rc = sane_init(NULL,NULL))) {
fprintf(stderr,"sane_init: %s\n",sane_strstatus(rc));
goto oops;
}
if (SANE_STATUS_GOOD != (rc = sane_open(filename,&h->sane))) {
fprintf(stderr,"sane_open: %s\n",sane_strstatus(rc));
goto oops;
}
/* set options */
opt = sane_get_option_descriptor(h->sane,0);
rc = sane_control_option(h->sane, 0, SANE_ACTION_GET_VALUE,
&count, &flags);
for (i = 1; i < count; i++) {
opt = sane_get_option_descriptor(h->sane,i);
if (opt->name && 0 == strcmp(opt->name,SANE_NAME_SCAN_TL_X)) {
value = opt->constraint.range->min;
sane_control_option(h->sane, i, SANE_ACTION_SET_VALUE,
&value, &flags);
} else if (opt->name && 0 == strcmp(opt->name,SANE_NAME_SCAN_TL_Y)) {
value = opt->constraint.range->min;
sane_control_option(h->sane, i, SANE_ACTION_SET_VALUE,
&value, &flags);
} else if (opt->name && 0 == strcmp(opt->name,SANE_NAME_SCAN_BR_X)) {
value = opt->constraint.range->max;
sane_control_option(h->sane, i, SANE_ACTION_SET_VALUE,
&value, &flags);
} else if (opt->name && 0 == strcmp(opt->name,SANE_NAME_SCAN_BR_Y)) {
value = opt->constraint.range->max;
sane_control_option(h->sane, i, SANE_ACTION_SET_VALUE,
&value, &flags);
} else if (opt->name && 0 == strcmp(opt->name,SANE_NAME_PREVIEW)) {
value = SANE_FALSE;
sane_control_option(h->sane, i, SANE_ACTION_SET_VALUE,
&value, &flags);
} else if (opt->cap & SANE_CAP_AUTOMATIC)
sane_control_option(h->sane, i, SANE_ACTION_SET_AUTO,
NULL, &flags);
if (opt->name && 0 == strcmp(opt->name,SANE_NAME_SCAN_RESOLUTION)) {
if (sane_res) {
dpi = sane_res;
sane_control_option(h->sane, i, SANE_ACTION_SET_VALUE,
&dpi, &flags);
}
sane_control_option(h->sane, i, SANE_ACTION_GET_VALUE,
&dpi, &flags);
}
if (debug)
dump_desc(h->sane,i,opt);
}
if (SANE_STATUS_GOOD != (rc = sane_start(h->sane))) {
fprintf(stderr,"sane_start: %s\n",sane_strstatus(rc));
goto oops;
}
h->started = 1;
if (SANE_STATUS_GOOD != (rc = sane_get_parameters(h->sane,&h->parm))) {
fprintf(stderr,"sane_get_parameters: %s\n",sane_strstatus(rc));
goto oops;
}
if (h->parm.format != SANE_FRAME_GRAY &&
h->parm.format != SANE_FRAME_RGB) {
fprintf(stderr,"sane: unsupported frame format (%d)\n",h->parm.format);
goto oops;
}
if (h->parm.depth != 8) {
fprintf(stderr,"sane: unsupported color depth (%d)\n",h->parm.depth);
goto oops;
}
if (-1 == h->parm.lines) {
fprintf(stderr,"sane: can't handle unknown image size\n");
goto oops;
}
info->width = h->parm.pixels_per_line;
info->height = h->parm.lines;
if (dpi)
info->dpi = dpi;
h->buf = malloc(h->parm.bytes_per_line * BUF_LINES);
if (debug)
fprintf(stderr,"sane: scanning %dx%d %s\n",info->width,info->height,
(h->parm.format == SANE_FRAME_GRAY) ? "gray" : "color");
return h;
oops:
if (h->buf)
free(h->buf);
if (h->started)
sane_cancel(h->sane);
if (h->sane)
sane_close(h->sane);
sane_exit();
free(h);
return NULL;
}
