// Copyright 2015 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "extensions/browser/api/webcam_private/v4l2_webcam.h"
#include <errno.h>
#include <fcntl.h>
#include <linux/uvcvideo.h>
#include <linux/videodev2.h>
#include <stdio.h>
#include <sys/ioctl.h>
#include <unistd.h>
#include "base/logging.h"
#include "base/posix/eintr_wrapper.h"
#define V4L2_CID_PAN_SPEED (V4L2_CID_CAMERA_CLASS_BASE+32)
#define V4L2_CID_TILT_SPEED (V4L2_CID_CAMERA_CLASS_BASE+33)
#define V4L2_CID_PANTILT_CMD (V4L2_CID_CAMERA_CLASS_BASE+34)
// GUID of the Extension Unit for Logitech CC3300e motor control:
// {212de5ff-3080-2c4e-82d9-f587d00540bd}
#define UVC_GUID_LOGITECH_CC3000E_MOTORS \
{ \
0x21, 0x2d, 0xe5, 0xff, 0x30, 0x80, 0x2c, 0x4e, 0x82, 0xd9, 0xf5, 0x87, \
0xd0, 0x05, 0x40, 0xbd \
}
// GUID of the Extension Unit for AVER XU1 motor control:
// {cb666936-6e26-a047-8451-96ecf60330d6}
#define UVC_GUID_AVER \
{ \
0xcb, 0x66, 0x69, 0x36, 0x6e, 0x26, 0xa0, 0x47, 0x84, 0x51, 0x96, 0xec, \
0xf6, 0x03, 0x30, 0xd6 \
}
#define LOGITECH_MOTORCONTROL_PANTILT_CMD 2
#define AVER_UVCX_UCAM_PRESET 0x12
namespace {
const int kLogitechMenuIndexGoHome = 1; // {0x02, Go Home}
const int kLogitechMenuIndexSetHome = 0; // {0x01, Set Home Preset}
const int kAverMenuIndexGoHome = 1; // {0x01, Restore preset 0}
const int kAverMenuIndexSetHome = 0; // {0x00, Set Preset 0}
// Note: Keep in sync with index constants above i.e kLogitechMenuIndex{Get, Set}Home
const uvc_menu_info kLogitechCmdMenu[] = {
{0x01, "Set Home Preset"},
{0x02, "Go Home"},
{0x03, "Go Home"},
{0x04, "Set Preset 1"},
{0x0C, "Restore Preset 1"},
{0x05, "Set Preset 2"},
{0x0D, "Restore Preset 2"},
{0x06, "Set Preset 3"},
{0x0E, "Restore Preset 3"},
{0x07, "Set Preset 4"},
{0x0F, "Restore Preset 4"},
{0x08, "Set Preset 5"},
{0x10, "Restore Preset 5"},
{0x09, "Set Preset 6"},
{0x11, "Restore Preset 6"},
{0x0A, "Set Preset 7"},
{0x12, "Restore Preset 7"},
{0x0B, "Set Preset 8"},
{0x13, "Restore Preset 8"},
};
// Preset 0 is equivalent to HOME in Aver cameras.
// Note: Keep in sync with index constants above i.e kAverMenuIndex{Go, Set}Home.
const uvc_menu_info kAverPresetMenu[] = {
/*0*/ {0x0000, "Set Preset 0"}, /*1*/ {0x0001, "Restore preset 0"},
/*2*/ {0x0100, "Set Preset 1"}, /*3*/ {0x0101, "Restore preset 1"},
/*4*/ {0x0200, "Set Preset 2"}, /*5*/ {0x0202, "Restore preset 2"},
/*6*/ {0x0300, "Set Preset 3"}, /*7*/ {0x0303, "Restore preset 3"},
/*8*/ {0x0400, "Set Preset 4"}, /*9*/ {0x0404, "Restore preset 4"},
/*10*/ {0x0500, "Set Preset 5"}, /*11*/ {0x0505, "Restore preset 5"},
/*12*/ {0x0600, "Set Preset 6"}, /*13*/ {0x0606, "Restore preset 6"},
/*14*/ {0x0700, "Set Preset 7"}, /*15*/ {0x0707, "Restore preset 7"},
/*16*/ {0x0800, "Set Preset 8"}, /*17*/ {0x0808, "Restore preset 8"},
/*18*/ {0x0900, "Set Preset 9"}, /*19*/ {0x0909, "Restore preset 9"},
};
const uvc_xu_control_mapping kLogitechCmdMapping = {
V4L2_CID_PANTILT_CMD,
"Pan/Tilt Go",
UVC_GUID_LOGITECH_CC3000E_MOTORS,
LOGITECH_MOTORCONTROL_PANTILT_CMD,
8,
0,
V4L2_CTRL_TYPE_MENU,
UVC_CTRL_DATA_TYPE_ENUM,
const_cast<uvc_menu_info*>(&kLogitechCmdMenu[0]),
std::size(kLogitechCmdMenu),
};
const uvc_xu_control_mapping kLogitechPanAbsoluteMapping = {
V4L2_CID_PAN_ABSOLUTE,
"Pan (Absolute)",
UVC_GUID_LOGITECH_CC3000E_MOTORS,
12,
32,
0,
V4L2_CTRL_TYPE_INTEGER,
UVC_CTRL_DATA_TYPE_SIGNED,
};
const uvc_xu_control_mapping kLogitechTiltAbsoluteMapping = {
V4L2_CID_TILT_ABSOLUTE,
"Tilt (Absolute)",
UVC_GUID_LOGITECH_CC3000E_MOTORS,
12,
32,
32,
V4L2_CTRL_TYPE_INTEGER,
UVC_CTRL_DATA_TYPE_SIGNED,
};
const uvc_xu_control_mapping kAverCmdMapping = {
V4L2_CID_PANTILT_CMD,
"PTZ Preset",
UVC_GUID_AVER,
AVER_UVCX_UCAM_PRESET,
24,
0,
V4L2_CTRL_TYPE_MENU,
UVC_CTRL_DATA_TYPE_ENUM,
const_cast<uvc_menu_info*>(kAverPresetMenu),
std::size(kAverPresetMenu),
};
} // namespace
namespace extensions {
V4L2Webcam::V4L2Webcam(const std::string& device_id) : device_id_(device_id) {
}
V4L2Webcam::~V4L2Webcam() {
}
bool V4L2Webcam::Open() {
fd_.reset(HANDLE_EINTR(open(device_id_.c_str(), 0)));
return fd_.is_valid();
}
bool V4L2Webcam::EnsureLogitechCommandsMapped() {
int res =
HANDLE_EINTR(ioctl(fd_.get(), UVCIOC_CTRL_MAP, &kLogitechCmdMapping));
// If mapping is successful or it's already mapped, this is a Logitech
// camera.
// NOTE: On success, occasionally EFAULT is returned. On a real error,
// ENOMEM, EPERM, EINVAL, or EOVERFLOW should be returned.
return res >= 0 || errno == EEXIST || errno == EFAULT;
}
bool V4L2Webcam::EnsureAverCommandsMapped() {
int res = HANDLE_EINTR(ioctl(fd_.get(), UVCIOC_CTRL_MAP, &kAverCmdMapping));
// If mapping is successful or it's already mapped, this is an Aver camera.
// NOTE: On success, occasionally EFAULT is returned. On a real error,
// ENOMEM, EPERM, EINVAL, or EOVERFLOW should be returned.
return res >= 0 || errno == EEXIST || errno == EFAULT;
}
bool V4L2Webcam::SetWebcamParameter(int fd, uint32_t control_id, int value) {
// Try to map the V4L2 control to the Logitech extension unit. If the
// connected camera does not implement these extension unit this will just
// silently fail and the standard camera terminal controls will be used.
if (control_id == V4L2_CID_PAN_ABSOLUTE) {
HANDLE_EINTR(ioctl(fd, UVCIOC_CTRL_MAP, &kLogitechPanAbsoluteMapping));
} else if (control_id == V4L2_CID_TILT_ABSOLUTE) {
HANDLE_EINTR(ioctl(fd, UVCIOC_CTRL_MAP, &kLogitechTiltAbsoluteMapping));
}
struct v4l2_control v4l2_ctrl = {control_id, value};
int res = HANDLE_EINTR(ioctl(fd, VIDIOC_S_CTRL, &v4l2_ctrl)) >= 0;
return res >= 0;
}
bool V4L2Webcam::GetWebcamParameter(int fd,
uint32_t control_id,
int* value,
int* min_value,
int* max_value) {
// Try to query current value for |control_id|. The getter fails if not
// supported.
struct v4l2_control v4l2_ctrl = {control_id};
if (HANDLE_EINTR(ioctl(fd, VIDIOC_G_CTRL, &v4l2_ctrl)))
return false;
*value = v4l2_ctrl.value;
// Try to query the valid range for |control_id|. Not supporting a range query
// is not a failure.
struct v4l2_queryctrl v4l2_range_query = {control_id};
if (HANDLE_EINTR(ioctl(fd, VIDIOC_QUERYCTRL, &v4l2_range_query))) {
*min_value = 0;
*max_value = 0;
} else {
*min_value = v4l2_range_query.minimum;
*max_value = v4l2_range_query.maximum;
}
return true;
}
void V4L2Webcam::GetPan(const GetPTZCompleteCallback& callback) {
int value = 0;
int min_value = 0;
int max_value = 0;
bool success = GetWebcamParameter(fd_.get(), V4L2_CID_PAN_ABSOLUTE, &value,
&min_value, &max_value);
callback.Run(success, value, min_value, max_value);
}
void V4L2Webcam::GetTilt(const GetPTZCompleteCallback& callback) {
int value = 0;
int min_value = 0;
int max_value = 0;
bool success = GetWebcamParameter(fd_.get(), V4L2_CID_TILT_ABSOLUTE, &value,
&min_value, &max_value);
callback.Run(success, value, min_value, max_value);
}
void V4L2Webcam::GetZoom(const GetPTZCompleteCallback& callback) {
int value = 0;
int min_value = 0;
int max_value = 0;
bool success = GetWebcamParameter(fd_.get(), V4L2_CID_ZOOM_ABSOLUTE, &value,
&min_value, &max_value);
callback.Run(success, value, min_value, max_value);
}
void V4L2Webcam::GetFocus(const GetPTZCompleteCallback& callback) {
int value = 0;
int min_value = 0;
int max_value = 0;
bool success = GetWebcamParameter(fd_.get(), V4L2_CID_FOCUS_ABSOLUTE, &value,
&min_value, &max_value);
callback.Run(success, value, min_value, max_value);
}
void V4L2Webcam::SetPan(int value,
int pan_speed,
const SetPTZCompleteCallback& callback) {
callback.Run(SetWebcamParameter(fd_.get(), V4L2_CID_PAN_ABSOLUTE, value));
}
void V4L2Webcam::SetTilt(int value,
int tilt_speed,
const SetPTZCompleteCallback& callback) {
callback.Run(SetWebcamParameter(fd_.get(), V4L2_CID_TILT_ABSOLUTE, value));
}
void V4L2Webcam::SetZoom(int value, const SetPTZCompleteCallback& callback) {
callback.Run(SetWebcamParameter(fd_.get(), V4L2_CID_ZOOM_ABSOLUTE, value));
}
void V4L2Webcam::SetFocus(int value, const SetPTZCompleteCallback& callback) {
callback.Run(SetWebcamParameter(fd_.get(), V4L2_CID_FOCUS_ABSOLUTE, value));
}
void V4L2Webcam::SetAutofocusState(AutofocusState state,
const SetPTZCompleteCallback& callback) {
const int value = (state == AUTOFOCUS_ON) ? 1 : 0;
callback.Run(SetWebcamParameter(fd_.get(), V4L2_CID_FOCUS_AUTO, value));
}
void V4L2Webcam::SetPanDirection(PanDirection direction,
int pan_speed,
const SetPTZCompleteCallback& callback) {
int direction_value = 0;
switch (direction) {
case PAN_STOP:
direction_value = 0;
break;
case PAN_RIGHT:
direction_value = 1;
break;
case PAN_LEFT:
direction_value = -1;
break;
}
callback.Run(
SetWebcamParameter(fd_.get(), V4L2_CID_PAN_SPEED, direction_value));
}
void V4L2Webcam::SetTiltDirection(TiltDirection direction,
int tilt_speed,
const SetPTZCompleteCallback& callback) {
int direction_value = 0;
switch (direction) {
case TILT_STOP:
direction_value = 0;
break;
case TILT_UP:
direction_value = 1;
break;
case TILT_DOWN:
direction_value = -1;
break;
}
callback.Run(
SetWebcamParameter(fd_.get(), V4L2_CID_TILT_SPEED, direction_value));
}
void V4L2Webcam::SetHome(const SetPTZCompleteCallback& callback) {
if (EnsureLogitechCommandsMapped()) {
if (!SetWebcamParameter(fd_.get(), V4L2_CID_PANTILT_CMD,
kLogitechMenuIndexSetHome)) {
LOG(WARNING) << "Failed to set HOME preset for Logitech webcam";
callback.Run(false);
return;
}
callback.Run(true);
return;
}
if (EnsureAverCommandsMapped()) {
if (!SetWebcamParameter(fd_.get(), V4L2_CID_PANTILT_CMD,
kAverMenuIndexSetHome)) {
LOG(WARNING) << "Failed to set HOME preset for AVer CAM webcam";
callback.Run(false);
return;
}
callback.Run(true);
return;
}
LOG(WARNING) << "Active webcam does not currently support seting HOME preset";
callback.Run(false);
}
int getLogitechPresetCmdMenuIndex(int preset_number, bool set_preset) {
// Preset must be within range [1, 8]
if (preset_number < 1 || preset_number > 8) {
LOG(WARNING) << "Preset number index for Logitech camera out of range.";
return -1;
}
int set_preset_index = preset_number * 2 + 1;
return set_preset ? set_preset_index : set_preset_index + 1;
}
int getAverPresetCmdMenuIndex(int preset_number, bool set_preset) {
// Preset must be within range [0, 9]
if (preset_number < 0 || preset_number > 9) {
LOG(WARNING) << "Preset number index for AVer camera out of range.";
return -1;
}
int set_preset_index = 2 * preset_number;
return set_preset ? set_preset_index : set_preset_index + 1;
}
void V4L2Webcam::RestoreCameraPreset(int preset_number,
const SetPTZCompleteCallback& callback) {
if (EnsureLogitechCommandsMapped()) {
int menu_index = getLogitechPresetCmdMenuIndex(preset_number, false);
if (menu_index < 0) {
callback.Run(false);
return;
}
if (!SetWebcamParameter(fd_.get(), V4L2_CID_PANTILT_CMD, menu_index)) {
LOG(WARNING) << "Failed to call preset " << preset_number
<< " for Logitech webcam";
callback.Run(false);
return;
}
callback.Run(true);
return;
} else if (EnsureAverCommandsMapped()) {
int menu_index = getAverPresetCmdMenuIndex(preset_number, false);
if (menu_index < 0) {
callback.Run(false);
return;
}
if (!SetWebcamParameter(fd_.get(), V4L2_CID_PANTILT_CMD, menu_index)) {
LOG(WARNING) << "Failed to call preset " << preset_number
<< " for AVer webcam";
callback.Run(false);
return;
}
callback.Run(true);
return;
}
LOG(WARNING)
<< "Active webcam does not currently support calling camera presets.";
callback.Run(false);
}
void V4L2Webcam::SetCameraPreset(int preset_number,
const SetPTZCompleteCallback& callback) {
if (EnsureLogitechCommandsMapped()) {
int menu_index = getLogitechPresetCmdMenuIndex(preset_number, true);
if (menu_index < 0) {
callback.Run(false);
return;
}
if (!SetWebcamParameter(fd_.get(), V4L2_CID_PANTILT_CMD, menu_index)) {
LOG(WARNING) << "Failed to set preset " << preset_number
<< " for Logitech webcam";
callback.Run(false);
return;
}
callback.Run(true);
return;
} else if (EnsureAverCommandsMapped()) {
int menu_index = getAverPresetCmdMenuIndex(preset_number, true);
if (menu_index < 0) {
callback.Run(false);
return;
}
if (!SetWebcamParameter(fd_.get(), V4L2_CID_PANTILT_CMD, menu_index)) {
LOG(WARNING) << "Failed to set preset " << preset_number
<< " for AVer webcam";
callback.Run(false);
return;
}
callback.Run(true);
return;
}
LOG(WARNING)
<< "Active webcam does not currently support setting camera presets.";
callback.Run(false);
}
void V4L2Webcam::Reset(bool pan,
bool tilt,
bool zoom,
const SetPTZCompleteCallback& callback) {
if (pan || tilt) {
if (EnsureLogitechCommandsMapped()) {
if (!SetWebcamParameter(fd_.get(), V4L2_CID_PANTILT_CMD,
kLogitechMenuIndexGoHome)) {
callback.Run(false);
return;
}
} else if (EnsureAverCommandsMapped()) {
if (!SetWebcamParameter(fd_.get(), V4L2_CID_PANTILT_CMD,
kAverMenuIndexGoHome)) {
callback.Run(false);
return;
}
} else {
if (pan) {
struct v4l2_control v4l2_ctrl = {V4L2_CID_PAN_RESET};
if (!HANDLE_EINTR(ioctl(fd_.get(), VIDIOC_S_CTRL, &v4l2_ctrl))) {
callback.Run(false);
return;
}
}
if (tilt) {
struct v4l2_control v4l2_ctrl = {V4L2_CID_TILT_RESET};
if (!HANDLE_EINTR(ioctl(fd_.get(), VIDIOC_S_CTRL, &v4l2_ctrl))) {
callback.Run(false);
return;
}
}
}
}
if (zoom) {
const int kDefaultZoom = 100;
if (!SetWebcamParameter(fd_.get(), V4L2_CID_ZOOM_ABSOLUTE, kDefaultZoom)) {
callback.Run(false);
return;
}
}
callback.Run(true);
}
} // namespace extensions
Codebase Browser
chromium