blob: 302f12c2ff70b00ddce9c0c3f552727103ec61f8 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
|
// 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.
#ifndef MEDIA_CAPTURE_VIDEO_CHROMEOS_VIDEO_CAPTURE_DEVICE_CHROMEOS_DELEGATE_H_
#define MEDIA_CAPTURE_VIDEO_CHROMEOS_VIDEO_CAPTURE_DEVICE_CHROMEOS_DELEGATE_H_
#include <memory>
#include "base/containers/flat_map.h"
#include "base/memory/weak_ptr.h"
#include "base/task/single_thread_task_runner.h"
#include "base/threading/thread.h"
#include "media/capture/video/chromeos/camera_device_context.h"
#include "media/capture/video/chromeos/display_rotation_observer.h"
#include "media/capture/video/video_capture_device.h"
#include "media/capture/video/video_capture_device_descriptor.h"
#include "media/capture/video_capture_types.h"
namespace display {
class Display;
} // namespace display
namespace media {
class CameraHalDelegate;
class CameraDeviceDelegate;
// Implementation of delegate for ChromeOS with CrOS camera HALv3.
class CAPTURE_EXPORT VideoCaptureDeviceChromeOSDelegate final
: public DisplayRotationObserver {
public:
VideoCaptureDeviceChromeOSDelegate() = delete;
VideoCaptureDeviceChromeOSDelegate(
scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
const VideoCaptureDeviceDescriptor& device_descriptor,
CameraHalDelegate* camera_hal_delegate,
base::OnceClosure cleanup_callback);
VideoCaptureDeviceChromeOSDelegate(
const VideoCaptureDeviceChromeOSDelegate&) = delete;
VideoCaptureDeviceChromeOSDelegate& operator=(
const VideoCaptureDeviceChromeOSDelegate&) = delete;
~VideoCaptureDeviceChromeOSDelegate();
void Shutdown();
bool HasDeviceClient();
void AllocateAndStart(const VideoCaptureParams& params,
std::unique_ptr<VideoCaptureDevice::Client> client,
ClientType client_type);
void StopAndDeAllocate(ClientType client_type);
void TakePhoto(VideoCaptureDevice::TakePhotoCallback callback);
void GetPhotoState(VideoCaptureDevice::GetPhotoStateCallback callback);
void SetPhotoOptions(mojom::PhotoSettingsPtr settings,
VideoCaptureDevice::SetPhotoOptionsCallback callback);
private:
// Helper to interact with PowerManagerClient on DBus original thread.
class PowerManagerClientProxy;
void OpenDevice();
void ReconfigureStreams();
void CloseDevice(base::UnguessableToken unblock_suspend_token);
// DisplayRotationDelegate implementation.
void SetDisplayRotation(const display::Display& display) final;
void SetRotation(int rotation);
const VideoCaptureDeviceDescriptor device_descriptor_;
// A reference to the CameraHalDelegate instance in the VCD factory. This is
// used by AllocateAndStart to query camera info and create the camera device.
CameraHalDelegate* camera_hal_delegate_;
// A reference to the thread that all the VideoCaptureDevice interface methods
// are expected to be called on.
const scoped_refptr<base::SingleThreadTaskRunner> capture_task_runner_;
// The thread that all the Mojo operations of |camera_device_delegate_| take
// place. Started in AllocateAndStart and stopped in StopAndDeAllocate, where
// the access to the base::Thread methods are sequenced on
// |capture_task_runner_|.
base::Thread camera_device_ipc_thread_;
// Map client type to VideoCaptureParams.
base::flat_map<ClientType, VideoCaptureParams> capture_params_;
// |device_context_| is created and owned by
// VideoCaptureDeviceChromeOSDelegate and is only accessed by
// |camera_device_delegate_|.
std::unique_ptr<CameraDeviceContext> device_context_;
// Internal delegate doing the actual capture setting, buffer allocation and
// circulation with the camera HAL. Created in AllocateAndStart and deleted in
// StopAndDeAllocate on |capture_task_runner_|. All methods of
// |camera_device_delegate_| operate on |camera_device_ipc_thread_|.
std::unique_ptr<CameraDeviceDelegate> camera_device_delegate_;
scoped_refptr<ScreenObserverDelegate> screen_observer_delegate_;
const VideoFacingMode lens_facing_;
// Whether the incoming frames should rotate when the device rotates.
const bool rotates_with_device_;
int rotation_;
base::OnceClosure cleanup_callback_;
base::WaitableEvent device_closed_;
scoped_refptr<PowerManagerClientProxy> power_manager_client_proxy_;
base::WeakPtrFactory<VideoCaptureDeviceChromeOSDelegate> weak_ptr_factory_{
this};
};
} // namespace media
#endif // MEDIA_CAPTURE_VIDEO_CHROMEOS_VIDEO_CAPTURE_DEVICE_CHROMEOS_DELEGATE_H_
|
