Merge ~r41k0u/ubuntu/+source/libcamera:ubuntu/devel into ubuntu/+source/libcamera:ubuntu/devel

[Pragyansh Chaturvedi]

* d/p/add_syncmode_and_tensors.patch: Add SyncMode controls
  and CNN Tensors to enable rpicam-apps (LP: #2109901)
* d/p/fix_pisp_cfe_entities.patch: Allow both old and new CFE
  entity match strings so camera modules can be detected on
  Raspberry Pi 5 using libcamera0.5 (LP: #2110144)

[Pragyansh Chaturvedi (r41k0u)]

PPA builds at:
https://launchpad.net/~r41k0u/+archive/ubuntu/plusone20250414/+build/30691603
https://launchpad.net/~r41k0u/+archive/ubuntu/plusone20250414/+build/30691604
https://launchpad.net/~r41k0u/+archive/ubuntu/plusone20250414/+build/30691605

[Pragyansh Chaturvedi (r41k0u)]

Revised PPA builds:
https://launchpad.net/~r41k0u/+archive/ubuntu/plusone20250414/+build/30697999
https://launchpad.net/~r41k0u/+archive/ubuntu/plusone20250414/+build/30698000
https://launchpad.net/~r41k0u/+archive/ubuntu/plusone20250414/+build/30698001

[Dave Jones (waveform)]

As discussed on MM, the second patch looks fine. The first patch needs a bug number (2109901 will do given that's what it's fixing), and ideally should be split so we can include a valid origin (some commit in github.com/raspberrypi/libcamera) for the bulk of it.

review: Needs Fixing

[Pragyansh Chaturvedi (r41k0u)]

Marking this merged as per https://bugs.launchpad.net/ubuntu/+source/libcamera/+bug/2110144/comments/3

diff --git a/debian/changelog b/debian/changelog
index 2fb1577..659eb45 100644
--- a/debian/changelog
+++ b/debian/changelog
@@ -1,3 +1,20 @@
+libcamera (0.5.0-1ubuntu2) questing; urgency=medium
+
+  * d/p/fix_pisp_cfe_entities.patch: Allow both old and new CFE
+    entity match strings so camera modules can be detected on
+    Raspberry Pi 5 using libcamera0.5 (LP: #2110144) 
+
+ -- Pragyansh Chaturvedi <[e-mail]>  Wed, 07 May 2025 21:15:01 +0530
+
+libcamera (0.5.0-1ubuntu1) questing; urgency=medium
+
+  * d/p/add_syncmode_and_tensors.patch: Add SyncMode controls
+    and CNN Tensors to enable rpicam-apps (LP: #2109901)
+    - This patch adds the SyncMode IPA controls and the IMX500 tesnors
+      and camera data required for rpicam-apps on the Raspberry Pi.
+
+ -- Pragyansh Chaturvedi <[e-mail]>  Tue, 06 May 2025 12:40:28 +0530
+
 libcamera (0.5.0-1) experimental; urgency=medium
 
   * New upstream version 0.5.0
diff --git a/debian/control b/debian/control
index 4c8fb9e..ba49615 100644
--- a/debian/control
+++ b/debian/control
@@ -1,5 +1,6 @@
 Source: libcamera
-Maintainer: Debian Multimedia Maintainers <[e-mail]>
+Maintainer: Ubuntu Developers <[e-mail]>
+XSBC-Original-Maintainer: Debian Multimedia Maintainers <[e-mail]>
 Uploaders: Emmanuel Arias <[e-mail]>,
            IOhannes m zmölnig (Debian/GNU) <[e-mail]>,
            Andrej Shadura <[e-mail]>,
diff --git a/debian/patches/add_syncmode_and_tensors.patch b/debian/patches/add_syncmode_and_tensors.patch
new file mode 100644
index 0000000..d5ec68a
--- /dev/null
+++ b/debian/patches/add_syncmode_and_tensors.patch
@@ -0,0 +1,15479 @@
+Description: Add SyncMode controls and CNN Tensors to enable
+ rpicam-apps and picamera2 on Raspberry Pis. This patch adds the 
+ Sync controls and the CNN tensors used on the Raspberry Pi 5 from
+ the Raspberry Pi Foundation's fork of libcamera
+ (https://github.com/raspberrypi/libcamera)
+ The camera modules on the Raspberry Pi use rpicam-apps, which
+ needs this patch in libcamera, so this patch is essential to
+ make them work.
+Author: Pragyansh Chaturvedi <[e-mail]>
+Last-Update: 2025-05-06
+---
+--- a/src/ipa/rpi/common/ipa_base.cpp	2025-05-08 00:06:16.067331148 +0530
++++ b/src/ipa/rpi/common/ipa_base.cpp	2025-05-08 00:06:16.043331520 +0530
+@@ -28,6 +28,8 @@
+ #include "controller/lux_status.h"
+ #include "controller/sharpen_algorithm.h"
+ #include "controller/statistics.h"
++#include "controller/sync_algorithm.h"
++#include "controller/sync_status.h"
+ 
+ namespace libcamera {
+ 
+@@ -84,8 +86,11 @@
+ 	{ &controls::FrameDurationLimits,
+ 	  ControlInfo(INT64_C(33333), INT64_C(120000),
+ 		      static_cast<int64_t>(defaultMinFrameDuration.get<std::micro>())) },
++	{ &controls::rpi::SyncMode, ControlInfo(controls::rpi::SyncModeValues) },
++	{ &controls::rpi::SyncFrames, ControlInfo(1, 1000000, 100) },
+ 	{ &controls::draft::NoiseReductionMode, ControlInfo(controls::draft::NoiseReductionModeValues) },
+ 	{ &controls::rpi::StatsOutputEnable, ControlInfo(false, true, false) },
++	{ &controls::rpi::CnnEnableInputTensor, ControlInfo(false, true, false) },
+ };
+ 
+ /* IPA controls handled conditionally, if the sensor is not mono */
+@@ -125,7 +130,7 @@
+ IpaBase::IpaBase()
+ 	: controller_(), frameLengths_(FrameLengthsQueueSize, 0s), statsMetadataOutput_(false),
+ 	  stitchSwapBuffers_(false), frameCount_(0), mistrustCount_(0), lastRunTimestamp_(0),
+-	  firstStart_(true), flickerState_({ 0, 0s })
++	  firstStart_(true), flickerState_({ 0, 0s }), cnnEnableInputTensor_(false)
+ {
+ }
+ 
+@@ -405,6 +410,7 @@
+ 
+ 	rpiMetadata.clear();
+ 	fillDeviceStatus(params.sensorControls, ipaContext);
++	fillSyncParams(params, ipaContext);
+ 
+ 	if (params.buffers.embedded) {
+ 		/*
+@@ -503,10 +509,24 @@
+ 		helper_->process(statistics, rpiMetadata);
+ 		controller_.process(statistics, &rpiMetadata);
+ 
++		/* Send any sync algorithm outputs back to the pipeline handler */
++		Duration offset(0s);
++		struct SyncStatus syncStatus;
++		if (rpiMetadata.get("sync.status", syncStatus) == 0) {
++			if (minFrameDuration_ != maxFrameDuration_)
++				LOG(IPARPI, Error) << "Sync algorithm enabled with variable framerate. "
++						   << minFrameDuration_ << " " << maxFrameDuration_;
++			offset = syncStatus.frameDurationOffset;
++
++			libcameraMetadata_.set(controls::rpi::SyncReady, syncStatus.ready);
++			if (syncStatus.timerKnown)
++				libcameraMetadata_.set(controls::rpi::SyncTimer, syncStatus.timerValue);
++		}
++
+ 		struct AgcStatus agcStatus;
+ 		if (rpiMetadata.get("agc.status", agcStatus) == 0) {
+ 			ControlList ctrls(sensorCtrls_);
+-			applyAGC(&agcStatus, ctrls);
++			applyAGC(&agcStatus, ctrls, offset);
+ 			setDelayedControls.emit(ctrls, ipaContext);
+ 			setCameraTimeoutValue();
+ 		}
+@@ -743,6 +763,7 @@
+ 	using RPiController::ContrastAlgorithm;
+ 	using RPiController::DenoiseAlgorithm;
+ 	using RPiController::HdrAlgorithm;
++	using RPiController::SyncAlgorithm;
+ 
+ 	/* Clear the return metadata buffer. */
+ 	libcameraMetadata_.clear();
+@@ -1334,6 +1355,39 @@
+ 			statsMetadataOutput_ = ctrl.second.get<bool>();
+ 			break;
+ 
++		case controls::rpi::CNN_ENABLE_INPUT_TENSOR:
++			cnnEnableInputTensor_ = ctrl.second.get<bool>();
++			break;
++
++		case controls::rpi::SYNC_MODE: {
++			SyncAlgorithm *sync = dynamic_cast<SyncAlgorithm *>(controller_.getAlgorithm("sync"));
++
++			if (sync) {
++				int mode = ctrl.second.get<int32_t>();
++				SyncAlgorithm::Mode m = SyncAlgorithm::Mode::Off;
++				if (mode == controls::rpi::SyncModeServer) {
++					m = SyncAlgorithm::Mode::Server;
++					LOG(IPARPI, Info) << "Sync mode set to server";
++				} else if (mode == controls::rpi::SyncModeClient) {
++					m = SyncAlgorithm::Mode::Client;
++					LOG(IPARPI, Info) << "Sync mode set to client";
++				}
++				sync->setMode(m);
++			}
++			break;
++		}
++
++		case controls::rpi::SYNC_FRAMES: {
++			SyncAlgorithm *sync = dynamic_cast<SyncAlgorithm *>(controller_.getAlgorithm("sync"));
++
++			if (sync) {
++				int frames = ctrl.second.get<int32_t>();
++				if (frames > 0)
++					sync->setReadyFrame(frames);
++			}
++			break;
++		}
++
+ 		default:
+ 			LOG(IPARPI, Warning)
+ 				<< "Ctrl " << controls::controls.at(ctrl.first)->name()
+@@ -1370,6 +1424,19 @@
+ 	rpiMetadata_[ipaContext].set("device.status", deviceStatus);
+ }
+ 
++void IpaBase::fillSyncParams(const PrepareParams &params, unsigned int ipaContext)
++{
++	RPiController::SyncAlgorithm *sync = dynamic_cast<RPiController::SyncAlgorithm *>(
++		controller_.getAlgorithm("sync"));
++	if (!sync)
++		return;
++
++	SyncParams syncParams;
++	syncParams.wallClock = *params.sensorControls.get(controls::FrameWallClock);
++	syncParams.sensorTimestamp = *params.sensorControls.get(controls::SensorTimestamp);
++	rpiMetadata_[ipaContext].set("sync.params", syncParams);
++}
++
+ void IpaBase::reportMetadata(unsigned int ipaContext)
+ {
+ 	RPiController::Metadata &rpiMetadata = rpiMetadata_[ipaContext];
+@@ -1520,6 +1587,51 @@
+ 			libcameraMetadata_.set(controls::HdrChannel, controls::HdrChannelNone);
+ 	}
+ 
++	const std::shared_ptr<uint8_t[]> *inputTensor =
++		rpiMetadata.getLocked<std::shared_ptr<uint8_t[]>>("cnn.input_tensor");
++	if (cnnEnableInputTensor_ && inputTensor) {
++		unsigned int size = *rpiMetadata.getLocked<unsigned int>("cnn.input_tensor_size");
++		Span<const uint8_t> tensor{ inputTensor->get(), size };
++		libcameraMetadata_.set(controls::rpi::CnnInputTensor, tensor);
++		/* No need to keep these big buffers anymore  */
++		rpiMetadata.eraseLocked("cnn.input_tensor");
++	}
++
++	const RPiController::CnnInputTensorInfo *inputTensorInfo =
++		rpiMetadata.getLocked<RPiController::CnnInputTensorInfo>("cnn.input_tensor_info");
++	if (inputTensorInfo) {
++		Span<const uint8_t> tensorInfo{ reinterpret_cast<const uint8_t *>(inputTensorInfo),
++						sizeof(*inputTensorInfo) };
++		libcameraMetadata_.set(controls::rpi::CnnInputTensorInfo, tensorInfo);
++	}
++
++	const std::shared_ptr<float[]> *outputTensor =
++		rpiMetadata.getLocked<std::shared_ptr<float[]>>("cnn.output_tensor");
++	if (outputTensor) {
++		unsigned int size = *rpiMetadata.getLocked<unsigned int>("cnn.output_tensor_size");
++		Span<const float> tensor{ reinterpret_cast<const float *>(outputTensor->get()),
++					  size };
++		libcameraMetadata_.set(controls::rpi::CnnOutputTensor, tensor);
++		/* No need to keep these big buffers anymore  */
++		rpiMetadata.eraseLocked("cnn.output_tensor");
++	}
++
++	const RPiController::CnnOutputTensorInfo *outputTensorInfo =
++		rpiMetadata.getLocked<RPiController::CnnOutputTensorInfo>("cnn.output_tensor_info");
++	if (outputTensorInfo) {
++		Span<const uint8_t> tensorInfo{ reinterpret_cast<const uint8_t *>(outputTensorInfo),
++						sizeof(*outputTensorInfo) };
++		libcameraMetadata_.set(controls::rpi::CnnOutputTensorInfo, tensorInfo);
++	}
++
++	const RPiController::CnnKpiInfo *kpiInfo =
++		rpiMetadata.getLocked<RPiController::CnnKpiInfo>("cnn.kpi_info");
++	if (kpiInfo) {
++		libcameraMetadata_.set(controls::rpi::CnnKpiInfo,
++				       { static_cast<int32_t>(kpiInfo->dnnRuntime),
++					 static_cast<int32_t>(kpiInfo->dspRuntime) });
++	}
++
+ 	metadataReady.emit(libcameraMetadata_);
+ }
+ 
+@@ -1548,14 +1660,22 @@
+ 	 * value possible.
+ 	 */
+ 	Duration maxExposureTime = Duration::max();
+-	helper_->getBlanking(maxExposureTime, minFrameDuration_, maxFrameDuration_);
++	auto [vblank, hblank] = helper_->getBlanking(maxExposureTime, minFrameDuration_, maxFrameDuration_);
+ 
+ 	RPiController::AgcAlgorithm *agc = dynamic_cast<RPiController::AgcAlgorithm *>(
+ 		controller_.getAlgorithm("agc"));
+ 	agc->setMaxExposureTime(maxExposureTime);
++
++	RPiController::SyncAlgorithm *sync = dynamic_cast<RPiController::SyncAlgorithm *>(
++		controller_.getAlgorithm("sync"));
++	if (sync) {
++		Duration duration = (mode_.height + vblank) * ((mode_.width + hblank) * 1.0s / mode_.pixelRate);
++		LOG(IPARPI, Debug) << "setting sync frame duration to  " << duration;
++		sync->setFrameDuration(duration);
++	}
+ }
+ 
+-void IpaBase::applyAGC(const struct AgcStatus *agcStatus, ControlList &ctrls)
++void IpaBase::applyAGC(const struct AgcStatus *agcStatus, ControlList &ctrls, Duration frameDurationOffset)
+ {
+ 	const int32_t minGainCode = helper_->gainCode(mode_.minAnalogueGain);
+ 	const int32_t maxGainCode = helper_->gainCode(mode_.maxAnalogueGain);
+@@ -1570,7 +1690,8 @@
+ 
+ 	/* getBlanking might clip exposure time to the fps limits. */
+ 	Duration exposure = agcStatus->exposureTime;
+-	auto [vblank, hblank] = helper_->getBlanking(exposure, minFrameDuration_, maxFrameDuration_);
++	auto [vblank, hblank] = helper_->getBlanking(exposure, minFrameDuration_ - frameDurationOffset,
++						       maxFrameDuration_ - frameDurationOffset);
+ 	int32_t exposureLines = helper_->exposureLines(exposure,
+ 						       helper_->hblankToLineLength(hblank));
+ 
+--- a/src/ipa/rpi/pisp/data/imx219.json	2025-05-08 00:06:16.067331148 +0530
++++ b/src/ipa/rpi/pisp/data/imx219.json	2025-05-08 00:06:16.044331505 +0530
+@@ -1182,6 +1182,11 @@
+                     ]
+                 }
+             }
++        },
++        {
++            "rpi.sync":
++            {
++            }
+         }
+     ]
+ }
+\ No newline at end of file
+--- a/src/ipa/rpi/pisp/data/imx219_noir.json	2025-05-08 00:06:16.067331148 +0530
++++ b/src/ipa/rpi/pisp/data/imx219_noir.json	2025-05-08 00:06:16.045331489 +0530
+@@ -1107,6 +1107,11 @@
+                     ]
+                 }
+             }
++        },
++        {
++            "rpi.sync":
++            {
++            }
+         }
+     ]
+ }
+\ No newline at end of file
+--- a/src/ipa/rpi/pisp/data/meson.build	2025-05-08 00:06:16.067331148 +0530
++++ b/src/ipa/rpi/pisp/data/meson.build	2025-05-08 00:06:16.045331489 +0530
+@@ -12,6 +12,7 @@
+     'imx477.json',
+     'imx477_noir.json',
+     'imx477_scientific.json',
++    'imx500.json',
+     'imx519.json',
+     'imx708.json',
+     'imx708_noir.json',
+--- a/src/libcamera/control_ids_rpi.yaml	2025-05-08 00:06:16.067331148 +0530
++++ b/src/libcamera/control_ids_rpi.yaml	2025-05-08 00:06:16.046331474 +0530
+@@ -71,4 +71,230 @@
+ 
+         \sa StatsOutputEnable
+ 
++  - CnnOutputTensor:
++      type: float
++      size: [n]
++      direction: out
++      description: |
++        This control returns a span of floating point values that represent the
++        output tensors from a Convolutional Neural Network (CNN). The size and
++        format of this array of values is entirely dependent on the neural
++        network used, and further post-processing may need to be performed at
++        the application level to generate the final desired output. This control
++        is agnostic of the hardware or software used to generate the output
++        tensors.
++
++        The structure of the span is described by the CnnOutputTensorInfo
++        control.
++
++        \sa CnnOutputTensorInfo
++
++  - CnnOutputTensorInfo:
++      type: uint8_t
++      size: [n]
++      direction: out
++      description: |
++        This control returns the structure of the CnnOutputTensor. This structure
++        takes the following form:
++
++        constexpr unsigned int NetworkNameLen = 64;
++        constexpr unsigned int MaxNumTensors = 8;
++        constexpr unsigned int MaxNumDimensions = 8;
++
++        struct CnnOutputTensorInfo {
++          char networkName[NetworkNameLen];
++          uint32_t numTensors;
++          OutputTensorInfo info[MaxNumTensors];
++        };
++
++        with
++
++        struct OutputTensorInfo {
++          uint32_t tensorDataNum;
++          uint32_t numDimensions;
++          uint16_t size[MaxNumDimensions];
++        };
++
++        networkName is the name of the CNN used,
++        numTensors is the number of output tensors returned,
++        tensorDataNum gives the number of elements in each output tensor,
++        numDimensions gives the dimensionality of each output tensor,
++        size gives the size of each dimension in each output tensor.
++
++        \sa CnnOutputTensor
++
++  - CnnEnableInputTensor:
++      type: bool
++      direction: in
++      description: |
++        Boolean to control if the IPA returns the input tensor used by the CNN
++        to generate the output tensors via the CnnInputTensor control. Because
++        the input tensor may be relatively large, for efficiency reason avoid
++        enabling input tensor output unless required for debugging purposes.
++
++        \sa CnnInputTensor
++
++  - CnnInputTensor:
++      type: uint8_t
++      size: [n]
++      direction: out
++      description: |
++        This control returns a span of uint8_t pixel values that represent the
++        input tensor for a Convolutional Neural Network (CNN). The size and
++        format of this array of values is entirely dependent on the neural
++        network used, and further post-processing (e.g. pixel normalisations) may
++        need to be performed at the application level to generate the final input
++        image.
++
++        The structure of the span is described by the CnnInputTensorInfo
++        control.
++
++        \sa CnnInputTensorInfo
++
++  - CnnInputTensorInfo:
++      type: uint8_t
++      size: [n]
++      direction: out
++      description: |
++        This control returns the structure of the CnnInputTensor. This structure
++        takes the following form:
++
++        constexpr unsigned int NetworkNameLen = 64;
++
++        struct CnnInputTensorInfo {
++          char networkName[NetworkNameLen];
++          uint32_t width;
++          uint32_t height;
++          uint32_t numChannels;
++        };
++
++        where
++
++        networkName is the name of the CNN used,
++        width and height are the input tensor image width and height in pixels,
++        numChannels is the number of channels in the input tensor image.
++
++        \sa CnnInputTensor
++
++  - CnnKpiInfo:
++      type: int32_t
++      size: [2]
++      direction: out
++      description: |
++        This control returns performance metrics for the CNN processing stage.
++        Two values are returned in this span, the runtime of the CNN/DNN stage
++        and the DSP stage in milliseconds.
++
++  - SyncMode:
++      type: int32_t
++      direction: in
++      description: |
++        Enable or disable camera synchronisation ("sync") mode.
++
++        When sync mode is enabled, a camera will synchronise frames temporally
++        with other cameras, either attached to the same device or a different
++        one. There should be one "server" device, which broadcasts timing
++        information to one or more "clients". Communication is one-way, from
++        server to clients only, and it is only clients that adjust their frame
++        timings to match the server.
++
++        Sync mode requires all cameras to be running at (as far as possible) the
++        same fixed framerate. Clients may continue to make adjustments to keep
++        their cameras synchronised with the server for the duration of the
++        session, though any updates after the initial ones should remain small.
++
++        \sa SyncReady
++        \sa SyncTimer
++        \sa SyncFrames
++
++      enum:
++        - name: SyncModeOff
++          value: 0
++          description: Disable sync mode.
++        - name: SyncModeServer
++          value: 1
++          description: |
++            Enable sync mode, act as server. The server broadcasts timing
++            messages to any clients that are listening, so that the clients can
++            synchronise their camera frames with the server's.
++        - name: SyncModeClient
++          value: 2
++          description: |
++            Enable sync mode, act as client. A client listens for any server
++            messages, and arranges for its camera frames to synchronise as
++            closely as possible with the server's. Many clients can listen out
++            for the same server. Clients can also be started ahead of any
++            servers, causing them merely to wait for the server to start.
++
++  - SyncReady:
++      type: bool
++      direction: out
++      description: |
++        When using the camera synchronisation algorithm, the server broadcasts
++        timing information to the clients. This also includes the time (some
++        number of frames in the future, called the "ready time") at which the
++        server will signal its controlling application, using this control, to
++        start using the image frames.
++
++        The client receives the "ready time" from the server, and will signal
++        its application to start using the frames at this same moment.
++
++        While this control value is false, applications (on both client and
++        server) should continue to wait, and not use the frames.
++
++        Once this value becomes true, it means that this is the first frame
++        where the server and its clients have agreed that they will both be
++        synchronised and that applications should begin consuming frames.
++        Thereafter, this control will continue to signal the value true for
++        the rest of the session.
++
++        \sa SyncMode
++        \sa SyncTimer
++        \sa SyncFrames
++
++  - SyncTimer:
++      type: int64_t
++      direction: out
++      description: |
++        This reports the amount of time, in microseconds, until the "ready
++        time", at which the server and client will signal their controlling
++        applications that the frames are now synchronised and should be
++        used. The value may be refined slightly over time, becoming more precise
++        as the "ready time" approaches.
++
++        Servers always report this value, whereas clients will omit this control
++        until they have received a message from the server that enables them to
++        calculate it.
++
++        Normally the value will start positive (the "ready time" is in the
++        future), and decrease towards zero, before becoming negative (the "ready
++        time" has elapsed). So there should be just one frame where the timer
++        value is, or is very close to, zero - the one for which the SyncReady
++        control becomes true. At this moment, the value indicates how closely
++        synchronised the client believes it is with the server.
++
++        But note that if frames are being dropped, then the "near zero" valued
++        frame, or indeed any other, could be skipped. In these cases the timer
++        value allows an application to deduce that this has happened.
++
++        \sa SyncMode
++        \sa SyncReady
++        \sa SyncFrames
++
++  - SyncFrames:
++      type: int32_t
++      direction: in
++      description: |
++        The number of frames the server should wait, after enabling
++        SyncModeServer, before signalling (via the SyncReady control) that
++        frames should be used. This therefore determines the "ready time" for
++        all synchronised cameras.
++
++        This control value should be set only for the device that is to act as
++        the server, before or at the same moment at which SyncModeServer is
++        enabled.
++
++        \sa SyncMode
++        \sa SyncReady
++        \sa SyncTimer
+ ...
+--- a/src/libcamera/pipeline/rpi/vc4/data/meson.build	2025-05-08 00:06:16.067331148 +0530
++++ b/src/libcamera/pipeline/rpi/vc4/data/meson.build	2025-05-08 00:06:16.047331458 +0530
+@@ -2,6 +2,7 @@
+ 
+ conf_files = files([
+     'example.yaml',
++    'rpi_apps.yaml',
+ ])
+ 
+ install_data(conf_files,
+--- /dev/null	1970-01-01 00:00:00.000000000 +0000
++++ b/src/libcamera/pipeline/rpi/vc4/data/rpi_apps.yaml	2025-05-08 00:06:16.047331458 +0530
+@@ -0,0 +1,45 @@
++{
++        "version": 1.0,
++        "target": "bcm2835",
++
++        "pipeline_handler":
++        {
++                # The minimum number of internal buffers to be allocated for
++                # Unicam. This value must be greater than 0, but less than or
++                # equal to min_total_unicam_buffers.
++                #
++                # A larger number of internal buffers can reduce the occurrence
++                # of frame drops during high CPU loads, but might also cause
++                # additional latency in the system.
++                #
++                # Note that the pipeline handler might override this value and
++                # not allocate any internal buffers if it knows they will never
++                # be used. For example if the RAW stream is marked as mandatory
++                # and there are no dropped frames signalled for algorithm
++                # convergence.
++                #
++                "min_unicam_buffers": 2,
++
++                # The minimum total (internal + external) buffer count used for
++                # Unicam. The number of internal buffers allocated for Unicam is
++                # given by:
++                #
++                # internal buffer count = max(min_unicam_buffers,
++                #         min_total_unicam_buffers - external buffer count)
++                #
++                "min_total_unicam_buffers": 4,
++
++                # Override any request from the IPA to drop a number of startup
++                # frames.
++                #
++                # "disable_startup_frame_drops": false,
++
++                # The application will always provide a request buffer for the
++                # RAW stream, if it has been configured.
++                "raw_mandatory_stream": true,
++
++                # The application will always provide a request buffer for the
++                # Output 0 stream, if it has been configured.
++                "output0_mandatory_stream": true,
++        }
++}
+--- a/src/libcamera/pipeline/rpi/vc4/vc4.cpp	2025-05-08 00:06:16.067331148 +0530
++++ b/src/libcamera/pipeline/rpi/vc4/vc4.cpp	2025-05-08 00:06:16.048331443 +0530
+@@ -104,6 +104,16 @@
+ 		 * minTotalUnicamBuffers >= minUnicamBuffers
+ 		 */
+ 		unsigned int minTotalUnicamBuffers;
++		/*
++		 * The application will always provide a request buffer for the
++		 * RAW stream, if it has been configured.
++		 */
++		bool rawMandatoryStream;
++		/*
++		 * The application will always provide a request buffer for the
++		 * Output 0 stream, if it has been configured.
++		 */
++		bool output0MandatoryStream;
+ 	};
+ 
+ 	Config config_;
+@@ -219,16 +229,47 @@
+ int PipelineHandlerVc4::prepareBuffers(Camera *camera)
+ {
+ 	Vc4CameraData *data = cameraData(camera);
+-	unsigned int numRawBuffers = 0;
++	unsigned int minUnicamBuffers = data->config_.minUnicamBuffers;
++	unsigned int minTotalUnicamBuffers = data->config_.minTotalUnicamBuffers;
++	unsigned int numRawBuffers = 0, minIspBuffers = 1;
+ 	int ret;
+ 
+-	for (Stream *s : camera->streams()) {
+-		if (BayerFormat::fromPixelFormat(s->configuration().pixelFormat).isValid()) {
+-			numRawBuffers = s->configuration().bufferCount;
+-			break;
++	if (data->unicam_[Unicam::Image].getFlags() & StreamFlag::External) {
++		numRawBuffers = data->unicam_[Unicam::Image].getBuffers().size();
++		/*
++		 * If the application provides a guarantees that Unicam
++		 * image buffers will always be provided for the RAW stream
++		 * in a Request, we need:
++		 * - at least 1 internal Unicam buffer to handle startup frame drops,
++		 * - no internal Unicam buffers if there are no startup frame drops.
++		 */
++		if (data->config_.rawMandatoryStream) {
++			if (data->dropFrameCount_) {
++				minUnicamBuffers = 2;
++				minTotalUnicamBuffers = 2;
++			} else {
++				minUnicamBuffers = 0;
++				minTotalUnicamBuffers = 0;
++			}
+ 		}
+ 	}
+ 
++	if (data->isp_[Isp::Output0].getFlags() & StreamFlag::External) {
++		/*
++		 * Since the ISP runs synchronous with the IPA and requests,
++		 * we only ever need a maximum of one internal buffer. Any
++		 * buffers the application wants to hold onto will already
++		 * be exported through PipelineHandlerRPi::exportFrameBuffers().
++		 *
++		 * However, as above, if the application provides a guarantee
++		 * that the buffer will always be provided for the ISP Output0
++		 * stream in a Request, we don't need any internal buffers
++		 * allocated.
++		 */
++		if (!data->dropFrameCount_ && data->config_.output0MandatoryStream)
++			minIspBuffers = 0;
++	}
++
+ 	/* Decide how many internal buffers to allocate. */
+ 	for (auto const stream : data->streams_) {
+ 		unsigned int numBuffers;
+@@ -236,7 +277,6 @@
+ 		 * For Unicam, allocate a minimum number of buffers for internal
+ 		 * use as we want to avoid any frame drops.
+ 		 */
+-		const unsigned int minBuffers = data->config_.minTotalUnicamBuffers;
+ 		if (stream == &data->unicam_[Unicam::Image]) {
+ 			/*
+ 			 * If an application has configured a RAW stream, allocate
+@@ -244,8 +284,9 @@
+ 			 * we have at least minUnicamBuffers of internal buffers
+ 			 * to use to minimise frame drops.
+ 			 */
+-			numBuffers = std::max<int>(data->config_.minUnicamBuffers,
+-						   minBuffers - numRawBuffers);
++			numBuffers = std::max<int>(minUnicamBuffers,
++						   minTotalUnicamBuffers - numRawBuffers);
++			LOG(RPI, Debug) << "Unicam::Image numBuffers " << numBuffers;
+ 		} else if (stream == &data->isp_[Isp::Input]) {
+ 			/*
+ 			 * ISP input buffers are imported from Unicam, so follow
+@@ -253,8 +294,9 @@
+ 			 * available.
+ 			 */
+ 			numBuffers = numRawBuffers +
+-				     std::max<int>(data->config_.minUnicamBuffers,
+-						   minBuffers - numRawBuffers);
++				     std::max<int>(minUnicamBuffers,
++						   minTotalUnicamBuffers - numRawBuffers);
++			LOG(RPI, Debug) << "Isp::Input numBuffers " << numBuffers;
+ 
+ 		} else if (stream == &data->unicam_[Unicam::Embedded]) {
+ 			/*
+@@ -273,14 +315,18 @@
+ 			 * buffers, as these will be recycled quicker.
+ 			 */
+ 			numBuffers = 12;
++		} else if (stream == &data->isp_[Isp::Output0]) {
++			/* Buffer count for this is handled in the earlier loop above. */
++			numBuffers = minIspBuffers;
++			LOG(RPI, Debug) << "Isp::Output0 numBuffers " << numBuffers;
+ 		} else {
+ 			/*
+-			 * Since the ISP runs synchronous with the IPA and requests,
+-			 * we only ever need one set of internal buffers. Any buffers
+-			 * the application wants to hold onto will already be exported
+-			 * through PipelineHandlerRPi::exportFrameBuffers().
++			 * Same reasoning as for ISP Output 0, we only ever need
++			 * a maximum of one internal buffer for Output1 (required
++			 * for colour denoise) and ISP statistics.
+ 			 */
+ 			numBuffers = 1;
++			LOG(RPI, Debug) << "Other numBuffers " << numBuffers;
+ 		}
+ 
+ 		LOG(RPI, Debug) << "Preparing " << numBuffers
+@@ -498,6 +544,8 @@
+ 	config_ = {
+ 		.minUnicamBuffers = 2,
+ 		.minTotalUnicamBuffers = 4,
++		.rawMandatoryStream = false,
++		.output0MandatoryStream = false,
+ 	};
+ 
+ 	if (!root)
+@@ -521,6 +569,10 @@
+ 		phConfig["min_unicam_buffers"].get<unsigned int>(config_.minUnicamBuffers);
+ 	config_.minTotalUnicamBuffers =
+ 		phConfig["min_total_unicam_buffers"].get<unsigned int>(config_.minTotalUnicamBuffers);
++	config_.rawMandatoryStream =
++		phConfig["raw_mandatory_stream"].get<bool>(config_.rawMandatoryStream);
++	config_.output0MandatoryStream =
++		phConfig["output0_mandatory_stream"].get<bool>(config_.output0MandatoryStream);
+ 
+ 	if (config_.minTotalUnicamBuffers < config_.minUnicamBuffers) {
+ 		LOG(RPI, Error) << "Invalid configuration: min_total_unicam_buffers must be >= min_unicam_buffers";
+@@ -781,9 +833,15 @@
+ 		auto [ctrl, delayContext] = delayedCtrls_->get(buffer->metadata().sequence);
+ 		/*
+ 		 * Add the frame timestamp to the ControlList for the IPA to use
+-		 * as it does not receive the FrameBuffer object.
++		 * as it does not receive the FrameBuffer object. Also derive a
++		 * corresponding wallclock value.
+ 		 */
+-		ctrl.set(controls::SensorTimestamp, buffer->metadata().timestamp);
++		wallClockRecovery_.addSample();
++		uint64_t sensorTimestamp = buffer->metadata().timestamp;
++		uint64_t wallClockTimestamp = wallClockRecovery_.getOutput(sensorTimestamp / 1000);
++
++		ctrl.set(controls::SensorTimestamp, sensorTimestamp);
++		ctrl.set(controls::FrameWallClock, wallClockTimestamp);
+ 		bayerQueue_.push({ buffer, std::move(ctrl), delayContext });
+ 	} else {
+ 		embeddedQueue_.push(buffer);
+--- a/src/libcamera/v4l2_videodevice.cpp	2025-05-08 00:06:16.067331148 +0530
++++ b/src/libcamera/v4l2_videodevice.cpp	2025-05-08 00:06:16.048331443 +0530
+@@ -1625,7 +1625,7 @@
+ }
+ 
+ /**
+- * \brief Queue a buffer to the video device
++ * \brief Queue a buffer to the video device if possible
+  * \param[in] buffer The buffer to be queued
+  *
+  * For capture video devices the \a buffer will be filled with data by the
+@@ -1639,14 +1639,14 @@
+  * Note that queueBuffer() will fail if the device is in the process of being
+  * stopped from a streaming state through streamOff().
+  *
++ * V4L2 only allows upto VIDEO_MAX_FRAME frames to be queued at a time, so if
++ * we reach this limit, store the framebuffers in a pending queue, and try to
++ * enqueue once a buffer has been dequeued.
++ *
+  * \return 0 on success or a negative error code otherwise
+  */
+ int V4L2VideoDevice::queueBuffer(FrameBuffer *buffer)
+ {
+-	struct v4l2_plane v4l2Planes[VIDEO_MAX_PLANES] = {};
+-	struct v4l2_buffer buf = {};
+-	int ret;
+-
+ 	if (state_ == State::Stopping) {
+ 		LOG(V4L2, Error) << "Device is in a stopping state.";
+ 		return -ESHUTDOWN;
+@@ -1662,133 +1662,25 @@
+ 		return -ENOENT;
+ 	}
+ 
+-	ret = cache_->get(*buffer);
+-	if (ret < 0)
+-		return ret;
+-
+-	buf.index = ret;
+-	buf.type = bufferType_;
+-	buf.memory = memoryType_;
+-	buf.field = V4L2_FIELD_NONE;
+-
+-	bool multiPlanar = V4L2_TYPE_IS_MULTIPLANAR(buf.type);
+-	const std::vector<FrameBuffer::Plane> &planes = buffer->planes();
+-	const unsigned int numV4l2Planes = format_.planesCount;
+-
+-	/*
+-	 * Ensure that the frame buffer has enough planes, and that they're
+-	 * contiguous if the V4L2 format requires them to be.
+-	 */
+-	if (planes.size() < numV4l2Planes) {
+-		LOG(V4L2, Error) << "Frame buffer has too few planes";
+-		return -EINVAL;
+-	}
+-
+-	if (planes.size() != numV4l2Planes && !buffer->_d()->isContiguous()) {
+-		LOG(V4L2, Error) << "Device format requires contiguous buffer";
+-		return -EINVAL;
+-	}
+-
+-	if (buf.memory == V4L2_MEMORY_DMABUF) {
+-		if (multiPlanar) {
+-			for (unsigned int p = 0; p < numV4l2Planes; ++p)
+-				v4l2Planes[p].m.fd = planes[p].fd.get();
+-		} else {
+-			buf.m.fd = planes[0].fd.get();
+-		}
+-	}
+-
+-	if (multiPlanar) {
+-		buf.length = numV4l2Planes;
+-		buf.m.planes = v4l2Planes;
+-	}
+-
+-	if (V4L2_TYPE_IS_OUTPUT(buf.type)) {
+-		const FrameMetadata &metadata = buffer->metadata();
+-
+-		for (const auto &plane : metadata.planes()) {
+-			if (!plane.bytesused)
+-				LOG(V4L2, Warning) << "byteused == 0 is deprecated";
+-		}
+-
+-		if (numV4l2Planes != planes.size()) {
+-			/*
+-			 * If we have a multi-planar buffer with a V4L2
+-			 * single-planar format, coalesce all planes. The length
+-			 * and number of bytes used may only differ in the last
+-			 * plane as any other situation can't be represented.
+-			 */
+-			unsigned int bytesused = 0;
+-			unsigned int length = 0;
+-
+-			for (auto [i, plane] : utils::enumerate(planes)) {
+-				bytesused += metadata.planes()[i].bytesused;
+-				length += plane.length;
+-
+-				if (i != planes.size() - 1 && bytesused != length) {
+-					LOG(V4L2, Error)
+-						<< "Holes in multi-planar buffer not supported";
+-					return -EINVAL;
+-				}
+-			}
+-
+-			if (multiPlanar) {
+-				v4l2Planes[0].bytesused = bytesused;
+-				v4l2Planes[0].length = length;
+-			} else {
+-				buf.bytesused = bytesused;
+-				buf.length = length;
+-			}
+-		} else if (multiPlanar) {
+-			/*
+-			 * If we use the multi-planar API, fill in the planes.
+-			 * The number of planes in the frame buffer and in the
+-			 * V4L2 buffer is guaranteed to be equal at this point.
+-			 */
+-			for (auto [i, plane] : utils::enumerate(planes)) {
+-				v4l2Planes[i].bytesused = metadata.planes()[i].bytesused;
+-				v4l2Planes[i].length = plane.length;
+-			}
+-		} else {
+-			/*
+-			 * Single-planar API with a single plane in the buffer
+-			 * is trivial to handle.
+-			 */
+-			buf.bytesused = metadata.planes()[0].bytesused;
+-			buf.length = planes[0].length;
+-		}
++	if (queuedBuffers_.size() == VIDEO_MAX_FRAME) {
++		LOG(V4L2, Debug) << "V4L2 queue has " << VIDEO_MAX_FRAME
++				 << " already queued, differing queueing.";
+ 
+-		/*
+-		 * Timestamps are to be supplied if the device is a mem-to-mem
+-		 * device. The drivers will have V4L2_BUF_FLAG_TIMESTAMP_COPY
+-		 * set hence these timestamps will be copied from the output
+-		 * buffers to capture buffers. If the device is not mem-to-mem,
+-		 * there is no harm in setting the timestamps as they will be
+-		 * ignored (and over-written).
+-		 */
+-		buf.timestamp.tv_sec = metadata.timestamp / 1000000000;
+-		buf.timestamp.tv_usec = (metadata.timestamp / 1000) % 1000000;
++		pendingBuffersToQueue_.push(buffer);
++		return 0;
+ 	}
+ 
+-	LOG(V4L2, Debug) << "Queueing buffer " << buf.index;
+-
+-	ret = ioctl(VIDIOC_QBUF, &buf);
+-	if (ret < 0) {
+-		LOG(V4L2, Error)
+-			<< "Failed to queue buffer " << buf.index << ": "
+-			<< strerror(-ret);
+-		return ret;
+-	}
++	if (!pendingBuffersToQueue_.empty()) {
++		LOG(V4L2, Debug) << "Adding buffer " << buffer
++				 << " to the pending queue and replacing with "
++				 << pendingBuffersToQueue_.front();
+ 
+-	if (queuedBuffers_.empty()) {
+-		fdBufferNotifier_->setEnabled(true);
+-		if (watchdogDuration_)
+-			watchdog_.start(std::chrono::duration_cast<std::chrono::milliseconds>(watchdogDuration_));
++		pendingBuffersToQueue_.push(buffer);
++		buffer = pendingBuffersToQueue_.front();
++		pendingBuffersToQueue_.pop();
+ 	}
+ 
+-	queuedBuffers_[buf.index] = buffer;
+-
+-	return 0;
++	return queueToDevice(buffer);
+ }
+ 
+ /**
+@@ -1816,6 +1708,11 @@
+  * This function dequeues the next available buffer from the device. If no
+  * buffer is available to be dequeued it will return nullptr immediately.
+  *
++ * Once a buffer is dequeued from the device, this function may also enqueue
++ * a buffer that has been placed in the pending queue (due to reaching the V4L2
++ * queue size limit. Note that if this enqueue fails, we log the error, but
++ * continue running this function to completion.
++ *
+  * \return A pointer to the dequeued buffer on success, or nullptr otherwise
+  */
+ FrameBuffer *V4L2VideoDevice::dequeueBuffer()
+@@ -1868,6 +1765,20 @@
+ 	FrameBuffer *buffer = it->second;
+ 	queuedBuffers_.erase(it);
+ 
++	if (!pendingBuffersToQueue_.empty()) {
++		FrameBuffer *pending = pendingBuffersToQueue_.front();
++
++		pendingBuffersToQueue_.pop();
++		/*
++		 * If the pending buffer enqueue fails, we must continue this
++		 * function to completion for the dequeue operation.
++		 */
++		if (queueToDevice(pending))
++			LOG(V4L2, Error)
++				<< "Failed to re-queue pending buffer "
++				<< pending;
++	}
++
+ 	if (queuedBuffers_.empty()) {
+ 		fdBufferNotifier_->setEnabled(false);
+ 		watchdog_.stop();
+@@ -1967,6 +1878,168 @@
+ }
+ 
+ /**
++ * \brief Queue a buffer to the video device if possible
++ * \param[in] buffer The buffer to be queued
++ *
++ * For capture video devices the \a buffer will be filled with data by the
++ * device. For output video devices the \a buffer shall contain valid data and
++ * will be processed by the device. Once the device has finished processing the
++ * buffer, it will be available for dequeue.
++ *
++ * The best available V4L2 buffer is picked for \a buffer using the V4L2 buffer
++ * cache.
++ *
++ * Note that queueToDevice() will fail if the device is in the process of being
++ * stopped from a streaming state through streamOff().
++ *
++ * \return 0 on success or a negative error code otherwise
++ */
++int V4L2VideoDevice::queueToDevice(FrameBuffer *buffer)
++{
++	struct v4l2_plane v4l2Planes[VIDEO_MAX_PLANES] = {};
++	struct v4l2_buffer buf = {};
++	int ret;
++
++	/*
++	 * Pipeline handlers should not requeue buffers after releasing the
++	 * buffers on the device. Any occurence of this error should be fixed
++	 * in the pipeline handler directly.
++	 */
++	if (!cache_) {
++		LOG(V4L2, Fatal) << "No BufferCache available to queue.";
++		return -ENOENT;
++	}
++
++	ret = cache_->get(*buffer);
++	if (ret < 0)
++		return ret;
++
++	buf.index = ret;
++	buf.type = bufferType_;
++	buf.memory = memoryType_;
++	buf.field = V4L2_FIELD_NONE;
++
++	bool multiPlanar = V4L2_TYPE_IS_MULTIPLANAR(buf.type);
++	const std::vector<FrameBuffer::Plane> &planes = buffer->planes();
++	const unsigned int numV4l2Planes = format_.planesCount;
++
++	/*
++	 * Ensure that the frame buffer has enough planes, and that they're
++	 * contiguous if the V4L2 format requires them to be.
++	 */
++	if (planes.size() < numV4l2Planes) {
++		LOG(V4L2, Error) << "Frame buffer has too few planes";
++		return -EINVAL;
++	}
++
++	if (planes.size() != numV4l2Planes && !buffer->_d()->isContiguous()) {
++		LOG(V4L2, Error) << "Device format requires contiguous buffer";
++		return -EINVAL;
++	}
++
++	if (buf.memory == V4L2_MEMORY_DMABUF) {
++		if (multiPlanar) {
++			for (unsigned int p = 0; p < numV4l2Planes; ++p)
++				v4l2Planes[p].m.fd = planes[p].fd.get();
++		} else {
++			buf.m.fd = planes[0].fd.get();
++		}
++	}
++
++	if (multiPlanar) {
++		buf.length = numV4l2Planes;
++		buf.m.planes = v4l2Planes;
++	}
++
++	if (V4L2_TYPE_IS_OUTPUT(buf.type)) {
++		const FrameMetadata &metadata = buffer->metadata();
++
++		for (const auto &plane : metadata.planes()) {
++			if (!plane.bytesused)
++				LOG(V4L2, Warning) << "byteused == 0 is deprecated";
++		}
++
++		if (numV4l2Planes != planes.size()) {
++			/*
++			 * If we have a multi-planar buffer with a V4L2
++			 * single-planar format, coalesce all planes. The length
++			 * and number of bytes used may only differ in the last
++			 * plane as any other situation can't be represented.
++			 */
++			unsigned int bytesused = 0;
++			unsigned int length = 0;
++
++			for (auto [i, plane] : utils::enumerate(planes)) {
++				bytesused += metadata.planes()[i].bytesused;
++				length += plane.length;
++
++				if (i != planes.size() - 1 && bytesused != length) {
++					LOG(V4L2, Error)
++						<< "Holes in multi-planar buffer not supported";
++					return -EINVAL;
++				}
++			}
++
++			if (multiPlanar) {
++				v4l2Planes[0].bytesused = bytesused;
++				v4l2Planes[0].length = length;
++			} else {
++				buf.bytesused = bytesused;
++				buf.length = length;
++			}
++		} else if (multiPlanar) {
++			/*
++			 * If we use the multi-planar API, fill in the planes.
++			 * The number of planes in the frame buffer and in the
++			 * V4L2 buffer is guaranteed to be equal at this point.
++			 */
++			for (auto [i, plane] : utils::enumerate(planes)) {
++				v4l2Planes[i].bytesused = metadata.planes()[i].bytesused;
++				v4l2Planes[i].length = plane.length;
++			}
++		} else {
++			/*
++			 * Single-planar API with a single plane in the buffer
++			 * is trivial to handle.
++			 */
++			buf.bytesused = metadata.planes()[0].bytesused;
++			buf.length = planes[0].length;
++		}
++
++		/*
++		 * Timestamps are to be supplied if the device is a mem-to-mem
++		 * device. The drivers will have V4L2_BUF_FLAG_TIMESTAMP_COPY
++		 * set hence these timestamps will be copied from the output
++		 * buffers to capture buffers. If the device is not mem-to-mem,
++		 * there is no harm in setting the timestamps as they will be
++		 * ignored (and over-written).
++		 */
++		buf.timestamp.tv_sec = metadata.timestamp / 1000000000;
++		buf.timestamp.tv_usec = (metadata.timestamp / 1000) % 1000000;
++	}
++
++	LOG(V4L2, Debug) << "Queueing buffer " << buf.index;
++
++	ret = ioctl(VIDIOC_QBUF, &buf);
++	if (ret < 0) {
++		LOG(V4L2, Error)
++			<< "Failed to queue buffer " << buf.index << ": "
++			<< strerror(-ret);
++		return ret;
++	}
++
++	if (queuedBuffers_.empty()) {
++		fdBufferNotifier_->setEnabled(true);
++		if (watchdogDuration_)
++			watchdog_.start(std::chrono::duration_cast<std::chrono::milliseconds>(watchdogDuration_));
++	}
++
++	queuedBuffers_[buf.index] = buffer;
++
++	return 0;
++}
++
++/**
+  * \var V4L2VideoDevice::bufferReady
+  * \brief A Signal emitted when a framebuffer completes
+  */
+--- a/src/ipa/rpi/pisp/data/imx296.json	2025-05-08 00:06:16.067331148 +0530
++++ b/src/ipa/rpi/pisp/data/imx296.json	2025-05-08 00:06:16.048331443 +0530
+@@ -1189,6 +1189,11 @@
+                     ]
+                 }
+             }
++        },
++        {
++            "rpi.sync":
++            {
++            }
+         }
+     ]
+ }
+\ No newline at end of file
+--- a/src/ipa/rpi/pisp/data/imx296_mono.json	2025-05-08 00:06:16.067331148 +0530
++++ b/src/ipa/rpi/pisp/data/imx296_mono.json	2025-05-08 00:06:16.048331443 +0530
+@@ -955,6 +955,11 @@
+                     ]
+                 }
+             }
++        },
++        {
++            "rpi.sync":
++            {
++            }
+         }
+     ]
+ }
+\ No newline at end of file
+--- a/src/ipa/rpi/pisp/data/imx477.json	2025-05-08 00:06:16.067331148 +0530
++++ b/src/ipa/rpi/pisp/data/imx477.json	2025-05-08 00:06:16.049331427 +0530
+@@ -1181,6 +1181,11 @@
+                     ]
+                 }
+             }
++        },
++        {
++            "rpi.sync":
++            {
++            }
+         }
+     ]
+ }
+\ No newline at end of file
+--- a/src/ipa/rpi/pisp/data/imx477_noir.json	2025-05-08 00:06:16.067331148 +0530
++++ b/src/ipa/rpi/pisp/data/imx477_noir.json	2025-05-08 00:06:16.049331427 +0530
+@@ -1143,6 +1143,11 @@
+                     ]
+                 }
+             }
++        },
++        {
++            "rpi.sync":
++            {
++            }
+         }
+     ]
+ }
+\ No newline at end of file
+--- a/src/ipa/rpi/pisp/data/imx477_scientific.json	2025-05-08 00:06:16.067331148 +0530
++++ b/src/ipa/rpi/pisp/data/imx477_scientific.json	2025-05-08 00:06:16.049331427 +0530
+@@ -541,6 +541,11 @@
+                 "limit": 1.0,
+                 "strength": 1.0
+             }
++        },
++        {
++            "rpi.sync":
++            {
++            }
+         }
+     ]
+ }
+\ No newline at end of file
+--- a/src/ipa/rpi/pisp/data/imx708.json	2025-05-08 00:06:16.067331148 +0530
++++ b/src/ipa/rpi/pisp/data/imx708.json	2025-05-08 00:06:16.049331427 +0530
+@@ -1265,6 +1265,11 @@
+                     ]
+                 }
+             }
++        },
++        {
++            "rpi.sync":
++            {
++            }
+         }
+     ]
+ }
+\ No newline at end of file
+--- a/src/ipa/rpi/pisp/data/imx708_noir.json	2025-05-08 00:06:16.067331148 +0530
++++ b/src/ipa/rpi/pisp/data/imx708_noir.json	2025-05-08 00:06:16.050331412 +0530
+@@ -1228,6 +1228,11 @@
+                     ]
+                 }
+             }
++        },
++        {
++            "rpi.syc":
++            {
++            }
+         }
+     ]
+ }
+\ No newline at end of file
+--- a/src/ipa/rpi/pisp/data/imx708_wide.json	2025-05-08 00:06:16.067331148 +0530
++++ b/src/ipa/rpi/pisp/data/imx708_wide.json	2025-05-08 00:06:16.050331412 +0530
+@@ -1288,6 +1288,11 @@
+                     ]
+                 }
+             }
++        },
++        {
++            "rpi.sync":
++            {
++            }
+         }
+     ]
+ }
+\ No newline at end of file
+--- a/src/ipa/rpi/pisp/data/imx708_wide_noir.json	2025-05-08 00:06:16.067331148 +0530
++++ b/src/ipa/rpi/pisp/data/imx708_wide_noir.json	2025-05-08 00:06:16.050331412 +0530
+@@ -1143,6 +1143,11 @@
+                     ]
+                 }
+             }
++        },
++        {
++            "rpi.sync":
++            {
++            }
+         }
+     ]
+ }
+\ No newline at end of file
+--- a/src/ipa/rpi/pisp/data/ov5647.json	2025-05-08 00:06:16.067331148 +0530
++++ b/src/ipa/rpi/pisp/data/ov5647.json	2025-05-08 00:06:16.050331412 +0530
+@@ -1181,6 +1181,11 @@
+                     ]
+                 }
+             }
++        },
++        {
++            "rpi.sync":
++            {
++            }
+         }
+     ]
+ }
+\ No newline at end of file
+--- a/src/ipa/rpi/pisp/data/ov5647_noir.json	2025-05-08 00:06:16.067331148 +0530
++++ b/src/ipa/rpi/pisp/data/ov5647_noir.json	2025-05-08 00:06:16.050331412 +0530
+@@ -1116,6 +1116,11 @@
+                     ]
+                 }
+             }
++        },
++        {
++            "rpi.sync":
++            {
++            }
+         }
+     ]
+ }
+\ No newline at end of file
+--- a/src/ipa/rpi/vc4/data/meson.build	2025-05-08 00:06:16.067331148 +0530
++++ b/src/ipa/rpi/vc4/data/meson.build	2025-05-08 00:06:16.051331396 +0530
+@@ -14,6 +14,7 @@
+     'imx477.json',
+     'imx477_noir.json',
+     'imx477_scientific.json',
++    'imx500.json',
+     'imx519.json',
+     'imx708.json',
+     'imx708_noir.json',
+--- /dev/null	1970-01-01 00:00:00.000000000 +0000
++++ b/src/ipa/rpi/vc4/data/imx500.json	2025-05-08 00:06:16.051331396 +0530
+@@ -0,0 +1,468 @@
++{
++    "version": 2.0,
++    "target": "bcm2835",
++    "algorithms": [
++        {
++            "rpi.black_level":
++            {
++                "black_level": 4096
++            }
++        },
++        {
++            "rpi.dpc": { }
++        },
++        {
++            "rpi.lux":
++            {
++                "reference_shutter_speed": 10369,
++                "reference_gain": 2.0,
++                "reference_aperture": 1.0,
++                "reference_lux": 950,
++                "reference_Y": 12457
++            }
++        },
++        {
++            "rpi.noise":
++            {
++                "reference_constant": 0,
++                "reference_slope": 2.747
++            }
++        },
++        {
++            "rpi.geq":
++            {
++                "offset": 223,
++                "slope": 0.00933
++            }
++        },
++        {
++            "rpi.sdn": { }
++        },
++        {
++            "rpi.awb":
++            {
++                "priors": [
++                    {
++                        "lux": 0,
++                        "prior":
++                        [
++                            2000, 1.0,
++                            3000, 0.0,
++                            13000, 0.0
++                        ]
++                    },
++                    {
++                        "lux": 800,
++                        "prior":
++                        [
++                            2000, 0.0,
++                            6000, 2.0,
++                            13000, 2.0
++                        ]
++                    },
++                    {
++                        "lux": 1500,
++                        "prior":
++                        [
++                            2000, 0.0,
++                            4000, 1.0,
++                            6000, 6.0,
++                            6500, 7.0,
++                            7000, 1.0,
++                            13000, 1.0
++                        ]
++                    }
++                ],
++                "modes":
++                {
++                    "auto":
++                    {
++                        "lo": 2800,
++                        "hi": 8000
++                    },
++                    "incandescent":
++                    {
++                        "lo": 2800,
++                        "hi": 3000
++                    },
++                    "tungsten":
++                    {
++                        "lo": 3000,
++                        "hi": 3500
++                    },
++                    "fluorescent":
++                    {
++                        "lo": 4000,
++                        "hi": 4700
++                    },
++                    "indoor":
++                    {
++                        "lo": 3000,
++                        "hi": 5000
++                    },
++                    "daylight":
++                    {
++                        "lo": 5500,
++                        "hi": 6500
++                    },
++                    "cloudy":
++                    {
++                        "lo": 7000,
++                        "hi": 7600
++                    }
++                },
++                "bayes": 1,
++                "ct_curve":
++                [
++                    2800.0, 0.7126, 0.3567,
++                    2860.0, 0.6681, 0.4042,
++                    2880.0, 0.6651, 0.4074,
++                    3580.0, 0.5674, 0.5091,
++                    3650.0, 0.5629, 0.5137,
++                    4500.0, 0.4792, 0.5982,
++                    4570.0, 0.4752, 0.6022,
++                    5648.0, 0.4137, 0.6628,
++                    5717.0, 0.4116, 0.6648,
++                    7600.0, 0.3609, 0.7138
++                ],
++                "sensitivity_r": 1.0,
++                "sensitivity_b": 1.0,
++                "transverse_pos": 0.02798,
++                "transverse_neg": 0.02626
++            }
++        },
++        {
++            "rpi.agc":
++            {
++                "metering_modes":
++                {
++                    "centre-weighted":
++                    {
++                        "weights":
++                        [
++                            3, 3, 3, 2, 2, 2, 2, 1, 1, 1, 1, 0, 0, 0, 0
++                        ]
++                    },
++                    "spot":
++                    {
++                        "weights":
++                        [
++                            2, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
++                        ]
++                    },
++                    "matrix":
++                    {
++                        "weights":
++                        [
++                            1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
++                        ]
++                    }
++                },
++                "exposure_modes":
++                {
++                    "normal":
++                    {
++                        "shutter": [ 100, 10000, 30000, 60000, 120000 ],
++                        "gain": [ 1.0, 2.0, 4.0, 6.0, 6.0 ]
++                    },
++                    "short":
++                    {
++                        "shutter": [ 100, 5000, 10000, 20000, 120000 ],
++                        "gain": [ 1.0, 2.0, 4.0, 6.0, 6.0 ]
++                    }
++                },
++                "constraint_modes":
++                {
++                    "normal": [
++                        {
++                            "bound": "LOWER",
++                            "q_lo": 0.98,
++                            "q_hi": 1.0,
++                            "y_target":
++                            [
++                                0, 0.5,
++                                1000, 0.5
++                            ]
++                        }
++                    ],
++                    "highlight": [
++                        {
++                            "bound": "LOWER",
++                            "q_lo": 0.98,
++                            "q_hi": 1.0,
++                            "y_target":
++                            [
++                                0, 0.5,
++                                1000, 0.5
++                            ]
++                        },
++                        {
++                            "bound": "UPPER",
++                            "q_lo": 0.98,
++                            "q_hi": 1.0,
++                            "y_target":
++                            [
++                                0, 0.8,
++                                1000, 0.8
++                            ]
++                        }
++                    ]
++                },
++                "y_target":
++                [
++                    0, 0.16,
++                    1000, 0.165,
++                    10000, 0.17
++                ]
++            }
++        },
++        {
++            "rpi.alsc":
++            {
++                "omega": 1.3,
++                "n_iter": 100,
++                "luminance_strength": 0.8,
++                "calibrations_Cr": [
++                    {
++                        "ct": 2800,
++                        "table":
++                        [
++                            1.613, 1.617, 1.621, 1.621, 1.615, 1.607, 1.604, 1.603, 1.603, 1.603, 1.607, 1.619, 1.626, 1.626, 1.622, 1.615,
++                            1.613, 1.616, 1.617, 1.615, 1.599, 1.583, 1.571, 1.564, 1.564, 1.571, 1.584, 1.603, 1.621, 1.624, 1.622, 1.618,
++                            1.613, 1.614, 1.614, 1.599, 1.577, 1.546, 1.529, 1.521, 1.521, 1.529, 1.548, 1.582, 1.603, 1.621, 1.621, 1.621,
++                            1.613, 1.613, 1.604, 1.577, 1.546, 1.521, 1.489, 1.481, 1.481, 1.491, 1.525, 1.548, 1.582, 1.612, 1.621, 1.623,
++                            1.614, 1.612, 1.595, 1.561, 1.521, 1.489, 1.475, 1.453, 1.453, 1.479, 1.491, 1.525, 1.567, 1.606, 1.623, 1.624,
++                            1.614, 1.612, 1.593, 1.555, 1.513, 1.477, 1.454, 1.452, 1.453, 1.455, 1.481, 1.519, 1.563, 1.604, 1.624, 1.626,
++                            1.615, 1.612, 1.593, 1.555, 1.513, 1.477, 1.458, 1.452, 1.453, 1.459, 1.481, 1.519, 1.563, 1.604, 1.625, 1.626,
++                            1.615, 1.614, 1.599, 1.564, 1.525, 1.496, 1.477, 1.459, 1.459, 1.481, 1.497, 1.531, 1.572, 1.609, 1.626, 1.627,
++                            1.614, 1.614, 1.609, 1.581, 1.552, 1.525, 1.496, 1.488, 1.488, 1.497, 1.531, 1.558, 1.591, 1.619, 1.626, 1.626,
++                            1.614, 1.616, 1.618, 1.607, 1.581, 1.552, 1.535, 1.529, 1.529, 1.538, 1.558, 1.591, 1.616, 1.631, 1.631, 1.625,
++                            1.613, 1.618, 1.619, 1.621, 1.607, 1.591, 1.579, 1.575, 1.575, 1.582, 1.597, 1.616, 1.631, 1.632, 1.631, 1.625,
++                            1.611, 1.616, 1.622, 1.623, 1.621, 1.615, 1.614, 1.614, 1.614, 1.615, 1.619, 1.631, 1.633, 1.633, 1.629, 1.624
++                        ]
++                    },
++                    {
++                        "ct": 4000,
++                        "table":
++                        [
++                            2.051, 2.057, 2.058, 2.058, 2.052, 2.045, 2.041, 2.041, 2.041, 2.042, 2.047, 2.062, 2.071, 2.071, 2.068, 2.061,
++                            2.051, 2.053, 2.055, 2.051, 2.033, 2.014, 2.001, 1.995, 1.995, 2.004, 2.019, 2.042, 2.064, 2.069, 2.068, 2.062,
++                            2.051, 2.051, 2.051, 2.033, 2.005, 1.971, 1.951, 1.943, 1.943, 1.953, 1.976, 2.016, 2.042, 2.064, 2.065, 2.065,
++                            2.049, 2.049, 2.037, 2.005, 1.971, 1.939, 1.904, 1.894, 1.894, 1.906, 1.947, 1.976, 2.016, 2.053, 2.065, 2.066,
++                            2.051, 2.048, 2.028, 1.987, 1.939, 1.904, 1.884, 1.858, 1.858, 1.891, 1.906, 1.947, 1.998, 2.044, 2.066, 2.068,
++                            2.051, 2.048, 2.025, 1.981, 1.929, 1.886, 1.858, 1.855, 1.857, 1.861, 1.892, 1.939, 1.992, 2.041, 2.068, 2.068,
++                            2.052, 2.048, 2.025, 1.981, 1.929, 1.886, 1.863, 1.855, 1.858, 1.864, 1.892, 1.939, 1.992, 2.041, 2.068, 2.069,
++                            2.053, 2.052, 2.033, 1.992, 1.944, 1.911, 1.886, 1.864, 1.864, 1.892, 1.912, 1.953, 2.003, 2.048, 2.069, 2.069,
++                            2.053, 2.053, 2.046, 2.013, 1.978, 1.944, 1.911, 1.901, 1.901, 1.912, 1.953, 1.985, 2.023, 2.059, 2.069, 2.069,
++                            2.053, 2.055, 2.058, 2.044, 2.013, 1.978, 1.959, 1.951, 1.951, 1.961, 1.985, 2.023, 2.054, 2.071, 2.071, 2.068,
++                            2.052, 2.058, 2.059, 2.061, 2.044, 2.025, 2.011, 2.005, 2.005, 2.014, 2.031, 2.054, 2.071, 2.075, 2.072, 2.068,
++                            2.051, 2.056, 2.064, 2.064, 2.061, 2.055, 2.052, 2.052, 2.052, 2.054, 2.058, 2.071, 2.077, 2.077, 2.072, 2.067
++                        ]
++                    }
++                ],
++                "calibrations_Cb": [
++                    {
++                        "ct": 2800,
++                        "table":
++                        [
++                            2.878, 2.876, 2.864, 2.851, 2.847, 2.847, 2.849, 2.854, 2.854, 2.854, 2.854, 2.854, 2.861, 2.873, 2.885, 2.887,
++                            2.876, 2.871, 2.859, 2.852, 2.849, 2.849, 2.854, 2.855, 2.855, 2.855, 2.854, 2.852, 2.854, 2.861, 2.875, 2.885,
++                            2.872, 2.869, 2.859, 2.856, 2.854, 2.856, 2.859, 2.863, 2.863, 2.861, 2.855, 2.852, 2.853, 2.855, 2.867, 2.875,
++                            2.872, 2.871, 2.865, 2.859, 2.858, 2.863, 2.869, 2.877, 2.877, 2.872, 2.861, 2.856, 2.854, 2.857, 2.863, 2.873,
++                            2.872, 2.871, 2.868, 2.865, 2.866, 2.872, 2.886, 2.899, 2.899, 2.879, 2.872, 2.861, 2.857, 2.859, 2.862, 2.871,
++                            2.872, 2.871, 2.869, 2.869, 2.872, 2.886, 2.901, 2.909, 2.903, 2.899, 2.879, 2.865, 2.859, 2.859, 2.861, 2.869,
++                            2.872, 2.871, 2.871, 2.871, 2.873, 2.886, 2.906, 2.909, 2.908, 2.902, 2.879, 2.865, 2.859, 2.859, 2.861, 2.868,
++                            2.872, 2.871, 2.871, 2.869, 2.873, 2.884, 2.892, 2.907, 2.903, 2.889, 2.875, 2.864, 2.859, 2.859, 2.861, 2.868,
++                            2.875, 2.872, 2.868, 2.867, 2.869, 2.874, 2.884, 2.889, 2.889, 2.877, 2.866, 2.859, 2.859, 2.861, 2.864, 2.872,
++                            2.877, 2.875, 2.867, 2.864, 2.865, 2.869, 2.874, 2.877, 2.877, 2.868, 2.861, 2.859, 2.859, 2.863, 2.872, 2.881,
++                            2.882, 2.877, 2.868, 2.863, 2.863, 2.863, 2.868, 2.869, 2.868, 2.865, 2.863, 2.861, 2.863, 2.871, 2.881, 2.883,
++                            2.885, 2.882, 2.872, 2.864, 2.861, 2.861, 2.865, 2.865, 2.865, 2.864, 2.863, 2.863, 2.866, 2.872, 2.882, 2.891
++                        ]
++                    },
++                    {
++                        "ct": 4000,
++                        "table":
++                        [
++                            1.919, 1.919, 1.913, 1.909, 1.909, 1.909, 1.911, 1.912, 1.912, 1.911, 1.909, 1.909, 1.911, 1.914, 1.919, 1.921,
++                            1.919, 1.916, 1.913, 1.911, 1.909, 1.912, 1.914, 1.915, 1.914, 1.913, 1.911, 1.909, 1.909, 1.911, 1.915, 1.919,
++                            1.916, 1.915, 1.915, 1.914, 1.914, 1.918, 1.921, 1.921, 1.921, 1.919, 1.915, 1.911, 1.909, 1.911, 1.913, 1.916,
++                            1.916, 1.916, 1.916, 1.916, 1.919, 1.924, 1.928, 1.932, 1.932, 1.928, 1.919, 1.915, 1.911, 1.911, 1.912, 1.914,
++                            1.916, 1.917, 1.918, 1.919, 1.924, 1.928, 1.937, 1.945, 1.945, 1.932, 1.928, 1.919, 1.915, 1.912, 1.912, 1.913,
++                            1.916, 1.918, 1.919, 1.923, 1.928, 1.937, 1.946, 1.949, 1.946, 1.945, 1.931, 1.922, 1.916, 1.912, 1.912, 1.913,
++                            1.916, 1.918, 1.919, 1.923, 1.928, 1.937, 1.948, 1.949, 1.948, 1.945, 1.931, 1.922, 1.916, 1.912, 1.912, 1.912,
++                            1.915, 1.917, 1.918, 1.922, 1.927, 1.933, 1.938, 1.946, 1.945, 1.935, 1.928, 1.919, 1.915, 1.912, 1.912, 1.912,
++                            1.916, 1.916, 1.917, 1.918, 1.922, 1.927, 1.933, 1.935, 1.935, 1.928, 1.921, 1.915, 1.913, 1.912, 1.912, 1.914,
++                            1.917, 1.916, 1.916, 1.915, 1.917, 1.921, 1.925, 1.926, 1.926, 1.921, 1.918, 1.913, 1.913, 1.913, 1.916, 1.919,
++                            1.918, 1.917, 1.915, 1.913, 1.913, 1.916, 1.919, 1.921, 1.921, 1.918, 1.914, 1.913, 1.913, 1.915, 1.918, 1.921,
++                            1.919, 1.919, 1.914, 1.912, 1.912, 1.913, 1.914, 1.915, 1.915, 1.915, 1.913, 1.913, 1.913, 1.915, 1.919, 1.922
++                        ]
++                    }
++                ],
++                "luminance_lut":
++                [
++                    3.029, 2.888, 2.497, 2.201, 1.954, 1.761, 1.711, 1.711, 1.711, 1.713, 1.778, 1.975, 2.225, 2.526, 2.925, 3.069,
++                    2.888, 2.562, 2.203, 1.999, 1.762, 1.602, 1.495, 1.447, 1.447, 1.503, 1.616, 1.785, 2.019, 2.229, 2.594, 2.925,
++                    2.577, 2.319, 2.004, 1.762, 1.602, 1.391, 1.284, 1.241, 1.241, 1.294, 1.409, 1.616, 1.785, 2.031, 2.349, 2.607,
++                    2.451, 2.155, 1.861, 1.607, 1.391, 1.284, 1.137, 1.095, 1.095, 1.154, 1.294, 1.409, 1.631, 1.891, 2.185, 2.483,
++                    2.393, 2.056, 1.765, 1.501, 1.288, 1.137, 1.091, 1.004, 1.011, 1.095, 1.154, 1.309, 1.527, 1.796, 2.088, 2.425,
++                    2.393, 2.015, 1.722, 1.455, 1.245, 1.097, 1.004, 1.001, 1.001, 1.016, 1.115, 1.266, 1.482, 1.752, 2.046, 2.425,
++                    2.393, 2.015, 1.722, 1.455, 1.245, 1.097, 1.014, 1.001, 1.011, 1.017, 1.115, 1.266, 1.482, 1.752, 2.046, 2.425,
++                    2.399, 2.071, 1.777, 1.515, 1.301, 1.158, 1.097, 1.017, 1.017, 1.114, 1.169, 1.323, 1.543, 1.809, 2.102, 2.429,
++                    2.471, 2.178, 1.881, 1.628, 1.419, 1.301, 1.158, 1.117, 1.117, 1.169, 1.323, 1.439, 1.657, 1.915, 2.213, 2.501,
++                    2.622, 2.358, 2.034, 1.799, 1.628, 1.419, 1.315, 1.271, 1.271, 1.327, 1.439, 1.657, 1.824, 2.067, 2.394, 2.662,
++                    2.959, 2.622, 2.255, 2.034, 1.799, 1.644, 1.536, 1.489, 1.489, 1.548, 1.664, 1.824, 2.066, 2.284, 2.662, 3.018,
++                    3.099, 2.959, 2.559, 2.249, 1.994, 1.803, 1.756, 1.756, 1.756, 1.759, 1.824, 2.022, 2.281, 2.601, 3.018, 3.155
++                ],
++                "sigma": 0.00096,
++                "sigma_Cb": 0.00125
++            }
++        },
++        {
++            "rpi.contrast":
++            {
++                "ce_enable": 1,
++                "gamma_curve":
++                [
++                    0, 0,
++                    1024, 5040,
++                    2048, 9338,
++                    3072, 12356,
++                    4096, 15312,
++                    5120, 18051,
++                    6144, 20790,
++                    7168, 23193,
++                    8192, 25744,
++                    9216, 27942,
++                    10240, 30035,
++                    11264, 32005,
++                    12288, 33975,
++                    13312, 35815,
++                    14336, 37600,
++                    15360, 39168,
++                    16384, 40642,
++                    18432, 43379,
++                    20480, 45749,
++                    22528, 47753,
++                    24576, 49621,
++                    26624, 51253,
++                    28672, 52698,
++                    30720, 53796,
++                    32768, 54876,
++                    36864, 57012,
++                    40960, 58656,
++                    45056, 59954,
++                    49152, 61183,
++                    53248, 62355,
++                    57344, 63419,
++                    61440, 64476,
++                    65535, 65535
++                ]
++            }
++        },
++        {
++            "rpi.ccm":
++            {
++                "ccms": [
++                    {
++                        "ct": 2800,
++                        "ccm":
++                        [
++                            1.61505, -0.29143, -0.32361,
++                            -0.36502, 1.73067, -0.36565,
++                            0.05048, -1.11795, 2.06747
++                        ]
++                    },
++                    {
++                        "ct": 2860,
++                        "ccm":
++                        [
++                            1.61304, -0.35407, -0.25897,
++                            -0.49934, 1.98721, -0.48786,
++                            -0.03138, -0.70205, 1.73343
++                        ]
++                    },
++                    {
++                        "ct": 2880,
++                        "ccm":
++                        [
++                            1.61025, -0.33823, -0.27202,
++                            -0.49191, 1.99155, -0.49964,
++                            -0.02357, -0.74144, 1.76501
++                        ]
++                    },
++                    {
++                        "ct": 3580,
++                        "ccm":
++                        [
++                            1.67102, -0.45799, -0.21303,
++                            -0.43726, 1.89058, -0.45332,
++                            -0.04778, -0.57899, 1.62678
++                        ]
++                    },
++                    {
++                        "ct": 3650,
++                        "ccm":
++                        [
++                            1.66289, -0.44966, -0.21324,
++                            -0.42687, 1.86716, -0.44029,
++                            -0.04423, -0.55781, 1.60204
++                        ]
++                    },
++                    {
++                        "ct": 4500,
++                        "ccm":
++                        [
++                            1.59699, -0.35409, -0.24291,
++                            -0.38812, 1.97453, -0.58641,
++                            -0.05398, -0.50715, 1.56113
++                        ]
++                    },
++                    {
++                        "ct": 4570,
++                        "ccm":
++                        [
++                            1.62669, -0.38858, -0.23811,
++                            -0.38608, 1.97311, -0.58703,
++                            -0.05461, -0.52526, 1.57986
++                        ]
++                    },
++                    {
++                        "ct": 5648,
++                        "ccm":
++                        [
++                            1.77461, -0.60797, -0.16664,
++                            -0.33734, 1.82254, -0.48521,
++                            -0.06916, -0.43139, 1.50056
++                        ]
++                    },
++                    {
++                        "ct": 5717,
++                        "ccm":
++                        [
++                            1.76115, -0.59353, -0.16763,
++                            -0.33521, 1.82009, -0.48488,
++                            -0.07309, -0.42667, 1.49976
++                        ]
++                    },
++                    {
++                        "ct": 7600,
++                        "ccm":
++                        [
++                            1.71087, -0.34863, -0.36223,
++                            -0.31392, 2.24605, -0.93213,
++                            -0.08447, -0.72208, 1.80655
++                        ]
++                    }
++                ]
++            }
++        },
++        {
++            "rpi.sharpen": { }
++        },
++        {
++            "rpi.sync":
++            {
++            }
++        }
++    ]
++}
+\ No newline at end of file
+--- a/src/ipa/rpi/pisp/data/imx290.json	2025-05-08 00:06:16.067331148 +0530
++++ b/src/ipa/rpi/pisp/data/imx290.json	2025-05-08 00:06:16.052331381 +0530
+@@ -336,6 +336,11 @@
+                     }
+                 ]
+             }
++        },
++        {
++            "rpi.sync":
++            {
++            }
+         }
+     ]
+ }
+\ No newline at end of file
+--- a/src/ipa/rpi/pisp/data/imx296_16mm.json	2025-05-08 00:06:16.067331148 +0530
++++ b/src/ipa/rpi/pisp/data/imx296_16mm.json	2025-05-08 00:06:16.052331381 +0530
+@@ -1242,6 +1242,11 @@
+                     ]
+                 }
+             }
++        },
++        {
++            "rpi.sync":
++            {
++            }
+         }
+     ]
+ }
+\ No newline at end of file
+--- a/src/ipa/rpi/pisp/data/imx296_6mm.json	2025-05-08 00:06:16.067331148 +0530
++++ b/src/ipa/rpi/pisp/data/imx296_6mm.json	2025-05-08 00:06:16.052331381 +0530
+@@ -1242,6 +1242,11 @@
+                     ]
+                 }
+             }
++        },
++        {
++            "rpi.sync":
++            {
++            }
+         }
+     ]
+ }
+\ No newline at end of file
+--- a/src/ipa/rpi/pisp/data/imx378.json	2025-05-08 00:06:16.067331148 +0530
++++ b/src/ipa/rpi/pisp/data/imx378.json	2025-05-08 00:06:16.052331381 +0530
+@@ -629,6 +629,11 @@
+         },
+         {
+             "rpi.sharpen": { }
++        },
++        {
++            "rpi.sync":
++            {
++            }
+         }
+     ]
+ }
+\ No newline at end of file
+--- a/src/ipa/rpi/pisp/data/imx477_16mm.json	2025-05-08 00:06:16.067331148 +0530
++++ b/src/ipa/rpi/pisp/data/imx477_16mm.json	2025-05-08 00:06:16.053331365 +0530
+@@ -1235,6 +1235,11 @@
+                     ]
+                 }
+             }
++        },
++        {
++            "rpi.sync":
++            {
++            }
+         }
+     ]
+ }
+\ No newline at end of file
+--- a/src/ipa/rpi/pisp/data/imx477_6mm.json	2025-05-08 00:06:16.067331148 +0530
++++ b/src/ipa/rpi/pisp/data/imx477_6mm.json	2025-05-08 00:06:16.053331365 +0530
+@@ -1235,6 +1235,11 @@
+                     ]
+                 }
+             }
++        },
++        {
++            "rpi.sync":
++            {
++            }
+         }
+     ]
+ }
+\ No newline at end of file
+--- /dev/null	1970-01-01 00:00:00.000000000 +0000
++++ b/src/ipa/rpi/pisp/data/imx500.json	2025-05-08 00:06:16.053331365 +0530
+@@ -0,0 +1,1214 @@
++{
++    "version": 2.0,
++    "target": "pisp",
++    "algorithms": [
++        {
++            "rpi.black_level":
++            {
++                "black_level": 4096
++            }
++        },
++        {
++            "rpi.lux":
++            {
++                "reference_shutter_speed": 10369,
++                "reference_gain": 2.0,
++                "reference_aperture": 1.0,
++                "reference_lux": 950,
++                "reference_Y": 12457
++            }
++        },
++        {
++            "rpi.dpc":
++            {
++                "strength": 1
++            }
++        },
++        {
++            "rpi.noise":
++            {
++                "reference_constant": 0,
++                "reference_slope": 2.747
++            }
++        },
++        {
++            "rpi.geq":
++            {
++                "offset": 223,
++                "slope": 0.00933
++            }
++        },
++        {
++            "rpi.denoise":
++            {
++                "normal":
++                {
++                    "sdn":
++                    {
++                        "deviation": 1.6,
++                        "strength": 0.5,
++                        "deviation2": 3.2,
++                        "deviation_no_tdn": 3.2,
++                        "strength_no_tdn": 0.75
++                    },
++                    "cdn":
++                    {
++                        "deviation": 200,
++                        "strength": 0.3
++                    },
++                    "tdn":
++                    {
++                        "deviation": 0.8,
++                        "threshold": 0.05
++                    }
++                },
++                "hdr":
++                {
++                    "sdn":
++                    {
++                        "deviation": 1.6,
++                        "strength": 0.5,
++                        "deviation2": 3.2,
++                        "deviation_no_tdn": 3.2,
++                        "strength_no_tdn": 0.75
++                    },
++                    "cdn":
++                    {
++                        "deviation": 200,
++                        "strength": 0.3
++                    },
++                    "tdn":
++                    {
++                        "deviation": 1.3,
++                        "threshold": 0.1
++                    }
++                },
++                "night":
++                {
++                    "sdn":
++                    {
++                        "deviation": 1.6,
++                        "strength": 0.5,
++                        "deviation2": 3.2,
++                        "deviation_no_tdn": 3.2,
++                        "strength_no_tdn": 0.75
++                    },
++                    "cdn":
++                    {
++                        "deviation": 200,
++                        "strength": 0.3
++                    },
++                    "tdn":
++                    {
++                        "deviation": 1.3,
++                        "threshold": 0.1
++                    }
++                }
++            }
++        },
++        {
++            "rpi.awb":
++            {
++                "priors": [
++                    {
++                        "lux": 0,
++                        "prior":
++                        [
++                            2000, 1.0,
++                            3000, 0.0,
++                            13000, 0.0
++                        ]
++                    },
++                    {
++                        "lux": 800,
++                        "prior":
++                        [
++                            2000, 0.0,
++                            6000, 2.0,
++                            13000, 2.0
++                        ]
++                    },
++                    {
++                        "lux": 1500,
++                        "prior":
++                        [
++                            2000, 0.0,
++                            4000, 1.0,
++                            6000, 6.0,
++                            6500, 7.0,
++                            7000, 1.0,
++                            13000, 1.0
++                        ]
++                    }
++                ],
++                "modes":
++                {
++                    "auto":
++                    {
++                        "lo": 2800,
++                        "hi": 7700
++                    },
++                    "incandescent":
++                    {
++                        "lo": 2800,
++                        "hi": 3000
++                    },
++                    "tungsten":
++                    {
++                        "lo": 3000,
++                        "hi": 3500
++                    },
++                    "fluorescent":
++                    {
++                        "lo": 4000,
++                        "hi": 4700
++                    },
++                    "indoor":
++                    {
++                        "lo": 3000,
++                        "hi": 5000
++                    },
++                    "daylight":
++                    {
++                        "lo": 5500,
++                        "hi": 6500
++                    },
++                    "cloudy":
++                    {
++                        "lo": 7000,
++                        "hi": 7600
++                    }
++                },
++                "bayes": 1,
++                "ct_curve":
++                [
++                    2800.0, 0.7115, 0.3579,
++                    2860.0, 0.6671, 0.4058,
++                    2880.0, 0.6641, 0.4089,
++                    3580.0, 0.5665, 0.5113,
++                    3650.0, 0.5621, 0.5159,
++                    4500.0, 0.4799, 0.5997,
++                    4570.0, 0.4752, 0.6046,
++                    5648.0, 0.4139, 0.6657,
++                    5717.0, 0.4118, 0.6678,
++                    7600.0, 0.3625, 0.7162
++                ],
++                "sensitivity_r": 1.0,
++                "sensitivity_b": 1.0,
++                "transverse_pos": 0.02822,
++                "transverse_neg": 0.02678
++            }
++        },
++        {
++            "rpi.agc":
++            {
++                "channels": [
++                    {
++                        "comment": "Channel 0 is normal AGC",
++                        "metering_modes":
++                        {
++                            "centre-weighted":
++                            {
++                                "weights":
++                                [
++                                    0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0,
++                                    0, 1, 1, 1, 1, 1, 2, 2, 2, 1, 1, 1, 1, 1, 0,
++                                    1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1,
++                                    1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1,
++                                    1, 1, 2, 2, 2, 2, 3, 3, 3, 2, 2, 2, 2, 1, 1,
++                                    1, 1, 2, 2, 2, 3, 3, 3, 3, 3, 2, 2, 2, 1, 1,
++                                    1, 1, 2, 2, 3, 3, 3, 4, 3, 3, 3, 2, 2, 1, 1,
++                                    1, 1, 2, 2, 3, 3, 4, 4, 4, 3, 3, 2, 2, 1, 1,
++                                    1, 1, 2, 2, 3, 3, 3, 4, 3, 3, 3, 2, 2, 1, 1,
++                                    1, 1, 2, 2, 2, 3, 3, 3, 3, 3, 2, 2, 2, 1, 1,
++                                    1, 1, 2, 2, 2, 2, 3, 3, 3, 2, 2, 2, 2, 1, 1,
++                                    1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1,
++                                    1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1,
++                                    0, 1, 1, 1, 1, 1, 2, 2, 2, 1, 1, 1, 1, 1, 0,
++                                    0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0
++                                ]
++                            },
++                            "spot":
++                            {
++                                "weights":
++                                [
++                                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
++                                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
++                                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
++                                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
++                                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
++                                    0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0,
++                                    0, 0, 0, 0, 0, 0, 1, 2, 1, 0, 0, 0, 0, 0, 0,
++                                    0, 0, 0, 0, 0, 1, 2, 3, 2, 1, 0, 0, 0, 0, 0,
++                                    0, 0, 0, 0, 0, 0, 1, 2, 1, 0, 0, 0, 0, 0, 0,
++                                    0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0,
++                                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
++                                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
++                                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
++                                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
++                                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
++                                ]
++                            },
++                            "matrix":
++                            {
++                                "weights":
++                                [
++                                    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
++                                    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
++                                    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
++                                    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
++                                    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
++                                    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
++                                    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
++                                    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
++                                    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
++                                    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
++                                    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
++                                    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
++                                    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
++                                    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
++                                    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
++                                ]
++                            }
++                        },
++                        "exposure_modes":
++                        {
++                            "normal":
++                            {
++                                "shutter": [ 100, 10000, 30000, 60000, 66666 ],
++                                "gain": [ 1.0, 1.5, 2.0, 4.0, 8.0 ]
++                            },
++                            "short":
++                            {
++                                "shutter": [ 100, 5000, 10000, 20000, 60000 ],
++                                "gain": [ 1.0, 1.5, 2.0, 4.0, 8.0 ]
++                            },
++                            "long":
++                            {
++                                "shutter": [ 100, 10000, 30000, 60000, 90000, 120000 ],
++                                "gain": [ 1.0, 1.5, 2.0, 4.0, 8.0, 12.0 ]
++                            }
++                        },
++                        "constraint_modes":
++                        {
++                            "normal": [
++                                {
++                                    "bound": "LOWER",
++                                    "q_lo": 0.98,
++                                    "q_hi": 1.0,
++                                    "y_target":
++                                    [
++                                        0, 0.5,
++                                        1000, 0.5
++                                    ]
++                                }
++                            ],
++                            "highlight": [
++                                {
++                                    "bound": "LOWER",
++                                    "q_lo": 0.98,
++                                    "q_hi": 1.0,
++                                    "y_target":
++                                    [
++                                        0, 0.5,
++                                        1000, 0.5
++                                    ]
++                                },
++                                {
++                                    "bound": "UPPER",
++                                    "q_lo": 0.98,
++                                    "q_hi": 1.0,
++                                    "y_target":
++                                    [
++                                        0, 0.8,
++                                        1000, 0.8
++                                    ]
++                                }
++                            ],
++                            "shadows": [
++                                {
++                                    "bound": "LOWER",
++                                    "q_lo": 0.0,
++                                    "q_hi": 0.5,
++                                    "y_target":
++                                    [
++                                        0, 0.17,
++                                        1000, 0.17
++                                    ]
++                                }
++                            ]
++                        },
++                        "y_target":
++                        [
++                            0, 0.16,
++                            1000, 0.165,
++                            10000, 0.17
++                        ]
++                    },
++                    {
++                        "comment": "Channel 1 is the HDR short channel",
++                        "desaturate": 0,
++                        "metering_modes":
++                        {
++                            "centre-weighted":
++                            {
++                                "weights":
++                                [
++                                    0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0,
++                                    0, 1, 1, 1, 1, 1, 2, 2, 2, 1, 1, 1, 1, 1, 0,
++                                    1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1,
++                                    1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1,
++                                    1, 1, 2, 2, 2, 2, 3, 3, 3, 2, 2, 2, 2, 1, 1,
++                                    1, 1, 2, 2, 2, 3, 3, 3, 3, 3, 2, 2, 2, 1, 1,
++                                    1, 1, 2, 2, 3, 3, 3, 4, 3, 3, 3, 2, 2, 1, 1,
++                                    1, 1, 2, 2, 3, 3, 4, 4, 4, 3, 3, 2, 2, 1, 1,
++                                    1, 1, 2, 2, 3, 3, 3, 4, 3, 3, 3, 2, 2, 1, 1,
++                                    1, 1, 2, 2, 2, 3, 3, 3, 3, 3, 2, 2, 2, 1, 1,
++                                    1, 1, 2, 2, 2, 2, 3, 3, 3, 2, 2, 2, 2, 1, 1,
++                                    1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1,
++                                    1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1,
++                                    0, 1, 1, 1, 1, 1, 2, 2, 2, 1, 1, 1, 1, 1, 0,
++                                    0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0
++                                ]
++                            },
++                            "spot":
++                            {
++                                "weights":
++                                [
++                                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
++                                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
++                                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
++                                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
++                                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
++                                    0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0,
++                                    0, 0, 0, 0, 0, 0, 1, 2, 1, 0, 0, 0, 0, 0, 0,
++                                    0, 0, 0, 0, 0, 1, 2, 3, 2, 1, 0, 0, 0, 0, 0,
++                                    0, 0, 0, 0, 0, 0, 1, 2, 1, 0, 0, 0, 0, 0, 0,
++                                    0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0,
++                                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
++                                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
++                                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
++                                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
++                                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
++                                ]
++                            },
++                            "matrix":
++                            {
++                                "weights":
++                                [
++                                    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
++                                    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
++                                    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
++                                    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
++                                    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
++                                    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
++                                    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
++                                    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
++                                    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
++                                    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
++                                    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
++                                    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
++                                    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
++                                    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
++                                    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
++                                ]
++                            }
++                        },
++                        "exposure_modes":
++                        {
++                            "normal":
++                            {
++                                "shutter": [ 100, 20000, 60000 ],
++                                "gain": [ 1.0, 1.0, 1.0 ]
++                            },
++                            "short":
++                            {
++                                "shutter": [ 100, 20000, 60000 ],
++                                "gain": [ 1.0, 1.0, 1.0 ]
++                            },
++                            "long":
++                            {
++                                "shutter": [ 100, 20000, 60000 ],
++                                "gain": [ 1.0, 1.0, 1.0 ]
++                            }
++                        },
++                        "constraint_modes":
++                        {
++                            "normal": [
++                                {
++                                    "bound": "LOWER",
++                                    "q_lo": 0.95,
++                                    "q_hi": 1.0,
++                                    "y_target":
++                                    [
++                                        0, 0.5,
++                                        1000, 0.5
++                                    ]
++                                },
++                                {
++                                    "bound": "UPPER",
++                                    "q_lo": 0.95,
++                                    "q_hi": 1.0,
++                                    "y_target":
++                                    [
++                                        0, 0.7,
++                                        1000, 0.7
++                                    ]
++                                },
++                                {
++                                    "bound": "LOWER",
++                                    "q_lo": 0.0,
++                                    "q_hi": 0.2,
++                                    "y_target":
++                                    [
++                                        0, 0.002,
++                                        1000, 0.002
++                                    ]
++                                }
++                            ],
++                            "highlight": [
++                                {
++                                    "bound": "LOWER",
++                                    "q_lo": 0.95,
++                                    "q_hi": 1.0,
++                                    "y_target":
++                                    [
++                                        0, 0.5,
++                                        1000, 0.5
++                                    ]
++                                },
++                                {
++                                    "bound": "UPPER",
++                                    "q_lo": 0.95,
++                                    "q_hi": 1.0,
++                                    "y_target":
++                                    [
++                                        0, 0.7,
++                                        1000, 0.7
++                                    ]
++                                },
++                                {
++                                    "bound": "LOWER",
++                                    "q_lo": 0.0,
++                                    "q_hi": 0.2,
++                                    "y_target":
++                                    [
++                                        0, 0.002,
++                                        1000, 0.002
++                                    ]
++                                }
++                            ],
++                            "shadows": [
++                                {
++                                    "bound": "LOWER",
++                                    "q_lo": 0.95,
++                                    "q_hi": 1.0,
++                                    "y_target":
++                                    [
++                                        0, 0.5,
++                                        1000, 0.5
++                                    ]
++                                },
++                                {
++                                    "bound": "UPPER",
++                                    "q_lo": 0.95,
++                                    "q_hi": 1.0,
++                                    "y_target":
++                                    [
++                                        0, 0.7,
++                                        1000, 0.7
++                                    ]
++                                },
++                                {
++                                    "bound": "LOWER",
++                                    "q_lo": 0.0,
++                                    "q_hi": 0.2,
++                                    "y_target":
++                                    [
++                                        0, 0.002,
++                                        1000, 0.002
++                                    ]
++                                }
++                            ]
++                        },
++                        "y_target":
++                        [
++                            0, 0.16,
++                            1000, 0.165,
++                            10000, 0.17
++                        ]
++                    },
++                    {
++                        "comment": "Channel 2 is the HDR long channel",
++                        "desaturate": 0,
++                        "metering_modes":
++                        {
++                            "centre-weighted":
++                            {
++                                "weights":
++                                [
++                                    0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0,
++                                    0, 1, 1, 1, 1, 1, 2, 2, 2, 1, 1, 1, 1, 1, 0,
++                                    1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1,
++                                    1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1,
++                                    1, 1, 2, 2, 2, 2, 3, 3, 3, 2, 2, 2, 2, 1, 1,
++                                    1, 1, 2, 2, 2, 3, 3, 3, 3, 3, 2, 2, 2, 1, 1,
++                                    1, 1, 2, 2, 3, 3, 3, 4, 3, 3, 3, 2, 2, 1, 1,
++                                    1, 1, 2, 2, 3, 3, 4, 4, 4, 3, 3, 2, 2, 1, 1,
++                                    1, 1, 2, 2, 3, 3, 3, 4, 3, 3, 3, 2, 2, 1, 1,
++                                    1, 1, 2, 2, 2, 3, 3, 3, 3, 3, 2, 2, 2, 1, 1,
++                                    1, 1, 2, 2, 2, 2, 3, 3, 3, 2, 2, 2, 2, 1, 1,
++                                    1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1,
++                                    1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1,
++                                    0, 1, 1, 1, 1, 1, 2, 2, 2, 1, 1, 1, 1, 1, 0,
++                                    0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0
++                                ]
++                            },
++                            "spot":
++                            {
++                                "weights":
++                                [
++                                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
++                                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
++                                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
++                                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
++                                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
++                                    0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0,
++                                    0, 0, 0, 0, 0, 0, 1, 2, 1, 0, 0, 0, 0, 0, 0,
++                                    0, 0, 0, 0, 0, 1, 2, 3, 2, 1, 0, 0, 0, 0, 0,
++                                    0, 0, 0, 0, 0, 0, 1, 2, 1, 0, 0, 0, 0, 0, 0,
++                                    0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0,
++                                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
++                                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
++                                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
++                                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
++                                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
++                                ]
++                            },
++                            "matrix":
++                            {
++                                "weights":
++                                [
++                                    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
++                                    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
++                                    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
++                                    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
++                                    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
++                                    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
++                                    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
++                                    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
++                                    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
++                                    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
++                                    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
++                                    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
++                                    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
++                                    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
++                                    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
++                                ]
++                            }
++                        },
++                        "exposure_modes":
++                        {
++                            "normal":
++                            {
++                                "shutter": [ 100, 20000, 30000, 60000 ],
++                                "gain": [ 1.0, 2.0, 4.0, 8.0 ]
++                            },
++                            "short":
++                            {
++                                "shutter": [ 100, 20000, 30000, 60000 ],
++                                "gain": [ 1.0, 2.0, 4.0, 8.0 ]
++                            },
++                            "long":
++                            {
++                                "shutter": [ 100, 20000, 30000, 60000 ],
++                                "gain": [ 1.0, 2.0, 4.0, 8.0 ]
++                            }
++                        },
++                        "constraint_modes":
++                        {
++                            "normal": [  ],
++                            "highlight": [  ],
++                            "shadows": [  ]
++                        },
++                        "channel_constraints": [
++                            {
++                                "bound": "UPPER",
++                                "channel": 4,
++                                "factor": 8
++                            },
++                            {
++                                "bound": "LOWER",
++                                "channel": 4,
++                                "factor": 2
++                            }
++                        ],
++                        "y_target":
++                        [
++                            0, 0.16,
++                            1000, 0.165,
++                            10000, 0.17
++                        ]
++                    },
++                    {
++                        "comment": "Channel 3 is the night mode channel",
++                        "base_ev": 0.33,
++                        "metering_modes":
++                        {
++                            "centre-weighted":
++                            {
++                                "weights":
++                                [
++                                    0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0,
++                                    0, 1, 1, 1, 1, 1, 2, 2, 2, 1, 1, 1, 1, 1, 0,
++                                    1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1,
++                                    1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1,
++                                    1, 1, 2, 2, 2, 2, 3, 3, 3, 2, 2, 2, 2, 1, 1,
++                                    1, 1, 2, 2, 2, 3, 3, 3, 3, 3, 2, 2, 2, 1, 1,
++                                    1, 1, 2, 2, 3, 3, 3, 4, 3, 3, 3, 2, 2, 1, 1,
++                                    1, 1, 2, 2, 3, 3, 4, 4, 4, 3, 3, 2, 2, 1, 1,
++                                    1, 1, 2, 2, 3, 3, 3, 4, 3, 3, 3, 2, 2, 1, 1,
++                                    1, 1, 2, 2, 2, 3, 3, 3, 3, 3, 2, 2, 2, 1, 1,
++                                    1, 1, 2, 2, 2, 2, 3, 3, 3, 2, 2, 2, 2, 1, 1,
++                                    1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1,
++                                    1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1,
++                                    0, 1, 1, 1, 1, 1, 2, 2, 2, 1, 1, 1, 1, 1, 0,
++                                    0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0
++                                ]
++                            },
++                            "spot":
++                            {
++                                "weights":
++                                [
++                                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
++                                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
++                                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
++                                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
++                                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
++                                    0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0,
++                                    0, 0, 0, 0, 0, 0, 1, 2, 1, 0, 0, 0, 0, 0, 0,
++                                    0, 0, 0, 0, 0, 1, 2, 3, 2, 1, 0, 0, 0, 0, 0,
++                                    0, 0, 0, 0, 0, 0, 1, 2, 1, 0, 0, 0, 0, 0, 0,
++                                    0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0,
++                                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
++                                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
++                                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
++                                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
++                                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
++                                ]
++                            },
++                            "matrix":
++                            {
++                                "weights":
++                                [
++                                    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
++                                    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
++                                    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
++                                    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
++                                    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
++                                    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
++                                    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
++                                    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
++                                    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
++                                    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
++                                    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
++                                    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
++                                    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
++                                    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
++                                    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
++                                ]
++                            }
++                        },
++                        "exposure_modes":
++                        {
++                            "normal":
++                            {
++                                "shutter": [ 100, 20000, 66666 ],
++                                "gain": [ 1.0, 2.0, 4.0 ]
++                            },
++                            "short":
++                            {
++                                "shutter": [ 100, 20000, 33333 ],
++                                "gain": [ 1.0, 2.0, 4.0 ]
++                            },
++                            "long":
++                            {
++                                "shutter": [ 100, 20000, 66666, 120000 ],
++                                "gain": [ 1.0, 2.0, 4.0, 4.0 ]
++                            }
++                        },
++                        "constraint_modes":
++                        {
++                            "normal": [
++                                {
++                                    "bound": "LOWER",
++                                    "q_lo": 0.98,
++                                    "q_hi": 1.0,
++                                    "y_target":
++                                    [
++                                        0, 0.5,
++                                        1000, 0.5
++                                    ]
++                                }
++                            ],
++                            "highlight": [
++                                {
++                                    "bound": "LOWER",
++                                    "q_lo": 0.98,
++                                    "q_hi": 1.0,
++                                    "y_target":
++                                    [
++                                        0, 0.5,
++                                        1000, 0.5
++                                    ]
++                                },
++                                {
++                                    "bound": "UPPER",
++                                    "q_lo": 0.98,
++                                    "q_hi": 1.0,
++                                    "y_target":
++                                    [
++                                        0, 0.8,
++                                        1000, 0.8
++                                    ]
++                                }
++                            ],
++                            "shadows": [
++                                {
++                                    "bound": "LOWER",
++                                    "q_lo": 0.98,
++                                    "q_hi": 1.0,
++                                    "y_target":
++                                    [
++                                        0, 0.5,
++                                        1000, 0.5
++                                    ]
++                                }
++                            ]
++                        },
++                        "y_target":
++                        [
++                            0, 0.16,
++                            1000, 0.16,
++                            10000, 0.17
++                        ]
++                    }
++                ]
++            }
++        },
++        {
++            "rpi.alsc":
++            {
++                "omega": 1.3,
++                "n_iter": 100,
++                "luminance_strength": 0.8,
++                "calibrations_Cr": [
++                    {
++                        "ct": 2800,
++                        "table":
++                        [
++                            1.607, 1.613, 1.616, 1.619, 1.621, 1.623, 1.624, 1.623, 1.623, 1.621, 1.619, 1.618, 1.616, 1.614, 1.614, 1.613, 1.613, 1.614, 1.616, 1.616, 1.618, 1.621, 1.623, 1.626, 1.626, 1.626, 1.626, 1.625, 1.622, 1.618, 1.611, 1.605,
++                            1.609, 1.614, 1.616, 1.619, 1.621, 1.623, 1.623, 1.622, 1.621, 1.617, 1.613, 1.609, 1.607, 1.605, 1.603, 1.602, 1.602, 1.603, 1.605, 1.608, 1.613, 1.616, 1.621, 1.625, 1.626, 1.626, 1.626, 1.625, 1.623, 1.619, 1.612, 1.609,
++                            1.612, 1.615, 1.616, 1.617, 1.621, 1.622, 1.622, 1.619, 1.615, 1.609, 1.602, 1.598, 1.594, 1.591, 1.589, 1.587, 1.587, 1.589, 1.593, 1.595, 1.601, 1.607, 1.615, 1.621, 1.624, 1.626, 1.627, 1.626, 1.623, 1.621, 1.616, 1.611,
++                            1.612, 1.614, 1.615, 1.617, 1.619, 1.621, 1.619, 1.615, 1.608, 1.601, 1.593, 1.585, 1.581, 1.577, 1.573, 1.572, 1.572, 1.574, 1.578, 1.582, 1.588, 1.595, 1.606, 1.615, 1.621, 1.625, 1.626, 1.626, 1.624, 1.621, 1.616, 1.613,
++                            1.612, 1.613, 1.615, 1.617, 1.619, 1.619, 1.616, 1.608, 1.601, 1.589, 1.581, 1.572, 1.565, 1.559, 1.558, 1.556, 1.556, 1.557, 1.562, 1.568, 1.574, 1.585, 1.595, 1.606, 1.615, 1.622, 1.626, 1.626, 1.626, 1.623, 1.617, 1.614,
++                            1.612, 1.613, 1.615, 1.617, 1.617, 1.616, 1.611, 1.601, 1.589, 1.578, 1.566, 1.556, 1.549, 1.543, 1.539, 1.538, 1.538, 1.541, 1.546, 1.552, 1.561, 1.572, 1.585, 1.597, 1.607, 1.618, 1.624, 1.626, 1.626, 1.623, 1.617, 1.615,
++                            1.612, 1.613, 1.616, 1.616, 1.616, 1.612, 1.604, 1.592, 1.578, 1.566, 1.553, 1.542, 1.533, 1.527, 1.523, 1.522, 1.522, 1.524, 1.529, 1.536, 1.546, 1.561, 1.572, 1.586, 1.601, 1.611, 1.619, 1.625, 1.625, 1.624, 1.619, 1.617,
++                            1.612, 1.613, 1.614, 1.615, 1.614, 1.607, 1.597, 1.584, 1.567, 1.553, 1.541, 1.529, 1.518, 1.511, 1.507, 1.506, 1.506, 1.507, 1.513, 1.519, 1.531, 1.546, 1.561, 1.576, 1.591, 1.605, 1.616, 1.623, 1.625, 1.624, 1.621, 1.618,
++                            1.612, 1.613, 1.614, 1.614, 1.611, 1.601, 1.589, 1.573, 1.555, 1.541, 1.529, 1.513, 1.503, 1.496, 1.493, 1.489, 1.489, 1.492, 1.498, 1.506, 1.519, 1.531, 1.549, 1.566, 1.582, 1.599, 1.613, 1.621, 1.625, 1.625, 1.621, 1.619,
++                            1.612, 1.613, 1.614, 1.613, 1.607, 1.598, 1.583, 1.567, 1.547, 1.529, 1.513, 1.503, 1.489, 1.482, 1.478, 1.476, 1.476, 1.481, 1.485, 1.494, 1.506, 1.519, 1.537, 1.556, 1.575, 1.593, 1.608, 1.621, 1.625, 1.625, 1.622, 1.619,
++                            1.612, 1.614, 1.614, 1.613, 1.606, 1.594, 1.577, 1.558, 1.539, 1.519, 1.503, 1.489, 1.479, 1.471, 1.466, 1.464, 1.464, 1.467, 1.473, 1.484, 1.494, 1.509, 1.528, 1.549, 1.568, 1.588, 1.605, 1.619, 1.626, 1.626, 1.623, 1.621,
++                            1.614, 1.614, 1.614, 1.612, 1.602, 1.591, 1.572, 1.552, 1.532, 1.512, 1.495, 1.479, 1.471, 1.463, 1.456, 1.455, 1.455, 1.459, 1.466, 1.473, 1.485, 1.502, 1.522, 1.542, 1.562, 1.584, 1.602, 1.618, 1.626, 1.626, 1.623, 1.622,
++                            1.614, 1.614, 1.614, 1.611, 1.601, 1.585, 1.568, 1.547, 1.526, 1.506, 1.488, 1.473, 1.463, 1.456, 1.449, 1.447, 1.447, 1.452, 1.459, 1.467, 1.478, 1.496, 1.515, 1.537, 1.559, 1.581, 1.601, 1.617, 1.626, 1.626, 1.624, 1.623,
++                            1.614, 1.614, 1.614, 1.611, 1.601, 1.584, 1.564, 1.544, 1.522, 1.502, 1.484, 1.469, 1.458, 1.449, 1.446, 1.443, 1.443, 1.447, 1.452, 1.461, 1.475, 1.492, 1.511, 1.533, 1.556, 1.578, 1.599, 1.616, 1.625, 1.626, 1.625, 1.621,
++                            1.614, 1.614, 1.614, 1.609, 1.599, 1.583, 1.563, 1.542, 1.521, 1.499, 1.482, 1.466, 1.455, 1.447, 1.443, 1.441, 1.442, 1.443, 1.449, 1.459, 1.473, 1.489, 1.509, 1.531, 1.554, 1.577, 1.597, 1.615, 1.625, 1.626, 1.626, 1.622,
++                            1.615, 1.614, 1.614, 1.609, 1.599, 1.583, 1.563, 1.542, 1.519, 1.499, 1.481, 1.466, 1.454, 1.447, 1.442, 1.439, 1.439, 1.443, 1.449, 1.459, 1.472, 1.489, 1.509, 1.531, 1.554, 1.576, 1.597, 1.615, 1.625, 1.626, 1.626, 1.622,
++                            1.615, 1.615, 1.614, 1.609, 1.599, 1.584, 1.563, 1.542, 1.521, 1.499, 1.482, 1.466, 1.454, 1.447, 1.442, 1.441, 1.442, 1.443, 1.449, 1.459, 1.472, 1.489, 1.509, 1.532, 1.554, 1.577, 1.598, 1.615, 1.625, 1.627, 1.627, 1.624,
++                            1.615, 1.615, 1.614, 1.611, 1.601, 1.586, 1.565, 1.544, 1.522, 1.502, 1.483, 1.469, 1.458, 1.451, 1.447, 1.443, 1.443, 1.448, 1.453, 1.462, 1.475, 1.493, 1.513, 1.534, 1.558, 1.579, 1.601, 1.616, 1.626, 1.628, 1.628, 1.624,
++                            1.615, 1.616, 1.615, 1.611, 1.601, 1.588, 1.568, 1.547, 1.526, 1.506, 1.488, 1.473, 1.462, 1.456, 1.451, 1.448, 1.448, 1.453, 1.458, 1.466, 1.481, 1.497, 1.517, 1.538, 1.561, 1.582, 1.603, 1.617, 1.628, 1.628, 1.628, 1.624,
++                            1.615, 1.615, 1.615, 1.613, 1.605, 1.589, 1.573, 1.552, 1.531, 1.511, 1.494, 1.479, 1.469, 1.462, 1.456, 1.455, 1.455, 1.458, 1.466, 1.473, 1.486, 1.503, 1.522, 1.543, 1.564, 1.585, 1.605, 1.621, 1.629, 1.629, 1.627, 1.624,
++                            1.615, 1.616, 1.616, 1.614, 1.607, 1.594, 1.576, 1.557, 1.538, 1.518, 1.501, 1.487, 1.479, 1.469, 1.463, 1.462, 1.462, 1.466, 1.473, 1.483, 1.494, 1.509, 1.529, 1.549, 1.571, 1.591, 1.609, 1.621, 1.629, 1.629, 1.627, 1.624,
++                            1.614, 1.615, 1.616, 1.615, 1.611, 1.599, 1.582, 1.564, 1.546, 1.527, 1.511, 1.499, 1.487, 1.479, 1.475, 1.473, 1.474, 1.476, 1.483, 1.493, 1.504, 1.518, 1.538, 1.557, 1.577, 1.596, 1.612, 1.625, 1.631, 1.631, 1.627, 1.624,
++                            1.613, 1.615, 1.616, 1.615, 1.613, 1.604, 1.589, 1.573, 1.555, 1.538, 1.522, 1.511, 1.499, 1.492, 1.488, 1.487, 1.487, 1.489, 1.494, 1.504, 1.518, 1.529, 1.548, 1.567, 1.586, 1.604, 1.617, 1.627, 1.631, 1.631, 1.626, 1.622,
++                            1.612, 1.614, 1.616, 1.616, 1.615, 1.608, 1.596, 1.582, 1.566, 1.549, 1.537, 1.522, 1.514, 1.507, 1.503, 1.501, 1.501, 1.504, 1.509, 1.518, 1.529, 1.544, 1.561, 1.578, 1.594, 1.609, 1.623, 1.629, 1.631, 1.631, 1.626, 1.623,
++                            1.612, 1.614, 1.616, 1.618, 1.618, 1.614, 1.604, 1.592, 1.577, 1.563, 1.549, 1.537, 1.529, 1.523, 1.518, 1.518, 1.518, 1.521, 1.526, 1.533, 1.544, 1.559, 1.574, 1.591, 1.604, 1.617, 1.626, 1.632, 1.632, 1.631, 1.626, 1.623,
++                            1.612, 1.613, 1.617, 1.619, 1.619, 1.619, 1.612, 1.601, 1.588, 1.576, 1.563, 1.552, 1.543, 1.538, 1.536, 1.535, 1.536, 1.538, 1.542, 1.549, 1.559, 1.574, 1.588, 1.601, 1.613, 1.623, 1.631, 1.633, 1.633, 1.631, 1.626, 1.623,
++                            1.612, 1.613, 1.617, 1.619, 1.621, 1.621, 1.618, 1.611, 1.601, 1.588, 1.577, 1.568, 1.561, 1.555, 1.552, 1.552, 1.552, 1.556, 1.558, 1.566, 1.576, 1.588, 1.599, 1.611, 1.621, 1.628, 1.633, 1.634, 1.634, 1.631, 1.625, 1.622,
++                            1.611, 1.612, 1.617, 1.619, 1.622, 1.623, 1.621, 1.616, 1.609, 1.601, 1.591, 1.583, 1.577, 1.574, 1.571, 1.569, 1.569, 1.573, 1.577, 1.582, 1.591, 1.601, 1.611, 1.621, 1.628, 1.634, 1.635, 1.635, 1.634, 1.631, 1.625, 1.622,
++                            1.609, 1.612, 1.616, 1.618, 1.622, 1.623, 1.624, 1.622, 1.617, 1.611, 1.603, 1.597, 1.593, 1.589, 1.588, 1.587, 1.587, 1.589, 1.593, 1.598, 1.605, 1.612, 1.621, 1.628, 1.633, 1.635, 1.635, 1.635, 1.633, 1.631, 1.624, 1.622,
++                            1.607, 1.611, 1.615, 1.618, 1.621, 1.624, 1.624, 1.624, 1.622, 1.618, 1.613, 1.609, 1.607, 1.603, 1.603, 1.603, 1.603, 1.605, 1.608, 1.613, 1.617, 1.621, 1.628, 1.634, 1.635, 1.635, 1.635, 1.633, 1.632, 1.628, 1.623, 1.619,
++                            1.605, 1.609, 1.614, 1.617, 1.619, 1.624, 1.625, 1.625, 1.625, 1.624, 1.621, 1.619, 1.617, 1.617, 1.617, 1.617, 1.617, 1.618, 1.621, 1.623, 1.627, 1.629, 1.633, 1.635, 1.635, 1.634, 1.633, 1.632, 1.631, 1.625, 1.619, 1.617,
++                            1.602, 1.606, 1.613, 1.617, 1.619, 1.624, 1.625, 1.626, 1.627, 1.626, 1.626, 1.625, 1.625, 1.624, 1.624, 1.624, 1.625, 1.625, 1.626, 1.628, 1.631, 1.633, 1.634, 1.635, 1.634, 1.634, 1.633, 1.632, 1.631, 1.625, 1.617, 1.608
++                        ]
++                    },
++                    {
++                        "ct": 4000,
++                        "table":
++                        [
++                            2.044, 2.051, 2.055, 2.059, 2.061, 2.063, 2.064, 2.063, 2.062, 2.062, 2.058, 2.058, 2.057, 2.055, 2.054, 2.054, 2.055, 2.056, 2.057, 2.059, 2.062, 2.065, 2.068, 2.071, 2.072, 2.072, 2.072, 2.071, 2.069, 2.065, 2.055, 2.047,
++                            2.048, 2.051, 2.055, 2.058, 2.059, 2.061, 2.062, 2.061, 2.059, 2.053, 2.049, 2.046, 2.043, 2.042, 2.039, 2.039, 2.039, 2.041, 2.044, 2.047, 2.053, 2.059, 2.065, 2.068, 2.072, 2.072, 2.072, 2.071, 2.069, 2.064, 2.058, 2.052,
++                            2.049, 2.052, 2.054, 2.057, 2.059, 2.059, 2.059, 2.057, 2.052, 2.044, 2.037, 2.033, 2.029, 2.024, 2.023, 2.021, 2.021, 2.023, 2.028, 2.034, 2.038, 2.048, 2.057, 2.064, 2.068, 2.071, 2.072, 2.072, 2.069, 2.065, 2.058, 2.056,
++                            2.051, 2.052, 2.054, 2.057, 2.058, 2.058, 2.057, 2.052, 2.044, 2.034, 2.026, 2.018, 2.012, 2.008, 2.005, 2.004, 2.004, 2.006, 2.012, 2.017, 2.024, 2.034, 2.047, 2.056, 2.064, 2.069, 2.072, 2.072, 2.071, 2.067, 2.061, 2.057,
++                            2.051, 2.052, 2.054, 2.056, 2.057, 2.057, 2.052, 2.045, 2.034, 2.021, 2.011, 2.001, 1.995, 1.988, 1.986, 1.985, 1.985, 1.988, 1.994, 1.999, 2.009, 2.022, 2.033, 2.047, 2.056, 2.066, 2.071, 2.072, 2.071, 2.069, 2.062, 2.061,
++                            2.051, 2.051, 2.053, 2.054, 2.055, 2.053, 2.046, 2.036, 2.021, 2.008, 1.994, 1.983, 1.975, 1.969, 1.965, 1.964, 1.965, 1.968, 1.973, 1.981, 1.991, 2.006, 2.021, 2.034, 2.048, 2.061, 2.066, 2.071, 2.071, 2.069, 2.063, 2.061,
++                            2.051, 2.051, 2.053, 2.053, 2.053, 2.048, 2.039, 2.025, 2.008, 1.993, 1.979, 1.965, 1.956, 1.949, 1.945, 1.944, 1.945, 1.948, 1.953, 1.961, 1.973, 1.991, 2.006, 2.022, 2.036, 2.052, 2.064, 2.069, 2.069, 2.069, 2.064, 2.061,
++                            2.051, 2.051, 2.051, 2.052, 2.049, 2.043, 2.031, 2.014, 1.994, 1.979, 1.964, 1.949, 1.939, 1.931, 1.925, 1.924, 1.924, 1.927, 1.934, 1.943, 1.957, 1.973, 1.991, 2.009, 2.028, 2.045, 2.058, 2.067, 2.069, 2.069, 2.064, 2.062,
++                            2.049, 2.049, 2.049, 2.049, 2.046, 2.036, 2.021, 2.002, 1.981, 1.964, 1.949, 1.931, 1.919, 1.911, 1.907, 1.905, 1.905, 1.909, 1.915, 1.926, 1.941, 1.957, 1.977, 1.997, 2.018, 2.037, 2.053, 2.064, 2.069, 2.069, 2.064, 2.062,
++                            2.049, 2.049, 2.049, 2.049, 2.041, 2.029, 2.011, 1.992, 1.969, 1.949, 1.931, 1.918, 1.904, 1.894, 1.889, 1.888, 1.888, 1.892, 1.898, 1.909, 1.926, 1.941, 1.962, 1.984, 2.008, 2.031, 2.048, 2.062, 2.069, 2.069, 2.066, 2.064,
++                            2.049, 2.051, 2.049, 2.049, 2.041, 2.024, 2.005, 1.984, 1.961, 1.938, 1.918, 1.904, 1.891, 1.879, 1.874, 1.873, 1.873, 1.877, 1.884, 1.898, 1.909, 1.929, 1.951, 1.973, 1.999, 2.025, 2.044, 2.062, 2.069, 2.069, 2.066, 2.064,
++                            2.051, 2.051, 2.051, 2.046, 2.035, 2.021, 1.999, 1.976, 1.952, 1.928, 1.908, 1.891, 1.879, 1.869, 1.862, 1.861, 1.861, 1.865, 1.875, 1.884, 1.899, 1.919, 1.943, 1.966, 1.992, 2.018, 2.039, 2.059, 2.069, 2.069, 2.067, 2.065,
++                            2.051, 2.051, 2.049, 2.046, 2.035, 2.017, 1.995, 1.969, 1.946, 1.921, 1.901, 1.881, 1.869, 1.861, 1.852, 1.851, 1.851, 1.856, 1.865, 1.875, 1.892, 1.911, 1.936, 1.961, 1.988, 2.014, 2.037, 2.057, 2.068, 2.069, 2.067, 2.066,
++                            2.051, 2.051, 2.049, 2.045, 2.034, 2.015, 1.992, 1.968, 1.941, 1.916, 1.895, 1.876, 1.862, 1.852, 1.849, 1.845, 1.845, 1.849, 1.856, 1.869, 1.886, 1.907, 1.931, 1.956, 1.984, 2.011, 2.037, 2.056, 2.068, 2.069, 2.068, 2.067,
++                            2.052, 2.051, 2.049, 2.044, 2.033, 2.013, 1.991, 1.964, 1.937, 1.915, 1.892, 1.873, 1.859, 1.849, 1.845, 1.841, 1.843, 1.844, 1.853, 1.865, 1.883, 1.906, 1.928, 1.954, 1.981, 2.009, 2.035, 2.055, 2.067, 2.068, 2.068, 2.068,
++                            2.051, 2.051, 2.049, 2.044, 2.032, 2.013, 1.991, 1.964, 1.937, 1.914, 1.891, 1.873, 1.858, 1.849, 1.842, 1.839, 1.839, 1.844, 1.853, 1.865, 1.883, 1.904, 1.928, 1.953, 1.981, 2.008, 2.034, 2.054, 2.067, 2.069, 2.069, 2.068,
++                            2.053, 2.052, 2.051, 2.045, 2.032, 2.015, 1.991, 1.965, 1.938, 1.914, 1.891, 1.874, 1.859, 1.849, 1.844, 1.841, 1.843, 1.845, 1.853, 1.866, 1.883, 1.904, 1.929, 1.954, 1.981, 2.009, 2.034, 2.055, 2.068, 2.069, 2.069, 2.068,
++                            2.053, 2.053, 2.051, 2.045, 2.035, 2.016, 1.993, 1.967, 1.942, 1.918, 1.894, 1.878, 1.863, 1.854, 1.849, 1.844, 1.845, 1.851, 1.857, 1.869, 1.885, 1.907, 1.932, 1.957, 1.985, 2.012, 2.037, 2.055, 2.069, 2.071, 2.069, 2.067,
++                            2.054, 2.053, 2.052, 2.047, 2.036, 2.019, 1.995, 1.972, 1.947, 1.922, 1.899, 1.882, 1.869, 1.861, 1.854, 1.851, 1.851, 1.857, 1.864, 1.873, 1.892, 1.913, 1.936, 1.962, 1.989, 2.014, 2.039, 2.058, 2.071, 2.071, 2.069, 2.067,
++                            2.053, 2.053, 2.053, 2.049, 2.039, 2.022, 2.002, 1.977, 1.951, 1.928, 1.907, 1.891, 1.877, 1.868, 1.861, 1.859, 1.859, 1.864, 1.873, 1.882, 1.899, 1.919, 1.943, 1.967, 1.994, 2.018, 2.043, 2.061, 2.072, 2.072, 2.069, 2.067,
++                            2.053, 2.054, 2.053, 2.051, 2.045, 2.027, 2.008, 1.984, 1.959, 1.937, 1.917, 1.901, 1.889, 1.877, 1.869, 1.869, 1.869, 1.873, 1.882, 1.894, 1.909, 1.928, 1.951, 1.975, 2.001, 2.025, 2.046, 2.063, 2.072, 2.072, 2.069, 2.068,
++                            2.053, 2.054, 2.055, 2.052, 2.047, 2.034, 2.014, 1.993, 1.971, 1.948, 1.929, 1.914, 1.901, 1.889, 1.885, 1.882, 1.883, 1.886, 1.894, 1.908, 1.921, 1.939, 1.961, 1.984, 2.007, 2.029, 2.051, 2.066, 2.072, 2.072, 2.068, 2.068,
++                            2.052, 2.054, 2.054, 2.054, 2.051, 2.039, 2.023, 2.002, 1.982, 1.962, 1.944, 1.929, 1.914, 1.906, 1.901, 1.899, 1.899, 1.903, 1.909, 1.921, 1.936, 1.951, 1.973, 1.995, 2.018, 2.038, 2.057, 2.068, 2.072, 2.072, 2.068, 2.065,
++                            2.051, 2.054, 2.055, 2.056, 2.054, 2.047, 2.031, 2.012, 1.994, 1.975, 1.959, 1.944, 1.932, 1.923, 1.918, 1.917, 1.917, 1.921, 1.927, 1.936, 1.951, 1.968, 1.988, 2.009, 2.028, 2.047, 2.061, 2.071, 2.073, 2.072, 2.067, 2.064,
++                            2.052, 2.054, 2.055, 2.057, 2.057, 2.053, 2.039, 2.027, 2.007, 1.991, 1.975, 1.959, 1.951, 1.943, 1.938, 1.938, 1.938, 1.939, 1.944, 1.955, 1.968, 1.987, 2.003, 2.022, 2.038, 2.056, 2.066, 2.072, 2.075, 2.073, 2.068, 2.067,
++                            2.052, 2.053, 2.057, 2.059, 2.059, 2.058, 2.051, 2.037, 2.021, 2.007, 1.991, 1.978, 1.968, 1.962, 1.958, 1.958, 1.959, 1.961, 1.966, 1.974, 1.987, 2.003, 2.019, 2.036, 2.051, 2.063, 2.071, 2.075, 2.075, 2.073, 2.068, 2.068,
++                            2.052, 2.053, 2.057, 2.061, 2.062, 2.062, 2.057, 2.049, 2.036, 2.021, 2.009, 1.998, 1.988, 1.983, 1.978, 1.978, 1.978, 1.981, 1.986, 1.994, 2.006, 2.019, 2.035, 2.049, 2.061, 2.069, 2.075, 2.077, 2.077, 2.074, 2.069, 2.067,
++                            2.051, 2.053, 2.057, 2.061, 2.063, 2.064, 2.063, 2.056, 2.048, 2.036, 2.026, 2.016, 2.008, 2.005, 2.001, 1.999, 2.001, 2.003, 2.007, 2.013, 2.025, 2.035, 2.048, 2.061, 2.068, 2.075, 2.079, 2.078, 2.077, 2.074, 2.069, 2.067,
++                            2.049, 2.053, 2.057, 2.059, 2.064, 2.065, 2.065, 2.063, 2.056, 2.048, 2.041, 2.033, 2.028, 2.023, 2.021, 2.021, 2.021, 2.023, 2.028, 2.033, 2.042, 2.049, 2.061, 2.069, 2.074, 2.078, 2.079, 2.079, 2.077, 2.073, 2.068, 2.064,
++                            2.046, 2.052, 2.054, 2.059, 2.063, 2.065, 2.066, 2.066, 2.064, 2.057, 2.051, 2.047, 2.045, 2.039, 2.039, 2.038, 2.039, 2.041, 2.045, 2.049, 2.055, 2.061, 2.071, 2.074, 2.077, 2.078, 2.078, 2.077, 2.075, 2.071, 2.065, 2.061,
++                            2.045, 2.051, 2.054, 2.059, 2.062, 2.065, 2.067, 2.068, 2.067, 2.065, 2.061, 2.058, 2.057, 2.056, 2.056, 2.056, 2.057, 2.058, 2.059, 2.062, 2.067, 2.071, 2.075, 2.077, 2.078, 2.077, 2.077, 2.076, 2.074, 2.068, 2.061, 2.056,
++                            2.043, 2.049, 2.056, 2.058, 2.061, 2.067, 2.068, 2.069, 2.069, 2.069, 2.068, 2.068, 2.065, 2.065, 2.065, 2.066, 2.067, 2.068, 2.068, 2.069, 2.073, 2.074, 2.077, 2.078, 2.078, 2.076, 2.076, 2.075, 2.071, 2.067, 2.057, 2.051
++                        ]
++                    }
++                ],
++                "calibrations_Cb": [
++                    {
++                        "ct": 2800,
++                        "table":
++                        [
++                            2.896, 2.894, 2.882, 2.876, 2.871, 2.863, 2.857, 2.855, 2.852, 2.852, 2.852, 2.852, 2.855, 2.857, 2.859, 2.863, 2.863, 2.862, 2.859, 2.859, 2.861, 2.863, 2.863, 2.864, 2.867, 2.869, 2.875, 2.879, 2.892, 2.897, 2.899, 2.904,
++                            2.888, 2.883, 2.877, 2.874, 2.865, 2.859, 2.852, 2.848, 2.846, 2.845, 2.845, 2.848, 2.849, 2.849, 2.851, 2.852, 2.854, 2.853, 2.852, 2.852, 2.852, 2.852, 2.851, 2.853, 2.857, 2.865, 2.873, 2.876, 2.882, 2.883, 2.897, 2.901,
++                            2.881, 2.878, 2.875, 2.867, 2.859, 2.853, 2.848, 2.846, 2.844, 2.844, 2.845, 2.847, 2.849, 2.849, 2.851, 2.851, 2.852, 2.852, 2.852, 2.851, 2.849, 2.849, 2.849, 2.851, 2.854, 2.857, 2.865, 2.873, 2.877, 2.881, 2.885, 2.892,
++                            2.881, 2.877, 2.873, 2.867, 2.859, 2.852, 2.849, 2.847, 2.846, 2.847, 2.848, 2.849, 2.851, 2.851, 2.852, 2.853, 2.854, 2.854, 2.854, 2.853, 2.852, 2.851, 2.851, 2.851, 2.851, 2.856, 2.861, 2.869, 2.875, 2.879, 2.885, 2.891,
++                            2.877, 2.874, 2.871, 2.867, 2.861, 2.856, 2.851, 2.848, 2.847, 2.848, 2.849, 2.851, 2.852, 2.853, 2.855, 2.856, 2.856, 2.856, 2.855, 2.854, 2.851, 2.849, 2.849, 2.851, 2.851, 2.853, 2.858, 2.864, 2.872, 2.875, 2.881, 2.888,
++                            2.873, 2.872, 2.871, 2.867, 2.861, 2.857, 2.853, 2.851, 2.849, 2.851, 2.851, 2.852, 2.854, 2.856, 2.857, 2.858, 2.858, 2.858, 2.857, 2.855, 2.854, 2.851, 2.849, 2.849, 2.851, 2.852, 2.855, 2.863, 2.869, 2.873, 2.877, 2.888,
++                            2.872, 2.872, 2.871, 2.868, 2.862, 2.858, 2.854, 2.853, 2.852, 2.853, 2.854, 2.857, 2.859, 2.859, 2.862, 2.863, 2.863, 2.862, 2.861, 2.857, 2.854, 2.853, 2.852, 2.851, 2.851, 2.851, 2.853, 2.859, 2.866, 2.872, 2.875, 2.885,
++                            2.872, 2.872, 2.871, 2.867, 2.861, 2.858, 2.855, 2.854, 2.854, 2.855, 2.857, 2.861, 2.862, 2.863, 2.866, 2.868, 2.869, 2.868, 2.865, 2.862, 2.857, 2.855, 2.855, 2.852, 2.851, 2.851, 2.853, 2.856, 2.862, 2.869, 2.876, 2.882,
++                            2.872, 2.872, 2.869, 2.865, 2.861, 2.859, 2.857, 2.856, 2.855, 2.858, 2.861, 2.862, 2.865, 2.868, 2.871, 2.873, 2.872, 2.871, 2.869, 2.865, 2.861, 2.858, 2.856, 2.854, 2.853, 2.852, 2.853, 2.856, 2.861, 2.869, 2.872, 2.879,
++                            2.874, 2.872, 2.869, 2.865, 2.863, 2.861, 2.859, 2.858, 2.859, 2.859, 2.862, 2.865, 2.868, 2.873, 2.877, 2.879, 2.879, 2.877, 2.873, 2.871, 2.865, 2.859, 2.857, 2.854, 2.854, 2.853, 2.855, 2.856, 2.861, 2.868, 2.872, 2.879,
++                            2.874, 2.873, 2.871, 2.866, 2.864, 2.863, 2.862, 2.862, 2.862, 2.863, 2.866, 2.868, 2.875, 2.882, 2.885, 2.886, 2.886, 2.884, 2.881, 2.873, 2.871, 2.864, 2.858, 2.856, 2.855, 2.855, 2.856, 2.857, 2.861, 2.868, 2.871, 2.879,
++                            2.874, 2.874, 2.872, 2.867, 2.865, 2.864, 2.864, 2.864, 2.865, 2.866, 2.868, 2.875, 2.882, 2.891, 2.897, 2.897, 2.896, 2.894, 2.888, 2.882, 2.873, 2.867, 2.862, 2.857, 2.857, 2.857, 2.857, 2.858, 2.862, 2.866, 2.871, 2.878,
++                            2.874, 2.874, 2.872, 2.869, 2.867, 2.865, 2.865, 2.865, 2.868, 2.868, 2.874, 2.882, 2.891, 2.899, 2.906, 2.907, 2.906, 2.903, 2.895, 2.888, 2.877, 2.868, 2.864, 2.862, 2.858, 2.858, 2.858, 2.859, 2.861, 2.867, 2.871, 2.877,
++                            2.875, 2.874, 2.871, 2.869, 2.868, 2.868, 2.868, 2.869, 2.869, 2.872, 2.878, 2.885, 2.899, 2.907, 2.912, 2.914, 2.914, 2.907, 2.903, 2.893, 2.879, 2.869, 2.866, 2.862, 2.859, 2.859, 2.859, 2.859, 2.861, 2.864, 2.868, 2.877,
++                            2.876, 2.874, 2.872, 2.869, 2.869, 2.869, 2.869, 2.869, 2.871, 2.875, 2.881, 2.894, 2.902, 2.912, 2.917, 2.919, 2.917, 2.914, 2.906, 2.894, 2.882, 2.874, 2.866, 2.863, 2.861, 2.859, 2.858, 2.859, 2.859, 2.863, 2.867, 2.876,
++                            2.873, 2.873, 2.869, 2.871, 2.869, 2.869, 2.869, 2.871, 2.872, 2.877, 2.884, 2.894, 2.902, 2.912, 2.921, 2.921, 2.919, 2.917, 2.907, 2.895, 2.882, 2.874, 2.868, 2.862, 2.859, 2.857, 2.857, 2.858, 2.859, 2.862, 2.866, 2.872,
++                            2.872, 2.872, 2.871, 2.871, 2.869, 2.869, 2.869, 2.871, 2.873, 2.878, 2.885, 2.894, 2.905, 2.914, 2.921, 2.922, 2.921, 2.917, 2.907, 2.896, 2.884, 2.874, 2.867, 2.863, 2.861, 2.859, 2.858, 2.858, 2.859, 2.863, 2.867, 2.871,
++                            2.871, 2.872, 2.871, 2.869, 2.868, 2.869, 2.869, 2.871, 2.875, 2.878, 2.884, 2.893, 2.905, 2.915, 2.919, 2.921, 2.919, 2.916, 2.907, 2.895, 2.884, 2.873, 2.868, 2.864, 2.862, 2.859, 2.858, 2.858, 2.861, 2.863, 2.866, 2.871,
++                            2.872, 2.872, 2.871, 2.869, 2.868, 2.868, 2.871, 2.873, 2.875, 2.877, 2.884, 2.893, 2.905, 2.909, 2.916, 2.919, 2.916, 2.911, 2.904, 2.894, 2.884, 2.873, 2.867, 2.864, 2.861, 2.859, 2.859, 2.858, 2.861, 2.863, 2.866, 2.873,
++                            2.873, 2.872, 2.871, 2.869, 2.867, 2.868, 2.869, 2.872, 2.873, 2.876, 2.882, 2.889, 2.899, 2.905, 2.909, 2.911, 2.911, 2.904, 2.899, 2.891, 2.881, 2.869, 2.865, 2.864, 2.861, 2.858, 2.858, 2.858, 2.861, 2.863, 2.865, 2.875,
++                            2.876, 2.874, 2.871, 2.869, 2.869, 2.869, 2.869, 2.869, 2.872, 2.873, 2.879, 2.886, 2.894, 2.899, 2.903, 2.903, 2.903, 2.899, 2.893, 2.883, 2.875, 2.869, 2.864, 2.862, 2.859, 2.858, 2.857, 2.857, 2.861, 2.863, 2.866, 2.875,
++                            2.876, 2.876, 2.873, 2.871, 2.869, 2.868, 2.868, 2.869, 2.869, 2.872, 2.875, 2.881, 2.887, 2.894, 2.895, 2.898, 2.898, 2.893, 2.887, 2.877, 2.872, 2.865, 2.862, 2.861, 2.859, 2.858, 2.857, 2.859, 2.862, 2.864, 2.868, 2.875,
++                            2.876, 2.877, 2.875, 2.871, 2.869, 2.867, 2.866, 2.866, 2.869, 2.871, 2.874, 2.878, 2.883, 2.887, 2.891, 2.891, 2.891, 2.887, 2.881, 2.874, 2.867, 2.863, 2.861, 2.859, 2.859, 2.858, 2.858, 2.861, 2.864, 2.866, 2.869, 2.875,
++                            2.876, 2.877, 2.875, 2.871, 2.868, 2.866, 2.864, 2.865, 2.867, 2.869, 2.872, 2.875, 2.879, 2.882, 2.885, 2.885, 2.883, 2.882, 2.878, 2.873, 2.865, 2.861, 2.859, 2.858, 2.857, 2.858, 2.859, 2.862, 2.866, 2.868, 2.875, 2.879,
++                            2.878, 2.878, 2.876, 2.871, 2.868, 2.864, 2.863, 2.863, 2.865, 2.867, 2.869, 2.872, 2.874, 2.879, 2.881, 2.881, 2.881, 2.878, 2.874, 2.868, 2.863, 2.859, 2.858, 2.858, 2.857, 2.859, 2.861, 2.864, 2.869, 2.874, 2.879, 2.883,
++                            2.879, 2.879, 2.876, 2.871, 2.865, 2.863, 2.863, 2.863, 2.862, 2.863, 2.867, 2.869, 2.871, 2.873, 2.874, 2.875, 2.875, 2.874, 2.871, 2.864, 2.862, 2.859, 2.858, 2.857, 2.857, 2.859, 2.863, 2.868, 2.874, 2.878, 2.881, 2.886,
++                            2.881, 2.881, 2.879, 2.871, 2.866, 2.863, 2.862, 2.861, 2.859, 2.861, 2.864, 2.868, 2.868, 2.869, 2.871, 2.871, 2.871, 2.871, 2.866, 2.863, 2.862, 2.859, 2.857, 2.858, 2.858, 2.859, 2.865, 2.872, 2.877, 2.879, 2.883, 2.887,
++                            2.881, 2.882, 2.879, 2.875, 2.869, 2.865, 2.862, 2.861, 2.859, 2.862, 2.863, 2.866, 2.868, 2.869, 2.871, 2.869, 2.869, 2.867, 2.866, 2.864, 2.863, 2.861, 2.858, 2.859, 2.858, 2.864, 2.867, 2.874, 2.879, 2.883, 2.887, 2.889,
++                            2.881, 2.883, 2.881, 2.881, 2.871, 2.868, 2.865, 2.862, 2.861, 2.863, 2.864, 2.867, 2.868, 2.869, 2.871, 2.871, 2.869, 2.868, 2.868, 2.867, 2.865, 2.863, 2.862, 2.863, 2.866, 2.867, 2.872, 2.876, 2.881, 2.886, 2.891, 2.897,
++                            2.885, 2.886, 2.884, 2.882, 2.874, 2.869, 2.866, 2.863, 2.861, 2.861, 2.862, 2.865, 2.866, 2.867, 2.871, 2.871, 2.868, 2.867, 2.867, 2.867, 2.865, 2.863, 2.862, 2.865, 2.867, 2.867, 2.872, 2.877, 2.881, 2.886, 2.891, 2.898,
++                            2.886, 2.889, 2.887, 2.882, 2.874, 2.869, 2.866, 2.863, 2.862, 2.861, 2.861, 2.862, 2.861, 2.862, 2.863, 2.863, 2.863, 2.862, 2.861, 2.861, 2.862, 2.862, 2.863, 2.863, 2.864, 2.867, 2.872, 2.876, 2.881, 2.884, 2.889, 2.898,
++                            2.907, 2.892, 2.889, 2.876, 2.874, 2.869, 2.865, 2.863, 2.861, 2.859, 2.861, 2.861, 2.861, 2.859, 2.861, 2.862, 2.862, 2.861, 2.859, 2.861, 2.861, 2.862, 2.862, 2.863, 2.863, 2.864, 2.868, 2.874, 2.879, 2.883, 2.888, 2.899
++                        ]
++                    },
++                    {
++                        "ct": 4000,
++                        "table":
++                        [
++                            1.929, 1.927, 1.922, 1.919, 1.916, 1.914, 1.911, 1.909, 1.908, 1.908, 1.909, 1.909, 1.911, 1.911, 1.912, 1.913, 1.914, 1.913, 1.912, 1.912, 1.911, 1.911, 1.912, 1.912, 1.912, 1.913, 1.915, 1.916, 1.922, 1.923, 1.927, 1.928,
++                            1.925, 1.923, 1.919, 1.917, 1.914, 1.911, 1.909, 1.908, 1.906, 1.907, 1.908, 1.909, 1.911, 1.911, 1.911, 1.912, 1.913, 1.912, 1.911, 1.911, 1.911, 1.909, 1.909, 1.909, 1.909, 1.911, 1.914, 1.915, 1.919, 1.919, 1.922, 1.924,
++                            1.921, 1.919, 1.918, 1.914, 1.912, 1.909, 1.908, 1.907, 1.906, 1.907, 1.908, 1.909, 1.911, 1.911, 1.911, 1.912, 1.912, 1.911, 1.911, 1.911, 1.909, 1.908, 1.908, 1.908, 1.909, 1.909, 1.912, 1.915, 1.917, 1.918, 1.921, 1.921,
++                            1.921, 1.919, 1.917, 1.914, 1.913, 1.909, 1.909, 1.908, 1.908, 1.909, 1.911, 1.912, 1.913, 1.913, 1.914, 1.914, 1.913, 1.913, 1.912, 1.912, 1.911, 1.909, 1.909, 1.909, 1.908, 1.909, 1.911, 1.914, 1.916, 1.918, 1.919, 1.921,
++                            1.918, 1.918, 1.917, 1.914, 1.913, 1.911, 1.909, 1.909, 1.909, 1.911, 1.912, 1.913, 1.914, 1.915, 1.916, 1.916, 1.916, 1.915, 1.914, 1.914, 1.912, 1.911, 1.909, 1.908, 1.908, 1.908, 1.909, 1.912, 1.915, 1.916, 1.917, 1.918,
++                            1.917, 1.917, 1.916, 1.915, 1.913, 1.912, 1.911, 1.911, 1.912, 1.913, 1.913, 1.914, 1.916, 1.917, 1.917, 1.917, 1.918, 1.918, 1.916, 1.915, 1.914, 1.912, 1.911, 1.909, 1.908, 1.908, 1.909, 1.911, 1.913, 1.915, 1.916, 1.917,
++                            1.916, 1.916, 1.916, 1.915, 1.914, 1.913, 1.913, 1.913, 1.913, 1.915, 1.917, 1.918, 1.919, 1.919, 1.921, 1.921, 1.921, 1.921, 1.919, 1.918, 1.915, 1.914, 1.912, 1.909, 1.908, 1.908, 1.908, 1.909, 1.913, 1.914, 1.915, 1.916,
++                            1.915, 1.916, 1.916, 1.915, 1.914, 1.914, 1.913, 1.914, 1.915, 1.918, 1.919, 1.922, 1.922, 1.924, 1.925, 1.925, 1.925, 1.924, 1.923, 1.921, 1.918, 1.915, 1.914, 1.911, 1.909, 1.908, 1.908, 1.909, 1.912, 1.913, 1.915, 1.915,
++                            1.915, 1.915, 1.915, 1.915, 1.914, 1.914, 1.915, 1.915, 1.917, 1.919, 1.922, 1.923, 1.924, 1.927, 1.928, 1.929, 1.929, 1.927, 1.925, 1.923, 1.921, 1.918, 1.915, 1.913, 1.911, 1.909, 1.908, 1.909, 1.912, 1.913, 1.914, 1.916,
++                            1.915, 1.915, 1.915, 1.916, 1.915, 1.915, 1.916, 1.917, 1.919, 1.922, 1.923, 1.925, 1.928, 1.929, 1.932, 1.933, 1.933, 1.932, 1.929, 1.926, 1.922, 1.919, 1.916, 1.914, 1.912, 1.911, 1.911, 1.911, 1.912, 1.913, 1.915, 1.917,
++                            1.916, 1.916, 1.916, 1.916, 1.916, 1.917, 1.918, 1.919, 1.921, 1.923, 1.925, 1.928, 1.933, 1.935, 1.937, 1.939, 1.939, 1.936, 1.934, 1.929, 1.926, 1.921, 1.917, 1.915, 1.913, 1.912, 1.911, 1.911, 1.913, 1.913, 1.914, 1.915,
++                            1.916, 1.917, 1.917, 1.917, 1.917, 1.918, 1.919, 1.921, 1.923, 1.925, 1.927, 1.933, 1.935, 1.941, 1.943, 1.944, 1.944, 1.941, 1.938, 1.934, 1.929, 1.924, 1.921, 1.916, 1.915, 1.913, 1.911, 1.911, 1.912, 1.914, 1.914, 1.914,
++                            1.917, 1.917, 1.917, 1.917, 1.917, 1.919, 1.921, 1.922, 1.925, 1.927, 1.931, 1.935, 1.941, 1.945, 1.949, 1.949, 1.949, 1.946, 1.941, 1.938, 1.931, 1.925, 1.921, 1.917, 1.916, 1.915, 1.913, 1.912, 1.912, 1.913, 1.913, 1.914,
++                            1.916, 1.917, 1.917, 1.917, 1.917, 1.919, 1.921, 1.923, 1.925, 1.928, 1.931, 1.938, 1.945, 1.949, 1.953, 1.954, 1.954, 1.949, 1.946, 1.941, 1.932, 1.926, 1.922, 1.919, 1.916, 1.915, 1.914, 1.912, 1.912, 1.912, 1.913, 1.914,
++                            1.915, 1.917, 1.917, 1.918, 1.919, 1.921, 1.922, 1.924, 1.926, 1.929, 1.934, 1.941, 1.946, 1.952, 1.955, 1.956, 1.955, 1.953, 1.947, 1.941, 1.933, 1.928, 1.922, 1.919, 1.916, 1.915, 1.913, 1.912, 1.912, 1.911, 1.913, 1.914,
++                            1.915, 1.916, 1.917, 1.919, 1.919, 1.921, 1.922, 1.924, 1.926, 1.931, 1.935, 1.941, 1.947, 1.952, 1.956, 1.956, 1.956, 1.953, 1.948, 1.941, 1.933, 1.928, 1.923, 1.919, 1.916, 1.914, 1.913, 1.911, 1.911, 1.911, 1.912, 1.914,
++                            1.915, 1.916, 1.917, 1.918, 1.919, 1.921, 1.922, 1.924, 1.927, 1.931, 1.935, 1.941, 1.947, 1.952, 1.956, 1.956, 1.956, 1.953, 1.948, 1.941, 1.933, 1.927, 1.922, 1.919, 1.917, 1.915, 1.913, 1.912, 1.911, 1.912, 1.912, 1.914,
++                            1.915, 1.915, 1.916, 1.917, 1.919, 1.921, 1.922, 1.925, 1.928, 1.931, 1.935, 1.941, 1.947, 1.952, 1.955, 1.956, 1.954, 1.951, 1.947, 1.941, 1.933, 1.927, 1.923, 1.919, 1.917, 1.914, 1.913, 1.911, 1.911, 1.912, 1.913, 1.913,
++                            1.915, 1.915, 1.916, 1.917, 1.918, 1.919, 1.922, 1.925, 1.928, 1.931, 1.935, 1.941, 1.946, 1.949, 1.953, 1.954, 1.951, 1.948, 1.945, 1.941, 1.933, 1.927, 1.923, 1.918, 1.917, 1.914, 1.912, 1.911, 1.911, 1.912, 1.913, 1.913,
++                            1.915, 1.916, 1.916, 1.917, 1.917, 1.919, 1.921, 1.924, 1.926, 1.929, 1.933, 1.938, 1.944, 1.946, 1.949, 1.949, 1.948, 1.946, 1.942, 1.937, 1.931, 1.924, 1.921, 1.918, 1.917, 1.913, 1.912, 1.911, 1.911, 1.911, 1.912, 1.912,
++                            1.915, 1.916, 1.916, 1.917, 1.917, 1.919, 1.921, 1.922, 1.924, 1.927, 1.931, 1.936, 1.938, 1.944, 1.944, 1.944, 1.944, 1.942, 1.938, 1.933, 1.926, 1.923, 1.919, 1.918, 1.915, 1.912, 1.911, 1.911, 1.911, 1.911, 1.912, 1.912,
++                            1.915, 1.916, 1.916, 1.917, 1.917, 1.919, 1.919, 1.921, 1.922, 1.926, 1.929, 1.931, 1.936, 1.938, 1.939, 1.941, 1.941, 1.938, 1.933, 1.929, 1.924, 1.921, 1.918, 1.916, 1.914, 1.912, 1.912, 1.911, 1.911, 1.911, 1.913, 1.913,
++                            1.915, 1.916, 1.917, 1.917, 1.916, 1.917, 1.918, 1.919, 1.921, 1.924, 1.927, 1.929, 1.932, 1.934, 1.936, 1.936, 1.935, 1.933, 1.929, 1.927, 1.922, 1.918, 1.916, 1.914, 1.913, 1.912, 1.912, 1.911, 1.912, 1.913, 1.914, 1.914,
++                            1.916, 1.917, 1.917, 1.917, 1.916, 1.915, 1.916, 1.918, 1.919, 1.922, 1.924, 1.927, 1.929, 1.931, 1.933, 1.933, 1.932, 1.929, 1.928, 1.925, 1.919, 1.917, 1.914, 1.913, 1.912, 1.912, 1.912, 1.912, 1.914, 1.914, 1.916, 1.916,
++                            1.916, 1.917, 1.917, 1.917, 1.915, 1.914, 1.915, 1.916, 1.917, 1.919, 1.921, 1.924, 1.926, 1.928, 1.929, 1.929, 1.929, 1.928, 1.925, 1.922, 1.919, 1.917, 1.914, 1.913, 1.912, 1.912, 1.912, 1.913, 1.915, 1.916, 1.917, 1.918,
++                            1.917, 1.917, 1.917, 1.916, 1.914, 1.913, 1.914, 1.914, 1.916, 1.917, 1.919, 1.921, 1.922, 1.924, 1.925, 1.926, 1.926, 1.925, 1.923, 1.919, 1.918, 1.915, 1.913, 1.913, 1.911, 1.911, 1.912, 1.915, 1.917, 1.917, 1.919, 1.921,
++                            1.917, 1.917, 1.917, 1.916, 1.914, 1.913, 1.913, 1.913, 1.913, 1.914, 1.917, 1.919, 1.921, 1.922, 1.922, 1.922, 1.922, 1.921, 1.919, 1.918, 1.916, 1.914, 1.913, 1.913, 1.912, 1.912, 1.914, 1.916, 1.917, 1.918, 1.921, 1.921,
++                            1.917, 1.918, 1.918, 1.917, 1.915, 1.913, 1.913, 1.912, 1.913, 1.913, 1.916, 1.918, 1.921, 1.921, 1.921, 1.921, 1.921, 1.919, 1.919, 1.918, 1.915, 1.914, 1.913, 1.913, 1.912, 1.914, 1.915, 1.917, 1.919, 1.921, 1.921, 1.923,
++                            1.917, 1.918, 1.919, 1.919, 1.917, 1.914, 1.914, 1.912, 1.913, 1.913, 1.915, 1.918, 1.919, 1.919, 1.921, 1.921, 1.919, 1.919, 1.919, 1.918, 1.916, 1.915, 1.914, 1.914, 1.914, 1.915, 1.917, 1.918, 1.919, 1.922, 1.923, 1.925,
++                            1.918, 1.921, 1.919, 1.919, 1.915, 1.914, 1.912, 1.911, 1.912, 1.913, 1.913, 1.915, 1.917, 1.918, 1.918, 1.919, 1.919, 1.918, 1.918, 1.918, 1.915, 1.915, 1.914, 1.914, 1.914, 1.915, 1.916, 1.918, 1.919, 1.921, 1.924, 1.926,
++                            1.921, 1.921, 1.919, 1.918, 1.914, 1.913, 1.911, 1.911, 1.911, 1.911, 1.911, 1.912, 1.912, 1.913, 1.913, 1.914, 1.914, 1.913, 1.912, 1.913, 1.913, 1.913, 1.913, 1.913, 1.912, 1.913, 1.915, 1.917, 1.918, 1.919, 1.923, 1.927,
++                            1.933, 1.924, 1.919, 1.914, 1.913, 1.913, 1.911, 1.909, 1.909, 1.909, 1.911, 1.911, 1.911, 1.911, 1.912, 1.912, 1.912, 1.911, 1.911, 1.911, 1.911, 1.911, 1.911, 1.911, 1.911, 1.912, 1.913, 1.916, 1.918, 1.919, 1.921, 1.927
++                        ]
++                    }
++                ],
++                "luminance_lut":
++                [
++                    3.676, 3.541, 3.263, 3.031, 2.824, 2.635, 2.471, 2.327, 2.204, 2.101, 2.018, 1.949, 1.913, 1.891, 1.879, 1.879, 1.879, 1.882, 1.898, 1.928, 1.979, 2.058, 2.149, 2.256, 2.389, 2.537, 2.712, 2.909, 3.124, 3.372, 3.676, 3.786,
++                    3.541, 3.353, 3.095, 2.871, 2.663, 2.481, 2.333, 2.219, 2.106, 2.018, 1.945, 1.882, 1.831, 1.793, 1.769, 1.762, 1.762, 1.777, 1.809, 1.854, 1.912, 1.979, 2.058, 2.155, 2.271, 2.391, 2.553, 2.745, 2.961, 3.196, 3.478, 3.676,
++                    3.364, 3.207, 2.959, 2.736, 2.535, 2.359, 2.219, 2.106, 2.018, 1.923, 1.846, 1.779, 1.726, 1.686, 1.661, 1.653, 1.653, 1.671, 1.702, 1.749, 1.809, 1.881, 1.964, 2.058, 2.155, 2.278, 2.429, 2.614, 2.828, 3.061, 3.324, 3.478,
++                    3.238, 3.078, 2.838, 2.614, 2.418, 2.259, 2.129, 2.021, 1.923, 1.834, 1.748, 1.678, 1.623, 1.584, 1.559, 1.549, 1.549, 1.567, 1.598, 1.646, 1.709, 1.783, 1.879, 1.964, 2.066, 2.183, 2.323, 2.494, 2.703, 2.933, 3.189, 3.333,
++                    3.132, 2.966, 2.725, 2.506, 2.319, 2.171, 2.048, 1.937, 1.834, 1.748, 1.654, 1.583, 1.528, 1.488, 1.463, 1.455, 1.455, 1.473, 1.505, 1.551, 1.613, 1.694, 1.783, 1.879, 1.986, 2.102, 2.232, 2.391, 2.589, 2.819, 3.072, 3.219,
++                    3.038, 2.863, 2.622, 2.411, 2.236, 2.095, 1.972, 1.858, 1.749, 1.654, 1.572, 1.495, 1.439, 1.402, 1.378, 1.371, 1.371, 1.388, 1.419, 1.465, 1.527, 1.613, 1.694, 1.798, 1.908, 2.027, 2.155, 2.303, 2.489, 2.714, 2.968, 3.119,
++                    2.951, 2.767, 2.531, 2.326, 2.163, 2.027, 1.901, 1.782, 1.671, 1.572, 1.495, 1.417, 1.363, 1.327, 1.303, 1.296, 1.296, 1.312, 1.342, 1.388, 1.452, 1.527, 1.616, 1.721, 1.835, 1.958, 2.086, 2.228, 2.402, 2.621, 2.872, 3.033,
++                    2.876, 2.683, 2.451, 2.255, 2.101, 1.965, 1.836, 1.712, 1.599, 1.499, 1.417, 1.354, 1.296, 1.259, 1.236, 1.231, 1.231, 1.246, 1.275, 1.319, 1.388, 1.452, 1.542, 1.649, 1.768, 1.895, 2.026, 2.165, 2.331, 2.538, 2.783, 2.956,
++                    2.809, 2.611, 2.383, 2.197, 2.044, 1.908, 1.777, 1.649, 1.536, 1.436, 1.354, 1.296, 1.237, 1.201, 1.179, 1.173, 1.173, 1.189, 1.218, 1.268, 1.319, 1.391, 1.479, 1.585, 1.706, 1.837, 1.971, 2.112, 2.269, 2.466, 2.707, 2.888,
++                    2.753, 2.546, 2.323, 2.147, 1.998, 1.858, 1.723, 1.596, 1.482, 1.384, 1.302, 1.237, 1.195, 1.153, 1.131, 1.124, 1.124, 1.141, 1.171, 1.218, 1.268, 1.339, 1.427, 1.531, 1.651, 1.784, 1.923, 2.065, 2.219, 2.406, 2.643, 2.829,
++                    2.705, 2.491, 2.276, 2.105, 1.956, 1.814, 1.677, 1.549, 1.436, 1.339, 1.259, 1.195, 1.153, 1.113, 1.091, 1.084, 1.084, 1.101, 1.137, 1.171, 1.226, 1.295, 1.381, 1.484, 1.604, 1.738, 1.882, 2.025, 2.176, 2.361, 2.587, 2.783,
++                    2.669, 2.446, 2.239, 2.072, 1.923, 1.777, 1.638, 1.511, 1.397, 1.303, 1.224, 1.162, 1.113, 1.086, 1.057, 1.052, 1.052, 1.069, 1.101, 1.137, 1.193, 1.261, 1.345, 1.448, 1.567, 1.701, 1.846, 1.992, 2.145, 2.323, 2.545, 2.747,
++                    2.642, 2.412, 2.209, 2.045, 1.895, 1.749, 1.608, 1.479, 1.369, 1.275, 1.197, 1.134, 1.086, 1.057, 1.034, 1.027, 1.027, 1.051, 1.069, 1.111, 1.166, 1.233, 1.318, 1.419, 1.537, 1.671, 1.816, 1.966, 2.119, 2.291, 2.509, 2.719,
++                    2.626, 2.389, 2.191, 2.026, 1.876, 1.727, 1.585, 1.457, 1.348, 1.254, 1.178, 1.116, 1.067, 1.034, 1.024, 1.012, 1.014, 1.027, 1.051, 1.092, 1.146, 1.214, 1.298, 1.398, 1.516, 1.651, 1.794, 1.945, 2.099, 2.271, 2.486, 2.703,
++                    2.619, 2.374, 2.177, 2.016, 1.864, 1.714, 1.572, 1.445, 1.335, 1.243, 1.166, 1.104, 1.056, 1.024, 1.011, 1.003, 1.009, 1.014, 1.039, 1.081, 1.135, 1.202, 1.286, 1.385, 1.502, 1.637, 1.783, 1.933, 2.088, 2.259, 2.469, 2.697,
++                    2.619, 2.372, 2.175, 2.013, 1.861, 1.711, 1.569, 1.442, 1.333, 1.241, 1.164, 1.102, 1.054, 1.021, 1.004, 1.001, 1.001, 1.011, 1.038, 1.079, 1.134, 1.202, 1.283, 1.383, 1.501, 1.633, 1.779, 1.931, 2.085, 2.256, 2.465, 2.697,
++                    2.619, 2.372, 2.175, 2.013, 1.861, 1.711, 1.569, 1.442, 1.333, 1.241, 1.164, 1.102, 1.054, 1.021, 1.004, 1.002, 1.002, 1.011, 1.038, 1.081, 1.135, 1.202, 1.283, 1.383, 1.501, 1.633, 1.779, 1.931, 2.085, 2.256, 2.465, 2.697,
++                    2.623, 2.385, 2.187, 2.022, 1.871, 1.722, 1.579, 1.452, 1.342, 1.251, 1.173, 1.111, 1.064, 1.031, 1.017, 1.005, 1.011, 1.021, 1.048, 1.089, 1.144, 1.211, 1.293, 1.394, 1.511, 1.644, 1.789, 1.941, 2.094, 2.265, 2.477, 2.699,
++                    2.636, 2.409, 2.207, 2.039, 1.888, 1.741, 1.601, 1.472, 1.361, 1.268, 1.191, 1.129, 1.081, 1.051, 1.031, 1.021, 1.021, 1.045, 1.064, 1.106, 1.161, 1.227, 1.311, 1.412, 1.529, 1.664, 1.808, 1.957, 2.109, 2.282, 2.499, 2.714,
++                    2.664, 2.441, 2.233, 2.066, 1.914, 1.769, 1.628, 1.499, 1.389, 1.294, 1.216, 1.153, 1.106, 1.081, 1.051, 1.045, 1.045, 1.064, 1.092, 1.131, 1.186, 1.254, 1.338, 1.441, 1.559, 1.693, 1.836, 1.985, 2.138, 2.313, 2.534, 2.739,
++                    2.697, 2.477, 2.265, 2.094, 1.943, 1.801, 1.662, 1.535, 1.422, 1.326, 1.247, 1.185, 1.141, 1.106, 1.081, 1.075, 1.075, 1.092, 1.129, 1.161, 1.217, 1.286, 1.371, 1.474, 1.594, 1.728, 1.869, 2.015, 2.168, 2.348, 2.573, 2.775,
++                    2.739, 2.528, 2.308, 2.133, 1.982, 1.842, 1.705, 1.579, 1.465, 1.368, 1.287, 1.224, 1.185, 1.141, 1.119, 1.114, 1.114, 1.129, 1.161, 1.205, 1.256, 1.327, 1.413, 1.519, 1.639, 1.772, 1.911, 2.054, 2.209, 2.394, 2.628, 2.818,
++                    2.793, 2.587, 2.361, 2.179, 2.028, 1.889, 1.757, 1.631, 1.517, 1.419, 1.337, 1.277, 1.224, 1.187, 1.165, 1.159, 1.159, 1.175, 1.205, 1.256, 1.304, 1.377, 1.465, 1.571, 1.691, 1.823, 1.959, 2.099, 2.258, 2.451, 2.693, 2.876,
++                    2.856, 2.661, 2.428, 2.239, 2.082, 1.946, 1.817, 1.693, 1.579, 1.479, 1.396, 1.337, 1.277, 1.241, 1.219, 1.214, 1.214, 1.231, 1.259, 1.304, 1.368, 1.436, 1.526, 1.634, 1.753, 1.883, 2.015, 2.154, 2.318, 2.523, 2.772, 2.943,
++                    2.931, 2.745, 2.505, 2.305, 2.144, 2.008, 1.882, 1.761, 1.648, 1.549, 1.471, 1.396, 1.342, 1.303, 1.281, 1.275, 1.275, 1.293, 1.323, 1.368, 1.436, 1.506, 1.595, 1.702, 1.821, 1.946, 2.075, 2.215, 2.388, 2.603, 2.857, 3.023,
++                    3.013, 2.842, 2.599, 2.387, 2.215, 2.076, 1.952, 1.836, 1.726, 1.627, 1.549, 1.471, 1.416, 1.377, 1.353, 1.347, 1.347, 1.365, 1.397, 1.444, 1.506, 1.593, 1.674, 1.779, 1.893, 2.014, 2.142, 2.289, 2.472, 2.696, 2.955, 3.108,
++                    3.107, 2.945, 2.699, 2.481, 2.296, 2.151, 2.027, 1.915, 1.808, 1.719, 1.627, 1.555, 1.501, 1.461, 1.435, 1.429, 1.429, 1.447, 1.479, 1.529, 1.593, 1.674, 1.761, 1.862, 1.971, 2.088, 2.219, 2.374, 2.568, 2.805, 3.064, 3.211,
++                    3.218, 3.058, 2.814, 2.589, 2.392, 2.235, 2.108, 1.997, 1.897, 1.808, 1.719, 1.649, 1.593, 1.553, 1.527, 1.521, 1.521, 1.539, 1.572, 1.622, 1.686, 1.761, 1.858, 1.947, 2.051, 2.168, 2.304, 2.474, 2.682, 2.923, 3.183, 3.327,
++                    3.342, 3.187, 2.939, 2.712, 2.506, 2.337, 2.198, 2.085, 1.995, 1.897, 1.818, 1.751, 1.695, 1.654, 1.629, 1.621, 1.621, 1.641, 1.674, 1.723, 1.786, 1.858, 1.947, 2.039, 2.139, 2.259, 2.408, 2.593, 2.807, 3.053, 3.319, 3.475,
++                    3.495, 3.329, 3.071, 2.845, 2.634, 2.455, 2.303, 2.185, 2.085, 1.995, 1.919, 1.855, 1.801, 1.763, 1.738, 1.731, 1.731, 1.749, 1.781, 1.828, 1.888, 1.959, 2.039, 2.139, 2.238, 2.367, 2.531, 2.728, 2.949, 3.195, 3.475, 3.658,
++                    3.669, 3.495, 3.218, 2.987, 2.776, 2.588, 2.426, 2.294, 2.185, 2.097, 2.024, 1.961, 1.911, 1.875, 1.851, 1.844, 1.844, 1.862, 1.893, 1.937, 1.995, 2.063, 2.142, 2.238, 2.352, 2.497, 2.675, 2.877, 3.101, 3.356, 3.658, 3.843,
++                    3.837, 3.669, 3.367, 3.123, 2.912, 2.721, 2.552, 2.407, 2.291, 2.185, 2.097, 2.024, 1.975, 1.954, 1.944, 1.944, 1.944, 1.946, 1.965, 1.995, 2.063, 2.142, 2.236, 2.345, 2.471, 2.628, 2.812, 3.018, 3.248, 3.517, 3.843, 3.988
++                ],
++                "sigma": 0.00072,
++                "sigma_Cb": 0.00079
++            }
++        },
++        {
++            "rpi.contrast":
++            {
++                "ce_enable": 1,
++                "gamma_curve":
++                [
++                    0, 0,
++                    1024, 5040,
++                    2048, 9338,
++                    3072, 12356,
++                    4096, 15312,
++                    5120, 18051,
++                    6144, 20790,
++                    7168, 23193,
++                    8192, 25744,
++                    9216, 27942,
++                    10240, 30035,
++                    11264, 32005,
++                    12288, 33975,
++                    13312, 35815,
++                    14336, 37600,
++                    15360, 39168,
++                    16384, 40642,
++                    18432, 43379,
++                    20480, 45749,
++                    22528, 47753,
++                    24576, 49621,
++                    26624, 51253,
++                    28672, 52698,
++                    30720, 53796,
++                    32768, 54876,
++                    36864, 57012,
++                    40960, 58656,
++                    45056, 59954,
++                    49152, 61183,
++                    53248, 62355,
++                    57344, 63419,
++                    61440, 64476,
++                    65535, 65535
++                ]
++            }
++        },
++        {
++            "rpi.ccm":
++            {
++                "ccms": [
++                    {
++                        "ct": 2800,
++                        "ccm":
++                        [
++                            1.60099, -0.27615, -0.32485,
++                            -0.36173, 1.73154, -0.36981,
++                            0.05061, -1.11212, 2.06152
++                        ]
++                    },
++                    {
++                        "ct": 2860,
++                        "ccm":
++                        [
++                            1.61273, -0.35631, -0.25641,
++                            -0.49273, 1.98065, -0.48793,
++                            -0.03047, -0.69949, 1.72997
++                        ]
++                    },
++                    {
++                        "ct": 2880,
++                        "ccm":
++                        [
++                            1.60615, -0.34009, -0.26606,
++                            -0.48642, 1.98548, -0.49906,
++                            -0.02324, -0.73793, 1.76117
++                        ]
++                    },
++                    {
++                        "ct": 3580,
++                        "ccm":
++                        [
++                            1.68146, -0.47435, -0.20711,
++                            -0.42387, 1.87351, -0.44963,
++                            -0.03582, -0.59119, 1.62701
++                        ]
++                    },
++                    {
++                        "ct": 3650,
++                        "ccm":
++                        [
++                            1.66879, -0.45734, -0.21146,
++                            -0.42285, 1.86266, -0.43981,
++                            -0.04212, -0.55689, 1.59902
++                        ]
++                    },
++                    {
++                        "ct": 4500,
++                        "ccm":
++                        [
++                            1.58737, -0.34781, -0.23956,
++                            -0.38604, 1.97168, -0.58564,
++                            -0.05469, -0.50253, 1.55722
++                        ]
++                    },
++                    {
++                        "ct": 4570,
++                        "ccm":
++                        [
++                            1.61538, -0.38095, -0.23443,
++                            -0.38067, 1.96743, -0.58675,
++                            -0.05282, -0.52277, 1.57559
++                        ]
++                    },
++                    {
++                        "ct": 5648,
++                        "ccm":
++                        [
++                            1.76567, -0.60063, -0.16504,
++                            -0.33153, 1.81445, -0.48292,
++                            -0.06404, -0.43593, 1.49997
++                        ]
++                    },
++                    {
++                        "ct": 5717,
++                        "ccm":
++                        [
++                            1.75403, -0.58859, -0.16543,
++                            -0.32727, 1.80986, -0.48259,
++                            -0.06479, -0.43555, 1.50035
++                        ]
++                    },
++                    {
++                        "ct": 7600,
++                        "ccm":
++                        [
++                            1.71011, -0.33715, -0.37296,
++                            -0.31253, 2.25037, -0.93784,
++                            -0.08325, -0.71623, 1.79948
++                        ]
++                    }
++                ]
++            }
++        },
++        {
++            "rpi.cac": { }
++        },
++        {
++            "rpi.sharpen":
++            {
++                "threshold": 0.25,
++                "limit": 1.0,
++                "strength": 1.0
++            }
++        },
++        {
++            "rpi.hdr":
++            {
++                "Off":
++                {
++                    "cadence": [ 0 ]
++                },
++                "MultiExposureUnmerged":
++                {
++                    "cadence": [ 1, 2 ],
++                    "channel_map":
++                    {
++                        "short": 1,
++                        "long": 2
++                    }
++                },
++                "SingleExposure":
++                {
++                    "cadence": [ 1 ],
++                    "channel_map":
++                    {
++                        "short": 1
++                    },
++                    "spatial_gain": 2.0,
++                    "tonemap_enable": 1
++                },
++                "MultiExposure":
++                {
++                    "cadence": [ 1, 2 ],
++                    "channel_map":
++                    {
++                        "short": 1,
++                        "long": 2
++                    },
++                    "stitch_enable": 1,
++                    "spatial_gain": 2.0,
++                    "tonemap_enable": 1
++                },
++                "Night":
++                {
++                    "cadence": [ 3 ],
++                    "channel_map":
++                    {
++                        "night": 3
++                    },
++                    "tonemap_enable": 1,
++                    "tonemap":
++                    [
++                        0, 0,
++                        5000, 20000,
++                        10000, 30000,
++                        20000, 47000,
++                        30000, 55000,
++                        65535, 65535
++                    ]
++                }
++            }
++        },
++        {
++            "rpi.sync":
++            {
++            }
++	    }
++    ]
++}
+\ No newline at end of file
+--- a/src/ipa/rpi/pisp/data/imx519.json	2025-05-08 00:06:16.067331148 +0530
++++ b/src/ipa/rpi/pisp/data/imx519.json	2025-05-08 00:06:16.054331350 +0530
+@@ -629,6 +629,11 @@
+         },
+         {
+             "rpi.sharpen": { }
++        },
++        {
++            "rpi.sync":
++            {
++            }
+         }
+     ]
+ }
+\ No newline at end of file
+--- a/src/ipa/rpi/pisp/data/ov9281_mono.json	2025-05-08 00:06:16.067331148 +0530
++++ b/src/ipa/rpi/pisp/data/ov9281_mono.json	2025-05-08 00:06:16.054331350 +0530
+@@ -210,6 +210,11 @@
+                     65535, 65535
+                 ]
+             }
++        },
++        {
++            "rpi.sync":
++            {
++            }
+         }
+     ]
+ }
+\ No newline at end of file
+--- a/src/ipa/rpi/pisp/data/se327m12.json	2025-05-08 00:06:16.067331148 +0530
++++ b/src/ipa/rpi/pisp/data/se327m12.json	2025-05-08 00:06:16.054331350 +0530
+@@ -634,6 +634,11 @@
+                 "strength": 0.5,
+                 "limit": 0.5
+             }
++        },
++        {
++            "rpi.sync":
++            {
++            }
+         }
+     ]
+ }
+\ No newline at end of file
+--- /dev/null	1970-01-01 00:00:00.000000000 +0000
++++ b/src/ipa/rpi/cam_helper/cam_helper_imx500.cpp	2025-05-08 00:06:16.054331350 +0530
+@@ -0,0 +1,330 @@
++/* SPDX-License-Identifier: BSD-2-Clause */
++/*
++ * Copyright (C) 2024, Raspberry Pi Ltd
++ *
++ * cam_helper_imx500.cpp - camera helper for imx500 sensor
++ */
++
++#include <algorithm>
++#include <assert.h>
++#include <cmath>
++#include <fstream>
++#include <memory>
++#include <stddef.h>
++#include <stdio.h>
++#include <stdlib.h>
++#include <string.h>
++
++#include <libcamera/base/log.h>
++#include <libcamera/base/span.h>
++
++#include <libcamera/control_ids.h>
++
++#include "imx500_tensor_parser/imx500_tensor_parser.h"
++
++#include "cam_helper.h"
++#include "md_parser.h"
++
++using namespace RPiController;
++using namespace libcamera;
++using libcamera::utils::Duration;
++
++namespace libcamera {
++LOG_DECLARE_CATEGORY(IPARPI)
++}
++
++/*
++ * We care about two gain registers and a pair of exposure registers. Their
++ * I2C addresses from the Sony IMX500 datasheet:
++ */
++constexpr uint32_t expHiReg = 0x0202;
++constexpr uint32_t expLoReg = 0x0203;
++constexpr uint32_t gainHiReg = 0x0204;
++constexpr uint32_t gainLoReg = 0x0205;
++constexpr uint32_t frameLengthHiReg = 0x0340;
++constexpr uint32_t frameLengthLoReg = 0x0341;
++constexpr uint32_t lineLengthHiReg = 0x0342;
++constexpr uint32_t lineLengthLoReg = 0x0343;
++constexpr uint32_t temperatureReg = 0x013a;
++constexpr std::initializer_list<uint32_t> registerList = { expHiReg, expLoReg, gainHiReg, gainLoReg, frameLengthHiReg, frameLengthLoReg,
++							   lineLengthHiReg, lineLengthLoReg, temperatureReg };
++
++class CamHelperImx500 : public CamHelper
++{
++public:
++	CamHelperImx500();
++	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;
++	std::pair<uint32_t, uint32_t> getBlanking(Duration &exposure, Duration minFrameDuration,
++						  Duration maxFrameDuration) const override;
++	bool sensorEmbeddedDataPresent() const override;
++
++private:
++	/*
++	 * Smallest difference between the frame length and integration time,
++	 * in units of lines.
++	 */
++	static constexpr int frameIntegrationDiff = 22;
++	/* Maximum frame length allowable for long exposure calculations. */
++	static constexpr int frameLengthMax = 0xffdc;
++	/* Largest long exposure scale factor given as a left shift on the frame length. */
++	static constexpr int longExposureShiftMax = 7;
++
++	void parseInferenceData(libcamera::Span<const uint8_t> buffer, Metadata &metadata);
++	void populateMetadata(const MdParser::RegisterMap &registers,
++			      Metadata &metadata) const override;
++
++	std::unique_ptr<uint8_t[]> savedInputTensor_;
++};
++
++CamHelperImx500::CamHelperImx500()
++	: CamHelper(std::make_unique<MdParserSmia>(registerList), frameIntegrationDiff)
++{
++}
++
++uint32_t CamHelperImx500::gainCode(double gain) const
++{
++	return static_cast<uint32_t>(1024 - 1024 / gain);
++}
++
++double CamHelperImx500::gain(uint32_t gainCode) const
++{
++	return 1024.0 / (1024 - gainCode);
++}
++
++void CamHelperImx500::prepare(libcamera::Span<const uint8_t> buffer, Metadata &metadata)
++{
++	MdParser::RegisterMap registers;
++	DeviceStatus deviceStatus;
++
++	if (metadata.get("device.status", deviceStatus)) {
++		LOG(IPARPI, Error) << "DeviceStatus not found from DelayedControls";
++		return;
++	}
++
++	parseEmbeddedData(buffer, metadata);
++
++	/*
++	 * The DeviceStatus struct is first populated with values obtained from
++	 * DelayedControls. If this reports frame length is > frameLengthMax,
++	 * it means we are using a long exposure mode. Since the long exposure
++	 * scale factor is not returned back through embedded data, we must rely
++	 * on the existing exposure lines and frame length values returned by
++	 * DelayedControls.
++	 *
++	 * Otherwise, all values are updated with what is reported in the
++	 * embedded data.
++	 */
++	if (deviceStatus.frameLength > frameLengthMax) {
++		DeviceStatus parsedDeviceStatus;
++
++		metadata.get("device.status", parsedDeviceStatus);
++		parsedDeviceStatus.exposureTime = deviceStatus.exposureTime;
++		parsedDeviceStatus.frameLength = deviceStatus.frameLength;
++		metadata.set("device.status", parsedDeviceStatus);
++
++		LOG(IPARPI, Debug) << "Metadata updated for long exposure: "
++				   << parsedDeviceStatus;
++	}
++
++	parseInferenceData(buffer, metadata);
++}
++
++std::pair<uint32_t, uint32_t> CamHelperImx500::getBlanking(Duration &exposure,
++							   Duration minFrameDuration,
++							   Duration maxFrameDuration) const
++{
++	uint32_t frameLength, exposureLines;
++	unsigned int shift = 0;
++
++	auto [vblank, hblank] = CamHelper::getBlanking(exposure, minFrameDuration,
++						       maxFrameDuration);
++
++	frameLength = mode_.height + vblank;
++	Duration lineLength = hblankToLineLength(hblank);
++
++	/*
++	 * Check if the frame length calculated needs to be setup for long
++	 * exposure mode. This will require us to use a long exposure scale
++	 * factor provided by a shift operation in the sensor.
++	 */
++	while (frameLength > frameLengthMax) {
++		if (++shift > longExposureShiftMax) {
++			shift = longExposureShiftMax;
++			frameLength = frameLengthMax;
++			break;
++		}
++		frameLength >>= 1;
++	}
++
++	if (shift) {
++		/* Account for any rounding in the scaled frame length value. */
++		frameLength <<= shift;
++		exposureLines = CamHelperImx500::exposureLines(exposure, lineLength);
++		exposureLines = std::min(exposureLines, frameLength - frameIntegrationDiff);
++		exposure = CamHelperImx500::exposure(exposureLines, lineLength);
++	}
++
++	return { frameLength - mode_.height, hblank };
++}
++
++bool CamHelperImx500::sensorEmbeddedDataPresent() const
++{
++	return true;
++}
++
++void CamHelperImx500::parseInferenceData(libcamera::Span<const uint8_t> buffer,
++					 Metadata &metadata)
++{
++	/* Inference data comes after 2 lines of embedded data. */
++	constexpr unsigned int StartLine = 2;
++	size_t bytesPerLine = (mode_.width * mode_.bitdepth) >> 3;
++	if (hwConfig_.dataBufferStrided)
++		bytesPerLine = (bytesPerLine + 15) & ~15;
++
++	if (buffer.size() <= StartLine * bytesPerLine)
++		return;
++
++	/* Check if an input tensor is needed - this is sticky! */
++	bool enableInputTensor = false;
++	metadata.get("cnn.enable_input_tensor", enableInputTensor);
++
++	/* Cache the DNN metadata for fast parsing. */
++	unsigned int tensorBufferSize = buffer.size() - (StartLine * bytesPerLine);
++	std::unique_ptr<uint8_t[]> cache = std::make_unique<uint8_t[]>(tensorBufferSize);
++	memcpy(cache.get(), buffer.data() + StartLine * bytesPerLine, tensorBufferSize);
++	Span<const uint8_t> tensors(cache.get(), tensorBufferSize);
++
++	std::unordered_map<TensorType, IMX500Tensors> offsets = RPiController::imx500SplitTensors(tensors);
++	auto itIn = offsets.find(TensorType::InputTensor);
++	auto itOut = offsets.find(TensorType::OutputTensor);
++
++	if (itIn != offsets.end() && itOut != offsets.end()) {
++		const unsigned int inputTensorOffset = itIn->second.offset;
++		const unsigned int outputTensorOffset = itOut->second.offset;
++		const unsigned int inputTensorSize = outputTensorOffset - inputTensorOffset;
++		Span<const uint8_t> inputTensor;
++
++		if (itIn->second.valid) {
++			if (itOut->second.valid) {
++				/* Valid input and output tensor, get the span directly from the current cache. */
++				inputTensor = Span<const uint8_t>(cache.get() + inputTensorOffset,
++								  inputTensorSize);
++			} else {
++				/*
++				 * Invalid output tensor with valid input tensor.
++				 * This is likely because the DNN takes longer than
++				 * a frame time to generate the output tensor.
++				 *
++				 * In such cases, we don't process the input tensor,
++				 * but simply save it for when the next output
++				 * tensor is valid. This way, we ensure that both
++				 * valid input and output tensors are in lock-step.
++				 */
++				savedInputTensor_ = std::make_unique<uint8_t[]>(inputTensorSize);
++				memcpy(savedInputTensor_.get(), cache.get() + inputTensorOffset,
++				       inputTensorSize);
++			}
++		} else if (itOut->second.valid && savedInputTensor_) {
++			/*
++			 * Invalid input tensor with valid output tensor. This is
++			 * likely because the DNN takes longer than a frame time
++			 * to generate the output tensor.
++			 *
++			 * In such cases, use the previously saved input tensor
++			 * if possible.
++			 */
++			inputTensor = Span<const uint8_t>(savedInputTensor_.get(), inputTensorSize);
++		}
++
++		if (inputTensor.size()) {
++			IMX500InputTensorInfo inputTensorInfo;
++			if (!imx500ParseInputTensor(inputTensorInfo, inputTensor)) {
++				CnnInputTensorInfo exported{};
++				exported.width = inputTensorInfo.width;
++				exported.height = inputTensorInfo.height;
++				exported.numChannels = inputTensorInfo.channels;
++				strncpy(exported.networkName, inputTensorInfo.networkName.c_str(),
++					sizeof(exported.networkName));
++				exported.networkName[sizeof(exported.networkName) - 1] = '\0';
++				metadata.set("cnn.input_tensor_info", exported);
++				metadata.set("cnn.input_tensor", std::move(inputTensorInfo.data));
++				metadata.set("cnn.input_tensor_size", inputTensorInfo.size);
++			}
++
++			/* We can now safely clear the saved input tensor. */
++			savedInputTensor_.reset();
++		}
++	}
++
++	if (itOut != offsets.end() && itOut->second.valid) {
++		unsigned int outputTensorOffset = itOut->second.offset;
++		Span<const uint8_t> outputTensor(cache.get() + outputTensorOffset,
++						 tensorBufferSize - outputTensorOffset);
++
++		IMX500OutputTensorInfo outputTensorInfo;
++		if (!imx500ParseOutputTensor(outputTensorInfo, outputTensor)) {
++			CnnOutputTensorInfo exported{};
++			if (outputTensorInfo.numTensors < MaxNumTensors) {
++				exported.numTensors = outputTensorInfo.numTensors;
++				for (unsigned int i = 0; i < exported.numTensors; i++) {
++					exported.info[i].tensorDataNum = outputTensorInfo.tensorDataNum[i];
++					exported.info[i].numDimensions = outputTensorInfo.numDimensions[i];
++					for (unsigned int j = 0; j < exported.info[i].numDimensions; j++)
++						exported.info[i].size[j] = outputTensorInfo.vecDim[i][j].size;
++				}
++			} else {
++				LOG(IPARPI, Debug)
++					<< "IMX500 output tensor info export failed, numTensors > MaxNumTensors";
++			}
++			strncpy(exported.networkName, outputTensorInfo.networkName.c_str(),
++				sizeof(exported.networkName));
++			exported.networkName[sizeof(exported.networkName) - 1] = '\0';
++			metadata.set("cnn.output_tensor_info", exported);
++			metadata.set("cnn.output_tensor", std::move(outputTensorInfo.data));
++			metadata.set("cnn.output_tensor_size", outputTensorInfo.totalSize);
++
++			auto itKpi = offsets.find(TensorType::Kpi);
++			if (itKpi != offsets.end()) {
++				constexpr unsigned int DnnRuntimeOffset = 9;
++				constexpr unsigned int DspRuntimeOffset = 10;
++				CnnKpiInfo kpi;
++
++				uint8_t *k = cache.get() + itKpi->second.offset;
++				kpi.dnnRuntime = k[4 * DnnRuntimeOffset + 3] << 24 |
++						 k[4 * DnnRuntimeOffset + 2] << 16 |
++						 k[4 * DnnRuntimeOffset + 1] << 8 |
++						 k[4 * DnnRuntimeOffset];
++				kpi.dspRuntime = k[4 * DspRuntimeOffset + 3] << 24 |
++						 k[4 * DspRuntimeOffset + 2] << 16 |
++						 k[4 * DspRuntimeOffset + 1] << 8 |
++						 k[4 * DspRuntimeOffset];
++				metadata.set("cnn.kpi_info", kpi);
++			}
++		}
++	}
++}
++
++void CamHelperImx500::populateMetadata(const MdParser::RegisterMap &registers,
++				       Metadata &metadata) const
++{
++	DeviceStatus deviceStatus;
++
++	deviceStatus.lineLength = lineLengthPckToDuration(registers.at(lineLengthHiReg) * 256 +
++							  registers.at(lineLengthLoReg));
++	deviceStatus.exposureTime = exposure(registers.at(expHiReg) * 256 + registers.at(expLoReg),
++					     deviceStatus.lineLength);
++	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);
++}
++
++static CamHelper *create()
++{
++	return new CamHelperImx500();
++}
++
++static RegisterCamHelper reg_imx500("imx500", &create);
+\ No newline at end of file
+--- /dev/null	1970-01-01 00:00:00.000000000 +0000
++++ b/src/ipa/rpi/cam_helper/imx500_tensor_parser/apParams.flatbuffers_generated.h	2025-05-08 00:06:16.055331334 +0530
+@@ -0,0 +1,544 @@
++// automatically generated by the FlatBuffers compiler, do not modify
++
++
++#ifndef FLATBUFFERS_GENERATED_APPARAMSFLATBUFFERS_APPARAMS_FB_H_
++#define FLATBUFFERS_GENERATED_APPARAMSFLATBUFFERS_APPARAMS_FB_H_
++
++#include "flatbuffers/flatbuffers.h"
++
++namespace apParams {
++namespace fb {
++
++struct FBDimension;
++
++struct FBInputTensor;
++
++struct FBOutputTensor;
++
++struct FBNetwork;
++
++struct FBApParams;
++
++struct FBDimension FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
++  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
++    VT_ID = 4,
++    VT_SIZE = 6,
++    VT_SERIALIZATIONINDEX = 8,
++    VT_PADDING = 10
++  };
++  uint8_t id() const {
++    return GetField<uint8_t>(VT_ID, 0);
++  }
++  uint16_t size() const {
++    return GetField<uint16_t>(VT_SIZE, 0);
++  }
++  uint8_t serializationIndex() const {
++    return GetField<uint8_t>(VT_SERIALIZATIONINDEX, 0);
++  }
++  uint8_t padding() const {
++    return GetField<uint8_t>(VT_PADDING, 0);
++  }
++  bool Verify(flatbuffers::Verifier &verifier) const {
++    return VerifyTableStart(verifier) &&
++           VerifyField<uint8_t>(verifier, VT_ID) &&
++           VerifyField<uint16_t>(verifier, VT_SIZE) &&
++           VerifyField<uint8_t>(verifier, VT_SERIALIZATIONINDEX) &&
++           VerifyField<uint8_t>(verifier, VT_PADDING) &&
++           verifier.EndTable();
++  }
++};
++
++struct FBDimensionBuilder {
++  flatbuffers::FlatBufferBuilder &fbb_;
++  flatbuffers::uoffset_t start_;
++  void add_id(uint8_t id) {
++    fbb_.AddElement<uint8_t>(FBDimension::VT_ID, id, 0);
++  }
++  void add_size(uint16_t size) {
++    fbb_.AddElement<uint16_t>(FBDimension::VT_SIZE, size, 0);
++  }
++  void add_serializationIndex(uint8_t serializationIndex) {
++    fbb_.AddElement<uint8_t>(FBDimension::VT_SERIALIZATIONINDEX, serializationIndex, 0);
++  }
++  void add_padding(uint8_t padding) {
++    fbb_.AddElement<uint8_t>(FBDimension::VT_PADDING, padding, 0);
++  }
++  explicit FBDimensionBuilder(flatbuffers::FlatBufferBuilder &_fbb)
++        : fbb_(_fbb) {
++    start_ = fbb_.StartTable();
++  }
++  FBDimensionBuilder &operator=(const FBDimensionBuilder &);
++  flatbuffers::Offset<FBDimension> Finish() {
++    const auto end = fbb_.EndTable(start_);
++    auto o = flatbuffers::Offset<FBDimension>(end);
++    return o;
++  }
++};
++
++inline flatbuffers::Offset<FBDimension> CreateFBDimension(
++    flatbuffers::FlatBufferBuilder &_fbb,
++    uint8_t id = 0,
++    uint16_t size = 0,
++    uint8_t serializationIndex = 0,
++    uint8_t padding = 0) {
++  FBDimensionBuilder builder_(_fbb);
++  builder_.add_size(size);
++  builder_.add_padding(padding);
++  builder_.add_serializationIndex(serializationIndex);
++  builder_.add_id(id);
++  return builder_.Finish();
++}
++
++struct FBInputTensor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
++  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
++    VT_ID = 4,
++    VT_NAME = 6,
++    VT_NUMOFDIMENSIONS = 8,
++    VT_DIMENSIONS = 10,
++    VT_SHIFT = 12,
++    VT_SCALE = 14,
++    VT_FORMAT = 16
++  };
++  uint8_t id() const {
++    return GetField<uint8_t>(VT_ID, 0);
++  }
++  const flatbuffers::String *name() const {
++    return GetPointer<const flatbuffers::String *>(VT_NAME);
++  }
++  uint8_t numOfDimensions() const {
++    return GetField<uint8_t>(VT_NUMOFDIMENSIONS, 0);
++  }
++  const flatbuffers::Vector<flatbuffers::Offset<FBDimension>> *dimensions() const {
++    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<FBDimension>> *>(VT_DIMENSIONS);
++  }
++  uint16_t shift() const {
++    return GetField<uint16_t>(VT_SHIFT, 0);
++  }
++  float scale() const {
++    return GetField<float>(VT_SCALE, 0.0f);
++  }
++  uint8_t format() const {
++    return GetField<uint8_t>(VT_FORMAT, 0);
++  }
++  bool Verify(flatbuffers::Verifier &verifier) const {
++    return VerifyTableStart(verifier) &&
++           VerifyField<uint8_t>(verifier, VT_ID) &&
++           VerifyOffset(verifier, VT_NAME) &&
++           verifier.VerifyString(name()) &&
++           VerifyField<uint8_t>(verifier, VT_NUMOFDIMENSIONS) &&
++           VerifyOffset(verifier, VT_DIMENSIONS) &&
++           verifier.VerifyVector(dimensions()) &&
++           verifier.VerifyVectorOfTables(dimensions()) &&
++           VerifyField<uint16_t>(verifier, VT_SHIFT) &&
++           VerifyField<float>(verifier, VT_SCALE) &&
++           VerifyField<uint8_t>(verifier, VT_FORMAT) &&
++           verifier.EndTable();
++  }
++};
++
++struct FBInputTensorBuilder {
++  flatbuffers::FlatBufferBuilder &fbb_;
++  flatbuffers::uoffset_t start_;
++  void add_id(uint8_t id) {
++    fbb_.AddElement<uint8_t>(FBInputTensor::VT_ID, id, 0);
++  }
++  void add_name(flatbuffers::Offset<flatbuffers::String> name) {
++    fbb_.AddOffset(FBInputTensor::VT_NAME, name);
++  }
++  void add_numOfDimensions(uint8_t numOfDimensions) {
++    fbb_.AddElement<uint8_t>(FBInputTensor::VT_NUMOFDIMENSIONS, numOfDimensions, 0);
++  }
++  void add_dimensions(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<FBDimension>>> dimensions) {
++    fbb_.AddOffset(FBInputTensor::VT_DIMENSIONS, dimensions);
++  }
++  void add_shift(uint16_t shift) {
++    fbb_.AddElement<uint16_t>(FBInputTensor::VT_SHIFT, shift, 0);
++  }
++  void add_scale(float scale) {
++    fbb_.AddElement<float>(FBInputTensor::VT_SCALE, scale, 0.0f);
++  }
++  void add_format(uint8_t format) {
++    fbb_.AddElement<uint8_t>(FBInputTensor::VT_FORMAT, format, 0);
++  }
++  explicit FBInputTensorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
++        : fbb_(_fbb) {
++    start_ = fbb_.StartTable();
++  }
++  FBInputTensorBuilder &operator=(const FBInputTensorBuilder &);
++  flatbuffers::Offset<FBInputTensor> Finish() {
++    const auto end = fbb_.EndTable(start_);
++    auto o = flatbuffers::Offset<FBInputTensor>(end);
++    return o;
++  }
++};
++
++inline flatbuffers::Offset<FBInputTensor> CreateFBInputTensor(
++    flatbuffers::FlatBufferBuilder &_fbb,
++    uint8_t id = 0,
++    flatbuffers::Offset<flatbuffers::String> name = 0,
++    uint8_t numOfDimensions = 0,
++    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<FBDimension>>> dimensions = 0,
++    uint16_t shift = 0,
++    float scale = 0.0f,
++    uint8_t format = 0) {
++  FBInputTensorBuilder builder_(_fbb);
++  builder_.add_scale(scale);
++  builder_.add_dimensions(dimensions);
++  builder_.add_name(name);
++  builder_.add_shift(shift);
++  builder_.add_format(format);
++  builder_.add_numOfDimensions(numOfDimensions);
++  builder_.add_id(id);
++  return builder_.Finish();
++}
++
++inline flatbuffers::Offset<FBInputTensor> CreateFBInputTensorDirect(
++    flatbuffers::FlatBufferBuilder &_fbb,
++    uint8_t id = 0,
++    const char *name = nullptr,
++    uint8_t numOfDimensions = 0,
++    const std::vector<flatbuffers::Offset<FBDimension>> *dimensions = nullptr,
++    uint16_t shift = 0,
++    float scale = 0.0f,
++    uint8_t format = 0) {
++  auto name__ = name ? _fbb.CreateString(name) : 0;
++  auto dimensions__ = dimensions ? _fbb.CreateVector<flatbuffers::Offset<FBDimension>>(*dimensions) : 0;
++  return apParams::fb::CreateFBInputTensor(
++      _fbb,
++      id,
++      name__,
++      numOfDimensions,
++      dimensions__,
++      shift,
++      scale,
++      format);
++}
++
++struct FBOutputTensor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
++  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
++    VT_ID = 4,
++    VT_NAME = 6,
++    VT_NUMOFDIMENSIONS = 8,
++    VT_DIMENSIONS = 10,
++    VT_BITSPERELEMENT = 12,
++    VT_SHIFT = 14,
++    VT_SCALE = 16,
++    VT_FORMAT = 18
++  };
++  uint8_t id() const {
++    return GetField<uint8_t>(VT_ID, 0);
++  }
++  const flatbuffers::String *name() const {
++    return GetPointer<const flatbuffers::String *>(VT_NAME);
++  }
++  uint8_t numOfDimensions() const {
++    return GetField<uint8_t>(VT_NUMOFDIMENSIONS, 0);
++  }
++  const flatbuffers::Vector<flatbuffers::Offset<FBDimension>> *dimensions() const {
++    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<FBDimension>> *>(VT_DIMENSIONS);
++  }
++  uint8_t bitsPerElement() const {
++    return GetField<uint8_t>(VT_BITSPERELEMENT, 0);
++  }
++  uint16_t shift() const {
++    return GetField<uint16_t>(VT_SHIFT, 0);
++  }
++  float scale() const {
++    return GetField<float>(VT_SCALE, 0.0f);
++  }
++  uint8_t format() const {
++    return GetField<uint8_t>(VT_FORMAT, 0);
++  }
++  bool Verify(flatbuffers::Verifier &verifier) const {
++    return VerifyTableStart(verifier) &&
++           VerifyField<uint8_t>(verifier, VT_ID) &&
++           VerifyOffset(verifier, VT_NAME) &&
++           verifier.VerifyString(name()) &&
++           VerifyField<uint8_t>(verifier, VT_NUMOFDIMENSIONS) &&
++           VerifyOffset(verifier, VT_DIMENSIONS) &&
++           verifier.VerifyVector(dimensions()) &&
++           verifier.VerifyVectorOfTables(dimensions()) &&
++           VerifyField<uint8_t>(verifier, VT_BITSPERELEMENT) &&
++           VerifyField<uint16_t>(verifier, VT_SHIFT) &&
++           VerifyField<float>(verifier, VT_SCALE) &&
++           VerifyField<uint8_t>(verifier, VT_FORMAT) &&
++           verifier.EndTable();
++  }
++};
++
++struct FBOutputTensorBuilder {
++  flatbuffers::FlatBufferBuilder &fbb_;
++  flatbuffers::uoffset_t start_;
++  void add_id(uint8_t id) {
++    fbb_.AddElement<uint8_t>(FBOutputTensor::VT_ID, id, 0);
++  }
++  void add_name(flatbuffers::Offset<flatbuffers::String> name) {
++    fbb_.AddOffset(FBOutputTensor::VT_NAME, name);
++  }
++  void add_numOfDimensions(uint8_t numOfDimensions) {
++    fbb_.AddElement<uint8_t>(FBOutputTensor::VT_NUMOFDIMENSIONS, numOfDimensions, 0);
++  }
++  void add_dimensions(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<FBDimension>>> dimensions) {
++    fbb_.AddOffset(FBOutputTensor::VT_DIMENSIONS, dimensions);
++  }
++  void add_bitsPerElement(uint8_t bitsPerElement) {
++    fbb_.AddElement<uint8_t>(FBOutputTensor::VT_BITSPERELEMENT, bitsPerElement, 0);
++  }
++  void add_shift(uint16_t shift) {
++    fbb_.AddElement<uint16_t>(FBOutputTensor::VT_SHIFT, shift, 0);
++  }
++  void add_scale(float scale) {
++    fbb_.AddElement<float>(FBOutputTensor::VT_SCALE, scale, 0.0f);
++  }
++  void add_format(uint8_t format) {
++    fbb_.AddElement<uint8_t>(FBOutputTensor::VT_FORMAT, format, 0);
++  }
++  explicit FBOutputTensorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
++        : fbb_(_fbb) {
++    start_ = fbb_.StartTable();
++  }
++  FBOutputTensorBuilder &operator=(const FBOutputTensorBuilder &);
++  flatbuffers::Offset<FBOutputTensor> Finish() {
++    const auto end = fbb_.EndTable(start_);
++    auto o = flatbuffers::Offset<FBOutputTensor>(end);
++    return o;
++  }
++};
++
++inline flatbuffers::Offset<FBOutputTensor> CreateFBOutputTensor(
++    flatbuffers::FlatBufferBuilder &_fbb,
++    uint8_t id = 0,
++    flatbuffers::Offset<flatbuffers::String> name = 0,
++    uint8_t numOfDimensions = 0,
++    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<FBDimension>>> dimensions = 0,
++    uint8_t bitsPerElement = 0,
++    uint16_t shift = 0,
++    float scale = 0.0f,
++    uint8_t format = 0) {
++  FBOutputTensorBuilder builder_(_fbb);
++  builder_.add_scale(scale);
++  builder_.add_dimensions(dimensions);
++  builder_.add_name(name);
++  builder_.add_shift(shift);
++  builder_.add_format(format);
++  builder_.add_bitsPerElement(bitsPerElement);
++  builder_.add_numOfDimensions(numOfDimensions);
++  builder_.add_id(id);
++  return builder_.Finish();
++}
++
++inline flatbuffers::Offset<FBOutputTensor> CreateFBOutputTensorDirect(
++    flatbuffers::FlatBufferBuilder &_fbb,
++    uint8_t id = 0,
++    const char *name = nullptr,
++    uint8_t numOfDimensions = 0,
++    const std::vector<flatbuffers::Offset<FBDimension>> *dimensions = nullptr,
++    uint8_t bitsPerElement = 0,
++    uint16_t shift = 0,
++    float scale = 0.0f,
++    uint8_t format = 0) {
++  auto name__ = name ? _fbb.CreateString(name) : 0;
++  auto dimensions__ = dimensions ? _fbb.CreateVector<flatbuffers::Offset<FBDimension>>(*dimensions) : 0;
++  return apParams::fb::CreateFBOutputTensor(
++      _fbb,
++      id,
++      name__,
++      numOfDimensions,
++      dimensions__,
++      bitsPerElement,
++      shift,
++      scale,
++      format);
++}
++
++struct FBNetwork FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
++  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
++    VT_ID = 4,
++    VT_NAME = 6,
++    VT_TYPE = 8,
++    VT_INPUTTENSORS = 10,
++    VT_OUTPUTTENSORS = 12
++  };
++  uint16_t id() const {
++    return GetField<uint16_t>(VT_ID, 0);
++  }
++  const flatbuffers::String *name() const {
++    return GetPointer<const flatbuffers::String *>(VT_NAME);
++  }
++  const flatbuffers::String *type() const {
++    return GetPointer<const flatbuffers::String *>(VT_TYPE);
++  }
++  const flatbuffers::Vector<flatbuffers::Offset<FBInputTensor>> *inputTensors() const {
++    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<FBInputTensor>> *>(VT_INPUTTENSORS);
++  }
++  const flatbuffers::Vector<flatbuffers::Offset<FBOutputTensor>> *outputTensors() const {
++    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<FBOutputTensor>> *>(VT_OUTPUTTENSORS);
++  }
++  bool Verify(flatbuffers::Verifier &verifier) const {
++    return VerifyTableStart(verifier) &&
++           VerifyField<uint16_t>(verifier, VT_ID) &&
++           VerifyOffset(verifier, VT_NAME) &&
++           verifier.VerifyString(name()) &&
++           VerifyOffset(verifier, VT_TYPE) &&
++           verifier.VerifyString(type()) &&
++           VerifyOffset(verifier, VT_INPUTTENSORS) &&
++           verifier.VerifyVector(inputTensors()) &&
++           verifier.VerifyVectorOfTables(inputTensors()) &&
++           VerifyOffset(verifier, VT_OUTPUTTENSORS) &&
++           verifier.VerifyVector(outputTensors()) &&
++           verifier.VerifyVectorOfTables(outputTensors()) &&
++           verifier.EndTable();
++  }
++};
++
++struct FBNetworkBuilder {
++  flatbuffers::FlatBufferBuilder &fbb_;
++  flatbuffers::uoffset_t start_;
++  void add_id(uint16_t id) {
++    fbb_.AddElement<uint16_t>(FBNetwork::VT_ID, id, 0);
++  }
++  void add_name(flatbuffers::Offset<flatbuffers::String> name) {
++    fbb_.AddOffset(FBNetwork::VT_NAME, name);
++  }
++  void add_type(flatbuffers::Offset<flatbuffers::String> type) {
++    fbb_.AddOffset(FBNetwork::VT_TYPE, type);
++  }
++  void add_inputTensors(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<FBInputTensor>>> inputTensors) {
++    fbb_.AddOffset(FBNetwork::VT_INPUTTENSORS, inputTensors);
++  }
++  void add_outputTensors(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<FBOutputTensor>>> outputTensors) {
++    fbb_.AddOffset(FBNetwork::VT_OUTPUTTENSORS, outputTensors);
++  }
++  explicit FBNetworkBuilder(flatbuffers::FlatBufferBuilder &_fbb)
++        : fbb_(_fbb) {
++    start_ = fbb_.StartTable();
++  }
++  FBNetworkBuilder &operator=(const FBNetworkBuilder &);
++  flatbuffers::Offset<FBNetwork> Finish() {
++    const auto end = fbb_.EndTable(start_);
++    auto o = flatbuffers::Offset<FBNetwork>(end);
++    return o;
++  }
++};
++
++inline flatbuffers::Offset<FBNetwork> CreateFBNetwork(
++    flatbuffers::FlatBufferBuilder &_fbb,
++    uint16_t id = 0,
++    flatbuffers::Offset<flatbuffers::String> name = 0,
++    flatbuffers::Offset<flatbuffers::String> type = 0,
++    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<FBInputTensor>>> inputTensors = 0,
++    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<FBOutputTensor>>> outputTensors = 0) {
++  FBNetworkBuilder builder_(_fbb);
++  builder_.add_outputTensors(outputTensors);
++  builder_.add_inputTensors(inputTensors);
++  builder_.add_type(type);
++  builder_.add_name(name);
++  builder_.add_id(id);
++  return builder_.Finish();
++}
++
++inline flatbuffers::Offset<FBNetwork> CreateFBNetworkDirect(
++    flatbuffers::FlatBufferBuilder &_fbb,
++    uint16_t id = 0,
++    const char *name = nullptr,
++    const char *type = nullptr,
++    const std::vector<flatbuffers::Offset<FBInputTensor>> *inputTensors = nullptr,
++    const std::vector<flatbuffers::Offset<FBOutputTensor>> *outputTensors = nullptr) {
++  auto name__ = name ? _fbb.CreateString(name) : 0;
++  auto type__ = type ? _fbb.CreateString(type) : 0;
++  auto inputTensors__ = inputTensors ? _fbb.CreateVector<flatbuffers::Offset<FBInputTensor>>(*inputTensors) : 0;
++  auto outputTensors__ = outputTensors ? _fbb.CreateVector<flatbuffers::Offset<FBOutputTensor>>(*outputTensors) : 0;
++  return apParams::fb::CreateFBNetwork(
++      _fbb,
++      id,
++      name__,
++      type__,
++      inputTensors__,
++      outputTensors__);
++}
++
++struct FBApParams FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
++  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
++    VT_NETWORKS = 4
++  };
++  const flatbuffers::Vector<flatbuffers::Offset<FBNetwork>> *networks() const {
++    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<FBNetwork>> *>(VT_NETWORKS);
++  }
++  bool Verify(flatbuffers::Verifier &verifier) const {
++    return VerifyTableStart(verifier) &&
++           VerifyOffset(verifier, VT_NETWORKS) &&
++           verifier.VerifyVector(networks()) &&
++           verifier.VerifyVectorOfTables(networks()) &&
++           verifier.EndTable();
++  }
++};
++
++struct FBApParamsBuilder {
++  flatbuffers::FlatBufferBuilder &fbb_;
++  flatbuffers::uoffset_t start_;
++  void add_networks(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<FBNetwork>>> networks) {
++    fbb_.AddOffset(FBApParams::VT_NETWORKS, networks);
++  }
++  explicit FBApParamsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
++        : fbb_(_fbb) {
++    start_ = fbb_.StartTable();
++  }
++  FBApParamsBuilder &operator=(const FBApParamsBuilder &);
++  flatbuffers::Offset<FBApParams> Finish() {
++    const auto end = fbb_.EndTable(start_);
++    auto o = flatbuffers::Offset<FBApParams>(end);
++    return o;
++  }
++};
++
++inline flatbuffers::Offset<FBApParams> CreateFBApParams(
++    flatbuffers::FlatBufferBuilder &_fbb,
++    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<FBNetwork>>> networks = 0) {
++  FBApParamsBuilder builder_(_fbb);
++  builder_.add_networks(networks);
++  return builder_.Finish();
++}
++
++inline flatbuffers::Offset<FBApParams> CreateFBApParamsDirect(
++    flatbuffers::FlatBufferBuilder &_fbb,
++    const std::vector<flatbuffers::Offset<FBNetwork>> *networks = nullptr) {
++  auto networks__ = networks ? _fbb.CreateVector<flatbuffers::Offset<FBNetwork>>(*networks) : 0;
++  return apParams::fb::CreateFBApParams(
++      _fbb,
++      networks__);
++}
++
++inline const apParams::fb::FBApParams *GetFBApParams(const void *buf) {
++  return flatbuffers::GetRoot<apParams::fb::FBApParams>(buf);
++}
++
++inline const apParams::fb::FBApParams *GetSizePrefixedFBApParams(const void *buf) {
++  return flatbuffers::GetSizePrefixedRoot<apParams::fb::FBApParams>(buf);
++}
++
++inline bool VerifyFBApParamsBuffer(
++    flatbuffers::Verifier &verifier) {
++  return verifier.VerifyBuffer<apParams::fb::FBApParams>(nullptr);
++}
++
++inline bool VerifySizePrefixedFBApParamsBuffer(
++    flatbuffers::Verifier &verifier) {
++  return verifier.VerifySizePrefixedBuffer<apParams::fb::FBApParams>(nullptr);
++}
++
++inline void FinishFBApParamsBuffer(
++    flatbuffers::FlatBufferBuilder &fbb,
++    flatbuffers::Offset<apParams::fb::FBApParams> root) {
++  fbb.Finish(root);
++}
++
++inline void FinishSizePrefixedFBApParamsBuffer(
++    flatbuffers::FlatBufferBuilder &fbb,
++    flatbuffers::Offset<apParams::fb::FBApParams> root) {
++  fbb.FinishSizePrefixed(root);
++}
++
++}  // namespace fb
++}  // namespace apParams
++
++#endif  // FLATBUFFERS_GENERATED_APPARAMSFLATBUFFERS_APPARAMS_FB_H_
+\ No newline at end of file
+--- /dev/null	1970-01-01 00:00:00.000000000 +0000
++++ b/src/ipa/rpi/cam_helper/imx500_tensor_parser/flatbuffers/base.h	2025-05-08 00:06:16.055331334 +0530
+@@ -0,0 +1,379 @@
++#ifndef FLATBUFFERS_BASE_H_
++#define FLATBUFFERS_BASE_H_
++
++// clang-format off
++
++// If activate should be declared and included first.
++#if defined(FLATBUFFERS_MEMORY_LEAK_TRACKING) && \
++    defined(_MSC_VER) && defined(_DEBUG)
++  // The _CRTDBG_MAP_ALLOC inside <crtdbg.h> will replace
++  // calloc/free (etc) to its debug version using #define directives.
++  #define _CRTDBG_MAP_ALLOC
++  #include <stdlib.h>
++  #include <crtdbg.h>
++  // Replace operator new by trace-enabled version.
++  #define DEBUG_NEW new(_NORMAL_BLOCK, __FILE__, __LINE__)
++  #define new DEBUG_NEW
++#endif
++
++#if !defined(FLATBUFFERS_ASSERT)
++#include <assert.h>
++#define FLATBUFFERS_ASSERT assert
++#elif defined(FLATBUFFERS_ASSERT_INCLUDE)
++// Include file with forward declaration
++#include FLATBUFFERS_ASSERT_INCLUDE
++#endif
++
++#ifndef ARDUINO
++#include <cstdint>
++#endif
++
++#include <cstddef>
++#include <cstdlib>
++#include <cstring>
++
++#if defined(ARDUINO) && !defined(ARDUINOSTL_M_H)
++  #include <utility.h>
++#else
++  #include <utility>
++#endif
++
++#include <string>
++#include <type_traits>
++#include <vector>
++#include <set>
++#include <algorithm>
++#include <iterator>
++#include <memory>
++
++#ifdef _STLPORT_VERSION
++  #define FLATBUFFERS_CPP98_STL
++#endif
++#ifndef FLATBUFFERS_CPP98_STL
++  #include <functional>
++#endif
++
++#include "stl_emulation.h"
++
++// Note the __clang__ check is needed, because clang presents itself
++// as an older GNUC compiler (4.2).
++// Clang 3.3 and later implement all of the ISO C++ 2011 standard.
++// Clang 3.4 and later implement all of the ISO C++ 2014 standard.
++// http://clang.llvm.org/cxx_status.html
++
++// Note the MSVC value '__cplusplus' may be incorrect:
++// The '__cplusplus' predefined macro in the MSVC stuck at the value 199711L,
++// indicating (erroneously!) that the compiler conformed to the C++98 Standard.
++// This value should be correct starting from MSVC2017-15.7-Preview-3.
++// The '__cplusplus' will be valid only if MSVC2017-15.7-P3 and the `/Zc:__cplusplus` switch is set.
++// Workaround (for details see MSDN):
++// Use the _MSC_VER and _MSVC_LANG definition instead of the __cplusplus  for compatibility.
++// The _MSVC_LANG macro reports the Standard version regardless of the '/Zc:__cplusplus' switch.
++
++#if defined(__GNUC__) && !defined(__clang__)
++  #define FLATBUFFERS_GCC (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
++#else
++  #define FLATBUFFERS_GCC 0
++#endif
++
++#if defined(__clang__)
++  #define FLATBUFFERS_CLANG (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__)
++#else
++  #define FLATBUFFERS_CLANG 0
++#endif
++
++/// @cond FLATBUFFERS_INTERNAL
++#if __cplusplus <= 199711L && \
++    (!defined(_MSC_VER) || _MSC_VER < 1600) && \
++    (!defined(__GNUC__) || \
++      (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__ < 40400))
++  #error A C++11 compatible compiler with support for the auto typing is \
++         required for FlatBuffers.
++  #error __cplusplus _MSC_VER __GNUC__  __GNUC_MINOR__  __GNUC_PATCHLEVEL__
++#endif
++
++#if !defined(__clang__) && \
++    defined(__GNUC__) && \
++    (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__ < 40600)
++  // Backwards compatability for g++ 4.4, and 4.5 which don't have the nullptr
++  // and constexpr keywords. Note the __clang__ check is needed, because clang
++  // presents itself as an older GNUC compiler.
++  #ifndef nullptr_t
++    const class nullptr_t {
++    public:
++      template<class T> inline operator T*() const { return 0; }
++    private:
++      void operator&() const;
++    } nullptr = {};
++  #endif
++  #ifndef constexpr
++    #define constexpr const
++  #endif
++#endif
++
++// The wire format uses a little endian encoding (since that's efficient for
++// the common platforms).
++#if defined(__s390x__)
++  #define FLATBUFFERS_LITTLEENDIAN 0
++#endif // __s390x__
++#if !defined(FLATBUFFERS_LITTLEENDIAN)
++  #if defined(__GNUC__) || defined(__clang__)
++    #if (defined(__BIG_ENDIAN__) || \
++         (defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__))
++      #define FLATBUFFERS_LITTLEENDIAN 0
++    #else
++      #define FLATBUFFERS_LITTLEENDIAN 1
++    #endif // __BIG_ENDIAN__
++  #elif defined(_MSC_VER)
++    #if defined(_M_PPC)
++      #define FLATBUFFERS_LITTLEENDIAN 0
++    #else
++      #define FLATBUFFERS_LITTLEENDIAN 1
++    #endif
++  #else
++    #error Unable to determine endianness, define FLATBUFFERS_LITTLEENDIAN.
++  #endif
++#endif // !defined(FLATBUFFERS_LITTLEENDIAN)
++
++#define FLATBUFFERS_VERSION_MAJOR 1
++#define FLATBUFFERS_VERSION_MINOR 11
++#define FLATBUFFERS_VERSION_REVISION 0
++#define FLATBUFFERS_STRING_EXPAND(X) #X
++#define FLATBUFFERS_STRING(X) FLATBUFFERS_STRING_EXPAND(X)
++
++#if (!defined(_MSC_VER) || _MSC_VER > 1600) && \
++    (!defined(__GNUC__) || (__GNUC__ * 100 + __GNUC_MINOR__ >= 407)) || \
++    defined(__clang__)
++  #define FLATBUFFERS_FINAL_CLASS final
++  #define FLATBUFFERS_OVERRIDE override
++  #define FLATBUFFERS_VTABLE_UNDERLYING_TYPE : flatbuffers::voffset_t
++#else
++  #define FLATBUFFERS_FINAL_CLASS
++  #define FLATBUFFERS_OVERRIDE
++  #define FLATBUFFERS_VTABLE_UNDERLYING_TYPE
++#endif
++
++#if (!defined(_MSC_VER) || _MSC_VER >= 1900) && \
++    (!defined(__GNUC__) || (__GNUC__ * 100 + __GNUC_MINOR__ >= 406)) || \
++    (defined(__cpp_constexpr) && __cpp_constexpr >= 200704)
++  #define FLATBUFFERS_CONSTEXPR constexpr
++#else
++  #define FLATBUFFERS_CONSTEXPR const
++#endif
++
++#if (defined(__cplusplus) && __cplusplus >= 201402L) || \
++    (defined(__cpp_constexpr) && __cpp_constexpr >= 201304)
++  #define FLATBUFFERS_CONSTEXPR_CPP14 FLATBUFFERS_CONSTEXPR
++#else
++  #define FLATBUFFERS_CONSTEXPR_CPP14
++#endif
++
++#if (defined(__GXX_EXPERIMENTAL_CXX0X__) && (__GNUC__ * 100 + __GNUC_MINOR__ >= 406)) || \
++    (defined(_MSC_FULL_VER) && (_MSC_FULL_VER >= 190023026)) || \
++    defined(__clang__)
++  #define FLATBUFFERS_NOEXCEPT noexcept
++#else
++  #define FLATBUFFERS_NOEXCEPT
++#endif
++
++// NOTE: the FLATBUFFERS_DELETE_FUNC macro may change the access mode to
++// private, so be sure to put it at the end or reset access mode explicitly.
++#if (!defined(_MSC_VER) || _MSC_FULL_VER >= 180020827) && \
++    (!defined(__GNUC__) || (__GNUC__ * 100 + __GNUC_MINOR__ >= 404)) || \
++    defined(__clang__)
++  #define FLATBUFFERS_DELETE_FUNC(func) func = delete;
++#else
++  #define FLATBUFFERS_DELETE_FUNC(func) private: func;
++#endif
++
++#ifndef FLATBUFFERS_HAS_STRING_VIEW
++  // Only provide flatbuffers::string_view if __has_include can be used
++  // to detect a header that provides an implementation
++  #if defined(__has_include)
++    // Check for std::string_view (in c++17)
++    #if __has_include(<string_view>) && (__cplusplus >= 201606 || _HAS_CXX17)
++      #include <string_view>
++      namespace flatbuffers {
++        typedef std::string_view string_view;
++      }
++      #define FLATBUFFERS_HAS_STRING_VIEW 1
++    // Check for std::experimental::string_view (in c++14, compiler-dependent)
++    #elif __has_include(<experimental/string_view>) && (__cplusplus >= 201411)
++      #include <experimental/string_view>
++      namespace flatbuffers {
++        typedef std::experimental::string_view string_view;
++      }
++      #define FLATBUFFERS_HAS_STRING_VIEW 1
++    #endif
++  #endif // __has_include
++#endif // !FLATBUFFERS_HAS_STRING_VIEW
++
++#ifndef FLATBUFFERS_HAS_NEW_STRTOD
++  // Modern (C++11) strtod and strtof functions are available for use.
++  // 1) nan/inf strings as argument of strtod;
++  // 2) hex-float  as argument of  strtod/strtof.
++  #if (defined(_MSC_VER) && _MSC_VER >= 1900) || \
++      (defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ >= 409)) || \
++      (defined(__clang__))
++    #define FLATBUFFERS_HAS_NEW_STRTOD 1
++  #endif
++#endif // !FLATBUFFERS_HAS_NEW_STRTOD
++
++#ifndef FLATBUFFERS_LOCALE_INDEPENDENT
++  // Enable locale independent functions {strtof_l, strtod_l,strtoll_l, strtoull_l}.
++  // They are part of the POSIX-2008 but not part of the C/C++ standard.
++  // GCC/Clang have definition (_XOPEN_SOURCE>=700) if POSIX-2008.
++  #if ((defined(_MSC_VER) && _MSC_VER >= 1800)            || \
++       (defined(_XOPEN_SOURCE) && (_XOPEN_SOURCE>=700)))
++    #define FLATBUFFERS_LOCALE_INDEPENDENT 1
++  #else
++    #define FLATBUFFERS_LOCALE_INDEPENDENT 0
++  #endif
++#endif  // !FLATBUFFERS_LOCALE_INDEPENDENT
++
++// Suppress Undefined Behavior Sanitizer (recoverable only). Usage:
++// - __supress_ubsan__("undefined")
++// - __supress_ubsan__("signed-integer-overflow")
++#if defined(__clang__)
++  #define __supress_ubsan__(type) __attribute__((no_sanitize(type)))
++#elif defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ >= 409)
++  #define __supress_ubsan__(type) __attribute__((no_sanitize_undefined))
++#else
++  #define __supress_ubsan__(type)
++#endif
++
++// This is constexpr function used for checking compile-time constants.
++// Avoid `#pragma warning(disable: 4127) // C4127: expression is constant`.
++template<typename T> FLATBUFFERS_CONSTEXPR inline bool IsConstTrue(T t) {
++  return !!t;
++}
++
++// Enable C++ attribute [[]] if std:c++17 or higher.
++#if ((__cplusplus >= 201703L) \
++    || (defined(_MSVC_LANG) &&  (_MSVC_LANG >= 201703L)))
++  // All attributes unknown to an implementation are ignored without causing an error.
++  #define FLATBUFFERS_ATTRIBUTE(attr) [[attr]]
++
++  #define FLATBUFFERS_FALLTHROUGH() [[fallthrough]]
++#else
++  #define FLATBUFFERS_ATTRIBUTE(attr)
++
++  #if FLATBUFFERS_CLANG >= 30800
++    #define FLATBUFFERS_FALLTHROUGH() [[clang::fallthrough]]
++  #elif FLATBUFFERS_GCC >= 70300
++    #define FLATBUFFERS_FALLTHROUGH() [[gnu::fallthrough]]
++  #else
++    #define FLATBUFFERS_FALLTHROUGH()
++  #endif
++#endif
++
++/// @endcond
++
++/// @file
++namespace flatbuffers {
++
++/// @cond FLATBUFFERS_INTERNAL
++// Our default offset / size type, 32bit on purpose on 64bit systems.
++// Also, using a consistent offset type maintains compatibility of serialized
++// offset values between 32bit and 64bit systems.
++typedef uint32_t uoffset_t;
++
++// Signed offsets for references that can go in both directions.
++typedef int32_t soffset_t;
++
++// Offset/index used in v-tables, can be changed to uint8_t in
++// format forks to save a bit of space if desired.
++typedef uint16_t voffset_t;
++
++typedef uintmax_t largest_scalar_t;
++
++// In 32bits, this evaluates to 2GB - 1
++#define FLATBUFFERS_MAX_BUFFER_SIZE ((1ULL << (sizeof(soffset_t) * 8 - 1)) - 1)
++
++// We support aligning the contents of buffers up to this size.
++#define FLATBUFFERS_MAX_ALIGNMENT 16
++
++#if defined(_MSC_VER)
++  #pragma warning(push)
++  #pragma warning(disable: 4127) // C4127: conditional expression is constant
++#endif
++
++template<typename T> T EndianSwap(T t) {
++  #if defined(_MSC_VER)
++    #define FLATBUFFERS_BYTESWAP16 _byteswap_ushort
++    #define FLATBUFFERS_BYTESWAP32 _byteswap_ulong
++    #define FLATBUFFERS_BYTESWAP64 _byteswap_uint64
++  #else
++    #if defined(__GNUC__) && __GNUC__ * 100 + __GNUC_MINOR__ < 408 && !defined(__clang__)
++      // __builtin_bswap16 was missing prior to GCC 4.8.
++      #define FLATBUFFERS_BYTESWAP16(x) \
++        static_cast<uint16_t>(__builtin_bswap32(static_cast<uint32_t>(x) << 16))
++    #else
++      #define FLATBUFFERS_BYTESWAP16 __builtin_bswap16
++    #endif
++    #define FLATBUFFERS_BYTESWAP32 __builtin_bswap32
++    #define FLATBUFFERS_BYTESWAP64 __builtin_bswap64
++  #endif
++  if (sizeof(T) == 1) {   // Compile-time if-then's.
++    return t;
++  } else if (sizeof(T) == 2) {
++    union { T t; uint16_t i; } u;
++    u.t = t;
++    u.i = FLATBUFFERS_BYTESWAP16(u.i);
++    return u.t;
++  } else if (sizeof(T) == 4) {
++    union { T t; uint32_t i; } u;
++    u.t = t;
++    u.i = FLATBUFFERS_BYTESWAP32(u.i);
++    return u.t;
++  } else if (sizeof(T) == 8) {
++    union { T t; uint64_t i; } u;
++    u.t = t;
++    u.i = FLATBUFFERS_BYTESWAP64(u.i);
++    return u.t;
++  } else {
++    FLATBUFFERS_ASSERT(0);
++  }
++}
++
++#if defined(_MSC_VER)
++  #pragma warning(pop)
++#endif
++
++
++template<typename T> T EndianScalar(T t) {
++  #if FLATBUFFERS_LITTLEENDIAN
++    return t;
++  #else
++    return EndianSwap(t);
++  #endif
++}
++
++template<typename T>
++// UBSAN: C++ aliasing type rules, see std::bit_cast<> for details.
++__supress_ubsan__("alignment")
++T ReadScalar(const void *p) {
++  return EndianScalar(*reinterpret_cast<const T *>(p));
++}
++
++template<typename T>
++// UBSAN: C++ aliasing type rules, see std::bit_cast<> for details.
++__supress_ubsan__("alignment")
++void WriteScalar(void *p, T t) {
++  *reinterpret_cast<T *>(p) = EndianScalar(t);
++}
++
++template<typename T> struct Offset;
++template<typename T> __supress_ubsan__("alignment") void WriteScalar(void *p, Offset<T> t) {
++  *reinterpret_cast<uoffset_t *>(p) = EndianScalar(t.o);
++}
++
++// Computes how many bytes you'd have to pad to be able to write an
++// "scalar_size" scalar if the buffer had grown to "buf_size" (downwards in
++// memory).
++inline size_t PaddingBytes(size_t buf_size, size_t scalar_size) {
++  return ((~buf_size) + 1) & (scalar_size - 1);
++}
++
++}  // namespace flatbuffers
++#endif  // FLATBUFFERS_BASE_H_
+\ No newline at end of file
+--- /dev/null	1970-01-01 00:00:00.000000000 +0000
++++ b/src/ipa/rpi/cam_helper/imx500_tensor_parser/flatbuffers/code_generators.h	2025-05-08 00:06:16.055331334 +0530
+@@ -0,0 +1,203 @@
++/*
++ * Copyright 2014 Google Inc. All rights reserved.
++ *
++ * Licensed under the Apache License, Version 2.0 (the "License");
++ * you may not use this file except in compliance with the License.
++ * You may obtain a copy of the License at
++ *
++ *     http://www.apache.org/licenses/LICENSE-2.0
++ *
++ * Unless required by applicable law or agreed to in writing, software
++ * distributed under the License is distributed on an "AS IS" BASIS,
++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
++ * See the License for the specific language governing permissions and
++ * limitations under the License.
++ */
++
++#ifndef FLATBUFFERS_CODE_GENERATORS_H_
++#define FLATBUFFERS_CODE_GENERATORS_H_
++
++#include <map>
++#include <sstream>
++#include "flatbuffers/idl.h"
++
++namespace flatbuffers {
++
++// Utility class to assist in generating code through use of text templates.
++//
++// Example code:
++//   CodeWriter code;
++//   code.SetValue("NAME", "Foo");
++//   code += "void {{NAME}}() { printf("%s", "{{NAME}}"); }";
++//   code.SetValue("NAME", "Bar");
++//   code += "void {{NAME}}() { printf("%s", "{{NAME}}"); }";
++//   std::cout << code.ToString() << std::endl;
++//
++// Output:
++//  void Foo() { printf("%s", "Foo"); }
++//  void Bar() { printf("%s", "Bar"); }
++class CodeWriter {
++ public:
++  CodeWriter() {}
++
++  // Clears the current "written" code.
++  void Clear() {
++    stream_.str("");
++    stream_.clear();
++  }
++
++  // Associates a key with a value.  All subsequent calls to operator+=, where
++  // the specified key is contained in {{ and }} delimiters will be replaced by
++  // the given value.
++  void SetValue(const std::string &key, const std::string &value) {
++    value_map_[key] = value;
++  }
++
++  // Appends the given text to the generated code as well as a newline
++  // character.  Any text within {{ and }} delimeters is replaced by values
++  // previously stored in the CodeWriter by calling SetValue above.  The newline
++  // will be suppressed if the text ends with the \\ character.
++  void operator+=(std::string text);
++
++  // Returns the current contents of the CodeWriter as a std::string.
++  std::string ToString() const { return stream_.str(); }
++
++ private:
++  std::map<std::string, std::string> value_map_;
++  std::stringstream stream_;
++};
++
++class BaseGenerator {
++ public:
++  virtual bool generate() = 0;
++
++  static std::string NamespaceDir(const Parser &parser, const std::string &path,
++                                  const Namespace &ns);
++
++ protected:
++  BaseGenerator(const Parser &parser, const std::string &path,
++                const std::string &file_name,
++                const std::string qualifying_start,
++                const std::string qualifying_separator)
++      : parser_(parser),
++        path_(path),
++        file_name_(file_name),
++        qualifying_start_(qualifying_start),
++        qualifying_separator_(qualifying_separator) {}
++  virtual ~BaseGenerator() {}
++
++  // No copy/assign.
++  BaseGenerator &operator=(const BaseGenerator &);
++  BaseGenerator(const BaseGenerator &);
++
++  std::string NamespaceDir(const Namespace &ns) const;
++
++  static const char *FlatBuffersGeneratedWarning();
++
++  static std::string FullNamespace(const char *separator, const Namespace &ns);
++
++  static std::string LastNamespacePart(const Namespace &ns);
++
++  // tracks the current namespace for early exit in WrapInNameSpace
++  // c++, java and csharp returns a different namespace from
++  // the following default (no early exit, always fully qualify),
++  // which works for js and php
++  virtual const Namespace *CurrentNameSpace() const { return nullptr; }
++
++  // Ensure that a type is prefixed with its namespace whenever it is used
++  // outside of its namespace.
++  std::string WrapInNameSpace(const Namespace *ns,
++                              const std::string &name) const;
++
++  std::string WrapInNameSpace(const Definition &def) const;
++
++  std::string GetNameSpace(const Definition &def) const;
++
++  const Parser &parser_;
++  const std::string &path_;
++  const std::string &file_name_;
++  const std::string qualifying_start_;
++  const std::string qualifying_separator_;
++};
++
++struct CommentConfig {
++  const char *first_line;
++  const char *content_line_prefix;
++  const char *last_line;
++};
++
++extern void GenComment(const std::vector<std::string> &dc,
++                       std::string *code_ptr, const CommentConfig *config,
++                       const char *prefix = "");
++
++class FloatConstantGenerator {
++ public:
++  virtual ~FloatConstantGenerator() {}
++  std::string GenFloatConstant(const FieldDef &field) const;
++
++ private:
++  virtual std::string Value(double v, const std::string &src) const = 0;
++  virtual std::string Inf(double v) const = 0;
++  virtual std::string NaN(double v) const = 0;
++
++  virtual std::string Value(float v, const std::string &src) const = 0;
++  virtual std::string Inf(float v) const = 0;
++  virtual std::string NaN(float v) const = 0;
++
++  template<typename T>
++  std::string GenFloatConstantImpl(const FieldDef &field) const;
++};
++
++class SimpleFloatConstantGenerator : public FloatConstantGenerator {
++ public:
++  SimpleFloatConstantGenerator(const char *nan_number,
++                               const char *pos_inf_number,
++                               const char *neg_inf_number);
++
++ private:
++  std::string Value(double v,
++                    const std::string &src) const FLATBUFFERS_OVERRIDE;
++  std::string Inf(double v) const FLATBUFFERS_OVERRIDE;
++  std::string NaN(double v) const FLATBUFFERS_OVERRIDE;
++
++  std::string Value(float v, const std::string &src) const FLATBUFFERS_OVERRIDE;
++  std::string Inf(float v) const FLATBUFFERS_OVERRIDE;
++  std::string NaN(float v) const FLATBUFFERS_OVERRIDE;
++
++  const std::string nan_number_;
++  const std::string pos_inf_number_;
++  const std::string neg_inf_number_;
++};
++
++// C++, C#, Java like generator.
++class TypedFloatConstantGenerator : public FloatConstantGenerator {
++ public:
++  TypedFloatConstantGenerator(const char *double_prefix,
++                              const char *single_prefix, const char *nan_number,
++                              const char *pos_inf_number,
++                              const char *neg_inf_number = "");
++
++ private:
++  std::string Value(double v,
++                    const std::string &src) const FLATBUFFERS_OVERRIDE;
++  std::string Inf(double v) const FLATBUFFERS_OVERRIDE;
++
++  std::string NaN(double v) const FLATBUFFERS_OVERRIDE;
++
++  std::string Value(float v, const std::string &src) const FLATBUFFERS_OVERRIDE;
++  std::string Inf(float v) const FLATBUFFERS_OVERRIDE;
++  std::string NaN(float v) const FLATBUFFERS_OVERRIDE;
++
++  std::string MakeNaN(const std::string &prefix) const;
++  std::string MakeInf(bool neg, const std::string &prefix) const;
++
++  const std::string double_prefix_;
++  const std::string single_prefix_;
++  const std::string nan_number_;
++  const std::string pos_inf_number_;
++  const std::string neg_inf_number_;
++};
++
++}  // namespace flatbuffers
++
++#endif  // FLATBUFFERS_CODE_GENERATORS_H_
+--- /dev/null	1970-01-01 00:00:00.000000000 +0000
++++ b/src/ipa/rpi/cam_helper/imx500_tensor_parser/flatbuffers/flatbuffers.h	2025-05-08 00:06:16.056331319 +0530
+@@ -0,0 +1,2613 @@
++/*
++ * Copyright 2014 Google Inc. All rights reserved.
++ *
++ * Licensed under the Apache License, Version 2.0 (the "License");
++ * you may not use this file except in compliance with the License.
++ * You may obtain a copy of the License at
++ *
++ *     http://www.apache.org/licenses/LICENSE-2.0
++ *
++ * Unless required by applicable law or agreed to in writing, software
++ * distributed under the License is distributed on an "AS IS" BASIS,
++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
++ * See the License for the specific language governing permissions and
++ * limitations under the License.
++ */
++
++#ifndef FLATBUFFERS_H_
++#define FLATBUFFERS_H_
++
++#include "base.h"
++
++#if defined(FLATBUFFERS_NAN_DEFAULTS)
++#include <cmath>
++#endif
++
++namespace flatbuffers {
++// Generic 'operator==' with conditional specialisations.
++template<typename T> inline bool IsTheSameAs(T e, T def) { return e == def; }
++
++#if defined(FLATBUFFERS_NAN_DEFAULTS) && \
++    (!defined(_MSC_VER) || _MSC_VER >= 1800)
++// Like `operator==(e, def)` with weak NaN if T=(float|double).
++template<> inline bool IsTheSameAs<float>(float e, float def) {
++  return (e == def) || (std::isnan(def) && std::isnan(e));
++}
++template<> inline bool IsTheSameAs<double>(double e, double def) {
++  return (e == def) || (std::isnan(def) && std::isnan(e));
++}
++#endif
++
++// Wrapper for uoffset_t to allow safe template specialization.
++// Value is allowed to be 0 to indicate a null object (see e.g. AddOffset).
++template<typename T> struct Offset {
++  uoffset_t o;
++  Offset() : o(0) {}
++  Offset(uoffset_t _o) : o(_o) {}
++  Offset<void> Union() const { return Offset<void>(o); }
++  bool IsNull() const { return !o; }
++};
++
++inline void EndianCheck() {
++  int endiantest = 1;
++  // If this fails, see FLATBUFFERS_LITTLEENDIAN above.
++  FLATBUFFERS_ASSERT(*reinterpret_cast<char *>(&endiantest) ==
++                     FLATBUFFERS_LITTLEENDIAN);
++  (void)endiantest;
++}
++
++template<typename T> FLATBUFFERS_CONSTEXPR size_t AlignOf() {
++  // clang-format off
++  #ifdef _MSC_VER
++    return __alignof(T);
++  #else
++    #ifndef alignof
++      return __alignof__(T);
++    #else
++      return alignof(T);
++    #endif
++  #endif
++  // clang-format on
++}
++
++// When we read serialized data from memory, in the case of most scalars,
++// we want to just read T, but in the case of Offset, we want to actually
++// perform the indirection and return a pointer.
++// The template specialization below does just that.
++// It is wrapped in a struct since function templates can't overload on the
++// return type like this.
++// The typedef is for the convenience of callers of this function
++// (avoiding the need for a trailing return decltype)
++template<typename T> struct IndirectHelper {
++  typedef T return_type;
++  typedef T mutable_return_type;
++  static const size_t element_stride = sizeof(T);
++  static return_type Read(const uint8_t *p, uoffset_t i) {
++    return EndianScalar((reinterpret_cast<const T *>(p))[i]);
++  }
++};
++template<typename T> struct IndirectHelper<Offset<T>> {
++  typedef const T *return_type;
++  typedef T *mutable_return_type;
++  static const size_t element_stride = sizeof(uoffset_t);
++  static return_type Read(const uint8_t *p, uoffset_t i) {
++    p += i * sizeof(uoffset_t);
++    return reinterpret_cast<return_type>(p + ReadScalar<uoffset_t>(p));
++  }
++};
++template<typename T> struct IndirectHelper<const T *> {
++  typedef const T *return_type;
++  typedef T *mutable_return_type;
++  static const size_t element_stride = sizeof(T);
++  static return_type Read(const uint8_t *p, uoffset_t i) {
++    return reinterpret_cast<const T *>(p + i * sizeof(T));
++  }
++};
++
++// An STL compatible iterator implementation for Vector below, effectively
++// calling Get() for every element.
++template<typename T, typename IT> struct VectorIterator {
++  typedef std::random_access_iterator_tag iterator_category;
++  typedef IT value_type;
++  typedef ptrdiff_t difference_type;
++  typedef IT *pointer;
++  typedef IT &reference;
++
++  VectorIterator(const uint8_t *data, uoffset_t i)
++      : data_(data + IndirectHelper<T>::element_stride * i) {}
++  VectorIterator(const VectorIterator &other) : data_(other.data_) {}
++  VectorIterator() : data_(nullptr) {}
++
++  VectorIterator &operator=(const VectorIterator &other) {
++    data_ = other.data_;
++    return *this;
++  }
++
++  // clang-format off
++  #if !defined(FLATBUFFERS_CPP98_STL)
++  VectorIterator &operator=(VectorIterator &&other) {
++    data_ = other.data_;
++    return *this;
++  }
++  #endif  // !defined(FLATBUFFERS_CPP98_STL)
++  // clang-format on
++
++  bool operator==(const VectorIterator &other) const {
++    return data_ == other.data_;
++  }
++
++  bool operator<(const VectorIterator &other) const {
++    return data_ < other.data_;
++  }
++
++  bool operator!=(const VectorIterator &other) const {
++    return data_ != other.data_;
++  }
++
++  difference_type operator-(const VectorIterator &other) const {
++    return (data_ - other.data_) / IndirectHelper<T>::element_stride;
++  }
++
++  IT operator*() const { return IndirectHelper<T>::Read(data_, 0); }
++
++  IT operator->() const { return IndirectHelper<T>::Read(data_, 0); }
++
++  VectorIterator &operator++() {
++    data_ += IndirectHelper<T>::element_stride;
++    return *this;
++  }
++
++  VectorIterator operator++(int) {
++    VectorIterator temp(data_, 0);
++    data_ += IndirectHelper<T>::element_stride;
++    return temp;
++  }
++
++  VectorIterator operator+(const uoffset_t &offset) const {
++    return VectorIterator(data_ + offset * IndirectHelper<T>::element_stride,
++                          0);
++  }
++
++  VectorIterator &operator+=(const uoffset_t &offset) {
++    data_ += offset * IndirectHelper<T>::element_stride;
++    return *this;
++  }
++
++  VectorIterator &operator--() {
++    data_ -= IndirectHelper<T>::element_stride;
++    return *this;
++  }
++
++  VectorIterator operator--(int) {
++    VectorIterator temp(data_, 0);
++    data_ -= IndirectHelper<T>::element_stride;
++    return temp;
++  }
++
++  VectorIterator operator-(const uoffset_t &offset) const {
++    return VectorIterator(data_ - offset * IndirectHelper<T>::element_stride,
++                          0);
++  }
++
++  VectorIterator &operator-=(const uoffset_t &offset) {
++    data_ -= offset * IndirectHelper<T>::element_stride;
++    return *this;
++  }
++
++ private:
++  const uint8_t *data_;
++};
++
++template<typename Iterator> struct VectorReverseIterator :
++  public std::reverse_iterator<Iterator> {
++
++  explicit VectorReverseIterator(Iterator iter) : iter_(iter) {}
++
++  typename Iterator::value_type operator*() const { return *(iter_ - 1); }
++
++  typename Iterator::value_type operator->() const { return *(iter_ - 1); }
++
++ private:
++  Iterator iter_;
++};
++
++struct String;
++
++// This is used as a helper type for accessing vectors.
++// Vector::data() assumes the vector elements start after the length field.
++template<typename T> class Vector {
++ public:
++  typedef VectorIterator<T, typename IndirectHelper<T>::mutable_return_type>
++      iterator;
++  typedef VectorIterator<T, typename IndirectHelper<T>::return_type>
++      const_iterator;
++  typedef VectorReverseIterator<iterator> reverse_iterator;
++  typedef VectorReverseIterator<const_iterator> const_reverse_iterator;
++
++  uoffset_t size() const { return EndianScalar(length_); }
++
++  // Deprecated: use size(). Here for backwards compatibility.
++  FLATBUFFERS_ATTRIBUTE(deprecated("use size() instead"))
++  uoffset_t Length() const { return size(); }
++
++  typedef typename IndirectHelper<T>::return_type return_type;
++  typedef typename IndirectHelper<T>::mutable_return_type mutable_return_type;
++
++  return_type Get(uoffset_t i) const {
++    FLATBUFFERS_ASSERT(i < size());
++    return IndirectHelper<T>::Read(Data(), i);
++  }
++
++  return_type operator[](uoffset_t i) const { return Get(i); }
++
++  // If this is a Vector of enums, T will be its storage type, not the enum
++  // type. This function makes it convenient to retrieve value with enum
++  // type E.
++  template<typename E> E GetEnum(uoffset_t i) const {
++    return static_cast<E>(Get(i));
++  }
++
++  // If this a vector of unions, this does the cast for you. There's no check
++  // to make sure this is the right type!
++  template<typename U> const U *GetAs(uoffset_t i) const {
++    return reinterpret_cast<const U *>(Get(i));
++  }
++
++  // If this a vector of unions, this does the cast for you. There's no check
++  // to make sure this is actually a string!
++  const String *GetAsString(uoffset_t i) const {
++    return reinterpret_cast<const String *>(Get(i));
++  }
++
++  const void *GetStructFromOffset(size_t o) const {
++    return reinterpret_cast<const void *>(Data() + o);
++  }
++
++  iterator begin() { return iterator(Data(), 0); }
++  const_iterator begin() const { return const_iterator(Data(), 0); }
++
++  iterator end() { return iterator(Data(), size()); }
++  const_iterator end() const { return const_iterator(Data(), size()); }
++
++  reverse_iterator rbegin() { return reverse_iterator(end()); }
++  const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); }
++
++  reverse_iterator rend() { return reverse_iterator(end()); }
++  const_reverse_iterator rend() const { return const_reverse_iterator(end()); }
++
++  const_iterator cbegin() const { return begin(); }
++
++  const_iterator cend() const { return end(); }
++
++  const_reverse_iterator crbegin() const { return rbegin(); }
++
++  const_reverse_iterator crend() const { return rend(); }
++
++  // Change elements if you have a non-const pointer to this object.
++  // Scalars only. See reflection.h, and the documentation.
++  void Mutate(uoffset_t i, const T &val) {
++    FLATBUFFERS_ASSERT(i < size());
++    WriteScalar(data() + i, val);
++  }
++
++  // Change an element of a vector of tables (or strings).
++  // "val" points to the new table/string, as you can obtain from
++  // e.g. reflection::AddFlatBuffer().
++  void MutateOffset(uoffset_t i, const uint8_t *val) {
++    FLATBUFFERS_ASSERT(i < size());
++    static_assert(sizeof(T) == sizeof(uoffset_t), "Unrelated types");
++    WriteScalar(data() + i,
++                static_cast<uoffset_t>(val - (Data() + i * sizeof(uoffset_t))));
++  }
++
++  // Get a mutable pointer to tables/strings inside this vector.
++  mutable_return_type GetMutableObject(uoffset_t i) const {
++    FLATBUFFERS_ASSERT(i < size());
++    return const_cast<mutable_return_type>(IndirectHelper<T>::Read(Data(), i));
++  }
++
++  // The raw data in little endian format. Use with care.
++  const uint8_t *Data() const {
++    return reinterpret_cast<const uint8_t *>(&length_ + 1);
++  }
++
++  uint8_t *Data() { return reinterpret_cast<uint8_t *>(&length_ + 1); }
++
++  // Similarly, but typed, much like std::vector::data
++  const T *data() const { return reinterpret_cast<const T *>(Data()); }
++  T *data() { return reinterpret_cast<T *>(Data()); }
++
++  template<typename K> return_type LookupByKey(K key) const {
++    void *search_result = std::bsearch(
++        &key, Data(), size(), IndirectHelper<T>::element_stride, KeyCompare<K>);
++
++    if (!search_result) {
++      return nullptr;  // Key not found.
++    }
++
++    const uint8_t *element = reinterpret_cast<const uint8_t *>(search_result);
++
++    return IndirectHelper<T>::Read(element, 0);
++  }
++
++ protected:
++  // This class is only used to access pre-existing data. Don't ever
++  // try to construct these manually.
++  Vector();
++
++  uoffset_t length_;
++
++ private:
++  // This class is a pointer. Copying will therefore create an invalid object.
++  // Private and unimplemented copy constructor.
++  Vector(const Vector &);
++
++  template<typename K> static int KeyCompare(const void *ap, const void *bp) {
++    const K *key = reinterpret_cast<const K *>(ap);
++    const uint8_t *data = reinterpret_cast<const uint8_t *>(bp);
++    auto table = IndirectHelper<T>::Read(data, 0);
++
++    // std::bsearch compares with the operands transposed, so we negate the
++    // result here.
++    return -table->KeyCompareWithValue(*key);
++  }
++};
++
++// Represent a vector much like the template above, but in this case we
++// don't know what the element types are (used with reflection.h).
++class VectorOfAny {
++ public:
++  uoffset_t size() const { return EndianScalar(length_); }
++
++  const uint8_t *Data() const {
++    return reinterpret_cast<const uint8_t *>(&length_ + 1);
++  }
++  uint8_t *Data() { return reinterpret_cast<uint8_t *>(&length_ + 1); }
++
++ protected:
++  VectorOfAny();
++
++  uoffset_t length_;
++
++ private:
++  VectorOfAny(const VectorOfAny &);
++};
++
++#ifndef FLATBUFFERS_CPP98_STL