| // 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); |
| } |