/*
* Only need to reset the generic camera type, AFAICT -
* the pocket digital never seems to need it.
*/
static int
ultrapocket_reset(Camera *camera)
{
GPPortInfo oldpi;
GPPort *port = camera->port;
CameraAbilities cab;
unsigned char cmdbuf[0x10];
gp_camera_get_abilities(camera, &cab);
GP_DEBUG ("First connect since camera was used - need to reset cam");
/*
* this resets the ultrapocket. Messy, but it's what the windows
* software does. We only reset if it's been plugged in since
* last reset.
*/
memset(cmdbuf, 0, 16);
cmdbuf[0] = 0x28;
cmdbuf[1] = 0x01;
CHECK_RESULT(ultrapocket_command(port, 1, cmdbuf, 0x10));
/* -------------- */
sleep(4); /* This should do - _might_ need increasing */
CHECK_RESULT(gp_port_get_info(port, &oldpi));
CHECK_RESULT(gp_port_free(port));
CHECK_RESULT(gp_port_new(&port));
CHECK_RESULT(gp_port_set_info(port, oldpi));
CHECK_RESULT(gp_port_usb_find_device(port,
cab.usb_vendor, cab.usb_product));
CHECK_RESULT(gp_port_open(port));
camera->port = port;
return GP_OK;
}
static gboolean
show_thumbnails_foreach_func (GtkTreeModel *model, GtkTreePath *path,
GtkTreeIter *iter, gpointer data)
{
GtkamList *list = GTKAM_LIST (data);
GtkamCamera *camera;
gchar *folder, *name;
CameraAbilities a;
GetThumbnailData *d;
camera = gtkam_list_get_camera_from_iter (list, iter);
folder = gtkam_list_get_folder_from_iter (list, iter);
name = gtkam_list_get_name_from_iter (list, iter);
gp_camera_get_abilities (camera->camera, &a);
if (a.file_operations & GP_FILE_OPERATION_PREVIEW) {
d = g_new0 (GetThumbnailData, 1);
d->camera = camera;
g_object_ref (G_OBJECT (camera));
d->folder = g_strdup (folder);
d->name = g_strdup (name);
d->iter = gtk_tree_iter_copy (iter);
if (list->priv->tail)
((GetThumbnailData*) list->priv->tail)->next = d;
list->priv->tail = d;
if (list->priv->head == NULL)
list->priv->head = d;
}
g_free (folder);
g_free (name);
return (FALSE);
}
void
gtkam_chooser_set_camera (GtkamChooser *chooser, GtkamCamera *camera)
{
CameraAbilities a;
GPPortInfo info;
gchar *full_info;
#ifdef HAVE_GP_PORT_INFO_GET_NAME
char *xname,*xpath;
#endif
g_return_if_fail (GTKAM_IS_CHOOSER (chooser));
g_return_if_fail (GTKAM_IS_CAMERA (camera));
gp_camera_get_abilities (camera->camera, &a);
gp_camera_get_port_info (camera->camera, &info);
#ifdef HAVE_GP_PORT_INFO_GET_NAME
gp_port_info_get_name (info, &xname);
gp_port_info_get_path (info, &xpath);
full_info = g_strdup_printf ("%s (%s)", xname, xpath);
#else
full_info = g_strdup_printf ("%s (%s)", info.name, info.path);
#endif
gtk_entry_set_text (chooser->priv->entry_port, full_info);
g_free (full_info);
gtk_entry_set_text (chooser->priv->entry_model, a.model);
gtk_toggle_button_set_active (
GTK_TOGGLE_BUTTON (chooser->priv->check_multi), camera->multi);
chooser->priv->needs_update = FALSE;
gtk_widget_set_sensitive (chooser->apply_button, FALSE);
}
int
camera_init(Camera *camera, GPContext *context)
{
GPPortSettings settings;
CameraAbilities abilities;
int ret = 0;
/* First, set up all the function pointers */
camera->functions->summary = camera_summary;
camera->functions->about = camera_about;
camera->functions->exit = camera_exit;
GP_DEBUG ("Initializing the camera\n");
ret = gp_port_get_settings(camera->port,&settings);
if (ret < 0) return ret;
ret = gp_camera_get_abilities(camera,&abilities);
if (ret < 0) return ret;
GP_DEBUG("product number is 0x%x\n", abilities.usb_product);
switch (camera->port->type) {
case GP_PORT_SERIAL:
return ( GP_ERROR );
case GP_PORT_USB:
settings.usb.config = 1;
settings.usb.altsetting = 0;
settings.usb.interface = 1;
settings.usb.inep = 0x84;
settings.usb.outep =0x05;
break;
default:
return ( GP_ERROR );
}
ret = gp_port_set_settings(camera->port,settings);
if (ret < 0) return ret;
GP_DEBUG("interface = %i\n", settings.usb.interface);
GP_DEBUG("inep = %x\n", settings.usb.inep);
GP_DEBUG("outep = %x\n", settings.usb.outep);
/* Tell the CameraFilesystem where to get lists from */
gp_filesystem_set_funcs (camera->fs, &fsfuncs, camera);
camera->pl = malloc (sizeof (CameraPrivateLibrary));
if (!camera->pl) return GP_ERROR_NO_MEMORY;
memset (camera->pl, 0, sizeof (CameraPrivateLibrary));
switch(abilities.usb_product) {
case 0x2130:
camera->pl->model = AOX_MODEL_DMAX;
break;
default:
camera->pl->model = AOX_MODEL_MINI;
}
/* Connect to the camera */
aox_init (camera->port, &camera->pl->model, camera->pl->info);
return GP_OK;
}
/*
* 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 */
CAMLprim
value caml_gp_camera_get_abilities(value cam_val) {
CAMLparam1(cam_val);
Camera *cam = Camera_val(cam_val);
CameraAbilities *abil = malloc(sizeof(*abil));
int ret = gp_camera_get_abilities(cam, abil);
CHECK_RESULT(ret);
CAMLreturn(encapsulate_pointer(abil));
}
int
camera_init (Camera *camera, GPContext *context)
{
CameraAbilities a;
int ret;
char *dump, buf[256];
/* First, set up all the function pointers */
camera->functions->exit = camera_exit;
camera->functions->summary = camera_summary;
camera->functions->manual = camera_manual;
camera->functions->about = camera_about;
camera->functions->get_config = camera_get_config;
camera->functions->set_config = camera_set_config;
/* Tell the CameraFilesystem where to get lists from */
gp_filesystem_set_funcs (camera->fs, &fsfuncs, camera);
camera->pl = calloc (1, sizeof(CameraPrivateLibrary));
if (!camera->pl) return GP_ERROR_NO_MEMORY;
ret = gp_setting_get("tp6801", "syncdatetime", buf);
if (ret == GP_OK)
camera->pl->syncdatetime = buf[0] == '1';
else
camera->pl->syncdatetime = 1;
CHECK (gp_camera_get_abilities(camera, &a))
dump = getenv("GP_TP6801_DUMP");
if (dump)
ret = tp6801_open_dump (camera, dump);
else
ret = tp6801_open_device (camera);
if (ret != GP_OK) {
camera_exit (camera, context);
return ret;
}
if (camera->pl->syncdatetime) {
struct tm tm;
time_t t;
t = time (NULL);
if (localtime_r (&t , &tm)) {
ret = tp6801_set_time_and_date (camera, &tm);
if (ret != GP_OK) {
camera_exit (camera, context);
return ret;
}
}
}
return GP_OK;
}
int
camera_init (Camera *camera, GPContext *context)
{
CameraAbilities cab;
up_badge_type badge;
camera->functions->exit = camera_exit;
camera->functions->about = camera_about;
gp_filesystem_set_funcs (camera->fs, &fsfuncs, camera);
badge = BADGE_UNKNOWN;
gp_camera_get_abilities(camera, &cab);
switch (cab.usb_vendor) {
case USB_VENDOR_ID_SMAL:
case USB_VENDOR_ID_CREATIVE:
switch (cab.usb_product) {
case USB_DEVICE_ID_ULTRAPOCKET:
/* could be an axia eyeplate or a slimshot
* figure it out later, when we get the image
* catalogue.
*/
badge = BADGE_GENERIC;
break;
case USB_DEVICE_ID_FLATFOTO:
badge = BADGE_FLATFOTO;
break;
case USB_DEVICE_ID_CARDCAM:
badge = BADGE_CARDCAM;
break;
default:
break;
}
break;
case USB_VENDOR_ID_LOGITECH:
switch (cab.usb_product) {
case USB_DEVICE_ID_POCKETDIGITAL:
badge = BADGE_LOGITECH_PD;
break;
default:
break;
}
break;
default:
break;
}
if (badge == BADGE_UNKNOWN) {
/* can't happen. Otherwise, how'd we get to camera_init, neh? */
return GP_ERROR;
}
camera->pl = malloc (sizeof (CameraPrivateLibrary));
camera->pl->up_type = badge;
/* don't need to do any exciting init stuff until we get pic numbers */
return GP_OK;
}
static int
camera_capture (Camera *camera, CameraCaptureType type,
CameraFilePath * path, GPContext *context)
{
struct SPCA50xFile *file;
CameraAbilities a;
/* Not all our cameras support capture */
gp_camera_get_abilities (camera, &a);
if (!a.operations & GP_OPERATION_CAPTURE_IMAGE)
return GP_ERROR_NOT_SUPPORTED;
if (cam_has_flash(camera->pl))
{
int fc;
char tmp [14];
CHECK(spca500_flash_capture (camera->pl));
CHECK(spca50x_flash_get_TOC (camera->pl, &fc));
/* assume new pic is the last one in the cam...*/
CHECK(spca50x_flash_get_file_name (camera->pl, (fc - 1), tmp));
/* Add new image name to file list */
/* NOTE: these lines moved from below */
strncpy (path->name, tmp, sizeof (path->name) - 1);
path->name[sizeof (path->name) - 1] = '\0';
}
else
{
CHECK (spca50x_capture (camera->pl));
CHECK (spca50x_sdram_get_info (camera->pl));
CHECK (spca50x_sdram_get_file_info
(camera->pl, camera->pl->num_files_on_sdram - 1, &file));
/* Add new image name to file list */
/* NOTE: these lines moved from below */
strncpy (path->name, file->name, sizeof (path->name) - 1);
path->name[sizeof (path->name) - 1] = '\0';
}
/* Now tell the frontend where to look for the image */
strncpy (path->folder, "/", sizeof (path->folder) - 1);
path->folder[sizeof (path->folder) - 1] = '\0';
CHECK (gp_filesystem_append
(camera->fs, path->folder, path->name, context));
return GP_OK;
}
static GnomeVFSResult do_create (
GnomeVFSMethod *method,
GnomeVFSMethodHandle **handle,
GnomeVFSURI *uri,
GnomeVFSOpenMode mode,
gboolean exclusive,
guint perm,
GnomeVFSContext *context)
{
Camera *camera;
CameraAbilities a;
FileHandle *file_handle;
GnomeVFSResult result;
G_LOCK (cameras);
result = get_camera (uri, &camera);
if (result != GNOME_VFS_OK) {
G_UNLOCK (cameras);
return (result);
}
gp_camera_get_abilities (camera, &a);
if (!(a.folder_operations & GP_FOLDER_OPERATION_PUT_FILE)) {
unref_camera (camera);
G_UNLOCK (cameras);
return (GNOME_VFS_ERROR_NOT_SUPPORTED);
}
/* Construct the file handle */
file_handle = g_new0 (FileHandle, 1);
file_handle->camera = camera;
gp_file_new (&(file_handle->file));
file_handle->create = TRUE;
file_handle->dirname = gnome_vfs_uri_extract_dirname (uri);
file_handle->preview = (camera_uri_get_user_name (uri) != NULL);
*handle = (GnomeVFSMethodHandle *) file_handle;
G_UNLOCK (cameras);
return (GNOME_VFS_OK);
}
static int
get_camera_model(Camera *camera, SonyModel *model)
{
CameraAbilities a;
int rc;
rc = gp_camera_get_abilities (camera, &a);
if (rc == GP_OK) {
int i;
rc = GP_ERROR;
for (i = 0; i < sizeof(models) / sizeof(models[i]); i++) {
if (model_compare(models[i].model_str,
a.model)) {
rc = GP_OK;
*model = models[i].model_id;
break;
}
}
}
return rc;
}
static int
camera_get_config (Camera *camera, CameraWidget **window, GPContext *context)
{
CameraWidget *section, *widget;
CameraAbilities abilities;
GPPortSettings settings;
int i;
char * wvalue;
char stringbuffer[12];
dc210_status status;
if (dc210_get_status(camera, &status) == GP_ERROR) return GP_ERROR;
gp_widget_new (GP_WIDGET_WINDOW, _("Camera Configuration"), window);
gp_widget_new (GP_WIDGET_SECTION, _("File"), §ion);
gp_widget_append (*window, section);
gp_widget_new (GP_WIDGET_RADIO, _("File type"), &widget);
gp_widget_append (section, widget);
gp_widget_add_choice (widget, _("JPEG"));
gp_widget_add_choice (widget, _("FlashPix"));
switch (status.file_type){
case DC210_FILE_TYPE_JPEG:
gp_widget_set_value (widget, _("JPEG")); break;
case DC210_FILE_TYPE_FPX:
gp_widget_set_value (widget, _("FlashPix")); break;
};
gp_widget_get_value (widget, &wvalue);
gp_widget_new (GP_WIDGET_RADIO, _("File resolution"), &widget);
gp_widget_append (section, widget);
gp_widget_add_choice (widget, _("640 x 480"));
gp_widget_add_choice (widget, _("1152 x 864"));
switch (status.resolution){
case DC210_FILE_640:
gp_widget_set_value (widget, _("640 x 480")); break;
case DC210_FILE_1152:
gp_widget_set_value (widget, _("1152 x 864")); break;
default:
DC210_DEBUG("Undefined value for file resolution.\n"); break;
};
gp_widget_get_value (widget, &wvalue);
gp_widget_new (GP_WIDGET_MENU, _("File compression"), &widget);
gp_widget_append (section, widget);
gp_widget_add_choice (widget, _("Low (best quality)"));
gp_widget_add_choice (widget, _("Medium (better quality)"));
gp_widget_add_choice (widget, _("High (good quality)"));
switch (status.compression_type){
case DC210_LOW_COMPRESSION:
gp_widget_set_value (widget, _("Low (best quality)")); break;
case DC210_MEDIUM_COMPRESSION:
gp_widget_set_value (widget, _("Medium (better quality)")); break;
case DC210_HIGH_COMPRESSION:
gp_widget_set_value (widget, _("High (good quality)")); break;
};
gp_widget_get_value (widget, &wvalue);
gp_widget_new (GP_WIDGET_SECTION, _("Capture"), §ion);
gp_widget_append (*window, section);
gp_widget_new (GP_WIDGET_MENU, _("Zoom"), &widget);
gp_widget_append (section, widget);
gp_widget_add_choice (widget, "58 mm"); /* no need to translate strings with SI units! */
gp_widget_add_choice (widget, "51 mm");
gp_widget_add_choice (widget, "41 mm");
gp_widget_add_choice (widget, "34 mm");
gp_widget_add_choice (widget, "29 mm");
gp_widget_add_choice (widget, _("Macro"));
switch (status.zoom){
case DC210_ZOOM_58:
gp_widget_set_value (widget, _("58 mm")); break;
case DC210_ZOOM_51:
gp_widget_set_value (widget, _("51 mm")); break;
case DC210_ZOOM_41:
gp_widget_set_value (widget, _("41 mm")); break;
case DC210_ZOOM_34:
gp_widget_set_value (widget, _("34 mm")); break;
case DC210_ZOOM_29:
gp_widget_set_value (widget, _("29 mm")); break;
case DC210_ZOOM_MACRO:
gp_widget_set_value (widget, _("Macro")); break;
};
gp_widget_get_value (widget, &wvalue);
gp_widget_new (GP_WIDGET_MENU, _("Exposure compensation"), &widget);
gp_widget_append (section, widget);
for (i = 0; i < sizeof(exp_comp)/sizeof(*exp_comp); i++){
gp_widget_add_choice (widget, exp_comp[i]);
if (status.exp_compensation + 4 == i)
gp_widget_set_value (widget, exp_comp[i]);
};
gp_widget_new (GP_WIDGET_RADIO, _("Flash"), &widget);
gp_widget_append (section, widget);
gp_widget_add_choice (widget, _("Auto"));
gp_widget_add_choice (widget, _("Force"));
gp_widget_add_choice (widget, _("None"));
switch (status.flash){
case DC210_FLASH_AUTO:
gp_widget_set_value (widget, _("Auto")); break;
case DC210_FLASH_FORCE:
gp_widget_set_value (widget, _("Force")); break;
case DC210_FLASH_NONE:
gp_widget_set_value (widget, _("None")); break;
};
gp_widget_get_value (widget, &wvalue);
gp_widget_new (GP_WIDGET_RADIO, _("Red eye flash"), &widget);
gp_widget_append (section, widget);
gp_widget_add_choice (widget, _("On"));
gp_widget_add_choice (widget, _("Off"));
if (status.preflash)
gp_widget_set_value (widget, _("On"));
else
gp_widget_set_value (widget, _("Off"));
gp_widget_get_value (widget, &wvalue);
gp_widget_new (GP_WIDGET_SECTION, _("Other"), §ion);
gp_widget_append (*window, section);
gp_widget_new (GP_WIDGET_BUTTON, "Set time to system time", &widget);
gp_widget_append (section, widget);
gp_widget_set_value (widget, dc210_system_time_callback);
gp_widget_set_info (widget, _("Set clock in camera"));
gp_camera_get_abilities(camera, &abilities);
gp_port_get_settings (camera->port, &settings);
gp_widget_new (GP_WIDGET_MENU, _("Port speed"), &widget);
gp_widget_append (section, widget);
for (i = 0; i < sizeof(abilities.speed); i++){
if (abilities.speed[i] == 0) break;
snprintf(stringbuffer, 12, "%d", abilities.speed[i]);
gp_widget_add_choice (widget, stringbuffer);
if (settings.serial.speed == abilities.speed[i])
gp_widget_set_value (widget, stringbuffer);
};
gp_widget_new (GP_WIDGET_TEXT, _("Album name"), &widget);
gp_widget_append (section, widget);
gp_widget_set_value (widget, status.album_name);
gp_widget_set_info (widget, _("Name to set on card when formatting."));
gp_widget_new (GP_WIDGET_BUTTON, _("Format compact flash"), &widget);
gp_widget_append (section, widget);
gp_widget_set_value (widget, dc210_format_callback);
gp_widget_set_info (widget, _("Format card and set album name."));
#ifdef DEBUG
gp_widget_new (GP_WIDGET_SECTION, _("Debug"), §ion);
gp_widget_append (*window, section);
gp_widget_new (GP_WIDGET_TEXT, "Parameter 1", &widget);
gp_widget_append (section, widget);
gp_widget_set_value (widget, "0");
gp_widget_new (GP_WIDGET_TEXT, "Parameter 2", &widget);
gp_widget_append (section, widget);
gp_widget_set_value (widget, "0");
gp_widget_new (GP_WIDGET_TEXT, "Parameter 3", &widget);
gp_widget_append (section, widget);
gp_widget_set_value (widget, "0");
gp_widget_new (GP_WIDGET_BUTTON, "Execute debug command", &widget);
gp_widget_append (section, widget);
gp_widget_set_value (widget, dc210_debug_callback);
gp_widget_set_info (widget, _("Execute predefined command\nwith parameter values."));
#endif
return GP_OK;
}
static gint
on_button_press_event (GtkWidget *widget, GdkEventButton *event,
GtkamList *list)
{
GtkTreePath *path = NULL;
GtkWidget *w;
GtkamCamera *camera;
CameraAbilities a;
switch (event->button) {
case 3:
if (!gtk_tree_view_get_path_at_pos (GTK_TREE_VIEW (list),
event->x, event->y, &path, NULL, NULL, NULL))
return (FALSE);
gtk_tree_model_get_iter (GTK_TREE_MODEL (list->priv->store),
&list->priv->iter, path);
gtk_tree_path_free (path);
camera = gtkam_list_get_camera_from_iter (list,
&list->priv->iter);
gp_camera_get_abilities (camera->camera, &a);
/* What operations does the camera support? */
w = gtk_item_factory_get_widget (list->priv->factory,
"/Delete");
gtk_widget_set_sensitive (w,
(a.file_operations & GP_FILE_OPERATION_DELETE));
#ifdef HAVE_BONOBO
{
Bonobo_ServerInfoList *l;
guint i;
GtkWidget *item, *c;
CORBA_Environment ev;
CameraFileInfo finfo;
gchar *fo, *fi, *query;
ViewAsData *d;
GList *cl;
w = gtk_item_factory_get_widget (list->priv->factory, "/View with...");
c = gtk_item_factory_get_widget (list->priv->factory,
"/View with.../Built-in viewer");
cl = gtk_container_get_children (GTK_CONTAINER (w));
for (i = 0; i < g_list_length (cl); i++) {
if (g_list_nth_data (cl, i) != c)
gtk_container_remove (GTK_CONTAINER (w),
GTK_WIDGET (g_list_nth_data (cl, i)));
}
fo = gtkam_list_get_folder_from_iter (list, &list->priv->iter);
fi = gtkam_list_get_name_from_iter (list, &list->priv->iter);
gp_camera_file_get_info (camera->camera, fo, fi, &finfo, NULL);
g_free (fo);
g_free (fi);
if (finfo.file.fields & GP_FILE_INFO_TYPE) {
CORBA_exception_init (&ev);
query = g_strconcat ("repo_ids.has ('IDL:Bonobo/Control:1.0') AND "
"bonobo:supported_mime_types.has ('",
finfo.file.type, "')", NULL);
l = bonobo_activation_query (query, NULL, &ev);
g_free (query);
CORBA_exception_free (&ev);
if (l && l->_length) {
for (i = 0; i < l->_length; i++) {
Bonobo_ServerInfo *si = &l->_buffer[i];
const gchar *n;
if (!si->iid)
continue;
n = bonobo_server_info_prop_lookup (si, "name", NULL);
if (!n)
n = si->iid;
item = gtk_menu_item_new_with_label (n);
gtk_widget_show (item);
gtk_menu_shell_append (GTK_MENU_SHELL (w), item);
d = g_new0 (ViewAsData, 1);
d->list = list;
d->camera = camera;
g_object_ref (G_OBJECT (d->camera));
d->folder = gtkam_list_get_folder_from_iter (list,
&list->priv->iter);
d->file = gtkam_list_get_name_from_iter (list,
&list->priv->iter);
d->iid = g_strdup (si->iid);
g_signal_connect (G_OBJECT (item), "activate",
G_CALLBACK (on_view_as_activate), d);
g_signal_connect (G_OBJECT (item), "destroy",
G_CALLBACK (on_menu_item_destroy), d);
}
}
if (l)
CORBA_free (l);
}
}
#endif
gtk_item_factory_popup (list->priv->factory, event->x_root,
event->y_root, event->button, event->time);
return (TRUE);
default:
return (FALSE);
}
}
int
camera_init (Camera *camera, GPContext *context)
{
int ret = 0;
int x = 0;
char *model;
GPPortSettings settings;
CameraAbilities abilities;
/* First, set up all the function pointers */
camera->functions->exit = camera_exit;
camera->functions->summary = camera_summary;
camera->functions->about = camera_about;
camera->functions->capture = camera_capture;
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_sdram = 1;
camera->pl->dirty_flash = 1;
/* What bridge chip is inside the camera? The gsmart mini is spca500
* based, while the others have a spca50xa */
gp_camera_get_abilities (camera, &abilities);
model = models[x].model;
while (model) {
if (abilities.usb_vendor == models[x].usb_vendor
&& abilities.usb_product == models[x].usb_product) {
int same;
char *m = strdup( models[x].model );
char *p = strchr (m, ':' );
if (p) *p = ' ';
same = !strcmp (m, abilities.model);
free (m);
if (same) {
camera->pl->bridge = models[x].bridge;
camera->pl->storage_media_mask =
models[x].storage_media_mask;
break;
}
}
model = models[++x].model;
}
CHECK (spca50x_get_firmware_revision (camera->pl));
if (camera->pl->fw_rev > 1) {
CHECK (spca50x_detect_storage_type (camera->pl));
}
if (cam_has_flash(camera->pl) || cam_has_card(camera->pl) ) {
if ((camera->pl->bridge == BRIDGE_SPCA504) ||
(camera->pl->bridge == BRIDGE_SPCA504B_PD))
CHECK (spca50x_flash_init (camera->pl, context));
}
if ((camera->pl->bridge == BRIDGE_SPCA504) ||
(camera->pl->bridge == BRIDGE_SPCA504B_PD)) {
/* if (abilities.usb_vendor != 0x04fc && abilities.usb_product != 0x504a ) */
if (!(abilities.usb_vendor == 0x04fc && abilities.usb_product == 0x504a ))
ret = spca50x_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);
}
int
camera_init (Camera *camera, GPContext *context)
{
CameraAbilities a;
int i, ret;
char *dump, buf[256];
/* First, set up all the function pointers */
camera->functions->exit = camera_exit;
camera->functions->summary = camera_summary;
camera->functions->manual = camera_manual;
camera->functions->about = camera_about;
camera->functions->get_config = camera_get_config;
camera->functions->set_config = camera_set_config;
/* Tell the CameraFilesystem where to get lists from */
gp_filesystem_set_funcs (camera->fs, &fsfuncs, camera);
camera->pl = calloc (1, sizeof(CameraPrivateLibrary));
if (!camera->pl) return GP_ERROR_NO_MEMORY;
ret = gp_setting_get("ax203", "syncdatetime", buf);
if (ret == GP_OK)
camera->pl->syncdatetime = buf[0] == '1';
else
camera->pl->syncdatetime = 1;
CHECK (gp_camera_get_abilities(camera, &a))
for (i = 0; ax203_devinfo[i].vendor_id; i++) {
if ((a.usb_vendor == ax203_devinfo[i].vendor_id) &&
(a.usb_product == ax203_devinfo[i].product_id)) {
camera->pl->frame_version =
ax203_devinfo[i].frame_version;
break;
}
}
if (!ax203_devinfo[i].vendor_id) {
gp_log (GP_LOG_ERROR, "ax203", "Unknown USB ID");
camera_exit (camera, context);
return GP_ERROR_BAD_PARAMETERS;
}
dump = getenv("GP_AX203_DUMP");
if (dump)
ret = ax203_open_dump (camera, dump);
else
ret = ax203_open_device (camera);
if (ret != GP_OK) {
camera_exit (camera, context);
return ret;
}
GP_DEBUG ("ax203 memory size: %d, free: %d",
ax203_get_mem_size (camera),
ax203_get_free_mem_size (camera));
if (camera->pl->syncdatetime) {
struct tm tm;
time_t t;
t = time (NULL);
if (localtime_r (&t , &tm)) {
ret = ax203_set_time_and_date (camera, &tm);
if (ret != GP_OK) {
camera_exit (camera, context);
return ret;
}
}
}
return GP_OK;
}
int camera_init(Camera *camera, GPContext *context) {
GPPortSettings settings;
CameraAbilities a;
int ret = 0;
/* First, set up all the function pointers */
camera->functions->exit = camera_exit;
camera->functions->summary = camera_summary;
camera->functions->about = camera_about;
camera->functions->capture = camera_capture;
GP_DEBUG ("Initializing the camera\n");
switch (camera->port->type) {
case GP_PORT_USB:
ret=gp_port_get_settings(camera->port,&settings);
if (ret<0) return ret;
/* Use the defaults the core parsed */
ret=gp_port_set_settings(camera->port,settings);
if (ret<0) return ret;
break;
case GP_PORT_SERIAL:
return GP_ERROR_IO_SUPPORTED_SERIAL;
default:
return GP_ERROR_NOT_SUPPORTED;
}
/* Set up camera private library */
camera->pl = malloc (sizeof (CameraPrivateLibrary));
if (!camera->pl) return (GP_ERROR_NO_MEMORY);
memset (camera->pl, 0, sizeof (CameraPrivateLibrary));
camera->pl->gpdev = camera->port;
/* Set up the sub-architectures */
/* Default to Agfa. Should we default otherwise? */
camera->pl->device_type=SOUNDVISION_AGFACL18;
gp_camera_get_abilities (camera, &a);
if ((a.usb_vendor==0x0919) && (a.usb_product==0x0100)) {
camera->pl->device_type=SOUNDVISION_TIGERFASTFLICKS;
}
if ((a.usb_vendor==0x0784) && (a.usb_product==0x0100)) {
camera->pl->device_type=SOUNDVISION_IXLA;
}
/* Keep track. We _must_ reset an even number of times */
camera->pl->reset_times=0;
camera->pl->odd_command=0;
/* Reset the camera */
ret = soundvision_reset (camera->pl,NULL,NULL);
if (ret < 0) {
free (camera->pl);
camera->pl = NULL;
return (ret);
}
/* Tell the CameraFilesystem where to get lists from */
return gp_filesystem_set_funcs (camera->fs, &fsfuncs, camera);
}
