static int get_file_func (CameraFilesystem *fs, const char *folder, const char *filename, CameraFileType type, CameraFile *file, void *user_data, GPContext *context) { Camera *camera = user_data; int image_no, result; image_no = gp_filesystem_number(camera->fs, folder, filename, context); if(image_no < 0) return image_no; gp_file_set_name (file, filename); gp_file_set_mime_type (file, GP_MIME_PNM); switch (type) { case GP_FILE_TYPE_NORMAL: result = stv0680_get_image (camera->port, image_no, file); break; case GP_FILE_TYPE_RAW: result = stv0680_get_image_raw (camera->port, image_no, file); break; case GP_FILE_TYPE_PREVIEW: result = stv0680_get_image_preview (camera->port, image_no, file); break; default: return (GP_ERROR_NOT_SUPPORTED); } return result; }
/** * Captures a preview that won't be stored on the camera but returned in * supplied file. * * @param camera a #Camera * @param file a #CameraFile * @param context a #GPContext * @return a gphoto2 error code * * For example, you could use gp_capture_preview() for taking some sample * pictures before calling gp_capture(). * **/ int gp_camera_capture_preview (Camera *camera, CameraFile *file, GPContext *context) { char *xname; C_PARAMS (camera && file); CHECK_INIT (camera, context); CR (camera, gp_file_clean (file), context); if (!camera->functions->capture_preview) { gp_context_error (context, _("This camera can " "not capture previews.")); CAMERA_UNUSED (camera, context); return (GP_ERROR_NOT_SUPPORTED); } CHECK_RESULT_OPEN_CLOSE (camera, camera->functions->capture_preview ( camera, file, context), context); gp_file_get_name_by_type (file, "capture_preview", GP_FILE_TYPE_NORMAL, &xname); /* FIXME: Marcus ... will go away, just keep compatible now. */ gp_file_set_name (file, xname); free (xname); CAMERA_UNUSED (camera, context); return (GP_OK); }
static int get_file_func (CameraFilesystem *fs, const char *folder, const char *filename, CameraFileType type, CameraFile *file, void *user_data, GPContext *context) { Camera *camera = user_data; int number, filetype; CHECK (number = gp_filesystem_number (camera->fs, folder, filename, context)); switch (type) { case GP_FILE_TYPE_NORMAL: CHECK (gsmart300_request_file (camera->pl, file, number)); break; case GP_FILE_TYPE_PREVIEW: CHECK (gsmart300_request_thumbnail (camera->pl, file, number, &filetype)); if (filetype == GSMART_FILE_TYPE_IMAGE) { CHECK (gp_file_set_mime_type (file, GP_MIME_BMP)); } break; default: return GP_ERROR_NOT_SUPPORTED; } CHECK (gp_file_set_name (file, filename)); return GP_OK; }
char gpi_jpeg_write(CameraFile *file, const char *filename, jpeg *myjpeg) { int x; CHECK_RESULT (gp_file_set_name (file, filename)); CHECK_RESULT (gp_file_set_mime_type(file, GP_MIME_JPEG)); for (x=0; x<myjpeg->count; x++) CHECK_RESULT (gp_file_append(file, (char*)myjpeg->marker[x]->data, myjpeg->marker[x]->size)); return 1; }
static int camera_capture (Camera* camera, CameraCaptureType type, CameraFilePath* path, GPContext *context) { int r; CameraFile *file = NULL; CameraFileInfo info; KncCamRes cr; KncCntrlRes cntrl_res; KncImageInfo i; C_NULL (camera && path); /* We only support capturing of images */ if (type != GP_CAPTURE_IMAGE) return (GP_ERROR_NOT_SUPPORTED); /* Stop the timeout, take the picture, and restart the timeout. */ gp_camera_stop_timeout (camera, camera->pl->timeout); gp_file_new (&file); knc_cntrl_set_func_data (camera->pl->c, data_func, file); cntrl_res = knc_take_picture (camera->pl->c, &cr, KNC_SOURCE_CARD, &i); camera->pl->timeout = gp_camera_start_timeout (camera, PING_TIMEOUT, timeout_func); if (cntrl_res) gp_file_unref (file); CR (cntrl_res, context); sprintf (path->name, "%06i.jpeg", (int) i.id); strcpy (path->folder, "/"); r = gp_filesystem_append (camera->fs, path->folder, path->name, context); if (r < 0) { gp_file_unref (file); return r; } info.preview.fields = GP_FILE_INFO_SIZE | GP_FILE_INFO_TYPE; gp_file_get_data_and_size (file, NULL, &info.preview.size); strcpy (info.preview.type, GP_MIME_JPEG); info.file.fields = GP_FILE_INFO_SIZE | GP_FILE_INFO_PERMISSIONS | GP_FILE_INFO_TYPE | GP_FILE_INFO_NAME; info.file.size = i.size; info.file.permissions = GP_FILE_PERM_READ; if (!i.prot) info.file.permissions |= GP_FILE_PERM_DELETE; strcpy (info.file.type, GP_MIME_JPEG); snprintf (info.file.name, sizeof (info.file.name), "%06i.jpeg", (int) i.id); gp_filesystem_set_info_noop (camera->fs, path->folder, info, context); gp_file_set_name (file, info.file.name); gp_file_set_mime_type (file, GP_MIME_JPEG); gp_file_set_type (file, GP_FILE_TYPE_EXIF); gp_filesystem_set_file_noop (camera->fs, path->folder, file, context); gp_file_unref (file); return (GP_OK); }
static int get_file_func (CameraFilesystem *fs, const char *folder, const char *filename, CameraFileType type, CameraFile *file, void *data, GPContext *context) { Camera *camera = data; int file_number=0, result; char buffer[128]; file_number = gp_filesystem_number(fs, folder, filename, context); if (file_number < 0) return (file_number); switch (type) { case GP_FILE_TYPE_NORMAL: gp_file_set_mime_type (file, GP_MIME_JPEG); gp_file_set_name (file, filename); result = dimagev_get_picture (camera->pl, file_number + 1, file); break; case GP_FILE_TYPE_PREVIEW: gp_file_set_mime_type (file, GP_MIME_PPM); #if defined HAVE_SNPRINTF snprintf(buffer, sizeof(buffer), DIMAGEV_THUMBNAIL_FMT, ( file_number + 1) ); #else sprintf(buffer, DIMAGEV_THUMBNAIL_FMT, ( file_number + 1) ); #endif gp_file_set_name (file, buffer); result = dimagev_get_thumbnail (camera->pl, file_number + 1, file); break; default: return (GP_ERROR_NOT_SUPPORTED); } if (result < 0) { GP_DEBUG( "camera_file_get::unable to retrieve image file"); return result; } sleep(2); return GP_OK; }
static int camera_capture_preview (Camera *camera, CameraFile *file, GPContext *context) { char *data; int size, result; result = stv0680_capture_preview (camera->port, &data, &size); if (result < 0) return result; gp_file_set_name (file, "capture.pnm"); gp_file_set_mime_type (file, GP_MIME_PNM); gp_file_set_data_and_size (file, data, size); return (GP_OK); }
static int get_info (Camera *camera, unsigned int n, CameraFileInfo *info, CameraFile *file, GPContext *context) { unsigned char *buffer = NULL; KncCamRes cr; KncCntrlRes cntrl_res; KncImageInfo i; /* * Remove the timeout, get the information and restart the * timeout afterwards. */ gp_camera_stop_timeout (camera, camera->pl->timeout); knc_cntrl_set_func_data (camera->pl->c, data_func, file); cntrl_res = knc_get_image_info (camera->pl->c, &cr, n, &i); camera->pl->timeout = gp_camera_start_timeout (camera, PING_TIMEOUT, timeout_func); CR (cntrl_res, context); info->audio.fields = GP_FILE_INFO_NONE; info->preview.fields = GP_FILE_INFO_TYPE; strcpy (info->preview.type, GP_MIME_JPEG); info->file.fields = GP_FILE_INFO_SIZE | GP_FILE_INFO_PERMISSIONS | GP_FILE_INFO_TYPE | GP_FILE_INFO_NAME; info->file.size = i.size * 1000; info->file.permissions = GP_FILE_PERM_READ; if (!i.prot) info->file.permissions |= GP_FILE_PERM_DELETE; strcpy (info->file.type, GP_MIME_JPEG); snprintf (info->file.name, sizeof (info->file.name), "%06i.jpeg", (int) i.id); if (file) { gp_file_set_type (file, GP_FILE_TYPE_EXIF); gp_file_set_name (file, info->file.name); } else free (buffer); return (GP_OK); }
static int get_file_func (CameraFilesystem *fs, const char *folder, const char *filename, CameraFileType type, CameraFile *file, void *user_data, GPContext *context) { Camera *camera = user_data; unsigned char *data = NULL; int size,ret,index; size = 0; index = gp_filesystem_number(fs, folder, filename, context); if (index < 0) return index; switch(type) { case GP_FILE_TYPE_NORMAL: ret=camera_get_file(camera, context, index, &data, &size); break; default: return GP_ERROR_NOT_SUPPORTED; } gp_file_set_data_and_size(file, data, size); gp_file_set_name (file, filename); return GP_OK; }
static int get_file_func (CameraFilesystem *fs, const char *folder, const char *filename, CameraFileType type, CameraFile *file, void *data, GPContext *context) { Camera *camera = data; int idx, size; #ifdef HAVE_GD int ret; gdImagePtr im, rotated; void *gdpng; #endif idx = get_file_idx(camera->pl, folder, filename); if (idx < 0) return idx; if (type == GP_FILE_TYPE_RAW) { unsigned char *raw; size = st2205_read_raw_file (camera, idx, &raw); if (size < 0) return size; gp_file_set_mime_type (file, GP_MIME_RAW); gp_file_set_name (file, filename); gp_file_set_data_and_size (file, (char *)raw, size); return GP_OK; } #ifdef HAVE_GD if (type != GP_FILE_TYPE_NORMAL) return GP_ERROR_NOT_SUPPORTED; im = gdImageCreateTrueColor(camera->pl->width, camera->pl->height); if (im == NULL) return GP_ERROR_NO_MEMORY; ret = st2205_read_file(camera, idx, im->tpixels); if (ret < 0) { gdImageDestroy (im); return ret; } if (needs_rotation (camera)) { rotated = gdImageCreateTrueColor (im->sy, im->sx); if (rotated == NULL) { gdImageDestroy (im); return GP_ERROR_NO_MEMORY; } rotate270 (im, rotated); gdImageDestroy (im); im = rotated; } gdpng = gdImagePngPtr(im, &size); gdImageDestroy (im); if (gdpng == NULL) return GP_ERROR_NO_MEMORY; ret = gp_file_set_mime_type (file, GP_MIME_PNG); if (ret < 0) { gdFree (gdpng); return ret; } ret = gp_file_set_name (file, filename); if (ret < 0) { gdFree (gdpng); return ret; } ret = gp_file_append (file, gdpng, size); gdFree (gdpng); return ret; #else gp_log(GP_LOG_ERROR,"st2205", "GD decompression not supported - no libGD present during build"); return GP_ERROR_NOT_SUPPORTED; #endif }
static int get_file_func (CameraFilesystem *fs, const char *folder, const char *filename, CameraFileType type, CameraFile *file, void *user_data, GPContext *context) { Camera *camera = user_data; int status = GP_OK; int w, h = 0, k; int i,j; int b = 0; int compressed = 0; unsigned char header[5] = "\xff\xff\xff\xff\x55"; unsigned int size; unsigned char *data; unsigned char *image_start; unsigned char *p_data=NULL; unsigned char *ppm=NULL, *ptr=NULL; unsigned char gtable[256]; unsigned char temp; GP_DEBUG ("Downloading pictures!\n"); /* These are cheap cameras. There ain't no EXIF data. So kill this. */ if (GP_FILE_TYPE_EXIF == type) return GP_ERROR_FILE_EXISTS; /* Get the number of the photo on the camera */ k = gp_filesystem_number (camera->fs, "/", filename, context); GP_DEBUG ("Filesystem number is %i\n",k); b = jl2005a_get_pic_data_size(camera->port, k); GP_DEBUG("b = %i = 0x%x bytes\n", b,b); w = jl2005a_get_pic_width(camera->port); GP_DEBUG ("width is %i\n", w); h = jl2005a_get_pic_height(camera->port); GP_DEBUG ("height is %i\n", h); /* Image data to be downloaded contains header and footer bytes */ data = malloc (b+14); if (!data) return GP_ERROR_NO_MEMORY; jl2005a_read_picture_data (camera, camera->port, data, b+14); if (memcmp(header,data,5) != 0) /* Image data is corrupted! Repeat the operation. */ jl2005a_read_picture_data (camera, camera->port, data, b+14); if (GP_FILE_TYPE_RAW == type) { gp_file_set_mime_type(file, GP_MIME_RAW); gp_file_set_name(file, filename); gp_file_set_data_and_size(file, (char *)data , b+14 ); return GP_OK; } /* Now get ready to put the data into a PPM image file. */ p_data = malloc( w*h ); if (!p_data) { status = GP_ERROR_NO_MEMORY; goto end; } image_start=data+5; if (w == 176) { for (i=1; i < h; i +=4){ for (j=1; j< w; j ++){ temp=image_start[i*w+j]; image_start[i*w+j] = image_start[(i+1)*w+j]; image_start[(i+1)*w+j] = temp; } } if (h == 72) { compressed = 1; h = 144; } } else if (h == 144) { compressed = 1; h = 288; } p_data = malloc( w*h ); if (!p_data) { status = GP_ERROR_NO_MEMORY; goto end; } if (compressed) jl2005a_decompress (image_start, p_data, w, h); else memcpy(p_data, image_start, w*h); ppm = malloc (w * h * 3 + 256); /* room for data and header */ if (!ppm) { status = GP_ERROR_NO_MEMORY; goto end; } sprintf ((char *)ppm, "P6\n" "# CREATOR: gphoto2, JL2005A library\n" "%d %d\n" "255\n", w, h); size = strlen ((char *)ppm); ptr = ppm + size; size = size + (w * h * 3); GP_DEBUG ("size = %i\n", size); gp_ahd_decode (p_data, w , h, ptr, BAYER_TILE_BGGR); free(p_data); gp_gamma_fill_table (gtable, .65); gp_gamma_correct_single (gtable, ptr, w * h); gp_file_set_mime_type (file, GP_MIME_PPM); gp_file_set_name (file, filename); gp_file_set_data_and_size (file, (char *)ppm, size); end: free(data); return status; return GP_OK; }
bool GPCamera::uploadItem(const QString& folder, const QString& itemName, const QString& localFile, CamItemInfo& itemInfo) { #ifdef HAVE_GPHOTO2 int errorCode; CameraFile* cfile = 0; errorCode = gp_file_new(&cfile); d->status->cancel = false; if (errorCode != GP_OK) { qCDebug(DIGIKAM_IMPORTUI_LOG) << "Failed to init new camera file instance!"; printGphotoErrorDescription(errorCode); return false; } errorCode = gp_file_open(cfile, QFile::encodeName(localFile).constData()); if (errorCode != GP_OK) { qCDebug(DIGIKAM_IMPORTUI_LOG) << "Failed to open file!"; printGphotoErrorDescription(errorCode); gp_file_unref(cfile); return false; } errorCode = gp_file_set_name(cfile, QFile::encodeName(itemName).constData()); if (errorCode != GP_OK) { qCDebug(DIGIKAM_IMPORTUI_LOG) << "Failed to rename item from camera!"; printGphotoErrorDescription(errorCode); gp_file_unref(cfile); return false; } #ifdef HAVE_GPHOTO25 errorCode = gp_camera_folder_put_file(d->camera, QFile::encodeName(folder).constData(), QFile::encodeName(itemName).constData(), GP_FILE_TYPE_NORMAL, cfile, d->status->context); #else errorCode = gp_camera_folder_put_file(d->camera, QFile::encodeName(folder).constData(), cfile, d->status->context); #endif if (errorCode != GP_OK) { qCDebug(DIGIKAM_IMPORTUI_LOG) << "Failed to upload item to camera!"; printGphotoErrorDescription(errorCode); gp_file_unref(cfile); return false; } // Get new camera item information. itemInfo.name = itemName; itemInfo.folder = folder; CameraFileInfo info; errorCode = gp_camera_file_get_info(d->camera, QFile::encodeName(folder).constData(), QFile::encodeName(itemName).constData(), &info, d->status->context); if (errorCode != GP_OK) { qCDebug(DIGIKAM_IMPORTUI_LOG) << "Failed to get camera item information!"; printGphotoErrorDescription(errorCode); gp_file_unref(cfile); return false; } itemInfo.ctime = QDateTime(); itemInfo.mime = QString(); itemInfo.size = -1; itemInfo.width = -1; itemInfo.height = -1; itemInfo.downloaded = CamItemInfo::DownloadUnknown; itemInfo.readPermissions = -1; itemInfo.writePermissions = -1; /* The mime type returned by Gphoto2 is dummy with all RAW files. if (info.file.fields & GP_FILE_INFO_TYPE) itemInfo.mime = info.file.type; */ itemInfo.mime = mimeType(itemInfo.name.section(QLatin1Char('.'), -1).toLower()); if (info.file.fields & GP_FILE_INFO_MTIME) { itemInfo.ctime = QDateTime::fromTime_t(info.file.mtime); } if (info.file.fields & GP_FILE_INFO_SIZE) { itemInfo.size = info.file.size; } if (info.file.fields & GP_FILE_INFO_WIDTH) { itemInfo.width = info.file.width; } if (info.file.fields & GP_FILE_INFO_HEIGHT) { itemInfo.height = info.file.height; } if (info.file.fields & GP_FILE_INFO_STATUS) { if (info.file.status == GP_FILE_STATUS_DOWNLOADED) { itemInfo.downloaded = CamItemInfo::DownloadedYes; } else { itemInfo.downloaded = CamItemInfo::DownloadedNo; } } if (info.file.fields & GP_FILE_INFO_PERMISSIONS) { if (info.file.permissions & GP_FILE_PERM_READ) { itemInfo.readPermissions = 1; } else { itemInfo.readPermissions = 0; } if (info.file.permissions & GP_FILE_PERM_DELETE) { itemInfo.writePermissions = 1; } else { itemInfo.writePermissions = 0; } } gp_file_unref(cfile); return true; #else Q_UNUSED(folder); Q_UNUSED(itemName); Q_UNUSED(localFile); Q_UNUSED(itemInfo); return false; #endif /* HAVE_GPHOTO2 */ }
static int get_file_func (CameraFilesystem *fs, const char *folder, const char *filename, CameraFileType type, CameraFile *file, void *user_data, GPContext *context) { Camera *camera = user_data; unsigned char *data = NULL; int size, number, filetype, flash_file_count = 0; CHECK (number = gp_filesystem_number (camera->fs, folder, filename, context)); if (cam_has_flash(camera->pl) || cam_has_card(camera->pl) ) { CHECK (spca50x_flash_get_filecount (camera->pl, &flash_file_count)); } switch (type) { case GP_FILE_TYPE_NORMAL: if ( number < flash_file_count) { CHECK (spca50x_flash_get_file (camera->pl, context, &data, &size, number, 0)); CHECK (gp_file_set_mime_type (file, GP_MIME_JPEG)); } else { CHECK (spca50x_sdram_request_file (camera->pl, &data, &size, number-flash_file_count, &filetype)); if (filetype == SPCA50X_FILE_TYPE_IMAGE) { CHECK (gp_file_set_mime_type (file, GP_MIME_JPEG)); } else if (filetype == SPCA50X_FILE_TYPE_AVI) { CHECK (gp_file_set_mime_type (file, GP_MIME_AVI)); } } break; case GP_FILE_TYPE_PREVIEW: if ( number < flash_file_count) { CHECK (spca50x_flash_get_file (camera->pl, context, &data, &size, number, 1)); CHECK (gp_file_set_mime_type (file, GP_MIME_BMP)); } else { CHECK (spca50x_sdram_request_thumbnail (camera->pl, &data, &size, number-flash_file_count, &filetype)); if (filetype == SPCA50X_FILE_TYPE_IMAGE) { CHECK (gp_file_set_mime_type (file, GP_MIME_BMP)); } else if (filetype == SPCA50X_FILE_TYPE_AVI) { CHECK (gp_file_set_mime_type (file, GP_MIME_JPEG)); } } break; default: return GP_ERROR_NOT_SUPPORTED; } if (!data) return GP_ERROR; CHECK (gp_file_set_data_and_size (file, data, size)); CHECK (gp_file_set_name (file, filename)); return GP_OK; }
static int get_file_func (CameraFilesystem *fs, const char *folder, const char *filename, CameraFileType type, CameraFile *file, void *user_data, GPContext *context) { int status = GP_OK; Camera *camera = user_data; int w, h, b; int k, next; unsigned char comp_ratio; unsigned char lighting; unsigned char *data = NULL; unsigned char *p_data = NULL; unsigned char *ppm; unsigned char *ptr; unsigned char gtable[256]; int size; if(!camera->pl->init_done) digi_init (camera->port, camera->pl); /* Get the entry number of the photo on the camera */ k = gp_filesystem_number (camera->fs, "/", filename, context); if (GP_FILE_TYPE_EXIF ==type) return GP_ERROR_FILE_EXISTS; if (GP_FILE_TYPE_RAW!=type && GP_FILE_TYPE_NORMAL !=type && GP_FILE_TYPE_PREVIEW!=type) { return GP_ERROR_NOT_SUPPORTED; } next = camera->pl->last_fetched_entry +1; while (next < k) { b = digi_get_data_size (camera->pl, next); data = malloc(b); if(!data) return GP_ERROR_NO_MEMORY; digi_read_picture_data (camera->port, data, b, next); free(data); next ++; } comp_ratio = digi_get_comp_ratio (camera->pl, k); w = digi_get_picture_width (camera->pl, k); switch (w) { case 176: h = 144; break; case 640: h = 480; break; case 320: h = 240; break; default: h = 288; break; } lighting = camera->pl->catalog[k*0x10+0x0b]; b = digi_get_data_size (camera->pl, k); if (!b) { GP_DEBUG("Photo number %i deleted?\n",k+1); camera->pl->last_fetched_entry = k; return GP_OK; } data = malloc (w*h); if(!data) return GP_ERROR_NO_MEMORY; GP_DEBUG("Fetch entry %i\n", k); digi_read_picture_data (camera->port, data, b, k); camera->pl->last_fetched_entry = k; if (GP_FILE_TYPE_RAW == type) { /* type is GP_FILE_TYPE_RAW */ size = b; gp_file_set_mime_type (file, GP_MIME_RAW); gp_file_set_name (file, filename); gp_file_append(file, (char *)data, size); /* Save photo's catalog entry as a footer for the raw file */ gp_file_append(file, (char *)camera->pl->catalog + k*0x10, 0x10); /* Reset camera when done, for more graceful exit. */ if (k +1 == camera->pl->nb_entries) { digi_rewind (camera->port, camera->pl); } free(data); return(GP_OK); } /* * Now put the data into a PPM image file. */ ppm = malloc (w * h * 3 + 256); /* room for data + header */ if (!ppm) { status = GP_ERROR_NO_MEMORY; goto end; } snprintf ((char *)ppm, 64, "P6\n" "# CREATOR: gphoto2, SQ905C library\n" "%d %d\n" "255\n", w, h); size = strlen ((char *)ppm); ptr = ppm + size; size = size + (w * h * 3); GP_DEBUG ("size = %i\n", size); p_data = malloc( w*h ); if (!p_data) { status = GP_ERROR_NO_MEMORY; goto end; } if(comp_ratio) { digi_decompress (p_data, data, w, h); } else memcpy(p_data, data, w*h); gp_ahd_decode (p_data, w , h , ptr, BAYER_TILE_BGGR); free(p_data); digi_postprocess (w, h, ptr); if (lighting < 0x40) { GP_DEBUG( "Low light condition. Using default gamma. \ No white balance.\n"); gp_gamma_fill_table (gtable, .65); gp_gamma_correct_single(gtable,ptr,w*h); } else