summaryrefslogtreecommitdiff
path: root/test/camera-sensor.cpp
AgeCommit message (Collapse)Author
2020-05-16libcamera: Move internal headers to include/libcamera/internal/Laurent Pinchart
The libcamera internal headers are located in src/libcamera/include/. The directory is added to the compiler headers search path with a meson include_directories() directive, and internal headers are included with (e.g. for the internal semaphore.h header) #include "semaphore.h" All was well, until libcxx decided to implement the C++20 synchronization library. The __threading_support header gained a #include <semaphore.h> to include the pthread's semaphore support. As include_directories() adds src/libcamera/include/ to the compiler search path with -I, the internal semaphore.h is included instead of the pthread version. Needless to say, the compiler isn't happy. Three options have been considered to fix this issue: - Use -iquote instead of -I. The -iquote option instructs gcc to only consider the header search path for headers included with the "" version. Meson unfortunately doesn't support this option. - Rename the internal semaphore.h header. This was deemed to be the beginning of a long whack-a-mole game, where namespace clashes with system libraries would appear over time (possibly dependent on particular system configurations) and would need to be constantly fixed. - Move the internal headers to another directory to create a unique namespace through path components. This causes lots of churn in all the existing source files through the all project. The first option would be best, but isn't available to us due to missing support in meson. Even if -iquote support was added, we would need to fix the problem before a new version of meson containing the required support would be released. The third option is thus the only practical solution available. Bite the bullet, and do it, moving headers to include/libcamera/internal/. Signed-off-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com> Acked-by: Jacopo Mondi <jacopo@jmondi.org>
2020-04-28test: camera_sensor: Test the model() functionLaurent Pinchart
Verify that the sensor model matches the expected value. The whole model extraction heuristic isn't fully tested as that would require being able to inject different entity names. It is still useful as an initial step. Signed-off-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com> Reviewed-by: Jacopo Mondi <jacopo@jmondi.org>
2019-10-15libcamera: utils: Add hex stream output helperLaurent Pinchart
Add a utils::hex() function that simplifies writing hexadecimal values to an ostream. The function handles the '0x' prefix, the field width and the fill character automatically. Use it through the libcamera code base, and add a test. Signed-off-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com> Reviewed-by: Niklas Söderlund <niklas.soderlund@ragnatech.se> Reviewed-by: Jacopo Mondi <jacopo@jmondi.org>
2019-08-11tests: camera-sensor: Test using invalid media bus formatNiklas Söderlund
Linux commit b6c61a6c37317efd ("media: vimc: propagate pixel format in the stream") changes the sensor in the vimc media graph to accept all media bus format currently described in Linux. This prevents the camera-sensor test case to verify that a supported media bus format is selected from a list of defined formats, fix this by using an invalid media bus format in the test case. Signed-off-by: Niklas Söderlund <niklas.soderlund@ragnatech.se> Reviewed-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
2019-06-12tests: Add CameraSensor class testLaurent Pinchart
Add a test to verify media bus codes, sizes and resolution retrieval through the CameraSensor API based on the Sensor A in the vimc pipeline. Also check that the getFormat() method returns the expected media bus code and size. Signed-off-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com> Reviewed-by: Niklas Söderlund <niklas.soderlund@ragnatech.se>
Message queue support * * The messaging API enables inter-thread communication through message * posting. Messages can be sent from any thread to any recipient deriving from * the Object class. * * To post a message, the sender allocates it dynamically as instance of a class * derived from Message. It then posts the message to an Object recipient * through Object::postMessage(). Message ownership is passed to the object, * thus the message shall not store any temporary data. * * The message is delivered in the context of the object's thread, through the * Object::message() virtual method. After delivery the message is * automatically deleted. */ namespace libcamera { LOG_DEFINE_CATEGORY(Message) std::atomic_uint Message::nextUserType_{ Message::UserMessage }; /** * \class Message * \brief A message that can be posted to a Thread */ /** * \enum Message::Type * \brief The message type * \var Message::None * \brief Invalid message type * \var Message::InvokeMessage * \brief Asynchronous method invocation across threads * \var Message::ThreadMoveMessage * \brief Object is being moved to a different thread * \var Message::UserMessage * \brief First value available for user-defined messages */ /** * \brief Construct a message object of type \a type * \param[in] type The message type */ Message::Message(Message::Type type) : type_(type) { } Message::~Message() { } /** * \fn Message::type() * \brief Retrieve the message type * \return The message type */ /** * \fn Message::receiver() * \brief Retrieve the message receiver * \return The message receiver */ /** * \brief Reserve and register a custom user-defined message type * * Custom message types use values starting at Message::UserMessage. Assigning * custom types manually may lead to accidental duplicated types. To avoid this * problem, this method reserves and returns the next available user-defined * message type. * * The recommended way to use this method is to subclass Message and provide a * static accessor for the custom message type. * * \code{.cpp} * class MyCustomMessage : public Message * { * public: * MyCustomMessage() : Message(type()) {} * * static Message::Type type() * { * static MessageType type = registerMessageType(); * return type; * } * }; * \endcode * * \return A new unique message type */ Message::Type Message::registerMessageType() { return static_cast<Message::Type>(nextUserType_++); } /** * \class InvokeMessage * \brief A message carrying a method invocation across threads */ /** * \brief Construct an InvokeMessage for method invocation on an Object * \param[in] method The bound method * \param[in] pack The packed method arguments * \param[in] semaphore The semaphore used to signal message delivery * \param[in] deleteMethod True to delete the \a method when the message is * destroyed */ InvokeMessage::InvokeMessage(BoundMethodBase *method, std::shared_ptr<BoundMethodPackBase> pack, Semaphore *semaphore, bool deleteMethod) : Message(Message::InvokeMessage), method_(method), pack_(pack), semaphore_(semaphore), deleteMethod_(deleteMethod) { } InvokeMessage::~InvokeMessage() { if (deleteMethod_) delete method_; } /** * \fn InvokeMessage::semaphore() * \brief Retrieve the message semaphore passed to the constructor * \return The message semaphore */ /** * \brief Invoke the method bound to InvokeMessage::method_ with arguments * InvokeMessage::pack_ */ void InvokeMessage::invoke() { method_->invokePack(pack_.get()); } /** * \var InvokeMessage::method_ * \brief The method to be invoked */ /** * \var InvokeMessage::pack_ * \brief The packed method invocation arguments */ } /* namespace libcamera */