diff --git a/CLAUDE.md b/CLAUDE.md
index fac2975..17f8fd4 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -114,6 +114,7 @@ VapourBox/
 | `worker/src/script_generator.rs` | Template substitution for .vpy |
 | `worker/src/pipeline_executor.rs` | vspipe \| ffmpeg execution |
 | `worker/src/pixel_format.rs` | Source `pix_fmt` → pipe format (see "Source Pixel Formats") |
+| `worker/templates/stabilize.py` | Stabilize pass's vertical pitch correction (see "Stabilize") |
 | `worker/src/cpu.rs` | The x86 deps CPU tier (`v3`/`v2`) — the single decision; see "CPU tiers" |
 | `worker/src/source_decode.rs` | Decoder ffmpeg args for encode + preview: full stored frame, size-guarded (see "Source Frame Size") |
 | `worker/src/source_timing.rs` | A variable-frame-rate source's stored frames placed on the constant-rate grid (see "Variable Frame Rate Sources") |
@@ -146,6 +147,7 @@ VapourBox/
 | `app/lib/services/filter_loader.dart` | Load filter schemas from JSON |
 | `app/lib/services/preset_service.dart` | Save/load user presets |
 | `app/lib/services/temp_directory_service.dart` | Configurable scratch-file directory (see "Temporary Files Directory") |
+| `app/lib/services/pitch_factor_file.dart` | Per-video pitch factor files: sidecar lookup + summary (see "Stabilize") |
 | `app/lib/services/overwrite_behavior_service.dart` | Default action for existing output files (see "Existing Output Files") |
 | `app/lib/models/native_res_report.dart` | What `--detect-native` found, as the Descale panel's Detect shows and applies it |
 | `app/lib/models/crop_detect_report.dart` | What `--detect-crop` found, and which suggestion (`CropApply`) the panel applies |
@@ -835,6 +837,38 @@ Three things decide the shape of the output, and they live in different places:
 else so a typo falls back to the source's own aspect rather than reaching ffmpeg
 as a broken filter argument.
 
+**The preview has to show the same shape (issue #149).** The preview PNG carries
+no aspect, so the app used to draw the processed frame at the **source's**
+display aspect. Anything a pass reshaped (a 720x576 4:3 source resized and
+padded to 1920x1080, say) came out squashed. Three invariants now hold:
+
+- **One decision, two consumers.** `ProcessingPipeline::output_aspect(input_sar)`
+  (rotation-adjusted SAR → `aspect_declaration`) is used by the encode's
+  `setsar`/`setdar` **and** by the preview. The preview reports it on its
+  `PREVIEW_INFO:` stderr line as `sar=N/D` or `dar=N/D` (nothing for square
+  pixels). `PreviewFrameInfo.displayAspectFor` turns that plus the PNG's size into
+  the shape to draw.
+- **Each side has its own aspect.** `BeforeAfterComparisonWidget` takes
+  `beforeAspectRatio` (source) and `afterAspectRatio` (processed). 1:1 is
+  measured against the processed one. The processed aspect is stored on the
+  `QueueItem` next to the image (`processedPreviewAspect`), not read from
+  `previewFrameInfo`, which goes null as soon as the scrubber moves.
+- **The preview job must carry `inputSar`.** `{{SOURCE_SAR}}` falls back to 1
+  without it, so square-pixel fitting previewed a different frame from the
+  one encoded (1350 vs 1440 wide in the #149 setup). `PreviewGenerator` reads it
+  through the same `FieldOrderDetector.normalizeSar` as the encode job.
+
+The panel reads both sides' aspects from the view model
+(`sourceDisplayAspect`, `comparisonAfterAspect`), not from its own arithmetic,
+so the wiring is testable without a worker (`debugAcceptProcessedPreview`).
+
+Covered by `test_185` (Rust), `preview_frame_info_test`, `preview_aspect_test`
+(including the view-model wiring: an unreshaped anamorphic source keeps its
+shape, the aspect survives a scrubber move), `before_after_comparison_test`, and
+the heavy `preview aspect (issue #149)` group in `integration_aspect_ratio_test.dart`,
+which compares the preview with the encode for square, preserve, forced DAR,
+denoise-only anamorphic and rotated anamorphic jobs.
+
 ### Borders (issue #86)
 
 Two ways to add bars, sharing one step at the **very end of both templates**
@@ -1099,6 +1133,72 @@ MB, null = off). `EncodingSettings::effective_max_cache_size_mb` treats 0 as
 off. `test_162` asserts both scripts. Don't reintroduce a hard-coded value —
 SD never reaches the cap, so a too-low one passes every SD test.
 
+### Stabilize: weave and pitch (issue #150)
+
+One pass, two independent corrections, weave first. It runs **last before
+framing** (after Colour Correction, before Rotate / Flip and Crop & Resize), so
+a crop can remove the edges both corrections expose.
+
+- **Weave / shake** — havsfunc `Stab(clp, dxmax, dymax, mirror)`
+  (`mv.DepanEstimate` / `DepanCompensate` against a 15-frame average), called
+  straight from both templates. On by default (`weave: true`).
+- **Vertical pitch ("frame height breathing")** — pull-through film scanners
+  let the film slip in the gate, so each frame is a fraction of a percent
+  taller or shorter than the last. `worker/templates/stabilize.py`
+  (`correct_pitch`, imported by **both** templates so preview and encode can't
+  drift) resamples each frame about its centre at a **constant frame size**
+  (`src_top`/`src_height`), sub-pixel. Rounding the height to even pixels and
+  padding back, as the issue proposed, makes any correction under ~0.19% at
+  1080 lines a no-op — i.e. all real breathing. **Off by default.**
+  - `auto`: the relative scale + shift between **adjacent** frames is measured
+    by grid search on a narrow luma strip, then each frame is corrected to the
+    mean of its ±radius window. Comparing against a temporal *average* was
+    clearly less accurate: motion and the breathing itself blur the average.
+    Pairs whose best match still differs by > 3/255 are treated as cuts.
+    Stateless per frame, so a preview measures exactly what the encode does.
+  - `file`: one factor per **source** frame. The factor is the *measured*
+    height ratio (1.004 = 0.4% too tall); `invertFactors` accepts the other
+    convention.
+
+Invariants that are easy to break:
+
+- **A pipeline saved before pitch existed must produce the same script.** Old
+  JSON has only `enabled/dxmax/dymax/mirror`; it deserialises to weave on,
+  pitch off, and the generator emits the Stab block byte-for-byte as before
+  (the inner `{{#STAB_WEAVE}}`/`{{#STAB_PITCH}}` tags go with their whole
+  lines — `keep_block_lines`). `test_212` pins it.
+- **The pass's temporal reach is declared.** `Stab` reads n-8…n+9 (measured
+  under vspipe: the ±7 average, its scene-change look-ahead, and Depan's
+  interleaved pair), auto pitch another radius+1. `StabilizeParameters::radius`
+  feeds the preview window and `pipe_cache_frames`; it used to be treated as
+  spatial, which starved a windowed preview.
+- **Every per-frame lookup must add the clip's source-frame offset.** Frame `n`
+  in the script is not source frame `n`: the preview decodes a window starting
+  at `first` (`PreviewParams::source_frame_offset`), a trimmed encode starts at
+  `start_frame`, and double-rate deinterlacing or IVTC before the pass changes
+  the count (`ProcessingPipeline::rate_before_stabilize`, composed from the
+  `FrameMap`s of the passes ahead of it). Lose any of these and every frame
+  gets another frame's factor, with no error.
+- **The factor file is per job, never per pipeline.** `VideoJob.pitchFactorsPath`
+  (Rust and Dart), set from `QueueItem.pitchFactorsPath`. Pipelines are saved
+  into presets shared by every video in the queue. `<video>.pitch.txt` (also
+  `<stem>.pitch.txt`, `<stem>_pitch.txt`) is picked up when a video is added.
+- **File mode without a usable file is an error**, raised by the script
+  generator with the bad line's number — not a silent pass-through.
+- **Pitch on a still-interlaced clip clears `_FieldBased`** (a vertical resample
+  would mix the fields; film scans are progressive). Weave alone leaves it.
+- **`pipe_source` evicts silently.** It keeps `cache_frames` decoded frames and
+  returns the *last* frame read for anything already evicted. The cache is
+  sized from the pipeline's declared radius (`pipe_cache_frames`, never below
+  the old 40), so a pass with a large window must report it through its
+  `FrameMap` radius.
+
+Tests: `test_211`…`test_218` (script generation, legacy block, offsets, errors,
+cache size, field marking) and `app/test/integration_stabilize_test.dart`
+(heavy), which injects known breathing with the pass's own file mode and checks
+that file mode, auto mode and the preview each bring the picture back toward
+the undistorted original.
+
 ### Temporary Files Directory
 
 Scratch files default to the system temp directory; the user can redirect them
diff --git a/README.md b/README.md
index 715835a..da876cd 100644
--- a/README.md
+++ b/README.md
@@ -125,7 +125,7 @@ Most sources need only a few of these, and the presets pick them for you. Filter
 | 14 | **Chroma Fixes** | Colour shifted off the picture, bleeding, rainbowing, dot crawl and leftover combing |
 | 15 | **Colourisation** | Black-and-white footage, coloured by AI (DDColor or DeOldify Video, optional downloads); the brightness of every pixel is kept exactly |
 | 16 | **Color Correction** | Brightness, contrast, saturation, levels, white balance, shadow detail and local contrast, set by hand or measured |
-| 17 | **Stabilize** | Shake and weave from telecine, film scans or a handheld camera |
+| 17 | **Stabilize** | Shake and weave from telecine, film scans or a handheld camera, and the frame-height "breathing" of pull-through film scanners (8mm, Super 8): measured from the footage, or read per frame from a factor file (`reel.pitch.txt` next to `reel.mp4` is picked up automatically) |
 | 18 | **Rotate / Flip** | Sideways, upside-down or mirrored footage |
 | 19 | **Crop & Resize** | Black borders, tape blanking and head-switching noise (measured for you by **Detect borders**), scaling and upscaling (edge-directed or AI) with SD colour converted to HD's BT.709, and borders to reach an exact frame size |
 | 20 | **Face Restoration** | Blurry, low-resolution faces, redrawn by AI at the output resolution (optional download) |
diff --git a/app/assets/filters/core/stabilize.json b/app/assets/filters/core/stabilize.json
index 1be89ba..9be170d 100644
--- a/app/assets/filters/core/stabilize.json
+++ b/app/assets/filters/core/stabilize.json
@@ -1,10 +1,10 @@
 {
   "$schema": "https://vapourbox.app/schemas/filter-v1.json",
   "id": "stabilize",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "name": "Stabilize",
-  "description": "Remove shake and weave from the picture",
-  "longDescription": "Measures how much the whole frame moves between shots and cancels it, so a shaky capture holds still. Deliberate camera movement survives: only the difference from the recent trend is removed.\n\nUse it on telecine weave, film scans that wobble in the gate, and handheld camcorder footage. It runs last before cropping, because it shifts the picture within the frame and leaves thin empty edges — a small crop afterwards removes them.\n\nThe shift leaves thin empty edges; set Fill Exposed Edges to mirror them back in, or crop them away afterwards.",
+  "description": "Remove shake, gate weave and frame-height breathing",
+  "longDescription": "Two independent corrections.\n\nRemove Shake / Weave measures how much the whole frame moves and cancels it, so a shaky capture holds still. Deliberate camera movement survives: only the difference from the recent trend is removed. Use it on telecine weave, film scans that wobble in the gate, and handheld camcorder footage.\n\nPitch Correction removes \"breathing\" in scanned 8mm, Super 8 and 16mm film: on pull-through scanners the film slips in the gate, so each frame comes out a fraction of a percent taller or shorter than the last, which a position stabiliser can't fix. Auto measures it from the footage, comparing each frame with its neighbours, so slow intentional zooms and tilts are kept. From File uses one factor per frame from a text file (reel.pitch.txt next to the video is picked up automatically).\n\nThe pass runs last before cropping, because both corrections move picture within the frame and leave thin edges: fill them below, or crop them away afterwards.",
   "category": "cleanup",
   "icon": "stay_current_landscape",
   "order": 11,
@@ -47,6 +47,14 @@
         "hidden": true
       }
     },
+    "weave": {
+      "type": "boolean",
+      "default": true,
+      "ui": {
+        "label": "Remove Shake / Weave",
+        "description": "Steady frame-to-frame bounce, side-to-side drift and handheld shake"
+      }
+    },
     "dxmax": {
       "type": "integer",
       "default": 4,
@@ -56,7 +64,10 @@
       "ui": {
         "label": "Max Horizontal Shift",
         "description": "Largest sideways correction, in pixels. 0 leaves the horizontal axis alone",
-        "widget": "slider"
+        "widget": "slider",
+        "visibleWhen": {
+          "weave": true
+        }
       }
     },
     "dymax": {
@@ -68,7 +79,10 @@
       "ui": {
         "label": "Max Vertical Shift",
         "description": "Largest up/down correction, in pixels. 0 leaves the vertical axis alone",
-        "widget": "slider"
+        "widget": "slider",
+        "visibleWhen": {
+          "weave": true
+        }
       }
     },
     "mirror": {
@@ -83,20 +97,122 @@
       "ui": {
         "label": "Fill Exposed Edges",
         "description": "Shifting the picture leaves thin empty edges. 0 leaves them black, 1 fills top and bottom, 2 left and right, 3 all four — which saves cropping afterwards",
-        "widget": "dropdown"
+        "widget": "dropdown",
+        "visibleWhen": {
+          "weave": true
+        }
+      }
+    },
+    "pitchMode": {
+      "type": "enum",
+      "default": "off",
+      "options": [
+        "off",
+        "auto",
+        "file"
+      ],
+      "ui": {
+        "label": "Pitch Correction",
+        "description": "Even out frame-height breathing from film slipping in a scanner's gate",
+        "widget": "dropdown",
+        "optionLabels": {
+          "off": "Off",
+          "auto": "Auto (measure from video)",
+          "file": "From File (per-frame factors)"
+        }
+      }
+    },
+    "maxPitchDeviation": {
+      "type": "number",
+      "default": 1.0,
+      "min": 0.1,
+      "max": 5.0,
+      "step": 0.1,
+      "ui": {
+        "label": "Max Pitch Correction (%)",
+        "description": "Largest height change applied to a frame; also limits values from a file. Auto measures more coarsely above about 1%, so keep it near the breathing you see",
+        "widget": "slider",
+        "precision": 1,
+        "visibleWhen": {
+          "pitchMode": [
+            "auto",
+            "file"
+          ]
+        }
+      }
+    },
+    "smoothingRadius": {
+      "type": "integer",
+      "default": 10,
+      "min": 2,
+      "max": 30,
+      "step": 1,
+      "ui": {
+        "label": "Comparison Window",
+        "description": "Frames each side a frame is compared with. Larger smooths more but follows quick zooms less closely",
+        "widget": "slider",
+        "visibleWhen": {
+          "pitchMode": "auto"
+        }
+      }
+    },
+    "invertFactors": {
+      "type": "boolean",
+      "default": false,
+      "ui": {
+        "label": "Factors Are Corrections",
+        "description": "Tick if the file lists the stretch to apply, not the measured frame height",
+        "visibleWhen": {
+          "pitchMode": "file"
+        }
+      }
+    },
+    "pitchEdgeFill": {
+      "type": "enum",
+      "default": "extend",
+      "options": [
+        "extend",
+        "black"
+      ],
+      "ui": {
+        "label": "Pitch Edge Fill",
+        "description": "What fills the rows a pitch correction moves in from outside the frame",
+        "widget": "dropdown",
+        "optionLabels": {
+          "extend": "Extend picture",
+          "black": "Black"
+        },
+        "visibleWhen": {
+          "pitchMode": [
+            "auto",
+            "file"
+          ]
+        }
       }
     }
   },
   "ui": {
     "sections": [
       {
-        "title": "Settings",
+        "title": "Shake / Weave",
         "parameters": [
+          "weave",
           "dxmax",
           "dymax",
           "mirror"
         ],
         "expanded": true
+      },
+      {
+        "title": "Pitch (Frame Height)",
+        "parameters": [
+          "pitchMode",
+          "maxPitchDeviation",
+          "smoothingRadius",
+          "invertFactors",
+          "pitchEdgeFill"
+        ],
+        "expanded": true
       }
     ]
   },
diff --git a/app/lib/models/parameter_converter.dart b/app/lib/models/parameter_converter.dart
index e98f432..52698fc 100644
--- a/app/lib/models/parameter_converter.dart
+++ b/app/lib/models/parameter_converter.dart
@@ -420,9 +420,15 @@ class ParameterConverter {
       enabled: params.enabled,
       values: {
         'method': 'stab',
+        'weave': params.weave,
         'dxmax': params.dxmax,
         'dymax': params.dymax,
         'mirror': params.mirror,
+        'pitchMode': params.pitchMode.value,
+        'maxPitchDeviation': params.maxPitchDeviation,
+        'smoothingRadius': params.smoothingRadius,
+        'invertFactors': params.invertFactors,
+        'pitchEdgeFill': params.pitchEdgeFill.value,
       },
     );
   }
@@ -432,9 +438,15 @@ class ParameterConverter {
     final v = params.values;
     return StabilizeParameters(
       enabled: params.enabled,
+      weave: v['weave'] as bool? ?? true,
       dxmax: _asInt(v['dxmax']) ?? 4,
       dymax: _asInt(v['dymax']) ?? 4,
       mirror: _asInt(v['mirror']) ?? 0,
+      pitchMode: PitchMode.fromValue(v['pitchMode'] as String?),
+      maxPitchDeviation: (v['maxPitchDeviation'] as num?)?.toDouble() ?? 1.0,
+      smoothingRadius: _asInt(v['smoothingRadius']) ?? 10,
+      invertFactors: v['invertFactors'] as bool? ?? false,
+      pitchEdgeFill: EdgeFill.fromValue(v['pitchEdgeFill'] as String?),
     );
   }
 
diff --git a/app/lib/models/preview_frame_info.dart b/app/lib/models/preview_frame_info.dart
index 5f3f234..e6cfc24 100644
--- a/app/lib/models/preview_frame_info.dart
+++ b/app/lib/models/preview_frame_info.dart
@@ -1,25 +1,46 @@
+import 'dart:ui' show Size;
+
 /// What the worker says it rendered for a preview: its `PREVIEW_INFO:` line.
 ///
 /// A source frame can have several output frames — two under a ×2 frame rate
 /// or double-rate deinterlacing, two or three at 24 → 60. [subFrame] is which
 /// of them this is, and [generated] whether it was made by interpolation
 /// rather than taken from a source frame (issue #129).
+///
+/// The line also carries the aspect the encode will declare for the frame —
+/// `sar=16/15` or `dar=16/9`, absent for square pixels — because the PNG
+/// carries none (issue #149).
 class PreviewFrameInfo {
   final int frame;
   final int subFrame;
   final int subFrames;
   final bool generated;
 
+  /// The sample aspect ratio the encode stamps on the output, or null for
+  /// square pixels.
+  final double? outputSar;
+
+  /// A forced display aspect the encode stamps instead of a SAR, or null.
+  final double? outputDar;
+
   const PreviewFrameInfo({
     required this.frame,
     this.subFrame = 0,
     this.subFrames = 1,
     this.generated = false,
+    this.outputSar,
+    this.outputDar,
   });
 
   /// Whether there is more than one output frame to step through.
   bool get hasSubFrames => subFrames > 1;
 
+  /// The shape the rendered frame has on screen, given its stored size: the
+  /// display aspect the encode will have. A worker that reports no aspect
+  /// reads as square pixels — the frame's own shape.
+  double displayAspectFor(Size pixels) =>
+      outputDar ?? pixels.width / pixels.height * (outputSar ?? 1.0);
+
   /// The last `PREVIEW_INFO:` line in a worker's stderr, or null if there is
   /// none. A worker from before sub-frames reports only `frame=`, which reads
   /// as a single real frame.
@@ -28,20 +49,46 @@ class PreviewFrameInfo {
         .split('\n')
         .where((l) => l.trimLeft().startsWith('PREVIEW_INFO:'));
     if (lines.isEmpty) return null;
-    final fields = <String, int>{};
+    final fields = <String, String>{};
     for (final pair in lines.last.trim().substring('PREVIEW_INFO:'.length).split(' ')) {
       final kv = pair.split('=');
-      final value = kv.length == 2 ? int.tryParse(kv[1]) : null;
-      if (value != null) fields[kv[0]] = value;
+      if (kv.length == 2) fields[kv[0]] = kv[1];
     }
-    final frame = fields['frame'];
+    int? integer(String key) {
+      final v = fields[key];
+      return v == null ? null : int.tryParse(v);
+    }
+
+    final frame = integer('frame');
     if (frame == null) return null;
-    final subFrames = (fields['sub_frames'] ?? 1).clamp(1, 1 << 20);
+    final subFrames = (integer('sub_frames') ?? 1).clamp(1, 1 << 20);
     return PreviewFrameInfo(
       frame: frame,
-      subFrame: (fields['sub_frame'] ?? 0).clamp(0, subFrames - 1),
+      subFrame: (integer('sub_frame') ?? 0).clamp(0, subFrames - 1),
       subFrames: subFrames,
-      generated: fields['generated'] == 1,
+      generated: integer('generated') == 1,
+      outputSar: parseRatio(fields['sar']),
+      outputDar: parseRatio(fields['dar']),
     );
   }
+
+  /// A ratio written `16/9`, `16:9` or `1.7778`, or null for anything that is
+  /// not a finite positive number — so a malformed token falls back to the
+  /// frame's own shape instead of drawing it zero-wide.
+  static double? parseRatio(String? text) {
+    if (text == null) return null;
+    final t = text.trim();
+    if (t.isEmpty) return null;
+    final parts = t.split(RegExp('[:/]'));
+    double? ratio;
+    if (parts.length == 2) {
+      final num = double.tryParse(parts[0].trim());
+      final den = double.tryParse(parts[1].trim());
+      if (num == null || den == null || den == 0) return null;
+      ratio = num / den;
+    } else if (parts.length == 1) {
+      ratio = double.tryParse(t);
+    }
+    return ratio != null && ratio.isFinite && ratio > 0 ? ratio : null;
+  }
 }
diff --git a/app/lib/models/processing_pipeline.dart b/app/lib/models/processing_pipeline.dart
index e738e0d..2891e79 100644
--- a/app/lib/models/processing_pipeline.dart
+++ b/app/lib/models/processing_pipeline.dart
@@ -139,7 +139,7 @@ extension PassTypeExtension on PassType {
       case PassType.antiAlias:
         return 'Smooth stair-stepping on diagonal edges';
       case PassType.stabilize:
-        return 'Remove shake and weave from the picture';
+        return 'Remove shake, gate weave and frame-height breathing';
       case PassType.geometry:
         return 'Rotate or mirror the picture';
       case PassType.grain:
diff --git a/app/lib/models/queue_item.dart b/app/lib/models/queue_item.dart
index dcfddb0..6d6f858 100644
--- a/app/lib/models/queue_item.dart
+++ b/app/lib/models/queue_item.dart
@@ -60,6 +60,11 @@ class QueueItem {
   /// Extraction progress (0.0 to 1.0), used during DVD extraction.
   double extractionProgress;
 
+  /// Pitch factor file for the Stabilize pass in "From File" mode. Per video,
+  /// because a factor log belongs to one film. Found automatically as a
+  /// sidecar when the video is added (see PitchFactorFile).
+  String? pitchFactorsPath;
+
   // Per-video in/out markers (normalized 0.0-1.0)
   double? inPoint;
   double? outPoint;
@@ -69,6 +74,12 @@ class QueueItem {
   double scrubberPosition;
   Uint8List? currentFrame;
   Uint8List? processedPreview;
+
+  /// The display aspect [processedPreview] is drawn at: the shape the encode
+  /// will have, from the aspect the worker reported for it. Kept with the
+  /// image rather than read from the frame info, which is dropped as soon as
+  /// the scrubber moves while this image is still on screen (issue #149).
+  double? processedPreviewAspect;
   double timelineZoom;
   double timelineViewStart;
 
@@ -90,12 +101,14 @@ class QueueItem {
     this.videoInfo,
     this.dvdSourceInfo,
     this.extractionProgress = 0.0,
+    this.pitchFactorsPath,
     this.inPoint,
     this.outPoint,
     List<Uint8List>? thumbnails,
     this.scrubberPosition = 0.0,
     this.currentFrame,
     this.processedPreview,
+    this.processedPreviewAspect,
     this.timelineZoom = 1.0,
     this.timelineViewStart = 0.0,
     this.thumbnailRangeStart = 0.0,
@@ -176,12 +189,14 @@ class QueueItem {
     String? inputPath,
     String? outputPath,
     VideoInfo? videoInfo,
+    String? pitchFactorsPath,
     double? inPoint,
     double? outPoint,
     List<Uint8List>? thumbnails,
     double? scrubberPosition,
     Uint8List? currentFrame,
     Uint8List? processedPreview,
+    double? processedPreviewAspect,
     double? timelineZoom,
     double? timelineViewStart,
     double? thumbnailRangeStart,
@@ -194,12 +209,15 @@ class QueueItem {
       inputPath: inputPath ?? this.inputPath,
       outputPath: outputPath ?? this.outputPath,
       videoInfo: videoInfo ?? this.videoInfo,
+      pitchFactorsPath: pitchFactorsPath ?? this.pitchFactorsPath,
       inPoint: inPoint ?? this.inPoint,
       outPoint: outPoint ?? this.outPoint,
       thumbnails: thumbnails ?? this.thumbnails,
       scrubberPosition: scrubberPosition ?? this.scrubberPosition,
       currentFrame: currentFrame ?? this.currentFrame,
       processedPreview: processedPreview ?? this.processedPreview,
+      processedPreviewAspect:
+          processedPreviewAspect ?? this.processedPreviewAspect,
       timelineZoom: timelineZoom ?? this.timelineZoom,
       timelineViewStart: timelineViewStart ?? this.timelineViewStart,
       thumbnailRangeStart: thumbnailRangeStart ?? this.thumbnailRangeStart,
diff --git a/app/lib/models/stabilize_parameters.dart b/app/lib/models/stabilize_parameters.dart
index 076dda3..73daf08 100644
--- a/app/lib/models/stabilize_parameters.dart
+++ b/app/lib/models/stabilize_parameters.dart
@@ -2,20 +2,59 @@ import 'package:json_annotation/json_annotation.dart';
 
 part 'stabilize_parameters.g.dart';
 
+/// How the per-frame vertical pitch factor is obtained (issue #150).
+@JsonEnum(valueField: 'value')
+enum PitchMode {
+  off('off', 'Off'),
+  auto('auto', 'Auto'),
+  file('file', 'From File');
+
+  const PitchMode(this.value, this.displayName);
+  final String value;
+  final String displayName;
+
+  static PitchMode fromValue(String? value) =>
+      PitchMode.values.firstWhere((m) => m.value == value, orElse: () => PitchMode.off);
+}
+
+/// What fills the rows a pitch correction moves in from outside the frame.
+/// (The weave correction's edges are [StabilizeParameters.mirror]'s business.)
+@JsonEnum(valueField: 'value')
+enum EdgeFill {
+  extend('extend'),
+  black('black');
+
+  const EdgeFill(this.value);
+  final String value;
+
+  static EdgeFill fromValue(String? value) =>
+      EdgeFill.values.firstWhere((m) => m.value == value, orElse: () => EdgeFill.extend);
+}
+
 /// Parameters for the stabilisation pass.
 ///
-/// Cancels global shake — telecine weave, jittery film scans, handheld
-/// camcorder footage — while leaving deliberate camera movement alone. It shifts
-/// the picture within the frame, so it runs last before framing: a crop can then
-/// remove the edges it exposes.
+/// Two independent corrections. **Weave** cancels global shake — telecine
+/// weave, jittery film scans, handheld camcorder footage — while leaving
+/// deliberate camera movement alone. **Pitch** (issue #150) evens out
+/// frame-height "breathing" from film slipping in a pull-through scanner's
+/// gate. The pass shifts and resamples the picture within the frame, so it
+/// runs last before framing: a crop can then remove the edges it exposes.
 ///
 /// The frame count is unchanged, which is what keeps this an ordinary pass
 /// rather than one of the frame-rate-changing filters.
+///
+/// The pitch factor *file* is not here: it belongs to one video, while a
+/// pipeline is saved into presets shared by every video in the queue. It
+/// travels on the job instead (`VideoJob.pitchFactorsPath`).
 @JsonSerializable()
 class StabilizeParameters {
   /// Whether this pass is enabled.
   final bool enabled;
 
+  /// Remove weave / shake. On by default, so a pipeline saved before this
+  /// switch existed keeps doing what it did.
+  final bool weave;
+
   /// Maximum horizontal correction in pixels.
   final int dxmax;
 
@@ -29,28 +68,74 @@ class StabilizeParameters {
   /// there is no `range` argument, whatever other implementations take.
   final int mirror;
 
+  /// Pitch correction source. Off by default.
+  @JsonKey(unknownEnumValue: PitchMode.off)
+  final PitchMode pitchMode;
+
+  /// Largest pitch correction, in percent of the frame height.
+  final double maxPitchDeviation;
+
+  /// Auto pitch: frames each side a frame is compared with.
+  final int smoothingRadius;
+
+  /// File pitch: the file lists the stretch to apply, not the measured height.
+  final bool invertFactors;
+
+  /// What fills rows exposed by the pitch correction.
+  @JsonKey(unknownEnumValue: EdgeFill.extend)
+  final EdgeFill pitchEdgeFill;
+
   const StabilizeParameters({
     this.enabled = false,
+    this.weave = true,
     this.dxmax = 4,
     this.dymax = 4,
     this.mirror = 0,
+    this.pitchMode = PitchMode.off,
+    this.maxPitchDeviation = 1.0,
+    this.smoothingRadius = 10,
+    this.invertFactors = false,
+    this.pitchEdgeFill = EdgeFill.extend,
   });
 
   StabilizeParameters copyWith({
     bool? enabled,
+    bool? weave,
     int? dxmax,
     int? dymax,
     int? mirror,
+    PitchMode? pitchMode,
+    double? maxPitchDeviation,
+    int? smoothingRadius,
+    bool? invertFactors,
+    EdgeFill? pitchEdgeFill,
   }) =>
       StabilizeParameters(
         enabled: enabled ?? this.enabled,
+        weave: weave ?? this.weave,
         dxmax: dxmax ?? this.dxmax,
         dymax: dymax ?? this.dymax,
         mirror: mirror ?? this.mirror,
+        pitchMode: pitchMode ?? this.pitchMode,
+        maxPitchDeviation: maxPitchDeviation ?? this.maxPitchDeviation,
+        smoothingRadius: smoothingRadius ?? this.smoothingRadius,
+        invertFactors: invertFactors ?? this.invertFactors,
+        pitchEdgeFill: pitchEdgeFill ?? this.pitchEdgeFill,
       );
 
+  /// Whether pitch correction reads a per-video factor file.
+  bool get usesFactorFile => enabled && pitchMode == PitchMode.file;
+
   /// Short summary for the pass list row.
-  String get summary => enabled ? 'Up to ${dxmax}x$dymax px' : 'Off';
+  String get summary {
+    if (!enabled) return 'Off';
+    final parts = <String>[
+      if (weave) 'Up to ${dxmax}x$dymax px',
+      if (pitchMode == PitchMode.auto) 'pitch auto',
+      if (pitchMode == PitchMode.file) 'pitch from file',
+    ];
+    return parts.isEmpty ? 'Nothing selected' : parts.join(', ');
+  }
 
   factory StabilizeParameters.fromJson(Map<String, dynamic> json) =>
       _$StabilizeParametersFromJson(json);
diff --git a/app/lib/models/video_job.dart b/app/lib/models/video_job.dart
index 51b8938..159d9b6 100644
--- a/app/lib/models/video_job.dart
+++ b/app/lib/models/video_job.dart
@@ -59,6 +59,11 @@ class VideoJob {
   /// subtitles to every video in a batch.
   final String? burnInSubtitlePath;
 
+  /// Per-video pitch factor file for the Stabilize pass in "From File" mode
+  /// (issue #150). On the job rather than in the pipeline, because pipelines
+  /// are saved into presets shared by every video in the queue.
+  final String? pitchFactorsPath;
+
   VideoJob({
     String? id,
     required this.inputPath,
@@ -82,6 +87,7 @@ class VideoJob {
     this.inputColorTransfer,
     this.inputColorRange,
     this.burnInSubtitlePath,
+    this.pitchFactorsPath,
   })  : id = id ?? const Uuid().v4(),
         qtgmcParameters = qtgmcParameters ?? QTGMCParameters(),
         encodingSettings = encodingSettings ?? EncodingSettings();
@@ -118,6 +124,7 @@ class VideoJob {
     String? inputColorTransfer,
     String? inputColorRange,
     String? burnInSubtitlePath,
+    String? pitchFactorsPath,
   }) {
     return VideoJob(
       id: id ?? this.id,
@@ -142,6 +149,7 @@ class VideoJob {
       inputColorTransfer: inputColorTransfer ?? this.inputColorTransfer,
       inputColorRange: inputColorRange ?? this.inputColorRange,
       burnInSubtitlePath: burnInSubtitlePath ?? this.burnInSubtitlePath,
+      pitchFactorsPath: pitchFactorsPath ?? this.pitchFactorsPath,
     );
   }
 }
diff --git a/app/lib/services/field_order_detector.dart b/app/lib/services/field_order_detector.dart
index afa0288..8f20ae1 100644
--- a/app/lib/services/field_order_detector.dart
+++ b/app/lib/services/field_order_detector.dart
@@ -91,8 +91,7 @@ class FieldOrderDetector {
       final pixelFormat = videoStream['pix_fmt'] as String?;
 
       // Extract sample aspect ratio (SAR) — null if square pixels or unavailable
-      final rawSar = videoStream['sample_aspect_ratio'] as String?;
-      final sar = (rawSar != null && rawSar != 'N/A' && rawSar != '1:1') ? rawSar : null;
+      final sar = normalizeSar(videoStream['sample_aspect_ratio'] as String?);
 
       // Get metadata field order for context
       final metadataFieldOrder = videoStream['field_order'] as String?;
@@ -447,6 +446,19 @@ class FieldOrderDetector {
   // UTILITIES
   // ============================================================================
 
+  /// ffprobe's `sample_aspect_ratio` as the job carries it: null for square
+  /// pixels or when there is none to read (`N/A`, `1:1`, and `0:1`, which is
+  /// ffprobe's "unknown"). The encode and the preview jobs both go through
+  /// this, so the preview fits the frame with the same SAR as the encode
+  /// (issue #149).
+  static String? normalizeSar(String? raw) {
+    final sar = raw?.trim();
+    if (sar == null || sar.isEmpty || sar == 'N/A' || sar == '1:1') return null;
+    final parts = sar.split(':');
+    if (parts.length == 2 && (double.tryParse(parts[0]) ?? 0) <= 0) return null;
+    return sar;
+  }
+
   /// Picks the true picture frame rate from the container's `r_frame_rate`
   /// (the stream's base/tick rate) and `avg_frame_rate` (the average displayed
   /// rate).
diff --git a/app/lib/services/pitch_factor_file.dart b/app/lib/services/pitch_factor_file.dart
new file mode 100644
index 0000000..ab6bee1
--- /dev/null
+++ b/app/lib/services/pitch_factor_file.dart
@@ -0,0 +1,108 @@
+import 'dart:io';
+
+/// Per-video pitch factor files for the Stabilize pass ("From File" mode,
+/// issue #150).
+///
+/// A factor file belongs to one film, so it is picked up per video: a
+/// sidecar next to the video is found automatically when the video is added
+/// to the queue, which makes a batch of reels work without choosing a file
+/// for each. The worker does the authoritative parsing (and reports a bad line
+/// by number); [inspect] is only a quick summary for the settings panel.
+class PitchFactorFile {
+  PitchFactorFile._();
+
+  /// File extensions offered by the file picker.
+  static const pickerExtensions = ['txt', 'csv', 'log'];
+
+  /// Sidecar names tried, in order, for `/dir/reel1.mp4`:
+  /// `reel1.mp4.pitch.txt`, `reel1.pitch.txt`, `reel1_pitch.txt`.
+  static List<String> sidecarCandidates(String videoPath) {
+    final dot = videoPath.lastIndexOf('.');
+    final sep = videoPath.lastIndexOf(RegExp(r'[/\\]'));
+    final stem = dot > sep ? videoPath.substring(0, dot) : videoPath;
+    return [
+      '$videoPath.pitch.txt',
+      '$stem.pitch.txt',
+      '${stem}_pitch.txt',
+    ];
+  }
+
+  /// The first existing sidecar for [videoPath], or null.
+  static String? findSidecar(String videoPath) {
+    for (final candidate in sidecarCandidates(videoPath)) {
+      if (File(candidate).existsSync()) return candidate;
+    }
+    return null;
+  }
+
+  /// A quick look at [path]: how many factors it holds, or why it can't be
+  /// used. Mirrors the worker's rules (comments, blank lines, bare factors or
+  /// `frame,factor`).
+  static Future<PitchFactorFileInfo> inspect(String path) async {
+    final String text;
+    try {
+      text = await File(path).readAsString();
+    } catch (e) {
+      return PitchFactorFileInfo.error('Cannot read the file');
+    }
+    return parse(text);
+  }
+
+  /// Summarise factor-file [text]. See [inspect].
+  static PitchFactorFileInfo parse(String text) {
+    var bare = 0;
+    var maxFrame = -1;
+    var indexed = 0;
+    final lines = text.split(RegExp(r'\r?\n'));
+    for (var i = 0; i < lines.length; i++) {
+      final line = lines[i].split('#').first.trim().replaceFirst('', '');
+      if (line.isEmpty) continue;
+      final fields = line.split(RegExp(r'[,;\s]+')).where((f) => f.isNotEmpty).toList();
+      final factorText = fields.length == 1 ? fields[0] : (fields.length == 2 ? fields[1] : null);
+      final factor = factorText == null ? null : double.tryParse(factorText);
+      if (factor == null || !factor.isFinite || factor <= 0) {
+        return PitchFactorFileInfo.error('Line ${i + 1} is not a valid factor');
+      }
+      if (fields.length == 1) {
+        bare++;
+      } else {
+        final frame = int.tryParse(fields[0]);
+        if (frame == null || frame < 0) {
+          return PitchFactorFileInfo.error('Line ${i + 1} has an invalid frame number');
+        }
+        indexed++;
+        if (frame > maxFrame) maxFrame = frame;
+      }
+    }
+    if (bare > 0 && indexed > 0) {
+      return PitchFactorFileInfo.error('Mixes bare factors and "frame,factor" lines');
+    }
+    final count = bare > 0 ? bare : maxFrame + 1;
+    if (count <= 0) return PitchFactorFileInfo.error('Contains no factors');
+    return PitchFactorFileInfo(count);
+  }
+}
+
+/// Result of [PitchFactorFile.inspect].
+class PitchFactorFileInfo {
+  /// Number of frames covered, or null when [error] is set.
+  final int? frameCount;
+  final String? error;
+
+  const PitchFactorFileInfo(int this.frameCount) : error = null;
+  const PitchFactorFileInfo.error(String this.error) : frameCount = null;
+
+  bool get isValid => error == null;
+
+  /// One-line status for the settings panel, given the video's frame count.
+  String describe(int? videoFrames) {
+    if (!isValid) return error!;
+    final n = frameCount!;
+    if (videoFrames == null || videoFrames <= 0) return '$n factors';
+    if (n == videoFrames) return '$n factors — one per frame';
+    if (n < videoFrames) {
+      return '$n factors for $videoFrames frames — frames past the end are left uncorrected';
+    }
+    return '$n factors for $videoFrames frames — the extra factors are ignored';
+  }
+}
diff --git a/app/lib/services/preview_generator.dart b/app/lib/services/preview_generator.dart
index 0836df9..7f882ec 100644
--- a/app/lib/services/preview_generator.dart
+++ b/app/lib/services/preview_generator.dart
@@ -79,6 +79,12 @@ class PreviewGenerator {
   String? _colorTransfer;
   String? _colorRange;
 
+  /// Source sample aspect ratio ("16:15"), null for square pixels. Sent with
+  /// the preview job so the script fits the frame by the same display aspect
+  /// as the encode — without it `{{SOURCE_SAR}}` fell back to 1, and Square
+  /// pixel aspect previewed a different frame from the one encoded (#149).
+  String? _sar;
+
   /// The display tone-map for the loaded source, or null for SDR. Applied to
   /// every picture of the source the app draws itself.
   String? get _toneMap => HdrDisplay.toneMapFilter(
@@ -265,6 +271,7 @@ class PreviewGenerator {
     required EncodingSettings encodingSettings,
     int subFrame = 0,
     int? startFrame,
+    String? pitchFactorsPath,
     CancelToken? cancelToken,
   }) async {
     if (_currentVideoPath == null || _workerPath == null) {
@@ -317,10 +324,14 @@ class PreviewGenerator {
         inputColorPrimaries: _colorPrimaries,
         inputColorTransfer: _colorTransfer,
         inputColorRange: _colorRange,
+        inputSar: _sar,
         // Not a trim: the worker's preview only uses it as the point the
         // encode's retime starts from, so a generated frame is previewed at
         // the moment the encode makes it.
         startFrame: startFrame,
+        // The selected video's factor file for Stabilize's "From File" pitch
+        // mode, so the preview corrects with the same factors as the encode.
+        pitchFactorsPath: pitchFactorsPath,
       );
 
       // Write job config to file
@@ -565,6 +576,8 @@ class PreviewGenerator {
     _colorPrimaries = colorTag(videoStream, 'color_primaries');
     _colorTransfer = colorTag(videoStream, 'color_transfer');
     _colorRange = colorTag(videoStream, 'color_range');
+    _sar = FieldOrderDetector.normalizeSar(
+        videoStream['sample_aspect_ratio'] as String?);
   }
 
   /// Parses an ffprobe rational frame-rate string (e.g. "25/1") to a double.
diff --git a/app/lib/viewmodels/main_viewmodel.dart b/app/lib/viewmodels/main_viewmodel.dart
index a308f16..0e4a90b 100644
--- a/app/lib/viewmodels/main_viewmodel.dart
+++ b/app/lib/viewmodels/main_viewmodel.dart
@@ -24,7 +24,9 @@ import '../services/disc_detector.dart';
 import '../services/dvd_service.dart';
 import '../services/field_order_detector.dart';
 import '../services/frame_math.dart';
+import '../services/image_dimensions.dart';
 import '../services/timeline_math.dart';
+import '../services/pitch_factor_file.dart';
 import '../services/preset_service.dart';
 import '../services/preview_generator.dart';
 import '../services/temp_directory_service.dart';
@@ -34,6 +36,18 @@ import '../services/system_shutdown.dart';
 import '../services/worker_manager.dart';
 import '../widgets/comparison_zoom_controller.dart';
 
+/// The display aspect a processed preview is drawn at: its stored size with
+/// the aspect the worker reported for it applied, i.e. the shape the encode
+/// will have. Null — draw it at its own pixel shape — when there is no image,
+/// its size can't be read, or the worker reported nothing (issue #149).
+@visibleForTesting
+double? processedDisplayAspect(Uint8List? image, PreviewFrameInfo? info) {
+  if (image == null || info == null) return null;
+  final pixels = encodedImageSize(image);
+  if (pixels == null || pixels.isEmpty) return null;
+  return info.displayAspectFor(pixels);
+}
+
 /// Main view model managing application state.
 class MainViewModel extends ChangeNotifier {
   /// Runs jobs. Injectable so the queue state machine can be driven from a
@@ -245,7 +259,8 @@ class MainViewModel extends ChangeNotifier {
 
   /// Put an analysed video in the queue and select it, for widget tests.
   @visibleForTesting
-  void debugAddQueueItemForTest(String path, {required int width, required int height}) {
+  void debugAddQueueItemForTest(String path,
+      {required int width, required int height, String? sar}) {
     final item = QueueItem(
       inputPath: path,
       outputPath: '$path.out.mkv',
@@ -258,6 +273,7 @@ class MainViewModel extends ChangeNotifier {
         codec: 'h264',
         pixelFormat: 'yuv420p',
         hasAudio: false,
+        sar: sar,
       ),
     );
     _queue.add(item);
@@ -672,6 +688,27 @@ class MainViewModel extends ChangeNotifier {
   List<Uint8List> get thumbnails => selectedItem?.thumbnails ?? [];
   Uint8List? get currentFrame => selectedItem?.currentFrame;
   Uint8List? get processedPreview => selectedItem?.processedPreview;
+
+  /// The display aspect of [processedPreview] — the shape the encode will
+  /// have — or null when it is drawn at its own pixel shape.
+  double? get processedPreviewAspect => selectedItem?.processedPreviewAspect;
+
+  /// The source's display aspect, `width / height * SAR`, for the "before"
+  /// frame; null for square pixels or an unreadable SAR.
+  double? get sourceDisplayAspect {
+    final info = videoInfo;
+    if (info == null || info.height <= 0) return null;
+    final sar = PreviewFrameInfo.parseRatio(info.sar);
+    if (sar == null) return null;
+    return info.width / info.height * sar;
+  }
+
+  /// The aspect the "after" side of the comparison is drawn at: the processed
+  /// frame's own (the encode's shape, which a resize, pad, crop, rotation or
+  /// squaring makes different from the source's — issue #149), or, until a
+  /// processed frame exists, the source's, since the source frame stands in.
+  double? get comparisonAfterAspect =>
+      processedPreview != null ? processedPreviewAspect : sourceDisplayAspect;
   double get scrubberPosition => selectedItem?.scrubberPosition ?? 0.0;
   bool get isGeneratingPreview => _isGeneratingPreview;
   double get videoDuration => _previewGenerator.duration;
@@ -875,6 +912,7 @@ class MainViewModel extends ChangeNotifier {
       final item = QueueItem(
         inputPath: filePath,
         outputPath: outputPath,
+        pitchFactorsPath: PitchFactorFile.findSidecar(filePath),
         status: QueueItemStatus.pending,
       );
       newItems.add(item);
@@ -1413,12 +1451,13 @@ class MainViewModel extends ChangeNotifier {
         encodingSettings: _encodingSettings,
         subFrame: _previewSubFrame,
         startFrame: item.inPointFrame,
+        pitchFactorsPath: item.pitchFactorsPath,
         cancelToken: cancelToken,
       );
 
       if (generation == _previewGeneration && !cancelToken.isCancelled) {
-        item.processedPreview = preview;
-        _previewFrameInfo = preview == null ? null : _previewGenerator.lastFrameInfo;
+        _acceptProcessedPreview(
+            item, preview, preview == null ? null : _previewGenerator.lastFrameInfo);
         // The worker clamps to the frames there are, e.g. after the frame
         // rate pass is switched off; step on from what it showed.
         if (_previewFrameInfo != null) _previewSubFrame = _previewFrameInfo!.subFrame;
@@ -1435,6 +1474,27 @@ class MainViewModel extends ChangeNotifier {
     }
   }
 
+  /// Store a rendered preview on [item] with the display aspect it is drawn
+  /// at. The aspect is kept with the image because [previewFrameInfo] goes
+  /// null as soon as the scrubber moves, while this image stays on screen
+  /// until the next one replaces it (issue #149).
+  void _acceptProcessedPreview(
+      QueueItem item, Uint8List? preview, PreviewFrameInfo? info) {
+    item.processedPreview = preview;
+    _previewFrameInfo = info;
+    item.processedPreviewAspect = processedDisplayAspect(preview, info);
+  }
+
+  /// Deliver a preview as the worker would have, for tests of what the
+  /// comparison is drawn at.
+  @visibleForTesting
+  void debugAcceptProcessedPreview(Uint8List? preview, PreviewFrameInfo? info) {
+    final item = selectedItem;
+    if (item == null) return;
+    _acceptProcessedPreview(item, preview, info);
+    notifyListeners();
+  }
+
   /// Cancels any ongoing preview generation.
   void _cancelPreviewGeneration() {
     _previewDebounceTimer?.cancel();
@@ -1584,6 +1644,16 @@ class MainViewModel extends ChangeNotifier {
     }
   }
 
+  /// Sets (or with null, clears) the selected video's pitch factor file for
+  /// the Stabilize pass's "From File" mode. Per video, never per preset.
+  void setPitchFactorsPath(String? path) {
+    final item = selectedItem;
+    if (item == null) return;
+    item.pitchFactorsPath = (path == null || path.isEmpty) ? null : path;
+    notifyListeners();
+    _requestPreviewUpdate();
+  }
+
   /// Expands a pass's settings inline, collapsing whichever was open. Selecting
   /// the pass that is already expanded collapses it.
   void selectPass(PassType pass) {
@@ -1730,6 +1800,8 @@ class MainViewModel extends ChangeNotifier {
           _processingPipeline.subtitles.burnInPath.trim().isEmpty
               ? null
               : _processingPipeline.subtitles.burnInPath.trim(),
+      // Per video, never per preset: a factor log belongs to one film.
+      pitchFactorsPath: item.pitchFactorsPath,
     );
 
     // Record the audio config each file is actually encoded with. If a file's
diff --git a/app/lib/views/pass_settings/pass_settings_inline.dart b/app/lib/views/pass_settings/pass_settings_inline.dart
index cc76cd5..ddb8acb 100644
--- a/app/lib/views/pass_settings/pass_settings_inline.dart
+++ b/app/lib/views/pass_settings/pass_settings_inline.dart
@@ -1,3 +1,4 @@
+import 'package:file_picker/file_picker.dart';
 import 'package:flutter/material.dart';
 import 'package:provider/provider.dart';
 
@@ -11,6 +12,7 @@ import '../../models/pass_advice.dart';
 import '../../models/processing_pipeline.dart';
 import '../../models/gpu_plugin_status.dart';
 import '../../services/addon_service.dart';
+import '../../services/pitch_factor_file.dart';
 import '../../services/whisper_addon_manager.dart';
 import '../../utils/pixel_format.dart';
 import '../../viewmodels/main_viewmodel.dart';
@@ -135,12 +137,35 @@ class PassSettingsInline extends StatelessWidget {
                 _handleParamChange(context, viewModel, filterId, params, newParams);
               },
             ),
+            _buildPitchFactorFile(viewModel, filterId, params),
           ],
         );
       },
     );
   }
 
+  /// Stabilize in "From File" pitch mode: the selected video's factor file,
+  /// with Choose / Clear. Per video (never part of a preset), so it is shown
+  /// here rather than as a schema parameter.
+  Widget _buildPitchFactorFile(
+    MainViewModel viewModel,
+    String filterId,
+    DynamicParameters params,
+  ) {
+    if (filterId != 'stabilize' || params.values['pitchMode'] != 'file') {
+      return const SizedBox.shrink();
+    }
+    final item = viewModel.selectedItem;
+    if (item == null) return const SizedBox.shrink();
+    return _PitchFactorFileRow(
+      key: ValueKey('${item.id}:${item.pitchFactorsPath}'),
+      videoPath: item.inputPath,
+      path: item.pitchFactorsPath,
+      videoFrames: item.videoInfo?.frameCount,
+      onChanged: viewModel.setPitchFactorsPath,
+    );
+  }
+
   /// What the filter does, shown above every option: the one-line summary
   /// always, with the fuller "what it does and when to use it" prose behind an
   /// expander. See [_FilterDescription].
@@ -775,3 +800,104 @@ class _FaceRestoreNoticeState extends State<FaceRestoreNotice> {
     );
   }
 }
+
+/// The selected video's pitch factor file, its status, and Choose / Clear.
+class _PitchFactorFileRow extends StatefulWidget {
+  final String videoPath;
+  final String? path;
+  final int? videoFrames;
+  final ValueChanged<String?> onChanged;
+
+  const _PitchFactorFileRow({
+    super.key,
+    required this.videoPath,
+    required this.path,
+    required this.videoFrames,
+    required this.onChanged,
+  });
+
+  @override
+  State<_PitchFactorFileRow> createState() => _PitchFactorFileRowState();
+}
+
+class _PitchFactorFileRowState extends State<_PitchFactorFileRow> {
+  Future<PitchFactorFileInfo>? _info;
+
+  @override
+  void initState() {
+    super.initState();
+    final path = widget.path;
+    if (path != null) _info = PitchFactorFile.inspect(path);
+  }
+
+  Future<void> _choose() async {
+    final result = await FilePicker.platform.pickFiles(
+      dialogTitle: 'Choose pitch factor file',
+      type: FileType.custom,
+      allowedExtensions: PitchFactorFile.pickerExtensions,
+    );
+    final picked = result?.files.single.path;
+    if (picked != null) widget.onChanged(picked);
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    final theme = Theme.of(context);
+    final path = widget.path;
+    final name = path?.split(RegExp(r'[/\\]')).last;
+    final sidecar = PitchFactorFile.sidecarCandidates(widget.videoPath)[1]
+        .split(RegExp(r'[/\\]'))
+        .last;
+
+    return Padding(
+      padding: const EdgeInsets.only(top: 12),
+      child: Column(
+        crossAxisAlignment: CrossAxisAlignment.start,
+        children: [
+          Text('Pitch Factor File (this video)', style: theme.textTheme.labelLarge),
+          const SizedBox(height: 4),
+          Row(
+            children: [
+              Expanded(
+                child: Text(
+                  name ?? 'None selected',
+                  overflow: TextOverflow.ellipsis,
+                  style: path == null
+                      ? theme.textTheme.bodyMedium?.copyWith(color: theme.colorScheme.error)
+                      : theme.textTheme.bodyMedium,
+                ),
+              ),
+              TextButton(onPressed: _choose, child: const Text('Choose…')),
+              if (path != null)
+                IconButton(
+                  tooltip: 'Clear',
+                  icon: const Icon(Icons.close, size: 18),
+                  onPressed: () => widget.onChanged(null),
+                ),
+            ],
+          ),
+          if (path == null)
+            Text(
+              'Choose a file, or put $sidecar next to the video before adding it. '
+              'Without one, this video can\'t be processed in From File mode.',
+              style: theme.textTheme.bodySmall,
+            )
+          else
+            FutureBuilder<PitchFactorFileInfo>(
+              future: _info,
+              builder: (context, snapshot) {
+                final info = snapshot.data;
+                if (info == null) return const SizedBox.shrink();
+                return Text(
+                  info.describe(widget.videoFrames),
+                  style: theme.textTheme.bodySmall?.copyWith(
+                    color: info.isValid ? null : theme.colorScheme.error,
+                  ),
+                );
+              },
+            ),
+        ],
+      ),
+    );
+  }
+}
diff --git a/app/lib/views/preview_panel.dart b/app/lib/views/preview_panel.dart
index 9ef3951..77d15f3 100644
--- a/app/lib/views/preview_panel.dart
+++ b/app/lib/views/preview_panel.dart
@@ -47,23 +47,6 @@ class _PreviewPanelState extends State<PreviewPanel> {
   }
 
   Widget _buildPreviewComparison(BuildContext context, MainViewModel viewModel) {
-    // Compute display aspect ratio for SAR correction.
-    // DAR = (width / height) * (sarNum / sarDen)
-    // Only needed when SAR is non-square (e.g. anamorphic DVD 32:27).
-    double? displayAspectRatio;
-    final videoInfo = viewModel.videoInfo;
-    if (videoInfo != null && videoInfo.sar != null) {
-      final parts = videoInfo.sar!.split(':');
-      if (parts.length == 2) {
-        final sarNum = double.tryParse(parts[0]);
-        final sarDen = double.tryParse(parts[1]);
-        if (sarNum != null && sarDen != null && sarDen > 0) {
-          displayAspectRatio =
-              (videoInfo.width / videoInfo.height) * (sarNum / sarDen);
-        }
-      }
-    }
-
     // The scope reads the processed preview, falling back to the source frame
     // before any pass has rendered — that is what the user is looking at.
     final scopeImage = viewModel.processedPreview ?? viewModel.currentFrame;
@@ -78,7 +61,10 @@ class _PreviewPanelState extends State<PreviewPanel> {
               afterImage: scopeImage,
               isBeforeLoading: viewModel.isAnalyzing,
               isAfterLoading: viewModel.isGeneratingPreview,
-              displayAspectRatio: displayAspectRatio,
+              // Each side at its own shape: the processed frame at the
+              // encode's, not the source's (issue #149).
+              beforeAspectRatio: viewModel.sourceDisplayAspect,
+              afterAspectRatio: viewModel.comparisonAfterAspect,
               zoomController: viewModel.previewZoom,
             ),
           ),
diff --git a/app/lib/widgets/before_after_comparison.dart b/app/lib/widgets/before_after_comparison.dart
index 17dc321..496bf53 100644
--- a/app/lib/widgets/before_after_comparison.dart
+++ b/app/lib/widgets/before_after_comparison.dart
@@ -35,9 +35,18 @@ class BeforeAfterComparisonWidget extends StatefulWidget {
   /// Whether the after image is loading.
   final bool isAfterLoading;
 
-  /// Display aspect ratio for SAR correction (e.g. 16/9 for anamorphic DVD).
-  /// When null, the image's native pixel aspect ratio is used (square pixels).
-  final double? displayAspectRatio;
+  /// Display aspect ratio of the "before" image, for SAR correction (e.g.
+  /// 4/3 for a 720x576 PAL source). When null, the image's native pixel
+  /// aspect ratio is used (square pixels).
+  final double? beforeAspectRatio;
+
+  /// Display aspect ratio of the "after" image — the shape the processed
+  /// frame will have once encoded. Each side has its own: a pass that
+  /// resizes, pads, crops, rotates or squares the pixels gives the processed
+  /// frame a different shape from the source, and drawing it at the source's
+  /// squashed it (issue #149). When null, the image's native pixel aspect
+  /// ratio is used.
+  final double? afterAspectRatio;
 
   /// Lets keyboard shortcuts drive Fit / 1:1 from outside the widget.
   final ComparisonZoomController? zoomController;
@@ -49,7 +58,8 @@ class BeforeAfterComparisonWidget extends StatefulWidget {
     this.initialDividerPosition = 0.5,
     this.isBeforeLoading = false,
     this.isAfterLoading = false,
-    this.displayAspectRatio,
+    this.beforeAspectRatio,
+    this.afterAspectRatio,
     this.zoomController,
   });
 
@@ -166,6 +176,12 @@ class _BeforeAfterComparisonWidgetState
     );
   }
 
+  /// Display aspect of the frame [_imagePixels] measures: the processed
+  /// frame's when there is one, else the source's.
+  double? get _measuredAspect => widget.afterImage != null
+      ? widget.afterAspectRatio
+      : widget.beforeAspectRatio;
+
   /// Pixel size of the frame the 1:1 scale is measured against: the
   /// processed frame, which is what is being inspected, else the source.
   Size? get _imagePixels {
@@ -182,7 +198,7 @@ class _BeforeAfterComparisonWidgetState
   Size? _fittedSize(Size box) {
     final pixels = _imagePixels;
     if (pixels == null || box.isEmpty) return null;
-    final aspect = widget.displayAspectRatio ?? pixels.width / pixels.height;
+    final aspect = _measuredAspect ?? pixels.width / pixels.height;
     final width = math.min(box.width, box.height * aspect);
     return Size(width, width / aspect);
   }
@@ -398,6 +414,7 @@ class _BeforeAfterComparisonWidgetState
                       ..scale(_scale, _scale),
                     child: _buildImageLayer(
                       imageData: widget.afterImage,
+                      displayAspectRatio: widget.afterAspectRatio,
                       isLoading: widget.isAfterLoading,
                       colorScheme: colorScheme,
                       label: 'Processed',
@@ -415,6 +432,7 @@ class _BeforeAfterComparisonWidgetState
                         ..scale(_scale, _scale),
                       child: _buildImageLayer(
                         imageData: widget.beforeImage,
+                        displayAspectRatio: widget.beforeAspectRatio,
                         isLoading: widget.isBeforeLoading,
                         colorScheme: colorScheme,
                         label: 'Original',
@@ -554,6 +572,7 @@ class _BeforeAfterComparisonWidgetState
 
   Widget _buildImageLayer({
     required Uint8List? imageData,
+    required double? displayAspectRatio,
     required bool isLoading,
     required ColorScheme colorScheme,
     required String label,
@@ -564,11 +583,11 @@ class _BeforeAfterComparisonWidgetState
       // FittedBox scales its child uniformly to fit the parent while
       // preserving the SizedBox's aspect ratio — works even under the
       // tight constraints from StackFit.expand.
-      if (widget.displayAspectRatio != null) {
+      if (displayAspectRatio != null) {
         return FittedBox(
           fit: BoxFit.contain,
           child: SizedBox(
-            width: widget.displayAspectRatio! * 1000,
+            width: displayAspectRatio * 1000,
             height: 1000,
             child: Image.memory(
               imageData,
diff --git a/app/test/before_after_comparison_test.dart b/app/test/before_after_comparison_test.dart
index 83833b8..ba3eee4 100644
--- a/app/test/before_after_comparison_test.dart
+++ b/app/test/before_after_comparison_test.dart
@@ -66,6 +66,8 @@ void main() {
       double height = 300,
       double devicePixelRatio = 1,
       double? displayAspectRatio,
+      Uint8List? beforeImage,
+      double? beforeAspectRatio,
     }) async {
       tester.view.devicePixelRatio = devicePixelRatio;
       tester.view.physicalSize =
@@ -78,9 +80,12 @@ void main() {
             width: width,
             height: height,
             child: BeforeAfterComparisonWidget(
-              beforeImage: image,
+              beforeImage: beforeImage ?? image,
               afterImage: image,
-              displayAspectRatio: displayAspectRatio,
+              beforeAspectRatio: beforeImage != null
+                  ? beforeAspectRatio
+                  : displayAspectRatio,
+              afterAspectRatio: displayAspectRatio,
               zoomController: controller,
             ),
           ),
@@ -150,6 +155,55 @@ void main() {
       expect(scaleOf(tester), closeTo(480 / fittedHeight, 1e-9));
     });
 
+    // Issue #149: a 720x576 PAL 4:3 source upscaled and padded to a
+    // 1920x1080 canvas was drawn squashed into the source's 4:3 shape.
+    testWidgets('each side is drawn at its own display aspect',
+        (tester) async {
+      final source = await tester.runAsync(() => _png(720, 576));
+      final processed = await tester.runAsync(() => _png(1920, 1080));
+      await pump(
+        tester,
+        processed!,
+        displayAspectRatio: 16 / 9,
+        beforeImage: source!,
+        beforeAspectRatio: 4 / 3,
+      );
+
+      // Stack order: the processed layer, then the source layer.
+      final images = find.descendant(
+        of: find.byType(BeforeAfterComparisonWidget),
+        matching: find.byType(Image),
+      );
+      expect(images, findsNWidgets(2));
+      final after = tester.getRect(images.at(0));
+      final before = tester.getRect(images.at(1));
+      expect(after.width / after.height, closeTo(16 / 9, 1e-6));
+      expect(before.width / before.height, closeTo(4 / 3, 1e-6));
+      // Both fit the 398x298 panel: the processed one by width, the source
+      // by height.
+      expect(after.width, closeTo(398, 1e-6));
+      expect(before.height, closeTo(298, 1e-6));
+    });
+
+    testWidgets('1:1 is measured against the processed frame\'s aspect',
+        (tester) async {
+      final source = await tester.runAsync(() => _png(720, 576));
+      final processed = await tester.runAsync(() => _png(1920, 1080));
+      await pump(
+        tester,
+        processed!,
+        displayAspectRatio: 16 / 9,
+        beforeImage: source!,
+        beforeAspectRatio: 4 / 3,
+      );
+      controller.showActualSize();
+      await tester.pumpAndSettle();
+
+      // Fitted 398 wide at 16:9; 1:1 puts its 1080 rows on 1080 pixels.
+      final fittedHeight = 398 / (16 / 9);
+      expect(scaleOf(tester), closeTo(1080 / fittedHeight, 1e-9));
+    });
+
     testWidgets('the frame is drawn on the pixel grid at 1:1', (tester) async {
       // An odd-sized frame centred in an even panel would straddle pixels.
       final image = await tester.runAsync(() => _png(201, 101));
diff --git a/app/test/integration_aspect_ratio_test.dart b/app/test/integration_aspect_ratio_test.dart
index 06dae45..4e6f121 100644
--- a/app/test/integration_aspect_ratio_test.dart
+++ b/app/test/integration_aspect_ratio_test.dart
@@ -13,15 +13,23 @@ library;
 // ignore_for_file: avoid_print — these tests print diagnostics to the test log.
 
 import 'dart:io';
+import 'dart:typed_data';
+import 'dart:ui' show Size;
 
 import 'package:flutter_test/flutter_test.dart';
 import 'package:uuid/uuid.dart';
 
 import 'package:vapourbox/models/crop_resize_parameters.dart';
 import 'package:vapourbox/models/encoding_settings.dart';
+import 'package:vapourbox/models/geometry_parameters.dart';
+import 'package:vapourbox/models/noise_reduction_parameters.dart';
+import 'package:vapourbox/models/preview_frame_info.dart';
 import 'package:vapourbox/models/processing_pipeline.dart';
 import 'package:vapourbox/models/qtgmc_parameters.dart';
 import 'package:vapourbox/models/video_job.dart';
+import 'package:vapourbox/services/image_dimensions.dart';
+import 'package:vapourbox/viewmodels/main_viewmodel.dart'
+    show processedDisplayAspect;
 
 import 'support/worker_harness.dart';
 
@@ -35,18 +43,87 @@ const _srcWidth = 720;
 const _srcHeight = 576;
 const _srcSar = 16 / 11;
 
+/// The issue #149 source: 720x576 PAL 4:3 (16:15 pixels), a flat mid-grey so
+/// the picture's extent inside the bars can be measured.
+late String _pal43;
+
+VideoJob _job(
+  String name,
+  CropResizeParameters cropResize, {
+  required String input,
+  required String inputSar,
+  ProcessingPipeline? pipeline,
+}) =>
+    VideoJob(
+      id: const Uuid().v4(),
+      inputPath: input,
+      outputPath: '$_outDir/$name.mkv',
+      processingPipeline: pipeline ??
+          ProcessingPipeline(
+            deinterlace: const QTGMCParameters(enabled: false),
+            cropResize: cropResize,
+          ),
+      encodingSettings: const EncodingSettings(
+        codec: VideoCodec.h264,
+        container: ContainerFormat.mkv,
+        audioMode: AudioMode.none,
+      ),
+      inputWidth: _srcWidth,
+      inputHeight: _srcHeight,
+      inputFrameRate: 25.0,
+      inputPixelFormat: 'yuv420p',
+      inputSar: inputSar,
+    );
+
+/// Preview one frame the way the app does, returning the PNG, what the
+/// worker reported for it, and the display aspect the app draws it at.
+Future<({Uint8List png, PreviewFrameInfo info, double? aspect})> _preview(
+  String name,
+  CropResizeParameters cropResize, {
+  required String input,
+  required String inputSar,
+  ProcessingPipeline? pipeline,
+}) async {
+  final job = _job(name, cropResize,
+      input: input, inputSar: inputSar, pipeline: pipeline);
+  final result =
+      await WorkerHarness.runPreview(job.toJson(), frame: 2, label: name);
+  expect(result.success, isTrue, reason: '$name: $result');
+  final info = PreviewFrameInfo.parse(result.logs);
+  expect(info, isNotNull, reason: '$name: no PREVIEW_INFO line');
+  final aspect = processedDisplayAspect(result.png, info);
+  print('  $name (preview): ${encodedImageSize(result.png!)} '
+      'SAR=${info!.outputSar} DAR=${info.outputDar} -> drawn at $aspect');
+  return (png: result.png!, info: info, aspect: aspect);
+}
+
+/// Columns of the middle row that are picture rather than black bars.
+Future<int> _pictureWidth(Uint8List rgb24, int width, int height) async {
+  final row = (height ~/ 2) * width * 3;
+  var count = 0;
+  for (var x = 0; x < width; x++) {
+    final i = row + x * 3;
+    if (rgb24[i] + rgb24[i + 1] + rgb24[i + 2] > 3 * 64) count++;
+  }
+  return count;
+}
+
 Future<({int width, int height, String sar, String dar})> _encode(
   String name,
-  CropResizeParameters cropResize,
-) async {
+  CropResizeParameters cropResize, {
+  String? input,
+  String inputSar = '16:11',
+  ProcessingPipeline? pipeline,
+}) async {
   final job = VideoJob(
     id: const Uuid().v4(),
-    inputPath: _anamorphic,
+    inputPath: input ?? _anamorphic,
     outputPath: '$_outDir/$name.mkv',
-    processingPipeline: ProcessingPipeline(
-      deinterlace: const QTGMCParameters(enabled: false),
-      cropResize: cropResize,
-    ),
+    processingPipeline: pipeline ??
+        ProcessingPipeline(
+          deinterlace: const QTGMCParameters(enabled: false),
+          cropResize: cropResize,
+        ),
     encodingSettings: const EncodingSettings(
       codec: VideoCodec.h264,
       container: ContainerFormat.mkv,
@@ -55,7 +132,7 @@ Future<({int width, int height, String sar, String dar})> _encode(
     inputWidth: _srcWidth,
     inputHeight: _srcHeight,
     inputFrameRate: 25.0,
-    inputSar: '16:11',
+    inputSar: inputSar,
     startFrame: 0,
     endFrame: 4,
   );
@@ -114,6 +191,22 @@ void main() {
         selector: 'v:0', entries: ['sample_aspect_ratio']);
     expect(src?['sample_aspect_ratio'], '16:11',
         reason: 'fixture must be anamorphic to exercise this at all');
+
+    _pal43 = '$_outDir/src_pal_4x3_16x15.mkv';
+    final pal = await Process.run(
+      WorkerHarness.ffmpegPath,
+      [
+        '-hide_banner', '-loglevel', 'error', '-y',
+        '-f', 'lavfi',
+        '-i', 'color=c=0x808080:size=${_srcWidth}x$_srcHeight:rate=25:duration=0.4',
+        '-c:v', 'ffv1', '-pix_fmt', 'yuv420p',
+        // 16:15 pixels: PAL 4:3. 720 * 16/15 / 576 = 4:3.
+        '-vf', 'setsar=16/15',
+        _pal43,
+      ],
+      environment: WorkerHarness.ffmpegEnv,
+    );
+    expect(pal.exitCode, 0, reason: 'fixture: ${pal.stderr}');
   });
 
   group('aspect ratio (full encode)', () {
@@ -217,4 +310,117 @@ void main() {
       expect(out.height, 1024);
     }, timeout: const Timeout(Duration(minutes: 5)));
   });
+
+  // Issue #149: a 720x576 PAL 4:3 capture resized to 1440x1080 and given
+  // borders out to 1920x1080 previewed squashed, because the processed frame
+  // was drawn at the source's 4:3. The preview now reports the aspect the
+  // encode declares, and is fitted with the same SAR.
+  group('preview aspect (issue #149)', () {
+    CropResizeParameters reporter(PixelAspectMode mode) => CropResizeParameters(
+          enabled: true,
+          resizeEnabled: true,
+          targetWidth: 1440,
+          targetHeight: 1080,
+          maintainAspect: true,
+          pixelAspect: mode,
+          padEnabled: true,
+          padWidth: 1920,
+          padHeight: 1080,
+        );
+
+    test('square pixels: drawn 16:9, picture fitted like the encode', () async {
+      final params = reporter(PixelAspectMode.square);
+      final preview = await _preview('preview_149_square', params,
+          input: _pal43, inputSar: '16:15');
+      expect(encodedImageSize(preview.png), const Size(1920, 1080));
+      expect(preview.info.outputSar, isNull);
+      expect(preview.info.outputDar, isNull);
+      expect(preview.aspect, closeTo(16 / 9, 1e-6),
+          reason: 'the processed frame must not be drawn at the source\'s 4:3');
+
+      // The picture inside the bars is the width the encode makes it: 4:3
+      // at 1080 tall is 1440. Without the source SAR in the preview job it
+      // was fitted as 1350.
+      final out = await _encode('aspect_149_square', params,
+          input: _pal43, inputSar: '16:15');
+      expect((out.width, out.height), (1920, 1080));
+      final encoded = await _pictureWidth(
+          await WorkerHarness.frameRgb24(
+              '$_outDir/aspect_149_square.mkv', 0, label: 'enc149'),
+          1920, 1080);
+      final previewed = await _pictureWidth(
+          await WorkerHarness.imageToRgb24(preview.png, label: 'pv149'),
+          1920, 1080);
+      print('  picture width: encode $encoded, preview $previewed');
+      expect(encoded, closeTo(1440, 4));
+      expect(previewed, closeTo(encoded, 4));
+    }, timeout: const Timeout(Duration(minutes: 5)));
+
+    test('preserve: drawn at the SAR the encode stamps', () async {
+      final params = reporter(PixelAspectMode.preserve);
+      final preview = await _preview('preview_149_preserve', params,
+          input: _pal43, inputSar: '16:15');
+      expect(preview.info.outputSar, closeTo(16 / 15, 1e-9));
+      final out = await _encode('aspect_149_preserve', params,
+          input: _pal43, inputSar: '16:15');
+      expect(preview.aspect, closeTo(_displayAspect(out), 0.01),
+          reason: 'the preview must be drawn at the encode\'s display aspect');
+    }, timeout: const Timeout(Duration(minutes: 5)));
+
+    test('a forced display aspect is reported as a DAR', () async {
+      final preview = await _preview(
+        'preview_149_dar',
+        const CropResizeParameters(enabled: true, displayAspect: '16:9'),
+        input: _pal43,
+        inputSar: '16:15',
+      );
+      expect(preview.info.outputDar, closeTo(16 / 9, 1e-9));
+      expect(preview.aspect, closeTo(16 / 9, 1e-9));
+    }, timeout: const Timeout(Duration(minutes: 5)));
+
+    // The everyday case, and the one the fix could break: an anamorphic
+    // source that no pass reshapes. Before #149 both sides were drawn at the
+    // source's aspect without asking; now the processed side relies on the
+    // worker's report, so it must come out the source's shape.
+    test('an anamorphic source only denoised keeps its shape', () async {
+      final pipeline = ProcessingPipeline(
+        deinterlace: const QTGMCParameters(enabled: false),
+        noiseReduction:
+            NoiseReductionParameters.fromPreset(NoiseReductionPreset.light),
+      );
+      const none = CropResizeParameters();
+      final preview = await _preview('preview_149_denoise', none,
+          input: _anamorphic, inputSar: '16:11', pipeline: pipeline);
+      expect(encodedImageSize(preview.png), Size(_srcWidth.toDouble(), _srcHeight.toDouble()));
+      expect(preview.info.outputSar, closeTo(16 / 11, 1e-9));
+      final out = await _encode('aspect_149_denoise', none,
+          input: _anamorphic, inputSar: '16:11', pipeline: pipeline);
+      const source = _srcWidth * _srcSar / _srcHeight;
+      expect(_displayAspect(out), closeTo(source, 0.01));
+      expect(preview.aspect, closeTo(source, 0.01),
+          reason: 'with nothing reshaping it the processed frame must be '
+              'drawn at the source\'s display aspect, as it was before #149');
+    }, timeout: const Timeout(Duration(minutes: 5)));
+
+    // A quarter turn swaps the stored width and height and inverts the SAR:
+    // 720x576 at 16:15 (4:3) becomes 576x720 at 15:16 (3:4).
+    test('a rotated anamorphic source is drawn at the encode\'s shape',
+        () async {
+      final pipeline = ProcessingPipeline(
+        deinterlace: const QTGMCParameters(enabled: false),
+        geometry:
+            const GeometryParameters(enabled: true, rotation: Rotation.cw90),
+      );
+      const none = CropResizeParameters();
+      final preview = await _preview('preview_149_rotate', none,
+          input: _pal43, inputSar: '16:15', pipeline: pipeline);
+      expect(encodedImageSize(preview.png), Size(_srcHeight.toDouble(), _srcWidth.toDouble()));
+      expect(preview.info.outputSar, closeTo(15 / 16, 1e-9));
+      final out = await _encode('aspect_149_rotate', none,
+          input: _pal43, inputSar: '16:15', pipeline: pipeline);
+      expect((out.width, out.height), (_srcHeight, _srcWidth));
+      expect(_displayAspect(out), closeTo(3 / 4, 0.01));
+      expect(preview.aspect, closeTo(_displayAspect(out), 0.01));
+    }, timeout: const Timeout(Duration(minutes: 5)));
+  });
 }
diff --git a/app/test/integration_filter_parameters_test.dart b/app/test/integration_filter_parameters_test.dart
index 1479964..b10c033 100644
--- a/app/test/integration_filter_parameters_test.dart
+++ b/app/test/integration_filter_parameters_test.dart
@@ -184,6 +184,7 @@ VideoJob buildJob({
   DescaleParameters? descale,
   FaceRestoreParameters? faceRestore,
   ColorizeParameters? colorize,
+  String? pitchFactorsPath,
 }) => VideoJob(
   id: const Uuid().v4(),
   inputPath: TestConfig.inputFile,
@@ -213,6 +214,7 @@ VideoJob buildJob({
     codec: VideoCodec.h264, container: ContainerFormat.mkv, audioMode: AudioMode.none,
   ),
   startFrame: 10, endFrame: 30,
+  pitchFactorsPath: pitchFactorsPath,
 );
 
 /// Map NR schema param IDs to converter keys (differ in casing for ThSAD/ThSADC).
@@ -1490,9 +1492,56 @@ void main() {
       // Stab(clp, dxmax, dymax, mirror) — there is no `range` argument, and
       // passing one is a TypeError at script evaluation.
       expect(actual.containsKey('range'), isFalse);
+      // Pitch correction is off by default: no extra module, no extra call.
+      expect(script, isNot(contains('_stab_correct_pitch(')));
       print('  PASS');
     }, timeout: const Timeout(Duration(minutes: 2)));
 
+    // --- STABILIZE pitch correction (issue #150) ---
+    test('stabilize: auto pitch params', () async {
+      loadSchema('stabilize'); // confirm schema parses
+      const typed = StabilizeParameters(
+        enabled: true, dxmax: 6, dymax: 2, pitchMode: PitchMode.auto,
+        maxPitchDeviation: 1.5, smoothingRadius: 12, pitchEdgeFill: EdgeFill.black,
+      );
+      final script = await generateScriptViaWorker(
+          buildJob(testName: 'stabilize_auto', stabilize: typed));
+      final weave = parseFilterParams(script, 'haf.Stab(');
+      expect(weave['dxmax'], '6');
+      expect(weave['dymax'], '2');
+      expect(script, contains('_stab_correct_pitch('));
+      final actual = parseFilterParams(script, '_stab_correct_pitch(');
+      expect(actual['mode'], '"auto"');
+      expect(actual['max_deviation_pct'], '1.5');
+      expect(actual['radius'], '12');
+      expect(actual['black'], 'True');
+      expect(actual.containsKey('factors_path'), isFalse);
+      expect(script.indexOf('haf.Stab('), lessThan(script.indexOf('_stab_correct_pitch(')));
+      print('  PASS');
+    }, timeout: const Timeout(Duration(minutes: 2)));
+
+    test('stabilize: file pitch reads the job\'s factor file at the trim offset', () async {
+      final factors = File('${Directory.systemTemp.path}/vb_stab_${const Uuid().v4()}.pitch.txt');
+      await factors.writeAsString('# reel 1\n1.001\n0.999\n1.0005\n');
+      try {
+        const typed = StabilizeParameters(
+          enabled: true, weave: false, pitchMode: PitchMode.file, invertFactors: true,
+        );
+        final script = await generateScriptViaWorker(buildJob(
+            testName: 'stabilize_file', stabilize: typed, pitchFactorsPath: factors.path));
+        expect(script, isNot(contains('haf.Stab(')));
+        final actual = parseFilterParams(script, '_stab_correct_pitch(');
+        expect(actual['mode'], '"file"');
+        expect(actual['invert'], 'True');
+        // buildJob trims from frame 10: the lookup must start there.
+        expect(actual['frame_offset'], '10');
+        expect(actual['factors_path'], startsWith('r"'));
+        print('  PASS');
+      } finally {
+        await factors.delete();
+      }
+    }, timeout: const Timeout(Duration(minutes: 2)));
+
     test('chroma_fixes: LUTDeRainbow with its 10-bit guard', () async {
       loadSchema('chroma_fixes');
       final job = buildJob(
diff --git a/app/test/integration_high_bit_depth_filters_test.dart b/app/test/integration_high_bit_depth_filters_test.dart
index bfb7b1c..af77a4a 100644
--- a/app/test/integration_high_bit_depth_filters_test.dart
+++ b/app/test/integration_high_bit_depth_filters_test.dart
@@ -61,6 +61,7 @@ import 'package:vapourbox/models/processing_pipeline.dart';
 import 'package:vapourbox/models/qtgmc_parameters.dart';
 import 'package:vapourbox/models/sharpen_parameters.dart';
 import 'package:vapourbox/models/spotless_parameters.dart';
+import 'package:vapourbox/models/stabilize_parameters.dart';
 import 'package:vapourbox/models/video_job.dart';
 
 import 'support/worker_harness.dart';
@@ -291,6 +292,7 @@ ProcessingPipeline _only({
   FrameRateParameters frameRate = const FrameRateParameters(),
   DescaleParameters descale = const DescaleParameters(),
   AntiAliasParameters antiAlias = const AntiAliasParameters(),
+  StabilizeParameters stabilize = const StabilizeParameters(),
 }) {
   return ProcessingPipeline(
     deinterlace: deinterlace,
@@ -311,6 +313,7 @@ ProcessingPipeline _only({
     frameRate: frameRate,
     descale: descale,
     antiAlias: antiAlias,
+    stabilize: stabilize,
   );
 }
 
@@ -377,6 +380,23 @@ List<_Pass> _passes() => [
 
       _Pass('spotless', _only(spotless: const SpotLessParameters(enabled: true))),
 
+      // Stabilize (weave + pitch correction, issue #150): Depan and the pitch
+      // search must see the same picture at any depth, and the black edge fill
+      // is computed from the format rather than written as 8-bit constants.
+      _Pass(
+        'stabilize',
+        _only(
+          stabilize: const StabilizeParameters(enabled: true, pitchMode: PitchMode.auto),
+        ),
+      ),
+      _Pass(
+        'stabilize_black_edges',
+        _only(
+          stabilize: const StabilizeParameters(
+              enabled: true, pitchMode: PitchMode.auto, pitchEdgeFill: EdgeFill.black),
+        ),
+      ),
+
       _Pass(
         'noise_smdegrain',
         _only(
diff --git a/app/test/integration_stabilize_test.dart b/app/test/integration_stabilize_test.dart
new file mode 100644
index 0000000..adccde7
--- /dev/null
+++ b/app/test/integration_stabilize_test.dart
@@ -0,0 +1,261 @@
+/// End-to-end tests for the Stabilize pass's vertical pitch ("frame height
+/// breathing") correction for scanned film (issue #150).
+///
+/// A filter like this can run cleanly and produce the wrong picture, so these
+/// test against a *reference* rather than "did it run": a fixture is built
+/// with a known per-frame vertical stretch (by the stabiliser's own file mode,
+/// inverted), and the corrections must bring it back measurably closer to the
+/// undistorted original.
+///
+/// Heavy (full-encode) — tagged so it runs in the nightly workflow, not the
+/// push gate. Script-generation coverage is in
+/// integration_filter_parameters_test.dart and the worker's test_211…test_218.
+@Tags(['heavy'])
+library;
+
+// ignore_for_file: avoid_print — these tests print diagnostics to the test log.
+
+import 'dart:io';
+import 'dart:math' as math;
+import 'dart:typed_data';
+
+import 'package:flutter_test/flutter_test.dart';
+import 'package:path/path.dart' as p;
+import 'package:uuid/uuid.dart';
+
+import 'package:vapourbox/models/encoding_settings.dart';
+import 'package:vapourbox/models/processing_pipeline.dart';
+import 'package:vapourbox/models/qtgmc_parameters.dart';
+import 'package:vapourbox/models/stabilize_parameters.dart';
+import 'package:vapourbox/models/video_job.dart';
+
+import 'support/worker_harness.dart';
+
+String get _outDir => '${WorkerHarness.outputDir}/stabilize';
+
+String get _source =>
+    p.join(WorkerHarness.repoRoot, 'Tests', 'TestResources', 'small_clip.mp4');
+
+// A steady stretch of small_clip.mp4 (320x240, 29.97p): little subject motion,
+// so pitch is measurable on every frame.
+const _start = 900;
+const _frames = 34;
+const _width = 320;
+const _height = 240;
+
+/// The breathing injected into the fixture: up to ±0.6% of frame height per
+/// frame — about what a pull-through scanner produces — from a fixed seed.
+final List<double> _factors = () {
+  final rng = math.Random(150);
+  return List.generate(_frames, (_) => 1.0 + (rng.nextDouble() * 2 - 1) * 0.006);
+}();
+
+const _off = StabilizeParameters();
+
+VideoJob _job(
+  String name, {
+  required String input,
+  required StabilizeParameters stabilize,
+  String? factorsPath,
+  int? startFrame,
+  int? endFrame,
+  int totalFrames = _frames,
+}) =>
+    VideoJob(
+      id: const Uuid().v4(),
+      inputPath: input,
+      outputPath: '$_outDir/$name.mkv',
+      processingPipeline: ProcessingPipeline(
+        deinterlace: const QTGMCParameters(enabled: false),
+        stabilize: stabilize,
+      ),
+      encodingSettings: const EncodingSettings(
+        codec: VideoCodec.ffv1,
+        container: ContainerFormat.mkv,
+        audioMode: AudioMode.none,
+      ),
+      detectedFieldOrder: FieldOrder.progressive,
+      totalFrames: totalFrames,
+      inputFrameRate: 29.97,
+      inputWidth: _width,
+      inputHeight: _height,
+      inputPixelFormat: 'yuv420p',
+      startFrame: startFrame,
+      endFrame: endFrame,
+      pitchFactorsPath: factorsPath,
+    );
+
+Future<String> _encode(VideoJob job) async {
+  final result = await WorkerHarness.runJob(job.toJson(), label: p.basename(job.outputPath));
+  final tail = result.logs.length > 25 ? result.logs.sublist(result.logs.length - 25) : result.logs;
+  expect(result.success, isTrue,
+      reason: '${result.error}\n--- worker log (tail) ---\n${tail.join('\n')}');
+  return result.outputPath!;
+}
+
+/// Frame [n] of [video] as rgb24.
+Future<Uint8List> _frame(String video, int n) async {
+  final result = await Process.run(
+    WorkerHarness.ffmpegPath,
+    [
+      '-v', 'error', '-i', video,
+      '-vf', 'select=eq(n\\,$n)', '-frames:v', '1',
+      '-f', 'rawvideo', '-pix_fmt', 'rgb24', '-',
+    ],
+    environment: WorkerHarness.ffmpegEnv,
+    stdoutEncoding: null,
+  );
+  if (result.exitCode != 0) throw Exception('frame $n of $video: ${result.stderr}');
+  return Uint8List.fromList(result.stdout as List<int>);
+}
+
+/// Mean abs diff (0-255) to [reference] over the interior frames, ignoring
+/// the top and bottom rows a correction fills from outside the picture.
+Future<double> _distance(String video, String reference) async {
+  const margin = 8; // rows
+  const rowBytes = _width * 3;
+  var total = 0.0;
+  var count = 0;
+  for (var n = 6; n < _frames - 6; n++) {
+    final a = await _frame(video, n);
+    final b = await _frame(reference, n);
+    Uint8List crop(Uint8List x) =>
+        Uint8List.sublistView(x, margin * rowBytes, (_height - margin) * rowBytes);
+    total += WorkerHarness.meanAbsDiff(crop(a), crop(b));
+    count++;
+  }
+  return total / count;
+}
+
+void main() {
+  late String reference; // the untouched frames
+  late String distorted; // the same frames with known breathing
+  late String factorsForDistorted; // per-frame factors, indexed from 0
+
+  setUpAll(() async {
+    await WorkerHarness.ensureReady();
+    await Directory(_outDir).create(recursive: true);
+
+    // The reference: the same trimmed range, pass off, lossless.
+    reference = await _encode(_job('reference',
+        input: _source,
+        stabilize: _off,
+        startFrame: _start,
+        endFrame: _start + _frames - 1));
+
+    // The fixture: file mode, inverted, on a TRIMMED encode — so this also
+    // exercises source-frame indexing (the file names frames 900…933).
+    final injectFile = File('$_outDir/inject.pitch.txt');
+    await injectFile.writeAsString([
+      '# frame,factor — stretch to apply',
+      for (var k = 0; k < _frames; k++) '${_start + k},${_factors[k]}',
+    ].join('\n'));
+    distorted = await _encode(_job('distorted',
+        input: _source,
+        stabilize: const StabilizeParameters(
+          enabled: true,
+          weave: false,
+          pitchMode: PitchMode.file,
+          invertFactors: true,
+        ),
+        factorsPath: injectFile.path,
+        startFrame: _start,
+        endFrame: _start + _frames - 1));
+
+    final f = File('$_outDir/distorted.pitch.txt');
+    await f.writeAsString(_factors.join('\n'));
+    factorsForDistorted = f.path;
+  });
+
+  test('the fixture is actually distorted', () async {
+    final d = await _distance(distorted, reference);
+    print('  distorted vs reference: $d');
+    // ~0.33 measured: small_clip is soft, so ±0.6% of height moves little.
+    // Every other bound here is relative to this, so it just has to be real.
+    expect(d, greaterThan(0.2), reason: 'the injected breathing must be visible to the metric');
+  }, timeout: const Timeout(Duration(minutes: 5)));
+
+  test('file mode undoes known per-frame factors', () async {
+    final corrected = await _encode(_job('file_corrected',
+        input: distorted,
+        stabilize: const StabilizeParameters(
+          enabled: true,
+          weave: false,
+          pitchMode: PitchMode.file,
+        ),
+        factorsPath: factorsForDistorted));
+    final before = await _distance(distorted, reference);
+    final after = await _distance(corrected, reference);
+    print('  file mode: $before -> $after');
+    // Two Spline36 resamples can't be perfect, but most of the error must go.
+    expect(after, lessThan(before * 0.4));
+  }, timeout: const Timeout(Duration(minutes: 5)));
+
+  test('auto mode measures and removes the breathing', () async {
+    final corrected = await _encode(_job('auto_corrected',
+        input: distorted,
+        stabilize: const StabilizeParameters(
+          enabled: true,
+          weave: false,
+          pitchMode: PitchMode.auto,
+        )));
+    final before = await _distance(distorted, reference);
+    final after = await _distance(corrected, reference);
+    print('  auto mode: $before -> $after');
+    // Auto corrects to the local mean rather than the absolute truth, and the
+    // clip has some real motion, so it is held to a looser bound than file
+    // mode: it must still remove a clear majority of the error.
+    expect(after, lessThan(before * 0.75));
+  }, timeout: const Timeout(Duration(minutes: 8)));
+
+  test('weave + auto pitch runs and keeps the frame geometry', () async {
+    final out = await _encode(_job('weave_auto',
+        input: distorted,
+        stabilize: const StabilizeParameters(
+            enabled: true, pitchMode: PitchMode.auto, pitchEdgeFill: EdgeFill.black)));
+    final v = await WorkerHarness.firstStream(out,
+        selector: 'v:0', entries: ['width', 'height', 'nb_read_frames'],
+        countFrames: true);
+    expect(v?['width'], _width);
+    expect(v?['height'], _height);
+    expect(int.parse('${v?['nb_read_frames']}'), _frames);
+    // Stabilising an already-steady clip must not wreck it.
+    expect(await _distance(out, distorted), lessThan(6.0));
+  }, timeout: const Timeout(Duration(minutes: 8)));
+
+  test('preview applies the factor of the frame it shows', () async {
+    // The preview decodes a window that starts before the target, so frame n
+    // of the preview script is not source frame n. If the offset were lost,
+    // the preview would correct frame 15 with another frame's factor.
+    const target = 15;
+    final job = _job('preview_file',
+        input: distorted,
+        stabilize: const StabilizeParameters(
+          enabled: true,
+          weave: false,
+          pitchMode: PitchMode.file,
+        ),
+        factorsPath: factorsForDistorted);
+    final corrected = await WorkerHarness.runPreview(job.toJson(), frame: target);
+    final plain = await WorkerHarness.runPreview(
+        _job('preview_plain', input: distorted, stabilize: _off).toJson(),
+        frame: target);
+    final ref = await WorkerHarness.runPreview(
+        _job('preview_ref', input: reference, stabilize: _off).toJson(),
+        frame: target);
+
+    for (final (label, result) in [('corrected', corrected), ('plain', plain), ('ref', ref)]) {
+      expect(result.success, isTrue, reason: '$label preview failed: ${result.error}\n${result.logs}');
+    }
+    final c = await WorkerHarness.imageToRgb24(corrected.png!, label: 'stab_c');
+    final d = await WorkerHarness.imageToRgb24(plain.png!, label: 'stab_d');
+    final r = await WorkerHarness.imageToRgb24(ref.png!, label: 'stab_r');
+    const rowBytes = _width * 3;
+    Uint8List crop(Uint8List x) =>
+        Uint8List.sublistView(x, 8 * rowBytes, (_height - 8) * rowBytes);
+    final before = WorkerHarness.meanAbsDiff(crop(d), crop(r));
+    final after = WorkerHarness.meanAbsDiff(crop(c), crop(r));
+    print('  preview frame $target (factor ${_factors[target]}): $before -> $after');
+    expect(after, lessThan(before * 0.5));
+  }, timeout: const Timeout(Duration(minutes: 5)));
+}
diff --git a/app/test/parameter_converter_test.dart b/app/test/parameter_converter_test.dart
index e5ee0ec..c63f6ad 100644
--- a/app/test/parameter_converter_test.dart
+++ b/app/test/parameter_converter_test.dart
@@ -11,6 +11,7 @@ import 'package:vapourbox/models/parameter_converter.dart';
 import 'package:vapourbox/models/qtgmc_parameters.dart';
 import 'package:vapourbox/models/processing_pipeline.dart';
 import 'package:vapourbox/models/sharpen_parameters.dart';
+import 'package:vapourbox/models/stabilize_parameters.dart';
 
 void main() {
   group('ParameterConverter', () {
@@ -393,6 +394,71 @@ void main() {
       });
     });
 
+    group('stabilize', () {
+      test('round-trips every field through the dynamic form', () {
+        const typed = StabilizeParameters(
+          enabled: true,
+          weave: false,
+          dxmax: 7,
+          dymax: 2,
+          mirror: 3,
+          pitchMode: PitchMode.file,
+          maxPitchDeviation: 2.5,
+          smoothingRadius: 14,
+          invertFactors: true,
+          pitchEdgeFill: EdgeFill.black,
+        );
+        final dynamic = ParameterConverter.fromStabilize(typed);
+        expect(dynamic.filterId, 'stabilize');
+        expect(dynamic.values['pitchMode'], 'file');
+        expect(dynamic.values['pitchEdgeFill'], 'black');
+        final back = ParameterConverter.toStabilize(dynamic);
+        expect(back.toJson(), typed.toJson());
+      });
+
+      test('is part of the dynamic pipeline both ways', () {
+        const pipeline = ProcessingPipeline(
+          stabilize: StabilizeParameters(
+              enabled: true, pitchMode: PitchMode.auto, smoothingRadius: 6),
+        );
+        final dynamicPipeline = ParameterConverter.fromPipeline(pipeline);
+        expect(dynamicPipeline.get('stabilize')?.enabled, isTrue);
+        final back = ParameterConverter.toPipeline(dynamicPipeline);
+        expect(back.stabilize.enabled, isTrue);
+        expect(back.stabilize.pitchMode, PitchMode.auto);
+        expect(back.stabilize.smoothingRadius, 6);
+      });
+
+      test('a pass saved before pitch correction keeps doing only weave', () {
+        // What a preset or job from before issue #150 holds.
+        final loaded = StabilizeParameters.fromJson(
+            {'enabled': true, 'dxmax': 6, 'dymax': 2, 'mirror': 3});
+        expect(loaded.weave, isTrue);
+        expect(loaded.pitchMode, PitchMode.off);
+        expect(loaded.dxmax, 6);
+        // And through the dynamic form the panel edits.
+        final viaDynamic = ParameterConverter.toStabilize(
+            ParameterConverter.fromStabilize(loaded));
+        expect(viaDynamic.toJson(), loaded.toJson());
+      });
+
+      test('wire names match the worker', () {
+        // Rust: StabilizeParameters (serde camelCase), PitchMode/EdgeFill
+        // camelCase variants — see test_pitch_serde_names_are_the_wire_format.
+        final json = const StabilizeParameters(
+          enabled: true, pitchMode: PitchMode.file, pitchEdgeFill: EdgeFill.black,
+        ).toJson();
+        expect(json.keys, containsAll(<String>[
+          'enabled', 'weave', 'dxmax', 'dymax', 'mirror', 'pitchMode',
+          'maxPitchDeviation', 'smoothingRadius', 'invertFactors', 'pitchEdgeFill',
+        ]));
+        expect(json['pitchMode'], 'file');
+        expect(json['pitchEdgeFill'], 'black');
+        expect(PitchMode.values.map((m) => m.value), ['off', 'auto', 'file']);
+        expect(EdgeFill.values.map((m) => m.value), ['extend', 'black']);
+      });
+    });
+
     group('fromPipeline', () {
       test('converts full processing pipeline', () {
         const pipeline = ProcessingPipeline(
diff --git a/app/test/pitch_factor_file_test.dart b/app/test/pitch_factor_file_test.dart
new file mode 100644
index 0000000..3d2f8a4
--- /dev/null
+++ b/app/test/pitch_factor_file_test.dart
@@ -0,0 +1,63 @@
+import 'dart:io';
+
+import 'package:flutter_test/flutter_test.dart';
+import 'package:path/path.dart' as p;
+import 'package:vapourbox/services/pitch_factor_file.dart';
+
+void main() {
+  group('PitchFactorFile.parse', () {
+    test('counts bare factors, skipping comments and blank lines', () {
+      final info = PitchFactorFile.parse('# log\n1.0012\n\n0.999 # slip\r\n1\n');
+      expect(info.isValid, isTrue);
+      expect(info.frameCount, 3);
+    });
+
+    test('frame,factor files cover up to the highest frame', () {
+      final info = PitchFactorFile.parse('0,1.001\n5 0.998\n2\t1.0\n');
+      expect(info.frameCount, 6);
+    });
+
+    test('names the first bad line', () {
+      expect(PitchFactorFile.parse('1.0\nabc\n').error, contains('Line 2'));
+      expect(PitchFactorFile.parse('-1\n').error, contains('Line 1'));
+      expect(PitchFactorFile.parse('x,1.0\n').error, contains('Line 1'));
+    });
+
+    test('rejects empty and mixed files', () {
+      expect(PitchFactorFile.parse('# nothing\n').isValid, isFalse);
+      expect(PitchFactorFile.parse('1.0\n3,1.0\n').isValid, isFalse);
+    });
+
+    test('describes coverage against the video', () {
+      const info = PitchFactorFileInfo(100);
+      expect(info.describe(100), contains('one per frame'));
+      expect(info.describe(120), contains('left uncorrected'));
+      expect(info.describe(80), contains('ignored'));
+    });
+  });
+
+  group('PitchFactorFile.findSidecar', () {
+    late Directory dir;
+    setUp(() async => dir = await Directory.systemTemp.createTemp('vb_pitch'));
+    tearDown(() async => dir.delete(recursive: true));
+
+    test('finds the sidecars in priority order', () async {
+      final video = p.join(dir.path, 'reel1.mp4');
+      expect(PitchFactorFile.findSidecar(video), isNull);
+
+      await File(p.join(dir.path, 'reel1_pitch.txt')).writeAsString('1.0');
+      expect(PitchFactorFile.findSidecar(video), endsWith('reel1_pitch.txt'));
+
+      await File(p.join(dir.path, 'reel1.pitch.txt')).writeAsString('1.0');
+      expect(PitchFactorFile.findSidecar(video), endsWith('reel1.pitch.txt'));
+
+      await File(p.join(dir.path, 'reel1.mp4.pitch.txt')).writeAsString('1.0');
+      expect(PitchFactorFile.findSidecar(video), endsWith('reel1.mp4.pitch.txt'));
+    });
+
+    test('a dot in a folder name is not an extension', () {
+      final c = PitchFactorFile.sidecarCandidates('/films/v1.2/reel');
+      expect(c, contains('/films/v1.2/reel.pitch.txt'));
+    });
+  });
+}
diff --git a/app/test/preview_aspect_test.dart b/app/test/preview_aspect_test.dart
new file mode 100644
index 0000000..33108a8
--- /dev/null
+++ b/app/test/preview_aspect_test.dart
@@ -0,0 +1,150 @@
+// Issue #149: the processed preview is drawn at the shape the encode will
+// have, not the source's.
+//
+// Run with: flutter test test/preview_aspect_test.dart
+
+import 'dart:typed_data';
+
+import 'package:flutter_test/flutter_test.dart';
+import 'package:vapourbox/models/preview_frame_info.dart';
+import 'package:vapourbox/services/field_order_detector.dart';
+import 'package:vapourbox/viewmodels/main_viewmodel.dart';
+
+/// Just enough of a PNG for its header to be read: signature, IHDR length and
+/// type, width, height.
+Uint8List _pngHeader(int width, int height) {
+  final b = ByteData(24);
+  const sig = [0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A];
+  for (var i = 0; i < 8; i++) {
+    b.setUint8(i, sig[i]);
+  }
+  b.setUint32(8, 13);
+  b.setUint32(12, 0x49484452); // "IHDR"
+  b.setUint32(16, width);
+  b.setUint32(20, height);
+  return b.buffer.asUint8List();
+}
+
+void main() {
+  group('comparison aspects through the view model', viewModelAspects);
+
+  group('processedDisplayAspect', () {
+    final canvas = _pngHeader(1920, 1080);
+
+    test('square pixels: the frame\'s own shape, not the source\'s', () {
+      // The reporter's setup with Square pixel aspect: nothing declared.
+      final info = PreviewFrameInfo.parse('PREVIEW_INFO:frame=1')!;
+      expect(processedDisplayAspect(canvas, info), closeTo(16 / 9, 1e-9));
+    });
+
+    test('a declared SAR stretches the stored size', () {
+      final info = PreviewFrameInfo.parse('PREVIEW_INFO:frame=1 sar=16/15')!;
+      expect(processedDisplayAspect(canvas, info),
+          closeTo(1920 * 16 / 15 / 1080, 1e-9));
+    });
+
+    test('a declared DAR is used as is', () {
+      final info = PreviewFrameInfo.parse('PREVIEW_INFO:frame=1 dar=4/3')!;
+      expect(processedDisplayAspect(canvas, info), closeTo(4 / 3, 1e-9));
+    });
+
+    test('nothing to go on draws the frame at its own shape', () {
+      final info = PreviewFrameInfo.parse('PREVIEW_INFO:frame=1')!;
+      expect(processedDisplayAspect(null, info), isNull);
+      expect(processedDisplayAspect(canvas, null), isNull);
+      expect(processedDisplayAspect(Uint8List.fromList([1, 2, 3]), info),
+          isNull);
+    });
+  });
+
+  group('FieldOrderDetector.normalizeSar', () {
+    test('keeps a real SAR', () {
+      expect(FieldOrderDetector.normalizeSar('16:15'), '16:15');
+      expect(FieldOrderDetector.normalizeSar(' 64:45 '), '64:45');
+    });
+
+    test('square, unknown and missing read as none', () {
+      for (final raw in [null, '', 'N/A', '1:1', '0:1']) {
+        expect(FieldOrderDetector.normalizeSar(raw), isNull, reason: '$raw');
+      }
+    });
+  });
+}
+
+/// What the comparison panel draws each side at, through the view model it
+/// reads — so dropping the stored aspect, or computing it from the frame
+/// info (null once the scrubber moves), fails here.
+void viewModelAspects() {
+  TestWidgetsFlutterBinding.ensureInitialized();
+
+  late MainViewModel vm;
+  setUp(() => vm = MainViewModel());
+  tearDown(() => vm.dispose());
+
+  // NTSC DVD: 720x480 with 32:27 pixels is 16:9 on screen.
+  const dvd = 720 / 480 * 32 / 27;
+
+  test('an anamorphic source with no reshaping pass: both sides 16:9', () {
+    vm.debugAddQueueItemForTest('/tmp/vb_dvd.mkv',
+        width: 720, height: 480, sar: '32:27');
+    expect(vm.sourceDisplayAspect, closeTo(dvd, 1e-9));
+
+    // A denoise-only pipeline: the worker re-stamps the source's SAR.
+    vm.debugAcceptProcessedPreview(_pngHeader(720, 480),
+        PreviewFrameInfo.parse('PREVIEW_INFO:frame=0 sar=32/27'));
+    expect(vm.comparisonAfterAspect, closeTo(dvd, 1e-9),
+        reason: 'the processed frame must keep the source\'s shape when '
+            'nothing reshapes it');
+  });
+
+  test('before a processed frame exists the after side is the source\'s',
+      () {
+    vm.debugAddQueueItemForTest('/tmp/vb_dvd.mkv',
+        width: 720, height: 480, sar: '32:27');
+    expect(vm.processedPreview, isNull);
+    expect(vm.comparisonAfterAspect, closeTo(dvd, 1e-9));
+  });
+
+  test('square-pixel source: no correction on either side', () {
+    vm.debugAddQueueItemForTest('/tmp/vb_sq.mkv', width: 1920, height: 1080);
+    expect(vm.sourceDisplayAspect, isNull);
+    vm.debugAcceptProcessedPreview(_pngHeader(1920, 1080),
+        PreviewFrameInfo.parse('PREVIEW_INFO:frame=0'));
+    expect(vm.comparisonAfterAspect, closeTo(16 / 9, 1e-9));
+  });
+
+  test('a reshaped frame is drawn at its own shape, not the source\'s', () {
+    vm.debugAddQueueItemForTest('/tmp/vb_pal.mkv',
+        width: 720, height: 576, sar: '16:15');
+    vm.debugAcceptProcessedPreview(_pngHeader(1920, 1080),
+        PreviewFrameInfo.parse('PREVIEW_INFO:frame=0'));
+    expect(vm.sourceDisplayAspect, closeTo(4 / 3, 1e-9));
+    expect(vm.comparisonAfterAspect, closeTo(16 / 9, 1e-9));
+  });
+
+  test('the processed aspect survives a scrubber move', () async {
+    vm.debugAddQueueItemForTest('/tmp/vb_pal.mkv',
+        width: 720, height: 576, sar: '16:15');
+    // Rendered for frame 7; the scrubber then sits somewhere else (with no
+    // video loaded every position maps to frame 0).
+    vm.debugAcceptProcessedPreview(_pngHeader(1920, 1080),
+        PreviewFrameInfo.parse('PREVIEW_INFO:frame=7'));
+
+    // The image stays on screen until the next preview replaces it, but the
+    // frame info no longer matches the scrubber's frame.
+    await vm.setScrubberPosition(0.5);
+    expect(vm.previewFrameInfo, isNull);
+    expect(vm.processedPreview, isNotNull);
+    expect(vm.comparisonAfterAspect, closeTo(16 / 9, 1e-9));
+  });
+
+  test('a failed preview clears the stored aspect with the image', () {
+    vm.debugAddQueueItemForTest('/tmp/vb_pal.mkv',
+        width: 720, height: 576, sar: '16:15');
+    vm.debugAcceptProcessedPreview(_pngHeader(1920, 1080),
+        PreviewFrameInfo.parse('PREVIEW_INFO:frame=0'));
+    vm.debugAcceptProcessedPreview(null, null);
+    expect(vm.processedPreviewAspect, isNull);
+    expect(vm.comparisonAfterAspect, closeTo(4 / 3, 1e-9));
+  });
+}
diff --git a/app/test/preview_frame_info_test.dart b/app/test/preview_frame_info_test.dart
index 7337042..de4bf23 100644
--- a/app/test/preview_frame_info_test.dart
+++ b/app/test/preview_frame_info_test.dart
@@ -1,3 +1,5 @@
+import 'dart:ui' show Size;
+
 import 'package:flutter_test/flutter_test.dart';
 import 'package:vapourbox/models/preview_frame_info.dart';
 
@@ -31,5 +33,52 @@ void main() {
           'PREVIEW_INFO:frame=3 sub_frame=9 sub_frames=2 generated=0')!;
       expect(info.subFrame, 1);
     });
+
+    // Issue #149: the processed frame is drawn at the aspect the encode will
+    // declare, not the source's.
+    test('reads the output SAR the encode will declare', () {
+      final info = PreviewFrameInfo.parse(
+          'PREVIEW_INFO:frame=3 sub_frame=0 sub_frames=1 generated=0 sar=16/15')!;
+      expect(info.outputSar, closeTo(16 / 15, 1e-9));
+      expect(info.outputDar, isNull);
+      // 1920x1080 padded, Preserve kept the PAL 4:3 SAR: wider than 16:9.
+      expect(info.displayAspectFor(const Size(1920, 1080)),
+          closeTo(1920 / 1080 * 16 / 15, 1e-9));
+    });
+
+    test('a forced DAR wins over the frame size', () {
+      final info =
+          PreviewFrameInfo.parse('PREVIEW_INFO:frame=3 dar=16/9')!;
+      expect(info.outputDar, closeTo(16 / 9, 1e-9));
+      expect(info.displayAspectFor(const Size(720, 576)), closeTo(16 / 9, 1e-9));
+    });
+
+    test('no aspect token means square pixels: the frame\'s own shape', () {
+      final info = PreviewFrameInfo.parse(
+          'PREVIEW_INFO:frame=3 sub_frame=0 sub_frames=1 generated=0')!;
+      expect(info.outputSar, isNull);
+      expect(info.outputDar, isNull);
+      expect(info.displayAspectFor(const Size(1920, 1080)),
+          closeTo(16 / 9, 1e-9));
+    });
+
+    test('a malformed aspect is ignored rather than drawn zero-wide', () {
+      final info =
+          PreviewFrameInfo.parse('PREVIEW_INFO:frame=3 sar=0/1 dar=wide')!;
+      expect(info.outputSar, isNull);
+      expect(info.outputDar, isNull);
+      expect(info.frame, 3);
+    });
+  });
+
+  group('PreviewFrameInfo.parseRatio', () {
+    test('accepts the forms the worker and users write', () {
+      expect(PreviewFrameInfo.parseRatio('16/9'), closeTo(16 / 9, 1e-9));
+      expect(PreviewFrameInfo.parseRatio('16:9'), closeTo(16 / 9, 1e-9));
+      expect(PreviewFrameInfo.parseRatio('1.5'), 1.5);
+      for (final junk in [null, '', '16/0', '-4/3', 'wide', '1/2/3']) {
+        expect(PreviewFrameInfo.parseRatio(junk), isNull, reason: '$junk');
+      }
+    });
   });
 }
diff --git a/docs/BUILDING.md b/docs/BUILDING.md
index fdea36c..ba229bc 100644
--- a/docs/BUILDING.md
+++ b/docs/BUILDING.md
@@ -63,7 +63,7 @@ VapourBox/
 │   │   ├── pixel_format.rs
 │   │   └── progress_reporter.rs
 │   ├── templates/              # pipeline_template.vpy, preview_template.vpy,
-│   │                           #   pipe_source.py, spotless.py
+│   │                           #   pipe_source.py, spotless.py, stabilize.py
 │   └── tests/                  # filter/preview/subtitle integration tests
 │
 ├── deps/                       # Platform dependencies (NOT committed —
diff --git a/worker/src/models/crop_resize_parameters.rs b/worker/src/models/crop_resize_parameters.rs
index 78706c9..e992022 100644
--- a/worker/src/models/crop_resize_parameters.rs
+++ b/worker/src/models/crop_resize_parameters.rs
@@ -521,6 +521,21 @@ pub enum AspectDeclaration {
     None,
 }
 
+impl AspectDeclaration {
+    /// The `key=value` token the preview reports on its `PREVIEW_INFO:` line,
+    /// or `None` for square pixels: `sar=16/15` or `dar=16/9`. The app draws
+    /// the processed frame at this shape; without it the frame was drawn at
+    /// the *source's* display aspect, squashing anything a pass reshaped
+    /// (issue #149). '/' as the separator, matching what ffmpeg is given.
+    pub fn preview_token(&self) -> Option<String> {
+        match self {
+            AspectDeclaration::Sar(sar) => Some(format!("sar={}", sar.trim().replace(':', "/"))),
+            AspectDeclaration::Dar(dar) => Some(format!("dar={}", dar.trim().replace(':', "/"))),
+            AspectDeclaration::None => None,
+        }
+    }
+}
+
 #[allow(dead_code)]
 impl CropResizeParameters {
     /// Whether this pass upscales with a neural model, which needs the VSNCNN
@@ -958,6 +973,19 @@ mod tests {
         assert_eq!(params.aspect_declaration(Some("10:11")), AspectDeclaration::None);
     }
 
+    #[test]
+    fn test_preview_token() {
+        assert_eq!(
+            AspectDeclaration::Sar("16:15".into()).preview_token().as_deref(),
+            Some("sar=16/15")
+        );
+        assert_eq!(
+            AspectDeclaration::Dar("16/9".into()).preview_token().as_deref(),
+            Some("dar=16/9")
+        );
+        assert_eq!(AspectDeclaration::None.preview_token(), None);
+    }
+
     #[test]
     fn test_parse_hex_color() {
         assert_eq!(parse_hex_color("#FF8000"), Some([255, 128, 0]));
diff --git a/worker/src/models/processing_pipeline.rs b/worker/src/models/processing_pipeline.rs
index a4cecfb..53e04fc 100644
--- a/worker/src/models/processing_pipeline.rs
+++ b/worker/src/models/processing_pipeline.rs
@@ -9,6 +9,7 @@ use super::{
     ChromaDenoiseParameters, ChromaFixParameters, ColorCorrectionParameters, CropResizeParameters,
     DebandParameters, DeblockParameters, DehaloParameters, DeinterlaceMethod, DeScratchParameters,
     SpotLessParameters, SharpenParameters, NoiseReductionParameters, QTGMCParameters, FrameRateParameters, FrameRateMethod, NoiseReductionMethod, DeflickerParameters, EdgeRepairParameters, GhostRemovalParameters, DescaleParameters, FaceRestoreParameters, ColorizeParameters, AudioRestorationParameters,};
+use super::AspectDeclaration;
 
 /// Minimum temporal context (frames on each side of the target) a windowed
 /// preview decodes, regardless of which filters are enabled. Motion-compensated
@@ -219,7 +220,7 @@ impl PassType {
             PassType::Deband => "Remove color banding from gradients",
             PassType::Sharpen => "Sharpen edges and enhance detail",
             PassType::AntiAlias => "Smooth stair-stepping on diagonal edges",
-            PassType::Stabilize => "Remove shake and weave from the picture",
+            PassType::Stabilize => "Remove shake, gate weave and frame-height breathing",
             PassType::Geometry => "Rotate or mirror the picture",
             PassType::Grain => "Add film grain back after denoising",
             PassType::Deflicker => "Even out brightness pulsing between frames",
@@ -643,6 +644,9 @@ impl ProcessingPipeline {
                 radius: self.chroma_denoise.radius(),
             },
             PassType::SpotLess => FrameMap::Identity { radius: 2 },
+            // Stab's temporal average plus, for auto pitch, the measured pairs
+            // either side (issue #150).
+            PassType::Stabilize => FrameMap::Identity { radius: self.stabilize.radius() },
             PassType::DeScratch => FrameMap::Identity { radius: 1 },
             PassType::Deflicker => FrameMap::Identity { radius: self.deflicker.radius() },
             PassType::EdgeRepair => FrameMap::Identity { radius: 0 },
@@ -745,6 +749,24 @@ impl ProcessingPipeline {
         }
     }
 
+    /// Frame-rate change, as `(num, den)` output/input, of the passes that run
+    /// before Stabilize (in practice deinterlacing: double rate or IVTC). The
+    /// pass's per-source-frame lookup — the pitch factor file — maps its clip
+    /// frame `n` back to source frame `offset + n * den / num` (issue #150).
+    pub fn rate_before_stabilize(&self) -> (u64, u64) {
+        let (mut num, mut den) = (1u64, 1u64);
+        for pass in self.enabled_passes() {
+            if pass == PassType::Stabilize {
+                break;
+            }
+            let (n, d) = self.frame_map_for(pass).rate_factor();
+            num *= n;
+            den *= d;
+        }
+        let g = gcd(num, den).max(1);
+        (num / g, den / g)
+    }
+
     /// Total output frame count for a given source frame count, composing every
     /// enabled pass's forward map. Replaces ad-hoc double-rate / IVTC scaling.
     pub fn output_count(&self, source_frames: u64) -> u64 {
@@ -860,6 +882,20 @@ impl ProcessingPipeline {
         declared.max(MIN_PREVIEW_RADIUS)
     }
 
+    /// How the output's aspect is declared, given the source's SAR as ffprobe
+    /// reports it ("16:15", or `None` for square pixels).
+    ///
+    /// The single decision used by both the encode (which stamps it with
+    /// `setsar`/`setdar`, because the Y4M pipe strips aspect) and the preview
+    /// (which reports it so the app can draw the processed frame at the shape
+    /// the encode will have — issue #149). A quarter turn exchanges pixel width
+    /// and height, so the source SAR is adjusted for rotation first, or a
+    /// rotated anamorphic source is stretched by the square of its own aspect.
+    pub fn output_aspect(&self, input_sar: Option<&str>) -> AspectDeclaration {
+        let rotated_sar = self.geometry.adjusted_sar(input_sar);
+        self.crop_resize.aspect_declaration(rotated_sar.as_deref())
+    }
+
     /// Check if a specific pass is enabled.
     pub fn is_pass_enabled(&self, pass: PassType) -> bool {
         match pass {
@@ -894,6 +930,49 @@ impl ProcessingPipeline {
 mod tests {
     use super::*;
 
+    #[test]
+    fn test_output_aspect_carries_the_source_sar_through() {
+        let p = ProcessingPipeline::default();
+        assert_eq!(p.output_aspect(Some("16:15")), AspectDeclaration::Sar("16:15".into()));
+        assert_eq!(p.output_aspect(None), AspectDeclaration::None);
+    }
+
+    #[test]
+    fn test_output_aspect_adjusts_the_sar_for_a_quarter_turn() {
+        let p = ProcessingPipeline {
+            geometry: GeometryParameters {
+                enabled: true,
+                rotation: crate::models::Rotation::Cw90,
+                ..Default::default()
+            },
+            ..Default::default()
+        };
+        assert_eq!(p.output_aspect(Some("16:15")), AspectDeclaration::Sar("15:16".into()));
+    }
+
+    #[test]
+    fn test_output_aspect_follows_the_crop_resize_decision() {
+        let square = ProcessingPipeline {
+            crop_resize: CropResizeParameters {
+                enabled: true,
+                pixel_aspect: crate::models::PixelAspectMode::Square,
+                ..Default::default()
+            },
+            ..Default::default()
+        };
+        assert_eq!(square.output_aspect(Some("16:15")), AspectDeclaration::None);
+
+        let forced = ProcessingPipeline {
+            crop_resize: CropResizeParameters {
+                enabled: true,
+                display_aspect: Some("16:9".into()),
+                ..Default::default()
+            },
+            ..Default::default()
+        };
+        assert_eq!(forced.output_aspect(Some("16:15")), AspectDeclaration::Dar("16/9".into()));
+    }
+
     fn retimed(target: (u32, u32), src: (u32, u32), method: FrameRateMethod, deinterlace: bool) -> ProcessingPipeline {
         ProcessingPipeline {
             deinterlace: QTGMCParameters { enabled: deinterlace, ..Default::default() },
@@ -1116,6 +1195,31 @@ mod tests {
         assert!(span.exact);
     }
 
+    #[test]
+    fn test_stabilize_radius_and_rate_before_it() {
+        let mut p = ProcessingPipeline::default();
+        p.deinterlace.enabled = false;
+        p.stabilize.enabled = true;
+        // Weave only: Stab's measured reach is declared, so a windowed
+        // preview decodes enough context (it used to be treated as spatial).
+        assert_eq!(p.frame_map_for(PassType::Stabilize).radius(), 9);
+        p.stabilize.pitch_mode = crate::models::PitchMode::Auto;
+        assert_eq!(p.frame_map_for(PassType::Stabilize).radius(), 20);
+        // Identity map: the frame count is unchanged.
+        assert_eq!(p.output_count(500), 500);
+        assert_eq!(p.rate_before_stabilize(), (1, 1));
+
+        p.deinterlace.enabled = true;
+        p.deinterlace.method = DeinterlaceMethod::Qtgmc;
+        p.deinterlace.fps_divisor = None; // double rate
+        assert_eq!(p.rate_before_stabilize(), (2, 1));
+        p.deinterlace.fps_divisor = Some(2);
+        assert_eq!(p.rate_before_stabilize(), (1, 1));
+        p.deinterlace.method = DeinterlaceMethod::Ivtc;
+        p.deinterlace.ivtc_cycle = Some(5);
+        assert_eq!(p.rate_before_stabilize(), (4, 5));
+    }
+
     #[test]
     fn test_total_radius_floored() {
         // Even an all-identity pipeline gets the minimum preview window.
diff --git a/worker/src/models/stabilize_parameters.rs b/worker/src/models/stabilize_parameters.rs
index a69b561..5222b92 100644
--- a/worker/src/models/stabilize_parameters.rs
+++ b/worker/src/models/stabilize_parameters.rs
@@ -1,17 +1,70 @@
-//! Image stabilisation parameters.
+//! Image stabilisation parameters: gate weave / shake, and vertical pitch
+//! ("frame height breathing", issue #150).
 //!
-//! havsfunc's `Stab` measures global motion with MVTools' Depan family and
-//! cancels it, so a shaky capture holds still while intended camera movement
-//! survives. Aimed at telecine weave, jittery film scans and handheld camcorder
-//! footage.
+//! Two independent corrections, applied in this order:
 //!
-//! It does not change the frame count, which is why it is an ordinary pass and
-//! not one of the frame-rate-changing filters that would touch `FrameMap`.
+//! 1. **Weave** — havsfunc's `Stab` measures global motion with MVTools'
+//!    Depan family and cancels it, so a shaky capture holds still while
+//!    intended camera movement survives. Aimed at telecine weave, jittery film
+//!    scans and handheld camcorder footage. On by default when the pass is on.
+//! 2. **Pitch** — pull-through film scanners let the film slip in the gate, so
+//!    the picture is stretched or squashed vertically by a fraction of a
+//!    percent from frame to frame, which a translation stabiliser cannot
+//!    remove. Each frame is resampled vertically about its centre by a factor
+//!    measured from the video (`auto`) or read from a per-video file (`file`).
+//!    Off by default, so a pipeline saved before pitch correction existed
+//!    produces exactly the script it always did.
 //!
-//! No bit-depth limit — verified against the bundle at 8/10/12/16-bit and 4:2:2.
+//! The pitch logic lives in `templates/stabilize.py`; see its module docstring
+//! for the algorithms and the factor convention.
+//!
+//! The pass does not change the frame count, which is why it is an ordinary
+//! pass and not one of the frame-rate-changing filters that would touch
+//! `FrameMap`. It does read neighbouring frames, which [`StabilizeParameters::radius`]
+//! declares so a windowed preview decodes enough context.
+//!
+//! No bit-depth limit — `Stab` verified against the bundle at 8/10/12/16-bit and
+//! 4:2:2; the pitch resample is plain zimg.
 
+use anyhow::{bail, Result};
 use serde::{Deserialize, Serialize};
 
+/// How the per-frame vertical pitch factor is obtained.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
+#[serde(rename_all = "camelCase")]
+pub enum PitchMode {
+    /// No pitch correction (the default: weave only, as before issue #150).
+    #[default]
+    Off,
+    /// Measured from the video itself (relative to the surrounding frames).
+    Auto,
+    /// Read from a per-video factor file (`VideoJob::pitch_factors_path`).
+    File,
+}
+
+impl PitchMode {
+    /// The value the template passes to `stabilize.correct_pitch(mode=…)`.
+    pub fn script_value(&self) -> &'static str {
+        match self {
+            PitchMode::Off => "off",
+            PitchMode::Auto => "auto",
+            PitchMode::File => "file",
+        }
+    }
+}
+
+/// What fills the rows a pitch correction moves in from outside the frame.
+/// (The weave correction's edges are `mirror`'s business.)
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
+#[serde(rename_all = "camelCase")]
+pub enum EdgeFill {
+    /// Repeat the nearest picture rows (invisible on most footage).
+    #[default]
+    Extend,
+    /// Black, computed from the clip's format (so it is black at any depth).
+    Black,
+}
+
 /// Parameters for the stabilisation pass.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
@@ -20,6 +73,11 @@ pub struct StabilizeParameters {
     #[serde(default)]
     pub enabled: bool,
 
+    /// Remove weave / shake with havsfunc `Stab`. Defaults on, so a pipeline
+    /// saved before this switch existed keeps doing what it did.
+    #[serde(default = "default_weave")]
+    pub weave: bool,
+
     /// Maximum horizontal correction in pixels.
     #[serde(default = "default_dxmax")]
     pub dxmax: i32,
@@ -33,22 +91,61 @@ pub struct StabilizeParameters {
     /// crop afterwards.
     #[serde(default)]
     pub mirror: i32,
+
+    /// Vertical pitch correction source.
+    #[serde(default)]
+    pub pitch_mode: PitchMode,
+
+    /// Largest pitch correction, in percent of the frame height. Also clamps
+    /// factors read from a file, so one bad value can't distort a frame.
+    #[serde(default = "default_max_pitch_deviation")]
+    pub max_pitch_deviation: f64,
+
+    /// Auto pitch: frames each side a frame is compared with. Larger follows
+    /// slow intentional zooms less closely but averages out more jitter.
+    #[serde(default = "default_smoothing_radius")]
+    pub smoothing_radius: i32,
+
+    /// File pitch: the file holds the stretch to *apply* rather than the
+    /// measured height ratio.
+    #[serde(default)]
+    pub invert_factors: bool,
+
+    /// What fills rows exposed by the pitch correction.
+    #[serde(default)]
+    pub pitch_edge_fill: EdgeFill,
 }
 
+fn default_weave() -> bool { true }
 fn default_dxmax() -> i32 { 4 }
 fn default_dymax() -> i32 { 4 }
+fn default_max_pitch_deviation() -> f64 { 1.0 }
+fn default_smoothing_radius() -> i32 { 10 }
 
 impl Default for StabilizeParameters {
     fn default() -> Self {
         Self {
             enabled: false,
+            weave: default_weave(),
             dxmax: default_dxmax(),
             dymax: default_dymax(),
             mirror: 0,
+            pitch_mode: PitchMode::default(),
+            max_pitch_deviation: default_max_pitch_deviation(),
+            smoothing_radius: default_smoothing_radius(),
+            invert_factors: false,
+            pitch_edge_fill: EdgeFill::default(),
         }
     }
 }
 
+/// Frames each side `Stab` reads. Its average is ±7, but the scene-change
+/// detection inside it looks one frame further out and DepanEstimate reads the
+/// next interleaved pair, so the reach measured under vspipe is n-8..n+9
+/// (issue #150 review). Too small a value here makes a windowed preview — and
+/// `pipe_source`'s cache — silently hand back the wrong frame.
+const WEAVE_RADIUS: u32 = 9;
+
 impl StabilizeParameters {
     /// Edge-fill mode, clamped to the 0-3 DePanStabilise implements.
     pub fn effective_mirror(&self) -> i32 {
@@ -66,6 +163,114 @@ impl StabilizeParameters {
     pub fn effective_dymax(&self) -> i32 {
         self.dymax.max(0)
     }
+
+    /// Whether the weave correction runs.
+    pub fn weave_active(&self) -> bool {
+        self.enabled && self.weave
+    }
+
+    /// Whether the pitch correction runs.
+    pub fn pitch_active(&self) -> bool {
+        self.enabled && self.pitch_mode != PitchMode::Off
+    }
+
+    /// Whether the pass does anything at all.
+    pub fn is_active(&self) -> bool {
+        self.weave_active() || self.pitch_active()
+    }
+
+    /// Auto pitch smoothing radius as the script uses it (1-50).
+    pub fn effective_smoothing_radius(&self) -> u32 {
+        self.smoothing_radius.clamp(1, 50) as u32
+    }
+
+    /// Maximum pitch deviation in percent, clamped to something sane.
+    pub fn effective_max_deviation(&self) -> f64 {
+        if self.max_pitch_deviation.is_finite() {
+            self.max_pitch_deviation.clamp(0.05, 5.0)
+        } else {
+            default_max_pitch_deviation()
+        }
+    }
+
+    /// Temporal neighbours (each side) the pass reads for one output frame.
+    pub fn radius(&self) -> u32 {
+        let weave = if self.weave_active() { WEAVE_RADIUS } else { 0 };
+        let pitch = if self.pitch_active() && self.pitch_mode == PitchMode::Auto {
+            // Pairs n-R..n+R-1, each reading one frame ahead.
+            self.effective_smoothing_radius() + 1
+        } else {
+            0
+        };
+        weave + pitch
+    }
+}
+
+/// Parse a pitch factor file into one factor per source frame.
+///
+/// Accepted, per line:
+/// - blank lines and `#` comments (also trailing `# …`)
+/// - a bare factor: `1.0012` — the line order is the frame order
+/// - `frame,factor`, `frame factor` or `frame<TAB>factor` — explicit frame
+///   numbers; frames not mentioned get 1.0 (no correction)
+///
+/// Every factor must be a finite number > 0; anything else is an error naming
+/// the line, because a silently skipped line shifts every later frame.
+pub fn parse_pitch_factors(text: &str) -> Result<Vec<f64>> {
+    let mut sequential: Vec<f64> = Vec::new();
+    let mut indexed: Vec<(usize, f64)> = Vec::new();
+
+    for (i, raw) in text.lines().enumerate() {
+        let line_no = i + 1;
+        let line = raw.split('#').next().unwrap_or("").trim().trim_start_matches('\u{feff}');
+        if line.is_empty() {
+            continue;
+        }
+        let fields: Vec<&str> = line
+            .split(|c: char| c == ',' || c == ';' || c.is_whitespace())
+            .filter(|s| !s.is_empty())
+            .collect();
+
+        let parse_factor = |s: &str| -> Result<f64> {
+            match s.parse::<f64>() {
+                Ok(v) if v.is_finite() && v > 0.0 => Ok(v),
+                _ => bail!("Pitch factor file, line {}: '{}' is not a positive number", line_no, s),
+            }
+        };
+
+        match fields.as_slice() {
+            [factor] => sequential.push(parse_factor(factor)?),
+            [frame, factor] => {
+                let frame: usize = frame.parse().map_err(|_| {
+                    anyhow::anyhow!("Pitch factor file, line {}: '{}' is not a frame number", line_no, frame)
+                })?;
+                indexed.push((frame, parse_factor(factor)?));
+            }
+            _ => bail!(
+                "Pitch factor file, line {}: expected a factor or 'frame,factor', found '{}'",
+                line_no, line
+            ),
+        }
+    }
+
+    match (sequential.is_empty(), indexed.is_empty()) {
+        (true, true) => bail!("Pitch factor file contains no factors"),
+        (false, false) => bail!(
+            "Pitch factor file mixes bare factors and 'frame,factor' lines; use one form throughout"
+        ),
+        (false, true) => Ok(sequential),
+        (true, false) => {
+            let len = indexed.iter().map(|(f, _)| f + 1).max().unwrap_or(0);
+            if len > 10_000_000 {
+                bail!("Pitch factor file: frame number {} is implausibly large", len - 1);
+            }
+            let mut out = vec![1.0; len];
+            for (frame, factor) in indexed {
+                out[frame] = factor;
+            }
+            Ok(out)
+        }
+    }
 }
 
 #[cfg(test)]
@@ -76,9 +281,13 @@ mod tests {
     fn test_defaults() {
         let p = StabilizeParameters::default();
         assert!(!p.enabled);
+        assert!(p.weave);
         assert_eq!(p.dxmax, 4);
         assert_eq!(p.dymax, 4);
         assert_eq!(p.mirror, 0);
+        assert_eq!(p.pitch_mode, PitchMode::Off);
+        assert_eq!(p.pitch_edge_fill, EdgeFill::Extend);
+        assert_eq!(p.radius(), 0, "disabled pass reads no neighbours");
     }
 
     #[test]
@@ -120,4 +329,74 @@ mod tests {
         assert!(json.contains("\"enabled\":false"));
         assert!(json.contains("\"dxmax\":4"));
     }
+
+    #[test]
+    fn test_radius_follows_the_enabled_parts() {
+        let mut p = StabilizeParameters { enabled: true, ..Default::default() };
+        // Weave only (the default): Stab's measured reach.
+        assert_eq!(p.radius(), 9);
+        p.pitch_mode = PitchMode::Auto;
+        assert_eq!(p.radius(), 9 + 11);
+        p.pitch_mode = PitchMode::File;
+        assert_eq!(p.radius(), 9);
+        p.weave = false;
+        assert_eq!(p.radius(), 0);
+        assert!(p.is_active());
+        p.pitch_mode = PitchMode::Off;
+        assert!(!p.is_active());
+    }
+
+    #[test]
+    fn test_pitch_serde_names_are_the_wire_format() {
+        let p = StabilizeParameters {
+            enabled: true,
+            pitch_mode: PitchMode::File,
+            pitch_edge_fill: EdgeFill::Black,
+            ..Default::default()
+        };
+        let json = serde_json::to_string(&p).unwrap();
+        for key in ["\"pitchMode\":\"file\"", "\"pitchEdgeFill\":\"black\"", "\"weave\":true",
+                    "\"maxPitchDeviation\"", "\"smoothingRadius\"", "\"invertFactors\""] {
+            assert!(json.contains(key), "{} missing from {}", key, json);
+        }
+    }
+
+    #[test]
+    fn test_old_pipelines_keep_weave_only() {
+        // A pipeline saved before pitch correction existed: weave on, pitch off.
+        let parsed: StabilizeParameters =
+            serde_json::from_str("{\"enabled\":true,\"dxmax\":6,\"dymax\":2,\"mirror\":3}").unwrap();
+        assert!(parsed.weave);
+        assert_eq!(parsed.pitch_mode, PitchMode::Off);
+        assert_eq!((parsed.dxmax, parsed.dymax, parsed.mirror), (6, 2, 3));
+        assert_eq!(parsed.smoothing_radius, 10);
+    }
+
+    #[test]
+    fn test_parses_bare_factors_with_comments_and_blank_lines() {
+        let text = "# pitch log\n1.0012\n\n0.9990  # gate slip\r\n1\n";
+        assert_eq!(parse_pitch_factors(text).unwrap(), vec![1.0012, 0.9990, 1.0]);
+    }
+
+    #[test]
+    fn test_parses_indexed_factors_and_fills_gaps() {
+        let text = "0,1.001\n2 0.998\n3\t1.002\n";
+        assert_eq!(parse_pitch_factors(text).unwrap(), vec![1.001, 1.0, 0.998, 1.002]);
+    }
+
+    #[test]
+    fn test_rejects_bad_values_with_the_line_number() {
+        for (text, line) in [("1.0\nabc\n", "line 2"), ("1.0\n1.0\nnan\n", "line 3"),
+                             ("-1.0\n", "line 1"), ("0\n", "line 1"), ("1 2 3\n", "line 1"),
+                             ("x,1.0\n", "line 1")] {
+            let err = parse_pitch_factors(text).unwrap_err().to_string();
+            assert!(err.contains(line), "{:?} -> {}", text, err);
+        }
+    }
+
+    #[test]
+    fn test_rejects_empty_and_mixed_files() {
+        assert!(parse_pitch_factors("# nothing\n\n").is_err());
+        assert!(parse_pitch_factors("1.0\n3,1.0\n").is_err());
+    }
 }
diff --git a/worker/src/models/video_job.rs b/worker/src/models/video_job.rs
index 1a427c9..e32264c 100644
--- a/worker/src/models/video_job.rs
+++ b/worker/src/models/video_job.rs
@@ -90,6 +90,13 @@ pub struct VideoJob {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub burn_in_subtitle_path: Option<String>,
 
+    /// Per-video pitch factor file for the Stabilize pass in `file` mode
+    /// (issue #150). Lives on the job, not in the pipeline, because pipelines
+    /// are saved into presets that apply to every video in the queue, and a
+    /// factor log belongs to exactly one film.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub pitch_factors_path: Option<String>,
+
 }
 
 impl VideoJob {
diff --git a/worker/src/pipeline_executor.rs b/worker/src/pipeline_executor.rs
index 42cd146..9697124 100644
--- a/worker/src/pipeline_executor.rs
+++ b/worker/src/pipeline_executor.rs
@@ -163,6 +163,28 @@ fn preview_window(target: i32, radius: i32) -> (i32, i32, i32) {
 }
 
 use crate::audio_restoration::{self, RestoredTrack};
+/// The `PREVIEW_INFO:` line a preview reports on stderr after rendering: the
+/// frame it rendered, which of that frame's outputs, and — when not square —
+/// the display aspect the encode will declare for it. The PNG carries no
+/// aspect, so without that last token the app had to guess, and it guessed the
+/// *source's* shape: a 720x576 4:3 source upscaled and padded to 1920x1080 was
+/// drawn squashed into 4:3 (issue #149).
+fn preview_info_line(job: &VideoJob, target: i32, out: &crate::models::PreviewOutput) -> String {
+    let mut line = format!(
+        "PREVIEW_INFO:frame={} sub_frame={} sub_frames={} generated={}",
+        target, out.sub_frame, out.sub_frames, out.generated as u8
+    );
+    if let Some(token) = job
+        .effective_pipeline()
+        .output_aspect(job.input_sar.as_deref())
+        .preview_token()
+    {
+        line.push(' ');
+        line.push_str(&token);
+    }
+    line
+}
+
 use crate::comment_metadata::{self, CommentFile};
 use crate::gpu_plugin::GpuPlugin;
 use crate::hdr_metadata::HdrMetadata;
@@ -972,10 +994,8 @@ impl PipelineExecutor {
         // a resize ran, which used to drop it and leave an anamorphic source
         // squashed (#50).
         let pipeline = job.effective_pipeline();
-        // A quarter turn exchanges pixel width and height, so the SAR that
-        // describes the source no longer describes the rotated frame. Adjust it
-        // before declaring it, or a rotated anamorphic source is stretched by
-        // the square of its own aspect.
+        // `output_aspect` adjusts the SAR for a quarter turn; the preview
+        // reports the same decision, so the two cannot disagree (#149).
         //
         // Filters accumulate into one chain. ffmpeg takes the LAST -vf and
         // silently drops any earlier one, so appending a second would throw
@@ -983,8 +1003,7 @@ impl PipelineExecutor {
         // would have broken issue #50's third leg.
         let mut vf: Vec<String> = Vec::new();
 
-        let rotated_sar = pipeline.geometry.adjusted_sar(input_sar);
-        match pipeline.crop_resize.aspect_declaration(rotated_sar.as_deref()) {
+        match pipeline.output_aspect(input_sar) {
             AspectDeclaration::Sar(sar) => {
                 // '/' as the ratio separator — ':' is ffmpeg's filter option separator.
                 vf.push(format!("setsar={}", sar.replace(':', "/")));
@@ -1250,8 +1269,9 @@ impl PipelineExecutor {
     /// then emits the exact output frame that `frame_index` maps to (accounting
     /// for any frame-rate change such as QTGMC double-rate). The requested frame
     /// is echoed back on stderr as `PREVIEW_INFO:frame=N sub_frame=K
-    /// sub_frames=C generated=0|1` so the caller can
-    /// label the result truthfully.
+    /// sub_frames=C generated=0|1 [sar=N/D | dar=N/D]` so the caller can
+    /// label the result truthfully and draw it at the encode's display aspect
+    /// (see [`preview_info_line`]).
     pub fn generate_preview(&self, job: &VideoJob, frame_index: i32, sub_frame: u32) -> Result<()> {
         use std::io::Write;
 
@@ -1354,6 +1374,7 @@ impl PipelineExecutor {
             fps_den,
             output_index,
             rate_pad: out.rate_pad,
+            source_frame_offset: first,
         };
 
         let script_path = script_generator.generate_preview(job, &preview_params)?;
@@ -1509,10 +1530,7 @@ impl PipelineExecutor {
 
         // Echo the frame we actually rendered so the caller can label it (the
         // PNG itself is the only thing on stdout, so this goes to stderr).
-        eprintln!(
-            "PREVIEW_INFO:frame={} sub_frame={} sub_frames={} generated={}",
-            target, out.sub_frame, out.sub_frames, out.generated as u8
-        );
+        eprintln!("{}", preview_info_line(job, target, &out));
 
         // Write PNG to stdout
         std::io::stdout().write_all(&output.stdout)?;
@@ -1952,6 +1970,51 @@ mod tests {
         args
     }
 
+    fn preview_out() -> crate::models::PreviewOutput {
+        crate::models::PreviewOutput {
+            local_index: 3,
+            rate_pad: 0,
+            sub_frame: 0,
+            sub_frames: 2,
+            generated: false,
+        }
+    }
+
+    /// The preview reports the aspect the encode will declare, so the app can
+    /// draw the processed frame at its own shape (issue #149).
+    #[test]
+    fn preview_info_reports_the_output_aspect() {
+        let mut job = create_test_job("/tmp/out.mkv");
+        job.input_sar = Some("16:15".to_string());
+        assert_eq!(
+            preview_info_line(&job, 7, &preview_out()),
+            "PREVIEW_INFO:frame=7 sub_frame=0 sub_frames=2 generated=0 sar=16/15"
+        );
+
+        // Squaring the pixels resamples the grid: nothing to declare.
+        let mut pipeline = job.effective_pipeline();
+        pipeline.crop_resize.enabled = true;
+        pipeline.crop_resize.pixel_aspect = crate::models::PixelAspectMode::Square;
+        job.processing_pipeline = Some(pipeline.clone());
+        assert_eq!(
+            preview_info_line(&job, 7, &preview_out()),
+            "PREVIEW_INFO:frame=7 sub_frame=0 sub_frames=2 generated=0"
+        );
+
+        // A forced display aspect is reported as a DAR.
+        pipeline.crop_resize.pixel_aspect = crate::models::PixelAspectMode::Preserve;
+        pipeline.crop_resize.display_aspect = Some("16:9".to_string());
+        job.processing_pipeline = Some(pipeline);
+        assert!(preview_info_line(&job, 7, &preview_out()).ends_with(" dar=16/9"));
+
+        // Square-pixel source, nothing changed: the line is what it always was.
+        let job = create_test_job("/tmp/out.mkv");
+        assert_eq!(
+            preview_info_line(&job, 7, &preview_out()),
+            "PREVIEW_INFO:frame=7 sub_frame=0 sub_frames=2 generated=0"
+        );
+    }
+
     fn create_test_job(output_path: &str) -> VideoJob {
         VideoJob {
             id: Uuid::new_v4(),
@@ -1976,6 +2039,7 @@ mod tests {
             input_color_transfer: None,
             input_color_range: None,
             burn_in_subtitle_path: None,
+            pitch_factors_path: None,
         }
     }
 
diff --git a/worker/src/script_generator.rs b/worker/src/script_generator.rs
index c86fa34..703423b 100644
--- a/worker/src/script_generator.rs
+++ b/worker/src/script_generator.rs
@@ -16,7 +16,7 @@ use crate::models::{
     ChromaDenoiseMethod, FrameRateMethod, SpotLessMethod, DeflickerMethod, EdgeRepairParameters,
     parse_ratio,
     DehaloMethod, DeblockMethod, SharpenMethod, DeinterlaceMethod,
-    FieldOrder,
+    FieldOrder, EdgeFill, PitchMode, parse_pitch_factors,
 };
 
 /// CPU dispatch level to hand `ctmf.CTMF`'s `opt` argument.
@@ -113,6 +113,27 @@ pub struct PreviewParams {
     /// Copies of the first frame to put in front of the Frame Rate pass, so
     /// its retime runs in the encode's phase (`PreviewOutput::rate_pad`).
     pub rate_pad: u64,
+    /// Source frame number of the first decoded frame (the window start).
+    /// Anything that looks frames up by source number — the stabiliser's
+    /// pitch factor file — must add it, or every preview frame gets the
+    /// factor of the wrong frame.
+    pub source_frame_offset: i32,
+}
+
+/// Per-script inputs to the Stabilize pass that aren't pipeline settings.
+struct StabilizeContext {
+    /// Source frame number of clip frame 0 (trim start / preview window start).
+    frame_offset: i64,
+    /// The worker's validated, normalised copy of the job's factor file.
+    factors_path: Option<PathBuf>,
+}
+
+/// Decoded frames `pipe_source` must keep for out-of-order reads: the whole
+/// temporal window either side, plus vspipe's read-ahead. Too few and an
+/// evicted frame silently comes back as the last frame read. Never below the
+/// 40 it was fixed at before it was sized from the pipeline.
+pub fn pipe_cache_frames(pipeline: &ProcessingPipeline) -> u32 {
+    (2 * pipeline.total_radius() + 24).max(40)
 }
 
 impl ScriptGenerator {
@@ -310,7 +331,10 @@ impl ScriptGenerator {
         let pipeline = job.effective_pipeline();
         self.ensure_methods_ready(&pipeline)?;
 
-        let script = self.substitute_parameters(&self.template, job, &pipeline, &job.input_path);
+        // A trimmed encode seeks the decoder, so clip frame 0 is start_frame.
+        let offset = job.start_frame.unwrap_or(0).max(0) as i64;
+        let stab = Self::stabilize_context(job, &pipeline, offset, "encode")?;
+        let script = self.substitute_parameters(&self.template, job, &pipeline, &stab);
 
         // Write to temp file
         let temp_dir = env::temp_dir();
@@ -327,6 +351,8 @@ impl ScriptGenerator {
     pub fn generate_preview(&self, job: &VideoJob, preview_params: &PreviewParams) -> Result<PathBuf> {
         let pipeline = job.effective_pipeline();
         self.ensure_methods_ready(&pipeline)?;
+        let stab = Self::stabilize_context(
+            job, &pipeline, preview_params.source_frame_offset.max(0) as i64, "preview")?;
 
         // Start with preview template and substitute preview-specific params
         let mut script = self.preview_template.clone();
@@ -348,6 +374,7 @@ impl ScriptGenerator {
         script = script.replace("{{FPS_DEN}}", &preview_params.fps_den.to_string());
         script = script.replace("{{PREVIEW_OUTPUT_INDEX}}", &preview_params.output_index.to_string());
         script = script.replace("{{PREVIEW_RATE_PAD}}", &preview_params.rate_pad.to_string());
+        script = script.replace("{{PIPE_CACHE_FRAMES}}", &pipe_cache_frames(&pipeline).to_string());
         // Field-based: same derivation as the encode path, so the preview can't
         // deinterlace at a different field order than the final render.
         if let Some(fb) = Self::field_based_for(job, &pipeline) {
@@ -359,7 +386,7 @@ impl ScriptGenerator {
         }
 
         // Now apply the same pipeline substitutions
-        script = self.substitute_parameters_on(&script, job, &pipeline);
+        script = self.substitute_parameters_on(&script, job, &pipeline, &stab);
 
         // Write to temp file
         let temp_dir = env::temp_dir();
@@ -465,8 +492,47 @@ impl ScriptGenerator {
         Self::field_based_for(job, pipeline).map(|fb| fb == 2)
     }
 
+    /// Validate and normalise the job's pitch factor file when the Stabilize
+    /// pass needs it, writing a clean one-factor-per-line copy to the temp
+    /// directory for the script to read.
+    ///
+    /// File mode without a usable file is an error rather than a silent
+    /// no-op: the user asked for that correction, and an encode without it is
+    /// indistinguishable from one with it until someone looks closely.
+    fn stabilize_context(
+        job: &VideoJob,
+        pipeline: &ProcessingPipeline,
+        frame_offset: i64,
+        purpose: &str,
+    ) -> Result<StabilizeContext> {
+        let stab = &pipeline.stabilize;
+        if !(stab.pitch_active() && stab.pitch_mode == PitchMode::File) {
+            return Ok(StabilizeContext { frame_offset, factors_path: None });
+        }
+        let source = job
+            .pitch_factors_path
+            .as_deref()
+            .filter(|p| !p.trim().is_empty())
+            .ok_or_else(|| anyhow::anyhow!(
+                "Stabilize: pitch correction is set to 'From file', but no pitch factor file is selected for this video"
+            ))?;
+        let text = fs::read_to_string(source)
+            .with_context(|| format!("Stabilize: cannot read pitch factor file {}", source))?;
+        let factors = parse_pitch_factors(&text)
+            .with_context(|| format!("Stabilize: invalid pitch factor file {}", source))?;
+
+        let mut normalised = String::with_capacity(factors.len() * 12);
+        for f in &factors {
+            normalised.push_str(&format!("{:.8}\n", f));
+        }
+        let path = env::temp_dir().join(format!("{}_{}_pitch_factors.txt", job.id, purpose));
+        fs::write(&path, normalised)
+            .with_context(|| format!("Failed to write pitch factors to {:?}", path))?;
+        Ok(StabilizeContext { frame_offset, factors_path: Some(path) })
+    }
+
     /// Substitute parameters in a script string.
-    fn substitute_parameters(&self, template: &str, job: &VideoJob, pipeline: &ProcessingPipeline, _input_path: &str) -> String {
+    fn substitute_parameters(&self, template: &str, job: &VideoJob, pipeline: &ProcessingPipeline, stab: &StabilizeContext) -> String {
         let mut script = template.to_string();
 
         // Pipe source parameters — FFmpeg decodes, pipes raw frames to VapourSynth via stdin
@@ -491,6 +557,7 @@ impl ScriptGenerator {
             None => job.total_frames.unwrap_or(1),
         };
         script = script.replace("{{TOTAL_FRAMES}}", &total_frames.to_string());
+        script = script.replace("{{PIPE_CACHE_FRAMES}}", &pipe_cache_frames(pipeline).to_string());
 
         // FPS as rational number
         let (fps_num, fps_den) = self.frame_rate_to_rational(job.input_frame_rate.unwrap_or(29.97));
@@ -514,7 +581,7 @@ impl ScriptGenerator {
             script = remove_block("{{#SET_FIELD_BASED}}", "{{/SET_FIELD_BASED}}", script);
         }
 
-        self.substitute_parameters_on(&script, job, pipeline)
+        self.substitute_parameters_on(&script, job, pipeline, stab)
     }
 
     /// Get the directory where pipe_source.py lives (same search as templates).
@@ -555,7 +622,7 @@ impl ScriptGenerator {
     }
 
     /// Substitute pipeline parameters on an already-prepared script.
-    fn substitute_parameters_on(&self, script: &str, job: &VideoJob, pipeline: &ProcessingPipeline) -> String {
+    fn substitute_parameters_on(&self, script: &str, job: &VideoJob, pipeline: &ProcessingPipeline, stab_ctx: &StabilizeContext) -> String {
         let mut script = self.substitute_addons(script.to_string(), pipeline);
         let params = &pipeline.deinterlace;
 
@@ -1767,12 +1834,59 @@ impl ScriptGenerator {
         // STABILIZE PASS
         // ====================================================================
         let stabilize = &pipeline.stabilize;
-        if stabilize.enabled {
+        if stabilize.is_active() {
             script = script.replace("{{#STABILIZE}}", "");
             script = script.replace("{{/STABILIZE}}", "");
-            script = script.replace("{{STAB_DXMAX}}", &stabilize.effective_dxmax().to_string());
-            script = script.replace("{{STAB_DYMAX}}", &stabilize.effective_dymax().to_string());
-            script = script.replace("{{STAB_MIRROR}}", &stabilize.effective_mirror().to_string());
+
+            // Weave (havsfunc Stab). Its inner tags go with their whole lines,
+            // so a weave-only pass — every pipeline saved before pitch
+            // correction existed — gets the block it always got.
+            if stabilize.weave_active() {
+                script = keep_block_lines("STAB_WEAVE", script);
+                script = script.replace("{{STAB_DXMAX}}", &stabilize.effective_dxmax().to_string());
+                script = script.replace("{{STAB_DYMAX}}", &stabilize.effective_dymax().to_string());
+                script = script.replace("{{STAB_MIRROR}}", &stabilize.effective_mirror().to_string());
+            } else {
+                script = remove_block("{{#STAB_WEAVE}}", "{{/STAB_WEAVE}}", script);
+            }
+
+            // Pitch (issue #150). File mode only reaches the script with a
+            // validated file (see stabilize_context, which errors otherwise).
+            let pitch_mode = match (stabilize.pitch_mode, &stab_ctx.factors_path) {
+                (PitchMode::File, None) => PitchMode::Off,
+                (m, _) if stabilize.pitch_active() => m,
+                _ => PitchMode::Off,
+            };
+            if pitch_mode != PitchMode::Off {
+                script = keep_block_lines("STAB_PITCH", script);
+                // Not deinterlaced but marked field-based: a vertical resample
+                // would mix the two fields, so treat the clip as progressive
+                // (film scans are) from here on.
+                if Self::still_interlaced_tff(job, pipeline).is_some() {
+                    script = keep_block_lines("STAB_CLEAR_FIELD_BASED", script);
+                } else {
+                    script = remove_block("{{#STAB_CLEAR_FIELD_BASED}}", "{{/STAB_CLEAR_FIELD_BASED}}", script);
+                }
+                let py_bool = |b: bool| if b { "True" } else { "False" };
+                let factors = stab_ctx.factors_path.as_ref().map(|p| p.to_string_lossy().to_string());
+                if factors.is_some() {
+                    script = keep_block_lines("STAB_FACTORS_PATH", script);
+                    script = script.replace("{{STAB_FACTORS_PATH}}", factors.as_deref().unwrap_or(""));
+                } else {
+                    script = remove_block("{{#STAB_FACTORS_PATH}}", "{{/STAB_FACTORS_PATH}}", script);
+                }
+                let (rate_num, rate_den) = pipeline.rate_before_stabilize();
+                script = script.replace("{{STAB_PITCH_MODE}}", pitch_mode.script_value());
+                script = script.replace("{{STAB_FRAME_OFFSET}}", &stab_ctx.frame_offset.to_string());
+                script = script.replace("{{STAB_RATE_NUM}}", &rate_num.to_string());
+                script = script.replace("{{STAB_RATE_DEN}}", &rate_den.to_string());
+                script = script.replace("{{STAB_INVERT}}", py_bool(stabilize.invert_factors));
+                script = script.replace("{{STAB_MAX_DEVIATION}}", &format_double(stabilize.effective_max_deviation()));
+                script = script.replace("{{STAB_RADIUS}}", &stabilize.effective_smoothing_radius().to_string());
+                script = script.replace("{{STAB_BLACK}}", py_bool(stabilize.pitch_edge_fill == EdgeFill::Black));
+            } else {
+                script = remove_block("{{#STAB_PITCH}}", "{{/STAB_PITCH}}", script);
+            }
         } else {
             script = remove_block("{{#STABILIZE}}", "{{/STABILIZE}}", script);
         }
@@ -2730,6 +2844,19 @@ pub(crate) fn ai_runtime_block(script: String, dir: Option<&Path>) -> String {
     }
 }
 
+/// Keep a block's contents, removing its `{{#NAME}}` / `{{/NAME}}` tags
+/// together with the newline after each, so a tag on a line of its own leaves
+/// no blank line behind. (Plain `replace(tag, "")` leaves one.)
+fn keep_block_lines(name: &str, script: String) -> String {
+    let start_tag = format!("{{{{#{}}}}}", name);
+    let end_tag = format!("{{{{/{}}}}}", name);
+    script
+        .replace(&format!("{}\n", start_tag), "")
+        .replace(&format!("{}\n", end_tag), "")
+        .replace(&start_tag, "")
+        .replace(&end_tag, "")
+}
+
 /// Remove a block from start tag to end tag (including the line).
 fn remove_block(start_tag: &str, end_tag: &str, mut script: String) -> String {
     while let Some(start_pos) = script.find(start_tag) {
diff --git a/worker/templates/pipe_source.py b/worker/templates/pipe_source.py
index d688f2d..42b9504 100644
--- a/worker/templates/pipe_source.py
+++ b/worker/templates/pipe_source.py
@@ -61,7 +61,7 @@
 class _PipeReader:
     """Reads raw video frames from stdin with a small cache for temporal filters."""
 
-    def __init__(self, width, height, vs_format):
+    def __init__(self, width, height, vs_format, cache_frames=40):
         self.width = width
         self.height = height
 
@@ -84,7 +84,7 @@ def __init__(self, width, height, vs_format):
 
         self._pipe = sys.stdin.buffer
         self._cache = OrderedDict()
-        self._cache_limit = 40  # enough for QTGMC TR2 + margin
+        self._cache_limit = max(40, int(cache_frames))  # >= QTGMC TR2 + margin
         self._next = 0
         self._lock = threading.Lock()
         self._eof = False
@@ -165,7 +165,8 @@ def fill_frame(self, n, f):
         return fout
 
 
-def create_pipe_clip(width, height, num_frames, fps_num, fps_den, pix_fmt):
+def create_pipe_clip(width, height, num_frames, fps_num, fps_den, pix_fmt,
+                     cache_frames=40):
     """
     Create a VapourSynth clip that reads raw frames from stdin.
 
@@ -176,6 +177,10 @@ def create_pipe_clip(width, height, num_frames, fps_num, fps_den, pix_fmt):
         fps_num: FPS numerator
         fps_den: FPS denominator
         pix_fmt: FFmpeg pixel format string (e.g. 'yuv420p')
+        cache_frames: Decoded frames kept for out-of-order reads. Must cover
+            the pipeline's temporal window plus vspipe's read-ahead: a frame
+            evicted before it is read again comes back as the *last* frame,
+            silently. The worker sizes it from the pipeline's total radius.
 
     Returns:
         vs.VideoNode backed by stdin pipe
@@ -185,7 +190,7 @@ def create_pipe_clip(width, height, num_frames, fps_num, fps_den, pix_fmt):
                          f"Supported: {', '.join(_FORMAT_MAP.keys())}")
 
     vs_format = _FORMAT_MAP[pix_fmt]
-    reader = _PipeReader(width, height, vs_format)
+    reader = _PipeReader(width, height, vs_format, cache_frames)
 
     blank = core.std.BlankClip(
         width=width, height=height,
diff --git a/worker/templates/pipeline_template.vpy b/worker/templates/pipeline_template.vpy
index a60f3ac..4e8965a 100644
--- a/worker/templates/pipeline_template.vpy
+++ b/worker/templates/pipeline_template.vpy
@@ -40,6 +40,7 @@ clip = create_pipe_clip(
     fps_num={{INPUT_FPS_NUM}},
     fps_den={{INPUT_FPS_DEN}},
     pix_fmt="{{INPUT_PIX_FMT}}",
+    cache_frames={{PIPE_CACHE_FRAMES}},
 )
 
 {{#VFR_TIMELINE}}
@@ -2107,6 +2108,7 @@ if clip.format.color_family == vs.YUV:
 # PASS: STABILIZE
 # ============================================================================
 {{#STABILIZE}}
+{{#STAB_WEAVE}}
 # Stab - global motion stabilisation via MVTools' Depan family. Measures the
 # frame-to-frame shift and subtracts it, so shake is cancelled while a
 # deliberate pan survives. Frame count is unchanged, which is why this is an
@@ -2121,6 +2123,39 @@ clip = haf.Stab(
     dymax={{STAB_DYMAX}},
     mirror={{STAB_MIRROR}},
 )
+{{/STAB_WEAVE}}
+{{#STAB_PITCH}}
+# Vertical pitch / frame-height breathing (issue #150): pull-through film
+# scanners let the film slip in the gate, stretching or squashing the picture
+# vertically by a fraction of a percent from frame to frame, which the weave
+# correction above cannot remove. Each frame is resampled about its centre at a
+# constant frame size. The logic lives in stabilize.py so the encode and the
+# preview can't drift apart.
+import sys as _stab_sys
+_stab_sys.path.insert(0, r"{{PIPE_SOURCE_DIR}}")
+from stabilize import correct_pitch as _stab_correct_pitch
+{{#STAB_CLEAR_FIELD_BASED}}
+# Not deinterlaced, but the source is flagged interlaced: a vertical resample
+# would mix the fields, so treat it as progressive (film scans are).
+clip = core.std.SetFieldBased(clip, 0)
+{{/STAB_CLEAR_FIELD_BASED}}
+clip = _stab_correct_pitch(
+    clip,
+    mode="{{STAB_PITCH_MODE}}",
+{{#STAB_FACTORS_PATH}}
+    factors_path=r"{{STAB_FACTORS_PATH}}",
+{{/STAB_FACTORS_PATH}}
+    # Frame n of this clip is source frame offset + n * rate_den // rate_num
+    # (preview window / trim start, and any deinterlace rate change).
+    frame_offset={{STAB_FRAME_OFFSET}},
+    rate_num={{STAB_RATE_NUM}},
+    rate_den={{STAB_RATE_DEN}},
+    invert={{STAB_INVERT}},
+    max_deviation_pct={{STAB_MAX_DEVIATION}},
+    radius={{STAB_RADIUS}},
+    black={{STAB_BLACK}},
+)
+{{/STAB_PITCH}}
 {{/STABILIZE}}
 
 # ============================================================================
diff --git a/worker/templates/preview_template.vpy b/worker/templates/preview_template.vpy
index e576469..621f8c8 100644
--- a/worker/templates/preview_template.vpy
+++ b/worker/templates/preview_template.vpy
@@ -35,6 +35,7 @@ clip = create_pipe_clip(
     width={{INPUT_WIDTH}}, height={{INPUT_HEIGHT}},
     num_frames={{TOTAL_FRAMES}}, fps_num={{FPS_NUM}},
     fps_den={{FPS_DEN}}, pix_fmt="{{INPUT_PIX_FMT}}",
+    cache_frames={{PIPE_CACHE_FRAMES}},
 )
 
 {{#VFR_TIMELINE}}
@@ -2042,6 +2043,7 @@ if clip.format.color_family == vs.YUV:
 # PASS: STABILIZE
 # ============================================================================
 {{#STABILIZE}}
+{{#STAB_WEAVE}}
 # Stab - global motion stabilisation via MVTools' Depan family. Measures the
 # frame-to-frame shift and subtracts it, so shake is cancelled while a
 # deliberate pan survives. Frame count is unchanged, which is why this is an
@@ -2056,6 +2058,39 @@ clip = haf.Stab(
     dymax={{STAB_DYMAX}},
     mirror={{STAB_MIRROR}},
 )
+{{/STAB_WEAVE}}
+{{#STAB_PITCH}}
+# Vertical pitch / frame-height breathing (issue #150): pull-through film
+# scanners let the film slip in the gate, stretching or squashing the picture
+# vertically by a fraction of a percent from frame to frame, which the weave
+# correction above cannot remove. Each frame is resampled about its centre at a
+# constant frame size. The logic lives in stabilize.py so the encode and the
+# preview can't drift apart.
+import sys as _stab_sys
+_stab_sys.path.insert(0, r"{{PIPE_SOURCE_DIR}}")
+from stabilize import correct_pitch as _stab_correct_pitch
+{{#STAB_CLEAR_FIELD_BASED}}
+# Not deinterlaced, but the source is flagged interlaced: a vertical resample
+# would mix the fields, so treat it as progressive (film scans are).
+clip = core.std.SetFieldBased(clip, 0)
+{{/STAB_CLEAR_FIELD_BASED}}
+clip = _stab_correct_pitch(
+    clip,
+    mode="{{STAB_PITCH_MODE}}",
+{{#STAB_FACTORS_PATH}}
+    factors_path=r"{{STAB_FACTORS_PATH}}",
+{{/STAB_FACTORS_PATH}}
+    # Frame n of this clip is source frame offset + n * rate_den // rate_num
+    # (preview window / trim start, and any deinterlace rate change).
+    frame_offset={{STAB_FRAME_OFFSET}},
+    rate_num={{STAB_RATE_NUM}},
+    rate_den={{STAB_RATE_DEN}},
+    invert={{STAB_INVERT}},
+    max_deviation_pct={{STAB_MAX_DEVIATION}},
+    radius={{STAB_RADIUS}},
+    black={{STAB_BLACK}},
+)
+{{/STAB_PITCH}}
 {{/STABILIZE}}
 
 # ============================================================================
diff --git a/worker/templates/stabilize.py b/worker/templates/stabilize.py
new file mode 100644
index 0000000..f7ad782
--- /dev/null
+++ b/worker/templates/stabilize.py
@@ -0,0 +1,380 @@
+"""
+Stabilize - vertical pitch correction for VapourBox's Stabilize pass (issue #150).
+
+The pass makes two independent corrections, in this order:
+
+1. Weave / shake: havsfunc ``Stab`` (``mv.DepanEstimate`` /
+   ``DepanCompensate`` against a temporal average), called directly from the
+   templates.
+
+2. Vertical pitch ("frame height breathing"), this module: pull-through film
+   scanners let the film slip in the gate, so from one frame to the next the
+   picture is stretched or squashed vertically by a fraction of a percent. A
+   translation stabiliser cannot remove that. Each frame is resampled
+   vertically about its centre by a per-frame factor, at sub-pixel precision
+   and at a constant frame size.
+
+   The factor comes either from a file (one value per source frame) or is
+   measured here (``auto``): the relative vertical scale and shift between
+   every pair of adjacent frames is measured, and each frame is corrected to
+   the mean of the ±radius frames around it. A symmetric mean leaves a steady
+   or linearly changing pitch alone, so slow intentional zooms and tilts are
+   kept and only the frame-to-frame jitter is removed. Each frame reads only
+   the measurements in its own window, so there is no sequential pre-pass and
+   a single-frame preview measures exactly what the encode does.
+
+Factor convention: a factor is the *measured* height of the picture relative to
+nominal. 1.004 means the frame came out 0.4% too tall, and it is corrected by
+compressing it by 1/1.004. ``invert=True`` accepts files written the other way
+round (the stretch to apply).
+
+Written for VapourBox.
+"""
+
+import math
+from collections import OrderedDict
+
+import vapoursynth as vs
+
+core = vs.core
+
+# Quantisation of per-frame corrections. Every distinct correction needs its
+# own resize node inside FrameEval, so values are rounded to a grid (0.01% of
+# height for the scale, 1/32 px for the offset) and the most recently used
+# nodes are kept. 0.01% is 0.1 px at 1080 lines — well below what can be seen.
+_SCALE_QUANTUM = 1e-4
+_SHIFT_QUANTUM = 1.0 / 32.0
+_NODE_CACHE_SIZE = 256
+
+# Mean absolute difference (0-1) between a frame pair's measurement strips,
+# after the best alignment, above which the pair is not trusted. The strip
+# averages ~100 columns into each sample, so grain barely registers; what's
+# left above this is real content change. Measured on small_clip.mp4: steady
+# pairs align to < 0.01, pairs with fast motion stay above 0.02.
+_UNRELIABLE_DIFF = 3.0 / 255.0
+
+
+def _black(fmt):
+    """Black for any format: limited-range black for YUV, 0 for RGB/Gray.
+
+    Computed from the format rather than written as 8-bit constants, so a
+    10-bit or float clip isn't filled with dark green.
+    """
+    if fmt.sample_type == vs.FLOAT:
+        return [0.0] * fmt.num_planes
+    shift = fmt.bits_per_sample - 8
+    if fmt.color_family == vs.YUV:
+        return [16 << shift, 128 << shift, 128 << shift]
+    if fmt.color_family == vs.GRAY:
+        return [16 << shift]
+    return [0] * fmt.num_planes
+
+
+def _to_working(clip, integer=False):
+    """Carry an RGB clip through 4:4:4 YUV (and float through 16-bit when
+    ``integer``), so the measurement works on luma.
+
+    Returns the converted clip plus the original format to restore, or None
+    when nothing changed.
+    """
+    fmt = clip.format
+    family = vs.YUV if fmt.color_family == vs.RGB else fmt.color_family
+    sample_type, bits = fmt.sample_type, fmt.bits_per_sample
+    if integer and sample_type == vs.FLOAT:
+        sample_type, bits = vs.INTEGER, 16
+    if family == fmt.color_family and sample_type == fmt.sample_type:
+        return clip, None
+    work = core.query_video_format(family, sample_type, bits,
+                                   fmt.subsampling_w, fmt.subsampling_h)
+    if fmt.color_family == vs.RGB:
+        return core.resize.Point(clip, format=work.id, matrix_s="709"), fmt
+    return core.resize.Point(clip, format=work.id), fmt
+
+
+def _from_working(clip, orig_fmt):
+    if orig_fmt is None:
+        return clip
+    if orig_fmt.color_family == vs.RGB:
+        return core.resize.Point(clip, format=orig_fmt.id, matrix_in_s="709")
+    return core.resize.Point(clip, format=orig_fmt.id)
+
+
+def correct_frame(clip, factor, shift=0.0, black=False):
+    """Undo a vertical stretch of ``factor`` and a downward shift of ``shift``
+    pixels, keeping the frame size.
+
+    Output row y samples input row ``c + factor*(y - c) + shift`` (c = centre),
+    i.e. ``src_height = factor*H`` and ``src_top = (1 - factor)*H/2 + shift``.
+    Rows that would come from outside the frame are edge-extended by zimg, or
+    blacked out when ``black`` is set.
+    """
+    h = clip.height
+    src_height = factor * h
+    src_top = (1.0 - factor) * h / 2.0 + shift
+    out = core.resize.Spline36(clip, width=clip.width, height=h,
+                               src_left=0, src_width=clip.width,
+                               src_top=src_top, src_height=src_height)
+    if not black:
+        return out
+
+    # Rows sampled from outside [0, h): top ones have y < (-src_top)/factor,
+    # bottom ones have y > (h - src_top)/factor. Round outwards and to the
+    # chroma subsampling so Crop/AddBorders stay legal.
+    mod = 1 << out.format.subsampling_h
+    top = max(0.0, -src_top / factor)
+    bottom = max(0.0, h - (h - src_top) / factor)
+    top = int(math.ceil(top / mod)) * mod
+    bottom = int(math.ceil(bottom / mod)) * mod
+    if top == 0 and bottom == 0:
+        return out
+    if top + bottom >= h:
+        return core.std.BlankClip(out, color=_black(out.format))
+    out = core.std.Crop(out, top=top, bottom=bottom)
+    return core.std.AddBorders(out, top=top, bottom=bottom, color=_black(out.format))
+
+
+def _apply_per_frame(clip, lookup, black, prop_src=None):
+    """FrameEval wrapper: ``lookup(n, f) -> (factor, shift)``.
+
+    Corrected nodes are cached per quantised correction (LRU, so a long reel
+    can't accumulate thousands of nodes). Every output frame carries
+    ``VapourBox_PitchFactor`` / ``VapourBox_PitchShift`` — what was applied —
+    for diagnostics and tests.
+    """
+    cache = OrderedDict()
+
+    def _select(n, f=None):
+        factor, shift = lookup(n, f)
+        key = (round((factor - 1.0) / _SCALE_QUANTUM), round(shift / _SHIFT_QUANTUM))
+        node = cache.get(key)
+        if node is not None:
+            cache.move_to_end(key)
+            return node
+        factor = 1.0 + key[0] * _SCALE_QUANTUM
+        shift = key[1] * _SHIFT_QUANTUM
+        node = clip if key == (0, 0) else correct_frame(clip, factor, shift, black)
+        node = core.std.SetFrameProps(node, VapourBox_PitchFactor=factor,
+                                      VapourBox_PitchShift=shift)
+        cache[key] = node
+        if len(cache) > _NODE_CACHE_SIZE:
+            cache.popitem(last=False)
+        return node
+
+    if prop_src is None:
+        return core.std.FrameEval(clip, lambda n: _select(n))
+    return core.std.FrameEval(clip, _select, prop_src=prop_src)
+
+
+def pitch_from_file(clip, factors_path, frame_offset=0, rate_num=1, rate_den=1,
+                    invert=False, max_deviation=0.01, black=False):
+    """Pitch correction from a file of per-source-frame factors.
+
+    The file is the worker's normalised copy: one float per line, already
+    validated. ``n`` is the frame number *in this clip*, which is not the
+    source frame number — a preview decodes a window starting at
+    ``frame_offset`` and a trimmed encode starts at the trim point — and a
+    preceding deinterlace pass may have changed the rate. The source frame is
+    ``frame_offset + n * rate_den // rate_num``.
+    """
+    with open(factors_path, "r", encoding="utf-8") as fh:
+        factors = [float(line) for line in fh if line.strip()]
+
+    lo, hi = 1.0 - max_deviation, 1.0 + max_deviation
+
+    def _lookup(n, f=None):
+        idx = frame_offset + (n * rate_den) // rate_num
+        factor = factors[idx] if 0 <= idx < len(factors) else 1.0
+        if invert and factor > 0:
+            factor = 1.0 / factor
+        return min(hi, max(lo, factor)), 0.0
+
+    return _apply_per_frame(clip, _lookup, black)
+
+
+def _measure_strip(clip, strip_width):
+    """Luma, centre 60% of the width, squeezed to a narrow strip.
+
+    A vertical scale doesn't depend on horizontal detail, so averaging columns
+    together costs nothing in precision and cuts the search cost ~40x. Kept at
+    float for exact diffs.
+    """
+    luma = core.std.ShufflePlanes(clip, 0, vs.GRAY) if clip.format.num_planes > 1 else clip
+    x0 = int(luma.width * 0.2)
+    w = luma.width - 2 * x0
+    return core.resize.Bicubic(luma, width=strip_width, height=luma.height,
+                               src_left=x0, src_width=w, format=vs.GRAYS)
+
+
+def _parabola(a, b, c):
+    """Vertex offset (-0.5..0.5 steps) of a parabola through 3 equally spaced points."""
+    denom = a - 2.0 * b + c
+    if denom <= 0:
+        return 0.0
+    return max(-0.5, min(0.5, 0.5 * (a - c) / denom))
+
+
+def _shifted(clip, offset):
+    """Frame n of the result is frame n+offset of ``clip``, clamped at the ends."""
+    if offset == 0:
+        return clip
+    n = clip.num_frames
+    if abs(offset) >= n:
+        return clip[0] * n if offset < 0 else clip[-1] * n
+    if offset > 0:
+        return clip[offset:] + clip[-1] * offset
+    return clip[0] * (-offset) + clip[:offset]
+
+
+def _pair_motion(strip, max_scale, step, max_shift, shift_step):
+    """Per-frame relative vertical motion between frame k and frame k+1.
+
+    Frame k of the returned (tiny) clip carries ``PairScale``/``PairShift``:
+    the (s, t) for which ``correct_frame(strip[k+1], s, t)`` best matches
+    ``strip[k]``, i.e. frame k+1 is stretched by s relative to frame k and
+    shifted down by t. Adjacent frames are nearly identical, so this is far
+    more precise than matching against a temporal average, which motion and
+    the breathing itself both blur. ``PairCut`` marks a scene change between
+    k and k+1, across which nothing is measured.
+    """
+    h = strip.height
+    # Compare only the central rows: the outer ones are edge-extended in some
+    # candidates and not others, which would bias the search toward 1.0.
+    margin = int(math.ceil(h * max_scale)) + int(math.ceil(max_shift)) + 4
+    margin = min(margin, h // 4)
+
+    def _core_rows(c):
+        return core.std.Crop(c, top=margin, bottom=margin)
+
+    nxt = _shifted(strip, 1)
+    ref_core = _core_rows(strip)
+
+    n_scale = max(1, int(round(max_scale / step)))
+    scales = [1.0 + i * step for i in range(-n_scale, n_scale + 1)]
+    n_shift = int(round(max_shift / shift_step)) if shift_step > 0 else 0
+    shifts = [i * shift_step for i in range(-n_shift, n_shift + 1)]
+    n_t = len(shifts)
+
+    stats = []
+    for s in scales:
+        for t in shifts:
+            stats.append(core.std.PlaneStats(_core_rows(correct_frame(nxt, s, t)), ref_core))
+    # Scene change detection on the strip itself: _SceneChangeNext on frame k.
+    cuts = core.misc.SCDetect(strip, threshold=0.1)
+
+    last = strip.num_frames - 1
+
+    def _measure(n, f):
+        fout = f[0].copy()
+        diffs = [fr.props["PlaneStatsDiff"] for fr in f[1:]]
+        best = min(range(len(diffs)), key=diffs.__getitem__)
+        i, j = divmod(best, n_t)
+        di = 0.0
+        if 0 < i < len(scales) - 1:
+            di = _parabola(diffs[best - n_t], diffs[best], diffs[best + n_t])
+        dj = 0.0
+        if 0 < j < n_t - 1:
+            dj = _parabola(diffs[best - 1], diffs[best], diffs[best + 1])
+        fout.props["PairScale"] = scales[i] + di * step
+        fout.props["PairShift"] = shifts[j] + dj * shift_step
+        fout.props["PairDiff"] = diffs[best]
+        # A pair whose best match still differs a lot is changing for reasons
+        # other than gate geometry (fast motion, a flash, a cut): its
+        # measurement is noise, so the chain is broken there like at a cut.
+        unreliable = diffs[best] > _UNRELIABLE_DIFF
+        cut = n >= last or f[0].props.get("_SceneChangeNext", 0) or unreliable
+        fout.props["PairCut"] = 1 if cut else 0
+        return fout
+
+    tiny = core.std.BlankClip(strip, width=8, height=8, format=vs.GRAY8)
+    tiny = core.std.CopyFrameProps(tiny, cuts)
+    return core.std.ModifyFrame(tiny, [tiny] + stats, _measure)
+
+
+def pitch_auto(clip, max_deviation=0.01, radius=10, step=0.002,
+               max_shift=2.0, shift_step=0.25, strip_width=48, black=False):
+    """Measure and correct vertical pitch and vertical jitter, frame by frame.
+
+    1. Relative (scale, shift) between every pair of adjacent frames, by grid
+       search on a narrow luma strip with parabolic sub-step refinement.
+    2. For frame n, chain those relative measurements across the ±radius
+       window (stopping at scene changes) to get every frame's position
+       relative to frame n, and correct n to the window's mean. A symmetric
+       mean leaves a constant or linearly changing pitch or position alone, so
+       slow zooms and tilts survive; only the jitter is removed.
+
+    Each frame only reads the pair measurements in its own window, so there is
+    no sequential state and preview frames match the encode.
+    """
+    if clip.format.color_family == vs.RGB:
+        work, orig = _to_working(clip)
+        out = pitch_auto(work, max_deviation, radius, step, max_shift,
+                         shift_step, strip_width, black)
+        return _from_working(out, orig)
+
+    radius = max(1, int(radius))
+    strip = _measure_strip(clip, strip_width)
+    # Adjacent frames can differ by up to twice the allowed deviation. The
+    # grid is capped at ±10 steps so a large limit costs coarser steps (the
+    # parabolic refinement still interpolates between them), not a search
+    # that grows without bound: at the default 1% it is 21 scales x 17 shifts.
+    pair_range = 2.0 * max_deviation
+    step = max(step, pair_range / 10.0)
+    pairs = _pair_motion(strip, pair_range, step, max_shift, shift_step)
+    # prop_src[i] is the pair (n + i - radius, n + i - radius + 1).
+    window = [_shifted(pairs, o) for o in range(-radius, radius)]
+
+    lo, hi = 1.0 - max_deviation, 1.0 + max_deviation
+    nframes = clip.num_frames
+
+    def _lookup(n, f):
+        # Position of frame k relative to frame n: log-scale L[k], shift T[k].
+        # Walk outwards from n, stopping at the clip ends and at scene changes.
+        L = {0: 0.0}
+        T = {0: 0.0}
+        # forward: pair (n+d, n+d+1) is f[radius + d]
+        for d in range(0, radius):
+            k = n + d
+            p = f[radius + d].props
+            if k + 1 >= nframes or p["PairCut"]:
+                break
+            s = p["PairScale"]
+            L[d + 1] = L[d] + math.log(s)
+            T[d + 1] = T[d] * s + p["PairShift"]
+        # backward: pair (n-d-1, n-d) is f[radius - d - 1]
+        for d in range(0, radius):
+            k = n - d - 1
+            p = f[radius - d - 1].props
+            if k < 0 or p["PairCut"]:
+                break
+            s = p["PairScale"]
+            # frame n-d = correct(frame n-d-1) relation inverted
+            L[-(d + 1)] = L[-d] - math.log(s)
+            T[-(d + 1)] = (T[-d] - p["PairShift"]) / s
+        if len(L) < 3:
+            return 1.0, 0.0
+        mean_l = sum(L.values()) / len(L)
+        mean_t = sum(T.values()) / len(T)
+        # Frame n relative to the window mean.
+        factor = math.exp(-mean_l)
+        shift = -mean_t
+        return min(hi, max(lo, factor)), max(-max_shift, min(max_shift, shift))
+
+    return _apply_per_frame(clip, _lookup, black, prop_src=window)
+
+
+def correct_pitch(clip, mode="off", factors_path=None, frame_offset=0,
+                  rate_num=1, rate_den=1, invert=False, max_deviation_pct=1.0,
+                  radius=10, black=False):
+    """Entry point used by the VapourBox templates' Stabilize pass.
+
+    ``mode`` is ``"auto"`` or ``"file"`` (the worker drops the call for
+    ``"off"``); file mode needs ``factors_path``, the worker's validated copy.
+    """
+    max_dev = max(0.0001, float(max_deviation_pct) / 100.0)
+    if mode == "file" and factors_path:
+        return pitch_from_file(clip, factors_path, frame_offset=frame_offset,
+                               rate_num=rate_num, rate_den=rate_den, invert=invert,
+                               max_deviation=max_dev, black=black)
+    if mode == "auto":
+        return pitch_auto(clip, max_deviation=max_dev, radius=radius, black=black)
+    return clip
diff --git a/worker/tests/filter_integration_test.rs b/worker/tests/filter_integration_test.rs
index 91bc743..ee02149 100644
--- a/worker/tests/filter_integration_test.rs
+++ b/worker/tests/filter_integration_test.rs
@@ -65,6 +65,7 @@ fn create_base_job(output_name: &str) -> VideoJob {
         input_color_transfer: None,
         input_color_range: None,
         burn_in_subtitle_path: None,
+        pitch_factors_path: None,
     }
 }
 
@@ -1273,6 +1274,7 @@ fn create_ivtc_base_job(output_name: &str) -> VideoJob {
         input_color_transfer: None,
         input_color_range: None,
         burn_in_subtitle_path: None,
+        pitch_factors_path: None,
     }
 }
 
@@ -1941,6 +1943,7 @@ fn test_55_preview_selects_exact_frame() {
     let generator = ScriptGenerator::new().expect("create generator");
     let params = PreviewParams {
         rate_pad: 0,
+        source_frame_offset: 0,
         width: 720,
         height: 576,
         pix_fmt: "yuv420p".to_string(),
@@ -3057,6 +3060,7 @@ fn generate_both_scripts(job: &VideoJob) -> (String, String) {
 
     let params = PreviewParams {
         rate_pad: 0,
+        source_frame_offset: 0,
         width: job.input_width.unwrap_or(720),
         height: job.input_height.unwrap_or(480),
         pix_fmt: job
@@ -4065,6 +4069,7 @@ fn test_107_stabilize() {
             dxmax: 6,
             dymax: 8,
             mirror: 3,
+            ..Default::default()
         },
         ..ProcessingPipeline::default()
     });
@@ -4090,6 +4095,7 @@ fn test_108_stabilize_limits_are_normalized() {
             dxmax: -3,
             dymax: -3,
             mirror: 9,
+            ..Default::default()
         },
         ..ProcessingPipeline::default()
     });
@@ -6010,6 +6016,7 @@ fn test_162_max_cache_size_is_only_set_when_overridden() {
         let generator = ScriptGenerator::new().expect("Failed to create generator");
         let params = PreviewParams {
         rate_pad: 0,
+        source_frame_offset: 0,
             width: 720,
             height: 480,
             pix_fmt: "yuv420p".to_string(),
@@ -6191,6 +6198,7 @@ fn both_scripts_with(generator: &ScriptGenerator, job: &VideoJob) -> anyhow::Res
     let encode = std::fs::read_to_string(generator.generate(job)?)?;
     let params = PreviewParams {
         rate_pad: 0,
+        source_frame_offset: 0,
         width: 720, height: 576, pix_fmt: "yuv420p".into(), num_frames: 11,
         fps_num: 25, fps_den: 1, output_index: 5,
     };
@@ -6250,6 +6258,7 @@ fn test_167_rife_unavailable_refuses_with_the_probe_message() {
     assert_eq!(err, message);
     let params = PreviewParams {
         rate_pad: 0,
+        source_frame_offset: 0,
         width: 720, height: 576, pix_fmt: "yuv420p".into(), num_frames: 11,
         fps_num: 25, fps_den: 1, output_index: 5,
     };
@@ -6818,6 +6827,7 @@ fn test_182_preview_retime_padding() {
 
         let params = PreviewParams {
             rate_pad: 1,
+            source_frame_offset: 0,
             width: 720, height: 576, pix_fmt: "yuv420p".into(), num_frames: 5,
             fps_num: 24, fps_den: 1, output_index: 3,
         };
@@ -7780,6 +7790,7 @@ fn test_209_gpu_plugin_models_are_addons() {
     ];
     let params = PreviewParams {
         rate_pad: 0,
+        source_frame_offset: 0,
         width: 720, height: 576, pix_fmt: "yuv420p".into(), num_frames: 11,
         fps_num: 25, fps_den: 1, output_index: 5,
     };
@@ -7818,3 +7829,370 @@ fn test_209_gpu_plugin_models_are_addons() {
     assert!(cases[0].0.effective_pipeline().required_addons().iter().any(|n| n.ids == [RIFE_ADDON]));
     let _ = std::fs::remove_dir_all(&root);
 }
+
+/// Issue #149: the preview must be drawn at the shape the encode declares, and
+/// fitted the same way. Two halves:
+/// - the preview script's square-pixel fitting reads the source SAR exactly as
+///   the encode's does (the app used to send no `inputSar` with a preview job,
+///   so `{{SOURCE_SAR}}` fell back to 1 and a 720x576 4:3 source was fitted to
+///   1350x1080 in the preview but 1440x1080 in the encode);
+/// - the declaration the preview reports (`output_aspect`) is the one the
+///   encode stamps, for the reporter's setup (square + resize + pad) and for
+///   the default Preserve.
+#[test]
+fn test_210_preview_aspect_matches_the_encode() {
+    create_output_dir();
+    let mut job = create_base_job("test_210_preview_aspect");
+    job.qtgmc_parameters.enabled = false;
+    job.input_sar = Some("16:15".to_string());
+    let crop_resize = CropResizeParameters {
+        enabled: true,
+        resize_enabled: true,
+        pixel_aspect: PixelAspectMode::Square,
+        target_width: Some(1440),
+        target_height: Some(1080),
+        ..Default::default()
+    };
+    job.processing_pipeline = Some(ProcessingPipeline {
+        deinterlace: QTGMCParameters { enabled: false, ..Default::default() },
+        crop_resize: crop_resize.clone(),
+        ..ProcessingPipeline::default()
+    });
+
+    let generator = ScriptGenerator::new().unwrap();
+    let encode = std::fs::read_to_string(generator.generate(&job).unwrap()).unwrap();
+    let params = PreviewParams {
+        rate_pad: 0,
+        source_frame_offset: 0,
+        width: 720, height: 576, pix_fmt: "yuv420p".into(), num_frames: 5,
+        fps_num: 25, fps_den: 1, output_index: 2,
+    };
+    let preview = std::fs::read_to_string(generator.generate_preview(&job, &params).unwrap()).unwrap();
+
+    let aspect_line = |script: &str| {
+        script
+            .lines()
+            .find(|l| l.starts_with("_display_aspect = (clip.width *"))
+            .map(str::to_string)
+    };
+    let encode_line = aspect_line(&encode).expect("encode fits by display aspect");
+    assert!(encode_line.contains("1.0667"), "source SAR 16/15 expected: {encode_line}");
+    assert_eq!(
+        aspect_line(&preview).as_deref(),
+        Some(encode_line.as_str()),
+        "the preview must fit by the same display aspect as the encode"
+    );
+
+    // Square pixels: nothing to declare, so the preview reports nothing.
+    let pipeline = job.effective_pipeline();
+    assert_eq!(pipeline.output_aspect(job.input_sar.as_deref()), AspectDeclaration::None);
+
+    // Preserve keeps the source SAR on the padded frame; the preview reports it.
+    let mut preserve = pipeline.clone();
+    preserve.crop_resize.pixel_aspect = PixelAspectMode::Preserve;
+    let declared = preserve.output_aspect(job.input_sar.as_deref());
+    assert_eq!(declared, AspectDeclaration::Sar("16:15".to_string()));
+    assert_eq!(declared.preview_token().as_deref(), Some("sar=16/15"));
+}
+
+// ============================================================================
+// STABILIZE pitch correction (issue #150): vertical pitch ("frame height
+// breathing") added to the existing Stabilize pass, after its havsfunc Stab
+// weave correction. These cover script generation; the picture-level checks
+// (does it actually undo a known distortion?) are in the Flutter heavy suite,
+// integration_stabilize_test.dart.
+// ============================================================================
+
+fn stabilize_job(name: &str, stabilize: StabilizeParameters) -> VideoJob {
+    let mut job = create_base_job(name);
+    job.qtgmc_parameters.enabled = false;
+    job.detected_field_order = Some(FieldOrder::Progressive);
+    job.processing_pipeline = Some(ProcessingPipeline {
+        deinterlace: QTGMCParameters { enabled: false, ..QTGMCParameters::default() },
+        stabilize,
+        ..ProcessingPipeline::default()
+    });
+    job
+}
+
+fn stabilize_preview_script_at(job: &VideoJob, source_frame_offset: i32) -> Result<String, String> {
+    let generator = ScriptGenerator::new().map_err(|e| e.to_string())?;
+    let params = PreviewParams {
+        rate_pad: 0,
+        source_frame_offset,
+        width: 720,
+        height: 576,
+        pix_fmt: "yuv420p".to_string(),
+        num_frames: 40,
+        fps_num: 25,
+        fps_den: 1,
+        output_index: 18,
+    };
+    let path = generator.generate_preview(job, &params).map_err(|e| format!("{:#}", e))?;
+    std::fs::read_to_string(path).map_err(|e| e.to_string())
+}
+
+fn write_factor_file(name: &str, contents: &str) -> String {
+    create_output_dir();
+    let path = get_output_path(name).with_extension("txt");
+    std::fs::write(&path, contents).expect("write factor file");
+    path.to_string_lossy().to_string()
+}
+
+fn assert_no_stab_placeholders(label: &str, script: &str) {
+    assert!(
+        !script.contains("{{STAB") && !script.contains("{{#STAB") && !script.contains("{{/STAB")
+            && !script.contains("{{PIPE_CACHE"),
+        "{}: unreplaced placeholder in:\n{}", label, script
+    );
+}
+
+#[test]
+fn test_211_stabilize_disabled_leaves_no_trace() {
+    // Off by default, and an off pass must leave the scripts exactly as they
+    // were: no import, no call, no unreplaced placeholder.
+    create_output_dir();
+    let job = stabilize_job("test_211_stabilize_off", StabilizeParameters::default());
+    let (encode, preview) = generate_both_scripts(&job);
+    for (label, script) in [("encode", &encode), ("preview", &preview)] {
+        for marker in ["haf.Stab(", "from stabilize import", "_stab_correct_pitch", "STABILIZE}}"] {
+            assert!(!script.contains(marker), "{}: unexpected '{}' in:\n{}", label, marker, script);
+        }
+        assert_no_stab_placeholders(label, script);
+    }
+}
+
+#[test]
+fn test_212_stabilize_saved_before_pitch_is_unchanged() {
+    // A pipeline saved before pitch correction existed has only
+    // enabled/dxmax/dymax/mirror. It must deserialise to weave-only and get
+    // exactly the Stabilize block it always got, byte for byte.
+    create_output_dir();
+    let stabilize: StabilizeParameters =
+        serde_json::from_str(r#"{"enabled":true,"dxmax":6,"dymax":2,"mirror":3}"#).unwrap();
+    let job = stabilize_job("test_212_stabilize_legacy", stabilize);
+    let expected = "# PASS: STABILIZE\n\
+# ============================================================================\n\
+\n\
+# Stab - global motion stabilisation via MVTools' Depan family. Measures the\n\
+# frame-to-frame shift and subtracts it, so shake is cancelled while a\n\
+# deliberate pan survives. Frame count is unchanged, which is why this is an\n\
+# ordinary pass.\n\
+#\n\
+# The signature is Stab(clp, dxmax, dymax, mirror) — there is no `range`\n\
+# argument, whatever other Stab implementations take. `mirror` fills the edges\n\
+# the shift exposes rather than leaving them black.\n\
+clip = haf.Stab(\n    clip,\n    dxmax=6,\n    dymax=2,\n    mirror=3,\n)\n\
+\n\
+\n\
+# ============================================================================\n";
+    let (encode, preview) = generate_both_scripts(&job);
+    for (label, script) in [("encode", &encode), ("preview", &preview)] {
+        let start = script.find("# PASS: STABILIZE").expect("stabilize section");
+        let end = start + script[start..].find("# PASS: ROTATE / FLIP").expect("rotate section");
+        assert_eq!(&script[start..end], expected, "{}: Stabilize block changed", label);
+        assert_no_stab_placeholders(label, script);
+    }
+}
+
+#[test]
+fn test_213_stabilize_auto_pitch_is_in_both_scripts() {
+    create_output_dir();
+    let job = stabilize_job("test_213_stabilize_auto", StabilizeParameters {
+        enabled: true,
+        dxmax: 6,
+        dymax: 3,
+        pitch_mode: PitchMode::Auto,
+        max_pitch_deviation: 1.5,
+        smoothing_radius: 8,
+        pitch_edge_fill: EdgeFill::Black,
+        ..StabilizeParameters::default()
+    });
+    let (encode, preview) = generate_both_scripts(&job);
+    for (label, script) in [("encode", &encode), ("preview", &preview)] {
+        for expected in [
+            "haf.Stab(",
+            "dxmax=6",
+            "dymax=3",
+            "from stabilize import correct_pitch as _stab_correct_pitch",
+            "mode=\"auto\"",
+            "max_deviation_pct=1.5",
+            "radius=8",
+            "black=True",
+        ] {
+            assert!(script.contains(expected), "{}: missing '{}' in:\n{}", label, expected, script);
+        }
+        assert!(!script.contains("factors_path"), "{}: auto mode reads no file", label);
+        assert!(!script.contains("SetFieldBased(clip, 0)"), "{}: progressive source", label);
+        assert_no_stab_placeholders(label, script);
+        // Weave, then pitch, both where the pass has always run: after colour
+        // correction, before rotate / crop.
+        let color = script.find("PASS 9: COLOR CORRECTION").unwrap();
+        let weave = script.find("clip = haf.Stab(").unwrap();
+        let pitch = script.find("clip = _stab_correct_pitch(").unwrap();
+        let rotate = script.find("PASS: ROTATE / FLIP").unwrap();
+        assert!(color < weave && weave < pitch && pitch < rotate, "{}: Stabilize is out of order", label);
+    }
+}
+
+#[test]
+fn test_214_stabilize_file_pitch_uses_source_frame_numbers() {
+    // The factor file is indexed by SOURCE frame. A trimmed encode starts its
+    // clip at start_frame and a preview at its window start, so each script
+    // must carry its own offset — factors[n] would give every frame of a
+    // preview or a trimmed export the wrong factor.
+    create_output_dir();
+    let factors = write_factor_file(
+        "test_214_factors",
+        "# pitch log from the reporter's tool\n1.0012\n0.9990\n\n1.0004  # slip\n",
+    );
+    let mut job = stabilize_job("test_214_stabilize_file", StabilizeParameters {
+        enabled: true,
+        weave: false,
+        pitch_mode: PitchMode::File,
+        invert_factors: true,
+        ..StabilizeParameters::default()
+    });
+    job.pitch_factors_path = Some(factors);
+    job.start_frame = Some(100);
+    job.end_frame = Some(200);
+
+    let generator = ScriptGenerator::new().unwrap();
+    let encode = std::fs::read_to_string(generator.generate(&job).unwrap()).unwrap();
+    assert!(encode.contains("frame_offset=100"), "encode must start at the trim:\n{}", encode);
+    assert!(encode.contains("mode=\"file\""));
+    assert!(!encode.contains("haf.Stab("), "weave is off");
+    assert!(encode.contains("invert=True"));
+    assert!(encode.contains("rate_num=1") && encode.contains("rate_den=1"));
+    assert_no_stab_placeholders("encode", &encode);
+
+    // The script reads the worker's normalised copy, not the user's file.
+    let line = encode.lines().find(|l| l.contains("factors_path=r\"")).expect("factors_path line");
+    let path = line.split("r\"").nth(1).unwrap().trim_end_matches("\",");
+    let normalised = std::fs::read_to_string(path).expect("normalised factor file exists");
+    let values: Vec<f64> = normalised.lines().map(|l| l.parse().unwrap()).collect();
+    assert_eq!(values, vec![1.0012, 0.9990, 1.0004]);
+
+    let preview = stabilize_preview_script_at(&job, 37).unwrap();
+    assert!(preview.contains("frame_offset=37"), "preview must start at its window:\n{}", preview);
+}
+
+#[test]
+fn test_215_stabilize_file_pitch_follows_double_rate_deinterlace() {
+    // Double-rate QTGMC runs first, so the stabiliser sees two frames per
+    // source frame and must look factors up at n // 2.
+    create_output_dir();
+    let factors = write_factor_file("test_215_factors", "1.001\n0.999\n");
+    let mut job = create_base_job("test_215_stabilize_double_rate");
+    job.qtgmc_parameters = QTGMCParameters {
+        enabled: true,
+        preset: QTGMCPreset::Fast,
+        tff: Some(true),
+        ..QTGMCParameters::default()
+    };
+    job.processing_pipeline = Some(ProcessingPipeline {
+        deinterlace: job.qtgmc_parameters.clone(),
+        stabilize: StabilizeParameters {
+            enabled: true,
+            pitch_mode: PitchMode::File,
+            ..StabilizeParameters::default()
+        },
+        ..ProcessingPipeline::default()
+    });
+    job.pitch_factors_path = Some(factors);
+    run_job_and_verify(&job, "Stabilize after double-rate QTGMC", &[
+        "rate_num=2",
+        "rate_den=1",
+        "haf.QTGMC(",
+    ]).unwrap();
+    // Deinterlaced output is progressive: no field marking to clear.
+    let generator = ScriptGenerator::new().unwrap();
+    let encode = std::fs::read_to_string(generator.generate(&job).unwrap()).unwrap();
+    assert!(!encode.contains("SetFieldBased(clip, 0)"));
+}
+
+#[test]
+fn test_216_stabilize_file_pitch_without_a_usable_file_fails_loudly() {
+    // File mode is an explicit request for a correction; producing a job
+    // without it would be indistinguishable from one with it.
+    create_output_dir();
+    let params = StabilizeParameters {
+        enabled: true,
+        pitch_mode: PitchMode::File,
+        ..StabilizeParameters::default()
+    };
+    let generator = ScriptGenerator::new().unwrap();
+
+    let job = stabilize_job("test_216_no_file", params.clone());
+    let err = format!("{:#}", generator.generate(&job).unwrap_err());
+    assert!(err.contains("no pitch factor file"), "{}", err);
+    assert!(stabilize_preview_script_at(&job, 0).unwrap_err().contains("no pitch factor file"));
+
+    let mut job = stabilize_job("test_216_missing_file", params.clone());
+    job.pitch_factors_path = Some("/nonexistent/vapourbox/pitch.txt".to_string());
+    let err = format!("{:#}", generator.generate(&job).unwrap_err());
+    assert!(err.contains("cannot read pitch factor file"), "{}", err);
+
+    let mut job = stabilize_job("test_216_bad_file", params);
+    job.pitch_factors_path = Some(write_factor_file("test_216_bad", "1.0\n1.0\nbanana\n"));
+    let err = format!("{:#}", generator.generate(&job).unwrap_err());
+    assert!(err.contains("line 3"), "error should name the bad line: {}", err);
+}
+
+#[test]
+fn test_217_pipe_cache_covers_the_temporal_window() {
+    // pipe_source returns the LAST frame read for anything it has already
+    // evicted — silently. Its cache has to cover the pipeline's whole window,
+    // which the stabiliser enlarges considerably.
+    create_output_dir();
+    let job = stabilize_job("test_217_pipe_cache", StabilizeParameters {
+        enabled: true,
+        pitch_mode: PitchMode::Auto,
+        smoothing_radius: 20,
+        ..StabilizeParameters::default()
+    });
+    let radius = job.effective_pipeline().total_radius();
+    assert!(radius >= 9 + 21, "stabiliser window must count toward the radius");
+    let (encode, preview) = generate_both_scripts(&job);
+    for (label, script) in [("encode", &encode), ("preview", &preview)] {
+        let line = script.lines().find(|l| l.contains("cache_frames=")).expect("cache_frames");
+        let frames: u32 = line.trim().trim_start_matches("cache_frames=").trim_end_matches(',').parse().unwrap();
+        assert!(frames >= 2 * radius + 1, "{}: cache {} < window {}", label, frames, 2 * radius + 1);
+    }
+    // And a plain pipeline keeps the old floor.
+    let plain = stabilize_job("test_217_plain", StabilizeParameters::default());
+    let (encode, preview) = generate_both_scripts(&plain);
+    assert!(encode.contains("cache_frames=40,"));
+    assert!(preview.contains("cache_frames=40,"));
+}
+
+#[test]
+fn test_218_stabilize_pitch_without_deinterlace_drops_field_marking() {
+    // A vertical resample of a field-based clip mixes the fields. Film scans
+    // flagged interlaced (or interlaced material the user chose not to
+    // deinterlace) get their pitch corrected as progressive. Weave alone keeps
+    // the marking, as it always has.
+    create_output_dir();
+    let mut job = stabilize_job("test_218_field_based", StabilizeParameters {
+        enabled: true,
+        pitch_mode: PitchMode::Auto,
+        ..StabilizeParameters::default()
+    });
+    job.detected_field_order = Some(FieldOrder::TopFieldFirst);
+    let (encode, preview) = generate_both_scripts(&job);
+    for (label, script) in [("encode", &encode), ("preview", &preview)] {
+        let mark = script.find("core.std.SetFieldBased(clip, 2)").expect("source is marked TFF");
+        let clear = script.find("core.std.SetFieldBased(clip, 0)").expect("pitch clears it");
+        let pitch = script.find("clip = _stab_correct_pitch(").unwrap();
+        assert!(mark < clear && clear < pitch, "{}: wrong order", label);
+    }
+
+    let mut weave_only = stabilize_job("test_218_weave_only", StabilizeParameters {
+        enabled: true,
+        ..StabilizeParameters::default()
+    });
+    weave_only.detected_field_order = Some(FieldOrder::TopFieldFirst);
+    let (encode, preview) = generate_both_scripts(&weave_only);
+    assert!(!encode.contains("core.std.SetFieldBased(clip, 0)"));
+    assert!(!preview.contains("core.std.SetFieldBased(clip, 0)"));
+}
diff --git a/worker/tests/preview_integration_test.rs b/worker/tests/preview_integration_test.rs
index 2a7acb7..5e8d2d0 100644
--- a/worker/tests/preview_integration_test.rs
+++ b/worker/tests/preview_integration_test.rs
@@ -85,6 +85,7 @@ fn test_preview_10bit_422_matches_source_frame() {
         input_color_transfer: None,
         input_color_range: None,
         burn_in_subtitle_path: None,
+        pitch_factors_path: None,
     };
 
     let cfg_path = out_dir.join("preview_pal_job.json");