/*
* Only need to reset the generic camera type, AFAICT -
* the pocket digital never seems to need it.
*/
static int
ultrapocket_reset(Camera *camera)
{
GPPortInfo oldpi;
GPPort *port = camera->port;
CameraAbilities cab;
unsigned char cmdbuf[0x10];
gp_camera_get_abilities(camera, &cab);
GP_DEBUG ("First connect since camera was used - need to reset cam");
/*
* this resets the ultrapocket. Messy, but it's what the windows
* software does. We only reset if it's been plugged in since
* last reset.
*/
memset(cmdbuf, 0, 16);
cmdbuf[0] = 0x28;
cmdbuf[1] = 0x01;
CHECK_RESULT(ultrapocket_command(port, 1, cmdbuf, 0x10));
/* -------------- */
sleep(4); /* This should do - _might_ need increasing */
CHECK_RESULT(gp_port_get_info(port, &oldpi));
CHECK_RESULT(gp_port_free(port));
CHECK_RESULT(gp_port_new(&port));
CHECK_RESULT(gp_port_set_info(port, oldpi));
CHECK_RESULT(gp_port_usb_find_device(port,
cab.usb_vendor, cab.usb_product));
CHECK_RESULT(gp_port_open(port));
camera->port = port;
return GP_OK;
}
int
gp_camera_get_port_info (Camera *camera, GPPortInfo *info)
{
CHECK_NULL (camera && info);
CR (camera, gp_port_get_info (camera->port, info), NULL);
return (GP_OK);
}
static int
gp_port_serial_open (GPPort *dev)
{
int result, max_tries = 5, i;
#ifdef OS2
int fd;
#endif
char *port;
GPPortInfo info;
result = gp_port_get_info (dev, &info);
if (result < GP_OK) return result;
result = gp_port_info_get_path (info, &port);
if (result < GP_OK) return result;
gp_log (GP_LOG_DEBUG, "gp_port_serial_open", "opening %s", port);
/* Ports are named "serial:/dev/whatever/port" */
port = strchr (port, ':');
if (!port)
return GP_ERROR_UNKNOWN_PORT;
port++;
result = gp_port_serial_lock (dev, port);
if (result != GP_OK) {
for (i = 0; i < max_tries; i++) {
result = gp_port_serial_lock (dev, port);
if (result == GP_OK)
break;
gp_log (GP_LOG_DEBUG, "gphoto2-port-serial",
"Failed to get a lock, trying again...");
sleep (1);
}
CHECK (result);
}
dev->pl->fd = -1;
#if defined(__FreeBSD__) || defined(__APPLE__) || defined(__DragonFly__)
dev->pl->fd = open (port, O_RDWR | O_NOCTTY | O_NONBLOCK);
#elif OS2
fd = open (port, O_RDWR | O_BINARY);
dev->pl->fd = open (port, O_RDWR | O_BINARY);
close(fd);
#else
if (dev->pl->fd == -1)
dev->pl->fd = open (port, O_RDWR | O_NOCTTY | O_SYNC | O_NONBLOCK);
#endif
if (dev->pl->fd == -1) {
int saved_errno = errno;
gp_port_set_error (dev, _("Failed to open '%s' (%s)."),
port, strerror(saved_errno));
dev->pl->fd = 0;
return GP_ERROR_IO;
}
return GP_OK;
}
static int
storage_info_func (CameraFilesystem *fs,
CameraStorageInformation **sinfos,
int *nrofsinfos,
void *data, GPContext *context
) {
Camera *camera = data;
CameraStorageInformation *sfs;
#if defined(linux) && defined(HAVE_STATFS)
struct statfs stfs;
char *xpath;
int ret;
GPPortInfo info;
ret = gp_port_get_info (camera->port, &info);
if (ret < GP_OK)
return ret;
xpath = strchr (info.path,':');
if (!xpath) xpath = info.path; else xpath++;
if (-1 == statfs (xpath, &stfs))
return GP_ERROR_NOT_SUPPORTED;
sfs = malloc (sizeof (CameraStorageInformation));
if (!sfs)
return GP_ERROR_NO_MEMORY;
*sinfos = sfs;
*nrofsinfos = 1;
sfs->fields = GP_STORAGEINFO_BASE |
GP_STORAGEINFO_DESCRIPTION |
GP_STORAGEINFO_STORAGETYPE |
GP_STORAGEINFO_FILESYSTEMTYPE |
GP_STORAGEINFO_ACCESS |
GP_STORAGEINFO_MAXCAPACITY |
GP_STORAGEINFO_FREESPACEKBYTES;
;
strcpy (sfs->basedir, "/");
strcpy (sfs->description, "Directory Driver");
sfs->type = GP_STORAGEINFO_ST_REMOVABLE_RAM;
sfs->fstype = GP_STORAGEINFO_FST_GENERICHIERARCHICAL;
sfs->access = GP_STORAGEINFO_AC_READWRITE;
if (stfs.f_bsize >= 1024) {
sfs->capacitykbytes = stfs.f_blocks*(stfs.f_bsize/1024);
sfs->freekbytes = stfs.f_bavail*(stfs.f_bsize/1024);
} else {
sfs->capacitykbytes = stfs.f_blocks/(1024/stfs.f_bsize);
sfs->freekbytes = stfs.f_bavail/(1024/stfs.f_bsize);
}
return GP_OK;
#endif
return GP_ERROR_NOT_SUPPORTED;
}
static int
_get_path (GPPort *port, const char *folder, const char *file, char *path, unsigned int size) {
if (port->type == GP_PORT_DISK) {
GPPortInfo info;
int ret;
char *xpath;
ret = gp_port_get_info (port, &info);
if (ret < GP_OK)
return ret;
xpath = strchr (info.path,':');
if (!xpath) xpath = info.path; else xpath++;
snprintf (path, size, "%s/%s/%s", xpath, folder, file);
} else {
/* old style access */
snprintf (path, size, "%s/%s", folder, file);
}
return GP_OK;
}
static int
folder_list_func (CameraFilesystem *fs, const char *folder, CameraList *list,
void *data, GPContext *context)
{
gp_system_dir dir;
gp_system_dirent de;
char buf[1024], f[1024];
unsigned int id, n;
struct stat st;
Camera *camera = (Camera*)data;
if (camera->port->type == GP_PORT_DISK) {
char *path;
GPPortInfo info;
int ret;
ret = gp_port_get_info (camera->port, &info);
if (ret < GP_OK)
return ret;
path = strchr (info.path,':');
if (!path) path = info.path; else path++;
snprintf (f, sizeof(f), "%s/%s/", path, folder);
gp_log (GP_LOG_DEBUG, "directory/folder_list_func", "%s", f);
/* UNIX / is empty, or we recurse through the whole fs */
if ( (!strcmp(path, "") || !strcmp(path, "/")) &&
!strcmp(folder,"/")
)
return GP_OK;
} else {
/* old style access */
/* Make sure we have 1 delimiter */
if (folder[strlen(folder)-1] != '/') {
snprintf (f, sizeof(f), "%s%c", folder, '/');
} else {
strncpy (f, folder, sizeof(f));
}
}
dir = gp_system_opendir ((char*) f);
if (!dir)
return GP_ERROR;
/* Count the files */
n = 0;
while (gp_system_readdir (dir))
n++;
gp_system_closedir (dir);
dir = gp_system_opendir (f);
if (!dir)
return GP_ERROR;
id = gp_context_progress_start (context, n, _("Listing folders in '%s'..."), folder);
n = 0;
while ((de = gp_system_readdir (dir))) {
const char * filename = NULL;
/* Give some feedback */
gp_context_progress_update (context, id, n + 1);
gp_context_idle (context);
if (gp_context_cancel (context) == GP_CONTEXT_FEEDBACK_CANCEL) {
gp_system_closedir (dir);
return GP_ERROR_CANCEL;
}
filename = gp_system_filename (de);
if (*filename != '.') {
snprintf (buf, sizeof(buf), "%s%s", f, filename);
/* lstat ... do not follow symlinks */
if (lstat (buf, &st) != 0) {
gp_context_error (context, _("Could not get information about '%s' (%m)."), buf);
return GP_ERROR;
}
if (S_ISDIR (st.st_mode)) {
gp_list_append(list, filename, NULL);
}
}
n++;
}
gp_system_closedir (dir);
gp_context_progress_stop (context, id);
return (GP_OK);
}
/**
* 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);
}