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;
}
dt_camctl_t *dt_camctl_new()
{
dt_camctl_t *camctl=g_malloc(sizeof(dt_camctl_t));
memset(camctl,0,sizeof(dt_camctl_t));
dt_print(DT_DEBUG_CAMCTL,"[camera_control] creating new context %lx\n",(unsigned long int)camctl);
// Initialize gphoto2 context and setup dispatch callbacks
camctl->gpcontext = gp_context_new();
gp_context_set_idle_func( camctl->gpcontext , (GPContextIdleFunc)_idle_func_dispatch, camctl );
gp_context_set_status_func( camctl->gpcontext , (GPContextStatusFunc)_status_func_dispatch, camctl );
gp_context_set_error_func( camctl->gpcontext , (GPContextErrorFunc)_error_func_dispatch, camctl );
gp_context_set_message_func( camctl->gpcontext , (GPContextMessageFunc)_message_func_dispatch, camctl );
// Load all camera drivers we know...
gp_abilities_list_new( &camctl->gpcams );
gp_abilities_list_load( camctl->gpcams, camctl->gpcontext );
dt_print(DT_DEBUG_CAMCTL,"[camera_control] loaded %d camera drivers.\n", gp_abilities_list_count( camctl->gpcams ) );
dt_pthread_mutex_init(&camctl->lock, NULL);
// Let's detect cameras connexted
dt_camctl_detect_cameras(camctl);
return camctl;
}
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
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);
}
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);
}
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 */
}
static int
gp_abilities_list_detect_usb (CameraAbilitiesList *list,
int *ability, GPPort *port)
{
int i, count, res = GP_ERROR_IO_USB_FIND;
CHECK_RESULT (count = gp_abilities_list_count (list));
/* Detect USB cameras */
gp_log (GP_LOG_VERBOSE, __FILE__,
"Auto-detecting USB cameras...");
*ability = -1;
for (i = 0; i < count; i++) {
int v, p, c, s;
if (!(list->abilities[i].port & port->type))
continue;
v = list->abilities[i].usb_vendor;
p = list->abilities[i].usb_product;
if (v) {
res = gp_port_usb_find_device(port, v, p);
if (res == GP_OK) {
gp_log(GP_LOG_DEBUG, __FILE__,
"Found '%s' (0x%x,0x%x)",
list->abilities[i].model,
v, p);
*ability = i;
} else if (res < 0 && res != GP_ERROR_IO_USB_FIND) {
/* another error occurred.
* perhaps we should better
* report this to the calling
* method?
*/
gp_log(GP_LOG_DEBUG, __FILE__,
"gp_port_usb_find_device(vendor=0x%x, "
"product=0x%x) returned %i, clearing "
"error message on port", v, p, res);
}
if (res != GP_ERROR_IO_USB_FIND)
return res;
}
c = list->abilities[i].usb_class;
s = list->abilities[i].usb_subclass;
p = list->abilities[i].usb_protocol;
if (c) {
res = gp_port_usb_find_device_by_class(port, c, s, p);
if (res == GP_OK) {
gp_log(GP_LOG_DEBUG, __FILE__,
"Found '%s' (0x%x,0x%x,0x%x)",
list->abilities[i].model,
c, s, p);
*ability = i;
} else if (res < 0 && res != GP_ERROR_IO_USB_FIND) {
/* another error occurred.
* perhaps we should better
* report this to the calling
* method?
*/
gp_log(GP_LOG_DEBUG, __FILE__,
"gp_port_usb_find_device_by_class("
"class=0x%x, subclass=0x%x, "
"protocol=0x%x) returned %i, "
"clearing error message on port",
c, s, p, res);
}
if (res != GP_ERROR_IO_USB_FIND)
return res;
}
}
return res;
}
int
gp_abilities_list_load_dir (CameraAbilitiesList *list, const char *dir,
GPContext *context)
{
CameraLibraryIdFunc id;
CameraLibraryAbilitiesFunc ab;
CameraText text;
int ret, x, old_count, new_count;
unsigned int i, p;
const char *filename;
CameraList *flist;
int count;
lt_dlhandle lh;
CHECK_NULL (list && dir);
gp_log (GP_LOG_DEBUG, "gphoto2-abilities-list",
"Using ltdl to load camera libraries from '%s'...", dir);
CHECK_RESULT (gp_list_new (&flist));
ret = gp_list_reset (flist);
if (ret < GP_OK) {
gp_list_free (flist);
return ret;
}
if (1) { /* a new block in which we can define a temporary variable */
foreach_data_t foreach_data = { NULL, GP_OK };
foreach_data.list = flist;
lt_dlinit ();
lt_dladdsearchdir (dir);
ret = lt_dlforeachfile (dir, foreach_func, &foreach_data);
lt_dlexit ();
if (ret != 0) {
gp_list_free (flist);
gp_log (GP_LOG_ERROR, "gp-abilities-list",
"Internal error looking for camlibs (%d)", ret);
gp_context_error (context,
_("Internal error looking for camlibs. "
"(path names too long?)"));
return (foreach_data.result!=GP_OK)?foreach_data.result:GP_ERROR;
}
}
count = gp_list_count (flist);
if (count < GP_OK) {
gp_list_free (flist);
return ret;
}
gp_log (GP_LOG_DEBUG, "gp-abilities-list", "Found %i "
"camera drivers.", count);
lt_dlinit ();
p = gp_context_progress_start (context, count,
_("Loading camera drivers from '%s'..."), dir);
for (i = 0; i < count; i++) {
ret = gp_list_get_name (flist, i, &filename);
if (ret < GP_OK) {
gp_list_free (flist);
return ret;
}
lh = lt_dlopenext (filename);
if (!lh) {
gp_log (GP_LOG_DEBUG, "gphoto2-abilities-list",
"Failed to load '%s': %s.", filename,
lt_dlerror ());
continue;
}
/* camera_id */
id = lt_dlsym (lh, "camera_id");
if (!id) {
gp_log (GP_LOG_DEBUG, "gphoto2-abilities-list",
"Library '%s' does not seem to "
"contain a camera_id function: %s",
filename, lt_dlerror ());
lt_dlclose (lh);
continue;
}
/*
* Make sure the camera driver hasn't been
* loaded yet.
*/
if (id (&text) != GP_OK) {
lt_dlclose (lh);
continue;
}
if (gp_abilities_list_lookup_id (list, text.text) >= 0) {
lt_dlclose (lh);
continue;
}
/* camera_abilities */
ab = lt_dlsym (lh, "camera_abilities");
if (!ab) {
gp_log (GP_LOG_DEBUG, "gphoto2-abilities-list",
"Library '%s' does not seem to "
"contain a camera_abilities function: "
"%s", filename, lt_dlerror ());
lt_dlclose (lh);
continue;
}
old_count = gp_abilities_list_count (list);
if (old_count < 0) {
lt_dlclose (lh);
continue;
}
if (ab (list) != GP_OK) {
lt_dlclose (lh);
continue;
}
lt_dlclose (lh);
new_count = gp_abilities_list_count (list);
if (new_count < 0)
continue;
/* Copy in the core-specific information */
for (x = old_count; x < new_count; x++) {
strcpy (list->abilities[x].id, text.text);
strcpy (list->abilities[x].library, filename);
}
gp_context_progress_update (context, p, i);
if (gp_context_cancel (context) == GP_CONTEXT_FEEDBACK_CANCEL) {
lt_dlexit ();
gp_list_free (flist);
return (GP_ERROR_CANCEL);
}
}
gp_context_progress_stop (context, p);
lt_dlexit ();
gp_list_free (flist);
return (GP_OK);
}
void Image_GPhoto::init()
{
_type = "image_gphoto";
registerAttributes();
// This is used for getting documentation "offline"
if (!_root)
return;
lock_guard<recursive_mutex> lock(_gpMutex);
_gpContext = gp_context_new();
gp_abilities_list_new(&_gpCams);
gp_abilities_list_load(_gpCams, _gpContext);
Log::get() << Log::MESSAGE << "Image_GPhoto::" << __FUNCTION__ << " - Loaded " << gp_abilities_list_count(_gpCams) << " camera drivers" << Log::endl;
detectCameras();
}
/**
* 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);
}
/**
* 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);
}
