extensions/browser/api/webcam_private/webcam_private_api_chromeos.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "extensions/browser/api/webcam_private/webcam_private_api.h"
   6
   7 #include <fcntl.h>
   8 #include <linux/uvcvideo.h>
   9 #include <linux/videodev2.h>
  10 #include <stdio.h>
  11 #include <sys/ioctl.h>
  12 #include <unistd.h>
  13
  14 #include "base/files/scoped_file.h"
  15 #include "base/posix/eintr_wrapper.h"
  16 #include "content/public/browser/browser_context.h"
  17 #include "content/public/browser/media_device_id.h"
  18 #include "content/public/browser/resource_context.h"
  19 #include "content/public/common/media_stream_request.h"
  20 #include "extensions/common/api/webcam_private.h"
  21
  22 #define V4L2_CID_PAN_SPEED (V4L2_CID_CAMERA_CLASS_BASE+32)
  23 #define V4L2_CID_TILT_SPEED (V4L2_CID_CAMERA_CLASS_BASE+33)
  24 #define V4L2_CID_PANTILT_CMD (V4L2_CID_CAMERA_CLASS_BASE+34)
  25
  26 // GUID of the Extension Unit for Logitech CC3300e motor control:
  27 // {212de5ff-3080-2c4e-82d9-f587d00540bd}
  28 #define UVC_GUID_LOGITECH_CC3000E_MOTORS          \
  29  {0x21, 0x2d, 0xe5, 0xff, 0x30, 0x80, 0x2c, 0x4e, \
  30   0x82, 0xd9, 0xf5, 0x87, 0xd0, 0x05, 0x40, 0xbd}
  31
  32 #define LOGITECH_MOTORCONTROL_PANTILT_CMD 2
  33
  34 namespace webcam_private = extensions::core_api::webcam_private;
  35
  36 namespace content {
  37 class BrowserContext;
  38 }  // namespace content
  39
  40 namespace {
  41 const int kLogitechMenuIndexGoHome = 2;
  42
  43 const uvc_menu_info kLogitechCmdMenu[] = {
  44   {1, "Set Preset"}, {2, "Get Preset"}, {3, "Go Home"}
  45 };
  46
  47 const uvc_xu_control_mapping kLogitechCmdMapping = {
  48   V4L2_CID_PANTILT_CMD,
  49   "Pan/Tilt Go",
  50   UVC_GUID_LOGITECH_CC3000E_MOTORS,
  51   LOGITECH_MOTORCONTROL_PANTILT_CMD,
  52   8,
  53   0,
  54   V4L2_CTRL_TYPE_MENU,
  55   UVC_CTRL_DATA_TYPE_ENUM,
  56   const_cast<uvc_menu_info*>(&kLogitechCmdMenu[0]),
  57   arraysize(kLogitechCmdMenu),
  58 };
  59
  60 base::ScopedFD OpenWebcam(const std::string& extension_id,
  61                           content::BrowserContext* browser_context,
  62                           const std::string& webcam_id) {
  63   GURL security_origin =
  64       extensions::Extension::GetBaseURLFromExtensionId(extension_id);
  65
  66   std::string device_id;
  67   bool success = content::GetMediaDeviceIDForHMAC(
  68       content::MEDIA_DEVICE_VIDEO_CAPTURE,
  69       browser_context->GetResourceContext()->GetMediaDeviceIDSalt(),
  70       security_origin,
  71       webcam_id,
  72       &device_id);
  73
  74   if (!success)
  75     return base::ScopedFD();
  76
  77   return base::ScopedFD(HANDLE_EINTR(open(device_id.c_str(), 0)));
  78 }
  79
  80 void SetWebcamParameter(int fd, uint32_t control_id, int value) {
  81   struct v4l2_control v4l2_ctrl = {control_id, value};
  82   HANDLE_EINTR(ioctl(fd, VIDIOC_S_CTRL, &v4l2_ctrl));
  83 }
  84
  85 bool GetWebcamParameter(int fd, uint32_t control_id, int* value) {
  86   struct v4l2_control v4l2_ctrl = {control_id};
  87
  88   if (HANDLE_EINTR(ioctl(fd, VIDIOC_G_CTRL, &v4l2_ctrl)))
  89     return false;
  90
  91   *value = v4l2_ctrl.value;
  92   return true;
  93 }
  94
  95 bool EnsureLogitechCommandsMapped(int fd) {
  96   int res = ioctl(fd, UVCIOC_CTRL_MAP, &kLogitechCmdMapping);
  97   // If mapping is successful or it's already mapped, this is a Logitech camera.
  98   return res >= 0 || errno == EEXIST;
  99 }
 100
 101 const char kUnknownWebcam[] = "Unknown webcam id";
 102 }  // namespace
 103
 104 namespace extensions {
 105
 106 WebcamPrivateSetFunction::WebcamPrivateSetFunction() {
 107 }
 108
 109 WebcamPrivateSetFunction::~WebcamPrivateSetFunction() {
 110 }
 111
 112 bool WebcamPrivateSetFunction::RunSync() {
 113   // Get parameters
 114   scoped_ptr<webcam_private::Set::Params> params(
 115       webcam_private::Set::Params::Create(*args_));
 116   EXTENSION_FUNCTION_VALIDATE(params.get());
 117
 118   base::ScopedFD fd =
 119       OpenWebcam(extension_id(), browser_context(), params->webcam_id);
 120   if (!fd.is_valid()) {
 121     SetError(kUnknownWebcam);
 122     return false;
 123   }
 124
 125   if (params->config.pan) {
 126     SetWebcamParameter(fd.get(), V4L2_CID_PAN_ABSOLUTE,
 127                        *(params->config.pan));
 128   }
 129
 130   if (params->config.pan_direction) {
 131     int direction = 0;
 132     switch (params->config.pan_direction) {
 133       case webcam_private::PAN_DIRECTION_NONE:
 134       case webcam_private::PAN_DIRECTION_STOP:
 135         direction = 0;
 136         break;
 137
 138       case webcam_private::PAN_DIRECTION_RIGHT:
 139         direction = 1;
 140         break;
 141
 142       case webcam_private::PAN_DIRECTION_LEFT:
 143         direction = -1;
 144         break;
 145     }
 146     SetWebcamParameter(fd.get(), V4L2_CID_PAN_SPEED, direction);
 147   }
 148
 149   if (params->config.tilt) {
 150     SetWebcamParameter(fd.get(), V4L2_CID_TILT_ABSOLUTE,
 151                        *(params->config.tilt));
 152   }
 153
 154   if (params->config.tilt_direction) {
 155     int direction = 0;
 156     switch (params->config.tilt_direction) {
 157       case webcam_private::TILT_DIRECTION_NONE:
 158       case webcam_private::TILT_DIRECTION_STOP:
 159         direction = 0;
 160         break;
 161
 162       case webcam_private::TILT_DIRECTION_UP:
 163         direction = 1;
 164         break;
 165
 166       case webcam_private::TILT_DIRECTION_DOWN:
 167         direction = -1;
 168         break;
 169     }
 170     SetWebcamParameter(fd.get(), V4L2_CID_TILT_SPEED, direction);
 171   }
 172
 173   if (params->config.zoom) {
 174     SetWebcamParameter(fd.get(), V4L2_CID_ZOOM_ABSOLUTE,
 175                        *(params->config.zoom));
 176   }
 177
 178
 179   return true;
 180 }
 181
 182 WebcamPrivateGetFunction::WebcamPrivateGetFunction() {
 183 }
 184
 185 WebcamPrivateGetFunction::~WebcamPrivateGetFunction() {
 186 }
 187
 188 bool WebcamPrivateGetFunction::RunSync() {
 189   // Get parameters
 190   scoped_ptr<webcam_private::Get::Params> params(
 191       webcam_private::Get::Params::Create(*args_));
 192   EXTENSION_FUNCTION_VALIDATE(params.get());
 193
 194   base::ScopedFD fd =
 195       OpenWebcam(extension_id(), browser_context(), params->webcam_id);
 196   if (!fd.is_valid()) {
 197     SetError(kUnknownWebcam);
 198     return false;
 199   }
 200
 201   webcam_private::WebcamConfiguration result;
 202
 203   int pan;
 204   if (GetWebcamParameter(fd.get(), V4L2_CID_PAN_ABSOLUTE, &pan))
 205     result.pan.reset(new double(pan));
 206
 207   int tilt;
 208   if (GetWebcamParameter(fd.get(), V4L2_CID_TILT_ABSOLUTE, &tilt))
 209     result.tilt.reset(new double(tilt));
 210
 211   int zoom;
 212   if (GetWebcamParameter(fd.get(), V4L2_CID_ZOOM_ABSOLUTE, &zoom))
 213     result.zoom.reset(new double(zoom));
 214
 215   SetResult(result.ToValue().release());
 216
 217   return true;
 218 }
 219
 220 WebcamPrivateResetFunction::WebcamPrivateResetFunction() {
 221 }
 222
 223 WebcamPrivateResetFunction::~WebcamPrivateResetFunction() {
 224 }
 225
 226 bool WebcamPrivateResetFunction::RunSync() {
 227   // Get parameters
 228   scoped_ptr<webcam_private::Reset::Params> params(
 229       webcam_private::Reset::Params::Create(*args_));
 230   EXTENSION_FUNCTION_VALIDATE(params.get());
 231
 232   base::ScopedFD fd =
 233       OpenWebcam(extension_id(), browser_context(), params->webcam_id);
 234   if (!fd.is_valid()) {
 235     SetError(kUnknownWebcam);
 236     return false;
 237   }
 238
 239   if (params->config.pan || params->config.tilt) {
 240     if (EnsureLogitechCommandsMapped(fd.get())) {
 241       SetWebcamParameter(fd.get(), V4L2_CID_PANTILT_CMD,
 242                          kLogitechMenuIndexGoHome);
 243     }
 244   }
 245
 246   if (params->config.pan) {
 247     struct v4l2_control v4l2_ctrl = {V4L2_CID_PAN_RESET};
 248     HANDLE_EINTR(ioctl(fd.get(), VIDIOC_S_CTRL, &v4l2_ctrl));
 249   }
 250
 251   if (params->config.tilt) {
 252     struct v4l2_control v4l2_ctrl = {V4L2_CID_TILT_RESET};
 253     HANDLE_EINTR(ioctl(fd.get(), VIDIOC_S_CTRL, &v4l2_ctrl));
 254   }
 255
 256   if (params->config.zoom) {
 257     const int kDefaultZoom = 100;
 258     SetWebcamParameter(fd.get(), V4L2_CID_ZOOM_ABSOLUTE, kDefaultZoom);
 259   }
 260
 261   return true;
 262 }
 263
 264 }  // namespace extensions