third_party/v4l2capture/v4l2capture.c - chromium/src - Git at Google

 // python-v4l2capture
 // Python extension to capture video with video4linux2
 //
 // 2009, 2010, 2011 Fredrik Portstrom
 //
 // I, the copyright holder of this file, hereby release it into the
 // public domain. This applies worldwide. In case this is not legally
 // possible: I grant anyone the right to use this work for any
 // purpose, without any conditions, unless such conditions are
 // required by law.

 #include <Python.h>
 #include <fcntl.h>
 #include <linux/videodev2.h>
 #include <sys/mman.h>

 // LIBV4L is not needed for MJPEG capture.
 #undef USE_LIBV4L

 #ifdef USE_LIBV4L
 #include <libv4l2.h>
 #else
 #include <sys/ioctl.h>
 #define v4l2_close close
 #define v4l2_ioctl ioctl
 #define v4l2_mmap mmap
 #define v4l2_munmap munmap
 #define v4l2_open open
 #endif

 #define ASSERT_OPEN if(self->fd < 0)                                    \
     {                                                                   \
       PyErr_SetString(PyExc_ValueError,                                 \
           "I/O operation on closed file");                              \
       return NULL;                                                      \
     }

 struct buffer {
   void *start;
   size_t length;
 };

 typedef struct {
   PyObject_HEAD
   int fd;
   struct buffer *buffers;
   int buffer_count;
 } Video_device;

 struct capability {
   int id;
   const char *name;
 };

 static struct capability capabilities[] = {
   { V4L2_CAP_ASYNCIO, "asyncio" },
   { V4L2_CAP_AUDIO, "audio" },
   { V4L2_CAP_HW_FREQ_SEEK, "hw_freq_seek" },
   { V4L2_CAP_RADIO, "radio" },
   { V4L2_CAP_RDS_CAPTURE, "rds_capture" },
   { V4L2_CAP_READWRITE, "readwrite" },
   { V4L2_CAP_SLICED_VBI_CAPTURE, "sliced_vbi_capture" },
   { V4L2_CAP_SLICED_VBI_OUTPUT, "sliced_vbi_output" },
   { V4L2_CAP_STREAMING, "streaming" },
   { V4L2_CAP_TUNER, "tuner" },
   { V4L2_CAP_VBI_CAPTURE, "vbi_capture" },
   { V4L2_CAP_VBI_OUTPUT, "vbi_output" },
   { V4L2_CAP_VIDEO_CAPTURE, "video_capture" },
   { V4L2_CAP_VIDEO_OUTPUT, "video_output" },
   { V4L2_CAP_VIDEO_OUTPUT_OVERLAY, "video_output_overlay" },
   { V4L2_CAP_VIDEO_OVERLAY, "video_overlay" }
 };

 static int my_ioctl(int fd, int request, void *arg)
 {
   // Retry ioctl until it returns without being interrupted.

   for(;;)
     {
       int result = v4l2_ioctl(fd, request, arg);

       if(!result)
         {
           return 0;
         }

       if(errno != EINTR)
         {
           PyErr_SetFromErrno(PyExc_IOError);
           return 1;
         }
     }
 }

 static void Video_device_unmap(Video_device *self)
 {
   int i;

   for(i = 0; i < self->buffer_count; i++)
     {
       v4l2_munmap(self->buffers[i].start, self->buffers[i].length);
     }
   free(self->buffers);
   self->buffers = NULL;
 }

 static void Video_device_dealloc(Video_device *self)
 {
   if(self->fd >= 0)
     {
       if(self->buffers)
         {
           Video_device_unmap(self);
         }

       v4l2_close(self->fd);
     }

   self->ob_type->tp_free((PyObject *)self);
 }

 static int Video_device_init(Video_device *self, PyObject *args,
     PyObject *kwargs)
 {
   const char *device_path;

   if(!PyArg_ParseTuple(args, "s", &device_path))
     {
       return -1;
     }

   int fd = v4l2_open(device_path, O_RDWR | O_NONBLOCK);

   if(fd < 0)
     {
       PyErr_SetFromErrnoWithFilename(PyExc_IOError, (char *)device_path);
       return -1;
     }

   self->fd = fd;
   self->buffers = NULL;
   self->buffer_count = 0;
   return 0;
 }

 static PyObject *Video_device_close(Video_device *self)
 {
   if(self->fd >= 0)
     {
       if(self->buffers)
         {
           Video_device_unmap(self);
         }

       v4l2_close(self->fd);
       self->fd = -1;
     }

   Py_RETURN_NONE;
 }

 static PyObject *Video_device_fileno(Video_device *self)
 {
   ASSERT_OPEN;
   return PyInt_FromLong(self->fd);
 }

 static PyObject *Video_device_get_info(Video_device *self)
 {
   ASSERT_OPEN;
   struct v4l2_capability caps;

   if(my_ioctl(self->fd, VIDIOC_QUERYCAP, &caps))
     {
       return NULL;
     }

   PyObject *set = PySet_New(NULL);

   if(!set)
     {
       return NULL;
     }

   struct capability *capability = capabilities;

   while((void *)capability < (void *)capabilities + sizeof(capabilities))
     {
       if(caps.capabilities & capability->id)
         {
           PyObject *s = PyString_FromString(capability->name);

           if(!s)
             {
               Py_DECREF(set);
               return NULL;
             }

           PySet_Add(set, s);
         }

       capability++;
     }

   return Py_BuildValue("sssO", caps.driver, caps.card, caps.bus_info, set);
 }

 static PyObject *Video_device_set_format(Video_device *self, PyObject *args)
 {
   int size_x;
   int size_y;
   if(!PyArg_ParseTuple(args, "ii", &size_x, &size_y))
     {
       return NULL;
     }

   struct v4l2_format format;
   format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
   format.fmt.pix.width = size_x;
   format.fmt.pix.height = size_y;
   format.fmt.pix.pixelformat = V4L2_PIX_FMT_MJPEG;
   format.fmt.pix.field = V4L2_FIELD_NONE;
   format.fmt.pix.bytesperline = 0;

   if(my_ioctl(self->fd, VIDIOC_S_FMT, &format))
     {
       return NULL;
     }

   return Py_BuildValue("ii", format.fmt.pix.width, format.fmt.pix.height);
 }

 static PyObject *Video_device_set_fps(Video_device *self, PyObject *args)
 {
   int fps;
   if(!PyArg_ParseTuple(args, "i", &fps))
     {
       return NULL;
     }
   struct v4l2_streamparm setfps;
   memset(&setfps, 0, sizeof(struct v4l2_streamparm));
   setfps.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
   setfps.parm.capture.timeperframe.numerator = 1;
   setfps.parm.capture.timeperframe.denominator = fps;
   if(my_ioctl(self->fd, VIDIOC_S_PARM, &setfps)){
         return NULL;
   }
   return Py_BuildValue("i",setfps.parm.capture.timeperframe.denominator);
 }

 static PyObject *Video_device_start(Video_device *self)
 {
   ASSERT_OPEN;
   enum v4l2_buf_type type;
   type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

   if(my_ioctl(self->fd, VIDIOC_STREAMON, &type))
     {
       return NULL;
     }

   Py_RETURN_NONE;
 }

 static PyObject *Video_device_stop(Video_device *self)
 {
   ASSERT_OPEN;
   enum v4l2_buf_type type;
   type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

   if(my_ioctl(self->fd, VIDIOC_STREAMOFF, &type))
     {
       return NULL;
     }

   Py_RETURN_NONE;
 }

 static PyObject *Video_device_create_buffers(Video_device *self, PyObject *args)
 {
   int buffer_count;

   if(!PyArg_ParseTuple(args, "I", &buffer_count))
     {
       return NULL;
     }

   ASSERT_OPEN;

   if(self->buffers)
     {
       PyErr_SetString(PyExc_ValueError, "Buffers are already created");
       return NULL;
     }

   struct v4l2_requestbuffers reqbuf;
   reqbuf.count = buffer_count;
   reqbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
   reqbuf.memory = V4L2_MEMORY_MMAP;

   if(my_ioctl(self->fd, VIDIOC_REQBUFS, &reqbuf))
     {
       return NULL;
     }

   if(!reqbuf.count)
     {
       PyErr_SetString(PyExc_IOError, "Not enough buffer memory");
       return NULL;
     }

   self->buffers = malloc(reqbuf.count * sizeof(struct buffer));

   if(!self->buffers)
     {
       PyErr_NoMemory();
       return NULL;
     }

   int i;

   for(i = 0; i < reqbuf.count; i++)
     {
       struct v4l2_buffer buffer;
       buffer.index = i;
       buffer.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
       buffer.memory = V4L2_MEMORY_MMAP;

       if(my_ioctl(self->fd, VIDIOC_QUERYBUF, &buffer))
         {
           return NULL;
         }

       self->buffers[i].length = buffer.length;
       self->buffers[i].start = v4l2_mmap(NULL, buffer.length,
           PROT_READ | PROT_WRITE, MAP_SHARED, self->fd, buffer.m.offset);

       if(self->buffers[i].start == MAP_FAILED)
         {
           PyErr_SetFromErrno(PyExc_IOError);
           Video_device_unmap(self);
           return NULL;
         }
       ++self->buffer_count;
     }

   Py_RETURN_NONE;
 }

 static PyObject *Video_device_queue_all_buffers(Video_device *self)
 {
   if(!self->buffers)
     {
       ASSERT_OPEN;
       PyErr_SetString(PyExc_ValueError, "Buffers have not been created");
       return NULL;
     }

   int i;
   int buffer_count = self->buffer_count;

   for(i = 0; i < buffer_count; i++)
     {
       struct v4l2_buffer buffer;
       buffer.index = i;
       buffer.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
       buffer.memory = V4L2_MEMORY_MMAP;

       if(my_ioctl(self->fd, VIDIOC_QBUF, &buffer))
         {
           return NULL;
         }
     }

   Py_RETURN_NONE;
 }

 static PyObject *Video_device_read_internal(Video_device *self, int queue)
 {
   if(!self->buffers)
     {
       ASSERT_OPEN;
       PyErr_SetString(PyExc_ValueError, "Buffers have not been created");
       return NULL;
     }

   struct v4l2_buffer buffer;
   buffer.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
   buffer.memory = V4L2_MEMORY_MMAP;

   if(my_ioctl(self->fd, VIDIOC_DQBUF, &buffer))
     {
       return NULL;
     }

   PyObject *result = PyString_FromStringAndSize(
       self->buffers[buffer.index].start, buffer.bytesused);

   if(!result)
     {
       return NULL;
     }

   if(queue && my_ioctl(self->fd, VIDIOC_QBUF, &buffer))
     {
       return NULL;
     }

   return result;
 }

 static PyObject *Video_device_read(Video_device *self)
 {
   return Video_device_read_internal(self, 0);
 }

 static PyObject *Video_device_read_and_queue(Video_device *self)
 {
   return Video_device_read_internal(self, 1);
 }

 static PyMethodDef Video_device_methods[] = {
   {"close", (PyCFunction)Video_device_close, METH_NOARGS,
        "close()\n\n"
        "Close video device. Subsequent calls to other methods will fail."},
   {"fileno", (PyCFunction)Video_device_fileno, METH_NOARGS,
        "fileno() -> integer \"file descriptor\".\n\n"
        "This enables video devices to be passed select.select for waiting "
        "until a frame is available for reading."},
   {"get_info", (PyCFunction)Video_device_get_info, METH_NOARGS,
        "get_info() -> driver, card, bus_info, capabilities\n\n"
        "Returns three strings with information about the video device, and one "
        "set containing strings identifying the capabilities of the video "
        "device."},
   {"set_format", (PyCFunction)Video_device_set_format, METH_VARARGS,
        "set_format(size_x, size_y) -> size_x, size_y\n\n"
        "Request the video device to set image size and format. The device may "
        "choose another size than requested and will return its choice. The "
        "image format will be MJPEG."},
   {"set_fps", (PyCFunction)Video_device_set_fps, METH_VARARGS,
        "set_fps(fps) -> fps \n\n"
        "Request the video device to set frame per seconds.The device may "
        "choose another frame rate than requested and will return its choice. " },
   {"start", (PyCFunction)Video_device_start, METH_NOARGS,
        "start()\n\n"
        "Start video capture."},
   {"stop", (PyCFunction)Video_device_stop, METH_NOARGS,
        "stop()\n\n"
        "Stop video capture."},
   {"create_buffers", (PyCFunction)Video_device_create_buffers, METH_VARARGS,
        "create_buffers(count)\n\n"
        "Create buffers used for capturing image data. Can only be called once "
        "for each video device object."},
   {"queue_all_buffers", (PyCFunction)Video_device_queue_all_buffers,
        METH_NOARGS,
        "queue_all_buffers()\n\n"
        "Let the video device fill all buffers created."},
   {"read", (PyCFunction)Video_device_read, METH_NOARGS,
        "read() -> string\n\n"
        "Reads image data from a buffer that has been filled by the video "
        "device. The image data is in MJPEG format. "
        "The buffer is removed from the queue. Fails if no buffer "
        "is filled. Use select.select to check for filled buffers."},
   {"read_and_queue", (PyCFunction)Video_device_read_and_queue, METH_NOARGS,
        "read_and_queue()\n\n"
        "Same as 'read', but adds the buffer back to the queue so the video "
        "device can fill it again."},
   {NULL}
 };

 static PyTypeObject Video_device_type = {
   PyObject_HEAD_INIT(NULL)
       0, "v4l2capture.Video_device", sizeof(Video_device), 0,
       (destructor)Video_device_dealloc, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, Py_TPFLAGS_DEFAULT, "Video_device(path)\n\nOpens the video device at "
       "the given path and returns an object that can capture images. The "
       "constructor and all methods except close may raise IOError.", 0, 0, 0,
       0, 0, 0, Video_device_methods, 0, 0, 0, 0, 0, 0, 0,
       (initproc)Video_device_init
 };

 static PyMethodDef module_methods[] = {
   {NULL}
 };

 PyMODINIT_FUNC initv4l2capture(void)
 {
   Video_device_type.tp_new = PyType_GenericNew;

   if(PyType_Ready(&Video_device_type) < 0)
     {
       return;
     }

   PyObject *module = Py_InitModule3("v4l2capture", module_methods,
       "Capture video with video4linux2.");

   if(!module)
     {
       return;
     }

   Py_INCREF(&Video_device_type);
   PyModule_AddObject(module, "Video_device", (PyObject *)&Video_device_type);
 }
	// python-v4l2capture
	// Python extension to capture video with video4linux2
	//
	// 2009, 2010, 2011 Fredrik Portstrom
	//
	// I, the copyright holder of this file, hereby release it into the
	// public domain. This applies worldwide. In case this is not legally
	// possible: I grant anyone the right to use this work for any
	// purpose, without any conditions, unless such conditions are
	// required by law.

	#include <Python.h>
	#include <fcntl.h>
	#include <linux/videodev2.h>
	#include <sys/mman.h>

	// LIBV4L is not needed for MJPEG capture.
	#undef USE_LIBV4L

	#ifdef USE_LIBV4L
	#include <libv4l2.h>
	#else
	#include <sys/ioctl.h>
	#define v4l2_close close
	#define v4l2_ioctl ioctl
	#define v4l2_mmap mmap
	#define v4l2_munmap munmap
	#define v4l2_open open
	#endif

	#define ASSERT_OPEN if(self->fd < 0) \
	{ \
	PyErr_SetString(PyExc_ValueError, \
	"I/O operation on closed file"); \
	return NULL; \
	}

	struct buffer {
	void *start;
	size_t length;
	};

	typedef struct {
	PyObject_HEAD
	int fd;
	struct buffer *buffers;
	int buffer_count;
	} Video_device;

	struct capability {
	int id;
	const char *name;
	};

	static struct capability capabilities[] = {
	{ V4L2_CAP_ASYNCIO, "asyncio" },
	{ V4L2_CAP_AUDIO, "audio" },
	{ V4L2_CAP_HW_FREQ_SEEK, "hw_freq_seek" },
	{ V4L2_CAP_RADIO, "radio" },
	{ V4L2_CAP_RDS_CAPTURE, "rds_capture" },
	{ V4L2_CAP_READWRITE, "readwrite" },
	{ V4L2_CAP_SLICED_VBI_CAPTURE, "sliced_vbi_capture" },
	{ V4L2_CAP_SLICED_VBI_OUTPUT, "sliced_vbi_output" },
	{ V4L2_CAP_STREAMING, "streaming" },
	{ V4L2_CAP_TUNER, "tuner" },
	{ V4L2_CAP_VBI_CAPTURE, "vbi_capture" },
	{ V4L2_CAP_VBI_OUTPUT, "vbi_output" },
	{ V4L2_CAP_VIDEO_CAPTURE, "video_capture" },
	{ V4L2_CAP_VIDEO_OUTPUT, "video_output" },
	{ V4L2_CAP_VIDEO_OUTPUT_OVERLAY, "video_output_overlay" },
	{ V4L2_CAP_VIDEO_OVERLAY, "video_overlay" }
	};

	static int my_ioctl(int fd, int request, void *arg)
	{
	// Retry ioctl until it returns without being interrupted.

	for(;;)
	{
	int result = v4l2_ioctl(fd, request, arg);

	if(!result)
	{
	return 0;
	}

	if(errno != EINTR)
	{
	PyErr_SetFromErrno(PyExc_IOError);
	return 1;
	}
	}
	}

	static void Video_device_unmap(Video_device *self)
	{
	int i;

	for(i = 0; i < self->buffer_count; i++)
	{
	v4l2_munmap(self->buffers[i].start, self->buffers[i].length);
	}
	free(self->buffers);
	self->buffers = NULL;
	}

	static void Video_device_dealloc(Video_device *self)
	{
	if(self->fd >= 0)
	{
	if(self->buffers)
	{
	Video_device_unmap(self);
	}

	v4l2_close(self->fd);
	}

	self->ob_type->tp_free((PyObject *)self);
	}

	static int Video_device_init(Video_device self, PyObject args,
	PyObject *kwargs)
	{
	const char *device_path;

	if(!PyArg_ParseTuple(args, "s", &device_path))
	{
	return -1;
	}

	int fd = v4l2_open(device_path, O_RDWR \| O_NONBLOCK);

	if(fd < 0)
	{
	PyErr_SetFromErrnoWithFilename(PyExc_IOError, (char *)device_path);
	return -1;
	}

	self->fd = fd;
	self->buffers = NULL;
	self->buffer_count = 0;
	return 0;
	}

	static PyObject Video_device_close(Video_device self)
	{
	if(self->fd >= 0)
	{
	if(self->buffers)
	{
	Video_device_unmap(self);
	}

	v4l2_close(self->fd);
	self->fd = -1;
	}

	Py_RETURN_NONE;
	}

	static PyObject Video_device_fileno(Video_device self)
	{
	ASSERT_OPEN;
	return PyInt_FromLong(self->fd);
	}

	static PyObject Video_device_get_info(Video_device self)
	{
	ASSERT_OPEN;
	struct v4l2_capability caps;

	if(my_ioctl(self->fd, VIDIOC_QUERYCAP, &caps))
	{
	return NULL;
	}

	PyObject *set = PySet_New(NULL);

	if(!set)
	{
	return NULL;
	}

	struct capability *capability = capabilities;

	while((void )capability < (void )capabilities + sizeof(capabilities))
	{
	if(caps.capabilities & capability->id)
	{
	PyObject *s = PyString_FromString(capability->name);

	if(!s)
	{
	Py_DECREF(set);
	return NULL;
	}

	PySet_Add(set, s);
	}

	capability++;
	}

	return Py_BuildValue("sssO", caps.driver, caps.card, caps.bus_info, set);
	}

	static PyObject Video_device_set_format(Video_device self, PyObject *args)
	{
	int size_x;
	int size_y;
	if(!PyArg_ParseTuple(args, "ii", &size_x, &size_y))
	{
	return NULL;
	}

	struct v4l2_format format;
	format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
	format.fmt.pix.width = size_x;
	format.fmt.pix.height = size_y;
	format.fmt.pix.pixelformat = V4L2_PIX_FMT_MJPEG;
	format.fmt.pix.field = V4L2_FIELD_NONE;
	format.fmt.pix.bytesperline = 0;

	if(my_ioctl(self->fd, VIDIOC_S_FMT, &format))
	{
	return NULL;
	}

	return Py_BuildValue("ii", format.fmt.pix.width, format.fmt.pix.height);
	}

	static PyObject Video_device_set_fps(Video_device self, PyObject *args)
	{
	int fps;
	if(!PyArg_ParseTuple(args, "i", &fps))
	{
	return NULL;
	}
	struct v4l2_streamparm setfps;
	memset(&setfps, 0, sizeof(struct v4l2_streamparm));
	setfps.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
	setfps.parm.capture.timeperframe.numerator = 1;
	setfps.parm.capture.timeperframe.denominator = fps;
	if(my_ioctl(self->fd, VIDIOC_S_PARM, &setfps)){
	return NULL;
	}
	return Py_BuildValue("i",setfps.parm.capture.timeperframe.denominator);
	}

	static PyObject Video_device_start(Video_device self)
	{
	ASSERT_OPEN;
	enum v4l2_buf_type type;
	type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

	if(my_ioctl(self->fd, VIDIOC_STREAMON, &type))
	{
	return NULL;
	}

	Py_RETURN_NONE;
	}

	static PyObject Video_device_stop(Video_device self)
	{
	ASSERT_OPEN;
	enum v4l2_buf_type type;
	type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

	if(my_ioctl(self->fd, VIDIOC_STREAMOFF, &type))
	{
	return NULL;
	}

	Py_RETURN_NONE;
	}

	static PyObject Video_device_create_buffers(Video_device self, PyObject *args)
	{
	int buffer_count;

	if(!PyArg_ParseTuple(args, "I", &buffer_count))
	{
	return NULL;
	}

	ASSERT_OPEN;

	if(self->buffers)
	{
	PyErr_SetString(PyExc_ValueError, "Buffers are already created");
	return NULL;
	}

	struct v4l2_requestbuffers reqbuf;
	reqbuf.count = buffer_count;
	reqbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
	reqbuf.memory = V4L2_MEMORY_MMAP;

	if(my_ioctl(self->fd, VIDIOC_REQBUFS, &reqbuf))
	{
	return NULL;
	}

	if(!reqbuf.count)
	{
	PyErr_SetString(PyExc_IOError, "Not enough buffer memory");
	return NULL;
	}

	self->buffers = malloc(reqbuf.count * sizeof(struct buffer));

	if(!self->buffers)
	{
	PyErr_NoMemory();
	return NULL;
	}

	int i;

	for(i = 0; i < reqbuf.count; i++)
	{
	struct v4l2_buffer buffer;
	buffer.index = i;
	buffer.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
	buffer.memory = V4L2_MEMORY_MMAP;

	if(my_ioctl(self->fd, VIDIOC_QUERYBUF, &buffer))
	{
	return NULL;
	}

	self->buffers[i].length = buffer.length;
	self->buffers[i].start = v4l2_mmap(NULL, buffer.length,
	PROT_READ \| PROT_WRITE, MAP_SHARED, self->fd, buffer.m.offset);

	if(self->buffers[i].start == MAP_FAILED)
	{
	PyErr_SetFromErrno(PyExc_IOError);
	Video_device_unmap(self);
	return NULL;
	}
	++self->buffer_count;
	}

	Py_RETURN_NONE;
	}

	static PyObject Video_device_queue_all_buffers(Video_device self)
	{
	if(!self->buffers)
	{
	ASSERT_OPEN;
	PyErr_SetString(PyExc_ValueError, "Buffers have not been created");
	return NULL;
	}

	int i;
	int buffer_count = self->buffer_count;

	for(i = 0; i < buffer_count; i++)
	{
	struct v4l2_buffer buffer;
	buffer.index = i;
	buffer.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
	buffer.memory = V4L2_MEMORY_MMAP;

	if(my_ioctl(self->fd, VIDIOC_QBUF, &buffer))
	{
	return NULL;
	}
	}

	Py_RETURN_NONE;
	}

	static PyObject Video_device_read_internal(Video_device self, int queue)
	{
	if(!self->buffers)
	{
	ASSERT_OPEN;
	PyErr_SetString(PyExc_ValueError, "Buffers have not been created");
	return NULL;
	}

	struct v4l2_buffer buffer;
	buffer.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
	buffer.memory = V4L2_MEMORY_MMAP;

	if(my_ioctl(self->fd, VIDIOC_DQBUF, &buffer))
	{
	return NULL;
	}

	PyObject *result = PyString_FromStringAndSize(
	self->buffers[buffer.index].start, buffer.bytesused);

	if(!result)
	{
	return NULL;
	}

	if(queue && my_ioctl(self->fd, VIDIOC_QBUF, &buffer))
	{
	return NULL;
	}

	return result;
	}

	static PyObject Video_device_read(Video_device self)
	{
	return Video_device_read_internal(self, 0);
	}

	static PyObject Video_device_read_and_queue(Video_device self)
	{
	return Video_device_read_internal(self, 1);
	}

	static PyMethodDef Video_device_methods[] = {
	{"close", (PyCFunction)Video_device_close, METH_NOARGS,
	"close()\n\n"
	"Close video device. Subsequent calls to other methods will fail."},
	{"fileno", (PyCFunction)Video_device_fileno, METH_NOARGS,
	"fileno() -> integer \"file descriptor\".\n\n"
	"This enables video devices to be passed select.select for waiting "
	"until a frame is available for reading."},
	{"get_info", (PyCFunction)Video_device_get_info, METH_NOARGS,
	"get_info() -> driver, card, bus_info, capabilities\n\n"
	"Returns three strings with information about the video device, and one "
	"set containing strings identifying the capabilities of the video "
	"device."},
	{"set_format", (PyCFunction)Video_device_set_format, METH_VARARGS,
	"set_format(size_x, size_y) -> size_x, size_y\n\n"
	"Request the video device to set image size and format. The device may "
	"choose another size than requested and will return its choice. The "
	"image format will be MJPEG."},
	{"set_fps", (PyCFunction)Video_device_set_fps, METH_VARARGS,
	"set_fps(fps) -> fps \n\n"
	"Request the video device to set frame per seconds.The device may "
	"choose another frame rate than requested and will return its choice. " },
	{"start", (PyCFunction)Video_device_start, METH_NOARGS,
	"start()\n\n"
	"Start video capture."},
	{"stop", (PyCFunction)Video_device_stop, METH_NOARGS,
	"stop()\n\n"
	"Stop video capture."},
	{"create_buffers", (PyCFunction)Video_device_create_buffers, METH_VARARGS,
	"create_buffers(count)\n\n"
	"Create buffers used for capturing image data. Can only be called once "
	"for each video device object."},
	{"queue_all_buffers", (PyCFunction)Video_device_queue_all_buffers,
	METH_NOARGS,
	"queue_all_buffers()\n\n"
	"Let the video device fill all buffers created."},
	{"read", (PyCFunction)Video_device_read, METH_NOARGS,
	"read() -> string\n\n"
	"Reads image data from a buffer that has been filled by the video "
	"device. The image data is in MJPEG format. "
	"The buffer is removed from the queue. Fails if no buffer "
	"is filled. Use select.select to check for filled buffers."},
	{"read_and_queue", (PyCFunction)Video_device_read_and_queue, METH_NOARGS,
	"read_and_queue()\n\n"
	"Same as 'read', but adds the buffer back to the queue so the video "
	"device can fill it again."},
	{NULL}
	};

	static PyTypeObject Video_device_type = {
	PyObject_HEAD_INIT(NULL)
	0, "v4l2capture.Video_device", sizeof(Video_device), 0,
	(destructor)Video_device_dealloc, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	0, Py_TPFLAGS_DEFAULT, "Video_device(path)\n\nOpens the video device at "
	"the given path and returns an object that can capture images. The "
	"constructor and all methods except close may raise IOError.", 0, 0, 0,
	0, 0, 0, Video_device_methods, 0, 0, 0, 0, 0, 0, 0,
	(initproc)Video_device_init
	};

	static PyMethodDef module_methods[] = {
	{NULL}
	};

	PyMODINIT_FUNC initv4l2capture(void)
	{
	Video_device_type.tp_new = PyType_GenericNew;

	if(PyType_Ready(&Video_device_type) < 0)
	{
	return;
	}

	PyObject *module = Py_InitModule3("v4l2capture", module_methods,
	"Capture video with video4linux2.");

	if(!module)
	{
	return;
	}

	Py_INCREF(&Video_device_type);
	PyModule_AddObject(module, "Video_device", (PyObject *)&Video_device_type);
	}