irs: Add irs header

include/nn/irs.h

@@ -0,0 +1,84 @@
+#pragma once
+
+#include <nn/irs/MomentStatistic.h>
+#include <nn/irs/Rect.h>
+#include <nn/types.h>
+#include <nn/util.h>
+
+namespace nn::irsensor {
+struct ClusteringProcessorConfig;
+struct ClusteringProcessorState;
+
+#if NN_SDK_VER <= NN_MAKE_VER(4, 0, 0)
+struct DpdProcessorConfig;
+struct DpdProcessorPointingState;
+struct DpdProcessorState;
+#endif
+
+struct HandAnalysisConfig;
+struct ImageTransferProcessorConfig;
+struct ImageTransferProcessorState;
+struct MomentProcessorConfig;
+struct MomentProcessorState;
+struct TeraPluginProcessorConfig;
+struct TeraPluginProcessorState;
+
+enum class IrCameraStatus : u32 {
+    Available,
+    Unsupported,
+    Unconnected,
+};
+
+struct IrCameraHandle {
+    u8 playerNumber;
+    u8 deviceType;
+    u8 reserved[2];
+};
+
+IrCameraHandle GetIrCameraHandle(const u32&);
+void Initialize(const IrCameraHandle& handle);
+void Finalize(const IrCameraHandle& handle);
+IrCameraStatus GetIrCameraStatus(const IrCameraHandle& handle);
+void StopImageProcessor(const IrCameraHandle& handle);
+
+void GetMomentProcessorDefaultConfig(MomentProcessorConfig* outConfig);
+void RunMomentProcessor(const IrCameraHandle& handle, const MomentProcessorConfig& config);
+Result GetMomentProcessorState(MomentProcessorState* outState, const IrCameraHandle& handle);
+Result GetMomentProcessorStates(MomentProcessorState* outStates, s32* outCount, s32,
+                                const IrCameraHandle& handle);
+MomentStatistic CalculateMomentRegionStatistic(const MomentProcessorState* state, const Rect&, s32,
+                                               s32, s32, s32);
+
+void GetClusteringProcessorDefaultConfig(ClusteringProcessorConfig* outConfig);
+void RunClusteringProcessor(const IrCameraHandle& handle, const ClusteringProcessorConfig& config);
+Result GetClusteringProcessorState(ClusteringProcessorState* outState,
+                                   const IrCameraHandle& handle);
+Result GetClusteringProcessorStates(ClusteringProcessorState* outStates, s32* outCount, s32,
+                                    const IrCameraHandle& handle);
+
+void GetImageTransferProcessorDefaultConfig(ImageTransferProcessorConfig* outConfig);
+void RunImageTransferProcessor(const IrCameraHandle& handle,
+                               const ImageTransferProcessorConfig& config, void*, u64);
+Result GetImageTransferProcessorState(ImageTransferProcessorState* outState, void*, u64,
+                                      const IrCameraHandle& handle);
+
+Result RunHandAnalysis(const IrCameraHandle& handle, const HandAnalysisConfig& config);
+
+Result RunTeraPluginProcessor(const IrCameraHandle& handle,
+                              const TeraPluginProcessorConfig& config);
+
+#if NN_SDK_VER <= NN_MAKE_VER(4, 0, 0)
+void RunDpdProcessor(const IrCameraHandle& handle);
+void GetDpdProcessorDefaultConfig(DpdProcessorConfig* outConfig);
+void RunDpdProcessor(const IrCameraHandle& handle, const DpdProcessorConfig& config);
+Result GetDpdProcessorStates(DpdProcessorPointingState* outStates, s32* outCount, s32,
+                             const IrCameraHandle& handle);
+Result GetDpdProcessorStates(DpdProcessorState* outStates, s32* outCount, s32,
+                             const IrCameraHandle& handle);
+#endif
+
+Result GetTeraPluginProcessorStates(TeraPluginProcessorState* outStates, s32* outCount, s32, long,
+                                    u32, s32, const IrCameraHandle& handle);
+
+Rect MakeRect(s32 x, s32 y, s32 width, s32 height);
+}  // namespace nn::irsensor

include/nn/irs/ClusteringData.h

@@ -0,0 +1,12 @@
+#pragma once
+
+#include <nn/irs/MomentStatistic.h>
+#include <nn/irs/Rect.h>
+
+namespace nn::irsensor {
+struct ClusteringData {
+    MomentStatistic momentStatistic;
+    s32 pixelCount;
+    Rect bounds;
+};
+}  // namespace nn::irsensor

include/nn/irs/ClusteringProcessorConfig.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include <nn/irs/Rect.h>
+#include <nn/types.h>
+
+namespace nn::irsensor {
+struct ClusteringProcessorConfig {
+    s64 exposureTime = 200000;
+    s32 lightTarget = 0;
+    s32 gain = 2;
+    bool isNegativeImageUsed = false;
+    u8 reserved[7];
+    Rect windowOfInterest;
+    s32 objectPixelCountMin = 3;
+    s32 objectPixelCountMax = 76800;  // windowOfInterest.width * windowOfInterest.height;
+    s32 objectIntensityMin = 150;
+    bool isExternalLightFilterEnabled = true;
+};
+}  // namespace nn::irsensor

include/nn/irs/ClusteringProcessorState.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include <nn/irs/ClusteringData.h>
+#include <nn/types.h>
+
+namespace nn::irsensor {
+struct ClusteringProcessorState {
+    s64 samplingNumber;
+    s64 timeStamp;
+    u8 objectCount;
+    s32 ambientNoiseLevel;
+    ClusteringData data[16];
+};
+}  // namespace nn::irsensor

include/nn/irs/DpdProcessorConfig.h

@@ -0,0 +1,9 @@
+#pragma once
+
+#include <nn/irs/Rect.h>
+
+namespace nn::irsensor {
+struct DpdProcessorConfig {
+    Rect windowOfInterest;
+};
+}  // namespace nn::irsensor

include/nn/irs/DpdProcessorPointingState.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#include <nn/irs/Rect.h>
+#include <nn/types.h>
+
+namespace nn::irsensor {
+struct DpdProcessorPointingState {
+    s64 samplingNumber;
+    s64 timeStamp;
+    struct {
+        u8 pointingStatus;
+        s32 _4;
+        f32 _8;
+        f32 positionX;
+        f32 positionY;
+        f32 _14;
+        Rect windowOfInterest;
+    } data[3];
+};
+}  // namespace nn::irsensor

include/nn/irs/DpdProcessorState.h

@@ -0,0 +1,13 @@
+#pragma once
+
+#include <nn/types.h>
+
+namespace nn::irsensor {
+struct DpdProcessorState {
+    s64 samplingNumber;
+    s64 timeStamp;
+    s32 pointingStatus;
+    f32 positionX;
+    f32 positionY;
+};
+}  // namespace nn::irsensor

include/nn/irs/HandAnalysisConfig.h

@@ -0,0 +1,9 @@
+#pragma once
+
+#include <nn/irs/HandAnalysisMode.h>
+
+namespace nn::irsensor {
+struct HandAnalysisConfig {
+    HandAnalysisMode mode;
+};
+}  // namespace nn::irsensor

include/nn/irs/HandAnalysisMode.h

@@ -0,0 +1,11 @@
+#pragma once
+
+namespace nn::irsensor {
+enum HandAnalysisMode {
+    HandAnalysisMode_None,
+    HandAnalysisMode_Silhouette,
+    HandAnalysisMode_Image,
+    HandAnalysisMode_SilhouetteAndImage,
+    HandAnalysisMode_SilhouetteOnly,  // [4.0.0+]
+};
+}  // namespace nn::irsensor

include/nn/irs/ImageTransferProcessorConfig.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#include <nn/irs/ImageTransferProcessorFormat.h>
+#include <nn/types.h>
+
+namespace nn::irsensor {
+struct __attribute__((packed)) ImageTransferProcessorConfig {
+    s64 exposureTime = 300000;
+    s32 lightTarget = 0;
+    s32 gain = 8;
+    bool isNegativeImageUsed = false;
+    u8 reserved[7];
+    ImageTransferProcessorFormat format = ImageTransferProcessorFormat::_320x240;
+};
+}  // namespace nn::irsensor

include/nn/irs/ImageTransferProcessorFormat.h

@@ -0,0 +1,13 @@
+#pragma once
+
+#include <nn/types.h>
+
+namespace nn::irsensor {
+enum class ImageTransferProcessorFormat : u32 {
+    _320x240,
+    _160x120,
+    _80x60,
+    _40x30,  // [4.0.0+]
+    _20x15,  // [4.0.0+]
+};
+}  // namespace nn::irsensor

include/nn/irs/ImageTransferProcessorState.h

@@ -0,0 +1,11 @@
+#pragma once
+
+#include <nn/types.h>
+
+namespace nn::irsensor {
+struct ImageTransferProcessorState {
+    s64 samplingNumber;
+    s32 ambientNoiseLevel;
+    u8 reserved[4];
+};
+}  // namespace nn::irsensor

include/nn/irs/MomentProcessorConfig.h

@@ -0,0 +1,17 @@
+#pragma once
+
+#include <nn/irs/Rect.h>
+#include <nn/types.h>
+
+namespace nn::irsensor {
+struct MomentProcessorConfig {
+    s64 exposureTime = 300000;
+    s32 lightTarget = 0;
+    s32 gain = 8;
+    bool isNegativeImageUsed = false;
+    u8 reserved[7];
+    Rect windowOfInterest;
+    s32 preprocess = 1;
+    s32 preprocessIntensityThreshold = 80;
+};
+}  // namespace nn::irsensor

include/nn/irs/MomentProcessorState.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include <nn/irs/MomentStatistic.h>
+#include <nn/types.h>
+
+namespace nn::irsensor {
+struct MomentProcessorState {
+    s64 samplingNumber;
+    s64 timeStamp;
+    s32 ambientNoiseLevel;
+    u8 reserved[4];
+    MomentStatistic statistics[48];
+};
+}  // namespace nn::irsensor

include/nn/irs/MomentStatistic.h

@@ -0,0 +1,11 @@
+#pragma once
+
+#include <nn/types.h>
+
+namespace nn::irsensor {
+struct MomentStatistic {
+    f32 averageIntensity;
+    f32 centroidX;
+    f32 centroidY;
+};
+}  // namespace nn::irsensor

include/nn/irs/Rect.h

@@ -0,0 +1,12 @@
+#pragma once
+
+#include <nn/types.h>
+
+namespace nn::irsensor {
+struct Rect {
+    u16 x = 0;
+    u16 y = 0;
+    u16 width = 320;
+    u16 height = 240;
+};
+}  // namespace nn::irsensor

include/nn/irs/TeraPluginProcessorConfig.h

@@ -0,0 +1,12 @@
+#pragma once
+
+#include <nn/types.h>
+
+namespace nn::irsensor {
+struct TeraPluginProcessorConfig {
+    s8 mode;
+    s8 _1;  // [6.0.0+]
+    s8 _2;  // [6.0.0+]
+    s8 _3;  // [6.0.0+]
+};
+}  // namespace nn::irsensor

include/nn/irs/TeraPluginProcessorState.h

@@ -0,0 +1,12 @@
+#pragma once
+
+#include <nn/types.h>
+
+namespace nn::irsensor {
+struct TeraPluginProcessorState {
+    s64 samplingNumber;
+    s64 timeStamp;
+    s32 ambientNoiseLevel;
+    u8 pluginData[0x12c];
+};
+}  // namespace nn::irsensor

include/nn/irs/sys.h

@@ -0,0 +1,12 @@
+#pragma once
+
+namespace nn::applet {
+struct AppletResourceUserId;
+}  // namespace nn::applet
+
+namespace nn::irsensor::system {
+void SetAppletResourceUserId(const applet::AppletResourceUserId&);
+void RegisterAppletResourceUserId(const applet::AppletResourceUserId&, bool);
+void UnregisterAppletResourceUserId(const applet::AppletResourceUserId&);
+void EnableAppletToGetInput(const applet::AppletResourceUserId&, bool);
+}  // namespace nn::irsensor::system