diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index d10de2d..e78661c 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -54,8 +54,8 @@ jobs:
           "$prefix/bin/ffmpeg" -version
       - name: Static checks
         run: |
-          ruff check src/tensorcodec av/python tests scripts benchmarks/image_codecs.py
-          ruff format --check src/tensorcodec av/python tests scripts benchmarks/image_codecs.py
+          ruff check src/tensorcodec av/python tests scripts benchmarks/image_codecs.py benchmarks/transform_bench.py
+          ruff format --check src/tensorcodec av/python tests scripts benchmarks/image_codecs.py benchmarks/transform_bench.py
           cargo fmt --manifest-path av/Cargo.toml --check
           cargo clippy --manifest-path av/Cargo.toml --locked -- -D warnings
       - name: Build tensorcodec-av against prebuilt FFmpeg and install tensorcodec
diff --git a/README.md b/README.md
index 656be41..cb19b11 100644
--- a/README.md
+++ b/README.md
@@ -60,7 +60,7 @@ with VideoDecoder("video.mkv", seek_mode="timestamp") as decoder:
     frames = decoder.get_frames_played_at([10.0, 10.1, 10.2])
 ```
 
-Decoder transforms (since v0.1.5) resize and crop inside the decoder, as TorchCodec's do:
+Decoder transforms (since v0.1.5) resize and crop inside the decoder:
 
 ```python
 from tensorcodec.transforms import CenterCrop, Resize
@@ -69,6 +69,10 @@ with VideoDecoder("video.mp4", transforms=[Resize((256, 340)), CenterCrop((224,
     frames = decoder.get_frames_at([0, 10])  # (2, 3, 224, 224)
 ```
 
+Crops select the same pixels as TorchCodec's. Since v0.4.2, `Resize` scales in YUV while converting
+to RGB, so it costs no more than native-size output; its pixels differ from TorchCodec's by about
+0.9 levels on average (see [resizing](docs/compatibility.md#resizing)).
+
 This TensorCodec extension selects by actual PTS and retries seeks that overshoot.
 It supports time queries, including ranges with explicit `fps`, but not frame
 indices, `len(decoder)`, or `get_all_frames()`. See [the contract](docs/compatibility.md#timestamp-mode).
diff --git a/av/Cargo.lock b/av/Cargo.lock
index 5ae0aee..d00c733 100644
--- a/av/Cargo.lock
+++ b/av/Cargo.lock
@@ -449,7 +449,7 @@ checksum = "61c41af27dd6d1e27b1b16b489db798443478cef1f06a660c96db617ba5de3b1"
 
 [[package]]
 name = "tensorcodec-av"
-version = "0.4.1"
+version = "0.4.2"
 dependencies = [
  "ffmpeg-sys-next",
  "libc",
diff --git a/av/Cargo.toml b/av/Cargo.toml
index f6656af..024ff5b 100644
--- a/av/Cargo.toml
+++ b/av/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "tensorcodec-av"
-version = "0.4.1"
+version = "0.4.2"
 edition = "2021"
 rust-version = "1.88"  # ffmpeg-sys-next 9 builds with let chains
 license = "Apache-2.0"
diff --git a/av/src/ffmpeg.rs b/av/src/ffmpeg.rs
index a53a356..381c46b 100644
--- a/av/src/ffmpeg.rs
+++ b/av/src/ffmpeg.rs
@@ -43,8 +43,8 @@ pub enum VideoRequest {
     Timestamps(Vec<f64>),
 }
 
-/// A geometric step on RGB frames; a rotation (counterclockwise quarter turns) comes first, then
-/// crops and resizes in the rotated frame's coordinates.
+/// A geometric step; a rotation (counterclockwise quarter turns) comes first, then crops and resizes in the
+/// rotated frame's coordinates. `Pipeline` decides which run on the decoded planes and which on RGB.
 #[derive(Clone, Copy, PartialEq)]
 pub enum Op {
     Rotate {
@@ -62,21 +62,51 @@ pub enum Op {
     },
 }
 
-/// One resize step's swscale context (bilinear, RGB to RGB at the same depth) and its output frame.
+/// One resize step: a bilinear swscale pass from a source region straight to RGB at the output size. swscale
+/// writes planar RGB with SIMD (its packed full-chroma writer is C only), interleaved into `frame` afterwards.
 struct Resizer {
     scale: *mut av::SwsContext,
-    config: (i32, i32, i32, i32, i32),
+    config: [i32; 8],
+    planar: *mut av::AVFrame,
     frame: *mut av::AVFrame,
 }
+impl Resizer {
+    fn new() -> Result<Self> {
+        let (planar, frame) = unsafe { (av::av_frame_alloc(), av::av_frame_alloc()) };
+        // Owned before the check, so Drop frees whichever allocation succeeded.
+        let resizer = Self {
+            scale: ptr::null_mut(),
+            config: [0; 8],
+            planar,
+            frame,
+        };
+        if planar.is_null() || frame.is_null() {
+            return Err(failure("cannot allocate resize frames"));
+        }
+        Ok(resizer)
+    }
+}
 impl Drop for Resizer {
     fn drop(&mut self) {
         unsafe {
             av::sws_freeContext(self.scale);
+            av::av_frame_free(&mut self.planar);
             av::av_frame_free(&mut self.frame);
         }
     }
 }
 
+/// Planes of a region to resize: decoded YUV/RGB planes or an RGB intermediate. `chroma_position` is swscale's
+/// `src_h_chr_pos`/`src_v_chr_pos` (1/256 luma pixel; -513 for its default, centered siting).
+struct Region {
+    data: [*const u8; 8],
+    linesize: [i32; 8],
+    format: av::AVPixelFormat,
+    width: i32,
+    height: i32,
+    chroma_position: (i32, i32),
+}
+
 enum Selection {
     Frame { pts: i64, key: i64, exact: bool },
     Timestamp(f64),
@@ -214,7 +244,7 @@ pub struct Decoder {
     frame: *mut av::AVFrame,
     rgb_frame: *mut av::AVFrame,
     scale: *mut av::SwsContext,
-    scale_config: Option<(i32, i32, i32, i32)>,
+    scale_config: Option<[i32; 4]>,
     resizers: Vec<Resizer>,
     rotated: Vec<u8>,
     io: *mut av::AVIOContext,
@@ -892,6 +922,7 @@ impl Decoder {
         let mut pts = vec![0.; length];
         let mut durations = vec![0.; length];
         let mut active_key = None;
+        let pipeline = Pipeline::new(ops, (self.video_layout.0, self.video_layout.1));
         let stride = count * if high_depth { 2 } else { 1 };
         for (selection, positions) in requests {
             match selection {
@@ -910,95 +941,53 @@ impl Decoder {
                     return Err(failure("dynamic frame dimensions are unsupported"));
                 }
                 let input_format: av::AVPixelFormat = std::mem::transmute(frame.format);
-                let output_frame = if native {
+                let format = if high_depth {
+                    av::AVPixelFormat::AV_PIX_FMT_RGB48LE
+                } else {
+                    av::AVPixelFormat::AV_PIX_FMT_RGB24
+                };
+                let (data, linesize, size, rest, slot) = if native {
                     if input_format != source_format {
                         return Err(Error("pixel format changed within stream".into(), true));
                     }
-                    frame
+                    let size = (frame.width, frame.height);
+                    (
+                        frame.data[0] as *const u8,
+                        frame.linesize[0],
+                        size,
+                        &[][..],
+                        0,
+                    )
+                } else if let Some((region, (h, w))) = pipeline
+                    .first
+                    .and_then(|(rect, size)| Some((region_planes(frame, rect)?, size)))
+                {
+                    let (data, linesize) =
+                        self.resize(0, &region, (w, h), high_depth, Some(frame))?;
+                    (data, linesize, (w, h), &pipeline.after_first[..], 1)
                 } else {
-                    let output_format = if high_depth {
-                        av::AVPixelFormat::AV_PIX_FMT_RGB48LE
-                    } else {
-                        av::AVPixelFormat::AV_PIX_FMT_RGB24
-                    };
-                    let config = (
+                    // Full-size color conversion, then every op on RGB.
+                    let config = [
                         frame.width,
                         frame.height,
                         input_format as i32,
-                        output_format as i32,
-                    );
+                        format as i32,
+                    ];
                     if self.scale_config != Some(config) {
                         av::sws_freeContext(self.scale);
-                        self.scale = av::sws_getContext(
-                            frame.width,
-                            frame.height,
-                            input_format,
-                            frame.width,
-                            frame.height,
-                            output_format,
+                        self.scale = scale_context(
+                            (frame.width, frame.height, input_format),
+                            (frame.width, frame.height, format),
                             0,
-                            ptr::null_mut(),
-                            ptr::null_mut(),
-                            ptr::null(),
+                            (-513, -513),
                         );
                         self.scale_config = Some(config);
                     }
                     if self.scale.is_null() {
                         return Err(failure("cannot initialize color conversion"));
                     }
-                    let mut inverse = ptr::null_mut();
-                    let mut table = ptr::null_mut();
-                    let (
-                        mut source_range,
-                        mut destination_range,
-                        mut brightness,
-                        mut contrast,
-                        mut saturation,
-                    ) = (0, 0, 0, 0, 0);
-                    check(
-                        av::sws_getColorspaceDetails(
-                            self.scale,
-                            &mut inverse,
-                            &mut source_range,
-                            &mut table,
-                            &mut destination_range,
-                            &mut brightness,
-                            &mut contrast,
-                            &mut saturation,
-                        ),
-                        "read color conversion settings",
-                    )?;
-                    if frame.color_range != av::AVColorRange::AVCOL_RANGE_UNSPECIFIED {
-                        source_range =
-                            i32::from(frame.color_range == av::AVColorRange::AVCOL_RANGE_JPEG);
-                    }
-                    let coefficients = av::sws_getCoefficients(frame.colorspace as i32);
-                    check(
-                        av::sws_setColorspaceDetails(
-                            self.scale,
-                            coefficients,
-                            source_range,
-                            coefficients,
-                            destination_range,
-                            brightness,
-                            contrast,
-                            saturation,
-                        ),
-                        "configure color conversion",
-                    )?;
-                    if (*self.rgb_frame).width != frame.width
-                        || (*self.rgb_frame).height != frame.height
-                        || (*self.rgb_frame).format != output_format as i32
-                    {
-                        av::av_frame_unref(self.rgb_frame);
-                        (*self.rgb_frame).width = frame.width;
-                        (*self.rgb_frame).height = frame.height;
-                        (*self.rgb_frame).format = output_format as i32;
-                        check(
-                            av::av_frame_get_buffer(self.rgb_frame, 32),
-                            "allocate RGB frame",
-                        )?;
-                    }
+                    configure_colors(self.scale, frame)?;
+                    ensure_frame(self.rgb_frame, frame.width, frame.height, format)?;
                     let rows = av::sws_scale(
                         self.scale,
                         frame.data.as_ptr() as *const *const u8,
@@ -1011,18 +1000,18 @@ impl Decoder {
                     if rows != frame.height {
                         return Err(failure("color conversion failed"));
                     }
-                    &*self.rgb_frame
-                };
-                let (data, linesize) = if ops.is_empty() {
-                    (output_frame.data[0] as *const u8, output_frame.linesize[0])
-                } else {
-                    let format = if high_depth {
-                        av::AVPixelFormat::AV_PIX_FMT_RGB48LE
-                    } else {
-                        av::AVPixelFormat::AV_PIX_FMT_RGB24
-                    };
-                    self.transform(output_frame, format, ops)?
+                    let rgb = &*self.rgb_frame;
+                    let size = (frame.width, frame.height);
+                    (
+                        rgb.data[0] as *const u8,
+                        rgb.linesize[0],
+                        size,
+                        &pipeline.ops[..],
+                        0,
+                    )
                 };
+                let (data, linesize) =
+                    self.transform((data, linesize), size, format, rest, slot)?;
                 let row_bytes = width * channels * if high_depth { 2 } else { 1 };
                 if data.is_null() || (linesize.unsigned_abs() as usize) < row_bytes {
                     return Err(failure("invalid decoded frame stride"));
@@ -1080,22 +1069,18 @@ impl Decoder {
         })
     }
 
-    /// Applies `ops` to an RGB frame: a crop moves the view, a resize scales it into its own frame.
-    /// Returns the result's first row and stride.
+    /// Applies `ops` to an RGB image (first row, stride) of `size` (width, height): a crop moves the view, a
+    /// resize scales it into resize slot `slot` onwards. Returns the result's first row and stride.
     unsafe fn transform(
         &mut self,
-        frame: &av::AVFrame,
+        (mut data, mut linesize): (*const u8, i32),
+        (mut width, mut height): (i32, i32),
         format: av::AVPixelFormat,
         ops: &[Op],
+        mut slot: usize,
     ) -> Result<(*const u8, i32)> {
-        let pixel_bytes: isize = if format == av::AVPixelFormat::AV_PIX_FMT_RGB24 {
-            3
-        } else {
-            6
-        };
-        let (mut data, mut linesize) = (frame.data[0] as *const u8, frame.linesize[0]);
-        let (mut width, mut height) = (frame.width, frame.height);
-        let mut resize = 0;
+        let high_depth = format == av::AVPixelFormat::AV_PIX_FMT_RGB48LE;
+        let pixel_bytes: isize = if high_depth { 6 } else { 3 };
         for op in ops {
             match *op {
                 Op::Rotate { turns } => {
@@ -1146,70 +1131,98 @@ impl Decoder {
                     height: h,
                     width: w,
                 } => {
-                    let config = (width, height, w, h, format as i32);
-                    if self.resizers.len() <= resize {
-                        let frame = av::av_frame_alloc();
-                        if frame.is_null() {
-                            return Err(failure("cannot allocate resize frame"));
-                        }
-                        self.resizers.push(Resizer {
-                            scale: ptr::null_mut(),
-                            config: (0, 0, 0, 0, 0),
-                            frame,
-                        });
-                    }
-                    let resizer = &mut self.resizers[resize];
-                    if resizer.scale.is_null() || resizer.config != config {
-                        av::sws_freeContext(resizer.scale);
-                        resizer.scale = av::sws_getContext(
-                            width,
-                            height,
-                            format,
-                            w,
-                            h,
-                            format,
-                            av::SWS_BILINEAR,
-                            ptr::null_mut(),
-                            ptr::null_mut(),
-                            ptr::null(),
-                        );
-                        if resizer.scale.is_null() {
-                            return Err(failure("cannot initialize resize"));
-                        }
-                        resizer.config = config;
-                        av::av_frame_unref(resizer.frame);
-                        (*resizer.frame).width = w;
-                        (*resizer.frame).height = h;
-                        (*resizer.frame).format = format as i32;
-                        check(
-                            av::av_frame_get_buffer(resizer.frame, 32),
-                            "allocate resize frame",
-                        )?;
-                    }
-                    let source = [data, ptr::null(), ptr::null(), ptr::null()];
-                    let strides = [linesize, 0, 0, 0];
-                    let rows = av::sws_scale(
-                        resizer.scale,
-                        source.as_ptr(),
-                        strides.as_ptr(),
-                        0,
+                    let mut planes = [ptr::null(); 8];
+                    let mut strides = [0; 8];
+                    (planes[0], strides[0]) = (data, linesize);
+                    let region = Region {
+                        data: planes,
+                        linesize: strides,
+                        format,
+                        width,
                         height,
-                        (*resizer.frame).data.as_ptr(),
-                        (*resizer.frame).linesize.as_ptr(),
-                    );
-                    if rows != h {
-                        return Err(failure("resize failed"));
-                    }
-                    data = (*resizer.frame).data[0];
-                    linesize = (*resizer.frame).linesize[0];
+                        chroma_position: (-513, -513),
+                    };
+                    (data, linesize) = self.resize(slot, &region, (w, h), high_depth, None)?;
                     (width, height) = (w, h);
-                    resize += 1;
+                    slot += 1;
                 }
             }
         }
         Ok((data, linesize))
     }
 
+    /// Resizes `region` to `size` (width, height) RGB in resize slot `slot`; `colors` is the decoded frame
+    /// whose color space and range apply when the region holds its planes. Returns the first row and stride.
+    unsafe fn resize(
+        &mut self,
+        slot: usize,
+        region: &Region,
+        (width, height): (i32, i32),
+        high_depth: bool,
+        colors: Option<&av::AVFrame>,
+    ) -> Result<(*const u8, i32)> {
+        while self.resizers.len() <= slot {
+            self.resizers.push(Resizer::new()?);
+        }
+        let resizer = &mut self.resizers[slot];
+        let (planar, packed, bytes) = if high_depth {
+            (
+                av::AVPixelFormat::AV_PIX_FMT_GBRP16LE,
+                av::AVPixelFormat::AV_PIX_FMT_RGB48LE,
+                2,
+            )
+        } else {
+            (
+                av::AVPixelFormat::AV_PIX_FMT_GBRP,
+                av::AVPixelFormat::AV_PIX_FMT_RGB24,
+                1,
+            )
+        };
+        let config = [
+            region.width,
+            region.height,
+            region.format as i32,
+            width,
+            height,
+            planar as i32,
+            region.chroma_position.0,
+            region.chroma_position.1,
+        ];
+        if resizer.scale.is_null() || resizer.config != config {
+            av::sws_freeContext(resizer.scale);
+            // Full-resolution chroma on both sides: interpolated from subsampled planes, not decimated from RGB.
+            resizer.scale = scale_context(
+                (region.width, region.height, region.format),
+                (width, height, planar),
+                av::SWS_BILINEAR | av::SWS_FULL_CHR_H_INT | av::SWS_FULL_CHR_H_INP,
+                region.chroma_position,
+            );
+            if resizer.scale.is_null() {
+                return Err(failure("cannot initialize resize"));
+            }
+            resizer.config = config;
+        }
+        if let Some(frame) = colors {
+            configure_colors(resizer.scale, frame)?;
+        }
+        ensure_frame(resizer.planar, width, height, planar)?;
+        ensure_frame(resizer.frame, width, height, packed)?;
+        let rows = av::sws_scale(
+            resizer.scale,
+            region.data.as_ptr(),
+            region.linesize.as_ptr(),
+            0,
+            region.height,
+            (*resizer.planar).data.as_ptr(),
+            (*resizer.planar).linesize.as_ptr(),
+        );
+        if rows != height {
+            return Err(failure("resize failed"));
+        }
+        interleave(&*resizer.planar, &*resizer.frame, bytes);
+        Ok(((*resizer.frame).data[0], (*resizer.frame).linesize[0]))
+    }
+
     pub fn audio(&mut self, rate: i32, channels: i32, stop: Option<f64>) -> Result<Audio> {
         if !self.audio {
             return Err(failure("cannot decode audio from video stream"));
@@ -1336,6 +1349,281 @@ pub struct Audio {
     pub pts: f64,
 }
 
+/// A region: (top, left, height, width).
+type Rect = (i32, i32, i32, i32);
+
+/// How `ops` run on decoded frames. Leading crops and the first resize are one swscale pass from the decoded
+/// planes to RGB at the output size, and a display rotation before them moves after that resize (right-angle
+/// turns commute with the resampling, up to rounding). Without a resize, frames are converted at full size and
+/// the crops select RGB pixels.
+struct Pipeline {
+    /// Region of the decoded frame and output (height, width) of the first resize, both in the decoded
+    /// (unrotated) orientation.
+    first: Option<(Rect, (i32, i32))>,
+    /// Ops on the first resize's RGB output: the display rotation, then those after the resize.
+    after_first: Vec<Op>,
+    /// Ops on a frame converted at full size: all of them, for pipelines without a resize and for frames whose
+    /// region `region_planes` cannot address.
+    ops: Vec<Op>,
+}
+impl Pipeline {
+    /// Plans `ops` for decoded frames of `size` (width, height), dropping resizes to the current size.
+    fn new(ops: &[Op], (width, height): (i32, i32)) -> Self {
+        let mut size = (height, width);
+        let ops: Vec<Op> = ops
+            .iter()
+            .copied()
+            .filter(|op| {
+                let previous = size;
+                size = match *op {
+                    Op::Rotate { turns } if turns % 2 == 1 => (size.1, size.0),
+                    Op::Rotate { .. } => size,
+                    Op::Crop { height, width, .. } | Op::Resize { height, width } => {
+                        (height, width)
+                    }
+                };
+                !matches!(op, Op::Resize { .. }) || size != previous
+            })
+            .collect();
+        let (turns, body) = match ops.first() {
+            Some(&Op::Rotate { turns }) => (turns, &ops[1..]),
+            _ => (0, &ops[..]),
+        };
+        let (mut top, mut left) = (0, 0);
+        let (mut h, mut w) = if turns % 2 == 1 {
+            (width, height)
+        } else {
+            (height, width)
+        };
+        for (i, op) in body.iter().enumerate() {
+            match *op {
+                Op::Crop {
+                    top: t,
+                    left: l,
+                    height: ch,
+                    width: cw,
+                } => (top, left, h, w) = (top + t, left + l, ch, cw),
+                Op::Resize {
+                    height: oh,
+                    width: ow,
+                } => {
+                    // Inverse of `transform`'s rotation: the rotated region's pixels in the decoded frame.
+                    let region = match turns {
+                        1 => (left, width - top - h, w, h),
+                        2 => (height - top - h, width - left - w, h, w),
+                        3 => (height - left - w, top, w, h),
+                        _ => (top, left, h, w),
+                    };
+                    let output = if turns % 2 == 1 { (ow, oh) } else { (oh, ow) };
+                    let mut after_first = Vec::with_capacity(body.len() - i);
+                    if turns != 0 {
+                        after_first.push(Op::Rotate { turns });
+                    }
+                    after_first.extend_from_slice(&body[i + 1..]);
+                    return Self {
+                        first: Some((region, output)),
+                        after_first,
+                        ops,
+                    };
+                }
+                Op::Rotate { .. } => break,
+            }
+        }
+        Self {
+            first: None,
+            after_first: Vec::new(),
+            ops,
+        }
+    }
+}
+
+/// The planes of `rect` in `frame`. An offset inside a subsampled chroma pair starts the chroma plane at the pair
+/// and moves the chroma siting back to match. None when the format cannot be addressed by plane offsets
+/// (paletted, bitstream, hardware, or packed with subsampled chroma).
+unsafe fn region_planes(frame: &av::AVFrame, rect: Rect) -> Option<Region> {
+    let (top, left, height, width) = rect;
+    let mut region = Region {
+        data: frame.data.map(|p| p as *const u8),
+        linesize: frame.linesize,
+        format: std::mem::transmute::<i32, av::AVPixelFormat>(frame.format),
+        width,
+        height,
+        chroma_position: (-513, -513),
+    };
+    if rect == (0, 0, frame.height, frame.width) {
+        return Some(region);
+    }
+    let descriptor = av::av_pix_fmt_desc_get(region.format);
+    if descriptor.is_null() {
+        return None;
+    }
+    let descriptor = &*descriptor;
+    let flags = descriptor.flags as i32;
+    let (shift_x, shift_y) = (
+        descriptor.log2_chroma_w as i32,
+        descriptor.log2_chroma_h as i32,
+    );
+    let planar = flags & av::AV_PIX_FMT_FLAG_PLANAR != 0;
+    if flags
+        & (av::AV_PIX_FMT_FLAG_PAL | av::AV_PIX_FMT_FLAG_BITSTREAM | av::AV_PIX_FMT_FLAG_HWACCEL)
+        != 0
+        || !planar && (shift_x != 0 || shift_y != 0)
+    {
+        return None;
+    }
+    for (plane, pointer) in region.data.iter_mut().enumerate() {
+        if pointer.is_null() {
+            continue;
+        }
+        let (index, component) = descriptor.comp[..descriptor.nb_components as usize]
+            .iter()
+            .enumerate()
+            .find(|(_, c)| c.plane as usize == plane)?;
+        let chroma = planar && flags & av::AV_PIX_FMT_FLAG_RGB == 0 && (index == 1 || index == 2);
+        let (y, x) = if chroma {
+            (top >> shift_y, left >> shift_x)
+        } else {
+            (top, left)
+        };
+        // `step`: bytes between horizontally adjacent samples of this plane (a whole pixel, padding included,
+        // in packed formats).
+        *pointer = pointer.offset(
+            y as isize * frame.linesize[plane] as isize + x as isize * component.step as isize,
+        );
+    }
+    let position = |shift: i32, offset: i32| {
+        let phase = offset & ((1 << shift) - 1);
+        if phase == 0 {
+            -513
+        } else {
+            ((128 << shift) - 128) - 256 * phase
+        }
+    };
+    region.chroma_position = (position(shift_x, left), position(shift_y, top));
+    Some(region)
+}
+
+/// Applies the frame's color space and range to `scale` (unspecified ones keep swscale's defaults).
+unsafe fn configure_colors(scale: *mut av::SwsContext, frame: &av::AVFrame) -> Result<()> {
+    let mut inverse = ptr::null_mut();
+    let mut table = ptr::null_mut();
+    let (mut source_range, mut destination_range, mut brightness, mut contrast, mut saturation) =
+        (0, 0, 0, 0, 0);
+    check(
+        av::sws_getColorspaceDetails(
+            scale,
+            &mut inverse,
+            &mut source_range,
+            &mut table,
+            &mut destination_range,
+            &mut brightness,
+            &mut contrast,
+            &mut saturation,
+        ),
+        "read color conversion settings",
+    )?;
+    if frame.color_range != av::AVColorRange::AVCOL_RANGE_UNSPECIFIED {
+        source_range = i32::from(frame.color_range == av::AVColorRange::AVCOL_RANGE_JPEG);
+    }
+    let coefficients = av::sws_getCoefficients(frame.colorspace as i32);
+    check(
+        av::sws_setColorspaceDetails(
+            scale,
+            coefficients,
+            source_range,
+            coefficients,
+            destination_range,
+            brightness,
+            contrast,
+            saturation,
+        ),
+        "configure color conversion",
+    )
+}
+
+/// (Re)allocates `frame` unless it already has this size and format.
+unsafe fn ensure_frame(
+    frame: *mut av::AVFrame,
+    width: i32,
+    height: i32,
+    format: av::AVPixelFormat,
+) -> Result<()> {
+    if (*frame).width != width || (*frame).height != height || (*frame).format != format as i32 {
+        av::av_frame_unref(frame);
+        (*frame).width = width;
+        (*frame).height = height;
+        (*frame).format = format as i32;
+        check(av::av_frame_get_buffer(frame, 32), "allocate RGB frame")?;
+    }
+    Ok(())
+}
+
+unsafe fn scale_context(
+    (source_width, source_height, source_format): (i32, i32, av::AVPixelFormat),
+    (width, height, format): (i32, i32, av::AVPixelFormat),
+    flags: i32,
+    (chroma_x, chroma_y): (i32, i32),
+) -> *mut av::SwsContext {
+    let context = av::sws_alloc_context();
+    if context.is_null() {
+        return context;
+    }
+    let options = [
+        (c"srcw", source_width),
+        (c"srch", source_height),
+        (c"src_format", source_format as i32),
+        (c"dstw", width),
+        (c"dsth", height),
+        (c"dst_format", format as i32),
+        (c"sws_flags", flags),
+        (c"src_h_chr_pos", chroma_x),
+        (c"src_v_chr_pos", chroma_y),
+    ];
+    for (name, value) in options {
+        if av::av_opt_set_int(context as *mut c_void, name.as_ptr(), value.into(), 0) < 0 {
+            av::sws_freeContext(context);
+            return ptr::null_mut();
+        }
+    }
+    if av::sws_init_context(context, ptr::null_mut(), ptr::null_mut()) < 0 {
+        av::sws_freeContext(context);
+        return ptr::null_mut();
+    }
+    context
+}
+
+/// Interleaves planar G, B, R (`bytes` per sample) into packed RGB of the same size.
+unsafe fn interleave(planar: &av::AVFrame, packed: &av::AVFrame, bytes: usize) {
+    let width = planar.width as usize;
+    for y in 0..planar.height as isize {
+        let plane = |i: usize| {
+            std::slice::from_raw_parts(
+                planar.data[i].offset(y * planar.linesize[i] as isize),
+                width * bytes,
+            )
+        };
+        let (g, b, r) = (plane(0), plane(1), plane(2));
+        let out = std::slice::from_raw_parts_mut(
+            packed.data[0].offset(y * packed.linesize[0] as isize),
+            width * 3 * bytes,
+        );
+        if bytes == 1 {
+            for (((p, &r), &g), &b) in out.as_chunks_mut::<3>().0.iter_mut().zip(r).zip(g).zip(b) {
+                *p = [r, g, b];
+            }
+        } else {
+            let (r, g, b) = (
+                r.as_chunks::<2>().0,
+                g.as_chunks::<2>().0,
+                b.as_chunks::<2>().0,
+            );
+            for (((p, r), g), b) in out.as_chunks_mut::<6>().0.iter_mut().zip(r).zip(g).zip(b) {
+                *p = [r[0], r[1], g[0], g[1], b[0], b[1]];
+            }
+        }
+    }
+}
+
 fn seconds_per_tick(time_base: av::AVRational) -> f64 {
     time_base.num as f64 / time_base.den as f64
 }
diff --git a/benchmarks/README.md b/benchmarks/README.md
index 647ad7a..3c77065 100644
--- a/benchmarks/README.md
+++ b/benchmarks/README.md
@@ -49,6 +49,43 @@ This tool generates fresh inputs with FFmpeg. Its codec matrix measures speed;
 it does not assert pixel or timestamp correctness. See
 [container and seek behavior](../docs/container_robustness.md) for tested guarantees.
 
+## Decoder transforms
+
+`benchmarks.transform_bench` times `get_frames_at` per returned frame on one persistent decoder,
+at native size and with `Resize` to each square size. Without `--video` it generates 640x480
+GOP-2 `testsrc2` clips in AV1 (SVT-AV1) and H.264. Calls alternate between pipelines, so changes
+in machine load affect them alike. Run it under each version to compare.
+
+```sh
+uv run --no-sync python -m benchmarks.transform_bench
+uv run --no-sync python -m benchmarks.transform_bench --video clip.mp4 --sizes 224 128 --batches 1 20
+```
+
+v0.4.1 (convert at full size, then resize in RGB) against v0.4.2 (resize in YUV while
+converting, one swscale pass). Setup: Intel Core i7-14700K under WSL2, one core pinned with
+`taskset`, other load present; conda-forge FFmpeg 7.1.1; one decoder thread. Values are ms per
+returned frame, the mean of two runs of each version, each the median of 50 calls. All clips are
+640x480, 30 fps, 300 frames, GOP 2: `syn` is `testsrc2`, `real` is 10 s of the Sintel 480p
+trailer cropped to 640x480. The 1-frame case is the middle (odd) frame. The 20-frame case is
+every 15th frame, so each needs its own seek and up to two decoded frames.
+
+| clip | frames | native 0.4.1 | native 0.4.2 | 224² 0.4.1 | 224² 0.4.2 | 128² 0.4.1 | 128² 0.4.2 |
+| --- | --- | --- | --- | --- | --- | --- | --- |
+| syn AV1 | 1 | 1.89 | 1.93 | 2.34 | 1.91 | 2.17 | 1.83 |
+| syn AV1 | 20 | 1.62 | 1.62 | 2.09 | 1.60 | 1.89 | 1.52 |
+| real AV1 | 1 | 2.09 | 1.92 | 2.52 | 1.89 | 2.37 | 1.81 |
+| real AV1 | 20 | 1.58 | 1.52 | 2.05 | 1.48 | 1.87 | 1.40 |
+| syn H.264 | 1 | 2.24 | 2.30 | 2.78 | 2.30 | 2.52 | 2.18 |
+| syn H.264 | 20 | 1.75 | 1.78 | 2.23 | 1.75 | 2.05 | 1.67 |
+| real H.264 | 1 | 3.10 | 3.06 | 3.58 | 3.08 | 3.37 | 2.96 |
+| real H.264 | 20 | 2.03 | 2.02 | 2.49 | 1.99 | 2.31 | 1.91 |
+
+Native-size decoding is unchanged; differences there are run-to-run noise. Decoding dominates.
+On this machine, swscale's 640x480 yuv420p to rgb24 conversion takes about 0.07 ms per frame.
+The v0.4.1 RGB resize added 0.56 ms (224²) or 0.38 ms (128²); the single pass takes 0.12 ms or
+0.07 ms plus interleaving. A resized decode now costs the same as, or slightly less than, a
+native-size one. See [resizing](../docs/compatibility.md#resizing) for how the pixels differ.
+
 ## Optional I/O and plotting
 
 To separate opening from an 11-frame playback window, counting bytes returned by
diff --git a/benchmarks/transform_bench.py b/benchmarks/transform_bench.py
new file mode 100644
index 0000000..e10913f
--- /dev/null
+++ b/benchmarks/transform_bench.py
@@ -0,0 +1,90 @@
+"""Per-frame cost of decoder transforms.
+
+Times ``get_frames_at`` on one persistent decoder at native size and with ``Resize``, for one frame and for a
+strided batch. Without ``--video``, it generates 640x480 GOP-2 synthetic clips (testsrc2) in AV1 and H.264. Run it
+under two TensorCodec versions to compare them.
+
+Usage::
+
+    uv run --no-sync python -m benchmarks.transform_bench
+    uv run --no-sync python -m benchmarks.transform_bench --video clip.mp4 --sizes 224 128 --batches 1 20
+"""
+
+from __future__ import annotations
+
+import argparse
+import statistics
+import subprocess
+import tempfile
+import time
+from pathlib import Path
+
+ENCODERS = {"av1": ["-c:v", "libsvtav1", "-preset", "8"], "h264": ["-c:v", "libx264"]}
+
+
+def _synthetic(directory: Path, codec: str) -> Path:
+    path = directory / f"testsrc2_640x480_gop2_{codec}.mp4"
+    subprocess.run(
+        ["ffmpeg", "-hide_banner", "-loglevel", "error", "-y", "-f", "lavfi", "-i",
+         "testsrc2=size=640x480:rate=30:duration=10", "-pix_fmt", "yuv420p", *ENCODERS[codec], "-g", "2", path],
+        check=True,
+    )  # fmt: skip
+    return path
+
+
+def _per_frame_ms(path: Path, pipelines: list[list], indices: list[int], runs: int) -> list[float]:
+    """Median ms per returned frame for each pipeline; calls alternate between pipelines so drift in machine load
+    affects them alike."""
+    from tensorcodec.decoders import VideoDecoder
+
+    decoders = [VideoDecoder(path, transforms=transforms) for transforms in pipelines]
+    times = [[] for _ in decoders]
+    try:
+        for decoder in decoders:
+            decoder.get_frames_at(indices)  # warm up
+        for _ in range(runs):
+            for decoder, samples in zip(decoders, times):
+                start = time.perf_counter()
+                decoder.get_frames_at(indices)
+                samples.append(time.perf_counter() - start)
+    finally:
+        for decoder in decoders:
+            decoder.close()
+    return [statistics.median(samples) * 1e3 / len(indices) for samples in times]
+
+
+def main() -> None:
+    import tensorcodec
+    from tensorcodec.decoders import VideoDecoder
+    from tensorcodec.transforms import Resize
+
+    parser = argparse.ArgumentParser(description=__doc__.split("\n\n")[0])
+    parser.add_argument("--video", type=Path, nargs="*", help="clips to time (default: synthetic AV1 and H.264)")
+    parser.add_argument("--sizes", type=int, nargs="*", default=[224, 128], help="square Resize outputs")
+    parser.add_argument("--batches", type=int, nargs="*", default=[1, 20], help="frames per call")
+    parser.add_argument("--runs", type=int, default=50)
+    args = parser.parse_args()
+
+    print(f"tensorcodec {tensorcodec.__version__}; ms per returned frame, median of {args.runs} calls")
+    with tempfile.TemporaryDirectory() as directory:
+        videos = args.video or [_synthetic(Path(directory), codec) for codec in ENCODERS]
+        columns = ["native"] + [f"{size}²" for size in args.sizes]
+        print("| clip | frames | " + " | ".join(columns) + " |")
+        print("|---" * (len(columns) + 2) + "|")
+        for path in videos:
+            with VideoDecoder(path) as decoder:
+                count = len(decoder)
+            for batch in args.batches:
+                # One frame from the middle; batches are strided across the clip, so each needs its own seek.
+                # Clips shorter than the batch contribute all their frames.
+                if batch == 1:
+                    indices = [min(count // 2 + 1, count - 1)]
+                else:
+                    indices = list(range(0, count, max(count // batch, 1)))[:batch]
+                pipelines = [[]] + [[Resize((size, size))] for size in args.sizes]
+                cells = _per_frame_ms(path, pipelines, indices, args.runs)
+                print(f"| {Path(path).name} | {len(indices)} | " + " | ".join(f"{cell:.2f}" for cell in cells) + " |")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/docs/compatibility.md b/docs/compatibility.md
index 74000e9..acf6987 100644
--- a/docs/compatibility.md
+++ b/docs/compatibility.md
@@ -19,11 +19,11 @@ FFmpeg; arrays are returned as NumPy instead of torch.Tensor.
 - NCHW/NHWC, paths/URLs, encoded bytes, uint8 arrays and seekable file-like input.
 - Exact and approximate video seeking; exact is the default.
 - Decoder transforms (`tensorcodec.transforms`): `Resize` (bilinear, antialiased), `CenterCrop`
-  and `RandomCrop`, applied in order to RGB frames after display rotation, as TorchCodec does
-  (frames match TorchCodec 0.17.0 within one level). The TorchCodec and TorchVision v2
-  counterparts are accepted and converted; other transforms fail explicitly. `RandomCrop`
-  draws its position once per decoder from NumPy's global random state. Native output
-  takes no transforms.
+  and `RandomCrop`, applied in order after display rotation, as TorchCodec does. Crops match
+  TorchCodec 0.17.0 within one level; resizing is done differently and does not (see
+  [resizing](#resizing)). The TorchCodec and TorchVision v2 counterparts are accepted and
+  converted; other transforms fail explicitly. `RandomCrop` draws its position once per
+  decoder from NumPy's global random state. Native output takes no transforms.
 
 CUDA, torch inputs, HDR tone mapping, arbitrary-angle rotation,
 video/audio encoders and samplers are outside the
@@ -57,7 +57,8 @@ uv run --group oracle pytest --compare
 ```
 
 Comparisons check timing separately from pixels. One uint8 RGB unit or 1/65535
-for float32 RGB is allowed for conversion rounding; frame identities have independent
+for float32 RGB is allowed for conversion rounding (resized frames are compared with a float64
+reference instead; see [resizing](#resizing)); frame identities have independent
 expectations. Tests requiring the oracle must fail on a missing/wrong reference
 when `--compare` is requested. Production installation does not require torch.
 
@@ -90,6 +91,64 @@ indexing and FPS resampling. RGB results retain their existing behavior. Native
 mode preserves encoded pixel coordinates, including inputs with display matrices.
 Playback selection follows the same TorchCodec contract as RGB, including the
 frame overlapping a range's start; it does not copy PyAV's legacy PTS-only range rule.
+
+## Resizing
+
+`Resize` resizes in YUV while converting to RGB: one bilinear swscale pass from the decoded planes
+to RGB at the output size, interpolating chroma at full resolution with swscale's default
+centered siting. TorchCodec 0.17.0 converts to RGB at full size, then resizes the RGB frame. In
+TensorCodec the single pass costs about as much as native-size output (see the
+[benchmarks](../benchmarks/README.md#decoder-transforms)).
+
+In a pipeline:
+
+- Crops before the first resize select its region in the decoded planes. An offset inside a
+  chroma pair (an odd offset for 4:2:0) starts the chroma plane at that pair and shifts the
+  chroma siting to match, so colors stay in place.
+- A display rotation is applied after the first resize, to its RGB output. Right-angle rotations
+  commute with the resampling, so this matches rotating first up to rounding.
+- Transforms after the first resize work on its RGB output. A later resize is the same kind of
+  pass, from that RGB image.
+- A resize to the current size does nothing.
+- After a crop, pixel formats that plane offsets cannot address (paletted, bitstream, hardware,
+  or packed with subsampled chroma) are converted at full size first, and the resize then
+  works from RGB.
+- swscale treats a region of odd width or height as if its subsampled chroma covered the
+  region exactly, which stretches chroma by up to half a pixel at the far edge. Even-sized
+  regions are unaffected. With an odd offset and an even size, the last row or column has no
+  chroma sample of its own beyond the region and reuses its neighbor's.
+
+Outputs therefore differ from TorchCodec's by about 0.9 levels on average. Most of that is
+TorchCodec's darker bias: swscale's fast full-size YUV to RGB conversion comes out 0.6-1.0
+levels darker than exact arithmetic, and resizing afterwards keeps the bias. Native-size
+decoding uses that same conversion in both libraries, so the bias is shared there. The single
+pass has no such bias and is closer to a float64 reference: exact limited-range YUV to RGB with
+bilinear chroma upsampling, then the antialiased bilinear filter of TorchVision v2 and PIL.
+
+Measured on 640x480 4:2:0 clips, 20 frames each. "real" is a 10 s excerpt of the Sintel 480p
+trailer cropped to 640x480; "syn" is FFmpeg `testsrc2`.
+
+| clip | output | vs TorchCodec: max / mean / bias / >1 level / p99.9 | vs float64 reference, mean abs (bias): TorchCodec / TensorCodec |
+| --- | --- | --- | --- |
+| syn AV1 | 224² | 42 / 0.80 / +0.60 / 14.6% / 18 | 1.27 (−0.65) / 1.03 (−0.05) |
+| syn AV1 | 128² | 25 / 0.76 / +0.60 / 15.0% / 12 | 0.84 (−0.65) / 0.60 (−0.04) |
+| syn AV1 | crop 400² → 224² | 59 / 1.07 / +0.72 / 22.3% / 33 | 1.43 (−0.76) / 1.15 (−0.04) |
+| real AV1 | 224² | 17 / 0.90 / +0.87 / 21.8% / 5 | 0.91 (−0.90) / 0.25 (−0.03) |
+| real AV1 | 128² | 11 / 0.89 / +0.87 / 20.8% / 4 | 0.91 (−0.90) / 0.23 (−0.04) |
+| real AV1 | crop 400² → 224² | 18 / 1.08 / +1.04 / 26.5% / 4 | 1.09 (−1.08) / 0.29 (−0.03) |
+| syn H.264 | 224² | 49 / 0.81 / +0.59 / 15.2% / 19 | 1.27 (−0.65) / 1.05 (−0.06) |
+| syn H.264 | 128² | 27 / 0.78 / +0.60 / 15.7% / 12 | 0.83 (−0.64) / 0.61 (−0.04) |
+| syn H.264 | crop 400² → 224² | 58 / 1.08 / +0.72 / 22.6% / 33 | 1.43 (−0.76) / 1.16 (−0.04) |
+| real H.264 | 224² | 26 / 0.90 / +0.86 / 21.9% / 5 | 0.90 (−0.89) / 0.25 (−0.03) |
+| real H.264 | 128² | 16 / 0.89 / +0.86 / 20.9% / 4 | 0.90 (−0.89) / 0.22 (−0.04) |
+| real H.264 | crop 400² → 224² | 27 / 1.08 / +1.04 / 26.6% / 5 | 1.08 (−1.07) / 0.29 (−0.04) |
+
+The largest differences are at sharp, saturated color edges, where TorchCodec's
+nearest-neighbor chroma followed by an RGB resize and direct bilinear chroma interpolation
+disagree. Tests compare resized frames with the float64 reference on natural content: the mean
+error must stay within 0.25 levels of zero and the mean absolute error below 0.75 levels. The
+measured values are |bias| <= 0.16 and 0.19-0.63, and TorchCodec's path would fail the bias bound.
+
 ## Timestamp mode
 
 `seek_mode="timestamp"` is an opt-in TensorCodec extension. Existing `exact` and
diff --git a/docs/releasing.md b/docs/releasing.md
index 4907320..7433d90 100644
--- a/docs/releasing.md
+++ b/docs/releasing.md
@@ -1,6 +1,6 @@
 # Publishing TensorCodec
 
-Release version: `0.4.1`. Each release publishes two PyPI projects at the same version:
+Release version: `0.4.2`. Each release publishes two PyPI projects at the same version:
 `tensorcodec` (pure Python, built by hatchling) and `tensorcodec-av` (the FFmpeg
 extension in `av/`, built by maturin). `tensorcodec` pins `tensorcodec-av==<version>`
 behind a platform marker; bump the version in `pyproject.toml` (twice), `av/Cargo.toml`,
diff --git a/docs/system_ffmpeg.md b/docs/system_ffmpeg.md
index c6e7862..0c6968a 100644
--- a/docs/system_ffmpeg.md
+++ b/docs/system_ffmpeg.md
@@ -37,7 +37,7 @@ test -f "$FFMPEG_DIR/include/libavcodec/avcodec.h"
 test -f "$FFMPEG_DIR/lib/libavcodec.so.61"
 
 uv venv
-uv pip install 'tensorcodec==0.4.1' 'tensorcodec-av==0.4.1' --no-binary tensorcodec-av
+uv pip install 'tensorcodec==0.4.2' 'tensorcodec-av==0.4.2' --no-binary tensorcodec-av
 ```
 
 Only `tensorcodec-av` is built from source; naming it also covers platforms
diff --git a/pyproject.toml b/pyproject.toml
index 585726f..f6c1d96 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,6 +1,6 @@
 [project]
 name = "tensorcodec"
-version = "0.4.1"
+version = "0.4.2"
 description = "Video, audio and image codecs with TorchCodec-style APIs and NumPy arrays"
 readme = "README.md"
 license = "Apache-2.0"
@@ -13,7 +13,7 @@ requires-python = ">=3.10"
 dependencies = [
     "numpy>=1.26",
     "opencv-python-headless>=4.11",
-    "tensorcodec-av==0.4.1; platform_python_implementation == 'CPython' and ((sys_platform == 'linux' and (platform_machine == 'x86_64' or platform_machine == 'aarch64')) or (sys_platform == 'darwin' and platform_machine == 'arm64'))",
+    "tensorcodec-av==0.4.2; platform_python_implementation == 'CPython' and ((sys_platform == 'linux' and (platform_machine == 'x86_64' or platform_machine == 'aarch64')) or (sys_platform == 'darwin' and platform_machine == 'arm64'))",
 ]
 classifiers = [
     "Development Status :: 3 - Alpha",
diff --git a/src/tensorcodec/__init__.py b/src/tensorcodec/__init__.py
index 6fc9328..3e86732 100644
--- a/src/tensorcodec/__init__.py
+++ b/src/tensorcodec/__init__.py
@@ -3,5 +3,5 @@
 from tensorcodec import decoders, transforms
 from tensorcodec._frame import AudioSamples, Frame, FrameBatch
 
-__version__ = "0.4.1"
+__version__ = "0.4.2"
 __all__ = ["AudioSamples", "Frame", "FrameBatch", "decoders", "transforms"]
diff --git a/src/tensorcodec/transforms.py b/src/tensorcodec/transforms.py
index 57e40ef..1d41cdc 100644
--- a/src/tensorcodec/transforms.py
+++ b/src/tensorcodec/transforms.py
@@ -1,8 +1,9 @@
 """Decoder transforms: geometric operations applied to RGB frames inside the decoder.
 
 They mirror TorchCodec 0.17's ``torchcodec.transforms`` (and the complementary TorchVision v2 transforms): a
-sequence of transforms is a pipeline, applied in order after color conversion and display rotation. Resizing is
-bilinear with antialiasing (swscale's bilinear filter widens with the downscale ratio); crops select exact pixels.
+sequence of transforms is a pipeline, applied in order after display rotation. Crops select exact RGB pixels, as
+TorchCodec's do. Resizing is bilinear with antialiasing (swscale's bilinear filter widens with the downscale ratio)
+and, unlike TorchCodec, happens in YUV while converting to RGB; see `Resize`.
 """
 
 from __future__ import annotations
@@ -37,7 +38,14 @@ def _op(self, input_dims):
 
 
 class Resize(DecoderTransform):
-    """Resize to `size` (height, width); bilinear interpolation, antialiased."""
+    """Resize to `size` (height, width); bilinear interpolation, antialiased.
+
+    Frames are resized in YUV while converting to RGB (one swscale pass at the output size), reading any crops before
+    the first resize from the source planes. TorchCodec converts to RGB at full size, then resizes, so outputs differ
+    by about 0.9 levels on average, mostly TorchCodec's darker bias from its full-size conversion; this output is
+    closer to a float64 reference. Differences reach a few levels on natural content and more at sharp, saturated
+    color edges. See docs/compatibility.md.
+    """
 
     def __init__(self, size):
         self.size = _size("Resize", size)
diff --git a/tests/test_transforms.py b/tests/test_transforms.py
index ea8b349..ba6f423 100644
--- a/tests/test_transforms.py
+++ b/tests/test_transforms.py
@@ -1,3 +1,6 @@
+import subprocess
+from pathlib import Path
+
 import numpy as np
 import pytest
 
@@ -22,26 +25,124 @@ def _frames(path, transforms=(), **kwargs):
         return decoder.get_frames_at([4, 0, 4]).data
 
 
-def _ffmpeg_resized(path, height, width, pixel_format="rgb24"):
-    """FFmpeg's own pipeline: RGB conversion, then a bilinear resize in RGB."""
-    import subprocess
+# Resizes are checked against a float64 reference: exact limited-range YUV to RGB with bilinear (centered) chroma
+# upsampling, then the antialiased bilinear filter of TorchVision v2 and PIL. On natural content swscale stays
+# unbiased (|mean error| <= 0.16 levels; TorchCodec's convert-then-resize path is 0.6-1.1 levels darker) with a mean
+# absolute error of 0.19-0.63 levels for even-sized regions, the residual being rounding plus swscale's chroma
+# filter at sharp color edges. The bounds below leave room above those measurements and fail either bias.
+NATURAL = Path(__file__).parent / "resources" / "nasa_13013.mp4"  # stream 0: 320x180 yuv420p, BT.709 limited
+NATURAL_FRAMES = [0, 100, 200, 300]
+MAX_BIAS, MAX_MEAN_ERROR = 0.25, 0.75
+BT709 = (
+    1.5748,
+    0.187324,
+    0.468124,
+    1.8556,
+)  # Kr*, Kgu, Kgv, Kb* for R = Y + Kr*V, G = Y - Kgu U - Kgv V, B = Y + Kb*U
+
+
+def _filter(n_in, n_out, shift=0.0):
+    """(n_out, n_in) antialiased bilinear weights: a triangle widened by the downscale ratio, pixel centers aligned."""
+    scale = n_in / n_out
+    centers = (np.arange(n_out) + 0.5) * scale + shift
+    weights = np.maximum(0, 1 - np.abs(np.arange(n_in) + 0.5 - centers[:, None]) / max(scale, 1.0))
+    return weights / weights.sum(axis=1, keepdims=True)
+
 
+def _planes(path, indices, pixel_format="yuv420p", size=(180, 320)):
+    """Decoded YUV planes of frames `indices` of stream 0, by the FFmpeg CLI."""
     out = subprocess.run(
-        ["ffmpeg", "-v", "error", "-i", str(path), "-threads", "1", "-vf",
-         f"format={pixel_format},scale={width}:{height}:flags=bilinear", "-f", "rawvideo", "-pix_fmt", pixel_format,
-         "-"],
+        ["ffmpeg", "-v", "error", "-i", str(path), "-map", "0:v:0", "-fps_mode", "passthrough", "-f", "rawvideo",
+         "-pix_fmt", pixel_format, "-"],
         capture_output=True, check=True,
     ).stdout  # fmt: skip
-    dtype = np.uint8 if pixel_format == "rgb24" else "<u2"
-    return np.frombuffer(out, dtype=dtype).reshape(-1, height, width, 3)
+    (height, width), (sub_y, sub_x) = size, {"yuv420p": (2, 2), "yuv422p": (1, 2)}[pixel_format]
+    luma, chroma = height * width, (height // sub_y) * (width // sub_x)
+    frames = np.frombuffer(out, np.uint8).reshape(-1, luma + 2 * chroma)[indices].astype(np.float64)
+    shape = (-1, height // sub_y, width // sub_x)
+    return frames[:, :luma].reshape(-1, height, width), frames[:, luma:-chroma].reshape(shape), \
+        frames[:, -chroma:].reshape(shape)  # fmt: skip
+
+
+def _reference_rgb(y, u, v, chroma_shift=0.0):
+    """Float RGB from limited-range BT.709 planes; `chroma_shift` (luma pixels, both axes) mis-sites chroma."""
+    height, width = y.shape[1:]
+
+    def up(plane):
+        shifts = (chroma_shift * plane.shape[1] / height, chroma_shift * plane.shape[2] / width)  # in chroma samples
+        rows, columns = _filter(plane.shape[1], height, shifts[0]), _filter(plane.shape[2], width, shifts[1])
+        return np.einsum("hi,nij,wj->nhw", rows, plane, columns, optimize=True)
+
+    y, u, v = (y - 16) * 255 / 219, (up(u) - 128) * 255 / 224, (up(v) - 128) * 255 / 224
+    kr, kgu, kgv, kb = BT709
+    return np.clip(np.stack([y + kr * v, y - kgu * u - kgv * v, y + kb * u], axis=-1), 0, 255)
+
+
+def _reference_resize(rgb, size, crop=None):
+    if crop:
+        top, left, height, width = crop
+        rgb = rgb[:, top : top + height, left : left + width]
+    rows, columns = _filter(rgb.shape[1], size[0]), _filter(rgb.shape[2], size[1])
+    return np.einsum("hi,nijc,wj->nhwc", rows, rgb, columns, optimize=True)
+
+
+def _assert_near_reference(frames, reference):
+    error = frames.astype(np.float64) - reference
+    assert abs(error.mean()) < MAX_BIAS, error.mean()
+    assert np.abs(error).mean() < MAX_MEAN_ERROR, np.abs(error).mean()
+
+
+class _CropAt(CenterCrop):
+    """A crop at a given (top, left, height, width)."""
 
+    def __init__(self, top, left, height, width):
+        super().__init__((height, width))
+        self.top, self.left = top, left
 
-@pytest.mark.parametrize("size", [(32, 48), (40, 72), (128, 160)])  # down by 2, uneven, up
-def test_resize_is_bilinear_in_rgb(scene, size):
-    frames = _frames(scene, [Resize(size)])
-    assert frames.shape == (3, *size, 3)
-    expected = _ffmpeg_resized(scene, *size)[[4, 0, 4]]
-    np.testing.assert_allclose(frames, expected, atol=1, rtol=0)
+    def _op(self, input_dims):
+        return ("crop", self.top, self.left, *self.size), self.size
+
+
+def _natural(transforms, **kwargs):
+    with VideoDecoder(NATURAL, stream_index=0, dimension_order="NHWC", transforms=transforms, **kwargs) as decoder:
+        return decoder.get_frames_at(NATURAL_FRAMES).data
+
+
+@pytest.mark.parametrize("size", [(64, 64), (120, 200), (90, 160), (360, 640)])  # uneven, by 1.6, by 2, up by 2
+def test_resize_matches_a_float64_reference(size):
+    frames = _natural([Resize(size)])
+    assert frames.shape == (4, *size, 3)
+    _assert_near_reference(frames, _reference_resize(_reference_rgb(*_planes(NATURAL, NATURAL_FRAMES)), size))
+
+
+@pytest.mark.parametrize("crop", [(40, 60, 100, 150), (41, 61, 100, 150)])
+def test_resize_reads_preceding_crops_from_the_source_planes(crop):
+    frames = _natural([_CropAt(*crop), Resize((48, 64))])
+    planes = _planes(NATURAL, NATURAL_FRAMES)
+    reference = _reference_resize(_reference_rgb(*planes), (48, 64), crop)
+    _assert_near_reference(frames, reference)
+    # Odd offsets keep the chroma siting: the output is clearly closer to the reference than to one with chroma half
+    # a pixel off, the error an unadjusted odd offset would make.
+    error = np.abs(frames - reference).mean()
+    for shift in (-0.5, 0.5):
+        missited = _reference_resize(_reference_rgb(*planes, chroma_shift=shift), (48, 64), crop)
+        assert error < np.abs(frames - missited).mean() - 0.15
+
+
+@pytest.mark.parametrize("pixel_format", ["yuv422p", "bgr0", "gray"])  # horizontal-only chroma, packed, one plane
+def test_resize_crops_other_pixel_formats(tmp_path, pixel_format):
+    path = tmp_path / f"{pixel_format}.mkv"
+    run_ffmpeg("-i", NATURAL, "-map", "0:v:0", "-frames:v", 301, "-c:v", "ffv1", "-pix_fmt", pixel_format, path)
+    if pixel_format == "yuv422p":
+        rgb = _reference_rgb(*_planes(path, NATURAL_FRAMES, pixel_format))
+    else:  # no chroma to place: the full-size RGB decode is exact
+        with VideoDecoder(path, dimension_order="NHWC") as decoder:
+            rgb = decoder.get_frames_at(NATURAL_FRAMES).data.astype(np.float64)
+    for crop in [None, (41, 61, 100, 150)]:
+        transforms = ([_CropAt(*crop)] if crop else []) + [Resize((48, 64))]
+        with VideoDecoder(path, dimension_order="NHWC", transforms=transforms) as decoder:
+            frames = decoder.get_frames_at(NATURAL_FRAMES).data
+        _assert_near_reference(frames, _reference_resize(rgb, (48, 64), crop))
 
 
 def test_crops_select_exact_pixels(scene):
@@ -63,6 +164,16 @@ def test_a_pipeline_applies_in_order(scene):
     assert cropped.shape == (3, 16, 24, 3)
     reference = _frames(scene, [CenterCrop((32, 48))])
     assert np.abs(cropped.astype(int) - reference[:, ::2, ::2]).mean() < 12  # the same picture, smaller
+    # Resizes after the first one resize its RGB output.
+    twice = _frames(scene, [Resize((32, 48)), CenterCrop((16, 16)), Resize((8, 8))])
+    assert twice.shape == (3, 8, 8, 3)
+    region = resized[:, 8:24, 16:32]
+    np.testing.assert_allclose(twice.mean(axis=(1, 2)), region.mean(axis=(1, 2)), atol=2)  # same colors, smaller
+    # A resize to the current size changes nothing.
+    np.testing.assert_array_equal(_frames(scene, [Resize((64, 96))]), _frames(scene))
+    np.testing.assert_array_equal(
+        _frames(scene, [CenterCrop((30, 50)), Resize((30, 50))]), _frames(scene)[:, 17:47, 23:73]
+    )
 
 
 @pytest.mark.parametrize("angle", [90, 180, -90])
@@ -78,18 +189,23 @@ def test_transforms_apply_after_display_rotation(scene, tmp_path, angle):
         top, left = np.random.randint(0, 8), np.random.randint(0, 12)
         np.random.seed(1)
         np.testing.assert_array_equal(_frames(path, [crop]), full[:, top : top + height - 7, left : left + width - 11])
-    resized = _frames(path, [Resize((height // 2, width // 3))])
-    assert resized.shape == (3, height // 2, width // 3, 3)
-    expected = _ffmpeg_resized(path, height // 2, width // 3)[[4, 0, 4]]  # FFmpeg rotates (autorotate), then scales
-    np.testing.assert_allclose(resized, expected, atol=1, rtol=0)
-
-
-def test_high_depth_output_resizes_at_depth(scene):
-    frames = _frames(scene, [Resize((32, 48))], output_dtype=np.uint16)
-    assert frames.dtype == np.uint16 and frames.shape == (3, 32, 48, 3)
-    expected = _ffmpeg_resized(scene, 32, 48, "rgb48le")[[4, 0, 4]]
-    np.testing.assert_allclose(frames, expected, atol=1, rtol=0)
-    floats = _frames(scene, [Resize((32, 48))], output_dtype=np.float32)
+    # Resizing happens before the rotation: the result is the unrotated resize, rotated. A crop leaving even margins
+    # reads the same source region either way.
+    turns = {90: 1, 180: 2, -90: 3}[angle]
+    size, crop = (height // 2, width // 3), (height - 24, width - 34)
+    resized = _frames(path, [CenterCrop(crop), Resize(size)])
+    assert resized.shape == (3, *size, 3)
+    swap = (lambda pair: pair[::-1]) if turns % 2 else (lambda pair: pair)
+    unrotated = _frames(scene, [CenterCrop(swap(crop)), Resize(swap(size))])
+    np.testing.assert_array_equal(resized, np.rot90(unrotated, turns, axes=(1, 2)))
+
+
+def test_high_depth_output_resizes_at_depth():
+    frames = _natural([Resize((120, 200))], output_dtype=np.uint16)
+    assert frames.dtype == np.uint16 and frames.shape == (4, 120, 200, 3)
+    reference = _reference_resize(_reference_rgb(*_planes(NATURAL, NATURAL_FRAMES)), (120, 200))
+    _assert_near_reference(frames / 257, reference)
+    floats = _natural([Resize((120, 200))], output_dtype=np.float32)
     np.testing.assert_allclose(floats, frames / np.float32(65535), atol=1e-7, rtol=0)
 
 
@@ -145,14 +261,16 @@ def test_transforms_match_torchcodec(oracle, scene, tmp_path, case):
         path = tmp_path / "rotated.mp4"
         run_ffmpeg("-display_rotation", 90, "-i", scene, "-c", "copy", path)
     for ours, theirs in [
-        ([Resize((32, 48))], [tct.Resize((32, 48))]),
-        ([Resize((40, 70))], [tct.Resize((40, 70))]),
         ([CenterCrop((30, 40))], [tct.CenterCrop((30, 40))]),
         ([CenterCrop((13, 17))], [tct.CenterCrop((13, 17))]),
         ([CenterCrop((29, 49))], [tct.CenterCrop((29, 49))]),
+        # Resizing differs by design (docs/compatibility.md); only the shapes agree.
+        ([Resize((32, 48))], [tct.Resize((32, 48))]),
+        ([Resize((40, 70))], [tct.Resize((40, 70))]),
         ([CenterCrop((40, 40)), Resize((20, 24))], [tct.CenterCrop((40, 40)), tct.Resize((20, 24))]),
     ]:
         actual = VideoDecoder(path, transforms=ours).get_frames_at([4, 0, 4])
         expected = oracle.VideoDecoder(path, transforms=theirs).get_frames_at(index_input(oracle, [4, 0, 4]))
         assert actual.data.shape == tuple(expected.data.shape)
-        np.testing.assert_allclose(actual.data, as_numpy(expected.data), atol=1, rtol=0)
+        if not any(isinstance(t, Resize) for t in ours):
+            np.testing.assert_allclose(actual.data, as_numpy(expected.data), atol=1, rtol=0)