OutputTinyGPU.h

Go to the documentation of this file.

#pragma once
#include <TinyGPU.h>  // https://github.com/pschatzmann/TinyGPU
#include <TinyGPU/DisplayDriver.h>  // ILI9341Driver
#include <TinyGPU/Boards.h>  // LCDBoard
 
#include "AudioTools/CoreAudio/AudioBasic/Collections/Vector.h"
#include "AudioTools/Video/CodecVideo.h"
 
namespace audio_tools {
 
class OutputTinyGPU : public VideoOutput {
 public:
  OutputTinyGPU(DisplayDriver<RGB565>& driver, int pinBacklight,
                int bandHeight = 40)
      : tftDriver(driver),
        kPinBacklight(pinBacklight),
        kBandHeight(bandHeight) {}
 
  OutputTinyGPU(LCDBoard& board, int bandHeight = 40)
      : tftDriver(board.display()),
        kPinBacklight(-1),
        kBandHeight(bandHeight),
        p_board(&board) {}
 
  bool begin() {
    if (p_board != nullptr) {
      if (!p_board->begin()) return false;
    } else {
      if (kPinBacklight >= 0) {
        pinMode(kPinBacklight, OUTPUT);
        digitalWrite(kPinBacklight, HIGH);
      }
      tftDriver.begin();
    }
    clearScreen();
 
    return true;
  }
 
  void setRotation(DisplayRotation rotation) { tftDriver.setRotation(rotation); }
 
  void setVideoInfoSource(VideoInfoSource& source) override { p_info = &source; }
 
  void setVideoInfo(VideoInfo info) { info_ = info; }
 
  void setScaleToFit(bool enable) { scale_to_fit = enable; }
 
  void setScaleSingleBuffer(bool enable) { scale_single_buffer = enable; }
 
  void setSkipRender(bool skip) override { skip_render = skip; }
 
  size_t write(const uint8_t* data, size_t len) override {
    auto start = millis();
    if (p_info != nullptr) {
      info_ = p_info->videoInfo();
    }
 
    if (info_.width == 0 || info_.height == 0) {
      LOGE("OutputTinyGPU: invalid video size: %d x %d", (int)info_.width,
           (int)info_.height);
      return 0;
    }
 
    bool isI420 = info_.format == VideoFormat::I420;
    // I420: one byte/pixel Y plane, plus two quarter-size (w/2 x h/2)
    // U/V planes - the standard w*h*3/2 packed-planar size.
    size_t needed = isI420 ? (size_t)info_.width * info_.height * 3 / 2
                            : (size_t)info_.width * info_.height * sizeof(RGB565);
    if (len < needed) {
      LOGE("OutputTinyGPU: frame too small: %d < %d bytes", (int)len,
           (int)needed);
      return 0;
    }
 
    if (skip_render) {
      return len;
    }
 
    if (isI420) {
      // Unlike the RGB565 path below, this always goes row-by-row (even
      // when scale_to_fit is off) - I420's planar layout isn't a raw byte
      // pattern the driver can view directly the way packed RGB565 is, so
      // conversion is unavoidable regardless of whether scaling also
      // happens in the same pass.
      writeI420(data, info_.width, info_.height);
      write_time_ms = millis() - start;
      return len;
    }
 
    if (scale_to_fit && (info_.width != (int)tftDriver.width() ||
                          info_.height != (int)tftDriver.height())) {
      writeScaled(data, info_.width, info_.height);
      write_time_ms = millis() - start;
      return len;
    }
 
    // View directly over the caller's buffer - no allocation, no copy.
    SurfaceWithExternalBuffer<RGB565> frame;
    frame.setExternalBuffer(const_cast<uint8_t*>(data), len);
    frame.resize(info_.width, info_.height);
    tftDriver.writeData(frame, 0, 0);
    write_time_ms = millis() - start;
 
    return len;
  }
 
  void writeScaled(const uint8_t* data, int srcW, int srcH) {
    int width = (int)tftDriver.width();
    int height = (int)tftDriver.height();
    updateScaleLuts(srcW, srcH, width, height);
    const RGB565* src = (const RGB565*)data;
    const int* xLut = scale_x_lut_.data();
    const int* yLut = scale_y_lut_.data();
 
    if (scale_single_buffer) {
      size_t pixels = (size_t)width * height;
      if (scale_frame_buf_.size() != pixels) scale_frame_buf_.resize(pixels);
      for (int y = 0; y < height; y++) {
        const RGB565* srcRow = src + (size_t)yLut[y] * srcW;
        RGB565* dstRow = scale_frame_buf_.data() + (size_t)y * width;
        for (int x = 0; x < width; x++) {
          dstRow[x] = srcRow[xLut[x]];
        }
      }
      SurfaceWithExternalBuffer<RGB565> frame;
      frame.setExternalBuffer((uint8_t*)scale_frame_buf_.data(),
                               pixels * sizeof(RGB565));
      frame.resize(width, height);
      tftDriver.writeData(frame, 0, 0);
      return;
    }
 
    // One row at a time: build one scaled row into scale_line_, then hand
    // it to the driver as a 1-row-tall surface - one extra small SPI
    // transaction per output row versus the single-buffer path above, but
    // needs only a single row's worth of scratch RAM regardless of
    // resolution.
    if ((int)scale_line_.size() != width) scale_line_.resize(width);
    for (int y = 0; y < height; y++) {
      const RGB565* srcRow = src + (size_t)yLut[y] * srcW;
      for (int x = 0; x < width; x++) {
        scale_line_[x] = srcRow[xLut[x]];
      }
      SurfaceWithExternalBuffer<RGB565> row;
      row.setExternalBuffer((uint8_t*)scale_line_.data(),
                             (size_t)width * sizeof(RGB565));
      row.resize(width, 1);
      tftDriver.writeData(row, 0, y);
    }
  }
 
  void updateScaleLuts(int srcW, int srcH, int width, int height) {
    if (srcW == scale_lut_src_w_ && srcH == scale_lut_src_h_ &&
        width == scale_lut_dst_w_ && height == scale_lut_dst_h_) {
      return;
    }
    scale_x_lut_.resize(width);
    for (int x = 0; x < width; x++) {
      scale_x_lut_[x] = (int)((int64_t)x * srcW / width);
    }
    scale_y_lut_.resize(height);
    for (int y = 0; y < height; y++) {
      scale_y_lut_[y] = (int)((int64_t)y * srcH / height);
    }
    scale_lut_src_w_ = srcW;
    scale_lut_src_h_ = srcH;
    scale_lut_dst_w_ = width;
    scale_lut_dst_h_ = height;
  }
 
  void writeI420(const uint8_t* data, int srcW, int srcH) {
    const uint8_t* yPlane = data;
    const uint8_t* uPlane = yPlane + (size_t)srcW * srcH;
    const uint8_t* vPlane = uPlane + (size_t)(srcW / 2) * (srcH / 2);
    size_t srcPixels = (size_t)srcW * srcH;
    if (i420_rgb_buf_.size() != srcPixels) i420_rgb_buf_.resize(srcPixels);
    for (int y = 0; y < srcH; y++) {
      const uint8_t* yRow = yPlane + (size_t)y * srcW;
      const uint8_t* uRow = uPlane + (size_t)(y / 2) * (srcW / 2);
      const uint8_t* vRow = vPlane + (size_t)(y / 2) * (srcW / 2);
      RGB565* dstRow = i420_rgb_buf_.data() + (size_t)y * srcW;
      for (int x = 0; x < srcW; x++) {
        dstRow[x] = yuvToRgb565(yRow[x], uRow[x / 2], vRow[x / 2]);
      }
    }
 
    if (scale_to_fit && (srcW != (int)tftDriver.width() ||
                          srcH != (int)tftDriver.height())) {
      writeScaled((const uint8_t*)i420_rgb_buf_.data(), srcW, srcH);
      return;
    }
    SurfaceWithExternalBuffer<RGB565> frame;
    frame.setExternalBuffer((uint8_t*)i420_rgb_buf_.data(),
                             srcPixels * sizeof(RGB565));
    frame.resize(srcW, srcH);
    tftDriver.writeData(frame, 0, 0);
  }
 
  static RGB565 yuvToRgb565(uint8_t Y, uint8_t U, uint8_t V) {
    int c = (int)Y - 16;
    int d = (int)U - 128;
    int e = (int)V - 128;
    int r = (298 * c + 409 * e + 128) >> 8;
    int g = (298 * c - 100 * d - 208 * e + 128) >> 8;
    int b = (298 * c + 516 * d + 128) >> 8;
    r = r < 0 ? 0 : (r > 255 ? 255 : r);
    g = g < 0 ? 0 : (g > 255 ? 255 : g);
    b = b < 0 ? 0 : (b > 255 ? 255 : b);
    return RGB565((uint8_t)r, (uint8_t)g, (uint8_t)b);
  }
 
  void clearScreen() {
    int width = (int)tftDriver.width();
    int height = (int)tftDriver.height();
    SurfaceRGB565 band(width, kBandHeight, FontRGB565);
    band.begin();
    band.clear(RGB565(0, 0, 0));
    for (int y = 0; y < height; y += kBandHeight) {
      tftDriver.writeData(band, 0, y);
    }
    band.end();
  }
 
  uint32_t getWriteTimeMs() const { return write_time_ms; }
 
 protected:
  int kPinBacklight;
  int kBandHeight;
  VideoInfoSource* p_info = nullptr;
  VideoInfo info_;
  DisplayDriver<RGB565>& tftDriver;
  LCDBoard* p_board = nullptr;
  bool scale_to_fit = false;
  bool scale_single_buffer = true;
  bool skip_render = false;
 
  Vector<RGB565> scale_frame_buf_{0, DefaultESP32AllocatorRAM};
  Vector<RGB565> scale_line_{0, DefaultESP32AllocatorRAM};
  Vector<int> scale_x_lut_{0, DefaultESP32AllocatorRAM};
  Vector<int> scale_y_lut_{0, DefaultESP32AllocatorRAM};
  int scale_lut_src_w_ = -1;
  int scale_lut_src_h_ = -1;
  int scale_lut_dst_w_ = -1;
  int scale_lut_dst_h_ = -1;
  Vector<RGB565> i420_rgb_buf_{0, DefaultESP32AllocatorRAM};
  uint32_t write_time_ms = 0;
};
 
}  // namespace audio_tools