libcamera/vivid.git - libcamera pipeline handler for VIVID

diff options

author	Laurent Pinchart <laurent.pinchart@ideasonboard.com>	2024-05-08 19:28:06 +0300
committer	Laurent Pinchart <laurent.pinchart@ideasonboard.com>	2024-05-08 22:39:50 +0300
commit	626172a16bba9a601c7652569ce9410631c1e6c0 (patch)
tree	f337079cde5d77b81b39023576c6ee5e91725f1e /src/apps/qcam/meson.build
parent	fdcd5d04ec6a3b3c98a46041762cdaf4bdb76190 (diff)

libcamera: Drop file name from header comment blocks

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>

Diffstat (limited to 'src/apps/qcam/meson.build')

0 files changed, 0 insertions, 0 deletions

/* SPDX-License-Identifier: LGPL-2.1-or-later */ /* * Copyright (C) 2018, Google Inc. * * log.cpp - Logging infrastructure */ #include "log.h" #include <cstdio> #include <cstdlib> #include <ctime> #include <fstream> #include <iomanip> #include <iostream> #include <list> #include <string.h> #include <syslog.h> #include <unordered_set> #include <libcamera/logging.h> #include "utils.h" /** * \file log.h * \brief Logging infrastructure * * libcamera includes a logging infrastructure used through the library that * allows inspection of internal operation in a user-configurable way. The log * messages are grouped in categories that represent areas of libcamera, and * output of messages for each category can be controlled by independent log * levels. * * The levels are configurable through the LIBCAMERA_LOG_LEVELS environment * variable that contains a comma-separated list of 'category:level' pairs. * * The category names are strings and can include a wildcard ('*') character at * the end to match multiple categories. * * The level are either numeric values, or strings containing the log level * name. The available log levels are DEBUG, INFO, WARN, ERROR and FATAL. Log * message with a level higher than or equal to the configured log level for * their category are output to the log, while other messages are silently * discarded. * * By default log messages are output to stderr. They can be redirected to a log * file by setting the LIBCAMERA_LOG_FILE environment variable to the name of * the file. The file must be writable and is truncated if it exists. If any * error occurs when opening the file, the file is ignored and the log is output * to stderr. */ /** * \file logging.h * \brief Logging management * * API to change the logging output destination and log levels programatically. */ namespace libcamera { static int log_severity_to_syslog(LogSeverity severity) { switch (severity) { case LogDebug: return LOG_DEBUG; case LogInfo: return LOG_INFO; case LogWarning: return LOG_WARNING; case LogError: return LOG_ERR; case LogFatal: return LOG_ALERT; default: return LOG_NOTICE; } } static std::string log_timespec_to_string(const struct timespec &timestamp) { std::ostringstream ossTimestamp; ossTimestamp.fill('0'); ossTimestamp << "[" << timestamp.tv_sec / (60 * 60) << ":" << std::setw(2) << (timestamp.tv_sec / 60) % 60 << ":" << std::setw(2) << timestamp.tv_sec % 60 << "." << std::setw(9) << timestamp.tv_nsec << "]"; return ossTimestamp.str(); } static const char *log_severity_name(LogSeverity severity) { static const char *const names[] = { " DBG", " INFO", " WARN", " ERR", "FATAL", }; if (static_cast<unsigned int>(severity) < ARRAY_SIZE(names)) return names[severity]; else return "UNKWN"; } /** * \brief Log output * * The LogOutput class models a log output destination */ class LogOutput { public: LogOutput(const char *path); LogOutput(std::ostream *stream); LogOutput(); ~LogOutput(); bool isValid() const; void write(const LogMessage &msg); private: void writeSyslog(const LogMessage &msg); void writeStream(const LogMessage &msg); std::ostream *stream_; LoggingTarget target_; }; /** * \brief Construct a log output based on a file * \param[in] path Full path to log file */ LogOutput::LogOutput(const char *path) : target_(LoggingTargetFile) { stream_ = new std::ofstream(path); } /** * \brief Construct a log output based on a stream * \param[in] stream Stream to send log output to */ LogOutput::LogOutput(std::ostream *stream) : stream_(stream), target_(LoggingTargetStream) { } /** * \brief Construct a log output to syslog */ LogOutput::LogOutput() : stream_(nullptr), target_(LoggingTargetSyslog) { openlog("libcamera", LOG_PID, 0); } LogOutput::~LogOutput() { switch (target_) { case LoggingTargetFile: delete stream_; break; case LoggingTargetSyslog: closelog(); break; default: break; } } /** * \brief Check if the log output is valid * \return True if the log output is valid */ bool LogOutput::isValid() const { switch (target_) { case LoggingTargetFile: return stream_->good(); case LoggingTargetStream: return stream_ != nullptr; default: return true; } } /** * \brief Write message to log output * \param[in] msg Message to write */ void LogOutput::write(const LogMessage &msg) { switch (target_) { case LoggingTargetSyslog: writeSyslog(msg); break; case LoggingTargetStream: case LoggingTargetFile: writeStream(msg); break; default: break; } } void LogOutput::writeSyslog(const LogMessage &msg) { std::string str = std::string(log_severity_name(msg.severity())) + " " + msg.category().name() + " " + msg.fileInfo() + " " + msg.msg(); syslog(log_severity_to_syslog(msg.severity()), "%s", str.c_str()); } void LogOutput::writeStream(const LogMessage &msg) { std::string str = std::string(log_timespec_to_string(msg.timestamp()) + log_severity_name(msg.severity()) + " " + msg.category().name() + " " + msg.fileInfo() + " " + msg.msg()); stream_->write(str.c_str(), str.size()); stream_->flush(); } /** * \brief Message logger * * The Logger class handles log configuration. */ class Logger { public: static Logger *instance(); void write(const LogMessage &msg); int logSetFile(const char *path); int logSetStream(std::ostream *stream); int logSetTarget(LoggingTarget target); void logSetLevel(const char *category, const char *level); private: Logger(); void parseLogFile(); void parseLogLevels(); static LogSeverity parseLogLevel(const std::string &level); friend LogCategory; void registerCategory(LogCategory *category); void unregisterCategory(LogCategory *category); void writeSyslog(const LogMessage &msg); void writeStream(const LogMessage &msg); std::unordered_set<LogCategory *> categories_; std::list<std::pair<std::string, LogSeverity>> levels_; std::shared_ptr<LogOutput> output_; }; /** * \enum LoggingTarget * \brief Log destination type * \var LoggingTargetNone * \brief No logging destination * \sa Logger::logSetTarget * \var LoggingTargetSyslog * \brief Log to syslog * \sa Logger::logSetTarget * \var LoggingTargetFile * \brief Log to file * \sa Logger::logSetFile * \var LoggingTargetStream * \brief Log to stream * \sa Logger::logSetStream */ /** * \brief Direct logging to a file * \param[in] path Full path to the log file * * This function directs the log output to the file identified by \a path. The * previous log target, if any, is closed, and all new log messages will be * written to the new log file. * * If the function returns an error, the log target is not changed. * * \return Zero on success, or a negative error code otherwise */ int logSetFile(const char *path) { return Logger::instance()->logSetFile(path); } /** * \brief Direct logging to a stream * \param[in] stream Stream to send log output to * * This function directs the log output to \a stream. The previous log target, * if any, is closed, and all new log messages will be written to the new log * stream. * * If the function returns an error, the log file is not changed * * \return Zero on success, or a negative error code otherwise. */ int logSetStream(std::ostream *stream) { return Logger::instance()->logSetStream(stream); } /** * \brief Set the logging target * \param[in] target Logging destination * * This function sets the logging output to the target specified by \a target. * The allowed values of \a target are LoggingTargetNone and * LoggingTargetSyslog. LoggingTargetNone will send the log output to nowhere, * and LoggingTargetSyslog will send the log output to syslog. The previous * log target, if any, is closed, and all new log messages will be written to * the new log destination. * * LoggingTargetFile and LoggingTargetStream are not valid values for \a target. * Use logSetFile() and logSetStream() instead, respectively. * * If the function returns an error, the log file is not changed. * * \return Zero on success, or a negative error code otherwise. */ int logSetTarget(LoggingTarget target) { return Logger::instance()->logSetTarget(target); } /** * \brief Set the log level * \param[in] category Logging category * \param[in] level Log level * * This function sets the log level of \a category to \a level. * \a level shall be one of the following strings: * - "DEBUG" * - "INFO" * - "WARN" * - "ERROR" * - "FATAL" * * "*" is not a valid \a category for this function. */ void logSetLevel(const char *category, const char *level) { Logger::instance()->logSetLevel(category, level); } /** * \brief Retrieve the logger instance * * The Logger is a singleton and can't be constructed manually. This function * shall instead be used to retrieve the single global instance of the logger. * * \return The logger instance */ Logger *Logger::instance() { static Logger instance; return &instance; } /** * \brief Write a message to the configured logger output * \param[in] msg The message object */ void Logger::write(const LogMessage &msg) { std::shared_ptr<LogOutput> output = std::atomic_load(&output_); if (!output) return; output->write(msg); } /** * \brief Set the log file * \param[in] path Full path to the log file * * \sa libcamera::logSetFile() * * \return Zero on success, or a negative error code otherwise. */ int Logger::logSetFile(const char *path) { std::shared_ptr<LogOutput> output = std::make_shared<LogOutput>(path); if (!output->isValid()) return -EINVAL; std::atomic_store(&output_, output); return 0; } /** * \brief Set the log stream * \param[in] stream Stream to send log output to * * \sa libcamera::logSetStream() * * \return Zero on success, or a negative error code otherwise. */ int Logger::logSetStream(std::ostream *stream) { std::shared_ptr<LogOutput> output = std::make_shared<LogOutput>(stream); std::atomic_store(&output_, output); return 0; } /** * \brief Set the log target * \param[in] target Log destination * * \sa libcamera::logSetTarget() * * \return Zero on success, or a negative error code otherwise. */ int Logger::logSetTarget(enum LoggingTarget target) { std::shared_ptr<LogOutput> output; switch (target) { case LoggingTargetSyslog: output = std::make_shared<LogOutput>(); std::atomic_store(&output_, output); break; case LoggingTargetNone: output = nullptr; std::atomic_store(&output_, std::shared_ptr<LogOutput>()); break; default: return -EINVAL; } return 0; } /** * \brief Set the log level * \param[in] category Logging category * \param[in] level Log level * * \sa libcamera::logSetLevel() */ void Logger::logSetLevel(const char *category, const char *level) { LogSeverity severity = parseLogLevel(level); if (severity == LogInvalid) return; for (LogCategory *c : categories_) { if (!strcmp(c->name(), category)) { c->setSeverity(severity); break; } } } /** * \brief Construct a logger */ Logger::Logger() { parseLogFile(); parseLogLevels(); } /** * \brief Parse the log output file from the environment * * If the LIBCAMERA_LOG_FILE environment variable is set, open the file it * points to and redirect the logger output to it. If the environment variable * is set to "syslog", then the logger output will be directed to syslog. Errors


context:
space:
mode: