Method GetFrame

src/effects/Sharpen.cpp:235–373

Main frame processing

// Main frame processing
std::shared_ptr<Frame> Sharpen::GetFrame(
  std::shared_ptr<Frame> frame, int64_t frame_number)
{
  auto img = frame->GetImage();
  if (!img || img->isNull())
    return frame;
  if (img->format() != QImage::Format_ARGB32)
    *img = img->convertToFormat(QImage::Format_ARGB32);

  int W = img->width();
  int H = img->height();
  if (W <= 0 || H <= 0)
    return frame;

  // Retrieve keyframe values
  double amt   = amount.GetValue(frame_number);    // 0–40
  double rpx   = radius.GetValue(frame_number);    // px
  double thrUI = threshold.GetValue(frame_number); // 0–1

  // Sigma scaled against 720p reference
  double sigma = std::max(0.1, rpx * H / 720.0);

  // Generate blurred image
  QImage blur(W, H, QImage::Format_ARGB32);
  gauss_blur(*img, blur, sigma);

  // Precompute maximum luma difference for adaptive threshold
  int bplS = img->bytesPerLine();
  int bplB = blur.bytesPerLine();
  uchar* sBits = img->bits();
  uchar* bBits = blur.bits();

  double maxDY = 0.0;
  #pragma omp parallel for reduction(max:maxDY)
  for (int y = 0; y < H; ++y) {
    uchar* sRow = sBits + y * bplS;
    uchar* bRow = bBits + y * bplB;
    for (int x = 0; x < W; ++x) {
      double dB = double(sRow[x*4+0]) - double(bRow[x*4+0]);
      double dG = double(sRow[x*4+1]) - double(bRow[x*4+1]);
      double dR = double(sRow[x*4+2]) - double(bRow[x*4+2]);
      double dY = std::abs(0.114*dB + 0.587*dG + 0.299*dR);
      maxDY = std::max(maxDY, dY);
    }
  }

  // Compute actual threshold in luma units
  double thr = thrUI * maxDY;

  // Process pixels
  #pragma omp parallel for
  for (int y = 0; y < H; ++y) {
    uchar* sRow = sBits + y * bplS;
    uchar* bRow = bBits + y * bplB;
    for (int x = 0; x < W; ++x) {
      uchar* sp = sRow + x*4;
      uchar* bp = bRow + x*4;