movie_private.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 <unordered_map>
 
#include <compass_msgs/Azimuth.h>
#include <cras_cpp_common/expected.hpp>
#include <cras_cpp_common/optional.hpp>
#include <cras_cpp_common/param_utils/bound_param_helper.hpp>
#include <geometry_msgs/TransformStamped.h>
#include <gps_common/GPSFix.h>
#include <movie_publisher/metadata_manager.h>
#include <movie_publisher/movie.h>
#include <movie_publisher/movie_reader.h>
#include <ros/duration.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 <sensor_msgs/image_encodings.h>
#include <vision_msgs/Detection2DArray.h>
 
extern "C" {
#include <libavcodec/avcodec.h>
#include <libavfilter/avfilter.h>
#include <libavformat/avformat.h>
#include <libswscale/swscale.h>
}
 
namespace movie_publisher
{
 
#ifdef av_err2str
#undef av_err2str
av_always_inline char* av_err2str(const int errnum)
{
  thread_local char str[AV_ERROR_MAX_STRING_SIZE] = {0};
  return av_make_error_string(str, AV_ERROR_MAX_STRING_SIZE, errnum);
}
#endif
 
// RAII helpers for libav
 
struct AVPacketClose
{
  void operator()(AVPacket* packet) noexcept { av_packet_unref(packet); }
};
using AVPacketPtr = std::unique_ptr<AVPacket, AVPacketClose>;
 
struct AVFrameClose
{
  void operator()(AVFrame* frame) noexcept { av_frame_unref(frame); }
};
using AVFramePtr = std::unique_ptr<AVFrame, AVFrameClose>;
 
template <typename M>
M updateHeader(const M& msg, const ros::Time& stamp, const std::string& frameId)
{
  M copy = msg;
  copy.header.stamp = stamp;
  copy.header.frame_id = frameId;
  return copy;
}
 
class MovieMetadataListener : public TimedMetadataListener
{
public:
  MovieMetadataListener(MovieOpenConfig& config, const std::function<ros::Time(const StreamTime&)>& getTimestamp);
  void processGNSSPosition(const TimedMetadata<GNSSFixAndDetail>& gnss) override;
  void processAzimuth(const TimedMetadata<compass_msgs::Azimuth>& data) override;
  void processMagneticField(const TimedMetadata<sensor_msgs::MagneticField>& data) override;
  void processFaces(const TimedMetadata<vision_msgs::Detection2DArray>& data) override;
  void processCameraInfo(const TimedMetadata<sensor_msgs::CameraInfo>& data) override;
  void processImu(const TimedMetadata<sensor_msgs::Imu>& data) override;
  void processRollPitch(const TimedMetadata<std::pair<double, double>>& data) override;
  void processOpticalFrameTF(const TimedMetadata<geometry_msgs::Transform>& data) override;
 
private:
  template <typename M>
  M fixHeader(const TimedMetadata<M>& msg, const std::string& frameId)
  {
    return updateHeader(msg.value, this->getTimestamp(msg.stamp), frameId);
  }
 
  MovieOpenConfig& config;
  std::function<ros::Time(const StreamTime&)> getTimestamp;
};
 
struct MoviePrivate : public cras::HasLogger
{
  explicit MoviePrivate(const cras::LogHelperPtr& log);
  ~MoviePrivate();
 
  MovieOpenConfig::Ptr config;
  MovieInfo::Ptr info;
  MoviePlaybackState::Ptr playbackState;  
 
  cras::optional<StreamTime> subclipStart;  
  cras::optional<StreamTime> subclipEnd;  
  cras::optional<StreamDuration> subclipDuration;  
 
  // State variables
  cras::optional<int64_t> seekRequest;  
  StreamTime lastSeek;  
 
  // Extracted metadata
  std::shared_ptr<MetadataManager> metadataManager;  
  std::shared_ptr<MovieMetadataListener> metadataListener;  
 
  // Libav stuff
  AVPixelFormat targetPixelFormat;  
  int imageBufferSize;  
  AVFilterGraph* filterGraph {};  
  AVFilterContext* filterBuffersrcContext {};  
  AVFilterContext* filterBuffersinkContext {};  
  SwsContext* swscaleContext {};  
  AVCodecContext* codecContext {};  
  AVStream* stream {};  
  AVFormatContext* formatContext {};  
 
  bool isStillImage() const;
 
  bool isSeekable() const;
 
  RationalNumber getFrameRate() const;
 
  StreamDuration getContainerDuration() const;
 
  StreamDuration getDuration() const;
 
  StreamTime getStreamStart() const;
 
  StreamTime getStreamEnd() const;
 
  StreamDuration getStreamDuration() const;
 
  size_t getNumFrames() const;
 
  void prepareMetadataExtractors();
 
  void extractMetadata();
 
  void updateMetadata(const StreamTime& ptsTime);
 
  ros::Time getTimestamp(const StreamTime& ptsTime) const;
 
  cras::expected<std::pair<AVCodec*, int>, std::string> selectStream();
  cras::expected<void, std::string> openCodec(const AVCodec* codec);
  void detectTargetPixelFormat();
  cras::expected<void, std::string> addRotationFilter();
  cras::expected<void, std::string> configSwscale();
};
 
}