static int file_list_func (CameraFilesystem *fs, const char *folder, CameraList *list, void *data, GPContext *context) { Camera *camera = data; int i = 0, filecount = 0; char temp_file[14]; if (cam_has_flash(camera->pl) || cam_has_card(camera->pl) ) { CHECK (spca50x_flash_get_TOC(camera->pl, &filecount)); for (i=0; i<filecount; i++) { CHECK(spca50x_flash_get_file_name (camera->pl, i, temp_file)); gp_list_append (list, temp_file, NULL); } } if (cam_has_sdram(camera->pl)) { if (camera->pl->dirty_sdram) CHECK (spca50x_sdram_get_info (camera->pl)); for (i = 0; i < camera->pl->num_files_on_sdram; i++) { strncpy (temp_file, camera->pl->files[i].name, 12); temp_file[12] = 0; gp_list_append (list, temp_file, NULL); } } 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 int n; const char *name; /* * Count the pictures on the camera. If we don't have any, we * are done. */ CR (fuji_pic_count (camera, &n, context)); if (!n) return (GP_OK); /* * Try to get the name of the first file. If we can't, just come * up with some dummy names. */ if (fuji_pic_name (camera, 1, &name, context) < 0) { CR (gp_list_populate (list, "DSCF%04i.JPG", n)); return (GP_OK); } CR (gp_list_append (list, name, NULL)); /* Get the names of the remaining files. */ for (i = 2; i <= n; i++) { CR (fuji_pic_name (camera, i, &name, context)); CR (gp_list_append (list, name, NULL)); } return (GP_OK); }
static int folder_list_func (CameraFilesystem *fs, const char *folder, CameraList *list, void *data, GPContext *context) { int res; int from_card; int folder_nr; Camera *camera = data; char *dc120_folder_card = _("CompactFlash Card"); res = find_folder( camera, folder, &from_card, &folder_nr, context); if( res != (GP_OK) ) { return res; } if( !from_card && folder_nr==0 ) { gp_list_append(list, dc120_folder_card, NULL); return (dc120_get_albums(camera, from_card, list, context)); } else if( from_card && folder_nr==0 ) { return (dc120_get_albums(camera, from_card, list, context)); } else { return (GP_OK); } }
static int getpicsoverview_logitech_pd( Camera *camera, GPContext *context, int *numpics, CameraList *list ) { GPPort *port = camera->port; unsigned char command[0x10]; unsigned char retbuf[0x8000]; int y; int np = 0; char fn[20]; memset(command, 0, 16); command[0] = 0x12; CHECK_RESULT(ultrapocket_command(port, 1, command, 0x10)); CHECK_RESULT(ultrapocket_command(port, 0, retbuf, 0x8000)); np = *(unsigned char*)(retbuf + 0x105); for (y=0;y<np;y++) { memset(fn, 0, 20); memcpy(fn, retbuf+0x106+(y*0x10),11); /* bizzarely, the logitech camera returns a fname with a space * in it, but requires a '.'. Go figure, eh? */ fn[7] = '.'; gp_list_append(list, fn, NULL); } CHECK_RESULT(ultrapocket_command(port, 0, retbuf, 0x8000)); *numpics = np; return GP_OK; }
int lg_gsm_list_files (GPPort *port, CameraList *list) { int num_pics; int i; char oknok[6]; char photonumber[22]; char photolist[142000]; /* max_photos * 142 */ char name[44]; char value[88]; memset (oknok,0,6); memset (photonumber,0,22); memset (photolist,0,142000); memset (name,0,44); memset (value,0,88); GP_DEBUG("Running lg_gsm_list_files\n"); /* set timeout to 3s */ /*port->timeout=20000;*/ /* syncstart */ MSGWRITE(port, 0x13, 0x6, 0x0, "", 0); WRITE(port, sync_start, 6); READ(port, oknok, 6); /* lsphoto : write 0x04000800000040000000ffffffff */ MSGWRITE(port, 0x13, 0xe, 0x0, "", 0); WRITE(port, list_all_photo, 0xe); READ(port, photonumber, 0x16); num_pics=photonumber[20]+256*photonumber[21]; /* increase timeout to 20s */ /*port->timeout=20000;*/ /* read 142 * nb_photos */ READ(port, photolist, 142*num_pics); for (i = 0; i < num_pics; i++){ /* sprintf( name, "lg_gsm_pic%03i.jpg", i ); */ memcpy(name,&photolist[6+142*i],44); memcpy(value,&photolist[50+142*i],80); gp_list_append(list, name, value); } /* restore timeout to 5s */ /*port->timeout=5000; */ /* syncstop */ MSGWRITE(port, 0x13, 0x6, 0x0, "", 0); WRITE(port, sync_stop, 6); READ(port, oknok, 6); /*port->timeout=5000;*/ GP_DEBUG("Number of pics : %03i\n", num_pics); GP_DEBUG("Leaving lg_gsm_list_files\n"); return GP_OK; }
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; }
static int foreach_func (const char *filename, lt_ptr data) { foreach_data_t *fd = data; CameraList *list = fd->list; GP_LOG_D ("Found '%s'.", filename); fd->result = gp_list_append (list, filename, NULL); return ((fd->result == GP_OK)?0:1); }
static int foreach_func (const char *filename, lt_ptr data) { foreach_data_t *fd = data; CameraList *list = fd->list; gp_log (GP_LOG_DEBUG, "gphoto2-abilities-list", "Found '%s'.", filename); fd->result = gp_list_append (list, filename, NULL); return ((fd->result == GP_OK)?0:1); }
static void decode_dir(Camera *camera, struct tf_packet *p, int listdirs, CameraList *list) { unsigned short count = (get_u16(&p->length) - PACKET_HEAD_SIZE) / sizeof(struct typefile); struct typefile *entries = (struct typefile *) p->data; int i; char *name; for(i = 0; i < count; i++) { switch (entries[i].filetype) { case 1: if (listdirs) { if (!strcmp ((char*)entries[i].name, "..")) continue; gp_list_append (list, (char*)entries[i].name, NULL); } break; case 2: if (!listdirs) { name = _convert_and_logname (camera, (char*)entries[i].name); gp_list_append (list, name, NULL); } break; default: break; } #if 0 /* This makes the assumption that the timezone of the Toppy and the system * that puppy runs on are the same. Given the limitations on the length of * USB cables, this condition is likely to be satisfied. */ timestamp = tfdt_to_time(&entries[i].stamp); printf("%c %20llu %24.24s %s\n", type, get_u64(&entries[i].size), ctime(×tamp), entries[i].name); #endif } }
static int file_list_func (CameraFilesystem *fs, const char *folder, CameraList *list, void *data, GPContext *context) { Camera *camera = data; int i, numpics; char tmp[20]; CHECK(enigma13_get_toc(camera,&numpics,&enigma13_static_toc)); for ( i=0; i < numpics; i=i+2 ) { sprintf(tmp,"sunp%04d.jpg",(i/2)); gp_list_append( list, tmp, NULL); } return (GP_OK); }
static int file_list_func (CameraFilesystem *fs, const char *folder, CameraList *list, void *data, GPContext *context) { Camera *camera = data; int num_lo_pics = aox_get_num_lo_pics (camera->pl->info); int num_hi_pics = aox_get_num_hi_pics (camera->pl->info); int n = num_hi_pics + num_lo_pics; char name[30]; int i; /* Low-resolution pictures are always downloaded first. We do not know * yet how to process them, so they will remain in RAW format. */ for (i=0; i< num_lo_pics; i++){ snprintf( name, sizeof(name), "aox_pic%03i.raw", i+1 ); gp_list_append(list, name, NULL); } for (i = num_lo_pics; i < n; i++){ snprintf( name, sizeof(name), "aox_pic%03i.ppm", i+1 ); gp_list_append(list, name, NULL); } return GP_OK; }
static int folder_list_func (CameraFilesystem __unused__ *fs, const char *folder, CameraList *list, void __unused__ *data, GPContext __unused__ *context) { printf ("### -> The camera will list the folders in '%s' here.\n", folder); if (!strcmp (folder, "/")) { gp_list_append (list, "whatever", NULL); gp_list_append (list, "another", NULL); } if (!strcmp (folder, "/whatever")) { gp_list_append (list, "directory", NULL); gp_list_append (list, "dir", NULL); } if (!strcmp (folder, "/whatever/directory")) { gp_list_append (list, "my_special_folder", NULL); } return (GP_OK); }
/** * 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); }
static int file_list_func (CameraFilesystem *fs, const char *folder, CameraList *list, void *data, GPContext *context) { Camera *camera = data; unsigned int n, i; const char *name; CR (ricoh_get_num (camera, context, &n)); for (i = 0; i < n; i++) { CR (ricoh_get_pic_name (camera, context, i + 1, &name)); CR (gp_list_append (list, name, NULL)); } return (GP_OK); }
/* * For most ultrapocket compatibles, call this. */ static int getpicsoverview_generic( Camera *camera, GPContext *context, int *numpics, CameraList *list ) { GPPort **pport = &camera->port; GPPort *port = *pport; unsigned char command[0x10]; unsigned char retbuf[0x1000]; int y; int np = 0; char fn[20]; int picid; int reset_needed; CHECK_RESULT(ultrapocket_sync(camera)); memset(command, 0, 16); command[0] = 0x12; CHECK_RESULT(ultrapocket_command(port, 1, command, 0x10)); CHECK_RESULT(ultrapocket_command(port, 0, retbuf, 0x1000)); np = *(unsigned char*)(retbuf + 0x104); for (y=0;y<np;y++) { picid = retbuf[0x106+y*2] + (retbuf[0x107+y*2] << 8); sprintf(fn, "IMG%4.4d.PPM",picid); gp_list_append(list, fn, NULL); } reset_needed = (*(retbuf + 2) & UP_FLAG_NEEDS_RESET); ultrapocket_skip(port, 7); #if 0 CHECK_RESULT(ultrapocket_sync(camera)); #endif if (reset_needed) { CHECK_RESULT(ultrapocket_reset(camera)); port = *pport; } #if 0 CHECK_RESULT(ultrapocket_sync(camera)); #endif *numpics = np; return GP_OK; }
static int file_list_func (CameraFilesystem *fs, const char *folder, CameraList *list, void *data, GPContext *context) { Camera *camera = data; int i, ret; for (i = 0; i < ST2205_MAX_NO_FILES; i++) { if (camera->pl->filenames[i][0]) { ret = gp_list_append (list, camera->pl->filenames[i], NULL); if (ret < 0) return ret; } } 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; }
static int file_list_func (CameraFilesystem *fs, const char *folder, CameraList *list, void *data, GPContext *context) { Camera *camera = data; int i; char temp_file[14]; if (camera->pl->dirty) CHECK (gsmart300_get_info (camera->pl)); for (i = 0; i < camera->pl->num_files; i++) { strncpy (temp_file, camera->pl->files[i].name, 12); temp_file[12] = 0; gp_list_append (list, temp_file, NULL); } return GP_OK; }
static int file_list_func (CameraFilesystem *fs, const char *folder, CameraList *list, void *data, GPContext *context) { Camera *camera=data; int i; char temp_file[14]; GP_DEBUG ("camera_file_list %s\n", folder); if (soundvision_get_file_list(camera->pl) < 0) { GP_DEBUG ("Could not soundvision_file_list!"); return GP_ERROR; } for(i=0; i < camera->pl->num_pictures; i++) { strncpy(temp_file,camera->pl->file_list+(13*i),12); temp_file[12]=0; gp_list_append (list, temp_file, NULL); } return GP_OK; }
static int file_list_func (CameraFilesystem *fs, const char *folder, CameraList *list, void *data, GPContext *context) { unsigned char buffer[SDSC_INFOSIZE]; Camera *camera = data; /* Rewind */ CHECK_RESULT (SDSC_initialize (camera->port)); /* Count the pictures */ while (1) { CHECK_RESULT (SDSC_send (camera->port, SDSC_NEXT)); CHECK_RESULT (SDSC_send (camera->port, SDSC_START)); CHECK_RESULT (SDSC_receive (camera->port, buffer, SDSC_INFOSIZE)); if (is_null (buffer)) break; gp_list_append(list, buffer, NULL); } return (GP_OK); }
static void _get_widget_names (CameraWidget *widget, CameraList *list) { CameraWidgetType type; gp_widget_get_type (widget, &type); switch (type) { case GP_WIDGET_MENU: case GP_WIDGET_RADIO: case GP_WIDGET_TEXT: case GP_WIDGET_RANGE: case GP_WIDGET_TOGGLE: case GP_WIDGET_DATE: { const char *name; gp_widget_get_name (widget, &name); gp_list_append (list, name, NULL); break; } case GP_WIDGET_SECTION: case GP_WIDGET_WINDOW: { int i, nrofchildren; nrofchildren = gp_widget_count_children (widget); for (i = 0; i < nrofchildren; i++) { CameraWidget *child; gp_widget_get_child (widget, i, &child); _get_widget_names (child, list); } break; } case GP_WIDGET_BUTTON: default: break; } }
static int file_list_func (CameraFilesystem __unused__ *fs, const char *folder, CameraList *list, void __unused__ *data, GPContext __unused__ *context) { printf ("### -> The camera will list the files in '%s' here.\n", folder); if (!strcmp (folder, "/whatever")) { gp_list_append (list, "file1", NULL); gp_list_append (list, "file2", NULL); gp_list_append (list, "file3", NULL); gp_list_append (list, "file4", NULL); gp_list_append (list, "file5", NULL); gp_list_append (list, "file6", NULL); } return (GP_OK); }
int pdrm11_get_filenames(GPPort *port, CameraList *list) { int i, j; uint32_t numPics; char name[20]; char buf[30]; gp_port_set_timeout(port, 10000); CHECK(gp_port_usb_msg_read(port, 0x01, PDRM11_CMD_GET_NUMPICS, 0, buf, 10)); /* trying to remain endian friendly */ numPics = le16atoh(&buf[2]) + (le16atoh(&buf[0]) * 1024); GP_DEBUG("found %d pictures", numPics); for(i=1; i<numPics+1; i++) { CHECK( pdrm11_select_file(port, i) ); CHECK(gp_port_usb_msg_read(port, 0x01, 0xe600, i, buf, 14)); /* the filename is 12 chars starting at the third byte */ CHECK(gp_port_usb_msg_read(port, 0x01, PDRM11_CMD_GET_FILENAME, i, buf, 26)); for(j=0; j<12; j+=2) { name[j] = buf[j+2+1]; name[j+1] = buf[j+2]; } name[12] = '\0'; GP_DEBUG("%s",name); gp_list_append(list, name, NULL); } return(GP_OK); }
static int file_list_func (CameraFilesystem *fs, const char *folder, CameraList *list, void *data, GPContext *context) { Camera *camera = data; int mpeg, rc = GP_OK; GP_DEBUG("camera_folder_list_files()"); for (mpeg = 0; mpeg <= 1 && rc == GP_OK; mpeg++) { int i, count; SonyFileType file_type; file_type = mpeg ? SONY_FILE_MPEG : SONY_FILE_IMAGE; rc = sony_file_count(camera, file_type, &count); if (rc != GP_OK) { break; } for (i = 1; i <= count; i++) { char buf[13]; rc = sony_file_name_get(camera, i, file_type, buf); if (rc != GP_OK) { break; } gp_list_append(list, buf, NULL); if (gp_context_cancel(context) == GP_CONTEXT_FEEDBACK_CANCEL) { rc = GP_ERROR_CANCEL; } } } return rc; }
static int file_list_func (CameraFilesystem *fs, const char *folder, CameraList *list, void *data, GPContext *context) { Camera *camera = data; int num = 0; int width; int year; int size; uint8_t month; uint8_t day; uint8_t hour; uint8_t minute; uint8_t byte1; uint8_t byte2; uint8_t byte3; char *filename; GP_DEBUG ("Camera List Files"); if (l859_sendcmd(camera, 0xa0) != GP_OK) return GP_ERROR; if (l859_retrcmd(camera) == GP_ERROR) return GP_ERROR; if (l859_sendcmd(camera, 0xb0) != GP_OK) return GP_ERROR; if (l859_retrcmd(camera) == GP_ERROR) return GP_ERROR; if (l859_sendcmd(camera, 0xc0) != GP_OK) return GP_ERROR; if (l859_retrcmd(camera) == GP_ERROR) return GP_ERROR; if (l859_sendcmd(camera, L859_CMD_PREVIEW) != GP_OK) return GP_ERROR; if (l859_retrcmd(camera) == GP_ERROR) return GP_ERROR; while (camera->pl->buf[13] == num) { byte1 = camera->pl->buf[8]; byte2 = camera->pl->buf[9]; width = (byte1 * 256) + byte2; byte1 = camera->pl->buf[22]; year = byte1 + 1900; month = camera->pl->buf[23]; day = camera->pl->buf[24]; hour = camera->pl->buf[25]; minute = camera->pl->buf[26]; byte1 = camera->pl->buf[5]; byte2 = camera->pl->buf[6]; byte3 = camera->pl->buf[7]; size = (byte1 * 256 * 256) + (byte2 * 256) + byte3; /* Check for no images */ if (size == 0) return GP_OK; if (!(filename = (char*)malloc(30))) { GP_DEBUG ("Unable to allocate memory for filename."); return GP_ERROR_NO_MEMORY; } sprintf(filename, "%.4i%s%i-%i-%i(%i-%i).jpg", num + 1, width == 640 ? "F" : "N", year, month, day, hour, minute); GP_DEBUG ("Filename: %s.", filename); gp_list_append (list, filename, NULL); /* GP_DEBUG ("Num %i Filename %s", num, filename); */ free (filename); num = num + 1; if (l859_sendcmd(camera, L859_CMD_PREVIEW_NEXT) != GP_OK) return GP_ERROR; if (l859_retrcmd(camera) == GP_ERROR) return GP_ERROR; } GP_DEBUG ("Camera List Files Done"); 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); }
static int file_list_func (CameraFilesystem *fs, const char *folder, CameraList *list, void *user_data, GPContext *context) { Camera *camera = user_data; unsigned char *data = NULL; long unsigned data_len = 0; unsigned char *ptr_data_buff; char filename[13]; int res, i; if(camera->pl->context) { gp_context_error(context, CONTEXT_EXISTS); return GP_ERROR; } if(check_last_use(camera) == GP_ERROR) { return GP_ERROR; } /* get file list data */ res = dc3200_get_data (camera, &data, &data_len, CMD_LIST_FILES, folder, NULL); if (res == GP_ERROR) { return GP_ERROR; } /* check the data length */ if(data_len%20 != 0 || data_len < 1) { return GP_ERROR; } if(data == NULL) { return GP_ERROR; } /* add files to the list */ ptr_data_buff = data; i = 0; while(i < data_len) { /* files don't have 0x10 in their attribute */ if(ptr_data_buff[11] & 0x10) { ptr_data_buff += 20; i += 20; continue; } /* copy the first 8 bytes of filename */ strncpy(filename, (char *)ptr_data_buff, 8); filename[8] = 0; /* add dot */ strcat(filename, "."); /* copy extension, last 3 bytes*/ strncat(filename, (char *)ptr_data_buff+8, 3); if(!strstr(filename, ".JPG") && !strstr(filename, ".jpg")) { ptr_data_buff += 20; i += 20; continue; } /* append file to the list */ gp_list_append(list, filename, NULL); ptr_data_buff += 20; i += 20; } free(data); return (dc3200_keep_alive(camera)); }
static int folder_list_func (CameraFilesystem *fs, const char *folder, CameraList *list, void *user_data, GPContext *context) { Camera *camera = user_data; unsigned char *data = NULL; long unsigned data_len = 0; unsigned char *ptr_data_buff; char filename[13], *ptr; int res, i; if(camera->pl->context) { gp_context_error(context, CONTEXT_EXISTS); return GP_ERROR; } if(check_last_use(camera) == GP_ERROR) { return GP_ERROR; } /* get file list data */ res = dc3200_get_data (camera, &data, &data_len, CMD_LIST_FILES, folder, NULL); if (res == GP_ERROR) { return GP_ERROR; } /* check the data length, each record is 20 bytes */ if(data_len%20 != 0 || data_len < 1) { return GP_ERROR; } if (data == NULL) { return GP_ERROR; } /* add directories to the list */ ptr_data_buff = data; i = 0; while(i < data_len) { /* directories have 0x10 in their attribute */ if(!(ptr_data_buff[11] & 0x10)) { ptr_data_buff += 20; i += 20; continue; } /* skip directories starting with . */ if(ptr_data_buff[0] == '.') { ptr_data_buff += 20; i += 20; continue; } /* copy the filename */ strncpy(filename, (char *)ptr_data_buff, sizeof(filename)); /* chop off the trailing spaces and null terminate */ ptr = strchr(filename, 0x20); if(ptr) ptr[0] = 0; /* in case of long directory */ filename[12] = 0; /* append dir to the list */ gp_list_append(list, filename, NULL); ptr_data_buff += 20; i += 20; } free (data); return (dc3200_keep_alive (camera)); }
/** * \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); }