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; }
/** * Lists the folders in supplied \c folder. * * @param camera a #Camera * @param folder a folder * @param list a #CameraList * @param context a #GPContext * @return a gphoto2 error code * **/ int gp_camera_folder_list_folders (Camera *camera, const char* folder, CameraList *list, GPContext *context) { GP_LOG_D ("Listing folders in '%s'...", folder); C_PARAMS (camera && folder && list); CHECK_INIT (camera, context); CR (camera, gp_list_reset (list), context); CHECK_RESULT_OPEN_CLOSE (camera, gp_filesystem_list_folders ( camera->fs, folder, list, context), context); CR (camera, gp_list_sort (list), context); CAMERA_UNUSED (camera, context); return (GP_OK); }
static int file_list_func (CameraFilesystem *fs, const char *folder, CameraList *list, void *data, GPContext *context) { Camera *camera = data; int i; unsigned char buf[1024]; GP_DEBUG ("List files in %s\n", folder); gp_list_reset (list); for (i = 0; i < camera->pl->nb_entries; i++) { snprintf((char *)buf, sizeof(buf), "img%03i.ppm", i + 1); gp_list_append (list, (char *)buf, NULL); } return GP_OK; }
/** * Lists the files in supplied \c folder. * * @param camera a #Camera * @param folder a folder * @param list a #CameraList * @param context a #GPContext * @return a gphoto2 error code * **/ int gp_camera_folder_list_files (Camera *camera, const char *folder, CameraList *list, GPContext *context) { gp_log (GP_LOG_DEBUG, "gphoto2-camera", "Listing files in '%s'...", folder); CHECK_NULL (camera && folder && list); CHECK_INIT (camera, context); CR (camera, gp_list_reset (list), context); CHECK_RESULT_OPEN_CLOSE (camera, gp_filesystem_list_files (camera->fs, folder, list, context), context); CR (camera, gp_list_sort (list), context); CAMERA_UNUSED (camera, context); return (GP_OK); }
static int recursive_directory(Camera *camera, const char *folder, GPContext *context, int *foundfile) { int i, ret; CameraList *list; const char *newfile; CameraFileInfo fileinfo; CameraFile *file; ret = gp_list_new (&list); if (ret < GP_OK) { printf ("Could not allocate list.\n"); return ret; } ret = gp_camera_folder_list_folders (camera, folder, list, context); if (ret < GP_OK) { printf ("Could not list folders.\n"); gp_list_free (list); return ret; } gp_list_sort (list); for (i = 0; i < gp_list_count (list); i++) { const char *newfolder; char *buf; int havefile = 0; gp_list_get_name (list, i, &newfolder); buf = malloc (strlen(folder) + 1 + strlen(newfolder) + 1); strcpy(buf, folder); if (strcmp(folder,"/")) /* avoid double / */ strcat(buf, "/"); strcat(buf, newfolder); ret = recursive_directory (camera, buf, context, &havefile); free (buf); if (ret != GP_OK) { gp_list_free (list); printf ("Failed to recursively list folders.\n"); return ret; } if (havefile) /* only look for the first directory with a file */ break; } gp_list_reset (list); ret = gp_camera_folder_list_files (camera, folder, list, context); if (ret < GP_OK) { gp_list_free (list); printf ("Could not list files.\n"); return ret; } gp_list_sort (list); if (gp_list_count (list) <= 0) { gp_list_free (list); return GP_OK; } gp_list_get_name (list, 0, &newfile); /* only entry 0 needed */ ret = gp_camera_file_get_info (camera, folder, newfile, &fileinfo, context); if (ret != GP_OK) { gp_list_free (list); printf ("Could not get file info.\n"); return ret; } /* Trigger the ptp things */ gp_file_new (&file); ret = gp_camera_file_get (camera, folder, newfile, GP_FILE_TYPE_METADATA, file, context); if ((ret != GP_OK) && (ret != GP_ERROR_NOT_SUPPORTED)) { gp_list_free (list); printf ("Could not get file metadata.\n"); return ret; } gp_file_free (file); if (foundfile) *foundfile = 1; gp_list_free (list); return GP_OK; }
static void load_filesystem(const char *folder) { #ifdef HAVE_GPHOTO2 int i, count, ret; CameraList *list; ret = gp_list_new (&list); if (ret < GP_OK) return; ret = gp_camera_folder_list_files (activeDS.camera, folder, list, activeDS.context); if (ret < GP_OK) { gp_list_free (list); return; } count = gp_list_count (list); if (count < GP_OK) { gp_list_free (list); return; } for (i = 0; i < count; i++) { const char *name; struct gphoto2_file *gpfile; ret = gp_list_get_name (list, i, &name); if (ret < GP_OK) continue; gpfile = malloc(sizeof(struct gphoto2_file)); if (!gpfile) continue; TRACE("adding %s/%s\n", folder, name); gpfile->folder = strdup(folder); gpfile->filename = strdup(name); gpfile->download = FALSE; list_add_head( &activeDS.files, &gpfile->entry ); } gp_list_reset (list); ret = gp_camera_folder_list_folders (activeDS.camera, folder, list, activeDS.context); if (ret < GP_OK) { FIXME("list_folders failed\n"); gp_list_free (list); return; } count = gp_list_count (list); if (count < GP_OK) { FIXME("list_folders failed\n"); gp_list_free (list); return; } for (i = 0; i < count; i++) { const char *name; char *newfolder; ret = gp_list_get_name (list, i, &name); if (ret < GP_OK) continue; TRACE("recursing into %s\n", name); newfolder = malloc(strlen(folder)+1+strlen(name)+1); if (!strcmp(folder,"/")) sprintf (newfolder, "/%s", name); else sprintf (newfolder, "%s/%s", folder, name); load_filesystem (newfolder); /* recurse ... happily */ } gp_list_free (list); #endif }
/** * \param list a CameraAbilitiesList * \param info_list the GPPortInfoList of ports to use for detection * \param l a #CameraList that contains the autodetected cameras after the call * \param context a #GPContext * * Tries to detect any camera connected to the computer using the supplied * list of supported cameras and the supplied info_list of ports. * * \return a gphoto2 error code */ int gp_abilities_list_detect (CameraAbilitiesList *list, GPPortInfoList *info_list, CameraList *l, GPContext *context) { GPPortInfo info; GPPort *port; int i, info_count; CHECK_NULL (list && info_list && l); gp_list_reset (l); CHECK_RESULT (info_count = gp_port_info_list_count (info_list)); CHECK_RESULT (gp_port_new (&port)); for (i = 0; i < info_count; i++) { int res; char *xpath; GPPortType type; CHECK_RESULT (gp_port_info_list_get_info (info_list, i, &info)); CHECK_RESULT (gp_port_set_info (port, info)); gp_port_info_get_type (info, &type); res = gp_port_info_get_path (info, &xpath); if (res <GP_OK) continue; switch (type) { case GP_PORT_USB: case GP_PORT_USB_SCSI: case GP_PORT_USB_DISK_DIRECT: { int ability; res = gp_abilities_list_detect_usb (list, &ability, port); if (res == GP_OK) { gp_list_append(l, list->abilities[ability].model, xpath); } else if (res < 0) gp_port_set_error (port, NULL); break; } case GP_PORT_DISK: { char *s, path[1024]; struct stat stbuf; s = strchr (xpath, ':'); if (!s) break; s++; snprintf (path, sizeof(path), "%s/DCIM", s); if (-1 == stat(path, &stbuf)) { snprintf (path, sizeof(path), "%s/dcim", s); if (-1 == stat(path, &stbuf)) continue; } gp_list_append (l, "Mass Storage Camera", xpath); break; } case GP_PORT_PTPIP: { char *s; s = strchr (xpath, ':'); if (!s) break; s++; if (!strlen(s)) break; gp_list_append (l, "PTP/IP Camera", xpath); break; } default: /* * We currently cannot detect any cameras on this * port */ break; } } gp_port_free (port); return (GP_OK); }
int gp_abilities_list_load_dir (CameraAbilitiesList *list, const char *dir, GPContext *context) { CameraLibraryIdFunc id; CameraLibraryAbilitiesFunc ab; CameraText text; int ret, x, old_count, new_count; unsigned int i, p; const char *filename; CameraList *flist; int count; lt_dlhandle lh; CHECK_NULL (list && dir); gp_log (GP_LOG_DEBUG, "gphoto2-abilities-list", "Using ltdl to load camera libraries from '%s'...", dir); CHECK_RESULT (gp_list_new (&flist)); ret = gp_list_reset (flist); if (ret < GP_OK) { gp_list_free (flist); return ret; } if (1) { /* a new block in which we can define a temporary variable */ foreach_data_t foreach_data = { NULL, GP_OK }; foreach_data.list = flist; lt_dlinit (); lt_dladdsearchdir (dir); ret = lt_dlforeachfile (dir, foreach_func, &foreach_data); lt_dlexit (); if (ret != 0) { gp_list_free (flist); gp_log (GP_LOG_ERROR, "gp-abilities-list", "Internal error looking for camlibs (%d)", ret); gp_context_error (context, _("Internal error looking for camlibs. " "(path names too long?)")); return (foreach_data.result!=GP_OK)?foreach_data.result:GP_ERROR; } } count = gp_list_count (flist); if (count < GP_OK) { gp_list_free (flist); return ret; } gp_log (GP_LOG_DEBUG, "gp-abilities-list", "Found %i " "camera drivers.", count); lt_dlinit (); p = gp_context_progress_start (context, count, _("Loading camera drivers from '%s'..."), dir); for (i = 0; i < count; i++) { ret = gp_list_get_name (flist, i, &filename); if (ret < GP_OK) { gp_list_free (flist); return ret; } lh = lt_dlopenext (filename); if (!lh) { gp_log (GP_LOG_DEBUG, "gphoto2-abilities-list", "Failed to load '%s': %s.", filename, lt_dlerror ()); continue; } /* camera_id */ id = lt_dlsym (lh, "camera_id"); if (!id) { gp_log (GP_LOG_DEBUG, "gphoto2-abilities-list", "Library '%s' does not seem to " "contain a camera_id function: %s", filename, lt_dlerror ()); lt_dlclose (lh); continue; } /* * Make sure the camera driver hasn't been * loaded yet. */ if (id (&text) != GP_OK) { lt_dlclose (lh); continue; } if (gp_abilities_list_lookup_id (list, text.text) >= 0) { lt_dlclose (lh); continue; } /* camera_abilities */ ab = lt_dlsym (lh, "camera_abilities"); if (!ab) { gp_log (GP_LOG_DEBUG, "gphoto2-abilities-list", "Library '%s' does not seem to " "contain a camera_abilities function: " "%s", filename, lt_dlerror ()); lt_dlclose (lh); continue; } old_count = gp_abilities_list_count (list); if (old_count < 0) { lt_dlclose (lh); continue; } if (ab (list) != GP_OK) { lt_dlclose (lh); continue; } lt_dlclose (lh); new_count = gp_abilities_list_count (list); if (new_count < 0) continue; /* Copy in the core-specific information */ for (x = old_count; x < new_count; x++) { strcpy (list->abilities[x].id, text.text); strcpy (list->abilities[x].library, filename); } gp_context_progress_update (context, p, i); if (gp_context_cancel (context) == GP_CONTEXT_FEEDBACK_CANCEL) { lt_dlexit (); gp_list_free (flist); return (GP_ERROR_CANCEL); } } gp_context_progress_stop (context, p); lt_dlexit (); gp_list_free (flist); return (GP_OK); }
void symbol_list_reset(void) { gp_list_reset(&state.obj.symbol_fifo); }