From daf1cf0c737bdee9e42a9aaf64af997609a90951 Mon Sep 17 00:00:00 2001 From: Umang Jain Date: Tue, 22 Jun 2021 13:02:08 +0530 Subject: src: Import MappedBuffer class from libcamera This libcamera internal class, needs to be imported from libcamera code base, in order to have standalone ipu3-ipa build. Other libcamera components required by ipu3-ipa, will be linked through libcamera_platform.so in subsequent commit. Signed-off-by: Umang Jain --- include/libcamera-helpers/mapped_buffer.h | 53 +++++++++ src/libcamera-helpers/mapped_buffer.cpp | 171 ++++++++++++++++++++++++++++++ src/libcamera-helpers/meson.build | 6 ++ src/meson.build | 3 + 4 files changed, 233 insertions(+) create mode 100644 include/libcamera-helpers/mapped_buffer.h create mode 100644 src/libcamera-helpers/mapped_buffer.cpp create mode 100644 src/libcamera-helpers/meson.build create mode 100644 src/meson.build diff --git a/include/libcamera-helpers/mapped_buffer.h b/include/libcamera-helpers/mapped_buffer.h new file mode 100644 index 0000000..b34a70c --- /dev/null +++ b/include/libcamera-helpers/mapped_buffer.h @@ -0,0 +1,53 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2020, Google Inc. + * + * buffer.h - Internal buffer handling + */ +#ifndef __LIBCAMERA_MAPPED_BUFFER_H__ +#define __LIBCAMERA_MAPPED_BUFFER_H__ + +#include +#include + +#include +#include + +#include + +namespace libcamera { + +class MappedBuffer +{ +public: + using Plane = Span; + + ~MappedBuffer(); + + MappedBuffer(MappedBuffer &&other); + MappedBuffer &operator=(MappedBuffer &&other); + + bool isValid() const { return error_ == 0; } + int error() const { return error_; } + const std::vector &maps() const { return maps_; } + +protected: + MappedBuffer(); + + int error_; + std::vector maps_; + +private: + LIBCAMERA_DISABLE_COPY(MappedBuffer) +}; + +class MappedFrameBuffer : public MappedBuffer +{ +public: + MappedFrameBuffer(const FrameBuffer *buffer, int flags); +}; + +} /* namespace libcamera */ + +#endif /* __LIBCAMERA_MAPPED_BUFFER_H__ */ + diff --git a/src/libcamera-helpers/mapped_buffer.cpp b/src/libcamera-helpers/mapped_buffer.cpp new file mode 100644 index 0000000..6f3248e --- /dev/null +++ b/src/libcamera-helpers/mapped_buffer.cpp @@ -0,0 +1,171 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2021, Google Inc. + * + * mapped_buffer.cpp - Mapped Buffer handling + */ + +#include "libcamera-helpers/mapped_buffer.h" + +#include +#include +#include +#include + +#include + +/** + * \file libcamera-helpers/mapped_buffer.h + * \brief Mapped Buffer handling + */ + +namespace libcamera { + +LOG_DEFINE_CATEGORY(MappedBuffer) + +/** + * \class MappedBuffer + * \brief Provide an interface to support managing memory mapped buffers + * + * The MappedBuffer interface provides access to a set of MappedPlanes which + * are available for access by the CPU. + * + * This class is not meant to be constructed directly, but instead derived + * classes should be used to implement the correct mapping of a source buffer. + * + * This allows treating CPU accessible memory through a generic interface + * regardless of whether it originates from a libcamera FrameBuffer or other + * source. + */ + +/** + * \typedef MappedBuffer::Plane + * \brief A mapped region of memory accessible to the CPU + * + * The MappedBuffer::Plane uses the Span interface to describe the mapped memory + * region. + */ + +/** + * \brief Construct an empty MappedBuffer + */ +MappedBuffer::MappedBuffer() + : error_(0) +{ +} + +/** + * \brief Move constructor, construct the MappedBuffer with the contents of \a + * other using move semantics + * \param[in] other The other MappedBuffer + * + * Moving a MappedBuffer moves the mappings contained in the \a other to the new + * MappedBuffer and invalidates the \a other. + * + * No mappings are unmapped or destroyed in this process. + */ +MappedBuffer::MappedBuffer(MappedBuffer &&other) +{ + *this = std::move(other); +} + +/** + * \brief Move assignment operator, replace the mappings with those of \a other +* \param[in] other The other MappedBuffer + * + * Moving a MappedBuffer moves the mappings contained in the \a other to the new + * MappedBuffer and invalidates the \a other. + * + * No mappings are unmapped or destroyed in this process. + */ +MappedBuffer &MappedBuffer::operator=(MappedBuffer &&other) +{ + error_ = other.error_; + maps_ = std::move(other.maps_); + other.error_ = -ENOENT; + + return *this; +} + +MappedBuffer::~MappedBuffer() +{ + for (Plane &map : maps_) + munmap(map.data(), map.size()); +} + +/** + * \fn MappedBuffer::isValid() + * \brief Check if the MappedBuffer instance is valid + * \return True if the MappedBuffer has valid mappings, false otherwise + */ + +/** + * \fn MappedBuffer::error() + * \brief Retrieve the map error status + * + * This function retrieves the error status from the MappedBuffer. + * The error status is a negative number as defined by errno.h. If + * no error occurred, this function returns 0. + * + * \return The map error code + */ + +/** + * \fn MappedBuffer::maps() + * \brief Retrieve the mapped planes + * + * This function retrieves the successfully mapped planes stored as a vector + * of Span to provide access to the mapped memory. + * + * \return A vector of the mapped planes + */ + +/** + * \var MappedBuffer::error_ + * \brief Stores the error value if present + * + * MappedBuffer derived classes shall set this to a negative value as defined + * by errno.h if an error occured during the mapping process. + */ + +/** + * \var MappedBuffer::maps_ + * \brief Stores the internal mapped planes + * + * MappedBuffer derived classes shall store the mappings they create in this + * vector which is parsed during destruct to unmap any memory mappings which + * completed successfully. + */ + +/** + * \class MappedFrameBuffer + * \brief Map a FrameBuffer using the MappedBuffer interface + */ + +/** + * \brief Map all planes of a FrameBuffer + * \param[in] buffer FrameBuffer to be mapped + * \param[in] flags Protection flags to apply to map + * + * Construct an object to map a frame buffer for CPU access. + * The flags are passed directly to mmap and should be either PROT_READ, + * PROT_WRITE, or a bitwise-or combination of both. + */ +MappedFrameBuffer::MappedFrameBuffer(const FrameBuffer *buffer, int flags) +{ + maps_.reserve(buffer->planes().size()); + + for (const FrameBuffer::Plane &plane : buffer->planes()) { + void *address = mmap(nullptr, plane.length, flags, + MAP_SHARED, plane.fd.fd(), 0); + if (address == MAP_FAILED) { + error_ = -errno; + LOG(MappedBuffer, Error) << "Failed to mmap plane"; + break; + } + + maps_.emplace_back(static_cast(address), plane.length); + } +} + +} /* namespace libcamera */ diff --git a/src/libcamera-helpers/meson.build b/src/libcamera-helpers/meson.build new file mode 100644 index 0000000..444f212 --- /dev/null +++ b/src/libcamera-helpers/meson.build @@ -0,0 +1,6 @@ +# SPDX-License-Identifier: CC0-1.0 + +# Implementation of internal libcamera internals +libcamera_helpers = files([ + 'mapped_buffer.cpp', +]) diff --git a/src/meson.build b/src/meson.build new file mode 100644 index 0000000..e6b735e --- /dev/null +++ b/src/meson.build @@ -0,0 +1,3 @@ +#SPDX-License-Identifier: CC0-1.0 + +subdir('libcamera-helpers') -- cgit v1.2.1