engage-engine 1.244.90840011 → 1.245.90850012

package/include/ConfigurationObjects.h

@@ -449,6 +449,110 @@ namespace AppConfigurationObjects
         }
     }
 
+    //-----------------------------------------------------------
+    JSON_SERIALIZED_CLASS(TuningSettings)
+    class TuningSettings : public ConfigurationObjectBase
+    {
+        IMPLEMENT_JSON_SERIALIZATION()
+        IMPLEMENT_JSON_DOCUMENTATION(TuningSettings)
+
+    public:
+        /** @brief [Optional, Default 0 (no max)] Maximum number of RTP bytes allowed to be pooled */
+        uint32_t                    maxPooledRtpMb;
+
+        /** @brief [Optional, Default 0 (no max)] Maximum number of RTP objects allowed to be pooled */
+        uint32_t                    maxPooledRtpObjects;
+
+        /** @brief [Optional, Default 0 (no max)] Maximum number of RTP objects allowed to be active */
+        uint32_t                    maxActiveRtpObjects;
+
+
+        /** @brief [Optional, Default 0 (no max)] Maximum number of blob bytes allowed to be pooled */
+        uint32_t                    maxPooledBlobMb;
+
+        /** @brief [Optional, Default 0 (no max)] Maximum number of blob objects allowed to be pooled */
+        uint32_t                    maxPooledBlobObjects;
+
+        /** @brief [Optional, Default 0 (no max)] Maximum number of blob objects allowed to be active */
+        uint32_t                    maxActiveBlobObjects;
+
+
+        /** @brief [Optional, Default 0 (no max)] Maximum number of buffer bytes allowed to be pooled */
+        uint32_t                    maxPooledBufferMb;
+
+        /** @brief [Optional, Default 0 (no max)] Maximum number of buffer objects allowed to be pooled */
+        uint32_t                    maxPooledBufferObjects;
+
+        /** @brief [Optional, Default 0 (no max)] Maximum number of buffer objects allowed to be active */
+        uint32_t                    maxActiveBufferObjects;
+
+        /** @brief [Optional, Default 0 (no max)] Maximum number concurrent RTP processors */
+        uint32_t                    maxActiveRtpProcessors;
+
+        TuningSettings()
+        {
+            clear();
+        }
+
+        void clear()
+        {
+            maxPooledRtpMb = 0;
+            maxPooledRtpObjects = 0;
+            maxActiveRtpObjects = 0;
+
+            maxPooledBlobMb = 0;
+            maxPooledBlobObjects = 0;
+            maxActiveBlobObjects = 0;
+
+            maxPooledBufferMb = 0;
+            maxPooledBufferObjects = 0;
+            maxActiveBufferObjects = 0;
+
+            maxActiveRtpProcessors = 0;
+        }
+
+        virtual void initForDocumenting()
+        {
+            clear();
+        }
+    };
+
+    static void to_json(nlohmann::json& j, const TuningSettings& p)
+    {
+        j = nlohmann::json{
+            TOJSON_IMPL(maxPooledRtpMb),
+            TOJSON_IMPL(maxPooledRtpObjects),
+            TOJSON_IMPL(maxActiveRtpObjects),
+
+            TOJSON_IMPL(maxPooledBlobMb),
+            TOJSON_IMPL(maxPooledBlobObjects),
+            TOJSON_IMPL(maxActiveBlobObjects),
+
+            TOJSON_IMPL(maxPooledBufferMb),
+            TOJSON_IMPL(maxPooledBufferObjects),
+            TOJSON_IMPL(maxActiveBufferObjects),
+
+            TOJSON_IMPL(maxActiveRtpProcessors)
+        };
+    }
+    static void from_json(const nlohmann::json& j, TuningSettings& p)
+    {
+        p.clear();
+        FROMJSON_IMPL(maxPooledRtpMb, uint32_t, 0);
+        FROMJSON_IMPL(maxPooledRtpObjects, uint32_t, 0);
+        FROMJSON_IMPL(maxActiveRtpObjects, uint32_t, 0);
+
+        FROMJSON_IMPL(maxPooledBlobMb, uint32_t, 0);
+        FROMJSON_IMPL(maxPooledBlobObjects, uint32_t, 0);
+        FROMJSON_IMPL(maxActiveBlobObjects, uint32_t, 0);
+
+        FROMJSON_IMPL(maxPooledBufferMb, uint32_t, 0);
+        FROMJSON_IMPL(maxPooledBufferObjects, uint32_t, 0);
+        FROMJSON_IMPL(maxActiveBufferObjects, uint32_t, 0);
+
+        FROMJSON_IMPL(maxActiveRtpProcessors, uint32_t, 0);
+    }    
+
 
     //-----------------------------------------------------------
     JSON_SERIALIZED_CLASS(FipsCryptoSettings)
@@ -1109,6 +1213,12 @@ namespace AppConfigurationObjects
         /** @brief Custom RTP header */
         RtpHeader       rtpHeader;
 
+        /** @brief [Optional but required if txnTimeoutSecs is > 0]*/
+        std::string     txnId;
+
+        /** @brief [Optional, Default: 0] Number of seconds after which to time out delivery to the target node */
+        int             txnTimeoutSecs;
+
         BlobInfo()
         {
             clear();
@@ -1121,6 +1231,8 @@ namespace AppConfigurationObjects
             target.clear();
             rtpHeader.clear();
             payloadType = PayloadType_t::bptUndefined;
+            txnId.clear();
+            txnTimeoutSecs = 0;
         }
 
         virtual void initForDocumenting()
@@ -1137,7 +1249,9 @@ namespace AppConfigurationObjects
             TOJSON_IMPL(source),
             TOJSON_IMPL(target),
             TOJSON_IMPL(rtpHeader),
-            TOJSON_IMPL(payloadType)
+            TOJSON_IMPL(payloadType),
+            TOJSON_IMPL(txnId),
+            TOJSON_IMPL(txnTimeoutSecs)
         };
     }
     static void from_json(const nlohmann::json& j, BlobInfo& p)
@@ -1148,6 +1262,8 @@ namespace AppConfigurationObjects
         getOptional<std::string>("target", p.target, j, EMPTY_STRING);
         getOptional<RtpHeader>("rtpHeader", p.rtpHeader, j);
         getOptional<BlobInfo::PayloadType_t>("payloadType", p.payloadType, j, BlobInfo::PayloadType_t::bptUndefined);
+        getOptional<std::string>("txnId", p.txnId, j, EMPTY_STRING);
+        getOptional<int>("txnTimeoutSecs", p.txnTimeoutSecs, j, 0);
     }
 
 
@@ -3653,6 +3769,20 @@ namespace AppConfigurationObjects
         IMPLEMENT_JSON_DOCUMENTATION(TalkerInformation)
 
     public:
+        /** @brief Manufactured alias type
+         * If an alias is "manufactured" then the alias is not a real user but is instead a system-generated alias.
+         */
+        typedef enum
+        {
+            /** @brief Not manufactured */
+            matNone                    = 0,
+
+            /** @brief The anonymous alias specified in the group configuration was used */
+            matAnonymous                  = 1,
+
+            /** @brief The alias was manufactured using the RTP stream's SSRC value in hex - in the format "SSRCxxxxxxxx" */
+            matSsrcGenerated                 = 2
+        } ManufacturedAliasType_t;
 
         /** @brief The user alias to represent as a "talker". */
         std::string alias;
@@ -3678,6 +3808,12 @@ namespace AppConfigurationObjects
         /** @brief Indicates if RX is muted for this talker. */
         bool        rxMuted;
 
+        /** @brief The RTS SSRC associated with a talker's transmission. */
+        uint32_t     ssrc;
+
+        /** @brief The method used to "manufacture" the alias */
+        ManufacturedAliasType_t     manufacturedAliasType;
+
         TalkerInformation()
         {
             clear();
@@ -3693,6 +3829,8 @@ namespace AppConfigurationObjects
             duplicateCount = 0;
             aliasSpecializer = 0;
             rxMuted = false;
+            manufacturedAliasType = ManufacturedAliasType_t::matNone;
+            ssrc = 0;
         }
     };
 
@@ -3706,7 +3844,9 @@ namespace AppConfigurationObjects
             TOJSON_IMPL(txId),
             TOJSON_IMPL(duplicateCount),
             TOJSON_IMPL(aliasSpecializer),
-            TOJSON_IMPL(rxMuted)
+            TOJSON_IMPL(rxMuted),
+            TOJSON_IMPL(manufacturedAliasType),
+            TOJSON_IMPL(ssrc)
         };
     }
     static void from_json(const nlohmann::json& j, TalkerInformation& p)
@@ -3720,6 +3860,8 @@ namespace AppConfigurationObjects
         getOptional<int>("duplicateCount", p.duplicateCount, j, 0);
         getOptional<uint16_t>("aliasSpecializer", p.aliasSpecializer, j, 0);
         getOptional<bool>("rxMuted", p.rxMuted, j, false);
+        getOptional<TalkerInformation::ManufacturedAliasType_t>("manufacturedAliasType", p.manufacturedAliasType, j, TalkerInformation::ManufacturedAliasType_t::matNone);
+        getOptional<uint32_t>("ssrc", p.ssrc, j, 0);
     }
 
     //-----------------------------------------------------------
@@ -6689,6 +6831,9 @@ namespace AppConfigurationObjects
         /** @brief [Optional, Default: 15] The number of seconds to cache an open microphone before actually closing it. */
         int                                     delayedMicrophoneClosureSecs;
 
+        /** @brief [Optional] Low-level tuning */
+        TuningSettings                          tuning; 
+
         EnginePolicyInternals()
         {
             clear();
@@ -6709,6 +6854,7 @@ namespace AppConfigurationObjects
             stickyTidHangSecs = 10;
             uriStreamingIntervalMs = 60;
             delayedMicrophoneClosureSecs = 15;
+            tuning.clear();
         }
     };
 
@@ -6727,7 +6873,8 @@ namespace AppConfigurationObjects
             TOJSON_IMPL(rpConnectionTimeoutSecs),
             TOJSON_IMPL(stickyTidHangSecs),
             TOJSON_IMPL(uriStreamingIntervalMs),
-            TOJSON_IMPL(delayedMicrophoneClosureSecs)
+            TOJSON_IMPL(delayedMicrophoneClosureSecs),
+            TOJSON_IMPL(tuning)
         };
     }
     static void from_json(const nlohmann::json& j, EnginePolicyInternals& p)
@@ -6745,7 +6892,8 @@ namespace AppConfigurationObjects
         getOptional<int>("rpConnectionTimeoutSecs", p.rpConnectionTimeoutSecs, j, 5);
         getOptional<int>("stickyTidHangSecs", p.stickyTidHangSecs, j, 10);
         getOptional<int>("uriStreamingIntervalMs", p.uriStreamingIntervalMs, j, 60);
-        getOptional<int>("delayedMicrophoneClosureSecs", p.delayedMicrophoneClosureSecs, j, 15);        
+        getOptional<int>("delayedMicrophoneClosureSecs", p.delayedMicrophoneClosureSecs, j, 15);      
+        getOptional<TuningSettings>("tuning", p.tuning, j);
     }
 
     //-----------------------------------------------------------
@@ -6781,6 +6929,15 @@ namespace AppConfigurationObjects
         /** @brief Specifies the maximum storage space to use. */
         int                                     maxStorageMb;
 
+        /** @brief Specifies the maximum memory to use - defaults to maxStorageMb. */
+        int                                     maxMemMb;
+
+        /** @brief Specifies the maximum number of megabytes to allow for a single audio event's memory block - defaults to maxMemMb. */
+        int                                     maxAudioEventMemMb;
+
+        /** @brief Specifies the maximum disk space to use - defaults to maxStorageMb. */
+        int                                     maxDiskMb;
+
         /** @brief Maximum age of an event after which it is to be erased */
         long                                    maxEventAgeSecs;
 
@@ -6818,6 +6975,9 @@ namespace AppConfigurationObjects
             enabled = true;
             storageRoot.clear();
             maxStorageMb = 1024;                    // 1 Gigabyte
+            maxMemMb = maxStorageMb;
+            maxAudioEventMemMb = maxMemMb;
+            maxDiskMb = maxStorageMb;
             maxEventAgeSecs = (86400 * 30);         // 30 days
             groomingIntervalSecs = (60 * 30);       // 30 minutes
             maxEvents = 1000;
@@ -6833,7 +6993,9 @@ namespace AppConfigurationObjects
         j = nlohmann::json{
             TOJSON_IMPL(enabled),
             TOJSON_IMPL(storageRoot),
-            TOJSON_IMPL(maxStorageMb),
+            TOJSON_IMPL(maxMemMb),
+            TOJSON_IMPL(maxAudioEventMemMb),            
+            TOJSON_IMPL(maxDiskMb),
             TOJSON_IMPL(maxEventAgeSecs),
             TOJSON_IMPL(maxEvents),
             TOJSON_IMPL(groomingIntervalSecs),
@@ -6850,6 +7012,9 @@ namespace AppConfigurationObjects
         getOptional<std::string>("storageRoot", p.storageRoot, j, EMPTY_STRING);
 
         getOptional<int>("maxStorageMb", p.maxStorageMb, j, 1024);
+        getOptional<int>("maxMemMb", p.maxMemMb, j, p.maxStorageMb);
+        getOptional<int>("maxAudioEventMemMb", p.maxAudioEventMemMb, j, p.maxMemMb);        
+        getOptional<int>("maxDiskMb", p.maxDiskMb, j, p.maxStorageMb);
         getOptional<long>("maxEventAgeSecs", p.maxEventAgeSecs, j, (86400 * 30));
         getOptional<long>("groomingIntervalSecs", p.groomingIntervalSecs, j, (60 * 30));
         getOptional<long>("autosaveIntervalSecs", p.autosaveIntervalSecs, j, 5);
@@ -7045,6 +7210,79 @@ namespace AppConfigurationObjects
         getOptional<int>("rtpTsMultiplier", p.rtpTsMultiplier, j, -1);
     }
     
+    //-----------------------------------------------------------
+    JSON_SERIALIZED_CLASS(EngineStatusReportConfiguration)
+    /**
+    * @brief TODO: Configuration for the translation server status report file
+    *
+    * Helper C++ class to serialize and de-serialize EngineStatusReportConfiguration JSON
+    *
+    * Example: @include[doc] examples/EngineStatusReportConfiguration.json
+    *
+    * @see EnginePolicy
+    */
+    class EngineStatusReportConfiguration : public ConfigurationObjectBase
+    {
+        IMPLEMENT_JSON_SERIALIZATION()
+        IMPLEMENT_JSON_DOCUMENTATION(EngineStatusReportConfiguration)
+
+    public:
+        /** File name to use for the status report. */
+        std::string                     fileName;
+
+        /** [Optional, Default: 30] The interval at which to write out the status report to file. */
+        int                             intervalSecs;
+
+        /** [Optional, Default: false] Indicates if status reporting is enabled. */
+        bool                            enabled;
+
+        /** [Optional, Default: null] Command to be executed every time the status report is produced. */
+        std::string                     runCmd;
+
+        /** [Optional, Default: false] Indicates whether to include details of objects in memory. */
+        bool                            includeMemoryDetail;
+
+        /** [Optional, Default: false] Indicates whether to include details of task queues. */
+        bool                            includeTaskQueueDetail;
+
+        EngineStatusReportConfiguration()
+        {
+            clear();
+        }
+
+        void clear()
+        {
+            fileName.clear();
+            intervalSecs = 60;
+            enabled = false;
+            includeMemoryDetail = false;
+            includeTaskQueueDetail = false;
+            runCmd.clear();
+        }
+    };
+
+    static void to_json(nlohmann::json& j, const EngineStatusReportConfiguration& p)
+    {
+        j = nlohmann::json{
+            TOJSON_IMPL(fileName),
+            TOJSON_IMPL(intervalSecs),
+            TOJSON_IMPL(enabled),
+            TOJSON_IMPL(includeMemoryDetail),
+            TOJSON_IMPL(includeTaskQueueDetail),
+            TOJSON_IMPL(runCmd)
+        };
+    }
+    static void from_json(const nlohmann::json& j, EngineStatusReportConfiguration& p)
+    {
+        p.clear();
+        getOptional<std::string>("fileName", p.fileName, j);
+        getOptional<int>("intervalSecs", p.intervalSecs, j, 60);
+        getOptional<bool>("enabled", p.enabled, j, false);
+        getOptional<std::string>("runCmd", p.runCmd, j);
+        getOptional<bool>("includeMemoryDetail", p.includeMemoryDetail, j, false);
+        getOptional<bool>("includeTaskQueueDetail", p.includeTaskQueueDetail, j, false);
+    }
+
     //-----------------------------------------------------------
     JSON_SERIALIZED_CLASS(EnginePolicy)
     /**
@@ -7107,6 +7345,9 @@ namespace AppConfigurationObjects
         /** @brief Optional RTP - overrides the default */
         std::vector<RtpMapEntry>    rtpMap;
 
+        /** @brief Optional statusReport - details for the status report */
+        EngineStatusReportConfiguration statusReport;
+
         EnginePolicy()
         {
             clear();
@@ -7128,6 +7369,7 @@ namespace AppConfigurationObjects
             namedAudioDevices.clear();
             externalCodecs.clear();
             rtpMap.clear();
+            statusReport.clear();
         }
     };
 
@@ -7147,7 +7389,8 @@ namespace AppConfigurationObjects
             TOJSON_IMPL(featureset),
             TOJSON_IMPL(namedAudioDevices),
             TOJSON_IMPL(externalCodecs),
-            TOJSON_IMPL(rtpMap)
+            TOJSON_IMPL(rtpMap),
+            TOJSON_IMPL(statusReport)
         };
     }
     static void from_json(const nlohmann::json& j, EnginePolicy& p)
@@ -7167,6 +7410,7 @@ namespace AppConfigurationObjects
         FROMJSON_IMPL_SIMPLE(namedAudioDevices);
         FROMJSON_IMPL_SIMPLE(externalCodecs);
         FROMJSON_IMPL_SIMPLE(rtpMap);
+        FROMJSON_IMPL_SIMPLE(statusReport);
     }
 
 
@@ -7880,6 +8124,19 @@ namespace AppConfigurationObjects
         IMPLEMENT_JSON_DOCUMENTATION(RallypointReflector)
 
     public:
+        /** @brief Enum describing direction(s) for the reflector. */
+        typedef enum
+        {
+            /** @brief No restriction - both directions allowed */
+            drNone = 0,
+
+            /** @brief RX only */
+            drRxOnly   = 1,
+
+            /** @brief TX only */
+            drTxOnly   = 2
+        } DirectionRestriction_t;
+
         /**
          * @brief Unique identity for the group.
          */
@@ -7894,9 +8151,12 @@ namespace AppConfigurationObjects
         /** @brief [Optional] The name of the NIC on which to send and receive multicast traffic. */
         std::string                             multicastInterfaceName;
 
-        /** @brief Vector of additional TX addresses . */
+        /** @brief [Optional] Vector of additional TX addresses . */
         std::vector<NetworkAddress>            additionalTx;
 
+        /** @brief [Optional] Restriction of direction of traffic flow */
+        DirectionRestriction_t                  directionRestriction;
+
         RallypointReflector()
         {
             clear();
@@ -7909,6 +8169,7 @@ namespace AppConfigurationObjects
             tx.clear();
             multicastInterfaceName.clear();
             additionalTx.clear();
+            directionRestriction = drNone;
         }
     };
 
@@ -7919,7 +8180,8 @@ namespace AppConfigurationObjects
             TOJSON_IMPL(rx),
             TOJSON_IMPL(tx),
             TOJSON_IMPL(multicastInterfaceName),
-            TOJSON_IMPL(additionalTx)
+            TOJSON_IMPL(additionalTx),
+            TOJSON_IMPL(directionRestriction)
         };
     }
     static void from_json(const nlohmann::json& j, RallypointReflector& p)
@@ -7930,6 +8192,7 @@ namespace AppConfigurationObjects
         j.at("tx").get_to(p.tx);
         getOptional<std::string>("multicastInterfaceName", p.multicastInterfaceName, j);
         getOptional<std::vector<NetworkAddress>>("additionalTx", p.additionalTx, j);
+        getOptional<RallypointReflector::DirectionRestriction_t>("directionRestriction", p.directionRestriction, j, RallypointReflector::DirectionRestriction_t::drNone);
     }    
 
 
@@ -8224,9 +8487,6 @@ namespace AppConfigurationObjects
         /** @brief [Default: false] Advertising is enabled */
         bool                                    enabled;
 
-        /** @brief [Optional] This Rallypoint's mesh name */
-        std::string                             meshName;
-
         /** @brief [Optional] This Rallypoint's DNS-SD host name */
         std::string                             hostName;
 
@@ -8242,10 +8502,6 @@ namespace AppConfigurationObjects
         /** @brief [Default: 60] TTL for service TTL */
         int                                     ttl;
 
-        /** @brief [Optional] List of additional meshes that can be reached via this RP */
-        std::vector<std::string>                extraMeshes;
-
-
         RallypointAdvertisingSettings()
         {
             clear();
@@ -8254,13 +8510,11 @@ namespace AppConfigurationObjects
         void clear()
         {
             enabled = false;
-            meshName.clear();
             hostName.clear();
             serviceName = "_rallypoint._tcp.local.";
             interfaceName.clear();
             port = 0;
             ttl = 60;
-            extraMeshes.clear();
         }
     };
 
@@ -8268,27 +8522,23 @@ namespace AppConfigurationObjects
     {
         j = nlohmann::json{
             TOJSON_IMPL(enabled),
-            TOJSON_IMPL(meshName),
             TOJSON_IMPL(hostName),
             TOJSON_IMPL(serviceName),
             TOJSON_IMPL(interfaceName),
             TOJSON_IMPL(port),
-            TOJSON_IMPL(ttl),
-            TOJSON_IMPL(extraMeshes)
+            TOJSON_IMPL(ttl)
         };
     }
     static void from_json(const nlohmann::json& j, RallypointAdvertisingSettings& p)
     {
         p.clear();
         getOptional<bool>("enabled", p.enabled, j, false);
-        getOptional<std::string>("meshName", p.meshName, j);
         getOptional<std::string>("hostName", p.hostName, j);
         getOptional<std::string>("serviceName", p.serviceName, j, "_rallypoint._tcp.local.");
         getOptional<std::string>("interfaceName", p.interfaceName, j);
 
         getOptional<int>("port", p.port, j, 0);
         getOptional<int>("ttl", p.ttl, j, 60);
-        getOptional<std::vector<std::string>>("extraMeshes", p.extraMeshes, j);
     }
 
 
@@ -8514,6 +8764,15 @@ namespace AppConfigurationObjects
         /** @brief Details for capture of transmitted packets  */
         PacketCapturer                          txCapture;
 
+        /** @brief [Optional] This Rallypoint's mesh name */
+        std::string                             meshName;
+
+        /** @brief [Optional] List of additional meshes that can be reached via this RP */
+        std::vector<std::string>                extraMeshes;
+
+        /** @brief [Optional] Low-level tuning */
+        TuningSettings                          tuning; 
+
         RallypointServer()
         {
             clear();
@@ -8574,6 +8833,9 @@ namespace AppConfigurationObjects
             ipFamily = IpFamilyType_t::ifIpUnspec;
             rxCapture.clear();
             txCapture.clear();
+            meshName.clear();
+            extraMeshes.clear();
+            tuning.clear();
         }
     };
 
@@ -8632,7 +8894,10 @@ namespace AppConfigurationObjects
             TOJSON_IMPL(groupRestrictionAccessPolicyType),
             TOJSON_IMPL(ipFamily),
             TOJSON_IMPL(rxCapture),
-            TOJSON_IMPL(txCapture)
+            TOJSON_IMPL(txCapture),
+            TOJSON_IMPL(meshName),
+            TOJSON_IMPL(extraMeshes),
+            TOJSON_IMPL(tuning)
         };
     }
     static void from_json(const nlohmann::json& j, RallypointServer& p)
@@ -8691,6 +8956,9 @@ namespace AppConfigurationObjects
         getOptional<IpFamilyType_t>("ipFamily", p.ipFamily, j, IpFamilyType_t::ifIpUnspec);
         getOptional<PacketCapturer>("rxCapture", p.rxCapture, j);
         getOptional<PacketCapturer>("txCapture", p.txCapture, j);
+        getOptional<std::string>("meshName", p.meshName, j);
+        getOptional<std::vector<std::string>>("extraMeshes", p.extraMeshes, j);
+        getOptional<TuningSettings>("tuning", p.tuning, j);
     }
 
     //-----------------------------------------------------------
@@ -9582,9 +9850,6 @@ namespace AppConfigurationObjects
 
             /** @brief  TX has ended with a failure */
             txsTxEndedWithFailure           = -10,
-
-            /** @brief  One or more other entities are or will soon be actively transmitting */
-            txsOthersActive                = -11
         } TxStatus_t;
 
         /** @brief ID of the group */
@@ -9856,6 +10121,7 @@ namespace AppConfigurationObjects
         uint64_t    presenceDeserializationFailures;
         uint64_t    notRtpErrors;
         uint64_t    generalErrors;
+        uint64_t    inboundRtpProcessorAllocationFailures;
         
         GroupHealthReport()
         {
@@ -9878,6 +10144,7 @@ namespace AppConfigurationObjects
             presenceDeserializationFailures = 0;
             notRtpErrors = 0;
             generalErrors = 0;
+            inboundRtpProcessorAllocationFailures = 0;
         }
     };
 
@@ -9897,7 +10164,8 @@ namespace AppConfigurationObjects
             TOJSON_IMPL(jitterBufferInsertionFailures),
             TOJSON_IMPL(presenceDeserializationFailures),
             TOJSON_IMPL(notRtpErrors),
-            TOJSON_IMPL(generalErrors)
+            TOJSON_IMPL(generalErrors),
+            TOJSON_IMPL(inboundRtpProcessorAllocationFailures)
         };
     }
     static void from_json(const nlohmann::json& j, GroupHealthReport& p)
@@ -9917,6 +10185,7 @@ namespace AppConfigurationObjects
         getOptional<uint64_t>("presenceDeserializationFailures", p.presenceDeserializationFailures, j, 0);
         getOptional<uint64_t>("notRtpErrors", p.notRtpErrors, j, 0);
         getOptional<uint64_t>("generalErrors", p.generalErrors, j, 0);
+        getOptional<uint64_t>("inboundRtpProcessorAllocationFailures", p.inboundRtpProcessorAllocationFailures, j, 0);
     }
 
     //-----------------------------------------------------------
@@ -10376,6 +10645,9 @@ namespace AppConfigurationObjects
         /** @brief [Optional, Default: 1000] Interval at which to run the housekeeper thread. */
         int                 housekeeperIntervalMs;
 
+        /** @brief [Optional] Low-level tuning */
+        TuningSettings      tuning; 
+
         LingoServerInternals()
         {
             clear();
@@ -10384,6 +10656,7 @@ namespace AppConfigurationObjects
         void clear()
         {
             watchdog.clear();
+            tuning.clear();
             housekeeperIntervalMs = 1000;
         }
     };
@@ -10392,7 +10665,8 @@ namespace AppConfigurationObjects
     {
         j = nlohmann::json{
             TOJSON_IMPL(watchdog),
-            TOJSON_IMPL(housekeeperIntervalMs)
+            TOJSON_IMPL(housekeeperIntervalMs),
+            TOJSON_IMPL(tuning)
         };
     }
     static void from_json(const nlohmann::json& j, LingoServerInternals& p)
@@ -10400,6 +10674,7 @@ namespace AppConfigurationObjects
         p.clear();
         getOptional<WatchdogSettings>("watchdog", p.watchdog, j);
         getOptional<int>("housekeeperIntervalMs", p.housekeeperIntervalMs, j, 1000);
+        getOptional<TuningSettings>("tuning", p.tuning, j);
     }
 
     //-----------------------------------------------------------
@@ -10792,6 +11067,9 @@ namespace AppConfigurationObjects
         /** @brief [Optional, Default: 1000] Interval at which to run the housekeeper thread. */
         int                 housekeeperIntervalMs;
 
+        /** @brief [Optional] Low-level tuning */
+        TuningSettings      tuning; 
+
         BridgingServerInternals()
         {
             clear();
@@ -10800,6 +11078,7 @@ namespace AppConfigurationObjects
         void clear()
         {
             watchdog.clear();
+            tuning.clear();
             housekeeperIntervalMs = 1000;
         }
     };
@@ -10808,7 +11087,8 @@ namespace AppConfigurationObjects
     {
         j = nlohmann::json{
             TOJSON_IMPL(watchdog),
-            TOJSON_IMPL(housekeeperIntervalMs)
+            TOJSON_IMPL(housekeeperIntervalMs),
+            TOJSON_IMPL(tuning)            
         };
     }
     static void from_json(const nlohmann::json& j, BridgingServerInternals& p)
@@ -10816,6 +11096,7 @@ namespace AppConfigurationObjects
         p.clear();
         getOptional<WatchdogSettings>("watchdog", p.watchdog, j);
         getOptional<int>("housekeeperIntervalMs", p.housekeeperIntervalMs, j, 1000);
+        getOptional<TuningSettings>("tuning", p.tuning, j);
     }
 
     //-----------------------------------------------------------
@@ -11096,6 +11377,9 @@ namespace AppConfigurationObjects
         /** @brief [Optional, Default: 1000] Interval at which to run the housekeeper thread. */
         int                 housekeeperIntervalMs;
 
+        /** @brief [Optional] Low-level tuning */
+        TuningSettings      tuning; 
+
         EarServerInternals()
         {
             clear();
@@ -11104,6 +11388,7 @@ namespace AppConfigurationObjects
         void clear()
         {
             watchdog.clear();
+            tuning.clear();
             housekeeperIntervalMs = 1000;
         }
     };
@@ -11112,7 +11397,8 @@ namespace AppConfigurationObjects
     {
         j = nlohmann::json{
             TOJSON_IMPL(watchdog),
-            TOJSON_IMPL(housekeeperIntervalMs)
+            TOJSON_IMPL(housekeeperIntervalMs),
+            TOJSON_IMPL(tuning)
         };
     }
     static void from_json(const nlohmann::json& j, EarServerInternals& p)
@@ -11120,6 +11406,7 @@ namespace AppConfigurationObjects
         p.clear();
         getOptional<WatchdogSettings>("watchdog", p.watchdog, j);
         getOptional<int>("housekeeperIntervalMs", p.housekeeperIntervalMs, j, 1000);
+        getOptional<TuningSettings>("tuning", p.tuning, j);
     }
 
     //-----------------------------------------------------------
@@ -11378,6 +11665,9 @@ namespace AppConfigurationObjects
         /** @brief [Optional, Default: 1000] Interval at which to run the housekeeper thread. */
         int                 housekeeperIntervalMs;
 
+        /** @brief [Optional] Low-level tuning */
+        TuningSettings      tuning; 
+
         EngageSemServerInternals()
         {
             clear();
@@ -11386,6 +11676,7 @@ namespace AppConfigurationObjects
         void clear()
         {
             watchdog.clear();
+            tuning.clear();
             housekeeperIntervalMs = 1000;
         }
     };
@@ -11394,7 +11685,8 @@ namespace AppConfigurationObjects
     {
         j = nlohmann::json{
             TOJSON_IMPL(watchdog),
-            TOJSON_IMPL(housekeeperIntervalMs)
+            TOJSON_IMPL(housekeeperIntervalMs),
+            TOJSON_IMPL(tuning)
         };
     }
     static void from_json(const nlohmann::json& j, EngageSemServerInternals& p)
@@ -11402,6 +11694,7 @@ namespace AppConfigurationObjects
         p.clear();
         getOptional<WatchdogSettings>("watchdog", p.watchdog, j);
         getOptional<int>("housekeeperIntervalMs", p.housekeeperIntervalMs, j, 1000);
+        getOptional<TuningSettings>("tuning", p.tuning, j);
     }
 
     //-----------------------------------------------------------

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "engage-engine",
-  "version": "1.244.90840011",
+  "version": "1.245.90850012",
   "description": "Use Engage to communicate with everyone, everywhere, from any device",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"