summaryrefslogtreecommitdiff
path: root/src/ipa/raspberrypi/controller/rpi/sharpen.cpp
blob: 9b7f903a155e9a9ebb759666cfd3c87c2bf54019 (plain)
1
2
3
4
5
6
7
8
9
10
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
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
/* SPDX-License-Identifier: BSD-2-Clause */
/*
 * Copyright (C) 2019, Raspberry Pi (Trading) Limited
 *
 * sharpen.cpp - sharpening control algorithm
 */

#include <math.h>

#include <libcamera/base/log.h>

#include "../sharpen_status.h"

#include "sharpen.hpp"

using namespace RPiController;
using namespace libcamera;

LOG_DEFINE_CATEGORY(RPiSharpen)

#define NAME "rpi.sharpen"

Sharpen::Sharpen(Controller *controller)
	: SharpenAlgorithm(controller), userStrength_(1.0)
{
}

char const *Sharpen::name() const
{
	return NAME;
}

void Sharpen::switchMode(CameraMode const &cameraMode,
			 [[maybe_unused]] Metadata *metadata)
{
	/* can't be less than one, right? */
	modeFactor_ = std::max(1.0, cameraMode.noiseFactor);
}

void Sharpen::read(boost::property_tree::ptree const &params)
{
	threshold_ = params.get<double>("threshold", 1.0);
	strength_ = params.get<double>("strength", 1.0);
	limit_ = params.get<double>("limit", 1.0);
	LOG(RPiSharpen, Debug)
		<< "Read threshold " << threshold_
		<< " strength " << strength_
		<< " limit " << limit_;
}

void Sharpen::setStrength(double strength)
{
	/*
	 * Note that this function is how an application sets the overall
	 * sharpening "strength". We call this the "user strength" field
	 * as there already is a strength_ field - being an internal gain
	 * parameter that gets passed to the ISP control code. Negative
	 * values are not allowed - coerce them to zero (no sharpening).
	 */
	userStrength_ = std::max(0.0, strength);
}

void Sharpen::prepare(Metadata *imageMetadata)
{
	/*
	 * The userStrength_ affects the algorithm's internal gain directly, but
	 * we adjust the limit and threshold less aggressively. Using a sqrt
	 * function is an arbitrary but gentle way of accomplishing this.
	 */
	double userStrengthSqrt = sqrt(userStrength_);
	struct SharpenStatus status;
	/*
	 * Binned modes seem to need the sharpening toned down with this
	 * pipeline, thus we use the modeFactor_ here. Also avoid
	 * divide-by-zero with the userStrengthSqrt.
	 */
	status.threshold = threshold_ * modeFactor_ /
			   std::max(0.01, userStrengthSqrt);
	status.strength = strength_ / modeFactor_ * userStrength_;
	status.limit = limit_ / modeFactor_ * userStrengthSqrt;
	/* Finally, report any application-supplied parameters that were used. */
	status.userStrength = userStrength_;
	imageMetadata->set("sharpen.status", status);
}

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