libcamera: Switch to the std::chrono API

Replace the clock_gettime()-based API with durations expressed as
integers with the std::chrono API.

Signed-off-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
Reviewed-by: Niklas Söderlund <niklas.soderlund@ragnatech.se>

include/libcamera/timer.h

@@ -7,6 +7,7 @@
 #ifndef __LIBCAMERA_TIMER_H__
 #define __LIBCAMERA_TIMER_H__
 
+#include <chrono>
 #include <cstdint>
 
 #include <libcamera/object.h>
@@ -22,12 +23,13 @@ public:
 	Timer(Object *parent = nullptr);
 	~Timer();
 
-	void start(unsigned int msec);
+	void start(unsigned int msec) { start(std::chrono::milliseconds(msec)); }
+	void start(std::chrono::milliseconds interval);
 	void stop();
 	bool isRunning() const;
 
-	unsigned int interval() const { return interval_; }
+	std::chrono::milliseconds interval() const { return interval_; }
-	uint64_t deadline() const { return deadline_; }
+	std::chrono::steady_clock::time_point deadline() const { return deadline_; }
 
 	Signal<Timer *> timeout;
 
@@ -38,8 +40,8 @@ private:
 	void registerTimer();
 	void unregisterTimer();
 
-	unsigned int interval_;
+	std::chrono::milliseconds interval_;
-	uint64_t deadline_;
+	std::chrono::steady_clock::time_point deadline_;
 };
 
 } /* namespace libcamera */

src/cam/capture.cpp

@@ -5,6 +5,7 @@
  * capture.cpp - Cam capture
  */
 
+#include <chrono>
 #include <climits>
 #include <iomanip>
 #include <iostream>
@@ -16,7 +17,7 @@
 using namespace libcamera;
 
 Capture::Capture(Camera *camera, CameraConfiguration *config)
-	: camera_(camera), config_(config), writer_(nullptr), last_(0)
+	: camera_(camera), config_(config), writer_(nullptr)
 {
 }
 
@@ -135,17 +136,13 @@ int Capture::capture(EventLoop *loop)
 
 void Capture::requestComplete(Request *request, const std::map<Stream *, Buffer *> &buffers)
 {
-	double fps = 0.0;
-	uint64_t now;
-
 	if (request->status() == Request::RequestCancelled)
 		return;
 
-	struct timespec time;
+	std::chrono::steady_clock::time_point now = std::chrono::steady_clock::now();
-	clock_gettime(CLOCK_MONOTONIC, &time);
+	double fps = std::chrono::duration_cast<std::chrono::milliseconds>(now - last_).count();
-	now = time.tv_sec * 1000 + time.tv_nsec / 1000000;
+	fps = last_ != std::chrono::steady_clock::time_point() && fps
-	fps = now - last_;
+	    ? 1000.0 / fps : 0.0;
-	fps = last_ && fps ? 1000.0 / fps : 0.0;
 	last_ = now;
 
 	std::stringstream info;

src/cam/capture.h

@@ -7,6 +7,7 @@
 #ifndef __CAM_CAPTURE_H__
 #define __CAM_CAPTURE_H__
 
+#include <chrono>
 #include <memory>
 
 #include <libcamera/camera.h>
@@ -35,7 +36,7 @@ private:
 
 	std::map<libcamera::Stream *, std::string> streamName_;
 	BufferWriter *writer_;
-	uint64_t last_;
+	std::chrono::steady_clock::time_point last_;
 };
 
 #endif /* __CAM_CAPTURE_H__ */

src/libcamera/event_dispatcher_poll.cpp

@@ -8,6 +8,7 @@
 #include "event_dispatcher_poll.h"
 
 #include <algorithm>
+#include <chrono>
 #include <iomanip>
 #include <poll.h>
 #include <stdint.h>
@@ -20,6 +21,7 @@
 
 #include "log.h"
 #include "thread.h"
+#include "utils.h"
 
 /**
  * \file event_dispatcher_poll.h
@@ -206,17 +208,12 @@ int EventDispatcherPoll::poll(std::vector<struct pollfd> *pollfds)
 	struct timespec timeout;
 
 	if (nextTimer) {
-		clock_gettime(CLOCK_MONOTONIC, &timeout);
+		utils::time_point now = utils::clock::now();
-		uint64_t now = timeout.tv_sec * 1000000000ULL + timeout.tv_nsec;
 
-		if (nextTimer->deadline() > now) {
+		if (nextTimer->deadline() > now)
-			uint64_t delta = nextTimer->deadline() - now;
+			timeout = utils::duration_to_timespec(nextTimer->deadline() - now);
-			timeout.tv_sec = delta / 1000000000ULL;
+		else
-			timeout.tv_nsec = delta % 1000000000ULL;
+			timeout = { 0, 0 };
-		} else {
-			timeout.tv_sec = 0;
-			timeout.tv_nsec = 0;
-		}
 
 		LOG(Event, Debug)
 			<< "timeout " << timeout.tv_sec << "."
@@ -295,10 +292,7 @@ void EventDispatcherPoll::processNotifiers(const std::vector<struct pollfd> &pol
 
 void EventDispatcherPoll::processTimers()
 {
-	struct timespec ts;
+	utils::time_point now = utils::clock::now();
-	uint64_t now;
-	clock_gettime(CLOCK_MONOTONIC, &ts);
-	now = ts.tv_sec * 1000000000ULL + ts.tv_nsec;
 
 	while (!timers_.empty()) {
 		Timer *timer = timers_.front();

src/libcamera/include/log.h

@@ -7,8 +7,11 @@
 #ifndef __LIBCAMERA_LOG_H__
 #define __LIBCAMERA_LOG_H__
 
+#include <chrono>
 #include <sstream>
 
+#include "utils.h"
+
 namespace libcamera {
 
 enum LogSeverity {
@@ -60,7 +63,7 @@ public:
 
 	std::ostream &stream() { return msgStream_; }
 
-	const struct timespec &timestamp() const { return timestamp_; }
+	const utils::time_point &timestamp() const { return timestamp_; }
 	LogSeverity severity() const { return severity_; }
 	const LogCategory &category() const { return category_; }
 	const std::string &fileInfo() const { return fileInfo_; }
@@ -72,7 +75,7 @@ private:
 	std::ostringstream msgStream_;
 	const LogCategory &category_;
 	LogSeverity severity_;
-	struct timespec timestamp_;
+	utils::time_point timestamp_;
 	std::string fileInfo_;
 };
 

src/libcamera/log.cpp

@@ -11,7 +11,6 @@
 #include <cstdlib>
 #include <ctime>
 #include <fstream>
-#include <iomanip>
 #include <iostream>
 #include <list>
 #include <string.h>
@@ -78,17 +77,6 @@ static int log_severity_to_syslog(LogSeverity severity)
 	}
 }
 
-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[] = {
@@ -216,10 +204,10 @@ void LogOutput::writeSyslog(const LogMessage &msg)
 
 void LogOutput::writeStream(const LogMessage &msg)
 {
-	std::string str = std::string(log_timespec_to_string(msg.timestamp()) +
+	std::string str = "[" + utils::time_point_to_string(msg.timestamp()) +
-	      		  log_severity_name(msg.severity()) + " " +
+			  "]" + log_severity_name(msg.severity()) + " " +
 			  msg.category().name() + " " + msg.fileInfo() + " " +
-			  msg.msg());
+			  msg.msg();
 	stream_->write(str.c_str(), str.size());
 	stream_->flush();
 }
@@ -777,7 +765,7 @@ LogMessage::LogMessage(LogMessage &&other)
 void LogMessage::init(const char *fileName, unsigned int line)
 {
 	/* Log the timestamp, severity and file information. */
-	clock_gettime(CLOCK_MONOTONIC, &timestamp_);
+	timestamp_ = utils::clock::now();
 
 	std::ostringstream ossFileInfo;
 	ossFileInfo << utils::basename(fileName) << ":" << line;

src/libcamera/timer.cpp

@@ -7,7 +7,7 @@
 
 #include <libcamera/timer.h>
 
-#include <time.h>
+#include <chrono>
 
 #include <libcamera/camera_manager.h>
 #include <libcamera/event_dispatcher.h>
@@ -15,6 +15,7 @@
 #include "log.h"
 #include "message.h"
 #include "thread.h"
+#include "utils.h"
 
 /**
  * \file timer.h
@@ -42,7 +43,7 @@ LOG_DEFINE_CATEGORY(Timer)
  * \param[in] parent The parent Object
  */
 Timer::Timer(Object *parent)
-	: Object(parent), interval_(0), deadline_(0)
+	: Object(parent)
 {
 }
 
@@ -52,22 +53,28 @@ Timer::~Timer()
 }
 
 /**
+ * \fn Timer::start(unsigned int msec)
  * \brief Start or restart the timer with a timeout of \a msec
  * \param[in] msec The timer duration in milliseconds
  *
  * If the timer is already running it will be stopped and restarted.
  */
-void Timer::start(unsigned int msec)
-{
-	struct timespec tp;
-	clock_gettime(CLOCK_MONOTONIC, &tp);
 
-	interval_ = msec;
+/**
-	deadline_ = tp.tv_sec * 1000000000ULL + tp.tv_nsec + msec * 1000000ULL;
+ * \brief Start or restart the timer with a timeout of \a interval
+ * \param[in] interval The timer duration in milliseconds
+ *
+ * If the timer is already running it will be stopped and restarted.
+ */
+void Timer::start(std::chrono::milliseconds interval)
+{
+	interval_ = interval;
+	deadline_ = utils::clock::now() + interval;
 
 	LOG(Timer, Debug)
 		<< "Starting timer " << this << " with interval "
-		<< msec << ": deadline " << deadline_;
+		<< interval.count() << ": deadline "
+		<< utils::time_point_to_string(deadline_);
 
 	registerTimer();
 }
@@ -84,7 +91,7 @@ void Timer::stop()
 {
 	unregisterTimer();
 
-	deadline_ = 0;
+	deadline_ = utils::time_point();
 }
 
 void Timer::registerTimer()
@@ -103,7 +110,7 @@ void Timer::unregisterTimer()
  */
 bool Timer::isRunning() const
 {
-	return deadline_ != 0;
+	return deadline_ != utils::time_point();
 }
 
 /**
@@ -115,7 +122,7 @@ bool Timer::isRunning() const
 /**
  * \fn Timer::deadline()
  * \brief Retrieve the timer deadline
- * \return The timer deadline in nanoseconds
+ * \return The timer deadline
  */
 
 /**
@@ -128,7 +135,7 @@ bool Timer::isRunning() const
 void Timer::message(Message *msg)
 {
 	if (msg->type() == Message::ThreadMoveMessage) {
-		if (deadline_) {
+		if (isRunning()) {
 			unregisterTimer();
 			invokeMethod(&Timer::registerTimer);
 		}

test/event-dispatcher.cpp

@@ -5,6 +5,7 @@
  * event-dispatcher.cpp - Event dispatcher test
  */
 
+#include <chrono>
 #include <iostream>
 #include <signal.h>
 #include <sys/time.h>
@@ -47,8 +48,7 @@ protected:
 		Timer timer;
 
 		/* Event processing interruption by signal. */
-		struct timespec start;
+		std::chrono::steady_clock::time_point start = std::chrono::steady_clock::now();
-		clock_gettime(CLOCK_MONOTONIC, &start);
 
 		timer.start(1000);
 
@@ -59,12 +59,11 @@ protected:
 
 		dispatcher->processEvents();
 
-		struct timespec stop;
+		std::chrono::steady_clock::time_point stop = std::chrono::steady_clock::now();
-		clock_gettime(CLOCK_MONOTONIC, &stop);
+		std::chrono::steady_clock::duration duration = stop - start;
-		int duration = (stop.tv_sec - start.tv_sec) * 1000;
+		int msecs = std::chrono::duration_cast<std::chrono::milliseconds>(duration).count();
-		duration += (stop.tv_nsec - start.tv_nsec) / 1000000;
 
-		if (abs(duration - 1000) > 50) {
+		if (abs(msecs - 1000) > 50) {
 			cout << "Event processing restart test failed" << endl;
 			return TestFail;
 		}

test/timer.cpp

@@ -5,6 +5,7 @@
  * timer.cpp - Timer test
  */
 
+#include <chrono>
 #include <iostream>
 
 #include <libcamera/event_dispatcher.h>
@@ -28,28 +29,28 @@ public:
 	void start(int msec)
 	{
 		interval_ = msec;
-		clock_gettime(CLOCK_MONOTONIC, &start_);
+		start_ = std::chrono::steady_clock::now();
-		expiration_ = { 0, 0 };
+		expiration_ = std::chrono::steady_clock::time_point();
 
 		Timer::start(msec);
 	}
 
 	int jitter()
 	{
-		int duration = (expiration_.tv_sec - start_.tv_sec) * 1000;
+		std::chrono::steady_clock::duration duration = expiration_ - start_;
-		duration += (expiration_.tv_nsec - start_.tv_nsec) / 1000000;
+		int msecs = std::chrono::duration_cast<std::chrono::milliseconds>(duration).count();
-		return abs(duration - interval_);
+		return abs(msecs - interval_);
 	}
 
 private:
 	void timeoutHandler(Timer *timer)
 	{
-		clock_gettime(CLOCK_MONOTONIC, &expiration_);
+		expiration_ = std::chrono::steady_clock::now();
 	}
 
 	int interval_;
-	struct timespec start_;
+	std::chrono::steady_clock::time_point start_;
-	struct timespec expiration_;
+	std::chrono::steady_clock::time_point expiration_;
 };
 
 class TimerTest : public Test