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; char *data = NULL; unsigned long int size = 0; switch (type) { case GP_FILE_TYPE_EXIF: gp_file_set_mime_type (file, GP_MIME_RAW); CR (sx330z_get_data (camera, context, filename, &data, &size, SX_THUMBNAIL)); break; case GP_FILE_TYPE_RAW: case GP_FILE_TYPE_NORMAL: gp_file_set_mime_type (file, GP_MIME_JPEG); CR (sx330z_get_data (camera, context, filename, &data, &size, SX_IMAGE)); break; case GP_FILE_TYPE_PREVIEW: default: return (GP_ERROR_NOT_SUPPORTED); } gp_file_set_data_and_size (file, data, size); 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 size,image_no,result; unsigned char *data; image_no = gp_filesystem_number(fs, folder, filename, context); if (image_no < GP_OK) return image_no; switch (type) { case GP_FILE_TYPE_NORMAL: result = ultrapocket_getpicture(camera,context,&data,&size,filename); gp_file_set_mime_type (file, GP_MIME_PPM); break; case GP_FILE_TYPE_RAW: result = ultrapocket_getrawpicture(camera, context, &data, &size, filename); gp_file_set_mime_type (file, GP_MIME_PPM); break; case GP_FILE_TYPE_PREVIEW: default: return (GP_ERROR_NOT_SUPPORTED); } if (result < 0) return result; CHECK_RESULT(gp_file_set_data_and_size (file, (char *)data, size)); 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; 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); 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); 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 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 n; unsigned int size; unsigned char *data; CR (n = gp_filesystem_number (fs, folder, filename, context)); n++; switch (type) { case GP_FILE_TYPE_NORMAL: CR (ricoh_get_pic (camera, context, n, RICOH_FILE_TYPE_NORMAL, &data, &size)); gp_file_set_mime_type (file, GP_MIME_EXIF); break; case GP_FILE_TYPE_PREVIEW: CR (ricoh_get_pic (camera, context, n, RICOH_FILE_TYPE_PREVIEW, &data, &size)); gp_file_set_mime_type (file, GP_MIME_TIFF); break; default: return (GP_ERROR_NOT_SUPPORTED); } gp_file_set_data_and_size (file, (char*)data, size); 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 n; unsigned char *d; unsigned int size; /* We need file numbers starting with 1 */ CR (n = gp_filesystem_number (camera->fs, folder, filename, context)); n++; switch (type) { case GP_FILE_TYPE_NORMAL: CR (fuji_pic_get (camera, n, &d, &size, context)); break; case GP_FILE_TYPE_PREVIEW: CR (fuji_pic_get_thumb (camera, n, &d, &size, context)); break; default: return (GP_ERROR_NOT_SUPPORTED); } CR (gp_file_set_data_and_size (file, (char *)d, size)); CR (gp_file_set_mime_type (file, GP_MIME_JPEG)); 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 size, nr, result; nr = gp_filesystem_number(fs, folder, filename, context); if(nr < 0) return nr; switch (type) { #if 0 case GP_FILE_TYPE_RAW: result = jd11_get_image_full (camera, nr, &data, (int*) &size, 1); break; #endif case GP_FILE_TYPE_NORMAL: result = mdc800_getImage(camera,nr,&data,&size); break; case GP_FILE_TYPE_PREVIEW: result = mdc800_getThumbnail(camera,nr,&data,&size); break; default: return (GP_ERROR_NOT_SUPPORTED); } if (result < 0) return result; gp_file_set_mime_type (file, GP_MIME_JPEG); gp_file_set_data_and_size(file, data, size); 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 image_no, result; image_no = gp_filesystem_number(camera->fs, folder, filename, context); if(image_no < 0) return image_no; gp_file_set_mime_type (file, GP_MIME_JPEG); switch (type) { case GP_FILE_TYPE_NORMAL: result = stv0674_get_image (camera->port, image_no, file); break; case GP_FILE_TYPE_RAW: result = stv0674_get_image_raw (camera->port, image_no, file); break; case GP_FILE_TYPE_PREVIEW: result = stv0674_get_image_preview (camera->port, image_no, file); break; default: return (GP_ERROR_NOT_SUPPORTED); } return result; }
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; } return GP_OK; }
static int camera_capture_preview (Camera *camera, CameraFile *file, GPContext *context) { unsigned char *frame_data; unsigned char *ppm, *ptr; unsigned char gtable[256]; int size; int w = 320; int h = 240; int b=0x12c40; camera->pl->last_fetched_data = malloc (b); if (!camera->pl->last_fetched_data) { sq_rewind(camera->port, camera->pl); return GP_ERROR_NO_MEMORY; } sq_access_reg(camera->port, CAPTURE); sq_read_picture_data (camera->port, camera->pl->last_fetched_data, b); frame_data = camera->pl->last_fetched_data + 0x40; sq_preprocess(camera->pl->model, 1, 0, frame_data, w, h); /* Now put the data into a PPM image file. */ ppm = malloc (w * h * 3 + 256); if (!ppm) return GP_ERROR_NO_MEMORY; sprintf ((char *)ppm, "P6\n" "# CREATOR: gphoto2, SQ905 library\n" "%d %d\n" "255\n", w, h); ptr = ppm + strlen ((char*)ppm); size = strlen ((char*)ppm) + (w * h * 3); GP_DEBUG ("size = %i\n", size); switch (camera->pl->model) { case SQ_MODEL_POCK_CAM: gp_bayer_decode (frame_data, w , h , ptr, BAYER_TILE_GBRG); break; default: gp_bayer_decode (frame_data, w , h , ptr, BAYER_TILE_BGGR); break; } /* TO DO: * Adapt some postprocessing routine to work here, because results * can vary greatly, depending both on lighting conditions and on * camera model. */ gp_gamma_fill_table (gtable, .5); gp_gamma_correct_single (gtable, ptr, w * h); gp_file_set_mime_type (file, GP_MIME_PPM); gp_file_set_data_and_size (file, (char *)ppm, size); sq_reset(camera->port); sq_access_reg(camera->port, CAPTURE); sq_reset(camera->port); return (GP_OK); }
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); }
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 get_file_func (CameraFilesystem *fs, const char *folder, const char *filename, CameraFileType type, CameraFile *file, void *user_data, GPContext *context) { char *pos; Camera *camera = user_data; unsigned char *data = NULL; int size,ret; switch (type) { case GP_FILE_TYPE_NORMAL: ret=soundvision_file_get(camera, filename, 0, &data, &size); if (ret<0) return ret; break; case GP_FILE_TYPE_PREVIEW: ret=soundvision_file_get(camera, filename, 1, &data, &size); if (ret<0) return ret; break; default: return GP_ERROR_NOT_SUPPORTED; } if (!data) return GP_ERROR; gp_file_set_data_and_size (file, (char *)data, size); /* Maybe skip below if EXIF data present? */ /* As far as I know we only support JPG and MOV */ /* Maybe some have MP3??? */ pos=strchr (filename, '.'); if (pos) { if ((!strcmp(pos,".JPG")) || ((!strcmp(pos,".jpg")))) gp_file_set_mime_type (file, GP_MIME_JPEG); else if (!strcmp(pos,".MOV")) gp_file_set_mime_type (file, GP_MIME_QUICKTIME); else gp_file_set_mime_type (file, GP_MIME_UNKNOWN); } return GP_OK; }
static int camera_capture_preview (Camera *camera, CameraFile *file, GPContext *context) { char *data; int size, result; result = stv0674_capture_preview (camera->port, &data, &size); if (result < 0) return result; gp_file_set_mime_type (file, GP_MIME_JPEG); return gp_file_set_data_and_size (file, data, size); }
static int get_file_func (CameraFilesystem *fs, const char *folder, const char *filename, CameraFileType type, CameraFile *file, void *data, GPContext *context) { Camera *camera = data; unsigned long image_id; char image_id_string[] = {0, 0, 0, 0, 0, 0, 0}; unsigned int size; CameraFileInfo info; int r; KncCamRes cr; KncCntrlRes cntrl_res = KNC_CNTRL_OK; if (strlen (filename) != 11) return (GP_ERROR_FILE_NOT_FOUND); if (strcmp (folder, "/")) return (GP_ERROR_DIRECTORY_NOT_FOUND); /* Check if we can get the image id from the filename. */ strncpy (image_id_string, filename, 6); image_id = atol (image_id_string); /* Get information about the image */ C (gp_filesystem_get_info (camera->fs, folder, filename, &info, context)); /* * Remove the timeout, get the image and start the timeout * afterwards. */ gp_camera_stop_timeout (camera, camera->pl->timeout); knc_cntrl_set_func_data (camera->pl->c, data_func, file); switch (type) { case GP_FILE_TYPE_PREVIEW: size = 2048; cntrl_res = knc_get_image (camera->pl->c, &cr, image_id, KNC_SOURCE_CARD, KNC_IMAGE_THUMB); break; case GP_FILE_TYPE_NORMAL: size = info.file.size; cntrl_res = knc_get_image (camera->pl->c, &cr, image_id, KNC_SOURCE_CARD, KNC_IMAGE_EXIF); break; default: r = GP_ERROR_NOT_SUPPORTED; } camera->pl->timeout = gp_camera_start_timeout (camera, PING_TIMEOUT, timeout_func); CR (cntrl_res, context); CCR (cr, context); C (gp_file_set_mime_type (file, GP_MIME_JPEG)); return (GP_OK); }
static int camera_capture_preview (Camera* camera, CameraFile* file, GPContext *context) { KncCamRes cr; knc_cntrl_set_func_data (camera->pl->c, data_func, file); CR (knc_get_preview (camera->pl->c, &cr, KNC_PREVIEW_YES), context); C (gp_file_set_mime_type (file, GP_MIME_JPEG)); return (GP_OK); }
static int camera_capture_preview(Camera *camera, CameraFile *file, GPContext *context) { long size; uint8_t *data; gp_file_set_mime_type (file, GP_MIME_PGM); data = Dimera_Preview( &size, camera, context); if (!data) return GP_ERROR; return gp_file_set_data_and_size (file, data, size); }
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 n, len; char *data, *data_start; n = gp_filesystem_number(camera->fs, "/", filename, context); if (n<GP_OK) return n; len = ez200_get_picture_size (camera->port, n); GP_DEBUG("len = %i", len); data = (char *)malloc(len + HEADER_SIZE + 1); if (!data) return GP_ERROR_NO_MEMORY; data_start = data + (HEADER_SIZE - DATA_HEADER_SIZE); GP_DEBUG("data - data_start : %p %p : %lx",data, data_start, (long) (data_start - data)); ez200_read_picture_data (camera->port, data_start, len, n); ez200_read_picture_header (camera->port, data); switch (type) { case GP_FILE_TYPE_PREVIEW: case GP_FILE_TYPE_NORMAL: gp_file_set_mime_type (file, GP_MIME_JPEG); gp_file_set_data_and_size (file, data, len + HEADER_SIZE + 1); break; case GP_FILE_TYPE_RAW: gp_file_set_data_and_size (file, data, len); gp_file_set_mime_type (file, GP_MIME_RAW); gp_file_adjust_name_for_mime_type(file); break; default: return (GP_ERROR_NOT_SUPPORTED); } 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 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 w=0, h=0, b=0; int k, res; unsigned char *data; unsigned char *jpeg_out = NULL; int file_size; unsigned char jpeg_format; /* 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; res = clicksmart_get_res_setting (camera->pl, k); switch (res) { case 0: w = 352; h = 288; jpeg_format = JPEG_CIF_FORMAT; break; case 1: case 3: w = 176; h = 144; jpeg_format = JPEG_QCIF_FORMAT; break; default: GP_DEBUG ( "Unknown resolution setting %i\n", res); return GP_ERROR; } data = malloc (w*h); if(!data) return GP_ERROR_NO_MEMORY; GP_DEBUG("Fetch entry %i\n", k); b = clicksmart_read_pic_data (camera->pl, camera->port, data, k); if (GP_FILE_TYPE_RAW == type) { /* type is GP_FILE_TYPE_RAW */ gp_file_set_mime_type (file, GP_MIME_RAW); gp_file_set_data_and_size (file, (char *)data, b); /* Reset camera when done, for more graceful exit. */ if (k +1 == camera->pl->num_pics) { clicksmart_reset (camera->port); } return GP_OK; } GP_DEBUG ("size = %i\n", b); /* It looks as though o_size = b */ /* It seems that qIndex is byte7, which is always 3, so I use that. */ file_size = b + 589 + 1024 * 10; jpeg_out = malloc(file_size); if (!jpeg_out) { free(data); return GP_ERROR_NO_MEMORY; } GP_DEBUG("width: %d, height: %d, data size: %d\n", w, h, b); create_jpeg_from_data (jpeg_out, data, 3, w, h, jpeg_format, b, &file_size, 0, 0); gp_file_set_mime_type (file, GP_MIME_JPEG); gp_file_set_data_and_size (file, (char *)jpeg_out, file_size); /* Reset camera when done, for more graceful exit. */ if (k +1 == camera->pl->num_pics) { clicksmart_reset (camera->port); } free(data); return GP_OK; }
/* * Get images, thumbnails or EXIF datas */ static int get_file_func (CameraFilesystem *fs, const char *folder, const char *filename, CameraFileType type, CameraFile *file, void *data, GPContext *context) { unsigned char *d,*thumbnail; int image_number, image_no, len, ret; long long_len; CameraFileInfo file_info; exifparser exifdat; GP_DEBUG ("*** ENTER: get_file_func ***"); image_no = gp_filesystem_number(fs, folder, filename, context); if (image_no < 0) return image_no; /* Search the image informations */ image_no++; ret = k_info_img (image_no, data, (CameraFileInfo *)&file_info, &image_number); image_no = image_number; if (ret < GP_OK) return ret; switch (type) { case GP_FILE_TYPE_NORMAL: len = file_info.file.size; if (!(d = (unsigned char *)malloc(len))) return (GP_ERROR_NO_MEMORY); ret = k_getdata(image_no, GP_FILE_TYPE_NORMAL,len, data, d, context); if (ret < GP_OK) { free(d); return ret; } break; case GP_FILE_TYPE_PREVIEW: len = file_info.preview.size; long_len = (long)len; if (!(d = (unsigned char *)malloc(len))) return (GP_ERROR_NO_MEMORY); ret = k_getdata(image_no, GP_FILE_TYPE_PREVIEW, len, data, d, context); if (ret < GP_OK) { free(d); return ret; } exifdat.header = d; exifdat.data = d+12; thumbnail = gpi_exif_get_thumbnail_and_size(&exifdat, &long_len); free(d); d = thumbnail; break; case GP_FILE_TYPE_EXIF: len = file_info.preview.size; if (!(d = (unsigned char *)malloc(len))) return (GP_ERROR_NO_MEMORY); ret = k_getdata(image_no, GP_FILE_TYPE_EXIF, len, data, d, context); if (ret < GP_OK) { free(d); return ret; } break; default: gp_context_error(context, _("Image type %d is not supported by this camera !"), type); return (GP_ERROR_NOT_SUPPORTED); } gp_file_set_mime_type (file, GP_MIME_JPEG); ret = gp_file_append(file, (char*)d, len); free(d); return (ret); }
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 w, h = 0, b = 0, k; unsigned char *pic_data, *pic_buffer, *pic_output = NULL; int HEADERSIZE=16; int outputsize; unsigned long start_of_photo; unsigned int downloadsize = 0; int filled = 0; GP_DEBUG ("Downloading pictures!\n"); if(!camera->pl->data_reg_opened) jl2005c_open_data_reg (camera, camera->port); /* These are cheap cameras. There ain't no EXIF data. */ 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); h = camera->pl->table[16 * k + 4] << 3; w = camera->pl->table[16 * k + 5] << 3; GP_DEBUG ("height is %i\n", h); b = jl2005c_get_pic_data_size(camera->pl, camera->pl->table, k); GP_DEBUG("b = %i = 0x%x bytes\n", b,b); start_of_photo = jl2005c_get_start_of_photo(camera->pl, camera->pl->table, k); GP_DEBUG("start_of_photo number %i = 0x%lx \n", k,start_of_photo); pic_buffer = malloc(b + HEADERSIZE); if (!pic_buffer) return GP_ERROR_NO_MEMORY; memset(pic_buffer, 0, b + HEADERSIZE); GP_DEBUG ("buffersize b+16 = %i = 0x%x bytes\n", b+16,b+16); /* Copy info line for photo from allocation table, as header */ memcpy(pic_buffer, camera->pl->table + 16 * k, 16); pic_data = pic_buffer+HEADERSIZE; /* * Camera can download in blocks of 0xfa00, with only the last block * possibly smaller. So first we set up a cache of that size * (if it is not set up already) to hold raw data. If one tries * instead to download one photo at a time, the camera will misbehave; * data will be lost or corrupted. The dog will bite you, too. */ if (!(camera->pl->data_cache)) { camera->pl->data_cache = malloc (MAX_DLSIZE); } if (!(camera->pl->data_cache)) { GP_DEBUG ("no cache memory allocated!\n"); return GP_ERROR_NO_MEMORY; } /* Is there data in the cache, or not? If yes, read from it into the * current photo, immediately. Update settings. But first two sanity * checks. */ if (start_of_photo < camera->pl->bytes_put_away) { GP_DEBUG("photo number %i starts in a funny place!\n",k); /* We need to start all over again to get this photo. */ jl2005c_reset(camera, camera->port); jl2005c_init (camera, camera->port, camera->pl); } if (start_of_photo+b > camera->pl->total_data_in_camera) { GP_DEBUG ("Photo runs past end of data. Exiting. \n"); GP_DEBUG ("Block size may be wrong for this camera\n"); return (GP_ERROR); } /* * This while loop is entered if the photo number k-1 was not requested * and thus has not been downloaded. The camera's rudimentary hardware * obliges us to download all data consecutively and toss whatever * portion of said data that we do not intend to use. The rudimentary * hardware also does not like to stop downloading at the end of one * photo and then to start on the next. It wants to keep getting data * in size 0xfa00 increments, and only the last block can be smaller. * To do otherwise will cause data to be lost or corrupted. * * Whoever tries to simplify this convoluted and ugly procedure is * warned that the obvious simplifications, while much prettier, * just won't work. A kutya harap. */ while (camera->pl->bytes_read_from_camera <= start_of_photo) { camera->pl->data_to_read = camera->pl->total_data_in_camera - camera->pl->bytes_read_from_camera; downloadsize = MAX_DLSIZE; if (camera->pl->data_to_read < downloadsize) downloadsize = camera->pl->data_to_read; GP_DEBUG("downloadsize = 0x%x\n", downloadsize); if (downloadsize) jl2005c_read_data ( camera->port, (char *) camera->pl->data_cache, downloadsize); camera->pl->bytes_read_from_camera += downloadsize; } camera->pl->bytes_put_away=start_of_photo; if (camera->pl->bytes_read_from_camera > start_of_photo) { if(start_of_photo + b <= camera->pl->bytes_read_from_camera) { memcpy(pic_data, camera->pl->data_cache + (start_of_photo % MAX_DLSIZE) , b); camera->pl->bytes_put_away += b; /* * Photo data is contained in what is already * downloaded. * Jump immediately to process the photo. */ } else { /* Photo starts in one 0xfa00-sized download and ends * in another */ filled = camera->pl->bytes_read_from_camera - start_of_photo; memcpy(pic_data, camera->pl->data_cache + (start_of_photo % MAX_DLSIZE), filled); camera->pl->bytes_put_away += filled; } } while (camera->pl->bytes_put_away < start_of_photo + b ) { camera->pl->data_to_read = camera->pl->total_data_in_camera - camera->pl->bytes_read_from_camera; downloadsize = MAX_DLSIZE; if (camera->pl->data_to_read < downloadsize) downloadsize = camera->pl->data_to_read; GP_DEBUG("downloadsize = 0x%x\n", downloadsize); if (downloadsize) jl2005c_read_data ( camera->port, (char *) camera->pl->data_cache, downloadsize); camera->pl->bytes_read_from_camera += downloadsize; if (camera->pl->bytes_read_from_camera >= start_of_photo + b ) { GP_DEBUG("THIS ONE?\n"); memcpy(pic_data+filled, camera->pl->data_cache, b - filled); camera->pl->bytes_put_away += b - filled; break; } else { GP_DEBUG("THIS ONE??\n"); if (!downloadsize) break; memcpy(pic_data + filled, camera->pl->data_cache, downloadsize); camera->pl->bytes_put_away += downloadsize; filled += downloadsize; } } if (type == GP_FILE_TYPE_RAW) { gp_file_set_mime_type(file, GP_MIME_RAW); gp_file_set_data_and_size(file, (char *)pic_buffer , b+16 ); return GP_OK; #ifdef HAVE_LIBJPEG } else if (type == GP_FILE_TYPE_PREVIEW) { if (!camera->pl->can_do_capture) return GP_ERROR_NOT_SUPPORTED; outputsize = (pic_buffer[9] & 0xf0) * 192 + 256; GP_DEBUG("pic_buffer[9] is 0x%02x\n", pic_buffer[9]); GP_DEBUG("Thumbnail outputsize = 0x%x = %d\n", outputsize, outputsize); if (outputsize == 256) { GP_DEBUG("Frame %d has no thumbnail.\n", k); return GP_OK; } pic_output = calloc(outputsize, 1); if (!pic_output) return GP_ERROR_NO_MEMORY; outputsize = jl2005bcd_decompress(pic_output, pic_buffer, b + 16, 1); GP_DEBUG("Thumbnail outputsize recalculated is 0x%x = %d\n", outputsize, outputsize); gp_file_set_mime_type(file, GP_MIME_PPM); gp_file_set_data_and_size(file, (char *)pic_output, outputsize); } else if (type == GP_FILE_TYPE_NORMAL) { outputsize = 3 * w * h + 256; pic_output = calloc(outputsize, 1); if (!pic_output) return GP_ERROR_NO_MEMORY; outputsize = jl2005bcd_decompress(pic_output, pic_buffer, b + 16, 0); gp_file_set_mime_type(file, GP_MIME_PPM); gp_file_set_data_and_size(file, (char *)pic_output, outputsize); #endif } else return GP_ERROR_NOT_SUPPORTED; 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 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; }
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_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
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 result; int havefirst = 0; unsigned char buffer[SDSC_BLOCKSIZE], first[SDSC_BLOCKSIZE]; long int size, curread; unsigned int pid; if (type != GP_FILE_TYPE_NORMAL) return (GP_ERROR_NOT_SUPPORTED); /* Seek the header of our file */ 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 (!strcmp(buffer,filename)) break; if (is_null(buffer)) { /* skipped to the end of the camera? */ /* Since we start at a random position, we wrap around. */ continue; } /* We are at the first item again, so break. */ if (havefirst && !strcmp(first,buffer)) return GP_ERROR_BAD_PARAMETERS; if (!havefirst) { havefirst = 1; strcpy(first,buffer); } } /* The buffer header has * filename (8.3 DOS format and \0) * filesize (as ascii number) and \0 */ /* Extract the size of the file */ sscanf(buffer+12,"%ld",&size); /* Put the camera into image mode */ CHECK_RESULT (SDSC_send (camera->port, SDSC_BINARY)); CHECK_RESULT (SDSC_send (camera->port, SDSC_START)); pid = gp_context_progress_start(context,size,_("Downloading image...")); curread = 0; /* Read data */ while (1) { /* Read data and check for EOF */ result = SDSC_receive (camera->port, buffer, SDSC_BLOCKSIZE); if (result == SDSC_ERROR_EOF) break; if (result < 0) return result; gp_file_append(file,buffer,SDSC_BLOCKSIZE); curread += SDSC_BLOCKSIZE; gp_context_progress_update(context, pid, curread); if (gp_context_cancel(context) == GP_CONTEXT_FEEDBACK_CANCEL) return GP_ERROR_CANCEL; CHECK_RESULT (SDSC_send (camera->port, SDSC_BINARY)); } gp_context_progress_stop(context, pid); CHECK_RESULT (gp_file_set_mime_type (file, GP_MIME_JPEG)); 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 num, width, height; uint8_t *data, *newdata; long int size; /* Retrieve the number of the photo on the camera */ if (strcmp(filename, RAM_IMAGE_TEMPLATE) == 0) /* Magic file name specifies magic image number */ num = RAM_IMAGE_NUM; else num = gp_filesystem_number(camera->fs, "/", filename, context); if (num < 0) return num; switch (type) { case GP_FILE_TYPE_NORMAL: data = Dimera_Get_Full_Image (num, &size, &width, &height, camera, context); if (!data) return GP_ERROR; gp_file_set_mime_type (file, GP_MIME_PPM); if (width == 640) gp_file_append (file, Dimera_finehdr, strlen(Dimera_finehdr)); else gp_file_append (file, Dimera_stdhdr, strlen(Dimera_stdhdr)); newdata = malloc(size*3); if (!newdata) return (GP_ERROR_NO_MEMORY); conversion_chuck (width, height, data, newdata); gp_file_append (file, newdata, size*3); free (newdata); free (data); break; break; case GP_FILE_TYPE_RAW: data = Dimera_Get_Full_Image (num, &size, &width, &height, camera, context); if (!data) return GP_ERROR; gp_file_set_data_and_size (file, data, size); /* will take over data ptr ownership */ gp_file_set_mime_type (file, GP_MIME_RAW); gp_file_adjust_name_for_mime_type (file); break; case GP_FILE_TYPE_PREVIEW: data = Dimera_Get_Thumbnail (num, &size, camera); if (!data) return GP_ERROR; gp_file_set_data_and_size (file, data, size); /* will take over data ptr ownership */ gp_file_set_mime_type (file, GP_MIME_PGM); gp_file_adjust_name_for_mime_type (file); break; default: gp_context_error (context, _("Image type is not supported")); return (GP_ERROR_NOT_SUPPORTED); } return GP_OK; }
int pdrm11_get_file(CameraFilesystem *fs, const char *filename, CameraFileType type, CameraFile *file, GPPort *port, uint16_t picNum) { uint32_t size = 0; uint16_t thumbsize = 0; uint8_t buf[30]; uint8_t *image; uint8_t temp; int i; int ret; int file_type; gp_port_set_timeout(port,10000); CHECK( pdrm11_select_file(port, picNum) ); if(type == GP_FILE_TYPE_PREVIEW) { CHECK(gp_port_usb_msg_read(port, 0x01, PDRM11_CMD_GET_INFO, picNum, (char *)buf, 8)); file_type = buf[4]; CHECK( gp_port_usb_msg_read(port, 0x01, PDRM11_CMD_GET_THUMBSIZE, picNum, (char *)buf, 14) ); thumbsize = le16atoh( &buf[8] ); /* add 1 to file size only for jpeg thumbnails */ if(file_type == 1) { GP_DEBUG("thumbnail file_type: %s.", "jpeg"); size = (uint32_t)thumbsize + 1; } else if(file_type == 2) { /* NOTE: tiff thumbnails are 160x120 pixel 8bpc rgb images, NOT jpegs... */ GP_DEBUG("thumbnail file_type: %s.", "tiff"); size = (uint32_t)thumbsize; } else { GP_DEBUG("Unknown thumbnail file format!"); return(GP_ERROR_NOT_SUPPORTED); } } else if(type == GP_FILE_TYPE_NORMAL) { CHECK( gp_port_usb_msg_read(port, 0x01, PDRM11_CMD_GET_FILESIZE, picNum, (char *)buf, 26) ); size = le32atoh( &buf[18] ); } else { GP_DEBUG("Unsupported file type!"); return(GP_ERROR_NOT_SUPPORTED); } GP_DEBUG("size: %d 0x%x", size, size); image = malloc(sizeof(char)*size); if(!image) return(GP_ERROR_NO_MEMORY); if(type == GP_FILE_TYPE_PREVIEW) { CHECK_AND_FREE( gp_port_usb_msg_write(port, 0x01, PDRM11_CMD_GET_THUMB, picNum, NULL, 0), image ); } else { CHECK_AND_FREE( gp_port_usb_msg_write(port, 0x01, PDRM11_CMD_GET_PIC, picNum, NULL, 0), image ); } ret = gp_port_read(port, (char *)image, size); if(ret != size) { GP_DEBUG("failed to read from port. Giving it one more try..."); ret = gp_port_read(port, (char *)image, size); if(ret != size) { GP_DEBUG("gp_port_read returned %d 0x%x. size: %d 0x%x", ret, ret, size, size); free (image); return(GP_ERROR_IO_READ); } } /* swap the bytes for the thumbnail, but not the file */ if(type == GP_FILE_TYPE_PREVIEW) { for(i=0; i<size; i+=2) { temp = image[i]; image[i] = image[i+1]; image[i+1] = temp; } } gp_file_set_mime_type(file, GP_MIME_JPEG); gp_file_set_data_and_size(file, (char *)image, size); return(GP_OK); }
/* This function reads all thumbnails at once and initializes the whole * camera filesystem. This can be done, because finding out how much * pictures are on the camera is done by reading the whole preview picture * stream anyway. * And since the file infos are static mostly, why not just set them too at * the same time. */ int jd11_index_reader(GPPort *port, CameraFilesystem *fs, GPContext *context) { int i, id, count, xsize, curread=0, ret=0; unsigned char *indexbuf; ret = jd11_select_index(port); if (ret != GP_OK) return ret; xsize = jd11_imgsize(port); if (!xsize) { /* shortcut, no reading needed */ return GP_OK; } count = xsize/(64*48); xsize = count * (64*48); indexbuf = malloc(xsize); if (!indexbuf) return GP_ERROR_NO_MEMORY; id = gp_context_progress_start (context, xsize, _("Downloading thumbnail...")); _send_cmd(port,0xfff1); while (curread < xsize) { int readsize = xsize-curread; if (readsize>200) readsize = 200; ret=getpacket(port,indexbuf+curread,readsize); if (ret==0) break; curread+=ret; if (ret<200) break; gp_context_progress_update (context, id, curread); if (gp_context_cancel (context) == GP_CONTEXT_FEEDBACK_CANCEL) { /* What to do...Just free the stuff we allocated for now.*/ free(indexbuf); return GP_ERROR_CANCEL; } _send_cmd(port,0xfff1); } gp_context_progress_stop (context, id); for (i=0;i<count;i++) { CameraFile *file; char fn[20]; unsigned char *src; unsigned char thumb[64*48]; int y; CameraFileInfo info; ret = gp_file_new(&file); if (ret!=GP_OK) { free(indexbuf); return ret; } sprintf(fn,"image%02i.pgm",i); gp_file_set_mime_type(file, GP_MIME_PGM); gp_file_append(file, THUMBHEADER, strlen(THUMBHEADER)); src = indexbuf+(i*64*48); for (y=0;y<48;y++) { int x,off = 64*y; for (x=0;x<64;x++) thumb[47*64-off+(63-x)] = src[off+x]; } ret = gp_file_append(file,(char*)thumb,sizeof(thumb)); if (ret != GP_OK) { gp_file_free (file); return ret; } ret = gp_filesystem_append(fs, "/", fn, context); if (ret != GP_OK) { /* should perhaps remove the entry again */ gp_file_free (file); return ret; } ret = gp_filesystem_set_file_noop(fs, "/", fn, GP_FILE_TYPE_PREVIEW, file, context); if (ret != GP_OK) return ret; /* we also get the fs info for free, so just set it */ info.file.fields = GP_FILE_INFO_TYPE | GP_FILE_INFO_WIDTH | GP_FILE_INFO_HEIGHT | GP_FILE_INFO_SIZE; strcpy(info.file.type,GP_MIME_PNM); info.file.width = 640; info.file.height = 480; info.file.size = 640*480*3+strlen(IMGHEADER); info.preview.fields = GP_FILE_INFO_TYPE | GP_FILE_INFO_WIDTH | GP_FILE_INFO_HEIGHT | GP_FILE_INFO_SIZE; strcpy(info.preview.type,GP_MIME_PGM); info.preview.width = 64; info.preview.height = 48; info.preview.size = 64*48+strlen(THUMBHEADER); ret = gp_filesystem_set_info_noop(fs, "/", fn, info, context); } free(indexbuf); 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; char *raw, *ppm; unsigned char gtable[256]; char *ptr; int size = 0, n = 0; int width, height; struct jamcam_file *jc_file; GP_DEBUG ("* camera_file_get"); GP_DEBUG ("*** folder: %s", folder); GP_DEBUG ("*** filename: %s",filename); GP_DEBUG ("*** type: %d", type); CHECK (n = gp_filesystem_number (camera->fs, folder, filename, context)); if (gp_context_cancel (context) == GP_CONTEXT_FEEDBACK_CANCEL) return (GP_ERROR_CANCEL); raw = malloc(640*480 * 3); ppm = malloc(640*480 * 3 + 200); switch (type) { case GP_FILE_TYPE_PREVIEW: CHECK_free (jamcam_request_thumbnail (camera, file, raw, &size, n, context)); width = 80; height = 60; sprintf( ppm, "P6\n" "# CREATOR: gphoto2, jamcam library\n" "%d %d\n" "255\n", width, height ); ptr = ppm + strlen( ppm ); size = strlen( ppm ) + ( height * width * 3 ); gp_bayer_decode(raw, width, height, ptr, BAYER_TILE_GBRG ); gp_gamma_fill_table( gtable, 0.5 ); gp_gamma_correct_single( gtable, ptr, height * width ); CHECK_free (gp_file_set_mime_type (file, GP_MIME_PPM)); CHECK_free (gp_file_append (file, ppm, size)); break; case GP_FILE_TYPE_NORMAL: CHECK_free (jamcam_request_image (camera, file, raw, &size, n, context)); jc_file = jamcam_file_info (camera, n); sprintf( ppm, "P6\n" "# CREATOR: gphoto2, jamcam library\n" "%d %d\n" "255\n", jc_file->width, jc_file->height ); ptr = ppm + strlen( ppm ); size = strlen( ppm ) + ( jc_file->width * jc_file->height * 3 ); gp_bayer_decode( raw, jc_file->width, jc_file->height, ptr, BAYER_TILE_GBRG ); gp_gamma_fill_table( gtable, 0.5 ); gp_gamma_correct_single( gtable, ptr, jc_file->width * jc_file->height ); CHECK_free (gp_file_set_mime_type (file, GP_MIME_PPM)); CHECK_free (gp_file_append (file, ppm, size)); break; case GP_FILE_TYPE_RAW: CHECK_free (jamcam_request_image (camera, file, raw, &size, n, context)); CHECK_free (gp_file_set_mime_type (file, GP_MIME_RAW)); CHECK_free (gp_file_append (file, raw, size)); break; default: free(raw); free(ppm); return (GP_ERROR_NOT_SUPPORTED); } free(raw); free(ppm); 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 number, filetype, flash_file_count = 0; unsigned int size; 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; return gp_file_set_data_and_size (file, (char *)data, size); }