626172a16b
Source files in libcamera start by a comment block header, which
includes the file name and a one-line description of the file contents.
While the latter is useful to get a quick overview of the file contents
at a glance, the former is mostly a source of inconvenience. The name in
the comments can easily get out of sync with the file name when files
are renamed, and copy & paste during development have often lead to
incorrect names being used to start with.
Readers of the source code are expected to know which file they're
looking it. Drop the file name from the header comment block.
The change was generated with the following script:
----------------------------------------
dirs="include/libcamera src test utils"
declare -rA patterns=(
['c']=' \* '
['cpp']=' \* '
['h']=' \* '
['py']='# '
['sh']='# '
)
for ext in ${!patterns[@]} ; do
files=$(for dir in $dirs ; do find $dir -name "*.${ext}" ; done)
pattern=${patterns[${ext}]}
for file in $files ; do
name=$(basename ${file})
sed -i "s/^\(${pattern}\)${name} - /\1/" "$file"
done
done
----------------------------------------
This misses several files that are out of sync with the comment block
header. Those will be addressed separately and manually.
Signed-off-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
Reviewed-by: Daniel Scally <dan.scally@ideasonboard.com>
167 lines
4.0 KiB
C++
167 lines
4.0 KiB
C++
/* SPDX-License-Identifier: LGPL-2.1-or-later */
|
|
/*
|
|
* Copyright (C) 2019, Google Inc.
|
|
*
|
|
* Message queue support
|
|
*/
|
|
|
|
#include <libcamera/base/message.h>
|
|
|
|
#include <libcamera/base/log.h>
|
|
#include <libcamera/base/signal.h>
|
|
|
|
/**
|
|
* \file base/message.h
|
|
* \brief 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 function. 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::DeferredDelete
|
|
* \brief Object is scheduled for deletion
|
|
* \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 function reserves and returns the next available user-defined
|
|
* message type.
|
|
*
|
|
* The recommended way to use this function 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 */
|