bwm 0.1.0

Image watermarking over borrowed RGB/RGBA buffers
Documentation
use std::{
    fs,
    path::{Path, PathBuf},
    process::Command,
};

use image::{
    codecs::jpeg::JpegEncoder,
    imageops::{self, FilterType},
    ImageReader, Rgb, RgbImage,
};

const KEY_HEX: &str = "0707070707070707070707070707070707070707070707070707070707070707";
const TEXT: &str = "bwm-ok-2026";

fn repo_path(path: &str) -> PathBuf {
    Path::new(env!("CARGO_MANIFEST_DIR")).join(path)
}

fn bwm() -> PathBuf {
    PathBuf::from(env!("CARGO_BIN_EXE_bwm"))
}

#[test]
fn binary_embeds_edits_and_extracts_fixture_jpeg() {
    let artifacts = repo_path("tests/artifacts");
    fs::create_dir_all(&artifacts).expect("create artifact dir");

    let input = repo_path("tests/fixtures/test.jpg");
    let watermarked = artifacts.join("test-watermarked.jpg");
    let edited = artifacts.join("test-edited.jpg");

    let embed_status = Command::new(bwm())
        .args([
            "embed",
            "--key",
            KEY_HEX,
            "--input",
            input.to_str().expect("utf-8 input path"),
            "--output",
            watermarked.to_str().expect("utf-8 watermarked path"),
            "--text",
            TEXT,
            "--strength",
            "high",
            "--robustness",
            "robust",
            "--quality",
            "100",
        ])
        .status()
        .expect("run embed binary");
    assert!(embed_status.success(), "embed binary failed");

    edit_jpeg_for_robustness(&watermarked, &edited);

    let output = Command::new(bwm())
        .args([
            "extract",
            "--key",
            KEY_HEX,
            "--input",
            edited.to_str().expect("utf-8 edited path"),
            "--strength",
            "high",
            "--robustness",
            "robust",
        ])
        .output()
        .expect("run extract binary");

    assert!(
        output.status.success(),
        "extract binary failed\nstdout:\n{}\nstderr:\n{}",
        String::from_utf8_lossy(&output.stdout),
        String::from_utf8_lossy(&output.stderr)
    );
    assert_eq!(
        String::from_utf8(output.stdout).expect("utf-8 stdout"),
        TEXT
    );
}

fn edit_jpeg_for_robustness(input: &Path, output: &Path) {
    let rgb = ImageReader::open(input)
        .expect("open watermarked jpg")
        .decode()
        .expect("decode watermarked jpg")
        .to_rgb8();

    let (width, height) = rgb.dimensions();
    let crop_w = width * 9 / 10;
    let crop_h = height * 9 / 10;
    let cropped = imageops::crop_imm(&rgb, 0, 0, crop_w, crop_h).to_image();
    let softened = imageops::resize(&cropped, crop_w, crop_h, FilterType::Triangle);
    let mut cropped_canvas = RgbImage::from_pixel(width, height, Rgb([0, 0, 0]));
    imageops::replace(&mut cropped_canvas, &softened, 0, 0);

    let mut edited = imageops::rotate180(&cropped_canvas);
    for (index, pixel) in edited.pixels_mut().enumerate() {
        let x = (index as u32) % width;
        let y = (index as u32) / width;
        let on_diagonal_scar =
            (x as i64 - y as i64).abs() < 36 || (x as i64 + y as i64 - width as i64).abs() < 28;

        if on_diagonal_scar || (x > width * 7 / 10 && y > height * 3 / 5) {
            *pixel = Rgb([12, 12, 12]);
            continue;
        }

        for channel in &mut pixel.0 {
            let contrast = (*channel as f32 - 128.0) * 1.10 + 128.0;
            let noise = match index % 7 {
                0 => -5.0,
                1 => 3.0,
                2 => 4.0,
                3 => -3.0,
                4 => 2.0,
                _ => 0.0,
            };
            *channel = (contrast + 8.0 + noise).round().clamp(0.0, 255.0) as u8;
        }
    }

    let file = fs::File::create(output).expect("create edited jpg");
    let mut encoder = JpegEncoder::new_with_quality(file, 85);
    encoder
        .encode(
            edited.as_raw(),
            edited.width(),
            edited.height(),
            image::ExtendedColorType::Rgb8,
        )
        .expect("encode edited jpg");
}