Add sub-bin carrier offset interpolation to v2, drop redundant tracker normalisation

FreqOffset::Estimate picked the carrier from the winning integer FFT bin. A bin
is 46.9 Hz, so a receiver whose offset lands mid-bin keeps up to ~23 Hz of
uncorrected carrier for the whole capture. Add a parabolic fit of the two-tone
metric around the winning bin, behind SUBBIN_INTERP (off for now).

Measured with frequency-shifted copies of the 10k synthetic stream: at a half-bin
offset the integer-bin estimate drops 9656 -> 9499 messages and interpolation
recovers it to 9627, while shifting by exactly one full bin changes nothing. On
southwood (33 min, real hardware, offset -1.45 ppm) it is 6616 -> 6675 (+0.9%).
Note the synthetic bulk stream is generated at exactly zero carrier offset, so it
is blind to this and reports no change.

PhaseTracker kept a unit-normalised copy of the decision line. It fed only proj,
which is consumed through its sign alone, and the EMA recursion never read it, so
the vector was redundant: dot against s directly and drop the member, removing a
sqrt and two divides per sample. Output is byte-identical on kijkduin, airspy,
bulk and southwood.

Author: jvde-github

Source/DSP/Decoder/V2/V2Engine.cpp

@@ -22,6 +22,8 @@
 #include "FFT.h"
 #include "Filters.h"
 
+#define SUBBIN_INTERP 0
+
 namespace V2
 {
 	// tuning
@@ -108,7 +110,24 @@ namespace V2
 		if (fz < 0)
 			return 0.0f;
 
-		return (fft_length / 2 - (fz + delta / 2.0f)) / 2.0f / fft_length;
+		float frac = 0.0f;
+
+#if SUBBIN_INTERP
+		if (fz > 0 && fz + delta + 1 < fft_length)
+		{
+			const float a = magnitude[fz - 1] + magnitude[fz - 1 + delta];
+			const float c = magnitude[fz + 1] + magnitude[fz + 1 + delta];
+			const float den = a - 2.0f * max_val + c;
+
+			if (den < 0.0f)
+			{
+				frac = 0.5f * (a - c) / den;
+				frac = frac > 0.5f ? 0.5f : (frac < -0.5f ? -0.5f : frac);
+			}
+		}
+#endif
+
+		return (fft_length / 2 - (fz + frac + delta / 2.0f)) / 2.0f / fft_length;
 	}
 
 	void FreqOffset::Derotate(float f, const CFLOAT32 *src, CFLOAT32 *dst, int len)
@@ -190,15 +209,11 @@ namespace V2
 		const float alpha = training ? weight_train : weight;
 		const float beta = 1.0f - alpha;
 
-		const float proj = z.real() * u.real() + z.imag() * u.imag();
+		const float proj = z.real() * s.real() + z.imag() * s.imag();
 		const float d = proj >= 0.0f ? 1.0f : -1.0f;
 
 		s = alpha * s + (beta * d) * z;
 
-		const float mag = sqrtf(norm2(s));
-		if (mag > 1e-12f)
-			u = s / mag;
-
 		// differential decision (NRZI-style, cancels any 180-degree offset)
 		const int decision = proj > 0.0f ? 1 : 0;
 		const int bit = decision ^ prev_decision;

Source/DSP/Decoder/V2/V2Engine.h

@@ -64,7 +64,6 @@ namespace V2
 	{
 		unsigned rot = 0;
 		CFLOAT32 s = CFLOAT32(0.0f, 0.0f); // decision-folded EMA
-		CFLOAT32 u = CFLOAT32(1.0f, 0.0f); // decision line direction (unit)
 		int prev_decision = 0;
 		float weight = 0.86f;		// tracking, after sync
 		float weight_train = 0.75f; // acquisition, while training