static int
gp_abilities_list_detect_usb (CameraAbilitiesList *list,
int *ability, GPPort *port)
{
int i, count, res = GP_ERROR_IO_USB_FIND;
CHECK_RESULT (count = gp_abilities_list_count (list));
/* Detect USB cameras */
gp_log (GP_LOG_VERBOSE, __FILE__,
"Auto-detecting USB cameras...");
*ability = -1;
for (i = 0; i < count; i++) {
int v, p, c, s;
if (!(list->abilities[i].port & port->type))
continue;
v = list->abilities[i].usb_vendor;
p = list->abilities[i].usb_product;
if (v) {
res = gp_port_usb_find_device(port, v, p);
if (res == GP_OK) {
gp_log(GP_LOG_DEBUG, __FILE__,
"Found '%s' (0x%x,0x%x)",
list->abilities[i].model,
v, p);
*ability = i;
} else if (res < 0 && res != GP_ERROR_IO_USB_FIND) {
/* another error occurred.
* perhaps we should better
* report this to the calling
* method?
*/
gp_log(GP_LOG_DEBUG, __FILE__,
"gp_port_usb_find_device(vendor=0x%x, "
"product=0x%x) returned %i, clearing "
"error message on port", v, p, res);
}
if (res != GP_ERROR_IO_USB_FIND)
return res;
}
c = list->abilities[i].usb_class;
s = list->abilities[i].usb_subclass;
p = list->abilities[i].usb_protocol;
if (c) {
res = gp_port_usb_find_device_by_class(port, c, s, p);
if (res == GP_OK) {
gp_log(GP_LOG_DEBUG, __FILE__,
"Found '%s' (0x%x,0x%x,0x%x)",
list->abilities[i].model,
c, s, p);
*ability = i;
} else if (res < 0 && res != GP_ERROR_IO_USB_FIND) {
/* another error occurred.
* perhaps we should better
* report this to the calling
* method?
*/
gp_log(GP_LOG_DEBUG, __FILE__,
"gp_port_usb_find_device_by_class("
"class=0x%x, subclass=0x%x, "
"protocol=0x%x) returned %i, "
"clearing error message on port",
c, s, p, res);
}
if (res != GP_ERROR_IO_USB_FIND)
return res;
}
}
return res;
}
/**
* Initiate a connection to the \c camera.
*
* @param camera a #Camera
* @param context a #GPContext
* @return a gphoto2 error code
*
* Before calling this function, the
* \c camera should be set up using #gp_camera_set_port_path or
* #gp_camera_set_port_name and #gp_camera_set_abilities. If that has been
* omitted, gphoto2 tries to autodetect any cameras and chooses the first one
* if any cameras are found. It is generally a good idea to call
* #gp_camera_exit after transactions have been completed in order to give
* other applications the chance to access the camera, too.
*
*/
int
gp_camera_init (Camera *camera, GPContext *context)
{
CameraAbilities a;
const char *model, *port;
CameraLibraryInitFunc init_func;
int result;
gp_log (GP_LOG_DEBUG, "gphoto2-camera", "Initializing camera...");
CHECK_NULL (camera);
/*
* Reset the exit_requested flag. If this flag is set,
* gp_camera_exit will be called as soon as the camera is no
* longer in use (used flag).
*/
camera->pc->exit_requested = 0;
/*
* If the model hasn't been indicated, try to
* figure it out (USB only). Beware of "Directory Browse".
*/
if (strcasecmp (camera->pc->a.model, "Directory Browse") &&
!strcmp ("", camera->pc->a.model)) {
CameraAbilitiesList *al;
GPPortInfo pinfo;
GPPortInfoList *il;
int m, p;
GPPortInfo info;
CameraList *list;
result = gp_list_new (&list);
if (result < GP_OK)
return result;
result = gp_port_get_info (camera->port, &pinfo);
if (result < GP_OK)
return result;
gp_log (GP_LOG_DEBUG, "gphoto2-camera", "pinfo.type %d", pinfo.type);
gp_log (GP_LOG_DEBUG, "gphoto2-camera", "pinfo.path %s", pinfo.path);
gp_log (GP_LOG_DEBUG, "gphoto2-camera", "pinfo.name %s", pinfo.name);
gp_log (GP_LOG_DEBUG, "gphoto2-camera", "Neither "
"port nor model set. Trying auto-detection...");
/* Call auto-detect and choose the first camera */
gp_abilities_list_new (&al);
gp_abilities_list_load (al, context);
gp_port_info_list_new (&il);
gp_port_info_list_load (il);
gp_abilities_list_detect (al, il, list, context);
if (!gp_list_count (list)) {
gp_abilities_list_free (al);
gp_port_info_list_free (il);
gp_context_error (context, _("Could not detect any camera"));
gp_list_free (list);
return (GP_ERROR_MODEL_NOT_FOUND);
}
p = 0;
/* if the port was set before, then use that entry. but not if it is "usb:" */
if ( (pinfo.type == GP_PORT_USB) &&
strlen(pinfo.path) &&
strcmp(pinfo.path,"usb:")
) {
for (p = gp_list_count (list);p--;) {
const char *xp;
gp_list_get_value (list, p, &xp);
if (!strcmp (xp, pinfo.path))
break;
}
if (p<0) {
gp_context_error (context, _("Could not detect any camera at port %s"), pinfo.path);
return (GP_ERROR_FILE_NOT_FOUND);
}
}
gp_list_get_name (list, p, &model);
m = gp_abilities_list_lookup_model (al, model);
gp_abilities_list_get_abilities (al, m, &a);
gp_abilities_list_free (al);
CRSL (camera, gp_camera_set_abilities (camera, a), context, list);
CRSL (camera, gp_list_get_value (list, p, &port), context, list);
p = gp_port_info_list_lookup_path (il, port);
gp_port_info_list_get_info (il, p, &info);
gp_port_info_list_free (il);
CRSL (camera, gp_camera_set_port_info (camera, info), context, list);
gp_list_free (list);
}
if (strcasecmp (camera->pc->a.model, "Directory Browse")) {
switch (camera->port->type) {
case GP_PORT_NONE:
gp_context_error (context, _("You have to set the "
"port prior to initialization of the camera."));
return (GP_ERROR_UNKNOWN_PORT);
case GP_PORT_USB:
if (gp_port_usb_find_device (camera->port,
camera->pc->a.usb_vendor,
camera->pc->a.usb_product) != GP_OK) {
CRS (camera, gp_port_usb_find_device_by_class
(camera->port,
camera->pc->a.usb_class,
camera->pc->a.usb_subclass,
camera->pc->a.usb_protocol), context);
}
break;
default:
break;
}
}
/* Load the library. */
gp_log (GP_LOG_DEBUG, "gphoto2-camera", "Loading '%s'...",
camera->pc->a.library);
lt_dlinit ();
camera->pc->lh = lt_dlopenext (camera->pc->a.library);
if (!camera->pc->lh) {
gp_context_error (context, _("Could not load required "
"camera driver '%s' (%s)."), camera->pc->a.library,
lt_dlerror ());
lt_dlexit ();
return (GP_ERROR_LIBRARY);
}
/* Initialize the camera */
init_func = lt_dlsym (camera->pc->lh, "camera_init");
if (!init_func) {
lt_dlclose (camera->pc->lh);
lt_dlexit ();
camera->pc->lh = NULL;
gp_context_error (context, _("Camera driver '%s' is "
"missing the 'camera_init' function."),
camera->pc->a.library);
return (GP_ERROR_LIBRARY);
}
if (strcasecmp (camera->pc->a.model, "Directory Browse")) {
result = gp_port_open (camera->port);
if (result < 0) {
lt_dlclose (camera->pc->lh);
lt_dlexit ();
camera->pc->lh = NULL;
return (result);
}
}
result = init_func (camera, context);
if (result < 0) {
gp_port_close (camera->port);
lt_dlclose (camera->pc->lh);
lt_dlexit ();
camera->pc->lh = NULL;
memset (camera->functions, 0, sizeof (CameraFunctions));
return (result);
}
/* We don't care if that goes wrong */
#ifdef HAVE_MULTI
gp_port_close (camera->port);
#endif
return (GP_OK);
}
