player.hpp

Go to the documentation of this file.

#ifndef OPENEV_READERS_PLAYER_HPP
#define OPENEV_READERS_PLAYER_HPP
 
#include "openev/containers/concurrent_queue.hpp"
#include "openev/containers/queue.hpp"
#include "openev/core/frames.hpp"
#include "openev/core/imu.hpp"
#include "openev/core/types.hpp"
#include <algorithm>
#include <chrono>
#include <cstddef>
#include <opencv2/imgcodecs.hpp>
#include <type_traits>
#include <utility>
 
namespace ev {
[[maybe_unused]] constexpr bool USING_PLAYER_HPP = true;

template <typename R, typename = void>
struct has_frames_ : std::false_type {};
template <typename R>
struct has_frames_<R, std::void_t<decltype(std::declval<const R &>().frames())>> : std::true_type {};
 
template <typename R, typename = void>
struct has_imu_ : std::false_type {};
template <typename R>
struct has_imu_<R, std::void_t<decltype(std::declval<const R &>().imu())>> : std::true_type {};

template <typename Reader>
class Player_ {
public:
  explicit Player_(Reader &reader) : reader_{reader} {}

  inline void setSpeed(const double speed) {
    speed_ = speed;
  }

  [[nodiscard]] inline double speed() const {
    return speed_;
  }

  inline void pause(const bool paused) {
    paused_ = paused;
  }

  [[nodiscard]] inline bool isPaused() const {
    return paused_;
  }

  inline void setLoop(const bool loop) {
    loop_ = loop;
  }

  void restart() {
    reader_.reset();
    playhead_ = 0;
    anchored_ = false;
    frame_ = 0;
    sample_ = 0;
    finished_ = false;
    loops_++;
  }

  [[nodiscard]] inline std::size_t loops() const {
    return loops_;
  }

  [[nodiscard]] inline TimeType playhead() const {
    return playhead_;
  }

  [[nodiscard]] inline bool isFinished() const {
    return finished_;
  }

  void next(Queue &events) {
    advance_(elapsed_(), events, nullptr, nullptr);
  }

  void next(Queue &events, StampedMatQueue &frames) {
    advance_(elapsed_(), events, &frames, nullptr);
  }

  void next(Queue &events, StampedMatQueue &frames, ImuQueue &imus) {
    advance_(elapsed_(), events, &frames, &imus);
  }
 
private:
  static constexpr double SECONDS_TO_MICROSECONDS = 1e6;
  static constexpr std::size_t BATCH = 256;
 
  Reader &reader_;
  std::chrono::steady_clock::time_point last_;
  bool started_{false};
  bool paused_{false};
  bool loop_{true};
  bool finished_{false};
  bool anchored_{false};
  double speed_{1.0};
  TimeType playhead_{0};
  std::size_t frame_{0};
  std::size_t sample_{0};
  std::size_t loops_{0};
 
  [[nodiscard]] std::size_t batch_() const {
    const std::size_t level = reader_.prefetchCapacity();
    return level > 0 ? std::min(level, BATCH) : BATCH;
  }
 
  [[nodiscard]] TimeType elapsed_() {
    const auto now = std::chrono::steady_clock::now();
    const TimeType elapsed = started_ && !paused_ ? std::chrono::duration<double>(now - last_).count() * SECONDS_TO_MICROSECONDS * speed_ : 0;
    last_ = now;
    started_ = true;
    return elapsed;
  }
 
protected:
  void advance_(const TimeType time, Queue &events, StampedMatQueue *frames, ImuQueue *imus) {
    if(finished_) {
      return;
    }
    if(!anchored_) {
      ConcurrentQueue *first = &reader_.events();
      if(first->empty()) {
        first = &reader_.events(batch_());
      }
      if(!first->empty()) {
        playhead_ = first->front().t;
      }
      anchored_ = true;
    }
    playhead_ += time;
 
    while(true) {
      ConcurrentQueue *pending = &reader_.events();
      if(pending->empty()) {
        pending = &reader_.events(batch_());
      }
      ConcurrentQueue &queue = *pending;
      if(queue.empty()) {
        if(!loop_) {
          finished_ = true;
          break;
        }
        restart();
        finished_ = reader_.events(batch_()).empty();
        break;
      }
      const Event &e = queue.front();
      if(e.t > playhead_) {
        break;
      }
      events.push(e);
      queue.pop();
    }
 
    if constexpr(has_frames_<Reader>::value) {
      if(frames != nullptr) {
        const auto &all = reader_.frames();
        while(frame_ < all.size() && all[frame_].t <= playhead_) {
          StampedMat frame;
          cv::imread(all[frame_].path, cv::IMREAD_GRAYSCALE).copyTo(frame);
          frame.t = all[frame_].t;
          if(!frame.empty()) {
            frames->push(frame);
          }
          frame_++;
        }
      }
    }
 
    if constexpr(has_imu_<Reader>::value) {
      if(imus != nullptr) {
        const auto &all = reader_.imu();
        while(sample_ < all.size() && all[sample_].t <= playhead_) {
          imus->push(all[sample_]);
          sample_++;
        }
      }
    }
  }
};
 
} // namespace ev
 
#endif // OPENEV_READERS_PLAYER_HPP