/* SPDX-License-Identifier: GPL-2.0-or-later */ /* * Copyright (C) 2020, Raspberry Pi (Trading) Ltd. * * stream_options.cpp - Helper to parse options for streams */ #include "stream_options.h" #include using namespace libcamera; StreamKeyValueParser::StreamKeyValueParser() { addOption("role", OptionString, "Role for the stream (viewfinder, video, still, stillraw)", ArgumentRequired); addOption("width", OptionInteger, "Width in pixels", ArgumentRequired); addOption("height", OptionInteger, "Height in pixels", ArgumentRequired); addOption("pixelformat", OptionInteger, "Pixel format", ArgumentRequired); } KeyValueParser::Options StreamKeyValueParser::parse(const char *arguments) { KeyValueParser::Options options = KeyValueParser::parse(arguments); StreamRole role; if (options.valid() && options.isSet("role") && !parseRole(&role, options)) { std::cerr << "Unknown stream role " << options["role"].toString() << std::endl; options.invalidate(); } return options; } StreamRoles StreamKeyValueParser::roles(const OptionValue &values) { const std::vector &streamParameters = values.toArray(); /* If no configuration values to examine default to viewfinder. */ if (streamParameters.empty()) return { StreamRole::Viewfinder }; StreamRoles roles; for (auto const &value : streamParameters) { KeyValueParser::Options opts = value.toKeyValues(); StreamRole role; /* If role is invalid or not set default to viewfinder. */ if (!parseRole(&role, value)) role = StreamRole::Viewfinder; roles.push_back(role); } return roles; } int StreamKeyValueParser::updateConfiguration(CameraConfiguration *config, const OptionValue &values) { const std::vector &streamParameters = values.toArray(); if (!config) { std::cerr << "No configuration provided" << std::endl; return -EINVAL; } /* If no configuration values nothing to do. */ if (!streamParameters.size()) return 0; if (config->size() != streamParameters.size()) { std::cerr << "Number of streams in configuration " << config->size() << " does not match number of streams parsed " << streamParameters.size() << std::endl; return -EINVAL; } unsigned int i = 0; for (auto const &value : streamParameters) { KeyValueParser::Options opts = value.toKeyValues(); StreamConfiguration &cfg = config->at(i++); if (opts.isSet("width") && opts.isSet("height")) { cfg.size.width = opts["width"]; cfg.size.height = opts["height"]; } /* \todo Translate 4CC string to pixelformat with modifier. */ if (opts.isSet("pixelformat")) cfg.pixelFormat = PixelFormat(opts["pixelformat"]); } return 0; } bool StreamKeyValueParser::parseRole(StreamRole *role, const KeyValueParser::Options &options) { if (!options.isSet("role")) return false; std::string name = options["role"].toString(); if (name == "viewfinder") { *role = StreamRole::Viewfinder; return true; } else if (name == "video") { *role = StreamRole::VideoRecording; return true; } else if (name == "still") { *role = StreamRole::StillCapture; return true; } else if (name == "stillraw") { *role = StreamRole::StillCaptureRaw; return true; } return false; } acc21fd04fa8568eea9a0bc59e0e614acfbaf7c'>diff
path: root/src/android/camera_worker.cpp
blob: dabb305407a21b1e8d20119d74d292cbfa79943f (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
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;