static int32_t dt_camera_import_job_run(dt_job_t *job) { dt_camera_import_t *params = dt_control_job_get_params(job); dt_control_log(_("starting to import images from camera")); if(!dt_import_session_ready(params->shared.session)) { dt_control_log("Failed to import images from camera."); return 1; } guint total = g_list_length(params->images); char message[512] = { 0 }; snprintf(message, sizeof(message), ngettext("importing %d image from camera", "importing %d images from camera", total), total); dt_control_job_set_progress_message(job, message); // Switch to new filmroll dt_film_open(dt_import_session_film_id(params->shared.session)); dt_ctl_switch_mode_to(DT_LIBRARY); // register listener dt_camctl_listener_t listener = { 0 }; listener.data = params; listener.image_downloaded = _camera_import_image_downloaded; listener.request_image_path = _camera_request_image_path; listener.request_image_filename = _camera_request_image_filename; // start download of images dt_camctl_register_listener(darktable.camctl, &listener); dt_camctl_import(darktable.camctl, params->camera, params->images); dt_camctl_unregister_listener(darktable.camctl, &listener); return 0; }
void gui_cleanup(dt_lib_module_t *self) { dt_lib_camera_t *lib = self->data; dt_gui_key_accel_block_on_focus_disconnect(lib->gui.plabel); dt_gui_key_accel_block_on_focus_disconnect(lib->gui.pname); // remove listener from camera control.. dt_camctl_tether_mode(darktable.camctl, NULL, FALSE); dt_camctl_unregister_listener(darktable.camctl, lib->data.listener); }
void gui_cleanup (dt_lib_module_t *self) { dt_lib_camera_t *lib = self->data; // remove listener from camera control.. dt_camctl_tether_mode(darktable.camctl,NULL,FALSE); dt_camctl_unregister_listener(darktable.camctl,lib->data.listener); }
static int32_t dt_camera_get_previews_job_run(dt_job_t *job) { dt_camera_get_previews_t *params = dt_control_job_get_params(job); dt_camctl_register_listener(darktable.camctl, params->listener); dt_camctl_get_previews(darktable.camctl, params->flags, params->camera); dt_camctl_unregister_listener(darktable.camctl, params->listener); return 0; }
int32_t dt_camera_get_previews_job_run(dt_job_t *job) { dt_camera_get_previews_t *t=(dt_camera_get_previews_t*)job->param; dt_camctl_register_listener(darktable.camctl,t->listener); dt_camctl_get_previews(darktable.camctl,t->flags,t->camera); dt_camctl_unregister_listener(darktable.camctl,t->listener); g_free(t->listener); return 0; }
gboolean _bailout_of_tethering(gpointer user_data) { /* consider all error types as failure and bailout of tethering mode */ dt_lib_camera_t *lib = (dt_lib_camera_t *)user_data; dt_camctl_tether_mode(darktable.camctl, NULL, FALSE); dt_camctl_unregister_listener(darktable.camctl, lib->data.listener); /* switch back to library mode */ dt_ctl_switch_mode_to(DT_LIBRARY); return FALSE; }
void gui_cleanup(dt_lib_module_t *self) { #ifdef HAVE_GPHOTO2 dt_lib_import_t *d = (dt_lib_import_t*)self->data; /* unregister camctl listener */ dt_camctl_unregister_listener(darktable.camctl, &d->camctl_listener ); #endif /* cleanup mem */ g_free(self->data); self->data = NULL; }
void gui_cleanup(dt_lib_module_t *self) { #ifdef HAVE_GPHOTO2 dt_control_signal_disconnect(darktable.signals, G_CALLBACK(_camera_detected), self); dt_lib_import_t *d = (dt_lib_import_t *)self->data; /* unregister camctl listener */ dt_camctl_unregister_listener(darktable.camctl, &d->camctl_listener); #endif /* cleanup mem */ g_free(self->data); self->data = NULL; }
void view_leave(struct dt_lib_module_t *self,struct dt_view_t *old_view,struct dt_view_t *new_view) { dt_lib_camera_t *lib = self->data; // remove listener from camera control.. dt_camctl_tether_mode(darktable.camctl, NULL, FALSE); dt_camctl_unregister_listener(darktable.camctl, lib->data.listener); gtk_widget_destroy(GTK_WIDGET(lib->gui.properties_menu)); lib->gui.properties_menu = NULL; // remove all properties while(lib->gui.prop_end > lib->gui.prop_start +1) { gtk_grid_remove_row(lib->gui.main_grid,lib->gui.prop_start +1); lib->gui.rows--; lib->gui.prop_end--; } // no need to free widgets, they are freed when the line of the grid is destroyed g_list_free_full(lib->gui.properties,_lib_property_free); lib->gui.properties = NULL; }
void leave(dt_view_t *self) { dt_capture_t *cv = (dt_capture_t *)self->data; dt_camctl_unregister_listener(darktable.camctl, cv->listener); g_free(cv->listener); cv->listener = NULL; /* destroy session, will cleanup empty film roll */ dt_import_session_destroy(cv->session); /* disconnect from mipmap updated signal */ dt_control_signal_disconnect(darktable.signals, G_CALLBACK(_capture_mipmaps_updated_signal_callback), (gpointer)self); /* disconnect from filmstrip image activate */ dt_control_signal_disconnect(darktable.signals, G_CALLBACK(_view_capture_filmstrip_activate_callback), (gpointer)self); }
int32_t dt_camera_import_job_run(dt_job_t *job) { dt_camera_import_t *t = (dt_camera_import_t *)job->param; dt_control_log(_("starting to import images from camera")); if (!dt_import_session_ready(t->shared.session)) { dt_control_log("Failed to import images from camera."); return 1; } int total = g_list_length( t->images ); char message[512]= {0}; sprintf(message, ngettext ("importing %d image from camera", "importing %d images from camera", total), total ); t->bgj = dt_control_backgroundjobs_create(darktable.control, 0, message); // Switch to new filmroll dt_film_open(dt_import_session_film_id(t->shared.session)); dt_ctl_switch_mode_to(DT_LIBRARY); // register listener dt_camctl_listener_t listener= {0}; listener.data=t; listener.image_downloaded=_camera_import_image_downloaded; listener.request_image_path=_camera_request_image_path; listener.request_image_filename=_camera_request_image_filename; // start download of images dt_camctl_register_listener(darktable.camctl,&listener); dt_camctl_import(darktable.camctl,t->camera,t->images); dt_camctl_unregister_listener(darktable.camctl,&listener); dt_control_backgroundjobs_destroy(darktable.control, t->bgj); dt_import_session_destroy(t->shared.session); return 0; }
int32_t dt_camera_import_job_run(dt_job_t *job) { dt_camera_import_t *t = (dt_camera_import_t *)job->param; dt_control_log(_("starting to import images from camera")); // Setup a new filmroll to import images to.... t->film=(dt_film_t*)g_malloc(sizeof(dt_film_t)); dt_film_init(t->film); gchar* fixed_path = dt_util_fix_path(t->path); g_free(t->path); t->path = fixed_path; dt_variables_expand( t->vp, t->path, FALSE ); sprintf(t->film->dirname,"%s",dt_variables_get_result(t->vp)); dt_pthread_mutex_lock(&t->film->images_mutex); t->film->ref++; dt_pthread_mutex_unlock(&t->film->images_mutex); // Create recursive directories, abort if no access if( g_mkdir_with_parents(t->film->dirname,0755) == -1 ) { dt_control_log(_("failed to create import path `%s', import aborted."), t->film->dirname); return 1; } // Import path is ok, lets actually create the filmroll in database.. if(dt_film_new(t->film,t->film->dirname) > 0) { int total = g_list_length( t->images ); char message[512]= {0}; sprintf(message, ngettext ("importing %d image from camera", "importing %d images from camera", total), total ); t->bgj = dt_control_backgroundjobs_create(darktable.control, 0, message); // Switch to new filmroll dt_film_open(t->film->id); dt_ctl_switch_mode_to(DT_LIBRARY); // register listener dt_camctl_listener_t listener= {0}; listener.data=t; listener.image_downloaded=_camera_image_downloaded; listener.request_image_path=_camera_import_request_image_path; listener.request_image_filename=_camera_import_request_image_filename; // start download of images dt_camctl_register_listener(darktable.camctl,&listener); dt_camctl_import(darktable.camctl,t->camera,t->images,dt_conf_get_bool("plugins/capture/camera/import/delete_originals")); dt_camctl_unregister_listener(darktable.camctl,&listener); dt_control_backgroundjobs_destroy(darktable.control, t->bgj); dt_variables_params_destroy(t->vp); } else dt_control_log(_("failed to create filmroll for camera import, import aborted.")); dt_pthread_mutex_lock(&t->film->images_mutex); t->film->ref--; dt_pthread_mutex_unlock(&t->film->images_mutex); return 0; }
static int32_t dt_camera_capture_job_run(dt_job_t *job) { dt_camera_capture_t *params = dt_control_job_get_params(job); int total; char message[512]= {0}; double fraction=0; total = params->total = params->brackets ? params->count * params->brackets : params->count; snprintf(message, sizeof(message), ngettext ("capturing %d image", "capturing %d images", total), total ); pthread_mutex_init(¶ms->mutex, NULL); pthread_cond_init(¶ms->done, NULL); // register listener dt_camctl_listener_t *listener; listener = g_malloc0(sizeof(dt_camctl_listener_t)); listener->data = params; listener->image_downloaded = _camera_capture_image_downloaded; listener->request_image_path = _camera_request_image_path; listener->request_image_filename = _camera_request_image_filename; dt_camctl_register_listener(darktable.camctl, listener); /* try to get exp program mode for nikon */ char *expprogram = (char *)dt_camctl_camera_get_property(darktable.camctl, NULL, "expprogram"); /* if fail, lets try fetching mode for cannon */ if(!expprogram) expprogram = (char *)dt_camctl_camera_get_property(darktable.camctl, NULL, "autoexposuremode"); /* Fetch all values for shutterspeed and initialize current value */ GList *values=NULL; gconstpointer original_value=NULL; const char *cvalue = dt_camctl_camera_get_property(darktable.camctl, NULL, "shutterspeed"); const char *value = dt_camctl_camera_property_get_first_choice(darktable.camctl, NULL, "shutterspeed"); /* get values for bracketing */ if (params->brackets && expprogram && expprogram[0]=='M' && value && cvalue) { do { // Add value to list values = g_list_append(values, g_strdup(value)); // Check if current values is the same as original value, then lets store item ptr if (strcmp(value,cvalue) == 0) original_value = g_list_last(values)->data; } while ((value = dt_camctl_camera_property_get_next_choice(darktable.camctl, NULL, "shutterspeed")) != NULL); } else { /* if this was an intended bracket capture bail out */ if(params->brackets) { dt_control_log(_("please set your camera to manual mode first!")); pthread_mutex_lock(¶ms->mutex); pthread_cond_wait(¶ms->done, ¶ms->mutex); pthread_mutex_unlock(¶ms->mutex); pthread_mutex_destroy(¶ms->mutex); pthread_cond_destroy(¶ms->done); dt_import_session_destroy(params->shared.session); dt_camctl_unregister_listener(darktable.camctl, listener); g_free(listener); free(params); return 1; } } /* create the bgjob plate */ const guint *jid = dt_control_backgroundjobs_create(darktable.control, 0, message); GList *current_value = g_list_find(values,original_value); for(uint32_t i=0; i < params->count; i++) { // Delay if active if(params->delay) g_usleep(params->delay*G_USEC_PER_SEC); for(uint32_t b=0; b < (params->brackets*2)+1; b++) { // If bracket capture, lets set change shutterspeed if (params->brackets) { if (b == 0) { // First bracket, step down time with (steps*brackets), also check so we never set the longest shuttertime which would be bulb mode for(uint32_t s=0; s < (params->steps * params->brackets); s++) if (g_list_next(current_value) && g_list_next(g_list_next(current_value))) current_value = g_list_next(current_value); } else { // Step up with (steps) for(uint32_t s=0; s < params->steps; s++) if(g_list_previous(current_value)) current_value = g_list_previous(current_value); } } // set the time property for bracket capture if (params->brackets && current_value) dt_camctl_camera_set_property_string(darktable.camctl, NULL, "shutterspeed", current_value->data); // Capture image dt_camctl_camera_capture(darktable.camctl,NULL); fraction += 1.0/total; dt_control_backgroundjobs_progress(darktable.control, jid, fraction); } // lets reset to original value before continue if (params->brackets) { current_value = g_list_find(values,original_value); dt_camctl_camera_set_property_string(darktable.camctl, NULL, "shutterspeed", current_value->data); } } /* wait for last image capture before exiting job */ pthread_mutex_lock(¶ms->mutex); pthread_cond_wait(¶ms->done, ¶ms->mutex); pthread_mutex_unlock(¶ms->mutex); pthread_mutex_destroy(¶ms->mutex); pthread_cond_destroy(¶ms->done); /* cleanup */ dt_control_backgroundjobs_destroy(darktable.control, jid); dt_import_session_destroy(params->shared.session); dt_camctl_unregister_listener(darktable.camctl, listener); g_free(listener); // free values if(values) { g_list_free_full(values, g_free); } free(params); return 0; }