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

media/capture/video/chromeos/video_capture_device_arc_chromeos.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/video_capture_device_arc_chromeos.h"
+
+#include "base/threading/platform_thread.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 {
+
+// This is a delegate class used to transfer Display change events from the UI
+// thread to the media capture thread.
+class VideoCaptureDeviceArcChromeOS::ScreenObserverDelegate
+    : public display::DisplayObserver,
+      public base::RefCountedThreadSafe<ScreenObserverDelegate> {
+ public:
+  // It is safe to use the raw pointer |capture_device| because
+  // ~VideoCaptureDeviceArcChromeOS() calls RemoveObserver() and sets
+  // |capture_device_| to nullptr.
+  ScreenObserverDelegate(VideoCaptureDeviceArcChromeOS* capture_device,
+                         scoped_refptr<base::SingleThreadTaskRunner>
+                             task_runner_for_screen_observer)
+      : capture_device_(capture_device),
+        task_runner_(task_runner_for_screen_observer),
+        capture_task_runner_(base::ThreadTaskRunnerHandle::Get()) {
+    task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(&ScreenObserverDelegate::AddObserverOnUIThread, this));
+  }
+
+  void RemoveObserver() {
+    DCHECK(capture_task_runner_->BelongsToCurrentThread());
+    capture_device_ = nullptr;
+    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(task_runner_->BelongsToCurrentThread());
+    if (!(metrics & DISPLAY_METRIC_ROTATION))
+      return;
+    SendDisplayRotation(display);
+  }
+
+  void AddObserverOnUIThread() {
+    DCHECK(task_runner_->BelongsToCurrentThread());
+    display::Screen* screen = display::Screen::GetScreen();
+    if (screen) {
+      screen->AddObserver(this);
+      SendDisplayRotation(screen->GetPrimaryDisplay());
+    }
+  }
+
+  void RemoveObserverOnUIThread() {
+    DCHECK(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(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> task_runner_;
+  scoped_refptr<base::SingleThreadTaskRunner> capture_task_runner_;
+  DISALLOW_IMPLICIT_CONSTRUCTORS(ScreenObserverDelegate);
+};
+
+VideoCaptureDeviceArcChromeOS::VideoCaptureDeviceArcChromeOS(
+    scoped_refptr<base::SingleThreadTaskRunner> task_runner_for_screen_observer,
+    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(task_runner_for_screen_observer))),
+      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),
+      rotation_(0) {}
+
+VideoCaptureDeviceArcChromeOS::~VideoCaptureDeviceArcChromeOS() {
+  DCHECK(capture_task_runner_->BelongsToCurrentThread());
+  DCHECK(!device_thread_.IsRunning());
+  screen_observer_delegate_->RemoveObserver();
+}
+
+// VideoCaptureDevice implementation.
+void VideoCaptureDeviceArcChromeOS::AllocateAndStart(
+    const VideoCaptureParams& params,
+    std::unique_ptr<Client> client) {
+  DCHECK(capture_task_runner_->BelongsToCurrentThread());
+  DCHECK(!camera_device_delegate_);
+
+  if (!device_thread_.Start()) {
+    std::string error_msg = "Failed to start device thread";
+    LOG(ERROR) << error_msg;
+    client->OnError(FROM_HERE, error_msg);
+    return;
+  }
+  camera_device_delegate_ = new CameraDeviceDelegate(
+      device_descriptor_, camera_hal_delegate_, device_thread_.task_runner());
+  device_thread_.task_runner()->PostTask(
+      FROM_HERE,
+      base::Bind(&CameraDeviceDelegate::AllocateAndStart,
+                 camera_device_delegate_, params, base::Passed(&client)));
+  device_thread_.task_runner()->PostTask(
+      FROM_HERE, base::Bind(&CameraDeviceDelegate::SetRotation,
+                            camera_device_delegate_, rotation_));
+}
+
+void VideoCaptureDeviceArcChromeOS::StopAndDeAllocate() {
+  DCHECK(capture_task_runner_->BelongsToCurrentThread());
+
+  if (!camera_device_delegate_) {
+    return;
+  }
+  device_thread_.task_runner()->PostTask(
+      FROM_HERE, base::Bind(&CameraDeviceDelegate::StopAndDeAllocate,
+                            camera_device_delegate_));
+  // Wait until all other references to |camera_device_delegate_| are dropped to
+  // make sure all the IPC calls are done.
+  base::TimeTicks wait_until =
+      base::TimeTicks() + base::TimeDelta::FromSeconds(3);
+  while (!camera_device_delegate_->HasOneRef()) {
+    if (base::TimeTicks() >= wait_until) {
+      LOG(ERROR) << "Timed out waiting capture device to stop";
+      break;
+    }
+    base::PlatformThread::YieldCurrentThread();
+  }
+  device_thread_.Stop();
+  camera_device_delegate_ = nullptr;
+}
+
+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::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