KKameraConfig::KKameraConfig(QWidget *parent, const char *name, const QStringList &) : KCModule(KKameraConfigFactory::instance(), parent, name) { m_devicePopup = new KPopupMenu(this); m_actions = new KActionCollection(this); m_config = new KSimpleConfig(KProtocolInfo::config("camera")); m_context = gp_context_new(); if (m_context) { // Register the callback functions gp_context_set_cancel_func(m_context, cbGPCancel, this); gp_context_set_idle_func(m_context, cbGPIdle, this); displayGPSuccessDialogue(); // load existing configuration load(); } else { displayGPFailureDialogue(); } // store instance for frontend_prompt m_instance = this; }
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; }
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 */ }
GPContext* sample_create_context() { GPContext *context; /* This is the mandatory part */ context = gp_context_new(); return context; }
int init_camera(Camera **camera,GPContext **context) { int retval; *context = gp_context_new(); gp_camera_new(camera); retval = gp_camera_init(*camera, *context); return retval; }
/** * @brief CameraHandler::CameraHandler */ QTLCamera::QTLCamera() { params = new GPhotoParams(); memset(params, 0, sizeof(GPhotoParams)); params->folder = strdup("/"); qDebug() << "Attempting to initialize camera..."; params->context = gp_context_new(); params->abilitiesList = NULL; params->widgetList = new vector<QTLWidget>(); }
GPContext* photo_camera::photo_camera_create_context( void ) { context_ = gp_context_new(); // Optional debugging and status output gp_context_set_error_func( context_, photo_reporter::contextError, NULL ); gp_context_set_status_func( context_, photo_reporter::contextStatus, NULL ); return context_; }
int main(int argc, char *argv[]){ Camera *camera; GPContext *context = gp_context_new(); int retval; CameraEventType evttype; void *evtdata; CameraFile *file; gp_camera_new(&camera); retval = gp_camera_init(camera, context); if(retval != GP_OK) { printf("Error: %s\n", gp_result_as_string(retval)); return 1; } do { retval = gp_camera_wait_for_event (camera, 10, &evttype, &evtdata, context); } while ((retval == GP_OK) && (evttype != GP_EVENT_TIMEOUT)); retval = gp_file_new(&file); if (retval != GP_OK) { printf("gp_file_new: %d\n", retval); return 1; } /*retval = gp_camera_capture_preview(camera, file, context); */ if (retval != GP_OK) { printf("gp_camera_capture_preview: %d\n", retval); return 1; } gp_file_free (file); if(argc == 1) { retval = camera_auto_focus(camera, context); if(retval != GP_OK) { printf("Error: %s\n", gp_result_as_string(retval)); return 1; } } else if(argc == 2) { int value = atoi(argv[1]); retval = camera_manual_focus(camera, value, context); if(retval != GP_OK) { printf("Error: %s\n", gp_result_as_string(retval)); return 1; } } do { retval = gp_camera_wait_for_event (camera, 10, &evttype, &evtdata, context); } while ((retval == GP_OK) && (evttype != GP_EVENT_TIMEOUT)); gp_camera_exit(camera, context); return 0; }
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; }
// Create a constext. used in init. GPContext* create_context() { GPContext *context; context = gp_context_new(); // make sure we log errors. helps work out wtf is going on. gp_context_set_error_func (context, (GPContextErrorFunc) ctx_error_func, NULL); gp_context_set_status_func (context, (GPContextStatusFunc) ctx_status_func, NULL); return context; }
GPhotoCameraWorker::GPhotoCameraWorker(const CameraAbilities &abilities, const PortInfo &portInfo, QObject *parent) : QObject(parent) , m_abilities(abilities) , m_portInfo(portInfo) , m_context(gp_context_new()) , m_camera(0) , m_file(0) , m_capturingFailCount(0) , m_status(QCamera::UnloadedStatus) { if (!m_context) m_status = QCamera::UnavailableStatus; }
GPStatus() { #ifdef HAVE_GPHOTO2 context = gp_context_new(); cancel = false; gp_context_set_cancel_func(context, cancel_func, 0); #ifdef GPHOTO2_DEBUG gp_context_set_progress_funcs(context, start_func, update_func, stop_func, 0); gp_context_set_error_func(context, error_func, 0); gp_context_set_status_func(context, status_func, 0); #endif /* GPHOTO2_DEBUG */ #endif /* HAVE_GPHOTO2 */ }
int initCamera(){ gp_camera_new(&my_Camera); my_Context = gp_context_new(); int result = gp_camera_init(my_Camera, my_Context); printf("\n\nCamera Init Result: %d\n\n", result); if(result == -105){ printf("Camera not found, quitting.\n\n"); return -105; } return 0; }
int initCamera(){ gp_camera_new(&my_Camera); my_Context = gp_context_new(); int result = gp_camera_init(my_Camera, my_Context); printf(" Camera Init Result: %d ", result); if(result == -105){ printf(" Camera not found, quitting. "); return -105; } printf(" camera successfully found!\n"); return 0; }
BOOL WINAPI DllMain (HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved) { TRACE("%p,%x,%p\n", hinstDLL, fdwReason, lpvReserved); switch (fdwReason) { case DLL_PROCESS_ATTACH: GPHOTO2_instance = hinstDLL; DisableThreadLibraryCalls(hinstDLL); #ifdef HAVE_GPHOTO2 activeDS.context = gp_context_new (); #endif break; } return TRUE; }
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(); }
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 */ }
void gp_params_init (GPParams *p, char **envp) { if (!p) return; memset (p, 0, sizeof (GPParams)); p->folder = strdup ("/"); if (!p->folder) { fprintf (stderr, _("Not enough memory.")); fputc ('\n', stderr); exit (1); } gp_camera_new (&p->camera); p->cols = 79; p->flags = FLAGS_RECURSE; /* Create a context. Report progress only if users will see it. */ p->context = gp_context_new (); gp_context_set_cancel_func (p->context, ctx_cancel_func, p); gp_context_set_error_func (p->context, ctx_error_func, p); gp_context_set_status_func (p->context, ctx_status_func, p); gp_context_set_message_func (p->context, ctx_message_func, p); if (isatty (STDOUT_FILENO)) gp_context_set_progress_funcs (p->context, ctx_progress_start_func, ctx_progress_update_func, ctx_progress_stop_func, p); p->_abilities_list = NULL; p->debug_func_id = -1; p->envp = envp; }
int init(t_cam *c) { c->liveview = 0; c->liveview_fps = 30; c->liveview_fps_time = 1000000 / 30; pthread_mutex_init(&c->liveview_mutex, NULL); pthread_cond_init(&c->liveview_condvar, NULL); c->folder_path = strdup("/tmp/"); c->camera_value_list = NULL; gp_context_set_error_func(c->context, (GPContextErrorFunc)error_func, NULL); gp_context_set_message_func(c->context, (GPContextMessageFunc)message_func, NULL); gp_camera_new(&c->camera); c->context = gp_context_new(); printf("Camera Init\n"); c->ret = gp_camera_init(c->camera, c->context); if (c->ret != GP_OK) { printf("gp_camera_init: %d\n", c->ret); return (GP_ERROR); } /* get_initial_camera_values(t_cam *c); */ return (GP_OK); }
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; }
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; }
Context::Context(bool use_messages) : context(gp_context_new()) { if (use_messages) init_messages(); }
photoController::photoController() { context = gp_context_new(); gp_context_set_error_func(context, ContextErrorPrint, NULL); initCamera(); }
int main () { CameraFilesystem *fs; CameraFileInfo info; CameraList *list; int x, count; const char *name; char *foldername; GPContext *context; #ifdef HAVE_MCHECK_H mtrace(); #endif CHECK (gp_list_new(&list)); gp_log_add_func (GP_LOG_DEBUG, log_func, NULL); context = gp_context_new (); gp_context_set_error_func (context, error_func, NULL); printf ("*** Creating file system...\n"); CHECK (gp_filesystem_new (&fs)); printf ("*** Setting the callbacks...\n"); CHECK (gp_filesystem_set_funcs (fs, &fsfuncs, NULL)); printf ("*** Adding a file...\n"); CHECK (gp_filesystem_append (fs, "/", "my.file", context)); gp_filesystem_dump (fs); printf ("*** Removing this file...\n"); CHECK (gp_filesystem_delete_file (fs, "/", "my.file", context)); gp_filesystem_dump (fs); printf ("*** Resetting...\n"); CHECK (gp_filesystem_reset (fs)); gp_filesystem_dump (fs); printf ("*** Adding /...\n"); CHECK (gp_filesystem_append (fs, "/", NULL, context)); printf ("*** Adding /whatever ...\n"); CHECK (gp_filesystem_append (fs, "/whatever", NULL, context)); printf ("*** Adding /whatever/dir...\n"); CHECK (gp_filesystem_append (fs, "/whatever/dir", NULL, context)); printf ("*** Adding /whatever/dir/file1...\n"); CHECK (gp_filesystem_append (fs, "/whatever/dir", "file1", context)); gp_filesystem_dump (fs); printf ("*** Adding /whatever/dir/file2...\n"); CHECK (gp_filesystem_append (fs, "/whatever/dir", "file2", context)); CHECK (gp_filesystem_append (fs, "/whatever/dir", "file3", context)); CHECK (gp_filesystem_append (fs, "/whatever/dir", "file4", context)); CHECK (gp_filesystem_append (fs, "/whatever/dir", "file5", context)); gp_filesystem_dump (fs); printf ("*** Deleting everything below root...\n"); CHECK (gp_filesystem_delete_all (fs, "/", context)); gp_filesystem_dump (fs); printf ("*** Appending root directory...\n"); CHECK (gp_filesystem_append (fs, "/", NULL, context)); printf ("*** Appending some directories...\n"); CHECK (gp_filesystem_append (fs, "/whatever", NULL, context)); CHECK (gp_filesystem_append (fs, "/whatever/directory", NULL, context)); printf ("*** Adding some files...\n"); CHECK (gp_filesystem_append (fs, "/whatever/directory", "some.file", context)); CHECK (gp_filesystem_append (fs, "/whatever/directory", "some.file2", context)); CHECK (gp_filesystem_append (fs, "/another/directory", "another.file", context)); gp_filesystem_dump (fs); printf ("*** Getting info about a file...\n"); CHECK (gp_filesystem_get_info (fs, "/whatever/directory", "some.file", &info, context)); printf ("*** Getting info again (cache!)...\n"); CHECK (gp_filesystem_get_info (fs, "/whatever/directory", "some.file", &info, context)); printf ("*** Set info about another file...\n"); CHECK (gp_filesystem_set_info (fs, "/whatever/directory", "some.file2", info, context)); printf ("*** Getting info about this file (cache!)...\n"); CHECK (gp_filesystem_get_info (fs, "/whatever/directory", "some.file2", &info, context)); printf ("*** Deleting a file...\n"); CHECK (gp_filesystem_delete_file (fs, "/whatever/directory", "some.file2", context)); gp_filesystem_dump (fs); printf ("*** Resetting the filesystem...\n"); CHECK (gp_filesystem_reset (fs)); gp_filesystem_dump (fs); printf ("*** Getting file list for folder '/whatever/directory'...\n"); CHECK (gp_filesystem_list_folders (fs, "/whatever/directory", list, context)); printf ("*** Getting file list for folder '/whatever/directory' " "again (cached!)...\n"); CHECK (gp_filesystem_list_folders (fs, "/whatever/directory", list, context)); printf ("*** Counting the contents...\n"); CHECK (count = gp_list_count (list)); printf ("*** Listing the contents...\n"); for (x = 0; x < count; x++) { CHECK (gp_list_get_name (list, x, &name)); printf (" %i: '%s'\n", x, name); } printf ("*** Getting folder of 'file1'...\n"); CHECK (gp_filesystem_get_folder (fs, "file1", &foldername, context)); printf ("... found in '%s'.\n", foldername); free(foldername); printf ("*** Deleting a couple of files...\n"); CHECK (gp_filesystem_delete_file (fs, "/whatever", "file5", context)); CHECK (gp_filesystem_delete_file (fs, "/whatever", "file4", context)); CHECK (gp_filesystem_delete_file (fs, "/whatever", "file3", context)); gp_filesystem_dump (fs); printf ("*** Freeing file system...\n"); CHECK (gp_filesystem_free (fs)); gp_context_unref (context); CHECK (gp_list_free(list)); #ifdef HAVE_MCHECK_H muntrace(); #endif return (0); }
int cameraFunction(int command) { int i, retval, ss, commandint; gp_camera_new(&canon); canoncontext = gp_context_new(); gp_log_add_func(GP_LOG_ERROR, errordumper, NULL); printf("Camera init. Takes about 3 seconds.\n"); retval = gp_camera_init(canon, canoncontext); if (retval != GP_OK) { printf(" Retval: %d\n", retval); exit(1); } else { printf("okay"); } canon_enable_capture(canon, TRUE, canoncontext); printf("ready to rock\n"); //i = getchar(); //getchar(); //commandint = atoi(command); switch (command) { case 'c': { capture(canon, canoncontext); break; } case 's': { ss = getchar(); getchar(); printf("ss is %c\n", ss); shutterchange(canon, canoncontext, ss); break; } case 'a': { int ap; ap = getchar(); getchar(); aperturechange(canon, canoncontext, ap); printf("aperture: %d", ap); break; } case 'i': { int iso; iso = getchar(); getchar(); isochange(canon, canoncontext, iso); printf("iso: %d", iso); break; } case 'l': { while (1) { liveview(canon, canoncontext); } break; } case 'q': { gp_camera_exit(canon, canoncontext); break; } default: capture(canon, canoncontext); return 0; } return 0; } //end of code
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 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; }