rfdecode: half-spectrum rfft/irfft for rfhpf and video outputs

Port from dp11's tree: the rfhpf dropout filter and the FVideo/FVideo05/
FVideoBurst/FVideoPilot output cluster operate on real signals through
conjugate-symmetric filters, so the full complex fft/ifft.real pairs are
exactly replaceable by half-spectrum rfft/irfft at roughly half the
transform cost (~2.3x on the transforms themselves).

Verified bit-identical (.tbc/.pcm/.efm md5) on ve-snw-cut (NTSC) and
jason-testpattern (PAL), both -t8.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: happycube

lddecode/rfdecode.py

@@ -376,6 +376,10 @@ def computevideofilters(self):
         # This high pass filter is intended to detect RF dropouts
         Frfhpf = sps.butter(1, 10 / self.freq_half, btype="highpass")
         self.Filters["Frfhpf"] = filtfft(Frfhpf, self.blocklen)
+        # Frfhpf is a real (conjugate-symmetric) filter and the input RF is real,
+        # so ifft(indata_fft * Frfhpf).real is exactly irfft over the half spectrum
+        # at ~half the transform cost.  Keep the positive-frequency half.
+        self.Filters["Frfhpf_half"] = self.Filters["Frfhpf"][: self.blocklen // 2 + 1]
 
         # First phase FFT filtering
 
@@ -691,7 +695,12 @@ def demodblock(self, data=None, mtf_level=0, fftdata=None, cut=False,
         if getattr(self, "delays", None) is not None and "video_rot" in self.delays:
             rotdelay = self.delays["video_rot"]
 
-        rv["rfhpf"] = npfft.ifft(indata_fft * self.Filters["Frfhpf"]).real
+        # Real filter + real RF input => half-spectrum irfft is exact (see
+        # computevideofilters).
+        nrf = indata_fft.shape[0] // 2 + 1
+        rv["rfhpf"] = npfft.irfft(
+            indata_fft[:nrf] * self.Filters["Frfhpf_half"], n=self.blocklen
+        )
         rv["rfhpf"] = rv["rfhpf"][
             self.blockcut - rotdelay : -self.blockcut_end - rotdelay
         ].astype(np.float32)
@@ -730,17 +739,22 @@ def demodblock(self, data=None, mtf_level=0, fftdata=None, cut=False,
         hilbert = npfft.ifft(indata_fft_filt)
         demod = unwrap_hilbert(hilbert, self.freq_hz)
 
-        # use a clipped demod for video output processing to reduce speckling impact
-        demod_fft = npfft.fft(np.clip(demod, 1500000, self.freq_hz * 0.75))
+        # use a clipped demod for video output processing to reduce speckling impact.
+        # demod is real and these video outputs are real, so the half-spectrum
+        # rfft/irfft pair is mathematically identical to fft/ifft.real (the filters
+        # are conjugate-symmetric) at ~2.3x the speed of the full complex transforms.
+        demod_fft = npfft.rfft(np.clip(demod, 1500000, self.freq_hz * 0.75))
+        nr = demod_fft.shape[0]
+        bl = self.blocklen
 
-        out_video = npfft.ifft(demod_fft * self.Filters["FVideo"]).real
+        out_video = npfft.irfft(demod_fft * self.Filters["FVideo"][:nr], n=bl)
 
-        out_video05 = npfft.ifft(demod_fft * self.Filters["FVideo05"]).real
+        out_video05 = npfft.irfft(demod_fft * self.Filters["FVideo05"][:nr], n=bl)
 
-        out_videoburst = npfft.ifft(demod_fft * self.Filters["FVideoBurst"]).real
+        out_videoburst = npfft.irfft(demod_fft * self.Filters["FVideoBurst"][:nr], n=bl)
 
         if self.system == "PAL":
-            out_videopilot = npfft.ifft(demod_fft * self.Filters["FVideoPilot"]).real
+            out_videopilot = npfft.irfft(demod_fft * self.Filters["FVideoPilot"][:nr], n=bl)
             video_out = np.rec.array(
                 [
                     out_video.astype(np.float32),