| // Copyright (c) 2010 The Chromium OS Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include <getopt.h> |
| |
| #include <memory> |
| #include <string> |
| #include <unordered_map> |
| |
| #include "camera_characteristics.h" |
| #include "common_types.h" |
| #include "media_v4l2_device.h" |
| |
| static void PrintUsage(int argc, char** argv) { |
| printf("Usage: %s [options]\n\n" |
| "Options:\n" |
| "--help Print usage\n" |
| "--device=DEVICE_NAME Video device name [/dev/video]\n" |
| "--usb-info=VID:PID Device vendor id and product id\n", |
| argv[0]); |
| } |
| |
| static const char short_options[] = "?d:u:"; |
| static const struct option |
| long_options[] = { |
| { "help", no_argument, NULL, '?' }, |
| { "device", required_argument, NULL, 'd' }, |
| { "usb-info", required_argument, NULL, 'u' }, |
| { 0, 0, 0, 0 } |
| }; |
| |
| int RunTest(V4L2Device* device, V4L2Device::IOMethod io, |
| uint32_t buffers, uint32_t capture_time_in_sec, uint32_t width, |
| uint32_t height, uint32_t pixfmt, uint32_t fps) { |
| int32_t retcode = 0; |
| if (!device->InitDevice(io, width, height, pixfmt, fps)) |
| retcode = 1; |
| |
| if (!retcode && !device->StartCapture()) |
| retcode = 2; |
| |
| if (!retcode && !device->Run(capture_time_in_sec)) |
| retcode = 3; |
| |
| if (!retcode && !device->StopCapture()) |
| retcode = 4; |
| |
| if (!retcode && !device->UninitDevice()) |
| retcode = 5; |
| |
| return retcode; |
| } |
| |
| bool GetSupportedFormats( |
| V4L2Device* device, SupportedFormats* supported_formats) { |
| supported_formats->clear(); |
| |
| SupportedFormat format; |
| uint32_t num_format = 0; |
| device->EnumFormat(&num_format, false); |
| for (uint32_t i = 0; i < num_format; ++i) { |
| if (!device->GetPixelFormat(i, &format.fourcc)) { |
| printf("[Error] Get format error\n"); |
| return false; |
| } |
| uint32_t num_frame_size; |
| if (!device->EnumFrameSize(format.fourcc, &num_frame_size, false)) { |
| printf("[Error] Enumerate frame size error\n"); |
| return false; |
| }; |
| |
| for (uint32_t j = 0; j < num_frame_size; ++j) { |
| if (!device->GetFrameSize(j, format.fourcc, &format.width, |
| &format.height)) { |
| printf("[Error] Get frame size error\n"); |
| return false; |
| }; |
| uint32_t num_frame_rate; |
| if (!device->EnumFrameInterval(format.fourcc, format.width, |
| format.height, &num_frame_rate, false)) { |
| printf("[Error] Enumerate frame interval error\n"); |
| return false; |
| }; |
| |
| format.frame_rates.clear(); |
| uint32_t frame_rate; |
| for (uint32_t k = 0; k < num_frame_rate; ++k) { |
| if (!device->GetFrameInterval(k, format.fourcc, format.width, |
| format.height, &frame_rate)) { |
| printf("[Error] Get frame interval error\n"); |
| return false; |
| }; |
| // All supported resolution should have at least 1 fps. |
| if (frame_rate == 0) { |
| printf("[Error] Frame rate should be at least 1.\n"); |
| return false; |
| } |
| format.frame_rates.push_back(frame_rate); |
| } |
| supported_formats->push_back(format); |
| } |
| } |
| return true; |
| } |
| |
| SupportedFormat GetMaximumResolution(const SupportedFormats& formats) { |
| SupportedFormat max_format; |
| memset(&max_format, 0, sizeof(max_format)); |
| for (const auto& format : formats) { |
| if (format.width >= max_format.width && |
| format.height >= max_format.height) { |
| max_format = format; |
| } |
| } |
| return max_format; |
| } |
| |
| // Find format according to width and height. If multiple formats support the |
| // same resolution, choose V4L2_PIX_FMT_MJPEG first. |
| const SupportedFormat* FindFormatByResolution(const SupportedFormats& formats, |
| uint32_t width, |
| uint32_t height) { |
| const SupportedFormat* result_format = nullptr; |
| for (const auto& format : formats) { |
| if (format.width == width && format.height == height) { |
| if (!result_format || format.fourcc == V4L2_PIX_FMT_MJPEG) { |
| result_format = &format; |
| } |
| } |
| } |
| return result_format; |
| } |
| |
| bool TestIO(const std::string& dev_name) { |
| uint32_t buffers = 4; |
| uint32_t width = 640; |
| uint32_t height = 480; |
| uint32_t pixfmt = V4L2_PIX_FMT_YUYV; |
| uint32_t fps = 30; |
| uint32_t time_to_capture = 3; // The unit is second. |
| bool check_1280x960 = false; |
| |
| std::unique_ptr<V4L2Device> device( |
| new V4L2Device(dev_name.c_str(), buffers)); |
| |
| if (!device->OpenDevice()) |
| return false; |
| |
| v4l2_capability cap; |
| if (!device->ProbeCaps(&cap)) |
| return false; |
| |
| if (cap.capabilities & V4L2_CAP_STREAMING) { |
| int mmap_ret = RunTest(device.get(), V4L2Device::IO_METHOD_MMAP, buffers, |
| time_to_capture, width, height, pixfmt, fps); |
| int userp_ret = RunTest(device.get(), V4L2Device::IO_METHOD_USERPTR, |
| buffers, time_to_capture, width, height, pixfmt, fps); |
| if (mmap_ret && userp_ret) { |
| printf("[Error] Stream I/O failed.\n"); |
| return false; |
| } |
| } else { |
| printf("[Error] Streaming capability is mandatory.\n"); |
| return false; |
| } |
| |
| device->CloseDevice(); |
| return true; |
| } |
| |
| // Test all required resolutions with all fps which are larger than 30. |
| bool TestResolutions(const std::string& dev_name, bool check_1280x960) { |
| uint32_t buffers = 4; |
| uint32_t time_to_capture = 3; |
| V4L2Device::IOMethod io = V4L2Device::IO_METHOD_MMAP; |
| std::unique_ptr<V4L2Device> device( |
| new V4L2Device(dev_name.c_str(), buffers)); |
| |
| if (!device->OpenDevice()) |
| return false; |
| |
| SupportedFormats supported_formats; |
| if (!GetSupportedFormats(device.get(), &supported_formats)) { |
| printf("[Error] Get supported formats failed in %s.\n", dev_name.c_str()); |
| return false; |
| } |
| SupportedFormat max_resolution = GetMaximumResolution(supported_formats); |
| |
| SupportedFormats required_resolutions; |
| required_resolutions.push_back(SupportedFormat(320, 240, 0, 30)); |
| required_resolutions.push_back(SupportedFormat(640, 480, 0, 30)); |
| required_resolutions.push_back(SupportedFormat(1280, 720, 0, 30)); |
| required_resolutions.push_back(SupportedFormat(1920, 1080, 0, 30)); |
| required_resolutions.push_back(SupportedFormat(1600, 1200, 0, 30)); |
| if (check_1280x960) { |
| required_resolutions.push_back(SupportedFormat(1280, 960, 0, 30)); |
| } |
| |
| for (const auto& test_resolution : required_resolutions) { |
| // Skip the resolution that is larger than the maximum. |
| if (max_resolution.width < test_resolution.width || |
| max_resolution.height < test_resolution.height) { |
| continue; |
| } |
| |
| const SupportedFormat* test_format = FindFormatByResolution( |
| supported_formats, test_resolution.width, test_resolution.height); |
| if (test_format == nullptr) { |
| printf("[Error] %dx%d not found in %s\n", test_resolution.width, |
| test_resolution.height, dev_name.c_str()); |
| return false; |
| } |
| |
| bool frame_rate_tested = false; |
| for (const auto& frame_rate : test_format->frame_rates) { |
| // If the fps is less than the fps that we want to test, skip it. |
| if (frame_rate < test_resolution.frame_rates[0]) { |
| continue; |
| } |
| frame_rate_tested = true; |
| if (RunTest(device.get(), io, buffers, time_to_capture, |
| test_format->width, test_format->height, test_format->fourcc, |
| frame_rate)) { |
| printf("[Error] Could not capture frames for %dx%d (%08X) in %s\n", |
| test_format->width, test_format->height, test_format->fourcc, |
| dev_name.c_str()); |
| return false; |
| } |
| |
| // Make sure the driver didn't adjust the format. |
| v4l2_format fmt = device->GetActualPixelFormat(); |
| if (test_format->width != fmt.fmt.pix.width || |
| test_format->height != fmt.fmt.pix.height || |
| test_format->fourcc != fmt.fmt.pix.pixelformat || |
| frame_rate != device->GetFrameRate()) { |
| printf("[Error] Capture test %dx%d (%08X) failed in %s\n", |
| test_format->width, test_format->height, test_format->fourcc, |
| dev_name.c_str()); |
| } |
| } |
| if (!frame_rate_tested) { |
| printf("[Error] Cannot test frame rate for %dx%d (%08X) failed in %s\n", |
| test_format->width, test_format->height, test_format->fourcc, |
| dev_name.c_str()); |
| return false; |
| } |
| } |
| device->CloseDevice(); |
| |
| return true; |
| } |
| |
| int main(int argc, char** argv) { |
| std::string dev_name = "/dev/video"; |
| std::string usb_info = ""; |
| |
| for (;;) { |
| int32_t index; |
| int32_t c = getopt_long(argc, argv, short_options, long_options, &index); |
| if (-1 == c) |
| break; |
| switch (c) { |
| case 0: // getopt_long() flag. |
| break; |
| case '?': |
| PrintUsage(argc, argv); |
| exit (EXIT_SUCCESS); |
| case 'd': |
| // Initialize default v4l2 device name. |
| dev_name = strdup(optarg); |
| break; |
| case 'u': |
| usb_info = strdup(optarg); |
| break; |
| default: |
| PrintUsage(argc, argv); |
| exit(EXIT_FAILURE); |
| } |
| } |
| |
| std::unordered_map<std::string, std::string> mapping = {{usb_info, dev_name}}; |
| CameraCharacteristics characteristics; |
| DeviceInfos device_infos = |
| characteristics.GetCharacteristicsFromFile(mapping); |
| |
| bool check_1280x960 = false; |
| if (device_infos.size() > 1) { |
| printf("[Error] One device should not have multiple configs.\n"); |
| exit(EXIT_FAILURE); |
| } |
| if (device_infos.size() == 1) { |
| check_1280x960 = !device_infos[0].resolution_1280x960_unsupported; |
| } |
| printf("[Info] check 1280x960: %d\n", check_1280x960); |
| |
| if (!TestIO(dev_name)) |
| exit(EXIT_FAILURE); |
| |
| if (!TestResolutions(dev_name, check_1280x960)) |
| exit(EXIT_FAILURE); |
| |
| return EXIT_SUCCESS; |
| } |
