/* SPDX-License-Identifier: GPL-2.0-or-later */ /* * Copyright (C) 2019, Google Inc. * * viewfinder_qt.cpp - qcam - QPainter-based ViewFinder */ #include "viewfinder_qt.h" #include #include #include #include #include #include #include #include #include #include "format_converter.h" static const QMap nativeFormats { #if QT_VERSION >= QT_VERSION_CHECK(5, 2, 0) { libcamera::formats::ABGR8888, QImage::Format_RGBA8888 }, #endif { libcamera::formats::ARGB8888, QImage::Format_RGB32 }, #if QT_VERSION >= QT_VERSION_CHECK(5, 14, 0) { libcamera::formats::RGB888, QImage::Format_BGR888 }, #endif { libcamera::formats::BGR888, QImage::Format_RGB888 }, }; ViewFinderQt::ViewFinderQt(QWidget *parent) : QWidget(parent), buffer_(nullptr) { icon_ = QIcon(":camera-off.svg"); } ViewFinderQt::~ViewFinderQt() { } const QList &ViewFinderQt::nativeFormats() const { static const QList formats = ::nativeFormats.keys(); return formats; } int ViewFinderQt::setFormat(const libcamera::PixelFormat &format, const QSize &size) { image_ = QImage(); /* * If format conversion is needed, configure the converter and allocate * the destination image. */ if (!::nativeFormats.contains(format)) { int ret = converter_.configure(format, size); if (ret < 0) return ret; image_ = QImage(size, QImage::Format_RGB32); qInfo() << "Using software format conversion from" << format.toString().c_str(); } else { qInfo() << "Zero-copy enabled"; } format_ = format; size_ = size; updateGeometry(); return 0; } void ViewFinderQt::render(libcamera::FrameBuffer *buffer, MappedBuffer *map) { if (buffer->planes().size() != 1) { qWarning() << "Multi-planar buffers are not supported"; return; } unsigned char *memory = static_cast(map->memory); size_t size = buffer->metadata().planes[0].bytesused; { QMutexLocker locker(&mutex_); if (::nativeFormats.contains(format_)) { /* * If the frame format is identical to the display * format, create a QImage that references the frame * and store a reference to the frame buffer. The * previously stored frame buffer, if any, will be * released. * * \todo Get the stride from the buffer instead of * computing it naively */ image_ = QImage(memory, size_.width(), size_.height(), size / size_.height(), ::nativeFormats[format_]); std::swap(buffer, buffer_); } else { /* * Otherwise, convert the format and release the frame * buffer immediately. */ converter_.convert(memory, size, &image_); } } update(); if (buffer) renderComplete(buffer); } void ViewFinderQt::stop() { image_ = QImage(); if (buffer_) { renderComplete(buffer_); buffer_ = nullptr; } update(); } QImage ViewFinderQt::getCurrentImage() { QMutexLocker locker(&mutex_); return image_.copy(); } void ViewFinderQt::paintEvent(QPaintEvent *) { QPainter painter(this); /* If we have an image, draw it. */ if (!image_.isNull()) { painter.drawImage(rect(), image_, image_.rect()); return; } /* * Otherwise, draw the camera stopped icon. Render it to the pixmap if * the size has changed. */ constexpr int margin = 20; if (vfSize_ != size() || pixmap_.isNull()) { QSize vfSize = size() - QSize{ 2 * margin, 2 * margin }; QSize pixmapSize{ 1, 1 }; pixmapSize.scale(vfSize, Qt::KeepAspectRatio); pixmap_ = icon_.pixmap(pixmapSize); vfSize_ = size(); } QPoint point{ margin, margin }; if (pixmap_.width() < width() - 2 * margin) point.setX((width() - pixmap_.width()) / 2); else point.setY((height() - pixmap_.height()) / 2); painter.setBackgroundMode(Qt::OpaqueMode); painter.drawPixmap(point, pixmap_); } QSize ViewFinderQt::sizeHint() const { return size_.isValid() ? size_ : QSize(640, 480); } ' href='#n11'>11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75

/* SPDX-License-Identifier: BSD-2-Clause */
/*
 * Copyright (C) 2019-2021, Raspberry Pi (Trading) Limited
 *
 * sdn.cpp - SDN (spatial denoise) control algorithm
 */

#include <libcamera/base/log.h>

#include "../denoise_status.h"
#include "../noise_status.h"

#include "sdn.hpp"

using namespace RPiController;
using namespace libcamera;

LOG_DEFINE_CATEGORY(RPiSdn)

// Calculate settings for the spatial denoise block using the noise profile in
// the image metadata.

#define NAME "rpi.sdn"

Sdn::Sdn(Controller *controller)
	: DenoiseAlgorithm(controller), mode_(DenoiseMode::ColourOff)
{
}

char const *Sdn::Name() const
{
	return NAME;
}

void Sdn::Read(boost::property_tree::ptree const &params)
{
	deviation_ = params.get<double>("deviation", 3.2);
	strength_ = params.get<double>("strength", 0.75);
}

void Sdn::Initialise() {}

void Sdn::Prepare(Metadata *image_metadata)
{
	struct NoiseStatus noise_status = {};
	noise_status.noise_slope = 3.0; // in case no metadata
	if (image_metadata->Get("noise.status", noise_status) != 0)
		LOG(RPiSdn, Warning) << "no noise profile found";
	LOG(RPiSdn, Debug)
		<< "Noise profile: constant " << noise_status.noise_constant
		<< " slope " << noise_status.noise_slope;
	struct DenoiseStatus status;
	status.noise_constant = noise_status.noise_constant * deviation_;
	status.noise_slope = noise_status.noise_slope * deviation_;
	status.strength = strength_;
	status.mode = static_cast<std::underlying_type_t<DenoiseMode>>(mode_);
	image_metadata->Set("denoise.status", status);
	LOG(RPiSdn, Debug)
		<< "programmed constant " << status.noise_constant
		<< " slope " << status.noise_slope
		<< " strength " << status.strength;
}

void Sdn::SetMode(DenoiseMode mode)
{
	// We only distinguish between off and all other modes.
	mode_ = mode;
}

// Register algorithm with the system.
static Algorithm *Create(Controller *controller)
{
	return (Algorithm *)new Sdn(controller);
}
static RegisterAlgorithm reg(NAME, &Create);