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)
+    : camera_info_updated_(base::WaitableEvent::ResetPolicy::MANUAL,
+                           base::WaitableEvent::InitialState::NOT_SIGNALED),
+      updating_camera_info_(false),
+      num_cameras_(0),
+      module_callbacks_registered_(false),
+      module_task_runner_(module_task_runner),
+      camera_module_callbacks_(this) {
+  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) {
+    LOG(ERROR) << "fcntl(F_GETFL) failed";
+    return false;
+  }
+  if (HANDLE_EINTR(fcntl(socket_handle.get().handle, F_SETFL,
+                         flags & ~O_NONBLOCK)) == -1) {
+    LOG(ERROR) << "fcntl(F_SETFL) failed";
+    return false;
+  }
+
+  char token[32] = {};
+  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) {
+    LOG(ERROR) << "PlatformChannelRecvmsg failed: " << strerror(errno);
+  }
+  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, 32));
+
+  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 (!UpdateCameraInfo()) {
+    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;
+    VLOG(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 (!UpdateCameraInfo()) {
+    return;
+  }
+  for (size_t camera_id = 0; camera_id < num_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;
+    }
+    device_descriptors->push_back(desc);
+  }
+}
+
+void CameraHalDelegate::GetCameraInfo(int32_t camera_id,
+                                      const GetCameraInfoCallback& callback) {
+  module_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&CameraHalDelegate::GetCameraInfoOnModuleThread,
+                            this, camera_id, callback));
+}
+
+void CameraHalDelegate::OpenDevice(int32_t camera_id,
+                                   const OpenDeviceCallback& callback) {
+  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::UpdateCameraInfo() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  if (camera_info_updated_.IsSignaled()) {
+    return true;
+  }
+  module_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&CameraHalDelegate::UpdateCameraInfoOnModuleThread, this));
+  if (!camera_info_updated_.TimedWait(kEventWaitTimeoutMs)) {
+    LOG(ERROR) << "Timed out getting camera info";
+    return false;
+  }
+  return true;
+}
+
+void CameraHalDelegate::UpdateCameraInfoOnModuleThread() {
+  DCHECK(module_task_runner_->BelongsToCurrentThread());
+  if (updating_camera_info_) {
+    return;
+  }
+  updating_camera_info_ = true;
+  // We clear all existing camera info here and ask again. In theory the camera
+  // info should remain unchanged for internal cameras, but for external cameras
+  // the info may change.
+  camera_info_.clear();
+  camera_module_->GetNumberOfCameras(
+      base::Bind(&CameraHalDelegate::OnGotNumberOfCamerasOnModuleThread, this));
+}
+
+void CameraHalDelegate::OnGotNumberOfCamerasOnModuleThread(
+    int32_t num_cameras) {
+  DCHECK(module_task_runner_->BelongsToCurrentThread());
+  num_cameras_ = num_cameras;
+  if (!module_callbacks_registered_) {
+    SetCallbacksOnModuleThread();
+  } else {
+    for (ssize_t camera_id = 0; camera_id < num_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());
+  DCHECK(!camera_info_updated_.IsSignaled());
+  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. Device id: " << camera_id;
+  }
+  // In case of failure |camera_info| is empty.
+  camera_info_[camera_id] = std::move(camera_info);
+  if (camera_info_.size() == num_cameras_) {
+    updating_camera_info_ = false;
+    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);
+}
+
+void CameraHalDelegate::SetCallbacksOnModuleThread() {
+  DCHECK(module_task_runner_->BelongsToCurrentThread());
+  camera_module_->SetCallbacks(
+      camera_module_callbacks_.CreateInterfacePtrAndBind(),
+      base::Bind(&CameraHalDelegate::OnSetCallbacksOnModuleThread, this));
+}
+
+void CameraHalDelegate::OnSetCallbacksOnModuleThread(int32_t result) {
+  if (result) {
+    LOG(ERROR) << "Failed to set camera module callbacks";
+    return;
+  }
+  module_callbacks_registered_ = true;
+  for (size_t camera_id = 0; camera_id < num_cameras_; ++camera_id) {
+    GetCameraInfoOnModuleThread(
+        camera_id, base::Bind(&CameraHalDelegate::OnGotCameraInfoOnModuleThread,
+                              this, camera_id));
+  }
+}
+
+// CameraModuleCallbacks implementations.
+void CameraHalDelegate::CameraDeviceStatusChange(
+    int32_t camera_id,
+    arc::mojom::CameraDeviceStatus new_status) {
+  DCHECK(module_task_runner_->BelongsToCurrentThread());
+  // Here we just reset |camera_info_updated_| instead of trigger an update of
+  // camera info. This is to make sure that changes to |num_cameras_| and
+  // |camera_info_| are only triggered by UpdateCameraInfo.
+  if (new_status ==
+      arc::mojom::CameraDeviceStatus::CAMERA_DEVICE_STATUS_NOT_PRESENT) {
+    if (camera_info_.find(camera_id) != camera_info_.end()) {
+      camera_info_updated_.Reset();
+    }
+  } else if (new_status ==
+             arc::mojom::CameraDeviceStatus::CAMERA_DEVICE_STATUS_PRESENT) {
+    if (camera_info_.find(camera_id) == camera_info_.end() ||
+        camera_info_[camera_id].is_null()) {
+      camera_info_updated_.Reset();
+    }
+  }
+}
+
+}  // namespace media