diff --git a/yavta.c b/yavta.c
index 3db1e5b..0332a79 100644
--- a/yavta.c
+++ b/yavta.c
@@ -111,7 +111,7 @@ static int video_open(struct device *dev, const char *devname, int no_query)
 
 	dev->fd = open(devname, O_RDWR);
 	if (dev->fd < 0) {
-		printf("Error opening device %s: %d.\n", devname, errno);
+		fprintf(stderr, "Error opening device %s: %d.\n", devname, errno);
 		return dev->fd;
 	}
 
@@ -119,7 +119,7 @@ static int video_open(struct device *dev, const char *devname, int no_query)
 		memset(&cap, 0, sizeof cap);
 		ret = ioctl(dev->fd, VIDIOC_QUERYCAP, &cap);
 		if (ret < 0) {
-			printf("Error opening device %s: unable to query "
+			fprintf(stderr, "Error opening device %s: unable to query "
 				"device.\n", devname);
 			close(dev->fd);
 			return ret;
@@ -130,16 +130,16 @@ static int video_open(struct device *dev, const char *devname, int no_query)
 		else if (cap.capabilities & V4L2_CAP_VIDEO_OUTPUT)
 			dev->type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
 		else {
-			printf("Error opening device %s: neither video capture "
+			fprintf(stderr, "Error opening device %s: neither video capture "
 				"nor video output supported.\n", devname);
 			close(dev->fd);
 			return -EINVAL;
 		}
 
-		printf("Device %s opened: %s (%s).\n", devname, cap.card, cap.bus_info);
+		fprintf(stderr, "Device %s opened: %s (%s).\n", devname, cap.card, cap.bus_info);
 	} else {
 		dev->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
-		printf("Device %s opened.\n", devname);
+		fprintf(stderr, "Device %s opened.\n", devname);
 	}
 
 	return 0;
@@ -161,12 +161,12 @@ static void uvc_get_control(struct device *dev, unsigned int id)
 
 	ret = ioctl(dev->fd, VIDIOC_G_CTRL, &ctrl);
 	if (ret < 0) {
-		printf("unable to get control: %s (%d).\n",
+		fprintf(stderr, "unable to get control: %s (%d).\n",
 			strerror(errno), errno);
 		return;
 	}
 
-	printf("Control 0x%08x value %u\n", id, ctrl.value);
+	fprintf(stderr, "Control 0x%08x value %u\n", id, ctrl.value);
 }
 
 static void uvc_set_control(struct device *dev, unsigned int id, int value)
@@ -179,12 +179,12 @@ static void uvc_set_control(struct device *dev, unsigned int id, int value)
 
 	ret = ioctl(dev->fd, VIDIOC_S_CTRL, &ctrl);
 	if (ret < 0) {
-		printf("unable to set control: %s (%d).\n",
+		fprintf(stderr, "unable to set control: %s (%d).\n",
 			strerror(errno), errno);
 		return;
 	}
 
-	printf("Control 0x%08x set to %u, is %u\n", id, value,
+	fprintf(stderr, "Control 0x%08x set to %u, is %u\n", id, value,
 		ctrl.value);
 }
 
@@ -198,7 +198,7 @@ static int video_get_format(struct device *dev)
 
 	ret = ioctl(dev->fd, VIDIOC_G_FMT, &fmt);
 	if (ret < 0) {
-		printf("Unable to get format: %s (%d).\n", strerror(errno),
+		fprintf(stderr, "Unable to get format: %s (%d).\n", strerror(errno),
 			errno);
 		return ret;
 	}
@@ -208,7 +208,7 @@ static int video_get_format(struct device *dev)
 	dev->bytesperline = fmt.fmt.pix.bytesperline;
 	dev->imagesize = fmt.fmt.pix.bytesperline ? fmt.fmt.pix.sizeimage : 0;
 
-	printf("Video format: %c%c%c%c (%08x) %ux%u\n",
+	fprintf(stderr, "Video format: %c%c%c%c (%08x) %ux%u\n",
 		(fmt.fmt.pix.pixelformat >> 0) & 0xff,
 		(fmt.fmt.pix.pixelformat >> 8) & 0xff,
 		(fmt.fmt.pix.pixelformat >> 16) & 0xff,
@@ -232,12 +232,12 @@ static int video_set_format(struct device *dev, unsigned int w, unsigned int h,
 
 	ret = ioctl(dev->fd, VIDIOC_S_FMT, &fmt);
 	if (ret < 0) {
-		printf("Unable to set format: %s (%d).\n", strerror(errno),
+		fprintf(stderr, "Unable to set format: %s (%d).\n", strerror(errno),
 			errno);
 		return ret;
 	}
 
-	printf("Video format set: width: %u height: %u buffer size: %u\n",
+	fprintf(stderr, "Video format set: width: %u height: %u buffer size: %u\n",
 		fmt.fmt.pix.width, fmt.fmt.pix.height, fmt.fmt.pix.sizeimage);
 	return 0;
 }
@@ -252,15 +252,15 @@ static int video_set_framerate(struct device *dev, struct v4l2_fract *time_per_f
 
 	ret = ioctl(dev->fd, VIDIOC_G_PARM, &parm);
 	if (ret < 0) {
-		printf("Unable to get frame rate: %d.\n", errno);
+		fprintf(stderr, "Unable to get frame rate: %d.\n", errno);
 		return ret;
 	}
 
-	printf("Current frame rate: %u/%u\n",
+	fprintf(stderr, "Current frame rate: %u/%u\n",
 		parm.parm.capture.timeperframe.numerator,
 		parm.parm.capture.timeperframe.denominator);
 
-	printf("Setting frame rate to: %u/%u\n",
+	fprintf(stderr, "Setting frame rate to: %u/%u\n",
 		time_per_frame->numerator,
 		time_per_frame->denominator);
 
@@ -269,17 +269,17 @@ static int video_set_framerate(struct device *dev, struct v4l2_fract *time_per_f
 
 	ret = ioctl(dev->fd, VIDIOC_S_PARM, &parm);
 	if (ret < 0) {
-		printf("Unable to set frame rate: %d.\n", errno);
+		fprintf(stderr, "Unable to set frame rate: %d.\n", errno);
 		return ret;
 	}
 
 	ret = ioctl(dev->fd, VIDIOC_G_PARM, &parm);
 	if (ret < 0) {
-		printf("Unable to get frame rate: %d.\n", errno);
+		fprintf(stderr, "Unable to get frame rate: %d.\n", errno);
 		return ret;
 	}
 
-	printf("Frame rate set: %u/%u\n",
+	fprintf(stderr, "Frame rate set: %u/%u\n",
 		parm.parm.capture.timeperframe.numerator,
 		parm.parm.capture.timeperframe.denominator);
 	return 0;
@@ -301,11 +301,11 @@ static int video_alloc_buffers(struct device *dev, int nbufs, unsigned int offse
 
 	ret = ioctl(dev->fd, VIDIOC_REQBUFS, &rb);
 	if (ret < 0) {
-		printf("Unable to request buffers: %d.\n", errno);
+		fprintf(stderr, "Unable to request buffers: %d.\n", errno);
 		return ret;
 	}
 
-	printf("%u buffers requested.\n", rb.count);
+	fprintf(stderr, "%u buffers requested.\n", rb.count);
 
 	buffers = malloc(rb.count * sizeof buffers[0]);
 	if (buffers == NULL)
@@ -321,31 +321,31 @@ static int video_alloc_buffers(struct device *dev, int nbufs, unsigned int offse
 		buf.memory = dev->memtype;
 		ret = ioctl(dev->fd, VIDIOC_QUERYBUF, &buf);
 		if (ret < 0) {
-			printf("Unable to query buffer %u (%d).\n", i, errno);
+			fprintf(stderr, "Unable to query buffer %u (%d).\n", i, errno);
 			return ret;
 		}
-		printf("length: %u offset: %u\n", buf.length, buf.m.offset);
+		fprintf(stderr, "length: %u offset: %u\n", buf.length, buf.m.offset);
 
 		switch (dev->memtype) {
 		case V4L2_MEMORY_MMAP:
 			buffers[i].mem = mmap(0, buf.length, PROT_READ | PROT_WRITE, MAP_SHARED, dev->fd, buf.m.offset);
 			if (buffers[i].mem == MAP_FAILED) {
-				printf("Unable to map buffer %u (%d)\n", i, errno);
+				fprintf(stderr, "Unable to map buffer %u (%d)\n", i, errno);
 				return ret;
 			}
 			buffers[i].size = buf.length;
-			printf("Buffer %u mapped at address %p.\n", i, buffers[i].mem);
+			fprintf(stderr, "Buffer %u mapped at address %p.\n", i, buffers[i].mem);
 			break;
 
 		case V4L2_MEMORY_USERPTR:
 			ret = posix_memalign(&buffers[i].mem, page_size, buf.length + offset);
 			if (ret < 0) {
-				printf("Unable to allocate buffer %u (%d)\n", i, ret);
+				fprintf(stderr, "Unable to allocate buffer %u (%d)\n", i, ret);
 				return -ENOMEM;
 			}
 			buffers[i].mem += offset;
 			buffers[i].size = buf.length;
-			printf("Buffer %u allocated at address %p.\n", i, buffers[i].mem);
+			fprintf(stderr, "Buffer %u allocated at address %p.\n", i, buffers[i].mem);
 			break;
 
 		default:
@@ -371,7 +371,7 @@ static int video_free_buffers(struct device *dev)
 		for (i = 0; i < dev->nbufs; ++i) {
 			ret = munmap(dev->buffers[i].mem, dev->buffers[i].size);
 			if (ret < 0) {
-				printf("Unable to unmap buffer %u (%d)\n", i, errno);
+				fprintf(stderr, "Unable to unmap buffer %u (%d)\n", i, errno);
 				return ret;
 			}
 		}
@@ -384,11 +384,11 @@ static int video_free_buffers(struct device *dev)
 
 	ret = ioctl(dev->fd, VIDIOC_REQBUFS, &rb);
 	if (ret < 0) {
-		printf("Unable to release buffers: %d.\n", errno);
+		fprintf(stderr, "Unable to release buffers: %d.\n", errno);
 		return ret;
 	}
 
-	printf("%u buffers released.\n", dev->nbufs);
+	fprintf(stderr, "%u buffers released.\n", dev->nbufs);
 
 	free(dev->buffers);
 	dev->nbufs = 0;
@@ -418,7 +418,7 @@ static int video_queue_buffer(struct device *dev, int index)
 
 	ret = ioctl(dev->fd, VIDIOC_QBUF, &buf);
 	if (ret < 0)
-		printf("Unable to queue buffer (%d).\n", errno);
+		fprintf(stderr, "Unable to queue buffer (%d).\n", errno);
 
 	return ret;
 }
@@ -430,7 +430,7 @@ static int video_enable(struct device *dev, int enable)
 
 	ret = ioctl(dev->fd, enable ? VIDIOC_STREAMON : VIDIOC_STREAMOFF, &type);
 	if (ret < 0) {
-		printf("Unable to %s streaming: %d.\n", enable ? "start" : "stop",
+		fprintf(stderr, "Unable to %s streaming: %d.\n", enable ? "start" : "stop",
 			errno);
 		return ret;
 	}
@@ -450,7 +450,7 @@ static void video_query_menu(struct device *dev, unsigned int id)
 		if (ret < 0)
 			break;
 
-		printf("  %u: %.32s\n", menu.index, menu.name);
+		fprintf(stderr, "  %u: %.32s\n", menu.index, menu.name);
 		menu.index++;
 	};
 }
@@ -487,7 +487,7 @@ static void video_list_controls(struct device *dev)
 		else
 			sprintf(value, "%d", ctrl.value);
 
-		printf("control 0x%08x %s min %d max %d step %d default %d current %s.\n",
+		fprintf(stderr, "control 0x%08x %s min %d max %d step %d default %d current %s.\n",
 			query.id, query.name, query.minimum, query.maximum,
 			query.step, query.default_value, value);
 
@@ -498,9 +498,9 @@ static void video_list_controls(struct device *dev)
 	}
 
 	if (nctrls)
-		printf("%u control%s found.\n", nctrls, nctrls > 1 ? "s" : "");
+		fprintf(stderr, "%u control%s found.\n", nctrls, nctrls > 1 ? "s" : "");
 	else
-		printf("No control found.\n");
+		fprintf(stderr, "No control found.\n");
 }
 
 static void video_enum_frame_intervals(struct device *dev, __u32 pixelformat,
@@ -521,30 +521,30 @@ static void video_enum_frame_intervals(struct device *dev, __u32 pixelformat,
 			break;
 
 		if (i != ival.index)
-			printf("Warning: driver returned wrong ival index "
+			fprintf(stderr, "Warning: driver returned wrong ival index "
 				"%u.\n", ival.index);
 		if (pixelformat != ival.pixel_format)
-			printf("Warning: driver returned wrong ival pixel "
+			fprintf(stderr, "Warning: driver returned wrong ival pixel "
 				"format %08x.\n", ival.pixel_format);
 		if (width != ival.width)
-			printf("Warning: driver returned wrong ival width "
+			fprintf(stderr, "Warning: driver returned wrong ival width "
 				"%u.\n", ival.width);
 		if (height != ival.height)
-			printf("Warning: driver returned wrong ival height "
+			fprintf(stderr, "Warning: driver returned wrong ival height "
 				"%u.\n", ival.height);
 
 		if (i != 0)
-			printf(", ");
+			fprintf(stderr, ", ");
 
 		switch (ival.type) {
 		case V4L2_FRMIVAL_TYPE_DISCRETE:
-			printf("%u/%u",
+			fprintf(stderr, "%u/%u",
 				ival.discrete.numerator,
 				ival.discrete.denominator);
 			break;
 
 		case V4L2_FRMIVAL_TYPE_CONTINUOUS:
-			printf("%u/%u - %u/%u",
+			fprintf(stderr, "%u/%u - %u/%u",
 				ival.stepwise.min.numerator,
 				ival.stepwise.min.denominator,
 				ival.stepwise.max.numerator,
@@ -552,7 +552,7 @@ static void video_enum_frame_intervals(struct device *dev, __u32 pixelformat,
 			return;
 
 		case V4L2_FRMIVAL_TYPE_STEPWISE:
-			printf("%u/%u - %u/%u (by %u/%u)",
+			fprintf(stderr, "%u/%u - %u/%u (by %u/%u)",
 				ival.stepwise.min.numerator,
 				ival.stepwise.min.denominator,
 				ival.stepwise.max.numerator,
@@ -582,23 +582,23 @@ static void video_enum_frame_sizes(struct device *dev, __u32 pixelformat)
 			break;
 
 		if (i != frame.index)
-			printf("Warning: driver returned wrong frame index "
+			fprintf(stderr, "Warning: driver returned wrong frame index "
 				"%u.\n", frame.index);
 		if (pixelformat != frame.pixel_format)
-			printf("Warning: driver returned wrong frame pixel "
+			fprintf(stderr, "Warning: driver returned wrong frame pixel "
 				"format %08x.\n", frame.pixel_format);
 
 		switch (frame.type) {
 		case V4L2_FRMSIZE_TYPE_DISCRETE:
-			printf("\tFrame size: %ux%u (", frame.discrete.width,
+			fprintf(stderr, "\tFrame size: %ux%u (", frame.discrete.width,
 				frame.discrete.height);
 			video_enum_frame_intervals(dev, frame.pixel_format,
 				frame.discrete.width, frame.discrete.height);
-			printf(")\n");
+			fprintf(stderr, ")\n");
 			break;
 
 		case V4L2_FRMSIZE_TYPE_CONTINUOUS:
-			printf("\tFrame size: %ux%u - %ux%u (",
+			fprintf(stderr, "\tFrame size: %ux%u - %ux%u (",
 				frame.stepwise.min_width,
 				frame.stepwise.min_height,
 				frame.stepwise.max_width,
@@ -606,11 +606,11 @@ static void video_enum_frame_sizes(struct device *dev, __u32 pixelformat)
 			video_enum_frame_intervals(dev, frame.pixel_format,
 				frame.stepwise.max_width,
 				frame.stepwise.max_height);
-			printf(")\n");
+			fprintf(stderr, ")\n");
 			break;
 
 		case V4L2_FRMSIZE_TYPE_STEPWISE:
-			printf("\tFrame size: %ux%u - %ux%u (by %ux%u) (\n",
+			fprintf(stderr, "\tFrame size: %ux%u - %ux%u (by %ux%u) (\n",
 				frame.stepwise.min_width,
 				frame.stepwise.min_height,
 				frame.stepwise.max_width,
@@ -620,7 +620,7 @@ static void video_enum_frame_sizes(struct device *dev, __u32 pixelformat)
 			video_enum_frame_intervals(dev, frame.pixel_format,
 				frame.stepwise.max_width,
 				frame.stepwise.max_height);
-			printf(")\n");
+			fprintf(stderr, ")\n");
 			break;
 
 		default:
@@ -643,19 +643,19 @@ static void video_enum_formats(struct device *dev, enum v4l2_buf_type type)
 			break;
 
 		if (i != fmt.index)
-			printf("Warning: driver returned wrong format index "
+			fprintf(stderr, "Warning: driver returned wrong format index "
 				"%u.\n", fmt.index);
 		if (type != fmt.type)
-			printf("Warning: driver returned wrong format type "
+			fprintf(stderr, "Warning: driver returned wrong format type "
 				"%u.\n", fmt.type);
 
-		printf("\tFormat %u: %s (%08x)\n", i,
+		fprintf(stderr, "\tFormat %u: %s (%08x)\n", i,
 			v4l2_fourcc_name(fmt.pixelformat), fmt.pixelformat);
-		printf("\tType: %s (%u)\n", v4l2_buf_type_name(fmt.type),
+		fprintf(stderr, "\tType: %s (%u)\n", v4l2_buf_type_name(fmt.type),
 			fmt.type);
-		printf("\tName: %.32s\n", fmt.description);
+		fprintf(stderr, "\tName: %.32s\n", fmt.description);
 		video_enum_frame_sizes(dev, fmt.pixelformat);
-		printf("\n");
+		fprintf(stderr, "\n");
 	}
 }
 
@@ -673,13 +673,13 @@ static void video_enum_inputs(struct device *dev)
 			break;
 
 		if (i != input.index)
-			printf("Warning: driver returned wrong input index "
+			fprintf(stderr, "Warning: driver returned wrong input index "
 				"%u.\n", input.index);
 
-		printf("\tInput %u: %s.\n", i, input.name);
+		fprintf(stderr, "\tInput %u: %s.\n", i, input.name);
 	}
 
-	printf("\n");
+	fprintf(stderr, "\n");
 }
 
 static int video_get_input(struct device *dev)
@@ -689,7 +689,7 @@ static int video_get_input(struct device *dev)
 
 	ret = ioctl(dev->fd, VIDIOC_G_INPUT, &input);
 	if (ret < 0) {
-		printf("Unable to get current input: %s.\n", strerror(errno));
+		fprintf(stderr, "Unable to get current input: %s.\n", strerror(errno));
 		return ret;
 	}
 
@@ -703,7 +703,7 @@ static int video_set_input(struct device *dev, unsigned int input)
 
 	ret = ioctl(dev->fd, VIDIOC_S_INPUT, &_input);
 	if (ret < 0)
-		printf("Unable to select input %u: %s.\n", input,
+		fprintf(stderr, "Unable to select input %u: %s.\n", input,
 			strerror(errno));
 
 	return ret;
@@ -722,14 +722,14 @@ static int video_set_quality(struct device *dev, unsigned int quality)
 
 	ret = ioctl(dev->fd, VIDIOC_S_JPEGCOMP, &jpeg);
 	if (ret < 0) {
-		printf("Unable to set quality to %u: %s.\n", quality,
+		fprintf(stderr, "Unable to set quality to %u: %s.\n", quality,
 			strerror(errno));
 		return ret;
 	}
 
 	ret = ioctl(dev->fd, VIDIOC_G_JPEGCOMP, &jpeg);
 	if (ret >= 0)
-		printf("Quality set to %u\n", jpeg.quality);
+		fprintf(stderr, "Quality set to %u\n", jpeg.quality);
 
 	return 0;
 }
@@ -749,7 +749,7 @@ static int video_load_test_pattern(struct device *dev, const char *filename)
 
 	if (filename == NULL) {
 		if (dev->bytesperline == 0) {
-			printf("Compressed format detect and no test pattern filename given.\n"
+			fprintf(stderr, "Compressed format detect and no test pattern filename given.\n"
 				"The test pattern can't be generated automatically.\n");
 			return -EINVAL;
 		}
@@ -766,7 +766,7 @@ static int video_load_test_pattern(struct device *dev, const char *filename)
 
 	fd = open(filename, O_RDONLY);
 	if (fd == -1) {
-		printf("Unable to open test pattern file '%s': %s.\n", filename,
+		fprintf(stderr, "Unable to open test pattern file '%s': %s.\n", filename,
 			strerror(errno));
 		return -errno;
 	}
@@ -775,7 +775,7 @@ static int video_load_test_pattern(struct device *dev, const char *filename)
 	close(fd);
 
 	if (ret != (int)size) {
-		printf("Test pattern file size %u doesn't match image size %u\n",
+		fprintf(stderr, "Test pattern file size %u doesn't match image size %u\n",
 			ret, size);
 		return -EINVAL;
 	}
@@ -811,11 +811,11 @@ static int video_prepare_capture(struct device *dev, int nbufs, unsigned int off
 
 static int video_do_capture(struct device *dev, unsigned int nframes,
 	unsigned int skip, unsigned int delay, const char *filename_prefix,
-	int do_requeue_last)
+	int do_requeue_last, int do_stdout)
 {
 	char *filename = NULL;
 	struct timeval start = { 0, 0 };
-	struct timeval end, ts;
+	struct timeval end, ts, prev;
 	struct v4l2_buffer buf;
 	unsigned int size;
 	unsigned int i;
@@ -843,7 +843,7 @@ static int video_do_capture(struct device *dev, unsigned int nframes,
 		ret = ioctl(dev->fd, VIDIOC_DQBUF, &buf);
 		if (ret < 0) {
 			if (errno != EIO) {
-				printf("Unable to dequeue buffer (%d).\n", errno);
+				fprintf(stderr, "Unable to dequeue buffer (%d).\n", errno);
 				goto done;
 			}
 			buf.type = dev->type;
@@ -854,27 +854,39 @@ static int video_do_capture(struct device *dev, unsigned int nframes,
 
 		if (dev->type == V4L2_BUF_TYPE_VIDEO_CAPTURE &&
 		    dev->imagesize != 0	&& buf.bytesused != dev->imagesize)
-			printf("Warning: bytes used %u != image size %u\n",
+			fprintf(stderr, "Warning: bytes used %u != image size %u\n",
 			       buf.bytesused, dev->imagesize);
 
 		size += buf.bytesused;
 
+		if (i != 0 || (prev.tv_sec == buf.timestamp.tv_sec && prev.tv_usec == buf.timestamp.tv_usec)) {
+			fps = 1000000. / ((buf.timestamp.tv_sec - prev.tv_sec)  * 1000000 + (buf.timestamp.tv_usec - prev.tv_usec));
+		} else {
+			fps = 0;
+		}
 		gettimeofday(&ts, NULL);
-		printf("%u (%u) [%c] %u %u bytes %ld.%06ld %ld.%06ld\n", i, buf.index,
+		fprintf(stderr, "%u (%u) [%c] %u %u bytes %ld.%06ld %ld.%06ld %f fps\n", i, buf.index,
 			(buf.flags & V4L2_BUF_FLAG_ERROR) ? 'E' : '-',
 			buf.sequence, buf.bytesused, buf.timestamp.tv_sec,
-			buf.timestamp.tv_usec, ts.tv_sec, ts.tv_usec);
+			buf.timestamp.tv_usec, ts.tv_sec, ts.tv_usec, fps);
+		prev.tv_sec = buf.timestamp.tv_sec;
+		prev.tv_usec = buf.timestamp.tv_usec;
 
 		if (i == 0)
 			start = ts;
 
 		/* Save the image. */
-		if (dev->type == V4L2_BUF_TYPE_VIDEO_CAPTURE && filename_prefix && !skip) {
-			sprintf(filename, "%s-%06u.bin", filename_prefix, i);
-			file = fopen(filename, "wb");
-			if (file != NULL) {
-				ret = fwrite(dev->buffers[buf.index].mem, buf.bytesused, 1, file);
-				fclose(file);
+		if (dev->type == V4L2_BUF_TYPE_VIDEO_CAPTURE && !skip) {
+			if (filename_prefix) {
+				sprintf(filename, "%s-%06u.bin", filename_prefix, i);
+				file = fopen(filename, "wb");
+				if (file != NULL) {
+					ret = fwrite(dev->buffers[buf.index].mem, buf.bytesused, 1, file);
+					fclose(file);
+				}
+			}
+			if (do_stdout) {
+				ret = fwrite(dev->buffers[buf.index].mem, buf.bytesused, 1, stdout);
 			}
 		}
 		if (skip)
@@ -891,7 +903,7 @@ static int video_do_capture(struct device *dev, unsigned int nframes,
 
 		ret = video_queue_buffer(dev, buf.index);
 		if (ret < 0) {
-			printf("Unable to requeue buffer (%d).\n", errno);
+			fprintf(stderr, "Unable to requeue buffer (%d).\n", errno);
 			goto done;
 		}
 	}
@@ -901,7 +913,7 @@ static int video_do_capture(struct device *dev, unsigned int nframes,
 	video_enable(dev, 0);
 
 	if (nframes == 0) {
-		printf("No frames captured.\n");
+		fprintf(stderr, "No frames captured.\n");
 		goto done;
 	}
 
@@ -918,7 +930,7 @@ static int video_do_capture(struct device *dev, unsigned int nframes,
 	bps = size/(end.tv_usec+1000000.0*end.tv_sec)*1000000.0;
 	fps = (i-1)/(end.tv_usec+1000000.0*end.tv_sec)*1000000.0;
 
-	printf("Captured %u frames in %lu.%06lu seconds (%f fps, %f B/s).\n",
+	fprintf(stderr, "Captured %u frames in %lu.%06lu seconds (%f fps, %f B/s).\n",
 		i-1, end.tv_sec, end.tv_usec, fps, bps);
 
 done:
@@ -931,30 +943,31 @@ done:
 
 static void usage(const char *argv0)
 {
-	printf("Usage: %s [options] device\n", argv0);
-	printf("Supported options:\n");
-	printf("-c, --capture[=nframes]		Capture frames\n");
-	printf("-d, --delay			Delay (in ms) before requeuing buffers\n");
-	printf("-f, --format format		Set the video format\n");
-	printf("-F, --file[=prefix]		Read/write frames from/to disk\n");
-	printf("-h, --help			Show this help screen\n");
-	printf("-i, --input input		Select the video input\n");
-	printf("-l, --list-controls		List available controls\n");
-	printf("-n, --nbufs n			Set the number of video buffers\n");
-	printf("-p, --pause			Pause before starting the video stream\n");
-	printf("-q, --quality n			MJPEG quality (0-100)\n");
-	printf("-r, --get-control ctrl		Get control 'ctrl'\n");
-	printf("-s, --size WxH			Set the frame size\n");
-	printf("-t, --time-per-frame num/denom	Set the time per frame (eg. 1/25 = 25 fps)\n");
-	printf("-u, --userptr			Use the user pointers streaming method\n");
-	printf("-w, --set-control 'ctrl value'	Set control 'ctrl' to 'value'\n");
-	printf("    --enum-formats		Enumerate formats\n");
-	printf("    --enum-inputs		Enumerate inputs\n");
-	printf("    --no-query			Don't query capabilities on open\n");
-	printf("    --offset			User pointer buffer offset from page start\n");
-	printf("    --requeue-last		Requeue the last buffers before streamoff\n");
-	printf("    --skip n			Skip the first n frames\n");
-	printf("    --sleep-forever		Sleep forever after configuring the device\n");
+	fprintf(stderr, "Usage: %s [options] device\n", argv0);
+	fprintf(stderr, "Supported options:\n");
+	fprintf(stderr, "-c, --capture[=nframes]		Capture frames\n");
+	fprintf(stderr, "-d, --delay			Delay (in ms) before requeuing buffers\n");
+	fprintf(stderr, "-f, --format format		Set the video format\n");
+	fprintf(stderr, "-F, --file[=prefix]		Read/write frames from/to disk\n");
+	fprintf(stderr, "    --stdout			write frames to stdout\n");
+	fprintf(stderr, "-h, --help			Show this help screen\n");
+	fprintf(stderr, "-i, --input input		Select the video input\n");
+	fprintf(stderr, "-l, --list-controls		List available controls\n");
+	fprintf(stderr, "-n, --nbufs n			Set the number of video buffers\n");
+	fprintf(stderr, "-p, --pause			Pause before starting the video stream\n");
+	fprintf(stderr, "-q, --quality n			MJPEG quality (0-100)\n");
+	fprintf(stderr, "-r, --get-control ctrl		Get control 'ctrl'\n");
+	fprintf(stderr, "-s, --size WxH			Set the frame size\n");
+	fprintf(stderr, "-t, --time-per-frame num/denom	Set the time per frame (eg. 1/25 = 25 fps)\n");
+	fprintf(stderr, "-u, --userptr			Use the user pointers streaming method\n");
+	fprintf(stderr, "-w, --set-control 'ctrl value'	Set control 'ctrl' to 'value'\n");
+	fprintf(stderr, "    --enum-formats		Enumerate formats\n");
+	fprintf(stderr, "    --enum-inputs		Enumerate inputs\n");
+	fprintf(stderr, "    --no-query			Don't query capabilities on open\n");
+	fprintf(stderr, "    --offset			User pointer buffer offset from page start\n");
+	fprintf(stderr, "    --requeue-last		Requeue the last buffers before streamoff\n");
+	fprintf(stderr, "    --skip n			Skip the first n frames\n");
+	fprintf(stderr, "    --sleep-forever		Sleep forever after configuring the device\n");
 }
 
 #define OPT_ENUM_FORMATS	256
@@ -964,6 +977,7 @@ static void usage(const char *argv0)
 #define OPT_SLEEP_FOREVER	260
 #define OPT_USERPTR_OFFSET	261
 #define OPT_REQUEUE_LAST	262
+#define OPT_STDOUT		263
 
 static struct option opts[] = {
 	{"capture", 2, 0, 'c'},
@@ -971,6 +985,7 @@ static struct option opts[] = {
 	{"enum-formats", 0, 0, OPT_ENUM_FORMATS},
 	{"enum-inputs", 0, 0, OPT_ENUM_INPUTS},
 	{"file", 2, 0, 'F'},
+	{"stdout", 0, 0, OPT_STDOUT},
 	{"format", 1, 0, 'f'},
 	{"help", 0, 0, 'h'},
 	{"input", 1, 0, 'i'},
@@ -1003,7 +1018,7 @@ int main(int argc, char *argv[])
 	int do_enum_inputs = 0, do_set_input = 0;
 	int do_list_controls = 0, do_get_control = 0, do_set_control = 0;
 	int do_sleep_forever = 0, do_requeue_last = 0;
-	int no_query = 0;
+	int no_query = 0, do_stdout = 0;
 	char *endptr;
 	int c;
 
@@ -1049,10 +1064,14 @@ int main(int argc, char *argv[])
 				pixelformat = V4L2_PIX_FMT_UYVY;
 			else if (strcasecmp(optarg, "Y16") == 0)
 				pixelformat = V4L2_PIX_FMT_Y16;
+			else if (strcasecmp(optarg, "Y8") == 0)
+				pixelformat = V4L2_PIX_FMT_GREY;
 			else if (strcasecmp(optarg, "SGRBG10_DPMC8") == 0)
 				pixelformat = V4L2_PIX_FMT_SGRBG10DPCM8;
 			else if (strcasecmp(optarg, "SGRBG10") == 0)
 				pixelformat = V4L2_PIX_FMT_SGRBG10;
+			else if (strcasecmp(optarg, "SGRBG8") == 0)
+				pixelformat = V4L2_PIX_FMT_SGRBG8;
 #ifdef V4L2_PIX_FMT_SGRBG12
 			else if (strcasecmp(optarg, "SGRBG12") == 0)
 				pixelformat = V4L2_PIX_FMT_SGRBG12;
@@ -1060,7 +1079,7 @@ int main(int argc, char *argv[])
 			else if (strcasecmp(optarg, "DV") == 0)
 				pixelformat = V4L2_PIX_FMT_DV;
 			else {
-				printf("Unsupported video format '%s'\n", optarg);
+				fprintf(stderr, "Unsupported video format '%s'\n", optarg);
 				return 1;
 			}
 			break;
@@ -1093,7 +1112,7 @@ int main(int argc, char *argv[])
 		case 'r':
 			ctrl_name = strtol(optarg, &endptr, 0);
 			if (*endptr != 0) {
-				printf("Invalid control name '%s'\n", optarg);
+				fprintf(stderr, "Invalid control name '%s'\n", optarg);
 				return 1;
 			}
 			do_get_control = 1;
@@ -1102,12 +1121,12 @@ int main(int argc, char *argv[])
 			do_set_format = 1;
 			width = strtol(optarg, &endptr, 10);
 			if (*endptr != 'x' || endptr == optarg) {
-				printf("Invalid size '%s'\n", optarg);
+				fprintf(stderr, "Invalid size '%s'\n", optarg);
 				return 1;
 			}
 			height = strtol(endptr + 1, &endptr, 10);
 			if (*endptr != 0) {
-				printf("Invalid size '%s'\n", optarg);
+				fprintf(stderr, "Invalid size '%s'\n", optarg);
 				return 1;
 			}
 			break;
@@ -1115,12 +1134,12 @@ int main(int argc, char *argv[])
 			do_set_time_per_frame = 1;
 			time_per_frame.numerator = strtol(optarg, &endptr, 10);
 			if (*endptr != '/' || endptr == optarg) {
-				printf("Invalid time per frame '%s'\n", optarg);
+				fprintf(stderr, "Invalid time per frame '%s'\n", optarg);
 				return 1;
 			}
 			time_per_frame.denominator = strtol(endptr + 1, &endptr, 10);
 			if (*endptr != 0) {
-				printf("Invalid time per frame '%s'\n", optarg);
+				fprintf(stderr, "Invalid time per frame '%s'\n", optarg);
 				return 1;
 			}
 			break;
@@ -1130,12 +1149,12 @@ int main(int argc, char *argv[])
 		case 'w':
 			ctrl_name = strtol(optarg, &endptr, 0);
 			if (*endptr != ' ' || endptr == optarg) {
-				printf("Invalid control name '%s'\n", optarg);
+				fprintf(stderr, "Invalid control name '%s'\n", optarg);
 				return 1;
 			}
 			ctrl_value = strtol(endptr + 1, &endptr, 0);
 			if (*endptr != 0) {
-				printf("Invalid control value '%s'\n", optarg);
+				fprintf(stderr, "Invalid control value '%s'\n", optarg);
 				return 1;
 			}
 			do_set_control = 1;
@@ -1161,9 +1180,12 @@ int main(int argc, char *argv[])
 		case OPT_USERPTR_OFFSET:
 			userptr_offset = atoi(optarg);
 			break;
+		case OPT_STDOUT:
+			do_stdout = 1;
+			break;
 		default:
-			printf("Invalid option -%c\n", c);
-			printf("Run %s -h for help.\n", argv[0]);
+			fprintf(stderr, "Invalid option -%c\n", c);
+			fprintf(stderr, "Run %s -h for help.\n", argv[0]);
 			return 1;
 		}
 	}
@@ -1192,21 +1214,21 @@ int main(int argc, char *argv[])
 		video_list_controls(&dev);
 
 	if (do_enum_formats) {
-		printf("- Available formats:\n");
+		fprintf(stderr, "- Available formats:\n");
 		video_enum_formats(&dev, V4L2_BUF_TYPE_VIDEO_CAPTURE);
 		video_enum_formats(&dev, V4L2_BUF_TYPE_VIDEO_OUTPUT);
 		video_enum_formats(&dev, V4L2_BUF_TYPE_VIDEO_OVERLAY);
 	}
 
 	if (do_enum_inputs) {
-		printf("- Available inputs:\n");
+		fprintf(stderr, "- Available inputs:\n");
 		video_enum_inputs(&dev);
 	}
 
 	if (do_set_input) {
 		video_set_input(&dev, input);
 		ret = video_get_input(&dev);
-		printf("Input %d selected\n", ret);
+		fprintf(stderr, "Input %d selected\n", ret);
 	}
 
 	/* Set the video format. */
@@ -1248,11 +1270,11 @@ int main(int argc, char *argv[])
 	}
 
 	if (do_pause) {
-		printf("Press enter to start capture\n");
+		fprintf(stderr, "Press enter to start capture\n");
 		getchar();
 	}
 
-	if (video_do_capture(&dev, nframes, skip, delay, filename, do_requeue_last) < 0) {
+	if (video_do_capture(&dev, nframes, skip, delay, filename, do_requeue_last, do_stdout) < 0) {
 		video_close(&dev);
 		return 1;
 	}