CodecH264ESP32P4.h

Go to the documentation of this file.

#pragma once
 
#include "AudioTools/Video/CodecVideo.h"
#include "H264EncoderP4.h"

 
namespace audio_tools {

template <typename Alloc = H264P4_DEFAULT_ALLOCATOR>
class H264EncoderESP32P4 : 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:
  H264EncoderESP32P4() { config_ = encoder_.defaultConfig(); }
 
  H264EncoderESP32P4(Print &out) : H264EncoderESP32P4() { setOutput(out); }
 
  H264EncoderESP32P4(VideoOutput &out) : H264EncoderESP32P4() {
    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:
        config_.pic_type = ESP_H264_RAW_FMT_O_UYY_E_VYY;
        input_format = format;
        break;
      case VideoFormat::RGB565:
        config_.pic_type = ESP_H264_RAW_FMT_RGB565_LE;
        input_format = format;
        break;
      case VideoFormat::YUV422:
        config_.pic_type = ESP_H264_RAW_FMT_YUYV;
        input_format = format;
        break;
      default:
        LOGW("H264EncoderESP32P4: 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: {
        size_t ySize = (size_t)config_.width * config_.height;
        size_t cSize = ySize / 4;
        if (len < ySize + 2 * cSize) break;
        const uint8_t *srcY = data;
        const uint8_t *srcU = data + ySize;
        const uint8_t *srcV = data + ySize + cSize;
        ok = encoder_.encodeYUV420Planar(srcY, config_.width, srcU, srcV,
                                          config_.width / 2, dual_out_);
        break;
      }
      case VideoFormat::RGB565:
      case VideoFormat::YUV422:
        ok = encoder_.encode(data, len, dual_out_);
        break;
      default:
        break;
    }
    return ok ? 1 : 0;
  }

  esp_h264_frame_type_t lastFrameType() const {
    return encoder_.lastFrameType();
  }

  esp_h264_p4::H264EncoderP4<Alloc> &driver() { return encoder_; }
 
 protected:
  esp_h264_p4::H264EncoderP4<Alloc> encoder_;
  typename esp_h264_p4::H264EncoderP4<Alloc>::Config config_;
  Print *p_out = nullptr;
  VideoOutput *p_out_video = nullptr;
  DualOutputPrint dual_out_;
  VideoFormat input_format = VideoFormat::I420;
};
 
}  // namespace audio_tools