OutputFPSMeter.h

Go to the documentation of this file.

#pragma once
#include "AudioTools/Video/VideoOutput.h"
 
namespace audio_tools {
 
class OutputFPSMeter : public VideoOutput {
 public:
  OutputFPSMeter(VideoOutput &target) : p_target(&target) {}
 
  size_t write(const uint8_t *data, size_t len) override {
    if (len == 0) return 0;
    // Cached for flush() to finalize with - some decoders (MJPEGDecoder)
    // only decode on flush(), by which point the raw encoded bytes
    // isKeyFrame() needs are already gone. OR'd across however many
    // write() calls precede the next flush(), in case a keyframe marker
    // isn't in the very first chunk.
    pending_is_key = pending_is_key || p_target->isKeyFrame(data, len);
    have_pending = true;
    uint32_t t0 = millis();
    size_t result = p_target->write(data, len);
    call_ms += millis() - t0;
    return result;
  }
 
  void flush() override {
    uint32_t t0 = millis();
    p_target->flush();
    call_ms += millis() - t0;
    if (have_pending && p_target->hadOutput()) {
      if (frame_count == 0) start_ms = t0;
      last_ms = millis();
      frame_count++;
      total_ms += call_ms;
      if (pending_is_key) {
        i_count++;
        i_ms += call_ms;
      } else {
        p_count++;
        p_ms += call_ms;
      }
    }
    call_ms = 0;
    have_pending = false;
    pending_is_key = false;
  }
 
  void setSkipRender(bool skip) override { p_target->setSkipRender(skip); }
  bool isKeyFrame(const uint8_t *data, size_t len) override {
    return p_target->isKeyFrame(data, len);
  }
 
  uint32_t frameCount() const { return frame_count; }
  uint32_t frameCountI() const { return i_count; }
  uint32_t frameCountP() const { return p_count; }
 
  void logTo(Print &out) {
    uint32_t elapsed = last_ms - start_ms;
    out.print("frames decoded: ");
    out.print((int)frame_count);
    out.print(" (I: ");
    out.print((int)i_count);
    out.print(" / P: ");
    out.print((int)p_count);
    out.println(")");
    out.print("elapsed: ");
    out.print((int)elapsed);
    out.println(" ms");
    out.print("avg fps (measured, full speed): ");
    out.println(elapsed > 0 ? 1000.0f * frame_count / elapsed : 0.0f);
    out.print("avg write ms (decode + whatever the target's own output "
               "does) - I: ");
    out.print(i_count > 0 ? (float)i_ms / i_count : 0.0f);
    out.print(" / P: ");
    out.print(p_count > 0 ? (float)p_ms / p_count : 0.0f);
    out.print(" / overall: ");
    out.println(frame_count > 0 ? (float)total_ms / frame_count : 0.0f);
    out.print("implied max fps - I: ");
    out.print(i_ms > 0 ? 1000.0f * i_count / i_ms : 0.0f);
    out.print(" / P: ");
    out.print(p_ms > 0 ? 1000.0f * p_count / p_ms : 0.0f);
    out.print(" / overall: ");
    out.println(total_ms > 0 ? 1000.0f * frame_count / total_ms : 0.0f);
    // Only nonzero for a target that tracks decode time separately from
    // everything after it (currently H264Decoder) - see VideoOutput::
    // totalDecodeMs()'s own comment. This is the one number here that IS
    // decode-only, regardless of what the target's own output does.
    uint64_t decodeMs = p_target->totalDecodeMs();
    if (decodeMs > 0 && frame_count > 0) {
      float avgDecodeMs = (float)decodeMs / frame_count;
      out.print("of which pure decode ms - avg: ");
      out.print(avgDecodeMs);
      out.print(" / implied max fps: ");
      out.println(1000.0f * frame_count / decodeMs);
      // Everything write() did minus the decode-only share above -
      // convert/render/SPI, i.e. exactly the display cost this class's
      // own comment warns is otherwise baked into "avg write ms" above.
      out.print("of which convert+render ms - avg: ");
      out.println(((float)total_ms / frame_count) - avgDecodeMs);
    }
  }
 
 protected:
  VideoOutput *p_target;
  // write()-then-flush() pending state - see flush()'s own comment for
  // why finalization happens there instead of in write().
  bool have_pending = false;
  bool pending_is_key = false;
  uint32_t call_ms = 0;
  uint32_t frame_count = 0, i_count = 0, p_count = 0;
  uint32_t total_ms = 0, i_ms = 0, p_ms = 0;
  uint32_t start_ms = 0, last_ms = 0;
};
 
}  // namespace audio_tools