Implemented qt port + e2e

Source/Components/Interfaces/UDPStream/UDPSClient.cpp

@@ -582,6 +582,7 @@ bool UDPSClient::PlaceFragment(const UDPSPacketHeader *hdr,
         reassemblySlots[slot].active            = true;
         reassemblySlots[slot].firstSeenTicks    = HighResolutionTimer::Counter();
         reassemblySlots[slot].chunkSize         = 0u;
+        reassemblySlots[slot].assembledBytes    = 0u;
         (void) MemoryOperationsHelper::Set(reassemblySlots[slot].recvMask, 0, 32u);
     }
 
@@ -619,6 +620,13 @@ bool UDPSClient::PlaceFragment(const UDPSPacketHeader *hdr,
         (void) MemoryOperationsHelper::Copy(s.payload + offset, payload, payloadBytes);
     }
 
+    // Track the exact assembled size: the highest byte written across all
+    // fragments. The last fragment is usually smaller than chunkSize, so the
+    // total is not chunkSize*totalFragments.
+    if ((offset + payloadBytes) > s.assembledBytes) {
+        s.assembledBytes = offset + payloadBytes;
+    }
+
     if (byteIdx < 32u) {
         s.recvMask[byteIdx] |= bitMask;
     }
@@ -641,25 +649,10 @@ void UDPSClient::DeliverAssembled(UDPSReassemblySlot &s) {
     if (listener == NULL_PTR(UDPSClientListener *)) {
         return;
     }
-    // Total assembled size = (totalFrags-1)*chunkSize + lastFragSize
-    // We don't store lastFragSize separately, but the last receivedFragments
-    // Write placed payloadBytes at its offset — total = chunkSize*(totalFrags-1) + lastBytes.
-    // Since we don't track lastBytes directly, use the mask to infer completeness.
-    // The assembled payload size is not trivially known without tracking it.
-    // Simplest correct approach: accumulate total bytes written.
-    // For now, estimate as chunkSize * totalFragments (may be slightly over for last frag).
-    // Fix: track totalPayloadBytes in slot.
-    //
-    // Since we don't have that, compute based on known structure:
-    // totalFrags-1 full chunks + one last chunk (which might be smaller).
-    // We'd need to save the last fragment's payloadBytes.
-    // As a pragmatic solution, deliver chunkSize * totalFragments as upper bound —
-    // the receiver (CONFIG/DATA parser) knows the actual sizes from content.
-    //
-    // Better: save the actual total in the slot. We don't have that field.
-    // Use the simplest approximation that is always correct for aligned payloads,
-    // and let the application-layer parser determine exact size from content.
-    uint32 totalSize = s.chunkSize * static_cast<uint32>(s.totalFragments);
+    // The exact assembled size is the highest byte offset written across all
+    // fragments (the last fragment is typically smaller than chunkSize), tracked
+    // incrementally in PlaceFragment.
+    uint32 totalSize = s.assembledBytes;
 
     if (s.type == UDPS_TYPE_CONFIG) {
         listener->OnUDPSConfig(s.payload, totalSize);

Source/Components/Interfaces/UDPStream/UDPSClient.h

@@ -78,6 +78,14 @@ public:
     /** Maximum number of concurrent in-flight reassembly slots. */
     static const uint32 UDPS_CLIENT_MAX_REASSEMBLY_SLOTS = 4u;
 
+    /** Maximum size (bytes) of a single reassembled packet payload. A UDPS
+     *  update for one source is fragmented into MaxPayloadSize chunks; this is
+     *  the ceiling on the reassembled total, so it bounds the largest multi-
+     *  fragment packet the client can deliver. Sized for large array bursts
+     *  (e.g. 8x10000 float32 ~= 320 KiB) with headroom; stays well within the
+     *  256-fragment span the recvMask[32] tracks at typical chunk sizes. */
+    static const uint32 UDPS_CLIENT_MAX_PACKET_BYTES = 1048576u; // 1 MiB
+
     /** Default silence timeout before reconnect (seconds). */
     static const uint32 UDPS_CLIENT_DEFAULT_SILENCE_TIMEOUT_S = 5u;
 
@@ -140,10 +148,11 @@ private:
         uint16 totalFragments;  ///< Expected fragment count
         uint16 receivedFragments; ///< How many we have so far
         uint8  recvMask[32];    ///< Bitmask: bit f set iff fragment f received
-        uint8  payload[65535];  ///< Assembled payload buffer
+        uint8  payload[UDPS_CLIENT_MAX_PACKET_BYTES]; ///< Assembled payload buffer
         uint64 firstSeenTicks;  ///< For GC (2 s stale detection)
         bool   active;          ///< Slot in use
         uint32 chunkSize;       ///< Payload bytes per fragment (from first fragment)
+        uint32 assembledBytes;  ///< Exact total payload bytes placed so far
     };
 
     // -------------------------------------------------------------------------