summaryrefslogtreecommitdiff
path: root/test/libtest
AgeCommit message (Expand)Author
2022-08-03libcamera: v4l2_videodevice: Reintroduce toV4L2PixelFormat()Jacopo Mondi
2021-12-01test: Store path to the test executable in Test classLaurent Pinchart
2021-11-24test: Convert to pragma onceKieran Bingham
2021-10-15test: Remove using namespace in header filesHirokazu Honda
2021-09-07libcamera: v4l2_videodevice: Drop toV4L2PixelFormat()Laurent Pinchart
2021-08-19libtest: camera_test: Plumb constructor to set LIBCAMERA_IPA_FORCE_ISOLATIONUmang Jain
2021-06-25libcamera/base: Validate internal headers as privateKieran Bingham
2020-12-09libcamera: v4l2_device: Return a unique pointer from fromEntityName()Laurent Pinchart
2020-09-21test: Include specific headers instead of libcamera.hLaurent Pinchart
2020-08-25meson: Remove -Wno-unused-parameterLaurent Pinchart
2020-05-16libcamera: Move internal headers to include/libcamera/internal/Laurent Pinchart
2020-05-13licenses: License all meson files under CC0-1.0Laurent Pinchart
2020-04-30libcamera: v4l2_pixelformat: Move DRM/V4L2 format conversionLaurent Pinchart
2020-03-19libcamera: v4l2_videodevice: Rename toV4L2Fourcc to toV4L2PixelFormatLaurent Pinchart
2020-03-18libcamera: v4l2_videodevice: Rename exportBuffers() to allocateBuffers()Laurent Pinchart
2020-03-18test: libtest: buffer_source: Close video device right after allocationLaurent Pinchart
2020-03-18tests: remove IPA_PROXY_PATH environment variableKaaira Gupta
2020-03-06test: Extract BufferSource class out of camera tests to libtestNiklas Söderlund
2020-02-24tests: Remove IPA_MODULE_PATH environment variableKieran Bingham
2019-11-20test: Extract CameraTest class out of camera tests to libtestLaurent Pinchart
2019-11-18libcamera: Remove space between empty curly bracketsLaurent Pinchart
2019-07-12libcamera: add IPA proxyPaul Elder
2019-06-05libcamera: ipa_manager: implement class for managing IPA modulesPaul Elder
2019-05-23meson: Create and use a dependency for libcamera and its headersLaurent Pinchart
2019-01-02test: Move include definitions to libtestKieran Bingham
2019-01-01test: libtest: Return all non-zero init valuesKieran Bingham
2019-01-01test: libtest: Add test return codesKieran Bingham
2019-01-01test: Move test objects to libtestKieran Bingham
generated by cgit v1.2.1 (git 2.18.0) at 2025-04-07 16:34:34 +0000
'n246' href='#n246'>246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 
/* SPDX-License-Identifier: LGPL-2.1-or-later */
/*
 * Copyright (C) 2019, Google Inc.
 *
 * v4l2_camera.cpp - V4L2 compatibility camera
 */

#include "v4l2_camera.h"

#include <errno.h>
#include <unistd.h>

#include "libcamera/internal/log.h"

using namespace libcamera;

LOG_DECLARE_CATEGORY(V4L2Compat)

V4L2Camera::V4L2Camera(std::shared_ptr<Camera> camera)
	: camera_(camera), isRunning_(false), bufferAllocator_(nullptr),
	  efd_(-1), bufferAvailableCount_(0)
{
	camera_->requestCompleted.connect(this, &V4L2Camera::requestComplete);
}

V4L2Camera::~V4L2Camera()
{
	close();
}

int V4L2Camera::open(StreamConfiguration *streamConfig)
{
	if (camera_->acquire() < 0) {
		LOG(V4L2Compat, Error) << "Failed to acquire camera";
		return -EINVAL;
	}

	config_ = camera_->generateConfiguration({ StreamRole::Viewfinder });
	if (!config_) {
		camera_->release();
		return -EINVAL;
	}

	bufferAllocator_ = new FrameBufferAllocator(camera_);

	*streamConfig = config_->at(0);
	return 0;
}

void V4L2Camera::close()
{
	requestPool_.clear();

	delete bufferAllocator_;
	bufferAllocator_ = nullptr;

	camera_->release();
}

void V4L2Camera::bind(int efd)
{
	efd_ = efd;
}

void V4L2Camera::unbind()
{
	efd_ = -1;
}

std::vector<V4L2Camera::Buffer> V4L2Camera::completedBuffers()
{
	std::vector<Buffer> v;

	bufferLock_.lock();
	for (std::unique_ptr<Buffer> &metadata : completedBuffers_)
		v.push_back(*metadata.get());
	completedBuffers_.clear();
	bufferLock_.unlock();

	return v;
}

void V4L2Camera::requestComplete(Request *request)
{
	if (request->status() == Request::RequestCancelled)
		return;

	/* We only have one stream at the moment. */
	bufferLock_.lock();
	FrameBuffer *buffer = request->buffers().begin()->second;
	std::unique_ptr<Buffer> metadata =
		std::make_unique<Buffer>(request->cookie(), buffer->metadata());
	completedBuffers_.push_back(std::move(metadata));
	bufferLock_.unlock();

	uint64_t data = 1;
	int ret = ::write(efd_, &data, sizeof(data));
	if (ret != sizeof(data))
		LOG(V4L2Compat, Error) << "Failed to signal eventfd POLLIN";

	request->reuse();
	{
		MutexLocker locker(bufferMutex_);
		bufferAvailableCount_++;
	}
	bufferCV_.notify_all();
}

int V4L2Camera::configure(StreamConfiguration *streamConfigOut,
			  const Size &size, const PixelFormat &pixelformat,
			  unsigned int bufferCount)
{
	StreamConfiguration &streamConfig = config_->at(0);
	streamConfig.size.width = size.width;
	streamConfig.size.height = size.height;
	streamConfig.pixelFormat = pixelformat;
	streamConfig.bufferCount = bufferCount;
	/* \todo memoryType (interval vs external) */

	CameraConfiguration::Status validation = config_->validate();
	if (validation == CameraConfiguration::Invalid) {
		LOG(V4L2Compat, Debug) << "Configuration invalid";
		return -EINVAL;
	}
	if (validation == CameraConfiguration::Adjusted)
		LOG(V4L2Compat, Debug) << "Configuration adjusted";

	LOG(V4L2Compat, Debug) << "Validated configuration is: "
			      << streamConfig.toString();

	int ret = camera_->configure(config_.get());
	if (ret < 0)
		return ret;

	*streamConfigOut = config_->at(0);

	return 0;
}

int V4L2Camera::validateConfiguration(const PixelFormat &pixelFormat,
				      const Size &size,
				      StreamConfiguration *streamConfigOut)
{
	std::unique_ptr<CameraConfiguration> config =
		camera_->generateConfiguration({ StreamRole::Viewfinder });
	StreamConfiguration &cfg = config->at(0);
	cfg.size = size;
	cfg.pixelFormat = pixelFormat;
	cfg.bufferCount = 1;

	CameraConfiguration::Status validation = config->validate();
	if (validation == CameraConfiguration::Invalid)
		return -EINVAL;

	*streamConfigOut = cfg;

	return 0;
}

int V4L2Camera::allocBuffers(unsigned int count)
{
	Stream *stream = config_->at(0).stream();

	int ret = bufferAllocator_->allocate(stream);
	if (ret < 0)
		return ret;

	for (unsigned int i = 0; i < count; i++) {
		std::unique_ptr<Request> request = camera_->createRequest(i);
		if (!request) {
			requestPool_.clear();
			return -ENOMEM;
		}
		requestPool_.push_back(std::move(request));
	}

	return ret;
}

void V4L2Camera::freeBuffers()
{
	pendingRequests_.clear();
	requestPool_.clear();

	Stream *stream = config_->at(0).stream();
	bufferAllocator_->free(stream);
}

FileDescriptor V4L2Camera::getBufferFd(unsigned int index)
{
	Stream *stream = config_->at(0).stream();
	const std::vector<std::unique_ptr<FrameBuffer>> &buffers =
		bufferAllocator_->buffers(stream);

	if (buffers.size() <= index)
		return FileDescriptor();

	return buffers[index]->planes()[0].fd;
}

int V4L2Camera::streamOn()
{
	if (isRunning_)
		return 0;

	int ret = camera_->start();
	if (ret < 0)
		return ret == -EACCES ? -EBUSY : ret;

	isRunning_ = true;

	for (Request *req : pendingRequests_) {
		/* \todo What should we do if this returns -EINVAL? */
		ret = camera_->queueRequest(req);
		if (ret < 0)
			return ret == -EACCES ? -EBUSY : ret;
	}

	pendingRequests_.clear();

	return 0;
}

int V4L2Camera::streamOff()
{
	if (!isRunning_) {
		for (std::unique_ptr<Request> &req : requestPool_)
			req->reuse();

		return 0;
	}

	pendingRequests_.clear();

	int ret = camera_->stop();
	if (ret < 0)
		return ret == -EACCES ? -EBUSY : ret;

	{
		MutexLocker locker(bufferMutex_);
		isRunning_ = false;
	}
	bufferCV_.notify_all();

	return 0;
}

int V4L2Camera::qbuf(unsigned int index)
{
	if (index >= requestPool_.size()) {
		LOG(V4L2Compat, Error) << "Invalid index";
		return -EINVAL;
	}
	Request *request = requestPool_[index].get();

	Stream *stream = config_->at(0).stream();
	FrameBuffer *buffer = bufferAllocator_->buffers(stream)[index].get();
	int ret = request->addBuffer(stream, buffer);
	if (ret < 0) {
		LOG(V4L2Compat, Error) << "Can't set buffer for request";
		return -ENOMEM;
	}

	if (!isRunning_) {
		pendingRequests_.push_back(request);
		return 0;
	}

	ret = camera_->queueRequest(request);
	if (ret < 0) {
		LOG(V4L2Compat, Error) << "Can't queue request";
		return ret == -EACCES ? -EBUSY : ret;
	}

	return 0;
}

void V4L2Camera::waitForBufferAvailable()
{
	MutexLocker locker(bufferMutex_);
	bufferCV_.wait(locker, [&] {
			       return bufferAvailableCount_ >= 1 || !isRunning_;
		       });
	if (isRunning_)
		bufferAvailableCount_--;
}

bool V4L2Camera::isBufferAvailable()
{
	MutexLocker locker(bufferMutex_);
	if (bufferAvailableCount_ < 1)
		return false;

	bufferAvailableCount_--;
	return true;
}

bool V4L2Camera::isRunning()
{
	return isRunning_;
}
generated by cgit v1.2.1 (git 2.18.0) at 2025-04-07 16:34:34 +0000