metadata_manager.h

Go to the documentation of this file.

// SPDX-License-Identifier: BSD-3-Clause
// SPDX-FileCopyrightText: Czech Technical University in Prague
 
#pragma once
 
#include "metadata_extractor.h"
 
#include <deque>
#include <memory>
#include <set>
#include <string>
#include <utility>
 
#include <compass_msgs/Azimuth.h>
#include <cras_cpp_common/log_utils.h>
#include <cras_cpp_common/optional.hpp>
#include <geometry_msgs/Transform.h>
#include <movie_publisher/metadata_cache.h>
#include <pluginlib/class_loader.hpp>
#include <ros/time.h>
#include <sensor_msgs/CameraInfo.h>
#include <sensor_msgs/Imu.h>
#include <sensor_msgs/MagneticField.h>
#include <vision_msgs/Detection2DArray.h>
 
namespace movie_publisher
{
 
class StackGuard;
struct CachingMetadataListener;
 
struct PriorityComparator
{
  bool operator()(const MetadataExtractor::ConstPtr& lhs, const MetadataExtractor::ConstPtr& rhs) const
  {
    if (lhs == nullptr)
      return true;
    if (rhs == nullptr)
      return false;
    return lhs->getPriority() < rhs->getPriority();
  }
};
 
class MetadataManager : public TimedMetadataExtractor
{
public:
  MetadataManager(const cras::LogHelperPtr& log, const MovieOpenConfig& config, const MovieInfo::ConstPtr& info);
  ~MetadataManager() override;
 
  void addExtractor(const std::shared_ptr<MetadataExtractor>& extractor);
 
  void loadExtractorPlugins(const MetadataExtractorParams& params);
 
  std::shared_ptr<MetadataCache> getCache();
 
  void clearTimedMetadataCache();
 
  void prepareTimedMetadata(const std::unordered_set<MetadataType>& metadataTypes) override;
  std::unordered_set<MetadataType> supportedTimedMetadata(
    const std::unordered_set<MetadataType>& availableMetadata) const override;
  size_t processTimedMetadata(MetadataType type, const StreamTime& maxTime, bool requireOptional) override;
  void seekTimedMetadata(const StreamTime& seekTime) override;
  bool hasTimedMetadata() const override;
  void processPacket(const AVPacket* packet) override;
 
  std::string getName() const override;
  int getPriority() const override;
 
  cras::optional<std::string> getCameraGeneralName() override;
  cras::optional<std::string> getCameraUniqueName() override;
  cras::optional<std::string> getCameraSerialNumber() override;
  cras::optional<std::string> getCameraMake() override;
  cras::optional<std::string> getCameraModel() override;
  cras::optional<std::string> getLensMake() override;
  cras::optional<std::string> getLensModel() override;
  cras::optional<int> getRotation() override;
  cras::optional<ros::Time> getCreationTime() override;
  cras::optional<double> getCropFactor() override;
  cras::optional<SensorSize> getSensorSizeMM() override;
  cras::optional<double> getFocalLength35MM() override;
  cras::optional<double> getFocalLengthPx() override;
  cras::optional<double> getFocalLengthMM() override;
  cras::optional<IntrinsicMatrix> getIntrinsicMatrix() override;
  cras::optional<std::pair<DistortionType, Distortion>> getDistortion() override;
  GNSSFixAndDetail getGNSSPosition() override;
  cras::optional<sensor_msgs::MagneticField> getMagneticField() override;
  cras::optional<compass_msgs::Azimuth> getAzimuth() override;
  cras::optional<RollPitch> getRollPitch() override;
  cras::optional<geometry_msgs::Vector3> getAngularVelocity() override;
  cras::optional<geometry_msgs::Vector3> getAcceleration() override;
  cras::optional<vision_msgs::Detection2DArray> getFaces() override;
  cras::optional<sensor_msgs::CameraInfo> getCameraInfo() override;
  cras::optional<sensor_msgs::Imu> getImu() override;
  cras::optional<geometry_msgs::Transform> getOpticalFrameTF() override;
  cras::optional<geometry_msgs::Transform> getZeroRollPitchTF() override;
 
protected:
  bool stopRecursion(const std::string& fn, const MetadataExtractor* extractor) const;
 
  template<typename T, typename O = cras::optional<T>>
  T checkExtractors(const std::string& func,
    T(MetadataExtractor::*getFn)(), O(LatestMetadataCache::*getFnLatest)(), const std::string& frame = "");
 
  pluginlib::ClassLoader<MetadataExtractorPlugin> loader;  
  std::multiset<MetadataExtractor::Ptr, PriorityComparator> extractors;  
  std::multiset<TimedMetadataExtractor::Ptr, PriorityComparator> timedExtractors;
  std::deque<std::pair<std::string, const MetadataExtractor*>> callStack;  
  size_t width {0u};  
  size_t height {0u};  
 
  MovieOpenConfig config;  
  MovieInfo::ConstPtr info;  
  std::shared_ptr<MetadataCache> cache;  
 
  std::shared_ptr<CachingMetadataListener> metadataListener;
 
  friend StackGuard;
};
 
class StackGuard
{
public:
  StackGuard(decltype(MetadataManager::callStack)& stack, const std::string& fn, const MetadataExtractor* extractor);
  ~StackGuard();
private:
  std::string getStackDescription() const;  
  decltype(MetadataManager::callStack)& stack;  
  std::string fn;  
  const MetadataExtractor* extractor;  
};
}