media: add video capture device for ARC++ camera HAL v3

media/capture/video/chromeos/camera_hal_delegate.cc

+// Copyright 2017 The Chromium 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 "media/capture/video/chromeos/camera_hal_delegate.h"
+
+#include <fcntl.h>
+#include <sys/uio.h>
+
+#include "base/bind.h"
+#include "base/bind_helpers.h"
+#include "base/strings/string_piece.h"
+#include "media/capture/video/chromeos/camera_metadata_utils.h"
+#include "media/capture/video/chromeos/video_capture_device_arc_chromeos.h"
+#include "mojo/edk/embedder/embedder.h"
+#include "mojo/edk/embedder/named_platform_handle.h"
+#include "mojo/edk/embedder/named_platform_handle_utils.h"
+#include "mojo/edk/embedder/pending_process_connection.h"
+#include "mojo/edk/embedder/platform_channel_pair.h"
+#include "mojo/edk/embedder/platform_channel_utils_posix.h"
+#include "mojo/edk/embedder/platform_handle_vector.h"
+
+namespace media {
+
+namespace {
+
+const base::StringPiece kArcCamera3SocketPath("/var/run/camera/camera3.sock");
+
+const base::TimeDelta kEventWaitTimeoutMs =
+    base::TimeDelta::FromMilliseconds(3000);
+
+}  // namespace
+
+CameraHalDelegate::CameraHalDelegate(
+    const scoped_refptr<base::SingleThreadTaskRunner> module_task_runner)
+    : builtin_camera_info_updated_(
+          base::WaitableEvent::ResetPolicy::MANUAL,
+          base::WaitableEvent::InitialState::NOT_SIGNALED),
+      num_builtin_cameras_(0),
+      module_task_runner_(module_task_runner),
+      camera_module_callbacks_(this) {
+  // We need to detach |thread_checker_| here because constructor is called on
+  // UI thread while the VideoCaptureDeviceFactory methods are called on capture
+  // thread.
+  thread_checker_.DetachFromThread();
+}
+
+CameraHalDelegate::~CameraHalDelegate() {
+  base::WaitableEvent interface_closed(
+      base::WaitableEvent::ResetPolicy::MANUAL,
+      base::WaitableEvent::InitialState::NOT_SIGNALED);
+  module_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&CameraHalDelegate::ResetMojoInterfaceOnModuleThread,
+                 base::Unretained(this), base::Unretained(&interface_closed)));
+  interface_closed.Wait();
+}
+
+bool CameraHalDelegate::StartCameraModuleIpc() {
+  // Non-blocking socket handle.
+  mojo::edk::ScopedPlatformHandle socket_handle = mojo::edk::CreateClientHandle(
+      mojo::edk::NamedPlatformHandle(kArcCamera3SocketPath));
+
+  // Set socket to blocking
+  int flags = HANDLE_EINTR(fcntl(socket_handle.get().handle, F_GETFL));
+  if (flags == -1) {
+    PLOG(ERROR) << "fcntl(F_GETFL) failed: ";
+    return false;
+  }
+  if (HANDLE_EINTR(fcntl(socket_handle.get().handle, F_SETFL,
+                         flags & ~O_NONBLOCK)) == -1) {
+    PLOG(ERROR) << "fcntl(F_SETFL) failed: ";
+    return false;
+  }
+
+  const size_t kTokenSize = 32;
+  char token[kTokenSize] = {};
+  std::deque<mojo::edk::PlatformHandle> platform_handles;
+  ssize_t ret = mojo::edk::PlatformChannelRecvmsg(
+      socket_handle.get(), token, sizeof(token), &platform_handles, true);
+  if (ret == -1) {
+    PLOG(ERROR) << "PlatformChannelRecvmsg failed: ";
+    return false;
+  }
+  if (platform_handles.size() != 1) {
+    LOG(ERROR) << "Unexpected number of handles received, expected 1: "
+               << platform_handles.size();
+    return false;
+  }
+  mojo::edk::ScopedPlatformHandle parent_pipe(platform_handles.back());
+  platform_handles.pop_back();
+  if (!parent_pipe.is_valid()) {
+    LOG(ERROR) << "Invalid parent pipe";
+    return false;
+  }
+  mojo::edk::SetParentPipeHandle(std::move(parent_pipe));
+
+  mojo::ScopedMessagePipeHandle child_pipe =
+      mojo::edk::CreateChildMessagePipe(std::string(token, kTokenSize));
+
+  camera_module_ =
+      mojo::MakeProxy(mojo::InterfacePtrInfo<arc::mojom::CameraModule>(
+                          std::move(child_pipe), 0u),
+                      module_task_runner_);
+
+  VLOG(1) << "Camera module IPC connection established";
+
+  return true;
+}
+
+std::unique_ptr<VideoCaptureDevice> CameraHalDelegate::CreateDevice(
+    const scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
+    const VideoCaptureDeviceDescriptor& device_descriptor) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  std::unique_ptr<VideoCaptureDevice> capture_device(
+      new VideoCaptureDeviceArcChromeOS(ui_task_runner, device_descriptor,
+                                        this));
+  return capture_device;
+}
+
+void CameraHalDelegate::GetSupportedFormats(
+    const VideoCaptureDeviceDescriptor& device_descriptor,
+    VideoCaptureFormats* supported_formats) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  if (!UpdateBuiltInCameraInfo()) {
+    return;
+  }
+  int camera_id = std::stoi(device_descriptor.device_id);
+  if (camera_info_.find(camera_id) == camera_info_.end() ||
+      camera_info_[camera_id].is_null()) {
+    // The camera may be removed already or is not ready yet.
+    VLOG(1) << "Invalid camera_id: " << camera_id;
+    return;
+  }
+  const arc::mojom::CameraInfoPtr& camera_info = camera_info_[camera_id];
+
+  const arc::mojom::CameraMetadataEntryPtr* fps_settings =
+      GetMetadataEntry(camera_info->static_camera_characteristics,
+                       arc::mojom::CameraMetadataTag::
+                           ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES);
+  if (!fps_settings) {
+    LOG(ERROR) << "Failed to get available target FPS ranges from camera info";
+    return;
+  }
+  // The available target FPS ranges are stored as pairs of two int32s:
+  // (min_fps, max_fps).
+  float max_fps = 0.0;
+  int32_t* iter = reinterpret_cast<int32_t*>((*fps_settings)->data.data());
+  // There may be multiple FPS ranges. We simply use the maximum FPS of all the
+  // FPS ranges here.
+  for (size_t i = 0; i < (*fps_settings)->count / sizeof(int32_t); ++i) {
+    float fps = static_cast<float>(*(iter + 1));
+    if (fps > max_fps) {
+      max_fps = fps;
+    }
+    iter += 2;
+  }
+
+  const arc::mojom::CameraMetadataEntryPtr* configurations =
+      GetMetadataEntry(camera_info->static_camera_characteristics,
+                       arc::mojom::CameraMetadataTag::
+                           ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS);
+  if (!configurations) {
+    LOG(ERROR)
+        << "Failed to get available stream configurations from camera info";
+    return;
+  }
+  // The available stream configurations are stored as tuples of four int32s:
+  // (hal_pixel_format, width, height, input_or_output_type).
+  iter = reinterpret_cast<int32_t*>((*configurations)->data.data());
+  for (size_t i = 0; i < (*configurations)->count / sizeof(int32_t); ++i) {
+    arc::mojom::HalPixelFormat format =
+        static_cast<arc::mojom::HalPixelFormat>(*iter);
+    int32_t width = *(iter + 1);
+    int32_t height = *(iter + 2);
+    int32_t type = *(iter + 3);
+    iter += 4;
+    DVLOG(1) << "[" << std::hex << format << " " << std::dec << width << " "
+             << height << " " << type << "]";
+    VideoPixelFormat cr_format =
+        VideoCaptureDeviceArcChromeOS::PixFormatHalToChromium(format);
+    if (cr_format == PIXEL_FORMAT_UNKNOWN) {
+      continue;
+    }
+    VLOG(1) << "Supported format: " << width << "x" << height
+            << " fps=" << max_fps << " format=" << cr_format;
+    supported_formats->emplace_back(gfx::Size(width, height), max_fps,
+                                    cr_format);
+  }
+}
+
+void CameraHalDelegate::GetDeviceDescriptors(
+    VideoCaptureDeviceDescriptors* device_descriptors) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  if (!UpdateBuiltInCameraInfo()) {
+    return;
+  }
+  for (size_t camera_id = 0; camera_id < num_builtin_cameras_; ++camera_id) {
+    VideoCaptureDeviceDescriptor desc;
+    arc::mojom::CameraInfoPtr& camera_info = camera_info_[camera_id];
+    if (!camera_info) {
+      continue;
+    }
+    desc.device_id = std::to_string(camera_id);
+    desc.capture_api = VideoCaptureApi::ANDROID_API2_LIMITED;
+    desc.transport_type = VideoCaptureTransportType::OTHER_TRANSPORT;
+    switch (camera_info->facing) {
+      case arc::mojom::CameraFacing::CAMERA_FACING_BACK:
+        desc.facing = VideoFacingMode::MEDIA_VIDEO_FACING_ENVIRONMENT;
+        desc.display_name = std::string("Back Camera");
+        break;
+      case arc::mojom::CameraFacing::CAMERA_FACING_FRONT:
+        desc.facing = VideoFacingMode::MEDIA_VIDEO_FACING_USER;
+        desc.display_name = std::string("Front Camera");
+        break;
+      case arc::mojom::CameraFacing::CAMERA_FACING_EXTERNAL:
+        desc.facing = VideoFacingMode::MEDIA_VIDEO_FACING_NONE;
+        desc.display_name = std::string("External Camera");
+        break;
+        // Mojo validates the input parameters for us so we don't need to worry
+        // about malformed values.
+    }
+    device_descriptors->push_back(desc);
+  }
+}
+
+void CameraHalDelegate::GetCameraInfo(int32_t camera_id,
+                                      const GetCameraInfoCallback& callback) {
+  // This method may be called on any thread.  Currently this method is used by
+  // VideoCaptureDeviceArcChromeOS to query camera info.
+  module_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&CameraHalDelegate::GetCameraInfoOnModuleThread,
+                            this, camera_id, callback));
+}
+
+void CameraHalDelegate::OpenDevice(int32_t camera_id,
+                                   const OpenDeviceCallback& callback) {
+  // This method may be called on any thread.  Currently this method is used by
+  // VideoCaptureDeviceArcChromeOS to open a camera device.
+  module_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&CameraHalDelegate::OpenDeviceOnModuleThread, this,
+                            camera_id, callback));
+}
+
+void CameraHalDelegate::ResetMojoInterfaceOnModuleThread(
+    base::WaitableEvent* interface_closed) {
+  DCHECK(module_task_runner_->BelongsToCurrentThread());
+  camera_module_.reset();
+  if (camera_module_callbacks_.is_bound()) {
+    camera_module_callbacks_.Unbind();
+  }
+  interface_closed->Signal();
+}
+
+bool CameraHalDelegate::UpdateBuiltInCameraInfo() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  if (builtin_camera_info_updated_.IsSignaled()) {
+    return true;
+  }
+  // The built-in camera are static per specification of the Android camera HAL
+  // v3 specification.  We only update the built-in camera info once.
+  module_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&CameraHalDelegate::UpdateBuiltInCameraInfoOnModuleThread,
+                 this));
+  if (!builtin_camera_info_updated_.TimedWait(kEventWaitTimeoutMs)) {
+    LOG(ERROR) << "Timed out getting camera info";
+    return false;
+  }
+  return true;
+}
+
+void CameraHalDelegate::UpdateBuiltInCameraInfoOnModuleThread() {
+  DCHECK(module_task_runner_->BelongsToCurrentThread());
+  camera_module_->GetNumberOfCameras(
+      base::Bind(&CameraHalDelegate::OnGotNumberOfCamerasOnModuleThread, this));
+}
+
+void CameraHalDelegate::OnGotNumberOfCamerasOnModuleThread(
+    int32_t num_cameras) {
+  DCHECK(module_task_runner_->BelongsToCurrentThread());
+  if (num_cameras < 0) {
+    builtin_camera_info_updated_.Signal();
+    LOG(ERROR) << "Failed to get number of cameras";
+    return;
+  }
+  VLOG(1) << "Number of built-in cameras: " << num_cameras;
+  num_builtin_cameras_ = num_cameras;
+  // Per camera HAL v3 specification SetCallbacks() should be called after the
+  // first time GetNumberOfCameras() is called, and before other CameraModule
+  // functions are called.
+  camera_module_->SetCallbacks(
+      camera_module_callbacks_.CreateInterfacePtrAndBind(),
+      base::Bind(&CameraHalDelegate::OnSetCallbacksOnModuleThread, this));
+}
+
+void CameraHalDelegate::OnSetCallbacksOnModuleThread(int32_t result) {
+  DCHECK(module_task_runner_->BelongsToCurrentThread());
+  if (result) {
+    num_builtin_cameras_ = 0;
+    builtin_camera_info_updated_.Signal();
+    LOG(ERROR) << "Failed to set camera module callbacks: " << strerror(result);
+    return;
+  }
+  for (size_t camera_id = 0; camera_id < num_builtin_cameras_; ++camera_id) {
+    GetCameraInfoOnModuleThread(
+        camera_id, base::Bind(&CameraHalDelegate::OnGotCameraInfoOnModuleThread,
+                              this, camera_id));
+  }
+}
+
+void CameraHalDelegate::GetCameraInfoOnModuleThread(
+    int32_t camera_id,
+    const GetCameraInfoCallback& callback) {
+  DCHECK(module_task_runner_->BelongsToCurrentThread());
+  camera_module_->GetCameraInfo(camera_id, callback);
+}
+
+void CameraHalDelegate::OnGotCameraInfoOnModuleThread(
+    int32_t camera_id,
+    int32_t result,
+    arc::mojom::CameraInfoPtr camera_info) {
+  DCHECK(module_task_runner_->BelongsToCurrentThread());
+  DVLOG(1) << "Got camera info of camera " << camera_id;
+  if (result) {
+    // The call to get_camera_info may fail if the device is still in the
+    // enumerating state or is no longer present.
+    VLOG(1) << "Failed to get camera info. Camera id: " << camera_id;
+  }
+  // In case of failure |camera_info| is empty.
+  camera_info_[camera_id] = std::move(camera_info);
+  if (!builtin_camera_info_updated_.IsSignaled()) {
+    // Make sure all the built-in camera info is set.  |camera_info_| may hold
+    // info of external cameras as well so we need to check each id of the
+    // built-in cameras here.
+    for (size_t id = 0; id < num_builtin_cameras_; ++id) {
+      if (camera_info_.find(id) == camera_info_.end()) {
+        return;
+      }
+    }
+    builtin_camera_info_updated_.Signal();
+  }
+}
+
+void CameraHalDelegate::OpenDeviceOnModuleThread(
+    int32_t camera_id,
+    const OpenDeviceCallback& callback) {
+  DCHECK(module_task_runner_->BelongsToCurrentThread());
+  camera_module_->OpenDevice(camera_id, callback);
+}
+
+// CameraModuleCallbacks implementations.
+void CameraHalDelegate::CameraDeviceStatusChange(
+    int32_t camera_id,
+    arc::mojom::CameraDeviceStatus new_status) {
+  DCHECK(module_task_runner_->BelongsToCurrentThread());
+  // TODO(jcliang): Handle status change for external cameras.
+}
+
+}  // namespace media