int main(int argc, char **argv) { Camera *canon; int retval; GPContext *canoncontext = sample_create_context(); gettimeofday(&starttime,NULL); gp_log_add_func(GP_LOG_ERROR, errordumper, NULL); gp_camera_new(&canon); /* When I set GP_LOG_DEBUG instead of GP_LOG_ERROR above, I noticed that the * init function seems to traverse the entire filesystem on the camera. This * is partly why it takes so long. * (Marcus: the ptp2 driver does this by default currently.) */ printf("Camera init. Takes about 10 seconds.\n"); retval = gp_camera_init(canon, canoncontext); if (retval != GP_OK) { printf(" Retval: %d\n", retval); exit (1); } canon_enable_capture(canon, TRUE, canoncontext); /*set_capturetarget(canon, canoncontext);*/ capture_to_file(canon, canoncontext, "foo.jpg"); gp_camera_exit(canon, canoncontext); return 0; }
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; }
CAMLprim value caml_gp_camera_new(value unit_val) { CAMLparam0(); Camera *cam; int ret = gp_camera_new(&cam); CHECK_RESULT(ret); CAMLreturn(encapsulate_pointer(cam)); }
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; }
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; }
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; }
/** * 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; } }
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 photo_camera::photo_camera_open( photo_camera_list* list, const std::string model_name, const std::string port_name ) { // Create a context if necessary if( context_ == NULL ) { context_ = photo_camera_create_context(); } // Create new camera if( gp_camera_new( &camera_ ) != GP_OK ) { photo_reporter::error( "gp_camera_new()" ); return false; } // Find and set camera abilities based on model //std::cout << "Model name: " << model_name << " == " << std::endl; if( list->lookupAbilities( model_name, &abilities_ ) == true ) { // Set the camera's abilities if( gp_camera_set_abilities( camera_, abilities_ ) != GP_OK ) { photo_reporter::error( "gp_camera_set_abilities()" ); return false; } } else { return false; } // Associate camera with port if( list->lookupPortInfo( port_name, &port_info_ ) == true ) { if( gp_camera_set_port_info( camera_, port_info_ ) != GP_OK ) { photo_reporter::error( "gp_camera_set_port_info()" ); return false; } } else { return false; } // Camera is open! return true; }
CameraController() { int retval; context = sample_create_context(); gp_log_add_func(GP_LOG_ERROR, errordumper, NULL); gp_camera_new(&camera); printf("Camera init. Takes a few seconds.\n"); signal(SIGTERM, handle_sigterm); retval = gp_camera_init(camera, context); if (retval != GP_OK) { printf(" Retval: %d\n", retval); exit (1); } }
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; } }
/** * @brief QTLCamera::initCamera * @return */ QTLError QTLCamera::initCamera() { QTLError result; result.rc = GP_OK; result.errorText = "Camera initialized."; // Set aside memory for camera result.rc = gp_camera_new(¶ms->camera); if (result.rc != GP_OK) { result.errorText = gp_result_as_string(result.rc); return result; } // Initialise camera qDebug() << "Detecting Camera."; result.rc = gp_camera_init(params->camera, params->context); if (result.rc != GP_OK) { result.errorText = gp_result_as_string(result.rc); if (result.rc == -105) { result.errorText = "Failed to initialise camera. Please check the camera " \ "is turned on, then re-initialise or restart the program to enable" \ " camera paramaters."; } else if (result.rc == -60 || result.rc == -53) { result.errorText = "Failed to initialise camera. Please check the camera " \ "is unmounted and that no other applications are using it, then " \ "re-initialise or restart the program to enable camera paramaters."; } } else { qDebug() << "Camera detected"; qDebug() << "Detecting widgets" << endl; CameraWidget *rootConfig; result.rc = gp_camera_get_config(params->camera, &rootConfig, params->context); if (result.rc == GP_OK) { char prefix[] = ""; _getWidgets(params->widgetList, rootConfig, prefix); gp_widget_free(rootConfig); } qDebug() << "Widgets detected"; } return result; }
int main(int argc, char **argv) { Camera *camera; int ret; char *owner; GPContext *context; CameraText text; context = sample_create_context (); /* see context.c */ gp_camera_new (&camera); /* This call will autodetect cameras, take the * first one from the list and use it. It will ignore * any others... See the *multi* examples on how to * detect and use more than the first one. */ ret = gp_camera_init (camera, context); if (ret < GP_OK) { printf("No camera auto detected.\n"); gp_camera_free (camera); return 0; } /* Simple query the camera summary text */ ret = gp_camera_get_summary (camera, &text, context); if (ret < GP_OK) { printf("Camera failed retrieving summary.\n"); gp_camera_free (camera); return 0; } printf("Summary:\n%s\n", text.text); /* Simple query of a string configuration variable. */ ret = get_config_value_string (camera, "owner", &owner, context); if (ret >= GP_OK) { printf("Owner: %s\n", owner); free (owner); } gp_camera_exit (camera, context); gp_camera_free (camera); gp_context_unref (context); return 0; }
int main(int argc, char **argv) { Camera *camera; int ret; char *owner; GPContext *context; context = sample_create_context (); /* see context.c */ gp_log_add_func(GP_LOG_ERROR, errordumper, NULL); gp_camera_new (&camera); /* This call will autodetect cameras, take the * first one from the list and use it. It will ignore * any others... See the *multi* examples on how to * detect and use more than the first one. */ ret = gp_camera_init (camera, context); if (ret < GP_OK) { printf("No camera auto detected.\n"); gp_camera_free (camera); return 0; } ret = get_config_value_string (camera, "ownername", &owner, context); if (ret < GP_OK) { printf ("Could not query owner.\n"); goto out; } printf("Current owner: %s\n", owner); if (argc > 1) { ret = set_config_value_string (camera, "ownername", argv[1], context); if (ret < GP_OK) { fprintf (stderr, "Failed to set camera owner to %s; %d\n", argv[1], ret); } else printf("New owner: %s\n", argv[1]); } out: gp_camera_exit (camera, context); gp_camera_free (camera); return 0; }
void GPhotoCameraWorker::openCamera() { // Camera is already open if (m_camera) return; setStatus(QCamera::LoadingStatus); // Create camera object int ret = gp_camera_new(&m_camera); if (ret != GP_OK) { openCameraErrorHandle("Unable to open camera"); return; } ret = gp_camera_set_abilities(m_camera, m_abilities); if (ret < GP_OK) { openCameraErrorHandle("Unable to set abilities for camera"); return; } ret = gp_camera_set_port_info(m_camera, m_portInfo.portInfo); if (ret < GP_OK) { openCameraErrorHandle("Unable to set port info for camera"); return; } ret = gp_file_new(&m_file); if (ret < GP_OK) { openCameraErrorHandle("Could not create capture file"); return; } if (parameter("viewfinder").isValid()) { if (!setParameter("viewfinder", true)) qWarning() << "Failed to flap up camera mirror"; } m_capturingFailCount = 0; setStatus(QCamera::LoadedStatus); }
bool photoController::initCamera() { gp_camera_new (&camera); DEBUG_PRINTF(V_MESSAGE, "Camera initialization (gp_camera_init).\n"); int retval = gp_camera_init(camera, context); if (retval != GP_OK) { DEBUG_PRINTF(V_WARNING, "Could not detect any camera!\n"); camera_detected = false; gp_camera_unref(camera); camera = NULL; // TODO - Retry camera initialization, if fails, signalize with led (and TCP message?). } else { DEBUG_PRINTF(V_MESSAGE, "Camera detected!\n"); camera_detected = true; setPhotoQuality(); } return camera_detected; }
// function to make sure the camara is initalised void initCamaraAndContext() { if(resetNextTime) { tc_reset(); resetNextTime = false; } if( context == NULL && camera == NULL ) { context = create_context (); gp_camera_new (&camera); if( gp_camera_init (camera, context) < GP_OK ) { initFailed = true; tc_reset(); } else { internal_set_setting("capture", "1"); initFailed = false; } } }
int main(int argc, char **argv) { Camera *camera; int retval; GPContext *context = sample_create_context(); FILE *f; char *data; unsigned long size; gp_log_add_func(GP_LOG_ERROR, errordumper, NULL); gp_camera_new(&camera); /* When I set GP_LOG_DEBUG instead of GP_LOG_ERROR above, I noticed that the * init function seems to traverse the entire filesystem on the camera. This * is partly why it takes so long. * (Marcus: the ptp2 driver does this by default currently.) */ printf("Camera init. Takes about 10 seconds.\n"); retval = gp_camera_init(camera, context); if (retval != GP_OK) { printf(" Retval of capture_to_file: %d\n", retval); exit (1); } capture_to_file(camera, context, "foo.jpg"); capture_to_memory(camera, context, (const char**)&data, &size); f = fopen("foo2.jpg", "wb"); if (f) { retval = fwrite (data, size, 1, f); if (retval != size) { printf(" fwrite size %ld, written %d\n", size, retval); } fclose(f); } else printf(" fopen foo2.jpg failed.\n"); gp_camera_exit(camera, context); return 0; }
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 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; }
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 */ }
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
int main(int argc, char **argv) { Camera *canon; int i, retval; GPContext *canoncontext = sample_create_context(); gp_log_add_func(GP_LOG_ERROR, errordumper, 0); gp_camera_new(&canon); /* When I set GP_LOG_DEBUG instead of GP_LOG_ERROR above, I noticed that the * init function seems to traverse the entire filesystem on the camera. This * is partly why it takes so long. * (Marcus: the ptp2 driver does this by default currently.) */ printf("Camera init. Takes about 10 seconds.\n"); retval = gp_camera_init(canon, canoncontext); if (retval != GP_OK) { printf(" Retval: %d\n", retval); exit (1); } canon_enable_capture(canon, TRUE, canoncontext); retval = camera_eosviewfinder(canon,canoncontext,1); if (retval != GP_OK) { fprintf(stderr,"camera_eosviewfinder(1): %d\n", retval); exit(1); } /*set_capturetarget(canon, canoncontext);*/ printf("Taking 100 previews and saving them to snapshot-XXX.jpg ...\n"); for (i=0;i<100;i++) { CameraFile *file; char output_file[32]; fprintf(stderr,"preview %d\n", i); retval = gp_file_new(&file); if (retval != GP_OK) { fprintf(stderr,"gp_file_new: %d\n", retval); exit(1); } /* autofocus every 10 shots */ if (i%10 == 9) { camera_auto_focus (canon, canoncontext, 1); /* FIXME: wait a bit and/or poll events ? */ camera_auto_focus (canon, canoncontext, 0); } else { camera_manual_focus (canon, (i/10-5)/2, canoncontext); } #if 0 /* testcase for EOS zooming */ { char buf[20]; if (i<10) set_config_value_string (canon, "eoszoom", "5", canoncontext); sprintf(buf,"%d,%d",(i&0x1f)*64,(i>>5)*64); fprintf(stderr, "%d - %s\n", i, buf); set_config_value_string (canon, "eoszoomposition", buf, canoncontext); } #endif retval = gp_camera_capture_preview(canon, file, canoncontext); if (retval != GP_OK) { fprintf(stderr,"gp_camera_capture_preview(%d): %d\n", i, retval); exit(1); } sprintf(output_file, "snapshot-%03d.jpg", i); retval = gp_file_save(file, output_file); if (retval != GP_OK) { fprintf(stderr,"gp_camera_capture_preview(%d): %d\n", i, retval); exit(1); } gp_file_unref(file); /* sprintf(output_file, "image-%03d.jpg", i); capture_to_file(canon, canoncontext, output_file); */ } retval = camera_eosviewfinder(canon,canoncontext,0); if (retval != GP_OK) { fprintf(stderr,"camera_eosviewfinder(0): %d\n", retval); exit(1); } sleep(10); gp_camera_exit(canon, canoncontext); return 0; }
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; }
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; }
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); }
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); }
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; }