Video.h

Go to the documentation of this file.

#pragma once
#include "AudioTools/CoreAudio/AudioOutput.h"
#include "AudioTools/CoreAudio/Buffers.h"
#include "AudioTools/Video/CodecCopy.h"
#include "stdint.h"
 
namespace audio_tools {
 
enum StreamContentType { Audio, Video };
 
enum class VideoFormat {
  H264,
  MJPEG,
  MPEG4,
  RAW,
  YUV422,
  RGB565,
  RGB666,
  RGB888,
  I420,
  MPEG1,
  UNKNOWN
};
 
inline size_t videoFrameSizeBytes(VideoFormat format, uint16_t width,
                                  uint16_t height) {
  size_t px = (size_t)width * (size_t)height;
  switch (format) {
    case VideoFormat::RAW:
    case VideoFormat::RGB666:
    case VideoFormat::RGB888:
      return px * 3;
    case VideoFormat::YUV422:
    case VideoFormat::RGB565:
      return px * 2;
    case VideoFormat::I420:
      return px + px / 2;
    default:
      return 0;
  }
}
 
inline bool isH264KeyFrame(const uint8_t* data, size_t len) {
  for (size_t i = 0; i + 3 < len; i++) {
    if (data[i] == 0 && data[i + 1] == 0 && data[i + 2] == 1) {
      if ((data[i + 3] & 0x1F) == 5) return true;  // IDR slice
      i += 2;
    }
  }
  return false;
}
 
inline bool isMpeg1KeyFrame(const uint8_t* data, size_t len) {
  for (size_t i = 0; i + 5 < len; i++) {
    if (data[i] == 0 && data[i + 1] == 0 && data[i + 2] == 1 &&
        data[i + 3] == 0x00) {
      return ((data[i + 5] >> 3) & 0x07) == 1;  // I-picture
    }
  }
  return false;
}
 
struct VideoInfo {
  uint16_t width = 0;
  uint16_t height = 0;
  float fps = 0;
  VideoFormat format = VideoFormat::UNKNOWN;
  uint32_t frame_size = 0;
  uint32_t total_file_size = 0;
 
  bool operator==(const VideoInfo& alt) const {
    return width == alt.width && height == alt.height && fps == alt.fps &&
           format == alt.format && frame_size == alt.frame_size &&
           total_file_size == alt.total_file_size;
  }
  bool operator!=(const VideoInfo& alt) const { return !(*this == alt); }
  operator bool() const { return width > 0 && height > 0; }
  void logInfo(const char* source = "") {
    LOGI(
        "%s width: %d / height: %d / fps: %f / format: %d / frame_size: %d / "
        "total_file_size: %d",
        source, (int)width, (int)height, fps, (int)format, (int)frame_size,
        (int)total_file_size);
  }
};
 
class VideoFrameSource {
 public:
  virtual ~VideoFrameSource() = default;
  virtual const uint8_t* nextFrame(size_t& len) = 0;
  virtual VideoInfo videoInfo() = 0;
 
  bool writeTo(Print& out) {
    size_t len;
    const uint8_t* frame = nextFrame(len);
    if (frame == nullptr || len == 0) return false;
    size_t written = out.write(frame, len);
    return written = len;
  }
};
 
class VideoInfoSource {
 public:
  virtual VideoInfo videoInfo() = 0;
};
 
class VideoOutput {
 public:
  virtual size_t write(const uint8_t* data, size_t len) = 0;
  virtual void flush() {}
  virtual void setSkipRender(bool skip) {}
 
  virtual bool isKeyFrame(const uint8_t* data, size_t len) { return false; }
 
  virtual uint32_t getWriteTimeMs() const { return 0; }
 
  virtual bool hadOutput() const { return true; }
};
 
 
class VideoFrameMeter : public VideoOutput {
 public:
  VideoFrameMeter(Print& target) : p_target(&target) {}
 
  VideoFrameMeter(VideoOutput& target) : p_target_video(&target) {}
 
  size_t write(const uint8_t* data, size_t len) override {
    uint32_t now = millis();
    if (has_last_call) {
      total_turnaround_ms += (now - last_call_ms);
    }
    last_call_ms = now;
    has_last_call = true;
 
    // VideoOutput and Print are unrelated types (no common base), so the
    // constructor that received a VideoOutput& only has somewhere to
    // store it as p_target_video, not p_target - check that one first.
    uint32_t forwardStart = millis();
    size_t result = 0;
    if (p_target_video != nullptr) {
      result = p_target_video->write(data, len);
    } else if (p_target != nullptr) {
      result = p_target->write(data, len);
    }
    total_forward_ms += millis() - forwardStart;
 
    count_++;
    return result;
  }
 
  void flush() override {
    if (p_target_video != nullptr) p_target_video->flush();
  }
  void setSkipRender(bool skip) override {
    if (p_target_video != nullptr) p_target_video->setSkipRender(skip);
  }
 
  uint32_t count() const { return count_; }
 
  float fpsMax() const {
    return count_ > 0 && total_forward_ms > 0
               ? (1000.0f * count_) / total_forward_ms
               : 0.0f;
  }
 
  float fpsAvg() const {
    return count_ > 1 && total_turnaround_ms > 0
               ? (1000.0f * (count_ - 1)) / total_turnaround_ms
               : 0.0f;
  }
 
  float timeWriteMs() const {
    return count_ > 0 ? (float)total_forward_ms / count_ : 0.0f;
  }
 
  float timeTurnaroundMs() const {
    return count_ > 1 ? (float)total_turnaround_ms / (count_ - 1) : 0.0f;
  }
 
  Print& asPrint() { return print_view_; }
 
 protected:
  class PrintView : public Print {
   public:
    explicit PrintView(VideoFrameMeter& meter) : meter_(meter) {}
    size_t write(const uint8_t* data, size_t len) override {
      return meter_.write(data, len);
    }
    size_t write(uint8_t b) override { return meter_.write(&b, 1); }
 
   private:
    VideoFrameMeter& meter_;
  };
 
  Print* p_target = nullptr;
  VideoOutput* p_target_video = nullptr;
  uint32_t count_ = 0;
  uint32_t last_call_ms = 0;
  bool has_last_call = false;
  uint32_t total_forward_ms = 0;
  uint32_t total_turnaround_ms = 0;
  PrintView print_view_{*this};
};
 
}  // namespace audio_tools
 
// PacedVideoOutput derives from VideoOutput (defined above), so this must
// come after the closing brace - see PacedVideoOutput.h's
// own #include "AudioTools/Video/Video.h" for the other half of this
// mutually-including-but-order-safe-via-pragma-once pair.
#include "AudioTools/Video/PacedVideoOutput.h"