CodecH264ESP32S3.h

Go to the documentation of this file.

#pragma once
 
#include "AudioTools/Video/CodecVideo.h"
#include "H264Decoder.h"
#include "H264Encoder.h"
 
namespace audio_tools {
 
template <typename Alloc = H264_DEFAULT_ALLOCATOR>
class H264DecoderESP32S3 : public VideoDecoder, public VideoInfoSource {
 public:
  H264DecoderESP32S3() {
    config_ = decoder_.defaultConfig();
    config_.output_format = ESP_H264_RAW_FMT_RGB565_LE;
    // esp_h264::H264Decoder::defaultConfig() sizes both buffers for VGA
    // (400KB input, ~450KB output) - both grow on demand via
    // std::vector::resize() if a frame ever exceeds them anyway (see
    // decode()/processDecodedFrame() in H264Decoder.h), so nothing
    // breaks if these prove too small; they only pre-size to avoid a
    // one-time reallocation. Default to something that fits this
    // library's actual target (small-panel TFTs, QCIF/CIF-ish streams)
    // instead of paying for VGA-sized buffers on every board regardless
    // of what it's actually decoding - override via
    // setInputBufferSize()/setOutputBufferSize() only if you know you
    // need more (e.g. a larger panel) and want to skip that reallocation.
    config_.input_buffer_size = 64 * 1024;
    config_.output_buffer_size = 100 * 1024;
    config_.frame_callback = [this](const uint8_t *frame, uint32_t w,
                                     uint32_t h, esp_h264_raw_format_t fmt) {
      if (p_out == nullptr && p_out_video == nullptr) return;
      size_t bytes = (size_t)(w * h * ESP_H264_GET_BPP_BY_PIC_TYPE(fmt));
      if (p_out != nullptr) p_out->write(frame, bytes);
      if (p_out_video != nullptr) p_out_video->write(frame, bytes);
    };
  }
 
  H264DecoderESP32S3(Print &out) : H264DecoderESP32S3() { setOutput(out); }
 
  H264DecoderESP32S3(VideoOutput &out) : H264DecoderESP32S3() {
    setOutput(out);
  }
 
  VideoFormat codecFormat() override { return VideoFormat::H264; }
 
  void setOutput(Print &out) override { p_out = &out; }
  void setOutput(VideoOutput &out) override { p_out_video = &out; }
 
  void setVideoFormat(VideoFormat format) override {
    switch (format) {
      case VideoFormat::RGB565:
        config_.output_format = ESP_H264_RAW_FMT_RGB565_LE;
        break;
      case VideoFormat::I420:
        config_.output_format = ESP_H264_RAW_FMT_I420;
        break;
      default:
        LOGW("H264DecoderESP32S3: unsupported VideoFormat %d", (int)format);
        break;
    }
  }
 
  VideoInfo videoInfo() override {
    VideoInfo info;
    info.format = config_.output_format == ESP_H264_RAW_FMT_I420
                       ? VideoFormat::I420
                       : VideoFormat::RGB565;
    uint32_t w = 0, h = 0;
    if (decoder_.getFrameDimensions(w, h)) {
      info.width = (uint16_t)w;
      info.height = (uint16_t)h;
    }
    return info;
  }
 
  void setInputBufferSize(size_t size) { config_.input_buffer_size = size; }
 
  void setOutputBufferSize(size_t size) { config_.output_buffer_size = size; }
 
  bool begin() override { return decoder_.begin(config_); }
 
  void end() override { decoder_.end(); }
 
  size_t write(const uint8_t *data, size_t len) override {
    decoder_.decode(data, len);
    return len;
  }
 
  void flush() override {}
 
  uint32_t frameCount() const { return decoder_.getFrameCount(); }
  uint32_t decodeErrors() const { return decoder_.getDecodeErrors(); }
 
  bool isKeyFrame(const uint8_t *data, size_t len) override {
    return isH264KeyFrame(data, len);
  }
 
  esp_h264::H264Decoder<Alloc> &driver() { return decoder_; }
 
 protected:
  esp_h264::H264Decoder<Alloc> decoder_;
  typename esp_h264::H264Decoder<Alloc>::Config config_;
  Print *p_out = nullptr;
  VideoOutput *p_out_video = nullptr;
};
 
template <typename Alloc = H264_DEFAULT_ALLOCATOR>
class H264EncoderESP32S3 : public VideoEncoder {
 protected:
  class DualOutputPrint : public Print {
   public:
    void setTargets(Print *out, VideoOutput *outVideo) {
      p_out = out;
      p_out_video = outVideo;
    }
    size_t write(uint8_t c) override { return write(&c, 1); }
    size_t write(const uint8_t *data, size_t len) override {
      size_t result = 0;
      if (p_out != nullptr) result = p_out->write(data, len);
      if (p_out_video != nullptr) result = p_out_video->write(data, len);
      return result;
    }
 
   protected:
    Print *p_out = nullptr;
    VideoOutput *p_out_video = nullptr;
  };
 
 public:
  H264EncoderESP32S3() { config_ = encoder_.defaultConfig(); }
 
  H264EncoderESP32S3(Print &out) : H264EncoderESP32S3() { setOutput(out); }
 
  H264EncoderESP32S3(VideoOutput &out) : H264EncoderESP32S3() {
    setOutput(out);
  }
 
  void setOutput(Print &out) override {
    p_out = &out;
    dual_out_.setTargets(p_out, p_out_video);
  }
  void setOutput(VideoOutput &out) {
    p_out_video = &out;
    dual_out_.setTargets(p_out, p_out_video);
  }
 
  void setVideoFormat(VideoFormat format) override {
    switch (format) {
      case VideoFormat::I420:
      case VideoFormat::RGB565:
      case VideoFormat::YUV422:
        input_format = format;
        break;
      default:
        LOGW("H264EncoderESP32S3: unsupported VideoFormat %d", (int)format);
        break;
    }
  }
 
  VideoInfo videoInfo() override {
    VideoInfo info;
    info.format = VideoFormat::H264;
    info.width = (uint16_t)config_.width;
    info.height = (uint16_t)config_.height;
    return info;
  }
 
  void setSize(int width, int height) {
    config_.width = width;
    config_.height = height;
  }
  void setFrameRate(int fps) { config_.fps = fps; }
  void setBitrate(int bitsPerSecond) { config_.bitrate = bitsPerSecond; }
  void setGop(int gop) { config_.gop = gop; }
  void setQpRange(int qpMin, int qpMax) {
    config_.qp_min = qpMin;
    config_.qp_max = qpMax;
  }
  void setOutputBufferSize(size_t size) { config_.outBufferSize = size; }
 
  bool begin() override { return encoder_.begin(config_); }
 
  void end() override { encoder_.end(); }
 
  size_t write(const uint8_t *data, size_t len) override {
    if (p_out == nullptr && p_out_video == nullptr) return 0;
    bool ok = false;
    switch (input_format) {
      case VideoFormat::I420:
        ok = encoder_.encode(data, len, dual_out_);
        break;
      case VideoFormat::RGB565:
        ok = encoder_.encodeRGB565(data, len, dual_out_);
        break;
      case VideoFormat::YUV422:
        ok = encoder_.encodeYUV422(data, len, dual_out_);
        break;
      default:
        break;
    }
    return ok ? 1 : 0;
  }
 
  esp_h264::H264Encoder<Alloc> &driver() { return encoder_; }
 
 protected:
  esp_h264::H264Encoder<Alloc> encoder_;
  typename esp_h264::H264Encoder<Alloc>::Config config_;
  Print *p_out = nullptr;
  VideoOutput *p_out_video = nullptr;
  DualOutputPrint dual_out_;
  VideoFormat input_format = VideoFormat::I420;
};
 
}  // namespace audio_tools