summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/android/camera_device.cpp2
-rw-r--r--src/ipa/raspberrypi/raspberrypi.cpp4
-rw-r--r--src/libcamera/base/file.cpp1
-rw-r--r--src/libcamera/base/file_descriptor.cpp266
-rw-r--r--src/libcamera/base/meson.build2
-rw-r--r--src/libcamera/base/shared_fd.cpp262
-rw-r--r--src/libcamera/framebuffer.cpp10
-rw-r--r--src/libcamera/ipa_data_serializer.cpp100
-rw-r--r--src/libcamera/ipc_pipe.cpp4
-rw-r--r--src/libcamera/pipeline/raspberrypi/raspberrypi.cpp6
-rw-r--r--src/libcamera/v4l2_videodevice.cpp12
-rw-r--r--src/v4l2/v4l2_camera.h2
12 files changed, 334 insertions, 337 deletions
diff --git a/src/android/camera_device.cpp b/src/android/camera_device.cpp
index db400e74..9f772b58 100644
--- a/src/android/camera_device.cpp
+++ b/src/android/camera_device.cpp
@@ -743,7 +743,7 @@ CameraDevice::createFrameBuffer(const buffer_handle_t camera3buffer,
std::vector<FrameBuffer::Plane> planes(buf.numPlanes());
for (size_t i = 0; i < buf.numPlanes(); ++i) {
- FileDescriptor fd{ camera3buffer->data[i] };
+ SharedFD fd{ camera3buffer->data[i] };
if (!fd.isValid()) {
LOG(HAL, Fatal) << "No valid fd";
return nullptr;
diff --git a/src/ipa/raspberrypi/raspberrypi.cpp b/src/ipa/raspberrypi/raspberrypi.cpp
index c6aec090..aaf629ee 100644
--- a/src/ipa/raspberrypi/raspberrypi.cpp
+++ b/src/ipa/raspberrypi/raspberrypi.cpp
@@ -15,8 +15,8 @@
#include <linux/bcm2835-isp.h>
-#include <libcamera/base/file_descriptor.h>
#include <libcamera/base/log.h>
+#include <libcamera/base/shared_fd.h>
#include <libcamera/base/span.h>
#include <libcamera/control_ids.h>
@@ -164,7 +164,7 @@ private:
bool processPending_;
/* LS table allocation passed in from the pipeline handler. */
- FileDescriptor lsTableHandle_;
+ SharedFD lsTableHandle_;
void *lsTable_;
/* Distinguish the first camera start from others. */
diff --git a/src/libcamera/base/file.cpp b/src/libcamera/base/file.cpp
index 923e03fa..fb3e276d 100644
--- a/src/libcamera/base/file.cpp
+++ b/src/libcamera/base/file.cpp
@@ -15,6 +15,7 @@
#include <unistd.h>
#include <libcamera/base/log.h>
+#include <libcamera/base/shared_fd.h>
/**
* \file base/file.h
diff --git a/src/libcamera/base/file_descriptor.cpp b/src/libcamera/base/file_descriptor.cpp
deleted file mode 100644
index 8e181abc..00000000
--- a/src/libcamera/base/file_descriptor.cpp
+++ /dev/null
@@ -1,266 +0,0 @@
-/* SPDX-License-Identifier: LGPL-2.1-or-later */
-/*
- * Copyright (C) 2019, Google Inc.
- *
- * file_descriptor.cpp - File descriptor wrapper
- */
-
-#include <libcamera/base/file_descriptor.h>
-
-#include <string.h>
-#include <sys/types.h>
-#include <unistd.h>
-#include <utility>
-
-#include <libcamera/base/log.h>
-#include <libcamera/base/unique_fd.h>
-
-/**
- * \file base/file_descriptor.h
- * \brief File descriptor wrapper
- */
-
-namespace libcamera {
-
-LOG_DEFINE_CATEGORY(FileDescriptor)
-
-/**
- * \class FileDescriptor
- * \brief RAII-style wrapper for file descriptors
- *
- * The FileDescriptor class provides RAII-style lifetime management of file
- * descriptors with an efficient mechanism for ownership sharing. At its core,
- * an internal Descriptor object wraps a file descriptor (expressed as a signed
- * integer) with an RAII-style interface. The Descriptor is then implicitly
- * shared with all FileDescriptor instances constructed as copies.
- *
- * When constructed from a numerical file descriptor, the FileDescriptor
- * instance either duplicates or takes over the file descriptor:
- *
- * - The FileDescriptor(const int &) constructor duplicates the numerical file
- * descriptor and wraps the duplicate in a Descriptor. The caller is
- * responsible for closing the original file descriptor, and the value
- * returned by fd() will be different from the value passed to the
- * constructor.
- *
- * - The FileDescriptor(int &&) constructor takes over the numerical file
- * descriptor and wraps it in a Descriptor. The caller shall not touch the
- * original file descriptor once the function returns, and the value returned
- * by fd() will be identical to the value passed to the constructor.
- *
- * The copy constructor and assignment operator create copies that share the
- * Descriptor, while the move versions of those functions additionally make the
- * other FileDescriptor invalid. When the last FileDescriptor that references a
- * Descriptor is destroyed, the file descriptor is closed.
- *
- * The numerical file descriptor is available through the fd() function. All
- * FileDescriptor instances created as copies of a FileDescriptor will report
- * the same fd() value. Callers can perform operations on the fd(), but shall
- * never close it manually.
- */
-
-/**
- * \brief Create a FileDescriptor copying a given \a fd
- * \param[in] fd File descriptor
- *
- * Construct a FileDescriptor from a numerical file descriptor by duplicating
- * the \a fd, and take ownership of the copy. The original \a fd is left
- * untouched, and the caller is responsible for closing it when appropriate.
- * The duplicated file descriptor will be closed automatically when all
- * FileDescriptor instances that reference it are destroyed.
- *
- * If the \a fd is negative, the FileDescriptor is constructed as invalid and
- * the fd() function will return -1.
- */
-FileDescriptor::FileDescriptor(const int &fd)
-{
- if (fd < 0)
- return;
-
- fd_ = std::make_shared<Descriptor>(fd, true);
- if (fd_->fd() < 0)
- fd_.reset();
-}
-
-/**
- * \brief Create a FileDescriptor taking ownership of a given \a fd
- * \param[in] fd File descriptor
- *
- * Construct a FileDescriptor from a numerical file descriptor by taking
- * ownership of the \a fd. The original \a fd is set to -1 and shall not be
- * touched by the caller anymore. In particular, the caller shall not close the
- * original \a fd manually. The duplicated file descriptor will be closed
- * automatically when all FileDescriptor instances that reference it are
- * destroyed.
- *
- * If the \a fd is negative, the FileDescriptor is constructed as invalid and
- * the fd() function will return -1.
- */
-FileDescriptor::FileDescriptor(int &&fd)
-{
- if (fd < 0)
- return;
-
- fd_ = std::make_shared<Descriptor>(fd, false);
- /*
- * The Descriptor constructor can't have failed here, as it took over
- * the fd without duplicating it. Just set the original fd to -1 to
- * implement move semantics.
- */
- fd = -1;
-}
-
-/**
- * \brief Create a FileDescriptor taking ownership of a given UniqueFD \a fd
- * \param[in] fd UniqueFD
- *
- * Construct a FileDescriptor from UniqueFD by taking ownership of the \a fd.
- * The original \a fd becomes invalid.
- */
-FileDescriptor::FileDescriptor(UniqueFD fd)
- : FileDescriptor(fd.release())
-{
-}
-
-/**
- * \brief Copy constructor, create a FileDescriptor from a copy of \a other
- * \param[in] other The other FileDescriptor
- *
- * Copying a FileDescriptor implicitly shares ownership of the wrapped file
- * descriptor. The original FileDescriptor is left untouched, and the caller is
- * responsible for destroying it when appropriate. The wrapped file descriptor
- * will be closed automatically when all FileDescriptor instances that
- * reference it are destroyed.
- */
-FileDescriptor::FileDescriptor(const FileDescriptor &other)
- : fd_(other.fd_)
-{
-}
-
-/**
- * \brief Move constructor, create a FileDescriptor by taking over \a other
- * \param[in] other The other FileDescriptor
- *
- * Moving a FileDescriptor moves the reference to the wrapped descriptor owned
- * by \a other to the new FileDescriptor. The \a other FileDescriptor is
- * invalidated and its fd() function will return -1. The wrapped file descriptor
- * will be closed automatically when all FileDescriptor instances that
- * reference it are destroyed.
- */
-FileDescriptor::FileDescriptor(FileDescriptor &&other)
- : fd_(std::move(other.fd_))
-{
-}
-
-/**
- * \brief Destroy the FileDescriptor instance
- *
- * Destroying a FileDescriptor instance releases its reference to the wrapped
- * descriptor, if any. When the last instance that references a wrapped
- * descriptor is destroyed, the file descriptor is automatically closed.
- */
-FileDescriptor::~FileDescriptor()
-{
-}
-
-/**
- * \brief Copy assignment operator, replace the wrapped file descriptor with a
- * copy of \a other
- * \param[in] other The other FileDescriptor
- *
- * Copying a FileDescriptor creates a new reference to the wrapped file
- * descriptor owner by \a other. If \a other is invalid, *this will also be
- * invalid. The original FileDescriptor is left untouched, and the caller is
- * responsible for destroying it when appropriate. The wrapped file descriptor
- * will be closed automatically when all FileDescriptor instances that
- * reference it are destroyed.
- *
- * \return A reference to this FileDescriptor
- */
-FileDescriptor &FileDescriptor::operator=(const FileDescriptor &other)
-{
- fd_ = other.fd_;
-
- return *this;
-}
-
-/**
- * \brief Move assignment operator, replace the wrapped file descriptor by
- * taking over \a other
- * \param[in] other The other FileDescriptor
- *
- * Moving a FileDescriptor moves the reference to the wrapped descriptor owned
- * by \a other to the new FileDescriptor. If \a other is invalid, *this will
- * also be invalid. The \a other FileDescriptor is invalidated and its fd()
- * function will return -1. The wrapped file descriptor will be closed
- * automatically when all FileDescriptor instances that reference it are
- * destroyed.
- *
- * \return A reference to this FileDescriptor
- */
-FileDescriptor &FileDescriptor::operator=(FileDescriptor &&other)
-{
- fd_ = std::move(other.fd_);
-
- return *this;
-}
-
-/**
- * \fn FileDescriptor::isValid()
- * \brief Check if the FileDescriptor instance is valid
- * \return True if the FileDescriptor is valid, false otherwise
- */
-
-/**
- * \fn FileDescriptor::fd()
- * \brief Retrieve the numerical file descriptor
- * \return The numerical file descriptor, which may be -1 if the FileDescriptor
- * instance is invalid
- */
-
-/**
- * \brief Duplicate a FileDescriptor
- *
- * Duplicating a FileDescriptor creates a duplicate of the wrapped file
- * descriptor and returns a UniqueFD that owns the duplicate. The fd() function
- * of the original and the get() function of the duplicate will return different
- * values. The duplicate instance will not be affected by destruction of the
- * original instance or its copies.
- *
- * \return A UniqueFD owning a duplicate of the original file descriptor
- */
-UniqueFD FileDescriptor::dup() const
-{
- UniqueFD dupFd(::dup(fd()));
- if (!dupFd.isValid()) {
- int ret = -errno;
- LOG(FileDescriptor, Error)
- << "Failed to dup() fd: " << strerror(-ret);
- }
-
- return dupFd;
-}
-
-FileDescriptor::Descriptor::Descriptor(int fd, bool duplicate)
-{
- if (!duplicate) {
- fd_ = fd;
- return;
- }
-
- /* Failing to dup() a fd should not happen and is fatal. */
- fd_ = ::dup(fd);
- if (fd_ == -1) {
- int ret = -errno;
- LOG(FileDescriptor, Fatal)
- << "Failed to dup() fd: " << strerror(-ret);
- }
-}
-
-FileDescriptor::Descriptor::~Descriptor()
-{
- if (fd_ != -1)
- close(fd_);
-}
-
-} /* namespace libcamera */
diff --git a/src/libcamera/base/meson.build b/src/libcamera/base/meson.build
index 352ec6f0..0ae3b0aa 100644
--- a/src/libcamera/base/meson.build
+++ b/src/libcamera/base/meson.build
@@ -8,13 +8,13 @@ libcamera_base_sources = files([
'event_dispatcher_poll.cpp',
'event_notifier.cpp',
'file.cpp',
- 'file_descriptor.cpp',
'flags.cpp',
'log.cpp',
'message.cpp',
'mutex.cpp',
'object.cpp',
'semaphore.cpp',
+ 'shared_fd.cpp',
'signal.cpp',
'thread.cpp',
'timer.cpp',
diff --git a/src/libcamera/base/shared_fd.cpp b/src/libcamera/base/shared_fd.cpp
new file mode 100644
index 00000000..346b4a85
--- /dev/null
+++ b/src/libcamera/base/shared_fd.cpp
@@ -0,0 +1,262 @@
+/* SPDX-License-Identifier: LGPL-2.1-or-later */
+/*
+ * Copyright (C) 2019, Google Inc.
+ *
+ * shared_fd.cpp - File descriptor wrapper with shared ownership
+ */
+
+#include <libcamera/base/shared_fd.h>
+
+#include <string.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <utility>
+
+#include <libcamera/base/log.h>
+#include <libcamera/base/unique_fd.h>
+
+/**
+ * \file base/shared_fd.h
+ * \brief File descriptor wrapper
+ */
+
+namespace libcamera {
+
+LOG_DEFINE_CATEGORY(SharedFD)
+
+/**
+ * \class SharedFD
+ * \brief RAII-style wrapper for file descriptors
+ *
+ * The SharedFD class provides RAII-style lifetime management of file
+ * descriptors with an efficient mechanism for ownership sharing. At its core,
+ * an internal Descriptor object wraps a file descriptor (expressed as a signed
+ * integer) with an RAII-style interface. The Descriptor is then implicitly
+ * shared with all SharedFD instances constructed as copies.
+ *
+ * When constructed from a numerical file descriptor, the SharedFD instance
+ * either duplicates or takes over the file descriptor:
+ *
+ * - The SharedFD(const int &) constructor duplicates the numerical file
+ * descriptor and wraps the duplicate in a Descriptor. The caller is
+ * responsible for closing the original file descriptor, and the value
+ * returned by fd() will be different from the value passed to the
+ * constructor.
+ *
+ * - The SharedFD(int &&) constructor takes over the numerical file descriptor
+ * and wraps it in a Descriptor. The caller shall not touch the original file
+ * descriptor once the function returns, and the value returned by fd() will
+ * be identical to the value passed to the constructor.
+ *
+ * The copy constructor and assignment operator create copies that share the
+ * Descriptor, while the move versions of those functions additionally make the
+ * other SharedFD invalid. When the last SharedFD that references a Descriptor
+ * is destroyed, the file descriptor is closed.
+ *
+ * The numerical file descriptor is available through the fd() function. All
+ * SharedFD instances created as copies of a SharedFD will report the same fd()
+ * value. Callers can perform operations on the fd(), but shall never close it
+ * manually.
+ */
+
+/**
+ * \brief Create a SharedFD copying a given \a fd
+ * \param[in] fd File descriptor
+ *
+ * Construct a SharedFD from a numerical file descriptor by duplicating the
+ * \a fd, and take ownership of the copy. The original \a fd is left untouched,
+ * and the caller is responsible for closing it when appropriate. The duplicated
+ * file descriptor will be closed automatically when all SharedFD instances that
+ * reference it are destroyed.
+ *
+ * If the \a fd is negative, the SharedFD is constructed as invalid and the fd()
+ * function will return -1.
+ */
+SharedFD::SharedFD(const int &fd)
+{
+ if (fd < 0)
+ return;
+
+ fd_ = std::make_shared<Descriptor>(fd, true);
+ if (fd_->fd() < 0)
+ fd_.reset();
+}
+
+/**
+ * \brief Create a SharedFD taking ownership of a given \a fd
+ * \param[in] fd File descriptor
+ *
+ * Construct a SharedFD from a numerical file descriptor by taking ownership of
+ * the \a fd. The original \a fd is set to -1 and shall not be touched by the
+ * caller anymore. In particular, the caller shall not close the original \a fd
+ * manually. The duplicated file descriptor will be closed automatically when
+ * all SharedFD instances that reference it are destroyed.
+ *
+ * If the \a fd is negative, the SharedFD is constructed as invalid and the fd()
+ * function will return -1.
+ */
+SharedFD::SharedFD(int &&fd)
+{
+ if (fd < 0)
+ return;
+
+ fd_ = std::make_shared<Descriptor>(fd, false);
+ /*
+ * The Descriptor constructor can't have failed here, as it took over
+ * the fd without duplicating it. Just set the original fd to -1 to
+ * implement move semantics.
+ */
+ fd = -1;
+}
+
+/**
+ * \brief Create a SharedFD taking ownership of a given UniqueFD \a fd
+ * \param[in] fd UniqueFD
+ *
+ * Construct a SharedFD from UniqueFD by taking ownership of the \a fd. The
+ * original \a fd becomes invalid.
+ */
+SharedFD::SharedFD(UniqueFD fd)
+ : SharedFD(fd.release())
+{
+}
+
+/**
+ * \brief Copy constructor, create a SharedFD from a copy of \a other
+ * \param[in] other The other SharedFD
+ *
+ * Copying a SharedFD implicitly shares ownership of the wrapped file
+ * descriptor. The original SharedFD is left untouched, and the caller is
+ * responsible for destroying it when appropriate. The wrapped file descriptor
+ * will be closed automatically when all SharedFD instances that reference it
+ * are destroyed.
+ */
+SharedFD::SharedFD(const SharedFD &other)
+ : fd_(other.fd_)
+{
+}
+
+/**
+ * \brief Move constructor, create a SharedFD by taking over \a other
+ * \param[in] other The other SharedFD
+ *
+ * Moving a SharedFD moves the reference to the wrapped descriptor owned by
+ * \a other to the new SharedFD. The \a other SharedFD is invalidated and its
+ * fd() function will return -1. The wrapped file descriptor will be closed
+ * automatically when all SharedFD instances that reference it are destroyed.
+ */
+SharedFD::SharedFD(SharedFD &&other)
+ : fd_(std::move(other.fd_))
+{
+}
+
+/**
+ * \brief Destroy the SharedFD instance
+ *
+ * Destroying a SharedFD instance releases its reference to the wrapped
+ * descriptor, if any. When the last instance that references a wrapped
+ * descriptor is destroyed, the file descriptor is automatically closed.
+ */
+SharedFD::~SharedFD()
+{
+}
+
+/**
+ * \brief Copy assignment operator, replace the wrapped file descriptor with a
+ * copy of \a other
+ * \param[in] other The other SharedFD
+ *
+ * Copying a SharedFD creates a new reference to the wrapped file descriptor
+ * owner by \a other. If \a other is invalid, *this will also be invalid. The
+ * original SharedFD is left untouched, and the caller is responsible for
+ * destroying it when appropriate. The wrapped file descriptor will be closed
+ * automatically when all SharedFD instances that reference it are destroyed.
+ *
+ * \return A reference to this SharedFD
+ */
+SharedFD &SharedFD::operator=(const SharedFD &other)
+{
+ fd_ = other.fd_;
+
+ return *this;
+}
+
+/**
+ * \brief Move assignment operator, replace the wrapped file descriptor by
+ * taking over \a other
+ * \param[in] other The other SharedFD
+ *
+ * Moving a SharedFD moves the reference to the wrapped descriptor owned by
+ * \a other to the new SharedFD. If \a other is invalid, *this will also be
+ * invalid. The \a other SharedFD is invalidated and its fd() function will
+ * return -1. The wrapped file descriptor will be closed automatically when
+ * all SharedFD instances that reference it are destroyed.
+ *
+ * \return A reference to this SharedFD
+ */
+SharedFD &SharedFD::operator=(SharedFD &&other)
+{
+ fd_ = std::move(other.fd_);
+
+ return *this;
+}
+
+/**
+ * \fn SharedFD::isValid()
+ * \brief Check if the SharedFD instance is valid
+ * \return True if the SharedFD is valid, false otherwise
+ */
+
+/**
+ * \fn SharedFD::fd()
+ * \brief Retrieve the numerical file descriptor
+ * \return The numerical file descriptor, which may be -1 if the SharedFD
+ * instance is invalid
+ */
+
+/**
+ * \brief Duplicate a SharedFD
+ *
+ * Duplicating a SharedFD creates a duplicate of the wrapped file descriptor and
+ * returns a UniqueFD that owns the duplicate. The fd() function of the original
+ * and the get() function of the duplicate will return different values. The
+ * duplicate instance will not be affected by destruction of the original
+ * instance or its copies.
+ *
+ * \return A UniqueFD owning a duplicate of the original file descriptor
+ */
+UniqueFD SharedFD::dup() const
+{
+ UniqueFD dupFd(::dup(fd()));
+ if (!dupFd.isValid()) {
+ int ret = -errno;
+ LOG(SharedFD, Error)
+ << "Failed to dup() fd: " << strerror(-ret);
+ }
+
+ return dupFd;
+}
+
+SharedFD::Descriptor::Descriptor(int fd, bool duplicate)
+{
+ if (!duplicate) {
+ fd_ = fd;
+ return;
+ }
+
+ /* Failing to dup() a fd should not happen and is fatal. */
+ fd_ = ::dup(fd);
+ if (fd_ == -1) {
+ int ret = -errno;
+ LOG(SharedFD, Fatal)
+ << "Failed to dup() fd: " << strerror(-ret);
+ }
+}
+
+SharedFD::Descriptor::~Descriptor()
+{
+ if (fd_ != -1)
+ close(fd_);
+}
+
+} /* namespace libcamera */
diff --git a/src/libcamera/framebuffer.cpp b/src/libcamera/framebuffer.cpp
index fcb475c2..fbf8f1c2 100644
--- a/src/libcamera/framebuffer.cpp
+++ b/src/libcamera/framebuffer.cpp
@@ -10,8 +10,8 @@
#include <sys/stat.h>
-#include <libcamera/base/file_descriptor.h>
#include <libcamera/base/log.h>
+#include <libcamera/base/shared_fd.h>
/**
* \file libcamera/framebuffer.h
@@ -182,9 +182,9 @@ FrameBuffer::Private::Private()
* offset and length.
*
* To support DMA access, planes are associated with dmabuf objects represented
- * by FileDescriptor handles. The Plane class doesn't handle mapping of the
- * memory to the CPU, but applications and IPAs may use the dmabuf file
- * descriptors to map the plane memory with mmap() and access its contents.
+ * by SharedFD handles. The Plane class doesn't handle mapping of the memory to
+ * the CPU, but applications and IPAs may use the dmabuf file descriptors to map
+ * the plane memory with mmap() and access its contents.
*
* \todo Specify how an application shall decide whether to use a single or
* multiple dmabufs, based on the camera requirements.
@@ -212,7 +212,7 @@ FrameBuffer::Private::Private()
namespace {
-ino_t fileDescriptorInode(const FileDescriptor &fd)
+ino_t fileDescriptorInode(const SharedFD &fd)
{
if (!fd.isValid())
return 0;
diff --git a/src/libcamera/ipa_data_serializer.cpp b/src/libcamera/ipa_data_serializer.cpp
index 82ec9b20..0a259305 100644
--- a/src/libcamera/ipa_data_serializer.cpp
+++ b/src/libcamera/ipa_data_serializer.cpp
@@ -31,7 +31,7 @@ LOG_DEFINE_CATEGORY(IPADataSerializer)
*
* \todo Harden the vector and map deserializer
*
- * \todo For FileDescriptors, instead of storing a validity flag, store an
+ * \todo For SharedFDs, instead of storing a validity flag, store an
* index into the fd array. This will allow us to use views instead of copying.
*/
@@ -112,7 +112,7 @@ namespace {
* \param[in] cs ControlSerializer
*
* This version of deserialize() can be used if the object type \a T and its
- * members don't have any FileDescriptor.
+ * members don't have any SharedFD.
*
* \a cs is only necessary if the object type \a T or its members contain
* ControlList or ControlInfoMap.
@@ -132,7 +132,7 @@ namespace {
* \param[in] cs ControlSerializer
*
* This version of deserialize() can be used if the object type \a T and its
- * members don't have any FileDescriptor.
+ * members don't have any SharedFD.
*
* \a cs is only necessary if the object type \a T or its members contain
* ControlList or ControlInfoMap.
@@ -143,7 +143,7 @@ namespace {
/**
* \fn template<typename T> IPADataSerializer<T>::deserialize(
* const std::vector<uint8_t> &data,
- * const std::vector<FileDescriptor> &fds,
+ * const std::vector<SharedFD> &fds,
* ControlSerializer *cs = nullptr)
* \brief Deserialize byte vector and fd vector into an object
* \tparam T Type of object to deserialize to
@@ -152,7 +152,7 @@ namespace {
* \param[in] cs ControlSerializer
*
* This version of deserialize() (or the iterator version) must be used if
- * the object type \a T or its members contain FileDescriptor.
+ * the object type \a T or its members contain SharedFD.
*
* \a cs is only necessary if the object type \a T or its members contain
* ControlList or ControlInfoMap.
@@ -164,8 +164,8 @@ namespace {
* \fn template<typename T> IPADataSerializer::deserialize(
* std::vector<uint8_t>::const_iterator dataBegin,
* std::vector<uint8_t>::const_iterator dataEnd,
- * std::vector<FileDescriptor>::const_iterator fdsBegin,
- * std::vector<FileDescriptor>::const_iterator fdsEnd,
+ * std::vector<SharedFD>::const_iterator fdsBegin,
+ * std::vector<SharedFD>::const_iterator fdsEnd,
* ControlSerializer *cs = nullptr)
* \brief Deserialize byte vector and fd vector into an object
* \tparam T Type of object to deserialize to
@@ -176,7 +176,7 @@ namespace {
* \param[in] cs ControlSerializer
*
* This version of deserialize() (or the vector version) must be used if
- * the object type \a T or its members contain FileDescriptor.
+ * the object type \a T or its members contain SharedFD.
*
* \a cs is only necessary if the object type \a T or its members contain
* ControlList or ControlInfoMap.
@@ -189,7 +189,7 @@ namespace {
#define DEFINE_POD_SERIALIZER(type) \
\
template<> \
-std::tuple<std::vector<uint8_t>, std::vector<FileDescriptor>> \
+std::tuple<std::vector<uint8_t>, std::vector<SharedFD>> \
IPADataSerializer<type>::serialize(const type &data, \
[[maybe_unused]] ControlSerializer *cs) \
{ \
@@ -217,7 +217,7 @@ type IPADataSerializer<type>::deserialize(const std::vector<uint8_t> &data, \
\
template<> \
type IPADataSerializer<type>::deserialize(const std::vector<uint8_t> &data, \
- [[maybe_unused]] const std::vector<FileDescriptor> &fds, \
+ [[maybe_unused]] const std::vector<SharedFD> &fds, \
ControlSerializer *cs) \
{ \
return deserialize(data.cbegin(), data.end(), cs); \
@@ -226,8 +226,8 @@ type IPADataSerializer<type>::deserialize(const std::vector<uint8_t> &data, \
template<> \
type IPADataSerializer<type>::deserialize(std::vector<uint8_t>::const_iterator dataBegin, \
std::vector<uint8_t>::const_iterator dataEnd, \
- [[maybe_unused]] std::vector<FileDescriptor>::const_iterator fdsBegin, \
- [[maybe_unused]] std::vector<FileDescriptor>::const_iterator fdsEnd, \
+ [[maybe_unused]] std::vector<SharedFD>::const_iterator fdsBegin, \
+ [[maybe_unused]] std::vector<SharedFD>::const_iterator fdsEnd, \
ControlSerializer *cs) \
{ \
return deserialize(dataBegin, dataEnd, cs); \
@@ -251,7 +251,7 @@ DEFINE_POD_SERIALIZER(double)
* function parameter serdes).
*/
template<>
-std::tuple<std::vector<uint8_t>, std::vector<FileDescriptor>>
+std::tuple<std::vector<uint8_t>, std::vector<SharedFD>>
IPADataSerializer<std::string>::serialize(const std::string &data,
[[maybe_unused]] ControlSerializer *cs)
{
@@ -278,7 +278,7 @@ IPADataSerializer<std::string>::deserialize(std::vector<uint8_t>::const_iterator
template<>
std::string
IPADataSerializer<std::string>::deserialize(const std::vector<uint8_t> &data,
- [[maybe_unused]] const std::vector<FileDescriptor> &fds,
+ [[maybe_unused]] const std::vector<SharedFD> &fds,
[[maybe_unused]] ControlSerializer *cs)
{
return { data.cbegin(), data.cend() };
@@ -288,8 +288,8 @@ template<>
std::string
IPADataSerializer<std::string>::deserialize(std::vector<uint8_t>::const_iterator dataBegin,
std::vector<uint8_t>::const_iterator dataEnd,
- [[maybe_unused]] std::vector<FileDescriptor>::const_iterator fdsBegin,
- [[maybe_unused]] std::vector<FileDescriptor>::const_iterator fdsEnd,
+ [[maybe_unused]] std::vector<SharedFD>::const_iterator fdsBegin,
+ [[maybe_unused]] std::vector<SharedFD>::const_iterator fdsEnd,
[[maybe_unused]] ControlSerializer *cs)
{
return { dataBegin, dataEnd };
@@ -307,7 +307,7 @@ IPADataSerializer<std::string>::deserialize(std::vector<uint8_t>::const_iterator
* be used. The serialized ControlInfoMap will have zero length.
*/
template<>
-std::tuple<std::vector<uint8_t>, std::vector<FileDescriptor>>
+std::tuple<std::vector<uint8_t>, std::vector<SharedFD>>
IPADataSerializer<ControlList>::serialize(const ControlList &data, ControlSerializer *cs)
{
if (!cs)
@@ -407,7 +407,7 @@ IPADataSerializer<ControlList>::deserialize(const std::vector<uint8_t> &data,
template<>
ControlList
IPADataSerializer<ControlList>::deserialize(const std::vector<uint8_t> &data,
- [[maybe_unused]] const std::vector<FileDescriptor> &fds,
+ [[maybe_unused]] const std::vector<SharedFD> &fds,
ControlSerializer *cs)
{
return deserialize(data.cbegin(), data.end(), cs);
@@ -417,8 +417,8 @@ template<>
ControlList
IPADataSerializer<ControlList>::deserialize(std::vector<uint8_t>::const_iterator dataBegin,
std::vector<uint8_t>::const_iterator dataEnd,
- [[maybe_unused]] std::vector<FileDescriptor>::const_iterator fdsBegin,
- [[maybe_unused]] std::vector<FileDescriptor>::const_iterator fdsEnd,
+ [[maybe_unused]] std::vector<SharedFD>::const_iterator fdsBegin,
+ [[maybe_unused]] std::vector<SharedFD>::const_iterator fdsEnd,
ControlSerializer *cs)
{
return deserialize(dataBegin, dataEnd, cs);
@@ -431,7 +431,7 @@ IPADataSerializer<ControlList>::deserialize(std::vector<uint8_t>::const_iterator
* X bytes - Serialized ControlInfoMap (using ControlSerializer)
*/
template<>
-std::tuple<std::vector<uint8_t>, std::vector<FileDescriptor>>
+std::tuple<std::vector<uint8_t>, std::vector<SharedFD>>
IPADataSerializer<ControlInfoMap>::serialize(const ControlInfoMap &map,
ControlSerializer *cs)
{
@@ -493,7 +493,7 @@ IPADataSerializer<ControlInfoMap>::deserialize(const std::vector<uint8_t> &data,
template<>
ControlInfoMap
IPADataSerializer<ControlInfoMap>::deserialize(const std::vector<uint8_t> &data,
- [[maybe_unused]] const std::vector<FileDescriptor> &fds,
+ [[maybe_unused]] const std::vector<SharedFD> &fds,
ControlSerializer *cs)
{
return deserialize(data.cbegin(), data.end(), cs);
@@ -503,30 +503,30 @@ template<>
ControlInfoMap
IPADataSerializer<ControlInfoMap>::deserialize(std::vector<uint8_t>::const_iterator dataBegin,
std::vector<uint8_t>::const_iterator dataEnd,
- [[maybe_unused]] std::vector<FileDescriptor>::const_iterator fdsBegin,
- [[maybe_unused]] std::vector<FileDescriptor>::const_iterator fdsEnd,
+ [[maybe_unused]] std::vector<SharedFD>::const_iterator fdsBegin,
+ [[maybe_unused]] std::vector<SharedFD>::const_iterator fdsEnd,
ControlSerializer *cs)
{
return deserialize(dataBegin, dataEnd, cs);
}
/*
- * FileDescriptors are serialized into four bytes that tells if the
- * FileDescriptor is valid or not. If it is valid, then for serialization
- * the fd will be written to the fd vector, or for deserialization the
- * fd vector const_iterator will be valid.
+ * SharedFD instances are serialized into four bytes that tells if the SharedFD
+ * is valid or not. If it is valid, then for serialization the fd will be
+ * written to the fd vector, or for deserialization the fd vector const_iterator
+ * will be valid.
*
* This validity is necessary so that we don't send -1 fd over sendmsg(). It
* also allows us to simply send the entire fd vector into the deserializer
* and it will be recursively consumed as necessary.
*/
template<>
-std::tuple<std::vector<uint8_t>, std::vector<FileDescriptor>>
-IPADataSerializer<FileDescriptor>::serialize(const FileDescriptor &data,
- [[maybe_unused]] ControlSerializer *cs)
+std::tuple<std::vector<uint8_t>, std::vector<SharedFD>>
+IPADataSerializer<SharedFD>::serialize(const SharedFD &data,
+ [[maybe_unused]] ControlSerializer *cs)
{
std::vector<uint8_t> dataVec;
- std::vector<FileDescriptor> fdVec;
+ std::vector<SharedFD> fdVec;
/*
* Store as uint32_t to prepare for conversion from validity flag
@@ -542,11 +542,11 @@ IPADataSerializer<FileDescriptor>::serialize(const FileDescriptor &data,
}
template<>
-FileDescriptor IPADataSerializer<FileDescriptor>::deserialize([[maybe_unused]] std::vector<uint8_t>::const_iterator dataBegin,
- [[maybe_unused]] std::vector<uint8_t>::const_iterator dataEnd,
- std::vector<FileDescriptor>::const_iterator fdsBegin,
- std::vector<FileDescriptor>::const_iterator fdsEnd,
- [[maybe_unused]] ControlSerializer *cs)
+SharedFD IPADataSerializer<SharedFD>::deserialize([[maybe_unused]] std::vector<uint8_t>::const_iterator dataBegin,
+ [[maybe_unused]] std::vector<uint8_t>::const_iterator dataEnd,
+ std::vector<SharedFD>::const_iterator fdsBegin,
+ std::vector<SharedFD>::const_iterator fdsEnd,
+ [[maybe_unused]] ControlSerializer *cs)
{
ASSERT(std::distance(dataBegin, dataEnd) >= 4);
@@ -554,13 +554,13 @@ FileDescriptor IPADataSerializer<FileDescriptor>::deserialize([[maybe_unused]] s
ASSERT(!(valid && std::distance(fdsBegin, fdsEnd) < 1));
- return valid ? *fdsBegin : FileDescriptor();
+ return valid ? *fdsBegin : SharedFD();
}
template<>
-FileDescriptor IPADataSerializer<FileDescriptor>::deserialize(const std::vector<uint8_t> &data,
- const std::vector<FileDescriptor> &fds,
- [[maybe_unused]] ControlSerializer *cs)
+SharedFD IPADataSerializer<SharedFD>::deserialize(const std::vector<uint8_t> &data,
+ const std::vector<SharedFD> &fds,
+ [[maybe_unused]] ControlSerializer *cs)
{
return deserialize(data.cbegin(), data.end(), fds.cbegin(), fds.end());
}
@@ -568,22 +568,22 @@ FileDescriptor IPADataSerializer<FileDescriptor>::deserialize(const std::vector<
/*
* FrameBuffer::Plane is serialized as:
*
- * 4 byte - FileDescriptor
+ * 4 byte - SharedFD
* 4 bytes - uint32_t Offset
* 4 bytes - uint32_t Length
*/
template<>
-std::tuple<std::vector<uint8_t>, std::vector<FileDescriptor>>
+std::tuple<std::vector<uint8_t>, std::vector<SharedFD>>
IPADataSerializer<FrameBuffer::Plane>::serialize(const FrameBuffer::Plane &data,
[[maybe_unused]] ControlSerializer *cs)
{
std::vector<uint8_t> dataVec;
- std::vector<FileDescriptor> fdsVec;
+ std::vector<SharedFD> fdsVec;
std::vector<uint8_t> fdBuf;
- std::vector<FileDescriptor> fdFds;
+ std::vector<SharedFD> fdFds;
std::tie(fdBuf, fdFds) =
- IPADataSerializer<FileDescriptor>::serialize(data.fd);
+ IPADataSerializer<SharedFD>::serialize(data.fd);
dataVec.insert(dataVec.end(), fdBuf.begin(), fdBuf.end());
fdsVec.insert(fdsVec.end(), fdFds.begin(), fdFds.end());
@@ -597,13 +597,13 @@ template<>
FrameBuffer::Plane
IPADataSerializer<FrameBuffer::Plane>::deserialize(std::vector<uint8_t>::const_iterator dataBegin,
std::vector<uint8_t>::const_iterator dataEnd,
- std::vector<FileDescriptor>::const_iterator fdsBegin,
- [[maybe_unused]] std::vector<FileDescriptor>::const_iterator fdsEnd,
+ std::vector<SharedFD>::const_iterator fdsBegin,
+ [[maybe_unused]] std::vector<SharedFD>::const_iterator fdsEnd,
[[maybe_unused]] ControlSerializer *cs)
{
FrameBuffer::Plane ret;
- ret.fd = IPADataSerializer<FileDescriptor>::deserialize(dataBegin, dataBegin + 4,
+ ret.fd = IPADataSerializer<SharedFD>::deserialize(dataBegin, dataBegin + 4,
fdsBegin, fdsBegin + 1);
ret.offset = readPOD<uint32_t>(dataBegin, 4, dataEnd);
ret.length = readPOD<uint32_t>(dataBegin, 8, dataEnd);
@@ -614,7 +614,7 @@ IPADataSerializer<FrameBuffer::Plane>::deserialize(std::vector<uint8_t>::const_i
template<>
FrameBuffer::Plane
IPADataSerializer<FrameBuffer::Plane>::deserialize(const std::vector<uint8_t> &data,
- const std::vector<FileDescriptor> &fds,
+ const std::vector<SharedFD> &fds,
ControlSerializer *cs)
{
return deserialize(data.cbegin(), data.end(), fds.cbegin(), fds.end(), cs);
diff --git a/src/libcamera/ipc_pipe.cpp b/src/libcamera/ipc_pipe.cpp
index ad870fd4..3b47032d 100644
--- a/src/libcamera/ipc_pipe.cpp
+++ b/src/libcamera/ipc_pipe.cpp
@@ -87,7 +87,7 @@ IPCMessage::IPCMessage(IPCUnixSocket::Payload &payload)
data_ = std::vector<uint8_t>(payload.data.begin() + sizeof(header_),
payload.data.end());
for (int32_t &fd : payload.fds)
- fds_.push_back(FileDescriptor(std::move(fd)));
+ fds_.push_back(SharedFD(std::move(fd)));
}
/**
@@ -112,7 +112,7 @@ IPCUnixSocket::Payload IPCMessage::payload() const
data_.data(), data_.size());
}
- for (const FileDescriptor &fd : fds_)
+ for (const SharedFD &fd : fds_)
payload.fds.push_back(fd.fd());
return payload;
diff --git a/src/libcamera/pipeline/raspberrypi/raspberrypi.cpp b/src/libcamera/pipeline/raspberrypi/raspberrypi.cpp
index 6debea63..4885a939 100644
--- a/src/libcamera/pipeline/raspberrypi/raspberrypi.cpp
+++ b/src/libcamera/pipeline/raspberrypi/raspberrypi.cpp
@@ -13,7 +13,7 @@
#include <queue>
#include <unordered_set>
-#include <libcamera/base/file_descriptor.h>
+#include <libcamera/base/shared_fd.h>
#include <libcamera/camera.h>
#include <libcamera/control_ids.h>
@@ -224,7 +224,7 @@ public:
/* DMAHEAP allocation helper. */
RPi::DmaHeap dmaHeap_;
- FileDescriptor lsTable_;
+ SharedFD lsTable_;
std::unique_ptr<DelayedControls> delayedCtrls_;
bool sensorMetadata_;
@@ -1393,7 +1393,7 @@ int RPiCameraData::configureIPA(const CameraConfiguration *config)
/* Allocate the lens shading table via dmaHeap and pass to the IPA. */
if (!lsTable_.isValid()) {
- lsTable_ = FileDescriptor(dmaHeap_.alloc("ls_grid", ipa::RPi::MaxLsGridSize));
+ lsTable_ = SharedFD(dmaHeap_.alloc("ls_grid", ipa::RPi::MaxLsGridSize));
if (!lsTable_.isValid())
return -ENOMEM;
diff --git a/src/libcamera/v4l2_videodevice.cpp b/src/libcamera/v4l2_videodevice.cpp
index 5f1cc6e2..0d214d9e 100644
--- a/src/libcamera/v4l2_videodevice.cpp
+++ b/src/libcamera/v4l2_videodevice.cpp
@@ -22,8 +22,8 @@
#include <linux/version.h>
#include <libcamera/base/event_notifier.h>
-#include <libcamera/base/file_descriptor.h>
#include <libcamera/base/log.h>
+#include <libcamera/base/shared_fd.h>
#include <libcamera/base/unique_fd.h>
#include <libcamera/base/utils.h>
@@ -617,7 +617,7 @@ int V4L2VideoDevice::open()
*
* \return 0 on success or a negative error code otherwise
*/
-int V4L2VideoDevice::open(FileDescriptor handle, enum v4l2_buf_type type)
+int V4L2VideoDevice::open(SharedFD handle, enum v4l2_buf_type type)
{
UniqueFD newFd = handle.dup();
if (!newFd.isValid()) {
@@ -1323,7 +1323,7 @@ std::unique_ptr<FrameBuffer> V4L2VideoDevice::createBuffer(unsigned int index)
return nullptr;
FrameBuffer::Plane plane;
- plane.fd = FileDescriptor(std::move(fd));
+ plane.fd = SharedFD(std::move(fd));
/*
* V4L2 API doesn't provide dmabuf offset information of plane.
* Set 0 as a placeholder offset.
@@ -1352,7 +1352,7 @@ std::unique_ptr<FrameBuffer> V4L2VideoDevice::createBuffer(unsigned int index)
ASSERT(numPlanes == 1u);
planes.resize(formatInfo_->numPlanes());
- const FileDescriptor &fd = planes[0].fd;
+ const SharedFD &fd = planes[0].fd;
size_t offset = 0;
for (auto [i, plane] : utils::enumerate(planes)) {
@@ -1900,8 +1900,8 @@ int V4L2M2MDevice::open()
* The output and capture V4L2VideoDevice instances use the same file
* handle for the same device node.
*/
- FileDescriptor fd(syscall(SYS_openat, AT_FDCWD, deviceNode_.c_str(),
- O_RDWR | O_NONBLOCK));
+ SharedFD fd(syscall(SYS_openat, AT_FDCWD, deviceNode_.c_str(),
+ O_RDWR | O_NONBLOCK));
if (!fd.isValid()) {
ret = -errno;
LOG(V4L2, Error) << "Failed to open V4L2 M2M device: "
diff --git a/src/v4l2/v4l2_camera.h b/src/v4l2/v4l2_camera.h
index 658c9297..03e74118 100644
--- a/src/v4l2/v4l2_camera.h
+++ b/src/v4l2/v4l2_camera.h
@@ -10,9 +10,9 @@
#include <deque>
#include <utility>
-#include <libcamera/base/file_descriptor.h>
#include <libcamera/base/mutex.h>
#include <libcamera/base/semaphore.h>
+#include <libcamera/base/shared_fd.h>
#include <libcamera/camera.h>
#include <libcamera/framebuffer.h>