types.h

Go to the documentation of this file.

// SPDX-License-Identifier: BSD-3-Clause
// SPDX-FileCopyrightText: Czech Technical University in Prague
 
#pragma once
 
#include <string>
 
#include <ros/duration.h>
#include <ros/time.h>
 
struct AVRational;
 
namespace movie_publisher
{
struct RationalNumber
{
  int32_t numerator {0};  
  int32_t denominator {1};  
 
  // ReSharper disable once CppNonExplicitConversionOperator
  operator double() const;  // NOLINT(*-explicit-constructor)
 
  // ReSharper disable once CppNonExplicitConversionOperator
  operator float() const;  // NOLINT(*-explicit-constructor)
 
  AVRational av_q() const;
};
 
class StreamDuration : public ros::DurationBase<StreamDuration>
{
public:
  StreamDuration();
  StreamDuration(int32_t sec, int32_t nsec);
  explicit StreamDuration(double t);
  explicit StreamDuration(const ros::Duration& t);
 
  StreamDuration(int64_t streamPTS, const RationalNumber& timeBase);
 
  StreamDuration(int64_t streamPTS, const AVRational& timeBase);
 
  ros::Duration toRosDuration() const;
 
  int64_t toStreamPTS(const RationalNumber& timeBase) const;
 
  int64_t toStreamPTS(const AVRational& timeBase) const;
 
  StreamDuration operator+(const StreamDuration& rhs) const {return StreamDuration(this->d() + rhs.d());}
  StreamDuration operator-(const StreamDuration& rhs) const {return StreamDuration(this->d() - rhs.d());}
  StreamDuration operator-() const  {return StreamDuration(-this->d());}
  StreamDuration operator*(const double scale) const {return StreamDuration(this->d() * scale);}
  StreamDuration& operator+=(const StreamDuration& rhs)
  {
    auto dur = this->d(); dur += rhs.d(); *this = StreamDuration(dur); return *this;
  }
  StreamDuration& operator-=(const StreamDuration& rhs) { return *this += -rhs; }
  StreamDuration& operator*=(const double scale)
  {
    auto dur = this->d(); dur *= scale; *this = StreamDuration(dur); return *this;
  }
  bool operator==(const StreamDuration& rhs) const {return this->d() == rhs.d();}
  bool operator!=(const StreamDuration& rhs) const { return !(*this == rhs); }
  bool operator>(const StreamDuration& rhs) const {return this->d() > rhs.d();}
  bool operator<(const StreamDuration& rhs) const {return this->d() < rhs.d();}
  bool operator>=(const StreamDuration& rhs) const {return this->d() >= rhs.d();}
  bool operator<=(const StreamDuration& rhs) const {return this->d() <= rhs.d();}
  bool isZero() const { return this->d().isZero(); }
  double toSec() const { return this->d().toSec(); }
  StreamDuration& fromSec(const double t) {*this = StreamDuration(ros::Duration().fromSec(t)); return *this;}
  StreamDuration& fromNSec(const int64_t t) {*this = StreamDuration(ros::Duration().fromNSec(t)); return *this;}
private:
  ros::Duration d() const {return this->toRosDuration();}
};
 
class StreamTime : public ros::TimeBase<StreamTime, StreamDuration>
{
public:
  StreamTime();
  StreamTime(uint32_t sec, uint32_t nsec);
  explicit StreamTime(double t);
  explicit StreamTime(const ros::Time& t);
  explicit StreamTime(const StreamDuration& duration);
  StreamTime(int64_t streamPTS, const RationalNumber& timeBase);
  StreamTime(int64_t streamPTS, const AVRational& timeBase);
 
  ros::Time toRosTime() const;
 
  StreamDuration toDuration() const;
 
  int64_t toStreamPTS(const RationalNumber& timeBase) const;
 
  int64_t toStreamPTS(const AVRational& timeBase) const;
 
  StreamDuration operator-(const StreamTime& rhs) const {return StreamDuration{this->t() - rhs.t()};}
  StreamTime operator+(const StreamDuration& rhs) const {return StreamTime{this->t() + rhs.toRosDuration()};}
  StreamTime operator-(const StreamDuration& rhs) const {return StreamTime{this->t() - rhs.toRosDuration()};}
  StreamTime& operator+=(const StreamDuration& rhs)
  {
    auto time = this->t(); time += rhs.toRosDuration(); *this = StreamTime(time); return *this;
  }
  StreamTime& operator-=(const StreamDuration& rhs) {return *this += -rhs;}
  bool operator==(const StreamTime& rhs) const {return this->t() == rhs.t();}
  bool operator!=(const StreamTime& rhs) const { return !(*this == rhs); }
  bool operator>(const StreamTime& rhs) const {return this->t() > rhs.t();}
  bool operator<(const StreamTime& rhs) const {return this->t() < rhs.t();}
  bool operator>=(const StreamTime& rhs) const {return this->t() >= rhs.t();}
  bool operator<=(const StreamTime& rhs) const {return this->t() <= rhs.t();}
  bool isZero() const { return this->t().isZero(); }
  double toSec() const { return this->t().toSec(); }
  StreamTime& fromSec(const double t){ *this = StreamTime(ros::Time().fromSec(t)); return *this; }
  StreamTime& fromNSec(const uint64_t t) { *this = StreamTime(ros::Time().fromNSec(t)); return *this; }
private:
  ros::Time t() const {return this->toRosTime();}
};
 
enum class TimestampSource
{
  AllZeros,  
  AbsoluteVideoTimecode,  
  RelativeVideoTimecode,  
  RosTime,  
  FromMetadata,  
};
 
}
 
namespace cras
{
 
std::string to_string(const movie_publisher::StreamTime& time);
std::string to_string(const movie_publisher::StreamDuration& duration);
 
}