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 <algorithm>
+#include <utility>
+
+#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/pixel_format_utils.h"
+#include "media/capture/video/chromeos/video_capture_device_arc_chromeos.h"
+#include "mojo/edk/embedder/embedder.h"
+#include "mojo/edk/embedder/incoming_broker_client_invitation.h"
+#include "mojo/edk/embedder/named_platform_handle.h"
+#include "mojo/edk/embedder/named_platform_handle_utils.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),

[chfremer, 2017/05/26 17:40:57]

For passing scoped_refptr<>, I believe it is now recommended to pass by value
and then use std::move() if no copy is needed.

[jcliang, 2017/05/31 14:58:06]

Done.

+      camera_module_callbacks_(this) {
+  DETACH_FROM_SEQUENCE(sequence_checker_);
+}
+
+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;
+  }
+  std::unique_ptr<mojo::edk::IncomingBrokerClientInvitation> invitation =
+      mojo::edk::IncomingBrokerClientInvitation::Accept(
+          mojo::edk::ConnectionParams(mojo::edk::TransportProtocol::kLegacy,
+                                      std::move(parent_pipe)));
+  mojo::ScopedMessagePipeHandle child_pipe =
+      invitation->ExtractMessagePipe(token);
+  DCHECK(child_pipe.is_valid());
+
+  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;
+}

[chfremer, 2017/05/26 17:40:57]

The contents of the above method look reasonable, but I am not familiar with the
APIs for establishing Mojo connections. I recommend asking rockot@ or yzshen@ to
help review this part.

[jcliang, 2017/05/31 14:58:06]

I believe this is the common flow to establish a legacy Mojo channel through
unix domain socket to another process on Chrome OS or inside Android container.
An example of merged codes in Chrome:
https://cs.chromium.org/chromium/src/components/arc/arc_session.cc?q=arc_sess...

[yzshen1, 2017/06/02 15:15:22]

+rockot who knows this the best.

+
+std::unique_ptr<VideoCaptureDevice> CameraHalDelegate::CreateDevice(
+    const scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
+    const VideoCaptureDeviceDescriptor& device_descriptor) {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+  std::unique_ptr<VideoCaptureDevice> capture_device;
+  if (!UpdateBuiltInCameraInfo()) {
+    return capture_device;
+  }
+  if (camera_info_.find(device_descriptor.device_id) == camera_info_.end()) {
+    LOG(ERROR) << "Invalid camera device: " << device_descriptor.device_id;
+    return capture_device;
+  }
+  capture_device.reset(new VideoCaptureDeviceArcChromeOS(
+      ui_task_runner, device_descriptor, this));
+  return capture_device;
+}
+
+void CameraHalDelegate::GetSupportedFormats(
+    const VideoCaptureDeviceDescriptor& device_descriptor,
+    VideoCaptureFormats* supported_formats) {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+
+  if (!UpdateBuiltInCameraInfo()) {
+    return;
+  }
+  std::string camera_id = device_descriptor.device_id;
+  if (camera_info_.find(camera_id) == camera_info_.end() ||
+      camera_info_[camera_id].is_null()) {
+    LOG(ERROR) << "Invalid camera_id: " << camera_id;
+    return;
+  }
+  const arc::mojom::CameraInfoPtr& camera_info = camera_info_[camera_id];
+
+  // FIXME(jcliang): Remove this after the camera HAL has set the min frame
+  //                 durations for all formats.
+  supported_formats->emplace_back(gfx::Size(1280, 720), 60.0,
+                                  PIXEL_FORMAT_NV12);
+
+  const arc::mojom::CameraMetadataEntryPtr* min_frame_durations =
+      GetMetadataEntry(camera_info->static_camera_characteristics,
+                       arc::mojom::CameraMetadataTag::
+                           ANDROID_SCALER_AVAILABLE_MIN_FRAME_DURATIONS);
+  if (!min_frame_durations) {
+    LOG(ERROR)
+        << "Failed to get available min frame durations from camera info";
+    return;
+  }
+  // The min frame durations are stored as tuples of four int64s:
+  // (hal_pixel_format, width, height, ns) x n
+  const size_t kStreamFormatOffset = 0;
+  const size_t kStreamWidthOffset = 1;
+  const size_t kStreamHeightOffset = 2;
+  const size_t kStreamDurationOffset = 3;
+  const size_t kStreamDurationSize = 4;
+  int64_t* iter =
+      reinterpret_cast<int64_t*>((*min_frame_durations)->data.data());
+  for (size_t i = 0; i < (*min_frame_durations)->count / sizeof(int64_t); ++i) {
+    int32_t format = static_cast<int32_t>(iter[kStreamFormatOffset]);
+    int32_t width = static_cast<int32_t>(iter[kStreamWidthOffset]);
+    int32_t height = static_cast<int32_t>(iter[kStreamHeightOffset]);
+    int64_t duration = iter[kStreamDurationOffset];
+    iter += kStreamDurationSize;
+
+    float max_fps = 1.0 * 1000000000LL / duration;
+
+    DVLOG(1) << "[" << std::hex << format << " " << std::dec << width << " "
+             << height << " " << duration << "]";
+    VideoPixelFormat cr_format =
+        PixFormatHalToChromium(static_cast<arc::mojom::HalPixelFormat>(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_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+
+  if (!UpdateBuiltInCameraInfo()) {
+    return;
+  }
+  for (size_t id = 0; id < num_builtin_cameras_; ++id) {
+    VideoCaptureDeviceDescriptor desc;
+    std::string camera_id = std::to_string(id);
+    const arc::mojom::CameraInfoPtr& camera_info = camera_info_[camera_id];
+    if (!camera_info) {
+      continue;
+    }
+    desc.device_id = 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);
+  }
+  // TODO(jcliang): Remove this after JS API supports query camera facing
+  // (http://crbug.com/543997).
+  std::sort(device_descriptors->begin(), device_descriptors->end());
+}
+
+void CameraHalDelegate::GetCameraInfo(int32_t camera_id,
+                                      const GetCameraInfoCallback& callback) {
+  // This method may be called on any thread.  Currently this method is used by
+  // CameraDeviceDelegate 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
+  // CameraDeviceDelegate to open a camera device.
+  module_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&CameraHalDelegate::OpenDeviceOnModuleThread, this,
+                            camera_id, callback));
+}
+
+void CameraHalDelegate::StartForTesting(arc::mojom::CameraModulePtrInfo info) {
+  camera_module_.Bind(std::move(info), module_task_runner_);
+}
+
+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_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+  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) {
+    LOG(ERROR) << "Failed to get camera info. Camera id: " << camera_id;
+  }
+  // In case of error |camera_info| is empty.
+  camera_info_[std::to_string(camera_id)] = std::move(camera_info);
+  if (camera_info_.size() == num_builtin_cameras_) {
+    builtin_camera_info_updated_.Signal();
+  }
+  if (!builtin_camera_info_updated_.IsSignaled()) {
+    // Make sure all the built-in camera info is set.
+    for (size_t id = 0; id < num_builtin_cameras_; ++id) {
+      if (camera_info_.find(std::to_string(id)) == camera_info_.end()) {
+        return;
+      }
+    }
+  }
+}
+
+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