FLIRA65-Capture.c

// Aravis capture program.

#define _POSIX_C_SOURCE 200809L

#include <aravis-0.4/arv.h>
#include <stdlib.h>
#include <time.h>
#include <unistd.h>
#include "savebuffer.h"

static gboolean cancel = FALSE;

static void
set_cancel (int signal)
{
	cancel = TRUE;
}

static char *arv_option_camera_name = "FLIR Systems AB-62600164";
static char *arv_option_debug_domains = NULL;
static gboolean arv_option_auto_buffer = FALSE;
static int arv_option_width = -1;
static int arv_option_height = -1;
static int arv_option_horizontal_binning = -1;
static int arv_option_vertical_binning = -1;
static int arv_option_max_frames = 1;
static int arv_option_max_errors_before_abort = 10;
static char * arv_option_save_dir = ".";
static char * arv_option_save_prefix = "";
static char * arv_option_save_type = "png";
static int arv_option_pixel_format = 8;
static int arv_option_sample_period = 0;

typedef bool(*SaveBuffer)(ArvBuffer*, const char*);
static SaveBuffer save_buffer_fn = NULL;

static SaveBuffer GetSaveBufferFn(const char * type)
{
	if (strcmp(type, "png") == 0)
		return arv_buffer_save_png;
	if (strcmp(type, "raw") == 0)
		return arv_buffer_save_raw;
	return NULL;
}

static const GOptionEntry arv_option_entries[] =
{
	{ "name",		'n', 0, G_OPTION_ARG_STRING,
		&arv_option_camera_name,"Camera name", NULL},
	{ "auto",		'a', 0, G_OPTION_ARG_NONE,
		&arv_option_auto_buffer,	"AutoBufferSize", NULL},
	{ "width", 		'w', 0, G_OPTION_ARG_INT,
		&arv_option_width,		"Width", NULL },
	{ "height", 		'h', 0, G_OPTION_ARG_INT,
		&arv_option_height, 		"Height", NULL },
	{ "h-binning", 		'\0', 0, G_OPTION_ARG_INT,
		&arv_option_horizontal_binning,"Horizontal binning", NULL },
	{ "v-binning", 		'\0', 0, G_OPTION_ARG_INT,
		&arv_option_vertical_binning, 	"Vertical binning", NULL },
	{ "debug", 		'd', 0, G_OPTION_ARG_STRING,
		&arv_option_debug_domains, 	"Debug mode", NULL },
	{ "frames",	'f',0, G_OPTION_ARG_INT, &arv_option_max_frames, "Number of frames to save", NULL},
	{ "directory", 'D', 0, G_OPTION_ARG_STRING, &arv_option_save_dir, "Directory for frame files (defaults to .)", NULL},
	{ "prefix", 'p',0, G_OPTION_ARG_STRING, &arv_option_save_prefix, "Prefix for frame files (defaults to Timestamp)", NULL},
	{ "type", 't',0, G_OPTION_ARG_STRING, &arv_option_save_type, "Type of file to save frames as", NULL},
	{ "errors", 'e', 0, G_OPTION_ARG_INT, &arv_option_max_errors_before_abort, "Errors before aborting", NULL},
	{ "pixel-format", 'F', 0, G_OPTION_ARG_INT, &arv_option_pixel_format, "Pixel format", NULL},
	{ "sample-period", 'T', 0, G_OPTION_ARG_INT, &arv_option_sample_period, "Sample period", NULL},
	{ NULL }
};

int main (int argc, char **argv)
{
	
	ArvCamera * camera;
	ArvStream *stream;
	ArvBuffer *buffer;
	GOptionContext *context;
	GError *error = NULL;
	char memory_buffer[100000];
	int i;

	arv_g_thread_init (NULL);
	arv_g_type_init ();

	context = g_option_context_new (NULL);
	g_option_context_add_main_entries (context, arv_option_entries, NULL);

	if (!g_option_context_parse (context, &argc, &argv, &error)) {
		g_option_context_free (context);
		g_print ("Option parsing failed: %s\n", error->message);
		g_error_free (error);
		return EXIT_FAILURE;
	}

	g_option_context_free (context);
	if (arv_option_max_frames < 0)
		arv_option_max_errors_before_abort = -1;
	
	save_buffer_fn = GetSaveBufferFn(arv_option_save_type);

	arv_debug_enable (arv_option_debug_domains);

	if (arv_option_camera_name == NULL)
		g_print ("Looking for the first available camera\n");
	else
		g_print ("Looking for camera '%s'\n", arv_option_camera_name);

	camera = arv_camera_new (arv_option_camera_name);
	
	int errors = 0;
	if (camera == NULL)
	{
		g_print("No device found");
		return 1;
	}

	guint payload_size = arv_camera_get_payload(camera);
	g_print ("payload size  = %d (0x%x)\n", payload_size, payload_size);
	

	stream = arv_camera_create_stream (camera, NULL, NULL);
	if (arv_option_auto_buffer)
	{
		g_object_set (stream,"socket-buffer", ARV_GV_STREAM_SOCKET_BUFFER_AUTO,"socket-buffer-size", 0,NULL);
	}
	
	for (i = 0; i < 30; i++)
	{
		arv_stream_push_buffer (stream, arv_buffer_new (payload_size, NULL));
	}
	
	arv_camera_stop_acquisition(camera);

	// set the bit depth
	ArvDevice * device = arv_camera_get_device(camera);
	ArvGcNode * feature = arv_device_get_feature(device, "PixelFormat");
	char * pix_format = "Mono8";
	if (arv_option_pixel_format == 14)
		pix_format = "Mono14";
	arv_gc_feature_node_set_value_from_string(ARV_GC_FEATURE_NODE(feature), pix_format, NULL);
	if (arv_option_pixel_format == 14)
	{
		feature = arv_device_get_feature(device, "CMOSBitDepth");
		arv_gc_feature_node_set_value_from_string(ARV_GC_FEATURE_NODE(feature), "bit14bit", NULL);
	}


	signal (SIGINT, set_cancel);
	signal (SIGQUIT, set_cancel);

	int captured_frames = 0;
	guint64 timeout=1000000;
	#define _CAN_STOP (arv_option_max_frames > 0 && captured_frames >= arv_option_max_frames)
	arv_camera_start_acquisition(camera);
	do {
		g_usleep (100000);
			do  {
			buffer = arv_stream_timeout_pop_buffer (stream, timeout);
			if (buffer == NULL) break;
			ArvBufferStatus status = arv_buffer_get_status(buffer);
			fprintf(stderr, "Status is %d\n", status);
			if (status == ARV_BUFFER_STATUS_SUCCESS)
			{
		
				
				
				if (timeout > 100000) timeout -= 1000;
				errors = 0;
				if (save_buffer_fn != NULL)
				{
					struct timespec timestamp;
					clock_gettime(CLOCK_REALTIME, &timestamp);
					char filename[BUFSIZ];
					if (strcmp(arv_option_save_prefix,"") != 0)
					{
						sprintf(filename, "%s/%s%d.%s", arv_option_save_dir,arv_option_save_prefix, captured_frames, arv_option_save_type);
					}
					else
					{
						sprintf(filename, "%s/%d.%03ld.%s", arv_option_save_dir, (int)timestamp.tv_sec, (long)(timestamp.tv_nsec/1.0e6), arv_option_save_type);
					}
					if ((*save_buffer_fn)(buffer, filename) == false)
					{
						g_print("Couldn't save frame %d to %s\n", captured_frames, filename);
						set_cancel(SIGQUIT);
					}
					g_print("Saved frame %d to %s\n", captured_frames, filename);
					char latest[] = "latest.png";
					sprintf(latest, "latest.%s", arv_option_save_type);
					unlink(latest);
					symlink(filename, latest);
				}
				captured_frames++;
				g_usleep(arv_option_sample_period);
			}
			else 
			{
				if (timeout < 10000000) timeout+=1000;
				fprintf(stderr, "%d errors out of %d allowed\n", errors, arv_option_max_errors_before_abort);
				arv_camera_stop_acquisition(camera);
				if (++errors > arv_option_max_errors_before_abort && arv_option_max_errors_before_abort >= 0)
				{
					set_cancel(SIGQUIT);
				}
				else
				{
					arv_camera_start_acquisition(camera);
				}
			}
			arv_stream_push_buffer (stream, buffer);
			
			
			
		} while (!cancel && buffer != NULL && !_CAN_STOP);
	} while (!cancel && !_CAN_STOP);
	arv_camera_stop_acquisition(camera);


	guint64 n_processed_buffers; guint64 n_failures; guint64 n_underruns;
	arv_stream_get_statistics (stream, &n_processed_buffers, &n_failures, &n_underruns);
	g_print ("Processed buffers = %Lu\n", (unsigned long long) n_processed_buffers);
	g_print ("Failures          = %Lu\n", (unsigned long long) n_failures);
	g_print ("Underruns         = %Lu\n", (unsigned long long) n_underruns);


	g_object_unref (stream);
	g_object_unref (camera);
	
	
	return (errors > 0);
}