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 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 */ }
void GPhotoContext::cleanup() { if( camera_ ) { gp_camera_free( camera_ ); camera_ = NULL; } if( context_ ) { gp_context_unref( context_ ); context_ = NULL; } if( portinfoList_ ) { gp_port_info_list_free( portinfoList_ ); portinfoList_ = NULL; } if( abilitiesList_ ) { gp_abilities_list_free( abilitiesList_ ); abilitiesList_ = NULL; } if( cameras_ ) { gp_list_free( cameras_ ); cameras_ = NULL; } }
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); }
int auto_detect_action (CameraList *list,GPContext *context) { int count, result; GPPortInfoList *portinfo_list; CameraAbilitiesList *al = NULL; if ((result = gp_port_info_list_new (&portinfo_list)) < GP_OK) return result; result = gp_port_info_list_load (portinfo_list); if (result < 0) { gp_port_info_list_free (portinfo_list); return result; } count = gp_port_info_list_count (portinfo_list); if (count < 0) { gp_port_info_list_free (portinfo_list); return count; } gp_abilities_list_new (&al); gp_abilities_list_load (al, context); gp_abilities_list_detect (al, portinfo_list, list, context); gp_abilities_list_free (al); count = gp_list_count (list); return count > 0 ? GP_OK : GP_ERROR; }
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); }
CameraAbilitiesList * read_abilities_list(const char *filename) { CameraAbilitiesList *al = NULL; int retval; if (0!=(retval = gp_abilities_list_new(&al))) { return NULL; } if (0!=(retval = yyparse(filename, al))) { goto error; } return al; error: if (al!=NULL) gp_abilities_list_free(al); return NULL; }
/** * Autodetect all detectable camera * * @param list a #CameraList that receives the autodetected cameras * @param context a #GPContext * @return a gphoto2 error code * * This camera will autodetected all cameras that can be autodetected. * This will for instance detect all USB cameras. * * CameraList *list; * gp_list_new (&list); * gp_camera_autodetect (list, context); * ... done! ... */ int gp_camera_autodetect (CameraList *list, GPContext *context) { CameraAbilitiesList *al = NULL; GPPortInfoList *il = NULL; int ret, i; CameraList *xlist = NULL; ret = gp_list_new (&xlist); if (ret < GP_OK) goto out; if (!il) { /* Load all the port drivers we have... */ ret = gp_port_info_list_new (&il); if (ret < GP_OK) goto out; ret = gp_port_info_list_load (il); if (ret < 0) goto out; ret = gp_port_info_list_count (il); if (ret < 0) goto out; } /* Load all the camera drivers we have... */ ret = gp_abilities_list_new (&al); if (ret < GP_OK) goto out; ret = gp_abilities_list_load (al, context); if (ret < GP_OK) goto out; /* ... and autodetect the currently attached cameras. */ ret = gp_abilities_list_detect (al, il, xlist, context); if (ret < GP_OK) goto out; /* Filter out the "usb:" entry */ ret = gp_list_count (xlist); if (ret < GP_OK) goto out; for (i=0;i<ret;i++) { const char *name, *value; gp_list_get_name (xlist, i, &name); gp_list_get_value (xlist, i, &value); if (!strcmp ("usb:",value)) continue; gp_list_append (list, name, value); } out: if (il) gp_port_info_list_free (il); if (al) gp_abilities_list_free (al); gp_list_free (xlist); if (ret < GP_OK) return ret; return gp_list_count(list); }
/** * Always close connection to the device. */ DigitalCameraCapture::~DigitalCameraCapture() { close(); try { CR(gp_abilities_list_free(abilitiesList)); abilitiesList = NULL; CR(gp_port_info_list_free(capablePorts)); capablePorts = NULL; CR(gp_list_unref(allDevices)); allDevices = NULL; gp_context_unref(context); context = NULL; } catch (GPhoto2Exception & e) { message(ERROR, "destruction error", e); } }
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 void gtkam_chooser_destroy (GtkObject *object) { GtkamChooser *chooser = GTKAM_CHOOSER (object); if (chooser->priv->al) { gp_abilities_list_free (chooser->priv->al); chooser->priv->al = NULL; } if (chooser->priv->il) { gp_port_info_list_free (chooser->priv->il); chooser->priv->il = NULL; } if (chooser->priv->tooltips) { g_object_unref (G_OBJECT (chooser->priv->tooltips)); chooser->priv->tooltips = NULL; } GTK_OBJECT_CLASS (parent_class)->destroy (object); }
void gp_params_exit (GPParams *p) { if (!p) return; if (p->_abilities_list) gp_abilities_list_free (p->_abilities_list); if (p->camera) gp_camera_unref (p->camera); if (p->folder) free (p->folder); if (p->filename) free (p->filename); if (p->context) gp_context_unref (p->context); if (p->hook_script) free (p->hook_script); if (p->portinfo_list) gp_port_info_list_free (p->portinfo_list); memset (p, 0, sizeof (GPParams)); }
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; }
photo_camera_list::~photo_camera_list( void ) { gp_list_unref( camera_list_ ); //delete camera_list_; gp_port_info_list_free( port_info_list_ ); //delete port_info_list_; gp_abilities_list_free( abilities_list_ ); //delete abilities_list_; }
int main (int argc, char **argv) { fd_set rs; struct timeval tv; int n, cmd_len; char cmd[PATH_MAX + 32]; const char *arg; GFParams params; memset (¶ms, 0, sizeof (GFParams)); if (gp_camera_new (&(params.camera)) < 0) goto ExitError; if (gp_abilities_list_new (&(params.al)) < 0) goto ExitError; if (gp_abilities_list_load (params.al, NULL) < 0) goto ExitError; if (gp_port_info_list_new (¶ms.il) < 0) goto ExitError; if (gp_port_info_list_load (params.il) < 0) goto ExitError; params.folder = malloc (strlen ("/") + 1); if (!params.folder) goto ExitError; strcpy (params.folder, "/"); params.idletime = 1800; n = sizeof (struct sockaddr_in); if (getsockname (0, (struct sockaddr *) ¶ms.sai_sock, &n)) { fprintf (stdout, "421 Can not get name of sock.\r\n"); fflush (stdout); goto ExitError; } n = sizeof (struct sockaddr_in); if (getpeername (0, (struct sockaddr *) ¶ms.sai_peer, &n)) { fprintf (stdout, "421 Can not get name of peer.\r\n"); fflush (stdout); goto ExitError; } n = IPTOS_LOWDELAY; setsockopt (0, IPPROTO_IP, IP_TOS, (char *) &n, sizeof (int)); fprintf (stdout, "220-Hello and welcome to the wonderful world\r\n"); fprintf (stdout, "220-of gphoto!\r\n"); fprintf (stdout, "220-\r\n"); fprintf (stdout, "220-Use this server like a standard FTP-Server.\r\n"); fprintf (stdout, "220-List files in virtual directory\r\n"); fflush (stdout); fprintf (stdout, "220-'/capture-image' in order to capture\r\n"); fflush (stdout); fprintf (stdout, "220-an image, in '/capture-preview' in order\r\n"); fflush (stdout); fprintf (stdout, "220-to capture a preview.\r\n"); fflush (stdout); fprintf (stdout, "220 FTP server ready.\r\n"); fflush (stdout); while (1) { /* Read something. */ syslog (LOG_INFO, "Reading..."); FD_ZERO (&rs); tv.tv_sec = 1800; tv.tv_usec = 0; memset (cmd, 0, sizeof (cmd)); cmd_len = n = 0; while (1) { if (!n) { FD_SET (0, &rs); select (1, &rs, NULL, NULL, &tv); if (ioctl (0, FIONREAD, &n) < 0) n = 0; } if (FD_ISSET (0, &rs)) { if (read (0, cmd + cmd_len, 1) <= 0) goto ExitError; if (n) n--; if (cmd[cmd_len] == '\n') { cmd[cmd_len + 1] = '\0'; break; } if (cmd_len < sizeof (cmd) - 2) cmd_len++; } else goto ExitError; } syslog (LOG_INFO, "Got '%s'...", cmd); for (n = 0; isalpha (cmd[n]) && n < sizeof (cmd); n++) cmd[n] = tolower (cmd[n]); if (!n) { printf ("%3d %s\r\n", 221, "Goodbye."); fflush (stdout); goto ExitOk; } while (isspace (cmd[n]) && n < sizeof (cmd)) cmd[n++] = '\0'; arg = cmd + n; while (cmd[n] && n < sizeof (cmd)) n++; n--; while (isspace (cmd[n])) cmd[n--] = '\0'; syslog (LOG_INFO, "Processing '%s' - '%s'...", cmd, arg); if (!strcasecmp (cmd, "cwd")) { gf_cwd (¶ms, arg); } else if (!strcasecmp (cmd, "list")) { if (gf_list (¶ms, arg) < 0) goto ExitError; } else if (!strcasecmp (cmd, "noop")) { fprintf (stdout, "200 NOOP command successful.\r\n"); fflush (stdout); } else if (!strcasecmp (cmd, "pass")) { if (gf_pass (¶ms, arg) < 0) goto ExitError; } else if (!strcasecmp (cmd, "pasv")) { gf_pasv (¶ms); } else if (!strcasecmp (cmd, "port")) { if (gf_port (¶ms, arg) < 0) goto ExitError; } else if (!strcasecmp (cmd, "pwd") || !strcasecmp (cmd, "xpwd")) { fprintf (stdout, "257 \"%s\"\r\n", params.folder); fflush (stdout); } else if (!strcasecmp (cmd, "quit")) { printf ("%3d %s\r\n", 221, "Goodbye."); fflush (stdout); syslog (LOG_INFO, "Quit."); return (0); } else if (!strcasecmp (cmd, "retr")) { if (gf_retr (¶ms, arg) < 0) goto ExitError; } else if (!strcasecmp (cmd, "syst")) { printf ("215 UNIX Type: L8\r\n"); fflush (stdout); } else if (!strcasecmp (cmd, "type")) { if (!arg) goto ExitError; gf_type (¶ms, *arg); } else if (!strcasecmp (cmd, "user")) { if (gf_user (¶ms, arg) < 0) goto ExitError; } else { syslog (LOG_INFO, "Command '%s'...", cmd); printf ("%3d %s\r\n", 550, "Unknown command."); fflush (stdout); } } ExitError: gp_abilities_list_free (params.al); gp_port_info_list_free (params.il); gp_camera_unref (params.camera); gp_file_unref (params.file); free (params.camera); syslog (LOG_INFO, "Error: 1"); return (1); ExitOk: gp_abilities_list_free (params.al); gp_port_info_list_free (params.il); gp_camera_unref (params.camera); gp_file_unref (params.file); free (params.camera); return (0); }
void KKameraConfig::load(bool useDefaults ) { m_config->setReadDefaults( useDefaults ); QStringList groupList = m_config->groupList(); QStringList::Iterator it; int i, count; CameraList *list; CameraAbilitiesList *al; GPPortInfoList *il; const char *model, *value; KCamera *kcamera; for (it = groupList.begin(); it != groupList.end(); it++) { if (*it != "<default>") { m_config->setGroup(*it); if (m_config->readEntry("Path").contains("usb:")) continue; kcamera = new KCamera(*it,m_config->readEntry("Path")); connect(kcamera, SIGNAL(error(const QString &)), SLOT(slot_error(const QString &))); connect(kcamera, SIGNAL(error(const QString &, const QString &)), SLOT(slot_error(const QString &, const QString &))); kcamera->load(m_config); m_devices[*it] = kcamera; } } m_cancelPending = false; gp_list_new (&list); gp_abilities_list_new (&al); gp_abilities_list_load (al, m_context); gp_port_info_list_new (&il); gp_port_info_list_load (il); gp_abilities_list_detect (al, il, list, m_context); gp_abilities_list_free (al); gp_port_info_list_free (il); count = gp_list_count (list); QMap<QString,QString> ports, names; for (i = 0 ; i<count ; i++) { gp_list_get_name (list, i, &model); gp_list_get_value (list, i, &value); ports[value] = model; if (!strcmp(value,"usb:")) names[model] = value; } if (ports.contains("usb:") && names[ports["usb:"]]!="usb:") ports.remove("usb:"); QMap<QString,QString>::iterator portit; for (portit = ports.begin() ; portit != ports.end(); portit++) { /* kdDebug() << "Adding USB camera: " << portit.data() << " at " << portit.key() << endl; */ kcamera = new KCamera(portit.data(),portit.key()); connect(kcamera, SIGNAL(error(const QString &)), SLOT(slot_error(const QString &))); connect(kcamera, SIGNAL(error(const QString &, const QString &)), SLOT(slot_error(const QString &, const QString &))); m_devices[portit.data()] = kcamera; } populateDeviceListView(); gp_list_free (list); emit changed( useDefaults ); }
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 */ }
/** * 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); }
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 */ }
int GPCamera::autoDetect(QString& model, QString& port) { #ifdef HAVE_GPHOTO2 CameraList* camList = 0; CameraAbilitiesList* abilList = 0; GPPortInfoList* infoList = 0; const char* camModel_ = 0, *camPort_ = 0; GPContext* context = 0; context = gp_context_new(); gp_list_new(&camList); gp_abilities_list_new(&abilList); gp_abilities_list_load(abilList, context); gp_port_info_list_new(&infoList); gp_port_info_list_load(infoList); gp_abilities_list_detect(abilList, infoList, camList, context); gp_abilities_list_free(abilList); gp_port_info_list_free(infoList); gp_context_unref(context); int count = gp_list_count(camList); if (count <= 0) { qCDebug(DIGIKAM_IMPORTUI_LOG) << "Failed to autodetect camera!"; printGphotoErrorDescription(count); gp_list_free(camList); return -1; } camModel_ = 0; camPort_ = 0; for (int i = 0; i < count; i++) { if (gp_list_get_name(camList, i, &camModel_) != GP_OK) { qCDebug(DIGIKAM_IMPORTUI_LOG) << "Failed to autodetect camera!"; gp_list_free(camList); return -1; } if (gp_list_get_value(camList, i, &camPort_) != GP_OK) { qCDebug(DIGIKAM_IMPORTUI_LOG) << "Failed to autodetect camera!"; gp_list_free(camList); return -1; } if (camModel_ && camPort_) { model = QString::fromLatin1(camModel_); port = QString::fromLatin1(camPort_); gp_list_free(camList); return 0; } } qCDebug(DIGIKAM_IMPORTUI_LOG) << "Failed to autodetect camera!"; gp_list_free(camList); #else Q_UNUSED(model); Q_UNUSED(port); #endif /* HAVE_GPHOTO2 */ return -1; }
/** * 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; }