metadata_extractor.h

Go to the documentation of this file.

// SPDX-License-Identifier: BSD-3-Clause
// SPDX-FileCopyrightText: Czech Technical University in Prague
 
#pragma once
 
#include <algorithm>
#include <memory>
#include <string>
#include <unordered_set>
#include <utility>
#include <vector>
 
#include <compass_msgs/Azimuth.h>
#include <cras_cpp_common/log_utils.h>
#include <cras_cpp_common/optional.hpp>
#include <cras_cpp_common/param_utils/bound_param_helper.hpp>
#include <geometry_msgs/Transform.h>
#include <geometry_msgs/TransformStamped.h>
#include <geometry_msgs/Vector3.h>
#include <gps_common/GPSFix.h>
#include <movie_publisher/metadata_cache.h>
#include <movie_publisher/metadata_type.h>
#include <movie_publisher/movie_info.h>
#include <movie_publisher/movie_open_config.h>
#include <ros/time.h>
#include <sensor_msgs/CameraInfo.h>
#include <sensor_msgs/Imu.h>
#include <sensor_msgs/MagneticField.h>
#include <sensor_msgs/NavSatFix.h>
#include <vision_msgs/Detection2DArray.h>
 
class AVFormatContext;
class AVPacket;
 
namespace movie_publisher
{
 
class MetadataManager;
 
struct MetadataExtractorParams
{
  cras::LogHelperPtr log;  
  std::weak_ptr<MetadataManager> manager;  
  MovieOpenConfig config;  
  MovieInfo::ConstPtr info;  
  const AVFormatContext* avFormatContext;  
  std::shared_ptr<MetadataCache> cache;  
};
 
class MetadataExtractor : public cras::HasLogger
{
public:
  using Ptr = std::shared_ptr<MetadataExtractor>;
  using ConstPtr = std::shared_ptr<const MetadataExtractor>;
 
  explicit MetadataExtractor(const cras::LogHelperPtr& log);
  virtual ~MetadataExtractor();
 
  virtual std::string getName() const = 0;
 
  virtual int getPriority() const = 0;
 
  virtual void processPacket(const AVPacket* packet) {}
 
  virtual cras::optional<std::string> getCameraGeneralName() { return cras::nullopt; }
  virtual cras::optional<std::string> getCameraUniqueName() { return cras::nullopt; }
  virtual cras::optional<std::string> getCameraSerialNumber() { return cras::nullopt; }
  virtual cras::optional<std::string> getCameraMake() { return cras::nullopt; }
  virtual cras::optional<std::string> getCameraModel() { return cras::nullopt; }
  virtual cras::optional<std::string> getLensMake() { return cras::nullopt; }
  virtual cras::optional<std::string> getLensModel() { return cras::nullopt; }
  virtual cras::optional<int> getRotation() { return cras::nullopt; }
  virtual cras::optional<ros::Time> getCreationTime() { return cras::nullopt; }
  virtual cras::optional<double> getCropFactor() { return cras::nullopt; }
  virtual cras::optional<SensorSize> getSensorSizeMM() { return cras::nullopt; }
  virtual cras::optional<double> getFocalLength35MM() { return cras::nullopt; }
  virtual cras::optional<double> getFocalLengthMM() { return cras::nullopt; }
  virtual cras::optional<double> getFocalLengthPx() { return cras::nullopt; }
  virtual cras::optional<IntrinsicMatrix> getIntrinsicMatrix() { return cras::nullopt; }
  virtual cras::optional<DistortionData> getDistortion() { return cras::nullopt; }
  virtual GNSSFixAndDetail getGNSSPosition() { return std::make_pair(cras::nullopt, cras::nullopt); }
  virtual cras::optional<compass_msgs::Azimuth> getAzimuth() { return cras::nullopt; }
  virtual cras::optional<sensor_msgs::MagneticField> getMagneticField() { return cras::nullopt; }
  virtual cras::optional<RollPitch> getRollPitch() { return cras::nullopt; }
  virtual cras::optional<geometry_msgs::Vector3> getAcceleration() { return cras::nullopt; }
  virtual cras::optional<geometry_msgs::Vector3> getAngularVelocity() { return cras::nullopt; }
  virtual cras::optional<vision_msgs::Detection2DArray> getFaces() { return cras::nullopt; }
 
  virtual cras::optional<sensor_msgs::CameraInfo> getCameraInfo() { return cras::nullopt; }
 
  virtual cras::optional<sensor_msgs::Imu> getImu() { return cras::nullopt; }
 
  virtual cras::optional<geometry_msgs::Transform> getOpticalFrameTF() { return cras::nullopt; }
 
  virtual cras::optional<geometry_msgs::Transform> getZeroRollPitchTF() { return cras::nullopt; }
 
  // These reserved functions are future-proofing placeholders that allow adding new types of extractable metadata
  // without breaking binary compatibility of existing extractors. When adding the getter for the new metadata type,
  // just replace one of these functions.
  // There are probably a few other steps to do when turning one of the reserved functions into an actual one:
  // https://www.haiku-os.org/documents/dev/binary_compatibility_3_easy_steps/
 
private:
  virtual void __reserved0() {}
  virtual void __reserved1() {}
  virtual void __reserved2() {}
  virtual void __reserved3() {}
  virtual void __reserved4() {}
  virtual void __reserved5() {}
  virtual void __reserved6() {}
  virtual void __reserved7() {}
  virtual void __reserved8() {}
  virtual void __reserved9() {}
};
 
struct TimedMetadataListener
{
  using Ptr = std::shared_ptr<TimedMetadataListener>;
  using ConstPtr = std::shared_ptr<const TimedMetadataListener>;
 
  virtual ~TimedMetadataListener();
 
  virtual void processRotation(const TimedMetadata<int>& data) {}
  virtual void processCropFactor(const TimedMetadata<double>& data) {}
  virtual void processSensorSizeMM(const TimedMetadata<SensorSize>& data) {}
  virtual void processFocalLength35MM(const TimedMetadata<double>& data) {}
  virtual void processFocalLengthMM(const TimedMetadata<double>& data) {}
  virtual void processFocalLengthPx(const TimedMetadata<double>& data) {}
  virtual void processIntrinsicMatrix(const TimedMetadata<IntrinsicMatrix>& data) {}
  virtual void processDistortion(const TimedMetadata<DistortionData>& data) {}
  virtual void processGNSSPosition(const TimedMetadata<GNSSFixAndDetail>& data) {}
  virtual void processAzimuth(const TimedMetadata<compass_msgs::Azimuth>& data) {}
  virtual void processMagneticField(const TimedMetadata<sensor_msgs::MagneticField>& data) {}
  virtual void processRollPitch(const TimedMetadata<RollPitch>& data) {}
  virtual void processAcceleration(const TimedMetadata<geometry_msgs::Vector3>& data) {}
  virtual void processAngularVelocity(const TimedMetadata<geometry_msgs::Vector3>& data) {}
  virtual void processFaces(const TimedMetadata<vision_msgs::Detection2DArray>& data) {}
 
  virtual void processCameraInfo(const TimedMetadata<sensor_msgs::CameraInfo>& data) {}
 
  virtual void processImu(const TimedMetadata<sensor_msgs::Imu>& data) {}
 
  virtual void processOpticalFrameTF(const TimedMetadata<geometry_msgs::Transform>& data) {}
 
  virtual void processZeroRollPitchTF(const TimedMetadata<geometry_msgs::Transform>& data) {}
 
private:
  // These reserved functions are future-proofing placeholders that allow adding new callbacks. See MetadataExtractor.
  virtual void __reserved0() {}
  virtual void __reserved1() {}
  virtual void __reserved2() {}
  virtual void __reserved3() {}
  virtual void __reserved4() {}
  virtual void __reserved5() {}
  virtual void __reserved6() {}
  virtual void __reserved7() {}
  virtual void __reserved8() {}
  virtual void __reserved9() {}
};
 
class TimedMetadataExtractor : public MetadataExtractor
{
public:
  using Ptr = std::shared_ptr<TimedMetadataExtractor>;
  using ConstPtr = std::shared_ptr<const TimedMetadataExtractor>;
 
  explicit TimedMetadataExtractor(const cras::LogHelperPtr& log);
 
  virtual void addTimedMetadataListener(const std::shared_ptr<TimedMetadataListener>& listener);
 
  virtual void prepareTimedMetadata(const std::unordered_set<MetadataType>& metadataTypes);
 
  virtual std::unordered_set<MetadataType> supportedTimedMetadata(
    const std::unordered_set<MetadataType>& availableMetadata) const = 0;
 
  virtual size_t processTimedMetadata(MetadataType type, const StreamTime& maxTime, bool requireOptional);
 
  virtual void seekTimedMetadata(const StreamTime& seekTime);
 
  virtual bool hasTimedMetadata() const;
 
protected:
  std::vector<TimedMetadataListener::Ptr> listeners;  
};
 
struct MetadataExtractorPlugin
{
  virtual ~MetadataExtractorPlugin() = default;
 
  virtual MetadataExtractor::Ptr getExtractor(const MetadataExtractorParams& params) = 0;
};
 
}