int auto_detect_action (CameraList *list,GPContext *context) { int count, result; GPPortInfoList *portinfo_list; CameraAbilitiesList *al = NULL; if ((result = gp_port_info_list_new (&portinfo_list)) < GP_OK) return result; result = gp_port_info_list_load (portinfo_list); if (result < 0) { gp_port_info_list_free (portinfo_list); return result; } count = gp_port_info_list_count (portinfo_list); if (count < 0) { gp_port_info_list_free (portinfo_list); return count; } gp_abilities_list_new (&al); gp_abilities_list_load (al, context); gp_abilities_list_detect (al, portinfo_list, list, context); gp_abilities_list_free (al); count = gp_list_count (list); return count > 0 ? GP_OK : GP_ERROR; }
int cam_detect_camera (GPParams *gp_params) { int x, count; CameraList *list; const char *name = NULL, *value = NULL; int ret = 0; _get_portinfo_list (gp_params); if ( (ret = gp_list_new (&list)) < 0) goto err_no; gp_abilities_list_detect (gp_params_abilities_list(gp_params), gp_params->portinfo_list, list, gp_params->context); if ((ret = count = gp_list_count (list)) < 0) goto err_list; LOG_I(("%-30s %-16s\n"), ("Model"), ("Port")); LOG_I(("----------------------------------------------------------\n")); for (x = 0; x < count; x++) { (gp_list_get_name (list, x, &name), list); (gp_list_get_value (list, x, &value), list); LOG_I(("%-30s %-16s\n"), name, value); } gp_list_free (list); return count; err_list: gp_list_free (list); err_no: return ret; }
bool photo_camera_list::filterCameraList( GPContext* context, const std::string match_string ) { CameraList *working_list = NULL; const char *name, *value; int count = 0; if( gp_list_new( &working_list ) != GP_OK ) { photo_reporter::error( "gp_list_new()" ); gp_list_free( working_list ); return false; } // Autodetect the currently attached photo_cameras. if( gp_abilities_list_detect( abilities_list_, port_info_list_, working_list, context) != GP_OK ) { photo_reporter::error( "gp_abilities_list_detect()" ); gp_list_free( working_list ); return false; } count = gp_list_count( working_list ); if( count < GP_OK ) { photo_reporter::error( "gp_list_count()" ); gp_list_free( working_list ); return false; } // Clear camera_list_ for appending if( gp_list_reset( camera_list_ ) != GP_OK ) { photo_reporter::error( "gp_list_reset()" ); gp_list_free( working_list ); return false; } // Filter out the generic 'usb:' entry for( int i = 0; i < count; i++ ) { gp_list_get_name( working_list, i, &name ); gp_list_get_value( working_list, i, &value ); if( match_string.compare( value ) != 0 ) { gp_list_append( camera_list_, name, value ); } } gp_list_free( working_list ); return true; }
/** * Autodetect all detectable camera * * @param list a #CameraList that receives the autodetected cameras * @param context a #GPContext * @return a gphoto2 error code * * This camera will autodetected all cameras that can be autodetected. * This will for instance detect all USB cameras. * * CameraList *list; * gp_list_new (&list); * gp_camera_autodetect (list, context); * ... done! ... */ int gp_camera_autodetect (CameraList *list, GPContext *context) { CameraAbilitiesList *al = NULL; GPPortInfoList *il = NULL; int ret, i; CameraList *xlist = NULL; ret = gp_list_new (&xlist); if (ret < GP_OK) goto out; if (!il) { /* Load all the port drivers we have... */ ret = gp_port_info_list_new (&il); if (ret < GP_OK) goto out; ret = gp_port_info_list_load (il); if (ret < 0) goto out; ret = gp_port_info_list_count (il); if (ret < 0) goto out; } /* Load all the camera drivers we have... */ ret = gp_abilities_list_new (&al); if (ret < GP_OK) goto out; ret = gp_abilities_list_load (al, context); if (ret < GP_OK) goto out; /* ... and autodetect the currently attached cameras. */ ret = gp_abilities_list_detect (al, il, xlist, context); if (ret < GP_OK) goto out; /* Filter out the "usb:" entry */ ret = gp_list_count (xlist); if (ret < GP_OK) goto out; for (i=0;i<ret;i++) { const char *name, *value; gp_list_get_name (xlist, i, &name); gp_list_get_value (xlist, i, &value); if (!strcmp ("usb:",value)) continue; gp_list_append (list, name, value); } out: if (il) gp_port_info_list_free (il); if (al) gp_abilities_list_free (al); gp_list_free (xlist); if (ret < GP_OK) return ret; return gp_list_count(list); }
void Image_GPhoto::detectCameras() { lock_guard<recursive_mutex> lock(_gpMutex); if (_gpPorts != nullptr) gp_port_info_list_free(_gpPorts); gp_port_info_list_new(&_gpPorts); gp_port_info_list_load(_gpPorts); CameraList* availableCameras = nullptr; gp_list_new(&availableCameras); gp_abilities_list_detect(_gpCams, _gpPorts, availableCameras, _gpContext); Log::get() << Log::MESSAGE << "Image_GPhoto::" << __FUNCTION__ << " - " << (gp_list_count(availableCameras) > 0 ? gp_list_count(availableCameras) : 0) << " cameras detected" << Log::endl; // Create the list of tetherable cameras for (int i = 0; i < gp_list_count(availableCameras); ++i) { GPhotoCamera camera; const char* s; gp_list_get_name(availableCameras, i, &s); camera.model = string(s); gp_list_get_value(availableCameras, i, &s); camera.port = string(s); if (!initCamera(camera)) { releaseCamera(camera); Log::get() << Log::WARNING << "Image_GPhoto::" << __FUNCTION__ << " - Unable to initialize camera " << camera.model << " on port " << camera.port << Log::endl; } else if (!camera.canTether && !camera.canImport) { releaseCamera(camera); Log::get() << Log::WARNING << "Image_GPhoto::" << __FUNCTION__ << " - Camera " << camera.model << " on port " << camera.port << " does not support import or tethering" << Log::endl; } else { releaseCamera(camera); _cameras.push_back(camera); Log::get() << Log::MESSAGE << "Image_GPhoto::" << __FUNCTION__ << " - Camera " << camera.model << " on port " << camera.port << " initialized correctly" << Log::endl; } } }
static void on_detect_clicked (GtkButton *button, GtkamChooser *chooser) { GtkWidget *d, *status; CameraList *list; int result; const char *name; status = gtkam_status_new (_("Detecting cameras...")); gtkam_dialog_add_status (GTKAM_DIALOG (chooser), status); gp_list_new (&list); result = gp_abilities_list_detect (chooser->priv->al, chooser->priv->il, list, GTKAM_STATUS (status)->context->context); switch (result) { case GP_OK: if (!gp_list_count (list)) { d = gtkam_close_new (_("No cameras detected.")); gtk_window_set_transient_for (GTK_WINDOW (d), GTK_WINDOW (chooser)); gtk_widget_show (d); } else { /* FIXME: Let user choose from the list */ gp_list_get_name (list, 0, &name); gtk_entry_set_text (chooser->priv->entry_model, name); gtk_entry_set_text (chooser->priv->entry_port, "Universal Serial Bus (usb:)"); } break; case GP_ERROR_CANCEL: break; default: d = gtkam_error_new (result, GTKAM_STATUS (status)->context, GTK_WIDGET (chooser), _("Could not detect any cameras.")); gtk_widget_show (d); break; } gp_list_unref (list); gtk_object_destroy (GTK_OBJECT (status)); }
static TW_UINT16 gphoto2_auto_detect(void) { int result, count; if (detected_cameras && (gp_list_count (detected_cameras) == 0)) { /* Reload if previously no cameras, we might detect new ones. */ TRACE("Reloading portlist trying to detect cameras.\n"); if (port_list) { gp_port_info_list_free (port_list); port_list = NULL; } } if (!port_list) { TRACE("Auto detecting gphoto cameras.\n"); TRACE("Loading ports...\n"); if (gp_port_info_list_new (&port_list) < GP_OK) return TWRC_FAILURE; result = gp_port_info_list_load (port_list); if (result < 0) { gp_port_info_list_free (port_list); return TWRC_FAILURE; } count = gp_port_info_list_count (port_list); if (count <= 0) return TWRC_FAILURE; if (gp_list_new (&detected_cameras) < GP_OK) return TWRC_FAILURE; if (!abilities_list) { /* Load only once per program start */ gp_abilities_list_new (&abilities_list); TRACE("Loading cameras...\n"); gp_abilities_list_load (abilities_list, NULL); } TRACE("Detecting cameras...\n"); gp_abilities_list_detect (abilities_list, port_list, detected_cameras, NULL); curcamera = 0; TRACE("%d cameras detected\n", gp_list_count(detected_cameras)); } return TWRC_SUCCESS; }
void dt_camctl_detect_cameras(const dt_camctl_t *c) { dt_camctl_t *camctl=(dt_camctl_t *)c; dt_pthread_mutex_lock(&camctl->lock); /* reload portdrivers */ if (camctl->gpports) gp_port_info_list_free (camctl->gpports); gp_port_info_list_new( &camctl->gpports ); gp_port_info_list_load( camctl->gpports ); dt_print(DT_DEBUG_CAMCTL,"[camera_control] loaded %d port drivers.\n", gp_port_info_list_count( camctl->gpports ) ); CameraList *available_cameras=NULL; gp_list_new( &available_cameras ); gp_abilities_list_detect (c->gpcams,c->gpports, available_cameras, c->gpcontext ); dt_print(DT_DEBUG_CAMCTL,"[camera_control] %d cameras connected\n",gp_list_count( available_cameras )>0?gp_list_count( available_cameras ):0); for(int i=0; i<gp_list_count( available_cameras ); i++) { dt_camera_t *camera=g_malloc(sizeof(dt_camera_t)); memset( camera,0,sizeof(dt_camera_t)); gp_list_get_name (available_cameras, i, &camera->model); gp_list_get_value (available_cameras, i, &camera->port); dt_pthread_mutex_init(&camera->config_lock, NULL); dt_pthread_mutex_init(&camera->live_view_pixbuf_mutex, NULL); dt_pthread_mutex_init(&camera->live_view_synch, NULL); // if(strcmp(camera->port,"usb:")==0) { g_free(camera); continue; } GList *citem; if( (citem=g_list_find_custom(c->cameras,camera,_compare_camera_by_port)) == NULL || strcmp(((dt_camera_t *)citem->data)->model,camera->model)!=0 ) { if(citem==NULL) { // Newly connected camera if(_camera_initialize(c,camera)==FALSE) { dt_print(DT_DEBUG_CAMCTL,"[camera_control] failed to initialize device %s on port %s, probably causes are: locked by another application, no access to udev etc.\n", camera->model,camera->port); g_free(camera); continue; } // Check if camera has capabililties for being presented to darktable if( camera->can_import==FALSE && camera->can_tether==FALSE ) { dt_print(DT_DEBUG_CAMCTL,"[camera_control] device %s on port %s doesn't support import or tether, skipping device.\n", camera->model,camera->port); g_free(camera); continue; } // Fetch some summary of camera if( gp_camera_get_summary(camera->gpcam, &camera->summary, c->gpcontext) == GP_OK ) { // Remove device property summary: char *eos=strstr(camera->summary.text,"Device Property Summary:\n"); if (eos) eos[0]='\0'; } // Add to camera list camctl->cameras = g_list_append(camctl->cameras,camera); // Notify listeners of connected camera _dispatch_camera_connected(camctl,camera); } } else g_free(camera); } /* check c->cameras in available_cameras */ if( c->cameras && g_list_length(c->cameras)>0) { GList *citem = c->cameras; do { int index=0; dt_camera_t *cam=(dt_camera_t *)citem->data; if (gp_list_find_by_name(available_cameras,&index,cam->model)!= GP_OK) { /* remove camera from cached list.. */ dt_camctl_t *camctl=(dt_camctl_t *)c; dt_camera_t *oldcam = (dt_camera_t *)citem->data; camctl->cameras=citem= g_list_delete_link (c->cameras,citem); g_free(oldcam); } } while ( citem && (citem=g_list_next(citem))!=NULL); } dt_pthread_mutex_unlock(&camctl->lock); }
void KKameraConfig::load(bool useDefaults ) { m_config->setReadDefaults( useDefaults ); QStringList groupList = m_config->groupList(); QStringList::Iterator it; int i, count; CameraList *list; CameraAbilitiesList *al; GPPortInfoList *il; const char *model, *value; KCamera *kcamera; for (it = groupList.begin(); it != groupList.end(); it++) { if (*it != "<default>") { m_config->setGroup(*it); if (m_config->readEntry("Path").contains("usb:")) continue; kcamera = new KCamera(*it,m_config->readEntry("Path")); connect(kcamera, SIGNAL(error(const QString &)), SLOT(slot_error(const QString &))); connect(kcamera, SIGNAL(error(const QString &, const QString &)), SLOT(slot_error(const QString &, const QString &))); kcamera->load(m_config); m_devices[*it] = kcamera; } } m_cancelPending = false; gp_list_new (&list); gp_abilities_list_new (&al); gp_abilities_list_load (al, m_context); gp_port_info_list_new (&il); gp_port_info_list_load (il); gp_abilities_list_detect (al, il, list, m_context); gp_abilities_list_free (al); gp_port_info_list_free (il); count = gp_list_count (list); QMap<QString,QString> ports, names; for (i = 0 ; i<count ; i++) { gp_list_get_name (list, i, &model); gp_list_get_value (list, i, &value); ports[value] = model; if (!strcmp(value,"usb:")) names[model] = value; } if (ports.contains("usb:") && names[ports["usb:"]]!="usb:") ports.remove("usb:"); QMap<QString,QString>::iterator portit; for (portit = ports.begin() ; portit != ports.end(); portit++) { /* kdDebug() << "Adding USB camera: " << portit.data() << " at " << portit.key() << endl; */ kcamera = new KCamera(portit.data(),portit.key()); connect(kcamera, SIGNAL(error(const QString &)), SLOT(slot_error(const QString &))); connect(kcamera, SIGNAL(error(const QString &, const QString &)), SLOT(slot_error(const QString &, const QString &))); m_devices[portit.data()] = kcamera; } populateDeviceListView(); gp_list_free (list); emit changed( useDefaults ); }
bool GPCamera::findConnectedUsbCamera(int vendorId, int productId, QString& model, QString& port) { #ifdef HAVE_GPHOTO2 CameraAbilitiesList* abilList = 0; GPPortInfoList* list = 0; GPContext* context = 0; CameraList* camList = 0; bool success = false; // get name and port of detected camera const char* model_str = 0; const char* port_str = 0; context = gp_context_new(); // get list of all ports gp_port_info_list_new(&list); gp_port_info_list_load(list); gp_abilities_list_new(&abilList); // get list of all supported cameras gp_abilities_list_load(abilList, context); // autodetect all cameras, then match the list to the passed in USB ids gp_list_new (&camList); gp_abilities_list_detect(abilList, list, camList, context); gp_context_unref(context); int count = gp_list_count(camList); int cnt = 0; for (int i = 0 ; i < count ; i++) { const char* xmodel = 0; gp_list_get_name(camList, i, &xmodel); int model = gp_abilities_list_lookup_model (abilList, xmodel); CameraAbilities ab; gp_abilities_list_get_abilities(abilList, model, &ab); if (ab.port != GP_PORT_USB) continue; /* KDE provides us USB Vendor and Product, but we might just * have covered this via a class match. Check class matched * cameras also for matchingo USB vendor/product id */ if (ab.usb_vendor == 0) { int ret; GPPortInfo info; const char* xport = 0; GPPort* gpport = 0; /* get the port path so we only look at this bus position */ gp_list_get_value(camList, i, &xport); ret = gp_port_info_list_lookup_path (list, xport); if (ret < GP_OK) /* should not happen */ continue; /* get the lowlevel port info for the path */ gp_port_info_list_get_info(list, ret, &info); /* open lowlevel driver interface briefly to search */ gp_port_new(&gpport); gp_port_set_info(gpport, info); /* And now call into the lowlevel usb driver to see if the bus position * has that specific vendor/product id */ if (gp_port_usb_find_device(gpport, vendorId, productId) == GP_OK) { ab.usb_vendor = vendorId; ab.usb_product = productId; } gp_port_free (gpport); } if (ab.usb_vendor != vendorId) continue; if (ab.usb_product != productId) continue; /* keep it, and continue iterating, in case we find another one */ gp_list_get_name (camList, i, &model_str); gp_list_get_value(camList, i, &port_str); cnt++; } gp_port_info_list_free(list); gp_abilities_list_free(abilList); if (cnt > 0) { if (cnt > 1) { qCWarning(DIGIKAM_IMPORTUI_LOG) << "More than one camera detected on port " << port << ". Due to restrictions in the GPhoto2 API, " << "only the first camera is used."; } model = QString::fromLatin1(model_str); port = QString::fromLatin1(port_str); success = true; } else { qCDebug(DIGIKAM_IMPORTUI_LOG) << "Failed to get information for the listed camera"; } gp_list_free(camList); return success; #else Q_UNUSED(vendorId); Q_UNUSED(productId); Q_UNUSED(model); Q_UNUSED(port); return false; #endif /* HAVE_GPHOTO2 */ }
int GPCamera::autoDetect(QString& model, QString& port) { #ifdef HAVE_GPHOTO2 CameraList* camList = 0; CameraAbilitiesList* abilList = 0; GPPortInfoList* infoList = 0; const char* camModel_ = 0, *camPort_ = 0; GPContext* context = 0; context = gp_context_new(); gp_list_new(&camList); gp_abilities_list_new(&abilList); gp_abilities_list_load(abilList, context); gp_port_info_list_new(&infoList); gp_port_info_list_load(infoList); gp_abilities_list_detect(abilList, infoList, camList, context); gp_abilities_list_free(abilList); gp_port_info_list_free(infoList); gp_context_unref(context); int count = gp_list_count(camList); if (count <= 0) { qCDebug(DIGIKAM_IMPORTUI_LOG) << "Failed to autodetect camera!"; printGphotoErrorDescription(count); gp_list_free(camList); return -1; } camModel_ = 0; camPort_ = 0; for (int i = 0; i < count; i++) { if (gp_list_get_name(camList, i, &camModel_) != GP_OK) { qCDebug(DIGIKAM_IMPORTUI_LOG) << "Failed to autodetect camera!"; gp_list_free(camList); return -1; } if (gp_list_get_value(camList, i, &camPort_) != GP_OK) { qCDebug(DIGIKAM_IMPORTUI_LOG) << "Failed to autodetect camera!"; gp_list_free(camList); return -1; } if (camModel_ && camPort_) { model = QString::fromLatin1(camModel_); port = QString::fromLatin1(camPort_); gp_list_free(camList); return 0; } } qCDebug(DIGIKAM_IMPORTUI_LOG) << "Failed to autodetect camera!"; gp_list_free(camList); #else Q_UNUSED(model); Q_UNUSED(port); #endif /* HAVE_GPHOTO2 */ return -1; }
int input_run(int id) { int res, i; global->in[id].buf = malloc(256 * 1024); if(global->in[id].buf == NULL) { IPRINT(INPUT_PLUGIN_NAME " - could not allocate memory\n"); exit(EXIT_FAILURE); } plugin_id = id; // auto-detect algorithm CameraAbilitiesList* al; GPPortInfoList* il; CameraList* list; const char* model; const char* port; context = gp_context_new(); gp_abilities_list_new(&al); gp_abilities_list_load(al, context); gp_port_info_list_new(&il); gp_port_info_list_load(il); gp_list_new(&list); gp_abilities_list_detect(al, il, list, context); int count = gp_list_count(list); IPRINT(INPUT_PLUGIN_NAME " - Detected %d camera(s)\n", count); if(count == 0) { IPRINT(INPUT_PLUGIN_NAME " - No cameras detected.\n"); return 0; } GPPortInfo info; CameraAbilities a; int m, p; camera = NULL; for(i = 0; i < count; i++) { res = gp_list_get_name(list, i, &model); CAMERA_CHECK_GP(res, "gp_list_get_name"); m = gp_abilities_list_lookup_model(al, model); if(m < 0) { IPRINT(INPUT_PLUGIN_NAME " - Gphoto abilities_list_lookup_model Code: %d - %s\n", m, gp_result_as_string(m)); return 0; } res = gp_abilities_list_get_abilities(al, m, &a); CAMERA_CHECK_GP(res, "gp_abilities_list_get_abilities"); res = gp_list_get_value(list, i, &port); CAMERA_CHECK_GP(res, "gp_list_get_value"); DBG("Model: %s; port: %s.\n", model, port); if(selected_port != NULL && strcmp(selected_port, port) != 0) continue; p = gp_port_info_list_lookup_path(il, port); if(p < 0) { IPRINT(INPUT_PLUGIN_NAME " - Gphoto port_info_list_lookup_path Code: %d - %s\n", m, gp_result_as_string(m)); return 0; } res = gp_port_info_list_get_info(il, p, &info); CAMERA_CHECK_GP(res, "gp_port_info_list_get_info"); res = gp_camera_new(&camera); CAMERA_CHECK_GP(res, "gp_camera_new"); res = gp_camera_set_abilities(camera, a); CAMERA_CHECK_GP(res, "gp_camera_set_abilities"); res = gp_camera_set_port_info(camera, info); CAMERA_CHECK_GP(res, "gp_camera_set_port_info"); } if(camera == NULL) { IPRINT("Camera %s not found, exiting.\n", selected_port); exit(EXIT_FAILURE); } // cleanup gp_list_unref(list); gp_port_info_list_free(il); gp_abilities_list_free(al); // open camera and set capture on int value = 1; res = gp_camera_init(camera, context); CAMERA_CHECK_GP(res, "gp_camera_init"); camera_set("capture", &value); // starting thread if(pthread_create(&thread, 0, capture, NULL) != 0) { free(global->in[id].buf); IPRINT("could not start worker thread\n"); exit(EXIT_FAILURE); } pthread_detach(thread); return 0; }
/** * 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); }