int photo_camera::photo_camera_find_widget_by_name( std::string name, CameraWidget **child, CameraWidget **root)
{
int error_code;
// Get camera configuration
error_code = gp_camera_get_config( camera_, root, context_ );
if (error_code != GP_OK)
{
photo_reporter::error( "gp_camera_get_config()");
return error_code;
}
// Find child of configuration by name
if( gp_widget_get_child_by_name( *root, name.c_str(), child ) == GP_OK )
{
return GP_OK;
}
// Find child of configuration by label
if( gp_widget_get_child_by_label( *root, name.c_str(), child ) == GP_OK )
{
return GP_OK;
}
// If full name is not found, search for last subname.
// name delimeter is '/'
size_t found_index = name.length();
while( found_index == name.length() )
{
found_index = name.rfind( '/' );
if( found_index == std::string::npos ) // No subname, we already failed this search above
{
gp_context_error( context_,"%s not found in configuration tree.", name.c_str() );
gp_widget_free( *root );
return GP_ERROR;
}
if( found_index == name.length() - 1 ) // end of string, cut it off
{
name = name.substr( 0, found_index );
}
}
name = name.substr( found_index, name.length() - 1 );
// Find child using
if( gp_widget_get_child_by_name( *root, name.c_str(), child ) == GP_OK )
{
return GP_OK;
}
if( gp_widget_get_child_by_label( *root, name.c_str(), child ) == GP_OK )
{
return GP_OK;
}
// all matches have failed
gp_context_error( context_, "%s not found in configuration tree.", name.c_str() );
gp_widget_free( *root );
return GP_ERROR;
}
static int file_list_func (CameraFilesystem *fs, const char *folder, CameraList *list, void *data, GPContext *context) {
Camera *camera = data;
int count;
/* We only support root folder */
if (strcmp (folder, "/"))
{
gp_context_error (context, _("Only root folder is supported - "
"you requested a file listing for folder '%s'."), folder);
return (GP_ERROR_DIRECTORY_NOT_FOUND);
}
count = mesa_get_image_count (camera->port);
if (count < 0)
{
gp_context_error (context, _("Problem getting number of images"));
return (count);
}
/*
* Create pseudo file names for each picture in the camera, including
* the temporary picture in RAM, which, unfortunately, might not always
* be available.
*
* We don't add anything to the filesystem here - the filesystem does
* that for us.
*/
CHECK (gp_filesystem_append (fs, "/", RAM_IMAGE_TEMPLATE, context));
return (gp_list_populate (list, IMAGE_NAME_TEMPLATE, count));
}
/* Download a live image from the camera and return it in a malloced
buffer with PGM headers */
static uint8_t *
Dimera_Preview( long *size, Camera *camera, GPContext *context )
{
uint8_t buffer[VIEWFIND_SZ/2], *p;
int i;
uint8_t *image;
uint32_t exposure_total;
unsigned brightness;
if ( !(image = (unsigned char *) malloc( VIEWFIND_SZ +
sizeof( Dimera_viewhdr ) - 1 )) )
{
ERROR( "Get Preview, allocation failed" );
gp_context_error (context, _("Out of memory"));
return NULL;
}
/* set image size */
*size = VIEWFIND_SZ + sizeof( Dimera_viewhdr ) - 1;
/* set image header */
memcpy( image, Dimera_viewhdr, sizeof( Dimera_viewhdr ) - 1 );
if ( mesa_snap_view( camera->port, buffer, TRUE, 0, 0, 0, camera->pl->exposure,
VIEW_TYPE) < 0 )
{
ERROR( "Get Preview, mesa_snap_view failed" );
free (image);
gp_context_error (context, _("Problem taking live image"));
return NULL;
}
/* copy the buffer, splitting the pixels up */
exposure_total = 0;
for ( p = image + sizeof( Dimera_viewhdr ) - 1, i = 0;
i < (VIEWFIND_SZ/2) ; i++ )
{
*p++ = buffer[i] >> 4;
*p++ = buffer[i] & 0xf;
exposure_total += (buffer[i] >> 4) + (buffer[i] & 0xf);
}
/* Automatic exposure control */
/* Current picture brightness, where 0 is is dark and 255 is bright */
brightness = exposure_total / (VIEWFIND_SZ / 16);
GP_DEBUG(
"Average pixel brightness %f, Current exposure value: %d",
brightness / 16.0, camera->pl->exposure);
if (camera->pl->auto_exposure && (brightness < 96 || brightness > 160)) {
/* Picture brightness needs to be corrected for next time */
camera->pl->exposure = calc_new_exposure(camera->pl->exposure, brightness);
GP_DEBUG( "New exposure value: %d", camera->pl->exposure);
}
return image;
}
/*
* Capture an image
*/
static int
camera_capture (Camera* camera, CameraCaptureType type, CameraFilePath* path,
GPContext *context)
{
unsigned char cmd[3], buf[256], ack;
int ret, nbr_images,images_taken,i;
GP_DEBUG ("*** ENTER: camera_capture ***");
/* Just check if there is space available yet */
cmd[0] = ESC;
cmd[1] = GETCAMINFO;
ret = gp_port_write (camera->port, (char*)cmd, 2);
if (ret<GP_OK)
return ret;
ret = gp_port_read (camera->port, (char*)buf, INFO_BUFFER);
nbr_images = (buf[FREE_IMAGE_PTR] << 8) | (buf[FREE_IMAGE_PTR+1]);
images_taken = (buf[TAKEN_IMAGE_PTR] << 8) | (buf[TAKEN_IMAGE_PTR+1]);
/* Capture the image */
cmd[0] = ESC;
cmd[1] = CAPTUREIMAGE_CMD1;
cmd[2] = CAPTUREIMAGE_CMD2;
ret = gp_port_write (camera->port, (char*)cmd, sizeof(cmd));
if (ret<GP_OK)
return ret;
ret = gp_port_read (camera->port, (char*)&ack, ACK_LEN);
if (ret<GP_OK)
return ret;
if (ack == NACK) {
if (buf[CAMERA_MODE_PTR] != REC_MODE)
gp_context_error(context, _("You must be in record "
"mode to capture images."));
else if (!nbr_images)
gp_context_error(context, _("No space available "
"to capture new images. You must delete some "
"images."));
else
gp_context_error(context, _("Can't capture new images. "
"Unknown error"));
return (GP_ERROR);
}
/* Wait image writting in camera's memory */
for (i=0; i<=15; i++) {
sleep(1);
if ((ret = k_ping(camera->port)) == GP_OK)
break;
}
if (ret < GP_OK) {
gp_context_error(context, _("No answer from the camera."));
return (GP_ERROR);
}
/* Now register new image */
images_taken++;
sprintf (path->name, FILENAME, (unsigned int) images_taken);
return (GP_OK);
}
int
camera_init (Camera *camera, GPContext *context)
{
int ret;
GPPortSettings settings;
/* First, set up all the function pointers */
camera->functions->exit = camera_exit;
camera->functions->summary = camera_summary;
camera->functions->about = camera_about;
CHECK (gp_port_get_settings (camera->port, &settings));
switch (camera->port->type) {
case GP_PORT_USB:
settings.usb.inep = 0x82;
settings.usb.outep = 0x03;
settings.usb.config = 1;
settings.usb.interface = 0;
settings.usb.altsetting = 0;
CHECK (gp_port_set_settings (camera->port, settings));
CHECK (gp_port_set_timeout (camera->port, TIMEOUT));
break;
default:
gp_context_error (context,
_("Unsupported port type: %d. "
"This driver only works with USB "
"cameras.\n"), camera->port->type);
return (GP_ERROR);
break;
}
camera->pl = malloc (sizeof (CameraPrivateLibrary));
if (!camera->pl)
return (GP_ERROR_NO_MEMORY);
memset (camera->pl, 0, sizeof (CameraPrivateLibrary));
camera->pl->gpdev = camera->port;
camera->pl->dirty = 1;
ret = gsmart300_reset (camera->pl);
if (ret < 0) {
gp_context_error (context, _("Could not reset camera.\n"));
free (camera->pl);
camera->pl = NULL;
return (ret);
}
/* Set up the CameraFilesystem */
return gp_filesystem_set_funcs (camera->fs, &fsfuncs, camera);
}
bool photo_camera::photo_camera_capture_to_file( std::string filename )
{
int fd, error_code;
CameraFile *photo_file;
CameraFilePath photo_file_path;
// 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;
}
fd = open( filename.c_str(), O_CREAT|O_WRONLY, 0644 );
error_code = gp_file_new_from_fd( &photo_file, fd );
if( error_code < GP_OK )
{
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;
}
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 )
{
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 );
gp_file_free( photo_file );
return false;
}
error_code = gp_camera_file_delete( camera_, photo_file_path.folder, photo_file_path.name, context_ );
if( error_code < GP_OK )
{
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;
}
gp_file_free( photo_file );
return true;
}
/*
* OK, lets get serious !
*/
int
camera_init(Camera *camera,GPContext *context)
{
GPPortSettings settings;
CameraAbilities abilities;
/* try to contact the camera ...*/
/*CR(gp_port_get_settings(camera->port,&settings));*/
camera->functions->about=camera_about;
camera->functions->exit=camera_exit;
gp_port_get_settings(camera->port,&settings);
if (camera->port->type!=GP_PORT_USB)
{
gp_context_error(context,_("sx330z is USB only"));
return(GP_ERROR_UNKNOWN_PORT);
}
/* GP_DEBUG("camera_init : in = %x",camera->port->settings.usb.inep);*/
CR(gp_port_set_settings(camera->port,settings));
CR(gp_port_set_timeout(camera->port,TIMEOUT));
CR(gp_filesystem_set_funcs(camera->fs, &fsfuncs, camera));
camera->pl=malloc(sizeof(CameraPrivateLibrary));
if (!camera->pl)
return(GP_ERROR_NO_MEMORY);
CR(gp_camera_get_abilities(camera, &abilities));
camera->pl->usb_product=abilities.usb_product; /* some models differ in Thumbnail size */
/* GP_DEBUG("sx330z Camera_init : sx init %04x",camera->pl->usb_product); */
return(sx330z_init(camera,context));
} /* camera init */
static int put_file_func (CameraFilesystem *fs, const char *folder, const char *filename,
CameraFileType type, CameraFile *file, void *data, GPContext *context) {
Camera *camera=data;
const char *data_file;
long unsigned int data_size;
/*
* Upload the file to the camera. Use gp_file_get_data_and_size, etc.
*/
GP_DEBUG ("*** put_file_func");
GP_DEBUG ("*** folder: %s", folder);
GP_DEBUG ("*** filename: %s", filename);
gp_file_get_data_and_size (file, &data_file, &data_size);
if ( data_size == 0) {
gp_context_error (context,
_("The file to be uploaded has a null length"));
return GP_ERROR_BAD_PARAMETERS;
}
/* Should check memory here */
/* if (available_memory < data_size) {
gp_context_error (context,
_("Not enough memory available on the memory card"));
return GP_ERROR_NO_MEMORY;
}
*/
tiger_upload_file (camera->pl, filename,data_file,data_size);
return GP_OK;
}
/**
* 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
set_info_func (CameraFilesystem *fs, const char *folder, const char *file,
CameraFileInfo info, void *data, GPContext *context)
{
Camera *camera = data;
char tmp[7];
int p;
unsigned long image_id;
KncCamRes cr;
/* Permissions? */
if (info.file.fields & GP_FILE_INFO_PERMISSIONS) {
strncpy (tmp, file, 6);
tmp[6] = '\0';
image_id = atol (tmp);
if (info.file.permissions & GP_FILE_PERM_DELETE) p = FALSE;
else p = TRUE;
CR (knc_set_prot (camera->pl->c, &cr, image_id,
KNC_SOURCE_CARD, p), context);
CCR (cr, context);
}
/* Name? */
if (info.file.fields & GP_FILE_INFO_NAME) {
gp_context_error (context, _("Your camera does not support "
"changing filenames."));
return (GP_ERROR_NOT_SUPPORTED);
}
return (GP_OK);
}
/*
* Delete all images
*/
static int
delete_all_func (CameraFilesystem *fs, const char *folder, void *data,
GPContext *context)
{
unsigned char cmd[7], ack;
int ret;
Camera *camera = data;
GP_DEBUG ("*** ENTER: delete_all_func ***");
cmd[0] = ESC;
cmd[1] = ERASEIMAGE_CMD1;
cmd[2] = IMAGE_CMD2;
cmd[3] = 0x30;
cmd[4] = 0x30;
cmd[5] = 0x30;
cmd[6] = 0x30;
ret = gp_port_write (camera->port, (char*)cmd, sizeof(cmd));
if (ret<GP_OK) return ret;
ret = gp_port_read (camera->port, (char*)&ack, ACK_LEN);
if (ret<GP_OK) return ret;
if (ack != ACK) {
gp_context_error(context, _("Can't delete all images."));
return (GP_ERROR);
}
return (GP_OK);
}
/*
* Delete one image
* The image mustn't be protected
*/
static int
delete_file_func (CameraFilesystem *fs, const char *folder,
const char *filename, void *data, GPContext *context)
{
Camera *camera = data;
CameraFileInfo file_info;
unsigned char cmd[7], ack;
int image_no;
int ret;
GP_DEBUG ("*** ENTER: delete_file_func ***");
image_no = gp_filesystem_number(fs, folder, filename, context);
if (image_no < 0) return image_no;
image_no++;
ret = k_info_img (image_no, data, (CameraFileInfo *)&file_info,
&image_no);
if (ret < GP_OK)
return ret;
/* Now, check if the image isn't protected */
if (file_info.file.permissions == GP_FILE_PERM_READ) {
gp_context_error(context, _("Image %s is delete protected."),
filename);
return (GP_ERROR);
}
/* Erase the image */
cmd[0] = ESC;
cmd[1] = ERASEIMAGE_CMD1;
cmd[2] = IMAGE_CMD2;
cmd[3] = 0x30 + ((image_no/1000)%10);
cmd[4] = 0x30 + ((image_no/100 )%10);
cmd[5] = 0x30 + ((image_no/10 )%10);
cmd[6] = 0x30 + ( image_no %10);
ret = gp_port_write (camera->port, (char*)cmd, sizeof(cmd));
if (ret<GP_OK) return ret;
ret = gp_port_read (camera->port, (char*)&ack, ACK_LEN);
if (ret<GP_OK) return ret;
if (ack != ACK) {
gp_context_error(context, _("Can't delete image %s."),filename);
return (GP_ERROR);
}
return (GP_OK);
}
static int
pre_func (Camera *camera, GPContext *context)
{
int r;
unsigned int i;
GPPortSettings settings;
GP_DEBUG ("Initializing connection...");
CR (gp_port_get_settings (camera->port, &settings));
CR (fuji_ping (camera, context));
if (!camera->pl->speed) {
/* Set to the highest possible speed. */
for (i = 0; Speeds[i].bit_rate; i++) {
r = fuji_set_speed (camera, Speeds[i].speed, NULL);
if (r >= 0)
break;
}
/*
* Change the port's speed and check if the camera is
* still there.
*/
settings.serial.speed = Speeds[i].bit_rate;
CR (gp_port_set_settings (camera->port, settings));
GP_DEBUG("Pinging to check new speed %i.", Speeds[i].bit_rate);
CR (fuji_ping (camera, context));
} else {
/* User specified a speed. Check if the speed is possible */
for (i = 0; Speeds[i].bit_rate; i++)
if (Speeds[i].bit_rate == camera->pl->speed)
break;
if (!Speeds[i].bit_rate) {
gp_context_error (context, _("Bit rate %ld is not "
"supported."), camera->pl->speed);
return (GP_ERROR_NOT_SUPPORTED);
}
/* Change the speed if necessary. */
if (camera->pl->speed != Speeds[i].bit_rate) {
CR (fuji_set_speed (camera, Speeds[i].speed, context));
/*
* Change the port's speed and check if the camera is
* still there.
*/
settings.serial.speed = Speeds[i].bit_rate;
CR (gp_port_set_settings (camera->port, settings));
CR (fuji_ping (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;
unsigned char *data = NULL;
long unsigned data_len = 0;
int res;
if(camera->pl->context)
{
gp_context_error(context, CONTEXT_EXISTS);
return GP_ERROR;
}
camera->pl->context = context;
if(check_last_use(camera) == GP_ERROR)
{
camera->pl->context = NULL;
return GP_ERROR;
}
switch (type) {
case GP_FILE_TYPE_PREVIEW:
res = dc3200_get_data (camera, &data, &data_len,
CMD_GET_PREVIEW, folder, filename);
break;
case GP_FILE_TYPE_NORMAL:
res = dc3200_get_data (camera, &data, &data_len,
CMD_GET_FILE, folder, filename);
break;
default:
camera->pl->context = NULL;
return (GP_ERROR_NOT_SUPPORTED);
}
if (res < 0)
{
camera->pl->context = NULL;
return (res);
}
if (data == NULL || data_len < 1)
{
camera->pl->context = NULL;
return GP_ERROR;
}
gp_file_append (file, (char *)data, data_len);
free(data);
camera->pl->context = NULL;
return (dc3200_keep_alive(camera));
}
static int camera_exit (Camera *camera, GPContext *context)
{
if (camera->pl) {
if(camera->pl->context) {
gp_context_error(context, CONTEXT_EXISTS);
return GP_ERROR;
}
free (camera->pl);
camera->pl = NULL;
}
return GP_OK;
}
/**
* Triggers capture of one or more images.
*
* @param camera a #Camera
* @param context a #GPContext
* @return a gphoto2 error code
*
* This functions just remotely causes the shutter release and returns
* immediately. You will want to run #gp_camera_wait_event until a image
* is added which can be downloaded using #gp_camera_file_get.
**/
int
gp_camera_trigger_capture (Camera *camera, GPContext *context)
{
C_PARAMS (camera);
CHECK_INIT (camera, context);
if (!camera->functions->trigger_capture) {
gp_context_error (context, _("This camera can not trigger capture."));
CAMERA_UNUSED (camera, context);
return (GP_ERROR_NOT_SUPPORTED);
}
CHECK_RESULT_OPEN_CLOSE (camera, camera->functions->trigger_capture (camera,
context), context);
CAMERA_UNUSED (camera, context);
return (GP_OK);
}
/**
* Retrieve a configuration \c window for the \c camera.
*
* @param camera a #Camera
* @param window a #CameraWidget
* @param context a #GPContext
* @return gphoto2 error code
*
* This \c window can be used for construction of a configuration dialog.
*
*/
int
gp_camera_get_config (Camera *camera, CameraWidget **window, GPContext *context)
{
C_PARAMS (camera);
CHECK_INIT (camera, context);
if (!camera->functions->get_config) {
gp_context_error (context, _("This camera does "
"not provide any configuration options."));
CAMERA_UNUSED (camera, context);
return (GP_ERROR_NOT_SUPPORTED);
}
CHECK_RESULT_OPEN_CLOSE (camera, camera->functions->get_config (
camera, window, context), context);
CAMERA_UNUSED (camera, context);
return (GP_OK);
}
/**
* Sets the configuration.
*
* @param camera a #Camera
* @param window a #CameraWidget
* @param context a #GPContext
* @return a gphoto2 error code
*
* Typically, a \c window is retrieved using #gp_camera_get_config and passed
* to this function in order to adjust the settings on the camera.
*
**/
int
gp_camera_set_config (Camera *camera, CameraWidget *window, GPContext *context)
{
CHECK_NULL (camera && window);
CHECK_INIT (camera, context);
if (!camera->functions->set_config) {
gp_context_error (context, _("This camera does "
"not support setting configuration options."));
CAMERA_UNUSED (camera, context);
return (GP_ERROR_NOT_SUPPORTED);
}
CHECK_RESULT_OPEN_CLOSE (camera, camera->functions->set_config (camera,
window, context), context);
CAMERA_UNUSED (camera, context);
return (GP_OK);
}
/**
* Retrieves a camera summary.
*
* @param camera a #Camera
* @param summary a #CameraText
* @param context a #GPContext
* @return a gphoto2 error code
*
* This summary typically contains information like manufacturer, pictures
* taken, or generally information that is not configurable.
*
**/
int
gp_camera_get_summary (Camera *camera, CameraText *summary, GPContext *context)
{
CHECK_NULL (camera && summary);
CHECK_INIT (camera, context);
if (!camera->functions->summary) {
gp_context_error (context, _("This camera does "
"not support summaries."));
CAMERA_UNUSED (camera, context);
return (GP_ERROR_NOT_SUPPORTED);
}
CHECK_RESULT_OPEN_CLOSE (camera, camera->functions->summary (camera,
summary, context), context);
CAMERA_UNUSED (camera, context);
return (GP_OK);
}
/**
* Retrieves the \c manual for given \c camera.
*
* @param camera a #Camera
* @param manual a #CameraText
* @param context a #GPContext
* @return a gphoto2 error code
*
* This manual typically contains information about using the camera.
*
**/
int
gp_camera_get_manual (Camera *camera, CameraText *manual, GPContext *context)
{
CHECK_NULL (camera && manual);
CHECK_INIT (camera, context);
if (!camera->functions->manual) {
gp_context_error (context, _("This camera "
"does not offer a manual."));
CAMERA_UNUSED (camera, context);
return (GP_ERROR_NOT_SUPPORTED);
}
CHECK_RESULT_OPEN_CLOSE (camera, camera->functions->manual (camera,
manual, context), context);
CAMERA_UNUSED (camera, context);
return (GP_OK);
}
/**
* Retrieves information about the camera driver.
*
* @param camera a #Camera
* @param about a #CameraText
* @param context a #GPContext
* @return a gphoto2 error code
*
* Typically, this information contains name and address of the author,
* acknowledgements, etc.
*
**/
int
gp_camera_get_about (Camera *camera, CameraText *about, GPContext *context)
{
CHECK_NULL (camera && about);
CHECK_INIT (camera, context);
if (!camera->functions->about) {
gp_context_error (context, _("This camera does "
"not provide information about the driver."));
CAMERA_UNUSED (camera, context);
return (GP_ERROR_NOT_SUPPORTED);
}
CHECK_RESULT_OPEN_CLOSE (camera, camera->functions->about (camera,
about, context), context);
CAMERA_UNUSED (camera, context);
return (GP_OK);
}
/**
* Captures an image, movie, or sound clip depending on the given \c type.
*
* @param camera a #Camera
* @param type a #CameraCaptureType
* @param path a #CameraFilePath
* @param context a #GPContext
* @return a gphoto2 error code
*
* The resulting file will be stored on the camera. The location gets stored
* in \c path. The file can then be downloaded using #gp_camera_file_get.
*
**/
int
gp_camera_capture (Camera *camera, CameraCaptureType type,
CameraFilePath *path, GPContext *context)
{
CHECK_NULL (camera);
CHECK_INIT (camera, context);
if (!camera->functions->capture) {
gp_context_error (context, _("This camera can not capture."));
CAMERA_UNUSED (camera, context);
return (GP_ERROR_NOT_SUPPORTED);
}
CHECK_RESULT_OPEN_CLOSE (camera, camera->functions->capture (camera,
type, path, context), context);
CAMERA_UNUSED (camera, context);
return (GP_OK);
}
static int
get_info_func (CameraFilesystem *fs, const char *folder, const char *file,
CameraFileInfo *info, void *data, GPContext *context)
{
char path[1024];
const char *mime_type;
struct stat st;
Camera *camera = (Camera*)data;
int result;
gp_log (GP_LOG_DEBUG, "directory/get_info_func", "%s %s", folder, file);
result = _get_path (camera->port, folder, file, path, sizeof(path));
if (result < GP_OK)
return result;
if (lstat (path, &st) != 0) {
gp_context_error (context, _("Could not get information "
"about '%s' in '%s' (%m)."), file, folder);
return (GP_ERROR);
}
info->preview.fields = GP_FILE_INFO_NONE;
info->file.fields = GP_FILE_INFO_SIZE | GP_FILE_INFO_NAME |
GP_FILE_INFO_TYPE | GP_FILE_INFO_PERMISSIONS |
GP_FILE_INFO_MTIME;
info->file.mtime = st.st_mtime;
info->file.permissions = GP_FILE_PERM_NONE;
if (st.st_mode & S_IRUSR)
info->file.permissions |= GP_FILE_PERM_READ;
if (st.st_mode & S_IWUSR)
info->file.permissions |= GP_FILE_PERM_DELETE;
strcpy (info->file.name, file);
info->file.size = st.st_size;
mime_type = get_mime_type (file);
if (!mime_type)
mime_type = "application/octet-stream";
strcpy (info->file.type, mime_type);
return (GP_OK);
}
/**
* 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)
{
CHECK_NULL (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);
CAMERA_UNUSED (camera, context);
return (GP_OK);
}
static int
delete_file_func (CameraFilesystem *fs, const char *folder,
const char *file, void *data, GPContext *context)
{
char path[2048];
int result;
Camera *camera = (Camera*)data;
result = _get_path (camera->port, folder, file, path, sizeof(path));
if (result < GP_OK)
return result;
result = unlink (path);
if (result) {
gp_context_error (context, _("Could not delete file '%s' "
"in folder '%s' (error code %i: %m)."),
file, folder, result);
return (GP_ERROR);
}
return (GP_OK);
}
int
gp_camera_list_config (Camera *camera, CameraList *list, GPContext *context)
{
CameraWidget *rootwidget;
int ret;
C_PARAMS (camera);
CHECK_INIT (camera, context);
if (camera->functions->list_config) {
CHECK_RESULT_OPEN_CLOSE (camera, camera->functions->list_config (
camera, list, context), context);
CAMERA_UNUSED (camera, context);
return GP_OK;
}
if (!camera->functions->get_config) {
gp_context_error (context, _("This camera does not provide any configuration options."));
CAMERA_UNUSED (camera, context);
return GP_ERROR_NOT_SUPPORTED;
}
/* emulate it ... */
CHECK_OPEN (camera, context);
ret = camera->functions->get_config ( camera, &rootwidget, context);
if (ret != GP_OK) {
CHECK_CLOSE (camera, context);
CAMERA_UNUSED (camera, context);
return ret;
}
_get_widget_names (rootwidget, list);
gp_widget_free (rootwidget);
CHECK_CLOSE (camera, context);
CAMERA_UNUSED (camera, context);
return ret;
}
static int camera_capture (Camera *camera, CameraCaptureType type, CameraFilePath *path, GPContext *context) {
if (type != GP_CAPTURE_IMAGE)
{
gp_context_error (context, _("Capture type is not supported"));
return (GP_ERROR_NOT_SUPPORTED);
}
if (camera->pl->auto_flash) {
CHECK (mesa_snap_picture( camera->port, camera->pl->exposure*4 ));
}
else {
CHECK (mesa_snap_image( camera->port, camera->pl->exposure*4 ));
}
/*
* User must download special RAM_IMAGE_TEMPLATE file.
*/
strncpy (path->folder, "/", sizeof (path->folder));
strncpy (path->name, RAM_IMAGE_TEMPLATE, sizeof (path->name));
return (GP_OK);
}
static int
delete_all_func (CameraFilesystem *fs, const char* folder, void *data,
GPContext *context)
{
Camera *camera = data;
unsigned int not_erased = 0;
KncCamRes cr;
if (strcmp (folder, "/")) return (GP_ERROR_DIRECTORY_NOT_FOUND);
CR (knc_erase_all (camera->pl->c, &cr, KNC_SOURCE_CARD, ¬_erased),
context);
CCR (cr, context);
if (not_erased) {
gp_context_error (context, _("%i pictures could not be "
"deleted because they are protected"), not_erased);
gp_filesystem_reset (camera->fs);
return (GP_ERROR);
}
return (GP_OK);
}
int camera_init (Camera *camera, GPContext *context)
{
GPPortSettings settings;
int ret;
/* First, set up all the function pointers */
camera->functions->summary = camera_summary;
camera->functions->about = camera_about;
camera->functions->capture_preview = camera_capture_preview;
camera->functions->capture = camera_capture;
gp_port_get_settings(camera->port, &settings);
switch(camera->port->type) {
case GP_PORT_USB:
/* Modify the default settings the core parsed */
settings.usb.altsetting=1;/* we need to use interface 0 setting 1 */
settings.usb.inep=2;
settings.usb.intep=3;
settings.usb.outep=5;
/* Use the defaults the core parsed */
break;
default:
return (GP_ERROR_UNKNOWN_PORT);
break;
}
ret = gp_port_set_settings (camera->port, settings);
if (ret != GP_OK) {
gp_context_error (context, _("Could not apply USB settings"));
return ret;
}
/* Set up the filesystem */
gp_filesystem_set_funcs (camera->fs, &fsfuncs, camera);
/* test camera */
return stv0674_ping(camera->port);
}
static int get_info_func (CameraFilesystem *fs, const char *folder, const char *filename, CameraFileInfo *info, void *data, GPContext *context) {
Camera *camera = data;
int num, std_res;
num = gp_filesystem_number (fs, folder, filename, context);
if (num < 0)
return num;
if ( (std_res = mesa_read_image_info( camera->port, num, NULL )) < 0 )
{
ERROR("Can't get Image Info");
gp_context_error (context, _("Problem getting image information"));
return std_res;
}
info->preview.fields = GP_FILE_INFO_ALL;
strcpy(info->preview.type, GP_MIME_PGM);
info->preview.size = MESA_THUMB_SZ + sizeof( Dimera_thumbhdr ) - 1;
info->preview.width = 64;
info->preview.height = 48;
info->file.fields = GP_FILE_INFO_TYPE|GP_FILE_INFO_PERMISSIONS|GP_FILE_INFO_WIDTH|GP_FILE_INFO_HEIGHT|GP_FILE_INFO_SIZE;
strcpy(info->file.type, GP_MIME_PPM);
info->file.permissions = GP_FILE_PERM_READ;
if (std_res) {
info->file.width = 320;
info->file.height = 240;
} else {
info->file.width = 640;
info->file.height = 480;
}
info->file.size = info->file.height*info->file.width*3 + sizeof( Dimera_finehdr ) - 1;
return GP_OK;
}
