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
|
/*
* Copyright (C) 2016 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef V4L2_CAMERA_HAL_V4L2_WRAPPER_H_
#define V4L2_CAMERA_HAL_V4L2_WRAPPER_H_
#include <array>
#include <memory>
#include <mutex>
#include <set>
#include <string>
#include <vector>
#include <android-base/unique_fd.h>
#include "arc/common_types.h"
#include "arc/frame_buffer.h"
#include "capture_request.h"
#include "common.h"
#include "stream_format.h"
namespace v4l2_camera_hal {
class V4L2Wrapper {
public:
// Use this method to create V4L2Wrapper objects. Functionally equivalent
// to "new V4L2Wrapper", except that it may return nullptr in case of failure.
static V4L2Wrapper* NewV4L2Wrapper(const std::string device_path);
virtual ~V4L2Wrapper();
// Helper class to ensure all opened connections are closed.
class Connection {
public:
Connection(std::shared_ptr<V4L2Wrapper> device)
: device_(std::move(device)), connect_result_(device_->Connect()) {}
~Connection() {
if (connect_result_ == 0) {
device_->Disconnect();
}
}
// Check whether the connection succeeded or not.
inline int status() const { return connect_result_; }
private:
std::shared_ptr<V4L2Wrapper> device_;
const int connect_result_;
};
// Turn the stream on or off.
virtual int StreamOn();
virtual int StreamOff();
// Manage controls.
virtual int QueryControl(uint32_t control_id, v4l2_query_ext_ctrl* result);
virtual int GetControl(uint32_t control_id, int32_t* value);
virtual int SetControl(uint32_t control_id,
int32_t desired,
int32_t* result = nullptr);
// Manage format.
virtual int GetFormats(std::set<uint32_t>* v4l2_formats);
virtual int GetQualifiedFormats(std::vector<uint32_t>* v4l2_formats);
virtual int GetFormatFrameSizes(uint32_t v4l2_format,
std::set<std::array<int32_t, 2>>* sizes);
// Durations are returned in ns.
virtual int GetFormatFrameDurationRange(
uint32_t v4l2_format,
const std::array<int32_t, 2>& size,
std::array<int64_t, 2>* duration_range);
virtual int SetFormat(const StreamFormat& desired_format,
uint32_t* result_max_buffers);
// Manage buffers.
virtual int EnqueueRequest(
std::shared_ptr<default_camera_hal::CaptureRequest> request);
virtual int DequeueRequest(
std::shared_ptr<default_camera_hal::CaptureRequest>* request);
virtual int GetInFlightBufferCount();
private:
// Constructor is private to allow failing on bad input.
// Use NewV4L2Wrapper instead.
V4L2Wrapper(const std::string device_path);
// Connect or disconnect to the device. Access by creating/destroying
// a V4L2Wrapper::Connection object.
int Connect();
void Disconnect();
// Perform an ioctl call in a thread-safe fashion.
template <typename T>
int IoctlLocked(int request, T data);
// Request/release userspace buffer mode via VIDIOC_REQBUFS.
int RequestBuffers(uint32_t num_buffers);
inline bool connected() { return device_fd_.get() >= 0; }
// Format management.
const arc::SupportedFormats GetSupportedFormats();
// The camera device path. For example, /dev/video0.
const std::string device_path_;
// The opened device fd.
android::base::unique_fd device_fd_;
// The underlying gralloc module.
// std::unique_ptr<V4L2Gralloc> gralloc_;
// Whether or not the device supports the extended control query.
bool extended_query_supported_;
// The format this device is set up for.
std::unique_ptr<StreamFormat> format_;
// Lock protecting use of the buffer tracker.
std::mutex buffer_queue_lock_;
// Lock protecting use of the device.
std::mutex device_lock_;
// Lock protecting connecting/disconnecting the device.
std::mutex connection_lock_;
// Reference count connections.
int connection_count_;
// Supported formats.
arc::SupportedFormats supported_formats_;
// Qualified formats.
arc::SupportedFormats qualified_formats_;
class RequestContext {
public:
RequestContext()
: active(false),
camera_buffer(std::make_shared<arc::AllocatedFrameBuffer>(0)){};
~RequestContext(){};
// Indicates whether this request context is in use.
bool active;
// Buffer handles of the context.
std::shared_ptr<arc::AllocatedFrameBuffer> camera_buffer;
std::shared_ptr<default_camera_hal::CaptureRequest> request;
};
// Map of in flight requests.
// |buffers_.size()| will always be the maximum number of buffers this device
// can handle in its current format.
std::vector<RequestContext> buffers_;
friend class Connection;
friend class V4L2WrapperMock;
DISALLOW_COPY_AND_ASSIGN(V4L2Wrapper);
};
} // namespace v4l2_camera_hal
#endif // V4L2_CAMERA_HAL_V4L2_WRAPPER_H_
|
