#50 Add channel name mappings

CMakeLists.txt

@@ -191,6 +191,7 @@ add_library(beyond-protocol STATIC
 	src/self.cpp
 	src/protocol.cpp
 	src/rpc.cpp
+    src/channelUtils.cpp
 )
 
 target_include_directories(beyond-protocol PUBLIC

include/ftl/protocol/channelUtils.hpp

@@ -19,6 +19,14 @@ inline bool isData(Channel c) { return static_cast<int>(c) >= 64; }
 /** Obtain a string name for channel. */
 std::string name(Channel c);
 
+/**
+ * @brief Get the channel ID from a name.
+ * 
+ * @param name 
+ * @return Channel 
+ */
+Channel fromName(const std::string &name);
+
 /** Obtain OpenCV type for channel. */
 int type(Channel c);
 

include/ftl/protocol/channels.hpp

@@ -117,6 +117,24 @@ enum struct Channel : int {
     kPipeline_EnableMVMLS     = 501,
     kPipeline_EnableAruco     = 502,
 
+    /* Stereo video settings */
+    kSGMResolution              = 600,
+    kStereoRectify              = 601,
+    kStereoRightPose            = 602,
+    kStereoRectifyCubic         = 603,
+    kVideoOffsetZ               = 604,
+    kVideoSize                  = 605,
+
+    /* Sender settings */
+    kSenderLosslessFloat        = 700,
+    kSenderLosslessColour       = 701,
+    kSenderIFrames              = 702,
+    kSenderCodecFloat           = 703,
+    kSenderCodecColour          = 704,
+    kSenderMaxBitrate           = 705,
+    kSenderFloatBitrateScale    = 706,
+
+
     /* Custom / user data channels */
     kData           = 2048,  // Do not use
     kEndFrame       = 2048,  // Signify the last packet

include/ftl/protocol/node.hpp

@@ -173,5 +173,7 @@ class Node {
     ftl::net::PeerPtr peer_;
 };
 
+using NodePtr = std::shared_ptr<Node>;
+
 }  // namespace protocol
 }  // namespace ftl

src/channelUtils.cpp

+/**
+ * @file channelUtils.cpp
+ * @copyright Copyright (c) 2022 University of Turku, MIT License
+ * @author Nicolas Pope
+ */
+
+#include <ftl/protocol/config.h>
+#include <string>
+#include <unordered_map>
+#include <ftl/protocol/channelUtils.hpp>
+
+using ftl::protocol::Channel;
+
+#ifndef CV_8U
+#define CV_CN_SHIFT   3
+#define CV_DEPTH_MAX  (1 << CV_CN_SHIFT)
+
+#define CV_8U   0
+#define CV_8S   1
+#define CV_16U  2
+#define CV_16S  3
+#define CV_32S  4
+#define CV_32F  5
+#define CV_64F  6
+#define CV_16F  7
+
+#define CV_MAT_DEPTH_MASK       (CV_DEPTH_MAX - 1)
+#define CV_MAT_DEPTH(flags)     ((flags) & CV_MAT_DEPTH_MASK)
+
+#define CV_MAKETYPE(depth,cn) (CV_MAT_DEPTH(depth) + (((cn)-1) << CV_CN_SHIFT))
+#define CV_MAKE_TYPE CV_MAKETYPE
+
+#define CV_8UC1 CV_MAKETYPE(CV_8U,1)
+#define CV_8UC2 CV_MAKETYPE(CV_8U,2)
+#define CV_8UC3 CV_MAKETYPE(CV_8U,3)
+#define CV_8UC4 CV_MAKETYPE(CV_8U,4)
+#define CV_8UC(n) CV_MAKETYPE(CV_8U,(n))
+
+#define CV_8SC1 CV_MAKETYPE(CV_8S,1)
+#define CV_8SC2 CV_MAKETYPE(CV_8S,2)
+#define CV_8SC3 CV_MAKETYPE(CV_8S,3)
+#define CV_8SC4 CV_MAKETYPE(CV_8S,4)
+#define CV_8SC(n) CV_MAKETYPE(CV_8S,(n))
+
+#define CV_16UC1 CV_MAKETYPE(CV_16U,1)
+#define CV_16UC2 CV_MAKETYPE(CV_16U,2)
+#define CV_16UC3 CV_MAKETYPE(CV_16U,3)
+#define CV_16UC4 CV_MAKETYPE(CV_16U,4)
+#define CV_16UC(n) CV_MAKETYPE(CV_16U,(n))
+
+#define CV_16SC1 CV_MAKETYPE(CV_16S,1)
+#define CV_16SC2 CV_MAKETYPE(CV_16S,2)
+#define CV_16SC3 CV_MAKETYPE(CV_16S,3)
+#define CV_16SC4 CV_MAKETYPE(CV_16S,4)
+#define CV_16SC(n) CV_MAKETYPE(CV_16S,(n))
+
+#define CV_32SC1 CV_MAKETYPE(CV_32S,1)
+#define CV_32SC2 CV_MAKETYPE(CV_32S,2)
+#define CV_32SC3 CV_MAKETYPE(CV_32S,3)
+#define CV_32SC4 CV_MAKETYPE(CV_32S,4)
+#define CV_32SC(n) CV_MAKETYPE(CV_32S,(n))
+
+#define CV_32FC1 CV_MAKETYPE(CV_32F,1)
+#define CV_32FC2 CV_MAKETYPE(CV_32F,2)
+#define CV_32FC3 CV_MAKETYPE(CV_32F,3)
+#define CV_32FC4 CV_MAKETYPE(CV_32F,4)
+#define CV_32FC(n) CV_MAKETYPE(CV_32F,(n))
+
+#define CV_64FC1 CV_MAKETYPE(CV_64F,1)
+#define CV_64FC2 CV_MAKETYPE(CV_64F,2)
+#define CV_64FC3 CV_MAKETYPE(CV_64F,3)
+#define CV_64FC4 CV_MAKETYPE(CV_64F,4)
+#define CV_64FC(n) CV_MAKETYPE(CV_64F,(n))
+
+#define CV_16FC1 CV_MAKETYPE(CV_16F,1)
+#define CV_16FC2 CV_MAKETYPE(CV_16F,2)
+#define CV_16FC3 CV_MAKETYPE(CV_16F,3)
+#define CV_16FC4 CV_MAKETYPE(CV_16F,4)
+#define CV_16FC(n) CV_MAKETYPE(CV_16F,(n))
+#endif
+
+struct ChannelInfo {
+    const char *name;
+    int cvtype = -1;
+};
+
+/* Name and type lookup table for channels */
+static const std::unordered_map<Channel,ChannelInfo> info = {
+    {Channel::kColour,              {"Left",                CV_8UC4}},
+    {Channel::kDepth,               {"Depth",               CV_32F}},
+    {Channel::kRight,               {"Right",               CV_8UC4}},
+    {Channel::kDepth2,              {"Depth Right",         CV_32F}},
+    {Channel::kDeviation,           {"Deviation",           CV_32F}},
+    {Channel::kNormals,             {"Normals",             CV_32FC4}},
+    {Channel::kWeights,             {"Weights",             CV_32F}},
+    {Channel::kConfidence,          {"Confidence",          CV_32F}},
+    {Channel::kEnergyVector,        {"Energy Vector",       CV_32FC4}},
+    {Channel::kFlow,                {"Flow",                CV_32F}},
+    {Channel::kEnergy,              {"Energy",              CV_32F}},
+    {Channel::kMask,                {"Mask",                CV_8U}},
+    {Channel::kDensity,             {"Density",             CV_32F}},
+    {Channel::kSupport1,            {"Support1",            CV_8UC4}},
+    {Channel::kSupport2,            {"Support2",            CV_8UC4}},
+    {Channel::kSegmentation,        {"Segmentation",        CV_8U}},
+    {Channel::kNormals2,            {"Normals Right",       CV_32FC4}},
+    {Channel::kUNUSED1,             {"Unused",              CV_8UC4}},
+    {Channel::kDisparity,           {"Disparity",           CV_16S}},
+    {Channel::kSmoothing,           {"Smoothing",           CV_32F}},
+    {Channel::kUNUSED2,             {"Unused",              CV_8UC4}},
+    {Channel::kOverlay,             {"Overlay",             CV_8UC4}},
+    {Channel::kGroundTruth,         {"Ground Truth",        CV_32F}},
+
+    {Channel::kAudioMono,           {"Audio (Mono)",        -1}},
+    {Channel::kAudioStereo,         {"Audio (Stereo)",      -1}},
+
+    {Channel::kConfiguration,       {"Configuration",       -1}},
+    {Channel::kCalibration,         {"Calibration",         -1}},
+    {Channel::kPose,                {"Pose",                -1}},
+    {Channel::kCalibration2,        {"CalibrationHR",       -1}},
+    {Channel::kMetaData,            {"Meta Data",           -1}},
+    {Channel::kCapabilities,        {"Capabilities",        -1}},
+    {Channel::kCalibrationData,     {"CalibrationData",     -1}},
+    {Channel::kThumbnail,           {"Thumbnail",           -1}},
+    {Channel::kOverlaySelect,       {"OverlaySelect",       -1}},
+    {Channel::kStartTime,           {"StartTime",           -1}},
+    {Channel::kUser,                {"User",                -1}},
+
+    {Channel::kBrightness,          {"Brightness",          -1}},
+    {Channel::kContrast,            {"Contrast",            -1}},
+    {Channel::kExposure,            {"Exposure",            -1}},
+    {Channel::kGain,                {"Gain",                -1}},
+    {Channel::kWhiteBalance,        {"WhiteBalance",        -1}},
+    {Channel::kAutoExposure,        {"AutoExposure",        -1}},
+    {Channel::kAutoWhiteBalance,    {"AutoWhiteBalance",    -1}},
+    {Channel::kCameraTemperature,   {"CameraTemperature",   -1}},
+
+    {Channel::kRS2_LaserPower,      {"RS2LaserPower",       -1}},
+    {Channel::kRS2_MinDistance,     {"RS2MinDistance",      -1}},
+    {Channel::kRS2_MaxDistance,     {"RS2MaxDistance",      -1}},
+    {Channel::kRS2_InterCamSync,    {"RS2InterCamSync",     -1}},
+    {Channel::kRS2_PostSharpening,  {"RS2PostSharpening",   -1}},
+
+    {Channel::kRenderer_CameraType,             {"RenderCameraType",            -1}},
+    {Channel::kRenderer_Visualisation,          {"RenderVisualisation",         -1}},
+    {Channel::kRenderer_Engine,                 {"RenderEngine",                -1}},
+    {Channel::kRenderer_FPS,                    {"RenderFPS",                   -1}},
+    {Channel::kRenderer_View,                   {"RenderView",                  -1}},
+    {Channel::kRenderer_Channel,                {"RenderChannel",               -1}},
+    {Channel::kRenderer_Opacity,                {"RenderOpacity",               -1}},
+    {Channel::kRenderer_Sources,                {"RenderSources",               -1}},
+    {Channel::kRenderer_Projection,             {"RenderProjection",            -1}},
+    {Channel::kRenderer_Background,             {"RenderBackground",            -1}},
+    {Channel::kRenderer_ShowBadColour,          {"RenderShowBadColour",         -1}},
+    {Channel::kRenderer_CoolEffect,             {"RenderCoolEffect",            -1}},
+    {Channel::kRenderer_EffectColour,           {"RenderEffectColour",          -1}},
+    {Channel::kRenderer_ShowColourWeights,      {"RenderShowColourWeights",     -1}},
+    {Channel::kRenderer_TriangleLimit,          {"RenderTriangleLimit",         -1}},
+    {Channel::kRenderer_DisconDisparities,      {"RenderDisconDisparities",     -1}},
+    {Channel::kRenderer_NormalWeightColour,     {"RenderNormalWeightColour",    -1}},
+    {Channel::kRenderer_ChannelWeights,         {"RenderChannelWeights",        -1}},
+    {Channel::kRenderer_AccumFunc,              {"RenderAccumFunc",             -1}},
+
+    {Channel::kSGMResolution,       {"SGMResolution",       -1}},
+    {Channel::kStereoRectify,       {"StereoRectify",       -1}},
+    {Channel::kStereoRightPose,     {"StereoRightPose",     -1}},
+    {Channel::kStereoRectifyCubic,  {"StereoRectifyCubic",  -1}},
+    {Channel::kVideoOffsetZ,        {"VideoOffsetZ",        -1}},
+    {Channel::kVideoSize,           {"VideoSize",           -1}},
+
+    {Channel::kSenderLosslessFloat,     {"SenderLosslessFloat",     -1}},
+    {Channel::kSenderLosslessColour,    {"SenderLosslessColour",    -1}},
+    {Channel::kSenderIFrames,           {"SenderIFrames",           -1}},
+    {Channel::kSenderCodecFloat,        {"SenderCodecFloat",        -1}},
+    {Channel::kSenderCodecColour,       {"SenderCodecColour",       -1}},
+    {Channel::kSenderMaxBitrate,        {"SenderMaxBitrate",        -1}},
+    {Channel::kSenderFloatBitrateScale, {"SenderFloatBitrateScale", -1}},
+
+    {Channel::kData,                {"Generic Data",        -1}},
+    {Channel::kFaces,               {"Faces",               -1}},
+    {Channel::kShapes3D,            {"Shapes 3D",           -1}},
+    {Channel::kMessages,            {"Messages",            -1}},
+    {Channel::kTouch,               {"Touch",               -1}}
+};
+
+static std::unordered_map<std::string, Channel> indexNames() {
+    std::unordered_map<std::string, Channel> result;
+    for (const auto &i : info) {
+        result[std::string(i.second.name)] = i.first;
+    }
+    return result;
+}
+
+static const std::unordered_map<std::string, Channel> nameIndex = indexNames();
+
+std::string ftl::protocol::name(Channel c) {
+    if (c == Channel::kNone) return "None";
+    auto i = info.find(c);
+    if (i != info.end()) {
+        return i->second.name;
+    } else {
+        return "Unknown";
+    }
+}
+
+Channel ftl::protocol::fromName(const std::string &name) {
+    auto i = nameIndex.find(name);
+    if (i != nameIndex.end()) {
+        return i->second;
+    } else {
+        return Channel::kNone;
+    }
+}
+
+int ftl::protocol::type(Channel c) {
+    if (c == Channel::kNone) return -1;
+    auto i = info.find(c);
+    if (i != info.end()) {
+        return i->second.cvtype;
+    } else {
+        return -1;
+    }
+}

test/CMakeLists.txt

@@ -17,6 +17,16 @@ target_link_libraries(uri_unit beyond-protocol
 
 add_test(URIUnitTest uri_unit)
 
+### Util #######################################################################
+add_executable(util_unit
+	$<TARGET_OBJECTS:CatchTest>
+	./utils_unit.cpp)
+target_include_directories(util_unit PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/../include")
+target_link_libraries(util_unit beyond-protocol
+	Threads::Threads ${OS_LIBS})
+
+add_test(UtilUnitTest util_unit)
+
 ### Handle Unit ################################################################
 add_executable(handle_unit
 	$<TARGET_OBJECTS:CatchTest>

test/utils_unit.cpp

+#include "catch.hpp"
+#include <ftl/protocol/channelUtils.hpp>
+
+using ftl::protocol::Channel;
+using std::string;
+
+SCENARIO( "Channel names", "[utility]" ) {
+    GIVEN( "a valid channel name" ) {
+        REQUIRE( ftl::protocol::fromName("User") == Channel::kUser );
+    }
+
+    GIVEN( "an invalid channel name" ) {
+        REQUIRE( ftl::protocol::fromName("RandomWord") == Channel::kNone );
+    }
+
+    GIVEN( "a channel, get a name" ) {
+        REQUIRE( ftl::protocol::name(Channel::kUser) == "User" );
+    }
+}
\ No newline at end of file