Genericized intrin parsing from Ambience

stimBuffApis/livoxGen1/openClCollatingAndMeshingEngine.cpp

@@ -994,13 +994,16 @@ void OpenClCollatingAndMeshingEngine::produceAmbienceStimulusFrame(
 	float* averageIntensityAverages = reinterpret_cast<float*>(
 		averageIntensityBufferPtr);
 
-	// Count frames whose average intensity matches the configured comparator.
-	uint32_t ambienceCount = 0;
-	for (uint32_t i = 0; i < nSucceeded; ++i)
+	uint32_t ambiencePassbandCount = 0;
+	if (ambienceCountComparator.has_value())
 	{
-		float avg = averageIntensityAverages[i];
-		if (ambienceCountComparator(avg)) {
-			++ambienceCount;
+		// Count frames whose average intensity matches the configured comparator.
+		for (uint32_t i = 0; i < nSucceeded; ++i)
+		{
+			float avg = averageIntensityAverages[i];
+			if (ambienceCountComparator.value()(avg)) {
+				++ambiencePassbandCount;
+			}
 		}
 	}
 
@@ -1010,7 +1013,7 @@ void OpenClCollatingAndMeshingEngine::produceAmbienceStimulusFrame(
 		::PcloudAmbienceStimulusValue;
 	PcloudAmbienceStimVal* ambienceValue = reinterpret_cast<
 		PcloudAmbienceStimVal*>(ambienceFrame.slotDesc.vaddr);
-	ambienceValue[0] = ambienceCount;
+	ambienceValue[0] = ambiencePassbandCount;
 }
 
 class OpenClCollatingAndMeshingEngine::CompactCollateAndMeshFrameReq

stimBuffApis/livoxGen1/pcloudAmbienceQualeIfaceApi.h

@@ -3,6 +3,7 @@
 
 #include <cstdint>
 #include <memory>
+#include <optional>
 #include <stdexcept>
 #include <user/deviceAttachmentSpec.h>
 
@@ -34,7 +35,7 @@ struct ParamComparator
 	}
 };
 
-inline ParamComparator parsePcloudAmbienceParamComparator(
+inline std::optional<ParamComparator> parseOptionalPcloudAmbienceParamComparator(
 	const std::shared_ptr<device::DeviceAttachmentSpec>& deviceAttachmentSpec)
 {
 	const auto& params = deviceAttachmentSpec->qualeIfaceApiParams;
@@ -53,24 +54,21 @@ inline ParamComparator parsePcloudAmbienceParamComparator(
 
 	if (gtVal != kParamNotSpecified)
 	{
-		return ParamComparator{
+		return std::optional<ParamComparator>(ParamComparator{
 			.op = OP_CMP_GT,
 			.value = static_cast<uint32_t>(gtVal),
-		};
+		});
 	}
 
 	if (ltVal != kParamNotSpecified)
 	{
-		return ParamComparator{
+		return std::optional<ParamComparator>(ParamComparator{
 			.op = OP_CMP_LT,
 			.value = static_cast<uint32_t>(ltVal),
-		};
+		});
 	}
 
-	return ParamComparator{
-		.op = OP_CMP_LT,
-		.value = 8U,
-	};
+	return std::nullopt;
 }
 
 } // namespace stim_buff

stimBuffApis/livoxGen1/pcloudAmbienceStimulusBuffer.h

@@ -5,6 +5,7 @@
 #include <cstdint>
 #include <list>
 #include <cstddef>
+#include <optional>
 #include <vector>
 #include <string>
 #include <user/stimulusBuffer.h>
@@ -17,15 +18,143 @@
 namespace smo {
 namespace stim_buff {
 
-inline intrin::ParsedThresholdParam parsePostrinInterestParam(
-	const std::shared_ptr<device::DeviceAttachmentSpec>& deviceAttachmentSpec)
+enum class IntrinStatus
 {
-	return intrin::parseOptionalThresholdParam(
-		deviceAttachmentSpec->qualeIfaceApiParams,
-		intrin::kPosIntPcParamNames,
-		intrin::kPosIntThrParamNames,
-		90,
-		intrin::ThresholdUnit::Percentage);
+	DISABLED,
+	NEGTRIN,
+	POSTRIN,
+};
+
+struct ParsedAmbienceIntrinConfig
+{
+	IntrinStatus status;
+	uint32_t interestPercentage;
+	uint32_t interestThreshold;
+};
+
+inline bool isAmbienceIntrinEnabled(IntrinStatus intrinStatus)
+{
+	return intrinStatus != IntrinStatus::DISABLED;
+}
+
+inline intrin::ParsedThresholdParam parseAmbienceThresholdParam(
+	const std::string& paramName,
+	const std::string& paramValue,
+	intrin::ThresholdUnit unit)
+{
+	try
+	{
+		return intrin::ParsedThresholdParam{
+			.value = std::stoi(paramValue),
+			.unit = unit,
+			.matchedName = paramName,
+			.wasSpecified = true,
+		};
+	}
+	catch (const std::exception& e)
+	{
+		throw std::runtime_error(
+			"Failed to parse '" + paramName + "' param value '" + paramValue
+			+ "' as integer: " + e.what());
+	}
+}
+
+inline ParsedAmbienceIntrinConfig buildAmbienceIntrinConfig(
+	IntrinStatus status,
+	const intrin::ParsedThresholdParam& thresholdParam,
+	size_t nDgramsPerFrame)
+{
+	return ParsedAmbienceIntrinConfig{
+		.status = status,
+		.interestPercentage =
+			thresholdParam.unit == intrin::ThresholdUnit::Percentage
+				? static_cast<uint32_t>(thresholdParam.value)
+				: 0U,
+		.interestThreshold = intrin::resolveThresholdValue(
+			thresholdParam, nDgramsPerFrame),
+	};
+}
+
+inline std::optional<ParsedAmbienceIntrinConfig> tryParseAmbienceIntrinConfig(
+	const std::string& paramName,
+	const std::string& paramValue,
+	size_t nDgramsPerFrame)
+{
+	using intrin::ThresholdUnit;
+
+	if (intrin::namesContain(intrin::kPosIntPcParamNames, paramName))
+	{
+		return buildAmbienceIntrinConfig(
+			IntrinStatus::POSTRIN,
+			parseAmbienceThresholdParam(
+				paramName, paramValue, ThresholdUnit::Percentage),
+			nDgramsPerFrame);
+	}
+
+	if (intrin::namesContain(intrin::kPosIntThrParamNames, paramName))
+	{
+		return buildAmbienceIntrinConfig(
+			IntrinStatus::POSTRIN,
+			parseAmbienceThresholdParam(
+				paramName, paramValue, ThresholdUnit::Absolute),
+			nDgramsPerFrame);
+	}
+
+	if (intrin::namesContain(intrin::kNegIntPcParamNames, paramName))
+	{
+		return buildAmbienceIntrinConfig(
+			IntrinStatus::NEGTRIN,
+			parseAmbienceThresholdParam(
+				paramName, paramValue, ThresholdUnit::Percentage),
+			nDgramsPerFrame);
+	}
+
+	if (intrin::namesContain(intrin::kNegIntThrParamNames, paramName))
+	{
+		return buildAmbienceIntrinConfig(
+			IntrinStatus::NEGTRIN,
+			parseAmbienceThresholdParam(
+				paramName, paramValue, ThresholdUnit::Absolute),
+			nDgramsPerFrame);
+	}
+
+	return std::nullopt;
+}
+
+inline ParsedAmbienceIntrinConfig parseAmbienceIntrinConfig(
+	const std::shared_ptr<device::DeviceAttachmentSpec>& deviceAttachmentSpec,
+	size_t nDgramsPerFrame)
+{
+	const auto& params = deviceAttachmentSpec->qualeIfaceApiParams;
+
+	for (auto paramIt = params.rbegin(); paramIt != params.rend(); ++paramIt)
+	{
+		const auto& [paramName, paramValue] = *paramIt;
+		const auto parsedConfig = tryParseAmbienceIntrinConfig(
+			paramName, paramValue, nDgramsPerFrame);
+		if (parsedConfig.has_value())
+			{ return parsedConfig.value(); }
+	}
+
+	return ParsedAmbienceIntrinConfig{
+		.status = IntrinStatus::DISABLED,
+		.interestPercentage = 0U,
+		.interestThreshold = 0U,
+	};
+}
+
+inline void validateAmbienceIntrinComparatorConfig(
+	IntrinStatus intrinStatus,
+	const std::optional<ParamComparator>& ambienceCountComparator)
+{
+	if (isAmbienceIntrinEnabled(intrinStatus)
+		&& !ambienceCountComparator.has_value())
+	{
+		throw std::runtime_error(
+			"A pcloudAmbience stim buff instance with an intrin threshold "
+			"must also specify either 'ambience-count-gt-val' or "
+			"'ambience-count-lt-val'");
+	}
 }
 
 // Forward declaration
@@ -56,16 +185,16 @@ public:
 		intrin::validateNoForbiddenUnitlessIntrinParams(
 			deviceAttachmentSpec->qualeIfaceApiParams);
 
-		const auto postrinInterestParam =
-			parsePostrinInterestParam(deviceAttachmentSpec);
-		postrinInterestPercentage =
-			postrinInterestParam.unit == intrin::ThresholdUnit::Percentage
-				? static_cast<uint32_t>(postrinInterestParam.value)
-				: 0U;
-		postrinInterestThreshold = intrin::resolveThresholdValue(
-			postrinInterestParam, nDgramsPerFrame_);
-		ambienceCountComparator = parsePcloudAmbienceParamComparator(
+		const auto intrinConfig = parseAmbienceIntrinConfig(
+			deviceAttachmentSpec, nDgramsPerFrame_);
+		intrinStatus = intrinConfig.status;
+		intrinInterestPercentage = intrinConfig.interestPercentage;
+		intrinInterestThreshold = intrinConfig.interestThreshold;
+
+		ambienceCountComparator = parseOptionalPcloudAmbienceParamComparator(
 			deviceAttachmentSpec);
+		validateAmbienceIntrinComparatorConfig(
+			intrinStatus, ambienceCountComparator);
 
 		// Construct stencils and add to list (FIFO behavior)
 		for (size_t i = 0; i < nStencils; ++i) {
@@ -75,6 +204,14 @@ public:
 
 	~PcloudAmbienceStimulusBuffer() = default;
 
+	bool shouldTriggerIntrinEvent(uint32_t ambiencePassbandCount) const
+	{
+		if (!isAmbienceIntrinEnabled(intrinStatus))
+			{ return false; }
+
+		return ambiencePassbandCount >= intrinInterestThreshold;
+	}
+
 	// Non-copyable, non-movable: inherited pinner lifetime is instance-bound
 	PcloudAmbienceStimulusBuffer(const PcloudAmbienceStimulusBuffer&) = delete;
 	PcloudAmbienceStimulusBuffer& operator=(const PcloudAmbienceStimulusBuffer&) = delete;
@@ -82,9 +219,10 @@ public:
 	PcloudAmbienceStimulusBuffer& operator=(PcloudAmbienceStimulusBuffer&&) = delete;
 
 public:
-	uint32_t postrinInterestPercentage;
-	uint32_t postrinInterestThreshold;
-	ParamComparator ambienceCountComparator;
+	IntrinStatus intrinStatus;
+	uint32_t intrinInterestPercentage;
+	uint32_t intrinInterestThreshold;
+	std::optional<ParamComparator> ambienceCountComparator;
 	size_t nStencils;
 	std::list<LG1PcloudAmbienceStencil> stencils;
 };