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

media/capture/video/chromeos/video_capture_device_arc_chromeos.cc

Index: media/capture/video/chromeos/video_capture_device_arc_chromeos.cc
diff --git a/media/capture/video/chromeos/video_capture_device_arc_chromeos.cc b/media/capture/video/chromeos/video_capture_device_arc_chromeos.cc
new file mode 100644
index 0000000000000000000000000000000000000000..c7069a1db68abc6e77ad597c22270586c389d18b
--- /dev/null
+++ b/media/capture/video/chromeos/video_capture_device_arc_chromeos.cc
@@ -0,0 +1,296 @@
+// 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/video_capture_device_arc_chromeos.h"
+
+#include "media/capture/video/chromeos/camera_device_delegate.h"
+#include "media/capture/video/chromeos/camera_hal_delegate.h"
+#include "ui/display/display.h"
+#include "ui/display/display_observer.h"
+#include "ui/display/screen.h"
+
+namespace media {
+
+namespace {
+
+const base::TimeDelta kEventWaitTimeoutMs =
+    base::TimeDelta::FromMilliseconds(3000);
+
+}  // namespace
+
+// This is a delegate class used to transfer Display change events from the UI
+// thread to the media thread.
+class VideoCaptureDeviceArcChromeOS::ScreenObserverDelegate
+    : public display::DisplayObserver,
+      public base::RefCountedThreadSafe<ScreenObserverDelegate> {
+ public:
+  // It is safe to use the raw pointer |capture_device| as
+  // VideoCaptureDeviceArcChromeOS owns the ScreenObserverDelegate instance and
+  // we make sure the VideoCaptureDeviceArcChromeOS instance outlives the
+  // ScreenObserverDelegate instance.
+  ScreenObserverDelegate(
+      VideoCaptureDeviceArcChromeOS* capture_device,
+      scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner)
+      : capture_device_(capture_device),
+        ui_task_runner_(ui_task_runner),
+        capture_task_runner_(base::ThreadTaskRunnerHandle::Get()) {
+    ui_task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(&ScreenObserverDelegate::AddObserverOnUIThread, this));
+  }
+
+  void RemoveObserver() {
+    DCHECK(capture_task_runner_->BelongsToCurrentThread());
+    capture_device_ = nullptr;
+    ui_task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(&ScreenObserverDelegate::RemoveObserverOnUIThread, this));
+  }
+
+ private:
+  friend class base::RefCountedThreadSafe<ScreenObserverDelegate>;
+
+  ~ScreenObserverDelegate() override { DCHECK(!capture_device_); }
+
+  void OnDisplayAdded(const display::Display& /*new_display*/) override {}
+  void OnDisplayRemoved(const display::Display& /*old_display*/) override {}
+  void OnDisplayMetricsChanged(const display::Display& display,
+                               uint32_t metrics) override {
+    DCHECK(ui_task_runner_->BelongsToCurrentThread());
+    if (!(metrics & DISPLAY_METRIC_ROTATION))
+      return;
+    SendDisplayRotation(display);
+  }
+
+  void AddObserverOnUIThread() {
+    DCHECK(ui_task_runner_->BelongsToCurrentThread());
+    display::Screen* screen = display::Screen::GetScreen();
+    if (screen) {
+      screen->AddObserver(this);
+      SendDisplayRotation(screen->GetPrimaryDisplay());
+    }
+  }
+
+  void RemoveObserverOnUIThread() {
+    DCHECK(ui_task_runner_->BelongsToCurrentThread());
+    display::Screen* screen = display::Screen::GetScreen();
+    if (screen)
+      screen->RemoveObserver(this);
+  }
+
+  // Post the screen rotation change from the UI thread to capture thread
+  void SendDisplayRotation(const display::Display& display) {
+    DCHECK(ui_task_runner_->BelongsToCurrentThread());
+    capture_task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(&ScreenObserverDelegate::SendDisplayRotationOnCaptureThread,
+                   this, display));
+  }
+
+  void SendDisplayRotationOnCaptureThread(const display::Display& display) {
+    DCHECK(capture_task_runner_->BelongsToCurrentThread());
+    if (capture_device_)
+      capture_device_->SetDisplayRotation(display);
+  }
+
+  VideoCaptureDeviceArcChromeOS* capture_device_;
+  scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner_;
+  scoped_refptr<base::SingleThreadTaskRunner> capture_task_runner_;
+  DISALLOW_IMPLICIT_CONSTRUCTORS(ScreenObserverDelegate);
+};
+
+VideoCaptureDeviceArcChromeOS::VideoCaptureDeviceArcChromeOS(
+    scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
+    const VideoCaptureDeviceDescriptor& device_descriptor,
+    scoped_refptr<CameraHalDelegate> camera_hal_delegate)
+    : device_descriptor_(device_descriptor),
+      camera_hal_delegate_(camera_hal_delegate),
+      capture_task_runner_(base::ThreadTaskRunnerHandle::Get()),
+      device_thread_("CameraDeviceThread"),
+      screen_observer_delegate_(
+          new ScreenObserverDelegate(this, std::move(ui_task_runner))),
+      lens_facing_(device_descriptor.facing),
+      camera_orientation_(0),
+      // External cameras have lens_facing as MEDIA_VIDEO_FACING_NONE.
+      // We don't want to rotate the frame even if the device rotates.
+      rotates_with_device_(lens_facing_ !=
+                           VideoFacingMode::MEDIA_VIDEO_FACING_NONE) {}
+
+VideoCaptureDeviceArcChromeOS::~VideoCaptureDeviceArcChromeOS() {
+  DCHECK(capture_task_runner_->BelongsToCurrentThread());
+  DCHECK(!device_thread_.IsRunning());
+  screen_observer_delegate_->RemoveObserver();
+}
+
+// static
+VideoPixelFormat VideoCaptureDeviceArcChromeOS::PixFormatHalToChromium(
+    arc::mojom::HalPixelFormat from) {
+  return CameraDeviceDelegate::PixFormatHalToChromium(from);
+}
+
+// static
+uint32_t VideoCaptureDeviceArcChromeOS::PixFormatChromiumToDrm(
+    VideoPixelFormat from) {
+  return CameraDeviceDelegate::PixFormatChromiumToDrm(from);
+}
+
+// VideoCaptureDevice implementation.
+void VideoCaptureDeviceArcChromeOS::AllocateAndStart(
+    const VideoCaptureParams& params,
+    std::unique_ptr<Client> client) {
+  DCHECK(capture_task_runner_->BelongsToCurrentThread());
+  DCHECK(!camera_device_delegate_);
+  base::WaitableEvent started(base::WaitableEvent::ResetPolicy::MANUAL,
+                              base::WaitableEvent::InitialState::NOT_SIGNALED);
+  int32_t camera_id = std::stoi(device_descriptor_.device_id);
+  device_thread_.Start();
+  // We need to get the static camera metadata of the camera deivce first.
+  camera_hal_delegate_->GetCameraInfo(
+      camera_id, base::Bind(&VideoCaptureDeviceArcChromeOS::OnGotCameraInfo,
+                            base::Unretained(this), params,
+                            base::Passed(&client), base::Unretained(&started)));
+  started.TimedWait(kEventWaitTimeoutMs);
+}
+
+void VideoCaptureDeviceArcChromeOS::StopAndDeAllocate() {
+  DCHECK(capture_task_runner_->BelongsToCurrentThread());
+  if (camera_device_delegate_) {
+    base::WaitableEvent closed(base::WaitableEvent::ResetPolicy::MANUAL,
+                               base::WaitableEvent::InitialState::NOT_SIGNALED);
+    device_thread_.task_runner()->PostTask(
+        FROM_HERE,
+        base::Bind(&CameraDeviceDelegate::StopAndDeAllocate,
+                   camera_device_delegate_, base::Unretained(&closed)));
+    closed.TimedWait(kEventWaitTimeoutMs);
+    camera_device_delegate_ = nullptr;
+  }
+  device_thread_.Stop();
+}
+
+void VideoCaptureDeviceArcChromeOS::TakePhoto(TakePhotoCallback callback) {
+  DCHECK(capture_task_runner_->BelongsToCurrentThread());
+  DCHECK(camera_device_delegate_);
+  device_thread_.task_runner()->PostTask(
+      FROM_HERE, base::Bind(&CameraDeviceDelegate::TakePhoto,
+                            camera_device_delegate_, base::Passed(&callback)));
+}
+
+void VideoCaptureDeviceArcChromeOS::GetPhotoCapabilities(
+    GetPhotoCapabilitiesCallback callback) {
+  DCHECK(capture_task_runner_->BelongsToCurrentThread());
+  device_thread_.task_runner()->PostTask(
+      FROM_HERE, base::Bind(&CameraDeviceDelegate::GetPhotoCapabilities,
+                            camera_device_delegate_, base::Passed(&callback)));
+}
+
+void VideoCaptureDeviceArcChromeOS::SetPhotoOptions(
+    mojom::PhotoSettingsPtr settings,
+    SetPhotoOptionsCallback callback) {
+  DCHECK(capture_task_runner_->BelongsToCurrentThread());
+  device_thread_.task_runner()->PostTask(
+      FROM_HERE, base::Bind(&CameraDeviceDelegate::SetPhotoOptions,
+                            camera_device_delegate_, base::Passed(&settings),
+                            base::Passed(&callback)));
+}
+
+void VideoCaptureDeviceArcChromeOS::OnGotCameraInfo(
+    const VideoCaptureParams& params,
+    std::unique_ptr<Client> client,
+    base::WaitableEvent* started,
+    int32_t result,
+    arc::mojom::CameraInfoPtr camera_info) {
+  // This method runs on |module_task_runner_| of |camera_hal_delegate_|.
+  if (result) {
+    client->OnError(FROM_HERE, "Failed to get camera info");
+    return;
+  }
+  int32_t camera_id = std::stoi(device_descriptor_.device_id);
+  camera_hal_delegate_->OpenDevice(
+      camera_id,
+      base::Bind(&VideoCaptureDeviceArcChromeOS::OnOpenedDevice,
+                 base::Unretained(this), params, base::Passed(&client),
+                 base::Unretained(started),
+                 base::Passed(&camera_info->static_camera_characteristics)));
+}
+
+void VideoCaptureDeviceArcChromeOS::OnOpenedDevice(
+    const VideoCaptureParams& params,
+    std::unique_ptr<Client> client,
+    base::WaitableEvent* started,
+    arc::mojom::CameraMetadataPtr static_metadata,
+    int32_t result,
+    arc::mojom::Camera3DeviceOpsPtr device_ops) {
+  // This method runs on |module_task_runner_| of |camera_hal_delegate_|.
+  if (result) {
+    client->OnError(FROM_HERE, "Failed to open camera device");
+    return;
+  }
+  mojo::InterfacePtrInfo<arc::mojom::Camera3DeviceOps> device_ops_info =
+      device_ops.PassInterface();
+  camera_device_delegate_ = new CameraDeviceDelegate(
+      device_descriptor_, std::move(static_metadata),
+      std::move(device_ops_info), device_thread_.task_runner());
+  device_thread_.task_runner()->PostTask(
+      FROM_HERE,
+      base::Bind(&CameraDeviceDelegate::AllocateAndStart,
+                 camera_device_delegate_, params, base::Passed(&client)));
+  started->Signal();
+}
+
+void VideoCaptureDeviceArcChromeOS::SetRotation(int rotation) {
+  DCHECK(capture_task_runner_->BelongsToCurrentThread());
+  if (!rotates_with_device_) {
+    rotation = 0;
+  } else if (lens_facing_ == VideoFacingMode::MEDIA_VIDEO_FACING_ENVIRONMENT) {
+    // Original frame when |rotation| = 0
+    // -----------------------
+    // |          *          |
+    // |         * *         |
+    // |        *   *        |
+    // |       *******       |
+    // |      *       *      |
+    // |     *         *     |
+    // -----------------------
+    //
+    // |rotation| = 90, this is what back camera sees
+    // -----------------------
+    // |    ********         |
+    // |       *   ****      |
+    // |       *      ***    |
+    // |       *      ***    |
+    // |       *   ****      |
+    // |    ********         |
+    // -----------------------
+    //
+    // |rotation| = 90, this is what front camera sees
+    // -----------------------
+    // |         ********    |
+    // |      ****   *       |
+    // |    ***      *       |
+    // |    ***      *       |
+    // |      ****   *       |
+    // |         ********    |
+    // -----------------------
+    //
+    // Therefore, for back camera, we need to rotate (360 - |rotation|).
+    rotation = (360 - rotation) % 360;
+  }
+  // Take into account camera orientation w.r.t. the display. External cameras
+  // would have camera_orientation_ as 0.
+  rotation = (rotation + camera_orientation_) % 360;
+  if (device_thread_.IsRunning()) {
+    device_thread_.task_runner()->PostTask(
+        FROM_HERE, base::Bind(&CameraDeviceDelegate::SetRotation,
+                              camera_device_delegate_, rotation));
+  }
+}
+
+void VideoCaptureDeviceArcChromeOS::SetDisplayRotation(
+    const display::Display& display) {
+  DCHECK(capture_task_runner_->BelongsToCurrentThread());
+  if (display.IsInternal())
+    SetRotation(display.rotation() * 90);
+}
+
+}  // namespace media