MeasuringStream.h

Go to the documentation of this file.

#pragma once
 
#include "AudioTools/CoreAudio/AudioStreams.h"
 
namespace audio_tools {

class MeasuringStream : public ModifyingStream {
 public:
  MeasuringStream(int count = 10, Print *logOut = nullptr) {
    this->count = count;
    this->max_count = count;
    p_io = &null;
    p_out = &null;
    start_time = millis();
    p_logout = logOut;
  }
 
  MeasuringStream(Print &print, int count = 10, Print *logOut = nullptr) {
    this->count = count;
    this->max_count = count;
    setOutput(print);
    start_time = millis();
    p_logout = logOut;
  }
 
  MeasuringStream(Stream &stream, int count = 10, Print *logOut = nullptr) {
    this->count = count;
    this->max_count = count;
    setStream(stream);
    start_time = millis();
    p_logout = logOut;
  }

  void setLogOutput(Print &out) { p_logout = &out; }

  void setStream(Stream &io) override {
    p_out = &io;
    p_io = &io;
  };

  void setOutput(Print &out) override { p_out = &out; }

  size_t readBytes(uint8_t *data, size_t len) override {
    size_t result = p_io->readBytes(data, len);
    total_bytes_since_begin += result;
    return measure(result);
  }
 
  int available() override { return p_io->available(); }

  virtual size_t write(const uint8_t *data, size_t len) override {
    size_t result = p_out->write(data, len);
    total_bytes_since_begin += result;
    return measure(result);
  }

  virtual int availableForWrite() override {
    return p_out->availableForWrite();
  }
 
  void flush() override {
    if (p_out != nullptr) p_out->flush();
  }

  int bytesPerSecond() { return bytes_per_second; }

  int framesPerSecond() {
    if (frame_size == 0) return 0;
    return bytes_per_second / frame_size;
  }

  uint32_t startTime() { return start_time; }
 
  void setAudioInfo(AudioInfo info) override {
    LOGI("MeasuringStream::setAudioInfo: %d bits, %d channels", info.bits_per_sample, info.channels);
    ModifyingStream::setAudioInfo(info);
    setFrameSize(info.bits_per_sample / 8 * info.channels);
  }
 
  bool begin() override {
    total_bytes_since_begin = 0;
    ms_at_begin = millis();
    return ModifyingStream::begin();
  }
 
  bool begin(AudioInfo info) {
    setAudioInfo(info);
    return begin();
  }

  void setFrameSize(int size) { frame_size = size; }

  void setReportBytes(bool flag) { report_bytes = flag; }
 
  void setName(const char *name) { this->name = name; }

  uint32_t timeSinceBegin() { return millis() - ms_at_begin; }

  uint32_t bytesSinceBegin() { return total_bytes_since_begin; }

  uint32_t estimatedTotalTimeFor(uint32_t totalBytes) {
    if (bytesSinceBegin() == 0) return 0;
    return static_cast<float>(timeSinceBegin()) / bytesSinceBegin() *
           totalBytes;
  }

  uint32_t estimatedOpenTimeFor(uint32_t totalBytes) {
    if (bytesSinceBegin() == 0) return 0;
    return estimatedTotalTimeFor(totalBytes) - timeSinceBegin();
  }

  bool setProcessedBytes(uint32_t pos) {
    bool is_regular_update = true;
    if (pos < total_bytes_since_begin) {
      begin();
      is_regular_update = false;
    }
    total_bytes_since_begin = pos;
    return is_regular_update;
  }
 
 protected:
  int max_count = 0;
  int count = 0;
  Stream *p_io = nullptr;
  Print *p_out = nullptr;
  uint32_t start_time;
  int total_bytes = 0;
  int bytes_per_second = 0;
  int frame_size = 0;
  NullStream null;
  Print *p_logout = nullptr;
  bool report_bytes = false;
  const char *name = "";
  uint32_t ms_at_begin = 0;
  uint32_t total_bytes_since_begin = 0;
 
  size_t measure(size_t len) {
    count--;
    total_bytes += len;
 
    if (count <= 0) {
      uint32_t end_time = millis();
      int time_diff = end_time - start_time;  // in ms
      if (time_diff > 0) {
        bytes_per_second = (int64_t)total_bytes * 1000 / time_diff;
        printResult();
        count = max_count;
        total_bytes = 0;
        start_time = end_time;
      }
    }
    return len;
  }
 
  void printResult() {
    char msg[70];
    if (report_bytes || frame_size == 0) {
      snprintf(msg, 70, "%s ==> Bytes per second: %d", name, bytes_per_second);
    } else {
      snprintf(msg, 70, "%s ==> Samples per second: %d", name,
               bytes_per_second / frame_size);
    }
    if (p_logout != nullptr) {
      p_logout->println(msg);
    } else {
      LOGI("%s", msg);
    }
  }
};
 
}  // namespace audio_tools