From patchwork Tue May 19 03:24:58 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Laurent Pinchart X-Patchwork-Id: 3812 X-Patchwork-Delegate: laurent.pinchart@ideasonboard.com Return-Path: Received: from perceval.ideasonboard.com (perceval.ideasonboard.com [IPv6:2001:4b98:dc2:55:216:3eff:fef7:d647]) by lancelot.ideasonboard.com (Postfix) with ESMTPS id E1BD660E2A for ; Tue, 19 May 2020 05:25:18 +0200 (CEST) Authentication-Results: lancelot.ideasonboard.com; dkim=pass (1024-bit key; unprotected) header.d=ideasonboard.com header.i=@ideasonboard.com header.b="mFCYP7c4"; dkim-atps=neutral Received: from pendragon.bb.dnainternet.fi (81-175-216-236.bb.dnainternet.fi [81.175.216.236]) by perceval.ideasonboard.com (Postfix) with ESMTPSA id 770749CD for ; Tue, 19 May 2020 05:25:18 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=ideasonboard.com; s=mail; t=1589858718; bh=LOk3AEjLrVVhMAvdxqTcaHifTmaqBlnpgfSeS4tLBqY=; h=From:To:Subject:Date:In-Reply-To:References:From; b=mFCYP7c4+Xw5aSZnIz8pTjxeOGrdONE6MMZp7LdOKIyEs4v3Fm4+JVnllo0uzOHUS W0HRRCbJeAs+EZCG2CXRBVHGu9R75Ta+gAuHibcTwDiKPnm00NJH9lJYSo7ZlOgXyr a6B9e6RYp69RyqBeFY38feOAYsMWcuetTk0s/wfQ= From: Laurent Pinchart To: libcamera-devel@lists.libcamera.org Date: Tue, 19 May 2020 06:24:58 +0300 Message-Id: <20200519032505.17307-2-laurent.pinchart@ideasonboard.com> X-Mailer: git-send-email 2.26.2 In-Reply-To: <20200519032505.17307-1-laurent.pinchart@ideasonboard.com> References: <20200519032505.17307-1-laurent.pinchart@ideasonboard.com> MIME-Version: 1.0 Subject: [libcamera-devel] [PATCH 1/8] cam: Pass stream roles to Capture class X-BeenThere: libcamera-devel@lists.libcamera.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Tue, 19 May 2020 03:25:19 -0000 The stream roles will be needed in the Capture class to verify the configuration. Store they in the CamApp class and pass them to the Capture class constructor. Signed-off-by: Laurent Pinchart Reviewed-by: Kieran Bingham --- src/cam/capture.cpp | 5 +++-- src/cam/capture.h | 4 +++- src/cam/main.cpp | 9 +++++---- 3 files changed, 11 insertions(+), 7 deletions(-) diff --git a/src/cam/capture.cpp b/src/cam/capture.cpp index 55fa2dabcee9..b7e06bcc9463 100644 --- a/src/cam/capture.cpp +++ b/src/cam/capture.cpp @@ -16,8 +16,9 @@ using namespace libcamera; -Capture::Capture(std::shared_ptr camera, CameraConfiguration *config) - : camera_(camera), config_(config), writer_(nullptr) +Capture::Capture(std::shared_ptr camera, CameraConfiguration *config, + const StreamRoles &roles) + : camera_(camera), config_(config), roles_(roles), writer_(nullptr) { } diff --git a/src/cam/capture.h b/src/cam/capture.h index 9bca5661070e..c0e697b831fb 100644 --- a/src/cam/capture.h +++ b/src/cam/capture.h @@ -24,7 +24,8 @@ class Capture { public: Capture(std::shared_ptr camera, - libcamera::CameraConfiguration *config); + libcamera::CameraConfiguration *config, + const libcamera::StreamRoles &roles); int run(EventLoop *loop, const OptionsParser::Options &options); private: @@ -35,6 +36,7 @@ private: std::shared_ptr camera_; libcamera::CameraConfiguration *config_; + libcamera::StreamRoles roles_; std::map streamName_; BufferWriter *writer_; diff --git a/src/cam/main.cpp b/src/cam/main.cpp index 2512fe9da782..cdd29d500202 100644 --- a/src/cam/main.cpp +++ b/src/cam/main.cpp @@ -47,6 +47,7 @@ private: OptionsParser::Options options_; CameraManager *cm_; std::shared_ptr camera_; + StreamRoles roles_; std::unique_ptr config_; EventLoop *loop_; }; @@ -194,10 +195,10 @@ int CamApp::parseOptions(int argc, char *argv[]) int CamApp::prepareConfig() { - StreamRoles roles = StreamKeyValueParser::roles(options_[OptStream]); + roles_ = StreamKeyValueParser::roles(options_[OptStream]); - config_ = camera_->generateConfiguration(roles); - if (!config_ || config_->size() != roles.size()) { + config_ = camera_->generateConfiguration(roles_); + if (!config_ || config_->size() != roles_.size()) { std::cerr << "Failed to get default stream configuration" << std::endl; return -EINVAL; @@ -326,7 +327,7 @@ int CamApp::run() } if (options_.isSet(OptCapture)) { - Capture capture(camera_, config_.get()); + Capture capture(camera_, config_.get(), roles_); return capture.run(loop_, options_); } From patchwork Tue May 19 03:24:59 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: Laurent Pinchart X-Patchwork-Id: 3813 X-Patchwork-Delegate: laurent.pinchart@ideasonboard.com Return-Path: Received: from perceval.ideasonboard.com (perceval.ideasonboard.com [IPv6:2001:4b98:dc2:55:216:3eff:fef7:d647]) by lancelot.ideasonboard.com (Postfix) with ESMTPS id 3575D60E44 for ; Tue, 19 May 2020 05:25:19 +0200 (CEST) Authentication-Results: lancelot.ideasonboard.com; dkim=pass (1024-bit key; unprotected) header.d=ideasonboard.com header.i=@ideasonboard.com header.b="LszftT3t"; dkim-atps=neutral Received: from pendragon.bb.dnainternet.fi (81-175-216-236.bb.dnainternet.fi [81.175.216.236]) by perceval.ideasonboard.com (Postfix) with ESMTPSA id CA87D30C for ; Tue, 19 May 2020 05:25:18 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=ideasonboard.com; s=mail; t=1589858719; bh=f1jXq/4rvugginWdAETolbk2dXRKTvSR11MQj/WFbu8=; h=From:To:Subject:Date:In-Reply-To:References:From; b=LszftT3tAQAvyDCTJK6JHG0ZVQJEYAEElk6vOcS7y2buX1j8BtNcA/DL+QuvMz/Y2 k7hMf2BYXcOspSg308k74WVcmkOzd4KBzDJG/bXuzmPENjx6ikei5JVcRoT+d9gnjI 3ffI5Zoj2tugGs59zIQs+UmECJ+I8BQLYuWbT4Hc= From: Laurent Pinchart To: libcamera-devel@lists.libcamera.org Date: Tue, 19 May 2020 06:24:59 +0300 Message-Id: <20200519032505.17307-3-laurent.pinchart@ideasonboard.com> X-Mailer: git-send-email 2.26.2 In-Reply-To: <20200519032505.17307-1-laurent.pinchart@ideasonboard.com> References: <20200519032505.17307-1-laurent.pinchart@ideasonboard.com> MIME-Version: 1.0 Subject: [libcamera-devel] [PATCH 2/8] cam: Add FrameSink base class X-BeenThere: libcamera-devel@lists.libcamera.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Tue, 19 May 2020 03:25:20 -0000 The FrameSink class serves as a base to implement components that consume frames. This allows handling frame sinks in a generic way, independent of their nature. The BufferWrite class will be ported to FrameSink in a second step. Signed-off-by: Laurent Pinchart Reviewed-by: Niklas Söderlund --- src/cam/frame_sink.cpp | 31 +++++++++++++++++++++++++++++++ src/cam/frame_sink.h | 35 +++++++++++++++++++++++++++++++++++ src/cam/meson.build | 1 + 3 files changed, 67 insertions(+) create mode 100644 src/cam/frame_sink.cpp create mode 100644 src/cam/frame_sink.h diff --git a/src/cam/frame_sink.cpp b/src/cam/frame_sink.cpp new file mode 100644 index 000000000000..fbe16e2f5081 --- /dev/null +++ b/src/cam/frame_sink.cpp @@ -0,0 +1,31 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ +/* + * Copyright (C) 2020, Ideas on Board Oy + * + * frame_sink.cpp - Base Frame Sink Class + */ + +#include "frame_sink.h" + +FrameSink::~FrameSink() +{ +} + +int FrameSink::configure(const libcamera::CameraConfiguration &config) +{ + return 0; +} + +void FrameSink::mapBuffer(libcamera::FrameBuffer *buffer) +{ +} + +int FrameSink::start() +{ + return 0; +} + +int FrameSink::stop() +{ + return 0; +} diff --git a/src/cam/frame_sink.h b/src/cam/frame_sink.h new file mode 100644 index 000000000000..39604a07eb70 --- /dev/null +++ b/src/cam/frame_sink.h @@ -0,0 +1,35 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ +/* + * Copyright (C) 2020, Ideas on Board Oy + * + * frame_sink.h - Base Frame Sink Class + */ +#ifndef __CAM_FRAME_SINK_H__ +#define __CAM_FRAME_SINK_H__ + +#include + +namespace libcamera { +class CameraConfiguration; +class FrameBuffer; +class Stream; +} /* namespace libcamera */ + +class FrameSink +{ +public: + virtual ~FrameSink(); + + virtual int configure(const libcamera::CameraConfiguration &config); + + virtual void mapBuffer(libcamera::FrameBuffer *buffer); + + virtual int start(); + virtual int stop(); + + virtual bool consumeBuffer(const libcamera::Stream *stream, + libcamera::FrameBuffer *buffer) = 0; + libcamera::Signal bufferReleased; +}; + +#endif /* __CAM_FRAME_SINK_H__ */ diff --git a/src/cam/meson.build b/src/cam/meson.build index 89e124fbae2a..d7b72ec02f8c 100644 --- a/src/cam/meson.build +++ b/src/cam/meson.build @@ -4,6 +4,7 @@ cam_sources = files([ 'buffer_writer.cpp', 'capture.cpp', 'event_loop.cpp', + 'frame_sink.cpp', 'main.cpp', 'options.cpp', 'stream_options.cpp', From patchwork Tue May 19 03:25:00 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Laurent Pinchart X-Patchwork-Id: 3814 X-Patchwork-Delegate: laurent.pinchart@ideasonboard.com Return-Path: Received: from perceval.ideasonboard.com (perceval.ideasonboard.com [213.167.242.64]) by lancelot.ideasonboard.com (Postfix) with ESMTPS id 8C15660E4B for ; Tue, 19 May 2020 05:25:19 +0200 (CEST) Authentication-Results: lancelot.ideasonboard.com; dkim=pass (1024-bit key; unprotected) header.d=ideasonboard.com header.i=@ideasonboard.com header.b="uUE7DOw9"; dkim-atps=neutral Received: from pendragon.bb.dnainternet.fi (81-175-216-236.bb.dnainternet.fi [81.175.216.236]) by perceval.ideasonboard.com (Postfix) with ESMTPSA id 2872A9CD for ; Tue, 19 May 2020 05:25:19 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=ideasonboard.com; s=mail; t=1589858719; bh=bbo2GZaNhzdqroS5K4iCIOQID0bTa3t6YBlyQNjWN48=; h=From:To:Subject:Date:In-Reply-To:References:From; b=uUE7DOw9yGPR53o2YFJjaNGiJAAUyNJ7JvDSis7cCnArip2LbSO6/8vfayVr9CxMd qwiZoK6NtsdwH+6/vwu8zJEJjkSdy3NfXvFujQbRSwA2fTLbobXgrnY7BAK3ItFusA VtU9tVWvaH37/y7qH1TGt5CFLZB5RZF4TmAI8s3U= From: Laurent Pinchart To: libcamera-devel@lists.libcamera.org Date: Tue, 19 May 2020 06:25:00 +0300 Message-Id: <20200519032505.17307-4-laurent.pinchart@ideasonboard.com> X-Mailer: git-send-email 2.26.2 In-Reply-To: <20200519032505.17307-1-laurent.pinchart@ideasonboard.com> References: <20200519032505.17307-1-laurent.pinchart@ideasonboard.com> MIME-Version: 1.0 Subject: [libcamera-devel] [PATCH 3/8] cam: Turn BufferWriter into a FrameSink X-BeenThere: libcamera-devel@lists.libcamera.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Tue, 19 May 2020 03:25:21 -0000 Make the BufferWriter class inherit from FrameSink, and use the FrameSink API to manage it. This makes the code more generic, and will allow usage of other sinks. Signed-off-by: Laurent Pinchart --- src/cam/buffer_writer.cpp | 25 ++++++++++--- src/cam/buffer_writer.h | 13 ++++--- src/cam/capture.cpp | 76 ++++++++++++++++++++++++++++++++------- src/cam/capture.h | 6 ++-- 4 files changed, 97 insertions(+), 23 deletions(-) diff --git a/src/cam/buffer_writer.cpp b/src/cam/buffer_writer.cpp index c5a5eb46224a..2bec4b132155 100644 --- a/src/cam/buffer_writer.cpp +++ b/src/cam/buffer_writer.cpp @@ -13,6 +13,8 @@ #include #include +#include + #include "buffer_writer.h" using namespace libcamera; @@ -32,6 +34,21 @@ BufferWriter::~BufferWriter() mappedBuffers_.clear(); } +int BufferWriter::configure(const libcamera::CameraConfiguration &config) +{ + int ret = FrameSink::configure(config); + if (ret < 0) + return ret; + + streamNames_.clear(); + for (unsigned int index = 0; index < config.size(); ++index) { + const StreamConfiguration &cfg = config.at(index); + streamNames_[cfg.stream()] = "stream" + std::to_string(index); + } + + return 0; +} + void BufferWriter::mapBuffer(FrameBuffer *buffer) { for (const FrameBuffer::Plane &plane : buffer->planes()) { @@ -43,7 +60,7 @@ void BufferWriter::mapBuffer(FrameBuffer *buffer) } } -int BufferWriter::write(FrameBuffer *buffer, const std::string &streamName) +bool BufferWriter::consumeBuffer(const Stream *stream, FrameBuffer *buffer) { std::string filename; size_t pos; @@ -53,7 +70,7 @@ int BufferWriter::write(FrameBuffer *buffer, const std::string &streamName) pos = filename.find_first_of('#'); if (pos != std::string::npos) { std::stringstream ss; - ss << streamName << "-" << std::setw(6) + ss << streamNames_[stream] << "-" << std::setw(6) << std::setfill('0') << buffer->metadata().sequence; filename.replace(pos, 1, ss.str()); } @@ -62,7 +79,7 @@ int BufferWriter::write(FrameBuffer *buffer, const std::string &streamName) (pos == std::string::npos ? O_APPEND : O_TRUNC), S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH); if (fd == -1) - return -errno; + return true; for (const FrameBuffer::Plane &plane : buffer->planes()) { void *data = mappedBuffers_[plane.fd.fd()].first; @@ -84,5 +101,5 @@ int BufferWriter::write(FrameBuffer *buffer, const std::string &streamName) close(fd); - return ret; + return true; } diff --git a/src/cam/buffer_writer.h b/src/cam/buffer_writer.h index 47e26103e13e..5a5b176f73d8 100644 --- a/src/cam/buffer_writer.h +++ b/src/cam/buffer_writer.h @@ -12,18 +12,23 @@ #include -class BufferWriter +#include "frame_sink.h" + +class BufferWriter : public FrameSink { public: BufferWriter(const std::string &pattern = "frame-#.bin"); ~BufferWriter(); - void mapBuffer(libcamera::FrameBuffer *buffer); + int configure(const libcamera::CameraConfiguration &config) override; - int write(libcamera::FrameBuffer *buffer, - const std::string &streamName); + void mapBuffer(libcamera::FrameBuffer *buffer) override; + + bool consumeBuffer(const libcamera::Stream *stream, + libcamera::FrameBuffer *buffer) override; private: + std::map streamNames_; std::string pattern_; std::map> mappedBuffers_; }; diff --git a/src/cam/capture.cpp b/src/cam/capture.cpp index b7e06bcc9463..7fc9cba48892 100644 --- a/src/cam/capture.cpp +++ b/src/cam/capture.cpp @@ -11,6 +11,7 @@ #include #include +#include "buffer_writer.h" #include "capture.h" #include "main.h" @@ -18,7 +19,7 @@ using namespace libcamera; Capture::Capture(std::shared_ptr camera, CameraConfiguration *config, const StreamRoles &roles) - : camera_(camera), config_(config), roles_(roles), writer_(nullptr) + : camera_(camera), config_(config), roles_(roles), sink_(nullptr) { } @@ -47,20 +48,28 @@ int Capture::run(EventLoop *loop, const OptionsParser::Options &options) if (options.isSet(OptFile)) { if (!options[OptFile].toString().empty()) - writer_ = new BufferWriter(options[OptFile]); + sink_ = new BufferWriter(options[OptFile]); else - writer_ = new BufferWriter(); + sink_ = new BufferWriter(); } + if (sink_) { + ret = sink_->configure(*config_); + if (ret < 0) { + std::cout << "Failed to configure frame sink" + << std::endl; + return ret; + } + + sink_->bufferReleased.connect(this, &Capture::sinkRelease); + } FrameBufferAllocator *allocator = new FrameBufferAllocator(camera_); ret = capture(loop, allocator); - if (options.isSet(OptFile)) { - delete writer_; - writer_ = nullptr; - } + delete sink_; + sink_ = nullptr; delete allocator; @@ -110,16 +119,26 @@ int Capture::capture(EventLoop *loop, FrameBufferAllocator *allocator) return ret; } - if (writer_) - writer_->mapBuffer(buffer.get()); + if (sink_) + sink_->mapBuffer(buffer.get()); } requests.push_back(request); } + if (sink_) { + ret = sink_->start(); + if (ret) { + std::cout << "Failed to start frame sink" << std::endl; + return ret; + } + } + ret = camera_->start(); if (ret) { std::cout << "Failed to start capture" << std::endl; + if (sink_) + sink_->stop(); return ret; } @@ -128,6 +147,8 @@ int Capture::capture(EventLoop *loop, FrameBufferAllocator *allocator) if (ret < 0) { std::cerr << "Can't queue request" << std::endl; camera_->stop(); + if (sink_) + sink_->stop(); return ret; } } @@ -141,6 +162,12 @@ int Capture::capture(EventLoop *loop, FrameBufferAllocator *allocator) if (ret) std::cout << "Failed to stop capture" << std::endl; + if (sink_) { + ret = sink_->stop(); + if (ret) + std::cout << "Failed to stop frame sink" << std::endl; + } + return ret; } @@ -157,17 +184,18 @@ void Capture::requestComplete(Request *request) ? 1000.0 / fps : 0.0; last_ = now; + bool requeue = true; + std::stringstream info; info << "fps: " << std::fixed << std::setprecision(2) << fps; for (auto it = buffers.begin(); it != buffers.end(); ++it) { Stream *stream = it->first; FrameBuffer *buffer = it->second; - const std::string &name = streamName_[stream]; const FrameMetadata &metadata = buffer->metadata(); - info << " " << name + info << " " << streamName_[stream] << " seq: " << std::setw(6) << std::setfill('0') << metadata.sequence << " bytesused: "; @@ -178,12 +206,21 @@ void Capture::requestComplete(Request *request) info << "/"; } - if (writer_) - writer_->write(buffer, name); + if (sink_) { + if (!sink_->consumeBuffer(stream, buffer)) + requeue = false; + } } std::cout << info.str() << std::endl; + /* + * If the frame sink holds on the buffer, we'll requeue it later in the + * complete handler. + */ + if (!requeue) + return; + /* * Create a new request and populate it with one buffer for each * stream. @@ -203,3 +240,16 @@ void Capture::requestComplete(Request *request) camera_->queueRequest(request); } + +void Capture::sinkRelease(libcamera::FrameBuffer *buffer) +{ + Request *request = camera_->createRequest(); + if (!request) { + std::cerr << "Can't create request" << std::endl; + return; + } + + request->addBuffer(config_->at(0).stream(), buffer); + + camera_->queueRequest(request); +} diff --git a/src/cam/capture.h b/src/cam/capture.h index c0e697b831fb..3be1d98e4d3e 100644 --- a/src/cam/capture.h +++ b/src/cam/capture.h @@ -16,10 +16,11 @@ #include #include -#include "buffer_writer.h" #include "event_loop.h" #include "options.h" +class FrameSink; + class Capture { public: @@ -33,13 +34,14 @@ private: libcamera::FrameBufferAllocator *allocator); void requestComplete(libcamera::Request *request); + void sinkRelease(libcamera::FrameBuffer *buffer); std::shared_ptr camera_; libcamera::CameraConfiguration *config_; libcamera::StreamRoles roles_; std::map streamName_; - BufferWriter *writer_; + FrameSink *sink_; std::chrono::steady_clock::time_point last_; }; From patchwork Tue May 19 03:25:01 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: Laurent Pinchart X-Patchwork-Id: 3815 X-Patchwork-Delegate: laurent.pinchart@ideasonboard.com Return-Path: Received: from perceval.ideasonboard.com (perceval.ideasonboard.com [213.167.242.64]) by lancelot.ideasonboard.com (Postfix) with ESMTPS id D4B1B603D6 for ; Tue, 19 May 2020 05:25:19 +0200 (CEST) Authentication-Results: lancelot.ideasonboard.com; dkim=pass (1024-bit key; unprotected) header.d=ideasonboard.com header.i=@ideasonboard.com header.b="R8dOyCzj"; dkim-atps=neutral Received: from pendragon.bb.dnainternet.fi (81-175-216-236.bb.dnainternet.fi [81.175.216.236]) by perceval.ideasonboard.com (Postfix) with ESMTPSA id 7AF0B30C for ; Tue, 19 May 2020 05:25:19 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=ideasonboard.com; s=mail; t=1589858719; bh=l3/7Y0VQ24TJkmu2AhPJYKcG0R0h94aW+5rUePXqJ68=; h=From:To:Subject:Date:In-Reply-To:References:From; b=R8dOyCzjgGhyn460Fxh+cQQPOb0Q4TsOwXtCW0WWBZ9hU8n+RhVsEXtHkEROHu514 /ltL315Dghk9k8ywcp5ADRwqVOVFpTKjpkWThRZEgMl7c3LJQLf75+rZa81z1SvLMk 60LWiFgHYLVmmgRFIkclNi2nWkDLLGztpF+8+uRs= From: Laurent Pinchart To: libcamera-devel@lists.libcamera.org Date: Tue, 19 May 2020 06:25:01 +0300 Message-Id: <20200519032505.17307-5-laurent.pinchart@ideasonboard.com> X-Mailer: git-send-email 2.26.2 In-Reply-To: <20200519032505.17307-1-laurent.pinchart@ideasonboard.com> References: <20200519032505.17307-1-laurent.pinchart@ideasonboard.com> MIME-Version: 1.0 Subject: [libcamera-devel] [PATCH 4/8] cam: Rename BufferWriter to FileSink X-BeenThere: libcamera-devel@lists.libcamera.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Tue, 19 May 2020 03:25:21 -0000 Rename the BufferWriter class to FileSink to establish a common naming scheme for all sinks. Signed-off-by: Laurent Pinchart Reviewed-by: Niklas Söderlund --- src/cam/capture.cpp | 6 +++--- src/cam/{buffer_writer.cpp => file_sink.cpp} | 14 +++++++------- src/cam/{buffer_writer.h => file_sink.h} | 14 +++++++------- src/cam/meson.build | 2 +- 4 files changed, 18 insertions(+), 18 deletions(-) rename src/cam/{buffer_writer.cpp => file_sink.cpp} (85%) rename src/cam/{buffer_writer.h => file_sink.h} (70%) diff --git a/src/cam/capture.cpp b/src/cam/capture.cpp index 7fc9cba48892..6982d89fabe7 100644 --- a/src/cam/capture.cpp +++ b/src/cam/capture.cpp @@ -11,8 +11,8 @@ #include #include -#include "buffer_writer.h" #include "capture.h" +#include "file_sink.h" #include "main.h" using namespace libcamera; @@ -48,9 +48,9 @@ int Capture::run(EventLoop *loop, const OptionsParser::Options &options) if (options.isSet(OptFile)) { if (!options[OptFile].toString().empty()) - sink_ = new BufferWriter(options[OptFile]); + sink_ = new FileSink(options[OptFile]); else - sink_ = new BufferWriter(); + sink_ = new FileSink(); } if (sink_) { diff --git a/src/cam/buffer_writer.cpp b/src/cam/file_sink.cpp similarity index 85% rename from src/cam/buffer_writer.cpp rename to src/cam/file_sink.cpp index 2bec4b132155..225f3d2200c1 100644 --- a/src/cam/buffer_writer.cpp +++ b/src/cam/file_sink.cpp @@ -2,7 +2,7 @@ /* * Copyright (C) 2019, Google Inc. * - * buffer_writer.cpp - Buffer writer + * file_sink.cpp - File Sink */ #include @@ -15,16 +15,16 @@ #include -#include "buffer_writer.h" +#include "file_sink.h" using namespace libcamera; -BufferWriter::BufferWriter(const std::string &pattern) +FileSink::FileSink(const std::string &pattern) : pattern_(pattern) { } -BufferWriter::~BufferWriter() +FileSink::~FileSink() { for (auto &iter : mappedBuffers_) { void *memory = iter.second.first; @@ -34,7 +34,7 @@ BufferWriter::~BufferWriter() mappedBuffers_.clear(); } -int BufferWriter::configure(const libcamera::CameraConfiguration &config) +int FileSink::configure(const libcamera::CameraConfiguration &config) { int ret = FrameSink::configure(config); if (ret < 0) @@ -49,7 +49,7 @@ int BufferWriter::configure(const libcamera::CameraConfiguration &config) return 0; } -void BufferWriter::mapBuffer(FrameBuffer *buffer) +void FileSink::mapBuffer(FrameBuffer *buffer) { for (const FrameBuffer::Plane &plane : buffer->planes()) { void *memory = mmap(NULL, plane.length, PROT_READ, MAP_SHARED, @@ -60,7 +60,7 @@ void BufferWriter::mapBuffer(FrameBuffer *buffer) } } -bool BufferWriter::consumeBuffer(const Stream *stream, FrameBuffer *buffer) +bool FileSink::consumeBuffer(const Stream *stream, FrameBuffer *buffer) { std::string filename; size_t pos; diff --git a/src/cam/buffer_writer.h b/src/cam/file_sink.h similarity index 70% rename from src/cam/buffer_writer.h rename to src/cam/file_sink.h index 5a5b176f73d8..9d427918a785 100644 --- a/src/cam/buffer_writer.h +++ b/src/cam/file_sink.h @@ -2,10 +2,10 @@ /* * Copyright (C) 2019, Google Inc. * - * buffer_writer.h - Buffer writer + * file_sink.h - File Sink */ -#ifndef __CAM_BUFFER_WRITER_H__ -#define __CAM_BUFFER_WRITER_H__ +#ifndef __CAM_FILE_SINK_H__ +#define __CAM_FILE_SINK_H__ #include #include @@ -14,11 +14,11 @@ #include "frame_sink.h" -class BufferWriter : public FrameSink +class FileSink : public FrameSink { public: - BufferWriter(const std::string &pattern = "frame-#.bin"); - ~BufferWriter(); + FileSink(const std::string &pattern = "frame-#.bin"); + ~FileSink(); int configure(const libcamera::CameraConfiguration &config) override; @@ -33,4 +33,4 @@ private: std::map> mappedBuffers_; }; -#endif /* __CAM_BUFFER_WRITER_H__ */ +#endif /* __CAM_FILE_SINK_H__ */ diff --git a/src/cam/meson.build b/src/cam/meson.build index d7b72ec02f8c..6ba49e82fbd1 100644 --- a/src/cam/meson.build +++ b/src/cam/meson.build @@ -1,9 +1,9 @@ # SPDX-License-Identifier: CC0-1.0 cam_sources = files([ - 'buffer_writer.cpp', 'capture.cpp', 'event_loop.cpp', + 'file_sink.cpp', 'frame_sink.cpp', 'main.cpp', 'options.cpp', From patchwork Tue May 19 03:25:02 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Laurent Pinchart X-Patchwork-Id: 3816 X-Patchwork-Delegate: laurent.pinchart@ideasonboard.com Return-Path: Received: from perceval.ideasonboard.com (perceval.ideasonboard.com [IPv6:2001:4b98:dc2:55:216:3eff:fef7:d647]) by lancelot.ideasonboard.com (Postfix) with ESMTPS id 61A2B60E3A for ; Tue, 19 May 2020 05:25:20 +0200 (CEST) Authentication-Results: lancelot.ideasonboard.com; dkim=pass (1024-bit key; unprotected) header.d=ideasonboard.com header.i=@ideasonboard.com header.b="BVKl8yYR"; dkim-atps=neutral Received: from pendragon.bb.dnainternet.fi (81-175-216-236.bb.dnainternet.fi [81.175.216.236]) by perceval.ideasonboard.com (Postfix) with ESMTPSA id CAFF49CD for ; Tue, 19 May 2020 05:25:19 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=ideasonboard.com; s=mail; t=1589858720; bh=pVnkRRDLRmwusKRSntd0NNVubZZda3Fh7S1LinbKcGU=; h=From:To:Subject:Date:In-Reply-To:References:From; b=BVKl8yYRdIReLxK4/DYRYpwG8zvQCfWwen4ip6UXjuzgJTAZzyHj3vpzlM89pdVCx oCnyileKlvvCR7RjtTZwsIUy5dcEX5HHTHXURs1FyTIPmLncUJZkC6UT9Xkbzcxt5a 7FfixeA1sPQVbmvz06MKf1EciAg+YGV7TrlSre8o= From: Laurent Pinchart To: libcamera-devel@lists.libcamera.org Date: Tue, 19 May 2020 06:25:02 +0300 Message-Id: <20200519032505.17307-6-laurent.pinchart@ideasonboard.com> X-Mailer: git-send-email 2.26.2 In-Reply-To: <20200519032505.17307-1-laurent.pinchart@ideasonboard.com> References: <20200519032505.17307-1-laurent.pinchart@ideasonboard.com> MIME-Version: 1.0 Subject: [libcamera-devel] [PATCH 5/8] cam: Add DRM helper classes X-BeenThere: libcamera-devel@lists.libcamera.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Tue, 19 May 2020 03:25:21 -0000 To prepare for viewfinder operation through the DRM/KMS API, add a set of helper classes that encapsulate the libdrm functions. Signed-off-by: Laurent Pinchart --- src/cam/drm.cpp | 661 ++++++++++++++++++++++++++++++++++++++++++++ src/cam/drm.h | 334 ++++++++++++++++++++++ src/cam/meson.build | 14 +- 3 files changed, 1008 insertions(+), 1 deletion(-) create mode 100644 src/cam/drm.cpp create mode 100644 src/cam/drm.h diff --git a/src/cam/drm.cpp b/src/cam/drm.cpp new file mode 100644 index 000000000000..c0677b1337d7 --- /dev/null +++ b/src/cam/drm.cpp @@ -0,0 +1,661 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ +/* + * Copyright (C) 2020, Ideas on Board Oy + * + * drm.cpp - DRM/KMS Helpers + */ + +/* Include our own copy of drm_mode.h first. */ +#include + +#include "drm.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +namespace DRM { + +Object::Object(Device *dev, uint32_t id, Type type) + : id_(id), dev_(dev), type_(type) +{ + /* Retrieve properties from the objects that support them. */ + if (type != TypeConnector && type != TypeCrtc && + type != TypeEncoder && type != TypePlane) + return; + + /* + * We can't distinguish between failures due to the object having no + * property and failures due to other conditions. Assume we use the API + * correctly and consider the object has no property. + */ + drmModeObjectProperties *properties = drmModeObjectGetProperties(dev->fd(), id, type); + if (!properties) + return; + + properties_.reserve(properties->count_props); + for (uint32_t i = 0; i < properties->count_props; ++i) + properties_.emplace_back(properties->props[i], + properties->prop_values[i]); + + drmModeFreeObjectProperties(properties); +} + +Object::~Object() +{ +} + +const Property *Object::property(const std::string &name) const +{ + for (const PropertyValue &pv : properties_) { + const Property *property = static_cast(dev_->object(pv.id())); + if (property && property->name() == name) + return property; + } + + return nullptr; +} + +const PropertyValue *Object::propertyValue(const std::string &name) const +{ + for (const PropertyValue &pv : properties_) { + const Property *property = static_cast(dev_->object(pv.id())); + if (property && property->name() == name) + return &pv; + } + + return nullptr; +} + +Property::Property(Device *dev, drmModePropertyRes *property) + : Object(dev, property->prop_id, TypeProperty), + name_(property->name), flags_(property->flags), + values_(property->values, property->values + property->count_values), + blobs_(property->blob_ids, property->blob_ids + property->count_blobs) +{ + if (drm_property_type_is(property, DRM_MODE_PROP_RANGE)) + type_ = TypeRange; + else if (drm_property_type_is(property, DRM_MODE_PROP_ENUM)) + type_ = TypeEnum; + else if (drm_property_type_is(property, DRM_MODE_PROP_BLOB)) + type_ = TypeBlob; + else if (drm_property_type_is(property, DRM_MODE_PROP_BITMASK)) + type_ = TypeBitmask; + else if (drm_property_type_is(property, DRM_MODE_PROP_OBJECT)) + type_ = TypeObject; + else if (drm_property_type_is(property, DRM_MODE_PROP_SIGNED_RANGE)) + type_ = TypeSignedRange; + else + type_ = TypeUnknown; + + for (int i = 0; i < property->count_enums; ++i) + enums_[property->enums[i].value] = property->enums[i].name; +} + +Blob::Blob(Device *dev, const libcamera::Span &data) + : Object(dev, 0, Object::TypeBlob) +{ + drmModeCreatePropertyBlob(dev->fd(), data.data(), data.size(), &id_); +} + +Blob::~Blob() +{ + if (isValid()) + drmModeDestroyPropertyBlob(device()->fd(), id()); +} + +Mode::Mode(const drmModeModeInfo &mode) + : drmModeModeInfo(mode) +{ +} + +std::unique_ptr Mode::toBlob(Device *dev) const +{ + libcamera::Span data{ reinterpret_cast(this), + sizeof(*this) }; + return std::make_unique(dev, data); +} + +Crtc::Crtc(Device *dev, const drmModeCrtc *crtc, unsigned int index) + : Object(dev, crtc->crtc_id, Object::TypeCrtc), index_(index) +{ +} + +Encoder::Encoder(Device *dev, const drmModeEncoder *encoder) + : Object(dev, encoder->encoder_id, Object::TypeEncoder), + type_(encoder->encoder_type) +{ + const std::list &crtcs = dev->crtcs(); + possibleCrtcs_.reserve(crtcs.size()); + + for (const Crtc &crtc : crtcs) { + if (encoder->possible_crtcs & (1 << crtc.index())) + possibleCrtcs_.push_back(&crtc); + } + + possibleCrtcs_.shrink_to_fit(); +} + +namespace { + +const std::map connectorTypeNames{ + { DRM_MODE_CONNECTOR_Unknown, "Unknown" }, + { DRM_MODE_CONNECTOR_VGA, "VGA" }, + { DRM_MODE_CONNECTOR_DVII, "DVI-I" }, + { DRM_MODE_CONNECTOR_DVID, "DVI-D" }, + { DRM_MODE_CONNECTOR_DVIA, "DVI-A" }, + { DRM_MODE_CONNECTOR_Composite, "Composite" }, + { DRM_MODE_CONNECTOR_SVIDEO, "S-Video" }, + { DRM_MODE_CONNECTOR_LVDS, "LVDS" }, + { DRM_MODE_CONNECTOR_Component, "Component" }, + { DRM_MODE_CONNECTOR_9PinDIN, "9-Pin-DIN" }, + { DRM_MODE_CONNECTOR_DisplayPort, "DP" }, + { DRM_MODE_CONNECTOR_HDMIA, "HDMI-A" }, + { DRM_MODE_CONNECTOR_HDMIB, "HDMI-B" }, + { DRM_MODE_CONNECTOR_TV, "TV" }, + { DRM_MODE_CONNECTOR_eDP, "eDP" }, + { DRM_MODE_CONNECTOR_VIRTUAL, "Virtual" }, + { DRM_MODE_CONNECTOR_DSI, "DSI" }, + { DRM_MODE_CONNECTOR_DPI, "DPI" }, + { DRM_MODE_CONNECTOR_WRITEBACK, "writeback" }, +}; + +} /* namespace */ + +Connector::Connector(Device *dev, const drmModeConnector *connector) + : Object(dev, connector->connector_id, Object::TypeConnector), + type_(connector->connector_type) +{ + auto typeName = connectorTypeNames.find(connector->connector_type); + if (typeName == connectorTypeNames.end()) { + std::cerr + << "Invalid connector type " + << connector->connector_type << std::endl; + typeName = connectorTypeNames.find(DRM_MODE_CONNECTOR_Unknown); + } + + name_ = std::string(typeName->second) + "-" + + std::to_string(connector->connector_type_id); + + switch (connector->connection) { + case DRM_MODE_CONNECTED: + status_ = Status::Connected; + break; + + case DRM_MODE_DISCONNECTED: + status_ = Status::Disconnected; + break; + + case DRM_MODE_UNKNOWNCONNECTION: + default: + status_ = Status::Unknown; + break; + } + + const std::list &encoders = dev->encoders(); + + encoders_.reserve(connector->count_encoders); + + for (int i = 0; i < connector->count_encoders; ++i) { + uint32_t encoderId = connector->encoders[i]; + auto encoder = std::find_if(encoders.begin(), encoders.end(), + [=](const Encoder &encoder) { + return encoder.id() == encoderId; + }); + if (encoder == encoders.end()) { + std::cerr + << "Encoder " << encoderId << " not found" + << std::endl; + continue; + } + + encoders_.push_back(&*encoder); + } + + encoders_.shrink_to_fit(); + + modes_ = { connector->modes, connector->modes + connector->count_modes }; +} + +Plane::Plane(Device *dev, const drmModePlane *plane) + : Object(dev, plane->plane_id, Object::TypePlane), + possibleCrtcsMask_(plane->possible_crtcs) +{ + formats_ = { plane->formats, plane->formats + plane->count_formats }; + + const std::list &crtcs = dev->crtcs(); + possibleCrtcs_.reserve(crtcs.size()); + + for (const Crtc &crtc : crtcs) { + if (plane->possible_crtcs & (1 << crtc.index())) + possibleCrtcs_.push_back(&crtc); + } + + possibleCrtcs_.shrink_to_fit(); +} + +bool Plane::supportsFormat(const libcamera::PixelFormat &format) const +{ + return std::find(formats_.begin(), formats_.end(), format.fourcc()) + != formats_.end(); +} + +int Plane::setup() +{ + const PropertyValue *pv = propertyValue("type"); + if (!pv) + return -EINVAL; + + switch (pv->value()) { + case DRM_PLANE_TYPE_OVERLAY: + type_ = TypeOverlay; + break; + + case DRM_PLANE_TYPE_PRIMARY: + type_ = TypePrimary; + break; + + case DRM_PLANE_TYPE_CURSOR: + type_ = TypeCursor; + break; + + default: + return -EINVAL; + } + + return 0; +} + +FrameBuffer::FrameBuffer(Device *dev) + : Object(dev, 0, Object::TypeFb) +{ +} + +FrameBuffer::~FrameBuffer() +{ + for (FrameBuffer::Plane &plane : planes_) { + struct drm_gem_close gem_close = { + .handle = plane.handle, + .pad = 0, + }; + int ret; + + do { + ret = ioctl(device()->fd(), DRM_IOCTL_GEM_CLOSE, &gem_close); + } while (ret == -1 && (errno == EINTR || errno == EAGAIN)); + + if (ret == -1) { + ret = -errno; + std::cerr + << "Failed to close GEM object: " + << strerror(-ret) << std::endl; + } + } + + drmModeRmFB(device()->fd(), id()); +} + +AtomicRequest::AtomicRequest(Device *dev) + : dev_(dev), valid_(true) +{ + request_ = drmModeAtomicAlloc(); + if (!request_) + valid_ = false; +} + +AtomicRequest::~AtomicRequest() +{ + if (request_) + drmModeAtomicFree(request_); +} + +int AtomicRequest::addProperty(const Object *object, const std::string &property, + uint64_t value) +{ + if (!valid_) + return -EINVAL; + + const Property *prop = object->property(property); + if (!prop) { + valid_ = false; + return -EINVAL; + } + + return addProperty(object->id(), prop->id(), value); +} + +int AtomicRequest::addProperty(const Object *object, const std::string &property, + std::unique_ptr blob) +{ + if (!valid_) + return -EINVAL; + + const Property *prop = object->property(property); + if (!prop) { + valid_ = false; + return -EINVAL; + } + + int ret = addProperty(object->id(), prop->id(), blob->id()); + if (ret < 0) + return ret; + + blobs_.emplace_back(std::move(blob)); + + return 0; +} + +int AtomicRequest::addProperty(uint32_t object, uint32_t property, uint64_t value) +{ + int ret = drmModeAtomicAddProperty(request_, object, property, value); + if (ret < 0) { + valid_ = false; + return ret; + } + + return 0; +} + +int AtomicRequest::commit(unsigned int flags) +{ + if (!valid_) + return -EINVAL; + + uint32_t drmFlags = 0; + if (flags & FlagAllowModeset) + drmFlags |= DRM_MODE_ATOMIC_ALLOW_MODESET; + if (flags & FlagAsync) + drmFlags |= DRM_MODE_PAGE_FLIP_EVENT | DRM_MODE_ATOMIC_NONBLOCK; + + return drmModeAtomicCommit(dev_->fd(), request_, drmFlags, this); +} + +Device::Device() + : fd_(-1) +{ +} + +Device::~Device() +{ + if (fd_ != -1) + drmClose(fd_); +} + +int Device::init() +{ + constexpr size_t NODE_NAME_MAX = sizeof("/dev/dri/card255"); + char name[NODE_NAME_MAX]; + int ret; + + /* + * Open the first DRM/KMS device. The libdrm drmOpen*() functions + * require either a module name or a bus ID, which we don't have, so + * bypass them. The automatic module loading and device node creation + * from drmOpen() is of no practical use as any modern system will + * handle that through udev or an equivalent component. + */ + snprintf(name, sizeof(name), "/dev/dri/card%u", 0); + fd_ = open(name, O_RDWR | O_CLOEXEC); + if (fd_ < 0) { + ret = -errno; + std::cerr + << "Failed to open DRM/KMS device " << name << ": " + << strerror(-ret) << std::endl; + return ret; + } + + /* + * Enable the atomic APIs. This also enables automatically the + * universal planes API. + */ + ret = drmSetClientCap(fd_, DRM_CLIENT_CAP_ATOMIC, 1); + if (ret < 0) { + ret = -errno; + std::cerr + << "Failed to enable atomic capability: " + << strerror(-ret) << std::endl; + return ret; + } + + /* List all the resources. */ + ret = getResources(); + if (ret < 0) + return ret; + + notifier_ = new libcamera::EventNotifier(fd_, libcamera::EventNotifier::Read); + notifier_->activated.connect(this, &Device::drmEvent); + + return 0; +} + +int Device::getResources() +{ + int ret; + + std::unique_ptr resources{ + drmModeGetResources(fd_), + &drmModeFreeResources + }; + if (!resources) { + ret = -errno; + std::cerr + << "Failed to get DRM/KMS resources: " + << strerror(-ret) << std::endl; + return ret; + } + + for (int i = 0; i < resources->count_crtcs; ++i) { + drmModeCrtc *crtc = drmModeGetCrtc(fd_, resources->crtcs[i]); + if (!crtc) { + ret = -errno; + std::cerr + << "Failed to get CRTC: " << strerror(-ret) + << std::endl; + return ret; + } + + crtcs_.emplace_back(this, crtc, i); + drmModeFreeCrtc(crtc); + + Crtc &obj = crtcs_.back(); + objects_[obj.id()] = &obj; + } + + for (int i = 0; i < resources->count_encoders; ++i) { + drmModeEncoder *encoder = + drmModeGetEncoder(fd_, resources->encoders[i]); + if (!encoder) { + ret = -errno; + std::cerr + << "Failed to get encoder: " << strerror(-ret) + << std::endl; + return ret; + } + + encoders_.emplace_back(this, encoder); + drmModeFreeEncoder(encoder); + + Encoder &obj = encoders_.back(); + objects_[obj.id()] = &obj; + } + + for (int i = 0; i < resources->count_connectors; ++i) { + drmModeConnector *connector = + drmModeGetConnector(fd_, resources->connectors[i]); + if (!connector) { + ret = -errno; + std::cerr + << "Failed to get connector: " << strerror(-ret) + << std::endl; + return ret; + } + + connectors_.emplace_back(this, connector); + drmModeFreeConnector(connector); + + Connector &obj = connectors_.back(); + objects_[obj.id()] = &obj; + } + + std::unique_ptr planes{ + drmModeGetPlaneResources(fd_), + &drmModeFreePlaneResources + }; + if (!planes) { + ret = -errno; + std::cerr + << "Failed to get DRM/KMS planes: " + << strerror(-ret) << std::endl; + return ret; + } + + for (uint32_t i = 0; i < planes->count_planes; ++i) { + drmModePlane *plane = + drmModeGetPlane(fd_, planes->planes[i]); + if (!plane) { + ret = -errno; + std::cerr + << "Failed to get plane: " << strerror(-ret) + << std::endl; + return ret; + } + + planes_.emplace_back(this, plane); + drmModeFreePlane(plane); + + Plane &obj = planes_.back(); + objects_[obj.id()] = &obj; + } + + /* Set the possible planes for each CRTC. */ + for (Crtc &crtc : crtcs_) { + for (const Plane &plane : planes_) { + if (plane.possibleCrtcsMask_ & (1 << crtc.index())) + crtc.planes_.push_back(&plane); + } + } + + /* Collect all property IDs and create Property instances. */ + std::set properties; + for (const auto &object : objects_) { + for (const PropertyValue &value : object.second->properties()) + properties.insert(value.id()); + } + + for (uint32_t id : properties) { + drmModePropertyRes *property = drmModeGetProperty(fd_, id); + if (!property) { + ret = -errno; + std::cerr + << "Failed to get property: " << strerror(-ret) + << std::endl; + continue; + } + + properties_.emplace_back(this, property); + drmModeFreeProperty(property); + + Property &obj = properties_.back(); + objects_[obj.id()] = &obj; + } + + /* Finally, perform all delayed setup of mode objects. */ + for (auto &object : objects_) { + ret = object.second->setup(); + if (ret < 0) { + std::cerr + << "Failed to setup object " << object.second->id() + << ": " << strerror(-ret) << std::endl; + return ret; + } + } + + return 0; +} + +const Object *Device::object(uint32_t id) +{ + const auto iter = objects_.find(id); + if (iter == objects_.end()) + return nullptr; + + return iter->second; +} + +std::unique_ptr Device::createFrameBuffer( + const libcamera::FrameBuffer &buffer, + const libcamera::PixelFormat &format, + const libcamera::Size &size, unsigned int stride) +{ + std::unique_ptr fb{ new FrameBuffer(this) }; + + uint32_t handles[4] = {}; + uint32_t pitches[4] = {}; + uint32_t offsets[4] = {}; + int ret; + + const std::vector &planes = buffer.planes(); + fb->planes_.reserve(planes.size()); + + unsigned int i = 0; + for (const libcamera::FrameBuffer::Plane &plane : planes) { + uint32_t handle; + + ret = drmPrimeFDToHandle(fd_, plane.fd.fd(), &handle); + if (ret < 0) { + ret = -errno; + std::cerr + << "Unable to import framebuffer dmabuf: " + << strerror(-ret) << std::endl; + return nullptr; + } + + fb->planes_.push_back({ handle }); + + handles[i] = handle; + pitches[i] = stride; + offsets[i] = 0; /* TODO */ + ++i; + } + + ret = drmModeAddFB2(fd_, size.width, size.height, format.fourcc(), handles, + pitches, offsets, &fb->id_, 0); + if (ret < 0) { + ret = -errno; + std::cerr + << "Failed to add framebuffer: " + << strerror(-ret) << std::endl; + return nullptr; + } + + return fb; +} + +void Device::drmEvent(libcamera::EventNotifier *notifier) +{ + drmEventContext ctx{}; + ctx.version = DRM_EVENT_CONTEXT_VERSION; + ctx.page_flip_handler = &Device::pageFlipComplete; + + drmHandleEvent(fd_, &ctx); +} + +void Device::pageFlipComplete(int fd, unsigned int sequence, unsigned int tv_sec, + unsigned int tv_usec, void *user_data) +{ + AtomicRequest *request = static_cast(user_data); + request->device()->requestComplete.emit(request); +} + +} /* namespace DRM */ diff --git a/src/cam/drm.h b/src/cam/drm.h new file mode 100644 index 000000000000..c1c2bab4b121 --- /dev/null +++ b/src/cam/drm.h @@ -0,0 +1,334 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ +/* + * Copyright (C) 2020, Ideas on Board Oy + * + * drm.h - DRM/KMS Helpers + */ +#ifndef __CAM_DRM_H__ +#define __CAM_DRM_H__ + +#include +#include +#include +#include +#include + +#include +#include + +#include +#include +#include + +namespace libcamera { +class EventNotifier; +class FrameBuffer; +class PixelFormat; +struct Size; +} /* namespace libcamera */ + +namespace DRM { + +class Device; +class Plane; +class Property; +class PropertyValue; + +class Object +{ +public: + enum Type { + TypeCrtc = DRM_MODE_OBJECT_CRTC, + TypeConnector = DRM_MODE_OBJECT_CONNECTOR, + TypeEncoder = DRM_MODE_OBJECT_ENCODER, + TypeMode = DRM_MODE_OBJECT_MODE, + TypeProperty = DRM_MODE_OBJECT_PROPERTY, + TypeFb = DRM_MODE_OBJECT_FB, + TypeBlob = DRM_MODE_OBJECT_BLOB, + TypePlane = DRM_MODE_OBJECT_PLANE, + TypeAny = DRM_MODE_OBJECT_ANY, + }; + + Object(Device *dev, uint32_t id, Type type); + virtual ~Object(); + + Device *device() const { return dev_; } + uint32_t id() const { return id_; } + Type type() const { return type_; } + + const Property *property(const std::string &name) const; + const PropertyValue *propertyValue(const std::string &name) const; + const std::vector &properties() const { return properties_; } + +protected: + virtual int setup() + { + return 0; + } + + uint32_t id_; + +private: + friend Device; + + Device *dev_; + Type type_; + std::vector properties_; +}; + +class Property : public Object +{ +public: + enum Type { + TypeUnknown = 0, + TypeRange, + TypeEnum, + TypeBlob, + TypeBitmask, + TypeObject, + TypeSignedRange, + }; + + Property(Device *dev, drmModePropertyRes *property); + + Type type() const { return type_; } + const std::string &name() const { return name_; } + + bool isImmutable() const { return flags_ & DRM_MODE_PROP_IMMUTABLE; } + + const std::vector values() const { return values_; } + const std::map &enums() const { return enums_; } + const std::vector blobs() const { return blobs_; } + +private: + Type type_; + std::string name_; + uint32_t flags_; + std::vector values_; + std::map enums_; + std::vector blobs_; +}; + +class PropertyValue +{ +public: + PropertyValue(uint32_t id, uint64_t value) + : id_(id), value_(value) + { + } + + uint32_t id() const { return id_; } + uint32_t value() const { return value_; } + +private: + uint32_t id_; + uint64_t value_; +}; + +class Blob : public Object +{ +public: + Blob(Device *dev, const libcamera::Span &data); + ~Blob(); + + bool isValid() const { return id() != 0; } +}; + +class Mode : public drmModeModeInfo +{ +public: + Mode(const drmModeModeInfo &mode); + + std::unique_ptr toBlob(Device *dev) const; +}; + +class Crtc : public Object +{ +public: + Crtc(Device *dev, const drmModeCrtc *crtc, unsigned int index); + + unsigned int index() const { return index_; } + const std::vector &planes() const { return planes_; } + +private: + friend Device; + + unsigned int index_; + std::vector planes_; +}; + +class Encoder : public Object +{ +public: + Encoder(Device *dev, const drmModeEncoder *encoder); + + uint32_t type() const { return type_; } + + const std::vector &possibleCrtcs() const { return possibleCrtcs_; } + +private: + uint32_t type_; + std::vector possibleCrtcs_; +}; + +class Connector : public Object +{ +public: + enum Status { + Connected, + Disconnected, + Unknown, + }; + + Connector(Device *dev, const drmModeConnector *connector); + + uint32_t type() const { return type_; } + const std::string &name() const { return name_; } + + Status status() const { return status_; } + + const std::vector &encoders() const { return encoders_; } + const std::vector &modes() const { return modes_; } + +private: + uint32_t type_; + std::string name_; + Status status_; + std::vector encoders_; + std::vector modes_; +}; + +class Plane : public Object +{ +public: + enum Type { + TypeOverlay, + TypePrimary, + TypeCursor, + }; + + Plane(Device *dev, const drmModePlane *plane); + + Type type() const { return type_; } + const std::vector &formats() const { return formats_; } + const std::vector &possibleCrtcs() const { return possibleCrtcs_; } + + bool supportsFormat(const libcamera::PixelFormat &format) const; + +protected: + int setup() override; + +private: + friend class Device; + + Type type_; + std::vector formats_; + std::vector possibleCrtcs_; + uint32_t possibleCrtcsMask_; +}; + +class FrameBuffer : public Object +{ +public: + struct Plane { + uint32_t handle; + }; + + ~FrameBuffer(); + +private: + friend class Device; + + FrameBuffer(Device *dev); + + std::vector planes_; +}; + +class AtomicRequest +{ +public: + enum Flags { + FlagAllowModeset = (1 << 0), + FlagAsync = (1 << 1), + }; + + AtomicRequest(Device *dev); + ~AtomicRequest(); + + Device *device() const { return dev_; } + bool isValid() const { return valid_; } + + int addProperty(const Object *object, const std::string &property, + uint64_t value); + int addProperty(const Object *object, const std::string &property, + std::unique_ptr blob); + int commit(unsigned int flags = 0); + +private: + AtomicRequest(const AtomicRequest &) = delete; + AtomicRequest(const AtomicRequest &&) = delete; + AtomicRequest &operator=(const AtomicRequest &) = delete; + AtomicRequest &operator=(const AtomicRequest &&) = delete; + + int addProperty(uint32_t object, uint32_t property, uint64_t value); + + Device *dev_; + bool valid_; + drmModeAtomicReq *request_; + std::list> blobs_; +}; + +class Device +{ +public: + Device(); + ~Device(); + + int init(); + + int fd() const { return fd_; } + + const std::list &crtcs() const { return crtcs_; } + const std::list &encoders() const { return encoders_; } + const std::list &connectors() const { return connectors_; } + const std::list &planes() const { return planes_; } + const std::list &properties() const { return properties_; } + + const Object *object(uint32_t id); + + std::unique_ptr createFrameBuffer( + const libcamera::FrameBuffer &buffer, + const libcamera::PixelFormat &format, + const libcamera::Size &size, unsigned int stride); + + libcamera::Signal requestComplete; + +private: + Device(const Device &) = delete; + Device(const Device &&) = delete; + Device &operator=(const Device &) = delete; + Device &operator=(const Device &&) = delete; + + int getResources(); + + void drmEvent(libcamera::EventNotifier *notifier); + static void pageFlipComplete(int fd, unsigned int sequence, + unsigned int tv_sec, unsigned int tv_usec, + void *user_data); + + int fd_; + + std::list crtcs_; + std::list encoders_; + std::list connectors_; + std::list planes_; + std::list properties_; + + std::map objects_; + + libcamera::EventNotifier *notifier_; +}; + +} /* namespace DRM */ + +#endif /* __CAM_DRM_H__ */ diff --git a/src/cam/meson.build b/src/cam/meson.build index 6ba49e82fbd1..b0a8a7580dcc 100644 --- a/src/cam/meson.build +++ b/src/cam/meson.build @@ -10,6 +10,18 @@ cam_sources = files([ 'stream_options.cpp', ]) +cam_cpp_args = [] + +libdrm = dependency('libdrm', required : false) + +if libdrm.found() +cam_cpp_args += [ '-DHAVE_KMS' ] +cam_sources += files([ + 'drm.cpp', +]) +endif + cam = executable('cam', cam_sources, - dependencies : [ libatomic, libcamera_dep ], + dependencies : [ libatomic, libcamera_dep, libdrm ], + cpp_args : cam_cpp_args, install : true) From patchwork Tue May 19 03:25:03 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Laurent Pinchart X-Patchwork-Id: 3817 X-Patchwork-Delegate: laurent.pinchart@ideasonboard.com Return-Path: Received: from perceval.ideasonboard.com (perceval.ideasonboard.com [IPv6:2001:4b98:dc2:55:216:3eff:fef7:d647]) by lancelot.ideasonboard.com (Postfix) with ESMTPS id CA2FA60E2A for ; Tue, 19 May 2020 05:25:20 +0200 (CEST) Authentication-Results: lancelot.ideasonboard.com; dkim=pass (1024-bit key; unprotected) header.d=ideasonboard.com header.i=@ideasonboard.com header.b="PzyQVeJB"; dkim-atps=neutral Received: from pendragon.bb.dnainternet.fi (81-175-216-236.bb.dnainternet.fi [81.175.216.236]) by perceval.ideasonboard.com (Postfix) with ESMTPSA id 66F96A1D for ; Tue, 19 May 2020 05:25:20 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=ideasonboard.com; s=mail; t=1589858720; bh=hJfRUAq3ru0Az/WIoLLsQIJq1KuWUmXCJ594x3p2dPU=; h=From:To:Subject:Date:In-Reply-To:References:From; b=PzyQVeJBzklx6fGbC080YZjLLDIguAPC81efJIglrzmO/ARHrj/UbN2PTgrQpUefw Z8g7Efnx5XRQQqtu6loMgF8bggdUq9uA5bwFWyPgzWUZZ9v5wi2Hhp//9XnPDU19fG Sx2JmwU7Xt1jZGxNQBWE1loQ7zTqLy1KZbD/V3DU= From: Laurent Pinchart To: libcamera-devel@lists.libcamera.org Date: Tue, 19 May 2020 06:25:03 +0300 Message-Id: <20200519032505.17307-7-laurent.pinchart@ideasonboard.com> X-Mailer: git-send-email 2.26.2 In-Reply-To: <20200519032505.17307-1-laurent.pinchart@ideasonboard.com> References: <20200519032505.17307-1-laurent.pinchart@ideasonboard.com> MIME-Version: 1.0 Subject: [libcamera-devel] [PATCH 6/8] cam: Add KMS sink class X-BeenThere: libcamera-devel@lists.libcamera.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Tue, 19 May 2020 03:25:21 -0000 Add a KMSSink class to display framebuffers through the DRM/KMS API. Signed-off-by: Laurent Pinchart --- src/cam/kms_sink.cpp | 297 +++++++++++++++++++++++++++++++++++++++++++ src/cam/kms_sink.h | 76 +++++++++++ src/cam/meson.build | 1 + 3 files changed, 374 insertions(+) create mode 100644 src/cam/kms_sink.cpp create mode 100644 src/cam/kms_sink.h diff --git a/src/cam/kms_sink.cpp b/src/cam/kms_sink.cpp new file mode 100644 index 000000000000..85f244ea5413 --- /dev/null +++ b/src/cam/kms_sink.cpp @@ -0,0 +1,297 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ +/* + * Copyright (C) 2020, Ideas on Board Oy + * + * kms_sink.cpp - KMS Sink + */ + +#include "kms_sink.h" + +#include +#include +#include +#include +#include + +#include +#include +#include + +#include "drm.h" + +KMSSink::KMSSink(const std::string &connectorName) + : connector_(nullptr), crtc_(nullptr), plane_(nullptr), mode_(nullptr) +{ + int ret = dev_.init(); + if (ret < 0) + return; + + /* + * Find the requested connector. If no connector is requested, pick the + * first connected connector. + */ + for (const DRM::Connector &conn : dev_.connectors()) { + if (conn.name() == connectorName) { + connector_ = &conn; + break; + } + + if (conn.status() != DRM::Connector::Disconnected) { + if (!connector_ || + (connector_->status() == DRM::Connector::Unknown && + conn.status() == DRM::Connector::Connected)) + connector_ = &conn; + } + } + + if (!connector_) { + if (!connectorName.empty()) + std::cerr + << "Connector " << connectorName << " not found" + << std::endl; + else + std::cerr << "No connected connector found" << std::endl; + return; + } + + dev_.requestComplete.connect(this, &KMSSink::requestComplete); +} + +void KMSSink::mapBuffer(libcamera::FrameBuffer *buffer) +{ + std::unique_ptr drmBuffer = + dev_.createFrameBuffer(*buffer, format_, size_, stride_); + if (!drmBuffer) + return; + + buffers_.emplace(std::piecewise_construct, + std::forward_as_tuple(buffer), + std::forward_as_tuple(std::move(drmBuffer))); +} + +int KMSSink::configure(const libcamera::CameraConfiguration &config) +{ + crtc_ = nullptr; + plane_ = nullptr; + mode_ = nullptr; + + const libcamera::StreamConfiguration &cfg = config.at(0); + int ret = configurePipeline(cfg.pixelFormat); + if (ret < 0) + return ret; + + const std::vector &modes = connector_->modes(); + const auto iter = std::find_if(modes.begin(), modes.end(), + [&](const DRM::Mode &mode) { + return mode.hdisplay == cfg.size.width && + mode.vdisplay == cfg.size.height; + }); + if (iter == modes.end()) { + std::cerr + << "No mode matching " << cfg.size.toString() + << std::endl; + return -EINVAL; + } + + mode_ = &*iter; + size_ = cfg.size; + stride_ = cfg.stride; + + return 0; +} + +int KMSSink::configurePipeline(const libcamera::PixelFormat &format) +{ + /* + * If the requested format has an alpha channel, also consider the X + * variant. + */ + libcamera::PixelFormat xFormat; + + switch (format) { + case DRM_FORMAT_ABGR8888: + xFormat = libcamera::PixelFormat(DRM_FORMAT_XBGR8888); + break; + case DRM_FORMAT_ARGB8888: + xFormat = libcamera::PixelFormat(DRM_FORMAT_XRGB8888); + break; + case DRM_FORMAT_BGRA8888: + xFormat = libcamera::PixelFormat(DRM_FORMAT_BGRX8888); + break; + case DRM_FORMAT_RGBA8888: + xFormat = libcamera::PixelFormat(DRM_FORMAT_RGBX8888); + break; + } + + /* + * Find a CRTC and plane suitable for the request format and the + * connector at the end of the pipeline. Restrict the search to primary + * planes for now. + */ + for (const DRM::Encoder *encoder : connector_->encoders()) { + for (const DRM::Crtc *crtc : encoder->possibleCrtcs()) { + for (const DRM::Plane *plane : crtc->planes()) { + if (plane->type() != DRM::Plane::TypePrimary) + continue; + + if (plane->supportsFormat(format)) { + crtc_ = crtc; + plane_ = plane; + format_ = format; + return 0; + } + + if (plane->supportsFormat(xFormat)) { + crtc_ = crtc; + plane_ = plane; + format_ = xFormat; + return 0; + } + } + } + } + + std::cerr + << "Unable to find display pipeline for format " + << format.toString() << std::endl; + return -EPIPE; +} + +int KMSSink::start() +{ + std::unique_ptr request; + + int ret = FrameSink::start(); + if (ret < 0) + return ret; + + /* Disable all CRTCs and planes to start from a known valid state. */ + request = std::make_unique(&dev_); + + for (const DRM::Crtc &crtc : dev_.crtcs()) + request->addProperty(&crtc, "ACTIVE", 0); + + for (const DRM::Plane &plane : dev_.planes()) { + request->addProperty(&plane, "CRTC_ID", 0); + request->addProperty(&plane, "FB_ID", 0); + } + + ret = request->commit(DRM::AtomicRequest::FlagAllowModeset); + if (ret < 0) { + std::cerr + << "Failed to disable CRTCs and planes: " + << strerror(-ret) << std::endl; + return ret; + } + + /* Enable the display pipeline with no plane to start with. */ + request = std::make_unique(&dev_); + + request->addProperty(connector_, "CRTC_ID", crtc_->id()); + request->addProperty(crtc_, "ACTIVE", 1); + request->addProperty(crtc_, "MODE_ID", mode_->toBlob(&dev_)); + + ret = request->commit(DRM::AtomicRequest::FlagAllowModeset); + if (ret < 0) { + std::cerr + << "Failed to enable display pipeline: " + << strerror(-ret) << std::endl; + return ret; + } + + planeInitialized_ = false; + + return 0; +} + +int KMSSink::stop() +{ + /* Display pipeline. */ + DRM::AtomicRequest request(&dev_); + + request.addProperty(connector_, "CRTC_ID", 0); + request.addProperty(crtc_, "ACTIVE", 0); + request.addProperty(crtc_, "MODE_ID", 0); + request.addProperty(plane_, "CRTC_ID", 0); + request.addProperty(plane_, "FB_ID", 0); + + int ret = request.commit(DRM::AtomicRequest::FlagAllowModeset); + if (ret < 0) { + std::cerr + << "Failed to stop display pipeline: " + << strerror(-ret) << std::endl; + return ret; + } + + /* Free all buffers. */ + pending_.reset(); + queued_.reset(); + active_.reset(); + buffers_.clear(); + + return FrameSink::stop(); +} + +bool KMSSink::consumeBuffer(const libcamera::Stream *stream, + libcamera::FrameBuffer *buffer) +{ + if (pending_) + return true; + + auto iter = buffers_.find(buffer); + if (iter == buffers_.end()) + return true; + + DRM::FrameBuffer *drmBuffer = iter->second.get(); + + DRM::AtomicRequest *request = new DRM::AtomicRequest(&dev_); + request->addProperty(plane_, "FB_ID", drmBuffer->id()); + + if (!planeInitialized_) { + request->addProperty(plane_, "CRTC_ID", crtc_->id()); + request->addProperty(plane_, "SRC_X", 0 << 16); + request->addProperty(plane_, "SRC_Y", 0 << 16); + request->addProperty(plane_, "SRC_W", mode_->hdisplay << 16); + request->addProperty(plane_, "SRC_H", mode_->vdisplay << 16); + request->addProperty(plane_, "CRTC_X", 0); + request->addProperty(plane_, "CRTC_Y", 0); + request->addProperty(plane_, "CRTC_W", mode_->hdisplay); + request->addProperty(plane_, "CRTC_H", mode_->vdisplay); + planeInitialized_ = true; + } + + pending_ = std::make_unique(request, buffer); + + std::lock_guard lock(lock_); + + if (!queued_) { + int ret = request->commit(DRM::AtomicRequest::FlagAsync); + if (ret < 0) + std::cerr + << "Failed to commit atomic request: " + << strerror(-ret) << std::endl; + queued_ = std::move(pending_); + } + + return false; +} + +void KMSSink::requestComplete(DRM::AtomicRequest *request) +{ + std::lock_guard lock(lock_); + + assert(queued_ && queued_->request_.get() == request); + + /* Complete the active request, if any. */ + if (active_) + bufferReleased.emit(active_->buffer_); + + /* The queued request becomes active. */ + active_ = std::move(queued_); + + /* Queue the pending request, if any. */ + if (pending_) { + pending_->request_->commit(DRM::AtomicRequest::FlagAsync); + queued_ = std::move(pending_); + } +} diff --git a/src/cam/kms_sink.h b/src/cam/kms_sink.h new file mode 100644 index 000000000000..ee257a071c24 --- /dev/null +++ b/src/cam/kms_sink.h @@ -0,0 +1,76 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ +/* + * Copyright (C) 2020, Ideas on Board Oy + * + * kms_sink.h - KMS Sink + */ +#ifndef __CAM_KMS_SINK_H__ +#define __CAM_KMS_SINK_H__ + +#include +#include +#include +#include +#include + +#include +#include +#include + +#include "drm.h" +#include "frame_sink.h" + +class KMSSink : public FrameSink +{ +public: + KMSSink(const std::string &connectorName); + + bool isValid() const { return connector_ != nullptr; } + + void mapBuffer(libcamera::FrameBuffer *buffer) override; + + int configure(const libcamera::CameraConfiguration &config) override; + int start() override; + int stop() override; + + bool consumeBuffer(const libcamera::Stream *stream, + libcamera::FrameBuffer *buffer) override; + +private: + class Request + { + public: + Request(DRM::AtomicRequest *request, libcamera::FrameBuffer *buffer) + : request_(request), buffer_(buffer) + { + } + + std::unique_ptr request_; + libcamera::FrameBuffer *buffer_; + }; + + int configurePipeline(const libcamera::PixelFormat &format); + void requestComplete(DRM::AtomicRequest *request); + + DRM::Device dev_; + + const DRM::Connector *connector_; + const DRM::Crtc *crtc_; + const DRM::Plane *plane_; + const DRM::Mode *mode_; + + libcamera::PixelFormat format_; + libcamera::Size size_; + unsigned int stride_; + + bool planeInitialized_; + + std::map> buffers_; + + std::mutex lock_; + std::unique_ptr pending_; + std::unique_ptr queued_; + std::unique_ptr active_; +}; + +#endif /* __CAM_KMS_SINK_H__ */ diff --git a/src/cam/meson.build b/src/cam/meson.build index b0a8a7580dcc..55f37ed7b323 100644 --- a/src/cam/meson.build +++ b/src/cam/meson.build @@ -18,6 +18,7 @@ if libdrm.found() cam_cpp_args += [ '-DHAVE_KMS' ] cam_sources += files([ 'drm.cpp', + 'kms_sink.cpp' ]) endif From patchwork Tue May 19 03:25:04 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Laurent Pinchart X-Patchwork-Id: 3818 X-Patchwork-Delegate: laurent.pinchart@ideasonboard.com Return-Path: Received: from perceval.ideasonboard.com (perceval.ideasonboard.com [213.167.242.64]) by lancelot.ideasonboard.com (Postfix) with ESMTPS id 2998B60E4C for ; Tue, 19 May 2020 05:25:21 +0200 (CEST) Authentication-Results: lancelot.ideasonboard.com; dkim=pass (1024-bit key; unprotected) header.d=ideasonboard.com header.i=@ideasonboard.com header.b="VH4OH4kr"; dkim-atps=neutral Received: from pendragon.bb.dnainternet.fi (81-175-216-236.bb.dnainternet.fi [81.175.216.236]) by perceval.ideasonboard.com (Postfix) with ESMTPSA id B80169CD for ; Tue, 19 May 2020 05:25:20 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=ideasonboard.com; s=mail; t=1589858720; bh=//ySr8lEYKBd9z1OWpP/SzhuiA6MxFQlyZEJhG4r/GM=; h=From:To:Subject:Date:In-Reply-To:References:From; b=VH4OH4kr3WYTzsmXr345blGj6KML+aaGGzIIpy1JvPx77wydi7wi8aWXFICM2I1qc JD4bZ7xWxAs3GT3c/MNmkeUgVWc+FTVnIG0Lr5SiqqectHMFX6keC4uMAS6+CNjgX+ p2p5Kd2Pb/E6yM5GTUvfwGh+R79JOBeomz0WYfqg= From: Laurent Pinchart To: libcamera-devel@lists.libcamera.org Date: Tue, 19 May 2020 06:25:04 +0300 Message-Id: <20200519032505.17307-8-laurent.pinchart@ideasonboard.com> X-Mailer: git-send-email 2.26.2 In-Reply-To: <20200519032505.17307-1-laurent.pinchart@ideasonboard.com> References: <20200519032505.17307-1-laurent.pinchart@ideasonboard.com> MIME-Version: 1.0 Subject: [libcamera-devel] [PATCH 7/8] cam: kms_sink: Enable display on first frame X-BeenThere: libcamera-devel@lists.libcamera.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Tue, 19 May 2020 03:25:21 -0000 Not all display controllers support enabling the display without any active plane. Delay display enabling to the first frame. Signed-off-by: Laurent Pinchart --- src/cam/kms_sink.cpp | 31 +++++++++++-------------------- src/cam/kms_sink.h | 2 -- 2 files changed, 11 insertions(+), 22 deletions(-) diff --git a/src/cam/kms_sink.cpp b/src/cam/kms_sink.cpp index 85f244ea5413..a769255c022e 100644 --- a/src/cam/kms_sink.cpp +++ b/src/cam/kms_sink.cpp @@ -184,23 +184,6 @@ int KMSSink::start() return ret; } - /* Enable the display pipeline with no plane to start with. */ - request = std::make_unique(&dev_); - - request->addProperty(connector_, "CRTC_ID", crtc_->id()); - request->addProperty(crtc_, "ACTIVE", 1); - request->addProperty(crtc_, "MODE_ID", mode_->toBlob(&dev_)); - - ret = request->commit(DRM::AtomicRequest::FlagAllowModeset); - if (ret < 0) { - std::cerr - << "Failed to enable display pipeline: " - << strerror(-ret) << std::endl; - return ret; - } - - planeInitialized_ = false; - return 0; } @@ -244,10 +227,17 @@ bool KMSSink::consumeBuffer(const libcamera::Stream *stream, DRM::FrameBuffer *drmBuffer = iter->second.get(); + unsigned int flags = DRM::AtomicRequest::FlagAsync; DRM::AtomicRequest *request = new DRM::AtomicRequest(&dev_); request->addProperty(plane_, "FB_ID", drmBuffer->id()); - if (!planeInitialized_) { + if (!active_ && !queued_) { + /* Enable the display pipeline on the first frame. */ + request->addProperty(connector_, "CRTC_ID", crtc_->id()); + + request->addProperty(crtc_, "ACTIVE", 1); + request->addProperty(crtc_, "MODE_ID", mode_->toBlob(&dev_)); + request->addProperty(plane_, "CRTC_ID", crtc_->id()); request->addProperty(plane_, "SRC_X", 0 << 16); request->addProperty(plane_, "SRC_Y", 0 << 16); @@ -257,7 +247,8 @@ bool KMSSink::consumeBuffer(const libcamera::Stream *stream, request->addProperty(plane_, "CRTC_Y", 0); request->addProperty(plane_, "CRTC_W", mode_->hdisplay); request->addProperty(plane_, "CRTC_H", mode_->vdisplay); - planeInitialized_ = true; + + flags |= DRM::AtomicRequest::FlagAllowModeset; } pending_ = std::make_unique(request, buffer); @@ -265,7 +256,7 @@ bool KMSSink::consumeBuffer(const libcamera::Stream *stream, std::lock_guard lock(lock_); if (!queued_) { - int ret = request->commit(DRM::AtomicRequest::FlagAsync); + int ret = request->commit(flags); if (ret < 0) std::cerr << "Failed to commit atomic request: " diff --git a/src/cam/kms_sink.h b/src/cam/kms_sink.h index ee257a071c24..0879bb559e5a 100644 --- a/src/cam/kms_sink.h +++ b/src/cam/kms_sink.h @@ -63,8 +63,6 @@ private: libcamera::Size size_; unsigned int stride_; - bool planeInitialized_; - std::map> buffers_; std::mutex lock_; From patchwork Tue May 19 03:25:05 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Laurent Pinchart X-Patchwork-Id: 3819 X-Patchwork-Delegate: laurent.pinchart@ideasonboard.com Return-Path: Received: from perceval.ideasonboard.com (perceval.ideasonboard.com [IPv6:2001:4b98:dc2:55:216:3eff:fef7:d647]) by lancelot.ideasonboard.com (Postfix) with ESMTPS id 776AF603D6 for ; Tue, 19 May 2020 05:25:21 +0200 (CEST) Authentication-Results: lancelot.ideasonboard.com; dkim=pass (1024-bit key; unprotected) header.d=ideasonboard.com header.i=@ideasonboard.com header.b="e5xcoQxI"; dkim-atps=neutral Received: from pendragon.bb.dnainternet.fi (81-175-216-236.bb.dnainternet.fi [81.175.216.236]) by perceval.ideasonboard.com (Postfix) with ESMTPSA id 1F232A1D for ; Tue, 19 May 2020 05:25:21 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=ideasonboard.com; s=mail; t=1589858721; bh=llEFdOHZMlyTyvwrTy2Iz0NNyRtg8yxj4chub2uUds4=; h=From:To:Subject:Date:In-Reply-To:References:From; b=e5xcoQxIbu//oIJTFm4xazYNbeo71XpEgxI3mM7FzrBDJ5XQOLiSZPzknL7ILl/BQ ntF69DUIqw1Qs4HSFEI1xhbOD1ROmGlkgSsgsBkzzrYNFTzi4li2bixx4i2JrHXk8q C0FNkqZbBHvK3coyGdCYBN/pJ0D6YUZOJ7KqARvk= From: Laurent Pinchart To: libcamera-devel@lists.libcamera.org Date: Tue, 19 May 2020 06:25:05 +0300 Message-Id: <20200519032505.17307-9-laurent.pinchart@ideasonboard.com> X-Mailer: git-send-email 2.26.2 In-Reply-To: <20200519032505.17307-1-laurent.pinchart@ideasonboard.com> References: <20200519032505.17307-1-laurent.pinchart@ideasonboard.com> MIME-Version: 1.0 Subject: [libcamera-devel] [PATCH 8/8] cam: Add support for viewfinder through DRM/KMS X-BeenThere: libcamera-devel@lists.libcamera.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Tue, 19 May 2020 03:25:22 -0000 Use the KMSSink class to display the viewfinder stream, if any, through DRM/KMS. The output connector is selected through the new -D/--display argument. Signed-off-by: Laurent Pinchart --- src/cam/capture.cpp | 21 +++++++++++++++++++++ src/cam/main.cpp | 11 +++++++++++ src/cam/main.h | 1 + 3 files changed, 33 insertions(+) diff --git a/src/cam/capture.cpp b/src/cam/capture.cpp index 6982d89fabe7..5b25b2c239f8 100644 --- a/src/cam/capture.cpp +++ b/src/cam/capture.cpp @@ -13,6 +13,9 @@ #include "capture.h" #include "file_sink.h" +#ifdef HAVE_KMS +#include "kms_sink.h" +#endif #include "main.h" using namespace libcamera; @@ -46,6 +49,24 @@ int Capture::run(EventLoop *loop, const OptionsParser::Options &options) camera_->requestCompleted.connect(this, &Capture::requestComplete); +#ifdef HAVE_KMS + if (options.isSet(OptDisplay)) { + if (config_->size() != 1) { + std::cout << "Display doesn't support multiple streams" + << std::endl; + return -EINVAL; + } + + if (roles_[0] != StreamRole::Viewfinder) { + std::cout << "Display requires a viewfinder stream" + << std::endl; + return -EINVAL; + } + + sink_ = new KMSSink(options[OptDisplay].toString()); + } +#endif + if (options.isSet(OptFile)) { if (!options[OptFile].toString().empty()) sink_ = new FileSink(options[OptFile]); diff --git a/src/cam/main.cpp b/src/cam/main.cpp index cdd29d500202..5cd1e929bd88 100644 --- a/src/cam/main.cpp +++ b/src/cam/main.cpp @@ -78,6 +78,12 @@ int CamApp::init(int argc, char **argv) if (ret < 0) return ret; + if (options_.isSet(OptDisplay) && options_.isSet(OptFile)) { + std::cout << "--display and --file options are mutually exclusive" + << std::endl; + return -EINVAL; + } + cm_ = new CameraManager(); ret = cm_->start(); @@ -164,6 +170,11 @@ int CamApp::parseOptions(int argc, char *argv[]) ArgumentRequired, "camera"); parser.addOption(OptCapture, OptionNone, "Capture until interrupted by user", "capture"); +#ifdef HAVE_KMS + parser.addOption(OptDisplay, OptionString, + "Display viewfinder through DRM/KMS on specified connector", + "display", ArgumentOptional, "connector"); +#endif parser.addOption(OptFile, OptionString, "Write captured frames to disk\n" "The first '#' character in the file name is expanded to the stream name and frame sequence number.\n" diff --git a/src/cam/main.h b/src/cam/main.h index 4a130d8dd290..57eece507a16 100644 --- a/src/cam/main.h +++ b/src/cam/main.h @@ -10,6 +10,7 @@ enum { OptCamera = 'c', OptCapture = 'C', + OptDisplay = 'D', OptFile = 'F', OptHelp = 'h', OptInfo = 'I',