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
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
/*
* Copyright (C) 2020, Google Inc.
*
* camera_worker.cpp - Process capture requests on behalf of the Camera HAL
*/
#include "camera_worker.h"
#include <errno.h>
#include <string.h>
#include <sys/poll.h>
#include <unistd.h>
#include "camera_device.h"
using namespace libcamera;
LOG_DECLARE_CATEGORY(HAL)
/*
* \class CaptureRequest
* \brief Wrap a libcamera::Request associated with buffers and fences
*
* A CaptureRequest is constructed by the CameraDevice, filled with
* buffers and fences provided by the camera3 framework and then processed
* by the CameraWorker which queues it to the libcamera::Camera after handling
* fences.
*/
CaptureRequest::CaptureRequest(Camera *camera, uint64_t cookie)
: camera_(camera)
{
request_ = camera_->createRequest(cookie);
}
void CaptureRequest::addBuffer(Stream *stream, FrameBuffer *buffer, int fence)
{
request_->addBuffer(stream, buffer);
acquireFences_.push_back(fence);
}
void CaptureRequest::queue()
{
camera_->queueRequest(request_.get());
}
/*
* \class CameraWorker
* \brief Process a CaptureRequest on an internal thread
*
* The CameraWorker class wraps a Worker that runs on an internal thread
* and schedules processing of CaptureRequest through it.
*/
CameraWorker::CameraWorker()
{
worker_.moveToThread(this);
}
void CameraWorker::start()
{
Thread::start();
}
void CameraWorker::stop()
{
exit();
wait();
}
void CameraWorker::run()
{
exec();
dispatchMessages(Message::Type::InvokeMessage);
}
void CameraWorker::queueRequest(CaptureRequest *request)
{
/* Async process the request on the worker which runs its own thread. */
worker_.invokeMethod(&Worker::processRequest, ConnectionTypeQueued,
request);
}
/*
* \class CameraWorker::Worker
* \brief Process a CaptureRequest handling acquisition fences
*/
int CameraWorker::Worker::waitFence(int fence)
{
/*
* \todo Better characterize the timeout. Currently equal to the one
* used by the Rockchip Camera HAL on ChromeOS.
*/
constexpr unsigned int timeoutMs = 300;
struct pollfd fds = { fence, POLLIN, 0 };
do {
int ret = poll(&fds, 1, timeoutMs);
if (ret == 0)
return -ETIME;
if (ret > 0) {
if (fds.revents & (POLLERR | POLLNVAL))
return -EINVAL;
return 0;
}
} while (errno == EINTR || errno == EAGAIN);
return -errno;
}
void CameraWorker::Worker::processRequest(CaptureRequest *request)
{
/* Wait on all fences before queuing the Request. */
for (int fence : request->fences()) {
if (fence == -1)
continue;
int ret = waitFence(fence);
close(fence);
if (ret < 0) {
LOG(HAL, Error) << "Failed waiting for fence: "
<< fence << ": " << strerror(-ret);
return;
}
}
request->queue();
}
|
