int main (int argc, char** argv)
{
std::cout<<"GP_OK = "<<GP_OK<<std::endl;
GPContext *currentContext = NULL;
gp_context_new();
Camera *camera=NULL;
gp_camera_new (&camera);
gp_camera_init (camera, currentContext);
CameraAbilitiesList * abilitiesList;
CameraAbilities abilities;
CameraAbilities * ptr_abilities;
ptr_abilities = &abilities;
int haveListAbilities = gp_abilities_list_get_abilities (abilitiesList, 0, ptr_abilities);
std::cout<<"haveListAbilities : "<< haveListAbilities<<std::endl;
/* int haveAbilities = gp_camera_set_abilities(camera, abilities);
std::cout<<"haveAbilities : "<< haveAbilities<<std::endl;*/
/* //in case camera driver can't figure out the current camera's speed
//gp_camera_set_port_path or name => pas TROUVE
int speed; //AURA BESOIN D4UNE VALEUR (???)
int hasSpeed = gp_camera_set_port_speed (camera, speed);
*/
//to know port's camera
GPPortInfo info;
GPPortInfo * ptr_info;
ptr_info = &info;
/* int infoSetted = gp_camera_set_port_info (camera, info);
std::cout<<"infoSetted : "<< infoSetted<<std::endl;*/
///
int infoGetted = gp_camera_get_port_info(camera, ptr_info);
std::cout<<"infoGetted : "<< infoGetted<<std::endl;
//To have a window with camera's config
CameraWidget ** widget;
CameraWidgetType type;
const char *label;
int widgetCreated = gp_widget_new (type, label, widget);
std::cout<<"widgetCreated : "<< widgetCreated<<std::endl;
//get config
int configGetted = gp_camera_get_config (camera, widget, currentContext);
std::cout<<"configGetted : "<< configGetted<<std::endl;
//set the configuration's camera
// int cameraSetted = gp_camera_set_config (camera, *widget, currentContext);
// std::cout<<"cameraSetted : "<< cameraSetted<<std::endl;
//HAVE TO FIND FUNCTION WHICH GET/SET THE PÄTH
CameraFilePath * path;
//IDEM
CameraCaptureType typeCapture;
CameraFileType typeFile; //mm type à priori
//capture
int captured = gp_camera_capture (camera, typeCapture, path, currentContext);
std::cout<<"captured : "<< captured<<std::endl;
//To get capture from camera to computer
//folder on computer
//TO COMPLETE
const char *folder = "../pictures";
//TO COMPLETE
//(devra être renseigné en fonction du numéro de la photoprécédente par ex)
const char *file = "picture001";
//??
CameraFile * camera_file;
int captureGetted = gp_camera_file_get(camera, folder, file, typeFile,camera_file, currentContext);
std::cout<<"captureGetted : "<< captureGetted<<std::endl;
int indiceCountCamera = gp_camera_unref (camera);
//Before the end of using camera => better!
int cameraExited = gp_camera_exit (camera, currentContext);
return EXIT_SUCCESS;
}
int _camctl_recursive_get_previews(const dt_camctl_t *c,dt_camera_preview_flags_t flags,char *path)
{
CameraList *files;
CameraList *folders;
const char *filename;
const char *foldername;
gp_list_new (&files);
gp_list_new (&folders);
// Process files in current folder...
if( gp_camera_folder_list_files(c->active_camera->gpcam,path,files,c->gpcontext) == GP_OK )
{
for(int i=0; i < gp_list_count(files); i++)
{
gp_list_get_name (files, i, &filename);
char *file = g_strconcat(path, "/", filename, NULL);
// Lets check the type of file...
CameraFileInfo cfi;
if( gp_camera_file_get_info(c->active_camera->gpcam, path, filename,&cfi,c->gpcontext) == GP_OK)
{
CameraFile *preview=NULL;
CameraFile *exif=NULL;
/*
* Fetch image preview if flagged...
*/
if( flags & CAMCTL_IMAGE_PREVIEW_DATA )
{
gp_file_new(&preview);
if( gp_camera_file_get(c->active_camera->gpcam, path, filename, GP_FILE_TYPE_PREVIEW,preview,c->gpcontext) < GP_OK )
{
// No preview for file lets check image size to se if we should download full image for preview...
if( cfi.file.size > 0 && cfi.file.size < 512000 )
if( gp_camera_file_get(c->active_camera->gpcam, path, filename, GP_FILE_TYPE_NORMAL,preview,c->gpcontext) < GP_OK )
{
preview=NULL;
dt_print(DT_DEBUG_CAMCTL,"[camera_control] failed to retreive preview of file %s\n",filename);
}
}
}
if( flags & CAMCTL_IMAGE_EXIF_DATA )
{
gp_file_new(&exif);
if( gp_camera_file_get(c->active_camera->gpcam, path, filename, GP_FILE_TYPE_EXIF,exif,c->gpcontext) < GP_OK )
{
exif=NULL;
dt_print(DT_DEBUG_CAMCTL,"[camera_control] failed to retreive exif of file %s\n",filename);
}
}
// let's dispatch to host app.. return if we should stop...
if (!_dispatch_camera_storage_image_filename(c,c->active_camera,file,preview,exif))
{
g_free(file);
return 0;
}
}
else
dt_print(DT_DEBUG_CAMCTL,"[camera_control] failed to get file information of %s in folder %s on device\n",filename,path);
g_free(file);
}
}
// Recurse into folders in current folder...
if( gp_camera_folder_list_folders(c->active_camera->gpcam,path,folders,c->gpcontext)==GP_OK)
{
for(int i=0; i < gp_list_count(folders); i++)
{
char buffer[4096]= {0};
g_strlcat(buffer,path, 4096);
if(path[1]!='\0') g_strlcat(buffer,"/", 4096);
gp_list_get_name (folders, i, &foldername);
g_strlcat(buffer,foldername, 4096);
if( !_camctl_recursive_get_previews(c,flags,buffer))
return 0;
}
}
gp_list_free (files);
gp_list_free (folders);
return 1;
}
bool photo_camera::photo_camera_capture( photo_image* image )
{
int fd, error_code;
CameraFile *photo_file;
CameraFilePath photo_file_path;
char temp_file_name[20];
// NOP: This gets overridden in the library to /capt0000.jpg
strcpy( photo_file_path.folder, "/" );
strcpy( photo_file_path.name, "foo.jpg" );
error_code = gp_camera_capture( camera_, GP_CAPTURE_IMAGE, &photo_file_path, context_ );
if( error_code < GP_OK )
{
photo_reporter::error( "gp_camera_capture()" );
gp_context_error( context_, "Could not capture image (error code %d)\n", error_code );
return false;
}
// create temporary file
strcpy( temp_file_name, "tmpfileXXXXXX" );
fd = mkstemp( temp_file_name );
error_code = gp_file_new_from_fd( &photo_file, fd );
if( error_code < GP_OK )
{
close( fd );
unlink( temp_file_name );
photo_reporter::error( "gp_file_new_from_fd()" );
gp_context_error( context_, "Could not create a new image file from %s%s (error code %d)\n", photo_file_path.folder, photo_file_path.name, error_code );
gp_file_free( photo_file );
return false;
}
// get image from camera and store in temporary file
error_code = gp_camera_file_get( camera_, photo_file_path.folder, photo_file_path.name, GP_FILE_TYPE_NORMAL, photo_file, context_ );
if( error_code < GP_OK )
{
gp_file_unref( photo_file );
unlink( temp_file_name );
photo_reporter::error( "gp_camera_file_get()" );
gp_context_error( context_, "Could not get file %s%s (error code %d)\n", photo_file_path.folder, photo_file_path.name, error_code );
return false;
}
// delete image from camera's memory
error_code = gp_camera_file_delete( camera_, photo_file_path.folder, photo_file_path.name, context_ );
if( error_code < GP_OK )
{
unlink( temp_file_name );
photo_reporter::error( "gp_camera_file_delete()" );
gp_context_error( context_, "Could delete file %s%s (error code %d)\n", photo_file_path.folder, photo_file_path.name, error_code );
gp_file_free( photo_file );
return false;
}
// load image from temporary file
if( image->photo_image_read( std::string(temp_file_name) ) == true )
{
gp_file_free( photo_file );
unlink( temp_file_name );
return true;
}
photo_reporter::error( "photo_image_read()" );
gp_file_free( photo_file );
unlink( temp_file_name );
return false;
}
TW_UINT16
_get_gphoto2_file_as_DIB(
const char *folder, const char *filename, CameraFileType type,
HWND hwnd, HBITMAP *hDIB
) {
const unsigned char *filedata;
unsigned long filesize;
int ret;
CameraFile *file;
struct jpeg_source_mgr xjsm;
struct jpeg_decompress_struct jd;
struct jpeg_error_mgr jerr;
HDC dc;
BITMAPINFO bmpInfo;
LPBYTE bits;
JSAMPROW samprow, oldsamprow;
if(!libjpeg_handle) {
if(!load_libjpeg()) {
FIXME("Failed reading JPEG because unable to find %s\n", SONAME_LIBJPEG);
filedata = NULL;
return TWRC_FAILURE;
}
}
gp_file_new (&file);
ret = gp_camera_file_get(activeDS.camera, folder, filename, type, file, activeDS.context);
if (ret < GP_OK) {
FIXME("Failed to get file?\n");
gp_file_unref (file);
return TWRC_FAILURE;
}
ret = gp_file_get_data_and_size (file, (const char**)&filedata, &filesize);
if (ret < GP_OK) {
FIXME("Failed to get file data?\n");
return TWRC_FAILURE;
}
/* FIXME: Actually we might get other types than JPEG ... But only handle JPEG for now */
if (filedata[0] != 0xff) {
ERR("File %s/%s might not be JPEG, cannot decode!\n", folder, filename);
}
/* This is basically so we can use in-memory data for jpeg decompression.
* We need to have all the functions.
*/
xjsm.next_input_byte = filedata;
xjsm.bytes_in_buffer = filesize;
xjsm.init_source = _jpeg_init_source;
xjsm.fill_input_buffer = _jpeg_fill_input_buffer;
xjsm.skip_input_data = _jpeg_skip_input_data;
xjsm.resync_to_restart = _jpeg_resync_to_restart;
xjsm.term_source = _jpeg_term_source;
jd.err = pjpeg_std_error(&jerr);
/* jpeg_create_decompress is a macro that expands to jpeg_CreateDecompress - see jpeglib.h
* jpeg_create_decompress(&jd); */
pjpeg_CreateDecompress(&jd, JPEG_LIB_VERSION, (size_t) sizeof(struct jpeg_decompress_struct));
jd.src = &xjsm;
ret=pjpeg_read_header(&jd,TRUE);
jd.out_color_space = JCS_RGB;
pjpeg_start_decompress(&jd);
if (ret != JPEG_HEADER_OK) {
ERR("Jpeg image in stream has bad format, read header returned %d.\n",ret);
gp_file_unref (file);
return TWRC_FAILURE;
}
ZeroMemory (&bmpInfo, sizeof (BITMAPINFO));
bmpInfo.bmiHeader.biSize = sizeof (BITMAPINFOHEADER);
bmpInfo.bmiHeader.biWidth = jd.output_width;
bmpInfo.bmiHeader.biHeight = -jd.output_height;
bmpInfo.bmiHeader.biPlanes = 1;
bmpInfo.bmiHeader.biBitCount = jd.output_components*8;
bmpInfo.bmiHeader.biCompression = BI_RGB;
bmpInfo.bmiHeader.biSizeImage = 0;
bmpInfo.bmiHeader.biXPelsPerMeter = 0;
bmpInfo.bmiHeader.biYPelsPerMeter = 0;
bmpInfo.bmiHeader.biClrUsed = 0;
bmpInfo.bmiHeader.biClrImportant = 0;
*hDIB = CreateDIBSection ((dc = GetDC(hwnd)), &bmpInfo, DIB_RGB_COLORS, (LPVOID)&bits, 0, 0);
if (!*hDIB) {
FIXME("Failed creating DIB.\n");
gp_file_unref (file);
return TWRC_FAILURE;
}
samprow = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,jd.output_width*jd.output_components);
oldsamprow = samprow;
while ( jd.output_scanline<jd.output_height ) {
int i, x = pjpeg_read_scanlines(&jd,&samprow,1);
if (x != 1) {
FIXME("failed to read current scanline?\n");
break;
}
/* We have to convert from RGB to BGR, see MSDN/ BITMAPINFOHEADER */
for(i=0;i<jd.output_width;i++,samprow+=jd.output_components) {
*(bits++) = *(samprow+2);
*(bits++) = *(samprow+1);
*(bits++) = *(samprow);
}
bits = (LPBYTE)(((UINT_PTR)bits + 3) & ~3);
samprow = oldsamprow;
}
if (hwnd) ReleaseDC (hwnd, dc);
HeapFree (GetProcessHeap(), 0, samprow);
gp_file_unref (file);
return TWRC_SUCCESS;
}
static void _camera_process_job(const dt_camctl_t *c,const dt_camera_t *camera, gpointer job)
{
dt_camera_t *cam=(dt_camera_t *)camera;
_camctl_camera_job_t *j = (_camctl_camera_job_t *)job;
switch( j->type )
{
case _JOB_TYPE_EXECUTE_CAPTURE:
{
dt_print (DT_DEBUG_CAMCTL,"[camera_control] executing remote camera capture job\n");
CameraFilePath fp;
int res=GP_OK;
if( (res = gp_camera_capture (camera->gpcam, GP_CAPTURE_IMAGE,&fp, c->gpcontext)) == GP_OK )
{
CameraFile *destination;
const char *output_path = _dispatch_request_image_path(c,camera);
if( !output_path ) output_path="/tmp";
const char *fname = _dispatch_request_image_filename(c,fp.name,cam);
if( !fname ) fname=fp.name;
char *output = g_build_filename (output_path,fname,(char *)NULL);
int handle = open (output, O_CREAT | O_WRONLY,0666);
gp_file_new_from_fd (&destination , handle);
gp_camera_file_get (camera->gpcam, fp.folder , fp.name, GP_FILE_TYPE_NORMAL, destination, c->gpcontext);
close (handle);
// Notify listerners of captured image
_dispatch_camera_image_downloaded (c,camera,output);
g_free (output);
}
else
dt_print (DT_DEBUG_CAMCTL,"[camera_control] capture job failed to capture image: %s\n",gp_result_as_string(res));
}
break;
case _JOB_TYPE_EXECUTE_LIVE_VIEW:
{
CameraFile *fp = NULL;
int res = GP_OK;
const gchar* data = NULL;
unsigned long int data_size = 0;
gp_file_new(&fp);
if( (res = gp_camera_capture_preview (cam->gpcam, fp, c->gpcontext)) != GP_OK )
{
dt_print (DT_DEBUG_CAMCTL,"[camera_control] live view failed to capture preview: %s\n", gp_result_as_string(res));
}
else if( (res = gp_file_get_data_and_size(fp, &data, &data_size)) != GP_OK )
{
dt_print (DT_DEBUG_CAMCTL,"[camera_control] live view failed to get preview data: %s\n", gp_result_as_string(res));
}
else
{
// everything worked
GdkPixbufLoader *loader = gdk_pixbuf_loader_new();
if(gdk_pixbuf_loader_write(loader, (guchar*)data, data_size, NULL) == TRUE)
{
dt_pthread_mutex_lock(&cam->live_view_pixbuf_mutex);
if(cam->live_view_pixbuf != NULL)
g_object_unref(cam->live_view_pixbuf);
cam->live_view_pixbuf = gdk_pixbuf_loader_get_pixbuf(loader);
dt_pthread_mutex_unlock(&cam->live_view_pixbuf_mutex);
}
gdk_pixbuf_loader_close(loader, NULL);
}
if(fp)
gp_file_free(fp);
dt_pthread_mutex_unlock(&cam->live_view_synch);
dt_control_queue_redraw_center();
}
break;
case _JOB_TYPE_SET_PROPERTY:
{
_camctl_camera_set_property_job_t *spj=(_camctl_camera_set_property_job_t *)job;
dt_print(DT_DEBUG_CAMCTL,"[camera_control] executing set camera config job %s=%s\n",spj->name,spj->value);
CameraWidget *config; // Copy of camera configuration
CameraWidget *widget;
gp_camera_get_config( cam->gpcam, &config, c->gpcontext );
if( gp_widget_get_child_by_name ( config, spj->name, &widget) == GP_OK)
{
gp_widget_set_value ( widget , spj->value);
gp_camera_set_config( cam->gpcam, config, c->gpcontext );
}
/* dt_pthread_mutex_lock( &cam->config_lock );
CameraWidget *widget;
if( gp_widget_get_child_by_name ( camera->configuration, spj->name, &widget) == GP_OK) {
gp_widget_set_value ( widget , spj->value);
//gp_widget_set_changed( widget, 1 );
cam->config_changed=TRUE;
}
dt_pthread_mutex_unlock( &cam->config_lock);*/
}
break;
default:
dt_print(DT_DEBUG_CAMCTL,"[camera_control] process of unknown job type %lx\n",(unsigned long int)j->type);
break;
}
g_free(j);
}
static TW_UINT16 _get_image_and_startup_jpeg(void) {
const char *folder = NULL, *filename = NULL;
struct gphoto2_file *file;
const unsigned char *filedata;
unsigned long filesize;
int ret;
if (activeDS.file) /* Already loaded. */
return TWRC_SUCCESS;
if(!libjpeg_handle) {
if(!load_libjpeg()) {
FIXME("Failed reading JPEG because unable to find %s\n", SONAME_LIBJPEG);
filedata = NULL;
return TWRC_FAILURE;
}
}
LIST_FOR_EACH_ENTRY( file, &activeDS.files, struct gphoto2_file, entry ) {
if (strstr(file->filename,".JPG") || strstr(file->filename,".jpg")) {
filename = file->filename;
folder = file->folder;
TRACE("downloading %s/%s\n", folder, filename);
if (file->download) {
file->download = FALSE; /* mark as done */
break;
}
}
}
gp_file_new (&activeDS.file);
ret = gp_camera_file_get(activeDS.camera, folder, filename, GP_FILE_TYPE_NORMAL,
activeDS.file, activeDS.context);
if (ret < GP_OK) {
FIXME("Failed to get file?\n");
activeDS.twCC = TWCC_SEQERROR;
return TWRC_FAILURE;
}
ret = gp_file_get_data_and_size (activeDS.file, (const char**)&filedata, &filesize);
if (ret < GP_OK) {
FIXME("Failed to get file data?\n");
activeDS.twCC = TWCC_SEQERROR;
return TWRC_FAILURE;
}
/* This is basically so we can use in-memory data for jpeg decompression.
* We need to have all the functions.
*/
activeDS.xjsm.next_input_byte = filedata;
activeDS.xjsm.bytes_in_buffer = filesize;
activeDS.xjsm.init_source = _jpeg_init_source;
activeDS.xjsm.fill_input_buffer = _jpeg_fill_input_buffer;
activeDS.xjsm.skip_input_data = _jpeg_skip_input_data;
activeDS.xjsm.resync_to_restart = _jpeg_resync_to_restart;
activeDS.xjsm.term_source = _jpeg_term_source;
activeDS.jd.err = pjpeg_std_error(&activeDS.jerr);
/* jpeg_create_decompress is a macro that expands to jpeg_CreateDecompress - see jpeglib.h
* jpeg_create_decompress(&jd); */
pjpeg_CreateDecompress(&activeDS.jd, JPEG_LIB_VERSION, (size_t) sizeof(struct jpeg_decompress_struct));
activeDS.jd.src = &activeDS.xjsm;
ret=pjpeg_read_header(&activeDS.jd,TRUE);
activeDS.jd.out_color_space = JCS_RGB;
pjpeg_start_decompress(&activeDS.jd);
if (ret != JPEG_HEADER_OK) {
ERR("Jpeg image in stream has bad format, read header returned %d.\n",ret);
gp_file_unref (activeDS.file);
activeDS.file = NULL;
return TWRC_FAILURE;
}
return TWRC_SUCCESS;
}
static gboolean
get_thumbnail_idle (gpointer data)
{
GtkamList *list = GTKAM_LIST (data);
GetThumbnailData *d;
CameraFile *file;
GtkWidget *s;
GdkPixbuf *pixbuf;
GdkPixbufLoader *loader;
int result;
const char *fd;
unsigned long fs;
gfloat factor;
d = list->priv->head;
if (d == NULL)
return (FALSE);
s = gtkam_status_new (_("Downloading thumbnail of '%s' from "
"folder '%s'..."), d->name, d->folder);
g_signal_emit (G_OBJECT (list), signals[NEW_STATUS], 0, s);
gp_file_new (&file);
result = gp_camera_file_get (d->camera->camera, d->folder, d->name,
GP_FILE_TYPE_PREVIEW, file,
GTKAM_STATUS (s)->context->context);
if (d->camera->multi)
gp_camera_exit (d->camera->camera, NULL);
if (result >= 0) {
gp_file_get_data_and_size (file, &fd, &fs);
loader = gdk_pixbuf_loader_new ();
gdk_pixbuf_loader_write (loader, fd, fs, NULL);
gdk_pixbuf_loader_close (loader, NULL);
pixbuf = gdk_pixbuf_loader_get_pixbuf (loader);
gtk_list_store_set (list->priv->store, d->iter,
PREVIEW_ORIG_COLUMN, pixbuf, -1);
factor = gtkam_list_get_zoom_factor (list);
pixbuf = gdk_pixbuf_scale_simple (pixbuf,
gdk_pixbuf_get_width (pixbuf) * factor,
gdk_pixbuf_get_height (pixbuf) * factor,
GDK_INTERP_BILINEAR);
g_object_unref (G_OBJECT (loader));
gtk_list_store_set (list->priv->store, d->iter,
PREVIEW_COLUMN, pixbuf, -1);
g_object_unref (G_OBJECT (pixbuf));
}
gp_file_unref (file);
gtk_object_destroy (GTK_OBJECT (s));
if (result == GP_ERROR_CAMERA_BUSY)
return (TRUE);
g_object_unref (G_OBJECT (d->camera));
g_free (d->name);
g_free (d->folder);
gtk_tree_iter_free (d->iter);
list->priv->head = d->next;
g_free (d);
if (!list->priv->head)
list->priv->tail = NULL;
gtk_widget_destroy (s);
if (list->priv->head == NULL)
return (FALSE);
else
return (TRUE);
}
bool GPCamera::getMetadata(const QString& folder, const QString& itemName, DMetadata& meta)
{
#ifdef HAVE_GPHOTO2
int errorCode;
CameraFile* cfile = 0;
const char* data = 0;
unsigned long int size;
gp_file_new(&cfile);
d->status->cancel = false;
errorCode = gp_camera_file_get(d->camera, QFile::encodeName(folder).constData(),
QFile::encodeName(itemName).constData(),
GP_FILE_TYPE_EXIF,
cfile, d->status->context);
if (errorCode != GP_OK)
{
qCDebug(DIGIKAM_IMPORTUI_LOG) << "Failed to get camera item!";
printGphotoErrorDescription(errorCode);
gp_file_unref(cfile);
return false;
}
errorCode = gp_file_get_data_and_size(cfile, &data, &size);
if (errorCode != GP_OK)
{
qCDebug(DIGIKAM_IMPORTUI_LOG) << "Failed to get Exif data from camera item!";
printGphotoErrorDescription(errorCode);
gp_file_unref(cfile);
return false;
}
QByteArray exifData(data, size);
gp_file_unref(cfile);
// Sometimes, GPhoto2 drivers return complete APP1 JFIF section. Exiv2 cannot
// decode (yet) exif metadata from APP1. We will find Exif header to get data at this place
// to please with Exiv2...
qCDebug(DIGIKAM_IMPORTUI_LOG) << "Size of Exif metadata from camera = " << exifData.size();
if (!exifData.isEmpty())
{
char exifHeader[] = { 0x45, 0x78, 0x69, 0x66, 0x00, 0x00 };
int i = exifData.indexOf(*exifHeader);
if (i != -1)
{
qCDebug(DIGIKAM_IMPORTUI_LOG) << "Exif header found at position " << i;
i = i + sizeof(exifHeader);
QByteArray data;
data.resize(exifData.size() - i);
memcpy(data.data(), exifData.data() + i, data.size());
meta.setExif(data);
return true;
}
}
return false;
#else
Q_UNUSED(folder);
Q_UNUSED(itemName);
Q_UNUSED(meta);
return false;
#endif /* HAVE_GPHOTO2 */
}
bool GPCamera::downloadItem(const QString& folder, const QString& itemName,
const QString& saveFile)
{
#ifdef HAVE_GPHOTO2
int errorCode;
CameraFile* cfile = 0;
d->status->cancel = false;
QFile file(saveFile);
if (!file.open(QIODevice::ReadWrite))
{
qCDebug(DIGIKAM_IMPORTUI_LOG) << "Failed to open file" << file.fileName() << file.errorString();
return false;
}
// dup fd, passing fd control to gphoto2 later
int handle = dup(file.handle());
if (handle == -1)
{
qCDebug(DIGIKAM_IMPORTUI_LOG) << "Failed to dup file descriptor";
return false;
}
errorCode = gp_file_new_from_fd(&cfile, handle);
if (errorCode != GP_OK)
{
qCDebug(DIGIKAM_IMPORTUI_LOG) << "Failed to get camera item!";
printGphotoErrorDescription(errorCode);
return false;
}
errorCode = gp_camera_file_get(d->camera, QFile::encodeName(folder).constData(),
QFile::encodeName(itemName).constData(),
GP_FILE_TYPE_NORMAL, cfile,
d->status->context);
if (errorCode != GP_OK)
{
qCDebug(DIGIKAM_IMPORTUI_LOG) << "Failed to get camera item!";
printGphotoErrorDescription(errorCode);
gp_file_unref(cfile);
return false;
}
time_t mtime;
errorCode = gp_file_get_mtime(cfile, &mtime);
if (errorCode == GP_OK && mtime)
{
struct utimbuf ut;
ut.modtime = mtime;
ut.actime = mtime;
::utime(QFile::encodeName(saveFile).constData(), &ut);
}
file.close();
gp_file_unref(cfile);
return true;
#else
Q_UNUSED(folder);
Q_UNUSED(itemName);
Q_UNUSED(saveFile);
return false;
#endif /* HAVE_GPHOTO2 */
}
bool photoController::capture(const char *filename)
{
if(checkCameraDetection() == false)
{
DEBUG_PRINTF(V_WARNING, "No camera detected.\n");
return false;
}
int fd, retval;
CameraFile *file;
CameraFilePath camera_file_path;
START_CHRONOMETER();
DEBUG_PRINTF(V_MESSAGE, "Deleting old files.\n");
retval = gp_camera_folder_delete_all(camera, "/", context);
if(retval != GP_OK) // Error.
{
DEBUG_PRINTF(V_WARNING, "ERROR: Couldn't delete old files in camera memory. Code: %d\n", retval);
return false;
}
DEBUG_PRINTF(V_MESSAGE, "Camera capture.\n");
retval = gp_camera_capture(camera, GP_CAPTURE_IMAGE, &camera_file_path, context);
if(retval != GP_OK) // Error.
{
if(retval == GP_ERROR_NOT_SUPPORTED)
DEBUG_PRINTF(V_WARNING, "ERROR: This camera can not capture.\n");
else
{
DEBUG_PRINTF(V_WARNING, "ERROR: Unexpected gp_camera_capture return. Code: %d\n", retval);
releaseCamera(&camera, context);
camera_detected = false;
initCamera();
}
return false;
}
DEBUG_PRINTF(V_MESSAGE, "camera_file_path.folder %s!\n", camera_file_path.folder);
DEBUG_PRINTF(V_MESSAGE, "Open %s!\n", filename);
fd = open(filename, O_CREAT | O_WRONLY, 0644);
if(fd < 0) // Error.
{
DEBUG_PRINTF(V_WARNING, "Error opening file: %s!\n", strerror(errno));
return false;
}
DEBUG_PRINTF(V_MESSAGE, "Create new CameraFile object from a file descriptor FD: %d.\n", fd);
retval = gp_file_new_from_fd(&file, fd);
if(retval != GP_OK) // Error.
{
DEBUG_PRINTF(V_WARNING, "ERROR: Unexpected gp_file_new_from_fd return. Code: %d\n", retval);
gp_file_free(file);
close(fd);
return false;
}
if(checkCameraDetection() == false)
{
DEBUG_PRINTF(V_WARNING, "No camera detected 2.\n");
gp_file_free(file);
close(fd);
return false;
}
DEBUG_PRINTF(V_MESSAGE, "Copy file from camera.\n");
retval = gp_camera_file_get(camera, camera_file_path.folder, camera_file_path.name, GP_FILE_TYPE_NORMAL, file, context);
if(retval != GP_OK) // Error.
{
if(retval == GP_ERROR_DIRECTORY_NOT_FOUND)
DEBUG_PRINTF(V_WARNING, "Photo directory not found.\n");
else if(retval == GP_ERROR_FILE_NOT_FOUND)
DEBUG_PRINTF(V_WARNING, "Photo file name not found.\n");
else
DEBUG_PRINTF(V_WARNING, "ERROR: Unexpected gp_camera_file_get return. Code: %d\n", retval);
gp_file_free(file);
close(fd);
return false;
}
if(checkCameraDetection() == false)
{
DEBUG_PRINTF(V_WARNING, "No camera detected 3.\n");
gp_file_free(file);
close(fd);
return false;
}
DEBUG_PRINTF(V_MESSAGE, "Delete file from camera.\n");
retval = gp_camera_file_delete(camera, camera_file_path.folder, camera_file_path.name, context);
if(retval != GP_OK) // Error.
{
DEBUG_PRINTF(V_WARNING, "ERROR: Unexpected gp_camera_file_delete return. Code: %d\n", retval);
gp_file_free(file);
close(fd);
return false;
}
DEBUG_PRINTF(V_MESSAGE, "Free CameraFile object.\n");
gp_file_unref(file);
close(fd);
cv::Mat raw = cv::imread(filename);
if(raw.data == NULL)
{
DEBUG_PRINTF(V_WARNING, "ERROR: OpenCV failed to open image file.\n");
return false;
}
cv::Size raw_size = raw.size();
DEBUG_PRINTF(V_MESSAGE, "capture() cv::Mat total=%u width=%d height=%d refcount=%d\n", raw.total(), raw_size.width, raw_size.height, (int)(void*)raw.refcount);
crop(raw);
raw.release();
STOP_CHRONOMETER("Capture");
return true;
}
