static int
compare_lists (void)
{
unsigned int errors = 0;
CameraAbilitiesList *ddb = read_abilities_list(NULL);
CameraAbilitiesList *clb;
unsigned int i, j, n_ddb, n_clb;
gp_abilities_list_new(&clb);
gp_abilities_list_load(clb, NULL);
n_ddb = gp_abilities_list_count(ddb);
n_clb = gp_abilities_list_count(clb);
fprintf(stderr, "## Comparing ddb with clb ##\n");
for (i=0, j=0; (i<n_ddb) && (j<n_clb); ) {
CameraAbilities a, b;
gp_abilities_list_get_abilities(ddb, i, &a);
gp_abilities_list_get_abilities(clb, j, &b);
if ((b.port & GP_PORT_USB) && (b.usb_class == 666)) {
/* ignore this camera */
j++;
continue;
}
if (compare_camera_abilities(&a, &b)) {
errors++;
}
i++, j++;
}
gp_abilities_list_free(clb);
gp_abilities_list_free(ddb);
return (errors == 0)? 0 : 1;
}
void
gtkam_chooser_set_camera_mask (GtkamChooser *chooser,
CameraOperation operations)
{
GtkWidget *dialog;
CameraAbilities a;
GList *list = NULL;
guint i;
int n;
g_return_if_fail (GTKAM_IS_CHOOSER (chooser));
n = gp_abilities_list_count (chooser->priv->al);
if (n < 0) {
dialog = gtkam_error_new (n, NULL, GTK_WIDGET (chooser),
_("Could not get number of "
"supported camera models"));
gtk_widget_show (dialog);
return;
}
/* Search for models that fulfil the criteria */
for (i = 0; i < n; i++) {
gp_abilities_list_get_abilities (chooser->priv->al, i, &a);
if (!operations || (a.operations & operations))
list = g_list_append (list, g_strdup (a.model));
}
gtkam_chooser_set_model_list (chooser, list);
}
static void
gtkam_chooser_update_for_model (GtkamChooser *chooser)
{
const gchar *model;
int m, result, i;
CameraAbilities a;
GtkWidget *dialog;
GList *list;
/* Get abilities of selected model */
model = gtk_entry_get_text (chooser->priv->entry_model);
if (!model || !*model)
return;
m = gp_abilities_list_lookup_model (chooser->priv->al, model);
result = gp_abilities_list_get_abilities (chooser->priv->al, m, &a);
if (result < 0) {
dialog = gtkam_error_new (result, NULL, GTK_WIDGET (chooser),
_("Could not get abilities of model '%s'."), model);
gtk_widget_show (dialog);
return;
}
/* Update port combo */
gtkam_chooser_set_port_mask (chooser, a.port);
/* Update speed combo */
list = g_list_append (NULL, _("Best"));
for (i = 0; a.speed[i]; i++)
list = g_list_append (list, g_strdup_printf ("%i", a.speed[i]));
gtk_combo_set_popdown_strings (chooser->priv->combo_speed, list);
gtk_widget_set_sensitive (GTK_WIDGET (chooser->priv->combo_speed),
!(a.port == GP_PORT_USB));
}
static GNOME_GnoCam_ModelList *
impl_GNOME_GnoCam_getModelList (PortableServer_Servant servant,
CORBA_Environment *ev)
{
GnoCamMain *gm;
GNOME_GnoCam_ModelList *list;
CameraAbilitiesList *al = NULL;
int n, i;
CameraAbilities a;
gm = GNOCAM_MAIN (bonobo_object_from_servant (servant));
gp_abilities_list_new (&al);
gp_abilities_list_load (al, NULL);
n = MAX (0, gp_abilities_list_count (al));
list = GNOME_GnoCam_ModelList__alloc ();
list->_buffer = CORBA_sequence_CORBA_string_allocbuf (n);
for (i = 0; i < n; i++) {
if (gp_abilities_list_get_abilities (al, i, &a) >= 0) {
list->_buffer[list->_length] =
CORBA_string_dup (a.model);
list->_length++;
}
}
CORBA_sequence_set_release (list, TRUE);
gp_abilities_list_free (al);
return (list);
}
void GPCamera::getCameraSupportedPorts(const QString& model, QStringList& plist)
{
#ifdef HAVE_GPHOTO2
int i = 0;
plist.clear();
CameraAbilities abilities;
CameraAbilitiesList* abilList = 0;
GPContext* context = 0;
context = gp_context_new();
gp_abilities_list_new(&abilList);
gp_abilities_list_load(abilList, context);
i = gp_abilities_list_lookup_model(abilList, model.toLocal8Bit().data());
gp_abilities_list_get_abilities(abilList, i, &abilities);
gp_abilities_list_free(abilList);
if (abilities.port & GP_PORT_SERIAL)
{
plist.append(QLatin1String("serial"));
}
if (abilities.port & GP_PORT_USB)
{
plist.append(QLatin1String("usb"));
}
gp_context_unref(context);
#else
Q_UNUSED(model);
Q_UNUSED(plist);
#endif /* HAVE_GPHOTO2 */
}
MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::MainWindow)
{
CameraAbilities a;
int size,r;
ui->setupUi(this);
QStandardItemModel *model = new QStandardItemModel(this);
model->setHorizontalHeaderItem(0, new QStandardItem(QString("Camera")));
model->setHorizontalHeaderItem(1, new QStandardItem(QString("Comment")));
ui->tableView->setModel(model);
GPContext* context = gp_context_new();
CameraAbilitiesList* list;
gp_abilities_list_new(&list);
gp_abilities_list_load(list, context);
size = gp_abilities_list_count(list);
for(int i= 0; i < size; i++)
{
r = gp_abilities_list_get_abilities(list, i, &a);
if( r < 0 ) break;
QStandardItem* cam = new QStandardItem(QString(a.model));
model->setItem(i,0, cam);
QStandardItem* com = new QStandardItem();
switch (a.status)
{
case GP_DRIVER_STATUS_TESTING:
com->setText(QString("TESTING"));
break;
case GP_DRIVER_STATUS_EXPERIMENTAL:
com->setText(QString("EXPERIMENTAL"));
break;
case GP_DRIVER_STATUS_DEPRECATED:
com->setText(QString("DEPRECATED"));
break;
case GP_DRIVER_STATUS_PRODUCTION:
break;
default:
com->setText(QString("UNKOWN"));
break;
}
model->setItem(i,1, com);
}
gp_abilities_list_free(list);
list = NULL;
gp_context_unref(context);
context = NULL;
}
/**
* Get list of supported cameras, walk through it, and try to see
* if the provided USB product/vendor combination was specified.
*/
int
main (int argc, char *argv[])
{
CameraAbilitiesList *al;
int i;
int count;
const char *fmt_str = NULL;
CHECK (gp_abilities_list_new (&al));
CHECK (gp_abilities_list_load (al, NULL));
count = gp_abilities_list_count (al);
if (count < 0) {
printf("gp_abilities_list_count error: %d\n", count);
return(1);
}
else if (count == 0) {
/* Copied from gphoto2-abilities-list.c gp_abilities_list_load() */
const char *camlib_env = getenv(CAMLIBDIR_ENV);
const char *camlibs = (camlib_env != NULL)?camlib_env:CAMLIBS;
printf("no camera drivers (camlibs) found in camlib dir:\n"
" CAMLIBS='%s', default='%s', used=%s\n",
camlib_env?camlib_env:"(null)", CAMLIBS,
(camlib_env!=NULL)?"CAMLIBS":"default");
return(1);
}
/* For each camera in the list, add a text snippet to the
* output file. */
for (i = 0; i < count; i++) {
CameraAbilities abilities;
const char *camlib_basename;
CHECK (gp_abilities_list_get_abilities (al, i, &abilities));
camlib_basename = basename(abilities.library);
/* Don't print out empty vendor IDs. Empty product IDs might be
* okay, though. */
if( !abilities.usb_vendor )
continue;
printf("%04x:%04x\t# %s\n",
abilities.usb_vendor,
abilities.usb_product,
abilities.model
);
}
CHECK (gp_abilities_list_free (al));
return (0);
}
gboolean _camera_initialize(const dt_camctl_t *c, dt_camera_t *cam)
{
dt_camctl_t *camctl=(dt_camctl_t *)c;
CameraAbilities a;
GPPortInfo pi;
if( cam->gpcam==NULL )
{
gp_camera_new(&cam->gpcam);
int m = gp_abilities_list_lookup_model( c->gpcams, cam->model );
gp_abilities_list_get_abilities (c->gpcams, m, &a);
gp_camera_set_abilities (cam->gpcam, a);
int p = gp_port_info_list_lookup_path (c->gpports, cam->port);
gp_port_info_list_get_info (c->gpports, p, &pi);
gp_camera_set_port_info (cam->gpcam , pi);
// Check for abilities
if( (a.operations&GP_OPERATION_CAPTURE_IMAGE) ) cam->can_tether=TRUE;
if( (a.operations&GP_OPERATION_CAPTURE_PREVIEW) ) cam->can_live_view=TRUE;
if( cam->can_tether && (a.operations&GP_OPERATION_CONFIG) ) cam->can_config=TRUE;
if( !(a.file_operations&GP_FILE_OPERATION_NONE) ) cam->can_import=TRUE;
if( gp_camera_init( cam->gpcam , camctl->gpcontext) != GP_OK )
{
dt_print(DT_DEBUG_CAMCTL,"[camera_control] failed to initialize camera %s on port %s\n", cam->model,cam->port);
return FALSE;
}
// read a full copy of config to configuration cache
gp_camera_get_config( cam->gpcam, &cam->configuration, c->gpcontext );
// TODO: find a more robust way for this, once we find out how to do it with non-EOS cameras
if(cam->can_live_view && dt_camctl_camera_property_exists(camctl, cam, "eoszoomposition"))
cam->can_live_view_advanced = TRUE;
// initialize timeout callbacks eg. keep alive, some cameras needs it.
cam->gpcontext = camctl->gpcontext;
gp_camera_set_timeout_funcs(cam->gpcam,
(CameraTimeoutStartFunc)_camera_start_timeout_func,
(CameraTimeoutStopFunc)_camera_stop_timeout_func,
cam);
dt_pthread_mutex_init(&cam->jobqueue_lock, NULL);
dt_print(DT_DEBUG_CAMCTL,"[camera_control] device %s on port %s initialized\n", cam->model,cam->port);
}
else
dt_print(DT_DEBUG_CAMCTL,"[camera_control] device %s on port %s already initialized\n", cam->model,cam->port);
return TRUE;
}
/**
* Connects to selected device.
*/
bool DigitalCameraCapture::open(int index)
{
const char * model = 0, *path = 0;
int m, p;
GPPortInfo portInfo;
if (isOpened()) {
close();
}
try
{
CR(gp_camera_new(&camera));
CR(gp_list_get_name(allDevices, index, &model));
CR(gp_list_get_value(allDevices, index, &path));
// Set model abilities.
CR(m = gp_abilities_list_lookup_model(abilitiesList, model));
CR(gp_abilities_list_get_abilities(abilitiesList, m, &cameraAbilities));
CR(gp_camera_set_abilities(camera, cameraAbilities));
// Set port
CR(p = gp_port_info_list_lookup_path(capablePorts, path));
CR(gp_port_info_list_get_info(capablePorts, p, &portInfo));
CR(gp_camera_set_port_info(camera, portInfo));
// Initialize connection to the camera.
CR(gp_camera_init(camera, context));
message(STATUS, "connected camera", model);
message(STATUS, "connected using", path);
// State initialization
firstCapturedFrameTime = 0;
capturedFrames = 0;
preview = false;
reloadOnChange = false;
collectMsgs = false;
reloadConfig();
opened = true;
return true;
}
catch (GPhoto2Exception & e)
{
message(WARNING, "opening device failed", e);
return false;
}
}
bool Image_GPhoto::initCamera(GPhotoCamera& camera)
{
lock_guard<recursive_mutex> lock(_gpMutex);
if (camera.cam == nullptr)
{
gp_camera_new(&camera.cam);
int m = gp_abilities_list_lookup_model(_gpCams, camera.model.c_str());
CameraAbilities abilities{};
gp_abilities_list_get_abilities(_gpCams, m, &abilities);
gp_camera_set_abilities(camera.cam, abilities);
int p = gp_port_info_list_lookup_path(_gpPorts, camera.port.c_str());
GPPortInfo portInfo;
gp_port_info_list_get_info(_gpPorts, p, &portInfo);
gp_camera_set_port_info(camera.cam, portInfo);
if (abilities.operations & GP_OPERATION_CAPTURE_IMAGE)
{
camera.canTether = true;
if (abilities.operations & GP_OPERATION_CONFIG)
camera.canConfig = true;
}
if (!(abilities.file_operations & GP_FILE_OPERATION_NONE))
camera.canImport = true;
if (gp_camera_init(camera.cam, _gpContext) != GP_OK)
return false;
gp_camera_get_config(camera.cam, &camera.configuration, _gpContext);
// Get the available shutterspeeds
initCameraProperty(camera, "shutterspeed", camera.shutterspeeds);
initCameraProperty(camera, "aperture", camera.apertures);
initCameraProperty(camera, "iso", camera.isos);
return true;
}
else
{
Log::get() << Log::WARNING << "Image_GPhoto::" << __FUNCTION__ << " - Camera " << camera.model << " already initialized" << Log::endl;
return false;
}
}
bool photo_camera_list::lookupAbilities( const std::string model_name, CameraAbilities* abilities )
{
int list_index = 0;
// Find the camera in the list of cameras and return the index
list_index = gp_abilities_list_lookup_model( abilities_list_, model_name.c_str() );
if( list_index < GP_OK )
{
photo_reporter::error( "gp_abilities_list_lookup_model()" );
return false;
}
// Find the camera's abilities in the abilities list
if( gp_abilities_list_get_abilities( abilities_list_, list_index, abilities ) != GP_OK )
{
photo_reporter::error( "gp_abilities_list_get_abilities()" );
return false;
}
return true;
}
void GPCamera::getSupportedCameras(int& count, QStringList& clist)
{
#ifdef HAVE_GPHOTO2
clist.clear();
count = 0;
CameraAbilities abil;
CameraAbilitiesList* abilList = 0;
GPContext* context = 0;
context = gp_context_new();
gp_abilities_list_new(&abilList);
gp_abilities_list_load(abilList, context);
count = gp_abilities_list_count(abilList);
if (count < 0)
{
qCDebug(DIGIKAM_IMPORTUI_LOG) << "Failed to get list of cameras!";
printGphotoErrorDescription(count);
gp_context_unref(context);
return;
}
else
{
for (int i = 0 ; i < count ; i++)
{
gp_abilities_list_get_abilities(abilList, i, &abil);
const char* cname = abil.model;
clist.append(QString::fromLocal8Bit(cname));
}
}
gp_abilities_list_free(abilList);
gp_context_unref(context);
#else
Q_UNUSED(count);
Q_UNUSED(clist);
#endif /* HAVE_GPHOTO2 */
}
int
gf_user (GFParams *params, const char *user)
{
CameraAbilities a;
int m;
CR (m = gp_abilities_list_lookup_model (params->al, user));
CR (gp_abilities_list_get_abilities (params->al, m, &a));
CR (gp_camera_set_abilities (params->camera, a));
params->folder = malloc (strlen ("/" + 1));
if (!params->folder)
return (GP_ERROR_NO_MEMORY);
strcpy (params->folder, "/");
if (strcmp (user, "Directory Browse"))
printf ("%3d %s\r\n", 331, "Please specify the port.");
else
printf ("%3d %s\r\n", 230, "Connected to camera.");
fflush (stdout);
return (0);
}
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;
}
static GtkamCamera *
gtkam_chooser_get_camera (GtkamChooser *chooser)
{
GtkWidget *dialog, *status;
GPPortInfo info;
Camera *camera;
CameraAbilities abilities;
const gchar *model, *port, *speed;
gchar *port_path, *right, *tmp;
int m, p, r;
gboolean multi;
GtkamCamera *c;
model = gtk_entry_get_text (chooser->priv->entry_model);
port = gtk_entry_get_text (chooser->priv->entry_port);
speed = gtk_entry_get_text (chooser->priv->entry_speed);
multi = GTK_TOGGLE_BUTTON (chooser->priv->check_multi)->active;
if (!port || !*port)
port_path = g_strdup (_("None"));
else {
port_path = g_strdup (port);
right = strrchr (port_path, ')');
*right = '\0';
tmp = g_strdup (strrchr (port_path, '(') + 1);
g_free (port_path);
port_path = tmp;
}
gp_camera_new (&camera);
#ifdef HAVE_GP_CAMERA_SET_TIMEOUT_FUNCS
gp_camera_set_timeout_funcs (camera, start_timeout_func,
stop_timeout_func, NULL);
#endif
/* Model? */
m = gp_abilities_list_lookup_model (chooser->priv->al, model);
gp_abilities_list_get_abilities (chooser->priv->al, m, &abilities);
gp_camera_set_abilities (camera, abilities);
/* Port? */
if (strcmp (port_path, _("None"))) {
p = gp_port_info_list_lookup_path (chooser->priv->il,
port_path);
gp_port_info_list_get_info (chooser->priv->il, p, &info);
gp_camera_set_port_info (camera, info);
}
/* Speed? */
if (strcmp (speed, _("Best")))
gp_camera_set_port_speed (camera, atoi (speed));
/*
* Initialize the camera to check if it is really there. Exit
* afterwards because other applications could need the camera, too.
*/
status = gtkam_status_new (_("Initializing camera..."));
gtkam_dialog_add_status (GTKAM_DIALOG (chooser), status);
r = gp_camera_init (camera, GTKAM_STATUS (status)->context->context);
if (multi)
gp_camera_exit (camera, NULL);
switch (r) {
case GP_OK:
break;
case GP_ERROR_CANCEL:
g_free (port_path);
break;
default:
g_free (port_path);
dialog = gtkam_error_new (r, GTKAM_STATUS (status)->context,
NULL, _("Could not initialize camera."));
gtk_window_set_transient_for (GTK_WINDOW (dialog),
GTK_WINDOW (chooser));
gtk_widget_show (dialog);
gp_camera_unref (camera);
camera = NULL;
}
gtk_object_destroy (GTK_OBJECT (status));
c = gtkam_camera_new (camera, multi);
gp_camera_unref (camera);
return (c);
}
static GnoCamCamera *
gnocam_main_get_camera (GnoCamMain *gm, const gchar *model, const gchar *port,
CORBA_Environment *ev)
{
Camera *camera;
GnoCamCamera *gc = NULL;
g_message ("Trying to get a camera for model '%s' (port '%s')...",
model, port);
g_return_val_if_fail (GNOCAM_IS_MAIN (gm), NULL);
gc = gnocam_cache_lookup (gm->priv->cache, model, port);
if (gc) {
bonobo_object_ref (gc);
return gc;
}
CR (gp_camera_new (&camera), ev);
if (BONOBO_EX (ev))
return (CORBA_OBJECT_NIL);
if (model && strlen (model)) {
CameraAbilities a;
CameraAbilitiesList *al = NULL;
int m;
memset (&a, 0, sizeof (CameraAbilities));
gp_abilities_list_new (&al);
gp_abilities_list_load (al, NULL);
m = gp_abilities_list_lookup_model (al, model);
gp_abilities_list_get_abilities (al, m, &a);
gp_abilities_list_free (al);
CR (gp_camera_set_abilities (camera, a), ev);
if (BONOBO_EX (ev)) {
gp_camera_unref (camera);
return NULL;
}
}
if (port && strlen (port)) {
GPPortInfo info;
GPPortInfoList *il = NULL;
int p;
memset (&info, 0, sizeof (GPPortInfo));
gp_port_info_list_new (&il);
gp_port_info_list_load (il);
p = gp_port_info_list_lookup_name (il, port);
if (p < 0)
p = gp_port_info_list_lookup_path (il, port);
gp_port_info_list_get_info (il, p, &info);
gp_port_info_list_free (il);
CR (gp_camera_set_port_info (camera, info), ev);
if (BONOBO_EX (ev)) {
gp_camera_unref (camera);
return (CORBA_OBJECT_NIL);
}
}
CR (gp_camera_init (camera, NULL), ev);
if (BONOBO_EX (ev)) {
gp_camera_unref (camera);
return NULL;
}
gc = gnocam_camera_new (camera, ev);
gp_camera_unref (camera);
if (BONOBO_EX (ev))
return NULL;
gnocam_cache_add (gm->priv->cache, gc);
g_message ("Successfully created a camera.");
return gc;
}
/**
* Get list of supported cameras, walk through it, and try to see
* if the provided USB product/vendor combination was specified.
*/
int
main (int argc, char *argv[])
{
CameraAbilitiesList *al;
int i;
int count;
const char *fmt_str = NULL;
long vendor_id, product_id;
/* Parse the command line, looking for the USB ids */
if( argc != 3 ) {
fprintf(stderr, "Usage: %s [vendor_id] [product_id]\n", argv[0]);
return 0;
}
vendor_id = strtol(argv[1], NULL, 0);
product_id = strtol(argv[2], NULL, 0);
fprintf(stderr, "Read vendor 0x%04x product 0x%04x\n", vendor_id,
product_id);
if( !vendor_id || !product_id ) {
fprintf(stderr, "Missing either the vendor or product id\n");
return 0;
}
/*
if (do_debug) {
gettimeofday (&glob_tv_zero, NULL);
CHECK (gp_log_add_func (GP_LOG_ALL, debug_func, NULL));
gp_log (GP_LOG_DEBUG, "main", "test-camera-list start");
}
*/
CHECK (gp_abilities_list_new (&al));
CHECK (gp_abilities_list_load (al, NULL));
count = gp_abilities_list_count (al);
if (count < 0) {
printf("gp_abilities_list_count error: %d\n", count);
return(0);
}
else if (count == 0) {
/* Copied from gphoto2-abilities-list.c gp_abilities_list_load() */
const char *camlib_env = getenv(CAMLIBDIR_ENV);
const char *camlibs = (camlib_env != NULL)?camlib_env:CAMLIBS;
printf("no camera drivers (camlibs) found in camlib dir:\n"
" CAMLIBS='%s', default='%s', used=%s\n",
camlib_env?camlib_env:"(null)", CAMLIBS,
(camlib_env!=NULL)?"CAMLIBS":"default");
return(0);
}
/* For each camera in the list, add a text snippet to the
* output file. */
fprintf(stderr, "Examining %d entries for 0x%04x:0x%04x\n",
count, vendor_id, product_id);
for (i = 0; i < count; i++) {
CameraAbilities abilities;
const char *camlib_basename;
CHECK (gp_abilities_list_get_abilities (al, i, &abilities));
camlib_basename = basename(abilities.library);
if( abilities.usb_vendor == vendor_id
&& abilities.usb_product == product_id ) {
fprintf(stderr, "Found camera model \"%s\"\n", abilities.model);
return 1;
}
/*
printf(fmt_str,
i+1,
camlib_basename,
abilities.id,
abilities.usb_vendor,
abilities.usb_product,
abilities.model
);
*/
}
CHECK (gp_abilities_list_free (al));
return (0);
}
static TW_UINT16
GPHOTO2_OpenDS( pTW_IDENTITY pOrigin, pTW_IDENTITY self) {
int ret, m, p, count, i;
CameraAbilities a;
GPPortInfo info;
const char *model, *port;
if (TWRC_SUCCESS != gphoto2_auto_detect())
return TWRC_FAILURE;
if (lstrcmpA(self->ProductFamily,"GPhoto2 Camera")) {
FIXME("identity passed is not a gphoto camera, but %s!?!\n", self->ProductFamily);
return TWRC_FAILURE;
}
count = gp_list_count (detected_cameras);
if (!count) {
ERR("No camera found by autodetection. Returning failure.\n");
return TWRC_FAILURE;
}
if (!lstrcmpA (self->ProductName, "GPhoto2 Camera")) {
TRACE("Potential undetected camera. Just using the first autodetected one.\n");
i = 0;
} else {
for (i=0;i<count;i++) {
const char *cname, *pname;
TW_STR32 name;
gp_list_get_name (detected_cameras, i, &cname);
gp_list_get_value (detected_cameras, i, &pname);
if (!lstrcmpA(self->ProductName,cname))
break;
snprintf(name, sizeof(name), "%s", cname);
if (!lstrcmpA(self->ProductName,name))
break;
snprintf(name, sizeof(name), "%s@%s", cname, pname);
if (!lstrcmpA(self->ProductName,name))
break;
}
if (i == count) {
TRACE("Camera %s not found in autodetected list. Using first entry.\n", self->ProductName);
i=0;
}
}
gp_list_get_name (detected_cameras, i, &model);
gp_list_get_value (detected_cameras, i, &port);
TRACE("model %s, port %s\n", model, port);
ret = gp_camera_new (&activeDS.camera);
if (ret < GP_OK) {
ERR("gp_camera_new: %d\n", ret);
return TWRC_FAILURE;
}
m = gp_abilities_list_lookup_model (abilities_list, model);
if (m < GP_OK) {
FIXME("Model %s not found, %d!\n", model, m);
return TWRC_FAILURE;
}
ret = gp_abilities_list_get_abilities (abilities_list, m, &a);
if (ret < GP_OK) {
FIXME("gp_camera_list_get_abilities failed? %d\n", ret);
return TWRC_FAILURE;
}
ret = gp_camera_set_abilities (activeDS.camera, a);
if (ret < GP_OK) {
FIXME("gp_camera_set_abilities failed? %d\n", ret);
return TWRC_FAILURE;
}
p = gp_port_info_list_lookup_path (port_list, port);
if (p < GP_OK) {
FIXME("port %s not in portlist?\n", port);
return TWRC_FAILURE;
}
ret = gp_port_info_list_get_info (port_list, p, &info);
if (ret < GP_OK) {
FIXME("could not get portinfo for port %s?\n", port);
return TWRC_FAILURE;
}
ret = gp_camera_set_port_info (activeDS.camera, info);
if (ret < GP_OK) {
FIXME("could not set portinfo for port %s to camera?\n", port);
return TWRC_FAILURE;
}
list_init( &(activeDS.files) );
activeDS.currentState = 4;
activeDS.twCC = TWRC_SUCCESS;
activeDS.pixelflavor = TWPF_CHOCOLATE;
activeDS.pixeltype = TWPT_RGB;
activeDS.capXferMech = TWSX_MEMORY;
TRACE("OK!\n");
return TWRC_SUCCESS;
}
/**
* Get list of supported cameras, walk through it and create some output.
*/
int
main (int argc, char *argv[])
{
CameraAbilitiesList *al;
int i;
int count;
const char *fmt_str = NULL;
parse_command_line (argc, argv);
if (do_debug) {
gettimeofday (&glob_tv_zero, NULL);
CHECK (gp_log_add_func (GP_LOG_ALL, debug_func, NULL));
gp_log (GP_LOG_DEBUG, "main", "test-camera-list start");
}
CHECK (gp_abilities_list_new (&al));
CHECK (gp_abilities_list_load (al, NULL));
count = gp_abilities_list_count (al);
if (count < 0) {
printf("gp_abilities_list_count error: %d\n", count);
return(1);
} else if (count == 0) {
/* Copied from gphoto2-abilities-list.c gp_abilities_list_load() */
const char *camlib_env = getenv(CAMLIBDIR_ENV);
const char *camlibs = (camlib_env != NULL)?camlib_env:CAMLIBS;
printf("no camera drivers (camlibs) found in camlib dir:\n"
" CAMLIBS='%s', default='%s', used=%s\n",
camlib_env?camlib_env:"(null)", CAMLIBS,
(camlib_env!=NULL)?"CAMLIBS":"default");
return(1);
}
/* Set output format for file body,
* and print opening part of output file. */
switch (format) {
case FMT_CSV:
fmt_str = "%d,%s,%s,%s\n";
break;
case FMT_FLAT_TEXT:
fmt_str = "%3d|%-20s|%-20s|%s\n";
break;
case FMT_HEADED_TEXT:
fmt_str = "%3d|%-20s|%-20s|%s\n";
break;
case FMT_XML:
fmt_str = " <camera name=\"%4$s\" entry_number=\"%1$d\">\n"
" <camlib-name value=\"%2$s\"/>\n"
" <driver-name value=\"%3$s\"/>\n"
" </camera>\n";
printf("<?xml version=\"%s\" encoding=\"%s\"?>\n"
"<camera-list camera-count=\"%d\">\n",
"1.0", "us-ascii", count);
break;
case FMT_FLAT_CAMLIBS:
fmt_str = "%2$-28s %3$s\n";
break;
case FMT_COUNT:
printf("%d\n", count);
return(0);
break;
}
/* For each camera in the list, add a text snippet to the
* output file. */
for (i = 0; i < count; i++) {
CameraAbilities abilities;
const char *camlib_basename;
CHECK (gp_abilities_list_get_abilities (al, i, &abilities));
camlib_basename = path_basename(abilities.library);
switch (format) {
case FMT_HEADED_TEXT:
if ( ((i%25)== 0) &&
( (i==0) || ((count-i) > 5) ) ) {
print_hline();
print_headline();
print_hline();
}
break;
case FMT_FLAT_CAMLIBS:
break;
case FMT_XML:
break;
case FMT_CSV:
break;
case FMT_FLAT_TEXT:
break;
case FMT_COUNT:
break;
}
printf(fmt_str,
i+1,
camlib_basename,
abilities.id,
abilities.model);
}
/* Print closing part of output file. */
switch (format) {
case FMT_HEADED_TEXT:
print_hline();
print_headline();
print_hline();
break;
case FMT_FLAT_CAMLIBS:
break;
case FMT_XML:
printf("</camera-list>\n");
break;
case FMT_CSV:
break;
case FMT_FLAT_TEXT:
break;
case FMT_COUNT:
break;
}
CHECK (gp_abilities_list_free (al));
return (0);
}
/**
* Initiate a connection to the \c camera.
*
* @param camera a #Camera
* @param context a #GPContext
* @return a gphoto2 error code
*
* Before calling this function, the
* \c camera should be set up using #gp_camera_set_port_path or
* #gp_camera_set_port_name and #gp_camera_set_abilities. If that has been
* omitted, gphoto2 tries to autodetect any cameras and chooses the first one
* if any cameras are found. It is generally a good idea to call
* #gp_camera_exit after transactions have been completed in order to give
* other applications the chance to access the camera, too.
*
*/
int
gp_camera_init (Camera *camera, GPContext *context)
{
CameraAbilities a;
const char *model, *port;
CameraLibraryInitFunc init_func;
int result;
gp_log (GP_LOG_DEBUG, "gphoto2-camera", "Initializing camera...");
CHECK_NULL (camera);
/*
* Reset the exit_requested flag. If this flag is set,
* gp_camera_exit will be called as soon as the camera is no
* longer in use (used flag).
*/
camera->pc->exit_requested = 0;
/*
* If the model hasn't been indicated, try to
* figure it out (USB only). Beware of "Directory Browse".
*/
if (strcasecmp (camera->pc->a.model, "Directory Browse") &&
!strcmp ("", camera->pc->a.model)) {
CameraAbilitiesList *al;
GPPortInfo pinfo;
GPPortInfoList *il;
int m, p;
GPPortInfo info;
CameraList *list;
result = gp_list_new (&list);
if (result < GP_OK)
return result;
result = gp_port_get_info (camera->port, &pinfo);
if (result < GP_OK)
return result;
gp_log (GP_LOG_DEBUG, "gphoto2-camera", "pinfo.type %d", pinfo.type);
gp_log (GP_LOG_DEBUG, "gphoto2-camera", "pinfo.path %s", pinfo.path);
gp_log (GP_LOG_DEBUG, "gphoto2-camera", "pinfo.name %s", pinfo.name);
gp_log (GP_LOG_DEBUG, "gphoto2-camera", "Neither "
"port nor model set. Trying auto-detection...");
/* Call auto-detect and choose the first camera */
gp_abilities_list_new (&al);
gp_abilities_list_load (al, context);
gp_port_info_list_new (&il);
gp_port_info_list_load (il);
gp_abilities_list_detect (al, il, list, context);
if (!gp_list_count (list)) {
gp_abilities_list_free (al);
gp_port_info_list_free (il);
gp_context_error (context, _("Could not detect any camera"));
gp_list_free (list);
return (GP_ERROR_MODEL_NOT_FOUND);
}
p = 0;
/* if the port was set before, then use that entry. but not if it is "usb:" */
if ( (pinfo.type == GP_PORT_USB) &&
strlen(pinfo.path) &&
strcmp(pinfo.path,"usb:")
) {
for (p = gp_list_count (list);p--;) {
const char *xp;
gp_list_get_value (list, p, &xp);
if (!strcmp (xp, pinfo.path))
break;
}
if (p<0) {
gp_context_error (context, _("Could not detect any camera at port %s"), pinfo.path);
return (GP_ERROR_FILE_NOT_FOUND);
}
}
gp_list_get_name (list, p, &model);
m = gp_abilities_list_lookup_model (al, model);
gp_abilities_list_get_abilities (al, m, &a);
gp_abilities_list_free (al);
CRSL (camera, gp_camera_set_abilities (camera, a), context, list);
CRSL (camera, gp_list_get_value (list, p, &port), context, list);
p = gp_port_info_list_lookup_path (il, port);
gp_port_info_list_get_info (il, p, &info);
gp_port_info_list_free (il);
CRSL (camera, gp_camera_set_port_info (camera, info), context, list);
gp_list_free (list);
}
if (strcasecmp (camera->pc->a.model, "Directory Browse")) {
switch (camera->port->type) {
case GP_PORT_NONE:
gp_context_error (context, _("You have to set the "
"port prior to initialization of the camera."));
return (GP_ERROR_UNKNOWN_PORT);
case GP_PORT_USB:
if (gp_port_usb_find_device (camera->port,
camera->pc->a.usb_vendor,
camera->pc->a.usb_product) != GP_OK) {
CRS (camera, gp_port_usb_find_device_by_class
(camera->port,
camera->pc->a.usb_class,
camera->pc->a.usb_subclass,
camera->pc->a.usb_protocol), context);
}
break;
default:
break;
}
}
/* Load the library. */
gp_log (GP_LOG_DEBUG, "gphoto2-camera", "Loading '%s'...",
camera->pc->a.library);
lt_dlinit ();
camera->pc->lh = lt_dlopenext (camera->pc->a.library);
if (!camera->pc->lh) {
gp_context_error (context, _("Could not load required "
"camera driver '%s' (%s)."), camera->pc->a.library,
lt_dlerror ());
lt_dlexit ();
return (GP_ERROR_LIBRARY);
}
/* Initialize the camera */
init_func = lt_dlsym (camera->pc->lh, "camera_init");
if (!init_func) {
lt_dlclose (camera->pc->lh);
lt_dlexit ();
camera->pc->lh = NULL;
gp_context_error (context, _("Camera driver '%s' is "
"missing the 'camera_init' function."),
camera->pc->a.library);
return (GP_ERROR_LIBRARY);
}
if (strcasecmp (camera->pc->a.model, "Directory Browse")) {
result = gp_port_open (camera->port);
if (result < 0) {
lt_dlclose (camera->pc->lh);
lt_dlexit ();
camera->pc->lh = NULL;
return (result);
}
}
result = init_func (camera, context);
if (result < 0) {
gp_port_close (camera->port);
lt_dlclose (camera->pc->lh);
lt_dlexit ();
camera->pc->lh = NULL;
memset (camera->functions, 0, sizeof (CameraFunctions));
return (result);
}
/* We don't care if that goes wrong */
#ifdef HAVE_MULTI
gp_port_close (camera->port);
#endif
return (GP_OK);
}
int input_run(int id)
{
int res, i;
global->in[id].buf = malloc(256 * 1024);
if(global->in[id].buf == NULL)
{
IPRINT(INPUT_PLUGIN_NAME " - could not allocate memory\n");
exit(EXIT_FAILURE);
}
plugin_id = id;
// auto-detect algorithm
CameraAbilitiesList* al;
GPPortInfoList* il;
CameraList* list;
const char* model;
const char* port;
context = gp_context_new();
gp_abilities_list_new(&al);
gp_abilities_list_load(al, context);
gp_port_info_list_new(&il);
gp_port_info_list_load(il);
gp_list_new(&list);
gp_abilities_list_detect(al, il, list, context);
int count = gp_list_count(list);
IPRINT(INPUT_PLUGIN_NAME " - Detected %d camera(s)\n", count);
if(count == 0)
{
IPRINT(INPUT_PLUGIN_NAME " - No cameras detected.\n");
return 0;
}
GPPortInfo info;
CameraAbilities a;
int m, p;
camera = NULL;
for(i = 0; i < count; i++)
{
res = gp_list_get_name(list, i, &model);
CAMERA_CHECK_GP(res, "gp_list_get_name");
m = gp_abilities_list_lookup_model(al, model);
if(m < 0)
{
IPRINT(INPUT_PLUGIN_NAME " - Gphoto abilities_list_lookup_model Code: %d - %s\n", m, gp_result_as_string(m));
return 0;
}
res = gp_abilities_list_get_abilities(al, m, &a);
CAMERA_CHECK_GP(res, "gp_abilities_list_get_abilities");
res = gp_list_get_value(list, i, &port);
CAMERA_CHECK_GP(res, "gp_list_get_value"); DBG("Model: %s; port: %s.\n", model, port);
if(selected_port != NULL && strcmp(selected_port, port) != 0)
continue;
p = gp_port_info_list_lookup_path(il, port);
if(p < 0)
{
IPRINT(INPUT_PLUGIN_NAME " - Gphoto port_info_list_lookup_path Code: %d - %s\n", m, gp_result_as_string(m));
return 0;
}
res = gp_port_info_list_get_info(il, p, &info);
CAMERA_CHECK_GP(res, "gp_port_info_list_get_info");
res = gp_camera_new(&camera);
CAMERA_CHECK_GP(res, "gp_camera_new");
res = gp_camera_set_abilities(camera, a);
CAMERA_CHECK_GP(res, "gp_camera_set_abilities");
res = gp_camera_set_port_info(camera, info);
CAMERA_CHECK_GP(res, "gp_camera_set_port_info");
}
if(camera == NULL)
{
IPRINT("Camera %s not found, exiting.\n", selected_port);
exit(EXIT_FAILURE);
}
// cleanup
gp_list_unref(list);
gp_port_info_list_free(il);
gp_abilities_list_free(al);
// open camera and set capture on
int value = 1;
res = gp_camera_init(camera, context);
CAMERA_CHECK_GP(res, "gp_camera_init");
camera_set("capture", &value);
// starting thread
if(pthread_create(&thread, 0, capture, NULL) != 0)
{
free(global->in[id].buf);
IPRINT("could not start worker thread\n");
exit(EXIT_FAILURE);
}
pthread_detach(thread);
return 0;
}
bool GPCamera::doConnect()
{
#ifdef HAVE_GPHOTO2
int errorCode;
// -- first step - setup the camera --------------------
if (d->camera)
{
gp_camera_unref(d->camera);
d->camera = 0;
}
CameraAbilitiesList* abilList = 0;
GPPortInfoList* infoList = 0;
GPPortInfo info;
gp_camera_new(&d->camera);
delete d->status;
d->status = 0;
d->status = new GPStatus();
gp_abilities_list_new(&abilList);
gp_abilities_list_load(abilList, d->status->context);
gp_port_info_list_new(&infoList);
gp_port_info_list_load(infoList);
int modelNum = gp_abilities_list_lookup_model(abilList, m_model.toLatin1().constData());
int portNum = gp_port_info_list_lookup_path(infoList, m_port.toLatin1().constData());
gp_abilities_list_get_abilities(abilList, modelNum, &d->cameraAbilities);
errorCode = gp_camera_set_abilities(d->camera, d->cameraAbilities);
if (errorCode != GP_OK)
{
qCDebug(DIGIKAM_IMPORTUI_LOG) << "Failed to set camera Abilities!";
printGphotoErrorDescription(errorCode);
gp_camera_unref(d->camera);
d->camera = 0;
gp_abilities_list_free(abilList);
gp_port_info_list_free(infoList);
return false;
}
if (m_model != QLatin1String("Directory Browse"))
{
gp_port_info_list_get_info(infoList, portNum, &info);
errorCode = gp_camera_set_port_info(d->camera, info);
if (errorCode != GP_OK)
{
qCDebug(DIGIKAM_IMPORTUI_LOG) << "Failed to set camera port!";
printGphotoErrorDescription(errorCode);
gp_camera_unref(d->camera);
d->camera = 0;
gp_abilities_list_free(abilList);
gp_port_info_list_free(infoList);
return false;
}
}
gp_abilities_list_free(abilList);
gp_port_info_list_free(infoList);
if (d->cameraAbilities.file_operations &
GP_FILE_OPERATION_PREVIEW)
{
m_thumbnailSupport = true;
}
if (d->cameraAbilities.file_operations &
GP_FILE_OPERATION_DELETE)
{
m_deleteSupport = true;
}
if (d->cameraAbilities.folder_operations &
GP_FOLDER_OPERATION_PUT_FILE)
{
m_uploadSupport = true;
}
if (d->cameraAbilities.folder_operations &
GP_FOLDER_OPERATION_MAKE_DIR)
{
m_mkDirSupport = true;
}
if (d->cameraAbilities.folder_operations &
GP_FOLDER_OPERATION_REMOVE_DIR)
{
m_delDirSupport = true;
}
if (d->cameraAbilities.operations &
GP_OPERATION_CAPTURE_IMAGE)
{
m_captureImageSupport = true;
}
if (d->cameraAbilities.operations &
GP_OPERATION_CAPTURE_PREVIEW)
{
m_captureImagePreviewSupport = true;
}
// -- Try and initialize the camera to see if its connected -----------------
errorCode = gp_camera_init(d->camera, d->status->context);
if (errorCode != GP_OK)
{
qCDebug(DIGIKAM_IMPORTUI_LOG) << "Failed to initialize camera!";
printGphotoErrorDescription(errorCode);
gp_camera_unref(d->camera);
d->camera = 0;
return false;
}
d->cameraInitialized = true;
return true;
#else
return false;
#endif /* HAVE_GPHOTO2 */
}
bool GPCamera::findConnectedUsbCamera(int vendorId, int productId, QString& model, QString& port)
{
#ifdef HAVE_GPHOTO2
CameraAbilitiesList* abilList = 0;
GPPortInfoList* list = 0;
GPContext* context = 0;
CameraList* camList = 0;
bool success = false;
// get name and port of detected camera
const char* model_str = 0;
const char* port_str = 0;
context = gp_context_new();
// get list of all ports
gp_port_info_list_new(&list);
gp_port_info_list_load(list);
gp_abilities_list_new(&abilList);
// get list of all supported cameras
gp_abilities_list_load(abilList, context);
// autodetect all cameras, then match the list to the passed in USB ids
gp_list_new (&camList);
gp_abilities_list_detect(abilList, list, camList, context);
gp_context_unref(context);
int count = gp_list_count(camList);
int cnt = 0;
for (int i = 0 ; i < count ; i++)
{
const char* xmodel = 0;
gp_list_get_name(camList, i, &xmodel);
int model = gp_abilities_list_lookup_model (abilList, xmodel);
CameraAbilities ab;
gp_abilities_list_get_abilities(abilList, model, &ab);
if (ab.port != GP_PORT_USB)
continue;
/* KDE provides us USB Vendor and Product, but we might just
* have covered this via a class match. Check class matched
* cameras also for matchingo USB vendor/product id
*/
if (ab.usb_vendor == 0)
{
int ret;
GPPortInfo info;
const char* xport = 0;
GPPort* gpport = 0;
/* get the port path so we only look at this bus position */
gp_list_get_value(camList, i, &xport);
ret = gp_port_info_list_lookup_path (list, xport);
if (ret < GP_OK) /* should not happen */
continue;
/* get the lowlevel port info for the path
*/
gp_port_info_list_get_info(list, ret, &info);
/* open lowlevel driver interface briefly to search */
gp_port_new(&gpport);
gp_port_set_info(gpport, info);
/* And now call into the lowlevel usb driver to see if the bus position
* has that specific vendor/product id
*/
if (gp_port_usb_find_device(gpport, vendorId, productId) == GP_OK)
{
ab.usb_vendor = vendorId;
ab.usb_product = productId;
}
gp_port_free (gpport);
}
if (ab.usb_vendor != vendorId)
continue;
if (ab.usb_product != productId)
continue;
/* keep it, and continue iterating, in case we find another one
*/
gp_list_get_name (camList, i, &model_str);
gp_list_get_value(camList, i, &port_str);
cnt++;
}
gp_port_info_list_free(list);
gp_abilities_list_free(abilList);
if (cnt > 0)
{
if (cnt > 1)
{
qCWarning(DIGIKAM_IMPORTUI_LOG) << "More than one camera detected on port " << port
<< ". Due to restrictions in the GPhoto2 API, "
<< "only the first camera is used.";
}
model = QString::fromLatin1(model_str);
port = QString::fromLatin1(port_str);
success = true;
}
else
{
qCDebug(DIGIKAM_IMPORTUI_LOG) << "Failed to get information for the listed camera";
}
gp_list_free(camList);
return success;
#else
Q_UNUSED(vendorId);
Q_UNUSED(productId);
Q_UNUSED(model);
Q_UNUSED(port);
return false;
#endif /* HAVE_GPHOTO2 */
}
