Martino FerrariandClaude Opus 4.6
7102412a9f
Review found the decoder was estimating something the wire states exactly. FrameView::counter increments once per update, so a gap of g means g-1 lost datagrams; reinstating their duration restores the hole precisely, with no threshold and no dependence on arrival time. The arrival-anchor comparison survives only as a backstop for what the counter cannot express — a producer restart, a counter stuck at zero, a wrong declared rate — and can no longer step a signal's timestamps backwards, which the ring and trigger forbid. Also from review: guard the time-signal lookup against a frame carrying more signals than the installed table, and give FrameBuilder a counter parameter. Leaving it at zero had hidden the counter rules from every test, and made the hrt-gap test vacuous — under uniform arrivals the hrt path and packetBurst agree by construction, so it could not tell which branch answered. Its arrivals now carry zero-mean jitter. Each new assertion was proven non-vacuous by sabotage: dropping the gap term, the backward guard, or the hrt branch fails exactly its own test. Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
71 lines
2.6 KiB
C++
71 lines
2.6 KiB
C++
/**
|
|
* @file FrameDecoder.h
|
|
* @brief Per-element timestamp reconstruction for UDPS frames.
|
|
*
|
|
* The C client's udps_frame_element_time() is explicitly an arrival-anchored
|
|
* estimate. It is not sufficient: the kernel frequently delivers several queued
|
|
* datagrams in one burst, so two packets are processed microseconds apart even
|
|
* though each represents ~10 ms of signal, and arrival-time interpolation then
|
|
* crams a packet's samples into that tiny gap — the trace renders as a sawtooth.
|
|
* Source/Applications/StreamHub/UDPSourceSession.cpp documents this failure and
|
|
* solves it; these are the same rules, computed from udps_frame_t's own fields
|
|
* so the scope and StreamHub agree on the same stream.
|
|
*/
|
|
#pragma once
|
|
|
|
#include "TimeBase.h"
|
|
#include "Types.h"
|
|
|
|
#include <vector>
|
|
|
|
namespace udpscope {
|
|
|
|
class FrameDecoder {
|
|
public:
|
|
/** Installs the signal table. Clears all per-signal timing history. */
|
|
void setSignals(const std::vector<SignalMeta>& signals);
|
|
|
|
const std::vector<SignalMeta>& signals() const { return signals_; }
|
|
|
|
/** Call once per frame, before any timestamps() call for that frame. */
|
|
void beginFrame(const FrameView& f);
|
|
|
|
/**
|
|
* @brief Timestamps for every value of signal @p idx in this frame.
|
|
* @return false when the signal produced nothing usable — an empty slot, or
|
|
* the first PACKET burst after connect, which has no previous
|
|
* arrival to span from and would otherwise poison the ring with
|
|
* wrongly spaced timestamps.
|
|
*/
|
|
bool timestamps(const FrameView& f, uint32_t idx, std::vector<double>& tsOut);
|
|
|
|
/** Forgets all timing history; call on reconnect. */
|
|
void reset();
|
|
|
|
private:
|
|
bool packetBurst(uint32_t idx, uint32_t nElems, double wallNow,
|
|
std::vector<double>& tsOut);
|
|
|
|
struct SigState {
|
|
ClockOffset offset;
|
|
double lastPacketWall = 0.0;
|
|
bool lastPacketValid = false;
|
|
double lastAccHrtSec = 0.0;
|
|
bool lastAccValid = false;
|
|
uint32_t prevAccCount = 0;
|
|
/** For accumulated scalars with a declared sampling rate: end timestamp
|
|
* of the most recently emitted burst, and the packet counter it came
|
|
* from. The next burst is chained onto that end, with the counter gap
|
|
* reinstating the exact duration of any lost datagrams. */
|
|
double lastEmittedEnd = 0.0;
|
|
uint32_t lastCounter = 0u;
|
|
bool lastEmittedValid = false;
|
|
};
|
|
|
|
std::vector<SignalMeta> signals_;
|
|
std::vector<SigState> state_;
|
|
HrtRateFit hrtFit_;
|
|
};
|
|
|
|
} /* namespace udpscope */
|