Merge pull request #1014 from eshaz/ld-wow-smoothing

add option to smooth wow brightness correction

Author: happycube

lddecode/core.py

@@ -1462,7 +1462,9 @@ def __init__(
         initphase=False,
         fields_written=0,
         readloc=0,
-        use_threads=True
+        use_threads=True,
+        wow_level_adjust_smoothing=0,
+        wow_interpolation_method="linear"
     ):
         self.rawdata = decode["input"]
         self.data = decode
@@ -1497,6 +1499,9 @@ def __init__(
 
         self.use_threads = use_threads
 
+        self.wow_level_adjust_smoothing = wow_level_adjust_smoothing
+        self.wow_interpolation_method = wow_interpolation_method
+
     @profile
     def process(self):
         self.linelocs1, self.linebad, self.nextfieldoffset = self.compute_linelocs()
@@ -2452,38 +2457,37 @@ def fix_badlines(self, linelocs_in, linelocs_backup_in=None):
 
         return linelocs
 
-    def computewow_scaled(self, kind='linear'):
+    def computewow_scaled(self):
         """Compute how much the line deviates fron expected,
            and scale input samples to output samples
         """
-        if self.interpolated_pixel_locs is None:
-            actual_linelocs = np.array(self.linelocs, dtype=np.float64)
-            expected_linelocs = np.array([i * self.inlinelen for i in range(len(actual_linelocs))], dtype=np.float64)
-
-            outscale = self.inlinelen / self.outlinelen
-            outsamples = self.outlinecount * self.outlinelen
-            outline_offset = (self.lineoffset + 1) * self.outlinelen
-
-            if kind == 'linear':
-                k=1
-                bc_type=None
-            elif kind == 'quadratic':
-                k=2
-                bc_type=None
-            elif kind == 'cubic':
-                k=3
-                bc_type='natural'
-
-            # create a spline that interpolates the exact sample value based on expected vs. actual line locations
-            spl = interpolate.make_interp_spline(expected_linelocs, actual_linelocs, k=k, bc_type=bc_type, check_finite=False)
-
-            # scale up to compute where the output pixel would fall on the interpolated line loc
-            scaled_pixel_locs = np.arange(outsamples + outline_offset) * outscale
-
-            # interpolate the expected pixel location
-            self.interpolated_pixel_locs = spl(scaled_pixel_locs)
-            # amount of wow for each scaled pixel
-            self.wowfactors = spl(scaled_pixel_locs, 1)
+        actual_linelocs = np.array(self.linelocs, dtype=np.float64)
+        expected_linelocs = np.array([i * self.inlinelen for i in range(len(actual_linelocs))], dtype=np.float64)
+
+        outscale = self.inlinelen / self.outlinelen
+        outsamples = self.outlinecount * self.outlinelen
+        outline_offset = (self.lineoffset + 1) * self.outlinelen
+
+        if self.wow_interpolation_method == 'linear':
+            k=1
+            bc_type=None
+        elif self.wow_interpolation_method == 'quadratic':
+            k=2
+            bc_type=None
+        elif self.wow_interpolation_method == 'cubic':
+            k=3
+            bc_type='natural'
+
+        # create a spline that interpolates the exact sample value based on expected vs. actual line locations
+        spl = interpolate.make_interp_spline(expected_linelocs, actual_linelocs, k=k, bc_type=bc_type, check_finite=False)
+
+        # scale up to compute where the output pixel would fall on the interpolated line loc
+        scaled_pixel_locs = np.arange(outsamples + outline_offset) * outscale
+
+        # interpolate the expected pixel location
+        self.interpolated_pixel_locs = spl(scaled_pixel_locs)
+        # amount of wow for each scaled pixel
+        self.wowfactors = spl(scaled_pixel_locs, 1)
 
         return self.interpolated_pixel_locs, self.wowfactors
 
@@ -2562,6 +2566,7 @@ def downscale(
             wowfactors,
             self.lineoffset,
             outwidth,
+            wow_level_adjust_smoothing=self.wow_level_adjust_smoothing
         )
 
         if self.rf.decode_digital_audio:
@@ -3510,6 +3515,8 @@ def __init__(
 
         self.autoMTF = True
         self.useAGC = extra_options.get("useAGC", True)
+        self.wow_level_adjust_smoothing = extra_options.get("wow_level_adjust_smoothing", 0)
+        self.wow_interpolation_method = extra_options.get("wow_interpolation_method", "linear")
 
         self.verboseVITS = False
 
@@ -3893,6 +3900,8 @@ def decodefield(self, start, mtf_level, prevfield=None, initphase=False, redo=Fa
             initphase=initphase,
             fields_written=self.fields_written,
             readloc=rawdecode["startloc"],
+            wow_level_adjust_smoothing=self.wow_level_adjust_smoothing,
+            wow_interpolation_method=self.wow_interpolation_method
         )
 
         # set an object-level variable to make notebook debugging easier

lddecode/main.py

@@ -22,6 +22,7 @@ def main(args=None):
     parser = argparse.ArgumentParser(
         description="Extracts audio and video from raw RF laserdisc captures",
         epilog=options_epilog,
+        formatter_class=argparse.RawTextHelpFormatter
     )
     parser.add_argument("infile", metavar="infile", type=str, help="source file")
     parser.add_argument(
@@ -210,6 +211,29 @@ def main(args=None):
         help="Strength of deemphasis (default 1.0)",
     )
 
+    parser.add_argument(
+        "--wow_level_adjust_smoothing",
+        type=float,
+        default=0,
+        help=(
+            "Adjusts the amount of smoothing in lines that is performed when compensating for brightness variations caused by wow. (default 0)"
+            "\nWow calculation is based on position of hsync pulses which is affected by the accuracy of the TBC. "
+            "\nIf you see vertical brightness variations (banding), setting to a value larger than 0 will smooth the wow adjustment."
+        )
+    )
+    parser.add_argument(
+        "--wow_interpolation_method",
+        type=str,
+        default="linear",
+        choices=["linear", "quadratic", "cubic"],
+        help=(
+            "Sets the type of interpolation spline used to correct wow."
+            "\n  linear     [default]"
+            "\n  quadratic"
+            "\n  cubic"
+        )
+    )
+
     parser.add_argument(
         "-t",
         "--threads",
@@ -330,6 +354,8 @@ def main(args=None):
         "audio_filterwidth": args.audio_filterwidth,
         "AC3": args.AC3,
         "use_profiler": args.use_profiler,
+        "wow_level_adjust_smoothing": args.wow_level_adjust_smoothing,
+        "wow_interpolation_method": args.wow_interpolation_method
     }
 
     if vid_standard == "NTSC" and args.NTSC_color_notch_filter:

lddecode/utils.py

@@ -71,7 +71,7 @@ def scale(buf, begin, end, tgtlen, mult=1):
 
 # Scales and compensates for wow-induced playback-speed variations
 @njit(nogil=True, cache=True, fastmath=True)
-def scale_field(buf, dsout, interpolated_pixel_locs, wowfactors, lineoffset, outwidth, level_adjust_threshold = 15):
+def scale_field(buf, dsout, interpolated_pixel_locs, wowfactors, lineoffset, outwidth, wow_level_adjust_smoothing = 0, level_adjust_threshold = 15):
     # Constants preserved as float32
     point_5 = np.float32(0.5)
     two = np.float32(2)
@@ -95,6 +95,15 @@ def scale_field(buf, dsout, interpolated_pixel_locs, wowfactors, lineoffset, out
         wowfactors
     )
 
+    if wow_level_adjust_smoothing > 0:
+        # removes oscillating brightness variations for video with lots of noise around the hsync pulses, i.e. noisy line locations result in noisy wow calculations
+        # applies a low pass filter that smooths any sudden brightness variations while still being reactive enough to compensate for low frequency wow
+        alpha = 1 / (wow_level_adjust_smoothing * outwidth)
+        one_minus_alpha = 1 - alpha
+
+        for i in range(1, len(level_adjusts)):
+            level_adjusts[i] = alpha * level_adjusts[i] + one_minus_alpha * level_adjusts[i-1]       
+
     for i in range(lineoffset_out_samples, len(dsout) + lineoffset_out_samples):
         # compensates for the amplitude/frequency shift caused by FM demodulation under varying playback speed.
         level_adjust = level_adjusts[i]