Exemplo n.º 1
0
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;
}
Exemplo n.º 2
0
static int camera_capture (Camera *camera, CameraCaptureType type, CameraFilePath *path, GPContext *context) {
	CameraList *list;
	int   count;
        const char* name;

	if (type != GP_CAPTURE_IMAGE)
		return (GP_ERROR_NOT_SUPPORTED);

	/* capture a image to flash (note: we do not check if full */
	CHECK_RESULT (dc120_capture(camera, path, context));

	/* Get the last picture in the Flash memory */
	gp_list_new(&list);

	dc120_get_filenames (camera, 0, 0, list, context);

	count = gp_list_count(list);
	gp_list_get_name (list, count - 1, &name);
	gp_list_free(list);


	/* Set the filename */
	snprintf(path->folder, sizeof(path->folder), "/");
	

	CHECK_RESULT (gp_filesystem_append (camera->fs, 
					    path->folder, 
					    path->name, context));

        return (GP_OK);

}
Exemplo n.º 3
0
static int
shell_cd (Camera __unused__ *camera, const char *arg)
{
	char folder[MAX_FOLDER_LEN];
	CameraList *list;
	int arg_count = shell_arg_count (arg);

	if (!arg_count)
		return (GP_OK);

	/* shell_arg(arg, 0, arg_dir); */

	if (strlen (arg) > 1023) {
		cli_error_print ("Folder value is too long");
		return (GP_ERROR);
	}

	/* Get the new folder value */
	shell_construct_path (p->folder, arg, folder, NULL);

	CHECK (gp_list_new (&list));

	CL (gp_camera_folder_list_folders (p->camera, folder, list,
					      p->context), list);
	gp_list_free (list);
	free (p->folder);
	p->folder = malloc (sizeof (char) * (strlen (folder) + 1));
	if (!p->folder)
		return (GP_ERROR_NO_MEMORY);
	strcpy (p->folder, folder);
	printf (_("Remote directory now '%s'."), p->folder);
	putchar ('\n');
	return (GP_OK);
}
Exemplo n.º 4
0
bool photo_camera_list::autodetect( GPContext* context )
{
  ssize_t port_count = 0;
 
  // Create a new list of cameras
  if( gp_list_new( &camera_list_ ) != GP_OK )
  {
    photo_reporter::error( "gp_list_new()" );
    return false;
  }

  // Load the low-level port drivers
  if( loadPortInfo( &port_count ) == false )
  {
    return false;
  }

  // Load the photo_camera drivers
  if( loadAbilities( context ) == false )
  {
    return false;
  }


  // Filter the list for USB cameras
  if( filterCameraList( context, "usb:" ) == false )
  {
    return false;
  }
  return true;
}
Exemplo n.º 5
0
void Camera::for_each_file_in_folder(const FileFunc& func, const std::string& folder) {
    int ret;
    CameraList *files;
    gp_list_new(&files);
    if ((ret = gp_camera_folder_list_files(camera, folder.c_str(), files, ctx->context)) < GP_OK) {
        throw Exception("gp_camera_folder_list_files", ret);
    }
    for (int i = 0; i < gp_list_count(files); ++i) {
        std::string file_name;
        {
            const char *c_file_name;
            gp_list_get_name(files, i, &c_file_name);
            file_name = c_file_name;
        }
        CameraFileInfo file_info;
        if ((ret = gp_camera_file_get_info(camera, folder.c_str(), file_name.c_str(), &file_info, ctx->context)) < GP_OK) {
            throw Exception("gp_camera_file_get_info", ret);
        }
        FileInfo info;
        info.folder = folder;
        info.name = file_name;
        if (file_info.file.fields & GP_FILE_INFO_MTIME) {
            info.fields |= FILE_INFO_TIME;
            info.time = file_info.file.mtime;
        }
        if (file_info.file.fields & GP_FILE_INFO_TYPE) {
            info.fields |= FILE_INFO_TYPE;
            info.type = file_info.file.type;
        }
        func(info);
    }
    gp_list_free(files);

    CameraList *folders;
    gp_list_new(&folders);
    if ((ret = gp_camera_folder_list_folders(camera, folder.c_str(), folders, ctx->context)) < GP_OK) {
        throw Exception("gp_camera_folder_list_folders", ret);
    }
    for (int i = 0; i < gp_list_count(folders); ++i) {
        const char *child_name;
        gp_list_get_name(folders, i, &child_name);
        std::string absolute_path = folder + "/" + child_name;
        for_each_file_in_folder(func, absolute_path);
    }
    gp_list_free(folders);
}
Exemplo n.º 6
0
static int foreach_entry(char* folder, GPParams* gp_params, enum EntryType type, PHandleFunc func, void* args)
{
	CameraList *list = NULL;
	int ret = 0, count = 0;
	CK00 (ret = gp_list_new (&list), err_newlist);
	if (type == ET_FOLDER)
		CK00 (ret = gp_camera_folder_list_folders (gp_params->camera, folder, list, gp_params->context), err_listfolder);
	else if (type == ET_FILE)
		CK00 (ret = gp_camera_folder_list_files (gp_params->camera, folder, list, gp_params->context), err_listfiles);
	else {
		LOG_E("unknow type :%d\n", type);
		goto release_list;
	}
	CK00 (count = ret = gp_list_count (list), err_listcount);

	int i = 0;
	for (i = 0; i < count; ++i) {
		const char* tmp_name = NULL;
		CK00 (ret= gp_list_get_name (list, i, &tmp_name), err_listgetname);
		if (type == ET_FILE && try_get_camera_file(gp_params, folder, tmp_name) < 0) {
			continue;
		}
		char* new_folder = NULL;
		CK01 (new_folder = make_new_path(folder,tmp_name), err_makpath);
		func(new_folder, gp_params, args);
		safe_free(new_folder);
	}
release_list:
	if (list)
		gp_list_free (list);
out:
	return ret;

err_newlist:
	LOG_E("gp_list_new error,retcode = %d", ret);
	ret = -1;
	goto out;
err_listfolder:
	LOG_E("gp_camera_folder_list_folders error,retcode = %d", ret);
	ret = -1;
	goto release_list;
err_listfiles:
	LOG_E("gp_camera_folder_list_files error,retcode = %d", ret);
	ret = -1;
	goto release_list;
err_listcount:
	LOG_E("gp_list_count error,retcode = %d", ret);
	ret = -1;
	goto release_list;
err_listgetname:
	LOG_E("gp_list_get_name error,retcode = %d", ret);
	ret = -1;
	goto release_list;
err_makpath:
	ret = -1;
	goto release_list;	
}
Exemplo n.º 7
0
int
for_each_file (GPParams *p, FileAction action)
{
	CameraList *list;
	int i, count, r;
	const char *name = NULL;
	char *f = NULL;

	CR (gp_list_new (&list));
	/* Iterate on all files */
	CR (gp_camera_folder_list_files (p->camera, p->folder, list,
					 p->context));
	CR (count = gp_list_count (list));
	if (p->flags & FLAGS_REVERSE) {
		for (i = count ; i--; ) {
			CL (gp_list_get_name (list, i, &name), list);
			CL (action (p, name), list);
		}
	} else {
		for (i = 0; i < count; i++) {
			CL (gp_list_get_name (list, i, &name), list);
			CL (action (p, name), list);
		}
	}

	/* If no recursion is requested, we are done. */
	if (!(p->flags & FLAGS_RECURSE)) {
		gp_list_free (list);
		return (GP_OK);
	}

	/* Recursion requested. Descend into subfolders. */
	CL (gp_camera_folder_list_folders (p->camera, p->folder,
					   list, p->context), list);
	CL (count = gp_list_count (list), list);
	for (i = 0; i < count; i++) {
		CL (gp_list_get_name (list, i, &name), list);
		f = p->folder;
		p->folder = malloc (sizeof (char) *
				(strlen (f) + 1 + strlen (name) + 1));
		if (!p->folder) {
			p->folder = f;
			gp_list_free (list);
			return (GP_ERROR_NO_MEMORY);
		}
		strcpy (p->folder, f);
		if (p->folder[strlen (p->folder) - 1] != '/')
			strcat (p->folder, "/");
		strcat (p->folder, name);
		r = for_each_file (p, action);
		free (p->folder);
		p->folder = f;
		CL (r, list);
	}
	gp_list_free (list);
	return (GP_OK);
}
Exemplo n.º 8
0
static int
shell_ls (Camera __unused__ *camera, const char *arg)
{
	CameraList *list;
	char buf[1024], folder[MAX_FOLDER_LEN];
	int x, y=1;
	int arg_count = shell_arg_count(arg);
	const char *name;

	if (arg_count) {
		shell_construct_path (p->folder, arg, folder, NULL);
	} else {
		strcpy (folder, p->folder);
	}

	CHECK (gp_list_new (&list));
	CL (gp_camera_folder_list_folders (p->camera, folder, list,
					      p->context), list);

	if (p->flags & FLAGS_QUIET)
		printf ("%i\n", gp_list_count (list));

	for (x = 1; x <= gp_list_count (list); x++) {
		CL (gp_list_get_name (list, x - 1, &name), list);
		if (p->flags & FLAGS_QUIET)
			printf ("%s\n", name);
		else {
			sprintf (buf, "%s/", name);
			printf ("%-20s", buf);
			if (y++ % 4 == 0)
				putchar ('\n');
		}
	}

	CL (gp_camera_folder_list_files (p->camera, folder, list,
					    p->context), list);

	if (p->flags & FLAGS_QUIET)
		printf("%i\n", gp_list_count(list));

	for (x = 1; x <= gp_list_count (list); x++) {
		gp_list_get_name (list, x - 1, &name);
		if (p->flags & FLAGS_QUIET)
			printf ("%s\n", name);
		else {
			printf ("%-20s", name);
			if (y++ % 4 == 0)
				putchar ('\n');
		}
	}
	if ((p->flags & FLAGS_QUIET) == 0 && (y % 4 != 1))
		putchar ('\n');

	gp_list_free (list);
	return (GP_OK);
}
Exemplo n.º 9
0
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;
}
Exemplo n.º 10
0
static int
get_path_for_id_rec (GPParams *p,
		     const char *base_folder, unsigned int id,
		     unsigned int *base_id, char *folder,
		     char *filename)
{
	char subfolder[1024];
	int n_folders, n_files, r;
	unsigned int i;
	const char *name;
	CameraList *list;

	strncpy (folder, base_folder, MAX_FOLDER_LEN);
	CR (gp_list_new(&list));
	CL (gp_camera_folder_list_files (p->camera, base_folder, list,
					 p->context), list);
	CL (n_files = gp_list_count (list), list);
	if (id - *base_id < (unsigned int) n_files) {

		/* ID is in this folder */
		GP_DEBUG ("ID %i is in folder '%s'.", id, base_folder);
		CL (gp_list_get_name (list, id - *base_id, &name), list);
		strncpy (filename, name, MAX_FILE_LEN);
		gp_list_free (list);
		return (GP_OK);
	} else {
		/* Look for IDs in subfolders */
		GP_DEBUG ("ID %i is not in folder '%s'.", id, base_folder);
		*base_id += n_files;
		CL (gp_camera_folder_list_folders (p->camera, base_folder,
						   list, p->context), list);
		CL (n_folders = gp_list_count (list), list);
		for (i = 0; i < (unsigned int)n_folders; i++) {
			CL (gp_list_get_name (list, i, &name), list);
			strncpy (subfolder, base_folder, sizeof (subfolder));
			if (strlen (base_folder) > 1)
				strncat (subfolder, "/", sizeof (subfolder) - strlen(subfolder) - 1);
			strncat (subfolder, name, sizeof (subfolder) - strlen(subfolder) - 1);
			r = get_path_for_id_rec (p, subfolder, id, base_id,
						 folder, filename);
			switch (r) {
			case GP_ERROR_FRONTEND_BAD_ID:
				break;
			default:
				gp_list_free (list);
				return (r);
			}
		}
		gp_list_free (list);
		return (GP_ERROR_FRONTEND_BAD_ID);
	}
}
Exemplo n.º 11
0
bool GPCamera::getFolders(const QString& folder)
{
#ifdef HAVE_GPHOTO2
    int         errorCode;
    CameraList* clist = 0;
    gp_list_new(&clist);

    d->status->cancel = false;
    errorCode         = gp_camera_folder_list_folders(d->camera, QFile::encodeName(folder).constData(), clist, d->status->context);

    if (errorCode != GP_OK)
    {
        qCDebug(DIGIKAM_IMPORTUI_LOG) << "Failed to get folders list from camera!";
        printGphotoErrorDescription(errorCode);
        gp_list_unref(clist);
        return false;
    }

    QStringList subFolderList;
    int count = gp_list_count(clist);

    if (count < 1)
    {
        return true;
    }

    for (int i = 0 ; i < count ; ++i)
    {
        const char* subFolder = 0;
        errorCode             = gp_list_get_name(clist, i, &subFolder);

        if (errorCode != GP_OK)
        {
            qCDebug(DIGIKAM_IMPORTUI_LOG) << "Failed to get folder name from camera!";
            printGphotoErrorDescription(errorCode);
            gp_list_unref(clist);
            return false;
        }

        subFolderList.append(folder + QFile::decodeName(subFolder) + QLatin1Char('/'));
    }

    gp_list_unref(clist);

    emit signalFolderList(subFolderList);

    return true;
#else
    Q_UNUSED(folder);
    return false;
#endif /* HAVE_GPHOTO2 */
}
Exemplo n.º 12
0
bool GPCamera::getItemsInfoList(const QString& folder, bool useMetadata, CamItemInfoList& items)
{
#ifdef HAVE_GPHOTO2
    int         errorCode;
    CameraList* clist = 0;
    const char* cname = 0;

    gp_list_new(&clist);

    d->status->cancel = false;
    errorCode         = gp_camera_folder_list_files(d->camera, QFile::encodeName(folder).constData(), clist, d->status->context);

    if (errorCode != GP_OK)
    {
        qCDebug(DIGIKAM_IMPORTUI_LOG) << "Failed to get folder files list from camera!";
        printGphotoErrorDescription(errorCode);
        gp_list_unref(clist);
        return false;
    }

    int count = gp_list_count(clist);

    for (int i = 0 ; i < count ; ++i)
    {
        errorCode = gp_list_get_name(clist, i, &cname);

        if (errorCode != GP_OK)
        {
            qCDebug(DIGIKAM_IMPORTUI_LOG) << "Failed to get file name from camera!";
            printGphotoErrorDescription(errorCode);
            gp_list_unref(clist);
            return false;
        }

        // TODO for further speed-up, getItemInfoInternal call could be called separately when needed
        CamItemInfo info;
        getItemInfoInternal(folder, QFile::decodeName(cname), info, useMetadata);
        items.append(info);
    }

    gp_list_unref(clist);

    return true;
#else
    Q_UNUSED(folder);
    Q_UNUSED(useMetadata);
    Q_UNUSED(items);
    return false;
#endif /* HAVE_GPHOTO2 */
}
int main(int argc, char **argv) {
    CameraList	*list;
    Camera		**cams;
    int		ret, i, count;
    const char	*name, *value;
    GPContext	*context;

    context = sample_create_context (); /* see context.c */

    /* Detect all the cameras that can be autodetected... */
    ret = gp_list_new (&list);
    if (ret < GP_OK) return 1;
    count = sample_autodetect (list, context);

    /* Now open all cameras we autodected for usage */
    printf("Number of cameras: %d\n", count);
    cams = calloc (sizeof (Camera*),count);
    for (i = 0; i < count; i++) {
        gp_list_get_name  (list, i, &name);
        gp_list_get_value (list, i, &value);
        ret = sample_open_camera (&cams[i], name, value, context);
        if (ret < GP_OK) fprintf(stderr,"Camera %s on port %s failed to open\n", name, value);
    }
    /* Now call a simple function in each of those cameras. */
    for (i = 0; i < count; i++) {
        CameraText	text;
        char 		*owner;
        ret = gp_camera_get_summary (cams[i], &text, context);
        if (ret < GP_OK) {
            fprintf (stderr, "Failed to get summary.\n");
            continue;
        }

        gp_list_get_name  (list, i, &name);
        gp_list_get_value (list, i, &value);
        printf("%-30s %-16s\n", name, value);
        printf("Summary:\n%s\n", text.text);

        /* Query a simple string configuration variable. */
        ret = get_config_value_string (cams[i], "owner", &owner, context);
        if (ret >= GP_OK) {
            printf("Owner: %s\n", owner);
            free (owner);
        } else {
            printf("Owner: No owner found.\n");
        }

    }
    return 0;
}
Exemplo n.º 14
0
/**
 * 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);
}
Exemplo n.º 15
0
// TODO unused, remove?
bool GPCamera::getItemsList(const QString& folder, QStringList& itemsList)
{
#ifdef HAVE_GPHOTO2
    int         errorCode;
    CameraList* clist = 0;
    const char* cname = 0;

    gp_list_new(&clist);

    d->status->cancel = false;
    errorCode         = gp_camera_folder_list_files(d->camera, QFile::encodeName(folder).constData(), clist, d->status->context);

    if (errorCode != GP_OK)
    {
        qCDebug(DIGIKAM_IMPORTUI_LOG) << "Failed to get folder files list from camera!";
        printGphotoErrorDescription(errorCode);
        gp_list_unref(clist);
        return false;
    }

    int count = gp_list_count(clist);

    for (int i = 0 ; i < count ; ++i)
    {
        errorCode = gp_list_get_name(clist, i, &cname);

        if (errorCode != GP_OK)
        {
            qCDebug(DIGIKAM_IMPORTUI_LOG) << "Failed to get file name from camera!";
            printGphotoErrorDescription(errorCode);
            gp_list_unref(clist);
            return false;
        }

        itemsList.append(QFile::decodeName(cname));
    }

    gp_list_unref(clist);

    return true;
#else
    Q_UNUSED(folder);
    Q_UNUSED(itemsList);
    return false;
#endif /* HAVE_GPHOTO2 */
}
Exemplo n.º 16
0
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;
        }
    }
}
Exemplo n.º 17
0
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));
}
Exemplo n.º 18
0
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;
}
Exemplo n.º 19
0
bool photoController::checkCameraDetection()
{
	START_CHRONOMETER();
	CameraList *list;
	gp_list_new (&list);
	int ret = auto_detect_action(list, context);
	DEBUG_PRINTF(V_MESSAGE, "gp_camera_autodetect return %d wanted %d\n", ret, GP_OK);
	if(ret >= GP_OK)
	{
		int cameraCount = gp_list_count(list);
		DEBUG_PRINTF(V_MESSAGE, "Camera count: %d\n", cameraCount);
		if(cameraCount > 0)
		{
			DEBUG_PRINTF(V_MESSAGE, "Got a camera\n");
			camera_detected = true;
			if(!camera && !initCamera())
			{
				camera = NULL;
			}
		}
	}
	else
	{
		if(camera)
		{
			DEBUG_PRINTF(V_MESSAGE, "Exit camera\n");
			gp_camera_exit(camera, context);
			camera = NULL;
		}
		camera_detected = false;
		DEBUG_PRINTF(V_MESSAGE, "Error while getting camera list\n");
	}
	
	gp_list_unref (list);
	STOP_CHRONOMETER("Camera detection");
	return camera_detected;
}
Exemplo n.º 20
0
/** Parses a path for a folder and returns folder number and card */
static int find_folder( Camera *camera, const char *folder, 
			int *from_card, int *folder_nr, GPContext *context)
{
    CameraList *albums = NULL;
    const char* album_name;
    int folder_len;
    int i;
    char *dc120_folder_card   = _("CompactFlash Card");
    
    if( folder[0] != '/' ) {
	return (GP_ERROR);
    }

    folder++;
    
    if( folder[0] == '\0') {
	/* From memory */
	*from_card = FALSE;
	*folder_nr = 0;
	return (GP_OK);
    }
    else if( strncmp(folder, dc120_folder_card, strlen(dc120_folder_card) )==0) {
	/* From card */
	*from_card = TRUE;
	folder += strlen(dc120_folder_card);
    }
    else {
	/* Subfolder in memory */
	*from_card = FALSE;
	folder--; /* step back to slash */
    }
    
    if ( (folder[0] == 0) ||
	 (folder[0] == '/' && folder[1] == 0) ) { /* ok, finished */
	*folder_nr = 0;
	return (GP_OK);
    }
    else if( folder[0] != '/' )
	return (GP_ERROR);
    
    folder++; /* remove slash */
    
    /* Have trailing slash */
    folder_len = strlen(folder);
    if (folder[folder_len-1] == '/') {
	folder_len--;
    }
    
  /* ok, now we have a album. first get all albums */
    if( gp_list_new( &albums ) != (GP_OK) ) {
	return (GP_ERROR);
    }
    
    if( dc120_get_albums(camera, *from_card, albums, context) != (GP_OK) ) {
	gp_list_free( albums );
	return (GP_ERROR);
    }
    
    /* no check if such a album exist */
    for( i = 0; i<gp_list_count( albums ); i++ )
    {
	gp_list_get_name( albums, i, &album_name );
	if( strlen( album_name ) == folder_len &&
	    strncmp( album_name, folder, folder_len ) == 0 )
	{
	    *folder_nr = i+1;
	    gp_list_free( albums ); /* ok, we found it. */
	    return (GP_OK);
	}
    }
    
    /* oh, we did not find the folder. bummer. */
    gp_list_free( albums );
    return (GP_ERROR);
}
Exemplo n.º 21
0
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 );
}
Exemplo n.º 22
0
static int camera_file_action (Camera *camera, int action, CameraFile *file,
			       const char *folder, const char *filename,
			       GPContext *context) 
{
	CameraList *files = NULL;
	const char* file_name;
	int file_nr;
	int i;
	char *dot;
	int picnum=0;
	int result = GP_OK;
	
	/*  first find the file */
	int from_card;
	int folder_nr;
	
	result = find_folder( camera, folder, &from_card, &folder_nr, context );
	if( result != (GP_OK) ) {
		return result;
	}
	
	result = gp_list_new( &files );
	if( result != GP_OK ) {
		goto fail;
	}
	
	result = dc120_get_filenames(camera, from_card, folder_nr, files, context);
	if( result != GP_OK ) {
		goto fail;
	}
	
	
	/* now we have the list, search for the file. */
	file_nr = -1;
	for( i = 0; i<gp_list_count( files ); i++ ) {
		gp_list_get_name( files, i, &file_name );
		if( strcmp( file_name, filename ) == 0 ) {
	    file_nr = i;  /* ok, we found it. */
	    break;
		}
	}
	gp_list_free( files );
	
	
	if( file_nr == -1 ) { /* not found */
		return GP_ERROR;
	}
	
	
	picnum = gp_filesystem_number(camera->fs, folder, filename, context);
	if (picnum < 0)
		return picnum;
	
	
	if (action == DC120_ACTION_PREVIEW) { /* FIXME: marcus, fix type */
		dot = strrchr(filename, '.');
		if( dot && strlen( dot )>3 ) {
	    strcpy( dot+1, "ppm");
		}
	}
	return (dc120_file_action(camera, action, from_card, folder_nr, picnum+1, file, context));
	/* yes, after that it is to handle failures. */
 fail:
	if (files)
		gp_list_free( files );
	return result;

}
Exemplo n.º 23
0
int
for_each_folder (GPParams *p, FolderAction action)
{
	CameraList *list;
	int r, i, count;
	const char *name = NULL;
	char *f = NULL;

	if (!p)
		return (GP_ERROR_BAD_PARAMETERS);

	/* Execute the action for this folder. */
	for (i = 0; FolderActions[i].name; i++)
		if (FolderActions[i].action == action)
			break;
	gp_log (GP_LOG_DEBUG, "foreach",
		"Executing action '%s' for folder '%s'.",
		FolderActions[i].name, p->folder);
	CR (action (p));

	/* If no recursion is requested, we are done. */
	if (!(p->flags & FLAGS_RECURSE))
		return GP_OK;

	CR (gp_list_new (&list));
	/* Recursion requested. Descend into subfolders. */
	CL (gp_camera_folder_list_folders (p->camera, p->folder, list,
					   p->context), list);
	CL (count = gp_list_count (list), list); 
	if (p->flags & FLAGS_REVERSE) {
		for (i = count - 1; i >= 0; i--) {
			CL (gp_list_get_name (list, i, &name), list);
			f = p->folder;
			p->folder = malloc (sizeof (char) *
				(strlen (f) + 1 + strlen (name) + 1));
			if (!p->folder) {
				p->folder = f;
				gp_list_free (list);
				return (GP_ERROR_NO_MEMORY);
			}
			strcpy (p->folder, f);
			if (p->folder[strlen (p->folder) - 1] != '/')
				strcat (p->folder, "/");
			strcat (p->folder, name);
			r = for_each_folder (p, action);
			free (p->folder);
			p->folder = f;
			CL (r, list);
		}
	} else {
		for (i = 0; i < count; i++) {
			CL (gp_list_get_name (list, i, &name), list);
			f = p->folder;
			p->folder = malloc (sizeof (char) * 
				(strlen (f) + 1 + strlen (name) + 1));
			if (!p->folder) {
				p->folder = f;
				gp_list_free (list);
				return (GP_ERROR_NO_MEMORY);
			}
			strcpy (p->folder, f);
			if (p->folder[strlen (p->folder) - 1] != '/')
				strcat (p->folder, "/");
			strcat (p->folder, name);
			r = for_each_folder (p, action);
			free (p->folder);
			p->folder = f;
			CL (r, list);
		}
	}
	gp_list_free (list);
	return (GP_OK);
}
Exemplo n.º 24
0
static int
get_path_for_id (GPParams *p, const char *base_folder,
		 unsigned int id, char *folder, char *filename)
{
	int r;
	unsigned int base_id;
	const char *name;

	strncpy (folder, base_folder, MAX_FOLDER_LEN);
	if (p->flags & FLAGS_RECURSE) {
                base_id = 0;
                r = get_path_for_id_rec (p, base_folder, id, &base_id, folder,
                                         filename);
                switch (r) {
                case GP_ERROR_FRONTEND_BAD_ID:
                        gp_context_error (p->context, _("Bad file number. "
                                "You specified %i, but there are only %i "
                                "files available in '%s' or its subfolders. "
                                "Please obtain a valid file number from "
                                "a file listing first."), id + 1, base_id,
                                base_folder);
                        return (GP_ERROR_BAD_PARAMETERS);
                default:
                        return (r);
                }
	} else {
		CameraList *list;
		int list_count;

		/* If we have no recursion, things are easy. */
		GP_DEBUG ("No recursion. Taking file %i from folder '%s'.",
			  id, base_folder);
		CR (gp_list_new (&list));
		CL (gp_camera_folder_list_files (p->camera, base_folder,
						 list, p->context), list);
		CL ((list_count = gp_list_count (list)), list);
		if (id >= (unsigned int) list_count) {
			switch (list_count) {
			case 0:
				gp_context_error (p->context,
					_("There are no files in "
					"folder '%s'."), base_folder);
				gp_list_free (list);
				return (GP_ERROR_BAD_PARAMETERS);
			case 1:
				gp_context_error (p->context, 
					_("Bad file number. "
					"You specified %i, but there is only "
					"1 file available in '%s'."), id + 1,
					base_folder);
				gp_list_free (list);
				return (GP_ERROR_BAD_PARAMETERS);
			default:
				gp_context_error (p->context,
					_("Bad file number. "
					"You specified %i, but there are only "
					"%i files available in '%s'. "
					"Please obtain a valid file number "
					"from a file listing first."), id + 1,
					gp_list_count (list), base_folder);
				gp_list_free (list);
				return (GP_ERROR_BAD_PARAMETERS);
			}
		}
		CL (gp_list_get_name (list, id, &name), list);
		strncpy (filename, name, MAX_FILE_LEN);
		gp_list_free (list);
		return (GP_OK);
	}
}
Exemplo n.º 25
0
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
}
Exemplo n.º 26
0
int _camctl_recursive_get_previews(const dt_camctl_t *c,dt_camera_preview_flags_t flags,char *path)
{
  CameraList *files;
  CameraList *folders;
  const char *filename;
  const char *foldername;

  gp_list_new (&files);
  gp_list_new (&folders);

  // Process files in current folder...
  if( gp_camera_folder_list_files(c->active_camera->gpcam,path,files,c->gpcontext) == GP_OK )
  {
    for(int i=0; i < gp_list_count(files); i++)
    {
      gp_list_get_name (files, i, &filename);
      char *file = g_strconcat(path, "/", filename, NULL);

      // Lets check the type of file...
      CameraFileInfo cfi;
      if( gp_camera_file_get_info(c->active_camera->gpcam, path, filename,&cfi,c->gpcontext) == GP_OK)
      {
        CameraFile *preview=NULL;
        CameraFile *exif=NULL;

        /*
         * Fetch image preview if flagged...
         */
        if( flags & CAMCTL_IMAGE_PREVIEW_DATA )
        {
          gp_file_new(&preview);
          if( gp_camera_file_get(c->active_camera->gpcam, path, filename, GP_FILE_TYPE_PREVIEW,preview,c->gpcontext) < GP_OK )
          {
            // No preview for file lets check image size to se if we should download full image for preview...
            if( cfi.file.size > 0  && cfi.file.size < 512000 )
              if( gp_camera_file_get(c->active_camera->gpcam, path, filename, GP_FILE_TYPE_NORMAL,preview,c->gpcontext) < GP_OK )
              {
                preview=NULL;
                dt_print(DT_DEBUG_CAMCTL,"[camera_control] failed to retreive preview of file %s\n",filename);
              }
          }
        }

        if( flags & CAMCTL_IMAGE_EXIF_DATA )
        {
          gp_file_new(&exif);
          if( gp_camera_file_get(c->active_camera->gpcam, path, filename, GP_FILE_TYPE_EXIF,exif,c->gpcontext) < GP_OK )
          {
            exif=NULL;
            dt_print(DT_DEBUG_CAMCTL,"[camera_control] failed to retreive exif of file %s\n",filename);
          }
        }

        // let's dispatch to host app.. return if we should stop...
        if (!_dispatch_camera_storage_image_filename(c,c->active_camera,file,preview,exif))
        {
          g_free(file);
          return 0;
        }
      }
      else
        dt_print(DT_DEBUG_CAMCTL,"[camera_control] failed to get file information of %s in folder %s on device\n",filename,path);
      g_free(file);
    }
  }

  // Recurse into folders in current folder...
  if( gp_camera_folder_list_folders(c->active_camera->gpcam,path,folders,c->gpcontext)==GP_OK)
  {
    for(int i=0; i < gp_list_count(folders); i++)
    {
      char buffer[4096]= {0};
      g_strlcat(buffer,path, 4096);
      if(path[1]!='\0') g_strlcat(buffer,"/", 4096);
      gp_list_get_name (folders, i, &foldername);
      g_strlcat(buffer,foldername, 4096);
      if( !_camctl_recursive_get_previews(c,flags,buffer))
        return 0;
    }
  }
  gp_list_free (files);
  gp_list_free (folders);
  return 1;
}
Exemplo n.º 27
0
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);
}
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);
}
Exemplo n.º 29
0
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;
}
Exemplo n.º 30
0
int
main ()
{
	CameraFilesystem *fs;
	CameraFileInfo info;
	CameraList *list;
	int x, count;
	const char *name;
	char *foldername;
	GPContext *context;

#ifdef HAVE_MCHECK_H
	mtrace();
#endif

	CHECK (gp_list_new(&list));

	gp_log_add_func (GP_LOG_DEBUG, log_func, NULL);
	context = gp_context_new ();
	gp_context_set_error_func (context, error_func, NULL);

	printf ("*** Creating file system...\n");
	CHECK (gp_filesystem_new (&fs));

	printf ("*** Setting the callbacks...\n");
	CHECK (gp_filesystem_set_funcs (fs, &fsfuncs, NULL));

	printf ("*** Adding a file...\n");
	CHECK (gp_filesystem_append (fs, "/", "my.file", context));

	gp_filesystem_dump (fs);

	printf ("*** Removing this file...\n");
	CHECK (gp_filesystem_delete_file (fs, "/", "my.file", context));

	gp_filesystem_dump (fs);

	printf ("*** Resetting...\n");
	CHECK (gp_filesystem_reset (fs));

	gp_filesystem_dump (fs);

	printf ("*** Adding /...\n");
	CHECK (gp_filesystem_append (fs, "/", NULL, context));

	printf ("*** Adding /whatever ...\n");
	CHECK (gp_filesystem_append (fs, "/whatever", NULL, context));

	printf ("*** Adding /whatever/dir...\n");
	CHECK (gp_filesystem_append (fs, "/whatever/dir", NULL, context));

	printf ("*** Adding /whatever/dir/file1...\n");
	CHECK (gp_filesystem_append (fs, "/whatever/dir", "file1", context));

	gp_filesystem_dump (fs);

	printf ("*** Adding /whatever/dir/file2...\n");
	CHECK (gp_filesystem_append (fs, "/whatever/dir", "file2", context));
	CHECK (gp_filesystem_append (fs, "/whatever/dir", "file3", context));
	CHECK (gp_filesystem_append (fs, "/whatever/dir", "file4", context));
	CHECK (gp_filesystem_append (fs, "/whatever/dir", "file5", context));

	gp_filesystem_dump (fs);

	printf ("*** Deleting everything below root...\n");
	CHECK (gp_filesystem_delete_all (fs, "/", context));

	gp_filesystem_dump (fs);

	printf ("*** Appending root directory...\n");
	CHECK (gp_filesystem_append (fs, "/", NULL, context));

	printf ("*** Appending some directories...\n");
	CHECK (gp_filesystem_append (fs, "/whatever", NULL, context));
	CHECK (gp_filesystem_append (fs, "/whatever/directory", NULL, context));

	printf ("*** Adding some files...\n");
	CHECK (gp_filesystem_append (fs, "/whatever/directory",
				     "some.file", context));
	CHECK (gp_filesystem_append (fs, "/whatever/directory",
				     "some.file2", context));
	CHECK (gp_filesystem_append (fs, "/another/directory",
				     "another.file", context));

	gp_filesystem_dump (fs);

	printf ("*** Getting info about a file...\n");
	CHECK (gp_filesystem_get_info (fs, "/whatever/directory", "some.file",
				       &info, context));

	printf ("*** Getting info again (cache!)...\n");
	CHECK (gp_filesystem_get_info (fs, "/whatever/directory", "some.file",
				       &info, context));

	printf ("*** Set info about another file...\n");
	CHECK (gp_filesystem_set_info (fs, "/whatever/directory", "some.file2",
				       info, context));

	printf ("*** Getting info about this file (cache!)...\n");
	CHECK (gp_filesystem_get_info (fs, "/whatever/directory", "some.file2",
				       &info, context));

	printf ("*** Deleting a file...\n");
	CHECK (gp_filesystem_delete_file (fs, "/whatever/directory",
					  "some.file2", context));

	gp_filesystem_dump (fs);

	printf ("*** Resetting the filesystem...\n");
	CHECK (gp_filesystem_reset (fs));

	gp_filesystem_dump (fs);

	printf ("*** Getting file list for folder '/whatever/directory'...\n");
	CHECK (gp_filesystem_list_folders (fs, "/whatever/directory",
					   list, context));

	printf ("*** Getting file list for folder '/whatever/directory' "
		"again (cached!)...\n");
	CHECK (gp_filesystem_list_folders (fs, "/whatever/directory",
					   list, context));

	printf ("*** Counting the contents...\n");
	CHECK (count = gp_list_count (list));

	printf ("*** Listing the contents...\n");
	for (x = 0; x < count; x++) {
		CHECK (gp_list_get_name (list, x, &name));
		printf (" %i: '%s'\n", x, name);
	}

	printf ("*** Getting folder of 'file1'...\n");
	CHECK (gp_filesystem_get_folder (fs, "file1", &foldername, context));
	printf ("... found in '%s'.\n", foldername);
	free(foldername);

	printf ("*** Deleting a couple of files...\n");
	CHECK (gp_filesystem_delete_file (fs, "/whatever", "file5", context));
	CHECK (gp_filesystem_delete_file (fs, "/whatever", "file4", context));
	CHECK (gp_filesystem_delete_file (fs, "/whatever", "file3", context));

	gp_filesystem_dump (fs);

	printf ("*** Freeing file system...\n");
	CHECK (gp_filesystem_free (fs));

	gp_context_unref (context);

	CHECK (gp_list_free(list));

#ifdef HAVE_MCHECK_H
	muntrace();
#endif

	return (0);
}