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 main(int argc, char **argv) {
Camera *camera = NULL;
int ret;
GPContext *context;
CameraWidget *rootwidget;
char buf[200];
CameraText summary;
gp_log_add_func(GP_LOG_DEBUG, errordumper, NULL);
context = sample_create_context (); /* see context.c */
strcpy(buf,"usb:");
if (argc > 1)
strcat (buf, argv[1]);
fprintf(stderr,"setting path %s.\n", buf);
ret = sample_open_camera (&camera, "USB PTP Class Camera", buf, context);
if (ret < GP_OK) {
fprintf(stderr,"camera %s not found.\n", buf);
goto out;
}
ret = gp_camera_init (camera, context);
if (ret < GP_OK) {
fprintf(stderr,"No camera auto detected.\n");
goto out;
}
/* AFL PART STARTS HERE */
ret = gp_camera_get_summary (camera, &summary, context);
if (ret < GP_OK) {
printf ("Could not get summary.\n");
goto out;
}
#if 1
ret = gp_camera_get_config (camera, &rootwidget, context);
if (ret < GP_OK) {
fprintf (stderr,"Could not get config.\n");
goto out;
}
#endif
printf ("OK, %s\n", summary.text);
/* AFL PART ENDS HERE */
out:
gp_camera_exit (camera, context);
gp_camera_free (camera);
return 0;
}
void Context::init_messages() {
gp_context_set_error_func(context, error_func, NULL);
gp_context_set_message_func(context, msg_func, NULL);
gp_context_set_status_func(context, status_func, NULL);
// debug logging is massive
const char *debug_enable = getenv("GPWRAP_LOG_DEBUG");
static bool debug_created;
if (debug_enable && debug_enable[0] == '1' && !debug_created) {
debug_created = true;
// maybe should have a top-level class for this as it's not context specific
// typecast because just enum vs int in header, should be safe
gp_log_add_func(GP_LOG_DEBUG, reinterpret_cast<GPLogFunc>(log_func), NULL);
}
}
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);
}
}
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;
}
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;
}
int main(int argc, char **argv) {
Camera *camera = NULL;
int ret;
GPContext *context;
CameraWidget *rootwidget;
char buf[200];
CameraText summary;
gp_log_add_func(GP_LOG_DEBUG, errordumper, NULL);
context = sample_create_context (); /* see context.c */
strcpy(buf,"usb:");
if (argc > 1)
strcat (buf, argv[1]);
fprintf(stderr,"setting path %s.\n", buf);
ret = sample_open_camera (&camera, "USB PTP Class Camera", buf, context);
if (ret < GP_OK) {
fprintf(stderr,"camera %s not found.\n", buf);
goto out;
}
ret = gp_camera_init (camera, context);
if (ret < GP_OK) {
fprintf(stderr,"No camera auto detected.\n");
goto out;
}
/* AFL PART STARTS HERE */
ret = recursive_directory(camera, "/", context, NULL);
if (ret < GP_OK) {
printf ("Could not recursive list files.\n");
goto out;
}
ret = gp_camera_get_summary (camera, &summary, context);
if (ret < GP_OK) {
printf ("Could not get summary.\n");
goto out;
}
#if 1
ret = gp_camera_get_config (camera, &rootwidget, context);
if (ret < GP_OK) {
fprintf (stderr,"Could not get config.\n");
goto out;
}
#endif
printf ("OK, %s\n", summary.text);
while (1) {
CameraEventType evttype;
void *data = NULL;
ret = gp_camera_wait_for_event(camera, 1, &evttype, &data, context);
if (ret < GP_OK) break;
if (data) free (data);
if (evttype == GP_EVENT_TIMEOUT) break;
}
/* AFL PART ENDS HERE */
out:
gp_camera_exit (camera, context);
gp_camera_free (camera);
return 0;
}
void _enable_debug()
{
logid=gp_log_add_func(GP_LOG_DATA,(GPLogFunc)_gphoto_log,NULL);
}
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);
}
/**
* 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);
}
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;
}