rpdfium_graphics/

cfx_dibitmap.rs

// Derived from PDFium's core/fxge/dib/cfx_dibitmap.h
// Original: Copyright 2014 The PDFium Authors
// Licensed under BSD-3-Clause / Apache-2.0
// See pdfium-upstream/LICENSE for the original license.

//! Bitmap image buffer for rendering output.

/// Pixel format for bitmap data.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum BitmapFormat {
    /// 8-bit grayscale.
    Gray8,
    /// 24-bit RGB (3 bytes per pixel).
    Rgb24,
    /// 32-bit RGBA (4 bytes per pixel, premultiplied alpha).
    Rgba32,
    /// 32-bit BGRA (4 bytes per pixel, premultiplied alpha).
    Bgra32,
}

impl BitmapFormat {
    /// Number of bytes per pixel.
    pub fn bytes_per_pixel(self) -> u32 {
        match self {
            Self::Gray8 => 1,
            Self::Rgb24 => 3,
            Self::Rgba32 | Self::Bgra32 => 4,
        }
    }

    /// Number of color components.
    pub fn components(self) -> u32 {
        match self {
            Self::Gray8 => 1,
            Self::Rgb24 => 3,
            Self::Rgba32 | Self::Bgra32 => 4,
        }
    }

    /// Whether this format has an alpha channel.
    pub fn has_alpha(self) -> bool {
        matches!(self, Self::Rgba32 | Self::Bgra32)
    }
}

/// A bitmap image buffer.
///
/// Stores pixel data in row-major order. Each row is padded to `stride` bytes.
#[derive(Debug, Clone)]
pub struct Bitmap {
    /// Width in pixels.
    pub width: u32,
    /// Height in pixels.
    pub height: u32,
    /// Pixel format.
    pub format: BitmapFormat,
    /// Row stride in bytes (may be larger than `width * bytes_per_pixel`).
    pub stride: u32,
    /// Raw pixel data.
    pub data: Vec<u8>,
}

impl Bitmap {
    /// Create a new bitmap filled with zeros.
    pub fn new(width: u32, height: u32, format: BitmapFormat) -> Self {
        let stride = width * format.bytes_per_pixel();
        let data = vec![0u8; (stride * height) as usize];
        Self {
            width,
            height,
            format,
            stride,
            data,
        }
    }

    /// Upstream-aligned alias for [`new()`](Self::new).
    ///
    /// Creates a new zero-filled bitmap. `alpha = true` selects
    /// [`BitmapFormat::Bgra32`] (4 channels with alpha); `alpha = false`
    /// selects [`BitmapFormat::Rgb24`] (3 channels, no alpha).
    ///
    /// Corresponds to `FPDFBitmap_Create`.
    #[inline]
    pub fn bitmap_create(width: u32, height: u32, alpha: bool) -> Self {
        Self::new(
            width,
            height,
            if alpha {
                BitmapFormat::Bgra32
            } else {
                BitmapFormat::Rgb24
            },
        )
    }

    /// Create a new bitmap filled with white (0xFF for all channels).
    pub fn new_white(width: u32, height: u32, format: BitmapFormat) -> Self {
        let stride = width * format.bytes_per_pixel();
        let data = vec![0xFF; (stride * height) as usize];
        Self {
            width,
            height,
            format,
            stride,
            data,
        }
    }

    /// Returns the bitmap width in pixels.
    ///
    /// Corresponds to `CFX_DIBBase::GetWidth()` in PDFium.
    pub fn width(&self) -> u32 {
        self.width
    }

    /// Upstream-aligned alias for [`width`](Self::width).
    ///
    /// Corresponds to `CFX_DIBBase::GetWidth()` in PDFium.
    #[inline]
    pub fn get_width(&self) -> u32 {
        self.width()
    }

    /// Returns the bitmap height in pixels.
    ///
    /// Corresponds to `CFX_DIBBase::GetHeight()` in PDFium.
    pub fn height(&self) -> u32 {
        self.height
    }

    /// Upstream-aligned alias for [`height`](Self::height).
    ///
    /// Corresponds to `CFX_DIBBase::GetHeight()` in PDFium.
    #[inline]
    pub fn get_height(&self) -> u32 {
        self.height()
    }

    /// Returns the pixel format of this bitmap.
    ///
    /// Corresponds to `CFX_DIBBase::GetFormat()` in PDFium.
    pub fn format(&self) -> BitmapFormat {
        self.format
    }

    /// Upstream-aligned alias for [`format`](Self::format).
    ///
    /// Corresponds to `CFX_DIBBase::GetFormat()` in PDFium.
    #[inline]
    pub fn get_format(&self) -> BitmapFormat {
        self.format()
    }

    /// Returns bits per pixel (8 × bytes_per_pixel).
    ///
    /// Corresponds to `CFX_DIBBase::GetBPP()` in PDFium.
    pub fn bpp(&self) -> u32 {
        self.format.bytes_per_pixel() * 8
    }

    /// Upstream-aligned alias for [`bpp`](Self::bpp).
    ///
    /// Corresponds to `CFX_DIBBase::GetBPP()` in PDFium.
    #[inline]
    pub fn get_bpp(&self) -> u32 {
        self.bpp()
    }

    /// Returns the number of bytes per scanline row.
    ///
    /// Corresponds to `CFX_DIBBase::GetPitch()` / `FPDFBitmap_GetStride` in PDFium.
    pub fn pitch(&self) -> u32 {
        self.stride
    }

    /// ADR-019 alias for [`pitch()`](Self::pitch).
    ///
    /// Corresponds to `CFX_DIBBase::GetPitch()` in PDFium.
    #[inline]
    pub fn get_pitch(&self) -> u32 {
        self.pitch()
    }

    /// Upstream-aligned alias for [`pitch()`](Self::pitch).
    ///
    /// Corresponds to `FPDFBitmap_GetStride`.
    #[inline]
    pub fn bitmap_get_stride(&self) -> u32 {
        self.pitch()
    }

    /// Deprecated — use [`bitmap_get_stride()`](Self::bitmap_get_stride) — matches upstream `FPDFBitmap_GetStride`.
    #[deprecated(note = "use `bitmap_get_stride()` — matches upstream `FPDFBitmap_GetStride`")]
    #[inline]
    pub fn get_stride(&self) -> u32 {
        self.pitch()
    }

    /// Returns the number of bytes per scanline row.
    ///
    /// Corresponds to `FPDFBitmap_GetStride` in PDFium's public C API.
    /// Note: the upstream C++ method is `CFX_DIBBase::GetPitch()`; use
    /// [`pitch()`](Self::pitch) / [`get_pitch()`](Self::get_pitch) for the C++-aligned name.
    #[inline]
    #[deprecated(since = "0.0.0", note = "use pitch() or get_pitch() instead")]
    pub fn stride(&self) -> u32 {
        self.pitch()
    }

    /// Returns `true` if the bitmap format has an alpha channel.
    ///
    /// Corresponds to `CFX_DIBBase::IsAlphaFormat()` in PDFium.
    pub fn is_alpha_format(&self) -> bool {
        self.format.has_alpha()
    }

    /// Returns `true` if the bitmap is a mask format (1-bit or 8-bit alpha mask).
    ///
    /// Corresponds to `CFX_DIBBase::IsMaskFormat()` in PDFium.
    /// In this implementation, Gray8 serves as the mask format (8-bit alpha mask).
    pub fn is_mask_format(&self) -> bool {
        self.format == BitmapFormat::Gray8
    }

    /// Returns `true` if the bitmap is opaque (no alpha channel and not a mask).
    ///
    /// Corresponds to `CFX_DIBBase::IsOpaqueImage()` in PDFium.
    /// An image is opaque if it is neither a mask format nor has an alpha channel.
    pub fn is_opaque_image(&self) -> bool {
        !self.is_mask_format() && !self.is_alpha_format()
    }

    /// Returns `true` if the bitmap uses premultiplied alpha.
    ///
    /// Corresponds to `CFX_DIBBase::IsPremultiplied()` in PDFium.
    /// In PDFium with Skia, `kBgraPremul` format is premultiplied. In this
    /// implementation, `Bgra32` is treated as premultiplied when used as a render target.
    pub fn is_premultiplied(&self) -> bool {
        self.format == BitmapFormat::Bgra32
    }

    /// Bytes per pixel for this bitmap's format.
    pub fn bytes_per_pixel(&self) -> u32 {
        self.format.bytes_per_pixel()
    }

    /// Total data size in bytes.
    pub fn data_size(&self) -> usize {
        (self.stride * self.height) as usize
    }

    /// Get a row of pixel data by scanline index.
    ///
    /// Corresponds to `CFX_DIBBase::GetScanline()` in PDFium.
    ///
    /// # Panics
    ///
    /// Panics if `y >= self.height`.
    pub fn scanline(&self, y: u32) -> &[u8] {
        assert!(
            y < self.height,
            "row index {y} out of bounds (height {})",
            self.height
        );
        let start = (y * self.stride) as usize;
        let end = start + (self.width * self.bytes_per_pixel()) as usize;
        &self.data[start..end]
    }

    /// Upstream-aligned `Get*` alias for [`scanline`](Self::scanline).
    ///
    /// Corresponds to `CFX_DIBBase::GetScanline()` in PDFium.
    ///
    /// # Panics
    ///
    /// Panics if `y >= self.height`.
    #[inline]
    pub fn get_scanline(&self, y: u32) -> &[u8] {
        self.scanline(y)
    }

    /// Rust-idiomatic alias for [`scanline`](Self::scanline).
    ///
    /// # Panics
    ///
    /// Panics if `y >= self.height`.
    #[inline]
    #[deprecated(since = "0.0.0", note = "use scanline() or get_scanline() instead")]
    pub fn row(&self, y: u32) -> &[u8] {
        self.scanline(y)
    }

    /// Convert this bitmap to a different pixel format.
    ///
    /// Currently supports Rgba32 to Gray8 (luminosity formula: 0.299R + 0.587G + 0.114B).
    /// Returns a new Bitmap in the target format, or `None` if the conversion is not supported.
    pub fn convert_format(&self, target: BitmapFormat) -> Option<Self> {
        match (self.format, target) {
            (BitmapFormat::Rgba32, BitmapFormat::Gray8) => {
                let gray_data: Vec<u8> = self
                    .data
                    .chunks_exact(4)
                    .map(|p| {
                        let r = p[0] as f32;
                        let g = p[1] as f32;
                        let b = p[2] as f32;
                        (0.299 * r + 0.587 * g + 0.114 * b).round() as u8
                    })
                    .collect();
                let stride = self.width;
                Some(Bitmap {
                    width: self.width,
                    height: self.height,
                    format: BitmapFormat::Gray8,
                    data: gray_data,
                    stride,
                })
            }
            (a, b) if a == b => Some(self.clone()),
            _ => None,
        }
    }

    /// Get a mutable row of pixel data by scanline index.
    ///
    /// Corresponds to `CFX_DIBitmap::GetWritableScanline()` in PDFium.
    ///
    /// # Panics
    ///
    /// Panics if `y >= self.height`.
    pub fn scanline_mut(&mut self, y: u32) -> &mut [u8] {
        assert!(
            y < self.height,
            "row index {y} out of bounds (height {})",
            self.height
        );
        let start = (y * self.stride) as usize;
        let end = start + (self.width * self.bytes_per_pixel()) as usize;
        &mut self.data[start..end]
    }

    /// Upstream-aligned `Get*` alias for [`scanline_mut`](Self::scanline_mut).
    ///
    /// Corresponds to `CFX_DIBitmap::GetWritableScanline()` in PDFium.
    ///
    /// # Panics
    ///
    /// Panics if `y >= self.height`.
    #[inline]
    pub fn get_writable_scanline(&mut self, y: u32) -> &mut [u8] {
        self.scanline_mut(y)
    }

    /// Deprecated alias for [`scanline_mut`](Self::scanline_mut).
    ///
    /// # Panics
    ///
    /// Panics if `y >= self.height`.
    #[inline]
    #[deprecated(note = "use scanline_mut() or get_writable_scanline() instead")]
    pub fn row_mut(&mut self, y: u32) -> &mut [u8] {
        self.scanline_mut(y)
    }

    /// Fill a rectangle with `color` bytes (must match `bytes_per_pixel()`).
    ///
    /// Clamps the rectangle to bitmap bounds. `color` slice length must equal
    /// `bytes_per_pixel()`. Returns `false` if `color.len() != bytes_per_pixel()`.
    ///
    /// Corresponds to `FPDFBitmap_FillRect` in PDFium's public API.
    pub fn fill_rect(&mut self, x: i32, y: i32, width: i32, height: i32, color: &[u8]) -> bool {
        let bpp = self.bytes_per_pixel() as usize;
        if color.len() != bpp {
            return false;
        }

        let bw = self.width as i32;
        let bh = self.height as i32;

        // Clamp to bounds.
        let x0 = x.max(0) as u32;
        let y0 = y.max(0) as u32;
        let x1 = (x + width).min(bw).max(0) as u32;
        let y1 = (y + height).min(bh).max(0) as u32;

        for row in y0..y1 {
            for col in x0..x1 {
                let offset = (row * self.stride + col * bpp as u32) as usize;
                self.data[offset..offset + bpp].copy_from_slice(color);
            }
        }
        true
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_bitmap_format_bytes_per_pixel() {
        assert_eq!(BitmapFormat::Gray8.bytes_per_pixel(), 1);
        assert_eq!(BitmapFormat::Rgb24.bytes_per_pixel(), 3);
        assert_eq!(BitmapFormat::Rgba32.bytes_per_pixel(), 4);
        assert_eq!(BitmapFormat::Bgra32.bytes_per_pixel(), 4);
    }

    #[test]
    fn test_bitmap_format_has_alpha() {
        assert!(!BitmapFormat::Gray8.has_alpha());
        assert!(!BitmapFormat::Rgb24.has_alpha());
        assert!(BitmapFormat::Rgba32.has_alpha());
        assert!(BitmapFormat::Bgra32.has_alpha());
    }

    #[test]
    fn test_bitmap_new_zeroed() {
        let bmp = Bitmap::new(100, 50, BitmapFormat::Rgba32);
        assert_eq!(bmp.width, 100);
        assert_eq!(bmp.height, 50);
        assert_eq!(bmp.stride, 400);
        assert_eq!(bmp.data.len(), 20000);
        assert!(bmp.data.iter().all(|&b| b == 0));
    }

    #[test]
    fn test_bitmap_new_white() {
        let bmp = Bitmap::new_white(10, 10, BitmapFormat::Rgb24);
        assert_eq!(bmp.data.len(), 300);
        assert!(bmp.data.iter().all(|&b| b == 0xFF));
    }

    #[test]
    fn test_bitmap_row_access() {
        let mut bmp = Bitmap::new(4, 4, BitmapFormat::Gray8);
        bmp.scanline_mut(0)[0] = 42;
        assert_eq!(bmp.scanline(0)[0], 42);
        assert_eq!(bmp.scanline(1)[0], 0); // different row
    }

    #[test]
    fn test_bitmap_data_size() {
        let bmp = Bitmap::new(100, 200, BitmapFormat::Rgba32);
        assert_eq!(bmp.data_size(), 100 * 200 * 4);
    }

    #[test]
    fn test_bitmap_zero_width() {
        let bmp = Bitmap::new(0, 50, BitmapFormat::Rgba32);
        assert_eq!(bmp.width, 0);
        assert_eq!(bmp.height, 50);
        assert!(bmp.data.is_empty());
    }

    #[test]
    fn test_bitmap_zero_height() {
        let bmp = Bitmap::new(100, 0, BitmapFormat::Rgb24);
        assert_eq!(bmp.width, 100);
        assert_eq!(bmp.height, 0);
        assert!(bmp.data.is_empty());
    }

    #[test]
    fn test_bitmap_zero_both() {
        let bmp = Bitmap::new(0, 0, BitmapFormat::Gray8);
        assert_eq!(bmp.width, 0);
        assert_eq!(bmp.height, 0);
        assert!(bmp.data.is_empty());
    }

    #[test]
    fn test_bitmap_stride_method() {
        let bmp = Bitmap::new(100, 50, BitmapFormat::Rgba32);
        assert_eq!(bmp.pitch(), 400);
        assert_eq!(bmp.pitch(), bmp.width * bmp.format.bytes_per_pixel());
    }

    #[test]
    fn test_bitmap_stride_method_rgb24() {
        let bmp = Bitmap::new(37, 10, BitmapFormat::Rgb24);
        assert_eq!(bmp.pitch(), 37 * 3);
    }

    #[test]
    fn test_bitmap_gray8_stride() {
        let bmp = Bitmap::new(37, 10, BitmapFormat::Gray8);
        // Gray8: 1 byte per pixel, so stride == width
        assert_eq!(bmp.stride, 37);
    }

    #[test]
    fn test_bitmap_convert_rgba32_to_gray8() {
        // Pure red pixel: 0.299*255 + 0.587*0 + 0.114*0 = 76.245 → 76
        let mut bmp = Bitmap::new(2, 1, BitmapFormat::Rgba32);
        // pixel 0: red (255, 0, 0, 255)
        bmp.data[0] = 255;
        bmp.data[1] = 0;
        bmp.data[2] = 0;
        bmp.data[3] = 255;
        // pixel 1: white (255, 255, 255, 255)
        bmp.data[4] = 255;
        bmp.data[5] = 255;
        bmp.data[6] = 255;
        bmp.data[7] = 255;

        let gray = bmp.convert_format(BitmapFormat::Gray8).unwrap();
        assert_eq!(gray.format, BitmapFormat::Gray8);
        assert_eq!(gray.width, 2);
        assert_eq!(gray.height, 1);
        assert_eq!(gray.data.len(), 2);
        // Red → luma ≈ 76
        assert_eq!(gray.data[0], 76);
        // White → luma = 255
        assert_eq!(gray.data[1], 255);
    }

    #[test]
    fn test_bitmap_convert_same_format_clones() {
        let bmp = Bitmap::new(10, 10, BitmapFormat::Rgba32);
        let copy = bmp.convert_format(BitmapFormat::Rgba32).unwrap();
        assert_eq!(copy.width, bmp.width);
        assert_eq!(copy.height, bmp.height);
        assert_eq!(copy.format, bmp.format);
        assert_eq!(copy.data, bmp.data);
    }

    #[test]
    fn test_bitmap_convert_unsupported_returns_none() {
        let bmp = Bitmap::new(10, 10, BitmapFormat::Gray8);
        assert!(bmp.convert_format(BitmapFormat::Rgba32).is_none());
        let bmp2 = Bitmap::new(10, 10, BitmapFormat::Rgb24);
        assert!(bmp2.convert_format(BitmapFormat::Gray8).is_none());
    }

    #[test]
    fn test_bitmap_data_size_matches_allocation() {
        let formats = [
            (BitmapFormat::Gray8, 64, 32),
            (BitmapFormat::Rgb24, 50, 25),
            (BitmapFormat::Rgba32, 100, 100),
            (BitmapFormat::Bgra32, 80, 60),
        ];
        for (fmt, w, h) in formats {
            let bmp = Bitmap::new(w, h, fmt);
            assert_eq!(
                bmp.data_size(),
                bmp.data.len(),
                "data_size() mismatch for {fmt:?} {w}x{h}"
            );
        }
    }

    // ------------------------------------------------------------------
    // fill_rect tests  (FPDFBitmap_FillRect)
    // ------------------------------------------------------------------

    #[test]
    fn test_fill_rect_basic() {
        // Fill the entire 2x2 Gray8 bitmap with 0xAB.
        let mut bmp = Bitmap::new(2, 2, BitmapFormat::Gray8);
        let ok = bmp.fill_rect(0, 0, 2, 2, &[0xAB]);
        assert!(ok);
        assert!(bmp.data.iter().all(|&b| b == 0xAB));
    }

    #[test]
    fn test_fill_rect_partial() {
        // 4x4 Gray8 bitmap; fill top-left 2x2 with 0xFF; rest stays 0.
        let mut bmp = Bitmap::new(4, 4, BitmapFormat::Gray8);
        let ok = bmp.fill_rect(0, 0, 2, 2, &[0xFF]);
        assert!(ok);
        // Top-left 2x2 should be 0xFF.
        for row in 0u32..2 {
            for col in 0u32..2 {
                let offset = (row * bmp.stride + col) as usize;
                assert_eq!(bmp.data[offset], 0xFF, "pixel ({col},{row}) should be 0xFF");
            }
        }
        // The rest should be 0.
        for row in 0u32..4 {
            for col in 0u32..4 {
                if row < 2 && col < 2 {
                    continue;
                }
                let offset = (row * bmp.stride + col) as usize;
                assert_eq!(bmp.data[offset], 0, "pixel ({col},{row}) should be 0");
            }
        }
    }

    #[test]
    fn test_fill_rect_clamped() {
        // Rect extends well beyond bitmap bounds — should not panic.
        let mut bmp = Bitmap::new(4, 4, BitmapFormat::Gray8);
        let ok = bmp.fill_rect(-10, -10, 100, 100, &[0x55]);
        assert!(ok);
        // All pixels should be filled because the rect covers the whole bitmap.
        assert!(bmp.data.iter().all(|&b| b == 0x55));
    }

    #[test]
    fn test_fill_rect_wrong_color_len() {
        // Gray8 expects 1-byte color; passing 4 bytes should return false.
        let mut bmp = Bitmap::new(4, 4, BitmapFormat::Gray8);
        let ok = bmp.fill_rect(0, 0, 4, 4, &[0xFF, 0x00, 0x00, 0xFF]);
        assert!(!ok);
        // Bitmap should be untouched (all zeros).
        assert!(bmp.data.iter().all(|&b| b == 0));
    }

    // --- Upstream ports ---

    /// Upstream: TEST(CFXDIBitmapTest, CalculatePitchAndSizeBad)
    ///
    /// rpdfium's Bitmap::new doesn't have CalculatePitchAndSize, but we can
    /// verify that zero/degenerate dimensions produce empty bitmaps and that
    /// pitch calculations are correct for valid cases. This test verifies
    /// the stride (pitch) relationship: stride = width * bpp.
    #[test]
    fn test_bitmap_pitch_bad_dimensions() {
        // Zero width/height produce empty bitmaps with zero data
        let bad_cases: &[(u32, u32)] = &[(0, 0), (0, 200), (100, 0)];
        for &(w, h) in bad_cases {
            let bmp = Bitmap::new(w, h, BitmapFormat::Bgra32);
            assert!(bmp.data.is_empty(), "expected empty data for {w}x{h}");
        }
    }

    /// Upstream: TEST(CFXDIBitmapTest, CalculatePitchAndSizeBoundary)
    ///
    /// Verifies pitch and size calculations at boundary conditions.
    /// rpdfium uses u32 for dimensions, so overflow happens at 2^32.
    #[test]
    fn test_bitmap_pitch_boundary() {
        // 8bpp: stride = width * 1, size = stride * height
        // 536870908 * 4 = 2147483632 (fits in u32)
        let w: u32 = 536_870_908;
        let h: u32 = 4;
        let stride = w.checked_mul(BitmapFormat::Gray8.bytes_per_pixel());
        assert!(stride.is_some());
        let size = stride.unwrap().checked_mul(h);
        assert!(size.is_some());
        assert_eq!(size.unwrap(), 2_147_483_632);

        // 536870909 * 4 overflows u32
        let w_over: u32 = 536_870_909;
        let stride2 = w_over.checked_mul(BitmapFormat::Gray8.bytes_per_pixel());
        assert!(stride2.is_some()); // still fits
        let size2 = stride2.unwrap().checked_mul(h);
        assert!(size2.is_some()); // 536870909 * 4 = 2147483636, fits u32
        // But 68174085 * 63 overflows u32
        let w3: u32 = 68_174_085;
        let h3: u32 = 63;
        let stride3 = w3
            .checked_mul(BitmapFormat::Gray8.bytes_per_pixel())
            .unwrap();
        let size3 = stride3.checked_mul(h3);
        // 68174085 * 63 = 4294967355 > u32::MAX
        assert!(size3.is_none(), "expected overflow for 68174085 * 63");

        // Valid boundary: 68174084 * 63
        let w4: u32 = 68_174_084;
        let stride4 = w4
            .checked_mul(BitmapFormat::Gray8.bytes_per_pixel())
            .unwrap();
        let size4 = stride4.checked_mul(h3);
        assert!(size4.is_some());
        assert_eq!(size4.unwrap(), 4_294_967_292);
    }

    /// Upstream: TEST(CFXDIBitmapTest, GetScanlineAsWith24Bpp)
    ///
    /// Tests scanline access with 24bpp format.
    #[test]
    fn test_bitmap_scanline_24bpp() {
        let bmp = Bitmap::new(3, 3, BitmapFormat::Rgb24);
        assert_eq!(bmp.width(), 3);
        // Pitch: 3 * 3 = 9 bytes per row (no padding in rpdfium)
        assert_eq!(bmp.pitch(), 9);

        // Total data size
        assert_eq!(bmp.data.len(), 9 * 3);

        // Scanline returns exactly width * bpp bytes
        assert_eq!(bmp.scanline(0).len(), 9);
        assert_eq!(bmp.scanline(1).len(), 9);
        assert_eq!(bmp.scanline(2).len(), 9);

        // Typed access: 3 pixels per scanline (3 bytes each)
        // Each RGB pixel is 3 bytes, so 9 / 3 = 3 pixel-sized chunks
        let scanline = bmp.scanline(0);
        let pixel_chunks: Vec<&[u8]> = scanline.chunks_exact(3).collect();
        assert_eq!(pixel_chunks.len(), 3);

        // Mutable scanline access
        let mut bmp_mut = bmp.clone();
        let sl = bmp_mut.scanline_mut(0);
        assert_eq!(sl.len(), 9);
        let pixel_chunks_mut: Vec<&mut [u8]> = sl.chunks_exact_mut(3).collect();
        assert_eq!(pixel_chunks_mut.len(), 3);
    }
}