NekoCWD/libcamera
NekoCWD/libcamera
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages 7 Wiki Activity Actions

libcamera: Rename V4L2Device to V4L2VideoDevice

Browse source 
In preparation of creating a new V4L2Device base class, rename
V4L2Device to V4L2VideoDevice.

This is a project wide rename without any intended functional change.

Signed-off-by: Jacopo Mondi <jacopo@jmondi.org>
Signed-off-by: Kieran Bingham <kieran.bingham@ideasonboard.com>
Reviewed-by: Kieran Bingham <kieran.bingham@ideasonboard.com>
Reviewed-by: Niklas Söderlund <niklas.soderlund@ragnatech.se>
Reviewed-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
This commit is contained in:
Jacopo Mondi 2019-06-12 13:09:57 +01:00
parent 20807a8c17
commit 3a6c4bd146
19 changed files with 130 additions and 129 deletions
Download patch file Download diff file Expand all files Collapse all files

2
include/libcamera/buffer.h
View file

@ -59,7 +59,7 @@ private:
friend class BufferPool; friend class BufferPool;
friend class PipelineHandler; friend class PipelineHandler;
friend class Request; friend class Request;
friend class V4L2Device; friend class V4L2VideoDevice;
void cancel(); void cancel();

24
src/libcamera/include/v4l2_device.h → src/libcamera/include/v4l2_videodevice.h
View file

@ -2,10 +2,10 @@
/* /*
* Copyright (C) 2019, Google Inc. * Copyright (C) 2019, Google Inc.
* *
* v4l2_device.h - V4L2 Device * v4l2_videodevice.h - V4L2 Video Device
*/ */
#ifndef __LIBCAMERA_V4L2_DEVICE_H__ #ifndef __LIBCAMERA_V4L2_VIDEODEVICE_H__
#define __LIBCAMERA_V4L2_DEVICE_H__ #define __LIBCAMERA_V4L2_VIDEODEVICE_H__
#include <atomic> #include <atomic>
#include <string> #include <string>
@ -112,15 +112,15 @@ public:
const std::string toString() const; const std::string toString() const;
}; };
class V4L2Device : protected Loggable class V4L2VideoDevice : protected Loggable
{ {
public: public:
explicit V4L2Device(const std::string &deviceNode); explicit V4L2VideoDevice(const std::string &deviceNode);
explicit V4L2Device(const MediaEntity *entity); explicit V4L2VideoDevice(const MediaEntity *entity);
V4L2Device(const V4L2Device &) = delete; V4L2VideoDevice(const V4L2VideoDevice &) = delete;
~V4L2Device(); ~V4L2VideoDevice();
V4L2Device &operator=(const V4L2Device &) = delete; V4L2VideoDevice &operator=(const V4L2VideoDevice &) = delete;
int open(); int open();
bool isOpen() const; bool isOpen() const;
@ -145,8 +145,8 @@ public:
int streamOn(); int streamOn();
int streamOff(); int streamOff();
static V4L2Device *fromEntityName(const MediaDevice *media, static V4L2VideoDevice *fromEntityName(const MediaDevice *media,
const std::string &entity); const std::string &entity);
protected: protected:
std::string logPrefix() const; std::string logPrefix() const;
@ -186,4 +186,4 @@ private:
} /* namespace libcamera */ } /* namespace libcamera */
#endif /* __LIBCAMERA_V4L2_DEVICE_H__ */ #endif /* __LIBCAMERA_V4L2_VIDEODEVICE_H__ */

4
src/libcamera/meson.build
View file

@ -23,8 +23,8 @@ libcamera_sources = files([
'stream.cpp', 'stream.cpp',
'timer.cpp', 'timer.cpp',
'utils.cpp', 'utils.cpp',
'v4l2_device.cpp',
'v4l2_subdevice.cpp', 'v4l2_subdevice.cpp',
'v4l2_videodevice.cpp',
]) ])
libcamera_headers = files([ libcamera_headers = files([
@ -41,8 +41,8 @@ libcamera_headers = files([
'include/media_object.h', 'include/media_object.h',
'include/pipeline_handler.h', 'include/pipeline_handler.h',
'include/utils.h', 'include/utils.h',
'include/v4l2_device.h',
'include/v4l2_subdevice.h', 'include/v4l2_subdevice.h',
'include/v4l2_videodevice.h',
]) ])
libcamera_internal_includes = include_directories('include') libcamera_internal_includes = include_directories('include')

24
src/libcamera/pipeline/ipu3/ipu3.cpp
View file

@ -22,8 +22,8 @@
#include "media_device.h" #include "media_device.h"
#include "pipeline_handler.h" #include "pipeline_handler.h"
#include "utils.h" #include "utils.h"
#include "v4l2_device.h"
#include "v4l2_subdevice.h" #include "v4l2_subdevice.h"
#include "v4l2_videodevice.h"
namespace libcamera { namespace libcamera {
@ -39,7 +39,7 @@ public:
/* ImgU output descriptor: group data specific to an ImgU output. */ /* ImgU output descriptor: group data specific to an ImgU output. */
struct ImgUOutput { struct ImgUOutput {
V4L2Device *dev; V4L2VideoDevice *dev;
unsigned int pad; unsigned int pad;
std::string name; std::string name;
BufferPool *pool; BufferPool *pool;
@ -85,7 +85,7 @@ public:
MediaDevice *media_; MediaDevice *media_;
V4L2Subdevice *imgu_; V4L2Subdevice *imgu_;
V4L2Device *input_; V4L2VideoDevice *input_;
ImgUOutput output_; ImgUOutput output_;
ImgUOutput viewfinder_; ImgUOutput viewfinder_;
ImgUOutput stat_; ImgUOutput stat_;
@ -125,7 +125,7 @@ public:
static int mediaBusToFormat(unsigned int code); static int mediaBusToFormat(unsigned int code);
V4L2Device *output_; V4L2VideoDevice *output_;
V4L2Subdevice *csi2_; V4L2Subdevice *csi2_;
CameraSensor *sensor_; CameraSensor *sensor_;
@ -943,7 +943,7 @@ void IPU3CameraData::cio2BufferReady(Buffer *buffer)
* Create and open the V4L2 devices and subdevices of the ImgU instance * Create and open the V4L2 devices and subdevices of the ImgU instance
* with \a index. * with \a index.
* *
* In case of errors the created V4L2Device and V4L2Subdevice instances * In case of errors the created V4L2VideoDevice and V4L2Subdevice instances
* are destroyed at pipeline handler delete time. * are destroyed at pipeline handler delete time.
* *
* \return 0 on success or a negative error code otherwise * \return 0 on success or a negative error code otherwise
@ -966,12 +966,12 @@ int ImgUDevice::init(MediaDevice *media, unsigned int index)
if (ret) if (ret)
return ret; return ret;
input_ = V4L2Device::fromEntityName(media, name_ + " input"); input_ = V4L2VideoDevice::fromEntityName(media, name_ + " input");
ret = input_->open(); ret = input_->open();
if (ret) if (ret)
return ret; return ret;
output_.dev = V4L2Device::fromEntityName(media, name_ + " output"); output_.dev = V4L2VideoDevice::fromEntityName(media, name_ + " output");
ret = output_.dev->open(); ret = output_.dev->open();
if (ret) if (ret)
return ret; return ret;
@ -980,8 +980,8 @@ int ImgUDevice::init(MediaDevice *media, unsigned int index)
output_.name = "output"; output_.name = "output";
output_.pool = &outPool_; output_.pool = &outPool_;
viewfinder_.dev = V4L2Device::fromEntityName(media, viewfinder_.dev = V4L2VideoDevice::fromEntityName(media,
name_ + " viewfinder"); name_ + " viewfinder");
ret = viewfinder_.dev->open(); ret = viewfinder_.dev->open();
if (ret) if (ret)
return ret; return ret;
@ -990,7 +990,7 @@ int ImgUDevice::init(MediaDevice *media, unsigned int index)
viewfinder_.name = "viewfinder"; viewfinder_.name = "viewfinder";
viewfinder_.pool = &vfPool_; viewfinder_.pool = &vfPool_;
stat_.dev = V4L2Device::fromEntityName(media, name_ + " 3a stat"); stat_.dev = V4L2VideoDevice::fromEntityName(media, name_ + " 3a stat");
ret = stat_.dev->open(); ret = stat_.dev->open();
if (ret) if (ret)
return ret; return ret;
@ -1067,7 +1067,7 @@ int ImgUDevice::configureInput(const Size &size,
int ImgUDevice::configureOutput(ImgUOutput *output, int ImgUDevice::configureOutput(ImgUOutput *output,
const StreamConfiguration &cfg) const StreamConfiguration &cfg)
{ {
V4L2Device *dev = output->dev; V4L2VideoDevice *dev = output->dev;
unsigned int pad = output->pad; unsigned int pad = output->pad;
V4L2SubdeviceFormat imguFormat = {}; V4L2SubdeviceFormat imguFormat = {};
@ -1337,7 +1337,7 @@ int CIO2Device::init(const MediaDevice *media, unsigned int index)
return ret; return ret;
std::string cio2Name = "ipu3-cio2 " + std::to_string(index); std::string cio2Name = "ipu3-cio2 " + std::to_string(index);
output_ = V4L2Device::fromEntityName(media, cio2Name); output_ = V4L2VideoDevice::fromEntityName(media, cio2Name);
ret = output_->open(); ret = output_->open();
if (ret) if (ret)
return ret; return ret;

6
src/libcamera/pipeline/rkisp1/rkisp1.cpp
View file

@ -23,8 +23,8 @@
#include "media_device.h" #include "media_device.h"
#include "pipeline_handler.h" #include "pipeline_handler.h"
#include "utils.h" #include "utils.h"
#include "v4l2_device.h"
#include "v4l2_subdevice.h" #include "v4l2_subdevice.h"
#include "v4l2_videodevice.h"
namespace libcamera { namespace libcamera {
@ -106,7 +106,7 @@ private:
MediaDevice *media_; MediaDevice *media_;
V4L2Subdevice *dphy_; V4L2Subdevice *dphy_;
V4L2Subdevice *isp_; V4L2Subdevice *isp_;
V4L2Device *video_; V4L2VideoDevice *video_;
Camera *activeCamera_; Camera *activeCamera_;
}; };
@ -458,7 +458,7 @@ bool PipelineHandlerRkISP1::match(DeviceEnumerator *enumerator)
return false; return false;
/* Locate and open the capture video node. */ /* Locate and open the capture video node. */
video_ = V4L2Device::fromEntityName(media_, "rkisp1_mainpath"); video_ = V4L2VideoDevice::fromEntityName(media_, "rkisp1_mainpath");
if (video_->open() < 0) if (video_->open() < 0)
return false; return false;

6
src/libcamera/pipeline/uvcvideo.cpp
View file

@ -16,7 +16,7 @@
#include "media_device.h" #include "media_device.h"
#include "pipeline_handler.h" #include "pipeline_handler.h"
#include "utils.h" #include "utils.h"
#include "v4l2_device.h" #include "v4l2_videodevice.h"
namespace libcamera { namespace libcamera {
@ -37,7 +37,7 @@ public:
void bufferReady(Buffer *buffer); void bufferReady(Buffer *buffer);
V4L2Device *video_; V4L2VideoDevice *video_;
Stream stream_; Stream stream_;
}; };
@ -250,7 +250,7 @@ bool PipelineHandlerUVC::match(DeviceEnumerator *enumerator)
/* Locate and open the default video node. */ /* Locate and open the default video node. */
for (MediaEntity *entity : media->entities()) { for (MediaEntity *entity : media->entities()) {
if (entity->flags() & MEDIA_ENT_FL_DEFAULT) { if (entity->flags() & MEDIA_ENT_FL_DEFAULT) {
data->video_ = new V4L2Device(entity); data->video_ = new V4L2VideoDevice(entity);
break; break;
} }
} }

6
src/libcamera/pipeline/vimc.cpp
View file

@ -20,7 +20,7 @@
#include "media_device.h" #include "media_device.h"
#include "pipeline_handler.h" #include "pipeline_handler.h"
#include "utils.h" #include "utils.h"
#include "v4l2_device.h" #include "v4l2_videodevice.h"
namespace libcamera { namespace libcamera {
@ -41,7 +41,7 @@ public:
void bufferReady(Buffer *buffer); void bufferReady(Buffer *buffer);
V4L2Device *video_; V4L2VideoDevice *video_;
Stream stream_; Stream stream_;
}; };
@ -262,7 +262,7 @@ bool PipelineHandlerVimc::match(DeviceEnumerator *enumerator)
std::unique_ptr<VimcCameraData> data = utils::make_unique<VimcCameraData>(this); std::unique_ptr<VimcCameraData> data = utils::make_unique<VimcCameraData>(this);
/* Locate and open the capture video node. */ /* Locate and open the capture video node. */
data->video_ = new V4L2Device(media->getEntityByName("Raw Capture 1")); data->video_ = new V4L2VideoDevice(media->getEntityByName("Raw Capture 1"));
if (data->video_->open()) if (data->video_->open())
return false; return false;

2
src/libcamera/v4l2_subdevice.cpp
View file

@ -44,7 +44,7 @@ LOG_DEFINE_CATEGORY(V4L2Subdev)
* as the "media bus format", and it is identified by a resolution and a pixel * as the "media bus format", and it is identified by a resolution and a pixel
* format identification code, known as the "media bus code", not to be confused * format identification code, known as the "media bus code", not to be confused
* with the fourcc code that identify the format of images when stored in memory * with the fourcc code that identify the format of images when stored in memory
* (see V4L2Device::V4L2DeviceFormat). * (see V4L2VideoDevice::V4L2DeviceFormat).
* *
* Media Bus formats supported by the V4L2 APIs are described in Section * Media Bus formats supported by the V4L2 APIs are described in Section
* 4.15.3.4.1 of the "Part I - Video for Linux API" chapter of the "Linux Media * 4.15.3.4.1 of the "Part I - Video for Linux API" chapter of the "Linux Media

107
src/libcamera/v4l2_device.cpp → src/libcamera/v4l2_videodevice.cpp
View file

@ -2,10 +2,10 @@
/* /*
* Copyright (C) 2019, Google Inc. * Copyright (C) 2019, Google Inc.
* *
* v4l2_device.cpp - V4L2 Device * v4l2_videodevice.cpp - V4L2 Video Device
*/ */
#include "v4l2_device.h" #include "v4l2_videodevice.h"
#include <fcntl.h> #include <fcntl.h>
#include <iomanip> #include <iomanip>
@ -25,8 +25,8 @@
#include "media_object.h" #include "media_object.h"
/** /**
* \file v4l2_device.h * \file v4l2_videodevice.h
* \brief V4L2 Device API * \brief V4L2 Video Device API
*/ */
namespace libcamera { namespace libcamera {
@ -243,8 +243,8 @@ const std::string V4L2DeviceFormat::toString() const
} }
/** /**
* \class V4L2Device * \class V4L2VideoDevice
* \brief V4L2Device object and API * \brief V4L2VideoDevice object and API
* *
* The V4L2 Device API class models an instance of a V4L2 device node. * The V4L2 Device API class models an instance of a V4L2 device node.
* It is constructed with the path to a V4L2 video device node. The device node * It is constructed with the path to a V4L2 video device node. The device node
@ -257,7 +257,7 @@ const std::string V4L2DeviceFormat::toString() const
* No API call other than open(), isOpen() and close() shall be called on an * No API call other than open(), isOpen() and close() shall be called on an
* unopened device instance. * unopened device instance.
* *
* The V4L2Device class tracks queued buffers and handles buffer events. It * The V4L2VideoDevice class tracks queued buffers and handles buffer events. It
* automatically dequeues completed buffers and emits the \ref bufferReady * automatically dequeues completed buffers and emits the \ref bufferReady
* signal. * signal.
* *
@ -266,10 +266,10 @@ const std::string V4L2DeviceFormat::toString() const
*/ */
/** /**
* \brief Construct a V4L2Device * \brief Construct a V4L2VideoDevice
* \param[in] deviceNode The file-system path to the video device node * \param[in] deviceNode The file-system path to the video device node
*/ */
V4L2Device::V4L2Device(const std::string &deviceNode) V4L2VideoDevice::V4L2VideoDevice(const std::string &deviceNode)
: deviceNode_(deviceNode), fd_(-1), bufferPool_(nullptr), : deviceNode_(deviceNode), fd_(-1), bufferPool_(nullptr),
queuedBuffersCount_(0), fdEvent_(nullptr) queuedBuffersCount_(0), fdEvent_(nullptr)
{ {
@ -282,17 +282,17 @@ V4L2Device::V4L2Device(const std::string &deviceNode)
} }
/** /**
* \brief Construct a V4L2Device from a MediaEntity * \brief Construct a V4L2VideoDevice from a MediaEntity
* \param[in] entity The MediaEntity to build the device from * \param[in] entity The MediaEntity to build the device from
* *
* Construct a V4L2Device from a MediaEntity's device node path. * Construct a V4L2VideoDevice from a MediaEntity's device node path.
*/ */
V4L2Device::V4L2Device(const MediaEntity *entity) V4L2VideoDevice::V4L2VideoDevice(const MediaEntity *entity)
: V4L2Device(entity->deviceNode()) : V4L2VideoDevice(entity->deviceNode())
{ {
} }
V4L2Device::~V4L2Device() V4L2VideoDevice::~V4L2VideoDevice()
{ {
close(); close();
} }
@ -301,7 +301,7 @@ V4L2Device::~V4L2Device()
* \brief Open a V4L2 device and query its capabilities * \brief Open a V4L2 device and query its capabilities
* \return 0 on success or a negative error code otherwise * \return 0 on success or a negative error code otherwise
*/ */
int V4L2Device::open() int V4L2VideoDevice::open()
{ {
int ret; int ret;
@ -362,7 +362,7 @@ int V4L2Device::open()
return -EINVAL; return -EINVAL;
} }
fdEvent_->activated.connect(this, &V4L2Device::bufferAvailable); fdEvent_->activated.connect(this, &V4L2VideoDevice::bufferAvailable);
fdEvent_->setEnabled(false); fdEvent_->setEnabled(false);
return 0; return 0;
@ -372,7 +372,7 @@ int V4L2Device::open()
* \brief Check if device is successfully opened * \brief Check if device is successfully opened
* \return True if the device is open, false otherwise * \return True if the device is open, false otherwise
*/ */
bool V4L2Device::isOpen() const bool V4L2VideoDevice::isOpen() const
{ {
return fd_ != -1; return fd_ != -1;
} }
@ -380,7 +380,7 @@ bool V4L2Device::isOpen() const
/** /**
* \brief Close the device, releasing any resources acquired by open() * \brief Close the device, releasing any resources acquired by open()
*/ */
void V4L2Device::close() void V4L2VideoDevice::close()
{ {
if (fd_ < 0) if (fd_ < 0)
return; return;
@ -393,30 +393,30 @@ void V4L2Device::close()
} }
/** /**
* \fn V4L2Device::driverName() * \fn V4L2VideoDevice::driverName()
* \brief Retrieve the name of the V4L2 device driver * \brief Retrieve the name of the V4L2 device driver
* \return The string containing the driver name * \return The string containing the driver name
*/ */
/** /**
* \fn V4L2Device::deviceName() * \fn V4L2VideoDevice::deviceName()
* \brief Retrieve the name of the V4L2 device * \brief Retrieve the name of the V4L2 device
* \return The string containing the device name * \return The string containing the device name
*/ */
/** /**
* \fn V4L2Device::busName() * \fn V4L2VideoDevice::busName()
* \brief Retrieve the location of the device in the system * \brief Retrieve the location of the device in the system
* \return The string containing the device location * \return The string containing the device location
*/ */
/** /**
* \fn V4L2Device::deviceNode() * \fn V4L2VideoDevice::deviceNode()
* \brief Retrieve the video device node path * \brief Retrieve the video device node path
* \return The video device device node path * \return The video device device node path
*/ */
std::string V4L2Device::logPrefix() const std::string V4L2VideoDevice::logPrefix() const
{ {
return deviceNode_ + (V4L2_TYPE_IS_OUTPUT(bufferType_) ? "[out]" : "[cap]"); return deviceNode_ + (V4L2_TYPE_IS_OUTPUT(bufferType_) ? "[out]" : "[cap]");
} }
@ -426,7 +426,7 @@ std::string V4L2Device::logPrefix() const
* \param[out] format The image format applied on the device * \param[out] format The image format applied on the device
* \return 0 on success or a negative error code otherwise * \return 0 on success or a negative error code otherwise
*/ */
int V4L2Device::getFormat(V4L2DeviceFormat *format) int V4L2VideoDevice::getFormat(V4L2DeviceFormat *format)
{ {
if (caps_.isMeta()) if (caps_.isMeta())
return getFormatMeta(format); return getFormatMeta(format);
@ -441,11 +441,11 @@ int V4L2Device::getFormat(V4L2DeviceFormat *format)
* \param[inout] format The image format to apply to the device * \param[inout] format The image format to apply to the device
* *
* Apply the supplied \a format to the device, and return the actually * Apply the supplied \a format to the device, and return the actually
* applied format parameters, as \ref V4L2Device::getFormat would do. * applied format parameters, as \ref V4L2VideoDevice::getFormat would do.
* *
* \return 0 on success or a negative error code otherwise * \return 0 on success or a negative error code otherwise
*/ */
int V4L2Device::setFormat(V4L2DeviceFormat *format) int V4L2VideoDevice::setFormat(V4L2DeviceFormat *format)
{ {
if (caps_.isMeta()) if (caps_.isMeta())
return setFormatMeta(format); return setFormatMeta(format);
@ -455,7 +455,7 @@ int V4L2Device::setFormat(V4L2DeviceFormat *format)
return setFormatSingleplane(format); return setFormatSingleplane(format);
} }
int V4L2Device::getFormatMeta(V4L2DeviceFormat *format) int V4L2VideoDevice::getFormatMeta(V4L2DeviceFormat *format)
{ {
struct v4l2_format v4l2Format = {}; struct v4l2_format v4l2Format = {};
struct v4l2_meta_format *pix = &v4l2Format.fmt.meta; struct v4l2_meta_format *pix = &v4l2Format.fmt.meta;
@ -479,7 +479,7 @@ int V4L2Device::getFormatMeta(V4L2DeviceFormat *format)
return 0; return 0;
} }
int V4L2Device::setFormatMeta(V4L2DeviceFormat *format) int V4L2VideoDevice::setFormatMeta(V4L2DeviceFormat *format)
{ {
struct v4l2_format v4l2Format = {}; struct v4l2_format v4l2Format = {};
struct v4l2_meta_format *pix = &v4l2Format.fmt.meta; struct v4l2_meta_format *pix = &v4l2Format.fmt.meta;
@ -509,7 +509,7 @@ int V4L2Device::setFormatMeta(V4L2DeviceFormat *format)
return 0; return 0;
} }
int V4L2Device::getFormatMultiplane(V4L2DeviceFormat *format) int V4L2VideoDevice::getFormatMultiplane(V4L2DeviceFormat *format)
{ {
struct v4l2_format v4l2Format = {}; struct v4l2_format v4l2Format = {};
struct v4l2_pix_format_mplane *pix = &v4l2Format.fmt.pix_mp; struct v4l2_pix_format_mplane *pix = &v4l2Format.fmt.pix_mp;
@ -536,7 +536,7 @@ int V4L2Device::getFormatMultiplane(V4L2DeviceFormat *format)
return 0; return 0;
} }
int V4L2Device::setFormatMultiplane(V4L2DeviceFormat *format) int V4L2VideoDevice::setFormatMultiplane(V4L2DeviceFormat *format)
{ {
struct v4l2_format v4l2Format = {}; struct v4l2_format v4l2Format = {};
struct v4l2_pix_format_mplane *pix = &v4l2Format.fmt.pix_mp; struct v4l2_pix_format_mplane *pix = &v4l2Format.fmt.pix_mp;
@ -577,7 +577,7 @@ int V4L2Device::setFormatMultiplane(V4L2DeviceFormat *format)
return 0; return 0;
} }
int V4L2Device::getFormatSingleplane(V4L2DeviceFormat *format) int V4L2VideoDevice::getFormatSingleplane(V4L2DeviceFormat *format)
{ {
struct v4l2_format v4l2Format = {}; struct v4l2_format v4l2Format = {};
struct v4l2_pix_format *pix = &v4l2Format.fmt.pix; struct v4l2_pix_format *pix = &v4l2Format.fmt.pix;
@ -601,7 +601,7 @@ int V4L2Device::getFormatSingleplane(V4L2DeviceFormat *format)
return 0; return 0;
} }
int V4L2Device::setFormatSingleplane(V4L2DeviceFormat *format) int V4L2VideoDevice::setFormatSingleplane(V4L2DeviceFormat *format)
{ {
struct v4l2_format v4l2Format = {}; struct v4l2_format v4l2Format = {};
struct v4l2_pix_format *pix = &v4l2Format.fmt.pix; struct v4l2_pix_format *pix = &v4l2Format.fmt.pix;
@ -641,7 +641,7 @@ int V4L2Device::setFormatSingleplane(V4L2DeviceFormat *format)
* *
* \return A list of the supported device formats * \return A list of the supported device formats
*/ */
ImageFormats V4L2Device::formats() ImageFormats V4L2VideoDevice::formats()
{ {
ImageFormats formats; ImageFormats formats;
@ -661,7 +661,7 @@ ImageFormats V4L2Device::formats()
return formats; return formats;
} }
int V4L2Device::requestBuffers(unsigned int count) int V4L2VideoDevice::requestBuffers(unsigned int count)
{ {
struct v4l2_requestbuffers rb = {}; struct v4l2_requestbuffers rb = {};
int ret; int ret;
@ -690,7 +690,7 @@ int V4L2Device::requestBuffers(unsigned int count)
* \param[out] pool BufferPool to populate with buffers * \param[out] pool BufferPool to populate with buffers
* \return 0 on success or a negative error code otherwise * \return 0 on success or a negative error code otherwise
*/ */
int V4L2Device::exportBuffers(BufferPool *pool) int V4L2VideoDevice::exportBuffers(BufferPool *pool)
{ {
unsigned int allocatedBuffers; unsigned int allocatedBuffers;
unsigned int i; unsigned int i;
@ -704,7 +704,8 @@ int V4L2Device::exportBuffers(BufferPool *pool)
allocatedBuffers = ret; allocatedBuffers = ret;
if (allocatedBuffers < pool->count()) { if (allocatedBuffers < pool->count()) {
LOG(V4L2, Error) << "Not enough buffers provided by V4L2Device"; LOG(V4L2, Error)
<< "Not enough buffers provided by V4L2VideoDevice";
requestBuffers(0); requestBuffers(0);
return -ENOMEM; return -ENOMEM;
} }
@ -758,8 +759,8 @@ int V4L2Device::exportBuffers(BufferPool *pool)
return 0; return 0;
} }
int V4L2Device::createPlane(Buffer *buffer, unsigned int planeIndex, int V4L2VideoDevice::createPlane(Buffer *buffer, unsigned int planeIndex,
unsigned int length) unsigned int length)
{ {
struct v4l2_exportbuffer expbuf = {}; struct v4l2_exportbuffer expbuf = {};
int ret; int ret;
@ -790,7 +791,7 @@ int V4L2Device::createPlane(Buffer *buffer, unsigned int planeIndex,
return 0; return 0;
} }
std::vector<unsigned int> V4L2Device::enumPixelformats() std::vector<unsigned int> V4L2VideoDevice::enumPixelformats()
{ {
std::vector<unsigned int> formats; std::vector<unsigned int> formats;
int ret; int ret;
@ -818,7 +819,7 @@ std::vector<unsigned int> V4L2Device::enumPixelformats()
return formats; return formats;
} }
std::vector<SizeRange> V4L2Device::enumSizes(unsigned int pixelFormat) std::vector<SizeRange> V4L2VideoDevice::enumSizes(unsigned int pixelFormat)
{ {
std::vector<SizeRange> sizes; std::vector<SizeRange> sizes;
int ret; int ret;
@ -882,7 +883,7 @@ std::vector<SizeRange> V4L2Device::enumSizes(unsigned int pixelFormat)
* \param[in] pool BufferPool of buffers to import * \param[in] pool BufferPool of buffers to import
* \return 0 on success or a negative error code otherwise * \return 0 on success or a negative error code otherwise
*/ */
int V4L2Device::importBuffers(BufferPool *pool) int V4L2VideoDevice::importBuffers(BufferPool *pool)
{ {
unsigned int allocatedBuffers; unsigned int allocatedBuffers;
int ret; int ret;
@ -896,7 +897,7 @@ int V4L2Device::importBuffers(BufferPool *pool)
allocatedBuffers = ret; allocatedBuffers = ret;
if (allocatedBuffers < pool->count()) { if (allocatedBuffers < pool->count()) {
LOG(V4L2, Error) LOG(V4L2, Error)
<< "Not enough buffers provided by V4L2Device"; << "Not enough buffers provided by V4L2VideoDevice";
requestBuffers(0); requestBuffers(0);
return -ENOMEM; return -ENOMEM;
} }
@ -910,7 +911,7 @@ int V4L2Device::importBuffers(BufferPool *pool)
/** /**
* \brief Release all internally allocated buffers * \brief Release all internally allocated buffers
*/ */
int V4L2Device::releaseBuffers() int V4L2VideoDevice::releaseBuffers()
{ {
LOG(V4L2, Debug) << "Releasing bufferPool"; LOG(V4L2, Debug) << "Releasing bufferPool";
@ -930,7 +931,7 @@ int V4L2Device::releaseBuffers()
* *
* \return 0 on success or a negative error code otherwise * \return 0 on success or a negative error code otherwise
*/ */
int V4L2Device::queueBuffer(Buffer *buffer) int V4L2VideoDevice::queueBuffer(Buffer *buffer)
{ {
struct v4l2_buffer buf = {}; struct v4l2_buffer buf = {};
struct v4l2_plane planes[VIDEO_MAX_PLANES] = {}; struct v4l2_plane planes[VIDEO_MAX_PLANES] = {};
@ -991,7 +992,7 @@ int V4L2Device::queueBuffer(Buffer *buffer)
* *
* \return A pointer to the dequeued buffer on success, or nullptr otherwise * \return A pointer to the dequeued buffer on success, or nullptr otherwise
*/ */
Buffer *V4L2Device::dequeueBuffer() Buffer *V4L2VideoDevice::dequeueBuffer()
{ {
struct v4l2_buffer buf = {}; struct v4l2_buffer buf = {};
struct v4l2_plane planes[VIDEO_MAX_PLANES] = {}; struct v4l2_plane planes[VIDEO_MAX_PLANES] = {};
@ -1040,7 +1041,7 @@ Buffer *V4L2Device::dequeueBuffer()
* For Capture devices the Buffer will contain valid data. * For Capture devices the Buffer will contain valid data.
* For Output devices the Buffer can be considered empty. * For Output devices the Buffer can be considered empty.
*/ */
void V4L2Device::bufferAvailable(EventNotifier *notifier) void V4L2VideoDevice::bufferAvailable(EventNotifier *notifier)
{ {
Buffer *buffer = dequeueBuffer(); Buffer *buffer = dequeueBuffer();
if (!buffer) if (!buffer)
@ -1053,7 +1054,7 @@ void V4L2Device::bufferAvailable(EventNotifier *notifier)
} }
/** /**
* \var V4L2Device::bufferReady * \var V4L2VideoDevice::bufferReady
* \brief A Signal emitted when a buffer completes * \brief A Signal emitted when a buffer completes
*/ */
@ -1061,7 +1062,7 @@ void V4L2Device::bufferAvailable(EventNotifier *notifier)
* \brief Start the video stream * \brief Start the video stream
* \return 0 on success or a negative error code otherwise * \return 0 on success or a negative error code otherwise
*/ */
int V4L2Device::streamOn() int V4L2VideoDevice::streamOn()
{ {
int ret; int ret;
@ -1084,7 +1085,7 @@ int V4L2Device::streamOn()
* *
* \return 0 on success or a negative error code otherwise * \return 0 on success or a negative error code otherwise
*/ */
int V4L2Device::streamOff() int V4L2VideoDevice::streamOff()
{ {
int ret; int ret;
@ -1111,16 +1112,16 @@ int V4L2Device::streamOff()
* Releasing memory of the newly created instance is responsibility of the * Releasing memory of the newly created instance is responsibility of the
* caller of this function. * caller of this function.
* *
* \return A newly created V4L2Device on success, nullptr otherwise * \return A newly created V4L2VideoDevice on success, nullptr otherwise
*/ */
V4L2Device *V4L2Device::fromEntityName(const MediaDevice *media, V4L2VideoDevice *V4L2VideoDevice::fromEntityName(const MediaDevice *media,
const std::string &entity) const std::string &entity)
{ {
MediaEntity *mediaEntity = media->getEntityByName(entity); MediaEntity *mediaEntity = media->getEntityByName(entity);
if (!mediaEntity) if (!mediaEntity)
return nullptr; return nullptr;
return new V4L2Device(mediaEntity); return new V4L2VideoDevice(mediaEntity);
} }
} /* namespace libcamera */ } /* namespace libcamera */

2
test/meson.build
View file

@ -5,8 +5,8 @@ subdir('ipa')
subdir('media_device') subdir('media_device')
subdir('pipeline') subdir('pipeline')
subdir('stream') subdir('stream')
subdir('v4l2_device')
subdir('v4l2_subdevice') subdir('v4l2_subdevice')
subdir('v4l2_videodevice')
public_tests = [ public_tests = [
['event', 'event.cpp'], ['event', 'event.cpp'],

18
test/v4l2_device/buffer_sharing.cpp → test/v4l2_videodevice/buffer_sharing.cpp
View file

@ -4,8 +4,8 @@
* *
* libcamera V4L2 API tests * libcamera V4L2 API tests
* *
* Validate the function of exporting buffers from a V4L2Device and * Validate the function of exporting buffers from a V4L2VideoDevice and
* the ability to import them to another V4L2Device instance. * the ability to import them to another V4L2VideoDevice instance.
* Ensure that the Buffers can successfully be queued and dequeued * Ensure that the Buffers can successfully be queued and dequeued
* between both devices. * between both devices.
*/ */
@ -17,19 +17,19 @@
#include <libcamera/event_dispatcher.h> #include <libcamera/event_dispatcher.h>
#include <libcamera/timer.h> #include <libcamera/timer.h>
#include "v4l2_device_test.h" #include "v4l2_videodevice_test.h"
class BufferSharingTest : public V4L2DeviceTest class BufferSharingTest : public V4L2VideoDeviceTest
{ {
public: public:
BufferSharingTest() BufferSharingTest()
: V4L2DeviceTest("vivid", "vivid-000-vid-cap"), : V4L2VideoDeviceTest("vivid", "vivid-000-vid-cap"),
output_(nullptr), framesCaptured_(0), framesOutput_(0) {} output_(nullptr), framesCaptured_(0), framesOutput_(0) {}
protected: protected:
int init() int init()
{ {
int ret = V4L2DeviceTest::init(); int ret = V4L2VideoDeviceTest::init();
if (ret) if (ret)
return ret; return ret;
@ -38,7 +38,7 @@ protected:
if (!entity) if (!entity)
return TestSkip; return TestSkip;
output_ = new V4L2Device(entity); output_ = new V4L2VideoDevice(entity);
if (!output_) { if (!output_) {
std::cout << "Failed to create output device" << std::endl; std::cout << "Failed to create output device" << std::endl;
return TestFail; return TestFail;
@ -171,13 +171,13 @@ protected:
delete output_; delete output_;
V4L2DeviceTest::cleanup(); V4L2VideoDeviceTest::cleanup();
} }
private: private:
const unsigned int bufferCount = 4; const unsigned int bufferCount = 4;
V4L2Device *output_; V4L2VideoDevice *output_;
unsigned int framesCaptured_; unsigned int framesCaptured_;
unsigned int framesOutput_; unsigned int framesOutput_;

6
test/v4l2_device/capture_async.cpp → test/v4l2_videodevice/capture_async.cpp
View file

@ -12,13 +12,13 @@
#include <iostream> #include <iostream>
#include "v4l2_device_test.h" #include "v4l2_videodevice_test.h"
class CaptureAsyncTest : public V4L2DeviceTest class CaptureAsyncTest : public V4L2VideoDeviceTest
{ {
public: public:
CaptureAsyncTest() CaptureAsyncTest()
: V4L2DeviceTest("vimc", "Raw Capture 0"), frames(0) {} : V4L2VideoDeviceTest("vimc", "Raw Capture 0"), frames(0) {}
void receiveBuffer(Buffer *buffer) void receiveBuffer(Buffer *buffer)
{ {

8
test/v4l2_device/double_open.cpp → test/v4l2_videodevice/double_open.cpp
View file

@ -7,15 +7,15 @@
#include <iostream> #include <iostream>
#include "v4l2_device_test.h" #include "v4l2_videodevice_test.h"
namespace { namespace {
class DoubleOpen : public V4L2DeviceTest class DoubleOpen : public V4L2VideoDeviceTest
{ {
public: public:
DoubleOpen() DoubleOpen()
: V4L2DeviceTest("vimc", "Raw Capture 0") {} : V4L2VideoDeviceTest("vimc", "Raw Capture 0") {}
protected: protected:
int run() int run()
{ {
@ -23,7 +23,7 @@ protected:
/* /*
* Expect failure: The device has already been opened by the * Expect failure: The device has already been opened by the
* V4L2DeviceTest base class * V4L2VideoDeviceTest base class
*/ */
ret = capture_->open(); ret = capture_->open();
if (!ret) { if (!ret) {

8
test/v4l2_device/formats.cpp → test/v4l2_videodevice/formats.cpp
View file

@ -8,18 +8,18 @@
#include <climits> #include <climits>
#include <iostream> #include <iostream>
#include "v4l2_device.h" #include "v4l2_videodevice.h"
#include "v4l2_device_test.h" #include "v4l2_videodevice_test.h"
using namespace std; using namespace std;
using namespace libcamera; using namespace libcamera;
class Format : public V4L2DeviceTest class Format : public V4L2VideoDeviceTest
{ {
public: public:
Format() Format()
: V4L2DeviceTest("vimc", "Raw Capture 0") {} : V4L2VideoDeviceTest("vimc", "Raw Capture 0") {}
protected: protected:
int run() int run()
{ {

8
test/v4l2_device/meson.build → test/v4l2_videodevice/meson.build
View file

@ -1,6 +1,6 @@
# Tests are listed in order of complexity. # Tests are listed in order of complexity.
# They are not alphabetically sorted. # They are not alphabetically sorted.
v4l2_device_tests = [ v4l2_videodevice_tests = [
[ 'double_open', 'double_open.cpp' ], [ 'double_open', 'double_open.cpp' ],
[ 'formats', 'formats.cpp' ], [ 'formats', 'formats.cpp' ],
[ 'request_buffers', 'request_buffers.cpp' ], [ 'request_buffers', 'request_buffers.cpp' ],
@ -9,10 +9,10 @@ v4l2_device_tests = [
[ 'buffer_sharing', 'buffer_sharing.cpp' ], [ 'buffer_sharing', 'buffer_sharing.cpp' ],
] ]
foreach t : v4l2_device_tests foreach t : v4l2_videodevice_tests
exe = executable(t[0], [t[1], 'v4l2_device_test.cpp'], exe = executable(t[0], [t[1], 'v4l2_videodevice_test.cpp'],
dependencies : libcamera_dep, dependencies : libcamera_dep,
link_with : test_libraries, link_with : test_libraries,
include_directories : test_includes_internal) include_directories : test_includes_internal)
test(t[0], exe, suite : 'v4l2_device', is_parallel : false) test(t[0], exe, suite : 'v4l2_videodevice', is_parallel : false)
endforeach endforeach

6
test/v4l2_device/request_buffers.cpp → test/v4l2_videodevice/request_buffers.cpp
View file

@ -5,13 +5,13 @@
* libcamera V4L2 API tests * libcamera V4L2 API tests
*/ */
#include "v4l2_device_test.h" #include "v4l2_videodevice_test.h"
class RequestBuffersTest : public V4L2DeviceTest class RequestBuffersTest : public V4L2VideoDeviceTest
{ {
public: public:
RequestBuffersTest() RequestBuffersTest()
: V4L2DeviceTest("vimc", "Raw Capture 0") {} : V4L2VideoDeviceTest("vimc", "Raw Capture 0") {}
protected: protected:
int run() int run()

6
test/v4l2_device/stream_on_off.cpp → test/v4l2_videodevice/stream_on_off.cpp
View file

@ -5,13 +5,13 @@
* libcamera V4L2 API tests * libcamera V4L2 API tests
*/ */
#include "v4l2_device_test.h" #include "v4l2_videodevice_test.h"
class StreamOnStreamOffTest : public V4L2DeviceTest class StreamOnStreamOffTest : public V4L2VideoDeviceTest
{ {
public: public:
StreamOnStreamOffTest() StreamOnStreamOffTest()
: V4L2DeviceTest("vimc", "Raw Capture 0") {} : V4L2VideoDeviceTest("vimc", "Raw Capture 0") {}
protected: protected:
int run() int run()
{ {

8
test/v4l2_device/v4l2_device_test.cpp → test/v4l2_videodevice/v4l2_videodevice_test.cpp
View file

@ -8,7 +8,7 @@
#include <iostream> #include <iostream>
#include <sys/stat.h> #include <sys/stat.h>
#include "v4l2_device_test.h" #include "v4l2_videodevice_test.h"
#include "device_enumerator.h" #include "device_enumerator.h"
#include "media_device.h" #include "media_device.h"
@ -26,7 +26,7 @@ bool exists(const std::string &path)
return false; return false;
} }
int V4L2DeviceTest::init() int V4L2VideoDeviceTest::init()
{ {
enumerator_ = DeviceEnumerator::create(); enumerator_ = DeviceEnumerator::create();
if (!enumerator_) { if (!enumerator_) {
@ -50,7 +50,7 @@ int V4L2DeviceTest::init()
if (!entity) if (!entity)
return TestSkip; return TestSkip;
capture_ = new V4L2Device(entity); capture_ = new V4L2VideoDevice(entity);
if (!capture_) if (!capture_)
return TestFail; return TestFail;
@ -77,7 +77,7 @@ int V4L2DeviceTest::init()
return TestPass; return TestPass;
} }
void V4L2DeviceTest::cleanup() void V4L2VideoDeviceTest::cleanup()
{ {
capture_->streamOff(); capture_->streamOff();
capture_->releaseBuffers(); capture_->releaseBuffers();

8
test/v4l2_device/v4l2_device_test.h → test/v4l2_videodevice/v4l2_videodevice_test.h
View file

@ -15,14 +15,14 @@
#include "device_enumerator.h" #include "device_enumerator.h"
#include "media_device.h" #include "media_device.h"
#include "v4l2_device.h" #include "v4l2_videodevice.h"
using namespace libcamera; using namespace libcamera;
class V4L2DeviceTest : public Test class V4L2VideoDeviceTest : public Test
{ {
public: public:
V4L2DeviceTest(const char *driver, const char *entity) V4L2VideoDeviceTest(const char *driver, const char *entity)
: driver_(driver), entity_(entity), capture_(nullptr) : driver_(driver), entity_(entity), capture_(nullptr)
{ {
} }
@ -35,7 +35,7 @@ protected:
std::string entity_; std::string entity_;
std::unique_ptr<DeviceEnumerator> enumerator_; std::unique_ptr<DeviceEnumerator> enumerator_;
std::shared_ptr<MediaDevice> media_; std::shared_ptr<MediaDevice> media_;
V4L2Device *capture_; V4L2VideoDevice *capture_;
BufferPool pool_; BufferPool pool_;
}; };