| /* |
| * Copyright (C) 2011 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| /* |
| * Contains code that is used to capture video frames from a camera device |
| * on Linux. This code uses V4L2 API to work with camera devices, and requires |
| * Linux kernel version at least 2.5 |
| */ |
| |
| #include <sys/mman.h> |
| #include <sys/stat.h> |
| #include <sys/ioctl.h> |
| #include "android/camera/camera-capture.h" |
| #include "android/camera/camera-format-converters.h" |
| |
| #define E(...) derror(__VA_ARGS__) |
| #define W(...) dwarning(__VA_ARGS__) |
| #define D(...) VERBOSE_PRINT(camera,__VA_ARGS__) |
| #define D_ACTIVE VERBOSE_CHECK(camera) |
| |
| /* the T(...) macro is used to dump traffic */ |
| #define T_ACTIVE 0 |
| |
| #if T_ACTIVE |
| #define T(...) VERBOSE_PRINT(camera,__VA_ARGS__) |
| #else |
| #define T(...) ((void)0) |
| #endif |
| |
| #define CLEAR(x) memset (&(x), 0, sizeof(x)) |
| |
| /* Pixel format descriptor. |
| * Instances of this descriptor are created during camera device enumeration, and |
| * an instance of this structure describing pixel format chosen for the camera |
| * emulation is saved by the camera factory service to represent an emulating |
| * camera properties. |
| */ |
| typedef struct QemuPixelFormat { |
| /* Pixel format in V4L2_PIX_FMT_XXX form. */ |
| uint32_t format; |
| /* Frame dimensions supported by this format. */ |
| CameraFrameDim* dims; |
| /* Number of frame dimensions supported by this format. */ |
| int dim_num; |
| } QemuPixelFormat; |
| |
| /* Describes a framebuffer. */ |
| typedef struct CameraFrameBuffer { |
| /* Framebuffer data. */ |
| uint8_t* data; |
| /* Framebuffer data size. */ |
| size_t size; |
| } CameraFrameBuffer; |
| |
| /* Defines type of the I/O used to obtain frames from the device. */ |
| typedef enum CameraIoType { |
| /* Framebuffers are shared via memory mapping. */ |
| CAMERA_IO_MEMMAP, |
| /* Framebuffers are available via user pointers. */ |
| CAMERA_IO_USERPTR, |
| /* Framebuffers are to be read from the device. */ |
| CAMERA_IO_DIRECT |
| } CameraIoType; |
| |
| typedef struct LinuxCameraDevice LinuxCameraDevice; |
| /* |
| * Describes a connection to an actual camera device. |
| */ |
| struct LinuxCameraDevice { |
| /* Common header. */ |
| CameraDevice header; |
| |
| /* Camera device name. (default is /dev/video0) */ |
| char* device_name; |
| /* Input channel. (default is 0) */ |
| int input_channel; |
| |
| /* |
| * Set by the framework after initializing camera connection. |
| */ |
| |
| /* Handle to the opened camera device. */ |
| int handle; |
| /* Device capabilities. */ |
| struct v4l2_capability caps; |
| /* Actual pixel format reported by the device when capturing is started. */ |
| struct v4l2_pix_format actual_pixel_format; |
| /* Defines type of the I/O to use to retrieve frames from the device. */ |
| CameraIoType io_type; |
| /* Allocated framebuffers. */ |
| struct CameraFrameBuffer* framebuffers; |
| /* Actual number of allocated framebuffers. */ |
| int framebuffer_num; |
| }; |
| |
| /* Preferred pixel formats arranged from the most to the least desired. |
| * |
| * More than anything else this array is defined by an existance of format |
| * conversion between the camera supported formats, and formats that are |
| * supported by camera framework in the guest system. Currently, guest supports |
| * only YV12 pixel format for data, and RGB32 for preview. So, this array should |
| * contain only those formats, for which converters are implemented. Generally |
| * speaking, the order in which entries should be arranged in this array matters |
| * only as far as conversion speed is concerned. So, formats with the fastest |
| * converters should be put closer to the top of the array, while slower ones |
| * should be put closer to the bottom. But as far as functionality is concerned, |
| * the orser doesn't matter, and any format can be placed anywhere in this array, |
| * as long as conversion for it exists. |
| */ |
| static const uint32_t _preferred_formats[] = |
| { |
| /* Native format for the emulated camera: no conversion at all. */ |
| V4L2_PIX_FMT_YUV420, |
| V4L2_PIX_FMT_YVU420, |
| /* Continue with YCbCr: less math than with RGB */ |
| V4L2_PIX_FMT_NV12, |
| V4L2_PIX_FMT_NV21, |
| V4L2_PIX_FMT_YUYV, |
| /* End with RGB. */ |
| V4L2_PIX_FMT_RGB32, |
| V4L2_PIX_FMT_RGB24, |
| V4L2_PIX_FMT_RGB565, |
| }; |
| /* Number of entries in _preferred_formats array. */ |
| static const int _preferred_format_num = |
| sizeof(_preferred_formats)/sizeof(*_preferred_formats); |
| |
| /******************************************************************************* |
| * Helper routines |
| ******************************************************************************/ |
| |
| /* IOCTL wrapper. */ |
| static int |
| _xioctl(int fd, int request, void *arg) { |
| int r; |
| do { |
| r = ioctl(fd, request, arg); |
| } while (-1 == r && EINTR == errno); |
| return r; |
| } |
| |
| /* Frees resource allocated for QemuPixelFormat instance, excluding the instance |
| * itself. |
| */ |
| static void _qemu_pixel_format_free(QemuPixelFormat* fmt) |
| { |
| if (fmt != NULL) { |
| if (fmt->dims != NULL) |
| free(fmt->dims); |
| } |
| } |
| |
| /* Returns an index of the given pixel format in an array containing pixel |
| * format descriptors. |
| * This routine is used to choose a pixel format for a camera device. The idea |
| * is that when the camera service enumerates all pixel formats for all cameras |
| * connected to the host, we need to choose just one, which would be most |
| * appropriate for camera emulation. To do that, the camera service will run |
| * formats, contained in _preferred_formats array against enumerated pixel |
| * formats to pick the first format that match. |
| * Param: |
| * fmt - Pixel format, for which to obtain the index. |
| * formats - Array containing list of pixel formats, supported by the camera |
| * device. |
| * size - Number of elements in the 'formats' array. |
| * Return: |
| * Index of the matched entry in the array, or -1 if no entry has been found. |
| */ |
| static int |
| _get_format_index(uint32_t fmt, QemuPixelFormat* formats, int size) |
| { |
| int f; |
| for (f = 0; f < size && formats[f].format != fmt; f++); |
| return f < size ? f : -1; |
| } |
| |
| /******************************************************************************* |
| * CameraFrameBuffer routines |
| ******************************************************************************/ |
| |
| /* Frees array of framebuffers, depending on the I/O method the array has been |
| * initialized for. |
| * Note that this routine doesn't frees the array itself. |
| * Param: |
| * fb, num - Array data, and its size. |
| * io_type - Type of the I/O the array has been initialized for. |
| */ |
| static void |
| _free_framebuffers(CameraFrameBuffer* fb, int num, CameraIoType io_type) |
| { |
| if (fb != NULL) { |
| int n; |
| |
| switch (io_type) { |
| case CAMERA_IO_MEMMAP: |
| /* Unmap framebuffers. */ |
| for (n = 0; n < num; n++) { |
| if (fb[n].data != NULL) { |
| munmap(fb[n].data, fb[n].size); |
| fb[n].data = NULL; |
| fb[n].size = 0; |
| } |
| } |
| break; |
| |
| case CAMERA_IO_USERPTR: |
| case CAMERA_IO_DIRECT: |
| /* Free framebuffers. */ |
| for (n = 0; n < num; n++) { |
| if (fb[n].data != NULL) { |
| free(fb[n].data); |
| fb[n].data = NULL; |
| fb[n].size = 0; |
| } |
| } |
| break; |
| |
| default: |
| E("%s: Invalid I/O type %d", __FUNCTION__, io_type); |
| break; |
| } |
| } |
| } |
| |
| /******************************************************************************* |
| * CameraDevice routines |
| ******************************************************************************/ |
| |
| /* Allocates an instance of LinuxCameraDevice structure. |
| * Return: |
| * Allocated instance of LinuxCameraDevice structure. Note that this routine |
| * also sets 'opaque' field in the 'header' structure to point back to the |
| * containing LinuxCameraDevice instance. |
| */ |
| static LinuxCameraDevice* |
| _camera_device_alloc(void) |
| { |
| LinuxCameraDevice* cd; |
| |
| ANEW0(cd); |
| memset(cd, 0, sizeof(*cd)); |
| cd->header.opaque = cd; |
| cd->handle = -1; |
| |
| return cd; |
| } |
| |
| /* Uninitializes and frees CameraDevice structure. |
| */ |
| static void |
| _camera_device_free(LinuxCameraDevice* lcd) |
| { |
| if (lcd != NULL) { |
| /* Closing handle will also disconnect from the driver. */ |
| if (lcd->handle >= 0) { |
| close(lcd->handle); |
| } |
| if (lcd->device_name != NULL) { |
| free(lcd->device_name); |
| } |
| if (lcd->framebuffers != NULL) { |
| _free_framebuffers(lcd->framebuffers, lcd->framebuffer_num, |
| lcd->io_type); |
| free(lcd->framebuffers); |
| } |
| AFREE(lcd); |
| } else { |
| E("%s: No descriptor", __FUNCTION__); |
| } |
| } |
| |
| /* Resets camera device after capturing. |
| * Since new capture request may require different frame dimensions we must |
| * reset camera device by reopening its handle. Otherwise attempts to set up new |
| * frame properties (different from the previous one) may fail. */ |
| static void |
| _camera_device_reset(LinuxCameraDevice* cd) |
| { |
| struct v4l2_cropcap cropcap; |
| struct v4l2_crop crop; |
| |
| /* Free capturing framebuffers first. */ |
| if (cd->framebuffers != NULL) { |
| _free_framebuffers(cd->framebuffers, cd->framebuffer_num, cd->io_type); |
| free(cd->framebuffers); |
| cd->framebuffers = NULL; |
| cd->framebuffer_num = 0; |
| } |
| |
| /* Reset device handle. */ |
| close(cd->handle); |
| cd->handle = open(cd->device_name, O_RDWR | O_NONBLOCK, 0); |
| |
| if (cd->handle >= 0) { |
| /* Select video input, video standard and tune here. */ |
| cropcap.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; |
| _xioctl(cd->handle, VIDIOC_CROPCAP, &cropcap); |
| crop.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; |
| crop.c = cropcap.defrect; /* reset to default */ |
| _xioctl (cd->handle, VIDIOC_S_CROP, &crop); |
| } |
| } |
| |
| /* Memory maps buffers and shares mapped memory with the device. |
| * Return: |
| * 0 Framebuffers have been mapped. |
| * -1 A critical error has ocurred. |
| * 1 Memory mapping is not available. |
| */ |
| static int |
| _camera_device_mmap_framebuffer(LinuxCameraDevice* cd) |
| { |
| struct v4l2_requestbuffers req; |
| CLEAR(req); |
| req.count = 4; |
| req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; |
| req.memory = V4L2_MEMORY_MMAP; |
| |
| /* Request memory mapped buffers. Note that device can return less buffers |
| * than requested. */ |
| if(_xioctl(cd->handle, VIDIOC_REQBUFS, &req)) { |
| if (EINVAL == errno) { |
| D("%s: Device '%s' does not support memory mapping", |
| __FUNCTION__, cd->device_name); |
| return 1; |
| } else { |
| E("%s: VIDIOC_REQBUFS has failed: %s", |
| __FUNCTION__, strerror(errno)); |
| return -1; |
| } |
| } |
| |
| /* Allocate framebuffer array. */ |
| cd->framebuffers = calloc(req.count, sizeof(CameraFrameBuffer)); |
| if (cd->framebuffers == NULL) { |
| E("%s: Not enough memory to allocate framebuffer array", __FUNCTION__); |
| return -1; |
| } |
| |
| /* Map every framebuffer to the shared memory, and queue it |
| * with the device. */ |
| for(cd->framebuffer_num = 0; cd->framebuffer_num < req.count; |
| cd->framebuffer_num++) { |
| /* Map framebuffer. */ |
| struct v4l2_buffer buf; |
| CLEAR(buf); |
| buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; |
| buf.memory = V4L2_MEMORY_MMAP; |
| buf.index = cd->framebuffer_num; |
| if(_xioctl(cd->handle, VIDIOC_QUERYBUF, &buf) < 0) { |
| E("%s: VIDIOC_QUERYBUF has failed: %s", |
| __FUNCTION__, strerror(errno)); |
| return -1; |
| } |
| cd->framebuffers[cd->framebuffer_num].size = buf.length; |
| cd->framebuffers[cd->framebuffer_num].data = |
| mmap(NULL, buf.length, PROT_READ | PROT_WRITE, MAP_SHARED, |
| cd->handle, buf.m.offset); |
| if (MAP_FAILED == cd->framebuffers[cd->framebuffer_num].data) { |
| E("%s: Memory mapping has failed: %s", |
| __FUNCTION__, strerror(errno)); |
| return -1; |
| } |
| |
| /* Queue the mapped buffer. */ |
| CLEAR(buf); |
| buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; |
| buf.memory = V4L2_MEMORY_MMAP; |
| buf.index = cd->framebuffer_num; |
| if (_xioctl(cd->handle, VIDIOC_QBUF, &buf) < 0) { |
| E("%s: VIDIOC_QBUF has failed: %s", __FUNCTION__, strerror(errno)); |
| return -1; |
| } |
| } |
| |
| cd->io_type = CAMERA_IO_MEMMAP; |
| |
| return 0; |
| } |
| |
| /* Allocates frame buffers and registers them with the device. |
| * Return: |
| * 0 Framebuffers have been mapped. |
| * -1 A critical error has ocurred. |
| * 1 Device doesn't support user pointers. |
| */ |
| static int |
| _camera_device_user_framebuffer(LinuxCameraDevice* cd) |
| { |
| struct v4l2_requestbuffers req; |
| CLEAR (req); |
| req.count = 4; |
| req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; |
| req.memory = V4L2_MEMORY_USERPTR; |
| |
| /* Request user buffers. Note that device can return less buffers |
| * than requested. */ |
| if(_xioctl(cd->handle, VIDIOC_REQBUFS, &req)) { |
| if (EINVAL == errno) { |
| D("%s: Device '%s' does not support user pointers", |
| __FUNCTION__, cd->device_name); |
| return 1; |
| } else { |
| E("%s: VIDIOC_REQBUFS has failed: %s", |
| __FUNCTION__, strerror(errno)); |
| return -1; |
| } |
| } |
| |
| /* Allocate framebuffer array. */ |
| cd->framebuffers = calloc(req.count, sizeof(CameraFrameBuffer)); |
| if (cd->framebuffers == NULL) { |
| E("%s: Not enough memory to allocate framebuffer array", __FUNCTION__); |
| return -1; |
| } |
| |
| /* Allocate buffers, queueing them wit the device at the same time */ |
| for(cd->framebuffer_num = 0; cd->framebuffer_num < req.count; |
| cd->framebuffer_num++) { |
| cd->framebuffers[cd->framebuffer_num].size = |
| cd->actual_pixel_format.sizeimage; |
| cd->framebuffers[cd->framebuffer_num].data = |
| malloc(cd->framebuffers[cd->framebuffer_num].size); |
| if (cd->framebuffers[cd->framebuffer_num].data == NULL) { |
| E("%s: Not enough memory to allocate framebuffer", __FUNCTION__); |
| return -1; |
| } |
| |
| /* Queue the user buffer. */ |
| struct v4l2_buffer buf; |
| CLEAR(buf); |
| buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; |
| buf.memory = V4L2_MEMORY_USERPTR; |
| buf.m.userptr = (unsigned long)cd->framebuffers[cd->framebuffer_num].data; |
| buf.length = cd->framebuffers[cd->framebuffer_num].size; |
| if (_xioctl(cd->handle, VIDIOC_QBUF, &buf) < 0) { |
| E("%s: VIDIOC_QBUF has failed: %s", __FUNCTION__, strerror(errno)); |
| return -1; |
| } |
| } |
| |
| cd->io_type = CAMERA_IO_USERPTR; |
| |
| return 0; |
| } |
| |
| /* Allocate frame buffer for direct read from the device. |
| * Return: |
| * 0 Framebuffers have been mapped. |
| * -1 A critical error has ocurred. |
| * 1 Memory mapping is not available. |
| */ |
| static int |
| _camera_device_direct_framebuffer(LinuxCameraDevice* cd) |
| { |
| /* Allocate framebuffer array. */ |
| cd->framebuffer_num = 1; |
| cd->framebuffers = malloc(sizeof(CameraFrameBuffer)); |
| if (cd->framebuffers == NULL) { |
| E("%s: Not enough memory to allocate framebuffer array", __FUNCTION__); |
| return -1; |
| } |
| |
| cd->framebuffers[0].size = cd->actual_pixel_format.sizeimage; |
| cd->framebuffers[0].data = malloc(cd->framebuffers[0].size); |
| if (cd->framebuffers[0].data == NULL) { |
| E("%s: Not enough memory to allocate framebuffer", __FUNCTION__); |
| return -1; |
| } |
| |
| cd->io_type = CAMERA_IO_DIRECT; |
| |
| return 0; |
| } |
| |
| /* Opens camera device. |
| * Param: |
| * cd - Camera device descriptor to open the camera for. |
| * Return: |
| * 0 on success, != 0 on failure. |
| */ |
| static int |
| _camera_device_open(LinuxCameraDevice* cd) |
| { |
| struct stat st; |
| |
| if (stat(cd->device_name, &st)) { |
| return -1; |
| } |
| |
| if (!S_ISCHR(st.st_mode)) { |
| E("%s: '%s' is not a device", __FUNCTION__, cd->device_name); |
| return -1; |
| } |
| |
| /* Open handle to the device, and query device capabilities. */ |
| cd->handle = open(cd->device_name, O_RDWR | O_NONBLOCK, 0); |
| if (cd->handle < 0) { |
| E("%s: Cannot open camera device '%s': %s", |
| __FUNCTION__, cd->device_name, strerror(errno)); |
| return -1; |
| } |
| if (_xioctl(cd->handle, VIDIOC_QUERYCAP, &cd->caps) < 0) { |
| if (EINVAL == errno) { |
| E("%s: Camera '%s' is not a V4L2 device", |
| __FUNCTION__, cd->device_name); |
| close(cd->handle); |
| cd->handle = -1; |
| return -1; |
| } else { |
| E("%s: Unable to query capabilities for camera device '%s'", |
| __FUNCTION__, cd->device_name); |
| close(cd->handle); |
| cd->handle = -1; |
| return -1; |
| } |
| } |
| |
| /* Make sure that camera supports minimal requirements. */ |
| if (!(cd->caps.capabilities & V4L2_CAP_VIDEO_CAPTURE)) { |
| E("%s: Camera '%s' is not a video capture device", |
| __FUNCTION__, cd->device_name); |
| close(cd->handle); |
| cd->handle = -1; |
| return -1; |
| } |
| |
| return 0; |
| } |
| |
| /* Enumerates frame sizes for the given pixel format. |
| * Param: |
| * cd - Opened camera device descriptor. |
| * fmt - Pixel format to enum frame sizes for. |
| * sizes - Upon success contains an array of supported frame sizes. The size of |
| * the array is defined by the value, returned from this routine. The caller |
| * is responsible for freeing memory allocated for this array. |
| * Return: |
| * On success returns number of entries in the 'sizes' array. On failure returns |
| * a negative value. |
| */ |
| static int |
| _camera_device_enum_format_sizes(LinuxCameraDevice* cd, |
| uint32_t fmt, |
| CameraFrameDim** sizes) |
| { |
| int n; |
| int sizes_num = 0; |
| int out_num = 0; |
| struct v4l2_frmsizeenum size_enum; |
| CameraFrameDim* arr; |
| |
| /* Calculate number of supported sizes for the given format. */ |
| for (n = 0; ; n++) { |
| size_enum.index = n; |
| size_enum.pixel_format = fmt; |
| if(_xioctl(cd->handle, VIDIOC_ENUM_FRAMESIZES, &size_enum)) { |
| break; |
| } |
| if (size_enum.type == V4L2_FRMSIZE_TYPE_DISCRETE) { |
| /* Size is in the simpe width, height form. */ |
| sizes_num++; |
| } else if (size_enum.type == V4L2_FRMSIZE_TYPE_STEPWISE) { |
| /* Sizes are represented as min/max width and height with a step for |
| * each dimension. Since at the end we want to list each supported |
| * size in the array (that's the only format supported by the guest |
| * camera framework), we need to calculate how many array entries |
| * this will generate. */ |
| const uint32_t dif_widths = |
| (size_enum.stepwise.max_width - size_enum.stepwise.min_width) / |
| size_enum.stepwise.step_width + 1; |
| const uint32_t dif_heights = |
| (size_enum.stepwise.max_height - size_enum.stepwise.min_height) / |
| size_enum.stepwise.step_height + 1; |
| sizes_num += dif_widths * dif_heights; |
| } else if (size_enum.type == V4L2_FRMSIZE_TYPE_CONTINUOUS) { |
| /* Special stepwise case, when steps are set to 1. We still need to |
| * flatten this for the guest, but the array may be too big. |
| * Fortunately, we don't need to be fancy, so three sizes would be |
| * sufficient here: min, max, and one in the middle. */ |
| sizes_num += 3; |
| } |
| |
| } |
| if (sizes_num == 0) { |
| return 0; |
| } |
| |
| /* Allocate, and initialize the array of supported entries. */ |
| *sizes = (CameraFrameDim*)malloc(sizes_num * sizeof(CameraFrameDim)); |
| if (*sizes == NULL) { |
| E("%s: Memory allocation failure", __FUNCTION__); |
| return -1; |
| } |
| arr = *sizes; |
| for (n = 0; out_num < sizes_num; n++) { |
| size_enum.index = n; |
| size_enum.pixel_format = fmt; |
| if(_xioctl(cd->handle, VIDIOC_ENUM_FRAMESIZES, &size_enum)) { |
| /* Errors are not welcome here anymore. */ |
| E("%s: Unexpected failure while getting pixel dimensions: %s", |
| __FUNCTION__, strerror(errno)); |
| free(arr); |
| return -1; |
| } |
| |
| if (size_enum.type == V4L2_FRMSIZE_TYPE_DISCRETE) { |
| arr[out_num].width = size_enum.discrete.width; |
| arr[out_num].height = size_enum.discrete.height; |
| out_num++; |
| } else if (size_enum.type == V4L2_FRMSIZE_TYPE_STEPWISE) { |
| uint32_t w; |
| for (w = size_enum.stepwise.min_width; |
| w <= size_enum.stepwise.max_width; |
| w += size_enum.stepwise.step_width) { |
| uint32_t h; |
| for (h = size_enum.stepwise.min_height; |
| h <= size_enum.stepwise.max_height; |
| h += size_enum.stepwise.step_height) { |
| arr[out_num].width = w; |
| arr[out_num].height = h; |
| out_num++; |
| } |
| } |
| } else if (size_enum.type == V4L2_FRMSIZE_TYPE_CONTINUOUS) { |
| /* min */ |
| arr[out_num].width = size_enum.stepwise.min_width; |
| arr[out_num].height = size_enum.stepwise.min_height; |
| out_num++; |
| /* one in the middle */ |
| arr[out_num].width = |
| (size_enum.stepwise.min_width + size_enum.stepwise.max_width) / 2; |
| arr[out_num].height = |
| (size_enum.stepwise.min_height + size_enum.stepwise.max_height) / 2; |
| out_num++; |
| /* max */ |
| arr[out_num].width = size_enum.stepwise.max_width; |
| arr[out_num].height = size_enum.stepwise.max_height; |
| out_num++; |
| } |
| } |
| |
| return out_num; |
| } |
| |
| /* Enumerates pixel formats, supported by the device. |
| * Note that this routine will enumerate only raw (uncompressed) formats. |
| * Param: |
| * cd - Opened camera device descriptor. |
| * fmts - Upon success contains an array of supported pixel formats. The size of |
| * the array is defined by the value, returned from this routine. The caller |
| * is responsible for freeing memory allocated for this array. |
| * Return: |
| * On success returns number of entries in the 'fmts' array. On failure returns |
| * a negative value. |
| */ |
| static int |
| _camera_device_enum_pixel_formats(LinuxCameraDevice* cd, QemuPixelFormat** fmts) |
| { |
| int n, max_fmt; |
| int fmt_num = 0; |
| int out_num = 0; |
| struct v4l2_fmtdesc fmt_enum; |
| QemuPixelFormat* arr; |
| |
| /* Calculate number of supported formats. */ |
| for (max_fmt = 0; ; max_fmt++) { |
| memset(&fmt_enum, 0, sizeof(fmt_enum)); |
| fmt_enum.index = max_fmt; |
| fmt_enum.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; |
| if(_xioctl(cd->handle, VIDIOC_ENUM_FMT, &fmt_enum)) { |
| break; |
| } |
| /* Skip the compressed ones. */ |
| if ((fmt_enum.flags & V4L2_FMT_FLAG_COMPRESSED) == 0) { |
| fmt_num++; |
| } |
| } |
| if (fmt_num == 0) { |
| return 0; |
| } |
| |
| /* Allocate, and initialize array for enumerated formats. */ |
| *fmts = (QemuPixelFormat*)malloc(fmt_num * sizeof(QemuPixelFormat)); |
| if (*fmts == NULL) { |
| E("%s: Memory allocation failure", __FUNCTION__); |
| return -1; |
| } |
| arr = *fmts; |
| memset(arr, 0, fmt_num * sizeof(QemuPixelFormat)); |
| for (n = 0; n < max_fmt && out_num < fmt_num; n++) { |
| memset(&fmt_enum, 0, sizeof(fmt_enum)); |
| fmt_enum.index = n; |
| fmt_enum.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; |
| if(_xioctl(cd->handle, VIDIOC_ENUM_FMT, &fmt_enum)) { |
| int nn; |
| /* Errors are not welcome here anymore. */ |
| E("%s: Unexpected failure while getting pixel format: %s", |
| __FUNCTION__, strerror(errno)); |
| for (nn = 0; nn < out_num; nn++) { |
| _qemu_pixel_format_free(arr + nn); |
| } |
| free(arr); |
| return -1; |
| } |
| /* Skip the compressed ones. */ |
| if ((fmt_enum.flags & V4L2_FMT_FLAG_COMPRESSED) == 0) { |
| arr[out_num].format = fmt_enum.pixelformat; |
| /* Enumerate frame dimensions supported for this format. */ |
| arr[out_num].dim_num = |
| _camera_device_enum_format_sizes(cd, fmt_enum.pixelformat, |
| &arr[out_num].dims); |
| if (arr[out_num].dim_num > 0) { |
| out_num++; |
| } else if (arr[out_num].dim_num < 0) { |
| int nn; |
| E("Unable to enumerate supported dimensions for pixel format %d", |
| fmt_enum.pixelformat); |
| for (nn = 0; nn < out_num; nn++) { |
| _qemu_pixel_format_free(arr + nn); |
| } |
| free(arr); |
| return -1; |
| } |
| } |
| } |
| |
| return out_num; |
| } |
| |
| /* Collects information about an opened camera device. |
| * The information collected in this routine contains list of pixel formats, |
| * supported by the device, and list of frame dimensions supported by the camera |
| * for each pixel format. |
| * Param: |
| * cd - Opened camera device descriptor. |
| * cis - Upon success contains information collected from the camera device. |
| * Return: |
| * 0 on success, != 0 on failure. |
| */ |
| static int |
| _camera_device_get_info(LinuxCameraDevice* cd, CameraInfo* cis) |
| { |
| int f; |
| int chosen = -1; |
| QemuPixelFormat* formats = NULL; |
| int num_pix_fmts = _camera_device_enum_pixel_formats(cd, &formats); |
| if (num_pix_fmts <= 0) { |
| return -1; |
| } |
| |
| /* Lets see if camera supports preferred formats */ |
| for (f = 0; f < _preferred_format_num; f++) { |
| chosen = _get_format_index(_preferred_formats[f], formats, num_pix_fmts); |
| if (chosen >= 0) { |
| break; |
| } |
| } |
| if (chosen < 0) { |
| /* Camera doesn't support any of the chosen formats. Then it doesn't |
| * matter which one we choose. Lets choose the first one. */ |
| chosen = 0; |
| } |
| |
| cis->device_name = ASTRDUP(cd->device_name); |
| cis->inp_channel = cd->input_channel; |
| cis->pixel_format = formats[chosen].format; |
| cis->frame_sizes_num = formats[chosen].dim_num; |
| /* Swap instead of copy. */ |
| cis->frame_sizes = formats[chosen].dims; |
| formats[chosen].dims = NULL; |
| cis->in_use = 0; |
| |
| for (f = 0; f < num_pix_fmts; f++) { |
| _qemu_pixel_format_free(formats + f); |
| } |
| free(formats); |
| |
| return 0; |
| } |
| |
| /******************************************************************************* |
| * CameraDevice API |
| ******************************************************************************/ |
| |
| CameraDevice* |
| camera_device_open(const char* name, int inp_channel) |
| { |
| struct v4l2_cropcap cropcap; |
| struct v4l2_crop crop; |
| LinuxCameraDevice* cd; |
| |
| /* Allocate and initialize the descriptor. */ |
| cd = _camera_device_alloc(); |
| cd->device_name = name != NULL ? ASTRDUP(name) : ASTRDUP("/dev/video0"); |
| cd->input_channel = inp_channel; |
| |
| /* Open the device. */ |
| if (_camera_device_open(cd)) { |
| _camera_device_free(cd); |
| return NULL; |
| } |
| |
| /* Select video input, video standard and tune here. */ |
| cropcap.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; |
| _xioctl(cd->handle, VIDIOC_CROPCAP, &cropcap); |
| crop.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; |
| crop.c = cropcap.defrect; /* reset to default */ |
| _xioctl (cd->handle, VIDIOC_S_CROP, &crop); |
| |
| return &cd->header; |
| } |
| |
| int |
| camera_device_start_capturing(CameraDevice* ccd, |
| uint32_t pixel_format, |
| int frame_width, |
| int frame_height) |
| { |
| struct v4l2_format fmt; |
| LinuxCameraDevice* cd; |
| char fmt_str[5]; |
| int r; |
| |
| /* Sanity checks. */ |
| if (ccd == NULL || ccd->opaque == NULL) { |
| E("%s: Invalid camera device descriptor", __FUNCTION__); |
| return -1; |
| } |
| cd = (LinuxCameraDevice*)ccd->opaque; |
| if (cd->handle < 0) { |
| E("%s: Camera device is not opened", __FUNCTION__); |
| return -1; |
| } |
| |
| /* Try to set pixel format with the given dimensions. */ |
| CLEAR(fmt); |
| fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; |
| fmt.fmt.pix.width = frame_width; |
| fmt.fmt.pix.height = frame_height; |
| fmt.fmt.pix.pixelformat = pixel_format; |
| if (_xioctl(cd->handle, VIDIOC_S_FMT, &fmt) < 0) { |
| memcpy(fmt_str, &pixel_format, 4); |
| fmt_str[4] = '\0'; |
| E("%s: Camera '%s' does not support pixel format '%s' with dimensions %dx%d", |
| __FUNCTION__, cd->device_name, fmt_str, frame_width, frame_height); |
| _camera_device_reset(cd); |
| return -1; |
| } |
| /* VIDIOC_S_FMT may has changed some properties of the structure. Make sure |
| * that dimensions didn't change. */ |
| if (fmt.fmt.pix.width != frame_width || fmt.fmt.pix.height != frame_height) { |
| memcpy(fmt_str, &pixel_format, 4); |
| fmt_str[4] = '\0'; |
| E("%s: Dimensions %dx%d are wrong for pixel format '%s'", |
| __FUNCTION__, frame_width, frame_height, fmt_str); |
| _camera_device_reset(cd); |
| return -1; |
| } |
| memcpy(&cd->actual_pixel_format, &fmt.fmt.pix, sizeof(struct v4l2_pix_format)); |
| |
| /* |
| * Lets initialize frame buffers, and see what kind of I/O we're going to |
| * use to retrieve frames. |
| */ |
| |
| /* First, lets see if we can do mapped I/O (as most performant one). */ |
| r = _camera_device_mmap_framebuffer(cd); |
| if (r < 0) { |
| /* Some critical error has ocurred. Bail out. */ |
| _camera_device_reset(cd); |
| return -1; |
| } else if (r > 0) { |
| /* Device doesn't support memory mapping. Retrieve to the next performant |
| * one: preallocated user buffers. */ |
| r = _camera_device_user_framebuffer(cd); |
| if (r < 0) { |
| /* Some critical error has ocurred. Bail out. */ |
| _camera_device_reset(cd); |
| return -1; |
| } else if (r > 0) { |
| /* The only thing left for us is direct reading from the device. */ |
| if (!(cd->caps.capabilities & V4L2_CAP_READWRITE)) { |
| E("%s: Don't know how to access frames on device '%s'", |
| __FUNCTION__, cd->device_name); |
| _camera_device_reset(cd); |
| return -1; |
| } |
| r = _camera_device_direct_framebuffer(cd); |
| if (r != 0) { |
| /* Any error at this point is a critical one. */ |
| _camera_device_reset(cd); |
| return -1; |
| } |
| } |
| } |
| |
| /* Start capturing from the device. */ |
| if (cd->io_type != CAMERA_IO_DIRECT) { |
| enum v4l2_buf_type type; |
| type = V4L2_BUF_TYPE_VIDEO_CAPTURE; |
| if (_xioctl (cd->handle, VIDIOC_STREAMON, &type) < 0) { |
| E("%s: VIDIOC_STREAMON on camera '%s' has failed: %s", |
| __FUNCTION__, cd->device_name, strerror(errno)); |
| _camera_device_reset(cd); |
| return -1; |
| } |
| } |
| return 0; |
| } |
| |
| int |
| camera_device_stop_capturing(CameraDevice* ccd) |
| { |
| enum v4l2_buf_type type; |
| LinuxCameraDevice* cd; |
| |
| /* Sanity checks. */ |
| if (ccd == NULL || ccd->opaque == NULL) { |
| E("%s: Invalid camera device descriptor", __FUNCTION__); |
| return -1; |
| } |
| cd = (LinuxCameraDevice*)ccd->opaque; |
| if (cd->handle < 0) { |
| E("%s: Camera device is not opened", __FUNCTION__); |
| return -1; |
| } |
| |
| switch (cd->io_type) { |
| case CAMERA_IO_DIRECT: |
| /* Nothing to do. */ |
| break; |
| |
| case CAMERA_IO_MEMMAP: |
| case CAMERA_IO_USERPTR: |
| type = V4L2_BUF_TYPE_VIDEO_CAPTURE; |
| if (_xioctl(cd->handle, VIDIOC_STREAMOFF, &type) < 0) { |
| E("%s: VIDIOC_STREAMOFF on camera '%s' has failed: %s", |
| __FUNCTION__, cd->device_name, strerror(errno)); |
| return -1; |
| } |
| break; |
| default: |
| E("%s: Unknown I/O method: %d", __FUNCTION__, cd->io_type); |
| return -1; |
| } |
| |
| /* Reopen the device to reset its internal state. It seems that if we don't |
| * do that, an attempt to reinit the device with different frame dimensions |
| * would fail. */ |
| _camera_device_reset(cd); |
| |
| return 0; |
| } |
| |
| int |
| camera_device_read_frame(CameraDevice* ccd, |
| ClientFrameBuffer* framebuffers, |
| int fbs_num, |
| float r_scale, |
| float g_scale, |
| float b_scale, |
| float exp_comp) |
| { |
| LinuxCameraDevice* cd; |
| |
| /* Sanity checks. */ |
| if (ccd == NULL || ccd->opaque == NULL) { |
| E("%s: Invalid camera device descriptor", __FUNCTION__); |
| return -1; |
| } |
| cd = (LinuxCameraDevice*)ccd->opaque; |
| if (cd->handle < 0) { |
| E("%s: Camera device is not opened", __FUNCTION__); |
| return -1; |
| } |
| |
| if (cd->io_type == CAMERA_IO_DIRECT) { |
| /* Read directly from the device. */ |
| size_t total_read_bytes = 0; |
| /* There is one framebuffer allocated for direct read. */ |
| void* buff = cd->framebuffers[0].data; |
| do { |
| int read_bytes = |
| read(cd->handle, buff + total_read_bytes, |
| cd->actual_pixel_format.sizeimage - total_read_bytes); |
| if (read_bytes < 0) { |
| switch (errno) { |
| case EIO: |
| case EAGAIN: |
| continue; |
| default: |
| E("%s: Unable to read from the camera device '%s': %s", |
| __FUNCTION__, cd->device_name, strerror(errno)); |
| return -1; |
| } |
| } |
| total_read_bytes += read_bytes; |
| } while (total_read_bytes < cd->actual_pixel_format.sizeimage); |
| /* Convert the read frame into the caller's framebuffers. */ |
| return convert_frame(buff, cd->actual_pixel_format.pixelformat, |
| cd->actual_pixel_format.sizeimage, |
| cd->actual_pixel_format.width, |
| cd->actual_pixel_format.height, |
| framebuffers, fbs_num, |
| r_scale, g_scale, b_scale, exp_comp); |
| } else { |
| /* Dequeue next buffer from the device. */ |
| struct v4l2_buffer buf; |
| int res; |
| CLEAR(buf); |
| buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; |
| buf.memory = cd->io_type == CAMERA_IO_MEMMAP ? V4L2_MEMORY_MMAP : |
| V4L2_MEMORY_USERPTR; |
| for (;;) { |
| const int res = _xioctl(cd->handle, VIDIOC_DQBUF, &buf); |
| if (res >= 0) { |
| break; |
| } else if (errno == EAGAIN) { |
| return 1; // Tells the caller to repeat. |
| } else if (errno != EINTR && errno != EIO) { |
| E("%s: VIDIOC_DQBUF on camera '%s' has failed: %s", |
| __FUNCTION__, cd->device_name, strerror(errno)); |
| return -1; |
| } |
| } |
| |
| /* Convert frame to the receiving buffers. */ |
| res = convert_frame(cd->framebuffers[buf.index].data, |
| cd->actual_pixel_format.pixelformat, |
| cd->actual_pixel_format.sizeimage, |
| cd->actual_pixel_format.width, |
| cd->actual_pixel_format.height, |
| framebuffers, fbs_num, |
| r_scale, g_scale, b_scale, exp_comp); |
| |
| /* Requeue the buffer back to the device. */ |
| if (_xioctl(cd->handle, VIDIOC_QBUF, &buf) < 0) { |
| W("%s: VIDIOC_QBUF on camera '%s' has failed: %s", |
| __FUNCTION__, cd->device_name, strerror(errno)); |
| } |
| |
| return res; |
| } |
| } |
| |
| void |
| camera_device_close(CameraDevice* ccd) |
| { |
| LinuxCameraDevice* cd; |
| |
| /* Sanity checks. */ |
| if (ccd != NULL && ccd->opaque != NULL) { |
| cd = (LinuxCameraDevice*)ccd->opaque; |
| _camera_device_free(cd); |
| } else { |
| E("%s: Invalid camera device descriptor", __FUNCTION__); |
| } |
| } |
| |
| int |
| enumerate_camera_devices(CameraInfo* cis, int max) |
| { |
| char dev_name[24]; |
| int found = 0; |
| int n; |
| |
| for (n = 0; n < max; n++) { |
| CameraDevice* cd; |
| |
| sprintf(dev_name, "/dev/video%d", n); |
| cd = camera_device_open(dev_name, 0); |
| if (cd != NULL) { |
| LinuxCameraDevice* lcd = (LinuxCameraDevice*)cd->opaque; |
| if (!_camera_device_get_info(lcd, cis + found)) { |
| char user_name[24]; |
| sprintf(user_name, "webcam%d", found); |
| cis[found].display_name = ASTRDUP(user_name); |
| cis[found].in_use = 0; |
| found++; |
| } |
| camera_device_close(cd); |
| } else { |
| break; |
| } |
| } |
| |
| return found; |
| } |
