[libcamera-devel,02/15] DNI: ipa: raspberrypi: Code refactoring to match style guidelines
diff mbox series

Message ID 20220725134639.4572-3-naush@raspberrypi.com
State Superseded
Headers show
Series
  • Raspberry Pi IPA code refactor
Related show

Commit Message

Naushir Patuck July 25, 2022, 1:46 p.m. UTC 
Refactor the source files src/ipa/raspberrypi/cam_helper* to match the
recommended formatting guidelines for the libcamera project. The vast majority
of changes in this commit comprise of switching from snake_case to CamelCase,
and starting class member functions with a lower case character.

Signed-off-by: Naushir Patuck <naush@raspberrypi.com>
---
 src/ipa/raspberrypi/cam_helper.cpp        | 88 +++++++++++------------
 src/ipa/raspberrypi/cam_helper.hpp        | 40 +++++------
 src/ipa/raspberrypi/cam_helper_imx219.cpp | 34 ++++-----
 src/ipa/raspberrypi/cam_helper_imx290.cpp | 32 ++++-----
 src/ipa/raspberrypi/cam_helper_imx296.cpp | 24 +++----
 src/ipa/raspberrypi/cam_helper_imx477.cpp | 72 +++++++++----------
 src/ipa/raspberrypi/cam_helper_imx519.cpp | 70 +++++++++---------
 src/ipa/raspberrypi/cam_helper_ov5647.cpp | 44 ++++++------
 src/ipa/raspberrypi/cam_helper_ov9281.cpp | 28 ++++----
 9 files changed, 216 insertions(+), 216 deletions(-)

Comments

Laurent Pinchart July 25, 2022, 7:47 p.m. UTC | #1 
Hi Naush,

Thank you for the patch.

On Mon, Jul 25, 2022 at 02:46:26PM +0100, Naushir Patuck via libcamera-devel wrote:
> Refactor the source files src/ipa/raspberrypi/cam_helper* to match the
> recommended formatting guidelines for the libcamera project. The vast majority
> of changes in this commit comprise of switching from snake_case to CamelCase,
> and starting class member functions with a lower case character.
> 
> Signed-off-by: Naushir Patuck <naush@raspberrypi.com>

Reviewed-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com>

> ---
>  src/ipa/raspberrypi/cam_helper.cpp        | 88 +++++++++++------------
>  src/ipa/raspberrypi/cam_helper.hpp        | 40 +++++------
>  src/ipa/raspberrypi/cam_helper_imx219.cpp | 34 ++++-----
>  src/ipa/raspberrypi/cam_helper_imx290.cpp | 32 ++++-----
>  src/ipa/raspberrypi/cam_helper_imx296.cpp | 24 +++----
>  src/ipa/raspberrypi/cam_helper_imx477.cpp | 72 +++++++++----------
>  src/ipa/raspberrypi/cam_helper_imx519.cpp | 70 +++++++++---------
>  src/ipa/raspberrypi/cam_helper_ov5647.cpp | 44 ++++++------
>  src/ipa/raspberrypi/cam_helper_ov9281.cpp | 28 ++++----
>  9 files changed, 216 insertions(+), 216 deletions(-)

Patch
diff mbox series 

diff --git a/src/ipa/raspberrypi/cam_helper.cpp b/src/ipa/raspberrypi/cam_helper.cpp
index 3f81d4187d4d..45db39506937 100644
--- a/src/ipa/raspberrypi/cam_helper.cpp
+++ b/src/ipa/raspberrypi/cam_helper.cpp
@@ -24,16 +24,16 @@  namespace libcamera {
 LOG_DECLARE_CATEGORY(IPARPI)
 }
 
-static std::map<std::string, CamHelperCreateFunc> cam_helpers;
+static std::map<std::string, CamHelperCreateFunc> camHelpers;
 
-CamHelper *CamHelper::Create(std::string const &cam_name)
+CamHelper *CamHelper::create(std::string const &camName)
 {
 	/*
 	 * CamHelpers get registered by static RegisterCamHelper
 	 * initialisers.
 	 */
-	for (auto &p : cam_helpers) {
-		if (cam_name.find(p.first) != std::string::npos)
+	for (auto &p : camHelpers) {
+		if (camName.find(p.first) != std::string::npos)
 			return p.second();
 	}
 
@@ -50,35 +50,35 @@  CamHelper::~CamHelper()
 {
 }
 
-void CamHelper::Prepare(Span<const uint8_t> buffer,
+void CamHelper::prepare(Span<const uint8_t> buffer,
 			Metadata &metadata)
 {
 	parseEmbeddedData(buffer, metadata);
 }
 
-void CamHelper::Process([[maybe_unused]] StatisticsPtr &stats,
+void CamHelper::process([[maybe_unused]] StatisticsPtr &stats,
 			[[maybe_unused]] Metadata &metadata)
 {
 }
 
-uint32_t CamHelper::ExposureLines(const Duration exposure) const
+uint32_t CamHelper::exposureLines(const Duration exposure) const
 {
 	assert(initialized_);
-	return exposure / mode_.line_length;
+	return exposure / mode_.lineLength;
 }
 
-Duration CamHelper::Exposure(uint32_t exposure_lines) const
+Duration CamHelper::exposure(uint32_t exposureLines) const
 {
 	assert(initialized_);
-	return exposure_lines * mode_.line_length;
+	return exposureLines * mode_.lineLength;
 }
 
-uint32_t CamHelper::GetVBlanking(Duration &exposure,
+uint32_t CamHelper::getVBlanking(Duration &exposure,
 				 Duration minFrameDuration,
 				 Duration maxFrameDuration) const
 {
 	uint32_t frameLengthMin, frameLengthMax, vblank;
-	uint32_t exposureLines = ExposureLines(exposure);
+	uint32_t exposureLines = CamHelper::exposureLines(exposure);
 
 	assert(initialized_);
 
@@ -86,15 +86,15 @@  uint32_t CamHelper::GetVBlanking(Duration &exposure,
 	 * minFrameDuration and maxFrameDuration are clamped by the caller
 	 * based on the limits for the active sensor mode.
 	 */
-	frameLengthMin = minFrameDuration / mode_.line_length;
-	frameLengthMax = maxFrameDuration / mode_.line_length;
+	frameLengthMin = minFrameDuration / mode_.lineLength;
+	frameLengthMax = maxFrameDuration / mode_.lineLength;
 
 	/*
 	 * Limit the exposure to the maximum frame duration requested, and
 	 * re-calculate if it has been clipped.
 	 */
 	exposureLines = std::min(frameLengthMax - frameIntegrationDiff_, exposureLines);
-	exposure = Exposure(exposureLines);
+	exposure = CamHelper::exposure(exposureLines);
 
 	/* Limit the vblank to the range allowed by the frame length limits. */
 	vblank = std::clamp(exposureLines + frameIntegrationDiff_,
@@ -102,34 +102,34 @@  uint32_t CamHelper::GetVBlanking(Duration &exposure,
 	return vblank;
 }
 
-void CamHelper::SetCameraMode(const CameraMode &mode)
+void CamHelper::setCameraMode(const CameraMode &mode)
 {
 	mode_ = mode;
 	if (parser_) {
-		parser_->SetBitsPerPixel(mode.bitdepth);
-		parser_->SetLineLengthBytes(0); /* We use SetBufferSize. */
+		parser_->setBitsPerPixel(mode.bitdepth);
+		parser_->setLineLengthBytes(0); /* We use SetBufferSize. */
 	}
 	initialized_ = true;
 }
 
-void CamHelper::GetDelays(int &exposure_delay, int &gain_delay,
-			  int &vblank_delay) const
+void CamHelper::getDelays(int &exposureDelay, int &gainDelay,
+			  int &vblankDelay) const
 {
 	/*
 	 * These values are correct for many sensors. Other sensors will
 	 * need to over-ride this function.
 	 */
-	exposure_delay = 2;
-	gain_delay = 1;
-	vblank_delay = 2;
+	exposureDelay = 2;
+	gainDelay = 1;
+	vblankDelay = 2;
 }
 
-bool CamHelper::SensorEmbeddedDataPresent() const
+bool CamHelper::sensorEmbeddedDataPresent() const
 {
 	return false;
 }
 
-double CamHelper::GetModeSensitivity([[maybe_unused]] const CameraMode &mode) const
+double CamHelper::getModeSensitivity([[maybe_unused]] const CameraMode &mode) const
 {
 	/*
 	 * Most sensors have the same sensitivity in every mode, but this
@@ -140,7 +140,7 @@  double CamHelper::GetModeSensitivity([[maybe_unused]] const CameraMode &mode) co
 	return 1.0;
 }
 
-unsigned int CamHelper::HideFramesStartup() const
+unsigned int CamHelper::hideFramesStartup() const
 {
 	/*
 	 * The number of frames when a camera first starts that shouldn't be
@@ -149,19 +149,19 @@  unsigned int CamHelper::HideFramesStartup() const
 	return 0;
 }
 
-unsigned int CamHelper::HideFramesModeSwitch() const
+unsigned int CamHelper::hideFramesModeSwitch() const
 {
 	/* After a mode switch, many sensors return valid frames immediately. */
 	return 0;
 }
 
-unsigned int CamHelper::MistrustFramesStartup() const
+unsigned int CamHelper::mistrustFramesStartup() const
 {
 	/* Many sensors return a single bad frame on start-up. */
 	return 1;
 }
 
-unsigned int CamHelper::MistrustFramesModeSwitch() const
+unsigned int CamHelper::mistrustFramesModeSwitch() const
 {
 	/* Many sensors return valid metadata immediately. */
 	return 0;
@@ -176,13 +176,13 @@  void CamHelper::parseEmbeddedData(Span<const uint8_t> buffer,
 	if (buffer.empty())
 		return;
 
-	if (parser_->Parse(buffer, registers) != MdParser::Status::OK) {
+	if (parser_->parse(buffer, registers) != MdParser::Status::OK) {
 		LOG(IPARPI, Error) << "Embedded data buffer parsing failed";
 		return;
 	}
 
-	PopulateMetadata(registers, parsedMetadata);
-	metadata.Merge(parsedMetadata);
+	populateMetadata(registers, parsedMetadata);
+	metadata.merge(parsedMetadata);
 
 	/*
 	 * Overwrite the exposure/gain, frame length and sensor temperature values
@@ -190,30 +190,30 @@  void CamHelper::parseEmbeddedData(Span<const uint8_t> buffer,
 	 * Fetch it first in case any other fields were set meaningfully.
 	 */
 	DeviceStatus deviceStatus, parsedDeviceStatus;
-	if (metadata.Get("device.status", deviceStatus) ||
-	    parsedMetadata.Get("device.status", parsedDeviceStatus)) {
+	if (metadata.get("device.status", deviceStatus) ||
+	    parsedMetadata.get("device.status", parsedDeviceStatus)) {
 		LOG(IPARPI, Error) << "DeviceStatus not found";
 		return;
 	}
 
-	deviceStatus.shutter_speed = parsedDeviceStatus.shutter_speed;
-	deviceStatus.analogue_gain = parsedDeviceStatus.analogue_gain;
-	deviceStatus.frame_length = parsedDeviceStatus.frame_length;
-	if (parsedDeviceStatus.sensor_temperature)
-		deviceStatus.sensor_temperature = parsedDeviceStatus.sensor_temperature;
+	deviceStatus.shutterSpeed = parsedDeviceStatus.shutterSpeed;
+	deviceStatus.analogueGain = parsedDeviceStatus.analogueGain;
+	deviceStatus.frameLength = parsedDeviceStatus.frameLength;
+	if (parsedDeviceStatus.sensorTemperature)
+		deviceStatus.sensorTemperature = parsedDeviceStatus.sensorTemperature;
 
 	LOG(IPARPI, Debug) << "Metadata updated - " << deviceStatus;
 
-	metadata.Set("device.status", deviceStatus);
+	metadata.set("device.status", deviceStatus);
 }
 
-void CamHelper::PopulateMetadata([[maybe_unused]] const MdParser::RegisterMap &registers,
+void CamHelper::populateMetadata([[maybe_unused]] const MdParser::RegisterMap &registers,
 				 [[maybe_unused]] Metadata &metadata) const
 {
 }
 
-RegisterCamHelper::RegisterCamHelper(char const *cam_name,
-				     CamHelperCreateFunc create_func)
+RegisterCamHelper::RegisterCamHelper(char const *camName,
+				     CamHelperCreateFunc createFunc)
 {
-	cam_helpers[std::string(cam_name)] = create_func;
+	camHelpers[std::string(camName)] = createFunc;
 }
diff --git a/src/ipa/raspberrypi/cam_helper.hpp b/src/ipa/raspberrypi/cam_helper.hpp
index 300f8f8a2d3b..0cd718c4bc4e 100644
--- a/src/ipa/raspberrypi/cam_helper.hpp
+++ b/src/ipa/raspberrypi/cam_helper.hpp
@@ -69,33 +69,33 @@  namespace RPiController {
 class CamHelper
 {
 public:
-	static CamHelper *Create(std::string const &cam_name);
+	static CamHelper *create(std::string const &camName);
 	CamHelper(std::unique_ptr<MdParser> parser, unsigned int frameIntegrationDiff);
 	virtual ~CamHelper();
-	void SetCameraMode(const CameraMode &mode);
-	virtual void Prepare(libcamera::Span<const uint8_t> buffer,
+	void setCameraMode(const CameraMode &mode);
+	virtual void prepare(libcamera::Span<const uint8_t> buffer,
 			     Metadata &metadata);
-	virtual void Process(StatisticsPtr &stats, Metadata &metadata);
-	virtual uint32_t ExposureLines(libcamera::utils::Duration exposure) const;
-	virtual libcamera::utils::Duration Exposure(uint32_t exposure_lines) const;
-	virtual uint32_t GetVBlanking(libcamera::utils::Duration &exposure,
+	virtual void process(StatisticsPtr &stats, Metadata &metadata);
+	virtual uint32_t exposureLines(libcamera::utils::Duration exposure) const;
+	virtual libcamera::utils::Duration exposure(uint32_t exposureLines) const;
+	virtual uint32_t getVBlanking(libcamera::utils::Duration &exposure,
 				      libcamera::utils::Duration minFrameDuration,
 				      libcamera::utils::Duration maxFrameDuration) const;
-	virtual uint32_t GainCode(double gain) const = 0;
-	virtual double Gain(uint32_t gain_code) const = 0;
-	virtual void GetDelays(int &exposure_delay, int &gain_delay,
-			       int &vblank_delay) const;
-	virtual bool SensorEmbeddedDataPresent() const;
-	virtual double GetModeSensitivity(const CameraMode &mode) const;
-	virtual unsigned int HideFramesStartup() const;
-	virtual unsigned int HideFramesModeSwitch() const;
-	virtual unsigned int MistrustFramesStartup() const;
-	virtual unsigned int MistrustFramesModeSwitch() const;
+	virtual uint32_t gainCode(double gain) const = 0;
+	virtual double gain(uint32_t gainCode) const = 0;
+	virtual void getDelays(int &exposureDelay, int &gainDelay,
+			       int &vblankDelay) const;
+	virtual bool sensorEmbeddedDataPresent() const;
+	virtual double getModeSensitivity(const CameraMode &mode) const;
+	virtual unsigned int hideFramesStartup() const;
+	virtual unsigned int hideFramesModeSwitch() const;
+	virtual unsigned int mistrustFramesStartup() const;
+	virtual unsigned int mistrustFramesModeSwitch() const;
 
 protected:
 	void parseEmbeddedData(libcamera::Span<const uint8_t> buffer,
 			       Metadata &metadata);
-	virtual void PopulateMetadata(const MdParser::RegisterMap &registers,
+	virtual void populateMetadata(const MdParser::RegisterMap &registers,
 				      Metadata &metadata) const;
 
 	std::unique_ptr<MdParser> parser_;
@@ -116,8 +116,8 @@  private:
 typedef CamHelper *(*CamHelperCreateFunc)();
 struct RegisterCamHelper
 {
-	RegisterCamHelper(char const *cam_name,
-			  CamHelperCreateFunc create_func);
+	RegisterCamHelper(char const *camName,
+			  CamHelperCreateFunc createFunc);
 };
 
 } // namespace RPi
diff --git a/src/ipa/raspberrypi/cam_helper_imx219.cpp b/src/ipa/raspberrypi/cam_helper_imx219.cpp
index a3caab714602..17c35143923a 100644
--- a/src/ipa/raspberrypi/cam_helper_imx219.cpp
+++ b/src/ipa/raspberrypi/cam_helper_imx219.cpp
@@ -39,10 +39,10 @@  class CamHelperImx219 : public CamHelper
 {
 public:
 	CamHelperImx219();
-	uint32_t GainCode(double gain) const override;
-	double Gain(uint32_t gain_code) const override;
-	unsigned int MistrustFramesModeSwitch() const override;
-	bool SensorEmbeddedDataPresent() const override;
+	uint32_t gainCode(double gain) const override;
+	double gain(uint32_t gainCode) const override;
+	unsigned int mistrustFramesModeSwitch() const override;
+	bool sensorEmbeddedDataPresent() const override;
 
 private:
 	/*
@@ -51,7 +51,7 @@  private:
 	 */
 	static constexpr int frameIntegrationDiff = 4;
 
-	void PopulateMetadata(const MdParser::RegisterMap &registers,
+	void populateMetadata(const MdParser::RegisterMap &registers,
 			      Metadata &metadata) const override;
 };
 
@@ -64,17 +64,17 @@  CamHelperImx219::CamHelperImx219()
 {
 }
 
-uint32_t CamHelperImx219::GainCode(double gain) const
+uint32_t CamHelperImx219::gainCode(double gain) const
 {
 	return (uint32_t)(256 - 256 / gain);
 }
 
-double CamHelperImx219::Gain(uint32_t gain_code) const
+double CamHelperImx219::gain(uint32_t gainCode) const
 {
-	return 256.0 / (256 - gain_code);
+	return 256.0 / (256 - gainCode);
 }
 
-unsigned int CamHelperImx219::MistrustFramesModeSwitch() const
+unsigned int CamHelperImx219::mistrustFramesModeSwitch() const
 {
 	/*
 	 * For reasons unknown, we do occasionally get a bogus metadata frame
@@ -84,26 +84,26 @@  unsigned int CamHelperImx219::MistrustFramesModeSwitch() const
 	return 1;
 }
 
-bool CamHelperImx219::SensorEmbeddedDataPresent() const
+bool CamHelperImx219::sensorEmbeddedDataPresent() const
 {
 	return ENABLE_EMBEDDED_DATA;
 }
 
-void CamHelperImx219::PopulateMetadata(const MdParser::RegisterMap &registers,
+void CamHelperImx219::populateMetadata(const MdParser::RegisterMap &registers,
 				       Metadata &metadata) const
 {
 	DeviceStatus deviceStatus;
 
-	deviceStatus.shutter_speed = Exposure(registers.at(expHiReg) * 256 + registers.at(expLoReg));
-	deviceStatus.analogue_gain = Gain(registers.at(gainReg));
-	deviceStatus.frame_length = registers.at(frameLengthHiReg) * 256 + registers.at(frameLengthLoReg);
+	deviceStatus.shutterSpeed = exposure(registers.at(expHiReg) * 256 + registers.at(expLoReg));
+	deviceStatus.analogueGain = gain(registers.at(gainReg));
+	deviceStatus.frameLength = registers.at(frameLengthHiReg) * 256 + registers.at(frameLengthLoReg);
 
-	metadata.Set("device.status", deviceStatus);
+	metadata.set("device.status", deviceStatus);
 }
 
-static CamHelper *Create()
+static CamHelper *create()
 {
 	return new CamHelperImx219();
 }
 
-static RegisterCamHelper reg("imx219", &Create);
+static RegisterCamHelper reg("imx219", &create);
diff --git a/src/ipa/raspberrypi/cam_helper_imx290.cpp b/src/ipa/raspberrypi/cam_helper_imx290.cpp
index 871c1f8eaec4..0d9a94d8d3f6 100644
--- a/src/ipa/raspberrypi/cam_helper_imx290.cpp
+++ b/src/ipa/raspberrypi/cam_helper_imx290.cpp
@@ -15,11 +15,11 @@  class CamHelperImx290 : public CamHelper
 {
 public:
 	CamHelperImx290();
-	uint32_t GainCode(double gain) const override;
-	double Gain(uint32_t gain_code) const override;
-	void GetDelays(int &exposure_delay, int &gain_delay,
-		       int &vblank_delay) const override;
-	unsigned int HideFramesModeSwitch() const override;
+	uint32_t gainCode(double gain) const override;
+	double gain(uint32_t gainCode) const override;
+	void getDelays(int &exposureDelay, int &gainDelay,
+		       int &vblankDelay) const override;
+	unsigned int hideFramesModeSwitch() const override;
 
 private:
 	/*
@@ -34,34 +34,34 @@  CamHelperImx290::CamHelperImx290()
 {
 }
 
-uint32_t CamHelperImx290::GainCode(double gain) const
+uint32_t CamHelperImx290::gainCode(double gain) const
 {
 	int code = 66.6667 * log10(gain);
 	return std::max(0, std::min(code, 0xf0));
 }
 
-double CamHelperImx290::Gain(uint32_t gain_code) const
+double CamHelperImx290::gain(uint32_t gainCode) const
 {
-	return pow(10, 0.015 * gain_code);
+	return pow(10, 0.015 * gainCode);
 }
 
-void CamHelperImx290::GetDelays(int &exposure_delay, int &gain_delay,
-				int &vblank_delay) const
+void CamHelperImx290::getDelays(int &exposureDelay, int &gainDelay,
+				int &vblankDelay) const
 {
-	exposure_delay = 2;
-	gain_delay = 2;
-	vblank_delay = 2;
+	exposureDelay = 2;
+	gainDelay = 2;
+	vblankDelay = 2;
 }
 
-unsigned int CamHelperImx290::HideFramesModeSwitch() const
+unsigned int CamHelperImx290::hideFramesModeSwitch() const
 {
 	/* After a mode switch, we seem to get 1 bad frame. */
 	return 1;
 }
 
-static CamHelper *Create()
+static CamHelper *create()
 {
 	return new CamHelperImx290();
 }
 
-static RegisterCamHelper reg("imx290", &Create);
+static RegisterCamHelper reg("imx290", &create);
diff --git a/src/ipa/raspberrypi/cam_helper_imx296.cpp b/src/ipa/raspberrypi/cam_helper_imx296.cpp
index a1a771cb96d5..15674335fa75 100644
--- a/src/ipa/raspberrypi/cam_helper_imx296.cpp
+++ b/src/ipa/raspberrypi/cam_helper_imx296.cpp
@@ -19,10 +19,10 @@  class CamHelperImx296 : public CamHelper
 {
 public:
 	CamHelperImx296();
-	uint32_t GainCode(double gain) const override;
-	double Gain(uint32_t gain_code) const override;
-	uint32_t ExposureLines(Duration exposure) const override;
-	Duration Exposure(uint32_t exposure_lines) const override;
+	uint32_t gainCode(double gain) const override;
+	double gain(uint32_t gainCode) const override;
+	uint32_t exposureLines(Duration exposure) const override;
+	Duration exposure(uint32_t exposureLines) const override;
 
 private:
 	static constexpr uint32_t maxGainCode = 239;
@@ -40,30 +40,30 @@  CamHelperImx296::CamHelperImx296()
 {
 }
 
-uint32_t CamHelperImx296::GainCode(double gain) const
+uint32_t CamHelperImx296::gainCode(double gain) const
 {
 	uint32_t code = 20 * std::log10(gain) * 10;
 	return std::min(code, maxGainCode);
 }
 
-double CamHelperImx296::Gain(uint32_t gain_code) const
+double CamHelperImx296::gain(uint32_t gainCode) const
 {
-	return std::pow(10.0, gain_code / 200.0);
+	return std::pow(10.0, gainCode / 200.0);
 }
 
-uint32_t CamHelperImx296::ExposureLines(Duration exposure) const
+uint32_t CamHelperImx296::exposureLines(Duration exposure) const
 {
 	return (exposure - 14.26us) / timePerLine;
 }
 
-Duration CamHelperImx296::Exposure(uint32_t exposure_lines) const
+Duration CamHelperImx296::exposure(uint32_t exposureLines) const
 {
-	return exposure_lines * timePerLine + 14.26us;
+	return exposureLines * timePerLine + 14.26us;
 }
 
-static CamHelper *Create()
+static CamHelper *create()
 {
 	return new CamHelperImx296();
 }
 
-static RegisterCamHelper reg("imx296", &Create);
+static RegisterCamHelper reg("imx296", &create);
diff --git a/src/ipa/raspberrypi/cam_helper_imx477.cpp b/src/ipa/raspberrypi/cam_helper_imx477.cpp
index 0e1c0dbd142f..0767a5e1dcc5 100644
--- a/src/ipa/raspberrypi/cam_helper_imx477.cpp
+++ b/src/ipa/raspberrypi/cam_helper_imx477.cpp
@@ -43,14 +43,14 @@  class CamHelperImx477 : public CamHelper
 {
 public:
 	CamHelperImx477();
-	uint32_t GainCode(double gain) const override;
-	double Gain(uint32_t gain_code) const override;
-	void Prepare(libcamera::Span<const uint8_t> buffer, Metadata &metadata) override;
-	uint32_t GetVBlanking(Duration &exposure, Duration minFrameDuration,
+	uint32_t gainCode(double gain) const override;
+	double gain(uint32_t gainCode) const override;
+	void prepare(libcamera::Span<const uint8_t> buffer, Metadata &metadata) override;
+	uint32_t getVBlanking(Duration &exposure, Duration minFrameDuration,
 			      Duration maxFrameDuration) const override;
-	void GetDelays(int &exposure_delay, int &gain_delay,
-		       int &vblank_delay) const override;
-	bool SensorEmbeddedDataPresent() const override;
+	void getDelays(int &exposureDelay, int &gainDelay,
+		       int &vblankDelay) const override;
+	bool sensorEmbeddedDataPresent() const override;
 
 private:
 	/*
@@ -63,7 +63,7 @@  private:
 	/* Largest long exposure scale factor given as a left shift on the frame length. */
 	static constexpr int longExposureShiftMax = 7;
 
-	void PopulateMetadata(const MdParser::RegisterMap &registers,
+	void populateMetadata(const MdParser::RegisterMap &registers,
 			      Metadata &metadata) const override;
 };
 
@@ -72,22 +72,22 @@  CamHelperImx477::CamHelperImx477()
 {
 }
 
-uint32_t CamHelperImx477::GainCode(double gain) const
+uint32_t CamHelperImx477::gainCode(double gain) const
 {
 	return static_cast<uint32_t>(1024 - 1024 / gain);
 }
 
-double CamHelperImx477::Gain(uint32_t gain_code) const
+double CamHelperImx477::gain(uint32_t gainCode) const
 {
-	return 1024.0 / (1024 - gain_code);
+	return 1024.0 / (1024 - gainCode);
 }
 
-void CamHelperImx477::Prepare(libcamera::Span<const uint8_t> buffer, Metadata &metadata)
+void CamHelperImx477::prepare(libcamera::Span<const uint8_t> buffer, Metadata &metadata)
 {
 	MdParser::RegisterMap registers;
 	DeviceStatus deviceStatus;
 
-	if (metadata.Get("device.status", deviceStatus)) {
+	if (metadata.get("device.status", deviceStatus)) {
 		LOG(IPARPI, Error) << "DeviceStatus not found from DelayedControls";
 		return;
 	}
@@ -105,27 +105,27 @@  void CamHelperImx477::Prepare(libcamera::Span<const uint8_t> buffer, Metadata &m
 	 * Otherwise, all values are updated with what is reported in the
 	 * embedded data.
 	 */
-	if (deviceStatus.frame_length > frameLengthMax) {
+	if (deviceStatus.frameLength > frameLengthMax) {
 		DeviceStatus parsedDeviceStatus;
 
-		metadata.Get("device.status", parsedDeviceStatus);
-		parsedDeviceStatus.shutter_speed = deviceStatus.shutter_speed;
-		parsedDeviceStatus.frame_length = deviceStatus.frame_length;
-		metadata.Set("device.status", parsedDeviceStatus);
+		metadata.get("device.status", parsedDeviceStatus);
+		parsedDeviceStatus.shutterSpeed = deviceStatus.shutterSpeed;
+		parsedDeviceStatus.frameLength = deviceStatus.frameLength;
+		metadata.set("device.status", parsedDeviceStatus);
 
 		LOG(IPARPI, Debug) << "Metadata updated for long exposure: "
 				   << parsedDeviceStatus;
 	}
 }
 
-uint32_t CamHelperImx477::GetVBlanking(Duration &exposure,
+uint32_t CamHelperImx477::getVBlanking(Duration &exposure,
 				       Duration minFrameDuration,
 				       Duration maxFrameDuration) const
 {
 	uint32_t frameLength, exposureLines;
 	unsigned int shift = 0;
 
-	frameLength = mode_.height + CamHelper::GetVBlanking(exposure, minFrameDuration,
+	frameLength = mode_.height + CamHelper::getVBlanking(exposure, minFrameDuration,
 							     maxFrameDuration);
 	/*
 	 * Check if the frame length calculated needs to be setup for long
@@ -144,43 +144,43 @@  uint32_t CamHelperImx477::GetVBlanking(Duration &exposure,
 	if (shift) {
 		/* Account for any rounding in the scaled frame length value. */
 		frameLength <<= shift;
-		exposureLines = ExposureLines(exposure);
+		exposureLines = CamHelperImx477::exposureLines(exposure);
 		exposureLines = std::min(exposureLines, frameLength - frameIntegrationDiff);
-		exposure = Exposure(exposureLines);
+		exposure = CamHelperImx477::exposure(exposureLines);
 	}
 
 	return frameLength - mode_.height;
 }
 
-void CamHelperImx477::GetDelays(int &exposure_delay, int &gain_delay,
-				int &vblank_delay) const
+void CamHelperImx477::getDelays(int &exposureDelay, int &gainDelay,
+				int &vblankDelay) const
 {
-	exposure_delay = 2;
-	gain_delay = 2;
-	vblank_delay = 3;
+	exposureDelay = 2;
+	gainDelay = 2;
+	vblankDelay = 3;
 }
 
-bool CamHelperImx477::SensorEmbeddedDataPresent() const
+bool CamHelperImx477::sensorEmbeddedDataPresent() const
 {
 	return true;
 }
 
-void CamHelperImx477::PopulateMetadata(const MdParser::RegisterMap &registers,
+void CamHelperImx477::populateMetadata(const MdParser::RegisterMap &registers,
 				       Metadata &metadata) const
 {
 	DeviceStatus deviceStatus;
 
-	deviceStatus.shutter_speed = Exposure(registers.at(expHiReg) * 256 + registers.at(expLoReg));
-	deviceStatus.analogue_gain = Gain(registers.at(gainHiReg) * 256 + registers.at(gainLoReg));
-	deviceStatus.frame_length = registers.at(frameLengthHiReg) * 256 + registers.at(frameLengthLoReg);
-	deviceStatus.sensor_temperature = std::clamp<int8_t>(registers.at(temperatureReg), -20, 80);
+	deviceStatus.shutterSpeed = exposure(registers.at(expHiReg) * 256 + registers.at(expLoReg));
+	deviceStatus.analogueGain = gain(registers.at(gainHiReg) * 256 + registers.at(gainLoReg));
+	deviceStatus.frameLength = registers.at(frameLengthHiReg) * 256 + registers.at(frameLengthLoReg);
+	deviceStatus.sensorTemperature = std::clamp<int8_t>(registers.at(temperatureReg), -20, 80);
 
-	metadata.Set("device.status", deviceStatus);
+	metadata.set("device.status", deviceStatus);
 }
 
-static CamHelper *Create()
+static CamHelper *create()
 {
 	return new CamHelperImx477();
 }
 
-static RegisterCamHelper reg("imx477", &Create);
+static RegisterCamHelper reg("imx477", &create);
diff --git a/src/ipa/raspberrypi/cam_helper_imx519.cpp b/src/ipa/raspberrypi/cam_helper_imx519.cpp
index eaf24982b37f..1752760e64a2 100644
--- a/src/ipa/raspberrypi/cam_helper_imx519.cpp
+++ b/src/ipa/raspberrypi/cam_helper_imx519.cpp
@@ -43,14 +43,14 @@  class CamHelperImx519 : public CamHelper
 {
 public:
 	CamHelperImx519();
-	uint32_t GainCode(double gain) const override;
-	double Gain(uint32_t gain_code) const override;
-	void Prepare(libcamera::Span<const uint8_t> buffer, Metadata &metadata) override;
-	uint32_t GetVBlanking(Duration &exposure, Duration minFrameDuration,
+	uint32_t gainCode(double gain) const override;
+	double gain(uint32_t gainCode) const override;
+	void prepare(libcamera::Span<const uint8_t> buffer, Metadata &metadata) override;
+	uint32_t getVBlanking(Duration &exposure, Duration minFrameDuration,
 			      Duration maxFrameDuration) const override;
-	void GetDelays(int &exposure_delay, int &gain_delay,
-		       int &vblank_delay) const override;
-	bool SensorEmbeddedDataPresent() const override;
+	void getDelays(int &exposureDelay, int &gainDelay,
+		       int &vblankDelay) const override;
+	bool sensorEmbeddedDataPresent() const override;
 
 private:
 	/*
@@ -63,7 +63,7 @@  private:
 	/* Largest long exposure scale factor given as a left shift on the frame length. */
 	static constexpr int longExposureShiftMax = 7;
 
-	void PopulateMetadata(const MdParser::RegisterMap &registers,
+	void populateMetadata(const MdParser::RegisterMap &registers,
 			      Metadata &metadata) const override;
 };
 
@@ -72,22 +72,22 @@  CamHelperImx519::CamHelperImx519()
 {
 }
 
-uint32_t CamHelperImx519::GainCode(double gain) const
+uint32_t CamHelperImx519::gainCode(double gain) const
 {
 	return static_cast<uint32_t>(1024 - 1024 / gain);
 }
 
-double CamHelperImx519::Gain(uint32_t gain_code) const
+double CamHelperImx519::gain(uint32_t gainCode) const
 {
-	return 1024.0 / (1024 - gain_code);
+	return 1024.0 / (1024 - gainCode);
 }
 
-void CamHelperImx519::Prepare(libcamera::Span<const uint8_t> buffer, Metadata &metadata)
+void CamHelperImx519::prepare(libcamera::Span<const uint8_t> buffer, Metadata &metadata)
 {
 	MdParser::RegisterMap registers;
 	DeviceStatus deviceStatus;
 
-	if (metadata.Get("device.status", deviceStatus)) {
+	if (metadata.get("device.status", deviceStatus)) {
 		LOG(IPARPI, Error) << "DeviceStatus not found from DelayedControls";
 		return;
 	}
@@ -105,27 +105,27 @@  void CamHelperImx519::Prepare(libcamera::Span<const uint8_t> buffer, Metadata &m
 	 * Otherwise, all values are updated with what is reported in the
 	 * embedded data.
 	 */
-	if (deviceStatus.frame_length > frameLengthMax) {
+	if (deviceStatus.frameLength > frameLengthMax) {
 		DeviceStatus parsedDeviceStatus;
 
-		metadata.Get("device.status", parsedDeviceStatus);
-		parsedDeviceStatus.shutter_speed = deviceStatus.shutter_speed;
-		parsedDeviceStatus.frame_length = deviceStatus.frame_length;
-		metadata.Set("device.status", parsedDeviceStatus);
+		metadata.get("device.status", parsedDeviceStatus);
+		parsedDeviceStatus.shutterSpeed = deviceStatus.shutterSpeed;
+		parsedDeviceStatus.frameLength = deviceStatus.frameLength;
+		metadata.set("device.status", parsedDeviceStatus);
 
 		LOG(IPARPI, Debug) << "Metadata updated for long exposure: "
 				   << parsedDeviceStatus;
 	}
 }
 
-uint32_t CamHelperImx519::GetVBlanking(Duration &exposure,
+uint32_t CamHelperImx519::getVBlanking(Duration &exposure,
 				       Duration minFrameDuration,
 				       Duration maxFrameDuration) const
 {
 	uint32_t frameLength, exposureLines;
 	unsigned int shift = 0;
 
-	frameLength = mode_.height + CamHelper::GetVBlanking(exposure, minFrameDuration,
+	frameLength = mode_.height + CamHelper::getVBlanking(exposure, minFrameDuration,
 							     maxFrameDuration);
 	/*
 	 * Check if the frame length calculated needs to be setup for long
@@ -144,42 +144,42 @@  uint32_t CamHelperImx519::GetVBlanking(Duration &exposure,
 	if (shift) {
 		/* Account for any rounding in the scaled frame length value. */
 		frameLength <<= shift;
-		exposureLines = ExposureLines(exposure);
+		exposureLines = CamHelperImx519::exposureLines(exposure);
 		exposureLines = std::min(exposureLines, frameLength - frameIntegrationDiff);
-		exposure = Exposure(exposureLines);
+		exposure = CamHelperImx519::exposure(exposureLines);
 	}
 
 	return frameLength - mode_.height;
 }
 
-void CamHelperImx519::GetDelays(int &exposure_delay, int &gain_delay,
-				int &vblank_delay) const
+void CamHelperImx519::getDelays(int &exposureDelay, int &gainDelay,
+				int &vblankDelay) const
 {
-	exposure_delay = 2;
-	gain_delay = 2;
-	vblank_delay = 3;
+	exposureDelay = 2;
+	gainDelay = 2;
+	vblankDelay = 3;
 }
 
-bool CamHelperImx519::SensorEmbeddedDataPresent() const
+bool CamHelperImx519::sensorEmbeddedDataPresent() const
 {
 	return true;
 }
 
-void CamHelperImx519::PopulateMetadata(const MdParser::RegisterMap &registers,
+void CamHelperImx519::populateMetadata(const MdParser::RegisterMap &registers,
 				       Metadata &metadata) const
 {
 	DeviceStatus deviceStatus;
 
-	deviceStatus.shutter_speed = Exposure(registers.at(expHiReg) * 256 + registers.at(expLoReg));
-	deviceStatus.analogue_gain = Gain(registers.at(gainHiReg) * 256 + registers.at(gainLoReg));
-	deviceStatus.frame_length = registers.at(frameLengthHiReg) * 256 + registers.at(frameLengthLoReg);
+	deviceStatus.shutterSpeed = exposure(registers.at(expHiReg) * 256 + registers.at(expLoReg));
+	deviceStatus.analogueGain = gain(registers.at(gainHiReg) * 256 + registers.at(gainLoReg));
+	deviceStatus.frameLength = registers.at(frameLengthHiReg) * 256 + registers.at(frameLengthLoReg);
 
-	metadata.Set("device.status", deviceStatus);
+	metadata.set("device.status", deviceStatus);
 }
 
-static CamHelper *Create()
+static CamHelper *create()
 {
 	return new CamHelperImx519();
 }
 
-static RegisterCamHelper reg("imx519", &Create);
+static RegisterCamHelper reg("imx519", &create);
diff --git a/src/ipa/raspberrypi/cam_helper_ov5647.cpp b/src/ipa/raspberrypi/cam_helper_ov5647.cpp
index 702c2d07f73a..9dc3fc44e5e8 100644
--- a/src/ipa/raspberrypi/cam_helper_ov5647.cpp
+++ b/src/ipa/raspberrypi/cam_helper_ov5647.cpp
@@ -15,14 +15,14 @@  class CamHelperOv5647 : public CamHelper
 {
 public:
 	CamHelperOv5647();
-	uint32_t GainCode(double gain) const override;
-	double Gain(uint32_t gain_code) const override;
-	void GetDelays(int &exposure_delay, int &gain_delay,
-		       int &vblank_delay) const override;
-	unsigned int HideFramesStartup() const override;
-	unsigned int HideFramesModeSwitch() const override;
-	unsigned int MistrustFramesStartup() const override;
-	unsigned int MistrustFramesModeSwitch() const override;
+	uint32_t gainCode(double gain) const override;
+	double gain(uint32_t gainCode) const override;
+	void getDelays(int &exposureDelay, int &gainDelay,
+		       int &vblankDelay) const override;
+	unsigned int hideFramesStartup() const override;
+	unsigned int hideFramesModeSwitch() const override;
+	unsigned int mistrustFramesStartup() const override;
+	unsigned int mistrustFramesModeSwitch() const override;
 
 private:
 	/*
@@ -42,29 +42,29 @@  CamHelperOv5647::CamHelperOv5647()
 {
 }
 
-uint32_t CamHelperOv5647::GainCode(double gain) const
+uint32_t CamHelperOv5647::gainCode(double gain) const
 {
 	return static_cast<uint32_t>(gain * 16.0);
 }
 
-double CamHelperOv5647::Gain(uint32_t gain_code) const
+double CamHelperOv5647::gain(uint32_t gainCode) const
 {
-	return static_cast<double>(gain_code) / 16.0;
+	return static_cast<double>(gainCode) / 16.0;
 }
 
-void CamHelperOv5647::GetDelays(int &exposure_delay, int &gain_delay,
-				int &vblank_delay) const
+void CamHelperOv5647::getDelays(int &exposureDelay, int &gainDelay,
+				int &vblankDelay) const
 {
 	/*
 	 * We run this sensor in a mode where the gain delay is bumped up to
 	 * 2. It seems to be the only way to make the delays "predictable".
 	 */
-	exposure_delay = 2;
-	gain_delay = 2;
-	vblank_delay = 2;
+	exposureDelay = 2;
+	gainDelay = 2;
+	vblankDelay = 2;
 }
 
-unsigned int CamHelperOv5647::HideFramesStartup() const
+unsigned int CamHelperOv5647::hideFramesStartup() const
 {
 	/*
 	 * On startup, we get a couple of under-exposed frames which
@@ -73,7 +73,7 @@  unsigned int CamHelperOv5647::HideFramesStartup() const
 	return 2;
 }
 
-unsigned int CamHelperOv5647::HideFramesModeSwitch() const
+unsigned int CamHelperOv5647::hideFramesModeSwitch() const
 {
 	/*
 	 * After a mode switch, we get a couple of under-exposed frames which
@@ -82,7 +82,7 @@  unsigned int CamHelperOv5647::HideFramesModeSwitch() const
 	return 2;
 }
 
-unsigned int CamHelperOv5647::MistrustFramesStartup() const
+unsigned int CamHelperOv5647::mistrustFramesStartup() const
 {
 	/*
 	 * First couple of frames are under-exposed and are no good for control
@@ -91,7 +91,7 @@  unsigned int CamHelperOv5647::MistrustFramesStartup() const
 	return 2;
 }
 
-unsigned int CamHelperOv5647::MistrustFramesModeSwitch() const
+unsigned int CamHelperOv5647::mistrustFramesModeSwitch() const
 {
 	/*
 	 * First couple of frames are under-exposed even after a simple
@@ -100,9 +100,9 @@  unsigned int CamHelperOv5647::MistrustFramesModeSwitch() const
 	return 2;
 }
 
-static CamHelper *Create()
+static CamHelper *create()
 {
 	return new CamHelperOv5647();
 }
 
-static RegisterCamHelper reg("ov5647", &Create);
+static RegisterCamHelper reg("ov5647", &create);
diff --git a/src/ipa/raspberrypi/cam_helper_ov9281.cpp b/src/ipa/raspberrypi/cam_helper_ov9281.cpp
index 9de868c31dc0..130450afefc7 100644
--- a/src/ipa/raspberrypi/cam_helper_ov9281.cpp
+++ b/src/ipa/raspberrypi/cam_helper_ov9281.cpp
@@ -15,10 +15,10 @@  class CamHelperOv9281 : public CamHelper
 {
 public:
 	CamHelperOv9281();
-	uint32_t GainCode(double gain) const override;
-	double Gain(uint32_t gain_code) const override;
-	void GetDelays(int &exposure_delay, int &gain_delay,
-		       int &vblank_delay) const override;
+	uint32_t gainCode(double gain) const override;
+	double gain(uint32_t gainCode) const override;
+	void getDelays(int &exposureDelay, int &gainDelay,
+		       int &vblankDelay) const override;
 
 private:
 	/*
@@ -38,28 +38,28 @@  CamHelperOv9281::CamHelperOv9281()
 {
 }
 
-uint32_t CamHelperOv9281::GainCode(double gain) const
+uint32_t CamHelperOv9281::gainCode(double gain) const
 {
 	return static_cast<uint32_t>(gain * 16.0);
 }
 
-double CamHelperOv9281::Gain(uint32_t gain_code) const
+double CamHelperOv9281::gain(uint32_t gainCode) const
 {
-	return static_cast<double>(gain_code) / 16.0;
+	return static_cast<double>(gainCode) / 16.0;
 }
 
-void CamHelperOv9281::GetDelays(int &exposure_delay, int &gain_delay,
-				int &vblank_delay) const
+void CamHelperOv9281::getDelays(int &exposureDelay, int &gainDelay,
+				int &vblankDelay) const
 {
 	/* The driver appears to behave as follows: */
-	exposure_delay = 2;
-	gain_delay = 2;
-	vblank_delay = 2;
+	exposureDelay = 2;
+	gainDelay = 2;
+	vblankDelay = 2;
 }
 
-static CamHelper *Create()
+static CamHelper *create()
 {
 	return new CamHelperOv9281();
 }
 
-static RegisterCamHelper reg("ov9281", &Create);
+static RegisterCamHelper reg("ov9281", &create);