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
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
|
// 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_CAMERA_DEVICE_DELEGATE_H_
#define MEDIA_CAPTURE_VIDEO_CHROMEOS_CAMERA_DEVICE_DELEGATE_H_
#include <memory>
#include "base/macros.h"
#include "base/memory/weak_ptr.h"
#include "media/capture/video/chromeos/mojo/camera3.mojom.h"
#include "media/capture/video/chromeos/mojo/camera_common.mojom.h"
#include "media/capture/video/video_capture_device.h"
#include "media/capture/video_capture_types.h"
namespace media {
class CameraHalDelegate;
class CameraDeviceContext;
class StreamBufferManager;
// The interface to register buffer with and send capture request to the
// camera HAL.
class CAPTURE_EXPORT StreamCaptureInterface {
public:
struct Plane {
Plane();
~Plane();
mojo::ScopedHandle fd;
uint32_t stride;
uint32_t offset;
};
virtual ~StreamCaptureInterface() {}
// Registers a buffer to the camera HAL.
virtual void RegisterBuffer(uint64_t buffer_id,
arc::mojom::Camera3DeviceOps::BufferType type,
uint32_t drm_format,
arc::mojom::HalPixelFormat hal_pixel_format,
uint32_t width,
uint32_t height,
std::vector<Plane> planes,
base::OnceCallback<void(int32_t)> callback) = 0;
// Sends a capture request to the camera HAL.
virtual void ProcessCaptureRequest(
arc::mojom::Camera3CaptureRequestPtr request,
base::OnceCallback<void(int32_t)> callback) = 0;
};
// CameraDeviceDelegate is instantiated on the capture thread where
// AllocateAndStart of VideoCaptureDeviceArcChromeOS runs on. All the methods
// in CameraDeviceDelegate run on |ipc_task_runner_| and hence all the
// access to member variables is sequenced.
class CAPTURE_EXPORT CameraDeviceDelegate final {
public:
CameraDeviceDelegate(
VideoCaptureDeviceDescriptor device_descriptor,
scoped_refptr<CameraHalDelegate> camera_hal_delegate,
scoped_refptr<base::SingleThreadTaskRunner> ipc_task_runner);
~CameraDeviceDelegate();
// Delegation methods for the VideoCaptureDevice interface.
void AllocateAndStart(const VideoCaptureParams& params,
CameraDeviceContext* device_context);
void StopAndDeAllocate(base::OnceClosure device_close_callback);
void TakePhoto(VideoCaptureDevice::TakePhotoCallback callback);
void GetPhotoState(VideoCaptureDevice::GetPhotoStateCallback callback);
void SetPhotoOptions(mojom::PhotoSettingsPtr settings,
VideoCaptureDevice::SetPhotoOptionsCallback callback);
// Sets the frame rotation angle in |rotation_|. |rotation_| is clockwise
// rotation in degrees, and is passed to |client_| along with the captured
// frames.
void SetRotation(int rotation);
base::WeakPtr<CameraDeviceDelegate> GetWeakPtr();
private:
class StreamCaptureInterfaceImpl;
friend class CameraDeviceDelegateTest;
// Mojo connection error handler.
void OnMojoConnectionError();
// Callback method for the Close Mojo IPC call. This method resets the Mojo
// connection and closes the camera device.
void OnClosed(int32_t result);
// Resets the Mojo interface and bindings.
void ResetMojoInterface();
// Sets |static_metadata_| from |camera_info|.
void OnGotCameraInfo(int32_t result, arc::mojom::CameraInfoPtr camera_info);
// Creates the Mojo connection to the camera device.
void OnOpenedDevice(int32_t result);
// Initializes the camera HAL. Initialize sets up the Camera3CallbackOps with
// the camera HAL. OnInitialized continues to ConfigureStreams if the
// Initialize call succeeds.
void Initialize();
void OnInitialized(int32_t result);
// ConfigureStreams sets up stream context in |streams_| and configure the
// streams with the camera HAL. OnConfiguredStreams updates |streams_| with
// the stream config returned, and allocates buffers as per |updated_config|
// indicates. If there's no error OnConfiguredStreams notifies
// |client_| the capture has started by calling OnStarted, and proceeds to
// ConstructDefaultRequestSettings.
void ConfigureStreams();
void OnConfiguredStreams(
int32_t result,
arc::mojom::Camera3StreamConfigurationPtr updated_config);
// ConstructDefaultRequestSettings asks the camera HAL for the default request
// settings of the stream in |stream_context_|.
// OnConstructedDefaultRequestSettings sets the request settings in
// |streams_context_|. If there's no error
// OnConstructedDefaultRequestSettings calls StartCapture to start the video
// capture loop.
void ConstructDefaultRequestSettings();
void OnConstructedDefaultRequestSettings(
arc::mojom::CameraMetadataPtr settings);
// StreamCaptureInterface implementations. These methods are called by
// |stream_buffer_manager_| on |ipc_task_runner_|.
void RegisterBuffer(uint64_t buffer_id,
arc::mojom::Camera3DeviceOps::BufferType type,
uint32_t drm_format,
arc::mojom::HalPixelFormat hal_pixel_format,
uint32_t width,
uint32_t height,
std::vector<StreamCaptureInterface::Plane> planes,
base::OnceCallback<void(int32_t)> callback);
void ProcessCaptureRequest(arc::mojom::Camera3CaptureRequestPtr request,
base::OnceCallback<void(int32_t)> callback);
const VideoCaptureDeviceDescriptor device_descriptor_;
int32_t camera_id_;
const scoped_refptr<CameraHalDelegate> camera_hal_delegate_;
VideoCaptureParams chrome_capture_params_;
CameraDeviceContext* device_context_;
std::unique_ptr<StreamBufferManager> stream_buffer_manager_;
// Stores the static camera characteristics of the camera device. E.g. the
// supported formats and resolution, various available exposure and apeture
// settings, etc.
arc::mojom::CameraMetadataPtr static_metadata_;
arc::mojom::Camera3DeviceOpsPtr device_ops_;
// Where all the Mojo IPC calls takes place.
const scoped_refptr<base::SingleThreadTaskRunner> ipc_task_runner_;
base::OnceClosure device_close_callback_;
base::WeakPtrFactory<CameraDeviceDelegate> weak_ptr_factory_;
DISALLOW_IMPLICIT_CONSTRUCTORS(CameraDeviceDelegate);
};
} // namespace media
#endif // MEDIA_CAPTURE_VIDEO_CHROMEOS_CAMERA_DEVICE_DELEGATE_H_
|
